pax_global_header00006660000000000000000000000064151003450670014513gustar00rootroot0000000000000052 comment=ba5dcfd1c69f3529d0cc9de3028e1a12a36042ba timescaledb-2.23.0/000077500000000000000000000000001510034506700140535ustar00rootroot00000000000000timescaledb-2.23.0/.clang-format000066400000000000000000000106061510034506700164310ustar00rootroot00000000000000--- Language: Cpp # BasedOnStyle: LLVM AccessModifierOffset: -2 AlignAfterOpenBracket: Align AlignConsecutiveAssignments: false AlignConsecutiveDeclarations: false AlignEscapedNewlines: Right AlignOperands: true AlignTrailingComments: true AllowAllParametersOfDeclarationOnNextLine: true AllowShortBlocksOnASingleLine: false AllowShortCaseLabelsOnASingleLine: false AllowShortFunctionsOnASingleLine: All AllowShortIfStatementsOnASingleLine: false AllowShortLoopsOnASingleLine: false # AlwaysBreakAfterDefinitionReturnType: None # option is deprecated AlwaysBreakAfterReturnType: AllDefinitions AlwaysBreakBeforeMultilineStrings: false AlwaysBreakTemplateDeclarations: MultiLine BinPackArguments: false BinPackParameters: true BraceWrapping: AfterCaseLabel: true AfterClass: true AfterControlStatement: true AfterEnum: true AfterFunction: true AfterNamespace: true AfterObjCDeclaration: true AfterStruct: true AfterUnion: true AfterExternBlock: true BeforeCatch: true BeforeElse: true IndentBraces: false SplitEmptyFunction: true SplitEmptyRecord: true SplitEmptyNamespace: true BreakBeforeBinaryOperators: None BreakBeforeBraces: Custom BreakBeforeInheritanceComma: false # N/A C++ BreakInheritanceList: BeforeColon BreakBeforeTernaryOperators: false BreakConstructorInitializersBeforeComma: false BreakConstructorInitializers: BeforeColon BreakAfterJavaFieldAnnotations: false # N/A Java BreakStringLiterals: true ColumnLimit: 100 CommentPragmas: '^ TS Pragma:' #For future proofing CompactNamespaces: false # N/A c++ ConstructorInitializerAllOnOneLineOrOnePerLine: false # N/A C++ ConstructorInitializerIndentWidth: 40 # N/A C++ ContinuationIndentWidth: 4 Cpp11BracedListStyle: false # see catalog.c array struct assigns for an example DerivePointerAlignment: false # always use Right DisableFormat: false # haha # ExperimentalAutoDetectBinPacking: false #the docs say not to have this in config file FixNamespaceComments: true # N/A C++ ForEachMacros: - foreach - forboth - for_each_cell - for_both_cell - forthree IncludeBlocks: Preserve # separate include blocks will not be merged IncludeCategories: # we want to ensure c.h and postgres.h appear first - Regex: '^<(string|unistd)\.h>' Priority: -2 - Regex: '^' Priority: -1 - Regex: '^(<|")compat/compat\.h' Priority: -2 - Regex: '^"compat/compat-msvc-enter\.h' Priority: -1 - Regex: '^"compat/compat-msvc-exit\.h' Priority: 2000000000 - Regex: '.*' Priority: 1 IncludeIsMainRegex: '' # filename_ will be seen as the primary include IndentCaseLabels: true IndentPPDirectives: None # do not indent preprocessor directives after the '#' IndentWidth: 4 IndentWrappedFunctionNames: false # we do not indent the function name in the declaration JavaScriptQuotes: Double # N/A js JavaScriptWrapImports: true # N/A js KeepEmptyLinesAtTheStartOfBlocks: false MacroBlockBegin: '' # regex of macros that behave like '{' MacroBlockEnd: '' # regex of macros that behave like '}' MaxEmptyLinesToKeep: 1 NamespaceIndentation: None # N/A c++ ObjCBinPackProtocolList: Auto # N/A objC ObjCBlockIndentWidth: 2 # N/A objC ObjCSpaceAfterProperty: false # N/A objC ObjCSpaceBeforeProtocolList: true # N/A objC PenaltyBreakAssignment: 2 PenaltyBreakBeforeFirstCallParameter: 10000 PenaltyBreakComment: 300 PenaltyBreakFirstLessLess: 120 PenaltyBreakString: 1000 PenaltyBreakTemplateDeclaration: 10 PenaltyExcessCharacter: 1000000 PenaltyReturnTypeOnItsOwnLine: 60 PointerAlignment: Right # as in char *foo; ReflowComments: true # break up long comments into multiple lines SortIncludes: CaseInsensitive # sort includes SortUsingDeclarations: false # N/A c++ SpaceAfterCStyleCast: true SpaceAfterTemplateKeyword: false # N/A c++ SpaceBeforeAssignmentOperators: true SpaceBeforeCpp11BracedList: false SpaceBeforeCtorInitializerColon: true # N/A c++ SpaceBeforeInheritanceColon: false # N/A c++ SpaceBeforeParens: ControlStatements SpaceBeforeRangeBasedForLoopColon: true # N/A C++ SpaceInEmptyParentheses: false SpacesBeforeTrailingComments: 1 SpacesInAngles: false # N/A c++ SpacesInContainerLiterals: true # N/A c++ SpacesInCStyleCastParentheses: false SpacesInParentheses: false SpacesInSquareBrackets: false Standard: Cpp11 TabWidth: 4 UseTab: Always ... timescaledb-2.23.0/.codecov.yml000066400000000000000000000004601510034506700162760ustar00rootroot00000000000000# If it says that commit YAML is invalid again, # validate it with: # curl --data-binary @.codecov.yml https://codecov.io/validate # More docs: https://docs.codecov.com/docs/codecov-yaml#repository-yaml ignore: - "test/src" coverage: status: project: default: flags: - pr timescaledb-2.23.0/.dir-locals.el000066400000000000000000000015201510034506700165020ustar00rootroot00000000000000;; see also src/tools/editors/emacs.samples in the PostgreSQL source ;; tree for more complete settings ((c-mode . ((c-basic-offset . 4) (c-file-style . "bsd") (fill-column . 78) (indent-tabs-mode . t) (tab-width . 4))) (diff-mode . ((tab-width . 4))) (dsssl-mode . ((indent-tabs-mode . nil))) (nxml-mode . ((indent-tabs-mode . nil))) (perl-mode . ((perl-indent-level . 4) (perl-continued-statement-offset . 4) (perl-continued-brace-offset . 4) (perl-brace-offset . 0) (perl-brace-imaginary-offset . 0) (perl-label-offset . -2) (indent-tabs-mode . t) (tab-width . 4))) (sgml-mode . ((fill-column . 78) (indent-tabs-mode . nil))) (sql-mode . ((sql-product . postgres))) ) timescaledb-2.23.0/.editorconfig000066400000000000000000000003431510034506700165300ustar00rootroot00000000000000root = true [*] charset = utf-8 trim_trailing_whitespace = true insert_final_newline = true end_of_line = lf [*.{c,h}] indent_style = tab indent_size = 4 [*.out] trim_trailing_whitespace = false insert_final_newline = false timescaledb-2.23.0/.git-blame-ignore-revs000066400000000000000000000025201510034506700201520ustar00rootroot00000000000000# This file contains a list of commits that are not likely what you # are looking for in a blame, such as mass reformatting or renaming. # You can set this file as a default ignore file for blame by running # the following command. # # $ git config blame.ignoreRevsFile .git-blame-ignore-revs # formatting with pgindent 32c45b75b27e3f690236a9d1c8d13a025316ad2f # Fix formatting to comply with pgindent 2ec065b53823e50dd1ac1d7cf925ae5f90e293ea # Fix formatting issues 3e42150e3b0402ae865d9a827d8d178568a0d27e # Run clang-format on code 34edba16a9385a4b0353e8e07a19dba98d7e3fb9 # Run pg_format on SQL files 3f5872ec61650519e2c5e6fe1dfb60d07696cac7 # Fix various misspellings 68aec9593c0f37dddbaa4f2e2b34a9ba3f5b11d9 # Switch to clang-format-14 7758f5959c8ed64499ab0e6bb66c30464b11dd81 # Remove trailing whitespaces from test code a4356f342f1732857a1d8057f71219b50f1919b2 # Cosmetic changes to create.c 230f368f4e5d146ce5f919cc5999b236997befaf # Adding python and yaml linters 9133319081aef92705f1405087822fc281d215d4 44cd71a602ba96029001de6e97a1b44488730080 f75a51def79796ff7fef58ec950c859fe4e71618 21a3f8206c0de98932867096637c7d1e3d04d925 # Clang-tidy f862212c8ca19b1af56c7608a68f22b7dd0c985e 05ba1cf22f0dc9232069b566dd23c3edb2cbaee4 ecf34132c69e1709cd393eab43b5fcbfd7c201db e75274ee7c6eef1dafc9b4f4d9f71e8e88f76813 a3ef0384655d57200e83ad7b13c91a31177b97c1 timescaledb-2.23.0/.github/000077500000000000000000000000001510034506700154135ustar00rootroot00000000000000timescaledb-2.23.0/.github/CODE_OF_CONDUCT.md000066400000000000000000000001331510034506700202070ustar00rootroot00000000000000The Timescale Code of Conduct can be found at . timescaledb-2.23.0/.github/ISSUE_TEMPLATE/000077500000000000000000000000001510034506700175765ustar00rootroot00000000000000timescaledb-2.23.0/.github/ISSUE_TEMPLATE/bug_report.yml000066400000000000000000000074541510034506700225030ustar00rootroot00000000000000--- name: Bug report description: Is something not working? Help us fix it! title: "[Bug]: " labels: ["bug", "triage"] body: - type: markdown attributes: value: | Thanks for taking the time to fill out this bug report! - type: dropdown id: type attributes: label: What type of bug is this? multiple: true options: - Configuration - Crash - Data corruption - Incorrect result - Locking issue - Performance issue - Unexpected error - Other validations: required: true - type: dropdown id: subsystem attributes: label: What subsystems and features are affected? description: You can pick multiple subsystems and features. multiple: true options: - Adaptive chunking - Background worker - Backup - Build system - Command processing - Compression - Configuration - Continuous aggregate - Data ingestion - Gapfill - Packaging - Partitioning - Platform/OS - Policy - Query executor - Query planner - Replication - Restore - SkipScan - Telemetry - User-Defined Action (UDA) - Other validations: required: true - type: textarea id: what-happened attributes: label: What happened? description: | Tell us what happened and also what you would have expected to happen instead. placeholder: "Describe the bug" validations: required: true - type: input id: timescaledb-version attributes: label: TimescaleDB version affected description: Let us know what version of TimescaleDB you are running. placeholder: "2.5.0" validations: required: true - type: input id: postgresql-version attributes: label: PostgreSQL version used description: Let us know what version of PostgreSQL you are running. placeholder: "17.4" validations: required: true - type: input id: os attributes: label: What operating system did you use? description: | Please provide OS, version, and architecture. For example: Windows 10 x64, Ubuntu 21.04 x64, Mac OS X 10.5 ARM, Rasperry Pi i386, etc. placeholder: "Ubuntu 21.04 x64" validations: required: true - type: dropdown id: installation attributes: label: What installation method did you use? multiple: true options: - Deb/Apt - Docker - Homebrew - RPM - Source - Other - Not applicable validations: required: true - type: dropdown id: platform attributes: label: What platform did you run on? multiple: true options: - Amazon Web Services (AWS) - Google Cloud Platform (GCP) - Managed Service for TimescaleDB (MST/Aiven) - Microsoft Azure Cloud - On prem/Self-hosted - Timescale Cloud - Other - Not applicable validations: required: true - type: textarea id: logs attributes: label: Relevant log output and stack trace description: | Please copy and paste any relevant log output or a stack trace. This will be automatically formatted into code, so no need for backticks. render: bash - type: textarea id: reproduce attributes: label: How can we reproduce the bug? description: | Please try to provide step-by-step instructions how to reproduce the issue. If possible, provide scripts that we can run to trigger the bug. render: bash validations: required: true ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/ISSUE_TEMPLATE/config.yml������������������������������������������������0000664�0000000�0000000�00000001100�15100345067�0021556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������blank_issues_enabled: true contact_links: - name: Support Request url: https://www.timescale.com/support about: Support request or question relating to TimescaleDB - name: Timescale Community Slack url: https://slack.timescale.com/ about: Get free help from the TimescaleDB community - name: Timescale Community Forum url: https://forum.timescale.com/ about: Get free help from the TimescaleDB community - name: Documentation request url: https://github.com/timescale/docs/issues/new/choose about: Request a change to our documentation ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/ISSUE_TEMPLATE/enhancement.yml�������������������������������������������0000664�0000000�0000000�00000003226�15100345067�0022611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������--- name: Enhancement description: Suggest an enhancement to existing functionality title: "[Enhancement]: <Title>" labels: [ "enhancement" ] body: - type: dropdown id: type attributes: label: What type of enhancement is this? multiple: true options: - API improvement - Configuration - Performance - Refactor - Tech debt reduction - User experience - Other validations: required: true - type: dropdown id: subsystem attributes: label: What subsystems and features will be improved? description: You can pick multiple subsystems and features. multiple: true options: - Adaptive chunking - Background worker - Build system - Command processing - Compression - Configuration - Continuous aggregate - Data ingestion - Gapfill - Packaging - Partitioning - Platform/OS - Policy - Query executor - Query planner - Replication - SkipScan - Telemetry - User-Defined Action (UDA) - Other validations: required: true - type: textarea id: what attributes: label: What does the enhancement do? description: | Give a high-level overview of how you suggest to improve an existing feature or functionality. validations: required: true - type: textarea id: implementation attributes: label: Implementation challenges description: | Share any ideas of how to implement the enhancement. validations: required: false ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/ISSUE_TEMPLATE/feature.yml�����������������������������������������������0000664�0000000�0000000�00000002467�15100345067�0021765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������--- name: Feature request description: Suggest a new feature for TimescaleDB title: "[Feature]: <Feature name>" labels: [ "feature-request" ] body: - type: markdown id: info attributes: value: | Only use this template to suggest a new feature that doesn't already exist in TimescaleDB. For enhancements to existing features, use the "Enhancement" issue template. For bugs, use the bug report template. - type: textarea id: what attributes: label: What problem does the new feature solve? description: | Describe the problem and why it is important to solve. Did you consider alternative solutions, perhaps outside the database? Why is it better to add the feature to TimescaleDB? validations: required: true - type: textarea id: how attributes: label: What does the feature do? description: | Give a high-level overview of what the feature does and how it would work. validations: required: true - type: textarea id: implementation attributes: label: Implementation challenges description: | If you have ideas of how to implement the feature, and any particularly challenging issues to overcome, then provide them here. validations: required: false ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/PULL_REQUEST_TEMPLATE/���������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020672�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md���������������������������0000664�0000000�0000000�00000004127�15100345067�0025637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������- [ ] Add [CHANGELOG](https://github.com/timescale/timescaledb/blob/main/CHANGELOG.md) updates - [ ] Needs [documentation](https://github.com/timescale/docs) updates Fixes #<issue number>. --- Cut everything below the above line. ## Guidelines for Pull requests Checklist for a pull request: - Try to follow [the seven rules of a great Git commit message](https://chris.beams.io/posts/git-commit/). - Ideally, the PR should be merged as a single commit. - Rebase on latest main code. - Reference the issue(s) resolved with Fixes #<issue number>, or Closes #<issue number>. - Make sure the PR has appropriate CHANGELOG updates, including thanks to people that reported issues. - Include appropriate documentation changes. - Two approvals are necessary to merge. ### The seven rules of a great Git commit message 1. Separate subject from body with a blank line 2. Limit the subject line to 50 characters 3. Capitalize the subject line 4. Do not end the subject line with a period 5. Use the imperative mood in the subject line 6. Wrap the body at 72 characters 7. Use the body to explain what and why vs. how ### Single commit PR The simplify reviewing and to protect against accidental merges of work-in-progress commits, the CI system enforces that a PR is merged as a single commit. However, sometimes a multi-commit PR is warranted if each commit is a distinct change that makes sense to submit in the same PR. The single-commit enforcement can be disabled by adding the following trailer to the PR description (note that the trailer should not be in the commit message): Disable-check: commit-count Generally, though, small single-commit PRs are preferred over large multi-commit PRs so that PRs are easier to review. It is also good to avoid multiple commits that have unrelated changes or a lot of work-in-progress changes that are not appropriate for a well-formatted commit log. ### Documentation If the code change adds a new feature, limitation, or change in behavior, the PR might need to include documentation or a separate follow-up PR to the [documentation repository](https://github.com/timescale/docs). �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/ci_settings.py�����������������������������������������������������������0000664�0000000�0000000�00000001456�15100345067�0020306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python # This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # Common settings for our CI jobs # # EARLIEST is the minimum postgres version required when building from source # LATEST is the maximum postgres version that is supported # ABI_MIN is the minimum postgres version required when the extension was build against LATEST # PG15_EARLIEST = "15.10" PG15_LATEST = "15.14" PG15_ABI_MIN = "15.10" PG16_EARLIEST = "16.6" PG16_LATEST = "16.10" PG16_ABI_MIN = "16.6" PG17_EARLIEST = "17.2" PG17_LATEST = "17.6" PG17_ABI_MIN = "17.2" PG18_EARLIEST = "18.0" PG18_LATEST = "18.0" PG18_ABI_MIN = "18.0" PG_LATEST = [PG15_LATEST, PG16_LATEST, PG17_LATEST, PG18_LATEST] ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/codespell-ignore-words���������������������������������������������������0000664�0000000�0000000�00000000045�15100345067�0021724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������brin inh larg inout textin clos isnt �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/gh_config_reader.py������������������������������������������������������0000664�0000000�0000000�00000001411�15100345067�0021227�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python # This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # We hash the .github directory to understand whether our Postgres build cache # can still be used, and the __pycache__ files interfere with that, so don't # create them. import sys sys.dont_write_bytecode = True import ci_settings import json import os # generate commands to set github action variables for key in dir(ci_settings): if not key.startswith("__"): value = getattr(ci_settings, key) with open(os.environ["GITHUB_OUTPUT"], "a", encoding="utf-8") as output: print(str.format("{0}={1}", key, json.dumps(value)), file=output) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/gh_matrix_builder.py�����������������������������������������������������0000775�0000000�0000000�00000031602�15100345067�0021462�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python # This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # Python script to dynamically generate matrix for github action # Since we want to run additional test configurations when triggered # by a push to prerelease_test or by cron but github actions don't # allow a dynamic matrix via yaml configuration, we generate the matrix # with this python script. While we could always have the full matrix # and have if checks on every step that would make the actual checks # harder to browse because the workflow will have lots of entries and # only by navigating into the individual jobs would it be visible # if a job was actually run. # We hash the .github directory to understand whether our Postgres build cache # can still be used, and the __pycache__ files interfere with that, so don't # create them. import sys sys.dont_write_bytecode = True import json import os import random import subprocess from ci_settings import ( PG15_EARLIEST, PG15_LATEST, PG16_EARLIEST, PG16_LATEST, PG17_EARLIEST, PG17_LATEST, PG18_EARLIEST, PG18_LATEST, PG_LATEST, ) # github event type which is either push, pull_request or schedule event_type = sys.argv[1] pull_request = event_type == "pull_request" m = { "include": [], } # Ignored tests that are known to be flaky or have known issues. default_ignored_tests = { "bgw_db_scheduler", "bgw_db_scheduler_fixed", "bgw_job_stat_history", "bgw_launcher", "telemetry", "memoize", "net", } # Some tests are ignored on PG earlier than 17 due to broken MergeAppend cost model there. ignored_before_pg17 = default_ignored_tests | {"merge_append_partially_compressed"} # Some tests are ignored on PG earlier than 16 due to changes in default relation # size estimates. ignored_before_pg16 = default_ignored_tests | {"columnar_scan_cost"} # Tests that we do not run as part of a Flake tests flaky_exclude_tests = { # Not executed as a flake test since it easily exhausts available # background worker slots. "bgw_launcher", # Not executed as a flake test since it takes a very long time and # easily interferes with other tests. "bgw_scheduler_restart", } # helper functions to generate matrix entries # the release and apache config inherit from the # debug config to reduce repetition def build_debug_config(overrides): # llvm version and clang versions must match otherwise # there will be build errors this is true even when compiling # with gcc as clang is used to compile the llvm parts. # # Strictly speaking, WARNINGS_AS_ERRORS=ON is not needed here, but # we add it as a precaution. Intention is to have at least one # release and one debug build with WARNINGS_AS_ERRORS=ON so that we # capture warnings generated due to changes in the code base or the # compiler. base_config = dict( { "build_type": "Debug", "cc": "gcc", "clang": "clang-14", "coverage": True, "cxx": "g++", "extra_packages": "clang-14 llvm-14 llvm-14-dev llvm-14-tools", "ignored_tests": default_ignored_tests, "name": "Debug", "os": "ubuntu-22.04", "pg_extra_args": "--enable-debug --enable-cassert --with-llvm LLVM_CONFIG=llvm-config-14", "pg_extensions": "postgres_fdw test_decoding", "installcheck": True, "pginstallcheck": True, "tsdb_build_args": "-DWARNINGS_AS_ERRORS=ON -DREQUIRE_ALL_TESTS=ON", } ) base_config.update(overrides) return base_config # We build this release configuration with WARNINGS_AS_ERRORS=ON to # make sure that we can build with -Werrors even for release # builds. This will capture some cases where warnings are generated # for release builds but not for debug builds. def build_release_config(overrides): release_config = dict( { "name": "Release", "build_type": "RelWithDebInfo", "tsdb_build_args": "-DWARNINGS_AS_ERRORS=ON -DREQUIRE_ALL_TESTS=ON", "coverage": False, } ) release_config.update(overrides) return build_debug_config(release_config) def build_without_telemetry(overrides): config = dict( { "name": "ReleaseWithoutTelemetry", "coverage": False, } ) config.update(overrides) config = build_release_config(config) config["tsdb_build_args"] += " -DUSE_TELEMETRY=OFF" return config def build_apache_config(overrides): apache_config = dict( { "name": "ApacheOnly", "build_type": "RelWithDebInfo", "tsdb_build_args": "-DWARNINGS_AS_ERRORS=ON -DREQUIRE_ALL_TESTS=ON -DAPACHE_ONLY=1", "coverage": False, } ) apache_config.update(overrides) return build_debug_config(apache_config) def macos_config(overrides): macos_ignored_tests = { "bgw_launcher", "pg_dump", "compression_bgw", "compressed_collation", } base_config = dict( { "cc": "clang", "clang": "clang", "coverage": False, "cxx": "clang++", "extra_packages": "", "ignored_tests": default_ignored_tests.union(macos_ignored_tests), "os": "macos-13", "pg_extra_args": "--enable-debug --with-libraries=/usr/local/opt/openssl@3/lib --with-includes=/usr/local/opt/openssl@3/include --without-icu", "pg_extensions": "postgres_fdw test_decoding", "pginstallcheck": True, "tsdb_build_args": "-DASSERTIONS=ON -DREQUIRE_ALL_TESTS=ON -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl@3", } ) base_config.update(overrides) return base_config # always test debug build on latest of all supported pg versions m["include"].append( build_debug_config({"pg": PG15_LATEST, "ignored_tests": ignored_before_pg16}) ) m["include"].append( build_debug_config({"pg": PG16_LATEST, "ignored_tests": ignored_before_pg17}) ) m["include"].append(build_debug_config({"pg": PG17_LATEST})) m["include"].append(build_debug_config({"pg": PG18_LATEST})) # Also test on ARM. See the available runners here: # https://github.com/timescale/timescaledb/actions/runners m["include"].append( build_debug_config( { "pg": PG18_LATEST, "os": "timescaledb-runner-arm64", # We need to enable ARM crypto extensions to build the vectorized grouping # code. The actual architecture for our ARM CI runner is reported as: # -imultiarch aarch64-linux-gnu - -mlittle-endian -mabi=lp64 -march=armv8.2-a+crypto+fp16+rcpc+dotprod "pg_extra_args": "--enable-debug --enable-cassert --without-llvm CFLAGS=-march=armv8.2-a+crypto", } ) ) # test timescaledb with release config on latest postgres release in MacOS m["include"].append(build_release_config(macos_config({"pg": PG18_LATEST}))) # Test latest postgres release without telemetry. Also run clang-tidy on it # because it's the fastest one. m["include"].append( build_without_telemetry( { "pg": PG18_LATEST, "cc": "clang-14", "cxx": "clang++-14", "tsdb_build_args": "-DLINTER=ON -DWARNINGS_AS_ERRORS=ON", } ) ) # if this is not a pull request e.g. a scheduled run or a push # to a specific branch like prerelease_test we add additional # entries to the matrix if not pull_request: # add debug test for first supported PG15 version m["include"].append( build_debug_config({"pg": PG15_EARLIEST, "ignored_tests": ignored_before_pg16}) ) # add debug test for first supported PG16 version m["include"].append( build_debug_config({"pg": PG16_EARLIEST, "ignored_tests": ignored_before_pg17}) ) # add debug test for first supported PG17 version if PG17_EARLIEST != PG17_LATEST: m["include"].append(build_debug_config({"pg": PG17_EARLIEST})) # add debug test for first supported PG18 version if PG18_EARLIEST != PG18_LATEST: m["include"].append(build_debug_config({"pg": PG18_EARLIEST})) # add debug tests for timescaledb on latest postgres release in MacOS m["include"].append( build_debug_config( macos_config({"pg": PG15_LATEST, "ignored_tests": ignored_before_pg16}) ) ) m["include"].append( build_debug_config( macos_config({"pg": PG16_LATEST, "ignored_tests": ignored_before_pg17}) ) ) m["include"].append(build_debug_config(macos_config({"pg": PG17_LATEST}))) m["include"].append(build_debug_config(macos_config({"pg": PG18_LATEST}))) # add release test for latest pg releases m["include"].append( build_release_config({"pg": PG15_LATEST, "ignored_tests": ignored_before_pg16}) ) m["include"].append( build_release_config({"pg": PG16_LATEST, "ignored_tests": ignored_before_pg17}) ) m["include"].append(build_release_config({"pg": PG17_LATEST})) m["include"].append(build_release_config({"pg": PG18_LATEST})) # add apache only test for latest pg versions for PG_LATEST_VER in PG_LATEST: m["include"].append(build_apache_config({"pg": PG_LATEST_VER})) # to discover issues with upcoming releases we run CI against # the stable branches of supported PG releases m["include"].append( build_debug_config( { "pg": 15, "ignored_tests": ignored_before_pg16 | { "bgw_custom", "bgw_scheduler_restart", "bgw_job_stat_history_errors_permissions", "bgw_job_stat_history_errors", "bgw_job_stat_history", "bgw_db_scheduler_fixed", "bgw_reorder_drop_chunks", "scheduler_fixed", "compress_bgw_reorder_drop_chunks", }, "snapshot": "snapshot", } ) ) m["include"].append( build_debug_config( { "pg": 16, "ignored_tests": ignored_before_pg17, "snapshot": "snapshot", } ) ) m["include"].append( build_debug_config( { "pg": 17, "snapshot": "snapshot", } ) ) m["include"].append( build_debug_config( { "pg": 18, "snapshot": "snapshot", } ) ) elif len(sys.argv) > 2: # Check if we need to check for the flaky tests. Determine which test files # have been changed in the PR. The sql files might include other files that # change independently, and might be .in templates, so it's easier to look # at the output files. They are also the same for the isolation tests. p = subprocess.Popen( f"git diff --name-only {sys.argv[2]} -- '**expected/*.out'", stdout=subprocess.PIPE, shell=True, ) (output, err) = p.communicate() p_status = p.wait() if p_status != 0: print( f'git diff failed: code {p_status}, output "{output}", stderr "{err}"', file=sys.stderr, ) sys.exit(1) tests = set() test_count = 1 for f in output.decode().split("\n"): print(f) if not f: continue test_count += 1 if test_count > 10: print( f"too many ({test_count}) changed tests, won't run the flaky check", file=sys.stderr, ) print("full list:", file=sys.stderr) print(output, file=sys.stderr) tests = set() break basename = os.path.basename(f) split = basename.split(".") name = split[0] ext = split[-1] if ext == "out": # Account for the version number. tests.add(name) else: # Should've been filtered out above. print( f"unknown extension '{ext}' for test output file '{f}'", file=sys.stderr ) sys.exit(1) if tests: to_run = [t for t in list(tests) if t not in flaky_exclude_tests] * 20 random.shuffle(to_run) installcheck_args = f'TESTS="{" ".join(to_run)}"' m["include"].append( build_debug_config( { "coverage": False, "installcheck_args": installcheck_args, "name": "Flaky Check Debug", "pg": PG18_LATEST, "pginstallcheck": False, } ) ) # generate command to set github action variable with open(os.environ["GITHUB_OUTPUT"], "a", encoding="utf-8") as output: print(str.format("matrix={0}", json.dumps(m, default=list)), file=output) ������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/���������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017450�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/abi.yaml�������������������������������������������������������0000664�0000000�0000000�00000012615�15100345067�0021074�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test minimum and maximum ABI compatible postgres version # # Build timescaledb against specific postgres version and then run our # tests with that library loaded in a different postgres version. # This is to detect changes in required minimum/maximum postgres versions # for our built packages. # This test is expected to fail when upstream does ABI incompatible changes # in a new minor postgresql version. name: ABI Test "on": schedule: # run daily 20:00 on main branch - cron: '0 20 * * *' push: branches: - prerelease_test - trigger/abi pull_request: paths: .github/workflows/abi.yaml workflow_dispatch: jobs: config: runs-on: ubuntu-latest outputs: pg15_abi_min: ${{ steps.config.outputs.pg15_abi_min }} pg16_abi_min: ${{ steps.config.outputs.pg16_abi_min }} pg17_abi_min: ${{ steps.config.outputs.pg17_abi_min }} pg18_abi_min: ${{ steps.config.outputs.pg18_abi_min }} pg15_latest: ${{ steps.config.outputs.pg15_latest }} pg16_latest: ${{ steps.config.outputs.pg16_latest }} pg17_latest: ${{ steps.config.outputs.pg17_latest }} pg18_latest: ${{ steps.config.outputs.pg18_latest }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Read configuration id: config run: python .github/gh_config_reader.py abi_test: name: ABI Test ${{ matrix.dir }} PG${{ matrix.pg }} runs-on: ubuntu-latest needs: config strategy: fail-fast: false matrix: pg: [ 15, 16, 17, 18 ] ignores: - 'net telemetry' include: - pg: 15 builder: ${{ fromJson(needs.config.outputs.pg15_abi_min) }} tester: ${{ fromJson(needs.config.outputs.pg15_latest) }} - pg: 16 builder: ${{ fromJson(needs.config.outputs.pg16_abi_min) }} tester: ${{ fromJson(needs.config.outputs.pg16_latest) }} - pg: 17 builder: ${{ fromJson(needs.config.outputs.pg17_abi_min) }} tester: ${{ fromJson(needs.config.outputs.pg17_latest) }} - pg: 18 builder: ${{ fromJson(needs.config.outputs.pg18_abi_min) }} tester: ${{ fromJson(needs.config.outputs.pg18_latest) }} steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Build extension with ${{ matrix.builder }} run: | BUILDER_IMAGE="postgres:${{matrix.builder}}-alpine" docker pull ${BUILDER_IMAGE} docker buildx imagetools inspect ${BUILDER_IMAGE} docker run -i --rm -v $(pwd):/mnt -e EXTRA_PKGS="${EXTRA_PKGS}" ${BUILDER_IMAGE} bash <<"EOF" apk add cmake gcc make build-base krb5-dev git ${EXTRA_PKGS} # We run the same extension on different docker images, old versions # have OpenSSL 1.1 and the new versions have OpenSSL 3, so we try to # pin the 1.1. Note that depending on PG version, both images might # have 1.1 or 3, so we first try to install the versioned 1.1 package, # and if it's not present, it means the unversioned package is 1.1, so # we install it. apk add openssl1.1-compat-dev || apk add openssl-dev git config --global --add safe.directory /mnt cd /mnt BUILD_DIR=build_abi BUILD_FORCE_REMOVE=true ./bootstrap make -C build_abi install mkdir -p build_abi/install_ext build_abi/install_lib cp `pg_config --sharedir`/extension/timescaledb*.{control,sql} build_abi/install_ext cp `pg_config --pkglibdir`/timescaledb*.so build_abi/install_lib EOF - name: Run tests on server ${{ matrix.tester }} run: | TEST_IMAGE="postgres:${{ matrix.tester }}-alpine" docker pull ${TEST_IMAGE} docker buildx imagetools inspect ${TEST_IMAGE} docker run -i --rm -v $(pwd):/mnt -e EXTRA_PKGS="${EXTRA_PKGS}" ${TEST_IMAGE} bash <<"EOF" apk add cmake gcc make build-base krb5-dev sudo coreutils ${EXTRA_PKGS} apk add openssl1.1-compat-dev || apk add openssl-dev cd /mnt cp build_abi/install_ext/* `pg_config --sharedir`/extension/ cp build_abi/install_lib/* `pg_config --pkglibdir` chown -R postgres /mnt set -o pipefail [ -f /usr/bin/gmake ] || ln -s /usr/bin/make /usr/bin/gmake sudo -u postgres make -C build_abi -k regresscheck regresscheck-t \ regresscheck-shared IGNORES="${{ matrix.ignores }}" | tee installcheck.log EOF - name: Show regression diffs if: always() id: collectlogs run: | sudo chmod a+rw . sudo find build_abi -name regression.diffs -exec cat {} + > regression.log sudo find build_abi -name postmaster.log -exec cat {} + > postmaster.log if [[ -s regression.log ]]; then echo "regression_diff=true" >>$GITHUB_OUTPUT; fi grep -e 'FAILED' -e 'failed (ignored)' -e 'not ok' installcheck.log || true cat regression.log - name: Save regression diffs if: always() && steps.collectlogs.outputs.regression_diff == 'true' uses: actions/upload-artifact@v4 with: name: Regression diff ABI Breakage ${{ matrix.dir }} PG${{ matrix.pg }} path: regression.log - name: Save postmaster.log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL log ABI Breakage ${{ matrix.dir }} PG${{ matrix.pg }} path: postmaster.log �������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/apt-arm-packages.yaml������������������������������������������0000664�0000000�0000000�00000010123�15100345067�0023446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test installing our ubuntu and debian ARM64 packages for the latest version. name: "Packaging tests: APT ARM64" "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' pull_request: paths: .github/workflows/apt-arm-packages.yaml push: tags: - '*' branches: - release_test - trigger/package_test workflow_dispatch: jobs: apt_tests: name: APT ARM64 ${{ matrix.image }} PG${{ matrix.pg }} runs-on: ubuntu-22.04 strategy: fail-fast: false matrix: image: [ "debian:11-slim", "debian:12-slim", "debian:13-slim", "ubuntu:22.04", "ubuntu:24.04" ] pg: [ 15, 16, 17 ] steps: - name: Setup emulation run: | sudo apt-get update sudo apt-get install qemu binfmt-support qemu-user-static docker run --rm --privileged multiarch/qemu-user-static --reset -p yes docker run -d --platform=linux/arm64 --name arm_container arm64v8/${{ matrix.image }} sleep 3600 - name: Add repositories run: | cat <<"EOF" | docker exec -i arm_container bash apt-get update apt-get install -y --no-install-recommends ca-certificates curl \ lsb-release gnupg apt-transport-https sudo postgresql-common yes | /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh curl -s https://packagecloud.io/install/repositories/timescale/timescaledb/script.deb.sh | bash EOF - name: Install timescaledb run: | cat <<"EOF" | docker exec -i arm_container bash DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ timescaledb-2-postgresql-${{ matrix.pg }} timescaledb-tools timescaledb-tune --quiet --yes EOF - name: List available versions run: | cat <<"EOF" | docker exec -i arm_container bash apt-cache show timescaledb-2-postgresql-${{ matrix.pg }} \ | grep -e Version: -e Depends: \ | tr '\n' ' ' \ | sed -e 's! Version: !\n!g' -e 's!Version: !!' -e 's!$!\n!' EOF - name: Show files in package run: | cat <<"EOF" | docker exec -i arm_container bash dpkg -L timescaledb-2-postgresql-${{ matrix.pg }} EOF - uses: actions/checkout@v4 - name: Read versions id: versions run: | # read expected version from version.config # version will only be a proper version in a release branch so we use previous_version # as fallback for main if grep '^version = [0-9.]\+$' version.config; then version=$(grep '^version = ' version.config | sed -e 's!^version = !!') else version=$(grep '^previous_version = ' version.config | sed -e 's!^previous_version = !!') fi echo "version=${version}" >>$GITHUB_OUTPUT - name: Test Installation run: | cat <<"EOF" | docker exec -i arm_container bash set -e pg_ctlcluster ${{ matrix.pg }} main start sudo -u postgres psql -X -c "CREATE EXTENSION timescaledb" \ -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb'" installed_version=$(sudo -u postgres psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" \ | sed -e 's! !!g') if [ "${{ steps.versions.outputs.version }}" != "$installed_version" ];then false fi EOF - name: Install toolkit run: | cat <<"EOF" | docker exec -i arm_container bash DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \ timescaledb-toolkit-postgresql-${{ matrix.pg }} EOF - name: List available toolkit versions run: | cat <<"EOF" | docker exec -i arm_container bash apt-cache show timescaledb-toolkit-postgresql-${{ matrix.pg }} \ | grep -e Version: -e Depends: \ | tr '\n' ' ' \ | sed -e 's! Version: !\n!g' -e 's!Version: !!' -e 's!$!\n!' EOF - name: Kill container run: | docker kill arm_container ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/apt-packages.yaml����������������������������������������������0000664�0000000�0000000�00000011470�15100345067�0022677�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test installing our ubuntu and debian packages for the latest version. name: "Packaging tests: APT" "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' pull_request: paths: .github/workflows/apt-packages.yaml push: tags: - '*' branches: - release_test - trigger/package_test workflow_dispatch: jobs: apt_tests: name: APT ${{ matrix.image }} PG${{ matrix.pg }} ${{ matrix.license }} runs-on: ubuntu-latest container: image: ${{ matrix.image }} env: DEBIAN_FRONTEND: noninteractive strategy: fail-fast: false matrix: image: [ "debian:11-slim", "debian:12-slim", "debian:13-slim", "ubuntu:22.04", "ubuntu:24.04" ] pg: [ 15, 16, 17 ] license: [ "TSL", "Apache"] include: - license: Apache pkg_suffix: "-oss" steps: - name: Add repositories run: | apt-get update apt-get install -y wget lsb-release gnupg apt-transport-https sudo postgresql-common yes | /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh image_type=$(lsb_release -i -s | tr '[:upper:]' '[:lower:]') echo "deb https://packagecloud.io/timescale/timescaledb/${image_type}/ $(lsb_release -c -s) main" \ > /etc/apt/sources.list.d/timescaledb.list if [ "${image_type}" = "ubuntu" ]; then wget --quiet -O - https://packagecloud.io/timescale/timescaledb/gpgkey | apt-key add - else wget --quiet -O - https://packagecloud.io/timescale/timescaledb/gpgkey | gpg --dearmor -o /etc/apt/trusted.gpg.d/timescale_timescaledb.gpg fi - name: Install timescaledb run: | apt-get update apt-get install -y --no-install-recommends \ timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }} timescaledb-tools timescaledb-tune --quiet --yes - name: List available versions run: | apt-cache show timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }} \ | grep -e Version: -e Depends: | tr '\n' ' ' | sed -e 's! Version: !\n!g' -e 's!Version: !!' -e 's!$!\n!' - name: Show files in package run: | dpkg -L timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }} - uses: actions/checkout@v4 - name: Read versions id: versions run: | # read expected version from version.config # version will only be a proper version in a release branch so we use previous_version # as fallback for main if grep '^version = [0-9.]\+$' version.config; then version=$(grep '^version = ' version.config | sed -e 's!^version = !!') else version=$(grep '^previous_version = ' version.config | sed -e 's!^previous_version = !!') fi echo "version=${version}" >>$GITHUB_OUTPUT - name: Test Installation run: | pg_ctlcluster ${{ matrix.pg }} main start sudo -u postgres psql -X -c "CREATE EXTENSION timescaledb" \ -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb'" installed_version=$(sudo -u postgres psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" | sed -e 's! !!g') if [ "${{ steps.versions.outputs.version }}" != "$installed_version" ];then false fi - name: Test Downgrade if: matrix.image != 'debian:13-slim' # debian 13 only has timescaledb 2.22.0+ so we can only start testing downgrades with 2.22.1+ run: | # Since this runs nightly on main we have to get the previous version # from the last released version and not current branch. prev_version=$(wget --quiet -O - \ https://raw.githubusercontent.com/timescale/timescaledb/${{ steps.versions.outputs.version }}/version.config \ | grep previous_version | sed -e 's!previous_version = !!') sudo -u postgres psql -X -c "ALTER EXTENSION timescaledb UPDATE TO '${prev_version}'" \ -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb'" installed_version=$(sudo -u postgres psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" | sed -e 's! !!g') if [ "$prev_version" != "$installed_version" ];then false fi - name: Install toolkit run: | apt-get install -y --no-install-recommends \ timescaledb-toolkit-postgresql-${{ matrix.pg }} - name: List available toolkit versions run: | apt-cache show timescaledb-toolkit-postgresql-${{ matrix.pg }} | grep -e Version: -e Depends: | tr '\n' ' ' | sed -e 's! Version: !\n!g' -e 's!Version: !!' -e 's!$!\n!' - name: PostgreSQL log if: always() run: | cat /var/log/postgresql/postgresql-${{ matrix.pg }}-main.log ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/backport-trigger.yaml������������������������������������������0000664�0000000�0000000�00000001161�15100345067�0023601�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# A helper workflow to trigger the run of the backport workflow on the main # branch, when a release branch or the main branch were changed. name: Trigger the Backport Workflow "on": push: branches: - main - ?.*.x pull_request: paths: .github/workflows/backport-trigger.yaml jobs: backport_trigger: runs-on: timescaledb-runner-arm64 steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Trigger the Backport Workflow env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | gh workflow run backport.yaml --ref main ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/backport.yaml��������������������������������������������������0000664�0000000�0000000�00000002573�15100345067�0022150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Backport Bug Fixes on: schedule: # Run weekdays 12:00 on main branch, so that it doesn't wreak havoc on # weekends. Good to have regular runs so that we can react to changes in # issue tags, or retry some spurious network errors, or whatever. - cron: '0 12 * * 1-5' workflow_dispatch: push: # This is also triggered from backport-trigger.yaml when the release branches # are updated. branches: # You can run and debug new versions of the backport script by pushing it # to this branch. workflow_dispatch can only be run through github cli for # branches that are not main, so it's inconvenient. - trigger/backport # The workflow needs the permission to push branches permissions: contents: write pull-requests: write issues: write actions: write statuses: write jobs: backport: name: Backport Bug Fixes runs-on: timescaledb-runner-arm64 steps: - name: Install Python Dependencies run: | pip install PyGithub requests - name: Checkout TimescaleDB uses: actions/checkout@v4 with: token: ${{ secrets.ORG_AUTOMATION_TOKEN }} - name: Run the Backport Script env: ORG_AUTOMATION_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | git remote --verbose scripts/backport.py 2>&1 git remote --verbose �������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/catalog-updates-check.yaml�������������������������������������0000664�0000000�0000000�00000002277�15100345067�0024474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Check for unsafe catalog updates "on": pull_request: push: branches: - main - ?.*.x jobs: check_catalog_correctly_updated: name: Check updates to latest-dev and reverse-dev are properly handled by PR runs-on: timescaledb-runner-arm64 steps: - name: Checkout source uses: actions/checkout@v4 with: fetch-depth: 0 - name: Install pglast run: | python -m pip install pglast - name: Check sql file contents run: | find sql -name '*.sql' -not -path 'sql/updates/*' -not -path 'sql/compat.sql' | xargs -IFILE python scripts/check_updates.py FILE - name: Check latest-dev contents run: | python scripts/check_updates.py --latest "sql/updates/latest-dev.sql" - name: Check for idempotency in SQL scripts if: always() run: | python scripts/check_sql_script.py sql/*.sql # To allow fixing previous mistakes we run the check against reverse-dev but don't # fail it on errors. - name: Check reverse-dev contents if: always() run: | python scripts/check_updates.py "sql/updates/reverse-dev.sql" || true ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/changelog-check.yaml�������������������������������������������0000664�0000000�0000000�00000006766�15100345067�0023355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Check for changelog entry file "on": pull_request: types: [opened, synchronize, reopened, edited] branches: - main jobs: # Check if the PR creates a separate file with changelog entry in the # ".unreleased" folder # # This check can be disabled by adding the following line in the PR text # # Disable-check: force-changelog-file # # The file having the changelog entry is expected to have lines in the # following format # # Fixes: #NNNN <bug description> (mandatory in case of bugfixes) # Thanks: @name <thank you note> (optional) # Implements: #NNNN <feature description> (mandatory in case of new features) check_changelog_file: name: Check for file with CHANGELOG entry runs-on: timescaledb-runner-arm64 steps: - name: Setup Python uses: actions/setup-python@v5 with: python-version: '3.13' - name: Install Python Dependencies run: | pip install PyGithub - name: Checkout source uses: actions/checkout@v4 with: ref: ${{ github.event.pull_request.head.sha }} fetch-depth: 0 - name: Check if the pull request adds file in ".unreleased" folder shell: bash --norc --noprofile {0} env: BODY: ${{ github.event.pull_request.body }} GH_TOKEN: ${{ github.token }} PR_NUMBER: ${{ github.event.pull_request.number }} run: | set -euo pipefail folder=".unreleased" # Get the list of modified files as a bash array. Exclude the # development-related files because they don't require a changelog. mapfile -t modified_files < <(gh pr view $PR_NUMBER --json files --jq ' [.files.[].path | select( (startswith(".github") or startswith("test") or startswith("tsl/test") or startswith("scripts")) | not)] | .[]') echo "Modified files: ${modified_files[@]}" # Get the changelog files as a bash array mapfile -t changelog_files < <(gh pr view $PR_NUMBER --json files --jq " [.files.[].path | select(startswith(\"${folder}\"))] | .[]") echo "Changelog files: ${changelog_files[@]}" if echo "$BODY" | egrep -qsi "Disable-check:[[:space:]]*force-changelog-file" then # skip changelog checks if forced : elif (( ${#modified_files[@]} > 0 && ${#changelog_files[@]} == 0 )) then # if no changelog files found, and the PR does not have the force disable check option echo "PR does not add a change log file in .unreleased/ folder" echo "Check .unreleased/template.rfc822 for the format of the change log file." echo echo "To disable changelog updated check, add this trailer to pull request message:" echo echo "Disable-check: force-changelog-file" echo echo "Trailers follow RFC2822 conventions, so no whitespace" echo "before field name and the check is case-insensitive for" echo "both the field name and the field body." exit 1 else # check the format of the files in .unreleased folder for file in "${changelog_files[@]}" do if ! scripts/check_changelog_format.py "${file}" then echo "Invalid CHANGELOG entries in ${file}." exit 1 fi done fi ����������timescaledb-2.23.0/.github/workflows/coccinelle.yaml������������������������������������������������0000664�0000000�0000000�00000001347�15100345067�0022441�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Check our codebase for defective programming patterns name: Coccinelle "on": pull_request: push: branches: - main - ?.*.x jobs: coccinelle: name: Coccinelle # coccinelle version in ubuntu-latest (20.04) is too old so we run # this in jammy (22.04) runs-on: ubuntu-22.04 steps: - name: Install Dependencies run: | sudo apt-get update sudo apt-get -y install coccinelle - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Run coccinelle run: | ./scripts/coccinelle.sh - name: Save coccinelle.diff if: always() uses: actions/upload-artifact@v4 with: name: coccinelle.diff path: coccinelle.diff �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/code_style.yaml������������������������������������������������0000664�0000000�0000000�00000011375�15100345067�0022475�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Code style "on": push: branches: - main - ?.*.x pull_request: jobs: cmake_checks: name: Check CMake files runs-on: ubuntu-22.04 steps: - name: Install prerequisites run: pip install cmakelang - name: Checkout source uses: actions/checkout@v4 - name: Run format on CMake files run: | git reset --hard find -name CMakeLists.txt -exec cmake-format -i {} + find src test tsl -name '*.cmake' -exec cmake-format -i {} + git diff --exit-code perl_checks: name: Check Perl code in tree runs-on: ubuntu-22.04 steps: - name: Install prerequisites run: sudo apt install perltidy - name: Checkout source uses: actions/checkout@v4 - name: Check trailing whitespace if: always() run: | find . -name '*.p[lm]' -exec perl -pi -e 's/[ \t]+$//' {} + git diff --exit-code - name: Format Perl files, if needed if: always() run: | git reset --hard find . -name '*.p[lm]' -exec perltidy -b -bext=/ {} + git diff --exit-code yaml_checks: name: Check YAML code in tree runs-on: ubuntu-latest steps: - name: Install prerequisites run: | pip install yamllint - name: Checkout source uses: actions/checkout@v4 - name: Run yamllint run: | find . -type f \( -name "*.yaml" -or -name "*.yml" \) -print -exec yamllint {} \+ spelling_checks: name: Check spelling runs-on: ubuntu-latest steps: - name: Install prerequisites run: | pip install codespell - name: Checkout source uses: actions/checkout@v4 - name: Run codespell run: | find . -type f \( -name "*.c" -or -name "*.h" -or -name "*.yaml" -or -name "*.yml" -or -name "*.sh" -or -name "*.cmake" -or -name "*.py" -or -name "*.pl" -or -name "CMakeLists.txt" \) \ -exec codespell -I .github/codespell-ignore-words {} \+ cc_checks: name: Check code formatting runs-on: ubuntu-22.04 strategy: fail-fast: false steps: - name: Checkout source uses: actions/checkout@v4 - name: Check trailing whitespace if: always() run: | git reset --hard find . -type f -regex '.*\.\(c\|h\|sql\|sql\.in\)$' -exec perl -pi -e 's/[ \t]+$//' {} + git diff --exit-code - name: Check code formatting if: always() run: | sudo apt install clang-format-14 sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-14 100 sudo update-alternatives --set clang-format /usr/bin/clang-format-14 git reset --hard ./scripts/clang_format_all.sh git diff --exit-code - name: FIXME annotations left in code (use TODO for long-term notes) if: always() run: | ! grep fixme -niR ./* python_checks: name: Check Python code in tree runs-on: ubuntu-latest steps: - name: Install prerequisites run: | pip install --upgrade pip pip install black prospector pylint dodgy \ mccabe pycodestyle pyflakes \ psutil pygithub pglast testgres more_itertools # pinning snowballstemmer to version 2.2.0 due to: # https://github.com/prospector-dev/prospector/issues/763 pip install --force-reinstall --no-deps snowballstemmer==2.2.0 pip list pip list --user - name: Checkout source uses: actions/checkout@v4 - name: Run prospector run: | git reset --hard find . -type f -name "*.py" -print -exec prospector {} + -exec black {} + git diff --exit-code misc_checks: name: Check license, update scripts, git hooks, missing gitignore entries and unnecessary template tests runs-on: ubuntu-24.04 strategy: fail-fast: false steps: - name: Checkout source if: always() uses: actions/checkout@v4 - name: Check license if: always() run: ./scripts/check_license_all.sh - name: Check git commit hooks if: always() run: | ./scripts/githooks/commit_msg_tests.py - name: Check for unreferenced test files if: always() run: ./scripts/check_unreferenced_files.sh - name: Check for missing gitignore entries for template test files if: always() run: | ./bootstrap ./scripts/check_missing_gitignore_for_template_tests.sh - name: Check for unnecessary template test files if: always() run: ./scripts/check_unnecessary_template_tests.sh - name: Check for orphaned output test files if: always() run: ./scripts/check_orphaned_test_output_files.sh �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/coverity.yaml��������������������������������������������������0000664�0000000�0000000�00000003765�15100345067�0022213�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Coverity "on": schedule: # run at 22:00 on every saturday - cron: '0 22 * * TUE,SAT' push: branches: - coverity_scan - trigger/coverity pull_request: paths: .github/workflows/coverity.yaml workflow_dispatch: jobs: coverity: name: Coverity ${{ matrix.pg }} runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: # run only on the 3 latest PG versions as we have rate limit on coverity pg: [16, 17, 18] os: [ubuntu-22.04] steps: - name: Install Dependencies run: | sudo apt-get update sudo apt-get install gnupg systemd-coredump gdb postgresql-common libkrb5-dev yes | sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh sudo apt-get update sudo apt-get install postgresql-${{ matrix.pg }} postgresql-server-dev-${{ matrix.pg }} - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Coverity tools run: | wget https://scan.coverity.com/download/linux64 \ --post-data "token=${{ secrets.COVERITY_TOKEN }}&project=timescale%2Ftimescaledb" \ -O coverity_tool.tgz -q tar xf coverity_tool.tgz mv cov-analysis-linux64-* coverity - name: Build TimescaleDB run: | PATH="$GITHUB_WORKSPACE/coverity/bin:/usr/lib/postgresql/${{ matrix.pg }}/bin:$PATH" ./bootstrap -DCMAKE_BUILD_TYPE=Release cov-build --dir cov-int make -C build - name: Upload report env: FORM_EMAIL: --form email=ci@timescale.com FORM_FILE: --form file=@timescaledb.tgz FORM_DESC: --form description="CI" FORM_TOKEN: --form token="${{ secrets.COVERITY_TOKEN }}" COVERITY_URL: https://scan.coverity.com/builds?project=timescale%2Ftimescaledb run: | tar czf timescaledb.tgz cov-int curl $FORM_TOKEN $FORM_EMAIL $FORM_DESC $FORM_FILE \ --form version="$(grep '^version' version.config | cut -b11-)-${{ matrix.pg }}" $COVERITY_URL �����������timescaledb-2.23.0/.github/workflows/docker-images.yaml���������������������������������������������0000664�0000000�0000000�00000004647�15100345067�0023061�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test our docker images are built with the most recent version # The main purpose of this test is to check the image is working # and the latest tag points to an image with the most recent # release. name: "Packaging tests: Docker images" "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' pull_request: paths: .github/workflows/docker-images.yaml push: tags: - '*' branches: - release_test - trigger/package_test workflow_dispatch: jobs: docker_tests: name: ${{ matrix.image }} runs-on: ubuntu-latest services: ts: image: timescale/${{ matrix.image }} ports: - 5432:5432 env: POSTGRES_HOST_AUTH_METHOD: trust POSTGRESQL_PASSWORD: ci env: PGHOST: localhost PGUSER: postgres PGPASSWORD: ci strategy: fail-fast: false matrix: image: [ "timescaledb:latest-pg15", "timescaledb:latest-pg16", "timescaledb:latest-pg17", "timescaledb-ha:pg15", "timescaledb-ha:pg16", "timescaledb-ha:pg17", ] steps: - uses: actions/checkout@v4 - name: Read versions id: versions run: | # read expected version from version.config # version will only be a proper version in a release branch so we use previous_version # as fallback for main if grep '^version = [0-9.]\+$' version.config; then version=$(grep '^version = ' version.config | sed -e 's!^version = !!') else version=$(grep '^previous_version = ' version.config | sed -e 's!^previous_version = !!') fi echo "version=${version}" >>$GITHUB_OUTPUT - name: Wait for services to start run: | sleep 10 pg_isready -t 30 - name: Check version run: | psql -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb'" installed_version=$(psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" | sed -e 's! !!g') if [ "${{ steps.versions.outputs.version }}" != "$installed_version" ];then false fi - name: Create hypertable run: | psql -c "$(cat <<SQL CREATE TABLE metrics(time timestamptz, device text, metric text, value float); SELECT create_hypertable('metrics','time'); SQL )" �����������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/homebrew.yaml��������������������������������������������������0000664�0000000�0000000�00000003765�15100345067�0022157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test installation of our homebrew tap for latest version name: "Packaging tests: Homebrew" "on": schedule: # run daily 20:00 on main branch - cron: '0 20 * * *' pull_request: paths: .github/workflows/homebrew.yaml push: tags: - '*' branches: - release_test - trigger/package_test - trigger/homebrew_test workflow_dispatch: jobs: homebrew: name: Homebrew runs-on: macos-latest strategy: fail-fast: false matrix: license: [ "TSL", "Apache"] include: - license: Apache install_options: "--with-oss-only" steps: - name: Setup run: | brew install postgresql@17 echo "/opt/homebrew/opt/postgresql@17/bin" >> $GITHUB_PATH brew tap timescale/tap brew info timescaledb - name: Install timescaledb run: | brew uninstall cmake brew install timescaledb ${{ matrix.install_options }} timescaledb-tune --quiet --yes timescaledb_move.sh brew services start postgresql@17 # checkout code to get version information - uses: actions/checkout@v4 - name: Test Installation run: | psql -X -c "CREATE EXTENSION timescaledb;" postgres psql -X -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb';" postgres # read expected version from version.config if grep '^version = [0-9.]\+$' version.config; then version=$(grep '^version = ' version.config | sed -e 's!^version = !!') else version=$(grep '^previous_version = ' version.config | sed -e 's!^previous_version = !!') fi installed_version=$(psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" \ postgres | sed -e 's! !!g') if [ "$version" != "$installed_version" ];then echo "Installed version \"${installed_version}\" does not match expected version \"${version}\"." false fi �����������timescaledb-2.23.0/.github/workflows/issue-handling.yaml��������������������������������������������0000664�0000000�0000000�00000017435�15100345067�0023260�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Process issue workflows "on": issues: types: [opened, closed, labeled] issue_comment: types: [created, edited] jobs: add-to-project: name: Add issue to projects # issue_comment is triggered when commenting on both issues and # pull requests. To avoid adding pull requests to the bug board, # filter out pull requests if: ${{ !github.event.issue.pull_request }} runs-on: timescaledb-runner-arm64 steps: - name: Add to bugs board uses: actions/add-to-project@v0.5.0 with: project-url: https://github.com/orgs/timescale/projects/55 github-token: ${{ secrets.ORG_AUTOMATION_TOKEN }} labeled: bug, needs-triage, flaky-test label-operator: OR - name: Add to CAggs board uses: actions/add-to-project@v0.5.0 with: project-url: https://github.com/orgs/timescale/projects/128 github-token: ${{ secrets.ORG_AUTOMATION_TOKEN }} labeled: continuous_aggregate notify-sec: name: Notify security channel runs-on: timescaledb-runner-arm64 if: >- github.event_name == 'issues' && github.event.action == 'opened' && ( contains(github.event.issue.labels.*.name, 'segfault') || contains(github.event.issue.labels.*.name, 'security') ) || github.event_name == 'issues' && github.event.action == 'labeled' && ( github.event.label.name == 'segfault' || github.event.label.name == 'security' ) env: SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }} steps: - name: Post to Security Channel uses: slackapi/slack-github-action@v1.25.0 with: channel-id: '${{ secrets.SLACK_CHANNEL_SECURITY }}' payload: | { "text": "Issue #${{github.event.issue.number}} (${{github.event.issue.title}})> needs attention", "blocks": [ { "type": "section", "text": { "type": "mrkdwn", "text": "Issue <${{github.event.issue.html_url}}|#${{github.event.issue.number}} ${{github.event.issue.title}}> needs attention" } } ] } close-issue: name: Issue is closed runs-on: timescaledb-runner-arm64 if: github.event_name == 'issues' && github.event.action == 'closed' && contains(github.event.issues.issue.labels.*.name, 'bug') steps: - uses: leonsteinhaeuser/project-beta-automations@v2.0.0 with: gh_token: ${{ secrets.ORG_AUTOMATION_TOKEN }} organization: timescale project_id: 55 resource_node_id: ${{ github.event.issue.node_id }} status_value: 'Done' - name: Remove waiting-for-author label uses: andymckay/labeler@3a4296e9dcdf9576b0456050db78cfd34853f260 with: remove-labels: 'waiting-for-author, no-activity' repo-token: ${{ secrets.ORG_AUTOMATION_TOKEN }} waiting-for-author: name: Waiting for Author runs-on: timescaledb-runner-arm64 if: github.event_name == 'issues' && github.event.action == 'labeled' && github.event.label.name == 'waiting-for-author' steps: - uses: leonsteinhaeuser/project-beta-automations@v2.0.0 with: gh_token: ${{ secrets.ORG_AUTOMATION_TOKEN }} organization: timescale project_id: 55 resource_node_id: ${{ github.event.issue.node_id }} status_value: 'Waiting for Author' waiting-for-engineering: name: Waiting for Engineering runs-on: timescaledb-runner-arm64 if: github.event_name == 'issue_comment' && !github.event.issue.pull_request steps: - name: Install dependencies run: | sudo apt-get update sudo apt-get install jq - name: Get board column of issue id: extract_board_column continue-on-error: true run: | # The following GraphQL query requests all issues from a project. It uses the repository # to locate the issue and get the reference to the project. Then, a filter is applied # (number: $project) to get the reference to the desired project (i.e., the bug board). # Now, all issues from this project are requested. The reason for fetching all issues is # because the current implementation of the GitHub GraphQL API for projects does not # support server-side filters for issues and we can not restrict the query to our issue. # Therefore, we fetch all issues and apply a filter on the client side in the next step. gh api graphql --paginate -F issue=$ISSUE -F project=$PROJECT -F owner=$OWNER -F repo=$REPO -f query=' query board_column($issue: Int!, $project: Int!, $owner: String!, $repo: String!, $endCursor: String) { repository(owner: $owner, name: $repo) { issue(number: $issue) { projectV2(number: $project) { items(first: 100, after: $endCursor) { nodes { fieldValueByName(name: "Status") { ... on ProjectV2ItemFieldSingleSelectValue { name } } content { ... on Issue { id title number repository { name owner { login } } } } } pageInfo { hasNextPage endCursor } } } } } } ' > api_result # Get board column for issue board_column=$(jq -r ".data.repository.issue.projectV2.items.nodes[] | select (.content.number == $ISSUE and .content.repository.name == \"$REPO\" and .content.repository.owner.login == \"$OWNER\") | .fieldValueByName.name" api_result) echo "Issue is in column: $board_column" echo "issue_board_column=$board_column" >> "$GITHUB_OUTPUT" env: OWNER: timescale REPO: ${{ github.event.repository.name }} PROJECT: 55 ISSUE: ${{ github.event.issue.number }} GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} - name: Check if organization member uses: tspascoal/get-user-teams-membership@v2 id: checkUserMember with: username: ${{ github.actor }} organization: timescale team: 'database-eng' GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} - name: Remove waiting-for-author label if: >- steps.checkUserMember.outputs.isTeamMember == 'false' && steps.extract_board_column.outputs.issue_board_column == 'Waiting for Author' uses: andymckay/labeler@3a4296e9dcdf9576b0456050db78cfd34853f260 with: remove-labels: 'waiting-for-author, no-activity' repo-token: ${{ secrets.ORG_AUTOMATION_TOKEN }} - name: Move to waiting for engineering column if: ${{ steps.checkUserMember.outputs.isTeamMember == 'false' && steps.extract_board_column.outputs.issue_board_column == 'Waiting for Author' }} uses: leonsteinhaeuser/project-beta-automations@v2.0.0 with: gh_token: ${{ secrets.ORG_AUTOMATION_TOKEN }} organization: timescale project_id: 55 resource_node_id: ${{ github.event.issue.node_id }} status_value: 'Waiting for Engineering' �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/label-handling.yaml��������������������������������������������0000664�0000000�0000000�00000001334�15100345067�0023176�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # Collection of actions to run when a label is added # to an issue or pull request # name: Label Handling on: pull_request: types: - labeled jobs: pr-upgrade-requires-restart: runs-on: ubuntu-latest steps: - name: "PR: upgrade-requires-restart" if: github.event.label.name == 'upgrade-requires-restart' uses: actions/github-script@v7 with: script: | github.rest.issues.createComment({ owner: context.repo.owner, repo: context.repo.repo, issue_number: context.payload.pull_request.number, body: "📣 the `upgrade-requires-restart` label was added, pinging @timescale/database-pings" }) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/label-released-prs.yaml����������������������������������������0000664�0000000�0000000�00000001352�15100345067�0024000�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Apply "released" labels to the PRs that got into a particular release. name: Label Released PRs on: release: types: [published] push: branches: [trigger/label-released-prs] jobs: label-release: name: Label Released PRs runs-on: timescaledb-runner-arm64 env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} steps: - uses: actions/checkout@v4 - name: Install Python Dependencies run: | pip install PyGithub requests - name: Get latest release tag run: | echo "LATEST_TAG=$(gh release view --json tagName --jq '.tagName')" >> $GITHUB_ENV - name: Run label-released script run: | scripts/label-released.py --release "$LATEST_TAG" ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/libfuzzer.yaml�������������������������������������������������0000664�0000000�0000000�00000036052�15100345067�0022356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Libfuzzer "on": schedule: # run daily 1:00 on main branch - cron: '0 1 * * *' push: branches: - main - trigger/libfuzzer pull_request: paths: - .github/workflows/libfuzzer.yaml - 'tsl/test/fuzzing/compression/**' workflow_dispatch: jobs: build: runs-on: ubuntu-22.04 name: Build PostgreSQL and TimescaleDB env: PG_SRC_DIR: pgbuild PG_INSTALL_DIR: postgresql steps: - name: Install Linux Dependencies run: | # Don't add ddebs here because the ddebs mirror is always 503 Service Unavailable. # If needed, install them before opening the core dump. sudo apt-get update sudo apt-get install 7zip clang lld llvm flex bison libipc-run-perl \ libtest-most-perl tree jq - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Read configuration id: config run: python -B .github/gh_config_reader.py # We are going to rebuild Postgres daily, so that it doesn't suddenly break # ages after the original problem. - name: Get date for build caching id: get-date run: | echo "date=$(date +"%d")" >> $GITHUB_OUTPUT # we cache the build directory instead of the install directory here # because extension installation will write files to install directory # leading to a tainted cache - name: Cache PostgreSQL id: cache-postgresql uses: actions/cache@v4 with: path: ~/${{ env.PG_SRC_DIR }} key: "postgresql-libfuzzer-${{ steps.get-date.outputs.date }}-${{ hashFiles('.github/**') }}" - name: Build PostgreSQL if: steps.cache-postgresql.outputs.cache-hit != 'true' run: | wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/source/v${{ steps.config.outputs.PG15_LATEST }}/postgresql-${{ steps.config.outputs.PG15_LATEST }}.tar.bz2 mkdir -p ~/$PG_SRC_DIR tar --extract --file postgresql.tar.bz2 --directory ~/$PG_SRC_DIR --strip-components 1 cd ~/$PG_SRC_DIR CC=clang ./configure --prefix=$HOME/$PG_INSTALL_DIR --with-openssl \ --without-readline --without-zlib --without-libxml --enable-cassert \ --enable-debug CC=clang \ CFLAGS="-fuse-ld=lld -ggdb3 -O2 -fno-omit-frame-pointer" make -j$(nproc) - name: Install PostgreSQL run: | make -C ~/$PG_SRC_DIR install make -C ~/$PG_SRC_DIR/contrib/postgres_fdw install - name: Upload config.log if: always() uses: actions/upload-artifact@v4 with: name: config.log for PostgreSQL path: ~/${{ env.PG_SRC_DIR }}/config.log - name: Build TimescaleDB run: | set -e export LIBFUZZER_PATH=$(dirname "$(find $(llvm-config --libdir) -name libclang_rt.fuzzer_no_main-x86_64.a | head -1)") # Some pointers for the next time we have linking/undefined symbol problems: # http://web.archive.org/web/20200926071757/https://github.com/google/sanitizers/issues/111 # http://web.archive.org/web/20231101091231/https://github.com/cms-sw/cmssw/issues/40680 cmake -B build -S . -DASSERTIONS=ON -DLINTER=OFF -DCMAKE_VERBOSE_MAKEFILE=1 \ -DWARNINGS_AS_ERRORS=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_C_COMPILER=clang \ -DCMAKE_C_FLAGS="-fsanitize=fuzzer-no-link -lstdc++ -L$LIBFUZZER_PATH -l:libclang_rt.fuzzer_no_main-x86_64.a -static-libsan" \ -DCOMPRESSION_FUZZING=1 -DPG_PATH=$HOME/$PG_INSTALL_DIR make -C build -j$(nproc) install # Incredibly, the upload-artifact action can't preserve executable permissions: # https://github.com/actions/upload-artifact/issues/38 # It's also extremely slow. - name: Compress the installation directory run: 7z a install.7z $HOME/$PG_INSTALL_DIR - name: Save the installation directory uses: actions/upload-artifact@v4 with: name: fuzzing-install-dir path: install.7z if-no-files-found: error retention-days: 1 fuzz: needs: build strategy: fail-fast: false matrix: case: [ { algo: gorilla , pgtype: float8, bulk: false, runs: 500000000 }, { algo: deltadelta, pgtype: int8 , bulk: false, runs: 500000000 }, { algo: gorilla , pgtype: float8, bulk: true , runs: 1000000000 }, { algo: deltadelta, pgtype: int8 , bulk: true , runs: 1000000000 }, # array has a peculiar recv function that recompresses all input, so # fuzzing it is much slower. The dictionary recv also uses it. { algo: array , pgtype: text , bulk: false, runs: 10000000 }, { algo: array , pgtype: text , bulk: true , runs: 10000000 }, { algo: dictionary, pgtype: text , bulk: false, runs: 100000000 }, { algo: dictionary, pgtype: text , bulk: true , runs: 100000000 }, { algo: bool, pgtype: bool , bulk: false, runs: 500000000 }, { algo: bool, pgtype: bool , bulk: true , runs: 1000000000 }, # uuid tests are slower because it is more work to compare { algo: dictionary, pgtype: uuid , bulk: false, runs: 5000000 }, { algo: dictionary, pgtype: uuid , bulk: true , runs: 10000000 }, { algo: uuid, pgtype: uuid , bulk: false, runs: 5000000 }, { algo: uuid, pgtype: uuid , bulk: true , runs: 10000000 }, ] name: Fuzz decompression ${{ matrix.case.algo }} ${{ matrix.case.pgtype }} ${{ matrix.case.bulk && 'bulk' || 'rowbyrow' }} runs-on: ubuntu-22.04 env: PG_SRC_DIR: pgbuild PG_INSTALL_DIR: postgresql JOB_NAME: Fuzz decompression ${{ matrix.case.algo }} ${{ matrix.case.pgtype }} ${{ matrix.case.bulk && 'bulk' || 'rowbyrow' }} steps: - name: Install Linux dependencies run: | sudo apt update sudo apt install 7zip systemd-coredump gdb - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Download the installation directory uses: actions/download-artifact@v4 with: name: fuzzing-install-dir - name: Unpack the installation directory run: 7z x -o$HOME install.7z - name: initdb run: | # Have to do this before initializing the corpus, or initdb will complain. set -xeu export PGDATA=db export PGPORT=5432 export PGDATABASE=postgres export PATH=$HOME/$PG_INSTALL_DIR/bin:$PATH initdb echo "shared_preload_libraries = 'timescaledb'" >> $PGDATA/postgresql.conf - name: Set configuration id: config run: | set -x echo "cache_prefix=${{ format('libfuzzer-corpus-2-{0}-{1}', matrix.case.algo, matrix.case.pgtype) }}" >> $GITHUB_OUTPUT echo "name=${{ matrix.case.algo }} ${{ matrix.case.pgtype }} ${{ matrix.case.bulk && 'bulk' || 'rowbyrow' }}" >> $GITHUB_OUTPUT - name: Restore the cached fuzzing corpus (bulk) id: restore-corpus-cache-bulk uses: actions/cache/restore@v4 with: path: db/corpus-bulk key: "${{ steps.config.outputs.cache_prefix }}-bulk" # We save the row-by-row corpus separately from the bulk corpus, so that # they don't overwrite each other. Now we are going to combine them. - name: Restore the cached fuzzing corpus (rowbyrow) id: restore-corpus-cache-rowbyrow uses: actions/cache/restore@v4 with: path: db/corpus-rowbyrow key: "${{ steps.config.outputs.cache_prefix }}-rowbyrow" - name: Initialize the fuzzing corpus run: | # Combine the cached corpus from rowbyrow and bulk fuzzing, and from repository. mkdir -p db/corpus{,-rowbyrow,-bulk} find "tsl/test/fuzzing/compression/${{ matrix.case.algo }}-${{ matrix.case.pgtype }}" -type f -exec cp -n -t db/corpus {} + find "db/corpus-rowbyrow" -type f -exec cp -n -t db/corpus {} + find "db/corpus-bulk" -type f -exec cp -n -t db/corpus {} + ls db/corpus | wc -l - name: Run libfuzzer for compression run: | set -xeu export PGDATA=db export PGPORT=5432 export PGDATABASE=postgres export PATH=$HOME/$PG_INSTALL_DIR/bin:$PATH pg_ctl -o "-clogging_collector=true" -o "-clog_destination=jsonlog,stderr" \ -o "-clog_directory=$(readlink -f .)" -o "-clog_filename=postmaster.log" \ -o "-clog_error_verbosity=verbose" start psql -c "create extension timescaledb;" # Create the fuzzing functions export MODULE_NAME=$(basename $(find $HOME/$PG_INSTALL_DIR -name "timescaledb-tsl-*.so")) psql -a -c "create or replace function fuzz(algo cstring, pgtype regtype, bulk bool, runs int) returns int as '"$MODULE_NAME"', 'ts_fuzz_compression' language c; create or replace function ts_read_compressed_data_directory(algo cstring, pgtype regtype, path cstring, bulk bool) returns table(path text, bytes int, rows int, sqlstate text, location text) as '"$MODULE_NAME"', 'ts_read_compressed_data_directory' language c; " # Start more fuzzing processes in the background. We won't even monitor # their progress, because the server will panic if they find an error. for x in {2..$(nproc)} do psql -v ON_ERROR_STOP=1 -c "select fuzz('${{ matrix.case.algo }}', '${{ matrix.case.pgtype }}', '${{ matrix.case.bulk }}', ${{ matrix.case.runs }});" & done # Start the one fuzzing process that we will monitor, in foreground. # The LLVM fuzzing driver calls exit(), so we expect to lose the connection. ret=0 psql -v ON_ERROR_STOP=1 -c "select fuzz('${{ matrix.case.algo }}', '${{ matrix.case.pgtype }}', '${{ matrix.case.bulk }}', ${{ matrix.case.runs }});" || ret=$? if ! [ $ret -eq 2 ] then >&2 echo "Unexpected psql exit code $ret" exit 1 fi ls db/corpus | wc -l fn="ts_read_compressed_data_directory('${{ matrix.case.algo }}', '${{ matrix.case.pgtype }}', 'corpus', '${{ matrix.case.bulk }}')" # Show the statistics about fuzzing corpus psql -c "select count(*), location, min(sqlstate), min(path) from $fn group by location order by count(*) desc " # Save interesting cases because the caches are not available for download from UI mkdir -p interesting psql -qtAX -c "select distinct on (location) 'db/' || path from $fn order by location, bytes, path " | xargs cp -t interesting # Check that we don't have any internal errors errors=$(psql -qtAX --set=ON_ERROR_STOP=1 -c "select count(*) from $fn where sqlstate = 'XX000'") echo "Internal program errors: $errors" [ $errors -eq 0 ] || exit 1 # Shouldn't have any WARNINGS in the log. ! grep -F "] WARNING: " postmaster.log # Check that the server is still alive. psql -c "select 1" - name: Collect the logs if: always() id: collectlogs run: | # wait in case there are in-progress coredumps sleep 10 if coredumpctl -q list >/dev/null; then echo "coredumps=true" >>$GITHUB_OUTPUT; fi # print OOM killer information sudo journalctl --system -q --facility=kern --grep "Killed process" || true - name: Save PostgreSQL log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL log for ${{ steps.config.outputs.name }} path: postgres.* - name: Save fuzzer-generated crash cases if: always() uses: actions/upload-artifact@v4 with: name: Crash cases for ${{ steps.config.outputs.name }} path: db/crash-* if-no-files-found: ignore - name: Save interesting cases if: always() uses: actions/upload-artifact@v4 with: name: Interesting cases for ${{ steps.config.outputs.name }} path: interesting/ # We use separate restore/save actions, because the default action won't # save the updated folder after the cache hit. We also want to save the # cache after fuzzing errors, and the default action doesn't save after # errors. # We can't overwrite the existing cache, so we add a unique suffix. The # cache is matched by key prefix, not exact key, and picks the newest # matching item, so this works. # The caches for rowbyrow and bulk fuzzing are saved separately, otherwise # the slower job would always overwrite the cache from the faster one. We # want to combine corpuses from bulk and rowbyrow fuzzing for better # coverage. # Note that the cache action cannot be restored on a path different from the # one it was saved from. To make our lives more interesting, it is not # directly documented anywhere, but we can deduce it from path influencing # the version. - name: Change corpus path to please the 'actions/cache' GitHub Action if: always() run: | rm -rf db/corpus-{bulk,rowbyrow} ||: mv -fT db/corpus{,-${{ matrix.case.bulk && 'bulk' || 'rowbyrow' }}} - name: Save fuzzer corpus if: always() uses: actions/cache/save@v4 with: path: db/corpus-${{ matrix.case.bulk && 'bulk' || 'rowbyrow' }} key: "${{ format('{0}-{1}-{2}-{3}', steps.config.outputs.cache_prefix, matrix.case.bulk && 'bulk' || 'rowbyrow', github.run_id, github.run_attempt) }}" - name: Stack trace if: always() && steps.collectlogs.outputs.coredumps == 'true' run: | sudo coredumpctl gdb <<<" set verbose on set trace-commands on show debug-file-directory printf "'"'"query = '%s'\n\n"'"'", debug_query_string frame function ExceptionalCondition printf "'"'"condition = '%s'\n"'"'", conditionName up 1 l info args info locals bt full " 2>&1 | tee stacktrace.log ./scripts/bundle_coredumps.sh exit 1 # Fail the job if we have core dumps. - name: Upload core dumps if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Coredumps for ${{ steps.config.outputs.name }} path: coredumps - name: Upload test results to the database if: always() env: CI_STATS_DB: ${{ secrets.CI_STATS_DB }} GITHUB_EVENT_NAME: ${{ github.event_name }} GITHUB_REF_NAME: ${{ github.ref_name }} GITHUB_REPOSITORY: ${{ github.repository }} GITHUB_RUN_ATTEMPT: ${{ github.run_attempt }} GITHUB_RUN_ID: ${{ github.run_id }} GITHUB_RUN_NUMBER: ${{ github.run_number }} JOB_STATUS: ${{ job.status }} run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then GITHUB_PR_NUMBER="${{ github.event.number }}" else GITHUB_PR_NUMBER=0 fi export GITHUB_PR_NUMBER scripts/upload_ci_stats.sh ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/linux-32bit-build-and-test-ignored.yaml������������������������0000664�0000000�0000000�00000001761�15100345067�0026660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Ignoring version of the corresponding workflow. These files are # needed to run required workflows even when the real workflow is not # executed because some files were ignored. name: Regression Linux i386 "on": push: branches: - main paths: - '!**' - '**.md' - 'LICENSE*' - NOTICE pull_request: paths: - '!**' - '**.md' - 'LICENSE*' - NOTICE jobs: config: runs-on: ubuntu-latest outputs: pg_latest: ${{ steps.setter.outputs.PG_LATEST }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Read configuration id: setter run: python .github/gh_config_reader.py regress_linux_32bit: name: PG${{ matrix.pg }} ${{ matrix.build_type }} linux-i386 runs-on: ubuntu-latest needs: config strategy: matrix: pg: ${{ fromJson(needs.config.outputs.pg_latest) }} build_type: [ Debug ] steps: - run: | echo "No build required" ���������������timescaledb-2.23.0/.github/workflows/linux-32bit-build-and-test.yaml��������������������������������0000664�0000000�0000000�00000026042�15100345067�0025232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Regression Linux i386 "on": schedule: # run daily 0:00 on main branch # Since we use the date as a part of the cache key to ensure no # stale cache entries hiding build failures we need to make sure # we have a cache entry present before workflows that depend on cache # are run. - cron: '0 0 * * *' push: branches: - main - ?.*.x paths-ignore: - '**.md' - 'LICENSE*' - NOTICE pull_request: paths-ignore: - '**.md' - 'LICENSE*' - NOTICE jobs: config: runs-on: ubuntu-latest outputs: pg_latest: ${{ steps.setter.outputs.PG_LATEST }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Read configuration id: setter run: python .github/gh_config_reader.py regress_linux_32bit: name: PG${{ matrix.pg }} ${{ matrix.build_type }} linux-i386 runs-on: ubuntu-latest needs: config container: image: i386/debian:bookworm-slim options: --privileged --ulimit core=-1:-1 --ulimit fsize=-1:-1 env: PG_SRC_DIR: pgbuild PG_INSTALL_DIR: postgresql CLANG: clang-14 CC: clang-14 CXX: clang++-14 DEBIAN_FRONTEND: noninteractive # vectorized_aggregation has different output on i386 because int8 is by # reference and currently it cannot be used for vectorized hash grouping. # vector_agg_text and vector_agg_groupagg use the UMASH hashing library # that we can't compile on i386. # For the same reason of different hashing, we ignore the results of # several bloom filter tests as well. IGNORES: >- append-* bgw_db_scheduler* columnar_scan_cost compress_bloom_sparse_compat compress_bloom_sparse_debug compress_qualpushdown_saop compression_allocation merge_append_partially_compressed net pg_dump telemetry transparent_decompress_chunk-* transparent_decompression-* vector_agg_byte vector_agg_filter vector_agg_groupagg vector_agg_grouping vector_agg_text vector_agg_uuid vectorized_aggregation ${{ matrix.pg < 16 && 'columnar_scan_cost' || '' }} SKIPS: chunk_adaptive histogram_test-* EXTENSIONS: "postgres_fdw test_decoding" strategy: matrix: pg: ${{ fromJson(needs.config.outputs.pg_latest) }} build_type: [ Debug ] fail-fast: false steps: # /__e/node16/bin/node (used by actions/checkout@v4) needs 64-bit libraries - name: Install 64-bit libraries for GitHub actions run: | apt-get update apt-get install -y lib64atomic1 lib64gcc-s1 lib64stdc++6 libc6-amd64 jq - name: Install build dependencies run: | PG_MAJOR=$(echo "${{ matrix.pg }}" | sed -e 's![.].*!!') echo '/tmp/core.%h.%e.%t' > /proc/sys/kernel/core_pattern apt-get install -y gcc make cmake libssl-dev libkrb5-dev libipc-run-perl \ libtest-most-perl sudo gdb git wget gawk lbzip2 flex bison lcov base-files \ locales clang-14 llvm-14 llvm-14-dev llvm-14-tools postgresql-client pkgconf \ icu-devtools - name: Checkout TimescaleDB uses: actions/checkout@v4 # We are going to rebuild Postgres daily, so that it doesn't suddenly break # ages after the original problem. - name: Get date for build caching id: get-date run: | echo "date=$(date +"%d")" >> $GITHUB_OUTPUT # we cache the build directory instead of the install directory here # because extension installation will write files to install directory # leading to a tainted cache - name: Cache PostgreSQL ${{ matrix.pg }} ${{ matrix.build_type }} id: cache-postgresql uses: actions/cache@v4 with: path: ~/${{ env.PG_SRC_DIR }} key: "linux-32-bit-postgresql-${{ matrix.pg }}-${{ matrix.cc }}\ -${{ steps.get-date.outputs.date }}-${{ hashFiles('.github/**') }}" - name: Build PostgreSQL ${{ matrix.pg }} if: steps.cache-postgresql.outputs.cache-hit != 'true' run: | wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/source/v${{ matrix.pg }}/postgresql-${{ matrix.pg }}.tar.bz2 mkdir -p ~/$PG_SRC_DIR tar --extract --file postgresql.tar.bz2 --directory ~/$PG_SRC_DIR --strip-components 1 cd ~/$PG_SRC_DIR # When building on i386 with the clang compiler, Postgres requires -msse2 to be used ./configure --prefix=$HOME/$PG_INSTALL_DIR --with-openssl \ --without-readline --without-zlib --without-libxml --enable-cassert \ --enable-debug --with-llvm --without-icu LLVM_CONFIG=llvm-config-14 CFLAGS="-msse2" make -j $(nproc) for ext in ${EXTENSIONS}; do make -j $(nproc) -C contrib/${ext} done - name: Install PostgreSQL ${{ matrix.pg }} run: | useradd postgres cd ~/$PG_SRC_DIR make install for ext in ${EXTENSIONS}; do make -C contrib/${ext} install done chown -R postgres:postgres $HOME/$PG_INSTALL_DIR sed -i 's/^# *\(en_US.UTF-8\)/\1/' /etc/locale.gen locale-gen - name: Upload config.log if: always() && steps.cache-postgresql.outputs.cache-hit != 'true' uses: actions/upload-artifact@v4 with: name: config.log linux-i386 PG${{ matrix.pg }} path: ~/${{ env.PG_SRC_DIR }}/config.log - name: Build TimescaleDB run: | # The owner of the checkout directory and the files do not match. Add the directory to # Git's "safe.directory" setting. Otherwise git would complain about # 'detected dubious ownership in repository' git config --global --add safe.directory $(pwd) ./bootstrap -DCMAKE_BUILD_TYPE="${{ matrix.build_type }}" \ -DPG_SOURCE_DIR=~/$PG_SRC_DIR -DPG_PATH=~/$PG_INSTALL_DIR \ -DREQUIRE_ALL_TESTS=ON \ -DTEST_PG_LOG_DIRECTORY="$(readlink -f .)" make -j $(nproc) -C build make -C build install chown -R postgres:postgres . - name: Upload CMake Logs if: always() uses: actions/upload-artifact@v4 with: name: CMake Logs linux-i386 PG${{ matrix.pg }} path: | build/CMakeCache.txt build/CMakeFiles/CMakeConfigureLog.yaml build/CMakeFiles/CMakeError.log build/CMakeFiles/CMakeOutput.log build/compile_commands.json - name: make installcheck id: installcheck shell: bash run: | set -o pipefail export LANG=C.UTF-8 # # Even disabling parallel plans the Sort Method on 32bits # is always 'still in progress' for PG17 and PG18. So for now added # those tests to SKIPS. # PG_MAJOR=$(echo "${{ matrix.pg }}" | sed -e 's![.].*!!') if [ ${PG_MAJOR} -eq 17 ]; then SKIPS="${SKIPS} constraint_exclusion_prepared-17 ordered_append*" fi if [ ${PG_MAJOR} -eq 18 ]; then SKIPS="${SKIPS} constraint_exclusion_prepared-18 ordered_append*" fi # PostgreSQL cannot be run as root. So, switch to postgres user. runuser -u postgres -- \ make -k -C build installcheck IGNORES="${IGNORES}" \ SKIPS="${SKIPS}" PSQL="${HOME}/${PG_INSTALL_DIR}/bin/psql" \ | tee installcheck.log - name: Show regression diffs if: always() id: collectlogs shell: bash run: | find . -name regression.diffs -exec cat {} + > regression.log if [[ -s regression.log ]]; then echo "regression_diff=true" >>$GITHUB_OUTPUT; fi grep -e 'FAILED' -e 'failed (ignored)' -e 'not ok' installcheck.log || true cat regression.log - name: Save regression diffs if: always() && steps.collectlogs.outputs.regression_diff == 'true' uses: actions/upload-artifact@v4 with: name: Regression diff linux-i386 PG${{ matrix.pg }} path: | regression.log installcheck.log - name: Save PostgreSQL log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL log linux-i386 PG${{ matrix.pg }} path: postmaster.* - name: Stack trace Linux if: always() shell: bash run: | # wait in case there are in-progress coredumps sleep 10 if compgen -G "/tmp/core*" > /dev/null; then PG_MAJOR=$(echo "${{ matrix.pg }}" | sed -e 's![.].*!!') for file in /tmp/core* do gdb "${HOME}/${PG_INSTALL_DIR}/bin/postgres" -c $file <<<" set verbose on set trace-commands on show debug-file-directory printf "'"'"query = '%s'\n\n"'"'", debug_query_string bt full # We try to find ExceptionalCondition frame to print the failed condition # for searching in logs. frame function ExceptionalCondition printf "'"'"condition = '%s'\n"'"'", conditionName # Hopefully now we should be around the failed assertion, print where # we are. up 1 list info args info locals " 2>&1 | tee -a stacktrace.log done echo "coredumps=true" >>$GITHUB_OUTPUT exit 1 fi - name: Coredumps if: always() && steps.coredumps.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Coredumps linux-i386 PG${{ matrix.pg }} path: coredumps - name: Save stacktraces if: always() && steps.coredumps.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Stacktraces linux-i386 PG${{ matrix.pg }} path: stacktrace.log - name: Save TAP test logs if: always() uses: actions/upload-artifact@v4 with: name: TAP test logs ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: | build/test/tmp_check/log build/tsl/test/tmp_check/log - name: Upload test results to the database if: always() shell: bash env: # GitHub Actions allow you neither to use the env context for the job name, # nor to access the job name from the step context, so we have to # duplicate it to work around this nonsense. JOB_NAME: PG${{ matrix.pg }} ${{ matrix.build_type }} linux-i386 CI_STATS_DB: ${{ secrets.CI_STATS_DB }} GITHUB_EVENT_NAME: ${{ github.event_name }} GITHUB_REF_NAME: ${{ github.ref_name }} GITHUB_REPOSITORY: ${{ github.repository }} GITHUB_RUN_ATTEMPT: ${{ github.run_attempt }} GITHUB_RUN_ID: ${{ github.run_id }} GITHUB_RUN_NUMBER: ${{ github.run_number }} JOB_STATUS: ${{ job.status }} run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then GITHUB_PR_NUMBER="${{ github.event.number }}" else GITHUB_PR_NUMBER=0 fi export GITHUB_PR_NUMBER scripts/upload_ci_stats.sh ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/linux-build-and-test-ignored.yaml������������������������������0000664�0000000�0000000�00000002325�15100345067�0025734�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Ignoring version of the corresponding workflow. These files are # needed to run required workflows even when the real workflow is not # executed because some files were ignored. name: Regression "on": push: branches: - main paths: - '!**' - '**.md' - 'LICENSE*' - NOTICE pull_request: paths: - '!**' - '**.md' - 'LICENSE*' - NOTICE jobs: matrixbuilder: runs-on: ubuntu-latest outputs: matrix: ${{ steps.set-matrix.outputs.matrix }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Build matrix id: set-matrix run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then git fetch origin ${{ github.base_ref }}:base .github/gh_matrix_builder.py ${{ github.event_name }} base else .github/gh_matrix_builder.py ${{ github.event_name }} fi regress: name: PG${{ matrix.pg }}${{ matrix.snapshot }} ${{ matrix.name }} ${{ matrix.os }} needs: matrixbuilder runs-on: ubuntu-latest strategy: matrix: ${{ fromJson(needs.matrixbuilder.outputs.matrix) }} steps: - run: | echo "No build required" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/linux-build-and-test.yaml��������������������������������������0000664�0000000�0000000�00000032432�15100345067�0024311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Regression "on": schedule: # run daily 0:00 on main branch # Since we use the date as a part of the cache key to ensure no # stale cache entries hiding build failures we need to make sure # we have a cache entry present before workflows that depend on cache # are run. - cron: '0 0 * * *' push: branches: - main - ?.*.x paths-ignore: - '**.md' - 'LICENSE*' - NOTICE pull_request: paths-ignore: - '**.md' - 'LICENSE*' - NOTICE jobs: matrixbuilder: runs-on: ubuntu-latest outputs: matrix: ${{ steps.set-matrix.outputs.matrix }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Build matrix id: set-matrix run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then git fetch origin ${{ github.base_ref }}:base .github/gh_matrix_builder.py ${{ github.event_name }} base else .github/gh_matrix_builder.py ${{ github.event_name }} fi regress: # Change the JOB_NAME variable below when changing the name. name: PG${{ matrix.pg }}${{ matrix.snapshot }} ${{ matrix.name }} ${{ matrix.os }} needs: matrixbuilder runs-on: ${{ matrix.os }} env: PG_SRC_DIR: pgbuild PG_INSTALL_DIR: postgresql CLANG: ${{ matrix.clang }} CC: ${{ matrix.cc }} CXX: ${{ matrix.cxx }} # For some reason, on PG <= 15 with faketime the client backends get the # modified time, and the background workers the unmodified time, so it # doesn't work. FAKETIME: | ${{ (contains(matrix.os, 'ubuntu') && !startsWith(matrix.pg, '14.') && !startsWith(matrix.pg, '15.') ) && 'faketime -f +379d' || '' }} strategy: matrix: ${{ fromJson(needs.matrixbuilder.outputs.matrix) }} fail-fast: false steps: - name: Install Linux Dependencies if: runner.os == 'Linux' run: | # Don't add ddebs here because the ddebs mirror is always 503 Service Unavailable. # If needed, install them before opening the core dump. sudo apt-get update sudo apt-get install flex bison lcov systemd-coredump gdb libipc-run-perl \ libtest-most-perl pkgconf icu-devtools faketime jq ${{ matrix.extra_packages }} - name: Install macOS Dependencies if: runner.os == 'macOS' run: | # Disable the automatic dependency upgrade executed by `brew install` # https://docs.brew.sh/Manpage#install-options-formulacask- HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew install gawk # Install perl modules after last Homebew call, since Homebrew can change the perl version sudo perl -MCPAN -e "CPAN::Shell->notest('install', 'IPC::Run')" sudo perl -MCPAN -e "CPAN::Shell->notest('install', 'Test::Most')" - name: Setup macOS coredump directory if: runner.os == 'macOS' run: sudo chmod 777 /cores - name: Checkout TimescaleDB uses: actions/checkout@v4 # We are going to rebuild Postgres daily, so that it doesn't suddenly break # ages after the original problem. - name: Get date for build caching id: get-date run: | echo "date=$(date +"%d")" >> $GITHUB_OUTPUT # on macOS the path used is depending on the runner version leading to cache failure # when the runner version changes so we extract runner version from path and add it # as cache suffix - name: Cache suffix if: runner.os == 'macOS' run: echo "CACHE_SUFFIX=-${ImageVersion}" >> $GITHUB_ENV # we cache the build directory instead of the install directory here # because extension installation will write files to install directory # leading to a tainted cache - name: Cache PostgreSQL ${{ matrix.pg }} ${{ matrix.build_type }} id: cache-postgresql if: matrix.snapshot != 'snapshot' uses: actions/cache@v4 with: path: ~/${{ env.PG_SRC_DIR }} key: "${{ matrix.os }}-postgresql-${{ matrix.pg }}-${{ matrix.cc }}\ -${{ steps.get-date.outputs.date }}-${{ hashFiles('.github/**') }}${{ env.CACHE_SUFFIX }}" - name: Build PostgreSQL ${{ matrix.pg }}${{ matrix.snapshot }} if: steps.cache-postgresql.outputs.cache-hit != 'true' run: | if [ "${{ matrix.snapshot }}" = "snapshot" ]; then wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/snapshot/${{ matrix.pg }}/postgresql-${{ matrix.pg }}-snapshot.tar.bz2 else wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/source/v${{ matrix.pg }}/postgresql-${{ matrix.pg }}.tar.bz2 fi mkdir -p ~/$PG_SRC_DIR tar --extract --file postgresql.tar.bz2 --directory ~/$PG_SRC_DIR --strip-components 1 cd ~/$PG_SRC_DIR ./configure --prefix=$HOME/$PG_INSTALL_DIR --with-openssl \ --without-readline --without-zlib --without-libxml ${{ matrix.pg_extra_args }} make -j $(nproc) for ext in ${{ matrix.pg_extensions }}; do make -j $(nproc) -C contrib/${ext} done - name: Install PostgreSQL ${{ matrix.pg }} run: | cd ~/$PG_SRC_DIR make install for ext in ${{ matrix.pg_extensions }}; do make -C contrib/${ext} install done echo "$HOME/$PG_INSTALL_DIR/bin" >> "${GITHUB_PATH}" - name: Upload config.log if: always() && steps.cache-postgresql.outputs.cache-hit != 'true' uses: actions/upload-artifact@v4 with: name: config.log for PostgreSQL ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: ~/${{ env.PG_SRC_DIR }}/config.log - name: Test telemetry without OpenSSL if: github.event_name != 'pull_request' && runner.os == 'Linux' && matrix.build_type == 'Debug' run: | BUILD_DIR=nossl ./bootstrap -DCMAKE_BUILD_TYPE=Debug \ -DPG_SOURCE_DIR=$HOME/$PG_SRC_DIR -DPG_PATH=$HOME/$PG_INSTALL_DIR \ ${{ matrix.tsdb_build_args }} -DCODECOVERAGE=${{ matrix.coverage }} -DUSE_OPENSSL=OFF \ -DTEST_PG_LOG_DIRECTORY="$(readlink -f .)" make -j $(nproc) -C nossl make -C nossl install make -C nossl regresscheck TESTS=telemetry - name: Build TimescaleDB run: | # Show the actual architecture this CI runner has "$CC" -march=native -E -v - </dev/null 2>&1 | grep cc1 ./bootstrap -DCMAKE_BUILD_TYPE="${{ matrix.build_type }}" \ -DPG_SOURCE_DIR=$HOME/$PG_SRC_DIR -DPG_PATH=$HOME/$PG_INSTALL_DIR \ ${{ matrix.tsdb_build_args }} -DCODECOVERAGE=${{ matrix.coverage }} \ -DTEST_PG_LOG_DIRECTORY="$(readlink -f .)" make -j $(nproc) -C build make -C build install - name: Upload CMake Logs if: always() uses: actions/upload-artifact@v4 with: name: CMake Logs ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: | build/CMakeCache.txt build/CMakeFiles/CMakeConfigureLog.yaml build/CMakeFiles/CMakeError.log build/CMakeFiles/CMakeOutput.log build/compile_commands.json - name: Check exported symbols run: ./build/scripts/export_prefix_check.sh - name: make installcheck if: matrix.installcheck run: | set -o pipefail make -k -C build installcheck IGNORES="${{ join(matrix.ignored_tests, ' ') }}" \ SKIPS="${{ join(matrix.skipped_tests, ' ') }}" ${{ matrix.installcheck_args }} \ | tee installcheck.log - name: pginstallcheck if: matrix.pginstallcheck run: make -C build pginstallcheck - name: coverage if: matrix.coverage run: make -j $(nproc) -k -C build coverage - name: Send coverage report to Codecov.io app if: matrix.coverage uses: codecov/codecov-action@v5 with: token: ${{ secrets.CODECOV_TOKEN }} files: ./build/coverage/timescaledb-coverage.info - name: Save LCOV coverage report if: matrix.coverage uses: actions/upload-artifact@v4 with: name: LCOV coverage report ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: ./build/coverage/lcov-report - name: Show regression diffs if: always() id: collectlogs run: | find . -name regression.diffs -exec cat {} + > regression.log if [[ "${{ runner.os }}" == "Linux" ]] ; then # wait in case there are in-progress coredumps sleep 10 if coredumpctl -q list >/dev/null; then echo "coredumps=true" >>$GITHUB_OUTPUT; fi # print OOM killer information sudo journalctl --system -q --facility=kern --grep "Killed process" || true elif [[ "${{ runner.os }}" == "macOS" ]] ; then if [ $(find /cores -type f | wc -l) -gt 0 ]; then echo "coredumps=true" >>$GITHUB_OUTPUT; fi fi if [[ -s regression.log ]]; then echo "regression_diff=true" >>$GITHUB_OUTPUT; fi grep -e 'FAILED' -e 'failed (ignored)' -e 'not ok' installcheck.log || true cat regression.log - name: Save regression diffs if: always() && steps.collectlogs.outputs.regression_diff == 'true' uses: actions/upload-artifact@v4 with: name: Regression diff ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: | regression.log installcheck.log - name: Save PostgreSQL log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL log ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: postmaster.* - name: Stack trace Linux if: always() && steps.collectlogs.outputs.coredumps == 'true' && runner.os == 'Linux' run: | sudo coredumpctl debug --debugger=gdb --debugger-arguments='' <<<" set verbose on set trace-commands on show debug-file-directory printf "'"'"query = '%s'\n\n"'"'", debug_query_string bt full # We try to find ExceptionalCondition frame to print the failed condition # for searching in logs. frame function ExceptionalCondition printf "'"'"condition = '%s'\n"'"'", conditionName # Hopefully now we should be around the failed assertion, print where # we are. up 1 list info args info locals " 2>&1 | tee -a stacktrace.log ./scripts/bundle_coredumps.sh - name: Stack trace macOS if: always() && steps.collectlogs.outputs.coredumps == 'true' && runner.os == 'macOS' run: | ~/$PG_SRC_DIR/src/tools/ci/cores_backtrace.sh macos /cores - name: Coredumps if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Coredumps ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: coredumps - name: Save stacktraces if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Stacktraces ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: stacktrace.log - name: Save TAP test logs if: always() uses: actions/upload-artifact@v4 with: name: TAP test logs ${{ matrix.os }} ${{ matrix.name }} ${{ matrix.pg }} path: | build/test/tmp_check/log build/tsl/test/tmp_check/log - name: Check that no new internal program errors are introduced # We collect the same messages when uploading to the CI checks database, # but it runs on different conditions (not on forks and not on flaky check), # and requires different data (job date), so we do it separately here. # The jq --exit-code option is broken with select() on jq-1.6 which we see # on some machines, so we use grep instead (see https://github.com/jqlang/jq/issues/1139). if: always() && contains(matrix.name, 'Flaky') run: | ! jq 'select( (.state_code == "XX000" and .error_severity != "LOG") or (.message | test("resource was not closed")) ) | [.message, .func_name, .statement] | @tsv ' -r postmaster.json | grep . - name: Upload test results to the database # Don't upload the results of the flaky check, because the db schema only # supports running one test once per job. if: always() && (! contains(matrix.name, 'Flaky')) env: # GitHub Actions allow you neither to use the env context for the job name, # nor to access the job name from the step context, so we have to # duplicate it to work around this nonsense. JOB_NAME: PG${{ matrix.pg }}${{ matrix.snapshot }} ${{ matrix.name }} ${{ matrix.os }} CI_STATS_DB: ${{ secrets.CI_STATS_DB }} GITHUB_EVENT_NAME: ${{ github.event_name }} GITHUB_REF_NAME: ${{ github.ref_name }} GITHUB_REPOSITORY: ${{ github.repository }} GITHUB_RUN_ATTEMPT: ${{ github.run_attempt }} GITHUB_RUN_ID: ${{ github.run_id }} GITHUB_RUN_NUMBER: ${{ github.run_number }} JOB_STATUS: ${{ job.status }} run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then GITHUB_PR_NUMBER="${{ github.event.number }}" else GITHUB_PR_NUMBER=0 fi export GITHUB_PR_NUMBER scripts/upload_ci_stats.sh ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/loader_check.yml�����������������������������������������������0000664�0000000�0000000�00000016441�15100345067�0022604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Check for loader changes "on": pull_request: types: [opened, synchronize, reopened, labeled, unlabeled] jobs: check_loader_change: name: Check for loader changes # Ignore loader changes if acknowledged already if: ${{ !contains(github.event.pull_request.labels.*.name, 'upgrade-requires-restart') }} runs-on: timescaledb-runner-arm64 steps: - name: Checkout source uses: actions/checkout@v4 - name: Check if the pull request changes the loader shell: bash --norc --noprofile {0} env: BODY: ${{ github.event.pull_request.body }} GH_TOKEN: ${{ github.token }} PR_NUMBER: ${{ github.event.pull_request.number }} run: | echo "$BODY" | egrep -qsi '^disable-check:.*\<loader-change\>' if [[ $? -ne 0 ]]; then # Get the list of modified files in this pull request files=$(gh pr view $PR_NUMBER --json files --jq '.files.[].path') # Check for loader changes if echo "${files}" | grep -Eq "^src/loader/.+$"; then echo "Warning: This PR changes the loader. Therefore, upgrading to the next TimescaleDB" echo "version requires a restart of PostgreSQL. Make sure to bump the loader version if" echo "necessary and coordinate the release with the cloud team before merging." echo echo "After the release is coordinated, add the 'upgrade-requires-restart' label" echo "to the PR to acknowledge this warning." echo echo "To disable this check, add this trailer to pull request message:" echo echo "Disable-check: loader-change" echo exit 1 fi fi check_loader_version_bump: name: Check if loader versions are incremented for required restart # If the label is present, validate the loader version is bumped if: ${{ contains(github.event.pull_request.labels.*.name, 'upgrade-requires-restart') }} runs-on: timescaledb-runner-arm64 steps: - name: Checkout source uses: actions/checkout@v4 with: fetch-depth: 0 - name: Checkout ${{ github.event.pull_request.base.ref }} branch run: git checkout ${{ github.event.pull_request.base.ref }} - name: Extract versions from ${{ github.event.pull_request.base.ref }} branch id: upstream-versions run: | # Extract version from bgw_interface.c BGW_VERSION_MAIN=$(grep -oP 'const int32 ts_bgw_loader_api_version = \K\d+' src/loader/bgw_interface.c || echo "0") echo "bgw_version_main=$BGW_VERSION_MAIN" >> $GITHUB_OUTPUT # Extract version from launcher_interface.c LAUNCHER_VERSION_MAIN=$(grep -oP '#define MIN_LOADER_API_VERSION \K\d+' src/bgw/launcher_interface.c || echo "0") echo "launcher_version_main=$LAUNCHER_VERSION_MAIN" >> $GITHUB_OUTPUT echo "${{ github.event.pull_request.base.ref }} branch:" echo "src/loader/bgw_interface.c:const int32 ts_bgw_loader_api_version = $BGW_VERSION_MAIN" echo "src/bgw/launcher_interface.c:#define MIN_LOADER_API_VERSION $LAUNCHER_VERSION_MAIN" - name: Checkout PR branch run: git checkout ${{ github.event.pull_request.head.sha }} - name: Extract versions from PR branch id: pr-versions run: | # Extract version from bgw_interface.c BGW_VERSION_PR=$(grep -oP 'const int32 ts_bgw_loader_api_version = \K\d+' src/loader/bgw_interface.c || echo "0") echo "bgw_version_pr=$BGW_VERSION_PR" >> $GITHUB_OUTPUT # Extract version from launcher_interface.c LAUNCHER_VERSION_PR=$(grep -oP '#define MIN_LOADER_API_VERSION \K\d+' src/bgw/launcher_interface.c || echo "0") echo "launcher_version_pr=$LAUNCHER_VERSION_PR" >> $GITHUB_OUTPUT echo "PR:" echo "src/loader/bgw_interface.c:const int32 ts_bgw_loader_api_version = $BGW_VERSION_PR" echo "src/bgw/launcher_interface.c:#define MIN_LOADER_API_VERSION $LAUNCHER_VERSION_PR" - name: Validate version increments run: | BGW_MAIN=${{ steps.upstream-versions.outputs.bgw_version_main }} BGW_PR=${{ steps.pr-versions.outputs.bgw_version_pr }} LAUNCHER_MAIN=${{ steps.upstream-versions.outputs.launcher_version_main }} LAUNCHER_PR=${{ steps.pr-versions.outputs.launcher_version_pr }} echo "Validating version increments..." echo "bgw_interface.c: $BGW_MAIN -> $BGW_PR (expected: $((BGW_MAIN + 1)))" echo "launcher_interface.c: $LAUNCHER_MAIN -> $LAUNCHER_PR (expected: $((LAUNCHER_MAIN + 1)))" VALIDATION_FAILED=false # Check bgw_interface version if [ "$BGW_PR" -ne "$((BGW_MAIN + 1))" ]; then echo "⌠ERROR: bgw_interface.c version should be incremented by 1, expected: $((BGW_MAIN + 1)), Found: $BGW_PR" VALIDATION_FAILED=true else echo "✅ bgw_interface.c version correctly incremented" fi # Check launcher_interface.c version if [ "$LAUNCHER_PR" -ne "$((LAUNCHER_MAIN + 1))" ]; then echo "⌠ERROR: launcher_interface.c version should be incremented by 1, expected: $((LAUNCHER_MAIN + 1)), Found: $LAUNCHER_PR" VALIDATION_FAILED=true else echo "✅ launcher_interface.c version correctly incremented" fi if [ "$VALIDATION_FAILED" = true ]; then echo "Version validation failed. Please ensure: Both version numbers are incremented by exactly 1 from ${{ github.event.pull_request.base.ref }} branch" exit 1 fi - name: Add comment to PR (if validation fails) if: failure() uses: actions/github-script@v7 with: script: | const bgwMain = '${{ steps.upstream-versions.outputs.bgw_version_main }}'; const bgwPr = '${{ steps.pr-versions.outputs.bgw_version_pr }}'; const launcherMain = '${{ steps.upstream-versions.outputs.launcher_version_main }}'; const launcherPr = '${{ steps.pr-versions.outputs.launcher_version_pr }}'; const comment = `## ⌠Loader Version Validation Failed The version numbers in your PR do not meet the requirements, to indicate a acknowledged loader change. | File | ${{ github.event.pull_request.base.ref }} | PR | Expected | |------|-------------|-----------|----------| | \`src/loader/bgw_interface.c:const int32 ts_bgw_loader_api_version\` | ${bgwMain} | ${bgwPr} | ${parseInt(bgwMain) + 1} | | \`src/bgw/launcher_interface.c:#define MIN_LOADER_API_VERSION\` | ${launcherMain} | ${launcherPr} | ${parseInt(launcherMain) + 1} | **Requirements:** Both version numbers must be incremented by 1 from the ${{ github.event.pull_request.base.ref }} branch. Please update the version numbers and push your changes.`; github.rest.issues.createComment({ issue_number: context.issue.number, owner: context.repo.owner, repo: context.repo.repo, body: comment }); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/memory-tests.yaml����������������������������������������������0000664�0000000�0000000�00000004465�15100345067�0023015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Memory tests "on": push: branches: - main - ?.*.x - memory_test - trigger/memory_test pull_request: paths: .github/workflows/memory-tests.yaml jobs: memory_leak: name: Memory leak on insert PG${{ matrix.pg }} runs-on: ubuntu-22.04 strategy: matrix: pg: [15, 16, 17, 18] fail-fast: false steps: - name: Install Dependencies run: | sudo apt-get update sudo apt-get install gnupg systemd-coredump gdb postgresql-common libkrb5-dev python3-psutil yes | sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh sudo apt-get update sudo apt-get install postgresql-${{ matrix.pg }} postgresql-server-dev-${{ matrix.pg }} - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Build TimescaleDB run: | PATH="/usr/lib/postgresql/${{ matrix.pg }}/bin:$PATH" ./bootstrap -DCMAKE_BUILD_TYPE=Release make -C build sudo make -C build install - name: Setup database run: | sudo pg_createcluster ${{matrix.pg}} main sudo tee -a /etc/postgresql/${{ matrix.pg }}/main/postgresql.conf <<-CONF shared_preload_libraries = 'timescaledb' max_worker_processes = 0 log_destination = syslog max_wal_size = 8GB max_wal_senders = 0 wal_level = minimal checkpoint_timeout = 20min log_checkpoints = on bgwriter_lru_maxpages = 0 track_counts = off fsync = off port = 5432 CONF sudo grep port /etc/postgresql/${{ matrix.pg }}/main/postgresql.conf sudo systemctl start postgresql@${{ matrix.pg }}-main.service sudo -u postgres psql -X -c "CREATE USER runner SUPERUSER LOGIN;" - name: Run insert memory test run: | sudo -u postgres python ./scripts/test_memory_spikes.py & sleep 5 \ && psql -d postgres -v ECHO=all -X -f scripts/out_of_order_random_direct.sql - name: Run generic memory test run: | sudo -u postgres python ./scripts/test_memory_spikes.py & sleep 5 \ && psql -d postgres -v ECHO=all -X -f scripts/memory_leaks.sql - name: Postgres log if: always() run: | sudo journalctl -u postgresql@${{ matrix.pg }}-main.service �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/nightly_cloud_smoke_test.yaml����������������������������������0000664�0000000�0000000�00000007613�15100345067�0025444�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Nightly - Update smoke test on release branch # QA: run the upgrade smoke tests with the last 10 releases # against the the next version. # Requires upstream GitHub action to deploy the last commit # from the release branch to the QA service in Cloud "on": #schedule: # - cron: '0 0 * * *' workflow_dispatch: pull_request: paths: - .github/workflows/nightly_cloud_smoke_test.yaml - scripts/test_update_smoke.sh - test/sql/updates/*.sql jobs: get-next-version: runs-on: ubuntu-latest outputs: next_version: ${{ steps.fetch.outputs.next_version }} steps: - name: Get next version # Get newest release branch with most recent commits id: fetch run: | RELEASE_BRANCH=$(git ls-remote --heads https://github.com/timescale/timescaledb.git | \ grep -Eo 'refs/heads/[2-9]+\.[0-9]+\.x' | \ sed 's|refs/heads/||' | \ sort -V | \ tail -n1) echo "current release branch: ${RELEASE_BRANCH}" curl --fail -o version.config "https://raw.githubusercontent.com/timescale/timescaledb/refs/heads/${RELEASE_BRANCH}/version.config" NEXT_VERSION=$(head -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) echo "next version: ${NEXT_VERSION} .." echo "next_version=${NEXT_VERSION}" >> "$GITHUB_OUTPUT" generate-matrix: runs-on: ubuntu-latest outputs: matrix: ${{ steps.set-matrix.outputs.matrix }} steps: - name: Fetch TimescaleDB releases id: fetch-releases run: | releases=$(curl -s \ -H "Accept: application/vnd.github.v3+json" \ "https://api.github.com/repos/timescale/timescaledb/releases?per_page=10" \ | jq -r '.[].tag_name') # Convert to JSON array format for matrix matrix_json=$(echo "$releases" | jq -R -s -c 'split("\n") | map(select(length > 0))') echo "releases=$matrix_json" >> $GITHUB_OUTPUT # Also output for debugging echo "Found releases:" echo "$releases" - name: Set matrix output id: set-matrix run: | matrix='{"version": ${{ steps.fetch-releases.outputs.releases }}}' echo "matrix=$matrix" >> $GITHUB_OUTPUT echo $matrix test-version: needs: [generate-matrix, get-next-version] runs-on: ubuntu-latest strategy: # run sequentially matrix: ${{ fromJson(needs.generate-matrix.outputs.matrix) }} max-parallel: 1 fail-fast: false steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Install Dependencies # we want the right version of Postgres for handling any dump file run: | sudo apt-get update sudo apt-get install gnupg postgresql-common yes | sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh sudo apt-get update sudo apt-get install postgresql-17 - name: "Run update smoke test with v${{ matrix.version }} to ${{needs.get-next-version.outputs.next_version}}" # Now run the test. Currently the cloud instance is always up. # only run the test if the versions are not equal run: | PATH="/usr/lib/postgresql/17/bin:$PATH" ./scripts/test_update_smoke.sh \ ${{ matrix.version }} \ ${{needs.get-next-version.outputs.next_version}} \ "${{ secrets.DB_TEAM_QA_SERVICE_CONNECTION_STRING }}" - name: Show logs if: always() run: | ls -l /tmp/smoketest*/* cat /tmp/smoketest*/* - name: Upload Artifacts # Save the logs, so if there is a failure we'll have a better # chance to understand what went wrong. if: failure() uses: actions/upload-artifact@v4 with: name: Cloud Update test smoke path: /tmp/smoketest*/* ���������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/pg_ladybug.yaml������������������������������������������������0000664�0000000�0000000�00000003056�15100345067�0022455�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: pg_ladybug "on": pull_request: push: branches: - main - ?.*.x jobs: pg_ladybug: runs-on: ubuntu-latest env: CC: clang-19 CXX: clang++-19 LLVM_CONFIG: llvm-config-19 steps: - name: Install dependencies run: | sudo apt-get update sudo apt-get purge llvm-16 llvm-17 llvm-18 clang-16 clang-17 clang-18 sudo apt-get install llvm-19 llvm-19-dev clang-19 libclang-19-dev clang-tidy-19 libcurl4-openssl-dev sudo ln -sf /usr/bin/clang-tidy-19 /usr/bin/clang-tidy - name: Checkout timescaledb uses: actions/checkout@v4 - name: Checkout pg_ladybug uses: actions/checkout@v4 with: repository: 'timescale/pg_ladybug' path: 'pg_ladybug' ref: '0.1.0' - name: build pg_ladybug run: | cd pg_ladybug cmake -S . -B build -DLLVM_ROOT=/usr/lib/llvm-19 make -C build sudo make -C build install - name: Verify pg_ladybug run: | clang-tidy --load /usr/local/lib/libPostgresCheck.so --checks='-*,postgres-*' --list-checks | grep postgres - name: Configure timescaledb run: | # installing postgres headers pulls in llvm-17 which confuses pg_ladybug build process so we install this here instead of at beginning sudo apt-get install postgresql-server-dev-16 ./bootstrap -DCMAKE_BUILD_TYPE=Debug -DLINTER=ON -DCLANG_TIDY_EXTRA_OPTS=",-*,postgres-*;--load=/usr/local/lib/libPostgresCheck.so" - name: Build timescaledb run: | make -C build ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/pg_upgrade-test.yaml�������������������������������������������0000664�0000000�0000000�00000010304�15100345067�0023424�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: pg_upgrade test "on": push: branches: - main - ?.*.x pull_request: jobs: pg_upgrade_test: name: pg_upgrade test from PG${{ matrix.pg_version_old }} to PG${{ matrix.pg_version_new }} runs-on: 'ubuntu-latest' strategy: matrix: include: - pg_version_old: 15 # 15 to 16 pg_version_new: 16 - pg_version_old: 15 # 15 to 17 pg_version_new: 17 - pg_version_old: 16 # 16 to 17 pg_version_new: 17 fail-fast: false env: OUTPUT_DIR: ${{ github.workspace }}/pg_upgrade_test steps: - name: Install Linux Dependencies run: | sudo apt-get update sudo apt-get install pip postgresql-common libkrb5-dev - name: Install testgres run: | pip install testgres - name: Install PostgreSQL ${{ matrix.pg_version_old}} and ${{ matrix.pg_version_new }} run: | yes | sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh echo "deb https://packagecloud.io/timescale/timescaledb/ubuntu/ $(lsb_release -c -s) main" | sudo tee /etc/apt/sources.list.d/timescaledb.list wget --quiet -O - https://packagecloud.io/timescale/timescaledb/gpgkey | sudo apt-key add - sudo apt-get update sudo apt-get install -y \ postgresql-${{ matrix.pg_version_old }} postgresql-server-dev-${{ matrix.pg_version_old }} \ postgresql-${{ matrix.pg_version_new }} postgresql-server-dev-${{ matrix.pg_version_new }} sudo apt-get install -y --no-install-recommends \ timescaledb-2-postgresql-${{ matrix.pg_version_old }} \ timescaledb-2-postgresql-${{ matrix.pg_version_new }} - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Build and install TimescaleDB on PostgreSQL ${{ matrix.pg_version_old}} env: BUILD_DIR: pg${{ matrix.pg_version_old }} run: | PATH="/usr/lib/postgresql/${{ matrix.pg_version_old }}/bin:$PATH" ./bootstrap -DCMAKE_BUILD_TYPE=Release -DWARNINGS_AS_ERRORS=OFF -DASSERTIONS=ON -DLINTER=OFF -DGENERATE_DOWNGRADE_SCRIPT=OFF -DREGRESS_CHECKS=OFF -DTAP_CHECKS=OFF make -j -C pg${{ matrix.pg_version_old }} sudo make -j -C pg${{ matrix.pg_version_old }} install - name: Build and install TimescaleDB on PostgreSQL ${{ matrix.pg_version_new}} env: BUILD_DIR: pg${{ matrix.pg_version_new }} run: | PATH="/usr/lib/postgresql/${{ matrix.pg_version_new }}/bin:$PATH" ./bootstrap -DCMAKE_BUILD_TYPE=Release -DWARNINGS_AS_ERRORS=OFF -DASSERTIONS=ON -DLINTER=OFF -DGENERATE_DOWNGRADE_SCRIPT=OFF -DREGRESS_CHECKS=OFF -DTAP_CHECKS=OFF make -j -C pg${{ matrix.pg_version_new }} sudo make -j -C pg${{ matrix.pg_version_new }} install - name: Run pg_upgrade test env: PGVERSIONOLD: ${{ matrix.pg_version_old }} PGVERSIONNEW: ${{ matrix.pg_version_new }} DIFFFILE: ${{ env.OUTPUT_DIR }}/upgrade_check.diff run: | scripts/test_pg_upgrade.py diff -u \ "${OUTPUT_DIR}/post.pg${PGVERSIONOLD}.log" \ "${OUTPUT_DIR}/post.pg${PGVERSIONNEW}.log" | \ tee "${DIFFFILE}" if [[ -s "${DIFFFILE}" ]]; then echo "pg_upgrade test for ${PGVERSIONOLD} -> ${PGVERSIONNEW} failed" exit 1 fi - name: Show pg_upgrade diffs if: always() env: DIFFFILE: ${{ env.OUTPUT_DIR }}/upgrade_check.diff DIROLD: pg${{ matrix.pg_version_old }} DIRNEW: pg${{ matrix.pg_version_new }} run: | cd ${OUTPUT_DIR} cat ${DIFFFILE} tar czf /tmp/pg_upgrade_artifacts.tgz \ ${DIFFFILE} \ ${OUTPUT_DIR}/*.log \ ${OUTPUT_DIR}/${DIROLD}/logs/* \ ${OUTPUT_DIR}/${DIRNEW}/logs/* \ ${OUTPUT_DIR}/${DIRNEW}/data/pg_upgrade_output.d/* - name: Upload pg_upgrade logs if: always() uses: actions/upload-artifact@v4 with: name: pg_upgrade logs from ${{ matrix.pg_version_old }} to ${{ matrix.pg_version_new }} path: /tmp/pg_upgrade_artifacts.tgz ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/pgspot.yaml����������������������������������������������������0000664�0000000�0000000�00000012136�15100345067�0021653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test our extension sql scripts are following security best practices name: pgspot "on": pull_request: push: branches: - main - ?.*.x jobs: pgspot: runs-on: ubuntu-latest env: # time_bucket with offset is intentional without explicit search_path to allow for inlining # policy_compression, policy_compression_execute, cagg_migrate_execute_plan and cagg_migrate # do not have explicit search_path because this would prevent them doing transaction control PGSPOT_OPTS: --ignore PS002 --proc-without-search-path 'extschema.time_bucket(bucket_width interval,ts timestamp,"offset" interval)' --proc-without-search-path 'extschema.time_bucket(bucket_width interval,ts timestamptz,"offset" interval)' --proc-without-search-path 'extschema.time_bucket(bucket_width interval,ts date,"offset" interval)' --proc-without-search-path 'extschema.recompress_chunk(chunk regclass,if_not_compressed boolean)' --proc-without-search-path '_timescaledb_internal.policy_compression(job_id integer,config jsonb)' --proc-without-search-path '_timescaledb_functions.policy_compression(job_id integer,config jsonb)' --proc-without-search-path '_timescaledb_internal.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean,use_creation_time boolean)' --proc-without-search-path '_timescaledb_functions.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean,use_creation_time boolean)' --proc-without-search-path '_timescaledb_functions.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean,use_creation_time boolean,useam boolean)' --proc-without-search-path '_timescaledb_internal.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean)' --proc-without-search-path '_timescaledb_functions.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean)' --proc-without-search-path '_timescaledb_internal.cagg_migrate_execute_plan(_cagg_data _timescaledb_catalog.continuous_agg)' --proc-without-search-path '_timescaledb_functions.cagg_migrate_execute_plan(_cagg_data _timescaledb_catalog.continuous_agg)' --proc-without-search-path 'extschema.cagg_migrate(cagg regclass,override boolean,drop_old boolean)' --proc-without-search-path '_timescaledb_functions.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean,reindex_enabled boolean,use_creation_time boolean,useam boolean)' --proc-without-search-path '_timescaledb_functions.policy_compression_execute(job_id integer,htid integer,lag anyelement,maxchunks integer,verbose_log boolean,recompress_enabled boolean,reindex_enabled boolean,use_creation_time boolean)' steps: - name: Setup python 3.13 uses: actions/setup-python@v5 with: python-version: '3.13' - name: Checkout timescaledb uses: actions/checkout@v4 - name: Install pgspot run: | python -m pip install pgspot==0.9.1 - name: Build timescaledb sqlfiles run: | previous_version=$(grep '^previous_version = ' version.config | sed -e 's!^[^=]\+ = !!') git fetch --tags ./bootstrap -DGENERATE_DOWNGRADE_SCRIPT=ON git checkout ${previous_version} make -C build sqlfile sqlupdatescripts git checkout ${GITHUB_SHA} make -C build sqlfile sqlupdatescripts ls -la build/sql/timescaledb--*.sql - name: Run pgspot run: | version=$(grep '^version = ' version.config | sed -e 's!^[^=]\+ = !!') previous_version=$(grep '^previous_version = ' version.config | sed -e 's!^[^=]\+ = !!') # Show files used ls -la build/sql/timescaledb--${version}.sql build/sql/timescaledb--${previous_version}--${version}.sql \ build/sql/timescaledb--${version}--${previous_version}.sql # The next pgspot execution tests the installation script by itself pgspot ${{ env.PGSPOT_OPTS }} build/sql/timescaledb--${version}.sql # The next pgspot execution tests the update script to the latest version # we prepend the installation script here so pgspot can correctly keep track of created objects pgspot ${{ env.PGSPOT_OPTS }} -a build/sql/timescaledb--${previous_version}.sql \ build/sql/timescaledb--${previous_version}--${version}.sql # The next pgspot execution tests the downgrade script to the previous version # we prepend the installation script here so pgspot can correctly keep track of created objects pgspot ${{ env.PGSPOT_OPTS }} -a build/sql/timescaledb--${version}.sql \ build/sql/timescaledb--${version}--${previous_version}.sql ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/pr-approvals.yaml����������������������������������������������0000664�0000000�0000000�00000004621�15100345067�0022765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# All PRs except trivial ones should require 2 approvals, since this a global setting # we cannot make this decision from github configuration alone. So we set the required # approved in github to 1 and make this check required which will enforce 2 approvals # unless overwritten or only CI files are touched. name: PR Approval Check "on": pull_request: types: [opened, synchronize, reopened, edited, auto_merge_enabled, auto_merge_disabled] branches: [main] pull_request_review: jobs: check_approvals: name: Check for sufficient approvals runs-on: timescaledb-runner-arm64 steps: - name: Checkout source uses: actions/checkout@v4 - name: Check for sufficient approvals shell: bash --norc --noprofile {0} env: GH_TOKEN: ${{ github.token }} PR_NUMBER: ${{ github.event.pull_request.number }} run: | set -eu echo "PR number is $PR_NUMBER" BODY=$(gh pr view $PR_NUMBER -q .body --json body) if ! echo "$BODY" | egrep -qsi '^disable-check:.*\<approval-count\>' then # Get the list of modified files in this pull request echo "Modified files: " gh pr view $PR_NUMBER --json files # Get the number of modified files, but exclude those that # are workflow files. These require only a single # reviewer. files=$(gh pr view $PR_NUMBER --json files --jq '[.files.[].path | select(startswith(".github") | not)] | length') # Get the number of approvals in this pull request echo "Reviews: " gh pr view $PR_NUMBER --json reviews approvals=$( gh pr view $PR_NUMBER --json reviews --jq ' [ .reviews.[] | select(.authorAssociation == "MEMBER" and .state == "APPROVED") ] | length ' ) echo "approvals: $approvals, files: $files" if [[ $approvals -lt 2 && $files -gt 0 ]] ; then echo "This pull request requires 2 approvals before merging." echo echo "For trivial changes, you may disable this check by adding this trailer to the pull request message:" echo echo "Disable-check: approval-count" echo exit 1 fi fi ���������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/pr-handling.yaml�����������������������������������������������0000664�0000000�0000000�00000002625�15100345067�0022544�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Assign PR to author and reviewers # This workflow runs on the pull_request_target event: # https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target. # # So the secrets are accessible even if the PR was opened from an external # repository. This is done because the GitHub API key needs to be accessed # to modify the PRs. # # NOTE: Only API calls should be made in the actions defined here. The # committed code should _NOT_ be touched in any case. "on": pull_request_target: types: [ opened, reopened, ready_for_review ] jobs: assign-pr: name: Assign PR to author runs-on: ubuntu-latest steps: - uses: toshimaru/auto-author-assign@v2.1.0 ask-review: name: Run pull-review runs-on: ubuntu-latest if: ${{ !github.event.pull_request.draft && github.event.pull_request.base.ref == 'main' }} steps: - uses: actions/checkout@v4 - name: Run pull-review with docker env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} OWNER: ${{ github.repository_owner }} REPO: ${{ github.event.repository.name }} PULL_REQUEST_NUMBER : ${{ github.event.pull_request.number }} shell: bash run: | PR_URL="https://github.com/${OWNER}/${REPO}/pull/${PULL_REQUEST_NUMBER}" docker run ghcr.io/imsky/pull-review "$PR_URL" --github-token "${GITHUB_TOKEN}" �����������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/pr-validation.yaml���������������������������������������������0000664�0000000�0000000�00000004240�15100345067�0023105�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Pull Request Validation "on": pull_request: types: [opened, synchronize, reopened, edited, auto_merge_enabled, auto_merge_disabled] branches: [main] jobs: # Count the number of commits in a pull request. This can be # disabled by adding a trailer line of the following form to the # pull request message: # # Disable-Check: commit-count # # The check is case-insensitive and ignores other contents on the # line as well, so it is possible to add several different checks if # that is necessary. # # It is assumed that the trailer is following RFC2822 conventions, # but this is currently not enforced. count_commits: name: Enforce single commit pull request runs-on: timescaledb-runner-arm64 steps: - name: Checkout source uses: actions/checkout@v4 with: ref: ${{ github.event.pull_request.head.sha }} fetch-depth: 0 - name: Dump GitHub context (for debugging) env: GITHUB_CONTEXT: ${{ toJSON(github) }} run: | echo "GITHUB_CONTEXT: $GITHUB_CONTEXT" - name: Check number of commits shell: bash --norc --noprofile {0} env: BODY: ${{ github.event.pull_request.body }} run: | echo "$BODY" | egrep -qsi '^disable-check:.*\<commit-count\>' if [[ $? -ne 0 ]] && [[ "${{ github.event.pull_request.auto_merge.merge_method }}" != "squash" ]] then base=${{ github.event.pull_request.base.sha }} head=${{ github.event.pull_request.head.sha }} count=`git rev-list --no-merges --count $base..$head` if [[ "$count" -ne 1 ]]; then echo "Found $count commits in pull request (there should be only one):" git log --format=format:'- %h %s' $base..$head echo echo "To disable commit count, add this trailer to pull request message:" echo echo "Disable-check: commit-count" echo echo "Trailers follow RFC2822 conventions, so no whitespace" echo "before field name and the check is case-insensitive for" echo "both the field name and the field body." exit 1 fi fi ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/prerelease-sanity.yaml�����������������������������������������0000664�0000000�0000000�00000004011�15100345067�0023764�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Prerelease Sanity "on": push: branches: - prerelease_test pull_request: branches: "?.*.x" paths: - version.config - .github/workflows/prerelease-sanity.yaml workflow_dispatch: jobs: check_release_commit: name: Check Release Commit runs-on: timescaledb-runner-arm64 steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 # GitHub creates an empty merge commit even for fast-fordward merges, which # makes it needlessly difficult to inspect the actual commit title. Since # we require the PRs to release branches to be up to date before merging, # we can just work with the PR head here. with: ref: ${{ github.event.pull_request.head.sha }} fetch-depth: 2 # The combined changelog must reference all changes, and the respective # change files in the .unreleased folder must be deleted. - name: No .unreleased files are left behind run: | ! compgen -G .unreleased/* # The messages of the release commit and tag must start with Release <version>. # If this is the release tag, it must point to the release commit # and not something else. - name: The release commit message references the respective version run: | required_title=$(sed -n "s/^version = /Release /p" version.config) echo $required_title tag_title=$(git log --oneline -1 --pretty=format:%s) echo $tag_title grep "$required_title" <<<"$tag_title" # Our reference might be a tag, so check the pointed-to commit as well, # using the ^0 git path specification to find it. commit_title=$(git log --oneline -1 --pretty=format:%s @^0) echo $commit_title grep "$required_title" <<<"$commit_title" # The release commit must modify the version.config - name: The release commit modifies the version.config run: | git log --oneline -1 @^0 git log --oneline -1 @^0~ ! git diff --exit-code @^0~ @^0 -- version.config �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/release_build_packages.yml�������������������������������������0000664�0000000�0000000�00000016146�15100345067�0024640�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: "Packaging: Build distributions" "on": release: types: [published] jobs: update: runs-on: ubuntu-latest steps: - name: Initialize build summary run: | echo "# 📦 Distribution Package Build Summary" >> $GITHUB_STEP_SUMMARY echo "" >> $GITHUB_STEP_SUMMARY echo "**Version:** \`${{ github.event.release.tag_name }}\`" >> $GITHUB_STEP_SUMMARY echo "**URL:** [${{ github.event.release.name }}](${{ github.event.release.html_url }})" >> $GITHUB_STEP_SUMMARY echo "**Triggered at:** $(date -u '+%Y-%m-%d %H:%M:%S UTC')" >> $GITHUB_STEP_SUMMARY echo "" >> $GITHUB_STEP_SUMMARY echo "## 🚀 Build Status" >> $GITHUB_STEP_SUMMARY echo "| Package | Status | Workflow |" >> $GITHUB_STEP_SUMMARY echo "| --- | --- | --- |" >> $GITHUB_STEP_SUMMARY echo "" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=false" >> $GITHUB_ENV - name: Build Docker Image env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "🳠Triggering Docker image build..." | tee -a build.log if gh workflow run docker-image.yml -R timescale/timescaledb-docker -f version=${{ github.event.release.tag_name }} -f tag_latest=true -f registry=prod; then echo "| 🳠Docker Image | ✅ Triggered | [timescaledb-docker](https://github.com/timescale/timescaledb-docker/actions/workflows/docker-image.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| 🳠Docker Image | ⌠Failed | [timescaledb-docker](https://github.com/timescale/timescaledb-docker/actions/workflows/docker-image.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Build Debian Packages env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "🧠Triggering Debian package build..." | tee -a build.log if gh workflow run timescaledb-debian.yml -R timescale/release-build-scripts -f version=${{ github.event.release.tag_name }} -f upload-artifacts=true; then echo "| 🧠Debian Packages | ✅ Triggered | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-debian.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| 🧠Debian Packages | ⌠Failed | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-debian.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Build Ubuntu Packages env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "🟠 Triggering Ubuntu package build..." | tee -a build.log if gh workflow run timescaledb-ubuntu.yml -R timescale/release-build-scripts -f version=${{ github.event.release.tag_name }} -f upload-artifacts=true; then echo "| 🟠 Ubuntu Packages | ✅ Triggered | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-ubuntu.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| 🟠 Ubuntu Packages | ⌠Failed | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-ubuntu.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Build ARM64 APT Packages env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "💪 Triggering ARM64 APT package build..." | tee -a build.log if gh workflow run timescaledb-apt-arm64.yml -R timescale/release-build-scripts -f version=${{ github.event.release.tag_name }} -f upload-artifacts=true; then echo "| 💪 ARM64 APT Packages | ✅ Triggered | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-apt-arm64.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| 💪 ARM64 APT Packages | ⌠Failed | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-apt-arm64.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Build RPM Packages env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "⚙ Triggering RPM package build..." | tee -a build.log if gh workflow run timescaledb-rpm.yml -R timescale/release-build-scripts -f version=${{ github.event.release.tag_name }} -f upload-artifacts=true; then echo "| ⚙ RPM Packages | ✅ Triggered | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-rpm.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| ⚙ RPM Packages | ⌠Failed | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-rpm.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Build Homebrew Packages env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "🺠Triggering Homebrew package build..." | tee -a build.log if gh workflow run timescaledb-homebrew.yml -R timescale/release-build-scripts -f version=${{ github.event.release.tag_name }} -f upload-artifacts=true; then echo "| 🺠Homebrew Packages | ✅ Triggered | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-homebrew.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| 🺠Homebrew Packages | ⌠Failed | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-homebrew.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Build Windows Packages env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "🪟 Triggering Windows package build..." | tee -a build.log if gh workflow run timescaledb-windows.yml -R timescale/release-build-scripts -f version=${{ github.event.release.tag_name }} -f upload-artifacts=true; then echo "| 🪟 Windows Packages | ✅ Triggered | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-windows.yml) |" >> $GITHUB_STEP_SUMMARY else echo "| 🪟 Windows Packages | ⌠Failed | [summary](https://github.com/timescale/release-build-scripts/actions/workflows/timescaledb-windows.yml) |" >> $GITHUB_STEP_SUMMARY echo "HAS_FAILURES=true" >> $GITHUB_ENV fi - name: Generate final summary if: always() run: | echo "---" >> $GITHUB_STEP_SUMMARY echo "## 📋 Next Steps" >> $GITHUB_STEP_SUMMARY echo "" >> $GITHUB_STEP_SUMMARY echo "1. Monitor the triggered workflows in their respective repositories" >> $GITHUB_STEP_SUMMARY echo "2. Check build artifacts once workflows complete" >> $GITHUB_STEP_SUMMARY echo "3. Verify package availability in distribution channels" >> $GITHUB_STEP_SUMMARY - name: Validate workflow dispatch status if: ${{ env.HAS_FAILURES == 'true' }} run: | echo "---" >> $GITHUB_STEP_SUMMARY echo "⌠one or more workflows could not get dispatched" >> $GITHUB_STEP_SUMMARY exit 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/release_feature_freeze_ceremony.yaml���������������������������0000664�0000000�0000000�00000021147�15100345067�0026735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Release - Feature Freeze Ceremony # # Feature Freeze # # prereqs: # 0. needs approval from another person to run the action (environment) # 1. ensure the correct branch is used to execute the action # a. if the run was triggered from the `main` branch, the NEXT_VERSION must be a new minor (end with a .0) # b. if NEXT_VERSION is a patch release, then the branch the action was triggered on must be a release branch: `^[0-9]+\.[0-9]+\.x$` # 2. ensure the next version does not exist as tag yet # # Tasks # 0. bump minor -dev version in version.config on main, if and only if it's a .0 release # 1. creates the release branch X.Y.x, if and if the branch does not exist yet # 2. generates CHANGELOG and opens PR for it # 3. generates the release artefacts for the next versions # 4. bumps the version in version.config to minor + 1 if and only if a .0 release is done # on: workflow_dispatch: # The workflow needs the permission to push branches permissions: contents: write pull-requests: write jobs: validate-conditions: name: Validate Run Conditions runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Check Release Conditions run: | NEXT_VERSION=$(head -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) RELEASE_BRANCH="${NEXT_VERSION/%.[0-9]/.x}" echo "Checking run conditions for release: $NEXT_VERSION" >> $GITHUB_STEP_SUMMARY echo "Current branch: ${{ github.ref_name }}" >> $GITHUB_STEP_SUMMARY echo "Expected release branch: $RELEASE_BRANCH" >> $GITHUB_STEP_SUMMARY echo "" >> $GITHUB_STEP_SUMMARY # Condition: version tag can not exist if git tag -l | grep -q "^$NEXT_VERSION$"; then echo "⌠\`$NEXT_VERSION\` tag already exists" >> $GITHUB_STEP_SUMMARY exit 1 fi # Condition: minor releases (.0) must be triggered from the main branch if [[ "$NEXT_VERSION" =~ \.0$ ]] && [[ "${{ github.ref_name }}" != "main" ]]; then echo "⌠for minor releases, \`$NEXT_VERSION\` the \`main\` branch is required, but got \`${{ github.ref_name }}\`" >> $GITHUB_STEP_SUMMARY exit 1 fi # Condition: patch releases must be triggered from the release branch if [[ ! "$NEXT_VERSION" =~ \.0$ ]] && [[ "${{ github.ref_name }}" != "$RELEASE_BRANCH" ]]; then echo "⌠the patch releases, \`$NEXT_VERSION\` the action must be started from the release branch \`$RELEASE_BRANCH\`, but got \`${{ github.ref_name }}\`" >> $GITHUB_STEP_SUMMARY exit 1 fi echo "✅ All release conditions satisfied for \`$NEXT_RELEASE\`" >> $GITHUB_STEP_SUMMARY release-feature-freeze-ceremony: name: Release - Feature Freeze runs-on: ubuntu-latest needs: validate-conditions environment: name: Release Ceremonies steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 # git user config timescale-automation - run: | git config user.name "timescale-automation" git config user.email "123763385+github-actions[bot]@users.noreply.github.com" - name: Install Dependencies run: | sudo apt-get update sudo apt-get install pip pip install PyGithub requests # Read the next version and build the next versions - name: Set version configuration run: | NEXT_VERSION=$(head -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) CURRENT_VERSION=$(tail -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) RELEASE_BRANCH="${NEXT_VERSION/%.[0-9]/.x}" echo "RELEASE_BRANCH=${RELEASE_BRANCH}" >> $GITHUB_ENV echo "CURRENT_VERSION=${CURRENT_VERSION}" >> $GITHUB_ENV echo "NEXT_VERSION=${NEXT_VERSION}" >> $GITHUB_ENV echo "# 🚀 Release v${NEXT_VERSION}" >> $GITHUB_STEP_SUMMARY echo "Previous version: \`$CURRENT_VERSION\`" >> $GITHUB_STEP_SUMMARY echo "Release branch: \`$RELEASE_BRANCH\`" >> $GITHUB_STEP_SUMMARY echo "Workflow branch: \`${{ github.ref_name }}\`" >> $GITHUB_STEP_SUMMARY echo "" >> $GITHUB_STEP_SUMMARY # ------------------------------------------------------- # # Only running for new minor releases # # ------------------------------------------------------- # Bump minor in main for minor releases - uses: actions/checkout@v4 with: ref: main - name: Bump minor version on main if next release is a new minor if: endsWith(env.NEXT_VERSION, '.0') env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | NEXT_MAIN_VERSION=$(head -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) NEXT_MAIN_VERSION=$(echo "$NEXT_MAIN_VERSION" | awk -F. '{printf "%d.%d.0-dev", $1, $2 + 1}') sed -i "s/^version = .*/version = $NEXT_MAIN_VERSION/" version.config BRANCH="release/bump-main-to-$NEXT_MAIN_VERSION" git checkout -b $BRANCH git add version.config git commit -m "Increase minor version $NEXT_MAIN_VERSION" git push origin $BRANCH PR_URL=$(gh pr create \ --title "Increase minor version $NEXT_MAIN_VERSION" \ --body "Bump to next minor for the upcoming ${{ env.CURRENT_VERSION }} release" \ --base main \ --head $BRANCH \ --label "release") echo "* ✅ minor version increase on main: $PR_URL" >> $GITHUB_STEP_SUMMARY # Create `2.XX.x` release branch of `main` # Release branch is a dependency for the next steps # only execute this step on .0 releases - name: Create Release Branch env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | if git ls-remote --heads origin "${{ env.RELEASE_BRANCH }}" | grep -q "${{ env.RELEASE_BRANCH }}"; then echo "* ✓ the \`${{ env.RELEASE_BRANCH }}\` release branch exists" >> $GITHUB_STEP_SUMMARY else gh api repos/${{ github.repository }}/git/refs \ --method POST \ --field ref="refs/heads/${{ env.RELEASE_BRANCH }}" \ --field sha="${{ github.sha }}" echo "* ✅ the \`${{ env.RELEASE_BRANCH }}\` release branch created" >> $GITHUB_STEP_SUMMARY fi # ------------------------------------------------------- # # Runs for every release # # ------------------------------------------------------- # Generate the CHANGELOG and submit it in a separate PR - uses: actions/checkout@v4 with: ref: ${{ env.RELEASE_BRANCH }} - name: Generate and create Pull Request for CHANGELOG env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | ./scripts/changelog/generate.sh BODY=$(head -n 19 CHANGELOG.md | tail -n 20) BRANCH="release/${{ env.NEXT_VERSION }}-changelog" git checkout -b $BRANCH git add .unreleased/* CHANGELOG.md git commit -m "CHANGELOG ${{ env.NEXT_VERSION }}" git push origin $BRANCH PR_URL=$(gh pr create \ --title "Release ${{ env.NEXT_VERSION }}" \ --body "$BODY" \ --base ${{ env.RELEASE_BRANCH }} \ --head $BRANCH \ --label "release,changelog") echo "* ✅ CHANGELOG: $PR_URL" >> $GITHUB_STEP_SUMMARY # Rework version.config and up & down grade scripts - uses: actions/checkout@v4 with: ref: ${{ env.RELEASE_BRANCH }} - name: Generate release artefacts env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | ./scripts/release/build_release_artefacts.sh ${{ env.CURRENT_VERSION }} ${{ env.NEXT_VERSION }} BRANCH="release/${{ env.CURRENT_VERSION }}-${{ env.NEXT_VERSION }}" git checkout -b $BRANCH git add version.config sql/updates/*.sql sql/CMakeLists.txt git commit -m "release artefacts from ${{ env.CURRENT_VERSION }} to ${{ env.NEXT_VERSION }}" git push origin $BRANCH BODY="- CHANGELOG\n- set previous_version in version.config\n- adjust CMakeList.txt with up & down grade files" PR_URL=$(gh pr create \ --title "Release artefacts ${{ env.NEXT_VERSION }}" \ --body "${BODY//\\n/$\n}" \ --base ${{ env.RELEASE_BRANCH }} \ --head $BRANCH \ --label "release") echo "* ✅ Release artefacts: $PR_URL" >> $GITHUB_STEP_SUMMARY �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/release_post_release_ceremony.yaml�����������������������������0000664�0000000�0000000�00000011054�15100345067�0026423�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Release - Post Release Ceremony # # Post Release Workflow # # 0. trigger the generate GUCs workflow in the docs repo # 1. generate the artefacts to forward port to main and open PR for it # 2. bump the next patch number + 1 on the release branch and open PR for it # "on": release: types: [published] # The workflow needs the permission to a PR permissions: contents: write pull-requests: write jobs: docs: name: Post Release Ceremonies runs-on: ubuntu-latest steps: - name: Generate list of GUCs for docs env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | if gh workflow run tsdb-refresh-gucs-list.yaml -R timescale/docs -f tag=${{ github.event.release.tag_name }}; then echo "✅ Triggered generation of GUC list in docs" >> $GITHUB_STEP_SUMMARY else echo "⌠docs workflow to generate the GUCs failed" >> $GITHUB_STEP_SUMMARY fi - uses: actions/checkout@v4 with: ref: ${{ github.event.release.tag_name }} # git user config timescale-automation - run: | git config user.name "timescale-automation" git config user.email "123763385+github-actions[bot]@users.noreply.github.com" - name: Forward port changes to main env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | ./scripts/release/build_post_release_artefacts.sh ${{ github.event.release.tag_name }} BRANCH="release/${{ github.event.release.tag_name }}-main" git checkout -b $BRANCH git add version.config sql/updates/*.sql sql/CMakeLists.txt .unreleased/* CHANGELOG.md git commit -m "forward port release artefacts of ${{ github.event.release.tag_name }} to main" git push origin $BRANCH printf '%b- CHANGELOG\n- set previous_version in version.config\n- adjust CMakeList.txt with up & down grade files\n- removed .unreleased files' > $BODY PR_URL=$(gh pr create \ --title "Forwardport ${{ github.event.release.tag_name }}" \ --body "$BODY" \ --base main \ --head $BRANCH \ --label "release") echo "✅ Forward ported release artefacts: $PR_URL" >> $GITHUB_STEP_SUMMARY - name: Get next versions run: | TAGGED_VERSION=$(head -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) if [[ "$TAGGED_VERSION" != "$${{ github.event.release.tag_name }}" ]]; then echo "The tag: ${{ github.event.release.tag_name }} and the release version ${TAGGED_VERSION} do not match." >&2 echo "⌠tagged version ${{ github.event.release.tag_name }} is not matching the current version $TAGGED_VERSION" >> $GITHUB_STEP_SUMMARY exit 1 fi RELEASE_BRANCH="${TAGGED_VERSION/%.d/.x}" NEXT_VERSION=$(echo "$TAGGED_VERSION" | awk -F. '{printf "%d.%d.%d", $1, $2, $3+1}') echo "TAGGED_VERSION=${TAGGED_VERSION}" >> $GITHUB_ENV echo "RELEASE_BRANCH=${RELEASE_BRANCH}" >> $GITHUB_ENV echo "NEXT_VERSION=${NEXT_VERSION}" >> $GITHUB_ENV - uses: actions/checkout@v4 with: ref: ${{ env.RELEASE_BRANCH }} - name: Bump to next version on release branch env: GITHUB_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | echo "Tagged version: ${{ env.TAGGED_VERSION }}" echo "Next version: ${{ env.NEXT_VERSION }}" # adjust version.config file sed -i \ -e "s/^version = .*/version = ${{ env.NEXT_VERSION }}/" \ -e "s/^previous_version = .*/previous_version = ${{ env.TAGGED_VERSION }}/" \ version.config echo "✅ setting next patch version ${{ env.TAGGED_VERSION }} in version.config" >> $GITHUB_STEP_SUMMARY cat version.config >> $GITHUB_STEP_SUMMARY BRANCH="release/bump-${{ github.event.release.tag_name }}-to-${{ env.NEXT_VERSION }}" git checkout -b $BRANCH git add version.config git commit -m "Bump to next patch version ${{ env.NEXT_VERSION }}" git push origin $BRANCH PR_URL=$(gh pr create \ --title "Forwardport ${{ github.event.release.tag_name }}" \ --body "Change to the next patch version ${{ env.NEXT_VERSION }} after the release of ${{ github.event.release.tag_name }}." \ --base $RELEASE_BRANCH \ --head $BRANCH \ --label "release") echo "✅ Bump to next patch version: $PR_URL" >> $GITHUB_STEP_SUMMARY ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/rpm-packages.yaml����������������������������������������������0000664�0000000�0000000�00000011465�15100345067�0022715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test rpm package installation for latest version name: "Packaging tests: RPM" "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' pull_request: paths: .github/workflows/rpm-packages.yaml push: tags: - '*' branches: - release_test - trigger/package_test workflow_dispatch: jobs: rpm_tests: name: RPM ${{ matrix.image }} PG${{ matrix.pg }} ${{ matrix.license }} runs-on: ubuntu-latest container: image: ${{ matrix.image }} strategy: fail-fast: false matrix: image: [ "rockylinux:8", "rockylinux:9" ] pg: [ 15, 16, 17 ] license: [ "TSL", "Apache"] include: - license: Apache pkg_suffix: "-oss" steps: - name: Add postgres repositories run: "yum install -y \"https://download.postgresql.org/pub/repos/yum/reporpms/\ EL-$(rpm -E %{rhel})-x86_64/pgdg-redhat-repo-latest.noarch.rpm\"" - name: Add other repositories run: | tee /etc/yum.repos.d/timescale_timescaledb.repo <<EOL [timescale_timescaledb] name=timescale_timescaledb baseurl=https://packagecloud.io/timescale/timescaledb/el/$(rpm -E %{rhel})/\$basearch repo_gpgcheck=1 gpgcheck=0 enabled=1 gpgkey=https://packagecloud.io/timescale/timescaledb/gpgkey sslverify=1 sslcacert=/etc/pki/tls/certs/ca-bundle.crt metadata_expire=300 EOL - name: Install timescaledb run: | yum update -y if [[ "$(rpm -E %{rhel})" -eq "8" ]]; then dnf -qy module disable postgresql; fi yum install -y timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }} sudo wget sudo -u postgres /usr/pgsql-${{ matrix.pg }}/bin/initdb -D /var/lib/pgsql/${{ matrix.pg }}/data timescaledb-tune --quiet --yes --pg-config /usr/pgsql-${{ matrix.pg }}/bin/pg_config - name: List available versions run: | yum --showduplicates list timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }} - name: Show files in package run: | rpm -ql timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }} - uses: actions/checkout@v3 - name: Read versions id: versions run: | # read expected version from version.config # version will only be a proper version in a release branch so we use previous_version # as fallback for main if grep '^version = [0-9.]\+$' version.config; then version=$(grep '^version = ' version.config | sed -e 's!^version = !!') else version=$(grep '^previous_version = ' version.config | sed -e 's!^previous_version = !!') fi echo "version=${version}" >>$GITHUB_OUTPUT - name: Test Installation run: | sudo -u postgres /usr/pgsql-${{ matrix.pg }}/bin/pg_ctl -D /var/lib/pgsql/${{ matrix.pg }}/data start while ! /usr/pgsql-${{ matrix.pg }}/bin/pg_isready; do sleep 1; done sudo -u postgres psql -X -c "CREATE EXTENSION timescaledb" \ -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb';" installed_version=$(sudo -u postgres psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" | sed -e 's! !!g') if [ "${{ steps.versions.outputs.version }}" != "$installed_version" ];then false fi - name: Test Downgrade run: | # Since this runs nightly on main we have to get the previous version # from the last released version and not current branch. prev_version=$(wget --quiet -O - \ https://raw.githubusercontent.com/timescale/timescaledb/${{ steps.versions.outputs.version }}/version.config \ | grep previous_version | sed -e 's!previous_version = !!') yum downgrade -y timescaledb-2${{ matrix.pkg_suffix }}-postgresql-${{ matrix.pg }}-${prev_version} sudo -u postgres psql -X -c "ALTER EXTENSION timescaledb UPDATE TO '${prev_version}'" \ -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb';" installed_version=$(sudo -u postgres psql -X -t \ -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" | sed -e 's! !!g') if [ "$prev_version" != "$installed_version" ];then false fi - name: Install toolkit if: matrix.pg != 17 && matrix.image != 'rockylinux:9' # timescaledb-toolkit currently not available for PG17 and Rocky9 run: | yum install -y timescaledb-toolkit-postgresql-${{ matrix.pg }} - name: List available toolkit versions if: matrix.pg != 17 && matrix.image != 'rockylinux:9' # timescaledb-toolkit currently not available for PG17 and Rocky9 run: | yum --showduplicates list timescaledb-toolkit-postgresql-${{ matrix.pg }} �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/sanitizer-build-and-test.yaml����������������������������������0000664�0000000�0000000�00000024156�15100345067�0025166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Run regression tests under memory sanitizer name: Sanitizer test "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' push: branches: - main - ?.*.x - trigger/sanitizer pull_request: paths: .github/workflows/sanitizer-build-and-test.yaml workflow_dispatch: env: name: "Sanitizer" PG_SRC_DIR: "pgbuild" PG_INSTALL_DIR: "postgresql" extra_packages: "clang-15 llvm-15 llvm-15-dev llvm-15-tools" llvm_config: "llvm-config-15" CLANG: "clang-15" CC: "clang-15" CXX: "clang-15" # gcc CFLAGS, disable inlining for function name pattern matching to work for suppressions # CFLAGS: "-g -fsanitize=address,undefined -fno-omit-frame-pointer -O1 -fno-inline" # CXXFLAGS: "-g -fsanitize=address,undefined -fno-omit-frame-pointer -O1 -fno-inline" # clang CFLAGS CFLAGS: "-g -fsanitize=address,undefined -fno-omit-frame-pointer -Og -fno-inline-functions" CXXFLAGS: "-g -fsanitize=address,undefined -fno-omit-frame-pointer -Og -fno-inline-functions" # We do not link libasan dynamically to avoid problems with libdl and our libraries. # clang does this by default, but we need to explicitly state that for gcc. # static gcc LDFLAGS # LDFLAGS: "-fsanitize=address,undefined -static-libasan -static-liblsan -static-libubsan" # static sanitizer clang LDFLAGS or dynamic sanitizer gcc LDFLAGS LDFLAGS: "-fsanitize=address,undefined" ASAN_OPTIONS: suppressions=${{ github.workspace }}/scripts/suppressions/suppr_asan.txt detect_odr_violation=0 log_path=${{ github.workspace }}/sanitizer_logs/sanitizer log_exe_name=true print_suppressions=false exitcode=27 detect_leaks=0 abort_on_error=1 LSAN_OPTIONS: suppressions=${{ github.workspace }}/scripts/suppressions/suppr_leak.txt print_suppressions=0 log_path=${{ github.workspace }}/sanitizer_logs/sanitizer log_exe_name=true print_suppressions=false exitcode=27 UBSAN_OPTIONS: suppressions=${{ github.workspace }}/scripts/suppressions/suppr_ub.txt print_stacktrace=1 halt_on_error=1 log_path=${{ github.workspace }}/sanitizer_logs/sanitizer log_exe_name=true print_suppressions=false exitcode=27 IGNORES: >- bgw_db_scheduler bgw_db_scheduler_fixed merge_append_partially_compressed net telemetry EXTENSIONS: "postgres_fdw test_decoding" jobs: config: runs-on: ubuntu-latest outputs: pg_latest: ${{ steps.setter.outputs.PG_LATEST }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Read configuration id: setter run: python .github/gh_config_reader.py sanitizer: # Change the JOB_NAME variable below when changing the name. # Don't use the env variable here because the env context is not accessible. name: PG${{ matrix.pg }} Sanitizer ${{ matrix.os }} runs-on: ${{ matrix.os }} needs: config strategy: fail-fast: false matrix: # "os" has to be in the matrix due to a bug in "env": https://github.community/t/how-to-use-env-context/16975 os: ["ubuntu-22.04"] pg: ${{ fromJson(needs.config.outputs.pg_latest) }} steps: - name: Install Linux Dependencies run: | sudo apt-get update sudo apt-get install flex bison lcov systemd-coredump gdb libipc-run-perl \ libtest-most-perl jq ${{ env.extra_packages }} - name: Checkout TimescaleDB uses: actions/checkout@v4 # We are going to rebuild Postgres daily, so that it doesn't suddenly break # ages after the original problem. - name: Get date for build caching id: get-date run: | echo "date=$(date +"%d")" >> $GITHUB_OUTPUT # Create a directory for sanitizer logs. This directory is referenced by # ASAN_OPTIONS, LSAN_OPTIONS, and UBSAN_OPTIONS - name: Create sanitizer log directory run: | mkdir ${{ github.workspace }}/sanitizer_logs # we cache the build directory instead of the install directory here # because extension installation will write files to install directory # leading to a tainted cache - name: Cache PostgreSQL ${{ matrix.pg }} id: cache-postgresql uses: actions/cache@v4 with: path: ~/${{ env.PG_SRC_DIR }} key: "${{ matrix.os }}-${{ env.name }}-postgresql-${{ matrix.pg }}-${{ env.CC }}\ -${{ steps.get-date.outputs.date }}-${{ hashFiles('.github/**') }}" - name: Build PostgreSQL ${{ matrix.pg }} if not in cache if: steps.cache-postgresql.outputs.cache-hit != 'true' run: | wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/source/v${{ matrix.pg }}/postgresql-${{ matrix.pg }}.tar.bz2 mkdir -p ~/$PG_SRC_DIR tar --extract --file postgresql.tar.bz2 --directory ~/$PG_SRC_DIR --strip-components 1 # Add instrumentation to the Postgres memory contexts. For more details, see # https://github.com/timescale/eng-database/wiki/Using-Address-Sanitizer#adding-more-instrumentation PG_MAJOR=$(echo "${{ matrix.pg }}" | sed -e 's![.].*!!') if [ ${PG_MAJOR} -lt 18 ]; then patch -F5 -p1 -d ~/$PG_SRC_DIR < test/postgres-asan-instrumentation.patch else patch -F5 -p1 -d ~/$PG_SRC_DIR < test/postgres-asan-instrumentation-PG18GE.patch fi cd ~/$PG_SRC_DIR ./configure --prefix=$HOME/$PG_INSTALL_DIR --enable-debug --enable-cassert \ --with-openssl --without-readline --without-zlib --without-libxml make -j$(nproc) for ext in ${EXTENSIONS}; do make -j$(nproc) -C contrib/${ext} done - name: Upload config.log if: always() && steps.cache-postgresql.outputs.cache-hit != 'true' uses: actions/upload-artifact@v4 with: name: config.log for PostgreSQL ${{ matrix.os }} ${{ env.name }} ${{ matrix.pg }} path: ~/${{ env.PG_SRC_DIR }}/config.log - name: Install PostgreSQL ${{ matrix.pg }} run: | cd ~/$PG_SRC_DIR make install for ext in ${EXTENSIONS}; do make -C contrib/${ext} install done ~/$PG_INSTALL_DIR/bin/pg_config --version - name: Build TimescaleDB run: | ./bootstrap -DCMAKE_BUILD_TYPE=Debug -DPG_SOURCE_DIR=~/$PG_SRC_DIR \ -DPG_PATH=~/$PG_INSTALL_DIR -DCODECOVERAGE=OFF -DREQUIRE_ALL_TESTS=ON \ -DTEST_GROUP_SIZE=5 -DTEST_PG_LOG_DIRECTORY="$(readlink -f .)" make -j$(nproc) -C build make -C build install - name: make installcheck run: | set -o pipefail # IGNORE some test since they fail under ASAN. make -k -C build installcheck IGNORES="${IGNORES}" \ PSQL="${HOME}/${PG_INSTALL_DIR}/bin/psql" | tee installcheck.log - name: Show regression diffs if: always() id: collectlogs run: | find . -name regression.diffs -exec cat {} + > regression.log if [[ "${{ runner.os }}" == "Linux" ]] ; then # wait in case there are in-progress coredumps sleep 10 if coredumpctl -q list >/dev/null; then echo "coredumps=true" >>$GITHUB_OUTPUT; fi # print OOM killer information sudo journalctl --system -q --facility=kern --grep "Killed process" || true fi if [[ -s regression.log ]]; then echo "regression_diff=true" >>$GITHUB_OUTPUT; fi grep -e 'FAILED' -e 'failed (ignored)' -e 'not ok' installcheck.log || true cat regression.log - name: Save regression diffs if: always() && steps.collectlogs.outputs.regression_diff == 'true' uses: actions/upload-artifact@v4 with: name: Regression diff ${{ matrix.os }} ${{ env.name }} ${{ matrix.pg }} path: | regression.log installcheck.log - name: Save PostgreSQL log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL log ${{ matrix.os }} ${{ env.name }} ${{ matrix.pg }} path: postmaster.* - name: Stack trace if: always() && steps.collectlogs.outputs.coredumps == 'true' run: | sudo coredumpctl gdb <<<" set verbose on set trace-commands on show debug-file-directory printf "'"'"query = '%s'\n\n"'"'", debug_query_string frame function ExceptionalCondition printf "'"'"condition = '%s'\n"'"'", conditionName up 1 l info args info locals bt full " 2>&1 | tee stacktrace.log ./scripts/bundle_coredumps.sh - name: Show sanitizer logs if: always() run: | tail -vn +1 ${{ github.workspace }}/sanitizer_logs/sanitizer* || : - name: Coredumps if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Coredumps ${{ matrix.os }} ${{ env.name }} ${{ matrix.pg }} path: coredumps - name: Upload sanitizer logs if: always() uses: actions/upload-artifact@v4 with: name: sanitizer logs ${{ matrix.os }} ${{ env.name }} ${{ matrix.pg }} # The log_path sanitizer option means "Write logs to 'log_path.pid'". # https://github.com/google/sanitizers/wiki/SanitizerCommonFlags path: ${{ github.workspace }}/sanitizer_logs/* - name: Upload test results to the database if: always() env: # GitHub Actions allow you neither to use the env context for the job name, # nor to access the job name from the step context, so we have to # duplicate it to work around this nonsense. JOB_NAME: PG${{ matrix.pg }} ${{ env.name }} ${{ matrix.os }} CI_STATS_DB: ${{ secrets.CI_STATS_DB }} GITHUB_EVENT_NAME: ${{ github.event_name }} GITHUB_REF_NAME: ${{ github.ref_name }} GITHUB_REPOSITORY: ${{ github.repository }} GITHUB_RUN_ATTEMPT: ${{ github.run_attempt }} GITHUB_RUN_ID: ${{ github.run_id }} GITHUB_RUN_NUMBER: ${{ github.run_number }} JOB_STATUS: ${{ job.status }} run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then GITHUB_PR_NUMBER="${{ github.event.number }}" else GITHUB_PR_NUMBER=0 fi export GITHUB_PR_NUMBER scripts/upload_ci_stats.sh ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/shellcheck-ignored.yaml����������������������������������������0000664�0000000�0000000�00000001057�15100345067�0024071�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Ignoring version of the corresponding workflow. These files are # needed to run required workflows even when the real workflow is not # executed because some files were ignored. name: Shellcheck "on": pull_request: paths-ignore: - '**.sh' - .github/workflows/shellcheck.yaml push: branches: - main - prerelease_test paths-ignore: - '**.sh' - .github/workflows/shellcheck.yaml jobs: shellcheck: name: Shellcheck runs-on: ubuntu-latest steps: - run: | echo "No build required" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/shellcheck.yaml������������������������������������������������0000664�0000000�0000000�00000001153�15100345067�0022441�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test our shell scripts for bugs name: Shellcheck "on": pull_request: paths: - '**.sh' - .github/workflows/shellcheck.yaml push: branches: - main - ?.*.x paths: - '**.sh' - .github/workflows/shellcheck.yaml jobs: shellcheck: name: Shellcheck runs-on: ubuntu-latest steps: - name: Install Dependencies run: | sudo apt-get update sudo apt-get install shellcheck - name: Checkout TimescaleDB uses: actions/checkout@v4 with: fetch-depth: 0 - name: Run shellcheck run: scripts/shellcheck-ci.sh ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/snapshot-abi.yaml����������������������������������������������0000664�0000000�0000000�00000014221�15100345067�0022724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test ABI versions against snapshot # # name: ABI Test Against Snapshot "on": schedule: # run daily 20:00 on main branch - cron: '0 20 * * *' push: branches: - ?.*.x - trigger/snapshot-abi pull_request: paths: .github/workflows/snapshot-abi.yaml workflow_dispatch: jobs: config: runs-on: ubuntu-latest outputs: pg15_abi_min: ${{ steps.config.outputs.pg15_abi_min }} pg16_abi_min: ${{ steps.config.outputs.pg16_abi_min }} pg17_abi_min: ${{ steps.config.outputs.pg17_abi_min }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Read configuration id: config run: python .github/gh_config_reader.py abi_snapshot_test: name: ABI Snapshot Test PG${{ matrix.pg }} runs-on: ubuntu-latest needs: config env: PG_SRC_DIR: pgbuild PG_INSTALL_DIR: postgresql PG_EXTENSIONS: postgres_fdw test_decoding strategy: fail-fast: false matrix: pg: [ 15, 16, 17 ] ignores: - 'net telemetry bgw_launcher' include: - pg: 15 abi_min: ${{ fromJson(needs.config.outputs.pg15_abi_min) }} - pg: 16 abi_min: ${{ fromJson(needs.config.outputs.pg16_abi_min) }} - pg: 17 abi_min: ${{ fromJson(needs.config.outputs.pg17_abi_min) }} steps: - name: Install Linux Dependencies run: | # Don't add ddebs here because the ddebs mirror is always 503 Service Unavailable. # If needed, install them before opening the core dump. sudo apt-get update sudo apt-get install flex bison lcov systemd-coredump gdb libipc-run-perl \ libtest-most-perl pkgconf icu-devtools clang-14 llvm-14 llvm-14-dev llvm-14-tools cmake - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Download Postgres ${{ matrix.pg }} run: | wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/source/v${{ matrix.abi_min }}/postgresql-${{ matrix.abi_min }}.tar.bz2 mkdir -p ~/$PG_SRC_DIR tar --extract --file postgresql.tar.bz2 --directory ~/$PG_SRC_DIR --strip-components 1 cd ~/$PG_SRC_DIR ./configure --prefix=$HOME/$PG_INSTALL_DIR --with-openssl \ --without-readline --without-zlib --without-libxml --without-llvm make -j $(nproc) for ext in $PG_EXTENSIONS; do make -j $(nproc) -C contrib/${ext} done - name: Install postgresql ${{ matrix.pg }} run: | cd ~/$PG_SRC_DIR make install for ext in $PG_EXTENSIONS; do make -C contrib/${ext} install done echo "$HOME/$PG_INSTALL_DIR/bin" >> "${GITHUB_PATH}" - name: Build TimescaleDB run: | ./bootstrap -DCMAKE_BUILD_TYPE=Debug \ -DPG_SOURCE_DIR=~/$PG_SRC_DIR -DPG_PATH=~/$PG_INSTALL_DIR \ -DWARNINGS_AS_ERRORS=OFF -DREQUIRE_ALL_TESTS=ON \ -DTEST_PG_LOG_DIRECTORY="$(readlink -f .)" make -j $(nproc) -C build make -C build install mkdir -p build/install_ext build/install_lib cp `pg_config --sharedir`/extension/timescaledb*.{control,sql} build/install_ext cp `pg_config --pkglibdir`/timescaledb*.so build/install_lib - name: Download Postgres ${{ matrix.pg }}-snapshot run: | wget -q -O postgresql.tar.bz2 \ https://ftp.postgresql.org/pub/snapshot/${{ matrix.pg }}/postgresql-${{ matrix.pg }}-snapshot.tar.bz2 mkdir -p ~/$PG_SRC_DIR-snapshot tar --extract --file postgresql.tar.bz2 --directory ~/$PG_SRC_DIR-snapshot --strip-components 1 cd ~/$PG_SRC_DIR-snapshot ./configure --prefix=$HOME/$PG_INSTALL_DIR-snapshot --with-openssl \ --without-readline --without-zlib --without-libxml --without-llvm make -j $(nproc) for ext in $PG_EXTENSIONS; do make -j $(nproc) -C contrib/${ext} done - name: Install PostgreSQL ${{ matrix.pg }}-snapshot run: | cd ~/$PG_SRC_DIR-snapshot make install for ext in $PG_EXTENSIONS; do make -C contrib/${ext} install done echo "$HOME/$PG_INSTALL_DIR-snapshot/bin" >> "${GITHUB_PATH}" - name: Copy extension files to postgresql ${{ matrix.pg }}-snapshot run: | BUILD_DIR=build_snapshot ./bootstrap -DCMAKE_BUILD_TYPE=Debug \ -DPG_SOURCE_DIR=~/$PG_SRC_DIR-snapshot -DPG_PATH=~/$PG_INSTALL_DIR-snapshot \ -DWARNINGS_AS_ERRORS=ON -DREQUIRE_ALL_TESTS=ON \ -DTEST_PG_LOG_DIRECTORY="$(readlink -f .)" cp build/install_ext/* `pg_config --sharedir`/extension/ cp build/install_lib/* `pg_config --pkglibdir` - name: make regresscheck id: regresscheck run: | set -o pipefail make -k -C build_snapshot installcheck IGNORES="${{ matrix.ignores }}" | tee installcheck.log - name: Show regression diffs if: always() id: collectlogs run: | find . -name regression.diffs -exec cat {} + > regression.log if [[ "${{ runner.os }}" == "Linux" ]] ; then # wait in case there are in-progress coredumps sleep 10 if coredumpctl -q list >/dev/null; then echo "coredumps=true" >>$GITHUB_OUTPUT; fi # print OOM killer information sudo journalctl --system -q --facility=kern --grep "Killed process" || true elif [[ "${{ runner.os }}" == "macOS" ]] ; then if [ $(find /cores -type f | wc -l) -gt 0 ]; then echo "coredumps=true" >>$GITHUB_OUTPUT; fi fi if [[ -s regression.log ]]; then echo "regression_diff=true" >>$GITHUB_OUTPUT; fi grep -e 'FAILED' -e 'failed (ignored)' -e 'not ok' installcheck.log || true cat regression.log - name: Save regression diffs if: always() && steps.collectlogs.outputs.regression_diff == 'true' uses: actions/upload-artifact@v4 with: name: Regression diff Snapshot ABI Breakage PG${{ matrix.pg }} path: regression.log - name: Save postmaster.log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL log Snapshot ABI Breakage PG${{ matrix.pg }} path: postmaster.log �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/sqlsmith.yaml��������������������������������������������������0000664�0000000�0000000�00000013217�15100345067�0022204�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: SQLsmith "on": schedule: # run daily 2:00 on main branch - cron: '0 2 * * *' workflow_dispatch: push: branches: - sqlsmith - main - ?.*.x pull_request: paths: .github/workflows/sqlsmith.yaml jobs: sqlsmith: # Change the JOB_NAME variable below when changing the name. # Don't use the env variable here because the env context is not accessible. name: SQLsmith PG${{ matrix.pg }} runs-on: ${{ matrix.os }} strategy: matrix: os: ["ubuntu-22.04"] pg: [ "15", "16", "17", "18" ] build_type: ["Debug"] fail-fast: false env: PG_SRC_DIR: pgbuild PG_INSTALL_DIR: postgresql JOB_NAME: SQLsmith PG${{ matrix.pg }} steps: - name: Install Dependencies run: | sudo apt-get update sudo apt-get install gnupg systemd-coredump gdb postgresql-common \ libkrb5-dev build-essential autoconf autoconf-archive \ libboost-regex-dev libsqlite3-dev jq yes | sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh sudo apt-get purge postgresql* sudo apt-get install libpqxx-dev postgresql-${{ matrix.pg }} postgresql-server-dev-${{ matrix.pg }} # Make sure the system postgres service is not running. sudo systemctl mask postgresql sudo systemctl stop postgresql { psql -c "select 1" && exit 1 ; } || : - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Build TimescaleDB run: | ./bootstrap -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DWARNINGS_AS_ERRORS=OFF make -j$(nproc) -C build sudo make -C build install - name: Checkout sqlsmith uses: actions/checkout@v4 with: repository: 'timescale/sqlsmith' path: 'sqlsmith' ref: 'timescaledb' - name: Build SQLsmith run: | cd sqlsmith autoreconf -i ./configure make -j$(nproc) - name: Setup test environment run: | mkdir ~/pgdata /usr/lib/postgresql/${{ matrix.pg }}/bin/pg_ctl initdb -D ~/pgdata /usr/lib/postgresql/${{ matrix.pg }}/bin/pg_ctl -D ~/pgdata start \ -o "-cshared_preload_libraries=timescaledb" -o "-cmax_connections=200" \ -o "-cmax_prepared_transactions=100" -o "-cunix_socket_directories=/tmp" \ -o "-clog_statement=all" -o "-clogging_collector=true" \ -o "-clog_destination=jsonlog,stderr" -o "-clog_directory=$(readlink -f .)" \ -o "-clog_error_verbosity=verbose" -o "-clog_filename=postmaster.log" psql -h /tmp postgres -c 'CREATE DATABASE smith;' psql -h /tmp smith -c 'CREATE EXTENSION timescaledb;' psql -h /tmp smith -c '\i ${{ github.workspace }}/tsl/test/shared/sql/include/shared_setup.sql' psql -h /tmp smith -c '\i ${{ github.workspace }}/tsl/test/shared/sql/include/cagg_compression_setup.sql' # we run these in a loop to reinitialize the random number generator # 10000 queries seems to take roughly 4 minutes in CI # so total runtime should be around 200 minutes in nightly run and 40 minutes otherwise - name: Run SQLsmith run: | set -xeu set -o pipefail if [ "${{ github.event_name }}" == "schedule" ]; then LOOPS=20 else LOOPS=10 fi cd sqlsmith for _ in $(seq 1 $LOOPS) do ./sqlsmith --seed=$((16#$(openssl rand -hex 3))) --exclude-catalog \ --target="host=/tmp dbname=smith" --max-queries=10000 \ 2>&1 | tee -a sqlsmith.log psql "host=/tmp dbname=smith" -c "select 1" done - name: Check for coredumps if: always() id: collectlogs run: | # wait for in progress coredumps sleep 10 if coredumpctl list; then echo "coredumps=true" >>$GITHUB_OUTPUT false fi - name: Stack trace if: always() && steps.collectlogs.outputs.coredumps == 'true' run: | sudo coredumpctl gdb <<<" set verbose on set trace-commands on show debug-file-directory printf "'"'"query = '%s'\n\n"'"'", (char *) debug_query_string frame function ExceptionalCondition printf "'"'"condition = '%s'\n"'"'", (char *) conditionName up 1 l info args info locals bt full " 2>&1 | tee stacktrace.log ./scripts/bundle_coredumps.sh false - name: Upload Coredumps if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Coredumps sqlsmith ${{ matrix.os }} PG${{ matrix.pg }} path: coredumps - name: Save PostgreSQL log if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: PostgreSQL log for PG${{ matrix.pg }} path: postgres.* - name: Upload test results to the database if: always() env: CI_STATS_DB: ${{ secrets.CI_STATS_DB }} GITHUB_EVENT_NAME: ${{ github.event_name }} GITHUB_REF_NAME: ${{ github.ref_name }} GITHUB_REPOSITORY: ${{ github.repository }} GITHUB_RUN_ATTEMPT: ${{ github.run_attempt }} GITHUB_RUN_ID: ${{ github.run_id }} GITHUB_RUN_NUMBER: ${{ github.run_number }} JOB_STATUS: ${{ job.status }} run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then GITHUB_PR_NUMBER="${{ github.event.number }}" else GITHUB_PR_NUMBER=0 fi export GITHUB_PR_NUMBER scripts/upload_ci_stats.sh ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/stalebot.yaml��������������������������������������������������0000664�0000000�0000000�00000004215�15100345067�0022153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: 'Close stale issues' "on": schedule: - cron: '30 1 * * *' workflow_dispatch: jobs: stale: runs-on: ubuntu-latest steps: - uses: actions/stale@v9 with: stale-issue-message: " Dear Author, \n\n This issue has been automatically marked as stale due to lack of activity. With only the issue description that is currently provided, we do not have enough information to take action. If you have or find the answers we would need, please reach out. Otherwise, this issue will be closed in 30 days. \n\n Thank you! " close-issue-message: " Dear Author, \n\n We are closing this issue due to lack of activity. Feel free to add a comment to this issue if you can provide more information and we will re-open it. \n\n Thank you! " # Don't process PRs days-before-stale: -1 # Process only issues days-before-issue-stale: 60 days-before-issue-close: 30 # Add this label after 'days-before-issue-stale' days to mark it as stale stale-issue-label: 'no-activity' # Label added when issues are closed. Can be used to identify issues closed by the stale bot. close-issue-label: 'closed-by-bot' # Process only issues that contain the label 'waiting-for-author' only-labels: 'waiting-for-author' # Stale only issues with one of these labels # # Disabled because some issues are marked wait-for-author # while, e.g., 'bug' is removed because it wasn't a bug. # # any-of-issue-labels: 'bug,enhancement,stale-issue' # Exclude issues with the 'in-progress' label exempt-issue-labels: 'in-progress' # Exclude assigned issues # # Removed because people often forget to unassign. They will # be notified by the stale-bot when issue is marked as stale. # #exempt-all-assignees: true �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/trigger-package-tests.yaml�������������������������������������0000664�0000000�0000000�00000001277�15100345067�0024537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Trigger the Pre-Release tests # # Params: # ref: branch, tag or SHA to checkout, defaults to `main` # name: Trigger Packaging tests on: workflow_dispatch: inputs: ref: description: "branch, tag or SHA to checkout" required: true default: "main" jobs: trigger_tests: runs-on: ubuntu-latest steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 with: ref: ${{ github.event.inputs.ref }} token: ${{ secrets.ORG_AUTOMATION_TOKEN }} - name: Push to package_test branch env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | git push origin HEAD:trigger/package_test --force ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/trigger-prerelease-tests.yaml����������������������������������0000664�0000000�0000000�00000001273�15100345067�0025267�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Trigger the Pre-Release tests # # Params: # ref: branch, tag or SHA to checkout, defaults to `main` # name: Trigger Pre-Release tests on: workflow_dispatch: inputs: ref: description: "branch, tag or SHA to checkout" required: true default: "main" jobs: trigger_tests: runs-on: ubuntu-latest steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 with: ref: ${{ github.event.inputs.ref }} token: ${{ secrets.ORG_AUTOMATION_TOKEN }} - name: Push to pre-release branch env: GH_TOKEN: ${{ secrets.ORG_AUTOMATION_TOKEN }} run: | git push origin HEAD:prerelease_test --force �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/update-test.yaml�����������������������������������������������0000664�0000000�0000000�00000005765�15100345067�0022610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������name: Test Update and Downgrade "on": push: branches: - main - ?.*.x pull_request: workflow_dispatch: jobs: update_test: name: Update test PG${{ matrix.pg }} runs-on: 'ubuntu-latest' strategy: matrix: pg: [15, 16, 17] fail-fast: false env: PG_VERSION: ${{ matrix.pg }} POSTGRES_HOST_AUTH_METHOD: trust steps: - name: Checkout TimescaleDB uses: actions/checkout@v4 - name: Install Dependencies run: | sudo apt-get update sudo apt-get install gnupg systemd-coredump gdb postgresql-common libkrb5-dev yes | sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh echo "deb https://packagecloud.io/timescale/timescaledb/ubuntu/ $(lsb_release -c -s) main" | sudo tee /etc/apt/sources.list.d/timescaledb.list wget --quiet -O - https://packagecloud.io/timescale/timescaledb/gpgkey | sudo apt-key add - sudo apt-get update sudo apt-get install postgresql-${{ matrix.pg }} postgresql-server-dev-${{ matrix.pg }} sudo apt-get install -y --no-install-recommends timescaledb-2-postgresql-${{ matrix.pg }} git fetch --tags - name: Update tests PG${{ matrix.pg }} run: | PATH="/usr/lib/postgresql/${{ matrix.pg }}/bin:$PATH" ./scripts/test_updates.sh - name: Downgrade tests PG${{ matrix.pg }} if: always() run: | PATH="/usr/lib/postgresql/${{ matrix.pg }}/bin:$PATH" ./scripts/test_downgrade.sh - name: Update diff if: failure() run: | find update_test -name "*.diff" | xargs -IFILE sh -c "echo '\nFILE\n';cat FILE" - name: Postgres Errors if: failure() run: | find update_test -name postgres.log -exec grep ERROR {} \; - name: Check for coredumps if: always() id: collectlogs run: | # wait for in progress coredumps sleep 10 if coredumpctl list; then echo "coredumps=true" >>$GITHUB_OUTPUT false fi - name: Stack trace if: always() && steps.collectlogs.outputs.coredumps == 'true' run: | sudo coredumpctl gdb <<<" set verbose on set trace-commands on show debug-file-directory printf "'"'"query = '%s'\n\n"'"'", (char *) debug_query_string frame function ExceptionalCondition printf "'"'"condition = '%s'\n"'"'", (char *) conditionName up 1 l info args info locals bt full " 2>&1 | tee stacktrace.log ./scripts/bundle_coredumps.sh false - name: Upload Coredumps if: always() && steps.collectlogs.outputs.coredumps == 'true' uses: actions/upload-artifact@v4 with: name: Coredumps update-test ${{ matrix.os }} PG${{ matrix.pg }} path: coredumps - name: Upload Artifacts if: failure() uses: actions/upload-artifact@v4 with: name: Update test PG${{ matrix.pg }} path: update_test �����������timescaledb-2.23.0/.github/workflows/windows-build-and-test-ignored.yaml����������������������������0000664�0000000�0000000�00000002453�15100345067�0026271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Ignoring version of the corresponding workflow. These files are # needed to run required workflows even when the real workflow is not # executed because some files were ignored. name: Regression Windows "on": push: branches: - main paths: - '!**' - '**.md' - CHANGELOG - 'LICENSE*' - NOTICE - 'bootstrap*' pull_request: paths: - '!**' - '**.md' - CHANGELOG - 'LICENSE*' - NOTICE - 'bootstrap*' jobs: config: runs-on: ubuntu-latest outputs: build_type: ${{ steps.build_type.outputs.build_type }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Set build_type id: build_type run: | if [[ "${{ github.event_name }}" == "pull_request" ]]; then echo "build_type=['Debug']" >>$GITHUB_OUTPUT else echo "build_type=['Debug','Release']" >>$GITHUB_OUTPUT fi build: name: PG${{ matrix.pg }} ${{ matrix.build_type }} ${{ matrix.os }} runs-on: ubuntu-latest needs: config strategy: fail-fast: false matrix: pg: [ 15, 16, 17, 18 ] os: [ windows-2022 ] build_type: ${{ fromJson(needs.config.outputs.build_type) }} steps: - run: | echo "No build required" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/windows-build-and-test.yaml������������������������������������0000664�0000000�0000000�00000033511�15100345067�0024643�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test building the extension on Windows name: Regression Windows "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' push: branches: - main - ?.*.x - trigger/windows_tests paths-ignore: - '**.md' - 'LICENSE*' - NOTICE - 'bootstrap*' pull_request: paths-ignore: - '**.md' - 'LICENSE*' - NOTICE - 'bootstrap*' workflow_dispatch: jobs: config: runs-on: ubuntu-latest outputs: build_type: ${{ steps.build_type.outputs.build_type }} pg15_latest: ${{ steps.config.outputs.pg15_latest }} pg16_latest: ${{ steps.config.outputs.pg16_latest }} pg17_latest: ${{ steps.config.outputs.pg17_latest }} pg18_latest: ${{ steps.config.outputs.pg18_latest }} steps: - name: Checkout source code uses: actions/checkout@v4 - name: Read configuration id: config run: python .github/gh_config_reader.py - name: Set build_type id: build_type run: | if [[ "${{ github.event_name }}" == "pull_request" ]]; then echo "build_type=['Debug']" >>$GITHUB_OUTPUT else echo "build_type=['Debug','Release']" >>$GITHUB_OUTPUT fi build: # Change the JOB_NAME variable below when changing the name. name: PG${{ matrix.pg }} ${{ matrix.build_type }} windows runs-on: windows-2025 needs: config strategy: fail-fast: false matrix: pg: [ 15, 16, 17 ] build_type: ${{ fromJson(needs.config.outputs.build_type) }} pg_config: ["-cfsync=off -cstatement_timeout=60s"] include: - pg: 15 pg_version: ${{ needs.config.outputs.pg15_latest }} - pg: 16 pg_version: ${{ needs.config.outputs.pg16_latest }} - pg: 17 pg_version: ${{ needs.config.outputs.pg17_latest }} # - pg: 18 # pg_version: ${{ needs.config.outputs.pg18_latest }} env: # PostgreSQL configuration PGPORT: 55432 PGDATA: pgdata TABLESPACE1: D:\tablespace1\ TABLESPACE2: D:\tablespace2\ IGNORES: >- bgw_launcher chunk_adaptive compress_bloom_sparse_compat compress_bloom_sparse_debug compress_qualpushdown_saop compression_algos compression_uuid direct_compress_copy merge_append_partially_compressed metadata telemetry vector_agg_byte vector_agg_filter vector_agg_groupagg vector_agg_grouping vector_agg_text vector_agg_uuid vectorized_aggregation ${{ matrix.pg < 16 && 'columnar_scan_cost' || '' }} SKIPS: >- bgw_db_scheduler bgw_db_scheduler_fixed steps: - name: Remove Existing PostgreSQL shell: powershell run: | # Search for any installed application package containing 'PostgreSQL' in the name. $PostgresPackages = Get-Package -Name "*PostgreSQL*" -Provider Programs -ErrorAction SilentlyContinue if ($PostgresPackages) { Write-Host "Found $($PostgresPackages.Count) PostgreSQL package(s) to uninstall." # Use Uninstall-Package with -Force for a silent, non-interactive removal. $PostgresPackages | Uninstall-Package -Force # Manually remove common installation paths and data folders # to ensure no conflicts with the new installation. Remove-Item "C:\Program Files\PostgreSQL" -Recurse -Force -ErrorAction SilentlyContinue Remove-Item "C:\PostgreSQL" -Recurse -Force -ErrorAction SilentlyContinue } else { Write-Host "No registered PostgreSQL installation found. Skipping uninstall step." } - name: Setup WSL uses: Vampire/setup-wsl@v3.1.4 with: distribution: Debian - name: Configure apt retries and timeout in WSL shell: wsl-bash {0} run: | echo 'Acquire::Retries "10";' >> /etc/apt/apt.conf.d/99retries echo 'Acquire::http::Timeout "240";' >> /etc/apt/apt.conf.d/99retries echo 'Acquire::https::Timeout "240";' >> /etc/apt/apt.conf.d/99retries - name: Install additional packages in WSL shell: wsl-bash {0} run: | # Workaround for https://github.com/Vampire/setup-wsl/issues/76 sed -i 's#ftp.debian.org/debian bullseye-backports#archive.debian.org/debian bullseye-backports#' /etc/apt/sources.list apt-get update apt-get install --yes --no-install-recommends cmake gawk gcc git gnupg jq make postgresql-client postgresql-common tree - name: Configure git # Since we want to reuse the checkout in the WSL environment # we have to prevent git from changing the line ending in the # shell scripts as that would break them. run: | git config --global core.autocrlf false git config --global core.eol lf - name: Checkout TimescaleDB source uses: actions/checkout@v4 # We are going to rebuild Postgres daily, so that it doesn't suddenly break # ages after the original problem. - name: Get date for build caching id: get-date env: WSLENV: GITHUB_OUTPUT/p shell: wsl-bash {0} run: | echo "date=$(date +"%d")" >> $GITHUB_OUTPUT # Use a cache for the PostgreSQL installation to speed things up # and avoid unnecessary package downloads. Since we only save # the directory containing the binaries, the runs with a cache # hit won't have PostgreSQL installed with a running service # since the installer never runs. We therefore install with # --extract-only and launch our own test instance, which is # probably better anyway since it gives us more control. - name: Cache PostgreSQL installation uses: actions/cache@v4 id: cache-postgresql with: path: C:\Progra~1\PostgreSQL\${{ matrix.pg }} key: "${{ runner.os }}-build-pg${{ matrix.pkg_version }}\ -${{ steps.get-date.outputs.date }}-${{ hashFiles('.github/**') }}" - name: Install PostgreSQL ${{ matrix.pg }} (using ${{ matrix.pg_version }}) if: github.event_name != 'schedule' && steps.cache-postgresql.outputs.cache-hit != 'true' run: | $version = ${{ matrix.pg_version }} $version = $version.Replace('"', '') + "-1" winget install --id PostgreSQL.PostgreSQL.${{ matrix.pg }} --version $version --force --accept-source-agreements --accept-package-agreements --disable-interactivity # This is for nightly builds. Here we pick the latest version of the package. - name: Install PostgreSQL ${{ matrix.pg }} if: github.event_name == 'schedule' && steps.cache-postgresql.outputs.cache-hit != 'true' run: | winget install --id PostgreSQL.PostgreSQL.${{ matrix.pg }} --force --accept-source-agreements --accept-package-agreements --disable-interactivity - name: Configure TimescaleDB run: cmake -B build_win -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} ` -DPG_CONFIG=C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/pg_config ` -DASSERTIONS=ON ` -DTEST_PG_LOG_DIRECTORY="log" - name: Build TimescaleDB run: cmake --build build_win --config ${{ matrix.build_type }} - name: Install TimescaleDB run: cmake --install build_win --config ${{ matrix.build_type }} - name: Setup postgres cluster run: | C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/initdb -U postgres -A trust --locale=en_US --encoding=UTF8 mkdir -p ${{ env.TABLESPACE1 }}\_default mkdir -p ${{ env.TABLESPACE2 }}\_default icacls ${{ env.TABLESPACE1 }} /grant runneradmin:F /T icacls ${{ env.TABLESPACE2 }} /grant runneradmin:F /T copy build_win/test/postgresql.conf ${{ env.PGDATA }} copy build_win/test/pg_hba.conf ${{ env.PGDATA }} icacls . /grant runneradmin:F /T C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/pg_ctl start -o "${{ matrix.pg_config }}" --log=postmaster.log C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/pg_isready -U postgres -d postgres --timeout=60 C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'CREATE USER root SUPERUSER LOGIN;' echo "PG version:" C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'SELECT version();' echo "Log configuration:" C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'SHOW logging_collector;' C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'SHOW log_filename;' C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'SHOW log_directory;' C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'SELECT pg_current_logfile();' echo "Data directory:" C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'SHOW data_directory;' - name: Install postgres for test runner shell: wsl-bash {0} run: | yes | /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh || true echo 'Acquire::Retries "10";' >> /etc/apt/apt.conf.d/99retries echo 'Acquire::http::Timeout "240";' >> /etc/apt/apt.conf.d/99retries echo 'Acquire::https::Timeout "240";' >> /etc/apt/apt.conf.d/99retries apt-get install -y --force-yes postgresql-server-dev-${{ matrix.pg }} - name: Run tests shell: wsl-bash {0} env: WSLENV: "IGNORES:SKIPS" run: | export TEST_TABLESPACE1_PREFIX='${{ env.TABLESPACE1 }}' export TEST_TABLESPACE2_PREFIX='${{ env.TABLESPACE2 }}' cmake -B build_wsl -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DTEST_PGPORT_LOCAL=${{ env.PGPORT }} make -C build_wsl isolationchecklocal | tee -a installcheck.log make -C build_wsl regresschecklocal IGNORES="${IGNORES}" SKIPS="${SKIPS}" | tee -a installcheck.log - name: Setup postgres cluster for TSL tests run: | C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/pg_ctl stop timeout 10 Remove-Item -Recurse ${{ env.PGDATA }} C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/initdb -U postgres -A trust --locale=en_US --encoding=UTF8 copy build_win/tsl/test/postgresql.conf ${{ env.PGDATA }} copy build_win/tsl/test/pg_hba.conf ${{ env.PGDATA }} C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/pg_ctl start -o "${{ matrix.pg_config }}" --log="postmaster.log" C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/pg_isready -U postgres -d postgres --timeout=30 C:\Progra~1/PostgreSQL/${{ matrix.pg }}/bin/psql -U postgres -d postgres -c 'CREATE USER root SUPERUSER LOGIN;' - name: Run TSL tests shell: wsl-bash {0} env: WSLENV: "IGNORES:SKIPS" run: | export TEST_TABLESPACE1_PREFIX='${{ env.TABLESPACE1 }}' export TEST_TABLESPACE2_PREFIX='${{ env.TABLESPACE2 }}' make -C build_wsl isolationchecklocal-t | tee -a installcheck.log make -C build_wsl -k regresschecklocal-t IGNORES="${IGNORES}" SKIPS="${SKIPS}" | tee -a installcheck.log - name: Show regression diffs id: collectlogs if: always() env: WSLENV: GITHUB_OUTPUT/p shell: wsl-bash {0} run: | find . -name regression.diffs -exec cat {} + > regression.log if [[ -s regression.log ]]; then echo "regression_diff=true" >>$GITHUB_OUTPUT; fi grep -e 'FAILED' -e 'failed (ignored)' -e 'not ok' installcheck.log || true cat regression.log - name: Save regression diffs if: always() && steps.collectlogs.outputs.regression_diff == 'true' uses: actions/upload-artifact@v4 with: name: Regression ${{ matrix.pg }} diff ${{ matrix.os }} ${{ matrix.build_type }} Build path: | regression.log installcheck.log - name: Save PostgreSQL log if: always() uses: actions/upload-artifact@v4 with: name: PostgreSQL ${{ matrix.pg }} log ${{ matrix.os }} ${{ matrix.build_type }} Build path: ${{ env.PGDATA }}\log\postmaster.log - name: Upload CMake Logs if: always() uses: actions/upload-artifact@v4 with: name: CMake Logs ${{ matrix.pg }} ${{ matrix.os }} ${{ matrix.build_type }} path: | build_win/CMakeCache.txt build_win/CMakeFiles/CMakeConfigureLog.yaml build_win/CMakeFiles/CMakeError.log build_win/CMakeFiles/CMakeOutput.log build_win/compile_commands.json build_wsl/CMakeCache.txt build_wsl/CMakeFiles/CMakeConfigureLog.yaml build_wsl/CMakeFiles/CMakeError.log build_wsl/CMakeFiles/CMakeOutput.log build_wsl/compile_commands.json - name: Upload test results to the database if: always() shell: wsl-bash {0} env: # Update when adding new variables. WSLENV: "JOB_NAME:CI_STATS_DB:GITHUB_EVENT_NAME:GITHUB_REF_NAME\ :GITHUB_REPOSITORY:GITHUB_RUN_ATTEMPT:GITHUB_RUN_ID:GITHUB_RUN_NUMBER:JOB_STATUS" # GitHub Actions allow you neither to use the env context for the job name, # nor to access the job name from the step context, so we have to # duplicate it to work around this nonsense. JOB_NAME: PG${{ matrix.pg }} ${{ matrix.build_type }} ${{ matrix.os }} CI_STATS_DB: ${{ secrets.CI_STATS_DB }} GITHUB_EVENT_NAME: ${{ github.event_name }} GITHUB_REF_NAME: ${{ github.ref_name }} GITHUB_REPOSITORY: ${{ github.repository }} GITHUB_RUN_ATTEMPT: ${{ github.run_attempt }} GITHUB_RUN_ID: ${{ github.run_id }} GITHUB_RUN_NUMBER: ${{ github.run_number }} JOB_STATUS: ${{ job.status }} run: | if [[ "${{ github.event_name }}" == "pull_request" ]] ; then GITHUB_PR_NUMBER="${{ github.event.number }}" else GITHUB_PR_NUMBER=0 fi export GITHUB_PR_NUMBER scripts/upload_ci_stats.sh ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.github/workflows/windows-packages.yaml������������������������������������������0000664�0000000�0000000�00000005657�15100345067�0023617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Test installation of windows package for latest version name: "Packaging tests: Windows" "on": schedule: # run daily 0:00 on main branch - cron: '0 0 * * *' pull_request: paths: .github/workflows/windows-packages.yaml push: tags: - '*' branches: - release_test - trigger/windows_packages workflow_dispatch: jobs: build: name: Windows package PG${{ matrix.pg }} runs-on: windows-2025 strategy: fail-fast: false matrix: pg: [ "15", "16", "17" ] env: # PostgreSQL configuration PGPORT: 6543 PGDATA: pgdata steps: - name: Checkout TimescaleDB source uses: actions/checkout@v4 - name: Get version id: version run: | # version will only be a proper version in a release branch so we use previous_version # as fallback for main if (grep '^version = [0-9.]\+$' version.config) { $version=sed -n 's!^version = !!p' version.config } else { $version=sed -n 's!^previous_version = !!p' version.config } cat version.config echo "Determined version: " echo "version=$version" echo "version=$version" >>$env:GITHUB_OUTPUT - name: Install PostgreSQL ${{ matrix.pg }} run: | choco feature disable --name=usePackageExitCodes choco feature disable --name=showDownloadProgress choco uninstall postgresql --yes winget install --id PostgreSQL.PostgreSQL.${{ matrix.pg }} --accept-source-agreements --accept-package-agreements --disable-interactivity choco install wget - name: Download TimescaleDB run: "wget --quiet -O timescaledb.zip 'https://github.com/timescale/timescaledb/releases/download/\ ${{ steps.version.outputs.version }}/timescaledb-postgresql-${{ matrix.pg}}-windows-amd64.zip'" - name: Install TimescaleDB run: | tar -xf timescaledb.zip cd timescaledb ./setup.exe -yes-tune -pgconfig C:\Progra~1\PostgreSQL\${{ matrix.pg }}\bin\pg_config - name: Create DB run: | C:\Progra~1\PostgreSQL\${{ matrix.pg }}\bin\initdb -U postgres -A trust C:\Progra~1\PostgreSQL\${{ matrix.pg }}\bin\pg_ctl start -o "-cshared_preload_libraries=timescaledb" - name: Test creating extension run: | C:\Progra~1\PostgreSQL\${{ matrix.pg }}\bin\psql -U postgres -d postgres -X ` -c "CREATE EXTENSION timescaledb" ` -c "SELECT extname,extversion,version() FROM pg_extension WHERE extname='timescaledb'" $installed_version = C:\Progra~1\PostgreSQL\${{ matrix.pg }}\bin\psql -U postgres ` -d postgres -qtAX -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb'" $installed_version = $installed_version.Trim() echo "Installed version is '${installed_version}'" if ("${installed_version}" -ne "${{ steps.version.outputs.version }}") { false } ���������������������������������������������������������������������������������timescaledb-2.23.0/.gitignore�����������������������������������������������������������������������0000664�0000000�0000000�00000000754�15100345067�0016051�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������\#*# .#* *~ **/CMakeFiles/ **/CMakeCache.txt /sql/tests/unit/testoutputs.tmp /sql/timescaledb--*.sql /sql/pre_install/*.gen /sql/updates/*.gen /data/ /src/*.o /src/*.so /src/*.d /.vscode/ /timescaledb.so *.bak *.backup typedef.list /test/testcluster /test/log /test/temp_schedule /build* /update_test **/GPATH **/GTAGS **/GRTAGS **/GSYMS tags /.vs /compile_commands.json /.DS_Store /.clangd /.cache /CMakeSettings.json /out/* /debug/ /cmake-build-debug/ /.idea/ coccinelle.diff .gdb_history ��������������������timescaledb-2.23.0/.perltidyrc����������������������������������������������������������������������0000664�0000000�0000000�00000000551�15100345067�0016236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������--add-whitespace --delete-old-whitespace --entab-leading-whitespace=4 --keep-old-blank-lines=2 --maximum-line-length=78 --nooutdent-long-comments --nooutdent-long-quotes --nospace-for-semicolon --opening-brace-on-new-line --output-line-ending=unix --paren-tightness=2 --paren-vertical-tightness=2 --paren-vertical-tightness-closing=2 --noblanks-before-comments �������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.pull-review���������������������������������������������������������������������0000664�0000000�0000000�00000004052�15100345067�0016330�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������--- # pull-review config version (required) version: 1 # use review requests instead of assignees to assign reviewers to pull requests use_review_requests: true # maximum number of files to evaluate per pull request (set to 0 for no limit) max_files: 0 # evaluate all files of the PR # minimum number of reviewers to assign and notify for a pull request min_reviewers: 2 # maximum number of reviewers to assign and notify for a pull request max_reviewers: 2 # maximum number of files per reviewer (set to 0 for no limit) max_files_per_reviewer: 0 # maximum number of lines changed per reviewer (set to 0 for no limit) max_lines_per_reviewer: 0 # if at least a minimum number of reviewers is not found, assign a minimum number of reviewers randomly assign_min_reviewers_randomly: true # if the pull request changes code with fewer than a minimum number of authors, add extra reviewers if possible (set to 0 to disable) min_authors_of_changed_files: 0 # minimum percent of lines authored by a reviewer to require an extra reviewer (set to 0 to disable) min_percent_authorship_for_extra_reviewer: 0 # minimum number of lines that must be changed to add an extra reviewer (set to 0 to disable) min_lines_changed_for_extra_reviewer: 0 # require a user to be listed in the reviewers section in order to be assigned to a pull request require_notification: true # list of users and their app-specific usernames reviewers: Poroma-Banerjee: {} akuzm: {} antekresic: {} dbeck: {} erimatnor: {} fabriziomello: {} kpan2034: {} melihmutlu: {} mkindahl: {} natalya-aksman: {} philkra: {} pnthao: {} svenklemm: {} # list of users who will never be notified review_blacklist: - timescale-automation - philkra # ignore changes to the test output files. # 1. because they usually will have equivalent .sql files # 2. because people that modify a test, don't necessarily change the same c-functionality at all # so tests should be less important than C files file_blacklist: - tsl/test/expected/*.out - test/expected/*.out label_blacklist: - is-auto-backport ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/.yamllint.yaml�������������������������������������������������������������������0000664�0000000�0000000�00000000075�15100345067�0016650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������rules: document-start: disable line-length: max: 250 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/CHANGELOG.md���������������������������������������������������������������������0000664�0000000�0000000�00000662371�15100345067�0015703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# TimescaleDB Changelog **Please note: When updating your database, you should connect using This page lists all the latest features and updates to TimescaleDB. When you use psql to update your database, use the -X flag and prevent any .psqlrc commands from accidentally triggering the load of a previous DB version.** ## 2.23.0 (2025-10-29) This release contains performance improvements and bug fixes since the 2.22.1 release. We recommend that you upgrade at the next available opportunity. **Highlighted features in TimescaleDB v2.23.0** * This release introduces full PostgreSQL 18 support for all existing features. TimescaleDB v2.23 is available for PostgreSQL 15, 16, 17, and 18. * UUIDv7 compression is now enabled by default on the columnstore. This feature was shipped in [v2.22.0](https://github.com/timescale/timescaledb/releases/tag/2.22.0). It saves you at least 30% of storage and delivers ~2× faster query performance with UUIDv7 columns in the filter conditions. * Added the ability to set hypertables to unlogged, addressing an open community request [#836](https://github.com/timescale/timescaledb/issues/836). This allows the tradeoff between durability and performance, with the latter being favourable for larger imports. * By allowing [set-returning functions](https://www.postgresql.org/docs/current/functions-srf.html) in continuous aggregates, this releases addresses a long standing blocker, raised by the community [#1717](https://github.com/timescale/timescaledb/issues/1717). **PostgreSQL 15 deprecation announcement** We will continue supporting PostgreSQL 15 until June 2026. Closer to that time, we will announce the specific TimescaleDB version in which PostgreSQL 15 support will not be included going forward. **Features** * [#8373](https://github.com/timescale/timescaledb/pull/8373) More precise estimates of row numbers for columnar storage based on Postgres statistics. * [#8581](https://github.com/timescale/timescaledb/pull/8581) Allow mixing Postgres and TimescaleDB options in `ALTER TABLE SET`. * [#8582](https://github.com/timescale/timescaledb/pull/8582) Make `partition_column` in `CREATE TABLE WITH` optional. * [#8588](https://github.com/timescale/timescaledb/pull/8588) Automatically create a columnstore policy when a hypertable with columnstore enabled is created via `CREATE TABLE WITH` statement. * [#8606](https://github.com/timescale/timescaledb/pull/8606) Add job history config parameters for maximum successes and failures to keep for each job. * [#8632](https://github.com/timescale/timescaledb/pull/8632) Remove `ChunkDispatch` custom node. * [#8637](https://github.com/timescale/timescaledb/pull/8637) Add `INSERT` support for direct compress. * [#8661](https://github.com/timescale/timescaledb/pull/8661) Allow `ALTER TABLE ONLY` to change `reloptions` to apply setting changes only to future chunks. * [#8703](https://github.com/timescale/timescaledb/pull/8703) Allow set-returning functions in continuous aggregates. * [#8734](https://github.com/timescale/timescaledb/pull/8734) Support direct compress when inserting into a chunk. * [#8741](https://github.com/timescale/timescaledb/pull/8741) Add support for unlogged hypertables. * [#8769](https://github.com/timescale/timescaledb/pull/8769) Remove continuous aggregate invalidation trigger. * [#8798](https://github.com/timescale/timescaledb/pull/8798) Enable UUIDv7 compression by default. * [#8804](https://github.com/timescale/timescaledb/pull/8804) Remove `insert_blocker` trigger. **Bugfixes** * [#8561](https://github.com/timescale/timescaledb/pull/8561) Show warning when direct compress is skipped due to triggers or unique constraints. * [#8567](https://github.com/timescale/timescaledb/pull/8567) Do not require a job to have executed to show status. * [#8654](https://github.com/timescale/timescaledb/pull/8654) Fix `approximate_row_count` for compressed chunks. * [#8704](https://github.com/timescale/timescaledb/pull/8704) Fix direct `DELETE` on compressed chunk. * [#8728](https://github.com/timescale/timescaledb/pull/8728) Don't block dropping hypertables with other objects. * [#8735](https://github.com/timescale/timescaledb/pull/8735) Fix `ColumnarScan` for `UNION` queries. * [#8739](https://github.com/timescale/timescaledb/pull/8739) Fix cached utility statements. * [#8742](https://github.com/timescale/timescaledb/pull/8742) Potential internal program error when grouping by `bool` columns of a compressed hypertable. * [#8743](https://github.com/timescale/timescaledb/pull/8743) Modify schedule interval for job history pruning. * [#8746](https://github.com/timescale/timescaledb/pull/8746) Support show/drop chunks with UUIDv7 partitioning. * [#8753](https://github.com/timescale/timescaledb/pull/8753) Allow sorts over decompressed index scans for `ChunkAppend`. * [#8758](https://github.com/timescale/timescaledb/pull/8758) Improve error message on catalog version mismatch. * [#8774](https://github.com/timescale/timescaledb/pull/8774) Add GUC for WAL based invalidation of continuous aggregates. * [#8782](https://github.com/timescale/timescaledb/pull/8782) Stops sparse index from allowing multiple options. * [#8799](https://github.com/timescale/timescaledb/pull/8799) Set `next_start` for `WITH` clause compression policy. * [#8807](https://github.com/timescale/timescaledb/pull/8807) Only warn but not fail the compression if bloom filter indexes are configured but disabled with a GUC. **GUCs** * `cagg_processing_wal_batch_size`: Batch size when processing WAL entries. * `enable_cagg_wal_based_invalidation`: Enable experimental invalidations for continuous aggregates using WAL. * `enable_direct_compress_insert`: Enable direct compression during `INSERT`. * `enable_direct_compress_insert_client_sorted`: Enable direct compress `INSERT` with presorted data. * `enable_direct_compress_insert_sort_batches`: Enable batch sorting during direct compress `INSERT`. **Thanks** * @brandonpurcell-dev For highlighting issues with `show_chunks()` and UUIDv7 partitioning * @moodgorning for reporting an issue with the `timescaledb_information.job_stats` view * @ruideyllot for reporting set-returning functions not working in continuous aggregates * @t-aistleitner for reporting an issue with utility statements in plpgsql functions ## 2.22.1 (2025-09-30) This release contains performance improvements and bug fixes since the [2.22.0](https://github.com/timescale/timescaledb/releases/tag/2.20.0) release. We recommend that you upgrade at the next available opportunity. This release blocks the ability to leverage **concurrent refresh policies** in **hierarchical continuous aggregates**, as potential deadlocks can occur. [Concurrent refresh policies](https://docs.tigerdata.com/use-timescale/latest/continuous-aggregates/refresh-policies/#add-concurrent-refresh-policies) were introduced in [2.21.0](https://github.com/timescale/timescaledb/releases/tag/2.20.0) and allow users to define multiple time ranges, to refresh, e.g. data from the last hour in policy and the last day in a second policy. If you are using this feature with **hierarchical** continuous aggregates, please [remove the existing policies](https://docs.tigerdata.com/api/latest/jobs-automation/delete_job/#samples) and [create a new policy](https://docs.tigerdata.com/use-timescale/latest/continuous-aggregates/refresh-policies/#change-the-refresh-policy) for the full range you want to refresh, of the continuous aggregate as follows: ``` --- Find the job ID's of the concurrent refresh policies SELECT * FROM timescaledb_information.jobs WHERE proc_name = 'policy_refresh_continuous_aggregate'; --- Remove the job SELECT delete_job("<job_id_of_concurrent_policy>"); --- Create new policy for hierarchical continuous aggregate SELECT add_continuous_aggregate_policy('<name_of_materialized_view>', start_offset => INTERVAL '1 month', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); ``` **Bugfixes** * [#7766](https://github.com/timescale/timescaledb/pull/7766) Load the OSM extension in the retention background worker to drop tiered chunks * [#8550](https://github.com/timescale/timescaledb/pull/8550) Error in gapfill with expressions over aggregates, groupby columns, and out-of-order columns * [#8593](https://github.com/timescale/timescaledb/pull/8593) Error on change of invalidation method for continuous aggregate * [#8599](https://github.com/timescale/timescaledb/pull/8599) Fix the attnum mismatch bug in chunk constraint checks * [#8607](https://github.com/timescale/timescaledb/pull/8607) Fix the interrupted continous aggregate refresh materialization phase that leaves behind pending materialization ranges * [#8638](https://github.com/timescale/timescaledb/pull/8638) `ALTER TABLE RESET` for `orderby` settings * [#8644](https://github.com/timescale/timescaledb/pull/8644) Fix the migration script for sparse index configuration * [#8657](https://github.com/timescale/timescaledb/pull/8657) Fix `CREATE TABLE WITH` when using UUIDv7 partitioning * [#8659](https://github.com/timescale/timescaledb/pull/8659) `ALTER TABLE` commands to foreign data wrapper chunks not propogated. * [#8693](https://github.com/timescale/timescaledb/pull/8693) Compressed index not chosen for `varchar` typed `segmentby` columns * [#8707](https://github.com/timescale/timescaledb/pull/8707) Block concurrent refresh policies for hierarchical continous aggregate due to potential deadlocks **Thanks** * @MKrkkl for reporting a bug in gapfill queries with expressions over aggregates and groupby columns * @brandonpurcell-dev for creating a test case that showed a bug in `CREATE TABLE WITH` when using UUIDv7 partitioning * @snyrkill for reporting a bug when interrupting a continous aggregate refresh ## 2.22.0 (2025-09-02) This release contains performance improvements and bug fixes since the 2.21.3 release. We recommend that you upgrade at the next available opportunity. **Highlighted features in TimescaleDB v2.22.0** * Sparse indexes on compressed hypertables can now be explicitly configured via `ALTER TABLE` rather than relying only on internal heuristics. Users can define indexes on multiple columns to improve query performance for their specific workloads. * [Tech Preview] Continuous aggregates now support the `timescaledb.invalidate_using` option, enabling invalidations to be collected either via triggers on the hypertable or directly from WAL using logical decoding. Aggregates inherit the hypertable’s method if none is specified. * UUIDv7 compression and vectorization are now supported. The compression algorithm leverages the timestamp portion for delta-delta compression while storing the random portion separately. The vectorized equality/inequality filters with bulk decompression deliver ~2× faster query performance. The feature is disabled by default (`timescaledb.enable_uuid_compression`) to simplify the downgrading experience, and will be enabled out of the box in the next minor release. * Hypertables can now be partitioned by UUIDv7 columns, leveraging their embedded timestamps for time-based chunking. We’ve also added utility functions to simplify working with UUIDv7, such as generating values or extracting timestamps - e.g., `uuid_timestamp()` returns a PostgreSQL timestamp from a UUIDv7. * SkipScan now supports multi-column indexes in not-null mode, improving performance for distinct and ordered queries across multiple keys. **Removal of the hypercore table access method** We made the decision to deprecate the hypercore table access method (TAM) with the 2.21.0 release. Hypercore TAM was an experiment and it did not show the performance improvements we hoped for. It is removed with this release. Upgrades to 2.22.0 and higher are blocked if TAM is still in use. Since TAM’s inception in [2.18.0](https://github.com/timescale/timescaledb/releases/tag/2.18.0), we learned that btrees were not the right architecture. Recent advancements in the columnstore, such as more performant backfilling, SkipScan, adding check constraints, and faster point queries, put the [columnstore](https://www.timescale.com/blog/hypercore-a-hybrid-row-storage-engine-for-real-time-analytics) close to or on par with TAM without needing to store an additional index. We apologize for the inconvenience this action potentially causes and are here to assist you during the migration process. Migration path ``` do $$ declare relid regclass; begin for relid in select cl.oid from pg_class cl join pg_am am on (am.oid = cl.relam) where am.amname = 'hypercore' loop raise notice 'converting % to heap', relid::regclass; execute format('alter table %s set access method heap', relid); end loop; end $$; ``` **Features** * [#8247](https://github.com/timescale/timescaledb/pull/8247) Add configurable alter settings for sparse indexes * [#8306](https://github.com/timescale/timescaledb/pull/8306) Add option for invalidation collection using WAL for continuous aggregates * [#8340](https://github.com/timescale/timescaledb/pull/8340) Improve selectivity estimates for sparse minmax indexes, so that an index scan on a table in the columnstore is chosen more often when it's beneficial. * [#8360](https://github.com/timescale/timescaledb/pull/8360) Continuous aggregate multi-hypertable invalidation processing * [#8364](https://github.com/timescale/timescaledb/pull/8364) Remove hypercore table access method * [#8371](https://github.com/timescale/timescaledb/pull/8371) Show available timescaledb `ALTER` options when encountering unsupported options * [#8376](https://github.com/timescale/timescaledb/pull/8376) Change `DecompressChunk` custom node name to `ColumnarScan` * [#8385](https://github.com/timescale/timescaledb/pull/8385) UUID v7 functions for testing pre PG18 * [#8393](https://github.com/timescale/timescaledb/pull/8393) Add specialized compression for UUIDs. Best suited for UUID v7, but still works with other UUID versions. This is experimental at the moment and backward compatibility is not guaranteed. * [#8398](https://github.com/timescale/timescaledb/pull/8398) Set default compression settings at compress time * [#8401](https://github.com/timescale/timescaledb/pull/8401) Support `ALTER TABLE RESET` for compression settings * [#8414](https://github.com/timescale/timescaledb/pull/8414) Vectorised filtering of UUID Eq and Ne filters, plus bulk decompression of UUIDs * [#8424](https://github.com/timescale/timescaledb/pull/8424) Block downgrade when orderby setting is `NULL` * [#8454](https://github.com/timescale/timescaledb/pull/8454) Remove internal unused index helper functions * [#8494](https://github.com/timescale/timescaledb/pull/8494) Improve job stat history retention policy * [#8496](https://github.com/timescale/timescaledb/pull/8496) Fix dropping chunks with foreign keys * [#8505](https://github.com/timescale/timescaledb/pull/8505) Add support for partitioning on UUIDv7 * [#8513](https://github.com/timescale/timescaledb/pull/8513) Support multikey SkipScan when all keys are guaranteed to be non-null * [#8514](https://github.com/timescale/timescaledb/pull/8514) Concurrent continuous aggregates improvements * [#8528](https://github.com/timescale/timescaledb/pull/8528) Add the `_timescaledb_functions.chunk_status_text` helper function * [#8529](https://github.com/timescale/timescaledb/pull/8529) Optimize direct compress status handling **Bugfixes** * [#8422](https://github.com/timescale/timescaledb/pull/8422) Don't require `columnstore=false` when using the TimescaleDB Apache 2 Edition * [#8493](https://github.com/timescale/timescaledb/pull/8493) Change log level of `not null` constraint message * [#8500](https://github.com/timescale/timescaledb/pull/8500) Fix uniqueness check with generated columns and hypercore * [#8545](https://github.com/timescale/timescaledb/pull/8545) Fix error in LOCF/Interpolate with out-of-order and repeated columns * [#8558](https://github.com/timescale/timescaledb/pull/8558) Error out on bad args when processing invalidation * [#8559](https://github.com/timescale/timescaledb/pull/8559) Fix `timestamp out of range` using `end_offset=NULL` on CAgg refresh policy **GUCs** * `enable_multikey_skipscan`: Enable SkipScan for multiple distinct keys, default: on * `enable_uuid_compression`: Enable UUID compression functionality, default: off * `cagg_processing_wal_batch_size`: Batch size when processing WAL entries, default: 10000 * `cagg_processing_low_work_mem`: Low working memory limit for continuous aggregate invalidation processing, default: 38.4MB * `cagg_processing_high_work_mem`: High working memory limit for continuous aggregate invalidation processing, default: 51.2MB **Thanks** * @CodeTherapist for reporting an issue where foreign key checks did not work after several insert statements * @moodgorning for reporting a bug in queries with LOCF/Interpolate using out-of-order columns * @nofalx for reporting an error when using `end_offset=NULL` on CAgg refresh policy * @pierreforstmann for fixing a bug that happened when dropping chunks with foreign keys * @Zaczero for reporting a bug with CREATE TABLE WITH when using the TimescaleDB Apache 2 Edition ## 2.21.4 (2025-09-25) This release contains performance improvements and bug fixes since the 2.21.3 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#8667](https://github.com/timescale/timescaledb/pull/8667) Fix wrong selectivity estimates uncovered by the recent Postgres minor releases 15.14, 16.10, 17.6. ## 2.21.3 (2025-08-12) This release contains performance improvements and bug fixes since the 2.21.2 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#8471](https://github.com/timescale/timescaledb/pull/8471) Fix MERGE behaviour with updated values ## 2.21.2 (2025-08-05) This release contains performance improvements and bug fixes since the 2.21.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#8418](https://github.com/timescale/timescaledb/pull/8418) Fix duplicate constraints in JOIN queries * [#8426](https://github.com/timescale/timescaledb/pull/8426) Fix chunk skipping min/max calculation * [#8434](https://github.com/timescale/timescaledb/pull/8434) Allow `show_chunks` to process more than 65535 chunks ## 2.21.1 (2025-07-22) This release contains one bug fix since the 2.21.0 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#8336](https://github.com/timescale/timescaledb/pull/8336) Fix generic plans for foreign key checks and prepared statements **Thanks** * @CodeTherapist for reporting the issue with foreign key checks not working after several `INSERT` statements ## 2.21.0 (2025-07-08) This release contains performance improvements and bug fixes since the 2.20.3 release. We recommend that you upgrade at the next available opportunity. **Highlighted features in TimescaleDB v2.21.0** * The attach & detach chunks feature allows manually adding or removing chunks from a hypertable with uncompressed chunks, similar to PostgreSQL’s partition management. * Continued improvement of backfilling into the columnstore, achieving up to 2.5x speedup for constrained tables, by introducing caching logic that boosts throughput for writes to compressed chunks, bringing `INSERT` performance close to that of uncompressed chunks. * Optimized `DELETE` operations on the columstore through batch-level deletions of non-segmentby keys in the filter condition, greatly improving performance to up to 42x faster in some cases, as well as reducing bloat, and lowering resource usage. * The heavy lock taken in Continuous Aggregate refresh was relaxed, enabling concurrent refreshes for non-overlapping ranges and eliminating the need for complex customer workarounds. * [tech preview] Direct Compress is an innovative TimescaleDB feature that improves high-volume data ingestion by compressing data in memory and writing it directly to disk, reducing I/O overhead, eliminating dependency on background compression jobs, and significantly boosting insert performance. **Sunsetting of the hypercore access method** We made the decision to deprecate hypercore access method (TAM) with the 2.21.0 release. It was an experiment, which did not show the signals we hoped for and will be sunsetted in TimescaleDB 2.22.0, scheduled for September 2025. Upgrading to 2.22.0 and higher will be blocked if TAM is still in use. Since TAM’s inception in [2.18.0](https://github.com/timescale/timescaledb/releases/tag/2.18.0), we learned that btrees were not the right architecture. The recent advancements in the columnstore—such as more performant backfilling, SkipScan, adding check constraints, and faster point queries—put the [columnstore](https://www.timescale.com/blog/hypercore-a-hybrid-row-storage-engine-for-real-time-analytics) close to or on par with TAM without the storage from the additional index. We apologize for the inconvenience this action potentially causes and are here to assist you during the migration process. Migration path ``` do $$ declare relid regclass; begin for relid in select cl.oid from pg_class cl join pg_am am on (am.oid = cl.relam) where am.amname = 'hypercore' loop raise notice 'converting % to heap', relid::regclass; execute format('alter table %s set access method heap', relid); end loop; end $$; ``` **Features** * [#8081](https://github.com/timescale/timescaledb/pull/8081) Use JSON error code for job configuration parsing * [#8100](https://github.com/timescale/timescaledb/pull/8100) Support splitting compressed chunks * [#8131](https://github.com/timescale/timescaledb/pull/8131) Add policy to process hypertable invalidations * [#8141](https://github.com/timescale/timescaledb/pull/8141) Add function to process hypertable invalidations * [#8165](https://github.com/timescale/timescaledb/pull/8165) Reindex recompressed chunks in compression policy * [#8178](https://github.com/timescale/timescaledb/pull/8178) Add columnstore option to `CREATE TABLE WITH` * [#8179](https://github.com/timescale/timescaledb/pull/8179) Implement direct `DELETE` on non-segmentby columns * [#8182](https://github.com/timescale/timescaledb/pull/8182) Cache information for repeated upserts into the same compressed chunk * [#8187](https://github.com/timescale/timescaledb/pull/8187) Allow concurrent Continuous Aggregate refreshes * [#8191](https://github.com/timescale/timescaledb/pull/8191) Add option to not process hypertable invalidations * [#8196](https://github.com/timescale/timescaledb/pull/8196) Show deprecation warning for TAM * [#8208](https://github.com/timescale/timescaledb/pull/8208) Use `NULL` compression for bool batches with all null values like the other compression algorithms * [#8223](https://github.com/timescale/timescaledb/pull/8223) Support for attach/detach chunk * [#8265](https://github.com/timescale/timescaledb/pull/8265) Set incremental Continous Aggregate refresh policy on by default * [#8274](https://github.com/timescale/timescaledb/pull/8274) Allow creating concurrent continuous aggregate refresh policies * [#8314](https://github.com/timescale/timescaledb/pull/8314) Add support for timescaledb_lake in loader * [#8209](https://github.com/timescale/timescaledb/pull/8209) Add experimental support for Direct Compress of `COPY` * [#8341](https://github.com/timescale/timescaledb/pull/8341) Allow quick migration from hypercore TAM to (columnstore) heap **Bugfixes** * [#8153](https://github.com/timescale/timescaledb/pull/8153) Restoring a database having NULL compressed data * [#8164](https://github.com/timescale/timescaledb/pull/8164) Check columns when creating new chunk from table * [#8294](https://github.com/timescale/timescaledb/pull/8294) The "vectorized predicate called for a null value" error for WHERE conditions like `x = any(null::int[])`. * [#8307](https://github.com/timescale/timescaledb/pull/8307) Fix missing catalog entries for bool and null compression in fresh installations * [#8323](https://github.com/timescale/timescaledb/pull/8323) Fix DML issue with expression indexes and BHS **GUCs** * `enable_direct_compress_copy`: Enable experimental support for direct compression during `COPY`, default: off * `enable_direct_compress_copy_sort_batches`: Enable batch sorting during direct compress `COPY`, default: on * `enable_direct_compress_copy_client_sorted`: Correct handling of data sorting by the user is required for this option, default: off ## 2.20.3 (2025-06-11) This release contains bug fixes since the 2.20.2 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#8107](https://github.com/timescale/timescaledb/pull/8107) Adjust SkipScan cost for quals needing full scan of indexed data. * [#8211](https://github.com/timescale/timescaledb/pull/8211) Fixed dump and restore when chunk skipping is enabled. * [#8216](https://github.com/timescale/timescaledb/pull/8216) Fix for dropped quals bug in SkipScan. * [#8230](https://github.com/timescale/timescaledb/pull/8230) Fix for inserting into compressed data when vectorised check is not available. * [#8236](https://github.com/timescale/timescaledb/pull/8236) Fixed the snapshot handling in background workers. **Thanks** * @ikaakkola for reporting that SkipScan is slow when non-index quals do not match any tuples. ## 2.20.2 (2025-06-02) This release contains bug fixes since the 2.20.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#8200](https://github.com/timescale/timescaledb/pull/8202) Fix `NULL` compression handling for vectorized constraint checking ## 2.20.1 (2025-05-27) This release contains performance improvements and bug fixes since the 2.20.0 release. We recommend that you upgrade at the next available opportunity. **Features** * [#8145](https://github.com/timescale/timescaledb/pull/8145) Log only if compression ratio warnings are enabled **Bugfixes** * [#7292](https://github.com/timescale/timescaledb/pull/7292) Intermittent "could not find pathkey item to sort" error when grouping or ordering by a time_bucket of an equality join variable. * [#8126](https://github.com/timescale/timescaledb/pull/8126) Allow setting bgw_log_level to FATAL and ERROR * [#8151](https://github.com/timescale/timescaledb/pull/8151) Treat null equal to null for merged CAgg refresh * [#8153](https://github.com/timescale/timescaledb/pull/8153) Restoring a database having NULL compressed data * [#8162](https://github.com/timescale/timescaledb/pull/8162) Fix setting compress_chunk_interval on continuous aggregates * [#8163](https://github.com/timescale/timescaledb/pull/8163) Fix gapfill crash with locf NULL values treated as missing * [#8171](https://github.com/timescale/timescaledb/pull/8171) Disable decompression limit during continuous aggregate refresh **Thanks** * @bobozaur, @kvc0, @ChadMoran, @PaddyKe for reporting the pathkey error. * @jlordiales for reporting an issue with setting compress_chunk_interval for continuous aggregates * @svanharmelen, @cmdjulian, @etaMS20 for reporting time_bucket_gapfill with locf crash when NULL values are treated as missing ## 2.20.0 (2025-05-15) This release contains performance improvements and bug fixes since the 2.19.3 release. We recommend that you upgrade at the next available opportunity. **Highlighted features in TimescaleDB v2.20.0** * The columnstore now leverages *bloom filters* to deliver up to 6x faster point queries on columns with high cardinality values, such as UUIDs. * Major *improvements to the columnstores' backfill process* enable `UPSERTS` with strict constraints to execute up to 10x faster. * *SkipScan is now supported in the columnstore*, including for DISTINCT queries. This enhancement leads to dramatic query performance improvements of 2000x to 2500x, especially for selective queries. * SIMD vectorization for the bool data type is now enabled by default. This change results in a 30–45% increase in performance for analytical queries with bool clauses on the columnstore. * *Continuous aggregates* now include experimental support for *window functions and non-immutable functions*, extending the analytics use cases they can solve. * Several quality-of-life improvements have been introduced: job names for continuous aggregates are now more descriptive, you can assign custom names to them, and it is now possible to add unique constraints along with `ADD COLUMN` operations in the columnstore. * Improved management and optimization of chunks with the ability to split large uncompressed chunks at a specified point in time using the `split_chunk` function. This new function complements the existing `merge_chunk` function that can be used to merge two small chunks into one larger chunk. * Enhancements to the default behavior of the columnstore now provide better *automatic assessments* of `segment by` and `order by` columns, reducing the need for manual configuration and simplifying initial setup. **PostgreSQL 14 support removal announcement** Following the deprecation announcement for PostgreSQL 14 in TimescaleDB v2.19.0, PostgreSQL 14 is no longer supported in TimescaleDB v2.20.0. The currently supported PostgreSQL major versions are 15, 16, and 17. **Features** * [#7638](https://github.com/timescale/timescaledb/pull/7638) Bloom filter sparse indexes for compressed columns. Can be disabled with the GUC `timescaledb.enable_sparse_index_bloom` * [#7756](https://github.com/timescale/timescaledb/pull/7756) Add warning for poor compression ratio * [#7762](https://github.com/timescale/timescaledb/pull/7762) Speed up the queries that use minmax sparse indexes on compressed tables by changing the index TOAST storage type to `MAIN`. This applies to newly compressed chunks * [#7785](https://github.com/timescale/timescaledb/pull/7785) Do `DELETE` instead of `TRUNCATE` when locks aren't acquired * [#7852](https://github.com/timescale/timescaledb/pull/7852) Allow creating foreign key constraints on compressed tables * [#7854](https://github.com/timescale/timescaledb/pull/7854) Remove support for PG14 * [#7864](https://github.com/timescale/timescaledb/pull/7854) Allow adding CHECK constraints to compressed chunks * [#7868](https://github.com/timescale/timescaledb/pull/7868) Allow adding columns with `CHECK` constraints to compressed chunks * [#7874](https://github.com/timescale/timescaledb/pull/7874) Support for SkipScan for distinct aggregates over the same column * [#7877](https://github.com/timescale/timescaledb/pull/7877) Remove blocker for unique constraints with `ADD COLUMN` * [#7878](https://github.com/timescale/timescaledb/pull/7878) Don't block non-immutable functions in continuous aggregates * [#7880](https://github.com/timescale/timescaledb/pull/7880) Add experimental support for window functions in continuous aggregates * [#7899](https://github.com/timescale/timescaledb/pull/7899) Vectorized decompression and filtering for boolean columns * [#7915](https://github.com/timescale/timescaledb/pull/7915) New option `refresh_newest_first` to continuous aggregate refresh policy API * [#7917](https://github.com/timescale/timescaledb/pull/7917) Remove `_timescaledb_functions.create_chunk_table` function * [#7929](https://github.com/timescale/timescaledb/pull/7929) Add `CREATE TABLE ... WITH` API for creating hypertables * [#7946](https://github.com/timescale/timescaledb/pull/7946) Add support for splitting a chunk * [#7958](https://github.com/timescale/timescaledb/pull/7958) Allow custom names for jobs * [#7972](https://github.com/timescale/timescaledb/pull/7972) Add vectorized filtering for constraint checking while backfilling into compressed chunks * [#7976](https://github.com/timescale/timescaledb/pull/7976) Include continuous aggregate name in jobs informational view * [#7977](https://github.com/timescale/timescaledb/pull/7977) Replace references to compression with columnstore * [#7981](https://github.com/timescale/timescaledb/pull/7981) Add columnstore as alias for `enable_columnstore `in `ALTER TABLE` * [#7983](https://github.com/timescale/timescaledb/pull/7983) Support for SkipScan over compressed data * [#7991](https://github.com/timescale/timescaledb/pull/7991) Improves default `segmentby` options * [#7992](https://github.com/timescale/timescaledb/pull/7992) Add API into hypertable invalidation log * [#8000](https://github.com/timescale/timescaledb/pull/8000) Add primary dimension info to information schema * [#8005](https://github.com/timescale/timescaledb/pull/8005) Support `ALTER TABLE SET (timescaledb.chunk_time_interval='1 day')` * [#8012](https://github.com/timescale/timescaledb/pull/8012) Add event triggers support on chunk creation * [#8014](https://github.com/timescale/timescaledb/pull/8014) Enable bool compression by default by setting `timescaledb.enable_bool_compression=true`. Note: for downgrading to `2.18` or earlier version, use [this downgrade script](https://github.com/timescale/timescaledb-extras/blob/master/utils/2.19.0-downgrade_new_compression_algorithms.sql) * [#8018](https://github.com/timescale/timescaledb/pull/8018) Add spin-lock during recompression on unique constraints * [#8026](https://github.com/timescale/timescaledb/pull/8026) Allow `WHERE` conditions that use nonvolatile functions to be pushed down to the compressed scan level. For example, conditions like `time > now()`, where `time` is a columnstore `orderby` column, will evaluate `now()` and use the sparse index on `time` to filter out the entire compressed batches that cannot contain matching rows. * [#8027](https://github.com/timescale/timescaledb/pull/8027) Add materialization invalidations API * [#8047](https://github.com/timescale/timescaledb/pull/8027) Support SkipScan for `SELECT DISTINCT` with multiple distincts when all but one distinct is pinned * [#8115](https://github.com/timescale/timescaledb/pull/8115) Add batch size limiting during compression **Bugfixes** * [#7862](https://github.com/timescale/timescaledb/pull/7862) Release cache pin when checking for `NOT NULL` * [#7909](https://github.com/timescale/timescaledb/pull/7909) Update compression stats when merging chunks * [#7928](https://github.com/timescale/timescaledb/pull/7928) Don't create a hypertable for implicitly published tables * [#7982](https://github.com/timescale/timescaledb/pull/7982) Fix crash in batch sort merge over eligible expressions * [#8008](https://github.com/timescale/timescaledb/pull/8008) Fix compression policy error message that shows number of successes * [#8031](https://github.com/timescale/timescaledb/pull/8031) Fix reporting of deleted tuples for direct batch delete * [#8033](https://github.com/timescale/timescaledb/pull/8033) Skip default `segmentby` if `orderby` is explicitly set * [#8061](https://github.com/timescale/timescaledb/pull/8061) Ensure settings for a compressed relation are found * [#7515](https://github.com/timescale/timescaledb/pull/7515) Add missing lock to Constraint-aware append * [#8067](https://github.com/timescale/timescaledb/pull/8067) Make sure hypercore TAM parent is vacuumed * [#8074](https://github.com/timescale/timescaledb/pull/8074) Fix memory leak in row compressor flush * [#8099](https://github.com/timescale/timescaledb/pull/8099) Block chunk merging on multi-dimensional hypertables * [#8106](https://github.com/timescale/timescaledb/pull/8106) Fix segfault when adding unique compression indexes to compressed chunks * [#8127](https://github.com/timescale/timescaledb/pull/8127) Read bit-packed version of booleans **GUCs** * `timescaledb.enable_sparse_index_bloom`: Enable creation of the bloom1 sparse index on compressed chunks; Default: `ON` * `timescaledb.compress_truncate_behaviour`: Defines how truncate behaves at the end of compression; Default: `truncate_only` * `timescaledb.enable_compression_ratio_warnings`: Enable warnings for poor compression ratio; Default: `ON` * `timescaledb.enable_event_triggers`: Enable event triggers for chunks creation; Default: `OFF` * `timescaledb.enable_cagg_window_functions`: Enable window functions in continuous aggregates; Default: `OFF` **Thanks** * @arajkumar for reporting that implicitly published tables were still able to create hypertables * @thotokraa for reporting an issue with unique expression indexes on compressed chunks ## 2.19.3 (2025-04-15) This release contains bug fixes since the 2.19.2 release. We recommend that you upgrade at the next available opportunity. **Bug fixes** * [#7893](https://github.com/timescale/timescaledb/pull/7893) Don't capture hard errors in with-clause parser * [#7903](https://github.com/timescale/timescaledb/pull/7903) Don't capture hard errors for old cagg format * [#7912](https://github.com/timescale/timescaledb/pull/7912) Don't capture errors estimating time max spread * [#7910](https://github.com/timescale/timescaledb/pull/7910) Fix not using SkipScan over one chunk * [#7913](https://github.com/timescale/timescaledb/pull/7913) Allow TAM chunk creation as non-owner * [#7935](https://github.com/timescale/timescaledb/pull/7935) Fix TAM segfault on DELETE using segmentby column * [#7954](https://github.com/timescale/timescaledb/pull/7954) Allow scheduler restarts to be disabled * [#7964](https://github.com/timescale/timescaledb/pull/7964) Crash when grouping by multiple columns of a compressed table, one of which is a UUID segmentby column. ## 2.19.2 (2025-04-07) This release contains bug fixes since the 2.19.1 release. We recommend that you upgrade at the next available opportunity. **Features** * [#7923](https://github.com/timescale/timescaledb/pull/7923) Add a GUC to set a compression batch size limit **Bugfixes** * [#7911](https://github.com/timescale/timescaledb/pull/7911) Don't create a Hypertable for published tables * [#7902](https://github.com/timescale/timescaledb/pull/7902) Fix crash in VectorAgg plan code **GUCs** * `compression_batch_size_limit`: set batch size limit, default: `1000` **Thanks** * @soedirgo for reporting that published tables don't get dropped when they have a hypertable* ## 2.19.1 (2025-04-01) This release contains bug fixes since the 2.19.0 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#7816](https://github.com/timescale/timescaledb/pull/7816) Fix `ORDER BY` for direct queries on partial chunks * [#7834](https://github.com/timescale/timescaledb/pull/7834) Avoid unnecessary scheduler restarts * [#7837](https://github.com/timescale/timescaledb/pull/7837) Ignore frozen chunks in compression policy * [#7850](https://github.com/timescale/timescaledb/pull/7850) Add `is_current_xact_tuple` to Arrow TTS * [#7890](https://github.com/timescale/timescaledb/pull/7890) Flush error state before doing anything else **Thanks** * @bjornuppeke for reporting a problem with `INSERT INTO ... ON CONFLICT DO NOTHING` on compressed chunks * @kav23alex for reporting a segmentation fault on `ALTER TABLE` with `DEFAULT` ## 2.19.0 (2025-03-18) This release contains performance improvements and bug fixes since the 2.18.2 release. We recommend that you upgrade at the next available opportunity. * Improved concurrency of `INSERT`, `UPDATE`, and `DELETE` operations on the columnstore by no longer blocking DML statements during the recompression of a chunk. * Improved system performance during continuous aggregate refreshes by breaking them into smaller batches. This reduces systems pressure and minimizes the risk of spilling to disk. * Faster and more up-to-date results for queries against continuous aggregates by materializing the most recent data first, as opposed to old data first in prior versions. * Faster analytical queries with SIMD vectorization of aggregations over text columns and `GROUP BY` over multiple columns. * Enable optimizing the chunk size for better query performance in the columnstore by merging them with `merge_chunk`. **Deprecation warning** This is the last minor release supporting PostgreSQL 14. Starting with the next minor version of TimescaleDB, only Postgres 15, 16, and 17 will be supported. **Downgrading of 2.19.0** This release introduces custom bool compression. If you enable this feature with `enable_bool_compression` and need to revert it, use [this script](https://github.com/timescale/timescaledb-extras/blob/master/utils/2.19.0-downgrade_new_compression_algorithms.sql) to convert the columns back to their previous state. TimescaleDB versions prior to 2.19.0 do not support this new type. **Features** * [#7586](https://github.com/timescale/timescaledb/pull/7586) Vectorized aggregation with grouping by a single text column * [#7632](https://github.com/timescale/timescaledb/pull/7632) Optimize recompression for chunks without segmentby * [#7655](https://github.com/timescale/timescaledb/pull/7655) Support vectorized aggregation on hypercore TAM * [#7669](https://github.com/timescale/timescaledb/pull/7669) Add support for merging compressed chunks * [#7701](https://github.com/timescale/timescaledb/pull/7701) Implement a custom compression algorithm for bool columns. It is in early access and can undergo backwards-incompatible changes. For testing, enable it using `timescaledb.enable_bool_compression = on` * [#7707](https://github.com/timescale/timescaledb/pull/7707) Support `ALTER COLUMN SET NOT NULL` on compressed chunks * [#7765](https://github.com/timescale/timescaledb/pull/7765) Allow `tsdb` as alias for `timescaledb` in `WITH` and `SET` clauses * [#7786](https://github.com/timescale/timescaledb/pull/7786) Show a warning for inefficient `compress_chunk_time_interval` configuration * [#7788](https://github.com/timescale/timescaledb/pull/7788) Add a callback to `mem_guard` for background workers * [#7789](https://github.com/timescale/timescaledb/pull/7789) Do not recompress segmentwise when default order by is empty * [#7790](https://github.com/timescale/timescaledb/pull/7790) Add a configurable incremental CAgg refresh policy **Bugfixes** * [#7665](https://github.com/timescale/timescaledb/pull/7665) Block merging of frozen chunks * [#7673](https://github.com/timescale/timescaledb/pull/7673) Don't abort additional `INSERT`s when hitting the first conflict * [#7714](https://github.com/timescale/timescaledb/pull/7714) Fix the wrong result when compressed `NULL` values were confused with default values. This happened for a very particular order of events. * [#7747](https://github.com/timescale/timescaledb/pull/7747) Block TAM rewrites with incompatible GUC setting * [#7748](https://github.com/timescale/timescaledb/pull/7748) Crash in the segmentwise recompression * [#7764](https://github.com/timescale/timescaledb/pull/7764) Fix compression settings handling in hypercore TAM * [#7768](https://github.com/timescale/timescaledb/pull/7768) Remove costing index scan of hypertable parent * [#7799](https://github.com/timescale/timescaledb/pull/7799) Handle the `DEFAULT` table access name in `ALTER TABLE` **GUCs** * `enable_bool_compression`: enable the BOOL compression algorithm, default: `OFF` * `enable_exclusive_locking_recompression`: enable exclusive locking during recompression (legacy mode), default: `OFF` **Thanks** * @bjornuppeke for reporting a problem with `INSERT INTO ... ON CONFLICT DO NOTHING` on compressed chunks * @kav23alex for reporting a segmentation fault on `ALTER TABLE with DEFAULT` ## 2.18.2 (2025-02-19) This release contains performance improvements and bug fixes since the 2.18.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * [#7686](https://github.com/timescale/timescaledb/pull/7686) Potential wrong aggregation result when using vectorized aggregation with hash grouping in reverse order * [#7694](https://github.com/timescale/timescaledb/pull/7694) Fix ExplainHook breaking call chain * [#7695](https://github.com/timescale/timescaledb/pull/7695) Block dropping internal compressed chunks with `drop_chunk()` * [#7711](https://github.com/timescale/timescaledb/pull/7711) License error when using hypercore handler * [#7712](https://github.com/timescale/timescaledb/pull/7712) Respect other extensions' ExecutorStart hooks **Thanks** * @davidmehren and @jflambert for reporting an issue with extension hooks * @jflambert for reporting a bug with license errors shown in autovacuum ## 2.18.1 (2025-02-10) This release contains performance improvements and bug fixes since the 2.18.0 release. We recommend that you upgrade at the next available opportunity. **Features** * [#7656](https://github.com/timescale/timescaledb/pull/7656) Remove limitation of compression policy for continuous aggregates **Bugfixes** * [#7600](https://github.com/timescale/timescaledb/pull/7600) Fix lock order when dropping index * [#7637](https://github.com/timescale/timescaledb/pull/7637) Allow EXPLAIN in read-only mode * [#7645](https://github.com/timescale/timescaledb/pull/7645) Fix DELETE on compressed chunk with non-btree operators * [#7649](https://github.com/timescale/timescaledb/pull/7649) Allow non-btree operator pushdown in UPDATE/DELETE queries on compressed chunks * [#7653](https://github.com/timescale/timescaledb/pull/7653) Push down orderby scankeys to Hypercore TAM * [#7665](https://github.com/timescale/timescaledb/pull/7665) Block merging of frozen chunks * [#7673](https://github.com/timescale/timescaledb/pull/7673) Don't abort additional INSERTs when hitting first conflict **GUCs** * `enable_hypercore_scankey_pushdown`: Push down qualifiers as scankeys when using Hypercore TAM introduced with [#7653](https://github.com/timescale/timescaledb/pull/7653) **Thanks** * @bjornuppeke for reporting a problem with INSERT INTO ... ON CONFLICT DO NOTHING on compressed chunks * @ikalafat for reporting a problem with EXPLAIN in read-only mode * Timescale community members Jacob and pantonis for reporting issues with slow queries. ## 2.18.0 (2025-01-23) This release introduces the ability to add secondary indexes to the columnstore, improves group by and filtering performance through columnstore vectorization, and contains the highly upvoted community request of transition table support. We recommend that you upgrade at the next available opportunity. **Highlighted features in TimescaleDB v2.18.0** * The ability to add secondary indexes to the columnstore through the new hypercore table access method. * Significant performance improvements through vectorization (`SIMD`) for aggregations using a group by with one column and/or using a filter clause when querying the columnstore. * Hypertables support triggers for transition tables, which is one of the most upvoted community feature requests. * Updated methods to manage Timescale's hybrid row-columnar store (hypercore) that highlight the usage of the columnstore which includes both an optimized columnar format as well as compression. **Dropping support for Bitnami images** After the recent change in Bitnami’s [LTS support policy](https://github.com/bitnami/containers/issues/75671), we are no longer building Bitnami images for TimescaleDB. We recommend using the [official TimescaleDB Docker image](https://hub.docker.com/r/timescale/timescaledb-ha) **Deprecation Notice** We are deprecating the following parameters, functions, procedures and views. They will be removed with the next major release of TimescaleDB. Please find the replacements in the table below: | Deprecated | Replacement | Type | | --- | --- | --- | | decompress_chunk | convert_to_rowstore | Procedure | | compress_chunk | convert_to_columnstore | Procedure | | add_compression_policy | add_columnstore_policy | Function | | remove_compression_policy | remove_columnstore_policy | Function | | hypertable_compression_stats | hypertable_columnstore_stats | Function | | chunk_compression_stats | chunk_columnstore_stats | Function | | hypertable_compression_settings | hypertable_columnstore_settings | View | | chunk_compression_settings | chunk_columnstore_settings | View | | compression_settings | columnstore_settings | View | | timescaledb.compress | timescaledb.enable_columnstore | Parameter | | timescaledb.compress_segmentby | timescaledb.segmentby | Parameter | | timescaledb.compress_orderby | timescaledb.orderby | Parameter | **Features** * #7341: Vectorized aggregation with grouping by one fixed-size by-value compressed column (such as arithmetic types). * #7104: Hypercore table access method. * #6901: Add hypertable support for transition tables. * #7482: Optimize recompression of partially compressed chunks. * #7458: Support vectorized aggregation with aggregate `filter` clauses that are also vectorizable. * #7433: Add support for merging chunks. * #7271: Push down `order by` in real-time continuous aggregate queries. * #7455: Support `drop not null` on compressed hypertables. * #7295: Support `alter table set access method` on hypertable. * #7411: Change parameter name to enable hypercore table access method. * #7436: Add index creation on `order by` columns. * #7443: Add hypercore function and view aliases. * #7521: Add optional `force` argument to `refresh_continuous_aggregate`. * #7528: Transform sorting on `time_bucket` to sorting on time for compressed chunks in some cases. * #7565: Add hint when hypertable creation fails. * #7390: Disable custom `hashagg` planner code. * #7587: Add `include_tiered_data` parameter to `add_continuous_aggregate_policy` API. * #7486: Prevent building against PostgreSQL versions with broken ABI. * #7412: Add [GUC](https://www.postgresql.org/docs/current/acronyms.html#:~:text=GUC) for the `hypercore_use_access_method` default. * #7413: Add GUC for segmentwise recompression. **Bugfixes** * #7378: Remove obsolete job referencing `policy_job_error_retention`. * #7409: Update `bgw_job` table when altering procedure. * #7410: Fix the `aggregated compressed column not found` error on aggregation query. * #7426: Fix `datetime` parsing error in chunk constraint creation. * #7432: Verify that the heap tuple is valid before using. * #7434: Fix the segfault when internally setting the replica identity for a given chunk. * #7488: Emit error for transition table trigger on chunks. * #7514: Fix the error: `invalid child of chunk append`. * #7517: Fix the performance regression on the `cagg_migrate` procedure. * #7527: Restart scheduler on error. * #7557: Fix null handling for in-memory tuple filtering. * #7566: Improve transaction check in CAGG refresh. * #7584: Fix NaN-handling for vectorized aggregation. * #7598: Match the Postgres NaN comparison behavior in WHERE clause over compressed tables. **Thanks** * @bharrisau for reporting the segfault when creating chunks. * @jakehedlund for reporting the incompatible NaN behavior in WHERE clause over compressed tables. * @k-rus for suggesting that we add a hint when hypertable creation fails. * @pgloader for reporting the issue in an internal background job. * @staticlibs for sending the pull request that improves the transaction check in CAGG refresh. * @uasiddiqi for reporting the `aggregated compressed column not found` error. ## 2.17.2 (2024-11-06) This release contains bug fixes since the 2.17.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #7384 Fix "negative bitmapset member not allowed" and performance degradation on queries to compressed tables with ORDER BY clause matching the order of the compressed data * #7388 Use-after-free in vectorized grouping by segmentby columns **Thanks** * @dx034 for reporting an issue with negative bitmapset members due to large OIDs ## 2.17.1 (2024-10-21) This release contains performance improvements and bug fixes since the 2.17.0 release. We recommend that you upgrade at the next available opportunity. **Features** * #7360 Add chunk skipping GUC **Bugfixes** * #7335 Change log level used in compression * #7342 Fix collation for in-memory tuple filtering **Thanks** * @gmilamjr for reporting an issue with the log level of compression messages * @hackbnw for reporting an issue with collation during tuple filtering ## 2.17.0 (2024-10-08) This release adds support for PostgreSQL 17, significantly improves the performance of continuous aggregate refreshes, and contains performance improvements for analytical queries and delete operations over compressed hypertables. We recommend that you upgrade at the next available opportunity. **Highlighted features in TimescaleDB v2.17.0** * Full PostgreSQL 17 support for all existing features. TimescaleDB v2.17 is available for PostgreSQL 14, 15, 16, and 17. * Significant performance improvements for continuous aggregate policies: continuous aggregate refresh is now using `merge` instead of deleting old materialized data and re-inserting. This update can decrease dramatically the amount of data that must be written on the continuous aggregate in the presence of a small number of changes, reduce the `i/o` cost of refreshing a continuous aggregate, and generate fewer Write-Ahead Logs (`WAL`). Overall, continuous aggregate policies will be more lightweight, use less system resources, and complete faster. * Increased performance for real-time analytical queries over compressed hypertables: we are excited to introduce additional Single Instruction, Multiple Data (`SIMD`) vectorization optimization to our engine by supporting vectorized execution for queries that group by using the `segment_by` column(s) and aggregate using the basic aggregate functions (`sum`, `count`, `avg`, `min`, `max`). Stay tuned for more to come in follow-up releases! Support for grouping on additional columns, filtered aggregation, vectorized expressions, and `time_bucket` is coming soon. * Improved performance of deletes on compressed hypertables when a large amount of data is affected. This improvement speeds up operations that delete whole segments by skipping the decompression step. It is enabled for all deletes that filter by the `segment_by` column(s). **PostgreSQL 14 deprecation announcement** We will continue supporting PostgreSQL 14 until April 2025. Closer to that time, we will announce the specific version of TimescaleDB in which PostgreSQL 14 support will not be included going forward. **Features** * #6882: Allow delete of full segments on compressed chunks without decompression. * #7033: Use `merge` statement on continuous aggregates refresh. * #7126: Add functions to show the compression information. * #7147: Vectorize partial aggregation for `sum(int4)` with grouping on `segment by` columns. * #7204: Track additional extensions in telemetry. * #7207: Refactor the `decompress_batches_scan` functions for easier maintenance. * #7209: Add a function to drop the `osm` chunk. * #7275: Add support for the `returning` clause for `merge`. * #7200: Vectorize common aggregate functions like `min`, `max`, `sum`, `avg`, `stddev`, `variance` for compressed columns of arithmetic types, when there is grouping on `segment by` columns or no grouping. **Bug fixes** * #7187: Fix the string literal length for the `compressed_data_info` function. * #7191: Fix creating default indexes on chunks when migrating the data. * #7195: Fix the `segment by` and `order by` checks when dropping a column from a compressed hypertable. * #7201: Use the generic extension description when building `apt` and `rpm` loader packages. * #7227: Add an index to the `compression_chunk_size` catalog table. * #7229: Fix the foreign key constraints where the index and the constraint column order are different. * #7230: Do not propagate the foreign key constraints to the `osm` chunk. * #7234: Release the cache after accessing the cache entry. * #7258: Force English in the `pg_config` command executed by `cmake` to avoid the unexpected building errors. * #7270: Fix the memory leak in compressed DML batch filtering. * #7286: Fix the index column check while searching for the index. * #7290: Add check for null offset for continuous aggregates built on top of continuous aggregates. * #7301: Make foreign key behavior for hypertables consistent. * #7318: Fix chunk skipping range filtering. * #7320: Set the license specific extension comment in the install script. **Thanks** * @MiguelTubio for reporting and fixing the Windows build error. * @posuch for reporting the misleading extension description in the generic loader packages. * @snyrkill for discovering and reporting the issue with continuous aggregates built on top of continuous aggregates. ## 2.16.1 (2024-08-06) This release contains bug fixes since the 2.16.0 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #7182 Fix untier_chunk for hypertables with foreign keys ## 2.16.0 (2024-07-31) This release contains significant performance improvements when working with compressed data, extended join support in continuous aggregates, and the ability to define foreign keys from regular tables towards hypertables. We recommend that you upgrade at the next available opportunity. In TimescaleDB v2.16.0 we: * Introduce multiple performance focused optimizations for data manipulation operations (DML) over compressed chunks. Improved upsert performance by more than 100x in some cases and more than 1000x in some update/delete scenarios. * Add the ability to define chunk skipping indexes on non-partitioning columns of compressed hypertables TimescaleDB v2.16.0 extends chunk exclusion to use those skipping (sparse) indexes when queries filter on the relevant columns, and prune chunks that do not include any relevant data for calculating the query response. * Offer new options for use cases that require foreign keys defined. You can now add foreign keys from regular tables towards hypertables. We have also removed some really annoying locks in the reverse direction that blocked access to referenced tables while compression was running. * Extend Continuous Aggregates to support more types of analytical queries. More types of joins are supported, additional equality operators on join clauses, and support for joins between multiple regular tables. **Highlighted features in this release** * Improved query performance through chunk exclusion on compressed hypertables. You can now define chunk skipping indexes on compressed chunks for any column with one of the following integer data types: `smallint`, `int`, `bigint`, `serial`, `bigserial`, `date`, `timestamp`, `timestamptz`. After you call `enable_chunk_skipping` on a column, TimescaleDB tracks the min and max values for that column. TimescaleDB uses that information to exclude chunks for queries that filter on that column, and would not find any data in those chunks. * Improved upsert performance on compressed hypertables. By using index scans to verify constraints during inserts on compressed chunks, TimescaleDB speeds up some ON CONFLICT clauses by more than 100x. * Improved performance of updates, deletes, and inserts on compressed hypertables. By filtering data while accessing the compressed data and before decompressing, TimescaleDB has improved performance for updates and deletes on all types of compressed chunks, as well as inserts into compressed chunks with unique constraints. By signaling constraint violations without decompressing, or decompressing only when matching records are found in the case of updates, deletes and upserts, TimescaleDB v2.16.0 speeds up those operations more than 1000x in some update/delete scenarios, and 10x for upserts. * You can add foreign keys from regular tables to hypertables, with support for all types of cascading options. This is useful for hypertables that partition using sequential IDs, and need to reference those IDs from other tables. * Lower locking requirements during compression for hypertables with foreign keys Advanced foreign key handling removes the need for locking referenced tables when new chunks are compressed. DML is no longer blocked on referenced tables while compression runs on a hypertable. * Improved support for queries on Continuous Aggregates `INNER/LEFT` and `LATERAL` joins are now supported. Plus, you can now join with multiple regular tables, and you can have more than one equality operator on join clauses. **PostgreSQL 13 support removal announcement** Following the deprecation announcement for PostgreSQL 13 in TimescaleDB v2.13, PostgreSQL 13 is no longer supported in TimescaleDB v2.16. The Currently supported PostgreSQL major versions are 14, 15 and 16. **Features** * #6880: Add support for the array operators used for compressed DML batch filtering. * #6895: Improve the compressed DML expression pushdown. * #6897: Add support for replica identity on compressed hypertables. * #6918: Remove support for PG13. * #6920: Rework compression activity wal markers. * #6989: Add support for foreign keys when converting plain tables to hypertables. * #7020: Add support for the chunk column statistics tracking. * #7048: Add an index scan for INSERT DML decompression. * #7075: Reduce decompression on the compressed INSERT. * #7101: Reduce decompressions for the compressed UPDATE/DELETE. * #7108 Reduce decompressions for INSERTs with UNIQUE constraints * #7116 Use DELETE instead of TRUNCATE after compression * #7134 Refactor foreign key handling for compressed hypertables * #7161 Fix `mergejoin input data is out of order` **Bugfixes** * #6987 Fix REASSIGN OWNED BY for background jobs * #7018: Fix `search_path` quoting in the compression defaults function. * #7046: Prevent locking for compressed tuples. * #7055: Fix the `scankey` for `segment by` columns, where the type `constant` is different to `variable`. * #7064: Fix the bug in the default `order by` calculation in compression. * #7069: Fix the index column name usage. * #7074: Fix the bug in the default `segment by` calculation in compression. **Thanks** * @jledentu For reporting a problem with mergejoin input order ## 2.15.3 (2024-07-02) This release contains bug fixes since the 2.15.2 release. Best practice is to upgrade at the next available opportunity. **Migrating from self-hosted TimescaleDB v2.14.x and earlier** After you run `ALTER EXTENSION`, you must run [this SQL script](https://github.com/timescale/timescaledb-extras/blob/master/utils/2.15.X-fix_hypertable_foreign_keys.sql). For more details, see the following pull request [#6797](https://github.com/timescale/timescaledb/pull/6797). If you are migrating from TimescaleDB v2.15.0, v2.15.1 or v2.15.2, no changes are required. **Bugfixes** * #7035: Fix the error when acquiring a tuple lock on the OSM chunks on the replica. * #7061: Fix the handling of multiple unique indexes in a compressed INSERT. * #7080: Fix the `corresponding equivalence member not found` error. * #7088: Fix the leaks in the DML functions. * #7091: Fix ORDER BY/GROUP BY expression not found in targetlist on PG16 **Thanks** * @Kazmirchuk for reporting the issue about leaks with the functions in DML. ## 2.15.2 (2024-06-07) This release contains bug fixes since the 2.15.1 release. Best practice is to upgrade at the next available opportunity. **Migrating from self-hosted TimescaleDB v2.14.x and earlier** After you run `ALTER EXTENSION`, you must run [this SQL script](https://github.com/timescale/timescaledb-extras/blob/master/utils/2.15.X-fix_hypertable_foreign_keys.sql). For more details, see the following pull request [#6797](https://github.com/timescale/timescaledb/pull/6797). If you are migrating from TimescaleDB v2.15.0 or v2.15.1, no changes are required. **Bugfixes** * #6975: Fix sort pushdown for partially compressed chunks. * #6976: Fix removal of metadata function and update script. * #6978: Fix segfault in `compress_chunk` with a primary space partition. * #6993: Disallow hash partitioning on primary column. **Thanks** * @gugu for reporting the issue with catalog corruption due to update. * @srieding for reporting an issue with partially compressed chunks and ordering on joined columns. ## 2.15.1 (2024-05-28) This release contains bug fixes since the 2.15.0 release. Best practice is to upgrade at the next available opportunity. **Migrating from self-hosted TimescaleDB v2.14.x and earlier** After you run `ALTER EXTENSION`, you must run [this SQL script](https://github.com/timescale/timescaledb-extras/blob/master/utils/2.15.X-fix_hypertable_foreign_keys.sql). For more details, see the following pull request [#6797](https://github.com/timescale/timescaledb/pull/6797). If you are migrating from TimescaleDB v2.15.0, no changes are required. **Bugfixes** * #6540: Segmentation fault when you backfill data using COPY into a compressed chunk. * #6858: `BEFORE UPDATE` trigger not working correctly. * #6908: Fix `time_bucket_gapfill()` with timezone behaviour around daylight savings time (DST) switches. * #6911: Fix dropped chunk metadata removal in the update script. * #6940: Fix `pg_upgrade` failure by removing `regprocedure` from the catalog table. * #6957: Fix then `segfault` in UNION queries that contain ordering on compressed chunks. **Thanks** * @DiAifU, @kiddhombre and @intermittentnrg for reporting the issues with gapfill and daylight saving time. * @edgarzamora for reporting the issue with update triggers. * @hongquan for reporting the issue with the update script. * @iliastsa and @SystemParadox for reporting the issue with COPY into a compressed chunk. ## 2.15.0 (2024-05-08) This release contains performance improvements and bug fixes since the 2.14.2 release. Best practice is to upgrade at the next available opportunity. In addition, it includes these noteworthy features: * Support `time_bucket` with `origin` and/or `offset` on Continuous Aggregate * Compression improvements: - Improve expression pushdown - Add minmax sparse indexes when compressing columns with btree indexes - Improve compression setting defaults - Vectorize filters in WHERE clause that contain text equality operators and LIKE expressions **Deprecation warning** * Starting on this release will not be possible to create Continuous Aggregate using `time_bucket_ng` anymore and it will be completely removed on the upcoming releases. * Recommend users to [migrate their old Continuous Aggregate format to the new one](https://docs.timescale.com/use-timescale/latest/continuous-aggregates/migrate/) because it support will be completely removed in next releases prevent them to migrate. * This is the last release supporting PostgreSQL 13. **Migrating from self-hosted TimescaleDB v2.14.x and earlier** After you run `ALTER EXTENSION`, you must run [this SQL script](https://github.com/timescale/timescaledb-extras/blob/master/utils/2.15.X-fix_hypertable_foreign_keys.sql). For more details, see the following pull request [#6797](https://github.com/timescale/timescaledb/pull/6797). **Features** * #6382: Support for `time_bucket` with `origin` and `offset` in CAggs. * #6696: Improve defaults for compression `segment_by` and `order_by`. * #6705: Add sparse minmax indexes for compressed columns that have uncompressed btree indexes. * #6754: Allow `DROP CONSTRAINT` on compressed hypertables. * #6767: Add metadata table `_timestaledb_internal.bgw_job_stat_history` for tracking job execution history. * #6798: Prevent usage of deprecated `time_bucket_ng` in CAgg definition. * #6810: Add telemetry for access methods. * #6811: Remove no longer relevant `timescaledb.allow_install_without_preload` GUC. * #6837: Add migration path for CAggs using `time_bucket_ng`. * #6865: Update the watermark when truncating a CAgg. **Bugfixes** * #6617: Fix error in show_chunks. * #6621: Remove metadata when dropping chunks. * #6677: Fix snapshot usage in CAgg invalidation scanner. * #6698: Define meaning of 0 retries for jobs as no retries. * #6717: Fix handling of compressed tables with primary or unique index in COPY path. * #6726: Fix constify cagg_watermark using window function when querying a CAgg. * #6729: Fix NULL start value handling in CAgg refresh. * #6732: Fix CAgg migration with custom timezone / date format settings. * #6752: Remove custom autovacuum setting from compressed chunks. * #6770: Fix plantime chunk exclusion for OSM chunk. * #6789: Fix deletes with subqueries and compression. * #6796: Fix a crash involving a view on a hypertable. * #6797: Fix foreign key constraint handling on compressed hypertables. * #6816: Fix handling of chunks with no contraints. * #6820: Fix a crash when the ts_hypertable_insert_blocker was called directly. * #6849: Use non-orderby compressed metadata in compressed DML. * #6867: Clean up compression settings when deleting compressed cagg. * #6869: Fix compressed DML with constraints of form value OP column. * #6870: Fix bool expression pushdown for queries on compressed chunks. **Thanks** * @brasic for reporting a crash when the ts_hypertable_insert_blocker was called directly. * @bvanelli for reporting an issue with the jobs retry count. * @djzurawsk for reporting error when dropping chunks. * @Dzuzepppe for reporting an issue with DELETEs using subquery on compressed chunk working incorrectly. * @hongquan for reporting a `timestamp out of range` error during CAgg migrations. * @kevcenteno for reporting an issue with the show_chunks API showing incorrect output when `created_before/created_after` was used with time-partitioned columns. * @mahipv for starting working on the job history PR. * @rovo89 for reporting constify cagg_watermark not working using window function when querying a CAgg. ## 2.14.2 (2024-02-20) This release contains bug fixes since the 2.14.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #6655 Fix segfault in cagg_validate_query * #6660 Fix refresh on empty CAgg with variable bucket * #6670 Don't try to compress osm chunks **Thanks** * @kav23alex for reporting a segfault in cagg_validate_query ## 2.14.1 (2024-02-14) This release contains bug fixes since the 2.14.0 release. We recommend that you upgrade at the next available opportunity. **Features** * #6630 Add views for per chunk compression settings **Bugfixes** * #6636 Fixes extension update of compressed hypertables with dropped columns * #6637 Reset sequence numbers on non-rollup compression * #6639 Disable default indexscan for compression * #6651 Fix DecompressChunk path generation with per chunk settings **Thanks** * @anajavi for reporting an issue with extension update of compressed hypertables ## 2.14.0 (2024-02-08) This release contains performance improvements and bug fixes since the 2.13.1 release. We recommend that you upgrade at the next available opportunity. In addition, it includes these noteworthy features: * Ability to change compression settings on existing compressed hypertables at any time. New compression settings take effect on any new chunks that are compressed after the change. * Reduced locking requirements during chunk recompression * Limiting tuple decompression during DML operations to avoid decompressing a lot of tuples and causing storage issues (100k limit, configurable) * Helper functions for determining compression settings * Plan-time chunk exclusion for real-time Continuous Aggregate by constifying the cagg_watermark function call, leading to faster queries using real-time continuous aggregates **For this release only**, you will need to restart the database before running `ALTER EXTENSION` **Multi-node support removal announcement** Following the deprecation announcement for Multi-node in TimescaleDB 2.13, Multi-node is no longer supported starting with TimescaleDB 2.14. TimescaleDB 2.13 is the last version that includes multi-node support. Learn more about it [here](docs/MultiNodeDeprecation.md). If you want to migrate from multi-node TimescaleDB to single-node TimescaleDB, read the [migration documentation](https://docs.timescale.com/migrate/latest/multi-node-to-timescale-service/). **Deprecation notice: recompress_chunk procedure** TimescaleDB 2.14 is the last version that will include the recompress_chunk procedure. Its functionality will be replaced by the compress_chunk function, which, starting on TimescaleDB 2.14, works on both uncompressed and partially compressed chunks. The compress_chunk function should be used going forward to fully compress all types of chunks or even recompress old fully compressed chunks using new compression settings (through the newly introduced recompress optional parameter). **Features** * #6325 Add plan-time chunk exclusion for real-time CAggs * #6360 Remove support for creating Continuous Aggregates with old format * #6386 Add functions for determining compression defaults * #6410 Remove multinode public API * #6440 Allow SQLValueFunction pushdown into compressed scan * #6463 Support approximate hypertable size * #6513 Make compression settings per chunk * #6529 Remove reindex_relation from recompression * #6531 Fix if_not_exists behavior for CAgg policy with NULL offsets * #6545 Remove restrictions for changing compression settings * #6566 Limit tuple decompression during DML operations * #6579 Change compress_chunk and decompress_chunk to idempotent version by default * #6608 Add LWLock for OSM usage in loader * #6609 Deprecate recompress_chunk * #6609 Add optional recompress argument to compress_chunk **Bugfixes** * #6541 Inefficient join plans on compressed hypertables. * #6491 Enable now() plantime constification with BETWEEN * #6494 Fix create_hypertable referenced by fk succeeds * #6498 Suboptimal query plans when using time_bucket with query parameters * #6507 time_bucket_gapfill with timezones doesn't handle daylight savings * #6509 Make extension state available through function * #6512 Log extension state changes * #6522 Disallow triggers on CAggs * #6523 Reduce locking level on compressed chunk index during segmentwise recompression * #6531 Fix if_not_exists behavior for CAgg policy with NULL offsets * #6571 Fix pathtarget adjustment for MergeAppend paths in aggregation pushdown code * #6575 Fix compressed chunk not found during upserts * #6592 Fix recompression policy ignoring partially compressed chunks * #6610 Ensure qsort comparison function is transitive **Thanks** * @coney21 and @GStechschulte for reporting the problem with inefficient join plans on compressed hypertables. * @HollowMan6 for reporting triggers not working on materialized views of CAggs * @jbx1 for reporting suboptimal query plans when using time_bucket with query parameters * @JerkoNikolic for reporting the issue with gapfill and DST * @pdipesh02 for working on removing the old Continuous Aggregate format * @raymalt and @martinhale for reporting very slow query plans on realtime CAggs queries ## 2.13.1 (2024-01-09) This release contains bug fixes since the 2.13.0 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #6365 Use numrows_pre_compression in approximate row count * #6377 Use processed group clauses in PG16 * #6384 Change bgw_log_level to use PGC_SUSET * #6393 Disable vectorized sum for expressions. * #6405 Read CAgg watermark from materialized data * #6408 Fix groupby pathkeys for gapfill in PG16 * #6428 Fix index matching during DML decompression * #6439 Fix compressed chunk permission handling on PG16 * #6443 Fix lost concurrent CAgg updates * #6454 Fix unique expression indexes on compressed chunks * #6465 Fix use of freed path in decompression sort logic **Thanks** * @MA-MacDonald for reporting an issue with gapfill in PG16 * @aarondglover for reporting an issue with unique expression indexes on compressed chunks * @adriangb for reporting an issue with security barrier views on pg16 ## 2.13.0 (2023-11-28) This release contains performance improvements, an improved hypertable DDL API and bug fixes since the 2.12.2 release. We recommend that you upgrade at the next available opportunity. In addition, it includes these noteworthy features: * Full PostgreSQL 16 support for all existing features * Vectorized aggregation execution for sum() * Track chunk creation time used in retention/compression policies **Deprecation notice: Multi-node support** TimescaleDB 2.13 is the last version that will include multi-node support. Multi-node support in 2.13 is available for PostgreSQL 13, 14 and 15. Learn more about it [here](docs/MultiNodeDeprecation.md). If you want to migrate from multi-node TimescaleDB to single-node TimescaleDB read the [migration documentation](https://docs.timescale.com/migrate/latest/multi-node-to-timescale-service/). **PostgreSQL 13 deprecation announcement** We will continue supporting PostgreSQL 13 until April 2024. Sooner to that time, we will announce the specific version of TimescaleDB in which PostgreSQL 13 support will not be included going forward. **Starting from TimescaleDB 2.13.0** * No Amazon Machine Images (AMI) are published. If you previously used AMI, please use another [installation method](https://docs.timescale.com/self-hosted/latest/install/) * Continuous Aggregates are materialized only (non-realtime) by default **Features** * #5575 Add chunk-wise sorted paths for compressed chunks * #5761 Simplify hypertable DDL API * #5890 Reduce WAL activity by freezing compressed tuples immediately * #6050 Vectorized aggregation execution for sum() * #6062 Add metadata for chunk creation time * #6077 Make Continous Aggregates materialized only (non-realtime) by default * #6177 Change show_chunks/drop_chunks using chunk creation time * #6178 Show batches/tuples decompressed during DML operations in EXPLAIN output * #6185 Keep track of catalog version * #6227 Use creation time in retention/compression policy * #6307 Add SQL function cagg_validate_query **Bugfixes** * #6188 Add GUC for setting background worker log level * #6222 Allow enabling compression on hypertable with unique expression index * #6240 Check if worker registration succeeded * #6254 Fix exception detail passing in compression_policy_execute * #6264 Fix missing bms_del_member result assignment * #6275 Fix negative bitmapset member not allowed in compression * #6280 Potential data loss when compressing a table with a partial index that matches compression order. * #6289 Add support for startup chunk exclusion with aggs * #6290 Repair relacl on upgrade * #6297 Fix segfault when creating a cagg using a NULL width in time bucket function * #6305 Make timescaledb_functions.makeaclitem strict * #6332 Fix typmod and collation for segmentby columns * #6339 Fix tablespace with constraints * #6343 Enable segmentwise recompression in compression policy **Thanks** * @fetchezar for reporting an issue with compression policy error messages * @jflambert for reporting the background worker log level issue * @torazem for reporting an issue with compression and large oids * @fetchezar for reporting an issue in the compression policy * @lyp-bobi for reporting an issue with tablespace with constraints * @pdipesh02 for contributing to the implementation of the metadata for chunk creation time, the generalized hypertable API, and show_chunks/drop_chunks using chunk creation time * @lkshminarayanan for all his work on PG16 support ## 2.12.2 (2023-10-19) This release contains bug fixes since the 2.12.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #6155 Align gapfill bucket generation with time_bucket * #6181 Ensure fixed_schedule field is populated * #6210 Fix EXPLAIN ANALYZE for compressed DML ## 2.12.1 (2023-10-12) This release contains bug fixes since the 2.12.0 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #6113 Fix planner distributed table count * #6117 Avoid decompressing batches using an empty slot * #6123 Fix concurrency errors in OSM API * #6142 do not throw an error when deprecation GUC cannot be read **Thanks** * @symbx for reporting a crash when selecting from empty hypertables ## 2.12.0 (2023-09-27) This release contains performance improvements for compressed hypertables and continuous aggregates and bug fixes since the 2.11.2 release. We recommend that you upgrade at the next available opportunity. This release moves all internal functions from the _timescaleb_internal schema into the _timescaledb_functions schema. This separates code from internal data objects and improves security by allowing more restrictive permissions for the code schema. If you are calling any of those internal functions you should adjust your code as soon as possible. This version also includes a compatibility layer that allows calling them in the old location but that layer will be removed in 2.14.0. **PostgreSQL 12 support removal announcement** Following the deprecation announcement for PostgreSQL 12 in TimescaleDB 2.10, PostgreSQL 12 is not supported starting with TimescaleDB 2.12. Currently supported PostgreSQL major versions are 13, 14 and 15. PostgreSQL 16 support will be added with a following TimescaleDB release. **Features** * #5137 Insert into index during chunk compression * #5150 MERGE support on hypertables * #5515 Make hypertables support replica identity * #5586 Index scan support during UPDATE/DELETE on compressed hypertables * #5596 Support for partial aggregations at chunk level * #5599 Enable ChunkAppend for partially compressed chunks * #5655 Improve the number of parallel workers for decompression * #5758 Enable altering job schedule type through `alter_job` * #5805 Make logrepl markers for (partial) decompressions * #5809 Relax invalidation threshold table-level lock to row-level when refreshing a Continuous Aggregate * #5839 Support CAgg names in chunk_detailed_size * #5852 Make set_chunk_time_interval CAggs aware * #5868 Allow ALTER TABLE ... REPLICA IDENTITY (FULL|INDEX) on materialized hypertables (continuous aggregates) * #5875 Add job exit status and runtime to log * #5909 CREATE INDEX ONLY ON hypertable creates index on chunks **Bugfixes** * #5860 Fix interval calculation for hierarchical CAggs * #5894 Check unique indexes when enabling compression * #5951 _timescaledb_internal.create_compressed_chunk doesn't account for existing uncompressed rows * #5988 Move functions to _timescaledb_functions schema * #5788 Chunk_create must add an existing table or fail * #5872 Fix duplicates on partially compressed chunk reads * #5918 Fix crash in COPY from program returning error * #5990 Place data in first/last function in correct mctx * #5991 Call eq_func correctly in time_bucket_gapfill * #6015 Correct row count in EXPLAIN ANALYZE INSERT .. ON CONFLICT output * #6035 Fix server crash on UPDATE of compressed chunk * #6044 Fix server crash when using duplicate segmentby column * #6045 Fix segfault in set_integer_now_func * #6053 Fix approximate_row_count for CAggs * #6081 Improve compressed DML datatype handling * #6084 Propagate parameter changes to decompress child nodes * #6102 Schedule compression policy more often **Thanks** * @ajcanterbury for reporting a problem with lateral joins on compressed chunks * @alexanderlaw for reporting multiple server crashes * @lukaskirner for reporting a bug with monthly continuous aggregates * @mrksngl for reporting a bug with unusual user names * @willsbit for reporting a crash in time_bucket_gapfill ## 2.11.2 (2023-08-09) This release contains bug fixes since the 2.11.1 release. We recommend that you upgrade at the next available opportunity. **Features** * #5923 Feature flags for TimescaleDB features **Bugfixes** * #5680 Fix DISTINCT query with JOIN on multiple segmentby columns * #5774 Fixed two bugs in decompression sorted merge code * #5786 Ensure pg_config --cppflags are passed * #5906 Fix quoting owners in sql scripts. * #5912 Fix crash in 1-step integer policy creation **Thanks** * @mrksngl for submitting a PR to fix extension upgrade scripts * @ericdevries for reporting an issue with DISTINCT queries using segmentby columns of compressed hypertable ## 2.11.1 (2023-06-29) This release contains bug fixes since the 2.11.0 release. We recommend that you upgrade at the next available opportunity. **Features** * #5679 Update the loader to add support for the OSM extension (used for data tiering on [Timescale](https://www.timescale.com/)) **Bugfixes** * #5705 Scheduler accidentally getting killed when calling `delete_job` * #5742 Fix Result node handling with ConstraintAwareAppend on compressed chunks * #5750 Ensure tlist is present in decompress chunk plan * #5754 Fixed handling of NULL values in bookend_sfunc * #5798 Fixed batch look ahead in compressed sorted merge * #5804 Mark cagg_watermark function as PARALLEL RESTRICTED * #5807 Copy job config JSONB structure into current MemoryContext * #5824 Improve continuous aggregate query chunk exclusion **Thanks** * @JamieD9 for reporting an issue with a wrong result ordering * @xvaara for reporting an issue with Result node handling in ConstraintAwareAppend ## 2.11.0 (2023-05-12) This release contains new features and bug fixes since the 2.10.3 release. We deem it moderate priority for upgrading. This release includes these noteworthy features: * Support for DML operations on compressed chunks: * UPDATE/DELETE support * Support for unique constraints on compressed chunks * Support for `ON CONFLICT DO UPDATE` * Support for `ON CONFLICT DO NOTHING` * Join support for Hierarchical Continuous Aggregates * Performance improvements for real-time Hierarchical Continuous Aggregates **Features** * #5212 Allow pushdown of reference table joins * #5261 Improve Realtime Continuous Aggregate performance * #5252 Improve unique constraint support on compressed hypertables * #5339 Support UPDATE/DELETE on compressed hypertables * #5344 Enable JOINS for Hierarchical Continuous Aggregates * #5361 Add parallel support for partialize_agg() * #5417 Refactor and optimize distributed COPY * #5454 Add support for ON CONFLICT DO UPDATE for compressed hypertables * #5547 Skip Ordered Append when only 1 child node is present * #5510 Propagate vacuum/analyze to compressed chunks * #5584 Reduce decompression during constraint checking * #5530 Optimize compressed chunk resorting * #5639 Support sending telemetry event reports **Bugfixes** * #5396 Fix SEGMENTBY columns predicates to be pushed down * #5427 Handle user-defined FDW options properly * #5442 Decompression may have lost DEFAULT values * #5459 Fix issue creating dimensional constraints * #5570 Improve interpolate error message on datatype mismatch * #5573 Fix unique constraint on compressed tables * #5615 Add permission checks to run_job() * #5614 Enable run_job() for telemetry job * #5578 Fix on-insert decompression after schema changes * #5613 Quote username identifier appropriately * #5525 Fix tablespace for compressed hypertable and corresponding toast * #5642 Fix ALTER TABLE SET with normal tables * #5666 Reduce memory usage for distributed analyze * #5668 Fix subtransaction resource owner **Thanks** * @kovetskiy and @DZDomi for reporting peformance regression in Realtime Continuous Aggregates * @ollz272 for reporting an issue with interpolate error messages ## 2.10.3 (2023-04-26) **Bugfixes** * #5583 Fix parameterization in DecompressChunk path generation * #5602 Fix broken CAgg with JOIN repair function ## 2.10.2 (2023-04-20) **Bugfixes** * #5410 Fix file trailer handling in the COPY fetcher * #5446 Add checks for malloc failure in libpq calls * #5233 Out of on_proc_exit slots on guc license change * #5428 Use consistent snapshots when scanning metadata * #5499 Do not segfault on large histogram() parameters * #5470 Ensure superuser perms during copy/move chunk * #5500 Fix when no FROM clause in continuous aggregate definition * #5433 Fix join rte in CAggs with joins * #5556 Fix duplicated entries on timescaledb_experimental.policies view * #5462 Fix segfault after column drop on compressed table * #5543 Copy scheduled_jobs list before sorting it * #5497 Allow named time_bucket arguments in Cagg definition * #5544 Fix refresh from beginning of Continuous Aggregate with variable time bucket * #5558 Use regrole for job owner * #5542 Enable indexscan on uncompressed part of partially compressed chunks **Thanks** * @nikolaps for reporting an issue with the COPY fetcher * @S-imo-n for reporting the issue on Background Worker Scheduler crash * @geezhu for reporting issue on segfault in historgram() * @mwahlhuetter for reporting the issue with joins in CAggs * @mwahlhuetter for reporting issue with duplicated entries on timescaledb_experimental.policies view * @H25E for reporting error refreshing from beginning of a Continuous Aggregate with variable time bucket ## 2.10.1 (2023-03-07) This release contains bug fixes since the 2.10.0 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #5159 Support Continuous Aggregates names in hypertable_(detailed_)size * #5226 Fix concurrent locking with chunk_data_node table * #5317 Fix some incorrect memory handling * #5336 Use NameData and namestrcpy for names * #5343 Set PortalContext when starting job * #5360 Fix uninitialized bucket_info variable * #5362 Make copy fetcher more async * #5364 Fix num_chunks inconsistency in hypertables view * #5367 Fix column name handling in old-style continuous aggregates * #5378 Fix multinode DML HA performance regression * #5384 Fix Hierarchical Continuous Aggregates chunk_interval_size **Thanks** * @justinozavala for reporting an issue with PL/Python procedures in the background worker * @Medvecrab for discovering an issue with copying NameData when forming heap tuples. * @pushpeepkmonroe for discovering an issue in upgrading old-style continuous aggregates with renamed columns ## 2.10.0 (2023-02-21) This release contains new features and bug fixes since the 2.9.3 release. We deem it moderate priority for upgrading. This release includes these noteworthy features: * Joins in continuous aggregates * Re-architecture of how compression works: ~2x improvement on INSERT rate into compressed chunks. * Full PostgreSQL 15 support for all existing features. Support for the newly introduced MERGE command on hypertables will be introduced on a follow-up release. **PostgreSQL 12 deprecation announcement** We will continue supporting PostgreSQL 12 until July 2023. Sooner to that time, we will announce the specific version of TimescaleDB in which PostgreSQL 12 support will not be included going forward. **Old format of Continuous Aggregates deprecation announcement** TimescaleDB 2.7 introduced a new format for continuous aggregates that improves performance. All instances with Continuous Aggregates using the old format should [migrate to the new format](https://docs.timescale.com/api/latest/continuous-aggregates/cagg_migrate/) by July 2023, when support for the old format will be removed. Sooner to that time, we will announce the specific version of TimescaleDB in which support for this feature will not be included going forward. **Features** * #4874 Allow joins in continuous aggregates * #4926 Refactor INSERT into compressed chunks * #5241 Allow RETURNING clause when inserting into compressed chunks * #5245 Manage life-cycle of connections via memory contexts * #5246 Make connection establishment interruptible * #5253 Make data node command execution interruptible * #5262 Extend enabling compression on a continuous aggregrate with 'compress_segmentby' and 'compress_orderby' parameters **Bugfixes** * #5214 Fix use of prepared statement in async module * #5218 Add role-level security to job error log * #5239 Fix next_start calculation for fixed schedules * #5290 Fix enabling compression on continuous aggregates with columns requiring quotation **Thanks** * @henriquegelio for reporting the issue on fixed schedules ## 2.9.3 (2023-02-03) This release contains bug fixes since the 2.9.2 release and a fix for a security vulnerability (#5259). You can check the security advisory(https://github.com/timescale/timescaledb/security/advisories/GHSA-44jh-j22r-33wq) for more information on the vulnerability and the platforms that are affected. This release is high priority for upgrade. We strongly recommend that you upgrade as soon as possible. **Bugfixes** * #4804 Skip bucketing when start or end of refresh job is null * #5108 Fix column ordering in compressed table index not following the order of a multi-column segment by definition * #5187 Don't enable clang-tidy by default * #5255 Fix year not being considered as a multiple of day/month in hierarchical continuous aggregates * #5259 Lock down search_path in SPI calls **Thanks** * @ssmoss for reporting issues on continuous aggregates * @jaskij for reporting the compliation issue that occurred with clang ## 2.9.2 (2023-01-26) This release contains bug fixes since the 2.9.1 release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #5114 Fix issue with deleting data node and dropping the database on multi-node * #5133 Fix creating a CAgg on a CAgg where the time column is in a different order of the original hypertable * #5152 Fix adding column with NULL constraint to compressed hypertable * #5170 Fix CAgg on CAgg variable bucket size validation * #5180 Fix default data node availability status on multi-node * #5181 Fix ChunkAppend and ConstraintAwareAppend with TidRangeScan child subplan * #5193 Fix repartition behavior when attaching data node on multi-node **Thanks** * @salquier-appvizer for reporting error on CAgg on CAgg using different column order on the original hypertable * @ikkala for reporting error when adding column with NULL constraint to compressed hypertable * @ssmoss, @adbnexxtlab and @ivanzamanov for reporting error on CAgg on CAgg variable bucket size validation * @ronnyas for reporting a bug "Invalid child of chunk" on specific ctid filtering ## 2.9.1 (2022-12-23) This release contains bug fixes since the 2.9.0 release. This release is high priority for upgrade. We strongly recommend that you upgrade as soon as possible. **Bugfixes** * #5072 Fix CAgg on CAgg bucket size validation * #5101 Fix enabling compression on caggs with renamed columns * #5106 Fix building against PG15 on Windows * #5117 Fix postgres server restart on background worker exit * #5121 Fix privileges for job_errors in update script ## 2.9.0 (2022-12-15) This release adds major new features since the 2.8.1 release. We deem it moderate priority for upgrading. This release includes these noteworthy features: * Hierarchical Continuous Aggregates (aka Continuous Aggregate on top of another Continuous Aggregate) * Improve `time_bucket_gapfill` function to allow specifying the timezone to bucket * Introduce fixed schedules for background jobs and the ability to check job errors. * Use `alter_data_node()` to change the data node configuration. This function introduces the option to configure the availability of the data node. This release also includes several bug fixes. **Features** * #4476 Batch rows on access node for distributed COPY * #4567 Exponentially backoff when out of background workers * #4650 Show warnings when not following best practices * #4664 Introduce fixed schedules for background jobs * #4668 Hierarchical Continuous Aggregates * #4670 Add timezone support to time_bucket_gapfill * #4678 Add interface for troubleshooting job failures * #4718 Add ability to merge chunks while compressing * #4786 Extend the now() optimization to also apply to CURRENT_TIMESTAMP * #4820 Support parameterized data node scans in joins * #4830 Add function to change configuration of a data nodes * #4966 Handle DML activity when datanode is not available * #4971 Add function to drop stale chunks on a datanode **Bugfixes** * #4663 Don't error when compression metadata is missing * #4673 Fix now() constification for VIEWs * #4681 Fix compression_chunk_size primary key * #4696 Report warning when enabling compression on hypertable * #4745 Fix FK constraint violation error while insert into hypertable which references partitioned table * #4756 Improve compression job IO performance * #4770 Continue compressing other chunks after an error * #4794 Fix degraded performance seen on timescaledb_internal.hypertable_local_size() function * #4807 Fix segmentation fault during INSERT into compressed hypertable * #4822 Fix missing segmentby compression option in CAGGs * #4823 Fix a crash that could occur when using nested user-defined functions with hypertables * #4840 Fix performance regressions in the copy code * #4860 Block multi-statement DDL command in one query * #4898 Fix cagg migration failure when trying to resume * #4904 Remove BitmapScan support in DecompressChunk * #4906 Fix a performance regression in the query planner by speeding up frozen chunk state checks * #4910 Fix a typo in process_compressed_data_out * #4918 Cagg migration orphans cagg policy * #4941 Restrict usage of the old format (pre 2.7) of continuous aggregates in PostgreSQL 15. * #4955 Fix cagg migration for hypertables using timestamp without timezone * #4968 Check for interrupts in gapfill main loop * #4988 Fix cagg migration crash when refreshing the newly created cagg * #5054 Fix segfault after second ANALYZE * #5086 Reset baserel cache on invalid hypertable cache **Thanks** * @byazici for reporting a problem with segmentby on compressed caggs * @jflambert for reporting a crash with nested user-defined functions. * @jvanns for reporting hypertable FK reference to vanilla PostgreSQL partitioned table doesn't seem to work * @kou for fixing a typo in process_compressed_data_out * @kyrias for reporting a crash when ANALYZE is executed on extended query protocol mode with extension loaded. * @tobiasdirksen for requesting Continuous aggregate on top of another continuous aggregate * @xima for reporting a bug in Cagg migration * @xvaara for helping reproduce a bug with bitmap scans in transparent decompression ## 2.8.1 (2022-10-06) This release is a patch release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #4454 Keep locks after reading job status * #4658 Fix error when querying a compressed hypertable with compress_segmentby on an enum column * #4671 Fix a possible error while flushing the COPY data * #4675 Fix bad TupleTableSlot drop * #4676 Fix a deadlock when decompressing chunks and performing SELECTs * #4685 Fix chunk exclusion for space partitions in SELECT FOR UPDATE queries * #4694 Change parameter names of cagg_migrate procedure * #4698 Do not use row-by-row fetcher for parameterized plans * #4711 Remove support for procedures as custom checks * #4712 Fix assertion failure in constify_now * #4713 Fix Continuous Aggregate migration policies * #4720 Fix chunk exclusion for prepared statements and dst changes * #4726 Fix gapfill function signature * #4737 Fix join on time column of compressed chunk * #4738 Fix error when waiting for remote COPY to finish * #4739 Fix continuous aggregate migrate check constraint * #4760 Fix segfault when INNER JOINing hypertables * #4767 Fix permission issues on index creation for CAggs **Thanks** * @boxhock and @cocowalla for reporting a segfault when JOINing hypertables * @carobme for reporting constraint error during continuous aggregate migration * @choisnetm, @dustinsorensen, @jayadevanm and @joeyberkovitz for reporting a problem with JOINs on compressed hypertables * @daniel-k for reporting a background worker crash * @justinpryzby for reporting an error when compressing very wide tables * @maxtwardowski for reporting problems with chunk exclusion and space partitions * @yuezhihan for reporting GROUP BY error when having compress_segmentby on an enum column ## 2.8.0 (2022-08-30) This release adds major new features since the 2.7.2 release. We deem it moderate priority for upgrading. This release includes these noteworthy features: * time_bucket now supports bucketing by month, year and timezone * Improve performance of bulk SELECT and COPY for distributed hypertables * 1 step CAgg policy management * Migrate Continuous Aggregates to the new format **Features** * #4188 Use COPY protocol in row-by-row fetcher * #4307 Mark partialize_agg as parallel safe * #4380 Enable chunk exclusion for space dimensions in UPDATE/DELETE * #4384 Add schedule_interval to policies * #4390 Faster lookup of chunks by point * #4393 Support intervals with day component when constifying now() * #4397 Support intervals with month component when constifying now() * #4405 Support ON CONFLICT ON CONSTRAINT for hypertables * #4412 Add telemetry about replication * #4415 Drop remote data when detaching data node * #4416 Handle TRUNCATE TABLE on chunks * #4425 Add parameter check_config to alter_job * #4430 Create index on Continuous Aggregates * #4439 Allow ORDER BY on continuous aggregates * #4443 Add stateful partition mappings * #4484 Use non-blocking data node connections for COPY * #4495 Support add_dimension() with existing data * #4502 Add chunks to baserel cache on chunk exclusion * #4545 Add hypertable distributed argument and defaults * #4552 Migrate Continuous Aggregates to the new format * #4556 Add runtime exclusion for hypertables * #4561 Change get_git_commit to return full commit hash * #4563 1 step CAgg policy management * #4641 Allow bucketing by month, year, century in time_bucket and time_bucket_gapfill * #4642 Add timezone support to time_bucket **Bugfixes** * #4359 Create composite index on segmentby columns * #4374 Remove constified now() constraints from plan * #4416 Handle TRUNCATE TABLE on chunks * #4478 Synchronize chunk cache sizes * #4486 Adding boolean column with default value doesn't work on compressed table * #4512 Fix unaligned pointer access * #4519 Throw better error message on incompatible row fetcher settings * #4549 Fix dump_meta_data for windows * #4553 Fix timescaledb_post_restore GUC handling * #4573 Load TSL library on compressed_data_out call * #4575 Fix use of `get_partition_hash` and `get_partition_for_key` inside an IMMUTABLE function * #4577 Fix segfaults in compression code with corrupt data * #4580 Handle default privileges on CAggs properly * #4582 Fix assertion in GRANT .. ON ALL TABLES IN SCHEMA * #4583 Fix partitioning functions * #4589 Fix rename for distributed hypertable * #4601 Reset compression sequence when group resets * #4611 Fix a potential OOM when loading large data sets into a hypertable * #4624 Fix heap buffer overflow * #4627 Fix telemetry initialization * #4631 Ensure TSL library is loaded on database upgrades * #4646 Fix time_bucket_ng origin handling * #4647 Fix the error "SubPlan found with no parent plan" that occurred if using joins in RETURNING clause. **Thanks** * @AlmiS for reporting error on `get_partition_hash` executed inside an IMMUTABLE function * @Creatation for reporting an issue with renaming hypertables * @janko for reporting an issue when adding bool column with default value to compressed hypertable * @jayadevanm for reporting error of TRUNCATE TABLE on compressed chunk * @michaelkitson for reporting permission errors using default privileges on Continuous Aggregates * @mwahlhuetter for reporting error in joins in RETURNING clause * @ninjaltd and @mrksngl for reporting a potential OOM when loading large data sets into a hypertable * @PBudmark for reporting an issue with dump_meta_data.sql on Windows * @ssmoss for reporting an issue with time_bucket_ng origin handling ## 2.7.2 (2022-07-26) This release is a patch release. We recommend that you upgrade at the next available opportunity. Among other things this release fixes several memory leaks, handling of TOASTed values in GapFill and parameter handling in prepared statements. **Bugfixes** * #4517 Fix prepared statement param handling in ChunkAppend * #4522 Fix ANALYZE on dist hypertable for a set of nodes * #4526 Fix gapfill group comparison for TOASTed values * #4527 Handle stats properly for range types * #4532 Fix memory leak in function telemetry * #4534 Use explicit memory context with hash_create * #4538 Fix chunk creation on hypertables with non-default statistics **Thanks** * @3a6u9ka, @bgemmill, @hongquan, @stl-leonid-kalmaev and @victor-sudakov for reporting a memory leak * @hleung2021 and @laocaixw for reporting an issue with parameter handling in prepared statements ## 2.7.1 (2022-07-07) This release is a patch release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #4494 Handle timescaledb versions aptly in multinode * #4493 Segfault when executing IMMUTABLE functions * #4482 Fix race conditions during chunk (de)compression * #4367 Improved buffer management in the copy operator * #4375 Don't ask for orderby column if default already set * #4400 Use our implementation of `find_em_expr_for_rel` for PG15+ * #4408 Fix crash during insert into distributed hypertable * #4411 Add `shmem_request_hook` * #4437 Fix segfault in subscription_exec * #4442 Fix perms in copy/move chunk * #4450 Retain hypertable ownership on `attach_data_node` * #4451 Repair numeric partial state on the fly * #4463 Fix empty bytea handlng with distributed tables * #4469 Better superuser handling for `move_chunk` **Features** * #4244 Function telemetry * #4287 Add internal api for foreign table chunk * #4470 Block drop chunk if chunk is in frozen state * #4464 Add internal api to associate a hypertable with custom jobs **Thanks** * @xin-hedera Finding bug in empty bytea values for distributed tables * @jflambert for reporting a bug with IMMUTABLE functions * @nikugogoi for reporting a bug with CTEs and upserts on distributed hypertables ## 2.7.0 (2022-05-24) This release adds major new features since the 2.6.1 release. We deem it moderate priority for upgrading. This release includes these noteworthy features: * Optimize continuous aggregate query performance and storage * The following query clauses and functions can now be used in a continuous aggregate: FILTER, DISTINCT, ORDER BY as well as [Ordered-Set Aggregate](https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-ORDEREDSET-TABLE) and [Hypothetical-Set Aggregate](https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-HYPOTHETICAL-TABLE) * Optimize now() query planning time * Improve COPY insert performance * Improve performance of UPDATE/DELETE on PG14 by excluding chunks This release also includes several bug fixes. If you are upgrading from a previous version and were using compression with a non-default collation on a segmentby-column you should recompress those hypertables. **Features** * #4045 Custom origin's support in CAGGs * #4120 Add logging for retention policy * #4158 Allow ANALYZE command on a data node directly * #4169 Add support for chunk exclusion on DELETE to PG14 * #4209 Add support for chunk exclusion on UPDATE to PG14 * #4269 Continuous Aggregates finals form * #4301 Add support for bulk inserts in COPY operator * #4311 Support non-superuser move chunk operations * #4330 Add GUC "bgw_launcher_poll_time" * #4340 Enable now() usage in plan-time chunk exclusion **Bugfixes** * #3899 Fix segfault in Continuous Aggregates * #4225 Fix TRUNCATE error as non-owner on hypertable * #4236 Fix potential wrong order of results for compressed hypertable with a non-default collation * #4249 Fix option "timescaledb.create_group_indexes" * #4251 Fix INSERT into compressed chunks with dropped columns * #4255 Fix option "timescaledb.create_group_indexes" * #4259 Fix logic bug in extension update script * #4269 Fix bad Continuous Aggregate view definition reported in #4233 * #4289 Support moving compressed chunks between data nodes * #4300 Fix refresh window cap for cagg refresh policy * #4315 Fix memory leak in scheduler * #4323 Remove printouts from signal handlers * #4342 Fix move chunk cleanup logic * #4349 Fix crashes in functions using AlterTableInternal * #4358 Fix crash and other issues in telemetry reporter **Thanks** * @abrownsword for reporting a bug in the telemetry reporter and testing the fix * @jsoref for fixing various misspellings in code, comments and documentation * @yalon for reporting an error with ALTER TABLE RENAME on distributed hypertables * @zhuizhuhaomeng for reporting and fixing a memory leak in our scheduler ## 2.6.1 (2022-04-11) This release is patch release. We recommend that you upgrade at the next available opportunity. **Bugfixes** * #4121 Fix RENAME TO/SET SCHEMA on distributed hypertable * #4122 Fix segfault on INSERT into distributed hypertable * #4142 Ignore invalid relid when deleting hypertable * #4159 Fix ADD COLUMN IF NOT EXISTS error on compressed hypertable * #4161 Fix memory handling during scans * #4176 Fix remote EXPLAIN with parameterized queries * #4181 Fix spelling errors and omissions * #4186 Fix owner change for distributed hypertable * #4192 Abort sessions after extension reload * #4193 Fix relcache callback handling causing crashes * #4199 Remove signal-unsafe calls from signal handlers * #4219 Do not modify aggregation state in finalize **Thanks** * @abrownsword for reporting a crash in the telemetry reporter * @amalek215 for reporting a segmentation fault when running VACUUM FULL pg_class * @daydayup863 for reporting issue with remote explain * @krvajal for reporting an error with ADD COLUMN IF NOT EXISTS on compressed hypertables ## 2.6.0 (2022-02-16) This release is medium priority for upgrade. We recommend that you upgrade at the next available opportunity. This release adds major new features since the 2.5.2 release, including: * Compression in continuous aggregates * Experimental support for timezones in continuous aggregates * Experimental support for monthly buckets in continuous aggregates The release also includes several bug fixes. Telemetry reports now include new and more detailed statistics on regular tables and views, compression, distributed hypertables, and continuous aggregates, which will help us improve TimescaleDB. **Features** * #3768 Allow ALTER TABLE ADD COLUMN with DEFAULT on compressed hypertable * #3769 Allow ALTER TABLE DROP COLUMN on compressed hypertable * #3943 Optimize first/last * #3945 Add support for ALTER SCHEMA on multi-node * #3949 Add support for DROP SCHEMA on multi-node **Bugfixes** * #3808 Properly handle `max_retries` option * #3863 Fix remote transaction heal logic * #3869 Fix ALTER SET/DROP NULL constraint on distributed hypertable * #3944 Fix segfault in add_compression_policy * #3961 Fix crash in EXPLAIN VERBOSE on distributed hypertable * #4015 Eliminate float rounding instabilities in interpolate * #4019 Update ts_extension_oid in transitioning state * #4073 Fix buffer overflow in partition scheme * #4180 ALTER TABLE OWNER TO does not work for distributed hypertable **Improvements** * Query planning performance is improved for hypertables with a large number of chunks. **Thanks** * @fvannee for reporting a first/last memory leak * @mmouterde for reporting an issue with floats and interpolate ## 2.5.2 (2022-02-09) This release contains bug fixes since the 2.5.1 release. This release is high priority for upgrade. We strongly recommend that you upgrade as soon as possible. **Bugfixes** * #3900 Improve custom scan node registration * #3911 Fix role type deparsing for GRANT command * #3918 Fix DataNodeScan plans with one-time filter * #3921 Fix segfault on insert into internal compressed table * #3938 Fix subtract_integer_from_now on 32-bit platforms and improve error handling * #3939 Fix projection handling in time_bucket_gapfill * #3948 Avoid double PGclear() in data fetchers * #3979 Fix deparsing of index predicates * #4020 Fix ALTER TABLE EventTrigger initialization * #4024 Fix premature cache release call * #4037 Fix status for dropped chunks that have catalog entries * #4069 Fix riinfo NULL handling in ANY construct * #4071 Fix extension installation privilege escalation (CVE-2022-24128) **Thanks** * @carlocperez for reporting crash with NULL handling in ANY construct * @erikhh for reporting an issue with time_bucket_gapfill * @kancsuki for reporting drop column and partial index creation not working * @mmouterde for reporting an issue with floats and interpolate * Pedro Gallegos for reporting a possible privilege escalation during extension installation ## 2.5.1 (2021-12-02) This release contains bug fixes since the 2.5.0 release. We deem it medium priority to upgrade. **Bugfixes** * #3706 Test enabling dist compression within a procedure * #3734 Rework distributed DDL processing logic * #3737 Fix flaky pg_dump * #3739 Fix compression policy on tables using INTEGER * #3766 Fix segfault in ts_hist_sfunc * #3779 Support GRANT/REVOKE on distributed database * #3789 Fix time_bucket comparison transformation * #3797 Fix DISTINCT ON queries for distributed hyperatbles * #3799 Fix error printout on correct security label * #3801 Fail size utility functions when data nodes do not respond * #3809 Fix NULL pointer evaluation in fill_result_error() * #3811 Fix INSERT..SELECT involving dist hypertables * #3819 Fix reading garbage value from TSConnectionError * #3824 Remove pointers from CAGG lists for 64-bit archs * #3846 Eliminate deadlock in recompress chunk policy * #3881 Fix SkipScan crash due to pruned unique path * #3884 Fix create_distributed_restore_point memory issue **Thanks** * @cbisnett for reporting and fixing a typo in an error message * @CaptainCuddleCube for reporting bug on compression policy procedure on tables using INTEGER on time dimension * @phemmer for reporting bugs on multi-node ## 2.5.0 (2021-10-28) This release adds major new features since the 2.4.2 release. We deem it moderate priority for upgrading. This release includes these noteworthy features: * Continuous Aggregates for Distributed Hypertables * Support for PostgreSQL 14 * Experimental: Support for timezones in `time_bucket_ng()`, including the `origin` argument This release also includes several bug fixes. **Features** * #3034 Add support for PostgreSQL 14 * #3435 Add continuous aggregates for distributed hypertables * #3505 Add support for timezones in `time_bucket_ng()` **Bugfixes** * #3580 Fix memory context bug executing TRUNCATE * #3592 Allow alter column type on distributed hypertable * #3598 Improve evaluation of stable functions such as now() on access node * #3618 Fix execution of refresh_caggs from user actions * #3625 Add shared dependencies when creating chunk * #3626 Fix memory context bug executing TRUNCATE * #3627 Schema qualify UDTs in multi-node * #3638 Allow owner change of a data node * #3654 Fix index attnum mapping in reorder_chunk * #3661 Fix SkipScan path generation with constant DISTINCT column * #3667 Fix compress_policy for multi txn handling * #3673 Fix distributed hypertable DROP within a procedure * #3701 Allow anyone to use size utilities on distributed hypertables * #3708 Fix crash in get_aggsplit * #3709 Fix ordered append pathkey check * #3712 Fix GRANT/REVOKE ALL IN SCHEMA handling * #3717 Support transparent decompression on individual chunks * #3724 Fix inserts into compressed chunks on hypertables with caggs * #3727 Fix DirectFunctionCall crash in distributed_exec * #3728 Fix SkipScan with varchar column * #3733 Fix ANALYZE crash with custom statistics for custom types * #3747 Always reset expr context in DecompressChunk **Thanks** * @binakot and @sebvett for reporting an issue with DISTINCT queries * @hardikm10, @DavidPavlicek and @pafiti for reporting bugs on TRUNCATE * @mjf for reporting an issue with ordered append and JOINs * @phemmer for reporting the issues on multinode with aggregate queries and evaluation of now() * @abolognino for reporting an issue with INSERTs into compressed hypertables that have cagg * @tanglebones for reporting the ANALYZE crash with custom types on multinode * @amadeubarbosa and @felipenogueirajack for reporting crash using JSONB column in compressed chunks ## 2.4.2 (2021-09-21) This release contains bug fixes since the 2.4.1 release. We deem it high priority to upgrade. **Bugfixes** * #3437 Rename on all continuous aggregate objects * #3469 Use signal-safe functions in signal handler * #3520 Modify compression job processing logic * #3527 Fix time_bucket_ng behaviour with origin argument * #3532 Fix bootstrap with regresschecks disabled * #3574 Fix failure on job execution by background worker * #3590 Call cleanup functions on backend exit **Thanks** * @jankatins for reporting a crash with background workers * @LutzWeischerFujitsu for reporting an issue with bootstrap ## 2.4.1 (2021-08-19) This release contains bug fixes since the 2.4.0 release. We deem it high priority to upgrade. The release fixes continous aggregate refresh for postgres 12.8 and 13.4, a crash with ALTER TABLE commands and a crash with continuous aggregates with HAVING clause. **Bugfixes** * #3430 Fix havingqual processing for continuous aggregates * #3468 Disable tests by default if tools are not found * #3462 Fix crash while tracking alter table commands * #3489 Fix continuous agg bgw job failure for PG 12.8 and 13.4 * #3494 Improve error message when adding data nodes **Thanks** * @brianbenns for reporting a segfault with continuous aggregates * @usego for reporting an issue with continuous aggregate refresh on PG 13.4 ## 2.4.0 (2021-07-29) This release adds new experimental features since the 2.3.1 release. The experimental features in this release are: * APIs for chunk manipulation across data nodes in a distributed hypertable setup. This includes the ability to add a data node and move chunks to the new data node for cluster rebalancing. * The `time_bucket_ng` function, a newer version of `time_bucket`. This function supports years, months, days, hours, minutes, and seconds. We’re committed to developing these experiments, giving the community a chance to provide early feedback and influence the direction of TimescaleDB’s development. We’ll travel faster with your input! Please create your feedback as a GitHub issue (using the experimental-schema label), describe what you found, and tell us the steps or share the code snip to recreate it. This release also includes several bug fixes. PostgreSQL 11 deprecation announcement Timescale is working hard on our next exciting features. To make that possible, we require functionality that is available in Postgres 12 and above. Postgres 11 is not supported with TimescaleDB 2.4. **Experimental Features** * #3293 Add timescaledb_experimental schema * #3302 Add block_new_chunks and allow_new_chunks API to experimental schema. Add chunk based refresh_continuous_aggregate. * #3211 Introduce experimental time_bucket_ng function * #3366 Allow use of experimental time_bucket_ng function in continuous aggregates * #3408 Support for seconds, minutes and hours in time_bucket_ng * #3446 Implement cleanup for chunk copy/move. **Bugfixes** * #3401 Fix segfault for RelOptInfo without fdw_private * #3411 Verify compressed chunk validity for compressed path * #3416 Fix targetlist names for continuous aggregate views * #3434 Remove extension check from relcache invalidation callback * #3440 Fix remote_tx_heal_data_node to work with only current database **Thanks** * @fvannee for reporting an issue with hypertable expansion in functions * @amalek215 for reporting an issue with cache invalidation during pg_class vacuum full * @hardikm10 for reporting an issue with inserting into compressed chunks * @dberardo-com and @iancmcc for reporting an issue with extension updates after renaming columns of continuous aggregates. ## 2.3.1 (2021-07-05) This maintenance release contains bugfixes since the 2.3.0 release. We deem it moderate priority for upgrading. The release introduces the possibility of generating downgrade scripts, improves the trigger handling for distributed hypertables, adds some more randomness to chunk assignment to avoid thundering herd issues in chunk assignment, and fixes some issues in update handling as well as some other bugs. **Bugfixes** * #3279 Add some more randomness to chunk assignment * #3288 Fix failed update with parallel workers * #3300 Improve trigger handling on distributed hypertables * #3304 Remove paths that reference parent relids for compressed chunks * #3305 Fix pull_varnos miscomputation of relids set * #3310 Generate downgrade script * #3314 Fix heap buffer overflow in hypertable expansion * #3317 Fix heap buffer overflow in remote connection cache. * #3327 Make aggregates in caggs fully qualified * #3336 Fix pg_init_privs objsubid handling * #3345 Fix SkipScan distinct column identification * #3355 Fix heap buffer overflow when renaming compressed hypertable columns. * #3367 Improve DecompressChunk qual pushdown * #3377 Fix bad use of repalloc **Thanks** * @db-adrian for reporting an issue when accessing cagg view through postgres_fdw * @fncaldas and @pgwhalen for reporting an issue accessing caggs when public is not in search_path * @fvannee, @mglonnro and @ebreijo for reporting an issue with the upgrade script * @fvannee for reporting a performance regression with SkipScan ## 2.3.0 (2021-05-25) This release adds major new features since the 2.2.1 release. We deem it moderate priority for upgrading. This release adds support for inserting data into compressed chunks and improves performance when inserting data into distributed hypertables. Distributed hypertables now also support triggers and compression policies. The bug fixes in this release address issues related to the handling of privileges on compressed hypertables, locking, and triggers with transition tables. **Features** * #3116 Add distributed hypertable compression policies * #3162 Use COPY when executing distributed INSERTs * #3199 Add GENERATED column support on distributed hypertables * #3210 Add trigger support on distributed hypertables * #3230 Support for inserts into compressed chunks **Bugfixes** * #3213 Propagate grants to compressed hypertables * #3229 Use correct lock mode when updating chunk * #3243 Fix assertion failure in decompress_chunk_plan_create * #3250 Fix constraint triggers on hypertables * #3251 Fix segmentation fault due to incorrect call to chunk_scan_internal * #3252 Fix blocking triggers with transition tables **Thanks** * @yyjdelete for reporting a crash with decompress_chunk and identifying the bug in the code * @fabriziomello for documenting the prerequisites when compiling against PostgreSQL 13 ## 2.2.1 (2021-05-05) This maintenance release contains bugfixes since the 2.2.0 release. We deem it high priority for upgrading. This release extends Skip Scan to multinode by enabling the pushdown of `DISTINCT` to data nodes. It also fixes a number of bugs in the implementation of Skip Scan, in distributed hypertables, in creation of indexes, in compression, and in policies. **Features** * #3113 Pushdown "SELECT DISTINCT" in multi-node to allow use of Skip Scan **Bugfixes** * #3101 Use commit date in `get_git_commit()` * #3102 Fix `REINDEX TABLE` for distributed hypertables * #3104 Fix use after free in `add_reorder_policy` * #3106 Fix use after free in `chunk_api_get_chunk_stats` * #3109 Copy recreated object permissions on update * #3111 Fix `CMAKE_BUILD_TYPE` check * #3112 Use `%u` to format Oid instead of `%d` * #3118 Fix use after free in cache * #3123 Fix crash while using `REINDEX TABLE CONCURRENTLY` * #3135 Fix SkipScan path generation in `DISTINCT` queries with expressions * #3146 Fix SkipScan for IndexPaths without pathkeys * #3147 Skip ChunkAppend if AppendPath has no children * #3148 Make `SELECT DISTINCT` handle non-var targetlists * #3151 Fix `fdw_relinfo_get` assertion failure on `DELETE` * #3155 Inherit `CFLAGS` from PostgreSQL * #3169 Fix incorrect type cast in compression policy * #3183 Fix segfault in calculate_chunk_interval * #3185 Fix wrong datatype for integer based retention policy **Thanks** * @Dead2, @dv8472 and @einsibjarni for reporting an issue with multinode queries and views * @aelg for reporting an issue with policies on integer-based hypertables * @hperez75 for reporting an issue with Skip Scan * @nathanloisel for reporting an issue with compression on hypertables with integer-based timestamps * @xin-hedera for fixing an issue with compression on hypertables with integer-based timestamps ## 2.2.0 (2021-04-13) This release adds major new features since the 2.1.1 release. We deem it moderate priority for upgrading. This release adds the Skip Scan optimization, which significantly improves the performance of queries with DISTINCT ON. This optimization is not yet available for queries on distributed hypertables. This release also adds a function to create a distributed restore point, which allows performing a consistent restore of a multi-node cluster from a backup. The bug fixes in this release address issues with size and stats functions, high memory usage in distributed inserts, slow distributed ORDER BY queries, indexes involving INCLUDE, and single chunk query planning. **PostgreSQL 11 deprecation announcement** Timescale is working hard on our next exciting features. To make that possible, we require functionality that is unfortunately absent on PostgreSQL 11. For this reason, we will continue supporting PostgreSQL 11 until mid-June 2021. Sooner to that time, we will announce the specific version of TimescaleDB in which PostgreSQL 11 support will not be included going forward. **Major Features** * #2843 Add distributed restore point functionality * #3000 SkipScan to speed up SELECT DISTINCT **Bugfixes** * #2989 Refactor and harden size and stats functions * #3058 Reduce memory usage for distributed inserts * #3067 Fix extremely slow multi-node order by queries * #3082 Fix chunk index column name mapping * #3083 Keep Append pathkeys in ChunkAppend **Thanks** * @BowenGG for reporting an issue with indexes with INCLUDE * @fvannee for reporting an issue with ChunkAppend pathkeys * @pedrokost and @RobAtticus for reporting an issue with size functions on empty hypertables * @phemmer and @ryanbooz for reporting issues with slow multi-node order by queries * @stephane-moreau for reporting an issue with high memory usage during single-transaction inserts on a distributed hypertable. ## 2.1.1 (2021-03-29) This maintenance release contains bugfixes since the 2.1.0 release. We deem it high priority for upgrading. The bug fixes in this release address issues with CREATE INDEX and UPSERT for hypertables, custom jobs, and gapfill queries. This release marks TimescaleDB as a trusted extension in PG13, so that superuser privileges are not required anymore to install the extension. **Minor features** * #2998 Mark timescaledb as trusted extension **Bugfixes** * #2948 Fix off by 4 error in histogram deserialize * #2974 Fix index creation for hypertables with dropped columns * #2990 Fix segfault in job_config_check for cagg * #2987 Fix crash due to txns in emit_log_hook_callback * #3042 Commit end transaction for CREATE INDEX * #3053 Fix gapfill/hashagg planner interaction * #3059 Fix UPSERT on hypertables with columns with defaults **Thanks** * @eloyekunle and @kitwestneat for reporting an issue with UPSERT * @jocrau for reporting an issue with index creation * @kev009 for fixing a compilation issue * @majozv and @pehlert for reporting an issue with time_bucket_gapfill ## 2.1.0 (2021-02-22) This release adds major new features since the 2.0.2 release. We deem it moderate priority for upgrading. This release adds the long-awaited support for PostgreSQL 13 to TimescaleDB. The minimum required PostgreSQL 13 version is 13.2 due to a security vulnerability affecting TimescaleDB functionality present in earlier versions of PostgreSQL 13. This release also relaxes some restrictions for compressed hypertables; namely, TimescaleDB now supports adding columns to compressed hypertables and renaming columns of compressed hypertables. **Major Features** * #2779 Add support for PostgreSQL 13 **Minor features** * #2736 Support adding columns to hypertables with compression enabled * #2909 Support renaming columns of hypertables with compression enabled ## 2.0.2 (2021-02-19) This maintenance release contains bugfixes since the 2.0.1 release. We deem it high priority for upgrading. The bug fixes in this release address issues with joins, the status of background jobs, and disabling compression. It also includes enhancements to continuous aggregates, including improved validation of policies and optimizations for faster refreshes when there are a lot of invalidations. **Minor features** * #2926 Optimize cagg refresh for small invalidations **Bugfixes** * #2850 Set status for backend in background jobs * #2883 Fix join qual propagation for nested joins * #2884 Add GUC to control join qual propagation * #2885 Fix compressed chunk check when disabling compression * #2908 Fix changing column type of clustered hypertables * #2942 Validate continuous aggregate policy **Thanks** * @zeeshanshabbir93 for reporting an issue with joins * @Antiarchitect for reporting the issue with slow refreshes of continuous aggregates. * @diego-hermida for reporting the issue about being unable to disable compression * @mtin for reporting the issue about wrong job status ## 1.7.5 (2021-02-12) This maintenance release contains bugfixes since the 1.7.4 release. Most of these fixes were backported from the 2.0.0 and 2.0.1 releases. We deem it high priority for upgrading for users on TimescaleDB 1.7.4 or previous versions. In particular the fixes contained in this maintenance release address issues in continuous aggregates, compression, JOINs with hypertables, and when upgrading from previous versions. **Bugfixes** * #2502 Replace check function when updating * #2558 Repair dimension slice table on update * #2619 Fix segfault in decompress_chunk for chunks with dropped columns * #2664 Fix support for complex aggregate expression * #2800 Lock dimension slices when creating new chunk * #2860 Fix projection in ChunkAppend nodes * #2865 Apply volatile function quals at decompresschunk * #2851 Fix nested loop joins that involve compressed chunks * #2868 Fix corruption in gapfill plan * #2883 Fix join qual propagation for nested joins * #2885 Fix compressed chunk check when disabling compression * #2920 Fix repair in update scripts **Thanks** * @akamensky for reporting several issues including segfaults after version update * @alex88 for reporting an issue with joined hypertables * @dhodyn for reporting an issue when joining compressed chunks * @diego-hermida for reporting an issue with disabling compression * @Netskeh for reporting bug on time_bucket problem in continuous aggregates * @WarriorOfWire for reporting the bug with gapfill queries not being able to find pathkey item to sort * @zeeshanshabbir93 for reporting an issue with joins ## 2.0.1 (2021-01-28) This maintenance release contains bugfixes since the 2.0.0 release. We deem it high priority for upgrading. In particular the fixes contained in this maintenance release address issues in continuous aggregates, compression, JOINs with hypertables and when upgrading from previous versions. **Bugfixes** * #2772 Always validate existing database and extension * #2780 Fix config enum entries for remote data fetcher * #2806 Add check for dropped chunk on update * #2828 Improve cagg watermark caching * #2838 Fix catalog repair in update script * #2842 Do not mark job as started when setting next_start field * #2845 Fix continuous aggregate privileges during upgrade * #2851 Fix nested loop joins that involve compressed chunks * #2860 Fix projection in ChunkAppend nodes * #2861 Remove compression stat update from update script * #2865 Apply volatile function quals at decompresschunk node * #2866 Avoid partitionwise planning of partialize_agg * #2868 Fix corruption in gapfill plan * #2874 Fix partitionwise agg crash due to uninitialized memory **Thanks** * @alex88 for reporting an issue with joined hypertables * @brian-from-quantrocket for reporting an issue with extension update and dropped chunks * @dhodyn for reporting an issue when joining compressed chunks * @markatosi for reporting a segfault with partitionwise aggregates enabled * @PhilippJust for reporting an issue with add_job and initial_start * @sgorsh for reporting an issue when using pgAdmin on windows * @WarriorOfWire for reporting the bug with gapfill queries not being able to find pathkey item to sort ## 2.0.0 (2020-12-18) With this release, we are officially moving TimescaleDB 2.0 to GA, concluding several release candidates. TimescaleDB 2.0 adds the much-anticipated support for distributed hypertables (multi-node TimescaleDB), as well as new features and enhancements to core functionality to give users better clarity and more control and flexibility over their data. Multi-node architecture: In particular, with TimescaleDB 2.0, users can now create distributed hypertables across multiple instances of TimescaleDB, configured so that one instance serves as an access node and multiple others as data nodes. All queries for a distributed hypertable are issued to the access node, but inserted data and queries are pushed down across data nodes for greater scale and performance. Multi-node TimescaleDB can be self managed or, for easier operation, launched within Timescale's fully-managed cloud services. This release also adds: * Support for user-defined actions, allowing users to define, customize, and schedule automated tasks, which can be run by the built-in jobs scheduling framework now exposed to users. * Significant changes to continuous aggregates, which now separate the view creation from the policy. Users can now refresh individual regions of the continuous aggregate materialized view, or schedule automated refreshing via policy. * Redesigned informational views, including new (and more general) views for information about hypertable's dimensions and chunks, policies and user-defined actions, as well as support for multi-node TimescaleDB. * Moving all formerly enterprise features into our Community Edition, and updating Timescale License, which now provides additional (more permissive) rights to users and developers. Some of the changes above (e.g., continuous aggregates, updated informational views) do introduce breaking changes to APIs and are not backwards compatible. While the update scripts in TimescaleDB 2.0 will upgrade databases running TimescaleDB 1.x automatically, some of these API and feature changes may require changes to clients and/or upstream scripts that rely on the previous APIs. Before upgrading, we recommend reviewing upgrade documentation at docs.timescale.com for more details. **Major Features** TimescaleDB 2.0 moves the following major features to GA: * #1923 Add support for distributed hypertables * #2006 Add support for user-defined actions * #2125 #2221 Improve Continuous Aggregate API * #2084 #2089 #2098 #2417 Redesign informational views * #2435 Move enterprise features to community * #2437 Update Timescale License **Previous Release Candidates** * #2702 Release Candidate 4 (December 2, 2020) * #2637 Release Candidate 3 (November 12, 2020) * #2554 Release Candidate 2 (October 20, 2020) * #2478 Release Candidate 1 (October 1, 2020) **Minor Features** Since the last release candidate 4, there are several minor improvements: * #2746 Optimize locking for create chunk API * #2705 Block tableoid access on distributed hypertable * #2730 Do not allow unique index on compressed hypertables * #2764 Bootstrap data nodes with versioned extension **Bugfixes** Since the last release candidate 4, there are several bugfixes: * #2719 Support disabling compression on distributed hypertables * #2742 Fix compression status in chunks view for distributed chunks * #2751 Fix crash and cancel when adding data node * #2763 Fix check constraint on hypertable metadata table **Thanks** Thanks to all contributors for the TimescaleDB 2.0 release: * @airton-neto for reporting a bug in executing some queries with UNION * @nshah14285 for reporting an issue with propagating privileges * @kalman5 for reporting an issue with renaming constraints * @LbaNeXte for reporting a bug in decompression for queries with subqueries * @semtexzv for reporting an issue with continuous aggregates on int-based hypertables * @mr-ns for reporting an issue with privileges for creating chunks * @cloud-rocket for reporting an issue with setting an owner on continuous aggregate * @jocrau for reporting a bug during creating an index with transaction per chunk * @fvannee for reporting an issue with custom time types * @ArtificialPB for reporting a bug in executing queries with conditional ordering on compressed hypertable * @dutchgecko for reporting an issue with continuous aggregate datatype handling * @lambdaq for suggesting to improve error message in continuous aggregate creation * @francesco11112 for reporting memory issue on COPY * @Netskeh for reporting bug on time_bucket problem in continuous aggregates * @mr-ns for reporting the issue with CTEs on distributed hypertables * @akamensky for reporting an issue with recursive cache invalidation * @ryanbooz for reporting slow queries with real-time aggregation on continuous aggregates * @cevian for reporting an issue with disabling compression on distributed hypertables ## 2.0.0-rc4 (2020-12-02) This release candidate contains bugfixes since the previous release candidate, as well as additional minor features. It improves validation of configuration changes for background jobs, adds support for gapfill on distributed tables, contains improvements to the memory handling for large COPY, and contains improvements to compression for distributed hypertables. **Minor Features** * #2689 Check configuration in alter_job and add_job * #2696 Support gapfill on distributed hypertable * #2468 Show more information in get_git_commit * #2678 Include user actions into job stats view * #2664 Fix support for complex aggregate expression * #2672 Add hypertable to continuous aggregates view * #2662 Save compression metadata settings on access node * #2707 Introduce additional db for data node bootstrapping **Bugfixes** * #2688 Fix crash for concurrent drop and compress chunk * #2666 Fix timeout handling in async library * #2683 Fix crash in add_job when given NULL interval * #2698 Improve memory handling for remote COPY * #2555 Set metadata for chunks compressed before 2.0 **Thanks** * @francesco11112 for reporting memory issue on COPY * @Netskeh for reporting bug on time_bucket problem in continuous aggregates ## 2.0.0-rc3 (2020-11-12) This release candidate contains bugfixes since the previous release candidate, as well as additional minor features including support for "user-mapping" authentication between access/data nodes and an experimental API for refreshing continuous aggregates on individual chunks. **Minor Features** * #2627 Add optional user mappings support * #2635 Add API to refresh continuous aggregate on chunk **Bugfixes** * #2560 Fix SCHEMA DROP CASCADE with continuous aggregates * #2593 Set explicitly all lock parameters in alter_job * #2604 Fix chunk creation on hypertables with foreign key constraints * #2610 Support analyze of internal compression table * #2612 Optimize internal cagg_watermark function * #2613 Refresh correct partial during refresh on drop * #2617 Fix validation of available extensions on data node * #2619 Fix segfault in decompress_chunk for chunks with dropped columns * #2620 Fix DROP CASCADE for continuous aggregate * #2625 Fix subquery errors when using AsyncAppend * #2626 Fix incorrect total_table_pages setting for compressed scan * #2628 Stop recursion in cache invalidation **Thanks** * @mr-ns for reporting the issue with CTEs on distributed hypertables * @akamensky for reporting an issue with recursive cache invalidation * @ryanbooz for reporting slow queries with real-time aggregation on continuous aggregates ## 2.0.0-rc2 (2020-10-21) This release candidate contains bugfixes since the previous release candidate. **Minor Features** * #2520 Support non-transactional distibuted_exec **Bugfixes** * #2307 Overflow handling for refresh policy with integer time * #2503 Remove error for correct bootstrap of data node * #2507 Fix validation logic when adding a new data node * #2510 Fix outer join qual propagation * #2514 Lock dimension slices when creating new chunk * #2515 Add if_attached argument to detach_data_node() * #2517 Fix member access within misaligned address in chunk_update_colstats * #2525 Fix index creation on hypertables with dropped columns * #2543 Pass correct status to lock_job * #2544 Assume custom time type range is same as bigint * #2563 Fix DecompressChunk path generation * #2564 Improve continuous aggregate datatype handling * #2568 Change use of ssl_dir GUC * #2571 Make errors and messages conform to style guide * #2577 Exclude compressed chunks from ANALYZE/VACUUM ## 2.0.0-rc1 (2020-10-06) This release adds major new features and bugfixes since the 1.7.4 release. We deem it moderate priority for upgrading. This release adds the long-awaited support for distributed hypertables to TimescaleDB. With 2.0, users can create distributed hypertables across multiple instances of TimescaleDB, configured so that one instance serves as an access node and multiple others as data nodes. All queries for a distributed hypertable are issued to the access node, but inserted data and queries are pushed down across data nodes for greater scale and performance. This release also adds support for user-defined actions allowing users to define actions that are run by the TimescaleDB automation framework. In addition to these major new features, the 2.0 branch introduces _breaking_ changes to APIs and existing features, such as continuous aggregates. These changes are not backwards compatible and might require changes to clients and/or scripts that rely on the previous APIs. Please review our updated documentation and do proper testing to ensure compatibility with your existing applications. The noticeable breaking changes in APIs are: - Redefined functions for policies - A continuous aggregate is now created with `CREATE MATERIALIZED VIEW` instead of `CREATE VIEW` and automated refreshing requires adding a policy via `add_continuous_aggregate_policy` - Redesign of informational views, including new (and more general) views for information about policies and user-defined actions This release candidate is upgradable, so if you are on a previous release (e.g., 1.7.4) you can upgrade to the release candidate and later expect to be able to upgrade to the final 2.0 release. However, please carefully consider your compatibility requirements _before_ upgrading. **Major Features** * #1923 Add support for distributed hypertables * #2006 Add support for user-defined actions * #2435 Move enterprise features to community * #2437 Update Timescale License **Minor Features** * #2011 Constify TIMESTAMPTZ OP INTERVAL in constraints * #2105 Support moving compressed chunks **Bugfixes** * #1843 Improve handling of "dropped" chunks * #1886 Change ChunkAppend leader to use worker subplan * #2116 Propagate privileges from hypertables to chunks * #2263 Fix timestamp overflow in time_bucket optimization * #2270 Fix handling of non-reference counted TupleDescs in gapfill * #2325 Fix rename constraint/rename index * #2370 Fix detection of hypertables in subqueries * #2376 Fix caggs width expression handling on int based hypertables * #2416 Check insert privileges to create chunk * #2428 Allow owner change of continuous aggregate * #2436 Propagate grants in continuous aggregates ## 2.0.0-beta6 (2020-09-14) **For beta releases**, upgrading from an earlier version of the extension (including previous beta releases) is not supported. This beta release includes breaking changes to APIs. The most notable changes since the beta-5 release are the following, which will be reflected in forthcoming documentation for the 2.0 release. * Existing information views were reorganized. Retrieving information about sizes and statistics was moved to functions. New views were added to expose information, which was previously available only internally. * New ability to create custom jobs was added. * Continuous aggregate API was redesigned. Its policy creation is separated from the view creation. * compress_chunk_policy and drop_chunk_policy were renamed to compression_policy and retention_policy. ## 1.7.4 (2020-09-07) This maintenance release contains bugfixes since the 1.7.3 release. We deem it high priority for upgrading if TimescaleDB is deployed with replicas (synchronous or asynchronous). In particular the fixes contained in this maintenance release address an issue with running queries on compressed hypertables on standby nodes. **Bugfixes** * #2340 Remove tuple lock on select path ## 1.7.3 (2020-07-27) This maintenance release contains bugfixes since the 1.7.2 release. We deem it high priority for upgrading. In particular the fixes contained in this maintenance release address issues in compression, drop_chunks and the background worker scheduler. **Bugfixes** * #2059 Improve infering start and stop arguments from gapfill query * #2067 Support moving compressed chunks * #2068 Apply SET TABLESPACE for compressed chunks * #2090 Fix index creation with IF NOT EXISTS for existing indexes * #2092 Fix delete on tables involving hypertables with compression * #2164 Fix telemetry installed_time format * #2184 Fix background worker scheduler memory consumption * #2222 Fix `negative bitmapset member not allowed` in decompression * #2255 Propagate privileges from hypertables to chunks * #2256 Fix segfault in chunk_append with space partitioning * #2259 Fix recursion in cache processing * #2261 Lock dimension slice tuple when scanning **Thanks** * @akamensky for reporting an issue with drop_chunks and ChunkAppend with space partitioning * @dewetburger430 for reporting an issue with setting tablespace for compressed chunks * @fvannee for reporting an issue with cache invalidation * @nexces for reporting an issue with ChunkAppend on space-partitioned hypertables * @PichetGoulu for reporting an issue with index creation and IF NOT EXISTS * @prathamesh-sonpatki for contributing a typo fix * @sezaru for reporting an issue with background worker scheduler memory consumption ## 1.7.2 (2020-07-07) This maintenance release contains bugfixes since the 1.7.1 release. We deem it medium priority for upgrading. In particular the fixes contained in this maintenance release address bugs in continuous aggregates, drop_chunks and compression. **Features** * #1877 Add support for fast pruning of inlined functions **Bugfixes** * #1908 Fix drop_chunks with unique constraints when cascade_to_materializations is false * #1915 Check for database in extension_current_state * #1918 Unify chunk index creation * #1932 Change compression locking order * #1938 Fix gapfill locf treat_null_as_missing * #1982 Check for disabled telemetry earlier * #1984 Fix compression bit array left shift count * #1997 Add checks for read-only transactions * #2002 Reset restoring gucs rather than explicitly setting 'off' * #2028 Fix locking in drop_chunks * #2031 Enable compression for tables with compound foreign key * #2039 Fix segfault in create_trigger_handler * #2043 Fix segfault in cagg_update_view_definition * #2046 Use index tablespace during chunk creation * #2047 Better handling of chunk insert state destruction * #2049 Fix handling of PlaceHolderVar in DecompressChunk * #2051 Fix tuple concurrently deleted error with multiple continuous aggregates **Thanks** * @akamensky for reporting an issue with telemetry and an issue with drop_chunks * @darko408 for reporting an issue with decompression * @dmitri191 for reporting an issue with failing background workers * @eduardotsj for reporting an issue with indexes not inheriting tablespace settings * @fourseventy for reporting an issue with multiple continuous aggregrates * @fvannee for contributing optimizations for pruning inlined functions * @jflambert for reporting an issue with failing telemetry jobs * @nbouscal for reporting an issue with compression jobs locking referenced tables * @nicolai6120 for reporting an issue with locf and treat_null_as_missing * @nomanor for reporting an issue with expression index with table references * @olernov for contributing a fix for compressing tables with compound foreign keys * @werjo for reporting an issue with drop_chunks and unique constraints ## 2.0.0-beta5 (2020-06-08) This release adds new functionality on distributed hypertables, including (but not limited to) basic LIMIT pushdown, manual chunk compression, table access methods storage options, SERIAL columns, and altering of the replication factor. This release only supports PG11 and PG12. Thus, PG9.6 and PG10 are no longer supported. Note that the 2.0 major release will introduce breaking changes to user functions and APIs. In particular, this beta removes the cascade parameter from drop_chunks and changes the names of certain GUC parameters. Expect additional breaking changes to be introduced up until the 2.0 release. **For beta releases**, upgrading from an earlier version of the extension (including previous beta releases) is not supported. **Features** * #1877 Add support for fast pruning of inlined functions * #1922 Cleanup GUC names * #1923 Add repartition option on detach/delete_data_node * #1923 Allow ALTER TABLE SET on distributed hypertable * #1923 Allow SERIAL columns for distributed hypertables * #1923 Basic LIMIT push down support * #1923 Implement altering replication factor * #1923 Support compression on distributed hypertables * #1923 Support storage options for distributed hypertables * #1941 Change default prefix for distributed tables * #1943 Support table access methods for distributed hypertables * #1952 Remove cascade option from drop_chunks * #1955 Remove support for PG9.6 and PG10 **Bugfixes** * #1915 Check for database in extension_current_state * #1918 Unify chunk index creation * #1923 Fix insert batch size calculation for prepared statements * #1923 Fix port conversion issue in add_data_node * #1932 Change compression locking order * #1938 Fix gapfill locf treat_null_as_missing **Thanks** * @dmitri191 for reporting an issue with failing background workers * @fvannee for optimizing pruning of inlined functions * @nbouscal for reporting an issue with compression jobs locking referenced tables * @nicolai6120 for reporting an issue with locf and treat_null_as_missing * @nomanor for reporting an issue with expression index with table references ## 1.7.1 (2020-05-18) This maintenance release contains bugfixes since the 1.7.0 release. We deem it medium priority for upgrading and high priority for users with multiple continuous aggregates. In particular the fixes contained in this maintenance release address bugs in continuous aggregates with real-time aggregation and PostgreSQL 12 support. **Bugfixes** * #1834 Define strerror() for Windows * #1846 Fix segfault on COPY to hypertable * #1850 Fix scheduler failure due to bad next_start_time for jobs * #1851 Fix hypertable expansion for UNION ALL * #1854 Fix reorder policy job to skip compressed chunks * #1861 Fix qual pushdown for compressed hypertables where quals have casts * #1864 Fix issue with subplan selection in parallel ChunkAppend * #1868 Add support for WHERE, HAVING clauses with real time aggregates * #1869 Fix real time aggregate support for multiple continuous aggregates * #1871 Don't rely on timescaledb.restoring for upgrade * #1875 Fix hypertable detection in subqueries * #1884 Fix crash on SELECT WHERE NOT with empty table **Thanks** * @airton-neto for reporting an issue with queries over UNIONs of hypertables * @dhodyn for reporting an issue with UNION ALL queries * @frostwind for reporting an issue with casts in where clauses on compressed hypertables * @fvannee for reporting an issue with hypertable detection in inlined SQL functions and an issue with COPY * @hgiasac for reporting missing where clause with real time aggregates * @louisth for reporting an issue with real-time aggregation and multiple continuous aggregates * @michael-sayapin for reporting an issue with INSERTs and WHERE NOT EXISTS * @olernov for reporting and fixing an issue with compressed chunks in the reorder policy * @pehlert for reporting an issue with pg_upgrade ## 1.7.0 (2020-04-16) This release adds major new features and bugfixes since the 1.6.1 release. We deem it moderate priority for upgrading. This release adds the long-awaited support for PostgreSQL 12 to TimescaleDB. This release also adds a new default behavior when querying continuous aggregates that we call real-time aggregation. A query on a continuous aggregate will now combine materialized data with recent data that has yet to be materialized. Note that only newly created continuous aggregates will have this real-time query behavior, although it can be enabled on existing continuous aggregates with a configuration setting as follows: ALTER VIEW continuous_view_name SET (timescaledb.materialized_only=false); This release also moves several data management lifecycle features to the Community version of TimescaleDB (from Enterprise), including data reordering and data retention policies. **Major Features** * #1456 Add support for PostgreSQL 12 * #1685 Add support for real-time aggregation on continuous aggregates **Bugfixes** * #1665 Add ignore_invalidation_older_than to timescaledb_information.continuous_aggregates view * #1750 Handle undefined ignore_invalidation_older_than * #1757 Restrict watermark to max for continuous aggregates * #1769 Add rescan function to CompressChunkDml CustomScan node * #1785 Fix last_run_success value in continuous_aggregate_stats view * #1801 Include parallel leader in plan execution * #1808 Fix ts_hypertable_get_all for compressed tables * #1828 Ignore dropped chunks in compressed_chunk_stats **Licensing changes** * Reorder and policies around reorder and drop chunks are now accessible to community users, not just enterprise * Gapfill functionality no longer warns about expired license **Thanks** * @t0k4rt for reporting an issue with parallel chunk append plans * @alxndrdude for reporting an issue when trying to insert into compressed chunks * @Olernov for reporting and fixing an issue with show_chunks and drop_chunks for compressed hypertables * @mjb512 for reporting an issue with INSERTs in CTEs in cached plans * @dmarsh19 for reporting and fixing an issue with dropped chunks in compressed_chunk_stats ## 1.6.1 (2020-03-18) This maintenance release contains bugfixes since the 1.6.0 release. We deem it medium priority for upgrading. In particular the fixes contained in this maintenance release address bugs in continuous aggregates, time_bucket_gapfill, partial index handling and drop_chunks. **For this release only**, you will need to restart the database after upgrade before restoring a backup. **Minor Features** * #1666 Support drop_chunks API for continuous aggregates * #1711 Change log level for continuous aggregate materialization messages **Bugfixes** * #1630 Print notice for COPY TO on hypertable * #1648 Drop chunks from materialized hypertable * #1668 Cannot add dimension if hypertable has empty chunks * #1673 Fix crash when interrupting create_hypertable * #1674 Fix time_bucket_gapfill's interaction with GROUP BY * #1686 Fix order by queries on compressed hypertables that have char segment by column * #1687 Fix issue with disabling compression when foreign keys are present * #1688 Handle many BGW jobs better * #1698 Add logic to ignore dropped chunks in hypertable_relation_size * #1704 Fix bad plan for continuous aggregate materialization * #1709 Prevent starting background workers with NOLOGIN * #1713 Fix miscellaneous background worker issues * #1715 Fix issue with overly aggressive chunk exclusion in outer joins * #1719 Fix restoring/scheduler entrypoint to avoid BGW death * #1720 Add scheduler cache invalidations * #1727 Fix compressing INTERVAL columns * #1728 Handle Sort nodes in ConstraintAwareAppend * #1730 Fix partial index handling on hypertables * #1739 Use release OpenSSL DLLs for debug builds on Windows * #1740 Fix invalidation entries from multiple caggs on same hypertable * #1743 Fix continuous aggregate materialization timezone handling * #1748 Fix remove_drop_chunks_policy for continuous aggregates * #1756 Fix handling of dropped chunks in compression background worker **Thanks** * @RJPhillips01 for reporting an issue with drop chunks. * @b4eEx for reporting an issue with disabling compression. * @darko408 for reporting an issue with order by on compressed hypertables * @mrechte for reporting an issue with compressing INTERVAL columns * @tstaehli for reporting an issue with ConstraintAwareAppend * @chadshowalter for reporting an issue with partial index on hypertables * @geoffreybennett for reporting an issue with create_hypertable when interrupting operations * @alxndrdude for reporting an issue with background workers during restore * @zcavaliero for reporting and fixing an issue with dropped columns in hypertable_relation_size * @ismailakpolat for reporting an issue with cagg materialization on hypertables with TIMESTAMP column ## 1.6.0 (2020-01-14) This release adds major new features and bugfixes since the 1.5.1 release. We deem it moderate priority for upgrading. The major new feature in this release allows users to keep the aggregated data in a continuous aggregate while dropping the raw data with drop_chunks. This allows users to save storage by keeping only the aggregates. The semantics of the refresh_lag parameter for continuous aggregates has been changed to be relative to the current timestamp instead of the maximum value in the table. This change requires that an integer_now func be set on hypertables with integer-based time columns to use continuous aggregates on this table. We added a timescaledb.ignore_invalidation_older_than parameter for continuous aggregates. This parameter accept a time-interval (e.g. 1 month). If set, it limits the amount of time for which to process invalidation. Thus, if timescaledb.ignore_invalidation_older_than = '1 month', then any modifications for data older than 1 month from the current timestamp at modification time may not cause continuous aggregate to be updated. This limits the amount of work that a backfill can trigger. By default, all invalidations are processed. **Major Features** * #1589 Allow drop_chunks while keeping continuous aggregates **Minor Features** * #1568 Add ignore_invalidation_older_than option to continuous aggs * #1575 Reorder group-by clause for continuous aggregates * #1592 Improve continuous agg user messages **Bugfixes** * #1565 Fix partial select query for continuous aggregate * #1591 Fix locf treat_null_as_missing option * #1594 Fix error in compression constraint check * #1603 Add join info to compressed chunk * #1606 Fix constify params during runtime exclusion * #1607 Delete compression policy when drop hypertable * #1608 Add jobs to timescaledb_information.policy_stats * #1609 Fix bug with parent table in decompression * #1624 Fix drop_chunks for ApacheOnly * #1632 Check for NULL before dereferencing variable **Thanks** * @optijon for reporting an issue with locf treat_null_as_missing option * @acarrera42 for reporting an issue with constify params during runtime exclusion * @ChristopherZellermann for reporting an issue with the compression constraint check * @SimonDelamare for reporting an issue with joining hypertables with compression ## 2.0.0-beta4 (2019-12-19) **For beta releases**, upgrading from an earlier version of the extension (including previous beta releases) is not supported. This release includes user experience improvements for managing data nodes, more efficient statistics collection for distributed hypertables, and miscellaneous fixes and improvements. ## 1.5.1 (2019-11-12) This maintenance release contains bugfixes since the 1.5.0 release. We deem it low priority for upgrading. In particular the fixes contained in this maintenance release address potential segfaults and no other security vulnerabilities. The bugfixes are related to bloom indexes and updates from previous versions. **Bugfixes** * #1523 Fix bad SQL updates from previous updates * #1526 Fix hypertable model * #1530 Set active snapshots in multi-xact index create **Thanks** * @84660320 for reporting an issue with bloom indexes * @gumshoes @perhamm @jermudgeon @gmisagm for reporting the issue with updates ## 2.0.0-beta3 (2019-11-05) **For beta releases**, upgrading from an earlier version of the extension (including previous beta releases) is not supported. This release improves performance for queries executed on distributed hypertables, fixes minor issues and blocks a number of SQL API functions, which are not supported on distributed hypertables. It also adds information about distributed databases in the telemetry. ## 2.0.0-beta2 (2019-10-22) This release introduces *distributed hypertables*, a major new feature that allows hypertables to scale out across multiple nodes for increased performance and fault tolerance. Please review the documentation to learn how to configure and use distributed hypertables and what current limitations are. ## 1.5.0 (2019-10-31) This release adds major new features and bugfixes since the 1.4.2 release. We deem it moderate priority for upgrading. This release adds compression as a major new feature. Multiple type-specific compression options are available in this release (including DeltaDelta with run-length-encoding for integers and timestamps; Gorilla compression for floats; dictionary-based compression for any data type, but specifically for low-cardinality datasets; and other LZ-based techniques). Individual columns can be compressed with type-specific compression algorithms as Postgres' native row-based format are rolled up into columnar-like arrays on a per chunk basis. The query planner then handles transparent decompression for compressed chunks at execution time. This release also adds support for basic data tiering by supporting the migration of chunks between tablespaces, as well as support for parallel query coordination to the ChunkAppend node. Previously ChunkAppend would rely on parallel coordination in the underlying scans for parallel plans. More information can be found on [our blog](https://blog.timescale.com/blog/building-columnar-compression-in-a-row-oriented-database) or in this [tutorial](https://docs.timescale.com/latest/tutorials/compression-tutorial) **For this release only**, you will need to restart the database before running `ALTER EXTENSION` **Major Features** * #1393 Moving chunks between different tablespaces * #1433 Make ChunkAppend parallel aware * #1434 Introducing native compression, multiple compression algorithms, and hybrid row/columnar projections **Minor Features** * #1471 Allow setting reloptions on chunks * #1479 Add next_start option to alter_job_schedule * #1481 Add last_successful_finish to bgw_job_stats **Bugfixes** * #1444 Prevent LIMIT pushdown in JOINs * #1447 Fix runtime exclusion memory leak * #1464 Fix ordered append with expressions in ORDER BY clause with space partitioning * #1476 Fix logic for BGW rescheduling * #1477 Fix gapfill treat_null_as_missing * #1493 Prevent recursion in invalidation processing * #1498 Fix overflow in gapfill's interpolate * #1499 Fix error for exported_uuid in pg_restore * #1503 Fix bug with histogram function in parallel **Thanks** * @dhyun-obsec for reporting an issue with pg_restore * @rhaymo for reporting an issue with interpolate * @optijon for reporting an issue with locf treat_null_as_missing * @fvannee for reporting an issue with runtime exclusion * @Lectem for reporting an issue with histograms * @rogerdwan for reporting an issue with BGW rescheduling * @od0 for reporting an issue with alter_job_schedule ## 1.4.2 (2019-09-11) This maintenance release contains bugfixes since the 1.4.1 release. We deem it medium priority for upgrading. In particular the fixes contained in this maintenance release address 2 potential segfaults and no other security vulnerabilities. The bugfixes are related to background workers, OUTER JOINs, ordered append on space partitioned hypertables and expression indexes. **Bugfixes** * #1327 Fix chunk exclusion with ordered append * #1390 Fix deletes of background workers while a job is running * #1392 Fix cagg_agg_validate expression handling (segfault) * #1408 Fix ChunkAppend space partitioning support for ordered append * #1420 Fix OUTER JOIN qual propagation * #1422 Fix background worker error handling (segfault) * #1424 Fix ChunkAppend LIMIT pushdown * #1429 Fix expression index creation **Thanks** * @shahidhk for reporting an issue with OUTER JOINs * @cossbow and @xxGL1TCHxx for reporting reporting issues with ChunkAppend and space partitioning * @est for reporting an issue with CASE expressions in continuous aggregates * @devlucasc for reporting the issue with deleting a background worker while a job is running * @ryan-shaw for reporting an issue with expression indexes on hypertables with dropped columns ## 1.4.1 (2019-08-01) This maintenance release contains bugfixes since the 1.4.0 release. We deem it medium priority for upgrading. In particular the fixes contained in this maintenance release address 2 potential segfaults and no other security vulnerabilities. The bugfixes are related to queries with prepared statements, PL/pgSQL functions and interoperability with other extensions. More details below. **Bugfixes** * #1362 Fix ConstraintAwareAppend subquery exclusion * #1363 Mark drop_chunks as VOLATILE and not PARALLEL SAFE * #1369 Fix ChunkAppend with prepared statements * #1373 Only allow PARAM_EXTERN as time_bucket_gapfill arguments * #1380 Handle Result nodes gracefully in ChunkAppend **Thanks** * @overhacked for reporting an issue with drop_chunks and parallel queries * @fvannee for reporting an issue with ConstraintAwareAppend and subqueries * @rrb3942 for reporting a segfault with ChunkAppend and prepared statements * @mchesser for reporting a segfault with time_bucket_gapfill and subqueries * @lolizeppelin for reporting and helping debug an issue with ChunkAppend and Result nodes ## 1.4.0 (2019-07-18) This release contains major new functionality for continuous aggregates and adds performance improvements for analytical queries. In version 1.3.0 we added support for continuous aggregates which was initially limited to one continuous aggregate per hypertable. With this release, we remove this restriction and allow multiple continuous aggregates per hypertable. This release adds a new custom node ChunkAppend that can perform execution time constraint exclusion and is also used for ordered append. Ordered append no longer requires a LIMIT clause and now supports space partitioning and ordering by time_bucket. **Major features** * #1270 Use ChunkAppend to replace Append nodes * #1257 Support for multiple continuous aggregates **Minor features** * #1181 Remove LIMIT clause restriction from ordered append * #1273 Propagate quals to joined hypertables * #1317 Support time bucket functions in Ordered Append * #1331 Add warning message for REFRESH MATERIALIZED VIEW * #1332 Add job statistics columns to timescaledb_information.continuous_aggregate_stats view * #1326 Add architecture and bit size to telemetry **Bugfixes** * #1288 Do not remove Result nodes with one-time filter * #1300 Fix telemetry report return value * #1339 Fix continuous agg catalog table insert failure * #1344 Update continuous agg bgw job start time **Thanks** * @ik9999 for reporting a bug with continuous aggregates and negative refresh lag ## 1.3.2 (2019-06-24) This maintenance release contains bug and security fixes since the 1.3.1 release. We deem it moderate-to-high priority for upgrading. This release fixes some security vulnerabilities, specifically related to being able to elevate role-based permissions by database users that already have access to the database. We strongly recommend that users who rely on role-based permissions upgrade to this release as soon as possible. **Security Fixes** * #1311 Fix role-based permission checking logic **Bugfixes** * #1315 Fix potentially lost invalidations in continuous aggs * #1303 Fix handling of types with custom time partitioning * #1299 Arm32: Fix Datum to int cast issue * #1297 Arm32: Fix crashes due to long handling * #1019 Add ARM32 tests on travis **Thanks** * @hedayat for reporting the error with handling of types with custom time partitioning ## 1.3.1 (2019-06-10) This maintenance release contains bugfixes since the 1.3.0 release. We deem it low-to-moderate priority for upgrading. In particular, the fixes contained in this maintenance release do not address any security vulnerabilities, while the only one affecting system stability is related to TimescaleDB running on PostgreSQL 11. More details below. **Bugfixes** * #1220 Fix detecting JOINs for continuous aggs * #1221 Fix segfault in VACUUM on PG11 * #1228 ARM32 Fix: Pass int64 using Int64GetDatum when a Datum is required * #1232 Allow Param as time_bucket_gapfill arguments * #1236 Stop preventing REFRESH in transaction blocks * #1283 Fix constraint exclusion for OUTER JOIN **Thanks** * @od0 for reporting an error with continuous aggs and JOINs * @rickbatka for reporting an error when using time_bucket_gapfill in functions * @OneMoreSec for reporting the bug with VACUUM * @dvdrozdov @od0 @t0k4rt for reporting the issue with REFRESH in transaction blocks * @mhagander and @devrimgunduz for suggesting adding a CMAKE flag to control the default telemetry level ## 1.3.0 (2019-05-06) This release contains major new functionality that we call continuous aggregates. Aggregate queries which touch large swathes of time-series data can take a long time to compute because the system needs to scan large amounts of data on every query execution. Our continuous aggregates continuously calculate the results of a query in the background and materialize the results. Queries to the continuous aggregate view are then significantly faster as they do not need to touch the raw data in the hypertable, instead using the pre-computed aggregates in the view. Continuous aggregates are somewhat similar to PostgreSQL materialized views, but unlike a materialized view, continuous aggregates do not need to be refreshed manually; the view will be refreshed automatically in the background as new data is added, or old data is modified. Additionally, it does not need to re-calculate all of the data on every refresh. Only new and/or invalidated data will be calculated. Since this re-aggregation is automatic, it doesn’t add any maintenance burden to your database. Our continuous aggregate approach supports high-ingest rates by avoiding the high-write amplification associated with trigger-based approaches. Instead, we use invalidation techniques to track what data has changed, and then correct the materialized aggregate the next time that the automated process executes. More information can be found on [our docs overview](http://docs.timescale.com/using-timescaledb/continuous-aggregates) or in this [tutorial](http://docs.timescale.com/tutorials/continuous-aggs-tutorial). **Major Features** * #1184 Add continuous aggregate functionality **Minor Features** * #1005 Enable creating indexes with one transaction per chunk * #1007 Remove hypertable parent from query plans * #1038 Infer time_bucket_gapfill arguments from WHERE clause * #1062 Make constraint aware append parallel safe * #1067 Add treat_null_as_missing option to locf * #1112 Add support for window functions to gapfill * #1130 Add support for cross datatype chunk exclusion for time types * #1134 Add support for partitionwise aggregation * #1153 Add time_bucket support to chunk exclusion * #1170 Add functions for turning restoring on/off and setting license key * #1177 Add transformed time_bucket comparison to quals * #1182 Enable optimizing SELECTs within INSERTs * #1201 Add telemetry for policies: drop_chunk & reorder **Bugfixes** * #1010 Add session locks to CLUSTER * #1115 Fix ordered append optimization for join queries * #1123 Fix gapfill with prepared statements * #1125 Fix column handling for columns derived from GROUP BY columns * #1132 Adjust ordered append path cost * #1155 Limit initial max_open_chunks_per_insert to PG_INT16_MAX * #1167 Fix postgres.conf ApacheOnly license * #1183 Handle NULL in a check constraint name * #1195 Fix cascade in scheduled drop chunks * #1196 Fix UPSERT with prepared statements **Thanks** * @spickman for reporting a segfault with ordered append and JOINs * @comicfans for reporting a performance regression with ordered append * @Specter-Y for reporting a segfault with UPSERT and prepared statements * @erthalion submitting a bugfix for a segfault with validating check constraints ## 1.2.2 (2019-03-14) This release contains bugfixes. **Bugfixes** * #1097 Adjust ordered append plan cost * #1079 Stop background worker on ALTER DATABASE SET TABLESPACE and CREATE DATABASE WITH TEMPLATE * #1088 Fix ON CONFLICT when using prepared statements and functions * #1089 Fix compatibility with extensions that define planner_hook * #1057 Fix chunk exclusion constraint type inference * #1060 Fix sort_transform optimization **Thanks** * @esatterwhite for reporting a bug when using timescaledb with zombodb * @eeeebbbbrrrr for fixing compatibility with extensions that also define planner_hook * @naquad for reporting a segfault when using ON conflict in stored procedures * @aaronkaplan for reporting an issue with ALTER DATABASE SET TABLESPACE * @quetz for reporting an issue with CREATE DATABASE WITH TEMPLATE * @nbouscal for reporting an issue with ordered append resulting in bad plans ## 1.2.1 (2019-02-11) This release contains bugfixes. **Notable commits** * [2f6b58a] Fix tlist on hypertable inserts inside CTEs * [7973b4a] Stop background worker on rename database * [32cc645] Fix loading the tsl license in parallel workers **Thanks** * @jamessewell for reporting and helping debug a segfault in last() [034a0b0] * @piscopoc for reporting a segfault in time_bucket_gapfill [e6c68f8] ## 1.2.0 (2019-01-29) **This is our first release to include Timescale-Licensed features, in addition to new Apache-2 capabilities.** We are excited to be introducing new time-series analytical functions, advanced data lifecycle management capabilities, and improved performance. - **Time-series analytical functions**: Users can now use our `time_bucket_gapfill` function, to write complex gapfilling, last object carried forward, and interpolation queries. - **Advanced data lifecycle management**: We are introducing scheduled policies, which use our background worker framework to manage time-series data. In this release, we support scheduled `drop_chunks` and `reorder`. - **Improved performance**: We added support for ordered appends, which optimize a large range of queries - particularly those that are ordered by time and contain a LIMIT clause. Please note that ordered appends do not support ordering by `time_bucket` at this time. - **Postgres 11 Support**: We added beta support for PG11 in 1.1.0. We're happy to announce that our PG11 support is now out of beta, and fully supported. This release adds code under a new license, LICENSE_TIMESCALE. This code can be found in `tsl`. **For this release only**, you will need to restart the database before running `ALTER EXTENSION` **Notable commits** * [a531733] switch cis state when we switch chunks * [5c6b619] Make a copy of the ri_onConflict object in PG11 * [61e524e] Make slot for upserts be update for every chunk switch * [8a7c127] Fix for ExecSlotDescriptor during upserts * [fa61613] Change time_bucket_gapfill argument names * [01be394] Fix bgw_launcher restart when failing during launcher setup * [7b3929e] Add ordered append optimization * [a69f84c] Fix signal processing in background workers * [47b5b7d] Log which chunks are dropped by background workers * [4e1e15f] Add reorder command * [2e4bb5d] Recluster and drop chunks scheduling code * [ef43e52] Add alter_policy_schedule API function * [5ba740e] Add gapfill query support * [be7c74c] Add logic for automatic DB maintenance functions * [4ff6ac7] Initial Timescale-Licensed-Module and License-Key Implementation * [fc42539] Add new top-level licensing information * [31e9c5b] Fix time column handling in get_create_command * [1b8ceca] Avoid loading twice in parallel workers and load only from $libdir * [76d7875] Don't throw errors when extension is loaded but not installed yet * [eecd845] Add Timescale License (TSL) * [4b42b30] Free ChunkInsertStates when the es_per_tuple_exprcontext is freed **Thanks** * @fordred for reporting our docker-run.sh script was out of date * @JpWebster for reporting a deadlock between reads an drop_chunks * @chickenburgers for reporting an issue with our CMake * Dimtrj and Asbjørn D., on slack, for creating a reproducible testcase for an UPSERT bug * @skebanga for reporting a loader bug ## 1.1.1 (2018-12-20) This release contains bugfixes. **High-level changes** * Fix issue when upgrading with pg_upgrade * Fix a segfault that sometimes appeared in long COPYs * Other bug and stability fixes **Notable commits** * [f99b540] Avoid loading twice in parallel workers and load only from $libdir * [e310f7d] Don't throw errors when extension is loaded but not installed yet * [8498416] Free ChunkInsertStates when the es_per_tuple_exprcontext is freed * [937eefe] Set C standard to C11 **Thanks** * @costigator for reporting the pg_upgrade bug * @FireAndIce68 for reporting the parallel workers issue * @damirda for reporting the copy bug ## 1.1.0 (2018-12-13) Our 1.1 release introduces beta support for PG 11, as well as several performance optimizations aimed at improving chunk exclusion for read queries. We are also packaging our new timescale-tune tool (currently in beta) with our Debian and Linux releases. If you encounter any issues with our beta features, please file a Github issue. **Potential breaking changes** - In addition to optimizing first() / last() to utilize indices for non-group-by queries, we adjusted its sorting behavior to match that of PostgreSQL’s max() and min() functions. Previously, if the column being sorted had NULL values, a NULL would be returned. First() and last() now instead ignore NULL values. **Notable Commits** * [71f3a0c] Fix Datum conversion issues * [5aa1eda] Refactor compatibility functions and code to support PG11 * [e4a4f8e] Add support for functions on open (time) dimensions * [ed5067c] Fix interval_from_now_to_internal timestamptz handling * [019971c] Optimize FIRST/LAST aggregate functions * [83014ee] Implement drop_chunks in C * [9a34028] Implement show_chunks in C and have drop_chunks use it * [d461959] Add view to show hypertable information * [35dee48] Remove version-checking from client-side * [5b6a5f4] Change size utility and job functions to STRICT * [7e55d91] Add checks for NULL arguments to DDL functions * [c1db608] Fix upsert TLE translation when mapping variable numbers * [55a378e] Check extension exists for DROP OWNED and DROP EXTENSION * [0c8c085] Exclude unneeded chunks for IN/ANY/ALL operators * [f27c0a3] Move int time_bucket functions with offset to C **Thanks** * @did-g for some memory improvements ## 1.0.1 (2018-12-05) This commit contains bugfixes and optimizations for 1.0.0 **Notable commits** * [6553aa4] Make a number of size utility functions to `STRICT` * [bb1d748] Add checks for NULL arguments to `set_adaptive_chunking`, `set_number_partitions`, `set_chunk_time_interval`, `add_dimension`, and `create_hypertable` * [a534ed4] Fix upsert TLE translation when mapping variable numbers * [aecd55b] Check extension exists for DROP OWNED and DROP EXTENSION ## 1.0.0 (2018-10-30) **This is our 1.0 release!** For notable commits between 0.12.0/0.12.1 and this final 1.0 release, please see previous entries for the release candidates (rc1, rc2, and rc3). **Thanks** To all the external contributors who helped us debug the release candidates, as well as anyone who has contributed bug reports, PRs, or feedback on Slack, GitHub, and other channels. All input has been valuable and helped us create the product we have today! **Potential breaking changes** * To better align with the ISO standard so that time bucketing starts each week by default on a Monday (rather than Saturday), the `time_bucket` epoch/origin has been changed from January 1, 2000 to January 3, 2000. The function now includes an `origin` parameter that can be used to adjust this. * Error codes are now prefixed with `TS` instead of the prior `IO` prefix. If you were checking for these error codes by name, please update your code. ## 1.0.0-rc3 (2018-10-18) This release is our third 1.0 release candidate. We expect to only merge bug fixes between now and our final 1.0 release. This is a big milestone for us and signifies our maturity and enterprise readiness. **PLEASE NOTE** that release candidate (rc) builds will only be made available via GitHub and Docker, and _not_ on other release channels. Please help us test these release candidates out if you can! **Potential breaking change**: Starting with rc2, we updated our error codes to be prefixed with `TS` instead of the old `IO` prefix. If you were checking for these error codes by name, please update your checks. **Notable commits** * [f7ba13d] Handle and test tablespace changes to and from the default tablespace * [9ccda0d] Start stopped workers on restart message * [3e3bb0c] Add bool created to create_hypertable and add_dimension return value * [53ff656] Add state machine and polling to launcher * [d9b2dfe] Change return value of add_dimension to TABLE * [19299cf] Make all time_bucket function STRICT * [297d885] Add a version of time_bucket that takes an origin * [e74be30] Move time_bucket epoch to a Monday * [46564c1] Handle ALTER SCHEMA RENAME properly * [a83e283] Change return value of create_hypertable to TABLE * [aea7c7e] Add GRANTs to update script for pg_dump to work * [119963a] Replace hardcoded bash path in shell scripts **Thanks** * @jesperpedersen for several PRs that help improve documentation and some rough edges * @did-g for improvements to our build process * @skebanga for reporting an issue with ALTER SCHEMA RENAME * @p-alik for suggesting a way to improve our bash scripts' portability * @mx781 and @HeikoOnnebrink for reporting an issues with permission GRANTs and ownership when using pg_dump ## 1.0.0-rc2 (2018-09-27) This release is our second 1.0 release candidate. We expect to only merge bug fixes between now and our final 1.0 release. This is a big milestone for us and signifies our maturity and enterprise readiness. **PLEASE NOTE** that release candidate (rc) builds will only be made available via GitHub and Docker, and _not_ on other release channels. Please help us test these release candidates out if you can! **Potential breaking change**: We updated our error codes to be prefixed with `TS` instead of the old `IO` prefix. If you were checking for these error codes by name, please update your checks. **Notable commits** * [b43574f] Switch 'IO' error prefix to 'TS' * [9747885] Prefix public C functions with ts_ * [39510c3] Block unknown alter table commands on hypertables * [2408a83] Add support for ALTER TABLE SET TABLESPACE on hypertables * [41d9846] Enclose macro replacement list and arguments in parentheses * [cc59d51] Replace macro LEAST_TIMESTAMP by a static function * [281f363] Modify telemetry BGW to run every hour the first 12 hours * [a09b3ec] Add pg_isolation_regress support to the timescale build system * [2c267ba] Handle SIGTERM/SIGINT asynchronously * [5377e2d] Fix use-after-free bug for connections in the telemetry BGW * [248f662] Fix pg_dump for unprivileged users * [193fa4a] Stop background workers when extension is DROP OWNED * [625e3fa] Fix negative value handling in int time_bucket * [a33224b] Add loader API version function * [18b8068] Remove unnecessary index on dimension metadata table * [d09405d] Fix adaptive chunking when hypertables have multiple dimensions * [a81dc18] Block signals when writing to the log table in tests * [d5a6392] Fix adaptive chunking so it chooses correct index * [3489cca] Fix sigterm handling in background jobs * [2369ae9] Remove !WIN32 for sys/time.h and sys/socket.h, pg provides fills * [ebbb4ae] Also add sys/time.h for NetBSD. Fixes #700 * [1a9ae17] Fix build on FreeBSD wrt sockets * [8225cd2] Remove (redefined) macro PG_VERSION and replace with PACKAGE_VERSION * [2a07cf9] Release SpinLock even when we're about to Error due to over-decrementing * [b2a15b8] Make sure DB schedulers are not decremented if they were never incremented * [6731c86] Add support for pre-release version checks **Thanks** * @did-g for an improvement to our macros to make compiliers happy * @mx781 and @HeikoOnnebrink for reporting issues with working with pg_dump fully * @znbang and @timolson for reporting a bug that was causing telemetry to fail * @alanhamlett for reporting an issue with spinlocks when handling SIGTERMs * @oldgreen for reporting an issue with building on NetBSD * @kev009 for fixing build issues on FreeBSD and NetBSD * All the others who have helped us test and used these RCs! ## 0.12.1 (2018-09-19) **High-level changes** * Fixes for a few issues related to the new scheduler and background worker framework. * Fixed bug in adaptive chunking where the incorrect index could be used for determining the current interval. * Improved testing, code cleanup, and other housekeeping. **Notable commits** * [0f6f7fc] Fix adaptive chunking so it chooses correct index * [3ed79ed] Fix sigterm handling in background jobs * [bea098f] Remove !WIN32 for sys/time.h and sys/socket.h, pg provides fills * [9f62a1a] Also add sys/time.h for NetBSD. Fixes #700 * [95a982f] Fix build on FreeBSD wrt sockets * [fcb4a79] Remove (redefined) macro PG_VERSION and replace with PACKAGE_VERSION * [2634897] Release SpinLock even when we're about to Error due to over-decrementing * [1f30dbb] Make sure DB schedulers are not decremented if they were never incremented * [f518cd0] Add support for pre-release version checks * [acebaea] Don't start schedulers for template databases. * [f221a12] Fix use-after-free bug in telemetry test * [0dc5bbb] Use pg_config bindir directory for pg executables **Thanks** * @did-g for reporting a use-after-free bug in a test and for improving the robustness of another test * @kev009 for fixing build issues on FreeBSD and NetBSD ## 1.0.0-rc1 (2018-09-12) This release is our 1.0 release candidate. We expect to only merge bug fixes between now and our final 1.0 release. This is a big milestone for us and signifies our maturity and enterprise readiness. **PLEASE NOTE** that release candidate (rc) builds will only be made available via GitHub and Docker, and _not_ on other release channels. Please help us test these release candidates out if you can! **Notable commits** * [acebaea] Don't start schedulers for template databases. * [f221a12] Fix use-after-free bug in telemetry test * [2092b2a] Fix unused variable warning in Release build * [0dc5bbb] Use pg_config bindir directory for pg executables **Thanks** * @did-g for reporting a use-after-free bug in a test and for improving the robustness of another test ## 0.12.0 (2018-09-10) **High-level changes** *Scheduler framework:* This release introduces a background job framework and scheduler. Each database running within a PostgreSQL instance has a scheduler that schedules recurring jobs from a new jobs table while maintaining statistics that inform the scheduler's policy. Future releases will leverage this scheduler framework for more automated management of data retention, archiving, analytics, and the like. *Telemetry:* Using this new scheduler framework, TimescaleDB databases now send anonymized usage information to a telemetry server via HTTPS, as well as perform version checking to notify users if a newer version is available. For transparency, a new `get_telemetry_report` function details the exact JSON that is sent, and users may also opt out of this telemetry and version check. *Continued hardening:* This release addresses several issues around more robust backup and recovery, handling large numbers of chunks, and additional test coverage. **Notable commits** * [efab2aa] Fix net lib functionality on Windows and improve error handling * [71589c4] Fix issues when OpenSSL is not available * [a43cd04] Call the main telemetry function inside BGW executor * [faf481b] Add telemetry functionality * [45a2b76] Add new Connection and HTTP libraries * [b6fe657] Fix max_background_workers guc, errors on EXEC_BACKEND and formatting * [5d8c7cc] Add a scheduler for background jobs * [55a7141] Implement a cluster-wide launcher for background workers * [5bc705f] Update bootstrap to check for cmake and exit if not found * [98e56dd] Improve show_indexes test func to be more platform agnostic * [b928caa] Note how to recreate templated files * [8571e41] Use AttrNumberGetAttrOffset instead of Anum_name - 1 for array indexing * [d1710ef] Improve regression test script to cleanup more thoroughly * [fc3677f] Reduce number of open chunks per insert * [027b7b2] Hide extension symbols by default on Unix platforms * [6a3abe5] Fix SubspaceStore to ensure max_open_chunks_per_insert is obeyed **Thanks** @EvanCarroll for updates to the bootstrap script to check for cmake ## 0.11.0 (2018-08-08) **High-level changes** * **Adaptive chunking**: This feature, currently in beta, allows the database to automatically adapt a chunk's time interval, so that users do not need to manually set (and possibly manually change) this interval size. In this release, users can specify either a target chunk data size (in terms of MB or GB), and the chunk's time intervals will be automatically adapted. Alternatively, users can ask the database to just estimate a target size itself based on the platform's available memory and other parameters, and the system will adapt accordingly. This type of automation can simplify initial database test and operations. This feature is default off. Note: The default time interval for non-adaptive chunking has also been changed from 1 month to 1 week. * **Continued hardening**: This release addresses a number of less frequently used schema modifications, functions, or constraints. Unsupported functions are safely blocked, while we have added support for a number of new types of table alterations. This release also adds additional test coverage. * Support for additional types of time columns, if they are binary compatible (thanks @fvannee!). **Notable commits** * [9ba2e81] Fix segfault with custom partition types * [7e9bf25] Change default chunk size to one week * [506fa18] Add tests for custom types * [1d9ade7] add support for other types as timescale column * [570f2f8] Validate parameters when creating partition info * [148f2da] Use shared_buffers as the available cache memory * [e0a15c1] Add additional comments to explain algorithm * [d81dccb] Set the default chunk_time_interval to 1 day with adaptive chunking enabled * [2e7b32c] Add WARNING when doing min-max heap scan for adaptive chunking * [6b452a8] Update adaptive chunk algorithm to handle very small chunks. * [9c9cdca] Add support for adaptive chunk sizing * [7f8d17d] Handle DEFERRED and VALID options for constraints * [0c5c21b] Block using rules with hypertables * [37142e9] Block INSERTs on a hypertable's root table * [4daf087] Fix some ALTER TABLE corner case bugs on hypertables * [122f5f1] Block replica identity usage with hypertables * [8bf552e] Block unlogged tables from being used as hypertables * [a8c637e] Create aggregate functions only once to avoid dependency issues * [a97f2af] Add support for custom hypertable dimension types * [dfe026c] Refactor create_hypertable rel access. * [ed379c3] Validate existing indexes before adding a new dimension * [1f2d276] Fix and improve show_indexes test support function * [77b0035] Enforce IMMUTABLE partitioning functions * [cbc5e60] Block NO INHERIT constraints on hypertables * [e362e9c] Block mixing hypertables with postgres inheritance * [011f12b] Add support for CLUSTER ON and SET WITHOUT CLUSTER * [e947c6b] Improve handling of column settings * [fc4957b] Update statistics on parent table when doing ANALYZE * [82942bf] Enable backwards compatibility for loader for 0.9.0 and 0.9.1 **Thanks** * @Ngalstyan4 and @hjsuh18, our interns, for all of the PRs this summer * @fvannee for a PR adding support for binary compatible custom types as a time column * @fmacelw for reporting a bug where first() and last() hold reference across extension update * @soccerdroid for reporting a corner case bug in ALTER TABLE ## 0.10.1 (2018-07-12) **High-level changes** * Improved memory management for long-lived connections. * Fixed handling of dropping triggers that would lead to orphaned references in pg_depend. * Fixed pruning in CustomScan when the subplan is not a Scan type that caused a crash with LATERALs. * Corrected size reporting that was not accurately counting TOAST size * Updated error messages that more closely conform to PG style. * Corrected handling of table and schema name changes to chunks; TimescaleDB metadata catalogs are now properly updated **Notable commits** * [8b58500] Fix bug where dropping triggers caused dangling references in pg_depend, disallow disabling triggers on hypertables * [745b8ab] Fixing CustomScan pruning whenever the subplan is NOT of a Scan type. * [67a8a41] Make chunk identifiers formatting safe using format * [41af6ff] Fix misreported toast_size in chunk_relation_size funcs * [4f2f1a6] Update the error messages to conform with the style guide; Fix tests * [3c28f65] Release cache pin memory * [abe76fc] Add support for changing chunk schema and name **Thanks** * @mfuterko for updating our error messages to conform with PG error message style * @fvannee for reporting a crash when using certain LATERAL joins with aggregates * @linba708 for reporting a memory leak with long lived connections * @phlsmk for reporting an issue where dropping triggers prevented drop_chunks from working due to orphaned dependencies ## 0.10.0 (2018-06-27) **High-level changes** * Planning time improvement (**up to 15x**) when a hypertable has many chunks by only expanding (and taking locks on) chunks that will actually be used in a query, rather than on all chunks (as was the default PostgreSQL behavior). * Smarter use of HashAggregate by teaching the planner to better estimate the number of output rows when using time-based grouping. * New convenience function for getting the approximate number of rows in a hypertable (`hypertable_approximate_row_count`). * Fixed support for installing extension into non-`public` schemas * Other bug fixes and refactorings. **Notable commits** * [12bc117] Fix static analyzer warning when checking for index attributes * [7d9f49b] Fix missing NULL check when creating default indexes * [2e1f3b9] Improve memory allocation during cache lookups * [ca6e5ef] Fix upserts on altered tables. * [2de6b02] Add optimization to use HashAggregate more often * [4b4211f] Fix some external functions when setting a custom schema * [b7257fc] Optimize planning times when hypertables have many chunks * [c660fcd] Add hypertable_approximate_row_count convenience function * [9ce1576] Fix a compilation issue on pre 9.6.3 versions **Thanks** * @viragkothari for suggesting the addition of `hypertable_approximate_row_count` and @fvannee for providing the initial SQL used to build that function * 'mintekhab' from Slack for reporting a segfault when using upserts on an altered table * @mmouterde for reporting an issue where the extension implicitly expected to be installed in the `public` schema * @mfuterko for bringing some potential bugs to our attention via static analysis ## 0.9.2 (2018-05-04) **High-level changes** * Fixed handling of `DISCARD ALL` command when parallel workers are involved, which sometimes caused the extension to complain it was not preloaded * User permission bug fix where users locating TRIGGER permissions in a database could not insert data into a hypertable * Fixes for some issues with 32-bit architectures **Notable commits** * [256b394] Fix parsing of GrantRoleStmt * [b78953b] Fix datum conversion typo * [c7283ef] Fix bug with extension loader when DISCARD ALL is executed * [fe20e48] Fix chunk creation with user that lacks TRIGGER permission **Thanks** * @gumshoes, @manigandham, @wallies, & @cjrh for reporting a problem where sometimes the extension would appear to not be preloaded when it actually was * @thaxy for reporting a permissions issue when user creating a hypertable lacks TRIGGER permission * @bertmelis for reporting some bugs with 32-bit architectures ## 0.9.1 (2018-03-26) **High-level changes** * **For this release only**, you will need to restart the database before running `ALTER EXTENSION` * Several edge cases regarding CTEs addressed * Updated preloader with better error messaging and fixed edge case * ABI compatibility with latest PostgreSQL to help catch any breaking changes **Notable commits** * [40ce037] Fix crash on explain analyze with insert cte * [8378beb] Enable hypertable inserts within CTEs * [bdfda75] Fix double-loading of extension * [01ea77e] Fix EXPLAIN output for ConstraintAwareAppend inside CTE * [fc05637] Add no preload error to versioned library. * [38f8e0c] Add ABI compatibility tests * [744ca09] Fix Cache Pinning for Subtxns * [39010db] Move more drops into event trigger system * [fc36699] Do not fail add_dimension() on non-empty table with 'if_not_exists' **Thanks** * @The-Alchemist for pointing out broken links in the README * @chaintng for pointing out a broken link in the docs * @jgranstrom for reporting a edge case crash with UPSERTs in CTEs * @saosebastiao for reporting the lack of an error message when the library is not preloaded and trying to delete/modify a hypertable * @jbylund for reporting a cache invalidation issue with the preloader ## 0.9.0 (2018-03-05) **High-level changes** * Support for multiple extension versions on different databases in the same PostgreSQL instance. This allows different databases to be updated independently and provides for smoother updates between versions. No more spurious errors in the log as the extension is being updated, and new versions no longer require a restart of the database. * Streamlined update process for smaller binary/package sizes * Significant refactoring to simplify and improve codebase, including improvements to error handling, security/permissions, and more * Corrections to edge-case scenarios involving dropping schemas, hypertables, dimensions, and more * Correctness improvements through propagating reloptions from main table to chunk tables and blocking `ONLY` commands that try to alter hypertables (i.e., changes should be applied to chunks as well) * Addition of a `migrate_data` option to `create_hypertable` to allow non-empty tables to be turned into hypertables without separate creation & insertion steps. Note, this option may take a while if the original table has lots of data * Support for `ALTER TABLE RENAME CONSTRAINT` * Support for adjusting the number of partitions for a space dimension * Improvements to tablespace handling **Notable commits** * [4672719] Fix error in handling of RESET ALL * [9399308] Refactor/simplify update scripts and build process * [0e79df4] Fix handling of custom SQL-based partitioning functions * [f13969e] Fix possible memory safety issue and squash valgrind error. * [ef74491] Migrate table data when creating a hypertable * [2696582] Move index and constraints drop handling to event trigger * [d6baccb] Improve tablespace handling, including blocks for DROP and REVOKE * [b9a6f89] Handle DROP SCHEMA for hypertable and chunk schemas * [b534a5a] Add test case for adding metadata entries automatically * [6adce4c] Handle TRUNCATE without upcall and handle ONLY modifier * [71b1124] Delete orphaned dimension slices * [fa19a54] Handle deletes on metadata objects via native catalog API * [6e011d1] Refactor hypertable-related API functions * [5afd39a] Fix locking for serializing chunk creation * [6dd2c46] Add check for null in ca_append_rescan to prevent segfault * [71962b8] Refactor dimension-related API functions * [cc254a9] Fix CREATE EXTENSION IF NOT EXISTS and error messages * [d135256] Spread chunk indexes across tablespaces like chunks * [e85721a] Block ONLY hypertable on all ALTER TABLE commands. * [78d36b5] Handle subtxn for cache pinning * [26ef77f] Add subtxn abort logic to process_utility.c * [25f3284] Handle cache invalidation during subtxn rollback * [264956f] Block DROP NOT NULL on time-partitioned columns. * [ad7d361] Better accounting for number of items stored in a subspace * [12f92ea] Improve speed of out-of-order inserts * [87f055d] Add support for ALTER TABLE RENAME CONSTRAINT. * [da8cc79] Add support for multiple extension version in one pg instance * [68faddc] Make chunks inherit reloptions set on the hypertable * [4df8f28] Add proper permissions handling for associated (chunk) schemas * [21efcce] Refactor chunk table creation and unify constraint handling **Thanks** * @Anthares for a request to pass reloptions like fill factor to child chunks * @oldgreen for reporting an issue with subtransaction handling * @fvannee for a PR that fixed a bug with `ca_append_rescan` * @maksm90 for reporting an superfluous index being created in an internal catalog table * @Rashid987 for reporting an issue where deleting a chunk, then changing the time interval would not apply the change when a replacement chunk is created * RaedA from Slack for reporting compilation issues on Windows between 0.8.0 and this release * @haohello for a request to adjust the number of partitions for a given dimension * @LonghronShen and @devereaux for reporting an issue (and submitting a PR) for handling version identification when there is more to the version than just major and minor numbers * @carlospeon for reporting an issue with dropping hypertables * @gumshoes, @simpod, @jbylund, and @ryan-shaw for testing a pre-release version to verify our new update path works as expected * @gumshoes for reporting an issue with `RESET ALL` ## 0.8.0 (2017-12-19) **High-level changes** * TimescaleDB now builds and runs on Windows! Now in addition to using Docker, users can choose to build the extension from source and install on 64-bit Windows * Update functions `add_dimension` and `set_chunk_time_interval` to take `INTERVAL` types * Improved tablespace management including detaching tablespaces from hypertables and looking up tablespaces associated with a hypertable * Reduced memory usage for `INSERT`s with out-of-order data * Fixes inserts on 32-bit architectures, in particular ARM * Other correctness improvements including preventing attachment of PG10 partitions to hypertables, improved handling of space dimensions with one partition, and correctly working with `pg_upgrade` * Test and build improvements making those both more robust and easier to do **Notable commits** * [26971d2] Make `tablespace_show` function return Name instead of CString * [2fe447b] Make TimescaleDB work with pg_upgrade * [90c7a6f] Fix logic for one space partition * [6cfdd79] Prevent native partitioning attachment of hypertables * [438d79d] Fix trigger relcache handling for COPY * [cc1ad95] Reduce memory usage for out-of-order inserts * [a0f62c5] Improve bootstrap script's robustness * [00a096f] Modify tests to make more platform agnostic * [0e76b5f] Do not add tablespaces to hypertable objects * [176b75e] Add command to show tablespaces attached to a hypertable * [6e92383] Add function to detach tablespaces from hypertables * [e593876] Refactor tablespace handling * [c4a46ac] Add hypertable cache lookup on ID/pkey * [f38a578] Fix handling of long constraint names * [20c9b28] Unconditionally add pg_config --includedir to src build * [12dff61] Fixes insert for 32bit architecture * [e44e47e] Update add_dimension to take INTERVAL times * [0763e62] Update set_chunk_time_interval to take INTERVAL times * [87c4b4f] Fix test generator to work for PG 10.1 * [51854ac] Fix error message to reflect that drop_chunks can take a DATE interval * [66396fb] Add build support for Windows * [e1a0e81] Refactor and fix cache invalidation **Thanks** * @oldgreen for reporting an issue where `COPY` was warning of relcache reference leaks * @campeterson for pointing out some documentation typos * @jwdeitch for the PR to prevent attaching PG10 partitions to hypertables * @vjpr and @sztanpet for reporting bugs and suggesting improvements to the bootstrap script ## 0.7.1 (2017-11-29) **High-level changes** * Fix to the migration script for those coming from 0.6.1 (or earlier) * Fix edge case in `drop_chunks` when hypertable uses `TIMESTAMP` type * Query planning improvements & fixes * Permission fixes and support `SET ROLE` functionality **Notable commits** * [717299f] Change time handling in drop_chunks for TIMESTAMP times * [d8ec285] Do not append-optimize plans with result relations (DELETE/UPDATE) * [30b72ec] Handle empty append plans in ConstraintAwareAppend * [b35509b] Permission fixes and allow SET ROLE **Thanks** * @shaneodonnell for reporting a bug with empty append plans in ConstraintAwareAppend * @ryan-shaw for reporting a bug with query plans involving result relations and reporting an issue with our 0.6.1 to 0.7.0 migration script ## 0.7.0 (2017-11-21) **Please note: This update may take a long time (minutes, even hours) to complete, depending on the size of your database** **High-level changes** * **Initial PostgreSQL 10 support**. TimescaleDB now should work on both PostgreSQL 9.6 and 10. As this is our first release supporting PG10, we look forward to community feedback and testing. _Some release channels, like Ubuntu & RPM-based distros will remain on 9.6 for now_ * Support for `CLUSTER` on hypertables to recursively apply to chunks * Improve constraint handling of edge cases for `DATE` and `TIMESTAMP` * Fix `range_start` and `range_end` to properly handle the full 32-bit int space * Allow users to specify their desired partitioning function * Enforce `NOT NULL` constraint on time columns * Add testing infrastructure to use Coverity and test PostgreSQL regression tests in TimescaleDB * Switch to the CMake build system for better cross-platform support * Several other bug fixes, cleanups, and improvements **Notable commits** * [13e1cb5] Add reindex function * [6594018] Handle when create_hypertable is invoked on partitioned table * [818bdbc] Add coverity testing * [5d0cbc1] Recurse CLUSTER command to chunks * [9c7191e] Change TIMESTAMP partitioning to be completely tz-independent * [741b256] Mark IMMUTABLE functions as PARALLEL SAFE * [2ffb30d] Make aggregate serialize and deserialize functions STRICT * [c552410] Add build target to run the standard PostgreSQL regression tests * [291050b] Change DATE partitioning to be completely tz-independent * [ca0968a] Make all partitioning functions take anyelement argument * [a4e1e32] Change range_start and range_end semantics * [2dfbc82] Fix off-by-one error on range-end * [500563f] Add support for PostgreSQL 10 * [201a948] Check that time dimensions are set as NOT NULL. * [4532650] Allow setting partitioning function * [4a0a0d8] Fix column type change on plain tables * [cf009cc] Avoid string conversion in hash partitioning * [8151098] Improve update testing by adding a rerun test * [c420c11] Create a catalog entry for constraint-backed indexes * [ec746d1] Add ability to run regression test locally * [44f9fec] Add analyze to parallel test for stability * [9e0422a] Fix bug with pointer assignment after realloc * [114fa8d] Refactor functions used to recurse DDL commands to chunks * [b1ec4fa] Refactor build system to use CMake **Thanks** * @jgraichen for reporting an issue with `drop_chunks` not accepting `BIGINT` * @nathansgreen for reporting an edge case with constraints for `TIMESTAMP` * @jonmd for reporting a similar edge case for `DATE` * @jwdeitch for a PR to cover an error case in PG10 ## 0.6.1 (2017-11-07) **High-level changes** * Fix several memory bugs that caused segfaults * Fix bug when creating expression indexes * Plug a memory leak with constraint expressions * Several other bug fixes and stability improvements **Notable commits** * [2799075] Fix EXPLAIN for ConstraintAware and MergeAppend * [8084594] Use per-chunk memory context for cached chunks * [a13d9de] Do not convert tuples on insert unless needed * [da09f24] Limit growth of range table during chunk inserts * [85dee79] Fix issue with creating expression indexes * [844ff7f] Fix memory leak due to constraint expressions. * [e90d3ee] Consider precvious CIS state in copy FROM file to rel * [56d632f] Fix bug with pointer assignment after realloc * [f97d624] Make event trigger creation idempotent **Thanks** * @jwdeitch for submitting a patch to correct behavior in the COPY operation * @jgraichen for reporting a bug with expression indexes * @zixet for reporting a memory leak * @djk447 for reporting a bug in EXPLAIN with ConstraintAware and MergeAppend ## 0.6.0 (2017-10-12) **High-level changes** * Fix bugs where hypertable-specific handlers were affecting normal Postgres tables. * Make it so that all TimescaleDB commands can run as a normal user rather than a superuser. * Updates to the code to make the extension compileable on Windows; future changes will add steps to properly build. * Move `time_bucket` functions out of `public` schema (put in schema where extension is). * Several other bugs fixes. **Notable commits** * [1d73fb8] Fix bug with extension starting too early. * [fd390ec] Fix chunk index attribute mismatch and locking issue * [430ed8a] Fix bug with collected commands in index statement. * [614c2b7] Fix permissions bugs and run tests as normal user * [ce12104] Fix "ON CONFLICT ON CONSTRAINT" on plain PostgreSQL tables * [4c451e0] Fix rename and reindex bugs when objects are not relations * [c3ebc67] Fix permission problems with dropping hypertables and chunks * [040e815] Remove truncate and hypertable metadata triggers * [5c26328] Fix INSERT on hypertables using sub-selects with aggregates * [b57e2bf] Prepare C code for compiling on Windows * [a2bad2b] Fix constraint validation on regular tables * [fb5717f] Remove explicit schema for time_bucket * [04d01ce] Split DDL processing into start and end hooks **Thanks** * @oldgreen for reporting `time_bucket` being incorrectly put in the `public` schema and pointing out permission problems * @qlandman for reporting a bug with INSERT using sub-selects with aggregates * @min-mwei for reporting a deadlock issue during INSERTs * @ryan-shaw for reporting a bug where the extension sometimes used `pg_cache` too soon ## 0.5.0 (2017-09-20) **High-level changes** * Improved support for primary-key, foreign-key, unique, and exclusion constraints. * New histogram function added for getting the frequency of a column's values. * Add support for using `DATE` as partition column. * `chunk_time_interval` now supports `INTERVAL` data types * Block several unsupported and/or dangerous operations on hypertables and chunks, including dropping or otherwise altering a chunk directly. * Several bug fixes throughout the code. **Notable commits** * [afcb0b1] Fix NULL handling in first/last functions. * [d53c705] Add script to dump meta data that can be useful for debugging. * [aa904fa] Block adding constraints without a constraint name * [a13039f] Fix dump and restore for tables with triggers and constraints * [8cf8d3c] Improve the size utils functions. * [2767548] Block adding constraints using an existing index * [5cee104] Allow chunk_time_interval to be specified as an INTERVAL type * [6232f98] Add histogram function. * [2380033] Block ALTER TABLE and handle DROP TABLE on chunks * [72d6681] Move security checks for ALTER TABLE ALTER COLUMN to C * [19d3d89] Handle changing the type of dimension columns correctly. * [17c4ba9] Handle ALTER TABLE rename column * [66932cf] Forbid relocating extension after install. * [d2561cc] Add ability to partition by a date type * [48e0a61] Remove triggers from chunk and chunk_constraint * [4dcbe61] Add support for hypertable constraints **Thanks** * @raycheung for reporting a segfault in `first`/`last` * @meotimdihia, @noyez, and @andrew-blake for reporting issues with `UNQIUE` and other types of constraints ## 0.4.2 (2017-09-06) **High-level changes** * Provide scripts for backing up and restoring single hypertables **Notable commits** * [683c078] Add backup/restore scripts for single hypertables ## 0.4.1 (2017-09-04) **High-level changes** * Bug fix for a segmentation fault in the planner * Shortcut when constraint-aware append excludes all chunks * Fix edge case with negative timestamps when points fell right on the boundary * Fix behavior of `time_bucket` for `DATE` types by not converting to `TIMESTAMPTZ` * Make the output of `chunk_relation_size` consistent **Notable commits** * [50c8c4c] Fix possible segfault in planner * [e49e45c] Fix failure when constraint-aware append excludes all chunks * [c3b6fb9] Fix bug with negative dimension values * [3c69e4f] Fix semantics of time_bucket on DATE input * [0137c92] Fix output order of chunk dimensions and ranges in chunk_relation_size. * [645b530] Convert inserted tuples to the chunk's rowtype **Thanks** * @yadid for reporting a segfault (fixed in 50c8c4c) * @ryan-shaw for reporting tuples not being correctly converted to a chunk's rowtype (fixed in 645b530) * @yuezhihan for reporting GROUP BY error when setting compress_segmentby with an enum column ## 0.4.0 (2017-08-21) **High-level changes** * Exclude chunks when constraints can be constifyed even if they are considered mutable like `NOW()`. * Support for negative values in the dimension range which allows for pre-1970 dates. * Improve handling of default chunk times for integral date times by forcing it to be explicit rather than guessing the units of the time. * Improve memory usage for long-running `COPY` operations (previously it would grow unbounded). * `VACUUM` and `REINDEX` on hypertables now recurse down to chunks. **Notable commits** * [139fe34] Implement constraint-aware appends to exclude chunks at execution time * [2a51cf0] Add support for negative values in dimension range * [f2d5c3f] Error if add_dimension given both partition number and interval length * [f3df02d] Improve handling of non-TIMESTAMP/TZ timestamps * [6a5a7eb] Reduce memory usage on long-running COPY operations * [953346c] Make VACUUM and REINDEX recurse to chunks * [55bfdf7] Release all cache pins when a transaction ends ## 0.3.0 (2017-07-31) **High-level changes** * "Upserts" are now supported via normal `ON CONFLICT DO UPDATE`/`ON CONFLICT DO NOTHING` syntax. However, `ON CONFLICT ON CONSTRAINT` is not yet supported. * Improved support for user-defined triggers on hypertables. Now handles both INSERT BEFORE and INSERT AFTER triggers, and triggers can be named arbitrarily (before, a \_0\_ prefix was required to ensure correct execution priority). * `TRUNCATE` on a hypertable now deletes empty chunks. **Notable commits** * [23f9d3c] Add support for upserts (`ON CONFLICT DO UPDATE`) * [1f3dcd8] Make `INSERT`s use a custom plan instead of triggers * [f23bf58] Remove empty chunks on `TRUNCATE` hypertable. ## 0.2.0 (2017-07-12) **High-level changes** * Users can now define their own triggers on hypertables (except for `INSERT AFTER`) * Hypertables can now be renamed or moved to a different schema * Utility functions added so you can examine the size hypertables, chunks, and indices **Notable commits** * [83c75fd] Add support for triggers on hypertables for all triggers except `INSERT AFTER` * [e0eeeb9] Add hypertable, chunk, and indexes size utils functions. * [4d2a65d] Add infrastructure to build update script files. * [a5725d9] Add support to rename and change schema on hypertable. * [142f58c] Cleanup planner and process utility hooks ## 0.1.0 (2017-06-28) **IMPORTANT NOTE** Starting with this release, TimescaleDB will now support upgrading between extension versions using the typical `ALTER EXTENSION` command, unless otherwise noted in future release notes. This important step should make it easier to test TimescaleDB and be able to get the latest benefits from new versions of TimescaleDB. If you were previously using a version with the `-beta` tag, you will need to `DROP` any databases currently using TimescaleDB and re-create them in order to upgrade to this new version. To backup and migrate data, use `pg_dump` to save the table schemas and `COPY` to write hypertable data to CSV for re-importing after upgrading is complete. We describe a similar process on [our docs](http://docs.timescale.com/getting-started/setup/migrate-from-postgresql#different-db). **High-level changes** * More refactoring to stabilize and cleanup the code base for supporting upgrades (see above note) * Correct handling of ownership and permission propagation for hypertables * Multiple bug fixes **Notable commits** * [696cc4c] Provide API for adding hypertable dimensions * [97681c2] Fixes permission handling * [aca7f32] Fix extension drop handling * [9b8a447] Limit the SubspaceStore size; Add documentation. * [14ac892] Fix possible segfault * [0f4169c] Fix check constraint on dimension table * [71c5e78] Fix and refactor tablespace support * [5452dc5] Fix partiton functions; bug fixes (including memory) * [e75cd7e] Finer grained memory management * [3c460f0] Fix partitioning, memory, and tests * [fe51d8d] Add native scan for the chunk table * [fc68baa] Separate out subspace_store and add it to the hypertable object as well * [c8124b8] Use hypercube instead of dimension slice list * [f5d7786] Change the semantics of range_end to be exclusive * [700c9c8] Refactor insert path in C. * [0584c47] Created chunk_get_or_create in sql with an SPI connector in C * [7b8de0c] Refactor catalog for new schema and add native data types * [d3bdcba] Start refactoring to support any number of partitioning dimensions ## 0.0.12-beta (2017-06-21) **High-level changes** * A major cleanup and refactoring was done to remove legacy code and currently unused code paths. This change is **backwards incompatible** and will require a database to be re-initialized and data re-imported. This refactoring will allow us to provide upgrade paths starting with the next release. * `COPY` and `INSERT` commands now return the correct number of rows * Default indexes no longer duplicate existing indexes * Cleanup of the Docker image and build process * Chunks are now time-aligned across partitions **Notable commits** * [3192c8a] Remove Dockerfile and docker.mk * [2a01ebc] Ensure that chunks are aligned. * [73622bf] Fix default index creation duplication of indexes * [c8872fe] Fix command-tag for COPY and INSERT * [bfe58b6] Refactor towards supporting version upgrades * [db01c84] Make time-bucket function parallel safe * [18db11c] Fix timestamp test * [97bbb59] Make constraint exclusion work with non-text partition keys * [f2b42eb] Fix problems with partitioning logic for padded fields * [997029a] if_not_exist flag to create_hypertable now works on hypertables with data as well * [347a8bd] Reference the correct column when scanning partition epochs * [88a9849] Fix bug with timescaledb.allow_install_without_preload GUC not working ## 0.0.11-beta (2017-05-24) **High-level changes** * New `first(value, time)` and `last(value, time)` aggregates * Remove `setup_timescaledb()` function to streamline setup * Allow for use cases where restarting the server is not feasible by force loading the library * Disable time series optimizations on non-hypertables * Add some default indexes for hypertables if they do not exist * Add "if not exists" flag for `create_hypertable` * Several bug fixes and cleanups **Notable commits** * [8ccc8cc] Add if_not_exists flag to create_hypertable() * [2bc60c7] Fix time interval field name in hypertable cache entry * [4638688] Improve GUC handling * [cedcafc] Remove setup_timescaledb() and fix pg_dump/pg_restore. * [34ad9a0] Add error when timescaledb library is not preloaded. * [fc4ddd6] Fix bug with dropping chunks on tables with indexes * [32215ff] Add default indexes for hypertables * [b2900f9] Disable query optimization on regular tables (non-hypertables) * [f227db4] Fixes command tag return for COPY on hypertables. * [eb32081] Fix Invalid database ID error * [662be94] Add the first(value, time),last(value, time) aggregates * [384a8fb] Add regression tests for deleted unit tests * [31ee92a] Remove unit tests and sql/setup * [13d3acb] Fix bug with alter table add/drop column if exists * [f960c24] Fix bug with querying a row as a composite type ## 0.0.10-beta (2017-05-04) **High-level changes** * New `time_bucket` functions for doing roll-ups on varied intervals * Change default partition function (thanks @robin900) * Variety of bug fixes **Notable commits** * [1c4868d] Add documentation for chunk_time_interval argument * [55fd2f2] Fixes command tag return for `INSERT`s on hypertables. * [c3f930f] Add `time_bucket` functions * [b128ac2] Fix bug with `INSERT INTO...SELECT` * [e20edf8] Add better error checking for index creation. * [72f754a] use PostgreSQL's own `hash_any` function as default partfunc (thanks @robin900) * [39f4c0f] Remove sample data instructions and point to docs site * [9015314] Revised the `get_general_index_definition` function to handle cases where indexes have definitions other than just `CREATE INDEX` (thanks @bricklen) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/CMakeLists.txt�������������������������������������������������������������������0000664�0000000�0000000�00000055560�15100345067�0016626�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������cmake_minimum_required(VERSION 3.15) list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) include(CheckCCompilerFlag) include(CheckSymbolExists) include(GitCommands) include(GenerateScripts) include(CMakeDependentOption) option(APACHE_ONLY "only compile apache code" off) # This requires all tests to run. This defaults to OFF but can be enabled to # ensure that no tests are skipped because of missing tools. option(REQUIRE_ALL_TESTS "Require all tests to run." OFF) option(USE_OPENSSL "Enable use of OpenSSL if available" ON) option(SEND_TELEMETRY_DEFAULT "The default value for whether to send telemetry" ON) option( USE_TELEMETRY "Include telemetry functionality in the build. Disabling will exclude all telemetry code from the build." ON) option(REGRESS_CHECKS "PostgreSQL regress checks through installcheck" ON) option( ENABLE_OPTIMIZER_DEBUG "Enable OPTIMIZER_DEBUG when building. Requires Postgres server to be built with OPTIMIZER_DEBUG." OFF) option(ENABLE_DEBUG_UTILS "Enable debug utilities for the extension." ON) # Option to enable assertions. Note that if we include headers from a PostgreSQL # build that has assertions enabled, we might inherit that setting without # explicitly enabling assertions via the ASSERTIONS option defined here. Thus, # this option is mostly useful to enable assertions when the PostgreSQL we # compile against has it disabled. option(ASSERTIONS "Compile with assertion checks (default OFF)" OFF) # Function to call pg_config and extract values. function(GET_PG_CONFIG var) set(_temp) # Only call pg_config if the variable didn't already have a value. if(NOT ${var}) execute_process( COMMAND ${CMAKE_COMMAND} -E env LC_MESSAGES=C ${PG_CONFIG} ${ARGN} OUTPUT_VARIABLE _temp OUTPUT_STRIP_TRAILING_WHITESPACE) endif() # On Windows, fields that are not recorded will be given the value "not # recorded", so we translate this into <var>-NOTFOUND to make it undefined. # # It will then also show as, e.g., "PG_LDFLAGS-NOTFOUND" in any string # interpolation, making it obvious that it is an undefined CMake variable. if("${_temp}" STREQUAL "not recorded") set(_temp ${var}-NOTFOUND) endif() set(${var} ${_temp} PARENT_SCOPE) endfunction() # Search paths for Postgres binaries if(WIN32) find_path( PG_PATH postgres.exe PATHS "C:/PostgreSQL" "C:/Program Files/PostgreSQL" PATH_SUFFIXES bin 15/bin 16/bin DOC "The path to a PostgreSQL installation") elseif(UNIX) find_path( PG_PATH postgres PATHS $ENV{HOME} /opt/local/pgsql /usr/local/pgsql /usr/lib/postgresql PATH_SUFFIXES bin 15/bin 16/bin DOC "The path to a PostgreSQL installation") endif() find_program( PG_CONFIG pg_config HINTS ${PG_PATH} PATH_SUFFIXES bin DOC "The path to the pg_config of the PostgreSQL version to compile against") if(NOT PG_CONFIG) message(FATAL_ERROR "Unable to find 'pg_config'") endif() configure_file("version.config" "version.config" COPYONLY) file(READ version.config VERSION_CONFIG) if(VERSION_CONFIG MATCHES "(^|.*[^a-z])version[\t ]*=[\t ]*([0-9]+\\.[0-9]+\\.*[0-9]*)(-([a-z]+[0-9]*|dev))?.*" ) set(VERSION ${CMAKE_MATCH_2}) set(VERSION_MOD ${CMAKE_MATCH_4}) # This is used in config.h if(CMAKE_MATCH_3) set(PROJECT_VERSION_MOD ${CMAKE_MATCH_2}${CMAKE_MATCH_3}) else() set(PROJECT_VERSION_MOD ${CMAKE_MATCH_2}) endif() endif() if(VERSION_CONFIG MATCHES ".*previous_version[\t ]*=[\t ]*([0-9]+\\.[0-9]+\\.[0-9]+(-[a-z]+[0-9]*)?).*" ) set(PREVIOUS_VERSION ${CMAKE_MATCH_1}) else() message( FATAL_ERROR "Could not determine previous version from version.config") endif() # a hack to avoid change of SQL extschema variable set(extschema "@extschema@") # If not explicitly specified, try to use the same compiler as Postgres to avoid # mismatches and simplify configuration. if((NOT DEFINED CMAKE_C_COMPILER) AND (NOT DEFINED ENV{CC})) get_pg_config(PG_CC --cc) # The first word might be ccache or similar, so handle this. string(REPLACE " " ";" PG_CC_LIST ${PG_CC}) list(POP_FRONT PG_CC_LIST PG_CC_FIRST) if(PG_CC_LIST) # Got multi-word PG CC, treat the first word as ccache. find_program(PG_CCACHE_FOUND ${PG_CC_FIRST}) if((NOT DEFINED CMAKE_C_COMPILER_LAUNCHER) AND PG_CCACHE_FOUND) message( STATUS "Using ${PG_CCACHE_FOUND} as C compiler launcher based on pg_config CC" ) set(CMAKE_C_COMPILER_LAUNCHER ${PG_CCACHE_FOUND}) endif() set(PG_CC ${PG_CC_LIST}) else() # Single-word CC. set(PG_CC ${PG_CC_FIRST}) endif() find_program(PG_CC_FOUND ${PG_CC}) if(PG_CC_FOUND) message(STATUS "Using ${PG_CC_FOUND} as CC based on pg_config CC") set(CMAKE_C_COMPILER ${PG_CC_FOUND}) endif() endif() # Set project name, version, and language. Language needs to be set for compiler # checks project( timescaledb VERSION ${VERSION} LANGUAGES C) if(NOT CMAKE_BUILD_TYPE) # Default to Release builds set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel" FORCE) endif() set(SUPPORTED_BUILD_TYPES Debug Release RelWithDebInfo MinSizeRel) if(NOT CMAKE_BUILD_TYPE IN_LIST SUPPORTED_BUILD_TYPES) message( FATAL_ERROR "Bad CMAKE_BUILD_TYPE. Expected one of ${SUPPORTED_BUILD_TYPES}" ) endif() message( STATUS "TimescaleDB version ${PROJECT_VERSION_MOD}. Can be updated from version ${PREVIOUS_VERSION}" ) message(STATUS "Build type is ${CMAKE_BUILD_TYPE}") set(PROJECT_INSTALL_METHOD source CACHE STRING "Specify what install platform this binary is built for") message(STATUS "Install method is '${PROJECT_INSTALL_METHOD}'") # Build compilation database by default set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # Code coverage is optional and OFF by default option(CODECOVERAGE "Enable code coverage for the build" OFF) option(EXPERIMENTAL "Skip postgres version compatibility check" OFF) # Generate downgrade script option(GENERATE_DOWNGRADE_SCRIPT "Generate downgrade script. Defaults to not generate a downgrade script." OFF) if(CMAKE_BUILD_TYPE MATCHES Debug) # CMAKE_BUILD_TYPE is set at CMake configuration type. But usage of # CMAKE_C_FLAGS_DEBUG is determined at build time by running cmake --build . # --config Debug (at least on Windows). Therefore, we only set these flags if # the configuration-time CMAKE_BUILD_TYPE is set to Debug. Then Debug enabled # builds will only happen on Windows if both the configuration- and build-time # settings are Debug. set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG=1 -DTS_DEBUG=1") endif(CMAKE_BUILD_TYPE MATCHES Debug) set(SUPPORTED_COMPILERS "GNU" "Clang" "AppleClang" "MSVC") # Check for a supported compiler if(NOT CMAKE_C_COMPILER_ID IN_LIST SUPPORTED_COMPILERS) message( FATAL_ERROR "Unsupported compiler ${CMAKE_C_COMPILER_ID}. Supported compilers are: ${SUPPORTED_COMPILERS}" ) endif() # Option to treat warnings as errors when compiling (default on for debug # builds, off for all other build types) if(CMAKE_BUILD_TYPE STREQUAL Debug) option(WARNINGS_AS_ERRORS "Make compiler warnings into errors (default ON)" ON) else() option(WARNINGS_AS_ERRORS "Make compiler warnings into errors (default ON)" OFF) endif() if(WARNINGS_AS_ERRORS) if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang|AppleClang") add_compile_options(-Werror) elseif(CMAKE_C_COMPILER_ID MATCHES "MSVC") add_compile_options(/WX) endif() endif(WARNINGS_AS_ERRORS) if(CMAKE_C_COMPILER_ID MATCHES "GNU|AppleClang|Clang") # These two flags generate too many errors currently, but we probably want # these optimizations enabled. # # -fdelete-null-pointer-checks -Wnull-dereference # This flag avoid some subtle bugs related to standard conversions, but # currently does not compile because we are using too many implicit # conversions that potentially lose precision. # # -Wconversions # These flags are supported on all compilers. add_compile_options( -Wempty-body -Wvla -Wall -Wextra # The SQL function arguments macro PG_FUNCTION_ARGS often inroduces unused # arguments. -Wno-unused-parameter -Wundef -Wmissing-prototypes -Wpointer-arith -Werror=vla -Wendif-labels -fno-strict-aliasing -fno-omit-frame-pointer) # These flags are just supported on some of the compilers, so we check them # before adding them. check_c_compiler_flag(-Wno-unused-command-line-argument CC_SUPPORTS_NO_UNUSED_CLI_ARG) if(CC_SUPPORTS_NO_UNUSED_CLI_ARG) add_compile_options(-Wno-unused-command-line-argument) endif() check_c_compiler_flag(-Wno-format-truncation CC_SUPPORTS_NO_FORMAT_TRUNCATION) if(CC_SUPPORTS_NO_FORMAT_TRUNCATION) add_compile_options(-Wno-format-truncation) else() message(STATUS "Compiler does not support -Wno-format-truncation") endif() check_c_compiler_flag(-Wstringop-truncation CC_STRINGOP_TRUNCATION) if(CC_STRINGOP_TRUNCATION) add_compile_options(-Wno-stringop-truncation) else() message(STATUS "Compiler does not support -Wno-stringop-truncation") endif() check_c_compiler_flag(-Wimplicit-fallthrough CC_SUPPORTS_IMPLICIT_FALLTHROUGH) if(CC_SUPPORTS_IMPLICIT_FALLTHROUGH) add_compile_options(-Wimplicit-fallthrough) else() message(STATUS "Compiler does not support -Wimplicit-fallthrough") endif() check_c_compiler_flag(-Wnewline-eof CC_SUPPORTS_NEWLINE_EOF) if(CC_SUPPORTS_NEWLINE_EOF) add_compile_options(-Wnewline-eof) endif() # strict overflow check produces false positives on gcc < 8 if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER_VERSION VERSION_LESS 8) add_compile_options(-Wno-strict-overflow) endif() # -Wclobbered produces false positives on gcc < 9 if(CMAKE_COMPILER_IS_GNUCC AND CMAKE_C_COMPILER_VERSION VERSION_LESS 9) add_compile_options(-Wno-clobbered) endif() if(CMAKE_COMPILER_IS_GNUCC) add_compile_options( # Seems to be broken in GCC 11 with designated initializers. -Wno-missing-field-initializers) endif() # On UNIX, the compiler needs to support -fvisibility=hidden to hide symbols # by default check_c_compiler_flag(-fvisibility=hidden CC_SUPPORTS_VISIBILITY_HIDDEN) if(NOT CC_SUPPORTS_VISIBILITY_HIDDEN) message( FATAL_ERROR "The compiler ${CMAKE_C_COMPILER_ID} does not support -fvisibility=hidden" ) endif(NOT CC_SUPPORTS_VISIBILITY_HIDDEN) endif() # On Windows, default to only include Release builds so MSBuild.exe 'just works' if(WIN32 AND NOT CMAKE_CONFIGURATION_TYPES) set(CMAKE_CONFIGURATION_TYPES Release CACHE STRING "Semicolon separated list of supported configuration types, only supports Debug, Release, MinSizeRel, and RelWithDebInfo, anything else will be ignored." FORCE) endif() message(STATUS "Using compiler ${CMAKE_C_COMPILER_ID}") if(ENABLE_OPTIMIZER_DEBUG) message( STATUS "Enabling OPTIMIZER_DEBUG. Make sure that ${PG_SOURCE_DIR} is installed and built with OPTIMIZER_DEBUG." ) add_definitions(-DOPTIMIZER_DEBUG) endif() find_package(Git) # Check PostgreSQL version execute_process( COMMAND ${PG_CONFIG} --version OUTPUT_VARIABLE PG_VERSION_STRING OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT ${PG_VERSION_STRING} MATCHES "^PostgreSQL[ ]+([0-9]+)(\\.([0-9]+)|beta|devel|rc[0-9]+)") message(FATAL_ERROR "Could not parse PostgreSQL version ${PG_VERSION_STRING}") endif() set(PG_VERSION_MAJOR ${CMAKE_MATCH_1}) if(${CMAKE_MATCH_COUNT} GREATER "2") set(PG_VERSION_MINOR ${CMAKE_MATCH_3}) else() set(PG_VERSION_MINOR 0) endif() set(PG_VERSION "${PG_VERSION_MAJOR}.${PG_VERSION_MINOR}") message( STATUS "Compiling against PostgreSQL version ${PG_VERSION} using pg_config '${PG_CONFIG}'" ) # Ensure that PostgreSQL version is supported and consistent with src/compat.h # version check if((${PG_VERSION_MAJOR} LESS "15") OR (${PG_VERSION_MAJOR} GREATER "18") AND NOT (${EXPERIMENTAL})) message(FATAL_ERROR "TimescaleDB only supports PostgreSQL 15, 16, 17 and 18") endif() # Get PostgreSQL configuration from pg_config get_pg_config(PG_INCLUDEDIR --includedir) get_pg_config(PG_INCLUDEDIR_SERVER --includedir-server) get_pg_config(PG_LIBDIR --libdir) get_pg_config(PG_PKGLIBDIR --pkglibdir) get_pg_config(PG_SHAREDIR --sharedir) get_pg_config(PG_BINDIR --bindir) get_pg_config(PG_CFLAGS --cflags) get_pg_config(PG_CFLAGS_SL --cflags_sl) get_pg_config(PG_CPPFLAGS --cppflags) get_pg_config(PG_LDFLAGS --ldflags) get_pg_config(PG_LIBS --libs) separate_arguments(PG_CFLAGS) foreach(option ${PG_CFLAGS}) if(NOT ${option} MATCHES ^-W) set(filtered "${filtered} ${option}") endif() endforeach() set(PG_CFLAGS "${filtered} ${PG_CFLAGS_SL}") find_path( PG_SOURCE_DIR src/include/pg_config.h.in HINTS $ENV{HOME} $ENV{HOME}/projects $ENV{HOME}/Projects $ENV{HOME}/development $ENV{HOME}/Development $ENV{HOME}/workspace PATH_SUFFIXES postgres postgresql pgsql DOC "The path to the PostgreSQL source tree") option(PG_SOURCE_INCLUDES "Add PG source to include directories" OFF) if(PG_SOURCE_DIR) message(STATUS "Found PostgreSQL source in ${PG_SOURCE_DIR}") if(PG_SOURCE_INCLUDES) # Add the PostgreSQL source dir include directories to the build system # includes BEFORE the installed PG include files. This will allow the LSP # (e.g., clangd) to navigate to the PostgreSQL source instead of the install # path directory that only has the headers. include_directories(BEFORE SYSTEM ${PG_SOURCE_DIR}/src/include) endif(PG_SOURCE_INCLUDES) endif(PG_SOURCE_DIR) set(EXT_CONTROL_FILE ${PROJECT_NAME}.control) configure_file(${EXT_CONTROL_FILE}.in ${EXT_CONTROL_FILE}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${EXT_CONTROL_FILE} DESTINATION "${PG_SHAREDIR}/extension") find_program( CLANG_FORMAT NAMES clang-format-14 clang-format PATHS /usr/bin /usr/local/bin /usr/local/opt/ /usr/local/opt/llvm/bin /opt/bin DOC "The path to clang-format") if(CLANG_FORMAT) execute_process( COMMAND ${CLANG_FORMAT} --version OUTPUT_VARIABLE CLANG_FORMAT_VERSION_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT ${CLANG_FORMAT_VERSION_OUTPUT} MATCHES "version[ ]+([0-9]+)\\.([0-9]+)(\\.([0-9]+))*") message( FATAL_ERROR "Could not parse clang-format version ${CLANG_FORMAT_VERSION_OUTPUT}") endif() if((${CMAKE_MATCH_1} LESS "14")) message(WARNING "clang-format version 14 or greater required") set(CLANG_FORMAT False) endif() endif() if(CLANG_FORMAT) message(STATUS "Using local clang-format") add_custom_target( clang-format COMMAND ${CMAKE_COMMAND} -E env CLANG_FORMAT=${CLANG_FORMAT} ${PROJECT_SOURCE_DIR}/scripts/clang_format_all.sh) endif() find_program( CMAKE_FORMAT NAMES cmake-format PATHS /usr/bin /usr/local/bin /usr/local/opt/ /usr/local/opt/llvm/bin /opt/bin DOC "The path to cmake-format") if(CMAKE_FORMAT) add_custom_target( cmake-format COMMAND ${CMAKE_COMMAND} -E env CMAKE_FORMAT=${CMAKE_FORMAT} ${PROJECT_SOURCE_DIR}/scripts/cmake_format_all.sh) endif() find_program( PERLTIDY NAMES perltidy PATHS /bin /usr/bin /usr/local/bin /usr/local/opt/ /opt/bin DOC "The path to perltidy") if(PERLTIDY) message(STATUS "Using perltidy ${PERLTIDY}") add_custom_target( perltidy COMMAND ${CMAKE_COMMAND} -E env PERLTIDY=${PERLTIDY} PERLTIDY_CONFIG="${PROJECT_SOURCE_DIR}/.perltidyrc" ${PROJECT_SOURCE_DIR}/scripts/perltidy_format_all.sh) endif() if(TARGET clang-format OR TARGET cmake-format OR TARGET perltidy) add_custom_target(format) if(TARGET clang-format) add_dependencies(format clang-format) endif() if(TARGET cmake-format) add_dependencies(format cmake-format) endif() if(TARGET perltidy) add_dependencies(format perltidy) endif() endif() if(REGRESS_CHECKS) find_program(PG_REGRESS pg_regress HINTS "${PG_BINDIR}" "${PG_PKGLIBDIR}/pgxs/src/test/regress/") if(NOT PG_REGRESS) message(STATUS "Regress checks disabled: program 'pg_regress' not found") endif() find_program( PG_ISOLATION_REGRESS NAMES pg_isolation_regress HINTS ${PG_BINDIR} ${PG_PKGLIBDIR}/pgxs/src/test/isolation ${PG_SOURCE_DIR}/src/test/isolation ${BINDIR}) if(NOT PG_ISOLATION_REGRESS) message( STATUS "Isolation regress checks disabled: 'pg_isolation_regress' not found") endif() else() message(STATUS "Regress checks and isolation checks disabled") endif() # Linter support via clang-tidy. Enabled when using clang as compiler option(LINTER "Enable linter support using clang-tidy" OFF) set(CLANG_TIDY_EXTRA_OPTS "" CACHE STRING "Additional options for clang-tidy") if(LINTER) find_program( CLANG_TIDY clang-tidy PATHS /usr/bin /usr/local/bin /usr/local/opt/ /usr/local/opt/llvm/bin /opt/bin DOC "The path to the clang-tidy linter" REQUIRED) message(STATUS "Using clang-tidy ${CLANG_TIDY}") execute_process(COMMAND ${CLANG_TIDY} --version) string( CONCAT CMAKE_C_CLANG_TIDY "${CLANG_TIDY}" ";--checks=clang-diagnostic-*,clang-analyzer-*" ",-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling" ",-clang-analyzer-deadcode.DeadStores" ",bugprone-*" ",-bugprone-branch-clone" ",-bugprone-easily-swappable-parameters" ",-bugprone-implicit-widening-of-multiplication-result" ",-bugprone-narrowing-conversions" ",-bugprone-reserved-identifier" ",-bugprone-suspicious-include" ",readability-*" ",-readability-avoid-const-params-in-decls" ",-readability-braces-around-statements" ",-readability-else-after-return" ",-readability-function-cognitive-complexity" ",-readability-function-size" ",-readability-identifier-length" ",-readability-isolate-declaration" ",-readability-magic-numbers" ",-readability-non-const-parameter" "${CLANG_TIDY_EXTRA_OPTS}") if(WARNINGS_AS_ERRORS) set(CMAKE_C_CLANG_TIDY "${CMAKE_C_CLANG_TIDY};--warnings-as-errors=*") else() set(CMAKE_C_CLANG_TIDY "${CMAKE_C_CLANG_TIDY};--quiet") endif(WARNINGS_AS_ERRORS) endif(LINTER) if(NOT EXISTS ${PG_INCLUDEDIR}/pg_config.h) message( FATAL_ERROR "Could not find pg_config.h in ${PG_INCLUDEDIR}. " "Make sure PG_PATH points to a valid PostgreSQL installation that includes development headers." ) endif() file(READ ${PG_INCLUDEDIR}/pg_config.h PG_CONFIG_H) string(REGEX MATCH "#define USE_ASSERT_CHECKING 1" PG_USE_ASSERT_CHECKING ${PG_CONFIG_H}) if(PG_USE_ASSERT_CHECKING AND NOT ASSERTIONS) message( STATUS "Assertion checks are OFF although enabled in PostgreSQL build (pg_config.h). " "The PostgreSQL setting for assertions will take precedence.") elseif(ASSERTIONS) message(STATUS "Assertion checks are ON") add_compile_definitions(USE_ASSERT_CHECKING=1) elseif(CMAKE_BUILD_TYPE MATCHES Debug) message( "Assertion checks are OFF in Debug build. Set -DASSERTIONS=ON to enable assertions." ) else() message(STATUS "Assertion checks are OFF") endif() # Check if PostgreSQL has OpenSSL enabled by inspecting pg_config.h. Right now, # a Postgres header will redefine an OpenSSL function if Postgres is not # installed --with-openssl, so in order for TimescaleDB to compile correctly # with OpenSSL, Postgres must also have OpenSSL enabled. check_symbol_exists(USE_OPENSSL ${PG_INCLUDEDIR}/pg_config.h PG_USE_OPENSSL) if(USE_OPENSSL AND (NOT PG_USE_OPENSSL)) message( FATAL_ERROR "PostgreSQL was built without OpenSSL support, which TimescaleDB needs for full compatibility. Please rebuild PostgreSQL using `--with-openssl` or if you want to continue without OpenSSL, re-run bootstrap with `-DUSE_OPENSSL=0`" ) endif(USE_OPENSSL AND (NOT PG_USE_OPENSSL)) # While we dont link directly against OpenSSL on non-Windows, doing this on # Windows causes linker errors. So on Windows we link directly against the # OpenSSL libraries. if(USE_OPENSSL AND MSVC) # Try to find a local OpenSSL installation find_package(OpenSSL) if(NOT OPENSSL_FOUND) message( FATAL_ERROR "TimescaleDB requires OpenSSL but it wasn't found. If you want to continue without OpenSSL, re-run bootstrap with `-DUSE_OPENSSL=0`" ) endif(NOT OPENSSL_FOUND) if(${OPENSSL_VERSION} VERSION_LESS "1.0") message(FATAL_ERROR "TimescaleDB requires OpenSSL version 1.0 or greater") endif() set(_libraries) foreach(_path ${OPENSSL_LIBRARIES}) if(EXISTS "${_path}") list(APPEND _libraries ${_path}) else() # check if a release version of the libraries are available if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND MSVC) get_filename_component(_dir ${_path} DIRECTORY) get_filename_component(_name ${_path} NAME_WE) string(REGEX REPLACE "[Dd]$" "" _fixed ${_name}) get_filename_component(_ext ${_path} EXT) set(_new_path "${_dir}/${_fixed}${_ext}") if(EXISTS "${_new_path}") list(APPEND _libraries ${_new_path}) endif() endif() endif() endforeach() set(OPENSSL_LIBRARIES ${_libraries}) foreach(_path ${OPENSSL_LIBRARIES}) message(STATUS "OpenSSL libraries: ${_path}") endforeach() message(STATUS "Using OpenSSL version ${OPENSSL_VERSION}") endif(USE_OPENSSL AND MSVC) if(CODECOVERAGE) message(STATUS "Code coverage is enabled.") # Note that --coverage is synonym for the necessary compiler and linker flags # for the given compiler. For example, with GCC, --coverage translates to # -fprofile-arcs -ftest-coverage when compiling and -lgcov when linking add_compile_options(--coverage -O0) add_link_options(--coverage) endif(CODECOVERAGE) # TAP test support option(TAP_CHECKS "Enable TAP test support" ON) if(TAP_CHECKS) find_package(Perl 5.8) if(PERL_FOUND) get_filename_component(PERL_BIN_PATH ${PERL_EXECUTABLE} DIRECTORY) find_program( PROVE prove HINTS ${PERL_BIN_PATH} PATHS "/usr/bin") if(NOT PROVE) message(STATUS "Not running TAP tests: 'prove' binary not found.") set(TAP_CHECKS OFF) endif() # Check for the IPC::Run module execute_process( COMMAND ${PERL_EXECUTABLE} -MIPC::Run -e "" ERROR_QUIET RESULT_VARIABLE PERL_MODULE_STATUS) if(PERL_MODULE_STATUS) message(STATUS "Not running TAP tests: IPC::Run Perl module not found.") set(TAP_CHECKS OFF) endif() else() message(STATUS "Not running TAP tests: Perl not found.") set(TAP_CHECKS OFF) endif() endif() if(UNIX) add_subdirectory(scripts) endif(UNIX) add_subdirectory(sql) add_subdirectory(test) add_subdirectory(src) if(NOT APACHE_ONLY) add_subdirectory(tsl) endif() add_custom_target(licensecheck COMMAND ${PROJECT_SOURCE_DIR}/scripts/check_license_all.sh) # This needs to be the last subdirectory so that other targets are already # defined if(CODECOVERAGE) add_subdirectory(coverage) endif() if(IS_DIRECTORY ${PROJECT_SOURCE_DIR}/.git) configure_file(${PROJECT_SOURCE_DIR}/scripts/githooks/commit_msg.py ${PROJECT_SOURCE_DIR}/.git/hooks/commit-msg COPYONLY) endif() ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/CONTRIBUTING.md������������������������������������������������������������������0000664�0000000�0000000�00000013333�15100345067�0016307�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Contributing to TimescaleDB We appreciate any help the community can provide to make TimescaleDB better! You can help in different ways: * Open an [issue](https://github.com/timescale/timescaledb/issues) with a bug report, build issue, feature request, suggestion, etc. * Fork this repository and submit a pull request For any particular improvement you want to make, it can be beneficial to begin discussion on the GitHub issues page. This is the best place to discuss your proposed improvement (and its implementation) with the core development team. Before we accept any code contributions, Timescale contributors need to sign the [Contributor License Agreement](https://cla-assistant.io/timescale/timescaledb) (CLA). By signing a CLA, we can ensure that the community is free and confident in its ability to use your contributions. ## Getting and building TimescaleDB Please follow our README for [instructions on installing from source](https://github.com/timescale/timescaledb/blob/main/README.md#option-3---from-source). ## Style guide Before submitting any contributions, please ensure that it adheres to our [Style Guide](docs/StyleGuide.md). ## Code review workflow * Sign the [Contributor License Agreement](https://cla-assistant.io/timescale/timescaledb) (CLA) if you're a new contributor. * Develop on your local branch: * Fork the repository and create a local feature branch to do work on, ideally on one thing at a time. Don't mix bug fixes with unrelated feature enhancements or stylistical changes. * Hack away. Add tests for non-trivial changes. * Run the [test suite](#testing) and make sure everything passes. * When committing, be sure to write good commit messages according to [these seven rules](https://chris.beams.io/posts/git-commit/#seven-rules). Doing `git commit` prints a message if any of the rules is violated. Stylistically, we use commit message titles in the imperative tense, e.g., `Add merge-append query optimization for time aggregate`. In the case of non-trivial changes, include a longer description in the commit message body explaining and detailing the changes. That is, a commit message should have a short title, followed by a empty line, and then followed by the longer description. * When committing, link which GitHub issue of [this repository](https://github.com/timescale/timescaledb/issues) is fixed or closed by the commit with a [linking keyword recognised by GitHub](https://docs.github.com/en/github/managing-your-work-on-github/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword). For example, if the commit fixes bug 123, add a line at the end of the commit message with `Fixes #123`, if the commit implements feature request 321, add a line at the end of the commit message `Closes #321`. This will be recognized by GitHub. It will close the corresponding issue and place a hyperlink under the number. * Push your changes to an upstream branch: * Make sure that each commit in the pull request will represent a logical change to the code, will compile, and will pass tests. * Make sure that the pull request message contains all important information from the commit messages including which issues are fixed and closed. If a pull request contains one commit only, then repeating the commit message is preferred, which is done automatically by GitHub when it creates the pull request. * Rebase your local feature branch against main (`git fetch origin`, then `git rebase origin/main`) to make sure you're submitting your changes on top of the newest version of our code. * When finalizing your PR (i.e., it has been approved for merging), aim for the fewest number of commits that make sense. That is, squash any "fix up" commits into the commit they fix rather than keep them separate. Each commit should represent a clean, logical change and include a descriptive commit message. * Push your commit to your upstream feature branch: `git push -u <yourfork> my-feature-branch` * Create and manage pull request: * [Create a pull request using GitHub](https://help.github.com/articles/creating-a-pull-request). If you know a core developer well suited to reviewing your pull request, either mention them (preferably by GitHub name) in the PR's body or [assign them as a reviewer](https://help.github.com/articles/assigning-issues-and-pull-requests-to-other-github-users/). * If you get a test failure in the CI, check them under [Github Actions](https://github.com/timescale/timescaledb/actions) * Address feedback by amending your commit(s). If your change contains multiple commits, address each piece of feedback by amending that commit to which the particular feedback is aimed. * The PR is marked as accepted when the reviewer thinks it's ready to be merged. Most new contributors aren't allowed to merge themselves; in that case, we'll do it for you. ## Testing Every non-trivial change to the code base should be accompanied by a relevant addition to or modification of the test suite. Please check that the full test suite (including your test additions or changes) passes successfully on your local machine **before you open a pull request**. If you are running locally: ```bash # Use Debug build mode for full battery of tests ./bootstrap -DCMAKE_BUILD_TYPE=Debug cd build && make make installcheck ``` All submitted pull requests are also automatically run against our test suite via [Github Actions](https://github.com/timescale/timescaledb/actions) (that link shows the latest build status of the repository). �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/LICENSE��������������������������������������������������������������������������0000664�0000000�0000000�00000001447�15100345067�0015066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Source code in this repository is variously licensed under the Apache License Version 2.0, an Apache compatible license, or the Timescale License. All source code should have information at the beginning of its respective file which specifies its licensing information. * Outside of the "tsl" directory, source code in a given file is licensed under the Apache License Version 2.0, unless otherwise noted (e.g., an Apache-compatible license). * Within the "tsl" folder, source code in a given file is licensed under the Timescale License, unless otherwise noted. When built, separate shared object files are generated for the Apache-licensed source code and the Timescale-licensed source code. The shared object binaries that contain `-tsl` in their name are licensed under the Timescale License. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/LICENSE-APACHE�������������������������������������������������������������������0000664�0000000�0000000�00000023676�15100345067�0016015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS ������������������������������������������������������������������timescaledb-2.23.0/NOTICE���������������������������������������������������������������������������0000664�0000000�0000000�00000004644�15100345067�0014767�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������TimescaleDB (TM) Copyright (c) 2017-2025 Timescale, Inc. All Rights Reserved. Copyright (c) 2016-2017 440 Labs, Inc. dba Timescale. All Rights Reserved. Source code in this repository is variously licensed under the Apache License Version 2.0, an Apache-compatible license, or the Timescale License. Please see LICENSE for more information. * For a copy of the Apache License Version 2.0, please see LICENSE-APACHE as included in this repository's top-level directory. * For a copy of the Timescale License, please see LICENSE-TIMESCALE as included in this repository's "tsl" directory. * For a copy of all other Apache-compatible licenses and notices, please see below. ======================================================================== NOTICES ======================================================================== Certain files in this code base have been modified and/or copied, either partially or wholely, from source code from the PostgreSQL database management system, which is licensed under the open-source PostgreSQL License with the following copyright information. The PostgreSQL License ======================================================================== PostgreSQL Database Management System (formerly known as Postgres, then as Postgres95) Portions Copyright (c) 1996-2025, The PostgreSQL Global Development Group Portions Copyright (c) 1994, The Regents of the University of California Permission to use, copy, modify, and distribute this software and its documentation for any purpose, without fee, and without a written agreement is hereby granted, provided that the above copyright notice and this paragraph and the following two paragraphs appear in all copies. IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. ======================================================================== ��������������������������������������������������������������������������������������������timescaledb-2.23.0/README.md������������������������������������������������������������������������0000664�0000000�0000000�00000024736�15100345067�0015346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<div align=center> <picture align=center> <source media="(prefers-color-scheme: dark)" srcset="https://assets.timescale.com/docs/images/tigerdata-gradient-white.svg"> <source media="(prefers-color-scheme: light)" srcset="https://assets.timescale.com/docs/images/tigerdata-gradient-black.svg"> <img alt="TigerData logo" > </picture> </div> <div align=center> <h3>TimescaleDB is a PostgreSQL extension for high-performance real-time analytics on time-series and event data</h3> [![Docs](https://img.shields.io/badge/Read_the_TigerData_docs-black?style=for-the-badge&logo=readthedocs&logoColor=white)](https://docs.tigerdata.com/) [![SLACK](https://img.shields.io/badge/Ask_the_TigerData_community-black?style=for-the-badge&logo=slack&logoColor=white)](https://timescaledb.slack.com/archives/C4GT3N90X) [![Try TimescaleDB for free](https://img.shields.io/badge/Try_Tiger_Cloud_for_free-black?style=for-the-badge&logo=timescale&logoColor=white)](https://console.cloud.timescale.com/signup) </div> ## Install TimescaleDB Install from a Docker container: 1. Run the TimescaleDB container: ```bash docker run -d --name timescaledb -p 5432:5432 -e POSTGRES_PASSWORD=password timescale/timescaledb-ha:pg17 ``` 1. Connect to a database: ```bash docker exec -it timescaledb psql -d "postgres://postgres:password@localhost/postgres" ``` See [other installation options](https://docs.tigerdata.com/self-hosted/latest/install/) or try [Tiger Cloud](https://docs.tigerdata.com/getting-started/latest/) for free. ## Create a hypertable TimescaleDB's hypercore is a hybrid row-columnar store that boosts analytical query performance on your time-series and event data, while reducing data size by more than 90%. This keeps your analytics operating at lightning speed and ensures low storage costs as you scale. Data is inserted in row format in the rowstore and converted to columnar format in the columnstore based on your configuration. ```sql -- Create a hypertable, with the columnstore from the hypercore engine -- "time" as partitioning column and a segment by on location CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ) WITH ( timescaledb.hypertable, timescaledb.partition_column='time', timescaledb.segmentby='location' ); ``` See more: - [About hypertables](https://docs.tigerdata.com/use-timescale/latest/hypertables/) - [API reference](https://docs.tigerdata.com/api/latest/hypertable/) - [About columnstore](https://docs.tigerdata.com/use-timescale/latest/compression/about-compression/) - [Enable columnstore manually](https://docs.tigerdata.com/use-timescale/latest/compression/manual-compression/) - [API reference](https://docs.tigerdata.com/api/latest/compression/) ## Insert and query data Insert and query data in a hypertable via regular SQL commands. For example: - Insert data into a hypertable named `conditions`: ```sql INSERT INTO conditions VALUES (NOW(), 'office', 70.0, 50.0), (NOW(), 'basement', 66.5, 60.0), (NOW(), 'garage', 77.0, 65.2); ``` - Return the number of entries written to the table conditions in the last 12 hours: ```sql SELECT COUNT(*) FROM conditions WHERE time > NOW() - INTERVAL '12 hours'; ``` See more: - [Query data](https://docs.tigerdata.com/use-timescale/latest/query-data/) - [Write data](https://docs.tigerdata.com/use-timescale/latest/write-data/) ## Create time buckets Time buckets enable you to aggregate data in hypertables by time interval and calculate summary values. For example, calculate the average daily temperature in a table named `conditions`. The table has a `time` and `temperature` columns: ```sql SELECT time_bucket('1 day', time) AS bucket, AVG(temperature) AS avg_temp FROM conditions GROUP BY bucket ORDER BY bucket ASC; ``` See more: - [About time buckets](https://docs.tigerdata.com/use-timescale/latest/time-buckets/about-time-buckets/) - [API reference](https://docs.tigerdata.com/api/latest/hyperfunctions/time_bucket/) - [All TimescaleDB features](https://docs.tigerdata.com/use-timescale/latest/) - [Tutorials](https://docs.tigerdata.com/tutorials/latest/) ## Create continuous aggregates Continuous aggregates make real-time analytics run faster on very large datasets. They continuously and incrementally refresh a query in the background, so that when you run such query, only the data that has changed needs to be computed, not the entire dataset. This is what makes them different from regular PostgreSQL [materialized views](https://www.postgresql.org/docs/current/rules-materializedviews.html), which cannot be incrementally materialized and have to be rebuilt from scratch every time you want to refresh it. For example, create a continuous aggregate view for daily weather data in two simple steps: 1. Create a materialized view: ```sql CREATE MATERIALIZED VIEW conditions_summary_daily WITH (timescaledb.continuous) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature), MAX(temperature), MIN(temperature) FROM conditions GROUP BY location, bucket; ``` 1. Create a policy to refresh the view every hour: ```sql SELECT add_continuous_aggregate_policy( 'conditions_summary_daily', start_offset => INTERVAL '1 month', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour' ); ``` See more: - [About continuous aggregates](https://docs.tigerdata.com/use-timescale/latest/continuous-aggregates/) - [API reference](https://docs.tigerdata.com/api/latest/continuous-aggregates/create_materialized_view/) ## Want TimescaleDB hosted and managed for you? Try Tiger Cloud [Tiger Cloud](https://docs.tigerdata.com/getting-started/latest/) is the modern PostgreSQL data platform for all your applications. It enhances PostgreSQL to handle time series, events, real-time analytics, and vector search—all in a single database alongside transactional workloads. You get one system that handles live data ingestion, late and out-of-order updates, and low latency queries, with the performance, reliability, and scalability your app needs. Ideal for IoT, crypto, finance, SaaS, and a myriad other domains, Tiger Cloud allows you to build data-heavy, mission-critical apps while retaining the familiarity and reliability of PostgreSQL. See [our whitepaper](https://docs.tigerdata.com/about/latest/whitepaper/) for a deep dive into Tiger Cloud's architecture and how it meets the needs of even the most demanding applications. A Tiger Cloud service is a single optimized 100% PostgreSQL database instance that you use as is, or extend with capabilities specific to your business needs. The available capabilities are: - **Time-series and analytics**: PostgreSQL with TimescaleDB. The PostgreSQL you know and love, supercharged with functionality for storing and querying time-series data at scale for real-time analytics and other use cases. Get faster time-based queries with hypertables, continuous aggregates, and columnar storage. Save on storage with native compression, data retention policies, and bottomless data tiering to Amazon S3. - **AI and vector**: PostgreSQL with vector extensions. Use PostgreSQL as a vector database with purpose built extensions for building AI applications from start to scale. Get fast and accurate similarity search with the pgvector and pgvectorscale extensions. Create vector embeddings and perform LLM reasoning on your data with the pgai extension. - **PostgreSQL**: the trusted industry-standard RDBMS. Ideal for applications requiring strong data consistency, complex relationships, and advanced querying capabilities. Get ACID compliance, extensive SQL support, JSON handling, and extensibility through custom functions, data types, and extensions. All services include all the cloud tooling you'd expect for production use: [automatic backups](https://docs.tigerdata.com/use-timescale/latest/backup-restore/backup-restore-cloud/), [high availability](https://docs.tigerdata.com/use-timescale/latest/ha-replicas/), [read replicas](https://docs.tigerdata.com/use-timescale/latest/ha-replicas/read-scaling/), [data forking](https://docs.tigerdata.com/use-timescale/latest/services/service-management/#fork-a-service), [connection pooling](https://docs.tigerdata.com/use-timescale/latest/services/connection-pooling/), [tiered storage](https://docs.tigerdata.com/use-timescale/latest/data-tiering/), [usage-based storage](https://docs.tigerdata.com/about/latest/pricing-and-account-management/), and much more. ## Check build status |Linux/macOS|Linux i386|Windows|Coverity|Code Coverage|OpenSSF| |:---:|:---:|:---:|:---:|:---:|:---:| |[![Build Status Linux/macOS](https://github.com/timescale/timescaledb/actions/workflows/linux-build-and-test.yaml/badge.svg?branch=main&event=schedule)](https://github.com/timescale/timescaledb/actions/workflows/linux-build-and-test.yaml?query=workflow%3ARegression+branch%3Amain+event%3Aschedule)|[![Build Status Linux i386](https://github.com/timescale/timescaledb/actions/workflows/linux-32bit-build-and-test.yaml/badge.svg?branch=main&event=schedule)](https://github.com/timescale/timescaledb/actions/workflows/linux-32bit-build-and-test.yaml?query=workflow%3ARegression+branch%3Amain+event%3Aschedule)|[![Windows build status](https://github.com/timescale/timescaledb/actions/workflows/windows-build-and-test.yaml/badge.svg?branch=main&event=schedule)](https://github.com/timescale/timescaledb/actions/workflows/windows-build-and-test.yaml?query=workflow%3ARegression+branch%3Amain+event%3Aschedule)|[![Coverity Scan Build Status](https://scan.coverity.com/projects/timescale-timescaledb/badge.svg)](https://scan.coverity.com/projects/timescale-timescaledb)|[![Code Coverage](https://codecov.io/gh/timescale/timescaledb/branch/main/graphs/badge.svg?branch=main)](https://codecov.io/gh/timescale/timescaledb)|[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/8012/badge)](https://www.bestpractices.dev/projects/8012)| ## Get involved We welcome contributions to TimescaleDB! See [Contributing](https://github.com/timescale/timescaledb/blob/main/CONTRIBUTING.md) and [Code style guide](https://github.com/timescale/timescaledb/blob/main/docs/StyleGuide.md) for details. ## Learn about TigerData TigerData is the fastest PostgreSQL for transactional, analytical and agentic workloads. To learn more about the company and its products, visit [tigerdata.com](https://www.tigerdata.com). ����������������������������������timescaledb-2.23.0/SECURITY.md����������������������������������������������������������������������0000664�0000000�0000000�00000002723�15100345067�0015650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Security Policy We aim to keep TimescaleDB safe for everyone. Publicly disclosing security bugs in a public forum can put everyone in the Timescale community at risk, however. Therefore, we ask that people follow the below instructions to report security vulnerability. The entire Timescale community thanks you! ## Supported Versions The supported version is always the latest major release available in our repository. We also release regular minor versions with fixes and corrections alongside some new features as well as patchfix releases, that you should keep upgrading to. Vulnerability fixes are made available as part of these patchfix releases and you can read our list of [Security Advisories](https://github.com/timescale/timescaledb/security/advisories?state=published). You can also take a look at our [Support Policy](https://www.timescale.com/legal/support-policy). ## Reporting a Vulnerability If you find a vulnerability in our software, please email the Timescale Security Team at security@timescale.com. Please note that the e-mail address should only be used for reporting undisclosed security vulnerabilities in Timescale products and services. Regular bug reports should be submitted as GitHub issues, while other _questions_ around security, compliance, or functionality can be made either through our support (for customers) or community channels (e.g., [Timescale Slack](https://slack.timescale.com/), [Forums](https://www.timescale.com/forums), etc.) ���������������������������������������������timescaledb-2.23.0/bootstrap������������������������������������������������������������������������0000775�0000000�0000000�00000002140�15100345067�0016013�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # This bootstrap scripts set up the build environment for TimescaleDB # Any flags will be passed on to CMake, e.g., # ./bootstrap -DCMAKE_BUILD_TYPE="Debug" ## Check to make cmake is installed if ! command -v cmake >/dev/null 2>&1; then echo "cmake is required to build TimescaleDB. Please install via your system's preferred method." exit 1 fi BUILD_DIR=${BUILD_DIR:-./build} BUILD_FORCE_REMOVE=${BUILD_FORCE_REMOVE:-false} SRC_DIR=$(dirname $0) if [[ ! ${SRC_DIR} == /* ]]; then SRC_DIR=$(pwd)/${SRC_DIR} fi if [ ${BUILD_FORCE_REMOVE} == "true" ]; then rm -fr ${BUILD_DIR} elif [ -d ${BUILD_DIR} ]; then echo "Build system already initialized in ${BUILD_DIR}" read -r -n 1 -p "Do you want to remove it (this is IMMEDIATE and PERMANENT), y/n? " choice echo "" if [ $choice == "y" ]; then rm -fr ${BUILD_DIR} else exit fi fi set -e set -u mkdir -p ${BUILD_DIR} && \ cd ${BUILD_DIR} && \ cmake ${SRC_DIR} "$@" echo "TimescaleDB build system initialized in ${BUILD_DIR}. To compile, do:" echo -e "\033[1mcd ${BUILD_DIR} && make\033[0m" ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/bootstrap.bat��������������������������������������������������������������������0000664�0000000�0000000�00000001406�15100345067�0016561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������@echo off :: This bootstrap scripts set up the build environment for TimescaleDB :: Any flags will be passed on to CMake, e.g., :: ./bootstrap.bat -DCMAKE_BUILD_TYPE="Debug" :: Get source directory to build from set ORIG=%0 for %%F in (%ORIG%) do set SRC_DIR=%%~dpF SET BUILD_DIR=./build IF EXIST "%BUILD_DIR%" ( setlocal EnableDelayedExpansion ECHO Build system already initialized in %BUILD_DIR% SET /P resp="Do you want to remove it (this is IMMEDIATE and PERMANENT), y/n? " IF "!resp!" == "y" ( rd /s /q "%BUILD_DIR%" ) ELSE ( ECHO Exiting EXIT ) ) mkdir "%BUILD_DIR%" cd "%BUILD_DIR%" cmake %SRC_DIR% -A x64 %* ECHO --- ECHO TimescaleDB build system initialized in %BUILD_DIR%. ECHO To compile, do: ECHO cmake --build %BUILD_DIR% --config Release ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/cmake/���������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015133�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/cmake/GenerateScripts.cmake������������������������������������������������������0000664�0000000�0000000�00000015532�15100345067�0021245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Functions and macros to generate upgrade and downgrade scripts # concatenate_files(<output> <file> ...) # # Concatenate a list of files into <output> function(concatenate_files OUTPUT_FILE FIRST_FILE) file(READ ${FIRST_FILE} _contents) file(WRITE ${OUTPUT_FILE} "${_contents}") foreach(_file ${ARGN}) file(READ ${_file} _contents) file(APPEND ${OUTPUT_FILE} "${_contents}") endforeach() endfunction() # generate_script(...) # # Generate a script file and install it into the script directory. # # VERSION <version> # # Version to use for shared libraryx. # # SCRIPT <file> # # File name for script file. # # OUTPUT_DIRECTORY <dir> # # Directory for where script file should be written. Defaults to # CMAKE_CURRENT_BINARY_DIR. # # FILES <file> ... # # List of files to include, in order, in the script file. function(generate_script) set(options) set(oneValueArgs VERSION SCRIPT OUTPUT_DIRECTORY) set(multiValueArgs FILES) cmake_parse_arguments(_generate "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) if(NOT _generate_OUTPUT_DIRECTORY) set(_generate_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) endif() # Set the necessary variables, generate the real files, and append the output # to the final update script. Ideally, the template files should have a '.in' # suffix so that we can keep the template file and the final file available # for debugging, but for some reason it was decided to not use the '.in' # suffix for template files so now we're stuck with it. set(MODULE_PATHNAME "$libdir/timescaledb-${_generate_VERSION}") set(LOADER_PATHNAME "$libdir/timescaledb") # Process all files. They are template files and should end with '.in' but for # some reason they do not, so we append '.gen' instead to indicate generated # files. set(_result_files) foreach(_file ${_generate_FILES}) configure_file(${_file} ${_file}.gen @ONLY) list(APPEND _result_files ${_file}.gen) endforeach() # Concatenate the real files into the update file. message(STATUS "Generating script ${_generate_SCRIPT}") concatenate_files(${_generate_OUTPUT_DIRECTORY}/${_generate_SCRIPT} ${_result_files}) install(FILES ${_generate_OUTPUT_DIRECTORY}/${_generate_SCRIPT} DESTINATION "${PG_SHAREDIR}/extension") endfunction() # generate_downgrade_script(<options>) # # Create a downgrade script from a source version to a target version. To figure # out what files are necessary, the ScriptFiles.cmake manifest is read from the # target version. If that file does not exist in the target version, the # manifest in the current version is used, but it is assumed that files are only # added. This situation only occur in the first version where we start to # generate downgrade scripts and in this case files were only added, so we can # safely ignore them. # # SOURCE_VERSION <version> # # Version to generate downgrade script from. # # TARGET_VERSION <version> # # Version to generate downgrade script to. # # OUTPUT_DIRECTORY <dir> # # Output directory for script file. Defaults to CMAKE_CURRENT_BINARY_DIR. # # INPUT_DIRECTORY <dir> # # Input directory for downgrade files. Defaults to CMAKE_CURRENT_SOURCE_DIR. # # FILES <file> ... # # Files to include, in order, when generating the downgrade script. # # The downgrade script is generated by creating a new file of the format # "timescaledb--<current>--<version>.sql" consisting of the sequence of files: # # 1. Generated prolog from the target version # 2. Generated downgrade files from the source version # 3. Generated epilog from the target version # # The files provided are assumed to be configure templates and configure_files # will be run on them with the following variables set: # # LOADER_PATHNAME: Pathname to loader shared library. This is the same as in the # update. # # MODULE_PATHNAME: Pathname to timescale extension of the version being # downgraded to. This can be used to load "old" functions from the correct # library. function(generate_downgrade_script) set(options) set(oneValueArgs SOURCE_VERSION TARGET_VERSION OUTPUT_DIRECTORY INPUT_DIRECTORY FILES) cmake_parse_arguments(_downgrade "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) if(NOT _downgrade_OUTPUT_DIRECTORY) set(_downgrade_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) endif() if(NOT _downgrade_INPUT_DIRECTORY) set(_downgrade_INPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) endif() foreach(_downgrade_file ${_downgrade_FILES}) if(NOT EXISTS ${_downgrade_INPUT_DIRECTORY}/${_downgrade_file}) message(FATAL_ERROR "No downgrade file ${_downgrade_file} found!") endif() endforeach() # Fetch manifest with list of files for the prolog and epilog from the target # version. git_versioned_get(VERSION ${_downgrade_TARGET_VERSION} FILES ${CMAKE_SOURCE_DIR}/cmake/ScriptFiles.cmake) # This will include the variables in this scope, but not in the parent scope # so we can read them locally without affecting the parent scope. include( ${CMAKE_BINARY_DIR}/v${_downgrade_TARGET_VERSION}/cmake/ScriptFiles.cmake) set(_downgrade_PRE_FILES ${PRE_DOWNGRADE_FILES}) set(_downgrade_POST_FILES "${PRE_INSTALL_FUNCTION_FILES};${SOURCE_FILES}" ${SET_POST_UPDATE_STAGE} ${POST_UPDATE_FILES} ${UNSET_UPDATE_STAGE}) # Fetch epilog from target version. git_versioned_get( VERSION ${_downgrade_TARGET_VERSION} FILES ${_downgrade_POST_FILES} RESULT_FILES _epilog_files IGNORE_ERRORS) if(_downgrade_TARGET_VERSION VERSION_EQUAL 2.18.0) list(TRANSFORM _epilog_files REPLACE "^.*/hypercore.sql" "${CMAKE_CURRENT_SOURCE_DIR}/pre_install/tam.functions.sql") endif() foreach(_downgrade_file ${_downgrade_PRE_FILES}) get_filename_component(_downgrade_filename ${_downgrade_file} NAME) configure_file(${_downgrade_file} ${_downgrade_INPUT_DIRECTORY}/${_downgrade_filename} COPYONLY) list(APPEND _files ${_downgrade_INPUT_DIRECTORY}/${_downgrade_filename}) endforeach() foreach(_downgrade_file ${_downgrade_FILES}) list(APPEND _files ${_downgrade_INPUT_DIRECTORY}/${_downgrade_file}) endforeach() list(APPEND _files ${_epilog_files}) # Save the current PROJECT_VERSION_MOD set(SAVED_PROJECT_VERSION_MOD ${PROJECT_VERSION_MOD}) # To use PROJECT_VERSION_MOD variable as a target version in downgrade scripts # we should set it as the PREVIOUS_VERSION because it means the target version # when executing the downgrade scripts set(PROJECT_VERSION_MOD ${PREVIOUS_VERSION}) generate_script( VERSION ${_downgrade_TARGET_VERSION} SCRIPT timescaledb--${_downgrade_SOURCE_VERSION}--${_downgrade_TARGET_VERSION}.sql OUTPUT_DIRECTORY ${_downgrade_OUTPUT_DIRECTORY} FILES ${_files}) # Restore the original PROJECT_VERSION_MOD set(PROJECT_VERSION_MOD ${SAVED_PROJECT_VERSION_MOD}) endfunction() ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/cmake/GenerateTestSchedule.cmake�������������������������������������������������0000664�0000000�0000000�00000003703�15100345067�0022207�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# generate_test_schedul(<output file> ...) # # A test schedule is generated for the files in TEST_FILES. The test schedule # groups the tests into groups of size GROUP_SIZE, with the exceptions of any # tests mentioned in the list SOLO, which will be in their own test group. # # TEST_FILES <file> ... # # Test files to generate a test schedule for. # # SOLO <test> ... # # Names of tests that should be run as solo tests. Note that these are test # names, not file names. # # GROUP_SIZE # # Size of each group in the test schedule. function(generate_test_schedule OUTPUT_FILE) set(options) set(oneValueArgs GROUP_SIZE) set(multiValueArgs TEST_FILES SOLO) cmake_parse_arguments(_generate "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) # Depending on the configuration we might end up # with an empty schedule here. On older cmake versions < 3.14 # trying to sort an empty list will produce an error, so # we check for empty list here. if(_generate_TEST_FILES) list(SORT _generate_TEST_FILES) endif() file(REMOVE ${OUTPUT_FILE}) # We put the solo tests in the test file first. Note that we do not generate # groups for solo tests that are not in the list of test files. foreach(_solo ${_generate_SOLO}) if("${_solo}.sql" IN_LIST _generate_TEST_FILES) file(APPEND ${OUTPUT_FILE} "test: ${_solo}\n") endif() endforeach() # Generate groups of tests set(_members 0) foreach(_file ${_generate_TEST_FILES}) string(REGEX REPLACE "(.+)\.sql" "\\1" _test ${_file}) if(NOT (_test IN_LIST _generate_SOLO)) if(_members EQUAL 0) file(APPEND ${OUTPUT_FILE} "test: ") endif() file(APPEND ${OUTPUT_FILE} "${_test} ") if(_members LESS _generate_GROUP_SIZE) math(EXPR _members "${_members} + 1") else() set(_members 0) file(APPEND ${OUTPUT_FILE} "\n") endif() endif() endforeach() file(APPEND ${OUTPUT_FILE} "\n") endfunction() �������������������������������������������������������������timescaledb-2.23.0/cmake/GitCommands.cmake����������������������������������������������������������0000664�0000000�0000000�00000006033�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Git helper functions and macros # git_get_versioned(VERSION <version> FILES <path> ...) # # Get files by name relative to the current source directory but read it from # branch VERSION. Note that the version referenced has to exists as a branch, # otherwise you get an error. # # VERSION <version> # # Version to read files from. Any object name is accepted as given in # gitrevision(7), but typically you should use a tag name. # # FILES <path> ... # # Paths to extract. These are relative or absolute paths to files to extract. If # relative, the path names are resolved relative the current source directory. # # RESULT_FILES <var> # # Variable for the list of the full paths of the retrieved files. # # IGNORE_ERRORS # # Ignore errors when fetching file from previous version. This is currently used # to ignore missing files, but we should probably be more selective in the # following versions. function(git_versioned_get) set(options IGNORE_ERRORS) set(oneValueArgs VERSION RESULT_FILES) set(multiValueArgs FILES) cmake_parse_arguments(_git_get "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) execute_process( COMMAND git show-ref --verify --quiet refs/tags/${_git_get_VERSION} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE _version_missing) if(_version_missing) message( FATAL_ERROR "Version ${_git_get_VERSION} does not exist in repository.") endif() set(_result_files) foreach(_file ${_git_get_FILES}) # Build full path, if the path is not absolute. if(IS_ABSOLUTE ${_file}) set(_path "${_file}") else() set(_path "${CMAKE_CURRENT_SOURCE_DIR}/${_file}") endif() # Remove root source directory to get path relative to source root. This is # necessary for git-show to work correctly and then use that to generate a # full path for the version. (Yeah, we could use ./ before, but this is # less clear in the log what file is actually fetched.) string(REPLACE ${CMAKE_SOURCE_DIR}/ "" _relpath ${_path}) set(_fullpath "${CMAKE_BINARY_DIR}/v${_git_get_VERSION}/${_relpath}") get_filename_component(_dirname ${_fullpath} DIRECTORY) file(MAKE_DIRECTORY ${_dirname}) # We place the output file next to the final file to avoid cross-device # renames but give it a different name since it is created even if the # command fails. execute_process( COMMAND ${GIT_EXECUTABLE} show ${_git_get_VERSION}:${_relpath} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_FILE "${_fullpath}.part" RESULT_VARIABLE _error ERROR_VARIABLE _message) if(_error) if(_git_get_IGNORE_ERRORS) string(STRIP "${_message}" _stripped_message) message(STATUS "${_stripped_message} (ignored).") else() message(FATAL_ERROR "${_message}") endif() else() file(RENAME "${_fullpath}.part" "${_fullpath}") list(APPEND _result_files "${_fullpath}") endif() endforeach() set(${_git_get_RESULT_FILES} ${_result_files} PARENT_SCOPE) endfunction() �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/cmake/ScriptFiles.cmake����������������������������������������������������������0000664�0000000�0000000�00000005520�15100345067�0020366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# File defining all variables used to generate script files. # # This is needed for the downgrade script since files can be added and removed # and it is necessary to get a list of all files available for a specific # version. # # We only care about files that are part of generating the prolog or epilog for # the update scripts, to the actual versioned files are not necessary to put # here. # Source files that define the schemas and tables for our metadata set(PRE_INSTALL_SOURCE_FILES pre_install/schemas.sql # Must be first pre_install/types.pre.sql pre_install/types.functions.sql pre_install/types.post.sql # Must be before tables.sql pre_install/tables.sql pre_install/cache.sql pre_install/insert_data.sql) # Source files that define functions and need to be rerun in update set(PRE_INSTALL_FUNCTION_FILES pre_install/types.functions.sql ) # The rest of the source files defining mostly functions set(SOURCE_FILES hypertable.sql chunk.sql util_time.sql util_internal_table_ddl.sql chunk_constraint.sql partitioning.sql ddl_api.sql ddl_triggers.sql bookend.sql time_bucket.sql time_bucket_ng.sql version.sql size_utils.sql histogram.sql bgw_scheduler.sql metadata.sql uuidv7.sql views.sql views_experimental.sql gapfill.sql maintenance_utils.sql partialize_finalize.sql restoring.sql job_api.sql policy_api.sql policy_internal.sql cagg_api.sql cagg_utils.sql cagg_migrate.sql job_stat_history_log_retention.sql osm_api.sql compression_defaults.sql sparse_index.sql) if(ENABLE_DEBUG_UTILS AND CMAKE_BUILD_TYPE MATCHES Debug) list(APPEND SOURCE_FILES debug_build_utils.sql) endif() if(ENABLE_DEBUG_UTILS) list(APPEND SOURCE_FILES debug_utils.sql) endif() if(USE_TELEMETRY) list(APPEND SOURCE_FILES with_telemetry.sql) else() list(APPEND SOURCE_FILES without_telemetry.sql) endif() # Compatibility layer for timescaledb 2.12 for internal functions that got moved into _timescaledb_functions list(APPEND SOURCE_FILES compat.sql) # These files need to be last in the scripts. list(APPEND SOURCE_FILES bgw_startup.sql) if(APACHE_ONLY) list(APPEND SOURCE_FILES comment_apache.sql) else() list(APPEND SOURCE_FILES comment_tsl.sql) endif() # These files should be prepended to update scripts so that they are executed # before anything else during updates set(PRE_UPDATE_FILES updates/pre-version-change.sql updates/pre-update.sql) set(PRE_DOWNGRADE_FILES updates/pre-version-change.sql) # The POST_UPDATE_FILES should be executed as the last part of the update # script. sets state for executing POST_UPDATE_FILES during ALTER EXTENSION set(SET_POST_UPDATE_STAGE updates/set_post_update_stage.sql) set(UNSET_UPDATE_STAGE updates/unset_update_stage.sql) set(POST_UPDATE_FILES updates/post-update.sql) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016153�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/README.md�������������������������������������������������������������0000664�0000000�0000000�00000002054�15100345067�0017433�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������This directory contains scripts to check the codebase for defective programming patterns, eg use after free or not freeing resources. Coccinelle is a static code analysis program. It uses a semantic patch language which resembles unified diff output. The semantic patches may inline python or ocaml code for more advanced use cases. A coccinelle patch file consists of multiple blocks. Example block header: ``` @ name @ Expression var1; Expression var2; @@ ``` The block header may contain variable definitions. It may also contain required matches or non-matches in previous blocks. Examples for blocks with required previous matches: ``` @ b2 depends on name @ @@ @ b3 depends on name && !b2 @ @@ ``` Variables inside a block can also reference matches from previous blocks. ``` @ b2 depends on name @ Expression name.var1; @@ ``` var1 inside this block will be the match from the `name` block. - https://github.com/coccinelle/coccinelle - https://coccinelle.gitlabpages.inria.fr/website/ - https://coccinelle.gitlabpages.inria.fr/website/docs/main_grammar.html ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/attrnumbergetattroffset.cocci�����������������������������������������0000664�0000000�0000000�00000001306�15100345067�0024142�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// // find missing `AttrNumberGetAttrOffset` usage // // Postgres has `AttrNumberGetAttrOffset()` macro to proper access Datum array members // (see https://github.com/postgres/postgres/blob/master/src/include/access/attnum.h). // // For example: // `datum[attrno - 1]` should be `datum[AttrNumberGetAttrOffset(attrno)]` // @@ typedef Datum; expression attrno; Datum [] datum; @@ - datum[attrno - 1] + /* use AttrNumberGetAttrOffset() for accessing Datum array members */ + datum[AttrNumberGetAttrOffset(attrno)] @@ typedef bool; expression attrno; bool [] isnull; @@ - isnull[attrno - 1] + /* use AttrNumberGetAttrOffset() for accessing bool array members */ + isnull[AttrNumberGetAttrOffset(attrno)] ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/bms_result.cocci������������������������������������������������������0000664�0000000�0000000�00000003030�15100345067�0021330�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// Some bitmap set operations recycle one of the input parameters or return // a reference to a new bitmap set. The following set of rules checks that the // returned reference is not discarded. @rule_1@ expression E1, E2; @@ + /* Result of bms_add_member has to be used */ + E1 = bms_add_member(E1, E2); - bms_add_member(E1, E2); @rule_2@ expression E1, E2; @@ + /* Result of bms_del_member has to be used */ + E1 = bms_del_member(E1, E2); - bms_del_member(E1, E2); @rule_3@ expression E1, E2; @@ + /* Result of bms_add_members has to be used */ + E1 = bms_add_members(E1, E2); - bms_add_members(E1, E2); @rule_4@ expression E1, E2, E3; @@ + /* Result of bms_add_range has to be used */ + E1 = bms_add_range(E1, E2, E3); - bms_add_range(E1, E2, E3); @rule_5@ expression E1, E2; @@ + /* Result of bms_int_members has to be used */ + E1 = bms_int_members(E1, E2); - bms_int_members(E1, E2); @rule_6@ expression E1, E2; @@ + /* Result of bms_del_members has to be used */ + E1 = bms_del_members(E1, E2); - bms_del_members(E1, E2); @rule_7@ expression E1, E2; @@ + /* Result of bms_join has to be used */ + E1 = bms_join(E1, E2); - bms_join(E1, E2); @rule_8@ expression E1, E2; @@ + /* Result of bms_union has to be used */ + E1 = bms_union(E1, E2); - bms_union(E1, E2); @rule_9@ expression E1, E2; @@ + /* Result of bms_intersect has to be used */ + E1 = bms_intersect(E1, E2); - bms_intersect(E1, E2); @rule_10@ expression E1, E2; @@ + /* Result of bms_difference has to be used */ + E1 = bms_difference(E1, E2); - bms_difference(E1, E2); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/hash_create.cocci�����������������������������������������������������0000664�0000000�0000000�00000001633�15100345067�0021426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// find hash_create calls without HASH_CONTEXT flag // // hash_create calls without HASH_CONTEXT flag will create the hash table in // TopMemoryContext which can introduce memory leaks if not intended. We want // to be explicit about the memory context our hash tables live in so we enforce // usage of the flag. @ hash_create @ position p; @@ hash_create@p(...) @safelist@ expression arg1, arg2, arg3; expression w1, w2; position hash_create.p; @@ ( hash_create@p(arg1,arg2,arg3, w1 | HASH_CONTEXT | w2) | hash_create@p(arg1,arg2,arg3, w1 | HASH_CONTEXT) | hash_create@p(arg1,arg2,arg3, HASH_CONTEXT | w2 ) ) @safelist2@ expression res; expression arg1, arg2, arg3; expression flags; position hash_create.p; @@ Assert(flags & HASH_CONTEXT); res = hash_create@p(arg1,arg2,arg3, flags); @ depends on !safelist && !safelist2 @ position hash_create.p; @@ + /* hash_create without HASH_CONTEXT flag */ hash_create@p(...) �����������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/heap_freetuple.cocci��������������������������������������������������0000664�0000000�0000000�00000000733�15100345067�0022150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// find heap_form_tuple with missing heap_freetuple calls @ heap_form_tuple @ identifier tuple; position p; @@ tuple@p = heap_form_tuple(...); @safelist@ expression tuple; position heap_form_tuple.p; @@ tuple@p = heap_form_tuple(...); ... ( return tuple; | heap_freetuple(tuple) | HeapTupleGetDatum(tuple) ) @depends on !safelist@ expression tuple; position heap_form_tuple.p; @@ + /* heap_form_tuple with missing heap_freetuple call */ tuple@p = heap_form_tuple(...); �������������������������������������timescaledb-2.23.0/coccinelle/hypertable_cache.cocci������������������������������������������������0000664�0000000�0000000�00000002276�15100345067�0022446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// find hypertable uses after cache release @ cache_get @ expression cache, ht, htid, relid, rv, schema, table, flags; position p; @@ ( ht = ts_hypertable_cache_get_entry(cache,...); | ht = ts_hypertable_cache_get_cache_and_entry(relid, flags, &cache); | ht = ts_hypertable_cache_get_entry_rv(cache, rv); | ht = ts_hypertable_cache_get_entry_with_table(cache, relid, schema, table, flags); | ht = ts_hypertable_cache_get_entry_by_id(cache, htid); ) ... ts_cache_release(cache)@p; ... ht @ safelist1 depends on cache_get @ expression cache_get.cache; position cache_get.p; @@ ts_cache_release(cache)@p; ( PG_RETURN_DATUM | aclcheck_error(...) | ereport(ERROR,...) ) // // if variable gets reassigned it's not use after free // @ safelist2 depends on cache_get && !safelist1 @ expression cache_get.cache; expression cache_get.ht; position cache_get.p; @@ ts_cache_release(cache)@p; ... ( ht = ts_hypertable_cache_get_entry(...); | ht = ts_hypertable_cache_get_cache_and_entry(...); ) // print context of matched use after free @ match depends on cache_get && !safelist1 && !safelist2 @ expression cache_get.cache; expression cache_get.ht; position cache_get.p; position m; @@ * ts_cache_release(cache)@p; ... * ht@m ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/hypertable_cache2.cocci�����������������������������������������������0000664�0000000�0000000�00000002501�15100345067�0022517�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// find use after free bugs due to premature cache releases // this will find bugs of the following form: // ht = ts_hypertable_cache_get_entry(cache) // dim = hyperspace_get_open_dimension(ht->space, ...) // ts_cache_release(cache) // usage of dim after cache release @ cache_get @ expression cache, htid, relid, rv, schema, table, flags; identifier dim, ht; position p; @@ ( ht = ts_hypertable_cache_get_entry(cache,...) | ht = ts_hypertable_cache_get_cache_and_entry(relid, flags, &cache) | ht = ts_hypertable_cache_get_entry_rv(cache, rv) | ht = ts_hypertable_cache_get_entry_with_table(cache, relid, schema, table, flags) | ht = ts_hypertable_cache_get_entry_by_id(cache, htid) ) ... ( dim = hyperspace_get_open_dimension(ht->space, ...) | dim = ts_hyperspace_get_dimension(ht->space, ...) | dim = ts_hyperspace_get_dimension_by_name(ht->space, ...) | dim = ts_hyperspace_get_mutable_dimension_by_name(ht->space, ...) | dim = ts_hyperspace_get_dimension_by_id(ht->space, ...) ) ... ts_cache_release(cache)@p; ... dim @ m1 depends on cache_get @ expression cache_get.cache; position cache_get.p; @@ ts_cache_release(cache)@p; PG_RETURN_DATUM @ m2 depends on cache_get && !m1 @ expression cache_get.cache; identifier cache_get.dim; position cache_get.p; @@ - ts_cache_release(cache)@p; ... + /* dim used after calling ts_cache_release */ dim �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/mcxt.cocci������������������������������������������������������������0000664�0000000�0000000�00000000773�15100345067�0020137�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// find MemoryContextSwitchTo missing a context switch back @ MemoryContextSwitch @ local idexpression oldctx; position p; @@ oldctx@p = MemoryContextSwitchTo(...); @safelist@ local idexpression MemoryContextSwitch.oldctx; position MemoryContextSwitch.p; @@ oldctx@p = MemoryContextSwitchTo(...); ... MemoryContextSwitchTo(oldctx) @depends on !safelist@ expression oldctx; position MemoryContextSwitch.p; @@ + /* MemoryContextSwitch missing context switch back */ oldctx@p = MemoryContextSwitchTo(...); �����timescaledb-2.23.0/coccinelle/namedata.cocci��������������������������������������������������������0000664�0000000�0000000�00000002335�15100345067�0020732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// NameData is a fixed-size type of 64 bytes. Using strlcpy to copy data into a // NameData struct can cause problems because any data that follows the initial // null-terminated string will also be part of the data. @rule_var_decl_struct@ symbol NAMEDATALEN; identifier I1, I2; @@ struct I1 { ... - char I2[NAMEDATALEN]; + /* You are declaring a char of length NAMEDATALEN, please consider using NameData instead. */ + NameData I2; ... } @rule_namedata_strlcpy@ identifier I1; expression E1; symbol NAMEDATALEN; @@ - strlcpy(I1, E1, NAMEDATALEN); + /* You are using strlcpy with NAMEDATALEN, please consider using NameData and namestrcpy instead. */ + namestrcpy(I1, E1); @rule_namedata_memcpy@ expression E1, E2; symbol NAMEDATALEN; @@ - memcpy(E1, E2, NAMEDATALEN); + /* You are using memcpy with NAMEDATALEN, please consider using NameData and namestrcpy instead. */ + namestrcpy(E1, E2); @@ typedef NameData; NameData E; @@ - E.data + /* Use NameStr rather than accessing data member directly */ + NameStr(E) @@ NameData *E; @@ - E->data + /* Use NameStr rather than accessing data member directly */ + NameStr(*E) @@ typedef Name; Name E; @@ - E->data + /* Use NameStr rather than accessing data member directly */ + NameStr(*E) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coccinelle/oidisvalid.cocci������������������������������������������������������0000664�0000000�0000000�00000002011�15100345067�0021276�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������// // find comparisons against `InvalidOid` // // Postgres has `OidIsValid()` macro to check if a given Oid is valid or not // (see https://github.com/postgres/postgres/blob/master/src/include/c.h). // // This script look for comparisons to `InvalidOid` and recommend the usage of // `OidIsValid()` instead. // // For example: // `oid != InvalidOid` should be `OidIsValid(oid)` // `oid == InvalidOid` should be `!OidIsValid(oid)` // @@ symbol InvalidOid; expression oid; @@ - (oid != InvalidOid) + /* use OidIsValid() instead of comparing against InvalidOid */ + OidIsValid(oid) @@ symbol InvalidOid; expression oid; @@ - (InvalidOid != oid) + /* use OidIsValid() instead of comparing against InvalidOid */ + OidIsValid(oid) @@ symbol InvalidOid; expression oid; @@ - (oid == InvalidOid) + /* use OidIsValid() instead of comparing against InvalidOid */ + !OidIsValid(oid) @@ symbol InvalidOid; expression oid; @@ - (InvalidOid == oid) + /* use OidIsValid() instead of comparing against InvalidOid */ + !OidIsValid(oid) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coverage/������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015646�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coverage/CMakeLists.txt����������������������������������������������������������0000664�0000000�0000000�00000014330�15100345067�0020407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# CMake targets for generating code coverage reports # # Note that the targets in here are not needed to enable code coverage on # builds. To have builds generate code coverage metadata, one only has to enable # the --coverage option for the compiler and this is done in the top-level # CMakeLists.txt so that the option covers all build targets in the project. # # Given that all dependencies (lcov, gcov, genhtml) are installed, and CMake is # initialized with -DCODECOVERAGE=ON, it should be possible to generate a code # coverage report by running: # # $ make coverage # # The report is generated in REPORT_DIR and can be viewed in a web browser. # If we use clang, prefer the LLVM gcov. The "normal" gcov segfaults with the # coverage info generated by clang, and the LLVM gcov with GCC-generated # coverage gives weird errors like GCOV_TAG_COUNTER_ARCS mismatch. set(GCOV_NAMES "gcov") if(CMAKE_C_COMPILER_ID MATCHES "Clang|AppleClang") string(REGEX MATCH "^[0-9]+" CMAKE_C_COMPILER_VERSION_MAJOR ${CMAKE_C_COMPILER_VERSION}) list(PREPEND GCOV_NAMES "llvm-cov-${CMAKE_C_COMPILER_VERSION_MAJOR}") endif() find_program(GCOV NAMES ${GCOV_NAMES}) # Find lcov for html output find_program(LCOV lcov) if(NOT GCOV) message(STATUS "Install gcov to generate code coverage reports") elseif(NOT LCOV) message(STATUS "Install lcov to generate code coverage reports") else() execute_process( COMMAND ${LCOV} --version OUTPUT_VARIABLE LCOV_VERSION_OUTPUT RESULT_VARIABLE LCOV_VERSION_RESULT OUTPUT_STRIP_TRAILING_WHITESPACE) if(LCOV_VERSION_RESULT EQUAL 0) # You might need to parse LCOV_VERSION_OUTPUT to extract just the version # number For example, if the output is "lcov: LCOV version 1.15", you'd # extract "1.15" string(REGEX MATCH "LCOV version ([0-9]+\\.[0-9]+)" LCOV_VERSION_MATCH "${LCOV_VERSION_OUTPUT}") if(LCOV_VERSION_MATCH) set(LCOV_VERSION ${CMAKE_MATCH_1}) message(STATUS "Using lcov ${LCOV}: ${LCOV_VERSION}") else() message( FATAL_ERROR "Could not parse LCOV version from output: ${LCOV_VERSION_OUTPUT}") endif() else() message( FATAL_ERROR "Failed to get LCOV version. Error code: ${LCOV_VERSION_RESULT}") endif() if(${LCOV_VERSION} GREATER_EQUAL "2.0") set(LCOV_EXTRA_OPTIONS "--ignore-errors mismatch,mismatch") else() set(LCOV_EXTRA_OPTIONS "") endif() message(STATUS "Using gcov ${GCOV}:") execute_process(COMMAND ${GCOV} --version) # Final tracefile for code coverage set(OUTPUT_FILE "timescaledb-coverage.info") # Directory where to generate the HTML report set(REPORT_DIR "lcov-report") # We can't directly use llvm-cov as --gcov-tool, because it has to be called # like "llvm-cov gcov <gcov args>" for that. Thankfully, if its $0 is gcov, it # will understand that we want it to operate like gcov. Just create a symlink. add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/gcov COMMAND ln -s ${GCOV} ${CMAKE_CURRENT_BINARY_DIR}/gcov) # The baseline run needs to run before tests to learn what zero coverage looks # like add_custom_command( OUTPUT ${OUTPUT_FILE}.base COMMENT "Generating code coverage base file" COMMAND ${LCOV} --rc lcov_branch_coverage=1 --capture --initial # Initial run --no-external # Do not include external source files --base-directory ${CMAKE_SOURCE_DIR} --directory ${CMAKE_BINARY_DIR} --output-file ${OUTPUT_FILE}.base --gcov-tool ${CMAKE_CURRENT_BINARY_DIR}/gcov ${LCOV_EXTRA_OPTIONS} DEPENDS timescaledb-tsl timescaledb timescaledb-loader ${CMAKE_CURRENT_BINARY_DIR}/gcov) add_custom_target(coverage_base DEPENDS ${OUTPUT_FILE}.base) # Ensure baseline file is generated before tests add_dependencies(installcheck coverage_base) # The test run needs to run after tests to analyze the test coverage add_custom_command( OUTPUT ${OUTPUT_FILE}.test COMMENT "Generating code coverage test file" COMMAND ${LCOV} --rc lcov_branch_coverage=1 --capture --no-external --base-directory ${CMAKE_SOURCE_DIR} --directory ${CMAKE_BINARY_DIR} --output-file ${OUTPUT_FILE}.test --gcov-tool ${CMAKE_CURRENT_BINARY_DIR}/gcov ${LCOV_EXTRA_OPTIONS} DEPENDS ${OUTPUT_FILE}.base coverage_base) # Make sure coverage_test runs after tests (installcheck) finish add_custom_target(coverage_test DEPENDS ${OUTPUT_FILE}.test) add_dependencies(installcheck-post-hook coverage_test) # Generate the final coverage file by combining the pre and post test # tracefiles add_custom_command( OUTPUT ${OUTPUT_FILE} COMMENT "Generating final code coverage file" COMMAND ${LCOV} --rc lcov_branch_coverage=1 --add-tracefile ${OUTPUT_FILE}.base --add-tracefile ${OUTPUT_FILE}.test --output-file ${OUTPUT_FILE} --gcov-tool ${CMAKE_CURRENT_BINARY_DIR}/gcov ${LCOV_EXTRA_OPTIONS} DEPENDS ${OUTPUT_FILE}.test coverage_test) add_custom_target(coverage_final DEPENDS ${OUTPUT_FILE}) add_dependencies(coverage_final coverage_test) # Look for genhtml to produce HTML report. This tool is part of the lcov # suite, so should be installed if lcov is installed. Thus, this is an # over-cautious check just in case some distributions break these tools up in # separate packages. find_program(GENHTML genhtml) if(GENHTML) message( STATUS "Generate a code coverage report using the 'coverage' target after tests have run." ) add_custom_command( OUTPUT ${REPORT_DIR}/index.html COMMENT "Generating HTML code coverage report in ${CMAKE_CURRENT_BINARY_DIR}/${REPORT_DIR}" COMMAND ${GENHTML} --prefix ${CMAKE_SOURCE_DIR} --branch-coverage --ignore-errors source --legend --title "TimescaleDB" --output-directory ${REPORT_DIR} ${OUTPUT_FILE} DEPENDS ${OUTPUT_FILE}) add_custom_target(coverage DEPENDS ${REPORT_DIR}/index.html) add_dependencies(coverage coverage_final) add_custom_command( COMMAND echo "Open file://${CMAKE_CURRENT_BINARY_DIR}/${REPORT_DIR}/index.html in a browser to view the report" TARGET coverage POST_BUILD COMMENT) else() message(STATUS "Install genhtml to generate code coverage reports") endif(GENHTML) endif() ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/coverage/README.md���������������������������������������������������������������0000664�0000000�0000000�00000003041�15100345067�0017123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Code coverage for TimescaleDB Code coverage can be enabled for TimescaleDB builds by setting the option `-DCODECOVEAGE=ON` when running CMake (it is off by default). This enables the necessary compiler option (`--coverage`) to generate code coverage statistics and should be enough for CI build reports using, e.g., `codecov.io`. In addition, local code coverage reports can be generated with the `lcov` tool, when this tool is installed on the build system. ## Generating local code coverage data files A code coverage report is generated in three steps using `lcov`: 1. A pre test baseline run to learn what zero coverage looks like (the `coverage_base` target). 2. A post test run to learn the test coverage (the `coverage_test` target). 3. A final run to combine the pre test and post test output files into a final data file (the `coverage_final` target). Each of these steps can be run manually using the mentioned targets, but should happen automatically as part of regular build and test steps. Optionally, this process can be extended with a filtering step to ignore certain paths that shouldn't be included in the final report. ## Producing a HTML-based code coverage report Once the complete test suite has run (`installcheck` target), it is possible to produce a HTML-based code coverage report that can be viewed in a web browser. This is automated by the `coverage` target. Thus, the complete steps to produce a code coverage report are: 1. `cmake --build` 2. `cmake --build --target installcheck` 3. `cmake --build --target coverage` �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/docs/����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015003�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/docs/BuildSource.md��������������������������������������������������������������0000664�0000000�0000000�00000005071�15100345067�0017550�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������### Building from source #### Building from source (Unix-based systems) If you are building from source for **non-development purposes** (i.e., you want to run TimescaleDB, not submit a patch), you should **always use a release-tagged commit and not build from `main`**. See the Releases tab for the latest release. **Prerequisites**: - A standard PostgreSQL 15, 16, or 17 installation with development environment (header files) (e.g., `postgresql-server-dev-17` package for Linux, Postgres.app for MacOS) - C compiler (e.g., gcc or clang) - [CMake](https://cmake.org/) version 3.15 or greater ```bash git clone git@github.com:timescale/timescaledb.git cd timescaledb # Find the latest release and checkout, e.g. for 2.15.0: git checkout 2.15.0 # Bootstrap the build system ./bootstrap # To build the extension cd build && make # To install make install ``` Note, if you have multiple versions of PostgreSQL installed you can specify the path to `pg_config` that should be used by using `./bootstrap -DPG_CONFIG=/path/to/pg_config`. Please see our [additional configuration instructions](https://docs.timescale.com/self-hosted/latest/install/). #### Building from source (Windows) If you are building from source for **non-development purposes** (i.e., you want to run TimescaleDB, not submit a patch), you should **always use a release-tagged commit and not build from `main`**. See the Releases tab for the latest release. **Prerequisites**: - A standard [PostgreSQL 15, 16, or 17 64-bit installation](https://www.enterprisedb.com/downloads/postgres-postgresql-downloads#windows) - OpenSSL for Windows - Microsoft Visual Studio 2017 with CMake and Git components - OR Visual Studio 2015/2016 with [CMake](https://cmake.org/) version 3.15 or greater and Git - Make sure all relevant binaries are in your PATH: `pg_config` and `cmake` If using Visual Studio 2017 with the CMake and Git components, you should be able to simply clone the repo and open the folder in Visual Studio which will take care of the rest. If you are using an earlier version of Visual Studio, then it can be built in the following way: ```bash git clone git@github.com:timescale/timescaledb.git cd timescaledb # Find the latest release and checkout, e.g. for 2.15.0: git checkout 2.15.0 # Bootstrap the build system bootstrap.bat # To build the extension from command line cmake --build ./build --config Release # To install cmake --build ./build --config Release --target install # Alternatively, build in Visual Studio via its built-in support for # CMake or by opening the generated build/timescaledb.sln solution file. ``` �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/docs/MultiNodeDeprecation.md�����������������������������������������������������0000664�0000000�0000000�00000006171�15100345067�0021410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������## Multi-node Deprecation Multi-node support has been deprecated. TimescaleDB 2.13 is the last version that will include multi-node support. Multi-node support in 2.13 is available for PostgreSQL 13, 14 and 15. This decision was not made lightly, and we want to provide a clear understanding of the reasoning behind this change and the path forward. ### Why we are ending multi-node support We began to work on multi-node support in 2018 and released the first version in 2020 to address the growing demand for higher scalability in TimescaleDB deployments. The distributed architecture of multi-node allowed for horizontal scalability of writes and reads to go beyond what a single node could provide. While we added many improvements since the initial launch, the architecture of multi-node came with a number of inherent limitations and challenges that have limited its adoption. Regrettably, only about 1% of current TimescaleDB deployments utilize multi-node, and the complexity involved in maintaining this feature has become a significant obstacle. It’s not an isolated feature that can be kept in the product with very little effort since adding new features required extra development and testing to ensure they also worked for multi-node. As we've evolved our single-node product and expanded our cloud offering to serve thousands of customers, we've identified more efficient solutions to meet the scalability needs of our users. First, we’ve been able and will continue to make big improvements in the write and read performance of single-node. We’ve scaled a single-node deployment to process 2 million inserts per second and have seen performance improvements of 10x for common queries. You can read a summary of the latest query performance improvements [here](https://www.timescale.com/blog/8-performance-improvements-in-recent-timescaledb-releases-for-faster-query-analytics/). And second, we are leveraging cloud technologies that have become very mature to provide higher scalability in a more accessible way. For example, our cloud offering uses object storage to deliver virtually [infinite storage capacity at a very low cost](https://www.timescale.com/blog/scaling-postgresql-for-cheap-introducing-tiered-storage-in-timescale/). For those reasons, we’ve decided to focus our efforts on improving single-node and leveraging cloud technologies to solve for high scalability and as a result we’ve ended support for multi-node. ### What this means for you We understand that this change may raise questions, and we are committed to supporting you through the transition. For current TimescaleDB multi-node users, please refer to our [migration documentation](https://docs.timescale.com/migrate/latest/multi-node-to-timescale-service/) for a step-by-step guide to transition to a single-node configuration. Alternatively, you can continue to use multi-node up to version 2.13. However, please be aware that future versions will no longer include this functionality. If you have any questions or feedback, you can share them in the #multi-node channel in our [community Slack](https://slack.timescale.com/). �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/docs/StyleGuide.md���������������������������������������������������������������0000664�0000000�0000000�00000014172�15100345067�0017410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# TimescaleDB code style guide Source code should follow the [PostgreSQL coding conventions](https://www.postgresql.org/docs/current/static/source.html). This includes [source formatting](https://www.postgresql.org/docs/current/static/source-format.html) with 4 column tab spacing and layout rules according to the BSD style. ## SQL and PL/pgSQL style There is no official SQL or PL/pgSQL style guide for PostgreSQL that we are aware of, apart from the general spacing and layout rules above. For now, try to follow the style of the surrounding code when making modifications. We might develop more stringent guidelines in the future. ## Error messages Error messages in TimescaleDB should obey the PostgreSQL [error message style guide](https://www.postgresql.org/docs/current/static/error-style-guide.html). ## C style While the PostgreSQL project mandates that [C code adheres to the C89 standard](https://www.postgresql.org/docs/current/static/source-conventions.html) with some exceptions, we've chosen to allow many C99 features for the clarity and convenience they provide. PostgreSQL sticks with C89 mostly for compatibility with many older compilers and platforms, such as Visual Studio on Windows. Visual Studio should support most of C99 nowadays, however. We might revisit this decision in the future if it turns out to be a problem for important platforms. Unfortunately, PostgreSQL does not have a consistent style for naming of functions, variables and types. This [mailing-list thread](https://www.postgresql.org/message-id/1221125165.5637.12.camel%40abbas-laptop) elaborates on the situation. Instead, we've tried our best to develop a consistent style that roughly follows the style of the PostgreSQL source code. ### Declarations before code C99 supports having code before a declaration, similar to C++, and we also support this in the code. For instance, the following code follows the guidelines: ```C void some_function() { prepare(); int result = fetch(); ... } ``` ### Function and variable names For clarity and consistency, we've chosen to go with lowercase under-score separated names for functions and variables. For instance, this piece of code is correct: ```C static void my_function_name(int my_parameter) { int my_variable; ... } ``` while this one is wrong: ```C static void MyFunctionName(int myParameter) { int myVariable; ... } ``` ### Type declarations New composite/aggregate types should be typedef'd and use UpperCamelCase naming. For instance, the following is correct: ```C typedef struct MyType { ... } MyType; ``` while the following is wrong: ```C typedef struct my_type { ... } my_type; ``` ### Modular code and namespacing When possible, code should be grouped into logical modules. Such modules typically resemble classes in object-oriented programming (OOP) languages and should use namespaced function and variable names that have the module name as prefix. TimescaleDB's [Cache](../src/cache.c) implementation is a good example of such a module where one would use ```C void cache_initialize(Cache *c) { ... } ``` rather than ```C void initialize_cache(Cache *c) { } ``` ### Object-orientated programming style Even though C is not an object-oriented programming language, it is fairly straight-forward to write C code with an OOP flavor. While we do not mandate that C code has an OOP flavor, we recommend it when it makes sense (e.g., to achieve modularity and code reuse). For example, TimescaleDB's [cache.c](../src/cache.c) module can be seen as a _base class_ with multiple derived _subclasses_, such as [hypertable_cache.c](../src/hypertable_cache.c) and [chunk_cache.c](../src/chunk_cache.c). Here's another example of subclassing using shapes: ```C typedef struct Shape { int color; void (*draw)(Shape *, Canvas *); } Shape; void shape_draw(Shape *shape) { /* open canvas for drawing */ Canvas *c = canvas_open(); /* other common shape code */ ... shape->draw(shape, c); canvas_close(c); } typedef struct Circle { Shape shape; float diameter; } Circle; Circle blue_circle = { .shape = { .color = BLUE, .draw = circle_draw, }, .diameter = 10.1, }; void circle_draw(Shape *shape, Canvas *canvas) { Circle *circle = (Circle *) shape; /* draw circle */ ... } ``` There are a couple of noteworthy take-aways from this example. * Non-static "member" methods should take a pointer to the object as first argument and be namespaced as described above. * Derived modules can expand the original type using struct embedding, in which case the "superclass" should be the first member of the "subclass", so that one can easily upcast a `Circle` to a `Shape` or, vice-versa, downcast as in `circle_draw()` above. * C++-style virtual functions can be implemented with functions pointers. Good use cases for such functions are module-specific initialization and cleanup, or function overriding in a subclass. ### Other noteworthy recommendations * Prefer static allocation and/or stack-allocated variables over heap/dynamic allocation when possible. Fortunately, PostgreSQL has a nice `MemoryContext` implementation that helps with heap allocation when needed. * Try to minimize the number of included headers in source files, especially when header files include other headers. Avoid circular header dependencies by predeclaring types (or use struct pointers). For a general guide to writing C functions in PostgreSQL, you can review the section on [C-language functions](https://www.postgresql.org/docs/current/static/xfunc-c.html) in the PostgreSQL documentation. ## Tools and editors We require running C code through clang-format before submitting a PR. This will ensure your code is properly formatted according to our style (which is similar to the PostgreSQL style but implement in clang-format). You can run clang-format on all of the TimescaleDB code using `make format` if you have clang-format (version >= 7) or docker installed. The following [Wiki post](https://wiki.postgresql.org/wiki/Developer_FAQ#What.27s_the_formatting_style_used_in_PostgreSQL_source_code.3F) contains links to style configuration files for various editors. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015542�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/CMakeLists.txt�����������������������������������������������������������0000664�0000000�0000000�00000000420�15100345067�0020276�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������find_program( NM NAMES nm PATHS /usr/bin /usr/local/bin /opt/local/bin) if(NM) message(STATUS "Using nm ${NM}") else() message(STATUS "Install nm to be able to run export checks") endif(NM) configure_file(export_prefix_check.sh.in export_prefix_check.sh @ONLY) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/backport.py��������������������������������������������������������������0000775�0000000�0000000�00000050010�15100345067�0017720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 import os import random import re import string import subprocess import sys from github import Github # This is PyGithub. import requests # Limit our history search and fetch depth to this value, not to get stuck in # case of a bug. HISTORY_DEPTH = 1000 def run_query(query): """A simple function to use requests.post to make the GraphQL API call.""" token = os.environ.get("ORG_AUTOMATION_TOKEN") request = requests.post( "https://api.github.com/graphql", json={"query": query}, headers={"Authorization": f"Bearer {token}"} if token else None, timeout=20, ) response = request.json() # Have to work around the unique GraphQL convention of returning 200 for errors. if request.status_code != 200 or "errors" in response: raise ValueError( f"Query failed to run by returning code of {request.status_code}." f"\nQuery: '{query}'" f"\nResponse: '{request.json()}'" ) return response def get_referenced_issue(pr_number): """Get the number of issue fixed by the given pull request. Returns None if no issue is fixed, or more than one issue""" # We only need the first issue here. We also request only the first 30 labels, # because GitHub requires some small restriction there that is counted # towards the GraphQL API usage quota. ref_result = run_query( string.Template( """ query { repository(owner: "timescale", name: "timescaledb") { pullRequest(number: $pr_number) { closingIssuesReferences(first: 1) { nodes { number, title, labels (first: 30) { nodes { name } } } } } } } """ ).substitute({"pr_number": pr_number}) ) # The above returns: # {'data': {'repository': {'pullRequest': {'closingIssuesReferences': {'nodes': [{'number': 6819, # 'title': '[Bug]: Segfault when `ts_insert_blocker` function is called', # 'labels': {'nodes': [{'name': 'bug'}]}}]}}}}} # # We can have {'nodes': [None]} in case it references an inaccessible repository, # just ignore it. ref_nodes = ref_result["data"]["repository"]["pullRequest"][ "closingIssuesReferences" ]["nodes"] if not ref_nodes or len(ref_nodes) != 1 or not ref_nodes[0]: return None, None, None number = ref_nodes[0]["number"] title = ref_nodes[0]["title"] labels = {x["name"] for x in ref_nodes[0]["labels"]["nodes"]} return number, title, labels def set_auto_merge(pr_number): """Enable auto-merge for the given PR""" # We first have to find out the PR id, which is some base64 string, different # from its number. query = string.Template( """query { repository(owner: "$owner", name: "$name") { pullRequest(number: $pr_number) { id } } }""" ).substitute( pr_number=pr_number, owner=source_repo.owner.login, name=source_repo.name ) result = run_query(query) pr_id = result["data"]["repository"]["pullRequest"]["id"] query = string.Template( """mutation { enablePullRequestAutoMerge( input: { pullRequestId: "$pr_id", mergeMethod: REBASE } ) { clientMutationId } }""" ).substitute(pr_id=pr_id) run_query(query) def git_output(command): """Get output from the git command, checking for the successful exit code""" return subprocess.check_output(f"git {command}", shell=True, text=True) def git_check(command): """Run a git command, checking for the successful exit code""" subprocess.run(f"git {command}", shell=True, check=True) def git_returncode(command): """Run a git command, returning the exit code""" return subprocess.run(f"git {command}", shell=True, check=False).returncode # The token has to have the "access public repositories" permission, or else creating a PR returns 404. github = Github(os.environ.get("ORG_AUTOMATION_TOKEN")) source_remote = "origin" source_repo_name = os.environ.get("GITHUB_REPOSITORY") # This is set in GitHub Actions. if not source_repo_name: source_repo_name = "timescale/timescaledb" print( f"Will look at '{source_repo_name}' (git remote '{source_remote}') for bug fixes." ) source_repo = github.get_repo(source_repo_name) # Fetch the main branch. Apparently the local repo can be shallow in some cases # in Github Actions, so specify the depth. --unshallow will complain on normal # repositories, this is why we don't use it here. git_check( f"fetch --quiet --depth={HISTORY_DEPTH} {source_remote} main:refs/remotes/{source_remote}/main" ) # Find out what is the branch corresponding to the previous version compared to # main. We will backport to that branch. version_config = dict( [ re.match(r"^(.+)\s+=\s+(.+)$", line).group(1, 2) for line in git_output(f"show {source_remote}/main:version.config").splitlines() if line ] ) version = version_config["version"].split("-")[0] # Split off the 'dev' suffix. version_parts = version.split(".") # Split the three version numbers. version_parts[1] = str(int(version_parts[1]) - 1) version_parts[2] = "x" backport_target = ".".join(version_parts) backported_label = f"backported-{backport_target}" print(f"Will backport to {backport_target}.") # Fetch the target branch. Apparently the local repo can be shallow in some cases # in Github Actions, so specify the depth. --unshallow will complain on normal # repositories, this is why we don't use it here. git_check( f"fetch --quiet --depth={HISTORY_DEPTH} {source_remote} {backport_target}:refs/remotes/{source_remote}/{backport_target}" ) # Find out which commits are unique to main and target branch. Also build sets of # the titles of these commits. We will compare the titles to check whether a # commit was backported. main_commits = [ line.split("\t") for line in git_output( f'log -{HISTORY_DEPTH} --abbrev=12 --pretty="format:%h\t%s" {source_remote}/{backport_target}..{source_remote}/main' ).splitlines() if line ] print(f"Have {len(main_commits)} new commits in the main branch.") branch_commits = [ line.split("\t") for line in git_output( f'log -{HISTORY_DEPTH} --abbrev=12 --pretty="format:%h\t%s" {source_remote}/main..{source_remote}/{backport_target}' ).splitlines() if line ] branch_commit_titles = {x[1] for x in branch_commits} # We will do backports per-PR, because one PR, though not often, might contain # many commits. So as the first step, go through the commits unique to main, find # out which of them have to be backported, and remember the corresponding PRs. # We also have to remember which commits to backport. The list from PR itself is # not what we need, these are the original commits from the PR branch, and we # need the resulting commits in master. class PRInfo: """Information about the PR to be backported.""" def __init__(self, pygithub_pr_, issue_number_): self.pygithub_pr = pygithub_pr_ self.pygithub_commits = [] self.issue_number = issue_number_ def should_backport_by_labels(number, title, labels): """Should we backport the given PR/issue, judging by the labels? Note that this works in ternary logic: True means we must, False means we must not (tags to disable backport take precedence), and None means weak no (no tags to either request or disable backport)""" stopper_labels = labels.intersection( ["disable-auto-backport", "auto-backport-not-done"] ) if stopper_labels: print( f"#{number} '{title}' is labeled as '{list(stopper_labels)[0]}' which prevents automated backporting." ) return False force_labels = labels.intersection(["bug", "force-auto-backport"]) if force_labels: print( f"#{number} '{title}' is labeled as '{list(force_labels)[0]}' which requests automated backporting." ) return True return None # Go through the commits unique to main, and build a dict(pr number -> PRInfo) # of PRs that we will consider for backporting. prs_to_backport = {} for commit_sha, commit_title in main_commits: print() pygithub_commit = source_repo.get_commit(sha=commit_sha) pulls = pygithub_commit.get_pulls() if not pulls or pulls.totalCount == 0: print(f"{commit_sha[:9]} '{commit_title}' does not belong to a PR.") continue if pulls.totalCount > 1: # What would that mean? Just play it safe and skip it. print( f"{commit_sha[:9]} '{commit_title}' references multiple PRs: {', '.join([pull.number for pull in pulls])}" ) continue pull = pulls[0] # If a commit with the same title is already in the branch, mark the PR with # a corresponding tag. This makes it easier to check what was backported # when looking at the release milestone. Note that we do this before other # checks -- maybe it was backported manually regardless of the usual # conditions. if commit_title in branch_commit_titles: print(f"{commit_sha[:9]} '{commit_title}' is already in the branch.") if backported_label not in {label.name for label in pull.labels}: pull.add_to_labels(backported_label) continue # Next, we're going to look at the labels of both the PR and the linked # issue, if any, to understand whether we should backport the fix. We have # labels to request backport like "bug", and labels to prevent backport # like "disable-auto-backport", on both issue and the PR. We're going to use # the ternary False/None/True logic to combine them properly. issue_number, issue_title, issue_labels = get_referenced_issue(pull.number) if not issue_number: should_backport_issue_ternary = None print( f"{commit_sha[:9]} belongs to the PR #{pull.number} '{pull.title}' that does not close an issue." ) else: issue = source_repo.get_issue(number=issue_number) should_backport_issue_ternary = should_backport_by_labels( issue_number, issue_title, issue_labels ) print( f"{commit_sha[:9]} belongs to the PR #{pull.number} '{pull.title}' " f"that references the issue #{issue.number} '{issue.title}'." ) pull_labels = {label.name for label in pull.labels} should_backport_pr_ternary = should_backport_by_labels( pull.number, pull.title, pull_labels ) # We backport if either the PR or the issue labels request the backport, and # none of them prevent it. I'm writing it with `is True` because I don't # remember python rules for ternary logic with None (do you?). if ( should_backport_pr_ternary is True or should_backport_issue_ternary is True ) and ( should_backport_pr_ternary is not False and should_backport_issue_ternary is not False ): print(f"{commit_sha[:9]} '{commit_title}' will be considered for backporting.") else: continue # Remember the PR and the corresponding resulting commit in main. if pull.number not in prs_to_backport: prs_to_backport[pull.number] = PRInfo(pull, issue_number) # We're traversing the history backwards, and want to have the list of # commits in forward order. prs_to_backport[pull.number].pygithub_commits.insert(0, pygithub_commit) def branch_has_open_pr(repo, branch): """Check whether the given branch has an open PR.""" # There's no way to search by branch name + fork name, but in the case the # branch name is probably unique. We'll bail out if we find more than one PR. template = """query { repository(name: "$repo_name", owner: "$repo_owner") { pullRequests(headRefName: "$branch", first: 2) { nodes { closed }}}}""" params = { "branch": branch, "repo_name": repo.name, "repo_owner": repo.owner.login, } query = string.Template(template).substitute(params) result = run_query(query) # This returns: # {'data': {'repository': {'pullRequests': {'nodes': [{'closed': True}]}}}} prs = result["data"]["repository"]["pullRequests"]["nodes"] if not prs or len(prs) != 1 or not prs[0]: return None return not prs[0]["closed"] def report_backport_not_done(original_pr, reason, details=None): """If something prevents us from backporting the PR automatically, report it in a comment to original PR, and add a label preventing further attempts.""" print( f"Will not backport the PR #{original_pr.number} '{original_pr.title}': {reason}" ) github_comment = f"Automated backport to {backport_target} not done: {reason}." if details: github_comment += f"\n\n{details}" # Link to the job if we're running in the Github Action environment. if "GITHUB_REPOSITORY" in os.environ: github_comment += ( "\n\n" f"[Job log](https://github.com/{os.environ.get('GITHUB_REPOSITORY')}" f"/actions/runs/{os.environ.get('GITHUB_RUN_ID')}" f"/attempts/{os.environ.get('GITHUB_RUN_ATTEMPT')})" ) original_pr.create_issue_comment(github_comment) original_pr.add_to_labels("auto-backport-not-done") # Set git name and email corresponding to the token user. token_user = github.get_user() os.environ["GIT_COMMITTER_NAME"] = token_user.name os.environ["GIT_AUTHOR_NAME"] = token_user.name # This is an email that is used by Github when you opt to hide your real email # address. It is required so that the commits are recognized by Github as made # by the user. That is, if you use a wrong e-mail, there won't be a clickable # profile picture next to the commit in the Github interface. os.environ["GIT_COMMITTER_EMAIL"] = ( f"{token_user.id}+{token_user.login}@users.noreply.github.com" ) os.environ["GIT_AUTHOR_EMAIL"] = os.environ["GIT_COMMITTER_EMAIL"] print( f"Will commit as {os.environ['GIT_COMMITTER_NAME']} <{os.environ['GIT_COMMITTER_EMAIL']}>" ) # Fetch all branches from the repository, because we use the presence # of the backport branches to determine that a backport exists. It's not convenient # to query for branch existence through the PyGithub API. git_check(f"fetch {source_remote}") # Now, go over the list of PRs that we have collected, and try to backport # each of them. Do it in randomized order to avoid getting stuck on a single # error. print(f"Have {len(prs_to_backport)} PRs to backport.") for index, pr_info in enumerate( random.sample(list(prs_to_backport.values()), len(prs_to_backport)) ): print() # Don't want to have an endless loop that modifies the repository in an # unattended script. The already backported/conflicted PRs shouldn't even # get into this list, so the low number is OK, it will still make progress. if index > 5: print(f"{index} PRs processed, stopping as a precaution.") sys.exit(0) original_pr = pr_info.pygithub_pr backport_branch = f"backport/{backport_target}/{original_pr.number}" # If there is already a backport branch for this PR, this probably means # that we already created the backport PR. Update it, because the PR might # not auto-merge when the branch is not up to date with the target branch, # depending on the branch protection settings. We want to update to the # recent target automatically to minimize the amount of manual work. if ( git_returncode(f"rev-parse {source_remote}/{backport_branch} > /dev/null 2>&1") == 0 ): print( f'Backport branch {backport_branch} for PR #{original_pr.number}: "{original_pr.title}" already exists.' ) if not branch_has_open_pr(source_repo, backport_branch): # The PR can be closed manually when the backport is not needed, or # can not exist when there was some error. We are only interested in # the most certain case when there is an open backport PR. continue print(f"Updating the branch {backport_branch} because it has an open PR.") git_check("reset --hard") git_check("clean -xfd") git_check( f"checkout --quiet --force --detach {source_remote}/{backport_branch} > /dev/null" ) # Use merge and no force-push, so that the simultaneous changes made by # other users are not accidentally overwritten. git_check(f"merge --quiet --no-edit {source_remote}/{backport_target}") git_check(f"push {source_remote} @:{backport_branch}") continue # Try to cherry-pick the commits. git_check("reset --hard") git_check("clean -xfd") git_check( f"checkout --quiet --force --detach {source_remote}/{backport_target} > /dev/null" ) commit_shas = [commit.sha for commit in pr_info.pygithub_commits] if git_returncode(f"cherry-pick --quiet -m 1 -x {' '.join(commit_shas)}") != 0: details = f"### Git status\n\n```\n{git_output('status')}\n```" git_check("cherry-pick --abort") report_backport_not_done(original_pr, "cherry-pick failed", details) continue changed_files = {file.filename for file in original_pr.get_files()} # Push the backport branch. git_check(f"push {source_remote} @:refs/heads/{backport_branch}") # Prepare description for the backport PR. backport_description = ( f"This is an automated backport of #{original_pr.number}: {original_pr.title}." ) if pr_info.issue_number: backport_description += f"\nThe original issue is #{pr_info.issue_number}." # Do not merge the PR automatically if it changes some particularly # conflict-prone files that are better to review manually. Also mention this # in the description. stopper_files = changed_files.intersection( ["sql/updates/latest-dev.sql", "sql/updates/reverse-dev.sql"] ) if stopper_files: backport_description += ( "\n" f"This PR will not be merged automatically, because it modifies '{list(stopper_files)[0]}' " "which is conflict-prone. Please review these changes manually." ) else: backport_description += ( "\n" "This PR will be merged automatically after all the relevant CI checks pass." ) backport_description += ( " If this fix should not be backported, or will be backported manually, " "just close this PR. You can use the backport branch to add your " "changes, it won't be modified automatically anymore." "\n" "\n" "For more details, please see the [documentation]" "(https://github.com/timescale/eng-database/wiki/Releasing-TimescaleDB#automated-cherry-picking-of-bug-fixes)" ) # Add original PR description. Comment out the Github issue reference # keywords like 'Fixes #1234', to avoid having multiple PRs saying they fix # a given issue. The backport PR is going to reference the fixed issue as # "Original issue #xxxx". original_description = re.sub( r"((fix|clos|resolv)[esd]+)(\s+#[0-9]+)", r"`\1`\3", original_pr.body or "", # Match "" if pr_body is None flags=re.IGNORECASE, ) backport_description += ( "\n" "\n" "## Original description" "\n" f"### {original_pr.title}" "\n" f"{original_description}" ) # Create the backport PR. backport_pr = source_repo.create_pull( title=f"Backport to {backport_target}: #{original_pr.number}: {original_pr.title}", body=backport_description, # We're creating PR from the token user's fork. head=backport_branch, base=backport_target, ) backport_pr.add_to_labels("is-auto-backport") backport_pr.add_to_assignees(original_pr.user.login) if not stopper_files: set_auto_merge(backport_pr.number) print( f"Created backport PR #{backport_pr.number} for #{original_pr.number}: {original_pr.title}" ) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/bundle_coredumps.sh������������������������������������������������������0000775�0000000�0000000�00000000656�15100345067�0021442�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash TARGET=coredumps COREDUMP_DIR=/var/lib/systemd/coredump set -e mkdir -p "$TARGET" # get information from gdb info=$(echo "info sharedlibrary" | coredumpctl gdb) executable=$(echo "$info" | grep Executable | sed -e 's!^[^/]\+!!') cp "$executable" "$TARGET" cp ${COREDUMP_DIR}/* "$TARGET" # copy libraries extracted from gdb info echo "$info" | grep '^0x' | sed -e 's!^[^/]\+!!' | xargs -ILIB cp "LIB" "$TARGET" ����������������������������������������������������������������������������������timescaledb-2.23.0/scripts/c_license_header-apache.h������������������������������������������������0000664�0000000�0000000�00000000275�15100345067�0022372�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/c_license_header-timescale.h���������������������������������������������0000664�0000000�0000000�00000000277�15100345067�0023121�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/changelog/���������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017471�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/changelog/generate.sh����������������������������������������������������0000775�0000000�0000000�00000004107�15100345067�0021624�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash set -eu # # This script build a CHANGELOG.md for a new release # echo_changelog() { echo "${1}" # skip the template and release notes files grep -i "${2}" .unreleased/* | \ cut -d: -f3- | sort | uniq | sed -e 's/^[[:space:]]*//' -e 's/^/* /' -e 's!#\([0-9][0-9]*\)![#\1](https://github.com/timescale/timescaledb/pull/\1)!g' echo } # Build a delta of the GUCs between two releases # # Param: previous release # Param: release branch # echo_gucs() { echo "**GUCs**" git diff ${1}..${2} src/guc.c | grep EXTOPTION | grep -o '"[^"]*"' | sed 's/^/* /' | sort | sed 's/"/`/g' } get_version_config_var() { grep "${1}" version.config | awk '{print $3}' | sed 's/-dev//' } RELEASE_NEXT=$(get_version_config_var '^version') RELEASE_PREVIOUS=$(get_version_config_var '^previous_version') RELEASE_BRANCH="${RELEASE_NEXT/%.[0-9]/.x}" echo "Building CHANGELOG" { echo "## ${RELEASE_NEXT} ($(date +"%Y-%m-%d"))" echo "" echo "This release contains performance improvements and bug fixes since the ${RELEASE_PREVIOUS} release. We recommend that you upgrade at the next available opportunity." echo "" echo "**Highlighted features in TimescaleDB v${RELEASE_NEXT}**" echo "* " echo "" echo_changelog '**Features**' '^Implements:' echo_changelog '**Bugfixes**' '^Fixes:' echo_gucs $RELEASE_PREVIOUS $RELEASE_BRANCH echo "" echo_changelog '**Thanks**' '^Thanks:' } > CHANGELOG_next.md RELEASE_NOTE_START=$(grep -n $RELEASE_PREVIOUS CHANGELOG.md | cut -d ':' -f 1 | head -1) CHANGELOG_HEADER_LINES=$((RELEASE_NOTE_START - 1)) mv CHANGELOG.md CHANGELOG.md.tmp head -n $CHANGELOG_HEADER_LINES CHANGELOG.md.tmp > CHANGELOG.md cat CHANGELOG_next.md >> CHANGELOG.md CHANGELOG_LENGTH=$(wc -l CHANGELOG.md.tmp | cut -d ' ' -f 5) CHANGELOG_ENTRIES=$((CHANGELOG_LENGTH-CHANGELOG_HEADER_LINES)) tail -n "$CHANGELOG_ENTRIES" CHANGELOG.md.tmp >> CHANGELOG.md rm -f CHANGELOG.md.tmp CHANGELOG_next.md # Remove the CHANGELOG generating # Fresh start for next version echo "Deleting all .unreleased files" rm -f .unreleased/* echo "done." ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/changelog/template.rfc822������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0022231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Implements: #NNNNN <one line description of the feature> Fixes: #NNNNN <one line description of the Issue> Thanks: @name <Thank you note> ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/check_changelog_format.py������������������������������������������������0000775�0000000�0000000�00000010663�15100345067�0022561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 import sys import re import os import github # this is PyGithub. import requests import string def run_query(query): """A simple function to use requests.post to make the GraphQL API call.""" request = requests.post( "https://api.github.com/graphql", json={"query": query}, headers={"Authorization": f'Bearer {os.environ.get("GH_TOKEN")}'}, timeout=20, ) response = request.json() # Have to work around the unique GraphQL convention of returning 200 for errors. if request.status_code != 200 or "errors" in response: raise ValueError( f"Query failed to run by returning code of {request.status_code}." f"\nQuery: '{query}'" f"\nResponse: '{request.json()}'" ) return response def get_referenced_issues(pr_number): """Get the numbers of issue fixed by the given pull request.""" ref_result = run_query( string.Template( """ query { repository(owner: "timescale", name: "timescaledb") { pullRequest(number: $pr_number) { closingIssuesReferences(first: 100) { edges { node { number } } } } } } """ ).substitute({"pr_number": pr_number}) ) # The above returns {'data': {'repository': {'pullRequest': {'closingIssuesReferences': {'edges': [{'node': {'number': 4944}}]}}}}} ref_edges = ref_result["data"]["repository"]["pullRequest"][ "closingIssuesReferences" ]["edges"] if not ref_edges: return [] return [edge["node"]["number"] for edge in ref_edges if edge] # Check if a line matches any of the specified patterns def is_valid_line(line): patterns = [r"^Fixes:\s*.*$", r"^Implements:\s*.*$", r"^Thanks:\s*.*$"] for pattern in patterns: if re.match(pattern, line): return True return False def main(): github_token = os.environ.get("GH_TOKEN") if not github_token: print("Please populate the GH_TOKEN environment variable.") sys.exit(1) github_obj = github.Github(github_token) repo = github_obj.get_repo("timescale/timescaledb") # Get the file name from the command line argument if len(sys.argv) != 2: print("Please provide a file name as a command-line argument.") sys.exit(1) file_name = sys.argv[1] this_pr_number = int(os.environ["PR_NUMBER"]) pr_issues = set(get_referenced_issues(this_pr_number)) # Read the file and check non-empty lines changelog_issues = set() with open(file_name, "r", encoding="utf-8") as file: for line in file: line = line.strip() if not is_valid_line(line): print(f'Invalid entry in change log: "{line}"') sys.exit(1) # The referenced issue number should be valid. for issue_number in re.findall("#([0-9]+)", line): issue_number = int(issue_number) try: issue = repo.get_issue(number=issue_number) except github.UnknownObjectException: print( f"The changelog entry references an invalid issue #{issue_number}:\n{line}" ) sys.exit(1) as_pr = None try: as_pr = issue.as_pull_request() except github.UnknownObjectException: # Not a pull request pass # Accept references to PR itself. if as_pr: if issue_number != this_pr_number: print( f"The changelog for PR #{this_pr_number} references another PR #{issue_number}" ) sys.exit(1) changelog_issues = pr_issues else: changelog_issues.add(issue_number) if changelog_issues != pr_issues: print( "Instead of " + (f"the issues {pr_issues}" if pr_issues else "no issues") + f" linked to the PR #{this_pr_number}, the changelog references " + (f"the issues {changelog_issues}" if changelog_issues else "no issues") ) sys.exit(1) if __name__ == "__main__": main() �����������������������������������������������������������������������������timescaledb-2.23.0/scripts/check_file_license.sh����������������������������������������������������0000775�0000000�0000000�00000005153�15100345067�0021663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash get_c_license() { awk 'BEGIN {ORS=""}{if($1 == "*/") {print; exit;}} {print}' $1 } get_sql_license() { awk 'BEGIN {ORS=""}{if($1 == "") {print; exit;}} {print}' $1 } check_file() { FLAG=${1} FILE=${2} SCRIPTPATH="$( cd "$(dirname "${0}")" || exit ; pwd -P )" TIMESCALE_LOCATION=$(dirname ${SCRIPTPATH}) LICENSE_FILE= LICENSE_STRING= FIRST_COMMENT= case ${FLAG} in ('-c') LICENSE_FILE="${SCRIPTPATH}/c_license_header-apache.h" LICENSE_STRING=$(get_c_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_c_license ${FILE}) ;; ('-e') LICENSE_FILE="${SCRIPTPATH}/c_license_header-timescale.h" LICENSE_STRING=$(get_c_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_c_license ${FILE}) ;; ('-i') LICENSE_FILE="${SCRIPTPATH}/license_apache.spec" LICENSE_STRING=$(get_sql_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_sql_license ${FILE}) ;; ('-j') LICENSE_FILE="${SCRIPTPATH}/license_tsl.spec" LICENSE_STRING=$(get_sql_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_sql_license ${FILE}) ;; ('-s') LICENSE_FILE="${SCRIPTPATH}/sql_license_apache.sql" LICENSE_STRING=$(get_sql_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_sql_license ${FILE}) ;; ('-t') LICENSE_FILE="${SCRIPTPATH}/sql_license_tsl.sql" LICENSE_STRING=$(get_sql_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_sql_license ${FILE}) ;; ('-p') LICENSE_FILE="${SCRIPTPATH}/license_tsl.spec" LICENSE_STRING=$(get_sql_license ${LICENSE_FILE}) FIRST_COMMENT=$(get_sql_license ${FILE}) ;; ("--") return 0; ;; (*) echo "Unknown flag" ${1} return 1; esac if [[ "${FIRST_COMMENT}" != "${LICENSE_STRING}" ]]; then echo ${FILE#"$TIMESCALE_LOCATION/"} "lacks a license header. Add"; echo cat ${LICENSE_FILE} echo echo "to the top of the file"; return 1; fi } args=$(getopt "c:e:i:j:p:s:t:" "$@"); errcode=$?; set -- $args if [[ ${errcode} != 0 ]]; then echo 'Usage: check_file_license ((-c|-e|-i|-j|-s|-t) <filename> ...)' return 2 fi ERRORCODE=0 while [[ ${1} ]]; do if [[ ${1} == "--" ]]; then break; fi check_file ${1} ${2} FILE_ERR=${?} ERRORCODE=$((FILE_ERR | ERRORCODE)); shift; shift; done exit ${ERRORCODE}; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/check_license.sh���������������������������������������������������������0000775�0000000�0000000�00000002431�15100345067�0020660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#! /bin/bash SCRIPT_DIR=$(dirname ${0}) SRC_DIR=$(dirname ${SCRIPT_DIR}) # we skip license checks for: # - the update script fragments, because the generated update scripts will # contain the license at top, and we don't want to repeat it in the middle # - test/sql/dump which contains auto-generated code # - src/chunk_adatptive since it's still in BETA check_file() { SUFFIX0= SUFFIX1= if [[ ${1} == '-c' || ${1} == '-e' ]]; then SUFFIX0='*.c' SUFFIX1='*.h' elif [[ ${1} == '-i' || ${1} == '-j' ]]; then SUFFIX0='*.spec' SUFFIX1='*.spec.in' elif [[ ${1} == '-p' ]]; then SUFFIX0='*.pl' SUFFIX1='*.pm' else SUFFIX0='*.sql' SUFFIX1='*.sql.in' fi find $2 -type f \( -name "${SUFFIX0}" -or -name "${SUFFIX1}" \) -and -not -path "${SRC_DIR}/sql/updates/*.sql" -and -not -path "${SRC_DIR}/test/sql/dump/*.sql" -and -not -path "${SRC_DIR}/src/chunk_adaptive.*" -print0 | xargs -0 -n1 "$(dirname ${0})/check_file_license.sh" ${1} } args=$(getopt "c:e:i:j:p:s:t:" "$@"); set -- $args ERRORCODE=0 while [[ ${1} ]]; do if [[ ${1} == "--" ]]; then break; fi check_file ${1} ${2} FILE_ERR=${?} ERRORCODE=$((FILE_ERR | ERRORCODE)); shift; shift; done exit ${ERRORCODE}; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/check_license_all.sh�����������������������������������������������������0000775�0000000�0000000�00000001000�15100345067�0021477�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash SCRIPT_DIR=$(dirname $0) BASE_DIR=$(dirname ${SCRIPT_DIR}) SRC_DIR=$BASE_DIR ${SCRIPT_DIR}/check_license.sh -c ${BASE_DIR}/src -s ${BASE_DIR}/sql -c ${BASE_DIR}/test -s ${BASE_DIR}/test -i ${BASE_DIR}/test exit_apache=$? SRC_DIR=$BASE_DIR ${SCRIPT_DIR}/check_license.sh -e ${BASE_DIR}/tsl/src -t ${BASE_DIR}/tsl/test -e ${BASE_DIR}/tsl/test -j ${BASE_DIR}/tsl/test -p ${BASE_DIR}/tsl/test -p ${BASE_DIR}/test/perl exit_tsl=$? if [ ${exit_apache} -ne 0 ] || [ ${exit_tsl} -ne 0 ]; then exit 1 fi timescaledb-2.23.0/scripts/check_missing_gitignore_for_template_tests.sh����������������������������0000775�0000000�0000000�00000000644�15100345067�0026745�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash ERROR=0 for FILE in $(git ls-files | grep '\.sql\.in') do DIRNAME=$(dirname "${FILE}") FILENAME=$(basename "${FILE}" .sql.in) GITIGNORE=${DIRNAME}/.gitignore if [ -f "${GITIGNORE}" ]; then if git ls-files --others --exclude-standard $DIRNAME | grep --silent "${FILENAME}-"; then echo "Missing entry in ${GITIGNORE} for template file ${FILE}" ERROR=1 fi fi done exit ${ERROR} ��������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/check_orphaned_test_output_files.sh��������������������������������������0000775�0000000�0000000�00000000767�15100345067�0024711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash ERROR=0 for FILE in $(git ls-files test/expected/*-[0-9][0-9].out tsl/test/expected/*-[0-9][0-9].out) do DIRNAME=$(dirname "${FILE}" | sed 's/expected/sql/g') TESTOUTPUTNAME=$(basename "${FILE}" .out | sed 's/-[0-9][0-9]//g') if [ ! -f "${DIRNAME}/${TESTOUTPUTNAME}.sql.in" ]; then echo "ERROR: template SQL test does not found: \"${DIRNAME}/${TESTOUTPUTNAME}.sql.in\"" echo "HINT: Please remove the output test file \"${FILE}\"" ERROR=1 fi done exit ${ERROR} ���������timescaledb-2.23.0/scripts/check_sql_script.py������������������������������������������������������0000664�0000000�0000000�00000007755�15100345067�0021452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python # Check SQL script components for problematic patterns. This script is # intended to be run on the scripts that are added to every update script, # but not the compiled update script or the pre_install scripts. # # This script will find patterns that are not idempotent and therefore # should be moved to the pre_install part. from pglast import parse_sql from pglast.visitors import Visitor, Skip, Continue from pglast.stream import RawStream import sys import re import argparse parser = argparse.ArgumentParser() parser.add_argument("filename", type=argparse.FileType("r"), nargs="+") args = parser.parse_args() class SQLVisitor(Visitor): def __init__(self, file): self.errors = 0 self.file = file super().__init__() def error(self, node, hint): self.errors += 1 print( f"Invalid statement found in sql script({self.file}):\n", RawStream()(node), ) print(hint, "\n") def visit_RawStmt(self, _ancestors, _node): # Statements are nested in RawStmt so we need to let the visitor descend return Continue def visit(self, _ancestors, node): self.error(node, "Consider moving the statement into a pre_install script") # We are only interested in checking top-level statements return Skip def visit_CommentStmt(self, _ancestors, _node): return Skip def visit_GrantStmt(self, _ancestors, _node): return Skip def visit_SelectStmt(self, _ancestors, _node): return Skip def visit_InsertStmt(self, _ancestors, _node): return Skip def visit_DeleteStmt(self, _ancestors, _node): return Skip def visit_DoStmt(self, _ancestors, _node): return Skip def visit_CreateEventTrigStmt(self, _ancestors, _node): return Skip def visit_CreateTrigStmt(self, _ancestors, node): if not node.replace: self.error(node, "Consider using CREATE OR REPLACE TRIGGER") return Skip def visit_DefineStmt(self, _ancestors, node): if not node.replace: self.error(node, "Consider using CREATE OR REPLACE") return Skip def visit_DropStmt(self, _ancestors, node): if not node.missing_ok: self.error(node, "Consider using DROP IF EXISTS") return Skip def visit_ViewStmt(self, _ancestors, node): if not node.replace: self.error(node, "Consider using CREATE OR REPLACE VIEW") return Skip def visit_CreateFunctionStmt(self, _ancestors, node): if not node.replace: fn_str = ("FUNCTION", "PROCEDURE")[node.is_procedure is True] self.error(node, f"Consider using CREATE OR REPLACE {fn_str}") return Skip # copied from pgspot def visit_sql(sql, file): # @extschema@ is placeholder in extension scripts for # the schema the extension gets installed in sql = sql.replace("@extschema@", "extschema") sql = sql.replace("@extowner@", "extowner") sql = sql.replace("@database_owner@", "database_owner") # postgres contrib modules are protected by psql meta commands to # prevent running extension files in psql. # The SQL parser will error on those since they are not valid # SQL, so we comment out all psql meta commands before parsing. sql = re.sub(r"^\\", "-- \\\\", sql, flags=re.MULTILINE) visitor = SQLVisitor(file) for stmt in parse_sql(sql): visitor(stmt) return visitor.errors def main(args): errors = 0 error_files = [] for file in args.filename: sql = file.read() result = visit_sql(sql, file.name) if result > 0: errors += result error_files.append(file.name) if errors > 0: numbering = "errors" if errors > 1 else "error" print( f"{errors} {numbering} detected in {len(error_files)} files({', '.join(error_files)})" ) sys.exit(1) sys.exit(0) if __name__ == "__main__": main(args) sys.exit(0) �������������������timescaledb-2.23.0/scripts/check_unnecessary_template_tests.sh��������������������������������������0000775�0000000�0000000�00000000746�15100345067�0024721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash ERROR=0 for FILE in $(git ls-files test/sql/*.sql.in tsl/test/sql/*.sql.in) do DIRNAME=$(dirname "${FILE}" | sed 's/sql/expected/g') TESTNAME=$(basename "${FILE}" .sql.in) if diff --from-file ${DIRNAME}/${TESTNAME}-*.out > /dev/null 2>&1; then echo "ERROR: all template output test files are equal: \"${DIRNAME}/${TESTNAME}-*.out\"" echo "HINT: Please turn template test file \"${FILE}\" into a regular test file" ERROR=1 fi done exit ${ERROR} ��������������������������timescaledb-2.23.0/scripts/check_unreferenced_files.sh����������������������������������������������0000775�0000000�0000000�00000001512�15100345067�0023064�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash SCRIPT_DIR=$(dirname ${0}) BASE_DIR=$(pwd)/$SCRIPT_DIR/.. unreferenced=0 function get_filenames { echo ./*.$2 ./*.$2.in | xargs git ls-files | xargs -IFILE basename FILE } function check_directory { cd $BASE_DIR/$1 || exit test_files=$(get_filenames $1 $2) for file in $test_files; do output=$(grep --files-without-match $file CMakeLists.txt) # return value from grep --files-without-match seems to differ # between grep versions so we use output instead of return value if [ "$output" != "" ]; then echo -e "\nUnreferenced file in $1: $file\n" unreferenced=1 fi done } check_directory test/sql sql check_directory tsl/test/sql sql check_directory tsl/test/shared/sql sql check_directory test/isolation/specs spec check_directory tsl/test/isolation/specs spec exit $unreferenced ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/check_updates.py���������������������������������������������������������0000664�0000000�0000000�00000021162�15100345067�0020720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python # Check SQL update script for undesirable patterns. This script is # intended to be run on the compiled update script or subsets of # the update script (e.g. latest-dev.sql and reverse-dev.sql) from pglast import parse_sql from pglast.ast import ColumnDef from pglast.visitors import Visitor from pglast import enums import sys import re import argparse parser = argparse.ArgumentParser() parser.add_argument("filename") parser.add_argument("--latest", action="store_true", help="process latest-dev.sql") args = parser.parse_args() class SQLVisitor(Visitor): def __init__(self): self.errors = 0 self.catalog_schemata = [ "_timescaledb_catalog", "_timescaledb_config", "_timescaledb_internal", ] super().__init__() def error(self, msg, hint=None): self.errors += 1 print(msg) if hint: print(hint) print() # ALTER TABLE _timescaledb_catalog.<tablename> ADD/DROP COLUMN def visit_AlterTableStmt(self, ancestors, node): # pylint: disable=unused-argument if ( "schemaname" in node.relation and node.relation.schemaname in self.catalog_schemata ): schema = node.relation.schemaname table = node.relation.relname for cmd in node.cmds: if cmd.subtype in ( enums.AlterTableType.AT_AddColumn, enums.AlterTableType.AT_DropColumn, ): if cmd.subtype == enums.AlterTableType.AT_AddColumn: subcmd = "ADD" column = cmd.def_.colname else: subcmd = "DROP" column = cmd.name self.error( f"Attempting to {subcmd} COLUMN {column} to catalog table {schema}.{table}", "Tables need to be rebuilt in update script to ensure consistent attribute numbers", ) # ALTER TABLE _timescaledb_catalog.<tablename> RENAME TO def visit_RenameStmt(self, ancestors, node): # pylint: disable=unused-argument if ( node.renameType == enums.ObjectType.OBJECT_TABLE and node.relation.schemaname in self.catalog_schemata ): self.error( f"Attempting to RENAME catalog table {node.relation.schemaname}.{node.relation.relname}", "Catalog tables should be rebuilt in update scripts to ensure consistent naming for dependent objects", ) # CREATE TEMP | TEMPORARY TABLE .. # CREATE TABLE IF NOT EXISTS .. def visit_CreateStmt(self, ancestors, node): # pylint: disable=unused-argument if node.relation.relpersistence == "t": schema = ( node.relation.schemaname + "." if node.relation.schemaname is not None else "" ) self.error( f"Attempting to CREATE TEMPORARY TABLE {schema}{node.relation.relname}" "Creating temporary tables is blocked in pg_extwlist context" ) if node.if_not_exists: self.error( f"Attempting to CREATE TABLE IF NOT EXISTS {node.relation.relname}" ) # We have to be careful with the column types we use in our catalog to only allow types # that are safe to use in catalog tables and not cause problems during extension upgrade, # pg_upgrade or dump/restore. if node.tableElts is not None: for coldef in node.tableElts: if isinstance(coldef, ColumnDef): if coldef.typeName.arrayBounds is not None: if coldef.typeName.names[-1].sval not in [ "bool", "text", ]: self.error( f"Attempting to CREATE TABLE {node.relation.relname} with blocked array type {coldef.typeName.names[-1].sval}" ) else: if coldef.typeName.names[-1].sval not in [ "bool", "int2", "int4", "int8", "interval", "jsonb", "name", "regclass", "regtype", "regrole", "serial", "text", "timestamptz", ]: self.error( f"Attempting to CREATE TABLE {node.relation.relname} with blocked type {coldef.typeName.names[-1].sval}" ) # CREATE SCHEMA IF NOT EXISTS .. def visit_CreateSchemaStmt( self, ancestors, node ): # pylint: disable=unused-argument if node.if_not_exists: self.error(f"Attempting to CREATE SCHEMA IF NOT EXISTS {node.schemaname}") # CREATE MATERIALIZED VIEW IF NOT EXISTS .. def visit_CreateTableAsStmt( self, ancestors, node ): # pylint: disable=unused-argument if node.if_not_exists: self.error( f"Attempting to CREATE MATERIALIZED VIEW IF NOT EXISTS {node.into.rel.relname}" ) # CREATE FOREIGN TABLE IF NOT EXISTS .. def visit_CreateForeignTableStmt( self, ancestors, node ): # pylint: disable=unused-argument if node.base.if_not_exists: self.error( f"Attempting to CREATE FOREIGN TABLE IF NOT EXISTS {node.base.relation.relname}" ) # CREATE INDEX IF NOT EXISTS .. def visit_IndexStmt(self, ancestors, node): # pylint: disable=unused-argument if node.if_not_exists: self.error(f"Attempting to CREATE INDEX IF NOT EXISTS {node.idxname}") # CREATE FUNCTION / PROCEDURE _timescaledb_internal... def visit_CreateFunctionStmt( self, ancestors, node ): # pylint: disable=unused-argument if args.latest: # C functions should only appear in actual function definition but not # in latest-dev.sql as that would introduce a dependency on the library. # In that case, we want to use a dedicated placeholder function. lang = [elem for elem in node.options if elem.defname == "language"] code = [elem for elem in node.options if elem.defname == "as"][0].arg if ( lang and lang[0].arg.sval == "c" and code[-1].sval != "ts_update_placeholder" and node.returnType.names[0].sval not in ["table_am_handler", "index_am_handler"] ): functype = "procedure" if node.is_procedure else "function" self.error( f"Attempting to create {functype} {node.funcname[-1].sval} with language 'c'", "latest-dev should link C functions to ts_update_placeholder", ) if len(node.funcname) == 2 and node.funcname[0].sval == "_timescaledb_internal": functype = "procedure" if node.is_procedure else "function" self.error( f"Attempting to create {functype} {node.funcname[1].sval} in the internal schema", "_timescaledb_functions should be used as schema for internal functions", ) # copied from pgspot def visit_sql(sql): # @extschema@ is placeholder in extension scripts for # the schema the extension gets installed in sql = sql.replace("@extschema@", "extschema") sql = sql.replace("@extowner@", "extowner") sql = sql.replace("@database_owner@", "database_owner") # postgres contrib modules are protected by psql meta commands to # prevent running extension files in psql. # The SQL parser will error on those since they are not valid # SQL, so we comment out all psql meta commands before parsing. sql = re.sub(r"^\\", "-- \\\\", sql, flags=re.MULTILINE) visitor = SQLVisitor() # try: for stmt in parse_sql(sql): visitor(stmt) return visitor.errors def main(args): file = args.filename with open(file, "r", encoding="utf-8") as f: sql = f.read() errors = visit_sql(sql) if errors > 0: numbering = "errors" if errors > 1 else "error" print(f"{errors} {numbering} detected in file {file}") sys.exit(1) sys.exit(0) if __name__ == "__main__": main(args) sys.exit(0) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/clang_format_all.sh������������������������������������������������������0000775�0000000�0000000�00000000723�15100345067�0021367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash # we need to convert script dir to an absolute path SCRIPT_DIR=$(cd "$(dirname $0)" || exit; pwd) BASE_DIR=$(dirname $SCRIPT_DIR) find ${BASE_DIR} \( -path "${BASE_DIR}/src/*" -or -path "${BASE_DIR}/test/*" -or -path "${BASE_DIR}/tsl/*" \) \ -and -not \( -path "*/.*" -or -path "*CMake*" -or -path "${BASE_DIR}/tsl/src/import/*" \) \ -and \( -name '*.c' -or -name '*.h' \) -print0 | xargs -0 ${SCRIPT_DIR}/clang_format_wrapper.sh -style=file -i ���������������������������������������������timescaledb-2.23.0/scripts/clang_format_wrapper.sh��������������������������������������������������0000775�0000000�0000000�00000004144�15100345067�0022300�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash # clang-format misunderstand sql function written in C because they have the signature # Datum my_func(PG_FUNCTION_ARGS) # and clang-format does not interpret PG_FUNCTION_ARGS as a type, name pair. # This script replaces PG_FUNCTION_ARGS with "PG_FUNCTION_ARGS fake_var_for_clang" to # make it look like a proper function for clang and then converts it back after clang runs. SCRIPT_DIR=$(cd "$(dirname $0)"; pwd) BASE_DIR=$(dirname $SCRIPT_DIR) TEMP_DIR="/tmp/timescaledb_format" OPTIONS=("${@}") if [ -e ${TEMP_DIR} ] then echo "error: ${TEMP_DIR} already exists" echo " delete ${TEMP_DIR} to format" exit 1 fi # shellcheck disable=SC2317 cleanup() { echo "cleaning" rm -rf ${TEMP_DIR} } trap cleanup EXIT SIGINT SIGTERM if ! mkdir ${TEMP_DIR} then echo "error: could not create temporary directory ${TEMP_DIR}" exit 1 fi #from this point on, if we get a failure we end up in an invalid state, so exit set -e CLANG_FORMAT_FLAGS="" FILE_NAMES="" for opt in "${OPTIONS[@]}" do if [[ "${opt:0:1}" != "-" ]] then file_path=${opt#"$BASE_DIR/"} FILE_NAMES="${FILE_NAMES} $file_path" else CLANG_FORMAT_FLAGS="${CLANG_FORMAT_FLAGS} $opt" fi done echo "copying to ${TEMP_DIR}" for name in ${FILE_NAMES} do # sed -i have different semantics on mac and linux, don't use mkdir -p "$(dirname "${TEMP_DIR}/${name}")" sed -e 's/(PG_FUNCTION_ARGS)/(PG_FUNCTION_ARGS fake_var_for_clang)/' ${BASE_DIR}/${name} > ${TEMP_DIR}/${name} done cp ${BASE_DIR}/.clang-format ${TEMP_DIR}/.clang-format CURR_DIR=${PWD} echo "formatting" cd ${TEMP_DIR} ${CLANG_FORMAT:-clang-format} --version ${CLANG_FORMAT:-clang-format} -Wno-error=unknown ${CLANG_FORMAT_FLAGS} ${FILE_NAMES} cd ${CURR_DIR} echo "copying back" for name in ${FILE_NAMES} do if sed -e 's/PG_FUNCTION_ARGS fake_var_for_clang/PG_FUNCTION_ARGS/' ${TEMP_DIR}/${name} > ${TEMP_DIR}/replace_file; then if ! cmp -s ${TEMP_DIR}/replace_file ${BASE_DIR}/${name}; then echo "Updating ${BASE_DIR}/${name}" mv ${TEMP_DIR}/replace_file ${BASE_DIR}/${name} fi fi done exit 0 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/cmake_format_all.sh������������������������������������������������������0000775�0000000�0000000�00000000360�15100345067�0021360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash SCRIPTDIR=$(cd "$(dirname $0)" || exit; pwd) BASEDIR=$(dirname $SCRIPTDIR) find $BASEDIR -name CMakeLists.txt -exec cmake-format -i {} + find $BASEDIR/src $BASEDIR/test $BASEDIR/tsl -name '*.cmake' -exec cmake-format -i {} + ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/coccinelle.sh������������������������������������������������������������0000775�0000000�0000000�00000000573�15100345067�0020206�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -o pipefail SCRIPT_DIR=$(dirname "${0}") FAILED=false true > coccinelle.diff for f in "${SCRIPT_DIR}"/../coccinelle/*.cocci; do spatch --very-quiet --include-headers --sp-file "$f" --dir "${SCRIPT_DIR}"/.. | tee -a coccinelle.diff rc=$? if [ $rc -ne 0 ]; then FAILED=true fi done if [ $FAILED = true ] || [ -s coccinelle.diff ] ; then exit 1; fi �������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/delete_released_change_logs.sh�������������������������������������������0000775�0000000�0000000�00000000640�15100345067�0023540�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash # Check if both old_version and new_version have been provided if [[ -z "$1" || -z "$2" ]]; then echo "Usage: $0 <old_version> <new_version>" exit 1 fi # Assign the values to variables for easier use later OLD_VERSION="$1" NEW_VERSION="$2" # Run git diff and remove the listed files git diff --name-only "$OLD_VERSION" "$NEW_VERSION" .unreleased | grep -v '.unreleased/template.rfc822' | xargs rm ������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/docker-build.sh����������������������������������������������������������0000775�0000000�0000000�00000007504�15100345067�0020453�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # # This script builds a development TimescaleDB image from the # currently checked out source on the host. # SCRIPT_DIR=$(dirname $0) BASE_DIR=${PWD}/${SCRIPT_DIR}/.. PG_VERSION=${PG_VERSION:-17.4} PG_IMAGE_TAG=${PG_IMAGE_TAG:-${PG_VERSION}-alpine} BUILD_CONTAINER_NAME=${BUILD_CONTAINER_NAME:-pgbuild} BUILD_IMAGE_NAME=${BUILD_IMAGE_NAME:-$USER/pgbuild} IMAGE_NAME=${IMAGE_NAME:-$USER/timescaledb} GIT_ID=$(git -C ${BASE_DIR} describe --dirty --always | sed -e "s|/|_|g") TAG_NAME=${TAG_NAME:-$GIT_ID} BUILD_TYPE=${BUILD_TYPE:-Release} USE_OPENSSL=${USE_OPENSSL:-true} PUSH_PG_IMAGE=${PUSH_PG_IMAGE:-false} GENERATE_DOWNGRADE_SCRIPT=${GENERATE_DOWNGRADE_SCRIPT:-OFF} # Full image identifiers PG_IMAGE=${BUILD_IMAGE_NAME}:${PG_IMAGE_TAG} TS_IMAGE=${IMAGE_NAME}:${TAG_NAME} trap remove_build_container EXIT image_exists() { [[ $(docker image ls -f "reference=$1" -q) ]] } postgres_build_image_exists() { image_exists ${PG_IMAGE} } timescaledb_image_exists() { image_exists ${TS_IMAGE} } remove_build_container() { local container=${1:-${BUILD_CONTAINER_NAME}} docker rm -vf "$(docker ps -a -q -f name=${container} 2>/dev/null)" 2>/dev/null } fetch_postgres_build_image() { local image=${1:-${PG_IMAGE}} docker pull ${image} } create_postgres_build_image() { local image=${1:-${PG_IMAGE}} echo "Creating new PostgreSQL build image ${image}" # Run a Postgres container docker run -d --name ${BUILD_CONTAINER_NAME} --env POSTGRES_HOST_AUTH_METHOD=trust -v ${BASE_DIR}:/src postgres:${PG_IMAGE_TAG} # Install build dependencies docker exec -u root ${BUILD_CONTAINER_NAME} /bin/bash -c "apk add --no-cache --virtual .build-deps postgresql-dev gdb coreutils dpkg-dev gcc git libc-dev make cmake util-linux-dev diffutils libssl3 openssl-dev krb5-dev && mkdir -p /build/debug" docker commit -a $USER -m "TimescaleDB build base image version $PG_IMAGE_TAG" ${BUILD_CONTAINER_NAME} ${image} remove_build_container ${BUILD_CONTAINER_NAME} if ${PUSH_PG_IMAGE}; then docker push ${image} fi } run_postgres_build_image() { local image=${1:-${PG_IMAGE}} echo "Starting image ${image}" docker run -d --name ${BUILD_CONTAINER_NAME} -v ${BASE_DIR}:/src ${image} } build_timescaledb() { echo "Building TimescaleDB image \"${TS_IMAGE}\" with USE_OPENSSL=${USE_OPENSSL} BUILD_TYPE=${BUILD_TYPE}" run_postgres_build_image ${PG_IMAGE} # Build and install the extension with debug symbols and assertions tar -c -C ${BASE_DIR} {cmake,src,sql,test,scripts,tsl,version.config,CMakeLists.txt,timescaledb.control.in} | docker cp - ${BUILD_CONTAINER_NAME}:/build/ if ! docker exec -u root ${BUILD_CONTAINER_NAME} /bin/bash -c " \ cd /build/debug \ && git config --global --add safe.directory /src \ && cmake -DGENERATE_DOWNGRADE_SCRIPT=${GENERATE_DOWNGRADE_SCRIPT} -DUSE_OPENSSL=${USE_OPENSSL} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} /src \ && make -j $(nproc) && make install \ && echo \"shared_preload_libraries = 'timescaledb'\" >> /usr/local/share/postgresql/postgresql.conf.sample \ && echo \"timescaledb.telemetry_level=off\" >> /usr/local/share/postgresql/postgresql.conf.sample \ && cd / && rm -rf /build" then echo "Building timescaledb failed" return 1 fi docker commit -a $USER -m "TimescaleDB development image" ${BUILD_CONTAINER_NAME} ${TS_IMAGE} } message_and_exit() { echo echo "Run 'docker run -d --name some-timescaledb -p 5432:5432 ${TS_IMAGE}' to launch" exit } remove_build_container if timescaledb_image_exists; then echo "Image \"${TS_IMAGE}\" already exists." message_and_exit fi if ! postgres_build_image_exists; then if ! fetch_postgres_build_image "$@"; then create_postgres_build_image "$@" || exit 1 fi fi build_timescaledb || exit 1 message_and_exit ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/docker-run-tests.sh������������������������������������������������������0000775�0000000�0000000�00000003116�15100345067�0021313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # # This script runs the TimescaleDB tests through a standard PostgreSQL # container, first installing the extension via a mounted host volume. # SCRIPT_DIR=$(dirname $0) BASE_DIR=${PWD}/${SCRIPT_DIR}/.. PG_IMAGE_TAG=${PG_IMAGE_TAG:-12.0-alpine} CONTAINER_NAME=${CONTAINER_NAME:-pgtest} case $1 in clean) docker rm -f "$(docker ps -a -q -f name=${CONTAINER_NAME} 2>/dev/null)" 2>/dev/null ;; esac if [ "$(docker ps -q -f name=${CONTAINER_NAME} 2>/dev/null | wc -l)" == "0" ]; then echo "Creating container ${CONTAINER_NAME}" docker rm ${CONTAINER_NAME} 2>/dev/null # Run a Postgres container docker run -u postgres -d --name ${CONTAINER_NAME} -v ${BASE_DIR}:/src postgres:${PG_IMAGE_TAG} # Install build dependencies docker exec -u root -it ${CONTAINER_NAME} /bin/bash -c "apk add --no-cache --virtual .build-deps coreutils dpkg-dev gcc libc-dev make util-linux-dev diffutils cmake bison flex && mkdir -p /build/debug" fi # Copy the source files to build directory docker exec -u root -it ${CONTAINER_NAME} /bin/bash -c "cp -a /src/{src,sql,scripts,test,tsl,CMakeLists.txt,timescaledb.control.in,version.config} /build/ &&cd /build/debug/ && CFLAGS=-Werror cmake .. -DCMAKE_BUILD_TYPE=Debug && make -C /build/debug install && chown -R postgres /build/debug" # Run tests if ! docker exec -u postgres -it ${CONTAINER_NAME} /bin/bash -c "make -C /build/debug installcheck TEST_INSTANCE_OPTS='--temp-instance=/tmp/pgdata --temp-config=/build/test/postgresql.conf'" then docker exec -it ${CONTAINER_NAME} cat /build/debug/test/regression.diffs fi ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/dump_meta_data.sql�������������������������������������������������������0000664�0000000�0000000�00000012651�15100345067�0021234�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- -- This file is licensed under the Apache License, see LICENSE-APACHE -- at the top level directory of the TimescaleDB distribution. -- This script will dump relevant meta data from internal TimescaleDB tables -- that can help our engineers trouble shoot. -- -- usage: -- psql [your connect flags] -d your_timescale_db < dump_meta_data.sql > dumpfile.txt \echo 'TimescaleDB meta data dump' \echo '<exclude_from_test>' \echo 'Date, git commit, and extension version can change without it being an error.' \echo 'Adding this tag allows us to run regression tests on this script file.' select now(); \echo 'Postgres version' select version(); \echo 'Build tag' \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_internal.get_git_commit(); \set ON_ERROR_STOP 1 \dx \echo '</exclude_from_test>' \echo 'List of tables' SELECT n.nspname as "Schema", c.relname as "Name", CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 't' THEN 'TOAST table' WHEN 'f' THEN 'foreign table' WHEN 'p' THEN 'partitioned table' WHEN 'I' THEN 'partitioned index' END as "Type", pg_catalog.pg_get_userbyid(c.relowner) as "Owner" FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam WHERE c.relkind IN ('r','p','') AND n.nspname <> 'pg_catalog' AND n.nspname !~ '^pg_toast' AND n.nspname <> 'information_schema' AND pg_catalog.pg_table_is_visible(c.oid) ORDER BY 1,2; \echo 'List of hypertables' SELECT * FROM _timescaledb_catalog.hypertable; \echo 'List of chunk indexes' SELECT ch.id AS chunk_id, ci.indexrelid::regclass::text AS index_name, h.id AS hypertable_id FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = h.id JOIN pg_index ci ON ci.indrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass ORDER BY h.id, ch.id, ci.indrelid::regclass::text; \echo 'Size of hypertables' SELECT hypertable, table_bytes, index_bytes, toast_bytes, total_bytes FROM ( SELECT *, total_bytes-index_bytes-COALESCE(toast_bytes,0) AS table_bytes FROM ( SELECT pgc.oid::regclass::text as hypertable, sum(pg_total_relation_size('"' || c.schema_name || '"."' || c.table_name || '"'))::bigint as total_bytes, sum(pg_indexes_size('"' || c.schema_name || '"."' || c.table_name || '"'))::bigint AS index_bytes, sum(pg_total_relation_size(reltoastrelid))::bigint AS toast_bytes FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c, pg_class pgc, pg_namespace pns WHERE c.hypertable_id = h.id AND pgc.relname = h.table_name AND pns.oid = pgc.relnamespace AND pns.nspname = h.schema_name AND relkind = 'r' AND c.dropped is false GROUP BY pgc.oid ) sub1 ) sub2; \echo 'Chunk sizes:' SELECT chunk_id, chunk_table, partitioning_columns, partitioning_column_types, partitioning_hash_functions, ranges, table_bytes, index_bytes, toast_bytes, total_bytes FROM ( SELECT *, total_bytes-index_bytes-COALESCE(toast_bytes,0) AS table_bytes FROM ( SELECT c.id as chunk_id, '"' || c.schema_name || '"."' || c.table_name || '"' as chunk_table, pg_total_relation_size('"' || c.schema_name || '"."' || c.table_name || '"') AS total_bytes, pg_indexes_size('"' || c.schema_name || '"."' || c.table_name || '"') AS index_bytes, pg_total_relation_size(reltoastrelid) AS toast_bytes, array_agg(d.column_name ORDER BY d.interval_length, d.column_name ASC) as partitioning_columns, array_agg(d.column_type ORDER BY d.interval_length, d.column_name ASC) as partitioning_column_types, array_agg(d.partitioning_func_schema || '.' || d.partitioning_func ORDER BY d.interval_length, d.column_name ASC) as partitioning_hash_functions, array_agg('[' || _timescaledb_functions.range_value_to_pretty(range_start, column_type) || ',' || _timescaledb_functions.range_value_to_pretty(range_end, column_type) || ')' ORDER BY d.interval_length, d.column_name ASC) as ranges FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension d, _timescaledb_catalog.dimension_slice ds, pg_class pgc, pg_namespace pns WHERE pgc.relname = h.table_name AND pns.oid = pgc.relnamespace AND pns.nspname = h.schema_name AND relkind = 'r' AND c.hypertable_id = h.id AND c.id = cc.chunk_id AND cc.dimension_slice_id = ds.id AND ds.dimension_id = d.id AND c.dropped is false GROUP BY c.id, pgc.reltoastrelid, pgc.oid ORDER BY c.id ) sub1 ) sub2; \echo 'Hypertable index sizes' SET search_path TO pg_catalog, pg_temp; SELECT i.indrelid::regclass AS hypertable, i.indexrelid::regclass AS index_name, public.hypertable_index_size(i.indexrelid::regclass) AS index_bytes FROM _timescaledb_catalog.hypertable h JOIN pg_index i ON i.indrelid = format('%I.%I',h.schema_name,h.table_name)::regclass ORDER BY i.indrelid::regclass::text, i.indexrelid::regclass::text; RESET search_path; ���������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/export_prefix_check.sh.in������������������������������������������������0000775�0000000�0000000�00000005771�15100345067�0022553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash if [ ! -x "@NM@" ]; then echo "Cannot check export format because nm is not installed" >&2 exit 1 fi DEFINED_ONLY="--defined-only" EXTERN_ONLY="--extern-only" if nm --help | grep -q ' \-defined\-only'; then # The flag can be either --defined-only or -defined-only # depending on nm-llvm version. If there is " -defined-only" # string in the --help output, we assume this is the right # way to specify the flag. DEFINED_ONLY="-defined-only" EXTERN_ONLY="-extern-only" fi # this script outputs all symbols not starting with an allowed prefix # exported symbols are allowed to start with # ts_ for regular timescaledb functions # pg_finfo for metadata defined by PG_FUNCTION_INFO_V1 # we also whitelist a couple of special symbols # _.*_init module startup functions # _.*_fini module shutdown functions # Pg_magic_func used by postgres to check extension compatibility # timescaledb_hello used to test that our name collision resistance works # loader_hello used to test that our name collision resistance works # test_symbol_conflict used to test that our name collision resistance works # tsl_license_update_check used to check for valid license # __sanitizer.* __sancov.* llvm sanitizer # _ZN11__sanitizer.* llvm sanitizer # __asan.* __odr_asan.* address sanitizer # __ubsan.* _ZN7__ubsan.* undefined behaviour sanitizer # internal_sigreturn gcc # OnPrint gcc # backtrace_uncompress_zdebug libbacktrace # reset_fn_list used by llvm code coverage infrastructure # all of these symbols start with an additional leading '_' on macos exports=$(find @CMAKE_BINARY_DIR@ -not -path '*/\.*' -name '*.so' -print0 \ | xargs -0 @NM@ ${DEFINED_ONLY} ${EXTERN_ONLY} \ | sed -e 's:^/.*$::' -e '/^$/d' -e 's/^[a-f0-9]* [A-Za-z] //' \ | grep -v \ -e '^_\?__gcov_' \ -e '^__bss_start$' \ -e '^_edata$' \ -e '^_end$' \ -e '^_fini$' \ -e '^_init$' \ -e '^_\?flush_fn_list$' \ -e '^_\?writeout_fn_list$' \ -e '^_\?lprofDirMode$' \ -e '^_\?mangle_path$' \ -e '^_\?ts_' \ -e '^_\?tsl_license_update_check$' \ -e '^_\?pg_finfo' \ -e '^_\?_.*_init$' \ -e '^_\?_.*_fini$' \ -e '^_\?Pg_magic_func$' \ -e '^_\?timescaledb_' \ -e '^_\?loader_hello$' \ -e '^_\?test_symbol_conflict$' \ -e '^_\?__sanitizer' \ -e '^_\?__sancov' \ -e '^_\?__asan' \ -e '^_\?__odr_asan' \ -e '^_\?__ubsan' \ -e '^_\?_ZN7__ubsan' \ -e '^_\?_ZN11__sanitizer' \ -e '^_\?internal_sigreturn$' \ -e '^_\?OnPrint$' \ -e '^_\?backtrace_uncompress_zdebug$' \ -e '^reset_fn_list$' \ ) num_exports=$(echo "${exports}" | grep -v '^$' -c) echo "${exports}" if [ ${num_exports} -gt 0 ]; then exit 1 else exit 0 fi �������timescaledb-2.23.0/scripts/githooks/����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017371�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/githooks/.gitignore������������������������������������������������������0000664�0000000�0000000�00000000030�15100345067�0021352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/__pycache__/ /*.pyc /*~��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/githooks/commit_msg.py���������������������������������������������������0000775�0000000�0000000�00000014072�15100345067�0022110�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 # Check a Git commit message according to the seven rules of a good commit message: # https://chris.beams.io/posts/git-commit/ import sys class GitCommitMessage: "Represents a parsed Git commit message" rules = [ "Separate subject from body with a blank line", "Limit the subject line to 50 characters", "Capitalize the subject line", "Do not end the subject line with a period", "Use the imperative mood in the subject line", "Wrap the body at 72 characters", "Use the body to explain what and why vs. how", ] valid_rules = [False, False, False, False, False, False, False] def __init__(self, filename=None): lines = [] if filename is not None: with open(filename, "r", encoding="utf-8") as f: for line in f: if line.startswith( "# ------------------------ >8 ------------------------" ): break if not line.startswith("#"): lines.append(line) self.parse_lines(lines) def parse_lines(self, lines): self.body_lines = [] self.subject = [] if not lines or len(lines) == 0: return self self.subject = lines[0] self.subject_words = self.subject.split() self.has_subject_body_separator = False if len(lines) > 1: self.has_subject_body_separator = len(lines[1].strip()) == 0 if self.has_subject_body_separator: self.body_lines = lines[2:] else: self.body_lines = lines[1:] return self def check_subject_body_separtor(self): "Rule 1: Separate subject from body with a blank line" if len(self.body_lines) > 0: return self.has_subject_body_separator return True def check_subject_limit(self): "Rule 2: Limit the subject line to 50 characters" return len(self.subject.rstrip("\n")) <= 50 def check_subject_capitalized(self): "Rule 3: Capitalize the subject line" return len(self.subject) > 0 and self.subject[0].isupper() def check_subject_no_period(self): "Rule 4: Do not end the subject line with a period" return not self.subject.endswith(".") common_first_words = [ "Add", "Adjust", "Support", "Change", "Remove", "Fix", "Print", "Track", "Refactor", "Combine", "Release", "Set", "Stop", "Make", "Mark", "Enable", "Check", "Exclude", "Format", "Correct", ] def check_subject_imperative(self): """Rule 5: Use the imperative mood in the subject line. We can only check for common mistakes here, like using the -ing form of a verb or non-imperative version of common verbs """ firstword = self.subject_words[0] if firstword.endswith("ing"): return False for word in self.common_first_words: if firstword.startswith(word) and firstword != word: return False return True def check_body_limit(self): "Rule 6: Wrap the body at 72 characters" if len(self.body_lines) == 0: return True for line in self.body_lines: if len(line.rstrip("\n")) > 72: return False return True def check_body_uses_why(self): "Rule 7: Use the body to explain what and why vs. how" # Not enforceable return True rule_funcs = [ check_subject_body_separtor, check_subject_limit, check_subject_capitalized, check_subject_no_period, check_subject_imperative, check_body_limit, check_body_uses_why, ] def check_the_seven_rules(self): "validates the commit message against the seven rules" num_violations = 0 for i, func in enumerate(self.rule_funcs): res = func(self) self.valid_rules[i] = res if not res: num_violations += 1 if num_violations > 0: print() print("**** WARNING ****") print() print( "The commit message does not seem to comply with the project's guidelines." ) print('Please try to follow the "Seven rules of a great commit message":') print("https://chris.beams.io/posts/git-commit/") print() print("The following rules are violated:\n") for i in range(len(self.rule_funcs)): if not self.valid_rules[i]: print(f'\t* Rule {i+1}: "{self.rules[i]}"') # Extra sanity checks beyond the seven rules if len(self.body_lines) == 0: print() print("NOTE: the commit message has no body.") print("It is recommended to add a body with a description of your") print( "changes, even if they are small. Explain what and why instead of how:" ) print("https://chris.beams.io/posts/git-commit/#why-not-how") if len(self.subject_words) < 3: print() print("Warning: the subject line has less than three words.") print("Consider using a more explanatory subject line.") if num_violations > 0: print() print("Run 'git commit --amend' to change the commit message") print() return num_violations def main(): if len(sys.argv) != 2: print("Unexpected number of arguments") sys.exit(1) msg = GitCommitMessage(sys.argv[1]) return msg.check_the_seven_rules() if __name__ == "__main__": main() # Always exit with success. We could also fail the commit if with # a non-zero exit code, but that might be a bit excessive and we'd # have to save the failed commit message to a file so that it can # be recovered. sys.exit(0) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/githooks/commit_msg_tests.py���������������������������������������������0000775�0000000�0000000�00000007531�15100345067�0023334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 import unittest from commit_msg import GitCommitMessage class TestCommitMsg(unittest.TestCase): def testNoInput(self): m = GitCommitMessage().parse_lines([]) self.assertEqual(len(m.body_lines), 0) m = GitCommitMessage().parse_lines(None) self.assertEqual(len(m.body_lines), 0) def testParsing(self): m = GitCommitMessage().parse_lines( ["This is a subject line", " ", "body line 1", "body line 2"] ) self.assertEqual(m.subject, "This is a subject line") self.assertTrue(m.has_subject_body_separator) self.assertEqual(m.body_lines[0], "body line 1") self.assertEqual(m.body_lines[1], "body line 2") def testNonImperative(self): m = GitCommitMessage().parse_lines(["Adds new file"]) self.assertFalse(m.check_subject_imperative()) m.parse_lines(["Adding new file"]) self.assertFalse(m.check_subject_imperative()) # Default to accept m.parse_lines(["Foo bar"]) self.assertTrue(m.check_subject_imperative()) def testSubjectBodySeparator(self): m = GitCommitMessage().parse_lines(["This is a subject line"]) self.assertTrue(m.check_subject_body_separtor()) m = GitCommitMessage().parse_lines(["This is a subject line", "body"]) self.assertFalse(m.check_subject_body_separtor()) m = GitCommitMessage().parse_lines(["This is a subject line", "", "body"]) self.assertTrue(m.check_subject_body_separtor()) m = GitCommitMessage().parse_lines(["This is a subject line", " ", "body"]) self.assertTrue(m.check_subject_body_separtor()) def testSubjectLimit(self): m = GitCommitMessage().parse_lines( ["This subject line is exactly 48 characters long"] ) self.assertTrue(m.check_subject_limit()) m = GitCommitMessage().parse_lines( ["This is a very long subject line that will obviously exceed the limit"] ) self.assertFalse(m.check_subject_limit()) m = GitCommitMessage().parse_lines( ["This 50-character subject line ends with an LF EOL\n"] ) self.assertTrue(m.check_subject_limit()) def testSubjectCapitalized(self): m = GitCommitMessage().parse_lines(["This subject line is capitalized"]) self.assertTrue(m.check_subject_capitalized()) m = GitCommitMessage().parse_lines(["this subject line is not capitalized"]) self.assertFalse(m.check_subject_capitalized()) def testSubjectNoPeriod(self): m = GitCommitMessage().parse_lines(["This subject line ends with a period."]) self.assertFalse(m.check_subject_no_period()) m = GitCommitMessage().parse_lines( ["This subject line does not end with a period"] ) self.assertTrue(m.check_subject_no_period()) def testBodyLimit(self): m = GitCommitMessage().parse_lines( ["This is a subject line", " ", "A short body line"] ) self.assertTrue(m.check_body_limit()) m = GitCommitMessage().parse_lines( [ "This is a subject line", " ", "A very long body line which certainly exceeds the 72 char recommended limit", ] ) self.assertFalse(m.check_body_limit()) m = GitCommitMessage().parse_lines( [ "This is a subject line", " ", "A body line with exactly 72 characters, followed by an EOL (Unix-style).\n", ] ) self.assertTrue(m.check_body_limit()) def testCheckAllRules(self): m = GitCommitMessage().parse_lines( ["This is a subject line", "", "A short body line"] ) self.assertEqual(0, m.check_the_seven_rules()) if __name__ == "__main__": unittest.main() �����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/label-released.py��������������������������������������������������������0000775�0000000�0000000�00000020726�15100345067�0020767�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 """ Look at commits between the given release and the previous one, and label all PRs that made these commits with the "released-..." label. """ import os import sys import argparse import re import subprocess import requests import github # This is PyGithub. import more_itertools OWNER = "timescale" REPO = "timescaledb" TOKEN = os.environ.get("GH_TOKEN") if not TOKEN: print("Specify the GitHub token in GH_TOKEN environment variable.", file=sys.stderr) sys.exit(1) def git_check(cmd: str): subprocess.run(f"git {cmd}", shell=True, check=True) def git_output(cmd: str) -> str: return subprocess.check_output(f"git {cmd}", shell=True, text=True).strip() def run_query(query, params): """A simple function to use requests.post to make the GraphQL API call.""" request = requests.post( "https://api.github.com/graphql", json={"query": query, "variables": params}, headers={"Authorization": f"Bearer {TOKEN}"} if TOKEN else None, timeout=20, ) response = request.json() # Have to work around the unique GraphQL convention of returning 200 for errors. if request.status_code != 200 or "errors" in response: raise ValueError( f"Query failed to run by returning code of {request.status_code}." f"\nQuery: '{query}'" f"\nResponse: '{request.json()}'" ) return response["data"] parser = argparse.ArgumentParser() parser.add_argument("--release", required=True, help="Tag to process, e.g. 2.20.0") parser.add_argument("--dry-run", action="store_true") args = parser.parse_args() target_tag = args.release dry_run = args.dry_run # Create the label if needed gh = github.Github(TOKEN) repo = gh.get_repo(f"{OWNER}/{REPO}") label_name = f"released-{target_tag}" try: pygithub_label = repo.get_label(label_name) label_id = pygithub_label.raw_data["node_id"] except github.UnknownObjectException: if not args.dry_run: pygithub_label = repo.create_label( label_name, "d3d3d3", f"Released in {target_tag}" ) label_id = pygithub_label.raw_data["node_id"] else: label_id = "<dry run>" print(f"Label will be: {label_name}") # Make sure the branches are present in the repository git_check("fetch --depth=1000 origin main:refs/remotes/origin/main") git_check(f"fetch --depth=1000 origin tag {target_tag}") # Read the previous release from version.config. try: cfg = git_output(f"show {target_tag}:version.config") except subprocess.CalledProcessError: sys.exit(f"Error: cannot read version.config at '{target_tag}'") m = re.search(r"^(?:previous_version|update_from_version)\s*=\s*(\S+)", cfg, re.M) if not m: sys.exit("Error: version.config missing previous_version/update_from_version") prev_tag = m.group(1) git_check(f"fetch --depth=1000 origin tag {prev_tag}") print(f"Comparing tags: {prev_tag} → {target_tag}") if dry_run: print("[dry-run] no changes will be made") def fetch_commits_with_prs(starting_commit, cutoff_date): """ Fetch the commits starting from the given one until the cutoff date, with the associated PRs, using paginated GraphQL request. """ GQL_COMMITS = """ query CommitsWithPRs( $owner: String!, $repo: String!, $expr: String!, $since: GitTimestamp!, $first: Int!, $after: String ) { repository(owner:$owner,name:$repo) { object(expression:$expr) { ... on Commit { history(first:$first, since:$since, after:$after) { pageInfo { hasNextPage endCursor } nodes { oid messageHeadline # We only handle the commits with one PR, so fetch at most two. associatedPullRequests(first:2) { nodes { id number title baseRefName } } } } } } } } """ nodes = [] after = None while True: params = { "owner": OWNER, "repo": REPO, "expr": starting_commit, "since": cutoff_date, "first": 100, "after": after, } hist = run_query(GQL_COMMITS, params)["repository"]["object"]["history"] nodes.extend(hist["nodes"]) page_info = hist["pageInfo"] if not page_info["hasNextPage"]: break after = page_info["endCursor"] print("Fetching next page...") print(f"Fetched {len(nodes)} commits with PR info starting from {starting_commit}") return nodes target_release = git_output(f"rev-parse {target_tag}^0") print(f"Target release commit {git_output(f'log -1 --oneline {target_release}')}") prev_release = git_output(f"rev-parse {prev_tag}^0") print(f"Prev release commit {git_output(f'log -1 --oneline {prev_release}')}") prev_release_fork_sha = git_output(f"merge-base {target_release} {prev_release}") print( f"Prev release fork point {git_output(f'log -1 --oneline {prev_release_fork_sha}')}" ) prev_release_fork_date = git_output(f"show -s --format=%cI {prev_release_fork_sha}") print(f"Prev release fork date {prev_release_fork_date}") main_fork_sha = git_output(f"merge-base {target_release} origin/main") print(f"Main fork point {git_output(f'log -1 --oneline {main_fork_sha}')}") main_fork_date = git_output(f"show -s --format=%cI {main_fork_sha}") print(f"Main fork date {main_fork_date}") # This is the relationship between the various refs we've built above: # For a patch release: # (current release branch) -(backports)---prev_release_fork_sha---target_release---> # / ^ ^ ^ # (main) >----main_fork_sha----------------> # # For a minor release: # (prev release branch) prev_release--> # / # (current release branch) / -(backports)-target_release--> # / / ^ ^ ^ # (main) >-prev_release_fork_sha---main_fork_sha---------------> # # We can't use the commit SHAs for the commit lookups due to API limitations, so # we use the dates instead. # Now, perform the lookups for release branch commits and the potentially # backported main commits with the respective PRs. branch_commit_nodes = fetch_commits_with_prs(target_release, prev_release_fork_date) main_commit_nodes = fetch_commits_with_prs("main", main_fork_date) # We're going to match the commits by title to account for backports. main_commit_title_to_pr = { node["messageHeadline"]: prs[0] for node in main_commit_nodes if (prs := node["associatedPullRequests"]["nodes"]) and len(prs) == 1 } print(f"On main ({len(main_commit_title_to_pr)} PRs):") print( "\n".join( [ f'#{pr["number"]}: {pr["title"]} <- {title}' for title, pr in main_commit_title_to_pr.items() ] ) ) print() branch_commit_title_to_pr = { node["messageHeadline"]: prs[0] for node in branch_commit_nodes if (prs := node["associatedPullRequests"]["nodes"]) and len(prs) == 1 } print(f"On branch ({len(branch_commit_title_to_pr)} PRs):") print( "\n".join( [ f'#{pr["number"]}: {pr["title"]} <- {title}' for title, pr in branch_commit_title_to_pr.items() ] ) ) print() # The commits with same titles in main and release branch, but with different PRs, # are backported commits. We have to label the PR to main in that case, and not # the backport PR. backported_titles = { title: pr for title, pr in main_commit_title_to_pr.items() if title in branch_commit_title_to_pr and pr["number"] != branch_commit_title_to_pr[title]["number"] } print(f"Backported ({len(backported_titles)} PRs):") print( "\n".join([f'#{pr["number"]}: {pr["title"]}' for pr in backported_titles.values()]) ) print() branch_commit_title_to_pr.update(backported_titles) print(f"To label as {label_name} ({len(branch_commit_title_to_pr)} PRs):") print( "\n".join( [f'#{pr["number"]}: {pr["title"]}' for pr in branch_commit_title_to_pr.values()] ) ) print() # Label the PRs in bulk using GraphQL. ids = list({pr["id"] for pr in branch_commit_title_to_pr.values()}) for chunk in more_itertools.chunked(ids, 20): parts = [ f'p{j}: addLabelsToLabelable(input: {{labelableId:"{nid}",labelIds:["{label_id}"]}}) {{ clientMutationId }}' for j, nid in enumerate(chunk) ] gql = "mutation BulkLabel {\n" + "\n".join(parts) + "\n}" if dry_run: print(f"\nDry-run for {len(chunk)} PRs:\n{gql}") else: run_query(gql, {}) print(f"Labeled {len(chunk)} PRs.") ������������������������������������������timescaledb-2.23.0/scripts/license_apache.spec������������������������������������������������������0000664�0000000�0000000�00000000263�15100345067�0021342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/license_tsl.spec���������������������������������������������������������0000664�0000000�0000000�00000000265�15100345067�0020725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/memory_leaks.sql���������������������������������������������������������0000664�0000000�0000000�00000002551�15100345067�0020755�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP DATABASE IF EXISTS test; CREATE DATABASE test; \c test \timing DROP EXTENSION IF EXISTS timescaledb CASCADE; CREATE EXTENSION timescaledb; SELECT pg_backend_pid(); SELECT pg_sleep(5); CREATE TABLE metrics(time timestamptz, device text, value float); SELECT create_hypertable('metrics', 'time'); INSERT INTO metrics SELECT '2020-01-01'::timestamptz + format('%ss',time)::interval, format('Device %s',time%10), random() FROM generate_series(1,1000000) g(time); \o /dev/null \set ECHO none \timing off \echo Starting 1 million SELECT queries SELECT format($$SELECT * FROM metrics WHERE device = 'Device %s' ORDER BY time DESC LIMIT 1;$$,time % 10) FROM generate_series(1,1000000) g(time) \gexec \echo Starting 10k UPDATE queries SELECT format($$UPDATE metrics SET value = %s WHERE time < '2020-01-02' AND device = 'Device %s';$$,time,time % 10) FROM generate_series(1,10000) g(time) \gexec \echo Starting 50k INSERTs with batches of 1000 SELECT format($$INSERT INTO metrics SELECT '2021-01-01'::timestamptz + '%ss'::interval + format('%%s', time)::interval, format('Device %%s',time %% 10), random() FROM generate_series(1,1000) g(time);$$,time) FROM generate_series(1,50000) g(time) \gexec �������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/out_of_order_random_direct.sql�������������������������������������������0000664�0000000�0000000�00000001212�15100345067�0023637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP DATABASE IF EXISTS test; CREATE DATABASE test; \c test \timing DROP EXTENSION IF EXISTS timescaledb CASCADE; CREATE EXTENSION timescaledb; SELECT pg_backend_pid(); CREATE TABLE test_hyper (i bigint, j double precision, k bigint, ts timestamp); SELECT create_hypertable('test_hyper', 'i', chunk_time_interval=>10); INSERT INTO test_hyper SELECT random()*100, random()*100, x*10, _timescaledb_functions.to_timestamp(x) FROM generate_series(1,100000000) AS x; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/perltidy_format_all.sh���������������������������������������������������0000775�0000000�0000000�00000000751�15100345067�0022140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash SCRIPTDIR=$(cd "$(dirname $0)" || exit; pwd) BASEDIR=$(dirname $SCRIPTDIR) PERLTIDY=${PERLTIDY:-perltidy} PERLTIDY_CONFIG=${PERLTIDY_CONFIG:-$BASEDIR/.perltidyrc} if [ ! -f "$PERLTIDY_CONFIG" ]; then echo "perltidy config '$PERLTIDY_CONFIG' not found" exit 1 fi find "$BASEDIR"/test -name '*.p[lm]' -exec "$PERLTIDY" --profile="$PERLTIDY_CONFIG" -b -bext=/ {} + find "$BASEDIR"/tsl/test -name '*.p[lm]' -exec "$PERLTIDY" --profile="$PERLTIDY_CONFIG" -b -bext=/ {} + �����������������������timescaledb-2.23.0/scripts/release/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017162�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/release/build_post_release_artefacts.sh����������������������������������0000775�0000000�0000000�00000004423�15100345067�0025424�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash # # Build the necessary artefacts for the forwardporting the # the release to `main` (Minor & Patch) # - up & down files for the next version # - latest.sql & reverse.sql # - sets new version in version.config # - adjusts the CMakeLists.txt # # Param: <published_version> # set -eu if [ "$#" -ne 1 ]; then echo "${0} <published_version>" exit 2 fi PUBLISHED_VERSION=$1 PREVIOUS_VERSION=$(tail -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) echo "fetch the up & downgrade files" URL_UPGRADE="https://raw.githubusercontent.com/timescale/timescaledb/refs/tags/${PUBLISHED_VERSION}/sql/updates/${PREVIOUS_VERSION}--${PUBLISHED_VERSION}.sql" URL_DOWNGRADE="https://raw.githubusercontent.com/timescale/timescaledb/refs/tags/${PUBLISHED_VERSION}/sql/updates/${PUBLISHED_VERSION}--${PREVIOUS_VERSION}.sql" echo $URL_UPGRADE curl --fail -o sql/updates/${PREVIOUS_VERSION}--${PUBLISHED_VERSION}.sql $URL_UPGRADE curl --fail -o sql/updates/${PUBLISHED_VERSION}--${PREVIOUS_VERSION}.sql $URL_DOWNGRADE # find last up & down grade files LAST_UPDATE_FILE=$(find sql/updates/*--${PREVIOUS_VERSION}.sql | head -1 | cut -d '/' -f 3) LAST_DOWNGRADE_FILE=$(find sql/updates/${PREVIOUS_VERSION}--*.sql | head -1 | cut -d '/' -f 3) echo "register upgrade sql file" gawk -i inplace '/'${LAST_UPDATE_FILE}')/ { print; print " updates/'${PREVIOUS_VERSION}'--'${PUBLISHED_VERSION}'.sql)"; next }1' ./sql/CMakeLists.txt sed -i.bak "s/${LAST_UPDATE_FILE})/${LAST_UPDATE_FILE}/g" ./sql/CMakeLists.txt echo "register downgrade sql file" gawk -i inplace '/'${LAST_DOWNGRADE_FILE}')/ { print; print " '${PUBLISHED_VERSION}'--'${PREVIOUS_VERSION}'.sql)"; next }1' ./sql/CMakeLists.txt sed -i.bak "s/${LAST_DOWNGRADE_FILE})/${LAST_DOWNGRADE_FILE}/g" ./sql/CMakeLists.txt # CHANGELOG echo "fetching CHANGELOG" URL_CHANGELOG="https://raw.githubusercontent.com/timescale/timescaledb/refs/tags/${PUBLISHED_VERSION}/CHANGELOG.md" curl --silent --fail -o CHANGELOG.md $URL_CHANGELOG # .unreleased files echo "remove .unreleased files" #git diff ${PUBLISHED_VERSION}..main .unreleased/* | xargs rm -v # Set new previous version echo "Set new previous version version.config to ${PUBLISHED_VERSION}" sed -i '' -e "s/^previous_version = .*/previous_version = $PUBLISHED_VERSION/" version.config tail -n 1 version.config ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/release/build_release_artefacts.sh���������������������������������������0000775�0000000�0000000�00000003535�15100345067�0024362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash # # Build the necessary artefacts for the next release (Minor & Patch) # - up & down files for the next version # - latest.sql & reverse.sql # - sets new version in version.config # - adjusts the CMakeLists.txt # # Param: <current_version> # Param: <nextt_version> # set -eu if [ "$#" -ne 2 ]; then echo "${0} <current_version> <next_version>" exit 2 fi CURRENT_VERSION=$1 NEXT_VERSION=$2 UPDATE_FILE="$CURRENT_VERSION--$NEXT_VERSION.sql" DOWNGRADE_FILE="$NEXT_VERSION--$CURRENT_VERSION.sql" LAST_UPDATE_FILE=$(find sql/updates/*--${CURRENT_VERSION}.sql | head -1 | cut -d '/' -f 3) LAST_DOWNGRADE_FILE=$(find sql/updates/${CURRENT_VERSION}--*.sql | head -1 | cut -d '/' -f 3) # prepare next up & down files echo "generate up and downgrade files" cp ./sql/updates/latest-dev.sql ./sql/updates/$UPDATE_FILE cp ./sql/updates/reverse-dev.sql ./sql/updates/$DOWNGRADE_FILE echo "truncate dev up & downgrade paths" truncate -s 0 ./sql/updates/latest-dev.sql truncate -s 0 ./sql/updates/reverse-dev.sql # CMakeLists echo "register upgrade sql file" gawk -i inplace '/'${LAST_UPDATE_FILE}')/ { print; print " updates/'${UPDATE_FILE}')"; next }1' ./sql/CMakeLists.txt sed -i.bak "s/${LAST_UPDATE_FILE})/${LAST_UPDATE_FILE}/g" ./sql/CMakeLists.txt echo "register downgrade sql file" gawk -i inplace '/'${LAST_DOWNGRADE_FILE}')/ { print; print " '${DOWNGRADE_FILE}')"; next }1' ./sql/CMakeLists.txt sed -i.bak "s/${LAST_DOWNGRADE_FILE})/${LAST_DOWNGRADE_FILE}/g" ./sql/CMakeLists.txt echo "register reverse path" sed -i.bak "s/FILE reverse-dev.sql)/FILE ${DOWNGRADE_FILE})/g" ./sql/CMakeLists.txt # Set only next minor release version in version.config # and create this as a separate PR on `main` echo "Set next minor release version.config" sed -i.bak "s/${NEXT_VERSION}-dev/${NEXT_VERSION}/g" version.config rm version.config.bak head -n1 version.config �������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/release/create_minor_release_branch.sh�����������������������������������0000775�0000000�0000000�00000001203�15100345067�0025201�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -eu # Folder, where we have cloned repositories' sources SOURCES_DIR="timescaledb" FORK_DIR="timescaledb" echo "---- Deriving the release related versions from main ----" cd ~/"$SOURCES_DIR"/"$FORK_DIR" git fetch --all NEW_PATCH_VERSION="0" NEW_VERSION=$(head -1 version.config | cut -d ' ' -f 3 | cut -d '-' -f 1) RELEASE_BRANCH="${NEW_VERSION/%.$NEW_PATCH_VERSION/.x}" echo "RELEASE_BRANCH is $RELEASE_BRANCH" echo "NEW_VERSION is $NEW_VERSION" echo "---- Creating the version branch from main ----" git fetch --all git checkout -b "$RELEASE_BRANCH" origin/main git push origin "$RELEASE_BRANCH":"$RELEASE_BRANCH" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/release/ready_fork_for_commit.sh�����������������������������������������0000775�0000000�0000000�00000002400�15100345067�0024060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -eu echo "---- Setting git user parameters as per current global git configuration ----" # GITHUB_USERNAMES GH_EMAIL=$(git config user.email) GH_FULL_USERNAME=$(git config user.name) GH_USERNAME=$(gh auth status | grep 'Logged in to' |cut -d ' ' -f 9) echo "GH_EMAIL is $GH_EMAIL" echo "GH_FULL_USERNAME is $GH_FULL_USERNAME" echo "GH_USERNAME is $GH_USERNAME" # Folder, where we have cloned repositories' sources SOURCES_DIR="sources" # Derived Variables FORK_DIR="$GH_USERNAME-timescaledb" echo "---- Updating fork with upstream for user $GH_USERNAME ----" gh repo sync "$GH_USERNAME/timescaledb" -b main echo "---- Cloning the fork to $FORK_DIR ----" cd cd "$SOURCES_DIR" rm -rf "$FORK_DIR" git clone git@github.com:"$GH_USERNAME"/timescaledb.git "$FORK_DIR" cd "$FORK_DIR" git branch git pull && git diff HEAD git log -n 2 echo "---- Configuring the fork for commit ----" git config user.name "$GH_FULL_USERNAME" git config user.email "$GH_EMAIL" git remote add upstream git@github.com:timescale/timescaledb.git git config -l git remote -v echo "---- Updating tags from upstream on the fork ----" git fetch --tags upstream git push --tags origin main # Check the needed branch name here - could it be 2.14.x ? # git push -f --tags origin main ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/run_sql.sh���������������������������������������������������������������0000775�0000000�0000000�00000000451�15100345067�0017564�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # To avoid pw writing, add localhost:5432:*:postgres:test to ~/.pgpass set -u set -e PWD=$(pwd) DIR=$(dirname $0) export PGUSER=${PGUSER:-postgres} export PGHOST=${PGHOST:-localhost} export PGDATABASE=${PGDATABASE:-timescaledb} psql -v ON_ERROR_STOP=1 -q -X -f $DIR/sql/$1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/shellcheck-ci.sh���������������������������������������������������������0000775�0000000�0000000�00000000375�15100345067�0020604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -e find ./* .github -type f -executable \ -exec bash -c '[ "$(file --brief --mime-type "$1")" == "text/x-shellscript" ]' sh {} \; \ -not -exec shellcheck -x --exclude=SC2086 {} \; \ -print \ | grep . \ && exit 1 \ || exit 0 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/sql_license_apache.sql���������������������������������������������������0000664�0000000�0000000�00000000267�15100345067�0022072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/sql_license_tsl.sql������������������������������������������������������0000664�0000000�0000000�00000000270�15100345067�0021445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/suppressions/������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020317�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/suppressions/README.md���������������������������������������������������0000664�0000000�0000000�00000001220�15100345067�0021571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Suppressions for Clang Sanitizers # This folder contains [supression files](https://clang.llvm.org/docs/SanitizerSpecialCaseList.html) for running timescale using Clang's [AddressSanitizer](https://clang.llvm.org/docs/AddressSanitizer.html) and [UndefinedBehaviorSanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html), which we use as part of timescale's regission suite. There are a few places OSs have UB and where postgres has benign memory leaks, in order to run these sanitizers, we suppress these warning. For ease of use, we provide a script in [/scripts/test_sanitizers.sh] to run our regression tests with sanitizers enabled. ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/suppressions/suppr_asan.txt����������������������������������������������0000664�0000000�0000000�00000000125�15100345067�0023231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#suppress getaddrinfo due to internal error on macos interceptor_via_fun:getaddrinfo �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/suppressions/suppr_leak.txt����������������������������������������������0000664�0000000�0000000�00000001256�15100345067�0023231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������leak:save_ps_display_args leak:psql/startup.c #don't care about the frontend leaks leak:fe_memutils.c leak:fe-connect.c leak:fe-exec.c leak:initdb.c #annoingly have to supress strdup because it leaks in PostmasterMain -D option leak:strdup leak:ProcessConfigFileInternal leak:internal_load_library leak:pg_timezone_abbrev_initialize leak:check_timezone_abbreviations leak:check_session_authorization leak:InitializeGUCOptions leak:CheckMyDatabase #pg_dump leak:getSchemaData leak:dumpDumpableObject #should live as long as the process leak:ShmemInitHash #test only functions leak:deserialize_test_parameters leak:ts_params_get leak:test_job_dispatcher #openssl leak:CRYPTO_zalloc ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/suppressions/suppr_ub.txt������������������������������������������������0000664�0000000�0000000�00000002135�15100345067�0022720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������alignment:pg_comp_crc32c_sse42 alignment:array_cmp alignment:array_iter_setup alignment:array_out alignment:array_unnest alignment:array_eq alignment:AllocSetCheck nonnull-attribute:TransactionIdSetPageStatus nonnull-attribute:SerializeTransactionState nonnull-attribute:initscan nonnull-attribute:SetTransactionSnapshot nonnull-attribute:shm_mq_receive #care, gcc cannot parse the path, only the filename nonnull-attribute:*/src/fe_utils/print.c nonnull-attribute:print_aligned_text #PG13.3-copyfuncs.c:2374:2: runtime error: null pointer passed as argument 2, which is declared to never be null nonnull-attribute:_copyAppendRelInfo #PG13.3-copyfuncs.c:1190:2: runtime error: null pointer passed as argument 2, which is declared to never be null nonnull-attribute:_copyLimit nonnull-attribute:*/src/backend/nodes/copyfuncs.c #division by 0, looks like a real postgres ug float-divide-by-zero:_bt_vacuum_needs_cleanup # It complains about casting -nan to int in histogram_test.sql. It is in the # postgres code and doesn't lead to bugs, because it is caught by a check later. float-cast-overflow:width_bucket_float8 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_downgrade.sh��������������������������������������������������������0000775�0000000�0000000�00000002643�15100345067�0021117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -e SCRIPT_DIR=$(dirname $0) PG_MAJOR_VERSION=$(pg_config --version | awk '{print $2}' | awk -F. '{print $1}') PG_EXTENSION_DIR=$(pg_config --sharedir)/extension if [ "${CI:-false}" == true ]; then GIT_REF=${GIT_REF:-$(git rev-parse HEAD)} else GIT_REF=$(git branch --show-current) fi BUILD_DIR="build_update_pg${PG_MAJOR_VERSION}" CURRENT_VERSION=$(grep '^version ' version.config | awk '{ print $3 }') PREV_VERSION=$(grep '^previous_version ' version.config | awk '{ print $3 }') if [ ! -d "${BUILD_DIR}" ]; then echo "Initializing build directory" BUILD_DIR="${BUILD_DIR}" ./bootstrap -DCMAKE_BUILD_TYPE=Release -DWARNINGS_AS_ERRORS=OFF -DASSERTIONS=ON -DLINTER=ON -DGENERATE_DOWNGRADE_SCRIPT=ON -DREGRESS_CHECKS=OFF -DTAP_CHECKS=OFF fi if [ ! -f "${PG_EXTENSION_DIR}/timescaledb--${PREV_VERSION}.sql" ]; then echo "Building ${PREV_VERSION}" git checkout ${PREV_VERSION} make -C "${BUILD_DIR}" -j4 > /dev/null sudo make -C "${BUILD_DIR}" install > /dev/null git checkout ${GIT_REF} fi # We want to use the latest loader for all the tests so we build it last make -C "${BUILD_DIR}" -j4 sudo make -C "${BUILD_DIR}" install > /dev/null set +e FROM_VERSION=${CURRENT_VERSION} TO_VERSION=${PREV_VERSION} TEST_REPAIR=false "${SCRIPT_DIR}/test_update_from_version.sh" return_code=$? if [ $return_code -ne 0 ]; then echo -e "\nFailed downgrade from ${CURRENT_VERSION} to ${PREV_VERSION}\n" exit 1 fi ���������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_license.sql���������������������������������������������������������0000664�0000000�0000000�00000000267�15100345067�0020751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_memory_spikes.py����������������������������������������������������0000664�0000000�0000000�00000012124�15100345067�0022041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python # This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # Python script to check if there are memory spikes when running queries import psutil import time import sys from datetime import datetime DEFAULT_MEMCAP = 300 # in MB THRESHOLD_RATIO = 1.5 # ratio above which considered memory spike WAIT_TO_STABILIZE = 15 # wait in seconds before considering memory stable CHECK_INTERVAL = 15 DEBUG = False # finds processes with name as argument def find_procs_by_name(name): # Return a list of processes matching 'name' ls = [] for p in psutil.process_iter(): if p.name() == name: ls.append(p) return ls # return human readable form of number of bytes n def bytes2human(n): # http://code.activestate.com/recipes/578019 # >>> bytes2human(10000) # '9.8K' # >>> bytes2human(100001221) # '95.4M' symbols = ("K", "M", "G", "T", "P", "E", "Z", "Y") prefix = {} for i, s in enumerate(symbols): prefix[s] = 1 << (i + 1) * 10 for s in reversed(symbols): if n >= prefix[s]: value = float(n) / prefix[s] return f"{value:.1f}{s}" return f"{n}B" # prints pid of processes def process_details(process): return f"{process.pid} {''.join(process.cmdline()).strip()}" def process_stats(): processes = find_procs_by_name("postgres") for p in processes: print(p, p.num_ctx_switches(), p.cpu_times(), p.memory_info(), flush=True) # return process id of new postgres process created when running SQL file def find_new_process(): # get postgres processes that are running before insertion starts base_process = find_procs_by_name("postgres") print("Processes running before inserts run: ") for p in base_process: print(process_details(p)) process_count = len(base_process) print( f"Waiting {WAIT_TO_STABILIZE} seconds for process running inserts to start", flush=True, ) time.sleep( WAIT_TO_STABILIZE ) # wait WAIT_TO_STABILIZE seconds to get process that runs the inserts # continuously check for creation of new postgres process timeout = time.time() + 60 while True: # prevent infinite loop if time.time() > timeout: print( "Timed out on finding new process, should force quit SQL inserts", flush=True, ) sys.exit(4) process = find_procs_by_name("postgres") cnt = len(process) print("process count ", cnt) if cnt > process_count: process = find_procs_by_name("postgres") difference_set = set(process) - set(base_process) new_process = None # We assume that the backend is the first 'new' process to start, so it will have # the lower PID for p in difference_set: print(f"found process: {process_details(p)}") if new_process is None or p.pid < new_process.pid: new_process = p print(f"new_process: {process_details(new_process)}") return new_process.pid time.sleep(1) def main(): # get process created from running insert test sql file pid = find_new_process() p = psutil.Process(pid) print('*** Check this pid is the same as "pg_backend_pid" from SQL command ***') print("New process backend process:", pid) print( f"Waiting {WAIT_TO_STABILIZE} seconds for memory consumption to stabilize", flush=True, ) time.sleep(WAIT_TO_STABILIZE) # Calculate average memory consumption from 5 values over 15 seconds total = 0 for _ in range(0, 5): total += p.memory_info().rss time.sleep(3) avg = total / 5 print("Average memory consumption: ", bytes2human(avg), flush=True) cap = int(sys.argv[1] if len(sys.argv) > 1 else DEFAULT_MEMCAP) * 1024 * 1024 upper_threshold = min(cap, avg * THRESHOLD_RATIO) # check if memory consumption goes above threshold until process terminates every 30 seconds timeout = time.time() + 45 * 60 while True: # insert finished if not psutil.pid_exists(pid): break # prevent infinite loop if time.time() > timeout: print("Timed out on running inserts (over 45 mins)") print("Killing postgres process") p.kill() sys.exit(4) rss = p.memory_info().rss stamp = datetime.now().strftime("%H:%M:%S") print(f"{stamp} Memory used by process {p.pid}: {bytes2human(rss)}", flush=True) if DEBUG: process_stats() # exit with error if memory above threshold if rss > upper_threshold: print("Memory consumption exceeded upper threshold") print("Killing postgres process", flush=True) p.kill() sys.exit(4) time.sleep(CHECK_INTERVAL) print("No memory leaks detected", flush=True) sys.exit(0) # success if __name__ == "__main__": main() ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_pg_upgrade.py�������������������������������������������������������0000775�0000000�0000000�00000007504�15100345067�0021301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python3 import os import sys from shutil import rmtree from testgres import get_new_node, PostgresNode # Accessor functions def set_default_conf(node: PostgresNode, unix_socket_dir): node.default_conf(fsync=True, allow_streaming=False, allow_logical=False) node.append_conf(unix_socket_directories=unix_socket_dir) node.append_conf(timezone="GMT") node.append_conf(client_min_messages="warning") node.append_conf(max_prepared_transactions="100") node.append_conf(max_worker_processes="0") node.append_conf(shared_preload_libraries="timescaledb") node.append_conf("timescaledb.telemetry_level=off") def write_bytes_to_file(filename, nbytes): with open(filename, "wb") as f: f.write(nbytes) f.close() def getenv_or_error(envvar): return os.getenv(envvar) or sys.exit(f"Environment variable {envvar} not defined") def getenv_or_default(envvar, default): return os.getenv(envvar) or default def initialize_node(working_dir, prefix, port, bin_dir, base_dir): node = get_new_node(prefix=prefix, port=port, bin_dir=bin_dir, base_dir=base_dir) node.init() set_default_conf(node, working_dir) return node # Globals pg_version_old = getenv_or_error("PGVERSIONOLD") pg_version_new = getenv_or_error("PGVERSIONNEW") pg_node_old = f"pg{pg_version_old}" pg_node_new = f"pg{pg_version_new}" pg_port_old = int(getenv_or_default("PGPORTOLD", "54321")) pg_port_new = int(getenv_or_default("PGPORTNEW", "54322")) test_version = getenv_or_default("TEST_VERSION", "v8") pg_bin_old = getenv_or_default("PGBINOLD", f"/usr/lib/postgresql/{pg_version_old}/bin") pg_bin_new = getenv_or_default("PGBINNEW", f"/usr/lib/postgresql/{pg_version_new}/bin") working_dir = getenv_or_default( "OUTPUT_DIR", f"/tmp/pg_upgrade_output/{pg_version_old}_to_{pg_version_new}", ) pg_data_old = getenv_or_default("PGDATAOLD", f"{working_dir}/{pg_node_old}") pg_data_new = getenv_or_default("PGDATAOLD", f"{working_dir}/{pg_node_new}") pg_database_test = getenv_or_default("PGDATABASE", "pg_upgrade_test") if os.path.exists(working_dir): rmtree(working_dir) os.makedirs(working_dir) # Real testing code print(f"Initializing nodes {pg_node_old} and {pg_node_new}") node_old = initialize_node( working_dir, pg_node_old, pg_port_old, pg_bin_old, pg_data_old ) node_old.start() node_new = initialize_node( working_dir, pg_node_new, pg_port_new, pg_bin_new, pg_data_new ) print(f"Creating {pg_database_test} database on node {pg_node_old}") node_old.safe_psql(filename="test/sql/updates/setup.roles.sql") node_old.safe_psql(query=f"CREATE DATABASE {pg_database_test};") node_old.safe_psql(dbname=pg_database_test, query="CREATE EXTENSION timescaledb;") node_old.safe_psql(dbname=pg_database_test, filename="test/sql/updates/pre.testing.sql") node_old.safe_psql( dbname=pg_database_test, filename=f"test/sql/updates/setup.{test_version}.sql" ) node_old.safe_psql( dbname=pg_database_test, filename="test/sql/updates/setup.pg_upgrade.sql" ) node_old.safe_psql(dbname=pg_database_test, query="CHECKPOINT") node_old.safe_psql(dbname=pg_database_test, filename="test/sql/updates/setup.check.sql") # Run over the old node to check the output (code, old_out, old_err) = node_old.psql( dbname=pg_database_test, filename="test/sql/updates/post.pg_upgrade.sql" ) # Save output to log write_bytes_to_file(f"{working_dir}/post.{pg_node_old}.log", old_out) node_old.stop() print(f"Upgrading node {pg_node_old} to {pg_node_new}") res = node_new.upgrade_from(old_node=node_old, options=["--retain"]) node_new.start() (code, new_out, new_err) = node_new.psql( dbname=pg_database_test, filename="test/sql/updates/post.pg_upgrade.sql", ) # Save output to log write_bytes_to_file(f"{working_dir}/post.pg{pg_version_new}.log", new_out) node_new.stop() print(f"Finish upgrading node {pg_node_old} to {pg_node_new}") ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_regressions.sh������������������������������������������������������0000775�0000000�0000000�00000005224�15100345067�0021506�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -eu # # Run regression check # # Param: <next_version> # Param: <connection_string> # if [ "$#" -ne 2 ]; then echo "${0} <next_version> <connection_string>" exit 2 fi #NEXT_VERSION=$1 #CONNECTION_STRING=$2 #psql "$CONNECTION_STRING" -c "ALTER EXTENSION timescaledb UPDATE TO '${NEXT_VERSION}'" #export TEST_PGPORT_REMOTE="$PORT" #export TEST_PGHOST="$HOSTNAME" #export TEST_PGUSER="$SERVICE_USER" #export TEST_DBNAME="$DBNAME" #export PGUSER="$SERVICE_USER" #export PGPASSWORD="$PASSWORD" #export PGPORT="$PORT" #export USER="tsdbadmin" #$SERVICE_USER" #Run the test #make regresscheck-shared #exit 2 # timescaledb Version/Tag related parameters, more changeable: #NEW_DEV_VERSION="2.17.0-dev" #COUNT="0" # PG Tag related parameters , usually less changeable: #PG_MAJOR_VERSION=16 #PG_MINOR_VERSION=4 #create required users on the service. #This is blocked , for now. #psql "$SERVICE_URL" -c "CREATE USER default_perm_user" #psql "$SERVICE_URL" -c "GRANT default_perm_user TO tsdbadmin" #psql "$SERVICE_URL" -c "CREATE USER default_perm_user_2" #psql "$SERVICE_URL" -c "GRANT default_perm_user_2 TO tsdbadmin" #Modify some GUCs, as needed on the service. #psql tsdb -c "ALTER database tsdb set timescaledb_experimental.enable_distributed_ddl to on;" #psql tsdb -c "ALTER database tsdb set timezone to 'US/Pacific';" #psql tsdb -c "ALTER database tsdb set timescaledb.telemetry_level to off;" #psql tsdb -c "ALTER database tsdb set extra_float_digits to 0;" #psql tsdb -c "ALTER database tsdb set random_page_cost to 1.0;" #psql tsdb -c "ALTER database tsdb set datestyle to 'Postgres, MDY';" #psql tsdb -c "ALTER system set autovacuum to false;" #psql tsdb -c "ALTER system set wal_level to 'logical';" #psql tsdb -c "SELECT _timescaledb_functions.stop_background_workers();" #psql tsdb -c "ALTER database tsdb set max_parallel_workers to 8;" #psql tsdb -c "ALTER database tsdb set max_parallel_workers_per_gather to 2;" # This does not switch off Query Identifier , right now. Need to check further. #psql tsdb -c "SET compute_query_id = off;" #sleeps are to allow the server to restart after these GUC parameters' change. #sc service parameters -E "$ENVIRONMENT" -R "$REGION" -S "$SERVICE_ID" set -p max_connections -n 200 #sleep 120 #sc service parameters -E "$ENVIRONMENT" -R "$REGION" -S "$SERVICE_ID" set -p max_worker_processes -n 24 #sleep 120 #Set the parameters #export TEST_PGPORT_REMOTE="$PORT" #export TEST_PGHOST="$HOSTNAME" #export TEST_PGUSER="$SERVICE_USER" #export TEST_DBNAME="$DBNAME" #export PGUSER="$SERVICE_USER" #export PGPASSWORD="$PASSWORD" #export PGPORT="$PORT" #export USER="$SERVICE_USER" #Run the test #make regresscheck-shared ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_sanitizers.sh�������������������������������������������������������0000775�0000000�0000000�00000006642�15100345067�0021343�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -e set -o pipefail DO_CLEANUP=true SCRIPT_DIR=${SCRIPT_DIR:-$(dirname "$0")} EXCLUDE_PATTERN=${EXCLUDE_PATTERN:-'^$'} # tests matching regex pattern will be excluded INCLUDE_PATTERN=${INCLUDE_PATTERN:-'.*'} # tests matching regex pattern will be included TEST_MAX=${TEST_MAX:-$((2**16))} TEST_MIN=${TEST_MIN:-$((-1))} USE_REMOTE=${USE_REMOTE:-false} REMOTE_TAG=${REMOTE_TAG:-'latest'} PUSH_IMAGE=${PUSH_IMAGE:-false} REMOTE_ORG=${REMOTE_ORG:-'timescaledev'} REMOTE_NAME=${REMOTE_NAME:-'postgres-dev-clang'} TIMESCALE_DIR=${TIMESCALE_DIR:-${PWD}/${SCRIPT_DIR}/..} while getopts "d" opt; do case $opt in d) DO_CLEANUP=false echo "!!Debug mode: Containers and temporary directory will be left on disk" echo ;; *) echo "Unknown flag '$opt'" exit 1 ;; esac done shift $((OPTIND-1)) if [ "$DO_CLEANUP" == "true" ] ; then trap cleanup EXIT fi cleanup() { # Save status here so that we can return the status of the last # command in the script and not the last command of the cleanup # function status="$?" set +e # do not exit immediately on failure in cleanup handler if [[ $status -eq 0 ]]; then echo "All tests passed" docker rm -vf timescaledb-san 2>/dev/null else # docker logs timescaledb-san # only print respective postmaster.log when regression.diffs exists docker_exec timescaledb-san "if [ -f /tsdb_build/timescaledb/build/test/regression.diffs ]; then cat /tsdb_build/timescaledb/build/test/regression.diffs /tsdb_build/timescaledb/build/test/log/postmaster.log; fi" docker_exec timescaledb-san "if [ -f /tsdb_build/timescaledb/build/tsl/test/regression.diffs ]; then cat /tsdb_build/timescaledb/build/tsl/test/regression.diffs /tsdb_build/timescaledb/build/tsl/test/log/postmaster.log; fi" fi echo "Exit status is $status" exit $status } docker_exec() { # Echo to stderr >&2 echo -e "\033[1m$1\033[0m: $2" docker exec "$1" /bin/bash -c "$2" } docker rm -f timescaledb-san 2>/dev/null || true docker run -d --privileged --name timescaledb-san --env POSTGRES_HOST_AUTH_METHOD=trust -v "${TIMESCALE_DIR}":/timescaledb "${REMOTE_ORG}/${REMOTE_NAME}":"${REMOTE_TAG}" # Run these commands as root to copy the source into the # container. Make sure that all files in the copy is owned by user # 'postgres', which we use to run tests below. docker exec -i timescaledb-san /bin/bash -Oe <<EOF mkdir /tsdb_build chown postgres /tsdb_build cp -R /timescaledb tsdb_build chown -R postgres:postgres /tsdb_build EOF # Build TimescaleDB as 'postgres' user docker exec -i -u postgres -w /tsdb_build/timescaledb timescaledb-san /bin/bash -Oe <<EOF export CFLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer -O2" export PG_SOURCE_DIR="/usr/src/postgresql/" export BUILD_FORCE_REMOVE=true ./bootstrap -DCMAKE_BUILD_TYPE='Debug' -DTEST_GROUP_SIZE=1 cd build make EOF # Install TimescaleDB as root docker exec -i -w /tsdb_build/timescaledb/build timescaledb-san /bin/bash <<EOF make install EOF echo "Testing" # Echo to stderr >&2 echo -e "\033[1m$1\033[0m: $2" # Run tests as 'postgres' user. # # IGNORE some test since they fail under ASAN. docker exec -i -u postgres -w /tsdb_build/timescaledb/build timescaledb-san /bin/bash <<EOF make -k regresscheck regresscheck-t IGNORES='bgw_db_scheduler bgw_db_scheduler_fixed bgw_launcher cluster-11 continuous_aggs_ddl-11' EOF ����������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_update_from_version.sh����������������������������������������������0000775�0000000�0000000�00000013007�15100345067�0023213�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # During the update test the following databases will be created: # - baseline: fresh installation of $TO_VERSION # - updated: install $FROM_VERSION, update to $TO_VERSION # - restored: restore from updated dump # - repair: install $FROM_VERSION, update to $TO_VERSION and run integrity tests set -xeu FROM_VERSION=${FROM_VERSION:-$(grep '^previous_version ' version.config | awk '{ print $3 }')} TO_VERSION=${TO_VERSION:-$(grep '^version ' version.config | awk '{ print $3 }')} TEST_REPAIR=${TEST_REPAIR:-false} TEST_VERSION=${TEST_VERSION:-v10} OUTPUT_DIR=${OUTPUT_DIR:-update_test/${FROM_VERSION}_to_${TO_VERSION}} PGDATA="${OUTPUT_DIR}/data" # Get an unused port to allow for parallel execution PGHOST=localhost PGPORT=${PGPORT:-$(python -c 'import socket; s=socket.socket(); s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) ; s.bind(("", 0)); print(s.getsockname()[1]); s.close()')} PGDATABASE=postgres export PGHOST PGPORT PGDATABASE PGDATA run_sql() { local db=${2:-$PGDATABASE} psql -X -q --echo-queries -d "${db}" -v ON_ERROR_STOP=1 -v VERBOSITY=verbose -v WITH_ROLES=true -v WITH_SUPERUSER=true -v WITH_CHUNK=true -c "${1}" } run_sql_file() { local db=${2:-$PGDATABASE} psql -X -q --echo-queries -d "${db}" -v ON_ERROR_STOP=1 -v VERBOSITY=verbose -v WITH_ROLES=true -v WITH_SUPERUSER=true -v WITH_CHUNK=true -f "${1}" } check_version() { psql -X -c "DO \$\$BEGIN PERFORM from pg_available_extension_versions WHERE name='timescaledb' AND version='$1'; IF NOT FOUND THEN RAISE 'Version $1 not available'; END IF; END\$\$;" > /dev/null } trap cleanup EXIT cleanup() { # Save status here so that we can return the status of the last # command in the script and not the last command of the cleanup # function local status="$?" set +e # do not exit immediately on failure in cleanup handler pg_ctl stop > /dev/null rm -rf "${PGDATA}" exit ${status} } mkdir -p "${OUTPUT_DIR}" rm -rf "${OUTPUT_DIR}/data" mkdir -p "${OUTPUT_DIR}/data" UNIX_SOCKET_DIR=$(readlink -f "${OUTPUT_DIR}") initdb > "${OUTPUT_DIR}/initdb.log" 2>&1 # Don't try to wrap the settings, pg_ctl can't handle newlines there. pg_ctl -l "${OUTPUT_DIR}/postgres.log" start -o "-c unix_socket_directories=${UNIX_SOCKET_DIR} -c timezone=GMT -c client_min_messages=warning -c port=${PGPORT} -c max_prepared_transactions=100 -c shared_preload_libraries=timescaledb -c timescaledb.telemetry_level=off -c timescaledb.enable_compression_ratio_warnings=off -c max_worker_processes=0 -c log_statement=all" pg_isready -t 30 > /dev/null echo -e "\nUpdate test version ${TEST_VERSION} for ${FROM_VERSION} -> ${TO_VERSION}\n" # caller should ensure that the versions are available check_version "${FROM_VERSION}" check_version "${TO_VERSION}" run_sql_file test/sql/updates/setup.roles.sql > /dev/null echo "Creating baseline database" { run_sql "CREATE DATABASE baseline;" PGDATABASE=baseline run_sql "CREATE EXTENSION timescaledb VERSION \"${TO_VERSION}\";" run_sql_file test/sql/updates/pre.testing.sql run_sql_file test/sql/updates/setup.${TEST_VERSION}.sql run_sql "CHECKPOINT;" run_sql_file test/sql/updates/setup.check.sql } > "${OUTPUT_DIR}/baseline.log" 2>&1 echo "Creating updated database" { run_sql "CREATE DATABASE updated;" > "${OUTPUT_DIR}/updated.log" PGDATABASE=updated run_sql "CREATE EXTENSION timescaledb VERSION \"${FROM_VERSION}\";" run_sql_file test/sql/updates/pre.testing.sql run_sql_file test/sql/updates/setup.${TEST_VERSION}.sql run_sql "CHECKPOINT;" >> "${OUTPUT_DIR}/updated.log" run_sql "ALTER EXTENSION timescaledb UPDATE TO \"${TO_VERSION}\";" run_sql_file test/sql/updates/setup.check.sql } > "${OUTPUT_DIR}/updated.log" 2>&1 echo "Creating restored database" { run_sql "CREATE DATABASE restored;" PGDATABASE=restored run_sql "CREATE EXTENSION timescaledb VERSION \"${TO_VERSION}\";" run_sql "ALTER DATABASE restored SET timescaledb.restoring='on';" pg_dump -Fc -d updated > "${OUTPUT_DIR}/updated.dump" pg_restore -d restored "${OUTPUT_DIR}/updated.dump" run_sql "ALTER DATABASE restored RESET timescaledb.restoring;" } > "${OUTPUT_DIR}/restored.log" 2>&1 run_sql_file test/sql/updates/post.${TEST_VERSION}.sql baseline > "${OUTPUT_DIR}/post.baseline.log" run_sql_file test/sql/updates/post.${TEST_VERSION}.sql updated > "${OUTPUT_DIR}/post.updated.log" run_sql_file test/sql/updates/post.${TEST_VERSION}.sql restored > "${OUTPUT_DIR}/post.restored.log" if [ "${TEST_REPAIR}" = "true" ]; then echo "Creating repair database" { run_sql "CREATE DATABASE repair;" PGDATABASE=repair run_sql "CREATE EXTENSION timescaledb VERSION \"${FROM_VERSION}\";" run_sql_file test/sql/updates/setup.repair.sql baseline run_sql "ALTER EXTENSION timescaledb UPDATE TO \"${TO_VERSION}\";" run_sql_file test/sql/updates/post.repair.sql baseline run_sql_file test/sql/updates/post.integrity_test.sql baseline } > "${OUTPUT_DIR}/repair.log" 2>&1 fi diff -u "${OUTPUT_DIR}/post.baseline.log" "${OUTPUT_DIR}/post.updated.log" | tee "${OUTPUT_DIR}/baseline_vs_updated.diff" if [ ! -s "${OUTPUT_DIR}/baseline_vs_updated.diff" ]; then rm "${OUTPUT_DIR}/baseline_vs_updated.diff" fi diff -u "${OUTPUT_DIR}/post.baseline.log" "${OUTPUT_DIR}/post.restored.log" | tee "${OUTPUT_DIR}/baseline_vs_restored.diff" if [ ! -s "${OUTPUT_DIR}/baseline_vs_restored.diff" ]; then rm "${OUTPUT_DIR}/baseline_vs_restored.diff" fi if [ -f "${OUTPUT_DIR}/baseline_vs_updated.diff" ] || [ -f "${OUTPUT_DIR}/baseline_vs_restored.diff" ]; then echo "Update test for ${FROM_VERSION} -> ${TO_VERSION} failed" exit 1 fi �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_update_smoke.sh�����������������������������������������������������0000775�0000000�0000000�00000015402�15100345067�0021622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash # shellcheck disable=SC2129,SC2230 # SC2129: Consider using { cmd1; cmd2; } >> file instead of individual redirects. # SC2230: which is non-standard. Use builtin 'command -v' instead. # Run smoke tests to test that updating between versions work. # # Usage: # bash test_update_smoke.sh postgres://... # # This is based on our update tests but doing some tweaks to ensure we # can run it on Forge (or any other PostgreSQL server that only permit # a single user and single database). # # In particular, we cannot create new roles and we cannot create new # databases. # # Info on the parameters: # - current_version is the version to update from # # - next_version is the version to update to # # - connection_string is the URL to use for the connection # if [ "$#" -ne 3 ]; then echo "${0} <current_version> <next_version> <connection_string>" exit 2 fi CURRENT_VERSION=$1 NEXT_VERSION=$2 CONNECTION_STRING=$3 echo "testing upgrade path from v${CURRENT_VERSION} to ${NEXT_VERSION} .." SCRIPT_DIR=$(dirname $0) BASE_DIR=${PWD}/${SCRIPT_DIR}/.. SCRATCHDIR=$(mktemp -d -t "smoketest-${CURRENT_VERSION}-${NEXT_VERSION}-XXXX") LOGFILE="$SCRATCHDIR/update-test.log" DUMPFILE="$SCRATCHDIR/smoke.dump" UPGRADE_OUT="$SCRATCHDIR/upgrade.out" CLEAN_OUT="$SCRATCHDIR/clean.out" RESTORE_OUT="$SCRATCHDIR/restore.out" TEST_VERSION=${TEST_VERSION:-v7} # We do not have superuser privileges when running smoke tests. WITH_SUPERUSER=false WITH_ROLES=false shift $((OPTIND-1)) echo "**** pg_dump at " "$(which pg_dump)" echo "**** pg_restore at" "$(which pg_restore)" # Extra options to pass to psql PGOPTS="-v TEST_VERSION=${TEST_VERSION} -v WITH_SUPERUSER=${WITH_SUPERUSER} -v WITH_ROLES=${WITH_ROLES} -v WITH_CHUNK=false" PSQL="psql -a -qX $PGOPTS" # If we are providing a URI for the connection, we parse it here and # set the PG??? variables since that is the only reliable way to # provide connection information to psql, pg_dump, and pg_restore. # # To work with Forge, we need to only set PGPASSWORD when the password # is available and leave it unset otherwise. If the user has either # set PGPASSWORD or has the password in a .pgpass file, it will be # picked up and used for the connection. if [[ $# -gt 0 ]]; then # shellcheck disable=SC2207 # Prefer mapfile or read -a to split command output (or quote to avoid splitting). parts=($(echo $CONNECTION_STRING | perl -mURI::Split=uri_split -ne '@F = uri_split($_); print join(" ", split(qr/[:@]/, $F[1]), substr($F[2], 1))')) export PGUSER=${parts[0]} if [[ ${#parts[@]} -eq 5 ]]; then # Cloud has 5 fields export PGPASSWORD=${parts[1]} export PGHOST=${parts[2]} export PGPORT=${parts[3]} export PGDATABASE=${parts[4]} elif [[ ${#parts[@]} -eq 4 ]]; then # Forge has 4 fields export PGHOST=${parts[1]} export PGPORT=${parts[2]} export PGDATABASE=${parts[3]} else echo "Malformed URL '$CONNECTION_STRING'" 1>&2 exit 2 fi fi err_trap() { exit 3 } exit_trap() { exit_code=$? if [ "$exit_code" != "0" ]; then echo "!!!! FAILED !!!!" else echo "**** passed ****" fi echo "**** logs can be found in $SCRATCHDIR" } set -e set -o pipefail trap exit_trap EXIT trap err_trap ERR missing_versions() { $PSQL -v ECHO=none -t <<-EOF SELECT * FROM (VALUES ('$1'), ('$2')) AS foo EXCEPT SELECT version FROM pg_available_extension_versions WHERE name = 'timescaledb' AND version IN ('$1', '$2'); EOF } echo "**** Scratch directory: ${SCRATCHDIR}" echo "**** Update files in directory ${BASE_DIR}/test/sql/updates" cd ${BASE_DIR}/test/sql/updates $PSQL -c '\conninfo' $PSQL -c "ALTER DATABASE tsdb SET timescaledb.enable_compression_ratio_warnings = 'off'"; # shellcheck disable=SC2207 # Prefer mapfile or read -a to split command output (or quote to avoid splitting). missing=($(missing_versions $CURRENT_VERSION $NEXT_VERSION)) if [[ ${#missing[@]} -gt 0 ]]; then echo "ERROR: Missing version(s) ${missing[*]} of 'timescaledb'" echo "Available versions: " "$($PSQL -tc "SELECT version FROM pg_available_extension_versions WHERE name = 'timescaledb'")" exit 1 fi # For the comments below, we assume the upgrade is from 1.7.5 to 2.0.2 # (this is just an example, the real value is given by variables # above). # Create a 1.7.5 version Upgrade echo "---- Connecting to ${FORGE_CONNINFO} and running setup ----" $PSQL -f cleanup.${TEST_VERSION}.sql >>$LOGFILE 2>&1 $PSQL -c "DROP EXTENSION IF EXISTS timescaledb CASCADE" >>$LOGFILE 2>&1 $PSQL -f pre.cleanup.sql >>$LOGFILE 2>&1 $PSQL -c "CREATE EXTENSION timescaledb VERSION '${CURRENT_VERSION}'" >>$LOGFILE 2>&1 $PSQL -c "\dx" # Run setup on Upgrade $PSQL -f pre.smoke.sql >>$LOGFILE 2>&1 $PSQL -f setup.${TEST_VERSION}.sql >>$LOGFILE 2>&1 # Run update on Upgrade. You now have a 2.0.2 version in Upgrade. $PSQL -c "ALTER EXTENSION timescaledb UPDATE TO '${NEXT_VERSION}'" >>$LOGFILE 2>&1 echo -n "Dumping the contents of Upgrade..." pg_dump -Fc -f $DUMPFILE >>$LOGFILE 2>&1 echo "done" # Run the post scripts on Upgrade to get UpgradeOut to compare # with. We can now discard Upgrade database. echo -n "Collecting post-update status..." $PSQL -f post.${TEST_VERSION}.sql >$UPGRADE_OUT echo "done" $PSQL -f cleanup.${TEST_VERSION}.sql >>$LOGFILE 2>&1 echo "---- Create a ${NEXT_VERSION} version Clean ----" $PSQL -c "DROP EXTENSION IF EXISTS timescaledb CASCADE" >>$LOGFILE 2>&1 $PSQL -f pre.cleanup.sql >>$LOGFILE 2>&1 $PSQL -c "CREATE EXTENSION timescaledb VERSION '${NEXT_VERSION}'" >>$LOGFILE 2>&1 $PSQL -c "\dx" echo "---- Run the setup scripts on Clean, with post-update actions ----" $PSQL -f pre.smoke.sql >>$LOGFILE 2>&1 $PSQL -f setup.${TEST_VERSION}.sql >>$LOGFILE 2>&1 echo "---- Run the post scripts on Clean to get output CleanOut ----" $PSQL -f post.${TEST_VERSION}.sql >$CLEAN_OUT $PSQL -f cleanup.${TEST_VERSION}.sql >>$LOGFILE 2>&1 echo "---- Create a ${NEXT_VERSION} version Restore ----" $PSQL -c "DROP EXTENSION IF EXISTS timescaledb CASCADE" >>$LOGFILE 2>&1 $PSQL -f pre.cleanup.sql >>$LOGFILE 2>&1 $PSQL -c "CREATE EXTENSION timescaledb VERSION '${NEXT_VERSION}'" >>$LOGFILE 2>&1 $PSQL -c "\dx" echo "---- Restore the UpgradeDump into Restore ----" echo -n "Restoring dump..." $PSQL -c "SELECT timescaledb_pre_restore()" >>$LOGFILE 2>&1 pg_restore -d $PGDATABASE $DUMPFILE >>$LOGFILE 2>&1 || true $PSQL -c "SELECT timescaledb_post_restore()" >>$LOGFILE 2>&1 echo "done" echo "---- Run the post scripts on Restore to get a RestoreOut ----" $PSQL -f post.${TEST_VERSION}.sql >$RESTORE_OUT echo "---- Compare UpgradeOut with CleanOut and make sure they are identical ----" diff -u $UPGRADE_OUT $CLEAN_OUT | tee $SCRATCHDIR/upgrade-clean.diff echo "---- Compare RestoreOut with CleanOut and make sure they are identical ----" diff -u $RESTORE_OUT $CLEAN_OUT | tee $SCRATCHDIR/restore-clean.diff $PSQL -f cleanup.${TEST_VERSION}.sql >>$LOGFILE 2>&1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/test_updates.sh����������������������������������������������������������0000775�0000000�0000000�00000007061�15100345067�0020611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash set -eu SCRIPT_DIR=$(readlink -f "$(dirname $0)") PG_MAJOR_VERSION=$(pg_config --version | awk '{print $2}' | awk -F. '{print $1}') PG_EXTENSION_DIR=$(pg_config --sharedir)/extension if [ "${CI:-false}" == true ]; then GIT_REF=${GIT_REF:-$(git rev-parse HEAD)} else GIT_REF=$(git branch --show-current) fi BUILD_DIR="build_update_pg${PG_MAJOR_VERSION}" VERSIONS="" FAILED_VERSIONS="" ALL_VERSIONS=$(git tag --sort=taggerdate | grep -P '^[2]\.[0-9]+\.[0-9]+$') MAX_VERSION=$(grep '^previous_version ' version.config | awk '{ print $3 }') # major version is always 2 atm max_minor_version=$(echo "${MAX_VERSION}" | awk -F. '{print $2}') max_patch_version=$(echo "${MAX_VERSION}" | awk -F. '{print $3}') # Filter versions depending on the current postgres version # Minimum version for valid update paths are as follows: # PG 14 v8 2.5+ # PG 15 v8 2.9+ # PG 16 v8 2.13+ # PG 17 v8 2.17+ for version in ${ALL_VERSIONS}; do minor_version=$(echo "${version}" | awk -F. '{print $2}') patch_version=$(echo "${version}" | awk -F. '{print $3}') # skip versions that are newer than the max version # We might have a tag for a newer version defined already but the post release # adjustment have not been merged yet. So we want to skip those versions. if [ "${minor_version}" -gt "${max_minor_version}" ]; then continue elif [ "${minor_version}" -eq "${max_minor_version}" ] && [ "${patch_version}" -gt "${max_patch_version}" ]; then continue fi if [ "${minor_version}" -le 8 ]; then # not part of any valid update path continue elif [ "${minor_version}" -le 12 ]; then if [ "${PG_MAJOR_VERSION}" -le 15 ]; then VERSIONS="${VERSIONS} ${version}" fi elif [ "${minor_version}" -le 16 ]; then if [ "${PG_MAJOR_VERSION}" -le 16 ]; then VERSIONS="${VERSIONS} ${version}" fi else VERSIONS="${VERSIONS} ${version}" fi done FAIL_COUNT=0 if [ ! -d "${BUILD_DIR}" ]; then echo "Initializing build directory" BUILD_DIR="${BUILD_DIR}" ./bootstrap -DCMAKE_BUILD_TYPE=Release -DWARNINGS_AS_ERRORS=OFF -DASSERTIONS=ON -DLINTER=OFF -DGENERATE_DOWNGRADE_SCRIPT=ON -DREGRESS_CHECKS=OFF -DTAP_CHECKS=OFF fi for version in ${VERSIONS}; do if [ ! -f "${PG_EXTENSION_DIR}/timescaledb--${version}.sql" ]; then echo "Building ${version}" git checkout ${version} make -C "${BUILD_DIR}" -j4 > /dev/null sudo make -C "${BUILD_DIR}" install > /dev/null git checkout ${GIT_REF} fi done # We want to use the latest loader for all the tests so we build it last git checkout ${GIT_REF} make -C "${BUILD_DIR}" -j4 sudo make -C "${BUILD_DIR}" install set +e if [ -n "${VERSIONS}" ]; then for version in ${VERSIONS}; do ts_minor_version=$(echo "${version}" | awk -F. '{print $2}') if [ "${ts_minor_version}" -ge 10 ]; then TEST_REPAIR=true else TEST_REPAIR=false fi if [ "${ts_minor_version}" -ge 20 ]; then TEST_VERSION=v10 elif [ "${ts_minor_version}" -ge 16 ]; then TEST_VERSION=v9 else TEST_VERSION=v8 fi export TEST_VERSION TEST_REPAIR FROM_VERSION=${version} "${SCRIPT_DIR}/test_update_from_version.sh" return_code=$? if [ $return_code -ne 0 ]; then FAIL_COUNT=$((FAIL_COUNT + 1)) FAILED_VERSIONS="${FAILED_VERSIONS} ${version}" fi done fi echo -e "\nUpdate test finished for ${VERSIONS}\n" if [ $FAIL_COUNT -gt 0 ]; then echo -e "Failed versions: ${FAILED_VERSIONS}\n" echo -e "Postgres errors:\n" find update_test -name postgres.log -exec grep ERROR {} \; else echo -e "All tests succeeded.\n" fi exit $FAIL_COUNT �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/ts_dump.sh���������������������������������������������������������������0000775�0000000�0000000�00000003311�15100345067�0017552�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # This script is used for backing up a single hypertable into an easy-to-restore # tarball. The tarball contains two files: (1) a .sql file for recreating the # hypertable and its indices and (2) a .csv file containing the data as CSV. # # Because pg_dump/pg_restore dump all of TimescaleDB's internal tables when # used, this script is useful if you want a backup that can be restored # regardless of TimescaleDB version running, or as part of a process where you # do not want to always backup all your hypertables at once. if [[ -z "$1" || -z "$2" ]]; then echo "Usage: $0 hypertable output_name [pg_dump CONNECTION OPTIONS]" echo " hypertable - Hypertable to backup" echo " output_name - Output files will be stored in an archive named [output_name].tar.gz" echo " " echo "Any connection options for pg_dump/psql (e.g. -d database, -U username) should be listed at the end" exit 1 fi HYPERTABLE=$1 PREFIX=$2 shift 2 set -e echo "Backing up schema as $PREFIX-schema.sql..." pg_dump "$@" --schema-only -t $HYPERTABLE -f $PREFIX-schema.sql echo >> $PREFIX-schema.sql "-- -- Restore to hypertable --" psql "$@" -qAtX -c "SELECT _timescaledb_functions.get_create_command('$HYPERTABLE');" >> $PREFIX-schema.sql echo "Backing up data as $PREFIX-data.csv..." psql "$@" -c "\COPY (SELECT * FROM $HYPERTABLE) TO $PREFIX-data.csv DELIMITER ',' CSV" echo "Archiving and removing previous files..." tar -czvf $PREFIX.tar.gz $PREFIX-data.csv $PREFIX-schema.sql rm $PREFIX-data.csv rm $PREFIX-schema.sql �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/ts_restore.sh������������������������������������������������������������0000775�0000000�0000000�00000002443�15100345067�0020275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # This script is used for restoring a hypertable from a tarball made with # ts_dump.sh. It unarchives the tarball, producing a schema file and data file, # which are then restore separately. if [[ -z "$1" || -z "$2" ]]; then echo "Usage: $0 hypertable tarfile_name" echo " hypertable - Hypertable to restore" echo " tarfile_name - Name of the tarball created by ts_dump.sh to restore" echo " " echo "Any connection options for pg_restore/psql (e.g. -d database, -U username) should be listed at the end" exit 1 fi HYPERTABLE=$1 TARFILE=$2 PREFIX="${TARFILE/.tar.gz/}" shift 2 echo "Unarchiving tarball..." tar xvzf $TARFILE echo "Restoring hypertable's schema..." if ! psql -q -v "ON_ERROR_STOP=1" "$@" < $PREFIX-schema.sql then echo "Restoring schema failed, exiting." rm $PREFIX-data.csv rm $PREFIX-schema.sql exit $? fi echo "Restoring hypertable's data..." if ! psql "$@" -v "ON_ERROR_STOP=1" -c "\COPY $HYPERTABLE FROM $PREFIX-data.csv DELIMITER ',' CSV" then echo "Restoring data failed, exiting." fi rm $PREFIX-data.csv rm $PREFIX-schema.sql �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/scripts/upload_ci_stats.sh�������������������������������������������������������0000775�0000000�0000000�00000013465�15100345067�0021267�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash set -xue set -o pipefail if [ -z "${CI_STATS_DB:-}" ] then # The secret with the stats db connection string is not accessible in forks. echo "The statistics database connection string is not specified" exit 0 fi PSQL=${PSQL:-psql} PSQL=("${PSQL}" "${CI_STATS_DB}" -qtAX "--set=ON_ERROR_STOP=1") # The tables we are going to use. This schema is here just as a reminder, you'll # have to create them manually. After you manually change the actual DB schema, # don't forget to append the needed migration code below. : " create extension if not exists timescaledb; create table job( job_date timestamptz, -- Serves as a unique id. commit_sha text, job_name text, repository text, ref_name text, event_name text, pr_number int, job_status text, url text, run_attempt int, run_id bigint, run_number int, pg_version text generated always as ( substring(job_name from 'PG([0-9]+(\.[0-9]+)*)') ) stored ); create unique index on job(job_date); select create_hypertable('job', 'job_date'); create table test( job_date timestamptz, test_name text, test_status text, test_duration float ); create unique index on test(job_date, test_name); select create_hypertable('test', 'job_date'); create table log( job_date timestamptz, test_name text, log_contents text ); create unique index on log(job_date, test_name); select create_hypertable('log', 'job_date'); create table ipe( job_date timestamptz, error text, location text, statement text ); select create_hypertable('ipe', 'job_date'); " # Create the job record. COMMIT_SHA=$(git -C "$(dirname "${BASH_SOURCE[0]}")" rev-parse @) export COMMIT_SHA JOB_NAME="${JOB_NAME:-test-job}" export JOB_NAME JOB_DATE=$("${PSQL[@]}" -c " insert into job( job_date, commit_sha, job_name, repository, ref_name, event_name, pr_number, job_status, url, run_attempt, run_id, run_number ) values ( now(), '$COMMIT_SHA', '$JOB_NAME', '$GITHUB_REPOSITORY', '$GITHUB_REF_NAME', '$GITHUB_EVENT_NAME', '$GITHUB_PR_NUMBER', '$JOB_STATUS', 'https://github.com/timescale/timescaledb/actions/runs/$GITHUB_RUN_ID/attempts/$GITHUB_RUN_ATTEMPT', '$GITHUB_RUN_ATTEMPT', '$GITHUB_RUN_ID', '$GITHUB_RUN_NUMBER') returning job_date; ") export JOB_DATE # Parse the installcheck.log to find the individual test results. Note that this # file might not exist for failed checks or non-regression checks like SQLSmith. # We still want to save the other logs. if [ -f 'installcheck.log' ] then gawk -v OFS='\t' ' match($0, /^(test| ) ([^ ]+)[ ]+\.\.\.[ ]+([^ ]+) (|\(.*\))[ ]+([0-9]+) ms$/, a) { print ENVIRON["JOB_DATE"], a[2], tolower(a[3] (a[4] ? (" " a[4]) : "")), a[5]; } match($0, /^([^0-9]+) [0-9]+ +[-+] ([^ ]+) +([0-9]+) ms/, a) { print ENVIRON["JOB_DATE"], a[2], a[1], a[3]; } ' installcheck.log > tests.tsv # Save the test results into the database. "${PSQL[@]}" -c "\copy test from tests.tsv" # Split the regression.diffs into per-test files. gawk ' match($0, /^(diff|\+\+\+|\-\-\-) .*\/(.*)[.]out/, a) { file = a[2] ".diff"; next; } { if (file) print $0 > file; } ' regression.log fi # Snip the long sequences of "+" or "-" changes in the diffs. for x in *.diff; do if ! [ -f "$x" ] ; then continue ; fi gawk -v max_context_lines=10 -v min_context_lines=2 ' /^-/ { new_sign = "-" } /^+/ { new_sign = "+" } /^[^+-]/ { new_sign = " " } { if (old_sign != new_sign) { to_print = lines_buffered > max_context_lines ? min_context_lines : lines_buffered; if (lines_buffered > to_print) print "<" lines_buffered - to_print " lines skipped>"; for (i = 0; i < to_print; i++) { print buf[(NR + i - to_print) % max_context_lines] } printf("c %04d: %s\n", NR, $0); old_sign = new_sign; lines_printed = 0; lines_buffered = 0; } else { if (lines_printed >= min_context_lines) { lines_buffered++; buf[NR % max_context_lines] = sprintf("b %04d: %s", NR, $0) } else { lines_printed++; printf("p %04d: %s\n", NR, $0); } } } END { to_print = lines_buffered > max_context_lines ? min_context_lines : lines_buffered; if (lines_buffered > to_print) print "<" lines_buffered - to_print " lines skipped>"; for (i = 0; i < to_print; i++) { print buf[(NR + 1 + i - to_print) % max_context_lines] } }' "$x" > "$x.tmp" mv "$x.tmp" "$x" done # Save a snippet of logs where a backend was terminated by signal. grep -C40 "was terminated by signal" postmaster.log > postgres-failure.log ||: # Find internal program errors and resource owner leak warnings in the sever log. # We do the same thing in Flaky Check and error out if we find any, not to # introduce these errors for the new tests. jq 'select( (.state_code == "XX000" and .error_severity != "LOG") or (.message | test("resource was not closed")) ) | [env.JOB_DATE, .message, .func_name, .statement] | @tsv ' -r postmaster.json > ipe.tsv ||: "${PSQL[@]}" -c "\copy ipe from ipe.tsv" # Upload the logs. # Note that the sanitizer setting log_path means "write logs to 'log_path.pid'". for x in sanitizer* sanitizer/* {sqlsmith/sqlsmith,sanitizer,stacktrace,postgres-failure}.log *.diff do if ! [ -e "$x" ]; then continue ; fi "${PSQL[@]}" <<<" \set contents \`cat $x\` insert into log values ('$JOB_DATE', '$(basename "$x" .diff)', :'contents'); " done �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/�����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0014652�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/CMakeLists.txt���������������������������������������������������������������0000664�0000000�0000000�00000022712�15100345067�0017416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(INSTALL_FILE ${PROJECT_NAME}--${PROJECT_VERSION_MOD}.sql) include(ScriptFiles) # These files represent the modifications that happen in each version, excluding # new objects or updates to functions. We use them to build a path (update # script) from every historical version to the current version. Note that not # all of these files may exist on disk, in case they would have no contents. # There still needs to be an entry here to build an update script for that # version. Thus, for every new release, an entry should be added here. set(MOD_FILES updates/2.9.0--2.9.1.sql updates/2.9.1--2.9.2.sql updates/2.9.2--2.9.3.sql updates/2.9.3--2.10.0.sql updates/2.10.0--2.10.1.sql updates/2.10.1--2.10.2.sql updates/2.10.2--2.10.3.sql updates/2.10.3--2.11.0.sql updates/2.11.0--2.11.1.sql updates/2.11.1--2.11.2.sql updates/2.11.2--2.12.0.sql updates/2.12.0--2.12.1.sql updates/2.12.1--2.12.2.sql updates/2.12.2--2.13.0.sql updates/2.13.0--2.13.1.sql updates/2.13.1--2.14.0.sql updates/2.14.0--2.14.1.sql updates/2.14.1--2.14.2.sql updates/2.14.2--2.15.0.sql updates/2.15.0--2.15.1.sql updates/2.15.1--2.15.2.sql updates/2.15.2--2.15.3.sql updates/2.15.3--2.16.0.sql updates/2.16.0--2.16.1.sql updates/2.16.1--2.17.0.sql updates/2.17.0--2.17.1.sql updates/2.17.1--2.17.2.sql updates/2.17.2--2.18.0.sql updates/2.18.0--2.18.1.sql updates/2.18.1--2.18.2.sql updates/2.18.2--2.19.0.sql updates/2.19.0--2.19.1.sql updates/2.19.1--2.19.2.sql updates/2.19.2--2.19.3.sql updates/2.19.3--2.20.0.sql updates/2.20.0--2.20.1.sql updates/2.20.1--2.20.2.sql updates/2.20.2--2.20.3.sql updates/2.20.3--2.21.0.sql updates/2.21.0--2.21.1.sql updates/2.21.1--2.21.2.sql updates/2.21.2--2.21.3.sql updates/2.21.3--2.21.4.sql updates/2.21.4--2.22.0.sql updates/2.22.0--2.22.1.sql updates/2.22.1--2.23.0.sql) # The downgrade file to generate a downgrade script for the current version, as # specified in version.config set(CURRENT_REV_FILE 2.23.0--2.22.1.sql) set(MODULE_PATHNAME "$libdir/timescaledb-${PROJECT_VERSION_MOD}") set(LOADER_PATHNAME "$libdir/timescaledb") set(TS_MODULE_PATHNAME ${MODULE_PATHNAME} PARENT_SCOPE) set(TSL_MODULE_PATHNAME "$libdir/timescaledb-tsl-${PROJECT_VERSION_MOD}" PARENT_SCOPE) if(NOT GENERATE_DOWNGRADE_SCRIPT) message( STATUS "Not generating downgrade script: downgrade generation disabled.") elseif(NOT GIT_FOUND) message(STATUS "Not generating downgrade script: Git not available.") else() generate_downgrade_script( SOURCE_VERSION ${PROJECT_VERSION_MOD} TARGET_VERSION ${PREVIOUS_VERSION} INPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/updates FILES ${CURRENT_REV_FILE}) endif() # Function to replace @MODULE_PATHNAME@ in source files, producing an output # file in the build dir function(version_files SRC_FILE_LIST OUTPUT_FILE_LIST) set(result "") foreach(unversioned_file ${SRC_FILE_LIST}) set(versioned_file ${unversioned_file}) list(APPEND result ${CMAKE_CURRENT_BINARY_DIR}/${versioned_file}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${unversioned_file}) configure_file(${unversioned_file} ${versioned_file} @ONLY) endif() endforeach(unversioned_file) set(${OUTPUT_FILE_LIST} "${result}" PARENT_SCOPE) endfunction() # Function to replace @VARIABLE@ in source files, producing an output file in # the build dir. Unlike the previous function we need to build a versioned file # for every version we create an update script for. function(version_check_file SRC_FILE_LIST OUTPUT_FILE_LIST) set(result "") foreach(unversioned_file ${SRC_FILE_LIST}) set(versioned_file ${unversioned_file}-${START_VERSION}) list(APPEND result ${CMAKE_CURRENT_BINARY_DIR}/${versioned_file}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${unversioned_file}) configure_file(${unversioned_file} ${versioned_file} @ONLY) endif() endforeach(unversioned_file) set(${OUTPUT_FILE_LIST} "${result}" PARENT_SCOPE) endfunction() # Create versioned files (replacing MODULE_PATHNAME) in the build directory of # all our source files version_files("${PRE_UPDATE_FILES}" PRE_UPDATE_FILES_VERSIONED) version_files("${POST_UPDATE_FILES}" POST_UPDATE_FILES_VERSIONED) version_files("${PRE_INSTALL_SOURCE_FILES}" PRE_INSTALL_SOURCE_FILES_VERSIONED) version_files("${PRE_INSTALL_FUNCTION_FILES}" PRE_INSTALL_FUNCTION_FILES_VERSIONED) version_files("${SOURCE_FILES}" SOURCE_FILES_VERSIONED) version_files("${MOD_FILES}" MOD_FILES_VERSIONED) version_files("updates/latest-dev.sql" LASTEST_MOD_VERSIONED) version_files("notice.sql" NOTICE_FILE) # Function to concatenate all files in SRC_FILE_LIST into file OUTPUT_FILE function(cat_files SRC_FILE_LIST OUTPUT_FILE) if(WIN32) set("SRC_ARG" "-DSRC_FILE_LIST=${SRC_FILE_LIST}") else() set("SRC_ARG" "'-DSRC_FILE_LIST=${SRC_FILE_LIST}'") endif() add_custom_command( OUTPUT ${OUTPUT_FILE} DEPENDS ${SRC_FILE_LIST} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${CMAKE_COMMAND} "${SRC_ARG}" "-DOUTPUT_FILE=${OUTPUT_FILE}" -P cat.cmake COMMENT "Generating ${OUTPUT_FILE}") endfunction() # Concatenate all files in SRC_FILE_LIST into file OUTPUT_FILE Additionally # strips out `OR REPLACE` from the generated file as this would allow a # privilege escalation attack when present in the CREATE script function(cat_create_files SRC_FILE_LIST OUTPUT_FILE) if(WIN32) set("SRC_ARG" "-DSRC_FILE_LIST=${SRC_FILE_LIST}") else() set("SRC_ARG" "'-DSRC_FILE_LIST=${SRC_FILE_LIST}'") endif() if(WIN32) add_custom_command( OUTPUT ${OUTPUT_FILE} DEPENDS ${SRC_FILE_LIST} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${CMAKE_COMMAND} "${SRC_ARG}" "-DOUTPUT_FILE=${OUTPUT_FILE}" "-DSTRIP_REPLACE=ON" -P cat.cmake COMMENT "Generating ${OUTPUT_FILE}") else() add_custom_command( OUTPUT ${OUTPUT_FILE} DEPENDS ${SRC_FILE_LIST} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${CMAKE_COMMAND} "'-DSRC_FILE_LIST=${SRC_FILE_LIST}'" "-DOUTPUT_FILE=${OUTPUT_FILE}" "-DSTRIP_REPLACE=ON" -P cat.cmake COMMENT "Generating ${OUTPUT_FILE}") endif() endfunction() # Generate the extension file used with CREATE EXTENSION cat_create_files( "${PRE_INSTALL_SOURCE_FILES_VERSIONED};${SOURCE_FILES_VERSIONED};${NOTICE_FILE}" ${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_FILE}) add_custom_target(sqlfile ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_FILE}) # Generate the update files used with ALTER EXTENSION <name> UPDATE set(MOD_FILE_REGEX "([0-9]+\\.[0-9]+\\.*[0-9]+[-a-z0-9]*)--([0-9]+\\.[0-9]+\\.*[0-9]+[-a-z0-9]*).sql" ) # We'd like to process the updates in reverse (descending) order if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/updates/${PREVIOUS_VERSION}--${PROJECT_VERSION_MOD}.sql" ) set(MOD_FILES_LIST ${MOD_FILES_VERSIONED}) else() set(MOD_FILES_LIST "${MOD_FILES_VERSIONED};updates/${PREVIOUS_VERSION}--${PROJECT_VERSION_MOD}.sql" ) endif() list(REVERSE MOD_FILES_LIST) # Variable that will hold the list of update scripts from every previous version # to the current version set(UPDATE_SCRIPTS "") # A list of current modfiles. We append to this list for every previous version # that moves us further away from the current version, thus making the update # path longer as we move back in history set(CURR_MOD_FILES "${LASTEST_MOD_VERSIONED}") # Now loop through the modfiles and generate the update files foreach(transition_mod_file ${MOD_FILES_LIST}) if(NOT (${transition_mod_file} MATCHES ${MOD_FILE_REGEX})) message(FATAL_ERROR "Cannot parse update file name ${transition_mod_file}") endif() set(START_VERSION ${CMAKE_MATCH_1}) set(END_VERSION ${CMAKE_MATCH_2}) set(PRE_FILES ${PRE_UPDATE_FILES_VERSIONED}) set(POST_FILES_PROCESSED ${POST_UPDATE_FILES_VERSIONED}.processed) cat_files( "${SET_POST_UPDATE_STAGE};${POST_UPDATE_FILES_VERSIONED};${UNSET_UPDATE_STAGE}" ${POST_FILES_PROCESSED}) # Check for version-specific update code with fixes if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/updates/${START_VERSION}.sql) version_files("updates/${START_VERSION}.sql" ORIGIN_MOD_FILE) list(APPEND PRE_FILES ${ORIGIN_MOD_FILE}) endif() version_check_file("updates/version_check.sql" VERSION_CHECK_VERSIONED) list(PREPEND PRE_FILES ${VERSION_CHECK_VERSIONED}) # There might not have been any changes in the modfile, in which case the # modfile need not be present if(EXISTS ${transition_mod_file}) # Prepend the modfile as we are moving through the versions in descending # order list(INSERT CURR_MOD_FILES 0 ${transition_mod_file}) endif() set(UPDATE_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/timescaledb--${START_VERSION}--${PROJECT_VERSION_MOD}.sql ) list(APPEND UPDATE_SCRIPTS ${UPDATE_SCRIPT}) if(CURR_MOD_FILES) cat_files( "${PRE_FILES};${CURR_MOD_FILES};${PRE_INSTALL_FUNCTION_FILES_VERSIONED};${SOURCE_FILES_VERSIONED};${POST_FILES_PROCESSED}" ${UPDATE_SCRIPT}) else() cat_files( "${PRE_FILES};${PRE_INSTALL_FUNCTION_FILES_VERSIONED};${SOURCE_FILES_VERSIONED};${POST_FILES_PROCESSED}" ${UPDATE_SCRIPT}) endif() endforeach(transition_mod_file) add_custom_target(sqlupdatescripts ALL DEPENDS ${UPDATE_SCRIPTS}) # Install target for the extension file and update scripts install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${INSTALL_FILE} ${UPDATE_SCRIPTS} DESTINATION "${PG_SHAREDIR}/extension") ������������������������������������������������������timescaledb-2.23.0/sql/bgw_scheduler.sql������������������������������������������������������������0000664�0000000�0000000�00000001236�15100345067�0020212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.restart_background_workers() RETURNS BOOL AS '@LOADER_PATHNAME@', 'ts_bgw_db_workers_restart' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.stop_background_workers() RETURNS BOOL AS '@LOADER_PATHNAME@', 'ts_bgw_db_workers_stop' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.start_background_workers() RETURNS BOOL AS '@LOADER_PATHNAME@', 'ts_bgw_db_workers_start' LANGUAGE C VOLATILE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/bgw_startup.sql��������������������������������������������������������������0000664�0000000�0000000�00000000363�15100345067�0017736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT _timescaledb_functions.restart_background_workers(); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/bookend.sql������������������������������������������������������������������0000664�0000000�0000000�00000006505�15100345067�0017022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.first_sfunc(internal, anyelement, "any") RETURNS internal AS '@MODULE_PATHNAME@', 'ts_first_sfunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.first_combinefunc(internal, internal) RETURNS internal AS '@MODULE_PATHNAME@', 'ts_first_combinefunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.last_sfunc(internal, anyelement, "any") RETURNS internal AS '@MODULE_PATHNAME@', 'ts_last_sfunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.last_combinefunc(internal, internal) RETURNS internal AS '@MODULE_PATHNAME@', 'ts_last_combinefunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.bookend_finalfunc(internal, anyelement, "any") RETURNS anyelement AS '@MODULE_PATHNAME@', 'ts_bookend_finalfunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.bookend_serializefunc(internal) RETURNS bytea AS '@MODULE_PATHNAME@', 'ts_bookend_serializefunc' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.bookend_deserializefunc(bytea, internal) RETURNS internal AS '@MODULE_PATHNAME@', 'ts_bookend_deserializefunc' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; -- We started using CREATE OR REPLACE AGGREGATE for aggregate creation once the syntax was fully supported -- as it is easier to support idempotent changes this way. This will allow for changes to functions supporting -- the aggregate, and, for instance, the definition and inclusion of inverse functions for window function -- support. However, it should still be noted that changes to the data structures used for the internal -- state of the aggregate must be backwards compatible and the old format must be accepted by any new functions -- in order for them to continue working with Continuous Aggregates, where old states may have been materialized. --This aggregate returns the "first" value of the first argument when ordered by the second argument. --Ex. first(temp, time) returns the temp value for the row with the lowest time CREATE OR REPLACE AGGREGATE @extschema@.first(anyelement, "any") ( SFUNC = _timescaledb_functions.first_sfunc, STYPE = internal, COMBINEFUNC = _timescaledb_functions.first_combinefunc, SERIALFUNC = _timescaledb_functions.bookend_serializefunc, DESERIALFUNC = _timescaledb_functions.bookend_deserializefunc, PARALLEL = SAFE, FINALFUNC = _timescaledb_functions.bookend_finalfunc, FINALFUNC_EXTRA ); --This aggregate returns the "last" value of the first argument when ordered by the second argument. --Ex. last(temp, time) returns the temp value for the row with highest time CREATE OR REPLACE AGGREGATE @extschema@.last(anyelement, "any") ( SFUNC = _timescaledb_functions.last_sfunc, STYPE = internal, COMBINEFUNC = _timescaledb_functions.last_combinefunc, SERIALFUNC = _timescaledb_functions.bookend_serializefunc, DESERIALFUNC = _timescaledb_functions.bookend_deserializefunc, PARALLEL = SAFE, FINALFUNC = _timescaledb_functions.bookend_finalfunc, FINALFUNC_EXTRA ); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/cagg_api.sql�����������������������������������������������������������������0000664�0000000�0000000�00000033466�15100345067�0017141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Get information about the materialization table and bucket width. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_materialization_info( continuous_aggregate REGCLASS ) RETURNS RECORD AS $body$ DECLARE info RECORD; BEGIN SELECT mat_hypertable_id AS materialization_id, bucket_width::interval AS bucket_width INTO info FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) WHERE format('%I.%I', user_view_schema, user_view_name)::regclass = continuous_aggregate; IF NOT FOUND THEN RAISE '"%" is not a continuous aggregate', continuous_aggregate USING ERRCODE = 'wrong_object_type'; END IF; RETURN info; END $body$ LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp; -- Get hypertable id for a hypertable and execute common checks to -- avoid duplicating them in the overloaded functions below. -- -- This function is part of the internal API and not intended for -- public consumption. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_hypertable_id( hypertable REGCLASS, column_type REGTYPE ) RETURNS integer AS $body$ DECLARE info RECORD; BEGIN SELECT ht.id AS hypertable_id, di.column_type::regtype, EXISTS(SELECT FROM _timescaledb_catalog.continuous_agg where raw_hypertable_id = ht.id) AS has_cagg INTO info FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.dimension di ON ht.id = di.hypertable_id WHERE format('%I.%I', schema_name, table_name)::regclass = hypertable AND di.interval_length IS NOT NULL; IF info IS NULL THEN RAISE EXCEPTION 'table "%" is not a hypertable', hypertable USING ERRCODE = 'object_not_in_prerequisite_state'; END IF; IF NOT info.has_cagg THEN RAISE EXCEPTION 'hypertable "%" has no continuous aggregate', hypertable USING HINT = 'Define a continuous aggregate for the hypertable to read invalidations.', ERRCODE = 'object_not_in_prerequisite_state'; END IF; IF info.column_type <> get_hypertable_id.column_type THEN RAISE EXCEPTION 'wrong column type for hypertable %', hypertable USING HINT = format('hypertable type was "%s", but caller expected "%s"', info.column_type, get_hypertable_id.column_type), ERRCODE = 'datatype_mismatch'; END IF; RETURN info.hypertable_id; END $body$ LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp; -- Get hypertable invalidations ranges based on bucket size. -- -- This will return a multirange for each bucket size passed in and a -- token that can be used to accept the multirange. -- -- Note that the token returned is not unique for each bucket size and -- represents either the LSN or a Snapshot of what data was read to -- produce the bucket ranges. -- -- Currently, we only have support for timestamp with and without -- timezone, but it is straightforward to add similar implementations -- for integer types. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_hypertable_invalidations( hypertable REGCLASS, base TIMESTAMPTZ, bucket_widths INTERVAL[] ) RETURNS TABLE (bucket_width INTERVAL, token TEXT, invalidations TSTZMULTIRANGE) AS $body$ DECLARE l_hypertable_id INTEGER := _timescaledb_functions.get_hypertable_id(hypertable, 'timestamptz'::regtype); BEGIN RETURN QUERY ( WITH -- Collect ranges from the invalidation log and convert them -- to correct type. timestamps AS MATERIALIZED ( SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS start, _timescaledb_functions.to_timestamp(greatest_modified_value) AS finish FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = l_hypertable_id ), -- Since a range can end at the end of a bucket and this -- range should not include the next bucket, we need to -- subtract one microsecond before computing the bucket and -- then add the width again. ranges AS MATERIALIZED ( SELECT width, tstzrange(@extschema@.time_bucket(width, start), @extschema@.time_bucket(width, finish - '1 microsecond'::interval) + width) AS bucket FROM timestamps CROSS JOIN UNNEST(bucket_widths) w(width) ) SELECT width, pg_current_snapshot()::text, range_agg(bucket) ranges FROM ranges GROUP BY width ); END $body$ LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_hypertable_invalidations( hypertable REGCLASS, base TIMESTAMP, bucket_widths INTERVAL[] ) RETURNS TABLE (bucket_width INTERVAL, token TEXT, invalidations TSMULTIRANGE) AS $body$ DECLARE l_hypertable_id INTEGER := _timescaledb_functions.get_hypertable_id(hypertable, 'timestamp'::regtype); BEGIN RETURN QUERY ( WITH -- Collect ranges from the invalidation log and convert them -- to correct type. timestamps AS MATERIALIZED ( SELECT _timescaledb_functions.to_timestamp_without_timezone(lowest_modified_value) AS start, _timescaledb_functions.to_timestamp_without_timezone(greatest_modified_value) AS finish FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = l_hypertable_id ), -- Compute bucket-aligned ranges from the ranges above. Since -- a range can end at the end of a bucket and this range -- should not include the next bucket, we need to subtract -- one microsecond before computing the bucket and then add -- the width again. ranges AS MATERIALIZED ( SELECT width, tsrange(@extschema@.time_bucket(width, start), @extschema@.time_bucket(width, finish - '1 microsecond'::interval) + width) AS bucket FROM timestamps CROSS JOIN UNNEST(bucket_widths) w(width) ) SELECT width, pg_current_snapshot()::text, range_agg(bucket) FROM ranges GROUP BY width ); END $body$ LANGUAGE plpgsql SET search_path TO pg_catalog, pg_temp; -- Add new invalidations to the materialization invalidation log. -- -- This will add the range to the materialization invalidations for -- the continuous aggregate. The range will automatically be "aligned" -- to the bucket width to ensure that it covers all buckets that it -- touches. CREATE OR REPLACE PROCEDURE _timescaledb_functions.add_materialization_invalidations( continuous_aggregate regclass, invalidation tsrange ) AS $body$ DECLARE info RECORD := _timescaledb_functions.get_materialization_info(continuous_aggregate); aligned TSRANGE := _timescaledb_functions.align_to_bucket(info.bucket_width, invalidation); BEGIN INSERT INTO _timescaledb_catalog.continuous_aggs_materialization_invalidation_log VALUES (info.materialization_id, _timescaledb_functions.to_unix_microseconds(lower(aligned)), _timescaledb_functions.to_unix_microseconds(upper(aligned))); END $body$ LANGUAGE plpgsql SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_functions.add_materialization_invalidations( continuous_aggregate REGCLASS, invalidation TSTZRANGE ) AS $body$ DECLARE info RECORD := _timescaledb_functions.get_materialization_info(continuous_aggregate); aligned TSTZRANGE := _timescaledb_functions.align_to_bucket(info.bucket_width, invalidation); BEGIN INSERT INTO _timescaledb_catalog.continuous_aggs_materialization_invalidation_log VALUES (info.materialization_id, _timescaledb_functions.to_unix_microseconds(lower(aligned)), _timescaledb_functions.to_unix_microseconds(upper(aligned))); END $body$ LANGUAGE plpgsql SET search_path TO pg_catalog, pg_temp; -- Get raw ranges from the materialization invalidation log -- -- This is a cleaned-up version of the timestamps, still in Unix -- microseconds, with nulls for '-infinity' and '+infinity' and -- invalid entries removed. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_raw_materialization_ranges(typ regtype) RETURNS TABLE (materialization_id integer, lowest_modified_value bigint, greatest_modified_value bigint) AS $$ WITH min_max_values AS MATERIALIZED ( SELECT _timescaledb_functions.get_internal_time_min(typ) AS min, _timescaledb_functions.get_internal_time_max(typ) AS max ) SELECT materialization_id, NULLIF(lowest_modified_value, min_max_values.min), NULLIF(greatest_modified_value, min_max_values.max) FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log, min_max_values WHERE lowest_modified_value BETWEEN min_max_values.min AND min_max_values.max AND greatest_modified_value BETWEEN min_max_values.min AND min_max_values.max $$ LANGUAGE SQL SET search_path TO pg_catalog, pg_temp; -- Get materialization invalidations for a continuous aggregate. -- -- Note that this will modify the materialization invalidation table -- to be able to extract the restricted range of invalidations. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_materialization_invalidations( continuous_aggregate REGCLASS, restriction TSTZRANGE ) RETURNS TABLE (invalidations TSTZMULTIRANGE) AS $body$ DECLARE info RECORD := _timescaledb_functions.get_materialization_info(continuous_aggregate); aligned TSTZRANGE := _timescaledb_functions.align_to_bucket(info.bucket_width, restriction); BEGIN -- Compute the multirange for the invalidations inside the -- restriction passed down to the function and return the ranges. RETURN QUERY WITH ranges AS ( SELECT materialization_id, range_agg(_timescaledb_functions.make_multirange_from_internal_time( null::tstzrange, lowest_modified_value, greatest_modified_value)) AS invals FROM _timescaledb_functions.get_raw_materialization_ranges('timestamptz'::regtype) GROUP BY materialization_id ) SELECT range_agg(invals * multirange(aligned)) FROM ranges WHERE invals && aligned AND materialization_id = info.materialization_id; END $body$ LANGUAGE plpgsql SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_materialization_invalidations( continuous_aggregate REGCLASS, restriction TSRANGE ) RETURNS TABLE (invalidations TSMULTIRANGE) AS $body$ DECLARE info RECORD := _timescaledb_functions.get_materialization_info(continuous_aggregate); aligned TSRANGE := _timescaledb_functions.align_to_bucket(info.bucket_width, restriction); BEGIN -- Compute the multirange for the invalidations inside the -- restriction passed down to the function and return the ranges. RETURN QUERY WITH ranges AS ( SELECT materialization_id, range_agg(_timescaledb_functions.make_multirange_from_internal_time( null::tsrange, lowest_modified_value, greatest_modified_value)) AS invals FROM _timescaledb_functions.get_raw_materialization_ranges('timestamp'::regtype) GROUP BY materialization_id ) SELECT range_agg(invals * multirange(aligned)) FROM ranges WHERE invals && aligned AND materialization_id = info.materialization_id; END $body$ LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp; -- Accept a set of hypertable invalidations for a hypertable. -- -- This procedure is used to accept all invalidations for a hypertable -- using the token returned by a previous call of -- get_hypertable_invalidations(). CREATE OR REPLACE PROCEDURE _timescaledb_functions.accept_hypertable_invalidations( hypertable REGCLASS, token TEXT ) AS $body$ DECLARE info RECORD; errmsg TEXT; BEGIN SELECT ht.id AS hypertable_id, (cagg.raw_hypertable_id IS NOT NULL) AS has_cagg INTO info FROM _timescaledb_catalog.hypertable ht LEFT JOIN _timescaledb_catalog.continuous_agg cagg ON cagg.raw_hypertable_id = ht.id WHERE format('%I.%I', schema_name, table_name)::regclass = hypertable; IF info IS NULL THEN RAISE EXCEPTION 'table "%" is not a hypertable', hypertable USING ERRCODE = 'object_not_in_prerequisite_state'; END IF; IF NOT info.has_cagg THEN RAISE EXCEPTION 'hypertable "%" has no continuous aggregate', hypertable USING HINT = 'Define a continuous aggregate for the hypertable to handle invalidations.', ERRCODE = 'object_not_in_prerequisite_state'; END IF; DELETE FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = info.hypertable_id AND pg_visible_in_snapshot(xmin::text::xid8, token::pg_snapshot); EXCEPTION WHEN invalid_text_representation THEN RAISE EXCEPTION '%', SQLERRM USING HINT = 'Use the token from the get_hypertable_invalidations() call.', ERRCODE = 'invalid_text_representation'; END $body$ LANGUAGE plpgsql SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_functions.process_hypertable_invalidations( hypertable NAME ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_continuous_agg_process_hypertable_invalidations'; CREATE OR REPLACE PROCEDURE _timescaledb_functions.process_hypertable_invalidations( hypertable REGCLASS ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_continuous_agg_process_hypertable_invalidations'; CREATE OR REPLACE PROCEDURE _timescaledb_functions.process_hypertable_invalidations( hypertables REGCLASS[] ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_continuous_agg_process_hypertable_invalidations'; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/cagg_migrate.sql�������������������������������������������������������������0000664�0000000�0000000�00000063155�15100345067�0020016�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains functions and procedures to migrate old continuous -- aggregate format to the finals form (without partials). -- Check if exists a plan for migrationg a given cagg CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_migrate_plan_exists ( _hypertable_id INTEGER ) RETURNS BOOLEAN LANGUAGE sql AS $BODY$ SELECT EXISTS ( SELECT 1 FROM _timescaledb_catalog.continuous_agg_migrate_plan WHERE mat_hypertable_id = _hypertable_id AND end_ts IS NOT NULL ); $BODY$ SET search_path TO pg_catalog, pg_temp; -- Execute all pre-validations required to execute the migration CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_migrate_pre_validation ( _cagg_schema TEXT, _cagg_name TEXT, _cagg_name_new TEXT ) RETURNS _timescaledb_catalog.continuous_agg LANGUAGE plpgsql AS $BODY$ DECLARE _cagg_data _timescaledb_catalog.continuous_agg; BEGIN SELECT * INTO _cagg_data FROM _timescaledb_catalog.continuous_agg WHERE user_view_schema = _cagg_schema AND user_view_name = _cagg_name; IF NOT FOUND THEN RAISE EXCEPTION 'continuous aggregate "%.%" does not exist', _cagg_schema, _cagg_name; END IF; IF _cagg_data.finalized IS TRUE THEN RAISE EXCEPTION 'continuous aggregate "%.%" does not require any migration', _cagg_schema, _cagg_name; END IF; IF _timescaledb_functions.cagg_migrate_plan_exists(_cagg_data.mat_hypertable_id) IS TRUE THEN RAISE EXCEPTION 'plan already exists for continuous aggregate %.%', _cagg_schema, _cagg_name; END IF; IF EXISTS ( SELECT FROM _timescaledb_catalog.continuous_agg WHERE user_view_schema = _cagg_schema AND user_view_name = _cagg_name_new AND NOT EXISTS ( SELECT FROM _timescaledb_catalog.continuous_agg_migrate_plan WHERE mat_hypertable_id = _cagg_data.mat_hypertable_id AND end_ts IS NULL ) ) THEN RAISE EXCEPTION 'continuous aggregate "%.%" already exists', _cagg_schema, _cagg_name_new; END IF; RETURN _cagg_data; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Create migration plan for given cagg CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_create_plan ( _cagg_data _timescaledb_catalog.continuous_agg, _cagg_name_new TEXT, _override BOOLEAN DEFAULT FALSE, _drop_old BOOLEAN DEFAULT FALSE ) LANGUAGE plpgsql AS $BODY$ DECLARE _sql TEXT; _matht RECORD; _time_interval INTERVAL; _integer_interval BIGINT; _watermark TEXT; _policies JSONB; _bucket_column_name TEXT; _bucket_column_type TEXT; _interval_type TEXT; _interval_value TEXT; _nbuckets INTEGER := 10; -- number of buckets per transaction BEGIN IF _timescaledb_functions.cagg_migrate_plan_exists(_cagg_data.mat_hypertable_id) IS TRUE THEN RAISE EXCEPTION 'plan already exists for materialized hypertable %', _cagg_data.mat_hypertable_id; END IF; -- If exist steps for this migration means that it's resuming the execution IF EXISTS ( SELECT 1 FROM _timescaledb_catalog.continuous_agg_migrate_plan_step WHERE mat_hypertable_id = _cagg_data.mat_hypertable_id ) THEN RAISE WARNING 'resuming the migration of the continuous aggregate "%.%"', _cagg_data.user_view_schema, _cagg_data.user_view_name; RETURN; END IF; INSERT INTO _timescaledb_catalog.continuous_agg_migrate_plan (mat_hypertable_id, user_view_definition) VALUES ( _cagg_data.mat_hypertable_id, pg_get_viewdef(format('%I.%I', _cagg_data.user_view_schema, _cagg_data.user_view_name)::regclass) ); SELECT schema_name, table_name INTO _matht FROM _timescaledb_catalog.hypertable WHERE id = _cagg_data.mat_hypertable_id; SELECT time_interval, integer_interval, column_name, column_type INTO _time_interval, _integer_interval, _bucket_column_name, _bucket_column_type FROM timescaledb_information.dimensions WHERE hypertable_schema = _matht.schema_name AND hypertable_name = _matht.table_name AND dimension_type = 'Time'; -- Get the current cagg bucket width SELECT bucket_width INTO _interval_value FROM _timescaledb_functions.cagg_get_bucket_function_info(_cagg_data.mat_hypertable_id); IF _integer_interval IS NOT NULL THEN _interval_type := _bucket_column_type; IF _bucket_column_type = 'bigint' THEN _watermark := COALESCE(_timescaledb_functions.cagg_watermark(_cagg_data.mat_hypertable_id)::bigint, '-9223372036854775808'::bigint)::TEXT; ELSIF _bucket_column_type = 'integer' THEN _watermark := COALESCE(_timescaledb_functions.cagg_watermark(_cagg_data.mat_hypertable_id)::integer, '-2147483648'::integer)::TEXT; ELSE _watermark := COALESCE(_timescaledb_functions.cagg_watermark(_cagg_data.mat_hypertable_id)::smallint, '-32768'::smallint)::TEXT; END IF; ELSE _interval_type := 'interval'; -- We expect an ISO date later in parsing (i.e., min value has to be '4714-11-24 00:53:28+00:53:28 BC') SET LOCAL datestyle = 'ISO, MDY'; IF _bucket_column_type = 'timestamp with time zone' THEN _watermark := COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(_cagg_data.mat_hypertable_id)), '-infinity'::timestamptz)::TEXT; ELSE _watermark := COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(_cagg_data.mat_hypertable_id)), '-infinity'::timestamp)::TEXT; END IF; END IF; -- get all scheduled policies except the refresh SELECT jsonb_build_object('policies', array_agg(id ORDER BY id)) INTO _policies FROM _timescaledb_config.bgw_job WHERE hypertable_id = _cagg_data.mat_hypertable_id AND proc_name IS DISTINCT FROM 'policy_refresh_continuous_aggregate' AND scheduled IS TRUE AND id >= 1000; INSERT INTO _timescaledb_catalog.continuous_agg_migrate_plan_step (mat_hypertable_id, type, config) VALUES (_cagg_data.mat_hypertable_id, 'SAVE WATERMARK', jsonb_build_object('watermark', _watermark)), (_cagg_data.mat_hypertable_id, 'CREATE NEW CAGG', jsonb_build_object('cagg_name_new', _cagg_name_new)), (_cagg_data.mat_hypertable_id, 'DISABLE POLICIES', _policies), (_cagg_data.mat_hypertable_id, 'REFRESH NEW CAGG', jsonb_build_object('cagg_name_new', _cagg_name_new, 'window_start', _watermark, 'window_start_type', _bucket_column_type)); -- Finish the step because don't require any extra step UPDATE _timescaledb_catalog.continuous_agg_migrate_plan_step SET status = 'FINISHED', start_ts = now(), end_ts = clock_timestamp() WHERE type = 'SAVE WATERMARK'; _sql := format ( $$ WITH boundaries AS ( SELECT min(%1$I), max(%1$I), %1$L AS bucket_column_name, %2$L AS bucket_column_type, %3$L AS cagg_name_new FROM %4$I.%5$I WHERE %1$I < CAST(%6$L AS %2$s) ) INSERT INTO _timescaledb_catalog.continuous_agg_migrate_plan_step (mat_hypertable_id, type, config) SELECT %7$L, 'COPY DATA', jsonb_build_object ( 'start_ts', start::text, 'end_ts', (start + (CAST(%8$L AS %9$s) * %10$s) )::text, 'bucket_column_name', bucket_column_name, 'bucket_column_type', bucket_column_type, 'cagg_name_new', cagg_name_new ) FROM boundaries, LATERAL generate_series(min, max, (CAST(%8$L AS %9$s) * %10$s)) AS start; $$, _bucket_column_name, _bucket_column_type, _cagg_name_new, _matht.schema_name, _matht.table_name, _watermark, _cagg_data.mat_hypertable_id, _interval_value, _interval_type, _nbuckets ); EXECUTE _sql; -- get all scheduled policies SELECT jsonb_build_object('policies', array_agg(id ORDER BY id)) INTO _policies FROM _timescaledb_config.bgw_job WHERE hypertable_id = _cagg_data.mat_hypertable_id AND scheduled IS TRUE AND id >= 1000; INSERT INTO _timescaledb_catalog.continuous_agg_migrate_plan_step (mat_hypertable_id, type, config) VALUES (_cagg_data.mat_hypertable_id, 'COPY POLICIES', _policies || jsonb_build_object('cagg_name_new', _cagg_name_new)), (_cagg_data.mat_hypertable_id, 'OVERRIDE CAGG', jsonb_build_object('cagg_name_new', _cagg_name_new, 'override', _override, 'drop_old', _drop_old)), (_cagg_data.mat_hypertable_id, 'DROP OLD CAGG', jsonb_build_object('cagg_name_new', _cagg_name_new, 'override', _override, 'drop_old', _drop_old)), (_cagg_data.mat_hypertable_id, 'ENABLE POLICIES', NULL); END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Create new cagg using the new format CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_create_new_cagg ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _view_name TEXT; _view_def TEXT; _compression_enabled BOOLEAN; BEGIN _view_name := format('%I.%I', _cagg_data.user_view_schema, _plan_step.config->>'cagg_name_new'); SELECT c.compression_enabled, left(c.view_definition, -1) INTO _compression_enabled, _view_def FROM timescaledb_information.continuous_aggregates c WHERE c.view_schema = _cagg_data.user_view_schema AND c.view_name = _cagg_data.user_view_name; _view_def := format( 'CREATE MATERIALIZED VIEW %s WITH (timescaledb.continuous, timescaledb.materialized_only=%L) AS %s WITH NO DATA;', _view_name, _cagg_data.materialized_only, _view_def); EXECUTE _view_def; IF _compression_enabled IS TRUE THEN EXECUTE format('ALTER MATERIALIZED VIEW %s SET (timescaledb.compress=true)', _view_name); END IF; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Disable policies CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_disable_policies ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _policies INTEGER[]; BEGIN IF _plan_step.config->>'policies' IS NOT NULL THEN SELECT array_agg(value::integer) INTO _policies FROM jsonb_array_elements_text( (_plan_step.config->'policies') ); PERFORM @extschema@.alter_job(job_id, scheduled => FALSE) FROM unnest(_policies) job_id; END IF; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Enable policies CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_enable_policies ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _policies INTEGER[]; BEGIN IF _plan_step.config->>'policies' IS NOT NULL THEN SELECT array_agg(value::integer) INTO _policies FROM jsonb_array_elements_text( (_plan_step.config->'policies') ); -- set the `if_exists=>TRUE` because the cagg can be removed if the user -- set `drop_old=>TRUE` during the migration PERFORM @extschema@.alter_job(job_id, scheduled => TRUE, if_exists => TRUE) FROM unnest(_policies) job_id; END IF; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Copy policies CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_copy_policies ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _mat_hypertable_id INTEGER; _policies INTEGER[]; _new_policies INTEGER[]; _bgw_job _timescaledb_config.bgw_job; _policy_id INTEGER; _config JSONB; BEGIN IF _plan_step.config->>'policies' IS NULL THEN RETURN; END IF; SELECT array_agg(value::integer) INTO _policies FROM jsonb_array_elements_text( (_plan_step.config->'policies') ); SELECT h.id INTO _mat_hypertable_id FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_schema = _cagg_data.user_view_schema AND user_view_name = _plan_step.config->>'cagg_name_new'; -- create a temp table with all policies we'll copy CREATE TEMP TABLE bgw_job_temp ON COMMIT DROP AS SELECT * FROM _timescaledb_config.bgw_job WHERE id = ANY(_policies) ORDER BY id; -- iterate over the policies and update the necessary fields FOR _bgw_job IN SELECT * FROM _timescaledb_config.bgw_job WHERE id = ANY(_policies) ORDER BY id LOOP _policy_id := nextval('_timescaledb_config.bgw_job_id_seq'); _new_policies := _new_policies || _policy_id; _config := jsonb_set(_bgw_job.config, '{mat_hypertable_id}', _mat_hypertable_id::text::jsonb, false); _config := jsonb_set(_config, '{hypertable_id}', _mat_hypertable_id::text::jsonb, false); UPDATE bgw_job_temp SET id = _policy_id, application_name = replace(application_name::text, _bgw_job.id::text, _policy_id::text)::name, config = _config, hypertable_id = _mat_hypertable_id WHERE id = _bgw_job.id; END LOOP; -- insert new policies INSERT INTO _timescaledb_config.bgw_job SELECT * FROM bgw_job_temp ORDER BY id; -- update the "ENABLE POLICIES" step with new policies UPDATE _timescaledb_catalog.continuous_agg_migrate_plan_step SET config = jsonb_build_object('policies', _new_policies || _policies) WHERE type = 'ENABLE POLICIES' AND mat_hypertable_id = _plan_step.mat_hypertable_id; END; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_update_watermark(_mat_hypertable_id INTEGER) LANGUAGE sql AS $BODY$ INSERT INTO _timescaledb_catalog.continuous_aggs_watermark VALUES (_mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(_mat_hypertable_id)) ON CONFLICT (mat_hypertable_id) DO UPDATE SET watermark = excluded.watermark; $BODY$ SECURITY DEFINER SET search_path TO pg_catalog, pg_temp; -- Refresh new cagg created by the migration CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_refresh_new_cagg ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _cagg_name TEXT; _override BOOLEAN; _mat_hypertable_id INTEGER; BEGIN SELECT (config->>'override')::BOOLEAN INTO _override FROM _timescaledb_catalog.continuous_agg_migrate_plan_step WHERE mat_hypertable_id = _cagg_data.mat_hypertable_id AND type = 'OVERRIDE CAGG'; _cagg_name = _plan_step.config->>'cagg_name_new'; IF _override IS TRUE THEN _cagg_name = _cagg_data.user_view_name; END IF; -- -- Update new cagg watermark -- SELECT h.id INTO _mat_hypertable_id FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_schema = _cagg_data.user_view_schema AND user_view_name = _plan_step.config->>'cagg_name_new'; CALL _timescaledb_functions.cagg_migrate_update_watermark(_mat_hypertable_id); -- -- Since we're still having problems with the `refresh_continuous_aggregate` executed inside procedures -- and the issue isn't easy/trivial to fix we decided to skip this step here WARNING users to do it -- manually after the migration. -- -- We didn't remove this step to make backward compatibility with potential existing and not finished -- migrations. -- -- Related issue: (https://github.com/timescale/timescaledb/issues/4913) -- RAISE WARNING 'refresh the continuous aggregate after the migration executing this statement: "CALL @extschema@.refresh_continuous_aggregate(%, CAST(% AS %), NULL);"', quote_literal(format('%I.%I', _cagg_data.user_view_schema, _cagg_name)), quote_literal(_plan_step.config->>'window_start'), _plan_step.config->>'window_start_type'; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Copy data from the OLD cagg to the new Materialization Hypertable CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_copy_data ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _stmt TEXT; _mat_schema_name TEXT; _mat_table_name TEXT; _mat_schema_name_old TEXT; _mat_table_name_old TEXT; _query TEXT; _select_columns TEXT; _groupby_columns TEXT; BEGIN SELECT h.schema_name, h.table_name INTO _mat_schema_name, _mat_table_name FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_schema = _cagg_data.user_view_schema AND user_view_name = _plan_step.config->>'cagg_name_new'; -- For realtime CAggs we need to read direct from the materialization hypertable IF _cagg_data.materialized_only IS FALSE THEN SELECT h.schema_name, h.table_name INTO _mat_schema_name_old, _mat_table_name_old FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_schema = _cagg_data.user_view_schema AND user_view_name = _cagg_data.user_view_name; _query := split_part( pg_get_viewdef(format('%I.%I', _cagg_data.user_view_schema, _cagg_data.user_view_name)), 'UNION ALL', 1); _groupby_columns := split_part( _query, 'GROUP BY ', 2); _select_columns := split_part( _query, format('FROM %I.%I', _mat_schema_name_old, _mat_table_name_old), 1); _stmt := format( 'INSERT INTO %I.%I %s FROM %I.%I WHERE %I >= %L AND %I < %L GROUP BY %s', _mat_schema_name, _mat_table_name, _select_columns, _mat_schema_name_old, _mat_table_name_old, _plan_step.config->>'bucket_column_name', _plan_step.config->>'start_ts', _plan_step.config->>'bucket_column_name', _plan_step.config->>'end_ts', _groupby_columns ); ELSE _stmt := format( 'INSERT INTO %I.%I SELECT * FROM %I.%I WHERE %I >= %L AND %I < %L', _mat_schema_name, _mat_table_name, _cagg_data.user_view_schema, _cagg_data.user_view_name, _plan_step.config->>'bucket_column_name', _plan_step.config->>'start_ts', _plan_step.config->>'bucket_column_name', _plan_step.config->>'end_ts' ); END IF; EXECUTE _stmt; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Rename the new cagg using `_old` suffix and rename the `_new` to the original name CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_override_cagg ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _stmt TEXT; BEGIN IF (_plan_step.config->>'override')::BOOLEAN IS FALSE THEN RETURN; END IF; _stmt := 'ALTER MATERIALIZED VIEW %I.%I RENAME TO %I;'; EXECUTE format ( _stmt, _cagg_data.user_view_schema, _cagg_data.user_view_name, replace(_plan_step.config->>'cagg_name_new', '_new', '_old') ); EXECUTE format ( _stmt, _cagg_data.user_view_schema, _plan_step.config->>'cagg_name_new', _cagg_data.user_view_name ); END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Remove old cagg if the parameter `drop_old` and `override` is true CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_drop_old_cagg ( _cagg_data _timescaledb_catalog.continuous_agg, _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step ) LANGUAGE plpgsql AS $BODY$ DECLARE _stmt TEXT; BEGIN IF (_plan_step.config->>'drop_old')::BOOLEAN IS FALSE THEN RETURN; END IF; _stmt := 'DROP MATERIALIZED VIEW %I.%I;'; IF (_plan_step.config->>'override')::BOOLEAN IS TRUE THEN EXECUTE format ( _stmt, _cagg_data.user_view_schema, replace(_plan_step.config->>'cagg_name_new', '_new', '_old') ); END IF; END; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Execute the migration plan, step by step CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_execute_plan ( _cagg_data _timescaledb_catalog.continuous_agg ) LANGUAGE plpgsql AS $BODY$ DECLARE _plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step; _call_stmt TEXT; BEGIN FOR _plan_step IN SELECT * FROM _timescaledb_catalog.continuous_agg_migrate_plan_step WHERE mat_hypertable_id OPERATOR(pg_catalog.=) _cagg_data.mat_hypertable_id AND status OPERATOR(pg_catalog.=) ANY (ARRAY['NOT STARTED', 'STARTED']) ORDER BY step_id LOOP -- change the status of the step UPDATE _timescaledb_catalog.continuous_agg_migrate_plan_step SET status = 'STARTED', start_ts = pg_catalog.clock_timestamp() WHERE mat_hypertable_id OPERATOR(pg_catalog.=) _plan_step.mat_hypertable_id AND step_id OPERATOR(pg_catalog.=) _plan_step.step_id; COMMIT; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; -- reload the step data for enable policies because the COPY DATA step update it IF _plan_step.type OPERATOR(pg_catalog.=) 'ENABLE POLICIES' THEN SELECT * INTO _plan_step FROM _timescaledb_catalog.continuous_agg_migrate_plan_step WHERE mat_hypertable_id OPERATOR(pg_catalog.=) _plan_step.mat_hypertable_id AND step_id OPERATOR(pg_catalog.=) _plan_step.step_id; END IF; -- execute step migration _call_stmt := pg_catalog.format('CALL _timescaledb_functions.cagg_migrate_execute_%s($1, $2)', pg_catalog.lower(pg_catalog.replace(_plan_step.type, ' ', '_'))); EXECUTE _call_stmt USING _cagg_data, _plan_step; UPDATE _timescaledb_catalog.continuous_agg_migrate_plan_step SET status = 'FINISHED', end_ts = pg_catalog.clock_timestamp() WHERE mat_hypertable_id OPERATOR(pg_catalog.=) _plan_step.mat_hypertable_id AND step_id OPERATOR(pg_catalog.=) _plan_step.step_id; COMMIT; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; END LOOP; END; $BODY$; -- Execute the entire migration CREATE OR REPLACE PROCEDURE @extschema@.cagg_migrate ( cagg REGCLASS, override BOOLEAN DEFAULT FALSE, drop_old BOOLEAN DEFAULT FALSE ) LANGUAGE plpgsql AS $BODY$ DECLARE _cagg_schema TEXT; _cagg_name TEXT; _cagg_name_new TEXT; _cagg_data _timescaledb_catalog.continuous_agg; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; SELECT nspname, relname INTO _cagg_schema, _cagg_name FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_namespace.oid OPERATOR(pg_catalog.=) pg_class.relnamespace WHERE pg_class.oid OPERATOR(pg_catalog.=) cagg::pg_catalog.oid; -- maximum size of an identifier in Postgres is 63 characters, se we need to left space for '_new' _cagg_name_new := pg_catalog.format('%s_new', pg_catalog.substr(_cagg_name, 1, 59)); -- pre-validate the migration and get some variables _cagg_data := _timescaledb_functions.cagg_migrate_pre_validation(_cagg_schema, _cagg_name, _cagg_name_new); -- create new migration plan CALL _timescaledb_functions.cagg_migrate_create_plan(_cagg_data, _cagg_name_new, override, drop_old); COMMIT; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; -- execute the migration plan CALL _timescaledb_functions.cagg_migrate_execute_plan(_cagg_data); -- Remove chunk metadata when marked as dropped PERFORM _timescaledb_functions.remove_dropped_chunk_metadata(_cagg_data.raw_hypertable_id); -- finish the migration plan UPDATE _timescaledb_catalog.continuous_agg_migrate_plan SET end_ts = pg_catalog.clock_timestamp() WHERE mat_hypertable_id OPERATOR(pg_catalog.=) _cagg_data.mat_hypertable_id; END; $BODY$; -- Migrate a CAgg which is using the experimental time_bucket_ng function -- into a CAgg using the regular time_bucket function CREATE OR REPLACE PROCEDURE _timescaledb_functions.cagg_migrate_to_time_bucket(cagg REGCLASS) AS '@MODULE_PATHNAME@', 'ts_continuous_agg_migrate_to_time_bucket' LANGUAGE C; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/cagg_utils.sql���������������������������������������������������������������0000664�0000000�0000000�00000003126�15100345067�0017516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_validate_query( query TEXT, OUT is_valid BOOLEAN, OUT error_level TEXT, OUT error_code TEXT, OUT error_message TEXT, OUT error_detail TEXT, OUT error_hint TEXT ) RETURNS RECORD AS '@MODULE_PATHNAME@', 'ts_continuous_agg_validate_query' LANGUAGE C STRICT VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_get_bucket_function_info( mat_hypertable_id INTEGER, -- The bucket function OUT bucket_func REGPROCEDURE, -- `bucket_width` argument of the function, e.g. "1 month" OUT bucket_width TEXT, -- optional `origin` argument of the function provided by the user OUT bucket_origin TEXT, -- optional `offset` argument of the function provided by the user OUT bucket_offset TEXT, -- optional `timezone` argument of the function provided by the user OUT bucket_timezone TEXT, -- fixed or variable sized bucket OUT bucket_fixed_width BOOLEAN ) RETURNS RECORD AS '@MODULE_PATHNAME@', 'ts_continuous_agg_get_bucket_function_info' LANGUAGE C STRICT VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_parse_invalidation_record( invalidation_record BYTEA, OUT hypertable_relid REGCLASS, OUT lowest_modified_value BIGINT, OUT greatest_modified_value BIGINT) RETURNS RECORD AS '@MODULE_PATHNAME@', 'ts_continuous_agg_read_invalidation_record' LANGUAGE C STRICT IMMUTABLE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/cat.cmake��������������������������������������������������������������������0000664�0000000�0000000�00000001311�15100345067�0016417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ IF(POLICY CMP0012) CMAKE_POLICY(SET CMP0012 NEW) ENDIF() if (NOT DEFINED STRIP_REPLACE) set(STRIP_REPLACE OFF) endif() function(append_file IN_FILE OUT_FILE STRIP_REPLACE) file(READ ${IN_FILE} CONTENTS) if (${STRIP_REPLACE}) string(REPLACE " OR REPLACE " " " CONTENTS "${CONTENTS}") endif() file(APPEND ${OUT_FILE} "${CONTENTS}") endfunction() # Function to concatenate all files in SRC_FILE_LIST into file OUTPUT_FILE function(cat SRC_FILE_LIST OUTPUT_FILE STRIP_REPLACE) file(WRITE ${OUTPUT_FILE} "") foreach(SRC_FILE ${SRC_FILE_LIST}) append_file(${SRC_FILE} ${OUTPUT_FILE} ${STRIP_REPLACE}) endforeach() endfunction() cat("${SRC_FILE_LIST}" "${OUTPUT_FILE}" "${STRIP_REPLACE}") �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/chunk.sql��������������������������������������������������������������������0000664�0000000�0000000�00000010677�15100345067�0016516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Built-in function for calculating the next chunk interval when -- using adaptive chunking. The function can be replaced by a -- user-defined function with the same signature. -- -- The parameters passed to the function are as follows: -- -- dimension_id: the ID of the dimension to calculate the interval for -- dimension_coord: the coordinate / point on the dimensional axis -- where the tuple that triggered this chunk creation falls. -- chunk_target_size: the target size in bytes that the chunk should have. -- -- The function should return the new interval in dimension-specific -- time (ususally microseconds). CREATE OR REPLACE FUNCTION _timescaledb_functions.calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_calculate_chunk_interval' LANGUAGE C; -- Get the status of the chunk CREATE OR REPLACE FUNCTION _timescaledb_functions.chunk_status(REGCLASS) RETURNS INT AS '@MODULE_PATHNAME@', 'ts_chunk_status' LANGUAGE C; -- Get the status of the chunk as text array CREATE OR REPLACE FUNCTION _timescaledb_functions.chunk_status_text(chunk_status int) RETURNS TEXT[] AS '@MODULE_PATHNAME@', 'ts_chunk_status_text' LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.chunk_status_text(chunk regclass) RETURNS TEXT[] AS $$ SELECT _timescaledb_functions.chunk_status_text(_timescaledb_functions.chunk_status($1)); $$ LANGUAGE SQL STRICT IMMUTABLE PARALLEL SAFE SET search_path TO pg_catalog, pg_temp;; --given a chunk's relid, return the id. Error out if not a chunk relid. CREATE OR REPLACE FUNCTION _timescaledb_functions.chunk_id_from_relid(relid OID) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_chunk_id_from_relid' LANGUAGE C STABLE STRICT PARALLEL SAFE; -- Show the definition of a chunk. CREATE OR REPLACE FUNCTION _timescaledb_functions.show_chunk(chunk REGCLASS) RETURNS TABLE(chunk_id INTEGER, hypertable_id INTEGER, schema_name NAME, table_name NAME, relkind "char", slices JSONB) AS '@MODULE_PATHNAME@', 'ts_chunk_show' LANGUAGE C VOLATILE; -- Create a chunk with the given dimensional constraints (slices) as -- given in the JSONB. If chunk_table is a valid relation, it will be -- attached to the hypertable and used as the data table for the new -- chunk. Note that schema_name and table_name need not be the same as -- the existing schema and name for chunk_table. The provided chunk -- table will be renamed and/or moved as necessary. CREATE OR REPLACE FUNCTION _timescaledb_functions.create_chunk( hypertable REGCLASS, slices JSONB, schema_name NAME = NULL, table_name NAME = NULL, chunk_table REGCLASS = NULL) RETURNS TABLE(chunk_id INTEGER, hypertable_id INTEGER, schema_name NAME, table_name NAME, relkind "char", slices JSONB, created BOOLEAN) AS '@MODULE_PATHNAME@', 'ts_chunk_create' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.freeze_chunk( chunk REGCLASS) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_chunk_freeze_chunk' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.unfreeze_chunk( chunk REGCLASS) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_chunk_unfreeze_chunk' LANGUAGE C VOLATILE; --wrapper for ts_chunk_drop --drops the chunk table and its entry in the chunk catalog CREATE OR REPLACE FUNCTION _timescaledb_functions.drop_chunk( chunk REGCLASS) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_chunk_drop_single_chunk' LANGUAGE C VOLATILE; -- internal API used by OSM extension to attach a table as a chunk of the hypertable CREATE OR REPLACE FUNCTION _timescaledb_functions.attach_osm_table_chunk( hypertable REGCLASS, chunk REGCLASS) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_chunk_attach_osm_table_chunk' LANGUAGE C VOLATILE; -- internal API used by OSM extension to drop an OSM chunk table from the hypertable CREATE OR REPLACE FUNCTION _timescaledb_functions.drop_osm_chunk(hypertable REGCLASS) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_chunk_drop_osm_chunk' LANGUAGE C VOLATILE; CREATE OR REPLACE PROCEDURE @extschema@.detach_chunk(chunk REGCLASS) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_detach_chunk'; CREATE OR REPLACE PROCEDURE @extschema@.attach_chunk(hypertable REGCLASS, chunk REGCLASS, slices JSONB) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_attach_chunk'; �����������������������������������������������������������������timescaledb-2.23.0/sql/chunk_constraint.sql���������������������������������������������������������0000664�0000000�0000000�00000010134�15100345067�0020746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create constraint on newly created chunk based on hypertable constraint CREATE OR REPLACE FUNCTION _timescaledb_functions.chunk_constraint_add_table_constraint( chunk_constraint_row _timescaledb_catalog.chunk_constraint ) RETURNS VOID LANGUAGE PLPGSQL AS $BODY$ DECLARE chunk_row _timescaledb_catalog.chunk; hypertable_row _timescaledb_catalog.hypertable; constraint_oid OID; constraint_type CHAR; check_sql TEXT; def TEXT; indx_tablespace NAME; tablespace_def TEXT; BEGIN SELECT * INTO STRICT chunk_row FROM _timescaledb_catalog.chunk c WHERE c.id = chunk_constraint_row.chunk_id; SELECT * INTO STRICT hypertable_row FROM _timescaledb_catalog.hypertable h WHERE h.id = chunk_row.hypertable_id; IF chunk_constraint_row.dimension_slice_id IS NOT NULL THEN RAISE 'cannot create dimension constraint %', chunk_constraint_row; ELSIF chunk_constraint_row.hypertable_constraint_name IS NOT NULL THEN SELECT oid, contype INTO STRICT constraint_oid, constraint_type FROM pg_constraint WHERE conname=chunk_constraint_row.hypertable_constraint_name AND conrelid = format('%I.%I', hypertable_row.schema_name, hypertable_row.table_name)::regclass::oid; IF constraint_type IN ('p','u') THEN -- since primary keys and unique constraints are backed by an index -- they might have an index tablespace assigned -- the tablspace is not part of the constraint definition so -- we have to append it explicitly to preserve it SELECT T.spcname INTO indx_tablespace FROM pg_constraint C, pg_class I, pg_tablespace T WHERE C.oid = constraint_oid AND C.contype IN ('p', 'u') AND I.oid = C.conindid AND I.reltablespace = T.oid; def := pg_get_constraintdef(constraint_oid); ELSIF constraint_type = 't' THEN -- constraint triggers are copied separately with normal triggers def := NULL; ELSE def := pg_get_constraintdef(constraint_oid); END IF; ELSE RAISE 'unknown constraint type'; END IF; IF def IS NOT NULL THEN -- to allow for custom types with operators outside of pg_catalog -- we set search_path to @extschema@ SET LOCAL search_path TO @extschema@, pg_temp; EXECUTE pg_catalog.format( $$ ALTER TABLE %I.%I ADD CONSTRAINT %I %s $$, chunk_row.schema_name, chunk_row.table_name, chunk_constraint_row.constraint_name, def ); -- if constraint (primary or unique) needs a tablespace then add it -- via a separate ALTER INDEX SET TABLESPACE command. We cannot append it -- to the "def" string above since it leads to a SYNTAX error when -- "DEFERRABLE" or "INITIALLY DEFERRED" are used in the constraint IF indx_tablespace IS NOT NULL THEN EXECUTE pg_catalog.format( $$ ALTER INDEX %I.%I SET TABLESPACE %I $$, chunk_row.schema_name, chunk_constraint_row.constraint_name, indx_tablespace ); END IF; END IF; END $BODY$ SET search_path TO pg_catalog, pg_temp; -- Clone fk constraint from a hypertable to a compressed chunk CREATE OR REPLACE FUNCTION _timescaledb_functions.constraint_clone( constraint_oid OID, target_oid REGCLASS ) RETURNS VOID LANGUAGE PLPGSQL AS $BODY$ DECLARE constraint_name NAME; def TEXT; BEGIN def := pg_get_constraintdef(constraint_oid); SELECT conname INTO STRICT constraint_name FROM pg_constraint WHERE oid = constraint_oid; IF def IS NULL THEN RAISE 'constraint not found'; END IF; -- to allow for custom types with operators outside of pg_catalog -- we set search_path to @extschema@ SET LOCAL search_path TO @extschema@, pg_temp; EXECUTE pg_catalog.format($$ ALTER TABLE %s ADD CONSTRAINT %I %s $$, target_oid::pg_catalog.text, constraint_name, def); END $BODY$ SET search_path TO pg_catalog, pg_temp; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/comment_apache.sql�����������������������������������������������������������0000664�0000000�0000000�00000000463�15100345067�0020341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. COMMENT ON EXTENSION timescaledb IS 'Enables scalable inserts and complex queries for time-series data (Apache 2 Edition)'; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/comment_tsl.sql��������������������������������������������������������������0000664�0000000�0000000�00000000464�15100345067�0017723�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. COMMENT ON EXTENSION timescaledb IS 'Enables scalable inserts and complex queries for time-series data (Community Edition)'; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/compat.sql�������������������������������������������������������������������0000664�0000000�0000000�00000122541�15100345067�0016663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- TimescaleDB 2.12 moved all functions present in _timescaledb_internal into -- _timescaledb_functions. This file contains a compatibility layer to allow -- for more flexibility when migrating for any users calling these internal -- functions. -- This compatibility layer will be removed in a future versions. CREATE OR REPLACE FUNCTION _timescaledb_internal.alter_job_set_hypertable_id(job_id integer, hypertable regclass) RETURNS integer LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.alter_job_set_hypertable_id(integer,regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.alter_job_set_hypertable_id($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.attach_osm_table_chunk(hypertable regclass, chunk regclass) RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.attach_osm_table_chunk(regclass,regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.attach_osm_table_chunk($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.cagg_migrate_plan_exists(_hypertable_id integer) RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.cagg_migrate_plan_exists(integer) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.cagg_migrate_plan_exists($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.cagg_migrate_pre_validation(_cagg_schema text,_cagg_name text,_cagg_name_new text) RETURNS _timescaledb_catalog.continuous_agg LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.cagg_migrate_pre_validation(text,text,text) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.cagg_migrate_pre_validation($1,$2,$3); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.cagg_watermark(hypertable_id integer) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.cagg_watermark(integer) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.cagg_watermark($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.cagg_watermark_materialized(hypertable_id integer) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.cagg_watermark_materialized(integer) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.cagg_watermark_materialized($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.calculate_chunk_interval(dimension_id integer,dimension_coord bigint,chunk_target_size bigint) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.calculate_chunk_interval(integer,bigint,bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.calculate_chunk_interval($1,$2,$3); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.chunk_constraint_add_table_constraint(chunk_constraint_row _timescaledb_catalog.chunk_constraint) RETURNS void LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.chunk_constraint_add_table_constraint(_timescaledb_catalog.chunk_constraint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; PERFORM _timescaledb_functions.chunk_constraint_add_table_constraint($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.chunk_id_from_relid(relid oid) RETURNS integer LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.chunk_id_from_relid(oid) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.chunk_id_from_relid($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.chunk_status(regclass) RETURNS integer LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.chunk_status(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.chunk_status($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.chunks_local_size(schema_name_in name,table_name_in name) RETURNS TABLE (chunk_id integer, chunk_schema NAME, chunk_name NAME, table_bytes bigint, index_bytes bigint, toast_bytes bigint, total_bytes bigint) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.chunks_local_size(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.chunks_local_size($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.compressed_chunk_local_stats(schema_name_in name,table_name_in name) RETURNS TABLE (chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.compressed_chunk_local_stats(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.compressed_chunk_local_stats($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.compressed_chunk_remote_stats(schema_name_in name,table_name_in name) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.compressed_chunk_remote_stats(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.compressed_chunk_remote_stats($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; -- we have to prefix slices, schema_name and table_name parameter with _ here to not clash with output names otherwise plpgsql will complain CREATE OR REPLACE FUNCTION _timescaledb_internal.create_chunk(hypertable regclass,_slices jsonb,_schema_name name=NULL,_table_name name=NULL,chunk_table regclass=NULL) RETURNS TABLE(chunk_id INTEGER, hypertable_id INTEGER, schema_name NAME, table_name NAME, relkind "char", slices JSONB, created BOOLEAN) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.create_chunk(regclass,jsonb,name,name,regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.create_chunk($1,$2,$3,$4,$5); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.create_compressed_chunk(chunk regclass,chunk_table regclass,uncompressed_heap_size bigint,uncompressed_toast_size bigint,uncompressed_index_size bigint,compressed_heap_size bigint,compressed_toast_size bigint,compressed_index_size bigint,numrows_pre_compression bigint,numrows_post_compression bigint) RETURNS regclass LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.create_compressed_chunk(regclass,regclass,bigint,bigint,bigint,bigint,bigint,bigint,bigint,bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.create_compressed_chunk($1,$2,$3,$4,$5,$6,$7,$8,$9,$10); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.drop_chunk(chunk regclass) RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.drop_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.drop_chunk($1); END$$ SET search_path TO pg_catalog,pg_temp; -- We cannot create a wrapper function in plpgsql for the aggregate transition -- functions because plpgsql cannot deal with datatype internal but since these -- are used in an aggregation context and cannot be called directly and will -- be used in conjunction with partialize_agg it is sufficient to have the -- warning there. CREATE OR REPLACE FUNCTION _timescaledb_internal.finalize_agg_ffunc( tstate internal, aggfn TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val ANYELEMENT) RETURNS anyelement AS '@MODULE_PATHNAME@', 'ts_finalize_agg_ffunc' LANGUAGE C IMMUTABLE; CREATE OR REPLACE FUNCTION _timescaledb_internal.finalize_agg_sfunc( tstate internal, aggfn TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val ANYELEMENT) RETURNS internal AS '@MODULE_PATHNAME@', 'ts_finalize_agg_sfunc' LANGUAGE C IMMUTABLE; CREATE OR REPLACE AGGREGATE _timescaledb_internal.finalize_agg(agg_name TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val anyelement) ( SFUNC = _timescaledb_functions.finalize_agg_sfunc, STYPE = internal, FINALFUNC = _timescaledb_functions.finalize_agg_ffunc, FINALFUNC_EXTRA ); CREATE OR REPLACE FUNCTION _timescaledb_internal.freeze_chunk(chunk regclass) RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.freeze_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.freeze_chunk($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.generate_uuid() RETURNS uuid LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.generate_uuid() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.generate_uuid(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_approx_row_count(relation regclass) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_approx_row_count(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.get_approx_row_count($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_compressed_chunk_index_for_recompression(uncompressed_chunk regclass) RETURNS regclass LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_compressed_chunk_index_for_recompression(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.get_compressed_chunk_index_for_recompression($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_create_command(table_name name) RETURNS text LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_create_command(name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.get_create_command($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_git_commit() RETURNS TABLE(commit_tag TEXT, commit_hash TEXT, commit_time TIMESTAMPTZ) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_git_commit() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.get_git_commit(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_os_info() RETURNS TABLE(sysname TEXT, version TEXT, release TEXT, version_pretty TEXT) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_os_info() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.get_os_info(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_partition_for_key(val anyelement) RETURNS integer LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_partition_for_key(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.get_partition_for_key($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.get_partition_hash(val anyelement) RETURNS integer LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.get_partition_hash(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.get_partition_hash($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.hypertable_local_size(schema_name_in name,table_name_in name) RETURNS TABLE ( table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.hypertable_local_size(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.hypertable_local_size($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.interval_to_usec(chunk_interval interval) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.interval_to_usec(interval) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.interval_to_usec($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.partialize_agg(arg anyelement) RETURNS bytea LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.partialize_agg(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.partialize_agg($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.policy_compression_check(config jsonb) RETURNS void LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.policy_compression_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; PERFORM _timescaledb_functions.policy_compression_check($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.policy_job_stat_history_retention(job_id integer,config jsonb) RETURNS integer LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.policy_job_stat_history_retention(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.policy_job_stat_history_retention($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.policy_job_stat_history_retention_check(config jsonb) RETURNS void LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.policy_job_stat_history_retention_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; PERFORM _timescaledb_functions.policy_job_stat_history_retention_check($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.policy_refresh_continuous_aggregate_check(config jsonb) RETURNS void LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.policy_refresh_continuous_aggregate_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; PERFORM _timescaledb_functions.policy_refresh_continuous_aggregate_check($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.policy_reorder_check(config jsonb) RETURNS void LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.policy_reorder_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; PERFORM _timescaledb_functions.policy_reorder_check($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.policy_retention_check(config jsonb) RETURNS void LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.policy_retention_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; PERFORM _timescaledb_functions.policy_retention_check($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.process_ddl_event() RETURNS event_trigger LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.process_ddl_event() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.process_ddl_event(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.range_value_to_pretty(time_value bigint,column_type regtype) RETURNS text LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.range_value_to_pretty(bigint,regtype) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.range_value_to_pretty($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.recompress_chunk_segmentwise(uncompressed_chunk regclass,if_compressed boolean=false) RETURNS regclass LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.recompress_chunk_segmentwise(regclass,boolean) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.recompress_chunk_segmentwise($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.relation_size(relation regclass) RETURNS TABLE (total_size BIGINT, heap_size BIGINT, index_size BIGINT, toast_size BIGINT) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.relation_size(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.relation_size($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.restart_background_workers() RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.restart_background_workers() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.restart_background_workers(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.show_chunk(chunk regclass) RETURNS TABLE(chunk_id INTEGER, hypertable_id INTEGER, schema_name NAME, table_name NAME, relkind "char", slices JSONB) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.show_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN QUERY SELECT * FROM _timescaledb_functions.show_chunk($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.start_background_workers() RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.start_background_workers() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.start_background_workers(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.stop_background_workers() RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.stop_background_workers() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.stop_background_workers(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.subtract_integer_from_now(hypertable_relid regclass,lag bigint) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.subtract_integer_from_now(regclass,bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.subtract_integer_from_now($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.time_to_internal(time_val anyelement) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.time_to_internal(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.time_to_internal($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.to_date(unixtime_us bigint) RETURNS date LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.to_date(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.to_date($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.to_interval(unixtime_us bigint) RETURNS interval LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.to_interval(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.to_interval($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.to_timestamp(unixtime_us bigint) RETURNS timestamp with time zone LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.to_timestamp(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.to_timestamp($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.to_timestamp_without_timezone(unixtime_us bigint) RETURNS timestamp without time zone LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.to_timestamp_without_timezone(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.to_timestamp_without_timezone($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.to_unix_microseconds(ts timestamp with time zone) RETURNS bigint LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.to_unix_microseconds(timestamp with time zone) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.to_unix_microseconds($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.tsl_loaded() RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.tsl_loaded() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.tsl_loaded(); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.unfreeze_chunk(chunk regclass) RETURNS boolean LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'function _timescaledb_internal.unfreeze_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; RETURN _timescaledb_functions.unfreeze_chunk($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_create_plan(_cagg_data _timescaledb_catalog.continuous_agg,_cagg_name_new text,_override boolean=false,_drop_old boolean=false) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_create_plan(_timescaledb_catalog.continuous_agg,text,boolean,boolean) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_create_plan($1,$2,$3,$4); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_copy_data(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_copy_data(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_copy_data($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_copy_policies(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_copy_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_copy_policies($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_create_new_cagg(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_create_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_create_new_cagg($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_disable_policies(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_disable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_disable_policies($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_drop_old_cagg($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_enable_policies(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_enable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_enable_policies($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_override_cagg(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_override_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_override_cagg($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_plan(_cagg_data _timescaledb_catalog.continuous_agg) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_plan(_timescaledb_catalog.continuous_agg) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_plan($1); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(_cagg_data _timescaledb_catalog.continuous_agg,_plan_step _timescaledb_catalog.continuous_agg_migrate_plan_step) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.cagg_migrate_execute_refresh_new_cagg($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.policy_compression(job_id integer,config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.policy_compression(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.policy_compression($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.policy_recompression(job_id integer,config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.policy_recompression(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.policy_recompression($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.policy_refresh_continuous_aggregate(job_id integer,config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.policy_refresh_continuous_aggregate(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.policy_refresh_continuous_aggregate($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.policy_reorder(job_id integer,config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.policy_reorder(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.policy_reorder($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; CREATE OR REPLACE PROCEDURE _timescaledb_internal.policy_retention(job_id integer,config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure _timescaledb_internal.policy_retention(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version.'; END IF; CALL _timescaledb_functions.policy_retention($1,$2); END$$ SET search_path TO pg_catalog,pg_temp; ���������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/compression_defaults.sql�����������������������������������������������������0000664�0000000�0000000�00000034030�15100345067�0021623�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This function return a jsonb with the following keys: -- - columns: an array of column names that shold be used for segment by -- - confidence: a number between 0 and 10 (most confident) indicating how sure we are. -- - message: a message that should be displayed to the user to evaluate the result. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_segmentby_defaults( relation regclass ) RETURNS JSONB LANGUAGE PLPGSQL AS $BODY$ DECLARE _table_name NAME; _schema_name NAME; _hypertable_row _timescaledb_catalog.hypertable; _segmentby NAME; _cnt int; BEGIN SELECT n.nspname, c.relname INTO STRICT _schema_name, _table_name FROM pg_class c INNER JOIN pg_namespace n ON (n.oid = c.relnamespace) WHERE c.oid = relation; SELECT * INTO STRICT _hypertable_row FROM _timescaledb_catalog.hypertable h WHERE h.table_name = _table_name AND h.schema_name = _schema_name; --STEP 1 if column stats exist use unique indexes. --Pick the column that comes first in any such indexes --Select the column such that tuples are segmented evenly across distinct values. --Note: this will only pick a column that is NOT unique in a multi-column unique index. with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM ( SELECT indkey, indnkeyatts FROM pg_catalog.pg_index WHERE indisunique AND indrelid = relation ) i INNER JOIN LATERAL ( SELECT * FROM unnest(i.indkey) WITH ORDINALITY ) a(attnum, pos) ON TRUE WHERE a.pos <= i.indnkeyatts GROUP BY a.attnum ), stats_with_stddev as ( SELECT a.attname, i.pos, ROUND(stddev_pop(freqs)::numeric, 5) as freq_stddev FROM index_attr i INNER JOIN pg_attribute a ON a.attnum = i.attnum AND a.attrelid = relation INNER JOIN pg_stats s ON s.attname = a.attname AND s.schemaname = _schema_name AND s.tablename = _table_name AND s.inherited = true LEFT JOIN LATERAL unnest(s.most_common_freqs) as freqs ON TRUE WHERE a.attname NOT IN ( SELECT column_name FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id ) AND s.n_distinct > 1 GROUP BY a.attname, i.pos ) SELECT attname INTO _segmentby FROM stats_with_stddev ORDER BY pos ASC, freq_stddev ASC NULLS LAST LIMIT 1; IF FOUND THEN return json_build_object('columns', json_build_array(_segmentby), 'confidence', 10); END IF; --STEP 2 if column stats exist and no unique indexes use non-unique indexes. --Pick the column that comes first in any such indexes --Select the column such that tuples are segmented evenly across distinct values. with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM (select indkey, indnkeyatts from pg_catalog.pg_index where NOT indisunique and indrelid = relation) i INNER JOIN LATERAL (select * from unnest(i.indkey) with ordinality) a(attnum, pos) ON (TRUE) WHERE a.pos <= i.indnkeyatts GROUP BY 1 ), stats_with_stddev as ( SELECT a.attname, i.pos, ROUND(stddev_pop(freqs)::numeric, 5) as freq_stddev FROM index_attr i INNER JOIN pg_attribute a ON a.attnum = i.attnum AND a.attrelid = relation INNER JOIN pg_stats s ON s.attname = a.attname AND s.schemaname = _schema_name AND s.tablename = _table_name AND s.inherited = true LEFT JOIN LATERAL unnest(s.most_common_freqs) as freqs ON TRUE WHERE a.attname NOT IN ( SELECT column_name FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id ) AND s.n_distinct > 1 GROUP BY a.attname, i.pos ) SELECT attname INTO _segmentby FROM stats_with_stddev ORDER BY pos ASC, freq_stddev ASC NULLS LAST LIMIT 1; IF FOUND THEN return json_build_object('columns', json_build_array(_segmentby), 'confidence', 8); END IF; --STEP 3 if column stats exist but there are no indexes --Select the column such that tuples are segmented evenly across distinct values. with stats_with_stddev as ( SELECT a.attname, ROUND(stddev_pop(freqs)::numeric, 5) as freq_stddev FROM pg_attribute a INNER JOIN pg_stats s ON s.attname = a.attname AND s.schemaname = _schema_name AND s.tablename = _table_name AND s.inherited = true LEFT JOIN LATERAL unnest(s.most_common_freqs) as freqs ON TRUE WHERE a.attrelid = relation AND a.attname NOT IN ( SELECT column_name FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id ) AND s.n_distinct > 1 GROUP BY a.attname ) SELECT attname INTO _segmentby FROM stats_with_stddev ORDER BY freq_stddev ASC NULLS LAST LIMIT 1; IF FOUND THEN return json_build_object('columns', json_build_array(_segmentby), 'confidence', 7); END IF; --STEP 4 if column stats do not exist use non-unique indexes. Pick the column that comes first in any such indexes. Ties are broken arbitrarily. with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM (select indkey, indnkeyatts from pg_catalog.pg_index where NOT indisunique and indrelid = relation) i INNER JOIN LATERAL (select * from unnest(i.indkey) with ordinality) a(attnum, pos) ON (TRUE) WHERE a.pos <= i.indnkeyatts GROUP BY 1 ) SELECT a.attname INTO _segmentby FROM index_attr i INNER JOIN pg_attribute a on (a.attnum = i.attnum AND a.attrelid = relation) LEFT JOIN pg_catalog.pg_attrdef ad ON (ad.adrelid = relation AND ad.adnum = a.attnum) LEFT JOIN pg_stats s ON s.attname = a.attname AND s.schemaname = _schema_name AND s.tablename = _table_name AND s.inherited = true WHERE a.attname NOT IN (SELECT column_name FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id) AND s.n_distinct is null AND a.attidentity = '' AND (ad.adbin IS NULL OR pg_get_expr(adbin, adrelid) not like 'nextval%') ORDER BY i.pos LIMIT 1; IF FOUND THEN return json_build_object( 'columns', json_build_array(_segmentby), 'confidence', 5, 'message', 'Please make sure '|| _segmentby||' is not a unique column and appropriate for a segment by'); END IF; --STEP 5 if column stats do not exist and no non-unique indexes, use unique indexes. Pick the column that comes first in any such indexes. Ties are broken arbitrarily. with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM (select indkey, indnkeyatts from pg_catalog.pg_index where indisunique and indrelid = relation) i INNER JOIN LATERAL (select * from unnest(i.indkey) with ordinality) a(attnum, pos) ON (TRUE) WHERE a.pos <= i.indnkeyatts GROUP BY 1 ) SELECT a.attname INTO _segmentby FROM index_attr i INNER JOIN pg_attribute a on (a.attnum = i.attnum AND a.attrelid = relation) LEFT JOIN pg_catalog.pg_attrdef ad ON (ad.adrelid = relation AND ad.adnum = a.attnum) LEFT JOIN pg_stats s ON s.attname = a.attname AND s.schemaname = _schema_name AND s.tablename = _table_name AND s.inherited = true WHERE a.attname NOT IN (SELECT column_name FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id) AND s.n_distinct is null AND a.attidentity = '' AND (ad.adbin IS NULL OR pg_get_expr(adbin, adrelid) not like 'nextval%') ORDER BY i.pos LIMIT 1; IF FOUND THEN return json_build_object( 'columns', json_build_array(_segmentby), 'confidence', 5, 'message', 'Please make sure '|| _segmentby||' is not a unique column and appropriate for a segment by'); END IF; --are there any indexed columns that are not dimemsions and are not serial/identity? with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM (select indkey, indnkeyatts from pg_catalog.pg_index where indisunique and indrelid = relation) i INNER JOIN LATERAL (select * from unnest(i.indkey) with ordinality) a(attnum, pos) ON (TRUE) WHERE a.pos <= i.indnkeyatts GROUP BY 1 ) SELECT count(*) INTO STRICT _cnt FROM index_attr i INNER JOIN pg_attribute a on (a.attnum = i.attnum AND a.attrelid = relation) LEFT JOIN pg_catalog.pg_attrdef ad ON (ad.adrelid = relation AND ad.adnum = a.attnum) WHERE a.attname NOT IN (SELECT column_name FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id) AND a.attidentity = '' AND (ad.adbin IS NULL OR pg_get_expr(adbin, adrelid) not like 'nextval%'); IF _cnt > 0 THEN --there are many potential candidates. We do not have enough information to choose one. return json_build_object( 'columns', json_build_array(), 'confidence', 0, 'message', 'Several columns are potential segment by candidates and we do not have enough information to choose one. Please use the segment_by option to explicitly specify the segment_by column'); ELSE --there are no potential candidates. There is a good chance no segment by is the correct choice. return json_build_object( 'columns', json_build_array(), 'confidence', 5, 'message', 'You do not have any indexes on columns that can be used for segment_by and thus we are not using segment_by for converting to columnstore. Please make sure you are not missing any indexes'); END IF; END $BODY$ SET search_path TO pg_catalog, pg_temp; -- This function return a jsonb with the following keys: -- - clauses: an array of column names and sort order key words that shold be used for order by. -- - confidence: a number between 0 and 10 (most confident) indicating how sure we are. -- - message: a message that should be shown to the user to evaluate the result. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_orderby_defaults( relation regclass, segment_by_cols text[] ) RETURNS JSONB LANGUAGE PLPGSQL AS $BODY$ DECLARE _table_name NAME; _schema_name NAME; _hypertable_row _timescaledb_catalog.hypertable; _orderby_names NAME[]; _dimension_names NAME[]; _first_index_attrs NAME[]; _orderby_clauses text[]; _confidence int; BEGIN SELECT n.nspname, c.relname INTO STRICT _schema_name, _table_name FROM pg_class c INNER JOIN pg_namespace n ON (n.oid = c.relnamespace) WHERE c.oid = relation; SELECT * INTO STRICT _hypertable_row FROM _timescaledb_catalog.hypertable h WHERE h.table_name = _table_name AND h.schema_name = _schema_name; --start with the unique index columns minus the segment by columns with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM --is there a better way to pick the right unique index if there are multiple? (select indkey, indnkeyatts from pg_catalog.pg_index where indisunique and indrelid = relation limit 1) i INNER JOIN LATERAL (select * from unnest(i.indkey) with ordinality) a(attnum, pos) ON (TRUE) WHERE a.pos <= i.indnkeyatts GROUP BY 1 ) SELECT array_agg(a.attname ORDER BY i.pos) INTO _orderby_names FROM index_attr i INNER JOIN pg_attribute a on (a.attnum = i.attnum AND a.attrelid = relation) WHERE NOT(a.attname::text = ANY (segment_by_cols)); if _orderby_names is null then _orderby_names := array[]::name[]; _confidence := 5; else _confidence := 8; end if; --add dimension colomns to the end. A dimension column like time should probably always be part of the order by. SELECT array_agg(d.column_name) INTO _dimension_names FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = _hypertable_row.id AND NOT(d.column_name::text = ANY (_orderby_names)) AND NOT(d.column_name::text = ANY (segment_by_cols)); _orderby_names := _orderby_names || _dimension_names; --add the first attribute of any index with index_attr as ( SELECT a.attnum, min(a.pos) as pos FROM (select indkey, indnkeyatts from pg_catalog.pg_index where indrelid = relation) i INNER JOIN LATERAL (select * from unnest(i.indkey) with ordinality) a(attnum, pos) ON (TRUE) WHERE a.pos = 1 GROUP BY 1 ) SELECT array_agg(a.attname ORDER BY i.pos) INTO _first_index_attrs FROM index_attr i INNER JOIN pg_attribute a on (a.attnum = i.attnum AND a.attrelid = relation) WHERE NOT(a.attname::text = ANY (_orderby_names)) AND NOT(a.attname::text = ANY (segment_by_cols)); _orderby_names := _orderby_names || _first_index_attrs; --add DESC to any dimensions SELECT coalesce(array_agg( CASE WHEN d.column_name IS NULL THEN format('%I', a.colname) ELSE format('%I DESC', a.colname) END ORDER BY pos), array[]::text[]) INTO STRICT _orderby_clauses FROM unnest(_orderby_names) WITH ORDINALITY as a(colname, pos) LEFT JOIN _timescaledb_catalog.dimension d ON (d.column_name = a.colname AND d.hypertable_id = _hypertable_row.id); return json_build_object('clauses', _orderby_clauses, 'confidence', _confidence); END $BODY$ SET search_path TO pg_catalog, pg_temp; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/ddl_api.sql������������������������������������������������������������������0000664�0000000�0000000�00000025626�15100345067�0017002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file defines DDL functions for adding and manipulating hypertables. -- Converts a regular postgres table to a hypertable. -- -- relation - The OID of the table to be converted -- time_column_name - Name of the column that contains time for a given record -- partitioning_column - Name of the column to partition data by -- number_partitions - (Optional) Number of partitions for data -- associated_schema_name - (Optional) Schema for internal hypertable tables -- associated_table_prefix - (Optional) Prefix for internal hypertable table names -- chunk_time_interval - (Optional) Initial time interval for a chunk -- create_default_indexes - (Optional) Whether or not to create the default indexes -- if_not_exists - (Optional) Do not fail if table is already a hypertable -- partitioning_func - (Optional) The partitioning function to use for spatial partitioning -- migrate_data - (Optional) Set to true to migrate any existing data in the table to chunks -- chunk_target_size - (Optional) The target size for chunks (e.g., '1000MB', 'estimate', or 'off') -- chunk_sizing_func - (Optional) A function to calculate the chunk time interval for new chunks -- time_partitioning_func - (Optional) The partitioning function to use for "time" partitioning CREATE OR REPLACE FUNCTION @extschema@.create_hypertable( relation REGCLASS, time_column_name NAME, partitioning_column NAME = NULL, number_partitions INTEGER = NULL, associated_schema_name NAME = NULL, associated_table_prefix NAME = NULL, chunk_time_interval ANYELEMENT = NULL::bigint, create_default_indexes BOOLEAN = TRUE, if_not_exists BOOLEAN = FALSE, partitioning_func REGPROC = NULL, migrate_data BOOLEAN = FALSE, chunk_target_size TEXT = NULL, chunk_sizing_func REGPROC = '_timescaledb_functions.calculate_chunk_interval'::regproc, time_partitioning_func REGPROC = NULL ) RETURNS TABLE(hypertable_id INT, schema_name NAME, table_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_create' LANGUAGE C VOLATILE; -- A generalized hypertable creation API that can be used to convert a PostgreSQL table -- with TIME/SERIAL/BIGSERIAL columns to a hypertable. -- -- relation - The OID of the table to be converted -- dimension - The dimension to use for partitioning -- create_default_indexes (Optional) Whether or not to create the default indexes -- if_not_exists (Optional) Do not fail if table is already a hypertable -- migrate_data (Optional) Set to true to migrate any existing data in the table to chunks CREATE OR REPLACE FUNCTION @extschema@.create_hypertable( relation REGCLASS, dimension _timescaledb_internal.dimension_info, create_default_indexes BOOLEAN = TRUE, if_not_exists BOOLEAN = FALSE, migrate_data BOOLEAN = FALSE ) RETURNS TABLE(hypertable_id INT, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_create_general' LANGUAGE C VOLATILE; -- Set adaptive chunking. To disable, set chunk_target_size => 'off'. CREATE OR REPLACE FUNCTION @extschema@.set_adaptive_chunking( hypertable REGCLASS, chunk_target_size TEXT, INOUT chunk_sizing_func REGPROC = '_timescaledb_functions.calculate_chunk_interval'::regproc, OUT chunk_target_size BIGINT ) RETURNS RECORD AS '@MODULE_PATHNAME@', 'ts_chunk_adaptive_set' LANGUAGE C VOLATILE; -- Update chunk_time_interval for a hypertable [DEPRECATED]. -- -- hypertable - The OID of the table corresponding to a hypertable whose time -- interval should be updated -- chunk_time_interval - The new time interval. For hypertables with integral -- time columns, this must be an integral type. For hypertables with a -- TIMESTAMP/TIMESTAMPTZ/DATE type, it can be integral which is treated as -- microseconds, or an INTERVAL type. CREATE OR REPLACE FUNCTION @extschema@.set_chunk_time_interval( hypertable REGCLASS, chunk_time_interval ANYELEMENT, dimension_name NAME = NULL ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_dimension_set_interval' LANGUAGE C VOLATILE; -- Update partition_interval for a hypertable. -- -- hypertable - The OID of the table corresponding to a hypertable whose -- partition interval should be updated -- partition_interval - The new interval. For hypertables with integral/serial/bigserial -- time columns, this must be an integral type. For hypertables with a -- TIMESTAMP/TIMESTAMPTZ/DATE type, it can be integral which is treated as -- microseconds, or an INTERVAL type. CREATE OR REPLACE FUNCTION @extschema@.set_partitioning_interval( hypertable REGCLASS, partition_interval ANYELEMENT, dimension_name NAME = NULL ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_dimension_set_interval' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.set_number_partitions( hypertable REGCLASS, number_partitions INTEGER, dimension_name NAME = NULL ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_dimension_set_num_slices' LANGUAGE C VOLATILE; -- Drop chunks older than the given timestamp for the specific -- hypertable or continuous aggregate. CREATE OR REPLACE FUNCTION @extschema@.drop_chunks( relation REGCLASS, older_than "any" = NULL, newer_than "any" = NULL, verbose BOOLEAN = FALSE, created_before "any" = NULL, created_after "any" = NULL ) RETURNS SETOF TEXT AS '@MODULE_PATHNAME@', 'ts_chunk_drop_chunks' LANGUAGE C VOLATILE PARALLEL UNSAFE; -- show chunks older than or newer than a specific time. -- `relation` must be a valid hypertable or continuous aggregate. CREATE OR REPLACE FUNCTION @extschema@.show_chunks( relation REGCLASS, older_than "any" = NULL, newer_than "any" = NULL, created_before "any" = NULL, created_after "any" = NULL ) RETURNS SETOF REGCLASS AS '@MODULE_PATHNAME@', 'ts_chunk_show_chunks' LANGUAGE C STABLE PARALLEL SAFE; -- Add a dimension (of partitioning) to a hypertable [DEPRECATED] -- -- hypertable - OID of the table to add a dimension to -- column_name - NAME of the column to use in partitioning for this dimension -- number_partitions - Number of partitions, for non-time dimensions -- chunk_time_interval - Size of intervals for time dimensions (can be integral or INTERVAL) -- partitioning_func - Function used to partition the column -- if_not_exists - If set, and the dimension already exists, generate a notice instead of an error CREATE OR REPLACE FUNCTION @extschema@.add_dimension( hypertable REGCLASS, column_name NAME, number_partitions INTEGER = NULL, chunk_time_interval ANYELEMENT = NULL::BIGINT, partitioning_func REGPROC = NULL, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(dimension_id INT, schema_name NAME, table_name NAME, column_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_dimension_add' LANGUAGE C VOLATILE; -- Add a dimension (of partitioning) to a hypertable. -- -- hypertable - OID of the table to add a dimension to -- dimension - Dimension to add -- if_not_exists - If set, and the dimension already exists, generate a notice instead of an error CREATE OR REPLACE FUNCTION @extschema@.add_dimension( hypertable REGCLASS, dimension _timescaledb_internal.dimension_info, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(dimension_id INT, created BOOL) AS '@MODULE_PATHNAME@', 'ts_dimension_add_general' LANGUAGE C VOLATILE; -- Enable tracking of statistics on a column of a hypertable. -- -- hypertable - OID of the table to which the column belongs to -- column_name - The column to track statistics for -- if_not_exists - If set, and the entry already exists, generate a notice instead of an error -- Returns the "id" of the entry created. The "enabled" field -- is set to true if entry is created or exists already. CREATE OR REPLACE FUNCTION @extschema@.enable_chunk_skipping( hypertable REGCLASS, column_name NAME, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(column_stats_id INT, enabled BOOL) AS '@MODULE_PATHNAME@', 'ts_chunk_column_stats_enable' LANGUAGE C VOLATILE; -- Disable tracking of statistics on a column of a hypertable. -- -- hypertable - OID of the table to remove from -- column_name - NAME of the column on which the stats are tracked -- if_not_exists - If set, and the entry does not exist, -- generate a notice instead of an error. The "disabled" field -- is set to true if entry is deleted successfully. CREATE OR REPLACE FUNCTION @extschema@.disable_chunk_skipping( hypertable REGCLASS, column_name NAME, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(hypertable_id INT, column_name NAME, disabled BOOL) AS '@MODULE_PATHNAME@', 'ts_chunk_column_stats_disable' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.by_hash(column_name NAME, number_partitions INTEGER, partition_func regproc = NULL) RETURNS _timescaledb_internal.dimension_info LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_hash_dimension'; CREATE OR REPLACE FUNCTION @extschema@.by_range(column_name NAME, partition_interval ANYELEMENT = NULL::bigint, partition_func regproc = NULL) RETURNS _timescaledb_internal.dimension_info LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_range_dimension'; CREATE OR REPLACE FUNCTION @extschema@.attach_tablespace( tablespace NAME, hypertable REGCLASS, if_not_attached BOOLEAN = false ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_tablespace_attach' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.detach_tablespace( tablespace NAME, hypertable REGCLASS = NULL, if_attached BOOLEAN = false ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_tablespace_detach' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.detach_tablespaces(hypertable REGCLASS) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_tablespace_detach_all_from_hypertable' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.show_tablespaces(hypertable REGCLASS) RETURNS SETOF NAME AS '@MODULE_PATHNAME@', 'ts_tablespace_show' LANGUAGE C VOLATILE STRICT; -- Refresh a continuous aggregate across the given window. CREATE OR REPLACE PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN = FALSE, options JSONB = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_continuous_agg_refresh'; ����������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/ddl_triggers.sql�������������������������������������������������������������0000664�0000000�0000000�00000001600�15100345067�0020041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP EVENT TRIGGER IF EXISTS timescaledb_ddl_command_end; CREATE OR REPLACE FUNCTION _timescaledb_functions.process_ddl_event() RETURNS event_trigger AS '@MODULE_PATHNAME@', 'ts_timescaledb_process_ddl_event' LANGUAGE C; --EVENT TRIGGER MUST exclude the ALTER EXTENSION tag. CREATE EVENT TRIGGER timescaledb_ddl_command_end ON ddl_command_end WHEN TAG IN ('ALTER TABLE','CREATE TRIGGER','CREATE TABLE','CREATE INDEX','ALTER INDEX', 'DROP TABLE', 'DROP INDEX', 'DROP SCHEMA') EXECUTE FUNCTION _timescaledb_functions.process_ddl_event(); DROP EVENT TRIGGER IF EXISTS timescaledb_ddl_sql_drop; CREATE EVENT TRIGGER timescaledb_ddl_sql_drop ON sql_drop EXECUTE FUNCTION _timescaledb_functions.process_ddl_event(); ��������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/debug_build_utils.sql��������������������������������������������������������0000664�0000000�0000000�00000001536�15100345067�0021065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains utility functions that are only used in debug -- builds for debugging and testing. CREATE OR REPLACE FUNCTION debug_waitpoint_enable(TEXT) RETURNS VOID LANGUAGE C VOLATILE STRICT AS '@MODULE_PATHNAME@', 'ts_debug_point_enable'; CREATE OR REPLACE FUNCTION debug_waitpoint_release(TEXT) RETURNS VOID LANGUAGE C VOLATILE STRICT AS '@MODULE_PATHNAME@', 'ts_debug_point_release'; CREATE OR REPLACE FUNCTION debug_waitpoint_id(TEXT) RETURNS BIGINT LANGUAGE C VOLATILE STRICT AS '@MODULE_PATHNAME@', 'ts_debug_point_id'; CREATE OR REPLACE FUNCTION ts_now_mock() RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_now_mock' LANGUAGE C STABLE STRICT PARALLEL SAFE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/debug_utils.sql��������������������������������������������������������������0000664�0000000�0000000�00000000741�15100345067�0017703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains utility functions and views that are used for -- debugging in release builds. These are all placed in the schema -- _timescaledb_debug. CREATE OR REPLACE FUNCTION _timescaledb_debug.extension_state() RETURNS TEXT AS '@MODULE_PATHNAME@', 'ts_extension_get_state' LANGUAGE C; �������������������������������timescaledb-2.23.0/sql/gapfill.sql������������������������������������������������������������������0000664�0000000�0000000�00000006060�15100345067�0017013�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width SMALLINT, ts SMALLINT, start SMALLINT=NULL, finish SMALLINT=NULL) RETURNS SMALLINT AS '@MODULE_PATHNAME@', 'ts_gapfill_int16_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width INT, ts INT, start INT=NULL, finish INT=NULL) RETURNS INT AS '@MODULE_PATHNAME@', 'ts_gapfill_int32_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width BIGINT, ts BIGINT, start BIGINT=NULL, finish BIGINT=NULL) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_gapfill_int64_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width INTERVAL, ts DATE, start DATE=NULL, finish DATE=NULL) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_gapfill_date_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width INTERVAL, ts TIMESTAMP, start TIMESTAMP=NULL, finish TIMESTAMP=NULL) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_gapfill_timestamp_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width INTERVAL, ts TIMESTAMPTZ, start TIMESTAMPTZ=NULL, finish TIMESTAMPTZ=NULL) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_gapfill_timestamptz_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.time_bucket_gapfill(bucket_width INTERVAL, ts TIMESTAMPTZ, timezone TEXT, start TIMESTAMPTZ=NULL, finish TIMESTAMPTZ=NULL) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_gapfill_timestamptz_timezone_bucket' LANGUAGE C VOLATILE PARALLEL SAFE; -- locf function CREATE OR REPLACE FUNCTION @extschema@.locf(value ANYELEMENT, prev ANYELEMENT=NULL, treat_null_as_missing BOOL=false) RETURNS ANYELEMENT AS '@MODULE_PATHNAME@', 'ts_gapfill_marker' LANGUAGE C VOLATILE PARALLEL SAFE; -- interpolate functions CREATE OR REPLACE FUNCTION @extschema@.interpolate(value SMALLINT,prev RECORD=NULL,next RECORD=NULL) RETURNS SMALLINT AS '@MODULE_PATHNAME@', 'ts_gapfill_marker' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.interpolate(value INT,prev RECORD=NULL,next RECORD=NULL) RETURNS INT AS '@MODULE_PATHNAME@', 'ts_gapfill_marker' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.interpolate(value BIGINT,prev RECORD=NULL,next RECORD=NULL) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_gapfill_marker' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.interpolate(value REAL,prev RECORD=NULL,next RECORD=NULL) RETURNS REAL AS '@MODULE_PATHNAME@', 'ts_gapfill_marker' LANGUAGE C VOLATILE PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.interpolate(value FLOAT,prev RECORD=NULL,next RECORD=NULL) RETURNS FLOAT AS '@MODULE_PATHNAME@', 'ts_gapfill_marker' LANGUAGE C VOLATILE PARALLEL SAFE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/histogram.sql����������������������������������������������������������������0000664�0000000�0000000�00000004762�15100345067�0017401�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.hist_sfunc (state INTERNAL, val DOUBLE PRECISION, MIN DOUBLE PRECISION, MAX DOUBLE PRECISION, nbuckets INTEGER) RETURNS INTERNAL AS '@MODULE_PATHNAME@', 'ts_hist_sfunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.hist_combinefunc(state1 INTERNAL, state2 INTERNAL) RETURNS INTERNAL AS '@MODULE_PATHNAME@', 'ts_hist_combinefunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.hist_serializefunc(INTERNAL) RETURNS bytea AS '@MODULE_PATHNAME@', 'ts_hist_serializefunc' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.hist_deserializefunc(bytea, INTERNAL) RETURNS INTERNAL AS '@MODULE_PATHNAME@', 'ts_hist_deserializefunc' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.hist_finalfunc(state INTERNAL, val DOUBLE PRECISION, MIN DOUBLE PRECISION, MAX DOUBLE PRECISION, nbuckets INTEGER) RETURNS INTEGER[] AS '@MODULE_PATHNAME@', 'ts_hist_finalfunc' LANGUAGE C IMMUTABLE PARALLEL SAFE; -- We started using CREATE OR REPLACE AGGREGATE for aggregate creation once the syntax was fully supported -- as it is easier to support idempotent changes this way. This will allow for changes to functions supporting -- the aggregate, and, for instance, the definition and inclusion of inverse functions for window function -- support. However, it should still be noted that changes to the data structures used for the internal -- state of the aggregate must be backwards compatible and the old format must be accepted by any new functions -- in order for them to continue working with Continuous Aggregates, where old states may have been materialized. -- This aggregate partitions the dataset into a specified number of buckets (nbuckets) ranging -- from the inputted min to max values. CREATE OR REPLACE AGGREGATE @extschema@.histogram (DOUBLE PRECISION, DOUBLE PRECISION, DOUBLE PRECISION, INTEGER) ( SFUNC = _timescaledb_functions.hist_sfunc, STYPE = INTERNAL, COMBINEFUNC = _timescaledb_functions.hist_combinefunc, SERIALFUNC = _timescaledb_functions.hist_serializefunc, DESERIALFUNC = _timescaledb_functions.hist_deserializefunc, PARALLEL = SAFE, FINALFUNC = _timescaledb_functions.hist_finalfunc, FINALFUNC_EXTRA ); ��������������timescaledb-2.23.0/sql/hypertable.sql���������������������������������������������������������������0000664�0000000�0000000�00000000651�15100345067�0017534�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION @extschema@.set_integer_now_func(hypertable REGCLASS, integer_now_func REGPROC, replace_if_exists BOOL = false) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_hypertable_set_integer_now_func' LANGUAGE C VOLATILE STRICT; ���������������������������������������������������������������������������������������timescaledb-2.23.0/sql/job_api.sql������������������������������������������������������������������0000664�0000000�0000000�00000003633�15100345067�0017003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION @extschema@.add_job( proc REGPROC, schedule_interval INTERVAL, config JSONB DEFAULT NULL, initial_start TIMESTAMPTZ DEFAULT NULL, scheduled BOOL DEFAULT true, check_config REGPROC DEFAULT NULL, fixed_schedule BOOL DEFAULT TRUE, timezone TEXT DEFAULT NULL, job_name TEXT DEFAULT NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_job_add' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.delete_job(job_id INTEGER) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_job_delete' LANGUAGE C VOLATILE STRICT; CREATE OR REPLACE PROCEDURE @extschema@.run_job(job_id INTEGER) AS '@MODULE_PATHNAME@', 'ts_job_run' LANGUAGE C; -- Returns the updated job schedule values CREATE OR REPLACE FUNCTION @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL = NULL, max_runtime INTERVAL = NULL, max_retries INTEGER = NULL, retry_period INTERVAL = NULL, scheduled BOOL = NULL, config JSONB = NULL, next_start TIMESTAMPTZ = NULL, if_exists BOOL = FALSE, check_config REGPROC = NULL, fixed_schedule BOOL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT DEFAULT NULL, job_name TEXT DEFAULT NULL ) RETURNS TABLE (job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, check_config TEXT, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT, application_name name) AS '@MODULE_PATHNAME@', 'ts_job_alter' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.alter_job_set_hypertable_id( job_id INTEGER, hypertable REGCLASS ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_job_alter_set_hypertable_id' LANGUAGE C VOLATILE; �����������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/job_stat_history_log_retention.sql�������������������������������������������0000664�0000000�0000000�00000013722�15100345067�0023716�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- A retention policy is set up for the table _timescaledb_internal.job_errors (Error Log Retention Policy [2]) -- By default, it will run once a month and and drop rows older than a month. -- We use binary search on the id column to figure out which rows should be retained from the job history table -- Doing it this way allows us to use the index on the `id` column, which (empirically) we found is faster than querying on the `execution_finish` column directly without an index -- This works because `execution_finish` is always ordered. -- We can consider alternative approaches to simplify this in the future. CREATE OR REPLACE FUNCTION _timescaledb_functions.job_history_bsearch(search_point TIMESTAMPTZ) RETURNS BIGINT AS $$ DECLARE id_lower BIGINT; id_upper BIGINT; id_middle BIGINT DEFAULT 0; target_tz TIMESTAMPTZ; BEGIN SELECT COALESCE(min(id), 0), COALESCE(max(id), 0) INTO id_lower, id_upper FROM _timescaledb_internal.bgw_job_stat_history; IF id_lower = 0 AND id_upper = 0 THEN RETURN NULL; END IF; -- We want the first entry in the table where execution_finish is >= search_point WHILE id_lower < id_upper LOOP id_middle := id_lower + (id_upper - id_lower) / 2; SELECT execution_finish INTO target_tz FROM _timescaledb_internal.bgw_job_stat_history WHERE id = id_middle; -- If the id_middle is not found, shift to a previous id that's still in the search space IF NOT FOUND THEN SELECT execution_finish, id INTO target_tz, id_middle FROM _timescaledb_internal.bgw_job_stat_history WHERE id <= id_middle AND id >= id_lower ORDER BY id LIMIT 1; IF NOT FOUND THEN id_middle := id_lower; END IF; END IF; IF target_tz >= search_point THEN id_upper := id_middle; ELSE id_lower := id_middle + 1; END IF; END LOOP; -- Handle the case where no ids need to be deleted and return NULL instead SELECT execution_finish INTO target_tz FROM _timescaledb_internal.bgw_job_stat_history WHERE id = id_lower; IF target_tz < search_point THEN RETURN NULL; END IF; RETURN id_lower; END $$ LANGUAGE plpgsql SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_job_stat_history_retention(job_id integer, config JSONB) RETURNS integer LANGUAGE PLPGSQL AS $BODY$ DECLARE numrows INTEGER; search_point TIMESTAMPTZ; id_found BIGINT; BEGIN PERFORM set_config('lock_timeout', coalesce(config->>'lock_timeout', '5s'), true /* is local */); -- We need to prevent concurrent changes on this table when running this retention job -- We take an AccessExclusiveLock at the start since we TRUNCATE later LOCK TABLE _timescaledb_internal.bgw_job_stat_history IN ACCESS EXCLUSIVE MODE; search_point := now() - (config->>'drop_after')::interval; id_found := _timescaledb_functions.job_history_bsearch(search_point); IF id_found IS NULL THEN RETURN 0; END IF; -- Build a table that contains only rows younger than the max age -- and satisfy the constraints on number of successfull and failures -- for each job. Since the table is ordered, we can use the "id" -- column to find out what records to remove. CREATE TEMP TABLE __tmp_bgw_job_stat_history ON COMMIT DROP AS WITH enumerated AS ( SELECT *, row_number() OVER ( PARTITION BY j.job_id, j.succeeded ORDER BY j.execution_finish DESC ) AS row_number FROM _timescaledb_internal.bgw_job_stat_history j WHERE id >= id_found) SELECT id, e.job_id, pid, execution_start, execution_finish, succeeded, data FROM enumerated e WHERE succeeded AND row_number <= (config->>'max_successes_per_job')::int OR NOT succeeded AND row_number <= (config->>'max_failures_per_job')::int ORDER BY id; TRUNCATE _timescaledb_internal.bgw_job_stat_history; INSERT INTO _timescaledb_internal.bgw_job_stat_history SELECT * FROM __tmp_bgw_job_stat_history; GET DIAGNOSTICS numrows = ROW_COUNT; RETURN numrows; END $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_job_stat_history_retention_check(config JSONB) RETURNS VOID LANGUAGE PLPGSQL AS $BODY$ BEGIN IF config IS NULL THEN RAISE EXCEPTION 'config cannot be NULL, and must contain drop_after'; END IF; IF NOT (config ? 'drop_after') THEN RAISE EXCEPTION 'drop_after interval not provided'; END IF; IF NOT (config ? 'max_successes_per_job') THEN RAISE EXCEPTION 'max_successes_per_job not provided'; END IF; IF NOT (config ? 'max_failures_per_job') THEN RAISE EXCEPTION 'max_failures_per_job not provided'; END IF; IF (config->>'max_successes_per_job')::integer < 10 THEN RAISE EXCEPTION 'max_successes_per_job has to be at least 10'; END IF; IF (config->>'max_failures_per_job')::integer < 10 THEN RAISE EXCEPTION 'max_failures_per_job has to be at least 10'; END IF; END $BODY$ SET search_path TO pg_catalog, pg_temp; INSERT INTO _timescaledb_config.bgw_job ( id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, config, check_schema, check_name, fixed_schedule, initial_start ) VALUES ( 3, 'Job History Log Retention Policy [3]', INTERVAL '6 hours', INTERVAL '1 hour', -1, INTERVAL '1h', '_timescaledb_functions', 'policy_job_stat_history_retention', pg_catalog.quote_ident(current_role)::regrole, true, '{"drop_after":"1 month","max_successes_per_job":1000,"max_failures_per_job":1000}', '_timescaledb_functions', 'policy_job_stat_history_retention_check', true, '2000-01-01 00:00:00+00'::timestamptz ) ON CONFLICT (id) DO NOTHING; ����������������������������������������������timescaledb-2.23.0/sql/maintenance_utils.sql��������������������������������������������������������0000664�0000000�0000000�00000017724�15100345067�0021110�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- chunk - the OID of the chunk to be CLUSTERed -- index - the OID of the index to be CLUSTERed on, or NULL to use the index -- last used CREATE OR REPLACE FUNCTION @extschema@.reorder_chunk( chunk REGCLASS, index REGCLASS=NULL, verbose BOOLEAN=FALSE ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_reorder_chunk' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.move_chunk( chunk REGCLASS, destination_tablespace Name, index_destination_tablespace Name=NULL, reorder_index REGCLASS=NULL, verbose BOOLEAN=FALSE ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_move_chunk' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.create_compressed_chunk( chunk REGCLASS, chunk_table REGCLASS, uncompressed_heap_size BIGINT, uncompressed_toast_size BIGINT, uncompressed_index_size BIGINT, compressed_heap_size BIGINT, compressed_toast_size BIGINT, compressed_index_size BIGINT, numrows_pre_compression BIGINT, numrows_post_compression BIGINT ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_create_compressed_chunk' LANGUAGE C STRICT VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.compress_chunk( uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true, recompress BOOLEAN = false ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_compress_chunk' LANGUAGE C VOLATILE; -- Alias for compress_chunk above. CREATE OR REPLACE PROCEDURE @extschema@.convert_to_columnstore( chunk REGCLASS, if_not_columnstore BOOLEAN = true, recompress BOOLEAN = false ) AS '@MODULE_PATHNAME@', 'ts_compress_chunk' LANGUAGE C; CREATE OR REPLACE FUNCTION @extschema@.decompress_chunk( uncompressed_chunk REGCLASS, if_compressed BOOLEAN = true ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_decompress_chunk' LANGUAGE C STRICT VOLATILE; CREATE OR REPLACE PROCEDURE @extschema@.convert_to_rowstore( chunk REGCLASS, if_columnstore BOOLEAN = true ) AS '@MODULE_PATHNAME@', 'ts_decompress_chunk' LANGUAGE C; CREATE OR REPLACE PROCEDURE @extschema@.merge_chunks( chunk1 REGCLASS, chunk2 REGCLASS ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_merge_two_chunks'; CREATE OR REPLACE PROCEDURE @extschema@.merge_chunks( chunks REGCLASS[] ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_merge_chunks'; CREATE OR REPLACE PROCEDURE @extschema@.split_chunk( chunk REGCLASS, split_at "any" = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_split_chunk'; CREATE OR REPLACE FUNCTION _timescaledb_functions.recompress_chunk_segmentwise( uncompressed_chunk REGCLASS, if_compressed BOOLEAN = true ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_recompress_chunk_segmentwise' LANGUAGE C STRICT VOLATILE; -- find the index on the compressed chunk that can be used to recompress efficiently -- this index must contain all the segmentby columns and the meta_sequence_number column last CREATE OR REPLACE FUNCTION _timescaledb_functions.get_compressed_chunk_index_for_recompression( uncompressed_chunk REGCLASS ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_get_compressed_chunk_index_for_recompression' LANGUAGE C STRICT VOLATILE; -- Recompress a chunk -- -- Will give an error if the chunk was not already compressed. In this -- case, the user should use compress_chunk instead. Note that this -- function cannot be executed in an explicit transaction since it -- contains transaction control commands. -- -- Parameters: -- chunk: Chunk to recompress. -- if_not_compressed: Print notice instead of error if chunk is already compressed. CREATE OR REPLACE PROCEDURE @extschema@.recompress_chunk(chunk REGCLASS, if_not_compressed BOOLEAN = true) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('timescaledb.enable_deprecation_warnings', true)::bool THEN RAISE WARNING 'procedure @extschema@.recompress_chunk(regclass,boolean) is deprecated and the functionality is now included in @extschema@.compress_chunk. this compatibility function will be removed in a future version.'; END IF; PERFORM @extschema@.compress_chunk(chunk, if_not_compressed); END$$ SET search_path TO pg_catalog,pg_temp; -- A version of makeaclitem that accepts a comma-separated list of -- privileges rather than just a single privilege. This is copied from -- PG16, but since we need to support earlier versions, we provide it -- with the extension. -- -- This is intended for internal usage and interface might change. CREATE OR REPLACE FUNCTION _timescaledb_functions.makeaclitem(regrole, regrole, text, bool) RETURNS AclItem AS '@MODULE_PATHNAME@', 'ts_makeaclitem' LANGUAGE C STABLE PARALLEL SAFE STRICT; -- Repair relation ACL by removing roles that do not exist in pg_authid. CREATE OR REPLACE PROCEDURE _timescaledb_functions.repair_relation_acls() LANGUAGE SQL AS $$ WITH badrels AS ( SELECT oid::regclass FROM (SELECT oid, (aclexplode(relacl)).* FROM pg_class) AS rels WHERE rels.grantee != 0 AND rels.grantee NOT IN (SELECT oid FROM pg_authid) ), pickacls AS ( SELECT oid::regclass, _timescaledb_functions.makeaclitem( b.grantee, b.grantor, string_agg(b.privilege_type, ','), b.is_grantable ) AS acl FROM (SELECT oid, (aclexplode(relacl)).* AS a FROM pg_class) AS b WHERE b.grantee IN (SELECT oid FROM pg_authid) GROUP BY oid, b.grantee, b.grantor, b.is_grantable ), cleanacls AS ( SELECT oid, array_agg(acl) AS acl FROM pickacls GROUP BY oid ) UPDATE pg_class c SET relacl = (SELECT acl FROM cleanacls n WHERE c.oid = n.oid) WHERE oid IN (SELECT oid FROM badrels) $$ SET search_path TO pg_catalog, pg_temp; -- Remove chunk metadata when marked as dropped CREATE OR REPLACE FUNCTION _timescaledb_functions.remove_dropped_chunk_metadata(_hypertable_id INTEGER) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE _chunk_id INTEGER; _removed INTEGER := 0; BEGIN FOR _chunk_id IN SELECT id FROM _timescaledb_catalog.chunk WHERE hypertable_id = _hypertable_id AND dropped IS TRUE AND NOT EXISTS ( SELECT FROM information_schema.tables WHERE tables.table_schema = chunk.schema_name AND tables.table_name = chunk.table_name ) AND NOT EXISTS ( SELECT FROM _timescaledb_catalog.hypertable JOIN _timescaledb_catalog.continuous_agg ON continuous_agg.raw_hypertable_id = hypertable.id WHERE hypertable.id = chunk.hypertable_id -- for the old caggs format we need to keep chunk metadata for dropped chunks AND continuous_agg.finalized IS FALSE ) LOOP _removed := _removed + 1; RAISE INFO 'Removing metadata of chunk % from hypertable %', _chunk_id, _hypertable_id; WITH _dimension_slice_remove AS ( DELETE FROM _timescaledb_catalog.dimension_slice USING _timescaledb_catalog.chunk_constraint WHERE dimension_slice.id = chunk_constraint.dimension_slice_id AND chunk_constraint.chunk_id = _chunk_id AND NOT EXISTS ( SELECT FROM _timescaledb_catalog.chunk_constraint cc WHERE cc.chunk_id <> _chunk_id AND cc.dimension_slice_id = dimension_slice.id ) RETURNING _timescaledb_catalog.dimension_slice.id ) DELETE FROM _timescaledb_catalog.chunk_constraint USING _dimension_slice_remove WHERE chunk_constraint.dimension_slice_id = _dimension_slice_remove.id; DELETE FROM _timescaledb_catalog.chunk_constraint WHERE chunk_constraint.chunk_id = _chunk_id; DELETE FROM _timescaledb_internal.bgw_policy_chunk_stats WHERE bgw_policy_chunk_stats.chunk_id = _chunk_id; DELETE FROM _timescaledb_catalog.compression_chunk_size WHERE compression_chunk_size.chunk_id = _chunk_id OR compression_chunk_size.compressed_chunk_id = _chunk_id; DELETE FROM _timescaledb_catalog.chunk WHERE chunk.id = _chunk_id OR chunk.compressed_chunk_id = _chunk_id; END LOOP; RETURN _removed; END; $$ SET search_path TO pg_catalog, pg_temp; ��������������������������������������������timescaledb-2.23.0/sql/metadata.sql�����������������������������������������������������������������0000664�0000000�0000000�00000003751�15100345067�0017161�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.generate_uuid() RETURNS UUID AS '@MODULE_PATHNAME@', 'ts_uuid_generate' LANGUAGE C VOLATILE STRICT; -- Trigger to change INSERT into UPDATE if key already exists. -- -- During extension installation we create 3 entries in the metadata table which are -- included in dumps. To allow loading logical dumps we need this trigger to turn INSERTs -- into UPDATEs if the key already exists. CREATE OR REPLACE FUNCTION _timescaledb_functions.metadata_insert_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN IF EXISTS (SELECT FROM _timescaledb_catalog.metadata WHERE key = NEW.key) THEN UPDATE _timescaledb_catalog.metadata SET value = NEW.value WHERE key = NEW.key; RETURN NULL; END IF; RETURN NEW; END $$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE TRIGGER metadata_insert_trigger BEFORE INSERT ON _timescaledb_catalog.metadata FOR EACH ROW EXECUTE PROCEDURE _timescaledb_functions.metadata_insert_trigger(); -- Insert uuid and install_timestamp on database creation since the trigger -- will turn these into UPDATEs on conflicts we can't use ON CONFLICT DO NOTHING. DO $$ BEGIN IF (NOT EXISTS (SELECT FROM _timescaledb_catalog.metadata WHERE key = 'uuid')) THEN INSERT INTO _timescaledb_catalog.metadata SELECT 'uuid', _timescaledb_functions.generate_uuid(), TRUE; END IF; IF (NOT EXISTS (SELECT FROM _timescaledb_catalog.metadata WHERE key = 'install_timestamp')) THEN INSERT INTO _timescaledb_catalog.metadata SELECT 'install_timestamp', now(), TRUE; END IF; END $$; -- Install catalog version on database installation and upgrade. -- This allows us to detect catalog mismatches in dump/restore cycle. INSERT INTO _timescaledb_catalog.metadata (key, value, include_in_telemetry) SELECT 'timescaledb_version', '@PROJECT_VERSION_MOD@', FALSE; �����������������������timescaledb-2.23.0/sql/notice.sql�������������������������������������������������������������������0000664�0000000�0000000�00000003366�15100345067�0016664�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DO language plpgsql $$ DECLARE telemetry_string TEXT; telemetry_level text; BEGIN telemetry_level := current_setting('timescaledb.telemetry_level', true); CASE telemetry_level WHEN 'off' THEN telemetry_string = E'Note: Please enable telemetry to help us improve our product by running: ALTER DATABASE "' || current_database() || E'" SET timescaledb.telemetry_level = ''basic'';'; WHEN 'basic' THEN telemetry_string = E'Note: TimescaleDB collects anonymous reports to better understand and assist our users.\nFor more information and how to disable, please see our docs https://docs.timescale.com/timescaledb/latest/how-to-guides/configuration/telemetry.'; ELSE telemetry_string = E''; END CASE; RAISE NOTICE E'%\n%\n', E'\nWELCOME TO\n' || E' _____ _ _ ____________ \n' || E'|_ _(_) | | | _ \\ ___ \\ \n' || E' | | _ _ __ ___ ___ ___ ___ __ _| | ___| | | | |_/ / \n' || ' | | | | _ ` _ \ / _ \/ __|/ __/ _` | |/ _ \ | | | ___ \ ' || E'\n' || ' | | | | | | | | | __/\__ \ (_| (_| | | __/ |/ /| |_/ /' || E'\n' || ' |_| |_|_| |_| |_|\___||___/\___\__,_|_|\___|___/ \____/' || E'\n' || E' Running version ' || '@PROJECT_VERSION_MOD@' || E'\n' || E'For more information on TimescaleDB, please visit the following links:\n\n' || E' 1. Getting started: https://docs.timescale.com/timescaledb/latest/getting-started\n' || E' 2. API reference documentation: https://docs.timescale.com/api/latest\n', telemetry_string; END; $$; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/osm_api.sql������������������������������������������������������������������0000664�0000000�0000000�00000001360�15100345067�0017022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This function updates the dimension slice range stored in the catalog with the min and max -- values that the OSM chunk contains. Since there is only one OSM chunk per hypertable with -- only a time dimension, the hypertable is used to determine the corresponding slice CREATE OR REPLACE FUNCTION _timescaledb_functions.hypertable_osm_range_update( hypertable REGCLASS, range_start ANYELEMENT = NULL::bigint, range_end ANYELEMENT = NULL, empty BOOL = false ) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_hypertable_osm_range_update' LANGUAGE C VOLATILE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/partialize_finalize.sql������������������������������������������������������0000664�0000000�0000000�00000002672�15100345067�0021427�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.partialize_agg(arg ANYELEMENT) RETURNS BYTEA AS '@MODULE_PATHNAME@', 'ts_partialize_agg' LANGUAGE C STABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.finalize_agg_sfunc( tstate internal, aggfn TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val ANYELEMENT) RETURNS internal AS '@MODULE_PATHNAME@', 'ts_finalize_agg_sfunc' LANGUAGE C IMMUTABLE; CREATE OR REPLACE FUNCTION _timescaledb_functions.finalize_agg_ffunc( tstate internal, aggfn TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val ANYELEMENT) RETURNS anyelement AS '@MODULE_PATHNAME@', 'ts_finalize_agg_ffunc' LANGUAGE C IMMUTABLE; CREATE OR REPLACE AGGREGATE _timescaledb_functions.finalize_agg(agg_name TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val anyelement) ( SFUNC = _timescaledb_functions.finalize_agg_sfunc, STYPE = internal, FINALFUNC = _timescaledb_functions.finalize_agg_ffunc, FINALFUNC_EXTRA ); ����������������������������������������������������������������������timescaledb-2.23.0/sql/partitioning.sql�������������������������������������������������������������0000664�0000000�0000000�00000001154�15100345067�0020103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Deprecated partition hash function CREATE OR REPLACE FUNCTION _timescaledb_functions.get_partition_for_key(val anyelement) RETURNS int AS '@MODULE_PATHNAME@', 'ts_get_partition_for_key' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_partition_hash(val anyelement) RETURNS int AS '@MODULE_PATHNAME@', 'ts_get_partition_hash' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/policy_api.sql���������������������������������������������������������������0000664�0000000�0000000�00000013626�15100345067�0017533�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Add a retention policy to a hypertable or continuous aggregate. -- The retention_window (typically an INTERVAL) determines the -- window beyond which data is dropped at the time -- of execution of the policy (e.g., '1 week'). Note that the retention -- window will always align with chunk boundaries, thus the window -- might be larger than the given one, but never smaller. In other -- words, some data beyond the retention window -- might be kept, but data within the window will never be deleted. CREATE OR REPLACE FUNCTION @extschema@.add_retention_policy( relation REGCLASS, drop_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, drop_created_before INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_retention_add' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.remove_retention_policy( relation REGCLASS, if_exists BOOL = false ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_policy_retention_remove' LANGUAGE C VOLATILE STRICT; /* reorder policy */ CREATE OR REPLACE FUNCTION @extschema@.add_reorder_policy( hypertable REGCLASS, index_name NAME, if_not_exists BOOL = false, initial_start timestamptz = NULL, timezone TEXT = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_reorder_add' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.remove_reorder_policy(hypertable REGCLASS, if_exists BOOL = false) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_policy_reorder_remove' LANGUAGE C VOLATILE STRICT; /* compression policy */ CREATE OR REPLACE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, compress_created_before INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_compression_add' LANGUAGE C VOLATILE; -- not strict because we need to set different default values for schedule_interval CREATE OR REPLACE PROCEDURE @extschema@.add_columnstore_policy( hypertable REGCLASS, after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, created_before INTERVAL = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_policy_compression_add'; CREATE OR REPLACE FUNCTION @extschema@.remove_compression_policy(hypertable REGCLASS, if_exists BOOL = false) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_policy_compression_remove' LANGUAGE C VOLATILE STRICT; CREATE OR REPLACE PROCEDURE @extschema@.remove_columnstore_policy( hypertable REGCLASS, if_exists BOOL = false ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_policy_compression_remove'; /* continuous aggregates policy */ CREATE OR REPLACE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, include_tiered_data BOOL = NULL, buckets_per_batch INTEGER = NULL, max_batches_per_execution INTEGER = NULL, refresh_newest_first BOOL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_add' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION @extschema@.remove_continuous_aggregate_policy( continuous_aggregate REGCLASS, if_not_exists BOOL = false, -- deprecating this argument, if_exists overrides it if_exists BOOL = NULL) -- when NULL get the value from if_not_exists RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_remove' LANGUAGE C VOLATILE; CREATE OR REPLACE PROCEDURE @extschema@.add_process_hypertable_invalidations_policy( hypertable REGCLASS, schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_policy_process_hyper_inval_add'; CREATE OR REPLACE PROCEDURE @extschema@.remove_process_hypertable_invalidations_policy( hypertable REGCLASS, if_exists BOOL = false ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_policy_process_hyper_inval_remove'; /* 1 step policies */ /* Add policies */ /* Unsupported drop_created_before/compress_created_before in add/alter for caggs */ CREATE OR REPLACE FUNCTION timescaledb_experimental.add_policies( relation REGCLASS, if_not_exists BOOL = false, refresh_start_offset "any" = NULL, refresh_end_offset "any" = NULL, compress_after "any" = NULL, drop_after "any" = NULL ) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_policies_add' LANGUAGE C VOLATILE; /* Remove policies */ CREATE OR REPLACE FUNCTION timescaledb_experimental.remove_policies( relation REGCLASS, if_exists BOOL = false, VARIADIC policy_names TEXT[] = NULL) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_policies_remove' LANGUAGE C VOLATILE; /* Remove all policies */ CREATE OR REPLACE FUNCTION timescaledb_experimental.remove_all_policies( relation REGCLASS, if_exists BOOL = false) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_policies_remove_all' LANGUAGE C VOLATILE; /* Alter policies */ CREATE OR REPLACE FUNCTION timescaledb_experimental.alter_policies( relation REGCLASS, if_exists BOOL = false, refresh_start_offset "any" = NULL, refresh_end_offset "any" = NULL, compress_after "any" = NULL, drop_after "any" = NULL) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_policies_alter' LANGUAGE C VOLATILE; /* Show policies info */ CREATE OR REPLACE FUNCTION timescaledb_experimental.show_policies( relation REGCLASS) RETURNS SETOF JSONB AS '@MODULE_PATHNAME@', 'ts_policies_show' LANGUAGE C VOLATILE; ����������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/policy_internal.sql����������������������������������������������������������0000664�0000000�0000000�00000024355�15100345067�0020577�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_retention(job_id INTEGER, config JSONB) AS '@MODULE_PATHNAME@', 'ts_policy_retention_proc' LANGUAGE C; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_retention_check(config JSONB) RETURNS void AS '@MODULE_PATHNAME@', 'ts_policy_retention_check' LANGUAGE C; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_reorder(job_id INTEGER, config JSONB) AS '@MODULE_PATHNAME@', 'ts_policy_reorder_proc' LANGUAGE C; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_reorder_check(config JSONB) RETURNS void AS '@MODULE_PATHNAME@', 'ts_policy_reorder_check' LANGUAGE C; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_recompression(job_id INTEGER, config JSONB) AS '@MODULE_PATHNAME@', 'ts_policy_recompression_proc' LANGUAGE C; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_compression_check(config JSONB) RETURNS void AS '@MODULE_PATHNAME@', 'ts_policy_compression_check' LANGUAGE C; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_refresh_continuous_aggregate(job_id INTEGER, config JSONB) AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_proc' LANGUAGE C; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_refresh_continuous_aggregate_check(config JSONB) RETURNS void AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_check' LANGUAGE C; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_process_hypertable_invalidations(job_id INTEGER, config JSONB) AS '@MODULE_PATHNAME@', 'ts_policy_process_hyper_inval_proc' LANGUAGE C; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_process_hypertable_invalidations_check(config JSONB) RETURNS void AS '@MODULE_PATHNAME@', 'ts_policy_process_hyper_inval_check' LANGUAGE C; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, reindex_enabled BOOLEAN, use_creation_time BOOLEAN ) AS $$ DECLARE htoid REGCLASS; chunk_rec RECORD; idx_rec RECORD; numchunks_compressed INTEGER := 0; _message text; _detail text; _sqlstate text; -- fully compressed chunk status status_fully_compressed int := 1; -- chunk status bits: bit_compressed int := 1; bit_compressed_unordered int := 2; bit_frozen int := 4; bit_compressed_partial int := 8; creation_lag INTERVAL := NULL; chunks_failure INTEGER := 0; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; SELECT format('%I.%I', schema_name, table_name) INTO htoid FROM _timescaledb_catalog.hypertable WHERE id = htid; -- for the integer cases, we have to compute the lag w.r.t -- the integer_now function and then pass on to show_chunks IF pg_typeof(lag) IN ('BIGINT'::regtype, 'INTEGER'::regtype, 'SMALLINT'::regtype) THEN -- cannot have use_creation_time set with this IF use_creation_time IS TRUE THEN RAISE EXCEPTION 'job % cannot use creation time with integer_now function', job_id; END IF; lag := _timescaledb_functions.subtract_integer_from_now(htoid, lag::BIGINT); END IF; -- if use_creation_time has been specified then the lag needs to be used with the -- "compress_created_before" argument. Otherwise the usual "older_than" argument -- is good enough IF use_creation_time IS TRUE THEN creation_lag := lag; lag := NULL; END IF; FOR chunk_rec IN SELECT show.oid, ch.schema_name, ch.table_name, ch.status FROM @extschema@.show_chunks(htoid, older_than => lag, created_before => creation_lag) AS show(oid) INNER JOIN pg_class pgc ON pgc.oid = show.oid INNER JOIN pg_namespace pgns ON pgc.relnamespace = pgns.oid INNER JOIN _timescaledb_catalog.chunk ch ON ch.table_name = pgc.relname AND ch.schema_name = pgns.nspname AND ch.hypertable_id = htid WHERE NOT ch.dropped AND NOT ch.osm_chunk -- Checking for chunks which are not fully compressed and not frozen AND ch.status != status_fully_compressed AND ch.status & bit_frozen = 0 LOOP BEGIN IF chunk_rec.status = bit_compressed OR recompress_enabled IS TRUE THEN PERFORM @extschema@.compress_chunk(chunk_rec.oid); numchunks_compressed := numchunks_compressed + 1; END IF; EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS _message = MESSAGE_TEXT, _detail = PG_EXCEPTION_DETAIL, _sqlstate = RETURNED_SQLSTATE; RAISE WARNING 'converting chunk "%" to columnstore failed when recompress columnstore policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = _sqlstate; chunks_failure := chunks_failure + 1; END; COMMIT; -- went through recompression successfully now reindex indexes IF (chunk_rec.status & bit_compressed_partial = bit_compressed_partial) AND (reindex_enabled IS TRUE) THEN FOR idx_rec IN SELECT idx.schemaname, idx.indexname FROM pg_indexes idx JOIN _timescaledb_catalog.chunk ch ON ch.schema_name = idx.schemaname AND ch.table_name = idx.tablename WHERE idx.schemaname = chunk_rec.schema_name AND idx.tablename = chunk_rec.table_name AND ch.status = status_fully_compressed LOOP BEGIN EXECUTE format('REINDEX INDEX %I.%I;', idx_rec.schemaname, idx_rec.indexname); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS _message = MESSAGE_TEXT, _detail = PG_EXCEPTION_DETAIL, _sqlstate = RETURNED_SQLSTATE; RAISE WARNING 'reindexing index "%.%" for chunk "%" to columnstore failed when columnstore policy is executed', idx_rec.schemaname, idx_rec.indexname, chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = _sqlstate; chunks_failure := chunks_failure + 1; END; COMMIT; END LOOP; END IF; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; IF verbose_log THEN RAISE LOG 'job % completed processing chunk %.%', job_id, chunk_rec.schema_name, chunk_rec.table_name; END IF; IF maxchunks > 0 AND numchunks_compressed >= maxchunks THEN EXIT; END IF; END LOOP; IF chunks_failure > 0 THEN RAISE EXCEPTION 'columnstore policy failure' USING DETAIL = format('Failed to convert %L chunks to columnstore. Successfully converted %L chunks.', chunks_failure, numchunks_compressed), ERRCODE = 'data_exception'; END IF; END; $$ LANGUAGE PLPGSQL; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_compression(job_id INTEGER, config JSONB) AS $$ DECLARE dimtype REGTYPE; dimtypeinput REGPROC; compress_after TEXT; compress_created_before TEXT; lag_value TEXT; lag_bigint_value BIGINT; htid INTEGER; htoid REGCLASS; chunk_rec RECORD; verbose_log BOOL; maxchunks INTEGER := 0; numchunks INTEGER := 1; recompress_enabled BOOL; reindex_enabled BOOL; use_creation_time BOOL := FALSE; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; IF config IS NULL THEN RAISE EXCEPTION 'job % has null config', job_id; END IF; htid := jsonb_object_field_text(config, 'hypertable_id')::INTEGER; IF htid is NULL THEN RAISE EXCEPTION 'job % config must have hypertable_id', job_id; END IF; verbose_log := COALESCE(jsonb_object_field_text(config, 'verbose_log')::BOOLEAN, FALSE); maxchunks := COALESCE(jsonb_object_field_text(config, 'maxchunks_to_compress')::INTEGER, 0); recompress_enabled := COALESCE(jsonb_object_field_text(config, 'recompress')::BOOLEAN, TRUE); reindex_enabled := COALESCE(jsonb_object_field_text(config, 'reindex')::BOOLEAN, TRUE); -- find primary dimension type -- SELECT dim.column_type INTO dimtype FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.dimension dim ON ht.id = dim.hypertable_id WHERE ht.id = htid ORDER BY dim.id LIMIT 1; compress_after := jsonb_object_field_text(config, 'compress_after'); IF compress_after IS NULL THEN compress_created_before := jsonb_object_field_text(config, 'compress_created_before'); IF compress_created_before IS NULL THEN RAISE EXCEPTION 'job % config must have compress_after or compress_created_before', job_id; END IF; lag_value := compress_created_before; use_creation_time := true; dimtype := 'INTERVAL' ::regtype; ELSE lag_value := compress_after; END IF; -- execute the properly type casts for the lag value CASE dimtype WHEN 'TIMESTAMP'::regtype, 'TIMESTAMPTZ'::regtype, 'DATE'::regtype, 'INTERVAL' ::regtype THEN CALL _timescaledb_functions.policy_compression_execute(job_id, htid, lag_value::INTERVAL, maxchunks, verbose_log, recompress_enabled, reindex_enabled, use_creation_time); WHEN 'BIGINT'::regtype THEN CALL _timescaledb_functions.policy_compression_execute(job_id, htid, lag_value::BIGINT, maxchunks, verbose_log, recompress_enabled, reindex_enabled, use_creation_time); WHEN 'INTEGER'::regtype THEN CALL _timescaledb_functions.policy_compression_execute(job_id, htid, lag_value::INTEGER, maxchunks, verbose_log, recompress_enabled, reindex_enabled, use_creation_time); WHEN 'SMALLINT'::regtype THEN CALL _timescaledb_functions.policy_compression_execute(job_id, htid, lag_value::SMALLINT, maxchunks, verbose_log, recompress_enabled, reindex_enabled, use_creation_time); END CASE; COMMIT; END; $$ LANGUAGE PLPGSQL; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017166�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/cache.sql��������������������������������������������������������0000664�0000000�0000000�00000002041�15100345067�0020747�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains infrastructure for cache invalidation of TimescaleDB -- metadata caches kept in C. Please look at cache_invalidate.c for a -- description of how this works. CREATE TABLE _timescaledb_cache.cache_inval_hypertable(); -- For notifying the scheduler of changes to the bgw_job table. CREATE TABLE _timescaledb_cache.cache_inval_bgw_job(); -- This is pretty subtle. We create this dummy cache_inval_extension table -- solely for the purpose of getting a relcache invalidation event when it is -- deleted on DROP extension. It has no related triggers. When the table is -- invalidated, all backends will be notified and will know that they must -- invalidate all cached information, including catalog table and index OIDs, -- etc. CREATE TABLE _timescaledb_cache.cache_inval_extension(); GRANT SELECT ON ALL TABLES IN SCHEMA _timescaledb_cache TO PUBLIC; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/insert_data.sql��������������������������������������������������0000664�0000000�0000000�00000001344�15100345067�0022206�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --insert data for compression_algorithm -- insert into _timescaledb_catalog.compression_algorithm( id, version, name, description) values ( 0, 1, 'COMPRESSION_ALGORITHM_NONE', 'no compression'), ( 1, 1, 'COMPRESSION_ALGORITHM_ARRAY', 'array'), ( 2, 1, 'COMPRESSION_ALGORITHM_DICTIONARY', 'dictionary'), ( 3, 1, 'COMPRESSION_ALGORITHM_GORILLA', 'gorilla'), ( 4, 1, 'COMPRESSION_ALGORITHM_DELTADELTA', 'deltadelta'), ( 5, 1, 'COMPRESSION_ALGORITHM_BOOL', 'bool'), ( 6, 1, 'COMPRESSION_ALGORITHM_NULL', 'null'), ( 7, 1, 'COMPRESSION_ALGORITHM_UUID', 'uuid'); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/schemas.sql������������������������������������������������������0000664�0000000�0000000�00000001422�15100345067�0021331�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET LOCAL search_path TO pg_catalog, pg_temp; CREATE SCHEMA _timescaledb_catalog; CREATE SCHEMA _timescaledb_functions; CREATE SCHEMA _timescaledb_internal; CREATE SCHEMA _timescaledb_cache; CREATE SCHEMA _timescaledb_config; CREATE SCHEMA timescaledb_experimental; CREATE SCHEMA timescaledb_information; CREATE SCHEMA _timescaledb_debug; GRANT USAGE ON SCHEMA _timescaledb_cache, _timescaledb_catalog, _timescaledb_config, _timescaledb_debug, _timescaledb_functions, _timescaledb_internal, timescaledb_experimental, timescaledb_information TO PUBLIC; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/tables.sql�������������������������������������������������������0000664�0000000�0000000�00000066721�15100345067�0021175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --NOTICE: UPGRADE-SCRIPT-NEEDED contents in this file are not auto-upgraded. -- This file contains table definitions for various abstractions and data -- structures for representing hypertables and lower-level concepts. -- Hypertable -- ========== -- -- The hypertable is an abstraction that represents a table that is -- partitioned in N dimensions, where each dimension maps to a column -- in the table. A dimension can either be 'open' or 'closed', which -- reflects the scheme that divides the dimension's keyspace into -- "slices". -- -- Conceptually, a partition -- called a "chunk", is a hypercube in -- the N-dimensional space. A chunk stores a subset of the -- hypertable's tuples on disk in its own distinct table. The slices -- that span the chunk's hypercube each correspond to a constraint on -- the chunk's table, enabling constraint exclusion during queries on -- the hypertable's data. -- -- -- Open dimensions ------------------ -- An open dimension does on-demand slicing, creating a new slice -- based on a configurable interval whenever a tuple falls outside the -- existing slices. Open dimensions fit well with columns that are -- incrementally increasing, such as time-based ones. -- -- Closed dimensions -------------------- -- A closed dimension completely divides its keyspace into a -- configurable number of slices. The number of slices can be -- reconfigured, but the new partitioning only affects newly created -- chunks. -- The unique constraint is table_name +schema_name. The ordering is -- important as we want index access when we filter by table_name CREATE SEQUENCE _timescaledb_catalog.hypertable_id_seq MINVALUE 1; CREATE TABLE _timescaledb_catalog.hypertable ( id INTEGER NOT NULL DEFAULT nextval('_timescaledb_catalog.hypertable_id_seq'), schema_name name NOT NULL, table_name name NOT NULL, associated_schema_name name NOT NULL, associated_table_prefix name NOT NULL, num_dimensions smallint NOT NULL, chunk_sizing_func_schema name NOT NULL, chunk_sizing_func_name name NOT NULL, chunk_target_size bigint NOT NULL, -- size in bytes compression_state smallint NOT NULL DEFAULT 0, compressed_hypertable_id integer, status int NOT NULL DEFAULT 0, -- table constraints CONSTRAINT hypertable_pkey PRIMARY KEY (id), CONSTRAINT hypertable_associated_schema_name_associated_table_prefix_key UNIQUE (associated_schema_name, associated_table_prefix), CONSTRAINT hypertable_table_name_schema_name_key UNIQUE (table_name, schema_name), CONSTRAINT hypertable_schema_name_check CHECK (schema_name != '_timescaledb_catalog'), -- internal compressed hypertables have compression state = 2 CONSTRAINT hypertable_dim_compress_check CHECK (num_dimensions > 0 OR compression_state = 2), CONSTRAINT hypertable_chunk_target_size_check CHECK (chunk_target_size >= 0), CONSTRAINT hypertable_compress_check CHECK ( (compression_state = 0 OR compression_state = 1 ) OR (compression_state = 2 AND compressed_hypertable_id IS NULL)), CONSTRAINT hypertable_compressed_hypertable_id_fkey FOREIGN KEY (compressed_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ); ALTER SEQUENCE _timescaledb_catalog.hypertable_id_seq OWNED BY _timescaledb_catalog.hypertable.id; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_id_seq', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable', 'WHERE id >= 1'); -- The tablespace table maps tablespaces to hypertables. -- This allows spreading a hypertable's chunks across multiple disks. CREATE TABLE _timescaledb_catalog.tablespace ( id serial NOT NULL, hypertable_id int NOT NULL, tablespace_name name NOT NULL, -- table constraints CONSTRAINT tablespace_pkey PRIMARY KEY (id), CONSTRAINT tablespace_hypertable_id_tablespace_name_key UNIQUE (hypertable_id, tablespace_name), CONSTRAINT tablespace_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.tablespace', ''); -- A dimension represents an axis along which data is partitioned. CREATE TABLE _timescaledb_catalog.dimension ( id serial NOT NULL , hypertable_id integer NOT NULL, column_name name NOT NULL, column_type REGTYPE NOT NULL, aligned boolean NOT NULL, -- closed dimensions num_slices smallint NULL, partitioning_func_schema name NULL, partitioning_func name NULL, -- open dimensions (e.g., time) interval_length bigint NULL, -- compress interval is used by rollup procedure during compression -- in order to merge multiple chunks into a single one compress_interval_length bigint NULL, integer_now_func_schema name NULL, integer_now_func name NULL, -- table constraints CONSTRAINT dimension_pkey PRIMARY KEY (id), CONSTRAINT dimension_hypertable_id_column_name_key UNIQUE (hypertable_id, column_name), CONSTRAINT dimension_check CHECK ((partitioning_func_schema IS NULL AND partitioning_func IS NULL) OR (partitioning_func_schema IS NOT NULL AND partitioning_func IS NOT NULL)), CONSTRAINT dimension_check1 CHECK ((num_slices IS NULL AND interval_length IS NOT NULL) OR (num_slices IS NOT NULL AND interval_length IS NULL)), CONSTRAINT dimension_check2 CHECK ((integer_now_func_schema IS NULL AND integer_now_func IS NULL) OR (integer_now_func_schema IS NOT NULL AND integer_now_func IS NOT NULL)), CONSTRAINT dimension_interval_length_check CHECK (interval_length IS NULL OR interval_length > 0), CONSTRAINT dimension_compress_interval_length_check CHECK (compress_interval_length IS NULL OR compress_interval_length > 0), CONSTRAINT dimension_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.dimension', ''); SELECT pg_catalog.pg_extension_config_dump(pg_get_serial_sequence('_timescaledb_catalog.dimension', 'id'), ''); -- A dimension slice defines a keyspace range along a dimension -- axis. A chunk references a slice in each of its dimensions, forming -- a hypercube. CREATE TABLE _timescaledb_catalog.dimension_slice ( id serial NOT NULL, dimension_id integer NOT NULL, range_start bigint NOT NULL, range_end bigint NOT NULL, -- table constraints CONSTRAINT dimension_slice_pkey PRIMARY KEY (id), CONSTRAINT dimension_slice_dimension_id_range_start_range_end_key UNIQUE (dimension_id, range_start, range_end), CONSTRAINT dimension_slice_check CHECK (range_start <= range_end), CONSTRAINT dimension_slice_dimension_id_fkey FOREIGN KEY (dimension_id) REFERENCES _timescaledb_catalog.dimension (id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.dimension_slice', ''); SELECT pg_catalog.pg_extension_config_dump(pg_get_serial_sequence('_timescaledb_catalog.dimension_slice', 'id'), ''); -- A chunk is a partition (hypercube) in an N-dimensional -- hyperspace. Each chunk is associated with N constraints that define -- the chunk's hypercube. Tuples that fall within the chunk's -- hypercube are stored in the chunk's data table, as given by -- 'schema_name' and 'table_name'. CREATE SEQUENCE _timescaledb_catalog.chunk_id_seq MINVALUE 1; CREATE TABLE _timescaledb_catalog.chunk ( id integer NOT NULL DEFAULT nextval('_timescaledb_catalog.chunk_id_seq'), hypertable_id int NOT NULL, schema_name name NOT NULL, table_name name NOT NULL, compressed_chunk_id integer , dropped boolean NOT NULL DEFAULT FALSE, status integer NOT NULL DEFAULT 0, osm_chunk boolean NOT NULL DEFAULT FALSE, creation_time timestamptz NOT NULL, -- table constraints CONSTRAINT chunk_pkey PRIMARY KEY (id), CONSTRAINT chunk_schema_name_table_name_key UNIQUE (schema_name, table_name), CONSTRAINT chunk_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk (id), CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ); ALTER SEQUENCE _timescaledb_catalog.chunk_id_seq OWNED BY _timescaledb_catalog.chunk.id; CREATE INDEX chunk_hypertable_id_idx ON _timescaledb_catalog.chunk (hypertable_id); CREATE INDEX chunk_compressed_chunk_id_idx ON _timescaledb_catalog.chunk (compressed_chunk_id); --we could use a partial index (where osm_chunk is true). However, the catalog code --does not work with partial/functional indexes. So we instead have a full index here. --Another option would be to use the status field to identify a OSM chunk. However bit --operations only work on varbit datatype and not integer datatype. CREATE INDEX chunk_osm_chunk_idx ON _timescaledb_catalog.chunk (osm_chunk, hypertable_id); CREATE INDEX chunk_hypertable_id_creation_time_idx ON _timescaledb_catalog.chunk(hypertable_id, creation_time); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_id_seq', ''); -- A chunk constraint maps a dimension slice to a chunk. Each -- constraint associated with a chunk will also be a table constraint -- on the chunk's data table. CREATE TABLE _timescaledb_catalog.chunk_constraint ( chunk_id integer NOT NULL, dimension_slice_id integer NULL, constraint_name name NOT NULL, hypertable_constraint_name name NULL, -- table constraints CONSTRAINT chunk_constraint_chunk_id_constraint_name_key UNIQUE (chunk_id, constraint_name), CONSTRAINT chunk_constraint_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id), CONSTRAINT chunk_constraint_dimension_slice_id_fkey FOREIGN KEY (dimension_slice_id) REFERENCES _timescaledb_catalog.dimension_slice (id) ); CREATE INDEX chunk_constraint_dimension_slice_id_idx ON _timescaledb_catalog.chunk_constraint (dimension_slice_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_constraint', ''); CREATE SEQUENCE _timescaledb_catalog.chunk_constraint_name; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_constraint_name', ''); -- Track statistics for columns of chunks from a hypertable. -- Currently, we track the min/max range for a given column across chunks. -- More statistics (like bloom filters) can be added in the future. -- -- A "special" entry for a column with invalid chunk_id, PG_INT64_MAX, -- PG_INT64_MIN indicates that min/max ranges could be computed for this column -- for chunks. -- -- The ranges can overlap across chunks. The values could be out-of-date if -- modifications/changes occur in the corresponding chunk and such entries -- should be marked as "invalid" to ensure that the chunk is in -- appropriate state to be able to use these values. Thus these entries -- are different from dimension_slice which is used for tracking partitioning -- column ranges which have different characteristics. -- -- Currently this catalog supports datatypes like INT, SERIAL, BIGSERIAL, -- DATE, TIMESTAMP etc. by storing the ranges in bigint columns. In the -- future, we could support additional datatypes (which support btree style -- >, <, = comparators) by storing their textual representation. -- CREATE TABLE _timescaledb_catalog.chunk_column_stats ( id serial NOT NULL, hypertable_id integer NOT NULL, chunk_id integer NULL, column_name name NOT NULL, range_start bigint NOT NULL, range_end bigint NOT NULL, valid boolean NOT NULL, -- table constraints CONSTRAINT chunk_column_stats_pkey PRIMARY KEY (id), CONSTRAINT chunk_column_stats_ht_id_chunk_id_colname_key UNIQUE (hypertable_id, chunk_id, column_name), CONSTRAINT chunk_column_stats_range_check CHECK (range_start <= range_end), CONSTRAINT chunk_column_stats_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id), CONSTRAINT chunk_column_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_column_stats', ''); SELECT pg_catalog.pg_extension_config_dump(pg_get_serial_sequence('_timescaledb_catalog.chunk_column_stats', 'id'), ''); -- Default jobs are given the id space [1,1000). User-installed jobs and any jobs created inside tests -- are given the id space [1000, INT_MAX). That way, we do not pg_dump jobs that are always default-installed -- inside other .sql scripts. This avoids insertion conflicts during pg_restore. CREATE SEQUENCE _timescaledb_config.bgw_job_id_seq MINVALUE 1000; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job_id_seq', ''); -- We put columns that can be null or have variable length -- last. This allow us to read the important fields above in the -- scheduler without materializing these fields below, which the -- scheduler does not neeed. CREATE TABLE _timescaledb_config.bgw_job ( id integer NOT NULL DEFAULT nextval('_timescaledb_config.bgw_job_id_seq'), application_name name NOT NULL, schedule_interval interval NOT NULL, max_runtime interval NOT NULL, max_retries integer NOT NULL, retry_period interval NOT NULL, proc_schema name NOT NULL, proc_name name NOT NULL, owner regrole NOT NULL DEFAULT pg_catalog.quote_ident(current_role)::regrole, scheduled bool NOT NULL DEFAULT TRUE, fixed_schedule bool not null default true, initial_start timestamptz, hypertable_id integer, config jsonb, check_schema name, check_name name, timezone text, -- table constraints CONSTRAINT bgw_job_pkey PRIMARY KEY (id), CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq OWNED BY _timescaledb_config.bgw_job.id; CREATE INDEX bgw_job_proc_hypertable_id_idx ON _timescaledb_config.bgw_job (proc_schema, proc_name, hypertable_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job', 'WHERE id >= 1000'); CREATE TABLE _timescaledb_internal.bgw_job_stat ( job_id integer NOT NULL, last_start timestamptz NOT NULL DEFAULT NOW(), last_finish timestamptz NOT NULL, next_start timestamptz NOT NULL, last_successful_finish timestamptz NOT NULL, last_run_success bool NOT NULL, total_runs bigint NOT NULL, total_duration interval NOT NULL, total_duration_failures interval NOT NULL, total_successes bigint NOT NULL, total_failures bigint NOT NULL, total_crashes bigint NOT NULL, consecutive_failures int NOT NULL, consecutive_crashes int NOT NULL, flags int NOT NULL DEFAULT 0, -- table constraints CONSTRAINT bgw_job_stat_pkey PRIMARY KEY (job_id), CONSTRAINT bgw_job_stat_job_id_fkey FOREIGN KEY (job_id) REFERENCES _timescaledb_config.bgw_job (id) ON DELETE CASCADE ); CREATE SEQUENCE _timescaledb_internal.bgw_job_stat_history_id_seq MINVALUE 1; CREATE TABLE _timescaledb_internal.bgw_job_stat_history ( id BIGINT NOT NULL DEFAULT nextval('_timescaledb_internal.bgw_job_stat_history_id_seq'), job_id INTEGER NOT NULL, pid INTEGER, execution_start TIMESTAMPTZ NOT NULL DEFAULT NOW(), execution_finish TIMESTAMPTZ, succeeded boolean, data jsonb, -- table constraints CONSTRAINT bgw_job_stat_history_pkey PRIMARY KEY (id) ); ALTER SEQUENCE _timescaledb_internal.bgw_job_stat_history_id_seq OWNED BY _timescaledb_internal.bgw_job_stat_history.id; CREATE INDEX bgw_job_stat_history_job_id_idx ON _timescaledb_internal.bgw_job_stat_history (job_id); --The job_stat table is not dumped by pg_dump on purpose because --the statistics probably aren't very meaningful across instances. -- Now we define a special stats table for each job/chunk pair. This will be used by the scheduler -- to determine whether to run a specific job on a specific chunk. CREATE TABLE _timescaledb_internal.bgw_policy_chunk_stats ( job_id integer NOT NULL, chunk_id integer NOT NULL, num_times_job_run integer, last_time_job_run timestamptz, -- table constraints CONSTRAINT bgw_policy_chunk_stats_job_id_chunk_id_key UNIQUE (job_id, chunk_id), CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE, CONSTRAINT bgw_policy_chunk_stats_job_id_fkey FOREIGN KEY (job_id) REFERENCES _timescaledb_config.bgw_job (id) ON DELETE CASCADE ); CREATE TABLE _timescaledb_catalog.metadata ( key NAME NOT NULL, value text NOT NULL, include_in_telemetry boolean NOT NULL, -- table constraints CONSTRAINT metadata_pkey PRIMARY KEY (key) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.metadata', $$ WHERE key <> 'uuid' $$); -- Log with events that will be sent out with the telemetry. The log -- will be flushed after it has been sent out. We do not save it to -- backups since it should not contain important data. CREATE TABLE _timescaledb_catalog.telemetry_event ( created timestamptz NOT NULL DEFAULT current_timestamp, tag name NOT NULL, body jsonb NOT NULL ); CREATE TABLE _timescaledb_catalog.continuous_agg ( mat_hypertable_id integer NOT NULL, raw_hypertable_id integer NOT NULL, parent_mat_hypertable_id integer, user_view_schema name NOT NULL, user_view_name name NOT NULL, partial_view_schema name NOT NULL, partial_view_name name NOT NULL, direct_view_schema name NOT NULL, direct_view_name name NOT NULL, materialized_only bool NOT NULL DEFAULT FALSE, finalized bool NOT NULL DEFAULT TRUE, -- table constraints CONSTRAINT continuous_agg_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_agg_partial_view_schema_partial_view_name_key UNIQUE (partial_view_schema, partial_view_name), CONSTRAINT continuous_agg_user_view_schema_user_view_name_key UNIQUE (user_view_schema, user_view_name), CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_parent_mat_hypertable_id_fkey FOREIGN KEY (parent_mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); CREATE INDEX continuous_agg_raw_hypertable_id_idx ON _timescaledb_catalog.continuous_agg (raw_hypertable_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg', ''); -- See the comments for ContinuousAggsBucketFunction structure. CREATE TABLE _timescaledb_catalog.continuous_aggs_bucket_function ( mat_hypertable_id integer NOT NULL, -- The bucket function bucket_func text NOT NULL, -- `bucket_width` argument of the function, e.g. "1 month" bucket_width text NOT NULL, -- optional `origin` argument of the function provided by the user bucket_origin text, -- optional `offset` argument of the function provided by the user bucket_offset text, -- optional `timezone` argument of the function provided by the user bucket_timezone text, -- fixed or variable sized bucket bucket_fixed_width bool NOT NULL, -- table constraints CONSTRAINT continuous_aggs_bucket_function_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_aggs_bucket_function_func_check CHECK (pg_catalog.to_regprocedure(bucket_func) IS DISTINCT FROM 0) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_bucket_function', ''); CREATE TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ( hypertable_id integer NOT NULL, watermark bigint NOT NULL, -- table constraints CONSTRAINT continuous_aggs_invalidation_threshold_pkey PRIMARY KEY (hypertable_id), CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_invalidation_threshold', ''); CREATE TABLE _timescaledb_catalog.continuous_aggs_watermark ( mat_hypertable_id integer NOT NULL, watermark bigint NOT NULL, -- table constraints CONSTRAINT continuous_aggs_watermark_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_watermark_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_watermark', ''); -- this does not have an FK on the materialization table since INSERTs to this -- table are performance critical CREATE TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log ( hypertable_id integer NOT NULL, lowest_modified_value bigint NOT NULL, greatest_modified_value bigint NOT NULL ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_hypertable_invalidation_log', ''); CREATE INDEX continuous_aggs_hypertable_invalidation_log_idx ON _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log (hypertable_id, lowest_modified_value ASC); -- per cagg copy of invalidation log CREATE TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ( materialization_id integer, lowest_modified_value bigint NOT NULL, greatest_modified_value bigint NOT NULL, -- table constraints CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey FOREIGN KEY (materialization_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_materialization_invalidation_log', ''); CREATE INDEX continuous_aggs_materialization_invalidation_log_idx ON _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value ASC); -- cagg materialization ranges CREATE TABLE _timescaledb_catalog.continuous_aggs_materialization_ranges ( materialization_id integer, lowest_modified_value bigint NOT NULL, greatest_modified_value bigint NOT NULL, -- table constraints CONSTRAINT continuous_aggs_materialization_ranges_materialization_id_fkey FOREIGN KEY (materialization_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_materialization_ranges', ''); CREATE INDEX continuous_aggs_materialization_ranges_idx ON _timescaledb_catalog.continuous_aggs_materialization_ranges (materialization_id, lowest_modified_value ASC); /* the source of this data is the enum from the source code that lists * the algorithms. This table is NOT dumped. */ CREATE TABLE _timescaledb_catalog.compression_algorithm ( id smallint NOT NULL, version smallint NOT NULL, name name NOT NULL, description text, -- table constraints CONSTRAINT compression_algorithm_pkey PRIMARY KEY (id) ); CREATE TABLE _timescaledb_catalog.compression_settings ( relid regclass NOT NULL, compress_relid regclass NULL, segmentby text[], orderby text[], orderby_desc bool[], orderby_nullsfirst bool[], index jsonb, CONSTRAINT compression_settings_pkey PRIMARY KEY (relid), CONSTRAINT compression_settings_check_segmentby CHECK (array_ndims(segmentby) = 1), CONSTRAINT compression_settings_check_orderby_null CHECK ((orderby IS NULL AND orderby_desc IS NULL AND orderby_nullsfirst IS NULL) OR (orderby IS NOT NULL AND orderby_desc IS NOT NULL AND orderby_nullsfirst IS NOT NULL)), CONSTRAINT compression_settings_check_orderby_cardinality CHECK (array_ndims(orderby) = 1 AND array_ndims(orderby_desc) = 1 AND array_ndims(orderby_nullsfirst) = 1 AND cardinality(orderby) = cardinality(orderby_desc) AND cardinality(orderby) = cardinality(orderby_nullsfirst)) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_settings', ''); CREATE INDEX compression_settings_compress_relid_idx ON _timescaledb_catalog.compression_settings (compress_relid); CREATE TABLE _timescaledb_catalog.compression_chunk_size ( chunk_id integer NOT NULL, compressed_chunk_id integer NOT NULL, uncompressed_heap_size bigint NOT NULL, uncompressed_toast_size bigint NOT NULL, uncompressed_index_size bigint NOT NULL, compressed_heap_size bigint NOT NULL, compressed_toast_size bigint NOT NULL, compressed_index_size bigint NOT NULL, numrows_pre_compression bigint, numrows_post_compression bigint, numrows_frozen_immediately bigint, -- table constraints CONSTRAINT compression_chunk_size_pkey PRIMARY KEY (chunk_id), CONSTRAINT compression_chunk_size_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE, CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE ); -- Create index on the compressed_chunk_id to speed up maintainance -- operations during upgrades. This is mostly relevant for very large -- number of chunks. CREATE INDEX compression_chunk_size_idx ON _timescaledb_catalog.compression_chunk_size (compressed_chunk_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_chunk_size', ''); CREATE TABLE _timescaledb_catalog.continuous_agg_migrate_plan ( mat_hypertable_id integer NOT NULL, start_ts TIMESTAMPTZ NOT NULL DEFAULT pg_catalog.now(), end_ts TIMESTAMPTZ, user_view_definition TEXT, -- table constraints CONSTRAINT continuous_agg_migrate_plan_pkey PRIMARY KEY (mat_hypertable_id) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg_migrate_plan', ''); CREATE TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step ( mat_hypertable_id integer NOT NULL, step_id serial NOT NULL, status TEXT NOT NULL DEFAULT 'NOT STARTED', -- NOT STARTED, STARTED, FINISHED, CANCELED start_ts TIMESTAMPTZ, end_ts TIMESTAMPTZ, type TEXT NOT NULL, config JSONB, -- table constraints CONSTRAINT continuous_agg_migrate_plan_step_pkey PRIMARY KEY (mat_hypertable_id, step_id), CONSTRAINT continuous_agg_migrate_plan_step_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg_migrate_plan (mat_hypertable_id) ON DELETE CASCADE, CONSTRAINT continuous_agg_migrate_plan_step_check CHECK (start_ts <= end_ts), CONSTRAINT continuous_agg_migrate_plan_step_check2 CHECK (type IN ('CREATE NEW CAGG', 'DISABLE POLICIES', 'COPY POLICIES', 'ENABLE POLICIES', 'SAVE WATERMARK', 'REFRESH NEW CAGG', 'COPY DATA', 'OVERRIDE CAGG', 'DROP OLD CAGG')) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg_migrate_plan_step', ''); SELECT pg_catalog.pg_extension_config_dump(pg_get_serial_sequence('_timescaledb_catalog.continuous_agg_migrate_plan_step', 'step_id'), ''); -- Set table permissions -- We need to grant SELECT to PUBLIC for all tables even those not -- marked as being dumped because pg_dump will try to access all -- tables initially to detect inheritance chains and then decide -- which objects actually need to be dumped. GRANT SELECT ON ALL TABLES IN SCHEMA _timescaledb_catalog TO PUBLIC; GRANT SELECT ON ALL TABLES IN SCHEMA _timescaledb_config TO PUBLIC; GRANT SELECT ON ALL TABLES IN SCHEMA _timescaledb_internal TO PUBLIC; GRANT SELECT ON ALL SEQUENCES IN SCHEMA _timescaledb_catalog TO PUBLIC; GRANT SELECT ON ALL SEQUENCES IN SCHEMA _timescaledb_config TO PUBLIC; GRANT SELECT ON ALL SEQUENCES IN SCHEMA _timescaledb_internal TO PUBLIC; -- We want to restrict access to the bgw_job_stat_history to only work through -- the job_errors and job_history views. REVOKE ALL ON _timescaledb_internal.bgw_job_stat_history FROM PUBLIC; �����������������������������������������������timescaledb-2.23.0/sql/pre_install/types.functions.sql����������������������������������������������0000664�0000000�0000000�00000006137�15100345067�0023071�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Functions have to be run in 2 places: -- 1) In pre-install between types.pre.sql and types.post.sql to set up the types. -- 2) On every update to make sure the function points to the correct versioned.so -- PostgreSQL composite types do not support constraint checks. That is why any table having a ts_interval column must use the following -- function for constraint validation. -- This function needs to be defined before executing pre_install/tables.sql because it is used as -- validation constraint for columns of type ts_interval. --the textual input/output is simply base64 encoding of the binary representation CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_data_in(CSTRING) RETURNS _timescaledb_internal.compressed_data AS '@MODULE_PATHNAME@', 'ts_compressed_data_in' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_data_out(_timescaledb_internal.compressed_data) RETURNS CSTRING AS '@MODULE_PATHNAME@', 'ts_compressed_data_out' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_data_send(_timescaledb_internal.compressed_data) RETURNS BYTEA AS '@MODULE_PATHNAME@', 'ts_compressed_data_send' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_data_recv(internal) RETURNS _timescaledb_internal.compressed_data AS '@MODULE_PATHNAME@', 'ts_compressed_data_recv' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_data_info(_timescaledb_internal.compressed_data) RETURNS TABLE (algorithm name, has_nulls bool) LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_compressed_data_info'; CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_data_has_nulls(_timescaledb_internal.compressed_data) RETURNS BOOL LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_compressed_data_has_nulls'; CREATE OR REPLACE FUNCTION _timescaledb_functions.dimension_info_in(cstring) RETURNS _timescaledb_internal.dimension_info LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_dimension_info_in'; CREATE OR REPLACE FUNCTION _timescaledb_functions.dimension_info_out(_timescaledb_internal.dimension_info) RETURNS cstring LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_dimension_info_out'; -- Type for bloom filters used by the sparse indexes on compressed hypertables. CREATE OR REPLACE FUNCTION _timescaledb_functions.bloom1in(cstring) RETURNS _timescaledb_internal.bloom1 AS 'byteain' LANGUAGE INTERNAL STRICT IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.bloom1out(_timescaledb_internal.bloom1) RETURNS cstring AS 'byteaout' LANGUAGE INTERNAL STRICT IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.invalidation_plugin_name() RETURNS text LANGUAGE C STRICT PARALLEL SAFE AS '@MODULE_PATHNAME@', 'ts_invalidation_plugin_name'; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/types.post.sql���������������������������������������������������0000664�0000000�0000000�00000002205�15100345067�0022036�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- The general compressed_data type; -- CREATE TYPE _timescaledb_internal.compressed_data ( INTERNALLENGTH = VARIABLE, STORAGE = EXTERNAL, ALIGNMENT = double, --needed for alignment in ARRAY type compression INPUT = _timescaledb_functions.compressed_data_in, OUTPUT = _timescaledb_functions.compressed_data_out, RECEIVE = _timescaledb_functions.compressed_data_recv, SEND = _timescaledb_functions.compressed_data_send ); -- Dimension type used in create_hypertable, add_dimension, etc. It is -- deliberately an opaque type. CREATE TYPE _timescaledb_internal.dimension_info ( INPUT = _timescaledb_functions.dimension_info_in, OUTPUT = _timescaledb_functions.dimension_info_out, INTERNALLENGTH = VARIABLE ); -- Type for bloom filters used by the sparse indexes on compressed hypertables. CREATE TYPE _timescaledb_internal.bloom1 ( INPUT = _timescaledb_functions.bloom1in, OUTPUT = _timescaledb_functions.bloom1out, LIKE = bytea ); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/pre_install/types.pre.sql����������������������������������������������������0000664�0000000�0000000�00000000770�15100345067�0021644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- The general compressed_data type; -- CREATE TYPE _timescaledb_internal.compressed_data; --placeholder to allow creation of functions below CREATE TYPE _timescaledb_internal.dimension_info; -- Type for bloom filters used by the sparse indexes on compressed hypertables. CREATE TYPE _timescaledb_internal.bloom1; ��������timescaledb-2.23.0/sql/restoring.sql����������������������������������������������������������������0000664�0000000�0000000�00000003016�15100345067�0017407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION @extschema@.timescaledb_pre_restore() RETURNS BOOL AS $BODY$ DECLARE db text; BEGIN SELECT current_database() INTO db; EXECUTE format($$ALTER DATABASE %I SET timescaledb.restoring ='on'$$, db); SET SESSION timescaledb.restoring = 'on'; PERFORM _timescaledb_functions.stop_background_workers(); RETURN true; END $BODY$ LANGUAGE PLPGSQL SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION @extschema@.timescaledb_post_restore() RETURNS BOOL AS $BODY$ DECLARE db text; catalog_version text; BEGIN SELECT m.value INTO catalog_version FROM pg_extension x JOIN _timescaledb_catalog.metadata m ON m.key='timescaledb_version' WHERE x.extname='timescaledb' AND x.extversion <> m.value; -- check that a loaded dump is compatible with the currently running code IF FOUND THEN RAISE EXCEPTION 'catalog version mismatch, expected "%" seen "%"', '@PROJECT_VERSION_MOD@', catalog_version; END IF; SELECT current_database() INTO db; EXECUTE format($$ALTER DATABASE %I RESET timescaledb.restoring $$, db); -- we cannot use reset here because the reset_val might not be off SET timescaledb.restoring TO off; PERFORM _timescaledb_functions.restart_background_workers(); RETURN true; END $BODY$ LANGUAGE PLPGSQL SET search_path TO pg_catalog, pg_temp; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/size_utils.sql���������������������������������������������������������������0000664�0000000�0000000�00000056642�15100345067�0017602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains utility functions to get the relation size -- of hypertables, chunks, and indexes on hypertables. CREATE OR REPLACE FUNCTION _timescaledb_functions.index_matches(index1 regclass, index2 regclass) RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_index_matches' LANGUAGE C STRICT IMMUTABLE; CREATE OR REPLACE FUNCTION _timescaledb_functions.relation_size(relation REGCLASS) RETURNS TABLE (total_size BIGINT, heap_size BIGINT, index_size BIGINT, toast_size BIGINT) AS '@MODULE_PATHNAME@', 'ts_relation_size' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION _timescaledb_functions.relation_approximate_size(relation REGCLASS) RETURNS TABLE (total_size BIGINT, heap_size BIGINT, index_size BIGINT, toast_size BIGINT) AS '@MODULE_PATHNAME@', 'ts_relation_approximate_size' LANGUAGE C STRICT VOLATILE; CREATE OR REPLACE VIEW _timescaledb_internal.hypertable_chunk_local_size AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, h.id AS hypertable_id, c.id AS chunk_id, c.schema_name AS chunk_schema, c.table_name AS chunk_name, COALESCE((relsize).total_size, 0) AS total_bytes, COALESCE((relsize).heap_size, 0) AS heap_bytes, COALESCE((relsize).index_size, 0) AS index_bytes, COALESCE((relsize).toast_size, 0) AS toast_bytes, COALESCE((relcompsize).total_size, 0) AS compressed_total_size, COALESCE((relcompsize).heap_size, 0) AS compressed_heap_size, COALESCE((relcompsize).index_size, 0) AS compressed_index_size, COALESCE((relcompsize).toast_size, 0) AS compressed_toast_size FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id AND c.dropped IS FALSE JOIN pg_class cl ON cl.relname = c.table_name AND cl.relkind = 'r' JOIN pg_namespace n ON n.oid = cl.relnamespace AND n.nspname = c.schema_name JOIN LATERAL _timescaledb_functions.relation_size(cl.oid) AS relsize ON TRUE LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id LEFT JOIN LATERAL _timescaledb_functions.relation_size( CASE WHEN comp.schema_name IS NOT NULL AND comp.table_name IS NOT NULL THEN format('%I.%I', comp.schema_name, comp.table_name)::regclass ELSE NULL::regclass END ) AS relcompsize ON TRUE; GRANT SELECT ON _timescaledb_internal.hypertable_chunk_local_size TO PUBLIC; CREATE OR REPLACE FUNCTION _timescaledb_functions.hypertable_local_size( schema_name_in name, table_name_in name) RETURNS TABLE ( table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT) LANGUAGE SQL VOLATILE STRICT AS $BODY$ /* get the main hypertable id and sizes */ WITH _hypertable_sizes AS ( SELECT id, COALESCE((relsize).total_size, 0) AS total_bytes, COALESCE((relsize).heap_size, 0) AS heap_bytes, COALESCE((relsize).index_size, 0) AS index_bytes, COALESCE((relsize).toast_size, 0) AS toast_bytes, 0::BIGINT AS compressed_total_size, 0::BIGINT AS compressed_index_size, 0::BIGINT AS compressed_toast_size, 0::BIGINT AS compressed_heap_size FROM _timescaledb_catalog.hypertable ht JOIN pg_class c ON relname = ht.table_name AND c.relkind = 'r' JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = ht.schema_name JOIN LATERAL _timescaledb_functions.relation_size(c.oid) AS relsize ON TRUE WHERE schema_name = schema_name_in AND table_name = table_name_in ), /* calculate the size of the hypertable chunks */ _chunk_sizes AS ( SELECT chunk_id, COALESCE(ch.total_bytes, 0) AS total_bytes, COALESCE(ch.heap_bytes, 0) AS heap_bytes, COALESCE(ch.index_bytes, 0) AS index_bytes, COALESCE(ch.toast_bytes, 0) AS toast_bytes, COALESCE(ch.compressed_total_size, 0) AS compressed_total_size, COALESCE(ch.compressed_index_size, 0) AS compressed_index_size, COALESCE(ch.compressed_toast_size, 0) AS compressed_toast_size, COALESCE(ch.compressed_heap_size, 0) AS compressed_heap_size FROM _timescaledb_internal.hypertable_chunk_local_size ch JOIN _hypertable_sizes ht ON ht.id = ch.hypertable_id WHERE hypertable_schema = schema_name_in AND hypertable_name = table_name_in ) /* calculate the SUM of the hypertable and chunk sizes */ SELECT (SUM(heap_bytes) + SUM(compressed_heap_size))::BIGINT AS heap_bytes, (SUM(index_bytes) + SUM(compressed_index_size))::BIGINT AS index_bytes, (SUM(toast_bytes) + SUM(compressed_toast_size))::BIGINT AS toast_bytes, (SUM(total_bytes) + SUM(compressed_total_size))::BIGINT AS total_bytes FROM (SELECT * FROM _hypertable_sizes UNION ALL SELECT * FROM _chunk_sizes) AS sizes; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Get relation size of hypertable -- like pg_relation_size(hypertable) -- -- hypertable - hypertable to get size of -- -- Returns: -- table_bytes - Disk space used by hypertable (like pg_relation_size(hypertable)) -- index_bytes - Disk space used by indexes -- toast_bytes - Disk space of toast tables -- total_bytes - Total disk space used by the specified table, including all indexes and TOAST data CREATE OR REPLACE FUNCTION @extschema@.hypertable_detailed_size( hypertable REGCLASS) RETURNS TABLE (table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT, node_name NAME) LANGUAGE PLPGSQL VOLATILE STRICT AS $BODY$ DECLARE table_name NAME = NULL; schema_name NAME = NULL; BEGIN SELECT relname, nspname INTO table_name, schema_name FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INNER JOIN _timescaledb_catalog.hypertable ht ON (ht.schema_name = n.nspname AND ht.table_name = c.relname) WHERE c.OID = hypertable; IF table_name IS NULL THEN SELECT h.schema_name, h.table_name INTO schema_name, table_name FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INNER JOIN _timescaledb_catalog.continuous_agg a ON (a.user_view_schema = n.nspname AND a.user_view_name = c.relname) INNER JOIN _timescaledb_catalog.hypertable h ON h.id = a.mat_hypertable_id WHERE c.OID = hypertable; IF table_name IS NULL THEN RETURN; END IF; END IF; RETURN QUERY SELECT *, NULL::name FROM _timescaledb_functions.hypertable_local_size(schema_name, table_name); END; $BODY$ SET search_path TO pg_catalog, pg_temp; --- returns total-bytes for a hypertable (includes table + index) CREATE OR REPLACE FUNCTION @extschema@.hypertable_size( hypertable REGCLASS) RETURNS BIGINT LANGUAGE SQL VOLATILE STRICT AS $BODY$ SELECT total_bytes::bigint FROM @extschema@.hypertable_detailed_size(hypertable); $BODY$ SET search_path TO pg_catalog, pg_temp; -- Get approximate relation size of hypertable -- -- hypertable - hypertable to get approximate size of -- -- Returns: -- table_bytes - Approximate disk space used by hypertable -- index_bytes - Approximate disk space used by indexes -- toast_bytes - Approximate disk space of toast tables -- total_bytes - Total approximate disk space used by the specified table, including all indexes and TOAST data CREATE OR REPLACE FUNCTION @extschema@.hypertable_approximate_detailed_size(relation REGCLASS) RETURNS TABLE (table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT) AS '@MODULE_PATHNAME@', 'ts_hypertable_approximate_size' LANGUAGE C VOLATILE; --- returns approximate total-bytes for a hypertable (includes table + index) CREATE OR REPLACE FUNCTION @extschema@.hypertable_approximate_size( hypertable REGCLASS) RETURNS BIGINT LANGUAGE SQL VOLATILE STRICT AS $BODY$ SELECT sum(total_bytes)::bigint FROM @extschema@.hypertable_approximate_detailed_size(hypertable); $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.chunks_local_size( schema_name_in name, table_name_in name) RETURNS TABLE ( chunk_id integer, chunk_schema NAME, chunk_name NAME, table_bytes bigint, index_bytes bigint, toast_bytes bigint, total_bytes bigint) LANGUAGE SQL VOLATILE STRICT AS $BODY$ SELECT ch.chunk_id, ch.chunk_schema, ch.chunk_name, (ch.total_bytes - COALESCE( ch.index_bytes , 0 ) - COALESCE( ch.toast_bytes, 0 ) + COALESCE( ch.compressed_heap_size , 0 ))::bigint as heap_bytes, (COALESCE( ch.index_bytes, 0 ) + COALESCE( ch.compressed_index_size , 0) )::bigint as index_bytes, (COALESCE( ch.toast_bytes, 0 ) + COALESCE( ch.compressed_toast_size, 0 ))::bigint as toast_bytes, (ch.total_bytes + COALESCE( ch.compressed_total_size, 0 ))::bigint as total_bytes FROM _timescaledb_internal.hypertable_chunk_local_size ch WHERE ch.hypertable_schema = schema_name_in AND ch.hypertable_name = table_name_in; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Get relation size of the chunks of an hypertable -- hypertable - hypertable to get size of -- -- Returns: -- chunk_schema - schema name for chunk -- chunk_name - chunk table name -- table_bytes - Disk space used by chunk table -- index_bytes - Disk space used by indexes -- toast_bytes - Disk space of toast tables -- total_bytes - Disk space used in total -- node_name - node on which chunk lives if this is -- a distributed hypertable. CREATE OR REPLACE FUNCTION @extschema@.chunks_detailed_size( hypertable REGCLASS ) RETURNS TABLE ( chunk_schema NAME, chunk_name NAME, table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT, node_name NAME) LANGUAGE PLPGSQL VOLATILE STRICT AS $BODY$ DECLARE table_name NAME; schema_name NAME; BEGIN SELECT relname, nspname INTO table_name, schema_name FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INNER JOIN _timescaledb_catalog.hypertable ht ON (ht.schema_name = n.nspname AND ht.table_name = c.relname) WHERE c.OID = hypertable; IF table_name IS NULL THEN SELECT h.schema_name, h.table_name INTO schema_name, table_name FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INNER JOIN _timescaledb_catalog.continuous_agg a ON (a.user_view_schema = n.nspname AND a.user_view_name = c.relname) INNER JOIN _timescaledb_catalog.hypertable h ON h.id = a.mat_hypertable_id WHERE c.OID = hypertable; IF table_name IS NULL THEN RETURN; END IF; END IF; RETURN QUERY SELECT chl.chunk_schema, chl.chunk_name, chl.table_bytes, chl.index_bytes, chl.toast_bytes, chl.total_bytes, NULL::NAME FROM _timescaledb_functions.chunks_local_size(schema_name, table_name) chl; END; $BODY$ SET search_path TO pg_catalog, pg_temp; ---------- end of detailed size functions ------ CREATE OR REPLACE FUNCTION _timescaledb_functions.range_value_to_pretty( time_value BIGINT, column_type REGTYPE ) RETURNS TEXT LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE BEGIN IF NOT (time_value > (-9223372036854775808)::bigint AND time_value < 9223372036854775807::bigint) THEN RETURN ''; END IF; IF time_value IS NULL THEN RETURN format('%L', NULL); END IF; CASE column_type WHEN 'BIGINT'::regtype, 'INTEGER'::regtype, 'SMALLINT'::regtype THEN RETURN format('%L', time_value); -- scale determined by user. WHEN 'TIMESTAMP'::regtype, 'TIMESTAMPTZ'::regtype THEN -- assume time_value is in microsec RETURN format('%1$L', _timescaledb_functions.to_timestamp(time_value)); -- microseconds WHEN 'DATE'::regtype THEN RETURN format('%L', timezone('UTC',_timescaledb_functions.to_timestamp(time_value))::date); ELSE RETURN time_value; END CASE; END $BODY$ SET search_path TO pg_catalog, pg_temp; -- Convenience function to return approximate row count -- -- relation - table or hypertable to get approximate row count for -- -- Returns: -- Estimated number of rows according to catalog tables CREATE OR REPLACE FUNCTION @extschema@.approximate_row_count(relation REGCLASS) RETURNS BIGINT LANGUAGE PLPGSQL VOLATILE STRICT AS $BODY$ DECLARE v_mat_ht REGCLASS = NULL; v_name NAME = NULL; v_schema NAME = NULL; v_hypertable_id INTEGER; BEGIN -- Check if input relation is continuous aggregate view then -- get the corresponding materialized hypertable and schema name SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass INTO v_mat_ht FROM pg_class c JOIN pg_namespace n ON (n.OID = c.relnamespace) JOIN _timescaledb_catalog.continuous_agg a ON (a.user_view_schema = n.nspname AND a.user_view_name = c.relname) JOIN _timescaledb_catalog.hypertable ht ON (a.mat_hypertable_id = ht.id) WHERE c.OID = relation; IF FOUND THEN relation = v_mat_ht; END IF; SELECT nspname, relname FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INTO v_schema, v_name WHERE c.OID = relation; -- for hypertables return the sum of the row counts of all chunks SELECT id FROM _timescaledb_catalog.hypertable INTO v_hypertable_id WHERE table_name = v_name AND schema_name = v_schema; IF FOUND THEN RETURN (SELECT coalesce(sum(_timescaledb_functions.get_approx_row_count(format('%I.%I',schema_name,table_name))),0) FROM _timescaledb_catalog.chunk WHERE hypertable_id = v_hypertable_id AND NOT dropped); END IF; IF EXISTS (SELECT FROM pg_inherits WHERE inhparent = relation) THEN RETURN ( SELECT _timescaledb_functions.get_approx_row_count(relation) + COALESCE(SUM(@extschema@.approximate_row_count(i.inhrelid)),0) FROM pg_inherits i WHERE i.inhparent = relation ); END IF; -- Check for input relation is Plain RELATION RETURN _timescaledb_functions.get_approx_row_count(relation); END; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_approx_row_count(relation REGCLASS) RETURNS BIGINT LANGUAGE PLPGSQL VOLATILE STRICT AS $BODY$ DECLARE v_schema NAME; v_name NAME; v_chunk_id INTEGER; v_oid OID; row_count BIGINT = 0; BEGIN SELECT nspname, relname INTO v_schema, v_name FROM pg_class c JOIN pg_namespace n ON (n.OID = c.relnamespace) WHERE c.OID = relation; -- we only need to check if the relation has a compressed chunk if it is a chunk SELECT compressed_chunk_id FROM _timescaledb_catalog.chunk INTO v_chunk_id WHERE table_name = v_name AND schema_name = v_schema; IF v_chunk_id IS NOT NULL THEN SELECT format('%I.%I', schema_name, table_name)::regclass INTO v_oid FROM _timescaledb_catalog.chunk WHERE id = v_chunk_id; row_count := (SELECT row_count + CASE WHEN reltuples IS NULL THEN 0 WHEN reltuples < 0 THEN 0 ELSE reltuples * 1000 END FROM pg_class WHERE oid = v_oid); END IF; row_count := COALESCE((SELECT row_count + CASE WHEN reltuples < 0 OR relkind = 'p' THEN 0 ELSE reltuples END FROM pg_class WHERE oid = relation), 0); RETURN row_count; END $BODY$ SET search_path TO pg_catalog, pg_temp; -------- stats related to compression ------ CREATE OR REPLACE VIEW _timescaledb_internal.compressed_chunk_stats AS SELECT srcht.schema_name AS hypertable_schema, srcht.table_name AS hypertable_name, srcch.schema_name AS chunk_schema, srcch.table_name AS chunk_name, CASE WHEN srcch.compressed_chunk_id IS NULL THEN 'Uncompressed'::text ELSE 'Compressed'::text END AS compression_status, map.uncompressed_heap_size, map.uncompressed_index_size, map.uncompressed_toast_size, map.uncompressed_heap_size + map.uncompressed_toast_size + map.uncompressed_index_size AS uncompressed_total_size, map.compressed_heap_size, map.compressed_index_size, map.compressed_toast_size, map.compressed_heap_size + map.compressed_toast_size + map.compressed_index_size AS compressed_total_size FROM _timescaledb_catalog.hypertable AS srcht JOIN _timescaledb_catalog.chunk AS srcch ON srcht.id = srcch.hypertable_id AND srcht.compressed_hypertable_id IS NOT NULL AND srcch.dropped = FALSE LEFT JOIN _timescaledb_catalog.compression_chunk_size map ON srcch.id = map.chunk_id; GRANT SELECT ON _timescaledb_internal.compressed_chunk_stats TO PUBLIC; CREATE OR REPLACE FUNCTION _timescaledb_functions.compressed_chunk_local_stats(schema_name_in name, table_name_in name) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint) LANGUAGE SQL STABLE STRICT AS $BODY$ SELECT ch.chunk_schema, ch.chunk_name, ch.compression_status, ch.uncompressed_heap_size, ch.uncompressed_index_size, ch.uncompressed_toast_size, ch.uncompressed_total_size, ch.compressed_heap_size, ch.compressed_index_size, ch.compressed_toast_size, ch.compressed_total_size FROM _timescaledb_internal.compressed_chunk_stats ch WHERE ch.hypertable_schema = schema_name_in AND ch.hypertable_name = table_name_in; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Get per chunk compression statistics for a hypertable that has -- compression enabled CREATE OR REPLACE FUNCTION @extschema@.chunk_compression_stats (hypertable REGCLASS) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE PLPGSQL STABLE STRICT AS $BODY$ DECLARE table_name name; schema_name name; BEGIN SELECT relname, nspname INTO table_name, schema_name FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INNER JOIN _timescaledb_catalog.hypertable ht ON (ht.schema_name = n.nspname AND ht.table_name = c.relname) WHERE c.OID = hypertable; IF table_name IS NULL THEN RETURN; END IF; RETURN QUERY SELECT *, NULL::name FROM _timescaledb_functions.compressed_chunk_local_stats(schema_name, table_name); END; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION @extschema@.chunk_columnstore_stats (hypertable REGCLASS) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE SQL STABLE STRICT AS 'SELECT * FROM @extschema@.chunk_compression_stats($1)' SET search_path TO pg_catalog, pg_temp; -- Get compression statistics for a hypertable that has -- compression enabled CREATE OR REPLACE FUNCTION @extschema@.hypertable_compression_stats (hypertable REGCLASS) RETURNS TABLE ( total_chunks bigint, number_compressed_chunks bigint, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE SQL STABLE STRICT AS $BODY$ SELECT count(*)::bigint AS total_chunks, (count(*) FILTER (WHERE ch.compression_status = 'Compressed'))::bigint AS number_compressed_chunks, sum(ch.before_compression_table_bytes)::bigint AS before_compression_table_bytes, sum(ch.before_compression_index_bytes)::bigint AS before_compression_index_bytes, sum(ch.before_compression_toast_bytes)::bigint AS before_compression_toast_bytes, sum(ch.before_compression_total_bytes)::bigint AS before_compression_total_bytes, sum(ch.after_compression_table_bytes)::bigint AS after_compression_table_bytes, sum(ch.after_compression_index_bytes)::bigint AS after_compression_index_bytes, sum(ch.after_compression_toast_bytes)::bigint AS after_compression_toast_bytes, sum(ch.after_compression_total_bytes)::bigint AS after_compression_total_bytes, ch.node_name FROM @extschema@.chunk_compression_stats(hypertable) ch GROUP BY ch.node_name; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION @extschema@.hypertable_columnstore_stats (hypertable REGCLASS) RETURNS TABLE ( total_chunks bigint, number_compressed_chunks bigint, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE SQL STABLE STRICT AS 'SELECT * FROM @extschema@.hypertable_compression_stats($1)' SET search_path TO pg_catalog, pg_temp; -------------Get index size for hypertables ------- CREATE OR REPLACE FUNCTION @extschema@.hypertable_index_size( index_name REGCLASS ) RETURNS BIGINT LANGUAGE SQL VOLATILE STRICT AS $BODY$ SELECT pg_relation_size(ht_i.indexrelid) + COALESCE(sum(pg_relation_size(ch_i.indexrelid)), 0) FROM pg_index ht_i LEFT JOIN pg_inherits ch on ch.inhparent = ht_i.indrelid LEFT JOIN pg_index ch_i on ch_i.indrelid = ch.inhrelid and _timescaledb_functions.index_matches(ht_i.indexrelid, ch_i.indexrelid) WHERE ht_i.indexrelid = index_name GROUP BY ht_i.indexrelid; $BODY$ SET search_path TO pg_catalog, pg_temp; -------------End index size for hypertables ------- ����������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/sparse_index.sql�������������������������������������������������������������0000664�0000000�0000000�00000002472�15100345067�0020064�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.bloom1_contains(_timescaledb_internal.bloom1, anyelement) RETURNS bool AS '@MODULE_PATHNAME@', 'ts_bloom1_contains' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.jsonb_get_matching_index_entry( config jsonb, attr_name text, target_type text ) RETURNS jsonb AS $$ DECLARE elem jsonb; attr_count int := 0; BEGIN -- Return NULL if any input is NULL IF config IS NULL OR attr_name IS NULL OR target_type IS NULL THEN RETURN NULL; END IF; FOR elem IN SELECT * FROM jsonb_array_elements(config) LOOP IF elem->>'column' = attr_name THEN attr_count := attr_count + 1; IF elem->>'type' = target_type THEN IF attr_count > 2 THEN RAISE EXCEPTION 'Found % sparse index entries for attribute "%"', attr_count, attr_name; END IF; RETURN elem; END IF; END IF; END LOOP; IF attr_count > 2 THEN RAISE EXCEPTION 'Found % sparse index entries for attribute "%"', attr_count, attr_name; END IF; RETURN NULL; END; $$ LANGUAGE PLPGSQL SET search_path TO pg_catalog, pg_temp; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/time_bucket.sql��������������������������������������������������������������0000664�0000000�0000000�00000010631�15100345067�0017667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- time_bucket returns the left edge of the bucket where ts falls into. -- Buckets span an interval of time equal to the bucket_width and are aligned with the epoch. CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMP) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_timestamp_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- bucketing of timestamptz happens at UTC time CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMPTZ) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_timestamptz_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; --bucketing on date should not do any timezone conversion CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts DATE) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_date_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; --bucketing with origin CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMP, origin TIMESTAMP) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_timestamp_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMPTZ, origin TIMESTAMPTZ) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_timestamptz_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts DATE, origin DATE) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_date_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; --bucketing with offset CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMP, "offset" INTERVAL) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_timestamp_offset_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMPTZ, "offset" INTERVAL) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_timestamptz_offset_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts DATE, "offset" INTERVAL) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_date_offset_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- bucketing with timezone CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INTERVAL, ts TIMESTAMPTZ, timezone TEXT, origin TIMESTAMPTZ DEFAULT NULL, "offset" INTERVAL DEFAULT NULL) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_timestamptz_timezone_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE; -- bucketing of int CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width SMALLINT, ts SMALLINT) RETURNS SMALLINT AS '@MODULE_PATHNAME@', 'ts_int16_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INT, ts INT) RETURNS INT AS '@MODULE_PATHNAME@', 'ts_int32_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width BIGINT, ts BIGINT) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_int64_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- bucketing of int with offset CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width SMALLINT, ts SMALLINT, "offset" SMALLINT) RETURNS SMALLINT AS '@MODULE_PATHNAME@', 'ts_int16_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width INT, ts INT, "offset" INT) RETURNS INT AS '@MODULE_PATHNAME@', 'ts_int32_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION @extschema@.time_bucket(bucket_width BIGINT, ts BIGINT, "offset" BIGINT) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_int64_bucket' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- This will align a range to a bucket size. It is similar to -- time_bucket(), but takes a range and produces a range that starts -- and ends at bucket boundaries. CREATE OR REPLACE FUNCTION _timescaledb_functions.align_to_bucket(width interval, rng anyrange) RETURNS anyrange AS $body$ BEGIN RETURN _timescaledb_functions.make_range_from_internal_time( rng, @extschema@.time_bucket(width, lower(rng)), @extschema@.time_bucket(width, upper(rng) - '1 microsecond'::interval) + width ); END $body$ LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path TO pg_catalog, pg_temp; �������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/time_bucket_ng.sql�����������������������������������������������������������0000664�0000000�0000000�00000007365�15100345067�0020365�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- time_bucket_ng() is an _experimental_ new version of time_bucket(). -- -- Unlike time_bucket(), time_bucket_ng() supports variable-sized buckets, -- such as months and years, and also timezones. Note that the behavior -- and the interface of this function are subjects to change. There could -- be bugs, and the implementation doesn't claim to be complete. Use at -- your own risk. -- -- This function may return different results for the same arguments depending -- on the version of local timezone database. Despite this fact, function is -- marked as IMMUTABLE. This is consistent with the volatility [1] of the -- functions provided by PostgreSQL. See discussion [2] for more details. -- -- We don't forbid users to work with timestamptz's from the future, nor warn -- about this corner case. This behavior is consistent with PostgreSQL -- behavior [3]. -- -- [1]: https://www.postgresql.org/docs/current/xfunc-volatility.html -- [2]: https://postgr.es/m/CAJ7c6TOMG8zSNEZtCn5SPe+cCk3Lfxb71ZaQwT2F4T7PJ_t=KA@mail.gmail.com -- [3]: https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-TIMEZONES -- DATE versions of time_bucket_ng(). CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts DATE) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_date' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts DATE, origin DATE) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_date' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- TIMESTAMP versions of time_bucket_ng(). CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts TIMESTAMP) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_timestamp' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts TIMESTAMP, origin TIMESTAMP) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_timestamp' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- TIMESTAMPTZ versions of time_bucket_ng(). CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts TIMESTAMPTZ, timezone TEXT) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_timezone' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts TIMESTAMPTZ, origin TIMESTAMPTZ, timezone TEXT) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_timezone_origin' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- The following two versions of time_bucket_ng() are kept only for the backward -- compatibility with time_bucket(). They convert 'ts' to UTC instead of treating -- it in the given timezone, which is almost certainly not something you want. -- Future versions may WARN you about this fact, and be completely removed -- eventually. -- -- These functions are STABLE because their implementation relies on the STABLE -- function timestamptz_date(). The latest is STABLE because it accounts for the -- session parameters. CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts TIMESTAMPTZ) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_timestamptz' LANGUAGE C STABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION timescaledb_experimental.time_bucket_ng(bucket_width INTERVAL, ts TIMESTAMPTZ, origin TIMESTAMPTZ) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_time_bucket_ng_timestamptz' LANGUAGE C STABLE PARALLEL SAFE STRICT; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/���������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016317�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.0--2.9.3.sql����������������������������������������������������0000664�0000000�0000000�00000000263�15100345067�0020303�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������GRANT ALL ON _timescaledb_internal.job_errors TO PUBLIC; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.job_errors; DROP VIEW timescaledb_information.job_errors; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.1--2.10.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020336�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.1--2.10.2.sql���������������������������������������������������0000664�0000000�0000000�00000007161�15100345067�0020357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION _timescaledb_internal.ping_data_node(NAME); -- We only create stub here to not introduce shared library dependencies in update chains -- the proper function definition will be created at end of update script when all functions -- are recreated. CREATE OR REPLACE FUNCTION _timescaledb_internal.ping_data_node(node_name NAME, timeout INTERVAL = NULL) RETURNS BOOLEAN AS $$SELECT false;$$ LANGUAGE SQL VOLATILE; -- drop dependent views DROP VIEW IF EXISTS timescaledb_information.job_errors; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.jobs; DROP VIEW IF EXISTS timescaledb_experimental.policies; ALTER TABLE _timescaledb_config.bgw_job ALTER COLUMN owner DROP DEFAULT, ALTER COLUMN owner TYPE regrole USING pg_catalog.quote_ident(owner)::regrole, ALTER COLUMN owner SET DEFAULT pg_catalog.quote_ident(current_role)::regrole; CREATE TABLE _timescaledb_config.bgw_job_tmp AS SELECT * FROM _timescaledb_config.bgw_job; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_config.bgw_job; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_config.bgw_job_id_seq; ALTER TABLE _timescaledb_internal.bgw_job_stat DROP CONSTRAINT IF EXISTS bgw_job_stat_job_id_fkey; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats DROP CONSTRAINT IF EXISTS bgw_policy_chunk_stats_job_id_fkey; CREATE TABLE _timescaledb_internal.tmp_bgw_job_seq_value AS SELECT last_value, is_called FROM _timescaledb_config.bgw_job_id_seq; DROP TABLE _timescaledb_config.bgw_job; CREATE SEQUENCE _timescaledb_config.bgw_job_id_seq MINVALUE 1000; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job_id_seq', ''); SELECT pg_catalog.setval('_timescaledb_config.bgw_job_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_bgw_job_seq_value; DROP TABLE _timescaledb_internal.tmp_bgw_job_seq_value; CREATE TABLE _timescaledb_config.bgw_job ( id integer NOT NULL DEFAULT nextval('_timescaledb_config.bgw_job_id_seq'), application_name name NOT NULL, schedule_interval interval NOT NULL, max_runtime interval NOT NULL, max_retries integer NOT NULL, retry_period interval NOT NULL, proc_schema name NOT NULL, proc_name name NOT NULL, owner regrole NOT NULL DEFAULT pg_catalog.quote_ident(current_role)::regrole, scheduled bool NOT NULL DEFAULT TRUE, fixed_schedule bool not null default true, initial_start timestamptz, hypertable_id integer, config jsonb, check_schema name, check_name name, timezone text, CONSTRAINT bgw_job_pkey PRIMARY KEY (id), CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq OWNED BY _timescaledb_config.bgw_job.id; CREATE INDEX bgw_job_proc_hypertable_id_idx ON _timescaledb_config.bgw_job(proc_schema,proc_name,hypertable_id); INSERT INTO _timescaledb_config.bgw_job SELECT * FROM _timescaledb_config.bgw_job_tmp ORDER BY id; DROP TABLE _timescaledb_config.bgw_job_tmp; ALTER TABLE _timescaledb_internal.bgw_job_stat ADD CONSTRAINT bgw_job_stat_job_id_fkey FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats ADD CONSTRAINT bgw_policy_chunk_stats_job_id_fkey FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id) ON DELETE CASCADE; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job', 'WHERE id >= 1000'); GRANT SELECT ON _timescaledb_config.bgw_job TO PUBLIC; GRANT SELECT ON _timescaledb_config.bgw_job_id_seq TO PUBLIC; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.2--2.10.1.sql���������������������������������������������������0000664�0000000�0000000�00000006513�15100345067�0020357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION _timescaledb_internal.ping_data_node(NAME, INTERVAL); CREATE OR REPLACE FUNCTION _timescaledb_internal.ping_data_node(node_name NAME) RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_data_node_ping' LANGUAGE C VOLATILE; -- drop dependent views DROP VIEW IF EXISTS timescaledb_information.job_errors; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.jobs; DROP VIEW IF EXISTS timescaledb_experimental.policies; ALTER TABLE _timescaledb_config.bgw_job ALTER COLUMN owner DROP DEFAULT, ALTER COLUMN owner TYPE name USING owner::name, ALTER COLUMN owner SET DEFAULT current_role; CREATE TABLE _timescaledb_config.bgw_job_tmp AS SELECT * FROM _timescaledb_config.bgw_job; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_config.bgw_job; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_config.bgw_job_id_seq; ALTER TABLE _timescaledb_internal.bgw_job_stat DROP CONSTRAINT IF EXISTS bgw_job_stat_job_id_fkey; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats DROP CONSTRAINT IF EXISTS bgw_policy_chunk_stats_job_id_fkey; CREATE TABLE _timescaledb_internal.tmp_bgw_job_seq_value AS SELECT last_value, is_called FROM _timescaledb_config.bgw_job_id_seq; DROP TABLE _timescaledb_config.bgw_job; CREATE SEQUENCE _timescaledb_config.bgw_job_id_seq MINVALUE 1000; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job_id_seq', ''); SELECT pg_catalog.setval('_timescaledb_config.bgw_job_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_bgw_job_seq_value; DROP TABLE _timescaledb_internal.tmp_bgw_job_seq_value; CREATE TABLE _timescaledb_config.bgw_job ( id integer NOT NULL DEFAULT nextval('_timescaledb_config.bgw_job_id_seq'), application_name name NOT NULL, schedule_interval interval NOT NULL, max_runtime interval NOT NULL, max_retries integer NOT NULL, retry_period interval NOT NULL, proc_schema name NOT NULL, proc_name name NOT NULL, owner name NOT NULL DEFAULT current_role, scheduled bool NOT NULL DEFAULT TRUE, fixed_schedule bool not null default true, initial_start timestamptz, hypertable_id integer, config jsonb, check_schema name, check_name name, timezone text, CONSTRAINT bgw_job_pkey PRIMARY KEY (id), CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq OWNED BY _timescaledb_config.bgw_job.id; CREATE INDEX bgw_job_proc_hypertable_id_idx ON _timescaledb_config.bgw_job(proc_schema,proc_name,hypertable_id); INSERT INTO _timescaledb_config.bgw_job SELECT * FROM _timescaledb_config.bgw_job_tmp ORDER BY id; DROP TABLE _timescaledb_config.bgw_job_tmp; ALTER TABLE _timescaledb_internal.bgw_job_stat ADD CONSTRAINT bgw_job_stat_job_id_fkey FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats ADD CONSTRAINT bgw_policy_chunk_stats_job_id_fkey FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id) ON DELETE CASCADE; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job', 'WHERE id >= 1000'); GRANT SELECT ON _timescaledb_config.bgw_job TO PUBLIC; GRANT SELECT ON _timescaledb_config.bgw_job_id_seq TO PUBLIC; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.2--2.10.3.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.3--2.10.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.10.3--2.11.0.sql���������������������������������������������������0000664�0000000�0000000�00000011336�15100345067�0020357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE _timescaledb_catalog.continuous_aggs_watermark ( mat_hypertable_id integer NOT NULL, watermark bigint NOT NULL, -- table constraints CONSTRAINT continuous_aggs_watermark_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_watermark_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); GRANT SELECT ON _timescaledb_catalog.continuous_aggs_watermark TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_watermark', ''); CREATE FUNCTION _timescaledb_internal.cagg_watermark_materialized(hypertable_id INTEGER) RETURNS INT8 AS '@MODULE_PATHNAME@', 'ts_continuous_agg_watermark_materialized' LANGUAGE C STABLE STRICT PARALLEL SAFE; CREATE FUNCTION _timescaledb_internal.recompress_chunk_segmentwise(REGCLASS, BOOLEAN) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_recompress_chunk_segmentwise' LANGUAGE C STRICT VOLATILE; CREATE FUNCTION _timescaledb_internal.get_compressed_chunk_index_for_recompression(REGCLASS) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_get_compressed_chunk_index_for_recompression' LANGUAGE C STRICT VOLATILE; DROP FUNCTION _timescaledb_internal.dimension_is_finite; DROP FUNCTION _timescaledb_internal.dimension_slice_get_constraint_sql; CREATE SCHEMA _timescaledb_functions; GRANT USAGE ON SCHEMA _timescaledb_functions TO PUBLIC; -- migrate histogram support functions into _timescaledb_functions schema ALTER FUNCTION _timescaledb_internal.hist_sfunc (state INTERNAL, val DOUBLE PRECISION, MIN DOUBLE PRECISION, MAX DOUBLE PRECISION, nbuckets INTEGER) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.hist_combinefunc(state1 INTERNAL, state2 INTERNAL) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.hist_serializefunc(INTERNAL) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.hist_deserializefunc(bytea, INTERNAL) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.hist_finalfunc(state INTERNAL, val DOUBLE PRECISION, MIN DOUBLE PRECISION, MAX DOUBLE PRECISION, nbuckets INTEGER) SET SCHEMA _timescaledb_functions; -- migrate first/last support functions into _timescaledb_functions schema ALTER FUNCTION _timescaledb_internal.first_sfunc(internal, anyelement, "any") SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.first_combinefunc(internal, internal) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.last_sfunc(internal, anyelement, "any") SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.last_combinefunc(internal, internal) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.bookend_finalfunc(internal, anyelement, "any") SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.bookend_serializefunc(internal) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.bookend_deserializefunc(bytea, internal) SET SCHEMA _timescaledb_functions; DROP FUNCTION IF EXISTS _timescaledb_internal.is_main_table(regclass); DROP FUNCTION IF EXISTS _timescaledb_internal.is_main_table(name, name); DROP FUNCTION IF EXISTS _timescaledb_internal.hypertable_from_main_table(regclass); DROP FUNCTION IF EXISTS _timescaledb_internal.main_table_from_hypertable(integer); DROP FUNCTION IF EXISTS _timescaledb_internal.time_literal_sql(bigint, regtype); ALTER FUNCTION _timescaledb_internal.compressed_data_in(CSTRING) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.compressed_data_out(_timescaledb_internal.compressed_data) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.compressed_data_send(_timescaledb_internal.compressed_data) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.compressed_data_recv(internal) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.rxid_in(cstring) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.rxid_out(@extschema@.rxid) SET SCHEMA _timescaledb_functions; ALTER TABLE _timescaledb_config.bgw_job ALTER COLUMN owner SET DEFAULT pg_catalog.quote_ident(current_role)::regrole; ALTER TABLE _timescaledb_catalog.continuous_agg_migrate_plan ADD COLUMN user_view_definition TEXT, DROP CONSTRAINT continuous_agg_migrate_plan_mat_hypertable_id_fkey; -- Log with events that will be sent out with the telemetry. The log -- will be flushed after it has been sent out. We do not save it to -- backups since it should not contain important data. CREATE TABLE _timescaledb_catalog.telemetry_event ( created timestamptz NOT NULL DEFAULT current_timestamp, tag name NOT NULL, body jsonb NOT NULL ); GRANT SELECT ON _timescaledb_catalog.telemetry_event TO PUBLIC; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.11.0--2.10.3.sql���������������������������������������������������0000664�0000000�0000000�00000025425�15100345067�0020363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION IF EXISTS _timescaledb_internal.get_approx_row_count(REGCLASS); ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_aggs_watermark; DROP TABLE IF EXISTS _timescaledb_catalog.continuous_aggs_watermark; DROP FUNCTION IF EXISTS _timescaledb_internal.cagg_watermark_materialized(hypertable_id INTEGER); DROP FUNCTION _timescaledb_internal.recompress_chunk_segmentwise(REGCLASS, BOOLEAN); DROP FUNCTION _timescaledb_internal.get_compressed_chunk_index_for_recompression(REGCLASS); CREATE OR REPLACE FUNCTION _timescaledb_internal.dimension_is_finite( val BIGINT ) RETURNS BOOLEAN LANGUAGE SQL IMMUTABLE PARALLEL SAFE AS $BODY$ --end values of bigint reserved for infinite SELECT val > (-9223372036854775808)::bigint AND val < 9223372036854775807::bigint $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_internal.dimension_slice_get_constraint_sql( dimension_slice_id INTEGER ) RETURNS TEXT LANGUAGE PLPGSQL VOLATILE AS $BODY$ DECLARE dimension_slice_row _timescaledb_catalog.dimension_slice; dimension_row _timescaledb_catalog.dimension; dimension_def TEXT; dimtype REGTYPE; parts TEXT[]; BEGIN SELECT * INTO STRICT dimension_slice_row FROM _timescaledb_catalog.dimension_slice WHERE id = dimension_slice_id; SELECT * INTO STRICT dimension_row FROM _timescaledb_catalog.dimension WHERE id = dimension_slice_row.dimension_id; IF dimension_row.partitioning_func_schema IS NOT NULL AND dimension_row.partitioning_func IS NOT NULL THEN SELECT prorettype INTO STRICT dimtype FROM pg_catalog.pg_proc pro WHERE pro.oid = format('%I.%I', dimension_row.partitioning_func_schema, dimension_row.partitioning_func)::regproc::oid; dimension_def := format('%1$I.%2$I(%3$I)', dimension_row.partitioning_func_schema, dimension_row.partitioning_func, dimension_row.column_name); ELSE dimension_def := format('%1$I', dimension_row.column_name); dimtype := dimension_row.column_type; END IF; IF dimension_row.num_slices IS NOT NULL THEN IF _timescaledb_internal.dimension_is_finite(dimension_slice_row.range_start) THEN parts = parts || format(' %1$s >= %2$L ', dimension_def, dimension_slice_row.range_start); END IF; IF _timescaledb_internal.dimension_is_finite(dimension_slice_row.range_end) THEN parts = parts || format(' %1$s < %2$L ', dimension_def, dimension_slice_row.range_end); END IF; IF array_length(parts, 1) = 0 THEN RETURN NULL; END IF; return array_to_string(parts, 'AND'); ELSE -- only works with time for now IF _timescaledb_internal.time_literal_sql(dimension_slice_row.range_start, dimtype) = _timescaledb_internal.time_literal_sql(dimension_slice_row.range_end, dimtype) THEN RAISE 'time-based constraints have the same start and end values for column "%": %', dimension_row.column_name, _timescaledb_internal.time_literal_sql(dimension_slice_row.range_end, dimtype); END IF; parts = ARRAY[]::text[]; IF _timescaledb_internal.dimension_is_finite(dimension_slice_row.range_start) THEN parts = parts || format(' %1$s >= %2$s ', dimension_def, _timescaledb_internal.time_literal_sql(dimension_slice_row.range_start, dimtype)); END IF; IF _timescaledb_internal.dimension_is_finite(dimension_slice_row.range_end) THEN parts = parts || format(' %1$s < %2$s ', dimension_def, _timescaledb_internal.time_literal_sql(dimension_slice_row.range_end, dimtype)); END IF; return array_to_string(parts, 'AND'); END IF; END $BODY$ SET search_path TO pg_catalog, pg_temp; ALTER FUNCTION _timescaledb_functions.hist_sfunc (state INTERNAL, val DOUBLE PRECISION, MIN DOUBLE PRECISION, MAX DOUBLE PRECISION, nbuckets INTEGER) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hist_combinefunc(state1 INTERNAL, state2 INTERNAL) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hist_serializefunc(INTERNAL) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hist_deserializefunc(bytea, INTERNAL) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hist_finalfunc(state INTERNAL, val DOUBLE PRECISION, MIN DOUBLE PRECISION, MAX DOUBLE PRECISION, nbuckets INTEGER) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.first_sfunc(internal, anyelement, "any") SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.first_combinefunc(internal, internal) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.last_sfunc(internal, anyelement, "any") SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.last_combinefunc(internal, internal) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.bookend_finalfunc(internal, anyelement, "any") SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.bookend_serializefunc(internal) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.bookend_deserializefunc(bytea, internal) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.compressed_data_in(CSTRING) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.compressed_data_out(_timescaledb_internal.compressed_data) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.compressed_data_send(_timescaledb_internal.compressed_data) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.compressed_data_recv(internal) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.rxid_in(cstring) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.rxid_out(@extschema@.rxid) SET SCHEMA _timescaledb_internal; DROP SCHEMA _timescaledb_functions; CREATE FUNCTION _timescaledb_internal.is_main_table( table_oid regclass ) RETURNS bool LANGUAGE SQL STABLE AS $BODY$ SELECT EXISTS(SELECT 1 FROM _timescaledb_catalog.hypertable WHERE table_name = relname AND schema_name = nspname) FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) WHERE c.OID = table_oid; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Check if given table is a hypertable's main table CREATE FUNCTION _timescaledb_internal.is_main_table( schema_name NAME, table_name NAME ) RETURNS BOOLEAN LANGUAGE SQL STABLE AS $BODY$ SELECT EXISTS( SELECT 1 FROM _timescaledb_catalog.hypertable h WHERE h.schema_name = is_main_table.schema_name AND h.table_name = is_main_table.table_name ); $BODY$ SET search_path TO pg_catalog, pg_temp; -- Get a hypertable given its main table OID CREATE FUNCTION _timescaledb_internal.hypertable_from_main_table( table_oid regclass ) RETURNS _timescaledb_catalog.hypertable LANGUAGE SQL STABLE AS $BODY$ SELECT h.* FROM pg_class c INNER JOIN pg_namespace n ON (n.OID = c.relnamespace) INNER JOIN _timescaledb_catalog.hypertable h ON (h.table_name = c.relname AND h.schema_name = n.nspname) WHERE c.OID = table_oid; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_internal.main_table_from_hypertable( hypertable_id int ) RETURNS regclass LANGUAGE SQL STABLE AS $BODY$ SELECT format('%I.%I',h.schema_name, h.table_name)::regclass FROM _timescaledb_catalog.hypertable h WHERE id = hypertable_id; $BODY$ SET search_path TO pg_catalog, pg_temp; -- Gets the sql code for representing the literal for the given time value (in the internal representation) as the column_type. CREATE FUNCTION _timescaledb_internal.time_literal_sql( time_value BIGINT, column_type REGTYPE ) RETURNS text LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE ret text; BEGIN IF time_value IS NULL THEN RETURN format('%L', NULL); END IF; CASE column_type WHEN 'BIGINT'::regtype, 'INTEGER'::regtype, 'SMALLINT'::regtype THEN RETURN format('%L', time_value); -- scale determined by user. WHEN 'TIMESTAMP'::regtype THEN --the time_value for timestamps w/o tz does not depend on local timezones. So perform at UTC. RETURN format('TIMESTAMP %1$L', timezone('UTC',_timescaledb_internal.to_timestamp(time_value))); -- microseconds WHEN 'TIMESTAMPTZ'::regtype THEN -- assume time_value is in microsec RETURN format('TIMESTAMPTZ %1$L', _timescaledb_internal.to_timestamp(time_value)); -- microseconds WHEN 'DATE'::regtype THEN RETURN format('%L', timezone('UTC',_timescaledb_internal.to_timestamp(time_value))::date); ELSE EXECUTE 'SELECT format(''%L'', $1::' || column_type::text || ')' into ret using time_value; RETURN ret; END CASE; END $BODY$ SET search_path TO pg_catalog, pg_temp; ALTER TABLE _timescaledb_config.bgw_job ALTER COLUMN owner SET DEFAULT pg_catalog.quote_ident(current_role)::regrole; -- Rebuild the _timescaledb_catalog.continuous_agg_migrate_plan_step definition ALTER TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step DROP CONSTRAINT continuous_agg_migrate_plan_step_mat_hypertable_id_fkey; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_agg_migrate_plan; CREATE TABLE _timescaledb_catalog._tmp_continuous_agg_migrate_plan AS SELECT mat_hypertable_id, start_ts, end_ts FROM _timescaledb_catalog.continuous_agg_migrate_plan; DROP TABLE _timescaledb_catalog.continuous_agg_migrate_plan; CREATE TABLE _timescaledb_catalog.continuous_agg_migrate_plan ( mat_hypertable_id integer NOT NULL, start_ts TIMESTAMPTZ NOT NULL DEFAULT pg_catalog.now(), end_ts TIMESTAMPTZ, -- table constraints CONSTRAINT continuous_agg_migrate_plan_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_agg_migrate_plan_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ); INSERT INTO _timescaledb_catalog.continuous_agg_migrate_plan SELECT * FROM _timescaledb_catalog._tmp_continuous_agg_migrate_plan; DROP TABLE _timescaledb_catalog._tmp_continuous_agg_migrate_plan; ALTER TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step ADD CONSTRAINT continuous_agg_migrate_plan_step_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg_migrate_plan (mat_hypertable_id) ON DELETE CASCADE; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg_migrate_plan', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan TO PUBLIC; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.telemetry_event; DROP TABLE IF EXISTS _timescaledb_catalog.telemetry_event; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.11.0--2.11.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.11.1--2.11.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.11.1--2.11.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.11.2--2.11.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.11.2--2.12.0.sql���������������������������������������������������0000664�0000000�0000000�00000042563�15100345067�0020366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION IF EXISTS @extschema@.alter_job( INTEGER, INTERVAL, INTERVAL, INTEGER, INTERVAL, BOOL, JSONB, TIMESTAMPTZ, BOOL, REGPROC ); CREATE FUNCTION @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL = NULL, max_runtime INTERVAL = NULL, max_retries INTEGER = NULL, retry_period INTERVAL = NULL, scheduled BOOL = NULL, config JSONB = NULL, next_start TIMESTAMPTZ = NULL, if_exists BOOL = FALSE, check_config REGPROC = NULL, fixed_schedule BOOL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT DEFAULT NULL ) RETURNS TABLE (job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, check_config TEXT, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT) AS '@MODULE_PATHNAME@', 'ts_job_alter' LANGUAGE C VOLATILE; -- when upgrading from old versions on PG13 this function might not be present -- since there is no ALTER FUNCTION IF EXISTS we have to work around it with a DO block DO $$ DECLARE foid regprocedure; funcs text[] = '{ drop_dist_ht_invalidation_trigger, subtract_integer_from_now, get_approx_row_count, chunk_status, create_chunk,create_chunk_table, freeze_chunk,unfreeze_chunk,drop_chunk, attach_osm_table_chunk }'; BEGIN FOR foid IN SELECT oid FROM pg_proc WHERE proname = ANY(funcs) AND pronamespace = '_timescaledb_internal'::regnamespace LOOP EXECUTE format('ALTER FUNCTION %s SET SCHEMA _timescaledb_functions', foid); END LOOP; END; $$; DROP FUNCTION IF EXISTS _timescaledb_internal.get_time_type(integer); ALTER FUNCTION _timescaledb_internal.insert_blocker() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.continuous_agg_invalidation_trigger() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_create_command(name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.to_unix_microseconds(timestamptz) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.to_timestamp(bigint) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.to_timestamp_without_timezone(bigint) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.to_date(bigint) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.to_interval(bigint) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.interval_to_usec(interval) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.time_to_internal(anyelement) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.set_dist_id(uuid) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.set_peer_dist_id(uuid) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.validate_as_data_node() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.show_connection_cache() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.ping_data_node(name, interval) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.remote_txn_heal_data_node(oid) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.relation_size(regclass) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.data_node_hypertable_info(name, name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.data_node_chunk_info(name, name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.hypertable_local_size(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.hypertable_remote_size(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.chunks_local_size(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.chunks_remote_size(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.range_value_to_pretty(bigint, regtype) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.data_node_compressed_chunk_stats(name, name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.compressed_chunk_local_stats(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.compressed_chunk_remote_stats(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.indexes_local_size(name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.data_node_index_size(name, name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.indexes_remote_size(name, name, name) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.generate_uuid() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_git_commit() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_os_info() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.tsl_loaded() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.calculate_chunk_interval(int, bigint, bigint) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.chunks_in(record, integer[]) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.chunk_id_from_relid(oid) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.show_chunk(regclass) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_chunk_relstats(regclass) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_chunk_colstats(regclass) SET SCHEMA _timescaledb_functions; UPDATE _timescaledb_catalog.hypertable SET chunk_sizing_func_schema = '_timescaledb_functions' WHERE chunk_sizing_func_schema = '_timescaledb_internal' AND chunk_sizing_func_name = 'calculate_chunk_interval'; DO $$ DECLARE foid regprocedure; kind text; funcs text[] = '{ policy_compression_check,policy_compression_execute,policy_compression, policy_job_error_retention_check,policy_job_error_retention, policy_recompression, policy_refresh_continuous_aggregate_check,policy_refresh_continuous_aggregate, policy_reorder_check,policy_reorder,policy_retention_check,policy_retention, cagg_watermark, cagg_watermark_materialized, cagg_migrate_plan_exists, cagg_migrate_pre_validation, cagg_migrate_create_plan, cagg_migrate_execute_create_new_cagg, cagg_migrate_execute_disable_policies, cagg_migrate_execute_enable_policies, cagg_migrate_execute_copy_policies, cagg_migrate_execute_refresh_new_cagg, cagg_migrate_execute_copy_data, cagg_migrate_execute_override_cagg, cagg_migrate_execute_drop_old_cagg, cagg_migrate_execute_plan, finalize_agg, hypertable_invalidation_log_delete, invalidation_cagg_log_add_entry, invalidation_hyper_log_add_entry, invalidation_process_cagg_log, invalidation_process_hypertable_log, materialization_invalidation_log_delete, alter_job_set_hypertable_id, set_chunk_default_data_node, create_compressed_chunk, get_compressed_chunk_index_for_recompression, recompress_chunk_segmentwise, chunk_drop_replica, chunk_index_clone, chunk_index_replace, create_chunk_replica_table, drop_stale_chunks, chunk_constraint_add_table_constraint, hypertable_constraint_add_table_fk_constraint, health, wait_subscription_sync }'; BEGIN FOR foid, kind IN SELECT oid, CASE WHEN prokind = 'f' THEN 'FUNCTION' WHEN prokind = 'a' THEN 'AGGREGATE' ELSE 'PROCEDURE' END FROM pg_proc WHERE proname = ANY(funcs) AND pronamespace = '_timescaledb_internal'::regnamespace LOOP EXECUTE format('ALTER %s %s SET SCHEMA _timescaledb_functions', kind, foid); END LOOP; END; $$; UPDATE _timescaledb_config.bgw_job SET proc_schema = '_timescaledb_functions' WHERE proc_schema = '_timescaledb_internal'; UPDATE _timescaledb_config.bgw_job SET check_schema = '_timescaledb_functions' WHERE check_schema = '_timescaledb_internal'; ALTER FUNCTION _timescaledb_internal.start_background_workers() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.stop_background_workers() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.restart_background_workers() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.process_ddl_event() SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_partition_for_key(val anyelement) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.get_partition_hash(val anyelement) SET SCHEMA _timescaledb_functions; UPDATE _timescaledb_catalog.dimension SET partitioning_func_schema = '_timescaledb_functions' WHERE partitioning_func_schema = '_timescaledb_internal' AND partitioning_func IN ('get_partition_for_key','get_partition_hash'); ALTER FUNCTION _timescaledb_internal.finalize_agg_ffunc(internal,text,name,name,name[],bytea,anyelement) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.finalize_agg_sfunc(internal,text,name,name,name[],bytea,anyelement) SET SCHEMA _timescaledb_functions; ALTER FUNCTION _timescaledb_internal.partialize_agg(anyelement) SET SCHEMA _timescaledb_functions; -- Fix osm chunk ranges UPDATE _timescaledb_catalog.dimension_slice ds SET range_start = 9223372036854775806 FROM _timescaledb_catalog.chunk_constraint cc INNER JOIN _timescaledb_catalog.chunk c ON c.id = cc.chunk_id AND c.osm_chunk WHERE cc.dimension_slice_id = ds.id AND ds.range_start <> 9223372036854775806; -- OSM support - table must be rebuilt to ensure consistent attribute numbers -- we cannot just ALTER TABLE .. ADD COLUMN ALTER TABLE _timescaledb_config.bgw_job DROP CONSTRAINT bgw_job_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk DROP CONSTRAINT chunk_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT chunk_index_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_agg DROP CONSTRAINT continuous_agg_mat_hypertable_id_fkey, DROP CONSTRAINT continuous_agg_raw_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function DROP CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold DROP CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.dimension DROP CONSTRAINT dimension_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable DROP CONSTRAINT hypertable_compressed_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable_compression DROP CONSTRAINT hypertable_compression_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable_data_node DROP CONSTRAINT hypertable_data_node_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.tablespace DROP CONSTRAINT tablespace_hypertable_id_fkey; DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.jobs; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; DROP VIEW IF EXISTS timescaledb_information.chunks; DROP VIEW IF EXISTS timescaledb_information.dimensions; DROP VIEW IF EXISTS timescaledb_information.compression_settings; DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size; DROP VIEW IF EXISTS _timescaledb_internal.compressed_chunk_stats; DROP VIEW IF EXISTS timescaledb_experimental.chunk_replication_status; DROP VIEW IF EXISTS timescaledb_experimental.policies; -- recreate table CREATE TABLE _timescaledb_catalog.hypertable_tmp AS SELECT * FROM _timescaledb_catalog.hypertable; CREATE TABLE _timescaledb_catalog.tmp_hypertable_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.hypertable_id_seq; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.hypertable_id_seq; SET timescaledb.restoring = on; -- must disable the hooks otherwise we can't do anything without the table _timescaledb_catalog.hypertable DROP TABLE _timescaledb_catalog.hypertable; CREATE SEQUENCE _timescaledb_catalog.hypertable_id_seq MINVALUE 1; SELECT setval('_timescaledb_catalog.hypertable_id_seq', last_value, is_called) FROM _timescaledb_catalog.tmp_hypertable_seq_value; DROP TABLE _timescaledb_catalog.tmp_hypertable_seq_value; CREATE TABLE _timescaledb_catalog.hypertable ( id INTEGER PRIMARY KEY NOT NULL DEFAULT nextval('_timescaledb_catalog.hypertable_id_seq'), schema_name name NOT NULL, table_name name NOT NULL, associated_schema_name name NOT NULL, associated_table_prefix name NOT NULL, num_dimensions smallint NOT NULL, chunk_sizing_func_schema name NOT NULL, chunk_sizing_func_name name NOT NULL, chunk_target_size bigint NOT NULL, -- size in bytes compression_state smallint NOT NULL DEFAULT 0, compressed_hypertable_id integer, replication_factor smallint NULL, status integer NOT NULL DEFAULT 0 ); SET timescaledb.restoring = off; INSERT INTO _timescaledb_catalog.hypertable ( id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, replication_factor ) SELECT id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, replication_factor FROM _timescaledb_catalog.hypertable_tmp ORDER BY id; UPDATE _timescaledb_catalog.hypertable h SET status = 3 WHERE EXISTS ( SELECT FROM _timescaledb_catalog.chunk c WHERE c.osm_chunk AND c.hypertable_id = h.id ); ALTER SEQUENCE _timescaledb_catalog.hypertable_id_seq OWNED BY _timescaledb_catalog.hypertable.id; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable', 'WHERE id >= 1'); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_id_seq', ''); GRANT SELECT ON _timescaledb_catalog.hypertable TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.hypertable_id_seq TO PUBLIC; DROP TABLE _timescaledb_catalog.hypertable_tmp; -- now add any constraints ALTER TABLE _timescaledb_catalog.hypertable ADD CONSTRAINT hypertable_associated_schema_name_associated_table_prefix_key UNIQUE (associated_schema_name, associated_table_prefix), ADD CONSTRAINT hypertable_table_name_schema_name_key UNIQUE (table_name, schema_name), ADD CONSTRAINT hypertable_schema_name_check CHECK (schema_name != '_timescaledb_catalog'), ADD CONSTRAINT hypertable_dim_compress_check CHECK (num_dimensions > 0 OR compression_state = 2), ADD CONSTRAINT hypertable_chunk_target_size_check CHECK (chunk_target_size >= 0), ADD CONSTRAINT hypertable_compress_check CHECK ( (compression_state = 0 OR compression_state = 1 ) OR (compression_state = 2 AND compressed_hypertable_id IS NULL)), ADD CONSTRAINT hypertable_replication_factor_check CHECK (replication_factor > 0 OR replication_factor = -1), ADD CONSTRAINT hypertable_compressed_hypertable_id_fkey FOREIGN KEY (compressed_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id); GRANT SELECT ON TABLE _timescaledb_catalog.hypertable TO PUBLIC; -- 3. reestablish constraints on other tables ALTER TABLE _timescaledb_config.bgw_job ADD CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT chunk_index_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_agg ADD CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE, ADD CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function ADD CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ADD CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.dimension ADD CONSTRAINT dimension_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.hypertable_compression ADD CONSTRAINT hypertable_compression_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.hypertable_data_node ADD CONSTRAINT hypertable_data_node_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.tablespace ADD CONSTRAINT tablespace_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ���������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.12.0--2.11.2.sql���������������������������������������������������0000664�0000000�0000000�00000100164�15100345067�0020356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ -- remove compatibility wrapper functions -- this needs to happen before we move the actual functions back into _timescaledb_internal DROP FUNCTION _timescaledb_internal.alter_job_set_hypertable_id(integer,regclass); DROP FUNCTION _timescaledb_internal.attach_osm_table_chunk(regclass,regclass); DROP FUNCTION _timescaledb_internal.cagg_migrate_plan_exists(integer); DROP FUNCTION _timescaledb_internal.cagg_migrate_pre_validation(text,text,text); DROP FUNCTION _timescaledb_internal.cagg_watermark(integer); DROP FUNCTION _timescaledb_internal.cagg_watermark_materialized(integer); DROP FUNCTION _timescaledb_internal.calculate_chunk_interval(integer,bigint,bigint); DROP FUNCTION _timescaledb_internal.chunk_constraint_add_table_constraint(_timescaledb_catalog.chunk_constraint); DROP FUNCTION _timescaledb_internal.chunk_drop_replica(regclass,name); DROP FUNCTION _timescaledb_internal.chunk_id_from_relid(oid); DROP FUNCTION _timescaledb_internal.chunk_index_clone(oid); DROP FUNCTION _timescaledb_internal.chunk_index_replace(oid,oid); DROP FUNCTION _timescaledb_internal.chunk_status(regclass); DROP FUNCTION _timescaledb_internal.chunks_in(record,integer[]); DROP FUNCTION _timescaledb_internal.chunks_local_size(name,name); DROP FUNCTION _timescaledb_internal.chunks_remote_size(name,name); DROP FUNCTION _timescaledb_internal.compressed_chunk_local_stats(name,name); DROP FUNCTION _timescaledb_internal.compressed_chunk_remote_stats(name,name); DROP FUNCTION _timescaledb_internal.continuous_agg_invalidation_trigger(); DROP FUNCTION _timescaledb_internal.create_chunk(regclass,jsonb,name,name,regclass); DROP FUNCTION _timescaledb_internal.create_chunk_replica_table(regclass,name); DROP FUNCTION _timescaledb_internal.create_chunk_table(regclass,jsonb,name,name); DROP FUNCTION _timescaledb_internal.create_compressed_chunk(regclass,regclass,bigint,bigint,bigint,bigint,bigint,bigint,bigint,bigint); DROP FUNCTION _timescaledb_internal.data_node_chunk_info(name,name,name); DROP FUNCTION _timescaledb_internal.data_node_compressed_chunk_stats(name,name,name); DROP FUNCTION _timescaledb_internal.data_node_hypertable_info(name,name,name); DROP FUNCTION _timescaledb_internal.data_node_index_size(name,name,name); DROP FUNCTION _timescaledb_internal.drop_chunk(regclass); DROP FUNCTION _timescaledb_internal.drop_dist_ht_invalidation_trigger(integer); DROP FUNCTION _timescaledb_internal.drop_stale_chunks(name,integer[]); DROP AGGREGATE _timescaledb_internal.finalize_agg(agg_name TEXT, inner_agg_collation_schema NAME, inner_agg_collation_name NAME, inner_agg_input_types NAME[][], inner_agg_serialized_state BYTEA, return_type_dummy_val anyelement); DROP FUNCTION _timescaledb_internal.finalize_agg_ffunc(internal, text, name, name, name[][], bytea, anyelement); DROP FUNCTION _timescaledb_internal.finalize_agg_sfunc(internal, text, name, name, name[][], bytea, anyelement); DROP FUNCTION _timescaledb_internal.freeze_chunk(regclass); DROP FUNCTION _timescaledb_internal.generate_uuid(); DROP FUNCTION _timescaledb_internal.get_approx_row_count(regclass); DROP FUNCTION _timescaledb_internal.get_chunk_colstats(regclass); DROP FUNCTION _timescaledb_internal.get_chunk_relstats(regclass); DROP FUNCTION _timescaledb_internal.get_compressed_chunk_index_for_recompression(regclass); DROP FUNCTION _timescaledb_internal.get_create_command(name); DROP FUNCTION _timescaledb_internal.get_git_commit(); DROP FUNCTION _timescaledb_internal.get_os_info(); DROP FUNCTION _timescaledb_internal.get_partition_for_key(anyelement); DROP FUNCTION _timescaledb_internal.get_partition_hash(anyelement); DROP FUNCTION _timescaledb_internal.health(); DROP FUNCTION _timescaledb_internal.hypertable_constraint_add_table_fk_constraint(name,name,name,integer); DROP FUNCTION _timescaledb_internal.hypertable_invalidation_log_delete(integer); DROP FUNCTION _timescaledb_internal.hypertable_local_size(name,name); DROP FUNCTION _timescaledb_internal.hypertable_remote_size(name,name); DROP FUNCTION _timescaledb_internal.indexes_local_size(name,name); DROP FUNCTION _timescaledb_internal.indexes_remote_size(name,name,name); DROP FUNCTION _timescaledb_internal.insert_blocker(); DROP FUNCTION _timescaledb_internal.interval_to_usec(interval); DROP FUNCTION _timescaledb_internal.invalidation_cagg_log_add_entry(integer,bigint,bigint); DROP FUNCTION _timescaledb_internal.invalidation_hyper_log_add_entry(integer,bigint,bigint); DROP FUNCTION _timescaledb_internal.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[]); DROP FUNCTION _timescaledb_internal.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[],text[]); DROP FUNCTION _timescaledb_internal.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[]); DROP FUNCTION _timescaledb_internal.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[],text[]); DROP FUNCTION _timescaledb_internal.materialization_invalidation_log_delete(integer); DROP FUNCTION _timescaledb_internal.partialize_agg(anyelement); DROP FUNCTION _timescaledb_internal.ping_data_node(name,interval); DROP FUNCTION _timescaledb_internal.policy_compression_check(jsonb); DROP FUNCTION _timescaledb_internal.policy_job_error_retention(integer,jsonb); DROP FUNCTION _timescaledb_internal.policy_job_error_retention_check(jsonb); DROP FUNCTION _timescaledb_internal.policy_refresh_continuous_aggregate_check(jsonb); DROP FUNCTION _timescaledb_internal.policy_reorder_check(jsonb); DROP FUNCTION _timescaledb_internal.policy_retention_check(jsonb); DROP FUNCTION _timescaledb_internal.process_ddl_event(); DROP FUNCTION _timescaledb_internal.range_value_to_pretty(bigint,regtype); DROP FUNCTION _timescaledb_internal.recompress_chunk_segmentwise(regclass,boolean); DROP FUNCTION _timescaledb_internal.relation_size(regclass); DROP FUNCTION _timescaledb_internal.remote_txn_heal_data_node(oid); DROP FUNCTION _timescaledb_internal.set_chunk_default_data_node(regclass,name); DROP FUNCTION _timescaledb_internal.set_dist_id(uuid); DROP FUNCTION _timescaledb_internal.set_peer_dist_id(uuid); DROP FUNCTION _timescaledb_internal.show_chunk(regclass); DROP FUNCTION _timescaledb_internal.show_connection_cache(); DROP FUNCTION _timescaledb_internal.start_background_workers(); DROP FUNCTION _timescaledb_internal.stop_background_workers(); DROP FUNCTION _timescaledb_internal.subtract_integer_from_now(regclass,bigint); DROP FUNCTION _timescaledb_internal.time_to_internal(anyelement); DROP FUNCTION _timescaledb_internal.to_date(bigint); DROP FUNCTION _timescaledb_internal.to_interval(bigint); DROP FUNCTION _timescaledb_internal.to_timestamp(bigint); DROP FUNCTION _timescaledb_internal.to_timestamp_without_timezone(bigint); DROP FUNCTION _timescaledb_internal.to_unix_microseconds(timestamp with time zone); DROP FUNCTION _timescaledb_internal.tsl_loaded(); DROP FUNCTION _timescaledb_internal.unfreeze_chunk(regclass); DROP FUNCTION _timescaledb_internal.validate_as_data_node(); DROP PROCEDURE _timescaledb_internal.cagg_migrate_create_plan(_timescaledb_catalog.continuous_agg,text,boolean,boolean); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_copy_data(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_copy_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_create_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_disable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_enable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_override_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_plan(_timescaledb_catalog.continuous_agg); DROP PROCEDURE _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE _timescaledb_internal.policy_compression(integer,jsonb); DROP PROCEDURE _timescaledb_internal.policy_compression_execute(integer,integer,anyelement,integer,boolean,boolean); DROP PROCEDURE _timescaledb_internal.policy_recompression(integer,jsonb); DROP PROCEDURE _timescaledb_internal.policy_refresh_continuous_aggregate(integer,jsonb); DROP PROCEDURE _timescaledb_internal.policy_reorder(integer,jsonb); DROP PROCEDURE _timescaledb_internal.policy_retention(integer,jsonb); DROP PROCEDURE _timescaledb_internal.wait_subscription_sync(name,name,integer,numeric); DROP FUNCTION IF EXISTS @extschema@.alter_job( INTEGER, INTERVAL, INTERVAL, INTEGER, INTERVAL, BOOL, JSONB, TIMESTAMPTZ, BOOL, REGPROC, BOOL, TIMESTAMPTZ, TEXT ); CREATE FUNCTION @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL = NULL, max_runtime INTERVAL = NULL, max_retries INTEGER = NULL, retry_period INTERVAL = NULL, scheduled BOOL = NULL, config JSONB = NULL, next_start TIMESTAMPTZ = NULL, if_exists BOOL = FALSE, check_config REGPROC = NULL ) RETURNS TABLE (job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, check_config TEXT) AS '@MODULE_PATHNAME@', 'ts_job_alter' LANGUAGE C VOLATILE; ALTER FUNCTION _timescaledb_functions.insert_blocker() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.continuous_agg_invalidation_trigger() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.drop_dist_ht_invalidation_trigger(integer) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_create_command(name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.to_unix_microseconds(timestamptz) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.to_timestamp(bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.to_timestamp_without_timezone(bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.to_date(bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.to_interval(bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.interval_to_usec(interval) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.time_to_internal(anyelement) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.subtract_integer_from_now(regclass, bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.set_dist_id(uuid) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.set_peer_dist_id(uuid) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.validate_as_data_node() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.show_connection_cache() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.ping_data_node(name, interval) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.remote_txn_heal_data_node(oid) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.relation_size(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.data_node_hypertable_info(name, name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.data_node_chunk_info(name, name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hypertable_local_size(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hypertable_remote_size(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunks_local_size(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunks_remote_size(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.range_value_to_pretty(bigint, regtype) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_approx_row_count(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.data_node_compressed_chunk_stats(name, name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.compressed_chunk_local_stats(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.compressed_chunk_remote_stats(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.indexes_local_size(name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.data_node_index_size(name, name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.indexes_remote_size(name, name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.generate_uuid() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_git_commit() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_os_info() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.tsl_loaded() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.calculate_chunk_interval(int, bigint, bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunk_status(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunks_in(record, integer[]) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunk_id_from_relid(oid) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.show_chunk(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.create_chunk(regclass, jsonb, name, name, regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.set_chunk_default_data_node(regclass, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_chunk_relstats(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_chunk_colstats(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.create_chunk_table(regclass, jsonb, name, name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.freeze_chunk(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.unfreeze_chunk(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.drop_chunk(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.attach_osm_table_chunk(regclass, regclass) SET SCHEMA _timescaledb_internal; UPDATE _timescaledb_catalog.hypertable SET chunk_sizing_func_schema = '_timescaledb_internal' WHERE chunk_sizing_func_schema = '_timescaledb_functions' AND chunk_sizing_func_name = 'calculate_chunk_interval'; ALTER FUNCTION _timescaledb_functions.policy_compression_check(jsonb) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.policy_compression_execute(integer,integer,anyelement,integer,boolean,boolean) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.policy_compression(integer,jsonb) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.policy_job_error_retention_check(jsonb) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.policy_job_error_retention(integer,jsonb) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.policy_recompression(integer,jsonb) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.policy_refresh_continuous_aggregate_check(jsonb) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.policy_refresh_continuous_aggregate(integer,jsonb) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.policy_reorder_check(jsonb) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.policy_reorder(integer,jsonb) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.policy_retention_check(jsonb) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.policy_retention(integer,jsonb) SET SCHEMA _timescaledb_internal; UPDATE _timescaledb_config.bgw_job SET proc_schema = '_timescaledb_internal' WHERE proc_schema = '_timescaledb_functions'; UPDATE _timescaledb_config.bgw_job SET check_schema = '_timescaledb_internal' WHERE check_schema = '_timescaledb_functions'; ALTER FUNCTION _timescaledb_functions.cagg_migrate_plan_exists(INTEGER) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.cagg_migrate_pre_validation(TEXT, TEXT, TEXT) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_create_plan(_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_create_new_cagg(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_disable_policies(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_enable_policies(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_copy_policies(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_refresh_new_cagg(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_copy_data(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_override_cagg(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_drop_old_cagg(_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.cagg_migrate_execute_plan(_timescaledb_catalog.continuous_agg) SET SCHEMA _timescaledb_internal; -- pre-update of previous version will have created an additional copy of restart_background_workers -- since restart_background_workers was handled differently from other functions in previous versions DROP FUNCTION _timescaledb_internal.restart_background_workers(); ALTER FUNCTION _timescaledb_functions.start_background_workers() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.stop_background_workers() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.restart_background_workers() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.alter_job_set_hypertable_id(integer,regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.cagg_watermark(integer) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.cagg_watermark_materialized(integer) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hypertable_invalidation_log_delete(integer) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.invalidation_cagg_log_add_entry(integer,bigint,bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.invalidation_hyper_log_add_entry(integer,bigint,bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[]) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[],text[]) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[]) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[],text[]) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.materialization_invalidation_log_delete(integer) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunk_constraint_add_table_constraint(_timescaledb_catalog.chunk_constraint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunk_drop_replica(regclass,name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunk_index_clone(oid) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.chunk_index_replace(oid,oid) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.create_chunk_replica_table(regclass,name) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.create_compressed_chunk(regclass,regclass,bigint,bigint,bigint,bigint,bigint,bigint,bigint,bigint) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.drop_stale_chunks(name,integer[]) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_compressed_chunk_index_for_recompression(regclass) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.health() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.hypertable_constraint_add_table_fk_constraint(name,name,name,integer) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.process_ddl_event() SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.recompress_chunk_segmentwise(regclass,boolean) SET SCHEMA _timescaledb_internal; ALTER PROCEDURE _timescaledb_functions.wait_subscription_sync(name,name,integer,numeric) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_partition_for_key(val anyelement) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.get_partition_hash(val anyelement) SET SCHEMA _timescaledb_internal; UPDATE _timescaledb_catalog.dimension SET partitioning_func_schema = '_timescaledb_internal' WHERE partitioning_func_schema = '_timescaledb_functions' AND partitioning_func IN ('get_partition_for_key','get_partition_hash'); ALTER FUNCTION _timescaledb_functions.finalize_agg_ffunc(internal,text,name,name,name[],bytea,anyelement) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.finalize_agg_sfunc(internal,text,name,name,name[],bytea,anyelement) SET SCHEMA _timescaledb_internal; ALTER FUNCTION _timescaledb_functions.partialize_agg(anyelement) SET SCHEMA _timescaledb_internal; ALTER AGGREGATE _timescaledb_functions.finalize_agg(text,name,name,name[][],bytea,anyelement) SET SCHEMA _timescaledb_internal; DROP FUNCTION _timescaledb_functions.hypertable_osm_range_update(regclass, anyelement, anyelement, boolean); -- recreate the _timescaledb_catalog.hypertable table as new field was added -- 1. drop CONSTRAINTS from other tables referencing the existing one ALTER TABLE _timescaledb_config.bgw_job DROP CONSTRAINT bgw_job_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk DROP CONSTRAINT chunk_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT chunk_index_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_agg DROP CONSTRAINT continuous_agg_mat_hypertable_id_fkey, DROP CONSTRAINT continuous_agg_raw_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function DROP CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold DROP CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.dimension DROP CONSTRAINT dimension_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable DROP CONSTRAINT hypertable_compressed_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable_compression DROP CONSTRAINT hypertable_compression_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable_data_node DROP CONSTRAINT hypertable_data_node_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.tablespace DROP CONSTRAINT tablespace_hypertable_id_fkey; -- drop dependent views ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.hypertables; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.job_stats; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.jobs; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.continuous_aggregates; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.chunks; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.dimensions; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.compression_settings; ALTER EXTENSION timescaledb DROP VIEW _timescaledb_internal.hypertable_chunk_local_size; ALTER EXTENSION timescaledb DROP VIEW _timescaledb_internal.compressed_chunk_stats; ALTER EXTENSION timescaledb DROP VIEW timescaledb_experimental.chunk_replication_status; ALTER EXTENSION timescaledb DROP VIEW timescaledb_experimental.policies; DROP VIEW timescaledb_information.hypertables; DROP VIEW timescaledb_information.job_stats; DROP VIEW timescaledb_information.jobs; DROP VIEW timescaledb_information.continuous_aggregates; DROP VIEW timescaledb_information.chunks; DROP VIEW timescaledb_information.dimensions; DROP VIEW timescaledb_information.compression_settings; DROP VIEW _timescaledb_internal.hypertable_chunk_local_size; DROP VIEW _timescaledb_internal.compressed_chunk_stats; DROP VIEW timescaledb_experimental.chunk_replication_status; DROP VIEW timescaledb_experimental.policies; -- recreate table CREATE TABLE _timescaledb_catalog.hypertable_tmp AS SELECT * FROM _timescaledb_catalog.hypertable; CREATE TABLE _timescaledb_catalog.tmp_hypertable_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.hypertable_id_seq; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.hypertable_id_seq; SET timescaledb.restoring = on; -- must disable the hooks otherwise we can't do anything without the table _timescaledb_catalog.hypertable DROP TABLE _timescaledb_catalog.hypertable; CREATE SEQUENCE _timescaledb_catalog.hypertable_id_seq MINVALUE 1; SELECT setval('_timescaledb_catalog.hypertable_id_seq', last_value, is_called) FROM _timescaledb_catalog.tmp_hypertable_seq_value; DROP TABLE _timescaledb_catalog.tmp_hypertable_seq_value; CREATE TABLE _timescaledb_catalog.hypertable ( id INTEGER PRIMARY KEY NOT NULL DEFAULT nextval('_timescaledb_catalog.hypertable_id_seq'), schema_name name NOT NULL, table_name name NOT NULL, associated_schema_name name NOT NULL, associated_table_prefix name NOT NULL, num_dimensions smallint NOT NULL, chunk_sizing_func_schema name NOT NULL, chunk_sizing_func_name name NOT NULL, chunk_target_size bigint NOT NULL, -- size in bytes compression_state smallint NOT NULL DEFAULT 0, compressed_hypertable_id integer, replication_factor smallint NULL ); SET timescaledb.restoring = off; INSERT INTO _timescaledb_catalog.hypertable ( id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, replication_factor ) SELECT id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, replication_factor FROM _timescaledb_catalog.hypertable_tmp ORDER BY id; ALTER SEQUENCE _timescaledb_catalog.hypertable_id_seq OWNED BY _timescaledb_catalog.hypertable.id; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable', 'WHERE id >= 1'); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_id_seq', ''); GRANT SELECT ON _timescaledb_catalog.hypertable TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.hypertable_id_seq TO PUBLIC; DROP TABLE _timescaledb_catalog.hypertable_tmp; -- now add any constraints ALTER TABLE _timescaledb_catalog.hypertable -- ADD CONSTRAINT hypertable_pkey PRIMARY KEY (id), ADD CONSTRAINT hypertable_associated_schema_name_associated_table_prefix_key UNIQUE (associated_schema_name, associated_table_prefix), ADD CONSTRAINT hypertable_table_name_schema_name_key UNIQUE (table_name, schema_name), ADD CONSTRAINT hypertable_schema_name_check CHECK (schema_name != '_timescaledb_catalog'), -- internal compressed hypertables have compression state = 2 ADD CONSTRAINT hypertable_dim_compress_check CHECK (num_dimensions > 0 OR compression_state = 2), ADD CONSTRAINT hypertable_chunk_target_size_check CHECK (chunk_target_size >= 0), ADD CONSTRAINT hypertable_compress_check CHECK ( (compression_state = 0 OR compression_state = 1 ) OR (compression_state = 2 AND compressed_hypertable_id IS NULL)), -- replication_factor NULL: regular hypertable -- replication_factor > 0: distributed hypertable on access node -- replication_factor -1: distributed hypertable on data node, which is part of a larger table ADD CONSTRAINT hypertable_replication_factor_check CHECK (replication_factor > 0 OR replication_factor = -1), ADD CONSTRAINT hypertable_compressed_hypertable_id_fkey FOREIGN KEY (compressed_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id); GRANT SELECT ON TABLE _timescaledb_catalog.hypertable TO PUBLIC; -- 3. reestablish constraints on other tables ALTER TABLE _timescaledb_config.bgw_job ADD CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT chunk_index_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_agg ADD CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE, ADD CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function ADD CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ADD CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.dimension ADD CONSTRAINT dimension_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.hypertable_compression ADD CONSTRAINT hypertable_compression_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.hypertable_data_node ADD CONSTRAINT hypertable_data_node_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.tablespace ADD CONSTRAINT tablespace_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.12.0-2.12.1.sql����������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020265�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.12.1--2.12.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.12.1--2.12.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.12.2--2.12.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.12.2--2.13.0.sql���������������������������������������������������0000664�0000000�0000000�00000045027�15100345067�0020366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TYPE _timescaledb_internal.dimension_info; CREATE OR REPLACE FUNCTION _timescaledb_functions.dimension_info_in(cstring) RETURNS _timescaledb_internal.dimension_info LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_dimension_info_in'; CREATE OR REPLACE FUNCTION _timescaledb_functions.dimension_info_out(_timescaledb_internal.dimension_info) RETURNS cstring LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_dimension_info_out'; CREATE TYPE _timescaledb_internal.dimension_info ( INPUT = _timescaledb_functions.dimension_info_in, OUTPUT = _timescaledb_functions.dimension_info_out, INTERNALLENGTH = VARIABLE ); CREATE FUNCTION @extschema@.create_hypertable( relation REGCLASS, dimension _timescaledb_internal.dimension_info, create_default_indexes BOOLEAN = TRUE, if_not_exists BOOLEAN = FALSE, migrate_data BOOLEAN = FALSE ) RETURNS TABLE(hypertable_id INT, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_create_general' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.add_dimension( hypertable REGCLASS, dimension _timescaledb_internal.dimension_info, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(dimension_id INT, created BOOL) AS '@MODULE_PATHNAME@', 'ts_dimension_add_general' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.set_partitioning_interval( hypertable REGCLASS, partition_interval ANYELEMENT, dimension_name NAME = NULL ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_dimension_set_interval' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.by_hash(column_name NAME, number_partitions INTEGER, partition_func regproc = NULL) RETURNS _timescaledb_internal.dimension_info LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_hash_dimension'; CREATE FUNCTION @extschema@.by_range(column_name NAME, partition_interval ANYELEMENT = NULL::bigint, partition_func regproc = NULL) RETURNS _timescaledb_internal.dimension_info LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_range_dimension'; -- -- Rebuild the catalog table `_timescaledb_catalog.chunk` to -- add new column `creation_time` -- CREATE TABLE _timescaledb_internal.chunk_tmp AS SELECT * from _timescaledb_catalog.chunk; CREATE TABLE _timescaledb_internal.tmp_chunk_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.chunk_id_seq; --drop foreign keys on chunk table ALTER TABLE _timescaledb_catalog.chunk_constraint DROP CONSTRAINT chunk_constraint_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT chunk_index_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_data_node DROP CONSTRAINT chunk_data_node_chunk_id_fkey; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats DROP CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT compression_chunk_size_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_copy_operation DROP CONSTRAINT chunk_copy_operation_chunk_id_fkey; --drop dependent views DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.chunks; DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size; DROP VIEW IF EXISTS _timescaledb_internal.compressed_chunk_stats; DROP VIEW IF EXISTS timescaledb_experimental.chunk_replication_status; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.chunk_id_seq; DROP TABLE _timescaledb_catalog.chunk; CREATE SEQUENCE _timescaledb_catalog.chunk_id_seq MINVALUE 1; -- now create table without self referential foreign key CREATE TABLE _timescaledb_catalog.chunk ( id integer NOT NULL DEFAULT nextval('_timescaledb_catalog.chunk_id_seq'), hypertable_id int NOT NULL, schema_name name NOT NULL, table_name name NOT NULL, compressed_chunk_id integer , dropped boolean NOT NULL DEFAULT FALSE, status integer NOT NULL DEFAULT 0, osm_chunk boolean NOT NULL DEFAULT FALSE, creation_time timestamptz, -- table constraints CONSTRAINT chunk_pkey PRIMARY KEY (id), CONSTRAINT chunk_schema_name_table_name_key UNIQUE (schema_name, table_name) ); INSERT INTO _timescaledb_catalog.chunk ( id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk) SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_internal.chunk_tmp; -- update creation_time for chunks UPDATE _timescaledb_catalog.chunk c SET creation_time = (pg_catalog.pg_stat_file(pg_catalog.pg_relation_filepath(r.oid))).modification FROM pg_class r, pg_namespace n WHERE r.relnamespace = n.oid AND r.relname = c.table_name AND n.nspname = c.schema_name AND r.relkind = 'r' AND c.dropped IS FALSE; -- Make sure that there are no record with empty creation time UPDATE _timescaledb_catalog.chunk SET creation_time = now() WHERE creation_time IS NULL; --add indexes to the chunk table CREATE INDEX chunk_hypertable_id_idx ON _timescaledb_catalog.chunk (hypertable_id); CREATE INDEX chunk_compressed_chunk_id_idx ON _timescaledb_catalog.chunk (compressed_chunk_id); CREATE INDEX chunk_osm_chunk_idx ON _timescaledb_catalog.chunk (osm_chunk, hypertable_id); CREATE INDEX chunk_hypertable_id_creation_time_idx ON _timescaledb_catalog.chunk(hypertable_id, creation_time); ALTER SEQUENCE _timescaledb_catalog.chunk_id_seq OWNED BY _timescaledb_catalog.chunk.id; SELECT setval('_timescaledb_catalog.chunk_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_chunk_seq_value; -- add self referential foreign key ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_compressed_chunk_id_fkey FOREIGN KEY ( compressed_chunk_id ) REFERENCES _timescaledb_catalog.chunk( id ); --add foreign key constraint ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_id_seq', ''); -- Add non-null constraint ALTER TABLE _timescaledb_catalog.chunk ALTER COLUMN creation_time SET NOT NULL; --add the foreign key constraints ALTER TABLE _timescaledb_catalog.chunk_constraint ADD CONSTRAINT chunk_constraint_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id); ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT chunk_index_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk_data_node ADD CONSTRAINT chunk_data_node_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id); ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats ADD CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT compression_chunk_size_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk_copy_operation ADD CONSTRAINT chunk_copy_operation_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE; --cleanup DROP TABLE _timescaledb_internal.chunk_tmp; DROP TABLE _timescaledb_internal.tmp_chunk_seq_value; GRANT SELECT ON _timescaledb_catalog.chunk_id_seq TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.chunk TO PUBLIC; -- end recreate _timescaledb_catalog.chunk table -- -- -- Rebuild the catalog table `_timescaledb_catalog.compression_chunk_size` to -- add new column `numrows_frozen_immediately` -- CREATE TABLE _timescaledb_internal.compression_chunk_size_tmp AS SELECT * from _timescaledb_catalog.compression_chunk_size; -- Drop depended views -- We assume that '_timescaledb_internal.compressed_chunk_stats' was already dropped in this update -- (see above) -- Drop table ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_chunk_size; DROP TABLE _timescaledb_catalog.compression_chunk_size; CREATE TABLE _timescaledb_catalog.compression_chunk_size ( chunk_id integer NOT NULL, compressed_chunk_id integer NOT NULL, uncompressed_heap_size bigint NOT NULL, uncompressed_toast_size bigint NOT NULL, uncompressed_index_size bigint NOT NULL, compressed_heap_size bigint NOT NULL, compressed_toast_size bigint NOT NULL, compressed_index_size bigint NOT NULL, numrows_pre_compression bigint, numrows_post_compression bigint, numrows_frozen_immediately bigint, -- table constraints CONSTRAINT compression_chunk_size_pkey PRIMARY KEY (chunk_id), CONSTRAINT compression_chunk_size_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE, CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.compression_chunk_size (chunk_id, compressed_chunk_id, uncompressed_heap_size, uncompressed_toast_size, uncompressed_index_size, compressed_heap_size, compressed_toast_size, compressed_index_size, numrows_pre_compression, numrows_post_compression, numrows_frozen_immediately) SELECT chunk_id, compressed_chunk_id, uncompressed_heap_size, uncompressed_toast_size, uncompressed_index_size, compressed_heap_size, compressed_toast_size, compressed_index_size, numrows_pre_compression, numrows_post_compression, 0 FROM _timescaledb_internal.compression_chunk_size_tmp; DROP TABLE _timescaledb_internal.compression_chunk_size_tmp; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_chunk_size', ''); GRANT SELECT ON _timescaledb_catalog.compression_chunk_size TO PUBLIC; -- End modify `_timescaledb_catalog.compression_chunk_size` DROP FUNCTION @extschema@.drop_chunks(REGCLASS, "any", "any", BOOL); CREATE FUNCTION @extschema@.drop_chunks( relation REGCLASS, older_than "any" = NULL, newer_than "any" = NULL, verbose BOOLEAN = FALSE, created_before "any" = NULL, created_after "any" = NULL ) RETURNS SETOF TEXT AS '@MODULE_PATHNAME@', 'ts_chunk_drop_chunks' LANGUAGE C VOLATILE PARALLEL UNSAFE; DROP FUNCTION @extschema@.show_chunks(REGCLASS, "any", "any"); CREATE FUNCTION @extschema@.show_chunks( relation REGCLASS, older_than "any" = NULL, newer_than "any" = NULL, created_before "any" = NULL, created_after "any" = NULL ) RETURNS SETOF REGCLASS AS '@MODULE_PATHNAME@', 'ts_chunk_show_chunks' LANGUAGE C STABLE PARALLEL SAFE; DROP FUNCTION @extschema@.add_retention_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT); CREATE FUNCTION @extschema@.add_retention_policy( relation REGCLASS, drop_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, drop_created_before INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_retention_add' LANGUAGE C VOLATILE; DROP FUNCTION @extschema@.add_compression_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT); CREATE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, compress_created_before INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_compression_add' LANGUAGE C VOLATILE; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute(INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN); DROP PROCEDURE IF EXISTS _timescaledb_internal.policy_compression_execute(INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN); CREATE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, use_creation_time BOOLEAN) AS $$ DECLARE htoid REGCLASS; chunk_rec RECORD; numchunks INTEGER := 1; _message text; _detail text; -- chunk status bits: bit_compressed int := 1; bit_compressed_unordered int := 2; bit_frozen int := 4; bit_compressed_partial int := 8; creation_lag INTERVAL := NULL; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; SELECT format('%I.%I', schema_name, table_name) INTO htoid FROM _timescaledb_catalog.hypertable WHERE id = htid; -- for the integer cases, we have to compute the lag w.r.t -- the integer_now function and then pass on to show_chunks IF pg_typeof(lag) IN ('BIGINT'::regtype, 'INTEGER'::regtype, 'SMALLINT'::regtype) THEN -- cannot have use_creation_time set with this IF use_creation_time IS TRUE THEN RAISE EXCEPTION 'job % cannot use creation time with integer_now function', job_id; END IF; lag := _timescaledb_functions.subtract_integer_from_now(htoid, lag::BIGINT); END IF; -- if use_creation_time has been specified then the lag needs to be used with the -- "compress_created_before" argument. Otherwise the usual "older_than" argument -- is good enough IF use_creation_time IS TRUE THEN creation_lag := lag; lag := NULL; END IF; FOR chunk_rec IN SELECT show.oid, ch.schema_name, ch.table_name, ch.status FROM @extschema@.show_chunks(htoid, older_than => lag, created_before => creation_lag) AS show(oid) INNER JOIN pg_class pgc ON pgc.oid = show.oid INNER JOIN pg_namespace pgns ON pgc.relnamespace = pgns.oid INNER JOIN _timescaledb_catalog.chunk ch ON ch.table_name = pgc.relname AND ch.schema_name = pgns.nspname AND ch.hypertable_id = htid WHERE ch.dropped IS FALSE AND ( ch.status = 0 OR ( ch.status & bit_compressed > 0 AND ( ch.status & bit_compressed_unordered > 0 OR ch.status & bit_compressed_partial > 0 ) ) ) LOOP IF chunk_rec.status = 0 THEN BEGIN PERFORM @extschema@.compress_chunk( chunk_rec.oid ); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS _message = MESSAGE_TEXT, _detail = PG_EXCEPTION_DETAIL; RAISE WARNING 'compressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = sqlstate; END; ELSIF ( chunk_rec.status & bit_compressed > 0 AND ( chunk_rec.status & bit_compressed_unordered > 0 OR chunk_rec.status & bit_compressed_partial > 0 ) ) AND recompress_enabled IS TRUE THEN BEGIN PERFORM @extschema@.decompress_chunk(chunk_rec.oid, if_compressed => true); EXCEPTION WHEN OTHERS THEN RAISE WARNING 'decompressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = sqlstate; END; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT BEGIN PERFORM @extschema@.compress_chunk(chunk_rec.oid); EXCEPTION WHEN OTHERS THEN RAISE WARNING 'compressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = sqlstate; END; END IF; COMMIT; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; IF verbose_log THEN RAISE LOG 'job % completed processing chunk %.%', job_id, chunk_rec.schema_name, chunk_rec.table_name; END IF; numchunks := numchunks + 1; IF maxchunks > 0 AND numchunks >= maxchunks THEN EXIT; END IF; END LOOP; END; $$ LANGUAGE PLPGSQL; -- fix atttypmod and attcollation for segmentby columns DO $$ DECLARE htc_id INTEGER; htc REGCLASS; _attname NAME; _atttypmod INTEGER; _attcollation OID; BEGIN -- find any segmentby columns where typmod and collation in -- the compressed hypertable does not match the uncompressed -- hypertable values FOR htc_id, htc, _attname, _atttypmod, _attcollation IN SELECT cat.htc_id, cat.htc, pga.attname, ht_mod, ht_coll FROM pg_attribute pga INNER JOIN ( SELECT htc.id AS htc_id, format('%I.%I',htc.schema_name,htc.table_name) AS htc, att_ht.atttypmod AS ht_mod, att_ht.attcollation AS ht_coll, c.attname FROM _timescaledb_catalog.hypertable_compression c INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=c.hypertable_id INNER JOIN pg_attribute att_ht ON att_ht.attname = c.attname AND att_ht.attrelid = format('%I.%I',ht.schema_name,ht.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable htc ON htc.id=ht.compressed_hypertable_id WHERE c.segmentby_column_index > 0 ) cat ON cat.htc::regclass = pga.attrelid AND cat.attname = pga.attname WHERE pga.atttypmod <> ht_mod OR pga.attcollation <> ht_coll LOOP -- fix typmod and collation for the compressed hypertable and all compressed chunks UPDATE pg_attribute SET atttypmod = _atttypmod, attcollation = _attcollation WHERE attname = _attname AND attrelid IN ( SELECT format('%I.%I',schema_name,table_name)::regclass from _timescaledb_catalog.chunk WHERE hypertable_id = htc_id AND NOT dropped UNION ALL SELECT htc ); END LOOP; END $$; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.13.0--2.12.2.sql���������������������������������������������������0000664�0000000�0000000�00000042113�15100345067�0020357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- API changes related to hypertable generalization DROP FUNCTION IF EXISTS @extschema@.add_dimension(regclass,dimension_info,boolean); DROP FUNCTION IF EXISTS @extschema@.create_hypertable(regclass,dimension_info,boolean,boolean,boolean); DROP FUNCTION IF EXISTS @extschema@.set_partitioning_interval(regclass,anyelement,name); DROP FUNCTION IF EXISTS @extschema@.by_hash(name,integer,regproc); DROP FUNCTION IF EXISTS @extschema@.by_range(name,anyelement,regproc); DROP TYPE IF EXISTS _timescaledb_internal.dimension_info CASCADE; -- -- Rebuild the catalog table `_timescaledb_catalog.chunk` -- -- We need to recreate the catalog from scratch because when we drop a column -- Postgres marks `pg_attribute.attisdropped=TRUE` instead of removing it from -- the `pg_catalog.pg_attribute` table. -- -- If we downgrade and upgrade the extension without rebuilding the catalog table it -- will mess up `pg_attribute.attnum` and we will end up with issues when trying -- to update data in those catalog tables. -- Recreate _timescaledb_catalog.chunk table -- CREATE TABLE _timescaledb_internal.chunk_tmp AS SELECT * from _timescaledb_catalog.chunk; CREATE TABLE _timescaledb_internal.tmp_chunk_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.chunk_id_seq; --drop foreign keys on chunk table ALTER TABLE _timescaledb_catalog.chunk_constraint DROP CONSTRAINT chunk_constraint_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT chunk_index_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_data_node DROP CONSTRAINT chunk_data_node_chunk_id_fkey; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats DROP CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT compression_chunk_size_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_copy_operation DROP CONSTRAINT chunk_copy_operation_chunk_id_fkey; --drop dependent views DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.chunks; DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size; DROP VIEW IF EXISTS _timescaledb_internal.compressed_chunk_stats; DROP VIEW IF EXISTS timescaledb_experimental.chunk_replication_status; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.chunk_id_seq; DROP TABLE _timescaledb_catalog.chunk; CREATE SEQUENCE _timescaledb_catalog.chunk_id_seq MINVALUE 1; -- now create table without self referential foreign key CREATE TABLE _timescaledb_catalog.chunk ( id integer NOT NULL DEFAULT nextval('_timescaledb_catalog.chunk_id_seq'), hypertable_id int NOT NULL, schema_name name NOT NULL, table_name name NOT NULL, compressed_chunk_id integer , dropped boolean NOT NULL DEFAULT FALSE, status integer NOT NULL DEFAULT 0, osm_chunk boolean NOT NULL DEFAULT FALSE, -- table constraints CONSTRAINT chunk_pkey PRIMARY KEY (id), CONSTRAINT chunk_schema_name_table_name_key UNIQUE (schema_name, table_name) ); INSERT INTO _timescaledb_catalog.chunk ( id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk) SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_internal.chunk_tmp; --add indexes to the chunk table CREATE INDEX chunk_hypertable_id_idx ON _timescaledb_catalog.chunk (hypertable_id); CREATE INDEX chunk_compressed_chunk_id_idx ON _timescaledb_catalog.chunk (compressed_chunk_id); CREATE INDEX chunk_osm_chunk_idx ON _timescaledb_catalog.chunk (osm_chunk, hypertable_id); ALTER SEQUENCE _timescaledb_catalog.chunk_id_seq OWNED BY _timescaledb_catalog.chunk.id; SELECT setval('_timescaledb_catalog.chunk_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_chunk_seq_value; -- add self referential foreign key ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_compressed_chunk_id_fkey FOREIGN KEY ( compressed_chunk_id ) REFERENCES _timescaledb_catalog.chunk( id ); --add foreign key constraint ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_id_seq', ''); --add the foreign key constraints ALTER TABLE _timescaledb_catalog.chunk_constraint ADD CONSTRAINT chunk_constraint_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id); ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT chunk_index_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk_data_node ADD CONSTRAINT chunk_data_node_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id); ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats ADD CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT compression_chunk_size_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk_copy_operation ADD CONSTRAINT chunk_copy_operation_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE; --cleanup DROP TABLE _timescaledb_internal.chunk_tmp; DROP TABLE _timescaledb_internal.tmp_chunk_seq_value; GRANT SELECT ON _timescaledb_catalog.chunk_id_seq TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.chunk TO PUBLIC; -- end recreate _timescaledb_catalog.chunk table -- -- -- Rebuild the catalog table `_timescaledb_catalog.compression_chunk_size` to -- remove column `numrows_frozen_immediately` -- CREATE TABLE _timescaledb_internal.compression_chunk_size_tmp AS SELECT * from _timescaledb_catalog.compression_chunk_size; -- Drop depended views -- We assume that '_timescaledb_internal.compressed_chunk_stats' was already dropped in this update -- (see above) -- Drop table ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_chunk_size; DROP TABLE _timescaledb_catalog.compression_chunk_size; CREATE TABLE _timescaledb_catalog.compression_chunk_size ( chunk_id integer NOT NULL, compressed_chunk_id integer NOT NULL, uncompressed_heap_size bigint NOT NULL, uncompressed_toast_size bigint NOT NULL, uncompressed_index_size bigint NOT NULL, compressed_heap_size bigint NOT NULL, compressed_toast_size bigint NOT NULL, compressed_index_size bigint NOT NULL, numrows_pre_compression bigint, numrows_post_compression bigint, -- table constraints CONSTRAINT compression_chunk_size_pkey PRIMARY KEY (chunk_id), CONSTRAINT compression_chunk_size_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE, CONSTRAINT compression_chunk_size_compressed_chunk_id_fkey FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.compression_chunk_size (chunk_id, compressed_chunk_id, uncompressed_heap_size, uncompressed_toast_size, uncompressed_index_size, compressed_heap_size, compressed_toast_size, compressed_index_size, numrows_pre_compression, numrows_post_compression) SELECT chunk_id, compressed_chunk_id, uncompressed_heap_size, uncompressed_toast_size, uncompressed_index_size, compressed_heap_size, compressed_toast_size, compressed_index_size, numrows_pre_compression, numrows_post_compression FROM _timescaledb_internal.compression_chunk_size_tmp; DROP TABLE _timescaledb_internal.compression_chunk_size_tmp; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_chunk_size', ''); GRANT SELECT ON _timescaledb_catalog.compression_chunk_size TO PUBLIC; -- End modify `_timescaledb_catalog.compression_chunk_size` DROP FUNCTION @extschema@.drop_chunks(REGCLASS, "any", "any", BOOL, "any", "any"); CREATE FUNCTION @extschema@.drop_chunks( relation REGCLASS, older_than "any" = NULL, newer_than "any" = NULL, verbose BOOLEAN = FALSE ) RETURNS SETOF TEXT AS '@MODULE_PATHNAME@', 'ts_chunk_drop_chunks' LANGUAGE C VOLATILE PARALLEL UNSAFE; DROP FUNCTION @extschema@.show_chunks(REGCLASS, "any", "any", "any", "any"); CREATE FUNCTION @extschema@.show_chunks( relation REGCLASS, older_than "any" = NULL, newer_than "any" = NULL ) RETURNS SETOF REGCLASS AS '@MODULE_PATHNAME@', 'ts_chunk_show_chunks' LANGUAGE C STABLE PARALLEL SAFE; DROP PROCEDURE IF EXISTS _timescaledb_functions.repair_relation_acls(); DROP FUNCTION IF EXISTS _timescaledb_functions.makeaclitem(regrole, regrole, text, bool); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_validate_query(TEXT); DROP FUNCTION @extschema@.add_retention_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT, INTERVAL); CREATE FUNCTION @extschema@.add_retention_policy( relation REGCLASS, drop_after "any", if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_retention_add' LANGUAGE C VOLATILE; DROP FUNCTION @extschema@.add_compression_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT, INTERVAL); CREATE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any", if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_compression_add' LANGUAGE C VOLATILE; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute(INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN, BOOLEAN); DROP PROCEDURE IF EXISTS _timescaledb_internal.policy_compression_execute(INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN, BOOLEAN); CREATE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN) AS $$ DECLARE htoid REGCLASS; chunk_rec RECORD; numchunks INTEGER := 1; _message text; _detail text; -- chunk status bits: bit_compressed int := 1; bit_compressed_unordered int := 2; bit_frozen int := 4; bit_compressed_partial int := 8; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; SELECT format('%I.%I', schema_name, table_name) INTO htoid FROM _timescaledb_catalog.hypertable WHERE id = htid; -- for the integer cases, we have to compute the lag w.r.t -- the integer_now function and then pass on to show_chunks IF pg_typeof(lag) IN ('BIGINT'::regtype, 'INTEGER'::regtype, 'SMALLINT'::regtype) THEN lag := _timescaledb_functions.subtract_integer_from_now(htoid, lag::BIGINT); END IF; FOR chunk_rec IN SELECT show.oid, ch.schema_name, ch.table_name, ch.status FROM @extschema@.show_chunks(htoid, older_than => lag) AS show(oid) INNER JOIN pg_class pgc ON pgc.oid = show.oid INNER JOIN pg_namespace pgns ON pgc.relnamespace = pgns.oid INNER JOIN _timescaledb_catalog.chunk ch ON ch.table_name = pgc.relname AND ch.schema_name = pgns.nspname AND ch.hypertable_id = htid WHERE ch.dropped IS FALSE AND ( ch.status = 0 OR ( ch.status & bit_compressed > 0 AND ( ch.status & bit_compressed_unordered > 0 OR ch.status & bit_compressed_partial > 0 ) ) ) LOOP IF chunk_rec.status = 0 THEN BEGIN PERFORM @extschema@.compress_chunk( chunk_rec.oid ); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS _message = MESSAGE_TEXT, _detail = PG_EXCEPTION_DETAIL; RAISE WARNING 'compressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = sqlstate; END; ELSIF ( chunk_rec.status & bit_compressed > 0 AND ( chunk_rec.status & bit_compressed_unordered > 0 OR chunk_rec.status & bit_compressed_partial > 0 ) ) AND recompress_enabled IS TRUE THEN BEGIN PERFORM @extschema@.decompress_chunk(chunk_rec.oid, if_compressed => true); EXCEPTION WHEN OTHERS THEN RAISE WARNING 'decompressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = sqlstate; END; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT BEGIN PERFORM @extschema@.compress_chunk(chunk_rec.oid); EXCEPTION WHEN OTHERS THEN RAISE WARNING 'compressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = sqlstate; END; END IF; COMMIT; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; IF verbose_log THEN RAISE LOG 'job % completed processing chunk %.%', job_id, chunk_rec.schema_name, chunk_rec.table_name; END IF; numchunks := numchunks + 1; IF maxchunks > 0 AND numchunks >= maxchunks THEN EXIT; END IF; END LOOP; END; $$ LANGUAGE PLPGSQL; DROP FUNCTION _timescaledb_functions.chunk_constraint_add_table_constraint( chunk_constraint_row _timescaledb_catalog.chunk_constraint ); CREATE FUNCTION _timescaledb_functions.chunk_constraint_add_table_constraint( chunk_constraint_row _timescaledb_catalog.chunk_constraint ) RETURNS VOID LANGUAGE PLPGSQL AS $BODY$ DECLARE chunk_row _timescaledb_catalog.chunk; hypertable_row _timescaledb_catalog.hypertable; constraint_oid OID; constraint_type CHAR; check_sql TEXT; def TEXT; indx_tablespace NAME; tablespace_def TEXT; BEGIN SELECT * INTO STRICT chunk_row FROM _timescaledb_catalog.chunk c WHERE c.id = chunk_constraint_row.chunk_id; SELECT * INTO STRICT hypertable_row FROM _timescaledb_catalog.hypertable h WHERE h.id = chunk_row.hypertable_id; IF chunk_constraint_row.dimension_slice_id IS NOT NULL THEN RAISE 'cannot create dimension constraint %', chunk_constraint_row; ELSIF chunk_constraint_row.hypertable_constraint_name IS NOT NULL THEN SELECT oid, contype INTO STRICT constraint_oid, constraint_type FROM pg_constraint WHERE conname=chunk_constraint_row.hypertable_constraint_name AND conrelid = format('%I.%I', hypertable_row.schema_name, hypertable_row.table_name)::regclass::oid; IF constraint_type IN ('p','u') THEN -- since primary keys and unique constraints are backed by an index -- they might have an index tablespace assigned -- the tablspace is not part of the constraint definition so -- we have to append it explicitly to preserve it SELECT T.spcname INTO indx_tablespace FROM pg_constraint C, pg_class I, pg_tablespace T WHERE C.oid = constraint_oid AND C.contype IN ('p', 'u') AND I.oid = C.conindid AND I.reltablespace = T.oid; def := pg_get_constraintdef(constraint_oid); IF indx_tablespace IS NOT NULL THEN def := format('%s USING INDEX TABLESPACE %I', def, indx_tablespace); END IF; ELSIF constraint_type = 't' THEN -- constraint triggers are copied separately with normal triggers def := NULL; ELSE def := pg_get_constraintdef(constraint_oid); END IF; ELSE RAISE 'unknown constraint type'; END IF; IF def IS NOT NULL THEN -- to allow for custom types with operators outside of pg_catalog -- we set search_path to @extschema@ SET LOCAL search_path TO @extschema@, pg_temp; EXECUTE pg_catalog.format( $$ ALTER TABLE %I.%I ADD CONSTRAINT %I %s $$, chunk_row.schema_name, chunk_row.table_name, chunk_constraint_row.constraint_name, def ); END IF; END $BODY$ SET search_path TO pg_catalog, pg_temp; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.13.0--2.13.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.13.1--2.13.0.sql���������������������������������������������������0000664�0000000�0000000�00000000400�15100345067�0020350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Manually drop the following functions / procedures since 'OR REPLACE' is missing in 2.13.0 DROP PROCEDURE IF EXISTS _timescaledb_functions.repair_relation_acls(); DROP FUNCTION IF EXISTS _timescaledb_functions.makeaclitem(regrole, regrole, text, bool); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.13.1--2.14.0.sql���������������������������������������������������0000664�0000000�0000000�00000055210�15100345067�0020362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ -- ERROR if trying to update the extension while multinode is present DO $$ DECLARE data_nodes TEXT; dist_hypertables TEXT; BEGIN SELECT string_agg(format('%I.%I', schema_name, table_name), ', ') INTO dist_hypertables FROM _timescaledb_catalog.hypertable WHERE replication_factor > 0; IF dist_hypertables IS NOT NULL THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'cannot upgrade because multi-node has been removed in 2.14.0', DETAIL = 'The following distributed hypertables should be migrated to regular: '||dist_hypertables; END IF; SELECT string_agg(format('%I', srv.srvname), ', ') INTO data_nodes FROM pg_foreign_server srv JOIN pg_foreign_data_wrapper fdw ON srv.srvfdw = fdw.oid AND fdw.fdwname = 'timescaledb_fdw'; IF data_nodes IS NOT NULL THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'cannot upgrade because multi-node has been removed in 2.14.0', DETAIL = 'The following data nodes should be removed: '||data_nodes; END IF; IF EXISTS(SELECT FROM _timescaledb_catalog.metadata WHERE key = 'dist_uuid') THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'cannot upgrade because multi-node has been removed in 2.14.0', DETAIL = 'This node appears to be part of a multi-node installation'; END IF; END $$; DROP FUNCTION IF EXISTS _timescaledb_functions.ping_data_node; DROP FUNCTION IF EXISTS _timescaledb_internal.ping_data_node; DROP FUNCTION IF EXISTS _timescaledb_functions.remote_txn_heal_data_node; DROP FUNCTION IF EXISTS _timescaledb_internal.remote_txn_heal_data_node; DROP FUNCTION IF EXISTS _timescaledb_functions.set_dist_id; DROP FUNCTION IF EXISTS _timescaledb_internal.set_dist_id; DROP FUNCTION IF EXISTS _timescaledb_functions.set_peer_dist_id; DROP FUNCTION IF EXISTS _timescaledb_internal.set_peer_dist_id; DROP FUNCTION IF EXISTS _timescaledb_functions.validate_as_data_node; DROP FUNCTION IF EXISTS _timescaledb_internal.validate_as_data_node; DROP FUNCTION IF EXISTS _timescaledb_functions.show_connection_cache; DROP FUNCTION IF EXISTS _timescaledb_internal.show_connection_cache; DROP FUNCTION IF EXISTS @extschema@.create_hypertable(relation REGCLASS, time_column_name NAME, partitioning_column NAME, number_partitions INTEGER, associated_schema_name NAME, associated_table_prefix NAME, chunk_time_interval ANYELEMENT, create_default_indexes BOOLEAN, if_not_exists BOOLEAN, partitioning_func REGPROC, migrate_data BOOLEAN, chunk_target_size TEXT, chunk_sizing_func REGPROC, time_partitioning_func REGPROC, replication_factor INTEGER, data_nodes NAME[], distributed BOOLEAN); CREATE FUNCTION @extschema@.create_hypertable( relation REGCLASS, time_column_name NAME, partitioning_column NAME = NULL, number_partitions INTEGER = NULL, associated_schema_name NAME = NULL, associated_table_prefix NAME = NULL, chunk_time_interval ANYELEMENT = NULL::bigint, create_default_indexes BOOLEAN = TRUE, if_not_exists BOOLEAN = FALSE, partitioning_func REGPROC = NULL, migrate_data BOOLEAN = FALSE, chunk_target_size TEXT = NULL, chunk_sizing_func REGPROC = '_timescaledb_functions.calculate_chunk_interval'::regproc, time_partitioning_func REGPROC = NULL ) RETURNS TABLE(hypertable_id INT, schema_name NAME, table_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_create' LANGUAGE C VOLATILE; DROP FUNCTION IF EXISTS @extschema@.create_distributed_hypertable; DROP FUNCTION IF EXISTS @extschema@.add_data_node; DROP FUNCTION IF EXISTS @extschema@.delete_data_node; DROP FUNCTION IF EXISTS @extschema@.attach_data_node; DROP FUNCTION IF EXISTS @extschema@.detach_data_node; DROP FUNCTION IF EXISTS @extschema@.alter_data_node; DROP PROCEDURE IF EXISTS @extschema@.distributed_exec; DROP FUNCTION IF EXISTS @extschema@.create_distributed_restore_point; DROP FUNCTION IF EXISTS @extschema@.set_replication_factor; CREATE TABLE _timescaledb_catalog.compression_settings ( relid regclass NOT NULL, segmentby text[], orderby text[], orderby_desc bool[], orderby_nullsfirst bool[], CONSTRAINT compression_settings_pkey PRIMARY KEY (relid), CONSTRAINT compression_settings_check_segmentby CHECK (array_ndims(segmentby) = 1), CONSTRAINT compression_settings_check_orderby_null CHECK ( (orderby IS NULL AND orderby_desc IS NULL AND orderby_nullsfirst IS NULL) OR (orderby IS NOT NULL AND orderby_desc IS NOT NULL AND orderby_nullsfirst IS NOT NULL) ), CONSTRAINT compression_settings_check_orderby_cardinality CHECK (array_ndims(orderby) = 1 AND array_ndims(orderby_desc) = 1 AND array_ndims(orderby_nullsfirst) = 1 AND cardinality(orderby) = cardinality(orderby_desc) AND cardinality(orderby) = cardinality(orderby_nullsfirst)) ); INSERT INTO _timescaledb_catalog.compression_settings(relid, segmentby, orderby, orderby_desc, orderby_nullsfirst) SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass, array_agg(attname ORDER BY segmentby_column_index) FILTER(WHERE segmentby_column_index >= 1) AS compress_segmentby, array_agg(attname ORDER BY orderby_column_index) FILTER(WHERE orderby_column_index >= 1) AS compress_orderby, array_agg(NOT orderby_asc ORDER BY orderby_column_index) FILTER(WHERE orderby_column_index >= 1) AS compress_orderby_desc, array_agg(orderby_nullsfirst ORDER BY orderby_column_index) FILTER(WHERE orderby_column_index >= 1) AS compress_orderby_nullsfirst FROM _timescaledb_catalog.hypertable_compression hc INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = hc.hypertable_id GROUP BY hypertable_id, ht.schema_name, ht.table_name; INSERT INTO _timescaledb_catalog.compression_settings SELECT format('%I.%I',ch.schema_name,ch.table_name)::regclass,s.segmentby,s.orderby,s.orderby_desc,s.orderby_nullsfirst FROM _timescaledb_catalog.hypertable ht1 INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht2.id = ht1.compressed_hypertable_id INNER JOIN _timescaledb_catalog.compression_settings s ON s.relid = format('%I.%I',ht1.schema_name,ht1.table_name)::regclass INNER JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht2.id ON CONFLICT DO NOTHING; GRANT SELECT ON _timescaledb_catalog.compression_settings TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_settings', ''); ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable_compression; DROP VIEW IF EXISTS timescaledb_information.compression_settings; DROP TABLE _timescaledb_catalog.hypertable_compression; DROP FOREIGN DATA WRAPPER IF EXISTS timescaledb_fdw; DROP FUNCTION IF EXISTS @extschema@.timescaledb_fdw_handler(); DROP FUNCTION IF EXISTS @extschema@.timescaledb_fdw_validator(text[], oid); DROP FUNCTION IF EXISTS _timescaledb_functions.create_chunk_replica_table; DROP FUNCTION IF EXISTS _timescaledb_functions.chunk_drop_replica; DROP PROCEDURE IF EXISTS _timescaledb_functions.wait_subscription_sync; DROP FUNCTION IF EXISTS _timescaledb_functions.health; DROP FUNCTION IF EXISTS _timescaledb_functions.drop_stale_chunks; DROP FUNCTION IF EXISTS _timescaledb_internal.create_chunk_replica_table; DROP FUNCTION IF EXISTS _timescaledb_internal.chunk_drop_replica; DROP PROCEDURE IF EXISTS _timescaledb_internal.wait_subscription_sync; DROP FUNCTION IF EXISTS _timescaledb_internal.health; DROP FUNCTION IF EXISTS _timescaledb_internal.drop_stale_chunks; ALTER TABLE _timescaledb_catalog.remote_txn DROP CONSTRAINT remote_txn_remote_transaction_id_check; DROP TYPE IF EXISTS @extschema@.rxid CASCADE; DROP FUNCTION IF EXISTS _timescaledb_functions.rxid_in; DROP FUNCTION IF EXISTS _timescaledb_functions.rxid_out; DROP FUNCTION IF EXISTS _timescaledb_functions.data_node_hypertable_info; DROP FUNCTION IF EXISTS _timescaledb_functions.data_node_chunk_info; DROP FUNCTION IF EXISTS _timescaledb_functions.data_node_compressed_chunk_stats; DROP FUNCTION IF EXISTS _timescaledb_functions.data_node_index_size; DROP FUNCTION IF EXISTS _timescaledb_internal.data_node_hypertable_info; DROP FUNCTION IF EXISTS _timescaledb_internal.data_node_chunk_info; DROP FUNCTION IF EXISTS _timescaledb_internal.data_node_compressed_chunk_stats; DROP FUNCTION IF EXISTS _timescaledb_internal.data_node_index_size; DROP FUNCTION IF EXISTS timescaledb_experimental.block_new_chunks; DROP FUNCTION IF EXISTS timescaledb_experimental.allow_new_chunks; DROP FUNCTION IF EXISTS timescaledb_experimental.subscription_exec; DROP PROCEDURE IF EXISTS timescaledb_experimental.move_chunk; DROP PROCEDURE IF EXISTS timescaledb_experimental.copy_chunk; DROP PROCEDURE IF EXISTS timescaledb_experimental.cleanup_copy_chunk_operation; DROP FUNCTION IF EXISTS _timescaledb_functions.set_chunk_default_data_node; DROP FUNCTION IF EXISTS _timescaledb_internal.set_chunk_default_data_node; DROP FUNCTION IF EXISTS _timescaledb_functions.drop_dist_ht_invalidation_trigger; DROP FUNCTION IF EXISTS _timescaledb_internal.drop_dist_ht_invalidation_trigger; -- remove multinode catalog tables DROP VIEW IF EXISTS timescaledb_information.chunks; DROP VIEW IF EXISTS timescaledb_information.data_nodes; DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_experimental.chunk_replication_status; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.remote_txn; DROP TABLE _timescaledb_catalog.remote_txn; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable_data_node; DROP TABLE _timescaledb_catalog.hypertable_data_node; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk_data_node; DROP TABLE _timescaledb_catalog.chunk_data_node; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk_copy_operation; DROP TABLE _timescaledb_catalog.chunk_copy_operation; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.chunk_copy_operation_id_seq; DROP SEQUENCE _timescaledb_catalog.chunk_copy_operation_id_seq; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.dimension_partition; DROP TABLE _timescaledb_catalog.dimension_partition; DROP FUNCTION IF EXISTS _timescaledb_functions.hypertable_remote_size; DROP FUNCTION IF EXISTS _timescaledb_internal.hypertable_remote_size; DROP FUNCTION IF EXISTS _timescaledb_functions.chunks_remote_size; DROP FUNCTION IF EXISTS _timescaledb_internal.chunks_remote_size; DROP FUNCTION IF EXISTS _timescaledb_functions.indexes_remote_size; DROP FUNCTION IF EXISTS _timescaledb_internal.indexes_remote_size; DROP FUNCTION IF EXISTS _timescaledb_functions.compressed_chunk_remote_stats; DROP FUNCTION IF EXISTS _timescaledb_internal.compressed_chunk_remote_stats; -- rebuild _timescaledb_catalog.hypertable ALTER TABLE _timescaledb_config.bgw_job DROP CONSTRAINT bgw_job_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk DROP CONSTRAINT chunk_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT chunk_index_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_agg DROP CONSTRAINT continuous_agg_mat_hypertable_id_fkey, DROP CONSTRAINT continuous_agg_raw_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function DROP CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold DROP CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.dimension DROP CONSTRAINT dimension_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable DROP CONSTRAINT hypertable_compressed_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.tablespace DROP CONSTRAINT tablespace_hypertable_id_fkey; DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.jobs; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; DROP VIEW IF EXISTS timescaledb_information.chunks; DROP VIEW IF EXISTS timescaledb_information.dimensions; DROP VIEW IF EXISTS timescaledb_information.compression_settings; DROP VIEW IF EXISTS _timescaledb_internal.hypertable_chunk_local_size; DROP VIEW IF EXISTS _timescaledb_internal.compressed_chunk_stats; DROP VIEW IF EXISTS timescaledb_experimental.chunk_replication_status; DROP VIEW IF EXISTS timescaledb_experimental.policies; -- recreate table CREATE TABLE _timescaledb_catalog.hypertable_tmp AS SELECT * FROM _timescaledb_catalog.hypertable; CREATE TABLE _timescaledb_catalog.tmp_hypertable_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.hypertable_id_seq; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.hypertable_id_seq; SET timescaledb.restoring = on; -- must disable the hooks otherwise we can't do anything without the table _timescaledb_catalog.hypertable DROP TABLE _timescaledb_catalog.hypertable; CREATE SEQUENCE _timescaledb_catalog.hypertable_id_seq MINVALUE 1; SELECT setval('_timescaledb_catalog.hypertable_id_seq', last_value, is_called) FROM _timescaledb_catalog.tmp_hypertable_seq_value; DROP TABLE _timescaledb_catalog.tmp_hypertable_seq_value; CREATE TABLE _timescaledb_catalog.hypertable ( id INTEGER PRIMARY KEY NOT NULL DEFAULT nextval('_timescaledb_catalog.hypertable_id_seq'), schema_name name NOT NULL, table_name name NOT NULL, associated_schema_name name NOT NULL, associated_table_prefix name NOT NULL, num_dimensions smallint NOT NULL, chunk_sizing_func_schema name NOT NULL, chunk_sizing_func_name name NOT NULL, chunk_target_size bigint NOT NULL, -- size in bytes compression_state smallint NOT NULL DEFAULT 0, compressed_hypertable_id integer, status integer NOT NULL DEFAULT 0 ); SET timescaledb.restoring = off; INSERT INTO _timescaledb_catalog.hypertable ( id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id ) SELECT id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id FROM _timescaledb_catalog.hypertable_tmp ORDER BY id; UPDATE _timescaledb_catalog.hypertable h SET status = 3 WHERE EXISTS ( SELECT FROM _timescaledb_catalog.chunk c WHERE c.osm_chunk AND c.hypertable_id = h.id ); ALTER SEQUENCE _timescaledb_catalog.hypertable_id_seq OWNED BY _timescaledb_catalog.hypertable.id; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_id_seq', ''); GRANT SELECT ON _timescaledb_catalog.hypertable TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.hypertable_id_seq TO PUBLIC; DROP TABLE _timescaledb_catalog.hypertable_tmp; -- now add any constraints ALTER TABLE _timescaledb_catalog.hypertable ADD CONSTRAINT hypertable_associated_schema_name_associated_table_prefix_key UNIQUE (associated_schema_name, associated_table_prefix), ADD CONSTRAINT hypertable_table_name_schema_name_key UNIQUE (table_name, schema_name), ADD CONSTRAINT hypertable_schema_name_check CHECK (schema_name != '_timescaledb_catalog'), ADD CONSTRAINT hypertable_dim_compress_check CHECK (num_dimensions > 0 OR compression_state = 2), ADD CONSTRAINT hypertable_chunk_target_size_check CHECK (chunk_target_size >= 0), ADD CONSTRAINT hypertable_compress_check CHECK ( (compression_state = 0 OR compression_state = 1 ) OR (compression_state = 2 AND compressed_hypertable_id IS NULL)), ADD CONSTRAINT hypertable_compressed_hypertable_id_fkey FOREIGN KEY (compressed_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id); GRANT SELECT ON TABLE _timescaledb_catalog.hypertable TO PUBLIC; -- 3. reestablish constraints on other tables ALTER TABLE _timescaledb_config.bgw_job ADD CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT chunk_index_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_agg ADD CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE, ADD CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function ADD CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ADD CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.dimension ADD CONSTRAINT dimension_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.tablespace ADD CONSTRAINT tablespace_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; CREATE SCHEMA _timescaledb_debug; -- Migrate existing compressed hypertables to new internal format DO $$ DECLARE chunk regclass; hypertable regclass; ht_id integer; index regclass; column_name name; cmd text; BEGIN SET timescaledb.restoring TO ON; -- Detach compressed chunks from their parent hypertables FOR chunk, hypertable, ht_id IN SELECT format('%I.%I',ch.schema_name,ch.table_name)::regclass chunk, format('%I.%I',ht.schema_name,ht.table_name)::regclass hypertable, ht.id FROM _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht_uncomp ON ch.hypertable_id = ht_uncomp.compressed_hypertable_id INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ht_uncomp.compressed_hypertable_id LOOP cmd := format('ALTER TABLE %s NO INHERIT %s', chunk, hypertable); EXECUTE cmd; -- remove references to indexes from the compressed hypertable DELETE FROM _timescaledb_catalog.chunk_index WHERE hypertable_id = ht_id; END LOOP; FOR hypertable IN SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass hypertable FROM _timescaledb_catalog.hypertable ht_uncomp INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ht_uncomp.compressed_hypertable_id LOOP -- remove indexes from the compressed hypertable (but not chunks) FOR index IN SELECT indexrelid::regclass FROM pg_index WHERE indrelid = hypertable LOOP cmd := format('DROP INDEX %s', index); EXECUTE cmd; END LOOP; -- remove columns from the compressed hypertable (but not chunks) FOR column_name IN SELECT attname FROM pg_attribute WHERE attrelid = hypertable AND attnum > 0 AND NOT attisdropped LOOP cmd := format('ALTER TABLE %s DROP COLUMN %I', hypertable, column_name); EXECUTE cmd; END LOOP; END LOOP; SET timescaledb.restoring TO OFF; END $$; DROP FUNCTION IF EXISTS _timescaledb_internal.hypertable_constraint_add_table_fk_constraint; DROP FUNCTION IF EXISTS _timescaledb_functions.hypertable_constraint_add_table_fk_constraint; -- only define stub here, actual code will be filled in at end of update script CREATE FUNCTION _timescaledb_functions.constraint_clone(constraint_oid OID,target_oid REGCLASS) RETURNS VOID LANGUAGE PLPGSQL AS $$BEGIN END$$ SET search_path TO pg_catalog, pg_temp; DROP FUNCTION IF EXISTS _timescaledb_functions.chunks_in; DROP FUNCTION IF EXISTS _timescaledb_internal.chunks_in; CREATE FUNCTION _timescaledb_functions.metadata_insert_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN IF EXISTS (SELECT FROM _timescaledb_catalog.metadata WHERE key = NEW.key) THEN UPDATE _timescaledb_catalog.metadata SET value = NEW.value WHERE key = NEW.key; RETURN NULL; END IF; RETURN NEW; END $$ SET search_path TO pg_catalog, pg_temp; CREATE TRIGGER metadata_insert_trigger BEFORE INSERT ON _timescaledb_catalog.metadata FOR EACH ROW EXECUTE PROCEDURE _timescaledb_functions.metadata_insert_trigger(); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.metadata', $$ WHERE key <> 'uuid' $$); -- Remove unwanted entries from extconfig and extcondition in pg_extension -- We use ALTER EXTENSION DROP TABLE to remove these entries. ALTER EXTENSION timescaledb DROP TABLE _timescaledb_cache.cache_inval_hypertable; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_cache.cache_inval_extension; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_cache.cache_inval_bgw_job; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_internal.job_errors; -- Associate the above tables back to keep the dependencies safe ALTER EXTENSION timescaledb ADD TABLE _timescaledb_cache.cache_inval_hypertable; ALTER EXTENSION timescaledb ADD TABLE _timescaledb_cache.cache_inval_extension; ALTER EXTENSION timescaledb ADD TABLE _timescaledb_cache.cache_inval_bgw_job; ALTER EXTENSION timescaledb ADD TABLE _timescaledb_internal.job_errors; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable; ALTER EXTENSION timescaledb ADD TABLE _timescaledb_catalog.hypertable; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable', 'WHERE id >= 1'); CREATE FUNCTION _timescaledb_functions.relation_approximate_size(relation REGCLASS) RETURNS TABLE (total_size BIGINT, heap_size BIGINT, index_size BIGINT, toast_size BIGINT) AS '@MODULE_PATHNAME@', 'ts_relation_approximate_size' LANGUAGE C STRICT VOLATILE; CREATE FUNCTION @extschema@.hypertable_approximate_detailed_size(relation REGCLASS) RETURNS TABLE (table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT) AS '@MODULE_PATHNAME@', 'ts_hypertable_approximate_size' LANGUAGE C VOLATILE; --- returns approximate total-bytes for a hypertable (includes table + index) CREATE FUNCTION @extschema@.hypertable_approximate_size( hypertable REGCLASS) RETURNS BIGINT LANGUAGE SQL VOLATILE STRICT AS $BODY$ SELECT sum(total_bytes)::bigint FROM @extschema@.hypertable_approximate_detailed_size(hypertable); $BODY$ SET search_path TO pg_catalog, pg_temp; DROP FUNCTION IF EXISTS @extschema@.compress_chunk; CREATE FUNCTION @extschema@.compress_chunk(uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true, recompress BOOLEAN = false) RETURNS REGCLASS AS '' LANGUAGE SQL SET search_path TO pg_catalog, pg_temp; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.14.0--2.13.1.sql���������������������������������������������������0000664�0000000�0000000�00000107145�15100345067�0020367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- check whether we can safely downgrade compression setup DO $$ DECLARE hypertable regclass; ht_uncomp regclass; chunk_relids oid[]; ht_id integer; BEGIN FOR hypertable, ht_uncomp, ht_id IN SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass, format('%I.%I',ht_uncomp.schema_name,ht_uncomp.table_name)::regclass, ht.id FROM _timescaledb_catalog.hypertable ht_uncomp INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ht_uncomp.compressed_hypertable_id LOOP -- hypertables need to at least have 1 compressed chunk so we can restore the columns IF NOT EXISTS(SELECT FROM _timescaledb_catalog.chunk WHERE hypertable_id = ht_id) THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'Cannot downgrade compressed hypertables with no compressed chunks. Disable compression on the affected hypertable before downgrading.', DETAIL = 'The following hypertable is affected: '|| ht_uncomp::text; END IF; chunk_relids := array(SELECT format('%I.%I',schema_name,table_name)::regclass FROM _timescaledb_catalog.chunk WHERE hypertable_id = ht_id); -- any hypertable with distinct compression settings cannot be downgraded IF EXISTS ( SELECT FROM ( SELECT DISTINCT segmentby, orderby, orderby_desc, orderby_nullsfirst FROM _timescaledb_catalog.compression_settings WHERE relid = hypertable OR relid = ANY(chunk_relids) ) dist_settings HAVING count(*) > 1 ) THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'Cannot downgrade hypertables with distinct compression settings. Decompress the affected hypertable before downgrading.', DETAIL = 'The following hypertable is affected: '|| ht_uncomp::text; END IF; END LOOP; END $$; CREATE FUNCTION _timescaledb_functions.tmp_resolve_indkeys(oid,int2[]) RETURNS text[] LANGUAGE SQL AS $$ SELECT array_agg(attname) FROM ( SELECT attname FROM (SELECT unnest($2) attnum) indkeys JOIN LATERAL ( SELECT attname FROM pg_attribute att WHERE att.attnum=indkeys.attnum AND att.attrelid=$1 ) r ON true ) resolve; $$ SET search_path TO pg_catalog, pg_temp; DO $$ DECLARE chunk regclass; hypertable regclass; ht_id integer; chunk_id integer; _index regclass; ht_index regclass; chunk_index regclass; index_name name; chunk_index_name name; _indkey text[]; column_name name; column_type regtype; cmd text; BEGIN SET timescaledb.restoring TO ON; FOR hypertable, ht_id IN SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass, ht.id FROM _timescaledb_catalog.hypertable ht_uncomp INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ht_uncomp.compressed_hypertable_id LOOP -- get first chunk which we use as template for restoring columns and indexes SELECT format('%I.%I',schema_name,table_name)::regclass INTO STRICT chunk FROM _timescaledb_catalog.chunk WHERE hypertable_id = ht_id ORDER by id LIMIT 1; -- restore columns from the compressed hypertable FOR column_name, column_type IN SELECT attname, atttypid::regtype FROM pg_attribute WHERE attrelid = chunk AND attnum > 0 AND NOT attisdropped LOOP cmd := format('ALTER TABLE %s ADD COLUMN %I %s', hypertable, column_name, column_type); EXECUTE cmd; END LOOP; -- restore indexes on the compressed hypertable FOR _index, _indkey IN SELECT indexrelid::regclass, _timescaledb_functions.tmp_resolve_indkeys(indrelid, indkey) FROM pg_index WHERE indrelid = chunk LOOP SELECT relname INTO STRICT index_name FROM pg_class WHERE oid = _index; cmd := pg_get_indexdef(_index); cmd := replace(cmd, format(' INDEX %s ON ', index_name), ' INDEX ON '); cmd := replace(cmd, chunk::text, hypertable::text); EXECUTE cmd; -- get indexrelid of index we just created on hypertable SELECT indexrelid INTO STRICT ht_index FROM pg_index WHERE indrelid = hypertable AND _timescaledb_functions.tmp_resolve_indkeys(hypertable, indkey) = _indkey; SELECT relname INTO STRICT index_name FROM pg_class WHERE oid = ht_index; -- restore indexes in our catalog FOR chunk, chunk_id IN SELECT format('%I.%I',schema_name,table_name)::regclass, id FROM _timescaledb_catalog.chunk WHERE hypertable_id = ht_id LOOP SELECT indexrelid INTO STRICT chunk_index FROM pg_index WHERE indrelid = chunk AND _timescaledb_functions.tmp_resolve_indkeys(chunk, indkey) = _indkey; SELECT relname INTO STRICT chunk_index_name FROM pg_class WHERE oid = chunk_index; INSERT INTO _timescaledb_catalog.chunk_index (chunk_id, index_name, hypertable_id, hypertable_index_name) VALUES (chunk_id, chunk_index_name, ht_id, index_name); END LOOP; END LOOP; -- restore inheritance cmd := format('ALTER TABLE %s INHERIT %s', chunk, hypertable); EXECUTE cmd; END LOOP; SET timescaledb.restoring TO OFF; END $$; DROP FUNCTION _timescaledb_functions.tmp_resolve_indkeys; CREATE FUNCTION _timescaledb_functions.ping_data_node(node_name NAME, timeout INTERVAL = NULL) RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_data_node_ping' LANGUAGE C VOLATILE; CREATE FUNCTION _timescaledb_functions.remote_txn_heal_data_node(foreign_server_oid oid) RETURNS INT AS '@MODULE_PATHNAME@', 'ts_remote_txn_heal_data_node' LANGUAGE C STRICT; CREATE FUNCTION _timescaledb_functions.set_dist_id(dist_id UUID) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_dist_set_id' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION _timescaledb_functions.set_peer_dist_id(dist_id UUID) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_dist_set_peer_id' LANGUAGE C VOLATILE STRICT; -- Function to validate that a node has local settings to function as -- a data node. Throws error if validation fails. CREATE FUNCTION _timescaledb_functions.validate_as_data_node() RETURNS void AS '@MODULE_PATHNAME@', 'ts_dist_validate_as_data_node' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION _timescaledb_functions.show_connection_cache() RETURNS TABLE ( node_name name, user_name name, host text, port int, database name, backend_pid int, connection_status text, transaction_status text, transaction_depth int, processing boolean, invalidated boolean) AS '@MODULE_PATHNAME@', 'ts_remote_connection_cache_show' LANGUAGE C VOLATILE STRICT; DROP FUNCTION IF EXISTS @extschema@.create_hypertable(relation REGCLASS, time_column_name NAME, partitioning_column NAME, number_partitions INTEGER, associated_schema_name NAME, associated_table_prefix NAME, chunk_time_interval ANYELEMENT, create_default_indexes BOOLEAN, if_not_exists BOOLEAN, partitioning_func REGPROC, migrate_data BOOLEAN, chunk_target_size TEXT, chunk_sizing_func REGPROC, time_partitioning_func REGPROC); CREATE FUNCTION @extschema@.create_hypertable( relation REGCLASS, time_column_name NAME, partitioning_column NAME = NULL, number_partitions INTEGER = NULL, associated_schema_name NAME = NULL, associated_table_prefix NAME = NULL, chunk_time_interval ANYELEMENT = NULL::bigint, create_default_indexes BOOLEAN = TRUE, if_not_exists BOOLEAN = FALSE, partitioning_func REGPROC = NULL, migrate_data BOOLEAN = FALSE, chunk_target_size TEXT = NULL, chunk_sizing_func REGPROC = '_timescaledb_functions.calculate_chunk_interval'::regproc, time_partitioning_func REGPROC = NULL, replication_factor INTEGER = NULL, data_nodes NAME[] = NULL, distributed BOOLEAN = NULL ) RETURNS TABLE(hypertable_id INT, schema_name NAME, table_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_create' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.create_distributed_hypertable( relation REGCLASS, time_column_name NAME, partitioning_column NAME = NULL, number_partitions INTEGER = NULL, associated_schema_name NAME = NULL, associated_table_prefix NAME = NULL, chunk_time_interval ANYELEMENT = NULL::bigint, create_default_indexes BOOLEAN = TRUE, if_not_exists BOOLEAN = FALSE, partitioning_func REGPROC = NULL, migrate_data BOOLEAN = FALSE, chunk_target_size TEXT = NULL, chunk_sizing_func REGPROC = '_timescaledb_functions.calculate_chunk_interval'::regproc, time_partitioning_func REGPROC = NULL, replication_factor INTEGER = NULL, data_nodes NAME[] = NULL ) RETURNS TABLE(hypertable_id INT, schema_name NAME, table_name NAME, created BOOL) AS '@MODULE_PATHNAME@', 'ts_hypertable_distributed_create' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.add_data_node( node_name NAME, host TEXT, database NAME = NULL, port INTEGER = NULL, if_not_exists BOOLEAN = FALSE, bootstrap BOOLEAN = TRUE, password TEXT = NULL ) RETURNS TABLE(node_name NAME, host TEXT, port INTEGER, database NAME, node_created BOOL, database_created BOOL, extension_created BOOL) AS '@MODULE_PATHNAME@', 'ts_data_node_add' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.delete_data_node( node_name NAME, if_exists BOOLEAN = FALSE, force BOOLEAN = FALSE, repartition BOOLEAN = TRUE, drop_database BOOLEAN = FALSE ) RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_data_node_delete' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.attach_data_node( node_name NAME, hypertable REGCLASS, if_not_attached BOOLEAN = FALSE, repartition BOOLEAN = TRUE ) RETURNS TABLE(hypertable_id INTEGER, node_hypertable_id INTEGER, node_name NAME) AS '@MODULE_PATHNAME@', 'ts_data_node_attach' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.detach_data_node( node_name NAME, hypertable REGCLASS = NULL, if_attached BOOLEAN = FALSE, force BOOLEAN = FALSE, repartition BOOLEAN = TRUE, drop_remote_data BOOLEAN = FALSE ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_data_node_detach' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.alter_data_node( node_name NAME, host TEXT = NULL, database NAME = NULL, port INTEGER = NULL, available BOOLEAN = NULL ) RETURNS TABLE(node_name NAME, host TEXT, port INTEGER, database NAME, available BOOLEAN) AS '@MODULE_PATHNAME@', 'ts_data_node_alter' LANGUAGE C VOLATILE; CREATE PROCEDURE @extschema@.distributed_exec( query TEXT, node_list name[] = NULL, transactional BOOLEAN = TRUE) AS '@MODULE_PATHNAME@', 'ts_distributed_exec' LANGUAGE C; CREATE FUNCTION @extschema@.create_distributed_restore_point( name TEXT ) RETURNS TABLE(node_name NAME, node_type TEXT, restore_point pg_lsn) AS '@MODULE_PATHNAME@', 'ts_create_distributed_restore_point' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION @extschema@.set_replication_factor( hypertable REGCLASS, replication_factor INTEGER ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_hypertable_distributed_set_replication_factor' LANGUAGE C VOLATILE; CREATE TABLE _timescaledb_catalog.hypertable_compression ( hypertable_id integer NOT NULL, attname name NOT NULL, compression_algorithm_id smallint, segmentby_column_index smallint, orderby_column_index smallint, orderby_asc boolean, orderby_nullsfirst boolean, -- table constraints CONSTRAINT hypertable_compression_pkey PRIMARY KEY (hypertable_id, attname), CONSTRAINT hypertable_compression_hypertable_id_orderby_column_index_key UNIQUE (hypertable_id, orderby_column_index), CONSTRAINT hypertable_compression_hypertable_id_segmentby_column_index_key UNIQUE (hypertable_id, segmentby_column_index), CONSTRAINT hypertable_compression_compression_algorithm_id_fkey FOREIGN KEY (compression_algorithm_id) REFERENCES _timescaledb_catalog.compression_algorithm (id) ); INSERT INTO _timescaledb_catalog.hypertable_compression( hypertable_id, attname, compression_algorithm_id, segmentby_column_index, orderby_column_index, orderby_asc, orderby_nullsfirst ) SELECT ht.id, att.attname, CASE WHEN att.attname = ANY(cs.segmentby) THEN 0 WHEN att.atttypid IN ('numeric'::regtype) THEN 1 WHEN att.atttypid IN ('float4'::regtype,'float8'::regtype) THEN 3 WHEN att.atttypid IN ('int2'::regtype,'int4'::regtype,'int8'::regtype,'date'::regtype,'timestamp'::regtype,'timestamptz'::regtype) THEN 4 WHEN EXISTS(SELECT FROM pg_operator op WHERE op.oprname = '=' AND op.oprkind = 'b' AND op.oprcanhash = true AND op.oprleft = att.atttypid AND op.oprright = att.atttypid) THEN 2 ELSE 1 END AS compression_algorithm_id, CASE WHEN att.attname = ANY(cs.segmentby) THEN array_position(cs.segmentby, att.attname::text) ELSE NULL END AS segmentby_column_index, CASE WHEN att.attname = ANY(cs.orderby) THEN array_position(cs.orderby, att.attname::text) ELSE NULL END AS orderby_column_index, CASE WHEN att.attname = ANY(cs.orderby) THEN NOT cs.orderby_desc[array_position(cs.orderby, att.attname::text)] ELSE false END AS orderby_asc, CASE WHEN att.attname = ANY(cs.orderby) THEN cs.orderby_nullsfirst[array_position(cs.orderby, att.attname::text)] ELSE false END AS orderby_nullsfirst FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.compression_settings cs ON cs.relid = format('%I.%I',ht.schema_name,ht.table_name)::regclass LEFT JOIN pg_attribute att ON att.attrelid = format('%I.%I',ht.schema_name,ht.table_name)::regclass AND attnum > 0 WHERE compressed_hypertable_id IS NOT NULL; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_compression', ''); GRANT SELECT ON _timescaledb_catalog.hypertable_compression TO PUBLIC; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.compression_settings; DROP VIEW timescaledb_information.compression_settings; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_settings; DROP TABLE _timescaledb_catalog.compression_settings; CREATE FUNCTION @extschema@.timescaledb_fdw_handler() RETURNS fdw_handler AS '@MODULE_PATHNAME@', 'ts_timescaledb_fdw_handler' LANGUAGE C STRICT; CREATE FUNCTION @extschema@.timescaledb_fdw_validator(text[], oid) RETURNS void AS '@MODULE_PATHNAME@', 'ts_timescaledb_fdw_validator' LANGUAGE C STRICT; CREATE FOREIGN DATA WRAPPER timescaledb_fdw HANDLER @extschema@.timescaledb_fdw_handler VALIDATOR @extschema@.timescaledb_fdw_validator; CREATE FUNCTION _timescaledb_functions.create_chunk_replica_table( chunk REGCLASS, data_node_name NAME ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_chunk_create_replica_table' LANGUAGE C VOLATILE; CREATE FUNCTION _timescaledb_functions.chunk_drop_replica( chunk REGCLASS, node_name NAME ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_chunk_drop_replica' LANGUAGE C VOLATILE; CREATE PROCEDURE _timescaledb_functions.wait_subscription_sync( schema_name NAME, table_name NAME, retry_count INT DEFAULT 18000, retry_delay_ms NUMERIC DEFAULT 0.200 ) LANGUAGE PLPGSQL AS $BODY$ DECLARE in_sync BOOLEAN; BEGIN FOR i in 1 .. retry_count LOOP SELECT pgs.srsubstate = 'r' INTO in_sync FROM pg_subscription_rel pgs JOIN pg_class pgc ON relname = table_name JOIN pg_namespace n ON (n.OID = pgc.relnamespace) WHERE pgs.srrelid = pgc.oid AND schema_name = n.nspname; if (in_sync IS NULL OR NOT in_sync) THEN PERFORM pg_sleep(retry_delay_ms); ELSE RETURN; END IF; END LOOP; RAISE 'subscription sync wait timedout'; END $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.health() RETURNS TABLE (node_name NAME, healthy BOOL, in_recovery BOOL, error TEXT) AS '@MODULE_PATHNAME@', 'ts_health_check' LANGUAGE C VOLATILE; CREATE FUNCTION _timescaledb_functions.drop_stale_chunks( node_name NAME, chunks integer[] = NULL ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_chunks_drop_stale' LANGUAGE C VOLATILE; CREATE FUNCTION _timescaledb_functions.rxid_in(cstring) RETURNS @extschema@.rxid AS '@MODULE_PATHNAME@', 'ts_remote_txn_id_in' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE FUNCTION _timescaledb_functions.rxid_out(@extschema@.rxid) RETURNS cstring AS '@MODULE_PATHNAME@', 'ts_remote_txn_id_out' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE TYPE @extschema@.rxid ( internallength = 16, input = _timescaledb_functions.rxid_in, output = _timescaledb_functions.rxid_out ); CREATE FUNCTION _timescaledb_functions.data_node_hypertable_info( node_name NAME, schema_name_in name, table_name_in name ) RETURNS TABLE ( table_bytes bigint, index_bytes bigint, toast_bytes bigint, total_bytes bigint) AS '@MODULE_PATHNAME@', 'ts_dist_remote_hypertable_info' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION _timescaledb_functions.data_node_chunk_info( node_name NAME, schema_name_in name, table_name_in name ) RETURNS TABLE ( chunk_id integer, chunk_schema name, chunk_name name, table_bytes bigint, index_bytes bigint, toast_bytes bigint, total_bytes bigint) AS '@MODULE_PATHNAME@', 'ts_dist_remote_chunk_info' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION _timescaledb_functions.data_node_compressed_chunk_stats(node_name name, schema_name_in name, table_name_in name) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint ) AS '@MODULE_PATHNAME@' , 'ts_dist_remote_compressed_chunk_info' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION _timescaledb_functions.data_node_index_size(node_name name, schema_name_in name, index_name_in name) RETURNS TABLE ( hypertable_id INTEGER, total_bytes BIGINT) AS '@MODULE_PATHNAME@' , 'ts_dist_remote_hypertable_index_info' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION timescaledb_experimental.block_new_chunks(data_node_name NAME, hypertable REGCLASS = NULL, force BOOLEAN = FALSE) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_data_node_block_new_chunks' LANGUAGE C VOLATILE; CREATE FUNCTION timescaledb_experimental.allow_new_chunks(data_node_name NAME, hypertable REGCLASS = NULL) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_data_node_allow_new_chunks' LANGUAGE C VOLATILE; CREATE PROCEDURE timescaledb_experimental.move_chunk( chunk REGCLASS, source_node NAME = NULL, destination_node NAME = NULL, operation_id NAME = NULL) AS '@MODULE_PATHNAME@', 'ts_move_chunk_proc' LANGUAGE C; CREATE PROCEDURE timescaledb_experimental.copy_chunk( chunk REGCLASS, source_node NAME = NULL, destination_node NAME = NULL, operation_id NAME = NULL) AS '@MODULE_PATHNAME@', 'ts_copy_chunk_proc' LANGUAGE C; CREATE FUNCTION timescaledb_experimental.subscription_exec( subscription_command TEXT ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_subscription_exec' LANGUAGE C VOLATILE; CREATE PROCEDURE timescaledb_experimental.cleanup_copy_chunk_operation( operation_id NAME) AS '@MODULE_PATHNAME@', 'ts_copy_chunk_cleanup_proc' LANGUAGE C; CREATE FUNCTION _timescaledb_functions.set_chunk_default_data_node(chunk REGCLASS, node_name NAME) RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_chunk_set_default_data_node' LANGUAGE C VOLATILE; CREATE FUNCTION _timescaledb_functions.drop_dist_ht_invalidation_trigger( raw_hypertable_id INTEGER ) RETURNS VOID AS '@MODULE_PATHNAME@', 'ts_drop_dist_ht_invalidation_trigger' LANGUAGE C STRICT VOLATILE; -- restore multinode catalog tables CREATE TABLE _timescaledb_catalog.remote_txn ( data_node_name name, --this is really only to allow us to cleanup stuff on a per-node basis. remote_transaction_id text NOT NULL, -- table constraints CONSTRAINT remote_txn_pkey PRIMARY KEY (remote_transaction_id) ); ALTER TABLE _timescaledb_catalog.remote_txn ADD CONSTRAINT remote_txn_remote_transaction_id_check CHECK (remote_transaction_id::@extschema@.rxid IS NOT NULL); CREATE INDEX remote_txn_data_node_name_idx ON _timescaledb_catalog.remote_txn (data_node_name); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.remote_txn', ''); GRANT SELECT ON TABLE _timescaledb_catalog.remote_txn TO PUBLIC; CREATE TABLE _timescaledb_catalog.hypertable_data_node ( hypertable_id integer NOT NULL, node_hypertable_id integer NULL, node_name name NOT NULL, block_chunks boolean NOT NULL, -- table constraints CONSTRAINT hypertable_data_node_hypertable_id_node_name_key UNIQUE (hypertable_id, node_name), CONSTRAINT hypertable_data_node_node_hypertable_id_node_name_key UNIQUE (node_hypertable_id, node_name), CONSTRAINT hypertable_data_node_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_data_node', ''); GRANT SELECT ON TABLE _timescaledb_catalog.hypertable_data_node TO PUBLIC; CREATE TABLE _timescaledb_catalog.chunk_data_node ( chunk_id integer NOT NULL, node_chunk_id integer NOT NULL, node_name name NOT NULL, -- table constraints CONSTRAINT chunk_data_node_chunk_id_node_name_key UNIQUE (chunk_id, node_name), CONSTRAINT chunk_data_node_node_chunk_id_node_name_key UNIQUE (node_chunk_id, node_name), CONSTRAINT chunk_data_node_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ); CREATE INDEX chunk_data_node_node_name_idx ON _timescaledb_catalog.chunk_data_node (node_name); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_data_node', ''); GRANT SELECT ON TABLE _timescaledb_catalog.chunk_data_node TO PUBLIC; CREATE SEQUENCE _timescaledb_catalog.chunk_copy_operation_id_seq MINVALUE 1; GRANT SELECT ON SEQUENCE _timescaledb_catalog.chunk_copy_operation_id_seq TO PUBLIC; CREATE TABLE _timescaledb_catalog.chunk_copy_operation ( operation_id name NOT NULL, -- the publisher/subscriber identifier used backend_pid integer NOT NULL, -- the pid of the backend running this activity completed_stage name NOT NULL, -- the completed stage/step time_start timestamptz NOT NULL DEFAULT NOW(), -- start time of the activity chunk_id integer NOT NULL, compress_chunk_name name NOT NULL, source_node_name name NOT NULL, dest_node_name name NOT NULL, delete_on_source_node bool NOT NULL, -- is a move or copy activity -- table constraints CONSTRAINT chunk_copy_operation_pkey PRIMARY KEY (operation_id), CONSTRAINT chunk_copy_operation_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE ); GRANT SELECT ON TABLE _timescaledb_catalog.chunk_copy_operation TO PUBLIC; CREATE TABLE _timescaledb_catalog.dimension_partition ( dimension_id integer NOT NULL REFERENCES _timescaledb_catalog.dimension (id) ON DELETE CASCADE, range_start bigint NOT NULL, data_nodes name[] NULL, UNIQUE (dimension_id, range_start) ); GRANT SELECT ON TABLE _timescaledb_catalog.dimension_partition TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.dimension_partition', ''); CREATE FUNCTION _timescaledb_functions.hypertable_remote_size( schema_name_in name, table_name_in name) RETURNS TABLE ( table_bytes bigint, index_bytes bigint, toast_bytes bigint, total_bytes bigint, node_name NAME) LANGUAGE SQL VOLATILE STRICT AS $BODY$ $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.chunks_remote_size( schema_name_in name, table_name_in name) RETURNS TABLE ( chunk_id integer, chunk_schema NAME, chunk_name NAME, table_bytes bigint, index_bytes bigint, toast_bytes bigint, total_bytes bigint, node_name NAME) LANGUAGE SQL VOLATILE STRICT AS $BODY$ $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.indexes_remote_size( schema_name_in NAME, table_name_in NAME, index_name_in NAME ) RETURNS BIGINT LANGUAGE SQL VOLATILE STRICT AS $BODY$ $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.compressed_chunk_remote_stats(schema_name_in name, table_name_in name) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE SQL STABLE STRICT AS $BODY$ $BODY$ SET search_path TO pg_catalog, pg_temp; -- recreate the _timescaledb_catalog.hypertable table as new field was added -- 1. drop CONSTRAINTS from other tables referencing the existing one ALTER TABLE _timescaledb_config.bgw_job DROP CONSTRAINT bgw_job_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk DROP CONSTRAINT chunk_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.chunk_index DROP CONSTRAINT chunk_index_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_agg DROP CONSTRAINT continuous_agg_mat_hypertable_id_fkey, DROP CONSTRAINT continuous_agg_raw_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function DROP CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold DROP CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.dimension DROP CONSTRAINT dimension_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable DROP CONSTRAINT hypertable_compressed_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.hypertable_data_node DROP CONSTRAINT hypertable_data_node_hypertable_id_fkey; ALTER TABLE _timescaledb_catalog.tablespace DROP CONSTRAINT tablespace_hypertable_id_fkey; -- drop dependent views ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.hypertables; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.job_stats; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.jobs; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.continuous_aggregates; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.chunks; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.dimensions; ALTER EXTENSION timescaledb DROP VIEW _timescaledb_internal.hypertable_chunk_local_size; ALTER EXTENSION timescaledb DROP VIEW _timescaledb_internal.compressed_chunk_stats; ALTER EXTENSION timescaledb DROP VIEW timescaledb_experimental.policies; DROP VIEW timescaledb_information.hypertables; DROP VIEW timescaledb_information.job_stats; DROP VIEW timescaledb_information.jobs; DROP VIEW timescaledb_information.continuous_aggregates; DROP VIEW timescaledb_information.chunks; DROP VIEW timescaledb_information.dimensions; DROP VIEW _timescaledb_internal.hypertable_chunk_local_size; DROP VIEW _timescaledb_internal.compressed_chunk_stats; DROP VIEW timescaledb_experimental.policies; -- recreate table CREATE TABLE _timescaledb_catalog.hypertable_tmp AS SELECT * FROM _timescaledb_catalog.hypertable; CREATE TABLE _timescaledb_catalog.tmp_hypertable_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.hypertable_id_seq; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.hypertable_id_seq; SET timescaledb.restoring = on; -- must disable the hooks otherwise we can't do anything without the table _timescaledb_catalog.hypertable DROP TABLE _timescaledb_catalog.hypertable; CREATE SEQUENCE _timescaledb_catalog.hypertable_id_seq MINVALUE 1; SELECT setval('_timescaledb_catalog.hypertable_id_seq', last_value, is_called) FROM _timescaledb_catalog.tmp_hypertable_seq_value; DROP TABLE _timescaledb_catalog.tmp_hypertable_seq_value; CREATE TABLE _timescaledb_catalog.hypertable ( id INTEGER PRIMARY KEY NOT NULL DEFAULT nextval('_timescaledb_catalog.hypertable_id_seq'), schema_name name NOT NULL, table_name name NOT NULL, associated_schema_name name NOT NULL, associated_table_prefix name NOT NULL, num_dimensions smallint NOT NULL, chunk_sizing_func_schema name NOT NULL, chunk_sizing_func_name name NOT NULL, chunk_target_size bigint NOT NULL, -- size in bytes compression_state smallint NOT NULL DEFAULT 0, compressed_hypertable_id integer, replication_factor smallint NULL, status int NOT NULL DEFAULT 0 ); SET timescaledb.restoring = off; INSERT INTO _timescaledb_catalog.hypertable ( id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id ) SELECT id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id FROM _timescaledb_catalog.hypertable_tmp ORDER BY id; ALTER SEQUENCE _timescaledb_catalog.hypertable_id_seq OWNED BY _timescaledb_catalog.hypertable.id; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable_id_seq', ''); GRANT SELECT ON _timescaledb_catalog.hypertable TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.hypertable_id_seq TO PUBLIC; DROP TABLE _timescaledb_catalog.hypertable_tmp; -- now add any constraints ALTER TABLE _timescaledb_catalog.hypertable -- ADD CONSTRAINT hypertable_pkey PRIMARY KEY (id), ADD CONSTRAINT hypertable_associated_schema_name_associated_table_prefix_key UNIQUE (associated_schema_name, associated_table_prefix), ADD CONSTRAINT hypertable_table_name_schema_name_key UNIQUE (table_name, schema_name), ADD CONSTRAINT hypertable_schema_name_check CHECK (schema_name != '_timescaledb_catalog'), -- internal compressed hypertables have compression state = 2 ADD CONSTRAINT hypertable_dim_compress_check CHECK (num_dimensions > 0 OR compression_state = 2), ADD CONSTRAINT hypertable_chunk_target_size_check CHECK (chunk_target_size >= 0), ADD CONSTRAINT hypertable_compress_check CHECK ( (compression_state = 0 OR compression_state = 1 ) OR (compression_state = 2 AND compressed_hypertable_id IS NULL)), ADD CONSTRAINT hypertable_replication_factor_check CHECK (replication_factor > 0 OR replication_factor = -1), ADD CONSTRAINT hypertable_compressed_hypertable_id_fkey FOREIGN KEY (compressed_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id); GRANT SELECT ON TABLE _timescaledb_catalog.hypertable TO PUBLIC; -- 3. reestablish constraints on other tables ALTER TABLE _timescaledb_config.bgw_job ADD CONSTRAINT bgw_job_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.chunk ADD CONSTRAINT chunk_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.chunk_index ADD CONSTRAINT chunk_index_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_agg ADD CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE, ADD CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_bucket_function ADD CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ADD CONSTRAINT continuous_aggs_invalidation_threshold_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.dimension ADD CONSTRAINT dimension_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.hypertable_compression ADD CONSTRAINT hypertable_compression_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.hypertable_data_node ADD CONSTRAINT hypertable_data_node_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id); ALTER TABLE _timescaledb_catalog.tablespace ADD CONSTRAINT tablespace_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) ON DELETE CASCADE; DROP FUNCTION IF EXISTS _timescaledb_debug.extension_state; DROP SCHEMA IF EXISTS _timescaledb_debug; DROP FUNCTION IF EXISTS _timescaledb_internal.hypertable_constraint_add_table_fk_constraint; DROP FUNCTION _timescaledb_functions.constraint_clone; CREATE FUNCTION _timescaledb_functions.hypertable_constraint_add_table_fk_constraint(user_ht_constraint_name name,user_ht_schema_name name,user_ht_table_name name,compress_ht_id integer) RETURNS void LANGUAGE PLPGSQL AS $$BEGIN END$$ SET search_path TO pg_catalog,pg_temp; CREATE FUNCTION _timescaledb_functions.chunks_in(record RECORD, chunks INTEGER[]) RETURNS BOOL AS 'BEGIN END' LANGUAGE PLPGSQL SET search_path TO pg_catalog,pg_temp; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.metadata', $$ WHERE KEY = 'exported_uuid' $$); DROP TRIGGER metadata_insert_trigger ON _timescaledb_catalog.metadata; DROP FUNCTION _timescaledb_functions.metadata_insert_trigger(); DROP FUNCTION IF EXISTS _timescaledb_functions.get_orderby_defaults(regclass,text[]); DROP FUNCTION IF EXISTS _timescaledb_functions.get_segmentby_defaults(regclass); --- re-include in the pg_dump config SELECT pg_catalog.pg_extension_config_dump('_timescaledb_cache.cache_inval_hypertable', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_cache.cache_inval_extension', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_cache.cache_inval_bgw_job', ''); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_internal.job_errors', ''); -- Remove unwanted entry from extconfig and extcondition in pg_extension ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.hypertable; -- Associate the above table back to keep the dependencies safe ALTER EXTENSION timescaledb ADD TABLE _timescaledb_catalog.hypertable; -- include this now in the config SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.hypertable', ''); DROP FUNCTION IF EXISTS _timescaledb_functions.relation_approximate_size(relation REGCLASS); DROP FUNCTION IF EXISTS @extschema@.hypertable_approximate_detailed_size(relation REGCLASS); DROP FUNCTION IF EXISTS @extschema@.hypertable_approximate_size(hypertable REGCLASS); DROP FUNCTION IF EXISTS @extschema@.compress_chunk; CREATE FUNCTION @extschema@.compress_chunk(uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true) RETURNS REGCLASS AS '' LANGUAGE SQL SET search_path TO pg_catalog,pg_temp; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.14.0--2.14.1.sql���������������������������������������������������0000664�0000000�0000000�00000005164�15100345067�0020366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ CREATE VIEW timescaledb_information.hypertable_compression_settings AS SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass AS hypertable, array_to_string(segmentby,',') AS segmentby, un.orderby, d.compress_interval_length FROM _timescaledb_catalog.hypertable ht JOIN LATERAL ( SELECT CASE WHEN d.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN _timescaledb_functions.to_interval(d.compress_interval_length)::text ELSE d.compress_interval_length::text END AS compress_interval_length FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = ht.id ORDER BY id LIMIT 1 ) d ON true LEFT JOIN _timescaledb_catalog.compression_settings s ON format('%I.%I',ht.schema_name,ht.table_name)::regclass = s.relid LEFT JOIN LATERAL ( SELECT string_agg( format('%I%s%s',orderby, CASE WHEN "desc" THEN ' DESC' ELSE '' END, CASE WHEN nullsfirst AND NOT "desc" THEN ' NULLS FIRST' WHEN NOT nullsfirst AND "desc" THEN ' NULLS LAST' ELSE '' END ) ,',') AS orderby FROM unnest(s.orderby, s.orderby_desc, s.orderby_nullsfirst) un(orderby, "desc", nullsfirst) ) un ON true; CREATE VIEW timescaledb_information.chunk_compression_settings AS SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass AS hypertable, format('%I.%I',ch.schema_name,ch.table_name)::regclass AS chunk, array_to_string(segmentby,',') AS segmentby, un.orderby FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id INNER JOIN _timescaledb_catalog.chunk ch2 ON ch2.id = ch.compressed_chunk_id LEFT JOIN _timescaledb_catalog.compression_settings s ON format('%I.%I',ch2.schema_name,ch2.table_name)::regclass = s.relid LEFT JOIN LATERAL ( SELECT string_agg( format('%I%s%s',orderby, CASE WHEN "desc" THEN ' DESC' ELSE '' END, CASE WHEN nullsfirst AND NOT "desc" THEN ' NULLS FIRST' WHEN NOT nullsfirst AND "desc" THEN ' NULLS LAST' ELSE '' END ),',') AS orderby FROM unnest(s.orderby, s.orderby_desc, s.orderby_nullsfirst) un(orderby, "desc", nullsfirst) ) un ON true; INSERT INTO _timescaledb_catalog.compression_settings SELECT format('%I.%I',ch.schema_name,ch.table_name)::regclass,s.segmentby,s.orderby,s.orderby_desc,s.orderby_nullsfirst FROM _timescaledb_catalog.hypertable ht1 INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht2.id = ht1.compressed_hypertable_id INNER JOIN _timescaledb_catalog.compression_settings s ON s.relid = format('%I.%I',ht1.schema_name,ht1.table_name)::regclass INNER JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht2.id ON CONFLICT DO NOTHING; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.14.1--2.14.0.sql���������������������������������������������������0000664�0000000�0000000�00000000227�15100345067�0020361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ DROP VIEW IF EXISTS timescaledb_information.hypertable_compression_settings; DROP VIEW IF EXISTS timescaledb_information.chunk_compression_settings; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.14.1--2.14.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.14.2--2.14.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.14.2--2.15.0.sql���������������������������������������������������0000664�0000000�0000000�00000052135�15100345067�0020370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Remove multi-node CAGG support DROP FUNCTION IF EXISTS _timescaledb_internal.invalidation_cagg_log_add_entry(integer,bigint,bigint); DROP FUNCTION IF EXISTS _timescaledb_internal.invalidation_hyper_log_add_entry(integer,bigint,bigint); DROP FUNCTION IF EXISTS _timescaledb_internal.materialization_invalidation_log_delete(integer); DROP FUNCTION IF EXISTS _timescaledb_internal.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[]); DROP FUNCTION IF EXISTS _timescaledb_internal.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[],text[]); DROP FUNCTION IF EXISTS _timescaledb_internal.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[]); DROP FUNCTION IF EXISTS _timescaledb_internal.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[],text[]); DROP FUNCTION IF EXISTS _timescaledb_internal.hypertable_invalidation_log_delete(integer); DROP FUNCTION IF EXISTS _timescaledb_functions.invalidation_cagg_log_add_entry(integer,bigint,bigint); DROP FUNCTION IF EXISTS _timescaledb_functions.invalidation_hyper_log_add_entry(integer,bigint,bigint); DROP FUNCTION IF EXISTS _timescaledb_functions.materialization_invalidation_log_delete(integer); DROP FUNCTION IF EXISTS _timescaledb_functions.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[]); DROP FUNCTION IF EXISTS _timescaledb_functions.invalidation_process_cagg_log(integer,integer,regtype,bigint,bigint,integer[],bigint[],bigint[],text[]); DROP FUNCTION IF EXISTS _timescaledb_functions.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[]); DROP FUNCTION IF EXISTS _timescaledb_functions.invalidation_process_hypertable_log(integer,integer,regtype,integer[],bigint[],bigint[],text[]); DROP FUNCTION IF EXISTS _timescaledb_functions.hypertable_invalidation_log_delete(integer); -- Remove chunk metadata when marked as dropped CREATE FUNCTION _timescaledb_functions.remove_dropped_chunk_metadata(_hypertable_id INTEGER) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE _chunk_id INTEGER; _removed INTEGER := 0; BEGIN FOR _chunk_id IN SELECT id FROM _timescaledb_catalog.chunk WHERE hypertable_id = _hypertable_id AND dropped IS TRUE AND NOT EXISTS ( SELECT FROM information_schema.tables WHERE tables.table_schema = chunk.schema_name AND tables.table_name = chunk.table_name ) AND NOT EXISTS ( SELECT FROM _timescaledb_catalog.hypertable JOIN _timescaledb_catalog.continuous_agg ON continuous_agg.raw_hypertable_id = hypertable.id WHERE hypertable.id = chunk.hypertable_id -- for the old caggs format we need to keep chunk metadata for dropped chunks AND continuous_agg.finalized IS FALSE ) LOOP _removed := _removed + 1; RAISE INFO 'Removing metadata of chunk % from hypertable %', _chunk_id, _hypertable_id; WITH _dimension_slice_remove AS ( DELETE FROM _timescaledb_catalog.dimension_slice USING _timescaledb_catalog.chunk_constraint WHERE dimension_slice.id = chunk_constraint.dimension_slice_id AND chunk_constraint.chunk_id = _chunk_id AND NOT EXISTS ( SELECT FROM _timescaledb_catalog.chunk_constraint cc WHERE cc.chunk_id <> _chunk_id AND cc.dimension_slice_id = dimension_slice.id ) RETURNING _timescaledb_catalog.dimension_slice.id ) DELETE FROM _timescaledb_catalog.chunk_constraint USING _dimension_slice_remove WHERE chunk_constraint.dimension_slice_id = _dimension_slice_remove.id; DELETE FROM _timescaledb_catalog.chunk_constraint WHERE chunk_constraint.chunk_id = _chunk_id; DELETE FROM _timescaledb_internal.bgw_policy_chunk_stats WHERE bgw_policy_chunk_stats.chunk_id = _chunk_id; DELETE FROM _timescaledb_catalog.chunk_index WHERE chunk_index.chunk_id = _chunk_id; DELETE FROM _timescaledb_catalog.compression_chunk_size WHERE compression_chunk_size.chunk_id = _chunk_id OR compression_chunk_size.compressed_chunk_id = _chunk_id; DELETE FROM _timescaledb_catalog.chunk WHERE chunk.id = _chunk_id OR chunk.compressed_chunk_id = _chunk_id; END LOOP; RETURN _removed; END; $$ SET search_path TO pg_catalog, pg_temp; SELECT _timescaledb_functions.remove_dropped_chunk_metadata(id) AS chunks_metadata_removed FROM _timescaledb_catalog.hypertable; -- -- Rebuild the catalog table `_timescaledb_catalog.continuous_aggs_bucket_function` -- CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_get_bucket_function( mat_hypertable_id INTEGER ) RETURNS regprocedure AS '@MODULE_PATHNAME@', 'ts_continuous_agg_get_bucket_function' LANGUAGE C STRICT VOLATILE; -- Since we need now the regclass of the used bucket function, we have to recover it -- by parsing the view query by calling 'cagg_get_bucket_function'. CREATE TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function AS SELECT mat_hypertable_id, _timescaledb_functions.cagg_get_bucket_function(mat_hypertable_id), bucket_width, origin, NULL::text AS bucket_offset, timezone, false AS bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function ORDER BY mat_hypertable_id; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; CREATE TABLE _timescaledb_catalog.continuous_aggs_bucket_function ( mat_hypertable_id integer NOT NULL, -- The bucket function bucket_func regprocedure NOT NULL, -- `bucket_width` argument of the function, e.g. "1 month" bucket_width text NOT NULL, -- optional `origin` argument of the function provided by the user bucket_origin text, -- optional `offset` argument of the function provided by the user bucket_offset text, -- optional `timezone` argument of the function provided by the user bucket_timezone text, -- fixed or variable sized bucket bucket_fixed_width bool NOT NULL, -- table constraints CONSTRAINT continuous_aggs_bucket_function_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT * FROM _timescaledb_catalog._tmp_continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_bucket_function', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_aggs_bucket_function TO PUBLIC; ANALYZE _timescaledb_catalog.continuous_aggs_bucket_function; ALTER EXTENSION timescaledb DROP FUNCTION _timescaledb_functions.cagg_get_bucket_function(INTEGER); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_get_bucket_function(INTEGER); -- -- End rebuild the catalog table `_timescaledb_catalog.continuous_aggs_bucket_function` -- -- Convert _timescaledb_catalog.continuous_aggs_bucket_function.bucket_origin to TimestampTZ UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_origin = bucket_origin::timestamp::timestamptz::text WHERE length(bucket_origin) > 1; -- Historically, we have used empty strings for undefined bucket_origin and timezone -- attributes. This is now replaced by proper NULL values. We use TRIM() to ensure we handle empty string well. UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_origin = NULL WHERE TRIM(bucket_origin) = ''; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_timezone = NULL WHERE TRIM(bucket_timezone) = ''; -- So far, there were no difference between 0 and -1 retries. Since now on, 0 means no retries. Updating the retry -- count of existing jobs to -1 to keep the current semantics. UPDATE _timescaledb_config.bgw_job SET max_retries = -1 WHERE max_retries = 0; DROP FUNCTION IF EXISTS _timescaledb_functions.get_chunk_relstats; DROP FUNCTION IF EXISTS _timescaledb_functions.get_chunk_colstats; DROP FUNCTION IF EXISTS _timescaledb_internal.get_chunk_relstats; DROP FUNCTION IF EXISTS _timescaledb_internal.get_chunk_colstats; -- In older TSDB versions, we disabled autovacuum for compressed chunks -- to keep the statistics. However, this restriction was removed in -- #5118 but no migration was performed to remove the custom -- autovacuum setting for existing chunks. DO $$ DECLARE chunk regclass; BEGIN FOR chunk IN SELECT pg_catalog.format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk c JOIN pg_catalog.pg_class AS pc ON (pc.oid=format('%I.%I', schema_name, table_name)::regclass) CROSS JOIN unnest(reloptions) AS u(option) WHERE dropped = false AND osm_chunk = false AND option LIKE 'autovacuum_enabled%' LOOP EXECUTE pg_catalog.format('ALTER TABLE %s RESET (autovacuum_enabled);', chunk::text); END LOOP; END $$; -- -- Rebuild the catalog table `_timescaledb_catalog.continuous_agg` -- -- (1) Create missing entries in _timescaledb_catalog.continuous_aggs_bucket_function CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_get_bucket_function( mat_hypertable_id INTEGER ) RETURNS regprocedure AS '@MODULE_PATHNAME@', 'ts_continuous_agg_get_bucket_function' LANGUAGE C STRICT VOLATILE; -- Make sure function points to the new version of TSDB CREATE OR REPLACE FUNCTION _timescaledb_functions.to_interval(unixtime_us BIGINT) RETURNS INTERVAL AS '@MODULE_PATHNAME@', 'ts_pg_unix_microseconds_to_interval' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; -- We need to create entries in continuous_aggs_bucket_function for all CAggs that were treated so far -- as fixed indicated by a bucket_width != -1 INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT mat_hypertable_id, _timescaledb_functions.cagg_get_bucket_function(mat_hypertable_id), -- Intervals needs to be converted into the proper interval format -- Function name could be prefixed with 'public.'. Therefore LIKE instead of starts_with is used CASE WHEN _timescaledb_functions.cagg_get_bucket_function(mat_hypertable_id)::text LIKE '%time_bucket(interval,%' THEN _timescaledb_functions.to_interval(bucket_width)::text ELSE bucket_width::text END, NULL, -- bucket_origin NULL, -- bucket_offset NULL, -- bucket_timezone true -- bucket_fixed_width FROM _timescaledb_catalog.continuous_agg WHERE bucket_width != -1; ALTER EXTENSION timescaledb DROP FUNCTION _timescaledb_functions.cagg_get_bucket_function(INTEGER); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_get_bucket_function(INTEGER); -- (2) Rebuild catalog table DROP VIEW IF EXISTS timescaledb_experimental.policies; DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; DROP PROCEDURE IF EXISTS @extschema@.cagg_migrate (REGCLASS, BOOLEAN, BOOLEAN); DROP FUNCTION IF EXISTS _timescaledb_internal.cagg_migrate_pre_validation (TEXT, TEXT, TEXT); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_migrate_pre_validation (TEXT, TEXT, TEXT); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_create_plan (_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_create_plan (_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_migrate_plan_exists (INTEGER); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_plan (_timescaledb_catalog.continuous_agg); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_plan (_timescaledb_catalog.continuous_agg); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_create_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_create_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_disable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_disable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_enable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_enable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_copy_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_copy_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_refresh_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_copy_data (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_copy_data (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_override_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_override_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_drop_old_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_drop_old_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); ALTER TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log DROP CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_watermark DROP CONSTRAINT continuous_aggs_watermark_mat_hypertable_id_fkey; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_agg; CREATE TABLE _timescaledb_catalog._tmp_continuous_agg AS SELECT mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized FROM _timescaledb_catalog.continuous_agg ORDER BY mat_hypertable_id; DROP TABLE _timescaledb_catalog.continuous_agg; CREATE TABLE _timescaledb_catalog.continuous_agg ( mat_hypertable_id integer NOT NULL, raw_hypertable_id integer NOT NULL, parent_mat_hypertable_id integer, user_view_schema name NOT NULL, user_view_name name NOT NULL, partial_view_schema name NOT NULL, partial_view_name name NOT NULL, direct_view_schema name NOT NULL, direct_view_name name NOT NULL, materialized_only bool NOT NULL DEFAULT FALSE, finalized bool NOT NULL DEFAULT TRUE, -- table constraints CONSTRAINT continuous_agg_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_agg_partial_view_schema_partial_view_name_key UNIQUE (partial_view_schema, partial_view_name), CONSTRAINT continuous_agg_user_view_schema_user_view_name_key UNIQUE (user_view_schema, user_view_name), CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_parent_mat_hypertable_id_fkey FOREIGN KEY (parent_mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.continuous_agg SELECT * FROM _timescaledb_catalog._tmp_continuous_agg; DROP TABLE _timescaledb_catalog._tmp_continuous_agg; CREATE INDEX continuous_agg_raw_hypertable_id_idx ON _timescaledb_catalog.continuous_agg (raw_hypertable_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_agg TO PUBLIC; ALTER TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ADD CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey FOREIGN KEY (materialization_id) REFERENCES _timescaledb_catalog.continuous_agg(mat_hypertable_id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_watermark ADD CONSTRAINT continuous_aggs_watermark_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE; ANALYZE _timescaledb_catalog.continuous_agg; -- -- END Rebuild the catalog table `_timescaledb_catalog.continuous_agg` -- -- -- START bgw_job_stat_history -- DROP VIEW IF EXISTS timescaledb_information.job_errors; CREATE SEQUENCE _timescaledb_internal.bgw_job_stat_history_id_seq MINVALUE 1; CREATE TABLE _timescaledb_internal.bgw_job_stat_history ( id INTEGER NOT NULL DEFAULT nextval('_timescaledb_internal.bgw_job_stat_history_id_seq'), job_id INTEGER NOT NULL, pid INTEGER, execution_start TIMESTAMPTZ NOT NULL DEFAULT NOW(), execution_finish TIMESTAMPTZ, succeeded boolean NOT NULL DEFAULT FALSE, data jsonb, -- table constraints CONSTRAINT bgw_job_stat_history_pkey PRIMARY KEY (id) ); ALTER SEQUENCE _timescaledb_internal.bgw_job_stat_history_id_seq OWNED BY _timescaledb_internal.bgw_job_stat_history.id; CREATE INDEX bgw_job_stat_history_job_id_idx ON _timescaledb_internal.bgw_job_stat_history (job_id); REVOKE ALL ON _timescaledb_internal.bgw_job_stat_history FROM PUBLIC; INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, execution_start, execution_finish, data) SELECT job_errors.job_id, job_errors.pid, job_errors.start_time, job_errors.finish_time, jsonb_build_object('job', to_jsonb(bgw_job.*)) || jsonb_build_object('error_data', job_errors.error_data) FROM _timescaledb_internal.job_errors LEFT JOIN _timescaledb_config.bgw_job ON bgw_job.id = job_errors.job_id ORDER BY job_errors.job_id, job_errors.start_time; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_internal.job_errors; DROP TABLE _timescaledb_internal.job_errors; UPDATE _timescaledb_config.bgw_job SET scheduled = false WHERE id = 2; INSERT INTO _timescaledb_config.bgw_job ( id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, config, check_schema, check_name, fixed_schedule, initial_start ) VALUES ( 3, 'Job History Log Retention Policy [3]', INTERVAL '1 month', INTERVAL '1 hour', -1, INTERVAL '1h', '_timescaledb_functions', 'policy_job_stat_history_retention', pg_catalog.quote_ident(current_role)::regrole, true, '{"drop_after":"1 month"}', '_timescaledb_functions', 'policy_job_stat_history_retention_check', true, '2000-01-01 00:00:00+00'::timestamptz ) ON CONFLICT (id) DO NOTHING; DROP FUNCTION IF EXISTS _timescaledb_internal.policy_job_error_retention(job_id integer,config jsonb); DROP FUNCTION IF EXISTS _timescaledb_internal.policy_job_error_retention_check(config jsonb); DROP FUNCTION IF EXISTS _timescaledb_functions.policy_job_error_retention(job_id integer,config jsonb); DROP FUNCTION IF EXISTS _timescaledb_functions.policy_job_error_retention_check(config jsonb); -- -- END bgw_job_stat_history -- -- Migrate existing CAggs using time_bucket_ng to time_bucket CREATE PROCEDURE _timescaledb_functions.cagg_migrate_to_time_bucket(cagg REGCLASS) AS '@MODULE_PATHNAME@', 'ts_continuous_agg_migrate_to_time_bucket' LANGUAGE C; DO $$ DECLARE cagg_name regclass; BEGIN FOR cagg_name IN SELECT pg_catalog.format('%I.%I', user_view_schema, user_view_name)::regclass FROM _timescaledb_catalog.continuous_agg cagg JOIN _timescaledb_catalog.continuous_aggs_bucket_function AS bf ON (cagg.mat_hypertable_id = bf.mat_hypertable_id) WHERE bf.bucket_func::text LIKE '%time_bucket_ng%' LOOP CALL _timescaledb_functions.cagg_migrate_to_time_bucket(cagg_name); END LOOP; END $$; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.0--2.14.2.sql���������������������������������������������������0000664�0000000�0000000�00000034265�15100345067�0020374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION IF EXISTS _timescaledb_functions.remove_dropped_chunk_metadata(INTEGER); -- -- Rebuild the catalog table `_timescaledb_catalog.continuous_agg` -- DROP VIEW IF EXISTS timescaledb_experimental.policies; DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; DROP PROCEDURE IF EXISTS @extschema@.cagg_migrate (REGCLASS, BOOLEAN, BOOLEAN); DROP FUNCTION IF EXISTS _timescaledb_internal.cagg_migrate_pre_validation (TEXT, TEXT, TEXT); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_migrate_pre_validation (TEXT, TEXT, TEXT); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_create_plan (_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_create_plan (_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN); DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_migrate_plan_exists (INTEGER); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_plan (_timescaledb_catalog.continuous_agg); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_plan (_timescaledb_catalog.continuous_agg); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_create_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_create_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_disable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_disable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_enable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_enable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_copy_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_copy_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_refresh_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_copy_data (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_copy_data (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_override_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_override_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_drop_old_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_execute_drop_old_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); ALTER TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log DROP CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_aggs_watermark DROP CONSTRAINT continuous_aggs_watermark_mat_hypertable_id_fkey; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_agg; CREATE TABLE _timescaledb_catalog._tmp_continuous_agg AS SELECT mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, -1::bigint as bucket_width, -- -1 means variable width. Will be modified soon if not variable. direct_view_schema, direct_view_name, materialized_only, finalized FROM _timescaledb_catalog.continuous_agg ORDER BY mat_hypertable_id; -- Migrate CAggs with fixed bucket on interval back WITH fixed_buckets AS ( SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE bucket_fixed_width = true AND bucket_func::text LIKE '%time_bucket(interval%' ) UPDATE _timescaledb_catalog._tmp_continuous_agg cagg SET bucket_width = _timescaledb_functions.interval_to_usec(fb.bucket_width::interval) FROM fixed_buckets fb WHERE cagg.mat_hypertable_id = fb.mat_hypertable_id; -- Migrate CAggs with fixed bucket on integer back WITH fixed_buckets AS ( SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE bucket_fixed_width = true AND bucket_func::text NOT LIKE '%time_bucket(interval%' ) UPDATE _timescaledb_catalog._tmp_continuous_agg cagg SET bucket_width = fb.bucket_width::bigint FROM fixed_buckets fb WHERE cagg.mat_hypertable_id = fb.mat_hypertable_id; DELETE FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE bucket_fixed_width = true; DROP TABLE _timescaledb_catalog.continuous_agg; CREATE TABLE _timescaledb_catalog.continuous_agg ( mat_hypertable_id integer NOT NULL, raw_hypertable_id integer NOT NULL, parent_mat_hypertable_id integer, user_view_schema name NOT NULL, user_view_name name NOT NULL, partial_view_schema name NOT NULL, partial_view_name name NOT NULL, bucket_width bigint NOT NULL, direct_view_schema name NOT NULL, direct_view_name name NOT NULL, materialized_only bool NOT NULL DEFAULT FALSE, finalized bool NOT NULL DEFAULT TRUE, -- table constraints CONSTRAINT continuous_agg_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_agg_partial_view_schema_partial_view_name_key UNIQUE (partial_view_schema, partial_view_name), CONSTRAINT continuous_agg_user_view_schema_user_view_name_key UNIQUE (user_view_schema, user_view_name), CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_parent_mat_hypertable_id_fkey FOREIGN KEY (parent_mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.continuous_agg SELECT * FROM _timescaledb_catalog._tmp_continuous_agg; DROP TABLE _timescaledb_catalog._tmp_continuous_agg; CREATE INDEX continuous_agg_raw_hypertable_id_idx ON _timescaledb_catalog.continuous_agg (raw_hypertable_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_agg TO PUBLIC; ALTER TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ADD CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey FOREIGN KEY (materialization_id) REFERENCES _timescaledb_catalog.continuous_agg(mat_hypertable_id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_aggs_watermark ADD CONSTRAINT continuous_aggs_watermark_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE; ANALYZE _timescaledb_catalog.continuous_agg; -- -- END Rebuild the catalog table `_timescaledb_catalog.continuous_agg` -- -- -- Rebuild the catalog table `_timescaledb_catalog.continuous_aggs_bucket_function` -- UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_origin = '' WHERE bucket_origin IS NULL; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_timezone = '' WHERE bucket_timezone IS NULL; CREATE TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function AS SELECT mat_hypertable_id, CASE WHEN bucket_func::text like 'timescaledb_experimental%' THEN true ELSE false END, split_part(bucket_func::regproc::text, '.', 2), bucket_width, bucket_origin, bucket_timezone FROM _timescaledb_catalog.continuous_aggs_bucket_function ORDER BY mat_hypertable_id; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; CREATE TABLE _timescaledb_catalog.continuous_aggs_bucket_function ( mat_hypertable_id integer NOT NULL, -- The schema of the function. Equals TRUE for "timescaledb_experimental", FALSE otherwise. experimental bool NOT NULL, -- Name of the bucketing function, e.g. "time_bucket" or "time_bucket_ng" name text NOT NULL, -- `bucket_width` argument of the function, e.g. "1 month" bucket_width text NOT NULL, -- `origin` argument of the function provided by the user origin text NOT NULL, -- `timezone` argument of the function provided by the user timezone text NOT NULL, -- table constraints CONSTRAINT continuous_aggs_bucket_function_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT * FROM _timescaledb_catalog._tmp_continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_bucket_function', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_aggs_bucket_function TO PUBLIC; ANALYZE _timescaledb_catalog.continuous_aggs_bucket_function; -- -- End rebuild the catalog table `_timescaledb_catalog.continuous_aggs_bucket_function` -- -- Convert _timescaledb_catalog.continuous_aggs_bucket_function.origin back to Timestamp UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET origin = origin::timestamptz::timestamp::text WHERE length(origin) > 1; -- only create stub CREATE FUNCTION _timescaledb_functions.get_chunk_relstats(relid REGCLASS) RETURNS TABLE(chunk_id INTEGER, hypertable_id INTEGER, num_pages INTEGER, num_tuples REAL, num_allvisible INTEGER) AS $$BEGIN END$$ LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.get_chunk_colstats(relid REGCLASS) RETURNS TABLE(chunk_id INTEGER, hypertable_id INTEGER, att_num INTEGER, nullfrac REAL, width INTEGER, distinctval REAL, slotkind INTEGER[], slotopstrings CSTRING[], slotcollations OID[], slot1numbers FLOAT4[], slot2numbers FLOAT4[], slot3numbers FLOAT4[], slot4numbers FLOAT4[], slot5numbers FLOAT4[], slotvaluetypetrings CSTRING[], slot1values CSTRING[], slot2values CSTRING[], slot3values CSTRING[], slot4values CSTRING[], slot5values CSTRING[]) AS $$BEGIN END$$ LANGUAGE plpgsql SET search_path = pg_catalog, pg_temp; -- -- START bgw_job_stat_history -- DROP VIEW IF EXISTS timescaledb_information.job_errors; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.job_history; DROP VIEW IF EXISTS timescaledb_information.job_history; CREATE TABLE _timescaledb_internal.job_errors ( job_id integer not null, pid integer, start_time timestamptz, finish_time timestamptz, error_data jsonb ); INSERT INTO _timescaledb_internal.job_errors (job_id, pid, start_time, finish_time, error_data) SELECT job_id, pid, execution_start, execution_finish, data->'error_data' FROM _timescaledb_internal.bgw_job_stat_history WHERE succeeded IS FALSE ORDER BY job_id, execution_start; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_internal.bgw_job_stat_history; DROP TABLE IF EXISTS _timescaledb_internal.bgw_job_stat_history; REVOKE ALL ON _timescaledb_internal.job_errors FROM PUBLIC; DROP FUNCTION IF EXISTS _timescaledb_internal.policy_job_stat_history_retention(job_id integer,config jsonb); DROP FUNCTION IF EXISTS _timescaledb_internal.policy_job_stat_history_retention_check(config jsonb); DROP FUNCTION IF EXISTS _timescaledb_functions.policy_job_stat_history_retention(job_id integer,config jsonb); DROP FUNCTION IF EXISTS _timescaledb_functions.policy_job_stat_history_retention_check(config jsonb); CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_job_error_retention(job_id integer, config JSONB) RETURNS integer LANGUAGE PLPGSQL AS $BODY$ DECLARE drop_after INTERVAL; numrows INTEGER; BEGIN SELECT config->>'drop_after' INTO STRICT drop_after; WITH deleted AS (DELETE FROM _timescaledb_internal.job_errors WHERE finish_time < (now() - drop_after) RETURNING *) SELECT count(*) FROM deleted INTO numrows; RETURN numrows; END; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.policy_job_error_retention_check(config JSONB) RETURNS VOID LANGUAGE PLPGSQL AS $BODY$ DECLARE drop_after interval; BEGIN IF config IS NULL THEN RAISE EXCEPTION 'config cannot be NULL, and must contain drop_after'; END IF; SELECT config->>'drop_after' INTO STRICT drop_after; IF drop_after IS NULL THEN RAISE EXCEPTION 'drop_after interval not provided'; END IF ; END; $BODY$ SET search_path TO pg_catalog, pg_temp; UPDATE _timescaledb_config.bgw_job SET scheduled = true WHERE id = 2; DELETE FROM _timescaledb_config.bgw_job WHERE id = 3; DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_to_time_bucket(cagg REGCLASS); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.0--2.15.1.sql���������������������������������������������������0000664�0000000�0000000�00000003720�15100345067�0020364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function AS SELECT mat_hypertable_id, bucket_func::text AS bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function ORDER BY mat_hypertable_id; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; CREATE TABLE _timescaledb_catalog.continuous_aggs_bucket_function ( mat_hypertable_id integer NOT NULL, -- The bucket function bucket_func text NOT NULL, -- `bucket_width` argument of the function, e.g. "1 month" bucket_width text NOT NULL, -- optional `origin` argument of the function provided by the user bucket_origin text, -- optional `offset` argument of the function provided by the user bucket_offset text, -- optional `timezone` argument of the function provided by the user bucket_timezone text, -- fixed or variable sized bucket bucket_fixed_width bool NOT NULL, -- table constraints CONSTRAINT continuous_aggs_bucket_function_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_aggs_bucket_function_func_check CHECK (pg_catalog.to_regprocedure(bucket_func) IS DISTINCT FROM 0) ); INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT * FROM _timescaledb_catalog._tmp_continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_bucket_function', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_aggs_bucket_function TO PUBLIC; ANALYZE _timescaledb_catalog.continuous_aggs_bucket_function; ������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.1--2.15.0.sql���������������������������������������������������0000664�0000000�0000000�00000003562�15100345067�0020370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function AS SELECT mat_hypertable_id, pg_catalog.to_regprocedure(bucket_func) AS bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function ORDER BY mat_hypertable_id; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog.continuous_aggs_bucket_function; CREATE TABLE _timescaledb_catalog.continuous_aggs_bucket_function ( mat_hypertable_id integer NOT NULL, -- The bucket function bucket_func regprocedure NOT NULL, -- `bucket_width` argument of the function, e.g. "1 month" bucket_width text NOT NULL, -- optional `origin` argument of the function provided by the user bucket_origin text, -- optional `offset` argument of the function provided by the user bucket_offset text, -- optional `timezone` argument of the function provided by the user bucket_timezone text, -- fixed or variable sized bucket bucket_fixed_width bool NOT NULL, -- table constraints CONSTRAINT continuous_aggs_bucket_function_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_aggs_bucket_function_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT * FROM _timescaledb_catalog._tmp_continuous_aggs_bucket_function; DROP TABLE _timescaledb_catalog._tmp_continuous_aggs_bucket_function; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_bucket_function', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_aggs_bucket_function TO PUBLIC; ANALYZE _timescaledb_catalog.continuous_aggs_bucket_function; ����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.1--2.15.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.2--2.15.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.2--2.15.3.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020354�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.3--2.15.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020354�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.15.3--2.16.0.sql���������������������������������������������������0000664�0000000�0000000�00000007602�15100345067�0020372�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Enable tracking of statistics on a column of a hypertable. -- -- hypertable - OID of the table to which the column belongs to -- column_name - The column to track statistics for -- if_not_exists - If set, and the entry already exists, generate a notice instead of an error CREATE FUNCTION @extschema@.enable_chunk_skipping( hypertable REGCLASS, column_name NAME, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(column_stats_id INT, enabled BOOL) AS 'SELECT NULL,NULL' LANGUAGE SQL VOLATILE SET search_path = pg_catalog, pg_temp; -- Disable tracking of statistics on a column of a hypertable. -- -- hypertable - OID of the table to remove from -- column_name - NAME of the column on which the stats are tracked -- if_not_exists - If set, and the entry does not exist, -- generate a notice instead of an error CREATE FUNCTION @extschema@.disable_chunk_skipping( hypertable REGCLASS, column_name NAME, if_not_exists BOOLEAN = FALSE ) RETURNS TABLE(hypertable_id INT, column_name NAME, disabled BOOL) AS 'SELECT NULL,NULL,NULL' LANGUAGE SQL VOLATILE SET search_path = pg_catalog, pg_temp; -- Track statistics for columns of chunks from a hypertable. -- Currently, we track the min/max range for a given column across chunks. -- More statistics (like bloom filters) will be added in the future. -- -- A "special" entry for a column with invalid chunk_id, PG_INT64_MAX, -- PG_INT64_MIN indicates that min/max ranges could be computed for this column -- for chunks. -- -- The ranges can overlap across chunks. The values could be out-of-date if -- modifications/changes occur in the corresponding chunk and such entries -- should be marked as "invalid" to ensure that the chunk is in -- appropriate state to be able to use these values. Thus these entries -- are different from dimension_slice which is used for tracking partitioning -- column ranges which have different characteristics. -- -- Currently this catalog supports datatypes like INT, SERIAL, BIGSERIAL, -- DATE, TIMESTAMP etc. by storing the ranges in bigint columns. In the -- future, we could support additional datatypes (which support btree style -- >, <, = comparators) by storing their textual representation. -- CREATE TABLE _timescaledb_catalog.chunk_column_stats ( id serial NOT NULL, hypertable_id integer NOT NULL, chunk_id integer NOT NULL, column_name name NOT NULL, range_start bigint NOT NULL, range_end bigint NOT NULL, valid boolean NOT NULL, -- table constraints CONSTRAINT chunk_column_stats_pkey PRIMARY KEY (id), CONSTRAINT chunk_column_stats_ht_id_chunk_id_colname_key UNIQUE (hypertable_id, chunk_id, column_name), CONSTRAINT chunk_column_stats_range_check CHECK (range_start <= range_end), CONSTRAINT chunk_column_stats_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id), CONSTRAINT chunk_column_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_column_stats', ''); SELECT pg_catalog.pg_extension_config_dump(pg_get_serial_sequence('_timescaledb_catalog.chunk_column_stats', 'id'), ''); GRANT SELECT ON _timescaledb_catalog.chunk_column_stats TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.chunk_column_stats_id_seq TO PUBLIC; -- Remove foreign key constraints from compressed chunks DO $$ DECLARE conrelid regclass; conname name; BEGIN FOR conrelid, conname IN SELECT con.conrelid::regclass, con.conname FROM _timescaledb_catalog.chunk ch JOIN pg_constraint con ON con.conrelid = format('%I.%I',schema_name,table_name)::regclass AND con.contype='f' WHERE NOT ch.dropped AND EXISTS(SELECT FROM _timescaledb_catalog.chunk ch2 WHERE NOT ch2.dropped AND ch2.compressed_chunk_id=ch.id) LOOP EXECUTE format('ALTER TABLE %s DROP CONSTRAINT %I', conrelid, conname); END LOOP; END $$; ������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.16.0--2.15.3.sql���������������������������������������������������0000664�0000000�0000000�00000002251�15100345067�0020365�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION IF EXISTS _timescaledb_functions.cagg_get_bucket_function_info(INTEGER); -- remove chunk column statistics related objects DROP FUNCTION IF EXISTS @extschema@.enable_chunk_skipping(REGCLASS, NAME, BOOLEAN); DROP FUNCTION IF EXISTS @extschema@.disable_chunk_skipping(REGCLASS, NAME, BOOLEAN); ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk_column_stats; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.chunk_column_stats_id_seq; DROP TABLE IF EXISTS _timescaledb_catalog.chunk_column_stats; -- Add foreign key constraints back to compressed chunks DO $$ DECLARE chunkrelid regclass; conname name; conoid oid; BEGIN FOR chunkrelid, conname, conoid IN SELECT format('%I.%I',ch.schema_name,ch.table_name)::regclass, con.conname, con.oid FROM _timescaledb_catalog.hypertable ht JOIN pg_constraint con ON con.contype = 'f' AND con.conrelid=format('%I.%I',ht.schema_name,ht.table_name)::regclass JOIN _timescaledb_catalog.chunk ch on ch.hypertable_id=ht.compressed_hypertable_id and not ch.dropped LOOP EXECUTE format('ALTER TABLE %s ADD CONSTRAINT %I %s', chunkrelid, conname, pg_get_constraintdef(conoid)); END LOOP; END $$; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.16.0--2.16.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.16.1--2.16.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.16.1--2.17.0.sql���������������������������������������������������0000664�0000000�0000000�00000001041�15100345067�0020361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE FUNCTION _timescaledb_functions.compressed_data_info(_timescaledb_internal.compressed_data) RETURNS TABLE (algorithm name, has_nulls bool) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C STRICT IMMUTABLE SET search_path = pg_catalog, pg_temp; CREATE INDEX compression_chunk_size_idx ON _timescaledb_catalog.compression_chunk_size (compressed_chunk_id); CREATE FUNCTION _timescaledb_functions.drop_osm_chunk(hypertable REGCLASS) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.17.0--2.16.1.sql���������������������������������������������������0000664�0000000�0000000�00000010622�15100345067�0020366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- check whether we can safely downgrade the existing compression setup CREATE OR REPLACE FUNCTION _timescaledb_functions.add_sequence_number_metadata_column( comp_ch_schema_name text, comp_ch_table_name text ) RETURNS BOOL LANGUAGE PLPGSQL AS $BODY$ DECLARE chunk_schema_name text; chunk_table_name text; index_name text; segmentby_columns text; BEGIN SELECT ch.schema_name, ch.table_name INTO STRICT chunk_schema_name, chunk_table_name FROM _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.chunk comp_ch ON ch.compressed_chunk_id = comp_ch.id WHERE comp_ch.schema_name = comp_ch_schema_name AND comp_ch.table_name = comp_ch_table_name; IF NOT FOUND THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'Cannot migrate compressed chunk to version 2.16.1, chunk not found'; END IF; -- Add sequence number column to compressed chunk EXECUTE format('ALTER TABLE %s.%s ADD COLUMN _ts_meta_sequence_num INT DEFAULT NULL', comp_ch_schema_name, comp_ch_table_name); -- Remove all indexes from compressed chunk FOR index_name IN SELECT format('%s.%s', i.schemaname, i.indexname) FROM pg_indexes i WHERE i.schemaname = comp_ch_schema_name AND i.tablename = comp_ch_table_name LOOP EXECUTE format('DROP INDEX %s;', index_name); END LOOP; -- Fetch the segmentby columns from compression settings SELECT string_agg(cs.segmentby_column, ',') INTO segmentby_columns FROM ( SELECT unnest(segmentby) FROM _timescaledb_catalog.compression_settings WHERE relid = format('%s.%s', comp_ch_schema_name, comp_ch_table_name)::regclass::oid AND segmentby IS NOT NULL ) AS cs(segmentby_column); -- Create compressed chunk index based on sequence num metadata column -- If there is no segmentby columns, we can skip creating the index IF FOUND AND segmentby_columns IS NOT NULL THEN EXECUTE format('CREATE INDEX ON %s.%s (%s, _ts_meta_sequence_num);', comp_ch_schema_name, comp_ch_table_name, segmentby_columns); END IF; -- Mark compressed chunk as unordered -- Marking the chunk status bit (2) makes it unordered -- and disables some optimizations. In order to re-enable -- them, you need to recompress these chunks. UPDATE _timescaledb_catalog.chunk SET status = status | 2 -- set unordered bit WHERE schema_name = chunk_schema_name AND table_name = chunk_table_name; RETURN true; END $BODY$ SET search_path TO pg_catalog, pg_temp; DO $$ DECLARE chunk_count int; chunk_record record; BEGIN -- if we find chunks which don't have sequence number metadata column in -- compressed chunk, we need to stop downgrade and have the user run -- a migration script to re-add the missing columns SELECT count(*) INTO STRICT chunk_count FROM _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.chunk uncomp_ch ON uncomp_ch.compressed_chunk_id = ch.id WHERE not exists ( SELECT FROM pg_attribute att WHERE attrelid=format('%I.%I',ch.schema_name,ch.table_name)::regclass AND attname='_ts_meta_sequence_num') AND NOT uncomp_ch.dropped; -- Doing the migration if we find 10 or less chunks that need to be migrated IF chunk_count > 10 THEN RAISE USING ERRCODE = 'feature_not_supported', MESSAGE = 'Cannot downgrade compressed hypertables with chunks that do not contain sequence numbers. Run timescaledb--2.17-2.16.1.sql migration script before downgrading.', DETAIL = 'Number of chunks that need to be migrated: '|| chunk_count::text; ELSIF chunk_count > 0 THEN FOR chunk_record IN SELECT comp_ch.* FROM _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.chunk comp_ch ON ch.compressed_chunk_id = comp_ch.id WHERE not exists ( SELECT FROM pg_attribute att WHERE attrelid=format('%I.%I',comp_ch.schema_name,comp_ch.table_name)::regclass AND attname='_ts_meta_sequence_num') AND NOT ch.dropped LOOP PERFORM _timescaledb_functions.add_sequence_number_metadata_column(chunk_record.schema_name, chunk_record.table_name); RAISE LOG 'Migrated compressed chunk %s.%s to version 2.16.1', chunk_record.schema_name, chunk_record.table_name; END LOOP; RAISE LOG 'Migration successful!'; END IF; END $$; DROP FUNCTION _timescaledb_functions.add_sequence_number_metadata_column(text, text); DROP FUNCTION _timescaledb_functions.compressed_data_info(_timescaledb_internal.compressed_data); DROP INDEX _timescaledb_catalog.compression_chunk_size_idx; DROP FUNCTION IF EXISTS _timescaledb_functions.drop_osm_chunk(REGCLASS); ��������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.17.0--2.17.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020354�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.17.1--2.17.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020354�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.17.1--2.17.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.17.2--2.17.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.17.2--2.18.0.sql���������������������������������������������������0000664�0000000�0000000�00000015176�15100345067�0020402�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- remove obsolete job DELETE FROM _timescaledb_config.bgw_job WHERE id = 2; -- Hypercore updates CREATE FUNCTION _timescaledb_debug.is_compressed_tid(tid) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C STRICT; DROP FUNCTION IF EXISTS @extschema@.compress_chunk(uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN, recompress BOOLEAN); CREATE FUNCTION @extschema@.compress_chunk( uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true, recompress BOOLEAN = false, hypercore_use_access_method BOOL = NULL ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP FUNCTION IF EXISTS @extschema@.add_compression_policy(hypertable REGCLASS, compress_after "any", if_not_exists BOOL, schedule_interval INTERVAL, initial_start TIMESTAMPTZ, timezone TEXT, compress_created_before INTERVAL); CREATE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, compress_created_before INTERVAL = NULL, hypercore_use_access_method BOOL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP FUNCTION IF EXISTS timescaledb_experimental.add_policies(relation REGCLASS, if_not_exists BOOL, refresh_start_offset "any", refresh_end_offset "any", compress_after "any", drop_after "any"); CREATE FUNCTION timescaledb_experimental.add_policies( relation REGCLASS, if_not_exists BOOL = false, refresh_start_offset "any" = NULL, refresh_end_offset "any" = NULL, compress_after "any" = NULL, drop_after "any" = NULL, hypercore_use_access_method BOOL = NULL) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute(job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, use_creation_time BOOLEAN); DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression(job_id INTEGER, config JSONB); CREATE PROCEDURE @extschema@.convert_to_columnstore( chunk REGCLASS, if_not_columnstore BOOLEAN = true, recompress BOOLEAN = false, hypercore_use_access_method BOOL = NULL) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C; CREATE PROCEDURE @extschema@.convert_to_rowstore( chunk REGCLASS, if_columnstore BOOLEAN = true) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C; CREATE PROCEDURE @extschema@.add_columnstore_policy( hypertable REGCLASS, after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, created_before INTERVAL = NULL, hypercore_use_access_method BOOL = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE PROCEDURE @extschema@.remove_columnstore_policy( hypertable REGCLASS, if_exists BOOL = false ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE FUNCTION @extschema@.chunk_columnstore_stats (hypertable REGCLASS) RETURNS TABLE ( chunk_schema name, chunk_name name, compression_status text, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE SQL STABLE STRICT AS 'SELECT * FROM @extschema@.chunk_compression_stats($1)' SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION @extschema@.hypertable_columnstore_stats (hypertable REGCLASS) RETURNS TABLE ( total_chunks bigint, number_compressed_chunks bigint, before_compression_table_bytes bigint, before_compression_index_bytes bigint, before_compression_toast_bytes bigint, before_compression_total_bytes bigint, after_compression_table_bytes bigint, after_compression_index_bytes bigint, after_compression_toast_bytes bigint, after_compression_total_bytes bigint, node_name name) LANGUAGE SQL STABLE STRICT AS 'SELECT * FROM @extschema@.hypertable_compression_stats($1)' SET search_path TO pg_catalog, pg_temp; -- Recreate `refresh_continuous_aggregate` procedure to add `force` argument DROP PROCEDURE IF EXISTS @extschema@.refresh_continuous_aggregate (continuous_aggregate REGCLASS, window_start "any", window_end "any"); CREATE PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN = FALSE ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; -- Add `include_tiered_data` argument to `add_continuous_aggregate_policy` DROP FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL, initial_start TIMESTAMPTZ, timezone TEXT ); CREATE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, include_tiered_data BOOL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; -- Merge chunks CREATE PROCEDURE @extschema@.merge_chunks( chunk1 REGCLASS, chunk2 REGCLASS ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE PROCEDURE @extschema@.merge_chunks( chunks REGCLASS[] ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE FUNCTION ts_hypercore_handler(internal) RETURNS table_am_handler AS 'heap_tableam_handler' LANGUAGE internal; CREATE FUNCTION ts_hypercore_proxy_handler(internal) RETURNS index_am_handler AS 'bthandler' LANGUAGE internal; CREATE ACCESS METHOD hypercore TYPE TABLE HANDLER ts_hypercore_handler; COMMENT ON ACCESS METHOD hypercore IS 'Storage engine using hybrid row/columnar compression'; CREATE ACCESS METHOD hypercore_proxy TYPE INDEX HANDLER ts_hypercore_proxy_handler; COMMENT ON ACCESS METHOD hypercore_proxy IS 'Hypercore proxy index access method'; CREATE OPERATOR CLASS int4_ops DEFAULT FOR TYPE int4 USING hypercore_proxy AS OPERATOR 1 = (int4, int4), FUNCTION 1 hashint4(int4); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.18.0--2.17.2.sql���������������������������������������������������0000664�0000000�0000000�00000010600�15100345067�0020365�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Hypercore AM DROP ACCESS METHOD IF EXISTS hypercore_proxy; DROP FUNCTION IF EXISTS ts_hypercore_proxy_handler; DROP ACCESS METHOD IF EXISTS hypercore; DROP FUNCTION IF EXISTS ts_hypercore_handler; DROP FUNCTION IF EXISTS _timescaledb_debug.is_compressed_tid; DROP FUNCTION IF EXISTS @extschema@.compress_chunk(uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN, recompress BOOLEAN, hypercore_use_access_method BOOL); CREATE FUNCTION @extschema@.compress_chunk( uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true, recompress BOOLEAN = false ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_compress_chunk' LANGUAGE C STRICT VOLATILE; DROP FUNCTION IF EXISTS @extschema@.add_compression_policy(hypertable REGCLASS, compress_after "any", if_not_exists BOOL, schedule_interval INTERVAL, initial_start TIMESTAMPTZ, timezone TEXT, compress_created_before INTERVAL, hypercore_use_access_method BOOL); CREATE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, compress_created_before INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_compression_add' LANGUAGE C VOLATILE; DROP FUNCTION IF EXISTS timescaledb_experimental.add_policies(relation REGCLASS, if_not_exists BOOL, refresh_start_offset "any", refresh_end_offset "any", compress_after "any", drop_after "any", hypercore_use_access_method BOOL); CREATE FUNCTION timescaledb_experimental.add_policies( relation REGCLASS, if_not_exists BOOL = false, refresh_start_offset "any" = NULL, refresh_end_offset "any" = NULL, compress_after "any" = NULL, drop_after "any" = NULL) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_policies_add' LANGUAGE C VOLATILE; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute(job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, use_creation_time BOOLEAN, useam BOOLEAN); DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression(job_id INTEGER, config JSONB); DROP PROCEDURE IF EXISTS @extschema@.convert_to_columnstore(REGCLASS, BOOLEAN, BOOLEAN, BOOLEAN); DROP PROCEDURE IF EXISTS @extschema@.convert_to_rowstore(REGCLASS, BOOLEAN); DROP PROCEDURE IF EXISTS @extschema@.add_columnstore_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT, INTERVAL, BOOL); DROP PROCEDURE IF EXISTS @extschema@.remove_columnstore_policy(REGCLASS, BOOL); DROP FUNCTION IF EXISTS @extschema@.hypertable_columnstore_stats(REGCLASS); DROP FUNCTION IF EXISTS @extschema@.chunk_columnstore_stats(REGCLASS); ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.hypertable_columnstore_settings; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.chunk_columnstore_settings; DROP VIEW timescaledb_information.hypertable_columnstore_settings; DROP VIEW timescaledb_information.chunk_columnstore_settings; DROP PROCEDURE IF EXISTS _timescaledb_functions.cagg_migrate_update_watermark(INTEGER); -- Recreate `refresh_continuous_aggregate` procedure to remove the `force` argument DROP PROCEDURE IF EXISTS @extschema@.refresh_continuous_aggregate (continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN); CREATE PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any" ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_continuous_agg_refresh'; -- Remove `include_tiered_data` argument from `add_continuous_aggregate_policy` DROP FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL, initial_start TIMESTAMPTZ, timezone TEXT, include_tiered_data BOOL ); CREATE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_add' LANGUAGE C VOLATILE; -- Merge chunks DROP PROCEDURE IF EXISTS @extschema@.merge_chunks(chunk1 REGCLASS, chunk2 REGCLASS); DROP PROCEDURE IF EXISTS @extschema@.merge_chunks(chunks REGCLASS[]); ��������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.18.0--2.18.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.18.1--2.18.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.18.1--2.18.2.sql���������������������������������������������������0000664�0000000�0000000�00000000212�15100345067�0020365�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ALTER TABLE _timescaledb_internal.bgw_job_stat_history ALTER COLUMN succeeded DROP NOT NULL, ALTER COLUMN succeeded DROP DEFAULT; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.18.2--2.18.1.sql���������������������������������������������������0000664�0000000�0000000�00000000360�15100345067�0020371�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������UPDATE _timescaledb_internal.bgw_job_stat_history SET succeeded = FALSE WHERE succeeded IS NULL; ALTER TABLE _timescaledb_internal.bgw_job_stat_history ALTER COLUMN succeeded SET NOT NULL, ALTER COLUMN succeeded SET DEFAULT FALSE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.18.2--2.19.0.sql���������������������������������������������������0000664�0000000�0000000�00000007374�15100345067�0020405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE FUNCTION _timescaledb_functions.compressed_data_has_nulls(_timescaledb_internal.compressed_data) RETURNS BOOL LANGUAGE C STRICT IMMUTABLE AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; INSERT INTO _timescaledb_catalog.compression_algorithm( id, version, name, description) values ( 5, 1, 'COMPRESSION_ALGORITHM_BOOL', 'bool'), ( 6, 1, 'COMPRESSION_ALGORITHM_NULL', 'null') ; ------------------------------- -- Update compression settings ------------------------------- CREATE TABLE _timescaledb_catalog.tempsettings (LIKE _timescaledb_catalog.compression_settings); INSERT INTO _timescaledb_catalog.tempsettings SELECT * FROM _timescaledb_catalog.compression_settings; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_settings; DROP TABLE _timescaledb_catalog.compression_settings CASCADE; CREATE TABLE _timescaledb_catalog.compression_settings ( relid regclass NOT NULL, compress_relid regclass NULL, segmentby text[], orderby text[], orderby_desc bool[], orderby_nullsfirst bool[], CONSTRAINT compression_settings_pkey PRIMARY KEY (relid), CONSTRAINT compression_settings_check_segmentby CHECK (array_ndims(segmentby) = 1), CONSTRAINT compression_settings_check_orderby_null CHECK ((orderby IS NULL AND orderby_desc IS NULL AND orderby_nullsfirst IS NULL) OR (orderby IS NOT NULL AND orderby_desc IS NOT NULL AND orderby_nullsfirst IS NOT NULL)), CONSTRAINT compression_settings_check_orderby_cardinality CHECK (array_ndims(orderby) = 1 AND array_ndims(orderby_desc) = 1 AND array_ndims(orderby_nullsfirst) = 1 AND cardinality(orderby) = cardinality(orderby_desc) AND cardinality(orderby) = cardinality(orderby_nullsfirst)) ); -- Insert updated settings INSERT INTO _timescaledb_catalog.compression_settings SELECT CASE WHEN h.schema_name IS NOT NULL THEN cs.relid ELSE format('%I.%I', ch.schema_name, ch.table_name)::regclass END AS relid, CASE WHEN h.schema_name IS NOT NULL THEN NULL ELSE cs.relid END AS compress_relid, cs.segmentby, cs.orderby, cs.orderby_desc, cs.orderby_nullsfirst FROM _timescaledb_catalog.tempsettings cs INNER JOIN pg_class c ON (cs.relid = c.oid) INNER JOIN pg_namespace ns ON (ns.oid = c.relnamespace) LEFT JOIN _timescaledb_catalog.hypertable h ON (h.schema_name = ns.nspname AND h.table_name = c.relname) LEFT JOIN _timescaledb_catalog.chunk cch ON (cch.schema_name = ns.nspname AND cch.table_name = c.relname) LEFT JOIN _timescaledb_catalog.chunk ch ON (cch.id = ch.compressed_chunk_id); -- Add index on secondary compressed relid key CREATE INDEX compression_settings_compress_relid_idx ON _timescaledb_catalog.compression_settings (compress_relid); DROP TABLE _timescaledb_catalog.tempsettings CASCADE; GRANT SELECT ON _timescaledb_catalog.compression_settings TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_settings', ''); -- New add_continuous_aggregate_policy API for incremental refresh policy DROP FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL, initial_start TIMESTAMPTZ, timezone TEXT, include_tiered_data BOOL ); CREATE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, include_tiered_data BOOL = NULL, buckets_per_batch INTEGER = NULL, max_batches_per_execution INTEGER = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE;��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.0--2.18.2.sql���������������������������������������������������0000664�0000000�0000000�00000005631�15100345067�0020377�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP FUNCTION IF EXISTS _timescaledb_functions.compressed_data_has_nulls(_timescaledb_internal.compressed_data); DELETE FROM _timescaledb_catalog.compression_algorithm WHERE id = 5 AND version = 1 AND name = 'COMPRESSION_ALGORITHM_BOOL'; DELETE FROM _timescaledb_catalog.compression_algorithm WHERE id = 6 AND version = 1 AND name = 'COMPRESSION_ALGORITHM_NULL'; -- Update compression settings CREATE TABLE _timescaledb_catalog.tempsettings (LIKE _timescaledb_catalog.compression_settings); INSERT INTO _timescaledb_catalog.tempsettings SELECT * FROM _timescaledb_catalog.compression_settings; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_settings; DROP TABLE _timescaledb_catalog.compression_settings CASCADE; CREATE TABLE _timescaledb_catalog.compression_settings ( relid regclass NOT NULL, segmentby text[], orderby text[], orderby_desc bool[], orderby_nullsfirst bool[], CONSTRAINT compression_settings_pkey PRIMARY KEY (relid), CONSTRAINT compression_settings_check_segmentby CHECK (array_ndims(segmentby) = 1), CONSTRAINT compression_settings_check_orderby_null CHECK ((orderby IS NULL AND orderby_desc IS NULL AND orderby_nullsfirst IS NULL) OR (orderby IS NOT NULL AND orderby_desc IS NOT NULL AND orderby_nullsfirst IS NOT NULL)), CONSTRAINT compression_settings_check_orderby_cardinality CHECK (array_ndims(orderby) = 1 AND array_ndims(orderby_desc) = 1 AND array_ndims(orderby_nullsfirst) = 1 AND cardinality(orderby) = cardinality(orderby_desc) AND cardinality(orderby) = cardinality(orderby_nullsfirst)) ); -- Revert information in compression settings INSERT INTO _timescaledb_catalog.compression_settings SELECT CASE WHEN cs.compress_relid IS NULL THEN cs.relid ELSE cs.compress_relid END as relid, cs.segmentby, cs.orderby, cs.orderby_desc, cs.orderby_nullsfirst FROM _timescaledb_catalog.tempsettings cs; DROP TABLE _timescaledb_catalog.tempsettings CASCADE; GRANT SELECT ON _timescaledb_catalog.compression_settings TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_settings', ''); -- Revert add_continuous_aggregate_policy API for incremental refresh policy DROP FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL, initial_start TIMESTAMPTZ, timezone TEXT, include_tiered_data BOOL, buckets_per_batch INTEGER, max_batches_per_execution INTEGER ); CREATE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, include_tiered_data BOOL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE;�������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.0--2.19.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.1--2.19.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.1--2.19.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.2--2.19.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.2--2.19.3.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.3--2.19.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.19.3--2.20.0.sql���������������������������������������������������0000664�0000000�0000000�00000014121�15100345067�0020363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Type for bloom filters used by the sparse indexes on compressed hypertables. CREATE TYPE _timescaledb_internal.bloom1; CREATE FUNCTION _timescaledb_functions.bloom1in(cstring) RETURNS _timescaledb_internal.bloom1 AS 'byteain' LANGUAGE INTERNAL STRICT IMMUTABLE PARALLEL SAFE; CREATE FUNCTION _timescaledb_functions.bloom1out(_timescaledb_internal.bloom1) RETURNS cstring AS 'byteaout' LANGUAGE INTERNAL STRICT IMMUTABLE PARALLEL SAFE; CREATE TYPE _timescaledb_internal.bloom1 ( INPUT = _timescaledb_functions.bloom1in, OUTPUT = _timescaledb_functions.bloom1out, LIKE = bytea ); CREATE FUNCTION _timescaledb_functions.bloom1_contains(_timescaledb_internal.bloom1, anyelement) RETURNS bool AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; DROP FUNCTION IF EXISTS _timescaledb_internal.create_chunk_table; DROP FUNCTION IF EXISTS _timescaledb_functions.create_chunk_table; -- New option `refresh_newest_first` for incremental cagg refresh policy DROP FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL, initial_start TIMESTAMPTZ, timezone TEXT, include_tiered_data BOOL, buckets_per_batch INTEGER, max_batches_per_execution INTEGER ); CREATE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, include_tiered_data BOOL = NULL, buckets_per_batch INTEGER = NULL, max_batches_per_execution INTEGER = NULL, refresh_newest_first BOOL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; UPDATE _timescaledb_catalog.hypertable SET chunk_sizing_func_schema = '_timescaledb_functions' WHERE chunk_sizing_func_schema = '_timescaledb_internal' AND chunk_sizing_func_name = 'calculate_chunk_interval'; DROP VIEW IF EXISTS timescaledb_information.hypertables; -- Rename Columnstore Policy jobs to Compression Policy UPDATE _timescaledb_config.bgw_job SET application_name = replace(application_name, 'Compression Policy', 'Columnstore Policy') WHERE application_name LIKE '%Compression Policy%'; -- Split chunk CREATE PROCEDURE @extschema@.split_chunk( chunk REGCLASS, split_at "any" = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE FUNCTION _timescaledb_functions.align_to_bucket(width INTERVAL, rng ANYRANGE) RETURNS ANYRANGE AS $body$ BEGIN RETURN _timescaledb_functions.make_range_from_internal_time( rng, @extschema@.time_bucket(width, lower(rng)), @extschema@.time_bucket(width, upper(rng) - '1 microsecond'::interval) + width ); END $body$ LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.make_multirange_from_internal_time( base TSTZRANGE, low_usec BIGINT, high_usec BIGINT ) RETURNS TSTZMULTIRANGE AS $body$ select multirange(tstzrange(_timescaledb_functions.to_timestamp(low_usec), _timescaledb_functions.to_timestamp(high_usec))); $body$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.make_multirange_from_internal_time( base TSRANGE, low_usec BIGINT, high_usec BIGINT ) RETURNS TSMULTIRANGE AS $body$ select multirange(tsrange(_timescaledb_functions.to_timestamp_without_timezone(low_usec), _timescaledb_functions.to_timestamp_without_timezone(high_usec))); $body$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET search_path TO pg_catalog, pg_temp; CREATE FUNCTION _timescaledb_functions.make_range_from_internal_time( base ANYRANGE, low_usec ANYELEMENT, high_usec ANYELEMENT ) RETURNS anyrange AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_internal_time_min(REGTYPE) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_internal_time_max(REGTYPE) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; DROP FUNCTION IF EXISTS @extschema@.add_job( proc REGPROC, schedule_interval INTERVAL, config JSONB, initial_start TIMESTAMPTZ, scheduled BOOL, check_config REGPROC, fixed_schedule BOOL, timezone TEXT ); CREATE FUNCTION @extschema@.add_job( proc REGPROC, schedule_interval INTERVAL, config JSONB DEFAULT NULL, initial_start TIMESTAMPTZ DEFAULT NULL, scheduled BOOL DEFAULT true, check_config REGPROC DEFAULT NULL, fixed_schedule BOOL DEFAULT TRUE, timezone TEXT DEFAULT NULL, job_name TEXT DEFAULT NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP FUNCTION IF EXISTS @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, if_exists BOOL, check_config REGPROC, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT ); CREATE FUNCTION @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL = NULL, max_runtime INTERVAL = NULL, max_retries INTEGER = NULL, retry_period INTERVAL = NULL, scheduled BOOL = NULL, config JSONB = NULL, next_start TIMESTAMPTZ = NULL, if_exists BOOL = FALSE, check_config REGPROC = NULL, fixed_schedule BOOL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT DEFAULT NULL, job_name TEXT DEFAULT NULL ) RETURNS TABLE (job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, check_config TEXT, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT, application_name name) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE;�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.0--2.19.3.sql���������������������������������������������������0000664�0000000�0000000�00000030127�15100345067�0020367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Drop the type used by the bloom sparse indexes on compressed hypertables. DROP TYPE _timescaledb_internal.bloom1 CASCADE; CREATE FUNCTION _timescaledb_internal.create_chunk_table(hypertable REGCLASS, slices JSONB, schema_name NAME, table_name NAME) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE FUNCTION _timescaledb_functions.create_chunk_table(hypertable REGCLASS, slices JSONB, schema_name NAME, table_name NAME) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP FUNCTION _timescaledb_functions.get_hypertable_id(REGCLASS, REGTYPE); DROP FUNCTION _timescaledb_functions.get_hypertable_invalidations(REGCLASS, TIMESTAMPTZ, INTERVAL[]); DROP FUNCTION _timescaledb_functions.get_hypertable_invalidations(REGCLASS, TIMESTAMP, INTERVAL[]); DROP PROCEDURE _timescaledb_functions.accept_hypertable_invalidations(REGCLASS, TEXT); -- Revert new option `refresh_newest_first` from incremental cagg refresh policy DROP FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL, initial_start TIMESTAMPTZ, timezone TEXT, include_tiered_data BOOL, buckets_per_batch INTEGER, max_batches_per_execution INTEGER, refresh_newest_first BOOL ); CREATE FUNCTION @extschema@.add_continuous_aggregate_policy( continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, include_tiered_data BOOL = NULL, buckets_per_batch INTEGER = NULL, max_batches_per_execution INTEGER = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP VIEW IF EXISTS timescaledb_information.hypertables; -- Rename Columnstore Policy jobs to Compression Policy UPDATE _timescaledb_config.bgw_job SET application_name = replace(application_name, 'Columnstore Policy', 'Compression Policy') WHERE application_name LIKE '%Columnstore Policy%'; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, use_creation_time BOOLEAN, useam BOOLEAN = NULL) AS $$ DECLARE htoid REGCLASS; chunk_rec RECORD; numchunks INTEGER := 1; _message text; _detail text; _sqlstate text; -- fully compressed chunk status status_fully_compressed int := 1; -- chunk status bits: bit_compressed int := 1; bit_compressed_unordered int := 2; bit_frozen int := 4; bit_compressed_partial int := 8; creation_lag INTERVAL := NULL; chunks_failure INTEGER := 0; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; SELECT format('%I.%I', schema_name, table_name) INTO htoid FROM _timescaledb_catalog.hypertable WHERE id = htid; -- for the integer cases, we have to compute the lag w.r.t -- the integer_now function and then pass on to show_chunks IF pg_typeof(lag) IN ('BIGINT'::regtype, 'INTEGER'::regtype, 'SMALLINT'::regtype) THEN -- cannot have use_creation_time set with this IF use_creation_time IS TRUE THEN RAISE EXCEPTION 'job % cannot use creation time with integer_now function', job_id; END IF; lag := _timescaledb_functions.subtract_integer_from_now(htoid, lag::BIGINT); END IF; -- if use_creation_time has been specified then the lag needs to be used with the -- "compress_created_before" argument. Otherwise the usual "older_than" argument -- is good enough IF use_creation_time IS TRUE THEN creation_lag := lag; lag := NULL; END IF; FOR chunk_rec IN SELECT show.oid, ch.schema_name, ch.table_name, ch.status FROM @extschema@.show_chunks(htoid, older_than => lag, created_before => creation_lag) AS show(oid) INNER JOIN pg_class pgc ON pgc.oid = show.oid INNER JOIN pg_namespace pgns ON pgc.relnamespace = pgns.oid INNER JOIN _timescaledb_catalog.chunk ch ON ch.table_name = pgc.relname AND ch.schema_name = pgns.nspname AND ch.hypertable_id = htid WHERE NOT ch.dropped AND NOT ch.osm_chunk -- Checking for chunks which are not fully compressed and not frozen AND ch.status != status_fully_compressed AND ch.status & bit_frozen = 0 LOOP BEGIN IF chunk_rec.status = bit_compressed OR recompress_enabled IS TRUE THEN PERFORM @extschema@.compress_chunk(chunk_rec.oid, hypercore_use_access_method => useam); numchunks := numchunks + 1; END IF; EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS _message = MESSAGE_TEXT, _detail = PG_EXCEPTION_DETAIL, _sqlstate = RETURNED_SQLSTATE; RAISE WARNING 'compressing chunk "%" failed when compression policy is executed', chunk_rec.oid::regclass::text USING DETAIL = format('Message: (%s), Detail: (%s).', _message, _detail), ERRCODE = _sqlstate; chunks_failure := chunks_failure + 1; END; COMMIT; -- SET LOCAL is only active until end of transaction. -- While we could use SET at the start of the function we do not -- want to bleed out search_path to caller, so we do SET LOCAL -- again after COMMIT SET LOCAL search_path TO pg_catalog, pg_temp; IF verbose_log THEN RAISE LOG 'job % completed processing chunk %.%', job_id, chunk_rec.schema_name, chunk_rec.table_name; END IF; IF maxchunks > 0 AND numchunks >= maxchunks THEN EXIT; END IF; END LOOP; IF chunks_failure > 0 THEN RAISE EXCEPTION 'compression policy failure' USING DETAIL = format('Failed to compress %L chunks. Successfully compressed %L chunks.', chunks_failure, numchunks - chunks_failure); END IF; END; $$ LANGUAGE PLPGSQL; CREATE OR REPLACE PROCEDURE _timescaledb_functions.policy_compression(job_id INTEGER, config JSONB) AS $$ DECLARE dimtype REGTYPE; dimtypeinput REGPROC; compress_after TEXT; compress_created_before TEXT; lag_value TEXT; lag_bigint_value BIGINT; htid INTEGER; htoid REGCLASS; chunk_rec RECORD; verbose_log BOOL; maxchunks INTEGER := 0; numchunks INTEGER := 1; recompress_enabled BOOL; use_creation_time BOOL := FALSE; hypercore_use_access_method BOOL; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; IF config IS NULL THEN RAISE EXCEPTION 'job % has null config', job_id; END IF; htid := jsonb_object_field_text(config, 'hypertable_id')::INTEGER; IF htid is NULL THEN RAISE EXCEPTION 'job % config must have hypertable_id', job_id; END IF; verbose_log := COALESCE(jsonb_object_field_text(config, 'verbose_log')::BOOLEAN, FALSE); maxchunks := COALESCE(jsonb_object_field_text(config, 'maxchunks_to_compress')::INTEGER, 0); recompress_enabled := COALESCE(jsonb_object_field_text(config, 'recompress')::BOOLEAN, TRUE); -- find primary dimension type -- SELECT dim.column_type INTO dimtype FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.dimension dim ON ht.id = dim.hypertable_id WHERE ht.id = htid ORDER BY dim.id LIMIT 1; compress_after := jsonb_object_field_text(config, 'compress_after'); IF compress_after IS NULL THEN compress_created_before := jsonb_object_field_text(config, 'compress_created_before'); IF compress_created_before IS NULL THEN RAISE EXCEPTION 'job % config must have compress_after or compress_created_before', job_id; END IF; lag_value := compress_created_before; use_creation_time := true; dimtype := 'INTERVAL' ::regtype; ELSE lag_value := compress_after; END IF; hypercore_use_access_method := jsonb_object_field_text(config, 'hypercore_use_access_method')::bool; -- execute the properly type casts for the lag value CASE dimtype WHEN 'TIMESTAMP'::regtype, 'TIMESTAMPTZ'::regtype, 'DATE'::regtype, 'INTERVAL' ::regtype THEN CALL _timescaledb_functions.policy_compression_execute( job_id, htid, lag_value::INTERVAL, maxchunks, verbose_log, recompress_enabled, use_creation_time, hypercore_use_access_method ); WHEN 'BIGINT'::regtype THEN CALL _timescaledb_functions.policy_compression_execute( job_id, htid, lag_value::BIGINT, maxchunks, verbose_log, recompress_enabled, use_creation_time, hypercore_use_access_method ); WHEN 'INTEGER'::regtype THEN CALL _timescaledb_functions.policy_compression_execute( job_id, htid, lag_value::INTEGER, maxchunks, verbose_log, recompress_enabled, use_creation_time, hypercore_use_access_method ); WHEN 'SMALLINT'::regtype THEN CALL _timescaledb_functions.policy_compression_execute( job_id, htid, lag_value::SMALLINT, maxchunks, verbose_log, recompress_enabled, use_creation_time, hypercore_use_access_method ); END CASE; END; $$ LANGUAGE PLPGSQL; -- Split chunk DROP PROCEDURE IF EXISTS @extschema@.split_chunk(chunk REGCLASS, split_at "any"); DROP FUNCTION _timescaledb_functions.align_to_bucket(INTERVAL, ANYRANGE); DROP FUNCTION _timescaledb_functions.make_multirange_from_internal_time(TSTZRANGE, BIGINT, BIGINT); DROP FUNCTION _timescaledb_functions.make_multirange_from_internal_time(TSRANGE, BIGINT, BIGINT); DROP FUNCTION _timescaledb_functions.make_range_from_internal_time(ANYRANGE, ANYELEMENT, ANYELEMENT); DROP FUNCTION _timescaledb_functions.get_internal_time_min(REGTYPE); DROP FUNCTION _timescaledb_functions.get_internal_time_max(REGTYPE); DROP PROCEDURE _timescaledb_functions.add_materialization_invalidations(REGCLASS,TSRANGE); DROP PROCEDURE _timescaledb_functions.add_materialization_invalidations(REGCLASS,TSTZRANGE); DROP FUNCTION _timescaledb_functions.get_raw_materialization_ranges(REGTYPE); DROP FUNCTION _timescaledb_functions.get_materialization_invalidations(REGCLASS, TSTZRANGE); DROP FUNCTION _timescaledb_functions.get_materialization_invalidations(REGCLASS, TSRANGE); DROP FUNCTION _timescaledb_functions.get_materialization_info(REGCLASS); DROP FUNCTION IF EXISTS @extschema@.add_job( proc REGPROC, schedule_interval INTERVAL, config JSONB, initial_start TIMESTAMPTZ, scheduled BOOL, check_config REGPROC, fixed_schedule BOOL, timezone TEXT, job_name TEXT ); CREATE FUNCTION @extschema@.add_job( proc REGPROC, schedule_interval INTERVAL, config JSONB DEFAULT NULL, initial_start TIMESTAMPTZ DEFAULT NULL, scheduled BOOL DEFAULT true, check_config REGPROC DEFAULT NULL, fixed_schedule BOOL DEFAULT TRUE, timezone TEXT DEFAULT NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; DROP FUNCTION IF EXISTS @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, if_exists BOOL, check_config REGPROC, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT, job_name TEXT ); CREATE FUNCTION @extschema@.alter_job( job_id INTEGER, schedule_interval INTERVAL = NULL, max_runtime INTERVAL = NULL, max_retries INTEGER = NULL, retry_period INTERVAL = NULL, scheduled BOOL = NULL, config JSONB = NULL, next_start TIMESTAMPTZ = NULL, if_exists BOOL = FALSE, check_config REGPROC = NULL, fixed_schedule BOOL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT DEFAULT NULL ) RETURNS TABLE (job_id INTEGER, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INTEGER, retry_period INTERVAL, scheduled BOOL, config JSONB, next_start TIMESTAMPTZ, check_config TEXT, fixed_schedule BOOL, initial_start TIMESTAMPTZ, timezone TEXT) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE;�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.0--2.20.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.1--2.20.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.1--2.20.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.2--2.20.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.2--2.20.3.sql���������������������������������������������������0000664�0000000�0000000�00000000501�15100345067�0020352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Make chunk_id use NULL to mark special entries instead of 0 -- (Invalid chunk) since that doesn't work with the FK constraint on -- chunk_id. ALTER TABLE _timescaledb_catalog.chunk_column_stats ALTER COLUMN chunk_id DROP NOT NULL; UPDATE _timescaledb_catalog.chunk_column_stats SET chunk_id = NULL WHERE chunk_id = 0; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.3--2.20.2.sql���������������������������������������������������0000664�0000000�0000000�00000002063�15100345067�0020357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Add back the chunk_column_stats NOT NULL constraint. But first -- delete all entries with with NULL since they will no longer be -- allowed. Note that reverting chunk_id back to 0 because it will -- violate the FK constraint. Even if we would revert, the downgrade -- tests for "restore" would fail due to violating entries. Removing -- the entries effectively means that collecting column stats for -- those columns will be disabled. It can be enabled again after -- downgrade. We emit a warning if anything was disabled. DO $$ DECLARE num_null_chunk_ids int; BEGIN SELECT count(*) INTO num_null_chunk_ids FROM _timescaledb_catalog.chunk_column_stats WHERE chunk_id IS NULL; IF num_null_chunk_ids > 0 THEN RAISE WARNING 'chunk skipping has been disabled for all hypertables' USING HINT = 'Use enable_chunk_skipping() to re-enable chunk skipping'; END IF; END $$; DELETE FROM _timescaledb_catalog.chunk_column_stats WHERE chunk_id IS NULL; ALTER TABLE _timescaledb_catalog.chunk_column_stats ALTER COLUMN chunk_id SET NOT NULL; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.20.3--2.21.0.sql���������������������������������������������������0000664�0000000�0000000�00000005053�15100345067�0020360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE PROCEDURE _timescaledb_functions.process_hypertable_invalidations( hypertable REGCLASS ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE PROCEDURE @extschema@.add_process_hypertable_invalidations_policy( hypertable REGCLASS, schedule_interval INTERVAL, if_not_exists BOOL = false, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE PROCEDURE @extschema@.remove_process_hypertable_invalidations_policy( hypertable REGCLASS, if_exists BOOL = false ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression(job_id INTEGER, config JSONB); DROP PROCEDURE IF EXISTS _timescaledb_internal.policy_compression_execute( INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN, BOOLEAN ); DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute( INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN ); CREATE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, reindex_enabled BOOLEAN, use_creation_time BOOLEAN, useam BOOLEAN = NULL) AS $$ BEGIN -- empty body END; $$ LANGUAGE PLPGSQL; DROP PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN ); CREATE PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN = FALSE, options JSONB = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; -- since we forgot to add the compression algorithms in the previous release to the preinstall script -- we add them here with an ON CONFLICT DO NOTHING clause INSERT INTO _timescaledb_catalog.compression_algorithm( id, version, name, description) values ( 5, 1, 'COMPRESSION_ALGORITHM_BOOL', 'bool'), ( 6, 1, 'COMPRESSION_ALGORITHM_NULL', 'null') ON CONFLICT (id) DO NOTHING ; CREATE PROCEDURE @extschema@.detach_chunk( chunk REGCLASS ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE PROCEDURE @extschema@.attach_chunk( hypertable REGCLASS, chunk REGCLASS, slices JSONB ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.0--2.20.3.sql���������������������������������������������������0000664�0000000�0000000�00000003265�15100345067�0020363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DROP PROCEDURE _timescaledb_functions.process_hypertable_invalidations(REGCLASS); DROP PROCEDURE @extschema@.add_process_hypertable_invalidations_policy(REGCLASS, INTERVAL, BOOL, TIMESTAMPTZ, TEXT); DROP PROCEDURE @extschema@.remove_process_hypertable_invalidations_policy(REGCLASS, BOOL); DROP PROCEDURE _timescaledb_functions.policy_process_hypertable_invalidations(INTEGER, JSONB); DROP FUNCTION _timescaledb_functions.policy_process_hypertable_invalidations_check(JSONB); DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression(job_id INTEGER, config JSONB); DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute( INTEGER, INTEGER, ANYELEMENT, INTEGER, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN, BOOLEAN ); CREATE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, use_creation_time BOOLEAN, useam BOOLEAN = NULL) AS $$ BEGIN -- empty body END; $$ LANGUAGE PLPGSQL; DROP PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN, options JSONB ); CREATE PROCEDURE @extschema@.refresh_continuous_aggregate( continuous_aggregate REGCLASS, window_start "any", window_end "any", force BOOLEAN = FALSE ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; DROP PROCEDURE IF EXISTS @extschema@.detach_chunk(REGCLASS); DROP PROCEDURE IF EXISTS @extschema@.attach_chunk(REGCLASS, REGCLASS, JSONB); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.0--2.21.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.1--2.21.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.1--2.21.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.2--2.21.1.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.2--2.21.3.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.3--2.21.2.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.3--2.21.4.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.21.4--2.22.0.sql���������������������������������������������������0000664�0000000�0000000�00000022766�15100345067�0020375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ -- block upgrade if hypercore access method is still in use DO $$ BEGIN IF EXISTS(SELECT from pg_class c join pg_am am ON c.relam=am.oid AND am.amname='hypercore') THEN RAISE EXCEPTION 'TimescaleDB does no longer support the hypercore table access method. Convert all tables to heap access method before upgrading.'; END IF; END $$; DROP OPERATOR CLASS IF EXISTS int4_ops USING hypercore_proxy; DROP ACCESS METHOD IF EXISTS hypercore_proxy; DROP ACCESS METHOD IF EXISTS hypercore; DROP FUNCTION IF EXISTS ts_hypercore_proxy_handler; DROP FUNCTION IF EXISTS ts_hypercore_handler; DROP FUNCTION IF EXISTS _timescaledb_debug.is_compressed_tid; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute; DROP FUNCTION IF EXISTS @extschema@.add_compression_policy; DROP PROCEDURE IF EXISTS @extschema@.add_columnstore_policy; DROP FUNCTION IF EXISTS timescaledb_experimental.add_policies; DROP FUNCTION IF EXISTS @extschema@.compress_chunk; DROP PROCEDURE IF EXISTS @extschema@.convert_to_columnstore; CREATE FUNCTION @extschema@.compress_chunk( uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true, recompress BOOLEAN = false ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE PROCEDURE @extschema@.convert_to_columnstore( chunk REGCLASS, if_not_columnstore BOOLEAN = true, recompress BOOLEAN = false ) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C; CREATE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, compress_created_before INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE PROCEDURE @extschema@.add_columnstore_policy( hypertable REGCLASS, after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, created_before INTERVAL = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE FUNCTION timescaledb_experimental.add_policies( relation REGCLASS, if_not_exists BOOL = false, refresh_start_offset "any" = NULL, refresh_end_offset "any" = NULL, compress_after "any" = NULL, drop_after "any" = NULL ) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, reindex_enabled BOOLEAN, use_creation_time BOOLEAN ) AS $$ BEGIN END $$ LANGUAGE PLPGSQL; INSERT INTO _timescaledb_catalog.compression_algorithm( id, version, name, description) values ( 7, 1, 'COMPRESSION_ALGORITHM_UUID', 'uuid'); DROP FUNCTION IF EXISTS _timescaledb_internal.chunk_index_clone(oid); DROP FUNCTION IF EXISTS _timescaledb_functions.chunk_index_clone(oid); DROP FUNCTION IF EXISTS _timescaledb_internal.chunk_index_replace(oid,oid); DROP FUNCTION IF EXISTS _timescaledb_functions.chunk_index_replace(oid,oid); -- Update compression settings CREATE TABLE _timescaledb_catalog.tempsettings (LIKE _timescaledb_catalog.compression_settings); INSERT INTO _timescaledb_catalog.tempsettings SELECT * FROM _timescaledb_catalog.compression_settings; DROP VIEW IF EXISTS timescaledb_information.hypertable_columnstore_settings; DROP VIEW IF EXISTS timescaledb_information.chunk_columnstore_settings; DROP VIEW IF EXISTS timescaledb_information.hypertable_compression_settings; DROP VIEW IF EXISTS timescaledb_information.chunk_compression_settings; DROP VIEW IF EXISTS timescaledb_information.compression_settings; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_settings; DROP TABLE _timescaledb_catalog.compression_settings; CREATE TABLE _timescaledb_catalog.compression_settings ( relid regclass NOT NULL, compress_relid regclass NULL, segmentby text[], orderby text[], orderby_desc bool[], orderby_nullsfirst bool[], index jsonb, CONSTRAINT compression_settings_pkey PRIMARY KEY (relid), CONSTRAINT compression_settings_check_segmentby CHECK (array_ndims(segmentby) = 1), CONSTRAINT compression_settings_check_orderby_null CHECK ((orderby IS NULL AND orderby_desc IS NULL AND orderby_nullsfirst IS NULL) OR (orderby IS NOT NULL AND orderby_desc IS NOT NULL AND orderby_nullsfirst IS NOT NULL)), CONSTRAINT compression_settings_check_orderby_cardinality CHECK (array_ndims(orderby) = 1 AND array_ndims(orderby_desc) = 1 AND array_ndims(orderby_nullsfirst) = 1 AND cardinality(orderby) = cardinality(orderby_desc) AND cardinality(orderby) = cardinality(orderby_nullsfirst)) ); -- Insert updated settings INSERT INTO _timescaledb_catalog.compression_settings SELECT cs.relid, cs.compress_relid, cs.segmentby, cs.orderby, cs.orderby_desc, cs.orderby_nullsfirst FROM _timescaledb_catalog.tempsettings cs; -- Add index on secondary compressed relid key CREATE INDEX compression_settings_compress_relid_idx ON _timescaledb_catalog.compression_settings (compress_relid); DROP TABLE _timescaledb_catalog.tempsettings; GRANT SELECT ON _timescaledb_catalog.compression_settings TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_settings', ''); CREATE FUNCTION _timescaledb_functions.jsonb_get_matching_index_entry( config jsonb, attr_name text, target_type text ) RETURNS jsonb AS $$ BEGIN --empty body RETURN NULL; END; $$ LANGUAGE PLPGSQL SET search_path TO pg_catalog, pg_temp; --migration script CREATE FUNCTION process_single_table_index_migrate( IN target_schema TEXT, IN target_table TEXT ) RETURNS jsonb AS $$ DECLARE col_name TEXT; json_entries jsonb := '[]'; type_part TEXT; sparse_type TEXT; col_part TEXT; BEGIN -- Step 1: Loop over relevant column names FOR col_name IN SELECT column_name FROM information_schema.columns WHERE table_name = target_table AND table_schema = target_schema AND column_name LIKE '_ts_meta_v2_%' LOOP -- Step 2: Parse column name: _ts_meta_v2_<type>_<col> col_name := regexp_replace(col_name, '^_ts_meta_v2_', ''); type_part := split_part(col_name, '_', 1); col_part := substring(col_name FROM length(type_part) + 2); -- skip type and underscore IF type_part = 'bloom1' THEN sparse_type := 'bloom'; ELSIF type_part = 'min' THEN sparse_type := 'minmax'; ELSE CONTINUE; END IF; json_entries := json_entries || jsonb_build_object('type', sparse_type, 'source', 'default', 'column', col_part); END LOOP; RETURN json_entries; END; $$ LANGUAGE PLPGSQL SET search_path TO pg_catalog, pg_temp; DO $$ DECLARE rec RECORD; schema_name TEXT; table_name TEXT; json_entries JSONB; rows_updated INT; BEGIN FOR rec IN SELECT relid, compress_relid FROM _timescaledb_catalog.compression_settings WHERE index IS NULL LOOP IF rec.compress_relid IS NULL THEN CONTINUE; ELSE -- Get schema and table name from compress_relid SELECT n.nspname, c.relname INTO schema_name, table_name FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.oid = rec.compress_relid; END IF; -- Call procedure for that table json_entries := process_single_table_index_migrate(schema_name, table_name); IF jsonb_array_length(json_entries) > 0 THEN UPDATE _timescaledb_catalog.compression_settings SET index = json_entries WHERE relid = rec.relid AND index IS NULL; END IF; END LOOP; END $$; DROP FUNCTION process_single_table_index_migrate(text, text); -- add orderby minmax columns to sparse index settings UPDATE _timescaledb_catalog.compression_settings cs SET index = COALESCE(index, '[]'::jsonb) || ( SELECT jsonb_agg(jsonb_build_object( 'type', 'minmax', 'source', 'orderby', 'column', elem)) FROM unnest(cs.orderby) AS elem ) WHERE cs.orderby IS NOT NULL AND cardinality(cs.orderby) > 0 AND compress_relid IS NOT NULL; DROP FUNCTION IF EXISTS _timescaledb_internal.indexes_local_size; DROP FUNCTION IF EXISTS _timescaledb_functions.indexes_local_size; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.chunk_index; DROP TABLE IF EXISTS _timescaledb_catalog.chunk_index; -- cagg materialization ranges CREATE TABLE _timescaledb_catalog.continuous_aggs_materialization_ranges ( materialization_id integer, lowest_modified_value bigint NOT NULL, greatest_modified_value bigint NOT NULL, -- table constraints CONSTRAINT continuous_aggs_materialization_ranges_materialization_id_fkey FOREIGN KEY (materialization_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id) ON DELETE CASCADE ); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_aggs_materialization_ranges', ''); CREATE INDEX continuous_aggs_materialization_ranges_idx ON _timescaledb_catalog.continuous_aggs_materialization_ranges (materialization_id, lowest_modified_value ASC); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_aggs_materialization_ranges TO PUBLIC; ����������timescaledb-2.23.0/sql/updates/2.22.0--2.21.3.sql���������������������������������������������������0000664�0000000�0000000�00000027560�15100345067�0020371�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.continuous_aggregates; DROP VIEW timescaledb_information.continuous_aggregates; DROP PROCEDURE _timescaledb_functions.process_hypertable_invalidations(REGCLASS[]); DROP PROCEDURE _timescaledb_functions.process_hypertable_invalidations(NAME); DROP FUNCTION _timescaledb_functions.cagg_parse_invalidation_record(BYTEA); DROP FUNCTION _timescaledb_functions.has_invalidation_trigger(regclass); DROP FUNCTION _timescaledb_functions.invalidation_plugin_name(); CREATE FUNCTION ts_hypercore_handler(internal) RETURNS table_am_handler AS '@MODULE_PATHNAME@', 'ts_hypercore_handler' LANGUAGE C; CREATE FUNCTION ts_hypercore_proxy_handler(internal) RETURNS index_am_handler AS '@MODULE_PATHNAME@', 'ts_hypercore_proxy_handler' LANGUAGE C; CREATE ACCESS METHOD hypercore TYPE TABLE HANDLER ts_hypercore_handler; COMMENT ON ACCESS METHOD hypercore IS 'Storage engine using hybrid row/columnar compression'; CREATE ACCESS METHOD hypercore_proxy TYPE INDEX HANDLER ts_hypercore_proxy_handler; COMMENT ON ACCESS METHOD hypercore_proxy IS 'Hypercore proxy index access method'; CREATE OPERATOR CLASS int4_ops DEFAULT FOR TYPE int4 USING hypercore_proxy AS OPERATOR 1 = (int4, int4), FUNCTION 1 hashint4(int4); CREATE FUNCTION _timescaledb_debug.is_compressed_tid(tid) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C STRICT; DROP PROCEDURE IF EXISTS _timescaledb_functions.policy_compression_execute; DROP FUNCTION IF EXISTS @extschema@.add_compression_policy; DROP PROCEDURE IF EXISTS @extschema@.add_columnstore_policy; DROP FUNCTION IF EXISTS timescaledb_experimental.add_policies; DROP FUNCTION IF EXISTS @extschema@.compress_chunk; DROP PROCEDURE IF EXISTS @extschema@.convert_to_columnstore; DO $$ DECLARE remove_these text[]; BEGIN SELECT array_agg(format('%I.%I', user_view_schema, user_view_name)) INTO remove_these FROM _timescaledb_catalog.continuous_agg JOIN _timescaledb_catalog.hypertable ht ON raw_hypertable_id = ht.id WHERE 'ts_cagg_invalidation_trigger' NOT IN ( SELECT tgname FROM pg_trigger WHERE tgrelid = format('%I.%I', ht.schema_name, ht.table_name)::regclass ); IF array_length(remove_these, 1) > 0 THEN RAISE EXCEPTION 'cannot downgrade because there are continuous aggregates using WAL-based invalidation collection' USING ERRCODE = 'object_not_in_prerequisite_state', DETAIL = format('Please remove these CAggs before downgrade: %s.', array_to_string(remove_these, ',')); END IF; END $$; CREATE FUNCTION @extschema@.compress_chunk( uncompressed_chunk REGCLASS, if_not_compressed BOOLEAN = true, recompress BOOLEAN = false, hypercore_use_access_method BOOL = NULL ) RETURNS REGCLASS AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE PROCEDURE @extschema@.convert_to_columnstore( chunk REGCLASS, if_not_columnstore BOOLEAN = true, recompress BOOLEAN = false, hypercore_use_access_method BOOL = NULL ) AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C; CREATE FUNCTION @extschema@.add_compression_policy( hypertable REGCLASS, compress_after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, compress_created_before INTERVAL = NULL, hypercore_use_access_method BOOL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE PROCEDURE @extschema@.add_columnstore_policy( hypertable REGCLASS, after "any" = NULL, if_not_exists BOOL = false, schedule_interval INTERVAL = NULL, initial_start TIMESTAMPTZ = NULL, timezone TEXT = NULL, created_before INTERVAL = NULL, hypercore_use_access_method BOOL = NULL ) LANGUAGE C AS '@MODULE_PATHNAME@', 'ts_update_placeholder'; CREATE OR REPLACE FUNCTION timescaledb_experimental.add_policies( relation REGCLASS, if_not_exists BOOL = false, refresh_start_offset "any" = NULL, refresh_end_offset "any" = NULL, compress_after "any" = NULL, drop_after "any" = NULL, hypercore_use_access_method BOOL = NULL) RETURNS BOOL AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C VOLATILE; CREATE PROCEDURE _timescaledb_functions.policy_compression_execute( job_id INTEGER, htid INTEGER, lag ANYELEMENT, maxchunks INTEGER, verbose_log BOOLEAN, recompress_enabled BOOLEAN, reindex_enabled BOOLEAN, use_creation_time BOOLEAN, useam BOOLEAN = NULL) AS $$ BEGIN END $$ LANGUAGE PLPGSQL; DROP FUNCTION IF EXISTS _timescaledb_functions.generate_uuid_v7; DROP FUNCTION IF EXISTS _timescaledb_functions.uuid_v7_from_timestamptz; DROP FUNCTION IF EXISTS _timescaledb_functions.uuid_v7_from_timestamptz_zeroed; DROP FUNCTION IF EXISTS _timescaledb_functions.timestamptz_from_uuid_v7; DROP FUNCTION IF EXISTS _timescaledb_functions.timestamptz_from_uuid_v7_with_microseconds; DROP FUNCTION IF EXISTS _timescaledb_functions.uuid_version; DELETE FROM _timescaledb_catalog.compression_algorithm WHERE id = 7 AND version = 1 AND name = 'COMPRESSION_ALGORITHM_UUID'; -- downgrade compression settings CREATE TABLE _timescaledb_catalog.tempsettings (LIKE _timescaledb_catalog.compression_settings); INSERT INTO _timescaledb_catalog.tempsettings SELECT * FROM _timescaledb_catalog.compression_settings; DROP VIEW timescaledb_information.hypertable_columnstore_settings; DROP VIEW timescaledb_information.chunk_columnstore_settings; DROP VIEW timescaledb_information.hypertable_compression_settings; DROP VIEW timescaledb_information.chunk_compression_settings; DROP VIEW timescaledb_information.compression_settings; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.compression_settings; DROP TABLE _timescaledb_catalog.compression_settings; CREATE TABLE _timescaledb_catalog.compression_settings ( relid regclass NOT NULL, compress_relid regclass NULL, segmentby text[], orderby text[], orderby_desc bool[], orderby_nullsfirst bool[], CONSTRAINT compression_settings_pkey PRIMARY KEY (relid), CONSTRAINT compression_settings_check_segmentby CHECK (array_ndims(segmentby) = 1), CONSTRAINT compression_settings_check_orderby_null CHECK ((orderby IS NULL AND orderby_desc IS NULL AND orderby_nullsfirst IS NULL) OR (orderby IS NOT NULL AND orderby_desc IS NOT NULL AND orderby_nullsfirst IS NOT NULL)), CONSTRAINT compression_settings_check_orderby_cardinality CHECK (array_ndims(orderby) = 1 AND array_ndims(orderby_desc) = 1 AND array_ndims(orderby_nullsfirst) = 1 AND cardinality(orderby) = cardinality(orderby_desc) AND cardinality(orderby) = cardinality(orderby_nullsfirst)) ); -- Revert information in compression settings INSERT INTO _timescaledb_catalog.compression_settings SELECT cs.relid, cs.compress_relid, cs.segmentby, cs.orderby, cs.orderby_desc, cs.orderby_nullsfirst FROM _timescaledb_catalog.tempsettings cs; DROP TABLE _timescaledb_catalog.tempsettings; CREATE INDEX compression_settings_compress_relid_idx ON _timescaledb_catalog.compression_settings (compress_relid); GRANT SELECT ON _timescaledb_catalog.compression_settings TO PUBLIC; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.compression_settings', ''); DROP FUNCTION IF EXISTS _timescaledb_functions.jsonb_get_matching_index_entry(jsonb, text, text); -- block downgrade if a table has NULL orderby setting (not allowed in 2.21) DO $$ BEGIN IF EXISTS ( SELECT 1 FROM _timescaledb_catalog.compression_settings WHERE orderby IS NULL ) THEN RAISE EXCEPTION 'TimescaleDB 2.21 can not have NULL columnstore orderby settings. Use ALTER TABLE to configure them before downgrading.'; END IF; END $$; -- remove empty segmentby UPDATE _timescaledb_catalog.compression_settings SET segmentby = NULL WHERE segmentby = '{}'; DROP FUNCTION IF EXISTS _timescaledb_functions.index_matches; CREATE TABLE _timescaledb_catalog.chunk_index ( chunk_id integer NOT NULL, index_name name NOT NULL, hypertable_id integer NOT NULL, hypertable_index_name name NOT NULL, -- table constraints CONSTRAINT chunk_index_chunk_id_index_name_key UNIQUE (chunk_id, index_name), CONSTRAINT chunk_index_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk (id) ON DELETE CASCADE, CONSTRAINT chunk_index_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); CREATE INDEX chunk_index_hypertable_id_hypertable_index_name_idx ON _timescaledb_catalog.chunk_index (hypertable_id, hypertable_index_name); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.chunk_index', ''); CREATE OR REPLACE FUNCTION _timescaledb_functions.temp_index_keycolumns(oid) RETURNS text[] AS $$ SELECT array_agg(att.attname ORDER BY array_position(idx.indkey, att.attnum)) AS index_columns FROM pg_index AS idx JOIN pg_attribute AS att ON att.attrelid = idx.indrelid WHERE idx.indexrelid = $1 AND att.attnum = ANY(idx.indkey); $$ LANGUAGE SQL IMMUTABLE SET search_path TO pg_catalog, pg_temp; INSERT INTO _timescaledb_catalog.chunk_index (chunk_id, index_name, hypertable_id, hypertable_index_name) SELECT ch.id, ch_ci.relname, h.id, ht_ci.relname FROM _timescaledb_catalog.hypertable h JOIN pg_index ht_i ON ht_i.indrelid = format('%I.%I',h.schema_name,h.table_name)::regclass JOIN pg_class ht_ci ON ht_ci.oid=ht_i.indexrelid JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id=h.id AND NOT ch.dropped JOIN pg_index ch_i ON ch_i.indrelid=format('%I.%I',ch.schema_name,ch.table_name)::regclass AND ht_i.indnatts = ch_i.indnatts AND ht_i.indnkeyatts = ch_i.indnkeyatts AND ht_i.indisunique = ch_i.indisunique AND ht_i.indnullsnotdistinct = ch_i.indnullsnotdistinct AND ht_i.indisprimary = ch_i.indisprimary AND ht_i.indisexclusion = ch_i.indisexclusion AND ht_i.indimmediate = ch_i.indimmediate AND ht_i.indcollation=ch_i.indcollation AND ht_i.indclass=ch_i.indclass AND ht_i.indoption = ch_i.indoption AND ht_i.indexprs IS NOT DISTINCT FROM ch_i.indexprs AND ht_i.indpred IS NOT DISTINCT FROM ch_i.indpred AND _timescaledb_functions.temp_index_keycolumns(ht_i.indexrelid) = _timescaledb_functions.temp_index_keycolumns(ch_i.indexrelid) JOIN pg_class ch_ci ON ch_ci.oid=ch_i.indexrelid; DROP FUNCTION IF EXISTS _timescaledb_functions.temp_index_keycolumns(oid); GRANT SELECT ON TABLE _timescaledb_catalog.chunk_index TO PUBLIC; DROP FUNCTION IF EXISTS _timescaledb_functions.chunk_status_text(regclass); DROP FUNCTION IF EXISTS _timescaledb_functions.chunk_status_text(int); DO $$ DECLARE caggs_to_refresh TEXT; BEGIN IF EXISTS (SELECT FROM _timescaledb_catalog.continuous_aggs_materialization_ranges LIMIT 1) THEN SELECT string_agg(format('%I.%I', user_view_schema, user_view_name), ', ' ORDER BY user_view_schema, user_view_name) INTO caggs_to_refresh FROM _timescaledb_catalog.continuous_aggs_materialization_ranges JOIN _timescaledb_catalog.continuous_agg ON materialization_id = mat_hypertable_id; RAISE EXCEPTION 'cannot downgrade because there are pending CAgg refreshes' USING ERRCODE = 'object_not_in_prerequisite_state', DETAIL = format('Please refresh the CAggs before downgrade: %s.', caggs_to_refresh); END IF; END; $$; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_aggs_materialization_ranges; DROP TABLE IF EXISTS _timescaledb_catalog.continuous_aggs_materialization_ranges; DROP FUNCTION _timescaledb_functions.job_history_bsearch(TIMESTAMPTZ); DROP FUNCTION IF EXISTS @extschema@.generate_uuidv7(); DROP FUNCTION IF EXISTS @extschema@.to_uuidv7(timestamptz); DROP FUNCTION IF EXISTS @extschema@.to_uuidv7_boundary(timestamptz); DROP FUNCTION IF EXISTS @extschema@.uuid_timestamp(uuid); DROP FUNCTION IF EXISTS @extschema@.uuid_timestamp_micros(uuid); DROP FUNCTION IF EXISTS @extschema@.uuid_version(uuid); ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.22.0--2.22.1.sql���������������������������������������������������0000664�0000000�0000000�00000001602�15100345067�0020355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- Fix wrong migration by removing all sparse index configurations -- which only contain auto sparse indexing definitions on hypertable DO $$ DECLARE rec RECORD; num_config INT; BEGIN IF NOT EXISTS ( SELECT column_name FROM information_schema.columns WHERE table_schema = '_timescaledb_catalog' AND table_name = 'compression_settings' AND column_name = 'index') THEN RETURN; END IF; FOR rec IN SELECT relid, compress_relid, index FROM _timescaledb_catalog.compression_settings WHERE compress_relid IS NULL LOOP num_config:=0; SELECT count(*) INTO num_config FROM jsonb_array_elements(rec.index) AS idx WHERE idx::jsonb @> '{"storage":"config"}'::jsonb; IF num_config = 0 THEN UPDATE _timescaledb_catalog.compression_settings SET index = NULL WHERE relid = rec.relid; END IF; END LOOP; END $$; ������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.22.1--2.22.0.sql���������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.22.1--2.23.0.sql���������������������������������������������������0000664�0000000�0000000�00000003342�15100345067�0020361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DO $$ BEGIN UPDATE _timescaledb_config.bgw_job SET config = config || '{"max_successes_per_job": 1000, "max_failures_per_job": 1000}', schedule_interval = '6 hours' WHERE id = 3; -- system job retention RAISE WARNING 'job history configuration modified' USING DETAIL = 'The job history will only keep the last 1000 successes and failures and run once each day.'; END $$; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; -- remove cagg trigger from all hypertables and chunks DO $$ DECLARE rel regclass; BEGIN FOR rel IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.hypertable ht LOOP EXECUTE format('DROP TRIGGER IF EXISTS ts_cagg_invalidation_trigger ON %s;', rel); END LOOP; FOR rel IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk ch LOOP EXECUTE format('DROP TRIGGER IF EXISTS ts_cagg_invalidation_trigger ON %s;', rel); END LOOP; END $$; DROP FUNCTION IF EXISTS _timescaledb_internal.continuous_agg_invalidation_trigger(); DROP FUNCTION IF EXISTS _timescaledb_functions.continuous_agg_invalidation_trigger(); DROP FUNCTION IF EXISTS _timescaledb_functions.has_invalidation_trigger(regclass); -- remove ts_insert_blocker trigger from all hypertables DO $$ DECLARE rel regclass; BEGIN FOR rel IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.hypertable ht LOOP EXECUTE format('DROP TRIGGER IF EXISTS ts_insert_blocker ON %s;', rel); END LOOP; END $$; DROP FUNCTION IF EXISTS _timescaledb_internal.insert_blocker(); DROP FUNCTION IF EXISTS _timescaledb_functions.insert_blocker(); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.23.0--2.22.1.sql���������������������������������������������������0000664�0000000�0000000�00000004423�15100345067�0020362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DO $$ BEGIN UPDATE _timescaledb_config.bgw_job SET config = config - 'max_successes_per_job' - 'max_failures_per_job', schedule_interval = '1 month' WHERE id = 3; -- system job retention RAISE WARNING 'job history configuration modified' USING DETAIL = 'The job history will keep full history for each job and run once each month.'; END $$; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; CREATE OR REPLACE FUNCTION _timescaledb_functions.continuous_agg_invalidation_trigger() RETURNS TRIGGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C; -- add cagg trigger to hypertables with caggs and their chunks DO $$ DECLARE v_hypertable regclass; v_chunk regclass; v_hypertable_id integer; BEGIN FOR v_hypertable_id, v_hypertable IN SELECT ht.id, format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.hypertable ht WHERE compression_state <> 2 AND EXISTS (SELECT FROM _timescaledb_catalog.continuous_agg agg WHERE agg.raw_hypertable_id = ht.id) LOOP EXECUTE format('CREATE TRIGGER ts_cagg_invalidation_trigger AFTER INSERT OR UPDATE OR DELETE ON %s FOR EACH ROW EXECUTE FUNCTION _timescaledb_functions.continuous_agg_invalidation_trigger(''%s'');', v_hypertable, v_hypertable_id); FOR v_chunk IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = v_hypertable_id LOOP EXECUTE format('CREATE TRIGGER ts_cagg_invalidation_trigger AFTER INSERT OR UPDATE OR DELETE ON %s FOR EACH ROW EXECUTE FUNCTION _timescaledb_functions.continuous_agg_invalidation_trigger(''%s'');', v_chunk, v_hypertable_id); END LOOP; END LOOP; END $$; CREATE OR REPLACE FUNCTION _timescaledb_functions.insert_blocker() RETURNS TRIGGER AS '@MODULE_PATHNAME@', 'ts_update_placeholder' LANGUAGE C; -- add ts_insert_blocker trigger to hypertables DO $$ DECLARE v_hypertable regclass; BEGIN FOR v_hypertable IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.hypertable ht LOOP EXECUTE format('CREATE TRIGGER ts_insert_blocker BEFORE INSERT ON %s FOR EACH ROW EXECUTE FUNCTION _timescaledb_functions.insert_blocker();', v_hypertable); END LOOP; END $$; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.0--2.8.1.sql�����������������������������������������������������0000664�0000000�0000000�00000047774�15100345067�0020252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- gapfill with timezone support DROP FUNCTION @extschema@.time_bucket_gapfill(INTERVAL,TIMESTAMPTZ,TEXT,TIMESTAMPTZ,TIMESTAMPTZ); ALTER TABLE _timescaledb_catalog.compression_chunk_size DROP CONSTRAINT compression_chunk_size_pkey; ALTER TABLE _timescaledb_catalog.compression_chunk_size ADD CONSTRAINT compression_chunk_size_pkey PRIMARY KEY(chunk_id,compressed_chunk_id); DROP FUNCTION _timescaledb_internal.policy_job_error_retention(integer, JSONB); DROP FUNCTION _timescaledb_internal.policy_job_error_retention_check(JSONB); DELETE FROM _timescaledb_config.bgw_job WHERE id = 2; ALTER EXTENSION timescaledb DROP VIEW timescaledb_information.job_errors; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_internal.job_errors; DROP VIEW timescaledb_information.job_errors; DROP TABLE _timescaledb_internal.job_errors; -- drop dependent views DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.jobs; CREATE TABLE _timescaledb_internal._tmp_bgw_job_stat AS SELECT * FROM _timescaledb_internal.bgw_job_stat; DROP TABLE _timescaledb_internal.bgw_job_stat; CREATE TABLE _timescaledb_internal.bgw_job_stat ( job_id integer NOT NULL, last_start timestamptz NOT NULL DEFAULT NOW(), last_finish timestamptz NOT NULL, next_start timestamptz NOT NULL, last_successful_finish timestamptz NOT NULL, last_run_success bool NOT NULL, total_runs bigint NOT NULL, total_duration interval NOT NULL, total_successes bigint NOT NULL, total_failures bigint NOT NULL, total_crashes bigint NOT NULL, consecutive_failures int NOT NULL, consecutive_crashes int NOT NULL, -- table constraints CONSTRAINT bgw_job_stat_pkey PRIMARY KEY (job_id), CONSTRAINT bgw_job_stat_job_id_fkey FOREIGN KEY (job_id) REFERENCES _timescaledb_config.bgw_job (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_internal.bgw_job_stat SELECT job_id, last_start, last_finish, next_start, last_successful_finish, last_run_success, total_runs, total_duration, total_successes, total_failures, total_crashes, consecutive_failures, consecutive_crashes FROM _timescaledb_internal._tmp_bgw_job_stat; DROP TABLE _timescaledb_internal._tmp_bgw_job_stat; GRANT SELECT ON TABLE _timescaledb_internal.bgw_job_stat TO PUBLIC; DROP VIEW _timescaledb_internal.hypertable_chunk_local_size; DROP FUNCTION _timescaledb_internal.hypertable_local_size(name, name); CREATE FUNCTION _timescaledb_internal.hypertable_local_size( schema_name_in name, table_name_in name) RETURNS TABLE ( table_bytes BIGINT, index_bytes BIGINT, toast_bytes BIGINT, total_bytes BIGINT) LANGUAGE SQL VOLATILE STRICT AS $BODY$ /* get the main hypertable id and sizes */ WITH _hypertable AS ( SELECT id, _timescaledb_internal.relation_size(format('%I.%I', schema_name, table_name)::regclass) AS relsize FROM _timescaledb_catalog.hypertable WHERE schema_name = schema_name_in AND table_name = table_name_in ), /* project the size of the parent hypertable */ _hypertable_sizes AS ( SELECT id, COALESCE((relsize).total_size, 0) AS total_bytes, COALESCE((relsize).heap_size, 0) AS heap_bytes, COALESCE((relsize).index_size, 0) AS index_bytes, COALESCE((relsize).toast_size, 0) AS toast_bytes, 0::BIGINT AS compressed_total_size, 0::BIGINT AS compressed_index_size, 0::BIGINT AS compressed_toast_size, 0::BIGINT AS compressed_heap_size FROM _hypertable ), /* calculate the size of the hypertable chunks */ _chunk_sizes AS ( SELECT chunk_id, COALESCE(ch.total_bytes, 0) AS total_bytes, COALESCE(ch.heap_bytes, 0) AS heap_bytes, COALESCE(ch.index_bytes, 0) AS index_bytes, COALESCE(ch.toast_bytes, 0) AS toast_bytes, COALESCE(ch.compressed_total_size, 0) AS compressed_total_size, COALESCE(ch.compressed_index_size, 0) AS compressed_index_size, COALESCE(ch.compressed_toast_size, 0) AS compressed_toast_size, COALESCE(ch.compressed_heap_size, 0) AS compressed_heap_size FROM _timescaledb_internal.hypertable_chunk_local_size ch JOIN _hypertable_sizes ht ON ht.id = ch.hypertable_id ) /* calculate the SUM of the hypertable and chunk sizes */ SELECT (SUM(heap_bytes) + SUM(compressed_heap_size))::BIGINT AS heap_bytes, (SUM(index_bytes) + SUM(compressed_index_size))::BIGINT AS index_bytes, (SUM(toast_bytes) + SUM(compressed_toast_size))::BIGINT AS toast_bytes, (SUM(total_bytes) + SUM(compressed_total_size))::BIGINT AS total_bytes FROM (SELECT * FROM _hypertable_sizes UNION ALL SELECT * FROM _chunk_sizes) AS sizes; $BODY$ SET search_path TO pg_catalog, pg_temp; DROP VIEW IF EXISTS timescaledb_information.job_stats; DROP VIEW IF EXISTS timescaledb_information.jobs; DROP VIEW IF EXISTS timescaledb_experimental.policies; -- fixed schedule DROP FUNCTION IF EXISTS @extschema@.add_retention_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, BOOL); DROP FUNCTION IF EXISTS @extschema@.add_compression_policy(REGCLASS, "any", BOOL, INTERVAL); -- fixed schedule changes -- drop and recreate functions with modified signatures, modified views, modified tables DROP FUNCTION IF EXISTS @extschema@.add_job(REGPROC, INTERVAL, JSONB, TIMESTAMPTZ, BOOL, REGPROC, BOOL, TEXT); DROP FUNCTION IF EXISTS @extschema@.add_continuous_aggregate_policy(REGCLASS, "any", "any", INTERVAL, BOOL, TIMESTAMPTZ, TEXT); DROP FUNCTION IF EXISTS @extschema@.add_compression_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT); DROP FUNCTION IF EXISTS @extschema@.add_retention_policy(REGCLASS, "any", BOOL, INTERVAL, TIMESTAMPTZ, TEXT); DROP FUNCTION IF EXISTS @extschema@.add_reorder_policy(REGCLASS, NAME, BOOL, TIMESTAMPTZ, TEXT); -- recreate functions with the previous signature CREATE FUNCTION @extschema@.add_job( proc REGPROC, schedule_interval INTERVAL, config JSONB DEFAULT NULL, initial_start TIMESTAMPTZ DEFAULT NULL, scheduled BOOL DEFAULT true, check_config REGPROC DEFAULT NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_job_add' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.add_compression_policy(hypertable REGCLASS, compress_after "any", if_not_exists BOOL = false, schedule_interval INTERVAL = NULL) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_compression_add' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION @extschema@.add_retention_policy( relation REGCLASS, drop_after "any", if_not_exists BOOL = false, schedule_interval INTERVAL = NULL ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_retention_add' LANGUAGE C VOLATILE STRICT; CREATE FUNCTION @extschema@.add_continuous_aggregate_policy(continuous_aggregate REGCLASS, start_offset "any", end_offset "any", schedule_interval INTERVAL, if_not_exists BOOL = false) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_refresh_cagg_add' LANGUAGE C VOLATILE; CREATE FUNCTION @extschema@.add_reorder_policy( hypertable REGCLASS, index_name NAME, if_not_exists BOOL = false ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_policy_reorder_add' LANGUAGE C VOLATILE STRICT; DROP VIEW IF EXISTS timescaledb_information.jobs; DROP VIEW IF EXISTS timescaledb_information.job_stats; -- now need to rebuild the table ALTER TABLE _timescaledb_internal.bgw_job_stat DROP CONSTRAINT bgw_job_stat_job_id_fkey; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats DROP CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey, DROP CONSTRAINT bgw_policy_chunk_stats_job_id_fkey; CREATE TABLE _timescaledb_config.bgw_job_tmp AS SELECT * FROM _timescaledb_config.bgw_job; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_config.bgw_job; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_config.bgw_job_id_seq; CREATE TABLE _timescaledb_internal.tmp_bgw_job_seq_value AS SELECT last_value, is_called FROM _timescaledb_config.bgw_job_id_seq; DROP TABLE _timescaledb_config.bgw_job; CREATE SEQUENCE _timescaledb_config.bgw_job_id_seq MINVALUE 1000; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job_id_seq', ''); SELECT setval('_timescaledb_config.bgw_job_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_bgw_job_seq_value; DROP TABLE _timescaledb_internal.tmp_bgw_job_seq_value; CREATE TABLE _timescaledb_config.bgw_job ( id integer PRIMARY KEY DEFAULT nextval('_timescaledb_config.bgw_job_id_seq'), application_name name NOT NULL, schedule_interval interval NOT NULL, max_runtime interval NOT NULL, max_retries integer NOT NULL, retry_period interval NOT NULL, proc_schema name NOT NULL, proc_name name NOT NULL, owner name NOT NULL DEFAULT CURRENT_ROLE, scheduled bool NOT NULL DEFAULT TRUE, hypertable_id integer REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, config jsonb, check_schema NAME, check_name NAME ); INSERT INTO _timescaledb_config.bgw_job(id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, hypertable_id, config) SELECT id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, hypertable_id, config FROM _timescaledb_config.bgw_job_tmp ORDER BY id; ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq OWNED BY _timescaledb_config.bgw_job.id; CREATE INDEX bgw_job_proc_hypertable_id_idx ON _timescaledb_config.bgw_job(proc_schema,proc_name,hypertable_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_config.bgw_job', 'WHERE id >= 1000'); GRANT SELECT ON _timescaledb_config.bgw_job TO PUBLIC; GRANT SELECT ON _timescaledb_config.bgw_job_id_seq TO PUBLIC; DROP TABLE _timescaledb_config.bgw_job_tmp; ALTER TABLE _timescaledb_internal.bgw_job_stat ADD CONSTRAINT bgw_job_stat_job_id_fkey FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_internal.bgw_policy_chunk_stats ADD CONSTRAINT bgw_policy_chunk_stats_chunk_id_fkey FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE, ADD CONSTRAINT bgw_policy_chunk_stats_job_id_fkey FOREIGN KEY(job_id) REFERENCES _timescaledb_config.bgw_job(id) ON DELETE CASCADE; DROP FUNCTION _timescaledb_internal.health; -- Recreate _timescaledb_catalog.dimension table without the compress_interval_length column -- CREATE TABLE _timescaledb_internal.dimension_tmp AS SELECT * from _timescaledb_catalog.dimension; CREATE TABLE _timescaledb_internal.tmp_dimension_seq_value AS SELECT last_value, is_called FROM _timescaledb_catalog.dimension_id_seq; --drop foreign keys on dimension table ALTER TABLE _timescaledb_catalog.dimension_partition DROP CONSTRAINT dimension_partition_dimension_id_fkey; ALTER TABLE _timescaledb_catalog.dimension_slice DROP CONSTRAINT dimension_slice_dimension_id_fkey; --drop dependent views DROP VIEW IF EXISTS timescaledb_information.chunks; DROP VIEW IF EXISTS timescaledb_information.dimensions; ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.dimension; ALTER EXTENSION timescaledb DROP SEQUENCE _timescaledb_catalog.dimension_id_seq; DROP TABLE _timescaledb_catalog.dimension; CREATE TABLE _timescaledb_catalog.dimension ( id serial NOT NULL , hypertable_id integer NOT NULL, column_name name NOT NULL, column_type REGTYPE NOT NULL, aligned boolean NOT NULL, -- closed dimensions num_slices smallint NULL, partitioning_func_schema name NULL, partitioning_func name NULL, -- open dimensions (e.g., time) interval_length bigint NULL, integer_now_func_schema name NULL, integer_now_func name NULL, -- table constraints CONSTRAINT dimension_pkey PRIMARY KEY (id), CONSTRAINT dimension_hypertable_id_column_name_key UNIQUE (hypertable_id, column_name), CONSTRAINT dimension_check CHECK ((partitioning_func_schema IS NULL AND partitioning_func IS NULL) OR (partitioning_func_schema IS NOT NULL AND partitioning_func IS NOT NULL)), CONSTRAINT dimension_check1 CHECK ((num_slices IS NULL AND interval_length IS NOT NULL) OR (num_slices IS NOT NULL AND interval_length IS NULL)), CONSTRAINT dimension_check2 CHECK ((integer_now_func_schema IS NULL AND integer_now_func IS NULL) OR (integer_now_func_schema IS NOT NULL AND integer_now_func IS NOT NULL)), CONSTRAINT dimension_interval_length_check CHECK (interval_length IS NULL OR interval_length > 0), CONSTRAINT dimension_hypertable_id_fkey FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.dimension ( id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, integer_now_func_schema, integer_now_func) SELECT id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, integer_now_func_schema, integer_now_func FROM _timescaledb_internal.dimension_tmp; ALTER SEQUENCE _timescaledb_catalog.dimension_id_seq OWNED BY _timescaledb_catalog.dimension.id; SELECT setval('_timescaledb_catalog.dimension_id_seq', last_value, is_called) FROM _timescaledb_internal.tmp_dimension_seq_value; SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.dimension', ''); SELECT pg_catalog.pg_extension_config_dump(pg_get_serial_sequence('_timescaledb_catalog.dimension', 'id'), ''); --add the foreign key constraints ALTER TABLE _timescaledb_catalog.dimension_partition ADD CONSTRAINT dimension_partition_dimension_id_fkey FOREIGN KEY (dimension_id) REFERENCES _timescaledb_catalog.dimension(id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.dimension_slice ADD CONSTRAINT dimension_slice_dimension_id_fkey FOREIGN KEY (dimension_id) REFERENCES _timescaledb_catalog.dimension(id) ON DELETE CASCADE; --cleanup DROP TABLE _timescaledb_internal.dimension_tmp; DROP TABLE _timescaledb_internal.tmp_dimension_seq_value; GRANT SELECT ON _timescaledb_catalog.dimension_id_seq TO PUBLIC; GRANT SELECT ON _timescaledb_catalog.dimension TO PUBLIC; -- end recreate _timescaledb_catalog.dimension table -- -- changes related to alter_data_node() DROP INDEX _timescaledb_catalog.chunk_data_node_node_name_idx; DROP FUNCTION @extschema@.alter_data_node; -- -- Prevent downgrading if there are hierarchical continuous aggregates -- DO $$ DECLARE caggs_hierarchical TEXT; caggs_count INTEGER; BEGIN SELECT string_agg(format('%I.%I', user_view_schema, user_view_name), ', '), count(*) INTO caggs_hierarchical, caggs_count FROM _timescaledb_catalog.continuous_agg WHERE parent_mat_hypertable_id IS NOT NULL; IF caggs_count > 0 THEN RAISE EXCEPTION 'Downgrade is not possible because there are % hierarchical continuous aggregates: %', caggs_count, caggs_nested USING HINT = 'Remove the corresponding continuous aggregates manually before downgrading'; END IF; END; $$ LANGUAGE 'plpgsql'; -- -- Rebuild the catalog table `_timescaledb_catalog.continuous_agg` -- DROP VIEW IF EXISTS timescaledb_information.hypertables; DROP VIEW IF EXISTS timescaledb_information.continuous_aggregates; DROP PROCEDURE IF EXISTS @extschema@.cagg_migrate (REGCLASS, BOOLEAN, BOOLEAN); DROP FUNCTION IF EXISTS _timescaledb_internal.cagg_migrate_pre_validation (TEXT, TEXT, TEXT); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_create_plan (_timescaledb_catalog.continuous_agg, TEXT, BOOLEAN, BOOLEAN); DROP FUNCTION IF EXISTS _timescaledb_internal.cagg_migrate_plan_exists (INTEGER); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_plan (_timescaledb_catalog.continuous_agg); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_create_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_disable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_enable_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_copy_policies (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_copy_data (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_override_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); DROP PROCEDURE IF EXISTS _timescaledb_internal.cagg_migrate_execute_drop_old_cagg (_timescaledb_catalog.continuous_agg, _timescaledb_catalog.continuous_agg_migrate_plan_step); ALTER EXTENSION timescaledb DROP TABLE _timescaledb_catalog.continuous_agg; ALTER TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log DROP CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey; ALTER TABLE _timescaledb_catalog.continuous_agg_migrate_plan DROP CONSTRAINT continuous_agg_migrate_plan_mat_hypertable_id_fkey; CREATE TABLE _timescaledb_catalog._tmp_continuous_agg AS SELECT mat_hypertable_id, raw_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, bucket_width, direct_view_schema, direct_view_name, materialized_only, finalized FROM _timescaledb_catalog.continuous_agg ORDER BY mat_hypertable_id; DROP TABLE _timescaledb_catalog.continuous_agg; CREATE TABLE _timescaledb_catalog.continuous_agg ( mat_hypertable_id integer NOT NULL, raw_hypertable_id integer NOT NULL, user_view_schema name NOT NULL, user_view_name name NOT NULL, partial_view_schema name NOT NULL, partial_view_name name NOT NULL, bucket_width bigint NOT NULL, direct_view_schema name NOT NULL, direct_view_name name NOT NULL, materialized_only bool NOT NULL DEFAULT FALSE, finalized bool NOT NULL DEFAULT TRUE, -- table constraints CONSTRAINT continuous_agg_pkey PRIMARY KEY (mat_hypertable_id), CONSTRAINT continuous_agg_partial_view_schema_partial_view_name_key UNIQUE (partial_view_schema, partial_view_name), CONSTRAINT continuous_agg_user_view_schema_user_view_name_key UNIQUE (user_view_schema, user_view_name), CONSTRAINT continuous_agg_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE, CONSTRAINT continuous_agg_raw_hypertable_id_fkey FOREIGN KEY (raw_hypertable_id) REFERENCES _timescaledb_catalog.hypertable (id) ON DELETE CASCADE ); INSERT INTO _timescaledb_catalog.continuous_agg SELECT * FROM _timescaledb_catalog._tmp_continuous_agg; DROP TABLE _timescaledb_catalog._tmp_continuous_agg; CREATE INDEX continuous_agg_raw_hypertable_id_idx ON _timescaledb_catalog.continuous_agg (raw_hypertable_id); SELECT pg_catalog.pg_extension_config_dump('_timescaledb_catalog.continuous_agg', ''); GRANT SELECT ON TABLE _timescaledb_catalog.continuous_agg TO PUBLIC; ALTER TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ADD CONSTRAINT continuous_aggs_materialization_invalid_materialization_id_fkey FOREIGN KEY (materialization_id) REFERENCES _timescaledb_catalog.continuous_agg(mat_hypertable_id) ON DELETE CASCADE; ALTER TABLE _timescaledb_catalog.continuous_agg_migrate_plan ADD CONSTRAINT continuous_agg_migrate_plan_mat_hypertable_id_fkey FOREIGN KEY (mat_hypertable_id) REFERENCES _timescaledb_catalog.continuous_agg (mat_hypertable_id); ANALYZE _timescaledb_catalog.continuous_agg; -- changes related to drop_stale_chunks() DROP FUNCTION _timescaledb_internal.drop_stale_chunks; ����timescaledb-2.23.0/sql/updates/2.9.0--2.9.1.sql�����������������������������������������������������0000664�0000000�0000000�00000000074�15100345067�0020231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������GRANT SELECT ON _timescaledb_internal.job_errors to PUBLIC; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.1--2.9.0.sql�����������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020216�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.1--2.9.2.sql�����������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.2--2.9.1.sql�����������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.2--2.9.3.sql�����������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.3--2.10.0.sql����������������������������������������������������0000664�0000000�0000000�00000002512�15100345067�0020302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������CREATE OR REPLACE VIEW timescaledb_information.job_errors WITH (security_barrier = true) AS SELECT job_id, error_data ->> 'proc_schema' as proc_schema, error_data ->> 'proc_name' as proc_name, pid, start_time, finish_time, error_data ->> 'sqlerrcode' AS sqlerrcode, CASE WHEN error_data ->>'message' IS NOT NULL THEN CASE WHEN error_data ->>'detail' IS NOT NULL THEN CASE WHEN error_data ->>'hint' IS NOT NULL THEN concat(error_data ->>'message', '. ', error_data ->>'detail', '. ', error_data->>'hint') ELSE concat(error_data ->>'message', ' ', error_data ->>'detail') END ELSE CASE WHEN error_data ->>'hint' IS NOT NULL THEN concat(error_data ->>'message', '. ', error_data->>'hint') ELSE error_data ->>'message' END END ELSE 'job crash detected, see server logs' END AS err_message FROM _timescaledb_internal.job_errors LEFT JOIN _timescaledb_config.bgw_job ON (bgw_job.id = job_errors.job_id) WHERE pg_catalog.pg_has_role(current_user, (SELECT pg_catalog.pg_get_userbyid(datdba) FROM pg_catalog.pg_database WHERE datname = current_database()), 'MEMBER') IS TRUE OR pg_catalog.pg_has_role(current_user, owner, 'MEMBER') IS TRUE; REVOKE ALL ON _timescaledb_internal.job_errors FROM PUBLIC; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/2.9.3--2.9.2.sql�����������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0020222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/README.md������������������������������������������������������������0000664�0000000�0000000�00000013770�15100345067�0017606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������## General principles for statements in update/downgrade scripts 1. The `search_path` for these scripts will be locked down to `pg_catalog, pg_temp`. Locking down `search_path` happens in `pre-update.sql`. Therefore all object references need to be fully qualified unless they reference objects from `pg_catalog`. Use `@extschema@` to refer to the target schema of the installation (resolves to `public` by default). 2. Creating objects must not use IF NOT EXISTS as this will introduce privilege escalation vulnerabilities. 3. All functions should have explicit `search_path`. Setting explicit `search_path` will prevent SQL function inlining for functions and transaction control for procedures so for some functions/procedures it is acceptable to not have explicit `search_path`. Special care needs to be taken with those functions/procedures by either setting `search_path` in function body or having only fully qualified object references including operators. 4. When generating the install scripts `CREATE OR REPLACE` will be changed to `CREATE` to prevent users from precreating extension objects. Since we need `CREATE OR REPLACE` for update scripts and we don't want to maintain two versions of the sql files containing the function definitions we use `CREATE OR REPLACE` in those. 5. Any object added in a new version needs to have an equivalent `CREATE` statement in the update script without `OR REPLACE` to prevent precreation of the object. 6. The creation of new metadata tables need to be part of modfiles, similar to `ALTER`s of such tables. Otherwise, later modfiles cannot rely on those tables being present. ## Extension updates This directory contains "modfiles" (SQL scripts) with modifications that are applied when updating from one version of the extension to another. The actual update scripts are compiled from modfiles by concatenating them with the current source code (which should come at the end of the resulting update script). Update scripts can "jump" several versions by using multiple modfiles in order. There are two types of modfiles: * Transition modfiles named `<from>-<to>.sql`, where `from` and `to` indicate the (adjacent) versions transitioning between. Transition modfiles are concatenated to form the lineage from an origin version to any later version. * Origin modfiles named <version>.sql, which are included only in update scripts that origin at the particular version given in the name. So, for instance, `0.7.0.sql` is only included in the script moving from `0.7.0` to the current version, but not in, e.g., the update script for `0.4.0` to the current version. These files typically contain fixes for bugs that are specific to the origin version, but are no longer present in the transition modfiles. Notes on post_update.sql We use a special config var (timescaledb.update_script_stage ) to notify that dependencies have been setup and now timescaledb specific queries can be enabled. This is useful if we want to, for example, modify objects that need timescaledb specific syntax as part of the extension update). The scripts in post_update.sql are executed as part of the `ALTER EXTENSION` stmt. Note that modfiles that contain no changes need not exist as a file. Transition modfiles must, however, be listed in the `CMakeLists.txt` file in the parent directory for an update script to be built for that version. ## Extension downgrades You can enable the generation of a downgrade file by setting `GENERATE_DOWNGRADE_SCRIPT` to `ON`, for example: ``` ./bootstrap -DGENERATE_DOWNGRADE_SCRIPT=ON ``` To support downgrades to previous versions of the extension, it is necessary to execute CMake from a Git repository since the generation of a downgrade script requires access to the previous version files that are used to generate an update script. In addition, we only generate a downgrade script to the immediate preceeding version and not to any other preceeding versions. The source and target versions are found in be found in the file `version.config` file in the root of the source tree, where `version` is the source version and `previous_version` is the target version. Note that we have a separate field for the downgrade. A downgrade file consists of: - A prolog that is retrieved from the target version. - A version-specific piece of code that exists on the source version. - An epilog that is retrieved from the target version. The prolog consists of the files mentioned in the `PRE_UPDATE_FILES` variable in the target version of `cmake/ScriptFiles.cmake`. The version-specific code is found in the source version of the file `sql/updates/reverse-dev.sql`. The epilog consists of the files in variables `SOURCE_FILES`, `SET_POST_UPDATE_STAGE`, `POST_UPDATE_FILES`, and `UNSET_UPDATE_STAGE` in that order. For downgrades to work correctly, some rules need to be followed: 1. If you add new objects in `sql/updates/latest-dev.sql`, you need to remove them in the version-specific downgrade file. The `sql/updates/pre-update.sql` in the target version do not know about objects created in the source version, so they need to be dropped explicitly. 2. Since `sql/updates/pre-update.sql` can be executed on a later version of the extension, it might be that some objects have been removed and do not exist. Hence `DROP` calls need to use `IF NOT EXISTS`. Note that, in contrast to update scripts, downgrade scripts are not built by composing several downgrade scripts into a more extensive downgrade script. The downgrade scripts are intended to be use only in special cases and are not intended to be use to move up and down between versions at will, which is why we only generate a downgrade script to the immediately preceeding version. ### When releasing a new version When releasing a new version, please rename the file `reverse-dev.sql` to `<version>--<previous_version>.sql` and add that name to `REV_FILES` variable in the `sql/CMakeLists.txt`. This will allow generation of downgrade scripts for any version in that list, but it is currently not added. ��������timescaledb-2.23.0/sql/updates/latest-dev.sql�������������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0021076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/post-update.sql������������������������������������������������������0000664�0000000�0000000�00000014465�15100345067�0021317�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- needed post 1.7.0 to fixup continuous aggregates created in 1.7.0 --- DO $$ DECLARE vname regclass; mat_ht_id INTEGER; materialized_only bool; finalized bool; ts_major INTEGER; ts_minor INTEGER; BEGIN -- procedures with SET clause cannot execute transaction -- control so we adjust search_path in procedure body SET LOCAL search_path TO pg_catalog, pg_temp; SELECT ((string_to_array(extversion,'.'))[1])::int, ((string_to_array(extversion,'.'))[2])::int INTO ts_major, ts_minor FROM pg_extension WHERE extname = 'timescaledb'; IF ts_major >= 2 AND ts_minor >= 7 THEN CREATE PROCEDURE _timescaledb_functions.post_update_cagg_try_repair( cagg_view REGCLASS, force_rebuild BOOLEAN ) AS '@MODULE_PATHNAME@', 'ts_cagg_try_repair' LANGUAGE C; END IF; FOR vname, mat_ht_id, materialized_only, finalized IN SELECT format('%I.%I', cagg.user_view_schema, cagg.user_view_name)::regclass, cagg.mat_hypertable_id, cagg.materialized_only, cagg.finalized FROM _timescaledb_catalog.continuous_agg cagg LOOP IF ts_major < 2 THEN EXECUTE format('ALTER VIEW %s SET (timescaledb.materialized_only=%L) ', vname::text, materialized_only); ELSIF ts_major = 2 AND ts_minor < 7 THEN EXECUTE format('ALTER MATERIALIZED VIEW %s SET (timescaledb.materialized_only=%L) ', vname::text, materialized_only); ELSIF ts_major = 2 AND ts_minor >= 7 THEN SET log_error_verbosity TO VERBOSE; CALL _timescaledb_functions.post_update_cagg_try_repair(vname, false); END IF; END LOOP; IF ts_major >= 2 AND ts_minor >= 7 THEN DROP PROCEDURE IF EXISTS _timescaledb_functions.post_update_cagg_try_repair(REGCLASS, BOOLEAN); END IF; END $$ LANGUAGE PLPGSQL; -- can only be dropped after views have been rebuilt DROP FUNCTION IF EXISTS _timescaledb_internal.cagg_watermark(oid); -- For objects that are newly created, we need to set the initprivs to -- the initprivs for some table that was created in the installation -- of the TimescaleDB extension and not as part of any update. -- -- We chose the "chunk" catalog table for this since that is created -- in the first version of TimescaleDB and should have the correct -- initprivs, but we could use any other table that existed in the -- first installation. INSERT INTO _timescaledb_internal.saved_privs SELECT nspname, relname, relacl, (SELECT tmpini FROM _timescaledb_internal.saved_privs WHERE tmpnsp = '_timescaledb_catalog' AND tmpname = 'chunk') FROM pg_class JOIN pg_namespace ns ON ns.oid = relnamespace LEFT JOIN _timescaledb_internal.saved_privs ON tmpnsp = nspname AND tmpname = relname WHERE relkind IN ('r', 'v') AND nspname IN ('_timescaledb_catalog', '_timescaledb_config') OR nspname = '_timescaledb_internal' AND relname IN ('hypertable_chunk_local_size', 'compressed_chunk_stats', 'bgw_job_stat', 'bgw_policy_chunk_stats', 'job_errors') ON CONFLICT DO NOTHING; -- The above is good enough for tables and views. However sequences need to -- use the "chunk_id_seq" catalog sequence as a template INSERT INTO _timescaledb_internal.saved_privs SELECT nspname, relname, relacl, (SELECT tmpini FROM _timescaledb_internal.saved_privs WHERE tmpnsp = '_timescaledb_catalog' AND tmpname = 'chunk_id_seq') FROM pg_class JOIN pg_namespace ns ON ns.oid = relnamespace LEFT JOIN _timescaledb_internal.saved_privs ON tmpnsp = nspname AND tmpname = relname WHERE relkind IN ('S') AND nspname IN ('_timescaledb_catalog', '_timescaledb_config') OR nspname = '_timescaledb_internal' AND relname IN ('hypertable_chunk_local_size', 'compressed_chunk_stats', 'bgw_job_stat', 'bgw_policy_chunk_stats') ON CONFLICT DO NOTHING; -- We can now copy back saved initprivs. WITH to_update AS ( SELECT objoid, tmpini FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace JOIN pg_init_privs ip ON ip.objoid = cl.oid AND ip.objsubid = 0 JOIN _timescaledb_internal.saved_privs ON tmpnsp = nspname AND tmpname = relname) UPDATE pg_init_privs SET initprivs = tmpini FROM to_update WHERE to_update.objoid = pg_init_privs.objoid AND classoid = 'pg_class'::regclass AND objsubid = 0; -- Can only restore permissions on views after they have been rebuilt, -- so we restore for all types of objects here. WITH to_update AS ( SELECT cl.oid, tmpacl FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace JOIN _timescaledb_internal.saved_privs ON tmpnsp = nspname AND tmpname = relname) UPDATE pg_class cl SET relacl = tmpacl FROM to_update WHERE cl.oid = to_update.oid; DROP TABLE _timescaledb_internal.saved_privs; -- Report warning when partial aggregates are used DO $$ DECLARE cagg_name text; BEGIN FOR cagg_name IN SELECT format('%I.%I', user_view_schema, user_view_name) FROM _timescaledb_catalog.continuous_agg WHERE finalized IS FALSE ORDER BY 1 LOOP RAISE WARNING 'Continuous Aggregate "%" with old format will not be supported in the next version. You should use `cagg_migrate` procedure to migrate to the new format.', cagg_name; END LOOP; END $$; -- Create watermark record when required DO $$ DECLARE ts_version TEXT; BEGIN SELECT extversion INTO ts_version FROM pg_extension WHERE extname = 'timescaledb'; IF ts_version >= '2.11.0' THEN INSERT INTO _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) SELECT a.mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(a.mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg a LEFT JOIN _timescaledb_catalog.continuous_aggs_watermark b ON b.mat_hypertable_id = a.mat_hypertable_id WHERE b.mat_hypertable_id IS NULL ORDER BY 1; END IF; END; $$; -- Repair relations that have relacl entries for users that do not -- exist in pg_authid CALL _timescaledb_functions.repair_relation_acls(); -- Cleanup orphaned compression settings WITH orphaned_settings AS ( SELECT cs.relid, cl.relname FROM _timescaledb_catalog.compression_settings cs LEFT JOIN pg_class cl ON (cs.relid = cl.oid) WHERE cl.relname IS NULL ) DELETE FROM _timescaledb_catalog.compression_settings AS cs USING orphaned_settings AS os WHERE cs.relid = os.relid; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/pre-update.sql�������������������������������������������������������0000664�0000000�0000000�00000000361�15100345067�0021106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file is always prepended to all upgrade scripts. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/pre-version-change.sql�����������������������������������������������0000664�0000000�0000000�00000006051�15100345067�0022536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file is always prepended to all upgrade and downgrade scripts. -- This file must avoid referencing extension objects directly as that -- would limit the things we can alter in extension update/downgrade -- itself. SET LOCAL search_path TO pg_catalog, pg_temp; -- Disable parallel execution for the duration of the update process. -- This avoids version mismatch errors that would have beeen triggered by the -- parallel workers in ts_extension_check_version(). SET LOCAL max_parallel_workers = 0; -- Triggers should be disabled during upgrades to avoid having them -- invoke functions that might load an old version of the shared -- library before those functions have been updated. DROP EVENT TRIGGER IF EXISTS timescaledb_ddl_command_end; DROP EVENT TRIGGER IF EXISTS timescaledb_ddl_sql_drop; -- Since we want to call the new version of restart_background_workers we -- create a function that points to that version. The proper restart_background_workers -- may either be in _timescaledb_internal or in _timescaledb_functions -- depending on the version we are upgrading from and we can't make -- the move in this location as the new schema might not have been set up. DO $$ BEGIN IF EXISTS (SELECT FROM pg_namespace WHERE nspname='_timescaledb_functions') THEN CREATE FUNCTION _timescaledb_functions._tmp_restart_background_workers() RETURNS BOOL AS '@LOADER_PATHNAME@', 'ts_bgw_db_workers_restart' LANGUAGE C VOLATILE; PERFORM _timescaledb_functions._tmp_restart_background_workers(); DROP FUNCTION _timescaledb_functions._tmp_restart_background_workers(); ELSE -- timescaledb < 2.11 does not have _timescaledb_functions schema CREATE FUNCTION _timescaledb_internal._tmp_restart_background_workers() RETURNS BOOL AS '@LOADER_PATHNAME@', 'ts_bgw_db_workers_restart' LANGUAGE C VOLATILE; PERFORM _timescaledb_internal._tmp_restart_background_workers(); DROP FUNCTION _timescaledb_internal._tmp_restart_background_workers(); END IF; END $$; -- Table for ACL and initprivs of tables. CREATE TABLE _timescaledb_internal.saved_privs( tmpnsp name, tmpname name, tmpacl aclitem[], tmpini aclitem[], UNIQUE (tmpnsp, tmpname)); -- We save away both the ACL and the initprivs for all tables and -- views in the extension (but not for chunks and internal objects) so -- that we can restore them to the proper state after the update. INSERT INTO _timescaledb_internal.saved_privs SELECT nspname, relname, relacl, initprivs FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace JOIN pg_init_privs ip ON ip.objoid = cl.oid AND ip.objsubid = 0 AND ip.classoid = 'pg_class'::regclass WHERE nspname IN ('_timescaledb_catalog', '_timescaledb_config') OR ( relname IN ('hypertable_chunk_local_size', 'compressed_chunk_stats', 'bgw_job_stat', 'bgw_policy_chunk_stats') AND nspname = '_timescaledb_internal' ) ; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/reverse-dev.sql������������������������������������������������������0000664�0000000�0000000�00000000000�15100345067�0021255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/set_post_update_stage.sql��������������������������������������������0000664�0000000�0000000�00000000056�15100345067�0023426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set timescaledb.update_script_stage = 'post'; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/unset_update_stage.sql�����������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0022720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set timescaledb.update_script_stage = ''; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/updates/version_check.sql����������������������������������������������������0000664�0000000�0000000�00000001276�15100345067�0021670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DO $$ DECLARE catalog_version TEXT; BEGIN SELECT value INTO catalog_version FROM _timescaledb_catalog.metadata WHERE key='timescaledb_version' AND value <> '@START_VERSION@'; IF FOUND THEN RAISE EXCEPTION 'catalog version mismatch' USING DETAIL = format('current extension version is "%s" but catalog version is "%s"', '@START_VERSION@', catalog_version), HINT = 'Make sure the TimescaleDB version used to dump the database is the same as the one used to restore it.'; END IF; END$$; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/util_internal_table_ddl.sql��������������������������������������������������0000664�0000000�0000000�00000004651�15100345067�0022244�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains functions associated with creating new -- hypertables. -- Outputs the create_hypertable command to recreate the given hypertable. -- -- This is currently used internally for our single hypertable backup tool -- so that it knows how to restore the hypertable without user intervention. -- -- It only works for hypertables with up to 2 dimensions. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_create_command( table_name NAME ) RETURNS TEXT LANGUAGE PLPGSQL VOLATILE AS $BODY$ DECLARE h_id INTEGER; schema_name NAME; time_column NAME; time_interval BIGINT; space_column NAME; space_partitions INTEGER; dimension_cnt INTEGER; dimension_row record; ret TEXT; BEGIN SELECT h.id, h.schema_name FROM _timescaledb_catalog.hypertable AS h WHERE h.table_name = get_create_command.table_name INTO h_id, schema_name; IF h_id IS NULL THEN RAISE EXCEPTION 'hypertable "%" not found', table_name USING ERRCODE = 'TS101'; END IF; SELECT COUNT(*) FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = h_id INTO STRICT dimension_cnt; IF dimension_cnt > 2 THEN RAISE EXCEPTION 'get_create_command only supports hypertables with up to 2 dimensions' USING ERRCODE = 'TS101'; END IF; FOR dimension_row IN SELECT * FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = h_id LOOP IF dimension_row.interval_length IS NOT NULL THEN time_column := dimension_row.column_name; time_interval := dimension_row.interval_length; ELSIF dimension_row.num_slices IS NOT NULL THEN space_column := dimension_row.column_name; space_partitions := dimension_row.num_slices; END IF; END LOOP; ret := format($$SELECT create_hypertable('%I.%I', '%s'$$, schema_name, table_name, time_column); IF space_column IS NOT NULL THEN ret := ret || format($$, '%I', %s$$, space_column, space_partitions); END IF; ret := ret || format($$, chunk_time_interval => %s, create_default_indexes=>FALSE);$$, time_interval); RETURN ret; END $BODY$ SET search_path TO pg_catalog, pg_temp; ���������������������������������������������������������������������������������������timescaledb-2.23.0/sql/util_time.sql����������������������������������������������������������������0000664�0000000�0000000�00000011200�15100345067�0017360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- This file contains utilities for time conversion. -- Return the minimum for the type. For time types, it will be the -- Unix timestamp in microseconds. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_internal_time_min(REGTYPE) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_get_internal_time_min' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; -- Return the minimum for the type. For time types, it will be the -- Unix timestamp in microseconds. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_internal_time_max(REGTYPE) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_get_internal_time_max' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.to_unix_microseconds(ts TIMESTAMPTZ) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_pg_timestamp_to_unix_microseconds' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.to_timestamp(unixtime_us BIGINT) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_pg_unix_microseconds_to_timestamp' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.to_timestamp_without_timezone(unixtime_us BIGINT) RETURNS TIMESTAMP AS '@MODULE_PATHNAME@', 'ts_pg_unix_microseconds_to_timestamp' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.to_date(unixtime_us BIGINT) RETURNS DATE AS '@MODULE_PATHNAME@', 'ts_pg_unix_microseconds_to_date' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.to_interval(unixtime_us BIGINT) RETURNS INTERVAL AS '@MODULE_PATHNAME@', 'ts_pg_unix_microseconds_to_interval' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; -- Time can be represented in a hypertable as an int* (bigint/integer/smallint) or as a timestamp type ( -- with or without timezones). In metatables and other internal systems all time values are stored as bigint. -- Converting from int* columns to internal representation is a cast to bigint. -- Converting from timestamps to internal representation is conversion to epoch (in microseconds). CREATE OR REPLACE FUNCTION _timescaledb_functions.interval_to_usec( chunk_interval INTERVAL ) RETURNS BIGINT LANGUAGE SQL IMMUTABLE PARALLEL SAFE AS $BODY$ SELECT (int_sec * 1000000)::bigint from extract(epoch from chunk_interval) as int_sec; $BODY$ SET search_path TO pg_catalog, pg_temp; CREATE OR REPLACE FUNCTION _timescaledb_functions.time_to_internal(time_val ANYELEMENT) RETURNS BIGINT AS '@MODULE_PATHNAME@', 'ts_time_to_internal' LANGUAGE C VOLATILE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_watermark(hypertable_id INTEGER) RETURNS INT8 AS '@MODULE_PATHNAME@', 'ts_continuous_agg_watermark' LANGUAGE C STABLE STRICT PARALLEL RESTRICTED; CREATE OR REPLACE FUNCTION _timescaledb_functions.cagg_watermark_materialized(hypertable_id INTEGER) RETURNS INT8 AS '@MODULE_PATHNAME@', 'ts_continuous_agg_watermark_materialized' LANGUAGE C STABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.subtract_integer_from_now( hypertable_relid REGCLASS, lag INT8 ) RETURNS INT8 AS '@MODULE_PATHNAME@', 'ts_subtract_integer_from_now' LANGUAGE C STABLE STRICT; -- Convert integer UNIX timestamps in microsecond to a timestamp range. CREATE OR REPLACE FUNCTION _timescaledb_functions.make_multirange_from_internal_time( base tstzrange, low_usec bigint, high_usec bigint ) RETURNS TSTZMULTIRANGE AS $body$ select multirange(tstzrange(_timescaledb_functions.to_timestamp(low_usec), _timescaledb_functions.to_timestamp(high_usec))); $body$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET search_path TO pg_catalog, pg_temp; -- Convert integer UNIX timestamps in microsecond to a timestamp range. CREATE OR REPLACE FUNCTION _timescaledb_functions.make_multirange_from_internal_time( base TSRANGE, low_usec bigint, high_usec bigint ) RETURNS TSMULTIRANGE AS $body$ select multirange(tsrange(_timescaledb_functions.to_timestamp_without_timezone(low_usec), _timescaledb_functions.to_timestamp_without_timezone(high_usec))); $body$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE SET search_path TO pg_catalog, pg_temp; -- Helper function to construct a range given an existing type from -- UNIX timestamps in microsecond precision. CREATE OR REPLACE FUNCTION _timescaledb_functions.make_range_from_internal_time( base anyrange, low_usec anyelement, high_usec anyelement ) RETURNS anyrange AS '@MODULE_PATHNAME@', 'ts_make_range_from_internal_time' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/uuidv7.sql�������������������������������������������������������������������0000664�0000000�0000000�00000003136�15100345067�0016621�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION @extschema@.generate_uuidv7() RETURNS UUID AS '@MODULE_PATHNAME@', 'ts_uuid_generate_v7' LANGUAGE C VOLATILE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.to_uuidv7( ts TIMESTAMPTZ ) RETURNS UUID AS '@MODULE_PATHNAME@', 'ts_uuid_v7_from_timestamptz' LANGUAGE C VOLATILE STRICT PARALLEL SAFE; -- -- Produce a boundary UUIDv7 from a timestamp, with all otherwise -- random bits in the resulting UUID set to zero. Useful for -- time-range queries directly on a UUID column. -- CREATE OR REPLACE FUNCTION @extschema@.to_uuidv7_boundary( ts TIMESTAMPTZ ) RETURNS UUID AS '@MODULE_PATHNAME@', 'ts_uuid_v7_from_timestamptz_boundary' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; -- -- Get the v7 UUID timestamp with millisecond precision. -- CREATE OR REPLACE FUNCTION @extschema@.uuid_timestamp( uuid UUID ) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_timestamptz_from_uuid_v7' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; -- -- Get the v7 UUID timestamp with microsecond precision using the -- (optional) rand_a bits. -- CREATE OR REPLACE FUNCTION @extschema@.uuid_timestamp_micros( uuid UUID ) RETURNS TIMESTAMPTZ AS '@MODULE_PATHNAME@', 'ts_timestamptz_from_uuid_v7_with_microseconds' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION @extschema@.uuid_version( uuid UUID ) RETURNS INTEGER AS '@MODULE_PATHNAME@', 'ts_uuid_version' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/version.sql������������������������������������������������������������������0000664�0000000�0000000�00000001421�15100345067�0017056�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION _timescaledb_functions.get_git_commit() RETURNS TABLE(commit_tag TEXT, commit_hash TEXT, commit_time TIMESTAMPTZ) AS '@MODULE_PATHNAME@', 'ts_get_git_commit' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.get_os_info() RETURNS TABLE(sysname TEXT, version TEXT, release TEXT, version_pretty TEXT) AS '@MODULE_PATHNAME@', 'ts_get_os_info' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_functions.tsl_loaded() RETURNS BOOLEAN AS '@MODULE_PATHNAME@', 'ts_tsl_loaded' LANGUAGE C; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/views.sql��������������������������������������������������������������������0000664�0000000�0000000�00000041351�15100345067�0016534�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Convenience view to list all hypertables CREATE OR REPLACE VIEW timescaledb_information.hypertables AS WITH hypertable_info AS ( SELECT hypertable_id, schema_name, table_name, num_dimensions, compression_state, column_name, column_type, interval_length, (compression_state = 1) AS compression_enabled, row_number() OVER (PARTITION BY hypertable_id ORDER BY di.id) AS dimension_num FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.dimension di ON ht.id = di.hypertable_id ) SELECT ht.schema_name AS hypertable_schema, ht.table_name AS hypertable_name, t.tableowner AS owner, ht.num_dimensions, ( SELECT count(1) FROM _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.hypertable_id AND ch.dropped IS FALSE AND ch.osm_chunk IS FALSE ) AS num_chunks, ht.compression_enabled, srchtbs.tablespace_list AS tablespaces, ht.column_name AS primary_dimension, ht.column_type AS primary_dimension_type FROM hypertable_info ht JOIN pg_tables t ON ht.table_name = t.tablename AND ht.schema_name = t.schemaname LEFT JOIN _timescaledb_catalog.continuous_agg ca ON ca.mat_hypertable_id = ht.hypertable_id LEFT JOIN ( SELECT hypertable_id, array_agg(tablespace_name ORDER BY id) AS tablespace_list FROM _timescaledb_catalog.tablespace GROUP BY hypertable_id) srchtbs ON ht.hypertable_id = srchtbs.hypertable_id WHERE ht.compression_state != 2 --> no internal compression tables AND ca.mat_hypertable_id IS NULL AND ht.interval_length IS NOT NULL AND ht.dimension_num = 1; -- Get status of existing jobs. -- -- Note that we will always list all jobs that are available in the -- database, but some fields might be null if, for example, the job -- has not yet executed, or there is no hypertable associated with the -- job. CREATE OR REPLACE VIEW timescaledb_information.job_stats AS SELECT ht.schema_name AS hypertable_schema, ht.table_name AS hypertable_name, j.id AS job_id, js.last_start AS last_run_started_at, js.last_successful_finish AS last_successful_finish, CASE WHEN js.last_finish < '4714-11-24 00:00:00+00 BC' THEN NULL WHEN js.last_finish IS NOT NULL THEN CASE WHEN js.last_run_success = 't' THEN 'Success' WHEN js.last_run_success = 'f' THEN 'Failed' END END AS last_run_status, CASE WHEN pgs.state = 'active' THEN 'Running' WHEN j.scheduled = FALSE THEN 'Paused' ELSE 'Scheduled' END AS job_status, CASE WHEN js.last_finish > js.last_start THEN (js.last_finish - js.last_start) END AS last_run_duration, CASE WHEN j.scheduled THEN js.next_start END AS next_start, js.total_runs, js.total_successes, js.total_failures FROM _timescaledb_config.bgw_job j LEFT JOIN _timescaledb_internal.bgw_job_stat js ON j.id = js.job_id LEFT JOIN _timescaledb_catalog.hypertable ht ON j.hypertable_id = ht.id LEFT JOIN pg_stat_activity pgs ON pgs.datname = current_database() AND pgs.application_name = j.application_name ORDER BY ht.schema_name, ht.table_name; -- view for background worker jobs CREATE OR REPLACE VIEW timescaledb_information.jobs AS SELECT j.id AS job_id, j.application_name, j.schedule_interval, j.max_runtime, j.max_retries, j.retry_period, j.proc_schema, j.proc_name, j.owner, j.scheduled, j.fixed_schedule, j.config, js.next_start, j.initial_start, COALESCE(ca.user_view_schema, ht.schema_name) AS hypertable_schema, COALESCE(ca.user_view_name, ht.table_name) AS hypertable_name, j.check_schema, j.check_name FROM _timescaledb_config.bgw_job j LEFT JOIN _timescaledb_catalog.hypertable ht ON ht.id = j.hypertable_id LEFT JOIN _timescaledb_internal.bgw_job_stat js ON js.job_id = j.id LEFT JOIN _timescaledb_catalog.continuous_agg ca ON ca.mat_hypertable_id = j.hypertable_id; -- views for continuous aggregate queries --- CREATE OR REPLACE VIEW timescaledb_information.continuous_aggregates AS SELECT ht.schema_name AS hypertable_schema, ht.table_name AS hypertable_name, cagg.user_view_schema AS view_schema, cagg.user_view_name AS view_name, viewinfo.viewowner AS view_owner, cagg.materialized_only, CASE WHEN mat_ht.compressed_hypertable_id IS NOT NULL THEN TRUE ELSE FALSE END AS compression_enabled, mat_ht.schema_name AS materialization_hypertable_schema, mat_ht.table_name AS materialization_hypertable_name, directview.viewdefinition AS view_definition, cagg.finalized FROM _timescaledb_catalog.continuous_agg cagg, _timescaledb_catalog.hypertable ht, LATERAL ( SELECT C.oid, pg_get_userbyid(C.relowner) AS viewowner FROM pg_class C LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace) WHERE C.relkind = 'v' AND C.relname = cagg.user_view_name AND N.nspname = cagg.user_view_schema) viewinfo, LATERAL ( SELECT pg_get_viewdef(C.oid) AS viewdefinition FROM pg_class C LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace) WHERE C.relkind = 'v' AND C.relname = cagg.direct_view_name AND N.nspname = cagg.direct_view_schema) directview, LATERAL ( SELECT schema_name, table_name, compressed_hypertable_id FROM _timescaledb_catalog.hypertable WHERE cagg.mat_hypertable_id = id) mat_ht WHERE cagg.raw_hypertable_id = ht.id; -- chunks metadata view, shows information about the primary dimension column -- query plans with CTEs are not always optimized by PG. So use in-line -- tables. CREATE OR REPLACE VIEW timescaledb_information.chunks AS SELECT hypertable_schema, hypertable_name, schema_name AS chunk_schema, chunk_name, primary_dimension, primary_dimension_type, range_start, range_end, integer_range_start AS range_start_integer, integer_range_end AS range_end_integer, is_compressed, chunk_table_space AS chunk_tablespace, creation_time AS chunk_creation_time FROM ( SELECT ht.schema_name AS hypertable_schema, ht.table_name AS hypertable_name, srcch.schema_name AS schema_name, srcch.table_name AS chunk_name, dim.column_name AS primary_dimension, dim.column_type AS primary_dimension_type, row_number() OVER (PARTITION BY chcons.chunk_id ORDER BY dim.id) AS chunk_dimension_num, CASE WHEN dim.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN _timescaledb_functions.to_timestamp(dimsl.range_start) ELSE NULL END AS range_start, CASE WHEN dim.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN _timescaledb_functions.to_timestamp(dimsl.range_end) ELSE NULL END AS range_end, CASE WHEN dim.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN NULL ELSE dimsl.range_start END AS integer_range_start, CASE WHEN dim.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN NULL ELSE dimsl.range_end END AS integer_range_end, CASE WHEN (srcch.status & 1 = 1) THEN TRUE ELSE FALSE END AS is_compressed, pgtab.spcname AS chunk_table_space, srcch.creation_time AS creation_time FROM _timescaledb_catalog.chunk srcch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = srcch.hypertable_id INNER JOIN _timescaledb_catalog.chunk_constraint chcons ON srcch.id = chcons.chunk_id INNER JOIN _timescaledb_catalog.dimension dim ON srcch.hypertable_id = dim.hypertable_id INNER JOIN _timescaledb_catalog.dimension_slice dimsl ON dim.id = dimsl.dimension_id AND chcons.dimension_slice_id = dimsl.id INNER JOIN ( SELECT relname, reltablespace, nspname AS schema_name FROM pg_class, pg_namespace WHERE pg_class.relnamespace = pg_namespace.oid) cl ON srcch.table_name = cl.relname AND srcch.schema_name = cl.schema_name LEFT OUTER JOIN pg_tablespace pgtab ON pgtab.oid = reltablespace WHERE srcch.dropped IS FALSE AND srcch.osm_chunk IS FALSE AND ht.compression_state != 2 ) finalq WHERE chunk_dimension_num = 1; -- hypertable's dimension information -- CTEs aren't used in the query as PG does not always optimize them -- as expected. CREATE OR REPLACE VIEW timescaledb_information.dimensions AS SELECT ht.schema_name AS hypertable_schema, ht.table_name AS hypertable_name, rank() OVER (PARTITION BY hypertable_id ORDER BY dim.id) AS dimension_number, dim.column_name, dim.column_type, CASE WHEN dim.interval_length IS NULL THEN 'Space' ELSE 'Time' END AS dimension_type, CASE WHEN dim.interval_length IS NOT NULL THEN CASE WHEN dim.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN _timescaledb_functions.to_interval(dim.interval_length) ELSE NULL END END AS time_interval, CASE WHEN dim.interval_length IS NOT NULL THEN CASE WHEN dim.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN NULL ELSE dim.interval_length END END AS integer_interval, dim.integer_now_func, dim.num_slices AS num_partitions FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.dimension dim WHERE dim.hypertable_id = ht.id; ---compression parameters information --- CREATE OR REPLACE VIEW timescaledb_information.compression_settings AS SELECT schema_name AS hypertable_schema, table_name AS hypertable_name, (unnest(cs.segmentby))::name COLLATE "C" AS attname, generate_series(1,array_length(cs.segmentby,1))::smallint AS segmentby_column_index, NULL::smallint AS orderby_column_index, NULL::bool AS orderby_asc, NULL::bool AS orderby_nullsfirst FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.compression_settings cs ON cs.relid = format('%I.%I',ht.schema_name,ht.table_name)::regclass AND cs.segmentby IS NOT NULL WHERE compressed_hypertable_id IS NOT NULL UNION ALL SELECT schema_name AS hypertable_schema, table_name AS hypertable_name, (unnest(cs.orderby))::name COLLATE "C" AS attname, NULL::smallint AS segmentby_column_index, generate_series(1,array_length(cs.orderby,1))::smallint AS orderby_column_index, unnest(array_replace(array_replace(array_replace(cs.orderby_desc,false,NULL),true,false),NULL,true)) AS orderby_asc, unnest(cs.orderby_nullsfirst) AS orderby_nullsfirst FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.compression_settings cs ON cs.relid = format('%I.%I',ht.schema_name,ht.table_name)::regclass AND cs.orderby IS NOT NULL WHERE compressed_hypertable_id IS NOT NULL ORDER BY hypertable_name, segmentby_column_index, orderby_column_index; -- Job errors view that adds a security barrier on the bgw_job_stat_history -- table in _timescaledb_internal. The view only allows users to view -- log entries belonging to jobs that are owned by any of the users -- role. A special case is added so that the superuser or the database -- owner can see all job log entries, even those that do not have an -- associated job. -- -- Note that we have to use a sub-select here since pg_database_owner -- does not exist before PostgreSQL 14. CREATE OR REPLACE VIEW timescaledb_information.job_errors WITH (security_barrier = true) AS SELECT h.job_id, h.data->'job'->>'proc_schema' as proc_schema, h.data->'job'->>'proc_name' as proc_name, h.pid, h.execution_start AS start_time, h.execution_finish AS finish_time, h.data->'error_data'->>'sqlerrcode' AS sqlerrcode, CASE WHEN h.succeeded IS NULL AND h.execution_finish IS NULL AND h.pid IS NULL THEN 'job crash detected, see server logs' WHEN h.data->'error_data'->>'message' IS NOT NULL THEN CASE WHEN h.data->'error_data'->>'detail' IS NOT NULL THEN CASE WHEN h.data->'error_data'->>'hint' IS NOT NULL THEN concat(h.data->'error_data'->>'message', '. ', h.data->'error_data'->>'detail', '. ', h.data->'error_data'->>'hint') ELSE concat(h.data->'error_data'->>'message', ' ', h.data->'error_data'->>'detail') END ELSE CASE WHEN h.data->'error_data'->>'hint' IS NOT NULL THEN concat(h.data->'error_data'->>'message', '. ', h.data->'error_data'->>'hint') ELSE h.data->'error_data'->>'message' END END END AS err_message FROM _timescaledb_internal.bgw_job_stat_history h LEFT JOIN _timescaledb_config.bgw_job j ON (j.id = h.job_id) WHERE h.succeeded IS FALSE OR h.succeeded IS NULL AND (pg_catalog.pg_has_role(current_user, (SELECT pg_catalog.pg_get_userbyid(datdba) FROM pg_catalog.pg_database WHERE datname = current_database()), 'MEMBER') IS TRUE OR pg_catalog.pg_has_role(current_user, owner, 'MEMBER') IS TRUE); CREATE OR REPLACE VIEW timescaledb_information.job_history WITH (security_barrier = true) AS SELECT h.id, h.job_id, h.succeeded, coalesce(h.data->'job'->>'proc_schema', j.proc_schema) as proc_schema, coalesce(h.data->'job'->>'proc_name', j.proc_name) as proc_name, h.pid, h.execution_start AS start_time, h.execution_finish AS finish_time, h.data->'job'->'config' AS config, h.data->'error_data'->>'sqlerrcode' AS sqlerrcode, CASE WHEN h.succeeded IS NULL AND h.execution_finish IS NULL AND h.pid IS NULL THEN 'job crash detected, see server logs' WHEN h.succeeded IS FALSE AND h.data->'error_data'->>'message' IS NOT NULL THEN CASE WHEN h.data->'error_data'->>'detail' IS NOT NULL THEN CASE WHEN h.data->'error_data'->>'hint' IS NOT NULL THEN concat(h.data->'error_data'->>'message', '. ', h.data->'error_data'->>'detail', '. ', h.data->'error_data'->>'hint') ELSE concat(h.data->'error_data'->>'message', ' ', h.data->'error_data'->>'detail') END ELSE CASE WHEN h.data->'error_data'->>'hint' IS NOT NULL THEN concat(h.data->'error_data'->>'message', '. ', h.data->'error_data'->>'hint') ELSE h.data->'error_data'->>'message' END END END AS err_message FROM _timescaledb_internal.bgw_job_stat_history h LEFT JOIN _timescaledb_config.bgw_job j ON (j.id = h.job_id) WHERE (pg_catalog.pg_has_role(current_user, (SELECT pg_catalog.pg_get_userbyid(datdba) FROM pg_catalog.pg_database WHERE datname = current_database()), 'MEMBER') IS TRUE OR pg_catalog.pg_has_role(current_user, owner, 'MEMBER') IS TRUE); CREATE OR REPLACE VIEW timescaledb_information.hypertable_compression_settings AS SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass AS hypertable, array_to_string(segmentby,',') AS segmentby, un.orderby, d.compress_interval_length, s.index AS index FROM _timescaledb_catalog.hypertable ht JOIN LATERAL ( SELECT CASE WHEN d.column_type = ANY(ARRAY['timestamp','timestamptz','date']::regtype[]) THEN _timescaledb_functions.to_interval(d.compress_interval_length)::text ELSE d.compress_interval_length::text END AS compress_interval_length FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = ht.id ORDER BY id LIMIT 1 ) d ON true LEFT JOIN _timescaledb_catalog.compression_settings s ON format('%I.%I',ht.schema_name,ht.table_name)::regclass = s.relid LEFT JOIN LATERAL ( SELECT string_agg( format('%I%s%s',orderby, CASE WHEN "desc" THEN ' DESC' ELSE '' END, CASE WHEN nullsfirst AND NOT "desc" THEN ' NULLS FIRST' WHEN NOT nullsfirst AND "desc" THEN ' NULLS LAST' ELSE '' END ) ,',') AS orderby FROM unnest(s.orderby, s.orderby_desc, s.orderby_nullsfirst) un(orderby, "desc", nullsfirst) ) un ON true; CREATE OR REPLACE VIEW timescaledb_information.chunk_compression_settings AS SELECT format('%I.%I',ht.schema_name,ht.table_name)::regclass AS hypertable, format('%I.%I',ch.schema_name,ch.table_name)::regclass AS chunk, array_to_string(segmentby,',') AS segmentby, un.orderby, s.index AS index FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id INNER JOIN _timescaledb_catalog.compression_settings s ON (format('%I.%I',ch.schema_name,ch.table_name)::regclass = s.relid) LEFT JOIN LATERAL ( SELECT string_agg( format('%I%s%s',orderby, CASE WHEN "desc" THEN ' DESC' ELSE '' END, CASE WHEN nullsfirst AND NOT "desc" THEN ' NULLS FIRST' WHEN NOT nullsfirst AND "desc" THEN ' NULLS LAST' ELSE '' END ) ,',') AS orderby FROM unnest(s.orderby, s.orderby_desc, s.orderby_nullsfirst) un(orderby, "desc", nullsfirst) ) un ON true; CREATE OR REPLACE VIEW timescaledb_information.hypertable_columnstore_settings AS SELECT * FROM timescaledb_information.hypertable_compression_settings; CREATE OR REPLACE VIEW timescaledb_information.chunk_columnstore_settings AS SELECT * FROM timescaledb_information.chunk_compression_settings; GRANT SELECT ON ALL TABLES IN SCHEMA timescaledb_information TO PUBLIC; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/views_experimental.sql�������������������������������������������������������0000664�0000000�0000000�00000001345�15100345067�0021310�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE VIEW timescaledb_experimental.policies AS SELECT ca.user_view_name AS relation_name, ca.user_view_schema AS relation_schema, j.schedule_interval, j.proc_schema, j.proc_name, j.config, ht.schema_name AS hypertable_schema, ht.table_name AS hypertable_name FROM _timescaledb_config.bgw_job j JOIN _timescaledb_catalog.continuous_agg ca ON ca.mat_hypertable_id = j.hypertable_id JOIN _timescaledb_catalog.hypertable ht ON ht.id = ca.mat_hypertable_id; GRANT SELECT ON ALL TABLES IN SCHEMA timescaledb_experimental TO PUBLIC; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/with_telemetry.sql�����������������������������������������������������������0000664�0000000�0000000�00000001377�15100345067�0020450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION @extschema@.get_telemetry_report() RETURNS jsonb AS '@MODULE_PATHNAME@', 'ts_telemetry_get_report_jsonb' LANGUAGE C STABLE PARALLEL SAFE; INSERT INTO _timescaledb_config.bgw_job (id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, fixed_schedule) VALUES (1, 'Telemetry Reporter [1]', INTERVAL '24h', INTERVAL '100s', -1, INTERVAL '1h', '_timescaledb_functions', 'policy_telemetry', pg_catalog.quote_ident(current_role)::regrole, true, false) ON CONFLICT (id) DO NOTHING; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/sql/without_telemetry.sql��������������������������������������������������������0000664�0000000�0000000�00000000732�15100345067�0021172�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- We drop the telemetry function here since we have a non-telemetry -- build and the function might exist. DROP FUNCTION IF EXISTS @extschema@.get_telemetry_report; -- We delete the telemetry job since this is a non-telemetry build. DELETE FROM _timescaledb_config.bgw_job WHERE id = 1; ��������������������������������������timescaledb-2.23.0/src/�����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0014642�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/CMakeLists.txt���������������������������������������������������������������0000664�0000000�0000000�00000006755�15100345067�0017417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES uuid.c agg_bookend.c func_cache.c cache.c cache_invalidate.c chunk.c chunk_adaptive.c chunk_constraint.c chunk_index.c chunk_insert_state.c chunk_scan.c chunk_tuple_routing.c constraint.c cross_module_fn.c copy.c dimension.c dimension_slice.c dimension_vector.c estimate.c event_trigger.c extension.c extension_constants.c expression_utils.c foreign_key.c gapfill.c guc.c histogram.c hypercube.c hypertable.c hypertable_cache.c hypertable_restrict_info.c indexing.c init.c jsonb_utils.c license_guc.c osm_callbacks.c partitioning.c process_utility.c scanner.c scan_iterator.c sort_transform.c subspace_store.c timezones.c time_bucket.c time_utils.c custom_type_cache.c trigger.c utils.c version.c tss_callbacks.c) # Add test source code in Debug builds if(CMAKE_BUILD_TYPE MATCHES Debug) set(TS_DEBUG 1) set(DEBUG 1) list(APPEND SOURCES debug_point.c) endif(CMAKE_BUILD_TYPE MATCHES Debug) include(build-defs.cmake) set(GITREV_TMP ${CMAKE_CURRENT_BINARY_DIR}/tmp_gitcommit.h) set(GITREV_FILE ${CMAKE_CURRENT_BINARY_DIR}/gitcommit.h) # The commands for generating gitcommit.h need to be executed on every make run # and not on cmake run to detect branch switches, commit changes or local # modifications. That's why we add the commands in a custom target and run them # on every make run. We do the generation part in a temporary file and only # overwrite the actual file when the content is different to not trigger # unnecessary recompilations. add_custom_target( gitcheck COMMAND ${CMAKE_COMMAND} "-DGIT_FOUND=${GIT_FOUND}" "-DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}" "-DGIT_EXECUTABLE=${GIT_EXECUTABLE}" "-DINPUT_FILE=${CMAKE_CURRENT_SOURCE_DIR}/gitcommit.h.in" "-DOUTPUT_FILE=${GITREV_TMP}" -P ${CMAKE_CURRENT_SOURCE_DIR}/gitcommit.cmake COMMAND ${CMAKE_COMMAND} -E copy_if_different ${GITREV_TMP} ${GITREV_FILE}) if(CMAKE_BUILD_TYPE MATCHES Debug) add_library(${PROJECT_NAME} MODULE ${SOURCES} ${GITCOMMIT_H} $<TARGET_OBJECTS:${TESTS_LIB_NAME}>) else() add_library(${PROJECT_NAME} MODULE ${SOURCES} ${GITCOMMIT_H}) endif() if(USE_TELEMETRY) if(SEND_TELEMETRY_DEFAULT) set(TELEMETRY_DEFAULT TELEMETRY_BASIC) else() set(TELEMETRY_DEFAULT TELEMETRY_OFF) endif() endif() set_target_properties( ${PROJECT_NAME} PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-${PROJECT_VERSION_MOD} PREFIX "") install(TARGETS ${PROJECT_NAME} DESTINATION ${PG_PKGLIBDIR}) if(USE_OPENSSL) set(TS_USE_OPENSSL ${USE_OPENSSL}) target_include_directories(${PROJECT_NAME} SYSTEM PUBLIC ${OPENSSL_INCLUDE_DIR}) if(MSVC) target_link_libraries(${PROJECT_NAME} ${OPENSSL_LIBRARIES}) endif(MSVC) endif(USE_OPENSSL) set(TSL_CAGG_INVALIDATION_PLUGIN_NAME "${PROJECT_NAME}-invalidations-${PROJECT_VERSION_MOD}" CACHE STRING "Continuous aggregates invalidation plugin name") configure_file(config.h.in config.h) add_dependencies(${PROJECT_NAME} gitcheck) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) add_subdirectory(bgw) add_subdirectory(net) if(USE_TELEMETRY) add_subdirectory(telemetry) endif() add_subdirectory(loader) add_subdirectory(bgw_policy) add_subdirectory(compat) add_subdirectory(ts_catalog) add_subdirectory(import) add_subdirectory(nodes) add_subdirectory(planner) add_subdirectory(with_clause) �������������������timescaledb-2.23.0/src/README.md��������������������������������������������������������������������0000664�0000000�0000000�00000000264�15100345067�0016123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Basic TimescaleDB Features - [TimescaleDB Abstract Data Types](adts/README.md) - [TimescaleDB Scheduler](bgw/README.md) - [TimescaleDB Multi-version Loader](loader/README.md) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015575�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/README.md���������������������������������������������������������������0000664�0000000�0000000�00000001164�15100345067�0017056�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# A Collection of ADTs This directory contains a collection of Abstract Data Types. These ADTS are containers that can store data of any other type. These ADTs use macros as oppossed to void pointers for performance reasons, as well as for better type safety. This approach to ADTs follows Postgres convention. ## Vector A dynamic vector implementation that can store any type. It handles growing/shrinking the memory for you. ## Bit Array A dynamic vector to store bits. The API allows appending and iterating an arbitrary amount of bits. It stores the bits in a vector of uint64 and has methods to serialize/deserialize. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/bit_array.h�������������������������������������������������������������0000664�0000000�0000000�00000004215�15100345067�0017724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include "bit_array_impl.h" #include <adts/uint64_vec.h> /******************* *** Public API *** *******************/ /* Array to hold blobs of bits of arbitrary sizes. The interface * expects you to read the same amount of bits, in the same order, as what * was written. */ typedef struct BitArray BitArray; typedef struct BitArrayIterator BitArrayIterator; /* Main Interface */ static void bit_array_init(BitArray *array, int expected_bits); /* Append num_bits to the array */ static void bit_array_append(BitArray *array, uint8 num_bits, uint64 bits); static void bit_array_iterator_init(BitArrayIterator *iter, const BitArray *array); /* return next num_bits from the iterator; must have been written as num_bits */ pg_attribute_always_inline static uint64 bit_array_iter_next(BitArrayIterator *iter, uint8 num_bits); static void bit_array_iterator_init_rev(BitArrayIterator *iter, const BitArray *array); /* return last num_bits in forward-order (not reverse-order); must have been written as num_bits */ static uint64 bit_array_iter_next_rev(BitArrayIterator *iter, uint8 num_bits); /* I/O */ static inline void bit_array_send(StringInfo buffer, const BitArray *data); static inline BitArray bit_array_recv(const StringInfo buffer); static char *bytes_store_bit_array_and_advance(char *dest, size_t expected_size, const BitArray *array, uint32 *num_buckets, uint8 *bits_in_last_bucket); static size_t bit_array_output(const BitArray *array, uint64 *data, size_t max_n_bytes, uint64 *num_bits_out); static void bit_array_wrap(BitArray *dst, uint64 *data, uint64 num_bits); /* Accessors / Info */ static uint64 bit_array_num_bits(const BitArray *array); static uint32 bit_array_num_buckets(const BitArray *array); static uint64 *bit_array_buckets(const BitArray *array); static size_t bit_array_data_bytes_used(const BitArray *array); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/bit_array_impl.h��������������������������������������������������������0000664�0000000�0000000�00000024052�15100345067�0020746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include "compat/compat.h" #include "adts/uint64_vec.h" #define BITS_PER_BUCKET 64 typedef struct BitArray { uint64_vec buckets; uint8 bits_used_in_last_bucket; } BitArray; typedef struct BitArrayIterator { const BitArray *array; uint8 bits_used_in_current_bucket; /* note that current_bucket should be signed since it sometimes gets decremented and must be * able to hold UINT32_MAX */ int64 current_bucket; } BitArrayIterator; /************************ *** Private Helpers *** ************************/ static void bit_array_append_bucket(BitArray *array, uint8 bits_used, uint64 bucket); static uint64 bit_array_low_bits_mask(uint8 bits_used); static inline void bit_array_wrap_internal(BitArray *array, uint32 num_buckets, uint8 bits_used_in_last_bucket, uint64 *buckets); /************************ *** Implementation *** ************************/ static inline void bit_array_init(BitArray *array, int expected_bits) { *array = (BitArray){ .bits_used_in_last_bucket = 0, }; uint64_vec_init(&array->buckets, CurrentMemoryContext, expected_bits / 64); } /* This initializes the bit array by wrapping buckets. Note, that the bit array will * point to buckets instead of creating a new copy. */ static inline void bit_array_wrap_internal(BitArray *array, uint32 num_buckets, uint8 bits_used_in_last_bucket, uint64 *buckets) { *array = (BitArray){ .bits_used_in_last_bucket = bits_used_in_last_bucket, .buckets = (uint64_vec){ .data = buckets, .num_elements = num_buckets, .max_elements = num_buckets, }, }; } static inline size_t bit_array_data_bytes_used(const BitArray *array) { return array->buckets.num_elements * sizeof(*array->buckets.data); } static inline uint32 bit_array_num_buckets(const BitArray *array) { return array->buckets.num_elements; } static inline uint64 bit_array_num_bits(const BitArray *array) { return (BITS_PER_BUCKET * (array->buckets.num_elements - UINT64CONST(1))) + array->bits_used_in_last_bucket; } static inline uint64 * bit_array_buckets(const BitArray *array) { return array->buckets.data; } static inline BitArray bit_array_recv(const StringInfo buffer) { uint32 i; uint32 num_elements = pq_getmsgint32(buffer); uint8 bits_used_in_last_bucket = pq_getmsgbyte(buffer); BitArray array; CheckCompressedData(num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); CheckCompressedData(bits_used_in_last_bucket <= BITS_PER_BUCKET); array = (BitArray){ .bits_used_in_last_bucket = bits_used_in_last_bucket, .buckets = { .num_elements = num_elements, .max_elements = num_elements, .ctx = CurrentMemoryContext, .data = palloc(num_elements * sizeof(uint64)), }, }; for (i = 0; i < num_elements; i++) array.buckets.data[i] = pq_getmsgint64(buffer); return array; } static inline void bit_array_send(StringInfo buffer, const BitArray *data) { pq_sendint32(buffer, data->buckets.num_elements); pq_sendbyte(buffer, data->bits_used_in_last_bucket); for (uint32 i = 0; i < data->buckets.num_elements; i++) pq_sendint64(buffer, data->buckets.data[i]); } static inline size_t bit_array_output(const BitArray *array, uint64 *dst, size_t max_n_bytes, uint64 *num_bits_out) { size_t size = bit_array_data_bytes_used(array); if (max_n_bytes < size) elog(ERROR, "not enough memory to serialize bit array"); if (num_bits_out != NULL) *num_bits_out = bit_array_num_bits(array); memcpy(dst, array->buckets.data, size); return size; } static inline char * bytes_store_bit_array_and_advance(char *dest, size_t expected_size, const BitArray *array, uint32 *num_buckets_out, uint8 *bits_in_last_bucket_out) { size_t size = bit_array_data_bytes_used(array); if (expected_size != size) elog(ERROR, "the size to serialize does not match the bit array"); *num_buckets_out = bit_array_num_buckets(array); *bits_in_last_bucket_out = array->bits_used_in_last_bucket; if (size > 0) { Assert(array->buckets.data != NULL); memcpy(dest, array->buckets.data, size); } return dest + size; } static inline void bit_array_wrap(BitArray *dst, uint64 *data, uint64 num_bits) { uint32 num_buckets = num_bits / BITS_PER_BUCKET; uint8 bits_used_in_last_bucket = num_bits % BITS_PER_BUCKET; if (bits_used_in_last_bucket == 0) { /* last bucket uses all bits */ if (num_buckets > 0) bits_used_in_last_bucket = BITS_PER_BUCKET; } else num_buckets += 1; bit_array_wrap_internal(dst, num_buckets, bits_used_in_last_bucket, data); } static inline void bit_array_append(BitArray *array, uint8 num_bits, uint64 bits) { /* Fill bits from LSB to MSB */ uint8 bits_remaining_in_last_bucket; uint8 num_bits_for_new_bucket; uint64 bits_for_new_bucket; Assert(num_bits <= 64); if (num_bits == 0) return; if (array->buckets.num_elements == 0) bit_array_append_bucket(array, 0, 0); bits &= bit_array_low_bits_mask(num_bits); bits_remaining_in_last_bucket = 64 - array->bits_used_in_last_bucket; if (bits_remaining_in_last_bucket >= num_bits) { uint64 *bucket = uint64_vec_last(&array->buckets); /* mask out any unused high bits, probably unneeded */ *bucket |= bits << array->bits_used_in_last_bucket; array->bits_used_in_last_bucket += num_bits; return; } /* When splitting an integer across buckets, the low-order bits go into the first bucket and * the high-order bits go into the second bucket */ num_bits_for_new_bucket = num_bits - bits_remaining_in_last_bucket; if (bits_remaining_in_last_bucket > 0) { uint64 bits_for_current_bucket = bits & bit_array_low_bits_mask(bits_remaining_in_last_bucket); uint64 *current_bucket = uint64_vec_last(&array->buckets); *current_bucket |= bits_for_current_bucket << array->bits_used_in_last_bucket; bits >>= bits_remaining_in_last_bucket; } /* We zero out the high bits of the new bucket, to ensure that unused bits are always 0 */ bits_for_new_bucket = bits & bit_array_low_bits_mask(num_bits_for_new_bucket); bit_array_append_bucket(array, num_bits_for_new_bucket, bits_for_new_bucket); } static inline void bit_array_iterator_init(BitArrayIterator *iter, const BitArray *array) { *iter = (BitArrayIterator){ .array = array, }; } pg_attribute_always_inline static uint64 bit_array_iter_next(BitArrayIterator *iter, uint8 num_bits) { uint8 bits_remaining_in_current_bucket; uint8 num_bits_from_next_bucket; uint64 value = 0; uint64 value_from_next_bucket; CheckCompressedData(num_bits <= 64); if (num_bits == 0) return 0; CheckCompressedData(iter->current_bucket < iter->array->buckets.num_elements); bits_remaining_in_current_bucket = 64 - iter->bits_used_in_current_bucket; if (bits_remaining_in_current_bucket >= num_bits) { value = *uint64_vec_get(&iter->array->buckets, iter->current_bucket); value >>= iter->bits_used_in_current_bucket; value &= bit_array_low_bits_mask(num_bits); iter->bits_used_in_current_bucket += num_bits; return value; } num_bits_from_next_bucket = num_bits - bits_remaining_in_current_bucket; if (bits_remaining_in_current_bucket > 0) { /* The first bucket has the low-order bits */ value = *uint64_vec_get(&iter->array->buckets, iter->current_bucket); value >>= iter->bits_used_in_current_bucket; } /* The second bucket has the high-order bits */ CheckCompressedData(iter->current_bucket + 1 < iter->array->buckets.num_elements); value_from_next_bucket = *uint64_vec_get(&iter->array->buckets, iter->current_bucket + 1) & bit_array_low_bits_mask(num_bits_from_next_bucket); value_from_next_bucket <<= bits_remaining_in_current_bucket; value |= value_from_next_bucket; iter->current_bucket += 1; iter->bits_used_in_current_bucket = num_bits_from_next_bucket; return value; } static inline void bit_array_iterator_init_rev(BitArrayIterator *iter, const BitArray *array) { *iter = (BitArrayIterator){ .array = array, .current_bucket = array->buckets.num_elements - 1, .bits_used_in_current_bucket = array->bits_used_in_last_bucket, }; } static inline uint64 bit_array_iter_next_rev(BitArrayIterator *iter, uint8 num_bits) { uint8 bits_remaining_in_current_bucket; uint8 num_bits_from_previous_bucket; uint64 value = 0; uint64 bits_from_previous; Assert(num_bits <= BITS_PER_BUCKET); if (num_bits == 0) return 0; Assert(iter->current_bucket >= 0); bits_remaining_in_current_bucket = iter->bits_used_in_current_bucket; if (bits_remaining_in_current_bucket >= num_bits) { value = *uint64_vec_get(&iter->array->buckets, iter->current_bucket); value >>= (iter->bits_used_in_current_bucket - num_bits); value &= bit_array_low_bits_mask(num_bits); iter->bits_used_in_current_bucket -= num_bits; return value; } Assert(iter->current_bucket - 1 >= 0); num_bits_from_previous_bucket = num_bits - bits_remaining_in_current_bucket; Assert(num_bits <= BITS_PER_BUCKET); if (bits_remaining_in_current_bucket > 0) { /* The current bucket has the high-order bits (it's the second bucket) */ value |= *uint64_vec_get(&iter->array->buckets, iter->current_bucket) & bit_array_low_bits_mask(bits_remaining_in_current_bucket); value <<= num_bits_from_previous_bucket; } /* The previous bucket has the low-order bits (it's the first bucket) */ bits_from_previous = *uint64_vec_get(&iter->array->buckets, iter->current_bucket - 1); bits_from_previous >>= BITS_PER_BUCKET - num_bits_from_previous_bucket; bits_from_previous &= bit_array_low_bits_mask(num_bits_from_previous_bucket); value |= bits_from_previous; iter->current_bucket -= 1; iter->bits_used_in_current_bucket = BITS_PER_BUCKET - num_bits_from_previous_bucket; return value; } /************************ *** Private Helpers *** ************************/ static void bit_array_append_bucket(BitArray *array, uint8 bits_used, uint64 bucket) { uint64_vec_append(&array->buckets, bucket); array->bits_used_in_last_bucket = bits_used; } static uint64 bit_array_low_bits_mask(uint8 bits_used) { Assert(bits_used > 0); return ~0ULL >> (64 - bits_used); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/char_vec.h��������������������������������������������������������������0000664�0000000�0000000�00000000542�15100345067�0017521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define VEC_PREFIX char #define VEC_ELEMENT_TYPE char #define VEC_DECLARE 1 #define VEC_DEFINE 1 #define VEC_SCOPE static inline #include <adts/vec.h> ��������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/uint64_vec.h������������������������������������������������������������0000664�0000000�0000000�00000000546�15100345067�0017741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define VEC_PREFIX uint64 #define VEC_ELEMENT_TYPE uint64 #define VEC_DECLARE 1 #define VEC_DEFINE 1 #define VEC_SCOPE static inline #include <adts/vec.h> ����������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/adts/vec.h�������������������������������������������������������������������0000664�0000000�0000000�00000021532�15100345067�0016526�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* NOTE header guard deliberately omitted, as it is valid to include this header * multiple times in a single file */ /* * To generate a vector and associated functions for a use case several * macros have to be #define'ed before this file is included. Including * the file #undef's all those, so a new vectors can be generated afterwards. * The relevant parameters are: * - VEC_PREFIX - prefix for all symbol names generated. A prefix of 'foo' * will result in vector table type 'foo_vec' and functions like * 'foo_vec_append'/'foo_vec_at' and so forth. This is usually the * name of the stored element type * - VEC_ELEMENT_TYPE - type of the contained elements. * - VEC_DECLARE - if defined function prototypes and type declarations are * generated * - VEC_DEFINE - if defined function definitions are generated * - VEC_SCOPE - in which scope (e.g. extern, static inline) do function * declarations reside */ #define VEC_MAKE_PREFIX(a) CppConcat(a, _) #define VEC_MAKE_NAME(name) VEC_MAKE_NAME_(VEC_MAKE_PREFIX(VEC_PREFIX), name) #define VEC_MAKE_NAME_(a, b) CppConcat(a, b) /* name macros for: */ /* type declarations */ #define VEC_TYPE VEC_MAKE_NAME(vec) /* function declarations */ #define VEC_INIT VEC_MAKE_NAME(vec_init) #define VEC_CREATE VEC_MAKE_NAME(vec_create) #define VEC_FREE_DATA VEC_MAKE_NAME(vec_free_data) #define VEC_CLEAR VEC_MAKE_NAME(vec_clear) #define VEC_AT VEC_MAKE_NAME(vec_at) #define VEC_GET VEC_MAKE_NAME(vec_get) #define VEC_LAST VEC_MAKE_NAME(vec_last) #define VEC_APPEND VEC_MAKE_NAME(vec_append) #define VEC_APPEND_ARRAY VEC_MAKE_NAME(vec_append_array) #define VEC_APPEND_ZEROS VEC_MAKE_NAME(vec_append_zeros) #define VEC_DELETE VEC_MAKE_NAME(vec_delete) #define VEC_DELETE_RANGE VEC_MAKE_NAME(vec_delete_range) #define VEC_RESERVE VEC_MAKE_NAME(vec_reserve) #define VEC_FREE VEC_MAKE_NAME(vec_free) /* generate forward declarations necessary to use the vector */ #ifdef VEC_DECLARE /* type definitions */ typedef struct VEC_TYPE { /* size of the elements array */ uint32 max_elements; /* number of elements currently used */ uint32 num_elements; /* the actual data */ VEC_ELEMENT_TYPE *data; /* memory context to use for allocations */ MemoryContext ctx; } VEC_TYPE; /* externally visible function prototypes */ VEC_SCOPE void VEC_INIT(VEC_TYPE *vec, MemoryContext ctx, uint32 nelements); VEC_SCOPE VEC_TYPE *VEC_CREATE(MemoryContext ctx, uint32 nelements); VEC_SCOPE void VEC_FREE_DATA(VEC_TYPE *vec); VEC_SCOPE void VEC_CLEAR(VEC_TYPE *vec); VEC_SCOPE VEC_ELEMENT_TYPE *VEC_AT(VEC_TYPE *vec, uint32 index); VEC_SCOPE const VEC_ELEMENT_TYPE *VEC_GET(const VEC_TYPE *vec, uint32 index); VEC_SCOPE VEC_ELEMENT_TYPE *VEC_LAST(VEC_TYPE *vec); VEC_SCOPE void VEC_APPEND(VEC_TYPE *vec, VEC_ELEMENT_TYPE element); VEC_SCOPE VEC_ELEMENT_TYPE *VEC_APPEND_ARRAY(VEC_TYPE *vec, VEC_ELEMENT_TYPE *elements, uint32 num_elements); VEC_SCOPE VEC_ELEMENT_TYPE *VEC_APPEND_ZEROS(VEC_TYPE *vec, uint32 num_elements); VEC_SCOPE void VEC_DELETE(VEC_TYPE *vec, uint32 index); VEC_SCOPE void VEC_DELETE_RANGE(VEC_TYPE *vec, uint32 start, uint32 len); VEC_SCOPE void VEC_RESERVE(VEC_TYPE *vec, uint32 additional); VEC_SCOPE void VEC_FREE(VEC_TYPE *vec); #endif /* VEC_DECLARE */ /* generate implementation of the vector */ #ifdef VEC_DEFINE #include <utils/memutils.h> /* * Allocate space so the vector can store least `additional` new elements. * * Usually this will automatically be called by appends/inserts, when * necessary. But resizing to the exact input size can be advantageous * performance-wise, when known at some point. */ VEC_SCOPE void VEC_RESERVE(VEC_TYPE *vec, uint32 additional) { uint64 num_new_elements = additional; uint64 max_element_limit = MaxAllocSize / sizeof(VEC_ELEMENT_TYPE); uint64 num_elements; uint64 num_bytes; /* this doesn't handle integer overflow or >MaxAllocSize allocations */ if (num_new_elements == 0 || vec->num_elements + num_new_elements <= vec->max_elements) return; num_elements = vec->num_elements + num_new_elements; if (num_new_elements < vec->num_elements) { /* Follow the usual doubling progression of allocation sizes. */ num_elements = vec->num_elements * 2; } if (num_elements >= max_element_limit) { if (vec->num_elements + num_new_elements >= max_element_limit) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("vector allocation overflow when trying to allocate %ld bytes", (long) ((vec->num_elements + num_new_elements) * sizeof(VEC_ELEMENT_TYPE))))); /* Clamp num_elements to max allocation size if they can fit*/ num_elements = max_element_limit; } Assert(num_elements > vec->num_elements); vec->max_elements = num_elements; num_bytes = vec->max_elements * sizeof(VEC_ELEMENT_TYPE); if (vec->data == NULL) vec->data = MemoryContextAlloc(vec->ctx, num_bytes); else vec->data = repalloc(vec->data, num_bytes); } /* * Initialize a vector with enough space for `nelements`. Memory is allocated * from the passed-in context. */ VEC_SCOPE void VEC_INIT(VEC_TYPE *vec, MemoryContext ctx, uint32 nelements) { *vec = (VEC_TYPE){ .ctx = ctx, }; if (nelements > 0) VEC_RESERVE(vec, nelements); } /* * Create a vector with enough space for `nelements`. Memory for the vector, and * its elements, is allocated from the passed-in context. */ VEC_SCOPE VEC_TYPE * VEC_CREATE(MemoryContext ctx, uint32 nelements) { VEC_TYPE *vec = MemoryContextAlloc(ctx, sizeof(*vec)); VEC_INIT(vec, ctx, nelements); return vec; } /* free the underlying array */ VEC_SCOPE void VEC_FREE_DATA(VEC_TYPE *vec) { if (vec->data != NULL) pfree(vec->data); /* zero out all the vec data except the memory context so it can be reused */ *vec = (VEC_TYPE){ .ctx = vec->ctx, }; } /* free an allocated vector, and its data */ VEC_SCOPE void VEC_FREE(VEC_TYPE *vec) { if (vec == NULL) return; VEC_FREE_DATA(vec); pfree(vec); } /* clear a vector, but don't free the underlying array */ VEC_SCOPE void VEC_CLEAR(VEC_TYPE *vec) { vec->num_elements = 0; } VEC_SCOPE VEC_ELEMENT_TYPE * VEC_AT(VEC_TYPE *vec, uint32 index) { Assert(index < vec->num_elements); return &vec->data[index]; } VEC_SCOPE const VEC_ELEMENT_TYPE * VEC_GET(const VEC_TYPE *vec, uint32 index) { Assert(index < vec->num_elements); return &vec->data[index]; } /* return a pointer to the last element in the vector */ VEC_SCOPE VEC_ELEMENT_TYPE * VEC_LAST(VEC_TYPE *vec) { Assert(vec->num_elements > 0); return VEC_AT(vec, vec->num_elements - 1); } VEC_SCOPE VEC_ELEMENT_TYPE * VEC_APPEND_ARRAY(VEC_TYPE *vec, VEC_ELEMENT_TYPE *elements, uint32 num_elements) { VEC_ELEMENT_TYPE *first_new_element; VEC_RESERVE(vec, num_elements); Assert(vec->num_elements < vec->max_elements); first_new_element = vec->data + vec->num_elements; memcpy(first_new_element, elements, sizeof(*elements) * num_elements); vec->num_elements += num_elements; return first_new_element; } VEC_SCOPE void VEC_APPEND(VEC_TYPE *vec, VEC_ELEMENT_TYPE element) { VEC_APPEND_ARRAY(vec, &element, 1); } VEC_SCOPE VEC_ELEMENT_TYPE * VEC_APPEND_ZEROS(VEC_TYPE *vec, uint32 num_elements) { VEC_ELEMENT_TYPE *first_new_element; VEC_RESERVE(vec, num_elements); Assert(vec->num_elements + num_elements <= vec->max_elements); first_new_element = vec->data + vec->num_elements; memset(first_new_element, 0, sizeof(*first_new_element) * num_elements); vec->num_elements += num_elements; return first_new_element; } VEC_SCOPE void VEC_DELETE_RANGE(VEC_TYPE *vec, uint32 start, uint32 len) { if (start > vec->num_elements) elog(ERROR, "trying to delete starting past the end of a vector"); if (start + (uint64) len > (uint64) vec->num_elements) elog(ERROR, "trying to delete past the end of a vector"); if (start + (uint64) len < (uint64) vec->num_elements) { /* backshift the elements after the deletion that still remain */ uint64 backshit_elements = vec->num_elements - (start + len); uint64 backshit_bytes = backshit_elements * sizeof(*vec->data); memmove(&vec->data[start], &vec->data[start + len], backshit_bytes); } vec->num_elements -= len; } VEC_SCOPE void VEC_DELETE(VEC_TYPE *vec, uint32 index) { VEC_DELETE_RANGE(vec, index, 1); } #endif /* undefine external parameters, so next vector can be defined */ #undef VEC_PREFIX #undef VEC_ELEMENT_TYPE #undef VEC_SCOPE #undef VEC_DECLARE #undef VEC_DEFINE /* undefine locally declared macros */ #undef VEC_MAKE_PREFIX #undef VEC_MAKE_NAME #undef VEC_MAKE_NAME /* types */ #undef VEC_TYPE /* external function names */ #undef VEC_INIT #undef VEC_CREATE #undef VEC_FREE_DATA #undef VEC_CLEAR #undef VEC_AT #undef VEC_GET #undef VEC_LAST #undef VEC_APPEND #undef VEC_APPEND_ARRAY #undef VEC_APPEND_ZEROS #undef VEC_DELETE #undef VEC_DELETE_RANGE #undef VEC_RESERVE #undef VEC_FREE ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/agg_bookend.c����������������������������������������������������������������0000664�0000000�0000000�00000041645�15100345067�0017257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include <nodes/value.h> #include <utils/datum.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include "export.h" /* bookend aggregates first and last: * first(value, cmp) returns the value for the row with the smallest cmp element. * last(value, cmp) returns the value for the row with the biggest cmp element. * * Usage: * SELECT first(metric, time), last(metric, time) FROM metric GROUP BY hostname. */ TS_FUNCTION_INFO_V1(ts_first_sfunc); TS_FUNCTION_INFO_V1(ts_first_combinefunc); TS_FUNCTION_INFO_V1(ts_last_sfunc); TS_FUNCTION_INFO_V1(ts_last_combinefunc); TS_FUNCTION_INFO_V1(ts_bookend_finalfunc); TS_FUNCTION_INFO_V1(ts_bookend_serializefunc); TS_FUNCTION_INFO_V1(ts_bookend_deserializefunc); /* A PolyDatum represents a polymorphic datum */ typedef struct PolyDatum { bool is_null; Datum datum; } PolyDatum; typedef struct TypeInfoCache { Oid typoid; int16 typlen; bool typbyval; } TypeInfoCache; /* PolyDatumIOState is internal state used by polydatum_serialize and polydatum_deserialize */ typedef struct PolyDatumIOState { TypeInfoCache type; FmgrInfo proc; Oid typeioparam; } PolyDatumIOState; static PolyDatum polydatum_from_arg(int argno, FunctionCallInfo fcinfo) { PolyDatum value; value.is_null = PG_ARGISNULL(argno); if (!value.is_null) value.datum = PG_GETARG_DATUM(argno); else value.datum = PointerGetDatum(NULL); return value; } /* Serialize type as namespace name string + type name string. * Don't simple send Oid since this state may be needed across pg_dumps. */ static void polydatum_serialize_type(StringInfo buf, Oid type_oid) { HeapTuple tup; Form_pg_type type_tuple; char *namespace_name; tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid)); if (!HeapTupleIsValid(tup)) elog(ERROR, "cache lookup failed for type %u", type_oid); type_tuple = (Form_pg_type) GETSTRUCT(tup); namespace_name = get_namespace_name(type_tuple->typnamespace); /* send qualified type name */ pq_sendstring(buf, namespace_name); pq_sendstring(buf, NameStr(type_tuple->typname)); ReleaseSysCache(tup); } /* serializes the polydatum pd unto buf */ static void polydatum_serialize(PolyDatum *pd, StringInfo buf, PolyDatumIOState *state, FunctionCallInfo fcinfo) { bytea *outputbytes; Assert(OidIsValid(state->type.typoid)); polydatum_serialize_type(buf, state->type.typoid); if (pd->is_null) { /* emit -1 data length to signify a NULL */ pq_sendint32(buf, -1); return; } outputbytes = SendFunctionCall(&state->proc, pd->datum); pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ); pq_sendbytes(buf, VARDATA(outputbytes), VARSIZE(outputbytes) - VARHDRSZ); } static Oid polydatum_deserialize_type(StringInfo buf) { const char *schema_name = pq_getmsgstring(buf); const char *type_name = pq_getmsgstring(buf); Oid schema_oid = LookupExplicitNamespace(schema_name, false); Oid type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid, PointerGetDatum(type_name), ObjectIdGetDatum(schema_oid)); if (!OidIsValid(type_oid)) elog(ERROR, "cache lookup failed for type %s.%s", schema_name, type_name); return type_oid; } /* * Deserialize the PolyDatum where the binary representation is in buf. * If a not-null PolyDatum is passed in, fill in it's fields, otherwise palloc. * */ static PolyDatum * polydatum_deserialize(MemoryContext mem_ctx, PolyDatum *result, StringInfo buf, PolyDatumIOState *state, FunctionCallInfo fcinfo) { int itemlen; StringInfoData item_buf; StringInfo bufptr; char csave; Assert(result != NULL); MemoryContext old_context = MemoryContextSwitchTo(mem_ctx); Oid deserialized_type = polydatum_deserialize_type(buf); /* Following is copied/adapted from record_recv in core postgres */ /* Get and check the item length */ itemlen = pq_getmsgint(buf, 4); if (itemlen < -1 || itemlen > (buf->len - buf->cursor)) ereport(ERROR, (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION), errmsg("insufficient data left in message %d %d", itemlen, buf->len))); if (itemlen == -1) { /* -1 length means NULL */ result->is_null = true; bufptr = NULL; csave = 0; } else { /* * Rather than copying data around, we just set up a phony StringInfo * pointing to the correct portion of the input buffer. We assume we * can scribble on the input buffer so as to maintain the convention * that StringInfos have a trailing null. */ item_buf.data = &buf->data[buf->cursor]; item_buf.maxlen = itemlen + 1; item_buf.len = itemlen; item_buf.cursor = 0; buf->cursor += itemlen; csave = buf->data[buf->cursor]; buf->data[buf->cursor] = '\0'; bufptr = &item_buf; result->is_null = false; } /* Now call the column's receiveproc */ if (state->type.typoid != deserialized_type) { Assert(!OidIsValid(state->type.typoid)); Oid func; getTypeBinaryInputInfo(deserialized_type, &func, &state->typeioparam); fmgr_info_cxt(func, &state->proc, fcinfo->flinfo->fn_mcxt); state->type.typoid = deserialized_type; get_typlenbyval(state->type.typoid, &state->type.typlen, &state->type.typbyval); } result->datum = ReceiveFunctionCall(&state->proc, bufptr, state->typeioparam, -1); if (bufptr) { /* Trouble if it didn't eat the whole buffer */ if (item_buf.cursor != itemlen) ereport(ERROR, (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION), errmsg("improper binary format in polydata"))); buf->data[buf->cursor] = csave; } MemoryContextSwitchTo(old_context); return result; } typedef struct TransCache { TypeInfoCache value_type_cache; TypeInfoCache cmp_type_cache; FmgrInfo cmp_proc; } TransCache; /* Internal state for bookend aggregates */ typedef struct InternalCmpAggStore { TransCache aggstate_type_cache; PolyDatum value; PolyDatum cmp; /* the comparison element. e.g. time */ } InternalCmpAggStore; inline static InternalCmpAggStore * init_store(MemoryContext aggcontext) { InternalCmpAggStore *state = (InternalCmpAggStore *) MemoryContextAllocZero(aggcontext, sizeof(InternalCmpAggStore)); state->value.is_null = true; state->cmp.is_null = true; return state; } /* State used to cache data for serialize/deserialize operations */ typedef struct InternalCmpAggStoreIOState { PolyDatumIOState value; PolyDatumIOState cmp; /* the comparison element. e.g. time */ } InternalCmpAggStoreIOState; inline static void typeinfocache_polydatumcopy(TypeInfoCache *tic, PolyDatum input, PolyDatum *output) { Assert(OidIsValid(tic->typoid)); if (!tic->typbyval && !output->is_null) { pfree(DatumGetPointer(output->datum)); } *output = input; if (!input.is_null) { output->datum = datumCopy(input.datum, tic->typbyval, tic->typlen); output->is_null = false; } else { output->datum = PointerGetDatum(NULL); output->is_null = true; } } inline static void cmpproc_init(FunctionCallInfo fcinfo, FmgrInfo *cmp_proc, Oid type_oid, char *opname) { Oid cmp_op, cmp_regproc; if (!OidIsValid(type_oid)) elog(ERROR, "could not determine the type of the comparison_element"); cmp_op = OpernameGetOprid(list_make1(makeString(opname)), type_oid, type_oid); if (!OidIsValid(cmp_op)) elog(ERROR, "could not find a %s operator for type %d", opname, type_oid); cmp_regproc = get_opcode(cmp_op); if (!OidIsValid(cmp_regproc)) elog(ERROR, "could not find the procedure for the %s operator for type %d", opname, type_oid); fmgr_info_cxt(cmp_regproc, cmp_proc, fcinfo->flinfo->fn_mcxt); } inline static bool cmpproc_cmp(FmgrInfo *cmp_proc, FunctionCallInfo fcinfo, PolyDatum left, PolyDatum right) { return DatumGetBool(FunctionCall2Coll(cmp_proc, fcinfo->fncollation, left.datum, right.datum)); } /* * bookend_sfunc - internal function called by ts_last_sfunc and ts_first_sfunc; */ static inline Datum bookend_sfunc(MemoryContext aggcontext, InternalCmpAggStore *state, char *opname, FunctionCallInfo fcinfo) { PolyDatum value = polydatum_from_arg(1, fcinfo); PolyDatum cmp = polydatum_from_arg(2, fcinfo); MemoryContext old_context; old_context = MemoryContextSwitchTo(aggcontext); if (state == NULL) { state = init_store(aggcontext); TransCache *cache = &state->aggstate_type_cache; TypeInfoCache *v = &cache->value_type_cache; v->typoid = get_fn_expr_argtype(fcinfo->flinfo, 1); get_typlenbyval(v->typoid, &v->typlen, &v->typbyval); TypeInfoCache *c = &cache->cmp_type_cache; c->typoid = get_fn_expr_argtype(fcinfo->flinfo, 2); get_typlenbyval(c->typoid, &c->typlen, &c->typbyval); typeinfocache_polydatumcopy(&cache->value_type_cache, value, &state->value); typeinfocache_polydatumcopy(&cache->cmp_type_cache, cmp, &state->cmp); } else if (!cmp.is_null) { TransCache *cache = &state->aggstate_type_cache; if (cache->cmp_proc.fn_addr == NULL) { cmpproc_init(fcinfo, &cache->cmp_proc, cache->cmp_type_cache.typoid, opname); } /* only do comparison if cmp is not NULL */ if (state->cmp.is_null || cmpproc_cmp(&cache->cmp_proc, fcinfo, cmp, state->cmp)) { typeinfocache_polydatumcopy(&cache->value_type_cache, value, &state->value); typeinfocache_polydatumcopy(&cache->cmp_type_cache, cmp, &state->cmp); } } MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(state); } /* bookend_combinefunc - internal function called by ts_last_combinefunc and ts_first_combinefunc; * fmgr args are: (internal internal_state, internal2 internal_state) */ static inline Datum bookend_combinefunc(MemoryContext aggcontext, InternalCmpAggStore *state1, InternalCmpAggStore *state2, char *opname, FunctionCallInfo fcinfo) { MemoryContext old_context; if (state2 == NULL) PG_RETURN_POINTER(state1); /* * manually copy all fields from state2 to state1, as per other combine * func like int8_avg_combine */ if (state1 == NULL) { old_context = MemoryContextSwitchTo(aggcontext); state1 = init_store(aggcontext); Assert(OidIsValid(state2->aggstate_type_cache.value_type_cache.typoid)); Assert(OidIsValid(state2->aggstate_type_cache.cmp_type_cache.typoid)); TransCache *cache1 = &state1->aggstate_type_cache; TransCache *cache2 = &state2->aggstate_type_cache; /* * Initialize the type information from the right-hand state. Note that * we will have to re-lookup the comparison procedure on demand, because * the comparison procedure from the right-hand state might have been * allocated in a different memory context. */ cache1->value_type_cache = cache2->value_type_cache; cache1->cmp_type_cache = cache2->cmp_type_cache; typeinfocache_polydatumcopy(&cache1->value_type_cache, state2->value, &state1->value); typeinfocache_polydatumcopy(&cache1->cmp_type_cache, state2->cmp, &state1->cmp); MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(state1); } if (state1->cmp.is_null && state2->cmp.is_null) { PG_RETURN_POINTER(state1); } else if (state1->cmp.is_null != state2->cmp.is_null) { if (state1->cmp.is_null) PG_RETURN_POINTER(state2); else PG_RETURN_POINTER(state1); } TransCache *cache1 = &state1->aggstate_type_cache; if (cache1->cmp_proc.fn_addr == NULL) { cmpproc_init(fcinfo, &cache1->cmp_proc, cache1->cmp_type_cache.typoid, opname); } if (cmpproc_cmp(&cache1->cmp_proc, fcinfo, state2->cmp, state1->cmp)) { old_context = MemoryContextSwitchTo(aggcontext); typeinfocache_polydatumcopy(&cache1->value_type_cache, state2->value, &state1->value); typeinfocache_polydatumcopy(&cache1->cmp_type_cache, state2->cmp, &state1->cmp); MemoryContextSwitchTo(old_context); } PG_RETURN_POINTER(state1); } /* first(internal internal_state, anyelement value, "any" comparison_element) */ Datum ts_first_sfunc(PG_FUNCTION_ARGS) { InternalCmpAggStore *store = PG_ARGISNULL(0) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(0); MemoryContext aggcontext; if (!AggCheckCallContext(fcinfo, &aggcontext)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "first_sfun called in non-aggregate context"); } return bookend_sfunc(aggcontext, store, "<", fcinfo); } /* last(internal internal_state, anyelement value, "any" comparison_element) */ Datum ts_last_sfunc(PG_FUNCTION_ARGS) { InternalCmpAggStore *store = PG_ARGISNULL(0) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(0); MemoryContext aggcontext; if (!AggCheckCallContext(fcinfo, &aggcontext)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "last_sfun called in non-aggregate context"); } return bookend_sfunc(aggcontext, store, ">", fcinfo); } /* first_combinerfunc(internal, internal) => internal */ Datum ts_first_combinefunc(PG_FUNCTION_ARGS) { MemoryContext aggcontext; InternalCmpAggStore *state1 = PG_ARGISNULL(0) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(0); InternalCmpAggStore *state2 = PG_ARGISNULL(1) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(1); if (!AggCheckCallContext(fcinfo, &aggcontext)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_first_combinefunc called in non-aggregate context"); } return bookend_combinefunc(aggcontext, state1, state2, "<", fcinfo); } /* last_combinerfunc(internal, internal) => internal */ Datum ts_last_combinefunc(PG_FUNCTION_ARGS) { MemoryContext aggcontext; InternalCmpAggStore *state1 = PG_ARGISNULL(0) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(0); InternalCmpAggStore *state2 = PG_ARGISNULL(1) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(1); if (!AggCheckCallContext(fcinfo, &aggcontext)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_last_combinefunc called in non-aggregate context"); } return bookend_combinefunc(aggcontext, state1, state2, ">", fcinfo); } /* ts_bookend_serializefunc(internal) => bytea */ Datum ts_bookend_serializefunc(PG_FUNCTION_ARGS) { StringInfoData buf; InternalCmpAggStoreIOState *my_extra; InternalCmpAggStore *state; Assert(!PG_ARGISNULL(0)); state = (InternalCmpAggStore *) PG_GETARG_POINTER(0); my_extra = (InternalCmpAggStoreIOState *) fcinfo->flinfo->fn_extra; if (my_extra == NULL) { fcinfo->flinfo->fn_extra = MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt, sizeof(InternalCmpAggStoreIOState)); my_extra = (InternalCmpAggStoreIOState *) fcinfo->flinfo->fn_extra; Oid func; bool is_varlena; my_extra->value.type = state->aggstate_type_cache.value_type_cache; Assert(OidIsValid(my_extra->value.type.typoid)); getTypeBinaryOutputInfo(my_extra->value.type.typoid, &func, &is_varlena); fmgr_info_cxt(func, &my_extra->value.proc, fcinfo->flinfo->fn_mcxt); my_extra->cmp.type = state->aggstate_type_cache.cmp_type_cache; Assert(OidIsValid(my_extra->cmp.type.typoid)); getTypeBinaryOutputInfo(my_extra->cmp.type.typoid, &func, &is_varlena); fmgr_info_cxt(func, &my_extra->cmp.proc, fcinfo->flinfo->fn_mcxt); } pq_begintypsend(&buf); polydatum_serialize(&state->value, &buf, &my_extra->value, fcinfo); polydatum_serialize(&state->cmp, &buf, &my_extra->cmp, fcinfo); PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); } /* ts_bookend_deserializefunc(bytea, internal) => internal */ Datum ts_bookend_deserializefunc(PG_FUNCTION_ARGS) { MemoryContext aggcontext; bytea *sstate; StringInfoData buf; InternalCmpAggStore *result; InternalCmpAggStoreIOState *my_extra; if (!AggCheckCallContext(fcinfo, &aggcontext)) elog(ERROR, "aggregate function called in non-aggregate context"); sstate = PG_GETARG_BYTEA_P(0); /* * Copy the bytea into a StringInfo so that we can "receive" it using the * standard recv-function infrastructure. */ initStringInfo(&buf); appendBinaryStringInfo(&buf, VARDATA(sstate), VARSIZE(sstate) - VARHDRSZ); my_extra = (InternalCmpAggStoreIOState *) fcinfo->flinfo->fn_extra; if (my_extra == NULL) { fcinfo->flinfo->fn_extra = MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt, sizeof(InternalCmpAggStoreIOState)); my_extra = (InternalCmpAggStoreIOState *) fcinfo->flinfo->fn_extra; } result = MemoryContextAllocZero(aggcontext, sizeof(InternalCmpAggStore)); polydatum_deserialize(aggcontext, &result->value, &buf, &my_extra->value, fcinfo); polydatum_deserialize(aggcontext, &result->cmp, &buf, &my_extra->cmp, fcinfo); result->aggstate_type_cache.value_type_cache = my_extra->value.type; result->aggstate_type_cache.cmp_type_cache = my_extra->cmp.type; PG_RETURN_POINTER(result); } /* ts_bookend_finalfunc(internal, anyelement, "any") => anyelement */ Datum ts_bookend_finalfunc(PG_FUNCTION_ARGS) { InternalCmpAggStore *state; if (!AggCheckCallContext(fcinfo, NULL)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_bookend_finalfunc called in non-aggregate context"); } state = PG_ARGISNULL(0) ? NULL : (InternalCmpAggStore *) PG_GETARG_POINTER(0); if (state == NULL || state->value.is_null || state->cmp.is_null) PG_RETURN_NULL(); PG_RETURN_DATUM(state->value.datum); } �������������������������������������������������������������������������������������������timescaledb-2.23.0/src/annotations.h����������������������������������������������������������������0000664�0000000�0000000�00000001143�15100345067�0017347�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* Supported since clang 12 and GCC 7 */ #if defined __has_attribute #if __has_attribute(fallthrough) #define TS_FALLTHROUGH __attribute__((fallthrough)) #else #define TS_FALLTHROUGH /* FALLTHROUGH */ #endif #else #define TS_FALLTHROUGH /* FALLTHROUGH */ #endif #ifdef __has_attribute #if __has_attribute(used) #define TS_USED __attribute__((used)) #else #define TS_USED #endif #else #define TS_USED #endif �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015421�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/CMakeLists.txt�����������������������������������������������������������0000664�0000000�0000000�00000000515�15100345067�0020162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/job.c ${CMAKE_CURRENT_SOURCE_DIR}/job_stat.c ${CMAKE_CURRENT_SOURCE_DIR}/job_stat_history.c ${CMAKE_CURRENT_SOURCE_DIR}/launcher_interface.c ${CMAKE_CURRENT_SOURCE_DIR}/scheduler.c ${CMAKE_CURRENT_SOURCE_DIR}/timer.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/README.md����������������������������������������������������������������0000664�0000000�0000000�00000006532�15100345067�0016706�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Background worker jobs TimescaleDB needs to run multiple background jobs. This module implements a simple scheduler so that jobs inserted into a jobs table can be run on a schedule. Each database in an instance runs it's own scheduler because different databases may run different TimescaleDB extension versions which may require different scheduler logic. ## Schedules The scheduler allows you to set a `schedule_interval` for every job. That defines the interval the scheduler will wait after a job finishes to start it again, if the job is successful. If the job fails, the scheduler uses `retry_period` in an exponential backoff to decide when to run the job again. ## Design The scheduler itself is a background job that continuously runs and waits for a time when jobs need to be scheduled. It then launches jobs as new background workers that it controls through the background worker handle. Aggregate statistics about a job are kept in the job stat catalog table. These statistics include the start and finish times of the last run of the job as well as whether or not the job succeeded. The `next_start` is used to figure out when next to run a job after a scheduler is restarted. The statistics table also tracks consecutive failures and crashes for the job which are used for calculating the exponential backoff after a crash or failure (which is used to set the `next_start` after the crash/failure). Note also that there is a minimum time after the database scheduler starts up and a crashed job is restarted. This is to allow the operator enough time to disable the job if needed. Note that the number of crashes is an overestimate of the actual number of crashes for a job. This is so that we are conservative and never miss a crash and fail to use the appropriate backoff logic. There is some complexity in ensuring that all crashes are counted. A crash in Postgres causes *all* processes to quit immediately therefore we cannot write anything to the database once any process has crashed. Thus, we must be able to deduce that a crash occurred from a commit that happened before any crash. We accomplish this by committing a changes to the stats table before a job starts and undoing the change after it finishes. If a job crashed, it will be left in an intermediate state from which we deduce that it could have been the crashing process. ## Scheduler State Machine The scheduler implements a state machine for each job. Each job starts in the `SCHEDULED` state. As soon as a job starts it enters the `STARTING` state. If the scheduler determines the job should be terminated (e.g. it has reached a timeout), it moves the job to a TERMINATING state. Once a background worker has for a job has stopped, the job returns to the `SCHEDULED` state. The states and associated transitions are as follows. ```ditaa +---------+ +--------+ +---> |SCHEDULED+-------> |DISABLED| | +----+----+ +--------+ | | | | | v | +---+----+ +<-----+STARTING| | +---+----+ | | | | | v | +---+-------+ +<-----+TERMINATING| +-----------+ ``` ## Limitations This first implementation has two limitations: - The list of jobs to be run is read from the database when the scheduler is first started. We do not update this list if the jobs table changes. - There is no prioritization for when to run jobs. ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/job.c��������������������������������������������������������������������0000664�0000000�0000000�00000136030�15100345067�0016342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <unistd.h> #include <access/xact.h> #include <catalog/pg_authid.h> #include <executor/execdebug.h> #include <executor/instrument.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <parser/parse_func.h> #include <parser/parser.h> #include <pgstat.h> #include <postmaster/bgworker.h> #include <storage/ipc.h> #include <storage/lock.h> #include <storage/proc.h> #include <storage/procarray.h> #include <storage/sinvaladt.h> #include <tcop/tcopprot.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/jsonb.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "bgw/job_stat_history.h" #include "bgw/scheduler.h" #include "bgw_policy/chunk_stats.h" #include "bgw_policy/policy.h" #include "config.h" #include "cross_module_fn.h" #include "debug_assert.h" #include "extension.h" #include "job.h" #include "job_stat.h" #include "license_guc.h" #include "scan_iterator.h" #include "scanner.h" #include "tss_callbacks.h" #include "utils.h" #ifdef USE_TELEMETRY #include "telemetry/telemetry.h" #endif static scheduler_test_hook_type scheduler_test_hook = NULL; static char *job_entrypoint_function_name = "ts_bgw_job_entrypoint"; /* * Get the mem_guard callbacks. * * You might get a NULL pointer back if there are no mem_guard installed, so * check before using. */ MGCallbacks * ts_get_mem_guard_callbacks(void) { static MGCallbacks **mem_guard_callback_ptr = NULL; if (mem_guard_callback_ptr) return *mem_guard_callback_ptr; mem_guard_callback_ptr = (MGCallbacks **) find_rendezvous_variable(MG_CALLBACKS_VAR_NAME); return *mem_guard_callback_ptr; } typedef enum JobLockLifetime { SESSION_LOCK = 0, TXN_LOCK, } JobLockLifetime; BackgroundWorkerHandle * ts_bgw_job_start(BgwJob *job, Oid user_oid) { BgwParams bgw_params = { .job_id = Int32GetDatum(job->fd.id), .job_history_id = job->job_history.id, .job_history_execution_start = job->job_history.execution_start, .user_oid = user_oid, }; strlcpy(bgw_params.bgw_main, job_entrypoint_function_name, sizeof(bgw_params.bgw_main)); return ts_bgw_start_worker(NameStr(job->fd.application_name), &bgw_params); } static void job_execute_function(FuncExpr *funcexpr) { bool isnull; EState *estate = CreateExecutorState(); ExprContext *econtext = CreateExprContext(estate); ExprState *es = ExecPrepareExpr((Expr *) funcexpr, estate); ExecEvalExpr(es, econtext, &isnull); FreeExprContext(econtext, true); FreeExecutorState(estate); } /** * Run configuration check validation function. * * This will run the configuration check validation function registered for * the job. If a new job is added, the job_id is going to be zero. */ void ts_bgw_job_run_config_check(Oid check, int32 job_id, Jsonb *config) { /* Nothing to check if there is no check function provided */ if (!OidIsValid(check)) return; /* NULL config may be valid */ Const *arg; if (config == NULL) arg = makeNullConst(JSONBOID, -1, InvalidOid); else arg = makeConst(JSONBOID, -1, InvalidOid, -1, JsonbPGetDatum(config), false, false); List *args = list_make1(arg); FuncExpr *funcexpr = makeFuncExpr(check, VOIDOID, args, InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL); if (get_func_prokind(check) == PROKIND_FUNCTION) job_execute_function(funcexpr); else ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported function type"), errdetail("Only functions are allowed as custom configuration checks"), errhint("Use a FUNCTION instead"))); } /* Run the check function on a configuration. It will generate errors if there * is anything wrong with the configuration, otherwise just return. If the * check function does not exist, no checking will be done.*/ static void job_config_check(BgwJob *job, Jsonb *config) { Oid proc; List *funcname; /* Both should either be empty or contain a schema and name */ Assert((strlen(NameStr(job->fd.check_schema)) == 0) == (strlen(NameStr(job->fd.check_schema)) == 0)); /* If there is no function, just return */ if (strlen(NameStr(job->fd.check_name)) == 0) return; funcname = list_make2(makeString(NameStr(job->fd.check_schema)), makeString(NameStr(job->fd.check_name))); Oid argtypes[] = { JSONBOID }; /* Only functions allowed as custom checks, as procedures can cause errors with COMMIT * statements */ proc = LookupFuncName(funcname, 1, argtypes, true); /* a check function has been registered but it can't be found anymore because it was dropped or renamed. Allow alter_job to run if that's the case without validating the config but also print a warning */ if (OidIsValid(proc)) ts_bgw_job_run_config_check(proc, job->fd.id, config); else elog(WARNING, "function %s.%s(config jsonb) not found, skipping config validation for " "job %d", NameStr(job->fd.check_schema), NameStr(job->fd.check_name), job->fd.id); } static BgwJob * bgw_job_from_tupleinfo(TupleInfo *ti, size_t alloc_size) { BgwJob *job; bool should_free; HeapTuple tuple; MemoryContext old_ctx; Datum values[Natts_bgw_job] = { 0 }; bool nulls[Natts_bgw_job] = { false }; /* * allow for embedding with arbitrary alloc_size, which means we can't use * the STRUCT_FROM_TUPLE macro */ Assert(alloc_size >= sizeof(BgwJob)); job = MemoryContextAllocZero(ti->mctx, alloc_size); tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); old_ctx = MemoryContextSwitchTo(ti->mctx); /* * Using heap_deform_tuple instead of GETSTRUCT since the tuple can * contain NULL values. Some of these cannot really be null, but we check * anyway since it is cheap and will avoid problems in the future. Note * that the job structure is zeroed, so we only need to update the field * if it is non-NULL. */ heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_id)]) job->fd.id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_bgw_job_id)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_application_name)]) namestrcpy(&job->fd.application_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_bgw_job_application_name)])); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_schedule_interval)]) job->fd.schedule_interval = *DatumGetIntervalP(values[AttrNumberGetAttrOffset(Anum_bgw_job_schedule_interval)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_max_runtime)]) job->fd.max_runtime = *DatumGetIntervalP(values[AttrNumberGetAttrOffset(Anum_bgw_job_max_runtime)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_max_retries)]) job->fd.max_retries = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_bgw_job_max_retries)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_fixed_schedule)]) job->fd.fixed_schedule = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_bgw_job_fixed_schedule)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)]) { job->fd.initial_start = DatumGetTimestampTz(values[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)]); } else job->fd.initial_start = DT_NOBEGIN; if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)]) job->fd.timezone = DatumGetTextPCopy(values[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_retry_period)]) job->fd.retry_period = *DatumGetIntervalP(values[AttrNumberGetAttrOffset(Anum_bgw_job_retry_period)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_proc_schema)]) namestrcpy(&job->fd.proc_schema, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_bgw_job_proc_schema)])); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_proc_name)]) namestrcpy(&job->fd.proc_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_bgw_job_proc_name)])); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)]) namestrcpy(&job->fd.check_schema, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)])); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)]) namestrcpy(&job->fd.check_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)])); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_owner)]) job->fd.owner = DatumGetObjectId(values[AttrNumberGetAttrOffset(Anum_bgw_job_owner)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_scheduled)]) job->fd.scheduled = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_bgw_job_scheduled)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)]) job->fd.hypertable_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)]); if (!nulls[AttrNumberGetAttrOffset(Anum_bgw_job_config)]) job->fd.config = DatumGetJsonbPCopy(values[AttrNumberGetAttrOffset(Anum_bgw_job_config)]); MemoryContextSwitchTo(old_ctx); if (should_free) heap_freetuple(tuple); return job; } typedef struct AccumData { List *list; size_t alloc_size; } AccumData; static ScanTupleResult bgw_job_accum_tuple_found(TupleInfo *ti, void *data) { AccumData *list_data = data; BgwJob *job = bgw_job_from_tupleinfo(ti, list_data->alloc_size); MemoryContext orig = MemoryContextSwitchTo(ti->mctx); list_data->list = lappend(list_data->list, job); MemoryContextSwitchTo(orig); return SCAN_CONTINUE; } static ScanFilterResult bgw_job_filter_scheduled(const TupleInfo *ti, void *data) { bool isnull; Datum scheduled = slot_getattr(ti->slot, Anum_bgw_job_scheduled, &isnull); Ensure(!isnull, "scheduled column was null"); return DatumGetBool(scheduled); } /* This function is meant to be used by the scheduler only * it does not include the config field which saves us from * detoasting and makes memory management in the scheduler * simpler as otherwise the config field would have to be * freed separately when freeing jobs which would prevent * the use of list_free_deep. * The scheduler does not need the config field only the * individual jobs do. * The scheduler requires jobs to be sorted by id * which is guaranteed by the index scan on the primary key */ List * ts_bgw_job_get_scheduled(size_t alloc_size, MemoryContext mctx) { MemoryContext old_ctx; List *jobs = NIL; ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, AccessShareLock, mctx); iterator.ctx.index = catalog_get_index(ts_catalog_get(), BGW_JOB, BGW_JOB_PKEY_IDX); iterator.ctx.filter = bgw_job_filter_scheduled; ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool should_free, isnull, initial_start_isnull, timezone_isnull; Datum value, initial_start, timezone; BgwJob *job = MemoryContextAllocZero(mctx, alloc_size); HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); /* * Note that the nullable columns might have variable width, so we * handle them below. We can only use memcpy for the non-nullable fixed * width starting part of the BgwJob struct. */ memcpy(job, GETSTRUCT(tuple), offsetof(FormData_bgw_job, initial_start)); if (should_free) heap_freetuple(tuple); #ifdef USE_TELEMETRY /* ignore telemetry jobs if telemetry is disabled */ if (!ts_telemetry_on() && ts_is_telemetry_job(job)) { pfree(job); continue; } #endif /* handle NULL columns */ initial_start = slot_getattr(ti->slot, Anum_bgw_job_initial_start, &initial_start_isnull); if (!initial_start_isnull) job->fd.initial_start = DatumGetTimestampTz(initial_start); else job->fd.initial_start = DT_NOBEGIN; value = slot_getattr(ti->slot, Anum_bgw_job_hypertable_id, &isnull); job->fd.hypertable_id = isnull ? 0 : DatumGetInt32(value); /* We skip config, check_name, and check_schema since the scheduler * doesn't need these, it saves us from detoasting, and simplifies * freeing job lists in the scheduler as otherwise the config field * would have to be freed separately when freeing a job. */ job->fd.config = NULL; old_ctx = MemoryContextSwitchTo(mctx); timezone = slot_getattr(ti->slot, Anum_bgw_job_timezone, &timezone_isnull); if (!timezone_isnull) { /* We use DatumGetTextPCopy to move the detoasted value into our memory context */ job->fd.timezone = DatumGetTextPCopy(timezone); } else { job->fd.timezone = NULL; } jobs = lappend(jobs, job); MemoryContextSwitchTo(old_ctx); } return jobs; } List * ts_bgw_job_get_all(size_t alloc_size, MemoryContext mctx) { Catalog *catalog = ts_catalog_get(); AccumData list_data = { .list = NIL, .alloc_size = sizeof(BgwJob), }; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, BGW_JOB), .data = &list_data, .tuple_found = bgw_job_accum_tuple_found, .lockmode = AccessShareLock, .result_mctx = mctx, .scandirection = ForwardScanDirection, }; ts_scanner_scan(&scanctx); return list_data.list; } static void init_scan_by_proc_name(ScanKeyData *scankey, const char *proc_name) { ScanKeyInit(scankey, Anum_bgw_job_proc_hypertable_id_idx_proc_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(proc_name)); } static void init_scan_by_proc_schema(ScanKeyData *scankey, const char *proc_schema) { ScanKeyInit(scankey, Anum_bgw_job_proc_hypertable_id_idx_proc_schema, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(proc_schema)); } static void init_scan_by_hypertable_id(ScanKeyData *scankey, int32 hypertable_id) { ScanKeyInit(scankey, Anum_bgw_job_proc_hypertable_id_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); } List * ts_bgw_job_find_by_proc_and_hypertable_id(const char *proc_name, const char *proc_schema, int32 hypertable_id) { Catalog *catalog = ts_catalog_get(); ScanKeyData scankey[3]; AccumData list_data = { .list = NIL, .alloc_size = sizeof(BgwJob), }; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, BGW_JOB), .index = catalog_get_index(ts_catalog_get(), BGW_JOB, BGW_JOB_PROC_HYPERTABLE_ID_IDX), .data = &list_data, .scankey = scankey, .nkeys = sizeof(scankey) / sizeof(*scankey), .tuple_found = bgw_job_accum_tuple_found, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, }; init_scan_by_proc_schema(&scankey[0], proc_schema); init_scan_by_proc_name(&scankey[1], proc_name); init_scan_by_hypertable_id(&scankey[2], hypertable_id); ts_scanner_scan(&scanctx); return list_data.list; } List * ts_bgw_job_find_by_hypertable_id(int32 hypertable_id) { Catalog *catalog = ts_catalog_get(); ScanKeyData scankey[1]; AccumData list_data = { .list = NIL, .alloc_size = sizeof(BgwJob), }; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, BGW_JOB), .index = catalog_get_index(ts_catalog_get(), BGW_JOB, BGW_JOB_PROC_HYPERTABLE_ID_IDX), .data = &list_data, .scankey = scankey, .nkeys = sizeof(scankey) / sizeof(*scankey), .tuple_found = bgw_job_accum_tuple_found, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, }; init_scan_by_hypertable_id(&scankey[0], hypertable_id); ts_scanner_scan(&scanctx); return list_data.list; } static void init_scan_by_job_id(ScanIterator *iterator, int32 job_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), BGW_JOB, BGW_JOB_PKEY_IDX); ts_scan_iterator_scan_key_init(iterator, Anum_bgw_job_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(job_id)); } /* Lock a job tuple using an advisory lock. Advisory job locks are used to * lock the job row while a job is running to prevent a job from being * modified while in the middle of a run. This lock should be taken before * bgw_job table lock to avoid deadlocks. * * We use an advisory lock instead of a tuple lock because we want the lock on * the job id and not on the tid of the row (in case it is vacuumed or updated * in some way). We don't want the job modified while it is running for safety * reasons. Finally, we use this lock to be able to send a signal to the PID * of the running job. This is used by delete because, a job deletion sends a * SIGINT to the running job to cancel it. * * We acquire a SHARE lock on the job during scheduling and when the job is * running so that it cannot be deleted during those times and an EXCLUSIVE * lock when deleting. * * returns whether or not the lock was obtained (false return only possible if * block==false) */ bool ts_lock_job_id(int32 job_id, LOCKMODE mode, bool session_lock, LOCKTAG *tag, bool block) { /* Use a special pseudo-random field 4 value to avoid conflicting with user-advisory-locks */ TS_SET_LOCKTAG_ADVISORY(*tag, MyDatabaseId, job_id, 0); return LockAcquire(tag, mode, session_lock, !block) != LOCKACQUIRE_NOT_AVAIL; } static BgwJob * ts_bgw_job_find_with_lock(int32 bgw_job_id, MemoryContext mctx, LOCKMODE tuple_lock_mode, JobLockLifetime lock_type, bool block, bool *got_lock) { /* Take a share lock on the table to prevent concurrent data changes during scan. This lock will * be released after the scan */ ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, ShareLock, mctx); List *jobs = NIL; BgwJob *job = NULL; LOCKTAG tag; /* take advisory lock before relation lock */ *got_lock = ts_lock_job_id(bgw_job_id, tuple_lock_mode, lock_type == SESSION_LOCK, &tag, block); if (!*got_lock) { /* return NULL if lock could not be acquired */ Assert(!block); return NULL; } init_scan_by_job_id(&iterator, bgw_job_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); job = bgw_job_from_tupleinfo(ti, sizeof(BgwJob)); jobs = lappend(jobs, job); } if (list_length(jobs) > 1) { ListCell *cell; foreach (cell, jobs) { BgwJob *job = (BgwJob *) lfirst(cell); ereport(LOG, (errmsg("more than one job with same job_id %d", bgw_job_id), errdetail("job_id: %d, application_name: %s, procedure: %s.%s, scheduled: %s", job->fd.id, NameStr(job->fd.application_name), quote_identifier(NameStr(job->fd.proc_schema)), quote_identifier(NameStr(job->fd.proc_name)), job->fd.scheduled ? "true" : "false"))); } } /* We don't care about duplicate jobs in release builds and will take the * last job */ Assert(list_length(jobs) <= 1); return job; } /* Take a lock on the job for the duration of the txn. This prevents * the job from being deleted. * * Returns true if the job is found ( we block till we can acquire a lock * so we will always lock here) * false if the job is missing. */ bool ts_bgw_job_get_share_lock(int32 bgw_job_id, MemoryContext mctx) { bool got_lock; /* note the mode here is equivalent to FOR SHARE row locks */ BgwJob *job = ts_bgw_job_find_with_lock(bgw_job_id, mctx, RowShareLock, TXN_LOCK, true, /* block */ &got_lock); if (job != NULL) { if (!got_lock) { /* since we blocked for a lock , this is an unexpected condition */ ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not acquire share lock for job=%d", bgw_job_id))); } pfree(job); return true; } return false; } BgwJob * ts_bgw_job_find(int32 bgw_job_id, MemoryContext mctx, bool fail_if_not_found) { ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, AccessShareLock, mctx); int num_found = 0; BgwJob *job = NULL; init_scan_by_job_id(&iterator, bgw_job_id); ts_scanner_foreach(&iterator) { Assert(num_found == 0); job = bgw_job_from_tupleinfo(ts_scan_iterator_tuple_info(&iterator), sizeof(BgwJob)); num_found++; } if (num_found == 0 && fail_if_not_found) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("job %d not found", bgw_job_id))); return job; } static void get_job_lock_for_delete(int32 job_id) { LOCKTAG tag; bool got_lock; /* Try getting an exclusive lock on the tuple in a non-blocking manner. Note this is the * equivalent of a row-based FOR UPDATE lock */ got_lock = ts_lock_job_id(job_id, AccessExclusiveLock, /* session_lock */ false, &tag, /* block */ false); if (!got_lock) { /* If I couldn't get a lock, try killing the background worker that's running the job. * This is probably not bulletproof but best-effort is good enough here. */ VirtualTransactionId *vxid = GetLockConflicts(&tag, AccessExclusiveLock, NULL); PGPROC *proc; if (VirtualTransactionIdIsValid(*vxid)) { proc = VirtualTransactionGetProcCompat(vxid); if (proc != NULL #if PG18_LT && proc->isBackgroundWorker #else && !proc->isRegularBackend #endif ) { /* Simply assuming that this pid corresponds to the background worker * running the job is not sufficient. The scheduler could also be the * one holding the lock, when transitioning the state of the job back * to scheduled state. So we must check we don't kill the scheduler. * See https://github.com/timescale/timescaledb/issues/5224 */ const char *worker_name = GetBackgroundWorkerTypeByPid(proc->pid); if (strcmp(worker_name, SCHEDULER_APPNAME) != 0) { elog(NOTICE, "cancelling the background worker for job %d (pid %d)", job_id, proc->pid); DirectFunctionCall1(pg_cancel_backend, Int32GetDatum(proc->pid)); } } } /* We have to grab this lock before proceeding so grab it in a blocking manner now */ got_lock = ts_lock_job_id(job_id, AccessExclusiveLock, /* session_lock */ false, &tag, /* block */ true); } Ensure(got_lock, "unable to lock job id %d", job_id); } static ScanTupleResult bgw_job_tuple_delete(TupleInfo *ti, void *data) { CatalogSecurityContext sec_ctx; bool isnull_job_id; Datum datum = slot_getattr(ti->slot, Anum_bgw_job_id, &isnull_job_id); int32 job_id = DatumGetInt32(datum); Ensure(!isnull_job_id, "job id was null"); /* Also delete the bgw_stat entry */ ts_bgw_job_stat_delete(job_id); /* Delete any stats in bgw_policy_chunk_stats related to this job */ ts_bgw_policy_chunk_stats_delete_row_only_by_job_id(job_id); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); return SCAN_CONTINUE; } static bool bgw_job_delete_scan(ScanKeyData *scankey, int32 job_id) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx; /* get job lock before relation lock */ get_job_lock_for_delete(job_id); scanctx = (ScannerCtx){ .table = catalog_get_table_id(catalog, BGW_JOB), .index = catalog_get_index(catalog, BGW_JOB, BGW_JOB_PKEY_IDX), .nkeys = 1, .scankey = scankey, .data = NULL, .limit = 1, .tuple_found = bgw_job_tuple_delete, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, .result_mctx = CurrentMemoryContext, }; return ts_scanner_scan(&scanctx); } /* * This function will try to delete the job identified by `job_id`. If the job is currently running, * this function will send a `SIGINT` to the job, and wait for the job to terminate before deleting * the job. In the event that it cannot send the signal (for instance, if the job is not in a * transaction, we have no way to send the signal), it will still wait for the job to terminate and * release the job lock, or will ERROR due to a lock or deadlock timeout. In this case, the user * has to manually determine the `pid` of the BGW and send an `SIGINT` or a `SIGKILL`. */ bool ts_bgw_job_delete_by_id(int32 job_id) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_bgw_job_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(job_id)); return bgw_job_delete_scan(scankey, job_id); } /* This function only updates the fields modifiable with alter_job. */ static ScanTupleResult bgw_job_tuple_update_by_id(TupleInfo *ti, void *const data) { BgwJob *updated_job = (BgwJob *) data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; Datum values[Natts_bgw_job] = { 0 }; bool isnull[Natts_bgw_job] = { 0 }; bool doReplace[Natts_bgw_job] = { 0 }; values[AttrNumberGetAttrOffset(Anum_bgw_job_application_name)] = NameGetDatum(&updated_job->fd.application_name); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_application_name)] = true; Datum old_schedule_interval = slot_getattr(ti->slot, Anum_bgw_job_schedule_interval, &isnull[0]); Assert(!isnull[0]); /* when we update the schedule interval, modify the next start time as well*/ if (!DatumGetBool(DirectFunctionCall2(interval_eq, old_schedule_interval, IntervalPGetDatum(&updated_job->fd.schedule_interval)))) { BgwJobStat *stat = ts_bgw_job_stat_find(updated_job->fd.id); if (stat != NULL) { TimestampTz next_start = DatumGetTimestampTz( DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(stat->fd.last_finish), IntervalPGetDatum(&updated_job->fd.schedule_interval))); /* allow DT_NOBEGIN for next_start here through allow_unset=true in the case that * last_finish is DT_NOBEGIN, * This means the value is counted as unset which is what we want */ ts_bgw_job_stat_update_next_start(updated_job->fd.id, next_start, true); } values[AttrNumberGetAttrOffset(Anum_bgw_job_schedule_interval)] = IntervalPGetDatum(&updated_job->fd.schedule_interval); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_schedule_interval)] = true; } values[AttrNumberGetAttrOffset(Anum_bgw_job_max_runtime)] = IntervalPGetDatum(&updated_job->fd.max_runtime); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_max_runtime)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_max_retries)] = Int32GetDatum(updated_job->fd.max_retries); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_max_retries)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_retry_period)] = IntervalPGetDatum(&updated_job->fd.retry_period); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_retry_period)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_scheduled)] = BoolGetDatum(updated_job->fd.scheduled); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_scheduled)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_fixed_schedule)] = BoolGetDatum(updated_job->fd.fixed_schedule); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_fixed_schedule)] = true; doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_config)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)] = NameGetDatum(&updated_job->fd.check_schema); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)] = NameGetDatum(&updated_job->fd.check_name); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)] = true; if (strlen(NameStr(updated_job->fd.check_name)) == 0) { isnull[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)] = true; isnull[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)] = true; } if (updated_job->fd.config) { job_config_check(updated_job, updated_job->fd.config); values[AttrNumberGetAttrOffset(Anum_bgw_job_config)] = JsonbPGetDatum(updated_job->fd.config); } else isnull[AttrNumberGetAttrOffset(Anum_bgw_job_config)] = true; if (updated_job->fd.hypertable_id != INVALID_HYPERTABLE_ID) { values[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)] = Int32GetDatum(updated_job->fd.hypertable_id); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)] = true; } else isnull[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)] = true; if (TIMESTAMP_NOT_FINITE(updated_job->fd.initial_start)) isnull[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = true; else values[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = TimestampTzGetDatum(updated_job->fd.initial_start); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = true; if (updated_job->fd.timezone) { values[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)] = PointerGetDatum(updated_job->fd.timezone); } else isnull[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)] = true; doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)] = true; new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, isnull, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_DONE; } /* * Overwrite job with specified job_id with the given fields * * This function only updates the fields modifiable with alter_job. */ bool ts_bgw_job_update_by_id(int32 job_id, BgwJob *job) { ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, BGW_JOB), .index = catalog_get_index(catalog, BGW_JOB, BGW_JOB_PKEY_IDX), .nkeys = 1, .scankey = scankey, .data = job, .limit = 1, .tuple_found = bgw_job_tuple_update_by_id, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, .result_mctx = CurrentMemoryContext, .tuplock = &scantuplock }; ScanKeyInit(&scankey[0], Anum_bgw_job_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(job_id)); return ts_scanner_scan(&scanctx); } static void ts_bgw_job_check_max_retries(BgwJob *job) { BgwJobStat *job_stat; job_stat = ts_bgw_job_stat_find(job->fd.id); /* stop to execute failing jobs after reached the "max_retries" option */ if (job->fd.max_retries >= 0 && job_stat->fd.consecutive_failures >= job->fd.max_retries) { ereport(WARNING, (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), errmsg("job %d reached max_retries after %d consecutive failures", job->fd.id, job_stat->fd.consecutive_failures), errdetail("Job %d unscheduled as max_retries reached %d, consecutive failures %d.", job->fd.id, job->fd.max_retries, job_stat->fd.consecutive_failures), errhint("Use alter_job(%d, scheduled => TRUE) SQL function to reschedule.", job->fd.id))); if (job->fd.scheduled) { job->fd.scheduled = false; ts_bgw_job_update_by_id(job->fd.id, job); } } } void ts_bgw_job_permission_check(BgwJob *job, const char *cmd) { if (!has_privs_of_role(GetUserId(), job->fd.owner)) { const char *owner_name = GetUserNameFromId(job->fd.owner, false); const char *user_name = GetUserNameFromId(GetUserId(), false); ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("insufficient permissions to %s job %d", cmd, job->fd.id), errdetail("Job %d is owned by role \"%s\" but user \"%s\" does not belong to that " "role.", job->fd.id, owner_name, user_name))); } } void ts_bgw_job_validate_job_owner(Oid owner) { HeapTuple role_tup = SearchSysCache1(AUTHOID, ObjectIdGetDatum(owner)); if (!HeapTupleIsValid(role_tup)) elog(ERROR, "cache lookup failed for role %u", owner); Form_pg_authid rform = (Form_pg_authid) GETSTRUCT(role_tup); if (!rform->rolcanlogin) { ReleaseSysCache(role_tup); ereport(ERROR, (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION), errmsg("permission denied to start background process as role \"%s\"", NameStr(rform->rolname)), errhint("Hypertable owner must have LOGIN permission to run background tasks."))); } ReleaseSysCache(role_tup); } /* * Is the job the telemetry job? */ #ifdef USE_TELEMETRY bool ts_is_telemetry_job(BgwJob *job) { return namestrcmp(&job->fd.proc_schema, FUNCTIONS_SCHEMA_NAME) == 0 && namestrcmp(&job->fd.proc_name, "policy_telemetry") == 0; } #endif JobResult ts_bgw_job_execute(BgwJob *job) { #ifdef USE_TELEMETRY /* The telemetry job has a separate code path since we want to be able to * use telemetry even if the TSL code is not installed. */ if (ts_is_telemetry_job(job)) { /* * In the first 12 hours, we want telemetry to ping every * hour. After that initial period, we default to the * schedule_interval listed in the job table. */ Interval one_hour = { .time = 1 * USECS_PER_HOUR }; return ts_bgw_job_run_and_set_next_start(job, ts_telemetry_main_wrapper, TELEMETRY_INITIAL_NUM_RUNS, &one_hour, /* atomic */ true, /* mark */ false); } #endif #ifdef TS_DEBUG if (scheduler_test_hook != NULL) return scheduler_test_hook(job); #endif return ts_cm_functions->job_execute(job); } bool ts_bgw_job_has_timeout(BgwJob *job) { Interval zero_val = { .time = 0, }; return DatumGetBool(DirectFunctionCall2(interval_gt, IntervalPGetDatum(&job->fd.max_runtime), IntervalPGetDatum(&zero_val))); } /* Return the timestamp at which to kill the job due to a timeout */ TimestampTz ts_bgw_job_timeout_at(BgwJob *job, TimestampTz start_time) { /* timestamptz plus interval */ return DatumGetTimestampTz(DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(start_time), IntervalPGetDatum(&job->fd.max_runtime))); } TS_FUNCTION_INFO_V1(ts_bgw_job_entrypoint); static void zero_guc(const char *guc_name) { int config_change = set_config_option(guc_name, "0", PGC_SUSET, PGC_S_SESSION, GUC_ACTION_SET, true, 0, false); if (config_change == 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("guc \"%s\" does not exist", guc_name))); else if (config_change < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not set \"%s\" guc", guc_name))); } Oid ts_bgw_job_get_funcid(BgwJob *job) { ObjectWithArgs *object = makeNode(ObjectWithArgs); object->objname = list_make2(makeString(NameStr(job->fd.proc_schema)), makeString(NameStr(job->fd.proc_name))); object->objargs = list_make2(SystemTypeName("int4"), SystemTypeName("jsonb")); /* Return InvalidOid if don't found */ return LookupFuncWithArgs(OBJECT_ROUTINE, object, true); } const char * ts_bgw_job_function_call_string(BgwJob *job) { Oid funcid = ts_bgw_job_get_funcid(job); /* If do not found the function or procedure then fallback to PROKIND_FUNCTION */ char prokind = OidIsValid(funcid) ? get_func_prokind(funcid) : PROKIND_FUNCTION; StringInfo stmt = makeStringInfo(); char *jsonb_str = "NULL"; if (job->fd.config) jsonb_str = quote_literal_cstr( JsonbToCString(NULL, &job->fd.config->root, VARSIZE(job->fd.config))); switch (prokind) { case PROKIND_FUNCTION: appendStringInfo(stmt, "SELECT %s.%s('%d', %s)", quote_identifier(NameStr(job->fd.proc_schema)), quote_identifier(NameStr(job->fd.proc_name)), job->fd.id, jsonb_str); break; case PROKIND_PROCEDURE: appendStringInfo(stmt, "CALL %s.%s('%d', %s)", quote_identifier(NameStr(job->fd.proc_schema)), quote_identifier(NameStr(job->fd.proc_name)), job->fd.id, jsonb_str); break; default: ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("unsupported function type: %c", prokind))); break; } return stmt->data; } extern Datum ts_bgw_job_entrypoint(PG_FUNCTION_ARGS) { Oid db_oid = DatumGetObjectId(MyBgworkerEntry->bgw_main_arg); BgwParams params; BgwJob *job; JobResult res = JOB_FAILURE_IN_EXECUTION; bool got_lock; instr_time start; instr_time duration; memcpy(¶ms, MyBgworkerEntry->bgw_extra, sizeof(BgwParams)); Ensure(OidIsValid(params.user_oid) && params.job_id != 0, "job id or user oid was zero - job_id: %d, user_oid: %d", params.job_id, params.user_oid); BackgroundWorkerBlockSignals(); /* Setup any signal handlers here */ /* * do not use the default `bgworker_die` sigterm handler because it does * not respect critical sections */ pqsignal(SIGTERM, die); BackgroundWorkerUnblockSignals(); /* * Set up mem_guard before starting to allocate (any significant amounts * of) memory but after we have unblocked signals since we have no control * over how the callback behaves. */ MGCallbacks *callbacks = ts_get_mem_guard_callbacks(); if (callbacks && callbacks->version_num == MG_CALLBACKS_VERSION && callbacks->toggle_allocation_blocking && !callbacks->enabled) callbacks->toggle_allocation_blocking(/*enable=*/true); BackgroundWorkerInitializeConnectionByOid(db_oid, params.user_oid, 0); log_min_messages = ts_guc_bgw_log_level; elog(DEBUG2, "job %d started execution", params.job_id); ts_license_enable_module_loading(); INSTR_TIME_SET_CURRENT(start); StartTransactionCommand(); /* Grab a session lock on the job row to prevent concurrent deletes. Lock is released * when the job process exits */ job = ts_bgw_job_find_with_lock(params.job_id, TopMemoryContext, RowShareLock, SESSION_LOCK, /* block */ true, &got_lock); if (job == NULL) /* If the job is not found, we can't proceed */ ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("job %d not found when running the background worker", params.job_id))); /* get parameters from bgworker */ job->job_history.id = params.job_history_id; job->job_history.execution_start = params.job_history_execution_start; ts_bgw_job_stat_history_update(JOB_STAT_HISTORY_UPDATE_PID, job, JOB_SUCCESS, NULL); CommitTransactionCommand(); elog(DEBUG2, "job %d (%s) found", params.job_id, NameStr(job->fd.application_name)); pgstat_report_appname(NameStr(job->fd.application_name)); MemoryContext oldcontext = CurrentMemoryContext; bool job_failed = false; if (scheduler_test_hook == NULL) ts_begin_tss_store_callback(); PG_TRY(); { /* * we do not necessarily have a valid parallel worker context in * background workers, so disable parallel execution by default */ zero_guc("max_parallel_workers_per_gather"); zero_guc("max_parallel_workers"); zero_guc("max_parallel_maintenance_workers"); res = ts_bgw_job_execute(job); /* The job is responsible for committing or aborting it's own txns */ if (IsTransactionState()) ereport(ERROR, (errcode(ERRCODE_INVALID_TRANSACTION_STATE), errmsg("TimescaleDB background job \"%s\" failed to end the transaction", NameStr(job->fd.application_name)))); } PG_CATCH(); { ErrorData *edata; NameData proc_schema = { .data = { 0 } }, proc_name = { .data = { 0 } }; if (IsTransactionState()) /* If there was an error, rollback what was done before the error */ AbortCurrentTransaction(); StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); /* Free the old job if it exists, it's no longer needed, and since it's * in the TopMemoryContext it won't be freed otherwise. */ if (job != NULL) { pfree(job); } /* switch away from error context to not lose the data */ MemoryContextSwitchTo(oldcontext); job_failed = true; edata = CopyErrorData(); FlushErrorState(); /* * Note that the mark_start happens in the scheduler right before the * job is launched. Try to get a lock on the job again. Because the error * removed the session lock. Don't block and only record if the lock was actually * obtained. */ job = ts_bgw_job_find_with_lock(params.job_id, TopMemoryContext, RowShareLock, TXN_LOCK, /* block */ false, &got_lock); if (job != NULL) { namestrcpy(&proc_name, NameStr(job->fd.proc_name)); namestrcpy(&proc_schema, NameStr(job->fd.proc_schema)); job->job_history.id = params.job_history_id; job->job_history.execution_start = params.job_history_execution_start; ts_bgw_job_stat_mark_end(job, JOB_FAILURE_IN_EXECUTION, ts_errdata_to_jsonb(edata, &proc_schema, &proc_name)); ts_bgw_job_check_max_retries(job); pfree(job); } /* * the rethrow will log the error; but also log which job threw the * error */ elog(LOG, "job %d threw an error", params.job_id); PopActiveSnapshot(); CommitTransactionCommand(); ReThrowError(edata); } PG_END_TRY(); Assert(!IsTransactionState()); StartTransactionCommand(); /* * Note that the mark_start happens in the scheduler right before the job * is launched */ ts_bgw_job_stat_mark_end(job, res, NULL); if (!job_failed && ts_is_tss_enabled() && scheduler_test_hook == NULL) { const char *stmt = ts_bgw_job_function_call_string(job); ts_end_tss_store_callback(stmt, -1, (int) strlen(stmt), 0, 0); } CommitTransactionCommand(); INSTR_TIME_SET_CURRENT(duration); INSTR_TIME_SUBTRACT(duration, start); elog(DEBUG1, "job %d (%s) exiting with %s: execution time %.2f ms", params.job_id, NameStr(job->fd.application_name), (res == JOB_SUCCESS ? "success" : "failure"), INSTR_TIME_GET_MILLISEC(duration)); if (job != NULL) { pfree(job); job = NULL; } PG_RETURN_VOID(); } void ts_bgw_job_set_scheduler_test_hook(scheduler_test_hook_type hook) { scheduler_test_hook = hook; } void ts_bgw_job_set_job_entrypoint_function_name(char *func_name) { job_entrypoint_function_name = func_name; } /* * Run job and set next start. * * job: Job to run and update * func: Function to execute for the job * initial_runs: Limit on the number of runs to do * next_interval: Interval to use when computing next start * atomic: Should be executed as a single transaction. * mark: Mark the start and end of the function execution in job_stats */ bool ts_bgw_job_run_and_set_next_start(BgwJob *job, job_main_func func, int64 initial_runs, Interval *next_interval, bool atomic, bool mark) { BgwJobStat *job_stat; bool result; if (atomic) StartTransactionCommand(); if (mark) ts_bgw_job_stat_mark_start(job); result = func(); if (mark) ts_bgw_job_stat_mark_end(job, result ? JOB_SUCCESS : JOB_FAILURE_IN_EXECUTION, NULL); /* Now update next_start. */ job_stat = ts_bgw_job_stat_find(job->fd.id); /* * Note that setting next_start explicitly from this function will * override any backoff calculation due to failure. */ Ensure(job_stat != NULL, "job status for job %d not found", job->fd.id); if (job_stat->fd.total_runs < initial_runs) { TimestampTz next_start = DatumGetTimestampTz(DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(job_stat->fd.last_start), IntervalPGetDatum(next_interval))); ts_bgw_job_stat_set_next_start(job->fd.id, next_start); } if (atomic) CommitTransactionCommand(); return result; } /* Insert a new job in the bgw_job relation */ int ts_bgw_job_insert_relation(Name application_name, Interval *schedule_interval, Interval *max_runtime, int32 max_retries, Interval *retry_period, Name proc_schema, Name proc_name, Name check_schema, Name check_name, Oid owner, bool scheduled, bool fixed_schedule, int32 hypertable_id, Jsonb *config, TimestampTz initial_start, const char *timezone) { Catalog *catalog = ts_catalog_get(); Relation rel; TupleDesc desc; Datum values[Natts_bgw_job] = { 0 }; CatalogSecurityContext sec_ctx; bool nulls[Natts_bgw_job] = { false }; int32 job_id; char app_name[NAMEDATALEN]; int name_len; rel = table_open(catalog_get_table_id(catalog, BGW_JOB), RowExclusiveLock); desc = RelationGetDescr(rel); values[AttrNumberGetAttrOffset(Anum_bgw_job_schedule_interval)] = IntervalPGetDatum(schedule_interval); values[AttrNumberGetAttrOffset(Anum_bgw_job_max_runtime)] = IntervalPGetDatum(max_runtime); values[AttrNumberGetAttrOffset(Anum_bgw_job_max_retries)] = Int32GetDatum(max_retries); values[AttrNumberGetAttrOffset(Anum_bgw_job_retry_period)] = IntervalPGetDatum(retry_period); values[AttrNumberGetAttrOffset(Anum_bgw_job_proc_schema)] = NameGetDatum(proc_schema); values[AttrNumberGetAttrOffset(Anum_bgw_job_proc_name)] = NameGetDatum(proc_name); if (strlen(NameStr(*check_schema)) > 0) values[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)] = NameGetDatum(check_schema); else nulls[AttrNumberGetAttrOffset(Anum_bgw_job_check_schema)] = true; if (strlen(NameStr(*check_name)) > 0) values[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)] = NameGetDatum(check_name); else nulls[AttrNumberGetAttrOffset(Anum_bgw_job_check_name)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_owner)] = ObjectIdGetDatum(owner); values[AttrNumberGetAttrOffset(Anum_bgw_job_scheduled)] = BoolGetDatum(scheduled); values[AttrNumberGetAttrOffset(Anum_bgw_job_fixed_schedule)] = BoolGetDatum(fixed_schedule); /* initial_start must have a value if the schedule is fixed */ Assert(!fixed_schedule || !TIMESTAMP_NOT_FINITE(initial_start)); if (TIMESTAMP_NOT_FINITE(initial_start)) { nulls[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = TimestampTzGetDatum(initial_start); } else { nulls[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = false; values[AttrNumberGetAttrOffset(Anum_bgw_job_initial_start)] = TimestampTzGetDatum(initial_start); } if (hypertable_id == INVALID_HYPERTABLE_ID) nulls[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)] = true; else values[AttrNumberGetAttrOffset(Anum_bgw_job_hypertable_id)] = Int32GetDatum(hypertable_id); if (config == NULL) nulls[AttrNumberGetAttrOffset(Anum_bgw_job_config)] = true; else values[AttrNumberGetAttrOffset(Anum_bgw_job_config)] = JsonbPGetDatum(config); if (timezone == NULL) nulls[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)] = true; else values[AttrNumberGetAttrOffset(Anum_bgw_job_timezone)] = CStringGetTextDatum(timezone); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); job_id = DatumGetInt32(ts_catalog_table_next_seq_id(catalog, BGW_JOB)); name_len = snprintf(app_name, NAMEDATALEN, "%s [%d]", NameStr(*application_name), job_id); if (name_len >= NAMEDATALEN) ereport(ERROR, (errcode(ERRCODE_NAME_TOO_LONG), errmsg("application name too long."))); values[AttrNumberGetAttrOffset(Anum_bgw_job_id)] = Int32GetDatum(job_id); values[AttrNumberGetAttrOffset(Anum_bgw_job_application_name)] = CStringGetDatum(app_name); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); /* This is where we would add a call to recordDependencyOnOwner, but it * cannot support dependencies on anything but built-in classes since * getObjectClass() have a lot of hard-coded checks in place. * * Instead we have a check in process_utility.c that prevents dropping the * user if there is a dependent job. */ table_close(rel, NoLock); return values[AttrNumberGetAttrOffset(Anum_bgw_job_id)]; } /* * This function ensures the schedule interval is acceptable in the case * of fixed job schedules. Intervals that mix months with day and time * components are not acceptable since internally we use time_bucket and * cannot bucket by such an interval. */ void ts_bgw_job_validate_schedule_interval(Interval *schedule_interval) { bool has_month, has_day, has_time; has_month = schedule_interval->month; has_day = schedule_interval->day; has_time = schedule_interval->time; if (has_month && (has_day || has_time)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("month intervals cannot have day or time component"), errdetail("Fixed schedule jobs do not support such schedule intervals."), errhint("Express the interval in terms of days or time instead."))); } char * ts_bgw_job_validate_timezone(Datum timezone) { DirectFunctionCall2(timestamp_zone, timezone, TimestampGetDatum(ts_timer_get_current_timestamp())); return TextDatumGetCString(timezone); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/job.h��������������������������������������������������������������������0000664�0000000�0000000�00000010221�15100345067�0016340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <postmaster/bgworker.h> #include <storage/lock.h> #include "export.h" #include "ts_catalog/catalog.h" #define TELEMETRY_INITIAL_NUM_RUNS 12 #define SCHEDULER_APPNAME "TimescaleDB Background Worker Scheduler" /* * This is copied from mem_guard and have to be the same as the type in * mem_guard. * * These are intended as an interim solution and will be removed once we have * a stable plugin ABI for TimescaleDB. */ #define MG_CALLBACKS_VERSION 1 #define MG_CALLBACKS_VAR_NAME "mg_callbacks" typedef void (*mg_toggle_allocation_blocking)(bool enable); typedef size_t (*mg_get_allocated_memory)(); typedef size_t (*mg_get_total_allocated_memory)(); typedef bool (*mg_enabled)(); typedef struct MGCallbacks { int64 version_num; mg_toggle_allocation_blocking toggle_allocation_blocking; mg_get_allocated_memory get_allocated_memory; mg_get_total_allocated_memory get_total_allocated_memory; mg_enabled enabled; } MGCallbacks; typedef struct BgwJobHistory { int64 id; TimestampTz execution_start; } BgwJobHistory; typedef struct BgwJob { FormData_bgw_job fd; BgwJobHistory job_history; } BgwJob; /* Positive result numbers reserved for success */ typedef enum JobResult { JOB_FAILURE_TO_START = -1, JOB_FAILURE_IN_EXECUTION = 0, JOB_SUCCESS = 1, } JobResult; typedef bool job_main_func(void); typedef bool (*scheduler_test_hook_type)(BgwJob *job); extern BackgroundWorkerHandle *ts_bgw_job_start(BgwJob *job, Oid user_oid); extern List *ts_bgw_job_get_all(size_t alloc_size, MemoryContext mctx); extern List *ts_bgw_job_get_scheduled(size_t alloc_size, MemoryContext mctx); extern TSDLLEXPORT List *ts_bgw_job_find_by_hypertable_id(int32 hypertable_id); extern TSDLLEXPORT List *ts_bgw_job_find_by_proc_and_hypertable_id(const char *proc_name, const char *proc_schema, int32 hypertable_id); extern bool ts_bgw_job_get_share_lock(int32 bgw_job_id, MemoryContext mctx); TSDLLEXPORT bool ts_lock_job_id(int32 job_id, LOCKMODE mode, bool session_lock, LOCKTAG *tag, bool block); TSDLLEXPORT BgwJob *ts_bgw_job_find(int job_id, MemoryContext mctx, bool fail_if_not_found); extern bool ts_bgw_job_has_timeout(BgwJob *job); extern TimestampTz ts_bgw_job_timeout_at(BgwJob *job, TimestampTz start_time); extern TSDLLEXPORT bool ts_bgw_job_delete_by_id(int32 job_id); extern TSDLLEXPORT bool ts_bgw_job_update_by_id(int32 job_id, BgwJob *job); extern TSDLLEXPORT int32 ts_bgw_job_insert_relation( Name application_name, Interval *schedule_interval, Interval *max_runtime, int32 max_retries, Interval *retry_period, Name proc_schema, Name proc_name, Name check_schema, Name check_name, Oid owner, bool scheduled, bool fixed_schedule, int32 hypertable_id, Jsonb *config, TimestampTz initial_start, const char *timezone); extern TSDLLEXPORT void ts_bgw_job_permission_check(BgwJob *job, const char *cmd); extern TSDLLEXPORT void ts_bgw_job_validate_job_owner(Oid owner); extern JobResult ts_bgw_job_execute(BgwJob *job); extern TSDLLEXPORT void ts_bgw_job_run_config_check(Oid check, int32 job_id, Jsonb *config); extern TSDLLEXPORT Datum ts_bgw_job_entrypoint(PG_FUNCTION_ARGS); extern void ts_bgw_job_set_scheduler_test_hook(scheduler_test_hook_type hook); extern void ts_bgw_job_set_job_entrypoint_function_name(char *func_name); extern TSDLLEXPORT bool ts_bgw_job_run_and_set_next_start(BgwJob *job, job_main_func func, int64 initial_runs, Interval *next_interval, bool atomic, bool mark); extern TSDLLEXPORT void ts_bgw_job_validate_schedule_interval(Interval *schedule_interval); extern TSDLLEXPORT char *ts_bgw_job_validate_timezone(Datum timezone); extern TSDLLEXPORT bool ts_is_telemetry_job(BgwJob *job); ScanTupleResult ts_bgw_job_change_owner(TupleInfo *ti, void *data); extern TSDLLEXPORT Oid ts_bgw_job_get_funcid(BgwJob *job); extern TSDLLEXPORT const char *ts_bgw_job_function_call_string(BgwJob *job); extern TSDLLEXPORT MGCallbacks *ts_get_mem_guard_callbacks(void); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/job_stat.c���������������������������������������������������������������0000664�0000000�0000000�00000063300�15100345067�0017374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <math.h> #include <stdlib.h> #include <utils/builtins.h> #include <utils/fmgrprotos.h> #include <utils/resowner.h> #include "guc.h" #include "job_stat.h" #include "job_stat_history.h" #include "jsonb_utils.h" #include "scanner.h" #include "time_bucket.h" #include "timer.h" #include "utils.h" #define MAX_INTERVALS_BACKOFF 5 #define MAX_FAILURES_MULTIPLIER 20 #define MIN_WAIT_AFTER_CRASH_MS (5 * 60 * 1000) static bool bgw_job_stat_next_start_was_set(FormData_bgw_job_stat *fd) { return fd->next_start != DT_NOBEGIN; } static ScanTupleResult bgw_job_stat_tuple_found(TupleInfo *ti, void *const data) { BgwJobStat **job_stat_pp = (BgwJobStat **) data; *job_stat_pp = STRUCT_FROM_SLOT(ti->slot, ti->mctx, BgwJobStat, FormData_bgw_job_stat); /* * Return SCAN_CONTINUE because we check for multiple tuples as an error * condition. */ return SCAN_CONTINUE; } static bool bgw_job_stat_scan_one(int indexid, ScanKeyData scankey[], int nkeys, tuple_found_func tuple_found, tuple_filter_func tuple_filter, void *data, LOCKMODE lockmode) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, BGW_JOB_STAT), .index = catalog_get_index(catalog, BGW_JOB_STAT, indexid), .nkeys = nkeys, .scankey = scankey, .flags = SCANNER_F_KEEPLOCK, .tuple_found = tuple_found, .filter = tuple_filter, .data = data, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; return ts_scanner_scan_one(&scanctx, false, "bgw job stat"); } static inline bool bgw_job_stat_scan_job_id(int32 bgw_job_id, tuple_found_func tuple_found, tuple_filter_func tuple_filter, void *data, LOCKMODE lockmode) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_bgw_job_stat_pkey_idx_job_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(bgw_job_id)); return bgw_job_stat_scan_one(BGW_JOB_STAT_PKEY_IDX, scankey, 1, tuple_found, tuple_filter, data, lockmode); } TSDLLEXPORT BgwJobStat * ts_bgw_job_stat_find(int32 bgw_job_id) { BgwJobStat *job_stat = NULL; bgw_job_stat_scan_job_id(bgw_job_id, bgw_job_stat_tuple_found, NULL, (void *) &job_stat, AccessShareLock); return job_stat; } static ScanTupleResult bgw_job_stat_tuple_delete(TupleInfo *ti, void *const data) { ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); return SCAN_CONTINUE; } void ts_bgw_job_stat_delete(int32 bgw_job_id) { bgw_job_stat_scan_job_id(bgw_job_id, bgw_job_stat_tuple_delete, NULL, NULL, ShareRowExclusiveLock); } /* Mark the start of a job. This should be done in a separate transaction by the scheduler * before the bgw for a job is launched. This ensures that the job is counted as started * before /any/ job specific code is executed. A job that has been started but never ended * is assumed to have crashed. We use this conservative design since no process in the database * instance can write once a crash happened in any job. Therefore our only choice is to deduce * a crash from the lack of a write (the marked end write in this case). */ static ScanTupleResult bgw_job_stat_tuple_mark_start(TupleInfo *ti, void *const data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple = heap_copytuple(tuple); FormData_bgw_job_stat *fd = (FormData_bgw_job_stat *) GETSTRUCT(new_tuple); if (should_free) heap_freetuple(tuple); fd->last_start = ts_timer_get_current_timestamp(); fd->last_finish = DT_NOBEGIN; fd->next_start = DT_NOBEGIN; fd->total_runs++; /* * This is undone by any of the end marks. This is so that we count * crashes conservatively. Pretty much the crash is incremented in the * beginning and then decremented during `bgw_job_stat_tuple_mark_end`. * Thus, it only remains incremented if the job is never marked as having * ended. This happens when: 1) the job crashes 2) another process crashes * while the job is running 3) the scheduler gets a SIGTERM while the job * is running * * Unfortunately, 3 cannot be helped because when a scheduler gets a * SIGTERM it sends SIGTERMS to it's any running jobs as well. Since you * aren't supposed to write to the DB Once you get a sigterm, neither the * job nor the scheduler can mark the end of a job. */ fd->last_run_success = false; fd->total_crashes++; fd->consecutive_crashes++; fd->flags = ts_clear_flags_32(fd->flags, LAST_CRASH_REPORTED); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); return SCAN_DONE; } typedef struct { JobResult result; BgwJob *job; } JobResultCtx; /* * logic is the following * Ideally we would return * time_bucket(schedule_interval, finish_time, origin => initial_start, timezone). * That is what we return when the schedule interval does not have month components. * However, when there is a month component in the schedule interval, * then supplying the origin in time_bucket * does not work and the returned bucket is aligned on the start of the month. * In those cases, we only have month components. So we compute the difference in * months between the initial_start's timebucket and the finish time's bucket. */ TimestampTz ts_get_next_scheduled_execution_slot(BgwJob *job, TimestampTz finish_time) { Assert(job->fd.fixed_schedule == true); Datum schedint_datum = IntervalPGetDatum(&job->fd.schedule_interval); Datum timebucket_fini, timebucket_init, result; Interval one_month = { .day = 0, .time = 0, .month = 1, }; if (job->fd.schedule_interval.month > 0) { if (job->fd.timezone == NULL) { timebucket_init = DirectFunctionCall2(ts_timestamptz_bucket, schedint_datum, TimestampTzGetDatum(job->fd.initial_start)); timebucket_fini = DirectFunctionCall2(ts_timestamptz_bucket, schedint_datum, TimestampTzGetDatum(finish_time)); } else { char *tz = text_to_cstring(job->fd.timezone); timebucket_fini = DirectFunctionCall3(ts_timestamptz_timezone_bucket, schedint_datum, TimestampTzGetDatum(finish_time), CStringGetTextDatum(tz)); timebucket_init = DirectFunctionCall3(ts_timestamptz_timezone_bucket, schedint_datum, TimestampTzGetDatum(job->fd.initial_start), CStringGetTextDatum(tz)); } /* always the next bucket */ timebucket_fini = DirectFunctionCall2(timestamptz_pl_interval, timebucket_fini, schedint_datum); /* get the number of months between them */ Datum year_init = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("year"), timebucket_init); Datum year_fini = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("year"), timebucket_fini); Datum month_init = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("month"), timebucket_init); Datum month_fini = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("month"), timebucket_fini); /* convert everything to months */ float8 month_diff = (DatumGetFloat8(year_fini) * 12) + DatumGetFloat8(month_fini) - ((DatumGetFloat8(year_init) * 12) + DatumGetFloat8(month_init)); Datum months_to_add = DirectFunctionCall2(interval_mul, IntervalPGetDatum(&one_month), Float8GetDatum(month_diff)); result = DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(job->fd.initial_start), months_to_add); } else { if (job->fd.timezone == NULL) { /* it is safe to use the origin in time_bucket calculation */ timebucket_fini = DirectFunctionCall3(ts_timestamptz_bucket, schedint_datum, TimestampTzGetDatum(finish_time), TimestampTzGetDatum(job->fd.initial_start)); result = timebucket_fini; } else { char *tz = text_to_cstring(job->fd.timezone); timebucket_fini = DirectFunctionCall4(ts_timestamptz_timezone_bucket, schedint_datum, TimestampTzGetDatum(finish_time), CStringGetTextDatum(tz), TimestampTzGetDatum(job->fd.initial_start)); result = timebucket_fini; } } while (DatumGetTimestampTz(result) <= finish_time) { result = DirectFunctionCall2(timestamptz_pl_interval, result, schedint_datum); } return DatumGetTimestampTz(result); } static TimestampTz calculate_next_start_on_success_fixed(TimestampTz finish_time, BgwJob *job) { TimestampTz next_slot; next_slot = ts_get_next_scheduled_execution_slot(job, finish_time); return next_slot; } static TimestampTz calculate_next_start_on_success_drifting(TimestampTz last_finish, BgwJob *job) { TimestampTz ts; ts = DatumGetTimestampTz(DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(last_finish), IntervalPGetDatum(&job->fd.schedule_interval))); return ts; } static TimestampTz calculate_next_start_on_success(TimestampTz finish_time, BgwJob *job) { /* next_start is the previously calculated next_start for this job */ TimestampTz ts; TimestampTz last_finish = finish_time; if (!IS_VALID_TIMESTAMP(finish_time)) { last_finish = ts_timer_get_current_timestamp(); } /* calculate next_start differently depending on drift/no drift */ if (job->fd.fixed_schedule) ts = calculate_next_start_on_success_fixed(last_finish, job); else ts = calculate_next_start_on_success_drifting(last_finish, job); return ts; } static float8 calculate_jitter_percent() { /* returns a number in the range [-0.125, 0.125] */ uint8 percent = rand(); return ldexp((double) (16 - (int) (percent % 32)), -7); } /* For failures we have backoff based on consecutive failures * along with a ceiling at schedule_interval * MAX_INTERVALS_BACKOFF / 1 minute * for jobs failing at runtime / for jobs failing to launch. * We also limit the backoff in case of consecutive failures as we don't * want to pass in input that leads to out of range timestamps and don't want to * put off the next start time for the job indefinitely */ static TimestampTz calculate_next_start_on_failure(TimestampTz finish_time, int consecutive_failures, BgwJob *job, bool launch_failure) { float8 jitter = calculate_jitter_percent(); /* * Have to be declared volatile because they are modified between * setjmp/longjmp calls. */ volatile TimestampTz res = 0; volatile bool res_set = false; volatile TimestampTz last_finish = finish_time; /* consecutive failures includes this failure */ float8 multiplier = (consecutive_failures > MAX_FAILURES_MULTIPLIER ? MAX_FAILURES_MULTIPLIER : consecutive_failures); Assert(consecutive_failures > 0 && multiplier < 63); MemoryContext oldctx = CurrentMemoryContext; ResourceOwner oldowner = CurrentResourceOwner; /* 2^(consecutive_failures) - 1, at most 2^20 */ int64 max_slots = (INT64CONST(1) << (int64) multiplier) - INT64CONST(1); int64 rand_backoff = rand() % (max_slots * USECS_PER_SEC); if (!IS_VALID_TIMESTAMP(finish_time)) { elog(LOG, "%s: invalid finish time", __func__); last_finish = ts_timer_get_current_timestamp(); } PG_TRY(); { Datum ival; /* ival_max is the ceiling = MAX_INTERVALS_BACKOFF * schedule_interval */ Datum ival_max; // max wait time to launch job is 1 minute Interval interval_max = { .time = 60000000 }; Interval retry_ival = { .time = 2000000 }; retry_ival.time += rand_backoff; BeginInternalSubTransaction("next start on failure"); if (launch_failure) { // random backoff seconds in [2, 2 + 2^f] ival = IntervalPGetDatum(&retry_ival); ival_max = IntervalPGetDatum(&interval_max); } else { /* ival = retry_period * (consecutive_failures) */ ival = DirectFunctionCall2(interval_mul, IntervalPGetDatum(&job->fd.retry_period), Float8GetDatum(multiplier)); /* ival_max is the ceiling = MAX_INTERVALS_BACKOFF * schedule_interval */ ival_max = DirectFunctionCall2(interval_mul, IntervalPGetDatum(&job->fd.schedule_interval), Float8GetDatum(MAX_INTERVALS_BACKOFF)); } if (DatumGetInt32(DirectFunctionCall2(interval_cmp, ival, ival_max)) > 0) ival = ival_max; /* Add some random jitter to prevent stampeding-herds, interval will be within about +-13% */ ival = DirectFunctionCall2(interval_mul, ival, Float8GetDatum(1.0 + jitter)); res = DatumGetTimestampTz( DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(last_finish), ival)); res_set = true; ReleaseCurrentSubTransaction(); MemoryContextSwitchTo(oldctx); CurrentResourceOwner = oldowner; } PG_CATCH(); { RollbackAndReleaseCurrentSubTransaction(); MemoryContextSwitchTo(oldctx); CurrentResourceOwner = oldowner; ErrorData *errdata = CopyErrorData(); FlushErrorState(); ereport(LOG, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not calculate next start on failure: resetting value"), errdetail("Error: %s.", errdata->message))); FreeErrorData(errdata); } PG_END_TRY(); Assert(CurrentMemoryContext == oldctx); if (!res_set) { TimestampTz nowt; /* job->fd_retry_period is a valid non-null value */ nowt = ts_timer_get_current_timestamp(); res = DatumGetTimestampTz(DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(nowt), IntervalPGetDatum(&job->fd.retry_period))); } /* for fixed_schedules, we make sure that if the calculated next_start time * surpasses the next scheduled slot, then next_start will be set to the value * of the next scheduled slot, so we don't get off track */ if (job->fd.fixed_schedule) { TimestampTz next_slot = ts_get_next_scheduled_execution_slot(job, finish_time); if (res > next_slot) res = next_slot; } return res; } static TimestampTz calculate_next_start_on_failed_launch(int consecutive_failed_launches, BgwJob *job) { TimestampTz now = ts_timer_get_current_timestamp(); TimestampTz failure_calc = calculate_next_start_on_failure(now, consecutive_failed_launches, job, true); return failure_calc; } /* For crashes, the logic is the similar as for failures except we also have * a minimum wait after a crash that we wait, so that if an operator needs to disable the job, * there will be enough time before another crash. */ static TimestampTz calculate_next_start_on_crash(int consecutive_crashes, BgwJob *job) { TimestampTz now = ts_timer_get_current_timestamp(); TimestampTz failure_calc = calculate_next_start_on_failure(now, consecutive_crashes, job, false); TimestampTz min_time = TimestampTzPlusMilliseconds(now, MIN_WAIT_AFTER_CRASH_MS); if (min_time > failure_calc) return min_time; return failure_calc; } static ScanTupleResult bgw_job_stat_tuple_mark_end(TupleInfo *ti, void *const data) { JobResultCtx *result_ctx = data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple = heap_copytuple(tuple); FormData_bgw_job_stat *fd = (FormData_bgw_job_stat *) GETSTRUCT(new_tuple); Interval *duration; if (should_free) heap_freetuple(tuple); fd->last_finish = ts_timer_get_current_timestamp(); duration = DatumGetIntervalP(DirectFunctionCall2(timestamp_mi, TimestampTzGetDatum(fd->last_finish), TimestampTzGetDatum(fd->last_start))); /* undo marking created by start marks */ fd->last_run_success = result_ctx->result == JOB_SUCCESS ? true : false; fd->total_crashes--; fd->consecutive_crashes = 0; fd->flags = ts_clear_flags_32(fd->flags, LAST_CRASH_REPORTED); if (result_ctx->result == JOB_SUCCESS) { fd->total_success++; fd->consecutive_failures = 0; fd->last_successful_finish = fd->last_finish; fd->total_duration = *DatumGetIntervalP(DirectFunctionCall2(interval_pl, IntervalPGetDatum(&fd->total_duration), IntervalPGetDatum(duration))); /* Mark the next start at the end if the job itself hasn't */ if (!bgw_job_stat_next_start_was_set(fd)) fd->next_start = calculate_next_start_on_success(fd->last_finish, result_ctx->job); } else { fd->total_failures++; fd->consecutive_failures++; fd->total_duration_failures = *DatumGetIntervalP(DirectFunctionCall2(interval_pl, IntervalPGetDatum(&fd->total_duration_failures), IntervalPGetDatum(duration))); /* * Mark the next start at the end if the job itself hasn't (this may * have happened before failure) and the failure was not in starting. * If the failure was in starting, then next_start should have been * restored in `on_failure_to_start_job` and thus we don't change it here. * Even if it wasn't restored, then keep it as DT_NOBEGIN to mark it as highest priority. */ if (!bgw_job_stat_next_start_was_set(fd) && result_ctx->result != JOB_FAILURE_TO_START) fd->next_start = calculate_next_start_on_failure(fd->last_finish, fd->consecutive_failures, result_ctx->job, false); } ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); return SCAN_DONE; } static ScanTupleResult bgw_job_stat_tuple_mark_crash_reported(TupleInfo *ti, void *const data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple = heap_copytuple(tuple); FormData_bgw_job_stat *fd = (FormData_bgw_job_stat *) GETSTRUCT(new_tuple); if (should_free) heap_freetuple(tuple); fd->flags = ts_set_flags_32(fd->flags, LAST_CRASH_REPORTED); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); return SCAN_DONE; } static ScanTupleResult bgw_job_stat_tuple_set_next_start(TupleInfo *ti, void *const data) { TimestampTz *next_start = data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple = heap_copytuple(tuple); FormData_bgw_job_stat *fd = (FormData_bgw_job_stat *) GETSTRUCT(new_tuple); if (should_free) heap_freetuple(tuple); fd->next_start = *next_start; ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); return SCAN_DONE; } static bool bgw_job_stat_insert_relation(Relation rel, int32 bgw_job_id, bool mark_start, TimestampTz next_start) { TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_bgw_job_stat]; bool nulls[Natts_bgw_job_stat] = { false }; CatalogSecurityContext sec_ctx; Interval zero_ival = { .time = 0, }; values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_job_id)] = Int32GetDatum(bgw_job_id); if (mark_start) values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_last_start)] = TimestampGetDatum(ts_timer_get_current_timestamp()); else values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_last_start)] = TimestampGetDatum(DT_NOBEGIN); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_last_finish)] = TimestampGetDatum(DT_NOBEGIN); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_next_start)] = TimestampGetDatum(next_start); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_last_successful_finish)] = TimestampGetDatum(DT_NOBEGIN); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_runs)] = Int64GetDatum((mark_start ? 1 : 0)); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_duration)] = IntervalPGetDatum(&zero_ival); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_duration_failures)] = IntervalPGetDatum(&zero_ival); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_success)] = Int64GetDatum(0); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_failures)] = Int64GetDatum(0); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_consecutive_failures)] = Int32GetDatum(0); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_flags)] = Int32GetDatum(JOB_STAT_FLAGS_DEFAULT); if (mark_start) { /* This is udone by any of the end marks */ values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_last_run_success)] = BoolGetDatum(false); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_crashes)] = Int64GetDatum(1); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_consecutive_crashes)] = Int32GetDatum(1); } else { values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_last_run_success)] = BoolGetDatum(true); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_total_crashes)] = Int64GetDatum(0); values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_consecutive_crashes)] = Int32GetDatum(0); } ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); return true; } void ts_bgw_job_stat_mark_start(BgwJob *job) { /* We grab a ShareRowExclusiveLock here because we need to ensure that no * job races and adds a job when we insert the relation as well since that * can trigger a failure when inserting a row for the job. We use the * RowExclusiveLock in the scan since we cannot use NoLock (relation_open * requires a lock that it not NoLock). */ Relation rel = table_open(catalog_get_table_id(ts_catalog_get(), BGW_JOB_STAT), ShareRowExclusiveLock); if (!bgw_job_stat_scan_job_id(job->fd.id, bgw_job_stat_tuple_mark_start, NULL, NULL, RowExclusiveLock)) bgw_job_stat_insert_relation(rel, job->fd.id, true, DT_NOBEGIN); table_close(rel, NoLock); /* We need to capture the execution start because failures are always logged */ job->job_history.execution_start = ts_timer_get_current_timestamp(); job->job_history.id = INVALID_BGW_JOB_STAT_HISTORY_ID; ts_bgw_job_stat_history_update(JOB_STAT_HISTORY_UPDATE_START, job, JOB_SUCCESS, NULL); pgstat_report_activity(STATE_IDLE, NULL); } void ts_bgw_job_stat_mark_end(BgwJob *job, JobResult result, Jsonb *edata) { JobResultCtx res = { .job = job, .result = result, }; if (!bgw_job_stat_scan_job_id(job->fd.id, bgw_job_stat_tuple_mark_end, NULL, &res, ShareRowExclusiveLock)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unable to find job statistics for job %d", job->fd.id))); } ts_bgw_job_stat_history_update(JOB_STAT_HISTORY_UPDATE_END, job, result, edata); pgstat_report_activity(STATE_IDLE, NULL); } void ts_bgw_job_stat_mark_crash_reported(BgwJob *job, JobResult result) { if (!bgw_job_stat_scan_job_id(job->fd.id, bgw_job_stat_tuple_mark_crash_reported, NULL, NULL, RowExclusiveLock)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unable to find job statistics for job %d", job->fd.id))); } ts_bgw_job_stat_history_update(JOB_STAT_HISTORY_UPDATE_END, job, result, NULL); pgstat_report_activity(STATE_IDLE, NULL); } bool ts_bgw_job_stat_end_was_marked(BgwJobStat *jobstat) { return !TIMESTAMP_IS_NOBEGIN(jobstat->fd.last_finish); } TSDLLEXPORT void ts_bgw_job_stat_set_next_start(int32 job_id, TimestampTz next_start) { /* Cannot use DT_NOBEGIN as that's the value used to indicate "not set" */ if (next_start == DT_NOBEGIN) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot set next start to -infinity"))); } if (!bgw_job_stat_scan_job_id(job_id, bgw_job_stat_tuple_set_next_start, NULL, &next_start, ShareRowExclusiveLock)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unable to find job statistics for job %d", job_id))); } } /* update next_start if job stat exists */ TSDLLEXPORT bool ts_bgw_job_stat_update_next_start(int32 job_id, TimestampTz next_start, bool allow_unset) { bool found = false; /* Cannot use DT_NOBEGIN as that's the value used to indicate "not set" */ if (!allow_unset && next_start == DT_NOBEGIN) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot set next start to -infinity"))); } found = bgw_job_stat_scan_job_id(job_id, bgw_job_stat_tuple_set_next_start, NULL, &next_start, ShareRowExclusiveLock); return found; } TSDLLEXPORT void ts_bgw_job_stat_upsert_next_start(int32 bgw_job_id, TimestampTz next_start) { /* Cannot use DT_NOBEGIN as that's the value used to indicate "not set" */ if (next_start == DT_NOBEGIN) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot set next start to -infinity"))); } /* We grab a ShareRowExclusiveLock here because we need to ensure that no * job races and adds a job when we insert the relation as well since that * can trigger a failure when inserting a row for the job. We use the * RowExclusiveLock in the scan since we cannot use NoLock (relation_open * requires a lock that it not NoLock). */ Relation rel = table_open(catalog_get_table_id(ts_catalog_get(), BGW_JOB_STAT), ShareRowExclusiveLock); if (!bgw_job_stat_scan_job_id(bgw_job_id, bgw_job_stat_tuple_set_next_start, NULL, &next_start, RowExclusiveLock)) bgw_job_stat_insert_relation(rel, bgw_job_id, false, next_start); table_close(rel, NoLock); } bool ts_bgw_job_stat_should_execute(BgwJobStat *jobstat, BgwJob *job) { /* * Stub to allow the system to disable jobs based on the number of crashes * or failures. */ return true; } TimestampTz ts_bgw_job_stat_next_start(BgwJobStat *jobstat, BgwJob *job, int32 consecutive_failed_launches) { /* give the system some room to breathe, wait before trying to launch again */ if (consecutive_failed_launches > 0) return calculate_next_start_on_failed_launch(consecutive_failed_launches, job); if (jobstat == NULL) /* Never previously run - run right away */ return DT_NOBEGIN; if (jobstat->fd.consecutive_crashes > 0) { /* Update the errors table regarding the crash */ if (!ts_flags_are_set_32(jobstat->fd.flags, LAST_CRASH_REPORTED)) { ts_bgw_job_stat_mark_crash_reported(job, JOB_FAILURE_IN_EXECUTION); } return calculate_next_start_on_crash(jobstat->fd.consecutive_crashes, job); } return jobstat->fd.next_start; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/job_stat.h���������������������������������������������������������������0000664�0000000�0000000�00000002673�15100345067�0017407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "job.h" #include "ts_catalog/catalog.h" #define JOB_STAT_FLAGS_DEFAULT 0 #define LAST_CRASH_REPORTED 1 typedef struct BgwJobStat { FormData_bgw_job_stat fd; } BgwJobStat; extern TSDLLEXPORT BgwJobStat *ts_bgw_job_stat_find(int job_id); extern void ts_bgw_job_stat_delete(int job_id); extern TSDLLEXPORT void ts_bgw_job_stat_mark_start(BgwJob *job); extern void ts_bgw_job_stat_mark_end(BgwJob *job, JobResult result, Jsonb *edata); extern bool ts_bgw_job_stat_end_was_marked(BgwJobStat *jobstat); extern TSDLLEXPORT void ts_bgw_job_stat_set_next_start(int32 job_id, TimestampTz next_start); extern TSDLLEXPORT bool ts_bgw_job_stat_update_next_start(int32 job_id, TimestampTz next_start, bool allow_unset); extern TSDLLEXPORT void ts_bgw_job_stat_upsert_next_start(int32 bgw_job_id, TimestampTz next_start); extern bool ts_bgw_job_stat_should_execute(BgwJobStat *jobstat, BgwJob *job); extern TimestampTz ts_bgw_job_stat_next_start(BgwJobStat *jobstat, BgwJob *job, int32 consecutive_failed_launches); extern TSDLLEXPORT void ts_bgw_job_stat_mark_crash_reported(BgwJob *job, JobResult result); extern TSDLLEXPORT TimestampTz ts_get_next_scheduled_execution_slot(BgwJob *job, TimestampTz finish_time); ���������������������������������������������������������������������timescaledb-2.23.0/src/bgw/job_stat_history.c�������������������������������������������������������0000664�0000000�0000000�00000024266�15100345067�0021165�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <utils/jsonb.h> #include "compat/compat.h" #include "guc.h" #include "hypertable.h" #include "job_stat_history.h" #include "jsonb_utils.h" #include "timer.h" #include "utils.h" typedef struct BgwJobStatHistoryContext { JobResult result; BgwJobStatHistoryUpdateType update_type; BgwJob *job; Jsonb *edata; } BgwJobStatHistoryContext; static Jsonb * build_job_info(BgwJob *job) { JsonbParseState *parse_state = NULL; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); /* all fields that is possible to change with `alter_job` API */ ts_jsonb_add_interval(parse_state, "schedule_interval", &job->fd.schedule_interval); ts_jsonb_add_interval(parse_state, "max_runtime", &job->fd.max_runtime); ts_jsonb_add_int32(parse_state, "max_retries", job->fd.max_retries); ts_jsonb_add_interval(parse_state, "retry_period", &job->fd.retry_period); ts_jsonb_add_str(parse_state, "proc_schema", NameStr(job->fd.proc_schema)); ts_jsonb_add_str(parse_state, "proc_name", NameStr(job->fd.proc_name)); ts_jsonb_add_str(parse_state, "owner", GetUserNameFromId(job->fd.owner, false)); ts_jsonb_add_bool(parse_state, "scheduled", job->fd.scheduled); ts_jsonb_add_bool(parse_state, "fixed_schedule", job->fd.fixed_schedule); if (job->fd.initial_start) ts_jsonb_add_interval(parse_state, "initial_start", &job->fd.retry_period); if (job->fd.hypertable_id != INVALID_HYPERTABLE_ID) ts_jsonb_add_int32(parse_state, "hypertable_id", job->fd.hypertable_id); if (job->fd.config != NULL) { /* config information jsonb*/ JsonbValue value = { 0 }; JsonbToJsonbValue(job->fd.config, &value); ts_jsonb_add_value(parse_state, "config", &value); } if (strlen(NameStr(job->fd.check_schema)) > 0) ts_jsonb_add_str(parse_state, "check_schema", NameStr(job->fd.check_schema)); if (strlen(NameStr(job->fd.check_name)) > 0) ts_jsonb_add_str(parse_state, "check_name", NameStr(job->fd.check_name)); if (job->fd.timezone != NULL) ts_jsonb_add_str(parse_state, "timezone", text_to_cstring(job->fd.timezone)); return JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL)); } static Jsonb * ts_bgw_job_stat_history_build_data_info(BgwJobStatHistoryContext *context) { JsonbParseState *parse_state = NULL; JsonbValue value = { 0 }; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); Assert(context != NULL && context->job != NULL); /* job information jsonb */ JsonbToJsonbValue(build_job_info(context->job), &value); ts_jsonb_add_value(parse_state, "job", &value); if (context->edata != NULL) { /* error information jsonb */ JsonbToJsonbValue(context->edata, &value); ts_jsonb_add_value(parse_state, "error_data", &value); } return JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL)); } static void bgw_job_stat_history_insert(BgwJobStatHistoryContext *context, bool track_only_errors) { Assert(context != NULL); Relation rel = table_open(catalog_get_table_id(ts_catalog_get(), BGW_JOB_STAT_HISTORY), ShareRowExclusiveLock); TupleDesc desc = RelationGetDescr(rel); NullableDatum values[Natts_bgw_job_stat_history] = { { 0 } }; CatalogSecurityContext sec_ctx; ts_datum_set_int32(Anum_bgw_job_stat_history_job_id, values, context->job->fd.id, false); ts_datum_set_timestamptz(Anum_bgw_job_stat_history_execution_start, values, context->job->job_history.execution_start, false); if (track_only_errors) { /* In case of logging only ERRORs */ ts_datum_set_int32(Anum_bgw_job_stat_history_pid, values, MyProcPid, false); ts_datum_set_timestamptz(Anum_bgw_job_stat_history_execution_finish, values, ts_timer_get_current_timestamp(), false); ts_datum_set_bool(Anum_bgw_job_stat_history_succeeded, values, false, false); } else { /* When tracking history first we INSERT the job without the FINISH execution timestamp, * PID and SUCCEED flag because it will be marked once the job finishes */ ts_datum_set_int32(Anum_bgw_job_stat_history_pid, values, 0, true); ts_datum_set_timestamptz(Anum_bgw_job_stat_history_execution_finish, values, 0, true); ts_datum_set_bool(Anum_bgw_job_stat_history_succeeded, values, false, true); } ts_datum_set_jsonb(Anum_bgw_job_stat_history_data, values, ts_bgw_job_stat_history_build_data_info(context)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); if (context->job->job_history.id == INVALID_BGW_JOB_STAT_HISTORY_ID) { /* We need to get a new job id to mark the end later */ context->job->job_history.id = ts_catalog_table_next_seq_id(ts_catalog_get(), BGW_JOB_STAT_HISTORY); } ts_datum_set_int64(Anum_bgw_job_stat_history_id, values, context->job->job_history.id, false); ts_catalog_insert_datums(rel, desc, values); ts_catalog_restore_user(&sec_ctx); table_close(rel, NoLock); } static void bgw_job_stat_history_mark_start(BgwJobStatHistoryContext *context) { /* Don't mark the start in case of the GUC be disabled */ if (!ts_guc_enable_job_execution_logging) return; bgw_job_stat_history_insert(context, false); } static bool bgw_job_stat_history_scan_one(int indexid, ScanKeyData scankey[], int nkeys, tuple_found_func tuple_found, tuple_filter_func tuple_filter, void *data, LOCKMODE lockmode) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, BGW_JOB_STAT_HISTORY), .index = catalog_get_index(catalog, BGW_JOB_STAT_HISTORY, indexid), .nkeys = nkeys, .scankey = scankey, .flags = SCANNER_F_KEEPLOCK, .tuple_found = tuple_found, .filter = tuple_filter, .data = data, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; return ts_scanner_scan_one(&scanctx, false, "bgw job stat"); } static inline bool bgw_job_stat_history_scan_id(int64 bgw_job_history_id, tuple_found_func tuple_found, tuple_filter_func tuple_filter, void *data, LOCKMODE lockmode) { if (bgw_job_history_id == INVALID_BGW_JOB_STAT_HISTORY_ID) return true; ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_bgw_job_stat_history_pkey_idx_id, BTEqualStrategyNumber, F_INT8EQ, Int64GetDatum(bgw_job_history_id)); return bgw_job_stat_history_scan_one(BGW_JOB_STAT_HISTORY_PKEY_IDX, scankey, 1, tuple_found, tuple_filter, data, lockmode); } static ScanTupleResult bgw_job_stat_history_tuple_update(TupleInfo *ti, void *const data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); BgwJobStatHistoryContext *context = (BgwJobStatHistoryContext *) data; Jsonb *job_history_data = NULL; Datum values[Natts_bgw_job_stat_history] = { 0 }; bool nulls[Natts_bgw_job_stat_history] = { 0 }; bool doReplace[Natts_bgw_job_stat_history] = { 0 }; switch (context->update_type) { case JOB_STAT_HISTORY_UPDATE_PID: { values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_pid)] = Int32GetDatum(MyProcPid); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_pid)] = true; break; } case JOB_STAT_HISTORY_UPDATE_END: { values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_execution_finish)] = TimestampTzGetDatum(ts_timer_get_current_timestamp()); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_execution_finish)] = true; values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_succeeded)] = BoolGetDatum((context->result == JOB_SUCCESS)); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_succeeded)] = true; job_history_data = ts_bgw_job_stat_history_build_data_info(context); if (job_history_data != NULL) { values[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_data)] = JsonbPGetDatum(job_history_data); doReplace[AttrNumberGetAttrOffset(Anum_bgw_job_stat_history_data)] = true; } break; } case JOB_STAT_HISTORY_UPDATE_START: pg_unreachable(); break; } HeapTuple new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_DONE; } static void bgw_job_stat_history_update(BgwJobStatHistoryContext *context) { /* Don't execute in case of the GUC is false and the job succeeded, because failures are always * logged */ if (!ts_guc_enable_job_execution_logging && context->result == JOB_SUCCESS) return; /* Re-read the job information because it can change during the execution by using the * `alter_job` API inside the function/procedure (i.e. job config) */ BgwJob *new_job = ts_bgw_job_find(context->job->fd.id, CurrentMemoryContext, true); /* Set the job history information */ new_job->job_history = context->job->job_history; /* Use the newly loaded job in the current context to use this information to register the * execution history */ context->job = new_job; /* Failures are always logged so in case of the GUC is false and a failure happens then we need * to insert all the information in the job error history table */ if (!ts_guc_enable_job_execution_logging && context->result != JOB_SUCCESS) { bgw_job_stat_history_insert(context, true); } else { /* Mark the end of the previous inserted start execution */ if (!bgw_job_stat_history_scan_id(new_job->job_history.id, bgw_job_stat_history_tuple_update, NULL, context, RowExclusiveLock)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unable to find job history " INT64_FORMAT, new_job->job_history.id))); } } void ts_bgw_job_stat_history_update(BgwJobStatHistoryUpdateType update_type, BgwJob *job, JobResult result, Jsonb *edata) { BgwJobStatHistoryContext context = { .result = result, .update_type = update_type, .job = job, .edata = edata, }; switch (update_type) { case JOB_STAT_HISTORY_UPDATE_START: bgw_job_stat_history_mark_start(&context); break; case JOB_STAT_HISTORY_UPDATE_END: case JOB_STAT_HISTORY_UPDATE_PID: bgw_job_stat_history_update(&context); break; } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/job_stat_history.h�������������������������������������������������������0000664�0000000�0000000�00000001164�15100345067�0021162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "job.h" #include "job_stat.h" #include "ts_catalog/catalog.h" #define INVALID_BGW_JOB_STAT_HISTORY_ID 0 typedef enum BgwJobStatHistoryUpdateType { JOB_STAT_HISTORY_UPDATE_START, JOB_STAT_HISTORY_UPDATE_END, JOB_STAT_HISTORY_UPDATE_PID, } BgwJobStatHistoryUpdateType; extern void ts_bgw_job_stat_history_update(BgwJobStatHistoryUpdateType update_type, BgwJob *job, JobResult result, Jsonb *edata); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/launcher_interface.c�����������������������������������������������������0000664�0000000�0000000�00000003071�15100345067�0021407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include "compat/compat.h" #include "extension.h" #include "launcher_interface.h" #define MIN_LOADER_API_VERSION 4 extern bool ts_bgw_worker_reserve(void) { PGFunction reserve = load_external_function(EXTENSION_SO, "ts_bgw_worker_reserve", true, NULL); return DatumGetBool( DirectFunctionCall1(reserve, BoolGetDatum(false))); /* no function call zero */ } extern void ts_bgw_worker_release(void) { PGFunction release = load_external_function(EXTENSION_SO, "ts_bgw_worker_release", true, NULL); DirectFunctionCall1(release, BoolGetDatum(false)); /* no function call zero */ } extern int ts_bgw_num_unreserved(void) { PGFunction unreserved = load_external_function(EXTENSION_SO, "ts_bgw_num_unreserved", true, NULL); return DatumGetInt32( DirectFunctionCall1(unreserved, BoolGetDatum(false))); /* no function call zero */ } extern int ts_bgw_loader_api_version(void) { void **versionptr = find_rendezvous_variable(RENDEZVOUS_BGW_LOADER_API_VERSION); if (*versionptr == NULL) return 0; return *((int32 *) *versionptr); } extern void ts_bgw_check_loader_api_version() { int version = ts_bgw_loader_api_version(); if (version < MIN_LOADER_API_VERSION) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("loader version out-of-date"), errhint("Please restart the database to upgrade the loader version."))); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/launcher_interface.h�����������������������������������������������������0000664�0000000�0000000�00000000673�15100345067�0021421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> extern bool ts_bgw_worker_reserve(void); extern void ts_bgw_worker_release(void); extern int ts_bgw_num_unreserved(void); extern int ts_bgw_loader_api_version(void); extern void ts_bgw_check_loader_api_version(void); ���������������������������������������������������������������������timescaledb-2.23.0/src/bgw/scheduler.c��������������������������������������������������������������0000664�0000000�0000000�00000064421�15100345067�0017552�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This is a scheduler that takes background jobs and schedules them appropriately * * Limitations: For now the jobs are only loaded when the scheduler starts and are not * updated if the jobs table changes * */ #include <postgres.h> #include <access/xact.h> #include <miscadmin.h> #include <nodes/pg_list.h> #include <pgstat.h> #include <postmaster/bgworker.h> #include <storage/ipc.h> #include <storage/latch.h> #include <storage/lwlock.h> #include <storage/proc.h> #include <storage/shmem.h> #include <tcop/tcopprot.h> #include <utils/acl.h> #include <utils/inval.h> #include <utils/jsonb.h> #include <utils/memutils.h> #include <utils/snapmgr.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "extension.h" #include "guc.h" #include "job.h" #include "job_stat.h" #include "launcher_interface.h" #include "scheduler.h" #include "timer.h" #include "version.h" #include "worker.h" #define START_RETRY_MS (1 * INT64CONST(1000)) /* 1 seconds */ #define ONE_SECOND_IN_MICROSECONDS 1000000 static TimestampTz least_timestamp(TimestampTz left, TimestampTz right) { return (left < right ? left : right); } TS_FUNCTION_INFO_V1(ts_bgw_scheduler_main); /* * Global so the invalidate cache message can set. Don't need to protect * access with a lock because it's accessed only by the scheduler process. */ static bool jobs_list_needs_update; /* has to be global to shutdown jobs on exit */ static List *scheduled_jobs = NIL; static MemoryContext scheduler_mctx; static MemoryContext scratch_mctx; /* See the README for a state transition diagram */ typedef enum JobState { /* terminal state for now. Later we may have path to JOB_STATE_SCHEDULED */ JOB_STATE_DISABLED, /* * This is the initial state. next states: JOB_STATE_STARTED, * JOB_STATE_DISABLED. This job is not running and has been scheduled to * be started at a later time. */ JOB_STATE_SCHEDULED, /* * next states: JOB_STATE_TERMINATING, JOB_STATE_SCHEDULED. This job has * been started by the scheduler and is either running or finished (and * the finish has not yet been detected by the scheduler). */ JOB_STATE_STARTED, /* * next states: JOB_STATE_SCHEDULED. The scheduler has explicitly sent a * terminate to this job but has not yet detected that it has stopped. */ JOB_STATE_TERMINATING } JobState; typedef struct ScheduledBgwJob { BgwJob job; TimestampTz next_start; TimestampTz timeout_at; JobState state; BackgroundWorkerHandle *handle; bool reserved_worker; /* * We say "may" here since under normal circumstances the job itself will * perform the mark_end */ bool may_need_mark_end; int32 consecutive_failed_launches; } ScheduledBgwJob; static void on_failure_to_start_job(ScheduledBgwJob *sjob); static volatile sig_atomic_t got_SIGHUP = false; BackgroundWorkerHandle * ts_bgw_start_worker(const char *name, const BgwParams *bgw_params) { BackgroundWorker worker = { .bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION, .bgw_start_time = BgWorkerStart_RecoveryFinished, .bgw_restart_time = BGW_NEVER_RESTART, .bgw_notify_pid = MyProcPid, .bgw_main_arg = ObjectIdGetDatum(MyDatabaseId), }; BackgroundWorkerHandle *handle = NULL; strlcpy(worker.bgw_name, name, BGW_MAXLEN); strlcpy(worker.bgw_library_name, ts_extension_get_so_name(), BGW_MAXLEN); strlcpy(worker.bgw_function_name, bgw_params->bgw_main, BGW_MAXLEN); memcpy(worker.bgw_extra, bgw_params, sizeof(*bgw_params)); /* handle needs to be allocated in long-lived memory context */ MemoryContextSwitchTo(scheduler_mctx); if (!RegisterDynamicBackgroundWorker(&worker, &handle)) { elog(NOTICE, "unable to register background worker"); handle = NULL; } MemoryContextSwitchTo(scratch_mctx); return handle; } #ifdef USE_ASSERT_CHECKING static void assert_that_worker_has_stopped(ScheduledBgwJob *sjob) { pid_t pid; BgwHandleStatus status; Assert(sjob->reserved_worker); status = GetBackgroundWorkerPid(sjob->handle, &pid); Assert(BGWH_STOPPED == status); } #endif static void mark_job_as_started(ScheduledBgwJob *sjob) { Assert(!sjob->may_need_mark_end); sjob->consecutive_failed_launches = 0; ts_bgw_job_stat_mark_start(&sjob->job); sjob->may_need_mark_end = true; } static void mark_job_as_ended(ScheduledBgwJob *sjob, JobResult res, Jsonb *edata) { Assert(sjob->may_need_mark_end); ts_bgw_job_stat_mark_end(&sjob->job, res, edata); sjob->may_need_mark_end = false; } static ErrorData * makeJobErrorData(ScheduledBgwJob *sjob, JobResult res) { ErrorData *edata = (ErrorData *) palloc0(sizeof(ErrorData)); edata->elevel = ERROR; edata->sqlerrcode = ERRCODE_INTERNAL_ERROR; edata->hint = NULL; Assert(res != JOB_SUCCESS); switch (res) { case JOB_FAILURE_TO_START: edata->message = "failed to start job"; edata->detail = psprintf("Job %d (\"%s\") failed to start", sjob->job.fd.id, NameStr(sjob->job.fd.application_name)); break; case JOB_FAILURE_IN_EXECUTION: edata->message = "failed to execute job"; edata->detail = psprintf("Job %d (\"%s\") failed to execute.", sjob->job.fd.id, NameStr(sjob->job.fd.application_name)); break; default: pg_unreachable(); break; } return edata; } static void worker_state_cleanup(ScheduledBgwJob *sjob) { /* * This function needs to be safe wrt failures occurring at any point in * the job starting process. */ if (sjob->handle != NULL) { #ifdef USE_ASSERT_CHECKING /* Sanity check: worker has stopped (if it was started) */ assert_that_worker_has_stopped(sjob); #endif pfree(sjob->handle); sjob->handle = NULL; } /* * first cleanup reserved workers before accessing db. Want to minimize * the possibility of errors before worker is released */ if (sjob->reserved_worker) { ts_bgw_worker_release(); sjob->reserved_worker = false; } if (sjob->may_need_mark_end) { BgwJobStat *job_stat; if (!ts_bgw_job_get_share_lock(sjob->job.fd.id, CurrentMemoryContext)) { elog(WARNING, "scheduler detected that job %d was deleted after job quit", sjob->job.fd.id); ts_bgw_job_cache_invalidate_callback(); sjob->may_need_mark_end = false; return; } job_stat = ts_bgw_job_stat_find(sjob->job.fd.id); Assert(job_stat != NULL); if (!ts_bgw_job_stat_end_was_marked(job_stat)) { /* * Usually the job process will mark the end, but if the job gets * a signal (cancel or terminate), it won't be able to so we * should. */ elog(LOG, "job %d failed", sjob->job.fd.id); ErrorData *edata = makeJobErrorData(sjob, JOB_FAILURE_IN_EXECUTION); mark_job_as_ended(sjob, JOB_FAILURE_IN_EXECUTION, ts_errdata_to_jsonb(edata, &sjob->job.fd.proc_schema, &sjob->job.fd.proc_name)); } else { sjob->may_need_mark_end = false; } } } /* Set the state of the job. * This function is responsible for setting all of the variables in ScheduledBgwJob * except for the job itself. */ static void scheduled_bgw_job_transition_state_to(ScheduledBgwJob *sjob, JobState new_state) { #ifdef USE_ASSERT_CHECKING JobState prev_state = sjob->state; #endif BgwJobStat *job_stat; switch (new_state) { case JOB_STATE_DISABLED: Assert(prev_state == JOB_STATE_STARTED || prev_state == JOB_STATE_TERMINATING); sjob->handle = NULL; break; case JOB_STATE_SCHEDULED: /* prev_state can be any value, including itself */ worker_state_cleanup(sjob); job_stat = ts_bgw_job_stat_find(sjob->job.fd.id); Assert(!sjob->reserved_worker); sjob->next_start = ts_bgw_job_stat_next_start(job_stat, &sjob->job, sjob->consecutive_failed_launches); break; case JOB_STATE_STARTED: Assert(prev_state == JOB_STATE_SCHEDULED); Assert(sjob->handle == NULL); Assert(!sjob->reserved_worker); StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); if (!ts_bgw_job_get_share_lock(sjob->job.fd.id, CurrentMemoryContext)) { elog(WARNING, "scheduler detected that job %d was deleted when starting job", sjob->job.fd.id); ts_bgw_job_cache_invalidate_callback(); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); return; } /* If we are unable to reserve a worker go back to the scheduled state */ sjob->reserved_worker = ts_bgw_worker_reserve(); if (!sjob->reserved_worker) { elog(WARNING, "failed to launch job %d \"%s\": out of background workers", sjob->job.fd.id, NameStr(sjob->job.fd.application_name)); sjob->consecutive_failed_launches++; scheduled_bgw_job_transition_state_to(sjob, JOB_STATE_SCHEDULED); PopActiveSnapshot(); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); return; } /* * start the job before you can encounter any errors so that they * are always registered */ mark_job_as_started(sjob); if (ts_bgw_job_has_timeout(&sjob->job)) sjob->timeout_at = ts_bgw_job_timeout_at(&sjob->job, ts_timer_get_current_timestamp()); else sjob->timeout_at = DT_NOEND; PopActiveSnapshot(); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); elog(DEBUG1, "launching job %d \"%s\"", sjob->job.fd.id, NameStr(sjob->job.fd.application_name)); sjob->handle = ts_bgw_job_start(&sjob->job, sjob->job.fd.owner); if (sjob->handle == NULL) { elog(WARNING, "failed to launch job %d \"%s\": failed to start a background worker", sjob->job.fd.id, NameStr(sjob->job.fd.application_name)); on_failure_to_start_job(sjob); return; } Assert(sjob->reserved_worker); break; case JOB_STATE_TERMINATING: Assert(prev_state == JOB_STATE_STARTED); Assert(sjob->handle != NULL); Assert(sjob->reserved_worker); TerminateBackgroundWorker(sjob->handle); break; } sjob->state = new_state; } static void on_failure_to_start_job(ScheduledBgwJob *sjob) { StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); if (!ts_bgw_job_get_share_lock(sjob->job.fd.id, CurrentMemoryContext)) { elog(WARNING, "scheduler detected that job %d was deleted while failing to start", sjob->job.fd.id); ts_bgw_job_cache_invalidate_callback(); } else { /* restore the original next_start to maintain priority (it is unset during mark_start) */ if (sjob->next_start != DT_NOBEGIN) ts_bgw_job_stat_set_next_start(sjob->job.fd.id, sjob->next_start); ErrorData *edata = makeJobErrorData(sjob, JOB_FAILURE_TO_START); mark_job_as_ended(sjob, JOB_FAILURE_TO_START, ts_errdata_to_jsonb(edata, &sjob->job.fd.proc_schema, &sjob->job.fd.proc_name)); } scheduled_bgw_job_transition_state_to(sjob, JOB_STATE_SCHEDULED); PopActiveSnapshot(); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); } static inline void bgw_scheduler_on_postmaster_death(void) { /* * Don't call exit hooks cause we want to bail out quickly. We don't care * about cleaning up shared memory in this case anyway since it's * potentially corrupt. */ on_exit_reset(); ereport(FATAL, (errcode(ERRCODE_ADMIN_SHUTDOWN), errmsg("postmaster exited while TimescaleDB scheduler was working"))); } /* * This function starts a job. * To correctly count crashes we need to mark the start of a job in a separate * txn before we kick off the actual job. Thus this function cannot be run * from within a transaction. */ static void scheduled_ts_bgw_job_start(ScheduledBgwJob *sjob, register_background_worker_callback_type bgw_register) { pid_t pid; BgwHandleStatus status; scheduled_bgw_job_transition_state_to(sjob, JOB_STATE_STARTED); if (sjob->state != JOB_STATE_STARTED) return; Assert(sjob->handle != NULL); if (bgw_register != NULL) bgw_register(sjob->handle, scheduler_mctx); status = WaitForBackgroundWorkerStartup(sjob->handle, &pid); switch (status) { case BGWH_POSTMASTER_DIED: bgw_scheduler_on_postmaster_death(); break; case BGWH_STARTED: /* all good */ break; case BGWH_STOPPED: StartTransactionCommand(); scheduled_bgw_job_transition_state_to(sjob, JOB_STATE_SCHEDULED); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); break; case BGWH_NOT_YET_STARTED: /* should not be possible */ elog(ERROR, "unexpected bgworker state %d", status); break; } } static void terminate_and_cleanup_job(ScheduledBgwJob *sjob) { if (sjob->handle != NULL) { TerminateBackgroundWorker(sjob->handle); WaitForBackgroundWorkerShutdown(sjob->handle); } sjob->may_need_mark_end = false; worker_state_cleanup(sjob); } /* * Update the given job list with whatever is in the bgw_job table. For overlapping jobs, * copy over any existing scheduler info from the given jobs list. * Assume that both lists are ordered by job ID. * Note that this function call will destroy cur_jobs_list and return a new list. */ List * ts_update_scheduled_jobs_list(List *cur_jobs_list, MemoryContext mctx) { List *new_jobs = ts_bgw_job_get_scheduled(sizeof(ScheduledBgwJob), mctx); ListCell *new_ptr = list_head(new_jobs); ListCell *cur_ptr = list_head(cur_jobs_list); elog(DEBUG2, "updating scheduled jobs list"); while (cur_ptr != NULL && new_ptr != NULL) { ScheduledBgwJob *new_sjob = lfirst(new_ptr); ScheduledBgwJob *cur_sjob = lfirst(cur_ptr); if (cur_sjob->job.fd.id < new_sjob->job.fd.id) { /* * We don't need cur_sjob anymore. Make sure to clean up the job * state. Then keep advancing cur pointer until we catch up. */ terminate_and_cleanup_job(cur_sjob); cur_ptr = lnext(cur_jobs_list, cur_ptr); continue; } if (cur_sjob->job.fd.id == new_sjob->job.fd.id) { /* * Then this job already exists. Copy over any state and advance * both pointers. */ cur_sjob->job = new_sjob->job; *new_sjob = *cur_sjob; /* reload the scheduling information from the job_stats */ if (cur_sjob->state == JOB_STATE_SCHEDULED) scheduled_bgw_job_transition_state_to(new_sjob, JOB_STATE_SCHEDULED); cur_ptr = lnext(cur_jobs_list, cur_ptr); new_ptr = lnext(new_jobs, new_ptr); } else if (cur_sjob->job.fd.id > new_sjob->job.fd.id) { scheduled_bgw_job_transition_state_to(new_sjob, JOB_STATE_SCHEDULED); elog(DEBUG1, "sjob %d was new, its fixed_schedule is %d", new_sjob->job.fd.id, new_sjob->job.fd.fixed_schedule); /* Advance the new_job list until we catch up to cur_list */ new_ptr = lnext(new_jobs, new_ptr); } } /* If there's more stuff in cur_list, clean it all up */ if (cur_ptr != NULL) { ListCell *ptr; for_each_cell (ptr, cur_jobs_list, cur_ptr) terminate_and_cleanup_job(lfirst(ptr)); } if (new_ptr != NULL) { /* Then there are more new jobs. Initialize all of them. */ ListCell *ptr; for_each_cell (ptr, new_jobs, new_ptr) scheduled_bgw_job_transition_state_to(lfirst(ptr), JOB_STATE_SCHEDULED); } /* Free the old list */ list_free_deep(cur_jobs_list); return new_jobs; } #ifdef TS_DEBUG /* Only used by test code */ void ts_populate_scheduled_job_tuple(ScheduledBgwJob *sjob, Datum *values) { if (sjob == NULL) return; values[0] = Int32GetDatum(sjob->job.fd.id); values[1] = NameGetDatum(&sjob->job.fd.application_name); values[2] = IntervalPGetDatum(&sjob->job.fd.schedule_interval); values[3] = IntervalPGetDatum(&sjob->job.fd.max_runtime); values[4] = Int32GetDatum(sjob->job.fd.max_retries); values[5] = IntervalPGetDatum(&sjob->job.fd.retry_period); values[6] = TimestampTzGetDatum(sjob->next_start); values[7] = TimestampTzGetDatum(sjob->timeout_at); values[8] = BoolGetDatum(sjob->reserved_worker); values[9] = BoolGetDatum(sjob->may_need_mark_end); } #endif static int cmp_next_start(const ListCell *left_cell, const ListCell *right_cell) { ScheduledBgwJob *left_sjob = lfirst(left_cell); ScheduledBgwJob *right_sjob = lfirst(right_cell); if (left_sjob->next_start < right_sjob->next_start) return -1; if (left_sjob->next_start > right_sjob->next_start) return 1; return 0; } static void start_scheduled_jobs(register_background_worker_callback_type bgw_register) { List *ordered_scheduled_jobs; ListCell *lc; Assert(CurrentMemoryContext == scratch_mctx); /* Order jobs by increasing next_start */ /* list_sort does in-place sort - so make a copy and sort that */ ordered_scheduled_jobs = list_copy(scheduled_jobs); list_sort(ordered_scheduled_jobs, cmp_next_start); foreach (lc, ordered_scheduled_jobs) { ScheduledBgwJob *sjob = lfirst(lc); int64 job_start_diff = sjob->next_start - ts_timer_get_current_timestamp(); if (sjob->state == JOB_STATE_SCHEDULED && (job_start_diff <= 0 || sjob->next_start == DT_NOBEGIN)) { elog(DEBUG2, "starting scheduled job %d", sjob->job.fd.id); scheduled_ts_bgw_job_start(sjob, bgw_register); } else { elog(DEBUG5, "starting scheduled job %d in " INT64_FORMAT " seconds", sjob->job.fd.id, job_start_diff / ONE_SECOND_IN_MICROSECONDS); } } list_free(ordered_scheduled_jobs); } /* Returns the earliest time the scheduler should start a job that is waiting to be started */ static TimestampTz earliest_wakeup_to_start_next_job() { ListCell *lc; TimestampTz earliest = DT_NOEND; TimestampTz now = ts_timer_get_current_timestamp(); foreach (lc, scheduled_jobs) { ScheduledBgwJob *sjob = lfirst(lc); if (sjob->state == JOB_STATE_SCHEDULED) { TimestampTz start = sjob->next_start; /* if the start is less than now, this means we tried and failed to start it already, so * use the retry period */ if (start < now) start = TimestampTzPlusMilliseconds(now, START_RETRY_MS); earliest = least_timestamp(earliest, start); } } return earliest; } /* Returns the earliest time the scheduler needs to kill a job according to its timeout */ static TimestampTz earliest_job_timeout() { ListCell *lc; TimestampTz earliest = DT_NOEND; foreach (lc, scheduled_jobs) { ScheduledBgwJob *sjob = lfirst(lc); if (sjob->state == JOB_STATE_STARTED) earliest = least_timestamp(earliest, sjob->timeout_at); } return earliest; } /* Special exit function only used in shmem_exit_callback. * Do not call the normal cleanup function (worker_state_cleanup), because * 1) we do not wait for the BGW to terminate, * 2) we cannot access the database at this time, so we should not be * trying to update the bgw_stat table. */ static void terminate_all_jobs_and_release_workers() { ListCell *lc; foreach (lc, scheduled_jobs) { ScheduledBgwJob *sjob = lfirst(lc); /* * Clean up the background workers. Don't worry about state of the * sjobs, because this callback might have interrupted a state * transition. */ if (sjob->handle != NULL) TerminateBackgroundWorker(sjob->handle); if (sjob->reserved_worker) { ts_bgw_worker_release(); sjob->reserved_worker = false; } } } static void wait_for_all_jobs_to_shutdown() { ListCell *lc; foreach (lc, scheduled_jobs) { ScheduledBgwJob *sjob = lfirst(lc); if (sjob->state == JOB_STATE_STARTED || sjob->state == JOB_STATE_TERMINATING) WaitForBackgroundWorkerShutdown(sjob->handle); } } static void check_for_stopped_and_timed_out_jobs() { ListCell *lc; foreach (lc, scheduled_jobs) { BgwHandleStatus status; pid_t pid; ScheduledBgwJob *sjob = lfirst(lc); TimestampTz now = ts_timer_get_current_timestamp(); if (sjob->state != JOB_STATE_STARTED && sjob->state != JOB_STATE_TERMINATING) continue; status = GetBackgroundWorkerPid(sjob->handle, &pid); switch (status) { case BGWH_POSTMASTER_DIED: bgw_scheduler_on_postmaster_death(); break; case BGWH_NOT_YET_STARTED: elog(ERROR, "unexpected bgworker state %d", status); break; case BGWH_STARTED: /* still running */ if (sjob->state == JOB_STATE_STARTED && now >= sjob->timeout_at) { elog(WARNING, "terminating background worker \"%s\" due to timeout", NameStr(sjob->job.fd.application_name)); scheduled_bgw_job_transition_state_to(sjob, JOB_STATE_TERMINATING); Assert(sjob->state != JOB_STATE_STARTED); } break; case BGWH_STOPPED: StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); scheduled_bgw_job_transition_state_to(sjob, JOB_STATE_SCHEDULED); PopActiveSnapshot(); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); Assert(sjob->state != JOB_STATE_STARTED); break; } } } /* This is the guts of the scheduler which runs the main loop. * The parameter ttl_ms gives a maximum time to run the loop (after which * the loop will exit). This functionality is used to ease testing. * In production, ttl_ms should be < 0 to signal that the loop should * run forever (or until the process gets a signal). * * The scheduler uses 2 memory contexts for its operation: scheduler_mctx * for long-lived objects and scratch_mctx for short-lived objects. * After every iteration of the scheduling main loop scratch_mctx gets * reset. Special care needs to be taken in regards to memory contexts * since StartTransactionCommand creates and switches to a transaction * memory context which gets deleted on CommitTransactionCommand which * switches CurrentMemoryContext back to TopMemoryContext. So operations * wrapped in Start/CommitTransactionCommit will not happen in scratch_mctx * but will get freed on CommitTransactionCommand. */ void ts_bgw_scheduler_process(int32 run_for_interval_ms, register_background_worker_callback_type bgw_register) { TimestampTz start = ts_timer_get_current_timestamp(); TimestampTz quit_time = DT_NOEND; log_min_messages = ts_guc_bgw_log_level; pgstat_report_activity(STATE_RUNNING, NULL); /* If we are restoring or upgrading, don't schedule anything. Just * exit. */ if (ts_guc_restoring || IsBinaryUpgrade) { ereport(LOG, errmsg("scheduler for database %u exiting with exit status %d", MyDatabaseId, ts_debug_bgw_scheduler_exit_status), errdetail("the database is restoring or upgrading")); terminate_all_jobs_and_release_workers(); goto scheduler_exit; } /* txn to read the list of jobs from the DB */ StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); scheduled_jobs = ts_update_scheduled_jobs_list(scheduled_jobs, scheduler_mctx); PopActiveSnapshot(); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); jobs_list_needs_update = false; if (run_for_interval_ms > 0) quit_time = TimestampTzPlusMilliseconds(start, run_for_interval_ms); elog(DEBUG1, "database scheduler for database %u starting", MyDatabaseId); /* * on SIGTERM the process will usually die from the CHECK_FOR_INTERRUPTS * in the die() called from the sigterm handler. Child reaping is then * handled in the before_shmem_exit, * bgw_scheduler_before_shmem_exit_callback. */ while (quit_time > ts_timer_get_current_timestamp() && !ProcDiePending && !ts_shutdown_bgw) { TimestampTz next_wakeup = quit_time; Assert(CurrentMemoryContext == scratch_mctx); /* start jobs, and then check when to next wake up */ elog(DEBUG5, "scheduler wakeup in database %u", MyDatabaseId); start_scheduled_jobs(bgw_register); next_wakeup = least_timestamp(next_wakeup, earliest_wakeup_to_start_next_job()); next_wakeup = least_timestamp(next_wakeup, earliest_job_timeout()); pgstat_report_activity(STATE_IDLE, NULL); ts_timer_wait(next_wakeup); pgstat_report_activity(STATE_RUNNING, NULL); CHECK_FOR_INTERRUPTS(); if (got_SIGHUP) { got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); log_min_messages = ts_guc_bgw_log_level; } /* * Process any cache invalidation message that indicates we need to * update the jobs list */ AcceptInvalidationMessages(); if (jobs_list_needs_update) { StartTransactionCommand(); Assert(CurrentMemoryContext == CurTransactionContext); scheduled_jobs = ts_update_scheduled_jobs_list(scheduled_jobs, scheduler_mctx); CommitTransactionCommand(); MemoryContextSwitchTo(scratch_mctx); jobs_list_needs_update = false; } check_for_stopped_and_timed_out_jobs(); MemoryContextReset(scratch_mctx); } elog(DEBUG1, "scheduler for database %u exiting with exit status %d", MyDatabaseId, ts_debug_bgw_scheduler_exit_status); #ifdef TS_DEBUG if (ts_shutdown_bgw) elog(WARNING, "bgw scheduler stopped due to shutdown_bgw guc"); #endif scheduler_exit: CHECK_FOR_INTERRUPTS(); wait_for_all_jobs_to_shutdown(); check_for_stopped_and_timed_out_jobs(); scheduled_jobs = NIL; proc_exit(ts_debug_bgw_scheduler_exit_status); } static void bgw_scheduler_before_shmem_exit_callback(int code, Datum arg) { terminate_all_jobs_and_release_workers(); } void ts_bgw_scheduler_setup_callbacks() { before_shmem_exit(bgw_scheduler_before_shmem_exit_callback, PointerGetDatum(NULL)); } /* some of the scheduler mock code calls functions from this file without going through * the main loop so we need a way to setup the memory contexts */ void ts_bgw_scheduler_setup_mctx() { scheduler_mctx = AllocSetContextCreate(TopMemoryContext, "Scheduler", ALLOCSET_DEFAULT_SIZES); scratch_mctx = AllocSetContextCreate(scheduler_mctx, "SchedulerScratch", ALLOCSET_DEFAULT_SIZES); MemoryContextSwitchTo(scratch_mctx); } static void handle_sighup(SIGNAL_ARGS) { /* based on av_sighup_handler */ int save_errno = errno; got_SIGHUP = true; SetLatch(MyLatch); errno = save_errno; } /* * Register SIGTERM and SIGHUP handlers for bgw_scheduler. * This function _must_ be called with signals blocked, i.e., after calling * BackgroundWorkerBlockSignals */ void ts_bgw_scheduler_register_signal_handlers(void) { /* * do not use the default `bgworker_die` sigterm handler because it does * not respect critical sections */ pqsignal(SIGTERM, die); pqsignal(SIGHUP, handle_sighup); /* Some SIGHUPS may already have been dropped, so we must load the file here */ got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); log_min_messages = ts_guc_bgw_log_level; } Datum ts_bgw_scheduler_main(PG_FUNCTION_ARGS) { BackgroundWorkerBlockSignals(); /* Setup any signal handlers here */ ts_bgw_scheduler_register_signal_handlers(); BackgroundWorkerUnblockSignals(); ts_bgw_scheduler_setup_callbacks(); pgstat_report_appname(SCHEDULER_APPNAME); ts_bgw_scheduler_setup_mctx(); ts_bgw_scheduler_process(-1, NULL); Assert(scheduled_jobs == NIL); MemoryContextSwitchTo(TopMemoryContext); MemoryContextDelete(scheduler_mctx); PG_RETURN_VOID(); }; void ts_bgw_job_cache_invalidate_callback() { jobs_list_needs_update = true; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/scheduler.h��������������������������������������������������������������0000664�0000000�0000000�00000002344�15100345067�0017553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "compat/compat.h" #include <postgres.h> #include <fmgr.h> #include <postmaster/bgworker.h> #include "timer.h" #include "worker.h" typedef struct ScheduledBgwJob ScheduledBgwJob; /* callback used in testing */ typedef void (*register_background_worker_callback_type)(BackgroundWorkerHandle *, MemoryContext scheduler_ctx); /* Exposed for testing */ extern List *ts_update_scheduled_jobs_list(List *cur_jobs_list, MemoryContext mctx); #ifdef TS_DEBUG extern void ts_populate_scheduled_job_tuple(ScheduledBgwJob *sjob, Datum *values); #endif extern void ts_bgw_scheduler_process(int32 run_for_interval_ms, register_background_worker_callback_type bgw_register); /* exposed for access by mock */ extern void ts_bgw_scheduler_setup_callbacks(void); extern void ts_bgw_job_cache_invalidate_callback(void); extern void ts_bgw_scheduler_register_signal_handlers(void); extern void ts_bgw_scheduler_setup_mctx(void); extern BackgroundWorkerHandle *ts_bgw_start_worker(const char *name, const BgwParams *bgw_params); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/timer.c������������������������������������������������������������������0000664�0000000�0000000�00000005313�15100345067�0016707�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <miscadmin.h> #include <pgstat.h> #include <postmaster/bgworker.h> #include <storage/ipc.h> #include <storage/latch.h> #include <storage/lwlock.h> #include <storage/proc.h> #include <storage/shmem.h> #include <utils/jsonb.h> #include <utils/memutils.h> #include <utils/snapmgr.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "config.h" #include "timer.h" #define MAX_TIMEOUT (5 * INT64CONST(1000)) #define MILLISECS_PER_SEC INT64CONST(1000) #define USECS_PER_MILLISEC INT64CONST(1000) static inline void on_postmaster_death(void) { /* * Don't call exit hooks cause we want to bail out quickly. We don't care * about cleaning up shared memory in this case anyway since it's * potentially corrupt. */ on_exit_reset(); ereport(FATAL, (errcode(ERRCODE_ADMIN_SHUTDOWN), errmsg("postmaster exited while timescaledb scheduler was working"))); } static int64 get_timeout_millisec(TimestampTz by_time) { long timeout_sec = 0; int timeout_usec = 0; if (TIMESTAMP_IS_NOBEGIN(by_time)) return 0; if (TIMESTAMP_IS_NOEND(by_time)) return PG_INT64_MAX; TimestampDifference(GetCurrentTimestamp(), by_time, &timeout_sec, &timeout_usec); if (timeout_sec < 0 || timeout_usec < 0) return 0; return (int64) ((timeout_sec * MILLISECS_PER_SEC) + (((int64) timeout_usec) / USECS_PER_MILLISEC)); } static bool wait_using_wait_latch(TimestampTz until) { int wl_rc; int64 timeout = get_timeout_millisec(until); Assert(timeout >= 0 && "get_timeout_millisec underflow"); if (timeout > MAX_TIMEOUT) timeout = MAX_TIMEOUT; /* Wait latch requires timeout to be <= INT_MAX */ if (timeout > (int64) INT_MAX) timeout = INT_MAX; wl_rc = WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, timeout, PG_WAIT_EXTENSION); ResetLatch(MyLatch); if (wl_rc & WL_POSTMASTER_DEATH) on_postmaster_death(); return true; } static const Timer standard_timer = { .get_current_timestamp = GetCurrentTimestamp, .wait = wait_using_wait_latch, }; static const Timer *current_timer_implementation = &standard_timer; static inline const Timer * timer_get() { return current_timer_implementation; } bool ts_timer_wait(TimestampTz until) { return timer_get()->wait(until); } TimestampTz ts_timer_get_current_timestamp() { return timer_get()->get_current_timestamp(); } #ifdef TS_DEBUG void ts_timer_set(const Timer *timer) { current_timer_implementation = timer; } const Timer * ts_get_standard_timer() { return &standard_timer; } #endif ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/timer.h������������������������������������������������������������������0000664�0000000�0000000�00000001177�15100345067�0016720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/timestamp.h> #include "config.h" #include "export.h" typedef struct Timer { TimestampTz (*get_current_timestamp)(); bool (*wait)(TimestampTz until); } Timer; extern bool ts_timer_wait(TimestampTz until); extern TSDLLEXPORT TimestampTz ts_timer_get_current_timestamp(void); #ifdef TS_DEBUG extern void ts_timer_set(const Timer *timer); extern const Timer *ts_get_standard_timer(void); #endif �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw/worker.h�����������������������������������������������������������������0000664�0000000�0000000�00000003251�15100345067�0017104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <postmaster/bgworker.h> /** * Parameters to background workers. * * Do not add data here that cannot be simply copied to the background worker * using memcpy(3). If it is necessary to add fields that cannot simply be * copied, we need to start using the send and recv functions for the types. * * Only one of `job_id` and `ttl` is passed currently, with `job_id` being used * for normal jobs and `ttl` being used for tests. * * The `bgw_main` is the function to execute when starting the job and is * different depending on whether this is a test runner or the real runner. * * @see ts_bgw_db_scheduler_test_main * @see ts_bgw_job_entrypoint */ typedef struct BgwParams { /** User oid to run the job as. Used when initializing the database * connection. */ Oid user_oid; /** Job id to use for the worker when executing the job */ int32 job_id; /** Job history information to use for the worker when recording the job execution */ int64 job_history_id; TimestampTz job_history_execution_start; /** Time to live. Only used in tests. */ int32 ttl; /** Name of function to call when starting the background worker. */ char bgw_main[BGW_MAXLEN]; } BgwParams; /** * Compile-time check to ensure that the size of BgwParams fit into the bgw_extra field * of BackgroundWorker. */ StaticAssertDecl(sizeof(BgwParams) <= sizeof(((BackgroundWorker *) 0)->bgw_extra), "sizeof(BgwParams) exceeds sizeof(bgw_extra) field of BackgroundWorker"); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw_policy/������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017000�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw_policy/CMakeLists.txt����������������������������������������������������0000664�0000000�0000000�00000000233�15100345067�0021536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/policy.c ${CMAKE_CURRENT_SOURCE_DIR}/chunk_stats.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw_policy/chunk_stats.c�����������������������������������������������������0000664�0000000�0000000�00000014004�15100345067�0021471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <executor/tuptable.h> #include "bgw/job.h" #include "chunk_stats.h" #include "policy.h" #include "ts_catalog/catalog.h" #include "utils.h" #include "compat/compat.h" static ScanTupleResult bgw_policy_chunk_stats_tuple_found(TupleInfo *ti, void *const data) { BgwPolicyChunkStats **chunk_stats = (BgwPolicyChunkStats **) data; *chunk_stats = STRUCT_FROM_SLOT(ti->slot, ti->mctx, BgwPolicyChunkStats, FormData_bgw_policy_chunk_stats); return SCAN_CONTINUE; } /* Cascades deletes via the job delete function */ static ScanTupleResult bgw_policy_chunk_stats_delete_via_job_tuple_found(TupleInfo *ti, void *const data) { bool isnull; Datum job_id = slot_getattr(ti->slot, Anum_bgw_policy_chunk_stats_job_id, &isnull); Assert(!isnull); /* This call will actually delete the row for us */ ts_bgw_job_delete_by_id(DatumGetInt32(job_id)); return SCAN_CONTINUE; } /* * Delete all chunk_stat rows associated with this job_id. * To prevent infinite recursive calls from the job <-> policy tables, we do not cascade deletes in * this function. Instead, the caller must be responsible for making sure that the delete cascades * to the job corresponding to this policy. */ void ts_bgw_policy_chunk_stats_delete_row_only_by_job_id(int32 job_id) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_job_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(job_id)); ts_catalog_scan_all(BGW_POLICY_CHUNK_STATS, BGW_POLICY_CHUNK_STATS_JOB_ID_CHUNK_ID_IDX, scankey, 1, ts_bgw_policy_delete_row_only_tuple_found, RowExclusiveLock, NULL); } /* * Delete all chunk_stat rows associated with this chunk_id. * Deletes are cascaded via ...delete_via_job_tuple_found. */ void ts_bgw_policy_chunk_stats_delete_by_chunk_id(int32 chunk_id) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_bgw_policy_chunk_stats_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); ts_catalog_scan_all(BGW_POLICY_CHUNK_STATS, InvalidOid, scankey, 1, bgw_policy_chunk_stats_delete_via_job_tuple_found, RowExclusiveLock, NULL); } static void ts_bgw_policy_chunk_stats_insert_with_relation(Relation rel, BgwPolicyChunkStats *chunk_stats) { TupleDesc tupdesc; CatalogSecurityContext sec_ctx; Datum values[Natts_bgw_policy_chunk_stats]; bool nulls[Natts_bgw_policy_chunk_stats] = { false }; tupdesc = RelationGetDescr(rel); values[AttrNumberGetAttrOffset(Anum_bgw_policy_chunk_stats_job_id)] = Int32GetDatum(chunk_stats->fd.job_id); values[AttrNumberGetAttrOffset(Anum_bgw_policy_chunk_stats_chunk_id)] = Int32GetDatum(chunk_stats->fd.chunk_id); values[AttrNumberGetAttrOffset(Anum_bgw_policy_chunk_stats_num_times_job_run)] = Int32GetDatum(chunk_stats->fd.num_times_job_run); values[AttrNumberGetAttrOffset(Anum_bgw_policy_chunk_stats_last_time_job_run)] = TimestampTzGetDatum(chunk_stats->fd.last_time_job_run); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, tupdesc, values, nulls); ts_catalog_restore_user(&sec_ctx); } void ts_bgw_policy_chunk_stats_insert(BgwPolicyChunkStats *chunk_stats) { Catalog *catalog = ts_catalog_get(); Relation rel = table_open(catalog_get_table_id(catalog, BGW_POLICY_CHUNK_STATS), RowExclusiveLock); ts_bgw_policy_chunk_stats_insert_with_relation(rel, chunk_stats); table_close(rel, RowExclusiveLock); } BgwPolicyChunkStats * ts_bgw_policy_chunk_stats_find(int32 job_id, int32 chunk_id) { ScanKeyData scankeys[2]; BgwPolicyChunkStats *stats = NULL; ScanKeyInit(&scankeys[0], Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_job_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(job_id)); ScanKeyInit(&scankeys[1], Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); ts_catalog_scan_one(BGW_POLICY_CHUNK_STATS, BGW_POLICY_CHUNK_STATS_JOB_ID_CHUNK_ID_IDX, scankeys, 2, bgw_policy_chunk_stats_tuple_found, AccessShareLock, BGW_POLICY_CHUNK_STATS_TABLE_NAME, (void *) &stats); return stats; } static ScanTupleResult bgw_policy_chunk_stats_update_tuple_found(TupleInfo *ti, void *const data) { TimestampTz *updated_last_time_job_run = data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple = heap_copytuple(tuple); BgwPolicyChunkStats *chunk_stats = (BgwPolicyChunkStats *) GETSTRUCT(new_tuple); if (should_free) heap_freetuple(tuple); chunk_stats->fd.num_times_job_run++; chunk_stats->fd.last_time_job_run = *updated_last_time_job_run; ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); return SCAN_CONTINUE; } /* This function also increments num_times_job_run by 1. */ void ts_bgw_policy_chunk_stats_record_job_run(int32 job_id, int32 chunk_id, TimestampTz last_time_job_run) { bool updated; ScanKeyData scankeys[2]; ScanKeyInit(&scankeys[0], Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_job_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(job_id)); ScanKeyInit(&scankeys[1], Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); updated = ts_catalog_scan_one(BGW_POLICY_CHUNK_STATS, BGW_POLICY_CHUNK_STATS_JOB_ID_CHUNK_ID_IDX, scankeys, 2, bgw_policy_chunk_stats_update_tuple_found, RowExclusiveLock, BGW_POLICY_CHUNK_STATS_TABLE_NAME, &last_time_job_run); if (!updated) { BgwPolicyChunkStats new_stat = { .fd = { .job_id = job_id, .chunk_id = chunk_id, .num_times_job_run = 1, .last_time_job_run = last_time_job_run, }, }; ts_bgw_policy_chunk_stats_insert(&new_stat); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw_policy/chunk_stats.h�����������������������������������������������������0000664�0000000�0000000�00000001501�15100345067�0021474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "export.h" #include "ts_catalog/catalog.h" typedef struct BgwPolicyChunkStats { FormData_bgw_policy_chunk_stats fd; } BgwPolicyChunkStats; extern TSDLLEXPORT void ts_bgw_policy_chunk_stats_insert(BgwPolicyChunkStats *chunk_stats); extern BgwPolicyChunkStats *ts_bgw_policy_chunk_stats_find(int32 job_id, int32 chunk_id); extern void ts_bgw_policy_chunk_stats_delete_row_only_by_job_id(int32 job_id); extern void ts_bgw_policy_chunk_stats_delete_by_chunk_id(int32 chunk_id); extern TSDLLEXPORT void ts_bgw_policy_chunk_stats_record_job_run(int32 job_id, int32 chunk_id, TimestampTz last_time_job_run); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw_policy/policy.c����������������������������������������������������������0000664�0000000�0000000�00000001650�15100345067�0020445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <utils/builtins.h> #include "bgw/job.h" #include "policy.h" void ts_bgw_policy_delete_by_hypertable_id(int32 hypertable_id) { List *jobs; ListCell *lc; jobs = ts_bgw_job_find_by_hypertable_id(hypertable_id); foreach (lc, jobs) { BgwJob *job = lfirst(lc); ts_bgw_job_delete_by_id(job->fd.id); } } /* This function does NOT cascade deletes to the bgw_job table. */ ScanTupleResult ts_bgw_policy_delete_row_only_tuple_found(TupleInfo *ti, void *const data) { CatalogSecurityContext sec_ctx; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); return SCAN_CONTINUE; } ����������������������������������������������������������������������������������������timescaledb-2.23.0/src/bgw_policy/policy.h����������������������������������������������������������0000664�0000000�0000000�00000000725�15100345067�0020454�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "config.h" #include "export.h" #include "scanner.h" #include "ts_catalog/catalog.h" extern ScanTupleResult ts_bgw_policy_delete_row_only_tuple_found(TupleInfo *ti, void *const data); extern void ts_bgw_policy_delete_by_hypertable_id(int32 hypertable_id); �������������������������������������������timescaledb-2.23.0/src/build-defs.cmake�������������������������������������������������������������0000664�0000000�0000000�00000004215�15100345067�0017664�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Hide symbols by default in shared libraries if(NOT USE_DEFAULT_VISIBILITY) set(CMAKE_C_VISIBILITY_PRESET "hidden") endif() if(UNIX) set(CMAKE_C_STANDARD 11) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -L${PG_LIBDIR}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -L${PG_LIBDIR}") set(CMAKE_C_FLAGS "${PG_CFLAGS} ${PG_CPPFLAGS} ${CMAKE_C_FLAGS}") set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g") endif() if(APPLE) if((${PG_VERSION_MAJOR} GREATER_EQUAL "16")) set(CMAKE_SHARED_MODULE_SUFFIX ".dylib") endif() set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -multiply_defined suppress") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -multiply_defined suppress -Wl,-undefined,dynamic_lookup -bundle_loader ${PG_BINDIR}/postgres" ) elseif(WIN32) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO") endif() # PG_LDFLAGS can have strange values if not found, so we just add the flags if # they are defined. if(PG_LDFLAGS) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${PG_LDFLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${PG_LDFLAGS}") endif() if(APACHE_ONLY) add_definitions(-DAPACHE_ONLY) endif() include_directories(${PROJECT_SOURCE_DIR}/src ${PROJECT_BINARY_DIR}/src) include_directories(SYSTEM ${PG_INCLUDEDIR_SERVER}) # Only Windows and FreeBSD need the base include/ dir instead of # include/server/, and including both causes problems on Ubuntu where they # frequently get out of sync if(WIN32 OR (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")) include_directories(SYSTEM ${PG_INCLUDEDIR}) endif() if(WIN32) set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${PG_LIBDIR}/postgres.lib ws2_32.lib Version.lib" ) set(CMAKE_C_FLAGS "-D_CRT_SECURE_NO_WARNINGS") include_directories(SYSTEM ${PG_INCLUDEDIR_SERVER}/port/win32) if(MSVC) include_directories(SYSTEM ${PG_INCLUDEDIR_SERVER}/port/win32_msvc) endif(MSVC) endif(WIN32) # Name of library with test-specific code set(TESTS_LIB_NAME ${PROJECT_NAME}-tests) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/cache.c����������������������������������������������������������������������0000664�0000000�0000000�00000021003�15100345067�0016045�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <storage/ipc.h> #include "compat/compat.h" #include "cache.h" /* List of pinned caches. A cache occurs once in this list for every pin * taken */ static List *pinned_caches = NIL; static MemoryContext pinned_caches_mctx = NULL; typedef struct CachePin { Cache *cache; SubTransactionId subtxnid; } CachePin; static void cache_reset_pinned_caches(void) { if (NULL != pinned_caches_mctx) MemoryContextDelete(pinned_caches_mctx); pinned_caches_mctx = AllocSetContextCreate(CacheMemoryContext, "Cache pins", ALLOCSET_DEFAULT_SIZES); pinned_caches = NIL; } void ts_cache_init(Cache *cache) { if (cache->htab != NULL) { elog(ERROR, "cache %s is already initialized", cache->name); return; } /* * The cache object should have been created in its own context so that * cache_destroy can just delete the context to free everything. */ Assert(GetMemoryChunkContext(cache) == ts_cache_memory_ctx(cache)); /* * We always want to be explicit about the memory context our hash table * ends up in to ensure it's not accidentally put in TopMemoryContext. */ Assert(cache->flags & HASH_CONTEXT); cache->htab = hash_create(cache->name, cache->numelements, &cache->hctl, cache->flags); cache->refcount = 1; cache->handle_txn_callbacks = true; cache->release_on_commit = true; } static void cache_destroy(Cache **cache_ptr) { Cache *cache = *cache_ptr; if (cache == NULL) return; if (cache->refcount > 0) { /* will be destroyed later */ return; } if (cache->pre_destroy_hook != NULL) cache->pre_destroy_hook(cache); hash_destroy(cache->htab); MemoryContextDelete(cache->hctl.hcxt); *cache_ptr = NULL; } void ts_cache_invalidate(Cache **cache_ptr) { Cache *cache = *cache_ptr; if (cache == NULL) return; cache->refcount--; cache_destroy(cache_ptr); } /* * Pinning is needed if any items returned by the cache may need to survive * invalidation events (i.e. AcceptInvalidationMessages() may be called). * * Invalidation messages may be processed on any internal function that takes a * lock (e.g. table_open). * * Each call to cache_pin MUST BE paired with a call to cache_release. * */ Cache * ts_cache_pin(Cache *cache) { MemoryContext old = MemoryContextSwitchTo(pinned_caches_mctx); CachePin *cp = palloc(sizeof(CachePin)); cp->cache = cache; cp->subtxnid = GetCurrentSubTransactionId(); if (cache->handle_txn_callbacks) pinned_caches = lappend(pinned_caches, cp); MemoryContextSwitchTo(old); cache->refcount++; return cache; } static void remove_pin(Cache *cache, SubTransactionId subtxnid) { ListCell *lc; foreach (lc, pinned_caches) { CachePin *cp = lfirst(lc); if (cp->cache == cache && cp->subtxnid == subtxnid) { // free cache memory and then remove the pin cache_destroy(&cp->cache); pinned_caches = list_delete_cell(pinned_caches, lc); pfree(cp); return; } } /* should never reach here: there should always be a pin to remove */ Assert(false); } static int cache_release_subtxn(Cache **cache_ptr, SubTransactionId subtxnid) { Cache *cache = *cache_ptr; int refcount = cache->refcount - 1; Assert(cache->refcount > 0); cache->refcount--; if (cache->handle_txn_callbacks) { remove_pin(cache, subtxnid); } else { cache_destroy(cache_ptr); } return refcount; } int ts_cache_release(Cache **cache) { return cache_release_subtxn(cache, GetCurrentSubTransactionId()); } MemoryContext ts_cache_memory_ctx(Cache *cache) { return cache->hctl.hcxt; } void * ts_cache_fetch(Cache *cache, CacheQuery *query) { HASHACTION action; bool found; if (cache->htab == NULL || cache->valid_result == NULL) elog(ERROR, "cache \"%s\" is not initialized", cache->name); if (query->flags & CACHE_FLAG_NOCREATE) action = HASH_FIND; else if (cache->create_entry == NULL) elog(ERROR, "cache \"%s\" does not support creating new entries", cache->name); else action = HASH_ENTER; query->result = hash_search(cache->htab, cache->get_key(query), action, &found); if (found) { cache->stats.hits++; if (cache->update_entry != NULL) query->result = cache->update_entry(cache, query); } else { cache->stats.misses++; if (action == HASH_ENTER) { cache->stats.numelements++; query->result = cache->create_entry(cache, query); } } if (!(query->flags & CACHE_FLAG_MISSING_OK) && !cache->valid_result(query->result)) { if (cache->missing_error != NULL) cache->missing_error(cache, query); else elog(ERROR, "failed to find entry in cache \"%s\"", cache->name); } return query->result; } static void release_all_pinned_caches() { ListCell *lc; /* * release once for every occurrence of a cache in the pinned caches list. * On abort, release irrespective of cache->release_on_commit. */ foreach (lc, pinned_caches) { CachePin *cp = lfirst(lc); cp->cache->refcount--; cache_destroy(&cp->cache); } cache_reset_pinned_caches(); } static void release_subtxn_pinned_caches(SubTransactionId subtxnid, bool abort) { ListCell *lc; /* * Need a copy because cache_release will modify pinned_caches. * * This needs to be allocated in pinned cache memory context. * Otherwise leaks ensue if CurTransactionContext (which is the * CurrentMemoryContext) gets used! */ MemoryContext old = MemoryContextSwitchTo(pinned_caches_mctx); List *pinned_caches_copy = list_copy(pinned_caches); MemoryContextSwitchTo(old); /* Only release caches created in subtxn */ foreach (lc, pinned_caches_copy) { CachePin *cp = lfirst(lc); if (cp->subtxnid == subtxnid && cp->cache) { /* * This assert makes sure that that we don't have a cache leak * when running with debugging */ Assert(abort); cache_release_subtxn(&cp->cache, subtxnid); } } list_free(pinned_caches_copy); } /* * Transaction end callback that cleans up any pinned caches. This is a * safeguard that protects against indefinitely pinned caches (memory leaks) * that may occur if a transaction ends (normally or abnormally) while a pin is * held. Without this, a ts_cache_pin() call always needs to be paired with a * ts_cache_release() call and wrapped in a PG_TRY() block to capture and handle * any exceptions that occur. * * Note that this checks that ts_cache_release() is always called by the end * of a non-aborted transaction unless cache->release_on_commit is set to true. * */ static void cache_xact_end(XactEvent event, void *arg) { switch (event) { case XACT_EVENT_ABORT: case XACT_EVENT_PARALLEL_ABORT: release_all_pinned_caches(); break; default: { /* * Make a copy of the list of pinned caches since * ts_cache_release() can manipulate the original list. */ List *pinned_caches_copy = list_copy(pinned_caches); ListCell *lc; /* * Only caches left should be marked as non-released */ foreach (lc, pinned_caches_copy) { CachePin *cp = lfirst(lc); /* * This assert makes sure that that we don't have a cache * leak when running with debugging */ Assert(!cp->cache->release_on_commit); /* * This may still happen in optimized environments where * Assert is turned off. In that case, release. */ if (cp->cache->release_on_commit) ts_cache_release(&cp->cache); } list_free(pinned_caches_copy); } break; } } static void cache_subxact_abort(SubXactEvent event, SubTransactionId subtxn_id, SubTransactionId parentSubid, void *arg) { /* * Note that cache->release_on_commit is irrelevant here since can't have * cross-commit operations in subtxns */ /* * In subtxns, caches should have already been released, unless an abort * happened. Be careful to only release caches that were created in the * same subtxn. */ switch (event) { case SUBXACT_EVENT_START_SUB: case SUBXACT_EVENT_PRE_COMMIT_SUB: /* do nothing */ break; case SUBXACT_EVENT_COMMIT_SUB: release_subtxn_pinned_caches(subtxn_id, false); break; case SUBXACT_EVENT_ABORT_SUB: release_subtxn_pinned_caches(subtxn_id, true); break; } } void _cache_init(void) { cache_reset_pinned_caches(); RegisterXactCallback(cache_xact_end, NULL); RegisterSubXactCallback(cache_subxact_abort, NULL); } void _cache_fini(void) { release_all_pinned_caches(); MemoryContextDelete(pinned_caches_mctx); pinned_caches_mctx = NULL; pinned_caches = NIL; UnregisterXactCallback(cache_xact_end, NULL); UnregisterSubXactCallback(cache_subxact_abort, NULL); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/cache.h����������������������������������������������������������������������0000664�0000000�0000000�00000003617�15100345067�0016065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/hsearch.h> #include <utils/memutils.h> #include "export.h" typedef enum CacheQueryFlags { CACHE_FLAG_NONE = 0, CACHE_FLAG_MISSING_OK = 1 << 0, CACHE_FLAG_NOCREATE = 1 << 1, } CacheQueryFlags; #define CACHE_FLAG_CHECK (CACHE_FLAG_MISSING_OK | CACHE_FLAG_NOCREATE) typedef struct CacheQuery { /* CacheQueryFlags as defined above */ const unsigned int flags; void *result; void *data; } CacheQuery; typedef struct CacheStats { long numelements; uint64 hits; uint64 misses; } CacheStats; typedef struct Cache { HASHCTL hctl; HTAB *htab; int refcount; const char *name; long numelements; int flags; CacheStats stats; void *(*get_key)(struct CacheQuery *); void *(*create_entry)(struct Cache *, CacheQuery *); void *(*update_entry)(struct Cache *, CacheQuery *); void (*missing_error)(const struct Cache *, const CacheQuery *); bool (*valid_result)(const void *); void (*remove_entry)(void *entry); void (*pre_destroy_hook)(struct Cache *); bool handle_txn_callbacks; /* Auto-release caches on (sub)txn * aborts and commits. Should be off * if cache used in txn callbacks */ bool release_on_commit; /* This should be false if doing * cross-commit operations like CLUSTER or * VACUUM */ } Cache; extern TSDLLEXPORT void ts_cache_init(Cache *cache); extern TSDLLEXPORT void ts_cache_invalidate(Cache **cache_ptr); extern TSDLLEXPORT void *ts_cache_fetch(Cache *cache, CacheQuery *query); extern TSDLLEXPORT MemoryContext ts_cache_memory_ctx(Cache *cache); extern TSDLLEXPORT Cache *ts_cache_pin(Cache *cache); extern TSDLLEXPORT int ts_cache_release(Cache **cache_ptr); extern void _cache_init(void); extern void _cache_fini(void); �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/cache_invalidate.c�����������������������������������������������������������0000664�0000000�0000000�00000012064�15100345067�0020254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/namespace.h> #include <miscadmin.h> #include <nodes/nodes.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include "compat/compat.h" #include "annotations.h" #include "extension.h" #include "hypertable_cache.h" #include "ts_catalog/catalog.h" #include "bgw/scheduler.h" #include "cache_invalidate.h" #include "cross_module_fn.h" /* * Notes on the way cache invalidation works. * * Since our caches are stored in per-process (per-backend memory), we need a * way to signal all backends that they should invalidate their caches. For this * we use the PostgreSQL relcache mechanism that propagates relation cache * invalidation events to all backends. We register a callback with this * mechanism to receive events on all backends whenever a relation cache entry * is invalidated. * * To know which events should trigger invalidation of our caches, we use dummy * (empty) tables. We can trigger relcache invalidation events for these tables * to signal other backends. If the received table OID is a dummy table, we know * that this is an event that we care about. * * Caches for catalog tables should be invalidated on: * * 1. INSERT/UPDATE/DELETE on a catalog table * 2. Aborted transactions that taint the caches * * Generally, INSERTS do not warrant cache invalidation, unless it is an insert * of a subobject that belongs to an object that might already be in the cache * (e.g., a new dimension of a hypertable), or when replacing an existing entry * (e.g., when replacing a negative hypertable entry with a positive one). Note, * also, that INSERTS can taint the cache if the transaction that did the INSERT * fails. This is why we also need to invalidate caches on transaction failure. */ void _cache_invalidate_init(void); void _cache_invalidate_fini(void); static inline void cache_invalidate_relcache_all(void) { ts_hypertable_cache_invalidate_callback(); ts_bgw_job_cache_invalidate_callback(); } static Oid hypertable_proxy_table_oid = InvalidOid; static Oid bgw_proxy_table_oid = InvalidOid; void ts_cache_invalidate_set_proxy_tables(Oid hypertable_proxy_oid, Oid bgw_proxy_oid) { hypertable_proxy_table_oid = hypertable_proxy_oid; bgw_proxy_table_oid = bgw_proxy_oid; } /* * This function is called when any relcache is invalidated. * Should route the invalidation to the correct cache. * * NOTE that the callback should not call any functions that could invoke the * relcache or syscache to query information during the invalidation. That * might lead to bad things happening. */ static void cache_invalidate_relcache_callback(Datum arg, Oid relid) { if (!OidIsValid(relid)) { cache_invalidate_relcache_all(); } else if (ts_extension_is_proxy_table_relid(relid)) { ts_extension_invalidate(); cache_invalidate_relcache_all(); ts_cache_invalidate_set_proxy_tables(InvalidOid, InvalidOid); } else if (relid == hypertable_proxy_table_oid) { ts_hypertable_cache_invalidate_callback(); } else if (relid == bgw_proxy_table_oid) { ts_bgw_job_cache_invalidate_callback(); } } TS_FUNCTION_INFO_V1(ts_timescaledb_invalidate_cache); /* * Force a cache invalidation for a catalog table. * * This function is used for debugging purposes and triggers a cache * invalidation. * * The first argument should be the catalog table that has changed, warranting a * cache invalidation. */ Datum ts_timescaledb_invalidate_cache(PG_FUNCTION_ARGS) { ts_catalog_invalidate_cache(PG_GETARG_OID(0), CMD_UPDATE); PG_RETURN_VOID(); } static void cache_invalidate_xact_end(XactEvent event, void *arg) { switch (event) { case XACT_EVENT_ABORT: case XACT_EVENT_PARALLEL_ABORT: /* * Invalidate caches on aborted transactions to purge entries that * have been added during the transaction and are now no longer * valid. Note that we need not signal other backends of this * change since the transaction hasn't been committed and other * backends cannot have the invalid state. */ cache_invalidate_relcache_all(); break; default: break; } } static void cache_invalidate_subxact_end(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg) { switch (event) { case SUBXACT_EVENT_ABORT_SUB: /* * Invalidate caches on aborted sub transactions. See notes above * in cache_invalidate_xact_end. */ cache_invalidate_relcache_all(); break; default: break; } } void _cache_invalidate_init(void) { RegisterXactCallback(cache_invalidate_xact_end, NULL); RegisterSubXactCallback(cache_invalidate_subxact_end, NULL); CacheRegisterRelcacheCallback(cache_invalidate_relcache_callback, PointerGetDatum(NULL)); } void _cache_invalidate_fini(void) { UnregisterXactCallback(cache_invalidate_xact_end, NULL); UnregisterSubXactCallback(cache_invalidate_subxact_end, NULL); /* No way to unregister relcache callback */ } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/cache_invalidate.h�����������������������������������������������������������0000664�0000000�0000000�00000000501�15100345067�0020252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> extern void ts_cache_invalidate_set_proxy_tables(Oid hypertable_proxy_oid, Oid bgw_proxy_oid); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk.c����������������������������������������������������������������������0000664�0000000�0000000�00000501113�15100345067�0016117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup.h> #include <access/htup_details.h> #include <access/reloptions.h> #include <access/table.h> #include <access/tableam.h> #include <access/tupdesc.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/pg_class.h> #include <catalog/pg_constraint.h> #include <catalog/pg_inherits.h> #include <catalog/pg_opfamily.h> #include <catalog/pg_trigger.h> #include <catalog/pg_type.h> #include <catalog/pg_type_d.h> #include <catalog/toasting.h> #include <commands/defrem.h> #include <commands/tablecmds.h> #include <commands/trigger.h> #include <executor/executor.h> #include <fmgr.h> #include <foreign/fdwapi.h> #include <funcapi.h> #include <miscadmin.h> #include <nodes/execnodes.h> #include <nodes/lockoptions.h> #include <nodes/makefuncs.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <tcop/tcopprot.h> #include <utils/acl.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/elog.h> #include <utils/hsearch.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/palloc.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include <utils/typcache.h> #include "chunk.h" #include "compat/compat.h" #include "bgw_policy/chunk_stats.h" #include "cache.h" #include "chunk_index.h" #include "cross_module_fn.h" #include "debug_assert.h" #include "debug_point.h" #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "errors.h" #include "foreign_key.h" #include "hypercube.h" #include "hypertable.h" #include "hypertable_cache.h" #include "osm_callbacks.h" #include "process_utility.h" #include "scan_iterator.h" #include "scanner.h" #include "time_utils.h" #include "trigger.h" #include "ts_catalog/catalog.h" #include "ts_catalog/chunk_column_stats.h" #include "ts_catalog/compression_chunk_size.h" #include "ts_catalog/compression_settings.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/continuous_aggs_watermark.h" #include "utils.h" TS_FUNCTION_INFO_V1(ts_chunk_show_chunks); TS_FUNCTION_INFO_V1(ts_chunk_drop_chunks); TS_FUNCTION_INFO_V1(ts_chunk_drop_single_chunk); TS_FUNCTION_INFO_V1(ts_chunk_attach_osm_table_chunk); TS_FUNCTION_INFO_V1(ts_chunk_drop_osm_chunk); TS_FUNCTION_INFO_V1(ts_chunk_id_from_relid); TS_FUNCTION_INFO_V1(ts_chunk_show); TS_FUNCTION_INFO_V1(ts_chunk_create); TS_FUNCTION_INFO_V1(ts_chunk_status); static bool ts_chunk_add_status(Chunk *chunk, int32 status); static const char * DatumGetNameString(Datum datum) { Name name = DatumGetName(datum); return pstrdup(NameStr(*name)); } /* Used when processing scanned chunks */ typedef enum ChunkResult { CHUNK_DONE, CHUNK_IGNORED, CHUNK_PROCESSED } ChunkResult; /* * Context for scanning and building a chunk from a stub. * * If found, the chunk will be created and the chunk pointer member is set in * the result. Optionally, a caller can pre-allocate the chunk member's memory, * which is useful if one, e.g., wants to fill in an memory-aligned array of * chunks. * * If the chunk is a tombstone (dropped flag set), then the Chunk will not be * created and instead is_dropped will be TRUE. */ typedef struct ChunkStubScanCtx { ChunkStub *stub; Chunk *chunk; LOCKMODE chunk_lockmode; const ScanTupLock *slice_lock; bool is_dropped; } ChunkStubScanCtx; static bool chunk_stub_is_valid(const ChunkStub *stub, int16 expected_slices) { return stub && stub->id > 0 && stub->constraints && expected_slices == stub->cube->num_slices && stub->cube->num_slices == stub->constraints->num_dimension_constraints; } typedef ChunkResult (*on_chunk_stub_func)(ChunkScanCtx *ctx, ChunkStub *stub); static void chunk_scan_ctx_init(ChunkScanCtx *ctx, const Hypertable *ht, const Point *point); static void chunk_scan_ctx_destroy(ChunkScanCtx *ctx); static void chunk_collision_scan(ChunkScanCtx *scanctx, const Hypercube *cube); static int chunk_scan_ctx_foreach_chunk_stub(ChunkScanCtx *ctx, on_chunk_stub_func on_chunk, uint64 limit); static Datum show_chunks_return_srf(FunctionCallInfo fcinfo); static int chunk_cmp(const void *ch1, const void *ch2); static void init_scan_by_qualified_table_name(ScanIterator *iterator, const char *schema_name, const char *table_name); static Chunk *get_chunks_in_time_range(Hypertable *ht, int64 older_than, int64 newer_than, MemoryContext mctx, uint64 *num_chunks_returned, ScanTupLock *tuplock); static Chunk *chunk_resurrect(const Hypertable *ht, int chunk_id); static Chunk *get_chunks_in_creation_time_range(Hypertable *ht, int64 older_than, int64 newer_than, MemoryContext mctx, uint64 *num_chunks_returned, ScanTupLock *tupLock); static HeapTuple chunk_formdata_make_tuple(const FormData_chunk *fd, TupleDesc desc) { Datum values[Natts_chunk]; bool nulls[Natts_chunk] = { false }; memset(values, 0, sizeof(Datum) * Natts_chunk); values[AttrNumberGetAttrOffset(Anum_chunk_id)] = Int32GetDatum(fd->id); values[AttrNumberGetAttrOffset(Anum_chunk_hypertable_id)] = Int32GetDatum(fd->hypertable_id); values[AttrNumberGetAttrOffset(Anum_chunk_schema_name)] = NameGetDatum(&fd->schema_name); values[AttrNumberGetAttrOffset(Anum_chunk_table_name)] = NameGetDatum(&fd->table_name); /*when we insert a chunk the compressed chunk id is always NULL */ if (fd->compressed_chunk_id == INVALID_CHUNK_ID) nulls[AttrNumberGetAttrOffset(Anum_chunk_compressed_chunk_id)] = true; else { values[AttrNumberGetAttrOffset(Anum_chunk_compressed_chunk_id)] = Int32GetDatum(fd->compressed_chunk_id); } values[AttrNumberGetAttrOffset(Anum_chunk_dropped)] = BoolGetDatum(fd->dropped); values[AttrNumberGetAttrOffset(Anum_chunk_status)] = Int32GetDatum(fd->status); values[AttrNumberGetAttrOffset(Anum_chunk_osm_chunk)] = BoolGetDatum(fd->osm_chunk); values[AttrNumberGetAttrOffset(Anum_chunk_creation_time)] = Int64GetDatum(fd->creation_time); return heap_form_tuple(desc, values, nulls); } void ts_chunk_formdata_fill(FormData_chunk *fd, const TupleInfo *ti) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); bool nulls[Natts_chunk]; Datum values[Natts_chunk]; memset(fd, 0, sizeof(FormData_chunk)); heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_id)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_hypertable_id)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_schema_name)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_table_name)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_dropped)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_status)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_osm_chunk)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_chunk_creation_time)]); fd->id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_id)]); fd->hypertable_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_hypertable_id)]); namestrcpy(&fd->schema_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_chunk_schema_name)])); namestrcpy(&fd->table_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_chunk_table_name)])); if (nulls[AttrNumberGetAttrOffset(Anum_chunk_compressed_chunk_id)]) fd->compressed_chunk_id = INVALID_CHUNK_ID; else fd->compressed_chunk_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_compressed_chunk_id)]); fd->dropped = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_chunk_dropped)]); fd->status = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_status)]); fd->osm_chunk = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_chunk_osm_chunk)]); fd->creation_time = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_chunk_creation_time)]); if (should_free) heap_freetuple(tuple); } int64 ts_chunk_primary_dimension_start(const Chunk *chunk) { return chunk->cube->slices[0]->fd.range_start; } int64 ts_chunk_primary_dimension_end(const Chunk *chunk) { return chunk->cube->slices[0]->fd.range_end; } static void chunk_insert_relation(Relation rel, const Chunk *chunk) { HeapTuple new_tuple; CatalogSecurityContext sec_ctx; new_tuple = chunk_formdata_make_tuple(&chunk->fd, RelationGetDescr(rel)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert(rel, new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); } void ts_chunk_insert_lock(const Chunk *chunk, LOCKMODE lock) { Catalog *catalog = ts_catalog_get(); Relation rel; rel = table_open(catalog_get_table_id(catalog, CHUNK), lock); chunk_insert_relation(rel, chunk); table_close(rel, lock); } typedef struct CollisionInfo { Hypercube *cube; ChunkStub *colliding_chunk; } CollisionInfo; /*- * Align a chunk's hypercube in 'aligned' dimensions. * * Alignment ensures that chunks line up in a particular dimension, i.e., their * ranges should either be identical or not overlap at all. * * Non-aligned: * * ' [---------] <- existing slice * ' [---------] <- calculated (new) slice * * To align the slices above there are two cases depending on where the * insertion point happens: * * Case 1 (reuse slice): * * ' [---------] * ' [--x------] * * The insertion point x falls within the range of the existing slice. We should * reuse the existing slice rather than creating a new one. * * Case 2 (cut to align): * * ' [---------] * ' [-------x-] * * The insertion point falls outside the range of the existing slice and we need * to cut the new slice to line up. * * ' [---------] * ' cut [---] * ' * * Note that slice reuse (case 1) happens already when calculating the tentative * hypercube for the chunk, and is thus already performed once reaching this * function. Thus, we deal only with case 2 here. Also note that a new slice * might overlap in complicated ways, requiring multiple cuts. For instance, * consider the following situation: * * ' [------] [-] [---] * ' [---x-------] <- calculated slice * * This should but cut-to-align as follows: * * ' [------] [-] [---] * ' [x] * * After a chunk collision scan, this function is called for each chunk in the * chunk scan context. Chunks in the scan context may have only a partial set of * slices if they only overlap in some, but not all, dimensions (see * illustrations below). Still, partial chunks may still be of interest for * alignment in a particular dimension. Thus, if a chunk has an overlapping * slice in an aligned dimension, we cut to not overlap with that slice. */ static ChunkResult do_dimension_alignment(ChunkScanCtx *scanctx, ChunkStub *stub) { CollisionInfo *info = scanctx->data; Hypercube *cube = info->cube; const Hyperspace *space = scanctx->ht->space; ChunkResult res = CHUNK_IGNORED; int i; for (i = 0; i < space->num_dimensions; i++) { const Dimension *dim = &space->dimensions[i]; const DimensionSlice *chunk_slice; DimensionSlice *cube_slice; int64 coord = scanctx->point->coordinates[i]; if (!dim->fd.aligned) continue; /* * The stub might not have a slice for each dimension, so we cannot * use array indexing. Fetch slice by dimension ID instead. */ chunk_slice = ts_hypercube_get_slice_by_dimension_id(stub->cube, dim->fd.id); if (NULL == chunk_slice) continue; cube_slice = cube->slices[i]; /* * Only cut-to-align if the slices collide and are not identical * (i.e., if we are reusing an existing slice we should not cut it) */ if (!ts_dimension_slices_equal(cube_slice, chunk_slice) && ts_dimension_slices_collide(cube_slice, chunk_slice)) { ts_dimension_slice_cut(cube_slice, chunk_slice, coord); res = CHUNK_PROCESSED; } } return res; } /* * Calculate, and potentially set, a new chunk interval for an open dimension. */ static bool calculate_and_set_new_chunk_interval(const Hypertable *ht, const Point *p) { Hyperspace *hs = ht->space; Dimension *dim = NULL; Datum datum; int64 chunk_interval, coord; int i; if (!OidIsValid(ht->chunk_sizing_func) || ht->fd.chunk_target_size <= 0) return false; /* Find first open dimension */ for (i = 0; i < hs->num_dimensions; i++) { dim = &hs->dimensions[i]; if (IS_OPEN_DIMENSION(dim)) break; dim = NULL; } /* Nothing to do if no open dimension */ if (NULL == dim) { elog(WARNING, "adaptive chunking enabled on hypertable \"%s\" without an open (time) dimension", get_rel_name(ht->main_table_relid)); return false; } coord = p->coordinates[i]; datum = OidFunctionCall3(ht->chunk_sizing_func, Int32GetDatum(dim->fd.id), Int64GetDatum(coord), Int64GetDatum(ht->fd.chunk_target_size)); chunk_interval = DatumGetInt64(datum); /* Check if the function didn't set and interval or nothing changed */ if (chunk_interval <= 0 || chunk_interval == dim->fd.interval_length) return false; /* Update the dimension */ ts_dimension_set_chunk_interval(dim, chunk_interval); return true; } /* * Resolve chunk collisions. * * After a chunk collision scan, this function is called for each chunk in the * chunk scan context. We only care about chunks that have a full set of * slices/constraints that overlap with our tentative hypercube, i.e., they * fully collide. We resolve those collisions by cutting the hypercube. */ static ChunkResult do_collision_resolution(ChunkScanCtx *scanctx, ChunkStub *stub) { CollisionInfo *info = scanctx->data; Hypercube *cube = info->cube; const Hyperspace *space = scanctx->ht->space; ChunkResult res = CHUNK_IGNORED; int i; if (stub->cube->num_slices != space->num_dimensions || !ts_hypercubes_collide(cube, stub->cube)) return CHUNK_IGNORED; for (i = 0; i < space->num_dimensions; i++) { DimensionSlice *cube_slice = cube->slices[i]; DimensionSlice *chunk_slice = stub->cube->slices[i]; int64 coord = scanctx->point->coordinates[i]; /* * Only cut if we aren't reusing an existing slice and there is a * collision */ if (!ts_dimension_slices_equal(cube_slice, chunk_slice) && ts_dimension_slices_collide(cube_slice, chunk_slice)) { ts_dimension_slice_cut(cube_slice, chunk_slice, coord); res = CHUNK_PROCESSED; /* * Redo the collision check after each cut since cutting in one * dimension might have resolved the collision in another */ if (!ts_hypercubes_collide(cube, stub->cube)) return res; } } Assert(!ts_hypercubes_collide(cube, stub->cube)); return res; } static ChunkResult check_for_collisions(ChunkScanCtx *scanctx, ChunkStub *stub) { CollisionInfo *info = scanctx->data; Hypercube *cube = info->cube; const Hyperspace *space = scanctx->ht->space; /* Check if this chunk collides with our hypercube */ if (stub->cube->num_slices == space->num_dimensions && ts_hypercubes_collide(cube, stub->cube)) { info->colliding_chunk = stub; return CHUNK_DONE; } return CHUNK_IGNORED; } /* * Check if a (tentative) chunk collides with existing chunks. * * Return the colliding chunk. Note that the chunk is a stub and not a full * chunk. */ static ChunkStub * chunk_collides(const Hypertable *ht, const Hypercube *hc) { ChunkScanCtx scanctx; CollisionInfo info = { .cube = (Hypercube *) hc, .colliding_chunk = NULL, }; chunk_scan_ctx_init(&scanctx, ht, NULL); /* Scan for all chunks that collide with the hypercube of the new chunk */ chunk_collision_scan(&scanctx, hc); scanctx.data = &info; /* Find chunks that collide */ chunk_scan_ctx_foreach_chunk_stub(&scanctx, check_for_collisions, 0); chunk_scan_ctx_destroy(&scanctx); return info.colliding_chunk; } /*- * Resolve collisions and perform alignment. * * Chunks collide only if their hypercubes overlap in all dimensions. For * instance, the 2D chunks below collide because they overlap in both the X and * Y dimensions: * * ' _____ * ' | | * ' | ___|__ * ' |_|__| | * ' | | * ' |_____| * * While the following chunks do not collide, although they still overlap in the * X dimension: * * ' _____ * ' | | * ' | | * ' |____| * ' ______ * ' | | * ' | *| * ' |_____| * * For the collision case above we obviously want to cut our hypercube to no * longer collide with existing chunks. However, the second case might still be * of interest for alignment in case X is an 'aligned' dimension. If '*' is the * insertion point, then we still want to cut the hypercube to ensure that the * dimension remains aligned, like so: * * ' _____ * ' | | * ' | | * ' |____| * ' ___ * ' | | * ' |*| * ' |_| * * * We perform alignment first as that might actually resolve chunk * collisions. After alignment we check for any remaining collisions. */ static void chunk_collision_resolve(const Hypertable *ht, Hypercube *cube, const Point *p) { ChunkScanCtx scanctx; CollisionInfo info = { .cube = cube, .colliding_chunk = NULL, }; chunk_scan_ctx_init(&scanctx, ht, p); /* Scan for all chunks that collide with the hypercube of the new chunk */ chunk_collision_scan(&scanctx, cube); scanctx.data = &info; /* Cut the hypercube in any aligned dimensions */ chunk_scan_ctx_foreach_chunk_stub(&scanctx, do_dimension_alignment, 0); /* * If there are any remaining collisions with chunks, then cut-to-fit to * resolve those collisions */ chunk_scan_ctx_foreach_chunk_stub(&scanctx, do_collision_resolution, 0); chunk_scan_ctx_destroy(&scanctx); } static int chunk_add_constraints(const Chunk *chunk) { int num_added; num_added = ts_chunk_constraints_add_dimension_constraints(chunk->constraints, chunk->fd.id, chunk->cube); num_added += ts_chunk_constraints_add_inheritable_constraints(chunk->constraints, chunk->fd.id, chunk->relkind, chunk->hypertable_relid, chunk->table_id); return num_added; } /* applies the attributes and statistics target for columns on the hypertable to columns on the chunk */ static void set_attoptions(Relation ht_rel, Oid chunk_oid) { TupleDesc tupleDesc = RelationGetDescr(ht_rel); int natts = tupleDesc->natts; int attno; List *alter_cmds = NIL; for (attno = 1; attno <= natts; attno++) { Form_pg_attribute attribute = TupleDescAttr(tupleDesc, attno - 1); char *attributeName = NameStr(attribute->attname); HeapTuple tuple; Datum options; bool isnull; /* Ignore dropped */ if (attribute->attisdropped) continue; tuple = SearchSysCacheAttName(RelationGetRelid(ht_rel), attributeName); Assert(tuple != NULL); /* * Pass down the attribute options (ALTER TABLE ALTER COLUMN SET * attribute_option) */ options = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions, &isnull); if (!isnull) { AlterTableCmd *cmd = makeNode(AlterTableCmd); cmd->subtype = AT_SetOptions; cmd->name = attributeName; cmd->def = (Node *) untransformRelOptions(options); alter_cmds = lappend(alter_cmds, cmd); } /* * Pass down the attribute options (ALTER TABLE ALTER COLUMN SET * STATISTICS) */ options = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attstattarget, &isnull); if (!isnull) { int32 target = DatumGetInt32(options); /* Don't do anything if it's set to the default */ if (target != -1) { AlterTableCmd *cmd = makeNode(AlterTableCmd); cmd->subtype = AT_SetStatistics; cmd->name = attributeName; cmd->def = (Node *) makeInteger(target); alter_cmds = lappend(alter_cmds, cmd); } } ReleaseSysCache(tuple); } if (alter_cmds != NIL) { AlterTableInternal(chunk_oid, alter_cmds, false); list_free_deep(alter_cmds); } } static void create_toast_table(CreateStmt *stmt, Oid chunk_oid) { /* similar to tcop/utility.c */ #if PG18_LT char *validnsps[] = HEAP_RELOPT_NAMESPACES; #else const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; #endif Datum toast_options = transformRelOptions((Datum) 0, stmt->options, "toast", validnsps, true, false); (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); NewRelationCreateToastTable(chunk_oid, toast_options); } static void copy_hypertable_acl_to_relid(const Hypertable *ht, const Oid owner_id, const Oid relid) { ts_copy_relation_acl(ht->main_table_relid, relid, owner_id); } /* * Create a chunk's table. * * A chunk inherits from the main hypertable and will have the same owner. Since * chunks can be created either in the TimescaleDB internal schema or in a * user-specified schema, some care has to be taken to use the right * permissions, depending on the case: * * 1. if the chunk is created in the internal schema, we create it as the * catalog/schema owner (i.e., anyone can create chunks there via inserting into * a hypertable, but can not do it via CREATE TABLE). * * 2. if the chunk is created in a user-specified "associated schema", then we * shouldn't use the catalog owner to create the table since that typically * implies super-user permissions. If we would allow that, anyone can specify * someone else's schema in create_hypertable() and create chunks in it without * having the proper permissions to do so. With this logic, the hypertable owner * must have permissions to create tables in the associated schema, or else * table creation will fail. If the schema doesn't yet exist, the table owner * instead needs the proper permissions on the database to create the schema. */ Oid ts_chunk_create_table(const Chunk *chunk, const Hypertable *ht, const char *tablespacename) { Relation rel; ObjectAddress address; int sec_ctx; char *amname = NULL; amname = get_am_name(ts_get_rel_am(chunk->hypertable_relid)); /* * CreateStmt node to create the chunk table */ CreateStmt stmt = { .type = T_CreateStmt, .relation = makeRangeVar((char *) NameStr(chunk->fd.schema_name), (char *) NameStr(chunk->fd.table_name), 0), .inhRelations = list_make1(makeRangeVar((char *) NameStr(ht->fd.schema_name), (char *) NameStr(ht->fd.table_name), 0)), .tablespacename = tablespacename ? (char *) tablespacename : NULL, .options = (chunk->relkind == RELKIND_RELATION) ? ts_get_reloptions(ht->main_table_relid) : NIL, .accessMethod = amname, }; Oid uid, saved_uid; Assert(chunk->hypertable_relid == ht->main_table_relid); rel = table_open(ht->main_table_relid, AccessShareLock); /* Inherit the persistence (LOGGED or UNLOGGED) from the parent hypertable */ stmt.relation->relpersistence = rel->rd_rel->relpersistence; /* * If the chunk is created in the internal schema, become the catalog * owner, otherwise become the hypertable owner */ if (namestrcmp((Name) &chunk->fd.schema_name, INTERNAL_SCHEMA_NAME) == 0) uid = ts_catalog_database_info_get()->owner_uid; else uid = rel->rd_rel->relowner; GetUserIdAndSecContext(&saved_uid, &sec_ctx); if (uid != saved_uid) SetUserIdAndSecContext(uid, sec_ctx | SECURITY_LOCAL_USERID_CHANGE); /* Prepare event trigger state and invoke ddl_command_start triggers */ if (ts_guc_enable_event_triggers) { EventTriggerBeginCompleteQuery(); EventTriggerDDLCommandStart((Node *) &stmt); } address = DefineRelation(&stmt, chunk->relkind, rel->rd_rel->relowner, NULL, NULL); /* Invoke ddl_command_end triggers and clean up the event trigger state */ if (ts_guc_enable_event_triggers) { EventTriggerCollectSimpleCommand(address, InvalidObjectAddress, (Node *) &stmt); EventTriggerDDLCommandEnd((Node *) &stmt); EventTriggerEndCompleteQuery(); } /* Make the newly defined relation visible so that we can update the * ACL. */ CommandCounterIncrement(); /* Copy acl from hypertable to chunk relation record */ copy_hypertable_acl_to_relid(ht, rel->rd_rel->relowner, address.objectId); if (chunk->relkind == RELKIND_RELATION) { /* * need to create a toast table explicitly for some of the option * setting to work */ create_toast_table(&stmt, address.objectId); /* * Some options require being table owner to set for example statistics * so we have to set them before restoring security context */ set_attoptions(rel, address.objectId); if (uid != saved_uid) SetUserIdAndSecContext(saved_uid, sec_ctx); } else elog(ERROR, "invalid relkind \"%c\" when creating chunk", chunk->relkind); table_close(rel, AccessShareLock); return address.objectId; } static int32 get_next_chunk_id() { int32 chunk_id; CatalogSecurityContext sec_ctx; const Catalog *catalog = ts_catalog_get(); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); chunk_id = ts_catalog_table_next_seq_id(catalog, CHUNK); ts_catalog_restore_user(&sec_ctx); return chunk_id; } /* * Create a chunk object from the dimensional constraints in the given hypercube. * * The chunk object is then used to create the actual chunk table and update the * metadata separately. * * The table name for the chunk can be given explicitly, or generated if * table_name is NULL. If the table name is generated, it will use the given * prefix or, if NULL, use the hypertable's associated table prefix. Similarly, * if schema_name is NULL it will use the hypertable's associated schema for * the chunk. */ static Chunk * chunk_create_object(const Hypertable *ht, Hypercube *cube, const char *schema_name, const char *table_name, const char *prefix, int32 chunk_id) { const Hyperspace *hs = ht->space; Chunk *chunk; const char relkind = RELKIND_RELATION; if (NULL == schema_name || schema_name[0] == '\0') schema_name = NameStr(ht->fd.associated_schema_name); /* Create a new chunk based on the hypercube */ chunk = ts_chunk_create_base(chunk_id, hs->num_dimensions, relkind); chunk->fd.hypertable_id = hs->hypertable_id; chunk->cube = cube; chunk->hypertable_relid = ht->main_table_relid; namestrcpy(&chunk->fd.schema_name, schema_name); if (NULL == table_name || table_name[0] == '\0') { int len; if (NULL == prefix) prefix = NameStr(ht->fd.associated_table_prefix); len = snprintf(NameStr(chunk->fd.table_name), NAMEDATALEN, "%s_%d_chunk", prefix, chunk->fd.id); if (len >= NAMEDATALEN) elog(ERROR, "chunk table name too long"); } else namestrcpy(&chunk->fd.table_name, table_name); return chunk; } static void chunk_insert_into_metadata_after_lock(const Chunk *chunk) { /* Insert chunk */ ts_chunk_insert_lock(chunk, RowExclusiveLock); /* Add metadata for dimensional and inheritable constraints */ ts_chunk_constraints_insert_metadata(chunk->constraints); } /* * Ensure the replica identity setting of a chunk matches that of the root * table. */ static void chunk_set_replica_identity(const Chunk *chunk) { Relation ht_rel = relation_open(chunk->hypertable_relid, AccessShareLock); Relation ch_rel = relation_open(chunk->table_id, AccessShareLock); /* Do nothing if REPLICA IDENTITY of hypertable and chunk are equal */ if (ht_rel->rd_rel->relreplident == ch_rel->rd_rel->relreplident) { table_close(ch_rel, NoLock); table_close(ht_rel, NoLock); return; } ReplicaIdentityStmt stmt = { .type = T_ReplicaIdentityStmt, .identity_type = ht_rel->rd_rel->relreplident, }; AlterTableCmd cmd = { .type = T_AlterTableCmd, .def = (Node *) &stmt, .subtype = AT_ReplicaIdentity, }; CatalogSecurityContext sec_ctx; if (stmt.identity_type == REPLICA_IDENTITY_INDEX) { /* Lookup the corresponding chunk index. If this index is * dropped, the behavior is the same as NOTHING (as per PG * documentation). */ Oid chunk_index_relid = ts_chunk_index_get_by_hypertable_indexrelid(ch_rel, ht_rel->rd_replidindex); if (OidIsValid(chunk_index_relid)) stmt.name = get_rel_name(chunk_index_relid); else stmt.identity_type = REPLICA_IDENTITY_NOTHING; } ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_alter_table_with_event_trigger(chunk->table_id, NULL, list_make1(&cmd), false); ts_catalog_restore_user(&sec_ctx); table_close(ch_rel, NoLock); table_close(ht_rel, NoLock); } static void chunk_create_table_constraints(const Hypertable *ht, const Chunk *chunk) { /* Create the chunk's constraints, triggers, and indexes */ ts_chunk_constraints_create(ht, chunk); if (chunk->relkind == RELKIND_RELATION && !IS_OSM_CHUNK(chunk)) { ts_trigger_create_all_on_chunk(chunk); ts_chunk_index_create_all(chunk->fd.hypertable_id, chunk->hypertable_relid, chunk->fd.id, chunk->table_id, InvalidOid); chunk_set_replica_identity(chunk); } } static Oid chunk_create_table(Chunk *chunk, const Hypertable *ht) { /* Create the actual table relation for the chunk */ const char *tablespace = ts_hypertable_select_tablespace_name(ht, chunk); chunk->table_id = ts_chunk_create_table(chunk, ht, tablespace); Assert(OidIsValid(chunk->table_id)); return chunk->table_id; } /* * Creates only a table for a chunk. * Either table name or chunk id needs to be provided. */ static Chunk * chunk_create_only_table_after_lock(const Hypertable *ht, Hypercube *cube, const char *schema_name, const char *table_name, const char *prefix, int32 chunk_id) { Chunk *chunk; Assert(table_name != NULL || chunk_id != INVALID_CHUNK_ID); chunk = chunk_create_object(ht, cube, schema_name, table_name, prefix, chunk_id); Assert(chunk != NULL); chunk_create_table(chunk, ht); return chunk; } static Chunk * chunk_create_from_hypercube_after_lock(const Hypertable *ht, Hypercube *cube, const char *schema_name, const char *table_name, const char *prefix) { chunk_insert_check_hook_type osm_chunk_insert_hook = ts_get_osm_chunk_insert_hook(); if (osm_chunk_insert_hook) { /* OSM only uses first dimension. */ Dimension *dim = &ht->space->dimensions[0]; /* convert to PG timestamp from timescaledb internal format */ int64 range_start = ts_internal_to_time_int64(cube->slices[0]->fd.range_start, dim->fd.column_type); int64 range_end = ts_internal_to_time_int64(cube->slices[0]->fd.range_end, dim->fd.column_type); int chunk_exists = osm_chunk_insert_hook(ht->main_table_relid, range_start, range_end); if (chunk_exists) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Cannot insert into tiered chunk range of %s.%s - attempt to create " "new chunk " "with range [%s %s] failed", NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), ts_internal_to_time_string(cube->slices[0]->fd.range_start, dim->fd.column_type), ts_internal_to_time_string(cube->slices[0]->fd.range_end, dim->fd.column_type)), errhint( "Hypertable has tiered data with time range that overlaps the insert"))); } } /* Insert any new dimension slices into metadata */ ts_dimension_slice_insert_multi(cube->slices, cube->num_slices); Chunk *chunk = chunk_create_only_table_after_lock(ht, cube, schema_name, table_name, prefix, get_next_chunk_id()); /* Insert any new chunk column stats entries into the catalog */ ts_chunk_column_stats_insert(ht, chunk); chunk_add_constraints(chunk); chunk_insert_into_metadata_after_lock(chunk); chunk_create_table_constraints(ht, chunk); return chunk; } /* * Make a chunk table inherit a hypertable. * * Execution happens via high-level ALTER TABLE statement. This includes * numerous checks to ensure that the chunk table has all the prerequisites to * properly inherit the hypertable. */ static void chunk_add_inheritance(Chunk *chunk, const Hypertable *ht) { AlterTableCmd altercmd = { .type = T_AlterTableCmd, .subtype = AT_AddInherit, .def = (Node *) makeRangeVar((char *) NameStr(ht->fd.schema_name), (char *) NameStr(ht->fd.table_name), 0), .missing_ok = false, }; AlterTableStmt alterstmt = { .type = T_AlterTableStmt, .cmds = list_make1(&altercmd), .missing_ok = false, .objtype = OBJECT_TABLE, .relation = makeRangeVar((char *) NameStr(chunk->fd.schema_name), (char *) NameStr(chunk->fd.table_name), 0), }; LOCKMODE lockmode = AlterTableGetLockLevel(alterstmt.cmds); AlterTableUtilityContext atcontext = { .relid = AlterTableLookupRelation(&alterstmt, lockmode), }; AlterTable(&alterstmt, lockmode, &atcontext); } static Chunk * chunk_create_from_hypercube_and_table_after_lock(const Hypertable *ht, Hypercube *cube, Oid chunk_table_relid, const char *schema_name, const char *table_name, const char *prefix) { Oid current_chunk_schemaid = get_rel_namespace(chunk_table_relid); Oid new_chunk_schemaid = InvalidOid; Chunk *chunk; Assert(OidIsValid(chunk_table_relid)); Assert(OidIsValid(current_chunk_schemaid)); Assert(OidIsValid(ht->main_table_relid)); Relation ht_rel = table_open(ht->main_table_relid, AccessShareLock); Relation chunk_rel = table_open(chunk_table_relid, AccessShareLock); TupleDesc tupdesc = RelationGetDescr(chunk_rel); for (int attno = 0; attno < tupdesc->natts; attno++) { Form_pg_attribute att = TupleDescAttr(tupdesc, attno); AttrNumber ht_attnum = InvalidAttrNumber; /* Ignore dropped */ if (att->attisdropped) continue; ht_attnum = get_attnum(ht->main_table_relid, NameStr(att->attname)); /* Try to find the column in parent (matching on column name) */ if (ht_attnum == InvalidAttrNumber) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("table \"%s\" contains column \"%s\" not found in parent \"%s\"", RelationGetRelationName(chunk_rel), NameStr(att->attname), RelationGetRelationName(ht_rel)), errdetail("The new chunk can contain only the columns present in parent."))); /* * PG16 and later does not allow generated columns on child tables if the parent * column is not generated. This is a change from PG15 and earlier, where the * child column could be generated even if the parent was not. * We check if a generated column is also generated in the parent here to disallow * this behavior in PG15 too. * * The case when the parent column is generated and the child column is not is handled * by Postgres code, which will throw an error. * * This check can be removed once we drop support for PG15. */ if (att->attgenerated && !get_attgenerated(ht->main_table_relid, ht_attnum)) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("column \"%s\" in chunk table must not be a generated column", NameStr(att->attname)), errdetail("Chunk column must be generated if and only if parent column is " "also generated"))); } /* Check that the chunk column has the same expression as the hypertable column */ if (att->attgenerated && get_attgenerated(ht->main_table_relid, ht_attnum)) { char *chunk_expr = ts_get_attr_expr(chunk_rel, attno + 1); char *ht_expr = ts_get_attr_expr(ht_rel, ht_attnum); if (strcmp(chunk_expr, ht_expr) != 0) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("chunk column \"%s\" must have the same expression as the " "hypertable column.", NameStr(att->attname)))); } } table_close(ht_rel, NoLock); /* Insert any new dimension slices into metadata */ ts_dimension_slice_insert_multi(cube->slices, cube->num_slices); chunk = chunk_create_object(ht, cube, schema_name, table_name, prefix, get_next_chunk_id()); chunk->table_id = chunk_table_relid; chunk->hypertable_relid = ht->main_table_relid; new_chunk_schemaid = get_namespace_oid(NameStr(chunk->fd.schema_name), false); if (current_chunk_schemaid != new_chunk_schemaid) { ObjectAddresses *objects; CheckSetNamespace(current_chunk_schemaid, new_chunk_schemaid); objects = new_object_addresses(); AlterTableNamespaceInternal(chunk_rel, current_chunk_schemaid, new_chunk_schemaid, objects); free_object_addresses(objects); /* Make changes visible */ CommandCounterIncrement(); } table_close(chunk_rel, NoLock); if (namestrcmp(&chunk->fd.table_name, get_rel_name(chunk_table_relid)) != 0) { /* Renaming will acquire and keep an AccessExclusivelock on the chunk * table */ RenameRelationInternal(chunk_table_relid, NameStr(chunk->fd.table_name), true, false); /* Make changes visible */ CommandCounterIncrement(); } /* Note that we do not automatically add constrains and triggers to the * chunk table when the chunk is created from an existing table. However, * PostgreSQL currently validates that CHECK constraints exists, but no * validation is done for other objects, including triggers, UNIQUE, * PRIMARY KEY, and FOREIGN KEY constraints. We might want to either * enforce that these constraints exist prior to creating the chunk from a * table, or we ensure that they are automatically added when the chunk is * created. However, for the latter case, we risk duplicating constraints * and triggers if some of them already exist on the chunk table prior to * creating the chunk from it. */ chunk_add_constraints(chunk); ts_chunk_constraint_check_violated(chunk, ht->space); chunk_insert_into_metadata_after_lock(chunk); chunk_add_inheritance(chunk, ht); chunk_create_table_constraints(ht, chunk); return chunk; } static Chunk * chunk_create_from_point_after_lock(const Hypertable *ht, const Point *p, const char *schema_name, const char *table_name, const char *prefix) { Hyperspace *hs = ht->space; Hypercube *cube; ScanTupLock tuplock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, }; /* * If the user has enabled adaptive chunking, call the function to * calculate and set the new chunk time interval. */ calculate_and_set_new_chunk_interval(ht, p); /* Calculate the hypercube for a new chunk that covers the tuple's point. * * We lock the tuple in KEY SHARE mode since we are concerned with * ensuring that it is not deleted (or the key value changed) while we are * adding chunk constraints (in `ts_chunk_constraints_insert_metadata` * called in `chunk_create_metadata_after_lock`). The range of a dimension * slice does not change, but we should use the weakest lock possible to * not unnecessarily block other operations. */ cube = ts_hypercube_calculate_from_point(hs, p, &tuplock); /* Resolve collisions with other chunks by cutting the new hypercube */ chunk_collision_resolve(ht, cube, p); return chunk_create_from_hypercube_after_lock(ht, cube, schema_name, table_name, prefix); } Chunk * ts_chunk_find_or_create_without_cuts(const Hypertable *ht, Hypercube *hc, const char *schema_name, const char *table_name, Oid chunk_table_relid, bool *created) { ChunkStub *stub; Chunk *chunk = NULL; DEBUG_WAITPOINT("find_or_create_chunk_start"); stub = chunk_collides(ht, hc); if (NULL == stub) { /* Serialize chunk creation around the root hypertable */ LockRelationOid(ht->main_table_relid, ShareUpdateExclusiveLock); /* Check again after lock */ stub = chunk_collides(ht, hc); if (NULL == stub) { ScanTupLock tuplock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, }; /* Lock all slices that already exist to ensure they remain when we * commit since we won't create those slices ourselves. */ ts_hypercube_find_existing_slices(hc, &tuplock); if (OidIsValid(chunk_table_relid)) chunk = chunk_create_from_hypercube_and_table_after_lock(ht, hc, chunk_table_relid, schema_name, table_name, NULL); else chunk = chunk_create_from_hypercube_after_lock(ht, hc, schema_name, table_name, NULL); if (NULL != created) *created = true; ASSERT_IS_VALID_CHUNK(chunk); DEBUG_WAITPOINT("find_or_create_chunk_created"); return chunk; } /* We didn't need the lock, so release it */ UnlockRelationOid(ht->main_table_relid, ShareUpdateExclusiveLock); } Assert(NULL != stub); /* We can only use an existing chunk if it has identical dimensional * constraints. Otherwise, throw an error */ if (OidIsValid(chunk_table_relid) || !ts_hypercube_equal(stub->cube, hc)) ereport(ERROR, (errcode(ERRCODE_TS_CHUNK_COLLISION), errmsg("chunk creation failed due to collision"))); /* chunk_collides only returned a stub, so we need to lookup the full * chunk. */ chunk = ts_chunk_get_by_id(stub->id, true); if (NULL != created) *created = false; DEBUG_WAITPOINT("find_or_create_chunk_found"); ASSERT_IS_VALID_CHUNK(chunk); return chunk; } /* * Find the chunk containing the given point, locking all its dimension slices * for share. NULL if not found. */ Chunk * ts_chunk_find_for_point(const Hypertable *ht, const Point *p, LOCKMODE lockmode) { ScanTupLock slice_lock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; int32 chunk_id = ts_chunk_point_find_chunk_id(ht, p, NULL); if (chunk_id == INVALID_CHUNK_ID) return NULL; /* The chunk might be dropped, so we don't fail if we haven't found it. */ return ts_chunk_get_by_id_with_slice_lock(chunk_id, lockmode, lockmode == NoLock ? NULL : &slice_lock, /* fail_if_not_found = */ false); } /* * Create a chunk through insertion of a tuple at a given point. * * If some other process managed to create the chunk before us, the existing * chunk is locked with "chunk_lockmode". */ Chunk * ts_chunk_create_for_point(const Hypertable *ht, const Point *p, const char *schema, const char *prefix, LOCKMODE chunk_lockmode) { /* * We're going to have to resurrect or create the chunk. * Serialize chunk creation around a lock on the "main table" to avoid * multiple processes trying to create the same chunk. We use a * ShareUpdateExclusiveLock, which is the weakest lock possible that * conflicts with itself. The lock needs to be held until transaction end. */ LockRelationOid(ht->main_table_relid, ShareUpdateExclusiveLock); DEBUG_WAITPOINT("chunk_create_for_point"); /* * Recheck if someone else created the chunk before we got the table * lock. The returned chunk will have all slices locked so that they * aren't removed. */ int chunk_id = ts_chunk_point_find_chunk_id(ht, p, NULL); if (chunk_id != INVALID_CHUNK_ID) { ScanTupLock slice_lock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; /* The chunk might be dropped, so we don't fail if we haven't found it. */ Chunk *chunk = ts_chunk_get_by_id_with_slice_lock(chunk_id, chunk_lockmode, &slice_lock, /* fail_if_not_found = */ false); if (chunk != NULL) { /* * Chunk was not created by us but by someone else, so we can * release the lock early. */ UnlockRelationOid(ht->main_table_relid, ShareUpdateExclusiveLock); return chunk; } /* * If we managed to find some metadata for the chunk (chunk_id != INVALID_CHUNK_ID), * but it is marked as dropped, try to resurrect it. */ chunk = chunk_resurrect(ht, chunk_id); if (chunk != NULL) { return chunk; } } /* Create the chunk normally. */ Chunk *chunk = chunk_create_from_point_after_lock(ht, p, schema, NULL, prefix); ASSERT_IS_VALID_CHUNK(chunk); return chunk; } static void scan_add_chunk_context(ChunkScanCtx *ctx, int32 chunk_id, List *dimension_vecs, List **l_chunk_ids) { bool found = false; ChunkScanEntry *entry = hash_search(ctx->htab, &chunk_id, HASH_ENTER, &found); if (!found) { entry->stub = NULL; entry->num_dimension_constraints = 0; } entry->num_dimension_constraints++; /* * A chunk is complete when we've found slices for all required dimensions, * i.e., a complete subspace. */ if (entry->num_dimension_constraints == list_length(dimension_vecs)) { *l_chunk_ids = lappend_int(*l_chunk_ids, entry->chunk_id); } } /* * Find the chunks that belong to the subspace identified by the given dimension * vectors. We might be restricting only some dimensions, so this subspace is * not a hypercube, but a hyperplane of some order. * Returns a list of matching chunk ids. */ List * ts_chunk_id_find_in_subspace(Hypertable *ht, List *dimension_vecs) { List *chunk_ids = NIL; ChunkScanCtx ctx; chunk_scan_ctx_init(&ctx, ht, /* point = */ NULL); ScanIterator iterator = ts_chunk_constraint_scan_iterator_create(CurrentMemoryContext); ListCell *lc; foreach (lc, dimension_vecs) { const DimensionVec *vec = lfirst(lc); /* * If it's an entry of type DIMENSION_TYPE_STATS then we need to get * the chunks using the _timescaledb_catalog.chunk_column_stats catalog. */ Assert(vec->dri != NULL); if (vec->dri->dimension->type == DIMENSION_TYPE_STATS) { ListCell *lc; List *range_chunk_ids; Assert(vec->num_slices == 0); range_chunk_ids = ts_chunk_column_stats_get_chunk_ids_by_scan(vec->dri); /* add these chunks to the context appropriately. */ foreach (lc, range_chunk_ids) { int32 chunk_id = lfirst_int(lc); scan_add_chunk_context(&ctx, chunk_id, dimension_vecs, &chunk_ids); } continue; } /* * We shouldn't see a dimension with zero matching dimension slices. * That would mean that no chunks match at all, this should have been * handled earlier by gather_restriction_dimension_vectors(). */ Assert(vec->num_slices > 0); for (int i = 0; i < vec->num_slices; i++) { const DimensionSlice *slice = vec->slices[i]; ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, slice->fd.id); ts_scan_iterator_start_or_restart_scan(&iterator); while (ts_scan_iterator_next(&iterator) != NULL) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool PG_USED_FOR_ASSERTS_ONLY isnull = true; Datum datum = slot_getattr(ti->slot, Anum_chunk_constraint_chunk_id, &isnull); Assert(!isnull); int32 current_chunk_id = DatumGetInt32(datum); Assert(current_chunk_id != INVALID_CHUNK_ID); /* * We have only the dimension constraints here, because we're searching * by dimension slice id. */ Assert(!slot_attisnull(ts_scan_iterator_slot(&iterator), Anum_chunk_constraint_dimension_slice_id)); scan_add_chunk_context(&ctx, current_chunk_id, dimension_vecs, &chunk_ids); } } } ts_scan_iterator_close(&iterator); chunk_scan_ctx_destroy(&ctx); return chunk_ids; } ChunkStub * ts_chunk_stub_create(int32 id, int16 num_constraints) { ChunkStub *stub; stub = palloc0(sizeof(*stub)); stub->id = id; if (num_constraints > 0) stub->constraints = ts_chunk_constraints_alloc(num_constraints, CurrentMemoryContext); return stub; } Chunk * ts_chunk_create_base(int32 id, int16 num_constraints, const char relkind) { Chunk *chunk; chunk = palloc0(sizeof(Chunk)); chunk->fd.id = id; chunk->fd.compressed_chunk_id = INVALID_CHUNK_ID; chunk->relkind = relkind; chunk->fd.creation_time = GetCurrentTimestamp(); if (num_constraints > 0) chunk->constraints = ts_chunk_constraints_alloc(num_constraints, CurrentMemoryContext); return chunk; } /* * Build a chunk from a chunk tuple and a stub. * * The stub allows the chunk to be constructed more efficiently. But if the stub * is not "valid", dimension slices and constraints are fully * rescanned/recreated. */ Chunk * ts_chunk_build_from_tuple_and_stub(Chunk **chunkptr, TupleInfo *ti, const ChunkStub *stub, const ScanTupLock *slice_lock) { Chunk *chunk = NULL; int num_constraints_hint = stub ? stub->constraints->num_constraints : 2; if (NULL == chunkptr) chunkptr = &chunk; if (NULL == *chunkptr) *chunkptr = MemoryContextAllocZero(ti->mctx, sizeof(Chunk)); chunk = *chunkptr; ts_chunk_formdata_fill(&chunk->fd, ti); /* * When searching for the chunk stub matching the dimensional point, we * only scanned for dimensional constraints. We now need to rescan the * constraints to also get the inherited constraints. */ chunk->constraints = ts_chunk_constraint_scan_by_chunk_id(chunk->fd.id, num_constraints_hint, ti->mctx); /* If a stub is provided then reuse its hypercube. Note that stubs that * are results of a point or range scan might be incomplete (in terms of * number of slices and constraints). Only a chunk stub that matches in * all dimensions will have a complete hypercube. Thus, we need to check * the validity of the stub before we can reuse it. */ if (chunk_stub_is_valid(stub, chunk->constraints->num_dimension_constraints)) { MemoryContext oldctx = MemoryContextSwitchTo(ti->mctx); chunk->cube = ts_hypercube_copy(stub->cube); MemoryContextSwitchTo(oldctx); /* * The hypercube slices were filled in during the scan. Now we need to * sort them in dimension order. */ ts_hypercube_slice_sort(chunk->cube); } else { ScanIterator it = ts_dimension_slice_scan_iterator_create(slice_lock, ti->mctx); chunk->cube = ts_hypercube_from_constraints(chunk->constraints, &it); ts_scan_iterator_close(&it); } return chunk; } static ScanFilterResult chunk_tuple_dropped_filter(const TupleInfo *ti, void *arg) { ChunkStubScanCtx *stubctx = arg; bool isnull; Datum dropped; dropped = slot_getattr(ti->slot, Anum_chunk_dropped, &isnull); Assert(!isnull); stubctx->is_dropped = DatumGetBool(dropped); if (stubctx->is_dropped) return SCAN_EXCLUDE; /* * The chunk table could also have been dropped concurrently. Try to * acquire the requested lock in order to guarantee that the chunk table * still exists. */ if (stubctx->chunk_lockmode != NoLock) { Datum schema_name; Datum table_name; const RangeVar *rv; schema_name = slot_getattr(ti->slot, Anum_chunk_schema_name, &isnull); Assert(!isnull); table_name = slot_getattr(ti->slot, Anum_chunk_table_name, &isnull); Assert(!isnull); rv = makeRangeVar(NameStr(*DatumGetName(schema_name)), NameStr(*DatumGetName(table_name)), -1); Relation rel = table_openrv_extended(rv, stubctx->chunk_lockmode, true); if (!rel) return SCAN_EXCLUDE; table_close(rel, NoLock); } return SCAN_INCLUDE; } static ScanTupleResult chunk_tuple_found(TupleInfo *ti, void *arg) { ChunkStubScanCtx *stubctx = arg; Chunk *chunk; chunk = ts_chunk_build_from_tuple_and_stub(&stubctx->chunk, ti, stubctx->stub, stubctx->slice_lock); if (!chunk) return SCAN_DONE; Assert(!chunk->fd.dropped); /* Fill in table relids. Note that we cannot do this in * ts_chunk_build_from_tuple_and_stub() since chunk_resurrect() also uses * that function and, in that case, the chunk object is needed to create * the data table and related objects. */ chunk->hypertable_relid = ts_hypertable_id_to_relid(chunk->fd.hypertable_id, false); ts_get_rel_info_by_name(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), &chunk->table_id, &chunk->relkind); Ensure(chunk->relkind > 0, "relkind for chunk \"%s\".\"%s\" is invalid", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); return SCAN_DONE; } /* Create a chunk by scanning on chunk ID. A stub must be provided as input. */ static Chunk * chunk_create_from_stub(ChunkStubScanCtx *stubctx) { ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); int num_found; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CHUNK), .index = catalog_get_index(catalog, CHUNK, CHUNK_ID_INDEX), .nkeys = 1, .scankey = scankey, .data = stubctx, .filter = chunk_tuple_dropped_filter, .tuple_found = chunk_tuple_found, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, }; /* * Perform an index scan on chunk ID. */ ScanKeyInit(&scankey[0], Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(stubctx->stub->id)); num_found = ts_scanner_scan(&scanctx); Assert(num_found == 0 || num_found == 1); if (stubctx->is_dropped) { Assert(num_found == 0); return NULL; } if (num_found != 1) elog(ERROR, "no chunk found with ID %d", stubctx->stub->id); Assert(NULL != stubctx->chunk); return stubctx->chunk; } /* * Initialize a chunk scan context. * * A chunk scan context is used to join chunk-related information from metadata * tables during scans. */ static void chunk_scan_ctx_init(ChunkScanCtx *ctx, const Hypertable *ht, const Point *point) { struct HASHCTL hctl = { .keysize = sizeof(int32), .entrysize = sizeof(ChunkScanEntry), .hcxt = CurrentMemoryContext, }; memset(ctx, 0, sizeof(*ctx)); ctx->htab = hash_create("chunk-scan-context", 20, &hctl, HASH_ELEM | HASH_CONTEXT | HASH_BLOBS); ctx->ht = ht; ctx->point = point; ctx->lockmode = NoLock; } /* * Destroy the chunk scan context. * * This will free the hash table in the context, but not the chunks within since * they are not allocated on the hash tables memory context. */ static void chunk_scan_ctx_destroy(ChunkScanCtx *ctx) { hash_destroy(ctx->htab); } static inline void dimension_slice_and_chunk_constraint_join(ChunkScanCtx *scanctx, const DimensionVec *vec) { int i; for (i = 0; i < vec->num_slices; i++) { /* * For each dimension slice, find matching constraints. These will be * saved in the scan context */ ts_chunk_constraint_scan_by_dimension_slice(vec->slices[i], scanctx, CurrentMemoryContext); } } /* * Scan for chunks that collide with the given hypercube. * * Collisions are determined using axis-aligned bounding box collision detection * generalized to N dimensions. Slices are collected in the scan context's hash * table according to the chunk IDs they are associated with. A slice might * represent the dimensional bound of multiple chunks, and thus is added to all * the hash table slots of those chunks. At the end of the scan, those chunks * that have a full set of slices are the ones that actually collide with the * given hypercube. * * Chunks in the scan context that do not collide (do not have a full set of * slices), might still be important for ensuring alignment in those dimensions * that require alignment. */ static void chunk_collision_scan(ChunkScanCtx *scanctx, const Hypercube *cube) { int i; /* Scan all dimensions for colliding slices */ for (i = 0; i < scanctx->ht->space->num_dimensions; i++) { DimensionVec *vec; DimensionSlice *slice = cube->slices[i]; vec = dimension_slice_collision_scan(slice->fd.dimension_id, slice->fd.range_start, slice->fd.range_end); /* Add the slices to all the chunks they are associated with */ dimension_slice_and_chunk_constraint_join(scanctx, vec); } } /* * Apply a function to each stub in the scan context's hash table. If the limit * is greater than zero only a limited number of chunks will be processed. * * The chunk handler function (on_chunk_func) should return CHUNK_PROCESSED if * the chunk should be considered processed and count towards the given * limit. CHUNK_IGNORE can be returned to have a chunk NOT count towards the * limit. CHUNK_DONE counts the chunk but aborts processing irrespective of * whether the limit is reached or not. * * Returns the number of processed chunks. */ static int chunk_scan_ctx_foreach_chunk_stub(ChunkScanCtx *ctx, on_chunk_stub_func on_chunk, uint64 limit) { HASH_SEQ_STATUS status; ChunkScanEntry *entry; ctx->num_processed = 0; hash_seq_init(&status, ctx->htab); for (entry = hash_seq_search(&status); entry != NULL; entry = hash_seq_search(&status)) { switch (on_chunk(ctx, entry->stub)) { case CHUNK_DONE: ctx->num_processed++; hash_seq_term(&status); return ctx->num_processed; case CHUNK_PROCESSED: ctx->num_processed++; if (limit > 0 && ctx->num_processed == limit) { hash_seq_term(&status); return ctx->num_processed; } break; case CHUNK_IGNORED: break; } } return ctx->num_processed; } typedef struct ChunkScanCtxAddChunkData { Chunk *chunks; uint64 max_chunks; uint64 num_chunks; } ChunkScanCtxAddChunkData; static ChunkResult chunk_scan_context_add_chunk(ChunkScanCtx *scanctx, ChunkStub *stub) { ChunkScanCtxAddChunkData *data = scanctx->data; ChunkStubScanCtx stubctx = { .chunk = &data->chunks[data->num_chunks], .stub = stub, }; Assert(data->num_chunks < data->max_chunks); chunk_create_from_stub(&stubctx); if (stubctx.is_dropped) return CHUNK_IGNORED; data->num_chunks++; return CHUNK_PROCESSED; } TM_Result ts_chunk_lock_for_creating_compressed_chunk(int32 chunk_id, int32 *compressed_chunk_id) { ScanIterator iterator; bool found = false; TM_Result lockresult; ScanTupLock tuplock = { .lockmode = LockTupleExclusive, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; iterator = ts_scan_iterator_create(CHUNK, RowShareLock, CurrentMemoryContext); ts_chunk_scan_iterator_set_chunk_id(&iterator, chunk_id); iterator.ctx.tuplock = &tuplock; ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); lockresult = ti->lockresult; if (lockresult == TM_Ok && compressed_chunk_id) { bool isnull; Datum value = slot_getattr(ti->slot, Anum_chunk_compressed_chunk_id, &isnull); *compressed_chunk_id = isnull ? INVALID_CHUNK_ID : DatumGetInt32(value); } found = true; } ts_scan_iterator_close(&iterator); if (!found) elog(ERROR, "chunk with ID %d does not exist", chunk_id); return lockresult; } /* * Resurrect a chunk from a tombstone. * * A chunk can be dropped while retaining its metadata as a tombstone. Such a * chunk is marked with dropped=true. * * This function resurrects such a dropped chunk based on the original metadata, * including recreating the table and related objects. */ static Chunk * chunk_resurrect(const Hypertable *ht, int chunk_id) { ScanIterator iterator; Chunk *chunk = NULL; PG_USED_FOR_ASSERTS_ONLY int count = 0; Assert(chunk_id != INVALID_CHUNK_ID); iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); ts_chunk_scan_iterator_set_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); HeapTuple new_tuple; ScanTupLock slice_lock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, }; Assert(count == 0 && chunk == NULL); chunk = ts_chunk_build_from_tuple_and_stub(/* chunkptr = */ NULL, ti, /* stub = */ NULL, &slice_lock); Assert(chunk->fd.dropped); /* Create data table and related objects */ chunk->hypertable_relid = ht->main_table_relid; chunk->relkind = RELKIND_RELATION; chunk->table_id = chunk_create_table(chunk, ht); chunk_create_table_constraints(ht, chunk); /* Finally, update the chunk tuple to no longer be a tombstone */ chunk->fd.dropped = false; new_tuple = chunk_formdata_make_tuple(&chunk->fd, ts_scan_iterator_tupledesc(&iterator)); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); heap_freetuple(new_tuple); count++; /* Assume there's only one match. (We break early to avoid scanning * also the updated tuple.) */ break; } ts_scan_iterator_close(&iterator); Assert(count == 0 || count == 1); /* If count == 0 and chunk is NULL here, the tombstone (metadata) must * have been removed before we had a chance to resurrect the chunk */ return chunk; } /* * Scan for the chunk that encloses the given point. * * In each dimension there can be one or more slices that match the point's * coordinate in that dimension. Slices are collected in the scan context's hash * table according to the chunk IDs they are associated with. A slice might * represent the dimensional bound of multiple chunks, and thus is added to all * the hash table slots of those chunks. At the end of the scan there will be at * most one chunk that has a complete set of slices, since a point cannot belong * to two chunks. * * This involves: * * 1) For each dimension: * - Find all dimension slices that match the dimension * 2) For each dimension slice: * - Find all chunk constraints matching the dimension slice * 3) For each matching chunk constraint * - Insert a chunk stub into a hash table and add the constraint to the chunk * - If chunk already exists in hash table, add the constraint to the chunk * 4) At the end of the scan, only one chunk in the hash table should have * N number of constraints. This is the matching chunk. * * NOTE: this function allocates transient data, e.g., dimension slice, * constraints and chunks, that in the end are not part of the returned * chunk. Therefore, this scan should be executed on a transient memory * context. The returned chunk needs to be copied into another memory context in * case it needs to live beyond the lifetime of the other data. * * The slices can be locked by specifying an optional slice lock. */ int32 ts_chunk_point_find_chunk_id(const Hypertable *ht, const Point *p, const ScanTupLock *slice_lock) { int32 matching_chunk_id = 0; /* The scan context will keep the state accumulated during the scan */ ChunkScanCtx ctx; chunk_scan_ctx_init(&ctx, ht, p); /* Scan all dimensions for slices enclosing the point */ List *all_slices = NIL; for (int dimension_index = 0; dimension_index < ctx.ht->space->num_dimensions; dimension_index++) { ts_dimension_slice_scan_list(ctx.ht->space->dimensions[dimension_index].fd.id, p->coordinates[dimension_index], &all_slices, slice_lock); } /* Find constraints matching dimension slices. */ ScanIterator iterator = ts_chunk_constraint_scan_iterator_create(CurrentMemoryContext); ListCell *lc; foreach (lc, all_slices) { DimensionSlice *slice = (DimensionSlice *) lfirst(lc); ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, slice->fd.id); ts_scan_iterator_start_or_restart_scan(&iterator); while (ts_scan_iterator_next(&iterator) != NULL) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool PG_USED_FOR_ASSERTS_ONLY isnull = true; Datum datum = slot_getattr(ti->slot, Anum_chunk_constraint_chunk_id, &isnull); Assert(!isnull); int32 current_chunk_id = DatumGetInt32(datum); Assert(current_chunk_id != INVALID_CHUNK_ID); bool found = false; ChunkScanEntry *entry = hash_search(ctx.htab, ¤t_chunk_id, HASH_ENTER, &found); if (!found) { entry->stub = NULL; entry->num_dimension_constraints = 0; } /* * We have only the dimension constraints here, because we're searching * by dimension slice id. */ Assert(!slot_attisnull(ts_scan_iterator_slot(&iterator), Anum_chunk_constraint_dimension_slice_id)); entry->num_dimension_constraints++; /* * A chunk is complete when we've found slices for all its dimensions, * i.e., a complete hypercube. Only one chunk matches a given hyperspace * point, so we can stop early. */ if (entry->num_dimension_constraints == ctx.ht->space->num_dimensions) { matching_chunk_id = entry->chunk_id; break; } } if (matching_chunk_id != INVALID_CHUNK_ID) { break; } } ts_scan_iterator_close(&iterator); chunk_scan_ctx_destroy(&ctx); return matching_chunk_id; } /* * Find all the chunks in hyperspace that include elements (dimension slices) * calculated by given range constraints and return the corresponding * ChunkScanCxt. It is the caller's responsibility to destroy this context after * usage. */ static void chunks_find_all_in_range_limit(const Hypertable *ht, const Dimension *time_dim, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value, int limit, uint64 *num_found, ScanTupLock *tuplock, ChunkScanCtx *ctx) { DimensionVec *slices; Assert(ht != NULL); /* must have been checked earlier that this is the case */ Assert(time_dim != NULL); slices = ts_dimension_slice_scan_range_limit(time_dim->fd.id, start_strategy, start_value, end_strategy, end_value, limit, tuplock); /* The scan context will keep the state accumulated during the scan */ chunk_scan_ctx_init(ctx, ht, NULL); /* No abort when the first chunk is found */ ctx->early_abort = false; /* Scan for chunks that are in range */ dimension_slice_and_chunk_constraint_join(ctx, slices); *num_found += hash_get_num_entries(ctx->htab); } /* show_chunks SQL function handler */ Datum ts_chunk_show_chunks(PG_FUNCTION_ARGS) { /* * show_chunks_return_srf is called even when it is not the first call but only * after doing some computation first */ if (SRF_IS_FIRSTCALL()) { FuncCallContext *funcctx; Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Hypertable *ht; const Dimension *time_dim; Cache *hcache; int64 older_than = PG_INT64_MAX; int64 newer_than = PG_INT64_MIN; int64 created_before = PG_INT64_MAX; int64 created_after = PG_INT64_MIN; Oid time_type; Oid arg_type; bool older_newer = false; bool before_after = false; hcache = ts_hypertable_cache_pin(); ht = ts_resolve_hypertable_from_table_or_cagg(hcache, relid, true); Assert(ht != NULL); time_dim = hyperspace_get_open_dimension(ht->space, 0); if (!time_dim) time_dim = hyperspace_get_closed_dimension(ht->space, 0); if (time_dim && IS_CLOSED_DIMENSION(time_dim) && (!PG_ARGISNULL(1) || !PG_ARGISNULL(2))) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot specify \"older_than\" or \"newer_than\" for " "\"closed\"-like partitioning types"), errhint("Use \"created_before\" and/or \"created_after\" which rely on the " "chunk creation time values."))); if (time_dim) time_type = ts_dimension_get_partition_type(time_dim); else time_type = InvalidOid; /* * Treat UUID (v7) as a timestamptz type. The expected input is an interval or absolute * timestamptz. */ if (IS_UUID_TYPE(time_type)) time_type = TIMESTAMPTZOID; /* note that arg_types will be the same for all specified "ANY" elements for a given call */ arg_type = InvalidOid; if (!PG_ARGISNULL(1)) { arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1); older_than = ts_time_value_from_arg(PG_GETARG_DATUM(1), arg_type, time_type, true); older_newer = true; } if (!PG_ARGISNULL(2)) { arg_type = get_fn_expr_argtype(fcinfo->flinfo, 2); newer_than = ts_time_value_from_arg(PG_GETARG_DATUM(2), arg_type, time_type, true); older_newer = true; } /* * We cannot have a mix of [older_than/newer_than] and [created_before/created_after]. * So, check that first. Note that created_before/created_after have a type of * TIMESTAMPTZOID regardless of the partitioning type. */ if (!PG_ARGISNULL(3)) { if (older_newer) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify \"older_than\" or \"newer_than\" together with " "\"created_before\"" "or \"created_after\""))); arg_type = get_fn_expr_argtype(fcinfo->flinfo, 3); /* We use the existing function for various type/conversion checks */ created_before = ts_time_value_from_arg(PG_GETARG_DATUM(3), arg_type, TIMESTAMPTZOID, false); /* convert into int64 format for comparisons */ created_before = ts_internal_to_time_int64(created_before, TIMESTAMPTZOID); before_after = true; } if (!PG_ARGISNULL(4)) { if (older_newer) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify \"older_than\" or \"newer_than\" together with " "\"created_before\"" "or \"created_after\""))); arg_type = get_fn_expr_argtype(fcinfo->flinfo, 4); /* We use the existing function for various type/conversion checks */ created_after = ts_time_value_from_arg(PG_GETARG_DATUM(4), arg_type, TIMESTAMPTZOID, false); /* convert into int64 format for comparisons */ created_after = ts_internal_to_time_int64(created_after, TIMESTAMPTZOID); before_after = true; } /* if both have not been specified then default to older_newer */ if (!older_newer && !before_after) older_newer = true; funcctx = SRF_FIRSTCALL_INIT(); /* * For INTEGER type dimensions, we support querying using intervals or any * timestamp or date input. For such INTEGER dimensions, we get the chunks * using their creation time values. */ if (IS_INTEGER_TYPE(time_type) && (arg_type == INTERVALOID || IS_TIMESTAMP_TYPE(arg_type))) { /* check that we use proper inputs for such cases */ if (older_newer) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify \"older_than\" and/or \"newer_than\" for " "\"integer\"-like partitioning types"), errhint( "Use \"created_before\" and/or \"created_after\" which rely on the " "chunk creation time values."))); funcctx->user_fctx = get_chunks_in_creation_time_range(ht, created_before, created_after, funcctx->multi_call_memory_ctx, &funcctx->max_calls, NULL); } else { /* check that we use proper inputs for such cases */ if (!older_newer) { funcctx->user_fctx = get_chunks_in_creation_time_range(ht, created_before, created_after, funcctx->multi_call_memory_ctx, &funcctx->max_calls, NULL); } else funcctx->user_fctx = get_chunks_in_time_range(ht, older_than, newer_than, funcctx->multi_call_memory_ctx, &funcctx->max_calls, NULL); } ts_cache_release(&hcache); } return show_chunks_return_srf(fcinfo); } static Chunk * get_chunks_in_time_range(Hypertable *ht, int64 older_than, int64 newer_than, MemoryContext mctx, uint64 *num_chunks_returned, ScanTupLock *tuplock) { MemoryContext oldcontext; ChunkScanCtx chunk_scan_ctx; Chunk *chunks; ChunkScanCtxAddChunkData data; const Dimension *time_dim; StrategyNumber start_strategy; StrategyNumber end_strategy; uint64 num_chunks = 0; if (older_than <= newer_than) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time range"), errhint("The start of the time range must be before the end."))); if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("invalid operation on compressed hypertable"))); start_strategy = (newer_than == PG_INT64_MIN) ? InvalidStrategy : BTGreaterEqualStrategyNumber; end_strategy = (older_than == PG_INT64_MAX) ? InvalidStrategy : BTLessStrategyNumber; time_dim = hyperspace_get_open_dimension(ht->space, 0); if (time_dim == NULL) time_dim = hyperspace_get_closed_dimension(ht->space, 0); Ensure(time_dim != NULL, "partitioning dimension not found for hypertable \"%s\".\"%s\"", NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name)); oldcontext = MemoryContextSwitchTo(mctx); chunks_find_all_in_range_limit(ht, time_dim, start_strategy, newer_than, end_strategy, older_than, -1, &num_chunks, tuplock, &chunk_scan_ctx); MemoryContextSwitchTo(oldcontext); chunks = MemoryContextAllocZero(mctx, sizeof(Chunk) * num_chunks); data = (ChunkScanCtxAddChunkData){ .chunks = chunks, .max_chunks = num_chunks, .num_chunks = 0, }; /* Get all the chunks from the context */ chunk_scan_ctx.data = &data; chunk_scan_ctx_foreach_chunk_stub(&chunk_scan_ctx, chunk_scan_context_add_chunk, 0); /* * only affects ctx.htab Got all the chunk already so can now safely * destroy the context */ chunk_scan_ctx_destroy(&chunk_scan_ctx); *num_chunks_returned = data.num_chunks; qsort(chunks, *num_chunks_returned, sizeof(Chunk), chunk_cmp); #ifdef USE_ASSERT_CHECKING do { uint64 i = 0; /* Assert that we never return dropped chunks */ for (i = 0; i < *num_chunks_returned; i++) ASSERT_IS_VALID_CHUNK(&chunks[i]); } while (false); #endif return chunks; } Chunk * ts_chunk_copy(const Chunk *chunk) { Chunk *copy; ASSERT_IS_VALID_CHUNK(chunk); copy = palloc(sizeof(Chunk)); memcpy(copy, chunk, sizeof(Chunk)); if (NULL != chunk->constraints) copy->constraints = ts_chunk_constraints_copy(chunk->constraints); if (NULL != chunk->cube) copy->cube = ts_hypercube_copy(chunk->cube); return copy; } static int chunk_scan_internal(int indexid, ScanKeyData scankey[], int nkeys, tuple_filter_func filter, tuple_found_func tuple_found, void *data, int limit, ScanDirection scandir, LOCKMODE lockmode, MemoryContext mctx) { Catalog *catalog = ts_catalog_get(); ScannerCtx ctx = { .table = catalog_get_table_id(catalog, CHUNK), .index = catalog_get_index(catalog, CHUNK, indexid), .nkeys = nkeys, .data = data, .scankey = scankey, .filter = filter, .tuple_found = tuple_found, .limit = limit, .lockmode = lockmode, .scandirection = scandir, .result_mctx = mctx, }; return ts_scanner_scan(&ctx); } /* * Get a window of chunks that "precedes" the given dimensional point. * * For instance, if the dimension is "time", then given a point in time the * function returns the recent chunks that come before the chunk that includes * that point. The count parameter determines the number or slices the window * should include in the given dimension. Note, that with multi-dimensional * partitioning, there might be multiple chunks in each dimensional slice that * all precede the given point. For instance, the example below shows two * different situations that each go "back" two slices (count = 2) in the * x-dimension, but returns two vs. eight chunks due to different * partitioning. * * '_____________ * '| | | * | * '|___|___|___| * ' * ' * '____ ________ * '| | | * | * '|___|___|___| * '| | | | * '|___|___|___| * '| | | | * '|___|___|___| * '| | | | * '|___|___|___| * * Note that the returned chunks will be allocated on the given memory * context, including the list itself. So, beware of not leaking the list if * the chunks are later cached somewhere else. */ List * ts_chunk_get_window(int32 dimension_id, int64 point, int count, MemoryContext mctx) { List *chunks = NIL; DimensionVec *dimvec; int i; /* Scan for "count" slices that precede the point in the given dimension */ dimvec = ts_dimension_slice_scan_by_dimension_before_point(dimension_id, point, count, BackwardScanDirection, mctx); /* * For each slice, join with any constraints that reference the slice. * There might be multiple constraints for each slice in case of * multi-dimensional partitioning. */ for (i = 0; i < dimvec->num_slices; i++) { DimensionSlice *slice = dimvec->slices[i]; ChunkConstraints *ccs = ts_chunk_constraints_alloc(1, mctx); int j; ts_chunk_constraint_scan_by_dimension_slice_id(slice->fd.id, ccs, mctx); /* For each constraint, find the corresponding chunk */ for (j = 0; j < ccs->num_constraints; j++) { ChunkConstraint *cc = &ccs->constraints[j]; Chunk *chunk = ts_chunk_get_by_id(cc->fd.chunk_id, false); MemoryContext old; ScanIterator it; /* Dropped chunks do not contain valid data and must not be returned */ if (!chunk) continue; chunk->constraints = ts_chunk_constraint_scan_by_chunk_id(chunk->fd.id, 1, mctx); it = ts_dimension_slice_scan_iterator_create(NULL, mctx); chunk->cube = ts_hypercube_from_constraints(chunk->constraints, &it); ts_scan_iterator_close(&it); /* Allocate the list on the same memory context as the chunks */ old = MemoryContextSwitchTo(mctx); chunks = lappend(chunks, chunk); MemoryContextSwitchTo(old); } } #ifdef USE_ASSERT_CHECKING /* Assert that we never return dropped chunks */ do { ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); ASSERT_IS_VALID_CHUNK(chunk); } } while (false); #endif return chunks; } static Chunk * chunk_scan_find(int indexid, ScanKeyData scankey[], int nkeys, MemoryContext mctx, LOCKMODE chunk_lockmode, const ScanTupLock *slice_lock, bool fail_if_not_found, const DisplayKeyData displaykey[]) { ChunkStubScanCtx stubctx = { .slice_lock = slice_lock, .chunk_lockmode = chunk_lockmode, }; Chunk *chunk; int num_found; num_found = chunk_scan_internal(indexid, scankey, nkeys, chunk_tuple_dropped_filter, chunk_tuple_found, &stubctx, 1, ForwardScanDirection, AccessShareLock, mctx); Assert(num_found == 0 || (num_found == 1 && !stubctx.is_dropped)); chunk = stubctx.chunk; switch (num_found) { case 0: if (fail_if_not_found) { int i = 0; StringInfo info = makeStringInfo(); while (i < nkeys) { appendStringInfo(info, "%s: %s", displaykey[i].name, displaykey[i].as_string(scankey[i].sk_argument)); if (++i < nkeys) appendStringInfoString(info, ", "); } ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("chunk not found"), errdetail("%s", info->data))); } break; case 1: if (chunk) { ASSERT_IS_VALID_CHUNK(chunk); } break; default: elog(ERROR, "expected a single chunk, found %d", num_found); } return chunk; } Chunk * ts_chunk_get_by_name_with_memory_context(const char *schema_name, const char *table_name, LOCKMODE chunk_lockmode, const ScanTupLock *slice_lock, MemoryContext mctx, bool fail_if_not_found) { NameData schema, table; ScanKeyData scankey[2]; static const DisplayKeyData displaykey[2] = { [0] = { .name = "schema_name", .as_string = DatumGetNameString }, [1] = { .name = "table_name", .as_string = DatumGetNameString }, }; /* Early check for rogue input */ if (schema_name == NULL || table_name == NULL) { if (fail_if_not_found) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("chunk not found"), errdetail("schema_name: %s, table_name: %s", schema_name ? schema_name : "<null>", table_name ? table_name : "<null>"))); else return NULL; } namestrcpy(&schema, schema_name); namestrcpy(&table, table_name); /* * Check that the table actually exists and get a lock, unless no lock * requested. */ if (chunk_lockmode != NoLock) { RangeVar *rv = makeRangeVar(NameStr(schema), NameStr(table), -1); Relation rel = table_openrv_extended(rv, chunk_lockmode, true); if (!rel) { if (fail_if_not_found) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("chunk not found"), errdetail("schema_name: %s, table_name: %s", schema_name, table_name))); return NULL; } table_close(rel, NoLock); } /* * Perform an index scan on chunk name. */ ScanKeyInit(&scankey[0], Anum_chunk_schema_name_idx_schema_name, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&schema)); ScanKeyInit(&scankey[1], Anum_chunk_schema_name_idx_table_name, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&table)); return chunk_scan_find(CHUNK_SCHEMA_NAME_INDEX, scankey, 2, mctx, chunk_lockmode, slice_lock, fail_if_not_found, displaykey); } Chunk * ts_chunk_get_by_relid_locked(Oid relid, LOCKMODE chunk_lockmode, bool fail_if_not_found) { char *schema; char *table; ScanTupLock slice_lock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; if (!OidIsValid(relid)) { if (fail_if_not_found) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("invalid Oid"))); else return NULL; } schema = get_namespace_name(get_rel_namespace(relid)); table = get_rel_name(relid); return chunk_get_by_name(schema, table, chunk_lockmode, &slice_lock, fail_if_not_found); } Chunk * ts_chunk_get_by_relid(Oid relid, bool fail_if_not_found) { return ts_chunk_get_by_relid_locked(relid, NoLock, fail_if_not_found); } void ts_chunk_free(Chunk *chunk) { if (chunk->cube) { ts_hypercube_free(chunk->cube); } if (chunk->constraints) { ChunkConstraints *c = chunk->constraints; pfree(c->constraints); pfree(c); } pfree(chunk); } static const char * DatumGetInt32AsString(Datum datum) { char *buf = (char *) palloc(12); /* sign, 10 digits, '\0' */ pg_ltoa(DatumGetInt32(datum), buf); return buf; } Chunk * ts_chunk_get_by_id_with_slice_lock(int32 id, LOCKMODE chunk_lockmode, const ScanTupLock *slice_lock, bool fail_if_not_found) { ScanKeyData scankey[1]; static const DisplayKeyData displaykey[1] = { [0] = { .name = "id", .as_string = DatumGetInt32AsString }, }; /* * Perform an index scan on chunk id. */ ScanKeyInit(&scankey[0], Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(id)); return chunk_scan_find(CHUNK_ID_INDEX, scankey, 1, CurrentMemoryContext, chunk_lockmode, slice_lock, fail_if_not_found, displaykey); } Chunk * ts_chunk_get_by_id(int32 id, bool fail_if_not_found) { ScanTupLock slice_lock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; return ts_chunk_get_by_id_with_slice_lock(id, NoLock, &slice_lock, fail_if_not_found); } /* * Simple scans provide lightweight ways to access chunk information without the * overhead of getting a full chunk (i.e., no extra metadata, like constraints, * are joined in). This function forms the basis of a number of lookup functions * that, e.g., translates a chunk relid to a chunk_id, or vice versa. */ static bool chunk_simple_scan(ScanIterator *iterator, FormData_chunk *form, bool missing_ok, const DisplayKeyData displaykey[]) { int count = 0; ts_scanner_foreach(iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(iterator); ts_chunk_formdata_fill(form, ti); if (!form->dropped) count++; } Assert(count == 0 || count == 1); if (count == 0 && !missing_ok) { int i = 0; StringInfo info = makeStringInfo(); while (i < iterator->ctx.nkeys) { appendStringInfo(info, "%s: %s", displaykey[i].name, displaykey[i].as_string(iterator->ctx.scankey[i].sk_argument)); if (++i < iterator->ctx.nkeys) appendStringInfoString(info, ", "); } ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("chunk not found"))); } return count == 1; } static bool chunk_simple_scan_by_name(const char *schema, const char *table, FormData_chunk *form, bool missing_ok) { ScanIterator iterator; static const DisplayKeyData displaykey[] = { [0] = { .name = "schema_name", .as_string = DatumGetNameString }, [1] = { .name = "table_name", .as_string = DatumGetNameString }, }; if (schema == NULL || table == NULL) return false; iterator = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); init_scan_by_qualified_table_name(&iterator, schema, table); return chunk_simple_scan(&iterator, form, missing_ok, displaykey); } bool ts_chunk_simple_scan_by_reloid(Oid reloid, FormData_chunk *form, bool missing_ok) { bool found = false; if (OidIsValid(reloid)) { const char *table = get_rel_name(reloid); if (table != NULL) { Oid nspid = get_rel_namespace(reloid); const char *schema = get_namespace_name(nspid); found = chunk_simple_scan_by_name(schema, table, form, missing_ok); } } if (!found && !missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("chunk with reloid %u not found", reloid))); return found; } static bool chunk_simple_scan_by_id(int32 chunk_id, FormData_chunk *form, bool missing_ok) { ScanIterator iterator; static const DisplayKeyData displaykey[] = { [0] = { .name = "id", .as_string = DatumGetInt32AsString }, }; iterator = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); ts_chunk_scan_iterator_set_chunk_id(&iterator, chunk_id); return chunk_simple_scan(&iterator, form, missing_ok, displaykey); } /* * Lookup a Chunk ID from a chunk's relid. */ Datum ts_chunk_id_from_relid(PG_FUNCTION_ARGS) { static Oid last_relid = InvalidOid; static int32 last_id = 0; Oid relid = PG_GETARG_OID(0); FormData_chunk form; if (last_relid == relid) return last_id; ts_chunk_simple_scan_by_reloid(relid, &form, false); last_relid = relid; last_id = form.id; PG_RETURN_INT32(last_id); } bool ts_chunk_exists_relid(Oid relid) { FormData_chunk form; return ts_chunk_simple_scan_by_reloid(relid, &form, true); } /* * Returns 0 if there is no chunk with such reloid. */ int32 ts_chunk_get_hypertable_id_by_reloid(Oid reloid) { FormData_chunk form; if (ts_chunk_simple_scan_by_reloid(reloid, &form, /* missing_ok = */ true)) { return form.hypertable_id; } return 0; } FormData_chunk ts_chunk_get_formdata(int32 chunk_id) { FormData_chunk fd; chunk_simple_scan_by_id(chunk_id, &fd, /* missing_ok = */ false); return fd; } /* * Get the relid of a chunk given its ID. */ Oid ts_chunk_get_relid(int32 chunk_id, bool missing_ok) { FormData_chunk form = { 0 }; Oid relid = InvalidOid; if (chunk_simple_scan_by_id(chunk_id, &form, missing_ok)) relid = ts_get_relation_relid(NameStr(form.schema_name), NameStr(form.table_name), true); if (!OidIsValid(relid) && !missing_ok) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_SCHEMA), errmsg("chunk with id %d not found", chunk_id))); return relid; } /* * Get the schema (namespace) of a chunk given its ID. * * This is a lightweight way to get the schema of a chunk without creating a * full Chunk object that joins in constraints, etc. */ Oid ts_chunk_get_schema_id(int32 chunk_id, bool missing_ok) { FormData_chunk form = { 0 }; if (!chunk_simple_scan_by_id(chunk_id, &form, missing_ok)) return InvalidOid; return get_namespace_oid(NameStr(form.schema_name), missing_ok); } bool ts_chunk_get_id(const char *schema, const char *table, int32 *chunk_id, bool missing_ok) { FormData_chunk form = { 0 }; if (!chunk_simple_scan_by_name(schema, table, &form, missing_ok)) return false; if (NULL != chunk_id) *chunk_id = form.id; return true; } /* * Results of deleting a chunk. * * A chunk can be deleted in two ways: (1) full delete of data and metadata, * (2) delete data but preserve metadata (marked with dropped=true). The * deletion mode (preserve or not) combined with the current state of the * "dropped" flag on a chunk metadata row leads to a cross-product resulting * in the following outcomes: */ typedef enum ChunkDeleteResult { /* Deleted a live chunk */ CHUNK_DELETED, /* Deleted a chunk previously marked "dropped" */ CHUNK_DELETED_DROPPED, /* Marked a chunk as dropped instead of deleting */ CHUNK_MARKED_DROPPED, /* Tried to mark a chunk as dropped when it was already marked */ CHUNK_ALREADY_MARKED_DROPPED, } ChunkDeleteResult; /* Delete the chunk tuple. * * relid: Required when deleting via an event trigger hook, because at that * point the relation is gone and it is no longer possible to resolve the Oid * from the PG catalog. * * preserve_chunk_catalog_row - instead of deleting the row, mark it as dropped. * this is used when we need to preserve catalog information about the chunk * after dropping it. Currently only used when preserving continuous aggregates * on the chunk after the raw data was dropped. Otherwise, we'd have dangling * chunk ids left over in the materialization table. Preserve the space dimension * info about these chunks too. * * When chunk rows are preserved, the rows need to be updated to set the * 'dropped' flag to TRUE. But since this produces a new tuple into the * metadata table we will process also the new tuple in the same loop, which * is not only inefficient but could also lead to bugs. For now, we just ignore * those tuples (the CHUNK_ALREADY_MARKED_DROPPED case), but ideally we * shouldn't scan the updated tuples at all since it means double the number * of tuples to process. */ static ChunkDeleteResult chunk_tuple_delete(TupleInfo *ti, Oid relid, DropBehavior behavior, bool preserve_chunk_catalog_row, bool detach) { FormData_chunk form; CatalogSecurityContext sec_ctx; ChunkDeleteResult res; int i; ts_chunk_formdata_fill(&form, ti); if (preserve_chunk_catalog_row && form.dropped) return CHUNK_ALREADY_MARKED_DROPPED; /* if only marking as deleted, keep the constraints and dimension info */ if (!preserve_chunk_catalog_row) { ChunkConstraints *ccs; /* * Do not drop any constraint if detaching * We will still need to delete dimension slices for the chunk */ ccs = ts_chunk_constraints_alloc(2, ti->mctx); ts_chunk_constraint_delete_dimensional_constraints(form.id, ccs); ts_chunk_constraint_delete_by_chunk_id(form.id, ccs, !detach); /* Check for dimension slices that are orphaned by the chunk deletion */ for (i = 0; i < ccs->num_constraints; i++) { ChunkConstraint *cc = &ccs->constraints[i]; /* * Delete the dimension slice if there are no remaining constraints * referencing it */ if (is_dimension_constraint(cc)) { /* * Dimension slices are shared between chunk constraints and * subsequently between chunks as well. Since different chunks * can reference the same dimension slice (through the chunk * constraint), we must lock the dimension slice in FOR UPDATE * mode *prior* to scanning the chunk constraints table. If we * do not do that, we can have the following scenario: * * - T1: Prepares to create a chunk that uses an existing dimension slice X * - T2: Deletes a chunk and dimension slice X because it is not * references by a chunk constraint. * - T1: Adds a chunk constraint referencing dimension * slice X (which is about to be deleted by T2). */ ScanTupLock tuplock = { .lockmode = LockTupleExclusive, .waitpolicy = LockWaitBlock }; DimensionSlice *slice = ts_dimension_slice_scan_by_id_and_lock(cc->fd.dimension_slice_id, &tuplock, CurrentMemoryContext, AccessShareLock); /* If the slice is not found in the scan above, the table is * broken so we do not delete the slice. We proceed * anyway since users need to be able to drop broken tables or * remove broken chunks. */ if (!slice) { const Hypertable *const ht = ts_hypertable_get_by_id(form.hypertable_id); ereport(WARNING, (errmsg("unexpected state for chunk %s.%s, dropping anyway", quote_identifier(NameStr(form.schema_name)), quote_identifier(NameStr(form.table_name))), errdetail("The integrity of hypertable %s.%s might be " "compromised " "since one of its chunks lacked a dimension slice.", quote_identifier(NameStr(ht->fd.schema_name)), quote_identifier(NameStr(ht->fd.table_name))))); } else if (ts_chunk_constraint_scan_by_dimension_slice_id(slice->fd.id, NULL, CurrentMemoryContext) == 0) ts_dimension_slice_delete_by_id(cc->fd.dimension_slice_id, false); } } } /* * Even tough we keep foreign key constraints on the chunk, we still * need to drop the referencing foreign keys since such keys are possibly * intended to reference the hypertable, not the chunk. */ if (detach) ts_chunk_drop_referencing_fk_by_chunk_id(form.id); ts_compression_chunk_size_delete(form.id); /* Delete any row in bgw_policy_chunk-stats corresponding to this chunk */ ts_bgw_policy_chunk_stats_delete_by_chunk_id(form.id); /* Delete any rows in _timescaledb_catalog.chunk_column_stats corresponding to this chunk */ ts_chunk_column_stats_delete_by_chunk_id(form.id); if (!OidIsValid(relid)) { /* * If the chunk is deleted as a result of deleting the Hypertable, and * it is cleaned up in the DROP eventtrigger hook, it might not be * possible to resolve the relid because the relation is already gone * in pg_catalog. But that's OK, because compression settings will be * cleaned up when processing the eventtrigger. */ relid = ts_get_relation_relid(NameStr(form.schema_name), NameStr(form.table_name), true); } if (form.compressed_chunk_id != INVALID_CHUNK_ID) { Chunk *compressed_chunk = ts_chunk_get_by_id(form.compressed_chunk_id, false); if (OidIsValid(relid)) ts_compression_settings_delete(relid); /* The chunk may have been deleted by a CASCADE */ if (compressed_chunk != NULL) { /* Plain drop without preserving catalog row because this is the compressed * chunk */ ts_chunk_drop(compressed_chunk, behavior, DEBUG1); } } else if (OidIsValid(relid)) { /* If there is no compressed chunk ID, this might be the actual * compressed chunk */ ts_compression_settings_delete_by_compress_relid(relid); } ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); if (!preserve_chunk_catalog_row) { ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); if (form.dropped) res = CHUNK_DELETED_DROPPED; else res = CHUNK_DELETED; } else { HeapTuple new_tuple; Assert(!form.dropped); form.compressed_chunk_id = INVALID_CHUNK_ID; form.dropped = true; form.status = CHUNK_STATUS_DEFAULT; new_tuple = chunk_formdata_make_tuple(&form, ts_scanner_get_tupledesc(ti)); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); heap_freetuple(new_tuple); res = CHUNK_MARKED_DROPPED; } ts_catalog_restore_user(&sec_ctx); return res; } static void init_scan_by_qualified_table_name(ScanIterator *iterator, const char *schema_name, const char *table_name) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_SCHEMA_NAME_INDEX); ts_scan_iterator_scan_key_init(iterator, Anum_chunk_schema_name_idx_schema_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(schema_name)); ts_scan_iterator_scan_key_init(iterator, Anum_chunk_schema_name_idx_table_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(table_name)); } static int chunk_delete(ScanIterator *iterator, Oid relid, DropBehavior behavior, bool preserve_chunk_catalog_row, bool detach) { int count = 0; ts_scanner_foreach(iterator) { ChunkDeleteResult res; res = chunk_tuple_delete(ts_scan_iterator_tuple_info(iterator), relid, behavior, preserve_chunk_catalog_row, detach); switch (res) { case CHUNK_DELETED: case CHUNK_MARKED_DROPPED: count++; break; case CHUNK_ALREADY_MARKED_DROPPED: case CHUNK_DELETED_DROPPED: break; } } return count; } static int ts_chunk_delete_by_name_internal(const char *schema, const char *table, Oid relid, DropBehavior behavior, bool preserve_chunk_catalog_row) { ScanIterator iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); int count; init_scan_by_qualified_table_name(&iterator, schema, table); count = chunk_delete(&iterator, relid, behavior, preserve_chunk_catalog_row, false); /* (schema,table) names and (hypertable_id) are unique so should only have * dropped one chunk or none (if not found) */ Assert(count == 1 || count == 0); return count; } int ts_chunk_delete_by_name(const char *schema, const char *table, DropBehavior behavior) { Oid relid = ts_get_relation_relid(schema, table, false); return ts_chunk_delete_by_name_internal(schema, table, relid, behavior, false); } int ts_chunk_delete_by_relid_and_relname(Oid relid, const char *schemaname, const char *tablename, DropBehavior behavior, bool preserve_chunk_catalog_row) { if (!OidIsValid(relid)) return 0; return ts_chunk_delete_by_name_internal(schemaname, tablename, relid, behavior, preserve_chunk_catalog_row); } static void init_scan_by_hypertable_id(ScanIterator *iterator, int32 hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_HYPERTABLE_ID_INDEX); ts_scan_iterator_scan_key_init(iterator, Anum_chunk_hypertable_id_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); } int ts_chunk_delete_by_hypertable_id(int32 hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); init_scan_by_hypertable_id(&iterator, hypertable_id); return chunk_delete(&iterator, InvalidOid, DROP_RESTRICT, false, false); } bool ts_chunk_exists_with_compression(int32 hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); bool found = false; init_scan_by_hypertable_id(&iterator, hypertable_id); ts_scanner_foreach(&iterator) { bool isnull_dropped; bool isnull_chunk_id = slot_attisnull(ts_scan_iterator_slot(&iterator), Anum_chunk_compressed_chunk_id); bool dropped = DatumGetBool( slot_getattr(ts_scan_iterator_slot(&iterator), Anum_chunk_dropped, &isnull_dropped)); /* dropped is not NULLABLE */ Assert(!isnull_dropped); if (!isnull_chunk_id && !dropped) { found = true; break; } } ts_scan_iterator_close(&iterator); return found; } static void init_scan_by_compressed_chunk_id(ScanIterator *iterator, int32 compressed_chunk_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_COMPRESSED_CHUNK_ID_INDEX); ts_scan_iterator_scan_key_init(iterator, Anum_chunk_compressed_chunk_id_idx_compressed_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(compressed_chunk_id)); } Chunk * ts_chunk_get_compressed_chunk_parent(const Chunk *chunk) { ScanIterator iterator = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); Oid parent_id = InvalidOid; init_scan_by_compressed_chunk_id(&iterator, chunk->fd.id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Datum datum; bool isnull; Assert(!OidIsValid(parent_id)); datum = slot_getattr(ti->slot, Anum_chunk_id, &isnull); if (!isnull) parent_id = DatumGetObjectId(datum); } if (OidIsValid(parent_id)) return ts_chunk_get_by_id(parent_id, true); return NULL; } bool ts_chunk_contains_compressed_data(const Chunk *chunk) { Chunk *parent_chunk = ts_chunk_get_compressed_chunk_parent(chunk); return parent_chunk != NULL; } List * ts_chunk_get_chunk_ids_by_hypertable_id(int32 hypertable_id) { List *chunkids = NIL; ScanIterator iterator = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); init_scan_by_hypertable_id(&iterator, hypertable_id); ts_scanner_foreach(&iterator) { bool isnull; Datum id = slot_getattr(ts_scan_iterator_slot(&iterator), Anum_chunk_id, &isnull); if (!isnull) chunkids = lappend_int(chunkids, DatumGetInt32(id)); } return chunkids; } /* Return list of chunks that belong to the given hypertable. * * The returned chunk objects will not have any constraints or dimension * information filled in. */ List * ts_chunk_get_by_hypertable_id(int32 hypertable_id) { List *chunks = NIL; Oid hypertable_relid = ts_hypertable_id_to_relid(hypertable_id, false); ScanIterator iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); init_scan_by_hypertable_id(&iterator, hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Chunk *chunk = palloc0(sizeof(Chunk)); ts_chunk_formdata_fill(&chunk->fd, ti); chunk->hypertable_relid = hypertable_relid; if (!chunk->fd.dropped) { chunk->table_id = ts_get_relation_relid(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), false); } chunks = lappend(chunks, chunk); } return chunks; } static ChunkResult chunk_recreate_constraint(ChunkScanCtx *ctx, ChunkStub *stub) { ChunkStubScanCtx stubctx = { .stub = stub, }; Chunk *chunk = chunk_create_from_stub(&stubctx); if (stubctx.is_dropped) elog(ERROR, "should not be recreating constraints on dropped chunks"); ts_chunk_constraints_recreate(ctx->ht, chunk); return CHUNK_PROCESSED; } void ts_chunk_recreate_all_constraints_for_dimension(Hypertable *ht, int32 dimension_id) { DimensionVec *slices; ChunkScanCtx chunkctx; int i; slices = ts_dimension_slice_scan_by_dimension(dimension_id, 0); if (NULL == slices) return; chunk_scan_ctx_init(&chunkctx, ht, NULL); for (i = 0; i < slices->num_slices; i++) ts_chunk_constraint_scan_by_dimension_slice(slices->slices[i], &chunkctx, CurrentMemoryContext); chunk_scan_ctx_foreach_chunk_stub(&chunkctx, chunk_recreate_constraint, 0); chunk_scan_ctx_destroy(&chunkctx); } /* * Chunk catalog updates are done in three steps. * This is achieved by following this sequence: * 1: call lock_chunk_tuple: this finds most recent version of tuple, * locks it, fills TID and data * 2: make changes to the data * 3: call chunk_update_catalog_tuple with the TID and updated data * * This is equivalent to SELECT for UPDATE, followed by UPDATE * * All callers who want to update chunk tuples should respect this so that locks * are acquired correctly. * */ static void chunk_update_catalog_tuple(ItemPointer tid, FormData_chunk *update) { HeapTuple new_tuple; CatalogSecurityContext sec_ctx; Catalog *catalog = ts_catalog_get(); Oid table = catalog_get_table_id(catalog, CHUNK); Relation chunk_rel = relation_open(table, RowExclusiveLock); new_tuple = chunk_formdata_make_tuple(update, chunk_rel->rd_att); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(chunk_rel, tid, new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); relation_close(chunk_rel, NoLock); } /* * This function locks the timescaledb_catalog.chunk tuple (corresponding to chunk_id ) in * LockTupleExclusiveMode. It blocks till the lock is acquired. The tid and data (corresponding to * the locked tuple) are returned via tid and form arguments. Anyone updating/deleting a chunk entry * from the catalog table is expected to first call this function. Refer to * chunk_update_catalog_tuple() for more details. */ static bool lock_chunk_tuple(int32 chunk_id, ItemPointer tid, FormData_chunk *form) { ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; ScanIterator iterator = ts_scan_iterator_create(CHUNK, RowShareLock, CurrentMemoryContext); iterator.ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_ID_INDEX); iterator.ctx.tuplock = &scantuplock; /* Keeping the lock since we presumably want to update the tuple */ iterator.ctx.flags = SCANNER_F_KEEPLOCK; /* see table_tuple_lock for details about flags that are set in TupleExclusive mode */ scantuplock.lockflags = TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS; if (!IsolationUsesXactSnapshot()) { /* in read committed mode, we follow all updates to this tuple */ scantuplock.lockflags |= TUPLE_LOCK_FLAG_FIND_LAST_VERSION; } ts_scan_iterator_scan_key_init(&iterator, Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); bool success = false; bool dropped, dropped_isnull; ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); if (ti->lockresult != TM_Ok) { if (IsolationUsesXactSnapshot()) { /* For Repeatable Read and Serializable isolation level report error * if we cannot lock the tuple */ ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); } else { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("unable to lock chunk catalog tuple, lock result is %d for chunk " "ID (%d)", ti->lockresult, chunk_id))); } } dropped = DatumGetBool(slot_getattr(ti->slot, Anum_chunk_dropped, &dropped_isnull)); Assert(!dropped_isnull); if (!dropped) { ts_chunk_formdata_fill(form, ti); ItemPointer result_tid = ts_scanner_get_tuple_tid(ti); tid->ip_blkid = result_tid->ip_blkid; tid->ip_posid = result_tid->ip_posid; success = true; break; } } ts_scan_iterator_close(&iterator); return success; } bool ts_chunk_set_name(Chunk *chunk, const char *newname) { FormData_chunk form; ItemPointerData tid; bool PG_USED_FOR_ASSERTS_ONLY found; found = lock_chunk_tuple(chunk->fd.id, &tid, &form); Assert(found); namestrcpy(&form.table_name, newname); chunk_update_catalog_tuple(&tid, &form); return true; } bool ts_chunk_set_schema(Chunk *chunk, const char *newschema) { FormData_chunk form; ItemPointerData tid; bool PG_USED_FOR_ASSERTS_ONLY found; found = lock_chunk_tuple(chunk->fd.id, &tid, &form); Assert(found); namestrcpy(&form.schema_name, newschema); chunk_update_catalog_tuple(&tid, &form); return true; } bool ts_chunk_set_unordered(Chunk *chunk) { Assert(ts_chunk_is_compressed(chunk)); return ts_chunk_add_status(chunk, CHUNK_STATUS_COMPRESSED_UNORDERED); } bool ts_chunk_set_partial(Chunk *chunk) { bool set_status; Assert(ts_chunk_is_compressed(chunk)); set_status = ts_chunk_add_status(chunk, CHUNK_STATUS_COMPRESSED_PARTIAL); if (set_status) { /* * If the status was set then convert the corresponding * _timescaledb_catalog.chunk_column_stats entries "INVALID". */ ts_chunk_column_stats_set_invalid(chunk->fd.hypertable_id, chunk->fd.id); /* changed chunk status, so invalidate plans involving this chunk */ CacheInvalidateRelcacheByRelid(chunk->table_id); } return set_status; } /* No inserts, updates, and deletes are permitted on a frozen chunk. * Compression policies etc do not run on a frozen chunk. * Only valid operation is dropping the chunk */ bool ts_chunk_set_frozen(Chunk *chunk) { return ts_chunk_add_status(chunk, CHUNK_STATUS_FROZEN); } bool ts_chunk_unset_frozen(Chunk *chunk) { return ts_chunk_clear_status(chunk, CHUNK_STATUS_FROZEN); } bool ts_chunk_is_frozen(const Chunk *chunk) { return ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_FROZEN); } /* only caller used to be ts_chunk_unset_frozen. This code was in PG14 block as we run into * a "defined but unset" error in CI/CD builds for PG < 14. But now called from recompress as well */ bool ts_chunk_clear_status(Chunk *chunk, int32 status) { /* only frozen status can be cleared for a frozen chunk */ if (status != CHUNK_STATUS_FROZEN && ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to clear status %d , current status %x ", chunk->fd.id, status, chunk->fd.status))); } FormData_chunk form; ItemPointerData tid; bool PG_USED_FOR_ASSERTS_ONLY found; found = lock_chunk_tuple(chunk->fd.id, &tid, &form); Assert(found); /* applying the flags after locking the metadata tuple */ int32 old_status = form.status; form.status = ts_clear_flags_32(form.status, status); chunk->fd.status = form.status; /* Row-level locks are released at transaction end or during savepoint rollback */ if (old_status != form.status) chunk_update_catalog_tuple(&tid, &form); return true; } static bool ts_chunk_add_status(Chunk *chunk, int32 status) { bool status_set = false; if (ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to set status %d , current status %x ", chunk->fd.id, status, chunk->fd.status))); } FormData_chunk form; ItemPointerData tid; bool PG_USED_FOR_ASSERTS_ONLY found; found = lock_chunk_tuple(chunk->fd.id, &tid, &form); Assert(found); /* Somebody could update the status before we are able to lock it so check again */ if (ts_flags_are_set_32(form.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to set status %d , current status %d ", chunk->fd.id, status, form.status))); } /* applying the flags after locking the metadata tuple */ int32 old_status = form.status; form.status = ts_set_flags_32(form.status, status); chunk->fd.status = form.status; /* Row-level locks are released at transaction end or during savepoint rollback */ if (old_status != form.status) { chunk_update_catalog_tuple(&tid, &form); status_set = true; } return status_set; } /*Assume permissions are already checked */ bool ts_chunk_set_compressed_chunk(Chunk *chunk, int32 compressed_chunk_id) { uint32 flags = CHUNK_STATUS_COMPRESSED; uint32 mstatus = ts_set_flags_32(chunk->fd.status, flags); if (ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to set status %d , current status %d ", chunk->fd.id, mstatus, chunk->fd.status))); } FormData_chunk form; ItemPointerData tid; bool PG_USED_FOR_ASSERTS_ONLY found; found = lock_chunk_tuple(chunk->fd.id, &tid, &form); Assert(found); /* Somebody could update the status before we are able to lock it so check again */ if (ts_flags_are_set_32(form.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to set status %d , current status %d ", chunk->fd.id, mstatus, form.status))); } /* re-applying the flags after locking the metadata tuple */ form.status = ts_set_flags_32(form.status, flags); form.compressed_chunk_id = compressed_chunk_id; chunk->fd.compressed_chunk_id = form.compressed_chunk_id; chunk->fd.status = form.status; chunk_update_catalog_tuple(&tid, &form); return true; } /*Assume permissions are already checked */ bool ts_chunk_clear_compressed_chunk(Chunk *chunk) { uint32 flags = CHUNK_STATUS_COMPRESSED | CHUNK_STATUS_COMPRESSED_UNORDERED | CHUNK_STATUS_COMPRESSED_PARTIAL; uint32 mstatus = ts_clear_flags_32(chunk->fd.status, flags); if (ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to set status %d , current status %d ", chunk->fd.id, mstatus, chunk->fd.status))); } FormData_chunk form; ItemPointerData tid; bool PG_USED_FOR_ASSERTS_ONLY found; found = lock_chunk_tuple(chunk->fd.id, &tid, &form); Assert(found); /* Somebody could update the status before we are able to lock it so check again */ if (ts_flags_are_set_32(form.status, CHUNK_STATUS_FROZEN)) { /* chunk in frozen state cannot be modified */ ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot modify frozen chunk status"), errdetail("chunk id = %d attempt to set status %d , current status %d ", chunk->fd.id, mstatus, form.status))); } /* re-applying the flags after locking the metadata tuple */ form.status = ts_clear_flags_32(form.status, flags); form.compressed_chunk_id = INVALID_CHUNK_ID; chunk->fd.compressed_chunk_id = form.compressed_chunk_id; chunk->fd.status = form.status; chunk_update_catalog_tuple(&tid, &form); return true; } /* Used as a tuple found function */ static ScanTupleResult chunk_rename_schema_name(TupleInfo *ti, void *data) { FormData_chunk form; HeapTuple new_tuple; CatalogSecurityContext sec_ctx; ts_chunk_formdata_fill(&form, ti); /* Rename schema name */ namestrcpy(&form.schema_name, (char *) data); new_tuple = chunk_formdata_make_tuple(&form, ts_scanner_get_tupledesc(ti)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); return SCAN_CONTINUE; } /* Go through the internal chunk table and rename all matching schemas */ void ts_chunks_rename_schema_name(char *old_schema, char *new_schema) { NameData old_schema_name; ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CHUNK), .index = catalog_get_index(catalog, CHUNK, CHUNK_SCHEMA_NAME_INDEX), .nkeys = 1, .scankey = scankey, .tuple_found = chunk_rename_schema_name, .data = new_schema, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; namestrcpy(&old_schema_name, old_schema); ScanKeyInit(&scankey[0], Anum_chunk_schema_name_idx_schema_name, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&old_schema_name)); ts_scanner_scan(&scanctx); } static int chunk_cmp(const void *ch1, const void *ch2) { const Chunk *v1 = ((const Chunk *) ch1); const Chunk *v2 = ((const Chunk *) ch2); if (v1->fd.hypertable_id < v2->fd.hypertable_id) return -1; if (v1->fd.hypertable_id > v2->fd.hypertable_id) return 1; if (v1->table_id < v2->table_id) return -1; if (v1->table_id > v2->table_id) return 1; return 0; } /* * This is a helper set returning function (SRF) that takes a set returning function context * and as argument and returns oids extracted from funcctx->user_fctx (which is Chunk* * array). Note that the caller needs to be registered as a set returning function for this * to work. */ static Datum show_chunks_return_srf(FunctionCallInfo fcinfo) { FuncCallContext *funcctx; uint64 call_cntr; TupleDesc tupdesc; Chunk *result_set; Chunk *curr_chunk; /* stuff done only on the first call of the function */ if (SRF_IS_FIRSTCALL()) { /* Build a tuple descriptor for our result type */ /* not quite necessary */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_SCALAR) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); } /* stuff done on every call of the function */ funcctx = SRF_PERCALL_SETUP(); call_cntr = funcctx->call_cntr; result_set = (Chunk *) funcctx->user_fctx; /* * skip if it's an OSM chunk. Ideally this check could be done deep down in * functions like "chunk_scan_context_add_chunk", "chunk_tuple_dropped_filter" * etc. but they are used by other APIs like drop_chunks, chunk_scan_find, etc * which need access to the OSM chunk. Trying to unify scan functions across * all such usages seems to be too much of an overhaul as compared to this. * * Check the index appropriately first. */ if (call_cntr < funcctx->max_calls) { curr_chunk = &result_set[call_cntr]; if (IS_OSM_CHUNK(curr_chunk)) { call_cntr = ++funcctx->call_cntr; } } /* do when there is more left to send */ if (call_cntr < funcctx->max_calls) SRF_RETURN_NEXT(funcctx, result_set[call_cntr].table_id); else /* do when there is no more left */ SRF_RETURN_DONE(funcctx); } static void ts_chunk_drop_internal(const Chunk *chunk, DropBehavior behavior, int32 log_level, bool preserve_catalog_row) { ObjectAddress objaddr = { .classId = RelationRelationId, .objectId = chunk->table_id, }; if (log_level >= 0) elog(log_level, "dropping chunk %s.%s", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); /* Remove the chunk from the chunk table */ ts_chunk_delete_by_relid_and_relname(chunk->table_id, NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), behavior, preserve_catalog_row); /* Drop the table */ performDeletion(&objaddr, behavior, 0); } void ts_chunk_drop(const Chunk *chunk, DropBehavior behavior, int32 log_level) { ts_chunk_drop_internal(chunk, behavior, log_level, false); } void ts_chunk_drop_preserve_catalog_row(const Chunk *chunk, DropBehavior behavior, int32 log_level) { ts_chunk_drop_internal(chunk, behavior, log_level, true); } static void lock_referenced_tables(Oid table_relid) { List *fk_relids = NIL; ListCell *lf; List *cachedfkeys = NIL; Relation table_rel = table_open(table_relid, AccessShareLock); /* this list is from the relcache and can disappear with a cache flush, so * no further catalog access till we save the fk relids */ cachedfkeys = RelationGetFKeyList(table_rel); foreach (lf, cachedfkeys) { ForeignKeyCacheInfo *cachedfk = lfirst_node(ForeignKeyCacheInfo, lf); /* conrelid should always be that of the table we're considering */ Assert(cachedfk->conrelid == RelationGetRelid(table_rel)); fk_relids = lappend_oid(fk_relids, cachedfk->confrelid); } table_close(table_rel, AccessShareLock); foreach (lf, fk_relids) LockRelationOid(lfirst_oid(lf), AccessExclusiveLock); } List * ts_chunk_do_drop_chunks(Hypertable *ht, int64 older_than, int64 newer_than, int32 log_level, Oid time_type, Oid arg_type, bool older_newer) { uint64 num_chunks = 0; Chunk *chunks; const char *schema_name, *table_name; const int32 hypertable_id = ht->fd.id; bool has_continuous_aggs, is_materialization_hypertable; const MemoryContext oldcontext = CurrentMemoryContext; ScanTupLock tuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; ts_hypertable_permissions_check(ht->main_table_relid, GetUserId()); /* We have a FK between hypertable H and PAR. Hypertable H has number of * chunks C1, C2, etc. When we execute "drop table C", PG acquires locks * on C and PAR. If we have a query as "select * from hypertable", this * acquires a lock on C and PAR as well. But the order of the locks is not * the same and results in deadlocks. - github issue #865 We hope to * alleviate the problem by acquiring a lock on PAR before executing the * drop table stmt. This is not fool-proof as we could have multiple * fkrelids and the order of lock acquisition for these could differ as * well. Do not unlock - let the transaction semantics take care of it. */ lock_referenced_tables(ht->main_table_relid); is_materialization_hypertable = false; switch (ts_continuous_agg_hypertable_status(hypertable_id)) { case HypertableIsMaterialization: has_continuous_aggs = false; is_materialization_hypertable = true; break; case HypertableIsMaterializationAndRaw: has_continuous_aggs = true; is_materialization_hypertable = true; break; case HypertableIsRawTable: has_continuous_aggs = true; break; default: has_continuous_aggs = false; break; } PG_TRY(); { /* * For INTEGER type dimensions, we support querying using intervals or any * timestamp or date input. For such INTEGER dimensions, we get the chunks * using their creation time values. */ if (IS_INTEGER_TYPE(time_type) && (arg_type == INTERVALOID || IS_TIMESTAMP_TYPE(arg_type))) { chunks = get_chunks_in_creation_time_range(ht, older_than, newer_than, CurrentMemoryContext, &num_chunks, &tuplock); } else { if (!older_newer) chunks = get_chunks_in_creation_time_range(ht, older_than, newer_than, CurrentMemoryContext, &num_chunks, &tuplock); else chunks = get_chunks_in_time_range(ht, older_than, newer_than, CurrentMemoryContext, &num_chunks, &tuplock); } } PG_CATCH(); { ErrorData *edata; MemoryContextSwitchTo(oldcontext); edata = CopyErrorData(); FlushErrorState(); if (edata->sqlerrcode == ERRCODE_LOCK_NOT_AVAILABLE) { edata->detail = edata->message; edata->message = psprintf("some chunks could not be read since they are being concurrently updated"); } ReThrowError(edata); } PG_END_TRY(); DEBUG_WAITPOINT("drop_chunks_chunks_found"); int32 osm_chunk_id = ts_chunk_get_osm_chunk_id(ht->fd.id); if (has_continuous_aggs) { /* Exclusively lock all chunks, and invalidate the continuous * aggregates in the regions covered by the chunks. We do this in two * steps: first lock all the chunks and then invalidate the * regions. Since we are going to drop the chunks, there is no point * in allowing inserts into them. * * Locking prevents further modification of the dropped region during * this transaction, which allows moving the invalidation threshold * without having to worry about new invalidations while * refreshing. */ for (uint64 i = 0; i < num_chunks; i++) { LockRelationOid(chunks[i].table_id, ExclusiveLock); Assert(hyperspace_get_open_dimension(ht->space, 0)->fd.id == chunks[i].cube->slices[0]->fd.dimension_id); } DEBUG_WAITPOINT("drop_chunks_locked"); /* Invalidate the dropped region to indicate that it was modified. * * The invalidation will allow the refresh command on a continuous * aggregate to see that this region was dropped and and will * therefore be able to refresh accordingly.*/ for (uint64 i = 0; i < num_chunks; i++) { if (osm_chunk_id == chunks[i].fd.id) { // we do not rebuild continuous aggs if tiered data is dropped */ continue; } int64 start = ts_chunk_primary_dimension_start(&chunks[i]); int64 end = ts_chunk_primary_dimension_end(&chunks[i]); ts_cm_functions->continuous_agg_invalidate_raw_ht(ht, start, end); } } bool all_caggs_finalized = ts_continuous_agg_hypertable_all_finalized(hypertable_id); List *dropped_chunk_names = NIL; for (uint64 i = 0; i < num_chunks; i++) { char *chunk_name; ASSERT_IS_VALID_CHUNK(&chunks[i]); /* frozen chunks are skipped. Not dropped. */ if (!ts_chunk_validate_chunk_status_for_operation(&chunks[i], CHUNK_DROP, false /*throw_error */) || osm_chunk_id == chunks[i].fd.id) { continue; } /* store chunk name for output */ schema_name = quote_identifier(NameStr(chunks[i].fd.schema_name)); table_name = quote_identifier(NameStr(chunks[i].fd.table_name)); chunk_name = psprintf("%s.%s", schema_name, table_name); dropped_chunk_names = lappend(dropped_chunk_names, chunk_name); if (has_continuous_aggs && !all_caggs_finalized) ts_chunk_drop_preserve_catalog_row(chunks + i, DROP_RESTRICT, log_level); else ts_chunk_drop(chunks + i, DROP_RESTRICT, log_level); } // if we have tiered chunks cascade drop to tiering layer as well if (osm_chunk_id != INVALID_CHUNK_ID) { Chunk *osm_chunk = ts_chunk_get_by_id(osm_chunk_id, true); hypertable_drop_chunks_hook_type osm_drop_chunks_hook = ts_get_osm_hypertable_drop_chunks_hook(); /* * The OSM library may not be loaded at the moment if * `ts_chunk_do_drop_chunks` is called from the a background worker * (e.g. from a retention policy). We call `GetFdwRoutineByRelId` to * ensure the library is loaded. */ if (!osm_drop_chunks_hook && GetFdwRoutineByRelId(osm_chunk->table_id)) osm_drop_chunks_hook = ts_get_osm_hypertable_drop_chunks_hook(); if (osm_drop_chunks_hook) { ListCell *lc; Dimension *dim = &ht->space->dimensions[0]; /* convert to PG timestamp from timescaledb internal format */ int64 range_start = ts_internal_to_time_int64(newer_than, dim->fd.column_type); int64 range_end = ts_internal_to_time_int64(older_than, dim->fd.column_type); List *osm_dropped_names = osm_drop_chunks_hook(osm_chunk->table_id, NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), range_start, range_end); foreach (lc, osm_dropped_names) { dropped_chunk_names = lappend(dropped_chunk_names, lfirst(lc)); } } } /* When dropping chunks for a given CAgg then force set the watermark */ if (is_materialization_hypertable) { bool isnull; int64 watermark = ts_hypertable_get_open_dim_max_value(ht, 0, &isnull); ts_cagg_watermark_update(ht, watermark, isnull, true); } DEBUG_WAITPOINT("drop_chunks_end"); return dropped_chunk_names; } /* * This is a helper set returning function (SRF) that takes a set returning function context * and as argument and returns cstrings extracted from funcctx->user_fctx (which is a List). * Note that the caller needs to be registered as a set returning function for this to work. */ static Datum list_return_srf(FunctionCallInfo fcinfo) { FuncCallContext *funcctx; uint64 call_cntr; TupleDesc tupdesc; List *result_set; Datum retval; /* stuff done only on the first call of the function */ if (SRF_IS_FIRSTCALL()) { /* Build a tuple descriptor for our result type */ /* not quite necessary */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_SCALAR) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); } /* stuff done on every call of the function */ funcctx = SRF_PERCALL_SETUP(); call_cntr = funcctx->call_cntr; result_set = castNode(List, funcctx->user_fctx); /* do when there is more left to send */ if (call_cntr < funcctx->max_calls) { /* store return value and increment linked list */ retval = CStringGetTextDatum(linitial(result_set)); funcctx->user_fctx = list_delete_first(result_set); SRF_RETURN_NEXT(funcctx, retval); } else /* do when there is no more left */ SRF_RETURN_DONE(funcctx); } Datum ts_chunk_drop_single_chunk(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); char *chunk_table_name = get_rel_name(chunk_relid); char *chunk_schema_name = get_namespace_name(get_rel_namespace(chunk_relid)); ScanTupLock tuplock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; const Chunk *ch = ts_chunk_get_by_name_with_memory_context(chunk_schema_name, chunk_table_name, NoLock, &tuplock, CurrentMemoryContext, true); Assert(ch != NULL); ts_chunk_validate_chunk_status_for_operation(ch, CHUNK_DROP, true /*throw_error */); if (ts_chunk_contains_compressed_data(ch)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("dropping compressed chunks not supported"), errhint("Please drop the corresponding chunk on the uncompressed hypertable " "instead."))); /* do not drop any chunk dependencies */ ts_chunk_drop(ch, DROP_RESTRICT, LOG); PG_RETURN_BOOL(true); } Datum ts_chunk_drop_chunks(PG_FUNCTION_ARGS) { MemoryContext oldcontext; FuncCallContext *funcctx; Hypertable *ht; List *dc_temp = NIL; List *dc_names = NIL; Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); /* * Marked volatile to suppress the -Wclobbered warning. The warning is * actually incorrect because these values are not used after longjmp. */ volatile int64 older_than = PG_INT64_MAX; volatile int64 newer_than = PG_INT64_MIN; volatile int64 created_before = PG_INT64_MAX; volatile int64 created_after = PG_INT64_MIN; volatile bool older_newer = false; volatile bool before_after = false; bool verbose; int elevel; Cache *hcache; const Dimension *time_dim; Oid time_type; Oid arg_type; TS_PREVENT_FUNC_IF_READ_ONLY(); arg_type = InvalidOid; /* * When past the first call of the SRF, dropping has already been completed, * so we just return the next chunk in the list of dropped chunks. */ if (!SRF_IS_FIRSTCALL()) return list_return_srf(fcinfo); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid hypertable or continuous aggregate"), errhint("Specify a hypertable or continuous aggregate."))); /* Find either the hypertable or view, or error out if the relid is * neither. * * We should improve the printout since it can either be a proper relid * that does not refer to a hypertable or a continuous aggregate, or a * relid that does not refer to anything at all. */ hcache = ts_hypertable_cache_pin(); ht = ts_resolve_hypertable_from_table_or_cagg(hcache, relid, false); Assert(ht != NULL); time_dim = hyperspace_get_open_dimension(ht->space, 0); if (!time_dim) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("hypertable has no open partitioning dimension"))); time_type = ts_dimension_get_partition_type(time_dim); /* * Treat UUID (v7) as a timestamptz type. The expected input is an interval or absolute * timestamptz. */ if (IS_UUID_TYPE(time_type)) time_type = TIMESTAMPTZOID; /* note that arg_types will be the same for all specified "ANY" elements for a given call */ if (!PG_ARGISNULL(1)) { arg_type = get_fn_expr_argtype(fcinfo->flinfo, 1); older_than = ts_time_value_from_arg(PG_GETARG_DATUM(1), arg_type, time_type, true); older_newer = true; } if (!PG_ARGISNULL(2)) { arg_type = get_fn_expr_argtype(fcinfo->flinfo, 2); newer_than = ts_time_value_from_arg(PG_GETARG_DATUM(2), arg_type, time_type, true); older_newer = true; } /* * We cannot have a mix of [older_than/newer_than] and [created_before/created_after]. * So, check that first. Note that created_before/created_after have a type of * TIMESTAMPTZOID regardless of the partitioning type. */ if (!PG_ARGISNULL(4)) { if (older_newer) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify \"older_than\" or \"newer_than\" together with " "\"created_before\"" "or \"created_after\""), errhint("\"older_than\" and/or \"newer_than\" is recommended with " "\"time\"-like partitioning" " and \"created_before\" and/or \"created_after\" is recommended " "with \"integer\"-like" " partitioning."))); arg_type = get_fn_expr_argtype(fcinfo->flinfo, 4); /* We use the existing function for various type/conversion checks */ created_before = ts_time_value_from_arg(PG_GETARG_DATUM(4), arg_type, TIMESTAMPTZOID, false); /* convert into int64 format for comparisons */ created_before = ts_internal_to_time_int64(created_before, TIMESTAMPTZOID); before_after = true; older_than = created_before; } if (!PG_ARGISNULL(5)) { if (older_newer) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify \"older_than\" or \"newer_than\" together with " "\"created_before\"" " or \"created_after\""), errhint("\"older_than\" and/or \"newer_than\" is recommended with " "\"time\"-like partitioning" " and \"created_before\" and/or \"created_after\" is recommended " "with \"integer\"-like" " partitioning."))); arg_type = get_fn_expr_argtype(fcinfo->flinfo, 5); /* We use the existing function for various type/conversion checks */ created_after = ts_time_value_from_arg(PG_GETARG_DATUM(5), arg_type, TIMESTAMPTZOID, false); /* convert into int64 format for comparisons */ created_after = ts_internal_to_time_int64(created_after, TIMESTAMPTZOID); before_after = true; newer_than = created_after; } /* if both have not been specified then error out */ if (!older_newer && !before_after) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time range for dropping chunks"), errhint("At least one of older_than/newer_than or created_before/created_after" " must be provided."))); /* * For INTEGER type dimensions, we support querying using intervals or any * timestamp or date input. For such INTEGER dimensions, we get the chunks * using their creation time values. */ if (IS_INTEGER_TYPE(time_type) && (arg_type == INTERVALOID || IS_TIMESTAMP_TYPE(arg_type))) { /* check that we use proper inputs for such cases */ if (older_newer) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify \"older_than\" and/or \"newer_than\" for " "\"integer\"-like partitioning types"), errhint("Use \"created_before\" and/or \"created_after\" which rely on the " "chunk creation time values."))); } verbose = PG_ARGISNULL(3) ? false : PG_GETARG_BOOL(3); elevel = verbose ? INFO : DEBUG2; /* Initial multi function call setup */ funcctx = SRF_FIRSTCALL_INIT(); /* Drop chunks and store their names for return */ oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); PG_TRY(); { dc_temp = ts_chunk_do_drop_chunks(ht, older_than, newer_than, elevel, time_type, arg_type, older_newer); } PG_CATCH(); { /* An error is raised if there are dependent objects, but the original * message is not very helpful in suggesting that you should use * CASCADE (we don't support it), so we replace the hint with a more * accurate hint for our situation. */ ErrorData *edata; MemoryContextSwitchTo(oldcontext); edata = CopyErrorData(); FlushErrorState(); if (edata->sqlerrcode == ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST) edata->hint = pstrdup("Use DROP ... to drop the dependent objects."); ts_cache_release(&hcache); ReThrowError(edata); } PG_END_TRY(); ts_cache_release(&hcache); dc_names = list_concat(dc_names, dc_temp); MemoryContextSwitchTo(oldcontext); /* store data for multi function call */ funcctx->max_calls = list_length(dc_names); funcctx->user_fctx = dc_names; return list_return_srf(fcinfo); } /* Return the compression status for the chunk */ ChunkCompressionStatus ts_chunk_get_compression_status(int32 chunk_id) { ChunkCompressionStatus st = CHUNK_COMPRESS_NONE; ScanIterator iterator = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); iterator.ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_ID_INDEX); ts_scan_iterator_scan_key_init(&iterator, Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool dropped_isnull, status_isnull; Datum status; bool dropped = DatumGetBool(slot_getattr(ti->slot, Anum_chunk_dropped, &dropped_isnull)); Assert(!dropped_isnull); status = slot_getattr(ti->slot, Anum_chunk_status, &status_isnull); Assert(!status_isnull); /* Note that dropped attribute takes precedence over everything else. * We should not check status attribute for dropped chunks */ if (!dropped) { bool status_is_compressed = ts_flags_are_set_32(DatumGetInt32(status), CHUNK_STATUS_COMPRESSED); bool status_is_unordered = ts_flags_are_set_32(DatumGetInt32(status), CHUNK_STATUS_COMPRESSED_UNORDERED); bool status_is_partial = ts_flags_are_set_32(DatumGetInt32(status), CHUNK_STATUS_COMPRESSED_PARTIAL); if (status_is_compressed) { if (status_is_unordered || status_is_partial) st = CHUNK_COMPRESS_UNORDERED; else st = CHUNK_COMPRESS_ORDERED; } else { Assert(!status_is_unordered); st = CHUNK_COMPRESS_NONE; } } else st = CHUNK_DROPPED; } ts_scan_iterator_close(&iterator); return st; } /* Note that only a compressed chunk can have unordered flag set */ bool ts_chunk_is_unordered(const Chunk *chunk) { return ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_COMPRESSED_UNORDERED); } bool ts_chunk_is_compressed(const Chunk *chunk) { return ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_COMPRESSED); } bool ts_chunk_needs_recompression(const Chunk *chunk) { Assert(ts_chunk_is_compressed(chunk)); return ts_chunk_is_partial(chunk) || ts_chunk_is_unordered(chunk); } /* Note that only a compressed chunk can have partial flag set */ bool ts_chunk_is_partial(const Chunk *chunk) { return ts_flags_are_set_32(chunk->fd.status, CHUNK_STATUS_COMPRESSED_PARTIAL); } static const char * get_chunk_operation_str(ChunkOperation cmd) { switch (cmd) { case CHUNK_INSERT: return "Insert"; case CHUNK_DELETE: return "Delete"; case CHUNK_UPDATE: return "Update"; case CHUNK_COMPRESS: return "compress_chunk"; case CHUNK_DECOMPRESS: return "decompress_chunk"; case CHUNK_DROP: return "drop_chunk"; default: return "Unsupported"; } } bool ts_chunk_validate_chunk_status_for_operation(const Chunk *chunk, ChunkOperation cmd, bool throw_error) { Oid chunk_relid = chunk->table_id; int32 chunk_status = chunk->fd.status; /* * Block everything but DELETE on OSM chunks. */ if (chunk->fd.osm_chunk) { switch (cmd) { case CHUNK_DROP: return true; break; default: if (throw_error) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("%s not permitted on tiered chunk \"%s\" ", get_chunk_operation_str(cmd), get_rel_name(chunk_relid)))); return false; break; } } /* Handle frozen chunks */ if (ts_flags_are_set_32(chunk_status, CHUNK_STATUS_FROZEN)) { /* Data modification is not permitted on a frozen chunk */ switch (cmd) { case CHUNK_INSERT: case CHUNK_DELETE: case CHUNK_UPDATE: case CHUNK_COMPRESS: case CHUNK_DECOMPRESS: case CHUNK_DROP: { if (throw_error) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("%s not permitted on frozen chunk \"%s\" ", get_chunk_operation_str(cmd), get_rel_name(chunk_relid)))); return false; break; } default: break; /*supported operations */ } } /* Handle unfrozen chunks */ else { switch (cmd) { /* supported operations */ case CHUNK_INSERT: case CHUNK_DELETE: case CHUNK_UPDATE: break; /* Only uncompressed chunks can be compressed */ case CHUNK_COMPRESS: { if (ts_flags_are_set_32(chunk_status, CHUNK_STATUS_COMPRESSED)) ereport((throw_error ? ERROR : NOTICE), (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("chunk \"%s\" is already compressed", get_rel_name(chunk_relid)))); return false; } /* Only compressed chunks can be decompressed */ case CHUNK_DECOMPRESS: { if (!ts_flags_are_set_32(chunk_status, CHUNK_STATUS_COMPRESSED)) ereport((throw_error ? ERROR : NOTICE), (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("chunk \"%s\" is already decompressed", get_rel_name(chunk_relid)))); return false; } default: break; } } return true; } Datum ts_chunk_show(PG_FUNCTION_ARGS) { return ts_cm_functions->show_chunk(fcinfo); } Datum ts_chunk_create(PG_FUNCTION_ARGS) { return ts_cm_functions->create_chunk(fcinfo); } /** * Get the chunk status. * * Values returned are documented above and is a bitwise or of the * CHUNK_STATUS_XXX values. * * @see CHUNK_STATUS_DEFAULT * @see CHUNK_STATUS_COMPRESSED * @see CHUNK_STATUS_COMPRESSED_UNORDERED * @see CHUNK_STATUS_FROZEN * @see CHUNK_STATUS_COMPRESSED_PARTIAL */ Datum ts_chunk_status(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_GETARG_OID(0); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, /* fail_if_not_found */ true); PG_RETURN_INT32(chunk->fd.status); } TS_FUNCTION_INFO_V1(ts_chunk_status_text); Datum ts_chunk_status_text(PG_FUNCTION_ARGS) { int32 status = PG_GETARG_INT32(0); ArrayBuildState *astate = initArrayResult(TEXTOID, CurrentMemoryContext, false); if (status & CHUNK_STATUS_COMPRESSED) astate = accumArrayResult(astate, CStringGetTextDatum("COMPRESSED"), false, TEXTOID, CurrentMemoryContext); if (status & CHUNK_STATUS_COMPRESSED_UNORDERED) astate = accumArrayResult(astate, CStringGetTextDatum("UNORDERED"), false, TEXTOID, CurrentMemoryContext); if (status & CHUNK_STATUS_FROZEN) astate = accumArrayResult(astate, CStringGetTextDatum("FROZEN"), false, TEXTOID, CurrentMemoryContext); if (status & CHUNK_STATUS_COMPRESSED_PARTIAL) astate = accumArrayResult(astate, CStringGetTextDatum("PARTIAL"), false, TEXTOID, CurrentMemoryContext); if (status < 0 || status > (CHUNK_STATUS_COMPRESSED | CHUNK_STATUS_COMPRESSED_UNORDERED | CHUNK_STATUS_FROZEN | CHUNK_STATUS_COMPRESSED_PARTIAL)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid chunk status %d", status))); PG_RETURN_DATUM(makeArrayResult(astate, CurrentMemoryContext)); } /* * Lock the chunk if the lockmode demands it. * * Also check that the chunk relation actually exists after the lock is * acquired. Return true if no locking is necessary or the chunk relation * exists and the lock was successfully acquired. Otherwise return false. */ bool ts_chunk_lock_if_exists(Oid chunk_oid, LOCKMODE chunk_lockmode) { /* No lock is requested, so assume relation exists */ if (chunk_lockmode != NoLock) { /* Get the lock to synchronize against concurrent drop */ LockRelationOid(chunk_oid, chunk_lockmode); /* * Now that we have the lock, double-check to see if the relation * really exists or not. If not, assume it was dropped while we * waited to acquire lock, and ignore it. */ if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(chunk_oid))) { /* Release useless lock */ UnlockRelationOid(chunk_oid, chunk_lockmode); /* And ignore this relation */ return false; } } return true; } ScanIterator ts_chunk_scan_iterator_create(MemoryContext result_mcxt) { ScanIterator it = ts_scan_iterator_create(CHUNK, AccessShareLock, result_mcxt); it.ctx.flags |= SCANNER_F_NOEND_AND_NOCLOSE; return it; } void ts_chunk_scan_iterator_set_chunk_id(ScanIterator *it, int32 chunk_id) { it->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_ID_INDEX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init(it, Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); } /* * Create a hypercube for the OSM chunk * The initial range for the OSM chunk will be from INT64_MAX - 1 to INT64_MAX. * This range was chosen to minimize interference with tuple routing and * occupy a range outside of potential values as there must be no overlap * between the hypercube occupied by the osm chunk and actual chunks. */ static Hypercube * fill_hypercube_for_osm_chunk(Hyperspace *hs) { Hypercube *cube = ts_hypercube_alloc(hs->num_dimensions); Assert(hs->num_dimensions == 1); // does not work with partitioned range for (int i = 0; i < hs->num_dimensions; i++) { const Dimension *dim = &hs->dimensions[i]; Assert(dim->type == DIMENSION_TYPE_OPEN); cube->slices[i] = ts_dimension_slice_create(dim->fd.id, PG_INT64_MAX - 1, PG_INT64_MAX); cube->num_slices++; } Assert(cube->num_slices == 1); return cube; } /* adds foreign table as a chunk to the hypertable. * creates a dummy chunk constraint for the time dimension. * These constraints are recorded in the chunk-dimension slice metadata. * They are NOT added as CHECK constraints on the foreign table. * * Does not add any inheritable constraints or indexes that are already * defined on the hypertable. * * This is used to add an OSM table as a chunk. * Set the osm_chunk flag to true. */ static void add_foreign_table_as_chunk(Oid relid, Hypertable *parent_ht) { Hyperspace *hs = parent_ht->space; Catalog *catalog = ts_catalog_get(); CatalogSecurityContext sec_ctx; Chunk *chunk; char *relschema = get_namespace_name(get_rel_namespace(relid)); char *relname = get_rel_name(relid); Oid ht_ownerid = ts_rel_get_owner(parent_ht->main_table_relid); if (!has_privs_of_role(GetUserId(), ht_ownerid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of hypertable \"%s\"", get_rel_name(parent_ht->main_table_relid)))); Assert(get_rel_relkind(relid) == RELKIND_FOREIGN_TABLE); if (hs->num_dimensions > 1) elog(ERROR, "cannot attach a foreign table to a hypertable that has more than 1 dimension"); /* Create a new chunk based on the hypercube */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); chunk = ts_chunk_create_base(ts_catalog_table_next_seq_id(catalog, CHUNK), hs->num_dimensions, RELKIND_RELATION); ts_catalog_restore_user(&sec_ctx); /* fill in the correct table_name for the chunk*/ chunk->fd.hypertable_id = hs->hypertable_id; chunk->fd.osm_chunk = true; /* this is an OSM chunk */ chunk->cube = fill_hypercube_for_osm_chunk(hs); chunk->hypertable_relid = parent_ht->main_table_relid; chunk->constraints = ts_chunk_constraints_alloc(1, CurrentMemoryContext); namestrcpy(&chunk->fd.schema_name, relschema); namestrcpy(&chunk->fd.table_name, relname); /* Insert chunk */ ts_chunk_insert_lock(chunk, RowExclusiveLock); /* insert dimension slices if they do not exist. */ ts_dimension_slice_insert_multi(chunk->cube->slices, chunk->cube->num_slices); /* check constraints are not automatically created for foreign tables. * See: ts_chunk_constraints_add_dimension_constraints. * Collect all the check constraints from the hypertable and add them to the * foreign table. Otherwise, cannot add as child of the hypertable (pg inheritance * code will error. Note that the name of the check constraint on the hypertable * and the foreign table chunk should match. */ ts_chunk_constraints_add_inheritable_check_constraints(chunk->constraints, chunk->fd.id, chunk->relkind, chunk->hypertable_relid); chunk_create_table_constraints(parent_ht, chunk); /* Add dimension constraints for the chunk */ ts_chunk_constraints_add_dimension_constraints(chunk->constraints, chunk->fd.id, chunk->cube); ts_chunk_constraints_insert_metadata(chunk->constraints); chunk_add_inheritance(chunk, parent_ht); /* * Update hypertable entry with tiering status information. * XXX: For compatibility reasons, we set the noncontiguous flag, but * this should be reverted as soon as the newer version of the OSM extension * is rolled out. * Noncontiguous flag should not be set since the chunk should be empty upon * creation, with an invalid range assigned, so ordered append should be allowed. * Once the data is moved into the OSM chunk, then our catalog should be * updated with proper API calls from the OSM extension. */ parent_ht->fd.status = ts_set_flags_32(parent_ht->fd.status, HYPERTABLE_STATUS_OSM | HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS); ts_hypertable_update_status_osm(parent_ht); } void ts_chunk_merge_on_dimension(const Hypertable *ht, Chunk *chunk, const Chunk *merge_chunk, int32 dimension_id) { const DimensionSlice *slice, *merge_slice; int num_ccs = 0; bool dimension_slice_found = false; if (chunk->hypertable_relid != merge_chunk->hypertable_relid) ereport(ERROR, (errmsg("cannot merge chunks from different hypertables"), errhint("chunk 1: \"%s\", chunk 2: \"%s\"", get_rel_name(chunk->table_id), get_rel_name(merge_chunk->table_id)))); for (int i = 0; i < chunk->cube->num_slices; i++) { if (chunk->cube->slices[i]->fd.dimension_id == dimension_id) { slice = chunk->cube->slices[i]; merge_slice = merge_chunk->cube->slices[i]; dimension_slice_found = true; } else if (chunk->cube->slices[i]->fd.id != merge_chunk->cube->slices[i]->fd.id) { /* If the slices do not match (except on time dimension), we cannot merge the chunks. */ ereport(ERROR, (errmsg("cannot merge chunks with different partitioning schemas"), errhint("chunk 1: \"%s\", chunk 2: \"%s\" have different slices on " "dimension ID %d", get_rel_name(chunk->table_id), get_rel_name(merge_chunk->table_id), chunk->cube->slices[i]->fd.dimension_id))); } } if (!dimension_slice_found) ereport(ERROR, (errmsg("cannot find slice for merging dimension"), errhint("chunk 1: \"%s\", chunk 2: \"%s\", dimension ID %d", get_rel_name(chunk->table_id), get_rel_name(merge_chunk->table_id), dimension_id))); if (slice->fd.range_end != merge_slice->fd.range_start) ereport(ERROR, (errmsg("cannot merge non-adjacent chunks over supplied dimension"), errhint("chunk 1: \"%s\", chunk 2: \"%s\", dimension ID %d", get_rel_name(chunk->table_id), get_rel_name(merge_chunk->table_id), dimension_id))); num_ccs = ts_chunk_constraint_scan_by_dimension_slice_id(slice->fd.id, NULL, CurrentMemoryContext); /* There should always be an associated chunk constraint to a dimension slice. * This can only occur when the catalog metadata is corrupt. */ if (num_ccs <= 0) ereport(ERROR, (errmsg("missing chunk constraint for dimension slice"), errhint("chunk: \"%s\", slice ID %d", get_rel_name(chunk->table_id), slice->fd.id))); DimensionSlice *new_slice = ts_dimension_slice_create(dimension_id, slice->fd.range_start, merge_slice->fd.range_end); /* Only if there is exactly one chunk constraint for the merged dimension slice * we can go ahead and delete it since we are dropping the chunk. */ if (num_ccs == 1) ts_dimension_slice_delete_by_id(slice->fd.id, false); /* Check for dimension slice already exists, if not create a new one. */ ScanTupLock tuplock = { .lockmode = LockTupleKeyShare, .waitpolicy = LockWaitBlock, }; if (!ts_dimension_slice_scan_for_existing(new_slice, &tuplock)) { ts_dimension_slice_insert(new_slice); } ts_chunk_constraint_update_slice_id(chunk->fd.id, slice->fd.id, new_slice->fd.id); ChunkConstraints *ccs = ts_chunk_constraints_alloc(1, CurrentMemoryContext); ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, AccessShareLock, CurrentMemoryContext); ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, new_slice->fd.id); ts_scanner_foreach(&iterator) { bool isnull; Datum d; d = slot_getattr(ts_scan_iterator_slot(&iterator), Anum_chunk_constraint_chunk_id, &isnull); if (!isnull && DatumGetInt32(d) == chunk->fd.id) { num_ccs++; ts_chunk_constraints_add_from_tuple(ccs, ts_scan_iterator_tuple_info(&iterator)); } } if (num_ccs <= 0) ereport(ERROR, (errmsg("missing chunk constraint for merged dimension slice"), errhint("chunk: \"%s\", slice ID %d", get_rel_name(chunk->table_id), new_slice->fd.id))); /* Update the slice in the chunk's hypercube. Needed to make recreate constraints work. */ for (int i = 0; i < chunk->cube->num_slices; i++) { if (chunk->cube->slices[i]->fd.dimension_id == dimension_id) { chunk->cube->slices[i] = new_slice; break; } } /* Delete the old constraint */ for (int i = 0; i < chunk->constraints->num_constraints; i++) { const ChunkConstraint *cc = &chunk->constraints->constraints[i]; if (cc->fd.dimension_slice_id == slice->fd.id) { ObjectAddress constrobj = { .classId = ConstraintRelationId, .objectId = get_relation_constraint_oid(chunk->table_id, NameStr(cc->fd.constraint_name), false), }; performDeletion(&constrobj, DROP_RESTRICT, 0); break; } } /* We have to recreate the chunk constraints since we are changing * table constraints when updating the slice. */ ChunkConstraints *oldccs = chunk->constraints; chunk->constraints = ccs; ts_process_utility_set_expect_chunk_modification(true); ts_chunk_constraints_create(ht, chunk); ts_process_utility_set_expect_chunk_modification(false); chunk->constraints = oldccs; ts_chunk_drop(merge_chunk, DROP_RESTRICT, 1); } /* Internal API used by OSM extension. OSM table is a foreign table that is * attached as a chunk of the hypertable. A chunk needs dimension constraints. We * add dummy constraints for the OSM chunk and then attach it to the hypertable. * OSM extension is responsible for maintaining any constraints on this table. */ Datum ts_chunk_attach_osm_table_chunk(PG_FUNCTION_ARGS) { Oid hypertable_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Oid ftable_relid = PG_ARGISNULL(1) ? InvalidOid : PG_GETARG_OID(1); bool ret = false; Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(hypertable_relid, CACHE_FLAG_MISSING_OK, &hcache); if (!ht) { char *name = get_rel_name(hypertable_relid); if (!name) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("invalid Oid"))); else ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("\"%s\" is not a hypertable", name))); } if (get_rel_relkind(ftable_relid) == RELKIND_FOREIGN_TABLE) { add_foreign_table_as_chunk(ftable_relid, ht); ret = true; } ts_cache_release(&hcache); PG_RETURN_BOOL(ret); } static ScanTupleResult chunk_tuple_osm_chunk_found(TupleInfo *ti, void *arg) { bool isnull; Datum osm_chunk = slot_getattr(ti->slot, Anum_chunk_osm_chunk, &isnull); Assert(!isnull); bool is_osm_chunk = DatumGetBool(osm_chunk); if (!is_osm_chunk) return SCAN_CONTINUE; int *chunk_id = (int *) arg; Datum chunk_id_datum = slot_getattr(ti->slot, Anum_chunk_id, &isnull); Assert(!isnull); *chunk_id = DatumGetInt32(chunk_id_datum); return SCAN_DONE; } /* get OSM chunk id associated with the hypertable */ int ts_chunk_get_osm_chunk_id(int hypertable_id) { int chunk_id = INVALID_CHUNK_ID; ScanKeyData scankey[2]; bool is_osm_chunk = true; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CHUNK), .index = catalog_get_index(catalog, CHUNK, CHUNK_OSM_CHUNK_INDEX), .nkeys = 2, .scankey = scankey, .data = &chunk_id, .tuple_found = chunk_tuple_osm_chunk_found, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, }; /* * Perform an index scan on hypertable ID + osm_chunk */ ScanKeyInit(&scankey[0], Anum_chunk_osm_chunk_idx_osm_chunk, BTEqualStrategyNumber, F_BOOLEQ, BoolGetDatum(is_osm_chunk)); ScanKeyInit(&scankey[1], Anum_chunk_osm_chunk_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); int num_found = ts_scanner_scan(&scanctx); if (num_found > 1) { ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("More than 1 OSM chunk found for hypertable (%d)", hypertable_id))); } return chunk_id; } /* Upon creation, OSM chunks are assigned an invalid range [INT64_MAX -1, infinity) */ bool ts_osm_chunk_range_is_invalid(int64 range_start, int64 range_end) { return ((range_end == PG_INT64_MAX) && (range_start == range_end - 1)); } int32 ts_chunk_get_osm_slice_id(int32 chunk_id, int32 time_dim_id) { Chunk *chunk = ts_chunk_get_by_id(chunk_id, true); const DimensionSlice *ds = ts_hypercube_get_slice_by_dimension_id(chunk->cube, time_dim_id); const int slice_id = ds->fd.id; return slice_id; } /* * Initialization and access method for ChunkVec. This needs to be extended to support additional * operations. */ static ChunkVec * chunk_vec_expand(ChunkVec *chunks, uint32 new_capacity) { if (chunks != NULL && chunks->capacity >= new_capacity) return chunks; if (chunks == NULL) chunks = palloc(CHUNK_VEC_SIZE(new_capacity)); else chunks = repalloc(chunks, CHUNK_VEC_SIZE(new_capacity)); chunks->capacity = new_capacity; return chunks; } ChunkVec * ts_chunk_vec_create(int32 capacity) { ChunkVec *chunks = chunk_vec_expand(NULL, capacity); chunks->num_chunks = 0; return chunks; } ChunkVec * ts_chunk_vec_sort(ChunkVec **chunks) { ChunkVec *vec = *chunks; if (vec->num_chunks > 1) qsort(&vec->chunks, vec->num_chunks, sizeof(Chunk), chunk_cmp); return vec; } ChunkVec * ts_chunk_vec_add_from_tuple(ChunkVec **chunks, TupleInfo *ti) { Chunk *chunkptr = NULL; ChunkVec *vec; int num_constraints_hint; ScanIterator it; vec = *chunks; num_constraints_hint = 2; if (vec->num_chunks + 1 > vec->capacity) *chunks = vec = chunk_vec_expand(vec, vec->capacity + DEFAULT_CHUNK_VEC_SIZE); chunkptr = &vec->chunks[vec->num_chunks++]; ts_chunk_formdata_fill(&chunkptr->fd, ti); /* * Get the chunk constraints, hypercube slices and relation details. */ chunkptr->constraints = ts_chunk_constraint_scan_by_chunk_id(chunkptr->fd.id, num_constraints_hint, ti->mctx); it = ts_dimension_slice_scan_iterator_create(NULL, ti->mctx); chunkptr->cube = ts_hypercube_from_constraints(chunkptr->constraints, &it); ts_scan_iterator_close(&it); chunkptr->table_id = ts_get_relation_relid(NameStr(chunkptr->fd.schema_name), NameStr(chunkptr->fd.table_name), true); chunkptr->hypertable_relid = ts_hypertable_id_to_relid(chunkptr->fd.hypertable_id, false); chunkptr->relkind = get_rel_relkind(chunkptr->table_id); return vec; } /* * Prepare for an index scan for all the chunks matching the given hypertable_id and range criteria. */ static int chunk_creation_time_set_range(ScanIterator *it, Oid hypertable_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value) { TypeCacheEntry *tce; it->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_HYPERTABLE_ID_CREATION_TIME_INDEX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init(it, Anum_chunk_hypertable_id_creation_time_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); tce = lookup_type_cache(TIMESTAMPTZOID, TYPECACHE_BTREE_OPFAMILY); /* If both are valid strategies then a proper scan within these limits will be performed */ if (start_strategy != InvalidStrategy) { Oid opno = get_opfamily_member(tce->btree_opf, TIMESTAMPTZOID, TIMESTAMPTZOID, start_strategy); Oid proc = get_opcode(opno); Assert(OidIsValid(proc)); ts_scan_iterator_scan_key_init(it, Anum_chunk_hypertable_id_creation_time_idx_creation_time, start_strategy, proc, Int64GetDatum(start_value)); } if (end_strategy != InvalidStrategy) { Oid opno = get_opfamily_member(tce->btree_opf, TIMESTAMPTZOID, TIMESTAMPTZOID, end_strategy); Oid proc = get_opcode(opno); Assert(OidIsValid(proc)); ts_scan_iterator_scan_key_init(it, Anum_chunk_hypertable_id_creation_time_idx_creation_time, end_strategy, proc, Int64GetDatum(end_value)); } return it->ctx.nkeys; } /* * Perform an index scan for given hypertable_id and chunk creation time range. * * Returns an array of chunks using ChunkVec the encloses all the chunks satisfying the range * criteria. */ static Chunk * get_chunks_in_creation_time_range_limit(Hypertable *ht, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value, int limit, uint64 *num_chunks, ScanTupLock *tupLock) { ScanIterator it; ChunkVec *chunk_vec = NULL; it = ts_scan_iterator_create(CHUNK, AccessShareLock, CurrentMemoryContext); it.ctx.flags |= SCANNER_F_NOEND_AND_NOCLOSE; it.ctx.tuplock = tupLock; chunk_creation_time_set_range(&it, ht->fd.id, start_strategy, start_value, end_strategy, end_value); it.ctx.limit = limit; #ifdef TS_DEBUG /* allow testing of the chunk vec expansion in debug builds */ if (limit == -1) limit = 1; #endif chunk_vec = ts_chunk_vec_create(limit > 0 ? limit : DEFAULT_CHUNK_VEC_SIZE); ts_scanner_foreach(&it) { bool dropped_isnull, dropped; TupleInfo *ti = ts_scan_iterator_tuple_info(&it); /* only add chunks that are not dropped */ dropped = DatumGetBool(slot_getattr(ti->slot, Anum_chunk_dropped, &dropped_isnull)); Assert(!dropped_isnull); if (!dropped) ts_chunk_vec_add_from_tuple(&chunk_vec, ti); } ts_scan_iterator_close(&it); ts_chunk_vec_sort(&chunk_vec); *num_chunks = chunk_vec->num_chunks; return chunk_vec->chunks; } Chunk * get_chunks_in_creation_time_range(Hypertable *ht, int64 older_than, int64 newer_than, MemoryContext mctx, uint64 *num_chunks_returned, ScanTupLock *tupLock) { MemoryContext oldcontext; Chunk *chunks = NULL; StrategyNumber start_strategy; StrategyNumber end_strategy; uint64 num_chunks = 0; if (older_than <= newer_than) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid chunk creation time range"), errhint("The start of the time range must be before the end."))); start_strategy = (newer_than == PG_INT64_MIN) ? InvalidStrategy : BTGreaterEqualStrategyNumber; end_strategy = (older_than == PG_INT64_MAX) ? InvalidStrategy : BTLessStrategyNumber; oldcontext = MemoryContextSwitchTo(mctx); chunks = get_chunks_in_creation_time_range_limit(ht, start_strategy, newer_than, end_strategy, older_than, -1, &num_chunks, tupLock); MemoryContextSwitchTo(oldcontext); *num_chunks_returned = num_chunks; return chunks; } Datum ts_chunk_drop_osm_chunk(PG_FUNCTION_ARGS) { Oid hypertable_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Cache *hcache = ts_hypertable_cache_pin(); Hypertable *ht = ts_resolve_hypertable_from_table_or_cagg(hcache, hypertable_relid, true); int32 osm_chunk_id = ts_chunk_get_osm_chunk_id(ht->fd.id); Chunk *osm_chunk = ts_chunk_get_by_id(osm_chunk_id, true); ts_chunk_validate_chunk_status_for_operation(osm_chunk, CHUNK_DROP, true); /* do not drop any chunk dependencies */ ts_chunk_drop(osm_chunk, DROP_RESTRICT, LOG); /* reset hypertable OSM status */ ht->fd.status = ts_clear_flags_32(ht->fd.status, HYPERTABLE_STATUS_OSM | HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS); ts_hypertable_update_status_osm(ht); ts_cache_release(&hcache); PG_RETURN_BOOL(true); } TS_FUNCTION_INFO_V1(ts_merge_two_chunks); Datum ts_merge_two_chunks(PG_FUNCTION_ARGS) { Datum chunks[2] = { PG_GETARG_DATUM(0), PG_GETARG_DATUM(1) }; ArrayType *chunk_array = construct_array(chunks, 2, REGCLASSOID, sizeof(Oid), true, TYPALIGN_INT); return DirectFunctionCall1(ts_cm_functions->merge_chunks, PointerGetDatum(chunk_array)); } void ts_chunk_detach_by_relid(Oid relid) { ScanIterator iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); char *schema; char *table; int PG_USED_FOR_ASSERTS_ONLY count; Assert(OidIsValid(relid)); schema = get_namespace_name(get_rel_namespace(relid)); table = get_rel_name(relid); init_scan_by_qualified_table_name(&iterator, schema, table); count = chunk_delete(&iterator, relid, DROP_RESTRICT, false, true); /* * (schema,table) names and (hypertable_id) are unique so should only have * dropped one chunk */ Assert(count == 1); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk.h����������������������������������������������������������������������0000664�0000000�0000000�00000033047�15100345067�0016132�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/htup.h> #include <access/tupdesc.h> #include <foreign/foreign.h> #include <utils/hsearch.h> #include "chunk_constraint.h" #include "export.h" #include "hypertable.h" #include "ts_catalog/catalog.h" #define INVALID_CHUNK_ID 0 #define IS_OSM_CHUNK(chunk) ((chunk)->fd.osm_chunk == true) /* Should match definitions in ddl_api.sql */ #define DROP_CHUNKS_FUNCNAME "drop_chunks" #define DROP_CHUNKS_NARGS 6 #define COMPRESS_CHUNK_FUNCNAME "compress_chunk" #define COMPRESS_CHUNK_NARGS 2 #define DECOMPRESS_CHUNK_FUNCNAME "decompress_chunk" #define RECOMPRESS_CHUNK_FUNCNAME "recompress_chunk" #define RECOMPRESS_CHUNK_NARGS 2 typedef enum ChunkCompressionStatus { CHUNK_COMPRESS_NONE = 0, CHUNK_COMPRESS_UNORDERED, CHUNK_COMPRESS_ORDERED, CHUNK_DROPPED } ChunkCompressionStatus; typedef enum ChunkOperation { CHUNK_DROP = 0, CHUNK_INSERT, CHUNK_UPDATE, CHUNK_DELETE, CHUNK_SELECT, CHUNK_COMPRESS, CHUNK_DECOMPRESS, } ChunkOperation; typedef struct Hypercube Hypercube; typedef struct Point Point; typedef struct Hyperspace Hyperspace; typedef struct Hypertable Hypertable; /* * A chunk represents a table that stores data, part of a partitioned * table. * * Conceptually, a chunk is a hypercube in an N-dimensional space. The * boundaries of the cube is represented by a collection of slices from the N * distinct dimensions. */ typedef struct Chunk { FormData_chunk fd; char relkind; Oid table_id; Oid hypertable_relid; /* * The hypercube defines the chunks position in the N-dimensional space. * Each of the N slices in the cube corresponds to a constraint on the * chunk table. */ Hypercube *cube; ChunkConstraints *constraints; } Chunk; /* This structure is used during the join of the chunk constraints to find * chunks that match all constraints. It is a stripped down version of the chunk * since we don't want to fill in all the fields until we find a match. */ typedef struct ChunkStub { int32 id; Hypercube *cube; ChunkConstraints *constraints; } ChunkStub; /* * ChunkScanCtx is used to scan for chunks in a hypertable's N-dimensional * hyperspace. * * For every matching constraint, a corresponding chunk will be created in the * context's hash table, keyed on the chunk ID. */ typedef struct ChunkScanCtx { HTAB *htab; char relkind; /* Create chunks of this relkind */ const Hypertable *ht; const Point *point; unsigned int num_complete_chunks; uint64 num_processed; bool early_abort; LOCKMODE lockmode; void *data; } ChunkScanCtx; /* Returns true if the stub has a full set of constraints, otherwise * false. Used to find a stub matching a point in an N-dimensional * hyperspace. */ static inline bool chunk_stub_is_complete(const ChunkStub *stub, const Hyperspace *space) { return space->num_dimensions == stub->constraints->num_dimension_constraints; } /* The hash table entry for the ChunkScanCtx */ typedef struct ChunkScanEntry { int32 chunk_id; ChunkStub *stub; /* Used for fast chunk search where we don't want to build chunk stubs. */ int32 num_dimension_constraints; } ChunkScanEntry; /* * Information to be able to display a scan key details for error messages. */ typedef struct DisplayKeyData { const char *name; const char *(*as_string)(Datum); } DisplayKeyData; /* * Chunk vector is collection of chunks for a given hypertable_id. */ typedef struct ChunkVec { uint32 capacity; uint32 num_chunks; Chunk chunks[FLEXIBLE_ARRAY_MEMBER]; } ChunkVec; extern ChunkVec *ts_chunk_vec_create(int32 capacity); extern ChunkVec *ts_chunk_vec_sort(ChunkVec **chunks); extern ChunkVec *ts_chunk_vec_add_from_tuple(ChunkVec **chunks, TupleInfo *ti); #define CHUNK_VEC_SIZE(num_chunks) (sizeof(ChunkVec) + (sizeof(Chunk) * num_chunks)) #define DEFAULT_CHUNK_VEC_SIZE 10 extern void ts_chunk_formdata_fill(FormData_chunk *fd, const TupleInfo *ti); extern int32 ts_chunk_point_find_chunk_id(const Hypertable *ht, const Point *p, const ScanTupLock *slice_lock); extern Chunk *ts_chunk_find_for_point(const Hypertable *ht, const Point *p, LOCKMODE lockmode); extern Chunk *ts_chunk_create_for_point(const Hypertable *ht, const Point *p, const char *schema, const char *prefix, LOCKMODE chunk_lockmode); List *ts_chunk_id_find_in_subspace(Hypertable *ht, List *dimension_vecs); extern TSDLLEXPORT Chunk *ts_chunk_create_base(int32 id, int16 num_constraints, const char relkind); extern TSDLLEXPORT ChunkStub *ts_chunk_stub_create(int32 id, int16 num_constraints); extern TSDLLEXPORT Chunk *ts_chunk_copy(const Chunk *chunk); extern TSDLLEXPORT Chunk * ts_chunk_get_by_name_with_memory_context(const char *schema_name, const char *table_name, LOCKMODE chunk_lockmode, const ScanTupLock *slice_lock, MemoryContext mctx, bool fail_if_not_found); extern TSDLLEXPORT void ts_chunk_insert_lock(const Chunk *chunk, LOCKMODE lock); extern TSDLLEXPORT Oid ts_chunk_create_table(const Chunk *chunk, const Hypertable *ht, const char *tablespacename); extern TSDLLEXPORT Chunk *ts_chunk_get_by_id_with_slice_lock(int32 id, LOCKMODE chunk_lockmode, const ScanTupLock *slice_lock, bool fail_if_not_found); extern TSDLLEXPORT Chunk *ts_chunk_get_by_id(int32 id, bool fail_if_not_found); extern TSDLLEXPORT Chunk *ts_chunk_get_by_relid_locked(Oid relid, LOCKMODE lockmode, bool fail_if_not_found); extern TSDLLEXPORT Chunk *ts_chunk_get_by_relid(Oid relid, bool fail_if_not_found); extern TSDLLEXPORT void ts_chunk_free(Chunk *chunk); extern bool ts_chunk_exists(const char *schema_name, const char *table_name); extern TSDLLEXPORT int32 ts_chunk_get_hypertable_id_by_reloid(Oid reloid); extern TSDLLEXPORT FormData_chunk ts_chunk_get_formdata(int32 chunk_id); extern TSDLLEXPORT bool ts_chunk_simple_scan_by_reloid(Oid reloid, FormData_chunk *form, bool missing_ok); extern TSDLLEXPORT Oid ts_chunk_get_relid(int32 chunk_id, bool missing_ok); extern Oid ts_chunk_get_schema_id(int32 chunk_id, bool missing_ok); extern TSDLLEXPORT bool ts_chunk_get_id(const char *schema, const char *table, int32 *chunk_id, bool missing_ok); extern bool ts_chunk_exists_relid(Oid relid); extern TSDLLEXPORT bool ts_chunk_exists_with_compression(int32 hypertable_id); extern void ts_chunk_recreate_all_constraints_for_dimension(Hypertable *ht, int32 dimension_id); extern int ts_chunk_delete_by_hypertable_id(int32 hypertable_id); extern TSDLLEXPORT int ts_chunk_delete_by_name(const char *schema, const char *table, DropBehavior behavior); extern int ts_chunk_delete_by_relid_and_relname(Oid relid, const char *schemaname, const char *tablename, DropBehavior behavior, bool preserve_chunk_catalog_row); extern bool ts_chunk_set_name(Chunk *chunk, const char *newname); extern bool ts_chunk_set_schema(Chunk *chunk, const char *newschema); extern TSDLLEXPORT List *ts_chunk_get_window(int32 dimension_id, int64 point, int count, MemoryContext mctx); extern void ts_chunks_rename_schema_name(char *old_schema, char *new_schema); extern TSDLLEXPORT bool ts_chunk_set_partial(Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_set_unordered(Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_set_frozen(Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_unset_frozen(Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_is_frozen(const Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_set_compressed_chunk(Chunk *chunk, int32 compressed_chunk_id); extern TSDLLEXPORT bool ts_chunk_clear_compressed_chunk(Chunk *chunk); extern TSDLLEXPORT void ts_chunk_drop(const Chunk *chunk, DropBehavior behavior, int32 log_level); extern TSDLLEXPORT void ts_chunk_drop_preserve_catalog_row(const Chunk *chunk, DropBehavior behavior, int32 log_level); extern TSDLLEXPORT List *ts_chunk_do_drop_chunks(Hypertable *ht, int64 older_than, int64 newer_than, int32 log_level, Oid time_type, Oid arg_type, bool older_newer); extern TSDLLEXPORT Chunk * ts_chunk_find_or_create_without_cuts(const Hypertable *ht, Hypercube *hc, const char *schema_name, const char *table_name, Oid chunk_table_relid, bool *created); extern TSDLLEXPORT Chunk *ts_chunk_get_compressed_chunk_parent(const Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_is_unordered(const Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_is_partial(const Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_is_compressed(const Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_needs_recompression(const Chunk *chunk); extern TSDLLEXPORT bool ts_chunk_validate_chunk_status_for_operation(const Chunk *chunk, ChunkOperation cmd, bool throw_error); extern TSDLLEXPORT bool ts_chunk_contains_compressed_data(const Chunk *chunk); extern TSDLLEXPORT ChunkCompressionStatus ts_chunk_get_compression_status(int32 chunk_id); extern TSDLLEXPORT Datum ts_chunk_id_from_relid(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_chunk_status_text(PG_FUNCTION_ARGS); extern TSDLLEXPORT List *ts_chunk_get_chunk_ids_by_hypertable_id(int32 hypertable_id); extern TSDLLEXPORT List *ts_chunk_get_by_hypertable_id(int32 hypertable_id); extern TSDLLEXPORT int64 ts_chunk_primary_dimension_start(const Chunk *chunk); extern TSDLLEXPORT int64 ts_chunk_primary_dimension_end(const Chunk *chunk); extern Chunk *ts_chunk_build_from_tuple_and_stub(Chunk **chunkptr, TupleInfo *ti, const ChunkStub *stub, const ScanTupLock *slice_lock); extern TM_Result ts_chunk_lock_for_creating_compressed_chunk(int32 chunk_id, int32 *compressed_chunk_id); extern ScanIterator ts_chunk_scan_iterator_create(MemoryContext result_mcxt); extern void ts_chunk_scan_iterator_set_chunk_id(ScanIterator *it, int32 chunk_id); extern bool ts_chunk_lock_if_exists(Oid chunk_oid, LOCKMODE chunk_lockmode); int ts_chunk_get_osm_chunk_id(int hypertable_id); extern TSDLLEXPORT void ts_chunk_merge_on_dimension(const Hypertable *ht, Chunk *chunk, const Chunk *merge_chunk, int32 dimension_id); extern TSDLLEXPORT void ts_chunk_detach_by_relid(Oid relid); #define chunk_get_by_name(schema_name, table_name, chunk_lockmode, slice_lock, fail_if_not_found) \ ts_chunk_get_by_name_with_memory_context(schema_name, \ table_name, \ chunk_lockmode, \ slice_lock, \ CurrentMemoryContext, \ fail_if_not_found) /* * Sanity checks for chunk. * * The individual checks are split into separate Asserts so it's * easier to tell from a stacktrace which one failed. */ #define ASSERT_IS_VALID_CHUNK(chunk) \ do \ { \ Assert(chunk); \ Assert(!(chunk)->fd.dropped); \ Assert((chunk)->fd.id > 0); \ Assert((chunk)->fd.hypertable_id > 0); \ Assert(OidIsValid((chunk)->table_id)); \ Assert(OidIsValid((chunk)->hypertable_relid)); \ Assert((chunk)->constraints); \ Assert((chunk)->cube); \ Assert((chunk)->cube->num_slices == (chunk)->constraints->num_dimension_constraints); \ Assert((chunk)->relkind == RELKIND_RELATION || (chunk)->relkind == RELKIND_FOREIGN_TABLE); \ } while (0) /* * The chunk status field values are persisted in the database and must never be changed. * Those values are used as flags and must always be powers of 2 to allow bitwise operations. * When adding new status values we must make sure to add special handling for these values * to the downgrade script as previous versions will not know how to deal with those. */ #define CHUNK_STATUS_DEFAULT 0 /* * Setting a chunk status field as CHUNK_STATUS_COMPRESSED means that the corresponding * compressed_chunk_id field points to a chunk that holds the compressed data. Otherwise, * the corresponding compressed_chunk_id is NULL. */ #define CHUNK_STATUS_COMPRESSED 1 /* * When inserting into a compressed chunk the configured compress_orderby is not retained. * Any such chunks need an explicit Sort step to produce ordered output until the chunk * ordering has been restored by recompress_chunk. This flag can only exist on compressed * chunks. */ #define CHUNK_STATUS_COMPRESSED_UNORDERED 2 /* * A chunk is in frozen state (i.e no inserts/updates/deletes into this chunk are * permitted. Other chunk level operations like dropping chunk etc. are also blocked. * */ #define CHUNK_STATUS_FROZEN 4 /* * A chunk is in this state when it is compressed but also has uncompressed tuples * in the uncompressed chunk. */ #define CHUNK_STATUS_COMPRESSED_PARTIAL 8 extern TSDLLEXPORT bool ts_chunk_clear_status(Chunk *chunk, int32 status); extern bool ts_osm_chunk_range_is_invalid(int64 range_start, int64 range_end); extern int32 ts_chunk_get_osm_slice_id(int32 chunk_id, int32 time_dim_id); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_adaptive.c�������������������������������������������������������������0000664�0000000�0000000�00000063471�15100345067�0020006�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * The contents and feature provided by this file (and its associated header * file) -- adaptive chunking -- are currently in BETA. * Feedback, suggestions, and bugs should be reported * on the GitHub repository issues page, or in our public slack. */ #include <postgres.h> #include <catalog/pg_proc.h> #include <catalog/pg_type.h> #include <funcapi.h> #include <math.h> #include <miscadmin.h> #include <parser/parse_func.h> #include <utils/acl.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "compat/compat.h" #include "chunk.h" #include "chunk_adaptive.h" #include "errors.h" #include "hypercube.h" #include "hypertable_cache.h" #include "utils.h" #define DEFAULT_CHUNK_SIZING_FN_NAME "calculate_chunk_interval" /* This can be set to a positive number (and non-zero) value from tests to * simulate memory cache size. This makes it possible to run tests * deterministically. */ static int64 fixed_memory_cache_size = -1; /* * Takes a PostgreSQL text representation of data (e.g., 40MB) and converts it * into a int64 for calculations */ static int64 convert_text_memory_amount_to_bytes(const char *memory_amount) { const char *hintmsg; int nblocks; int64 bytes; if (NULL == memory_amount) elog(ERROR, "invalid memory amount"); if (!parse_int(memory_amount, &nblocks, GUC_UNIT_BLOCKS, &hintmsg)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid data amount"), errhint("%s", hintmsg))); bytes = nblocks; bytes *= BLCKSZ; return bytes; } /* * Exposed for testing purposes to be able to simulate a different memory * cache size in tests. */ TS_FUNCTION_INFO_V1(ts_set_memory_cache_size); Datum ts_set_memory_cache_size(PG_FUNCTION_ARGS) { const char *memory_amount = text_to_cstring(PG_GETARG_TEXT_P(0)); fixed_memory_cache_size = convert_text_memory_amount_to_bytes(memory_amount); PG_RETURN_INT64(fixed_memory_cache_size); } /* * Get the amount of cache memory for chunks. * We use shared_buffers converted to bytes. */ static int64 get_memory_cache_size(void) { const char *val; const char *hintmsg; int shared_buffers; int64 memory_bytes; if (fixed_memory_cache_size > 0) return fixed_memory_cache_size; val = GetConfigOption("shared_buffers", false, false); if (NULL == val) elog(ERROR, "missing configuration for 'shared_buffers'"); if (!parse_int(val, &shared_buffers, GUC_UNIT_BLOCKS, &hintmsg)) elog(ERROR, "could not parse 'shared_buffers' setting: %s", hintmsg); memory_bytes = shared_buffers; /* Value is in blocks, so convert to bytes */ memory_bytes *= BLCKSZ; return memory_bytes; } /* * For chunk sizing, we don't want to set chunk size exactly the same as the * available cache memory, since chunk sizes won't be exact. We therefore give * some slack here. */ #define DEFAULT_CACHE_MEMORY_SLACK 0.9 extern inline int64 ts_chunk_calculate_initial_chunk_target_size(void) { return (int64) ((double) get_memory_cache_size() * DEFAULT_CACHE_MEMORY_SLACK); } typedef enum MinMaxResult { MINMAX_NO_INDEX, MINMAX_NO_TUPLES, MINMAX_FOUND, } MinMaxResult; /* * Use a heap scan to find the min and max of a given column of a chunk. This * could be a rather costly operation. Should figure out how to keep min-max * stats cached. */ static MinMaxResult minmax_heapscan(Relation rel, Oid atttype, AttrNumber attnum, Datum minmax[2]) { TupleTableSlot *slot = table_slot_create(rel, NULL); TableScanDesc scan; TypeCacheEntry *tce; bool nulls[2] = { true, true }; /* Lookup the tuple comparison function from the type cache */ tce = lookup_type_cache(atttype, TYPECACHE_CMP_PROC | TYPECACHE_CMP_PROC_FINFO); if (NULL == tce || !OidIsValid(tce->cmp_proc)) elog(ERROR, "no comparison function for type %u", atttype); PushActiveSnapshot(GetTransactionSnapshot()); scan = table_beginscan(rel, GetActiveSnapshot(), 0, NULL); while (table_scan_getnextslot(scan, ForwardScanDirection, slot)) { bool isnull; Datum value = slot_getattr(slot, attnum, &isnull); if (isnull) continue; /* Check for new min */ if (nulls[0] || DatumGetInt32(FunctionCall2(&tce->cmp_proc_finfo, value, minmax[0])) < 0) { nulls[0] = false; minmax[0] = value; } /* Check for new max */ if (nulls[1] || DatumGetInt32(FunctionCall2(&tce->cmp_proc_finfo, value, minmax[1])) > 0) { nulls[1] = false; minmax[1] = value; } } table_endscan(scan); ExecDropSingleTupleTableSlot(slot); PopActiveSnapshot(); return (nulls[0] || nulls[1]) ? MINMAX_NO_TUPLES : MINMAX_FOUND; } /* * Use an index scan to find the min and max of a given column of a chunk. */ static MinMaxResult minmax_indexscan(Relation rel, Relation idxrel, AttrNumber attnum, Datum minmax[2]) { PushActiveSnapshot(GetTransactionSnapshot()); IndexScanDesc scan = index_beginscan_compat(rel, idxrel, GetActiveSnapshot(), NULL, 0, 0); TupleTableSlot *slot = table_slot_create(rel, NULL); bool nulls[2] = { true, true }; int i; ScanDirection directions[2] = { ForwardScanDirection /* min */, BackwardScanDirection /* max */ }; int16 option = idxrel->rd_indoption[0]; bool index_orderby_asc = ((option & INDOPTION_DESC) == 0); /* default index ordering is ASC, check if that's not the case */ if (!index_orderby_asc) { directions[0] = BackwardScanDirection; directions[1] = ForwardScanDirection; } for (i = 0; i < 2; i++) { bool found_tuple; bool isnull; index_rescan(scan, NULL, 0, NULL, 0); found_tuple = index_getnext_slot(scan, directions[i], slot); if (!found_tuple) break; minmax[i] = slot_getattr(slot, attnum, &isnull); nulls[i] = isnull; } index_endscan(scan); ExecDropSingleTupleTableSlot(slot); PopActiveSnapshot(); Assert((nulls[0] && nulls[1]) || (!nulls[0] && !nulls[1])); return nulls[0] ? MINMAX_NO_TUPLES : MINMAX_FOUND; } /* * Do a scan for min and max using and index on the given column. */ static MinMaxResult relation_minmax_indexscan(Relation rel, Oid atttype, Name attname, AttrNumber attnum, Datum minmax[2]) { List *indexlist = RelationGetIndexList(rel); ListCell *lc; MinMaxResult res = MINMAX_NO_INDEX; foreach (lc, indexlist) { Relation idxrel; Form_pg_attribute idxattr; idxrel = index_open(lfirst_oid(lc), AccessShareLock); idxattr = TupleDescAttr(idxrel->rd_att, 0); if (idxattr->atttypid == atttype && namestrcmp(&idxattr->attname, NameStr(*attname)) == 0) res = minmax_indexscan(rel, idxrel, attnum, minmax); index_close(idxrel, AccessShareLock); if (res == MINMAX_FOUND) break; } return res; } /* * Determines if a table has an appropriate index for finding the minimum and * maximum time value. This would be an index whose first column is the same as * the column used for time partitioning. */ static bool table_has_minmax_index(Oid relid, Oid atttype, Name attname, AttrNumber attnum) { Datum minmax[2]; Relation rel = table_open(relid, AccessShareLock); MinMaxResult res = relation_minmax_indexscan(rel, atttype, attname, attnum, minmax); table_close(rel, AccessShareLock); return res != MINMAX_NO_INDEX; } /* * Get the min and max value for a given column of a chunk. * * Returns true iff min and max is found, otherwise false. */ static bool chunk_get_minmax(Oid relid, Oid atttype, AttrNumber attnum, const char *call_context, Datum minmax[2]) { Relation rel = table_open(relid, AccessShareLock); NameData attname; MinMaxResult res; namestrcpy(&attname, get_attname(relid, attnum, false)); res = relation_minmax_indexscan(rel, atttype, &attname, attnum, minmax); if (res == MINMAX_NO_INDEX) { ereport(WARNING, (errmsg("no index on \"%s\" found for %s on chunk \"%s\"", NameStr(attname), call_context, get_rel_name(relid)), errdetail("%s works best with an index on the dimension.", call_context))); res = minmax_heapscan(rel, atttype, attnum, minmax); } table_close(rel, AccessShareLock); return res == MINMAX_FOUND; } #define CHUNK_SIZING_FUNC_NARGS 3 #define DEFAULT_CHUNK_WINDOW 3 /* Tuples must have filled this fraction of the chunk interval to use it to * estimate a new chunk time interval */ #define INTERVAL_FILLFACTOR_THRESH 0.5 /* A chunk must fill this (extrapolated) fraction of the target size to use it * to estimate a new chunk time interval. */ #define SIZE_FILLFACTOR_THRESH 0.15 /* The calculated chunk time interval must differ this much to actually change * the interval */ #define INTERVAL_MIN_CHANGE_THRESH 0.15 /* More than this number of intervals must be undersized in order to use the * undersized calculation path */ #define NUM_UNDERSIZED_INTERVALS 1 /* Threshold to boost to if there are only undersized intervals to make * predictions from. This should be slightly above the SIZE_FILLFACTOR_THRESH * so that the next chunks made with this are likely to meet that threshold * and be used in normal prediction mode */ #define UNDERSIZED_FILLFACTOR_THRESH (SIZE_FILLFACTOR_THRESH * 1.1) TS_FUNCTION_INFO_V1(ts_calculate_chunk_interval); /* * Calculate a new interval for a chunk in a given dimension. * * This function implements the main algorithm for adaptive chunking. Given a * dimension, coordinate (point) on the dimensional axis (e.g., point in time), * and a chunk target size (in bytes), the function should return a new * interval that best fills the chunk to the target size. * * The intuition behind the current implementation is to look back at the recent * past chunks in the dimension and look at how close they are to the target * size (the fillfactor) and then use that information to calculate a new * interval. I.e., if the fillfactor of a past chunk was below 1.0 we increase * the interval, and if it was above 1.0 we decrease it. Thus, for each past * chunk, we calculate the interval that would have filled the chunk to the * target size. Then, to calculate the new chunk interval, we average the * intervals of the past chunks. * * Note, however, that there are a couple of caveats. First, we cannot look back * at the most recently created chunks, because there is no guarantee that data * was written exactly in order of the dimension we are looking at. Therefore, * we "look back" along the dimension axis instead of by, e.g., chunk * ID. Second, chunks can be filled unevenly. Below are three examples of how * chunks can be filled ('*' represents data): * *' |--------| *' | * * * *| 1. Evenly filled (ideal) *' |--------| * *' |--------| *' | ****| 2. Partially filled *' |--------| * *' |--------| *' | * * **| 3. Unevenly filled *' |--------| * * Chunk (1) above represents the ideal situation. The chunk is evenly filled * across the entire chunk interval. This indicates a steady stream of data at * an even rate. Given the size and interval of this chunk, it would be * straightforward to calculate a new interval to hit a given target size. * * Chunk (2) has the same amount of data as (1), but it is reasonable to believe * that the following chunk will be fully filled with about twice the amount of * data. It is common for the first chunk in a hypertable to look like * this. Thus, to be able to use the first chunk for prediction, we compensate * by finding the MIN and MAX dimension values of the data in the chunk and then * use max-min (difference) as the interval instead of the chunk's actual * interval (i.e., since we are more interested in data rate/density we pretend * that this is a smaller chunk in terms of the given dimension.) * * Chunk (3) is probably a common real world scenario. We don't do anything * special to handle this case. * * We use a number of thresholds to avoid changing intervals * unnecessarily. I.e., if we are close to the target interval, we avoid * changing the interval since there might be a natural variance in the * fillfactor across chunks. This is intended to avoid flip-flopping or unstable * behavior. * * Additionally, two other thresholds govern much of the algorithm's behavior. * First is the SIZE_FILLFACTOR_THRESH, which is the minimum percentage of * the extrapolated size a chunk should fill to be used in computing a new * target size. We want a minimum so as to not overreact to a chunk that is too * small to get an accurate extrapolation from. For example, a chunk that is * only a percentage point or two of the extrapolated size (or less!) may not * contain enough data to give a true sense of the data rate, i.e., if it was * made in a particularly bursty or slow period. * * However, in the event that an initial chunk size was set * way too small, the algorithm will never adjust because * _all_ the chunks fall below this threshold. Therefore we have another * threshold -- NUM_UNDERSIZED_INTERVALS -- that helps our algorithm make * progress to the correct estimate. If there are _no_ chunks that * meet SIZE_FILLFACTOR_THRESH, and at least NUM_UNDERSIZED_INTERVALS chunks * we are sufficiently full, we use those chunks to adjust the target chunk * size so that the next chunks created at least meet SIZE_FILLFACTOR_THRESH. * This will then allow the algorithm to work in the normal way to adjust * further if needed. */ Datum ts_calculate_chunk_interval(PG_FUNCTION_ARGS) { int32 dimension_id = PG_GETARG_INT32(0); int64 dimension_coord = PG_GETARG_INT64(1); int64 chunk_target_size_bytes = PG_GETARG_INT64(2); int64 chunk_interval = 0; int64 undersized_intervals = 0; int64 current_interval; int32 hypertable_id; Hypertable *ht; const Dimension *dim; List *chunks = NIL; ListCell *lc; int num_intervals = 0; int num_undersized_intervals = 0; double interval_diff; double undersized_fillfactor = 0.0; AclResult acl_result; if (PG_NARGS() != CHUNK_SIZING_FUNC_NARGS) elog(ERROR, "invalid number of arguments"); if (chunk_target_size_bytes < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("chunk_target_size must be positive"))); elog(DEBUG1, "[adaptive] chunk_target_size_bytes=" UINT64_FORMAT, chunk_target_size_bytes); hypertable_id = ts_dimension_get_hypertable_id(dimension_id); if (hypertable_id <= 0) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("could not find a matching hypertable for dimension %u", dimension_id))); ht = ts_hypertable_get_by_id(hypertable_id); Assert(ht != NULL); acl_result = pg_class_aclcheck(ht->main_table_relid, GetUserId(), ACL_SELECT); if (acl_result != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for table %s", NameStr(ht->fd.table_name)))); dim = ts_hyperspace_get_dimension_by_id(ht->space, dimension_id); Assert(dim != NULL); current_interval = dim->fd.interval_length; /* Get a window of recent chunks */ chunks = ts_chunk_get_window(dimension_id, dimension_coord, DEFAULT_CHUNK_WINDOW, CurrentMemoryContext); foreach (lc, chunks) { Chunk *chunk = lfirst(lc); const DimensionSlice *slice = ts_hypercube_get_slice_by_dimension_id(chunk->cube, dimension_id); int64 chunk_size, slice_interval; Datum minmax[2]; AttrNumber attno = ts_map_attno(ht->main_table_relid, chunk->table_id, dim->column_attno); Assert(NULL != slice); chunk_size = DatumGetInt64( DirectFunctionCall1(pg_total_relation_size, ObjectIdGetDatum(chunk->table_id))); slice_interval = slice->fd.range_end - slice->fd.range_start; if (chunk_get_minmax(chunk->table_id, dim->fd.column_type, attno, "adaptive chunking", minmax)) { int64 min = ts_time_value_to_internal(minmax[0], dim->fd.column_type); int64 max = ts_time_value_to_internal(minmax[1], dim->fd.column_type); double interval_fillfactor, size_fillfactor; int64 extrapolated_chunk_size; /* * The fillfactor of the slice interval that the data actually * spans */ interval_fillfactor = ((double) max - min) / slice_interval; /* * Extrapolate the size the chunk would have if it spanned the * entire interval */ extrapolated_chunk_size = chunk_size / interval_fillfactor; size_fillfactor = ((double) extrapolated_chunk_size) / chunk_target_size_bytes; elog(DEBUG2, "[adaptive] slice_interval=" UINT64_FORMAT " interval_fillfactor=%lf" " current_chunk_size=" UINT64_FORMAT " extrapolated_chunk_size=" UINT64_FORMAT " size_fillfactor=%lf", slice_interval, interval_fillfactor, chunk_size, extrapolated_chunk_size, size_fillfactor); /* * If the chunk is sufficiently filled with data and its * extrapolated size is large enough to make a good estimate, use * it */ if (interval_fillfactor > INTERVAL_FILLFACTOR_THRESH && size_fillfactor > SIZE_FILLFACTOR_THRESH) { chunk_interval += (slice_interval / size_fillfactor); num_intervals++; } /* * If the chunk is sufficiently filled with data but its * extrapolated size is too small, track it and maybe use it if it * is all we have */ else if (interval_fillfactor > INTERVAL_FILLFACTOR_THRESH) { elog(DEBUG2, "[adaptive] chunk sufficiently full, " "but undersized. may use for prediction."); undersized_intervals += slice_interval; undersized_fillfactor += size_fillfactor; num_undersized_intervals++; } } } elog(DEBUG1, "[adaptive] current interval=" UINT64_FORMAT " num_intervals=%d num_undersized_intervals=%d", current_interval, num_intervals, num_undersized_intervals); /* * No full sized intervals, but enough undersized intervals to adjust * higher. We only want to do this if there are no sufficiently sized * intervals to use for a normal adjustment. This keeps us from getting * stuck with a really small interval size. */ if (num_intervals == 0 && num_undersized_intervals > NUM_UNDERSIZED_INTERVALS) { double avg_fillfactor = undersized_fillfactor / num_undersized_intervals; double incr_factor = UNDERSIZED_FILLFACTOR_THRESH / avg_fillfactor; int64 avg_interval = undersized_intervals / num_undersized_intervals; elog(DEBUG1, "[adaptive] no sufficiently large intervals found, but " "some undersized ones found. increase interval to probe for better" " threshold. factor=%lf", incr_factor); chunk_interval = (int64) (avg_interval * incr_factor); } /* No data & insufficient amount of undersized chunks, keep old interval */ else if (num_intervals == 0) { elog(DEBUG1, "[adaptive] no sufficiently large intervals found, " "nor enough undersized chunks to estimate. " "use previous size of " UINT64_FORMAT, current_interval); PG_RETURN_INT64(current_interval); } else chunk_interval /= num_intervals; /* * If the interval hasn't really changed much from before, we keep the old * interval to ensure we do not have fluctuating behavior around the * target size. */ interval_diff = fabs(1.0 - ((double) chunk_interval / current_interval)); if (interval_diff <= INTERVAL_MIN_CHANGE_THRESH) { elog(DEBUG1, "[adaptive] calculated chunk interval=" UINT64_FORMAT ", but is below change threshold, keeping old interval", chunk_interval); chunk_interval = current_interval; } else { elog(LOG, "[adaptive] calculated chunk interval=" UINT64_FORMAT " for hypertable %d, making change", chunk_interval, hypertable_id); } PG_RETURN_INT64(chunk_interval); } /* * Validate that the provided function in the catalog can be used for * determining a new chunk size, i.e., has form (int,bigint,bigint) -> bigint. * * Parameter 'info' will be updated with the function's information */ void ts_chunk_sizing_func_validate(regproc func, ChunkSizingInfo *info) { HeapTuple tuple; Form_pg_proc form; Oid *typearr; if (!OidIsValid(func)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), (errmsg("invalid chunk sizing function")))); tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(func)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for function %u", func); form = (Form_pg_proc) GETSTRUCT(tuple); typearr = form->proargtypes.values; if (form->pronargs != CHUNK_SIZING_FUNC_NARGS || typearr[0] != INT4OID || typearr[1] != INT8OID || typearr[2] != INT8OID || form->prorettype != INT8OID) { ReleaseSysCache(tuple); ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("invalid function signature"), errhint("A chunk sizing function's signature should be (int, bigint, bigint) -> " "bigint"))); } if (NULL != info) { info->func = func; namestrcpy(&info->func_schema, get_namespace_name(form->pronamespace)); namestrcpy(&info->func_name, NameStr(form->proname)); } ReleaseSysCache(tuple); } /* * Parse the target size text into an integer amount of bytes. * * 'off' / 'disable' - returns a target of 0 * 'estimate' - returns a target based on number of bytes in shared memory * 'XXMB' / etc - converts from PostgreSQL pretty text into number of bytes */ static int64 chunk_target_size_in_bytes(const text *target_size_text) { const char *target_size = text_to_cstring(target_size_text); int64 target_size_bytes = 0; if (pg_strcasecmp(target_size, "off") == 0 || pg_strcasecmp(target_size, "disable") == 0) return 0; if (pg_strcasecmp(target_size, "estimate") == 0) target_size_bytes = ts_chunk_calculate_initial_chunk_target_size(); else target_size_bytes = convert_text_memory_amount_to_bytes(target_size); /* Disable if target size is zero or less */ if (target_size_bytes <= 0) target_size_bytes = 0; return target_size_bytes; } #define MB (1024 * 1024) void ts_chunk_adaptive_sizing_info_validate(ChunkSizingInfo *info) { AttrNumber attnum; NameData attname; Oid atttype; if (!OidIsValid(info->table_relid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("table does not exist"))); ts_hypertable_permissions_check(info->table_relid, GetUserId()); if (NULL == info->colname) ereport(ERROR, (errcode(ERRCODE_TS_DIMENSION_NOT_EXIST), errmsg("no open dimension found for adaptive chunking"))); attnum = get_attnum(info->table_relid, info->colname); namestrcpy(&attname, info->colname); atttype = get_atttype(info->table_relid, attnum); if (!OidIsValid(atttype)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" does not exist", info->colname))); ts_chunk_sizing_func_validate(info->func, info); if (NULL == info->target_size) info->target_size_bytes = 0; else info->target_size_bytes = chunk_target_size_in_bytes(info->target_size); /* Don't validate further if disabled */ if (info->target_size_bytes <= 0 || !OidIsValid(info->func)) return; /* Warn of small target sizes */ if (info->target_size_bytes > 0 && info->target_size_bytes < (10 * MB)) elog(WARNING, "target chunk size for adaptive chunking is less than 10 MB"); if (info->check_for_index && !table_has_minmax_index(info->table_relid, atttype, &attname, attnum)) ereport(WARNING, (errmsg("no index on \"%s\" found for adaptive chunking on hypertable \"%s\"", info->colname, get_rel_name(info->table_relid)), errdetail("Adaptive chunking works best with an index on the dimension being " "adapted."))); } TS_FUNCTION_INFO_V1(ts_chunk_adaptive_set); /* * Change the settings for adaptive chunking. */ Datum ts_chunk_adaptive_set(PG_FUNCTION_ARGS) { ChunkSizingInfo info = { .table_relid = PG_GETARG_OID(0), .target_size = PG_ARGISNULL(1) ? NULL : PG_GETARG_TEXT_P(1), .func = PG_ARGISNULL(2) ? InvalidOid : PG_GETARG_OID(2), .colname = NULL, .check_for_index = true, }; Hypertable *ht; const Dimension *dim; Cache *hcache; HeapTuple tuple; TupleDesc tupdesc; Datum values[2]; bool nulls[2] = { false, false }; TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid hypertable: cannot be NULL"))); if (!OidIsValid(info.table_relid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("table does not exist"))); ts_hypertable_permissions_check(info.table_relid, GetUserId()); ht = ts_hypertable_cache_get_cache_and_entry(info.table_relid, CACHE_FLAG_NONE, &hcache); /* Get the first open dimension that we will adapt on */ dim = ts_hyperspace_get_dimension(ht->space, DIMENSION_TYPE_OPEN, 0); if (NULL == dim) ereport(ERROR, (errcode(ERRCODE_TS_DIMENSION_NOT_EXIST), errmsg("no open dimension found for adaptive chunking"))); info.colname = NameStr(dim->fd.column_name); ts_chunk_adaptive_sizing_info_validate(&info); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "function returning record called in context that cannot accept type record"); tupdesc = BlessTupleDesc(tupdesc); if (OidIsValid(info.func)) { ht->chunk_sizing_func = info.func; values[0] = ObjectIdGetDatum(info.func); } else if (OidIsValid(ht->chunk_sizing_func)) { ts_chunk_sizing_func_validate(ht->chunk_sizing_func, &info); values[0] = ObjectIdGetDatum(ht->chunk_sizing_func); } else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid chunk sizing function"))); values[1] = Int64GetDatum(info.target_size_bytes); /* Update the hypertable entry */ ht->fd.chunk_target_size = info.target_size_bytes; ts_hypertable_update_chunk_sizing(ht); ts_cache_release(&hcache); tuple = heap_form_tuple(tupdesc, values, nulls); PG_RETURN_DATUM(HeapTupleGetDatum(tuple)); } static Oid get_default_chunk_sizing_fn_oid() { Oid chunkfnargtypes[] = { INT4OID, INT8OID, INT8OID }; List *funcname = list_make2(makeString(FUNCTIONS_SCHEMA_NAME), makeString(DEFAULT_CHUNK_SIZING_FN_NAME)); int nargs = sizeof(chunkfnargtypes) / sizeof(chunkfnargtypes[0]); Oid chunkfnoid = LookupFuncName(funcname, nargs, chunkfnargtypes, false); return chunkfnoid; } ChunkSizingInfo * ts_chunk_sizing_info_get_default_disabled(Oid table_relid) { ChunkSizingInfo *chunk_sizing_info = palloc(sizeof(*chunk_sizing_info)); *chunk_sizing_info = (ChunkSizingInfo){ .table_relid = table_relid, .target_size = NULL, .func = get_default_chunk_sizing_fn_oid(), .colname = NULL, .check_for_index = false, }; return chunk_sizing_info; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_adaptive.h�������������������������������������������������������������0000664�0000000�0000000�00000001524�15100345067�0020002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * NOTE: adaptive chunking is still in BETA */ #pragma once #include <postgres.h> #include "export.h" typedef struct ChunkSizingInfo { Oid table_relid; /* Set manually */ Oid func; text *target_size; const char *colname; /* The column of the dimension we are adapting * on */ bool check_for_index; /* Set if we should check for an index on * the dimension we are adapting on */ /* Validated info */ NameData func_name; NameData func_schema; int64 target_size_bytes; } ChunkSizingInfo; extern void ts_chunk_adaptive_sizing_info_validate(ChunkSizingInfo *info); extern void ts_chunk_sizing_func_validate(regproc func, ChunkSizingInfo *info); extern TSDLLEXPORT ChunkSizingInfo *ts_chunk_sizing_info_get_default_disabled(Oid table_relid); extern TSDLLEXPORT int64 ts_chunk_calculate_initial_chunk_target_size(void); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_constraint.c�����������������������������������������������������������0000664�0000000�0000000�00000117532�15100345067�0020373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/xact.h> #include <catalog/dependency.h> #include <catalog/heap.h> #include <catalog/indexing.h> #include <catalog/objectaddress.h> #include <catalog/pg_constraint.h> #include <commands/tablecmds.h> #include <funcapi.h> #include <nodes/makefuncs.h> #include <storage/lockdefs.h> #include <utils/builtins.h> #include <utils/hsearch.h> #include <utils/lsyscache.h> #include <utils/palloc.h> #include <utils/rel.h> #include <utils/relcache.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include "compat/compat.h" #include "chunk.h" #include "chunk_constraint.h" #include "chunk_index.h" #include "constraint.h" #include "debug_assert.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "errors.h" #include "export.h" #include "foreign_key.h" #include "hypercube.h" #include "hypertable.h" #include "partitioning.h" #include "process_utility.h" #include "scan_iterator.h" #include "scanner.h" #define DEFAULT_EXTRA_CONSTRAINTS_SIZE 4 #define CHUNK_CONSTRAINTS_SIZE(num_constraints) (sizeof(ChunkConstraint) * (num_constraints)) ChunkConstraints * ts_chunk_constraints_alloc(int size_hint, MemoryContext mctx) { ChunkConstraints *ccs = MemoryContextAlloc(mctx, sizeof(ChunkConstraints)); ccs->mctx = mctx; ccs->capacity = size_hint + DEFAULT_EXTRA_CONSTRAINTS_SIZE; ccs->num_constraints = 0; ccs->num_dimension_constraints = 0; ccs->constraints = MemoryContextAllocZero(mctx, CHUNK_CONSTRAINTS_SIZE(ccs->capacity)); return ccs; } ChunkConstraints * ts_chunk_constraints_copy(ChunkConstraints *chunk_constraints) { ChunkConstraints *copy = palloc(sizeof(ChunkConstraints)); memcpy(copy, chunk_constraints, sizeof(ChunkConstraints)); copy->constraints = palloc0(CHUNK_CONSTRAINTS_SIZE(chunk_constraints->capacity)); memcpy(copy->constraints, chunk_constraints->constraints, CHUNK_CONSTRAINTS_SIZE(chunk_constraints->num_constraints)); return copy; } static void chunk_constraints_expand(ChunkConstraints *ccs, int16 new_capacity) { MemoryContext old; if (new_capacity <= ccs->capacity) return; old = MemoryContextSwitchTo(ccs->mctx); ccs->capacity = new_capacity; Assert(ccs->constraints); /* repalloc() does not work with NULL argument */ ccs->constraints = repalloc(ccs->constraints, CHUNK_CONSTRAINTS_SIZE(new_capacity)); MemoryContextSwitchTo(old); } static void chunk_constraint_dimension_choose_name(Name dst, int32 dimension_slice_id) { snprintf(NameStr(*dst), NAMEDATALEN, "constraint_%d", dimension_slice_id); } static void chunk_constraint_choose_name(Name dst, const char *hypertable_constraint_name, int32 chunk_id) { char constrname[NAMEDATALEN]; CatalogSecurityContext sec_ctx; Assert(hypertable_constraint_name != NULL); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); snprintf(constrname, NAMEDATALEN, "%d_" INT64_FORMAT "_%s", chunk_id, ts_catalog_table_next_seq_id(ts_catalog_get(), CHUNK_CONSTRAINT), hypertable_constraint_name); ts_catalog_restore_user(&sec_ctx); namestrcpy(dst, constrname); } ChunkConstraint * ts_chunk_constraints_add(ChunkConstraints *ccs, int32 chunk_id, int32 dimension_slice_id, const char *constraint_name, const char *hypertable_constraint_name) { ChunkConstraint *cc; chunk_constraints_expand(ccs, ccs->num_constraints + 1); cc = &ccs->constraints[ccs->num_constraints++]; cc->fd.chunk_id = chunk_id; cc->fd.dimension_slice_id = dimension_slice_id; if (NULL == constraint_name) { if (is_dimension_constraint(cc)) { chunk_constraint_dimension_choose_name(&cc->fd.constraint_name, cc->fd.dimension_slice_id); namestrcpy(&cc->fd.hypertable_constraint_name, ""); } else chunk_constraint_choose_name(&cc->fd.constraint_name, hypertable_constraint_name, cc->fd.chunk_id); } else namestrcpy(&cc->fd.constraint_name, constraint_name); if (NULL != hypertable_constraint_name) namestrcpy(&cc->fd.hypertable_constraint_name, hypertable_constraint_name); if (is_dimension_constraint(cc)) ccs->num_dimension_constraints++; return cc; } static void chunk_constraint_fill_tuple_values(const ChunkConstraint *cc, Datum values[Natts_chunk_constraint], bool nulls[Natts_chunk_constraint]) { memset(values, 0, sizeof(Datum) * Natts_chunk_constraint); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_chunk_id)] = Int32GetDatum(cc->fd.chunk_id); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_dimension_slice_id)] = Int32GetDatum(cc->fd.dimension_slice_id); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)] = NameGetDatum(&cc->fd.constraint_name); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)] = NameGetDatum(&cc->fd.hypertable_constraint_name); if (is_dimension_constraint(cc)) nulls[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)] = true; else nulls[AttrNumberGetAttrOffset(Anum_chunk_constraint_dimension_slice_id)] = true; } static void chunk_constraint_insert_relation(const Relation rel, const ChunkConstraint *cc) { TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_chunk_constraint]; bool nulls[Natts_chunk_constraint] = { false }; chunk_constraint_fill_tuple_values(cc, values, nulls); ts_catalog_insert_values(rel, desc, values, nulls); } /* * Insert multiple chunk constraints into the metadata catalog. */ void ts_chunk_constraints_insert_metadata(const ChunkConstraints *ccs) { Catalog *catalog = ts_catalog_get(); CatalogSecurityContext sec_ctx; Relation rel; int i; rel = table_open(catalog_get_table_id(catalog, CHUNK_CONSTRAINT), RowExclusiveLock); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); for (i = 0; i < ccs->num_constraints; i++) chunk_constraint_insert_relation(rel, &ccs->constraints[i]); ts_catalog_restore_user(&sec_ctx); table_close(rel, RowExclusiveLock); } /* * Insert a single chunk constraints into the metadata catalog. */ void ts_chunk_constraint_insert(ChunkConstraint *constraint) { Catalog *catalog = ts_catalog_get(); CatalogSecurityContext sec_ctx; Relation rel; rel = table_open(catalog_get_table_id(catalog, CHUNK_CONSTRAINT), RowExclusiveLock); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); chunk_constraint_insert_relation(rel, constraint); ts_catalog_restore_user(&sec_ctx); table_close(rel, RowExclusiveLock); } ChunkConstraint * ts_chunk_constraints_add_from_tuple(ChunkConstraints *ccs, const TupleInfo *ti) { bool nulls[Natts_chunk_constraint]; Datum values[Natts_chunk_constraint]; ChunkConstraint *constraints; int32 dimension_slice_id; Name constraint_name; Name hypertable_constraint_name; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); MemoryContext oldcxt; heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); oldcxt = MemoryContextSwitchTo(ccs->mctx); constraint_name = DatumGetName(values[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)]); if (nulls[AttrNumberGetAttrOffset(Anum_chunk_constraint_dimension_slice_id)]) { dimension_slice_id = 0; hypertable_constraint_name = DatumGetName( values[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)]); } else { dimension_slice_id = DatumGetInt32( values[AttrNumberGetAttrOffset(Anum_chunk_constraint_dimension_slice_id)]); hypertable_constraint_name = DatumGetName(DirectFunctionCall1(namein, CStringGetDatum(""))); } constraints = ts_chunk_constraints_add(ccs, DatumGetInt32(values[AttrNumberGetAttrOffset( Anum_chunk_constraint_chunk_id)]), dimension_slice_id, NameStr(*constraint_name), NameStr(*hypertable_constraint_name)); MemoryContextSwitchTo(oldcxt); if (should_free) heap_freetuple(tuple); return constraints; } /* * Create a dimensional CHECK constraint for a partitioning dimension. */ Constraint * ts_chunk_constraint_dimensional_create(const Dimension *dim, const DimensionSlice *slice, const char *name) { Constraint *constr = NULL; Node *dimdef; ColumnRef *colref; List *compexprs = NIL; Oid type; if (slice->fd.range_start == PG_INT64_MIN && slice->fd.range_end == PG_INT64_MAX) return NULL; colref = makeNode(ColumnRef); colref->fields = list_make1(makeString(pstrdup(NameStr(dim->fd.column_name)))); colref->location = -1; /* Convert the dimensional ranges to the appropriate text/string * representation for the time type. For dimensions with a * partitioning/time function, use the function's output type. */ if (dim->partitioning != NULL) { /* Both open and closed dimensions can have a partitioning function */ PartitioningInfo *partinfo = dim->partitioning; List *funcname = list_make2(makeString(NameStr(partinfo->partfunc.schema)), makeString(NameStr(partinfo->partfunc.name))); dimdef = (Node *) makeFuncCall(funcname, list_make1(colref), COERCE_EXPLICIT_CALL, -1); if (IS_OPEN_DIMENSION(dim)) { /* The dimension has a time function to compute the time value so * need to convert the range values to the time type returned by * the partitioning function. */ type = partinfo->partfunc.rettype; } else { /* Closed dimension, just use the INT8 type */ type = INT8OID; } } else { /* Must be open dimension, since no partitioning function */ Assert(IS_OPEN_DIMENSION(dim)); dimdef = (Node *) colref; type = dim->fd.column_type; } /* * We are forcing ISO datestyle here to prevent parsing errors with * certain timezone/datestyle combinations. */ int current_datestyle = DateStyle; DateStyle = USE_ISO_DATES; char *start_str = ts_internal_to_time_string(slice->fd.range_start, type); char *end_str = ts_internal_to_time_string(slice->fd.range_end, type); DateStyle = current_datestyle; /* Elide range constraint for +INF or -INF */ if (slice->fd.range_start != PG_INT64_MIN) { A_Const *start_const = makeNode(A_Const); memcpy(&start_const->val, makeString(start_str), sizeof(start_const->val)); start_const->location = -1; A_Expr *ge_expr = makeSimpleA_Expr(AEXPR_OP, ">=", dimdef, (Node *) start_const, -1); compexprs = lappend(compexprs, ge_expr); } if (slice->fd.range_end != PG_INT64_MAX) { A_Const *end_const = makeNode(A_Const); memcpy(&end_const->val, makeString(end_str), sizeof(end_const->val)); end_const->location = -1; A_Expr *lt_expr = makeSimpleA_Expr(AEXPR_OP, "<", dimdef, (Node *) end_const, -1); compexprs = lappend(compexprs, lt_expr); } constr = makeNode(Constraint); constr->contype = CONSTR_CHECK; constr->conname = name ? pstrdup(name) : NULL; constr->deferrable = false; constr->skip_validation = true; constr->initially_valid = true; #if PG18_GE constr->is_enforced = true; #endif Assert(list_length(compexprs) >= 1); if (list_length(compexprs) == 2) constr->raw_expr = (Node *) makeBoolExpr(AND_EXPR, compexprs, -1); else if (list_length(compexprs) == 1) constr->raw_expr = linitial(compexprs); return constr; } /* * Add a constraint to a chunk table. */ static Oid chunk_constraint_create_on_table(const ChunkConstraint *cc, Oid chunk_oid) { HeapTuple tuple; Datum values[Natts_chunk_constraint]; bool nulls[Natts_chunk_constraint] = { false }; CatalogSecurityContext sec_ctx; Relation rel; chunk_constraint_fill_tuple_values(cc, values, nulls); rel = RelationIdGetRelation(catalog_get_table_id(ts_catalog_get(), CHUNK_CONSTRAINT)); tuple = heap_form_tuple(RelationGetDescr(rel), values, nulls); RelationClose(rel); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); CatalogInternalCall1(DDL_ADD_CHUNK_CONSTRAINT, HeapTupleGetDatum(tuple)); ts_catalog_restore_user(&sec_ctx); heap_freetuple(tuple); return get_relation_constraint_oid(chunk_oid, NameStr(cc->fd.constraint_name), true); } /* * Create a non-dimensional constraint on a chunk table (foreign key, trigger * constraint, etc.), including adding relevant metadata to the catalog. */ static Oid create_non_dimensional_constraint(const ChunkConstraint *cc, Oid chunk_oid, int32 chunk_id, Oid hypertable_oid, int32 hypertable_id) { Oid chunk_constraint_oid; Assert(!is_dimension_constraint(cc)); /* * If we're creating constraints for a new chunk from an existing * table or attaching a chunk to an existing hypertable, we might * have constraints already created. If so, skip creating * such constraints, we only needed their metadata to be added. */ if (ConstraintNameIsUsed(CONSTRAINT_RELATION, chunk_oid, NameStr(cc->fd.constraint_name))) { chunk_constraint_oid = get_relation_constraint_oid(chunk_oid, NameStr(cc->fd.constraint_name), true); } else { ts_process_utility_set_expect_chunk_modification(true); chunk_constraint_oid = chunk_constraint_create_on_table(cc, chunk_oid); ts_process_utility_set_expect_chunk_modification(false); } return chunk_constraint_oid; } static const DimensionSlice * get_slice_with_id(const Hypercube *cube, int32 id) { int i; for (i = 0; i < cube->num_slices; i++) { const DimensionSlice *slice = cube->slices[i]; if (slice->fd.id == id) return slice; } return NULL; } /* * Create a set of constraints on a chunk table. */ void ts_chunk_constraints_create(const Hypertable *ht, const Chunk *chunk) { const ChunkConstraints *ccs = chunk->constraints; List *newconstrs = NIL; int i; for (i = 0; i < ccs->num_constraints; i++) { const ChunkConstraint *cc = &ccs->constraints[i]; if (is_dimension_constraint(cc)) { const DimensionSlice *slice = get_slice_with_id(chunk->cube, cc->fd.dimension_slice_id); const Dimension *dim; Constraint *constr; dim = ts_hyperspace_get_dimension_by_id(ht->space, slice->fd.dimension_id); Assert(dim); constr = ts_chunk_constraint_dimensional_create(dim, slice, NameStr(cc->fd.constraint_name)); /* In some cases, a CHECK constraint is not needed. For instance, * if the range is -INF to +INF. */ if (constr != NULL) newconstrs = lappend(newconstrs, constr); } else { create_non_dimensional_constraint(cc, chunk->table_id, chunk->fd.id, ht->main_table_relid, ht->fd.id); } } if (newconstrs != NIL) { List PG_USED_FOR_ASSERTS_ONLY *cookedconstrs = NIL; Relation rel = table_open(chunk->table_id, AccessExclusiveLock); cookedconstrs = AddRelationNewConstraints(rel, NIL /* List *newColDefaults */, newconstrs, false /* allow_merge */, true /* is_local */, false /* is_internal */, NULL /* query string */); table_close(rel, NoLock); Assert(list_length(cookedconstrs) == list_length(newconstrs)); CommandCounterIncrement(); } /* Copy FK triggers to this chunk */ ts_chunk_copy_referencing_fk(ht, chunk); } ScanIterator ts_chunk_constraint_scan_iterator_create(MemoryContext result_mcxt) { ScanIterator it = ts_scan_iterator_create(CHUNK_CONSTRAINT, AccessShareLock, result_mcxt); it.ctx.flags |= SCANNER_F_NOEND_AND_NOCLOSE; return it; } void ts_chunk_constraint_scan_iterator_set_slice_id(ScanIterator *it, int32 slice_id) { it->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK_CONSTRAINT, CHUNK_CONSTRAINT_DIMENSION_SLICE_ID_IDX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init(it, Anum_chunk_constraint_dimension_slice_id_idx_dimension_slice_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(slice_id)); } void ts_chunk_constraint_scan_iterator_set_chunk_id(ScanIterator *it, int32 chunk_id) { it->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK_CONSTRAINT, CHUNK_CONSTRAINT_CHUNK_ID_CONSTRAINT_NAME_IDX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init(it, Anum_chunk_constraint_chunk_id_constraint_name_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); } static void init_scan_by_chunk_id_constraint_name(ScanIterator *iterator, int32 chunk_id, const char *constraint_name) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK_CONSTRAINT, CHUNK_CONSTRAINT_CHUNK_ID_CONSTRAINT_NAME_IDX); ts_scan_iterator_scan_key_reset(iterator); ts_scan_iterator_scan_key_init(iterator, Anum_chunk_constraint_chunk_id_constraint_name_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); ts_scan_iterator_scan_key_init( iterator, Anum_chunk_constraint_chunk_id_constraint_name_idx_constraint_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(constraint_name)); } /* * Scan all the chunk's constraints given its chunk ID. * * Returns a set of chunk constraints. */ ChunkConstraints * ts_chunk_constraint_scan_by_chunk_id(int32 chunk_id, Size num_constraints_hint, MemoryContext mctx) { ChunkConstraints *constraints = ts_chunk_constraints_alloc(num_constraints_hint, mctx); ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, AccessShareLock, mctx); int num_found = 0; ts_chunk_constraint_scan_iterator_set_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { num_found++; ts_chunk_constraints_add_from_tuple(constraints, ts_scan_iterator_tuple_info(&iterator)); } if (num_found != constraints->num_constraints) elog(ERROR, "unexpected number of constraints found for chunk ID %d", chunk_id); return constraints; } /* * Scan for all chunk constraints that match the given slice ID. The chunk * constraints are saved in the chunk scan context. */ int ts_chunk_constraint_scan_by_dimension_slice(const DimensionSlice *slice, ChunkScanCtx *ctx, MemoryContext mctx) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, AccessShareLock, mctx); int count = 0; ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, slice->fd.id); ts_scanner_foreach(&iterator) { const Hyperspace *hs = ctx->ht->space; ChunkStub *stub; ChunkScanEntry *entry; bool found; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Datum datum = slot_getattr(ti->slot, Anum_chunk_constraint_chunk_id, &found); int32 chunk_id = DatumGetInt32(datum); if (slot_attisnull(ts_scan_iterator_slot(&iterator), Anum_chunk_constraint_dimension_slice_id)) continue; count++; Assert(!slot_attisnull(ti->slot, Anum_chunk_constraint_dimension_slice_id)); entry = hash_search(ctx->htab, &chunk_id, HASH_ENTER, &found); if (!found) { stub = ts_chunk_stub_create(chunk_id, hs->num_dimensions); stub->cube = ts_hypercube_alloc(hs->num_dimensions); entry->stub = stub; } else stub = entry->stub; ts_chunk_constraints_add_from_tuple(stub->constraints, ti); ts_hypercube_add_slice(stub->cube, slice); /* A stub is complete when we've added slices for all its dimensions, * i.e., a complete hypercube */ if (chunk_stub_is_complete(stub, ctx->ht->space)) { ctx->num_complete_chunks++; if (ctx->early_abort) { ts_scan_iterator_close(&iterator); break; } } } return count; } /* * Similar to chunk_constraint_scan_by_dimension_slice, but stores only chunk_ids * in a list, which is easier to traverse and provides deterministic chunk selection. */ int ts_chunk_constraint_scan_by_dimension_slice_to_list(const DimensionSlice *slice, List **list, MemoryContext mctx) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, AccessShareLock, mctx); int count = 0; ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, slice->fd.id); ts_scanner_foreach(&iterator) { bool is_null; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Datum chunk_id; if (slot_attisnull(ti->slot, Anum_chunk_constraint_dimension_slice_id)) continue; count++; chunk_id = slot_getattr(ti->slot, Anum_chunk_constraint_chunk_id, &is_null); Assert(!is_null); *list = lappend_int(*list, DatumGetInt32(chunk_id)); } return count; } /* * Scan for chunk constraints given a dimension slice ID. * * Optionally, collect all chunk constraints if ChunkConstraints is non-NULL. */ int ts_chunk_constraint_scan_by_dimension_slice_id(int32 dimension_slice_id, ChunkConstraints *ccs, MemoryContext mctx) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, AccessShareLock, mctx); int count = 0; ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, dimension_slice_id); ts_scanner_foreach(&iterator) { if (slot_attisnull(ts_scan_iterator_slot(&iterator), Anum_chunk_constraint_dimension_slice_id)) continue; count++; if (ccs != NULL) ts_chunk_constraints_add_from_tuple(ccs, ts_scan_iterator_tuple_info(&iterator)); } return count; } static bool chunk_constraint_need_on_chunk(Form_pg_constraint conform) { if (conform->contype == CONSTRAINT_CHECK #if PG18_GE /* Avoid NOT NULL constraints * https://github.com/postgres/postgres/commit/b0e96f31 */ || conform->contype == CONSTRAINT_NOTNULL #endif ) { /* * check and not null constraints handled by regular inheritance (from * docs): All check constraints and not-null constraints on a parent * table are automatically inherited by its children, unless * explicitly specified otherwise with NO INHERIT clauses. Other types * of constraints (unique, primary key, and foreign key constraints) * are not inherited." */ return false; } /* Check if the foreign key constraint references a partition in a partitioned table. In that case, we shouldn't include this constraint as we will end up checking the foreign key constraint once for every partition, which obviously leads to foreign key constraint violation. Instead, we only include constraints referencing the parent table of the partitioned table. */ if (conform->contype == CONSTRAINT_FOREIGN && OidIsValid(conform->conparentid)) return false; return true; } int ts_chunk_constraints_add_dimension_constraints(ChunkConstraints *ccs, int32 chunk_id, const Hypercube *cube) { int i; for (i = 0; i < cube->num_slices; i++) ts_chunk_constraints_add(ccs, chunk_id, cube->slices[i]->fd.id, NULL, NULL); return cube->num_slices; } typedef struct ConstraintContext { int num_added; char chunk_relkind; ChunkConstraints *ccs; int32 chunk_id; Oid chunk_relid; } ConstraintContext; static ConstraintProcessStatus chunk_constraint_add(HeapTuple constraint_tuple, void *arg) { ConstraintContext *cc = arg; Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(constraint_tuple); if (cc->chunk_relkind != RELKIND_FOREIGN_TABLE && chunk_constraint_need_on_chunk(constraint)) { /* If the chunk already has an equivalent constraint, use the existing one. */ Relation chunk = table_open(cc->chunk_relid, AccessShareLock); Form_pg_constraint matching_const = ts_constraint_find_matching(constraint_tuple, chunk); table_close(chunk, NoLock); if (matching_const != NULL) ts_chunk_constraints_add(cc->ccs, cc->chunk_id, 0, NameStr(matching_const->conname), NameStr(constraint->conname)); else ts_chunk_constraints_add(cc->ccs, cc->chunk_id, 0, NULL, NameStr(constraint->conname)); return CONSTR_PROCESSED; } return CONSTR_IGNORED; } int ts_chunk_constraints_add_inheritable_constraints(ChunkConstraints *ccs, int32 chunk_id, const char chunk_relkind, Oid hypertable_oid, Oid table_id) { /* This should never be called with NULL ccs. */ Ensure(ccs, "ccs must not be NULL"); ConstraintContext cc = { .chunk_relkind = chunk_relkind, .ccs = ccs, .chunk_id = chunk_id, .chunk_relid = table_id, }; return ts_constraint_process(hypertable_oid, chunk_constraint_add, &cc); } /* check constraints have the same name as the one on the hypertable */ static ConstraintProcessStatus chunk_constraint_add_check(HeapTuple constraint_tuple, void *arg) { ConstraintContext *cc = arg; Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(constraint_tuple); if (constraint->contype == CONSTRAINT_CHECK) { ts_chunk_constraints_add(cc->ccs, cc->chunk_id, 0, NameStr(constraint->conname), NameStr(constraint->conname)); return CONSTR_PROCESSED; } return CONSTR_IGNORED; } /* Adds only inheritable check constraints */ int ts_chunk_constraints_add_inheritable_check_constraints(ChunkConstraints *ccs, int32 chunk_id, const char chunk_relkind, Oid hypertable_oid) { ConstraintContext cc = { .chunk_relkind = chunk_relkind, .ccs = ccs, .chunk_id = chunk_id, }; return ts_constraint_process(hypertable_oid, chunk_constraint_add_check, &cc); } void ts_chunk_constraint_create_on_chunk(const Hypertable *ht, const Chunk *chunk, Oid constraint_oid) { HeapTuple tuple; Form_pg_constraint con; tuple = SearchSysCache1(CONSTROID, ObjectIdGetDatum(constraint_oid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for constraint %u", constraint_oid); con = (Form_pg_constraint) GETSTRUCT(tuple); if (chunk->relkind != RELKIND_FOREIGN_TABLE && chunk_constraint_need_on_chunk(con)) { ChunkConstraint *cc = ts_chunk_constraints_add(chunk->constraints, chunk->fd.id, 0, NULL, NameStr(con->conname)); ts_chunk_constraint_insert(cc); create_non_dimensional_constraint(cc, chunk->table_id, chunk->fd.id, ht->main_table_relid, ht->fd.id); } ReleaseSysCache(tuple); } static bool hypertable_constraint_matches_tuple(TupleInfo *ti, const char *hypertable_constraint_name) { bool isnull; Datum name = slot_getattr(ti->slot, Anum_chunk_constraint_hypertable_constraint_name, &isnull); return !isnull && namestrcmp(DatumGetName(name), hypertable_constraint_name) == 0; } static void chunk_constraint_drop_constraint(TupleInfo *ti) { bool isnull; Datum constrname = slot_getattr(ti->slot, Anum_chunk_constraint_constraint_name, &isnull); int32 chunk_id = DatumGetInt32(slot_getattr(ti->slot, Anum_chunk_constraint_chunk_id, &isnull)); /* Get the chunk relid. Note that, at this point, the chunk table can be * deleted already. */ Oid chunk_relid = ts_chunk_get_relid(chunk_id, true); if (OidIsValid(chunk_relid)) { ObjectAddress constrobj = { .classId = ConstraintRelationId, .objectId = get_relation_constraint_oid(chunk_relid, NameStr(*DatumGetName(constrname)), true), }; if (OidIsValid(constrobj.objectId)) /* must use DROP_CASCADE if regular table references a hypertable */ performDeletion(&constrobj, DROP_CASCADE, 0); } } int ts_chunk_constraint_delete_by_hypertable_constraint_name(int32 chunk_id, const char *hypertable_constraint_name) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; ts_chunk_constraint_scan_iterator_set_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { if (!hypertable_constraint_matches_tuple(ts_scan_iterator_tuple_info(&iterator), hypertable_constraint_name)) continue; count++; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); chunk_constraint_drop_constraint(ti); } return count; } int ts_chunk_constraint_delete_by_constraint_name(int32 chunk_id, const char *constraint_name) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; init_scan_by_chunk_id_constraint_name(&iterator, chunk_id, constraint_name); ts_scanner_foreach(&iterator) { count++; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); } return count; } /* * Delete all constraints for a chunk. Optionally, collect the deleted constraints. */ int ts_chunk_constraint_delete_by_chunk_id(int32 chunk_id, ChunkConstraints *ccs, bool drop_constraint) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; ts_chunk_constraint_scan_iterator_set_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { count++; ts_chunk_constraints_add_from_tuple(ccs, ts_scan_iterator_tuple_info(&iterator)); TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); if (drop_constraint) chunk_constraint_drop_constraint(ts_scan_iterator_tuple_info(&iterator)); } return count; } int ts_chunk_constraint_delete_by_dimension_slice_id(int32 dimension_slice_id) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, dimension_slice_id); ts_scanner_foreach(&iterator) { count++; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); chunk_constraint_drop_constraint(ti); } return count; } void ts_chunk_constraints_recreate(const Hypertable *ht, const Chunk *chunk) { const ChunkConstraints *ccs = chunk->constraints; int i; for (i = 0; i < ccs->num_constraints; i++) { const ChunkConstraint *cc = &ccs->constraints[i]; ObjectAddress constrobj = { .classId = ConstraintRelationId, .objectId = get_relation_constraint_oid(chunk->table_id, NameStr(cc->fd.constraint_name), false), }; performDeletion(&constrobj, DROP_RESTRICT, 0); } ts_chunk_constraints_create(ht, chunk); } static void chunk_constraint_rename_on_chunk_table(int32 chunk_id, const char *old_name, const char *new_name) { Oid chunk_relid = ts_chunk_get_relid(chunk_id, false); Oid nspid = get_rel_namespace(chunk_relid); RenameStmt rename = { .renameType = OBJECT_TABCONSTRAINT, .relation = makeRangeVar(get_namespace_name(nspid), get_rel_name(chunk_relid), 0), .subname = pstrdup(old_name), .newname = pstrdup(new_name), }; RenameConstraint(&rename); } static void chunk_constraint_rename_hypertable_from_tuple(TupleInfo *ti, const char *new_name) { bool nulls[Natts_chunk_constraint]; Datum values[Natts_chunk_constraint]; bool doReplace[Natts_chunk_constraint] = { false }; HeapTuple tuple, new_tuple; TupleDesc tupdesc = ts_scanner_get_tupledesc(ti); NameData new_hypertable_constraint_name; NameData new_chunk_constraint_name; Name old_chunk_constraint_name; int32 chunk_id; bool should_free; tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); heap_deform_tuple(tuple, tupdesc, values, nulls); chunk_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_constraint_chunk_id)]); namestrcpy(&new_hypertable_constraint_name, new_name); chunk_constraint_choose_name(&new_chunk_constraint_name, new_name, chunk_id); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)] = NameGetDatum(&new_hypertable_constraint_name); doReplace[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)] = true; old_chunk_constraint_name = DatumGetName(values[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)]); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)] = NameGetDatum(&new_chunk_constraint_name); doReplace[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)] = true; chunk_constraint_rename_on_chunk_table(chunk_id, NameStr(*old_chunk_constraint_name), NameStr(new_chunk_constraint_name)); new_tuple = heap_modify_tuple(tuple, tupdesc, values, nulls, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); } /* * Adjust internal metadata after index/constraint rename */ int ts_chunk_constraint_adjust_meta(int32 chunk_id, const char *ht_name, const char *chunk_old_name, const char *chunk_new_name) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; init_scan_by_chunk_id_constraint_name(&iterator, chunk_id, chunk_old_name); ts_scanner_foreach(&iterator) { bool nulls[Natts_chunk_constraint]; bool doReplace[Natts_chunk_constraint] = { false }; Datum values[Natts_chunk_constraint]; bool should_free; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); /* * The constraint names are of Postgres type 'name' which is fixed-width * 64-byte type. The input strings might not have the necessary padding * after them. */ NameData ht_constraint_namedata; namestrcpy(&ht_constraint_namedata, ht_name); NameData new_namedata; namestrcpy(&new_namedata, chunk_new_name); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)] = NameGetDatum(&ht_constraint_namedata); doReplace[AttrNumberGetAttrOffset(Anum_chunk_constraint_hypertable_constraint_name)] = true; values[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)] = NameGetDatum(&new_namedata); doReplace[AttrNumberGetAttrOffset(Anum_chunk_constraint_constraint_name)] = true; new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); count++; } return count; } bool ts_chunk_constraint_update_slice_id(int32 chunk_id, int32 old_slice_id, int32 new_slice_id) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); ts_chunk_constraint_scan_iterator_set_slice_id(&iterator, old_slice_id); ts_scanner_foreach(&iterator) { bool replIsnull[Natts_chunk_constraint]; bool repl[Natts_chunk_constraint] = { false }; Datum values[Natts_chunk_constraint]; bool should_free, isnull; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); int32 current_chunk_id = DatumGetInt32(slot_getattr(ti->slot, Anum_chunk_constraint_chunk_id, &isnull)); if (isnull || current_chunk_id != chunk_id) continue; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, replIsnull); values[AttrNumberGetAttrOffset(Anum_chunk_constraint_dimension_slice_id)] = Int32GetDatum(new_slice_id); repl[AttrNumberGetAttrOffset(Anum_chunk_constraint_dimension_slice_id)] = true; new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, replIsnull, repl); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); ts_scan_iterator_close(&iterator); return true; } return false; } int ts_chunk_constraint_rename_hypertable_constraint(int32 chunk_id, const char *old_name, const char *new_name) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; ts_chunk_constraint_scan_iterator_set_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { if (!hypertable_constraint_matches_tuple(ts_scan_iterator_tuple_info(&iterator), old_name)) continue; count++; chunk_constraint_rename_hypertable_from_tuple(ts_scan_iterator_tuple_info(&iterator), new_name); } return count; } char * ts_chunk_constraint_get_name_from_hypertable_constraint(Oid chunk_relid, const char *hypertable_constraint_name) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); Datum chunk_id = DirectFunctionCall1(ts_chunk_id_from_relid, ObjectIdGetDatum(chunk_relid)); ts_chunk_constraint_scan_iterator_set_chunk_id(&iterator, DatumGetInt32(chunk_id)); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); MemoryContext oldmctx; bool isnull; Datum datum; char *name; if (!hypertable_constraint_matches_tuple(ti, hypertable_constraint_name)) continue; datum = slot_getattr(ti->slot, Anum_chunk_constraint_constraint_name, &isnull); Assert(!isnull); oldmctx = MemoryContextSwitchTo(ti->mctx); name = pstrdup(NameStr(*DatumGetName(datum))); MemoryContextSwitchTo(oldmctx); ts_scan_iterator_close(&iterator); return name; } return NULL; } int ts_chunk_constraint_delete_dimensional_constraints(int32 chunk_id, ChunkConstraints *ccs) { ScanIterator iterator = ts_scan_iterator_create(CHUNK_CONSTRAINT, RowExclusiveLock, CurrentMemoryContext); int count = 0; ts_chunk_constraint_scan_iterator_set_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool isnull; int32 slice_id = DatumGetInt32( slot_getattr(ti->slot, Anum_chunk_constraint_dimension_slice_id, &isnull)); if (isnull || slice_id == 0) continue; count++; ts_chunk_constraints_add_from_tuple(ccs, ti); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); chunk_constraint_drop_constraint(ti); } return count; } /* * Drop a constraint using a pg_constraint heap tuple. */ void ts_chunk_constraint_drop_from_tuple(HeapTuple constraint_tuple) { FormData_pg_constraint *constr = (FormData_pg_constraint *) GETSTRUCT(constraint_tuple); ObjectAddress constrobj = { .classId = ConstraintRelationId, .objectId = constr->oid, }; if (OidIsValid(constr->conparentid)) { deleteDependencyRecordsForClass(constrobj.classId, constrobj.objectId, ConstraintRelationId, DEPENDENCY_INTERNAL); CommandCounterIncrement(); } if (OidIsValid(constrobj.objectId)) performDeletion(&constrobj, DROP_RESTRICT, 0); } static void check_chunk_constraint_violated(Oid chunk_relid, const Dimension *dim, const DimensionSlice *slice) { Relation rel; TupleTableSlot *slot; TableScanDesc scandesc; bool isnull; int attno = get_attnum(chunk_relid, NameStr(dim->fd.column_name)); Ensure(attno != InvalidAttrNumber, "invalid attribute number"); PushActiveSnapshot(GetLatestSnapshot()); rel = table_open(chunk_relid, AccessShareLock); scandesc = table_beginscan(rel, GetActiveSnapshot(), 0, NULL); slot = table_slot_create(rel, NULL); while (table_scan_getnextslot(scandesc, ForwardScanDirection, slot)) { Datum datum; int64 value; datum = slot_getattr(slot, attno, &isnull); Assert(!isnull); if (NULL != dim->partitioning) { Oid collation = TupleDescAttr(slot->tts_tupleDescriptor, AttrNumberGetAttrOffset(attno)) ->attcollation; datum = ts_partitioning_func_apply(dim->partitioning, collation, datum); } if (dim->type == DIMENSION_TYPE_OPEN) value = ts_time_value_to_internal(datum, ts_dimension_get_partition_type(dim)); else if (dim->type == DIMENSION_TYPE_CLOSED) value = (int64) DatumGetInt32(datum); else elog(ERROR, "invalid dimension type when checking constraint"); if (value < slice->fd.range_start || value >= slice->fd.range_end) ereport(ERROR, (errcode(ERRCODE_CHECK_VIOLATION), errmsg("dimension constraint for column \"%s\" violated by some row", NameStr(dim->fd.column_name)))); } ExecDropSingleTupleTableSlot(slot); table_endscan(scandesc); table_close(rel, NoLock); PopActiveSnapshot(); } /* * Check whether the chunk has any row that violates any of its dimensional constraints */ void ts_chunk_constraint_check_violated(const Chunk *chunk, const Hyperspace *hs) { const ChunkConstraints *ccs = chunk->constraints; for (int i = 0; i < ccs->num_constraints; i++) { const ChunkConstraint *cc = &ccs->constraints[i]; if (is_dimension_constraint(cc)) { const DimensionSlice *slice = get_slice_with_id(chunk->cube, cc->fd.dimension_slice_id); const Dimension *dim; dim = ts_hyperspace_get_dimension_by_id(hs, slice->fd.dimension_id); Assert(dim); /* Check if the chunk has any row that violates the constraint */ check_chunk_constraint_violated(chunk->table_id, dim, slice); } } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_constraint.h�����������������������������������������������������������0000664�0000000�0000000�00000011310�15100345067�0020363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pg_list.h> #include "hypertable.h" #include "ts_catalog/catalog.h" typedef struct ChunkConstraint { FormData_chunk_constraint fd; } ChunkConstraint; typedef struct ChunkConstraints { MemoryContext mctx; int16 capacity; int16 num_constraints; int16 num_dimension_constraints; ChunkConstraint *constraints; } ChunkConstraints; #define chunk_constraints_get(cc, i) &((cc)->constraints[i]) #define is_dimension_constraint(cc) ((cc)->fd.dimension_slice_id > 0) typedef struct Chunk Chunk; typedef struct DimensionSlice DimensionSlice; typedef struct Hypercube Hypercube; typedef struct ChunkScanCtx ChunkScanCtx; extern TSDLLEXPORT ChunkConstraints *ts_chunk_constraints_alloc(int size_hint, MemoryContext mctx); extern ChunkConstraints * ts_chunk_constraint_scan_by_chunk_id(int32 chunk_id, Size num_constraints_hint, MemoryContext mctx); extern ChunkConstraints *ts_chunk_constraints_copy(ChunkConstraints *chunk_constraints); extern int ts_chunk_constraint_scan_by_dimension_slice(const DimensionSlice *slice, ChunkScanCtx *ctx, MemoryContext mctx); extern int ts_chunk_constraint_scan_by_dimension_slice_to_list(const DimensionSlice *slice, List **list, MemoryContext mctx); extern int TSDLLEXPORT ts_chunk_constraint_scan_by_dimension_slice_id(int32 dimension_slice_id, ChunkConstraints *ccs, MemoryContext mctx); extern ChunkConstraint *ts_chunk_constraints_add(ChunkConstraints *ccs, int32 chunk_id, int32 dimension_slice_id, const char *constraint_name, const char *hypertable_constraint_name); extern int ts_chunk_constraints_add_dimension_constraints(ChunkConstraints *ccs, int32 chunk_id, const Hypercube *cube); extern TSDLLEXPORT int ts_chunk_constraints_add_inheritable_constraints(ChunkConstraints *ccs, int32 chunk_id, const char chunk_relkind, Oid hypertable_oid, Oid table_id); extern TSDLLEXPORT int ts_chunk_constraints_add_inheritable_check_constraints( ChunkConstraints *ccs, int32 chunk_id, const char chunk_relkind, Oid hypertable_oid); extern TSDLLEXPORT void ts_chunk_constraints_insert_metadata(const ChunkConstraints *ccs); extern TSDLLEXPORT Constraint *ts_chunk_constraint_dimensional_create(const Dimension *dim, const DimensionSlice *slice, const char *name); extern TSDLLEXPORT void ts_chunk_constraints_create(const Hypertable *ht, const Chunk *chunk); extern void ts_chunk_constraint_create_on_chunk(const Hypertable *ht, const Chunk *chunk, Oid constraint_oid); extern int ts_chunk_constraint_delete_by_hypertable_constraint_name(int32 chunk_id, const char *hypertable_constraint_name); extern int ts_chunk_constraint_delete_by_chunk_id(int32 chunk_id, ChunkConstraints *ccs, bool drop_constraint); extern int ts_chunk_constraint_delete_by_dimension_slice_id(int32 dimension_slice_id); extern int ts_chunk_constraint_delete_by_constraint_name(int32 chunk_id, const char *constraint_name); extern void ts_chunk_constraints_recreate(const Hypertable *ht, const Chunk *chunk); extern int ts_chunk_constraint_rename_hypertable_constraint(int32 chunk_id, const char *old_name, const char *new_name); extern int ts_chunk_constraint_adjust_meta(int32 chunk_id, const char *ht_name, const char *chunk_old_name, const char *chunk_new_name); extern TSDLLEXPORT bool ts_chunk_constraint_update_slice_id(int32 chunk_id, int32 old_slice_id, int32 new_slice_id); extern char * ts_chunk_constraint_get_name_from_hypertable_constraint(Oid chunk_relid, const char *hypertable_constraint_name); extern void ts_chunk_constraint_insert(ChunkConstraint *constraint); extern ChunkConstraint *ts_chunk_constraints_add_from_tuple(ChunkConstraints *ccs, const TupleInfo *ti); extern ScanIterator ts_chunk_constraint_scan_iterator_create(MemoryContext result_mcxt); extern void ts_chunk_constraint_scan_iterator_set_slice_id(ScanIterator *it, int32 slice_id); extern void ts_chunk_constraint_scan_iterator_set_chunk_id(ScanIterator *it, int32 chunk_id); extern int ts_chunk_constraint_delete_dimensional_constraints(int32 chunk_id, ChunkConstraints *ccs); extern TSDLLEXPORT void ts_chunk_constraint_drop_from_tuple(HeapTuple constraint_tuple); extern TSDLLEXPORT void ts_chunk_constraint_check_violated(const Chunk *chunk, const Hyperspace *hs); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_index.c����������������������������������������������������������������0000664�0000000�0000000�00000045230�15100345067�0017311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/xact.h> #include <catalog/dependency.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/objectaddress.h> #include <catalog/pg_constraint.h> #include <catalog/pg_depend.h> #include <catalog/pg_index.h> #include <commands/cluster.h> #include <commands/defrem.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <miscadmin.h> #include <nodes/parsenodes.h> #include <optimizer/optimizer.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/syscache.h> #include "chunk.h" #include "chunk_index.h" #include "hypertable.h" #include "hypertable_cache.h" #include "indexing.h" #include "scan_iterator.h" #include "scanner.h" #include "ts_catalog/catalog.h" static Oid ts_chunk_index_create_post_adjustment(int32 hypertable_id, Relation template_indexrel, Relation chunkrel, IndexInfo *indexinfo, bool isconstraint, Oid index_tablespace); static List * create_index_colnames(Relation indexrel) { List *colnames = NIL; int i; for (i = 0; i < indexrel->rd_att->natts; i++) { Form_pg_attribute idxattr = TupleDescAttr(indexrel->rd_att, i); colnames = lappend(colnames, pstrdup(NameStr(idxattr->attname))); } return colnames; } /* * Pick a name for a chunk index. * * The chunk's index name will the original index name prefixed with the chunk's * table name, modulo any conflict resolution we need to do. */ static char * chunk_index_choose_name(const char *tabname, const char *main_index_name, Oid namespaceid) { char buf[10]; char *label = NULL; char *idxname; int n = 0; for (;;) { /* makeObjectName will ensure the index name fits within a NAME type */ idxname = makeObjectName(tabname, main_index_name, label); if (!OidIsValid(get_relname_relid(idxname, namespaceid))) break; /* found a conflict, so try a new name component */ pfree(idxname); snprintf(buf, sizeof(buf), "%d", ++n); label = buf; } return idxname; } static void adjust_expr_attnos(Oid ht_relid, IndexInfo *ii, Relation chunkrel) { List *vars = NIL; ListCell *lc; /* Get a list of references to all Vars in the expression */ if (ii->ii_Expressions != NIL) vars = list_concat(vars, pull_var_clause((Node *) ii->ii_Expressions, 0)); /* Get a list of references to all Vars in the predicate */ if (ii->ii_Predicate != NIL) vars = list_concat(vars, pull_var_clause((Node *) ii->ii_Predicate, 0)); foreach (lc, vars) { Var *var = lfirst_node(Var, lc); var->varattno = ts_map_attno(ht_relid, chunkrel->rd_id, var->varattno); var->varattnosyn = var->varattno; } } /* * Adjust column reference attribute numbers for regular indexes. */ static void chunk_adjust_colref_attnos(IndexInfo *ii, Oid ht_relid, Relation chunkrel) { int i; for (i = 0; i < ii->ii_NumIndexAttrs; i++) { /* zeroes indicate expressions */ if (ii->ii_IndexAttrNumbers[i] == 0) continue; /* we must not use get_attname on the index here as the index column names * are independent of parent relation column names. Instead we need to look * up the attno of the referenced hypertable column and do the matching * with the hypertable column name */ ii->ii_IndexAttrNumbers[i] = ts_map_attno(ht_relid, chunkrel->rd_id, ii->ii_IndexAttrNumbers[i]); } } void ts_adjust_indexinfo_attnos(IndexInfo *indexinfo, Oid ht_relid, Relation chunkrel) { /* * Adjust a hypertable's index attribute numbers to match a chunk. * * A hypertable's IndexInfo for one of its indexes references the attributes * (columns) in the hypertable by number. These numbers might not be the same * for the corresponding attribute in one of its chunks. To be able to use an * IndexInfo from a hypertable's index to create a corresponding index on a * chunk, we need to adjust the attribute numbers to match the chunk. * * We need to handle 3 places: * - direct column references in ii_IndexAttrNumbers * - references in expressions in ii_Expressions * - references in expressions in ii_Predicate */ chunk_adjust_colref_attnos(indexinfo, ht_relid, chunkrel); if (indexinfo->ii_Expressions || indexinfo->ii_Predicate) adjust_expr_attnos(ht_relid, indexinfo, chunkrel); } #define CHUNK_INDEX_TABLESPACE_OFFSET 1 /* * Pick a chunk index's tablespace at an offset from the chunk's tablespace in * order to avoid colocating chunks and their indexes in the same tablespace. * This hopefully leads to more I/O parallelism. */ static Oid chunk_index_select_tablespace(int32 hypertable_id, Relation chunkrel) { Tablespace *tspc; Oid tablespace_oid = InvalidOid; tspc = ts_hypertable_get_tablespace_at_offset_from(hypertable_id, chunkrel->rd_rel->reltablespace, CHUNK_INDEX_TABLESPACE_OFFSET); if (NULL != tspc) tablespace_oid = tspc->tablespace_oid; return tablespace_oid; } Oid ts_chunk_index_get_tablespace(int32 hypertable_id, Relation template_indexrel, Relation chunkrel) { /* * Determine the index's tablespace. Use the main index's tablespace, or, * if not set, select one at an offset from the chunk's tablespace. */ if (OidIsValid(template_indexrel->rd_rel->reltablespace)) return template_indexrel->rd_rel->reltablespace; else return chunk_index_select_tablespace(hypertable_id, chunkrel); } /* * Create a chunk index based on the configuration of the "parent" index. */ static Oid chunk_relation_index_create(Relation htrel, Relation template_indexrel, Relation chunkrel, bool isconstraint, Oid index_tablespace) { IndexInfo *indexinfo = BuildIndexInfo(template_indexrel); int32 hypertable_id; bool skip_mapping = false; /* * If the supplied template index is not on the hypertable we must not do attnum * mapping based on the hypertable. Ideally we would check for the template being * on the chunk but we cannot do that since when we rebuild a chunk the new chunk * has a different id. But the template index should always be either on the * hypertable or on a relation with the same physical layout as chunkrel. */ if (IndexGetRelation(template_indexrel->rd_id, false) != htrel->rd_id) skip_mapping = true; /* * Convert the IndexInfo's attnos to match the chunk instead of the * hypertable */ if (!skip_mapping && chunk_index_need_attnos_adjustment(RelationGetDescr(htrel), RelationGetDescr(chunkrel))) ts_adjust_indexinfo_attnos(indexinfo, htrel->rd_id, chunkrel); hypertable_id = ts_hypertable_relid_to_id(htrel->rd_id); Assert(hypertable_id != INVALID_HYPERTABLE_ID); return ts_chunk_index_create_post_adjustment(hypertable_id, template_indexrel, chunkrel, indexinfo, isconstraint, index_tablespace); } static Oid ts_chunk_index_create_post_adjustment(int32 hypertable_id, Relation template_indexrel, Relation chunkrel, IndexInfo *indexinfo, bool isconstraint, Oid index_tablespace) { Oid chunk_indexrelid = InvalidOid; const char *indexname; HeapTuple tuple; bool isnull; Datum reloptions; Datum indclass; oidvector *indclassoid; List *colnames = create_index_colnames(template_indexrel); Oid tablespace; bits16 flags = 0; tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(RelationGetRelid(template_indexrel))); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for index relation %u", RelationGetRelid(template_indexrel)); reloptions = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions, &isnull); indclass = SysCacheGetAttr(INDEXRELID, template_indexrel->rd_indextuple, Anum_pg_index_indclass, &isnull); Assert(!isnull); indclassoid = (oidvector *) DatumGetPointer(indclass); indexname = chunk_index_choose_name(get_rel_name(RelationGetRelid(chunkrel)), get_rel_name(RelationGetRelid(template_indexrel)), get_rel_namespace(RelationGetRelid(chunkrel))); if (OidIsValid(index_tablespace)) tablespace = index_tablespace; else tablespace = ts_chunk_index_get_tablespace(hypertable_id, template_indexrel, chunkrel); /* assign flags for index creation and constraint creation */ if (isconstraint) flags |= INDEX_CREATE_ADD_CONSTRAINT; if (template_indexrel->rd_index->indisprimary) flags |= INDEX_CREATE_IS_PRIMARY; chunk_indexrelid = index_create_compat(chunkrel, indexname, InvalidOid, InvalidOid, InvalidOid, InvalidOid, indexinfo, colnames, template_indexrel->rd_rel->relam, tablespace, template_indexrel->rd_indcollation, indclassoid->values, NULL, /* opclassOptions */ template_indexrel->rd_indoption, NULL, /* stattargets */ reloptions, flags, 0, /* constr_flags constant and 0 * for now */ false, /* allow system table mods */ false, /* is internal */ NULL); /* constraintId */ ReleaseSysCache(tuple); return chunk_indexrelid; } static Oid chunk_index_find_matching(Relation chunk_rel, Oid ht_indexoid) { List *indexlist = RelationGetIndexList(chunk_rel); ListCell *lc; foreach (lc, indexlist) { Oid indexoid = lfirst_oid(lc); if (ts_indexing_compare(indexoid, ht_indexoid)) return indexoid; } list_free(indexlist); return InvalidOid; } /* * Create a new chunk index as a child of a parent hypertable index. * * The chunk index is created based on the information from the parent index * relation. This function is typically called when a new chunk is created and * it should, for each hypertable index, have a corresponding index of its own. */ static void chunk_index_create(Relation hypertable_rel, int32 hypertable_id, Relation hypertable_idxrel, int32 chunk_id, Relation chunkrel, Oid constraint_oid, Oid index_tblspc) { Oid chunk_indexrelid; if (OidIsValid(constraint_oid)) { /* * If there is an associated constraint then that constraint created * both the index and the catalog entry for the index */ return; } chunk_indexrelid = chunk_index_find_matching(chunkrel, RelationGetRelid(hypertable_idxrel)); if (!OidIsValid(chunk_indexrelid)) { chunk_indexrelid = chunk_relation_index_create(hypertable_rel, hypertable_idxrel, chunkrel, false, index_tblspc); } } void ts_chunk_index_create_from_adjusted_index_info(int32 hypertable_id, Relation hypertable_idxrel, int32 chunk_id, Relation chunkrel, IndexInfo *indexinfo) { ts_chunk_index_create_post_adjustment(hypertable_id, hypertable_idxrel, chunkrel, indexinfo, false, false); } /* * Create all indexes on a chunk, given the indexes that exists on the chunk's * hypertable. */ void ts_chunk_index_create_all(int32 hypertable_id, Oid hypertable_relid, int32 chunk_id, Oid chunkrelid, Oid index_tblspc) { Relation htrel; Relation chunkrel; List *indexlist; ListCell *lc; const char chunk_relkind = get_rel_relkind(chunkrelid); /* Foreign table chunks don't support indexes */ if (chunk_relkind == RELKIND_FOREIGN_TABLE) return; Assert(chunk_relkind == RELKIND_RELATION); htrel = table_open(hypertable_relid, AccessShareLock); /* Need ShareLock on the heap relation we are creating indexes on */ chunkrel = table_open(chunkrelid, ShareLock); /* * We should only add those indexes that aren't created from constraints, * since those are added separately. * * Ideally, we should just be able to check the index relation's rd_index * struct for the flags indisunique, indisprimary, indisexclusion to * figure out if this is a constraint-supporting index. However, * indisunique is true both for plain unique indexes and those created * from constraints. Instead, we prune the main table's index list, * removing those indexes that are supporting a constraint. */ indexlist = RelationGetIndexList(htrel); foreach (lc, indexlist) { Oid hypertable_idxoid = lfirst_oid(lc); Relation hypertable_idxrel = index_open(hypertable_idxoid, AccessShareLock); chunk_index_create(htrel, hypertable_id, hypertable_idxrel, chunk_id, chunkrel, get_index_constraint(hypertable_idxoid), index_tblspc); index_close(hypertable_idxrel, AccessShareLock); } table_close(chunkrel, NoLock); table_close(htrel, AccessShareLock); } List * ts_chunk_index_get_mappings(Hypertable *ht, Oid hypertable_indexrelid) { List *mappings = NIL; List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.id); ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); if (!OidIsValid(chunk->table_id)) continue; Relation chunk_rel = table_open(chunk->table_id, AccessShareLock); Oid chunk_indexrelid = ts_chunk_index_get_by_hypertable_indexrelid(chunk_rel, hypertable_indexrelid); table_close(chunk_rel, AccessShareLock); if (OidIsValid(chunk_indexrelid)) { ChunkIndexMapping *cim = palloc0(sizeof(ChunkIndexMapping)); cim->chunkoid = chunk->table_id; cim->indexoid = chunk_indexrelid; cim->parent_indexoid = hypertable_indexrelid; cim->hypertableoid = ht->fd.id; mappings = lappend(mappings, cim); } } return mappings; } TSDLLEXPORT Oid ts_chunk_index_get_by_hypertable_indexrelid(Relation chunk_rel, Oid ht_indexoid) { List *indexlist = RelationGetIndexList(chunk_rel); ListCell *lc; Oid chunk_index_oid = InvalidOid; foreach (lc, indexlist) { Oid indexoid = lfirst_oid(lc); if (ts_indexing_compare(indexoid, ht_indexoid)) { chunk_index_oid = indexoid; break; } } list_free(indexlist); return chunk_index_oid; } void ts_chunk_index_rename(Hypertable *ht, Oid hypertable_indexrelid, const char *ht_name) { ListCell *lc; List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.id); foreach (lc, chunks) { Chunk *chunk = lfirst(lc); if (!OidIsValid(chunk->table_id)) continue; Relation chunk_rel = table_open(chunk->table_id, AccessExclusiveLock); Oid chunk_indexrelid = ts_chunk_index_get_by_hypertable_indexrelid(chunk_rel, hypertable_indexrelid); table_close(chunk_rel, NoLock); /* If there is no matching index on the chunk, skip it */ if (OidIsValid(chunk_indexrelid)) { Oid chunk_schemaoid = get_namespace_oid(NameStr(chunk->fd.schema_name), false); const char *chunk_old_name = get_rel_name(chunk_indexrelid); const char *chunk_new_name = chunk_index_choose_name(NameStr(chunk->fd.table_name), ht_name, chunk_schemaoid); /* * Index might also have a constraint which we track separately in our catalog * and needs to be updated too */ ts_chunk_constraint_adjust_meta(chunk->fd.id, ht_name, chunk_old_name, chunk_new_name); RenameRelationInternal(chunk_indexrelid, chunk_new_name, false, true); } } } void ts_chunk_index_set_tablespace(Hypertable *ht, Oid hypertable_indexrelid, char *tablespace) { List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.id); ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); Relation chunk_rel = table_open(chunk->table_id, AccessExclusiveLock); Oid chunk_indexrelid = ts_chunk_index_get_by_hypertable_indexrelid(chunk_rel, hypertable_indexrelid); table_close(chunk_rel, NoLock); if (OidIsValid(chunk_indexrelid)) { AlterTableCmd *cmd = makeNode(AlterTableCmd); List *cmds = NIL; cmd->subtype = AT_SetTableSpace; cmd->name = tablespace; cmds = lappend(cmds, cmd); ts_alter_table_with_event_trigger(chunk_indexrelid, NULL, cmds, false); } } } TSDLLEXPORT void ts_chunk_index_mark_clustered(Oid chunkrelid, Oid indexrelid) { Relation rel = table_open(chunkrelid, AccessShareLock); mark_index_clustered(rel, indexrelid, true); CommandCounterIncrement(); table_close(rel, AccessShareLock); } static Oid chunk_index_duplicate_index(Relation hypertable_rel, Chunk *src_chunk, Oid chunk_index_oid, Relation dest_chunk_rel, Oid index_tablespace) { Relation chunk_index_rel = index_open(chunk_index_oid, AccessShareLock); Oid constraint_oid; Oid new_chunk_indexrelid; constraint_oid = get_index_constraint(chunk_index_oid); new_chunk_indexrelid = chunk_relation_index_create(hypertable_rel, chunk_index_rel, dest_chunk_rel, OidIsValid(constraint_oid), index_tablespace); index_close(chunk_index_rel, NoLock); return new_chunk_indexrelid; } /* * Create versions of every index over src_chunkrelid over chunkrelid. * Returns the relids of the new indexes created. * New indexes are in the same order as RelationGetIndexList. */ TSDLLEXPORT List * ts_chunk_index_duplicate(Oid src_chunkrelid, Oid dest_chunkrelid, List **src_index_oids, Oid index_tablespace) { Relation hypertable_rel = NULL; Relation src_chunk_rel; Relation dest_chunk_rel; List *index_oids; ListCell *index_elem; List *new_index_oids = NIL; Chunk *src_chunk; src_chunk_rel = table_open(src_chunkrelid, AccessShareLock); dest_chunk_rel = table_open(dest_chunkrelid, ShareLock); src_chunk = ts_chunk_get_by_relid(src_chunkrelid, true); hypertable_rel = table_open(src_chunk->hypertable_relid, AccessShareLock); index_oids = RelationGetIndexList(src_chunk_rel); foreach (index_elem, index_oids) { Oid chunk_index_oid = lfirst_oid(index_elem); Oid new_chunk_indexrelid = chunk_index_duplicate_index(hypertable_rel, src_chunk, chunk_index_oid, dest_chunk_rel, index_tablespace); new_index_oids = lappend_oid(new_index_oids, new_chunk_indexrelid); } table_close(hypertable_rel, AccessShareLock); table_close(dest_chunk_rel, NoLock); table_close(src_chunk_rel, NoLock); if (src_index_oids != NULL) *src_index_oids = index_oids; return new_index_oids; } void ts_chunk_index_move_all(Oid chunk_relid, Oid index_tblspc) { Relation chunkrel; List *indexlist; ListCell *lc; const char chunk_relkind = get_rel_relkind(chunk_relid); /* execute ALTER INDEX .. SET TABLESPACE for each index on the chunk */ AlterTableCmd cmd = { .type = T_AlterTableCmd, .subtype = AT_SetTableSpace, .name = get_tablespace_name(index_tblspc) }; /* Foreign table chunks don't support indexes */ if (chunk_relkind == RELKIND_FOREIGN_TABLE) return; Assert(chunk_relkind == RELKIND_RELATION); chunkrel = table_open(chunk_relid, AccessShareLock); indexlist = RelationGetIndexList(chunkrel); foreach (lc, indexlist) { Oid chunk_idxoid = lfirst_oid(lc); ts_alter_table_with_event_trigger(chunk_idxoid, NULL, list_make1(&cmd), false); } table_close(chunkrel, AccessShareLock); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_index.h����������������������������������������������������������������0000664�0000000�0000000�00000005034�15100345067�0017314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <nodes/execnodes.h> #include <nodes/parsenodes.h> #include <utils/relcache.h> #include "compat/compat.h" #include "export.h" typedef struct Chunk Chunk; typedef struct Hypertable Hypertable; typedef struct ChunkIndexMapping { Oid chunkoid; Oid parent_indexoid; Oid indexoid; Oid hypertableoid; } ChunkIndexMapping; extern void ts_chunk_index_create(Relation hypertable_rel, int32 hypertable_id, Relation hypertable_idxrel, int32 chunk_id, Relation chunkrel); void ts_adjust_indexinfo_attnos(IndexInfo *indexinfo, Oid ht_relid, Relation chunkrel); extern void ts_chunk_index_create_from_adjusted_index_info(int32 hypertable_id, Relation hypertable_idxrel, int32 chunk_id, Relation chunkrel, IndexInfo *indexinfo); extern TSDLLEXPORT void ts_chunk_index_create_all(int32 hypertable_id, Oid hypertable_relid, int32 chunk_id, Oid chunkrelid, Oid index_tblspc); extern TSDLLEXPORT void ts_chunk_index_move_all(Oid chunk_relid, Oid index_tblspc); extern void ts_chunk_index_rename(Hypertable *ht, Oid hypertable_indexrelid, const char *ht_name); extern void ts_chunk_index_set_tablespace(Hypertable *ht, Oid hypertable_indexrelid, char *tablespace); extern List *ts_chunk_index_get_mappings(Hypertable *ht, Oid hypertable_indexrelid); extern TSDLLEXPORT Oid ts_chunk_index_get_by_hypertable_indexrelid(Relation chunk_rel, Oid ht_indexoid); extern TSDLLEXPORT void ts_chunk_index_mark_clustered(Oid chunkrelid, Oid indexrelid); extern TSDLLEXPORT List *ts_chunk_index_duplicate(Oid src_chunkrelid, Oid dest_chunkrelid, List **src_index_oids, Oid index_tablespace); extern Oid ts_chunk_index_get_tablespace(int32 hypertable_id, Relation template_indexrel, Relation chunkrel); static inline bool chunk_index_columns_changed(int hypertable_natts, TupleDesc chunkdesc) { /* * We should be able to safely assume that the only reason the number of * attributes differ is because we have removed columns in the base table, * leaving junk attributes that aren't inherited by the chunk. */ return hypertable_natts != chunkdesc->natts; } static inline bool chunk_index_need_attnos_adjustment(TupleDesc htdesc, TupleDesc chunkdesc) { return chunk_index_columns_changed(htdesc->natts, chunkdesc); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_insert_state.c���������������������������������������������������������0000664�0000000�0000000�00000043123�15100345067�0020705�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/attnum.h> #include <access/xact.h> #include <catalog/pg_type.h> #include <executor/tuptable.h> #include <foreign/fdwapi.h> #include <miscadmin.h> #include <nodes/execnodes.h> #include <nodes/makefuncs.h> #include <nodes/nodes.h> #include <nodes/plannodes.h> #include <optimizer/optimizer.h> #include <parser/parsetree.h> #include <rewrite/rewriteManip.h> #include <utils/builtins.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/rel.h> #include <utils/rls.h> #include "compat/compat.h" #include "chunk_index.h" #include "chunk_insert_state.h" #include "chunk_tuple_routing.h" #include "debug_point.h" #include "errors.h" #include "indexing.h" #include "nodes/modify_hypertable.h" #include "ts_catalog/continuous_agg.h" /* Just like ExecPrepareExpr except that it doesn't switch to the query memory context */ static inline ExprState * prepare_constr_expr(Expr *node) { ExprState *result; node = expression_planner(node); result = ExecInitExpr(node, NULL); return result; } /* * Create the constraint exprs inside the current memory context. If this * is not done here, then ExecRelCheck will do it for you but put it into * the query memory context, which will cause a memory leak. * * See the comment in `ts_chunk_insert_state_destroy` for more information * on the implications of this. */ static inline void create_chunk_rri_constraint_expr(ResultRelInfo *rri, Relation rel) { int ncheck, i; ConstrCheck *check; Assert(rel->rd_att->constr != NULL && rri->ri_CheckConstraintExprs == NULL); ncheck = rel->rd_att->constr->num_check; check = rel->rd_att->constr->check; rri->ri_CheckConstraintExprs = (ExprState **) palloc(ncheck * sizeof(ExprState *)); for (i = 0; i < ncheck; i++) { Expr *checkconstr = stringToNode(check[i].ccbin); rri->ri_CheckConstraintExprs[i] = prepare_constr_expr(checkconstr); } } /* * Create a new ResultRelInfo for a chunk. * * The ResultRelInfo holds the executor state (e.g., open relation, indexes, and * options) for the result relation where tuples will be stored. * * The Hypertable ResultRelInfo is used as a template for the chunk's new ResultRelInfo. */ ResultRelInfo * create_chunk_result_relation_info(ResultRelInfo *ht_rri, Relation rel, EState *estate) { ResultRelInfo *rri; rri = makeNode(ResultRelInfo); InitResultRelInfo(rri, rel, ht_rri->ri_RangeTableIndex, NULL, estate->es_instrument); /* Copy options from the main table's (hypertable's) result relation info */ rri->ri_WithCheckOptions = ht_rri->ri_WithCheckOptions; rri->ri_WithCheckOptionExprs = ht_rri->ri_WithCheckOptionExprs; rri->ri_projectReturning = ht_rri->ri_projectReturning; rri->ri_FdwState = NULL; rri->ri_usesFdwDirectModify = ht_rri->ri_usesFdwDirectModify; if (RelationGetForm(rel)->relkind == RELKIND_FOREIGN_TABLE) rri->ri_FdwRoutine = GetFdwRoutineForRelation(rel, true); create_chunk_rri_constraint_expr(rri, rel); return rri; } static ProjectionInfo * get_adjusted_projection_info_returning(ProjectionInfo *orig, List *returning_clauses, TupleConversionMap *map, Index varno, Oid rowtype, TupleDesc chunk_desc) { bool found_whole_row; Assert(returning_clauses != NIL); /* map hypertable attnos -> chunk attnos */ if (map != NULL) returning_clauses = castNode(List, map_variable_attnos((Node *) returning_clauses, varno, 0, map->attrMap, rowtype, &found_whole_row)); return ExecBuildProjectionInfo(returning_clauses, orig->pi_exprContext, orig->pi_state.resultslot, orig->pi_state.parent, chunk_desc); } static List * translate_clause(List *inclause, TupleConversionMap *chunk_map, Index varno, Relation hyper_rel, Relation chunk_rel) { List *clause = copyObject(inclause); bool found_whole_row; /* nothing to do here if the chunk_map is NULL */ if (!chunk_map) return list_copy(clause); /* map hypertable attnos -> chunk attnos for the "excluded" table */ clause = castNode(List, map_variable_attnos((Node *) clause, INNER_VAR, 0, chunk_map->attrMap, RelationGetForm(chunk_rel)->reltype, &found_whole_row)); /* map hypertable attnos -> chunk attnos for the hypertable */ clause = castNode(List, map_variable_attnos((Node *) clause, varno, 0, chunk_map->attrMap, RelationGetForm(chunk_rel)->reltype, &found_whole_row)); return clause; } /* * adjust_chunk_colnos * Adjust the list of UPDATE target column numbers to account for * attribute differences between the parent and the partition. * * adapted from postgres adjust_partition_colnos */ static List * adjust_chunk_colnos(List *colnos, ResultRelInfo *chunk_rri) { List *new_colnos = NIL; TupleConversionMap *map = ExecGetChildToRootMap(chunk_rri); AttrMap *attrMap; ListCell *lc; Assert(map != NULL); /* else we shouldn't be here */ attrMap = map->attrMap; foreach (lc, colnos) { AttrNumber parentattrno = lfirst_int(lc); if (parentattrno <= 0 || parentattrno > attrMap->maplen || attrMap->attnums[parentattrno - 1] == 0) elog(ERROR, "unexpected attno %d in target column list", parentattrno); new_colnos = lappend_int(new_colnos, attrMap->attnums[parentattrno - 1]); } return new_colnos; } /* * Setup ON CONFLICT state for a chunk. * * Mostly, this is about mapping attribute numbers from the hypertable root to * a chunk, accounting for differences in the tuple descriptors due to dropped * columns, etc. */ static void setup_on_conflict_state(ResultRelInfo *ht_rri, ModifyTableState *mtstate, ChunkInsertState *state, TupleConversionMap *chunk_map) { TupleConversionMap *map = state->hyper_to_chunk_map; ResultRelInfo *chunk_rri = state->result_relation_info; Relation chunk_rel = state->result_relation_info->ri_RelationDesc; Relation hyper_rel = ht_rri->ri_RelationDesc; ModifyTable *mt = castNode(ModifyTable, mtstate->ps.plan); OnConflictSetState *onconfl = makeNode(OnConflictSetState); memcpy(onconfl, ht_rri->ri_onConflict, sizeof(OnConflictSetState)); chunk_rri->ri_onConflict = onconfl; #if PG16_LT chunk_rri->ri_RootToPartitionMap = map; #else chunk_rri->ri_RootToChildMap = map; chunk_rri->ri_RootToChildMapValid = true; #endif Assert(mt->onConflictSet); Assert(ht_rri->ri_onConflict != NULL); /* * Need a separate existing slot for each partition, as the * partition could be of a different AM, even if the tuple * descriptors match. */ onconfl->oc_Existing = table_slot_create(chunk_rri->ri_RelationDesc, NULL); state->existing_slot = onconfl->oc_Existing; /* * If the chunk's tuple descriptor matches exactly the hypertable * (the common case), we can reuse most of the parent's ON * CONFLICT SET state, skipping a bunch of work. Otherwise, we * need to create state specific to this partition. */ if (!map) { /* * It's safe to reuse these from the hypertable, as we * only process one tuple at a time (therefore we won't * overwrite needed data in slots), and the results of * projections are independent of the underlying storage. * Projections and where clauses themselves don't store state * / are independent of the underlying storage. */ onconfl->oc_ProjSlot = ht_rri->ri_onConflict->oc_ProjSlot; onconfl->oc_ProjInfo = ht_rri->ri_onConflict->oc_ProjInfo; onconfl->oc_WhereClause = ht_rri->ri_onConflict->oc_WhereClause; state->conflproj_slot = onconfl->oc_ProjSlot; } else { List *onconflset; List *onconflcols; /* * Translate expressions in onConflictSet to account for * different attribute numbers. For that, map partition * varattnos twice: first to catch the EXCLUDED * pseudo-relation (INNER_VAR), and second to handle the main * target relation (firstVarno). */ onconflset = copyObject(mt->onConflictSet); Assert(map->outdesc == RelationGetDescr(chunk_rel)); if (!chunk_map) chunk_map = convert_tuples_by_name(RelationGetDescr(chunk_rel), RelationGetDescr(hyper_rel)); onconflset = translate_clause(onconflset, chunk_map, ht_rri->ri_RangeTableIndex, hyper_rel, chunk_rel); chunk_rri->ri_ChildToRootMap = chunk_map; chunk_rri->ri_ChildToRootMapValid = true; /* Finally, adjust the target colnos to match the chunk. */ if (chunk_map) onconflcols = adjust_chunk_colnos(mt->onConflictCols, chunk_rri); else onconflcols = mt->onConflictCols; /* create the tuple slot for the UPDATE SET projection */ onconfl->oc_ProjSlot = table_slot_create(chunk_rel, NULL); state->conflproj_slot = onconfl->oc_ProjSlot; /* build UPDATE SET projection state */ onconfl->oc_ProjInfo = ExecBuildUpdateProjection(onconflset, true, onconflcols, RelationGetDescr(chunk_rel), mtstate->ps.ps_ExprContext, onconfl->oc_ProjSlot, &mtstate->ps); Node *onconflict_where = mt->onConflictWhere; /* * Map attribute numbers in the WHERE clause, if it exists. */ if (onconflict_where && chunk_map) { List *clause = translate_clause(castNode(List, onconflict_where), chunk_map, ht_rri->ri_RangeTableIndex, hyper_rel, chunk_rel); chunk_rri->ri_onConflict->oc_WhereClause = ExecInitQual(clause, NULL); } } } /* Translate hypertable indexes to chunk indexes in the arbiter clause */ static void set_arbiter_indexes(ChunkInsertState *state, List *ht_arbiter_indexes) { List *chunk_arbiter_indexes = NIL; ListCell *lc; foreach (lc, ht_arbiter_indexes) { Oid hypertable_index = lfirst_oid(lc); Oid chunk_index_oid = ts_chunk_index_get_by_hypertable_indexrelid(state->rel, hypertable_index); if (!OidIsValid(chunk_index_oid)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("could not find arbiter index for hypertable index \"%s\" on chunk " "\"%s\"", get_rel_name(hypertable_index), get_rel_name(RelationGetRelid(state->rel))))); } chunk_arbiter_indexes = lappend_oid(chunk_arbiter_indexes, chunk_index_oid); } state->result_relation_info->ri_onConflictArbiterIndexes = chunk_arbiter_indexes; } /* Change the projections to work with chunks instead of hypertables */ static void adjust_projections(ResultRelInfo *ht_rri, ModifyTableState *mtstate, ChunkInsertState *cis, Oid rowtype) { ResultRelInfo *chunk_rri = cis->result_relation_info; Relation hyper_rel = ht_rri->ri_RelationDesc; Relation chunk_rel = cis->rel; TupleConversionMap *chunk_map = NULL; OnConflictAction onConflictAction = ONCONFLICT_NONE; List *returningLists = NIL; if (mtstate) { ModifyTable *mt = castNode(ModifyTable, mtstate->ps.plan); onConflictAction = mt->onConflictAction; returningLists = mt->returningLists; } if (returningLists) { /* * We need the opposite map from cis->hyper_to_chunk_map. The map needs * to have the hypertable_desc in the out spot for map_variable_attnos * to work correctly in mapping hypertable attnos->chunk attnos. */ chunk_map = convert_tuples_by_name(RelationGetDescr(chunk_rel), RelationGetDescr(hyper_rel)); chunk_rri->ri_projectReturning = get_adjusted_projection_info_returning(chunk_rri->ri_projectReturning, linitial(returningLists), chunk_map, ht_rri->ri_RangeTableIndex, rowtype, RelationGetDescr(chunk_rel)); } /* Set the chunk's arbiter indexes for ON CONFLICT statements */ if (onConflictAction != ONCONFLICT_NONE) { set_arbiter_indexes(cis, ht_rri->ri_onConflictArbiterIndexes); if (onConflictAction == ONCONFLICT_UPDATE) setup_on_conflict_state(ht_rri, mtstate, cis, chunk_map); } } /* * Create new insert chunk state. * * This is essentially a ResultRelInfo for a chunk. Initialization of the * ResultRelInfo should be similar to ExecInitModifyTable(). */ extern ChunkInsertState * ts_chunk_insert_state_create(Oid chunk_relid, const ChunkTupleRouting *ctr) { ChunkInsertState *state; Relation rel, parent_rel; MemoryContext cis_context = AllocSetContextCreate(ctr->estate->es_query_cxt, "chunk insert state memory context", ALLOCSET_DEFAULT_SIZES); ResultRelInfo *relinfo; const Chunk *chunk; MemoryContext old_mcxt = MemoryContextSwitchTo(ctr->estate->es_per_tuple_exprcontext->ecxt_per_tuple_memory); /* * Since we insert data and won't modify metadata, a RowExclusiveLock * should be sufficient. This should conflict with any metadata-modifying * operations as they should take higher-level locks (ShareLock and * above). */ rel = table_open(chunk_relid, RowExclusiveLock); /* * A concurrent chunk operation (e.g., compression) might have changed the * chunk metadata before we got a lock, so re-read it. * * This works even in higher levels of isolation since catalog data is * always read from latest snapshot. */ chunk = ts_chunk_get_by_relid(chunk_relid, true); Assert(chunk->relkind == RELKIND_RELATION); ts_chunk_validate_chunk_status_for_operation(chunk, CHUNK_INSERT, true); MemoryContextSwitchTo(cis_context); if (ctr->single_chunk_insert) relinfo = ctr->root_rri; else relinfo = create_chunk_result_relation_info(ctr->root_rri, rel, ctr->estate); if (ctr->mht_state) CheckValidResultRelCompat(relinfo, ctr->mht_state->mt->operation, ctr->mht_state->mt->onConflictAction, NIL); state = palloc0(sizeof(ChunkInsertState)); state->counters = ctr->counters; if (ctr->mht_state) state->onConflictAction = ctr->mht_state->mt->onConflictAction; state->mctx = cis_context; state->rel = rel; state->result_relation_info = relinfo; state->estate = ctr->estate; ts_set_compression_status(state, chunk); if (relinfo->ri_RelationDesc->rd_rel->relhasindex && relinfo->ri_IndexRelationDescs == NULL) ExecOpenIndices(relinfo, state->onConflictAction != ONCONFLICT_NONE); if (relinfo->ri_TrigDesc != NULL) { TriggerDesc *tg = relinfo->ri_TrigDesc; /* instead of triggers can only be created on VIEWs */ Assert(!tg->trig_insert_instead_row); /* * A statement that targets a parent table in an inheritance or * partitioning hierarchy does not cause the statement-level triggers * of affected child tables to be fired; only the parent table's * statement-level triggers are fired. However, row-level triggers * of any affected child tables will be fired. * During chunk creation we only copy ROW trigger to chunks so * statement triggers should not exist on chunks. */ if (tg->trig_insert_after_statement || tg->trig_insert_before_statement) elog(ERROR, "statement trigger on chunk table not supported"); } if (!ctr->single_chunk_insert) { parent_rel = table_open(ctr->hypertable->main_table_relid, AccessShareLock); /* Set tuple conversion map, if tuple needs conversion. */ state->hyper_to_chunk_map = convert_tuples_by_name(RelationGetDescr(parent_rel), RelationGetDescr(rel)); if (ctr->mht_state) adjust_projections(ctr->root_rri, linitial_node(ModifyTableState, ctr->mht_state->cscan_state.custom_ps), state, RelationGetForm(rel)->reltype); table_close(parent_rel, AccessShareLock); } /* Need a tuple table slot to store tuples going into this chunk. We don't * want this slot tied to the executor's tuple table, since that would tie * the slot's lifetime to the entire length of the execution and we want * to be able to dynamically create and destroy chunk insert * state. Otherwise, memory might blow up when there are many chunks being * inserted into. This also means that the slot needs to be destroyed with * the chunk insert state. */ state->slot = MakeSingleTupleTableSlot(RelationGetDescr(relinfo->ri_RelationDesc), table_slot_callbacks(relinfo->ri_RelationDesc)); state->hypertable_relid = chunk->hypertable_relid; state->chunk_id = chunk->fd.id; MemoryContextSwitchTo(old_mcxt); return state; } void ts_set_compression_status(ChunkInsertState *state, const Chunk *chunk) { state->chunk_compressed = ts_chunk_is_compressed(chunk); if (state->chunk_compressed) { state->chunk_partial = ts_chunk_is_partial(chunk); } } extern void ts_chunk_insert_state_destroy(ChunkInsertState *state, bool single_chunk_insert) { /* * Check if we need to mark the chunk as partial. * We need to change chunk status to partial in the following cases: * - rowstore insert into compressed chunk * - columnstore insert into uncompressed chunk that is not a new chunk (flagged as * needs_partial in chunk_tuple_routing.c) */ if (state->chunk_compressed && !state->chunk_partial && (!state->columnstore_insert || state->needs_partial)) { Oid chunk_relid = RelationGetRelid(state->result_relation_info->ri_RelationDesc); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); ts_chunk_set_partial(chunk); } table_close(state->rel, NoLock); if (state->slot) ExecDropSingleTupleTableSlot(state->slot); /* * Clean up per-chunk tuple table slots created for ON CONFLICT handling. */ if (NULL != state->existing_slot) ExecDropSingleTupleTableSlot(state->existing_slot); /* The ON CONFLICT projection slot is only chunk specific in case the * tuple descriptor didn't match the hypertable */ if (NULL != state->hyper_to_chunk_map && NULL != state->conflproj_slot) ExecDropSingleTupleTableSlot(state->conflproj_slot); if (!single_chunk_insert) { ExecCloseIndices(state->result_relation_info); MemoryContextDelete(state->mctx); } } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_insert_state.h���������������������������������������������������������0000664�0000000�0000000�00000007342�15100345067�0020715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/tupconvert.h> #include <funcapi.h> #include "cache.h" #include "chunk.h" typedef struct ChunkTupleRouting ChunkTupleRouting; typedef struct CompressionSettings CompressionSettings; typedef struct tuple_filtering_constraints tuple_filtering_constraints; /* * Bundle the ScanKey and the attribute numbers together * to be able to update the scankey by replacing the * `sk_argument` field with the value from the actual slot. */ typedef struct ScanKeyWithAttnos { int num_scankeys; ScanKeyData *scankeys; AttrNumber *attnos; } ScanKeyWithAttnos; /* * Holds information to cache scan keys and other * information needed for repeated calls of * `decompress_batches_for_insert` on the same chunk. */ typedef struct CachedDecompressionState { bool has_primary_or_unique_index; CompressionSettings *compression_settings; tuple_filtering_constraints *constraints; /* Columns that needs to be checked manually because * heap scan doesn't support SK_SEARCHNULL: */ Bitmapset *columns_with_null_check; ScanKeyWithAttnos heap_scankeys; ScanKeyWithAttnos index_scankeys; ScanKeyWithAttnos mem_scankeys; Oid index_relid; } CachedDecompressionState; typedef struct SharedCounters { /* Number of batches deleted */ int64 batches_deleted; /* Number of batches filtered */ int64 batches_filtered; /* Number of batches decompressed */ int64 batches_decompressed; /* Number of tuples decompressed */ int64 tuples_decompressed; } SharedCounters; typedef struct ChunkInsertState { Relation rel; ResultRelInfo *result_relation_info; /* When the tuple descriptors for the main hypertable (root) and a chunk * differs, it is necessary to convert tuples to chunk format before * insertion, ON CONFLICT, or RETURNING handling. The table AM (storage format) * can also differ between the hypertable root and each chunk (as well as * between each chunk, in theory). * * The ResultRelInfo keeps per-relation slots for these purposes. The slots * here simply points to the per-relation slots in the ResultRelInfo. */ /* Pointer to slot for projected tuple in ON CONFLICT handling */ TupleTableSlot *conflproj_slot; /* Pointer to slot for tuple replaced in ON CONFLICT DO UPDATE * handling. Note that this slot's tuple descriptor is always the same as * the chunk rel's. */ TupleTableSlot *existing_slot; /* Slot for inserted/new tuples going into the chunk */ TupleTableSlot *slot; /* Map for converting tuple from hypertable (root table) format to chunk format */ TupleConversionMap *hyper_to_chunk_map; MemoryContext mctx; EState *estate; Oid hypertable_relid; int32 chunk_id; Oid user_id; /* for tracking compressed chunks */ bool chunk_compressed; bool chunk_partial; bool columnstore_insert; bool needs_partial; /* To speedup repeated calls of `decompress_batches_for_insert` */ CachedDecompressionState *cached_decompression_state; OnConflictAction onConflictAction; /* Should this INSERT be skipped due to ON CONFLICT DO NOTHING */ bool skip_current_tuple; SharedCounters *counters; /* for tracking generated column computations */ bool skip_generated_column_computations; } ChunkInsertState; extern ChunkInsertState *ts_chunk_insert_state_create(Oid chunk_relid, const ChunkTupleRouting *ctr); extern void ts_chunk_insert_state_destroy(ChunkInsertState *state, bool single_chunk_insert); ResultRelInfo *create_chunk_result_relation_info(ResultRelInfo *ht_rri, Relation rel, EState *estate); void ts_set_compression_status(ChunkInsertState *state, const Chunk *chunk); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_scan.c�����������������������������������������������������������������0000664�0000000�0000000�00000015702�15100345067�0017127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/namespace.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/syscache.h> #include "chunk.h" #include "chunk_constraint.h" #include "chunk_scan.h" #include "debug_point.h" #include "dimension_vector.h" #include "guc.h" #include "hypercube.h" #include "hypertable.h" #include "scan_iterator.h" #include "utils.h" /* * Scan for chunks matching a query. * * Given a number of dimension slices that match a query (a vector of slices * is given for each dimension), find the chunks that reference one slice in * each of the given dimensions. The matching chunks are built across multiple * scans: * * 1. Dimensional chunk constraints * 2. Chunk metadata * 3. Additional chunk constraints * 4. Chunk data nodes * * For performance, try not to interleave scans of different metadata tables * in order to maintain data locality while scanning. Also, keep scanned * tables and indexes open until all the metadata is scanned for all chunks. */ Chunk ** ts_chunk_scan_by_chunk_ids(const Hyperspace *hs, const List *chunk_ids, unsigned int *num_chunks) { MemoryContext work_mcxt = AllocSetContextCreate(CurrentMemoryContext, "chunk-scan-work", ALLOCSET_DEFAULT_SIZES); Chunk **locked_chunks = NULL; int locked_chunk_count = 0; ListCell *lc; Assert(OidIsValid(hs->main_table_relid)); MemoryContext orig_mcxt = MemoryContextSwitchTo(work_mcxt); /* * For each matching chunk, fill in the metadata from the "chunk" table. * Make sure to filter out "dropped" chunks. */ ScanIterator chunk_it = ts_chunk_scan_iterator_create(orig_mcxt); locked_chunks = (Chunk **) MemoryContextAlloc(orig_mcxt, sizeof(Chunk *) * list_length(chunk_ids)); foreach (lc, chunk_ids) { int chunk_id = lfirst_int(lc); Assert(CurrentMemoryContext == work_mcxt); ts_chunk_scan_iterator_set_chunk_id(&chunk_it, chunk_id); ts_scan_iterator_start_or_restart_scan(&chunk_it); TupleInfo *ti = ts_scan_iterator_next(&chunk_it); if (ti == NULL) { continue; } bool isnull; Datum datum = slot_getattr(ti->slot, Anum_chunk_dropped, &isnull); const bool is_dropped = isnull ? false : DatumGetBool(datum); if (is_dropped) { continue; } /* We found a chunk that is not dropped. First, try to lock it. */ Name schema_name = DatumGetName(slot_getattr(ti->slot, Anum_chunk_schema_name, &isnull)); Assert(!isnull); Name table_name = DatumGetName(slot_getattr(ti->slot, Anum_chunk_table_name, &isnull)); Assert(!isnull); Oid chunk_reloid = ts_get_relation_relid(NameStr(*schema_name), NameStr(*table_name), /* return_invalid = */ false); Assert(OidIsValid(chunk_reloid)); /* Only one chunk should match */ Assert(ts_scan_iterator_next(&chunk_it) == NULL); DEBUG_WAITPOINT("hypertable_expansion_before_lock_chunk"); if (!ts_chunk_lock_if_exists(chunk_reloid, AccessShareLock)) { continue; } /* * Now after we have locked the chunk, we have to reread its metadata. * It might have been modified concurrently by decompression, for * example. */ ts_chunk_scan_iterator_set_chunk_id(&chunk_it, chunk_id); ts_scan_iterator_start_or_restart_scan(&chunk_it); ti = ts_scan_iterator_next(&chunk_it); Assert(ti != NULL); Chunk *chunk = MemoryContextAllocZero(orig_mcxt, sizeof(Chunk)); ts_chunk_formdata_fill(&chunk->fd, ti); chunk->constraints = NULL; chunk->cube = NULL; chunk->hypertable_relid = hs->main_table_relid; chunk->table_id = chunk_reloid; locked_chunks[locked_chunk_count] = chunk; locked_chunk_count++; /* Only one chunk should match */ Assert(ts_scan_iterator_next(&chunk_it) == NULL); } ts_scan_iterator_close(&chunk_it); Assert(locked_chunk_count == 0 || locked_chunks != NULL); Assert(locked_chunk_count <= list_length(chunk_ids)); Assert(CurrentMemoryContext == work_mcxt); for (int i = 0; i < locked_chunk_count; i++) { Chunk *chunk = locked_chunks[i]; chunk->relkind = get_rel_relkind(chunk->table_id); } /* * Fetch the chunk constraints. */ ScanIterator constr_it = ts_chunk_constraint_scan_iterator_create(orig_mcxt); for (int i = 0; i < locked_chunk_count; i++) { Chunk *chunk = locked_chunks[i]; chunk->constraints = ts_chunk_constraints_alloc(/* size_hint = */ 0, orig_mcxt); ts_chunk_constraint_scan_iterator_set_chunk_id(&constr_it, chunk->fd.id); ts_scan_iterator_start_or_restart_scan(&constr_it); while (ts_scan_iterator_next(&constr_it) != NULL) { TupleInfo *constr_ti = ts_scan_iterator_tuple_info(&constr_it); ts_chunk_constraints_add_from_tuple(chunk->constraints, constr_ti); } } ts_scan_iterator_close(&constr_it); /* * Build hypercubes for the chunks by finding and combining the dimension * slices that match the chunk constraints. */ ScanIterator slice_iterator = ts_dimension_slice_scan_iterator_create(NULL, orig_mcxt); for (int chunk_index = 0; chunk_index < locked_chunk_count; chunk_index++) { Chunk *chunk = locked_chunks[chunk_index]; ChunkConstraints *constraints = chunk->constraints; MemoryContextSwitchTo(orig_mcxt); Hypercube *cube = ts_hypercube_alloc(constraints->num_dimension_constraints); MemoryContextSwitchTo(work_mcxt); for (int constraint_index = 0; constraint_index < constraints->num_constraints; constraint_index++) { ChunkConstraint *constraint = &constraints->constraints[constraint_index]; if (!is_dimension_constraint(constraint)) { continue; } /* * Find the slice by id. Don't have to lock it because the chunk is * locked. */ const int slice_id = constraint->fd.dimension_slice_id; DimensionSlice *slice_ptr = ts_dimension_slice_scan_iterator_get_by_id(&slice_iterator, slice_id); if (slice_ptr == NULL) { elog(ERROR, "dimension slice %d is not found", slice_id); } MemoryContextSwitchTo(orig_mcxt); DimensionSlice *slice_copy = ts_dimension_slice_create(slice_ptr->fd.dimension_id, slice_ptr->fd.range_start, slice_ptr->fd.range_end); slice_copy->fd.id = slice_ptr->fd.id; MemoryContextSwitchTo(work_mcxt); Assert(cube->capacity > cube->num_slices); cube->slices[cube->num_slices++] = slice_copy; } if (cube->num_slices == 0) { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("chunk %s has no dimension slices", get_rel_name(chunk->table_id)))); } ts_hypercube_slice_sort(cube); chunk->cube = cube; } ts_scan_iterator_close(&slice_iterator); Assert(CurrentMemoryContext == work_mcxt); MemoryContextSwitchTo(orig_mcxt); MemoryContextDelete(work_mcxt); #ifdef USE_ASSERT_CHECKING /* Assert that we always return valid chunks */ for (int i = 0; i < locked_chunk_count; i++) { ASSERT_IS_VALID_CHUNK(locked_chunks[i]); } #endif *num_chunks = locked_chunk_count; Assert(*num_chunks == 0 || locked_chunks != NULL); return locked_chunks; } ��������������������������������������������������������������timescaledb-2.23.0/src/chunk_scan.h�����������������������������������������������������������������0000664�0000000�0000000�00000000571�15100345067�0017132�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "hypertable.h" extern Chunk **ts_chunk_scan_by_chunk_ids(const Hyperspace *hs, const List *chunk_ids, unsigned int *num_chunks); ���������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_tuple_routing.c��������������������������������������������������������0000664�0000000�0000000�00000021621�15100345067�0021100�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/tableam.h> #include <storage/lockdefs.h> #include <utils/rls.h> #include "chunk_insert_state.h" #include "chunk_tuple_routing.h" #include "cross_module_fn.h" #include "debug_point.h" #include "guc.h" #include "hypercube.h" #include "subspace_store.h" ChunkTupleRouting * ts_chunk_tuple_routing_create(EState *estate, Hypertable *ht, ResultRelInfo *rri) { ChunkTupleRouting *ctr; Assert(ht); /* * Here we attempt to expend as little effort as possible in setting up * the ChunkTupleRouting. Each partition's ResultRelInfo is built on * demand, only when we actually need to route a tuple to that partition. * The reason for this is that a common case is for INSERT to insert a * single tuple into a partitioned table and this must be fast. */ ctr = (ChunkTupleRouting *) palloc0(sizeof(ChunkTupleRouting)); ctr->root_rri = rri; ctr->root_rel = rri->ri_RelationDesc; ctr->estate = estate; ctr->counters = palloc0(sizeof(SharedCounters)); ctr->hypertable = ht; /* * If the relid of ResultRelInfo does not match the Hypertable this is an operation * directly on a chunk. */ ctr->single_chunk_insert = ht->main_table_relid != RelationGetRelid(rri->ri_RelationDesc); ctr->subspace = ts_subspace_store_init(ctr->hypertable->space, estate->es_query_cxt, ts_guc_max_open_chunks_per_insert); ctr->has_dropped_attrs = false; return ctr; } void ts_chunk_tuple_routing_destroy(ChunkTupleRouting *ctr) { ts_subspace_store_free(ctr->subspace); pfree(ctr); } static void destroy_chunk_insert_state_single_chunk(void *cis) { ts_chunk_insert_state_destroy((ChunkInsertState *) cis, true); } static void destroy_chunk_insert_state(void *cis) { ts_chunk_insert_state_destroy((ChunkInsertState *) cis, false); } extern ChunkInsertState * ts_chunk_tuple_routing_find_chunk(ChunkTupleRouting *ctr, Point *point) { Chunk *chunk = NULL; ChunkInsertState *cis = NULL; cis = ts_subspace_store_get(ctr->subspace, point); /* * The chunk search functions may leak memory, so switch to a temporary * memory context. */ MemoryContext old_context = MemoryContextSwitchTo(GetPerTupleMemoryContext(ctr->estate)); if (!cis) { bool chunk_created = false; bool needs_partial = false; const LOCKMODE lockmode = RowExclusiveLock; /* * Normally, for every row of the chunk except the first one, we expect * the chunk to exist already. The "create" function would take a lock * on the hypertable to serialize the concurrent chunk creation. Here we * first use the "find" function to try to find the chunk without * locking the hypertable. This serves as a fast path for the usual case * where the chunk already exists. */ DEBUG_WAITPOINT("chunk_insert_before_lock"); chunk = ts_hypertable_find_chunk_for_point(ctr->hypertable, point, lockmode); /* * When inserting directly into a chunk, we should always find the chunk and * the returned chunk should match the relid we are inserting into. */ if (ctr->single_chunk_insert) { if (!chunk || chunk->table_id != RelationGetRelid(ctr->root_rri->ri_RelationDesc)) ereport(ERROR, (errcode(ERRCODE_CHECK_VIOLATION), errmsg("new row for relation \"%s\" violates chunk constraint", RelationGetRelationName(ctr->root_rri->ri_RelationDesc)))); } if (chunk && ts_chunk_is_frozen(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot INSERT into frozen chunk \"%s\"", get_rel_name(chunk->table_id)))); if (chunk && IS_OSM_CHUNK(chunk)) { const Dimension *time_dim = hyperspace_get_open_dimension(ctr->hypertable->space, 0); Assert(time_dim != NULL); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Cannot insert into tiered chunk range of %s.%s - attempt to create " "new chunk " "with range [%s %s] failed", NameStr(ctr->hypertable->fd.schema_name), NameStr(ctr->hypertable->fd.table_name), ts_internal_to_time_string(chunk->cube->slices[0]->fd.range_start, time_dim->fd.column_type), ts_internal_to_time_string(chunk->cube->slices[0]->fd.range_end, time_dim->fd.column_type)), errhint( "Hypertable has tiered data with time range that overlaps the insert"))); } if (!chunk) { chunk = ts_hypertable_create_chunk_for_point(ctr->hypertable, point, lockmode); chunk_created = true; } Ensure(chunk, "no chunk found or created"); #ifdef USE_ASSERT_CHECKING /* Ensure we always hold a lock on the chunk table at this point */ Relation chunk_rel = RelationIdGetRelation(chunk->table_id); Assert(CheckRelationLockedByMe(chunk_rel, lockmode, true)); RelationClose(chunk_rel); #endif if (ctr->create_compressed_chunk && !chunk->fd.compressed_chunk_id) { /* * When creating a compressed chunk, the operation must be * synchronized with other operations. A RowExclusiveLock is * already held on the chunk table itself so it will conflict with * explicit compress calls like compress_chunk() or * convert_to_columnstore() that take at least * ExclusiveLock. However, it is also necessary to synchronize * with other concurrent inserts doing the same thing. * * We don't want to do a lock upgrade on the chunk table since * that increases the risk of deadlocks. * * Instead we synchronize around a tuple lock on the chunk * metadata row since this is the row getting updated with new * compression status. */ TM_Result lockres; DEBUG_WAITPOINT("insert_create_compressed"); lockres = ts_chunk_lock_for_creating_compressed_chunk(chunk->fd.id, &chunk->fd.compressed_chunk_id); /* * Since the locking function blocks and follows the update chain, * the only reasonable return value is TM_Ok. Everything else is * an error. */ Ensure(lockres == TM_Ok, "could not lock chunk row for creating " "compressed chunk. Lock result %d", lockres); /* recheck whether compressed chunk exists after acquiring the lock */ if (!chunk->fd.compressed_chunk_id) { Hypertable *compressed_ht = ts_hypertable_get_by_id(ctr->hypertable->fd.compressed_hypertable_id); Chunk *compressed_chunk = ts_cm_functions->compression_chunk_create(compressed_ht, chunk); ts_chunk_set_compressed_chunk(chunk, compressed_chunk->fd.id); chunk->fd.compressed_chunk_id = compressed_chunk->fd.id; /* mark chunk as partial unless completely new chunk */ if (!chunk_created) needs_partial = true; } } cis = ts_chunk_insert_state_create(chunk->table_id, ctr); cis->needs_partial = needs_partial; ts_subspace_store_add(ctr->subspace, chunk->cube, cis, ctr->single_chunk_insert ? destroy_chunk_insert_state_single_chunk : destroy_chunk_insert_state); } MemoryContextSwitchTo(old_context); Assert(cis != NULL); return cis; } extern void ts_chunk_tuple_routing_decompress_for_insert(ChunkInsertState *cis, TupleTableSlot *slot, EState *estate, bool update_counter) { if (!cis->chunk_compressed || (cis->cached_decompression_state && !cis->cached_decompression_state->has_primary_or_unique_index)) return; /* * If this is an INSERT into a compressed chunk with UNIQUE or * PRIMARY KEY constraints we need to make sure any batches that could * potentially lead to a conflict are in the decompressed chunk so * postgres can do proper constraint checking. */ ts_cm_functions->init_decompress_state_for_insert(cis, slot); /* If we are dealing with generated stored columns, generate the values * so can use it for uniqueness checks. */ Relation resultRelationDesc = cis->result_relation_info->ri_RelationDesc; if (resultRelationDesc->rd_att->constr && resultRelationDesc->rd_att->constr->has_generated_stored) { slot->tts_tableOid = RelationGetRelid(resultRelationDesc); ExecComputeStoredGenerated(cis->result_relation_info, estate, slot, CMD_INSERT); cis->skip_generated_column_computations = true; } ts_cm_functions->decompress_batches_for_insert(cis, slot); /* mark rows visible */ if (update_counter) estate->es_output_cid = GetCurrentCommandId(true); if (ts_guc_max_tuples_decompressed_per_dml > 0) { if (cis->counters->tuples_decompressed > ts_guc_max_tuples_decompressed_per_dml) { ereport(ERROR, (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), errmsg("tuple decompression limit exceeded by operation"), errdetail("current limit: %d, tuples decompressed: %lld", ts_guc_max_tuples_decompressed_per_dml, (long long int) cis->counters->tuples_decompressed), errhint("Consider increasing " "timescaledb.max_tuples_decompressed_per_dml_transaction or set " "to 0 (unlimited)."))); } } } ���������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/chunk_tuple_routing.h��������������������������������������������������������0000664�0000000�0000000�00000002612�15100345067�0021104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <executor/nodeModifyTable.h> #include "chunk_insert_state.h" #include "hypertable.h" typedef struct ModifyHypertableState ModifyHypertableState; typedef struct ChunkTupleRouting { Hypertable *hypertable; /* * When single_chunk_insert is true, root_rel and root_rri point to the * chunk being inserted into. Otherwise, they point to the hypertable. */ Relation root_rel; ResultRelInfo *root_rri; bool single_chunk_insert; SubspaceStore *subspace; EState *estate; bool create_compressed_chunk; bool has_dropped_attrs; ModifyHypertableState *mht_state; /* state for the ModifyHypertable custom scan node */ ChunkInsertState *cis; SharedCounters *counters; /* shared counters for the current statement */ } ChunkTupleRouting; ChunkTupleRouting *ts_chunk_tuple_routing_create(EState *estate, Hypertable *ht, ResultRelInfo *rri); void ts_chunk_tuple_routing_destroy(ChunkTupleRouting *ctr); ChunkInsertState *ts_chunk_tuple_routing_find_chunk(ChunkTupleRouting *ctr, Point *point); extern void ts_chunk_tuple_routing_decompress_for_insert(ChunkInsertState *cis, TupleTableSlot *slot, EState *estate, bool update_counter); ����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/compat/����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016125�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/compat/CMakeLists.txt��������������������������������������������������������0000664�0000000�0000000�00000000101�15100345067�0020655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/compat/compat-msvc-enter.h���������������������������������������������������0000664�0000000�0000000�00000002561�15100345067�0021646�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> /* * Not all exported data symbols in PostgreSQL are marked with PGDLLIMPORT, * which causes errors during linking. This hack turns all extern symbols into * properly exported symbols so we can use them in our code. Only necessary * for files that use these incorrectly unlabeled data symbols (e.g. extension.c) * * NOTE: Applies to data symbols only, not functions */ #ifdef _MSC_VER #undef PGDLLIMPORT #define PGDLLIMPORT #define extern extern _declspec(dllimport) #include <catalog/genbki.h> #undef DECLARE_TOAST #undef DECLARE_INDEX #undef DECLARE_UNIQUE_INDEX #undef DECLARE_UNIQUE_INDEX_PKEY #undef DECLARE_FOREIGN_KEY #undef DECLARE_FOREIGN_KEY_OPT #undef DECLARE_ARRAY_FOREIGN_KEY #undef DECLARE_ARRAY_FOREIGN_KEY_OPT #define DECLARE_TOAST(name, toastoid, indexoid) #define DECLARE_INDEX(name, oid, decl) #define DECLARE_UNIQUE_INDEX(name, oid, decl) #define DECLARE_UNIQUE_INDEX_PKEY(name, oid, decl) #define DECLARE_FOREIGN_KEY(cols, reftbl, refcols) #define DECLARE_FOREIGN_KEY_OPT(cols, reftbl, refcols) #define DECLARE_ARRAY_FOREIGN_KEY(cols, reftbl, refcols) #define DECLARE_ARRAY_FOREIGN_KEY_OPT(cols, reftbl, refcols) #endif /* _MSC_VER */ �����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/compat/compat-msvc-exit.h����������������������������������������������������0000664�0000000�0000000�00000000741�15100345067�0021500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* * Included after all files that need compatibility are included, this undoes * the 'extern' macro so as not to break other headers (e.g. Windows headers). */ #ifdef _MSC_VER #undef extern #undef PGDLLIMPORT #define PGDLLIMPORT __declspec(dllexport) #endif /* _MSC_VER */ �������������������������������timescaledb-2.23.0/src/compat/compat.h��������������������������������������������������������������0000664�0000000�0000000�00000127344�15100345067�0017574�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <commands/cluster.h> #include <commands/defrem.h> #include <commands/explain.h> #include <commands/trigger.h> #include <commands/vacuum.h> #include <executor/executor.h> #include <executor/tuptable.h> #include <nodes/execnodes.h> #include <nodes/nodes.h> #include <optimizer/restrictinfo.h> #include <pgstat.h> #include <storage/lmgr.h> #include <utils/jsonb.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include "export.h" #define PG_MAJOR_MIN 15 /* * Prevent building against upstream versions that had ABI breaking change (15.9, 16.5, 17.1) * that was reverted in the following release. */ #define is_supported_pg_version_15(version) ((version >= 150010) && (version < 160000)) #define is_supported_pg_version_16(version) ((version >= 160006) && (version < 170000)) #define is_supported_pg_version_17(version) ((version >= 170002) && (version < 180000)) #define is_supported_pg_version_18(version) ((version >= 180000) && (version < 190000)) /* * To compile with an unsupported version, use -DEXPERIMENTAL=ON with cmake. * (Useful when testing with unreleased versions) */ #define is_supported_pg_version(version) \ (is_supported_pg_version_15(version) || is_supported_pg_version_16(version) || \ is_supported_pg_version_17(version) || is_supported_pg_version_18(version)) #define PG15 is_supported_pg_version_15(PG_VERSION_NUM) #define PG16 is_supported_pg_version_16(PG_VERSION_NUM) #define PG17 is_supported_pg_version_17(PG_VERSION_NUM) #define PG18 is_supported_pg_version_18(PG_VERSION_NUM) #define PG15_LT (PG_VERSION_NUM < 150000) #define PG15_GE (PG_VERSION_NUM >= 150000) #define PG16_LT (PG_VERSION_NUM < 160000) #define PG16_GE (PG_VERSION_NUM >= 160000) #define PG17_LT (PG_VERSION_NUM < 170000) #define PG17_GE (PG_VERSION_NUM >= 170000) #define PG18_LT (PG_VERSION_NUM < 180000) #define PG18_GE (PG_VERSION_NUM >= 180000) #if !(is_supported_pg_version(PG_VERSION_NUM)) #error "Unsupported PostgreSQL version" #endif #if ((PG_VERSION_NUM >= 150009 && PG_VERSION_NUM < 160000) || \ (PG_VERSION_NUM >= 160005 && PG_VERSION_NUM < 170000) || (PG_VERSION_NUM >= 170001)) /* * The above versions introduced a fix for potentially losing updates to * pg_class and pg_database due to inplace updates done to those catalog * tables by PostgreSQL. The fix requires taking a lock on the tuple via * SearchSysCacheLocked1(). For older PG versions, we just map the new * function to the unlocked version and the unlocking of the tuple is a noop. * * https://github.com/postgres/postgres/commit/3b7a689e1a805c4dac2f35ff14fd5c9fdbddf150 * * Here's an excerpt from README.tuplock that explains the need for additional * tuple locks: * * If IsInplaceUpdateRelation() returns true for a table, the table is a * system catalog that receives systable_inplace_update_begin() calls. * Preparing a heap_update() of these tables follows additional locking rules, * to ensure we don't lose the effects of an inplace update. In particular, * consider a moment when a backend has fetched the old tuple to modify, not * yet having called heap_update(). Another backend's inplace update starting * then can't conclude until the heap_update() places its new tuple in a * buffer. We enforce that using locktags as follows. While DDL code is the * main audience, the executor follows these rules to make e.g. "MERGE INTO * pg_class" safer. Locking rules are per-catalog: * * pg_class heap_update() callers: before copying the tuple to modify, take a * lock on the tuple, a ShareUpdateExclusiveLock on the relation, or a * ShareRowExclusiveLock or stricter on the relation. */ #define SYSCACHE_TUPLE_LOCK_NEEDED 1 #define AssertSufficientPgClassUpdateLockHeld(relid) \ Assert(CheckRelationOidLockedByMe(relid, ShareUpdateExclusiveLock, false) || \ CheckRelationOidLockedByMe(relid, ShareRowExclusiveLock, true)); #define UnlockSysCacheTuple(rel, tid) UnlockTuple(rel, tid, InplaceUpdateTupleLock); #else #define SearchSysCacheLockedCopy1(rel, datum) SearchSysCacheCopy1(rel, datum) #define UnlockSysCacheTuple(rel, tid) #define AssertSufficientPgClassUpdateLockHeld(relid) #endif /* * The following are compatibility functions for different versions of * PostgreSQL. Each compatibility function (or group) has its own logic for * which versions get different behavior and is separated from others by a * comment with its name and any clarifying notes about supported behavior. Each * compatibility define is separated out by function so that it is easier to see * what changed about its behavior, and at what version, but closely related * functions that changed at the same time may be grouped together into a single * block. Compatibility functions are organized in alphabetical order. * * Wherever reasonable, we try to achieve forwards compatibility so that we can * take advantage of features added in newer PG versions. This avoids some * future tech debt, though may not always be possible. * * We append "compat" to the name of the function or define if we change the behavior * of something that existed in a previous version. If we are merely backpatching * behavior from a later version to an earlier version and not changing the * behavior of the new version we simply adopt the new version's name. */ #if PG16_LT #define ExecInsertIndexTuplesCompat(rri, \ slot, \ estate, \ update, \ noDupErr, \ specConflict, \ arbiterIndexes, \ onlySummarizing) \ ExecInsertIndexTuples(rri, slot, estate, update, noDupErr, specConflict, arbiterIndexes) #else #define ExecInsertIndexTuplesCompat(rri, \ slot, \ estate, \ update, \ noDupErr, \ specConflict, \ arbiterIndexes, \ onlySummarizing) \ ExecInsertIndexTuples(rri, \ slot, \ estate, \ update, \ noDupErr, \ specConflict, \ arbiterIndexes, \ onlySummarizing) #endif /* * PG16 removed outerjoin_delayed, nullable_relids arguments from make_restrictinfo * https://github.com/postgres/postgres/commit/b448f1c8d8 * * PG16 adds three new parameter - has_clone, is_clone and incompatible_relids, as a * part of fixing the filtering of "cloned" outer-join quals * https://github.com/postgres/postgres/commit/991a3df227 */ #if PG16_LT #define make_restrictinfo_compat(root, \ clause, \ is_pushed_down, \ has_clone, \ is_clone, \ outerjoin_delayed, \ pseudoconstant, \ security_level, \ required_relids, \ incompatible_relids, \ outer_relids, \ nullable_relids) \ make_restrictinfo(root, \ clause, \ is_pushed_down, \ outerjoin_delayed, \ pseudoconstant, \ security_level, \ required_relids, \ outer_relids, \ nullable_relids) #else #define make_restrictinfo_compat(root, \ clause, \ is_pushed_down, \ has_clone, \ is_clone, \ outerjoin_delayed, \ pseudoconstant, \ security_level, \ required_relids, \ incompatible_relids, \ outer_relids, \ nullable_relids) \ make_restrictinfo(root, \ clause, \ is_pushed_down, \ has_clone, \ is_clone, \ pseudoconstant, \ security_level, \ required_relids, \ incompatible_relids, \ outer_relids) #endif /* fmgr * In a9c35cf postgres changed how it calls SQL functions so that the number of * argument-slots allocated is chosen dynamically, instead of being fixed. This * change was ABI-breaking, so we cannot backport this optimization, however, * we do backport the interface, so that all our code will be compatible with * new versions. */ /* convenience macro to allocate FunctionCallInfoData on the heap */ #define HEAP_FCINFO(nargs) palloc(SizeForFunctionCallInfo(nargs)) /* getting arguments has a different API, so these macros unify the versions */ #define FC_ARG(fcinfo, n) ((fcinfo)->args[(n)].value) #define FC_NULL(fcinfo, n) ((fcinfo)->args[(n)].isnull) #define FC_FN_OID(fcinfo) ((fcinfo)->flinfo->fn_oid) /* convenience setters */ #define FC_SET_ARG(fcinfo, n, val) \ do \ { \ short _n = (n); \ FunctionCallInfo _fcinfo = (fcinfo); \ FC_ARG(_fcinfo, _n) = (val); \ FC_NULL(_fcinfo, _n) = false; \ } while (0) #define FC_SET_NULL(fcinfo, n) \ do \ { \ short _n = (n); \ FunctionCallInfo _fcinfo = (fcinfo); \ FC_ARG(_fcinfo, _n) = 0; \ FC_NULL(_fcinfo, _n) = true; \ } while (0) /* create this function for symmetry with pq_sendint32 */ #define pq_getmsgint32(buf) pq_getmsgint(buf, 4) #define ts_tuptableslot_set_table_oid(slot, table_oid) (slot)->tts_tableOid = table_oid static inline ClusterParams * get_cluster_options(const ClusterStmt *stmt) { ListCell *lc; ClusterParams *params = palloc0(sizeof(ClusterParams)); bool verbose = false; /* Parse option list */ foreach (lc, stmt->params) { DefElem *opt = (DefElem *) lfirst(lc); if (strcmp(opt->defname, "verbose") == 0) verbose = defGetBoolean(opt); else ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unrecognized CLUSTER option \"%s\"", opt->defname), parser_errposition(NULL, opt->location))); } params->options = (verbose ? CLUOPT_VERBOSE : 0); return params; } #include <catalog/index.h> static inline int get_reindex_options(ReindexStmt *stmt) { ListCell *lc; bool concurrently = false; bool verbose = false; /* Parse option list */ foreach (lc, stmt->params) { DefElem *opt = (DefElem *) lfirst(lc); if (strcmp(opt->defname, "verbose") == 0) verbose = defGetBoolean(opt); else if (strcmp(opt->defname, "concurrently") == 0) concurrently = defGetBoolean(opt); else ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unrecognized REINDEX option \"%s\"", opt->defname), parser_errposition(NULL, opt->location))); } return (verbose ? REINDEXOPT_VERBOSE : 0) | (concurrently ? REINDEXOPT_CONCURRENTLY : 0); } /* * define some list macros for convenience */ #define lfifth(l) lfirst(list_nth_cell(l, 4)) #define lfifth_int(l) lfirst_int(list_nth_cell(l, 4)) #if PG16_LT /* * PG15 consolidate VACUUM xid cutoff logic. * * https://github.com/postgres/postgres/commit/efa4a946 * * PG16 introduced VacuumCutoffs so define here for previous PG versions. */ struct VacuumCutoffs { TransactionId relfrozenxid; MultiXactId relminmxid; TransactionId OldestXmin; MultiXactId OldestMxact; TransactionId FreezeLimit; MultiXactId MultiXactCutoff; }; static inline bool vacuum_get_cutoffs(Relation rel, const VacuumParams *params, struct VacuumCutoffs *cutoffs) { return vacuum_set_xid_limits(rel, 0, 0, 0, 0, &cutoffs->OldestXmin, &cutoffs->OldestMxact, &cutoffs->FreezeLimit, &cutoffs->MultiXactCutoff); } #endif /* * PG16 adds TMResult argument to ExecBRUpdateTriggers * https://github.com/postgres/postgres/commit/7103ebb7 * this was backported to PG15 in * https://github.com/postgres/postgres/commit/7d9a75713ab9 */ #if PG15 #define ExecBRUpdateTriggers(estate, \ epqstate, \ resultRelInfo, \ tupleid, \ oldtuple, \ slot, \ result, \ tmfdp) \ ExecBRUpdateTriggersNew(estate, epqstate, resultRelInfo, tupleid, oldtuple, slot, result, tmfdp) #endif /* * PG16 adds TMResult argument to ExecBRDeleteTriggers * https://github.com/postgres/postgres/commit/9321c79c * this was backported to PG15 in * https://github.com/postgres/postgres/commit/7d9a75713ab9 */ #if PG15 #define ExecBRDeleteTriggers(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd) \ ExecBRDeleteTriggersNew(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd) #endif #if PG16_GE #define pgstat_get_local_beentry_by_index_compat(idx) pgstat_get_local_beentry_by_index(idx) #else #define pgstat_get_local_beentry_by_index_compat(idx) pgstat_fetch_stat_local_beentry(idx) #endif /* * PG16 adds a new parameter to DefineIndex, total_parts, that takes * in the total number of direct and indirect partitions of the relation. * * https://github.com/postgres/postgres/commit/27f5c712 */ #if PG16_LT #define DefineIndexCompat(relationId, \ stmt, \ indexRelationId, \ parentIndexId, \ parentConstraintId, \ total_parts, \ is_alter_table, \ check_rights, \ check_not_in_use, \ skip_build, \ quiet) \ DefineIndex(relationId, \ stmt, \ indexRelationId, \ parentIndexId, \ parentConstraintId, \ is_alter_table, \ check_rights, \ check_not_in_use, \ skip_build, \ quiet) #else #define DefineIndexCompat(relationId, \ stmt, \ indexRelationId, \ parentIndexId, \ parentConstraintId, \ total_parts, \ is_alter_table, \ check_rights, \ check_not_in_use, \ skip_build, \ quiet) \ DefineIndex(relationId, \ stmt, \ indexRelationId, \ parentIndexId, \ parentConstraintId, \ total_parts, \ is_alter_table, \ check_rights, \ check_not_in_use, \ skip_build, \ quiet) #endif #if PG16_LT #include <catalog/pg_database_d.h> #include <catalog/pg_foreign_server_d.h> #include <catalog/pg_namespace_d.h> #include <catalog/pg_proc_d.h> #include <catalog/pg_tablespace_d.h> #include <utils/acl.h> /* * PG16 replaces most aclcheck functions with a common object_aclcheck() function * https://github.com/postgres/postgres/commit/c727f511 */ static inline AclResult object_aclcheck(Oid classid, Oid objectid, Oid roleid, AclMode mode) { switch (classid) { case DatabaseRelationId: return pg_database_aclcheck(objectid, roleid, mode); case ForeignServerRelationId: return pg_foreign_server_aclcheck(objectid, roleid, mode); case NamespaceRelationId: return pg_namespace_aclcheck(objectid, roleid, mode); case ProcedureRelationId: return pg_proc_aclcheck(objectid, roleid, mode); case TableSpaceRelationId: return pg_tablespace_aclcheck(objectid, roleid, mode); default: Assert(false); } return ACLCHECK_NOT_OWNER; } /* * PG16 replaces pg_foo_ownercheck() functions with a common object_ownercheck() function * https://github.com/postgres/postgres/commit/afbfc029 */ static inline bool object_ownercheck(Oid classid, Oid objectid, Oid roleid) { switch (classid) { case RelationRelationId: return pg_class_ownercheck(objectid, roleid); default: Assert(false); } return false; } #endif #if PG17_LT /* * Backport of RestrictSearchPath() from PG17 * * We skip the check for IsBootstrapProcessingMode() since it creates problems * on Windows builds and we don't need it for our use case. */ #include <utils/guc.h> static inline void RestrictSearchPath(void) { set_config_option("search_path", "pg_catalog, pg_temp", PGC_USERSET, PGC_S_SESSION, GUC_ACTION_SAVE, true, 0, false); } #endif #if PG17_LT /* This macro was renamed in PG17, see 414f6c0fb79a */ #define WAIT_EVENT_MESSAGE_QUEUE_INTERNAL WAIT_EVENT_MQ_INTERNAL /* 'flush' argument was added in 173b56f1ef59 */ #define LogLogicalMessageCompat(prefix, message, size, transactional, flush) \ LogLogicalMessage(prefix, message, size, transactional) /* 'stmt' argument was added in f21848de2013 */ #define reindex_relation_compat(stmt, relid, flags, params) reindex_relation(relid, flags, params) /* 'vacuum_is_relation_owner' was renamed to 'vacuum_is_permitted_for_relation' in ecb0fd33720f */ #define vacuum_is_permitted_for_relation_compat(relid, reltuple, options) \ vacuum_is_relation_owner(relid, reltuple, options) /* * 'BackendIdGetProc' was renamed to 'ProcNumberGetProc' in 024c52111757. * Also 'backendId' was renamed to 'procNumber' */ #define VirtualTransactionGetProcCompat(vxid) BackendIdGetProc((vxid)->backendId) /* * 'opclassOptions' argument was added in 784162357130. * Previously indexInfo->ii_OpclassOptions was used instead. * On top of that 'stattargets' argument was added in 6a004f1be87d. */ #define index_create_compat(heapRelation, \ indexRelationName, \ indexRelationId, \ parentIndexRelid, \ parentConstraintId, \ relFileNumber, \ indexInfo, \ indexColNames, \ accessMethodId, \ tableSpaceId, \ collationIds, \ opclassIds, \ opclassOptions, \ coloptions, \ stattargets, \ reloptions, \ flags, \ constr_flags, \ allow_system_table_mods, \ is_internal, \ constraintId) \ index_create(heapRelation, \ indexRelationName, \ indexRelationId, \ parentIndexRelid, \ parentConstraintId, \ relFileNumber, \ indexInfo, \ indexColNames, \ accessMethodId, \ tableSpaceId, \ collationIds, \ opclassIds, \ coloptions, \ reloptions, \ flags, \ constr_flags, \ allow_system_table_mods, \ is_internal, \ constraintId) #else /* PG17_GE */ #define LogLogicalMessageCompat(prefix, message, size, transactional, flush) \ LogLogicalMessage(prefix, message, size, transactional, flush) #define reindex_relation_compat(stmt, relid, flags, params) \ reindex_relation(stmt, relid, flags, params) #define vacuum_is_permitted_for_relation_compat(relid, reltuple, options) \ vacuum_is_permitted_for_relation(relid, reltuple, options) #define VirtualTransactionGetProcCompat(vxid) ProcNumberGetProc(vxid->procNumber) #define index_create_compat(heapRelation, \ indexRelationName, \ indexRelationId, \ parentIndexRelid, \ parentConstraintId, \ relFileNumber, \ indexInfo, \ indexColNames, \ accessMethodId, \ tableSpaceId, \ collationIds, \ opclassIds, \ opclassOptions, \ coloptions, \ stattargets, \ reloptions, \ flags, \ constr_flags, \ allow_system_table_mods, \ is_internal, \ constraintId) \ index_create(heapRelation, \ indexRelationName, \ indexRelationId, \ parentIndexRelid, \ parentConstraintId, \ relFileNumber, \ indexInfo, \ indexColNames, \ accessMethodId, \ tableSpaceId, \ collationIds, \ opclassIds, \ opclassOptions, \ coloptions, \ stattargets, \ reloptions, \ flags, \ constr_flags, \ allow_system_table_mods, \ is_internal, \ constraintId) #endif #if PG17_LT /* 'mergeActions' argument was added in 5f2e179bd31e */ #define CheckValidResultRelCompat(resultRelInfo, operation, onConflictAction, mergeActions) \ CheckValidResultRel(resultRelInfo, operation) #elif PG18_LT #define CheckValidResultRelCompat(resultRelInfo, operation, onConflictAction, mergeActions) \ CheckValidResultRel(resultRelInfo, operation, mergeActions) #else #define CheckValidResultRelCompat(resultRelInfo, operation, onConflictAction, mergeActions) \ CheckValidResultRel(resultRelInfo, operation, onConflictAction, mergeActions) #endif #if PG17_LT /* * Overflow-aware comparison functions to be used in qsort. Introduced in PG * 17 and included here for older PG versions. */ static inline int pg_cmp_u32(uint32 a, uint32 b) { return (a > b) - (a < b); } #endif #if PG16_LT /* * Similarly, wrappers around labs()/llabs() matching our int64. * * Introduced on PG16: * https://github.com/postgres/postgres/commit/357cfefb09115292cfb98d504199e6df8201c957 */ #ifdef HAVE_LONG_INT_64 #define i64abs(i) labs(i) #else #define i64abs(i) llabs(i) #endif #endif /* * PG18 adds IndexScanInstrumentation parameter to index_beginscan * https://github.com/postgres/postgres/commit/0fbceae8 */ #if PG18_LT #define index_beginscan_compat(heapRelation, \ indexRelation, \ snapshot, \ instrument, \ nkeys, \ norderbys) \ index_beginscan(heapRelation, indexRelation, snapshot, nkeys, norderbys) #else #define index_beginscan_compat(heapRelation, \ indexRelation, \ snapshot, \ instrument, \ nkeys, \ norderbys) \ index_beginscan(heapRelation, indexRelation, snapshot, instrument, nkeys, norderbys) #endif #if PG16_LT #define make_range_compat(typcache, lower, upper, empty, escontext) \ make_range(typcache, lower, upper, empty) #else #define make_range_compat(typcache, lower, upper, empty, escontext) \ make_range(typcache, lower, upper, empty, escontext) #endif /* Copied from PG17. We can remove it once we deprecate older versions. */ #if PG17_LT static inline void initReadOnlyStringInfo(StringInfo str, char *data, int len) { str->data = data; str->len = len; str->maxlen = 0; /* read-only */ str->cursor = 0; } #endif /* * PG18 renames ri_ConstraintExprs to ri_CheckConstraintExprs * Add macros so we can use the new naming for older versions. * https://github.com/postgres/postgres/commit/9a9ead11 */ #if PG18_LT #define ri_CheckConstraintExprs ri_ConstraintExprs #endif /* * PG18 renames ec_derives to ec_derives_list * Add macros so we can use the new naming for older versions. * https://github.com/postgres/postgres/commit/88f55bc9 */ #if PG18_LT #define ec_derives_list ec_derives #endif /* PG18 introduces new CompareType for ordering operations * Add macros so we can use the new naming for older versions. * https://github.com/postgres/postgres/commit/8123e91f */ #if PG18_LT #define CompareType int16 #define COMPARE_LT BTLessStrategyNumber #define COMPARE_GT BTGreaterStrategyNumber #define pk_cmptype pk_strategy #endif /* PG18 adds is_merge_delete param to ExecBR{Delete|Update}Triggers function. * This has been backported to 17.6 but with a new name (ExecBR{Delete|Update}TriggersNew)j * Add compat function to cover 3 versions (pre 17.6, 17.6 - 18, post 18) * https://github.com/postgres/postgres/commit/5022ff25 */ #if PG_VERSION_NUM < 170006 #define ExecBRDeleteTriggersCompat(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) \ ExecBRDeleteTriggers(estate, epqstate, relinfo, tupleid, fdw_trigtuple, epqslot, tmresult, tmfd) #define ExecBRUpdateTriggersCompat(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) \ ExecBRUpdateTriggers(estate, epqstate, relinfo, tupleid, fdw_trigtuple, epqslot, tmresult, tmfd) #endif #if PG_VERSION_NUM >= 170006 && PG_VERSION_NUM < 180000 #define ExecBRDeleteTriggersCompat(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) \ ExecBRDeleteTriggersNew(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) #define ExecBRUpdateTriggersCompat(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) \ ExecBRUpdateTriggersNew(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) #endif #if PG18_GE #define ExecBRDeleteTriggersCompat(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) \ ExecBRDeleteTriggers(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) #define ExecBRUpdateTriggersCompat(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) \ ExecBRUpdateTriggers(estate, \ epqstate, \ relinfo, \ tupleid, \ fdw_trigtuple, \ epqslot, \ tmresult, \ tmfd, \ is_merge_delete) #endif /* PG16 consolidates ItemPointer to datum functions so backported it to PG15 * https://github.com/postgres/postgres/commit/bd944884e92a */ #if PG16_LT static inline ItemPointer DatumGetItemPointer(Datum X) { return (ItemPointer) DatumGetPointer(X); } static inline Datum ItemPointerGetDatum(const ItemPointerData *X) { return PointerGetDatum(X); } #endif ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/config.h.in������������������������������������������������������������������0000664�0000000�0000000�00000002526�15100345067�0016672�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#ifndef TIMESCALEDB_CONFIG_H #define TIMESCALEDB_CONFIG_H #define TIMESCALEDB_VERSION "@PROJECT_VERSION@" #define TIMESCALEDB_VERSION_MOD "@PROJECT_VERSION_MOD@" #define TIMESCALEDB_MAJOR_VERSION "@PROJECT_VERSION_MAJOR@" #define TIMESCALEDB_MINOR_VERSION "@PROJECT_VERSION_MINOR@" #define TIMESCALEDB_PATCH_VERSION "@PROJECT_VERSION_PATCH@" #define TIMESCALEDB_MOD_VERSION "@VERSION_MOD@" #define BUILD_OS_NAME "@CMAKE_SYSTEM_NAME@" #define BUILD_OS_VERSION "@CMAKE_SYSTEM_VERSION@" #define BUILD_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@" #define BUILD_POINTER_BYTES @CMAKE_SIZEOF_VOID_P@ #define CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_PLUGIN_NAME "@TSL_CAGG_INVALIDATION_PLUGIN_NAME@" /* * Value should be set in package release scripts. Otherwise * defaults to "source" */ #define TIMESCALEDB_INSTALL_METHOD "@PROJECT_INSTALL_METHOD@" /* Platform */ #ifndef WIN32 #cmakedefine WIN32 #endif #ifndef MSVC #cmakedefine MSVC #endif #ifndef UNIX #cmakedefine UNIX #endif #ifndef APPLE #cmakedefine APPLE #endif #ifndef DEBUG #cmakedefine DEBUG #endif #ifndef TS_DEBUG #cmakedefine TS_DEBUG #endif #ifndef USE_TELEMETRY #cmakedefine USE_TELEMETRY #endif #ifndef TELEMETRY_DEFAULT #cmakedefine TELEMETRY_DEFAULT @TELEMETRY_DEFAULT@ #endif /* Avoid conflicts with USE_OPENSSL defined by PostgreSQL */ #cmakedefine TS_USE_OPENSSL #endif /* TIMESCALEDB_CONFIG_H */ ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/constraint.c�����������������������������������������������������������������0000664�0000000�0000000�00000007160�15100345067�0017176�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/genam.h> #include <access/table.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/pg_constraint.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/rel.h> #include "constraint.h" #include "indexing.h" /* * Process constraints that belong to a given relation. * * Returns the number of constraints processed. */ int ts_constraint_process(Oid relid, constraint_func process_func, void *ctx) { ScanKeyData skey; Relation rel; SysScanDesc scan; HeapTuple htup; bool should_continue = true; int count = 0; ScanKeyInit(&skey, Anum_pg_constraint_conrelid, BTEqualStrategyNumber, F_OIDEQ, relid); rel = table_open(ConstraintRelationId, AccessShareLock); scan = systable_beginscan(rel, ConstraintRelidTypidNameIndexId, true, NULL, 1, &skey); while (HeapTupleIsValid(htup = systable_getnext(scan)) && should_continue) { switch (process_func(htup, ctx)) { case CONSTR_PROCESSED: count++; break; case CONSTR_PROCESSED_DONE: count++; should_continue = false; break; case CONSTR_IGNORED: break; case CONSTR_IGNORED_DONE: should_continue = false; break; } } systable_endscan(scan); table_close(rel, AccessShareLock); return count; } /* * Search for an existing constraint in the chunk that matches the given * hypertable constraint. This is used to avoid creating duplicate constraints * when creating chunks. * * Returns true if a matching constraint is found, false otherwise. */ Form_pg_constraint ts_constraint_find_matching(HeapTuple ht_tup, Relation chunk_rel) { ScanKeyData skey; Relation constraint_rel; SysScanDesc scan; HeapTuple chunk_tup; Form_pg_constraint ht_con = (Form_pg_constraint) GETSTRUCT(ht_tup); Form_pg_constraint chunk_con; Relation ht_rel = RelationIdGetRelation(ht_con->conrelid); Form_pg_constraint result = NULL; constraint_rel = table_open(ConstraintRelationId, RowExclusiveLock); /* Search for a constraint matching this one */ ScanKeyInit(&skey, Anum_pg_constraint_conrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(RelationGetRelid(chunk_rel))); scan = systable_beginscan(constraint_rel, ConstraintRelidTypidNameIndexId, true, NULL, 1, &skey); while (HeapTupleIsValid(chunk_tup = systable_getnext(scan))) { chunk_con = (Form_pg_constraint) GETSTRUCT(chunk_tup); /* Check constraints are handled by CreateInheritance() */ if (ht_con->contype != chunk_con->contype || ht_con->contype == CONSTRAINT_CHECK) continue; /* * Get the main name for chunk constraint and check whether it matches * the hypertable constraint name. If names match, then we compare indexes * to ensure that the constraints are equivalent. If the names do not * match, we assume that the constraints are not equivalent. */ if (ht_con->contype == CONSTRAINT_PRIMARY || ht_con->contype == CONSTRAINT_UNIQUE || ht_con->contype == CONSTRAINT_EXCLUSION) { if (ts_indexing_compare(ht_con->conindid, chunk_con->conindid)) { /* * pfree'ing this form is up to the caller. It is not expected to * consume a lot of memory, as only one form is allocated per * constraint. */ result = (Form_pg_constraint) palloc(sizeof(FormData_pg_constraint)); memcpy(result, chunk_con, sizeof(FormData_pg_constraint)); break; } } } systable_endscan(scan); table_close(constraint_rel, RowExclusiveLock); RelationClose(ht_rel); return result; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/constraint.h�����������������������������������������������������������������0000664�0000000�0000000�00000001640�15100345067�0017200�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/htup.h> #include "export.h" /* * Return status for constraint processing function. * * PROCESSED - count the constraint as processed * IGNORED - the constraint wasn't processed * DONE - stop processing constraints */ typedef enum ConstraintProcessStatus { CONSTR_PROCESSED, CONSTR_PROCESSED_DONE, CONSTR_IGNORED, CONSTR_IGNORED_DONE, } ConstraintProcessStatus; typedef ConstraintProcessStatus (*constraint_func)(HeapTuple constraint_tuple, void *ctx); extern TSDLLEXPORT int ts_constraint_process(Oid relid, constraint_func process_func, void *ctx); extern TSDLLEXPORT Form_pg_constraint ts_constraint_find_matching(HeapTuple ht_tup, Relation chunk_rel); ������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/copy.c�����������������������������������������������������������������������0000664�0000000�0000000�00000136464�15100345067�0015776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. * * The code copies data to a hypertable or migrates existing data from * a table to a hypertable when create_hypertable(..., migrate_data => * 'true', ...) is called. * * Unfortunately, there aren't any good hooks in the regular COPY code to * insert our chunk dispatching. So, most of this code is a straight-up * copy of the regular PostgreSQL source code for the COPY command * (command/copy.c and command/copyfrom.c), albeit with minor modifications. */ #include <postgres.h> #include <access/heapam.h> #include <access/hio.h> #include <access/sysattr.h> #include <access/xact.h> #include <catalog/pg_trigger_d.h> #include <commands/copy.h> #include <commands/copyfrom_internal.h> #include <commands/tablecmds.h> #include <commands/trigger.h> #include <executor/executor.h> #include <executor/nodeModifyTable.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <optimizer/optimizer.h> #include <parser/parse_coerce.h> #include <parser/parse_collate.h> #include <parser/parse_expr.h> #include <parser/parse_relation.h> #include <storage/bufmgr.h> #include <storage/smgr.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/guc.h> #include <utils/hsearch.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/rls.h> #include "compat/compat.h" #include "chunk_insert_state.h" #include "copy.h" #include "cross_module_fn.h" #include "dimension.h" #include "hypertable.h" #include "indexing.h" #include "subspace_store.h" /* * Represents the insert method to be used during COPY FROM. */ typedef enum TSCopyInsertMethod { TS_CIM_SINGLE, /* use table_tuple_insert or ExecForeignInsert */ TS_CIM_MULTI_CONDITIONAL, /* use table_multi_insert or * ExecForeignBatchInsert only if valid */ TS_CIM_COMPRESSION, /* use compression for the insert */ } TSCopyInsertMethod; /* * No more than this many tuples per TSCopyMultiInsertBuffer * * Caution: Don't make this too big, as we could end up with this many * TSCopyMultiInsertBuffer items stored in TSCopyMultiInsertInfo's * multiInsertBuffers list. Increasing this can cause quadratic growth in * memory requirements during copies into partitioned tables with a large * number of partitions. */ #define MAX_BUFFERED_TUPLES 1000 /* * Flush buffers if there are >= this many bytes, as counted by the input * size, of tuples stored. */ #define MAX_BUFFERED_BYTES 65535 /* Trim the list of buffers back down to this number after flushing */ #define MAX_PARTITION_BUFFERS 32 /* Stores multi-insert data related to a single relation in CopyFrom. */ typedef struct TSCopyMultiInsertBuffer { TSCopyInsertMethod method; /* The insert method to use */ /* * Tuple description for inserted tuple slots. We use a copy of the result * relation tupdesc to disable reference counting for this tupdesc. It is * not needed and is wasting a lot of CPU in ResourceOwner. */ TupleDesc tupdesc; TupleTableSlot *slots[MAX_BUFFERED_TUPLES]; /* Array to store tuples */ Point *point; /* The point in space of this buffer */ BulkInsertState bistate; /* BulkInsertState for this buffer */ int nused; /* number of 'slots' containing tuples */ uint64 linenos[MAX_BUFFERED_TUPLES]; /* Line # of tuple in copy * stream */ bool can_skip_constraints; /* Whether we can skip constraint * checks for this relation */ RowCompressor *compressor; /* compressor for the chunk */ BulkWriter *bulk_writer; /* BulkWriter for the compressed chunk */ } TSCopyMultiInsertBuffer; /* * Stores one or many TSCopyMultiInsertBuffers and details about the size and * number of tuples which are stored in them. This allows multiple buffers to * exist at once when COPYing into a partitioned table. * * The HTAB is used to store the relationship between a chunk and a * TSCopyMultiInsertBuffer beyond the lifetime of the ChunkInsertState. * * Chunks can be closed (e.g., due to timescaledb.max_open_chunks_per_insert). * When ts_chunk_dispatch_get_chunk_insert_state is called again for a closed * chunk, a new ChunkInsertState is returned. */ typedef struct TSCopyMultiInsertInfo { HTAB *multiInsertBuffers; /* Maps the chunk ids to the buffers (chunkid -> TSCopyMultiInsertBuffer) */ int bufferedTuples; /* number of tuples buffered over all buffers */ int bufferedBytes; /* number of bytes from all buffered tuples */ CopyChunkState *ccstate; /* Copy chunk state for this TSCopyMultiInsertInfo */ EState *estate; /* Executor state used for COPY */ CommandId mycid; /* Command Id used for COPY */ int ti_options; /* table insert options */ Hypertable *ht; /* The hypertable for the inserts */ bool has_continuous_aggregate; } TSCopyMultiInsertInfo; /* * The entry of the multiInsertBuffers HTAB. */ typedef struct MultiInsertBufferEntry { int32 key; TSCopyMultiInsertBuffer *buffer; } MultiInsertBufferEntry; static CopyChunkState * copy_chunk_state_create(Hypertable *ht, Relation rel, CopyFromFunc from_func, CopyFromState cstate, TableScanDesc scandesc) { CopyChunkState *ccstate; EState *estate = CreateExecutorState(); ccstate = palloc(sizeof(CopyChunkState)); ccstate->rel = rel; ccstate->estate = estate; ccstate->cstate = cstate; ccstate->scandesc = scandesc; ccstate->next_copy_from = from_func; ccstate->where_clause = NULL; return ccstate; } /* * Determine whether we can skip constraints checks for this relation. * We will skip constraints checks if: * 1. The relation has CHECK constraints that match the number of dimensions * 2. The relation has no NOT NULL constraints on non-partitioning columns */ static bool can_skip_constraint_check(Hypertable *ht, TupleDesc tupledesc) { /* * When the number of constraints does not match the number of dimensions then there are * additional constraints that we need to check during COPY. Partitioning constraints would * have already been checked by tuple routing. */ Assert(tupledesc->constr->num_check >= ht->space->num_dimensions); if (tupledesc->constr && tupledesc->constr->num_check != ht->space->num_dimensions) return false; for (int i = 0; i < tupledesc->natts; i++) { Form_pg_attribute att = TupleDescAttr(tupledesc, i); if (att->attisdropped) continue; /* * If we have NOT NULL constraints on non-partitioning columns, we cannot skip * constraints and have to check them. */ if (att->attnotnull) { if (ts_is_partitioning_column_name(ht, att->attname)) continue; return false; } } return true; } /* * Allocate memory and initialize a new TSCopyMultiInsertBuffer for this * ResultRelInfo. */ static TSCopyMultiInsertBuffer * TSCopyMultiInsertBufferInit(TSCopyMultiInsertInfo *miinfo, ChunkInsertState *cis, Point *point, TSCopyInsertMethod method) { TSCopyMultiInsertBuffer *buffer; buffer = (TSCopyMultiInsertBuffer *) palloc0(sizeof(TSCopyMultiInsertBuffer)); buffer->method = method; buffer->point = palloc(POINT_SIZE(point->num_coords)); memcpy(buffer->point, point, POINT_SIZE(point->num_coords)); buffer->can_skip_constraints = can_skip_constraint_check(miinfo->ht, cis->rel->rd_att); /* * Downgrade the insert method when triggers are present. */ if (method != TS_CIM_SINGLE && cis->result_relation_info->ri_TrigDesc) { /* If there are BEFORE INSERT row triggers, we cannot use * multi-insert, as the tuples may be inserted in an out-of-order manner, * which might violate the semantics of the triggers. * * For compressed inserts we fall back to TS_CIM_SINGLE when any triggers are present. * This is a safety measure. We might actually safely allow some of these in the future. */ if (method == TS_CIM_MULTI_CONDITIONAL && (cis->result_relation_info->ri_TrigDesc->trig_insert_before_row || cis->result_relation_info->ri_TrigDesc->trig_insert_instead_row)) { buffer->method = TS_CIM_SINGLE; } else if (method == TS_CIM_COMPRESSION) { buffer->method = TS_CIM_SINGLE; } } switch (buffer->method) { case TS_CIM_SINGLE: break; case TS_CIM_MULTI_CONDITIONAL: buffer->bistate = GetBulkInsertState(); /* * Make a non-refcounted copy of tupdesc to avoid spending CPU in * ResourceOwner when creating a big number of table slots. This happens * because each new slot pins its tuple descriptor using PinTupleDesc, and * for reference-counting tuples this involves adding a new reference to * ResourceOwner, which is not very efficient for a large number of * references. */ buffer->tupdesc = CreateTupleDescCopyConstr(cis->rel->rd_att); Assert(buffer->tupdesc->tdrefcount == -1); break; case TS_CIM_COMPRESSION: { bool sort = ts_guc_enable_direct_compress_copy_sort_batches && !ts_guc_enable_direct_compress_copy_client_sorted; buffer->compressor = ts_cm_functions->compressor_init(cis->rel, &buffer->bulk_writer, sort); /* * The sorting done in the compressor is only a local sort for the * currently ingested batch and will produce overlapping batches for * multiple independent insert streams. Therefore we still need to * mark the chunk as unordered until we adjust the rest of the code to * be able to deal with overlapping batches. */ if (!ts_guc_enable_direct_compress_copy_client_sorted) { Chunk *chunk = ts_chunk_get_by_id(cis->chunk_id, true); if (!ts_chunk_is_unordered(chunk)) ts_chunk_set_unordered(chunk); } cis->columnstore_insert = true; break; } } return buffer; } /* * Get the existing TSCopyMultiInsertBuffer for the chunk or create a new one. */ static inline TSCopyMultiInsertBuffer * TSCopyMultiInsertInfoGetOrSetupBuffer(TSCopyMultiInsertInfo *miinfo, ChunkInsertState *cis, Point *point, TSCopyInsertMethod method) { bool found; int32 chunk_id; Assert(miinfo != NULL); Assert(cis != NULL); Assert(point != NULL); chunk_id = cis->chunk_id; MultiInsertBufferEntry *entry = hash_search(miinfo->multiInsertBuffers, &chunk_id, HASH_ENTER, &found); /* No insert buffer for this chunk exists, create a new one */ if (!found) { entry->buffer = TSCopyMultiInsertBufferInit(miinfo, cis, point, method); } return entry->buffer; } /* * Create a new HTAB that maps from the chunk_id to the multi-insert buffers. */ static HTAB * TSCopyCreateNewInsertBufferHashMap() { struct HASHCTL hctl = { .keysize = sizeof(int32), .entrysize = sizeof(MultiInsertBufferEntry), .hcxt = CurrentMemoryContext, }; return hash_create("COPY insert buffer", 20, &hctl, HASH_ELEM | HASH_CONTEXT | HASH_BLOBS); } /* * Initialize an already allocated TSCopyMultiInsertInfo. */ static void TSCopyMultiInsertInfoInit(TSCopyMultiInsertInfo *miinfo, ResultRelInfo *rri, CopyChunkState *ccstate, EState *estate, CommandId mycid, int ti_options, Hypertable *ht) { miinfo->multiInsertBuffers = TSCopyCreateNewInsertBufferHashMap(); miinfo->bufferedTuples = 0; miinfo->bufferedBytes = 0; miinfo->ccstate = ccstate; miinfo->estate = estate; miinfo->mycid = mycid; miinfo->ti_options = ti_options; miinfo->ht = ht; miinfo->has_continuous_aggregate = ts_hypertable_has_continuous_aggregates(ht->fd.id); } /* * Returns true if the buffers are full. */ static inline bool TSCopyMultiInsertInfoIsFull(TSCopyMultiInsertInfo *miinfo) { if (miinfo->bufferedTuples >= MAX_BUFFERED_TUPLES || miinfo->bufferedBytes >= MAX_BUFFERED_BYTES) return true; return false; } /* * Write the tuples stored in 'buffer' out to the table. */ static inline int TSCopyMultiInsertBufferFlush(TSCopyMultiInsertInfo *miinfo, TSCopyMultiInsertBuffer *buffer) { MemoryContext oldcontext; int i; Assert(miinfo != NULL); Assert(buffer != NULL); EState *estate = miinfo->estate; CommandId mycid = miinfo->mycid; int ti_options = miinfo->ti_options; int nused = buffer->nused; TupleTableSlot **slots = buffer->slots; if (buffer->method == TS_CIM_COMPRESSION) { ts_cm_functions->compressor_flush(buffer->compressor, buffer->bulk_writer); } /* * table_multi_insert and reinitialization of the chunk insert state may * leak memory, so switch to short-lived memory context before calling it. */ oldcontext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate)); /* * A chunk can be closed while buffering the tuples. Even when the chunk * insert state is moved to the copy memory context, the underlying * table is closed and pointers (e.g., result_relation_info point) to invalid * addresses. Re-reading the chunk insert state ensures that the table is * open and the pointers are valid. * * No callback on changed chunk is needed, the bulk insert state buffer is * freed in TSCopyMultiInsertBufferCleanup(). */ ChunkInsertState *cis = ts_chunk_tuple_routing_find_chunk(miinfo->ccstate->ctr, buffer->point); ResultRelInfo *resultRelInfo = cis->result_relation_info; /* * Add context information to the copy state, which is used to display * error messages with additional details. */ uint64 save_cur_lineno = 0; bool line_buf_valid = false; CopyFromState cstate = miinfo->ccstate->cstate; /* cstate can be NULL in calls that are invoked from timescaledb_move_from_table_to_chunks. */ if (cstate != NULL) { line_buf_valid = cstate->line_buf_valid; save_cur_lineno = cstate->cur_lineno; cstate->line_buf_valid = false; } table_multi_insert(resultRelInfo->ri_RelationDesc, slots, nused, mycid, ti_options, buffer->bistate); MemoryContextSwitchTo(oldcontext); for (i = 0; i < nused; i++) { if (cstate != NULL) cstate->cur_lineno = buffer->linenos[i]; /* * If there are any indexes, update them for all the inserted tuples, * and run AFTER ROW INSERT triggers. */ if (resultRelInfo->ri_NumIndices > 0) { List *recheckIndexes; recheckIndexes = ExecInsertIndexTuplesCompat(resultRelInfo, buffer->slots[i], estate, false, false, NULL, NIL, false); ExecARInsertTriggers(estate, resultRelInfo, slots[i], recheckIndexes, NULL /* transition capture */); list_free(recheckIndexes); } /* * There's no indexes, but see if we need to run AFTER ROW INSERT * triggers anyway. */ else if (resultRelInfo->ri_TrigDesc != NULL && (resultRelInfo->ri_TrigDesc->trig_insert_after_row || resultRelInfo->ri_TrigDesc->trig_insert_new_table)) { ExecARInsertTriggers(estate, resultRelInfo, slots[i], NIL, NULL /* transition capture */); } if (miinfo->has_continuous_aggregate && !ts_guc_enable_cagg_wal_based_invalidation) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slots[i], false, &should_free); ts_cm_functions->continuous_agg_dml_invalidate(miinfo->ht->fd.id, resultRelInfo->ri_RelationDesc, tuple, NULL, false); if (should_free) heap_freetuple(tuple); } ExecClearTuple(slots[i]); } /* Mark that all slots are free */ buffer->nused = 0; /* Chunk could be closed on a subsequent call of ts_chunk_dispatch_get_chunk_insert_state * (e.g., due to timescaledb.max_open_chunks_per_insert). So, ensure the bulk insert is * finished after the flush is complete. */ ResultRelInfo *result_relation_info = cis->result_relation_info; Assert(result_relation_info != NULL); table_finish_bulk_insert(result_relation_info->ri_RelationDesc, miinfo->ti_options); /* Reset cur_lineno and line_buf_valid to what they were */ if (cstate != NULL) { cstate->line_buf_valid = line_buf_valid; cstate->cur_lineno = save_cur_lineno; } return cis->chunk_id; } /* * Drop used slots and free member for this buffer. * * The buffer must be flushed before cleanup. */ static inline void TSCopyMultiInsertBufferCleanup(TSCopyMultiInsertInfo *miinfo, TSCopyMultiInsertBuffer *buffer) { int i; /* Ensure buffer was flushed */ Assert(buffer->nused == 0); switch (buffer->method) { case TS_CIM_SINGLE: break; case TS_CIM_MULTI_CONDITIONAL: FreeBulkInsertState(buffer->bistate); /* Since we only create slots on demand, just drop the non-null ones. */ for (i = 0; i < MAX_BUFFERED_TUPLES && buffer->slots[i] != NULL; i++) ExecDropSingleTupleTableSlot(buffer->slots[i]); FreeTupleDesc(buffer->tupdesc); break; case TS_CIM_COMPRESSION: ts_cm_functions->compressor_free(buffer->compressor, buffer->bulk_writer); break; } pfree(buffer->point); pfree(buffer); } /* list_sort comparator to sort TSCopyMultiInsertBuffer by usage */ static int TSCmpBuffersByUsage(const ListCell *a, const ListCell *b) { int b1 = ((const TSCopyMultiInsertBuffer *) lfirst(a))->nused; int b2 = ((const TSCopyMultiInsertBuffer *) lfirst(b))->nused; Assert(b1 >= 0); Assert(b2 >= 0); if (b1 > b2) { return 1; } if (b1 == b2) { return 0; } return -1; } /* * Flush all buffers by writing the tuples to the chunks. In addition, trim down the * amount of multi-insert buffers to MAX_PARTITION_BUFFERS by deleting the least used * buffers (the buffers that store least tuples). */ static inline void TSCopyMultiInsertInfoFlush(TSCopyMultiInsertInfo *miinfo, ChunkInsertState *cur_cis) { HASH_SEQ_STATUS status; MultiInsertBufferEntry *entry; int current_multi_insert_buffers; int buffers_to_delete; bool found; int32 flushed_chunk_id; List *buffer_list = NIL; ListCell *lc; current_multi_insert_buffers = hash_get_num_entries(miinfo->multiInsertBuffers); int current_chunk_id = cur_cis ? cur_cis->chunk_id : 0; /* Create a list of buffers that can be sorted by usage */ hash_seq_init(&status, miinfo->multiInsertBuffers); for (entry = hash_seq_search(&status); entry != NULL; entry = hash_seq_search(&status)) { buffer_list = lappend(buffer_list, entry->buffer); } buffers_to_delete = Max(current_multi_insert_buffers - MAX_PARTITION_BUFFERS, 0); /* Sorting is only needed if we want to remove the least used buffers */ if (buffers_to_delete > 0) list_sort(buffer_list, TSCmpBuffersByUsage); /* Flush buffers and delete them if needed */ foreach (lc, buffer_list) { TSCopyMultiInsertBuffer *buffer = (TSCopyMultiInsertBuffer *) lfirst(lc); flushed_chunk_id = TSCopyMultiInsertBufferFlush(miinfo, buffer); if (buffers_to_delete > 0) { /* * Reduce active multi-insert buffers. However, the current used buffer * should not be deleted because it might reused for the next insert. */ if (current_chunk_id == 0 || flushed_chunk_id != current_chunk_id) { TSCopyMultiInsertBufferCleanup(miinfo, buffer); hash_search(miinfo->multiInsertBuffers, &flushed_chunk_id, HASH_REMOVE, &found); Assert(found); buffers_to_delete--; } } } list_free(buffer_list); /* All buffers have been flushed */ miinfo->bufferedTuples = 0; miinfo->bufferedBytes = 0; } /* * All existing buffers are flushed and the multi-insert states * are freed. So, delete old hash map and create a new one for further * inserts. */ static inline void TSCopyMultiInsertInfoFlushAndCleanup(TSCopyMultiInsertInfo *miinfo) { TSCopyMultiInsertInfoFlush(miinfo, NULL); HASH_SEQ_STATUS status; MultiInsertBufferEntry *entry; hash_seq_init(&status, miinfo->multiInsertBuffers); for (entry = hash_seq_search(&status); entry != NULL; entry = hash_seq_search(&status)) { TSCopyMultiInsertBuffer *buffer = entry->buffer; TSCopyMultiInsertBufferCleanup(miinfo, buffer); } hash_destroy(miinfo->multiInsertBuffers); } /* * Get the next TupleTableSlot that the next tuple should be stored in. * * Callers must ensure that the buffer is not full. * * Note: 'miinfo' is unused but has been included for consistency with the * other functions in this area. */ static inline TupleTableSlot * TSCopyMultiInsertInfoNextFreeSlot(TSCopyMultiInsertInfo *miinfo, ResultRelInfo *result_relation_info, TSCopyMultiInsertBuffer *buffer) { int nused = buffer->nused; Assert(buffer != NULL); Assert(nused < MAX_BUFFERED_TUPLES); if (buffer->slots[nused] == NULL) { const TupleTableSlotOps *tts_cb = table_slot_callbacks(result_relation_info->ri_RelationDesc); buffer->slots[nused] = MakeSingleTupleTableSlot(buffer->tupdesc, tts_cb); } return buffer->slots[nused]; } /* * Record the previously reserved TupleTableSlot that was reserved by * TSCopyMultiInsertInfoNextFreeSlot as being consumed. */ static inline void TSCopyMultiInsertInfoStore(TSCopyMultiInsertInfo *miinfo, ResultRelInfo *rri, TSCopyMultiInsertBuffer *buffer, TupleTableSlot *slot, CopyFromState cstate) { Assert(buffer != NULL); Assert(slot == buffer->slots[buffer->nused]); /* Store the line number so we can properly report any errors later */ uint64 lineno = 0; /* The structure CopyFromState is private in PG < 14. So we can not access * the members like the line number or the size of the tuple. */ if (cstate != NULL) lineno = cstate->cur_lineno; buffer->linenos[buffer->nused] = lineno; /* Record this slot as being used */ buffer->nused++; /* Update how many tuples are stored and their size */ miinfo->bufferedTuples++; /* * Note: There is no reliable way to determine the in-memory size of a virtual * tuple. So, we perform flushing in PG < 14 only based on the number of buffered * tuples and not based on the size. */ if (cstate != NULL) { int tuplen = cstate->line_buf.len; miinfo->bufferedBytes += tuplen; } } static void copy_chunk_state_destroy(CopyChunkState *ccstate) { ts_chunk_tuple_routing_destroy(ccstate->ctr); FreeExecutorState(ccstate->estate); } static bool next_copy_from(CopyChunkState *ccstate, ExprContext *econtext, Datum *values, bool *nulls) { Assert(ccstate->cstate != NULL); return NextCopyFrom(ccstate->cstate, econtext, values, nulls); } /* * Error context callback when copying from table to chunk. */ static void copy_table_to_chunk_error_callback(void *arg) { TableScanDesc scandesc = (TableScanDesc) arg; errcontext("copying from table %s", RelationGetRelationName(scandesc->rs_rd)); } static TSCopyInsertMethod choose_copy_method(Hypertable *ht, CopyChunkState *ccstate, ResultRelInfo *resultRelInfo) { /* * Multi-insert buffers (TS_CIM_MULTI_CONDITIONAL) can only be used if no triggers are * defined on the target table. Otherwise, the tuples may be inserted in an out-of-order * manner, which might violate the semantics of the triggers. So, they are inserted * tuple-per-tuple (TS_CIM_SINGLE). However, the ts_block trigger on the hypertable can * be ignored. */ /* Before INSERT Triggers */ bool has_before_insert_row_trig = (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_before_row); /* Instead of INSERT Triggers */ bool has_instead_insert_row_trig = (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_instead_row); bool has_after_insert_statement_trig = (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_new_table); /* Depending on the configured trigger, enable or disable the multi-insert buffers */ if (has_after_insert_statement_trig || has_before_insert_row_trig || has_instead_insert_row_trig) { ereport(DEBUG1, (errmsg("Using normal unbuffered copy operation (TS_CIM_SINGLE) " "because triggers are defined on the destination table."))); if (ts_guc_enable_direct_compress_copy) ereport(WARNING, (errmsg("disabling direct compress copy due to presence of triggers on the " "destination table"))); return TS_CIM_SINGLE; } if (TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht) && ts_guc_enable_direct_compress_copy) { if (ts_hypertable_has_continuous_aggregates(ccstate->ctr->hypertable->fd.id)) { ereport(WARNING, (errmsg( "disabling direct compress because the destination table has continuous " "aggregates"))); } else if (ts_indexing_relation_has_primary_or_unique_index(ccstate->rel)) { ereport(WARNING, (errmsg("disabling direct compress because the destination table has unique " "constraints"))); } else if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->numtriggers > 1) { ereport(WARNING, (errmsg( "disabling direct compress because the destination table has triggers"))); } else { ccstate->ctr->create_compressed_chunk = true; ereport(DEBUG1, (errmsg("Using compressed copy operation (TS_CIM_COMPRESSION)."))); return TS_CIM_COMPRESSION; } } ereport(DEBUG1, (errmsg("Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL)."))); return TS_CIM_MULTI_CONDITIONAL; } /* * Use COPY FROM to copy data from file to relation. */ static uint64 copyfrom(CopyChunkState *ccstate, ParseState *pstate, Hypertable *ht, MemoryContext copycontext, void (*callback)(void *), void *arg) { ResultRelInfo *resultRelInfo; ResultRelInfo *saved_resultRelInfo = NULL; EState *estate = ccstate->estate; /* for ExecConstraints() */ ExprContext *econtext; TupleTableSlot *singleslot; MemoryContext oldcontext = CurrentMemoryContext; ErrorContextCallback errcallback = { .callback = callback, .arg = arg, }; CommandId mycid = GetCurrentCommandId(true); TSCopyInsertMethod insertMethod; /* The insert method for the table */ TSCopyMultiInsertInfo multiInsertInfo = { 0 }; /* pacify compiler */ int ti_options = 0; /* start with default options for insert */ BulkInsertState bistate = NULL; uint64 processed = 0; ExprState *qualexpr = NULL; Assert(pstate->p_rtable); if (ccstate->rel->rd_rel->relkind != RELKIND_RELATION) { if (ccstate->rel->rd_rel->relkind == RELKIND_VIEW) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot copy to view \"%s\"", RelationGetRelationName(ccstate->rel)))); else if (ccstate->rel->rd_rel->relkind == RELKIND_MATVIEW) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot copy to materialized view \"%s\"", RelationGetRelationName(ccstate->rel)))); else if (ccstate->rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot copy to foreign table \"%s\"", RelationGetRelationName(ccstate->rel)))); else if (ccstate->rel->rd_rel->relkind == RELKIND_SEQUENCE) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot copy to sequence \"%s\"", RelationGetRelationName(ccstate->rel)))); else ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot copy to non-table relation \"%s\"", RelationGetRelationName(ccstate->rel)))); } /*---------- * Check to see if we can avoid writing WAL * * If archive logging/streaming is not enabled *and* either * - table was created in same transaction as this COPY * - data is being written to relfilenode created in this transaction * then we can skip writing WAL. It's safe because if the transaction * doesn't commit, we'll discard the table (or the new relfilenode file). * If it does commit, we'll have done the heap_sync at the bottom of this * routine first. * * As mentioned in comments in utils/rel.h, the in-same-transaction test * is not always set correctly, since in rare cases rd_newRelfilenodeSubid * can be cleared before the end of the transaction. The exact case is * when a relation sets a new relfilenode twice in same transaction, yet * the second one fails in an aborted subtransaction, e.g. * * BEGIN; * TRUNCATE t; * SAVEPOINT save; * TRUNCATE t; * ROLLBACK TO save; * COPY ... * * Also, if the target file is new-in-transaction, we assume that checking * FSM for free space is a waste of time, even if we must use WAL because * of archiving. This could possibly be wrong, but it's unlikely. * * The comments for heap_insert and RelationGetBufferForTuple specify that * skipping WAL logging is only safe if we ensure that our tuples do not * go into pages containing tuples from any other transactions --- but this * must be the case if we have a new table or new relfilenode, so we need * no additional work to enforce that. *---------- */ /* createSubid is creation check, newRelfilenodeSubid is truncation check */ if (ccstate->rel->rd_createSubid != InvalidSubTransactionId || #if PG16_LT ccstate->rel->rd_newRelfilenodeSubid != InvalidSubTransactionId) #else ccstate->rel->rd_newRelfilelocatorSubid != InvalidSubTransactionId) #endif { ti_options |= HEAP_INSERT_SKIP_FSM; } /* * We need a ResultRelInfo so we can use the regular executor's * index-entry-making machinery. (There used to be a huge amount of code * here that basically duplicated execUtils.c ...) * * WARNING. The dummy rangetable index is decremented by 1 (unchecked) * inside `ExecConstraints` so unless you want to have a overflow, keep it * above zero. See `rt_fetch` in parsetree.h. */ resultRelInfo = makeNode(ResultRelInfo); #if PG16_LT ExecInitRangeTable(estate, pstate->p_rtable); #elif PG18_LT Assert(pstate->p_rteperminfos != NULL); ExecInitRangeTable(estate, pstate->p_rtable, pstate->p_rteperminfos); #else /* * PG18+ adds unpruned relids to ExecInitRangeTable * We initialize it with 1 similar to upstream behavior, * but since this is copy no pruning is expected to happen. */ Assert(pstate->p_rteperminfos != NULL); ExecInitRangeTable(estate, pstate->p_rtable, pstate->p_rteperminfos, bms_make_singleton(1)); #endif ExecInitResultRelation(estate, resultRelInfo, 1); CheckValidResultRelCompat(resultRelInfo, CMD_INSERT, ONCONFLICT_NONE, NIL); ExecOpenIndices(resultRelInfo, false); ccstate->ctr = ts_chunk_tuple_routing_create(estate, ht, resultRelInfo); singleslot = table_slot_create(resultRelInfo->ri_RelationDesc, &estate->es_tupleTable); /* Prepare to catch AFTER triggers. */ AfterTriggerBeginQuery(); /* * If there are any triggers with transition tables on the named relation, * we need to be prepared to capture transition tuples. Note that * ccstate->cstate is null when we migrate from an existing table in a * call from create_hypertable(), so we do not need a transition capture * state in this case. */ if (ccstate->cstate) ccstate->cstate->transition_capture = MakeTransitionCaptureState(ccstate->rel->trigdesc, RelationGetRelid(ccstate->rel), CMD_INSERT); if (ccstate->where_clause) qualexpr = ExecInitQual(castNode(List, ccstate->where_clause), NULL); /* * Check BEFORE STATEMENT insertion triggers. It's debatable whether we * should do this for COPY, since it's not really an "INSERT" statement as * such. However, executing these triggers maintains consistency with the * EACH ROW triggers that we already fire on COPY. */ ExecBSInsertTriggers(estate, resultRelInfo); bistate = GetBulkInsertState(); econtext = GetPerTupleExprContext(estate); /* Set up callback to identify error line number. * * It is not necessary to add an entry to the error context stack if we do * not have a CopyFromState or callback. In that case, we just use the existing * error already on the context stack. */ if (ccstate->cstate && callback) { errcallback.previous = error_context_stack; error_context_stack = &errcallback; } insertMethod = choose_copy_method(ht, ccstate, resultRelInfo); TSCopyMultiInsertInfoInit(&multiInsertInfo, resultRelInfo, ccstate, estate, mycid, ti_options, ht); TSCopyMultiInsertBuffer *buffer = NULL; int reset_count = 0; /* Reset the per-tuple exprcontext every 100 tuples */ Oid prev_chunk_oid = InvalidOid; /* Previous chunk OID to detect chunk changes */ for (;;) { TupleTableSlot *myslot = NULL; bool skip_tuple; Point *point = NULL; ChunkInsertState *cis = NULL; CHECK_FOR_INTERRUPTS(); /* * Reset the per-tuple exprcontext. We do this after every tuple, to * clean-up after expression evaluations etc. */ if (reset_count == 100) { ResetPerTupleExprContext(estate); reset_count = 0; } else reset_count++; myslot = singleslot; Assert(myslot != NULL); /* Switch into its memory context */ MemoryContextSwitchTo(GetPerTupleMemoryContext(estate)); ExecClearTuple(myslot); if (!ccstate->next_copy_from(ccstate, econtext, myslot->tts_values, myslot->tts_isnull)) break; ExecStoreVirtualTuple(myslot); /* Calculate the tuple's point in the N-dimensional hyperspace */ point = ts_hyperspace_calculate_point(ht->space, myslot); /* Find or create the insert state matching the point */ cis = ts_chunk_tuple_routing_find_chunk(ccstate->ctr, point); if (OidIsValid(prev_chunk_oid) && prev_chunk_oid != cis->rel->rd_id) { ReleaseBulkInsertStatePin(bistate); } prev_chunk_oid = cis->rel->rd_id; Assert(cis != NULL); ts_chunk_tuple_routing_decompress_for_insert(cis, myslot, ccstate->ctr->estate, false); /* Triggers and stuff need to be invoked in query context. */ MemoryContextSwitchTo(oldcontext); buffer = TSCopyMultiInsertInfoGetOrSetupBuffer(&multiInsertInfo, cis, point, insertMethod); /* * If the insert method has changed, we need to flush the * multi-insert info to ensure that the tuples are * visible to the triggers. */ if (insertMethod != buffer->method) TSCopyMultiInsertInfoFlush(&multiInsertInfo, cis); /* Convert the tuple to match the chunk's rowtype */ if (buffer->method == TS_CIM_SINGLE) { if (NULL != cis->hyper_to_chunk_map) myslot = execute_attr_map_slot(cis->hyper_to_chunk_map->attrMap, myslot, cis->slot); } else if (buffer->method == TS_CIM_COMPRESSION) { if (NULL != cis->hyper_to_chunk_map) myslot = execute_attr_map_slot(cis->hyper_to_chunk_map->attrMap, myslot, cis->slot); } else { /* * Prepare to queue up tuple for later batch insert into * current chunk. */ TupleTableSlot *batchslot; batchslot = TSCopyMultiInsertInfoNextFreeSlot(&multiInsertInfo, cis->result_relation_info, buffer); if (NULL != cis->hyper_to_chunk_map) myslot = execute_attr_map_slot(cis->hyper_to_chunk_map->attrMap, myslot, batchslot); else { /* * This looks more expensive than it is (Believe me, I * optimized it away. Twice.). The input is in virtual * form, and we'll materialize the slot below - for most * slot types the copy performs the work materialization * would later require anyway. */ ExecCopySlot(batchslot, myslot); myslot = batchslot; } } if (qualexpr != NULL) { econtext->ecxt_scantuple = myslot; if (!ExecQual(qualexpr, econtext)) continue; } /* * Set the result relation in the executor state to the target chunk. * This makes sure that the tuple gets inserted into the correct * chunk. */ saved_resultRelInfo = resultRelInfo; resultRelInfo = cis->result_relation_info; /* Set the right relation for triggers */ ts_tuptableslot_set_table_oid(myslot, RelationGetRelid(resultRelInfo->ri_RelationDesc)); skip_tuple = false; /* BEFORE ROW INSERT Triggers */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_before_row) skip_tuple = !ExecBRInsertTriggers(estate, resultRelInfo, myslot); if (!skip_tuple) { /* Note that PostgreSQL's copy path would check INSTEAD OF * INSERT/UPDATE/DELETE triggers here, but such triggers can only * exist on views and chunks cannot be views. */ List *recheckIndexes = NIL; /* Compute stored generated columns */ if (resultRelInfo->ri_RelationDesc->rd_att->constr && resultRelInfo->ri_RelationDesc->rd_att->constr->has_generated_stored) ExecComputeStoredGenerated(resultRelInfo, estate, myslot, CMD_INSERT); /* * If the target is a plain table, check the constraints of * the tuple. Since we check the constraints during tuple routing * we only need to check if we have additional constraints beyond * partitioning constraints. */ if (!buffer->can_skip_constraints) { Assert(resultRelInfo->ri_RangeTableIndex > 0 && estate->es_range_table); ExecConstraints(resultRelInfo, myslot, estate); } if (buffer->method == TS_CIM_SINGLE) { /* OK, store the tuple and create index entries for it */ table_tuple_insert(resultRelInfo->ri_RelationDesc, myslot, mycid, ti_options, bistate); if (resultRelInfo->ri_NumIndices > 0) recheckIndexes = ExecInsertIndexTuplesCompat(resultRelInfo, myslot, estate, false, false, NULL, NIL, false); /* AFTER ROW INSERT Triggers. We do not need to do this if we * are migrating data from an existing table in a call from * create_hypertable(). */ if (ccstate->cstate) ExecARInsertTriggers(estate, resultRelInfo, myslot, recheckIndexes, ccstate->cstate->transition_capture); } else if (buffer->method == TS_CIM_COMPRESSION) { ts_cm_functions->compressor_add_slot(buffer->compressor, buffer->bulk_writer, myslot); } else { /* * The slot previously might point into the per-tuple * context. For batching it needs to be longer lived. */ ExecMaterializeSlot(myslot); /* Add this tuple to the tuple buffer */ TSCopyMultiInsertInfoStore(&multiInsertInfo, resultRelInfo, buffer, myslot, ccstate->cstate); /* * If enough inserts have queued up, then flush all * buffers out to their tables. */ if (TSCopyMultiInsertInfoIsFull(&multiInsertInfo)) { ereport(DEBUG2, (errmsg("flush called with %d bytes and %d buffered tuples", multiInsertInfo.bufferedBytes, multiInsertInfo.bufferedTuples))); TSCopyMultiInsertInfoFlush(&multiInsertInfo, cis); } } list_free(recheckIndexes); /* * We count only tuples not suppressed by a BEFORE INSERT trigger; * this is the same definition used by execMain.c for counting * tuples inserted by an INSERT command. */ processed++; } resultRelInfo = saved_resultRelInfo; } /* Flush any remaining buffered tuples */ if (insertMethod != TS_CIM_SINGLE) TSCopyMultiInsertInfoFlushAndCleanup(&multiInsertInfo); /* Done, clean up */ if (ccstate->cstate && callback) error_context_stack = errcallback.previous; FreeBulkInsertState(bistate); MemoryContextSwitchTo(oldcontext); /* * Execute AFTER STATEMENT insertion triggers. * * We do not need to do this ccstate->cstate is NULL, which is the case * when migrating data from an existing table in a call from * create_hypertable(). */ if (ccstate->cstate) ExecASInsertTriggers(estate, resultRelInfo, ccstate->cstate->transition_capture); /* Handle queued AFTER triggers */ AfterTriggerEndQuery(estate); ExecResetTupleTable(estate->es_tupleTable, false); ExecCloseResultRelations(estate); ExecCloseRangeTableRelations(estate); /* * If we skipped writing WAL, then we need to sync the heap (but not * indexes since those use WAL anyway) */ if (!RelationNeedsWAL(ccstate->rel)) smgrimmedsync(RelationGetSmgr(ccstate->rel), MAIN_FORKNUM); return processed; } /* * CopyGetAttnums - build an integer list of attnums to be copied * * The input attnamelist is either the user-specified column list, * or NIL if there was none (in which case we want all the non-dropped * columns). * * rel can be NULL ... it's only used for error reports. */ static List * timescaledb_CopyGetAttnums(TupleDesc tupDesc, Relation rel, List *attnamelist) { List *attnums = NIL; if (attnamelist == NIL) { /* Generate default column list */ int attr_count = tupDesc->natts; int i; for (i = 0; i < attr_count; i++) { Form_pg_attribute attr = TupleDescAttr(tupDesc, i); if (attr->attisdropped) continue; attnums = lappend_int(attnums, i + 1); } } else { /* Validate the user-supplied list and extract attnums */ ListCell *l; foreach (l, attnamelist) { char *name = strVal(lfirst(l)); int attnum; int i; /* Lookup column name */ attnum = InvalidAttrNumber; for (i = 0; i < tupDesc->natts; i++) { Form_pg_attribute attr = TupleDescAttr(tupDesc, i); if (attr->attisdropped) continue; if (namestrcmp(&(attr->attname), name) == 0) { attnum = attr->attnum; break; } } if (attnum == InvalidAttrNumber) { if (rel != NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" of relation \"%s\" does not exist", name, RelationGetRelationName(rel)))); else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" does not exist", name))); } /* Check for duplicates */ if (list_member_int(attnums, attnum)) ereport(ERROR, (errcode(ERRCODE_DUPLICATE_COLUMN), errmsg("column \"%s\" specified more than once", name))); attnums = lappend_int(attnums, attnum); } } return attnums; } static void copy_constraints_and_check(ParseState *pstate, Relation rel, List *attnums) { ListCell *cur; char *xactReadOnly; ParseNamespaceItem *nsitem = addRangeTableEntryForRelation(pstate, rel, RowExclusiveLock, NULL, false, false); RangeTblEntry *rte = nsitem->p_rte; addNSItemToQuery(pstate, nsitem, true, true, true); #if PG16_LT rte->requiredPerms = ACL_INSERT; foreach (cur, attnums) { int attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber; rte->insertedCols = bms_add_member(rte->insertedCols, attno); } ExecCheckRTPerms(pstate->p_rtable, true); #else RTEPermissionInfo *perminfo = nsitem->p_perminfo; perminfo->requiredPerms = ACL_INSERT; foreach (cur, attnums) { int attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber; perminfo->insertedCols = bms_add_member(perminfo->insertedCols, attno); } ExecCheckPermissions(pstate->p_rtable, list_make1(perminfo), true); #endif /* * Permission check for row security policies. * * check_enable_rls will ereport(ERROR) if the user has requested * something invalid and will otherwise indicate if we should enable RLS * (returns RLS_ENABLED) or not for this COPY statement. * * If the relation has a row security policy and we are to apply it then * perform a "query" copy and allow the normal query processing to handle * the policies. * * If RLS is not enabled for this, then just fall through to the normal * non-filtering relation handling. */ if (check_enable_rls(rte->relid, InvalidOid, false) == RLS_ENABLED) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("COPY FROM not supported with row-level security"), errhint("Use INSERT statements instead."))); } /* check read-only transaction and parallel mode */ xactReadOnly = GetConfigOptionByName("transaction_read_only", NULL, false); if (strncmp(xactReadOnly, "on", sizeof("on")) == 0 && !rel->rd_islocaltemp) PreventCommandIfReadOnly("COPY FROM"); PreventCommandIfParallelMode("COPY FROM"); } void timescaledb_DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed, Hypertable *ht) { CopyChunkState *ccstate; CopyFromState cstate; bool pipe = (stmt->filename == NULL); Relation rel; List *attnums = NIL; Node *where_clause = NULL; ParseState *pstate; MemoryContext copycontext = NULL; /* Disallow COPY to/from file or program except to superusers. */ if (!pipe && !superuser()) { if (stmt->is_program) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be superuser to COPY to or from an external program"), errhint("Anyone can COPY to stdout or from stdin. " "psql's \\copy command also works for anyone."))); else ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be superuser to COPY to or from a file"), errhint("Anyone can COPY to stdout or from stdin. " "psql's \\copy command also works for anyone."))); } if (!stmt->is_from || NULL == stmt->relation) elog(ERROR, "timescale DoCopy should only be called for COPY FROM"); Assert(!stmt->query); /* * We never actually write to the main table, but we need RowExclusiveLock * to ensure no one else is. Because of the check above, we know that * `stmt->relation` is defined, so we are guaranteed to have a relation * available. */ rel = table_openrv(stmt->relation, RowExclusiveLock); attnums = timescaledb_CopyGetAttnums(RelationGetDescr(rel), rel, stmt->attlist); pstate = make_parsestate(NULL); pstate->p_sourcetext = queryString; copy_constraints_and_check(pstate, rel, attnums); cstate = BeginCopyFrom(pstate, rel, NULL, stmt->filename, stmt->is_program, NULL, stmt->attlist, stmt->options); if (stmt->whereClause) { where_clause = transformExpr(pstate, stmt->whereClause, EXPR_KIND_COPY_WHERE); where_clause = coerce_to_boolean(pstate, where_clause, "WHERE"); assign_expr_collations(pstate, where_clause); where_clause = eval_const_expressions(NULL, where_clause); where_clause = (Node *) canonicalize_qual((Expr *) where_clause, false); where_clause = (Node *) make_ands_implicit((Expr *) where_clause); } ccstate = copy_chunk_state_create(ht, rel, next_copy_from, cstate, NULL); ccstate->where_clause = where_clause; copycontext = cstate->copycontext; *processed = copyfrom(ccstate, pstate, ht, copycontext, CopyFromErrorCallback, cstate); copy_chunk_state_destroy(ccstate); EndCopyFrom(cstate); free_parsestate(pstate); table_close(rel, NoLock); } static bool next_copy_from_table_to_chunks(CopyChunkState *ccstate, ExprContext *econtext, Datum *values, bool *nulls) { TableScanDesc scandesc = ccstate->scandesc; HeapTuple tuple; Assert(scandesc != NULL); tuple = heap_getnext(scandesc, ForwardScanDirection); if (!HeapTupleIsValid(tuple)) return false; heap_deform_tuple(tuple, RelationGetDescr(ccstate->rel), values, nulls); return true; } /* * Move data from the given hypertable's main table to chunks. * * The data moving is essentially a COPY from the main table to the chunks * followed by a TRUNCATE on the main table. */ void timescaledb_move_from_table_to_chunks(Hypertable *ht, LOCKMODE lockmode) { Relation rel; CopyChunkState *ccstate; TableScanDesc scandesc; ParseState *pstate = make_parsestate(NULL); Snapshot snapshot; List *attnums = NIL; MemoryContext copycontext; RangeVar rv = { .schemaname = NameStr(ht->fd.schema_name), .relname = NameStr(ht->fd.table_name), .inh = false, /* Don't recurse */ }; TruncateStmt stmt = { .type = T_TruncateStmt, .relations = list_make1(&rv), .behavior = DROP_RESTRICT, }; int i; rel = table_open(ht->main_table_relid, lockmode); for (i = 0; i < rel->rd_att->natts; i++) { Form_pg_attribute attr = TupleDescAttr(rel->rd_att, i); attnums = lappend_int(attnums, attr->attnum); } copycontext = AllocSetContextCreate(CurrentMemoryContext, "COPY", ALLOCSET_DEFAULT_SIZES); copy_constraints_and_check(pstate, rel, attnums); snapshot = RegisterSnapshot(GetLatestSnapshot()); scandesc = table_beginscan(rel, snapshot, 0, NULL); ccstate = copy_chunk_state_create(ht, rel, next_copy_from_table_to_chunks, NULL, scandesc); copyfrom(ccstate, pstate, ht, copycontext, copy_table_to_chunk_error_callback, scandesc); copy_chunk_state_destroy(ccstate); table_endscan(scandesc); UnregisterSnapshot(snapshot); table_close(rel, lockmode); if (MemoryContextIsValid(copycontext)) MemoryContextDelete(copycontext); ExecuteTruncate(&stmt); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/copy.h�����������������������������������������������������������������������0000664�0000000�0000000�00000002030�15100345067�0015760�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/relscan.h> #include <access/xact.h> #include <commands/copy.h> #include <executor/executor.h> #include <nodes/parsenodes.h> #include <storage/lockdefs.h> #include "chunk_tuple_routing.h" typedef struct CopyChunkState CopyChunkState; typedef struct Hypertable Hypertable; typedef bool (*CopyFromFunc)(CopyChunkState *ccstate, ExprContext *econtext, Datum *values, bool *nulls); typedef struct CopyChunkState { Relation rel; EState *estate; ChunkTupleRouting *ctr; CopyFromFunc next_copy_from; CopyFromState cstate; TableScanDesc scandesc; Node *where_clause; } CopyChunkState; extern void timescaledb_DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed, Hypertable *ht); extern void timescaledb_move_from_table_to_chunks(Hypertable *ht, LOCKMODE lockmode); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/cross_module_fn.c������������������������������������������������������������0000664�0000000�0000000�00000036615�15100345067�0020202�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/amapi.h> #include <fmgr.h> #include <utils/lsyscache.h> #include <utils/timestamp.h> #include "bgw/job.h" #include "cross_module_fn.h" #include "export.h" #include "guc.h" #include "license_guc.h" #define CROSSMODULE_WRAPPER(func) \ TS_FUNCTION_INFO_V1(ts_##func); \ Datum ts_##func(PG_FUNCTION_ARGS) \ { \ PG_RETURN_DATUM(ts_cm_functions->func(fcinfo)); \ } /* bgw policy functions */ CROSSMODULE_WRAPPER(policy_compression_add); CROSSMODULE_WRAPPER(policy_compression_remove); CROSSMODULE_WRAPPER(policy_recompression_proc); CROSSMODULE_WRAPPER(policy_compression_check); CROSSMODULE_WRAPPER(policy_refresh_cagg_add); CROSSMODULE_WRAPPER(policy_refresh_cagg_proc); CROSSMODULE_WRAPPER(policy_refresh_cagg_check); CROSSMODULE_WRAPPER(policy_process_hyper_inval_remove); CROSSMODULE_WRAPPER(policy_process_hyper_inval_add); CROSSMODULE_WRAPPER(policy_process_hyper_inval_proc); CROSSMODULE_WRAPPER(policy_process_hyper_inval_check); CROSSMODULE_WRAPPER(policy_refresh_cagg_remove); CROSSMODULE_WRAPPER(policy_reorder_add); CROSSMODULE_WRAPPER(policy_reorder_proc); CROSSMODULE_WRAPPER(policy_reorder_check); CROSSMODULE_WRAPPER(policy_reorder_remove); CROSSMODULE_WRAPPER(policy_retention_add); CROSSMODULE_WRAPPER(policy_retention_proc); CROSSMODULE_WRAPPER(policy_retention_check); CROSSMODULE_WRAPPER(policy_retention_remove); CROSSMODULE_WRAPPER(job_add); CROSSMODULE_WRAPPER(job_delete); CROSSMODULE_WRAPPER(job_run); CROSSMODULE_WRAPPER(job_alter); CROSSMODULE_WRAPPER(job_alter_set_hypertable_id); CROSSMODULE_WRAPPER(reorder_chunk); CROSSMODULE_WRAPPER(move_chunk); CROSSMODULE_WRAPPER(policies_add); CROSSMODULE_WRAPPER(policies_remove); CROSSMODULE_WRAPPER(policies_remove_all); CROSSMODULE_WRAPPER(policies_alter); CROSSMODULE_WRAPPER(policies_show); /* partialize/finalize aggregate */ CROSSMODULE_WRAPPER(partialize_agg); CROSSMODULE_WRAPPER(finalize_agg_sfunc); CROSSMODULE_WRAPPER(finalize_agg_ffunc); /* compression functions */ CROSSMODULE_WRAPPER(compressed_data_decompress_forward); CROSSMODULE_WRAPPER(compressed_data_decompress_reverse); CROSSMODULE_WRAPPER(compressed_data_send); CROSSMODULE_WRAPPER(compressed_data_recv); CROSSMODULE_WRAPPER(compressed_data_in); CROSSMODULE_WRAPPER(compressed_data_out); CROSSMODULE_WRAPPER(compressed_data_info); CROSSMODULE_WRAPPER(compressed_data_has_nulls); CROSSMODULE_WRAPPER(deltadelta_compressor_append); CROSSMODULE_WRAPPER(deltadelta_compressor_finish); CROSSMODULE_WRAPPER(gorilla_compressor_append); CROSSMODULE_WRAPPER(gorilla_compressor_finish); CROSSMODULE_WRAPPER(dictionary_compressor_append); CROSSMODULE_WRAPPER(dictionary_compressor_finish); CROSSMODULE_WRAPPER(array_compressor_append); CROSSMODULE_WRAPPER(array_compressor_finish); CROSSMODULE_WRAPPER(bool_compressor_append); CROSSMODULE_WRAPPER(bool_compressor_finish); CROSSMODULE_WRAPPER(uuid_compressor_append); CROSSMODULE_WRAPPER(uuid_compressor_finish); CROSSMODULE_WRAPPER(create_compressed_chunk); CROSSMODULE_WRAPPER(compress_chunk); CROSSMODULE_WRAPPER(decompress_chunk); CROSSMODULE_WRAPPER(bloom1_contains); /* continuous aggregate */ CROSSMODULE_WRAPPER(continuous_agg_refresh); CROSSMODULE_WRAPPER(continuous_agg_process_hypertable_invalidations); CROSSMODULE_WRAPPER(continuous_agg_validate_query); CROSSMODULE_WRAPPER(continuous_agg_get_bucket_function); CROSSMODULE_WRAPPER(continuous_agg_get_bucket_function_info); CROSSMODULE_WRAPPER(continuous_agg_migrate_to_time_bucket); CROSSMODULE_WRAPPER(continuous_agg_read_invalidation_record); CROSSMODULE_WRAPPER(cagg_try_repair); CROSSMODULE_WRAPPER(chunk_freeze_chunk); CROSSMODULE_WRAPPER(chunk_unfreeze_chunk); CROSSMODULE_WRAPPER(recompress_chunk_segmentwise); CROSSMODULE_WRAPPER(get_compressed_chunk_index_for_recompression); CROSSMODULE_WRAPPER(merge_chunks); CROSSMODULE_WRAPPER(split_chunk); CROSSMODULE_WRAPPER(detach_chunk); CROSSMODULE_WRAPPER(attach_chunk); /* * casting a function pointer to a pointer of another type is undefined * behavior, so we need one of these for every function type we have */ static void error_no_default_fn_community(void) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("functionality not supported under the current \"%s\" license. Learn more at " "https://tsdb.co/pdbir1r3", ts_guc_license), errhint("To access all features and the best time-series experience, try out " "Timescale Cloud."))); } static bool error_no_default_fn_bool_void_community(void) { error_no_default_fn_community(); pg_unreachable(); } static bool job_execute_default_fn(BgwJob *job) { error_no_default_fn_community(); pg_unreachable(); } static void tsl_postprocess_plan_stub(PlannedStmt *stmt) { } static bool process_compress_table_default(Hypertable *ht, WithClauseResult *with_clause_options) { error_no_default_fn_community(); pg_unreachable(); } static void columnstore_setup_default(Hypertable *ht, WithClauseResult *with_clause_options) { error_no_default_fn_community(); pg_unreachable(); } static Datum error_no_default_fn_pg_community(PG_FUNCTION_ARGS) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function \"%s\" is not supported under the current \"%s\" license", get_func_name(fcinfo->flinfo->fn_oid), ts_guc_license), errhint("Upgrade your license to 'timescale' to use this free community feature."))); pg_unreachable(); } static void error_no_default_fn_chunk_insert_state_community(ChunkInsertState *cis, TupleTableSlot *slot) { error_no_default_fn_community(); pg_unreachable(); } /* * TSL library is not loaded by the replication worker for some reason, * so a call to `compressed_data_in` and `compressed_data_out` functions would * produce a misleading error saying that your license is "timescale" and you * should upgrade to "timescale" license, even if you have already upgraded. * * As a workaround, we try to load the TSL module it in this function. * It will still error out in the "apache" version */ static Datum process_compressed_data_in(PG_FUNCTION_ARGS) { ts_license_enable_module_loading(); if (ts_cm_functions->compressed_data_in != process_compressed_data_in) return ts_cm_functions->compressed_data_in(fcinfo); error_no_default_fn_pg_community(fcinfo); pg_unreachable(); } static Datum process_compressed_data_out(PG_FUNCTION_ARGS) { ts_license_enable_module_loading(); if (ts_cm_functions->compressed_data_out != process_compressed_data_out) return ts_cm_functions->compressed_data_out(fcinfo); error_no_default_fn_pg_community(fcinfo); pg_unreachable(); } /* * This function ensures that the TSL library is loaded and the call to * post_update_cagg_try_repair is dispatched to the correct * function. * * The TSL library might not be loaded when post_update_cagg_try_repair is * called during a database upgrade, resulting in an error message about * improper licensing: * * "[..] is not supported under the current "timescale" license * INT: Upgrade your license to 'timescale'"" * * See also the comment about this problem in the function * process_compressed_data_in. */ static Datum process_cagg_try_repair(PG_FUNCTION_ARGS) { ts_license_enable_module_loading(); if (ts_cm_functions->cagg_try_repair != process_cagg_try_repair) return ts_cm_functions->cagg_try_repair(fcinfo); error_no_default_fn_pg_community(fcinfo); pg_unreachable(); } static DDLResult process_cagg_viewstmt_default(Node *stmt, const char *query_string, void *pstmt, WithClauseResult *with_clause_options) { return error_no_default_fn_bool_void_community(); } static void continuous_agg_update_options_default(ContinuousAgg *cagg, WithClauseResult *with_clause_options) { error_no_default_fn_community(); pg_unreachable(); } static void continuous_agg_invalidate_raw_ht_all_default(const Hypertable *raw_ht, int64 start, int64 end) { error_no_default_fn_community(); pg_unreachable(); } static void continuous_agg_invalidate_mat_ht_all_default(const Hypertable *raw_ht, const Hypertable *mat_ht, int64 start, int64 end) { error_no_default_fn_community(); pg_unreachable(); } static void continuous_agg_dml_invalidate_default(int32 hypertable_id, Relation chunk_rel, HeapTuple chunk_tuple, HeapTuple chunk_newtuple, bool update) { error_no_default_fn_community(); pg_unreachable(); } TS_FUNCTION_INFO_V1(ts_tsl_loaded); PGDLLEXPORT Datum ts_tsl_loaded(PG_FUNCTION_ARGS) { PG_RETURN_BOOL(ts_cm_functions != &ts_cm_functions_default); } static void preprocess_query_tsl_default_fn_community(Query *parse, int *cursor_opts) { /* No op in community licensed code */ } static PGFunction bloom1_get_hash_function_default(Oid type, FmgrInfo **finfo) { error_no_default_fn_community(); pg_unreachable(); } /* * Define cross-module functions' default values: * If the submodule isn't activated, using one of the cm functions will throw an * exception. */ TSDLLEXPORT CrossModuleFunctions ts_cm_functions_default = { .create_upper_paths_hook = NULL, .set_rel_pathlist_dml = NULL, .set_rel_pathlist_query = NULL, .process_altertable_cmd = NULL, .process_rename_cmd = NULL, /* gapfill */ .gapfill_marker = error_no_default_fn_pg_community, .gapfill_int16_time_bucket = error_no_default_fn_pg_community, .gapfill_int32_time_bucket = error_no_default_fn_pg_community, .gapfill_int64_time_bucket = error_no_default_fn_pg_community, .gapfill_date_time_bucket = error_no_default_fn_pg_community, .gapfill_timestamp_time_bucket = error_no_default_fn_pg_community, .gapfill_timestamptz_time_bucket = error_no_default_fn_pg_community, .gapfill_timestamptz_timezone_time_bucket = error_no_default_fn_pg_community, /* bgw policies */ .policy_compression_add = error_no_default_fn_pg_community, .policy_compression_remove = error_no_default_fn_pg_community, .policy_recompression_proc = error_no_default_fn_pg_community, .policy_compression_check = error_no_default_fn_pg_community, .policy_refresh_cagg_add = error_no_default_fn_pg_community, .policy_refresh_cagg_proc = error_no_default_fn_pg_community, .policy_refresh_cagg_check = error_no_default_fn_pg_community, .policy_refresh_cagg_remove = error_no_default_fn_pg_community, .policy_process_hyper_inval_add = error_no_default_fn_pg_community, .policy_process_hyper_inval_proc = error_no_default_fn_pg_community, .policy_process_hyper_inval_check = error_no_default_fn_pg_community, .policy_process_hyper_inval_remove = error_no_default_fn_pg_community, .policy_reorder_add = error_no_default_fn_pg_community, .policy_reorder_proc = error_no_default_fn_pg_community, .policy_reorder_check = error_no_default_fn_pg_community, .policy_reorder_remove = error_no_default_fn_pg_community, .policy_retention_add = error_no_default_fn_pg_community, .policy_retention_proc = error_no_default_fn_pg_community, .policy_retention_check = error_no_default_fn_pg_community, .policy_retention_remove = error_no_default_fn_pg_community, .job_add = error_no_default_fn_pg_community, .job_alter = error_no_default_fn_pg_community, .job_alter_set_hypertable_id = error_no_default_fn_pg_community, .job_delete = error_no_default_fn_pg_community, .job_run = error_no_default_fn_pg_community, .job_execute = job_execute_default_fn, .reorder_chunk = error_no_default_fn_pg_community, .move_chunk = error_no_default_fn_pg_community, .policies_add = error_no_default_fn_pg_community, .policies_remove = error_no_default_fn_pg_community, .policies_remove_all = error_no_default_fn_pg_community, .policies_alter = error_no_default_fn_pg_community, .policies_show = error_no_default_fn_pg_community, .tsl_postprocess_plan = tsl_postprocess_plan_stub, .partialize_agg = error_no_default_fn_pg_community, .finalize_agg_sfunc = error_no_default_fn_pg_community, .finalize_agg_ffunc = error_no_default_fn_pg_community, .process_cagg_viewstmt = process_cagg_viewstmt_default, .continuous_agg_refresh = error_no_default_fn_pg_community, .continuous_agg_process_hypertable_invalidations = error_no_default_fn_pg_community, .continuous_agg_invalidate_raw_ht = continuous_agg_invalidate_raw_ht_all_default, .continuous_agg_invalidate_mat_ht = continuous_agg_invalidate_mat_ht_all_default, .continuous_agg_dml_invalidate = continuous_agg_dml_invalidate_default, .continuous_agg_update_options = continuous_agg_update_options_default, .continuous_agg_validate_query = error_no_default_fn_pg_community, .continuous_agg_get_bucket_function = error_no_default_fn_pg_community, .continuous_agg_get_bucket_function_info = error_no_default_fn_pg_community, .continuous_agg_migrate_to_time_bucket = error_no_default_fn_pg_community, .continuous_agg_read_invalidation_record = error_no_default_fn_pg_community, .cagg_try_repair = process_cagg_try_repair, /* compression */ .compressed_data_send = error_no_default_fn_pg_community, .compressed_data_recv = error_no_default_fn_pg_community, .compressed_data_in = process_compressed_data_in, .compressed_data_out = process_compressed_data_out, .process_compress_table = process_compress_table_default, .create_compressed_chunk = error_no_default_fn_pg_community, .compress_chunk = error_no_default_fn_pg_community, .decompress_chunk = error_no_default_fn_pg_community, .compressed_data_decompress_forward = error_no_default_fn_pg_community, .compressed_data_decompress_reverse = error_no_default_fn_pg_community, .deltadelta_compressor_append = error_no_default_fn_pg_community, .deltadelta_compressor_finish = error_no_default_fn_pg_community, .gorilla_compressor_append = error_no_default_fn_pg_community, .gorilla_compressor_finish = error_no_default_fn_pg_community, .dictionary_compressor_append = error_no_default_fn_pg_community, .dictionary_compressor_finish = error_no_default_fn_pg_community, .array_compressor_append = error_no_default_fn_pg_community, .array_compressor_finish = error_no_default_fn_pg_community, .bool_compressor_append = error_no_default_fn_pg_community, .bool_compressor_finish = error_no_default_fn_pg_community, .uuid_compressor_append = error_no_default_fn_pg_community, .uuid_compressor_finish = error_no_default_fn_pg_community, .bloom1_contains = error_no_default_fn_pg_community, .bloom1_get_hash_function = bloom1_get_hash_function_default, .decompress_batches_for_insert = error_no_default_fn_chunk_insert_state_community, .init_decompress_state_for_insert = error_no_default_fn_chunk_insert_state_community, .columnstore_setup = columnstore_setup_default, .show_chunk = error_no_default_fn_pg_community, .create_chunk = error_no_default_fn_pg_community, .chunk_freeze_chunk = error_no_default_fn_pg_community, .chunk_unfreeze_chunk = error_no_default_fn_pg_community, .recompress_chunk_segmentwise = error_no_default_fn_pg_community, .get_compressed_chunk_index_for_recompression = error_no_default_fn_pg_community, .preprocess_query_tsl = preprocess_query_tsl_default_fn_community, .merge_chunks = error_no_default_fn_pg_community, .split_chunk = error_no_default_fn_pg_community, .detach_chunk = error_no_default_fn_pg_community, .attach_chunk = error_no_default_fn_pg_community, }; TSDLLEXPORT CrossModuleFunctions *ts_cm_functions = &ts_cm_functions_default; �������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/cross_module_fn.h������������������������������������������������������������0000664�0000000�0000000�00000016017�15100345067�0020201�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <commands/event_trigger.h> #include <fmgr.h> #include <optimizer/planner.h> #include <utils/array.h> #include <utils/jsonb.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "bgw/job.h" #include "export.h" #include "planner/planner.h" #include "process_utility.h" #include "ts_catalog/continuous_agg.h" #include "with_clause/with_clause_parser.h" /* * To define a cross-module function add it to this struct, add a default * version in to ts_cm_functions_default cross_module_fn.c, and the overridden * version to tsl_cm_functions tsl/src/init.c. * This will allow the function to be called from this codebase as * ts_cm_functions-><function name> */ typedef struct JsonbParseState JsonbParseState; typedef struct Hypertable Hypertable; typedef struct Chunk Chunk; typedef struct ChunkInsertState ChunkInsertState; typedef struct CopyChunkState CopyChunkState; typedef struct ModifyHypertableState ModifyHypertableState; typedef struct RowCompressor RowCompressor; typedef struct BulkWriter BulkWriter; typedef struct CrossModuleFunctions { PGFunction policy_compression_add; PGFunction policy_compression_remove; PGFunction policy_recompression_proc; PGFunction policy_compression_check; PGFunction policy_refresh_cagg_add; PGFunction policy_refresh_cagg_proc; PGFunction policy_refresh_cagg_check; PGFunction policy_refresh_cagg_remove; PGFunction policy_process_hyper_inval_add; PGFunction policy_process_hyper_inval_proc; PGFunction policy_process_hyper_inval_check; PGFunction policy_process_hyper_inval_remove; PGFunction policy_reorder_add; PGFunction policy_reorder_proc; PGFunction policy_reorder_check; PGFunction policy_reorder_remove; PGFunction policy_retention_add; PGFunction policy_retention_proc; PGFunction policy_retention_check; PGFunction policy_retention_remove; PGFunction policies_add; PGFunction policies_remove; PGFunction policies_remove_all; PGFunction policies_alter; PGFunction policies_show; PGFunction job_add; PGFunction job_alter; PGFunction job_alter_set_hypertable_id; PGFunction job_delete; PGFunction job_run; bool (*job_execute)(BgwJob *job); void (*create_upper_paths_hook)(PlannerInfo *, UpperRelationKind, RelOptInfo *, RelOptInfo *, TsRelType input_reltype, Hypertable *ht, void *extra); void (*set_rel_pathlist_dml)(PlannerInfo *, RelOptInfo *, Index, RangeTblEntry *, Hypertable *); void (*set_rel_pathlist_query)(PlannerInfo *, RelOptInfo *, Index, RangeTblEntry *, Hypertable *); /* gapfill */ PGFunction gapfill_marker; PGFunction gapfill_int16_time_bucket; PGFunction gapfill_int32_time_bucket; PGFunction gapfill_int64_time_bucket; PGFunction gapfill_date_time_bucket; PGFunction gapfill_timestamp_time_bucket; PGFunction gapfill_timestamptz_time_bucket; PGFunction gapfill_timestamptz_timezone_time_bucket; PGFunction reorder_chunk; PGFunction move_chunk; /* Vectorized queries */ void (*tsl_postprocess_plan)(PlannedStmt *stmt); /* Continuous Aggregates */ PGFunction partialize_agg; PGFunction finalize_agg_sfunc; PGFunction finalize_agg_ffunc; DDLResult (*process_cagg_viewstmt)(Node *stmt, const char *query_string, void *pstmt, WithClauseResult *with_clause_options); PGFunction continuous_agg_refresh; PGFunction continuous_agg_process_hypertable_invalidations; void (*continuous_agg_invalidate_raw_ht)(const Hypertable *raw_ht, int64 start, int64 end); void (*continuous_agg_invalidate_mat_ht)(const Hypertable *raw_ht, const Hypertable *mat_ht, int64 start, int64 end); void (*continuous_agg_dml_invalidate)(int32 hypertable_id, Relation chunk_rel, HeapTuple chunk_tuple, HeapTuple chunk_newtuple, bool update); void (*continuous_agg_update_options)(ContinuousAgg *cagg, WithClauseResult *with_clause_options); PGFunction continuous_agg_validate_query; PGFunction continuous_agg_get_bucket_function; PGFunction continuous_agg_get_bucket_function_info; PGFunction continuous_agg_migrate_to_time_bucket; PGFunction cagg_try_repair; PGFunction continuous_agg_read_invalidation_record; PGFunction compressed_data_send; PGFunction compressed_data_recv; PGFunction compressed_data_in; PGFunction compressed_data_out; PGFunction compressed_data_info; PGFunction compressed_data_has_nulls; bool (*process_compress_table)(Hypertable *ht, WithClauseResult *with_clause_options); void (*process_altertable_cmd)(Hypertable *ht, const AlterTableCmd *cmd); void (*process_rename_cmd)(Oid relid, Cache *hcache, const RenameStmt *stmt); PGFunction create_compressed_chunk; PGFunction compress_chunk; PGFunction decompress_chunk; void (*decompress_batches_for_insert)(ChunkInsertState *state, TupleTableSlot *slot); void (*init_decompress_state_for_insert)(ChunkInsertState *state, TupleTableSlot *slot); bool (*decompress_target_segments)(ModifyHypertableState *ht_state); void (*columnstore_setup)(Hypertable *ht, WithClauseResult *with_clause_options); RowCompressor *(*compressor_init)(Relation in_rel, BulkWriter **bulk_writer, bool sort); void (*compressor_add_slot)(RowCompressor *compressor, BulkWriter *bulk_writer, TupleTableSlot *slot); void (*compressor_flush)(RowCompressor *compressor, BulkWriter *bulk_writer); void (*compressor_free)(RowCompressor *compressor, BulkWriter *bulk_writer); Chunk *(*compression_chunk_create)(Hypertable *ht, Chunk *src_chunk); /* The compression functions below are not installed in SQL as part of create extension; * They are installed and tested during testing scripts. They are exposed in cross-module * functions because they may be very useful for debugging customer problems if the sql * stub is installed on the customer's machine. */ PGFunction compressed_data_decompress_forward; PGFunction compressed_data_decompress_reverse; PGFunction deltadelta_compressor_append; PGFunction deltadelta_compressor_finish; PGFunction gorilla_compressor_append; PGFunction gorilla_compressor_finish; PGFunction dictionary_compressor_append; PGFunction dictionary_compressor_finish; PGFunction array_compressor_append; PGFunction array_compressor_finish; PGFunction bool_compressor_append; PGFunction bool_compressor_finish; PGFunction uuid_compressor_append; PGFunction uuid_compressor_finish; PGFunction bloom1_contains; PGFunction (*bloom1_get_hash_function)(Oid type, FmgrInfo **finfo); PGFunction create_chunk; PGFunction show_chunk; PGFunction chunk_freeze_chunk; PGFunction chunk_unfreeze_chunk; PGFunction recompress_chunk_segmentwise; PGFunction get_compressed_chunk_index_for_recompression; void (*preprocess_query_tsl)(Query *parse, int *cursor_opts); PGFunction merge_chunks; PGFunction split_chunk; PGFunction detach_chunk; PGFunction attach_chunk; } CrossModuleFunctions; extern TSDLLEXPORT CrossModuleFunctions *ts_cm_functions; extern TSDLLEXPORT CrossModuleFunctions ts_cm_functions_default; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/custom_type_cache.c����������������������������������������������������������0000664�0000000�0000000�00000002577�15100345067�0020517�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <utils/syscache.h> #include "custom_type_cache.h" #include "extension_constants.h" #include "ts_catalog/catalog.h" /* Information about functions that we put in the cache */ static CustomTypeInfo typeinfo[_CUSTOM_TYPE_MAX_INDEX] = { [CUSTOM_TYPE_COMPRESSED_DATA] = { .schema_name = INTERNAL_SCHEMA_NAME, .type_name = "compressed_data", .type_oid = InvalidOid, }, [CUSTOM_TYPE_BLOOM1] = { .schema_name = INTERNAL_SCHEMA_NAME, .type_name = "bloom1", .type_oid = InvalidOid, } }; extern CustomTypeInfo * ts_custom_type_cache_get(CustomType type) { CustomTypeInfo *tinfo; if (type >= _CUSTOM_TYPE_MAX_INDEX) elog(ERROR, "invalid timescaledb type %d", type); tinfo = &typeinfo[type]; if (!OidIsValid(tinfo->type_oid)) { Oid schema_oid = LookupExplicitNamespace(tinfo->schema_name, false); Oid type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid, CStringGetDatum(tinfo->type_name), ObjectIdGetDatum(schema_oid)); if (!OidIsValid(type_oid)) elog(ERROR, "unknown timescaledb type %s", tinfo->type_name); tinfo->type_oid = type_oid; } return tinfo; } ���������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/custom_type_cache.h����������������������������������������������������������0000664�0000000�0000000�00000001070�15100345067�0020507�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "compat/compat.h" #include <postgres.h> typedef enum CustomType { CUSTOM_TYPE_COMPRESSED_DATA = 0, CUSTOM_TYPE_BLOOM1, _CUSTOM_TYPE_MAX_INDEX } CustomType; typedef struct CustomTypeInfo { const char *schema_name; const char *type_name; Oid type_oid; } CustomTypeInfo; extern TSDLLEXPORT CustomTypeInfo *ts_custom_type_cache_get(CustomType type); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/debug_assert.h���������������������������������������������������������������0000664�0000000�0000000�00000003725�15100345067�0017471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> /* * Macro that expands to an assert in debug builds and to an ereport in * release builds. * * This allow you to start the debugger if internal assumptions are violated * in debug builds, but a release build will just print an error and abort the * transaction but and not crash the server. * * The error code is automatically set to ERRCODE_INTERNAL_ERROR and the error * details contains the assertion that failed in text format. * * The macro should be used for checks that are not expected to occur in * normal execution, or which can occur in odd corner-cases for conditions out * of our control (e.g., unexpected changes to the metadata) so if you have a * test that trigger the error, this macro should not be used. */ #define Ensure(COND, FMT, ...) \ do \ { \ if (unlikely(!(COND))) \ { \ Assert(false); \ ereport(ERROR, \ (errcode(ERRCODE_INTERNAL_ERROR), \ errdetail("Assertion '" #COND "' failed."), \ errmsg(FMT, ##__VA_ARGS__))); \ } \ } while (0) �������������������������������������������timescaledb-2.23.0/src/debug_point.c����������������������������������������������������������������0000664�0000000�0000000�00000016514�15100345067�0017314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include "debug_point.h" #include <postgres.h> #include <fmgr.h> #include <access/hash.h> #include <access/xact.h> #include <miscadmin.h> #include <storage/ipc.h> #include <storage/lock.h> #include <utils/builtins.h> #include "annotations.h" #include "export.h" TS_FUNCTION_INFO_V1(ts_debug_point_enable); TS_FUNCTION_INFO_V1(ts_debug_point_release); TS_FUNCTION_INFO_V1(ts_debug_point_id); /* * Debug points only exist in debug code and are intended to allow * more controlled testing of the code. * * Debug points can be used as a wait point (1) or as a way to * introduce error injections (2). * * (1) When used as wait points, execution will halt until the debug points are * explicitly released. * * When waiting on a debug point, there is an attempt to take a shared lock on it. * If the debug point is enabled by locking using an exclusive * lock, this will block all waiters. Once the exclusive lock is released, all * waiters will be able to proceed. * * (2) is similar to (1), but, instead of waiting for the debug point to be * released, it will generate an error immediately. * */ /* Tag for debug points. * * Each debug point is identified by a string that is hashed to a 8-byte * number and used with the normal advisory locks available in PostgreSQL. */ typedef struct DebugPoint { const char *name; LOCKTAG tag; } DebugPoint; static uint64 debug_point_name_to_id(const char *name) { return DatumGetUInt32(hash_any((const unsigned char *) name, strlen(name))); } static void debug_point_init(DebugPoint *point, const char *name) { /* Use 64-bit hashing to get two independent 32-bit hashes */ uint64 hash = debug_point_name_to_id(name); SET_LOCKTAG_ADVISORY(point->tag, MyDatabaseId, (uint32) (hash >> 32), (uint32) hash, 1); point->name = pstrdup(name); ereport(DEBUG3, (errmsg("initializing debug point '%s' to use " UINT64_FORMAT, point->name, hash))); } static void debug_point_enable(const DebugPoint *point) { LockAcquireResult lock_acquire_result; ereport(DEBUG1, (errmsg("enabling debug point \"%s\"", point->name))); lock_acquire_result = LockAcquire(&point->tag, ExclusiveLock, true, true); switch (lock_acquire_result) { case LOCKACQUIRE_ALREADY_HELD: case LOCKACQUIRE_ALREADY_CLEAR: LockRelease(&point->tag, ExclusiveLock, true); TS_FALLTHROUGH; case LOCKACQUIRE_NOT_AVAIL: ereport(ERROR, (errmsg("debug point \"%s\" already enabled", point->name))); break; case LOCKACQUIRE_OK: break; } } static void debug_point_release(const DebugPoint *point) { ereport(DEBUG1, (errmsg("releasing debug point \"%s\"", point->name))); if (!LockRelease(&point->tag, ExclusiveLock, true)) ereport(ERROR, (errmsg("cannot release debug point \"%s\"", point->name))); } /* * Enable a debug point to block when being reached. * * This function will always succeed since we will not lock the debug point if * it is already locked. A notice will be printed if the debug point is already * enabled. */ Datum ts_debug_point_enable(PG_FUNCTION_ARGS) { text *name = PG_GETARG_TEXT_PP(0); DebugPoint point; if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no name provided"))); debug_point_init(&point, text_to_cstring(name)); debug_point_enable(&point); PG_RETURN_VOID(); } /* * Release a debug point allowing execution to proceed. */ Datum ts_debug_point_release(PG_FUNCTION_ARGS) { text *name = PG_GETARG_TEXT_PP(0); DebugPoint point; if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no name provided"))); debug_point_init(&point, text_to_cstring(name)); debug_point_release(&point); PG_RETURN_VOID(); } /* * Get the debug point identifier from the name. */ Datum ts_debug_point_id(PG_FUNCTION_ARGS) { text *name = PG_GETARG_TEXT_PP(0); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no name provided"))); PG_RETURN_UINT64(debug_point_name_to_id(text_to_cstring(name))); } /* * Wait for the debug point to be released. * * This is handled by first trying to get a shared lock, which will not block * other sessions that try to grab the same lock but will block if an * exclusive lock is already taken, and then release the lock immediately * after. * * This function can decide to block while taking the shared lock or it can * have a retry loop to take the share lock. This retry loop option is useful * in cases where this function gets called from deep down inside a transaction * where interrupts are not being served currently. */ void ts_debug_point_wait(const char *name, bool blocking) { DebugPoint point; LockAcquireResult lock_acquire_result pg_attribute_unused(); bool lock_release_result pg_attribute_unused(); /* Ensure that we are in a transaction before trying for locks */ if (!IsTransactionState()) return; debug_point_init(&point, name); ereport(DEBUG3, (errmsg("waiting on debug point '%s'", point.name))); if (blocking) lock_acquire_result = LockAcquire(&point.tag, ShareLock, true, false); else { /* * Trying to wait indefinitely here could lead to hangs. The current * behavior is to retry for retry_count and return with a warning * if that's crossed. * * If required, in future, we could take an additional option to decide * if the caller wants to retry indefinitely or return with a warning. * But the current behavior based on the "blocking" argument is ok for * now. */ unsigned int retry_count = 1000; /* try to acquire the lock without waiting. */ do { /* try to acquire the lock without waiting. */ lock_acquire_result = LockAcquire(&point.tag, ShareLock, true, true); if (lock_acquire_result == LOCKACQUIRE_OK) break; /* don't dare to take a lock when the proc is exiting! */ if (proc_exit_inprogress || ProcDiePending) return; if (retry_count == 0) { elog(WARNING, "timeout while acquiring debug point lock"); return; } retry_count--; /* retry after some time */ pg_usleep(100L); } while (lock_acquire_result == LOCKACQUIRE_NOT_AVAIL); } Assert(lock_acquire_result == LOCKACQUIRE_OK); lock_release_result = LockRelease(&point.tag, ShareLock, true); Assert(lock_release_result); ereport(DEBUG3, (errmsg("proceeding after debug point '%s'", point.name))); } /* * Produce an error in case if the debug point is enabled. * * The idea is to enable the debug point separately first which * acquires a ShareLock on this tag. With the debug point enabled, this function * when invoked will not get the exclusive lock and will be able to raise * the error as desired. */ void ts_debug_point_raise_error_if_enabled(const char *name) { DebugPoint point; LockAcquireResult lock_acquire_result; debug_point_init(&point, name); lock_acquire_result = LockAcquire(&point.tag, ExclusiveLock, true, true); switch (lock_acquire_result) { case LOCKACQUIRE_OK: case LOCKACQUIRE_ALREADY_HELD: case LOCKACQUIRE_ALREADY_CLEAR: /* Release/decrement lock count */ LockRelease(&point.tag, ExclusiveLock, true); if (lock_acquire_result == LOCKACQUIRE_OK) return; break; case LOCKACQUIRE_NOT_AVAIL: break; } ereport(ERROR, (errmsg("error injected at debug point '%s'", point.name))); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/debug_point.h����������������������������������������������������������������0000664�0000000�0000000�00000001366�15100345067�0017320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "export.h" extern TSDLLEXPORT void ts_debug_point_wait(const char *name, bool blocking); extern TSDLLEXPORT void ts_debug_point_raise_error_if_enabled(const char *name); #ifdef TS_DEBUG #define DEBUG_WAITPOINT(NAME) ts_debug_point_wait((NAME), true) #define DEBUG_RETRY_WAITPOINT(NAME) ts_debug_point_wait((NAME), false) #define DEBUG_ERROR_INJECTION(NAME) ts_debug_point_raise_error_if_enabled((NAME)) #else #define DEBUG_WAITPOINT(NAME) #define DEBUG_RETRY_WAITPOINT(NAME) #define DEBUG_ERROR_INJECTION(NAME) #endif ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/dimension.c������������������������������������������������������������������0000664�0000000�0000000�00000160033�15100345067�0016776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/relscan.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <commands/tablecmds.h> #include <funcapi.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "cross_module_fn.h" #include "debug_point.h" #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "error_utils.h" #include "errors.h" #include "hypertable.h" #include "hypertable_cache.h" #include "indexing.h" #include "partitioning.h" #include "scanner.h" #include "time_utils.h" #include "ts_catalog/catalog.h" #include "utils.h" /* add_dimension record attribute numbers */ enum Anum_add_dimension { Anum_add_dimension_id = 1, Anum_add_dimension_schema_name, Anum_add_dimension_table_name, Anum_add_dimension_column_name, Anum_add_dimension_created, _Anum_add_dimension_max, }; #define Natts_add_dimension (_Anum_add_dimension_max - 1) /* * Generic add dimension attributes */ enum Anum_generic_add_dimension { Anum_generic_add_dimension_id = 1, Anum_generic_add_dimension_created, _Anum_generic_add_dimension_max, }; #define Natts_generic_add_dimension (_Anum_generic_add_dimension_max - 1) static int cmp_dimension_id(const void *left, const void *right) { const Dimension *diml = (Dimension *) left; const Dimension *dimr = (Dimension *) right; if (diml->fd.id < dimr->fd.id) return -1; if (diml->fd.id > dimr->fd.id) return 1; return 0; } TS_FUNCTION_INFO_V1(ts_hash_dimension); TS_FUNCTION_INFO_V1(ts_range_dimension); PG_FUNCTION_INFO_V1(ts_dimension_info_in); PG_FUNCTION_INFO_V1(ts_dimension_info_out); const Dimension * ts_hyperspace_get_dimension_by_id(const Hyperspace *hs, int32 id) { Dimension dim = { .fd.id = id, }; return bsearch(&dim, hs->dimensions, hs->num_dimensions, sizeof(Dimension), cmp_dimension_id); } Dimension * ts_hyperspace_get_mutable_dimension_by_name(Hyperspace *hs, DimensionType type, const char *name) { int i; for (i = 0; i < hs->num_dimensions; i++) { Dimension *dim = &hs->dimensions[i]; if ((type == DIMENSION_TYPE_ANY || dim->type == type) && namestrcmp(&dim->fd.column_name, name) == 0) return dim; } return NULL; } const Dimension * ts_hyperspace_get_dimension_by_name(const Hyperspace *hs, DimensionType type, const char *name) { return ts_hyperspace_get_mutable_dimension_by_name((Hyperspace *) hs, type, name); } Dimension * ts_hyperspace_get_mutable_dimension(Hyperspace *hs, DimensionType type, Index n) { int i; for (i = 0; i < hs->num_dimensions; i++) { if (type == DIMENSION_TYPE_ANY || hs->dimensions[i].type == type) { if (n == 0) return &hs->dimensions[i]; n--; } } return NULL; } const Dimension * ts_hyperspace_get_dimension(const Hyperspace *hs, DimensionType type, Index n) { return ts_hyperspace_get_mutable_dimension((Hyperspace *) hs, type, n); } static int hyperspace_get_num_dimensions_by_type(Hyperspace *hs, DimensionType type) { int i; int n = 0; for (i = 0; i < hs->num_dimensions; i++) { if (type == DIMENSION_TYPE_ANY || hs->dimensions[i].type == type) n++; } return n; } static inline DimensionType dimension_type(TupleInfo *ti) { if (slot_attisnull(ti->slot, Anum_dimension_interval_length) && !slot_attisnull(ti->slot, Anum_dimension_num_slices)) return DIMENSION_TYPE_CLOSED; if (!slot_attisnull(ti->slot, Anum_dimension_interval_length) && slot_attisnull(ti->slot, Anum_dimension_num_slices)) return DIMENSION_TYPE_OPEN; elog(ERROR, "invalid partitioning dimension"); /* suppress compiler warning on MSVC */ return DIMENSION_TYPE_ANY; } static void dimension_fill_in_from_tuple(Dimension *d, TupleInfo *ti, Oid main_table_relid) { Datum values[Natts_dimension]; bool isnull[Natts_dimension]; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); /* * With need to use heap_deform_tuple() rather than GETSTRUCT(), since * optional values may be omitted from the tuple. */ heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, isnull); d->type = dimension_type(ti); d->fd.id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_dimension_id)]); d->fd.hypertable_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_dimension_hypertable_id)]); d->fd.aligned = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_dimension_aligned)]); d->fd.column_type = DatumGetObjectId(values[AttrNumberGetAttrOffset(Anum_dimension_column_type)]); namestrcpy(&d->fd.column_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_dimension_column_name)])); if (!isnull[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] && !isnull[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func)]) { MemoryContext old; d->fd.num_slices = DatumGetInt16(values[AttrNumberGetAttrOffset(Anum_dimension_num_slices)]); namestrcpy(&d->fd.partitioning_func_schema, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)])); namestrcpy(&d->fd.partitioning_func, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func)])); old = MemoryContextSwitchTo(ti->mctx); d->partitioning = ts_partitioning_info_create(NameStr(d->fd.partitioning_func_schema), NameStr(d->fd.partitioning_func), NameStr(d->fd.column_name), d->type, main_table_relid); MemoryContextSwitchTo(old); } if (!isnull[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)] && !isnull[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func)]) { namestrcpy(&d->fd.integer_now_func_schema, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)])); namestrcpy(&d->fd.integer_now_func, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func)])); } if (IS_CLOSED_DIMENSION(d)) d->fd.num_slices = DatumGetInt16(values[AttrNumberGetAttrOffset(Anum_dimension_num_slices)]); else { d->fd.interval_length = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_dimension_interval_length)]); if (!isnull[AttrNumberGetAttrOffset(Anum_dimension_compress_interval_length)]) d->fd.compress_interval_length = DatumGetInt64( values[AttrNumberGetAttrOffset(Anum_dimension_compress_interval_length)]); } d->column_attno = get_attnum(main_table_relid, NameStr(d->fd.column_name)); d->main_table_relid = main_table_relid; if (should_free) heap_freetuple(tuple); } static Datum create_range_datum(FunctionCallInfo fcinfo, DimensionSlice *slice) { TupleDesc tupdesc; Datum values[2]; bool nulls[2] = { false }; HeapTuple tuple; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "function returning record called in context that cannot accept type record"); tupdesc = BlessTupleDesc(tupdesc); values[0] = Int64GetDatum(slice->fd.range_start); values[1] = Int64GetDatum(slice->fd.range_end); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } static DimensionSlice * calculate_open_range_default(const Dimension *dim, int64 value) { int64 range_start, range_end; Oid dimtype = ts_dimension_get_partition_type(dim); if (value < 0) { const int64 dim_min = ts_time_get_min(dimtype); range_end = ((value + 1) / dim->fd.interval_length) * dim->fd.interval_length; /* prevent integer underflow */ if (dim_min - range_end > -dim->fd.interval_length) range_start = DIMENSION_SLICE_MINVALUE; else range_start = range_end - dim->fd.interval_length; } else { const int64 dim_end = ts_time_get_max(dimtype); range_start = (value / dim->fd.interval_length) * dim->fd.interval_length; /* prevent integer overflow */ if (dim_end - range_start < dim->fd.interval_length) range_end = DIMENSION_SLICE_MAXVALUE; else range_end = range_start + dim->fd.interval_length; } return ts_dimension_slice_create(dim->fd.id, range_start, range_end); } TS_FUNCTION_INFO_V1(ts_dimension_calculate_open_range_default); /* * Expose open dimension range calculation for testing purposes. */ Datum ts_dimension_calculate_open_range_default(PG_FUNCTION_ARGS) { int64 value = PG_GETARG_INT64(0); Dimension dim = { .type = DIMENSION_TYPE_OPEN, .fd.id = 0, .fd.interval_length = PG_GETARG_INT64(1), .fd.column_type = TypenameGetTypid(PG_GETARG_CSTRING(2)), }; DimensionSlice *slice = calculate_open_range_default(&dim, value); PG_RETURN_DATUM(create_range_datum(fcinfo, slice)); } static int64 calculate_closed_range_interval(const Dimension *dim) { Assert(NULL != dim && IS_CLOSED_DIMENSION(dim)); return DIMENSION_SLICE_CLOSED_MAX / ((int64) dim->fd.num_slices); } static DimensionSlice * calculate_closed_range_default(const Dimension *dim, int64 value) { int64 range_start, range_end; /* The interval that divides the dimension into N equal sized slices */ int64 interval = calculate_closed_range_interval(dim); int64 last_start = interval * (dim->fd.num_slices - 1); if (value < 0) elog(ERROR, "invalid value " INT64_FORMAT " for closed dimension", value); if (value >= last_start) { /* put overflow from integer-division errors in last range */ range_start = last_start; range_end = DIMENSION_SLICE_MAXVALUE; } else { range_start = (value / interval) * interval; range_end = range_start + interval; } if (0 == range_start) { range_start = DIMENSION_SLICE_MINVALUE; } return ts_dimension_slice_create(dim->fd.id, range_start, range_end); } TS_FUNCTION_INFO_V1(ts_dimension_calculate_closed_range_default); /* * Exposed closed dimension range calculation for testing purposes. */ Datum ts_dimension_calculate_closed_range_default(PG_FUNCTION_ARGS) { int64 value = PG_GETARG_INT64(0); Dimension dim = { .type = DIMENSION_TYPE_CLOSED, .fd.id = 0, .fd.num_slices = PG_GETARG_INT16(1), }; DimensionSlice *slice = calculate_closed_range_default(&dim, value); PG_RETURN_DATUM(create_range_datum(fcinfo, slice)); } DimensionSlice * ts_dimension_calculate_default_slice(const Dimension *dim, int64 value) { if (IS_OPEN_DIMENSION(dim)) return calculate_open_range_default(dim, value); return calculate_closed_range_default(dim, value); } /* * Get the ordinal value of a slice in an open dimension. * * Note that, for an open dimension, we can only deal with already created * slices and cannot account for, e.g., gaps in the dimension where future * slices might be created and thus changing the ordinal value for a slice. * * For instance, the ordinal value of slice D below is 2 (zero indexed): * * ' | A | B | <gap> | D | E | * * but when slice C is later created the ordinal value of D will be 3: * * ' | A | B | C | D | E | */ static int ts_dimension_get_open_slice_ordinal(const Dimension *dim, const DimensionSlice *slice) { DimensionVec *vec; int i; Assert(NULL != dim && IS_OPEN_DIMENSION(dim)); Assert(NULL != slice); vec = ts_dimension_get_slices(dim); Assert(NULL != vec); /* Find the index (ordinal) of the chunk's slice in the open dimension */ i = ts_dimension_vec_find_slice_index(vec, slice->fd.id); if (i >= 0) return i; /* * Returns the number of slices if the slice not found, i.e., i = -1. * Dimension slice might not exist if a chunk table is created without * modifying metadata. */ return vec->num_slices; } /* * Get the ordinal value of a slice in a closed dimension. * * For closed dimensions, we calculate the ordinal value of a slice based on * the assumption that the dimension is fully partitioned in equal size slices * as given by the current partitioning configuration. In reality, though, * slices are created lazily so a closed dimension might have less slices in * time interval than the configuration suggests. Further, during time * intervals where repartitioning happens, there might be an unexpected number * of slices due to a mix of slices from both the old and the new partitioning * configuration. As a result, the ordinal value of a given slice might not * actually match the partitioning settings at a given point in time. In this case, we will return * the ordinal of current slice most overlapping the given slice (or first fully overlapped slice). */ static int ts_dimension_get_closed_slice_ordinal(const Dimension *dim, const DimensionSlice *target_slice) { int64 current_slice_size; int64 target_slice_size; int candidate_slice_ordinal; int64 target_overlap_with_candidate_slice; Assert(NULL != dim && IS_CLOSED_DIMENSION(dim)); Assert(NULL != target_slice); Assert(dim->fd.num_slices > 0); /* Slicing assumes partitioning functions use the range [0, INT32_MAX], though the first slice * uses INT64_MIN as its lower bound, and the last slice uses INT64_MAX as its upper bound. */ if (target_slice->fd.range_start == DIMENSION_SLICE_MINVALUE) return 0; if (target_slice->fd.range_end == DIMENSION_SLICE_MAXVALUE) return dim->fd.num_slices - 1; Assert(target_slice->fd.range_start > 0); Assert(target_slice->fd.range_end < DIMENSION_SLICE_CLOSED_MAX); /* Given a target slice starting from some point p, determine a candidate slice in the current * partitioning configuration that contains p. If that slice contains over half of our target * slice, return it's ordinal. Otherwise return the ordinal for the next slice. */ current_slice_size = calculate_closed_range_interval(dim); target_slice_size = target_slice->fd.range_end - target_slice->fd.range_start; candidate_slice_ordinal = target_slice->fd.range_start / current_slice_size; target_overlap_with_candidate_slice = current_slice_size - (target_slice->fd.range_start % current_slice_size); /* Note that if the candidate slice wholly contains the target slice, * target_overlap_with_candidate_slice will actually be greater than target_slice_size. This * doesn't affect the correctness of the following check. */ if (target_overlap_with_candidate_slice >= target_slice_size / 2) return candidate_slice_ordinal; else return candidate_slice_ordinal + 1; } /* * Get the ordinal value of a slice in a dimension. * * This function returns the ordinal value of a slice (starting at 0) in the * dimension it belongs to. In other words, the "earliest" slice along the * dimensional axis gets the lowest ordinal value and the "latest" the largest. */ int ts_dimension_get_slice_ordinal(const Dimension *dim, const DimensionSlice *slice) { Assert(NULL != dim); Assert(NULL != slice); Assert(dim->fd.id == slice->fd.dimension_id); switch (dim->type) { case DIMENSION_TYPE_OPEN: return ts_dimension_get_open_slice_ordinal(dim, slice); case DIMENSION_TYPE_CLOSED: return ts_dimension_get_closed_slice_ordinal(dim, slice); default: Assert(false); break; } pg_unreachable(); return -1; } static Hyperspace * hyperspace_create(int32 hypertable_id, Oid main_table_relid, uint16 num_dimensions, MemoryContext mctx) { Hyperspace *hs = MemoryContextAllocZero(mctx, HYPERSPACE_SIZE(num_dimensions)); hs->hypertable_id = hypertable_id; hs->main_table_relid = main_table_relid; hs->capacity = num_dimensions; hs->num_dimensions = 0; return hs; } static ScanTupleResult dimension_tuple_found(TupleInfo *ti, void *data) { Hyperspace *hs = data; Dimension *d = &hs->dimensions[hs->num_dimensions++]; dimension_fill_in_from_tuple(d, ti, hs->main_table_relid); return SCAN_CONTINUE; } static int dimension_scan_internal(ScanKeyData *scankey, int nkeys, tuple_found_func tuple_found, void *data, int limit, int dimension_index, LOCKMODE lockmode, MemoryContext mctx) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, DIMENSION), .index = catalog_get_index(catalog, DIMENSION, dimension_index), .nkeys = nkeys, .limit = limit, .scankey = scankey, .data = data, .tuple_found = tuple_found, .lockmode = lockmode, .scandirection = ForwardScanDirection, .result_mctx = mctx, }; return ts_scanner_scan(&scanctx); } Hyperspace * ts_dimension_scan(int32 hypertable_id, Oid main_table_relid, int16 num_dimensions, MemoryContext mctx) { Hyperspace *space = hyperspace_create(hypertable_id, main_table_relid, num_dimensions, mctx); ScanKeyData scankey[1]; /* Perform an index scan on hypertable_id. */ ScanKeyInit(&scankey[0], Anum_dimension_hypertable_id_column_name_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); dimension_scan_internal(scankey, 1, dimension_tuple_found, space, num_dimensions, DIMENSION_HYPERTABLE_ID_COLUMN_NAME_IDX, AccessShareLock, mctx); /* Sort dimensions in ascending order to allow binary search lookups */ qsort(space->dimensions, space->num_dimensions, sizeof(Dimension), cmp_dimension_id); return space; } static ScanTupleResult dimension_find_hypertable_id_tuple_found(TupleInfo *ti, void *data) { int32 *hypertable_id = data; bool isnull = false; Datum datum = slot_getattr(ti->slot, Anum_dimension_hypertable_id, &isnull); Assert(!isnull); *hypertable_id = DatumGetInt32(datum); return SCAN_DONE; } int32 ts_dimension_get_hypertable_id(int32 dimension_id) { int32 hypertable_id; ScanKeyData scankey[1]; int ret; /* Perform an index scan dimension_id. */ ScanKeyInit(&scankey[0], Anum_dimension_id_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); ret = dimension_scan_internal(scankey, 1, dimension_find_hypertable_id_tuple_found, &hypertable_id, 1, DIMENSION_ID_IDX, AccessShareLock, CurrentMemoryContext); if (ret == 1) return hypertable_id; return -1; } DimensionVec * ts_dimension_get_slices(const Dimension *dim) { return ts_dimension_slice_scan_by_dimension(dim->fd.id, 0); } static int dimension_scan_update(int32 dimension_id, tuple_found_func tuple_found, void *data, LOCKMODE lockmode) { Catalog *catalog = ts_catalog_get(); ScanKeyData scankey[1]; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, DIMENSION), .index = catalog_get_index(catalog, DIMENSION, DIMENSION_ID_IDX), .nkeys = 1, .limit = 1, .scankey = scankey, .data = data, .tuple_found = tuple_found, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; ScanKeyInit(&scankey[0], Anum_dimension_id_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); return ts_scanner_scan(&scanctx); } static ScanTupleResult dimension_tuple_delete(TupleInfo *ti, void *data) { CatalogSecurityContext sec_ctx; bool isnull; Datum dimension_id = slot_getattr(ti->slot, Anum_dimension_id, &isnull); bool *delete_slices = data; Assert(!isnull); /* delete dimension slices */ if (NULL != delete_slices && *delete_slices) ts_dimension_slice_delete_by_dimension_id(DatumGetInt32(dimension_id), false); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); return SCAN_CONTINUE; } int ts_dimension_delete_by_hypertable_id(int32 hypertable_id, bool delete_slices) { ScanKeyData scankey[1]; /* Perform an index scan to delete based on hypertable_id */ ScanKeyInit(&scankey[0], Anum_dimension_hypertable_id_column_name_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); return dimension_scan_internal(scankey, 1, dimension_tuple_delete, &delete_slices, 0, DIMENSION_HYPERTABLE_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); } static ScanTupleResult dimension_tuple_update(TupleInfo *ti, void *data) { Dimension *dim = data; Datum values[Natts_dimension]; bool nulls[Natts_dimension]; CatalogSecurityContext sec_ctx; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); Assert((dim->fd.num_slices <= 0 && dim->fd.interval_length > 0) || (dim->fd.num_slices > 0 && dim->fd.interval_length <= 0)); values[AttrNumberGetAttrOffset(Anum_dimension_column_name)] = NameGetDatum(&dim->fd.column_name); values[AttrNumberGetAttrOffset(Anum_dimension_column_type)] = ObjectIdGetDatum(dim->fd.column_type); values[AttrNumberGetAttrOffset(Anum_dimension_num_slices)] = Int16GetDatum(dim->fd.num_slices); if (!nulls[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func)] && !nulls[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)]) { values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func)] = NameGetDatum(&dim->fd.partitioning_func); values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] = NameGetDatum(&dim->fd.partitioning_func_schema); } if (*NameStr(dim->fd.integer_now_func) != '\0' && *NameStr(dim->fd.integer_now_func_schema) != '\0') { values[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func)] = NameGetDatum(&dim->fd.integer_now_func); values[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)] = NameGetDatum(&dim->fd.integer_now_func_schema); nulls[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func)] = false; nulls[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)] = false; } if (!nulls[AttrNumberGetAttrOffset(Anum_dimension_interval_length)]) values[AttrNumberGetAttrOffset(Anum_dimension_interval_length)] = Int64GetDatum(dim->fd.interval_length); if (dim->fd.compress_interval_length > 0) { values[AttrNumberGetAttrOffset(Anum_dimension_compress_interval_length)] = Int64GetDatum(dim->fd.compress_interval_length); nulls[AttrNumberGetAttrOffset(Anum_dimension_compress_interval_length)] = false; } else { nulls[AttrNumberGetAttrOffset(Anum_dimension_compress_interval_length)] = true; } new_tuple = heap_form_tuple(ts_scanner_get_tupledesc(ti), values, nulls); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_DONE; } static int32 dimension_insert_relation(Relation rel, int32 hypertable_id, Name colname, Oid coltype, int16 num_slices, regproc partitioning_func, int64 interval_length) { TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_dimension]; bool nulls[Natts_dimension] = { false }; CatalogSecurityContext sec_ctx; int32 dimension_id; values[AttrNumberGetAttrOffset(Anum_dimension_hypertable_id)] = Int32GetDatum(hypertable_id); values[AttrNumberGetAttrOffset(Anum_dimension_column_name)] = NameGetDatum(colname); values[AttrNumberGetAttrOffset(Anum_dimension_column_type)] = ObjectIdGetDatum(coltype); if (OidIsValid(partitioning_func)) { Oid pronamespace = get_func_namespace(partitioning_func); values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func)] = DirectFunctionCall1(namein, CStringGetDatum(get_func_name(partitioning_func))); values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] = DirectFunctionCall1(namein, CStringGetDatum(get_namespace_name(pronamespace))); } else { nulls[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func)] = true; nulls[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] = true; } if (num_slices > 0) { /* Closed (hash) dimension */ Assert(num_slices > 0 && interval_length <= 0); values[AttrNumberGetAttrOffset(Anum_dimension_num_slices)] = Int16GetDatum(num_slices); values[AttrNumberGetAttrOffset(Anum_dimension_aligned)] = BoolGetDatum(false); nulls[AttrNumberGetAttrOffset(Anum_dimension_interval_length)] = true; } else { /* Open (time) dimension */ Assert(num_slices <= 0 && interval_length > 0); values[AttrNumberGetAttrOffset(Anum_dimension_interval_length)] = Int64GetDatum(interval_length); values[AttrNumberGetAttrOffset(Anum_dimension_aligned)] = BoolGetDatum(true); nulls[AttrNumberGetAttrOffset(Anum_dimension_num_slices)] = true; } /* no integer_now function by default */ nulls[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)] = true; nulls[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func)] = true; /* no compress interval length by default */ nulls[AttrNumberGetAttrOffset(Anum_dimension_compress_interval_length)] = true; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); dimension_id = Int32GetDatum(ts_catalog_table_next_seq_id(ts_catalog_get(), DIMENSION)); values[AttrNumberGetAttrOffset(Anum_dimension_id)] = dimension_id; ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); return dimension_id; } static int32 dimension_insert(int32 hypertable_id, Name colname, Oid coltype, int16 num_slices, regproc partitioning_func, int64 interval_length) { Catalog *catalog = ts_catalog_get(); Relation rel; int32 dimension_id; rel = table_open(catalog_get_table_id(catalog, DIMENSION), RowExclusiveLock); dimension_id = dimension_insert_relation(rel, hypertable_id, colname, coltype, num_slices, partitioning_func, interval_length); table_close(rel, RowExclusiveLock); return dimension_id; } int ts_dimension_set_type(Dimension *dim, Oid newtype) { if (!IS_VALID_OPEN_DIM_TYPE(newtype)) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("cannot change data type of hypertable column \"%s\" from %s to %s", NameStr(dim->fd.column_name), format_type_be(dim->fd.column_type), format_type_be(newtype)), errhint("Use an integer, timestamp, or date type."))); dim->fd.column_type = newtype; return dimension_scan_update(dim->fd.id, dimension_tuple_update, dim, RowExclusiveLock); } TSDLLEXPORT Oid ts_dimension_get_partition_type(const Dimension *dim) { Assert(dim != NULL); return dim->partitioning != NULL ? dim->partitioning->partfunc.rettype : dim->fd.column_type; } int ts_dimension_set_name(Dimension *dim, const char *newname) { namestrcpy(&dim->fd.column_name, newname); return dimension_scan_update(dim->fd.id, dimension_tuple_update, dim, RowExclusiveLock); } int ts_dimension_set_chunk_interval(Dimension *dim, int64 chunk_interval) { Assert(IS_OPEN_DIMENSION(dim)); dim->fd.interval_length = chunk_interval; return dimension_scan_update(dim->fd.id, dimension_tuple_update, dim, RowExclusiveLock); } int ts_dimension_set_compress_interval(Dimension *dim, int64 compress_interval) { if (!IS_OPEN_DIMENSION(dim)) ereport(ERROR, (errmsg("trying to set compress interval on closed dimension"), errhint("dimension ID %d", dim->fd.id))); dim->fd.compress_interval_length = compress_interval; return dimension_scan_update(dim->fd.id, dimension_tuple_update, dim, RowExclusiveLock); } /* * Apply any dimension-specific transformations on a value, i.e., apply * partitioning function. Optionally get the type of the resulting value via * the restype parameter. */ Datum ts_dimension_transform_value(const Dimension *dim, Oid collation, Datum value, Oid const_datum_type, Oid *restype) { if (NULL != dim->partitioning) value = ts_partitioning_func_apply(dim->partitioning, collation, value); if (NULL != restype) { if (NULL != dim->partitioning) *restype = dim->partitioning->partfunc.rettype; else if (OidIsValid(const_datum_type)) *restype = const_datum_type; else *restype = dim->fd.column_type; } return value; } Point * ts_point_create(int16 num_dimensions) { Point *p = palloc0(POINT_SIZE(num_dimensions)); p->cardinality = num_dimensions; p->num_coords = 0; return p; } TSDLLEXPORT Point * ts_hyperspace_calculate_point(const Hyperspace *hs, TupleTableSlot *slot) { Point *p = ts_point_create(hs->num_dimensions); int i; for (i = 0; i < hs->num_dimensions; i++) { const Dimension *d = &hs->dimensions[i]; Datum datum; bool isnull; Oid dimtype; if (NULL != d->partitioning) datum = ts_partitioning_func_apply_slot(d->partitioning, slot, &isnull); else datum = slot_getattr(slot, d->column_attno, &isnull); switch (d->type) { case DIMENSION_TYPE_OPEN: dimtype = ts_dimension_get_partition_type(d); if (isnull) ereport(ERROR, (errcode(ERRCODE_NOT_NULL_VIOLATION), errmsg("NULL value in column \"%s\" violates not-null constraint", NameStr(d->fd.column_name)), errhint("Columns used for time partitioning cannot be NULL."))); p->coordinates[p->num_coords++] = ts_time_value_to_internal(datum, dimtype); break; case DIMENSION_TYPE_CLOSED: p->coordinates[p->num_coords++] = (int64) DatumGetInt32(datum); break; case DIMENSION_TYPE_STATS: case DIMENSION_TYPE_ANY: elog(ERROR, "invalid dimension type when inserting tuple"); break; } } return p; } #define INT_TYPE_MAX(type) \ (int64)(((type) == INT2OID) ? PG_INT16_MAX : \ (((type) == INT4OID) ? PG_INT32_MAX : PG_INT64_MAX)) #define IS_VALID_NUM_SLICES(num_slices) ((num_slices) >= 1 && (num_slices) <= PG_INT16_MAX) static int64 get_validated_integer_interval(Oid dimtype, int64 value) { if (value < 1 || value > INT_TYPE_MAX(dimtype)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid interval: must be between 1 and " INT64_FORMAT, INT_TYPE_MAX(dimtype)))); if (IS_TIMESTAMP_TYPE(dimtype) && value < USECS_PER_SEC) ereport(WARNING, (errcode(ERRCODE_AMBIGUOUS_PARAMETER), errmsg("unexpected interval: smaller than one second"), errhint("The interval is specified in microseconds."))); return value; } /* * Get the default chunk interval based on dimension type. */ static int64 get_default_interval(Oid dimtype, bool adaptive_chunking) { int64 interval; switch (dimtype) { case INT2OID: interval = DEFAULT_SMALLINT_INTERVAL; break; case INT4OID: interval = DEFAULT_INT_INTERVAL; break; case INT8OID: interval = DEFAULT_BIGINT_INTERVAL; break; case TIMESTAMPOID: case TIMESTAMPTZOID: case DATEOID: case UUIDOID: interval = adaptive_chunking ? DEFAULT_CHUNK_TIME_INTERVAL_ADAPTIVE : DEFAULT_CHUNK_TIME_INTERVAL; break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot get default interval for %s dimension", format_type_be(dimtype)), errhint("Use a valid dimension type."))); } return interval; } static int64 dimension_interval_to_internal(const char *colname, Oid dimtype, Oid valuetype, Datum value, bool adaptive_chunking) { int64 interval; if (!IS_VALID_OPEN_DIM_TYPE(dimtype)) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("invalid type for dimension \"%s\"", colname), errhint("Use an integer, timestamp, or date type."))); if (!OidIsValid(valuetype)) { value = Int64GetDatum(get_default_interval(dimtype, adaptive_chunking)); valuetype = INT8OID; } switch (valuetype) { case INT2OID: interval = get_validated_integer_interval(dimtype, DatumGetInt16(value)); break; case INT4OID: interval = get_validated_integer_interval(dimtype, DatumGetInt32(value)); break; case INT8OID: interval = get_validated_integer_interval(dimtype, DatumGetInt64(value)); break; case INTERVALOID: if (!IS_TIMESTAMP_TYPE(dimtype) && !IS_UUID_TYPE(dimtype)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid interval type for %s dimension", format_type_be(dimtype)), errhint("Use an interval of type integer."))); interval = interval_to_usec(DatumGetIntervalP(value)); break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid interval type for %s dimension", format_type_be(dimtype)), IS_TIMESTAMP_TYPE(dimtype) ? errhint("Use an interval of type integer or interval.") : errhint("Use an interval of type integer."))); } if (dimtype == DATEOID && (interval <= 0 || interval % USECS_PER_DAY != 0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid interval for %s dimension", format_type_be(dimtype)), errhint("Use an interval that is a multiple of one day."))); return interval; } TS_FUNCTION_INFO_V1(ts_dimension_interval_to_internal_test); /* * Exposed for testing purposes. */ Datum ts_dimension_interval_to_internal_test(PG_FUNCTION_ARGS) { Oid dimtype = PG_GETARG_OID(0); Datum value = PG_GETARG_DATUM(1); Oid valuetype = PG_ARGISNULL(1) ? InvalidOid : get_fn_expr_argtype(fcinfo->flinfo, 1); PG_RETURN_INT64(dimension_interval_to_internal("testcol", dimtype, valuetype, value, false)); } static void dimension_add_not_null_on_column(Oid table_relid, char *colname) { AlterTableCmd cmd = { .type = T_AlterTableCmd, .subtype = AT_SetNotNull, .name = colname, .missing_ok = false, }; ereport(DEBUG1, (errmsg("adding not-null constraint to column \"%s\"", colname), errdetail("Dimensions cannot have NULL values."))); ts_alter_table_with_event_trigger(table_relid, (Node *) &cmd, list_make1(&cmd), false); } void ts_dimension_update(const Hypertable *ht, const NameData *dimname, DimensionType dimtype, Datum *interval, Oid *intervaltype, int16 *num_slices, Oid *integer_now_func) { Dimension *dim; if (NULL == ht) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("invalid hypertable"))); if (dimtype == DIMENSION_TYPE_ANY) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid dimension type"))); if (NULL == dimname) { if (hyperspace_get_num_dimensions_by_type(ht->space, dimtype) > 1) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable \"%s\" has multiple %s dimensions", get_rel_name(ht->main_table_relid), dimtype == DIMENSION_TYPE_OPEN ? "time" : "space"), errhint("An explicit dimension name must be specified."))); dim = ts_hyperspace_get_mutable_dimension(ht->space, dimtype, 0); } else dim = ts_hyperspace_get_mutable_dimension_by_name(ht->space, dimtype, NameStr(*dimname)); if (NULL == dim) ereport(ERROR, (errcode(ERRCODE_TS_DIMENSION_NOT_EXIST), errmsg("hypertable \"%s\" does not have a matching dimension", get_rel_name(ht->main_table_relid)))); Assert(dim->type == dimtype); if (interval) { Oid dimtype = ts_dimension_get_partition_type(dim); Assert(intervaltype); Assert(IS_OPEN_DIMENSION(dim)); dim->fd.interval_length = dimension_interval_to_internal(NameStr(dim->fd.column_name), dimtype, *intervaltype, *interval, hypertable_adaptive_chunking_enabled(ht)); } if (num_slices) { Assert(IS_CLOSED_DIMENSION(dim)); dim->fd.num_slices = *num_slices; } if (integer_now_func) { Oid pronamespace = get_func_namespace(*integer_now_func); namestrcpy(&dim->fd.integer_now_func_schema, get_namespace_name(pronamespace)); namestrcpy(&dim->fd.integer_now_func, get_func_name(*integer_now_func)); } dimension_scan_update(dim->fd.id, dimension_tuple_update, dim, RowExclusiveLock); } TS_FUNCTION_INFO_V1(ts_dimension_set_num_slices); Datum ts_dimension_set_num_slices(PG_FUNCTION_ARGS) { Oid table_relid = PG_GETARG_OID(0); int32 num_slices_arg = PG_ARGISNULL(1) ? -1 : PG_GETARG_INT32(1); Name colname = PG_ARGISNULL(2) ? NULL : PG_GETARG_NAME(2); Cache *hcache = ts_hypertable_cache_pin(); int16 num_slices; Hypertable *ht; TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable cannot be NULL"))); /* Verify that we're dealing with a hypertable or fail */ ht = ts_hypertable_cache_get_entry(hcache, table_relid, CACHE_FLAG_NONE); ts_hypertable_permissions_check(table_relid, GetUserId()); if (PG_ARGISNULL(1) || !IS_VALID_NUM_SLICES(num_slices_arg)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid number of partitions: must be between 1 and %d", PG_INT16_MAX))); /* * Our catalog stores num_slices as a smallint (int16). However, function * argument is an integer (int32) so that the user need not cast it to a * smallint. We therefore convert to int16 here after checking that * num_slices cannot be > INT16_MAX. */ num_slices = num_slices_arg & 0xffff; ts_dimension_update(ht, colname, DIMENSION_TYPE_CLOSED, NULL, NULL, &num_slices, NULL); ts_cache_release(&hcache); PG_RETURN_VOID(); } TS_FUNCTION_INFO_V1(ts_dimension_set_interval); /* * Update chunk_time_interval for a hypertable. * * hypertable - The OID of the table corresponding to a hypertable whose time * interval should be updated * chunk_time_interval - The new time interval. For hypertables with integral * time columns, this must be an integral type. For hypertables with a * TIMESTAMP/TIMESTAMPTZ/DATE type, it can be integral which is treated as * microseconds, or an INTERVAL type. * dimension_name - The name of the dimension */ Datum ts_dimension_set_interval(PG_FUNCTION_ARGS) { Oid table_relid = PG_GETARG_OID(0); Datum interval = PG_GETARG_DATUM(1); Oid intervaltype = InvalidOid; Name colname = PG_ARGISNULL(2) ? NULL : PG_GETARG_NAME(2); Cache *hcache = ts_hypertable_cache_pin(); Hypertable *ht; TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable cannot be NULL"))); ht = ts_resolve_hypertable_from_table_or_cagg(hcache, table_relid, true); ts_hypertable_permissions_check(table_relid, GetUserId()); if (PG_ARGISNULL(1)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid interval: an explicit interval must be specified"))); intervaltype = get_fn_expr_argtype(fcinfo->flinfo, 1); ts_dimension_update(ht, colname, DIMENSION_TYPE_OPEN, &interval, &intervaltype, NULL, NULL); ts_cache_release(&hcache); PG_RETURN_VOID(); } DimensionInfo * ts_dimension_info_create_open(Oid table_relid, Name column_name, Datum interval, Oid interval_type, regproc partitioning_func) { DimensionInfo *info = palloc(sizeof(*info)); *info = (DimensionInfo){ .type = DIMENSION_TYPE_OPEN, .table_relid = table_relid, .interval_datum = interval, .interval_type = interval_type, .partitioning_func = partitioning_func, }; namestrcpy(&info->colname, NameStr(*column_name)); return info; } DimensionInfo * ts_dimension_info_create_closed(Oid table_relid, Name column_name, int32 num_slices, regproc partitioning_func) { DimensionInfo *info = palloc(sizeof(*info)); *info = (DimensionInfo){ .type = DIMENSION_TYPE_CLOSED, .table_relid = table_relid, .num_slices = num_slices, .num_slices_is_set = (num_slices > 0), .partitioning_func = partitioning_func, }; namestrcpy(&info->colname, NameStr(*column_name)); return info; } /* Validate the configuration of an open ("time") dimension */ static void dimension_info_validate_open(DimensionInfo *info) { Oid dimtype = info->coltype; Assert(info->type == DIMENSION_TYPE_OPEN); if (OidIsValid(info->partitioning_func)) { if (!ts_partitioning_func_is_valid(info->partitioning_func, info->type, info->coltype)) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("invalid partitioning function"), errhint("A valid partitioning function for open (time) dimensions must be " "IMMUTABLE, " "take the column type as input, and return an integer or " "timestamp type."))); dimtype = get_func_rettype(info->partitioning_func); } info->interval = dimension_interval_to_internal(NameStr(info->colname), dimtype, info->interval_type, info->interval_datum, info->adaptive_chunking); } /* Validate the configuration of a closed ("space") dimension */ static void dimension_info_validate_closed(DimensionInfo *info) { Assert(info->type == DIMENSION_TYPE_CLOSED); if (!OidIsValid(info->partitioning_func)) info->partitioning_func = ts_partitioning_func_get_closed_default(); else if (!ts_partitioning_func_is_valid(info->partitioning_func, info->type, info->coltype)) ereport(ERROR, (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION), errmsg("invalid partitioning function"), errhint("A valid partitioning function for closed (space) dimensions must be " "IMMUTABLE " "and have the signature (anyelement) -> integer."))); if (!info->num_slices_is_set || !IS_VALID_NUM_SLICES(info->num_slices)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid number of partitions for dimension \"%s\"", NameStr(info->colname)), errhint("A closed (space) dimension must specify between 1 and %d partitions.", PG_INT16_MAX))); } void ts_dimension_info_validate(DimensionInfo *info) { const Dimension *dim; HeapTuple tuple; Datum datum; bool isnull = false; bool isgenerated; if (!DIMENSION_INFO_IS_SET(info)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid dimension info"))); if (info->num_slices_is_set && OidIsValid(info->interval_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify both the number of partitions and an interval"))); /* Check that the column exists and get its NOT NULL status */ tuple = SearchSysCacheAttName(info->table_relid, NameStr(info->colname)); if (!HeapTupleIsValid(tuple)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" does not exist", NameStr(info->colname)))); datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_atttypid, &isnull); Assert(!isnull); info->coltype = DatumGetObjectId(datum); datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attnotnull, &isnull); Assert(!isnull); info->set_not_null = !DatumGetBool(datum); /* check that the column is not generated */ datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attgenerated, &isnull); Assert(!isnull); isgenerated = (DatumGetChar(datum) == ATTRIBUTE_GENERATED_STORED); if (isgenerated) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid partitioning column"), errhint("Generated columns cannot be used as partitioning dimensions."))); ReleaseSysCache(tuple); if (NULL != info->ht) { /* Check if the dimension already exists */ dim = ts_hyperspace_get_dimension_by_name(info->ht->space, DIMENSION_TYPE_ANY, NameStr(info->colname)); if (NULL != dim) { if (!info->if_not_exists) ereport(ERROR, (errcode(ERRCODE_TS_DUPLICATE_DIMENSION), errmsg("column \"%s\" is already a dimension", NameStr(info->colname)))); info->dimension_id = dim->fd.id; info->skip = true; ereport(NOTICE, (errmsg("column \"%s\" is already a dimension, skipping", NameStr(info->colname)))); return; } } switch (info->type) { case DIMENSION_TYPE_CLOSED: dimension_info_validate_closed(info); break; case DIMENSION_TYPE_OPEN: dimension_info_validate_open(info); break; case DIMENSION_TYPE_STATS: case DIMENSION_TYPE_ANY: elog(ERROR, "invalid dimension type in configuration"); break; } } int32 ts_dimension_add_from_info(DimensionInfo *info) { if (info->set_not_null && info->type == DIMENSION_TYPE_OPEN) dimension_add_not_null_on_column(info->table_relid, NameStr(info->colname)); Assert(info->ht != NULL); info->dimension_id = dimension_insert(info->ht->fd.id, &info->colname, info->coltype, info->num_slices, info->partitioning_func, info->interval); return info->dimension_id; } /* * Create a datum to be returned by add_dimension DDL function */ static Datum dimension_create_datum(FunctionCallInfo fcinfo, DimensionInfo *info, bool is_generic) { TupleDesc tupdesc; HeapTuple tuple; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in " "context that cannot accept type record"))); tupdesc = BlessTupleDesc(tupdesc); if (is_generic) { Datum values[Natts_generic_add_dimension]; bool nulls[Natts_generic_add_dimension] = { false }; Assert(tupdesc->natts == Natts_generic_add_dimension); values[AttrNumberGetAttrOffset(Anum_generic_add_dimension_id)] = info->dimension_id; values[AttrNumberGetAttrOffset(Anum_generic_add_dimension_created)] = BoolGetDatum(!info->skip); tuple = heap_form_tuple(tupdesc, values, nulls); } else { Datum values[Natts_add_dimension]; bool nulls[Natts_add_dimension] = { false }; Assert(tupdesc->natts == Natts_add_dimension); values[AttrNumberGetAttrOffset(Anum_add_dimension_id)] = info->dimension_id; values[AttrNumberGetAttrOffset(Anum_add_dimension_schema_name)] = NameGetDatum(&info->ht->fd.schema_name); values[AttrNumberGetAttrOffset(Anum_add_dimension_table_name)] = NameGetDatum(&info->ht->fd.table_name); values[AttrNumberGetAttrOffset(Anum_add_dimension_column_name)] = NameGetDatum(&info->colname); values[AttrNumberGetAttrOffset(Anum_add_dimension_created)] = BoolGetDatum(!info->skip); tuple = heap_form_tuple(tupdesc, values, nulls); } return HeapTupleGetDatum(tuple); } /* * Add a new dimension to a hypertable. * * Arguments: * 0. Relation ID of table * 1. Column name * 2. Number of partitions / slices in close ('space') dimensions * 3. Interval for open ('time') dimensions * 4. Partitioning function * 5. IF NOT EXISTS option (bool) */ static Datum ts_dimension_add_internal(FunctionCallInfo fcinfo, DimensionInfo *info, bool is_generic) { Cache *hcache; Datum retval = 0; Assert(DIMENSION_INFO_IS_SET(info)); if (!DIMENSION_INFO_IS_VALID(info)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("must specify either the number of partitions or an interval"))); ts_hypertable_permissions_check(info->table_relid, GetUserId()); /* * The hypertable catalog table has a CHECK(num_dimensions > 0), which * means, that when this function is called from create_hypertable() * instead of directly, num_dimension is already set to one. We therefore * need to lock the hypertable tuple here so that we can set the correct * number of dimensions once we've added the new dimension. * * This lock is also used to serialize access from concurrent add_dimension() * call and a chunk creation. */ LockRelationOid(info->table_relid, ShareUpdateExclusiveLock); DEBUG_WAITPOINT("add_dimension_ht_lock"); info->ht = ts_hypertable_cache_get_cache_and_entry(info->table_relid, CACHE_FLAG_NONE, &hcache); if (info->num_slices_is_set && OidIsValid(info->interval_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot specify both the number of partitions and an interval"))); if (!info->num_slices_is_set && !OidIsValid(info->interval_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot omit both the number of partitions and the interval"))); ts_dimension_info_validate(info); if (!info->skip) { int32 dimension_id; /* * Note that space->num_dimensions reflects the actual number of * dimension rows and not the num_dimensions in the hypertable catalog * table. */ ts_hypertable_set_num_dimensions(info->ht, info->ht->space->num_dimensions + 1); dimension_id = ts_dimension_add_from_info(info); /* Verify that existing indexes are compatible with a hypertable */ /* * Need to get a fresh copy of hypertable from the database as cache * does not reflect the changes in the previous 2 lines which add a * new dimension */ info->ht = ts_hypertable_get_by_id(info->ht->fd.id); ts_indexing_verify_indexes(info->ht); /* * If the hypertable has chunks, to make it compatible * we add artificial dimension slice which will cover -inf / inf * range. * * Newly created chunks will have a proper slice range according to * the created dimension and its partitioning. */ if (ts_hypertable_has_chunks(info->table_relid, AccessShareLock)) { ListCell *lc; List *chunk_id_list = ts_chunk_get_chunk_ids_by_hypertable_id(info->ht->fd.id); DimensionSlice *slice; slice = ts_dimension_slice_create(dimension_id, DIMENSION_SLICE_MINVALUE, DIMENSION_SLICE_MAXVALUE); ts_dimension_slice_insert_multi(&slice, 1); foreach (lc, chunk_id_list) { int32 chunk_id = lfirst_int(lc); Chunk *chunk = ts_chunk_get_by_id(chunk_id, true); ChunkConstraint *cc = ts_chunk_constraints_add(chunk->constraints, chunk->fd.id, slice->fd.id, NULL, NULL); ts_chunk_constraint_insert(cc); } } } retval = dimension_create_datum(fcinfo, info, is_generic); ts_cache_release(&hcache); PG_RETURN_DATUM(retval); } TS_FUNCTION_INFO_V1(ts_dimension_add); TS_FUNCTION_INFO_V1(ts_dimension_add_general); Datum ts_dimension_add(PG_FUNCTION_ARGS) { DimensionInfo info = { .type = PG_ARGISNULL(2) ? DIMENSION_TYPE_OPEN : DIMENSION_TYPE_CLOSED, .table_relid = PG_GETARG_OID(0), .num_slices = PG_ARGISNULL(2) ? DatumGetInt32(-1) : PG_GETARG_INT32(2), .num_slices_is_set = !PG_ARGISNULL(2), .interval_datum = PG_ARGISNULL(3) ? Int32GetDatum(-1) : PG_GETARG_DATUM(3), .interval_type = PG_ARGISNULL(3) ? InvalidOid : get_fn_expr_argtype(fcinfo->flinfo, 3), .partitioning_func = PG_ARGISNULL(4) ? InvalidOid : PG_GETARG_OID(4), .if_not_exists = PG_ARGISNULL(5) ? false : PG_GETARG_BOOL(5), }; TS_PREVENT_FUNC_IF_READ_ONLY(); if (!PG_ARGISNULL(1)) namestrcpy(&info.colname, NameStr(*PG_GETARG_NAME(1))); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable cannot be NULL"))); return ts_dimension_add_internal(fcinfo, &info, false); } TSDLLEXPORT Datum ts_dimension_info_in(PG_FUNCTION_ARGS) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot construct type \"dimension_info\" from string"), errdetail("Type dimension_info cannot be constructed from string. You need to " "use constructor function."), errhint("Use \"by_range\" or \"by_hash\" to construct dimension types."))); PG_RETURN_VOID(); /* keep compiler quiet */ } TSDLLEXPORT Datum ts_dimension_info_out(PG_FUNCTION_ARGS) { DimensionInfo *info = (DimensionInfo *) PG_GETARG_POINTER(0); StringInfoData str; const char *partfuncname = OidIsValid(info->partitioning_func) ? get_func_name(info->partitioning_func) : "-"; initStringInfo(&str); switch (info->type) { case DIMENSION_TYPE_CLOSED: appendStringInfo(&str, "hash//%s//%d//%s", NameStr(info->colname), info->num_slices, partfuncname); break; case DIMENSION_TYPE_OPEN: { const char *argvalstr = "-"; if (OidIsValid(info->interval_type)) { argvalstr = ts_datum_to_string(info->interval_datum, info->interval_type); } appendStringInfo(&str, "range//%s//%s//%s", NameStr(info->colname), argvalstr, partfuncname); break; } case DIMENSION_TYPE_STATS: appendStringInfo(&str, "range"); break; case DIMENSION_TYPE_ANY: appendStringInfo(&str, "any"); break; } PG_RETURN_CSTRING(str.data); } static DimensionInfo * make_dimension_info(Name colname, DimensionType dimtype) { size_t size = sizeof(DimensionInfo); DimensionInfo *info = palloc0(size); SET_VARSIZE(info, size); info->type = dimtype; namestrcpy(&info->colname, NameStr(*colname)); return info; } /* * DimensionInfo for a hash dimension. * * This structure is only partially filled in when constructed. The rest will * be filled in by ts_dimension_add_general. */ Datum ts_hash_dimension(PG_FUNCTION_ARGS) { Ensure(PG_NARGS() > 2, "expected at most 3 arguments, invoked with %d arguments", PG_NARGS()); Name column_name; GETARG_NOTNULL_NULLABLE(column_name, 0, "column_name", NAME); DimensionInfo *info = make_dimension_info(column_name, DIMENSION_TYPE_CLOSED); info->num_slices = PG_ARGISNULL(1) ? DatumGetInt32(-1) : PG_GETARG_INT32(1); info->num_slices_is_set = !PG_ARGISNULL(1); info->partitioning_func = PG_ARGISNULL(2) ? InvalidOid : PG_GETARG_OID(2); PG_RETURN_POINTER(info); } /* * DimensionInfo for a hash dimension. * * This structure is only partially filled in when constructed. The rest will * be filled in by ts_dimension_add_general. */ Datum ts_range_dimension(PG_FUNCTION_ARGS) { Ensure(PG_NARGS() > 2, "expected at most 3 arguments, invoked with %d arguments", PG_NARGS()); Name column_name; GETARG_NOTNULL_NULLABLE(column_name, 0, "column_name", NAME); DimensionInfo *info = make_dimension_info(column_name, DIMENSION_TYPE_OPEN); info->interval_datum = PG_ARGISNULL(1) ? Int32GetDatum(-1) : PG_GETARG_DATUM(1); info->interval_type = PG_ARGISNULL(1) ? InvalidOid : get_fn_expr_argtype(fcinfo->flinfo, 1); info->partitioning_func = PG_ARGISNULL(2) ? InvalidOid : PG_GETARG_OID(2); PG_RETURN_POINTER(info); } Datum ts_dimension_add_general(PG_FUNCTION_ARGS) { DimensionInfo *info = NULL; GETARG_NOTNULL_POINTER(info, 1, "dimension", DimensionInfo); info->table_relid = PG_GETARG_OID(0); if (PG_GETARG_BOOL(2)) info->if_not_exists = true; return ts_dimension_add_internal(fcinfo, info, true); } /* Used as a tuple found function */ static ScanTupleResult dimension_rename_schema_name(TupleInfo *ti, void *data) { /* Dimension table may contain null valued columns that is why we do not use * FormData_dimension *dimension = (FormData_dimension *) GETSTRUCT(tuple); * pattern here */ Datum values[Natts_dimension]; bool nulls[Natts_dimension]; bool doReplace[Natts_dimension] = { false }; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; /* contains [old_name,new_name] in that order */ char **names = (char **) data; Name schemaname; heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); Assert(!nulls[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] || !nulls[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)]); /* Rename schema names */ if (!nulls[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)]) { schemaname = DatumGetName(values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)]); if (namestrcmp(schemaname, names[0]) == 0) { namestrcpy(schemaname, (const char *) names[1]); values[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] = NameGetDatum(schemaname); doReplace[AttrNumberGetAttrOffset(Anum_dimension_partitioning_func_schema)] = true; } } if (!nulls[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)]) { schemaname = DatumGetName(values[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)]); if (namestrcmp(schemaname, names[0]) == 0) { namestrcpy(schemaname, (const char *) names[1]); values[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)] = NameGetDatum(schemaname); doReplace[AttrNumberGetAttrOffset(Anum_dimension_integer_now_func_schema)] = true; } } new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_CONTINUE; } /* Go through internal dimensions table and rename all relevant schema */ void ts_dimensions_rename_schema_name(const char *old_name, const char *new_name) { NameData old_schema_name; ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); char *names[2] = { (char *) old_name, (char *) new_name }; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, DIMENSION), .index = InvalidOid, .nkeys = 1, .scankey = scankey, .tuple_found = dimension_rename_schema_name, .data = (void *) names, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; namestrcpy(&old_schema_name, old_name); ScanKeyInit(&scankey[0], Anum_dimension_partitioning_func_schema, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&old_schema_name)); ts_scanner_scan(&scanctx); ScanKeyInit(&scankey[0], Anum_dimension_integer_now_func_schema, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&old_schema_name)); ts_scanner_scan(&scanctx); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/dimension.h������������������������������������������������������������������0000664�0000000�0000000�00000015374�15100345067�0017012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/attnum.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <executor/tuptable.h> #include "export.h" #include "time_utils.h" #include "ts_catalog/catalog.h" typedef struct PartitioningInfo PartitioningInfo; typedef struct DimensionSlice DimensionSlice; typedef struct DimensionVec DimensionVec; typedef enum DimensionType { DIMENSION_TYPE_OPEN, DIMENSION_TYPE_CLOSED, DIMENSION_TYPE_STATS, DIMENSION_TYPE_ANY, } DimensionType; typedef struct Dimension { FormData_dimension fd; DimensionType type; AttrNumber column_attno; Oid main_table_relid; PartitioningInfo *partitioning; } Dimension; #define IS_OPEN_DIMENSION(d) ((d)->type == DIMENSION_TYPE_OPEN) #define IS_CLOSED_DIMENSION(d) ((d)->type == DIMENSION_TYPE_CLOSED) #define IS_VALID_OPEN_DIM_TYPE(type) \ (IS_INTEGER_TYPE(type) || IS_TIMESTAMP_TYPE(type) || IS_UUID_TYPE(type) || \ ts_type_is_int8_binary_compatible(type)) /* * A hyperspace defines how to partition in a N-dimensional space. */ typedef struct Hyperspace { int32 hypertable_id; Oid main_table_relid; uint16 capacity; uint16 num_dimensions; /* Open dimensions should be stored before closed dimensions */ Dimension dimensions[FLEXIBLE_ARRAY_MEMBER]; } Hyperspace; #define HYPERSPACE_SIZE(num_dimensions) \ (sizeof(Hyperspace) + (sizeof(Dimension) * (num_dimensions))) /* * A point in an N-dimensional hyperspace. */ typedef struct Point { int16 cardinality; uint8 num_coords; /* Open dimension coordinates are stored before the closed coordinates */ int64 coordinates[FLEXIBLE_ARRAY_MEMBER]; } Point; #define POINT_SIZE(cardinality) (sizeof(Point) + (sizeof(int64) * (cardinality))) #define DEFAULT_CHUNK_TIME_INTERVAL (USECS_PER_DAY * 7) /* 7 days w/o adaptive */ #define DEFAULT_CHUNK_TIME_INTERVAL_ADAPTIVE \ (USECS_PER_DAY) /* 1 day with adaptive \ * chunking enabled */ /* Default intervals for integer types */ #define DEFAULT_SMALLINT_INTERVAL 10000 #define DEFAULT_INT_INTERVAL 100000 #define DEFAULT_BIGINT_INTERVAL 1000000 typedef struct Hypertable Hypertable; /* * Dimension information used to validate, create and update dimensions. * * This structure is used both partially filled in from the dimension info * constructors as well as when building dimension info for the storage into * the dimension table. * * @see ts_hash_dimension * @see ts_range_dimension */ typedef struct DimensionInfo { /* We declare the SQL type dimension_info with INTERNALLENGTH = VARIABLE. * So, PostgreSQL expects a proper length info field (varlena header). */ int32 vl_len_; Oid table_relid; int32 dimension_id; NameData colname; Oid coltype; DimensionType type; Datum interval_datum; Oid interval_type; /* Type of the interval datum */ int64 interval; int32 num_slices; regproc partitioning_func; bool if_not_exists; bool skip; bool set_not_null; bool num_slices_is_set; bool adaptive_chunking; /* True if adaptive chunking is enabled */ Hypertable *ht; } DimensionInfo; #define DIMENSION_INFO_IS_SET(di) (di != NULL && OidIsValid((di)->table_relid)) #define DIMENSION_INFO_IS_VALID(di) (info->num_slices_is_set || OidIsValid(info->interval_type)) extern Hyperspace *ts_dimension_scan(int32 hypertable_id, Oid main_table_relid, int16 num_dimension, MemoryContext mctx); extern DimensionSlice *ts_dimension_calculate_default_slice(const Dimension *dim, int64 value); extern TSDLLEXPORT Point *ts_hyperspace_calculate_point(const Hyperspace *h, TupleTableSlot *slot); extern int ts_dimension_get_slice_ordinal(const Dimension *dim, const DimensionSlice *slice); extern TSDLLEXPORT const Dimension *ts_hyperspace_get_dimension_by_id(const Hyperspace *hs, int32 id); extern TSDLLEXPORT const Dimension *ts_hyperspace_get_dimension(const Hyperspace *hs, DimensionType type, Index n); extern TSDLLEXPORT Dimension *ts_hyperspace_get_mutable_dimension(Hyperspace *hs, DimensionType type, Index n); extern TSDLLEXPORT const Dimension * ts_hyperspace_get_dimension_by_name(const Hyperspace *hs, DimensionType type, const char *name); extern TSDLLEXPORT Dimension * ts_hyperspace_get_mutable_dimension_by_name(Hyperspace *hs, DimensionType type, const char *name); extern DimensionVec *ts_dimension_get_slices(const Dimension *dim); extern int32 ts_dimension_get_hypertable_id(int32 dimension_id); extern int ts_dimension_set_type(Dimension *dim, Oid newtype); extern TSDLLEXPORT Oid ts_dimension_get_partition_type(const Dimension *dim); extern int ts_dimension_set_name(Dimension *dim, const char *newname); extern TSDLLEXPORT int ts_dimension_set_chunk_interval(Dimension *dim, int64 chunk_interval); extern int ts_dimension_set_compress_interval(Dimension *dim, int64 compress_interval); extern Datum ts_dimension_transform_value(const Dimension *dim, Oid collation, Datum value, Oid const_datum_type, Oid *restype); extern int ts_dimension_delete_by_hypertable_id(int32 hypertable_id, bool delete_slices); extern TSDLLEXPORT DimensionInfo *ts_dimension_info_create_open(Oid table_relid, Name column_name, Datum interval, Oid interval_type, regproc partitioning_func); extern TSDLLEXPORT DimensionInfo *ts_dimension_info_create_closed(Oid table_relid, Name column_name, int32 num_slices, regproc partitioning_func); extern void ts_dimension_info_validate(DimensionInfo *info); extern int32 ts_dimension_add_from_info(DimensionInfo *info); extern void ts_dimensions_rename_schema_name(const char *old_name, const char *new_name); extern TSDLLEXPORT void ts_dimension_update(const Hypertable *ht, const NameData *dimname, DimensionType dimtype, Datum *interval, Oid *intervaltype, int16 *num_slices, Oid *integer_now_func); extern TSDLLEXPORT Point *ts_point_create(int16 num_dimensions); extern TSDLLEXPORT bool ts_is_equality_operator(Oid opno, Oid left, Oid right); extern TSDLLEXPORT Datum ts_dimension_info_in(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_dimension_info_out(PG_FUNCTION_ARGS); #define hyperspace_get_open_dimension(space, i) \ ts_hyperspace_get_dimension(space, DIMENSION_TYPE_OPEN, i) #define hyperspace_get_closed_dimension(space, i) \ ts_hyperspace_get_dimension(space, DIMENSION_TYPE_CLOSED, i) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/dimension_slice.c������������������������������������������������������������0000664�0000000�0000000�00000114443�15100345067�0020161�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/relscan.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/pg_opfamily.h> #include <catalog/pg_type.h> #include <funcapi.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include "bgw_policy/chunk_stats.h" #include "chunk.h" #include "chunk_constraint.h" #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "hypertable.h" #include "scanner.h" #include "ts_catalog/catalog.h" #include "compat/compat.h" static inline DimensionSlice * dimension_slice_alloc(void) { return palloc0(sizeof(DimensionSlice)); } static inline DimensionSlice * dimension_slice_from_form_data(const Form_dimension_slice fd) { DimensionSlice *slice = dimension_slice_alloc(); memcpy(&slice->fd, fd, sizeof(FormData_dimension_slice)); slice->storage_free = NULL; slice->storage = NULL; return slice; } static inline DimensionSlice * dimension_slice_from_slot(TupleTableSlot *slot) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); DimensionSlice *slice; slice = dimension_slice_from_form_data((Form_dimension_slice) GETSTRUCT(tuple)); if (should_free) heap_freetuple(tuple); return slice; } static HeapTuple dimension_slice_formdata_make_tuple(const FormData_dimension_slice *fd, TupleDesc desc) { Datum values[Natts_dimension_slice]; bool nulls[Natts_dimension_slice] = { false }; memset(values, 0, sizeof(Datum) * Natts_dimension_slice); values[AttrNumberGetAttrOffset(Anum_dimension_slice_id)] = Int32GetDatum(fd->id); values[AttrNumberGetAttrOffset(Anum_dimension_slice_dimension_id)] = Int32GetDatum(fd->dimension_id); values[AttrNumberGetAttrOffset(Anum_dimension_slice_range_start)] = Int64GetDatum(fd->range_start); values[AttrNumberGetAttrOffset(Anum_dimension_slice_range_end)] = Int64GetDatum(fd->range_end); return heap_form_tuple(desc, values, nulls); } static inline void dimension_slice_formdata_fill(FormData_dimension_slice *fd, const TupleInfo *ti) { bool nulls[Natts_dimension_slice]; Datum values[Natts_dimension_slice]; bool should_free; HeapTuple tuple; tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); Assert(!nulls[AttrNumberGetAttrOffset(Anum_dimension_slice_id)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_dimension_slice_dimension_id)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_dimension_slice_range_start)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_dimension_slice_range_end)]); fd->id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_dimension_slice_id)]); fd->dimension_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_dimension_slice_dimension_id)]); fd->range_start = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_dimension_slice_range_start)]); fd->range_end = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_dimension_slice_range_end)]); if (should_free) heap_freetuple(tuple); } static bool lock_dimension_slice_tuple(int32 dimension_slice_id, ItemPointer tid, FormData_dimension_slice *form) { bool success = false; ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; ScanIterator iterator = ts_scan_iterator_create(DIMENSION_SLICE, RowShareLock, CurrentMemoryContext); iterator.ctx.index = catalog_get_index(ts_catalog_get(), DIMENSION_SLICE, DIMENSION_SLICE_ID_IDX); iterator.ctx.tuplock = &scantuplock; /* Keeping the lock since we presumably want to update the tuple */ iterator.ctx.flags = SCANNER_F_KEEPLOCK; /* see table_tuple_lock for details about flags that are set in TupleExclusive mode */ scantuplock.lockflags = TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS; if (!IsolationUsesXactSnapshot()) { /* in read committed mode, we follow all updates to this tuple */ scantuplock.lockflags |= TUPLE_LOCK_FLAG_FIND_LAST_VERSION; } ts_scan_iterator_scan_key_init(&iterator, Anum_dimension_slice_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_slice_id)); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); if (ti->lockresult != TM_Ok) { if (IsolationUsesXactSnapshot()) { /* For Repeatable Read and Serializable isolation level report error * if we cannot lock the tuple */ ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); } else { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("unable to lock hypertable catalog tuple, lock result is %d for " "hypertable " "ID (%d)", ti->lockresult, dimension_slice_id))); } } dimension_slice_formdata_fill(form, ti); ItemPointer result_tid = ts_scanner_get_tuple_tid(ti); tid->ip_blkid = result_tid->ip_blkid; tid->ip_posid = result_tid->ip_posid; success = true; break; } ts_scan_iterator_close(&iterator); return success; } /* update the tuple at this tid. The assumption is that we already hold a * tuple exclusive lock and no other transaction can modify this tuple * The sequence of operations for any update is: * lock the tuple using lock_hypertable_tuple. * then update the required fields * call dimension_slice_update_catalog_tuple to complete the update. * This ensures correct tuple locking and tuple updates in the presence of * concurrent transactions. Failure to follow this results in catalog corruption */ static void dimension_slice_update_catalog_tuple(ItemPointer tid, FormData_dimension_slice *update) { HeapTuple new_tuple; CatalogSecurityContext sec_ctx; Catalog *catalog = ts_catalog_get(); Oid table = catalog_get_table_id(catalog, DIMENSION_SLICE); Relation dimension_slice_rel = relation_open(table, RowExclusiveLock); new_tuple = dimension_slice_formdata_make_tuple(update, dimension_slice_rel->rd_att); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(dimension_slice_rel, tid, new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); relation_close(dimension_slice_rel, NoLock); } /* delete the tuple at this tid. The assumption is that we already hold a * tuple exclusive lock and no other transaction can modify this tuple * The sequence of operations for any delete is: * lock the tuple using lock_hypertable_tuple. * call dimension_slice_delete_catalog_tuple to complete the delete. * This ensures correct tuple locking and tuple deletes in the presence of * concurrent transactions. Failure to follow this results in catalog corruption */ static void dimension_slice_delete_catalog_tuple(ItemPointer tid) { CatalogSecurityContext sec_ctx; Catalog *catalog = ts_catalog_get(); Oid table = catalog_get_table_id(catalog, DIMENSION_SLICE); Relation dimension_slice_rel = relation_open(table, RowExclusiveLock); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(dimension_slice_rel, tid); ts_catalog_restore_user(&sec_ctx); relation_close(dimension_slice_rel, NoLock); } DimensionSlice * ts_dimension_slice_create(int dimension_id, int64 range_start, int64 range_end) { DimensionSlice *slice = dimension_slice_alloc(); slice->fd.dimension_id = dimension_id; slice->fd.range_start = range_start; slice->fd.range_end = range_end; return slice; } int ts_dimension_slice_cmp(const DimensionSlice *left, const DimensionSlice *right) { int res = DIMENSION_SLICE_RANGE_START_CMP(left, right); if (res == 0) res = DIMENSION_SLICE_RANGE_END_CMP(left, right); return res; } int ts_dimension_slice_cmp_coordinate(const DimensionSlice *slice, int64 coord) { coord = REMAP_LAST_COORDINATE(coord); if (coord < slice->fd.range_start) return -1; if (coord >= slice->fd.range_end) return 1; return 0; } static bool tuple_is_deleted(TupleInfo *ti) { #ifdef USE_ASSERT_CHECKING if (ti->lockresult == TM_Deleted) Assert(ItemPointerEquals(ts_scanner_get_tuple_tid(ti), &ti->lockfd.ctid)); #endif return ti->lockresult == TM_Deleted; } static void lock_result_ok_or_abort(TupleInfo *ti) { switch (ti->lockresult) { /* Updating a tuple in the same transaction before taking a lock is OK * even though it is not expected in this case */ case TM_SelfModified: case TM_Ok: break; case TM_Deleted: case TM_Updated: ereport(ERROR, (errcode(ERRCODE_LOCK_NOT_AVAILABLE), errmsg("chunk %s by other transaction", tuple_is_deleted(ti) ? "deleted" : "updated"), errhint("Retry the operation again."))); pg_unreachable(); break; case TM_BeingModified: ereport(ERROR, (errcode(ERRCODE_LOCK_NOT_AVAILABLE), errmsg("chunk updated by other transaction"), errhint("Retry the operation again."))); pg_unreachable(); break; case TM_Invisible: elog(ERROR, "attempt to lock invisible tuple"); pg_unreachable(); break; case TM_WouldBlock: default: elog(ERROR, "unexpected tuple lock status: %d", ti->lockresult); pg_unreachable(); break; } } static ScanTupleResult dimension_vec_tuple_found_list(TupleInfo *ti, void *data) { List **slices = (List **) data; DimensionSlice *slice; MemoryContext old; switch (ti->lockresult) { case TM_SelfModified: case TM_Ok: break; case TM_Deleted: case TM_Updated: /* Treat as not found */ return SCAN_CONTINUE; default: elog(ERROR, "unexpected tuple lock status: %d", ti->lockresult); pg_unreachable(); break; } old = MemoryContextSwitchTo(ti->mctx); slice = dimension_slice_from_slot(ti->slot); Assert(NULL != slice); *slices = lappend(*slices, slice); MemoryContextSwitchTo(old); return SCAN_CONTINUE; } static ScanTupleResult dimension_vec_tuple_found(TupleInfo *ti, void *data) { DimensionVec **slices = (DimensionVec **) data; DimensionSlice *slice; MemoryContext old; switch (ti->lockresult) { case TM_SelfModified: case TM_Ok: break; case TM_Deleted: case TM_Updated: /* Treat as not found */ return SCAN_CONTINUE; default: elog(ERROR, "unexpected tuple lock status: %d", ti->lockresult); pg_unreachable(); break; } old = MemoryContextSwitchTo(ti->mctx); slice = dimension_slice_from_slot(ti->slot); Assert(NULL != slice); *slices = ts_dimension_vec_add_slice(slices, slice); MemoryContextSwitchTo(old); return SCAN_CONTINUE; } static int dimension_slice_scan_limit_direction_internal(int indexid, ScanKeyData *scankey, int nkeys, tuple_found_func on_tuple_found, void *scandata, int limit, ScanDirection scandir, LOCKMODE lockmode, const ScanTupLock *tuplock, MemoryContext mctx) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, DIMENSION_SLICE), .index = catalog_get_index(catalog, DIMENSION_SLICE, indexid), .nkeys = nkeys, .scankey = scankey, .data = scandata, .limit = limit, .tuplock = tuplock, .tuple_found = on_tuple_found, .lockmode = lockmode, .scandirection = scandir, .result_mctx = mctx, }; return ts_scanner_scan(&scanctx); } static int dimension_slice_scan_limit_internal(int indexid, ScanKeyData *scankey, int nkeys, tuple_found_func on_tuple_found, void *scandata, int limit, LOCKMODE lockmode, const ScanTupLock *tuplock, MemoryContext mctx) { /* * We have =, <=, > ops for index columns, so backwards scan direction is * more appropriate. Forward direction wouldn't be able to use the second * column to find a starting point for the scan. Unfortunately we can't do * anything about the third column, we'll be checking for it with a * sequential scan over index pages. Ideally we need some other index type * than btree for this. */ return dimension_slice_scan_limit_direction_internal(indexid, scankey, nkeys, on_tuple_found, scandata, limit, BackwardScanDirection, lockmode, tuplock, mctx); } /* * Scan for slices that enclose the coordinate in the given dimension. * * Returns a dimension vector of slices that enclose the coordinate. */ DimensionVec * ts_dimension_slice_scan_limit(int32 dimension_id, int64 coordinate, int limit, const ScanTupLock *slice_lock) { ScanKeyData scankey[3]; DimensionVec *slices = ts_dimension_vec_create(limit > 0 ? limit : DIMENSION_VEC_DEFAULT_SIZE); coordinate = REMAP_LAST_COORDINATE(coordinate); /* * Perform an index scan for slices matching the dimension's ID and which * enclose the coordinate. */ ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); ScanKeyInit(&scankey[1], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, BTLessEqualStrategyNumber, F_INT8LE, Int64GetDatum(coordinate)); ScanKeyInit(&scankey[2], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, BTGreaterStrategyNumber, F_INT8GT, Int64GetDatum(coordinate)); dimension_slice_scan_limit_internal(DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 3, dimension_vec_tuple_found, (void *) &slices, limit, AccessShareLock, slice_lock, CurrentMemoryContext); return ts_dimension_vec_sort(&slices); } void ts_dimension_slice_scan_list(int32 dimension_id, int64 coordinate, List **matching_dimension_slices, const ScanTupLock *slice_lock) { coordinate = REMAP_LAST_COORDINATE(coordinate); /* * Perform an index scan for slices matching the dimension's ID and which * enclose the coordinate. */ ScanKeyData scankey[3]; ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); ScanKeyInit(&scankey[1], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, BTLessEqualStrategyNumber, F_INT8LE, Int64GetDatum(coordinate)); ScanKeyInit(&scankey[2], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, BTGreaterStrategyNumber, F_INT8GT, Int64GetDatum(coordinate)); dimension_slice_scan_limit_internal(DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 3, dimension_vec_tuple_found_list, (void *) matching_dimension_slices, /* limit = */ 0, AccessShareLock, slice_lock, CurrentMemoryContext); } int ts_dimension_slice_scan_iterator_set_range(ScanIterator *it, int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value) { Catalog *catalog = ts_catalog_get(); it->ctx.index = catalog_get_index(catalog, DIMENSION_SLICE, DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init( it, Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); /* * Perform an index scan for slices matching the dimension's ID and which * enclose the coordinate. */ if (start_strategy != InvalidStrategy) { Oid opno = get_opfamily_member(INTEGER_BTREE_FAM_OID, INT8OID, INT8OID, start_strategy); Oid proc = get_opcode(opno); Assert(OidIsValid(proc)); ts_scan_iterator_scan_key_init( it, Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, start_strategy, proc, Int64GetDatum(start_value)); } if (end_strategy != InvalidStrategy) { Oid opno = get_opfamily_member(INTEGER_BTREE_FAM_OID, INT8OID, INT8OID, end_strategy); Oid proc = get_opcode(opno); Assert(OidIsValid(proc)); /* * range_end is stored as exclusive, so add 1 to the value being * searched. Also avoid overflow */ if (end_value != PG_INT64_MAX) { end_value++; /* * If getting as input INT64_MAX-1, need to remap the incremented * value back to INT64_MAX-1 */ end_value = REMAP_LAST_COORDINATE(end_value); } else { /* * The point with INT64_MAX gets mapped to INT64_MAX-1 so * incrementing that gets you to INT_64MAX */ end_value = PG_INT64_MAX; } ts_scan_iterator_scan_key_init( it, Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, end_strategy, proc, Int64GetDatum(end_value)); } return it->ctx.nkeys; } /* * Look for all dimension slices where (lower_bound, upper_bound) of the dimension_slice contains * the given (start_value, end_value) range * */ DimensionVec * ts_dimension_slice_scan_range_limit(int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value, int limit, const ScanTupLock *tuplock) { DimensionVec *slices = ts_dimension_vec_create(limit > 0 ? limit : DIMENSION_VEC_DEFAULT_SIZE); ScanIterator it = ts_dimension_slice_scan_iterator_create(tuplock, CurrentMemoryContext); ts_dimension_slice_scan_iterator_set_range(&it, dimension_id, start_strategy, start_value, end_strategy, end_value); it.ctx.limit = limit; ts_scanner_foreach(&it) { const TupleInfo *ti = ts_scan_iterator_tuple_info(&it); DimensionSlice *slice; MemoryContext old; switch (ti->lockresult) { case TM_SelfModified: case TM_Ok: old = MemoryContextSwitchTo(ti->mctx); slice = dimension_slice_from_slot(ti->slot); Assert(NULL != slice); slices = ts_dimension_vec_add_slice(&slices, slice); MemoryContextSwitchTo(old); break; case TM_Deleted: case TM_Updated: /* Treat as not found */ break; default: elog(ERROR, "unexpected tuple lock status: %d", ti->lockresult); pg_unreachable(); break; } } Assert(limit <= 0 || slices->num_slices <= limit); ts_scan_iterator_close(&it); return ts_dimension_vec_sort(&slices); } /* * Scan for slices that collide/overlap with the given range. * * Returns a dimension vector of colliding slices. */ DimensionVec * ts_dimension_slice_collision_scan_limit(int32 dimension_id, int64 range_start, int64 range_end, int limit) { ScanKeyData scankey[3]; DimensionVec *slices = ts_dimension_vec_create(limit > 0 ? limit : DIMENSION_VEC_DEFAULT_SIZE); ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); ScanKeyInit(&scankey[1], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, BTLessStrategyNumber, F_INT8LT, Int64GetDatum(range_end)); ScanKeyInit(&scankey[2], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, BTGreaterStrategyNumber, F_INT8GT, Int64GetDatum(range_start)); dimension_slice_scan_limit_internal(DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 3, dimension_vec_tuple_found, (void *) &slices, limit, AccessShareLock, NULL, CurrentMemoryContext); return ts_dimension_vec_sort(&slices); } DimensionVec * ts_dimension_slice_scan_by_dimension(int32 dimension_id, int limit) { ScanKeyData scankey[1]; DimensionVec *slices = ts_dimension_vec_create(limit > 0 ? limit : DIMENSION_VEC_DEFAULT_SIZE); ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); dimension_slice_scan_limit_internal(DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 1, dimension_vec_tuple_found, (void *) &slices, limit, AccessShareLock, NULL, CurrentMemoryContext); return ts_dimension_vec_sort(&slices); } /* * Return slices that occur "before" the given point. * * The slices will be allocated on the given memory context. Note, however, that * the returned dimension vector is allocated on the current memory context. */ DimensionVec * ts_dimension_slice_scan_by_dimension_before_point(int32 dimension_id, int64 point, int limit, ScanDirection scandir, MemoryContext mctx) { ScanKeyData scankey[3]; DimensionVec *slices = ts_dimension_vec_create(limit > 0 ? limit : DIMENSION_VEC_DEFAULT_SIZE); ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); ScanKeyInit(&scankey[1], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, BTLessStrategyNumber, F_INT8LT, Int64GetDatum(point)); ScanKeyInit(&scankey[2], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, BTLessStrategyNumber, F_INT8LT, Int64GetDatum(point)); dimension_slice_scan_limit_direction_internal( DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 3, dimension_vec_tuple_found, (void *) &slices, limit, scandir, AccessShareLock, NULL, mctx); return ts_dimension_vec_sort(&slices); } static ScanTupleResult dimension_slice_tuple_delete(TupleInfo *ti, void *data) { bool isnull; Datum dimension_slice_id = slot_getattr(ti->slot, Anum_dimension_slice_id, &isnull); if (ti->lockresult != TM_Ok) { if (IsolationUsesXactSnapshot()) { /* For Repeatable Read and Serializable isolation level report error * if we cannot lock the tuple */ ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); } else { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("unable to lock hypertable catalog tuple, lock result is %d for " "hypertable " "ID (%d)", ti->lockresult, DatumGetInt32(dimension_slice_id)))); } } bool *delete_constraints = data; CatalogSecurityContext sec_ctx; Assert(!isnull); /* delete chunk constraints */ if (NULL != delete_constraints && *delete_constraints) ts_chunk_constraint_delete_by_dimension_slice_id(DatumGetInt32(dimension_slice_id)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); return SCAN_CONTINUE; } int ts_dimension_slice_delete_by_dimension_id(int32 dimension_id, bool delete_constraints) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; return dimension_slice_scan_limit_internal( DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 1, dimension_slice_tuple_delete, (void *) &delete_constraints, 0, RowExclusiveLock, &scantuplock, CurrentMemoryContext); } int ts_dimension_slice_delete_by_id(int32 dimension_slice_id, bool delete_constraints) { FormData_dimension_slice form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_dimension_slice_tuple(dimension_slice_id, &tid, &form); Ensure(found, "dimension slice id %d not found", dimension_slice_id); dimension_slice_delete_catalog_tuple(&tid); return true; } static ScanTupleResult dimension_slice_fill(TupleInfo *ti, void *data) { switch (ti->lockresult) { case TM_SelfModified: case TM_Ok: { DimensionSlice **slice = (DimensionSlice **) data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); memcpy(&(*slice)->fd, GETSTRUCT(tuple), sizeof(FormData_dimension_slice)); if (should_free) heap_freetuple(tuple); break; } case TM_Deleted: case TM_Updated: /* Same as not found */ break; default: elog(ERROR, "unexpected tuple lock status: %d", ti->lockresult); pg_unreachable(); break; } return SCAN_DONE; } /* * Scan for an existing slice that exactly matches the given slice's dimension * and range. If a match is found, the given slice is updated with slice ID * and the tuple is locked. * * Returns true if the dimension slice was found (and locked), false * otherwise. */ bool ts_dimension_slice_scan_for_existing(const DimensionSlice *slice, const ScanTupLock *tuplock) { ScanKeyData scankey[3]; ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(slice->fd.dimension_id)); ScanKeyInit(&scankey[1], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, BTEqualStrategyNumber, F_INT8EQ, Int64GetDatum(slice->fd.range_start)); ScanKeyInit(&scankey[2], Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, BTEqualStrategyNumber, F_INT8EQ, Int64GetDatum(slice->fd.range_end)); return dimension_slice_scan_limit_internal( DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 3, dimension_slice_fill, (void *) &slice, 1, AccessShareLock, tuplock, CurrentMemoryContext); } DimensionSlice * ts_dimension_slice_from_tuple(TupleInfo *ti) { DimensionSlice *slice; MemoryContext old; lock_result_ok_or_abort(ti); old = MemoryContextSwitchTo(ti->mctx); slice = dimension_slice_from_slot(ti->slot); MemoryContextSwitchTo(old); return slice; } static ScanTupleResult dimension_slice_tuple_found(TupleInfo *ti, void *data) { DimensionSlice **slice = (DimensionSlice **) data; *slice = ts_dimension_slice_from_tuple(ti); return SCAN_DONE; } /* Scan for a slice by dimension slice id. * * If you're scanning for a tuple, you have to provide a lock, since, otherwise, * concurrent threads can do bad things with the tuple and you probably want * it to not change nor disappear. */ DimensionSlice * ts_dimension_slice_scan_by_id_and_lock(int32 dimension_slice_id, const ScanTupLock *tuplock, MemoryContext mctx, LOCKMODE lockmode) { DimensionSlice *slice = NULL; ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_dimension_slice_id_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_slice_id)); dimension_slice_scan_limit_internal(DIMENSION_SLICE_ID_IDX, scankey, 1, dimension_slice_tuple_found, (void *) &slice, 1, lockmode, tuplock, mctx); return slice; } ScanIterator ts_dimension_slice_scan_iterator_create(const ScanTupLock *tuplock, MemoryContext result_mcxt) { ScanIterator it = ts_scan_iterator_create(DIMENSION_SLICE, AccessShareLock, result_mcxt); it.ctx.flags |= SCANNER_F_NOEND_AND_NOCLOSE; it.ctx.tuplock = RecoveryInProgress() ? NULL : tuplock; return it; } void ts_dimension_slice_scan_iterator_set_slice_id(ScanIterator *it, int32 slice_id) { it->ctx.index = catalog_get_index(ts_catalog_get(), DIMENSION_SLICE, DIMENSION_SLICE_ID_IDX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init(it, Anum_dimension_slice_id_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(slice_id)); } DimensionSlice * ts_dimension_slice_scan_iterator_get_by_id(ScanIterator *it, int32 slice_id) { TupleInfo *ti; DimensionSlice *slice = NULL; ts_dimension_slice_scan_iterator_set_slice_id(it, slice_id); ts_scan_iterator_start_or_restart_scan(it); ti = ts_scan_iterator_next(it); Assert(ti); if (ti) { slice = ts_dimension_slice_from_tuple(ti); Assert(ts_scan_iterator_next(it) == NULL); } return slice; } DimensionSlice * ts_dimension_slice_copy(const DimensionSlice *original) { DimensionSlice *new = palloc(sizeof(DimensionSlice)); Assert(original->storage == NULL); Assert(original->storage_free == NULL); memcpy(new, original, sizeof(DimensionSlice)); return new; } /* * Check if two dimensions slices overlap by doing collision detection in one * dimension. * * Returns true if the slices collide, otherwise false. */ bool ts_dimension_slices_collide(const DimensionSlice *slice1, const DimensionSlice *slice2) { Assert(slice1->fd.dimension_id == slice2->fd.dimension_id); return (slice1->fd.range_start < slice2->fd.range_end && slice1->fd.range_end > slice2->fd.range_start); } /* * Check whether two slices are identical. * * We require by assertion that the slices are in the same dimension and we only * compare the ranges (i.e., the slice ID is not important for equality). * * Returns true if the slices have identical ranges, otherwise false. */ bool ts_dimension_slices_equal(const DimensionSlice *slice1, const DimensionSlice *slice2) { Assert(slice1->fd.dimension_id == slice2->fd.dimension_id); return slice1->fd.range_start == slice2->fd.range_start && slice1->fd.range_end == slice2->fd.range_end; } /*- * Cut a slice that collides with another slice. The coordinate is the point of * insertion, and determines which end of the slice to cut. * * Case where we cut "after" the coordinate: * * ' [-x--------] * ' [--------] * * Case where we cut "before" the coordinate: * * ' [------x--] * ' [--------] * * Returns true if the slice was cut, otherwise false. */ bool ts_dimension_slice_cut(DimensionSlice *to_cut, const DimensionSlice *other, int64 coord) { Assert(to_cut->fd.dimension_id == other->fd.dimension_id); coord = REMAP_LAST_COORDINATE(coord); if (other->fd.range_end <= coord && other->fd.range_end > to_cut->fd.range_start) { /* Cut "before" the coordinate */ to_cut->fd.range_start = other->fd.range_end; return true; } else if (other->fd.range_start > coord && other->fd.range_start < to_cut->fd.range_end) { /* Cut "after" the coordinate */ to_cut->fd.range_end = other->fd.range_start; return true; } return false; } void ts_dimension_slice_free(DimensionSlice *slice) { if (slice->storage_free != NULL) slice->storage_free(slice->storage); pfree(slice); } static bool dimension_slice_insert_relation(const Relation rel, DimensionSlice *slice) { TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_dimension_slice]; bool nulls[Natts_dimension_slice] = { false }; CatalogSecurityContext sec_ctx; if (slice->fd.id > 0) /* Slice already exists in table */ return false; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); memset(values, 0, sizeof(values)); slice->fd.id = ts_catalog_table_next_seq_id(ts_catalog_get(), DIMENSION_SLICE); values[AttrNumberGetAttrOffset(Anum_dimension_slice_id)] = Int32GetDatum(slice->fd.id); values[AttrNumberGetAttrOffset(Anum_dimension_slice_dimension_id)] = Int32GetDatum(slice->fd.dimension_id); values[AttrNumberGetAttrOffset(Anum_dimension_slice_range_start)] = Int64GetDatum(slice->fd.range_start); values[AttrNumberGetAttrOffset(Anum_dimension_slice_range_end)] = Int64GetDatum(slice->fd.range_end); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); return true; } /* * Insert slices into the catalog. * * Only slices that don't already exist in the catalog will be inserted. Note * that all slices that already exist (i.e., have a valid ID) MUST be locked * with a tuple lock (e.g., FOR KEY SHARE) prior to calling this function * since they won't be created. Otherwise it is not possible to guarantee that * all slices still exist once the transaction commits. * * Returns the number of slices inserted. */ int ts_dimension_slice_insert_multi(DimensionSlice **slices, Size num_slices) { Catalog *catalog = ts_catalog_get(); Relation rel; Size i, n = 0; rel = table_open(catalog_get_table_id(catalog, DIMENSION_SLICE), RowExclusiveLock); for (i = 0; i < num_slices; i++) { if (slices[i]->fd.id == 0) { dimension_slice_insert_relation(rel, slices[i]); n++; } } table_close(rel, RowExclusiveLock); return n; } void ts_dimension_slice_insert(DimensionSlice *slice) { Catalog *catalog = ts_catalog_get(); Relation rel; rel = table_open(catalog_get_table_id(catalog, DIMENSION_SLICE), RowExclusiveLock); dimension_slice_insert_relation(rel, slice); /* Keeping a row lock to prevent VACUUM or ALTER TABLE from running while working on the table. * This is known to cause issues in certain situations. */ table_close(rel, NoLock); } static ScanTupleResult dimension_slice_nth_tuple_found(TupleInfo *ti, void *data) { DimensionSlice **slice = (DimensionSlice **) data; MemoryContext old = MemoryContextSwitchTo(ti->mctx); *slice = dimension_slice_from_slot(ti->slot); MemoryContextSwitchTo(old); return SCAN_CONTINUE; } DimensionSlice * ts_dimension_slice_nth_latest_slice(int32 dimension_id, int n) { ScanKeyData scankey[1]; int num_tuples; DimensionSlice *ret = NULL; ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); num_tuples = dimension_slice_scan_limit_direction_internal( DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 1, dimension_slice_nth_tuple_found, (void *) &ret, n, BackwardScanDirection, AccessShareLock, NULL, CurrentMemoryContext); if (num_tuples < n) return NULL; return ret; } DimensionSlice * ts_dimension_slice_nth_earliest_slice(int32 dimension_id, int n) { ScanKeyData scankey[1]; int num_tuples; DimensionSlice *ret = NULL; ScanKeyInit(&scankey[0], Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(dimension_id)); num_tuples = dimension_slice_scan_limit_direction_internal( DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, scankey, 1, dimension_slice_nth_tuple_found, (void *) &ret, n, ForwardScanDirection, AccessShareLock, NULL, CurrentMemoryContext); if (num_tuples < n) return NULL; return ret; } int32 ts_dimension_slice_oldest_valid_chunk_for_reorder(int32 job_id, int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value) { int32 result_chunk_id = -1; ScanIterator it = ts_dimension_slice_scan_iterator_create(NULL, CurrentMemoryContext); bool done = false; ts_dimension_slice_scan_iterator_set_range(&it, dimension_id, start_strategy, start_value, end_strategy, end_value); ts_scan_iterator_start_scan(&it); while (!done) { const TupleInfo *ti = ts_scan_iterator_next(&it); ListCell *lc; DimensionSlice *slice; List *chunk_ids = NIL; if (NULL == ti) break; slice = dimension_slice_from_slot(ti->slot); ts_chunk_constraint_scan_by_dimension_slice_to_list(slice, &chunk_ids, CurrentMemoryContext); foreach (lc, chunk_ids) { /* Look for a chunk that a) doesn't have a job stat (reorder ) and b) is not compressed * (should not reorder a compressed chunk) */ int32 chunk_id = lfirst_int(lc); BgwPolicyChunkStats *chunk_stat = ts_bgw_policy_chunk_stats_find(job_id, chunk_id); if ((chunk_stat == NULL || chunk_stat->fd.num_times_job_run == 0) && ts_chunk_get_compression_status(chunk_id) == CHUNK_COMPRESS_NONE) { /* Save the chunk_id */ result_chunk_id = chunk_id; done = true; break; } } } ts_scan_iterator_close(&it); return result_chunk_id; } List * ts_dimension_slice_get_chunkids_to_compress(int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value, bool compress, bool recompress, int32 numchunks) { List *chunk_ids = NIL; int32 maxchunks = numchunks > 0 ? numchunks : -1; ScanIterator it = ts_dimension_slice_scan_iterator_create(NULL, CurrentMemoryContext); bool done = false; ts_dimension_slice_scan_iterator_set_range(&it, dimension_id, start_strategy, start_value, end_strategy, end_value); ts_scan_iterator_start_scan(&it); while (!done) { DimensionSlice *slice; TupleInfo *ti; ListCell *lc; List *slice_chunk_ids = NIL; ti = ts_scan_iterator_next(&it); if (NULL == ti) break; slice = dimension_slice_from_slot(ti->slot); ts_chunk_constraint_scan_by_dimension_slice_to_list(slice, &slice_chunk_ids, CurrentMemoryContext); foreach (lc, slice_chunk_ids) { int32 chunk_id = lfirst_int(lc); ChunkCompressionStatus st = ts_chunk_get_compression_status(chunk_id); if ((compress && st == CHUNK_COMPRESS_NONE) || (recompress && st == CHUNK_COMPRESS_UNORDERED)) { /* found a chunk that is not compressed or needs recompress * caller needs to check the correct chunk status */ chunk_ids = lappend_int(chunk_ids, chunk_id); if (maxchunks > 0 && list_length(chunk_ids) >= maxchunks) { done = true; break; } } } } ts_scan_iterator_close(&it); return chunk_ids; } /* This function checks for overlap between the range we want to update for the OSM chunk and the chunks currently in timescaledb (not managed by OSM) */ bool ts_osm_chunk_range_overlaps(int32 osm_dimension_slice_id, int32 dimension_id, int64 range_start, int64 range_end) { bool res; DimensionVec *vec = dimension_slice_collision_scan(dimension_id, range_start, range_end); /* there is only one dimension slice for the OSM chunk. The OSM chunk may not * necessarily appear in the list of overlapping ranges because when first tiered, * it is given a range [max, infinity) */ if (vec->num_slices >= 2 || (vec->num_slices == 1 && vec->slices[0]->fd.id != osm_dimension_slice_id)) res = true; else res = false; pfree(vec); return res; } int ts_dimension_slice_range_update(DimensionSlice *slice) { FormData_dimension_slice form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_dimension_slice_tuple(slice->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", slice->fd.id); if (form.range_start != slice->fd.range_start || form.range_end != slice->fd.range_end) { form.range_start = slice->fd.range_start; form.range_end = slice->fd.range_end; dimension_slice_update_catalog_tuple(&tid, &form); } return true; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/dimension_slice.h������������������������������������������������������������0000664�0000000�0000000�00000014261�15100345067�0020163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pg_list.h> #include "chunk_constraint.h" /* Put DIMENSION_SLICE_MAXVALUE point in same slice as DIMENSION_SLICE_MAXVALUE-1, always */ /* This avoids the problem with coord < range_end where coord and range_end is an int64 */ #define REMAP_LAST_COORDINATE(coord) \ (((coord) == DIMENSION_SLICE_MAXVALUE) ? DIMENSION_SLICE_MAXVALUE - 1 : (coord)) #define DIMENSION_SLICE_MAXVALUE ((int64) PG_INT64_MAX) #define DIMENSION_SLICE_MINVALUE ((int64) PG_INT64_MIN) /* partition functions return int32 */ #define DIMENSION_SLICE_CLOSED_MAX ((int64) PG_INT32_MAX) #define VALUE_GT(v1, v2) ((v1) > (v2)) #define VALUE_LT(v1, v2) ((v1) < (v2)) /* * Compare two values, returning -1, 1, 0 if the left one is, less, greater, * or equal to the right one, respectively. */ #define VALUE_CMP(v1, v2) VALUE_GT(v1, v2) - VALUE_LT(v1, v2) /* Compare the range start values of two slices */ #define DIMENSION_SLICE_RANGE_START_CMP(s1, s2) \ VALUE_CMP((s1)->fd.range_start, (s2)->fd.range_start) /* Compare the range end values of two slices */ #define DIMENSION_SLICE_RANGE_END_CMP(s1, s2) VALUE_CMP((s1)->fd.range_end, (s2)->fd.range_end) typedef struct DimensionSlice { FormData_dimension_slice fd; void (*storage_free)(void *); void *storage; } DimensionSlice; typedef struct DimensionVec DimensionVec; typedef struct Hypercube Hypercube; extern DimensionVec *ts_dimension_slice_scan_limit(int32 dimension_id, int64 coordinate, int limit, const ScanTupLock *slice_lock); extern void ts_dimension_slice_scan_list(int32 dimension_id, int64 coordinate, List **matching_dimension_slices, const ScanTupLock *slice_lock); extern DimensionVec * ts_dimension_slice_scan_range_limit(int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value, int limit, const ScanTupLock *tuplock); extern DimensionVec *ts_dimension_slice_collision_scan_limit(int32 dimension_id, int64 range_start, int64 range_end, int limit); extern TSDLLEXPORT bool ts_dimension_slice_scan_for_existing(const DimensionSlice *slice, const ScanTupLock *tuplock); extern DimensionSlice *ts_dimension_slice_scan_by_id_and_lock(int32 dimension_slice_id, const ScanTupLock *tuplock, MemoryContext mctx, LOCKMODE lockmode); extern DimensionVec *ts_dimension_slice_scan_by_dimension(int32 dimension_id, int limit); extern DimensionVec *ts_dimension_slice_scan_by_dimension_before_point(int32 dimension_id, int64 point, int limit, ScanDirection scandir, MemoryContext mctx); extern int ts_dimension_slice_delete_by_dimension_id(int32 dimension_id, bool delete_constraints); extern TSDLLEXPORT int ts_dimension_slice_delete_by_id(int32 dimension_slice_id, bool delete_constraints); extern TSDLLEXPORT DimensionSlice *ts_dimension_slice_create(int dimension_id, int64 range_start, int64 range_end); extern TSDLLEXPORT DimensionSlice *ts_dimension_slice_copy(const DimensionSlice *original); extern TSDLLEXPORT bool ts_dimension_slices_collide(const DimensionSlice *slice1, const DimensionSlice *slice2); extern TSDLLEXPORT bool ts_dimension_slices_equal(const DimensionSlice *slice1, const DimensionSlice *slice2); extern bool ts_dimension_slice_cut(DimensionSlice *to_cut, const DimensionSlice *other, int64 coord); extern void ts_dimension_slice_free(DimensionSlice *slice); extern int ts_dimension_slice_insert_multi(DimensionSlice **slice, Size num_slices); extern TSDLLEXPORT void ts_dimension_slice_insert(DimensionSlice *slice); extern int ts_dimension_slice_cmp(const DimensionSlice *left, const DimensionSlice *right); extern int ts_dimension_slice_cmp_coordinate(const DimensionSlice *slice, int64 coord); extern TSDLLEXPORT DimensionSlice *ts_dimension_slice_nth_latest_slice(int32 dimension_id, int n); extern TSDLLEXPORT DimensionSlice *ts_dimension_slice_nth_earliest_slice(int32 dimension_id, int n); extern TSDLLEXPORT int32 ts_dimension_slice_oldest_valid_chunk_for_reorder( int32 job_id, int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value); extern TSDLLEXPORT List *ts_dimension_slice_get_chunkids_to_compress( int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value, bool compress, bool recompress, int32 numchunks); extern DimensionSlice *ts_dimension_slice_from_tuple(TupleInfo *ti); extern ScanIterator ts_dimension_slice_scan_iterator_create(const ScanTupLock *tuplock, MemoryContext result_mcxt); extern void ts_dimension_slice_scan_iterator_set_slice_id(ScanIterator *it, int32 slice_id); extern DimensionSlice *ts_dimension_slice_scan_iterator_get_by_id(ScanIterator *it, int32 slice_id); extern int ts_dimension_slice_scan_iterator_set_range(ScanIterator *it, int32 dimension_id, StrategyNumber start_strategy, int64 start_value, StrategyNumber end_strategy, int64 end_value); extern bool ts_osm_chunk_range_overlaps(int32 osm_dimension_slice_id, int32 dimension_id, int64 range_start, int64 range_end); extern int ts_dimension_slice_range_update(DimensionSlice *slice); #define dimension_slice_insert(slice) ts_dimension_slice_insert_multi(&(slice), 1) #define dimension_slice_scan(dimension_id, coordinate, tuplock) \ ts_dimension_slice_scan_limit(dimension_id, coordinate, 0, tuplock) #define dimension_slice_collision_scan(dimension_id, range_start, range_end) \ ts_dimension_slice_collision_scan_limit(dimension_id, range_start, range_end, 0) DimensionSlice *ts_chunk_get_osm_slice_and_lock(int32 osm_chunk_id, int32 time_dim_id, LockTupleMode tuplockmode, LOCKMODE tablelockmode); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/dimension_vector.c�����������������������������������������������������������0000664�0000000�0000000�00000007616�15100345067�0020367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include "dimension_vector.h" static int cmp_slices(const void *left, const void *right) { const DimensionSlice *left_slice = *((DimensionSlice **) left); const DimensionSlice *right_slice = *((DimensionSlice **) right); return ts_dimension_slice_cmp(left_slice, right_slice); } static int cmp_coordinate_and_slice(const void *left, const void *right) { int64 coord = *((int64 *) left); const DimensionSlice *slice = *((DimensionSlice **) right); return ts_dimension_slice_cmp_coordinate(slice, coord); } static DimensionVec * dimension_vec_expand(DimensionVec *vec, int32 new_capacity) { if (vec != NULL && vec->capacity >= new_capacity) return vec; if (NULL == vec) vec = palloc(DIMENSION_VEC_SIZE(new_capacity)); else vec = repalloc(vec, DIMENSION_VEC_SIZE(new_capacity)); vec->capacity = new_capacity; return vec; } DimensionVec * ts_dimension_vec_create(int32 initial_num_slices) { DimensionVec *vec = dimension_vec_expand(NULL, initial_num_slices); vec->capacity = initial_num_slices; vec->num_slices = 0; return vec; } DimensionVec * ts_dimension_vec_sort(DimensionVec **vecptr) { DimensionVec *vec = *vecptr; if (vec->num_slices > 1) qsort((void *) vec->slices, vec->num_slices, sizeof(DimensionSlice *), cmp_slices); return vec; } DimensionVec * ts_dimension_vec_add_slice(DimensionVec **vecptr, DimensionSlice *slice) { DimensionVec *vec = *vecptr; /* Ensure consistent dimension */ Assert(vec->num_slices == 0 || vec->slices[0]->fd.dimension_id == slice->fd.dimension_id); if (vec->num_slices + 1 > vec->capacity) *vecptr = vec = dimension_vec_expand(vec, vec->capacity + 10); vec->slices[vec->num_slices++] = slice; return vec; } DimensionVec * ts_dimension_vec_add_unique_slice(DimensionVec **vecptr, DimensionSlice *slice) { DimensionVec *vec = *vecptr; int32 existing_slice_index = ts_dimension_vec_find_slice_index(vec, slice->fd.id); if (existing_slice_index == -1) return ts_dimension_vec_add_slice(vecptr, slice); return vec; } DimensionVec * ts_dimension_vec_add_slice_sort(DimensionVec **vecptr, DimensionSlice *slice) { *vecptr = ts_dimension_vec_add_slice(vecptr, slice); return ts_dimension_vec_sort(vecptr); } void ts_dimension_vec_remove_slice(DimensionVec **vecptr, int32 index) { DimensionVec *vec = *vecptr; ts_dimension_slice_free(vec->slices[index]); memmove((void *) &vec->slices[index], (void *) &vec->slices[index + 1], sizeof(DimensionSlice *) * (vec->num_slices - index - 1)); vec->num_slices--; } #if defined(USE_ASSERT_CHECKING) static inline bool dimension_vec_is_sorted(const DimensionVec *vec) { int i; if (vec->num_slices < 2) return true; for (i = 1; i < vec->num_slices; i++) if (cmp_slices((void *) &vec->slices[i - 1], (void *) &vec->slices[i]) > 0) return false; return true; } #endif DimensionSlice * ts_dimension_vec_find_slice(const DimensionVec *vec, int64 coordinate) { DimensionSlice **res; if (vec->num_slices == 0) return NULL; Assert(dimension_vec_is_sorted(vec)); res = (DimensionSlice **) bsearch(&coordinate, (void *) vec->slices, vec->num_slices, sizeof(DimensionSlice *), cmp_coordinate_and_slice); if (res == NULL) return NULL; return *res; } int ts_dimension_vec_find_slice_index(const DimensionVec *vec, int32 dimension_slice_id) { int i; for (i = 0; i < vec->num_slices; i++) if (dimension_slice_id == vec->slices[i]->fd.id) return i; return -1; } const DimensionSlice * ts_dimension_vec_get(const DimensionVec *vec, int32 index) { if (index >= vec->num_slices) return NULL; return vec->slices[index]; } void ts_dimension_vec_free(DimensionVec *vec) { int i; for (i = 0; i < vec->num_slices; i++) ts_dimension_slice_free(vec->slices[i]); pfree(vec); } ������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/dimension_vector.h�����������������������������������������������������������0000664�0000000�0000000�00000003337�15100345067�0020370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "dimension_slice.h" #include "hypertable_restrict_info.h" /* * DimensionVec is a collection of slices (ranges) along one dimension for a * time range. */ typedef struct DimensionVec { int32 capacity; /* The capacity of the slices array */ int32 num_slices; /* The current number of slices in slices * array */ DimensionRestrictInfo *dri; /* corresponding restrictinfo */ DimensionSlice *slices[FLEXIBLE_ARRAY_MEMBER]; } DimensionVec; #define DIMENSION_VEC_SIZE(num_slices) \ (sizeof(DimensionVec) + (sizeof(DimensionSlice *) * num_slices)) #define DIMENSION_VEC_DEFAULT_SIZE 10 extern DimensionVec *ts_dimension_vec_create(int32 initial_num_slices); extern DimensionVec *ts_dimension_vec_sort(DimensionVec **vec); extern DimensionVec *ts_dimension_vec_add_slice_sort(DimensionVec **vec, DimensionSlice *slice); extern DimensionVec *ts_dimension_vec_add_slice(DimensionVec **vecptr, DimensionSlice *slice); extern DimensionVec *ts_dimension_vec_add_unique_slice(DimensionVec **vecptr, DimensionSlice *slice); extern void ts_dimension_vec_remove_slice(DimensionVec **vecptr, int32 index); extern DimensionSlice *ts_dimension_vec_find_slice(const DimensionVec *vec, int64 coordinate); extern int ts_dimension_vec_find_slice_index(const DimensionVec *vec, int32 dimension_slice_id); extern const DimensionSlice *ts_dimension_vec_get(const DimensionVec *vec, int32 index); extern void ts_dimension_vec_free(DimensionVec *vec); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/error_utils.h����������������������������������������������������������������0000664�0000000�0000000�00000004175�15100345067�0017373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define GETARG_NOTNULL_OID(var, arg, name) \ { \ var = PG_ARGISNULL(arg) ? InvalidOid : PG_GETARG_OID(arg); \ if (!OidIsValid(var)) \ ereport(ERROR, \ (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \ errmsg("%s cannot be NULL", name))); \ } #define GETARG_NOTNULL_POINTER(var, arg, name, type) \ { \ if (PG_ARGISNULL(arg)) \ ereport(ERROR, \ (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \ errmsg("%s cannot be NULL", name))); \ var = (type *) PG_GETARG_POINTER(arg); \ } #define GETARG_NOTNULL_NULLABLE(var, arg, name, type) \ { \ if (PG_ARGISNULL(arg)) \ ereport(ERROR, \ (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \ errmsg("%s cannot be NULL", name))); \ var = PG_GETARG_##type(arg); \ } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/errors.h���������������������������������������������������������������������0000664�0000000�0000000�00000004163�15100345067�0016333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* Defines error codes used -- PREFIX TS */ /* -- TS000 - GROUP: query errors -- TS001 - hypertable does not exist -- TS002 - column does not exist */ #define ERRCODE_TS_QUERY_ERRORS MAKE_SQLSTATE('T', 'S', '0', '0', '0') #define ERRCODE_TS_HYPERTABLE_NOT_EXIST MAKE_SQLSTATE('T', 'S', '0', '0', '1') #define ERRCODE_TS_DIMENSION_NOT_EXIST MAKE_SQLSTATE('T', 'S', '0', '0', '2') #define ERRCODE_TS_CHUNK_NOT_EXIST MAKE_SQLSTATE('T', 'S', '0', '0', '3') /* --TS100 - GROUP: DDL errors --TS101 - operation not supported --TS102 - bad hypertable definition --TS103 - bad hypertable index definition --TS110 - hypertable already exists --TS120 - node already exists --TS130 - user already exists --TS140 - tablespace already attached --TS150 - tablespace not attached --TS160 - duplicate dimension */ #define ERRCODE_TS_DDL_ERRORS MAKE_SQLSTATE('T', 'S', '1', '0', '0') #define ERRCODE_TS_OPERATION_NOT_SUPPORTED MAKE_SQLSTATE('T', 'S', '1', '0', '1') #define ERRCODE_TS_BAD_HYPERTABLE_DEFINITION MAKE_SQLSTATE('T', 'S', '1', '0', '2') #define ERRCODE_TS_BAD_HYPERTABLE_INDEX_DEFINITION MAKE_SQLSTATE('T', 'S', '1', '0', '3') #define ERRCODE_TS_HYPERTABLE_EXISTS MAKE_SQLSTATE('T', 'S', '1', '1', '0') #define ERRCODE_TS_NODE_EXISTS MAKE_SQLSTATE('T', 'S', '1', '2', '0') #define ERRCODE_TS_USER_EXISTS MAKE_SQLSTATE('T', 'S', '1', '3', '0') #define ERRCODE_TS_TABLESPACE_ALREADY_ATTACHED MAKE_SQLSTATE('T', 'S', '1', '4', '0') #define ERRCODE_TS_TABLESPACE_NOT_ATTACHED MAKE_SQLSTATE('T', 'S', '1', '5', '0') #define ERRCODE_TS_DUPLICATE_DIMENSION MAKE_SQLSTATE('T', 'S', '1', '6', '0') #define ERRCODE_TS_INSUFFICIENT_NUM_DATA_NODES MAKE_SQLSTATE('T', 'S', '1', '7', '0') /* --IO500 - GROUP: internal error --IO501 - unexpected state/event */ #define ERRCODE_TS_INTERNAL_ERROR MAKE_SQLSTATE('T', 'S', '5', '0', '0') #define ERRCODE_TS_UNEXPECTED MAKE_SQLSTATE('T', 'S', '5', '0', '1') #define ERRCODE_TS_CHUNK_COLLISION MAKE_SQLSTATE('T', 'S', '5', '0', '3') �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/estimate.c�������������������������������������������������������������������0000664�0000000�0000000�00000014625�15100345067�0016631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <optimizer/optimizer.h> #include <parser/parse_oper.h> #include <utils/selfuncs.h> #include "compat/compat.h" #include "estimate.h" #include "func_cache.h" #include "import/planner.h" #include "utils.h" /* * This module contains functions for estimating, e.g., the number of groups * formed in various grouping expressions that involve time bucketing. */ static double estimate_max_spread_expr(PlannerInfo *root, Expr *expr); static double group_estimate_opexpr(PlannerInfo *root, OpExpr *opexpr, double path_rows); /* Estimate the max spread on a time var in terms of the internal time representation. * Note that this will happen on the hypertable var in most cases. Therefore this is * a huge overestimate in many cases where there is a WHERE clause on time. */ static double estimate_max_spread_var(PlannerInfo *root, Var *var) { VariableStatData vardata; Oid ltop; Datum max_datum, min_datum; int64 max, min; bool valid; examine_variable(root, (Node *) var, 0, &vardata); get_sort_group_operators(var->vartype, true, false, false, <op, NULL, NULL, NULL); valid = ts_get_variable_range(root, &vardata, ltop, &min_datum, &max_datum); ReleaseVariableStats(vardata); if (!valid) return INVALID_ESTIMATE; max = ts_time_value_to_internal(max_datum, var->vartype); min = ts_time_value_to_internal(min_datum, var->vartype); return (double) (max - min); } static double estimate_max_spread_opexpr(PlannerInfo *root, OpExpr *opexpr) { char *function_name = get_opname(opexpr->opno); Expr *left; Expr *right; Expr *nonconst; if (list_length(opexpr->args) != 2 || strlen(function_name) != 1) return INVALID_ESTIMATE; left = linitial(opexpr->args); right = lsecond(opexpr->args); if (IsA(left, Const)) nonconst = right; else if (IsA(right, Const)) nonconst = left; else return INVALID_ESTIMATE; /* adding or subtracting a constant doesn't affect the range */ if (function_name[0] == '-' || function_name[0] == '+') return estimate_max_spread_expr(root, nonconst); return INVALID_ESTIMATE; } /* estimate the max spread (max(value)-min(value)) of the expr */ static double estimate_max_spread_expr(PlannerInfo *root, Expr *expr) { switch (nodeTag(expr)) { case T_Var: return estimate_max_spread_var(root, (Var *) expr); case T_OpExpr: return estimate_max_spread_opexpr(root, (OpExpr *) expr); default: return INVALID_ESTIMATE; } } /* * Return an estimate for the number of groups formed when expr is divided * into intervals of size interval_period. */ double ts_estimate_group_expr_interval(PlannerInfo *root, Expr *expr, double interval_period) { double max_period; if (interval_period <= 0) return INVALID_ESTIMATE; max_period = estimate_max_spread_expr(root, expr); if (!IS_VALID_ESTIMATE(max_period)) return INVALID_ESTIMATE; return clamp_row_est(max_period / interval_period); } /* if performing integer division number of groups is less than the spread divided by the divisor. * Note that this is an overestimate. */ static double group_estimate_integer_division(PlannerInfo *root, Oid opno, Node *left, Node *right) { char *function_name = get_opname(opno); /* only handle division */ if (function_name[0] == '/' && function_name[1] == '\0' && IsA(right, Const)) { Const *c = (Const *) right; if (c->consttype != INT2OID && c->consttype != INT4OID && c->consttype != INT8OID) return INVALID_ESTIMATE; return ts_estimate_group_expr_interval(root, (Expr *) left, (double) c->constvalue); } return INVALID_ESTIMATE; } static double group_estimate_funcexpr(PlannerInfo *root, FuncExpr *group_estimate_func, double path_rows) { FuncInfo *func_est = ts_func_cache_get_bucketing_func(group_estimate_func->funcid); if (NULL != func_est) return func_est->group_estimate(root, group_estimate_func, path_rows); return INVALID_ESTIMATE; } /* Get a custom estimate for the number of groups of an expression. Return INVALID_ESTIMATE if we * don't have any extra knowledge and should just use the default estimate */ static double group_estimate_expr(PlannerInfo *root, Node *expr, double path_rows) { switch (nodeTag(expr)) { case T_FuncExpr: return group_estimate_funcexpr(root, (FuncExpr *) expr, path_rows); case T_OpExpr: return group_estimate_opexpr(root, (OpExpr *) expr, path_rows); default: return INVALID_ESTIMATE; } } static double group_estimate_opexpr(PlannerInfo *root, OpExpr *opexpr, double path_rows) { Node *first; Node *second; double estimate; if (list_length(opexpr->args) != 2) return INVALID_ESTIMATE; first = eval_const_expressions(root, linitial(opexpr->args)); second = eval_const_expressions(root, lsecond(opexpr->args)); estimate = group_estimate_integer_division(root, opexpr->opno, first, second); if (IS_VALID_ESTIMATE(estimate)) return estimate; if (IsA(first, Const)) return group_estimate_expr(root, second, path_rows); if (IsA(second, Const)) return group_estimate_expr(root, first, path_rows); return INVALID_ESTIMATE; } /* * Get a custom estimate for the number of groups in a query. Return * INVALID_ESTIMATE if we don't have any extra knowledge and should just use * the default estimate. This works by getting a custom estimate for any * groups where a custom estimate exists and multiplying that by the standard * estimate of the groups for which custom estimates don't exist. */ double ts_estimate_group(PlannerInfo *root, double path_rows) { Query *parse = root->parse; double d_num_groups = 1; List *group_exprs; ListCell *lc; bool found = false; List *new_group_expr = NIL; Assert(parse->groupClause && !parse->groupingSets); group_exprs = get_sortgrouplist_exprs(parse->groupClause, parse->targetList); foreach (lc, group_exprs) { Node *item = lfirst(lc); double estimate = group_estimate_expr(root, item, path_rows); if (IS_VALID_ESTIMATE(estimate)) { found = true; d_num_groups *= estimate; } else new_group_expr = lappend(new_group_expr, item); } /* nothing custom */ if (!found) return INVALID_ESTIMATE; /* multiply by default estimates */ if (new_group_expr != NIL) d_num_groups *= estimate_num_groups(root, new_group_expr, path_rows, NULL, NULL); if (d_num_groups > path_rows) return INVALID_ESTIMATE; return clamp_row_est(d_num_groups); } �����������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/estimate.h�������������������������������������������������������������������0000664�0000000�0000000�00000000746�15100345067�0016635�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #define INVALID_ESTIMATE (-1) #define IS_VALID_ESTIMATE(est) ((est) >= 0) extern double ts_estimate_group_expr_interval(PlannerInfo *root, Expr *expr, double interval_period); extern double ts_estimate_group(PlannerInfo *root, double path_rows); ��������������������������timescaledb-2.23.0/src/event_trigger.c��������������������������������������������������������������0000664�0000000�0000000�00000022032�15100345067�0017651�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/pg_constraint.h> #include <catalog/pg_foreign_server.h> #include <catalog/pg_namespace.h> #include <catalog/pg_trigger.h> #include <commands/event_trigger.h> #include <executor/executor.h> #include <utils/array.h> #include <utils/builtins.h> #include "compat/compat.h" #include "event_trigger.h" #define DDL_INFO_NATTS 9 #define DROPPED_OBJECTS_NATTS 12 /* Function manager info for the event "pg_event_trigger_ddl_commands", which is * used to retrieve information on executed DDL commands in an event * trigger. The function manager info is initialized on extension load. */ static FmgrInfo ddl_commands_fmgrinfo; static FmgrInfo dropped_objects_fmgrinfo; /* * Get a list of executed DDL commands in an event trigger. * * This function calls the function pg_ts_event_trigger_ddl_commands(), which is * part of the event trigger API, and retrieves the DDL commands executed in * relation to the event trigger. It is only valid to call this function from * within an event trigger. */ List * ts_event_trigger_ddl_commands(void) { ReturnSetInfo rsinfo; LOCAL_FCINFO(fcinfo, 1); TupleTableSlot *slot; EState *estate = CreateExecutorState(); List *objects = NIL; InitFunctionCallInfoData(*fcinfo, &ddl_commands_fmgrinfo, 1, InvalidOid, NULL, NULL); MemSet(&rsinfo, 0, sizeof(rsinfo)); rsinfo.type = T_ReturnSetInfo; rsinfo.allowedModes = SFRM_Materialize; rsinfo.econtext = CreateExprContext(estate); FC_SET_NULL(fcinfo, 0); fcinfo->resultinfo = (fmNodePtr) &rsinfo; FunctionCallInvoke(fcinfo); slot = MakeSingleTupleTableSlot(rsinfo.setDesc, &TTSOpsMinimalTuple); while (tuplestore_gettupleslot(rsinfo.setResult, true, false, slot)) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); CollectedCommand *cmd; Datum values[DDL_INFO_NATTS]; bool nulls[DDL_INFO_NATTS]; heap_deform_tuple(tuple, rsinfo.setDesc, values, nulls); if (should_free) heap_freetuple(tuple); if (rsinfo.setDesc->natts > 8 && !nulls[8]) { cmd = (CollectedCommand *) DatumGetPointer(values[8]); objects = lappend(objects, cmd); } } ExecDropSingleTupleTableSlot(slot); FreeExprContext(rsinfo.econtext, false); FreeExecutorState(estate); return objects; } /* Given a TEXT[] of addrnames return a list of heap allocated char * * * similar to textarray_to_strvaluelist */ static List * extract_addrnames(ArrayType *arr) { Datum *elems; bool *nulls; int nelems; List *list = NIL; int i; deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT, &elems, &nulls, &nelems); for (i = 0; i < nelems; i++) { if (nulls[i]) elog(ERROR, "unexpected NULL in name list"); /* TextDatumGetCString heap allocates the string */ list = lappend(list, TextDatumGetCString(elems[i])); } return list; } static EventTriggerDropTableConstraint * make_event_trigger_drop_table_constraint(const char *constraint_name, const char *schema, const char *table) { EventTriggerDropTableConstraint *obj = palloc(sizeof(EventTriggerDropTableConstraint)); *obj = (EventTriggerDropTableConstraint){ .obj = { .type = EVENT_TRIGGER_DROP_TABLE_CONSTRAINT, }, .constraint_name = constraint_name, .schema = schema, .table = table, }; return obj; } static EventTriggerDropRelation * make_event_trigger_drop_index(const char *index_name, const char *schema) { EventTriggerDropRelation *obj = palloc(sizeof(EventTriggerDropRelation)); *obj = (EventTriggerDropRelation){ .obj = { .type = EVENT_TRIGGER_DROP_INDEX, }, .name = index_name, .schema = schema, }; return obj; } static EventTriggerDropRelation * make_event_trigger_drop_table(Oid relid, const char *table_name, const char *schema, char relkind) { EventTriggerDropRelation *obj = palloc(sizeof(EventTriggerDropRelation)); *obj = (EventTriggerDropRelation){ .obj = { .type = (relkind == RELKIND_RELATION) ? EVENT_TRIGGER_DROP_TABLE : EVENT_TRIGGER_DROP_FOREIGN_TABLE, }, .relid = relid, .name = table_name, .schema = schema, }; return obj; } static EventTriggerDropView * make_event_trigger_drop_view(char *view_name, char *schema) { EventTriggerDropView *obj = palloc(sizeof(*obj)); *obj = (EventTriggerDropView){ .obj = { .type = EVENT_TRIGGER_DROP_VIEW }, .view_name = view_name, .schema = schema, }; return obj; } static EventTriggerDropSchema * make_event_trigger_drop_schema(const char *schema) { EventTriggerDropSchema *obj = palloc(sizeof(EventTriggerDropSchema)); *obj = (EventTriggerDropSchema){ .obj = { .type = EVENT_TRIGGER_DROP_SCHEMA, }, .schema = schema, }; return obj; } static EventTriggerDropTrigger * make_event_trigger_drop_trigger(const char *trigger_name, const char *schema, const char *table) { EventTriggerDropTrigger *obj = palloc(sizeof(EventTriggerDropTrigger)); *obj = (EventTriggerDropTrigger){ .obj = { .type = EVENT_TRIGGER_DROP_TRIGGER, }, .trigger_name = trigger_name, .schema = schema, .table = table }; return obj; } static EventTriggerDropForeignServer * make_event_trigger_drop_foreign_server(const char *server_name) { EventTriggerDropForeignServer *obj = palloc(sizeof(EventTriggerDropForeignServer)); *obj = (EventTriggerDropForeignServer){ .obj = { .type = EVENT_TRIGGER_DROP_FOREIGN_SERVER, }, .servername = server_name, }; return obj; } List * ts_event_trigger_dropped_objects(void) { ReturnSetInfo rsinfo; LOCAL_FCINFO(fcinfo, 0); TupleTableSlot *slot; EState *estate = CreateExecutorState(); List *objects = NIL; InitFunctionCallInfoData(*fcinfo, &dropped_objects_fmgrinfo, 0, InvalidOid, NULL, NULL); MemSet(&rsinfo, 0, sizeof(rsinfo)); rsinfo.type = T_ReturnSetInfo; rsinfo.allowedModes = SFRM_Materialize; rsinfo.econtext = CreateExprContext(estate); fcinfo->resultinfo = (fmNodePtr) &rsinfo; FunctionCallInvoke(fcinfo); slot = MakeSingleTupleTableSlot(rsinfo.setDesc, &TTSOpsMinimalTuple); while (tuplestore_gettupleslot(rsinfo.setResult, true, false, slot)) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); Datum values[DROPPED_OBJECTS_NATTS]; bool nulls[DROPPED_OBJECTS_NATTS]; Oid class_id; char *objtype; List *addrnames = NIL; void *eventobj = NULL; heap_deform_tuple(tuple, rsinfo.setDesc, values, nulls); class_id = DatumGetObjectId(values[0]); switch (class_id) { case ConstraintRelationId: objtype = TextDatumGetCString(values[6]); if (objtype != NULL && strcmp(objtype, "table constraint") == 0) { addrnames = extract_addrnames(DatumGetArrayTypeP(values[10])); eventobj = make_event_trigger_drop_table_constraint(lthird(addrnames), linitial(addrnames), lsecond(addrnames)); } break; case RelationRelationId: objtype = TextDatumGetCString(values[6]); if (objtype == NULL) break; addrnames = extract_addrnames(DatumGetArrayTypeP(values[10])); if (strcmp(objtype, "index") == 0) eventobj = make_event_trigger_drop_index(lsecond(addrnames), linitial(addrnames)); else if (strcmp(objtype, "table") == 0) { eventobj = make_event_trigger_drop_table(DatumGetInt32(values[1]), lsecond(addrnames), linitial(addrnames), RELKIND_RELATION); } else if (strcmp(objtype, "view") == 0) { List *addrnames = extract_addrnames(DatumGetArrayTypeP(values[10])); objects = lappend(objects, make_event_trigger_drop_view(lsecond(addrnames), linitial(addrnames))); } else if (strcmp(objtype, "foreign table") == 0) eventobj = make_event_trigger_drop_table(DatumGetInt32(values[1]), lsecond(addrnames), linitial(addrnames), RELKIND_FOREIGN_TABLE); break; case NamespaceRelationId: addrnames = extract_addrnames(DatumGetArrayTypeP(values[10])); eventobj = make_event_trigger_drop_schema(linitial(addrnames)); break; case TriggerRelationId: addrnames = extract_addrnames(DatumGetArrayTypeP(values[10])); eventobj = make_event_trigger_drop_trigger(lthird(addrnames), linitial(addrnames), lsecond(addrnames)); break; case ForeignServerRelationId: addrnames = extract_addrnames(DatumGetArrayTypeP(values[10])); eventobj = make_event_trigger_drop_foreign_server(linitial(addrnames)); break; default: break; } if (NULL != eventobj) objects = lappend(objects, eventobj); if (should_free) heap_freetuple(tuple); } ExecDropSingleTupleTableSlot(slot); FreeExprContext(rsinfo.econtext, false); FreeExecutorState(estate); return objects; } void _event_trigger_init(void) { fmgr_info(fmgr_internal_function("pg_event_trigger_ddl_commands"), &ddl_commands_fmgrinfo); fmgr_info(fmgr_internal_function("pg_event_trigger_dropped_objects"), &dropped_objects_fmgrinfo); } void _event_trigger_fini(void) { /* Nothing to do */ } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/event_trigger.h��������������������������������������������������������������0000664�0000000�0000000�00000003264�15100345067�0017664�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pg_list.h> typedef enum EventTriggerDropType { EVENT_TRIGGER_DROP_TABLE_CONSTRAINT, EVENT_TRIGGER_DROP_INDEX, EVENT_TRIGGER_DROP_TABLE, EVENT_TRIGGER_DROP_VIEW, EVENT_TRIGGER_DROP_FOREIGN_TABLE, EVENT_TRIGGER_DROP_SCHEMA, EVENT_TRIGGER_DROP_TRIGGER, EVENT_TRIGGER_DROP_FOREIGN_SERVER, } EventTriggerDropType; typedef struct EventTriggerDropObject { EventTriggerDropType type; } EventTriggerDropObject; typedef struct EventTriggerDropTableConstraint { EventTriggerDropObject obj; const char *constraint_name; const char *schema; const char *table; } EventTriggerDropTableConstraint; typedef struct EventTriggerDropRelation { EventTriggerDropObject obj; Oid relid; const char *name; const char *schema; } EventTriggerDropRelation; typedef struct EventTriggerDropView { EventTriggerDropObject obj; char *view_name; char *schema; } EventTriggerDropView; typedef struct EventTriggerDropSchema { EventTriggerDropObject obj; const char *schema; } EventTriggerDropSchema; typedef struct EventTriggerDropTrigger { EventTriggerDropObject obj; const char *trigger_name; const char *schema; const char *table; } EventTriggerDropTrigger; typedef struct EventTriggerDropForeignServer { EventTriggerDropObject obj; const char *servername; } EventTriggerDropForeignServer; extern List *ts_event_trigger_dropped_objects(void); extern List *ts_event_trigger_ddl_commands(void); extern void _event_trigger_init(void); extern void _event_trigger_fini(void); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/export.h���������������������������������������������������������������������0000664�0000000�0000000�00000003407�15100345067�0016340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "config.h" /* Definitions for symbol exports */ #if defined(_WIN32) && !defined(WIN32) #define WIN32 #endif /* * PGDLLEXPORT is defined as en empty macro until PG15. * Since PG16, a macro HAVE_VISIBILITY_ATTRIBUTE is defined if the compiler has * support for visibility attribute and the PGDLLEXPORT macro is defined as the * same. So, skip redefining PGDLLEXPORT if HAVE_VISIBILITY_ATTRIBUTE is defined. * If not, undef the empty PGDLLEXPORT macro and redefine it properly. */ #if !defined(WIN32) && !defined(__CYGWIN__) && !defined(HAVE_VISIBILITY_ATTRIBUTE) #if __GNUC__ >= 4 /* PGDLLEXPORT is defined but will be empty. Redefine it. */ #undef PGDLLEXPORT #define PGDLLEXPORT __attribute__((visibility("default"))) #else #error "Unsupported GNUC version" #endif /* __GNUC__ */ #endif /* * On windows, symbols shared across modules have to be marked "export" in the * main TimescaleDb module and "import" in the submodule. Since we want to use the * same headers, we TSDLLEXPORT functions as "export" in the main module and * "import" in submodules. */ #ifndef TS_SUBMODULE /* In the core timescaledb TSDLLEXPORT is export */ #define TSDLLEXPORT PGDLLEXPORT #elif defined(PGDLLIMPORT) /* In submodules it works as imports */ #define TSDLLEXPORT PGDLLIMPORT #else /* If there is no IMPORT defined, it's a nop */ #define TSDLLEXPORT #endif #define TS_FUNCTION_INFO_V1(fn) \ PGDLLEXPORT Datum fn(PG_FUNCTION_ARGS); \ PG_FUNCTION_INFO_V1(fn) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/expression_utils.c�����������������������������������������������������������0000664�0000000�0000000�00000004341�15100345067�0020427�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <nodes/primnodes.h> #include <utils/lsyscache.h> #include "export.h" #include "expression_utils.h" /* * This function is meant to extract the expression components to be used in a ScanKey. * * It will work on the following expression types: * - Var OP Expr * * Var OP Var is not supported as that will not work with scankeys. * */ bool TSDLLEXPORT ts_extract_expr_args(Expr *expr, Var **var, Expr **arg_value, Oid *opno, Oid *opcode) { List *args; Oid expr_opno, expr_opcode; switch (nodeTag(expr)) { case T_OpExpr: { OpExpr *opexpr = castNode(OpExpr, expr); args = opexpr->args; expr_opno = opexpr->opno; expr_opcode = opexpr->opfuncid; if (opexpr->opresulttype != BOOLOID) return false; break; } case T_ScalarArrayOpExpr: { ScalarArrayOpExpr *sa_opexpr = castNode(ScalarArrayOpExpr, expr); args = sa_opexpr->args; expr_opno = sa_opexpr->opno; expr_opcode = sa_opexpr->opfuncid; break; } default: return false; } if (list_length(args) != 2) return false; Expr *leftop = linitial(args); Expr *rightop = lsecond(args); if (IsA(leftop, RelabelType)) leftop = castNode(RelabelType, leftop)->arg; if (IsA(rightop, RelabelType)) rightop = castNode(RelabelType, rightop)->arg; if (IsA(leftop, Var) && !IsA(rightop, Var)) { /* ignore system columns */ if (castNode(Var, leftop)->varattno <= 0) return false; *var = castNode(Var, leftop); *arg_value = rightop; *opno = expr_opno; if (opcode) *opcode = expr_opcode; return true; } else if (IsA(rightop, Var) && !IsA(leftop, Var)) { /* ignore system columns */ if (castNode(Var, rightop)->varattno <= 0) return false; *var = castNode(Var, rightop); *arg_value = leftop; expr_opno = get_commutator(expr_opno); if (!OidIsValid(expr_opno)) return false; if (opcode) { expr_opcode = get_opcode(expr_opno); if (!OidIsValid(expr_opcode)) return false; *opcode = expr_opcode; } *opno = expr_opno; return true; } return false; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/expression_utils.h�����������������������������������������������������������0000664�0000000�0000000�00000000627�15100345067�0020437�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <nodes/primnodes.h> #include <utils/lsyscache.h> #include "export.h" bool TSDLLEXPORT ts_extract_expr_args(Expr *expr, Var **var, Expr **arg_value, Oid *opno, Oid *opcode); ���������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/extension.c������������������������������������������������������������������0000664�0000000�0000000�00000024571�15100345067�0017033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/transam.h> #include <access/xact.h> #include <catalog/namespace.h> #include <catalog/objectaccess.h> #include <commands/event_trigger.h> #include <fmgr.h> #include <utils/inval.h> #include <utils/lsyscache.h> #if PG_VERSION_NUM < 150000 /* * Some externs are mislabeled when building on Windows so we try to fix them * with this hack. This is only needed for versions < 15. */ #include "compat/compat-msvc-enter.h" #include <commands/extension.h> #include <miscadmin.h> #include "compat/compat-msvc-exit.h" #endif #include <access/relscan.h> #include <catalog/indexing.h> #include <catalog/pg_extension.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include "compat/compat.h" #include "extension.h" #include "extension_utils.c" #include "guc.h" #include "ts_catalog/catalog.h" #define TS_UPDATE_SCRIPT_CONFIG_VAR MAKE_EXTOPTION("update_script_stage") #define POST_UPDATE "post" /* * The name of the experimental schema. * * Call ts_extension_schema_name() or ts_experimental_schema_name() for * consistency. Don't use this macro directly. */ #define TS_EXPERIMENTAL_SCHEMA_NAME "timescaledb_experimental" static Oid extension_proxy_oid = InvalidOid; /* * ExtensionState tracks the state of extension metadata in the backend. * * Since we want to cache extension metadata to speed up common checks (e.g., * check for presence of the extension itself), we also need to track the * extension state to know when the metadata is valid. * * We use a proxy_table to be notified of extension drops/creates. Namely, * we rely on the fact that postgres will internally create RelCacheInvalidation * events when any tables are created or dropped. We rely on the following properties * of Postgres's dependency management: * * The proxy table will be created before the extension itself. * * The proxy table will be dropped before the extension itself. */ static enum ExtensionState extstate = EXTENSION_STATE_UNKNOWN; /* * Looking up the extension oid is a catalog lookup that can be costly, and we * often need it during the planning, so we cache it here. We update it when * the extension status is updated. */ static Oid ts_extension_oid = InvalidOid; static const char *extstate_str[] = { [EXTENSION_STATE_UNKNOWN] = "unknown", [EXTENSION_STATE_TRANSITIONING] = "transitioning", [EXTENSION_STATE_CREATED] = "created", [EXTENSION_STATE_NOT_INSTALLED] = "not installed", }; static bool extension_loader_present() { void **presentptr = find_rendezvous_variable(RENDEZVOUS_LOADER_PRESENT_NAME); return (*presentptr != NULL && *((bool *) *presentptr)); } void ts_extension_check_version(const char *so_version) { char *sql_version; if (!IsNormalProcessingMode() || !IsTransactionState() || !extension_exists(EXTENSION_NAME)) return; sql_version = extension_version(EXTENSION_NAME); if (strcmp(sql_version, so_version) != 0) { /* * Throw a FATAL error here so that clients will be forced to reconnect * when they have the wrong extension version loaded. */ ereport(FATAL, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("extension \"%s\" version mismatch: shared library version %s; SQL version " "%s", EXTENSION_NAME, so_version, sql_version))); } if (!process_shared_preload_libraries_in_progress && !extension_loader_present()) { extension_load_without_preload(); } } void ts_extension_check_server_version() { /* * This is a load-time check for the correct server version since the * extension may be distributed as a binary */ char *server_version_num_guc = GetConfigOptionByName("server_version_num", NULL, false); long server_version_num = strtol(server_version_num_guc, NULL, 10); if (!is_supported_pg_version(server_version_num)) { char *server_version_guc = GetConfigOptionByName("server_version", NULL, false); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("extension \"%s\" does not support postgres version %s", EXTENSION_NAME, server_version_guc))); } } /* Sets a new state, returning whether the state has changed */ static bool extension_set_state(enum ExtensionState newstate) { if (newstate == extstate) { return false; } switch (newstate) { case EXTENSION_STATE_TRANSITIONING: case EXTENSION_STATE_UNKNOWN: break; case EXTENSION_STATE_CREATED: ts_extension_check_version(TIMESCALEDB_VERSION_MOD); extension_proxy_oid = ts_get_relation_relid(CACHE_SCHEMA_NAME, EXTENSION_PROXY_TABLE, true); ts_catalog_reset(); break; case EXTENSION_STATE_NOT_INSTALLED: extension_proxy_oid = InvalidOid; ts_catalog_reset(); break; } elog(DEBUG1, "extension state changed: %s to %s", extstate_str[extstate], extstate_str[newstate]); extstate = newstate; return true; } /* Updates the state based on the current state, returning whether there had been a change. */ static void extension_update_state() { enum ExtensionState new_state = extension_current_state(EXTENSION_NAME, CACHE_SCHEMA_NAME, EXTENSION_PROXY_TABLE); /* Never actually set the state to "not installed" since there is no good * way to get out of it in case the extension is installed again in * another backend. After the extension has been dropped, the proxy table * no longer exists and when the extension is reinstalled, the proxy table * will have a different relid. Therefore, there is no way to identify the * invalidation on the proxy table when CREATE EXTENSION is issued in * another backend. Nor is it allowed to lookup the new relid in the * invalidation callback, since that may lead to bad behavior. * * Instead, set the state to "unknown" so that a "slow path" lookup of the * actual state has to be made next time the state is queried. */ if (new_state == EXTENSION_STATE_NOT_INSTALLED) new_state = EXTENSION_STATE_UNKNOWN; extension_set_state(new_state); /* * Update the extension oid. Note that it is only safe to run * get_extension_oid() when the extension state is 'CREATED' or * 'TRANSITIONING', because otherwise we might not be even able to do a * catalog lookup because we are not in transaction state, and the like. */ if (new_state == EXTENSION_STATE_CREATED || new_state == EXTENSION_STATE_TRANSITIONING) { ts_extension_oid = get_extension_oid(EXTENSION_NAME, true /* missing_ok */); Assert(OidIsValid(ts_extension_oid)); } else { ts_extension_oid = InvalidOid; } } Oid ts_extension_schema_oid(void) { Datum result; Relation rel; SysScanDesc scandesc; HeapTuple tuple; ScanKeyData entry[1]; bool is_null = true; Oid schema = InvalidOid; rel = table_open(ExtensionRelationId, AccessShareLock); ScanKeyInit(&entry[0], Anum_pg_extension_extname, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(EXTENSION_NAME)); scandesc = systable_beginscan(rel, ExtensionNameIndexId, true, NULL, 1, entry); tuple = systable_getnext(scandesc); /* We assume that there can be at most one matching tuple */ if (HeapTupleIsValid(tuple)) { result = heap_getattr(tuple, Anum_pg_extension_extnamespace, RelationGetDescr(rel), &is_null); if (!is_null) schema = DatumGetObjectId(result); } systable_endscan(scandesc); table_close(rel, AccessShareLock); if (!OidIsValid(schema)) elog(ERROR, "extension schema not found"); return schema; } char * ts_extension_schema_name(void) { return get_namespace_name(ts_extension_schema_oid()); } const char * ts_experimental_schema_name(void) { return TS_EXPERIMENTAL_SCHEMA_NAME; } /* * Invalidate the state of the extension (i.e., whether the extension is * installed or not in the current database). * * Since this function is called from a relcache invalidation callback, it * must not, directly or indirectly, call functions that use the cache. This * includes, e.g., table scans. * * Instead, the function just invalidates the state so that the true state is * resolved lazily when needed. */ void ts_extension_invalidate(void) { elog(DEBUG1, "extension state invalidated: %s to %s", extstate_str[extstate], extstate_str[EXTENSION_STATE_UNKNOWN]); extstate = EXTENSION_STATE_UNKNOWN; extension_proxy_oid = InvalidOid; } bool ts_extension_is_loaded(void) { if (EXTENSION_STATE_UNKNOWN == extstate || EXTENSION_STATE_TRANSITIONING == extstate) { /* status may have updated without a relcache invalidate event */ extension_update_state(); } switch (extstate) { case EXTENSION_STATE_CREATED: Assert(OidIsValid(ts_extension_oid)); Assert(OidIsValid(extension_proxy_oid)); return true; case EXTENSION_STATE_NOT_INSTALLED: case EXTENSION_STATE_UNKNOWN: case EXTENSION_STATE_TRANSITIONING: /* * Turn off extension during upgrade scripts. This is necessary so * that, for example, the catalog does not go looking for things * that aren't yet there. */ if (extstate == EXTENSION_STATE_TRANSITIONING) { /* when we are updating the extension, we execute * scripts in post_update.sql after setting up the * the dependencies. At this stage, TS * specific functionality is permitted as we now have * all catalogs and functions in place */ const char *update_script_stage = GetConfigOption(TS_UPDATE_SCRIPT_CONFIG_VAR, true, false); if (update_script_stage && (strncmp(update_script_stage, POST_UPDATE, strlen(POST_UPDATE)) == 0) && (strlen(POST_UPDATE) == strlen(update_script_stage))) return true; } return false; default: elog(ERROR, "unknown state: %d", extstate); return false; } } bool ts_extension_is_loaded_and_not_upgrading(void) { /* When restoring deactivate extension. * * We are using IsBinaryUpgrade (and ts_guc_restoring). If a user set * `ts_guc_restoring` for a database, it will be stored in * `pg_db_role_settings` and be included in a dump, which will cause * `pg_upgrade` to fail. * * See dumpDatabaseConfig in pg_dump.c. */ if (ts_guc_restoring || IsBinaryUpgrade) return false; return ts_extension_is_loaded(); } const char * ts_extension_get_so_name(void) { return EXTENSION_NAME "-" TIMESCALEDB_VERSION_MOD; } bool ts_extension_is_proxy_table_relid(Oid relid) { return relid == extension_proxy_oid; } TS_FUNCTION_INFO_V1(ts_extension_get_state); Datum ts_extension_get_state(PG_FUNCTION_ARGS) { PG_RETURN_TEXT_P(cstring_to_text(extstate_str[extstate])); } ���������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/extension.h������������������������������������������������������������������0000664�0000000�0000000�00000001532�15100345067�0017030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/parsenodes.h> #include "export.h" #include "extension_constants.h" extern void ts_extension_invalidate(void); extern TSDLLEXPORT bool ts_extension_is_loaded(void); extern bool ts_extension_is_loaded_and_not_upgrading(void); extern void ts_extension_check_version(const char *so_version); extern void ts_extension_check_server_version(void); extern TSDLLEXPORT Oid ts_extension_schema_oid(void); extern TSDLLEXPORT char *ts_extension_schema_name(void); extern const char *ts_experimental_schema_name(void); extern const char *ts_extension_get_so_name(void); extern bool ts_extension_is_proxy_table_relid(Oid relid); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/extension_constants.c��������������������������������������������������������0000664�0000000�0000000�00000001132�15100345067�0021113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include "extension_constants.h" const char *const ts_extension_schema_names[] = { [TS_CATALOG_SCHEMA] = CATALOG_SCHEMA_NAME, [TS_FUNCTIONS_SCHEMA] = FUNCTIONS_SCHEMA_NAME, [TS_INTERNAL_SCHEMA] = INTERNAL_SCHEMA_NAME, [TS_CACHE_SCHEMA] = CACHE_SCHEMA_NAME, [TS_CONFIG_SCHEMA] = CONFIG_SCHEMA_NAME, [TS_EXPERIMENTAL_SCHEMA] = EXPERIMENTAL_SCHEMA_NAME, [TS_INFORMATION_SCHEMA] = INFORMATION_SCHEMA_NAME, }; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/extension_constants.h��������������������������������������������������������0000664�0000000�0000000�00000003477�15100345067�0021136�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* No function definitions here, only potentially globally available defines as this is used by the * loader*/ #define EXTENSION_NAME "timescaledb" /* Name of the actual extension */ #define EXTENSION_NAMESPACE "timescaledb" /* Namespace for extension objects */ #define EXTENSION_NAMESPACE_ALIAS "tsdb" /* Namespace for extension objects */ #define TSL_LIBRARY_NAME "timescaledb-tsl" #define TS_LIBDIR "$libdir/" #define EXTENSION_SO TS_LIBDIR "" EXTENSION_NAME #define EXTENSION_TSL_SO TS_LIBDIR TSL_LIBRARY_NAME "-" TIMESCALEDB_VERSION_MOD #define MAKE_EXTOPTION(NAME) (EXTENSION_NAMESPACE "." NAME) #define MAX_VERSION_LEN (NAMEDATALEN + 1) #define MAX_SO_NAME_LEN \ (8 + NAMEDATALEN + 1 + MAX_VERSION_LEN) /* "$libdir/"+extname+"-"+version \ * */ typedef enum TsExtensionSchemas { TS_CATALOG_SCHEMA, TS_FUNCTIONS_SCHEMA, TS_INTERNAL_SCHEMA, TS_CACHE_SCHEMA, TS_CONFIG_SCHEMA, TS_EXPERIMENTAL_SCHEMA, TS_INFORMATION_SCHEMA, _TS_MAX_SCHEMA, } TsExtensionSchemas; #define NUM_TIMESCALEDB_SCHEMAS _TS_MAX_SCHEMA #define CATALOG_SCHEMA_NAME "_timescaledb_catalog" #define FUNCTIONS_SCHEMA_NAME "_timescaledb_functions" #define INTERNAL_SCHEMA_NAME "_timescaledb_internal" #define CACHE_SCHEMA_NAME "_timescaledb_cache" #define CONFIG_SCHEMA_NAME "_timescaledb_config" #define EXPERIMENTAL_SCHEMA_NAME "timescaledb_experimental" #define INFORMATION_SCHEMA_NAME "timescaledb_information" extern const char *const ts_extension_schema_names[]; #define RENDEZVOUS_BGW_LOADER_API_VERSION MAKE_EXTOPTION("bgw_loader_api_version") �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/extension_utils.c������������������������������������������������������������0000664�0000000�0000000�00000016004�15100345067�0020243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* This file will be used by the versioned timescaledb extension and the loader * Because we want the loader not to export symbols all files here should be static * and be included via #include "extension_utils.c" instead of the regular linking process */ #include <postgres.h> #include <access/genam.h> #include <access/relscan.h> #include <access/table.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/pg_authid.h> #include <catalog/pg_extension.h> #include <commands/extension.h> #include <miscadmin.h> #include <parser/analyze.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include "compat/compat.h" #include "extension_constants.h" #include "utils.h" #define EXTENSION_PROXY_TABLE "cache_inval_extension" #define RENDEZVOUS_LOADER_PRESENT_NAME MAKE_EXTOPTION("loader_present") enum ExtensionState { /* * NOT_INSTALLED means that this backend knows that the extension is not * present. In this state we know that the proxy table is not present. * This state is never saved since there is no real way to get out of it * since we cannot signal via the proxy table as its relid is not known * post installation without a full lookup, which is not allowed in the * relcache callback. */ EXTENSION_STATE_NOT_INSTALLED, /* * UNKNOWN state is used only if we cannot be sure what the state is. This * can happen in two cases: 1) at the start of a backend or 2) We got a * relcache event outside of a transaction and thus could not check the * cache for the presence/absence of the proxy table or extension. */ EXTENSION_STATE_UNKNOWN, /* * TRANSITIONING only occurs in the middle of a CREATE EXTENSION or ALTER * EXTENSION UPDATE */ EXTENSION_STATE_TRANSITIONING, /* * CREATED means we know the extension is loaded, metadata is up-to-date, * and we therefore do not need a full check until a RelCacheInvalidation * on the proxy table. */ EXTENSION_STATE_CREATED, }; static char * extension_version(char const *const extension_name) { Datum result; Relation rel; SysScanDesc scandesc; HeapTuple tuple; ScanKeyData entry[1]; bool is_null = true; char *sql_version = NULL; rel = table_open(ExtensionRelationId, AccessShareLock); ScanKeyInit(&entry[0], Anum_pg_extension_extname, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(extension_name)); scandesc = systable_beginscan(rel, ExtensionNameIndexId, true, NULL, 1, entry); tuple = systable_getnext(scandesc); /* We assume that there can be at most one matching tuple */ if (HeapTupleIsValid(tuple)) { result = heap_getattr(tuple, Anum_pg_extension_extversion, RelationGetDescr(rel), &is_null); if (!is_null) { sql_version = pstrdup(TextDatumGetCString(result)); } } systable_endscan(scandesc); table_close(rel, AccessShareLock); if (sql_version == NULL) { elog(ERROR, "extension not found while getting version"); } return sql_version; } inline static bool extension_exists(char const *const extension_name) { return OidIsValid(get_extension_oid(extension_name, true)); } inline static bool extension_is_transitioning(char const *const extension_name) { /* * Determine whether the extension is being created or upgraded (as a * misnomer creating_extension is true during upgrades) */ if (creating_extension) { return get_extension_oid(extension_name, true) == CurrentExtensionObject; } return false; } /* Returns the recomputed current state. * * (schema_name, table_name) refer to a table that is owned by the extension. * thus it is created with the extension and dropped with the extension. */ static enum ExtensionState extension_current_state(char const *const extension_name, char const *const schema_name, char const *const table_name) { /* * NormalProcessingMode necessary to avoid accessing cache before its * ready (which may result in an infinite loop). More concretely we need * RelationCacheInitializePhase3 to have been already called. */ if (!IsNormalProcessingMode() || !IsTransactionState() || !OidIsValid(MyDatabaseId)) return EXTENSION_STATE_UNKNOWN; /* * NOTE: do not check for (schema_name, table_name) existing here. Want to be in * TRANSITIONING state even before that table is created */ if (extension_is_transitioning(extension_name)) return EXTENSION_STATE_TRANSITIONING; /* * We use syscache to check (schema_name, table_name) exists. Must come first. * * A table that is owned by the extension is dropped before the extension itself is dropped. * this logic lets us detect that an extension is being dropped early on in the drop process and * return `EXTENSION_STATE_NOT_INSTALLED` if that is the case. * It is best to use a table created early on in the extension creation process because * that means it will be dropped early in the drop process. */ if (OidIsValid(ts_get_relation_relid(schema_name, table_name, true))) { Assert(extension_exists(extension_name)); return EXTENSION_STATE_CREATED; } return EXTENSION_STATE_NOT_INSTALLED; } /* Handle extension load request without loader present */ static void extension_load_without_preload() { /* * These are FATAL because otherwise the loader ends up in a weird * half-loaded state after an ERROR */ /* Only privileged users can get the value of `config file` */ if (has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS)) { char *config_file = GetConfigOptionByName("config_file", NULL, false); ereport(FATAL, (errmsg("extension \"%s\" must be preloaded", EXTENSION_NAME), errhint("Please preload the timescaledb library via " "shared_preload_libraries.\n\n" "This can be done by editing the config file at: %1$s\n" "and adding 'timescaledb' to the list in the shared_preload_libraries " "config.\n" " # Modify postgresql.conf:\n shared_preload_libraries = " "'timescaledb'\n\n" "Another way to do this, if not preloading other libraries, is with " "the command:\n" " echo \"shared_preload_libraries = 'timescaledb'\" >> %1$s \n\n" "(Will require a database restart.)\n\n", config_file))); } else { ereport(FATAL, (errmsg("extension \"%s\" must be preloaded", EXTENSION_NAME), errhint("Please preload the timescaledb library via shared_preload_libraries.\n\n" "This can be done by editing the postgres config file \n" "and adding 'timescaledb' to the list in the shared_preload_libraries " "config.\n" " # Modify postgresql.conf:\n shared_preload_libraries = " "'timescaledb'\n\n" "Another way to do this, if not preloading other libraries, is with the " "command:\n" " echo \"shared_preload_libraries = 'timescaledb'\" >> " "/path/to/config/file \n\n" "(Will require a database restart.)\n\n"))); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/foreign_key.c����������������������������������������������������������������0000664�0000000�0000000�00000041037�15100345067�0017314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * The table referenced by a foreign constraint is supposed to have a * constraint that prevents removing the referenced rows. The constraint * is enforced by a pair of update and delete triggers. Normally this * is done by the postgres addFkRecurseReferenced(), but it doesn't work * for hypertables because they use inheritance, and that function only * recurses into declarative partitioning hierarchy. */ #include <postgres.h> #include "access/attmap.h" #include "catalog/pg_trigger.h" #include "commands/trigger.h" #include "parser/parser.h" #include "compat/compat.h" #include "chunk.h" #include "chunk_constraint.h" #include "foreign_key.h" #include "hypertable.h" static HeapTuple relation_get_fk_constraint(Oid conrelid, Oid confrelid); static List *relation_get_referencing_fk(Oid reloid); static Oid get_fk_index(Relation rel, int nkeys, AttrNumber *confkeys); static void constraint_get_trigger(Oid conoid, Oid *updtrigoid, Oid *deltrigoid); static char *ChooseForeignKeyConstraintNameAddition(int numkeys, AttrNumber *keys, Oid relid); static void createForeignKeyActionTriggers(Form_pg_constraint fk, Oid relid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid parentDelTrigger, Oid parentUpdTrigger); static void clone_constraint_on_chunk(const Chunk *chunk, Relation parentRel, Form_pg_constraint fk, int numfks, AttrNumber *conkey, AttrNumber *confkey, Oid *conpfeqop, Oid *conppeqop, Oid *conffeqop, int numfkdelsetcols, AttrNumber *confdelsetcols, Oid parentDelTrigger, Oid parentUpdTrigger); /* * Copy foreign key constraint fk_tuple to all chunks. */ static void propagate_fk(Relation ht_rel, HeapTuple fk_tuple, List *chunks) { Form_pg_constraint fk = (Form_pg_constraint) GETSTRUCT(fk_tuple); int numfks; AttrNumber conkey[INDEX_MAX_KEYS]; AttrNumber confkey[INDEX_MAX_KEYS]; Oid conpfeqop[INDEX_MAX_KEYS]; Oid conppeqop[INDEX_MAX_KEYS]; Oid conffeqop[INDEX_MAX_KEYS]; int numfkdelsetcols; AttrNumber confdelsetcols[INDEX_MAX_KEYS]; DeconstructFkConstraintRow(fk_tuple, &numfks, conkey, confkey, conpfeqop, conppeqop, conffeqop, &numfkdelsetcols, confdelsetcols); Oid parentDelTrigger, parentUpdTrigger; constraint_get_trigger(fk->oid, &parentUpdTrigger, &parentDelTrigger); ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); if (chunk->fd.osm_chunk) continue; clone_constraint_on_chunk(chunk, ht_rel, fk, numfks, conkey, confkey, conpfeqop, conppeqop, conffeqop, numfkdelsetcols, confdelsetcols, parentDelTrigger, parentUpdTrigger); } } /* * Copy all foreign key constraints from the main table to a chunk. */ void ts_chunk_copy_referencing_fk(const Hypertable *ht, const Chunk *chunk) { ListCell *lc; List *chunks = list_make1((Chunk *) chunk); List *fks = relation_get_referencing_fk(ht->main_table_relid); Relation ht_rel = table_open(ht->main_table_relid, AccessShareLock); foreach (lc, fks) { HeapTuple fk_tuple = lfirst(lc); propagate_fk(ht_rel, fk_tuple, chunks); } table_close(ht_rel, NoLock); } /* * Copy one foreign key constraint from the main table to all chunks. */ void ts_fk_propagate(Oid conrelid, Hypertable *ht) { HeapTuple fk_tuple = relation_get_fk_constraint(conrelid, ht->main_table_relid); if (!fk_tuple) elog(ERROR, "foreign key constraint not found"); Relation ht_rel = table_open(ht->main_table_relid, AccessShareLock); List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.id); propagate_fk(ht_rel, fk_tuple, chunks); table_close(ht_rel, NoLock); } /* * Clone a single constraint to a single chunk. */ static void clone_constraint_on_chunk(const Chunk *chunk, Relation parentRel, Form_pg_constraint fk, int numfks, AttrNumber *conkey, AttrNumber *confkey, Oid *conpfeqop, Oid *conppeqop, Oid *conffeqop, int numfkdelsetcols, AttrNumber *confdelsetcols, Oid parentDelTrigger, Oid parentUpdTrigger) { AttrNumber mapped_confkey[INDEX_MAX_KEYS]; Relation pkrel = table_open(chunk->table_id, AccessShareLock); /* Map the foreign key columns on the hypertable side to the chunk columns */ #if PG16_GE AttrMap *attmap = build_attrmap_by_name(RelationGetDescr(pkrel), RelationGetDescr(parentRel), false); #else AttrMap *attmap = build_attrmap_by_name(RelationGetDescr(pkrel), RelationGetDescr(parentRel)); #endif for (int i = 0; i < numfks; i++) mapped_confkey[i] = attmap->attnums[confkey[i] - 1]; Oid indexoid = get_fk_index(pkrel, numfks, mapped_confkey); /* Since postgres accepted the constraint, there should be a supporting index. */ Ensure(OidIsValid(indexoid), "index for constraint not found on chunk"); table_close(pkrel, NoLock); char *conname_addition = ChooseForeignKeyConstraintNameAddition(numfks, confkey, parentRel->rd_id); char *conname = ChooseConstraintName(get_rel_name(fk->conrelid), conname_addition, "fkey", fk->connamespace, NIL); Oid conoid = CreateConstraintEntry(conname, fk->connamespace, CONSTRAINT_FOREIGN, fk->condeferrable, fk->condeferred, #if PG18_GE true, /* isEnforced */ #endif fk->convalidated, fk->oid, fk->conrelid, conkey, numfks, numfks, InvalidOid, indexoid, chunk->table_id, mapped_confkey, conpfeqop, conppeqop, conffeqop, numfks, fk->confupdtype, fk->confdeltype, confdelsetcols, numfkdelsetcols, fk->confmatchtype, NULL, NULL, NULL, false, 1, false, #if PG18_GE false, /* conPeriod */ #endif false); ObjectAddress address, referenced; ObjectAddressSet(address, ConstraintRelationId, conoid); ObjectAddressSet(referenced, ConstraintRelationId, fk->oid); recordDependencyOn(&address, &referenced, DEPENDENCY_INTERNAL); CommandCounterIncrement(); createForeignKeyActionTriggers(fk, fk->conrelid, chunk->table_id, conoid, indexoid, parentDelTrigger, parentUpdTrigger); } /* * Generate the column-name portion of the constraint name for a new foreign * key given the list of column names that reference the referenced * table. This will be passed to ChooseConstraintName along with the parent * table name and the "fkey" suffix. * * We know that less than NAMEDATALEN characters will actually be used, so we * can truncate the result once we've generated that many. * * This function is based on a static function by the same name in tablecmds.c in PostgreSQL. */ static char * ChooseForeignKeyConstraintNameAddition(int numkeys, AttrNumber *keys, Oid relid) { char buf[NAMEDATALEN * 2]; int buflen = 0; buf[0] = '\0'; for (int i = 0; i < numkeys; i++) { char *name = get_attname(relid, keys[i], false); if (buflen > 0) buf[buflen++] = '_'; /* insert _ between names */ /* * At this point we have buflen <= NAMEDATALEN. name should be less * than NAMEDATALEN already, but use strlcpy for paranoia. */ strlcpy(buf + buflen, name, NAMEDATALEN); buflen += strlen(buf + buflen); if (buflen >= NAMEDATALEN) break; } return pstrdup(buf); } /* * createForeignKeyActionTriggers * Create the referenced-side "action" triggers that implement a foreign * key. * This function is based on a static function by the same name in tablecmds.c in PostgreSQL. */ static void createForeignKeyActionTriggers(Form_pg_constraint fk, Oid relid, Oid refRelOid, Oid constraintOid, Oid indexOid, Oid parentDelTrigger, Oid parentUpdTrigger) { CreateTrigStmt *fk_trigger; /* * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON * DELETE action on the referenced table. */ fk_trigger = makeNode(CreateTrigStmt); fk_trigger->replace = false; fk_trigger->isconstraint = true; fk_trigger->trigname = "RI_ConstraintTrigger_a"; fk_trigger->relation = NULL; fk_trigger->args = NIL; fk_trigger->row = true; fk_trigger->timing = TRIGGER_TYPE_AFTER; fk_trigger->events = TRIGGER_TYPE_DELETE; fk_trigger->columns = NIL; fk_trigger->whenClause = NULL; fk_trigger->transitionRels = NIL; fk_trigger->constrrel = NULL; switch (fk->confdeltype) { case FKCONSTR_ACTION_NOACTION: fk_trigger->deferrable = fk->condeferrable; fk_trigger->initdeferred = fk->condeferred; fk_trigger->funcname = SystemFuncName("RI_FKey_noaction_del"); break; case FKCONSTR_ACTION_RESTRICT: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_restrict_del"); break; case FKCONSTR_ACTION_CASCADE: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_cascade_del"); break; case FKCONSTR_ACTION_SETNULL: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_setnull_del"); break; case FKCONSTR_ACTION_SETDEFAULT: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_setdefault_del"); break; default: elog(ERROR, "unrecognized FK action type: %d", (int) fk->confdeltype); break; } /* * clang will complain here about swapped arguments but this is intentional * as this is the reverse trigger from the referenced table back to the * referencing table. So we disable that specific warning for the next call. * * NOLINTBEGIN(readability-suspicious-call-argument) */ CreateTrigger(fk_trigger, NULL, refRelOid, relid, constraintOid, indexOid, InvalidOid, parentDelTrigger, NULL, true, false); /* NOLINTEND(readability-suspicious-call-argument) */ /* Make changes-so-far visible */ CommandCounterIncrement(); /* * Build and execute a CREATE CONSTRAINT TRIGGER statement for the ON * UPDATE action on the referenced table. */ fk_trigger = makeNode(CreateTrigStmt); fk_trigger->replace = false; fk_trigger->isconstraint = true; fk_trigger->trigname = "RI_ConstraintTrigger_a"; fk_trigger->relation = NULL; fk_trigger->args = NIL; fk_trigger->row = true; fk_trigger->timing = TRIGGER_TYPE_AFTER; fk_trigger->events = TRIGGER_TYPE_UPDATE; fk_trigger->columns = NIL; fk_trigger->whenClause = NULL; fk_trigger->transitionRels = NIL; fk_trigger->constrrel = NULL; switch (fk->confupdtype) { case FKCONSTR_ACTION_NOACTION: fk_trigger->deferrable = fk->condeferrable; fk_trigger->initdeferred = fk->condeferred; fk_trigger->funcname = SystemFuncName("RI_FKey_noaction_upd"); break; case FKCONSTR_ACTION_RESTRICT: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_restrict_upd"); break; case FKCONSTR_ACTION_CASCADE: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_cascade_upd"); break; case FKCONSTR_ACTION_SETNULL: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_setnull_upd"); break; case FKCONSTR_ACTION_SETDEFAULT: fk_trigger->deferrable = false; fk_trigger->initdeferred = false; fk_trigger->funcname = SystemFuncName("RI_FKey_setdefault_upd"); break; default: elog(ERROR, "unrecognized FK action type: %d", (int) fk->confupdtype); break; } /* * clang will complain here about swapped arguments but this is intentional * as this is the reverse trigger from the referenced table back to the * referencing table. * * NOLINTBEGIN(readability-suspicious-call-argument) */ CreateTrigger(fk_trigger, NULL, refRelOid, relid, constraintOid, indexOid, InvalidOid, parentUpdTrigger, NULL, true, false); /* NOLINTEND(readability-suspicious-call-argument) */ /* Make changes-so-far visible */ CommandCounterIncrement(); } /* * Return a list of foreign key pg_constraint heap tuples referencing reloid. */ static List * relation_get_referencing_fk(Oid reloid) { List *result = NIL; Relation conrel; SysScanDesc conscan; ScanKeyData skey[2]; HeapTuple htup; /* Prepare to scan pg_constraint for entries having confrelid = this rel. */ ScanKeyInit(&skey[0], Anum_pg_constraint_confrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(reloid)); ScanKeyInit(&skey[1], Anum_pg_constraint_contype, BTEqualStrategyNumber, F_CHAREQ, CharGetDatum(CONSTRAINT_FOREIGN)); conrel = table_open(ConstraintRelationId, AccessShareLock); conscan = systable_beginscan(conrel, InvalidOid, false, NULL, 2, skey); while (HeapTupleIsValid(htup = systable_getnext(conscan))) { result = lappend(result, heap_copytuple(htup)); } systable_endscan(conscan); table_close(conrel, AccessShareLock); return result; } /* * Return a list of foreign key pg_constraint heap tuples referencing reloid. */ static HeapTuple relation_get_fk_constraint(Oid conrelid, Oid confrelid) { Relation conrel; SysScanDesc conscan; ScanKeyData skey[3]; /* Prepare to scan pg_constraint for entries having confrelid = this rel. */ ScanKeyInit(&skey[0], Anum_pg_constraint_conrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(conrelid)); ScanKeyInit(&skey[1], Anum_pg_constraint_confrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(confrelid)); ScanKeyInit(&skey[2], Anum_pg_constraint_contype, BTEqualStrategyNumber, F_CHAREQ, CharGetDatum(CONSTRAINT_FOREIGN)); conrel = table_open(ConstraintRelationId, AccessShareLock); conscan = systable_beginscan(conrel, InvalidOid, false, NULL, 3, skey); HeapTuple htup = systable_getnext(conscan); if (HeapTupleIsValid(htup)) { htup = heap_copytuple(htup); } systable_endscan(conscan); table_close(conrel, AccessShareLock); return htup; } /* Get the UPDATE and DELETE trigger OIDs for the given constraint OID */ static void constraint_get_trigger(Oid conoid, Oid *updtrigoid, Oid *deltrigoid) { Relation rel; SysScanDesc scan; ScanKeyData skey[1]; HeapTuple htup; *updtrigoid = InvalidOid; *deltrigoid = InvalidOid; ScanKeyInit(&skey[0], Anum_pg_trigger_tgconstraint, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(conoid)); rel = table_open(TriggerRelationId, AccessShareLock); scan = systable_beginscan(rel, TriggerConstraintIndexId, true, NULL, 1, skey); while (HeapTupleIsValid(htup = systable_getnext(scan))) { Form_pg_trigger trigform = (Form_pg_trigger) GETSTRUCT(htup); if ((trigform->tgtype & TRIGGER_TYPE_UPDATE) == TRIGGER_TYPE_UPDATE) *updtrigoid = trigform->oid; if ((trigform->tgtype & TRIGGER_TYPE_DELETE) == TRIGGER_TYPE_DELETE) *deltrigoid = trigform->oid; } systable_endscan(scan); table_close(rel, AccessShareLock); } /* * Return the oid of the index supporting the foreign key constraint. */ static Oid get_fk_index(Relation rel, int nkeys, AttrNumber *confkeys) { Oid indexoid = InvalidOid; List *indexes = RelationGetIndexList(rel); ListCell *lc; foreach (lc, indexes) { Oid indexoid = lfirst_oid(lc); Relation indexrel = index_open(indexoid, AccessShareLock); if (!indexrel->rd_index->indisunique || indexrel->rd_index->indnkeyatts != nkeys) { index_close(indexrel, AccessShareLock); continue; } Bitmapset *con_keys = NULL; Bitmapset *ind_keys = NULL; for (int i = 0; i < nkeys; i++) { /* * Since ordering of the constraint definition and index definition can differ, * we need to check that all the columns in the constraint are present in the index */ con_keys = bms_add_member(con_keys, confkeys[i]); ind_keys = bms_add_member(ind_keys, indexrel->rd_index->indkey.values[i]); } bool match = bms_equal(con_keys, ind_keys); index_close(indexrel, AccessShareLock); bms_free(con_keys); bms_free(ind_keys); if (match) { return indexoid; } } return indexoid; } void ts_chunk_drop_referencing_fk_by_chunk_id(Oid chunk_id) { Chunk *chunk = ts_chunk_get_by_id(chunk_id, true); List *fks = relation_get_referencing_fk(chunk->table_id); ListCell *lc; foreach (lc, fks) { HeapTuple fk_tuple = lfirst(lc); ts_chunk_constraint_drop_from_tuple(fk_tuple); } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/foreign_key.h����������������������������������������������������������������0000664�0000000�0000000�00000001115�15100345067�0017312�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_constraint.h> #include <nodes/parsenodes.h> #include "chunk.h" #include "export.h" #include "hypertable.h" extern TSDLLEXPORT void ts_fk_propagate(Oid conrelid, Hypertable *ht); extern TSDLLEXPORT void ts_chunk_copy_referencing_fk(const Hypertable *ht, const Chunk *chunk); extern TSDLLEXPORT void ts_chunk_drop_referencing_fk_by_chunk_id(Oid chunk_id); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/func_cache.c�����������������������������������������������������������������0000664�0000000�0000000�00000042110�15100345067�0017062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/htup.h> #include <catalog/pg_namespace_d.h> #include <catalog/pg_proc.h> #include <catalog/pg_type.h> #include <miscadmin.h> #include <nodes/pathnodes.h> #include <optimizer/optimizer.h> #include <parser/parse_oper.h> #include <utils/builtins.h> #include <utils/hsearch.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/selfuncs.h> #include <utils/syscache.h> #include "compat/compat.h" #include "cache.h" #include "estimate.h" #include "extension.h" #include "func_cache.h" #include "sort_transform.h" #include "utils.h" /* * func_cache - a cache for quick identification of, and access to, functions * useful for TimescaleDB. The function info is used in various query * optimizations, for instance, we provide custom group estimate functions for * use when grouping on time buckets. We also provide functions that allow * sorting time buckets using an index on the non-bucketed expression/column. */ static Expr * date_trunc_sort_transform(FuncExpr *func) { /* * date_trunc (const, var) => var * * proof: date_trunc(c, time1) >= date_trunc(c,time2) iff time1 > time2 */ Expr *second; if (list_length(func->args) != 2 || !IsA(linitial(func->args), Const)) return (Expr *) func; second = ts_sort_transform_expr(lsecond(func->args)); if (!IsA(second, Var)) return (Expr *) func; return (Expr *) copyObject(second); } /* * Check that time_bucket has a const offset, if an offset is supplied */ #define time_bucket_has_const_offset(func) \ (list_length((func)->args) == 2 || IsA(lthird((func)->args), Const)) #define time_bucket_has_const_period(func) IsA(linitial((func)->args), Const) #define time_bucket_has_const_timezone(func) IsA(lthird((func)->args), Const) static Expr * do_sort_transform(FuncExpr *func) { Expr *second = ts_sort_transform_expr(lsecond(func->args)); if (!IsA(second, Var)) return (Expr *) func; return (Expr *) copyObject(second); } static Expr * time_bucket_gapfill_sort_transform(FuncExpr *func) { /* * time_bucket(const, var, const) => var * * proof: time_bucket(const1, time1) >= time_bucket(const1,time2) iff time1 * > time2 */ Assert(list_length(func->args) == 4 || list_length(func->args) == 5); if (!time_bucket_has_const_period(func) || (list_length(func->args) == 5 && !time_bucket_has_const_timezone(func))) return (Expr *) func; return do_sort_transform(func); } static Expr * time_bucket_sort_transform(FuncExpr *func) { Assert(list_length(func->args) >= 2); /* * If period and offset are not constants we must not do the optimization */ if (!time_bucket_has_const_offset(func)) return (Expr *) func; if (!time_bucket_has_const_period(func)) return (Expr *) func; return do_sort_transform(func); } /* * time_bucket with timezone will always have 5 args. For the sort * optimization to apply all args need to be Const except timestamp. */ static Expr * time_bucket_tz_sort_transform(FuncExpr *func) { Assert(list_length(func->args) == 5); if (!IsA(linitial((func)->args), Const) || !IsA(lthird(func->args), Const) || !IsA(lfourth(func->args), Const) || !IsA(lfifth(func->args), Const)) return (Expr *) func; return do_sort_transform(func); } /* For time_bucket this estimate currently works by seeing how many possible * buckets there will be if the data spans the entire hypertable. Note that * this is an overestimate. * */ static double time_bucket_group_estimate(PlannerInfo *root, FuncExpr *expr, double path_rows) { Node *first_arg = eval_const_expressions(root, linitial(expr->args)); Expr *second_arg = lsecond(expr->args); Const *c; double period; if (!IsA(first_arg, Const)) return INVALID_ESTIMATE; c = (Const *) first_arg; switch (c->consttype) { case INT2OID: period = (double) DatumGetInt16(c->constvalue); break; case INT4OID: period = (double) DatumGetInt32(c->constvalue); break; case INT8OID: period = (double) DatumGetInt64(c->constvalue); break; case INTERVALOID: period = (double) ts_get_interval_period_approx(DatumGetIntervalP(c->constvalue)); break; default: return INVALID_ESTIMATE; } return ts_estimate_group_expr_interval(root, second_arg, period); } /* For date_trunc this estimate currently works by seeing how many possible * buckets there will be if the data spans the entire hypertable. Note that * this is an overestimate. * */ static double date_trunc_group_estimate(PlannerInfo *root, FuncExpr *expr, double path_rows) { Node *first_arg = eval_const_expressions(root, linitial(expr->args)); Expr *second_arg = lsecond(expr->args); Const *c; text *interval; if (!IsA(first_arg, Const)) return INVALID_ESTIMATE; c = (Const *) first_arg; interval = DatumGetTextPP(c->constvalue); return ts_estimate_group_expr_interval(root, second_arg, (double) ts_date_trunc_interval_period_approx(interval)); } typedef struct FuncEntry { Oid funcid; FuncInfo *funcinfo; } FuncEntry; /* Information about functions that we put in the cache */ static FuncInfo funcinfo[] = { { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 2, .arg_types = { INTERVALOID, TIMESTAMPOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Interval Bucket with origin */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INTERVALOID, TIMESTAMPOID, TIMESTAMPOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Interval Bucket with offset */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INTERVALOID, TIMESTAMPOID, INTERVALOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 2, .arg_types = { INTERVALOID, TIMESTAMPTZOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Interval Bucket with origin */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INTERVALOID, TIMESTAMPTZOID, TIMESTAMPTZOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Interval Bucket with offset */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INTERVALOID, TIMESTAMPTZOID, INTERVALOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 2, .arg_types = { INTERVALOID, DATEOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Interval Bucket with origin */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INTERVALOID, DATEOID, DATEOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Interval Bucket with offset */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INTERVALOID, DATEOID, INTERVALOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 2, .arg_types = { INT2OID, INT2OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Int2 Bucket with offset */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INT2OID, INT2OID, INT2OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 2, .arg_types = { INT4OID, INT4OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Int4 Bucket with offset */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INT4OID, INT4OID, INT4OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 2, .arg_types = { INT8OID, INT8OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, /* Int8 Bucket with offset */ { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 3, .arg_types = { INT8OID, INT8OID, INT8OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = true, .funcname = "time_bucket", .nargs = 5, .arg_types = { INTERVALOID, TIMESTAMPTZOID, TEXTOID, TIMESTAMPTZOID, INTERVALOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_tz_sort_transform, }, { .origin = ORIGIN_TIMESCALE_EXPERIMENTAL, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_ng", .nargs = 2, .arg_types = { INTERVALOID, DATEOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE_EXPERIMENTAL, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_ng", .nargs = 3, .arg_types = { INTERVALOID, DATEOID, DATEOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE_EXPERIMENTAL, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_ng", .nargs = 2, .arg_types = { INTERVALOID, TIMESTAMPOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE_EXPERIMENTAL, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_ng", .nargs = 3, .arg_types = { INTERVALOID, TIMESTAMPOID, TIMESTAMPOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE_EXPERIMENTAL, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_ng", .nargs = 3, .arg_types = { INTERVALOID, TIMESTAMPTZOID, TEXTOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE_EXPERIMENTAL, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_ng", .nargs = 4, .arg_types = { INTERVALOID, TIMESTAMPTZOID, TIMESTAMPTZOID, TEXTOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 4, .arg_types = { INTERVALOID, TIMESTAMPOID, TIMESTAMPOID, TIMESTAMPOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 4, .arg_types = { INTERVALOID, TIMESTAMPTZOID, TIMESTAMPTZOID, TIMESTAMPTZOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 5, .arg_types = { INTERVALOID, TIMESTAMPTZOID, TEXTOID, TIMESTAMPTZOID, TIMESTAMPTZOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 4, .arg_types = { INTERVALOID, DATEOID, DATEOID, DATEOID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 4, .arg_types = { INT2OID, INT2OID, INT2OID, INT2OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 4, .arg_types = { INT4OID, INT4OID, INT4OID, INT4OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_TIMESCALE, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "time_bucket_gapfill", .nargs = 4, .arg_types = { INT8OID, INT8OID, INT8OID, INT8OID }, .group_estimate = time_bucket_group_estimate, .sort_transform = time_bucket_gapfill_sort_transform, }, { .origin = ORIGIN_POSTGRES, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "date_trunc", .nargs = 2, .arg_types = { TEXTOID, TIMESTAMPOID }, .group_estimate = date_trunc_group_estimate, .sort_transform = date_trunc_sort_transform, }, { .origin = ORIGIN_POSTGRES, .is_bucketing_func = true, .allowed_in_cagg_definition = false, .funcname = "date_trunc", .nargs = 2, .arg_types = { TEXTOID, TIMESTAMPTZOID }, .group_estimate = date_trunc_group_estimate, .sort_transform = date_trunc_sort_transform, }, }; #define _MAX_CACHE_FUNCTIONS (sizeof(funcinfo) / sizeof(funcinfo[0])) static HTAB *func_hash = NULL; static Oid proc_get_oid(HeapTuple tuple) { Form_pg_proc form = (Form_pg_proc) GETSTRUCT(tuple); return form->oid; } static void initialize_func_info() { HASHCTL hashctl = { .keysize = sizeof(Oid), .entrysize = sizeof(FuncEntry), .hcxt = CacheMemoryContext, }; Oid extension_nsp = ts_extension_schema_oid(); Oid experimental_nsp = get_namespace_oid(ts_experimental_schema_name(), false); HeapTuple tuple; Relation rel; func_hash = hash_create("func_cache", _MAX_CACHE_FUNCTIONS, &hashctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); rel = table_open(ProcedureRelationId, AccessShareLock); for (size_t i = 0; i < _MAX_CACHE_FUNCTIONS; i++) { FuncInfo *finfo = &funcinfo[i]; Oid namespaceoid = PG_CATALOG_NAMESPACE; oidvector *paramtypes = buildoidvector(finfo->arg_types, finfo->nargs); FuncEntry *fentry; bool hash_found; Oid funcid; if (finfo->origin == ORIGIN_TIMESCALE) { namespaceoid = extension_nsp; } else if (finfo->origin == ORIGIN_TIMESCALE_EXPERIMENTAL) { namespaceoid = experimental_nsp; } tuple = SearchSysCache3(PROCNAMEARGSNSP, PointerGetDatum(finfo->funcname), PointerGetDatum(paramtypes), ObjectIdGetDatum(namespaceoid)); if (!HeapTupleIsValid(tuple)) { /* The function cache could be accessed during an extension upgrade. Not all expected * functions have to exist at this point. */ elog(ts_extension_is_loaded_and_not_upgrading() ? ERROR : NOTICE, "cache lookup failed for function \"%s\" with %d args", finfo->funcname, finfo->nargs); continue; } funcid = proc_get_oid(tuple); fentry = hash_search(func_hash, &funcid, HASH_ENTER, &hash_found); Assert(!hash_found); fentry->funcid = funcid; fentry->funcinfo = finfo; ReleaseSysCache(tuple); } table_close(rel, AccessShareLock); } FuncInfo * ts_func_cache_get(Oid funcid) { FuncEntry *entry; if (NULL == func_hash) initialize_func_info(); entry = hash_search(func_hash, &funcid, HASH_FIND, NULL); return (NULL == entry) ? NULL : entry->funcinfo; } FuncInfo * ts_func_cache_get_bucketing_func(Oid funcid) { FuncInfo *finfo = ts_func_cache_get(funcid); if (NULL == finfo) return NULL; return finfo->is_bucketing_func ? finfo : NULL; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/func_cache.h�����������������������������������������������������������������0000664�0000000�0000000�00000002324�15100345067�0017072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/primnodes.h> #include "export.h" #define FUNC_CACHE_MAX_FUNC_ARGS 10 typedef Expr *(*sort_transform_func)(FuncExpr *func); typedef double (*group_estimate_func)(PlannerInfo *root, FuncExpr *expr, double path_rows); /* Describes the function origin */ typedef enum { /* * Function is provided by PostgreSQL. */ ORIGIN_POSTGRES = 0, /* * Function is provided by TimescaleDB. */ ORIGIN_TIMESCALE = 1, /* * Function is provided by TimescaleDB and is experimental. * It should be looked for in the experimental schema. */ ORIGIN_TIMESCALE_EXPERIMENTAL = 2, } FuncOrigin; typedef struct FuncInfo { const char *funcname; FuncOrigin origin; bool is_bucketing_func; bool allowed_in_cagg_definition; int nargs; Oid arg_types[FUNC_CACHE_MAX_FUNC_ARGS]; group_estimate_func group_estimate; sort_transform_func sort_transform; } FuncInfo; extern TSDLLEXPORT FuncInfo *ts_func_cache_get(Oid funcid); extern TSDLLEXPORT FuncInfo *ts_func_cache_get_bucketing_func(Oid funcid); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/gapfill.c��������������������������������������������������������������������0000664�0000000�0000000�00000003001�15100345067�0016416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include "compat/compat.h" #include "cross_module_fn.h" #include "export.h" #include "gapfill.h" #include "license_guc.h" bool ts_is_gapfill_path(Path *path) { if (IsA(path, CustomPath)) { CustomPath *cpath = castNode(CustomPath, path); if (strcmp(cpath->methods->CustomName, GAPFILL_PATH_NAME) == 0) return true; } return false; } /* * stub function to trigger locf and interpolate in gapfill node */ TS_FUNCTION_INFO_V1(ts_gapfill_marker); Datum ts_gapfill_marker(PG_FUNCTION_ARGS) { PG_RETURN_DATUM(ts_cm_functions->gapfill_marker(fcinfo)); } #define GAPFILL_TIMEBUCKET_WRAPPER(datatype) \ TS_FUNCTION_INFO_V1(ts_gapfill_##datatype##_bucket); \ Datum ts_gapfill_##datatype##_bucket(PG_FUNCTION_ARGS) \ { \ return ts_cm_functions->gapfill_##datatype##_time_bucket(fcinfo); \ } GAPFILL_TIMEBUCKET_WRAPPER(int16); GAPFILL_TIMEBUCKET_WRAPPER(int32); GAPFILL_TIMEBUCKET_WRAPPER(int64); GAPFILL_TIMEBUCKET_WRAPPER(date); GAPFILL_TIMEBUCKET_WRAPPER(timestamp); GAPFILL_TIMEBUCKET_WRAPPER(timestamptz); GAPFILL_TIMEBUCKET_WRAPPER(timestamptz_timezone); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/gapfill.h��������������������������������������������������������������������0000664�0000000�0000000�00000000475�15100345067�0016437�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "export.h" #define GAPFILL_PATH_NAME "GapFill" extern TSDLLEXPORT bool ts_is_gapfill_path(Path *path); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/gitcommit.cmake��������������������������������������������������������������0000664�0000000�0000000�00000002530�15100345067�0017640�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# The commands for generating gitcommit.h need to be executed on every make run # and not on cmake run to detect branch switches, commit changes or local # modifications. if(GIT_FOUND) # We use "git describe" to generate the tag. It will find the latest tag and # also add some additional information if we are not on the tag. execute_process( COMMAND ${GIT_EXECUTABLE} describe --dirty --always --tags WORKING_DIRECTORY ${SOURCE_DIR} OUTPUT_VARIABLE EXT_GIT_COMMIT_TAG RESULT_VARIABLE _describe_RESULT OUTPUT_STRIP_TRAILING_WHITESPACE) # Fetch the commit HASH of head (short version) using rev-parse execute_process( COMMAND ${GIT_EXECUTABLE} rev-parse HEAD OUTPUT_VARIABLE EXT_GIT_COMMIT_HASH WORKING_DIRECTORY ${SOURCE_DIR} RESULT_VARIABLE _revparse_RESULT OUTPUT_STRIP_TRAILING_WHITESPACE) # Fetch the date of the head commit execute_process( COMMAND ${GIT_EXECUTABLE} log -1 --format=%cI WORKING_DIRECTORY ${SOURCE_DIR} OUTPUT_VARIABLE EXT_GIT_COMMIT_TIME RESULT_VARIABLE _log_RESULT OUTPUT_STRIP_TRAILING_WHITESPACE) # Results are non-zero if there were an error if(_describe_RESULT OR _revparse_RESULT OR _log_RESULT) message(STATUS "Unable to get git commit information") endif() endif() file(REMOVE ${OUTPUT_FILE}) configure_file(${INPUT_FILE} ${OUTPUT_FILE}) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/gitcommit.h.in���������������������������������������������������������������0000664�0000000�0000000�00000000655�15100345067�0017422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #ifndef GITCOMMIT_H_ #define GITCOMMIT_H_ #cmakedefine EXT_GIT_COMMIT_TAG "@EXT_GIT_COMMIT_TAG@" #cmakedefine EXT_GIT_COMMIT_HASH "@EXT_GIT_COMMIT_HASH@" #cmakedefine EXT_GIT_COMMIT_TIME "@EXT_GIT_COMMIT_TIME@" #endif /* GITCOMMIT_H_ */ �����������������������������������������������������������������������������������timescaledb-2.23.0/src/guc.c������������������������������������������������������������������������0000664�0000000�0000000�00000134266�15100345067�0015600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <miscadmin.h> #include <parser/parse_func.h> #include <utils/guc.h> #include <utils/regproc.h> #include <utils/varlena.h> #include "compat/compat.h" #include "config.h" #include "extension.h" #include "guc.h" #include "hypertable_cache.h" #include "license_guc.h" #ifdef USE_TELEMETRY #include "telemetry/telemetry.h" #endif #ifdef USE_TELEMETRY /* Define which level means on. We use this object to have at least one object * of type TelemetryLevel in the code, otherwise pgindent won't work for the * type */ static const TelemetryLevel on_level = TELEMETRY_NO_FUNCTIONS; bool ts_telemetry_on() { return ts_guc_telemetry_level >= on_level; } bool ts_function_telemetry_on() { return ts_guc_telemetry_level > TELEMETRY_NO_FUNCTIONS; } static const struct config_enum_entry telemetry_level_options[] = { { "off", TELEMETRY_OFF, false }, { "no_functions", TELEMETRY_NO_FUNCTIONS, false }, { "basic", TELEMETRY_BASIC, false }, { NULL, 0, false } }; #endif /* Copied from contrib/auto_explain/auto_explain.c */ static const struct config_enum_entry loglevel_options[] = { { "debug5", DEBUG5, false }, { "debug4", DEBUG4, false }, { "debug3", DEBUG3, false }, { "debug2", DEBUG2, false }, { "debug1", DEBUG1, false }, { "debug", DEBUG2, true }, { "info", INFO, false }, { "notice", NOTICE, false }, { "warning", WARNING, false }, { "log", LOG, false }, { "error", ERROR, false }, { "fatal", FATAL, false }, { NULL, 0, false } }; static const struct config_enum_entry compress_truncate_behaviour_options[] = { { "truncate_only", COMPRESS_TRUNCATE_ONLY, false }, { "truncate_or_delete", COMPRESS_TRUNCATE_OR_DELETE, false }, { "truncate_disabled", COMPRESS_TRUNCATE_DISABLED, false }, { NULL, 0, false } }; #define GUC_CAGG_LOW_WORK_MEM_NAME "cagg_processing_low_work_mem" #define GUC_CAGG_LOW_WORK_MEM_VALUE (0.6 * 65536) #define GUC_CAGG_HIGH_WORK_MEM_NAME "cagg_processing_high_work_mem" #define GUC_CAGG_HIGH_WORK_MEM_VALUE (0.8 * 65536) bool ts_guc_enable_direct_compress_copy = false; bool ts_guc_enable_direct_compress_copy_sort_batches = true; bool ts_guc_enable_direct_compress_copy_client_sorted = false; bool ts_guc_enable_direct_compress_insert = false; bool ts_guc_enable_direct_compress_insert_sort_batches = true; bool ts_guc_enable_direct_compress_insert_client_sorted = false; bool ts_guc_enable_deprecation_warnings = true; bool ts_guc_enable_optimizations = true; bool ts_guc_restoring = false; bool ts_guc_enable_constraint_aware_append = true; bool ts_guc_enable_ordered_append = true; bool ts_guc_enable_chunk_append = true; bool ts_guc_enable_parallel_chunk_append = true; bool ts_guc_enable_runtime_exclusion = true; bool ts_guc_enable_constraint_exclusion = true; bool ts_guc_enable_qual_propagation = true; bool ts_guc_enable_cagg_reorder_groupby = true; TSDLLEXPORT bool ts_guc_enable_cagg_window_functions = false; bool ts_guc_enable_now_constify = true; bool ts_guc_enable_foreign_key_propagation = true; #if PG16_GE TSDLLEXPORT bool ts_guc_enable_cagg_sort_pushdown = true; #endif TSDLLEXPORT bool ts_guc_enable_cagg_watermark_constify = true; TSDLLEXPORT int ts_guc_cagg_max_individual_materializations = 10; TSDLLEXPORT bool ts_guc_enable_cagg_wal_based_invalidation = false; TSDLLEXPORT int ts_guc_cagg_wal_batch_size = 10000; TSDLLEXPORT int ts_guc_cagg_low_work_mem = GUC_CAGG_LOW_WORK_MEM_VALUE; TSDLLEXPORT int ts_guc_cagg_high_work_mem = GUC_CAGG_HIGH_WORK_MEM_VALUE; bool ts_guc_enable_osm_reads = true; TSDLLEXPORT bool ts_guc_enable_compressed_direct_batch_delete = true; TSDLLEXPORT bool ts_guc_enable_dml_decompression = true; TSDLLEXPORT bool ts_guc_enable_dml_decompression_tuple_filtering = true; TSDLLEXPORT int ts_guc_max_tuples_decompressed_per_dml = 100000; TSDLLEXPORT bool ts_guc_enable_transparent_decompression = true; TSDLLEXPORT bool ts_guc_enable_compression_wal_markers = false; TSDLLEXPORT bool ts_guc_enable_decompression_sorted_merge = true; bool ts_guc_enable_chunkwise_aggregation = true; bool ts_guc_enable_vectorized_aggregation = true; bool ts_guc_enable_custom_hashagg = false; TSDLLEXPORT bool ts_guc_enable_compression_indexscan = false; TSDLLEXPORT bool ts_guc_enable_bulk_decompression = true; TSDLLEXPORT bool ts_guc_auto_sparse_indexes = true; TSDLLEXPORT bool ts_guc_enable_sparse_index_bloom = true; bool ts_guc_enable_chunk_skipping = false; TSDLLEXPORT bool ts_guc_enable_segmentwise_recompression = true; TSDLLEXPORT bool ts_guc_enable_exclusive_locking_recompression = false; TSDLLEXPORT bool ts_guc_enable_bool_compression = true; TSDLLEXPORT bool ts_guc_enable_uuid_compression = true; TSDLLEXPORT int ts_guc_compression_batch_size_limit = 1000; TSDLLEXPORT bool ts_guc_compression_enable_compressor_batch_limit = false; TSDLLEXPORT CompressTruncateBehaviour ts_guc_compress_truncate_behaviour = COMPRESS_TRUNCATE_ONLY; bool ts_guc_enable_event_triggers = false; bool ts_guc_debug_skip_scan_info = false; /* Only settable in debug mode for testing */ TSDLLEXPORT bool ts_guc_enable_null_compression = true; TSDLLEXPORT bool ts_guc_enable_compression_ratio_warnings = true; /* Enable of disable columnar scans for columnar-oriented storage engines. If * disabled, regular sequence scans will be used instead. */ TSDLLEXPORT bool ts_guc_enable_columnarscan = true; TSDLLEXPORT int ts_guc_bgw_log_level = WARNING; TSDLLEXPORT bool ts_guc_enable_skip_scan = true; #if PG16_GE TSDLLEXPORT bool ts_guc_enable_skip_scan_for_distinct_aggregates = true; #endif TSDLLEXPORT bool ts_guc_enable_compressed_skip_scan = true; TSDLLEXPORT bool ts_guc_enable_multikey_skip_scan = true; TSDLLEXPORT double ts_guc_skip_scan_run_cost_multiplier = 1.0; static char *ts_guc_default_segmentby_fn = NULL; static char *ts_guc_default_orderby_fn = NULL; TSDLLEXPORT bool ts_guc_enable_job_execution_logging = false; bool ts_guc_enable_tss_callbacks = true; TSDLLEXPORT bool ts_guc_enable_delete_after_compression = false; TSDLLEXPORT bool ts_guc_enable_merge_on_cagg_refresh = false; /* default value of ts_guc_max_open_chunks_per_insert and * ts_guc_max_cached_chunks_per_hypertable will be set as their respective boot-value when the * GUC mechanism starts up */ int ts_guc_max_open_chunks_per_insert; int ts_guc_max_cached_chunks_per_hypertable; #ifdef USE_TELEMETRY TelemetryLevel ts_guc_telemetry_level = TELEMETRY_DEFAULT; char *ts_telemetry_cloud = NULL; #endif TSDLLEXPORT char *ts_guc_license = TS_LICENSE_DEFAULT; char *ts_last_tune_time = NULL; char *ts_last_tune_version = NULL; bool ts_guc_debug_allow_cagg_with_deprecated_funcs = false; /* * Exit code for the scheduler. * * Normally it exits with a zero which means that it will not restart. If an * error is raised, it exits with error code 1, which will trigger a * restart. * * This variable exists to be able to trigger a restart for a normal exit, * which is useful when debugging. * * See backend/postmaster/bgworker.c */ int ts_debug_bgw_scheduler_exit_status = 0; #ifdef TS_DEBUG bool ts_shutdown_bgw = false; char *ts_current_timestamp_mock = NULL; #endif int ts_guc_debug_toast_tuple_target = 128; static const struct config_enum_entry debug_require_options[] = { { "allow", DRO_Allow, false }, { "forbid", DRO_Forbid, false }, { "require", DRO_Require, false }, { "force", DRO_Force, false }, { NULL, 0, false } }; #ifdef TS_DEBUG bool ts_guc_debug_have_int128; DebugRequireOption ts_guc_debug_require_vector_qual = DRO_Allow; DebugRequireOption ts_guc_debug_require_vector_agg = DRO_Allow; #endif DebugRequireOption ts_guc_debug_require_batch_sorted_merge = false; bool ts_guc_debug_compression_path_info = false; bool ts_guc_enable_rowlevel_compression_locking = false; static bool ts_guc_enable_hypertable_create = true; static bool ts_guc_enable_hypertable_compression = true; static bool ts_guc_enable_cagg_create = true; static bool ts_guc_enable_policy_create = true; typedef struct { const char *name; const char *description; bool *enable; } FeatureFlag; static FeatureFlag ts_feature_flags[] = { [FEATURE_HYPERTABLE] = { MAKE_EXTOPTION("enable_hypertable_create"), "Enable creation of hypertable", &ts_guc_enable_hypertable_create }, [FEATURE_HYPERTABLE_COMPRESSION] = { MAKE_EXTOPTION("enable_hypertable_compression"), "Enable hypertable compression functions", &ts_guc_enable_hypertable_compression }, [FEATURE_CAGG] = { MAKE_EXTOPTION("enable_cagg_create"), "Enable creation of continuous aggregate", &ts_guc_enable_cagg_create }, [FEATURE_POLICY] = { MAKE_EXTOPTION("enable_policy_create"), "Enable creation of policies and user-defined actions", &ts_guc_enable_policy_create } }; static void ts_feature_flag_add(FeatureFlagType type) { FeatureFlag *flag = &ts_feature_flags[type]; int flag_context = PGC_SIGHUP; #ifdef TS_DEBUG flag_context = PGC_USERSET; #endif DefineCustomBoolVariable(flag->name, flag->description, NULL, flag->enable, true, flag_context, GUC_SUPERUSER_ONLY, NULL, NULL, NULL); } void ts_feature_flag_check(FeatureFlagType type) { FeatureFlag *flag = &ts_feature_flags[type]; if (likely(*flag->enable)) return; ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("You are using a PostgreSQL service. This feature is only available on " "Time-series and analytics services. " "https://docs.timescale.com/use-timescale/latest/services/"))); } /* * We have to understand if we have finished initializing the GUCs, so that we * know when it's OK to check their values for mutual consistency. */ static bool gucs_are_initialized = false; /* * Warn about the mismatched cache sizes that can lead to cache thrashing. */ static void validate_chunk_cache_sizes(int hypertable_chunks, int insert_chunks) { /* * Note that this callback is also called when the individual GUCs are * initialized, so we are going to see temporary mismatched values here. * That's why we also have to check that the GUC initialization have * finished. */ if (gucs_are_initialized && insert_chunks > hypertable_chunks) { ereport(WARNING, (errmsg("insert cache size is larger than hypertable chunk cache size"), errdetail("insert cache size is %d, hypertable chunk cache size is %d", insert_chunks, hypertable_chunks), errhint("This is a configuration problem. Either increase " "timescaledb.max_cached_chunks_per_hypertable (preferred) or decrease " "timescaledb.max_open_chunks_per_insert."))); } } static void assign_max_cached_chunks_per_hypertable_hook(int newval, void *extra) { /* invalidate the hypertable cache to reset */ ts_hypertable_cache_invalidate_callback(); validate_chunk_cache_sizes(newval, ts_guc_max_open_chunks_per_insert); } static void assign_max_open_chunks_per_insert_hook(int newval, void *extra) { validate_chunk_cache_sizes(ts_guc_max_cached_chunks_per_hypertable, newval); } static Oid get_segmentby_func(char *input_name) { List *namelist = NIL; if (strlen(input_name) == 0) { return InvalidOid; } #if PG16_LT namelist = stringToQualifiedNameList(input_name); #else namelist = stringToQualifiedNameList(input_name, NULL); #endif Oid argtyp[] = { REGCLASSOID }; return LookupFuncName(namelist, lengthof(argtyp), argtyp, true); } static bool check_cagg_low_work_mem(int *newval, void **extra, GucSource source) { if (*newval >= ts_guc_cagg_high_work_mem) { GUC_check_errdetail("\"%s\" must be less than value of \"%s\".", GUC_CAGG_LOW_WORK_MEM_NAME, GUC_CAGG_HIGH_WORK_MEM_NAME); GUC_check_errhint("Set \"%s\" to a value less than %d.", GUC_CAGG_LOW_WORK_MEM_NAME, ts_guc_cagg_high_work_mem); return false; } return true; } static bool check_cagg_high_work_mem(int *newval, void **extra, GucSource source) { if (*newval <= ts_guc_cagg_low_work_mem) { GUC_check_errdetail("\"%s\" must be greater than value of \"%s\".", GUC_CAGG_HIGH_WORK_MEM_NAME, GUC_CAGG_LOW_WORK_MEM_NAME); GUC_check_errhint("Set \"%s\" to a value greater than %d.", GUC_CAGG_HIGH_WORK_MEM_NAME, ts_guc_cagg_low_work_mem); return false; } return true; } static bool check_segmentby_func(char **newval, void **extra, GucSource source) { /* if the extension doesn't exist you can't check for the function, have to take it on faith */ if (ts_extension_is_loaded_and_not_upgrading()) { Oid segment_func_oid = get_segmentby_func(*newval); if (strlen(*newval) > 0 && !OidIsValid(segment_func_oid)) { GUC_check_errdetail("Function \"%s\" does not exist.", *newval); return false; } } return true; } Oid ts_guc_default_segmentby_fn_oid() { return get_segmentby_func(ts_guc_default_segmentby_fn); } static Oid get_orderby_func(char *input_name) { List *namelist = NIL; if (strlen(input_name) == 0) { return InvalidOid; } #if PG16_LT namelist = stringToQualifiedNameList(input_name); #else namelist = stringToQualifiedNameList(input_name, NULL); #endif Oid argtyp[] = { REGCLASSOID, TEXTARRAYOID }; return LookupFuncName(namelist, lengthof(argtyp), argtyp, true); } static bool check_orderby_func(char **newval, void **extra, GucSource source) { /* if the extension doesn't exist you can't check for the function, have to take it on faith */ if (ts_extension_is_loaded_and_not_upgrading()) { Oid func_oid = get_orderby_func(*newval); if (strlen(*newval) > 0 && !OidIsValid(func_oid)) { GUC_check_errdetail("Function \"%s\" does not exist.", *newval); return false; } } return true; } Oid ts_guc_default_orderby_fn_oid() { return get_orderby_func(ts_guc_default_orderby_fn); } void _guc_init(void) { DefineCustomBoolVariable(MAKE_EXTOPTION("enable_deprecation_warnings"), "Enable warnings when using deprecated functionality", NULL, &ts_guc_enable_deprecation_warnings, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_direct_compress_copy"), "Enable direct compression during COPY", "Enable experimental support for direct compression during COPY", &ts_guc_enable_direct_compress_copy, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_direct_compress_copy_sort_batches"), "Enable batch sorting during direct compress COPY", NULL, &ts_guc_enable_direct_compress_copy_sort_batches, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_direct_compress_copy_client_sorted"), "Enable direct compress COPY with presorted data", "Correct handling of data sorting by the user is required for this " "option.", &ts_guc_enable_direct_compress_copy_client_sorted, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_direct_compress_insert"), "Enable direct compression during INSERT", "Enable experimental support for direct compression during INSERT", &ts_guc_enable_direct_compress_insert, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_direct_compress_insert_sort_batches"), "Enable batch sorting during direct compress INSERT", NULL, &ts_guc_enable_direct_compress_insert_sort_batches, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_direct_compress_insert_client_sorted"), "Enable direct compress INSERT with presorted data", "Correct handling of data sorting by the user is required for this " "option.", &ts_guc_enable_direct_compress_insert_client_sorted, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_optimizations"), "Enable TimescaleDB query optimizations", NULL, &ts_guc_enable_optimizations, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("restoring"), "Enable restoring mode for timescaledb", "In restoring mode all timescaledb internal hooks are disabled. This " "mode is required for restoring logical dumps of databases with " "timescaledb.", &ts_guc_restoring, false, PGC_SUSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_constraint_aware_append"), "Enable constraint-aware append scans", "Enable constraint exclusion at execution time", &ts_guc_enable_constraint_aware_append, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_ordered_append"), "Enable ordered append scans", "Enable ordered append optimization for queries that are ordered by " "the time dimension", &ts_guc_enable_ordered_append, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_chunk_append"), "Enable chunk append node", "Enable using chunk append node", &ts_guc_enable_chunk_append, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_parallel_chunk_append"), "Enable parallel chunk append node", "Enable using parallel aware chunk append node", &ts_guc_enable_parallel_chunk_append, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_runtime_exclusion"), "Enable runtime chunk exclusion", "Enable runtime chunk exclusion in ChunkAppend node", &ts_guc_enable_runtime_exclusion, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_constraint_exclusion"), "Enable constraint exclusion", "Enable planner constraint exclusion", &ts_guc_enable_constraint_exclusion, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_foreign_key_propagation"), "Enable foreign key propagation", "Adjust foreign key lookup queries to target whole hypertable", &ts_guc_enable_foreign_key_propagation, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_qual_propagation"), "Enable qualifier propagation", "Enable propagation of qualifiers in JOINs", &ts_guc_enable_qual_propagation, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_dml_decompression"), "Enable DML decompression", "Enable DML decompression when modifying compressed hypertable", &ts_guc_enable_dml_decompression, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_dml_decompression_tuple_filtering"), "Enable DML decompression tuple filtering", "Recheck tuples during DML decompression to only decompress batches " "with matching tuples", &ts_guc_enable_dml_decompression_tuple_filtering, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_compressed_direct_batch_delete"), "Enable direct deletion of compressed batches", "Enable direct batch deletion in compressed chunks", &ts_guc_enable_compressed_direct_batch_delete, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomIntVariable(MAKE_EXTOPTION("max_tuples_decompressed_per_dml_transaction"), "The max number of tuples that can be decompressed during an " "INSERT, UPDATE, or DELETE.", " If the number of tuples exceeds this value, an error will " "be thrown and transaction rolled back. " "Setting this to 0 sets this value to unlimited number of " "tuples decompressed.", &ts_guc_max_tuples_decompressed_per_dml, 100000, 0, 2147483647, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_transparent_decompression"), "Enable transparent decompression", "Enable transparent decompression when querying hypertable", &ts_guc_enable_transparent_decompression, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_skipscan"), "Enable SkipScan", "Enable SkipScan for DISTINCT queries", &ts_guc_enable_skip_scan, true, PGC_USERSET, 0, NULL, NULL, NULL); #if PG16_GE DefineCustomBoolVariable(MAKE_EXTOPTION("enable_skipscan_for_distinct_aggregates"), "Enable SkipScan for DISTINCT aggregates", "Enable SkipScan for DISTINCT aggregates", &ts_guc_enable_skip_scan_for_distinct_aggregates, true, PGC_USERSET, 0, NULL, NULL, NULL); #endif DefineCustomBoolVariable(MAKE_EXTOPTION("enable_compressed_skipscan"), "Enable SkipScan for compressed chunks", "Enable SkipScan for distinct inputs over compressed chunks", &ts_guc_enable_compressed_skip_scan, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_multikey_skipscan"), "Enable SkipScan for multiple distinct keys", "Enable SkipScan for multiple distinct inputs", &ts_guc_enable_multikey_skip_scan, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomRealVariable(MAKE_EXTOPTION("skip_scan_run_cost_multiplier"), "Multiplier for SkipScan run cost as an option to make the cost " "smaller so that SkipScan can be chosen", "Default is 1.0 i.e. regularly estimated SkipScan run cost, 0.0 will " "make SkipScan to have run cost = 0", &ts_guc_skip_scan_run_cost_multiplier, 1.0, 0.0, 1.0, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("debug_skip_scan_info"), "Print debug info about SkipScan", "Print debug info about SkipScan distinct columns", &ts_guc_debug_skip_scan_info, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_compression_wal_markers"), "Enable WAL markers for compression ops", "Enable the generation of markers in the WAL stream which mark the " "start and end of compression operations", &ts_guc_enable_compression_wal_markers, true, PGC_SIGHUP, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_decompression_sorted_merge"), "Enable compressed batches heap merge", "Enable the merge of compressed batches to preserve the compression " "order by", &ts_guc_enable_decompression_sorted_merge, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_cagg_reorder_groupby"), "Enable group by reordering", "Enable group by clause reordering for continuous aggregates", &ts_guc_enable_cagg_reorder_groupby, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_cagg_window_functions"), "Enable window functions in continuous aggregates", "Allow window functions in continuous aggregate views", &ts_guc_enable_cagg_window_functions, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_now_constify"), "Enable now() constify", "Enable constifying now() in query constraints", &ts_guc_enable_now_constify, true, PGC_USERSET, 0, NULL, NULL, NULL); #if PG16_GE DefineCustomBoolVariable(MAKE_EXTOPTION("enable_cagg_sort_pushdown"), "Enable sort pushdown for continuous aggregates", "Enable pushdown of ORDER BY clause for continuous aggregates", &ts_guc_enable_cagg_sort_pushdown, true, PGC_USERSET, 0, NULL, NULL, NULL); #endif DefineCustomBoolVariable(MAKE_EXTOPTION("enable_cagg_watermark_constify"), "Enable cagg watermark constify", "Enable constifying cagg watermark for real-time caggs", &ts_guc_enable_cagg_watermark_constify, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_merge_on_cagg_refresh"), "Enable MERGE statement on cagg refresh", "Enable MERGE statement on cagg refresh", &ts_guc_enable_merge_on_cagg_refresh, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_chunk_skipping"), "Enable chunk skipping functionality", "Enable using chunk column stats to filter chunks based on column " "filters", &ts_guc_enable_chunk_skipping, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_segmentwise_recompression"), "Enable segmentwise recompression functionality", "Enable segmentwise recompression", &ts_guc_enable_segmentwise_recompression, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_exclusive_locking_recompression"), "Enable exclusive locking recompression", "Enable getting exclusive lock on chunk during segmentwise " "recompression", &ts_guc_enable_exclusive_locking_recompression, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_bool_compression"), "Enable bool compression functionality", "Enable bool compression", &ts_guc_enable_bool_compression, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_uuid_compression"), "Enable uuid compression functionality", "Enable uuid compression", &ts_guc_enable_uuid_compression, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomIntVariable(MAKE_EXTOPTION("compression_batch_size_limit"), "The max number of tuples that can be batched together during " "compression", "Setting this option to a number between 1 and 999 will force " "compression " "to limit the size of compressed batches to that amount of " "uncompressed tuples." "Setting this to 0 defaults to the max batch size of 1000.", &ts_guc_compression_batch_size_limit, 1000, 1, 1000, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_compressor_batch_limit"), "Enable compressor batch limit", "Enable compressor batch limit for compressors which " "can go over the allocation limit (1 GB). This feature will" "limit those compressors by reducing the size of the batch and thus " "avoid hitting the limit.", &ts_guc_compression_enable_compressor_batch_limit, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_event_triggers"), "Enable event triggers for chunks creation", "Enable event triggers for chunks creation", &ts_guc_enable_event_triggers, false, PGC_SUSET, 0, NULL, NULL, NULL); #ifdef TS_DEBUG DefineCustomBoolVariable(MAKE_EXTOPTION("enable_null_compression"), "Debug only flag to enable NULL compression", "Enable null compression", &ts_guc_enable_null_compression, true, PGC_USERSET, 0, NULL, NULL, NULL); #endif DefineCustomBoolVariable(MAKE_EXTOPTION("enable_compression_ratio_warnings"), "Enable warnings for poor compression ratio", "Enable warnings for poor compression ratio", &ts_guc_enable_compression_ratio_warnings, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_cagg_wal_based_invalidation"), "Enable experimental invalidations for continuous aggregates using " "WAL", "Use WAL to track changes to hypertables for continuous aggregates. " "This is not meant for production use.", &ts_guc_enable_cagg_wal_based_invalidation, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomIntVariable(MAKE_EXTOPTION("cagg_processing_wal_batch_size"), "Batch size when processing WAL entries.", "Number of entries processed from the WAL at a go. Larger values take " "more memory but might be more efficient.", &ts_guc_cagg_wal_batch_size, 10000, 1000, 10000000, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomIntVariable(MAKE_EXTOPTION(GUC_CAGG_LOW_WORK_MEM_NAME), "Low working memory limit for continuous aggregate invalidation " "processing.", "The low working memory limit for the continuous aggregate " "invalidation processing.", &ts_guc_cagg_low_work_mem, GUC_CAGG_LOW_WORK_MEM_VALUE, 64, MAX_KILOBYTES, PGC_USERSET, GUC_UNIT_KB, check_cagg_low_work_mem, NULL, NULL); DefineCustomIntVariable(MAKE_EXTOPTION(GUC_CAGG_HIGH_WORK_MEM_NAME), "High working memory limit for continuous aggregate invalidation " "processing.", "The high working memory limit for the continuous aggregate " "invalidation processing.", &ts_guc_cagg_high_work_mem, GUC_CAGG_HIGH_WORK_MEM_VALUE, 64, MAX_KILOBYTES, PGC_USERSET, GUC_UNIT_KB, check_cagg_high_work_mem, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_tiered_reads"), "Enable tiered data reads", "Enable reading of tiered data by including a foreign table " "representing the data in the object storage into the query plan", &ts_guc_enable_osm_reads, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_chunkwise_aggregation"), "Enable chunk-wise aggregation", "Enable the pushdown of aggregations to the" " chunk level", &ts_guc_enable_chunkwise_aggregation, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_custom_hashagg"), "Enable custom hash aggregation", "Enable creating custom hash aggregation plans", &ts_guc_enable_custom_hashagg, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_vectorized_aggregation"), "Enable vectorized aggregation", "Enable vectorized aggregation for compressed data", &ts_guc_enable_vectorized_aggregation, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_compression_indexscan"), "Enable compression to take indexscan path", "Enable indexscan during compression, if matching index is found", &ts_guc_enable_compression_indexscan, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_bulk_decompression"), "Enable decompression of the entire compressed batches", "Increases throughput of decompression, but might increase query " "memory usage", &ts_guc_enable_bulk_decompression, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("auto_sparse_indexes"), "Create sparse indexes on compressed chunks", "The hypertable columns that are used as index keys will have " "suitable sparse indexes when compressed. Must be set at the moment " "of chunk compression, e.g. when the `compress_chunk()` is called.", &ts_guc_auto_sparse_indexes, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_sparse_index_bloom"), "Enable creation of the bloom1 sparse index on compressed chunks", "This sparse index speeds up the equality queries on compressed " "columns, and can be disabled when not desired.", &ts_guc_enable_sparse_index_bloom, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_columnarscan"), "Enable columnar-optimized scans for supported access methods", "A columnar scan replaces sequence scans for columnar-oriented " "storage " "and enables storage-specific optimizations like vectorized filters. " "Disabling columnar scan will make PostgreSQL fall back to regular " "sequence scans.", &ts_guc_enable_columnarscan, true, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomIntVariable(MAKE_EXTOPTION("max_open_chunks_per_insert"), "Maximum open chunks per insert", "Maximum number of open chunk tables per insert", &ts_guc_max_open_chunks_per_insert, 1024, 0, PG_INT16_MAX, PGC_USERSET, 0, NULL, assign_max_open_chunks_per_insert_hook, NULL); DefineCustomIntVariable(MAKE_EXTOPTION("max_cached_chunks_per_hypertable"), "Maximum cached chunks", "Maximum number of chunks stored in the cache", &ts_guc_max_cached_chunks_per_hypertable, 1024, 0, 65536, PGC_USERSET, 0, NULL, assign_max_cached_chunks_per_hypertable_hook, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_job_execution_logging"), "Enable job execution logging", "Retain job run status in logging table", &ts_guc_enable_job_execution_logging, false, PGC_SIGHUP, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_tss_callbacks"), "Enable ts_stat_statements callbacks", "Enable ts_stat_statements callbacks", &ts_guc_enable_tss_callbacks, true, PGC_SUSET, 0, NULL, NULL, NULL); DefineCustomBoolVariable(MAKE_EXTOPTION("enable_delete_after_compression"), "Delete all rows after compression instead of truncate", "Delete all rows after compression instead of truncate", &ts_guc_enable_delete_after_compression, false, PGC_USERSET, 0, NULL, NULL, NULL); DefineCustomEnumVariable(MAKE_EXTOPTION("compress_truncate_behaviour"), "Define behaviour of truncate after compression", "Defines how truncate behaves at the end of compression. " "'truncate_only' forces truncation. 'truncate_disabled' deletes rows " "instead of truncate. 'truncate_or_delete' allows falling back to " "deletion.", (int *) &ts_guc_compress_truncate_behaviour, COMPRESS_TRUNCATE_ONLY, compress_truncate_behaviour_options, PGC_USERSET, 0, NULL, NULL, NULL); #ifdef USE_TELEMETRY DefineCustomEnumVariable(MAKE_EXTOPTION("telemetry_level"), "Telemetry settings level", "Level used to determine which telemetry to send", (int *) &ts_guc_telemetry_level, TELEMETRY_DEFAULT, telemetry_level_options, PGC_USERSET, 0, NULL, NULL, NULL); #endif DefineCustomStringVariable(/* name= */ MAKE_EXTOPTION("compression_segmentby_default_function"), /* short_desc= */ "Function that sets default segment_by", /* long_desc= */ "Function to use for calculating default segment_by setting for " "compression", /* valueAddr= */ &ts_guc_default_segmentby_fn, /* Value= */ "_timescaledb_functions.get_segmentby_defaults", /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ check_segmentby_func, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomStringVariable(/* name= */ MAKE_EXTOPTION("compression_orderby_default_function"), /* short_desc= */ "Function that sets default order_by", /* long_desc= */ "Function to use for calculating default order_by setting for " "compression", /* valueAddr= */ &ts_guc_default_orderby_fn, /* Value= */ "_timescaledb_functions.get_orderby_defaults", /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ check_orderby_func, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomStringVariable(/* name= */ MAKE_EXTOPTION("license"), /* short_desc= */ "TimescaleDB license type", /* long_desc= */ "Determines which features are enabled", /* valueAddr= */ &ts_guc_license, /* bootValue= */ TS_LICENSE_DEFAULT, /* context= */ PGC_SUSET, /* flags= */ 0, /* check_hook= */ ts_license_guc_check_hook, /* assign_hook= */ ts_license_guc_assign_hook, /* show_hook= */ NULL); DefineCustomStringVariable(/* name= */ MAKE_EXTOPTION("last_tuned"), /* short_desc= */ "last tune run", /* long_desc= */ "records last time timescaledb-tune ran", /* valueAddr= */ &ts_last_tune_time, /* bootValue= */ NULL, /* context= */ PGC_SIGHUP, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomStringVariable(/* name= */ MAKE_EXTOPTION("last_tuned_version"), /* short_desc= */ "version of timescaledb-tune", /* long_desc= */ "version of timescaledb-tune used to tune", /* valueAddr= */ &ts_last_tune_version, /* bootValue= */ NULL, /* context= */ PGC_SIGHUP, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomEnumVariable(MAKE_EXTOPTION("bgw_log_level"), "Log level for the background worker subsystem", "Log level for the scheduler and workers of the background worker " "subsystem. Requires configuration reload to change.", /* valueAddr= */ &ts_guc_bgw_log_level, /* bootValue= */ WARNING, /* options= */ loglevel_options, /* context= */ PGC_SUSET, 0, NULL, NULL, NULL); /* this information is useful in general on customer deployments */ DefineCustomBoolVariable(/* name= */ MAKE_EXTOPTION("debug_compression_path_info"), /* short_desc= */ "show various compression-related debug info", /* long_desc= */ "this is for debugging/information purposes", /* valueAddr= */ &ts_guc_debug_compression_path_info, /* bootValue= */ false, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomBoolVariable(/* name= */ MAKE_EXTOPTION("enable_rowlevel_compression_locking"), /* short_desc= */ "Use rowlevel locking during compression", /* long_desc= */ "Use only if you know what you are doing", /* valueAddr= */ &ts_guc_enable_rowlevel_compression_locking, /* bootValue= */ false, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); #ifdef USE_TELEMETRY DefineCustomStringVariable(/* name= */ "timescaledb_telemetry.cloud", /* short_desc= */ "cloud provider", /* long_desc= */ "cloud provider used for this instance", /* valueAddr= */ &ts_telemetry_cloud, /* bootValue= */ NULL, /* context= */ PGC_SIGHUP, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); #endif DefineCustomIntVariable(/* name= */ MAKE_EXTOPTION("debug_bgw_scheduler_exit_status"), /* short_desc= */ "exit status to use when shutting down the scheduler", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ &ts_debug_bgw_scheduler_exit_status, /* bootValue= */ 0, /* minValue= */ 0, /* maxValue= */ 255, /* context= */ PGC_SIGHUP, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomEnumVariable(/* name= */ MAKE_EXTOPTION("debug_require_batch_sorted_merge"), /* short_desc= */ "require batch sorted merge in ColumnarScan node", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ (int *) &ts_guc_debug_require_batch_sorted_merge, /* bootValue= */ DRO_Allow, /* options = */ debug_require_options, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); #ifdef TS_DEBUG DefineCustomBoolVariable(/* name= */ MAKE_EXTOPTION("shutdown_bgw_scheduler"), /* short_desc= */ "immediately shutdown the bgw scheduler", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ &ts_shutdown_bgw, /* bootValue= */ false, /* context= */ PGC_SIGHUP, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomStringVariable(/* name= */ MAKE_EXTOPTION("current_timestamp_mock"), /* short_desc= */ "set the current timestamp", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ &ts_current_timestamp_mock, /* bootValue= */ NULL, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomIntVariable(/* name= */ MAKE_EXTOPTION("debug_toast_tuple_target"), /* short_desc= */ "set toast tuple target on compressed chunks", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ &ts_guc_debug_toast_tuple_target, /* bootValue = */ 128, /* minValue = */ 1, /* maxValue = */ 65535, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomBoolVariable(/* name= */ MAKE_EXTOPTION("debug_have_int128"), /* short_desc= */ "whether we have int128 support", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ &ts_guc_debug_have_int128, #ifdef HAVE_INT128 /* bootValue= */ true, #else /* bootValue= */ false, #endif /* context= */ PGC_INTERNAL, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomEnumVariable(/* name= */ MAKE_EXTOPTION("debug_require_vector_agg"), /* short_desc= */ "ensure that vectorized aggregation is used or not", /* long_desc= */ "this is for debugging purposes", /* valueAddr= */ (int *) &ts_guc_debug_require_vector_agg, /* bootValue= */ DRO_Allow, /* options = */ debug_require_options, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomEnumVariable(/* name= */ MAKE_EXTOPTION("debug_require_vector_qual"), /* short_desc= */ "ensure that non-vectorized or vectorized filters are used in " "ColumnarScan node", /* long_desc= */ "this is for debugging purposes, to let us check if the vectorized " "quals are used or not. EXPLAIN differs after PG15 for custom nodes, " "and " "using the test templates is a pain", /* valueAddr= */ (int *) &ts_guc_debug_require_vector_qual, /* bootValue= */ DRO_Allow, /* options = */ debug_require_options, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); DefineCustomBoolVariable(/* name= */ MAKE_EXTOPTION("debug_allow_cagg_with_deprecated_funcs"), /* short_desc= */ "allow new caggs using time_bucket_ng", /* long_desc= */ "this is for debugging/testing purposes", /* valueAddr= */ &ts_guc_debug_allow_cagg_with_deprecated_funcs, /* bootValue= */ false, /* context= */ PGC_USERSET, /* flags= */ 0, /* check_hook= */ NULL, /* assign_hook= */ NULL, /* show_hook= */ NULL); #endif /* register feature flags */ ts_feature_flag_add(FEATURE_HYPERTABLE); ts_feature_flag_add(FEATURE_HYPERTABLE_COMPRESSION); ts_feature_flag_add(FEATURE_CAGG); ts_feature_flag_add(FEATURE_POLICY); gucs_are_initialized = true; validate_chunk_cache_sizes(ts_guc_max_cached_chunks_per_hypertable, ts_guc_max_open_chunks_per_insert); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/guc.h������������������������������������������������������������������������0000664�0000000�0000000�00000013636�15100345067�0015602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "compat/compat.h" #include "config.h" #include "export.h" #ifdef USE_TELEMETRY extern bool ts_telemetry_on(void); extern bool ts_function_telemetry_on(void); #endif extern bool ts_guc_enable_deprecation_warnings; extern bool ts_guc_enable_optimizations; extern bool ts_guc_enable_constraint_aware_append; extern bool ts_guc_enable_ordered_append; extern bool ts_guc_enable_chunk_append; extern bool ts_guc_enable_parallel_chunk_append; extern bool ts_guc_enable_qual_propagation; extern bool ts_guc_enable_runtime_exclusion; extern bool ts_guc_enable_constraint_exclusion; extern bool ts_guc_enable_cagg_reorder_groupby; extern TSDLLEXPORT bool ts_guc_enable_cagg_window_functions; extern TSDLLEXPORT int ts_guc_cagg_max_individual_materializations; extern TSDLLEXPORT bool ts_guc_enable_cagg_wal_based_invalidation; extern TSDLLEXPORT int ts_guc_cagg_wal_batch_size; extern TSDLLEXPORT int ts_guc_cagg_low_work_mem; extern TSDLLEXPORT int ts_guc_cagg_high_work_mem; extern bool ts_guc_enable_now_constify; extern bool ts_guc_enable_foreign_key_propagation; extern TSDLLEXPORT bool ts_guc_enable_osm_reads; #if PG16_GE extern TSDLLEXPORT bool ts_guc_enable_cagg_sort_pushdown; #endif extern TSDLLEXPORT bool ts_guc_enable_cagg_watermark_constify; extern TSDLLEXPORT bool ts_guc_enable_dml_decompression; extern TSDLLEXPORT bool ts_guc_enable_dml_decompression_tuple_filtering; extern bool ts_guc_enable_direct_compress_copy; extern bool ts_guc_enable_direct_compress_copy_sort_batches; extern bool ts_guc_enable_direct_compress_copy_client_sorted; extern bool ts_guc_enable_direct_compress_insert; extern bool ts_guc_enable_direct_compress_insert_sort_batches; extern bool ts_guc_enable_direct_compress_insert_client_sorted; extern TSDLLEXPORT bool ts_guc_enable_compressed_direct_batch_delete; extern TSDLLEXPORT int ts_guc_max_tuples_decompressed_per_dml; extern TSDLLEXPORT bool ts_guc_enable_transparent_decompression; extern TSDLLEXPORT bool ts_guc_enable_compression_wal_markers; extern TSDLLEXPORT bool ts_guc_enable_decompression_sorted_merge; extern TSDLLEXPORT bool ts_guc_enable_skip_scan; extern TSDLLEXPORT bool ts_guc_enable_chunkwise_aggregation; extern TSDLLEXPORT bool ts_guc_enable_vectorized_aggregation; extern TSDLLEXPORT bool ts_guc_enable_custom_hashagg; extern bool ts_guc_restoring; extern int ts_guc_max_open_chunks_per_insert; extern int ts_guc_max_cached_chunks_per_hypertable; extern TSDLLEXPORT bool ts_guc_enable_job_execution_logging; extern bool ts_guc_enable_tss_callbacks; extern TSDLLEXPORT bool ts_guc_enable_delete_after_compression; extern TSDLLEXPORT bool ts_guc_enable_merge_on_cagg_refresh; extern bool ts_guc_enable_chunk_skipping; extern TSDLLEXPORT bool ts_guc_enable_segmentwise_recompression; extern TSDLLEXPORT bool ts_guc_enable_exclusive_locking_recompression; extern TSDLLEXPORT bool ts_guc_enable_bool_compression; extern TSDLLEXPORT bool ts_guc_enable_uuid_compression; extern TSDLLEXPORT int ts_guc_compression_batch_size_limit; extern TSDLLEXPORT bool ts_guc_compression_enable_compressor_batch_limit; #if PG16_GE extern TSDLLEXPORT bool ts_guc_enable_skip_scan_for_distinct_aggregates; #endif extern bool ts_guc_enable_event_triggers; extern TSDLLEXPORT bool ts_guc_enable_compressed_skip_scan; extern TSDLLEXPORT bool ts_guc_enable_multikey_skip_scan; extern TSDLLEXPORT double ts_guc_skip_scan_run_cost_multiplier; extern TSDLLEXPORT bool ts_guc_debug_skip_scan_info; /* Only settable in debug mode for testing */ extern TSDLLEXPORT bool ts_guc_enable_null_compression; extern TSDLLEXPORT bool ts_guc_enable_compression_ratio_warnings; typedef enum CompressTruncateBehaviour { COMPRESS_TRUNCATE_ONLY, COMPRESS_TRUNCATE_OR_DELETE, COMPRESS_TRUNCATE_DISABLED, } CompressTruncateBehaviour; extern TSDLLEXPORT CompressTruncateBehaviour ts_guc_compress_truncate_behaviour; #ifdef USE_TELEMETRY typedef enum TelemetryLevel { TELEMETRY_OFF, TELEMETRY_NO_FUNCTIONS, TELEMETRY_BASIC, } TelemetryLevel; extern TelemetryLevel ts_guc_telemetry_level; extern char *ts_telemetry_cloud; #endif extern TSDLLEXPORT char *ts_guc_license; extern char *ts_last_tune_time; extern char *ts_last_tune_version; extern TSDLLEXPORT bool ts_guc_enable_2pc; extern TSDLLEXPORT bool ts_guc_enable_compression_indexscan; extern TSDLLEXPORT bool ts_guc_enable_bulk_decompression; extern TSDLLEXPORT bool ts_guc_auto_sparse_indexes; extern TSDLLEXPORT bool ts_guc_enable_sparse_index_bloom; extern TSDLLEXPORT bool ts_guc_enable_columnarscan; extern TSDLLEXPORT int ts_guc_bgw_log_level; /* * Exit code to use when scheduler exits. * * Used for debugging. */ extern TSDLLEXPORT int ts_debug_bgw_scheduler_exit_status; #ifdef TS_DEBUG extern bool ts_shutdown_bgw; extern char *ts_current_timestamp_mock; #else #define ts_shutdown_bgw false #endif extern TSDLLEXPORT int ts_guc_debug_toast_tuple_target; typedef enum DebugRequireOption { DRO_Allow = 0, DRO_Forbid, DRO_Require, DRO_Force, } DebugRequireOption; #ifdef TS_DEBUG extern TSDLLEXPORT DebugRequireOption ts_guc_debug_require_vector_qual; extern TSDLLEXPORT DebugRequireOption ts_guc_debug_require_vector_agg; #endif extern TSDLLEXPORT bool ts_guc_debug_compression_path_info; extern TSDLLEXPORT bool ts_guc_enable_rowlevel_compression_locking; extern TSDLLEXPORT DebugRequireOption ts_guc_debug_require_batch_sorted_merge; extern TSDLLEXPORT bool ts_guc_debug_allow_cagg_with_deprecated_funcs; void _guc_init(void); typedef enum { FEATURE_HYPERTABLE, FEATURE_HYPERTABLE_COMPRESSION, FEATURE_CAGG, FEATURE_POLICY } FeatureFlagType; extern TSDLLEXPORT void ts_feature_flag_check(FeatureFlagType); extern TSDLLEXPORT Oid ts_guc_default_segmentby_fn_oid(void); extern TSDLLEXPORT Oid ts_guc_default_orderby_fn_oid(void); extern TSDLLEXPORT bool ts_is_whitelisted_indexam(const char *amname); ��������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/histogram.c������������������������������������������������������������������0000664�0000000�0000000�00000016322�15100345067�0017007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <libpq/pqformat.h> #include <netinet/in.h> #include <nodes/makefuncs.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include "compat/compat.h" #include "debug_assert.h" #include "utils.h" /* aggregate histogram: * histogram(state, val, min, max, nbuckets) returns the histogram array with nbuckets * * Usage: * SELECT grouping_element, histogram(field, min, max, nbuckets) FROM table GROUP BY *grouping_element. * * Description: * Histogram generates a histogram array based off of a specified range passed into the function. * Values falling outside of this range are bucketed into the 0 or nbucket+1 buckets depending on * if they are below or above the range, respectively. The resultant histogram therefore contains * nbucket+2 buckets accounting for buckets outside the range. */ TS_FUNCTION_INFO_V1(ts_hist_sfunc); TS_FUNCTION_INFO_V1(ts_hist_combinefunc); TS_FUNCTION_INFO_V1(ts_hist_serializefunc); TS_FUNCTION_INFO_V1(ts_hist_deserializefunc); TS_FUNCTION_INFO_V1(ts_hist_finalfunc); #define HISTOGRAM_SIZE(state, nbuckets) \ (sizeof(*(state)) + ((nbuckets) * sizeof(*(state)->buckets))) typedef struct Histogram { int32 nbuckets; Datum buckets[FLEXIBLE_ARRAY_MEMBER]; } Histogram; /* histogram(state, val, min, max, nbuckets) */ Datum ts_hist_sfunc(PG_FUNCTION_ARGS) { MemoryContext aggcontext; Histogram *state = (Histogram *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); Datum val_datum = PG_GETARG_DATUM(1); Datum min_datum = PG_GETARG_DATUM(2); Datum max_datum = PG_GETARG_DATUM(3); double min = DatumGetFloat8(min_datum); double max = DatumGetFloat8(max_datum); int nbuckets; if (!AggCheckCallContext(fcinfo, &aggcontext)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_hist_sfunc called in non-aggregate context"); } if (min > max) { /* cannot generate a histogram with incompatible bounds */ elog(ERROR, "lower bound cannot exceed upper bound"); } if (state == NULL) { nbuckets = PG_GETARG_INT32(4) + 2; /* Allocate memory to a new histogram state array */ state = MemoryContextAllocZero(aggcontext, HISTOGRAM_SIZE(state, nbuckets)); state->nbuckets = nbuckets; } /* Since the number of buckets is an argument to the calls it might differ * from the number we initialized with so we need to make sure we check * against what we actually have. */ nbuckets = state->nbuckets - 2; if (nbuckets != PG_GETARG_INT32(4)) elog(ERROR, "number of buckets must not change between calls"); int32 bucket = DatumGetInt32(DirectFunctionCall4(width_bucket_float8, val_datum, min_datum, max_datum, Int32GetDatum(nbuckets))); /* Increment the proper histogram bucket */ if (bucket < 0 || bucket >= state->nbuckets) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("index %d from \"width_bucket\" out of range", bucket), errhint("You probably have a floating point overflow."))); if (DatumGetInt32(state->buckets[bucket]) >= PG_INT32_MAX - 1) elog(ERROR, "overflow in histogram"); state->buckets[bucket] = Int32GetDatum(DatumGetInt32(state->buckets[bucket]) + 1); PG_RETURN_POINTER(state); } /* Make a copy of the histogram state */ static inline Histogram * copy_state(MemoryContext aggcontext, Histogram *state) { Histogram *copy; Size bucket_bytes = state->nbuckets * sizeof(*copy->buckets); copy = MemoryContextAlloc(aggcontext, sizeof(*copy) + bucket_bytes); copy->nbuckets = state->nbuckets; memcpy(copy->buckets, state->buckets, bucket_bytes); return copy; } /* ts_hist_combinefunc(internal, internal) => internal */ Datum ts_hist_combinefunc(PG_FUNCTION_ARGS) { MemoryContext aggcontext; Histogram *state1 = (Histogram *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); Histogram *state2 = (Histogram *) (PG_ARGISNULL(1) ? NULL : PG_GETARG_POINTER(1)); Histogram *result; if (!AggCheckCallContext(fcinfo, &aggcontext)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_hist_combinefunc called in non-aggregate context"); } if (state1 == NULL && state2 == NULL) { PG_RETURN_NULL(); } else if (state2 == NULL) { result = copy_state(aggcontext, state1); } else if (state1 == NULL) { result = copy_state(aggcontext, state2); } else { /* Since number of buckets is part of the aggregation call the initialization * might be different in the partials so we error out if they are not identical. */ if (state1->nbuckets != state2->nbuckets) elog(ERROR, "number of buckets must not change between calls"); result = copy_state(aggcontext, state1); /* Combine values from state1 and state2 when both states are non-null */ for (int32 i = 0; i < state1->nbuckets; i++) { /* Perform addition using int64 to check for overflow */ int64 val = (int64) DatumGetInt32(result->buckets[i]); int64 other = (int64) DatumGetInt32(state2->buckets[i]); if (val + other >= PG_INT32_MAX) elog(ERROR, "overflow in histogram combine"); result->buckets[i] = Int32GetDatum((int32) (val + other)); } } PG_RETURN_POINTER(result); } /* ts_hist_serializefunc(internal) => bytea */ Datum ts_hist_serializefunc(PG_FUNCTION_ARGS) { Histogram *state; StringInfoData buf; Assert(!PG_ARGISNULL(0)); state = (Histogram *) PG_GETARG_POINTER(0); pq_begintypsend(&buf); pq_sendint32(&buf, state->nbuckets); for (int32 i = 0; i < state->nbuckets; i++) pq_sendint32(&buf, DatumGetInt32(state->buckets[i])); PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); } /* ts_hist_deserializefunc(bytea *, internal) => internal */ Datum ts_hist_deserializefunc(PG_FUNCTION_ARGS) { MemoryContext aggcontext; bytea *serialized; int32 nbuckets; int32 i; StringInfoData buf; Histogram *state; if (!AggCheckCallContext(fcinfo, &aggcontext)) elog(ERROR, "ts_hist_deserializefunc called in non-aggregate context"); Assert(!PG_ARGISNULL(0)); serialized = PG_GETARG_BYTEA_P(0); buf.data = VARDATA(serialized); buf.len = VARSIZE(serialized) - VARHDRSZ; buf.maxlen = VARSIZE(serialized) - VARHDRSZ; buf.cursor = 0; /* used by pq_getmsgint*/ nbuckets = pq_getmsgint(&buf, 4); state = MemoryContextAllocZero(aggcontext, HISTOGRAM_SIZE(state, nbuckets)); state->nbuckets = nbuckets; for (i = 0; i < state->nbuckets; i++) state->buckets[i] = Int32GetDatum(pq_getmsgint(&buf, 4)); PG_RETURN_POINTER(state); } /* hist_finalfunc(internal, val REAL, MIN REAL, MAX REAL, nbuckets INTEGER) => INTEGER[] */ Datum ts_hist_finalfunc(PG_FUNCTION_ARGS) { Histogram *state; int dims[1]; int lbs[1]; if (!AggCheckCallContext(fcinfo, NULL)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_hist_finalfunc called in non-aggregate context"); } state = (Histogram *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (state == NULL) PG_RETURN_NULL(); dims[0] = state->nbuckets; lbs[0] = 1; PG_RETURN_ARRAYTYPE_P( construct_md_array(state->buckets, NULL, 1, dims, lbs, INT4OID, 4, true, 'i')); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypercube.c������������������������������������������������������������������0000664�0000000�0000000�00000022025�15100345067�0016775�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <utils/jsonb.h> #include <utils/numeric.h> #include "dimension_vector.h" #include "export.h" #include "hypercube.h" /* * A hypercube represents the partition bounds of a hypertable chunk. * * A hypercube consists of N slices that each represent a range in a particular * dimension that make up the hypercube. When a new tuple is inserted into a * hypertable, and no chunk exists that can hold that tuple, we need to * calculate a new hypercube that encloses the point corresponding to the * tuple. When calculating the hypercube, we need to account for alignment * requirements in dimensions marked as "aligned" and also ensure that there are * no collisions with existing chunks. Alignment issues and collisions can occur * when the partitioning configuration has changed (e.g., the time interval or * number of partitions in a particular dimension changed). */ Hypercube * ts_hypercube_alloc(int16 num_dimensions) { Hypercube *hc = palloc0(HYPERCUBE_SIZE(num_dimensions)); hc->capacity = num_dimensions; return hc; } void ts_hypercube_free(Hypercube *hc) { int i; for (i = 0; i < hc->num_slices; i++) ts_dimension_slice_free(hc->slices[i]); pfree(hc); } #if defined(USE_ASSERT_CHECKING) static inline bool hypercube_is_sorted(const Hypercube *hc) { int i; if (hc->num_slices < 2) return true; for (i = 1; i < hc->num_slices; i++) if (hc->slices[i]->fd.dimension_id < hc->slices[i - 1]->fd.dimension_id) return false; return true; } #endif Hypercube * ts_hypercube_copy(const Hypercube *hc) { Hypercube *copy; size_t nbytes = HYPERCUBE_SIZE(hc->capacity); int i; copy = palloc(nbytes); memcpy(copy, hc, nbytes); for (i = 0; i < hc->num_slices; i++) copy->slices[i] = ts_dimension_slice_copy(hc->slices[i]); return copy; } bool ts_hypercube_equal(const Hypercube *hc1, const Hypercube *hc2) { int i; if (hc1->num_slices != hc2->num_slices) return false; for (i = 0; i < hc1->num_slices; i++) if (ts_dimension_slice_cmp(hc1->slices[i], hc2->slices[i]) != 0) return false; return true; } static int cmp_slices_by_dimension_id(const void *left, const void *right) { const DimensionSlice *left_slice = *((DimensionSlice **) left); const DimensionSlice *right_slice = *((DimensionSlice **) right); if (left_slice->fd.dimension_id == right_slice->fd.dimension_id) return 0; if (left_slice->fd.dimension_id < right_slice->fd.dimension_id) return -1; return 1; } DimensionSlice * ts_hypercube_add_slice_from_range(Hypercube *hc, int32 dimension_id, int64 start, int64 end) { DimensionSlice *slice; Assert(hc->capacity > hc->num_slices); slice = ts_dimension_slice_create(dimension_id, start, end); hc->slices[hc->num_slices++] = slice; /* Check if we require a sort to maintain dimension order */ if (hc->num_slices > 1 && slice->fd.dimension_id < hc->slices[hc->num_slices - 2]->fd.dimension_id) ts_hypercube_slice_sort(hc); Assert(hypercube_is_sorted(hc)); return slice; } DimensionSlice * ts_hypercube_add_slice(Hypercube *hc, const DimensionSlice *slice) { DimensionSlice *new_slice; new_slice = ts_hypercube_add_slice_from_range(hc, slice->fd.dimension_id, slice->fd.range_start, slice->fd.range_end); new_slice->fd.id = slice->fd.id; return new_slice; } /* * Sort the hypercubes slices in ascending dimension ID order. This allows us to * iterate slices in a consistent order. */ void ts_hypercube_slice_sort(Hypercube *hc) { qsort((void *) hc->slices, hc->num_slices, sizeof(DimensionSlice *), cmp_slices_by_dimension_id); } const DimensionSlice * ts_hypercube_get_slice_by_dimension_id(const Hypercube *hc, int32 dimension_id) { DimensionSlice slice = { .fd.dimension_id = dimension_id, }; void *ptr = &slice; if (hc->num_slices == 0) return NULL; Assert(hypercube_is_sorted(hc)); ptr = bsearch((void *) &ptr, (void *) hc->slices, hc->num_slices, sizeof(DimensionSlice *), cmp_slices_by_dimension_id); if (NULL == ptr) return NULL; return *((DimensionSlice **) ptr); } /* * Given a set of constraints, build the corresponding hypercube. */ Hypercube * ts_hypercube_from_constraints(const ChunkConstraints *constraints, ScanIterator *slice_it) { Hypercube *hc; int i; MemoryContext old; old = MemoryContextSwitchTo(ts_scan_iterator_get_result_memory_context(slice_it)); hc = ts_hypercube_alloc(constraints->num_dimension_constraints); MemoryContextSwitchTo(old); for (i = 0; i < constraints->num_constraints; i++) { ChunkConstraint *cc = chunk_constraints_get(constraints, i); if (is_dimension_constraint(cc)) { DimensionSlice *slice; Assert(hc->num_slices < constraints->num_dimension_constraints); /* When building the hypercube, we reference the dimension slices * to construct the hypercube. * * However, we cannot add a tuple lock when running in recovery * mode since that prevents SELECT statements (which reach this * point) from running on a read-only secondary (which runs in * ephemeral recovery mode), so we only take the lock if we are not * in recovery mode. */ slice = ts_dimension_slice_scan_iterator_get_by_id(slice_it, cc->fd.dimension_slice_id); Assert(slice != NULL); hc->slices[hc->num_slices++] = slice; } } ts_hypercube_slice_sort(hc); Assert(hypercube_is_sorted(hc)); return hc; } /* * Find slices in the hypercube that already exists in metadata. * * If a slice exists in metadata, the slice ID will be filled in on the * existing slice in the hypercube. Optionally, also lock the slice when * found. */ int ts_hypercube_find_existing_slices(const Hypercube *cube, const ScanTupLock *tuplock) { int i; int num_found = 0; for (i = 0; i < cube->num_slices; i++) { /* * Check if there's already an existing slice with the calculated * range. If a slice already exists, use that slice's ID instead * of a new one. */ bool found = ts_dimension_slice_scan_for_existing(cube->slices[i], tuplock); if (found) num_found++; } return num_found; } /* * Calculate the hypercube that encloses the given point. * * The hypercube's dimensions are calculated one by one, and depend on the * current partitioning in each dimension of the N-dimensional hyperspace, * including any alignment requirements. * * For non-aligned dimensions, we simply calculate the hypercube's slice range * in that dimension given current partitioning configuration. If there is * already an identical slice for that dimension, we will reuse it rather than * creating a new one. * * For aligned dimensions, we first try to find an existing slice that covers * the insertion point. If an existing slice is found, we reuse it or otherwise * we calculate a new slice as described for non-aligned dimensions. * * If a hypercube has dimension slices that are not reused ones, we might need * to cut them to ensure alignment and avoid collisions with other chunk * hypercubes. This happens in a later step. */ Hypercube * ts_hypercube_calculate_from_point(const Hyperspace *hs, const Point *p, const ScanTupLock *tuplock) { Hypercube *cube; int i; cube = ts_hypercube_alloc(hs->num_dimensions); /* For each dimension, calculate the hypercube's slice in that dimension */ for (i = 0; i < hs->num_dimensions; i++) { const Dimension *dim = &hs->dimensions[i]; int64 value = p->coordinates[i]; bool found = false; bool check_for_existing_slice = false; /* Assert that dimensions are in ascending order */ Assert(i == 0 || dim->fd.id > hs->dimensions[i - 1].fd.id); if (dim->fd.aligned) { DimensionVec *vec; vec = ts_dimension_slice_scan_limit(dim->fd.id, value, 1, tuplock); if (vec->num_slices > 0) { cube->slices[i] = vec->slices[0]; found = true; } } if (!found) { /* * No existing slice found, or we are not aligning, so calculate * the range of a new slice */ cube->slices[i] = ts_dimension_calculate_default_slice(dim, value); check_for_existing_slice = true; } if (check_for_existing_slice) { /* * Check if there's already an existing slice with the calculated * range. If a slice already exists, use that slice's ID instead * of a new one. */ ts_dimension_slice_scan_for_existing(cube->slices[i], tuplock); } } cube->num_slices = hs->num_dimensions; Assert(hypercube_is_sorted(cube)); return cube; } /* * Check if two hypercubes collide (overlap). * * This is basically an axis-aligned bounding box collision detection, * generalized to N dimensions. We check for dimension slice collisions in each * dimension and only if all dimensions collide there is a hypercube collision. */ bool ts_hypercubes_collide(const Hypercube *cube1, const Hypercube *cube2) { int i; Assert(cube1->num_slices == cube2->num_slices); for (i = 0; i < cube1->num_slices; i++) if (!ts_dimension_slices_collide(cube1->slices[i], cube2->slices[i])) return false; return true; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypercube.h������������������������������������������������������������������0000664�0000000�0000000�00000003724�15100345067�0017007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "dimension_slice.h" #include "scan_iterator.h" /* * Hypercube is a collection of slices from N distinct dimensions, i.e., the * N-dimensional analogue of a cube. */ typedef struct Hypercube { int16 capacity; /* capacity of slices[] */ int16 num_slices; /* actual number of slices (should equal * capacity after create) */ /* Slices are stored in dimension order */ DimensionSlice *slices[FLEXIBLE_ARRAY_MEMBER]; } Hypercube; #define HYPERCUBE_SIZE(num_dimensions) \ (sizeof(Hypercube) + (sizeof(DimensionSlice *) * (num_dimensions))) extern TSDLLEXPORT Hypercube *ts_hypercube_alloc(int16 num_dimensions); extern TSDLLEXPORT void ts_hypercube_free(Hypercube *hc); extern TSDLLEXPORT DimensionSlice * ts_hypercube_add_slice_from_range(Hypercube *hc, int32 dimension_id, int64 start, int64 end); extern TSDLLEXPORT DimensionSlice *ts_hypercube_add_slice(Hypercube *hc, const DimensionSlice *slice); extern Hypercube *ts_hypercube_from_constraints(const ChunkConstraints *constraints, ScanIterator *slice_it); extern int ts_hypercube_find_existing_slices(const Hypercube *cube, const ScanTupLock *tuplock); extern Hypercube *ts_hypercube_calculate_from_point(const Hyperspace *hs, const Point *p, const ScanTupLock *tuplock); extern bool ts_hypercubes_collide(const Hypercube *cube1, const Hypercube *cube2); extern TSDLLEXPORT const DimensionSlice *ts_hypercube_get_slice_by_dimension_id(const Hypercube *hc, int32 dimension_id); extern TSDLLEXPORT Hypercube *ts_hypercube_copy(const Hypercube *hc); extern bool ts_hypercube_equal(const Hypercube *hc1, const Hypercube *hc2); extern void ts_hypercube_slice_sort(Hypercube *hc); ��������������������������������������������timescaledb-2.23.0/src/hypertable.c�����������������������������������������������������������������0000664�0000000�0000000�00000235377�15100345067�0017166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/htup_details.h> #include <access/relscan.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/pg_collation.h> #include <catalog/pg_constraint.h> #include <catalog/pg_database_d.h> #include <catalog/pg_inherits.h> #include <catalog/pg_namespace_d.h> #include <catalog/pg_proc.h> #include <catalog/pg_type.h> #include <commands/dbcommands.h> #include <commands/schemacmds.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <commands/trigger.h> #include <executor/spi.h> #include <funcapi.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/memnodes.h> #include <nodes/parsenodes.h> #include <nodes/value.h> #include <parser/parse_coerce.h> #include <parser/parse_func.h> #include <storage/lmgr.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include "hypertable.h" #include "compat/compat.h" #include "bgw_policy/policy.h" #include "chunk.h" #include "chunk_adaptive.h" #include "copy.h" #include "cross_module_fn.h" #include "debug_assert.h" #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "error_utils.h" #include "errors.h" #include "guc.h" #include "hypercube.h" #include "hypertable_cache.h" #include "indexing.h" #include "license_guc.h" #include "osm_callbacks.h" #include "scan_iterator.h" #include "scanner.h" #include "subspace_store.h" #include "trigger.h" #include "ts_catalog/catalog.h" #include "ts_catalog/chunk_column_stats.h" #include "ts_catalog/compression_settings.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/metadata.h" #include "utils.h" Oid ts_rel_get_owner(Oid relid) { HeapTuple tuple; Oid ownerid; if (!OidIsValid(relid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("invalid relation OID"))); tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tuple)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("relation with OID %u does not exist", relid))); ownerid = ((Form_pg_class) GETSTRUCT(tuple))->relowner; ReleaseSysCache(tuple); return ownerid; } bool ts_hypertable_has_privs_of(Oid hypertable_oid, Oid userid) { return has_privs_of_role(userid, ts_rel_get_owner(hypertable_oid)); } /* * The error output for permission denied errors such as these changed in PG11, * it modifies places where relation is specified to note the specific object * type we note that permissions are denied for the hypertable for all PG * versions so that tests need not change due to one word changes in error * messages and because it is more clear this way. */ Oid ts_hypertable_permissions_check(Oid hypertable_oid, Oid userid) { Oid ownerid = ts_rel_get_owner(hypertable_oid); if (!has_privs_of_role(userid, ownerid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of hypertable \"%s\"", get_rel_name(hypertable_oid)))); return ownerid; } void ts_hypertable_permissions_check_by_id(int32 hypertable_id) { Oid table_relid = ts_hypertable_id_to_relid(hypertable_id, false); ts_hypertable_permissions_check(table_relid, GetUserId()); } static Oid get_chunk_sizing_func_oid(const FormData_hypertable *fd) { Oid argtype[] = { INT4OID, INT8OID, INT8OID }; return LookupFuncName(list_make2(makeString((char *) NameStr(fd->chunk_sizing_func_schema)), makeString((char *) NameStr(fd->chunk_sizing_func_name))), sizeof(argtype) / sizeof(argtype[0]), argtype, false); } static HeapTuple hypertable_formdata_make_tuple(const FormData_hypertable *fd, TupleDesc desc) { Datum values[Natts_hypertable]; bool nulls[Natts_hypertable] = { false }; memset(values, 0, sizeof(Datum) * Natts_hypertable); values[AttrNumberGetAttrOffset(Anum_hypertable_id)] = Int32GetDatum(fd->id); values[AttrNumberGetAttrOffset(Anum_hypertable_schema_name)] = NameGetDatum(&fd->schema_name); values[AttrNumberGetAttrOffset(Anum_hypertable_table_name)] = NameGetDatum(&fd->table_name); values[AttrNumberGetAttrOffset(Anum_hypertable_associated_schema_name)] = NameGetDatum(&fd->associated_schema_name); Assert(&fd->associated_table_prefix != NULL); values[AttrNumberGetAttrOffset(Anum_hypertable_associated_table_prefix)] = NameGetDatum(&fd->associated_table_prefix); values[AttrNumberGetAttrOffset(Anum_hypertable_num_dimensions)] = Int16GetDatum(fd->num_dimensions); values[AttrNumberGetAttrOffset(Anum_hypertable_chunk_sizing_func_schema)] = NameGetDatum(&fd->chunk_sizing_func_schema); values[AttrNumberGetAttrOffset(Anum_hypertable_chunk_sizing_func_name)] = NameGetDatum(&fd->chunk_sizing_func_name); values[AttrNumberGetAttrOffset(Anum_hypertable_chunk_target_size)] = Int64GetDatum(fd->chunk_target_size); values[AttrNumberGetAttrOffset(Anum_hypertable_compression_state)] = Int16GetDatum(fd->compression_state); if (fd->compressed_hypertable_id == INVALID_HYPERTABLE_ID) nulls[AttrNumberGetAttrOffset(Anum_hypertable_compressed_hypertable_id)] = true; else values[AttrNumberGetAttrOffset(Anum_hypertable_compressed_hypertable_id)] = Int32GetDatum(fd->compressed_hypertable_id); values[AttrNumberGetAttrOffset(Anum_hypertable_status)] = Int32GetDatum(fd->status); return heap_form_tuple(desc, values, nulls); } void ts_hypertable_formdata_fill(FormData_hypertable *fd, const TupleInfo *ti) { bool nulls[Natts_hypertable]; Datum values[Natts_hypertable]; bool should_free; HeapTuple tuple; tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_id)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_schema_name)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_table_name)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_associated_schema_name)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_associated_table_prefix)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_num_dimensions)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_chunk_sizing_func_schema)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_chunk_sizing_func_name)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_chunk_target_size)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_compression_state)]); Assert(!nulls[AttrNumberGetAttrOffset(Anum_hypertable_status)]); fd->id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_hypertable_id)]); namestrcpy(&fd->schema_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_hypertable_schema_name)])); namestrcpy(&fd->table_name, DatumGetCString(values[AttrNumberGetAttrOffset(Anum_hypertable_table_name)])); namestrcpy(&fd->associated_schema_name, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_hypertable_associated_schema_name)])); namestrcpy(&fd->associated_table_prefix, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_hypertable_associated_table_prefix)])); fd->num_dimensions = DatumGetInt16(values[AttrNumberGetAttrOffset(Anum_hypertable_num_dimensions)]); namestrcpy(&fd->chunk_sizing_func_schema, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_hypertable_chunk_sizing_func_schema)])); namestrcpy(&fd->chunk_sizing_func_name, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_hypertable_chunk_sizing_func_name)])); fd->chunk_target_size = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_hypertable_chunk_target_size)]); fd->compression_state = DatumGetInt16(values[AttrNumberGetAttrOffset(Anum_hypertable_compression_state)]); if (nulls[AttrNumberGetAttrOffset(Anum_hypertable_compressed_hypertable_id)]) fd->compressed_hypertable_id = INVALID_HYPERTABLE_ID; else fd->compressed_hypertable_id = DatumGetInt32( values[AttrNumberGetAttrOffset(Anum_hypertable_compressed_hypertable_id)]); fd->status = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_hypertable_status)]); if (should_free) heap_freetuple(tuple); } Hypertable * ts_hypertable_from_tupleinfo(const TupleInfo *ti) { Hypertable *h = MemoryContextAllocZero(ti->mctx, sizeof(Hypertable)); ts_hypertable_formdata_fill(&h->fd, ti); h->main_table_relid = ts_get_relation_relid(NameStr(h->fd.schema_name), NameStr(h->fd.table_name), true); h->space = ts_dimension_scan(h->fd.id, h->main_table_relid, h->fd.num_dimensions, ti->mctx); h->chunk_cache = ts_subspace_store_init(h->space, ti->mctx, ts_guc_max_cached_chunks_per_hypertable); h->chunk_sizing_func = get_chunk_sizing_func_oid(&h->fd); if (ts_guc_enable_chunk_skipping) { h->range_space = ts_chunk_column_stats_range_space_scan(h->fd.id, h->main_table_relid, ti->mctx); } return h; } /* * Find either the hypertable or the materialized hypertable, if the relid is * a continuous aggregate, for the relid. * * If allow_matht is false, relid should be a cagg or a hypertable. * If allow_matht is true, materialized hypertable is also permitted as relid */ Hypertable * ts_resolve_hypertable_from_table_or_cagg(Cache *hcache, Oid relid, bool allow_matht) { const char *rel_name; Hypertable *ht; rel_name = get_rel_name(relid); if (!rel_name) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("invalid hypertable or continuous aggregate"))); ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (ht) { const ContinuousAggHypertableStatus status = ts_continuous_agg_hypertable_status(ht->fd.id); switch (status) { case HypertableIsMaterialization: case HypertableIsMaterializationAndRaw: if (!allow_matht) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on materialized hypertable"), errhint("Try the operation on the continuous aggregate instead."), errdetail("Hypertable \"%s\" is a materialized hypertable.", rel_name))); } break; default: break; } } else { ContinuousAgg *const cagg = ts_continuous_agg_find_by_relid(relid); if (!cagg) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("\"%s\" is not a hypertable or a continuous aggregate", rel_name), errhint("The operation is only possible on a hypertable or continuous" " aggregate."))); ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); if (!ht) ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("no materialized table for continuous aggregate"), errdetail("Continuous aggregate \"%s\" had a materialized hypertable" " with id %d but it was not found in the hypertable " "catalog.", rel_name, cagg->data.mat_hypertable_id))); } return ht; } static ScanTupleResult hypertable_tuple_get_relid(TupleInfo *ti, void *data) { Oid *relid = data; FormData_hypertable fd; Oid schema_oid; ts_hypertable_formdata_fill(&fd, ti); schema_oid = get_namespace_oid(NameStr(fd.schema_name), true); if (OidIsValid(schema_oid)) *relid = get_relname_relid(NameStr(fd.table_name), schema_oid); return SCAN_DONE; } Oid ts_hypertable_id_to_relid(int32 hypertable_id, bool return_invalid) { Catalog *catalog = ts_catalog_get(); Oid relid = InvalidOid; ScanKeyData scankey[1]; ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, HYPERTABLE), .index = catalog_get_index(catalog, HYPERTABLE, HYPERTABLE_ID_INDEX), .nkeys = 1, .scankey = scankey, .tuple_found = hypertable_tuple_get_relid, .data = &relid, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, }; /* Perform an index scan on the hypertable pkey. */ ScanKeyInit(&scankey[0], Anum_hypertable_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); ts_scanner_scan(&scanctx); Ensure(return_invalid || OidIsValid(relid), "unable to get valid parent Oid for hypertable %d", hypertable_id); return relid; } int32 ts_hypertable_relid_to_id(Oid relid) { Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(relid, CACHE_FLAG_MISSING_OK, &hcache); int result = ht ? ht->fd.id : INVALID_HYPERTABLE_ID; ts_cache_release(&hcache); return result; } static int hypertable_scan_limit_internal(ScanKeyData *scankey, int num_scankeys, int indexid, tuple_found_func on_tuple_found, void *scandata, int limit, LOCKMODE lock, MemoryContext mctx, tuple_filter_func filter) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, HYPERTABLE), .index = catalog_get_index(catalog, HYPERTABLE, indexid), .nkeys = num_scankeys, .scankey = scankey, .data = scandata, .limit = limit, .tuple_found = on_tuple_found, .lockmode = lock, .filter = filter, .scandirection = ForwardScanDirection, .result_mctx = mctx, }; return ts_scanner_scan(&scanctx); } /* update the tuple at this tid. The assumption is that we already hold a * tuple exclusive lock and no other transaction can modify this tuple * The sequence of operations for any update is: * lock the tuple using lock_hypertable_tuple. * then update the required fields * call hypertable_update_catalog_tuple to complete the update. * This ensures correct tuple locking and tuple updates in the presence of * concurrent transactions. Failure to follow this results in catalog corruption */ static void hypertable_update_catalog_tuple(ItemPointer tid, FormData_hypertable *update) { HeapTuple new_tuple; CatalogSecurityContext sec_ctx; Catalog *catalog = ts_catalog_get(); Oid table = catalog_get_table_id(catalog, HYPERTABLE); Relation hypertable_rel = relation_open(table, RowExclusiveLock); new_tuple = hypertable_formdata_make_tuple(update, hypertable_rel->rd_att); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(hypertable_rel, tid, new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); relation_close(hypertable_rel, NoLock); } static bool lock_hypertable_tuple(int32 htid, ItemPointer tid, FormData_hypertable *form) { bool success = false; ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; ScanIterator iterator = ts_scan_iterator_create(HYPERTABLE, RowShareLock, CurrentMemoryContext); iterator.ctx.index = catalog_get_index(ts_catalog_get(), HYPERTABLE, HYPERTABLE_ID_INDEX); iterator.ctx.tuplock = &scantuplock; /* Keeping the lock since we presumably want to update the tuple */ iterator.ctx.flags = SCANNER_F_KEEPLOCK; /* see table_tuple_lock for details about flags that are set in TupleExclusive mode */ scantuplock.lockflags = TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS; if (!IsolationUsesXactSnapshot()) { /* in read committed mode, we follow all updates to this tuple */ scantuplock.lockflags |= TUPLE_LOCK_FLAG_FIND_LAST_VERSION; } ts_scan_iterator_scan_key_init(&iterator, Anum_hypertable_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(htid)); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); if (ti->lockresult != TM_Ok) { if (IsolationUsesXactSnapshot()) { /* For Repeatable Read and Serializable isolation level report error * if we cannot lock the tuple */ ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); } else { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("unable to lock hypertable catalog tuple, lock result is %d for " "hypertable " "ID (%d)", ti->lockresult, htid))); } } ts_hypertable_formdata_fill(form, ti); ItemPointer result_tid = ts_scanner_get_tuple_tid(ti); tid->ip_blkid = result_tid->ip_blkid; tid->ip_posid = result_tid->ip_posid; success = true; break; } ts_scan_iterator_close(&iterator); return success; } int ts_hypertable_scan_with_memory_context(const char *schema, const char *table, tuple_found_func tuple_found, void *data, LOCKMODE lockmode, MemoryContext mctx) { ScanKeyData scankey[2]; NameData schema_name = { .data = { 0 } }; NameData table_name = { .data = { 0 } }; if (schema) namestrcpy(&schema_name, schema); if (table) namestrcpy(&table_name, table); /* Perform an index scan on schema and table. */ ScanKeyInit(&scankey[0], Anum_hypertable_name_idx_table, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&table_name)); ScanKeyInit(&scankey[1], Anum_hypertable_name_idx_schema, BTEqualStrategyNumber, F_NAMEEQ, NameGetDatum(&schema_name)); return hypertable_scan_limit_internal(scankey, 2, HYPERTABLE_NAME_INDEX, tuple_found, data, 1, lockmode, mctx, NULL); } TSDLLEXPORT ObjectAddress ts_hypertable_create_trigger(const Hypertable *ht, CreateTrigStmt *stmt, const char *query) { ObjectAddress root_trigger_addr; List *chunks; ListCell *lc; int sec_ctx; Oid saved_uid; Oid owner; Assert(ht != NULL); /* create the trigger on the root table */ /* ACL permissions checks happen within this call */ root_trigger_addr = CreateTrigger(stmt, query, InvalidOid, InvalidOid, InvalidOid, InvalidOid, InvalidOid, InvalidOid, NULL, false, false); /* and forward it to the chunks */ CommandCounterIncrement(); if (!stmt->row) return root_trigger_addr; /* switch to the hypertable owner's role -- note that this logic must be the same as * `ts_trigger_create_all_on_chunk` */ owner = ts_rel_get_owner(ht->main_table_relid); GetUserIdAndSecContext(&saved_uid, &sec_ctx); if (saved_uid != owner) SetUserIdAndSecContext(owner, sec_ctx | SECURITY_LOCAL_USERID_CHANGE); chunks = find_inheritance_children(ht->main_table_relid, NoLock); foreach (lc, chunks) { Oid chunk_oid = lfirst_oid(lc); char *relschema = get_namespace_name(get_rel_namespace(chunk_oid)); char *relname = get_rel_name(chunk_oid); char relkind = get_rel_relkind(chunk_oid); Assert(relkind == RELKIND_RELATION || relkind == RELKIND_FOREIGN_TABLE); /* Only create triggers on standard relations and not on, e.g., foreign * table chunks */ if (relkind == RELKIND_RELATION) ts_trigger_create_on_chunk(root_trigger_addr.objectId, relschema, relname); } if (saved_uid != owner) SetUserIdAndSecContext(saved_uid, sec_ctx); return root_trigger_addr; } TSDLLEXPORT void ts_hypertable_drop_invalidation_replication_slot(const char *slot_name) { CatalogSecurityContext sec_ctx; NameData slot; namestrcpy(&slot, slot_name); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); DirectFunctionCall1(pg_drop_replication_slot, NameGetDatum(&slot)); ts_catalog_restore_user(&sec_ctx); } /* based on RemoveObjects */ TSDLLEXPORT void ts_hypertable_drop_trigger(Oid relid, const char *trigger_name) { List *chunks = find_inheritance_children(relid, NoLock); ListCell *lc; if (OidIsValid(relid)) { ObjectAddress objaddr = { .classId = TriggerRelationId, .objectId = get_trigger_oid(relid, trigger_name, true), }; if (OidIsValid(objaddr.objectId)) performDeletion(&objaddr, DROP_RESTRICT, 0); } foreach (lc, chunks) { Oid chunk_oid = lfirst_oid(lc); ObjectAddress objaddr = { .classId = TriggerRelationId, .objectId = get_trigger_oid(chunk_oid, trigger_name, true), }; if (OidIsValid(objaddr.objectId)) performDeletion(&objaddr, DROP_RESTRICT, 0); } } static ScanTupleResult hypertable_tuple_delete(TupleInfo *ti, void *data) { CatalogSecurityContext sec_ctx; bool isnull; bool compressed_hypertable_id_isnull; int hypertable_id = DatumGetInt32(slot_getattr(ti->slot, Anum_hypertable_id, &isnull)); int compressed_hypertable_id = DatumGetInt32(slot_getattr(ti->slot, Anum_hypertable_compressed_hypertable_id, &compressed_hypertable_id_isnull)); ts_tablespace_delete(hypertable_id, NULL, InvalidOid); ts_chunk_delete_by_hypertable_id(hypertable_id); ts_dimension_delete_by_hypertable_id(hypertable_id, true); /* Also remove any policy argument / job that uses this hypertable */ ts_bgw_policy_delete_by_hypertable_id(hypertable_id); /* Also remove any rows in _timescaledb_catalog.chunk_column_stats corresponding to this * hypertable */ ts_chunk_column_stats_delete_by_hypertable_id(hypertable_id); /* Remove any dependent continuous aggs */ ts_continuous_agg_drop_hypertable_callback(hypertable_id); if (!compressed_hypertable_id_isnull) { Hypertable *compressed_hypertable = ts_hypertable_get_by_id(compressed_hypertable_id); /* The hypertable may have already been deleted by a cascade */ if (compressed_hypertable != NULL) ts_hypertable_drop(compressed_hypertable, DROP_RESTRICT); } hypertable_drop_hook_type osm_htdrop_hook = ts_get_osm_hypertable_drop_hook(); /* Invoke the OSM callback if set */ if (osm_htdrop_hook) { Name schema_name = DatumGetName(slot_getattr(ti->slot, Anum_hypertable_schema_name, &isnull)); Name table_name = DatumGetName(slot_getattr(ti->slot, Anum_hypertable_table_name, &isnull)); osm_htdrop_hook(NameStr(*schema_name), NameStr(*table_name)); } ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); return SCAN_CONTINUE; } int ts_hypertable_delete_by_name(const char *schema_name, const char *table_name) { ScanKeyData scankey[2]; ScanKeyInit(&scankey[0], Anum_hypertable_name_idx_table, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(table_name)); ScanKeyInit(&scankey[1], Anum_hypertable_name_idx_schema, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(schema_name)); return hypertable_scan_limit_internal(scankey, 2, HYPERTABLE_NAME_INDEX, hypertable_tuple_delete, NULL, 0, RowExclusiveLock, CurrentMemoryContext, NULL); } int ts_hypertable_delete_by_id(int32 hypertable_id) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_hypertable_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); return hypertable_scan_limit_internal(scankey, 1, HYPERTABLE_ID_INDEX, hypertable_tuple_delete, NULL, 1, RowExclusiveLock, CurrentMemoryContext, NULL); } void ts_hypertable_drop(Hypertable *hypertable, DropBehavior behavior) { /* The actual table might have been deleted already, but we still need to * clean up the catalog entry. */ if (OidIsValid(hypertable->main_table_relid)) { ObjectAddress hypertable_addr = (ObjectAddress){ .classId = RelationRelationId, .objectId = hypertable->main_table_relid, }; /* Drop the postgres table */ ts_compression_settings_delete(hypertable->main_table_relid); performDeletion(&hypertable_addr, behavior, 0); } /* Clean up catalog */ ts_hypertable_delete_by_name(NameStr(hypertable->fd.schema_name), NameStr(hypertable->fd.table_name)); } static ScanTupleResult reset_associated_tuple_found(TupleInfo *ti, void *data) { HeapTuple new_tuple; FormData_hypertable fd; CatalogSecurityContext sec_ctx; ts_hypertable_formdata_fill(&fd, ti); namestrcpy(&fd.associated_schema_name, INTERNAL_SCHEMA_NAME); new_tuple = hypertable_formdata_make_tuple(&fd, ts_scanner_get_tupledesc(ti)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); return SCAN_CONTINUE; } /* * Reset the matching associated schema to the internal schema. */ int ts_hypertable_reset_associated_schema_name(const char *associated_schema) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_hypertable_associated_schema_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(associated_schema)); return hypertable_scan_limit_internal(scankey, 1, INVALID_INDEXID, reset_associated_tuple_found, NULL, 0, RowExclusiveLock, CurrentMemoryContext, NULL); } int ts_hypertable_set_name(Hypertable *ht, const char *newname) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); namestrcpy(&form.table_name, newname); hypertable_update_catalog_tuple(&tid, &form); return true; } int ts_hypertable_set_schema(Hypertable *ht, const char *newname) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); namestrcpy(&form.schema_name, newname); hypertable_update_catalog_tuple(&tid, &form); return true; } int ts_hypertable_set_num_dimensions(Hypertable *ht, int16 num_dimensions) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); Assert(num_dimensions > 0); form.num_dimensions = num_dimensions; hypertable_update_catalog_tuple(&tid, &form); return true; } #define DEFAULT_ASSOCIATED_TABLE_PREFIX_FORMAT "_hyper_%d" static const size_t MAXIMUM_PREFIX_LENGTH = NAMEDATALEN - 16; static void hypertable_insert_relation(Relation rel, FormData_hypertable *fd) { HeapTuple new_tuple; CatalogSecurityContext sec_ctx; new_tuple = hypertable_formdata_make_tuple(fd, RelationGetDescr(rel)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert(rel, new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); } static void hypertable_insert(int32 hypertable_id, Name schema_name, Name table_name, Name associated_schema_name, Name associated_table_prefix, Name chunk_sizing_func_schema, Name chunk_sizing_func_name, int64 chunk_target_size, int16 num_dimensions, bool compressed) { Catalog *catalog = ts_catalog_get(); Relation rel; FormData_hypertable fd; fd.id = hypertable_id; if (fd.id == INVALID_HYPERTABLE_ID) { CatalogSecurityContext sec_ctx; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); fd.id = ts_catalog_table_next_seq_id(ts_catalog_get(), HYPERTABLE); ts_catalog_restore_user(&sec_ctx); } namestrcpy(&fd.schema_name, NameStr(*schema_name)); namestrcpy(&fd.table_name, NameStr(*table_name)); namestrcpy(&fd.associated_schema_name, NameStr(*associated_schema_name)); if (NULL == associated_table_prefix) { NameData default_associated_table_prefix; memset(NameStr(default_associated_table_prefix), '\0', NAMEDATALEN); snprintf(NameStr(default_associated_table_prefix), NAMEDATALEN, DEFAULT_ASSOCIATED_TABLE_PREFIX_FORMAT, fd.id); namestrcpy(&fd.associated_table_prefix, NameStr(default_associated_table_prefix)); } else { namestrcpy(&fd.associated_table_prefix, NameStr(*associated_table_prefix)); } if (strnlen(NameStr(fd.associated_table_prefix), NAMEDATALEN) > MAXIMUM_PREFIX_LENGTH) elog(ERROR, "associated_table_prefix too long"); fd.num_dimensions = num_dimensions; namestrcpy(&fd.chunk_sizing_func_schema, NameStr(*chunk_sizing_func_schema)); namestrcpy(&fd.chunk_sizing_func_name, NameStr(*chunk_sizing_func_name)); fd.chunk_target_size = chunk_target_size; if (fd.chunk_target_size < 0) fd.chunk_target_size = 0; if (compressed) fd.compression_state = HypertableInternalCompressionTable; else fd.compression_state = HypertableCompressionOff; /* when creating a hypertable, there is never an associated compressed dual */ fd.compressed_hypertable_id = INVALID_HYPERTABLE_ID; /* new hypertable does not have OSM chunk */ fd.status = HYPERTABLE_STATUS_DEFAULT; rel = table_open(catalog_get_table_id(catalog, HYPERTABLE), RowExclusiveLock); hypertable_insert_relation(rel, &fd); table_close(rel, RowExclusiveLock); } static ScanTupleResult hypertable_tuple_found(TupleInfo *ti, void *data) { Hypertable **entry = (Hypertable **) data; *entry = ts_hypertable_from_tupleinfo(ti); return SCAN_DONE; } Hypertable * ts_hypertable_get_by_name(const char *schema, const char *name) { Hypertable *ht = NULL; hypertable_scan(schema, name, hypertable_tuple_found, (void *) &ht, AccessShareLock); return ht; } Hypertable * ts_hypertable_get_by_id(int32 hypertable_id) { ScanKeyData scankey[1]; Hypertable *ht = NULL; ScanKeyInit(&scankey[0], Anum_hypertable_pkey_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); hypertable_scan_limit_internal(scankey, 1, HYPERTABLE_ID_INDEX, hypertable_tuple_found, (void *) &ht, 1, AccessShareLock, CurrentMemoryContext, NULL); return ht; } static void hypertable_chunk_store_free(void *entry) { ts_chunk_free((Chunk *) entry); } /* * Add the chunk to the cache that allows fast lookup of chunks * for a given hyperspace Point. */ Chunk * ts_hypertable_chunk_store_add(const Hypertable *h, const Chunk *input_chunk) { MemoryContext old_mcxt; /* Add the chunk to the subspace store */ old_mcxt = MemoryContextSwitchTo(ts_subspace_store_mcxt(h->chunk_cache)); Chunk *cached_chunk = ts_chunk_copy(input_chunk); ts_subspace_store_add(h->chunk_cache, cached_chunk->cube, cached_chunk, hypertable_chunk_store_free); MemoryContextSwitchTo(old_mcxt); return cached_chunk; } /* * Create a chunk for the point, given that it does not exist yet. * * If the chunk already exists (i.e., another process beat us to it), then * lock the chunk with the specified lockmode. If the chunk is created, it * will always be locked with AccessExclusivelock. */ Chunk * ts_hypertable_create_chunk_for_point(const Hypertable *h, const Point *point, LOCKMODE chunk_lockmode) { Assert(ts_subspace_store_get(h->chunk_cache, point) == NULL); Chunk *chunk = ts_chunk_create_for_point(h, point, NameStr(h->fd.associated_schema_name), NameStr(h->fd.associated_table_prefix), chunk_lockmode); /* Also add the chunk to the hypertable's chunk store */ Chunk *cached_chunk = ts_hypertable_chunk_store_add(h, chunk); return cached_chunk; } /* * Find the chunk responsible for the given point. * * In case of a cache miss, a point scan will try to find a matching chunk. A * matching chunk will be locked in the given lockmode (unless NoLock is * specified) and added to the cache. * * If lockmode is higher than NoLock, all dimension slices will also be locked * in LockTupleKeyShare. * * If no chunk is found, NULL is returned. The returned chunk is owned by the * cache and may become invalid after some subsequent call to this function. * Leaks memory, so call in a short-lived context. */ Chunk * ts_hypertable_find_chunk_for_point(const Hypertable *h, const Point *point, LOCKMODE lockmode) { Chunk *chunk = ts_subspace_store_get(h->chunk_cache, point); if (!chunk) { chunk = ts_chunk_find_for_point(h, point, lockmode); if (chunk) chunk = ts_hypertable_chunk_store_add(h, chunk); } else if (!ts_chunk_lock_if_exists(chunk->table_id, lockmode)) { return NULL; } #ifdef USE_ASSERT_CHECKING if (chunk) { Relation chunk_rel = RelationIdGetRelation(chunk->table_id); Assert(CheckRelationLockedByMe(chunk_rel, lockmode, true)); RelationClose(chunk_rel); } #endif return chunk; } bool ts_hypertable_has_tablespace(const Hypertable *ht, Oid tspc_oid) { Tablespaces *tspcs = ts_tablespace_scan(ht->fd.id); return ts_tablespaces_contain(tspcs, tspc_oid); } static int hypertable_get_chunk_round_robin_index(const Hypertable *ht, const Hypercube *hc) { const Dimension *dim; const DimensionSlice *slice; int offset = 0; Assert(NULL != ht); Assert(NULL != hc); dim = hyperspace_get_closed_dimension(ht->space, 0); if (NULL == dim) { dim = hyperspace_get_open_dimension(ht->space, 0); /* Add some randomness between hypertables so that * if there is no space partitions, but multiple hypertables * the initial index is different for different hypertables. * This protects against creating a lot of chunks on the same * data node when many hypertables are created at roughly * the same time, e.g., from a bootstrap script. */ offset = (int) ht->fd.id; } Assert(NULL != dim); slice = ts_hypercube_get_slice_by_dimension_id(hc, dim->fd.id); Assert(NULL != slice); return ts_dimension_get_slice_ordinal(dim, slice) + offset; } /* * Select a tablespace to use for a given chunk. * * Selection happens based on the first closed (space) dimension, if available, * otherwise the first closed (time) one. * * We try to do "sticky" selection to consistently pick the same tablespace for * chunks in the same closed (space) dimension. This ensures chunks in the same * "space" partition will live on the same disk. */ Tablespace * ts_hypertable_select_tablespace(const Hypertable *ht, const Chunk *chunk) { Tablespaces *tspcs = ts_tablespace_scan(ht->fd.id); int i; if (NULL == tspcs || tspcs->num_tablespaces == 0) return NULL; i = hypertable_get_chunk_round_robin_index(ht, chunk->cube); /* Use the index of the slice to find the tablespace */ return &tspcs->tablespaces[i % tspcs->num_tablespaces]; } const char * ts_hypertable_select_tablespace_name(const Hypertable *ht, const Chunk *chunk) { Tablespace *tspc = ts_hypertable_select_tablespace(ht, chunk); Oid main_tspc_oid; if (tspc != NULL) return NameStr(tspc->fd.tablespace_name); /* Use main table tablespace, if any */ main_tspc_oid = get_rel_tablespace(ht->main_table_relid); if (OidIsValid(main_tspc_oid)) return get_tablespace_name(main_tspc_oid); return NULL; } /* * Get the tablespace at an offset from the given tablespace. */ Tablespace * ts_hypertable_get_tablespace_at_offset_from(int32 hypertable_id, Oid tablespace_oid, int16 offset) { Tablespaces *tspcs = ts_tablespace_scan(hypertable_id); int i = 0; if (NULL == tspcs || tspcs->num_tablespaces == 0) return NULL; for (i = 0; i < tspcs->num_tablespaces; i++) { if (tablespace_oid == tspcs->tablespaces[i].tablespace_oid) return &tspcs->tablespaces[(i + offset) % tspcs->num_tablespaces]; } return NULL; } static inline Oid hypertable_relid_lookup(Oid relid) { Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(relid, CACHE_FLAG_MISSING_OK, &hcache); Oid result = (ht == NULL) ? InvalidOid : ht->main_table_relid; ts_cache_release(&hcache); return result; } /* * Returns a hypertable's relation ID (OID) iff the given RangeVar corresponds to * a hypertable, otherwise InvalidOid. */ Oid ts_hypertable_relid(RangeVar *rv) { return hypertable_relid_lookup(RangeVarGetRelid(rv, NoLock, true)); } bool ts_is_hypertable(Oid relid) { if (!OidIsValid(relid)) return false; return OidIsValid(hypertable_relid_lookup(relid)); } /* * Check that the current user can create chunks in a hypertable's associated * schema. * * This function is typically called from create_hypertable() to verify that the * table owner has CREATE permissions for the schema (if it already exists) or * the database (if the schema does not exist and needs to be created). */ static Oid hypertable_check_associated_schema_permissions(const char *schema_name, Oid user_oid) { Oid schema_oid; /* * If the schema name is NULL, it implies the internal catalog schema and * anyone should be able to create chunks there. */ if (NULL == schema_name) return InvalidOid; schema_oid = get_namespace_oid(schema_name, true); /* Anyone can create chunks in the internal schema */ if (strncmp(schema_name, INTERNAL_SCHEMA_NAME, NAMEDATALEN) == 0) { Assert(OidIsValid(schema_oid)); return schema_oid; } if (!OidIsValid(schema_oid)) { /* * Schema does not exist, so we must check that the user has * privileges to create the schema in the current database */ if (object_aclcheck(DatabaseRelationId, MyDatabaseId, user_oid, ACL_CREATE) != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permissions denied: cannot create schema \"%s\" in database \"%s\"", schema_name, get_database_name(MyDatabaseId)))); } else if (object_aclcheck(NamespaceRelationId, schema_oid, user_oid, ACL_CREATE) != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permissions denied: cannot create chunks in schema \"%s\"", schema_name))); return schema_oid; } inline static bool table_has_rules(Relation rel) { return rel->rd_rules != NULL; } bool ts_hypertable_has_chunks(Oid table_relid, LOCKMODE lockmode) { return find_inheritance_children(table_relid, lockmode) != NIL; } static void hypertable_create_schema(const char *schema_name) { CreateSchemaStmt stmt = { .schemaname = (char *) schema_name, .authrole = NULL, .schemaElts = NIL, .if_not_exists = true, }; CreateSchemaCommand(&stmt, "(generated CREATE SCHEMA command)", -1, -1); } /* * Check that existing table constraints are supported. * * Hypertables do not support the following constraints: * * - NO INHERIT constraints cannot be enforced on a hypertable since they only * exist on the parent table, which will have no tuples. * - FOREIGN KEY constraints referencing a hypertable. */ static void hypertable_validate_constraints(Oid relid) { Relation catalog; SysScanDesc scan; ScanKeyData scankey; HeapTuple tuple; catalog = table_open(ConstraintRelationId, AccessShareLock); ScanKeyInit(&scankey, Anum_pg_constraint_conrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relid)); scan = systable_beginscan(catalog, ConstraintRelidTypidNameIndexId, true, NULL, 1, &scankey); while (HeapTupleIsValid(tuple = systable_getnext(scan))) { Form_pg_constraint form = (Form_pg_constraint) GETSTRUCT(tuple); if (form->contype == CONSTRAINT_FOREIGN) { if (ts_hypertable_relid_to_id(form->confrelid) != INVALID_HYPERTABLE_ID) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables cannot be used as foreign key references of " "hypertables"))); } if (form->contype == CONSTRAINT_CHECK && form->connoinherit) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("cannot have NO INHERIT constraints on hypertable \"%s\"", get_rel_name(relid)), errhint("Remove all NO INHERIT constraints from table \"%s\" before " "making it a hypertable.", get_rel_name(relid)))); } systable_endscan(scan); /* Check for foreign keys that reference this table */ ScanKeyInit(&scankey, Anum_pg_constraint_confrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relid)); scan = systable_beginscan(catalog, 0, false, NULL, 1, &scankey); while (HeapTupleIsValid(tuple = systable_getnext(scan))) { Form_pg_constraint form = (Form_pg_constraint) GETSTRUCT(tuple); /* * Hypertable <-> hypertable foreign keys are not supported. */ if (form->contype == CONSTRAINT_FOREIGN && ts_hypertable_relid_to_id(form->conrelid) != INVALID_HYPERTABLE_ID) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("cannot have FOREIGN KEY constraints to hypertable \"%s\"", get_rel_name(relid)), errhint("Remove all FOREIGN KEY constraints to table \"%s\" before " "making it a hypertable.", get_rel_name(relid)))); } systable_endscan(scan); table_close(catalog, AccessShareLock); } static Datum create_hypertable_datum(FunctionCallInfo fcinfo, const Hypertable *ht, bool created, bool is_generic) { TupleDesc tupdesc; HeapTuple tuple; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in " "context that cannot accept type record"))); tupdesc = BlessTupleDesc(tupdesc); if (is_generic) { Datum values[Natts_generic_create_hypertable]; bool nulls[Natts_generic_create_hypertable] = { false }; values[AttrNumberGetAttrOffset(Anum_generic_create_hypertable_id)] = Int32GetDatum(ht->fd.id); values[AttrNumberGetAttrOffset(Anum_generic_create_hypertable_created)] = BoolGetDatum(created); tuple = heap_form_tuple(tupdesc, values, nulls); } else { Datum values[Natts_create_hypertable]; bool nulls[Natts_create_hypertable] = { false }; values[AttrNumberGetAttrOffset(Anum_create_hypertable_id)] = Int32GetDatum(ht->fd.id); values[AttrNumberGetAttrOffset(Anum_create_hypertable_schema_name)] = NameGetDatum(&ht->fd.schema_name); values[AttrNumberGetAttrOffset(Anum_create_hypertable_table_name)] = NameGetDatum(&ht->fd.table_name); values[AttrNumberGetAttrOffset(Anum_create_hypertable_created)] = BoolGetDatum(created); tuple = heap_form_tuple(tupdesc, values, nulls); } return HeapTupleGetDatum(tuple); } TS_FUNCTION_INFO_V1(ts_hypertable_create); TS_FUNCTION_INFO_V1(ts_hypertable_create_general); /* * Create a hypertable from an existing table. The specific version of create hypertable API * process the function arguments before calling this function. */ static Datum ts_hypertable_create_internal(FunctionCallInfo fcinfo, Oid table_relid, DimensionInfo *open_dim_info, DimensionInfo *closed_dim_info, Name associated_schema_name, Name associated_table_prefix, bool create_default_indexes, bool if_not_exists, bool migrate_data, text *target_size, Oid sizing_func, bool is_generic) { Cache *hcache; Hypertable *ht; Datum retval; bool created; uint32 flags = 0; ts_feature_flag_check(FEATURE_HYPERTABLE); ChunkSizingInfo chunk_sizing_info = { .table_relid = table_relid, .target_size = target_size, .func = sizing_func, .colname = NameStr(open_dim_info->colname), .check_for_index = !create_default_indexes, }; TS_PREVENT_FUNC_IF_READ_ONLY(); ht = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_MISSING_OK, &hcache); if (ht) { if (if_not_exists) ereport(NOTICE, (errcode(ERRCODE_TS_HYPERTABLE_EXISTS), errmsg("table \"%s\" is already a hypertable, skipping", get_rel_name(table_relid)))); else ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_EXISTS), errmsg("table \"%s\" is already a hypertable", get_rel_name(table_relid)))); created = false; } else { /* Release previously pinned cache */ ts_cache_release(&hcache); if (closed_dim_info && !closed_dim_info->num_slices_is_set) { /* If the number of partitions isn't specified, default to setting it * to the number of data nodes */ int16 num_partitions = closed_dim_info->num_slices; closed_dim_info->num_slices = num_partitions; closed_dim_info->num_slices_is_set = true; } if (if_not_exists) flags |= HYPERTABLE_CREATE_IF_NOT_EXISTS; if (!create_default_indexes) flags |= HYPERTABLE_CREATE_DISABLE_DEFAULT_INDEXES; if (migrate_data) flags |= HYPERTABLE_CREATE_MIGRATE_DATA; created = ts_hypertable_create_from_info(table_relid, INVALID_HYPERTABLE_ID, flags, open_dim_info, closed_dim_info, associated_schema_name, associated_table_prefix, &chunk_sizing_info); Assert(created); ht = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); } retval = create_hypertable_datum(fcinfo, ht, created, is_generic); ts_cache_release(&hcache); PG_RETURN_DATUM(retval); } /* * Process create_hypertable parameters for time specific implementation. * * Arguments: * relation REGCLASS * time_column_name NAME * partitioning_column NAME = NULL * number_partitions INTEGER = NULL * associated_schema_name NAME = NULL * associated_table_prefix NAME = NULL * chunk_time_interval anyelement = NULL::BIGINT * create_default_indexes BOOLEAN = TRUE * if_not_exists BOOLEAN = FALSE * partitioning_func REGPROC = NULL * migrate_data BOOLEAN = FALSE * chunk_target_size TEXT = NULL * chunk_sizing_func OID = NULL * time_partitioning_func REGPROC = NULL */ Datum ts_hypertable_create(PG_FUNCTION_ARGS) { Oid table_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Name open_dim_name = PG_ARGISNULL(1) ? NULL : PG_GETARG_NAME(1); Name closed_dim_name = PG_ARGISNULL(2) ? NULL : PG_GETARG_NAME(2); int16 num_partitions = PG_ARGISNULL(3) ? -1 : PG_GETARG_INT16(3); Name associated_schema_name = PG_ARGISNULL(4) ? NULL : PG_GETARG_NAME(4); Name associated_table_prefix = PG_ARGISNULL(5) ? NULL : PG_GETARG_NAME(5); Datum default_interval = PG_ARGISNULL(6) ? UnassignedDatum : PG_GETARG_DATUM(6); Oid interval_type = PG_ARGISNULL(6) ? InvalidOid : get_fn_expr_argtype(fcinfo->flinfo, 6); bool create_default_indexes = PG_ARGISNULL(7) ? false : PG_GETARG_BOOL(7); /* Defaults to true in the sql code */ bool if_not_exists = PG_ARGISNULL(8) ? false : PG_GETARG_BOOL(8); regproc closed_partitioning_func = PG_ARGISNULL(9) ? InvalidOid : PG_GETARG_OID(9); bool migrate_data = PG_ARGISNULL(10) ? false : PG_GETARG_BOOL(10); text *target_size = PG_ARGISNULL(11) ? NULL : PG_GETARG_TEXT_P(11); Oid sizing_func = PG_ARGISNULL(12) ? InvalidOid : PG_GETARG_OID(12); regproc open_partitioning_func = PG_ARGISNULL(13) ? InvalidOid : PG_GETARG_OID(13); if (!OidIsValid(table_relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("relation cannot be NULL"))); if (!open_dim_name) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("partition column cannot be NULL"))); DimensionInfo *open_dim_info = ts_dimension_info_create_open(table_relid, open_dim_name, /* column name */ default_interval, /* interval */ interval_type, /* interval type */ open_partitioning_func /* partitioning func */ ); DimensionInfo *closed_dim_info = NULL; if (closed_dim_name) closed_dim_info = ts_dimension_info_create_closed(table_relid, closed_dim_name, /* column name */ num_partitions, /* number partitions */ closed_partitioning_func /* partitioning func */ ); return ts_hypertable_create_internal(fcinfo, table_relid, open_dim_info, closed_dim_info, associated_schema_name, associated_table_prefix, create_default_indexes, if_not_exists, migrate_data, target_size, sizing_func, false); } static Oid get_sizing_func_oid() { const char *sizing_func_name = "calculate_chunk_interval"; const int sizing_func_nargs = 3; static Oid sizing_func_arg_types[] = { INT4OID, INT8OID, INT8OID }; return ts_get_function_oid(sizing_func_name, FUNCTIONS_SCHEMA_NAME, sizing_func_nargs, sizing_func_arg_types); } /* * Process create_hypertable parameters for generic implementation. * * Arguments: * relation REGCLASS * dimension dimension_info * create_default_indexes BOOLEAN = TRUE * if_not_exists BOOLEAN = FALSE * migrate_data BOOLEAN = FALSE */ Datum ts_hypertable_create_general(PG_FUNCTION_ARGS) { Oid table_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); DimensionInfo *dim_info = NULL; GETARG_NOTNULL_POINTER(dim_info, 1, "dimension", DimensionInfo); bool create_default_indexes = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); bool if_not_exists = PG_ARGISNULL(3) ? false : PG_GETARG_BOOL(3); bool migrate_data = PG_ARGISNULL(4) ? false : PG_GETARG_BOOL(4); /* * We do not support closed (hash) dimensions for the main partitioning * column. Check that first. The behavior then becomes consistent with the * earlier "ts_hypertable_create" implementation. */ if (IS_CLOSED_DIMENSION(dim_info)) ereport(ERROR, (errmsg("cannot partition using a closed dimension on primary column"), errhint("Use range partitioning on the primary column."))); /* * Current implementation requires to provide a valid chunk sizing function * that is being used to populate hypertable catalog information. */ Oid sizing_func = get_sizing_func_oid(); /* * Fill in the rest of the info. */ dim_info->table_relid = table_relid; return ts_hypertable_create_internal(fcinfo, table_relid, dim_info, NULL, /* closed_dim_info */ NULL, /* associated_schema_name */ NULL, /* associated_table_prefix */ create_default_indexes, if_not_exists, migrate_data, NULL, sizing_func, true); } /* Go through columns of parent table and check for column data types. */ static void ts_validate_basetable_columns(Relation *rel) { int attno; TupleDesc tupdesc; tupdesc = RelationGetDescr(*rel); for (attno = 1; attno <= tupdesc->natts; attno++) { Form_pg_attribute attr = TupleDescAttr(tupdesc, attno - 1); /* skip dropped columns */ if (attr->attisdropped) continue; Oid typid = attr->atttypid; switch (typid) { case CHAROID: case VARCHAROID: ereport(WARNING, (errmsg("column type \"%s\" used for \"%s\" does not follow best practices", format_type_be(typid), NameStr(attr->attname)), errhint("Use datatype TEXT instead."))); break; case TIMESTAMPOID: ereport(WARNING, (errmsg("column type \"%s\" used for \"%s\" does not follow best practices", format_type_be(typid), NameStr(attr->attname)), errhint("Use datatype TIMESTAMPTZ instead."))); break; default: break; } } } /* Creates a new hypertable. * * Flags are one of HypertableCreateFlags. * All parameters after tim_dim_info can be NUL * returns 'true' if new hypertable was created, false if 'if_not_exists' and the hypertable already * exists. */ bool ts_hypertable_create_from_info(Oid table_relid, int32 hypertable_id, uint32 flags, DimensionInfo *time_dim_info, DimensionInfo *closed_dim_info, Name associated_schema_name, Name associated_table_prefix, ChunkSizingInfo *chunk_sizing_info) { Cache *hcache; Hypertable *ht; Oid associated_schema_oid; Oid user_oid = GetUserId(); Oid tspc_oid = get_rel_tablespace(table_relid); bool table_has_data; NameData schema_name, table_name, default_associated_schema_name; Relation rel; bool if_not_exists = (flags & HYPERTABLE_CREATE_IF_NOT_EXISTS) != 0; /* quick exit in the easy if-not-exists case to avoid all locking */ if (if_not_exists && ts_is_hypertable(table_relid)) { ereport(NOTICE, (errcode(ERRCODE_TS_HYPERTABLE_EXISTS), errmsg("table \"%s\" is already a hypertable, skipping", get_rel_name(table_relid)))); return false; } /* * Serialize hypertable creation to avoid having multiple transactions * creating the same hypertable simultaneously. The lock should conflict * with itself and RowExclusive, to prevent simultaneous inserts on the * table. Also since TRUNCATE (part of data migrations) takes an * AccessExclusiveLock take that lock level here too so that we don't have * lock upgrades, which are susceptible to deadlocks. If we aren't * migrating data, then shouldn't have much contention on the table thus * not worth optimizing. */ rel = table_open(table_relid, AccessExclusiveLock); /* recheck after getting lock */ if (ts_is_hypertable(table_relid)) { /* * Unlock and return. Note that unlocking is analogous to what PG does * for ALTER TABLE ADD COLUMN IF NOT EXIST */ table_close(rel, AccessExclusiveLock); if (if_not_exists) { ereport(NOTICE, (errcode(ERRCODE_TS_HYPERTABLE_EXISTS), errmsg("table \"%s\" is already a hypertable, skipping", get_rel_name(table_relid)))); return false; } ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_EXISTS), errmsg("table \"%s\" is already a hypertable", get_rel_name(table_relid)))); } /* * Hypertables also get created as part of caggs. Report warnings * only for hypertables created via call to create_hypertable(). */ if (hypertable_id == INVALID_HYPERTABLE_ID) ts_validate_basetable_columns(&rel); /* * Check that the user has permissions to make this table into a * hypertable */ ts_hypertable_permissions_check(table_relid, user_oid); /* Is this the right kind of relation? */ switch (get_rel_relkind(table_relid)) { case RELKIND_PARTITIONED_TABLE: ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("table \"%s\" is already partitioned", get_rel_name(table_relid)), errdetail("It is not possible to turn partitioned tables into hypertables."))); case RELKIND_MATVIEW: case RELKIND_RELATION: break; default: ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("invalid relation type"))); } /* * Check that the table is not part of any publication */ if (GetRelationPublications(table_relid) != NIL || GetAllTablesPublications() != NIL) { ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot create hypertable for table \"%s\" because it is part of a " "publication", get_rel_name(table_relid)))); } /* Check that the table doesn't have any unsupported constraints */ hypertable_validate_constraints(table_relid); table_has_data = ts_relation_has_tuples(rel); if ((flags & HYPERTABLE_CREATE_MIGRATE_DATA) == 0 && table_has_data) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("table \"%s\" is not empty", get_rel_name(table_relid)), errhint("You can migrate data by specifying 'migrate_data => true' when calling " "this function."))); if (is_inheritance_table(table_relid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("table \"%s\" is already partitioned", get_rel_name(table_relid)), errdetail( "It is not possible to turn tables that use inheritance into hypertables."))); if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("table \"%s\" cannot be temporary", get_rel_name(table_relid)), errdetail("It is not supported to turn temporary tables into hypertables."))); if (table_has_rules(rel)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support rules"), errdetail("Table \"%s\" has attached rules, which do not work on hypertables.", get_rel_name(table_relid)), errhint("Remove the rules before creating a hypertable."))); /* * Must close the relation to decrease the reference count for the relation * as PG18+ will check the reference count when adding constraints for the table. */ table_close(rel, NoLock); /* * Create the associated schema where chunks are stored, or, check * permissions if it already exists */ if (NULL == associated_schema_name) { namestrcpy(&default_associated_schema_name, INTERNAL_SCHEMA_NAME); associated_schema_name = &default_associated_schema_name; } associated_schema_oid = hypertable_check_associated_schema_permissions(NameStr(*associated_schema_name), user_oid); /* Create the associated schema if it doesn't already exist */ if (!OidIsValid(associated_schema_oid)) hypertable_create_schema(NameStr(*associated_schema_name)); /* * Hypertables do not support arbitrary triggers, so if the table already * has unsupported triggers we bail out */ ts_check_unsupported_triggers(table_relid); if (NULL == chunk_sizing_info) chunk_sizing_info = ts_chunk_sizing_info_get_default_disabled(table_relid); /* Validate and set chunk sizing information */ if (OidIsValid(chunk_sizing_info->func)) { ts_chunk_adaptive_sizing_info_validate(chunk_sizing_info); if (chunk_sizing_info->target_size_bytes > 0) { ereport(NOTICE, (errcode(ERRCODE_WARNING), errmsg("adaptive chunking is a BETA feature and is not recommended for " "production deployments"))); time_dim_info->adaptive_chunking = true; } } else { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("chunk sizing function cannot be NULL"))); } /* Validate that the dimensions are OK */ ts_dimension_info_validate(time_dim_info); if (DIMENSION_INFO_IS_SET(closed_dim_info)) ts_dimension_info_validate(closed_dim_info); /* Checks pass, now we can create the catalog information */ namestrcpy(&schema_name, get_namespace_name(get_rel_namespace(table_relid))); namestrcpy(&table_name, get_rel_name(table_relid)); hypertable_insert(hypertable_id, &schema_name, &table_name, associated_schema_name, associated_table_prefix, &chunk_sizing_info->func_schema, &chunk_sizing_info->func_name, chunk_sizing_info->target_size_bytes, DIMENSION_INFO_IS_SET(closed_dim_info) ? 2 : 1, false); /* Get the a Hypertable object via the cache */ time_dim_info->ht = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); /* Add validated dimensions */ ts_dimension_add_from_info(time_dim_info); if (DIMENSION_INFO_IS_SET(closed_dim_info)) { closed_dim_info->ht = time_dim_info->ht; ts_dimension_add_from_info(closed_dim_info); } /* Refresh the cache to get the updated hypertable with added dimensions */ ts_cache_release(&hcache); ht = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); /* Verify that existing indexes are compatible with a hypertable */ ts_indexing_verify_indexes(ht); /* Attach tablespace, if any */ if (OidIsValid(tspc_oid)) { NameData tspc_name; namestrcpy(&tspc_name, get_tablespace_name(tspc_oid)); ts_tablespace_attach_internal(&tspc_name, table_relid, false); } if ((flags & HYPERTABLE_CREATE_DISABLE_DEFAULT_INDEXES) == 0) ts_indexing_create_default_indexes(ht); /* * Migrate data from the main table to chunks */ if (table_has_data) { ereport(NOTICE, (errmsg("migrating data to chunks"), errdetail("Migration might take a while depending on the amount of data."))); timescaledb_move_from_table_to_chunks(ht, RowExclusiveLock); } ts_cache_release(&hcache); return true; } /* Used as a tuple found function */ static ScanTupleResult hypertable_rename_schema_name(TupleInfo *ti, void *data) { const char **schema_names = (const char **) data; const char *old_schema_name = schema_names[0]; const char *new_schema_name = schema_names[1]; bool updated = false; FormData_hypertable fd; ts_hypertable_formdata_fill(&fd, ti); /* * Because we are doing a heap scan with no scankey, we don't know which * schema name to change, if any */ if (namestrcmp(&fd.schema_name, old_schema_name) == 0) { namestrcpy(&fd.schema_name, new_schema_name); updated = true; } if (namestrcmp(&fd.associated_schema_name, old_schema_name) == 0) { namestrcpy(&fd.associated_schema_name, new_schema_name); updated = true; } if (namestrcmp(&fd.chunk_sizing_func_schema, old_schema_name) == 0) { namestrcpy(&fd.chunk_sizing_func_schema, new_schema_name); updated = true; } /* Only update the catalog if we explicitly something */ if (updated) { HeapTuple new_tuple = hypertable_formdata_make_tuple(&fd, ts_scanner_get_tupledesc(ti)); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); heap_freetuple(new_tuple); } /* Keep going so we can change the name for all hypertables */ return SCAN_CONTINUE; } /* Go through internal hypertable table and rename all matching schemas */ void ts_hypertables_rename_schema_name(const char *old_name, const char *new_name) { const char *schema_names[2] = { old_name, new_name }; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, HYPERTABLE), .index = InvalidOid, .tuple_found = hypertable_rename_schema_name, .data = (void *) schema_names, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; ts_scanner_scan(&scanctx); } bool ts_is_partitioning_column(const Hypertable *ht, AttrNumber column_attno) { uint16 i; for (i = 0; i < ht->space->num_dimensions; i++) { if (column_attno == ht->space->dimensions[i].column_attno) return true; } return false; } bool ts_is_partitioning_column_name(const Hypertable *ht, NameData column_name) { uint16 i; for (i = 0; i < ht->space->num_dimensions; i++) { if (namestrcmp(&ht->space->dimensions[i].fd.column_name, NameStr(column_name)) == 0) return true; } return false; } static void integer_now_func_validate(Oid now_func_oid, Oid open_dim_type) { HeapTuple tuple; Form_pg_proc now_func; /* this function should only be called for hypertables with an open integer time dimension */ Assert(IS_INTEGER_TYPE(open_dim_type)); if (!OidIsValid(now_func_oid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), (errmsg("invalid custom time function")))); tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(now_func_oid)); if (!HeapTupleIsValid(tuple)) { ereport(ERROR, (errcode(ERRCODE_NO_DATA_FOUND), errmsg("cache lookup failed for function %u", now_func_oid))); } now_func = (Form_pg_proc) GETSTRUCT(tuple); if ((now_func->provolatile != PROVOLATILE_IMMUTABLE && now_func->provolatile != PROVOLATILE_STABLE) || now_func->pronargs != 0) { ReleaseSysCache(tuple); ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid custom time function"), errhint("A custom time function must take no arguments and be STABLE."))); } if (now_func->prorettype != open_dim_type) { ReleaseSysCache(tuple); ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid custom time function"), errhint("The return type of the custom time function must be the same as" " the type of the time column of the hypertable."))); } ReleaseSysCache(tuple); } TS_FUNCTION_INFO_V1(ts_hypertable_set_integer_now_func); Datum ts_hypertable_set_integer_now_func(PG_FUNCTION_ARGS) { Oid table_relid = PG_GETARG_OID(0); Oid now_func_oid = PG_GETARG_OID(1); bool replace_if_exists = PG_GETARG_BOOL(2); Hypertable *hypertable; Cache *hcache; const Dimension *open_dim; Oid open_dim_type; AclResult aclresult; ts_hypertable_permissions_check(table_relid, GetUserId()); hypertable = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(hypertable)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("custom time function not supported on internal columnstore table"))); /* validate that the open dimension uses numeric type */ open_dim = hyperspace_get_open_dimension(hypertable->space, 0); if (!replace_if_exists) if (*NameStr(open_dim->fd.integer_now_func_schema) != '\0' || *NameStr(open_dim->fd.integer_now_func) != '\0') ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("custom time function already set for hypertable \"%s\"", get_rel_name(table_relid)))); open_dim_type = ts_dimension_get_partition_type(open_dim); if (!IS_INTEGER_TYPE(open_dim_type)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("custom time function not supported"), errhint("A custom time function can only be set for hypertables" " that have integer time dimensions."))); integer_now_func_validate(now_func_oid, open_dim_type); aclresult = object_aclcheck(ProcedureRelationId, now_func_oid, GetUserId(), ACL_EXECUTE); if (aclresult != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for function %s", get_func_name(now_func_oid)))); ts_dimension_update(hypertable, &open_dim->fd.column_name, DIMENSION_TYPE_OPEN, NULL, NULL, NULL, &now_func_oid); ts_cache_release(&hcache); PG_RETURN_NULL(); } /*Assume permissions are already checked * set compression state as enabled */ bool ts_hypertable_set_compressed(Hypertable *ht, int32 compressed_hypertable_id) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); Assert(!TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)); form.compression_state = HypertableCompressionEnabled; form.compressed_hypertable_id = compressed_hypertable_id; hypertable_update_catalog_tuple(&tid, &form); return true; } /* set compression_state as disabled and remove any * associated compressed hypertable id */ bool ts_hypertable_unset_compressed(Hypertable *ht) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); Assert(!TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)); form.compression_state = HypertableCompressionOff; form.compressed_hypertable_id = INVALID_HYPERTABLE_ID; hypertable_update_catalog_tuple(&tid, &form); return true; } bool ts_hypertable_set_compress_interval(Hypertable *ht, int64 compress_interval) { Assert(!TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)); Dimension *time_dimension = ts_hyperspace_get_mutable_dimension(ht->space, DIMENSION_TYPE_OPEN, 0); return ts_dimension_set_compress_interval(time_dimension, compress_interval) > 0; } /* create a compressed hypertable * table_relid - already created table which we are going to * set up as a compressed hypertable * hypertable_id - id to be used while creating hypertable with * compression property set * NOTE: * compressed hypertable has no dimensions. */ bool ts_hypertable_create_compressed(Oid table_relid, int32 hypertable_id) { Oid user_oid = GetUserId(); Oid tspc_oid = get_rel_tablespace(table_relid); NameData schema_name, table_name, associated_schema_name; ChunkSizingInfo *chunk_sizing_info; LockRelationOid(table_relid, AccessExclusiveLock); /* * Check that the user has permissions to make this table to a compressed * hypertable */ ts_hypertable_permissions_check(table_relid, user_oid); if (ts_is_hypertable(table_relid)) { ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_EXISTS), errmsg("table \"%s\" is already a hypertable", get_rel_name(table_relid)))); } namestrcpy(&schema_name, get_namespace_name(get_rel_namespace(table_relid))); namestrcpy(&table_name, get_rel_name(table_relid)); /* we don't use the chunking size info for managing the compressed table. * But need this to satisfy hypertable constraints */ chunk_sizing_info = ts_chunk_sizing_info_get_default_disabled(table_relid); ts_chunk_sizing_func_validate(chunk_sizing_info->func, chunk_sizing_info); /* Checks pass, now we can create the catalog information */ namestrcpy(&schema_name, get_namespace_name(get_rel_namespace(table_relid))); namestrcpy(&table_name, get_rel_name(table_relid)); namestrcpy(&associated_schema_name, INTERNAL_SCHEMA_NAME); /* compressed hypertable has no dimensions of its own , shares the original hypertable dims*/ hypertable_insert(hypertable_id, &schema_name, &table_name, &associated_schema_name, NULL, &chunk_sizing_info->func_schema, &chunk_sizing_info->func_name, chunk_sizing_info->target_size_bytes, 0 /*num_dimensions*/, true); /* No indexes are created for the compressed hypertable here */ /* Attach tablespace, if any */ if (OidIsValid(tspc_oid)) { NameData tspc_name; namestrcpy(&tspc_name, get_tablespace_name(tspc_oid)); ts_tablespace_attach_internal(&tspc_name, table_relid, false); } return true; } /* * Get the max value of an open dimension. */ int64 ts_hypertable_get_open_dim_max_value(const Hypertable *ht, int dimension_index, bool *isnull) { StringInfo command; const Dimension *dim; int res; bool max_isnull; Datum maxdat; Oid timetype; dim = hyperspace_get_open_dimension(ht->space, dimension_index); if (NULL == dim) elog(ERROR, "invalid open dimension index %d", dimension_index); timetype = ts_dimension_get_partition_type(dim); /* * Query for the last bucket in the materialized hypertable. * Since this might be run as part of a parallel operation * we cannot use SET search_path here to lock down the * search_path and instead have to fully schema-qualify * everything. */ command = makeStringInfo(); appendStringInfo(command, "SELECT pg_catalog.max(%s) FROM %s.%s", quote_identifier(NameStr(dim->fd.column_name)), quote_identifier(NameStr(ht->fd.schema_name)), quote_identifier(NameStr(ht->fd.table_name))); if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); res = SPI_execute(command->data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not find the maximum time value for hypertable \"%s\"", get_rel_name(ht->main_table_relid))))); Ensure(SPI_gettypeid(SPI_tuptable->tupdesc, 1) == timetype, "partition types for result (%d) and dimension (%d) do not match", SPI_gettypeid(SPI_tuptable->tupdesc, 1), ts_dimension_get_partition_type(dim)); maxdat = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &max_isnull); if (isnull) *isnull = max_isnull; int64 max_value = max_isnull ? ts_time_get_min(timetype) : ts_time_value_to_internal(maxdat, timetype); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); return max_value; } bool ts_hypertable_has_compression_table(const Hypertable *ht) { if (ht->fd.compressed_hypertable_id != INVALID_HYPERTABLE_ID) { Assert(ht->fd.compression_state == HypertableCompressionEnabled); return true; } return false; } /* * hypertable status update is done in two steps, similar to * chunk_update_status * This is again equivalent to a SELECT FOR UPDATE, followed by UPDATE * 1. RowShareLock to SELECT for UPDATE * 2. UPDATE status using RowExclusiveLock */ bool ts_hypertable_update_status_osm(Hypertable *ht) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); if (form.status != ht->fd.status) { form.status = ht->fd.status; hypertable_update_catalog_tuple(&tid, &form); } return true; } bool ts_hypertable_update_chunk_sizing(Hypertable *ht) { FormData_hypertable form; ItemPointerData tid; /* lock the tuple entry in the catalog table */ bool found = lock_hypertable_tuple(ht->fd.id, &tid, &form); Ensure(found, "hypertable id %d not found", ht->fd.id); if (OidIsValid(ht->chunk_sizing_func)) { const Dimension *dim = ts_hyperspace_get_dimension(ht->space, DIMENSION_TYPE_OPEN, 0); ChunkSizingInfo info = { .table_relid = ht->main_table_relid, .colname = dim == NULL ? NULL : NameStr(dim->fd.column_name), .func = ht->chunk_sizing_func, }; ts_chunk_adaptive_sizing_info_validate(&info); namestrcpy(&form.chunk_sizing_func_schema, NameStr(info.func_schema)); namestrcpy(&form.chunk_sizing_func_name, NameStr(info.func_name)); } else elog(ERROR, "chunk sizing function cannot be NULL"); form.chunk_target_size = ht->fd.chunk_target_size; hypertable_update_catalog_tuple(&tid, &form); return true; } DimensionSlice * ts_chunk_get_osm_slice_and_lock(int32 osm_chunk_id, int32 time_dim_id, LockTupleMode tuplockmode, LOCKMODE tablelockmode) { ChunkConstraints *constraints = ts_chunk_constraint_scan_by_chunk_id(osm_chunk_id, 1, CurrentMemoryContext); for (int i = 0; i < constraints->num_constraints; i++) { ChunkConstraint *cc = chunk_constraints_get(constraints, i); if (is_dimension_constraint(cc)) { ScanTupLock tuplock = { .lockmode = tuplockmode, .waitpolicy = LockWaitBlock, }; /* * We cannot acquire a tuple lock when running in recovery mode * since that prevents scans on tiered hypertables from running * on a read-only secondary. Acquiring a tuple lock requires * assigning a transaction id for the current transaction state * which is not possible in recovery mode. So we only acquire the * lock if we are not in recovery mode. */ ScanTupLock *const tuplock_ptr = RecoveryInProgress() ? NULL : &tuplock; if (!IsolationUsesXactSnapshot()) { /* in read committed mode, we follow all updates to this tuple */ tuplock.lockflags |= TUPLE_LOCK_FLAG_FIND_LAST_VERSION; } DimensionSlice *dimslice = ts_dimension_slice_scan_by_id_and_lock(cc->fd.dimension_slice_id, tuplock_ptr, CurrentMemoryContext, tablelockmode); if (dimslice->fd.dimension_id == time_dim_id) return dimslice; } } return NULL; } /* * hypertable_osm_range_update * 0 hypertable REGCLASS, * 1 range_start=NULL::bigint, * 2 range_end=NULL, * 3 empty=false * If empty is set to true then the range will be set to invalid range * but the overlap flag will be unset, indicating that no data is managed * by OSM and therefore timescaledb optimizations can be applied. */ TS_FUNCTION_INFO_V1(ts_hypertable_osm_range_update); Datum ts_hypertable_osm_range_update(PG_FUNCTION_ARGS) { Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Hypertable *ht; const Dimension *time_dim; Cache *hcache; Oid time_type; /* required for resolving the argument types, should match the hypertable partitioning column type */ /* * This function is not meant to be run on a read-only secondary. It is * only used by OSM to update chunk's range in timescaledb catalog when * tiering configuration changes (a new chunk is created, a chunk drop * etc); OSM would already be holding a lock on a dimension slice tuple * by this moment (which is not possible on read-only instance). * Technically this function can be executed from SQL (e.g. from psql) when * in recovery mode; in that instance an ERROR would be thrown when trying * to update the dimension slice tuple, no harm will be done. */ Assert(!RecoveryInProgress()); hcache = ts_hypertable_cache_pin(); ht = ts_resolve_hypertable_from_table_or_cagg(hcache, relid, true); Assert(ht != NULL); time_dim = hyperspace_get_open_dimension(ht->space, 0); if (time_dim == NULL) elog(ERROR, "could not find time dimension for hypertable %s.%s", quote_identifier(NameStr(ht->fd.schema_name)), quote_identifier(NameStr(ht->fd.table_name))); time_type = ts_dimension_get_partition_type(time_dim); int32 osm_chunk_id = ts_chunk_get_osm_chunk_id(ht->fd.id); if (osm_chunk_id == INVALID_CHUNK_ID) elog(ERROR, "no OSM chunk found for hypertable %s.%s", quote_identifier(NameStr(ht->fd.schema_name)), quote_identifier(NameStr(ht->fd.table_name))); /* * range_start, range_end arguments must be converted to internal representation * a NULL start value is interpreted as INT64_MAX - 1 and a NULL end value is * interpreted as INT64_MAX. * Passing both start and end NULL values will reset the range to the default range an * OSM chunk is given upon creation, which is [INT64_MAX - 1, INT64_MAX] */ if ((PG_ARGISNULL(1) && !PG_ARGISNULL(2)) || (!PG_ARGISNULL(1) && PG_ARGISNULL(2))) elog(ERROR, "range_start and range_end parameters must be both NULL or both non-NULL"); Oid argtypes[2]; for (int i = 0; i < 2; i++) { argtypes[i] = get_fn_expr_argtype(fcinfo->flinfo, i + 1); if (!can_coerce_type(1, &argtypes[i], &time_type, COERCION_IMPLICIT) && !PG_ARGISNULL(i + 1)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time argument type \"%s\"", format_type_be(argtypes[i])), errhint("Try casting the argument to \"%s\".", format_type_be(time_type)))); } int64 range_start_internal, range_end_internal; if (PG_ARGISNULL(1)) range_start_internal = PG_INT64_MAX - 1; else range_start_internal = ts_time_value_to_internal(PG_GETARG_DATUM(1), get_fn_expr_argtype(fcinfo->flinfo, 1)); if (PG_ARGISNULL(2)) range_end_internal = PG_INT64_MAX; else range_end_internal = ts_time_value_to_internal(PG_GETARG_DATUM(2), get_fn_expr_argtype(fcinfo->flinfo, 2)); if (range_start_internal > range_end_internal) ereport(ERROR, errmsg("dimension slice range_end cannot be less than range_start")); bool osm_chunk_empty = PG_GETARG_BOOL(3); bool overlap = false, range_invalid = false; /* Lock tuple FOR UPDATE */ DimensionSlice *slice = ts_chunk_get_osm_slice_and_lock(osm_chunk_id, time_dim->fd.id, LockTupleExclusive, RowShareLock); if (!slice) ereport(ERROR, errmsg("could not find time dimension slice for chunk %d", osm_chunk_id)); int32 dimension_slice_id = slice->fd.id; overlap = ts_osm_chunk_range_overlaps(dimension_slice_id, slice->fd.dimension_id, range_start_internal, range_end_internal); /* * It should not be possible for OSM chunks to overlap with the range * managed by timescaledb. OSM extension should update the range of the * OSM chunk to [INT64_MAX -1, infinity) when it detects that it is * noncontiguous, so we should not end up detecting overlaps anyway. * But throw an error in case we encounter this situation. */ if (overlap) ereport(ERROR, errmsg("attempting to set overlapping range for tiered chunk of %s.%s", NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name)), errhint("Range should be set to invalid for tiered chunk")); range_invalid = ts_osm_chunk_range_is_invalid(range_start_internal, range_end_internal); /* Update the hypertable flags regarding the validity of the OSM range */ if (range_invalid) { /* range is set to infinity so the OSM chunk is considered last */ range_start_internal = PG_INT64_MAX - 1; range_end_internal = PG_INT64_MAX; if (!osm_chunk_empty) ht->fd.status = ts_set_flags_32(ht->fd.status, HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS); else ht->fd.status = ts_clear_flags_32(ht->fd.status, HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS); } else ht->fd.status = ts_clear_flags_32(ht->fd.status, HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS); ts_hypertable_update_status_osm(ht); ts_cache_release(&hcache); slice->fd.range_start = range_start_internal; slice->fd.range_end = range_end_internal; ts_dimension_slice_range_update(slice); PG_RETURN_BOOL(overlap); } TSDLLEXPORT bool ts_hypertable_has_continuous_aggregates(int32 hypertable_id) { bool found = false; ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); iterator.ctx.limit = 1; /* we only need to know if there is at least one */ iterator.ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGG, CONTINUOUS_AGG_RAW_HYPERTABLE_ID_IDX); ts_scan_iterator_scan_key_init(&iterator, Anum_continuous_agg_raw_hypertable_id_idx_raw_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); ts_scan_iterator_start_scan(&iterator); if (ts_scan_iterator_next(&iterator)) found = true; ts_scan_iterator_close(&iterator); return found; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypertable.h�����������������������������������������������������������������0000664�0000000�0000000�00000016552�15100345067�0017163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/primnodes.h> #include <utils/array.h> #include "chunk_adaptive.h" #include "dimension.h" #include "export.h" #include "hypertable_cache.h" #include "scan_iterator.h" #include "scanner.h" #include "ts_catalog/catalog.h" #include "ts_catalog/tablespace.h" #define INVALID_HYPERTABLE_ID 0 typedef struct SubspaceStore SubspaceStore; typedef struct Chunk Chunk; typedef struct Hypercube Hypercube; typedef struct ChunkRangeSpace ChunkRangeSpace; enum { HypertableCompressionOff = 0, HypertableCompressionEnabled = 1, HypertableInternalCompressionTable = 2, }; #define TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht) ts_hypertable_has_compression_table(ht) #define TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht) \ ((ht)->fd.compression_state == HypertableCompressionEnabled) #define TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht) \ ((ht)->fd.compression_state == HypertableInternalCompressionTable) typedef struct Hypertable { FormData_hypertable fd; Oid main_table_relid; Oid chunk_sizing_func; Hyperspace *space; SubspaceStore *chunk_cache; ChunkRangeSpace *range_space; } Hypertable; /* create_hypertable record attribute numbers */ enum Anum_create_hypertable { Anum_create_hypertable_id = 1, Anum_create_hypertable_schema_name, Anum_create_hypertable_table_name, Anum_create_hypertable_created, _Anum_create_hypertable_max, }; #define Natts_create_hypertable (_Anum_create_hypertable_max - 1) /* Create a generic hypertable */ enum Anum_generic_create_hypertable { Anum_generic_create_hypertable_id = 1, Anum_generic_create_hypertable_created, _Anum_generic_create_hypertable_max, }; #define Natts_generic_create_hypertable (_Anum_generic_create_hypertable_max - 1) extern TSDLLEXPORT Oid ts_rel_get_owner(Oid relid); typedef enum HypertableCreateFlags { HYPERTABLE_CREATE_DISABLE_DEFAULT_INDEXES = 1 << 0, HYPERTABLE_CREATE_IF_NOT_EXISTS = 1 << 1, HYPERTABLE_CREATE_MIGRATE_DATA = 1 << 2, } HypertableCreateFlags; extern TSDLLEXPORT bool ts_hypertable_create_from_info(Oid table_relid, int32 hypertable_id, uint32 flags, DimensionInfo *time_dim_info, DimensionInfo *closed_dim_info, Name associated_schema_name, Name associated_table_prefix, ChunkSizingInfo *chunk_sizing_info); extern TSDLLEXPORT bool ts_hypertable_create_compressed(Oid table_relid, int32 hypertable_id); extern TSDLLEXPORT Hypertable *ts_hypertable_get_by_id(int32 hypertable_id); extern Hypertable *ts_hypertable_get_by_name(const char *schema, const char *name); extern TSDLLEXPORT bool ts_hypertable_get_attributes_by_name(const char *schema, const char *name, FormData_hypertable *form); extern TSDLLEXPORT bool ts_hypertable_has_privs_of(Oid hypertable_oid, Oid userid); extern TSDLLEXPORT Oid ts_hypertable_permissions_check(Oid hypertable_oid, Oid userid); extern TSDLLEXPORT void ts_hypertable_permissions_check_by_id(int32 hypertable_id); extern Hypertable *ts_hypertable_from_tupleinfo(const TupleInfo *ti); extern Hypertable *ts_resolve_hypertable_from_table_or_cagg(Cache *hcache, Oid relid, bool allow_matht); extern int ts_hypertable_scan_with_memory_context(const char *schema, const char *table, tuple_found_func tuple_found, void *data, LOCKMODE lockmode, MemoryContext mctx); extern bool ts_hypertable_update_status_osm(Hypertable *ht); extern bool ts_hypertable_update_chunk_sizing(Hypertable *ht); extern int ts_hypertable_set_name(Hypertable *ht, const char *newname); extern int ts_hypertable_set_schema(Hypertable *ht, const char *newname); extern int ts_hypertable_set_num_dimensions(Hypertable *ht, int16 num_dimensions); extern int ts_hypertable_delete_by_name(const char *schema_name, const char *table_name); extern int ts_hypertable_delete_by_id(int32 hypertable_id); extern TSDLLEXPORT ObjectAddress ts_hypertable_create_trigger(const Hypertable *ht, CreateTrigStmt *stmt, const char *query); extern TSDLLEXPORT void ts_hypertable_drop_invalidation_replication_slot(const char *slot_name); extern TSDLLEXPORT void ts_hypertable_drop_trigger(Oid relid, const char *trigger_name); extern TSDLLEXPORT void ts_hypertable_drop(Hypertable *hypertable, DropBehavior behavior); extern int ts_hypertable_reset_associated_schema_name(const char *associated_schema); extern TSDLLEXPORT Oid ts_hypertable_id_to_relid(int32 hypertable_id, bool return_invalid); extern TSDLLEXPORT int32 ts_hypertable_relid_to_id(Oid relid); extern TSDLLEXPORT Chunk *ts_hypertable_find_chunk_for_point(const Hypertable *h, const Point *point, LOCKMODE lockmode); extern TSDLLEXPORT Chunk *ts_hypertable_chunk_store_add(const Hypertable *h, const Chunk *input_chunk); extern TSDLLEXPORT Chunk *ts_hypertable_create_chunk_for_point(const Hypertable *h, const Point *point, LOCKMODE chunk_lockmode); extern Oid ts_hypertable_relid(RangeVar *rv); extern TSDLLEXPORT bool ts_is_hypertable(Oid relid); extern bool ts_hypertable_has_tablespace(const Hypertable *ht, Oid tspc_oid); extern Tablespace *ts_hypertable_select_tablespace(const Hypertable *ht, const Chunk *chunk); extern const char *ts_hypertable_select_tablespace_name(const Hypertable *ht, const Chunk *chunk); extern Tablespace *ts_hypertable_get_tablespace_at_offset_from(int32 hypertable_id, Oid tablespace_oid, int16 offset); extern TSDLLEXPORT bool ts_hypertable_has_chunks(Oid table_relid, LOCKMODE lockmode); extern void ts_hypertables_rename_schema_name(const char *old_name, const char *new_name); extern bool ts_is_partitioning_column(const Hypertable *ht, AttrNumber column_attno); extern bool ts_is_partitioning_column_name(const Hypertable *ht, NameData column_name); extern TSDLLEXPORT bool ts_hypertable_set_compressed(Hypertable *ht, int32 compressed_hypertable_id); extern TSDLLEXPORT bool ts_hypertable_unset_compressed(Hypertable *ht); extern TSDLLEXPORT bool ts_hypertable_set_compress_interval(Hypertable *ht, int64 compress_interval); extern TSDLLEXPORT int64 ts_hypertable_get_open_dim_max_value(const Hypertable *ht, int dimension_index, bool *isnull); extern TSDLLEXPORT bool ts_hypertable_has_compression_table(const Hypertable *ht); extern TSDLLEXPORT bool ts_hypertable_has_continuous_aggregates(int32 hypertable_id); extern TSDLLEXPORT void ts_hypertable_formdata_fill(FormData_hypertable *fd, const TupleInfo *ti); #define hypertable_scan(schema, table, tuple_found, data, lockmode) \ ts_hypertable_scan_with_memory_context(schema, \ table, \ tuple_found, \ data, \ lockmode, \ CurrentMemoryContext) #define hypertable_adaptive_chunking_enabled(ht) \ (OidIsValid((ht)->chunk_sizing_func) && (ht)->fd.chunk_target_size > 0) ������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypertable_cache.c�����������������������������������������������������������0000664�0000000�0000000�00000013555�15100345067�0020301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/namespace.h> #include <utils/builtins.h> #include <utils/catcache.h> #include <utils/lsyscache.h> #include "cache.h" #include "dimension.h" #include "errors.h" #include "hypertable.h" #include "hypertable_cache.h" #include "scanner.h" #include "ts_catalog/catalog.h" #include "ts_catalog/tablespace.h" static void *hypertable_cache_create_entry(Cache *cache, CacheQuery *query); static void hypertable_cache_missing_error(const Cache *cache, const CacheQuery *query); typedef struct HypertableCacheQuery { CacheQuery q; Oid relid; const char *schema; const char *table; } HypertableCacheQuery; static void * hypertable_cache_get_key(CacheQuery *query) { return &((HypertableCacheQuery *) query)->relid; } typedef struct { Oid relid; Hypertable *hypertable; } HypertableCacheEntry; static bool hypertable_cache_valid_result(const void *result) { if (result == NULL) return false; return ((HypertableCacheEntry *) result)->hypertable != NULL; } static Cache * hypertable_cache_create() { MemoryContext ctx = AllocSetContextCreate(CacheMemoryContext, "Hypertable cache", ALLOCSET_DEFAULT_SIZES); Cache *cache = MemoryContextAlloc(ctx, sizeof(Cache)); Cache template = { .hctl = { .keysize = sizeof(Oid), .entrysize = sizeof(HypertableCacheEntry), .hcxt = ctx, }, .name = "hypertable_cache", .numelements = 16, .flags = HASH_ELEM | HASH_CONTEXT | HASH_BLOBS, .get_key = hypertable_cache_get_key, .create_entry = hypertable_cache_create_entry, .missing_error = hypertable_cache_missing_error, .valid_result = hypertable_cache_valid_result, }; *cache = template; ts_cache_init(cache); return cache; } static Cache *hypertable_cache_current = NULL; static ScanTupleResult hypertable_tuple_found(TupleInfo *ti, void *data) { HypertableCacheEntry *entry = data; entry->hypertable = ts_hypertable_from_tupleinfo(ti); return SCAN_DONE; } static void * hypertable_cache_create_entry(Cache *cache, CacheQuery *query) { HypertableCacheQuery *hq = (HypertableCacheQuery *) query; HypertableCacheEntry *cache_entry = query->result; int number_found; if (NULL == hq->schema) hq->schema = get_namespace_name(get_rel_namespace(hq->relid)); if (NULL == hq->table) hq->table = get_rel_name(hq->relid); number_found = ts_hypertable_scan_with_memory_context(hq->schema, hq->table, hypertable_tuple_found, query->result, AccessShareLock, ts_cache_memory_ctx(cache)); switch (number_found) { case 0: /* Negative cache entry: table is not a hypertable */ cache_entry->hypertable = NULL; break; case 1: Assert(strncmp(NameStr(cache_entry->hypertable->fd.schema_name), hq->schema, NAMEDATALEN) == 0); Assert(strncmp(NameStr(cache_entry->hypertable->fd.table_name), hq->table, NAMEDATALEN) == 0); break; default: elog(ERROR, "got an unexpected number of records: %d", number_found); break; } return cache_entry->hypertable == NULL ? NULL : cache_entry; } static void hypertable_cache_missing_error(const Cache *cache, const CacheQuery *query) { HypertableCacheQuery *hq = (HypertableCacheQuery *) query; const char *const rel_name = get_rel_name(hq->relid); if (rel_name == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("OID %u does not refer to a table", hq->relid))); else ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("table \"%s\" is not a hypertable", rel_name))); } void ts_hypertable_cache_invalidate_callback(void) { ts_cache_invalidate(&hypertable_cache_current); hypertable_cache_current = hypertable_cache_create(); } /* Get hypertable cache entry. If the entry is not in the cache, add it. */ Hypertable * ts_hypertable_cache_get_entry(Cache *const cache, const Oid relid, const unsigned int flags) { if (!OidIsValid(relid)) { if (flags & CACHE_FLAG_MISSING_OK) return NULL; else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("invalid Oid"))); } return ts_hypertable_cache_get_entry_with_table(cache, relid, NULL, NULL, flags); } /* * Returns cache into the argument and hypertable as the function result. * If hypertable is not found, fails with an error. */ Hypertable * ts_hypertable_cache_get_cache_and_entry(const Oid relid, const unsigned int flags, Cache **const cache) { *cache = ts_hypertable_cache_pin(); return ts_hypertable_cache_get_entry(*cache, relid, flags); } Hypertable * ts_hypertable_cache_get_entry_rv(Cache *cache, const RangeVar *rv) { return ts_hypertable_cache_get_entry(cache, RangeVarGetRelid(rv, NoLock, true), CACHE_FLAG_MISSING_OK); } TSDLLEXPORT Hypertable * ts_hypertable_cache_get_entry_by_id(Cache *cache, const int32 hypertable_id) { return ts_hypertable_cache_get_entry(cache, ts_hypertable_id_to_relid(hypertable_id, true), CACHE_FLAG_MISSING_OK); } Hypertable * ts_hypertable_cache_get_entry_with_table(Cache *cache, const Oid relid, const char *schema, const char *table, const unsigned int flags) { HypertableCacheQuery query = { .q.flags = flags, .relid = relid, .schema = schema, .table = table, }; HypertableCacheEntry *entry = ts_cache_fetch(cache, &query.q); Assert((flags & CACHE_FLAG_MISSING_OK) ? true : (entry != NULL && entry->hypertable != NULL)); return entry == NULL ? NULL : entry->hypertable; } extern TSDLLEXPORT Cache * ts_hypertable_cache_pin() { return ts_cache_pin(hypertable_cache_current); } void _hypertable_cache_init(void) { CreateCacheMemoryContext(); hypertable_cache_current = hypertable_cache_create(); } void _hypertable_cache_fini(void) { ts_cache_invalidate(&hypertable_cache_current); } ���������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypertable_cache.h�����������������������������������������������������������0000664�0000000�0000000�00000004472�15100345067�0020304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "cache.h" #include "export.h" #include "hypertable.h" /* When a hypertable entry ht is fetched using the cache * i.e. ts_hypertable_cache_get_entry and variants, all related information such as * hyperspaces, dimensions etc are also fetched into the cache. These are allocated in * the cache's memory context. * If the cache pin is released by calling ts_cache_release or variants, the memory * associated with hypertable, its space dimensions etc. have also been released. * As a best practice, call ts_cache_release right before returning from the function * where the cache entry was acquired. This prevents inadvertent errors if someone * modifies this function later and uses an indirectly linked object from the cache. * Example: * void my_func(...) * { * * Hypertable * ht = ts_hypertable_cache_get_xxx(...) * ...... * * if ( error ) * { * elog(ERROR, ... ); <----- ts_cache_release not needed here. * } * * ..... * ts_cache_release(); * return ..; * } * Note that any exceptions/errors i.e. elog/ereport etc. will trigger an automatic * cache release. So there is no need for additional ts_cache_release() calls. */ extern TSDLLEXPORT Hypertable *ts_hypertable_cache_get_entry(Cache *const cache, const Oid relid, const unsigned int flags); extern TSDLLEXPORT Hypertable *ts_hypertable_cache_get_cache_and_entry(const Oid relid, const unsigned int flags, Cache **const cache); extern TSDLLEXPORT Hypertable *ts_hypertable_cache_get_entry_rv(Cache *cache, const RangeVar *rv); extern TSDLLEXPORT Hypertable * ts_hypertable_cache_get_entry_with_table(Cache *cache, const Oid relid, const char *schema, const char *table, const unsigned int flags); extern TSDLLEXPORT Hypertable *ts_hypertable_cache_get_entry_by_id(Cache *cache, const int32 hypertable_id); extern void ts_hypertable_cache_invalidate_callback(void); extern TSDLLEXPORT Cache *ts_hypertable_cache_pin(void); extern void _hypertable_cache_init(void); extern void _hypertable_cache_fini(void); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypertable_restrict_info.c���������������������������������������������������0000664�0000000�0000000�00000056173�15100345067�0022113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_inherits.h> #include <optimizer/optimizer.h> #include <parser/parsetree.h> #include <tcop/tcopprot.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/typcache.h> #include "hypertable_restrict_info.h" #include "chunk.h" #include "chunk_scan.h" #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "expression_utils.h" #include "guc.h" #include "hypercube.h" #include "partitioning.h" #include "scan_iterator.h" #include "ts_catalog/chunk_column_stats.h" #include "utils.h" typedef struct DimensionValues { List *values; bool use_or; /* ORed or ANDed values */ Oid type; /* Oid type for values */ } DimensionValues; static DimensionRestrictInfoOpen * dimension_restrict_info_open_create(const Dimension *d) { DimensionRestrictInfoOpen *new = palloc(sizeof(DimensionRestrictInfoOpen)); new->base.dimension = d; new->lower_strategy = InvalidStrategy; new->upper_strategy = InvalidStrategy; return new; } static DimensionRestrictInfoClosed * dimension_restrict_info_closed_create(const Dimension *d) { DimensionRestrictInfoClosed *new = palloc(sizeof(DimensionRestrictInfoClosed)); new->partitions = NIL; new->base.dimension = d; new->strategy = InvalidStrategy; return new; } static DimensionRestrictInfo * dimension_restrict_info_create(const Dimension *d) { switch (d->type) { case DIMENSION_TYPE_OPEN: return &dimension_restrict_info_open_create(d)->base; case DIMENSION_TYPE_CLOSED: return &dimension_restrict_info_closed_create(d)->base; default: elog(ERROR, "unknown dimension type"); return NULL; } } /* * Given a column from a hypertable, create a DimensionRestrictInfo entry * representing it. This gets used by the usual hypertable restrict info * machinery to identify if the query clauses are using expressions involving * this column. Note that this column is NOT a partitioning column but we are * tracking ranges for this column in the _timescaledb_catalog.chunk_column_stats * catalog table. * * The idea is to do chunk exclusion when queries have WHERE clauses using this * column. The logic at the "Dimension" entry level are the same, so we reuse the * same representation to benefit from it. */ static DimensionRestrictInfo * chunk_column_stats_restrict_info_create(const Hypertable *ht, const Form_chunk_column_stats d) { /* create a dummy dimension structure for this range entry */ Dimension *dim = ts_chunk_column_stats_fill_dummy_dimension(d, ht->main_table_relid); /* similar to open dimensions */ return &dimension_restrict_info_open_create(dim)->base; } /* * Check if the restriction on this dimension is trivial, that is, the entire * range of the dimension matches. */ static bool dimension_restrict_info_is_trivial(const DimensionRestrictInfo *dri) { switch (dri->dimension->type) { case DIMENSION_TYPE_OPEN: case DIMENSION_TYPE_STATS: { DimensionRestrictInfoOpen *open = (DimensionRestrictInfoOpen *) dri; return open->lower_strategy == InvalidStrategy && open->upper_strategy == InvalidStrategy; } case DIMENSION_TYPE_CLOSED: return ((DimensionRestrictInfoClosed *) dri)->strategy == InvalidStrategy; default: Assert(false); return false; } } static bool dimension_restrict_info_open_add(DimensionRestrictInfoOpen *dri, StrategyNumber strategy, Oid collation, DimensionValues *dimvalues) { ListCell *item; bool restriction_added = false; /* can't handle IN/ANY with multiple values */ if (dimvalues->use_or && list_length(dimvalues->values) > 1) return false; foreach (item, dimvalues->values) { Oid restype; Datum datum = ts_dimension_transform_value(dri->base.dimension, collation, PointerGetDatum(lfirst(item)), dimvalues->type, &restype); int64 value = ts_time_value_to_internal_or_infinite(datum, restype); switch (strategy) { case BTLessEqualStrategyNumber: case BTLessStrategyNumber: if (dri->upper_strategy == InvalidStrategy || value < dri->upper_bound) { dri->upper_strategy = strategy; dri->upper_bound = value; restriction_added = true; } break; case BTGreaterEqualStrategyNumber: case BTGreaterStrategyNumber: if (dri->lower_strategy == InvalidStrategy || value > dri->lower_bound) { dri->lower_strategy = strategy; dri->lower_bound = value; restriction_added = true; } break; case BTEqualStrategyNumber: dri->lower_bound = value; dri->upper_bound = value; dri->lower_strategy = BTGreaterEqualStrategyNumber; dri->upper_strategy = BTLessEqualStrategyNumber; restriction_added = true; break; default: /* unsupported strategy */ break; } } return restriction_added; } static List * dimension_restrict_info_get_partitions(DimensionRestrictInfoClosed *dri, Oid collation, List *values) { List *partitions = NIL; ListCell *item; foreach (item, values) { Datum value = ts_dimension_transform_value(dri->base.dimension, collation, PointerGetDatum(lfirst(item)), InvalidOid, NULL); partitions = list_append_unique_int(partitions, DatumGetInt32(value)); } return partitions; } static bool dimension_restrict_info_closed_add(DimensionRestrictInfoClosed *dri, StrategyNumber strategy, Oid collation, DimensionValues *dimvalues) { List *partitions; bool restriction_added = false; if (strategy != BTEqualStrategyNumber) { return false; } partitions = dimension_restrict_info_get_partitions(dri, collation, dimvalues->values); /* the intersection is empty when using ALL operator (ANDing values) */ if (list_length(partitions) > 1 && !dimvalues->use_or) { dri->strategy = strategy; dri->partitions = NIL; return true; } if (dri->strategy == InvalidStrategy) /* first time through */ { dri->partitions = partitions; dri->strategy = strategy; restriction_added = true; } else { /* intersection with NULL is NULL */ if (dri->partitions == NIL) return true; /* * We are always ANDing the expressions thus intersection is used. */ dri->partitions = list_intersection_int(dri->partitions, partitions); /* no intersection is also a restriction */ restriction_added = true; } return restriction_added; } static bool dimension_restrict_info_add(DimensionRestrictInfo *dri, int strategy, Oid collation, DimensionValues *values) { switch (dri->dimension->type) { case DIMENSION_TYPE_OPEN: return dimension_restrict_info_open_add((DimensionRestrictInfoOpen *) dri, strategy, collation, values); case DIMENSION_TYPE_STATS: /* we reuse the DimensionRestrictInfoOpen structure for these */ return dimension_restrict_info_open_add((DimensionRestrictInfoOpen *) dri, strategy, collation, values); case DIMENSION_TYPE_CLOSED: return dimension_restrict_info_closed_add((DimensionRestrictInfoClosed *) dri, strategy, collation, values); default: elog(ERROR, "unknown dimension type: %d", dri->dimension->type); /* suppress compiler warning on MSVC */ return false; } } typedef struct HypertableRestrictInfo { int num_base_restrictions; /* number of base restrictions * successfully added */ int num_dimensions; DimensionRestrictInfo *dimension_restriction[FLEXIBLE_ARRAY_MEMBER]; /* array of dimension * restrictions */ } HypertableRestrictInfo; HypertableRestrictInfo * ts_hypertable_restrict_info_create(RelOptInfo *rel, Hypertable *ht) { /* If chunk skipping is disabled, we have to empty range_space * in case it was cached earlier. */ ChunkRangeSpace *range_space = ht->range_space; if (!ts_guc_enable_chunk_skipping) range_space = NULL; int num_dimensions = ht->space->num_dimensions + (range_space ? range_space->num_range_cols : 0); HypertableRestrictInfo *res = palloc0(sizeof(HypertableRestrictInfo) + (sizeof(DimensionRestrictInfo *) * num_dimensions)); int i; int range_index = 0; res->num_dimensions = num_dimensions; for (i = 0; i < ht->space->num_dimensions; i++) { DimensionRestrictInfo *dri = dimension_restrict_info_create(&ht->space->dimensions[i]); res->dimension_restriction[i] = dri; range_index++; } /* * We convert the range_space entries into dummy "DimensionRestrictInfo" entries. This allows * the hypertable restrict info machinery to consider these as well. */ for (i = 0; range_space != NULL && i < range_space->num_range_cols; i++) { DimensionRestrictInfo *dri = chunk_column_stats_restrict_info_create(ht, &ht->range_space->range_cols[i]); res->dimension_restriction[range_index++] = dri; } return res; } static DimensionRestrictInfo * hypertable_restrict_info_get(HypertableRestrictInfo *hri, AttrNumber attno) { int i; for (i = 0; i < hri->num_dimensions; i++) { if (hri->dimension_restriction[i]->dimension->column_attno == attno) return hri->dimension_restriction[i]; } return NULL; } typedef DimensionValues *(*get_dimension_values)(Const *c, bool use_or); static void hypertable_restrict_info_add_expr(HypertableRestrictInfo *hri, PlannerInfo *root, Var *v, Expr *expr, Oid op_oid, get_dimension_values func_get_dim_values, bool use_or) { DimensionRestrictInfo *dri; Const *c; RangeTblEntry *rte; Oid columntype; TypeCacheEntry *tce; int strategy; Oid lefttype, righttype; DimensionValues *dimvalues; dri = hypertable_restrict_info_get(hri, v->varattno); /* the attribute is not a dimension */ if (dri == NULL) return; expr = (Expr *) eval_const_expressions(root, (Node *) expr); if (!IsA(expr, Const) || !OidIsValid(op_oid) || !op_strict(op_oid)) return; c = (Const *) expr; /* quick check for a NULL constant */ if (c->constisnull) return; rte = rt_fetch(v->varno, root->parse->rtable); columntype = get_atttype(rte->relid, dri->dimension->column_attno); tce = lookup_type_cache(columntype, TYPECACHE_BTREE_OPFAMILY); if (!op_in_opfamily(op_oid, tce->btree_opf)) return; get_op_opfamily_properties(op_oid, tce->btree_opf, false, &strategy, &lefttype, &righttype); dimvalues = func_get_dim_values(c, use_or); if (dimension_restrict_info_add(dri, strategy, c->constcollid, dimvalues)) { hri->num_base_restrictions++; } } static DimensionValues * dimension_values_create(List *values, Oid type, bool use_or) { DimensionValues *dimvalues; dimvalues = palloc(sizeof(DimensionValues)); dimvalues->values = values; dimvalues->use_or = use_or; dimvalues->type = type; return dimvalues; } static DimensionValues * dimension_values_create_from_array(Const *c, bool user_or) { ArrayIterator iterator = array_create_iterator(DatumGetArrayTypeP(c->constvalue), 0, NULL); Datum elem = (Datum) NULL; bool isnull; List *values = NIL; Oid base_el_type; while (array_iterate(iterator, &elem, &isnull)) { if (!isnull) values = lappend(values, DatumGetPointer(elem)); } /* it's an array type, lets get the base element type */ base_el_type = get_element_type(c->consttype); if (!OidIsValid(base_el_type)) elog(ERROR, "invalid base element type for array type: \"%s\"", format_type_be(c->consttype)); return dimension_values_create(values, base_el_type, user_or); } static DimensionValues * dimension_values_create_from_single_element(Const *c, bool user_or) { return dimension_values_create(list_make1(DatumGetPointer(c->constvalue)), c->consttype, user_or); } static void hypertable_restrict_info_add_restrict_info(HypertableRestrictInfo *hri, PlannerInfo *root, RestrictInfo *ri) { Oid opno; Var *var; Expr *arg_value; Expr *e = ri->clause; /* Same as constraint_exclusion */ if (contain_mutable_functions((Node *) e)) return; if (ts_extract_expr_args(e, &var, &arg_value, &opno, NULL)) { get_dimension_values value_func; bool use_or; switch (nodeTag(e)) { case T_OpExpr: { value_func = dimension_values_create_from_single_element; use_or = false; break; } case T_ScalarArrayOpExpr: { value_func = dimension_values_create_from_array; use_or = castNode(ScalarArrayOpExpr, e)->useOr; break; } default: /* we don't support other node types */ return; } hypertable_restrict_info_add_expr(hri, root, var, arg_value, opno, value_func, use_or); } } void ts_hypertable_restrict_info_add(HypertableRestrictInfo *hri, PlannerInfo *root, List *base_restrict_infos) { ListCell *lc; foreach (lc, base_restrict_infos) { RestrictInfo *ri = lfirst(lc); hypertable_restrict_info_add_restrict_info(hri, root, ri); } } /* * Scan for dimension slices matching query constraints. * * Matching slices are appended to to the given dimension vector. Note that we * keep the table and index open as long as we do not change the number of * scan keys. If the keys change, but the number of keys is the same, we can * simply "rescan". If the number of keys change, however, we need to end the * scan and start again. */ static DimensionVec * scan_and_append_slices(ScanIterator *it, int old_nkeys, DimensionVec **dv, bool unique) { if (old_nkeys != -1 && old_nkeys != it->ctx.nkeys) ts_scan_iterator_end(it); ts_scan_iterator_start_or_restart_scan(it); while (ts_scan_iterator_next(it)) { TupleInfo *ti = ts_scan_iterator_tuple_info(it); DimensionSlice *slice = ts_dimension_slice_from_tuple(ti); if (NULL != slice) { if (unique) *dv = ts_dimension_vec_add_unique_slice(dv, slice); else *dv = ts_dimension_vec_add_slice(dv, slice); } } return *dv; } /* search dimension_slice catalog table for slices that meet hri restriction */ static List * gather_restriction_dimension_vectors(const HypertableRestrictInfo *hri) { List *dimension_vecs = NIL; ScanIterator it; int i; int old_nkeys = -1; it = ts_dimension_slice_scan_iterator_create(NULL, CurrentMemoryContext); for (i = 0; i < hri->num_dimensions; i++) { DimensionRestrictInfo *dri = hri->dimension_restriction[i]; DimensionVec *dv; Assert(NULL != dri); /* dimension ranges don't need dimension slices */ dv = ts_dimension_vec_create( dri->dimension->type == DIMENSION_TYPE_STATS ? 1 : DIMENSION_VEC_DEFAULT_SIZE); dv->dri = dri; switch (dri->dimension->type) { case DIMENSION_TYPE_OPEN: { const DimensionRestrictInfoOpen *open = (const DimensionRestrictInfoOpen *) dri; ts_dimension_slice_scan_iterator_set_range(&it, open->base.dimension->fd.id, open->upper_strategy, open->upper_bound, open->lower_strategy, open->lower_bound); /* * If we have a condition on the second index column * range_start, use a backward scan direction, so that the index * is able to use the second column as well to choose the * starting point for the scan. * If not, prefer forward direction, because backwards scan is * slightly slower for some reason. * Ideally we need some other index type than btree for this, * because the btree index is not so suited for queries like * "find an interval that contains a given point", which is what * we're doing here. * There is a comment in the Postgres code (_bt_start()) that * explains the logic of selecting a starting point for a btree * index scan in more detail. */ it.ctx.scandirection = open->upper_strategy != InvalidStrategy ? BackwardScanDirection : ForwardScanDirection; dv = scan_and_append_slices(&it, old_nkeys, &dv, false); break; } case DIMENSION_TYPE_CLOSED: { const DimensionRestrictInfoClosed *closed = (const DimensionRestrictInfoClosed *) dri; /* Shouldn't have trivial restriction infos here. */ Assert(closed->strategy == BTEqualStrategyNumber); ListCell *cell; foreach (cell, closed->partitions) { int32 partition = lfirst_int(cell); /* * slice_end >= value && slice_start <= value. * See the comment about scan direction above. */ it.ctx.scandirection = BackwardScanDirection; ts_dimension_slice_scan_iterator_set_range(&it, dri->dimension->fd.id, BTLessEqualStrategyNumber, partition, BTGreaterEqualStrategyNumber, partition); dv = scan_and_append_slices(&it, old_nkeys, &dv, true); } break; } case DIMENSION_TYPE_STATS: { /* an empty dv will be appended for this as a placeholder */ break; } default: elog(ERROR, "unknown dimension type"); return NULL; } Assert(dv->num_slices >= 0); /* * If there is a dimension where no slices match, the result will be * empty. But only do so if it's not a DIMENSION_TYPE_STATS entry. * * For DIMENSION_TYPE_STATS entries, we get the list of chunks * directly later on from "chunk_column_stats" catalog. They do not * have dimension slices. */ if (dv->num_slices == 0 && dri->dimension->type != DIMENSION_TYPE_STATS) { ts_scan_iterator_close(&it); return NIL; } dv = ts_dimension_vec_sort(&dv); dimension_vecs = lappend(dimension_vecs, dv); old_nkeys = it.ctx.nkeys; } ts_scan_iterator_close(&it); Assert(list_length(dimension_vecs) == hri->num_dimensions); return dimension_vecs; } Chunk ** ts_hypertable_restrict_info_get_chunks(HypertableRestrictInfo *hri, Hypertable *ht, bool include_osm, unsigned int *num_chunks) { /* * Remove the dimensions for which we don't have a restriction, that is, * the entire range of the dimension matches. Such dimensions do not * influence the result set, because their every slice matches, so we can * just ignore them when searching for the matching chunks. */ const int old_dimensions = hri->num_dimensions; hri->num_dimensions = 0; for (int i = 0; i < old_dimensions; i++) { DimensionRestrictInfo *dri = hri->dimension_restriction[i]; if (!dimension_restrict_info_is_trivial(dri)) { hri->dimension_restriction[hri->num_dimensions] = dri; hri->num_dimensions++; } } List *chunk_ids = NIL; if (hri->num_dimensions == 0) { /* * No restrictions on hyperspace. Just enumerate all the chunks. */ chunk_ids = ts_chunk_get_chunk_ids_by_hypertable_id(ht->fd.id); /* * If the hypertable has an OSM chunk it would end up in the list * as well. We need to remove it when OSM reads are disabled via GUC * variable. */ if (!include_osm || !ts_guc_enable_osm_reads) { int32 osm_chunk_id = ts_chunk_get_osm_chunk_id(ht->fd.id); chunk_ids = list_delete_int(chunk_ids, osm_chunk_id); } } else { /* * Have some restrictions, enumerate the matching dimension slices. */ List *dimension_vectors = gather_restriction_dimension_vectors(hri); if (list_length(dimension_vectors) == 0) { /* * No dimension slices match for some dimension for which there is * a restriction. This means that no chunks match. */ chunk_ids = NIL; } else { /* Find the chunks matching these dimension ranges/slices. */ chunk_ids = ts_chunk_id_find_in_subspace(ht, dimension_vectors); } int32 osm_chunk_id = ts_chunk_get_osm_chunk_id(ht->fd.id); if (osm_chunk_id != INVALID_CHUNK_ID) { if (!ts_guc_enable_osm_reads) { chunk_ids = list_delete_int(chunk_ids, osm_chunk_id); } else { /* * At this point the OSM chunk was either: * 1. added to the list because it has a valid range that agrees with the * restrictions; * 2. not added because it has a valid range and it was excluded; * 3. not added because it has an invalid range and it was excluded. * If the chunk's range is invalid, only then should we consider adding it, * otherwise the exclusion logic should have correctly included or excluded it from * the list. Also, if the range is invalid but the NONCONTIGUOUS flag is not set, * indicating that the chunk is empty, we don't need to do a scan so we do not add * it either. */ const Dimension *time_dim = hyperspace_get_open_dimension(ht->space, 0); DimensionSlice *slice = ts_chunk_get_osm_slice_and_lock(osm_chunk_id, time_dim->fd.id, LockTupleKeyShare, RowShareLock); bool range_invalid = ts_osm_chunk_range_is_invalid(slice->fd.range_start, slice->fd.range_end); if (range_invalid && ts_flags_are_set_32(ht->fd.status, HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS)) chunk_ids = list_append_unique_int(chunk_ids, osm_chunk_id); } } } /* * Sort the ids to have more favorable (closer to sequential) data access * patterns to our catalog tables and indexes. * We don't care about the locking order here, because this code uses * AccessShareLock that doesn't conflict with itself. */ list_sort(chunk_ids, list_int_cmp); return ts_chunk_scan_by_chunk_ids(ht->space, chunk_ids, num_chunks); } /* * Compare two chunks along first dimension and chunk ID (in that priority and * order). */ static int chunk_cmp_impl(const Chunk *c1, const Chunk *c2) { int cmp = ts_dimension_slice_cmp(c1->cube->slices[0], c2->cube->slices[0]); if (cmp == 0) cmp = VALUE_CMP(c1->fd.id, c2->fd.id); return cmp; } static int chunk_cmp(const void *c1, const void *c2) { return chunk_cmp_impl(*((const Chunk **) c1), *((const Chunk **) c2)); } static int chunk_cmp_reverse(const void *c1, const void *c2) { return chunk_cmp_impl(*((const Chunk **) c2), *((const Chunk **) c1)); } /* * get chunk oids ordered by time dimension * * if "chunks" is NULL, we get all the chunks from the catalog. Otherwise we * restrict ourselves to the passed in chunks list. * * nested_oids is a list of lists, chunks that occupy the same time slice will be * in the same list. In the list [[1,2,3],[4,5,6]] chunks 1, 2 and 3 are space partitions of * the same time slice and 4, 5 and 6 are space partitions of the next time slice. * */ Chunk ** ts_hypertable_restrict_info_get_chunks_ordered(HypertableRestrictInfo *hri, Hypertable *ht, bool include_osm, Chunk **chunks, bool reverse, List **nested_oids, unsigned int *num_chunks) { List *slot_chunk_oids = NIL; DimensionSlice *slice = NULL; unsigned int i; if (chunks == NULL) { chunks = ts_hypertable_restrict_info_get_chunks(hri, ht, include_osm, num_chunks); } if (*num_chunks == 0) return NULL; Assert(ht->space->num_dimensions > 0); Assert(IS_OPEN_DIMENSION(&ht->space->dimensions[0])); if (reverse) qsort((void *) chunks, *num_chunks, sizeof(Chunk *), chunk_cmp_reverse); else qsort((void *) chunks, *num_chunks, sizeof(Chunk *), chunk_cmp); for (i = 0; i < *num_chunks; i++) { Chunk *chunk = chunks[i]; if (NULL != slice && ts_dimension_slice_cmp(slice, chunk->cube->slices[0]) != 0 && slot_chunk_oids != NIL) { *nested_oids = lappend(*nested_oids, slot_chunk_oids); slot_chunk_oids = NIL; } if (NULL != nested_oids) slot_chunk_oids = lappend_oid(slot_chunk_oids, chunk->table_id); slice = chunk->cube->slices[0]; } if (slot_chunk_oids != NIL) *nested_oids = lappend(*nested_oids, slot_chunk_oids); return chunks; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/hypertable_restrict_info.h���������������������������������������������������0000664�0000000�0000000�00000003442�15100345067�0022107�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "hypertable.h" typedef struct DimensionRestrictInfo { const Dimension *dimension; } DimensionRestrictInfo; typedef struct DimensionRestrictInfoOpen { DimensionRestrictInfo base; int64 lower_bound; /* internal time representation */ StrategyNumber lower_strategy; int64 upper_bound; /* internal time representation */ StrategyNumber upper_strategy; } DimensionRestrictInfoOpen; typedef struct DimensionRestrictInfoClosed { DimensionRestrictInfo base; List *partitions; /* hash values */ StrategyNumber strategy; /* either Invalid or equal */ } DimensionRestrictInfoClosed; /* HypertableRestrictInfo represents restrictions on a hypertable. It uses * range exclusion logic to figure out which chunks can match the description */ typedef struct HypertableRestrictInfo HypertableRestrictInfo; extern HypertableRestrictInfo *ts_hypertable_restrict_info_create(RelOptInfo *rel, Hypertable *ht); /* Add restrictions based on a List of RestrictInfo */ extern void ts_hypertable_restrict_info_add(HypertableRestrictInfo *hri, PlannerInfo *root, List *base_restrict_infos); /* Get a list of chunk oids for chunks whose constraints match the restriction clauses */ extern Chunk **ts_hypertable_restrict_info_get_chunks(HypertableRestrictInfo *hri, Hypertable *ht, bool include_osm, unsigned int *num_chunks); extern Chunk **ts_hypertable_restrict_info_get_chunks_ordered(HypertableRestrictInfo *hri, Hypertable *ht, bool include_osm, Chunk **chunks, bool reverse, List **nested_oids, unsigned int *num_chunks); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016154�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/CMakeLists.txt��������������������������������������������������������0000664�0000000�0000000�00000000425�15100345067�0020715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/allpaths.c ${CMAKE_CURRENT_SOURCE_DIR}/heapswap.c ${CMAKE_CURRENT_SOURCE_DIR}/list.c ${CMAKE_CURRENT_SOURCE_DIR}/planner.c ${CMAKE_CURRENT_SOURCE_DIR}/ts_explain.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/allpaths.c������������������������������������������������������������0000664�0000000�0000000�00000071356�15100345067�0020144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ #include <postgres.h> #include <access/tsmapi.h> #include <catalog/pg_proc.h> #include <foreign/fdwapi.h> #include <miscadmin.h> #include <nodes/nodeFuncs.h> #include <nodes/parsenodes.h> #include <nodes/plannodes.h> #include <optimizer/appendinfo.h> #include <optimizer/clauses.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/plancat.h> #include <optimizer/planner.h> #include <optimizer/prep.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <math.h> #include "allpaths.h" #include "chunk.h" #include "cross_module_fn.h" #include "planner/planner.h" static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte); /* copied from allpaths.c */ static void set_foreign_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { /* Call the FDW's GetForeignPaths function to generate path(s) */ rel->fdwroutine->GetForeignPaths(root, rel, rte->relid); } /* copied from allpaths.c */ static void set_tablesample_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { Relids required_outer; Path *path; /* * We don't support pushing join clauses into the quals of a samplescan, * but it could still have required parameterization due to LATERAL refs * in its tlist or TABLESAMPLE arguments. */ required_outer = rel->lateral_relids; /* Consider sampled scan */ path = create_samplescan_path(root, rel, required_outer); /* * If the sampling method does not support repeatable scans, we must avoid * plans that would scan the rel multiple times. Ideally, we'd simply * avoid putting the rel on the inside of a nestloop join; but adding such * a consideration to the planner seems like a great deal of complication * to support an uncommon usage of second-rate sampling methods. Instead, * if there is a risk that the query might perform an unsafe join, just * wrap the SampleScan in a Materialize node. We can check for joins by * counting the membership of all_baserels (note that this correctly * counts inheritance trees as single rels). If we're inside a subquery, * we can't easily check whether a join might occur in the outer query, so * just assume one is possible. * * GetTsmRoutine is relatively expensive compared to the other tests here, * so check repeatable_across_scans last, even though that's a bit odd. */ if ((root->query_level > 1 || bms_membership(root->all_baserels) != BMS_SINGLETON) && !(GetTsmRoutine(rte->tablesample->tsmhandler)->repeatable_across_scans)) { path = (Path *) create_material_path(rel, path); } add_path(rel, path); /* For the moment, at least, there are no other paths to consider */ } /* copied from allpaths.c */ static void ts_create_plain_partial_paths(PlannerInfo *root, RelOptInfo *rel) { int parallel_workers; parallel_workers = compute_parallel_worker(rel, rel->pages, -1, max_parallel_workers_per_gather); /* If any limit was set to zero, the user doesn't want a parallel scan. */ if (parallel_workers <= 0) return; /* Add an unordered partial path based on a parallel sequential scan. */ add_partial_path(rel, create_seqscan_path(root, rel, NULL, parallel_workers)); } /* copied from allpaths.c */ static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { Relids required_outer; /* * We don't support pushing join clauses into the quals of a seqscan, but * it could still have required parameterization due to LATERAL refs in * its tlist. */ required_outer = rel->lateral_relids; /* Consider sequential scan */ add_path(rel, create_seqscan_path(root, rel, required_outer, 0)); /* If appropriate, consider parallel sequential scan */ if (rel->consider_parallel && required_outer == NULL) ts_create_plain_partial_paths(root, rel); /* Consider index scans */ create_index_paths(root, rel); /* Consider TID scans */ create_tidscan_paths(root, rel); } /* copied from allpaths.c */ void ts_set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *parent_rel, Index parent_rt_index, RangeTblEntry *parent_rte) { List *live_childrels = NIL; ListCell *l; /* * Generate access paths for each member relation, and remember the * non-dummy children. */ foreach (l, root->append_rel_list) { AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l); /* append_rel_list contains all append rels; ignore others */ if (appinfo->parent_relid != parent_rt_index) continue; /* Re-locate the child RTE and RelOptInfo */ const int child_rt_index = appinfo->child_relid; RelOptInfo *child_rel = root->simple_rel_array[child_rt_index]; /* * If set_append_rel_size() decided the parent appendrel was * parallel-unsafe at some point after visiting this child rel, we * need to propagate the unsafety marking down to the child, so that * we don't generate useless partial paths for it. */ if (!parent_rel->consider_parallel) child_rel->consider_parallel = false; /* * We want to disable planning the index scans on uncompressed chunk * tables of fully compressed chunks. It would be expensive and useless * because the uncompressed chunk tables are empty in this case. * * Note about the 'if' condition: compressed chunk tables expanded from * normal hypertables always have the type TS_REL_CHUNK_STANDALONE. The * direct select from a compressed chunk table would also produce this * type. Another possibility is a direct select from an internal * compression hypertable, where the compressed chunks would have the * type TS_REL_CHUNK_CHILD. We have to filter out all these cases here. * * For standalone chunks or UPDATE/DELETE, we do the same thing in * timescaledb_get_relation_info_hook(). */ Hypertable *ht; TsRelType reltype = ts_classify_relation(root, child_rel, &ht); if (reltype == TS_REL_CHUNK_CHILD && !TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) { const Chunk *chunk = ts_planner_chunk_fetch(root, child_rel); /* * This function is called only in tandem with our own hypertable * expansion, so the Chunk struct must be initialized already. */ Assert(chunk != NULL); if (!ts_chunk_is_partial(chunk) && ts_chunk_is_compressed(chunk)) { child_rel->indexlist = NIL; } } /* * Compute the child's access paths. */ RangeTblEntry *child_rte = root->simple_rte_array[child_rt_index]; set_rel_pathlist(root, child_rel, child_rt_index, child_rte); /* * If child is dummy, ignore it. */ if (IS_DUMMY_REL(child_rel)) continue; /* * Child is live, so add it to the live_childrels list for use below. */ live_childrels = lappend(live_childrels, child_rel); /* If consider startup costs on chunks because we can apply SkipScan, should also consider * startup costs on a hypertable */ if (child_rel->consider_startup) parent_rel->consider_startup = true; } /* Add paths to the append relation. */ add_paths_to_append_rel(root, parent_rel, live_childrels); } /* based on the function in allpaths.c, with the irrelevant branches removed */ static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) { if (IS_DUMMY_REL(rel)) { /* We already proved the relation empty, so nothing more to do */ } else { Assert(!rte->inh); switch (rel->rtekind) { case RTE_RELATION: if (rte->relkind == RELKIND_FOREIGN_TABLE) { /* Foreign table */ set_foreign_pathlist(root, rel, rte); } else if (rte->tablesample != NULL) { /* Sampled relation */ set_tablesample_rel_pathlist(root, rel, rte); } else { /* Plain relation */ set_plain_rel_pathlist(root, rel, rte); } break; case RTE_SUBQUERY: case RTE_FUNCTION: case RTE_TABLEFUNC: case RTE_VALUES: case RTE_CTE: case RTE_NAMEDTUPLESTORE: case RTE_RESULT: default: elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind); break; } } /* * Allow a plugin to editorialize on the set of Paths for this base * relation. It could add new paths (such as CustomPaths) by calling * add_path(), or add_partial_path() if parallel aware. It could also * delete or modify paths added by the core code. */ if (set_rel_pathlist_hook) (*set_rel_pathlist_hook)(root, rel, rti, rte); /* * If this is a baserel, we should normally consider gathering any partial * paths we may have created for it. We have to do this after calling the * set_rel_pathlist_hook, else it cannot add partial paths to be included * here. * * However, if this is an inheritance child, skip it. Otherwise, we could * end up with a very large number of gather nodes, each trying to grab * its own pool of workers. Instead, we'll consider gathering partial * paths for the parent appendrel. * * Also, if this is the topmost scan/join rel (that is, the only baserel), * we postpone gathering until the final scan/join targetlist is available * (see grouping_planner). */ if (rel->reloptkind == RELOPT_BASEREL && bms_membership(root->all_baserels) != BMS_SINGLETON) generate_gather_paths(root, rel, false); /* Now find the cheapest of the paths for this rel */ set_cheapest(rel); #ifdef OPTIMIZER_DEBUG debug_print_rel(root, rel); #endif } /* * set_dummy_rel_pathlist, copied from allpaths.c. * * This was a public function prior to PG12. */ static void set_dummy_rel_pathlist(RelOptInfo *rel) { /* Set dummy size estimates --- we leave attr_widths[] as zeroes */ rel->rows = 0; rel->reltarget->width = 0; /* Discard any pre-existing paths; no further need for them */ rel->pathlist = NIL; rel->partial_pathlist = NIL; /* Set up the dummy path */ add_path(rel, (Path *) create_append_path(NULL, rel, NIL, NIL, NIL, rel->lateral_relids, 0, false, -1)); /* * We set the cheapest-path fields immediately, just in case they were * pointing at some discarded path. This is redundant when we're called * from set_rel_size(), but not when called from elsewhere, and doing it * twice is harmless anyway. */ set_cheapest(rel); } /* copied from allpaths.c */ static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { /* * The flag has previously been initialized to false, so we can just * return if it becomes clear that we can't safely set it. */ Assert(!rel->consider_parallel); /* Don't call this if parallelism is disallowed for the entire query. */ Assert(root->glob->parallelModeOK); /* This should only be called for baserels and appendrel children. */ Assert(IS_SIMPLE_REL(rel)); /* Assorted checks based on rtekind. */ switch (rte->rtekind) { case RTE_RELATION: /* * Currently, parallel workers can't access the leader's temporary * tables. We could possibly relax this if the wrote all of its * local buffers at the start of the query and made no changes * thereafter (maybe we could allow hint bit changes), and if we * taught the workers to read them. Writing a large number of * temporary buffers could be expensive, though, and we don't have * the rest of the necessary infrastructure right now anyway. So * for now, bail out if we see a temporary table. */ if (get_rel_persistence(rte->relid) == RELPERSISTENCE_TEMP) return; /* * Table sampling can be pushed down to workers if the sample * function and its arguments are safe. */ if (rte->tablesample != NULL) { char proparallel = func_parallel(rte->tablesample->tsmhandler); if (proparallel != PROPARALLEL_SAFE) return; if (!is_parallel_safe(root, (Node *) rte->tablesample->args)) return; } /* * Ask FDWs whether they can support performing a ForeignScan * within a worker. Most often, the answer will be no. For * example, if the nature of the FDW is such that it opens a TCP * connection with a remote server, each parallel worker would end * up with a separate connection, and these connections might not * be appropriately coordinated between workers and the leader. */ if (rte->relkind == RELKIND_FOREIGN_TABLE) { Assert(rel->fdwroutine); if (!rel->fdwroutine->IsForeignScanParallelSafe) return; if (!rel->fdwroutine->IsForeignScanParallelSafe(root, rel, rte)) return; } /* * There are additional considerations for appendrels, which we'll * deal with in set_append_rel_size and set_append_rel_pathlist. * For now, just set consider_parallel based on the rel's own * quals and targetlist. */ break; case RTE_SUBQUERY: /* * There's no intrinsic problem with scanning a subquery-in-FROM * (as distinct from a SubPlan or InitPlan) in a parallel worker. * If the subquery doesn't happen to have any parallel-safe paths, * then flagging it as consider_parallel won't change anything, * but that's true for plain tables, too. We must set * consider_parallel based on the rel's own quals and targetlist, * so that if a subquery path is parallel-safe but the quals and * projection we're sticking onto it are not, we correctly mark * the SubqueryScanPath as not parallel-safe. (Note that * set_subquery_pathlist() might push some of these quals down * into the subquery itself, but that doesn't change anything.) * * We can't push sub-select containing LIMIT/OFFSET to workers as * there is no guarantee that the row order will be fully * deterministic, and applying LIMIT/OFFSET will lead to * inconsistent results at the top-level. (In some cases, where * the result is ordered, we could relax this restriction. But it * doesn't currently seem worth expending extra effort to do so.) */ { Query *subquery = castNode(Query, rte->subquery); if (limit_needed(subquery)) return; } break; case RTE_JOIN: /* Shouldn't happen; we're only considering baserels here. */ Assert(false); return; case RTE_FUNCTION: /* Check for parallel-restricted functions. */ if (!is_parallel_safe(root, (Node *) rte->functions)) return; break; case RTE_TABLEFUNC: /* not parallel safe */ return; case RTE_VALUES: /* Check for parallel-restricted functions. */ if (!is_parallel_safe(root, (Node *) rte->values_lists)) return; break; case RTE_CTE: /* * CTE tuplestores aren't shared among parallel workers, so we * force all CTE scans to happen in the leader. Also, populating * the CTE would require executing a subplan that's not available * in the worker, might be parallel-restricted, and must get * executed only once. */ return; case RTE_NAMEDTUPLESTORE: /* * tuplestore cannot be shared, at least without more * infrastructure to support that. */ return; case RTE_RESULT: /* RESULT RTEs, in themselves, are no problem. */ break; #if PG18_GE case RTE_GROUP: /* Shouldn't happen; we're only considering baserels here. */ Assert(false); return; #endif } /* * If there's anything in baserestrictinfo that's parallel-restricted, we * give up on parallelizing access to this relation. We could consider * instead postponing application of the restricted quals until we're * above all the parallelism in the plan tree, but it's not clear that * that would be a win in very many cases, and it might be tricky to make * outer join clauses work correctly. It would likely break equivalence * classes, too. */ if (!is_parallel_safe(root, (Node *) rel->baserestrictinfo)) return; /* * Likewise, if the relation's outputs are not parallel-safe, give up. * (Usually, they're just Vars, but sometimes they're not.) */ if (!is_parallel_safe(root, (Node *) rel->reltarget->exprs)) return; /* We have a winner. */ rel->consider_parallel = true; } /* copied from allpaths.c */ static void ts_set_append_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) { int parentRTindex = rti; bool has_live_children; double parent_rows; double parent_size; double *parent_attrsizes; int nattrs; ListCell *l; /* Guard against stack overflow due to overly deep inheritance tree. */ check_stack_depth(); Assert(IS_SIMPLE_REL(rel)); /* * If this is a partitioned baserel, set the consider_partitionwise_join * flag; currently, we only consider partitionwise joins with the baserel * if its targetlist doesn't contain a whole-row Var. */ if (enable_partitionwise_join && rel->reloptkind == RELOPT_BASEREL && rte->relkind == RELKIND_PARTITIONED_TABLE && rel->attr_needed[InvalidAttrNumber - rel->min_attr] == NULL) rel->consider_partitionwise_join = true; /* * Initialize to compute size estimates for whole append relation. * * We handle width estimates by weighting the widths of different child * rels proportionally to their number of rows. This is sensible because * the use of width estimates is mainly to compute the total relation * "footprint" if we have to sort or hash it. To do this, we sum the * total equivalent size (in "double" arithmetic) and then divide by the * total rowcount estimate. This is done separately for the total rel * width and each attribute. * * Note: if you consider changing this logic, beware that child rels could * have zero rows and/or width, if they were excluded by constraints. */ has_live_children = false; parent_rows = 0; parent_size = 0; nattrs = rel->max_attr - rel->min_attr + 1; parent_attrsizes = (double *) palloc0(nattrs * sizeof(double)); foreach (l, root->append_rel_list) { AppendRelInfo *appinfo = (AppendRelInfo *) lfirst(l); int childRTindex; RangeTblEntry *childRTE; RelOptInfo *childrel; ListCell *parentvars; ListCell *childvars; /* append_rel_list contains all append rels; ignore others */ if (appinfo->parent_relid != (Index) parentRTindex) continue; childRTindex = appinfo->child_relid; childRTE = root->simple_rte_array[childRTindex]; /* * The child rel's RelOptInfo was already created during * add_other_rels_to_query. */ childrel = find_base_rel(root, childRTindex); Assert(childrel->reloptkind == RELOPT_OTHER_MEMBER_REL); /* We may have already proven the child to be dummy. */ if (IS_DUMMY_REL(childrel)) continue; /* * We have to copy the parent's targetlist and quals to the child, * with appropriate substitution of variables. However, the * baserestrictinfo quals were already copied/substituted when the * child RelOptInfo was built. So we don't need any additional setup * before applying constraint exclusion. */ if (relation_excluded_by_constraints(root, childrel, childRTE)) { /* * This child need not be scanned, so we can omit it from the * appendrel. */ set_dummy_rel_pathlist(childrel); continue; } /* * Constraint exclusion failed, so copy the parent's join quals and * targetlist to the child, with appropriate variable substitutions. * * NB: the resulting childrel->reltarget->exprs may contain arbitrary * expressions, which otherwise would not occur in a rel's targetlist. * Code that might be looking at an appendrel child must cope with * such. (Normally, a rel's targetlist would only include Vars and * PlaceHolderVars.) XXX we do not bother to update the cost or width * fields of childrel->reltarget; not clear if that would be useful. */ childrel->joininfo = (List *) adjust_appendrel_attrs(root, (Node *) rel->joininfo, 1, &appinfo); childrel->reltarget->exprs = (List *) adjust_appendrel_attrs(root, (Node *) rel->reltarget->exprs, 1, &appinfo); /* * We have to make child entries in the EquivalenceClass data * structures as well. This is needed either if the parent * participates in some eclass joins (because we will want to consider * inner-indexscan joins on the individual children) or if the parent * has useful pathkeys (because we should try to build MergeAppend * paths that produce those sort orderings). */ if (rel->has_eclass_joins || has_useful_pathkeys(root, rel)) add_child_rel_equivalences(root, appinfo, rel, childrel); childrel->has_eclass_joins = rel->has_eclass_joins; /* * Note: we could compute appropriate attr_needed data for the child's * variables, by transforming the parent's attr_needed through the * translated_vars mapping. However, currently there's no need * because attr_needed is only examined for base relations not * otherrels. So we just leave the child's attr_needed empty. */ /* * If we consider partitionwise joins with the parent rel, do the same * for partitioned child rels. * * Note: here we abuse the consider_partitionwise_join flag by setting * it for child rels that are not themselves partitioned. We do so to * tell try_partitionwise_join() that the child rel is sufficiently * valid to be used as a per-partition input, even if it later gets * proven to be dummy. (It's not usable until we've set up the * reltarget and EC entries, which we just did.) */ if (rel->consider_partitionwise_join) childrel->consider_partitionwise_join = true; /* * If parallelism is allowable for this query in general, see whether * it's allowable for this childrel in particular. But if we've * already decided the appendrel is not parallel-safe as a whole, * there's no point in considering parallelism for this child. For * consistency, do this before calling set_rel_size() for the child. */ if (root->glob->parallelModeOK && rel->consider_parallel) set_rel_consider_parallel(root, childrel, childRTE); /* * Compute the child's size. */ ts_set_rel_size(root, childrel, childRTindex, childRTE); /* * It is possible that constraint exclusion detected a contradiction * within a child subquery, even though we didn't prove one above. If * so, we can skip this child. */ if (IS_DUMMY_REL(childrel)) continue; /* We have at least one live child. */ has_live_children = true; /* * If any live child is not parallel-safe, treat the whole appendrel * as not parallel-safe. In future we might be able to generate plans * in which some children are farmed out to workers while others are * not; but we don't have that today, so it's a waste to consider * partial paths anywhere in the appendrel unless it's all safe. * (Child rels visited before this one will be unmarked in * set_append_rel_pathlist().) */ if (!childrel->consider_parallel) rel->consider_parallel = false; /* * Accumulate size information from each live child. */ Assert(childrel->rows > 0); parent_rows += childrel->rows; parent_size += childrel->reltarget->width * childrel->rows; /* * Accumulate per-column estimates too. We need not do anything for * PlaceHolderVars in the parent list. If child expression isn't a * Var, or we didn't record a width estimate for it, we have to fall * back on a datatype-based estimate. * * By construction, child's targetlist is 1-to-1 with parent's. */ forboth (parentvars, rel->reltarget->exprs, childvars, childrel->reltarget->exprs) { Var *parentvar = (Var *) lfirst(parentvars); Node *childvar = (Node *) lfirst(childvars); if (IsA(parentvar, Var)) { int pndx = parentvar->varattno - rel->min_attr; int32 child_width = 0; if (IsA(childvar, Var) && (Index) ((Var *) childvar)->varno == childrel->relid) { int cndx = ((Var *) childvar)->varattno - childrel->min_attr; child_width = childrel->attr_widths[cndx]; } if (child_width <= 0) child_width = get_typavgwidth(exprType(childvar), exprTypmod(childvar)); Assert(child_width > 0); parent_attrsizes[pndx] += child_width * childrel->rows; } } } if (has_live_children) { /* * Save the finished size estimates. */ int i; Assert(parent_rows > 0); rel->rows = parent_rows; rel->reltarget->width = rint(parent_size / parent_rows); for (i = 0; i < nattrs; i++) rel->attr_widths[i] = rint(parent_attrsizes[i] / parent_rows); /* * Set "raw tuples" count equal to "rows" for the appendrel; needed * because some places assume rel->tuples is valid for any baserel. */ rel->tuples = parent_rows; /* * Note that we leave rel->pages as zero; this is important to avoid * double-counting the appendrel tree in total_table_pages. */ } else { /* * All children were excluded by constraints, so mark the whole * appendrel dummy. We must do this in this phase so that the rel's * dummy-ness is visible when we generate paths for other rels. */ set_dummy_rel_pathlist(rel); } pfree(parent_attrsizes); } /* copied from allpaths.c */ static void set_foreign_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { /* Mark rel with estimated output rows, width, etc */ set_foreign_size_estimates(root, rel); /* Let FDW adjust the size estimates, if it can */ rel->fdwroutine->GetForeignRelSize(root, rel, rte->relid); /* ... but do not let it set the rows estimate to zero */ rel->rows = clamp_row_est(rel->rows); } /* copied from allpaths.c */ static void set_tablesample_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { TableSampleClause *tsc = rte->tablesample; TsmRoutine *tsm; BlockNumber pages; double tuples; /* * Test any partial indexes of rel for applicability. We must do this * first since partial unique indexes can affect size estimates. */ check_index_predicates(root, rel); /* * Call the sampling method's estimation function to estimate the number * of pages it will read and the number of tuples it will return. (Note: * we assume the function returns sane values.) */ tsm = GetTsmRoutine(tsc->tsmhandler); tsm->SampleScanGetSampleSize(root, rel, tsc->args, &pages, &tuples); /* * For the moment, because we will only consider a SampleScan path for the * rel, it's okay to just overwrite the pages and tuples estimates for the * whole relation. If we ever consider multiple path types for sampled * rels, we'll need more complication. */ rel->pages = pages; rel->tuples = tuples; /* Mark rel with estimated output rows, width, etc */ set_baserel_size_estimates(root, rel); } /* copied from allpaths.c */ static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { /* * Test any partial indexes of rel for applicability. We must do this * first since partial unique indexes can affect size estimates. */ check_index_predicates(root, rel); /* Mark rel with estimated output rows, width, etc */ set_baserel_size_estimates(root, rel); } /* extracted from the same function in allpaths.c * assumes that the root table is either excluded by constraints, or is an * inheritance base table, and that chunks are regular tables */ void ts_set_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) { if (rel->reloptkind == RELOPT_BASEREL && relation_excluded_by_constraints(root, rel, rte)) { /* * We proved we don't need to scan the rel via constraint exclusion, * so set up a single dummy path for it. Here we only check this for * regular baserels; if it's an otherrel, CE was already checked in * set_append_rel_size(). * * In this case, we go ahead and set up the relation's path right away * instead of leaving it for set_rel_pathlist to do. This is because * we don't have a convention for marking a rel as dummy except by * assigning a dummy path to it. */ set_dummy_rel_pathlist(rel); } else if (rte->inh) { /* It's an "append relation", process accordingly */ ts_set_append_rel_size(root, rel, rti, rte); } else { switch (rel->rtekind) { case RTE_RELATION: if (rte->relkind == RELKIND_FOREIGN_TABLE) { /* Foreign table */ set_foreign_size(root, rel, rte); } else if (rte->relkind == RELKIND_PARTITIONED_TABLE) { /* * We could get here if asked to scan a partitioned table * with ONLY. In that case we shouldn't scan any of the * partitions, so mark it as a dummy rel. */ set_dummy_rel_pathlist(rel); } else if (rte->tablesample != NULL) { /* Sampled relation */ set_tablesample_rel_size(root, rel, rte); } else { /* Plain relation */ set_plain_rel_size(root, rel, rte); } break; case RTE_SUBQUERY: case RTE_FUNCTION: case RTE_TABLEFUNC: case RTE_VALUES: case RTE_CTE: case RTE_NAMEDTUPLESTORE: case RTE_RESULT: default: elog(ERROR, "unexpected rtekind: %d", (int) rel->rtekind); break; } } /* * We insist that all non-dummy rels have a nonzero rowcount estimate. */ Assert(rel->rows > 0 || IS_DUMMY_REL(rel)); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/allpaths.h������������������������������������������������������������0000664�0000000�0000000�00000001005�15100345067�0020131�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pathnodes.h> #include "export.h" extern void ts_set_rel_size(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte); extern void ts_set_append_rel_pathlist(PlannerInfo *root, RelOptInfo *parent_rel, Index parent_rt_index, RangeTblEntry *parent_rte); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/heapswap.c������������������������������������������������������������0000664�0000000�0000000�00000054765�15100345067�0020151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ #include <postgres.h> #include <access/htup.h> #include <access/multixact.h> #include <access/relation.h> #include <access/table.h> #include <access/toast_internals.h> #include <access/xact.h> #include <catalog/catalog.h> #include <catalog/dependency.h> #include <catalog/heap.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/objectaccess.h> #include <catalog/pg_am.h> #include <catalog/pg_class.h> #include <commands/defrem.h> #include <commands/progress.h> #include <commands/tablecmds.h> #include <executor/spi.h> #include <nodes/makefuncs.h> #include <nodes/value.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <utils/backend_progress.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/relcache.h> #include <utils/relmapper.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include "compat/compat.h" #include "heapswap.h" #if PG16_LT typedef Oid RelFileNumber; #define RelFileNumberIsValid OidIsValid #define RelationMapOidToFilenumber RelationMapOidToFilenode #define rd_newRelfilelocatorSubid rd_newRelfilenodeSubid #define rd_firstRelfilelocatorSubid rd_firstRelfilenodeSubid #define RelationAssumeNewRelfilelocator RelationAssumeNewRelfilenode #endif /** * The code in this file is imported from PostgreSQL and slightly modified to: * * 1. Make swap_relation_files() a public function. * 2. Optionally build indexes in finish_heap_swap(). * * The above changes are needed to decouple index building from heap swaps, needed for reorder and * merge chunks. */ /* * Swap the physical files of two given relations. * * We swap the physical identity (reltablespace, relfilenumber) while keeping * the same logical identities of the two relations. relpersistence is also * swapped, which is critical since it determines where buffers live for each * relation. * * We can swap associated TOAST data in either of two ways: recursively swap * the physical content of the toast tables (and their indexes), or swap the * TOAST links in the given relations' pg_class entries. The former is needed * to manage rewrites of shared catalogs (where we cannot change the pg_class * links) while the latter is the only way to handle cases in which a toast * table is added or removed altogether. * * Additionally, the first relation is marked with relfrozenxid set to * frozenXid. It seems a bit ugly to have this here, but the caller would * have to do it anyway, so having it here saves a heap_update. Note: in * the swap-toast-links case, we assume we don't need to change the toast * table's relfrozenxid: the new version of the toast table should already * have relfrozenxid set to RecentXmin, which is good enough. * * Lastly, if r2 and its toast table and toast index (if any) are mapped, * their OIDs are emitted into mapped_tables[]. This is hacky but beats * having to look the information up again later in finish_heap_swap. */ void ts_swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class, bool swap_toast_by_content, bool is_internal, TransactionId frozenXid, MultiXactId cutoffMulti, Oid *mapped_tables) { Relation relRelation; HeapTuple reltup1, reltup2; Form_pg_class relform1, relform2; RelFileNumber relfilenumber1, relfilenumber2; RelFileNumber swaptemp; char swptmpchr; Oid relam1, relam2; /* We need writable copies of both pg_class tuples. */ relRelation = table_open(RelationRelationId, RowExclusiveLock); reltup1 = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(r1)); if (!HeapTupleIsValid(reltup1)) elog(ERROR, "cache lookup failed for relation %u", r1); relform1 = (Form_pg_class) GETSTRUCT(reltup1); reltup2 = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(r2)); if (!HeapTupleIsValid(reltup2)) elog(ERROR, "cache lookup failed for relation %u", r2); relform2 = (Form_pg_class) GETSTRUCT(reltup2); relfilenumber1 = relform1->relfilenode; relfilenumber2 = relform2->relfilenode; relam1 = relform1->relam; relam2 = relform2->relam; if (RelFileNumberIsValid(relfilenumber1) && RelFileNumberIsValid(relfilenumber2)) { /* * Normal non-mapped relations: swap relfilenumbers, reltablespaces, * relpersistence */ Assert(!target_is_pg_class); swaptemp = relform1->relfilenode; relform1->relfilenode = relform2->relfilenode; relform2->relfilenode = swaptemp; swaptemp = relform1->reltablespace; relform1->reltablespace = relform2->reltablespace; relform2->reltablespace = swaptemp; swaptemp = relform1->relam; relform1->relam = relform2->relam; relform2->relam = swaptemp; swptmpchr = relform1->relpersistence; relform1->relpersistence = relform2->relpersistence; relform2->relpersistence = swptmpchr; /* Also swap toast links, if we're swapping by links */ if (!swap_toast_by_content) { swaptemp = relform1->reltoastrelid; relform1->reltoastrelid = relform2->reltoastrelid; relform2->reltoastrelid = swaptemp; } } else { /* * Mapped-relation case. Here we have to swap the relation mappings * instead of modifying the pg_class columns. Both must be mapped. */ if (RelFileNumberIsValid(relfilenumber1) || RelFileNumberIsValid(relfilenumber2)) elog(ERROR, "cannot swap mapped relation \"%s\" with non-mapped relation", NameStr(relform1->relname)); /* * We can't change the tablespace nor persistence of a mapped rel, and * we can't handle toast link swapping for one either, because we must * not apply any critical changes to its pg_class row. These cases * should be prevented by upstream permissions tests, so these checks * are non-user-facing emergency backstop. */ if (relform1->reltablespace != relform2->reltablespace) elog(ERROR, "cannot change tablespace of mapped relation \"%s\"", NameStr(relform1->relname)); if (relform1->relpersistence != relform2->relpersistence) elog(ERROR, "cannot change persistence of mapped relation \"%s\"", NameStr(relform1->relname)); if (relform1->relam != relform2->relam) elog(ERROR, "cannot change access method of mapped relation \"%s\"", NameStr(relform1->relname)); if (!swap_toast_by_content && (relform1->reltoastrelid || relform2->reltoastrelid)) elog(ERROR, "cannot swap toast by links for mapped relation \"%s\"", NameStr(relform1->relname)); /* * Fetch the mappings --- shouldn't fail, but be paranoid */ relfilenumber1 = RelationMapOidToFilenumber(r1, relform1->relisshared); if (!RelFileNumberIsValid(relfilenumber1)) elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u", NameStr(relform1->relname), r1); relfilenumber2 = RelationMapOidToFilenumber(r2, relform2->relisshared); if (!RelFileNumberIsValid(relfilenumber2)) elog(ERROR, "could not find relation mapping for relation \"%s\", OID %u", NameStr(relform2->relname), r2); /* * Send replacement mappings to relmapper. Note these won't actually * take effect until CommandCounterIncrement. */ RelationMapUpdateMap(r1, relfilenumber2, relform1->relisshared, false); RelationMapUpdateMap(r2, relfilenumber1, relform2->relisshared, false); /* Pass OIDs of mapped r2 tables back to caller */ *mapped_tables++ = r2; } /* * Recognize that rel1's relfilenumber (swapped from rel2) is new in this * subtransaction. The rel2 storage (swapped from rel1) may or may not be * new. */ { Relation rel1, rel2; rel1 = relation_open(r1, NoLock); rel2 = relation_open(r2, NoLock); rel2->rd_createSubid = rel1->rd_createSubid; rel2->rd_newRelfilelocatorSubid = rel1->rd_newRelfilelocatorSubid; rel2->rd_firstRelfilelocatorSubid = rel1->rd_firstRelfilelocatorSubid; RelationAssumeNewRelfilelocator(rel1); relation_close(rel1, NoLock); relation_close(rel2, NoLock); } /* * In the case of a shared catalog, these next few steps will only affect * our own database's pg_class row; but that's okay, because they are all * noncritical updates. That's also an important fact for the case of a * mapped catalog, because it's possible that we'll commit the map change * and then fail to commit the pg_class update. */ /* set rel1's frozen Xid and minimum MultiXid */ if (relform1->relkind != RELKIND_INDEX) { Assert(!TransactionIdIsValid(frozenXid) || TransactionIdIsNormal(frozenXid)); relform1->relfrozenxid = frozenXid; relform1->relminmxid = cutoffMulti; } /* swap size statistics too, since new rel has freshly-updated stats */ { int32 swap_pages; float4 swap_tuples; int32 swap_allvisible; swap_pages = relform1->relpages; relform1->relpages = relform2->relpages; relform2->relpages = swap_pages; swap_tuples = relform1->reltuples; relform1->reltuples = relform2->reltuples; relform2->reltuples = swap_tuples; swap_allvisible = relform1->relallvisible; relform1->relallvisible = relform2->relallvisible; relform2->relallvisible = swap_allvisible; } /* * Update the tuples in pg_class --- unless the target relation of the * swap is pg_class itself. In that case, there is zero point in making * changes because we'd be updating the old data that we're about to throw * away. Because the real work being done here for a mapped relation is * just to change the relation map settings, it's all right to not update * the pg_class rows in this case. The most important changes will instead * performed later, in finish_heap_swap() itself. */ if (!target_is_pg_class) { CatalogIndexState indstate; indstate = CatalogOpenIndexes(relRelation); CatalogTupleUpdateWithInfo(relRelation, &reltup1->t_self, reltup1, indstate); CatalogTupleUpdateWithInfo(relRelation, &reltup2->t_self, reltup2, indstate); CatalogCloseIndexes(indstate); } else { /* no update ... but we do still need relcache inval */ CacheInvalidateRelcacheByTuple(reltup1); CacheInvalidateRelcacheByTuple(reltup2); } /* * Now that pg_class has been updated with its relevant information for * the swap, update the dependency of the relations to point to their new * table AM, if it has changed. */ if (relam1 != relam2) { if (changeDependencyFor(RelationRelationId, r1, AccessMethodRelationId, relam1, relam2) != 1) elog(ERROR, "could not change access method dependency for relation \"%s.%s\"", get_namespace_name(get_rel_namespace(r1)), get_rel_name(r1)); if (changeDependencyFor(RelationRelationId, r2, AccessMethodRelationId, relam2, relam1) != 1) elog(ERROR, "could not change access method dependency for relation \"%s.%s\"", get_namespace_name(get_rel_namespace(r2)), get_rel_name(r2)); } /* * Post alter hook for modified relations. The change to r2 is always * internal, but r1 depends on the invocation context. */ InvokeObjectPostAlterHookArg(RelationRelationId, r1, 0, InvalidOid, is_internal); InvokeObjectPostAlterHookArg(RelationRelationId, r2, 0, InvalidOid, true); /* * If we have toast tables associated with the relations being swapped, * deal with them too. */ if (relform1->reltoastrelid || relform2->reltoastrelid) { if (swap_toast_by_content) { if (relform1->reltoastrelid && relform2->reltoastrelid) { /* Recursively swap the contents of the toast tables */ ts_swap_relation_files(relform1->reltoastrelid, relform2->reltoastrelid, target_is_pg_class, swap_toast_by_content, is_internal, frozenXid, cutoffMulti, mapped_tables); } else { /* caller messed up */ elog(ERROR, "cannot swap toast files by content when there's only one"); } } else { /* * We swapped the ownership links, so we need to change dependency * data to match. * * NOTE: it is possible that only one table has a toast table. * * NOTE: at present, a TOAST table's only dependency is the one on * its owning table. If more are ever created, we'd need to use * something more selective than deleteDependencyRecordsFor() to * get rid of just the link we want. */ ObjectAddress baseobject, toastobject; long count; /* * We disallow this case for system catalogs, to avoid the * possibility that the catalog we're rebuilding is one of the * ones the dependency changes would change. It's too late to be * making any data changes to the target catalog. */ if (IsSystemClass(r1, relform1)) elog(ERROR, "cannot swap toast files by links for system catalogs"); /* Delete old dependencies */ if (relform1->reltoastrelid) { count = deleteDependencyRecordsFor(RelationRelationId, relform1->reltoastrelid, false); if (count != 1) elog(ERROR, "expected one dependency record for TOAST table, found %ld", count); } if (relform2->reltoastrelid) { count = deleteDependencyRecordsFor(RelationRelationId, relform2->reltoastrelid, false); if (count != 1) elog(ERROR, "expected one dependency record for TOAST table, found %ld", count); } /* Register new dependencies */ baseobject.classId = RelationRelationId; baseobject.objectSubId = 0; toastobject.classId = RelationRelationId; toastobject.objectSubId = 0; if (relform1->reltoastrelid) { baseobject.objectId = r1; toastobject.objectId = relform1->reltoastrelid; recordDependencyOn(&toastobject, &baseobject, DEPENDENCY_INTERNAL); } if (relform2->reltoastrelid) { baseobject.objectId = r2; toastobject.objectId = relform2->reltoastrelid; recordDependencyOn(&toastobject, &baseobject, DEPENDENCY_INTERNAL); } } } /* * If we're swapping two toast tables by content, do the same for their * valid index. The swap can actually be safely done only if the relations * have indexes. */ if (swap_toast_by_content && relform1->relkind == RELKIND_TOASTVALUE && relform2->relkind == RELKIND_TOASTVALUE) { Oid toastIndex1, toastIndex2; /* Get valid index for each relation */ toastIndex1 = toast_get_valid_index(r1, AccessExclusiveLock); toastIndex2 = toast_get_valid_index(r2, AccessExclusiveLock); ts_swap_relation_files(toastIndex1, toastIndex2, target_is_pg_class, swap_toast_by_content, is_internal, InvalidTransactionId, InvalidMultiXactId, mapped_tables); } /* Clean up. */ heap_freetuple(reltup1); heap_freetuple(reltup2); table_close(relRelation, RowExclusiveLock); /* * Close both relcache entries' smgr links. We need this kludge because * both links will be invalidated during upcoming CommandCounterIncrement. * Whichever of the rels is the second to be cleared will have a dangling * reference to the other's smgr entry. Rather than trying to avoid this * by ordering operations just so, it's easiest to close the links first. * (Fortunately, since one of the entries is local in our transaction, * it's sufficient to clear out our own relcache this way; the problem * cannot arise for other backends when they see our update on the * non-transient relation.) * * Caution: the placement of this step interacts with the decision to * handle toast rels by recursion. When we are trying to rebuild pg_class * itself, the smgr close on pg_class must happen after all accesses in * this function. */ #if PG17_LT /* Not needed as of 21d9c3ee4ef7 in the upstream */ RelationCloseSmgrByOid(r1); RelationCloseSmgrByOid(r2); #endif } /* * Remove the transient table that was built by make_new_heap, and finish * cleaning up (including rebuilding all indexes on the old heap). */ void ts_finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap, bool is_system_catalog, bool swap_toast_by_content, bool check_constraints, bool is_internal, bool reindex, TransactionId frozenXid, MultiXactId cutoffMulti, char newrelpersistence) { ObjectAddress object; Oid mapped_tables[4]; int i; /* Report that we are now swapping relation files */ pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE, PROGRESS_CLUSTER_PHASE_SWAP_REL_FILES); /* Zero out possible results from swapped_relation_files */ memset(mapped_tables, 0, sizeof(mapped_tables)); /* * Swap the contents of the heap relations (including any toast tables). * Also set old heap's relfrozenxid to frozenXid. */ ts_swap_relation_files(OIDOldHeap, OIDNewHeap, (OIDOldHeap == RelationRelationId), swap_toast_by_content, is_internal, frozenXid, cutoffMulti, mapped_tables); /* * If it's a system catalog, queue a sinval message to flush all catcaches * on the catalog when we reach CommandCounterIncrement. */ if (is_system_catalog) CacheInvalidateCatalog(OIDOldHeap); if (reindex) { int reindex_flags; ReindexParams reindex_params = { 0 }; /* * Rebuild each index on the relation (but not the toast table, which * is all-new at this point). It is important to do this before the * DROP step because if we are processing a system catalog that will * be used during DROP, we want to have its indexes available. There * is no advantage to the other order anyway because this is all * transactional, so no chance to reclaim disk space before commit. We * do not need a final CommandCounterIncrement() because * reindex_relation does it. * * Note: because index_build is called via reindex_relation, it will * never set indcheckxmin true for the indexes. This is OK even * though in some sense we are building new indexes rather than * rebuilding existing ones, because the new heap won't contain any * HOT chains at all, let alone broken ones, so it can't be necessary * to set indcheckxmin. */ reindex_flags = REINDEX_REL_SUPPRESS_INDEX_USE; if (check_constraints) reindex_flags |= REINDEX_REL_CHECK_CONSTRAINTS; /* * Ensure that the indexes have the same persistence as the parent * relation. */ if (newrelpersistence == RELPERSISTENCE_UNLOGGED) reindex_flags |= REINDEX_REL_FORCE_INDEXES_UNLOGGED; else if (newrelpersistence == RELPERSISTENCE_PERMANENT) reindex_flags |= REINDEX_REL_FORCE_INDEXES_PERMANENT; /* Report that we are now reindexing relations */ pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE, PROGRESS_CLUSTER_PHASE_REBUILD_INDEX); #if PG17_LT reindex_relation(OIDOldHeap, reindex_flags, &reindex_params); #else reindex_relation(NULL, OIDOldHeap, reindex_flags, &reindex_params); #endif } else { /* Must make changes visible after swap. Normally reindex does it * implicitly. */ CommandCounterIncrement(); } /* Report that we are now doing clean up */ pgstat_progress_update_param(PROGRESS_CLUSTER_PHASE, PROGRESS_CLUSTER_PHASE_FINAL_CLEANUP); /* * If the relation being rebuilt is pg_class, swap_relation_files() * couldn't update pg_class's own pg_class entry (check comments in * swap_relation_files()), thus relfrozenxid was not updated. That's * annoying because a potential reason for doing a VACUUM FULL is a * imminent or actual anti-wraparound shutdown. So, now that we can * access the new relation using its indices, update relfrozenxid. * pg_class doesn't have a toast relation, so we don't need to update the * corresponding toast relation. Not that there's little point moving all * relfrozenxid updates here since swap_relation_files() needs to write to * pg_class for non-mapped relations anyway. */ if (OIDOldHeap == RelationRelationId) { Relation relRelation; HeapTuple reltup; Form_pg_class relform; relRelation = table_open(RelationRelationId, RowExclusiveLock); reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDOldHeap)); if (!HeapTupleIsValid(reltup)) elog(ERROR, "cache lookup failed for relation %u", OIDOldHeap); relform = (Form_pg_class) GETSTRUCT(reltup); relform->relfrozenxid = frozenXid; relform->relminmxid = cutoffMulti; CatalogTupleUpdate(relRelation, &reltup->t_self, reltup); table_close(relRelation, RowExclusiveLock); } /* Destroy new heap with old filenumber */ object.classId = RelationRelationId; object.objectId = OIDNewHeap; object.objectSubId = 0; /* * The new relation is local to our transaction and we know nothing * depends on it, so DROP_RESTRICT should be OK. */ performDeletion(&object, DROP_RESTRICT, PERFORM_DELETION_INTERNAL); /* performDeletion does CommandCounterIncrement at end */ /* * Now we must remove any relation mapping entries that we set up for the * transient table, as well as its toast table and toast index if any. If * we fail to do this before commit, the relmapper will complain about new * permanent map entries being added post-bootstrap. */ for (i = 0; OidIsValid(mapped_tables[i]); i++) RelationMapRemoveMapping(mapped_tables[i]); /* * At this point, everything is kosher except that, if we did toast swap * by links, the toast table's name corresponds to the transient table. * The name is irrelevant to the backend because it's referenced by OID, * but users looking at the catalogs could be confused. Rename it to * prevent this problem. * * Note no lock required on the relation, because we already hold an * exclusive lock on it. */ if (!swap_toast_by_content) { Relation newrel; newrel = table_open(OIDOldHeap, NoLock); if (OidIsValid(newrel->rd_rel->reltoastrelid)) { Oid toastidx; char NewToastName[NAMEDATALEN]; /* Get the associated valid index to be renamed */ toastidx = toast_get_valid_index(newrel->rd_rel->reltoastrelid, NoLock); /* rename the toast table ... */ snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u", OIDOldHeap); RenameRelationInternal(newrel->rd_rel->reltoastrelid, NewToastName, true, false); /* ... and its valid index too. */ snprintf(NewToastName, NAMEDATALEN, "pg_toast_%u_index", OIDOldHeap); RenameRelationInternal(toastidx, NewToastName, true, true); /* * Reset the relrewrite for the toast. The command-counter * increment is required here as we are about to update the tuple * that is updated as part of RenameRelationInternal. */ CommandCounterIncrement(); ResetRelRewrite(newrel->rd_rel->reltoastrelid); } relation_close(newrel, NoLock); } /* if it's not a catalog table, clear any missing attribute settings */ if (!is_system_catalog) { Relation newrel; newrel = table_open(OIDOldHeap, NoLock); RelationClearMissing(newrel); relation_close(newrel, NoLock); } } �����������timescaledb-2.23.0/src/import/heapswap.h������������������������������������������������������������0000664�0000000�0000000�00000002110�15100345067�0020127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ #pragma once #include <postgres.h> #include <nodes/pg_list.h> #include <utils/rel.h> #include "export.h" extern TSDLLEXPORT void ts_finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap, bool is_system_catalog, bool swap_toast_by_content, bool check_constraints, bool is_internal, bool reindex, TransactionId frozenXid, MultiXactId cutoffMulti, char newrelpersistence); extern TSDLLEXPORT void ts_swap_relation_files(Oid r1, Oid r2, bool target_is_pg_class, bool swap_toast_by_content, bool is_internal, TransactionId frozenXid, MultiXactId cutoffMulti, Oid *mapped_tables); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/list.c����������������������������������������������������������������0000664�0000000�0000000�00000006276�15100345067�0017306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <nodes/pg_list.h> #include <port/pg_bitutils.h> #include "import/list.h" /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. * * Copied from PostgreSQL 15.0 (2a7ce2e2ce474504a707ec03e128fde66cfb8b48) * without modifications. */ /* Overhead for the fixed part of a List header, measured in ListCells */ #define LIST_HEADER_OVERHEAD \ ((int) (((offsetof(List, initial_elements) - 1) / sizeof(ListCell)) + 1)) /* * Return a freshly allocated List with room for at least min_size cells. * * Since empty non-NIL lists are invalid, new_list() sets the initial length * to min_size, effectively marking that number of cells as valid; the caller * is responsible for filling in their data. */ List * ts_new_list(NodeTag type, int min_size) { List *newlist; int max_size; Assert(min_size > 0); /* * We allocate all the requested cells, and possibly some more, as part of * the same palloc request as the List header. This is a big win for the * typical case of short fixed-length lists. It can lose if we allocate a * moderately long list and then it gets extended; we'll be wasting more * initial_elements[] space than if we'd made the header small. However, * rounding up the request as we do in the normal code path provides some * defense against small extensions. */ #ifndef DEBUG_LIST_MEMORY_USAGE /* * Normally, we set up a list with some extra cells, to allow it to grow * without a repalloc. Prefer cell counts chosen to make the total * allocation a power-of-2, since palloc would round it up to that anyway. * (That stops being true for very large allocations, but very long lists * are infrequent, so it doesn't seem worth special logic for such cases.) * * The minimum allocation is 8 ListCell units, providing either 4 or 5 * available ListCells depending on the machine's word width. Counting * palloc's overhead, this uses the same amount of space as a one-cell * list did in the old implementation, and less space for any longer list. * * We needn't worry about integer overflow; no caller passes min_size * that's more than twice the size of an existing list, so the size limits * within palloc will ensure that we don't overflow here. */ max_size = pg_nextpower2_32(Max(8, min_size + LIST_HEADER_OVERHEAD)); max_size -= LIST_HEADER_OVERHEAD; #else /* * For debugging, don't allow any extra space. This forces any cell * addition to go through enlarge_list() and thus move the existing data. */ max_size = min_size; #endif newlist = (List *) palloc(offsetof(List, initial_elements) + (max_size * sizeof(ListCell))); newlist->type = type; newlist->length = min_size; newlist->max_length = max_size; newlist->elements = newlist->initial_elements; return newlist; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/list.h����������������������������������������������������������������0000664�0000000�0000000�00000001046�15100345067�0017301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "export.h" /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ extern TSDLLEXPORT List *ts_new_list(NodeTag type, int min_size); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/planner.c�������������������������������������������������������������0000664�0000000�0000000�00000064450�15100345067�0017770�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. * * These function were copied from the PostgreSQL core planner, since * they were declared static in the core planner, but we need them for * our manipulations. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/pg_collation.h> #include <catalog/pg_statistic.h> #include <executor/nodeAgg.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/clauses.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/paramassign.h> #include <optimizer/paths.h> #include <optimizer/placeholder.h> #include <optimizer/planmain.h> #include <optimizer/planner.h> #include <optimizer/tlist.h> #include <parser/parsetree.h> #include <utils/datum.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/syscache.h> #include "compat/compat.h" #include "planner.h" static Node *replace_nestloop_params(PlannerInfo *root, Node *expr); static Node *replace_nestloop_params_mutator(Node *node, PlannerInfo *root); static Plan *inject_projection_plan(Plan *subplan, List *tlist, bool parallel_safe); /* copied verbatim from optimizer/util/appendinfo.c at REL_17_6 */ void ts_make_inh_translation_list(Relation oldrelation, Relation newrelation, Index newvarno, AppendRelInfo *appinfo) { List *vars = NIL; AttrNumber *pcolnos; TupleDesc old_tupdesc = RelationGetDescr(oldrelation); TupleDesc new_tupdesc = RelationGetDescr(newrelation); Oid new_relid = RelationGetRelid(newrelation); int oldnatts = old_tupdesc->natts; int newnatts = new_tupdesc->natts; int old_attno; int new_attno = 0; /* Initialize reverse-translation array with all entries zero */ appinfo->num_child_cols = newnatts; appinfo->parent_colnos = pcolnos = (AttrNumber *) palloc0(newnatts * sizeof(AttrNumber)); for (old_attno = 0; old_attno < oldnatts; old_attno++) { Form_pg_attribute att; char *attname; Oid atttypid; int32 atttypmod; Oid attcollation; att = TupleDescAttr(old_tupdesc, old_attno); if (att->attisdropped) { /* Just put NULL into this list entry */ vars = lappend(vars, NULL); continue; } attname = NameStr(att->attname); atttypid = att->atttypid; atttypmod = att->atttypmod; attcollation = att->attcollation; /* * When we are generating the "translation list" for the parent table * of an inheritance set, no need to search for matches. */ if (oldrelation == newrelation) { vars = lappend(vars, makeVar(newvarno, (AttrNumber) (old_attno + 1), atttypid, atttypmod, attcollation, 0)); pcolnos[old_attno] = old_attno + 1; continue; } /* * Otherwise we have to search for the matching column by name. * There's no guarantee it'll have the same column position, because * of cases like ALTER TABLE ADD COLUMN and multiple inheritance. * However, in simple cases, the relative order of columns is mostly * the same in both relations, so try the column of newrelation that * follows immediately after the one that we just found, and if that * fails, let syscache handle it. */ if (new_attno >= newnatts || (att = TupleDescAttr(new_tupdesc, new_attno))->attisdropped || strcmp(attname, NameStr(att->attname)) != 0) { HeapTuple newtup; newtup = SearchSysCacheAttName(new_relid, attname); if (!HeapTupleIsValid(newtup)) elog(ERROR, "could not find inherited attribute \"%s\" of relation \"%s\"", attname, RelationGetRelationName(newrelation)); new_attno = ((Form_pg_attribute) GETSTRUCT(newtup))->attnum - 1; Assert(new_attno >= 0 && new_attno < newnatts); ReleaseSysCache(newtup); att = TupleDescAttr(new_tupdesc, new_attno); } /* Found it, check type and collation match */ if (atttypid != att->atttypid || atttypmod != att->atttypmod) elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's type", attname, RelationGetRelationName(newrelation)); if (attcollation != att->attcollation) elog(ERROR, "attribute \"%s\" of relation \"%s\" does not match parent's collation", attname, RelationGetRelationName(newrelation)); vars = lappend(vars, makeVar(newvarno, (AttrNumber) (new_attno + 1), atttypid, atttypmod, attcollation, 0)); pcolnos[new_attno] = old_attno + 1; new_attno++; } appinfo->translated_vars = vars; } /* copied verbatim from planner.c */ struct PathTarget * ts_make_partial_grouping_target(struct PlannerInfo *root, PathTarget *grouping_target) { struct Query *parse = root->parse; PathTarget *partial_target; struct List *non_group_cols; struct List *non_group_exprs; int i; ListCell *lc; partial_target = create_empty_pathtarget(); non_group_cols = NIL; i = 0; foreach (lc, grouping_target->exprs) { struct Expr *expr = (struct Expr *) lfirst(lc); unsigned int sgref = get_pathtarget_sortgroupref(grouping_target, i); if (sgref && parse->groupClause && get_sortgroupref_clause_noerr(sgref, parse->groupClause) != NULL) { /* * It's a grouping column, so add it to the partial_target as-is. * (This allows the upper agg step to repeat the grouping calcs.) */ add_column_to_pathtarget(partial_target, expr, sgref); } else { /* * Non-grouping column, so just remember the expression for later * call to pull_var_clause. */ non_group_cols = lappend(non_group_cols, expr); } i++; } /* * If there's a HAVING clause, we'll need the Vars/Aggrefs it uses, too. */ if (parse->havingQual) non_group_cols = lappend(non_group_cols, parse->havingQual); /* * Pull out all the Vars, PlaceHolderVars, and Aggrefs mentioned in * non-group cols (plus HAVING), and add them to the partial_target if not * already present. (An expression used directly as a GROUP BY item will * be present already.) Note this includes Vars used in resjunk items, so * we are covering the needs of ORDER BY and window specifications. */ non_group_exprs = pull_var_clause((struct Node *) non_group_cols, PVC_INCLUDE_AGGREGATES | PVC_RECURSE_WINDOWFUNCS | PVC_INCLUDE_PLACEHOLDERS); add_new_columns_to_pathtarget(partial_target, non_group_exprs); /* * Adjust Aggrefs to put them in partial mode. At this point all Aggrefs * are at the top level of the target list, so we can just scan the list * rather than recursing through the expression trees. */ foreach (lc, partial_target->exprs) { struct Aggref *aggref = (struct Aggref *) lfirst(lc); if (IsA(aggref, Aggref)) { struct Aggref *newaggref; /* * We shouldn't need to copy the substructure of the Aggref node, * but flat-copy the node itself to avoid damaging other trees. */ newaggref = makeNode(Aggref); memcpy(newaggref, aggref, sizeof(struct Aggref)); /* For now, assume serialization is required */ mark_partial_aggref(newaggref, AGGSPLIT_INITIAL_SERIAL); lfirst(lc) = newaggref; } } /* clean up cruft */ list_free(non_group_exprs); list_free(non_group_cols); /* XXX this causes some redundant cost calculation ... */ return set_pathtarget_cost_width(root, partial_target); } /* copied verbatim from selfuncs.c */ bool ts_get_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, Datum *min, Datum *max) { Datum tmin = 0; Datum tmax = 0; bool have_data = false; int16 typLen; bool typByVal; Oid opfuncoid; AttStatsSlot sslot; int i; /* * XXX It's very tempting to try to use the actual column min and max, if * we can get them relatively-cheaply with an index probe. However, since * this function is called many times during join planning, that could * have unpleasant effects on planning speed. Need more investigation * before enabling this. */ #ifdef NOT_USED if (get_actual_variable_range(root, vardata, sortop, min, max)) return true; #endif if (!HeapTupleIsValid(vardata->statsTuple)) { /* no stats available, so default result */ return false; } /* * If we can't apply the sortop to the stats data, just fail. In * principle, if there's a histogram and no MCVs, we could return the * histogram endpoints without ever applying the sortop ... but it's * probably not worth trying, because whatever the caller wants to do with * the endpoints would likely fail the security check too. */ opfuncoid = get_opcode(sortop); if (!statistic_proc_security_check(vardata, opfuncoid)) return false; get_typlenbyval(vardata->atttype, &typLen, &typByVal); /* * If there is a histogram, grab the first and last values. * * If there is a histogram that is sorted with some other operator than * the one we want, fail --- this suggests that there is data we can't * use. */ if (get_attstatsslot(&sslot, vardata->statsTuple, STATISTIC_KIND_HISTOGRAM, sortop, ATTSTATSSLOT_VALUES)) { if (sslot.nvalues > 0) { tmin = datumCopy(sslot.values[0], typByVal, typLen); tmax = datumCopy(sslot.values[sslot.nvalues - 1], typByVal, typLen); have_data = true; } free_attstatsslot(&sslot); } else if (get_attstatsslot(&sslot, vardata->statsTuple, STATISTIC_KIND_HISTOGRAM, InvalidOid, 0)) { free_attstatsslot(&sslot); return false; } /* * If we have most-common-values info, look for extreme MCVs. This is * needed even if we also have a histogram, since the histogram excludes * the MCVs. However, usually the MCVs will not be the extreme values, so * avoid unnecessary data copying. */ if (get_attstatsslot(&sslot, vardata->statsTuple, STATISTIC_KIND_MCV, InvalidOid, ATTSTATSSLOT_VALUES)) { bool tmin_is_mcv = false; bool tmax_is_mcv = false; FmgrInfo opproc; fmgr_info(opfuncoid, &opproc); for (i = 0; i < sslot.nvalues; i++) { if (!have_data) { tmin = tmax = sslot.values[i]; tmin_is_mcv = tmax_is_mcv = have_data = true; continue; } if (DatumGetBool( FunctionCall2Coll(&opproc, DEFAULT_COLLATION_OID, sslot.values[i], tmin))) { tmin = sslot.values[i]; tmin_is_mcv = true; } if (DatumGetBool( FunctionCall2Coll(&opproc, DEFAULT_COLLATION_OID, tmax, sslot.values[i]))) { tmax = sslot.values[i]; tmax_is_mcv = true; } } if (tmin_is_mcv) tmin = datumCopy(tmin, typByVal, typLen); if (tmax_is_mcv) tmax = datumCopy(tmax, typByVal, typLen); free_attstatsslot(&sslot); } *min = tmin; *max = tmax; return have_data; } /* * ts_make_sort --- basic routine to build a Sort plan node * * Caller must have built the sortColIdx, sortOperators, collations, and * nullsFirst arrays already. */ Sort * ts_make_sort(Plan *lefttree, int numCols, AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst) { Sort *node = makeNode(Sort); Plan *plan = &node->plan; plan->targetlist = lefttree->targetlist; plan->qual = NIL; plan->lefttree = lefttree; plan->righttree = NULL; node->numCols = numCols; node->sortColIdx = sortColIdx; node->sortOperators = sortOperators; node->collations = collations; node->nullsFirst = nullsFirst; return node; } /* * make_sort_from_pathkeys * Create sort plan to sort according to given pathkeys * * 'lefttree' is the node which yields input tuples * 'pathkeys' is the list of pathkeys by which the result is to be sorted * 'relids' is the set of relations required by prepare_sort_from_pathkeys() */ Sort * ts_make_sort_from_pathkeys(Plan *lefttree, List *pathkeys, Relids relids) { int numsortkeys; AttrNumber *sortColIdx; Oid *sortOperators; Oid *collations; bool *nullsFirst; /* Compute sort column info, and adjust lefttree as needed */ lefttree = ts_prepare_sort_from_pathkeys(lefttree, pathkeys, relids, NULL, false, &numsortkeys, &sortColIdx, &sortOperators, &collations, &nullsFirst); /* Now build the Sort node */ return ts_make_sort(lefttree, numsortkeys, sortColIdx, sortOperators, collations, nullsFirst); } /* * prepare_sort_from_pathkeys * Prepare to sort according to given pathkeys * * This is used to set up for Sort, MergeAppend, and Gather Merge nodes. It * calculates the executor's representation of the sort key information, and * adjusts the plan targetlist if needed to add resjunk sort columns. * * Input parameters: * 'lefttree' is the plan node which yields input tuples * 'pathkeys' is the list of pathkeys by which the result is to be sorted * 'relids' identifies the child relation being sorted, if any * 'reqColIdx' is NULL or an array of required sort key column numbers * 'adjust_tlist_in_place' is true if lefttree must be modified in-place * * We must convert the pathkey information into arrays of sort key column * numbers, sort operator OIDs, collation OIDs, and nulls-first flags, * which is the representation the executor wants. These are returned into * the output parameters *p_numsortkeys etc. * * When looking for matches to an EquivalenceClass's members, we will only * consider child EC members if they belong to given 'relids'. This protects * against possible incorrect matches to child expressions that contain no * Vars. * * If reqColIdx isn't NULL then it contains sort key column numbers that * we should match. This is used when making child plans for a MergeAppend; * it's an error if we can't match the columns. * * If the pathkeys include expressions that aren't simple Vars, we will * usually need to add resjunk items to the input plan's targetlist to * compute these expressions, since a Sort or MergeAppend node itself won't * do any such calculations. If the input plan type isn't one that can do * projections, this means adding a Result node just to do the projection. * However, the caller can pass adjust_tlist_in_place = true to force the * lefttree tlist to be modified in-place regardless of whether the node type * can project --- we use this for fixing the tlist of MergeAppend itself. * * Returns the node which is to be the input to the Sort (either lefttree, * or a Result stacked atop lefttree). * * static function copied from createplan.c */ Plan * ts_prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys, Relids relids, const AttrNumber *reqColIdx, bool adjust_tlist_in_place, int *p_numsortkeys, AttrNumber **p_sortColIdx, Oid **p_sortOperators, Oid **p_collations, bool **p_nullsFirst) { List *tlist = lefttree->targetlist; ListCell *i; int numsortkeys; AttrNumber *sortColIdx; Oid *sortOperators; Oid *collations; bool *nullsFirst; /* * We will need at most list_length(pathkeys) sort columns; possibly less */ numsortkeys = list_length(pathkeys); sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber)); sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid)); collations = (Oid *) palloc(numsortkeys * sizeof(Oid)); nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool)); numsortkeys = 0; foreach (i, pathkeys) { PathKey *pathkey = (PathKey *) lfirst(i); EquivalenceClass *ec = pathkey->pk_eclass; EquivalenceMember *em; TargetEntry *tle = NULL; Oid pk_datatype = InvalidOid; Oid sortop; ListCell *j; if (ec->ec_has_volatile) { /* * If the pathkey's EquivalenceClass is volatile, then it must * have come from an ORDER BY clause, and we have to match it to * that same targetlist entry. */ if (ec->ec_sortref == 0) /* can't happen */ elog(ERROR, "volatile EquivalenceClass has no sortref"); tle = get_sortgroupref_tle(ec->ec_sortref, tlist); Assert(tle); Assert(list_length(ec->ec_members) == 1); pk_datatype = ((EquivalenceMember *) linitial(ec->ec_members))->em_datatype; } else if (reqColIdx != NULL) { /* * If we are given a sort column number to match, only consider * the single TLE at that position. It's possible that there is * no such TLE, in which case fall through and generate a resjunk * targetentry (we assume this must have happened in the parent * plan as well). If there is a TLE but it doesn't match the * pathkey's EC, we do the same, which is probably the wrong thing * but we'll leave it to caller to complain about the mismatch. */ tle = get_tle_by_resno(tlist, reqColIdx[numsortkeys]); if (tle) { em = find_ec_member_matching_expr(ec, tle->expr, relids); if (em) { /* found expr at right place in tlist */ pk_datatype = em->em_datatype; } else tle = NULL; } } else { /* * Otherwise, we can sort by any non-constant expression listed in * the pathkey's EquivalenceClass. For now, we take the first * tlist item found in the EC. If there's no match, we'll generate * a resjunk entry using the first EC member that is an expression * in the input's vars. (The non-const restriction only matters * if the EC is below_outer_join; but if it isn't, it won't * contain consts anyway, else we'd have discarded the pathkey as * redundant.) * * XXX if we have a choice, is there any way of figuring out which * might be cheapest to execute? (For example, int4lt is likely * much cheaper to execute than numericlt, but both might appear * in the same equivalence class...) Not clear that we ever will * have an interesting choice in practice, so it may not matter. */ foreach (j, tlist) { tle = (TargetEntry *) lfirst(j); em = find_ec_member_matching_expr(ec, tle->expr, relids); if (em) { /* found expr already in tlist */ pk_datatype = em->em_datatype; break; } tle = NULL; } } if (!tle) { /* * No matching tlist item; look for a computable expression. */ em = find_computable_ec_member(NULL, ec, tlist, relids, false); if (!em) elog(ERROR, "could not find pathkey item to sort"); pk_datatype = em->em_datatype; /* * Do we need to insert a Result node? */ if (!adjust_tlist_in_place && !is_projection_capable_plan(lefttree)) { /* copy needed so we don't modify input's tlist below */ tlist = copyObject(tlist); lefttree = inject_projection_plan(lefttree, tlist, lefttree->parallel_safe); } /* Don't bother testing is_projection_capable_plan again */ adjust_tlist_in_place = true; /* * Add resjunk entry to input's tlist */ tle = makeTargetEntry(copyObject(em->em_expr), list_length(tlist) + 1, NULL, true); tlist = lappend(tlist, tle); lefttree->targetlist = tlist; /* just in case NIL before */ } /* * Look up the correct sort operator from the PathKey's slightly * abstracted representation. */ sortop = get_opfamily_member(pathkey->pk_opfamily, pk_datatype, pk_datatype, pathkey->pk_cmptype); if (!OidIsValid(sortop)) /* should not happen */ elog(ERROR, "missing operator %d(%u,%u) in opfamily %u", pathkey->pk_cmptype, pk_datatype, pk_datatype, pathkey->pk_opfamily); /* Add the column to the sort arrays */ sortColIdx[numsortkeys] = tle->resno; sortOperators[numsortkeys] = sortop; collations[numsortkeys] = ec->ec_collation; nullsFirst[numsortkeys] = pathkey->pk_nulls_first; numsortkeys++; } /* Return results */ *p_numsortkeys = numsortkeys; *p_sortColIdx = sortColIdx; *p_sortOperators = sortOperators; *p_collations = collations; *p_nullsFirst = nullsFirst; return lefttree; } /* * copied verbatim from createplan.c */ List * ts_build_path_tlist(PlannerInfo *root, Path *path) { List *tlist = NIL; Index *sortgrouprefs = path->pathtarget->sortgrouprefs; int resno = 1; ListCell *v; foreach (v, path->pathtarget->exprs) { Node *node = (Node *) lfirst(v); TargetEntry *tle; /* * If it's a parameterized path, there might be lateral references in * the tlist, which need to be replaced with Params. There's no need * to remake the TargetEntry nodes, so apply this to each list item * separately. */ if (path->param_info) node = replace_nestloop_params(root, node); tle = makeTargetEntry((Expr *) node, resno, NULL, false); if (sortgrouprefs) tle->ressortgroupref = sortgrouprefs[resno - 1]; tlist = lappend(tlist, tle); resno++; } return tlist; } /* * replace_nestloop_params * Replace outer-relation Vars and PlaceHolderVars in the given expression * with nestloop Params * * All Vars and PlaceHolderVars belonging to the relation(s) identified by * root->curOuterRels are replaced by Params, and entries are added to * root->curOuterParams if not already present. */ static Node * replace_nestloop_params(PlannerInfo *root, Node *expr) { /* No setup needed for tree walk, so away we go */ return replace_nestloop_params_mutator(expr, root); } static Node * replace_nestloop_params_mutator(Node *node, PlannerInfo *root) { if (node == NULL) return NULL; if (IsA(node, Var)) { Var *var = (Var *) node; /* Upper-level Vars should be long gone at this point */ Assert(var->varlevelsup == 0); /* If not to be replaced, we can just return the Var unmodified */ if (!bms_is_member(var->varno, root->curOuterRels)) return node; /* Replace the Var with a nestloop Param */ return (Node *) replace_nestloop_param_var(root, var); } if (IsA(node, PlaceHolderVar)) { PlaceHolderVar *phv = (PlaceHolderVar *) node; /* Upper-level PlaceHolderVars should be long gone at this point */ Assert(phv->phlevelsup == 0); #if PG16_LT /* * Check whether we need to replace the PHV. We use bms_overlap as a * cheap/quick test to see if the PHV might be evaluated in the outer * rels, and then grab its PlaceHolderInfo to tell for sure. */ if (!bms_overlap(phv->phrels, root->curOuterRels) || !bms_is_subset(find_placeholder_info(root, phv, false)->ph_eval_at, root->curOuterRels)) #else /* Check whether we need to replace the PHV */ if (!bms_is_subset(find_placeholder_info(root, phv)->ph_eval_at, root->curOuterRels)) #endif { /* * We can't replace the whole PHV, but we might still need to * replace Vars or PHVs within its expression, in case it ends up * actually getting evaluated here. (It might get evaluated in * this plan node, or some child node; in the latter case we don't * really need to process the expression here, but we haven't got * enough info to tell if that's the case.) Flat-copy the PHV * node and then recurse on its expression. * * Note that after doing this, we might have different * representations of the contents of the same PHV in different * parts of the plan tree. This is OK because equal() will just * match on phid/phlevelsup, so setrefs.c will still recognize an * upper-level reference to a lower-level copy of the same PHV. */ PlaceHolderVar *newphv = makeNode(PlaceHolderVar); memcpy(newphv, phv, sizeof(PlaceHolderVar)); newphv->phexpr = (Expr *) replace_nestloop_params_mutator((Node *) phv->phexpr, root); return (Node *) newphv; } /* Replace the PlaceHolderVar with a nestloop Param */ return (Node *) replace_nestloop_param_placeholdervar(root, phv); } return expression_tree_mutator(node, replace_nestloop_params_mutator, (void *) root); } /* * make_result * Build a Result plan node */ static Result * make_result(List *tlist, Node *resconstantqual, Plan *subplan) { Result *node = makeNode(Result); Plan *plan = &node->plan; plan->targetlist = tlist; plan->qual = NIL; plan->lefttree = subplan; plan->righttree = NULL; node->resconstantqual = resconstantqual; return node; } /* * Copy cost and size info from a lower plan node to an inserted node. * (Most callers alter the info after copying it.) */ static void copy_plan_costsize(Plan *dest, Plan *src) { dest->startup_cost = src->startup_cost; dest->total_cost = src->total_cost; dest->plan_rows = src->plan_rows; dest->plan_width = src->plan_width; /* Assume the inserted node is not parallel-aware. */ dest->parallel_aware = false; /* Assume the inserted node is parallel-safe, if child plan is. */ dest->parallel_safe = src->parallel_safe; } /* * inject_projection_plan * Insert a Result node to do a projection step. * * This is used in a few places where we decide on-the-fly that we need a * projection step as part of the tree generated for some Path node. * We should try to get rid of this in favor of doing it more honestly. * * One reason it's ugly is we have to be told the right parallel_safe marking * to apply (since the tlist might be unsafe even if the child plan is safe). */ static Plan * inject_projection_plan(Plan *subplan, List *tlist, bool parallel_safe) { Plan *plan; plan = (Plan *) make_result(tlist, NULL, subplan); /* * In principle, we should charge tlist eval cost plus cpu_per_tuple per * row for the Result node. But the former has probably been factored in * already and the latter was not accounted for during Path construction, * so being formally correct might just make the EXPLAIN output look less * consistent not more so. Hence, just copy the subplan's cost. */ copy_plan_costsize(plan, subplan); plan->parallel_safe = parallel_safe; return plan; } /* In PG18, child ems are not added to ec_members * but need to be maintained in separate Lists. * * https://github.com/postgres/postgres/commit/d69d45a5 */ /* copied from add_child_eq_member */ #if PG18_GE void ts_add_child_eq_member(PlannerInfo *root, EquivalenceClass *ec, EquivalenceMember *em, int child_relid) { /* * Allocate the array to store child members; an array of Lists indexed by * relid, or expand the existing one, if necessary. */ if (unlikely(ec->ec_childmembers_size < root->simple_rel_array_size)) { ec->ec_relids = bms_add_members(ec->ec_relids, em->em_relids); if (ec->ec_childmembers == NULL) ec->ec_childmembers = palloc0_array(List *, root->simple_rel_array_size); else ec->ec_childmembers = repalloc0_array(ec->ec_childmembers, List *, ec->ec_childmembers_size, root->simple_rel_array_size); ec->ec_childmembers_size = root->simple_rel_array_size; } /* add member to the ec_childmembers List for the given child_relid */ ec->ec_childmembers[child_relid] = lappend(ec->ec_childmembers[child_relid], em); } #endif ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/planner.h�������������������������������������������������������������0000664�0000000�0000000�00000004657�15100345067�0020000�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. * * These function were copied from the PostgreSQL core planner, since * they were declared static in the core planner, but we need them for * our manipulations. */ #include <postgres.h> #include <nodes/execnodes.h> #include <utils/rel.h> #include <utils/selfuncs.h> #include "export.h" extern TSDLLEXPORT void ts_make_inh_translation_list(Relation oldrelation, Relation newrelation, Index newvarno, AppendRelInfo *appinfo); extern TSDLLEXPORT struct PathTarget *ts_make_partial_grouping_target(struct PlannerInfo *root, PathTarget *grouping_target); extern bool ts_get_variable_range(PlannerInfo *root, VariableStatData *vardata, Oid sortop, Datum *min, Datum *max); extern TSDLLEXPORT Plan * ts_prepare_sort_from_pathkeys(Plan *lefttree, List *pathkeys, Relids relids, const AttrNumber *reqColIdx, bool adjust_tlist_in_place, int *p_numsortkeys, AttrNumber **p_sortColIdx, Oid **p_sortOperators, Oid **p_collations, bool **p_nullsFirst); extern TSDLLEXPORT Sort *ts_make_sort_from_pathkeys(Plan *lefttree, List *pathkeys, Relids relids); extern TSDLLEXPORT Sort *ts_make_sort(Plan *lefttree, int numCols, AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst); extern TSDLLEXPORT PathKey *ts_make_pathkey_from_sortop(PlannerInfo *root, Expr *expr, Relids nullable_relids, Oid ordering_op, bool nulls_first, Index sortref, bool create_it); extern TSDLLEXPORT List *ts_build_path_tlist(PlannerInfo *root, Path *path); extern void ts_ExecSetTupleBound(int64 tuples_needed, PlanState *child_node); #if PG18_GE /* In PG18, child ems are not added to ec_members * but need to be maintained in separate Lists. * * https://github.com/postgres/postgres/commit/d69d45a5 */ /* copied from add_child_eq_member */ extern TSDLLEXPORT void ts_add_child_eq_member(PlannerInfo *root, EquivalenceClass *ec, EquivalenceMember *em, int child_relid); #endif ���������������������������������������������������������������������������������timescaledb-2.23.0/src/import/ts_explain.c����������������������������������������������������������0000664�0000000�0000000�00000005172�15100345067�0020473�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ #include "ts_explain.h" #include <commands/explain.h> #include <nodes/makefuncs.h> #include <utils/ruleutils.h> #include "compat/compat.h" /* * Show a generic expression */ static void ts_show_expression(Node *node, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es) { List *context; char *exprstr; /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, planstate->plan, ancestors); /* Deparse the expression */ exprstr = deparse_expression(node, context, useprefix, false); /* And add to es->str */ ExplainPropertyText(qlabel, exprstr, es); } /* * Show a qualifier expression (which is a List with implicit AND semantics) */ static void ts_show_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, bool useprefix, ExplainState *es) { Node *node; /* No work if empty qual */ if (qual == NIL) return; /* Convert AND list to explicit AND */ node = (Node *) make_ands_explicit(qual); /* And show it */ ts_show_expression(node, qlabel, planstate, ancestors, useprefix, es); } /* * Show a qualifier expression for a scan plan node */ void ts_show_scan_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es) { bool useprefix; useprefix = (IsA(planstate->plan, SubqueryScan) || es->verbose); ts_show_qual(qual, qlabel, planstate, ancestors, useprefix, es); } /* * If it's EXPLAIN ANALYZE, show instrumentation information for a plan node * * "which" identifies which instrumentation counter to print */ void ts_show_instrumentation_count(const char *qlabel, int which, PlanState *planstate, ExplainState *es) { double nfiltered; double nloops; if (!es->analyze || !planstate->instrument) return; if (which == 2) nfiltered = planstate->instrument->nfiltered2; else nfiltered = planstate->instrument->nfiltered1; nloops = planstate->instrument->nloops; /* In text mode, suppress zero counts; they're not interesting enough */ if (nfiltered > 0 || es->format != EXPLAIN_FORMAT_TEXT) { if (nloops > 0) ExplainPropertyFloat(qlabel, NULL, nfiltered / nloops, 0, es); else ExplainPropertyFloat(qlabel, NULL, 0.0, 0, es); } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/import/ts_explain.h����������������������������������������������������������0000664�0000000�0000000�00000001750�15100345067�0020476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ #include <postgres.h> #include <commands/explain.h> #include <nodes/execnodes.h> #include <nodes/pg_list.h> #include <compat/compat.h> #include "export.h" #if PG18_GE #include <commands/explain_format.h> #include <commands/explain_state.h> #endif extern TSDLLEXPORT void ts_show_scan_qual(List *qual, const char *qlabel, PlanState *planstate, List *ancestors, ExplainState *es); extern TSDLLEXPORT void ts_show_instrumentation_count(const char *qlabel, int which, PlanState *planstate, ExplainState *es); ������������������������timescaledb-2.23.0/src/indexing.c�������������������������������������������������������������������0000664�0000000�0000000�00000036646�15100345067�0016632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/pg_inherits.h> #include <commands/defrem.h> #include <commands/event_trigger.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <fmgr.h> #include <nodes/makefuncs.h> #include <nodes/parsenodes.h> #include <nodes/value.h> #include <parser/parse_utilcmd.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include "annotations.h" #include "dimension.h" #include "errors.h" #include "hypertable_cache.h" #include "indexing.h" #include "partitioning.h" static bool index_has_attribute(const List *indexelems, const char *attrname) { ListCell *lc; foreach (lc, indexelems) { Node *node = lfirst(lc); const char *colname = NULL; /* * The type of the element varies depending on whether the list is * from an index or a constraint */ switch (nodeTag(node)) { case T_IndexElem: colname = ((IndexElem *) node)->name; break; case T_String: colname = strVal(node); break; case T_List: { List *pair = lfirst_node(List, lc); if (list_length(pair) == 2 && IsA(linitial(pair), IndexElem) && IsA(lsecond(pair), List)) { colname = ((IndexElem *) linitial(pair))->name; break; } } TS_FALLTHROUGH; default: elog(ERROR, "unsupported index list element"); } if (colname != NULL && strncmp(colname, attrname, NAMEDATALEN) == 0) return true; } return false; } /* * Verify that index columns cover all partitioning dimensions. * * A UNIQUE, PRIMARY KEY or EXCLUSION index on a chunk must cover all * partitioning dimensions to guarantee uniqueness (or exclusion) across the * entire hypertable. Therefore we check that all dimensions are present among * the index columns. */ void ts_indexing_verify_columns(const Hyperspace *hs, const List *indexelems) { int i; for (i = 0; i < hs->num_dimensions; i++) { const Dimension *dim = &hs->dimensions[i]; if (!index_has_attribute(indexelems, NameStr(dim->fd.column_name))) ereport(ERROR, (errcode(ERRCODE_TS_BAD_HYPERTABLE_INDEX_DEFINITION), errmsg("cannot create a unique index without the column \"%s\" (used in " "partitioning)", NameStr(dim->fd.column_name)), errhint( "If you're creating a hypertable on a table with a primary key, ensure " "the partitioning column is part of the primary or composite key."))); } } /* * Verify index columns. * * We only care about UNIQUE, PRIMARY KEY or EXCLUSION indexes. */ void ts_indexing_verify_index(const Hyperspace *hs, const IndexStmt *stmt) { if (stmt->unique || stmt->excludeOpNames != NULL) ts_indexing_verify_columns(hs, stmt->indexParams); } /* * Build a list of string Values representing column names that an index covers. */ static List * build_indexcolumn_list(const Relation idxrel) { List *columns = NIL; int i; for (i = 0; i < idxrel->rd_att->natts; i++) { Form_pg_attribute idxattr = TupleDescAttr(idxrel->rd_att, i); columns = lappend(columns, makeString(NameStr(idxattr->attname))); } return columns; } static void create_default_index(const Hypertable *ht, List *indexelems) { IndexStmt stmt = { .type = T_IndexStmt, .accessMethod = DEFAULT_INDEX_TYPE, .idxname = NULL, .relation = makeRangeVar((char *) NameStr(ht->fd.schema_name), (char *) NameStr(ht->fd.table_name), 0), .tableSpace = get_tablespace_name(get_rel_tablespace(ht->main_table_relid)), .indexParams = indexelems, }; DefineIndexCompat(ht->main_table_relid, &stmt, InvalidOid, /* indexRelationId */ InvalidOid, /* parentIndexId */ InvalidOid, /* parentConstraintId */ -1, /* total_parts */ false, /* is_alter_table */ false, /* check_rights */ false, /* check_not_in_use */ false, /* skip_build */ true); /* quiet */ } static const Node * get_open_dim_expr(const Dimension *dim) { if (dim == NULL || dim->partitioning == NULL) return NULL; return dim->partitioning->partfunc.func_fmgr.fn_expr; } static const char * get_open_dim_name(const Dimension *dim) { if (dim == NULL || dim->partitioning != NULL) return NULL; return NameStr(dim->fd.column_name); } static void create_default_indexes(const Hypertable *ht, const Dimension *time_dim, const Dimension *space_dim, bool has_time_idx, bool has_time_space_idx) { const char *dimname = get_open_dim_name(time_dim); IndexElem telem = { .type = T_IndexElem, .name = dimname ? (char *) dimname : NULL, .ordering = SORTBY_DESC, .expr = (Node *) get_open_dim_expr(time_dim), }; /* In case we'd allow tables that are only space partitioned */ if (NULL == time_dim) return; /* Create ("time") index */ if (!has_time_idx) create_default_index(ht, list_make1(&telem)); /* Create ("space", "time") index */ if (space_dim != NULL && !has_time_space_idx) { IndexElem selem = { .type = T_IndexElem, .name = pstrdup(NameStr(space_dim->fd.column_name)), .ordering = SORTBY_ASC, }; create_default_index(ht, list_make2(&selem, &telem)); } } /* * Verify that unique, primary and exclusion indexes on a hypertable cover all * partitioning columns and create any default indexes. * * Default indexes are assumed to cover the first open ("time") dimension, and, * optionally, the first closed ("space") dimension. */ static void indexing_create_and_verify_hypertable_indexes(const Hypertable *ht, bool create_default, bool verify) { Relation tblrel = table_open(ht->main_table_relid, AccessShareLock); const Dimension *time_dim = ts_hyperspace_get_dimension(ht->space, DIMENSION_TYPE_OPEN, 0); const Dimension *space_dim = ts_hyperspace_get_dimension(ht->space, DIMENSION_TYPE_CLOSED, 0); List *indexlist = RelationGetIndexList(tblrel); bool has_time_idx = false; bool has_time_space_idx = false; ListCell *lc; foreach (lc, indexlist) { Relation idxrel = index_open(lfirst_oid(lc), AccessShareLock); if (verify && (idxrel->rd_index->indisunique || idxrel->rd_index->indisexclusion)) ts_indexing_verify_columns(ht->space, build_indexcolumn_list(idxrel)); /* Check for existence of "default" indexes */ if (create_default && NULL != time_dim) { Form_pg_attribute idxattr_time, idxattr_space; switch (idxrel->rd_att->natts) { case 1: /* ("time") index */ idxattr_time = TupleDescAttr(idxrel->rd_att, 0); if (namestrcmp(&idxattr_time->attname, NameStr(time_dim->fd.column_name)) == 0) has_time_idx = true; break; case 2: /* ("space", "time") index */ idxattr_space = TupleDescAttr(idxrel->rd_att, 0); idxattr_time = TupleDescAttr(idxrel->rd_att, 1); if (space_dim != NULL && namestrcmp(&idxattr_space->attname, NameStr(space_dim->fd.column_name)) == 0 && namestrcmp(&idxattr_time->attname, NameStr(time_dim->fd.column_name)) == 0) has_time_space_idx = true; break; default: break; } } index_close(idxrel, AccessShareLock); } if (create_default) create_default_indexes(ht, time_dim, space_dim, has_time_idx, has_time_space_idx); table_close(tblrel, AccessShareLock); } bool TSDLLEXPORT ts_indexing_relation_has_primary_or_unique_index(Relation htrel) { List *indexoidlist = RelationGetIndexList(htrel); ListCell *lc; bool result = false; if (OidIsValid(htrel->rd_pkindex)) return true; foreach (lc, indexoidlist) { Oid indexoid = lfirst_oid(lc); HeapTuple index_tuple; Form_pg_index index; index_tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexoid)); if (!HeapTupleIsValid(index_tuple)) /* should not happen */ elog(ERROR, "cache lookup failed for index %u in \"%s\" ", indexoid, RelationGetRelationName(htrel)); index = (Form_pg_index) GETSTRUCT(index_tuple); result = index->indisunique; ReleaseSysCache(index_tuple); if (result) break; } list_free(indexoidlist); return result; } /* create the index on the root table of a hypertable. * based on postgres CREATE INDEX * https://github.com/postgres/postgres/blob/ebfe20dc706bd3238a9bdf3b44cd8f82337e86a8/src/backend/tcop/utility.c#L1291-L1374 * despite not allowing CONCURRENT index creation now, we expect to do so soon, so this code * retains those code paths */ extern ObjectAddress ts_indexing_root_table_create_index(IndexStmt *stmt, const char *queryString, bool is_multitransaction) { Oid relid; LOCKMODE lockmode; ObjectAddress root_table_address; int total_parts = -1; if (stmt->concurrent) PreventInTransactionBlock(true, "CREATE INDEX CONCURRENTLY"); /* * Look up the relation OID just once, right here at the * beginning, so that we don't end up repeating the name * lookup later and latching onto a different relation * partway through. To avoid lock upgrade hazards, it's * important that we take the strongest lock that will * eventually be needed here, so the lockmode calculation * needs to match what DefineIndex() does. */ lockmode = stmt->concurrent ? ShareUpdateExclusiveLock : ShareLock; relid = RangeVarGetRelidExtended(stmt->relation, lockmode, 0, RangeVarCallbackOwnsRelation, NULL); /* * single-transaction CREATE INDEX on a hypertable tables recurses to * chunks, so we must acquire locks early to avoid deadlocks. * * We also take the opportunity to verify that all * chunks are something we can put an index on, to * avoid building some indexes only to fail later. */ if (!is_multitransaction) { ListCell *lc; List *inheritors = NIL; inheritors = find_all_inheritors(relid, lockmode, NULL); foreach (lc, inheritors) { char relkind = get_rel_relkind(lfirst_oid(lc)); if (relkind != RELKIND_RELATION && relkind != RELKIND_MATVIEW && relkind != RELKIND_FOREIGN_TABLE) ereport(ERROR, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), errmsg("cannot create index on hypertable \"%s\"", stmt->relation->relname), errdetail("Table \"%s\" contains chunks of the wrong type.", stmt->relation->relname))); } total_parts = list_length(inheritors) - 1; list_free(inheritors); } /* Run parse analysis ... */ stmt = transformIndexStmt(relid, stmt, queryString); /* ... and do it */ EventTriggerAlterTableStart((Node *) stmt); (void) total_parts; root_table_address = DefineIndexCompat(relid, /* OID of heap relation */ stmt, InvalidOid, /* no predefined OID */ InvalidOid, /* parentIndexId */ InvalidOid, /* parentConstraintId */ total_parts, /* total_parts */ false, /* is_alter_table */ true, /* check_rights */ false, /* check_not_in_use */ false, /* skip_build */ false); /* quiet */ return root_table_address; } void ts_indexing_verify_indexes(const Hypertable *ht) { indexing_create_and_verify_hypertable_indexes(ht, false, true); } void ts_indexing_create_default_indexes(const Hypertable *ht) { indexing_create_and_verify_hypertable_indexes(ht, true, false); } TSDLLEXPORT Oid ts_indexing_find_clustered_index(Oid table_relid) { Relation rel; ListCell *index; Oid index_relid = InvalidOid; rel = table_open(table_relid, AccessShareLock); /* We need to find the index that has indisclustered set. */ foreach (index, RelationGetIndexList(rel)) { HeapTuple idxtuple; Form_pg_index indexForm; index_relid = lfirst_oid(index); idxtuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_relid)); if (!HeapTupleIsValid(idxtuple)) elog(ERROR, "cache lookup failed for index %u when looking for a clustered index", index_relid); indexForm = (Form_pg_index) GETSTRUCT(idxtuple); if (indexForm->indisclustered) { ReleaseSysCache(idxtuple); break; } ReleaseSysCache(idxtuple); index_relid = InvalidOid; } table_close(rel, AccessShareLock); return index_relid; } typedef enum IndexValidity { IndexInvalid = 0, IndexValid, } IndexValidity; static bool ts_indexing_mark_as(Oid index_id, IndexValidity validity) { Relation pg_index; HeapTuple indexTuple; HeapTuple new_tuple; Form_pg_index indexForm; bool was_valid; /* Open pg_index and fetch a writable copy of the index's tuple */ pg_index = table_open(IndexRelationId, RowExclusiveLock); indexTuple = SearchSysCacheCopy1(INDEXRELID, ObjectIdGetDatum(index_id)); if (!HeapTupleIsValid(indexTuple)) elog(ERROR, "cache lookup failed when marking index %u", index_id); new_tuple = heap_copytuple(indexTuple); indexForm = (Form_pg_index) GETSTRUCT(new_tuple); was_valid = indexForm->indisvalid; /* Perform the requested state change on the copy */ switch (validity) { case IndexValid: Assert(indexForm->indislive); Assert(indexForm->indisready); indexForm->indisvalid = true; break; case IndexInvalid: indexForm->indisvalid = false; indexForm->indisclustered = false; break; } /* ... and write it back */ CatalogTupleUpdate(pg_index, &indexTuple->t_self, new_tuple); table_close(pg_index, RowExclusiveLock); return was_valid; } void ts_indexing_mark_as_valid(Oid index_id) { ts_indexing_mark_as(index_id, IndexValid); } /* returns if the index was valid */ bool ts_indexing_mark_as_invalid(Oid index_id) { return ts_indexing_mark_as(index_id, IndexInvalid); } TS_FUNCTION_INFO_V1(ts_index_matches); Datum ts_index_matches(PG_FUNCTION_ARGS) { Oid index1 = PG_GETARG_OID(0); Oid index2 = PG_GETARG_OID(1); bool result; if (!OidIsValid(index1) || !OidIsValid(index2)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid index"))); result = ts_indexing_compare(index1, index2); PG_RETURN_BOOL(result); } /* Returns true if the indexes are equivalent */ bool ts_indexing_compare(Oid index1, Oid index2) { Relation indexrel1 = index_open(index1, AccessShareLock); Relation indexrel2 = index_open(index2, AccessShareLock); Relation rel1 = table_open(indexrel1->rd_index->indrelid, AccessShareLock); Relation rel2 = table_open(indexrel2->rd_index->indrelid, AccessShareLock); if (indexrel1->rd_rel->relkind != RELKIND_INDEX || indexrel2->rd_rel->relkind != RELKIND_INDEX) { ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("expected both \"%s\" and \"%s\" to be indexes", RelationGetRelationName(indexrel1), RelationGetRelationName(indexrel2)))); } IndexInfo *info1 = BuildIndexInfo(indexrel1); IndexInfo *info2 = BuildIndexInfo(indexrel2); #if PG16_GE AttrMap *attmap = build_attrmap_by_name(RelationGetDescr(rel1), RelationGetDescr(rel2), false); #else AttrMap *attmap = build_attrmap_by_name(RelationGetDescr(rel1), RelationGetDescr(rel2)); #endif bool result = CompareIndexInfo(info1, info2, indexrel1->rd_indcollation, indexrel2->rd_indcollation, indexrel1->rd_opfamily, indexrel2->rd_opfamily, attmap); if (result) { /* * CompareIndexInfo does not compare indoption, which means it will * consider two indexes with different ASC/DESC or NULLS FIRST/LAST * options as equivalent. */ for (int i = 0; i < IndexRelationGetNumberOfKeyAttributes(indexrel1); i++) { if (indexrel1->rd_indoption[i] != indexrel2->rd_indoption[i]) { result = false; break; } } } index_close(indexrel1, NoLock); index_close(indexrel2, NoLock); table_close(rel1, NoLock); table_close(rel2, NoLock); return result; } ������������������������������������������������������������������������������������������timescaledb-2.23.0/src/indexing.h�������������������������������������������������������������������0000664�0000000�0000000�00000002224�15100345067�0016620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/parsenodes.h> #include <nodes/pg_list.h> #include "dimension.h" #include "export.h" extern void ts_indexing_verify_columns(const Hyperspace *hs, const List *indexelems); extern void ts_indexing_verify_index(const Hyperspace *hs, const IndexStmt *stmt); extern void ts_indexing_verify_indexes(const Hypertable *ht); extern void ts_indexing_create_default_indexes(const Hypertable *ht); extern ObjectAddress ts_indexing_root_table_create_index(IndexStmt *stmt, const char *queryString, bool is_multitransaction); extern TSDLLEXPORT Oid ts_indexing_find_clustered_index(Oid table_relid); extern void ts_indexing_mark_as_valid(Oid index_id); extern bool ts_indexing_mark_as_invalid(Oid index_id); extern bool TSDLLEXPORT ts_indexing_relation_has_primary_or_unique_index(Relation htrel); extern TSDLLEXPORT bool ts_indexing_compare(Oid index1, Oid index2); extern TSDLLEXPORT Datum ts_index_matches(PG_FUNCTION_ARGS); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/init.c�����������������������������������������������������������������������0000664�0000000�0000000�00000006100�15100345067�0015746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <commands/extension.h> #include <miscadmin.h> #include <parser/analyze.h> #include <storage/ipc.h> #include <utils/guc.h> #include "compat/compat.h" #include "bgw/launcher_interface.h" #include "config.h" #include "extension.h" #include "guc.h" #include "license_guc.h" #include "nodes/constraint_aware_append/constraint_aware_append.h" #include "ts_catalog/catalog.h" #include "version.h" #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif extern void _hypertable_cache_init(void); extern void _hypertable_cache_fini(void); extern void _cache_invalidate_init(void); extern void _cache_invalidate_fini(void); extern void _planner_init(void); extern void _planner_fini(void); extern void _process_utility_init(void); extern void _process_utility_fini(void); extern void _event_trigger_init(void); extern void _event_trigger_fini(void); extern void _conn_plain_init(); extern void _conn_plain_fini(); #ifdef TS_USE_OPENSSL extern void _conn_ssl_init(); extern void _conn_ssl_fini(); #endif #ifdef TS_DEBUG extern void _conn_mock_init(); extern void _conn_mock_fini(); #endif extern void _chunk_append_init(); #if PG16_LT extern void TSDLLEXPORT _PG_init(void); #endif TS_FUNCTION_INFO_V1(ts_post_load_init); /* Called when the backend exits */ static void cleanup_on_pg_proc_exit(int code, Datum arg) { /* * Order of items should be strict reverse order of _PG_init. Please * document any exceptions. */ #ifdef TS_DEBUG _conn_mock_fini(); #endif #ifdef TS_USE_OPENSSL _conn_ssl_fini(); #endif _conn_plain_fini(); _process_utility_fini(); _event_trigger_fini(); _planner_fini(); _cache_invalidate_fini(); _hypertable_cache_fini(); _cache_fini(); } void _PG_init(void) { static bool init_done = false; /* * Check extension_is loaded to catch certain errors such as calls to * functions defined on the wrong extension version */ ts_extension_check_version(TIMESCALEDB_VERSION_MOD); ts_extension_check_server_version(); ts_bgw_check_loader_api_version(); /* We can call _PG_init() several times if we do an eager load, so abort * init if we do. */ if (init_done) return; _cache_init(); _hypertable_cache_init(); _cache_invalidate_init(); _planner_init(); _constraint_aware_append_init(); _chunk_append_init(); _event_trigger_init(); _process_utility_init(); _guc_init(); _conn_plain_init(); #ifdef TS_USE_OPENSSL _conn_ssl_init(); #endif #ifdef TS_DEBUG _conn_mock_init(); #endif /* Register a cleanup function to be called when the backend exits */ on_proc_exit(cleanup_on_pg_proc_exit, 0); init_done = true; } TSDLLEXPORT Datum ts_post_load_init(PG_FUNCTION_ARGS) { /* * Unfortunately, if we load the tsl during _PG_init parallel workers try * to load the tsl before timescale itself, causing link-time errors. To * prevent this we defer loading until here. */ ts_license_enable_module_loading(); PG_RETURN_VOID(); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/jsonb_utils.c����������������������������������������������������������������0000664�0000000�0000000�00000020475�15100345067�0017351�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <common/jsonapi.h> #include <fmgr.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/json.h> #include <utils/jsonb.h> #include "compat/compat.h" #include "export.h" #include "jsonb_utils.h" #include "utils.h" static void ts_jsonb_add_pair(JsonbParseState *state, JsonbValue *key, JsonbValue *value); void ts_jsonb_add_null(JsonbParseState *state, const char *key) { JsonbValue json_value; json_value.type = jbvNull; ts_jsonb_add_value(state, key, &json_value); } void ts_jsonb_add_bool(JsonbParseState *state, const char *key, bool boolean) { JsonbValue json_value; json_value.type = jbvBool; json_value.val.boolean = boolean; ts_jsonb_add_value(state, key, &json_value); } void ts_jsonb_add_str(JsonbParseState *state, const char *key, const char *value) { JsonbValue json_value; Assert(value != NULL); /* If there is a null entry, don't add it to the JSON */ if (value == NULL) return; json_value.type = jbvString; json_value.val.string.val = (char *) value; json_value.val.string.len = strlen(value); ts_jsonb_add_value(state, key, &json_value); } static PGFunction get_convert_func(Oid typeid) { switch (typeid) { case INT2OID: return int2_numeric; case INT4OID: return int4_numeric; case INT8OID: return int8_numeric; default: return NULL; } } void ts_jsonb_set_value_by_type(JsonbValue *value, Oid typeid, Datum datum) { switch (typeid) { case INT2OID: case INT4OID: case INT8OID: case NUMERICOID: { PGFunction func = get_convert_func(typeid); value->type = jbvNumeric; value->val.numeric = DatumGetNumeric(func ? DirectFunctionCall1(func, datum) : datum); break; } default: { char *str = ts_datum_to_string(datum, typeid); value->type = jbvString; value->val.string.val = str; value->val.string.len = strlen(str); break; } } } void ts_jsonb_add_int32(JsonbParseState *state, const char *key, const int32 int_value) { JsonbValue json_value; ts_jsonb_set_value_by_type(&json_value, INT4OID, Int32GetDatum(int_value)); ts_jsonb_add_value(state, key, &json_value); } void ts_jsonb_add_int64(JsonbParseState *state, const char *key, const int64 int_value) { JsonbValue json_value; ts_jsonb_set_value_by_type(&json_value, INT8OID, Int64GetDatum(int_value)); ts_jsonb_add_value(state, key, &json_value); } void ts_jsonb_add_interval(JsonbParseState *state, const char *key, Interval *interval) { JsonbValue json_value; ts_jsonb_set_value_by_type(&json_value, INTERVALOID, IntervalPGetDatum(interval)); ts_jsonb_add_value(state, key, &json_value); } void ts_jsonb_add_value(JsonbParseState *state, const char *key, JsonbValue *value) { JsonbValue json_key; Assert(key != NULL); if (value == NULL) return; json_key.type = jbvString; json_key.val.string.val = (char *) key; json_key.val.string.len = strlen(key); ts_jsonb_add_pair(state, &json_key, value); } static void ts_jsonb_add_pair(JsonbParseState *state, JsonbValue *key, JsonbValue *value) { Assert(state != NULL); Assert(key != NULL); if (value == NULL) return; pushJsonbValue(&state, WJB_KEY, key); pushJsonbValue(&state, WJB_VALUE, value); } char * ts_jsonb_get_str_field(const Jsonb *jsonb, const char *key) { /* * `jsonb_object_field_text` returns NULL when the field is not found so * we cannot use `DirectFunctionCall` */ LOCAL_FCINFO(fcinfo, 2); Datum result; InitFunctionCallInfoData(*fcinfo, NULL, 2, InvalidOid, NULL, NULL); FC_SET_ARG(fcinfo, 0, PointerGetDatum(jsonb)); FC_SET_ARG(fcinfo, 1, PointerGetDatum(cstring_to_text(key))); result = jsonb_object_field_text(fcinfo); if (fcinfo->isnull) return NULL; return text_to_cstring(DatumGetTextP(result)); } bool ts_jsonb_get_bool_field(const Jsonb *json, const char *key, bool *field_found) { Datum bool_datum; char *bool_str = ts_jsonb_get_str_field(json, key); if (bool_str == NULL) { *field_found = false; return false; } bool_datum = DirectFunctionCall1(boolin, CStringGetDatum(bool_str)); *field_found = true; return DatumGetBool(bool_datum); } int32 ts_jsonb_get_int32_field(const Jsonb *json, const char *key, bool *field_found) { Datum int_datum; char *int_str = ts_jsonb_get_str_field(json, key); if (int_str == NULL) { *field_found = false; return 0; } int_datum = DirectFunctionCall1(int4in, CStringGetDatum(int_str)); *field_found = true; return DatumGetInt32(int_datum); } int64 ts_jsonb_get_int64_field(const Jsonb *json, const char *key, bool *field_found) { Datum int_datum; char *int_str = ts_jsonb_get_str_field(json, key); if (int_str == NULL) { *field_found = false; return 0; } int_datum = DirectFunctionCall1(int8in, CStringGetDatum(int_str)); *field_found = true; return DatumGetInt64(int_datum); } Interval * ts_jsonb_get_interval_field(const Jsonb *json, const char *key) { Datum interval_datum; char *interval_str = ts_jsonb_get_str_field(json, key); if (interval_str == NULL) return NULL; interval_datum = DirectFunctionCall3(interval_in, CStringGetDatum(interval_str), InvalidOid, -1); return DatumGetIntervalP(interval_datum); } bool ts_jsonb_equal(Jsonb *left, Jsonb *right) { /* Quick exit if both are NULL or point to same thing. */ if (left == right) return true; if (left == NULL || right == NULL) return false; Assert(left != NULL && right != NULL); Datum result = DirectFunctionCall2(jsonb_eq, PointerGetDatum(left), PointerGetDatum(right)); return DatumGetBool(result); } /* * Searches and replaces any occurrences of a matching key value pair (strings only). * Compatible with nested and array jsonbs */ Jsonb * ts_jsonb_replace_key_value_str_field(Jsonb *jb, const char *key, const char *old, const char *new, bool *replaced) { JsonbParseState *state = NULL; JsonbIterator *it; JsonbValue v, *res = NULL; JsonbIteratorToken r; *replaced = false; if (JB_ROOT_IS_SCALAR(jb)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot replace from scalar"))); if (JB_ROOT_COUNT(jb) == 0) return jb; it = JsonbIteratorInit(&jb->root); while ((r = JsonbIteratorNext(&it, &v, false)) != WJB_DONE) { if (r == WJB_KEY && v.type == jbvString && ((int) strlen(key) == v.val.string.len) && strncmp(key, v.val.string.val, v.val.string.len) == 0) { JsonbValue change_value; r = JsonbIteratorNext(&it, &change_value, false); Assert(r == WJB_VALUE); if (change_value.type != jbvString) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("Jsonb value if of type \"%s\", but expected of type string", JsonbTypeName(&change_value)))); } if (((int) strlen(old) == change_value.val.string.len) && strncmp(old, change_value.val.string.val, change_value.val.string.len) == 0) { *replaced = true; change_value.val.string.val = (char *) new; change_value.val.string.len = strlen(new); } pushJsonbValue(&state, WJB_KEY, &v); pushJsonbValue(&state, WJB_VALUE, &change_value); continue; } res = pushJsonbValue(&state, r, r < WJB_BEGIN_ARRAY ? &v : NULL); } return JsonbValueToJsonb(res); } /* * searches for any occurrences of a matching key value pair. compatible with nested and * array jsonbs */ bool ts_jsonb_has_key_value_str_field(Jsonb *jb, const char *key, const char *value) { JsonbIterator *it; JsonbValue v; JsonbIteratorToken r; if (jb == NULL || JB_ROOT_COUNT(jb) == 0) return false; if (JB_ROOT_IS_SCALAR(jb)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot find from scalar"))); it = JsonbIteratorInit(&jb->root); while ((r = JsonbIteratorNext(&it, &v, false)) != WJB_DONE) { if (r == WJB_KEY && v.type == jbvString && ((int) strlen(key) == v.val.string.len) && strncmp(key, v.val.string.val, v.val.string.len) == 0) { r = JsonbIteratorNext(&it, &v, false); Assert(r == WJB_VALUE); if (v.type != jbvString) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("Jsonb value if of type \"%s\", but expected type \"string\"", JsonbTypeName(&v)))); } if (((int) strlen(value) == v.val.string.len) && strncmp(value, v.val.string.val, v.val.string.len) == 0) { return true; } } } return false; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/jsonb_utils.h����������������������������������������������������������������0000664�0000000�0000000�00000003774�15100345067�0017361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <utils/datetime.h> #include <utils/json.h> #include <utils/jsonb.h> #include "export.h" extern TSDLLEXPORT void ts_jsonb_add_null(JsonbParseState *state, const char *key); extern TSDLLEXPORT void ts_jsonb_add_bool(JsonbParseState *state, const char *key, bool boolean); extern TSDLLEXPORT void ts_jsonb_add_str(JsonbParseState *state, const char *key, const char *value); extern TSDLLEXPORT void ts_jsonb_add_interval(JsonbParseState *state, const char *key, Interval *interval); extern TSDLLEXPORT void ts_jsonb_add_int32(JsonbParseState *state, const char *key, const int32 value); extern TSDLLEXPORT void ts_jsonb_add_int64(JsonbParseState *state, const char *key, const int64 value); extern TSDLLEXPORT void ts_jsonb_set_value_by_type(JsonbValue *value, Oid typeid, Datum datum); extern void ts_jsonb_add_value(JsonbParseState *state, const char *key, JsonbValue *value); extern TSDLLEXPORT char *ts_jsonb_get_str_field(const Jsonb *jsonb, const char *key); extern TSDLLEXPORT Interval *ts_jsonb_get_interval_field(const Jsonb *jsonb, const char *key); extern TSDLLEXPORT bool ts_jsonb_get_bool_field(const Jsonb *json, const char *key, bool *field_found); extern TSDLLEXPORT int32 ts_jsonb_get_int32_field(const Jsonb *json, const char *key, bool *field_found); extern TSDLLEXPORT int64 ts_jsonb_get_int64_field(const Jsonb *json, const char *key, bool *field_found); extern TSDLLEXPORT bool ts_jsonb_equal(Jsonb *left, Jsonb *right); extern TSDLLEXPORT Jsonb *ts_jsonb_replace_key_value_str_field(Jsonb *jb, const char *key, const char *old, const char *new, bool *replaced); extern TSDLLEXPORT bool ts_jsonb_has_key_value_str_field(Jsonb *jb, const char *key, const char *value); ����timescaledb-2.23.0/src/license_guc.c����������������������������������������������������������������0000664�0000000�0000000�00000013147�15100345067�0017274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_authid.h> #include <fmgr.h> #include <miscadmin.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/guc.h> #include "cross_module_fn.h" #include "export.h" #include "extension_constants.h" #include "license_guc.h" static bool load_enabled = false; static GucSource load_source = PGC_S_DEFAULT; static void *tsl_handle = NULL; static PGFunction tsl_init_fn = NULL; static bool tsl_register_proc_exit = false; /* * License Functions. * * License validation is performed via guc update-hooks. * In this file we check if the type of license supplied warrants loading an * additional module. * * GUC checks work in two parts: * * 1. In the check function, all validation of the new value is performed * and any auxiliary state is setup but not installed. This function * is not allowed to throw exceptions. * * 2. In the assign function all user-visible state is installed. This * function *MUST NOT FAIL* as it can be called from such places as * transaction commitment, and will cause database restarts if it fails. * * Therefore license validation also works in two parts, corresponding to * check and assign: * * 1. In the first stage we check the license type, load the submodule into * memory if needed (but don't link any of the cross-module functions yet). * * 2. In the second stage we link all of the cross-module functions and init * tsl module. * * In order for restoring libraries to work (e.g. in parallel workers), loading * the submodule must happen strictly after the main timescaledb module is * loaded. In order to ensure that the initial value doesn't break this, we * disable loading submodules until the post_load_init. * * No license change from user session is allowed. License can be changed only * if it is set from server configuration file or the server command line. */ typedef enum { LICENSE_UNDEF, LICENSE_APACHE, LICENSE_TIMESCALE } LicenseType; static LicenseType license_type_of(const char *string) { if (string == NULL) return LICENSE_UNDEF; if (strcmp(string, TS_LICENSE_TIMESCALE) == 0) return LICENSE_TIMESCALE; if (strcmp(string, TS_LICENSE_APACHE) == 0) return LICENSE_APACHE; return LICENSE_UNDEF; } bool ts_license_is_apache(void) { return license_type_of(ts_guc_license) == LICENSE_APACHE; } TSDLLEXPORT void ts_license_enable_module_loading(void) { int result; if (load_enabled) return; load_enabled = true; /* re-set the license to actually load the submodule if needed */ result = set_config_option(MAKE_EXTOPTION("license"), ts_guc_license, PGC_SUSET, load_source, GUC_ACTION_SET, true, 0, false); if (result <= 0) elog(ERROR, "invalid value for timescaledb.license: \"%s\"", ts_guc_license); } /* * TSL module load function. * * Load the module, but do not start it. Set tsl_handle and * tsl_init_fn module init function pointer (tsl/src/init.c). * * This function is idempotent, and will not reload the module * if called multiple times. */ static bool tsl_module_load(void) { void *function; void *handle; if (tsl_handle != NULL) return true; function = load_external_function(EXTENSION_TSL_SO, "ts_module_init", false, &handle); if (function == NULL || handle == NULL) return false; tsl_init_fn = function; tsl_handle = handle; /* the on_proc_exit callback is registered by the tsl_init_fn after load */ tsl_register_proc_exit = true; return true; } static void tsl_module_init(void) { Assert(tsl_handle != NULL); Assert(tsl_init_fn != NULL); DirectFunctionCall1(tsl_init_fn, BoolGetDatum(tsl_register_proc_exit)); /* register the on_proc_exit only when the module is reloaded */ if (tsl_register_proc_exit) tsl_register_proc_exit = false; } /* * Check hook function set by license guc. * * Used to validate license string before the assign hook * ts_license_guc_assign_hook() call. */ bool ts_license_guc_check_hook(char **newval, void **extra, GucSource source) { LicenseType type = license_type_of(*newval); /* Allow setting a license only if is is set from postgresql.conf * or the server command line */ switch (type) { case LICENSE_APACHE: case LICENSE_TIMESCALE: if (source == PGC_S_FILE || source == PGC_S_ARGV || source == PGC_S_DEFAULT) break; GUC_check_errdetail("Cannot change a license in a running session."); GUC_check_errhint( "Change the license in the configuration file or server command line."); return false; case LICENSE_UNDEF: GUC_check_errdetail("Unrecognized license type."); GUC_check_errhint("Supported license types are 'timescale' or 'apache'."); return false; } /* If loading is delayed, save the GucSource for later retry * in the ts_license_enable_module_loading() */ if (!load_enabled) { load_source = source; return true; } if (type == LICENSE_TIMESCALE && !tsl_module_load()) { GUC_check_errdetail("Could not find TSL timescaledb module."); GUC_check_errhint("Check that \"%s\" is available.", EXTENSION_TSL_SO); return false; } return true; } /* * Assign hook function set by license guc, executed right after * ts_license_guc_check_hook() hook call. * * Executes tsl module init function (tsl/src/init.c) which sets the * cross-module function pointers. */ void ts_license_guc_assign_hook(const char *newval, void *extra) { if (load_enabled && license_type_of(newval) == LICENSE_TIMESCALE) tsl_module_init(); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/license_guc.h����������������������������������������������������������������0000664�0000000�0000000�00000001517�15100345067�0017277�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <utils/guc.h> #include <export.h> #include <guc.h> #define TS_LICENSE_APACHE "apache" #define TS_LICENSE_TIMESCALE "timescale" /* * If compiled with APACHE_ONLY, default to using only Apache code. */ #ifdef APACHE_ONLY #define TS_LICENSE_DEFAULT TS_LICENSE_APACHE #else #define TS_LICENSE_DEFAULT TS_LICENSE_TIMESCALE #endif extern bool ts_license_guc_check_hook(char **newval, void **extra, GucSource source); extern void ts_license_guc_assign_hook(const char *newval, void *extra); extern TSDLLEXPORT void ts_license_enable_module_loading(void); extern bool ts_license_is_apache(void); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016110�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/CMakeLists.txt��������������������������������������������������������0000664�0000000�0000000�00000001432�15100345067�0020650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES loader.c bgw_message_queue.c bgw_counter.c bgw_launcher.c bgw_interface.c function_telemetry.c lwlocks.c) set(TEST_SOURCES ${PROJECT_SOURCE_DIR}/test/src/symbol_conflict.c) add_library(${PROJECT_NAME}-loader MODULE ${SOURCES}) if(CMAKE_BUILD_TYPE MATCHES Debug) # Include code for tests in Debug build target_sources(${PROJECT_NAME}-loader PRIVATE ${TEST_SOURCES}) # This define generates extension-specific code for symbol conflict testing target_compile_definitions(${PROJECT_NAME}-loader PUBLIC MODULE_NAME=loader) endif(CMAKE_BUILD_TYPE MATCHES Debug) set_target_properties(${PROJECT_NAME}-loader PROPERTIES OUTPUT_NAME ${PROJECT_NAME} PREFIX "") install(TARGETS ${PROJECT_NAME}-loader DESTINATION ${PG_PKGLIBDIR}) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/README.md�������������������������������������������������������������0000664�0000000�0000000�00000015007�15100345067�0017372�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Loader The loader has two main purposes: 1) Load the correct versioned library for each database. Multiple databases in the same Postgres instance may have different versions of TimescaleDB installed. The loader is responsible for loading the shared library corresponding to the correct TimescaleDB version for the database as soon as possible. For example, a database containing TimescaleDB version 0.8.0 will have timescaledb-0.8.0.so loaded. 2) Starting a background task called the launcher at server startup. The launcher is responsible for launching schedulers (one for each database) that are responsible for checking whether the TimescaleDB extension is installed in a database. In case of no TimescaleDB extension, the scheduler exits until it is reactivated for that database, which happens, for instance, when the extension is installed. If a scheduler finds an extension, its task is to schedule jobs for that database. The launcher controls when schedulers are started up or shut down in response to events that necessitate such actions. It also instantiates a counter from which TimescaleDB background workers are allocated to be sure we are not using more `worker_processes` than we should. # Messages the launcher may receive The launcher implements a simple message queue to be notified when it should take certain actions, like starting or restarting a scheduler for a given database. ## Message types sent to the launcher: `start`: Used to start the scheduler by the user. It is meant to be an idempotent start, as in, if it is run multiple times, it is the same as if it were run once. It is used mainly to reactivate a scheduler that the user had stopped. It does not reset the vxid of a scheduler and the started scheduler will not wait on txn finish. `stop`: Used to stop the scheduler immediately. It does not wait on a vxid and it is idempotent. `restart`: Used to either stop and restart the scheduler if it is running or start it if it is not. Technically, this would be better named `force_restart` as that better describes the action to start or restart the scheduler. The scheduler is immediately restarted, but waits on the vxid of the txn that sent the message. It is not idempotent, and will restart newly started schedulers, even while they are waiting. However, if the scheduler is already started or allocated, its "slot" is never released back to the pool, so as not to allow a job worker to "steal" a scheduler's slot during a restart. ## When/which messages are sent: Server startup: no message sent. However, the launcher takes essentially the `start` action for each database (without the message handling/signalling bit). It cannot figure out whether a scheduler should exist for a given database because it can only connect to shared catalogs. The scheduler is responsible for shutting down if it should not exist (because either TimescaleDB is not installed in the database or the version of TimescaleDB installed does not have a scheduler function to call). `CREATE DATABASE`: essentially the same as server startup. The launcher checks for new databases each time it wakes up and will start schedulers for any that it has not seen before. `CREATE EXTENSION`: the create script sends a `restart` message. It does not use the `start` message because we need to wait waiting on the vxid of the process that is running `CREATE EXTENSION`. There is also the possibility that the idempotency of the `start` action, even if it waited on a vxid, would cause race conditions in cases where the server has just started or the database has been created. `ALTER EXTENSION UPDATE`: the pre-update script sends a `restart` message. This ensures that the current scheduler is shut down as the action starts, it then waits on the vxid of the calling txn to figure out the correct version of the extension to use. `DROP EXTENSION`: sends a `restart` message, which is necessary because a rollback of the drop extension command can still happen. The scheduler therefore waits on the vxid of the txn running `DROP EXTENSION` and then will take the correct action depending on whether the extension exists when the txn finishes. `DROP DATABASE`: sends a `stop` message, causing immediate shutdown of the scheduler. This is necessary as the database cannot be dropped if there are any open connections to it (the scheduler maintains a connection to the db). # Launcher per-DB state machine The following is the state machine that the launcher maintains for each database. The CAPITAL labels are the possible states, and the `lowercase` names for messages that trigger the accompanying transitions. Transitions without labels are taken automatically whenever available resources exist. ``` stop ENABLED+--------------+ + ^--------------| | start/restart || | || | || v +v ALLOCATED+------> DISABLED ^+ stop ^ || | restart || | || | +v | STARTED+--------------+ stop / scheduler quit ``` ## The following is a detailed description of the transitions Note that `set vxid` sets a vxid variable on the scheduler. This variable is passed down to the scheduler and the scheduler waits on that vxid when it first starts. Transitions that happen automatically (at least once per poll period). * `ENABLED->ALLOCATED`: Reserved slot for worker * `ALLOCATED->STARTED`: Scheduler started * `STARTED->DISABLED`: Iff scheduler has stopped. Release slot. Transitions that happen upon getting a STOP MESSAGE: * `ENABLED->DISABLED`: No action * `ALLOCATED->DISABLED`: Release slot. * `STARTED->DISABLED`: Terminate scheduler & release slot * `DISABLED->DISABLED`: No Action Transitions that happen upon getting a START MESSAGE * Database not yet registered: Register, set to ENABLED and take ENABLED action below. * `ENABLED->ENABLED`: Try automatic transitions * `ALLOCATED->ALLOCATED`: Try automatic transitions * `STARTED->STARTED`: No action * `DISABLED->ENABLED`: Try automatic transitions Transitions that happen upon getting a RESTART MESSAGE * Database not yet registered: Register it set to ENABLED, take ENABLED actions * `ENABLED->ENABLED`: Set vxid, try automatic transitions * `ALLOCATED->ALLOCATED`: Set vxid, try automatic transitions * `STARTED->ALLOCATED`: Terminate scheduler, do /not/ release slot, set vxid, then try automatic transitions * `DISABLED->ENABLED`: Set vxid, try automatic transitions �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_counter.c���������������������������������������������������������0000664�0000000�0000000�00000010014�15100345067�0020566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* needed for initializing shared memory and using various locks */ #include <postgres.h> #include <miscadmin.h> #include <storage/ipc.h> #include <storage/latch.h> #include <storage/lwlock.h> #include <storage/shmem.h> #include <storage/spin.h> #include <utils/guc.h> #include <utils/hsearch.h> #include "bgw_counter.h" #include "extension_constants.h" #define BGW_COUNTER_STATE_NAME "ts_bgw_counter_state" int ts_guc_max_background_workers = 16; /* * We need a bit of shared state here to deal with keeping track of the total * number of background workers we've launched across the instance since we * don't want to exceed some configured value. We considered, briefly, the * possibility of using pg_sema for this, unfortunately it does not appear to * be accessible to code outside of postgres core in any meaningful way. So * we're not using that. */ typedef struct CounterState { /* * Using an slock because we're only taking it for very brief periods to * read a single value so no need for an lwlock */ slock_t mutex; /* controls modification of total_workers */ int total_workers; } CounterState; static CounterState *ct = NULL; static void bgw_counter_state_init() { bool found; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); ct = ShmemInitStruct(BGW_COUNTER_STATE_NAME, sizeof(CounterState), &found); if (!found) { memset(ct, 0, sizeof(CounterState)); SpinLockInit(&ct->mutex); ct->total_workers = 0; } LWLockRelease(AddinShmemInitLock); } extern void ts_bgw_counter_setup_gucs(void) { DefineCustomIntVariable(MAKE_EXTOPTION("max_background_workers"), "Maximum background worker processes allocated to TimescaleDB", "Max background worker processes allocated to TimescaleDB - set to at " "least 1 + number of databases in Postgres instance to use background " "workers ", &ts_guc_max_background_workers, ts_guc_max_background_workers, 0, 1000, /* no reasonable way to have more than * 1000 background workers */ PGC_POSTMASTER, 0, NULL, NULL, NULL); } /* * This gets called by the loader (and therefore the postmaster) at * shared_preload_libraries time */ extern void ts_bgw_counter_shmem_alloc(void) { RequestAddinShmemSpace(sizeof(CounterState)); } extern void ts_bgw_counter_shmem_startup(void) { bgw_counter_state_init(); } extern void ts_bgw_counter_reinit(void) { /* set counter back to zero on startup */ SpinLockAcquire(&ct->mutex); ct->total_workers = 0; SpinLockRelease(&ct->mutex); } extern bool ts_bgw_total_workers_increment_by(int increment_by) { bool incremented = false; int max_workers = ts_guc_max_background_workers; SpinLockAcquire(&ct->mutex); if (ct->total_workers + increment_by <= max_workers) { ct->total_workers += increment_by; incremented = true; } SpinLockRelease(&ct->mutex); return incremented; } extern bool ts_bgw_total_workers_increment() { return ts_bgw_total_workers_increment_by(1); } extern void ts_bgw_total_workers_decrement_by(int decrement_by) { /* * Launcher is 1 worker, and when it dies we reinitialize, so we should * never be below 1 */ SpinLockAcquire(&ct->mutex); if (ct->total_workers - decrement_by >= 1) { ct->total_workers -= decrement_by; SpinLockRelease(&ct->mutex); } else { SpinLockRelease(&ct->mutex); ereport(FATAL, (errmsg("TimescaleDB background worker cannot decrement workers below 1"), errhint("The background worker scheduler is in an invalid state and may not be " "keeping track of workers allocated to TimescaleDB properly, please " "submit a bug report."))); } } extern void ts_bgw_total_workers_decrement() { ts_bgw_total_workers_decrement_by(1); } extern int ts_bgw_total_workers_get() { int nworkers; SpinLockAcquire(&ct->mutex); nworkers = ct->total_workers; SpinLockRelease(&ct->mutex); return nworkers; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_counter.h���������������������������������������������������������0000664�0000000�0000000�00000001324�15100345067�0020577�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> extern int ts_guc_max_background_workers; extern void ts_bgw_counter_shmem_alloc(void); extern void ts_bgw_counter_shmem_startup(void); extern void ts_bgw_counter_setup_gucs(void); extern void ts_bgw_counter_reinit(void); extern bool ts_bgw_total_workers_increment(void); extern void ts_bgw_total_workers_decrement(void); extern int ts_bgw_total_workers_get(void); extern bool ts_bgw_total_workers_increment_by(int increment_by); extern void ts_bgw_total_workers_decrement_by(int decrement_by); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_interface.c�������������������������������������������������������0000664�0000000�0000000�00000005412�15100345067�0021055�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <miscadmin.h> #include "../compat/compat.h" #include "../extension_constants.h" #include "bgw_counter.h" #include "bgw_interface.h" #include "bgw_message_queue.h" /* This is where versioned-extension facing functions live. They shouldn't live anywhere else. */ /* All loader changes should always be backward compatible. * Update ts_bgw_loader_api_version if the loader changes are needed for newer extension updates. * e.g. adding a LWLock to loader is required for some future change coming to OSM extension version * xxxx. RENDEZVOUS_BGW_LOADER_API_VERSION is used to verify if the loader in use is compatible with * the current TimescaleDB version. This check happens in bgw/bgw_launcher.c When * ts_bgw_loader_api_version is updated, check the compatibility in bgw/bgw_launcher.c as well */ const int32 ts_bgw_loader_api_version = 4; TS_FUNCTION_INFO_V1(ts_bgw_worker_reserve); TS_FUNCTION_INFO_V1(ts_bgw_worker_release); TS_FUNCTION_INFO_V1(ts_bgw_num_unreserved); TS_FUNCTION_INFO_V1(ts_bgw_db_workers_start); TS_FUNCTION_INFO_V1(ts_bgw_db_workers_stop); TS_FUNCTION_INFO_V1(ts_bgw_db_workers_restart); void ts_bgw_interface_register_api_version() { void **versionptr = find_rendezvous_variable(RENDEZVOUS_BGW_LOADER_API_VERSION); /* Cast away the const to store in the rendezvous variable */ *versionptr = (void *) &ts_bgw_loader_api_version; } Datum ts_bgw_worker_reserve(PG_FUNCTION_ARGS) { PG_RETURN_BOOL(ts_bgw_total_workers_increment()); } Datum ts_bgw_worker_release(PG_FUNCTION_ARGS) { ts_bgw_total_workers_decrement(); PG_RETURN_VOID(); } Datum ts_bgw_num_unreserved(PG_FUNCTION_ARGS) { int unreserved_workers; unreserved_workers = ts_guc_max_background_workers - ts_bgw_total_workers_get(); PG_RETURN_INT32(unreserved_workers); } Datum ts_bgw_db_workers_start(PG_FUNCTION_ARGS) { if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("must be superuser to start background workers")))); PG_RETURN_BOOL(ts_bgw_message_send_and_wait(START, MyDatabaseId)); } Datum ts_bgw_db_workers_stop(PG_FUNCTION_ARGS) { if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("must be superuser to stop background workers")))); PG_RETURN_BOOL(ts_bgw_message_send_and_wait(STOP, MyDatabaseId)); } Datum ts_bgw_db_workers_restart(PG_FUNCTION_ARGS) { if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("must be superuser to restart background workers")))); PG_RETURN_BOOL(ts_bgw_message_send_and_wait(RESTART, MyDatabaseId)); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_interface.h�������������������������������������������������������0000664�0000000�0000000�00000000511�15100345067�0021055�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> extern void ts_bgw_interface_register_api_version(void); extern const int32 ts_bgw_loader_api_version; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_launcher.c��������������������������������������������������������0000664�0000000�0000000�00000100520�15100345067�0020712�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> /* BGW includes below */ /* These are always necessary for a bgworker */ #include <miscadmin.h> #include <postmaster/bgworker.h> #include <storage/ipc.h> #include <storage/latch.h> #include <storage/lwlock.h> #include <storage/proc.h> #include <storage/shmem.h> /* for setting our wait event during waitlatch*/ #include <pgstat.h> /* needed for getting database list*/ #include <access/heapam.h> #include <access/htup_details.h> #include <access/xact.h> #include <catalog/pg_database.h> #include <utils/snapmgr.h> /* and checking db list for whether we're in a template*/ #include <utils/syscache.h> /* for calling external function*/ #include <fmgr.h> /* for signal handling (specifically die() function) */ #include <tcop/tcopprot.h> /* for looking up sending proc information for message handling */ #include <storage/procarray.h> /* for allocating the htab storage */ #include <utils/memutils.h> /* for getting settings correct before loading the versioned scheduler */ #include "catalog/pg_db_role_setting.h" #include "../compat/compat.h" #include "../extension_constants.h" #include "bgw_counter.h" #include "bgw_launcher.h" #include "bgw_message_queue.h" #include "loader.h" #define BGW_DB_SCHEDULER_FUNCNAME "ts_bgw_scheduler_main" #define BGW_ENTRYPOINT_FUNCNAME "ts_bgw_db_scheduler_entrypoint" typedef enum AckResult { ACK_FAILURE = 0, ACK_SUCCESS, } AckResult; /* See state machine in README.md */ typedef enum SchedulerState { /* Scheduler should be started but has not been allocated or started */ ENABLED = 0, /* The scheduler has been allocated a spot in timescaleDB's worker counter */ ALLOCATED, /* Scheduler has been started */ STARTED, /* * Scheduler is stopped and should not be started automatically. START and * RESTART messages can re-enable the scheduler. */ DISABLED } SchedulerState; #ifdef TS_DEBUG #define BGW_LAUNCHER_RESTART_TIME_S 0 #else #define BGW_LAUNCHER_RESTART_TIME_S 60 #endif static volatile sig_atomic_t got_SIGHUP = false; int ts_guc_bgw_scheduler_restart_time_sec = BGW_NEVER_RESTART; static void launcher_sighup(SIGNAL_ARGS) { /* based on av_sighup_handler */ int save_errno = errno; got_SIGHUP = true; SetLatch(MyLatch); errno = save_errno; } /* * Main bgw launcher for the cluster. * * Run through the TimescaleDB loader, so needs to have a small footprint as * any interactions it has will need to remain backwards compatible for the * foreseeable future. * * Notes: multiple databases in an instance (PG cluster) can have TimescaleDB * installed. They are not necessarily the same version of TimescaleDB (though * they could be) Shared memory is allocated and background workers are * registered at shared_preload_libraries time We do not know what databases * exist, nor which databases TimescaleDB is installed in (if any) at * shared_preload_libraries time. */ TS_FUNCTION_INFO_V1(ts_bgw_cluster_launcher_main); TS_FUNCTION_INFO_V1(ts_bgw_db_scheduler_entrypoint); typedef struct DbHashEntry { Oid db_oid; /* key for the hash table, must be first */ BackgroundWorkerHandle *db_scheduler_handle; /* needed to shut down * properly */ SchedulerState state; VirtualTransactionId vxid; int state_transition_failures; } DbHashEntry; static void scheduler_state_trans_enabled_to_allocated(DbHashEntry *entry); static void bgw_on_postmaster_death(void) { on_exit_reset(); /* don't call exit hooks cause we want to bail * out quickly */ ereport(FATAL, (errcode(ERRCODE_ADMIN_SHUTDOWN), errmsg("postmaster exited while TimescaleDB background worker launcher was working"))); } static void report_bgw_limit_exceeded(DbHashEntry *entry) { if (entry->state_transition_failures == 0) ereport(LOG, (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), errmsg("TimescaleDB background worker limit of %d exceeded", ts_guc_max_background_workers), errhint("Consider increasing timescaledb.max_background_workers."))); entry->state_transition_failures++; } static void report_error_on_worker_register_failure(DbHashEntry *entry) { if (entry->state_transition_failures == 0) ereport(LOG, (errcode(ERRCODE_INSUFFICIENT_RESOURCES), errmsg("no available background worker slots"), errhint("Consider increasing max_worker_processes in tandem with " "timescaledb.max_background_workers."))); entry->state_transition_failures++; } /* * Aliasing a few things in bgworker.h so that we exit correctly on postmaster * death so we don't have to duplicate code basically telling it we shouldn't * call exit hooks cause we want to bail out quickly - similar to how the * quickdie function works when we receive a sigquit. This should work * similarly because postmaster death is a similar severity of issue. * Additionally, we're wrapping these calls to make sure we never have a NULL * handle, if we have a null handle, we return normal things. */ static BgwHandleStatus get_background_worker_pid(BackgroundWorkerHandle *handle, pid_t *pidp) { BgwHandleStatus status; pid_t pid; if (handle == NULL) status = BGWH_STOPPED; else { status = GetBackgroundWorkerPid(handle, &pid); if (pidp != NULL) *pidp = pid; } if (status == BGWH_POSTMASTER_DIED) bgw_on_postmaster_death(); return status; } static void wait_for_background_worker_startup(BackgroundWorkerHandle *handle, pid_t *pidp) { BgwHandleStatus status; if (handle == NULL) status = BGWH_STOPPED; else status = WaitForBackgroundWorkerStartup(handle, pidp); /* * We don't care whether we get BGWH_STOPPED or BGWH_STARTED here, because * the worker could have started and stopped very quickly before we read * it. We can't get BGWH_NOT_YET_STARTED as that's what we're waiting for. * We do care if the Postmaster died however. */ if (status == BGWH_POSTMASTER_DIED) bgw_on_postmaster_death(); Assert(status == BGWH_STOPPED || status == BGWH_STARTED); } static void wait_for_background_worker_shutdown(BackgroundWorkerHandle *handle) { BgwHandleStatus status; if (handle == NULL) status = BGWH_STOPPED; else status = WaitForBackgroundWorkerShutdown(handle); /* We can only ever get BGWH_STOPPED stopped unless the Postmaster died. */ if (status == BGWH_POSTMASTER_DIED) bgw_on_postmaster_death(); Assert(status == BGWH_STOPPED); } static void terminate_background_worker(BackgroundWorkerHandle *handle) { if (handle == NULL) return; else TerminateBackgroundWorker(handle); } static bool check_scheduler_restart_time(int *newval, void **extra, GucSource source) { if (*newval == -1 || *newval >= 10) return true; GUC_check_errdetail("Scheduler restart time must be be either -1 or at least 10 seconds."); return false; } extern void ts_bgw_cluster_launcher_init(void) { BackgroundWorker worker; DefineCustomIntVariable(/* name= */ MAKE_EXTOPTION("bgw_scheduler_restart_time"), /* short_desc= */ "Restart time for scheduler in seconds", /* long_desc= */ "The number of seconds until the scheduler restart on failure, or zero " "if it should never restart.", /* valueAddr= */ &ts_guc_bgw_scheduler_restart_time_sec, /* bootValue= */ BGW_NEVER_RESTART, /* minValue= */ -1, /* maxValue= */ 3600, /* context= */ PGC_SIGHUP, /* flags= */ GUC_UNIT_S, /* check_hook= */ check_scheduler_restart_time, /* assign_hook= */ NULL, /* show_hook= */ NULL); memset(&worker, 0, sizeof(worker)); /* set up worker settings for our main worker */ snprintf(worker.bgw_name, BGW_MAXLEN, TS_BGW_TYPE_LAUNCHER); worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_restart_time = BGW_LAUNCHER_RESTART_TIME_S; /* * Starting at BgWorkerStart_RecoveryFinished means we won't ever get * started on a hot_standby see * https://www.postgresql.org/docs/10/static/bgworker.html as it's not * documented in bgworker.c. */ worker.bgw_start_time = BgWorkerStart_RecoveryFinished; worker.bgw_notify_pid = 0; snprintf(worker.bgw_library_name, BGW_MAXLEN, EXTENSION_NAME); snprintf(worker.bgw_function_name, BGW_MAXLEN, "ts_bgw_cluster_launcher_main"); RegisterBackgroundWorker(&worker); } /* * Register a background worker that calls the main TimescaleDB background * worker launcher library (i.e. loader) and uses the scheduler entrypoint * function. The scheduler entrypoint will deal with starting a new worker, * and waiting on any txns that it needs to, if we pass along a vxid in the * bgw_extra field of the BgWorker. */ static bool register_entrypoint_for_db(Oid db_id, VirtualTransactionId vxid, BackgroundWorkerHandle **handle) { BackgroundWorker worker; int restart_time_sec = ts_guc_bgw_scheduler_restart_time_sec; /* BGW_NEVER_RESTART is typically -1, but we check that explicitly here in * case PostgreSQL changes it. Compiler should optimize this away if they * are the same. */ if (restart_time_sec == -1) restart_time_sec = BGW_NEVER_RESTART; memset(&worker, 0, sizeof(worker)); snprintf(worker.bgw_type, BGW_MAXLEN, TS_BGW_TYPE_SCHEDULER); snprintf(worker.bgw_name, BGW_MAXLEN, "%s for database %d", TS_BGW_TYPE_SCHEDULER, db_id); worker.bgw_flags = BGWORKER_SHMEM_ACCESS | BGWORKER_BACKEND_DATABASE_CONNECTION; worker.bgw_restart_time = restart_time_sec; worker.bgw_start_time = BgWorkerStart_RecoveryFinished; snprintf(worker.bgw_library_name, BGW_MAXLEN, EXTENSION_NAME); snprintf(worker.bgw_function_name, BGW_MAXLEN, BGW_ENTRYPOINT_FUNCNAME); worker.bgw_notify_pid = MyProcPid; worker.bgw_main_arg = ObjectIdGetDatum(db_id); memcpy(worker.bgw_extra, &vxid, sizeof(VirtualTransactionId)); return RegisterDynamicBackgroundWorker(&worker, handle); } /* Initializes the launcher's hash table of schedulers. * Return value is guaranteed to be not-null, because otherwise the function * will have thrown an error. */ static HTAB * init_database_htab(void) { HASHCTL info = { .keysize = sizeof(Oid), .entrysize = sizeof(DbHashEntry), .hcxt = TopMemoryContext }; return hash_create("launcher_db_htab", ts_guc_max_background_workers, &info, HASH_BLOBS | HASH_CONTEXT | HASH_ELEM); } /* Insert a scheduler entry into the hash table. Correctly set entry values. */ static DbHashEntry * db_hash_entry_create_if_not_exists(HTAB *db_htab, Oid db_oid) { DbHashEntry *db_he; bool found; db_he = (DbHashEntry *) hash_search(db_htab, &db_oid, HASH_ENTER, &found); if (!found) { db_he->db_scheduler_handle = NULL; db_he->state = ENABLED; SetInvalidVirtualTransactionId(db_he->vxid); db_he->state_transition_failures = 0; /* * Try to allocate a spot right away to give schedulers priority over * other bgws. This is especially important on initial server startup * where we want to reserve slots for all schedulers before starting * any. This is done so that background workers started by schedulers * don't race for open slots with other schedulers on startup. */ scheduler_state_trans_enabled_to_allocated(db_he); } return db_he; } /* * Result from signalling a backend. * * Error codes are non-zero, and success is zero. */ enum SignalBackendResult { SIGNAL_BACKEND_SUCCESS = 0, SIGNAL_BACKEND_ERROR, SIGNAL_BACKEND_NOPERMISSION, SIGNAL_BACKEND_NOSUPERUSER, }; /* * Terminate a background worker. * * This is copied from pg_signal_backend() in * src/backend/storage/ipc/signalfuncs.c but tweaked to not require a database * connection since the launcher does not have one. */ static enum SignalBackendResult ts_signal_backend(int pid, int sig) { PGPROC *proc = BackendPidGetProc(pid); if (unlikely(proc == NULL)) { ereport(WARNING, (errmsg("PID %d is not a PostgreSQL backend process", pid))); return SIGNAL_BACKEND_ERROR; } if (unlikely(kill(pid, sig))) { /* Again, just a warning to allow loops */ ereport(WARNING, (errmsg("could not send signal to process %d: %m", pid))); return SIGNAL_BACKEND_ERROR; } return SIGNAL_BACKEND_SUCCESS; } /* * Terminate backends by backend type. * * We iterate through all backends and mark those that match the given backend * type as terminated. * * Note that there is potentially a delay between marking backends as * terminated and their actual termination, so the backends have to be able to * run even if there are multiple instances accessing the same data. * * Parts of this code is taken from pg_stat_get_activity() in * src/backend/utils/adt/pgstatfuncs.c. */ static void terminate_backends_by_backend_type(const char *backend_type) { Assert(backend_type); const int num_backends = pgstat_fetch_stat_numbackends(); for (int curr_backend = 1; curr_backend <= num_backends; ++curr_backend) { const LocalPgBackendStatus *local_beentry = pgstat_get_local_beentry_by_index_compat(curr_backend); const PgBackendStatus *beentry = &local_beentry->backendStatus; const char *bgw_type = GetBackgroundWorkerTypeByPid(beentry->st_procpid); if (bgw_type && strcmp(backend_type, bgw_type) == 0) { int error = ts_signal_backend(beentry->st_procpid, SIGTERM); if (error) elog(LOG, "failed to terminate backend with pid %d", beentry->st_procpid); } } } /* * Model this on autovacuum.c -> get_database_list. * * Note that we are not doing all the things around memory context that they * do, because the hashtable we're using to store db entries is automatically * created in its own memory context (a child of TopMemoryContext) This can * get called at two different times 1) when the cluster launcher starts and * is looking for dbs and 2) if it restarts due to a postmaster signal. */ static void populate_database_htab(HTAB *db_htab) { Relation rel; TableScanDesc scan; HeapTuple tup; /* * by this time we should already be connected to the db, and only have * access to shared catalogs */ StartTransactionCommand(); (void) GetTransactionSnapshot(); rel = table_open(DatabaseRelationId, AccessShareLock); scan = table_beginscan_catalog(rel, 0, NULL); while (HeapTupleIsValid(tup = heap_getnext(scan, ForwardScanDirection))) { Form_pg_database pgdb = (Form_pg_database) GETSTRUCT(tup); if (!pgdb->datallowconn || pgdb->datistemplate) continue; /* don't bother with dbs that don't allow * connections or are templates */ db_hash_entry_create_if_not_exists(db_htab, pgdb->oid); } table_endscan(scan); table_close(rel, AccessShareLock); CommitTransactionCommand(); } static void scheduler_modify_state(DbHashEntry *entry, SchedulerState new_state) { Assert(entry->state != new_state); entry->state_transition_failures = 0; entry->state = new_state; } /* TRANSITION FUNCTIONS */ static void scheduler_state_trans_disabled_to_enabled(DbHashEntry *entry) { Assert(entry->state == DISABLED); Assert(entry->db_scheduler_handle == NULL); scheduler_modify_state(entry, ENABLED); } static void scheduler_state_trans_enabled_to_allocated(DbHashEntry *entry) { Assert(entry->state == ENABLED); Assert(entry->db_scheduler_handle == NULL); /* Reserve a spot for this scheduler with BGW counter */ if (!ts_bgw_total_workers_increment()) { report_bgw_limit_exceeded(entry); return; } scheduler_modify_state(entry, ALLOCATED); } static void scheduler_state_trans_started_to_allocated(DbHashEntry *entry) { Assert(entry->state == STARTED); Assert(get_background_worker_pid(entry->db_scheduler_handle, NULL) == BGWH_STOPPED); if (entry->db_scheduler_handle != NULL) { pfree(entry->db_scheduler_handle); entry->db_scheduler_handle = NULL; } scheduler_modify_state(entry, ALLOCATED); } static void scheduler_state_trans_allocated_to_started(DbHashEntry *entry) { pid_t worker_pid; bool worker_registered; Assert(entry->state == ALLOCATED); Assert(entry->db_scheduler_handle == NULL); worker_registered = register_entrypoint_for_db(entry->db_oid, entry->vxid, &entry->db_scheduler_handle); if (!worker_registered) { report_error_on_worker_register_failure(entry); return; } wait_for_background_worker_startup(entry->db_scheduler_handle, &worker_pid); SetInvalidVirtualTransactionId(entry->vxid); scheduler_modify_state(entry, STARTED); } static void scheduler_state_trans_enabled_to_disabled(DbHashEntry *entry) { Assert(entry->state == ENABLED); Assert(entry->db_scheduler_handle == NULL); scheduler_modify_state(entry, DISABLED); } static void scheduler_state_trans_allocated_to_disabled(DbHashEntry *entry) { Assert(entry->state == ALLOCATED); Assert(entry->db_scheduler_handle == NULL); ts_bgw_total_workers_decrement(); scheduler_modify_state(entry, DISABLED); } static void scheduler_state_trans_started_to_disabled(DbHashEntry *entry) { Assert(entry->state == STARTED); Assert(get_background_worker_pid(entry->db_scheduler_handle, NULL) == BGWH_STOPPED); ts_bgw_total_workers_decrement(); if (entry->db_scheduler_handle != NULL) { pfree(entry->db_scheduler_handle); entry->db_scheduler_handle = NULL; } scheduler_modify_state(entry, DISABLED); } static void scheduler_state_trans_automatic(DbHashEntry *entry) { switch (entry->state) { case ENABLED: scheduler_state_trans_enabled_to_allocated(entry); if (entry->state == ALLOCATED) scheduler_state_trans_allocated_to_started(entry); break; case ALLOCATED: scheduler_state_trans_allocated_to_started(entry); break; case STARTED: if (get_background_worker_pid(entry->db_scheduler_handle, NULL) == BGWH_STOPPED) scheduler_state_trans_started_to_disabled(entry); break; case DISABLED: break; } } static void scheduler_state_trans_automatic_all(HTAB *db_htab) { HASH_SEQ_STATUS hash_seq; DbHashEntry *current_entry; hash_seq_init(&hash_seq, db_htab); while ((current_entry = hash_seq_search(&hash_seq)) != NULL) scheduler_state_trans_automatic(current_entry); } /* This is called when we're going to shut down so we don't leave things messy*/ static void launcher_pre_shmem_cleanup(int code, Datum arg) { HTAB *db_htab = *(HTAB **) DatumGetPointer(arg); HASH_SEQ_STATUS hash_seq; DbHashEntry *current_entry; /* db_htab will be NULL if we fail during init_database_htab */ if (db_htab != NULL) { hash_seq_init(&hash_seq, db_htab); /* * Stop everyone (or at least tell the Postmaster we don't care about * them anymore) */ while ((current_entry = hash_seq_search(&hash_seq)) != NULL) { if (current_entry->db_scheduler_handle != NULL) { terminate_background_worker(current_entry->db_scheduler_handle); pfree(current_entry->db_scheduler_handle); } } hash_destroy(db_htab); } /* * Reset our pid in the queue so that others know we've died and don't * wait forever */ ts_bgw_message_queue_shmem_cleanup(); } /* ************* * Actions for message types we could receive off of the bgw_message_queue. ************* */ /* * This should be idempotent. If we find the background worker and it's not * stopped, do nothing. In order to maintain idempotency, a scheduler in the * ENABLED, ALLOCATED or STARTED state cannot get a new vxid to wait on. (We * cannot pass in a new vxid to wait on for an already-started scheduler in any * case). This means that actions like restart, which are not idempotent, will * not have their effects changed by subsequent start actions, no matter the * state they are in when the start action is received. */ static AckResult message_start_action(HTAB *db_htab, BgwMessage *message) { DbHashEntry *entry; entry = db_hash_entry_create_if_not_exists(db_htab, message->db_oid); if (entry->state == DISABLED) scheduler_state_trans_disabled_to_enabled(entry); scheduler_state_trans_automatic(entry); return (entry->state == STARTED ? ACK_SUCCESS : ACK_FAILURE); } static AckResult message_stop_action(HTAB *db_htab, BgwMessage *message) { DbHashEntry *entry; /* * If the entry does not exist try to create it so we can put it in the * DISABLED state. Otherwise, it will be created during the next poll and * then will end up in the ENABLED state and proceed to being STARTED. But * this is not the behavior we want. */ entry = db_hash_entry_create_if_not_exists(db_htab, message->db_oid); switch (entry->state) { case ENABLED: scheduler_state_trans_enabled_to_disabled(entry); break; case ALLOCATED: scheduler_state_trans_allocated_to_disabled(entry); break; case STARTED: terminate_background_worker(entry->db_scheduler_handle); wait_for_background_worker_shutdown(entry->db_scheduler_handle); scheduler_state_trans_started_to_disabled(entry); break; case DISABLED: break; } return entry->state == DISABLED ? ACK_SUCCESS : ACK_FAILURE; } /* * This function will stop and restart a scheduler in the STARTED state, ENABLE * a scheduler if it does not exist or is in the DISABLED state and set the vxid * to wait on for a scheduler in any state. It is not idempotent. Additionally, * one might think that this function would simply be a combination of stop and * start above, but it is not as we maintain the worker's "slot" by never * releasing the worker from our "pool" of background workers as stopping and * starting would. We don't want a race condition where some other db steals * the scheduler of the other by requesting a worker at the wrong time. (This is * accomplished by moving from STARTED to ALLOCATED after shutting down the * worker, never releasing the entry and transitioning all the way back to * ENABLED). */ static AckResult message_restart_action(HTAB *db_htab, BgwMessage *message, VirtualTransactionId vxid) { DbHashEntry *entry; entry = db_hash_entry_create_if_not_exists(db_htab, message->db_oid); entry->vxid = vxid; switch (entry->state) { case ENABLED: break; case ALLOCATED: break; case STARTED: terminate_background_worker(entry->db_scheduler_handle); wait_for_background_worker_shutdown(entry->db_scheduler_handle); scheduler_state_trans_started_to_allocated(entry); break; case DISABLED: scheduler_state_trans_disabled_to_enabled(entry); } scheduler_state_trans_automatic(entry); return entry->state == STARTED ? ACK_SUCCESS : ACK_FAILURE; } /* * Handle 1 message. */ static bool launcher_handle_message(HTAB *db_htab) { BgwMessage *message = ts_bgw_message_receive(); PGPROC *sender; VirtualTransactionId vxid; AckResult action_result = ACK_FAILURE; if (message == NULL) return false; sender = BackendPidGetProc(message->sender_pid); if (sender == NULL) { ereport(LOG, (errmsg("TimescaleDB background worker launcher received message from non-existent " "backend"))); return true; } GET_VXID_FROM_PGPROC(vxid, *sender); switch (message->message_type) { case START: action_result = message_start_action(db_htab, message); break; case STOP: action_result = message_stop_action(db_htab, message); break; case RESTART: action_result = message_restart_action(db_htab, message, vxid); break; } ts_bgw_message_send_ack(message, action_result); return true; } /* * The default, `bgworker_die()`, can't be used due to the fact that it * handles signals synchronously, rather than waiting for a * CHECK_FOR_INTERRUPTS(). `die()` (which is arguably misnamed) sets flags * that will cause the backend to exit on the next call to * CHECK_FOR_INTERRUPTS(), which can happen either in our code or in functions * within the Postgres codebase that we call. This means that we don't need to * wait for the next time control is returned to our loop to exit, which would * be necessary if we set our own flag and checked it in a loop * condition. However, because it cannot exit 0, the launcher will be * restarted by the postmaster, even when it has received a SIGTERM, which we * decided was the proper behavior. If users want to disable the launcher, * they can set `timescaledb.max_background_workers = 0` and then we will * `proc_exit(0)` before doing anything else. */ extern Datum ts_bgw_cluster_launcher_main(PG_FUNCTION_ARGS) { HTAB **htab_storage; HTAB *db_htab; pqsignal(SIGINT, StatementCancelHandler); pqsignal(SIGTERM, die); pqsignal(SIGHUP, launcher_sighup); /* Some SIGHUPS may already have been dropped, so we must load the file here */ got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); BackgroundWorkerUnblockSignals(); ereport(DEBUG1, (errmsg("TimescaleDB background worker launcher started"))); /* set counter back to zero on restart */ ts_bgw_counter_reinit(); if (!ts_bgw_total_workers_increment()) { /* * Should be the first thing happening so if we already exceeded our * limits it means we have a limit of 0 and we should just exit We * have to exit(0) because if we exit in error we get restarted by the * postmaster. */ ereport(LOG, (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), errmsg("TimescaleDB background worker is set to 0"), errhint("TimescaleDB background worker launcher shutting down."))); proc_exit(0); } /* Connect to the db, no db name yet, so can only access shared catalogs */ BackgroundWorkerInitializeConnection(NULL, NULL, 0); pgstat_report_appname(MyBgworkerEntry->bgw_name); ereport(LOG, (errmsg("TimescaleDB background worker launcher connected to shared catalogs"))); htab_storage = (HTAB **) MemoryContextAllocZero(TopMemoryContext, sizeof(void *)); /* * We must setup the cleanup function _before_ initializing any state it * touches (specifically the bgw_message_queue and db_htab). Failing to do * this can cause cascading failures when the launcher fails in * init_database_htab (eg. due to running out of shared memory) but * doesn't deregister itself from the shared bgw_message_queue. */ before_shmem_exit(launcher_pre_shmem_cleanup, PointerGetDatum(htab_storage)); ts_bgw_message_queue_set_reader(); db_htab = init_database_htab(); *htab_storage = db_htab; /* * If the launcher was restarted and discovers old schedulers, these has * to be terminated to avoid exhausting the worker slots. * * We cannot easily pick up the old schedulers since we do not have access * to the slots array in PostgreSQL, so instead we scan for something that * looks like schedulers for databases, and kill them. New ones will then * be spawned below. */ terminate_backends_by_backend_type(TS_BGW_TYPE_SCHEDULER); populate_database_htab(db_htab); while (true) { int wl_rc; bool handled_msgs = false; CHECK_FOR_INTERRUPTS(); populate_database_htab(db_htab); handled_msgs = launcher_handle_message(db_htab); scheduler_state_trans_automatic_all(db_htab); if (handled_msgs) continue; wl_rc = WaitLatch(MyLatch, WL_LATCH_SET | WL_POSTMASTER_DEATH | WL_TIMEOUT, (long) ts_guc_bgw_launcher_poll_time, PG_WAIT_EXTENSION); ResetLatch(MyLatch); if (wl_rc & WL_POSTMASTER_DEATH) bgw_on_postmaster_death(); if (got_SIGHUP) { got_SIGHUP = false; ProcessConfigFile(PGC_SIGHUP); } } PG_RETURN_VOID(); } /* * Inside the entrypoint, we must check again if we're in a template db * even though we excluded template dbs in populate_database_htab because * we can be called on, say, CREATE EXTENSION in a template db and then * we'll not stop til next server shutdown so if we hit this point and are * in a template db, we throw an error and shut down Check in the syscache * rather than searching through the entire database catalog again. * Modelled on autovacuum.c -> do_autovacuum. */ static void database_checks(void) { Form_pg_database pgdb; HeapTuple tuple; tuple = SearchSysCache1(DATABASEOID, ObjectIdGetDatum(MyDatabaseId)); if (!HeapTupleIsValid(tuple)) ereport(ERROR, (errmsg("TimescaleDB background worker failed to find entry for database in " "syscache"))); pgdb = (Form_pg_database) GETSTRUCT(tuple); if (!pgdb->datallowconn) ereport(ERROR, (errmsg("background worker \"%s\" trying to connect to database that does not " "allow connections, exiting", MyBgworkerEntry->bgw_name))); if (pgdb->datistemplate) ereport(ERROR, (errmsg("background worker \"%s\" trying to connect to template database, exiting", MyBgworkerEntry->bgw_name))); ReleaseSysCache(tuple); } /* * Before we morph into the scheduler, we also need to reload configs from their * defaults if the database default has changed. Defaults are changed in the * post_restore function where we change the db default for the restoring guc * wait until the txn commits and then must see if the txn made the change. * Checks for changes are normally run at connection startup, but because we * have to connect in order to wait on the txn we have to re-run after the wait. * This function is based on the postgres function in postinit.c by the same * name. */ static void process_settings(Oid databaseid) { Relation relsetting; Snapshot snapshot; if (!IsUnderPostmaster) return; relsetting = table_open(DbRoleSettingRelationId, AccessShareLock); /* read all the settings under the same snapshot for efficiency */ snapshot = RegisterSnapshot(GetCatalogSnapshot(DbRoleSettingRelationId)); /* Later settings are ignored if set earlier. */ ApplySetting(snapshot, databaseid, InvalidOid, relsetting, PGC_S_DATABASE); ApplySetting(snapshot, InvalidOid, InvalidOid, relsetting, PGC_S_GLOBAL); UnregisterSnapshot(snapshot); table_close(relsetting, AccessShareLock); } /* * Get the versioned scheduler for the database. * * This captures any errors generated while fetching information and print * them out, but does not propagate the error further since that might trigger * a restart. */ static PGFunction get_versioned_scheduler() { volatile PGFunction versioned_scheduler_main = NULL; PG_TRY(); { bool ts_installed = false; char version[MAX_VERSION_LEN]; /* * now we can start our transaction and get the version currently * installed */ StartTransactionCommand(); (void) GetTransactionSnapshot(); /* * Check whether a database is a template database and raise an error if * so, as we don't want to run in template dbs. */ database_checks(); /* Process any config changes caused by an ALTER DATABASE */ process_settings(MyDatabaseId); ts_installed = ts_loader_extension_exists(); if (ts_installed) strlcpy(version, ts_loader_extension_version(), MAX_VERSION_LEN); ts_loader_extension_check(); CommitTransactionCommand(); if (ts_installed) { char soname[MAX_SO_NAME_LEN]; snprintf(soname, MAX_SO_NAME_LEN, "%s-%s", EXTENSION_SO, version); versioned_scheduler_main = load_external_function(soname, BGW_DB_SCHEDULER_FUNCNAME, false, NULL); if (versioned_scheduler_main == NULL) ereport(ERROR, (errmsg("TimescaleDB version %s does not have a background worker, exiting", soname))); } } PG_CATCH(); { EmitErrorReport(); FlushErrorState(); } PG_END_TRY(); return versioned_scheduler_main; } /* * This can be run either from the cluster launcher at db_startup time, or * in the case of an install/uninstall/update of the extension, in the * first case, we have no vxid that we're waiting on. In the second case, * we do, because we have to wait so that we see the effects of said txn. * So we wait for it to finish, then we morph into the new db_scheduler * worker using whatever version is now installed (or exit gracefully if * no version is now installed). */ extern Datum ts_bgw_db_scheduler_entrypoint(PG_FUNCTION_ARGS) { Oid db_id = DatumGetObjectId(MyBgworkerEntry->bgw_main_arg); VirtualTransactionId vxid; pqsignal(SIGINT, StatementCancelHandler); pqsignal(SIGTERM, die); BackgroundWorkerUnblockSignals(); /* * Connecting to a database that does not allow connections will generate * a FATAL error, which might trigger restarts, so we override this check * and do it ourselves. */ BackgroundWorkerInitializeConnectionByOid(db_id, InvalidOid, BGWORKER_BYPASS_ALLOWCONN); pgstat_report_appname(MyBgworkerEntry->bgw_name); /* * Wait until whatever vxid that potentially called us finishes before we * happens in a txn so it's cleaned up correctly if we get a sigkill in * the meantime, but we will need stop after and take a new txn so we can * see the correct state after its effects */ StartTransactionCommand(); (void) GetTransactionSnapshot(); memcpy(&vxid, MyBgworkerEntry->bgw_extra, sizeof(VirtualTransactionId)); if (VirtualTransactionIdIsValid(vxid)) VirtualXactLock(vxid, true); CommitTransactionCommand(); /* * Essentially we morph into the versioned worker here, if there is one. * * If an error is generated here, we should trigger a restart (if the * scheduler is configured for that). */ PGFunction versioned_scheduler_main = get_versioned_scheduler(); if (versioned_scheduler_main) DirectFunctionCall1(versioned_scheduler_main, ObjectIdGetDatum(InvalidOid)); PG_RETURN_VOID(); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_launcher.h��������������������������������������������������������0000664�0000000�0000000�00000001254�15100345067�0020723�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #define TS_BGW_TYPE_LAUNCHER "TimescaleDB Background Worker Launcher" #define TS_BGW_TYPE_SCHEDULER "TimescaleDB Background Worker Scheduler" extern int ts_guc_bgw_scheduler_restart_time_sec; extern void ts_bgw_cluster_launcher_init(void); /*called by postmaster at launcher bgw startup*/ TSDLLEXPORT extern Datum ts_bgw_cluster_launcher_main(PG_FUNCTION_ARGS); TSDLLEXPORT extern Datum ts_bgw_db_scheduler_entrypoint(PG_FUNCTION_ARGS); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_message_queue.c���������������������������������������������������0000664�0000000�0000000�00000027667�15100345067�0021765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <miscadmin.h> #include <pgstat.h> #include <storage/lwlock.h> #include <storage/proc.h> #include <storage/procarray.h> #include <storage/shm_mq.h> #include <storage/shmem.h> #include <storage/spin.h> #include "../compat/compat.h" #include "bgw_message_queue.h" #define BGW_MQ_MAX_MESSAGES 16 #define BGW_MQ_NAME "ts_bgw_message_queue" #define BGW_MQ_TRANCHE_NAME "ts_bgw_mq_tranche" #define BGW_MQ_NUM_WAITS 100 /* WaitLatch expects a long */ #define BGW_MQ_WAIT_INTERVAL 1000L #define BGW_ACK_RETRIES 20 /* WaitLatch expects a long */ #define BGW_ACK_WAIT_INTERVAL 100L #define BGW_ACK_QUEUE_SIZE (MAXALIGN(shm_mq_minimum_size + sizeof(int))) /* We're using a relatively simple implementation of a circular queue similar to: * http://opendatastructures.org/ods-python/2_3_ArrayQueue_Array_Based_.html */ typedef struct MessageQueue { pid_t reader_pid; /* Should only be set once at cluster launcher * startup */ slock_t mutex; /* Controls access to the reader pid */ LWLock *lock; /* Pointer to the lock to control * adding/removing elements from queue */ uint8 read_upto; uint8 num_elements; BgwMessage buffer[BGW_MQ_MAX_MESSAGES]; } MessageQueue; typedef enum QueueResponseType { MESSAGE_SENT = 0, QUEUE_FULL, READER_DETACHED } QueueResponseType; static MessageQueue *mq = NULL; /* * This is run during the shmem_startup_hook. * On Linux, it's only run once, but in EXEC_BACKEND mode / on Windows/ other systems * that do forking differently, it is run in every backend at startup */ static void queue_init() { bool found; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); mq = ShmemInitStruct(BGW_MQ_NAME, sizeof(MessageQueue), &found); if (!found) { memset(mq, 0, sizeof(MessageQueue)); mq->reader_pid = InvalidPid; SpinLockInit(&mq->mutex); mq->lock = &(GetNamedLWLockTranche(BGW_MQ_TRANCHE_NAME))->lock; } LWLockRelease(AddinShmemInitLock); } /* This gets called when shared memory is initialized in a backend * (shmem_startup_hook) */ extern void ts_bgw_message_queue_shmem_startup(void) { queue_init(); } /* This is called in the loader during server startup to allocate a shared * memory segment*/ extern void ts_bgw_message_queue_alloc(void) { RequestAddinShmemSpace(sizeof(MessageQueue)); RequestNamedLWLockTranche(BGW_MQ_TRANCHE_NAME, 1); } /* * Notes on managing the queue/locking: We decided that for this application, * simplicity of locking scheme was more important than being very good about * concurrency as the frequency of these messages will be low and the number * of messages on this queue should be low, given that they mostly happen when * we update the extension. Therefore we decided to simply take an exclusive * lock whenever we were modifying anything in the shared memory segment to * avoid collisions. */ static pid_t queue_get_reader(MessageQueue *queue) { pid_t reader; volatile MessageQueue *vq = queue; SpinLockAcquire(&vq->mutex); reader = vq->reader_pid; SpinLockRelease(&vq->mutex); return reader; } static void queue_set_reader(MessageQueue *queue) { volatile MessageQueue *vq = queue; pid_t reader_pid; SpinLockAcquire(&vq->mutex); if (vq->reader_pid == InvalidPid) { vq->reader_pid = MyProcPid; } reader_pid = vq->reader_pid; SpinLockRelease(&vq->mutex); if (reader_pid != MyProcPid) ereport(ERROR, (errmsg("only one reader allowed for TimescaleDB background worker message queue"), errhint("Current process is %d.", reader_pid))); } static void queue_reset_reader(MessageQueue *queue) { volatile MessageQueue *vq = queue; bool reset = false; SpinLockAcquire(&vq->mutex); if (vq->reader_pid == MyProcPid) { reset = true; vq->reader_pid = InvalidPid; } SpinLockRelease(&vq->mutex); if (!reset) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("multiple TimescaleDB background worker launchers have been started when " "only one is allowed"))); } /* Add a message to the queue - we can do this if the queue is not full */ static QueueResponseType queue_add(MessageQueue *queue, BgwMessage *message) { QueueResponseType message_result = QUEUE_FULL; LWLockAcquire(queue->lock, LW_EXCLUSIVE); if (queue->num_elements < BGW_MQ_MAX_MESSAGES) { memcpy(&queue->buffer[(queue->read_upto + queue->num_elements) % BGW_MQ_MAX_MESSAGES], message, sizeof(BgwMessage)); queue->num_elements++; message_result = MESSAGE_SENT; } LWLockRelease(queue->lock); if (queue_get_reader(queue) != InvalidPid) SetLatch(&BackendPidGetProc(queue_get_reader(queue))->procLatch); else message_result = READER_DETACHED; return message_result; } static BgwMessage * queue_remove(MessageQueue *queue) { BgwMessage *message = NULL; LWLockAcquire(queue->lock, LW_EXCLUSIVE); if (queue_get_reader(queue) != MyProcPid) ereport(ERROR, (errmsg( "cannot read if not reader for TimescaleDB background worker message queue"))); if (queue->num_elements > 0) { message = palloc(sizeof(BgwMessage)); memcpy(message, &queue->buffer[queue->read_upto], sizeof(BgwMessage)); queue->read_upto = (queue->read_upto + 1) % BGW_MQ_MAX_MESSAGES; queue->num_elements--; } LWLockRelease(queue->lock); return message; } /* Construct a message */ static BgwMessage * bgw_message_create(BgwMessageType message_type, Oid db_oid) { BgwMessage *message = palloc(sizeof(BgwMessage)); dsm_segment *seg; seg = dsm_create(BGW_ACK_QUEUE_SIZE, 0); *message = (BgwMessage){ .message_type = message_type, .sender_pid = MyProcPid, .db_oid = db_oid, .ack_dsm_handle = dsm_segment_handle(seg) }; return message; } /* * Our own version of shm_mq_wait_for_attach that waits with a timeout so that * should our counterparty die before attaching, we don't end up hanging. */ static shm_mq_result ts_shm_mq_wait_for_attach(MessageQueue *queue, shm_mq_handle *ack_queue_handle) { int n; PGPROC *reader_proc; for (n = 1; n <= BGW_MQ_NUM_WAITS; n++) { /* The reader is the sender on the ack queue */ reader_proc = shm_mq_get_sender(shm_mq_get_queue(ack_queue_handle)); if (reader_proc != NULL) return SHM_MQ_SUCCESS; else if (queue_get_reader(queue) == InvalidPid) return SHM_MQ_DETACHED; /* Reader died after we enqueued our * message */ WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, BGW_MQ_WAIT_INTERVAL, WAIT_EVENT_MESSAGE_QUEUE_INTERNAL); ResetLatch(MyLatch); CHECK_FOR_INTERRUPTS(); } return SHM_MQ_DETACHED; } static bool enqueue_message_wait_for_ack(MessageQueue *queue, BgwMessage *message, shm_mq_handle *ack_queue_handle) { Size bytes_received = 0; QueueResponseType send_result; bool *data = NULL; shm_mq_result mq_res; bool ack_received = false; int n; /* * We don't want the process restarting workers to really distinguish the * reasons workers might or might not be restarted, and we don't really * want them to error when workers can't be started, as there are multiple * valid reasons for that. So we'll simply return false for the ack even * if we can't attach to the queue etc. */ send_result = queue_add(queue, message); if (send_result != MESSAGE_SENT) return false; mq_res = ts_shm_mq_wait_for_attach(queue, ack_queue_handle); if (mq_res != SHM_MQ_SUCCESS) return false; /* Get a response, non-blocking, with retries */ for (n = 1; n <= BGW_ACK_RETRIES; n++) { mq_res = shm_mq_receive(ack_queue_handle, &bytes_received, (void **) &data, true); if (mq_res != SHM_MQ_WOULD_BLOCK) break; ereport(DEBUG1, (errmsg("TimescaleDB ack message receive failure, retrying"))); WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, BGW_ACK_WAIT_INTERVAL, WAIT_EVENT_MESSAGE_QUEUE_INTERNAL); ResetLatch(MyLatch); CHECK_FOR_INTERRUPTS(); } if (mq_res != SHM_MQ_SUCCESS) return false; ack_received = (bytes_received != 0) && *data; return ack_received; } /* * Write element to queue, wait/error if queue is full * consumes message and deallocates */ extern bool ts_bgw_message_send_and_wait(BgwMessageType message_type, Oid db_oid) { shm_mq *ack_queue; dsm_segment *seg; shm_mq_handle *ack_queue_handle; BgwMessage *message; bool ack_received = false; message = bgw_message_create(message_type, db_oid); seg = dsm_find_mapping(message->ack_dsm_handle); if (seg == NULL) ereport(ERROR, (errmsg("TimescaleDB background worker dynamic shared memory segment not mapped"))); ack_queue = shm_mq_create(dsm_segment_address(seg), BGW_ACK_QUEUE_SIZE); shm_mq_set_receiver(ack_queue, MyProc); ack_queue_handle = shm_mq_attach(ack_queue, seg, NULL); if (ack_queue_handle != NULL) ack_received = enqueue_message_wait_for_ack(mq, message, ack_queue_handle); dsm_detach(seg); /* Queue detach happens in dsm detach callback */ pfree(message); return ack_received; } /* * Called only by the launcher */ extern BgwMessage * ts_bgw_message_receive(void) { return queue_remove(mq); } extern void ts_bgw_message_queue_set_reader(void) { queue_set_reader(mq); } typedef enum MessageAckSent { ACK_SENT = 0, DSM_SEGMENT_UNAVAILABLE, QUEUE_NOT_ATTACHED, SEND_FAILURE } MessageAckSent; static const char *message_ack_sent_err[] = { [ACK_SENT] = "Sent ack successfully", [DSM_SEGMENT_UNAVAILABLE] = "DSM Segment unavailable", [QUEUE_NOT_ATTACHED] = "Ack queue unable to attach", [SEND_FAILURE] = "Unable to send ack on queue" }; static MessageAckSent send_ack(dsm_segment *seg, bool success) { shm_mq *ack_queue; shm_mq_handle *ack_queue_handle; shm_mq_result ack_res; int n; ack_queue = dsm_segment_address(seg); if (ack_queue == NULL) return DSM_SEGMENT_UNAVAILABLE; shm_mq_set_sender(ack_queue, MyProc); ack_queue_handle = shm_mq_attach(ack_queue, seg, NULL); if (ack_queue_handle == NULL) return QUEUE_NOT_ATTACHED; /* Send the message off, non blocking, with retries */ for (n = 1; n <= BGW_ACK_RETRIES; n++) { ack_res = shm_mq_send(ack_queue_handle, sizeof(bool), &success, true, true); if (ack_res != SHM_MQ_WOULD_BLOCK) break; ereport(DEBUG1, (errmsg("TimescaleDB ack message send failure, retrying"))); WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, BGW_ACK_WAIT_INTERVAL, WAIT_EVENT_MESSAGE_QUEUE_INTERNAL); ResetLatch(MyLatch); CHECK_FOR_INTERRUPTS(); } /* we are responsible for pfree'ing the handle, the dsm infrastructure only * deals with the queue itself */ pfree(ack_queue_handle); if (ack_res != SHM_MQ_SUCCESS) return SEND_FAILURE; return ACK_SENT; } /* * Called by launcher once it has taken action based on the contents of the message * consumes message and deallocates */ extern void ts_bgw_message_send_ack(BgwMessage *message, bool success) { dsm_segment *seg; /* * PG 9.6 does not check to see if we had a CurrentResourceOwner inside of * dsm.c->dsm_create_descriptor. Basically, it assumed we were in a * transaction if we ever attached to the dsm, whereas PG 10 addressed * that and did proper NULL checking. So, if we are in 9.6, we start a * transaction and then commit it at the end of ack sending, to be sure * everything is cleaned up properly etc. */ seg = dsm_attach(message->ack_dsm_handle); if (seg != NULL) { MessageAckSent ack_res; ack_res = send_ack(seg, success); if (ack_res != ACK_SENT) ereport(DEBUG1, (errmsg("TimescaleDB background worker launcher unable to send ack to backend " "pid %d", message->sender_pid), errhint("Reason: %s", message_ack_sent_err[ack_res]))); dsm_detach(seg); } pfree(message); } /* * This gets called before shmem exit in the launcher (even if we're exiting * in error, but not if we're exiting due to possible shmem corruption) */ static void queue_shmem_cleanup(MessageQueue *queue) { queue_reset_reader(queue); } extern void ts_bgw_message_queue_shmem_cleanup(void) { queue_shmem_cleanup(mq); } �������������������������������������������������������������������������timescaledb-2.23.0/src/loader/bgw_message_queue.h���������������������������������������������������0000664�0000000�0000000�00000001732�15100345067�0021753�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <storage/dsm.h> typedef enum BgwMessageType { STOP = 0, START, RESTART } BgwMessageType; typedef struct BgwMessage { BgwMessageType message_type; pid_t sender_pid; Oid db_oid; dsm_handle ack_dsm_handle; } BgwMessage; extern bool ts_bgw_message_send_and_wait(BgwMessageType message, Oid db_oid); /* called only by the launcher*/ extern void ts_bgw_message_queue_set_reader(void); extern BgwMessage *ts_bgw_message_receive(void); extern void ts_bgw_message_send_ack(BgwMessage *message, bool success); /*called at server startup*/ extern void ts_bgw_message_queue_alloc(void); /*called in every backend during shmem startup hook*/ extern void ts_bgw_message_queue_shmem_startup(void); extern void ts_bgw_message_queue_shmem_cleanup(void); ��������������������������������������timescaledb-2.23.0/src/loader/function_telemetry.c��������������������������������������������������0000664�0000000�0000000�00000004066�15100345067�0022201�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ /* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <port/atomics.h> #include <storage/lwlock.h> #include <storage/shmem.h> #include "loader/function_telemetry.h" // Function telemetry hash table size. Sized to be large enough that we're // unlikely to run out of entries, but small enough that it won't have a // noticeable impact. #define FN_TELEMETRY_HASH_SIZE 10000 static FnTelemetryRendezvous rendezvous; void ts_function_telemetry_shmem_startup() { FnTelemetryRendezvous **rendezvous_ptr; HASHCTL hash_info; HTAB *function_telemetry_hash; LWLock **lock; bool found; // NOTE: dshash would be better once it's stable hash_info.keysize = sizeof(Oid); hash_info.entrysize = sizeof(FnTelemetryHashEntry); LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); /* * GetNamedLWLockTranche must only be run once on windows, otherwise it * segfaults. Since the shmem_startup_hook is run on every backend, we use * a ShmemInitStruct to detect if this function has been called before. */ lock = (LWLock **) ShmemInitStruct("fn_telemetry_detect_first_run", sizeof(LWLock *), &found); if (!found) *lock = &(GetNamedLWLockTranche(FN_TELEMETRY_LWLOCK_TRANCHE_NAME))->lock; function_telemetry_hash = ShmemInitHash("timescaledb function telemetry hash", FN_TELEMETRY_HASH_SIZE, FN_TELEMETRY_HASH_SIZE, &hash_info, HASH_ELEM | HASH_BLOBS); LWLockRelease(AddinShmemInitLock); rendezvous.lock = *lock; rendezvous.function_counts = function_telemetry_hash; rendezvous_ptr = (FnTelemetryRendezvous **) find_rendezvous_variable(RENDEZVOUS_FUNCTION_TELEMENTRY); *rendezvous_ptr = &rendezvous; } void ts_function_telemetry_shmem_alloc() { Size size = hash_estimate_size(FN_TELEMETRY_HASH_SIZE, sizeof(FnTelemetryHashEntry)); RequestAddinShmemSpace(add_size(size, sizeof(LWLock *))); RequestNamedLWLockTranche(FN_TELEMETRY_LWLOCK_TRANCHE_NAME, 1); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/function_telemetry.h��������������������������������������������������0000664�0000000�0000000�00000001215�15100345067�0022177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ /* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define RENDEZVOUS_FUNCTION_TELEMENTRY "ts_function_telemetry" #define FN_TELEMETRY_LWLOCK_TRANCHE_NAME "ts_fn_telemetry_lwlock_tranche" typedef struct FnTelemetryRendezvous { LWLock *lock; HTAB *function_counts; } FnTelemetryRendezvous; typedef struct FnTelemetryHashEntry { Oid key; pg_atomic_uint64 count; } FnTelemetryHashEntry; extern void ts_function_telemetry_shmem_startup(void); extern void ts_function_telemetry_shmem_alloc(void); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/loader.c��������������������������������������������������������������0000664�0000000�0000000�00000055733�15100345067�0017537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/parallel.h> #include <access/xact.h> #include <catalog/pg_database.h> #include <commands/dbcommands.h> #include <commands/defrem.h> #include <commands/user.h> #include <nodes/print.h> #include <parser/analyze.h> #include <pg_config.h> #include <postmaster/bgworker.h> #include <storage/ipc.h> #include <tcop/utility.h> #include <utils/guc.h> #include <utils/inval.h> #if PG_VERSION_NUM < 150000 #include "compat/compat-msvc-enter.h" #include <commands/extension.h> #include <miscadmin.h> #include "compat/compat-msvc-exit.h" #endif #include "compat/compat.h" #include "config.h" #include "export.h" #include "extension_constants.h" #include "extension_utils.c" #include "loader/bgw_counter.h" #include "loader/bgw_interface.h" #include "loader/bgw_launcher.h" #include "loader/bgw_message_queue.h" #include "loader/function_telemetry.h" #include "loader/loader.h" #include "loader/lwlocks.h" /* * Loading process: * * 1. _PG_init starts up cluster-wide background worker stuff, and sets the * post_parse_analyze_hook (a postgres-defined hook which is called after * every statement is parsed) to our function post_analyze_hook * 2. When a command is run with timescale not loaded, post_analyze_hook: * a. Gets the extension version. * b. Loads the versioned extension. * c. Grabs the post_parse_analyze_hook from the versioned extension * (src/init.c:post_analyze_hook) and stores it in * extension_post_parse_analyze_hook. * d. Sets the post_parse_analyze_hook back to what it was before we * loaded the versioned extension (this hook eventually called our * post_analyze_hook, but may not be our function, for instance, if * another extension is loaded). * e. Calls extension_post_parse_analyze_hook. * f. Calls the prev_post_parse_analyze_hook. * * Some notes on design: * * We do not check for the installation of the extension upon loading the extension and instead rely * on a hook for a few reasons: * * 1) We probably can't: * - The shared_preload_libraries is called in PostmasterMain which is way before InitPostgres is * called. Note: This happens even before the fork of the backend, so we don't even know which * database this is for. * - This means we cannot query for the existence of the extension yet because the caches are * initialized in InitPostgres. * * 2) We actually don't want to load the extension in two cases: * a) We are upgrading the extension. * b) We set the guc timescaledb.disable_load. * * 3) We include a section for the bgw launcher and some workers below the rest, separated with its * own notes, some function definitions are included as they are referenced by other loader * functions. * */ #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif #define POST_LOAD_INIT_FN "ts_post_load_init" #define GUC_LAUNCHER_POLL_TIME_MS MAKE_EXTOPTION("bgw_launcher_poll_time") /* * The loader really shouldn't load if we're in a parallel worker as there is a * separate infrastructure for loading libraries inside of parallel workers. The * issue is that IsParallelWorker() doesn't work on Windows because the var used * is not dll exported correctly, so we have an alternate macro that looks for * the parallel worker flags in MyBgworkerEntry, if it exists. */ #define CalledInParallelWorker() \ (MyBgworkerEntry != NULL && (MyBgworkerEntry->bgw_flags & BGWORKER_CLASS_PARALLEL) != 0) #if PG16_LT extern void TSDLLEXPORT _PG_init(void); #endif /* was the versioned-extension loaded*/ static bool loader_present = true; int ts_guc_bgw_launcher_poll_time = BGW_LAUNCHER_POLL_TIME_MS; /* This is the hook that existed before the loader was installed */ static post_parse_analyze_hook_type prev_post_parse_analyze_hook; static shmem_startup_hook_type prev_shmem_startup_hook; static shmem_request_hook_type prev_shmem_request_hook; typedef struct TsExtension { /* * Static data */ /* Name of the extension (must be part of the so file name) */ char const *const name; /* Name of the schema for table_name. */ char const *const schema_name; /* Name of the table whose existence indicates the extension is loaded. */ char const *const table_name; /* Name of the GUC for disabling loading this extension. */ char const *const guc_disable_load_name; /* * Run-time state */ /* Current value of this extension's disable GUC. */ bool guc_disable_load; /* Shared object library version loaded; empty if none. */ char soversion[MAX_VERSION_LEN]; /* TODO Remove. Neither timescaledb nor OSM actually have this hook, * never have, and we don't plan to add them. */ post_parse_analyze_hook_type post_parse_analyze_hook; } TsExtension; TsExtension extensions[] = { /* Redundant default initializers are here because we compile with * `-Werror -Wmissing-field-initializers` for our PG13 build... */ { .name = EXTENSION_NAME, .schema_name = CACHE_SCHEMA_NAME, .table_name = EXTENSION_PROXY_TABLE, .guc_disable_load_name = MAKE_EXTOPTION("disable_load"), .guc_disable_load = false, .soversion = "", .post_parse_analyze_hook = NULL, }, { .name = "timescaledb_osm", .schema_name = "_osm_catalog", .table_name = "metadata", .guc_disable_load_name = "timescaledb_osm.disable_load", .guc_disable_load = false, .soversion = "", .post_parse_analyze_hook = NULL, }, { .name = "timescaledb_lake", .schema_name = "_timescaledb_lake_catalog", .table_name = "metadata", .guc_disable_load_name = "timescaledb_lake.disable_load", .guc_disable_load = false, .soversion = "", .post_parse_analyze_hook = NULL, }, }; inline static void extension_check(TsExtension * /*ext*/); static void call_extension_post_parse_analyze_hook(ParseState *pstate, Query *query, TsExtension const * /*ext*/, JumbleState *jstate); static bool extension_is_loaded(TsExtension const *const ext) { /* The extension is loaded when the version is set to a non-null string */ return ext->soversion[0] != '\0'; } extern char * ts_loader_extension_version(void) { return extension_version(EXTENSION_NAME); } extern bool ts_loader_extension_exists(void) { return extension_exists(EXTENSION_NAME); } static bool drop_statement_drops_extension(DropStmt const *const stmt, TsExtension const *const ext) { if (!extension_exists(ext->name)) return false; if (stmt->removeType == OBJECT_EXTENSION) { if (list_length(stmt->objects) == 1) { char *ext_name; void *name = linitial(stmt->objects); ext_name = strVal(name); if (strcmp(ext_name, ext->name) == 0) return true; } } return false; } static Oid extension_owner(TsExtension const *const ext) { Datum result; Relation rel; SysScanDesc scandesc; HeapTuple tuple; ScanKeyData entry[1]; bool is_null = true; Oid extension_owner = InvalidOid; rel = table_open(ExtensionRelationId, AccessShareLock); ScanKeyInit(&entry[0], Anum_pg_extension_extname, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(ext->name)); scandesc = systable_beginscan(rel, ExtensionNameIndexId, true, NULL, 1, entry); tuple = systable_getnext(scandesc); /* We assume that there can be at most one matching tuple */ if (HeapTupleIsValid(tuple)) { result = heap_getattr(tuple, Anum_pg_extension_extowner, RelationGetDescr(rel), &is_null); if (!is_null) extension_owner = ObjectIdGetDatum(result); } systable_endscan(scandesc); table_close(rel, AccessShareLock); if (!OidIsValid(extension_owner)) elog(ERROR, "extension not found while getting owner"); return extension_owner; } static bool drop_owned_statement_drops_extension(DropOwnedStmt const *const stmt, TsExtension const *const ext) { Oid extension_owner_oid; List *role_ids; ListCell *lc; if (!extension_exists(ext->name)) return false; Assert(IsTransactionState()); extension_owner_oid = extension_owner(ext); role_ids = roleSpecsToIds(stmt->roles); /* Check privileges */ foreach (lc, role_ids) { Oid role_id = lfirst_oid(lc); if (role_id == extension_owner_oid) return true; } return false; } static bool should_load_on_variable_set(Node const *const utility_stmt, TsExtension const *const ext) { VariableSetStmt *stmt = (VariableSetStmt *) utility_stmt; switch (stmt->kind) { case VAR_SET_VALUE: case VAR_SET_DEFAULT: case VAR_RESET: /* Do not load when setting the guc to disable load */ return stmt->name == NULL || strcmp(stmt->name, ext->guc_disable_load_name) != 0; default: return true; } } static bool should_load_on_alter_extension(Node const *const utility_stmt, TsExtension const *const ext) { AlterExtensionStmt *stmt = (AlterExtensionStmt *) utility_stmt; if (strcmp(stmt->extname, ext->name) != 0) return true; /* disallow loading two .so from different versions */ if (extension_is_loaded(ext)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("extension \"%s\" cannot be updated after the old version has already been " "loaded", stmt->extname), errhint("Start a new session and execute ALTER EXTENSION as the first command. " "Make sure to pass the \"-X\" flag to psql."))); /* do not load the current (old) version's .so */ return false; } static bool should_load_on_create_extension(Node const *const utility_stmt, TsExtension const *const ext) { CreateExtensionStmt *stmt = (CreateExtensionStmt *) utility_stmt; if (strcmp(stmt->extname, ext->name) != 0) return false; /* If set, a library has already been loaded */ if (!extension_is_loaded(ext)) return true; /* * If the extension exists and the create statement has an IF NOT EXISTS * option, we continue without loading and let CREATE EXTENSION bail out * with a standard NOTICE. We can only do this if the extension actually * exists (is created), or else we might potentially load the shared * library of another version of the extension. Loading typically happens * on CREATE EXTENSION (via CREATE FUNCTION as SQL files are installed) * even if we do not explicitly load the library here. If we load another * version of the library, in addition to the currently loaded version, we * might taint the backend. */ if (extension_exists(ext->name) && stmt->if_not_exists) return false; /* disallow loading two .so from different versions */ ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("extension \"%s\" has already been loaded with another version", stmt->extname), errdetail("The loaded version is \"%s\".", ext->soversion), errhint("Start a new session and execute CREATE EXTENSION as the first command. " "Make sure to pass the \"-X\" flag to psql."))); return false; } static bool load_utility_cmd(Node const *const utility_stmt, TsExtension const *const ext) { switch (nodeTag(utility_stmt)) { case T_VariableSetStmt: return should_load_on_variable_set(utility_stmt, ext); case T_AlterExtensionStmt: return should_load_on_alter_extension(utility_stmt, ext); case T_CreateExtensionStmt: return should_load_on_create_extension(utility_stmt, ext); case T_DropStmt: return !drop_statement_drops_extension((DropStmt *) utility_stmt, ext); default: return true; } } static void stop_workers_on_db_drop(DropdbStmt *drop_db_statement) { /* * Don't check if extension exists here because even though the current * database might not have TimescaleDB installed the database we are * dropping might. */ Oid dropped_db_oid = get_database_oid(drop_db_statement->dbname, drop_db_statement->missing_ok); if (OidIsValid(dropped_db_oid)) { ereport(LOG, (errmsg("TimescaleDB background worker scheduler for database %u will be stopped", dropped_db_oid))); ts_bgw_message_send_and_wait(STOP, dropped_db_oid); } } static bool database_allowconn(const Oid db_oid) { Relation pg_database; ScanKeyData entry[1]; SysScanDesc scan; HeapTuple dbtuple; bool allowconn = false; pg_database = table_open(DatabaseRelationId, AccessShareLock); ScanKeyInit(&entry[0], Anum_pg_database_oid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(db_oid)); scan = systable_beginscan(pg_database, DatabaseOidIndexId, true, NULL, 1, entry); dbtuple = systable_getnext(scan); /* We assume that there can be at most one matching tuple */ if (!HeapTupleIsValid(dbtuple)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_DATABASE), errmsg("database with OID \"%u\" does not exist", db_oid))); allowconn = ((Form_pg_database) GETSTRUCT(dbtuple))->datallowconn; systable_endscan(scan); table_close(pg_database, AccessShareLock); return allowconn; } static void post_analyze_hook(ParseState *pstate, Query *query, JumbleState *jstate) { if (query->commandType == CMD_UTILITY) { switch (nodeTag(query->utilityStmt)) { case T_AlterDatabaseStmt: { /* * On ALTER DATABASE SET TABLESPACE we need to stop background * workers for the command to succeed. */ AlterDatabaseStmt *stmt = (AlterDatabaseStmt *) query->utilityStmt; if (list_length(stmt->options) == 1) { DefElem *option = linitial(stmt->options); if (option->defname && strcmp(option->defname, "tablespace") == 0) { Oid db_oid = get_database_oid(stmt->dbname, false); if (OidIsValid(db_oid)) { ts_bgw_message_send_and_wait(RESTART, db_oid); ereport(WARNING, (errmsg("you may need to manually restart any running " "background workers after this command"))); } } } break; } case T_CreatedbStmt: { /* * If we create a database and the database used as template * has background workers we need to stop those background * workers connected to the template database. */ CreatedbStmt *stmt = (CreatedbStmt *) query->utilityStmt; ListCell *lc; foreach (lc, stmt->options) { DefElem *option = lfirst(lc); if (option->defname != NULL && option->arg != NULL && strcmp(option->defname, "template") == 0) { Oid db_oid = get_database_oid(defGetString(option), false); if (OidIsValid(db_oid) && database_allowconn(db_oid)) ts_bgw_message_send_and_wait(RESTART, db_oid); } } break; } case T_DropdbStmt: { DropdbStmt *stmt = (DropdbStmt *) query->utilityStmt; /* * If we drop a database, we need to intercept and stop any of our * schedulers that might be connected to said db. */ stop_workers_on_db_drop(stmt); break; } case T_DropStmt: for (size_t i = 0; i < sizeof(extensions) / sizeof(TsExtension); ++i) { if (drop_statement_drops_extension((DropStmt *) query->utilityStmt, &extensions[i])) { /* * if we drop the extension we should restart (in case of * a rollback) the scheduler */ ts_bgw_message_send_and_wait(RESTART, MyDatabaseId); break; } } break; case T_DropOwnedStmt: for (size_t i = 0; i < sizeof(extensions) / sizeof(TsExtension); ++i) { if (drop_owned_statement_drops_extension((DropOwnedStmt *) query->utilityStmt, &extensions[i])) { ts_bgw_message_send_and_wait(RESTART, MyDatabaseId); break; } } break; case T_RenameStmt: if (((RenameStmt *) query->utilityStmt)->renameType == OBJECT_DATABASE) { RenameStmt *stmt = (RenameStmt *) query->utilityStmt; Oid db_oid = get_database_oid(stmt->subname, stmt->missing_ok); if (OidIsValid(db_oid)) { ts_bgw_message_send_and_wait(STOP, db_oid); ereport(WARNING, (errmsg("you need to manually restart any running " "background workers after this command"))); } } break; default: break; } } for (size_t i = 0; i < sizeof(extensions) / sizeof(TsExtension); ++i) { TsExtension *const ext = &extensions[i]; /* timescaledb.disable_load prevents loading of all extensions. * timescaledb_osm.disable_load prevents loading of timescaledb_osm. * If we ever had a third extension to load, we might need to make * this smarter, but not today. */ bool const disable_load = extensions[0].guc_disable_load || ext->guc_disable_load; if (!disable_load && (query->commandType != CMD_UTILITY || load_utility_cmd(query->utilityStmt, ext))) { extension_check(ext); } /* * Call the extension's hook. This is necessary since the extension is * installed during the hook. If we did not do this the extension's hook * would not be called during the first command because the extension * would not have yet been installed. Thus the loader captures the * extension hook and calls it explicitly after the check for installing * the extension. */ call_extension_post_parse_analyze_hook(pstate, query, ext, jstate); } if (prev_post_parse_analyze_hook != NULL) { prev_post_parse_analyze_hook(pstate, query, jstate); } } static void timescaledb_shmem_startup_hook(void) { if (prev_shmem_startup_hook) prev_shmem_startup_hook(); ts_bgw_counter_shmem_startup(); ts_bgw_message_queue_shmem_startup(); ts_lwlocks_shmem_startup(); ts_function_telemetry_shmem_startup(); } /* * PG15 requires all shared memory requests to be requested in a dedicated * hook. We group all our shared memory requests in this function and use * it as a normal function for PG < 14 and as a hook for PG 15+. */ static void timescaledb_shmem_request_hook(void) { if (prev_shmem_request_hook) prev_shmem_request_hook(); ts_bgw_counter_shmem_alloc(); ts_bgw_message_queue_alloc(); ts_lwlocks_shmem_alloc(); ts_function_telemetry_shmem_alloc(); } static void extension_mark_loader_present() { void **presentptr = find_rendezvous_variable(RENDEZVOUS_LOADER_PRESENT_NAME); *presentptr = &loader_present; } void _PG_init(void) { if (!process_shared_preload_libraries_in_progress) { extension_load_without_preload(); } extension_mark_loader_present(); elog(INFO, "timescaledb loaded"); ts_bgw_cluster_launcher_init(); ts_bgw_counter_setup_gucs(); ts_bgw_interface_register_api_version(); /* This is a safety-valve variable to prevent loading the full extension */ for (size_t i = 0; i < sizeof(extensions) / sizeof(TsExtension); ++i) { TsExtension *const ext = &extensions[i]; DefineCustomBoolVariable(ext->guc_disable_load_name, "Disable the loading of the actual extension", NULL, &ext->guc_disable_load, false, PGC_USERSET, 0, NULL, NULL, NULL); } DefineCustomIntVariable(GUC_LAUNCHER_POLL_TIME_MS, "Launcher timeout value in milliseconds", "Configure the time the launcher waits " "to look for new TimescaleDB instances", &ts_guc_bgw_launcher_poll_time, BGW_LAUNCHER_POLL_TIME_MS, /* 10 ms or 60 seconds */ 10, /* min: 10ms */ PG_INT32_MAX, /* PG_INT16_MAX would be too small */ PGC_POSTMASTER, 0, NULL, NULL, NULL); /* * Cannot check for extension here since not inside a transaction yet. Nor * do we even have an assigned database yet. * Using the post_parse_analyze_hook since it's the earliest available * hook. */ prev_post_parse_analyze_hook = post_parse_analyze_hook; /* register shmem startup hook for the background worker stuff */ prev_shmem_startup_hook = shmem_startup_hook; post_parse_analyze_hook = post_analyze_hook; shmem_startup_hook = timescaledb_shmem_startup_hook; prev_shmem_request_hook = shmem_request_hook; shmem_request_hook = timescaledb_shmem_request_hook; } inline static void do_load(TsExtension *const ext) { char *version = extension_version(ext->name); char soname[MAX_SO_NAME_LEN]; post_parse_analyze_hook_type old_hook; /* If the right version of the library is already loaded, we will just * skip the actual loading. If the wrong version of the library is loaded, * we need to kill the session since it will not be able to continue * operate. */ if (extension_is_loaded(ext)) { if (strcmp(ext->soversion, version) == 0) return; ereport(FATAL, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("\"%s\" already loaded with a different version", ext->name), errdetail("The new version is \"%s\", this session is using version \"%s\". The " "session will be restarted.", version, ext->soversion))); } strlcpy(ext->soversion, version, MAX_VERSION_LEN); snprintf(soname, MAX_SO_NAME_LEN, "%s%s-%s", TS_LIBDIR, ext->name, version); /* * In a parallel worker, we're not responsible for loading libraries, it's * handled by the parallel worker infrastructure which restores the * library state. */ if (CalledInParallelWorker()) { return; } /* * Set the config option to let versions 0.9.0 and 0.9.1 know that the * loader was preloaded, newer versions use rendezvous variables instead. */ if ((strcmp(version, "0.9.0") == 0 || strcmp(version, "0.9.1") == 0) && strcmp(ext->name, EXTENSION_NAME) == 0) { SetConfigOption(MAKE_EXTOPTION("loader_present"), "on", PGC_USERSET, PGC_S_SESSION); } /* * we need to capture the loaded extension's post analyze hook, giving it * a NULL as previous */ old_hook = post_parse_analyze_hook; post_parse_analyze_hook = NULL; /* * We want to call the post_parse_analyze_hook from the versioned * extension after we've loaded the versioned so. When the file is loaded * it sets post_parse_analyze_hook, which we capture and store in * extension_post_parse_analyze_hook to call at the end _PG_init */ PG_TRY(); { PGFunction ts_post_load_init = load_external_function(soname, POST_LOAD_INIT_FN, false, NULL); if (ts_post_load_init != NULL) { DirectFunctionCall1(ts_post_load_init, CharGetDatum(0)); } } PG_CATCH(); { ext->post_parse_analyze_hook = post_parse_analyze_hook; post_parse_analyze_hook = old_hook; PG_RE_THROW(); } PG_END_TRY(); ext->post_parse_analyze_hook = post_parse_analyze_hook; post_parse_analyze_hook = old_hook; } inline static void extension_check(TsExtension *const ext) { switch (extension_current_state(ext->name, ext->schema_name, ext->table_name)) { case EXTENSION_STATE_TRANSITIONING: /* * Always load as soon as the extension is transitioning. This is * necessary so that the extension load before any CREATE FUNCTION * calls. Otherwise, the CREATE FUNCTION calls will load the .so * without capturing the post_parse_analyze_hook. */ case EXTENSION_STATE_CREATED: do_load(ext); return; case EXTENSION_STATE_UNKNOWN: case EXTENSION_STATE_NOT_INSTALLED: return; } } extern void ts_loader_extension_check(void) { for (size_t i = 0; i < sizeof(extensions) / sizeof(TsExtension); ++i) { extension_check(&extensions[i]); } } static void call_extension_post_parse_analyze_hook(ParseState *pstate, Query *query, TsExtension const *const ext, JumbleState *jstate) { if (extension_is_loaded(ext) && ext->post_parse_analyze_hook != NULL) { ext->post_parse_analyze_hook(pstate, query, jstate); } } �������������������������������������timescaledb-2.23.0/src/loader/loader.h��������������������������������������������������������������0000664�0000000�0000000�00000001241�15100345067�0017525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> extern char *ts_loader_extension_version(void); extern bool ts_loader_extension_exists(void); extern void ts_loader_extension_check(void); /* WaitLatch expects a long, so make sure to cast the value */ /* Default value for timescaledb.launcher_poll_time */ #ifdef TS_DEBUG #define BGW_LAUNCHER_POLL_TIME_MS 10 #else #define BGW_LAUNCHER_POLL_TIME_MS 60000 #endif /* GUC to control launcher timeout */ extern int ts_guc_bgw_launcher_poll_time; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/lwlocks.c�������������������������������������������������������������0000664�0000000�0000000�00000004345�15100345067�0017740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <miscadmin.h> #include <storage/lwlock.h> #include <storage/shmem.h> #include "loader/lwlocks.h" #define TS_LWLOCKS_SHMEM_NAME "ts_lwlocks_shmem" #define CHUNK_APPEND_LWLOCK_TRANCHE_NAME "ts_chunk_append_lwlock_tranche" #define OSM_PARALLEL_LWLOCK_TRANCHE_NAME "ts_osm_parallel_lwlock_tranche" /* * since shared memory can only be setup in a library loaded as * shared_preload_libraries we have to setup this struct here */ typedef struct TSLWLocks { LWLock *chunk_append; LWLock *osm_parallel_lwlock; } TSLWLocks; static TSLWLocks *ts_lwlocks = NULL; void ts_lwlocks_shmem_startup() { bool found; LWLock **lock_pointer, **osm_lock_pointer; LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); ts_lwlocks = ShmemInitStruct(TS_LWLOCKS_SHMEM_NAME, sizeof(TSLWLocks), &found); if (!found) { memset(ts_lwlocks, 0, sizeof(TSLWLocks)); ts_lwlocks->chunk_append = &(GetNamedLWLockTranche(CHUNK_APPEND_LWLOCK_TRANCHE_NAME))->lock; ts_lwlocks->osm_parallel_lwlock = &(GetNamedLWLockTranche(OSM_PARALLEL_LWLOCK_TRANCHE_NAME))->lock; } LWLockRelease(AddinShmemInitLock); /* * We use a lock specific rendezvous variable to decouple the struct * from the individual lock users to have no constraints on the struct * across timescaledb versions. */ lock_pointer = (LWLock **) find_rendezvous_variable(RENDEZVOUS_CHUNK_APPEND_LWLOCK); *lock_pointer = ts_lwlocks->chunk_append; osm_lock_pointer = (LWLock **) find_rendezvous_variable(RENDEZVOUS_OSM_PARALLEL_LWLOCK); *osm_lock_pointer = ts_lwlocks->osm_parallel_lwlock; } /* * from postgres code comments: * Extensions (or core code) can obtain an LWLocks by calling * RequestNamedLWLockTranche() during postmaster startup. Subsequently, * call GetNamedLWLockTranche() to obtain a pointer to an array containing * the number of LWLocks requested. */ void ts_lwlocks_shmem_alloc() { RequestNamedLWLockTranche(CHUNK_APPEND_LWLOCK_TRANCHE_NAME, 1); RequestNamedLWLockTranche(OSM_PARALLEL_LWLOCK_TRANCHE_NAME, 1); RequestAddinShmemSpace(sizeof(TSLWLocks)); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/loader/lwlocks.h�������������������������������������������������������������0000664�0000000�0000000�00000000624�15100345067�0017741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define RENDEZVOUS_CHUNK_APPEND_LWLOCK "ts_chunk_append_lwlock" #define RENDEZVOUS_OSM_PARALLEL_LWLOCK "ts_osm_parallel_lwlock" void ts_lwlocks_shmem_startup(void); void ts_lwlocks_shmem_alloc(void); ������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015430�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/CMakeLists.txt�����������������������������������������������������������0000664�0000000�0000000�00000000575�15100345067�0020177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/conn.c ${CMAKE_CURRENT_SOURCE_DIR}/conn_plain.c ${CMAKE_CURRENT_SOURCE_DIR}/http.c ${CMAKE_CURRENT_SOURCE_DIR}/http_response.c ${CMAKE_CURRENT_SOURCE_DIR}/http_request.c) if(USE_OPENSSL) list(APPEND SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/conn_ssl.c) endif(USE_OPENSSL) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) �����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/conn.c�������������������������������������������������������������������0000664�0000000�0000000�00000005534�15100345067�0016540�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include "conn_internal.h" #include "debug_assert.h" static ConnOps *conn_ops[_CONNECTION_MAX] = { NULL }; static const char *conn_names[] = { [CONNECTION_PLAIN] = "PLAIN", [CONNECTION_SSL] = "SSL", [CONNECTION_MOCK] = "MOCK", }; static Connection * connection_internal_create(ConnectionType type, ConnOps *ops) { Connection *conn = palloc(ops->size); if (NULL == conn) return NULL; memset(conn, 0, ops->size); conn->ops = ops; conn->type = type; return conn; } Connection * ts_connection_create(ConnectionType type) { Connection *conn; if (type == _CONNECTION_MAX) { elog(NOTICE, "invalid connection type"); return NULL; } if (NULL == conn_ops[type]) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("%s connections are not supported", conn_names[type]), errhint("Enable %s support when compiling the extension.", conn_names[type]))); conn = connection_internal_create(type, conn_ops[type]); Ensure(conn, "unable to create connection"); if (NULL != conn->ops->init) if (conn->ops->init(conn) < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("%s connection could not be initialized", conn_names[type]))); return conn; } /* * Connect to a remote endpoint (host, service/port). * * The connection will be made to the host's service endpoint given by * 'servname' (e.g., 'http'), unless a valid port number is given. */ int ts_connection_connect(Connection *conn, const char *host, const char *servname, int port) { /* Windows defines 'connect()' as a macro, so we need to undef it here to use it in ops->connect */ #ifdef WIN32 #undef connect #endif return conn->ops->connect(conn, host, servname, port); } ssize_t ts_connection_write(Connection *conn, const char *buf, size_t writelen) { return conn->ops->write(conn, buf, writelen); } ssize_t ts_connection_read(Connection *conn, char *buf, size_t buflen) { return conn->ops->read(conn, buf, buflen); } void ts_connection_close(Connection *conn) { if (NULL != conn->ops) conn->ops->close(conn); } int ts_connection_set_timeout_millis(Connection *conn, unsigned long millis) { if (NULL != conn->ops->set_timeout) return conn->ops->set_timeout(conn, millis); return -1; } void ts_connection_destroy(Connection *conn) { if (conn == NULL) return; ts_connection_close(conn); conn->ops = NULL; pfree(conn); } int ts_connection_register(ConnectionType type, ConnOps *ops) { if (type == _CONNECTION_MAX) return -1; conn_ops[type] = ops; return 0; } const char * ts_connection_get_and_clear_error(Connection *conn) { if (NULL != conn->ops->errmsg) return conn->ops->errmsg(conn); return "unknown connection error"; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/conn.h�������������������������������������������������������������������0000664�0000000�0000000�00000002142�15100345067�0016535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> typedef struct ConnOps ConnOps; typedef enum ConnectionType { CONNECTION_PLAIN, CONNECTION_SSL, CONNECTION_MOCK, _CONNECTION_MAX, } ConnectionType; typedef struct Connection { ConnectionType type; #ifdef WIN32 SOCKET sock; #else int sock; #endif ConnOps *ops; int err; } Connection; extern Connection *ts_connection_create(ConnectionType type); extern int ts_connection_connect(Connection *conn, const char *host, const char *servname, int port); extern ssize_t ts_connection_read(Connection *conn, char *buf, size_t buflen); extern ssize_t ts_connection_write(Connection *conn, const char *buf, size_t writelen); extern void ts_connection_close(Connection *conn); extern void ts_connection_destroy(Connection *conn); extern int ts_connection_set_timeout_millis(Connection *conn, unsigned long millis); extern const char *ts_connection_get_and_clear_error(Connection *conn); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/conn_internal.h����������������������������������������������������������0000664�0000000�0000000�00000001377�15100345067�0020442�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "conn.h" typedef struct ConnOps { size_t size; /* Size of the connection object */ int (*init)(Connection *conn); int (*connect)(Connection *conn, const char *host, const char *servname, int port); void (*close)(Connection *conn); ssize_t (*write)(Connection *conn, const char *buf, size_t writelen); ssize_t (*read)(Connection *conn, char *buf, size_t readlen); int (*set_timeout)(Connection *conn, unsigned long millis); const char *(*errmsg)(Connection *conn); } ConnOps; extern int ts_connection_register(ConnectionType type, ConnOps *ops); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/conn_plain.c�������������������������������������������������������������0000664�0000000�0000000�00000013142�15100345067�0017715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <unistd.h> #include <postgres.h> #include <sys/socket.h> #include <sys/time.h> #include "compat/compat.h" #include "conn_internal.h" #include "conn_plain.h" #include "port.h" #define DEFAULT_TIMEOUT_MSEC 3000 #define MAX_PORT 65535 static void set_error(int err) { #ifdef WIN32 WSASetLastError(err); #else errno = err; #endif } static int get_error(void) { #ifdef WIN32 return WSAGetLastError(); #else return errno; #endif } /* Create socket and connect */ int ts_plain_connect(Connection *conn, const char *host, const char *servname, int port) { char strport[6]; struct addrinfo *ainfo, hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM, }; int ret; if (NULL == servname && (port <= 0 || port > MAX_PORT)) { set_error(EINVAL); return -1; } /* Explicit port given. Use it instead of servname */ if (port > 0 && port <= MAX_PORT) { snprintf(strport, sizeof(strport), "%d", port); servname = strport; hints.ai_flags = AI_NUMERICSERV; } /* Lookup the endpoint ip address */ ret = getaddrinfo(host, servname, &hints, &ainfo); if (ret != 0) { ret = SOCKET_ERROR; #ifdef WIN32 WSASetLastError(WSAHOST_NOT_FOUND); #else /* * The closest match for a name resolution error. Strictly, this error * should not be used here, but to fix we need to support using * gai_strerror() */ errno = EADDRNOTAVAIL; #endif goto out; } #ifdef WIN32 /* * PostgreSQL redefines the socket() call on Windows and creates a * non-blocking socket by default. We avoid this by calling WSASocket * directly. */ conn->sock = WSASocket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol, NULL, 0, WSA_FLAG_OVERLAPPED); if (conn->sock == INVALID_SOCKET) ret = SOCKET_ERROR; #else ret = conn->sock = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol); #endif if (IS_SOCKET_ERROR(ret)) goto out_addrinfo; /* * Set send / recv timeout so that write and read don't block forever. Set * separately so that one of the actions failing doesn't block the other. */ if (ts_plain_set_timeout(conn, DEFAULT_TIMEOUT_MSEC) < 0) { ret = SOCKET_ERROR; goto out_addrinfo; } #ifdef WIN32 ret = WSAConnect(conn->sock, ainfo->ai_addr, ainfo->ai_addrlen, NULL, NULL, NULL, NULL); #else /* connect the socket */ ret = connect(conn->sock, ainfo->ai_addr, ainfo->ai_addrlen); #endif out_addrinfo: freeaddrinfo(ainfo); out: if (IS_SOCKET_ERROR(ret)) { conn->err = ret; return -1; } return 0; } static ssize_t plain_write(Connection *conn, const char *buf, size_t writelen) { ssize_t ret; #ifdef WIN32 DWORD b; WSABUF wbuf = { .len = writelen, .buf = (char *) buf, }; conn->err = WSASend(conn->sock, &wbuf, 1, &b, 0, NULL, NULL); if (IS_SOCKET_ERROR(conn->err)) ret = -1; else ret = b; #else ret = send(conn->sock, buf, writelen, 0); if (ret < 0) conn->err = ret; #endif return ret; } static ssize_t plain_read(Connection *conn, char *buf, size_t buflen) { ssize_t ret; #ifdef WIN32 DWORD b, flags = 0; WSABUF wbuf = { .len = buflen, .buf = buf, }; conn->err = WSARecv(conn->sock, &wbuf, 1, &b, &flags, NULL, NULL); if (IS_SOCKET_ERROR(conn->err)) ret = -1; else ret = b; #else ret = recv(conn->sock, buf, buflen, 0); if (ret < 0) conn->err = ret; #endif return ret; } void ts_plain_close(Connection *conn) { #ifdef WIN32 closesocket(conn->sock); #else close(conn->sock); #endif } int ts_plain_set_timeout(Connection *conn, unsigned long millis) { #ifdef WIN32 /* Timeout is in milliseconds on Windows */ DWORD timeout = millis; int optlen = sizeof(DWORD); #else /* we deliberately use a long constant here instead of a fixed width one because tv_sec is * declared as a long */ struct timeval timeout = { .tv_sec = millis / 1000L, .tv_usec = (millis % 1000L) * 1000L, }; int optlen = sizeof(struct timeval); #endif /* * Set send / recv timeout so that write and read don't block forever. Set * separately so that one of the actions failing doesn't block the other. */ conn->err = setsockopt(conn->sock, SOL_SOCKET, SO_RCVTIMEO, (const char *) &timeout, optlen); if (conn->err != 0) return -1; conn->err = setsockopt(conn->sock, SOL_SOCKET, SO_SNDTIMEO, (const char *) &timeout, optlen); if (conn->err != 0) return -1; return 0; } const char * ts_plain_errmsg(Connection *conn) { const char *errmsg = "no connection error"; if (IS_SOCKET_ERROR(conn->err)) errmsg = strerror(get_error()); conn->err = 0; return errmsg; } static ConnOps plain_ops = { .size = sizeof(Connection), .init = NULL, .connect = ts_plain_connect, .close = ts_plain_close, .write = plain_write, .read = plain_read, .errmsg = ts_plain_errmsg, }; extern void _conn_plain_init(void); extern void _conn_plain_fini(void); void _conn_plain_init(void) { /* * WSAStartup is required on Windows before using the Winsock API. * However, PostgreSQL already handles this for us, so it is disabled here * by default. Set WSA_STARTUP_ENABLED to perform this initialization * anyway. */ #if defined(WIN32) && defined(WSA_STARTUP_ENABLED) WSADATA wsadata; int res; res = WSAStartup(MAKEWORD(2, 2), &wsadata); if (res != 0) { elog(ERROR, "WSAStartup failed: %d", res); return; } #endif ts_connection_register(CONNECTION_PLAIN, &plain_ops); } void _conn_plain_fini(void) { #if defined(WIN32) && defined(WSA_STARTUP_ENABLED) int ret = WSACleanup(); if (ret != 0) elog(WARNING, "WSACleanup failed"); #endif } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/conn_plain.h�������������������������������������������������������������0000664�0000000�0000000�00000001215�15100345067�0017720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once typedef struct Connection Connection; #ifdef WIN32 #define IS_SOCKET_ERROR(err) (err == SOCKET_ERROR) #else #define SOCKET_ERROR -1 #define IS_SOCKET_ERROR(err) (err < 0) #endif extern int ts_plain_connect(Connection *conn, const char *host, const char *servname, int port); extern void ts_plain_close(Connection *conn); extern int ts_plain_set_timeout(Connection *conn, unsigned long millis); extern const char *ts_plain_errmsg(Connection *conn); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/conn_ssl.c���������������������������������������������������������������0000664�0000000�0000000�00000012232�15100345067�0017412�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <openssl/err.h> #include <openssl/ssl.h> #include "conn_internal.h" #include "conn_plain.h" typedef struct SSLConnection { Connection conn; SSL_CTX *ssl_ctx; SSL *ssl; unsigned long errcode; } SSLConnection; static void ssl_set_error(SSLConnection *conn, int err) { conn->errcode = ERR_get_error(); conn->conn.err = err; } static SSL_CTX * ssl_ctx_create(void) { SSL_CTX *ctx; int options; #if (OPENSSL_VERSION_NUMBER >= 0x1010000fL) /* OpenSSL >= v1.1 */ ctx = SSL_CTX_new(TLS_method()); options = SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1; #elif (OPENSSL_VERSION_NUMBER >= 0x1000000fL) /* OpenSSL >= v1.0 */ ctx = SSL_CTX_new(SSLv23_method()); options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1; #else #error "Unsupported OpenSSL version" #endif /* * Because we have a blocking socket, we don't want to be bothered with * retries. */ if (NULL != ctx) { SSL_CTX_set_options(ctx, options); SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY); } return ctx; } static int ssl_setup(SSLConnection *conn, const char *host) { int ret; conn->ssl_ctx = ssl_ctx_create(); if (NULL == conn->ssl_ctx) { ssl_set_error(conn, -1); return -1; } ERR_clear_error(); conn->ssl = SSL_new(conn->ssl_ctx); if (conn->ssl == NULL) { ssl_set_error(conn, -1); return -1; } ERR_clear_error(); ret = SSL_set_fd(conn->ssl, conn->conn.sock); if (ret == 0) { ssl_set_error(conn, -1); return -1; } /* * Tell the server during the handshake which hostname we are attempting * to connect to in case the server supports multiple hosts. */ if (!SSL_set_tlsext_host_name(conn->ssl, host)) { ssl_set_error(conn, -1); return -1; } ret = SSL_connect(conn->ssl); if (ret <= 0) { ssl_set_error(conn, ret); ret = -1; } return ret; } static int ssl_connect(Connection *conn, const char *host, const char *servname, int port) { int ret; /* First do the base connection setup */ ret = ts_plain_connect(conn, host, servname, port); if (ret < 0) return -1; return ssl_setup((SSLConnection *) conn, host); } static ssize_t ssl_write(Connection *conn, const char *buf, size_t writelen) { SSLConnection *sslconn = (SSLConnection *) conn; int ret = SSL_write(sslconn->ssl, buf, writelen); if (ret < 0) ssl_set_error(sslconn, ret); return ret; } static ssize_t ssl_read(Connection *conn, char *buf, size_t buflen) { SSLConnection *sslconn = (SSLConnection *) conn; int ret = SSL_read(sslconn->ssl, buf, buflen); if (ret < 0) ssl_set_error(sslconn, ret); return ret; } static void ssl_close(Connection *conn) { SSLConnection *sslconn = (SSLConnection *) conn; if (sslconn->ssl != NULL) { SSL_free(sslconn->ssl); sslconn->ssl = NULL; } if (sslconn->ssl_ctx != NULL) { SSL_CTX_free(sslconn->ssl_ctx); sslconn->ssl_ctx = NULL; } ts_plain_close(conn); } static const char * ssl_errmsg(Connection *conn) { SSLConnection *sslconn = (SSLConnection *) conn; const char *reason; static char errbuf[32]; int err = conn->err; unsigned long ecode = sslconn->errcode; /* Clear errors */ conn->err = 0; sslconn->errcode = 0; if (NULL != sslconn->ssl) { int sslerr = SSL_get_error(sslconn->ssl, err); switch (sslerr) { case SSL_ERROR_NONE: case SSL_ERROR_SSL: /* ecode should be set and handled below */ break; case SSL_ERROR_ZERO_RETURN: return "SSL error zero return"; case SSL_ERROR_WANT_READ: return "SSL error want read"; case SSL_ERROR_WANT_WRITE: return "SSL error want write"; case SSL_ERROR_WANT_CONNECT: return "SSL error want connect"; case SSL_ERROR_WANT_ACCEPT: return "SSL error want accept"; case SSL_ERROR_WANT_X509_LOOKUP: return "SSL error want X509 lookup"; case SSL_ERROR_SYSCALL: if (ecode == 0) { if (err == 0) return "EOF in SSL operation"; else if (IS_SOCKET_ERROR(err)) { /* reset error for plan_errmsg() */ conn->err = err; return ts_plain_errmsg(conn); } else return "unknown SSL syscall error"; } return "SSL error syscall"; default: break; } } if (ecode == 0) { /* Assume this was an error of the underlying socket */ if (IS_SOCKET_ERROR(err)) { /* reset error for plan_errmsg() */ conn->err = err; return ts_plain_errmsg(conn); } return "no SSL error"; } reason = ERR_reason_error_string(ecode); if (NULL != reason) return reason; snprintf(errbuf, sizeof(errbuf), "SSL error code %lu", ecode); return errbuf; } static ConnOps ssl_ops = { .size = sizeof(SSLConnection), .init = NULL, .connect = ssl_connect, .close = ssl_close, .write = ssl_write, .read = ssl_read, .set_timeout = ts_plain_set_timeout, .errmsg = ssl_errmsg, }; extern void _conn_ssl_init(void); extern void _conn_ssl_fini(void); void _conn_ssl_init(void) { SSL_library_init(); /* Always returns 1 */ SSL_load_error_strings(); ts_connection_register(CONNECTION_SSL, &ssl_ops); } void _conn_ssl_fini(void) { ERR_free_strings(); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/http.c�������������������������������������������������������������������0000664�0000000�0000000�00000005422�15100345067�0016556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include "conn.h" #include "http.h" static const char *http_error_strings[] = { [HTTP_ERROR_NONE] = "no HTTP error", [HTTP_ERROR_WRITE] = "HTTP connection write error", [HTTP_ERROR_READ] = "HTTP connection read error", [HTTP_ERROR_CONN_CLOSED] = "HTTP connection closed", [HTTP_ERROR_REQUEST_BUILD] = "could not build HTTP request", [HTTP_ERROR_RESPONSE_PARSE] = "could not parse HTTP response", [HTTP_ERROR_RESPONSE_INCOMPLETE] = "incomplete HTTP response", [HTTP_ERROR_INVALID_BUFFER_STATE] = "invalid HTTP buffer state", [HTTP_ERROR_UNKNOWN] = "unknown HTTP error", }; static const char *http_version_strings[] = { [HTTP_VERSION_10] = "HTTP/1.0", [HTTP_VERSION_11] = "HTTP/1.1", [HTTP_VERSION_INVALID] = "invalid HTTP version", }; const char * ts_http_strerror(HttpError http_errno) { return http_error_strings[http_errno]; } HttpVersion ts_http_version_from_string(const char *version) { int i; for (i = 0; i < HTTP_VERSION_INVALID; i++) if (pg_strcasecmp(http_version_strings[i], version) == 0) return i; return HTTP_VERSION_INVALID; } const char * ts_http_version_string(HttpVersion version) { return http_version_strings[version]; } /* * Send an HTTP request and receive the HTTP response on the given connection. * * Returns HTTP_ERROR_NONE (0) on success or a HTTP-specific error on failure. */ HttpError ts_http_send_and_recv(Connection *conn, HttpRequest *req, HttpResponseState *state) { const char *built_request; size_t request_len; off_t write_off = 0; HttpError err = HTTP_ERROR_NONE; int ret; built_request = ts_http_request_build(req, &request_len); if (NULL == built_request) return HTTP_ERROR_REQUEST_BUILD; while (request_len > 0) { ret = ts_connection_write(conn, built_request + write_off, request_len); if (ret < 0 || (size_t) ret > request_len) return HTTP_ERROR_WRITE; if (ret == 0) return HTTP_ERROR_CONN_CLOSED; write_off += ret; request_len -= ret; } while (err == HTTP_ERROR_NONE && !ts_http_response_state_is_done(state)) { ssize_t remaining = 0; char *buf = ts_http_response_state_next_buffer(state, &remaining); if (remaining < 0) err = HTTP_ERROR_INVALID_BUFFER_STATE; else if (remaining == 0) err = HTTP_ERROR_RESPONSE_INCOMPLETE; else { ssize_t bytes_read = ts_connection_read(conn, buf, remaining); if (bytes_read < 0) err = HTTP_ERROR_READ; /* Check for error or closed socket/EOF (ret == 0) */ else if (bytes_read == 0) err = HTTP_ERROR_CONN_CLOSED; else if (!ts_http_response_state_parse(state, bytes_read)) err = HTTP_ERROR_RESPONSE_PARSE; } } return err; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/http.h�������������������������������������������������������������������0000664�0000000�0000000�00000006707�15100345067�0016572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/jsonb.h> #define HTTP_HOST "Host" #define HTTP_CONTENT_LENGTH "Content-Length" #define HTTP_CONTENT_TYPE "Content-Type" #define MAX_RAW_BUFFER_SIZE 4096 #define MAX_REQUEST_DATA_SIZE 2048 typedef struct HttpHeader { char *name; int name_len; char *value; int value_len; struct HttpHeader *next; } HttpHeader; /******* http_request.c *******/ /* We can add more methods later, but for now we do not need others */ typedef enum HttpRequestMethod { HTTP_GET, HTTP_POST, } HttpRequestMethod; typedef enum HttpVersion { HTTP_VERSION_10, HTTP_VERSION_11, HTTP_VERSION_INVALID, } HttpVersion; typedef enum HttpError { HTTP_ERROR_NONE = 0, HTTP_ERROR_WRITE, /* Connection write error, check errno */ HTTP_ERROR_READ, /* Connection read error, check errno */ HTTP_ERROR_CONN_CLOSED, HTTP_ERROR_REQUEST_BUILD, HTTP_ERROR_RESPONSE_PARSE, HTTP_ERROR_RESPONSE_INCOMPLETE, HTTP_ERROR_INVALID_BUFFER_STATE, HTTP_ERROR_UNKNOWN, /* Should always be last */ } HttpError; /* NOTE: HttpRequest* structs are all responsible */ /* for allocating and deallocating the char* */ typedef struct HttpRequest HttpRequest; typedef struct Connection Connection; extern HttpVersion ts_http_version_from_string(const char *version); extern const char *ts_http_version_string(HttpVersion version); extern void ts_http_request_init(HttpRequest *req, HttpRequestMethod method); extern HttpRequest *ts_http_request_create(HttpRequestMethod method); extern void ts_http_request_destroy(HttpRequest *req); /* Assume that uri is null-terminated */ extern void ts_http_request_set_uri(HttpRequest *req, const char *uri); extern void ts_http_request_set_version(HttpRequest *req, HttpVersion version); /* Assume that name and value are null-terminated */ extern void ts_http_request_set_header(HttpRequest *req, const char *name, const char *value); extern void ts_http_request_set_body_jsonb(HttpRequest *req, const Jsonb *json); /* Serialize the request into char *dst. Return the length of request in optional size pointer*/ extern const char *ts_http_request_build(HttpRequest *req, size_t *buf_size); /******* http_response.c *******/ typedef struct HttpResponseState HttpResponseState; extern void ts_http_response_state_init(HttpResponseState *state); extern HttpResponseState *ts_http_response_state_create(void); extern void ts_http_response_state_destroy(HttpResponseState *state); /* Accessor Functions */ extern bool ts_http_response_state_is_done(HttpResponseState *state); extern bool ts_http_response_state_valid_status(HttpResponseState *state); extern char *ts_http_response_state_next_buffer(HttpResponseState *state, ssize_t *bufsize); extern ssize_t ts_http_response_state_buffer_remaining(HttpResponseState *state); extern const char *ts_http_response_state_body_start(HttpResponseState *state); extern size_t ts_http_response_state_content_length(HttpResponseState *state); extern int ts_http_response_state_status_code(HttpResponseState *state); /* Returns false if encountered an error during parsing */ extern bool ts_http_response_state_parse(HttpResponseState *state, size_t bytes); extern const char *ts_http_strerror(HttpError http_errno); extern HttpError ts_http_send_and_recv(Connection *conn, HttpRequest *req, HttpResponseState *state); ���������������������������������������������������������timescaledb-2.23.0/src/net/http_request.c�����������������������������������������������������������0000664�0000000�0000000�00000015151�15100345067�0020326�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <lib/stringinfo.h> #include <utils/memutils.h> #include "http.h" #define SPACE ' ' #define COLON ':' #define CARRIAGE '\r' #define NEW_LINE '\n' /* So that http_response.c can find this function */ HttpHeader *ts_http_header_create(const char *name, size_t name_len, const char *value, size_t value_len, HttpHeader *next); HttpHeader * ts_http_header_create(const char *name, size_t name_len, const char *value, size_t value_len, HttpHeader *next) { HttpHeader *new_header = palloc(sizeof(HttpHeader)); memset(new_header, 0, sizeof(*new_header)); new_header->name = palloc(name_len + 1); if (name_len > 0) memcpy(new_header->name, name, name_len); new_header->name[name_len] = '\0'; new_header->name_len = name_len; new_header->value = palloc(value_len + 1); if (value_len > 0) memcpy(new_header->value, value, value_len); new_header->value[value_len] = '\0'; new_header->value_len = value_len; new_header->next = next; return new_header; } /* NOTE: The setter functions for HttpRequest should all */ /* ensure that every char * in this struct is null-terminated */ typedef struct HttpRequest { HttpRequestMethod method; char *uri; size_t uri_len; HttpVersion version; HttpHeader *headers; char *body; size_t body_len; MemoryContext context; } HttpRequest; static const char *http_method_strings[] = { [HTTP_GET] = "GET", [HTTP_POST] = "POST" }; #define METHOD_STRING(x) http_method_strings[x] #define VERSION_STRING(x) ts_http_version_string(x) /* appendBinaryStringInfo is UB if data is NULL. This function wraps it in a check that datalen > 0 */ static void appendOptionalBinaryStringInfo(StringInfo str, const char *data, int datalen) { if (datalen <= 0) return; Assert(data != NULL); appendBinaryStringInfo(str, data, datalen); } void ts_http_request_init(HttpRequest *req, HttpRequestMethod method) { req->method = method; } HttpRequest * ts_http_request_create(HttpRequestMethod method) { MemoryContext request_context = AllocSetContextCreate(CurrentMemoryContext, "Http Request", ALLOCSET_DEFAULT_SIZES); MemoryContext old = MemoryContextSwitchTo(request_context); HttpRequest *req = palloc0(sizeof(HttpRequest)); req->context = request_context; ts_http_request_init(req, method); MemoryContextSwitchTo(old); return req; } void ts_http_request_destroy(HttpRequest *req) { MemoryContextDelete(req->context); } void ts_http_request_set_uri(HttpRequest *req, const char *uri) { MemoryContext old = MemoryContextSwitchTo(req->context); int uri_len = strlen(uri); req->uri = palloc(uri_len + 1); memcpy(req->uri, uri, uri_len); req->uri[uri_len] = '\0'; req->uri_len = uri_len; MemoryContextSwitchTo(old); } void ts_http_request_set_version(HttpRequest *req, HttpVersion version) { req->version = version; } static void set_header(HttpRequest *req, const char *name, const char *value) { int name_len = strlen(name); int value_len = strlen(value); req->headers = ts_http_header_create(name, name_len, value, value_len, req->headers); } void ts_http_request_set_header(HttpRequest *req, const char *name, const char *value) { MemoryContext old = MemoryContextSwitchTo(req->context); set_header(req, name, value); MemoryContextSwitchTo(old); } void ts_http_request_set_body_jsonb(HttpRequest *req, const Jsonb *json) { MemoryContext old = MemoryContextSwitchTo(req->context); StringInfo jtext = makeStringInfo(); char content_length[10]; JsonbToCString(jtext, (JsonbContainer *) &json->root, VARSIZE(json)); req->body = jtext->data; req->body_len = jtext->len; snprintf(content_length, sizeof(content_length), "%d", jtext->len); set_header(req, HTTP_CONTENT_TYPE, "application/json"); set_header(req, HTTP_CONTENT_LENGTH, content_length); MemoryContextSwitchTo(old); } static void http_request_serialize_method(HttpRequest *req, StringInfo buf) { const char *method = METHOD_STRING(req->method); appendStringInfoString(buf, method); } static void http_request_serialize_version(HttpRequest *req, StringInfo buf) { const char *version = VERSION_STRING(req->version); appendStringInfoString(buf, version); } static void http_request_serialize_uri(HttpRequest *req, StringInfo buf) { appendOptionalBinaryStringInfo(buf, req->uri, req->uri_len); } static void http_request_serialize_char(char to_serialize, StringInfo buf) { appendStringInfoChar(buf, to_serialize); } static void http_request_serialize_body(HttpRequest *req, StringInfo buf) { appendOptionalBinaryStringInfo(buf, req->body, req->body_len); } static void http_header_serialize(HttpHeader *header, StringInfo buf) { appendOptionalBinaryStringInfo(buf, header->name, header->name_len); http_request_serialize_char(COLON, buf); http_request_serialize_char(SPACE, buf); appendOptionalBinaryStringInfo(buf, header->value, header->value_len); } static int http_header_get_content_length(HttpHeader *header) { int content_length = -1; if (!strncmp(header->name, HTTP_CONTENT_LENGTH, header->name_len)) sscanf(header->value, "%d", &content_length); return content_length; } const char * ts_http_request_build(HttpRequest *req, size_t *buf_size) { /* serialize into this buf, which is allocated on caller's memory context */ StringInfoData buf; HttpHeader *cur_header; int content_length = 0; bool verified_content_length = false; initStringInfo(&buf); http_request_serialize_method(req, &buf); http_request_serialize_char(SPACE, &buf); http_request_serialize_uri(req, &buf); http_request_serialize_char(SPACE, &buf); http_request_serialize_version(req, &buf); http_request_serialize_char(CARRIAGE, &buf); http_request_serialize_char(NEW_LINE, &buf); cur_header = req->headers; while (cur_header != NULL) { content_length = http_header_get_content_length(cur_header); if (content_length != -1) { /* make sure it's equal to body_len */ if ((size_t) content_length != req->body_len) { return NULL; } else verified_content_length = true; } http_header_serialize(cur_header, &buf); http_request_serialize_char(CARRIAGE, &buf); http_request_serialize_char(NEW_LINE, &buf); cur_header = cur_header->next; } http_request_serialize_char(CARRIAGE, &buf); http_request_serialize_char(NEW_LINE, &buf); if (!verified_content_length) { /* Then there was no header field for Content-Length */ if (req->body_len != 0) { return NULL; } } http_request_serialize_body(req, &buf); /* Now everything lives in buf.data */ if (buf_size != NULL) *buf_size = buf.len; return buf.data; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/net/http_response.c����������������������������������������������������������0000664�0000000�0000000�00000021525�15100345067�0020476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <lib/stringinfo.h> #include <utils/memutils.h> #include "http.h" #define CARRIAGE_RETURN '\r' #define NEW_LINE '\n' #define SEP_CHAR ':' #define HTTP_VERSION_BUFFER_SIZE 128 extern HttpHeader *ts_http_header_create(const char *name, size_t name_len, const char *value, size_t value_len, HttpHeader *next); typedef enum HttpParseState { HTTP_STATE_STATUS, HTTP_STATE_INTERM, /* received a single \r */ HTTP_STATE_HEADER_NAME, /* received \r\n */ HTTP_STATE_HEADER_VALUE, HTTP_STATE_ALMOST_DONE, HTTP_STATE_BODY, HTTP_STATE_ERROR, HTTP_STATE_DONE, } HttpParseState; typedef struct HttpResponseState { MemoryContext context; char version[HTTP_VERSION_BUFFER_SIZE]; char raw_buffer[MAX_RAW_BUFFER_SIZE]; /* The next read should copy data into the buffer starting here */ off_t offset; off_t parse_offset; size_t cur_header_name_len; size_t cur_header_value_len; char *cur_header_name; char *cur_header_value; HttpHeader *headers; int status_code; size_t content_length; char *body_start; HttpParseState state; } HttpResponseState; void ts_http_response_state_init(HttpResponseState *state) { state->status_code = -1; state->state = HTTP_STATE_STATUS; } HttpResponseState * ts_http_response_state_create() { MemoryContext context = AllocSetContextCreate(CurrentMemoryContext, "Http Response", ALLOCSET_DEFAULT_SIZES); MemoryContext old = MemoryContextSwitchTo(context); HttpResponseState *ret = palloc(sizeof(HttpResponseState)); memset(ret, 0, sizeof(*ret)); ret->context = context; ts_http_response_state_init(ret); MemoryContextSwitchTo(old); return ret; } void ts_http_response_state_destroy(HttpResponseState *state) { MemoryContextDelete(state->context); } bool ts_http_response_state_valid_status(HttpResponseState *state) { /* If the status code hasn't been parsed yet, return */ if (state->status_code == -1) return true; /* If it's a bad status code, then bad! */ if (state->status_code / 100 == 2) return true; return false; } bool ts_http_response_state_is_done(HttpResponseState *state) { return (state->state == HTTP_STATE_DONE); } /* * Return the remaining buffer space. * * Returns 0 or a positive number, or -1 for invalid state. * */ ssize_t ts_http_response_state_buffer_remaining(HttpResponseState *state) { Assert(state->offset <= MAX_RAW_BUFFER_SIZE); return MAX_RAW_BUFFER_SIZE - state->offset; } /* * Return a pointer to the next buffer to write to. * * Optionally, return the buffer size via the bufsize parameter. */ char * ts_http_response_state_next_buffer(HttpResponseState *state, ssize_t *bufsize) { Assert(state->offset <= MAX_RAW_BUFFER_SIZE); if (NULL != bufsize) *bufsize = ts_http_response_state_buffer_remaining(state); /* * This should not happen, be we return NULL in this case and let caller * deal with it */ if (state->offset > MAX_RAW_BUFFER_SIZE) return NULL; return state->raw_buffer + state->offset; } const char * ts_http_response_state_body_start(HttpResponseState *state) { return state->body_start; } int ts_http_response_state_status_code(HttpResponseState *state) { return state->status_code; } size_t ts_http_response_state_content_length(HttpResponseState *state) { return state->content_length; } static bool http_parse_version(HttpResponseState *state) { return ts_http_version_from_string(state->version) != HTTP_VERSION_INVALID; } static void http_parse_status(HttpResponseState *state, const char next) { char *raw_buf = palloc(state->parse_offset + 1); switch (next) { case CARRIAGE_RETURN: /* * Then we are at the end of status and can use sscanf * * Need a second %s inside the sscanf so that we make sure to get * all of the digits of the status code */ memcpy(raw_buf, state->raw_buffer, state->parse_offset); raw_buf[state->parse_offset] = '\0'; state->state = HTTP_STATE_ERROR; memset(state->version, '\0', sizeof(state->version)); if (sscanf(raw_buf, "%127s%*[ ]%d%*[ ]%*s", state->version, &state->status_code) == 2) { if (http_parse_version(state)) state->state = HTTP_STATE_INTERM; else state->state = HTTP_STATE_ERROR; } break; case NEW_LINE: state->state = HTTP_STATE_ERROR; break; default: /* Don't try to parse Status line until we see '\r' */ break; } pfree(raw_buf); } static void http_response_state_add_header(HttpResponseState *state, const char *name, size_t name_len, const char *value, size_t value_len) { MemoryContext old = MemoryContextSwitchTo(state->context); HttpHeader *new_header = ts_http_header_create(name, name_len, value, value_len, state->headers); state->headers = new_header; MemoryContextSwitchTo(old); } static void http_parse_interm(HttpResponseState *state, const char next) { int temp_length; switch (next) { case NEW_LINE: state->state = HTTP_STATE_HEADER_NAME; /* Store another header */ http_response_state_add_header(state, state->cur_header_name, state->cur_header_name_len, state->cur_header_value, state->cur_header_value_len); /* Check if the line we just read is Content-Length */ if (state->cur_header_name != NULL && strncmp(HTTP_CONTENT_LENGTH, state->cur_header_name, state->cur_header_name_len) == 0) { if (sscanf(state->cur_header_value, "%d", &temp_length) == 1) { state->content_length = temp_length; } else { state->state = HTTP_STATE_ERROR; break; } } state->cur_header_name_len = 0; state->cur_header_value_len = 0; break; default: state->state = HTTP_STATE_ERROR; break; } } static void http_parse_header_name(HttpResponseState *state, const char next) { switch (next) { case SEP_CHAR: state->state = HTTP_STATE_HEADER_VALUE; state->cur_header_value = state->raw_buffer + state->parse_offset + 1; break; case CARRIAGE_RETURN: if (state->cur_header_name_len == 0) { state->state = HTTP_STATE_ALMOST_DONE; break; } else { /* * I'm guessing getting a carriage return in the middle of * field */ /* name is bad... */ state->state = HTTP_STATE_ERROR; break; } default: /* Header names are only alphabetic chars */ if (('a' <= next && next <= 'z') || ('A' <= next && next <= 'Z') || next == '-') { /* Good, then the next call will save this char */ state->cur_header_name_len++; break; } state->state = HTTP_STATE_ERROR; break; } } /* We do not customize to header_name. Assume all non \r or \n chars are allowed. */ static void http_parse_header_value(HttpResponseState *state, const char next) { /* Allow everything except... \r, \n */ switch (next) { case CARRIAGE_RETURN: state->state = HTTP_STATE_INTERM; break; case NEW_LINE: /* \n is not allowed */ state->state = HTTP_STATE_ERROR; break; default: state->cur_header_value_len++; break; } } static void http_parse_almost_done(HttpResponseState *state, const char next) { /* Don't do anything, this is intermediate state */ switch (next) { case NEW_LINE: state->state = HTTP_STATE_BODY; state->body_start = state->raw_buffer + state->parse_offset + 1; /* Special case if there is no body */ if (state->content_length == 0) state->state = HTTP_STATE_DONE; break; default: state->state = HTTP_STATE_ERROR; break; } } bool ts_http_response_state_parse(HttpResponseState *state, size_t bytes) { state->offset += bytes; if (state->offset > MAX_RAW_BUFFER_SIZE) state->offset = MAX_RAW_BUFFER_SIZE; /* Each state function will do the state AND transition */ while (state->parse_offset < state->offset) { char next = state->raw_buffer[state->parse_offset]; switch (state->state) { case HTTP_STATE_STATUS: http_parse_status(state, next); state->parse_offset++; break; case HTTP_STATE_INTERM: http_parse_interm(state, next); state->parse_offset++; state->cur_header_name = state->raw_buffer + state->parse_offset; break; case HTTP_STATE_HEADER_NAME: http_parse_header_name(state, next); state->parse_offset++; break; case HTTP_STATE_HEADER_VALUE: http_parse_header_value(state, next); state->parse_offset++; break; case HTTP_STATE_ALMOST_DONE: http_parse_almost_done(state, next); state->parse_offset++; break; case HTTP_STATE_BODY: /* Stay here until we have read content_length */ if ((state->body_start + state->content_length) <= (state->raw_buffer + state->offset)) { /* Then we are done */ state->state = HTTP_STATE_DONE; return true; } state->parse_offset++; break; case HTTP_STATE_ERROR: return false; case HTTP_STATE_DONE: return true; } } return true; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/�����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015752�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/CMakeLists.txt���������������������������������������������������������0000664�0000000�0000000�00000000372�15100345067�0020514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/modify_hypertable.c ${CMAKE_CURRENT_SOURCE_DIR}/modify_hypertable_exec.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) add_subdirectory(chunk_append) add_subdirectory(constraint_aware_append) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/����������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020411�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/CMakeLists.txt��������������������������������������������0000664�0000000�0000000�00000000431�15100345067�0023147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Add all *.c to sources in upperlevel directory set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/chunk_append.c ${CMAKE_CURRENT_SOURCE_DIR}/exec.c ${CMAKE_CURRENT_SOURCE_DIR}/planner.c ${CMAKE_CURRENT_SOURCE_DIR}/transform.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/chunk_append.c��������������������������������������������0000664�0000000�0000000�00000043577�15100345067�0023234�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <nodes/nodeFuncs.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/tlist.h> #include <utils/builtins.h> #include <utils/typcache.h> #include "func_cache.h" #include "guc.h" #include "nodes/chunk_append/chunk_append.h" #include "planner/planner.h" static Var *find_equality_join_var(Var *sort_var, Index ht_relid, Oid eq_opr, List *join_conditions); static CustomPathMethods chunk_append_path_methods = { .CustomName = "ChunkAppend", .PlanCustomPath = ts_chunk_append_plan_create, }; bool ts_is_chunk_append_path(Path *path) { return IsA(path, CustomPath) && castNode(CustomPath, path)->methods == &chunk_append_path_methods; } static bool has_joins(FromExpr *jointree) { return list_length(jointree->fromlist) != 1 || !IsA(linitial(jointree->fromlist), RangeTblRef); } /* * Create the appropriate subpath for the outer MergeAppend * node depending on the number of paths in the current group: * Combine two or more group members into a mergeAppend node * or append a single member as is. * Members of the same group contain data of the same chunk, * so they are combined into a MergeAppend node corresponding * to that single chunk. */ static void create_group_subpath(PlannerInfo *root, RelOptInfo *rel, List *group, List *pathkeys, Relids required_outer, List *partitioned_rels, List **nested_children) { if (list_length(group) > 1) { MergeAppendPath *append = create_merge_append_path(root, rel, group, pathkeys, required_outer); *nested_children = lappend(*nested_children, append); } else { /* If group only has 1 member we can add it directly */ *nested_children = lappend(*nested_children, linitial(group)); } } ChunkAppendPath * ts_chunk_append_path_copy(ChunkAppendPath *ca, List *subpaths, PathTarget *pathtarget) { ListCell *lc; double total_cost = 0, rows = 0; ChunkAppendPath *new = palloc(sizeof(ChunkAppendPath)); memcpy(new, ca, sizeof(ChunkAppendPath)); new->cpath.custom_paths = subpaths; foreach (lc, subpaths) { Path *child = lfirst(lc); total_cost += child->total_cost; rows += child->rows; } new->cpath.path.total_cost = total_cost; new->cpath.path.rows = rows; new->cpath.path.pathtarget = copy_pathtarget(pathtarget); return new; } Path * ts_chunk_append_path_create(PlannerInfo *root, RelOptInfo *rel, Hypertable *ht, Path *subpath, bool parallel_aware, bool ordered, List *nested_oids) { ChunkAppendPath *path; ListCell *lc; double rows = 0.0; Cost total_cost = 0.0; List *children = NIL; path = (ChunkAppendPath *) newNode(sizeof(ChunkAppendPath), T_CustomPath); path->cpath.path.pathtype = T_CustomScan; path->cpath.path.parent = rel; path->cpath.path.pathtarget = rel->reltarget; path->cpath.path.param_info = subpath->param_info; /* * We keep the pathkeys from the original path here because * the original path was either a MergeAppendPath and this * will become an ordered append or the original path is an * AppendPath and since we do not reorder children the order * will be kept intact. For the AppendPath case with pathkeys * it was most likely an Append with only a single child. * We could skip the ChunkAppend path creation if there is * only a single child but we decided earlier that ChunkAppend * would be beneficial for this query so we treat it the same * as if it had multiple children. */ Assert(IsA(subpath, AppendPath) || IsA(subpath, MergeAppendPath)); path->cpath.path.pathkeys = subpath->pathkeys; path->cpath.path.parallel_aware = ts_guc_enable_parallel_chunk_append ? parallel_aware : false; path->cpath.path.parallel_safe = subpath->parallel_safe; path->cpath.path.parallel_workers = subpath->parallel_workers; /* * Set flags. We can set CUSTOMPATH_SUPPORT_BACKWARD_SCAN and * CUSTOMPATH_SUPPORT_MARK_RESTORE. The only interesting flag is the first * one (backward scan), but since we are not scanning a real relation we * need not indicate that we support backward scans. Lower-level index * scanning nodes will scan backward if necessary, so once tuples get to * this node they will be in a given order already. */ path->cpath.flags = 0; path->cpath.methods = &chunk_append_path_methods; /* * Figure out whether there's a hard limit on the number of rows that * query_planner's result subplan needs to return. Even if we know a * hard limit overall, it doesn't apply if the query has any * grouping/aggregation operations, or SRFs in the tlist. */ if (root->parse->groupClause || root->parse->groupingSets || root->parse->distinctClause || root->parse->hasAggs || root->parse->hasWindowFuncs || root->hasHavingQual || has_joins(root->parse->jointree) || root->limit_tuples > PG_INT32_MAX || root->parse->hasTargetSRFs || !pathkeys_contained_in(root->sort_pathkeys, subpath->pathkeys)) path->limit_tuples = -1; else path->limit_tuples = (int) root->limit_tuples; /* * check if we should do startup and runtime exclusion */ foreach (lc, rel->baserestrictinfo) { RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc); /* * The external parameters (e.g. from parameterized prepared statements) * are constant during query run time, so we can use them for startup * exclusion. * The join parameters have multiple values, so they are only used for * runtime exclusion. */ if (contain_mutable_functions((Node *) rinfo->clause) || ts_contains_external_param((Node *) rinfo->clause)) { path->startup_exclusion = true; } if (ts_guc_enable_runtime_exclusion && ts_contains_join_param((Node *) rinfo->clause)) { ListCell *lc_var; /* We have two types of exclusion: * * Parent exclusion fires if the entire hypertable can be excluded. * This happens if doing things like joining against a parameter * value that is an empty array or NULL. It doesn't happen often, * but when it does, it speeds up the query immensely. It's also cheap * to check for this condition as you check this once per hypertable * at runtime. * * Child exclusion works by seeing if there is a contradiction between * the chunks constraints and the expression on parameter values. For example, * it can evaluate whether a time parameter from a subquery falls outside * the range of the chunk. It is more widely applicable than the parent * exclusion but is also more expensive to evaluate since you have to perform * the check on every chunk. Child exclusion can only apply if one of the quals * involves a partitioning column. * */ path->runtime_exclusion_parent = true; foreach (lc_var, pull_var_clause((Node *) rinfo->clause, 0)) { Var *var = lfirst(lc_var); /* * varattno 0 is whole row and varattno less than zero are * system columns so we skip those even though * ts_is_partitioning_column would return the correct * answer for those as well */ if ((Index) var->varno == rel->relid && var->varattno > 0 && ts_is_partitioning_column(ht, var->varattno)) { path->runtime_exclusion_children = true; break; } } } } /* * Our strategy is to use child exclusion if possible (if a partitioning * column is used) and fall back to parent exclusion if we can't use child * exclusion. Please note: there is no point to using both child and parent * exclusion at the same time since child exclusion would always exclude * the same chunks that parent exclusion would. */ if (path->runtime_exclusion_parent && path->runtime_exclusion_children) path->runtime_exclusion_parent = false; /* * Make sure our subpath is either an Append or MergeAppend node */ switch (nodeTag(subpath)) { case T_AppendPath: { AppendPath *append = castNode(AppendPath, subpath); if (append->path.parallel_aware && append->first_partial_path > 0) path->first_partial_path = append->first_partial_path; children = append->subpaths; break; } case T_MergeAppendPath: /* * check if ordered append is applicable, only assert ordered here * checked properly in ts_ordered_append_should_optimize */ Assert(ordered); /* * we only push down LIMIT for ordered append */ path->pushdown_limit = true; children = castNode(MergeAppendPath, subpath)->subpaths; break; default: elog(ERROR, "invalid child of chunk append: %s", ts_get_node_name((Node *) subpath)); break; } if (!ordered) { path->cpath.custom_paths = children; } else if (ht->space->num_dimensions == 1) { List *nested_children = NIL; /* * Convert the sort nodes that refer to the same chunk into a single * mergeAppend node to combine compressed and uncompressed chunk output. * * NB: We assume that the sort nodes referring the same chunk appear * one after the other and so we iterate through the children examining * consecutive pairs. Is it possible that this assumption is wrong? */ List *group = NIL; Oid relid = InvalidOid; foreach (lc, children) { Path *child = (Path *) lfirst(lc); /* Check if this is in new group */ if (child->parent->relid != relid) { /* if previous group had members, process them */ if (group) { create_group_subpath(root, rel, group, path->cpath.path.pathkeys, PATH_REQ_OUTER(subpath), NIL, &nested_children); group = NIL; } relid = child->parent->relid; } /* Form the new group */ group = lappend(group, child); } if (group) { create_group_subpath(root, rel, group, path->cpath.path.pathkeys, PATH_REQ_OUTER(subpath), NIL, &nested_children); } path->cpath.custom_paths = nested_children; children = nested_children; } else { /* * For space partitioning we need to change the shape of the plan * into a MergeAppend for each time slice with all space partitions below * The final plan for space partitioning will look like this: * * Custom Scan (ChunkAppend) * Hypertable: space * -> Merge Append * Sort Key: _hyper_9_56_chunk."time" * -> Index Scan * -> Index Scan * -> Index Scan * -> Merge Append * Sort Key: _hyper_9_55_chunk."time" * -> Index Scan * -> Index Scan * -> Index Scan * * We do not check sort order at this stage but injecting of Sort * nodes happens when the plan is created instead. */ ListCell *flat = list_head(children); List *nested_children = NIL; bool has_scan_childs = false; foreach (lc, nested_oids) { ListCell *lc_oid; List *current_oids = lfirst(lc); List *merge_childs = NIL; MergeAppendPath *append; /* * For each lc_oid, there will be 0, 1, or 2 matches in flat_list: 0 matches * if child was pruned, 1 match if the chunk is uncompressed or fully compressed, * 2 matches if the chunk is partially compressed. * If there are 2 matches they will also be consecutive (see assumption above) */ foreach (lc_oid, current_oids) { bool is_not_pruned = true; #ifdef USE_ASSERT_CHECKING int nmatches = 0; #endif /* Before entering the "DO" loop, check for a valid path entry */ if (flat == NULL) break; do { Path *child = (Path *) lfirst(flat); Oid parent_relid = child->parent->relid; is_not_pruned = lfirst_oid(lc_oid) == root->simple_rte_array[parent_relid]->relid; /* postgres may have pruned away some children already */ if (is_not_pruned) { #ifdef USE_ASSERT_CHECKING nmatches++; #endif merge_childs = lappend(merge_childs, child); flat = lnext(children, flat); if (flat == NULL) break; } /* if current one matched then need to check next one for match */ } while (is_not_pruned); #ifdef USE_ASSERT_CHECKING Assert(nmatches <= 2); #endif } if (list_length(merge_childs) > 1) { append = create_merge_append_path(root, rel, merge_childs, path->cpath.path.pathkeys, PATH_REQ_OUTER(subpath)); nested_children = lappend(nested_children, append); } else if (list_length(merge_childs) == 1) { has_scan_childs = true; nested_children = lappend(nested_children, linitial(merge_childs)); } } Assert(flat == NULL); /* * if we do not have scans as direct children of this * node we disable startup and runtime exclusion * in this node */ if (!has_scan_childs) { path->startup_exclusion = false; path->runtime_exclusion_parent = false; path->runtime_exclusion_children = false; } path->cpath.custom_paths = nested_children; } foreach (lc, path->cpath.custom_paths) { Path *child = lfirst(lc); /* * If there is a LIMIT clause we only include as many chunks as * planner thinks are needed to satisfy LIMIT clause. * We do this to prevent planner choosing parallel plan which might * otherwise look preferable cost wise. */ if (!path->pushdown_limit || path->limit_tuples == -1 || rows < path->limit_tuples) { total_cost += child->total_cost; rows += child->rows; } } path->cpath.path.rows = rows; path->cpath.path.total_cost = total_cost; if (path->cpath.custom_paths != NIL) path->cpath.path.startup_cost = ((Path *) linitial(path->cpath.custom_paths))->startup_cost; return &path->cpath.path; } /* * Check if conditions for doing ordered append optimization are fulfilled */ bool ts_ordered_append_should_optimize(PlannerInfo *root, RelOptInfo *rel, Hypertable *ht, List *join_conditions, int *order_attno, bool *reverse) { SortGroupClause *sort = linitial(root->parse->sortClause); TargetEntry *tle = get_sortgroupref_tle(sort->tleSortGroupRef, root->parse->targetList); RangeTblEntry *rte = root->simple_rte_array[rel->relid]; TypeCacheEntry *tce; char *column; Index ht_relid = rel->relid; Index sort_relid; Var *ht_var; Var *sort_var; /* these are checked in caller so we only Assert */ Assert(ts_guc_enable_optimizations && ts_guc_enable_ordered_append && ts_guc_enable_chunk_append); /* * only do this optimization for queries with an ORDER BY clause, * caller checked this, so only asserting */ Assert(root->parse->sortClause != NIL); if (IsA(tle->expr, Var)) { /* direct column reference */ sort_var = castNode(Var, tle->expr); } else if (IsA(tle->expr, FuncExpr) && list_length(root->parse->sortClause) == 1) { /* * check for bucketing functions * * If ORDER BY clause only has 1 expression and the expression is a * bucketing function we can still do Ordered Append, the 1 expression * limit could only be safely removed if we ensure chunk boundaries * are not crossed. * * The following example demonstrates this requirement: * * Chunk 1 has (time, device_id) * 0 1 * 0 2 * * Chunk 2 has (time, device_id) * 10 1 * 10 2 * * The ORDER BY clause is time_bucket(100,time), device_id * The result when transforming to an ordered append would be the following: * (time_bucket(100, time), device_id) * 0 1 * 0 2 * 0 1 * 0 2 * * The order of the device_ids is wrong so we cannot safely remove the MergeAppend * unless we eliminate the possibility that a bucket spans multiple chunks. */ FuncInfo *info = ts_func_cache_get_bucketing_func(castNode(FuncExpr, tle->expr)->funcid); Expr *transformed; if (info == NULL) return false; transformed = info->sort_transform(castNode(FuncExpr, tle->expr)); if (!IsA(transformed, Var)) return false; sort_var = castNode(Var, transformed); } else return false; /* ordered append won't work for system columns / whole row orderings */ if (sort_var->varattno <= 0) return false; sort_relid = sort_var->varno; tce = lookup_type_cache(sort_var->vartype, TYPECACHE_EQ_OPR | TYPECACHE_LT_OPR | TYPECACHE_GT_OPR); /* check sort operation is either less than or greater than */ if (sort->sortop != tce->lt_opr && sort->sortop != tce->gt_opr) return false; /* * check the ORDER BY column actually belongs to our hypertable */ if (sort_relid == ht_relid) { /* ORDER BY column belongs to our hypertable */ ht_var = sort_var; } else { /* * If the ORDER BY does not match our hypertable but we are joining * against another hypertable on the time column doing an ordered * append here is still beneficial because we can skip the sort * step for the MergeJoin */ if (join_conditions == NIL) return false; ht_var = find_equality_join_var(sort_var, ht_relid, tce->eq_opr, join_conditions); if (ht_var == NULL) return false; } /* Check hypertable column is the first dimension of the hypertable */ column = strVal(list_nth(rte->eref->colnames, AttrNumberGetAttrOffset(ht_var->varattno))); if (namestrcmp(&ht->space->dimensions[0].fd.column_name, column) != 0) return false; Assert(order_attno != NULL && reverse != NULL); *order_attno = ht_var->varattno; *reverse = sort->sortop == tce->lt_opr ? false : true; return true; } /* * Find equality join between column referenced by sort_var and Relation * with relid ht_relid */ static Var * find_equality_join_var(Var *sort_var, Index ht_relid, Oid eq_opr, List *join_conditions) { ListCell *lc; Index sort_relid = sort_var->varno; foreach (lc, join_conditions) { OpExpr *op = lfirst(lc); if (op->opno == eq_opr) { Var *left = linitial(op->args); Var *right = lsecond(op->args); Assert(IsA(left, Var) && IsA(right, Var)); /* Is this a join condition referencing our hypertable */ if (((Index) left->varno == sort_relid && (Index) right->varno == ht_relid && left->varattno == sort_var->varattno)) { return right; } if (((Index) left->varno == ht_relid && (Index) right->varno == sort_relid && right->varattno == sort_var->varattno)) { return left; } } } return NULL; } ���������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/chunk_append.h��������������������������������������������0000664�0000000�0000000�00000003204�15100345067�0023220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/extensible.h> #include "hypertable.h" typedef struct ChunkAppendPath { CustomPath cpath; bool startup_exclusion; bool runtime_exclusion_parent; bool runtime_exclusion_children; bool pushdown_limit; int limit_tuples; int first_partial_path; } ChunkAppendPath; extern TSDLLEXPORT ChunkAppendPath *ts_chunk_append_path_copy(ChunkAppendPath *ca, List *subpaths, PathTarget *pathtarget); extern Path *ts_chunk_append_path_create(PlannerInfo *root, RelOptInfo *rel, Hypertable *ht, Path *subpath, bool parallel_aware, bool ordered, List *nested_oids); extern Plan *ts_chunk_append_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path, List *tlist, List *clauses, List *custom_plans); extern Node *ts_chunk_append_state_create(CustomScan *cscan); extern bool ts_ordered_append_should_optimize(PlannerInfo *root, RelOptInfo *rel, Hypertable *ht, List *join_conditions, int *order_attno, bool *reverse); extern TSDLLEXPORT bool ts_is_chunk_append_path(Path *path); extern TSDLLEXPORT bool ts_is_chunk_append_plan(Plan *plan); extern Scan *ts_chunk_append_get_scan_plan(Plan *plan); void _chunk_append_init(void); extern TSDLLEXPORT List *ts_constify_restrictinfos(PlannerInfo *root, List *restrictinfos); extern TSDLLEXPORT List *ts_constify_restrictinfo_params(PlannerInfo *root, EState *state, List *restrictinfos); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/exec.c����������������������������������������������������0000664�0000000�0000000�00000124420�15100345067�0021504�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_collation.h> #include <executor/executor.h> #include <executor/nodeSubplan.h> #include <fmgr.h> #include <miscadmin.h> #include <nodes/bitmapset.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/plancat.h> #include <optimizer/prep.h> #include <optimizer/restrictinfo.h> #include <parser/parsetree.h> #include <rewrite/rewriteManip.h> #include <utils/builtins.h> #include <utils/memutils.h> #include <utils/ruleutils.h> #include <utils/typcache.h> #include <math.h> #include "compat/compat.h" #include "loader/lwlocks.h" #include "nodes/chunk_append/chunk_append.h" #include "planner/planner.h" #include "transform.h" #include "ts_catalog/chunk_column_stats.h" #if PG18_GE #include <commands/explain_format.h> #endif #define INVALID_SUBPLAN_INDEX (-1) #define NO_MATCHING_SUBPLANS (-2) typedef enum SubplanState { SUBPLAN_STATE_INCLUDED = 1 << 0, /* Used and not removed by startup exclusion */ SUBPLAN_STATE_FINISHED = 1 << 1, /* The subplan is finished */ } SubplanState; /* ParallelChunkAppendState is stored in shared memory to coordinate the parallel workers. * * subplan_state is accessed by two different indexes. This is done because a C struct can have only * one FLEXIBLE_ARRAY_MEMBER, two pieces of information must be stored per subplan in shared memory, * and computing a mapping between both indexes is avoided in the current implementation. * * The first index is the position of the subplan in initial_subplans. This index is used to * get/set the flag SUBPLAN_STATE_INCLUDED. * * The second index is the position of a subplan in filtered_subplans. This index is used to get/set * the flag SUBPLAN_STATE_FINISHED. */ typedef struct ParallelChunkAppendState { int next_plan; int filtered_first_partial_plan; uint32 subplan_state[FLEXIBLE_ARRAY_MEMBER]; /* See SubplanState */ } ParallelChunkAppendState; typedef struct ChunkAppendState { CustomScanState csstate; PlanState **subplanstates; MemoryContext exclusion_ctx; int num_subplans; int first_partial_plan; int filtered_first_partial_plan; int current; Oid ht_reloid; bool startup_exclusion; bool runtime_exclusion_parent; bool runtime_exclusion_children; bool runtime_initialized; uint32 limit; #ifdef USE_ASSERT_CHECKING bool init_done; #endif /* list of subplans after planning */ List *initial_subplans; /* list of constraints indexed like initial_subplans */ List *initial_constraints; /* list of restrictinfo clauses indexed like initial_subplans */ List *initial_ri_clauses; /* List of restrictinfo clauses on the parent hypertable */ List *initial_parent_clauses; /* list of subplans after startup exclusion */ List *filtered_subplans; /* list of relation constraints after startup exclusion */ List *filtered_constraints; /* list of restrictinfo clauses after startup exclusion */ List *filtered_ri_clauses; /* included subplans by startup exclusion */ Bitmapset *included_subplans_by_se; /* valid subplans for runtime exclusion */ Bitmapset *valid_subplans; Bitmapset *params; /* sort options if this append is ordered, only used for EXPLAIN */ List *sort_options; /* number of loops and exclusions for EXPLAIN */ int runtime_number_loops; int runtime_number_exclusions_parent; int runtime_number_exclusions_children; LWLock *lock; ParallelContext *pcxt; ParallelChunkAppendState *pstate; EState *estate; int eflags; void (*choose_next_subplan)(struct ChunkAppendState *); } ChunkAppendState; static TupleTableSlot *chunk_append_exec(CustomScanState *node); static void chunk_append_begin(CustomScanState *node, EState *estate, int eflags); static void chunk_append_end(CustomScanState *node); static void chunk_append_rescan(CustomScanState *node); static void chunk_append_explain(CustomScanState *node, List *ancestors, ExplainState *es); static Size chunk_append_estimate_dsm(CustomScanState *node, ParallelContext *pcxt); static void chunk_append_initialize_dsm(CustomScanState *node, ParallelContext *pcxt, void *coordinate); static void chunk_append_reinitialize_dsm(CustomScanState *node, ParallelContext *pcxt, void *coordinate); static void chunk_append_initialize_worker(CustomScanState *node, shm_toc *toc, void *coordinate); static CustomExecMethods chunk_append_state_methods = { .BeginCustomScan = chunk_append_begin, .ExecCustomScan = chunk_append_exec, .EndCustomScan = chunk_append_end, .ReScanCustomScan = chunk_append_rescan, .ExplainCustomScan = chunk_append_explain, .EstimateDSMCustomScan = chunk_append_estimate_dsm, .InitializeDSMCustomScan = chunk_append_initialize_dsm, .ReInitializeDSMCustomScan = chunk_append_reinitialize_dsm, .InitializeWorkerCustomScan = chunk_append_initialize_worker, }; static void choose_next_subplan_non_parallel(ChunkAppendState *state); static void choose_next_subplan_for_worker(ChunkAppendState *state); static bool can_exclude_chunk(List *constraints, List *baserestrictinfo); static void do_startup_exclusion(ChunkAppendState *state); static Node *constify_param_mutator(Node *node, void *context); static void initialize_constraints(ChunkAppendState *state, List *initial_rt_indexes); static LWLock *chunk_append_get_lock_pointer(void); static void show_sort_group_keys(ChunkAppendState *planstate, List *ancestors, ExplainState *es); static void show_sortorder_options(StringInfo buf, Node *sortexpr, Oid sortOperator, Oid collation, bool nullsFirst); static void perform_plan_init(ChunkAppendState *state, EState *estate, int eflags); Node * ts_chunk_append_state_create(CustomScan *cscan) { ChunkAppendState *state; List *settings = linitial(cscan->custom_private); state = (ChunkAppendState *) newNode(sizeof(ChunkAppendState), T_CustomScanState); state->csstate.methods = &chunk_append_state_methods; state->initial_subplans = cscan->custom_plans; state->initial_ri_clauses = lsecond(cscan->custom_private); state->sort_options = lfourth(cscan->custom_private); state->initial_parent_clauses = lfirst(list_nth_cell(cscan->custom_private, 4)); state->startup_exclusion = (bool) linitial_int(settings); state->runtime_exclusion_parent = (bool) lsecond_int(settings); state->runtime_exclusion_children = (bool) lthird_int(settings); state->limit = lfourth_int(settings); state->first_partial_plan = lfirst_int(list_nth_cell(settings, 4)); state->filtered_subplans = state->initial_subplans; state->filtered_ri_clauses = state->initial_ri_clauses; state->filtered_first_partial_plan = state->first_partial_plan; state->current = INVALID_SUBPLAN_INDEX; state->choose_next_subplan = choose_next_subplan_non_parallel; state->exclusion_ctx = AllocSetContextCreate(CurrentMemoryContext, "ChunkApppend exclusion", ALLOCSET_DEFAULT_SIZES); return (Node *) state; } static void do_startup_exclusion(ChunkAppendState *state) { List *filtered_children = NIL; List *filtered_ri_clauses = NIL; List *filtered_constraints = NIL; ListCell *lc_plan; ListCell *lc_clauses; ListCell *lc_constraints; int i = -1; int filtered_first_partial_plan = state->first_partial_plan; /* * create skeleton plannerinfo for estimate_expression_value */ PlannerGlobal glob = { .boundParams = state->csstate.ss.ps.state->es_param_list_info, }; PlannerInfo root = { .glob = &glob, }; /* Reset included subplans */ state->included_subplans_by_se = NULL; /* * clauses and constraints should always have the same length as initial_subplans */ Assert(list_length(state->initial_subplans) == list_length(state->initial_ri_clauses)); Assert(list_length(state->initial_subplans) == list_length(state->initial_constraints)); forthree (lc_plan, state->initial_subplans, lc_constraints, state->initial_constraints, lc_clauses, state->initial_ri_clauses) { List *restrictinfos = NIL; List *ri_clauses = lfirst(lc_clauses); ListCell *lc; Scan *scan = ts_chunk_append_get_scan_plan(lfirst(lc_plan)); i++; /* * If this is a base rel (chunk), check if it can be * excluded from the scan. Otherwise, fall through. */ if (scan != NULL && scan->scanrelid) { foreach (lc, ri_clauses) { RestrictInfo *ri = makeNode(RestrictInfo); ri->clause = lfirst(lc); restrictinfos = lappend(restrictinfos, ri); } restrictinfos = ts_constify_restrictinfos(&root, restrictinfos); if (can_exclude_chunk(lfirst(lc_constraints), restrictinfos)) { if (i < state->first_partial_plan) filtered_first_partial_plan--; continue; } /* * if this node does runtime exclusion on the children we keep the constified * expressions to save us some work during runtime exclusion */ if (state->runtime_exclusion_children) { List *const_ri_clauses = NIL; foreach (lc, restrictinfos) { RestrictInfo *ri = lfirst(lc); const_ri_clauses = lappend(const_ri_clauses, ri->clause); } ri_clauses = const_ri_clauses; } } state->included_subplans_by_se = bms_add_member(state->included_subplans_by_se, i); filtered_children = lappend(filtered_children, lfirst(lc_plan)); filtered_ri_clauses = lappend(filtered_ri_clauses, ri_clauses); filtered_constraints = lappend(filtered_constraints, lfirst(lc_constraints)); } state->filtered_subplans = filtered_children; state->filtered_ri_clauses = filtered_ri_clauses; state->filtered_constraints = filtered_constraints; state->filtered_first_partial_plan = filtered_first_partial_plan; Assert(list_length(state->filtered_subplans) == bms_num_members(state->included_subplans_by_se)); } /* * Complete initialization of the supplied CustomScanState. * Standard fields have been initialized by ExecInitCustomScan, * but any private fields should be initialized here. */ static void chunk_append_begin(CustomScanState *node, EState *estate, int eflags) { CustomScan *cscan = castNode(CustomScan, node->ss.ps.plan); ChunkAppendState *state = (ChunkAppendState *) node; /* CustomScan hard-codes the scan and result tuple slot to a fixed * TTSOpsVirtual ops (meaning it expects the slot ops of the child tuple to * also have this type). Oddly, when reading slots from subscan nodes * (children), there is no knowing what tuple slot ops the child slot will * have (e.g., for ChunkAppend it is common that the child is a * seqscan/indexscan that produces a TTSOpsBufferHeapTuple * slot). Unfortunately, any mismatch between slot types when projecting is * asserted by PostgreSQL. To avoid this issue, we mark the scanops as * non-fixed and reinitialize the projection state with this new setting. * * Alternatively, we could copy the child tuple into the scan slot to get * the expected ops before projection, but this would require materializing * and copying the tuple unnecessarily. */ node->ss.ps.scanopsfixed = false; /* Since we sometimes return the scan slot directly from the subnode, the * result slot is not fixed either. */ node->ss.ps.resultopsfixed = false; ExecAssignScanProjectionInfoWithVarno(&node->ss, INDEX_VAR); initialize_constraints(state, lthird(cscan->custom_private)); /* In parallel mode with a parallel_aware plan, the parallel leader performs the startup * exclusion and stores the result in shared memory (the flag SUBPLAN_STATE_INCLUDED of * pstate->subplan_state is set for all included plans). * * The parallel workers use the information from shared memory to include the same plans as the * parallel leader. This ensures that all workers work on the same subplans and we have an * agreement about the number of subplans. This is necessary to ensure that the parallel workers * work correctly and that the next subplan to be processed in the shared memory * (pstate->next_plan) pointers to the same plan in all workers. * * If the workers perform the startup exclusion individually, they may choose different subplans * (e.g., due to a "constant" function that claims to be constant but returns different * results). In that case, we have a disagreement about the plans between the workers. This * would lead to hard-to-debug problems and out-of-bounds reads when pstate->next_plan is used * for subplan selection. * */ if (IsParallelWorker() && node->ss.ps.plan->parallel_aware) { /* We are inside a parallel worker running a parallel plan. Chunk exclusion was performed by * the leader, and based on it, we will initialize the included subplans later, in * chunk_append_initialize_worker. We have to store estate and eflags here that are needed * for that initialization. * * Note: When force_parallel_mode debug GUC is set, a normal sequential ChunkAppend plan can * run inside a parallel worker. In this case, we have to perform the chunk exclusion right * away. We distinguish it by that the parallel_aware flag of the plan is not set. */ state->estate = estate; state->eflags = eflags; return; } if (state->startup_exclusion) do_startup_exclusion(state); perform_plan_init(state, estate, eflags); } /* * Perform an initialization of the filtered_subplans. */ static void perform_plan_init(ChunkAppendState *state, EState *estate, int eflags) { ListCell *lc; int i; #ifdef USE_ASSERT_CHECKING Assert(state->init_done == false); state->init_done = true; #endif state->num_subplans = list_length(state->filtered_subplans); if (state->num_subplans == 0) { state->current = NO_MATCHING_SUBPLANS; return; } state->subplanstates = (PlanState **) palloc0(state->num_subplans * sizeof(PlanState *)); i = 0; foreach (lc, state->filtered_subplans) { /* * we use an array for the states but put it in custom_ps as well * so explain and planstate_tree_walker can find it */ state->subplanstates[i] = ExecInitNode(lfirst(lc), estate, eflags); state->csstate.custom_ps = lappend(state->csstate.custom_ps, state->subplanstates[i]); /* * pass down limit to child nodes */ if (state->limit) ExecSetTupleBound(state->limit, state->subplanstates[i]); i++; } if (state->runtime_exclusion_parent || state->runtime_exclusion_children) { state->params = state->subplanstates[0]->plan->allParam; /* * make sure all params are initialized for runtime exclusion */ state->csstate.ss.ps.chgParam = bms_copy(state->subplanstates[0]->plan->allParam); } } static bool can_exclude_constraints_using_clauses(ChunkAppendState *state, List *constraints, List *clauses, PlannerInfo *root, PlanState *ps) { bool can_exclude; ListCell *lc; MemoryContext old = MemoryContextSwitchTo(state->exclusion_ctx); List *restrictinfos = NIL; foreach (lc, clauses) { RestrictInfo *ri = makeNode(RestrictInfo); ri->clause = lfirst(lc); restrictinfos = lappend(restrictinfos, ri); } restrictinfos = ts_constify_restrictinfo_params(root, ps->state, restrictinfos); can_exclude = can_exclude_chunk(constraints, restrictinfos); MemoryContextReset(state->exclusion_ctx); MemoryContextSwitchTo(old); return can_exclude; } /* * build bitmap of valid subplans for runtime exclusion */ static void initialize_runtime_exclusion(ChunkAppendState *state) { ListCell *lc_clauses, *lc_constraints; int i = 0; PlannerGlobal glob = { .boundParams = state->csstate.ss.ps.state->es_param_list_info, }; PlannerInfo root = { .glob = &glob, }; state->runtime_initialized = true; if (state->num_subplans == 0) { return; } state->runtime_number_loops++; if (state->runtime_exclusion_parent) { /* try to exclude all the chunks using the parents clauses. * here, all constraints are true but exclusion can still * happen because of things like ANY(empty set), and NULL * inference */ if (can_exclude_constraints_using_clauses(state, list_make1(makeBoolConst(true, false)), state->initial_parent_clauses, &root, &state->csstate.ss.ps)) { state->runtime_number_exclusions_parent++; return; } } if (!state->runtime_exclusion_children) { for (i = 0; i < state->num_subplans; i++) { state->valid_subplans = bms_add_member(state->valid_subplans, i); } return; } Assert(state->num_subplans == list_length(state->filtered_ri_clauses)); lc_clauses = list_head(state->filtered_ri_clauses); lc_constraints = list_head(state->filtered_constraints); /* * mark subplans as active/inactive in valid_subplans */ for (i = 0; i < state->num_subplans; i++) { PlanState *ps = state->subplanstates[i]; Scan *scan = ts_chunk_append_get_scan_plan(ps->plan); if (scan == NULL || scan->scanrelid == 0) { state->valid_subplans = bms_add_member(state->valid_subplans, i); } else { bool can_exclude = can_exclude_constraints_using_clauses(state, lfirst(lc_constraints), lfirst(lc_clauses), &root, ps); if (!can_exclude) state->valid_subplans = bms_add_member(state->valid_subplans, i); else state->runtime_number_exclusions_children++; } lc_clauses = lnext(state->filtered_ri_clauses, lc_clauses); lc_constraints = lnext(state->filtered_constraints, lc_constraints); } } /* * Fetch the next scan tuple. * * If any tuples remain, it should fill ps_ResultTupleSlot with the next * tuple in the current scan direction, and then return the tuple slot. * If not, NULL or an empty slot should be returned. */ static TupleTableSlot * chunk_append_exec(CustomScanState *node) { ChunkAppendState *state = (ChunkAppendState *) node; ExprContext *econtext = node->ss.ps.ps_ExprContext; ProjectionInfo *projinfo = node->ss.ps.ps_ProjInfo; TupleTableSlot *subslot; Assert(state->init_done == true); if (state->current == INVALID_SUBPLAN_INDEX) state->choose_next_subplan(state); while (true) { PlanState *subnode; CHECK_FOR_INTERRUPTS(); if (state->current == NO_MATCHING_SUBPLANS) return ExecClearTuple(node->ss.ps.ps_ResultTupleSlot); Assert(state->current >= 0 && state->current < state->num_subplans); subnode = state->subplanstates[state->current]; /* * get a tuple from the subplan */ subslot = ExecProcNode(subnode); if (!TupIsNull(subslot)) { /* * If the subplan gave us something check if we need * to do projection otherwise return as is. */ if (projinfo == NULL) return subslot; ResetExprContext(econtext); econtext->ecxt_scantuple = subslot; return ExecProject(projinfo); } state->choose_next_subplan(state); /* loop back and try to get a tuple from the new subplan */ } } static int get_next_subplan(ChunkAppendState *state, int last_plan) { if (last_plan == NO_MATCHING_SUBPLANS) return NO_MATCHING_SUBPLANS; if (state->runtime_exclusion_parent || state->runtime_exclusion_children) { if (!state->runtime_initialized) initialize_runtime_exclusion(state); /* * bms_next_member will return -2 (NO_MATCHING_SUBPLANS) if there are * no more members */ return bms_next_member(state->valid_subplans, last_plan); } else { int next_plan = last_plan + 1; if (next_plan >= state->num_subplans) return NO_MATCHING_SUBPLANS; return next_plan; } } static void choose_next_subplan_non_parallel(ChunkAppendState *state) { state->current = get_next_subplan(state, state->current); } static void choose_next_subplan_for_worker(ChunkAppendState *state) { ParallelChunkAppendState *pstate = state->pstate; int next_plan; int start; LWLockAcquire(state->lock, LW_EXCLUSIVE); /* mark just completed subplan as finished */ if (state->current >= 0) pstate->subplan_state[state->current] = ts_set_flags_32(pstate->subplan_state[state->current], SUBPLAN_STATE_FINISHED); if (pstate->next_plan == INVALID_SUBPLAN_INDEX) next_plan = get_next_subplan(state, INVALID_SUBPLAN_INDEX); else next_plan = pstate->next_plan; if (next_plan == NO_MATCHING_SUBPLANS) { /* all subplans are finished */ pstate->next_plan = NO_MATCHING_SUBPLANS; state->current = NO_MATCHING_SUBPLANS; LWLockRelease(state->lock); return; } start = next_plan; /* skip finished subplans */ while (ts_flags_are_set_32(pstate->subplan_state[next_plan], SUBPLAN_STATE_FINISHED)) { next_plan = get_next_subplan(state, next_plan); /* wrap around if we reach end of subplan list */ if (next_plan < 0) next_plan = get_next_subplan(state, INVALID_SUBPLAN_INDEX); if (next_plan == start || next_plan < 0) { /* * back at start of search so all subplans are finished * * next_plan should not be < 0 because this means there * are no valid subplans and then the function would * have returned at the check before the while loop but * static analysis marked this so might as well include * that in the check */ Assert(next_plan >= 0); pstate->next_plan = NO_MATCHING_SUBPLANS; state->current = NO_MATCHING_SUBPLANS; LWLockRelease(state->lock); return; } } Assert(next_plan >= 0 && next_plan < state->num_subplans); state->current = next_plan; /* * if this is not a partial plan we mark it as finished * immediately so it does not get assigned another worker */ if (next_plan < state->filtered_first_partial_plan) pstate->subplan_state[next_plan] = ts_set_flags_32(pstate->subplan_state[next_plan], SUBPLAN_STATE_FINISHED); /* advance next_plan for next worker */ pstate->next_plan = get_next_subplan(state, state->current); /* * if we reach the end of the list of subplans we set next_plan * to INVALID_SUBPLAN_INDEX to allow rechecking unfinished subplans * on next call */ if (pstate->next_plan < 0) pstate->next_plan = INVALID_SUBPLAN_INDEX; LWLockRelease(state->lock); } /* * Clean up any private data associated with the CustomScanState. * * This method is required, but it does not need to do anything if there * is no associated data or it will be cleaned up automatically. */ static void chunk_append_end(CustomScanState *node) { ChunkAppendState *state = (ChunkAppendState *) node; int i; for (i = 0; i < state->num_subplans; i++) { ExecEndNode(state->subplanstates[i]); } } /* * Rewind the current scan to the beginning and prepare to rescan the relation. */ static void chunk_append_rescan(CustomScanState *node) { ChunkAppendState *state = (ChunkAppendState *) node; int i; for (i = 0; i < state->num_subplans; i++) { if (node->ss.ps.chgParam != NULL) UpdateChangedParamSet(state->subplanstates[i], node->ss.ps.chgParam); ExecReScan(state->subplanstates[i]); } state->current = INVALID_SUBPLAN_INDEX; /* * detect changed params and reset runtime exclusion state */ if ((state->runtime_exclusion_parent || state->runtime_exclusion_children) && bms_overlap(node->ss.ps.chgParam, state->params)) { bms_free(state->valid_subplans); state->valid_subplans = NULL; state->runtime_initialized = false; } } /* * Estimate the amount of dynamic shared memory that will be required * for parallel operation. * This may be higher than the amount that will actually be used, * but it must not be lower. The return value is in bytes. * This callback is optional, and need only be supplied if this * custom scan provider supports parallel execution. */ static Size chunk_append_estimate_dsm(CustomScanState *node, ParallelContext *pcxt) { ChunkAppendState *state = (ChunkAppendState *) node; return add_size(offsetof(ParallelChunkAppendState, subplan_state), sizeof(uint32) * list_length(state->initial_subplans)); } /* * Initialize the parallel state. */ static void init_pstate(ChunkAppendState *state, ParallelChunkAppendState *pstate) { Assert(state != NULL); Assert(pstate != NULL); Assert(state->csstate.pscan_len > 0); /* The parallel worker state has to be (re-)initialized by the parallel leader */ Assert(!IsParallelWorker()); memset(pstate, 0, state->csstate.pscan_len); pstate->next_plan = INVALID_SUBPLAN_INDEX; pstate->filtered_first_partial_plan = state->filtered_first_partial_plan; /* Mark active subplans in parallel state */ int plan = -1; while ((plan = bms_next_member(state->included_subplans_by_se, plan)) >= 0) { pstate->subplan_state[plan] = ts_set_flags_32(pstate->subplan_state[plan], SUBPLAN_STATE_INCLUDED); } } /* * Initialize the dynamic shared memory that will be required for * parallel operation. * coordinate points to a shared memory area of size equal to the return * value of EstimateDSMCustomScan. * This callback is optional, and need only be supplied if this custom scan * provider supports parallel execution. */ static void chunk_append_initialize_dsm(CustomScanState *node, ParallelContext *pcxt, void *coordinate) { ChunkAppendState *state = (ChunkAppendState *) node; ParallelChunkAppendState *pstate = (ParallelChunkAppendState *) coordinate; init_pstate(state, pstate); state->lock = chunk_append_get_lock_pointer(); /* * Leader should use the same subplan selection as normal worker threads. If the user wishes to * disallow running plans on the leader they should do so via the parallel_leader_participation * GUC. */ state->choose_next_subplan = choose_next_subplan_for_worker; state->current = INVALID_SUBPLAN_INDEX; state->pcxt = pcxt; state->pstate = pstate; } /* * Re-initialize the dynamic shared memory required for parallel operation * when the custom-scan plan node is about to be re-scanned. * This callback is optional, and need only be supplied if this custom scan * provider supports parallel execution. * Recommended practice is that this callback reset only shared state, * while the ReScanCustomScan callback resets only local state. * Currently, this callback will be called before ReScanCustomScan, * but it's best not to rely on that ordering. */ static void chunk_append_reinitialize_dsm(CustomScanState *node, ParallelContext *pcxt, void *coordinate) { ChunkAppendState *state = (ChunkAppendState *) node; ParallelChunkAppendState *pstate = (ParallelChunkAppendState *) coordinate; init_pstate(state, pstate); } /* * Initialize a parallel worker's local state based on the shared state * set up by the leader during InitializeDSMCustomScan. * * This callback is optional, and need only be supplied if this custom scan * provider supports parallel execution. */ static void chunk_append_initialize_worker(CustomScanState *node, shm_toc *toc, void *coordinate) { ChunkAppendState *state = (ChunkAppendState *) node; ParallelChunkAppendState *pstate = (ParallelChunkAppendState *) coordinate; Assert(IsParallelWorker()); Assert(node->ss.ps.plan->parallel_aware); Assert(pstate != NULL); Assert(state->estate != NULL); /* Read information about included plans by startup exclusion from the parallel state */ state->filtered_first_partial_plan = pstate->filtered_first_partial_plan; List *filtered_subplans = NIL; List *filtered_ri_clauses = NIL; List *filtered_constraints = NIL; for (int plan = 0; plan < list_length(state->initial_subplans); plan++) { if (ts_flags_are_set_32(pstate->subplan_state[plan], SUBPLAN_STATE_INCLUDED)) { filtered_subplans = lappend(filtered_subplans, list_nth(state->filtered_subplans, plan)); filtered_ri_clauses = lappend(filtered_ri_clauses, list_nth(state->filtered_ri_clauses, plan)); filtered_constraints = lappend(filtered_constraints, list_nth(state->filtered_constraints, plan)); } } state->filtered_subplans = filtered_subplans; state->filtered_ri_clauses = filtered_ri_clauses; state->filtered_constraints = filtered_constraints; Assert(list_length(state->filtered_subplans) == list_length(state->filtered_ri_clauses)); Assert(list_length(state->filtered_ri_clauses) == list_length(state->filtered_constraints)); state->lock = chunk_append_get_lock_pointer(); state->choose_next_subplan = choose_next_subplan_for_worker; state->current = INVALID_SUBPLAN_INDEX; state->pstate = pstate; perform_plan_init(state, state->estate, state->eflags); Assert(state->num_subplans == list_length(state->filtered_subplans)); } /* * get a pointer to the LWLock used for coordinating * parallel workers */ static LWLock * chunk_append_get_lock_pointer() { LWLock **lock = (LWLock **) find_rendezvous_variable(RENDEZVOUS_CHUNK_APPEND_LWLOCK); if (*lock == NULL) elog(ERROR, "LWLock for coordinating parallel workers not initialized"); return *lock; } /* * Convert restriction clauses to constants expressions (i.e., if there are * mutable functions, they need to be evaluated to constants). For instance, * something like: * * ...WHERE time > now - interval '1 hour' * * becomes * * ...WHERE time > '2017-06-02 11:26:43.935712+02' */ List * ts_constify_restrictinfos(PlannerInfo *root, List *restrictinfos) { List *additional_list = NIL; ListCell *lc; foreach (lc, restrictinfos) { RestrictInfo *rinfo = lfirst(lc); Expr *constified = (Expr *) estimate_expression_value(root, (Node *) rinfo->clause); /* * Note that we have to use equal() here, because the expression mutators * always return a deep copy of the expression tree, even if nothing was * modified. */ if (!equal(rinfo->clause, constified)) { /* * We have constified something, so try applying the time_bucket * transformations again. This might allow us to exclude chunks * based on a parameterized time_bucket expression. */ Expr *additional_clause = ts_transform_time_bucket_comparison(constified); if (additional_clause != NULL) { /* * We successfully added a filter clause based on a * parameterized time_bucket comparison, but it might contain * stable operators like comparison of timestamp to timestamptz, * so we have to evaluate them as well. */ additional_clause = ts_transform_cross_datatype_comparison(additional_clause); additional_clause = (Expr *) estimate_expression_value(root, (Node *) additional_clause); additional_list = lappend(additional_list, make_simple_restrictinfo(root, additional_clause)); } } rinfo->clause = constified; } return list_concat(restrictinfos, additional_list); } List * ts_constify_restrictinfo_params(PlannerInfo *root, EState *state, List *restrictinfos) { ListCell *lc; foreach (lc, restrictinfos) { RestrictInfo *rinfo = lfirst(lc); rinfo->clause = (Expr *) constify_param_mutator((Node *) rinfo->clause, state); rinfo->clause = (Expr *) estimate_expression_value(root, (Node *) rinfo->clause); } return restrictinfos; } static Node * constify_param_mutator(Node *node, void *context) { if (node == NULL) return NULL; /* Don't descend into subplans to constify their parameters, because they may not be valid yet */ if (IsA(node, SubPlan)) return node; if (IsA(node, Param)) { Param *param = castNode(Param, node); EState *estate = (EState *) context; if (param->paramkind == PARAM_EXEC) { TypeCacheEntry *tce = lookup_type_cache(param->paramtype, 0); ParamExecData prm = estate->es_param_exec_vals[param->paramid]; if (prm.execPlan != NULL) { ExprContext *econtext = GetPerTupleExprContext(estate); ExecSetParamPlan(prm.execPlan, econtext); // reload prm as it may have been changed by ExecSetParamPlan call above. prm = estate->es_param_exec_vals[param->paramid]; } if (prm.execPlan == NULL) return (Node *) makeConst(param->paramtype, param->paramtypmod, param->paramcollid, tce->typlen, prm.value, prm.isnull, tce->typbyval); } return node; } return expression_tree_mutator(node, constify_param_mutator, context); } /* * stripped down version of postgres get_relation_constraints */ static List * ca_get_relation_constraints(Oid relationObjectId, Index varno, bool include_notnull) { List *result = NIL; Relation relation; TupleConstr *constr; /* * We assume the relation has already been safely locked. */ relation = table_open(relationObjectId, AccessShareLock); constr = relation->rd_att->constr; if (constr != NULL) { int num_check = constr->num_check; int i; for (i = 0; i < num_check; i++) { Node *cexpr; /* * If this constraint hasn't been fully validated yet, we must * ignore it here. */ if (!constr->check[i].ccvalid) continue; cexpr = stringToNode(constr->check[i].ccbin); /* * Run each expression through const-simplification and * canonicalization. This is not just an optimization, but is * necessary, because we will be comparing it to * similarly-processed qual clauses, and may fail to detect valid * matches without this. This must match the processing done to * qual clauses in preprocess_expression()! (We can skip the * stuff involving subqueries, however, since we don't allow any * in check constraints.) */ cexpr = eval_const_expressions(NULL, cexpr); cexpr = (Node *) canonicalize_qual((Expr *) cexpr, true); /* Fix Vars to have the desired varno */ if (varno != 1) ChangeVarNodes(cexpr, 1, varno, 0); /* * Finally, convert to implicit-AND format (that is, a List) and * append the resulting item(s) to our output list. */ result = list_concat(result, make_ands_implicit((Expr *) cexpr)); } /* Add NOT NULL constraints in expression form, if requested */ if (include_notnull && constr->has_not_null) { int natts = relation->rd_att->natts; for (i = 1; i <= natts; i++) { Form_pg_attribute att = TupleDescAttr(relation->rd_att, i - 1); if (att->attnotnull && !att->attisdropped) { NullTest *ntest = makeNode(NullTest); ntest->arg = (Expr *) makeVar(varno, i, att->atttypid, att->atttypmod, att->attcollation, 0); ntest->nulltesttype = IS_NOT_NULL; /* * argisrow=false is correct even for a composite column, * because attnotnull does not represent a SQL-spec IS NOT * NULL test in such a case, just IS DISTINCT FROM NULL. */ ntest->argisrow = false; ntest->location = -1; result = lappend(result, ntest); } } } if (ts_guc_enable_chunk_skipping) { /* Add column range min/max ranges in 'CHECK CONSTRAINT' form */ result = list_concat(result, ts_chunk_column_stats_construct_check_constraints(relation, relationObjectId, varno)); } } table_close(relation, NoLock); return result; } /* * Exclude child relations (chunks) at execution time based on constraints. * * constraints is the list of constraint expressions of the relation * baserestrictinfo is the list of RestrictInfos */ static bool can_exclude_chunk(List *constraints, List *baserestrictinfo) { /* * Detect constant-FALSE-or-NULL restriction clauses. If we have such a * clause, no rows from the chunk are going to match. Unlike the postgres * analog of this code in relation_excluded_by_constraints, we can't expect * a single const false restrictinfo in this case, because we don't try to * fold the restrictinfos after evaluating the mutable functions. * We have to check this separately from the subsequent predicate_refuted_by. * That function can also work with the normal CHECK constraints, and they * don't fail if the constraint evaluates to null given the restriction info. * That's why it has to prove that the CHECK constraint evaluates to false, * and this doesn't follow from having a const null restrictinfo. */ ListCell *lc; foreach (lc, baserestrictinfo) { RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc); Expr *clause = rinfo->clause; if (clause && IsA(clause, Const) && (((Const *) clause)->constisnull || !DatumGetBool(((Const *) clause)->constvalue))) return true; } /* * The constraints are effectively ANDed together, so we can just try to * refute the entire collection at once. This may allow us to make proofs * that would fail if we took them individually. * * Note: we use rel->baserestrictinfo, not safe_restrictions as might seem * an obvious optimization. Some of the clauses might be OR clauses that * have volatile and nonvolatile subclauses, and it's OK to make * deductions with the nonvolatile parts. * * We need strong refutation because we have to prove that the constraints * would yield false, not just NULL. */ if (predicate_refuted_by(constraints, baserestrictinfo, false)) return true; return false; } /* * Fetch the constraints for a relation and adjust range table indexes * if necessary. */ static void initialize_constraints(ChunkAppendState *state, List *initial_rt_indexes) { ListCell *lc_clauses, *lc_plan, *lc_relid; List *constraints = NIL; EState *estate = state->csstate.ss.ps.state; if (initial_rt_indexes == NIL) return; Assert(list_length(state->initial_subplans) == list_length(state->initial_ri_clauses)); Assert(list_length(state->initial_subplans) == list_length(initial_rt_indexes)); forthree (lc_plan, state->initial_subplans, lc_clauses, state->initial_ri_clauses, lc_relid, initial_rt_indexes) { Scan *scan = ts_chunk_append_get_scan_plan(lfirst(lc_plan)); Index initial_index = lfirst_oid(lc_relid); List *relation_constraints = NIL; if (scan != NULL && scan->scanrelid > 0) { Index rt_index = scan->scanrelid; RangeTblEntry *rte = rt_fetch(rt_index, estate->es_range_table); relation_constraints = ca_get_relation_constraints(rte->relid, rt_index, true); /* * Adjust the RangeTableEntry indexes in the restrictinfo * clauses because during planning subquery indexes may be * different from the final index after flattening. */ if (rt_index != initial_index) ChangeVarNodes(lfirst(lc_clauses), initial_index, scan->scanrelid, 0); } constraints = lappend(constraints, relation_constraints); } state->initial_constraints = constraints; state->filtered_constraints = constraints; } /* * Output additional information for EXPLAIN of a custom-scan plan node. * This callback is optional. Common data stored in the ScanState, * such as the target list and scan relation, will be shown even without * this callback, but the callback allows the display of additional, * private state. */ static void chunk_append_explain(CustomScanState *node, List *ancestors, ExplainState *es) { ChunkAppendState *state = (ChunkAppendState *) node; if (state->sort_options != NIL) show_sort_group_keys(state, ancestors, es); if (es->verbose || es->format != EXPLAIN_FORMAT_TEXT) ExplainPropertyBool("Startup Exclusion", state->startup_exclusion, es); if (es->verbose || es->format != EXPLAIN_FORMAT_TEXT) ExplainPropertyBool("Runtime Exclusion", (state->runtime_exclusion_parent || state->runtime_exclusion_children), es); if (state->startup_exclusion) ExplainPropertyInteger("Chunks excluded during startup", NULL, list_length(state->initial_subplans) - list_length(node->custom_ps), es); if (state->runtime_exclusion_parent && state->runtime_number_loops > 0) { int avg_excluded = state->runtime_number_exclusions_parent / state->runtime_number_loops; ExplainPropertyInteger("Hypertables excluded during runtime", NULL, avg_excluded, es); } if (state->runtime_exclusion_children && state->runtime_number_loops > 0) { int avg_excluded = state->runtime_number_exclusions_children / state->runtime_number_loops; ExplainPropertyInteger("Chunks excluded during runtime", NULL, avg_excluded, es); } } /* * adjusted from postgresql explain.c * since we have to keep the state in custom_private our sort state * is in lists instead of arrays */ static void show_sort_group_keys(ChunkAppendState *state, List *ancestors, ExplainState *es) { Plan *plan = state->csstate.ss.ps.plan; List *context; List *result = NIL; StringInfoData sortkeybuf; bool useprefix; int keyno; int nkeys = list_length(linitial(state->sort_options)); List *sort_indexes = linitial(state->sort_options); List *sort_ops = lsecond(state->sort_options); List *sort_collations = lthird(state->sort_options); List *sort_nulls = lfourth(state->sort_options); if (nkeys <= 0) return; initStringInfo(&sortkeybuf); /* Set up deparsing context */ context = set_deparse_context_plan(es->deparse_cxt, plan, ancestors); useprefix = (list_length(es->rtable) > 1 || es->verbose); for (keyno = 0; keyno < nkeys; keyno++) { /* find key expression in tlist */ AttrNumber keyresno = list_nth_oid(sort_indexes, keyno); TargetEntry *target = get_tle_by_resno(castNode(CustomScan, plan)->custom_scan_tlist, keyresno); char *exprstr; if (!target) elog(ERROR, "no tlist entry for key %d", keyresno); /* Deparse the expression, showing any top-level cast */ exprstr = deparse_expression((Node *) target->expr, context, useprefix, true); resetStringInfo(&sortkeybuf); appendStringInfoString(&sortkeybuf, exprstr); /* Append sort order information, if relevant */ if (sort_ops != NIL) show_sortorder_options(&sortkeybuf, (Node *) target->expr, list_nth_oid(sort_ops, keyno), list_nth_oid(sort_collations, keyno), list_nth_oid(sort_nulls, keyno)); /* Emit one property-list item per sort key */ result = lappend(result, pstrdup(sortkeybuf.data)); } ExplainPropertyList("Order", result, es); } /* copied verbatim from postgresql explain.c */ static void show_sortorder_options(StringInfo buf, Node *sortexpr, Oid sortOperator, Oid collation, bool nullsFirst) { Oid sortcoltype = exprType(sortexpr); bool reverse = false; TypeCacheEntry *typentry; typentry = lookup_type_cache(sortcoltype, TYPECACHE_LT_OPR | TYPECACHE_GT_OPR); /* * Print COLLATE if it's not default. There are some cases where this is * redundant, eg if expression is a column whose declared collation is * that collation, but it's hard to distinguish that here. */ if (OidIsValid(collation) && collation != DEFAULT_COLLATION_OID) { char *collname = get_collation_name(collation); if (collname == NULL) elog(ERROR, "cache lookup failed for collation %u", collation); appendStringInfo(buf, " COLLATE %s", quote_identifier(collname)); } /* Print direction if not ASC, or USING if non-default sort operator */ if (sortOperator == typentry->gt_opr) { appendStringInfoString(buf, " DESC"); reverse = true; } else if (sortOperator != typentry->lt_opr) { char *opname = get_opname(sortOperator); if (opname == NULL) elog(ERROR, "cache lookup failed for operator %u", sortOperator); appendStringInfo(buf, " USING %s", opname); /* Determine whether operator would be considered ASC or DESC */ (void) get_equality_op_for_ordering_op(sortOperator, &reverse); } /* Add NULLS FIRST/LAST only if it wouldn't be default */ if (nullsFirst && !reverse) { appendStringInfoString(buf, " NULLS FIRST"); } else if (!nullsFirst && reverse) { appendStringInfoString(buf, " NULLS LAST"); } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/planner.c�������������������������������������������������0000664�0000000�0000000�00000026113�15100345067�0022217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_namespace.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/appendinfo.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/placeholder.h> #include <optimizer/planmain.h> #include <optimizer/prep.h> #include <optimizer/subselect.h> #include <optimizer/tlist.h> #include <parser/parsetree.h> #include "guc.h" #include "import/planner.h" #include "nodes/chunk_append/chunk_append.h" #include "nodes/chunk_append/transform.h" #include "nodes/modify_hypertable.h" #include "nodes/vector_agg.h" static Sort *make_sort(Plan *lefttree, int numCols, AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst); static Plan *adjust_childscan(PlannerInfo *root, Plan *plan, Path *path, List *pathkeys, List *tlist, AttrNumber *sortColIdx); static CustomScanMethods chunk_append_plan_methods = { .CustomName = "ChunkAppend", .CreateCustomScanState = ts_chunk_append_state_create, }; bool ts_is_chunk_append_plan(Plan *plan) { if (IsA(plan, Result)) { if (castNode(Result, plan)->plan.lefttree && IsA(castNode(Result, plan)->plan.lefttree, CustomScan)) { return castNode(CustomScan, castNode(Result, plan)->plan.lefttree)->methods == &chunk_append_plan_methods; } return false; } return IsA(plan, CustomScan) && castNode(CustomScan, plan)->methods == &chunk_append_plan_methods; } void _chunk_append_init(void) { TryRegisterCustomScanMethods(&chunk_append_plan_methods); } static Plan * adjust_childscan(PlannerInfo *root, Plan *plan, Path *path, List *pathkeys, List *tlist, AttrNumber *sortColIdx) { int childSortCols; Oid *sortOperators; Oid *collations; bool *nullsFirst; AttrNumber *childColIdx; /* Compute sort column info, and adjust subplan's tlist as needed */ plan = ts_prepare_sort_from_pathkeys(plan, pathkeys, path->parent->relids, sortColIdx, true, &childSortCols, &childColIdx, &sortOperators, &collations, &nullsFirst); /* inject sort node if child sort order does not match desired order */ if (!pathkeys_contained_in(pathkeys, path->pathkeys)) { Assert(!IsA(plan, Sort)); plan = (Plan *) make_sort(plan, childSortCols, childColIdx, sortOperators, collations, nullsFirst); } return plan; } Plan * ts_chunk_append_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path, List *tlist, List *clauses, List *custom_plans) { ListCell *lc_child; List *parent_clauses = NIL; List *chunk_ri_clauses = NIL; List *chunk_rt_indexes = NIL; List *sort_options = NIL; List *custom_private = NIL; uint32 limit = 0; List *orig_tlist = NIL; ChunkAppendPath *capath = (ChunkAppendPath *) path; CustomScan *cscan = makeNode(CustomScan); cscan->flags = path->flags; cscan->methods = &chunk_append_plan_methods; cscan->scan.scanrelid = rel->relid; orig_tlist = ts_build_path_tlist(root, (Path *) path); tlist = orig_tlist; /* * If this is a child of ModifyHypertable we need to adjust * targetlists to not have any ROWID_VAR references as postgres * asserts that scan targetlists do not have them in setrefs.c * * We keep orig_tlist unaltered to let adjust_appendrel_attrs() * replace ROWID_VARs for chunks' targetlists (it would assert * trying to modify a "wholerow" target entry that has already * been adjusted by ts_replace_rowid_vars(); we see these in * foreign tables). */ if (root->parse->commandType != CMD_SELECT) tlist = ts_replace_rowid_vars(root, tlist, rel->relid); cscan->scan.plan.targetlist = tlist; ListCell *lc_plan, *lc_path; forboth (lc_path, path->custom_paths, lc_plan, custom_plans) { Plan *child_plan = lfirst(lc_plan); Path *child_path = lfirst(lc_path); /* push down targetlist to children */ if (child_path->parent->reloptkind == RELOPT_OTHER_MEMBER_REL) { /* if this is an append child we need to adjust targetlist references */ AppendRelInfo *appinfo = ts_get_appendrelinfo(root, child_path->parent->relid, false); child_plan->targetlist = castNode(List, adjust_appendrel_attrs(root, (Node *) orig_tlist, 1, &appinfo)); } else { /* * This can also be a MergeAppend path building the entire * hypertable, in case we have a single partial chunk. */ child_plan->targetlist = tlist; } } if (path->path.pathkeys != NIL) { /* * If this is an ordered append node we need to ensure the columns * required for sorting are present in the targetlist and all children * return sorted output. Children not returning sorted output will be * wrapped in a sort node. */ int numCols; AttrNumber *sortColIdx; Oid *sortOperators; Oid *collations; bool *nullsFirst; List *pathkeys = path->path.pathkeys; List *sort_indexes = NIL; List *sort_ops = NIL; List *sort_collations = NIL; List *sort_nulls = NIL; int i; /* Compute sort column info, and adjust MergeAppend's tlist as needed */ ts_prepare_sort_from_pathkeys(&cscan->scan.plan, pathkeys, path->path.parent->relids, NULL, true, &numCols, &sortColIdx, &sortOperators, &collations, &nullsFirst); /* * collect sort information to make available to explain */ for (i = 0; i < numCols; i++) { sort_indexes = lappend_oid(sort_indexes, sortColIdx[i]); sort_ops = lappend_oid(sort_ops, sortOperators[i]); sort_collations = lappend_oid(sort_collations, collations[i]); sort_nulls = lappend_oid(sort_nulls, nullsFirst[i]); } sort_options = list_make4(sort_indexes, sort_ops, sort_collations, sort_nulls); forboth (lc_path, path->custom_paths, lc_plan, custom_plans) { /* * If the planner injected a Result node to do projection * we can safely remove the Result node if it does not have * a one-time filter because ChunkAppend can do projection. */ if (IsA(lfirst(lc_plan), Result) && castNode(Result, lfirst(lc_plan))->resconstantqual == NULL) lfirst(lc_plan) = ((Plan *) lfirst(lc_plan))->lefttree; /* * This could be a MergeAppend due to space partitioning, or * due to partially compressed chunks. The MergeAppend plan adds * sort to it children, and has the proper sorting itself, so no * need to do anything for it. * We can also have plain chunk scans here which might require a * Sort. */ if (!IsA(lfirst(lc_plan), MergeAppend)) { lfirst(lc_plan) = adjust_childscan(root, lfirst(lc_plan), lfirst(lc_path), path->path.pathkeys, orig_tlist, sortColIdx); } } } /* decouple input tlist from output tlist in case output tlist gets modified later */ cscan->custom_scan_tlist = list_copy(tlist); cscan->custom_plans = custom_plans; /* * If we do either startup or runtime exclusion, we need to pass restrictinfo * clauses into executor. */ if (capath->startup_exclusion || capath->runtime_exclusion_children) { foreach (lc_child, cscan->custom_plans) { Scan *scan = ts_chunk_append_get_scan_plan(lfirst(lc_child)); if (scan == NULL || scan->scanrelid == 0) { chunk_ri_clauses = lappend(chunk_ri_clauses, NIL); chunk_rt_indexes = lappend_oid(chunk_rt_indexes, 0); } else { List *chunk_clauses = NIL; ListCell *lc; AppendRelInfo *appinfo = ts_get_appendrelinfo(root, scan->scanrelid, false); foreach (lc, clauses) { Node *clause = (Node *) ts_transform_cross_datatype_comparison( castNode(RestrictInfo, lfirst(lc))->clause); clause = adjust_appendrel_attrs(root, clause, 1, &appinfo); chunk_clauses = lappend(chunk_clauses, clause); } chunk_ri_clauses = lappend(chunk_ri_clauses, chunk_clauses); chunk_rt_indexes = lappend_oid(chunk_rt_indexes, scan->scanrelid); } } Assert(list_length(cscan->custom_plans) == list_length(chunk_ri_clauses)); Assert(list_length(chunk_ri_clauses) == list_length(chunk_rt_indexes)); } /* pass down the parent clauses if doing parent exclusion */ if (capath->runtime_exclusion_parent) { ListCell *lc; foreach (lc, clauses) { parent_clauses = lappend(parent_clauses, castNode(RestrictInfo, lfirst(lc))->clause); } } if (capath->pushdown_limit && capath->limit_tuples > 0) limit = capath->limit_tuples; custom_private = list_make1(list_make5_int(capath->startup_exclusion, capath->runtime_exclusion_parent, capath->runtime_exclusion_children, limit, capath->first_partial_path)); custom_private = lappend(custom_private, chunk_ri_clauses); custom_private = lappend(custom_private, chunk_rt_indexes); custom_private = lappend(custom_private, sort_options); custom_private = lappend(custom_private, parent_clauses); cscan->custom_private = custom_private; return &cscan->scan.plan; } /* * make_sort --- basic routine to build a Sort plan node * * Caller must have built the sortColIdx, sortOperators, collations, and * nullsFirst arrays already. */ static Sort * make_sort(Plan *lefttree, int numCols, AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst) { Sort *node = makeNode(Sort); Plan *plan = &node->plan; plan->targetlist = lefttree->targetlist; plan->qual = NIL; plan->lefttree = lefttree; plan->righttree = NULL; node->numCols = numCols; node->sortColIdx = sortColIdx; node->sortOperators = sortOperators; node->collations = collations; node->nullsFirst = nullsFirst; return node; } Scan * ts_chunk_append_get_scan_plan(Plan *plan) { if (plan == NULL) return NULL; switch (nodeTag(plan)) { case T_BitmapHeapScan: case T_BitmapIndexScan: case T_CteScan: case T_ForeignScan: case T_FunctionScan: case T_IndexOnlyScan: case T_IndexScan: case T_SampleScan: case T_SeqScan: case T_SubqueryScan: case T_TidScan: case T_ValuesScan: case T_WorkTableScan: case T_TidRangeScan: return (Scan *) plan; case T_CustomScan: { CustomScan *custom = castNode(CustomScan, plan); if (custom->scan.scanrelid > 0) { /* * The custom plan node is a scan itself. This handles the * ColumnarScan node. */ return (Scan *) plan; } if (strcmp(custom->methods->CustomName, VECTOR_AGG_NODE_NAME) == 0) { /* * This is a vectorized aggregation node, we have to recurse * into its child, similar to the normal aggregation node. * * Unfortunately we have to hardcode the node name here, because * we can't depend on the TSL library. */ return ts_chunk_append_get_scan_plan(linitial(custom->custom_plans)); } break; } case T_Sort: case T_Result: case T_Agg: if (plan->lefttree != NULL) { Assert(plan->righttree == NULL); /* Let ts_chunk_append_get_scan_plan handle the subplan */ return ts_chunk_append_get_scan_plan(plan->lefttree); } break; default: break; } return NULL; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/transform.c�����������������������������������������������0000664�0000000�0000000�00000006400�15100345067�0022570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_namespace.h> #include <catalog/pg_type.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/optimizer.h> #include <utils/lsyscache.h> #include "nodes/chunk_append/transform.h" #include "utils.h" #define DATATYPE_PAIR(left, right, type1, type2) \ (((left) == (type1) && (right) == (type2)) || ((left) == (type2) && (right) == (type1))) /* * Cross datatype comparisons between DATE/TIMESTAMP/TIMESTAMPTZ * are not immutable which prevents their usage for chunk exclusion. * Unfortunately estimate_expression_value will not estimate those * expressions which makes them unusable for execution time chunk * exclusion with constraint aware append. * To circumvent this we inject casts and use an operator * with the same datatype on both sides when constifying * restrictinfo. This allows estimate_expression_value * to evaluate those expressions and makes them accessible for * execution time chunk exclusion. * * The following transformations are done: * TIMESTAMP OP TIMESTAMPTZ => TIMESTAMP OP (TIMESTAMPTZ::TIMESTAMP) * TIMESTAMPTZ OP DATE => TIMESTAMPTZ OP (DATE::TIMESTAMPTZ) * * No transformation is required for TIMESTAMP OP DATE because * those operators are marked immutable. */ Expr * ts_transform_cross_datatype_comparison(Expr *clause) { if (!IsA(clause, OpExpr) || list_length(castNode(OpExpr, clause)->args) != 2) { return clause; } OpExpr *op = castNode(OpExpr, clause); Oid left_type = exprType(linitial(op->args)); Oid right_type = exprType(lsecond(op->args)); /* * Postgres doesn't allow non-bool or set returning functions in the WHERE * clause. */ Assert(op->opresulttype == BOOLOID && !op->opretset); if (!IsA(linitial(op->args), Var) && !IsA(lsecond(op->args), Var)) return clause; if (DATATYPE_PAIR(left_type, right_type, TIMESTAMPOID, TIMESTAMPTZOID) || DATATYPE_PAIR(left_type, right_type, TIMESTAMPTZOID, DATEOID)) { char *opname = get_opname(op->opno); Oid source_type, target_type, opno, cast_oid; /* * if Var is on left side we put cast on right side otherwise * it will be left */ if (IsA(linitial(op->args), Var)) { source_type = right_type; target_type = left_type; } else { source_type = left_type; target_type = right_type; } opno = ts_get_operator(opname, PG_CATALOG_NAMESPACE, target_type, target_type); cast_oid = ts_get_cast_func(source_type, target_type); if (OidIsValid(opno) && OidIsValid(cast_oid)) { Expr *left = copyObject(linitial(op->args)); Expr *right = copyObject(lsecond(op->args)); if (source_type == left_type) left = (Expr *) makeFuncExpr(cast_oid, target_type, list_make1(left), InvalidOid, InvalidOid, 0); else right = (Expr *) makeFuncExpr(cast_oid, target_type, list_make1(right), InvalidOid, InvalidOid, 0); return make_opclause(opno, BOOLOID, false, left, right, InvalidOid, InvalidOid); } } return clause; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/chunk_append/transform.h�����������������������������������������������0000664�0000000�0000000�00000000544�15100345067�0022600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/extensible.h> #include "export.h" extern TSDLLEXPORT Expr *ts_transform_cross_datatype_comparison(Expr *clause); ������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/constraint_aware_append/�����������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0022644�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/constraint_aware_append/CMakeLists.txt���������������������������������0000664�0000000�0000000�00000000166�15100345067�0025407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/constraint_aware_append.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/constraint_aware_append/constraint_aware_append.c����������������������0000664�0000000�0000000�00000042251�15100345067�0027706�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_cast.h> #include <catalog/pg_class.h> #include <catalog/pg_namespace.h> #include <catalog/pg_operator.h> #include <commands/explain.h> #include <executor/executor.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/nodes.h> #include <nodes/parsenodes.h> #include <nodes/plannodes.h> #include <optimizer/appendinfo.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/plancat.h> #include <parser/parsetree.h> #include <rewrite/rewriteManip.h> #include <storage/lockdefs.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/syscache.h> #include "compat/compat.h" #include "constraint_aware_append.h" #include "debug_assert.h" #include "guc.h" #include "nodes/chunk_append/transform.h" #include "utils.h" #if PG18_GE #include <commands/explain_format.h> #endif /* * Exclude child relations (chunks) at execution time based on constraints. * * This functions tries to reuse as much functionality as possible from standard * constraint exclusion in PostgreSQL that normally happens at planning * time. Therefore, we need to fake a number of planning-related data * structures. */ static bool excluded_by_constraint(PlannerInfo *root, RangeTblEntry *rte, Index rt_index, List *restrictinfos) { RelOptInfo rel = { .type = T_RelOptInfo, .relid = rt_index, .reloptkind = RELOPT_OTHER_MEMBER_REL, .baserestrictinfo = restrictinfos, }; return relation_excluded_by_constraints(root, &rel, rte); } static Plan * get_plans_for_exclusion(Plan *plan) { /* Optimization: If we want to be able to prune */ /* when the node is a T_Result or T_Sort, then we need to peek */ /* into the subplans of this Result node. */ switch (nodeTag(plan)) { case T_Result: case T_Sort: Ensure(plan->lefttree != NULL, "subplan is null"); return get_plans_for_exclusion(plan->lefttree); default: return plan; } } static bool can_exclude_chunk(PlannerInfo *root, RangeTblEntry *rte, Index rt_index, List *restrictinfos) { return rte->rtekind == RTE_RELATION && rte->relkind == RELKIND_RELATION && !rte->inh && excluded_by_constraint(root, rte, rt_index, restrictinfos); } /* * Convert restriction clauses to constants expressions (i.e., if there are * mutable functions, they need to be evaluated to constants). For instance, * something like: * * ...WHERE time > now - interval '1 hour' * * becomes * * ...WHERE time > '2017-06-02 11:26:43.935712+02' */ static List * constify_restrictinfos(PlannerInfo *root, List *restrictinfos) { ListCell *lc; foreach (lc, restrictinfos) { RestrictInfo *rinfo = lfirst(lc); rinfo->clause = (Expr *) estimate_expression_value(root, (Node *) rinfo->clause); } return restrictinfos; } /* * Initialize the scan state and prune any subplans from the Append node below * us in the plan tree. Pruning happens by evaluating the subplan's table * constraints against a folded version of the restriction clauses in the query. */ static void ca_append_begin(CustomScanState *node, EState *estate, int eflags) { ConstraintAwareAppendState *state = (ConstraintAwareAppendState *) node; CustomScan *cscan = (CustomScan *) node->ss.ps.plan; Plan *subplan = copyObject(state->subplan); List *chunk_ri_clauses = lsecond(cscan->custom_private); List *chunk_relids = lthird(cscan->custom_private); List **appendplans, *old_appendplans; ListCell *lc_plan; ListCell *lc_clauses; ListCell *lc_relid; /* * create skeleton plannerinfo to reuse some PostgreSQL planner functions */ Query parse = { .resultRelation = InvalidOid, }; PlannerGlobal glob = { .boundParams = NULL, }; PlannerInfo root = { .glob = &glob, .parse = &parse, }; /* CustomScan hard-codes the scan and result tuple slot to a fixed * TTSOpsVirtual ops (meaning it expects the slot ops of the child tuple to * also have this type). Oddly, when reading slots from subscan nodes * (children), there is no knowing what tuple slot ops the child slot will * have (e.g., for ChunkAppend it is common that the child is a * seqscan/indexscan that produces a TTSOpsBufferHeapTuple * slot). Unfortunately, any mismatch between slot types when projecting is * asserted by PostgreSQL. To avoid this issue, we mark the scanops as * non-fixed and reinitialize the projection state with this new setting. * * Alternatively, we could copy the child tuple into the scan slot to get * the expected ops before projection, but this would require materializing * and copying the tuple unnecessarily. */ node->ss.ps.scanopsfixed = false; /* Since we sometimes return the scan slot directly from the subnode, the * result slot is not fixed either. */ node->ss.ps.resultopsfixed = false; ExecAssignScanProjectionInfoWithVarno(&node->ss, INDEX_VAR); switch (nodeTag(subplan)) { case T_Append: { Append *append = (Append *) subplan; old_appendplans = append->appendplans; append->appendplans = NIL; appendplans = &append->appendplans; break; } case T_MergeAppend: { MergeAppend *append = (MergeAppend *) subplan; old_appendplans = append->mergeplans; append->mergeplans = NIL; appendplans = &append->mergeplans; break; } case T_Result: /* * Append plans are turned into a Result node if empty. This can * happen if children are pruned first by constraint exclusion * while we also remove the main table from the appendplans list, * leaving an empty list. In that case, there is nothing to do. */ return; default: elog(ERROR, "invalid child of constraint-aware append: %s", ts_get_node_name((Node *) subplan)); } /* * clauses should always have the same length as appendplans because * that's the base for building the lists */ Assert(list_length(old_appendplans) == list_length(chunk_ri_clauses)); Assert(list_length(chunk_relids) == list_length(chunk_ri_clauses)); forthree (lc_plan, old_appendplans, lc_clauses, chunk_ri_clauses, lc_relid, chunk_relids) { Plan *plan = get_plans_for_exclusion(lfirst(lc_plan)); switch (nodeTag(plan)) { case T_SeqScan: case T_SampleScan: case T_IndexScan: case T_IndexOnlyScan: case T_BitmapIndexScan: case T_BitmapHeapScan: case T_TidScan: case T_SubqueryScan: case T_FunctionScan: case T_ValuesScan: case T_CteScan: case T_WorkTableScan: case T_ForeignScan: case T_CustomScan: case T_TidRangeScan: { /* * If this is a base rel (chunk), check if it can be * excluded from the scan. Otherwise, fall through. */ Index scanrelid = ((Scan *) plan)->scanrelid; List *restrictinfos = NIL; List *ri_clauses = lfirst(lc_clauses); ListCell *lc; RangeTblEntry *rte; Assert(scanrelid); foreach (lc, ri_clauses) { RestrictInfo *ri = makeNode(RestrictInfo); ri->clause = lfirst(lc); /* * The index of the RangeTblEntry might have changed between planning * because of flattening, so we need to adjust the expressions * for the RestrictInfos if they are not equal. */ if (lfirst_oid(lc_relid) != scanrelid) ChangeVarNodes((Node *) ri->clause, lfirst_oid(lc_relid), scanrelid, 0); restrictinfos = lappend(restrictinfos, ri); } /* * The function excluded_by_constraint(), which is called when * excluding chunks, assumes that a relation is already locked * when called. In most cases the relation is already locked * when getting here, but not in case of some parallel scans * where the parallel worker hasn't locked it yet. */ rte = rt_fetch(scanrelid, estate->es_range_table); LockRelationOid(rte->relid, AccessShareLock); restrictinfos = constify_restrictinfos(&root, restrictinfos); if (can_exclude_chunk(&root, rte, scanrelid, restrictinfos)) continue; *appendplans = lappend(*appendplans, lfirst(lc_plan)); break; } default: elog(ERROR, "invalid child of constraint-aware append: %s", ts_get_node_name((Node *) plan)); break; } } state->num_append_subplans = list_length(*appendplans); state->num_chunks_excluded = list_length(old_appendplans) - state->num_append_subplans; if (state->num_append_subplans > 0) node->custom_ps = list_make1(ExecInitNode(subplan, estate, eflags)); } static TupleTableSlot * ca_append_exec(CustomScanState *node) { ConstraintAwareAppendState *state = (ConstraintAwareAppendState *) node; TupleTableSlot *subslot; ExprContext *econtext = node->ss.ps.ps_ExprContext; /* * Check if all append subplans were pruned. In that case there is nothing * to do. */ if (state->num_append_subplans == 0) return NULL; ResetExprContext(econtext); while (true) { subslot = ExecProcNode(linitial(node->custom_ps)); if (TupIsNull(subslot)) return NULL; if (!node->ss.ps.ps_ProjInfo) return subslot; econtext->ecxt_scantuple = subslot; return ExecProject(node->ss.ps.ps_ProjInfo); } } static void ca_append_end(CustomScanState *node) { if (node->custom_ps != NIL) { ExecEndNode(linitial(node->custom_ps)); } } static void ca_append_rescan(CustomScanState *node) { if (node->custom_ps != NIL) { ExecReScan(linitial(node->custom_ps)); } } static void ca_append_explain(CustomScanState *node, List *ancestors, ExplainState *es) { CustomScan *cscan = (CustomScan *) node->ss.ps.plan; ConstraintAwareAppendState *state = (ConstraintAwareAppendState *) node; Oid relid = linitial_oid(linitial(cscan->custom_private)); ExplainPropertyText("Hypertable", get_rel_name(relid), es); ExplainPropertyInteger("Chunks excluded during startup", NULL, state->num_chunks_excluded, es); } static CustomExecMethods constraint_aware_append_state_methods = { .BeginCustomScan = ca_append_begin, .ExecCustomScan = ca_append_exec, .EndCustomScan = ca_append_end, .ReScanCustomScan = ca_append_rescan, .ExplainCustomScan = ca_append_explain, }; static Node * constraint_aware_append_state_create(CustomScan *cscan) { ConstraintAwareAppendState *state; Append *append = linitial(cscan->custom_plans); state = (ConstraintAwareAppendState *) newNode(sizeof(ConstraintAwareAppendState), T_CustomScanState); state->csstate.methods = &constraint_aware_append_state_methods; state->subplan = &append->plan; return (Node *) state; } static CustomScanMethods constraint_aware_append_plan_methods = { .CustomName = "ConstraintAwareAppend", .CreateCustomScanState = constraint_aware_append_state_create, }; static Plan * constraint_aware_append_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path, List *tlist, List *clauses, List *custom_plans) { CustomScan *cscan = makeNode(CustomScan); Plan *subplan; RangeTblEntry *rte = planner_rt_fetch(rel->relid, root); List *chunk_ri_clauses = NIL; List *chunk_relids = NIL; List *children = NIL; ListCell *lc_child; /* * Postgres will inject Result nodes above mergeappend when target lists don't match * because the nodes themselves do not perform projection. The ConstraintAwareAppend * node can do this projection itself, however, so just throw away the result node * Removing the Result node is only safe if there is no one-time filter */ if (IsA(linitial(custom_plans), Result) && castNode(Result, linitial(custom_plans))->resconstantqual == NULL) { Result *result = castNode(Result, linitial(custom_plans)); if (result->plan.righttree != NULL) elog(ERROR, "unexpected right tree below result node in constraint aware append"); custom_plans = list_make1(result->plan.lefttree); } subplan = linitial(custom_plans); cscan->scan.scanrelid = 0; /* Not a real relation we are scanning */ cscan->scan.plan.targetlist = tlist; /* Target list we expect as output */ cscan->custom_plans = custom_plans; /* * create per chunk RestrictInfo * * We also need to walk the expression trees of the restriction clauses and * update any Vars that reference the main table to instead reference the child * table (chunk) we want to exclude. */ switch (nodeTag(linitial(custom_plans))) { case T_MergeAppend: children = castNode(MergeAppend, linitial(custom_plans))->mergeplans; break; case T_Append: children = castNode(Append, linitial(custom_plans))->appendplans; break; default: elog(ERROR, "invalid child of constraint-aware append: %s", ts_get_node_name((Node *) linitial(custom_plans))); break; } /* * we only iterate over the child chunks of this node * so the list of metadata exactly matches the list of * child nodes in the executor */ foreach (lc_child, children) { Plan *plan = get_plans_for_exclusion(lfirst(lc_child)); switch (nodeTag(plan)) { case T_SeqScan: case T_SampleScan: case T_IndexScan: case T_IndexOnlyScan: case T_BitmapIndexScan: case T_BitmapHeapScan: case T_TidScan: case T_SubqueryScan: case T_FunctionScan: case T_ValuesScan: case T_CteScan: case T_WorkTableScan: case T_ForeignScan: case T_CustomScan: case T_TidRangeScan: { List *chunk_clauses = NIL; ListCell *lc; Index scanrelid = ((Scan *) plan)->scanrelid; AppendRelInfo *appinfo = ts_get_appendrelinfo(root, scanrelid, false); foreach (lc, clauses) { Node *clause = (Node *) ts_transform_cross_datatype_comparison( castNode(RestrictInfo, lfirst(lc))->clause); clause = adjust_appendrel_attrs(root, clause, 1, &appinfo); chunk_clauses = lappend(chunk_clauses, clause); } chunk_ri_clauses = lappend(chunk_ri_clauses, chunk_clauses); chunk_relids = lappend_oid(chunk_relids, scanrelid); break; } default: elog(ERROR, "invalid child of constraint-aware append: %s", ts_get_node_name((Node *) plan)); break; } } cscan->custom_private = list_make3(list_make1_oid(rte->relid), chunk_ri_clauses, chunk_relids); cscan->custom_scan_tlist = subplan->targetlist; /* Target list of tuples * we expect as input */ cscan->flags = path->flags; cscan->methods = &constraint_aware_append_plan_methods; return &cscan->scan.plan; } static CustomPathMethods constraint_aware_append_path_methods = { .CustomName = "ConstraintAwareAppend", .PlanCustomPath = constraint_aware_append_plan_create, }; Path * ts_constraint_aware_append_path_create(PlannerInfo *root, Path *subpath) { ConstraintAwareAppendPath *path; path = (ConstraintAwareAppendPath *) newNode(sizeof(ConstraintAwareAppendPath), T_CustomPath); path->cpath.path.pathtype = T_CustomScan; path->cpath.path.rows = subpath->rows; path->cpath.path.startup_cost = subpath->startup_cost; path->cpath.path.total_cost = subpath->total_cost; path->cpath.path.parent = subpath->parent; path->cpath.path.pathkeys = subpath->pathkeys; path->cpath.path.param_info = subpath->param_info; path->cpath.path.pathtarget = subpath->pathtarget; path->cpath.path.parallel_aware = false; path->cpath.path.parallel_safe = subpath->parallel_safe; path->cpath.path.parallel_workers = subpath->parallel_workers; /* * Set flags. We can set CUSTOMPATH_SUPPORT_BACKWARD_SCAN and * CUSTOMPATH_SUPPORT_MARK_RESTORE. The only interesting flag is the first * one (backward scan), but since we are not scanning a real relation we * need not indicate that we support backward scans. Lower-level index * scanning nodes will scan backward if necessary, so once tuples get to * this node they will be in a given order already. */ path->cpath.flags = 0; path->cpath.custom_paths = list_make1(subpath); path->cpath.methods = &constraint_aware_append_path_methods; /* * Make sure our subpath is either an Append or MergeAppend node */ switch (nodeTag(subpath)) { case T_AppendPath: case T_MergeAppendPath: break; default: elog(ERROR, "invalid child of constraint-aware append: %s", ts_get_node_name((Node *) subpath)); break; } return &path->cpath.path; } bool ts_constraint_aware_append_possible(Path *path) { RelOptInfo *rel = path->parent; ListCell *lc; int num_children; if (!ts_guc_enable_optimizations || !ts_guc_enable_constraint_aware_append || constraint_exclusion == CONSTRAINT_EXCLUSION_OFF) return false; switch (nodeTag(path)) { case T_AppendPath: num_children = list_length(castNode(AppendPath, path)->subpaths); break; case T_MergeAppendPath: num_children = list_length(castNode(MergeAppendPath, path)->subpaths); break; default: return false; } /* Never use constraint-aware append with only one child, since PostgreSQL * will later prune the (Merge)Append node from such plans, leaving us with * an unexpected child node. */ if (num_children <= 1) return false; /* * If there are clauses that have mutable functions, this path is ripe for * execution-time optimization. */ foreach (lc, rel->baserestrictinfo) { RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc); if (contain_mutable_functions((Node *) rinfo->clause)) return true; } return false; } bool ts_is_constraint_aware_append_path(Path *path) { return IsA(path, CustomPath) && castNode(CustomPath, path)->methods == &constraint_aware_append_path_methods; } void _constraint_aware_append_init(void) { TryRegisterCustomScanMethods(&constraint_aware_append_plan_methods); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/constraint_aware_append/constraint_aware_append.h����������������������0000664�0000000�0000000�00000001507�15100345067�0027712�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/extensible.h> typedef struct ConstraintAwareAppendPath { CustomPath cpath; } ConstraintAwareAppendPath; typedef struct ConstraintAwareAppendState { CustomScanState csstate; Plan *subplan; Size num_append_subplans; Size num_chunks_excluded; } ConstraintAwareAppendState; typedef struct Hypertable Hypertable; extern bool ts_constraint_aware_append_possible(Path *path); extern TSDLLEXPORT Path *ts_constraint_aware_append_path_create(PlannerInfo *root, Path *subpath); extern TSDLLEXPORT bool ts_is_constraint_aware_append_path(Path *path); extern void _constraint_aware_append_init(void); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/modify_hypertable.c����������������������������������������������������0000664�0000000�0000000�00000040707�15100345067�0021634�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <nodes/execnodes.h> #include <nodes/makefuncs.h> #include <utils/syscache.h> #include "compat/compat.h" #include "chunk_tuple_routing.h" #include "cross_module_fn.h" #include "guc.h" #include "indexing.h" #include "nodes/chunk_append/chunk_append.h" #include "nodes/modify_hypertable.h" #if PG18_GE #include <commands/explain_format.h> #endif static AttrNumber rel_get_natts(Oid relid) { HeapTuple tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tp)) elog(ERROR, "cache lookup failed for relation %u", relid); AttrNumber natts = ((Form_pg_class) GETSTRUCT(tp))->relnatts; ReleaseSysCache(tp); return natts; } static bool rel_has_dropped_attrs(Oid relid) { AttrNumber natts = rel_get_natts(relid); for (AttrNumber attno = 1; attno <= natts; attno++) { HeapTuple tp = SearchSysCache2(ATTNUM, ObjectIdGetDatum(relid), Int16GetDatum(attno)); if (!HeapTupleIsValid(tp)) continue; Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); bool result = att_tup->attisdropped || att_tup->atthasmissing; ReleaseSysCache(tp); if (result) return true; } return false; } static bool should_use_direct_compress(ModifyHypertableState *state) { if (!ts_guc_enable_direct_compress_insert) return false; ModifyTableState *mtstate = linitial_node(ModifyTableState, state->cscan_state.custom_ps); ResultRelInfo *resultRelInfo = mtstate->resultRelInfo; Hypertable *ht = state->ctr->hypertable; if (!TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) return false; if (ts_hypertable_has_continuous_aggregates(ht->fd.id)) { ereport(WARNING, (errmsg("disabling direct compress because the destination table has continuous " "aggregates"))); return false; } if (resultRelInfo->ri_TrigDesc) { ereport(WARNING, (errmsg("disabling direct compress because the destination table has triggers"))); return false; } if (ts_indexing_relation_has_primary_or_unique_index(state->ctr->root_rel)) { ereport(WARNING, (errmsg("disabling direct compress because the destination table has unique " "constraints"))); return false; } Plan *subplan = mtstate->ps.plan->lefttree; if (subplan->plan_rows < 10) { ereport(WARNING, (errmsg("disabling direct compress because of too small batch size"))); return false; } return true; } /* * ModifyHypertable is a plan node that implements DML for hypertables. * It is a wrapper around the ModifyTable plan node that calls the wrapped ModifyTable * plan. */ static void modify_hypertable_begin(CustomScanState *node, EState *estate, int eflags) { ModifyHypertableState *state = (ModifyHypertableState *) node; ModifyTableState *mtstate; PlanState *ps; ModifyTable *mt = castNode(ModifyTable, &state->mt->plan); /* * To make statement trigger defined on the hypertable work * we need to set the hypertable as the rootRelation otherwise * statement trigger defined only on the hypertable will not fire. */ if (mt->operation == CMD_DELETE || mt->operation == CMD_UPDATE || mt->operation == CMD_MERGE) mt->rootRelation = mt->nominalRelation; ps = ExecInitNode(&mt->plan, estate, eflags); node->custom_ps = list_make1(ps); mtstate = castNode(ModifyTableState, ps); /* * If this is not the primary ModifyTable node, postgres added it to the * beginning of es_auxmodifytables, to be executed by ExecPostprocessPlan. * Unfortunately that strips off the HypertableInsert node leading to * tuple routing not working in INSERTs inside CTEs. To make INSERTs * inside CTEs work we have to fix es_auxmodifytables and add back the * ModifyHypertableState. */ if (estate->es_auxmodifytables && linitial(estate->es_auxmodifytables) == mtstate) linitial(estate->es_auxmodifytables) = node; state->ht = ts_hypertable_cache_get_cache_and_entry(RelationGetRelid( mtstate->resultRelInfo->ri_RelationDesc), CACHE_FLAG_MISSING_OK, &state->ht_cache); /* * If we are inserting into a chunk directly, rri will point to the chunk * itself, so we need to get the hypertable from the chunk. */ if (!state->ht) { Chunk *chunk = ts_chunk_get_by_relid(RelationGetRelid(mtstate->resultRelInfo->ri_RelationDesc), true); state->ht = ts_hypertable_cache_get_entry(state->ht_cache, chunk->hypertable_relid, CACHE_FLAG_NONE); } state->has_continuous_aggregate = ts_hypertable_has_continuous_aggregates(state->ht->fd.id); if (mtstate->operation == CMD_INSERT || mtstate->operation == CMD_MERGE) { /* setup chunk tuple routing state for INSERT/MERGE */ state->ctr = ts_chunk_tuple_routing_create(estate, state->ht, mtstate->resultRelInfo); state->ctr->mht_state = state; if (mtstate->operation == CMD_INSERT && should_use_direct_compress(state)) { state->columnstore_insert = true; state->ctr->create_compressed_chunk = true; } if (mtstate->operation == CMD_MERGE) state->ctr->has_dropped_attrs = rel_has_dropped_attrs(state->ctr->hypertable->main_table_relid); /* setup per tuple exprcontext for tuple routing */ if (!estate->es_per_tuple_exprcontext) estate->es_per_tuple_exprcontext = CreateExprContext(estate); } } static TupleTableSlot * modify_hypertable_exec(CustomScanState *node) { ModifyTableState *mtstate = linitial_node(ModifyTableState, node->custom_ps); return ExecModifyTable(node, &mtstate->ps); } static void modify_hypertable_end(CustomScanState *node) { ModifyHypertableState *state = (ModifyHypertableState *) node; if (state->compressor) { ts_cm_functions->compressor_flush(state->compressor, state->bulk_writer); ts_cm_functions->compressor_free(state->compressor, state->bulk_writer); state->compressor = NULL; state->bulk_writer = NULL; } ExecEndNode(linitial(node->custom_ps)); if (state->ctr) ts_chunk_tuple_routing_destroy(state->ctr); ts_cache_release(&state->ht_cache); } static void modify_hypertable_rescan(CustomScanState *node) { ExecReScan(linitial(node->custom_ps)); } static void modify_hypertable_explain(CustomScanState *node, List *ancestors, ExplainState *es) { ModifyHypertableState *state = (ModifyHypertableState *) node; ModifyTableState *mtstate = linitial_node(ModifyTableState, node->custom_ps); /* * The targetlist for this node will have references that cannot be resolved by * EXPLAIN. So for EXPLAIN VERBOSE we clear the targetlist so that EXPLAIN does not * complain. PostgreSQL does something equivalent and does not print the targetlist * for ModifyTable for EXPLAIN VERBOSE. */ if (((ModifyTable *) mtstate->ps.plan)->operation == CMD_DELETE && es->verbose && ts_is_chunk_append_plan(mtstate->ps.plan->lefttree)) { mtstate->ps.plan->lefttree->targetlist = NULL; ((CustomScan *) mtstate->ps.plan->lefttree)->custom_scan_tlist = NULL; } if (((ModifyTable *) mtstate->ps.plan)->operation == CMD_MERGE && es->verbose) { mtstate->ps.plan->lefttree->targetlist = NULL; ((CustomScan *) mtstate->ps.plan->lefttree)->custom_scan_tlist = NULL; } /* * Since we hijack the ModifyTable node, instrumentation on ModifyTable will * be missing so we set it to instrumentation of ModifyHypertable node. */ if (mtstate->ps.instrument) { /* * INSERT .. ON CONFLICT statements record few metrics in the ModifyTable node. * So, copy them into ModifyHypertable node before replacing them. */ node->ss.ps.instrument->ntuples2 = mtstate->ps.instrument->ntuples2; node->ss.ps.instrument->nfiltered1 = mtstate->ps.instrument->nfiltered1; } mtstate->ps.instrument = node->ss.ps.instrument; /* * For INSERT we have to read the number of decompressed batches and * tuples from the ChunkTupleRouting state below the ModifyTable. */ if ((mtstate->operation == CMD_INSERT || mtstate->operation == CMD_MERGE) && outerPlanState(mtstate)) { SharedCounters *counters = state->ctr->counters; state->batches_deleted += counters->batches_deleted; state->batches_filtered += counters->batches_filtered; state->batches_decompressed += counters->batches_decompressed; state->tuples_decompressed += counters->tuples_decompressed; } if (state->batches_filtered > 0) ExplainPropertyInteger("Batches filtered", NULL, state->batches_filtered, es); if (state->batches_decompressed > 0) ExplainPropertyInteger("Batches decompressed", NULL, state->batches_decompressed, es); if (state->tuples_decompressed > 0) ExplainPropertyInteger("Tuples decompressed", NULL, state->tuples_decompressed, es); if (state->batches_deleted > 0) ExplainPropertyInteger("Batches deleted", NULL, state->batches_deleted, es); if (ts_guc_enable_direct_compress_insert && state->mt->operation == CMD_INSERT) ExplainPropertyBool("Direct Compress", state->columnstore_insert, es); } static CustomExecMethods modify_hypertable_state_methods = { .CustomName = "ModifyHypertableState", .BeginCustomScan = modify_hypertable_begin, .EndCustomScan = modify_hypertable_end, .ExecCustomScan = modify_hypertable_exec, .ReScanCustomScan = modify_hypertable_rescan, .ExplainCustomScan = modify_hypertable_explain, }; static Node * modify_hypertable_state_create(CustomScan *cscan) { ModifyHypertableState *state; ModifyTable *mt = castNode(ModifyTable, linitial(cscan->custom_plans)); state = (ModifyHypertableState *) newNode(sizeof(ModifyHypertableState), T_CustomScanState); state->cscan_state.methods = &modify_hypertable_state_methods; state->mt = mt; state->mt->arbiterIndexes = linitial(cscan->custom_private); return (Node *) state; } static CustomScanMethods modify_hypertable_plan_methods = { .CustomName = "ModifyHypertable", .CreateCustomScanState = modify_hypertable_state_create, }; /* * Make a targetlist to meet CustomScan expectations. * * When a CustomScan isn't scanning a real relation (scanrelid=0), it will build * a virtual TupleDesc for the scan "input" based on custom_scan_tlist. The * "output" targetlist is then expected to reference the attributes of the * input's TupleDesc. Without projection, the targetlist will be only Vars with * varno set to INDEX_VAR (to indicate reference to the TupleDesc instead of a * real relation) and matching the order of the attributes in the TupleDesc. * * Any other order, or non-Vars, will lead to the CustomScan performing * projection. * * Since the CustomScan for hypertable insert just wraps ModifyTable, no * projection is needed, so we'll build a targetlist to avoid this. */ static List * make_var_targetlist(const List *tlist) { List *new_tlist = NIL; ListCell *lc; int resno = 1; foreach (lc, tlist) { TargetEntry *tle = lfirst_node(TargetEntry, lc); Var *var = makeVarFromTargetEntry(INDEX_VAR, tle); var->varattno = resno; new_tlist = lappend(new_tlist, makeTargetEntry(&var->xpr, resno, tle->resname, false)); resno++; } return new_tlist; } /* * Construct the HypertableInsert's target list based on the ModifyTable's * target list, which now exists after having been created by * set_plan_references(). */ void ts_modify_hypertable_fixup_tlist(Plan *plan) { if (IsA(plan, CustomScan)) { CustomScan *cscan = (CustomScan *) plan; if (cscan->methods == &modify_hypertable_plan_methods) { ModifyTable *mt = linitial_node(ModifyTable, cscan->custom_plans); if (mt->plan.targetlist == NIL) { cscan->custom_scan_tlist = NIL; cscan->scan.plan.targetlist = NIL; } else { /* The input is the output of the child ModifyTable node */ cscan->custom_scan_tlist = mt->plan.targetlist; /* The output is a direct mapping of the input */ cscan->scan.plan.targetlist = make_var_targetlist(mt->plan.targetlist); } } } } List * ts_replace_rowid_vars(PlannerInfo *root, List *tlist, int varno) { ListCell *lc; tlist = list_copy(tlist); foreach (lc, tlist) { TargetEntry *tle = lfirst_node(TargetEntry, lc); if (IsA(tle->expr, Var) && castNode(Var, tle->expr)->varno == ROWID_VAR) { tle = copyObject(tle); Var *var = castNode(Var, copyObject(tle->expr)); RowIdentityVarInfo *ridinfo = (RowIdentityVarInfo *) list_nth(root->row_identity_vars, var->varattno - 1); var = copyObject(ridinfo->rowidvar); var->varno = varno; var->varnosyn = 0; var->varattnosyn = 0; tle->expr = (Expr *) var; lfirst(lc) = tle; } } return tlist; } static Plan * modify_hypertable_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *best_path, List *tlist, List *clauses, List *custom_plans) { CustomScan *cscan = makeNode(CustomScan); ModifyTable *mt = linitial_node(ModifyTable, custom_plans); cscan->methods = &modify_hypertable_plan_methods; cscan->custom_plans = custom_plans; cscan->scan.scanrelid = 0; /* Copy costs, etc., from the original plan */ cscan->scan.plan.startup_cost = mt->plan.startup_cost; cscan->scan.plan.total_cost = mt->plan.total_cost; cscan->scan.plan.plan_rows = mt->plan.plan_rows; cscan->scan.plan.plan_width = mt->plan.plan_width; /* The tlist is always NIL since the ModifyTable subplan doesn't have its * targetlist set until set_plan_references (setrefs.c) is run */ Assert(tlist == NIL); /* Target list handling here needs special attention. Intuitively, we'd like * to adopt the target list of the ModifyTable subplan we wrap without * further projection. For a CustomScan this means setting the "input" * custom_scan_tlist to the ModifyTable's target list and having an "output" * targetlist that references the TupleDesc that is created from the * custom_scan_tlist at execution time. Now, while this seems * straight-forward, there are several things with how ModifyTable nodes are * handled in the planner that complicates this: * * - First, ModifyTable doesn't have a targetlist set at this point, and * it is only set later in set_plan_references (setrefs.c) if there's a * RETURNING clause. * * - Second, top-level plan nodes, except for ModifyTable nodes, need to * have a targetlist matching root->processed_tlist. This is asserted in * apply_tlist_labeling, which is called in create_plan (createplan.c) * immediately after this function returns. ModifyTable is exempted * because it doesn't always have a targetlist that matches * processed_tlist. So, even if we had access to ModifyTable's * targetlist here we wouldn't be able to use it since we're a * CustomScan and thus not exempted. * * - Third, a CustomScan's targetlist should reference the attributes of the * TupleDesc that gets created from the custom_scan_tlist at the start of * execution. This means we need to make the targetlist into all Vars with * attribute numbers that correspond to the TupleDesc instead of result * relation in the ModifyTable. * * To get around these issues, we set the targetlist here to * root->processed_tlist, and at the end of planning when the ModifyTable's * targetlist is set, we go back and fix up the CustomScan's targetlist. */ cscan->scan.plan.targetlist = copyObject(root->processed_tlist); /* * For UPDATE/DELETE/MERGE processed_tlist will have ROWID_VAR. We * need to remove those because set_customscan_references will bail * if it sees ROWID_VAR entries in the targetlist. */ if (mt->operation == CMD_UPDATE || mt->operation == CMD_DELETE || mt->operation == CMD_MERGE) { cscan->scan.plan.targetlist = ts_replace_rowid_vars(root, cscan->scan.plan.targetlist, mt->nominalRelation); if (mt->operation == CMD_UPDATE && ts_is_chunk_append_plan(mt->plan.lefttree)) { mt->plan.lefttree->targetlist = ts_replace_rowid_vars(root, mt->plan.lefttree->targetlist, mt->nominalRelation); } } cscan->custom_scan_tlist = cscan->scan.plan.targetlist; /* * we save the original list of arbiter indexes here * because we modify that list during execution and * we still need the original list in case that plan * gets reused. */ cscan->custom_private = list_make1(mt->arbiterIndexes); return &cscan->scan.plan; } static CustomPathMethods modify_hypertable_path_methods = { .CustomName = "ModifyHypertablePath", .PlanCustomPath = modify_hypertable_plan_create, }; Path * ts_modify_hypertable_path_create(PlannerInfo *root, ModifyTablePath *mtpath, RelOptInfo *rel) { ModifyHypertablePath *mht_path = palloc0(sizeof(ModifyHypertablePath)); /* Copy costs, etc. */ memcpy(&mht_path->cpath.path, &mtpath->path, sizeof(Path)); mht_path->cpath.path.type = T_CustomPath; mht_path->cpath.path.pathtype = T_CustomScan; mht_path->cpath.custom_paths = list_make1(mtpath); mht_path->cpath.methods = &modify_hypertable_path_methods; return &mht_path->cpath.path; } ���������������������������������������������������������timescaledb-2.23.0/src/nodes/modify_hypertable.h����������������������������������������������������0000664�0000000�0000000�00000003352�15100345067�0021634�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <foreign/fdwapi.h> #include <nodes/execnodes.h> #include "chunk_tuple_routing.h" #include "hypertable.h" /* Forward declarations */ typedef struct ModifyTableContext ModifyTableContext; typedef struct RowCompressor RowCompressor; typedef struct BulkWriter BulkWriter; typedef struct ModifyHypertablePath { CustomPath cpath; } ModifyHypertablePath; /* * State for the hypertable_modify custom scan node. * * This struct definition is also used in ts_stat_statements, so any new fields * should only be added at the end of the struct. */ typedef struct ModifyHypertableState { CustomScanState cscan_state; ModifyTable *mt; ChunkTupleRouting *ctr; Hypertable *ht; Cache *ht_cache; bool has_continuous_aggregate; RowCompressor *compressor; BulkWriter *bulk_writer; Oid compressor_relid; bool columnstore_insert; bool comp_chunks_processed; Snapshot snapshot; int64 tuples_decompressed; int64 batches_decompressed; int64 batches_filtered; int64 batches_deleted; int64 tuples_deleted; } ModifyHypertableState; extern void ts_modify_hypertable_fixup_tlist(Plan *plan); extern Path *ts_modify_hypertable_path_create(PlannerInfo *root, ModifyTablePath *mtpath, RelOptInfo *input_rel); extern List *ts_replace_rowid_vars(PlannerInfo *root, List *tlist, int varno); TupleTableSlot *ExecModifyTable(CustomScanState *cs_node, PlanState *pstate); TupleTableSlot *ExecInsert(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ChunkTupleRouting *ctr, TupleTableSlot *slot, bool canSetTag); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/modify_hypertable_exec.c�����������������������������������������������0000664�0000000�0000000�00000332560�15100345067�0022641�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file is based on postgresql backend/executor/nodeModifyTable.c * Ordering of functions in this file is based on the order of functions in * nodeModifyTable.c */ /* clang-format off */ /* INTERFACE ROUTINES * ExecInitModifyTable - initialize the ModifyTable node * ExecModifyTable - retrieve the next tuple from the node * ExecEndModifyTable - shut down the ModifyTable node * ExecReScanModifyTable - rescan the ModifyTable node * * NOTES * The ModifyTable node receives input from its outerPlan, which is * the data to insert for INSERT cases, the changed columns' new * values plus row-locating info for UPDATE and MERGE cases, or just the * row-locating info for DELETE cases. * * The relation to modify can be an ordinary table, a foreign table, or a * view. If it's a view, either it has sufficient INSTEAD OF triggers or * this node executes only MERGE ... DO NOTHING. If the original MERGE * targeted a view not in one of those two categories, earlier processing * already pointed the ModifyTable result relation to an underlying * relation of that other view. This node does process * ri_WithCheckOptions, which may have expressions from those other, * automatically updatable views. * * MERGE runs a join between the source relation and the target table. * If any WHEN NOT MATCHED [BY TARGET] clauses are present, then the join * is an outer join that might output tuples without a matching target * tuple. In this case, any unmatched target tuples will have NULL * row-locating info, and only INSERT can be run. But for matched target * tuples, the row-locating info is used to determine the tuple to UPDATE * or DELETE. When all clauses are WHEN MATCHED or WHEN NOT MATCHED BY * SOURCE, all tuples produced by the join will include a matching target * tuple, so all tuples contain row-locating info. * * If the query specifies RETURNING, then the ModifyTable returns a * RETURNING tuple after completing each row insert, update, or delete. * It must be called again to continue the operation. Without RETURNING, * we just loop within the node until all the work is done, then * return NULL. This avoids useless call/return overhead. */ #include <postgres.h> #include <access/tupdesc.h> #include <access/xact.h> #include <catalog/pg_attribute.h> #include <catalog/pg_type.h> #include <executor/execPartition.h> #include <executor/nodeModifyTable.h> #include <foreign/foreign.h> #include <nodes/execnodes.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/pg_list.h> #include <nodes/plannodes.h> #include <optimizer/optimizer.h> #include <optimizer/plancat.h> #include <parser/parsetree.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/snapmgr.h> #include "cross_module_fn.h" #include "guc.h" #include "hypertable_cache.h" #include "modify_hypertable.h" #include "nodes/chunk_append/chunk_append.h" #include "utils.h" /* * Context struct for a ModifyTable operation, containing basic execution * state and some output variables populated by ExecUpdateAct() and * ExecDeleteAct() to report the result of their actions to callers. */ typedef struct ModifyTableContext { /* Operation state */ ModifyHypertableState *ht_state; ModifyTableState *mtstate; EPQState *epqstate; EState *estate; /* * Slot containing tuple obtained from ModifyTable's subplan. Used to * access "junk" columns that are not going to be stored. */ TupleTableSlot *planSlot; /* MERGE specific */ MergeActionState *relaction; /* MERGE action in progress */ /* * Information about the changes that were made concurrently to a tuple * being updated or deleted */ TM_FailureData tmfd; /* * The tuple produced by EvalPlanQual to retry from, if a * cross-partition UPDATE requires it */ TupleTableSlot *cpUpdateRetrySlot; /* * The tuple projected by the INSERT's RETURNING clause, when doing a * cross-partition UPDATE */ TupleTableSlot *cpUpdateReturningSlot; /* * Lock mode to acquire on the latest tuple version before performing * EvalPlanQual on it */ LockTupleMode lockmode; } ModifyTableContext; /* * Context struct containing output data specific to UPDATE operations. */ typedef struct UpdateContext { bool crossPartUpdate; /* was it a cross-partition update? */ #if PG16_LT bool updateIndexes; /* index update required? */ #else TU_UpdateIndexes updateIndexes; /* Which index updates are required? */ #endif /* * Lock mode to acquire on the latest tuple version before performing * EvalPlanQual on it */ LockTupleMode lockmode; } UpdateContext; static void ExecBatchInsert(ModifyTableState *mtstate, ResultRelInfo *resultRelInfo, TupleTableSlot **slots, TupleTableSlot **planSlots, int numSlots, EState *estate, bool canSetTag); static void ExecPendingInserts(EState *estate); /* static void ExecCrossPartitionUpdateForeignKey(ModifyTableContext *context, ResultRelInfo *sourcePartInfo, ResultRelInfo *destPartInfo, ItemPointer tupleid, TupleTableSlot *oldslot, TupleTableSlot *newslot); */ static bool ExecOnConflictUpdate(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer conflictTid, TupleTableSlot *excludedSlot, bool canSetTag, TupleTableSlot **returning); static TupleTableSlot *ExecPrepareTupleRouting(ModifyTableState *mtstate, EState *estate, ChunkTupleRouting *ctr, ResultRelInfo *targetRelInfo, TupleTableSlot *slot, ResultRelInfo **partRelInfo); static TupleTableSlot *ExecMerge(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ChunkTupleRouting *ctr, ItemPointer tupleid, HeapTuple oldtuple, bool canSetTag); /* static void ExecInitMerge(ModifyTableState *mtstate, EState *estate); */ static TupleTableSlot *ExecMergeMatched(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, bool canSetTag, bool *matched); static TupleTableSlot *ExecMergeNotMatched(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ChunkTupleRouting *ctr, bool canSetTag); /* * Verify that the tuples to be produced by INSERT match the * target relation's rowtype * * We do this to guard against stale plans. If plan invalidation is * functioning properly then we should never get a failure here, but better * safe than sorry. Note that this is called after we have obtained lock * on the target rel, so the rowtype can't change underneath us. * * The plan output is represented by its targetlist, because that makes * handling the dropped-column case easier. * * We used to use this for UPDATE as well, but now the equivalent checks * are done in ExecBuildUpdateProjection. */ static void ExecCheckPlanOutput(Relation resultRel, List *targetList) { TupleDesc resultDesc = RelationGetDescr(resultRel); int attno = 0; ListCell *lc; foreach(lc, targetList) { TargetEntry *tle = (TargetEntry *) lfirst(lc); Form_pg_attribute attr; Assert(!tle->resjunk); /* caller removed junk items already */ if (attno >= resultDesc->natts) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("table row type and query-specified row type do not match"), errdetail("Query has too many columns."))); attr = TupleDescAttr(resultDesc, attno); attno++; if (!attr->attisdropped) { /* Normal case: demand type match */ if (exprType((Node *) tle->expr) != attr->atttypid) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("table row type and query-specified row type do not match"), errdetail("Table has type %s at ordinal position %d, but query expects %s.", format_type_be(attr->atttypid), attno, format_type_be(exprType((Node *) tle->expr))))); } else { /* * For a dropped column, we can't check atttypid (it's likely 0). * In any case the planner has most likely inserted an INT4 null. * What we insist on is just *some* NULL constant. */ if (!IsA(tle->expr, Const) || !((Const *) tle->expr)->constisnull) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("table row type and query-specified row type do not match"), errdetail("Query provides a value for a dropped column at ordinal position %d.", attno))); } } if (attno != resultDesc->natts) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("table row type and query-specified row type do not match"), errdetail("Query has too few columns."))); } /* * ExecProcessReturning --- evaluate a RETURNING list * * resultRelInfo: current result rel * tupleSlot: slot holding tuple actually inserted/updated/deleted * planSlot: slot holding tuple returned by top subplan node * * Note: If tupleSlot is NULL, the FDW should have already provided econtext's * scan tuple. * * Returns a slot holding the result tuple */ static TupleTableSlot * ExecProcessReturning(ResultRelInfo *resultRelInfo, TupleTableSlot *tupleSlot, TupleTableSlot *planSlot) { ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning; ExprContext *econtext = projectReturning->pi_exprContext; /* Make tuple and any needed join variables available to ExecProject */ if (tupleSlot) econtext->ecxt_scantuple = tupleSlot; econtext->ecxt_outertuple = planSlot; /* * RETURNING expressions might reference the tableoid column, so * reinitialize tts_tableOid before evaluating them. */ econtext->ecxt_scantuple->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc); /* Compute the RETURNING expressions */ return ExecProject(projectReturning); } /* * ExecCheckTupleVisible -- verify tuple is visible * * It would not be consistent with guarantees of the higher isolation levels to * proceed with avoiding insertion (taking speculative insertion's alternative * path) on the basis of another tuple that is not visible to MVCC snapshot. * Check for the need to raise a serialization failure, and do so as necessary. */ static void ExecCheckTupleVisible(EState *estate, Relation rel, TupleTableSlot *slot) { if (!IsolationUsesXactSnapshot()) return; if (!table_tuple_satisfies_snapshot(rel, slot, estate->es_snapshot)) { Datum xminDatum; TransactionId xmin; bool isnull; xminDatum = slot_getsysattr(slot, MinTransactionIdAttributeNumber, &isnull); Assert(!isnull); xmin = DatumGetTransactionId(xminDatum); /* * We should not raise a serialization failure if the conflict is * against a tuple inserted by our own transaction, even if it's not * visible to our snapshot. (This would happen, for example, if * conflicting keys are proposed for insertion in a single command.) */ if (!TransactionIdIsCurrentTransactionId(xmin)) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); } } /* * ExecCheckTIDVisible -- convenience variant of ExecCheckTupleVisible() */ static void ExecCheckTIDVisible(EState *estate, ResultRelInfo *relinfo, ItemPointer tid, TupleTableSlot *tempSlot) { Relation rel = relinfo->ri_RelationDesc; /* Redundantly check isolation level */ if (!IsolationUsesXactSnapshot()) return; if (!table_tuple_fetch_row_version(rel, tid, SnapshotAny, tempSlot)) elog(ERROR, "failed to fetch conflicting tuple for ON CONFLICT"); ExecCheckTupleVisible(estate, rel, tempSlot); ExecClearTuple(tempSlot); } /* * ExecInitInsertProjection * Do one-time initialization of projection data for INSERT tuples. * * INSERT queries may need a projection to filter out junk attrs in the tlist. * * This is also a convenient place to verify that the * output of an INSERT matches the target table. */ static void ExecInitInsertProjection(ModifyTableState *mtstate, ResultRelInfo *resultRelInfo) { ModifyTable *node = (ModifyTable *) mtstate->ps.plan; Plan *subplan = outerPlan(node); EState *estate = mtstate->ps.state; List *insertTargetList = NIL; bool need_projection = false; ListCell *l; /* Extract non-junk columns of the subplan's result tlist. */ foreach(l, subplan->targetlist) { TargetEntry *tle = (TargetEntry *) lfirst(l); if (!tle->resjunk) insertTargetList = lappend(insertTargetList, tle); else need_projection = true; } /* * The junk-free list must produce a tuple suitable for the result * relation. */ ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc, insertTargetList); /* We'll need a slot matching the table's format. */ resultRelInfo->ri_newTupleSlot = table_slot_create(resultRelInfo->ri_RelationDesc, &estate->es_tupleTable); /* Build ProjectionInfo if needed (it probably isn't). */ if (need_projection) { TupleDesc relDesc = RelationGetDescr(resultRelInfo->ri_RelationDesc); /* need an expression context to do the projection */ if (mtstate->ps.ps_ExprContext == NULL) ExecAssignExprContext(estate, &mtstate->ps); resultRelInfo->ri_projectNew = ExecBuildProjectionInfo(insertTargetList, mtstate->ps.ps_ExprContext, resultRelInfo->ri_newTupleSlot, &mtstate->ps, relDesc); } resultRelInfo->ri_projectNewInfoValid = true; } /* * ExecInitUpdateProjection * Do one-time initialization of projection data for UPDATE tuples. * * UPDATE always needs a projection, because (1) there's always some junk * attrs, and (2) we may need to merge values of not-updated columns from * the old tuple into the final tuple. In UPDATE, the tuple arriving from * the subplan contains only new values for the changed columns, plus row * identity info in the junk attrs. * * This is "one-time" for any given result rel, but we might touch more than * one result rel in the course of an inherited UPDATE, and each one needs * its own projection due to possible column order variation. * * This is also a convenient place to verify that the output of an UPDATE * matches the target table (ExecBuildUpdateProjection does that). */ static void ExecInitUpdateProjection(ModifyTableState *mtstate, ResultRelInfo *resultRelInfo) { ModifyTable *node = (ModifyTable *) mtstate->ps.plan; Plan *subplan = outerPlan(node); EState *estate = mtstate->ps.state; TupleDesc relDesc = RelationGetDescr(resultRelInfo->ri_RelationDesc); int whichrel; List *updateColnos; /* * Usually, mt_lastResultIndex matches the target rel. If it happens not * to, we can get the index the hard way with an integer division. */ whichrel = mtstate->mt_lastResultIndex; if (resultRelInfo != mtstate->resultRelInfo + whichrel) { whichrel = resultRelInfo - mtstate->resultRelInfo; Assert(whichrel >= 0 && whichrel < mtstate->mt_nrels); } updateColnos = (List *) list_nth(node->updateColnosLists, whichrel); /* * For UPDATE, we use the old tuple to fill up missing values in the tuple * produced by the subplan to get the new tuple. We need two slots, both * matching the table's desired format. */ resultRelInfo->ri_oldTupleSlot = table_slot_create(resultRelInfo->ri_RelationDesc, &estate->es_tupleTable); resultRelInfo->ri_newTupleSlot = table_slot_create(resultRelInfo->ri_RelationDesc, &estate->es_tupleTable); /* need an expression context to do the projection */ if (mtstate->ps.ps_ExprContext == NULL) ExecAssignExprContext(estate, &mtstate->ps); resultRelInfo->ri_projectNew = ExecBuildUpdateProjection(subplan->targetlist, false, /* subplan did the evaluation */ updateColnos, relDesc, mtstate->ps.ps_ExprContext, resultRelInfo->ri_newTupleSlot, &mtstate->ps); resultRelInfo->ri_projectNewInfoValid = true; } /* * ExecGetInsertNewTuple * This prepares a "new" tuple ready to be inserted into given result * relation, by removing any junk columns of the plan's output tuple * and (if necessary) coercing the tuple to the right tuple format. */ static TupleTableSlot * ExecGetInsertNewTuple(ResultRelInfo *relinfo, TupleTableSlot *planSlot) { ProjectionInfo *newProj = relinfo->ri_projectNew; ExprContext *econtext; /* * If there's no projection to be done, just make sure the slot is of the * right type for the target rel. If the planSlot is the right type we * can use it as-is, else copy the data into ri_newTupleSlot. */ if (newProj == NULL) { if (relinfo->ri_newTupleSlot->tts_ops != planSlot->tts_ops) { ExecCopySlot(relinfo->ri_newTupleSlot, planSlot); return relinfo->ri_newTupleSlot; } else return planSlot; } /* * Else project; since the projection output slot is ri_newTupleSlot, this * will also fix any slot-type problem. * * Note: currently, this is dead code, because INSERT cases don't receive * any junk columns so there's never a projection to be done. */ econtext = newProj->pi_exprContext; econtext->ecxt_outertuple = planSlot; return ExecProject(newProj); } /* * ExecPrepareTupleRouting --- prepare for routing one tuple * * Determine the partition in which the tuple in slot is to be inserted, * and return its ResultRelInfo in *partRelInfo. The return value is * a slot holding the tuple of the partition rowtype. * * This also sets the transition table information in mtstate based on the * selected partition. */ static TupleTableSlot * ExecPrepareTupleRouting(ModifyTableState *mtstate, EState *estate, ChunkTupleRouting *ctr, ResultRelInfo *targetRelInfo, TupleTableSlot *slot, ResultRelInfo **partRelInfo) { ChunkInsertState *cis = ctr->cis; /* Convert the tuple to the chunk's rowtype, if necessary */ if (cis->hyper_to_chunk_map != NULL && ctr->has_dropped_attrs == false) slot = execute_attr_map_slot(cis->hyper_to_chunk_map->attrMap, slot, cis->slot); *partRelInfo = cis->result_relation_info; return slot; } /* ---------------------------------------------------------------- * ExecInsert * * For INSERT, we have to insert the tuple into the target relation * (or partition thereof) and insert appropriate tuples into the index * relations. * * slot contains the new tuple value to be stored. * planSlot is the output of the ModifyTable's subplan; we use it * to access "junk" columns that are not going to be stored. * * Returns RETURNING result if any, otherwise NULL. * * This may change the currently active tuple conversion map in * mtstate->mt_transition_capture, so the callers must take care to * save the previous value to avoid losing track of it. * ---------------------------------------------------------------- * * copied and modified version of ExecInsert from executor/nodeModifyTable.c */ TupleTableSlot * ExecInsert(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ChunkTupleRouting *ctr, TupleTableSlot *slot, bool canSetTag) { ModifyTableState *mtstate = context->mtstate; EState *estate = context->estate; Relation resultRelationDesc; List *recheckIndexes = NIL; TupleTableSlot *planSlot = context->planSlot; TupleTableSlot *result = NULL; TransitionCaptureState *ar_insert_trig_tcs; ModifyTable *node = (ModifyTable *) mtstate->ps.plan; OnConflictAction onconflict = node->onConflictAction; bool skip_generated_column_computations = false; Assert(!mtstate->mt_partition_tuple_routing); /* * If the input result relation is a partitioned table, find the leaf * partition to insert the tuple into. */ if (ctr) { ResultRelInfo *partRelInfo; slot = ExecPrepareTupleRouting(mtstate, estate, ctr, resultRelInfo, slot, &partRelInfo); resultRelInfo = partRelInfo; skip_generated_column_computations = ctr->cis->skip_generated_column_computations; } ExecMaterializeSlot(slot); resultRelationDesc = resultRelInfo->ri_RelationDesc; /* * Open the table's indexes, if we have not done so already, so that we * can add new index entries for the inserted tuple. */ if (resultRelationDesc->rd_rel->relhasindex && resultRelInfo->ri_IndexRelationDescs == NULL) ExecOpenIndices(resultRelInfo, onconflict != ONCONFLICT_NONE); /* * BEFORE ROW INSERT Triggers. * * Note: We fire BEFORE ROW TRIGGERS for every attempted insertion in an * INSERT ... ON CONFLICT statement. We cannot check for constraint * violations before firing these triggers, because they can change the * values to insert. Also, they can run arbitrary user-defined code with * side-effects that we can't cancel by just not inserting the tuple. */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_before_row) { if (!ExecBRInsertTriggers(estate, resultRelInfo, slot)) return NULL; /* "do nothing" */ } /* INSTEAD OF ROW INSERT Triggers */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_instead_row) { if (!ExecIRInsertTriggers(estate, resultRelInfo, slot)) return NULL; /* "do nothing" */ } else if (resultRelInfo->ri_FdwRoutine) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("inserting into foreign tables not supported in hypertable context"))); } else { WCOKind wco_kind; /* * Constraints and GENERATED expressions might reference the tableoid * column, so (re-)initialize tts_tableOid before evaluating them. */ slot->tts_tableOid = RelationGetRelid(resultRelationDesc); /* * Compute stored generated columns * NOTE: we are skipping generation if we detect that we went through * compressed chunk uniqueness check which would have already * triggered generating the columns. */ if (resultRelationDesc->rd_att->constr && resultRelationDesc->rd_att->constr->has_generated_stored && !skip_generated_column_computations ) ExecComputeStoredGenerated(resultRelInfo, estate, slot, CMD_INSERT); /* * Check any RLS WITH CHECK policies. * * Normally we should check INSERT policies. But if the insert is the * result of a partition key update that moved the tuple to a new * partition, we should instead check UPDATE policies, because we are * executing policies defined on the target table, and not those * defined on the child partitions. * * If we're running MERGE, we refer to the action that we're executing * to know if we're doing an INSERT or UPDATE to a partition table. */ if (mtstate->operation == CMD_UPDATE) wco_kind = WCO_RLS_UPDATE_CHECK; else if (mtstate->operation == CMD_MERGE) wco_kind = ( #if PG17_GE mtstate->mt_merge_action->mas_action->commandType #else context->relaction->mas_action->commandType #endif == CMD_UPDATE) ? WCO_RLS_UPDATE_CHECK : WCO_RLS_INSERT_CHECK; else wco_kind = WCO_RLS_INSERT_CHECK; /* * ExecWithCheckOptions() will skip any WCOs which are not of the kind * we are looking for at this point. */ if (resultRelInfo->ri_WithCheckOptions != NIL) ExecWithCheckOptions(wco_kind, resultRelInfo, slot, estate); /* * Check the constraints of the tuple. */ if (resultRelationDesc->rd_att->constr) ExecConstraints(resultRelInfo, slot, estate); /* * Also check the tuple against the partition constraint, if there is * one; except that if we got here via tuple-routing, we don't need to * if there's no BR trigger defined on the partition. */ if (resultRelationDesc->rd_rel->relispartition && (resultRelInfo->ri_RootResultRelInfo == NULL || (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_insert_before_row))) ExecPartitionCheck(resultRelInfo, slot, estate, true); if (onconflict != ONCONFLICT_NONE && resultRelInfo->ri_NumIndices > 0) { /* Perform a speculative insertion. */ uint32 specToken; ItemPointerData conflictTid; bool specConflict; List *arbiterIndexes; arbiterIndexes = resultRelInfo->ri_onConflictArbiterIndexes; /* * Do a non-conclusive check for conflicts first. * * We're not holding any locks yet, so this doesn't guarantee that * the later insert won't conflict. But it avoids leaving behind * a lot of canceled speculative insertions, if you run a lot of * INSERT ON CONFLICT statements that do conflict. * * We loop back here if we find a conflict below, either during * the pre-check, or when we re-check after inserting the tuple * speculatively. */ vlock: specConflict = false; if (!ExecCheckIndexConstraints(resultRelInfo, slot, estate, &conflictTid, #if PG18_GE NULL, #endif arbiterIndexes)) { /* committed conflict tuple found */ if (onconflict == ONCONFLICT_UPDATE) { /* * In case of ON CONFLICT DO UPDATE, execute the UPDATE * part. Be prepared to retry if the UPDATE fails because * of another concurrent UPDATE/DELETE to the conflict * tuple. */ TupleTableSlot *returning = NULL; if (ExecOnConflictUpdate(context, resultRelInfo, &conflictTid, slot, canSetTag, &returning)) { InstrCountTuples2(&mtstate->ps, 1); return returning; } else goto vlock; } else { /* * In case of ON CONFLICT DO NOTHING, do nothing. However, * verify that the tuple is visible to the executor's MVCC * snapshot at higher isolation levels. * * Using ExecGetReturningSlot() to store the tuple for the * recheck isn't that pretty, but we can't trivially use * the input slot, because it might not be of a compatible * type. As there's no conflicting usage of * ExecGetReturningSlot() in the DO NOTHING case... */ Assert(onconflict == ONCONFLICT_NOTHING); ExecCheckTIDVisible(estate, resultRelInfo, &conflictTid, ExecGetReturningSlot(estate, resultRelInfo)); InstrCountTuples2(&mtstate->ps, 1); return NULL; } } /* * Before we start insertion proper, acquire our "speculative * insertion lock". Others can use that to wait for us to decide * if we're going to go ahead with the insertion, instead of * waiting for the whole transaction to complete. */ specToken = SpeculativeInsertionLockAcquire(GetCurrentTransactionId()); /* insert the tuple, with the speculative token */ table_tuple_insert_speculative(resultRelationDesc, slot, estate->es_output_cid, 0, NULL, specToken); /* insert index entries for tuple */ recheckIndexes = ExecInsertIndexTuplesCompat(resultRelInfo, slot, estate, false, true, &specConflict, arbiterIndexes, false); /* adjust the tuple's state accordingly */ table_tuple_complete_speculative(resultRelationDesc, slot, specToken, !specConflict); /* * Wake up anyone waiting for our decision. They will re-check * the tuple, see that it's no longer speculative, and wait on our * XID as if this was a regularly inserted tuple all along. Or if * we killed the tuple, they will see it's dead, and proceed as if * the tuple never existed. */ SpeculativeInsertionLockRelease(GetCurrentTransactionId()); /* * If there was a conflict, start from the beginning. We'll do * the pre-check again, which will now find the conflicting tuple * (unless it aborts before we get there). */ if (specConflict) { list_free(recheckIndexes); goto vlock; } /* Since there was no insertion conflict, we're done */ } else { /* insert the tuple normally */ table_tuple_insert(resultRelationDesc, slot, estate->es_output_cid, 0, NULL); /* insert index entries for tuple */ if (resultRelInfo->ri_NumIndices > 0) recheckIndexes = ExecInsertIndexTuplesCompat(resultRelInfo, slot, estate, false, false, NULL, NIL, false); } } if (context->ht_state->has_continuous_aggregate && !ts_guc_enable_cagg_wal_based_invalidation) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); ts_cm_functions->continuous_agg_dml_invalidate(context->ht_state->ht->fd.id, resultRelationDesc, tuple, NULL, false); if (should_free) heap_freetuple(tuple); } if (canSetTag) (estate->es_processed)++; /* * If this insert is the result of a partition key update that moved the * tuple to a new partition, put this row into the transition NEW TABLE, * if there is one. We need to do this separately for DELETE and INSERT * because they happen on different tables. */ ar_insert_trig_tcs = mtstate->mt_transition_capture; if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture && mtstate->mt_transition_capture->tcs_update_new_table) { ExecARUpdateTriggers(estate, resultRelInfo, NULL, /* src_partinfo */ NULL, /* dst_partinfo */ NULL, NULL, slot, NULL, mtstate->mt_transition_capture, false /* is_crosspart_update */ ); /* * We've already captured the NEW TABLE row, so make sure any AR * INSERT trigger fired below doesn't capture it again. */ ar_insert_trig_tcs = NULL; } /* AFTER ROW INSERT Triggers */ ExecARInsertTriggers(estate, resultRelInfo, slot, recheckIndexes, ar_insert_trig_tcs); list_free(recheckIndexes); /* * Check any WITH CHECK OPTION constraints from parent views. We are * required to do this after testing all constraints and uniqueness * violations per the SQL spec, so we do it after actually inserting the * record into the heap and all indexes. * * ExecWithCheckOptions will elog(ERROR) if a violation is found, so the * tuple will never be seen, if it violates the WITH CHECK OPTION. * * ExecWithCheckOptions() will skip any WCOs which are not of the kind we * are looking for at this point. */ if (resultRelInfo->ri_WithCheckOptions != NIL) ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate); /* Process RETURNING if present */ if (resultRelInfo->ri_projectReturning) result = ExecProcessReturning(resultRelInfo, slot, planSlot); return result; } /* ---------------------------------------------------------------- * ExecBatchInsert * * Insert multiple tuples in an efficient way. * Currently, this handles inserting into a foreign table without * RETURNING clause. * ---------------------------------------------------------------- */ static void ExecBatchInsert(ModifyTableState *mtstate, ResultRelInfo *resultRelInfo, TupleTableSlot **slots, TupleTableSlot **planSlots, int numSlots, EState *estate, bool canSetTag) { int i; int numInserted = numSlots; TupleTableSlot *slot = NULL; TupleTableSlot **rslots; /* * insert into foreign table: let the FDW do it */ rslots = resultRelInfo->ri_FdwRoutine->ExecForeignBatchInsert(estate, resultRelInfo, slots, planSlots, &numInserted); for (i = 0; i < numInserted; i++) { slot = rslots[i]; /* * AFTER ROW Triggers might reference the tableoid column, so * (re-)initialize tts_tableOid before evaluating them. */ slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc); /* AFTER ROW INSERT Triggers */ ExecARInsertTriggers(estate, resultRelInfo, slot, NIL, mtstate->mt_transition_capture); /* * Check any WITH CHECK OPTION constraints from parent views. See the * comment in ExecInsert. */ if (resultRelInfo->ri_WithCheckOptions != NIL) ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate); } if (canSetTag && numInserted > 0) estate->es_processed += numInserted; /* Clean up all the slots, ready for the next batch */ for (i = 0; i < numSlots; i++) { ExecClearTuple(slots[i]); ExecClearTuple(planSlots[i]); } resultRelInfo->ri_NumSlots = 0; } /* * ExecPendingInserts -- flushes all pending inserts to the foreign tables */ static void ExecPendingInserts(EState *estate) { ListCell *l1, *l2; forboth(l1, estate->es_insert_pending_result_relations, l2, estate->es_insert_pending_modifytables) { ResultRelInfo *resultRelInfo = (ResultRelInfo *) lfirst(l1); ModifyTableState *mtstate = (ModifyTableState *) lfirst(l2); Assert(mtstate); ExecBatchInsert(mtstate, resultRelInfo, resultRelInfo->ri_Slots, resultRelInfo->ri_PlanSlots, resultRelInfo->ri_NumSlots, estate, mtstate->canSetTag); } list_free(estate->es_insert_pending_result_relations); list_free(estate->es_insert_pending_modifytables); estate->es_insert_pending_result_relations = NIL; estate->es_insert_pending_modifytables = NIL; } /* * ExecDeletePrologue -- subroutine for ExecDelete * * Prepare executor state for DELETE. Actually, the only thing we have to do * here is execute BEFORE ROW triggers. We return false if one of them makes * the delete a no-op; otherwise, return true. */ static bool ExecDeletePrologue(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot **epqreturnslot, TM_Result *result) { if (result) *result = TM_Ok; /* BEFORE ROW DELETE triggers */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_delete_before_row) { /* Flush any pending inserts, so rows are visible to the triggers */ if (context->estate->es_insert_pending_result_relations != NIL) ExecPendingInserts(context->estate); return ExecBRDeleteTriggersCompat(context->estate, context->epqstate, resultRelInfo, tupleid, oldtuple, epqreturnslot, result, &context->tmfd, context->mtstate->operation == CMD_MERGE); } return true; } /* * ExecDeleteAct -- subroutine for ExecDelete * * Actually delete the tuple from a plain table. * * Caller is in charge of doing EvalPlanQual as necessary */ static TM_Result ExecDeleteAct(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, bool changingPart) { EState *estate = context->estate; return table_tuple_delete(resultRelInfo->ri_RelationDesc, tupleid, estate->es_output_cid, estate->es_snapshot, estate->es_crosscheck_snapshot, true /* wait for commit */ , &context->tmfd, changingPart); } /* * ExecDeleteEpilogue -- subroutine for ExecDelete * * Closing steps of tuple deletion; this invokes AFTER FOR EACH ROW triggers, * including the UPDATE triggers if the deletion is being done as part of a * cross-partition tuple move. */ static void ExecDeleteEpilogue(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, bool changingPart) { ModifyTableState *mtstate = context->mtstate; EState *estate = context->estate; TransitionCaptureState *ar_delete_trig_tcs; /* * If this delete is the result of a partition key update that moved the * tuple to a new partition, put this row into the transition OLD TABLE, * if there is one. We need to do this separately for DELETE and INSERT * because they happen on different tables. */ ar_delete_trig_tcs = mtstate->mt_transition_capture; if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture && mtstate->mt_transition_capture->tcs_update_old_table) { ExecARUpdateTriggers(estate, resultRelInfo, NULL, NULL, tupleid, oldtuple, NULL, NULL, mtstate->mt_transition_capture, false); /* * We've already captured the OLD TABLE row, so make sure any AR * DELETE trigger fired below doesn't capture it again. */ ar_delete_trig_tcs = NULL; } /* AFTER ROW DELETE Triggers */ ExecARDeleteTriggers(estate, resultRelInfo, tupleid, oldtuple, ar_delete_trig_tcs, changingPart); } /* ---------------------------------------------------------------- * ExecDelete * * DELETE is like UPDATE, except that we delete the tuple and no * index modifications are needed. * * When deleting from a table, tupleid identifies the tuple to delete and * oldtuple is NULL. When deleting through a view INSTEAD OF trigger, * oldtuple is passed to the triggers and identifies what to delete, and * tupleid is invalid. When deleting from a foreign table, tupleid is * invalid; the FDW has to figure out which row to delete using data from * the planSlot. oldtuple is passed to foreign table triggers; it is * NULL when the foreign table has no relevant triggers. We use * tupleDeleted to indicate whether the tuple is actually deleted, * callers can use it to decide whether to continue the operation. When * this DELETE is a part of an UPDATE of partition-key, then the slot * returned by EvalPlanQual() is passed back using output parameter * epqreturnslot. * * Returns RETURNING result if any, otherwise NULL. * ---------------------------------------------------------------- */ static TupleTableSlot * ExecDelete(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, bool processReturning, bool changingPart, bool canSetTag, TM_Result *tmresult, bool *tupleDeleted, TupleTableSlot **epqreturnslot) { EState *estate = context->estate; Relation resultRelationDesc = resultRelInfo->ri_RelationDesc; TupleTableSlot *slot = NULL; TM_Result result; if (tupleDeleted) *tupleDeleted = false; /* * Prepare for the delete. This includes BEFORE ROW triggers, so we're * done if it says we are. */ if (!ExecDeletePrologue(context, resultRelInfo, tupleid, oldtuple, epqreturnslot, tmresult)) return NULL; /* INSTEAD OF ROW DELETE Triggers */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_delete_instead_row) { bool dodelete; Assert(oldtuple != NULL); dodelete = ExecIRDeleteTriggers(estate, resultRelInfo, oldtuple); if (!dodelete) /* "do nothing" */ return NULL; } else if (resultRelInfo->ri_FdwRoutine) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("deleting from foreign tables not supported in hypertable context"))); } else { /* * delete the tuple * * Note: if context->estate->es_crosscheck_snapshot isn't * InvalidSnapshot, we check that the row to be deleted is visible to * that snapshot, and throw a can't-serialize error if not. This is a * special-case behavior needed for referential integrity updates in * transaction-snapshot mode transactions. */ ldelete: result = ExecDeleteAct(context, resultRelInfo, tupleid, changingPart); if (tmresult) *tmresult = result; switch (result) { case TM_SelfModified: /* * The target tuple was already updated or deleted by the * current command, or by a later command in the current * transaction. The former case is possible in a join DELETE * where multiple tuples join to the same target tuple. This * is somewhat questionable, but Postgres has always allowed * it: we just ignore additional deletion attempts. * * The latter case arises if the tuple is modified by a * command in a BEFORE trigger, or perhaps by a command in a * volatile function used in the query. In such situations we * should not ignore the deletion, but it is equally unsafe to * proceed. We don't want to discard the original DELETE * while keeping the triggered actions based on its deletion; * and it would be no better to allow the original DELETE * while discarding updates that it triggered. The row update * carries some information that might be important according * to business rules; so throwing an error is the only safe * course. * * If a trigger actually intends this type of interaction, it * can re-execute the DELETE and then return NULL to cancel * the outer delete. */ if (context->tmfd.cmax != estate->es_output_cid) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION), errmsg("tuple to be deleted was already modified by an operation triggered by the current command"), errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows."))); /* Else, already deleted by self; nothing to do */ return NULL; case TM_Ok: break; case TM_Updated: { TupleTableSlot *inputslot; TupleTableSlot *epqslot; if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); /* * Already know that we're going to need to do EPQ, so * fetch tuple directly into the right slot. */ EvalPlanQualBegin(context->epqstate); inputslot = EvalPlanQualSlot(context->epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex); result = table_tuple_lock(resultRelationDesc, tupleid, estate->es_snapshot, inputslot, estate->es_output_cid, LockTupleExclusive, LockWaitBlock, TUPLE_LOCK_FLAG_FIND_LAST_VERSION, &context->tmfd); switch (result) { case TM_Ok: Assert(context->tmfd.traversed); epqslot = EvalPlanQual(context->epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex, inputslot); if (TupIsNull(epqslot)) /* Tuple not passing quals anymore, exiting... */ return NULL; /* * If requested, skip delete and pass back the * updated row. */ if (epqreturnslot) { *epqreturnslot = epqslot; return NULL; } else goto ldelete; case TM_SelfModified: /* * This can be reached when following an update * chain from a tuple updated by another session, * reaching a tuple that was already updated in * this transaction. If previously updated by this * command, ignore the delete, otherwise error * out. * * See also TM_SelfModified response to * table_tuple_delete() above. */ if (context->tmfd.cmax != estate->es_output_cid) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION), errmsg("tuple to be deleted was already modified by an operation triggered by the current command"), errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows."))); return NULL; case TM_Deleted: /* tuple already deleted; nothing to do */ return NULL; default: /* * TM_Invisible should be impossible because we're * waiting for updated row versions, and would * already have errored out if the first version * is invisible. * * TM_Updated should be impossible, because we're * locking the latest version via * TUPLE_LOCK_FLAG_FIND_LAST_VERSION. */ elog(ERROR, "unexpected table_tuple_lock status: %u", result); return NULL; } Assert(false); break; } case TM_Deleted: if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent delete"))); /* tuple already deleted; nothing to do */ return NULL; default: elog(ERROR, "unrecognized table_tuple_delete status: %u", result); return NULL; } /* * Note: Normally one would think that we have to delete index tuples * associated with the heap tuple now... * * ... but in POSTGRES, we have no need to do this because VACUUM will * take care of it later. We can't delete index tuples immediately * anyway, since the tuple is still visible to other transactions. */ } if (context->ht_state->has_continuous_aggregate && !ts_guc_enable_cagg_wal_based_invalidation) { bool should_free; TupleTableSlot *cagg_slot = table_slot_create(resultRelationDesc, NULL); table_tuple_fetch_row_version(resultRelationDesc, tupleid, SnapshotAny, cagg_slot); HeapTuple tuple = ExecFetchSlotHeapTuple(cagg_slot, false, &should_free); ts_cm_functions->continuous_agg_dml_invalidate(context->ht_state->ht->fd.id, resultRelationDesc, tuple, NULL, false); if (should_free) heap_freetuple(tuple); ExecDropSingleTupleTableSlot(cagg_slot); } if (canSetTag) (estate->es_processed)++; /* Tell caller that the delete actually happened. */ if (tupleDeleted) *tupleDeleted = true; ExecDeleteEpilogue(context, resultRelInfo, tupleid, oldtuple, changingPart); /* Process RETURNING if present and if requested */ if (processReturning && resultRelInfo->ri_projectReturning) { /* * We have to put the target tuple into a slot, which means first we * gotta fetch it. We can use the trigger tuple slot. */ TupleTableSlot *rslot; if (resultRelInfo->ri_FdwRoutine) { /* FDW must have provided a slot containing the deleted row */ Assert(!TupIsNull(slot)); } else { slot = ExecGetReturningSlot(estate, resultRelInfo); if (oldtuple != NULL) { ExecForceStoreHeapTuple(oldtuple, slot, false); } else { if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid, SnapshotAny, slot)) elog(ERROR, "failed to fetch deleted tuple for DELETE RETURNING"); } } rslot = ExecProcessReturning(resultRelInfo, slot, context->planSlot); /* * Before releasing the target tuple again, make sure rslot has a * local copy of any pass-by-reference values. */ ExecMaterializeSlot(rslot); ExecClearTuple(slot); return rslot; } return NULL; } /* * ExecUpdatePrologue -- subroutine for ExecUpdate * * Prepare executor state for UPDATE. This includes running BEFORE ROW * triggers. We return false if one of them makes the update a no-op; * otherwise, return true. */ static bool ExecUpdatePrologue(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot *slot, TM_Result *result) { Relation resultRelationDesc = resultRelInfo->ri_RelationDesc; if (result) *result = TM_Ok; ExecMaterializeSlot(slot); /* * Open the table's indexes, if we have not done so already, so that we * can add new index entries for the updated tuple. */ if (resultRelationDesc->rd_rel->relhasindex && resultRelInfo->ri_IndexRelationDescs == NULL) ExecOpenIndices(resultRelInfo, false); /* BEFORE ROW UPDATE triggers */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_update_before_row) { /* Flush any pending inserts, so rows are visible to the triggers */ if (context->estate->es_insert_pending_result_relations != NIL) ExecPendingInserts(context->estate); return ExecBRUpdateTriggersCompat(context->estate, context->epqstate, resultRelInfo, tupleid, oldtuple, slot, result, &context->tmfd, context->mtstate->operation == CMD_MERGE); } return true; } /* * ExecUpdatePrepareSlot -- subroutine for ExecUpdateAct * * Apply the final modifications to the tuple slot before the update. * (This is split out because we also need it in the foreign-table code path.) */ static void ExecUpdatePrepareSlot(ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate) { Relation resultRelationDesc = resultRelInfo->ri_RelationDesc; /* * Constraints and GENERATED expressions might reference the tableoid * column, so (re-)initialize tts_tableOid before evaluating them. */ slot->tts_tableOid = RelationGetRelid(resultRelationDesc); /* * Compute stored generated columns */ if (resultRelationDesc->rd_att->constr && resultRelationDesc->rd_att->constr->has_generated_stored) ExecComputeStoredGenerated(resultRelInfo, estate, slot, CMD_UPDATE); } /* * ExecUpdateAct -- subroutine for ExecUpdate * * Actually update the tuple, when operating on a plain table. If the * table is a partition, and the command was called referencing an ancestor * partitioned table, this routine migrates the resulting tuple to another * partition. * * The caller is in charge of keeping indexes current as necessary. The * caller is also in charge of doing EvalPlanQual if the tuple is found to * be concurrently updated. However, in case of a cross-partition update, * this routine does it. */ static TM_Result ExecUpdateAct(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot *slot, bool canSetTag, UpdateContext *updateCxt) { EState *estate = context->estate; Relation resultRelationDesc = resultRelInfo->ri_RelationDesc; bool partition_constraint_failed; TM_Result result; updateCxt->crossPartUpdate = false; /* Fill in GENERATEd columns */ ExecUpdatePrepareSlot(resultRelInfo, slot, estate); /* ensure slot is independent, consider e.g. EPQ */ ExecMaterializeSlot(slot); /* * If partition constraint fails, this row might get moved to another * partition, in which case we should check the RLS CHECK policy just * before inserting into the new partition, rather than doing it here. * This is because a trigger on that partition might again change the row. * So skip the WCO checks if the partition constraint fails. */ partition_constraint_failed = resultRelationDesc->rd_rel->relispartition && !ExecPartitionCheck(resultRelInfo, slot, estate, false); /* Check any RLS UPDATE WITH CHECK policies */ if (!partition_constraint_failed && resultRelInfo->ri_WithCheckOptions != NIL) { /* * ExecWithCheckOptions() will skip any WCOs which are not of the kind * we are looking for at this point. */ ExecWithCheckOptions(WCO_RLS_UPDATE_CHECK, resultRelInfo, slot, estate); } /* * If a partition check failed, try to move the row into the right * partition. */ if (partition_constraint_failed) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot update partition key of hypertable"), errdetail("The partition constraint failed, and the row was not moved to another partition."), errhint("Use DELETE and INSERT to change the partition key."))); } /* * Check the constraints of the tuple. We've already checked the * partition constraint above; however, we must still ensure the tuple * passes all other constraints, so we will call ExecConstraints() and * have it validate all remaining checks. */ if (resultRelationDesc->rd_att->constr) ExecConstraints(resultRelInfo, slot, estate); /* * replace the heap tuple * * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check that * the row to be updated is visible to that snapshot, and throw a * can't-serialize error if not. This is a special-case behavior needed * for referential integrity updates in transaction-snapshot mode * transactions. */ result = table_tuple_update(resultRelationDesc, tupleid, slot, estate->es_output_cid, estate->es_snapshot, estate->es_crosscheck_snapshot, true /* wait for commit */ , &context->tmfd, &updateCxt->lockmode, &updateCxt->updateIndexes); return result; } /* * ExecUpdateEpilogue -- subroutine for ExecUpdate * * Closing steps of updating a tuple. Must be called if ExecUpdateAct * returns indicating that the tuple was updated. */ static void ExecUpdateEpilogue(ModifyTableContext *context, UpdateContext *updateCxt, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot *slot) { ModifyTableState *mtstate = context->mtstate; List *recheckIndexes = NIL; /* insert index entries for tuple if necessary */ #if PG15 if (resultRelInfo->ri_NumIndices > 0 && updateCxt->updateIndexes) recheckIndexes = ExecInsertIndexTuples(resultRelInfo, slot, context->estate, true, false, NULL, NIL); #else if (resultRelInfo->ri_NumIndices > 0 && (updateCxt->updateIndexes != TU_None)) recheckIndexes = ExecInsertIndexTuples(resultRelInfo, slot, context->estate, true, false, NULL, NIL, (updateCxt->updateIndexes == TU_Summarizing)); #endif /* AFTER ROW UPDATE Triggers */ ExecARUpdateTriggers(context->estate, resultRelInfo, NULL, NULL, tupleid, oldtuple, slot, recheckIndexes, mtstate->operation == CMD_INSERT ? mtstate->mt_oc_transition_capture : mtstate->mt_transition_capture, false); list_free(recheckIndexes); /* * Check any WITH CHECK OPTION constraints from parent views. We are * required to do this after testing all constraints and uniqueness * violations per the SQL spec, so we do it after actually updating the * record in the heap and all indexes. * * ExecWithCheckOptions() will skip any WCOs which are not of the kind we * are looking for at this point. */ if (resultRelInfo->ri_WithCheckOptions != NIL) ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, context->estate); } /* ---------------------------------------------------------------- * ExecUpdate * * note: we can't run UPDATE queries with transactions * off because UPDATEs are actually INSERTs and our * scan will mistakenly loop forever, updating the tuple * it just inserted.. This should be fixed but until it * is, we don't want to get stuck in an infinite loop * which corrupts your database.. * * When updating a table, tupleid identifies the tuple to update and * oldtuple is NULL. When updating through a view INSTEAD OF trigger, * oldtuple is passed to the triggers and identifies what to update, and * tupleid is invalid. When updating a foreign table, tupleid is * invalid; the FDW has to figure out which row to update using data from * the planSlot. oldtuple is passed to foreign table triggers; it is * NULL when the foreign table has no relevant triggers. * * slot contains the new tuple value to be stored. * planSlot is the output of the ModifyTable's subplan; we use it * to access values from other input tables (for RETURNING), * row-ID junk columns, etc. * * Returns RETURNING result if any, otherwise NULL. On exit, if tupleid * had identified the tuple to update, it will identify the tuple * actually updated after EvalPlanQual. * ---------------------------------------------------------------- */ static TupleTableSlot * ExecUpdate(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, TupleTableSlot *slot, bool canSetTag) { EState *estate = context->estate; Relation resultRelationDesc = resultRelInfo->ri_RelationDesc; UpdateContext updateCxt = {0}; TM_Result result; /* * abort the operation if not running transactions */ if (IsBootstrapProcessingMode()) elog(ERROR, "cannot UPDATE during bootstrap"); /* * Prepare for the update. This includes BEFORE ROW triggers, so we're * done if it says we are. */ if (!ExecUpdatePrologue(context, resultRelInfo, tupleid, oldtuple, slot, NULL)) return NULL; /* INSTEAD OF ROW UPDATE Triggers */ if (resultRelInfo->ri_TrigDesc && resultRelInfo->ri_TrigDesc->trig_update_instead_row) { if (!ExecIRUpdateTriggers(estate, resultRelInfo, oldtuple, slot)) return NULL; /* "do nothing" */ } else if (resultRelInfo->ri_FdwRoutine) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("updating foreign tables not supported in hypertable context"))); } else { #if PG16_GE ItemPointerData lockedtid; #endif /* * If we generate a new candidate tuple after EvalPlanQual testing, we * must loop back here to try again. (We don't need to redo triggers, * however. If there are any BEFORE triggers then trigger.c will have * done table_tuple_lock to lock the correct tuple, so there's no need * to do them again.) */ redo_act: #if PG16_GE lockedtid = *tupleid; #endif result = ExecUpdateAct(context, resultRelInfo, tupleid, oldtuple, slot, canSetTag, &updateCxt); /* * If ExecUpdateAct reports that a cross-partition update was done, * then the RETURNING tuple (if any) has been projected and there's * nothing else for us to do. */ if (updateCxt.crossPartUpdate) return context->cpUpdateReturningSlot; switch (result) { case TM_SelfModified: /* * The target tuple was already updated or deleted by the * current command, or by a later command in the current * transaction. The former case is possible in a join UPDATE * where multiple tuples join to the same target tuple. This * is pretty questionable, but Postgres has always allowed it: * we just execute the first update action and ignore * additional update attempts. * * The latter case arises if the tuple is modified by a * command in a BEFORE trigger, or perhaps by a command in a * volatile function used in the query. In such situations we * should not ignore the update, but it is equally unsafe to * proceed. We don't want to discard the original UPDATE * while keeping the triggered actions based on it; and we * have no principled way to merge this update with the * previous ones. So throwing an error is the only safe * course. * * If a trigger actually intends this type of interaction, it * can re-execute the UPDATE (assuming it can figure out how) * and then return NULL to cancel the outer update. */ if (context->tmfd.cmax != estate->es_output_cid) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION), errmsg("tuple to be updated was already modified by an operation triggered by the current command"), errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows."))); /* Else, already updated by self; nothing to do */ return NULL; case TM_Ok: break; case TM_Updated: { TupleTableSlot *inputslot; TupleTableSlot *epqslot; TupleTableSlot *oldSlot; if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); /* * Already know that we're going to need to do EPQ, so * fetch tuple directly into the right slot. */ inputslot = EvalPlanQualSlot(context->epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex); result = table_tuple_lock(resultRelationDesc, tupleid, estate->es_snapshot, inputslot, estate->es_output_cid, updateCxt.lockmode, LockWaitBlock, TUPLE_LOCK_FLAG_FIND_LAST_VERSION, &context->tmfd); switch (result) { case TM_Ok: Assert(context->tmfd.traversed); epqslot = EvalPlanQual(context->epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex, inputslot); if (TupIsNull(epqslot)) /* Tuple not passing quals anymore, exiting... */ return NULL; /* Make sure ri_oldTupleSlot is initialized. */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid)) ExecInitUpdateProjection(context->mtstate, resultRelInfo); #if PG16_GE if (resultRelInfo->ri_needLockTagTuple) { UnlockTuple(resultRelationDesc, &lockedtid, InplaceUpdateTupleLock); LockTuple(resultRelationDesc, tupleid, InplaceUpdateTupleLock); } #endif /* Fetch the most recent version of old tuple. */ oldSlot = resultRelInfo->ri_oldTupleSlot; if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid, SnapshotAny, oldSlot)) elog(ERROR, "failed to fetch tuple being updated"); slot = ExecGetUpdateNewTuple(resultRelInfo, epqslot, oldSlot); goto redo_act; case TM_Deleted: /* tuple already deleted; nothing to do */ return NULL; case TM_SelfModified: /* * This can be reached when following an update * chain from a tuple updated by another session, * reaching a tuple that was already updated in * this transaction. If previously modified by * this command, ignore the redundant update, * otherwise error out. * * See also TM_SelfModified response to * table_tuple_update() above. */ if (context->tmfd.cmax != estate->es_output_cid) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION), errmsg("tuple to be updated was already modified by an operation triggered by the current command"), errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows."))); return NULL; default: /* see table_tuple_lock call in ExecDelete() */ elog(ERROR, "unexpected table_tuple_lock status: %u", result); return NULL; } } break; case TM_Deleted: if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent delete"))); /* tuple already deleted; nothing to do */ return NULL; default: elog(ERROR, "unrecognized table_tuple_update status: %u", result); return NULL; } } if (canSetTag) (estate->es_processed)++; ExecUpdateEpilogue(context, &updateCxt, resultRelInfo, tupleid, oldtuple, slot); if (context->ht_state->has_continuous_aggregate && !ts_guc_enable_cagg_wal_based_invalidation) { TupleTableSlot *invalidation_slot = NULL; bool should_free_old = false, should_free_new = false; if (!oldtuple) { invalidation_slot = table_slot_create(resultRelationDesc, NULL); table_tuple_fetch_row_version(resultRelationDesc, tupleid, SnapshotAny, invalidation_slot); oldtuple = ExecFetchSlotHeapTuple(invalidation_slot, false, &should_free_old); } HeapTuple newtuple = ExecFetchSlotHeapTuple(slot, false, &should_free_new); ts_cm_functions->continuous_agg_dml_invalidate(context->ht_state->ht->fd.id, resultRelInfo->ri_RelationDesc, oldtuple, newtuple, true); if (should_free_old) heap_freetuple(oldtuple); if (should_free_new) heap_freetuple(newtuple); if (invalidation_slot) ExecDropSingleTupleTableSlot(invalidation_slot); } /* Process RETURNING if present */ if (resultRelInfo->ri_projectReturning) return ExecProcessReturning(resultRelInfo, slot, context->planSlot); return NULL; } /* * ExecOnConflictUpdate --- execute UPDATE of INSERT ON CONFLICT DO UPDATE * * Try to lock tuple for update as part of speculative insertion. If * a qual originating from ON CONFLICT DO UPDATE is satisfied, update * (but still lock row, even though it may not satisfy estate's * snapshot). * * Returns true if we're done (with or without an update), or false if * the caller must retry the INSERT from scratch. */ static bool ExecOnConflictUpdate(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer conflictTid, TupleTableSlot *excludedSlot, bool canSetTag, TupleTableSlot **returning) { ModifyTableState *mtstate = context->mtstate; ExprContext *econtext = mtstate->ps.ps_ExprContext; Relation relation = resultRelInfo->ri_RelationDesc; ExprState *onConflictSetWhere = resultRelInfo->ri_onConflict->oc_WhereClause; TupleTableSlot *existing = resultRelInfo->ri_onConflict->oc_Existing; TM_FailureData tmfd; LockTupleMode lockmode; TM_Result test; Datum xminDatum; TransactionId xmin; bool isnull; /* * Parse analysis should have blocked ON CONFLICT for all system * relations, which includes these. There's no fundamental obstacle to * supporting this; we'd just need to handle LOCKTAG_TUPLE like the other * ExecUpdate() caller. */ #if PG16_GE Assert(!resultRelInfo->ri_needLockTagTuple); #endif /* Determine lock mode to use */ lockmode = ExecUpdateLockMode(context->estate, resultRelInfo); /* * Lock tuple for update. Don't follow updates when tuple cannot be * locked without doing so. A row locking conflict here means our * previous conclusion that the tuple is conclusively committed is not * true anymore. */ test = table_tuple_lock(relation, conflictTid, context->estate->es_snapshot, existing, context->estate->es_output_cid, lockmode, LockWaitBlock, 0, &tmfd); switch (test) { case TM_Ok: /* success! */ break; case TM_Invisible: /* * This can occur when a just inserted tuple is updated again in * the same command. E.g. because multiple rows with the same * conflicting key values are inserted. * * This is somewhat similar to the ExecUpdate() TM_SelfModified * case. We do not want to proceed because it would lead to the * same row being updated a second time in some unspecified order, * and in contrast to plain UPDATEs there's no historical behavior * to break. * * It is the user's responsibility to prevent this situation from * occurring. These problems are why the SQL standard similarly * specifies that for SQL MERGE, an exception must be raised in * the event of an attempt to update the same row twice. */ xminDatum = slot_getsysattr(existing, MinTransactionIdAttributeNumber, &isnull); Assert(!isnull); xmin = DatumGetTransactionId(xminDatum); if (TransactionIdIsCurrentTransactionId(xmin)) ereport(ERROR, (errcode(ERRCODE_CARDINALITY_VIOLATION), /* translator: %s is a SQL command name */ errmsg("%s command cannot affect row a second time", "ON CONFLICT DO UPDATE"), errhint("Ensure that no rows proposed for insertion within the same command have duplicate constrained values."))); /* This shouldn't happen */ elog(ERROR, "attempted to lock invisible tuple"); break; case TM_SelfModified: /* * This state should never be reached. As a dirty snapshot is used * to find conflicting tuples, speculative insertion wouldn't have * seen this row to conflict with. */ elog(ERROR, "unexpected self-updated tuple"); break; case TM_Updated: if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); /* * As long as we don't support an UPDATE of INSERT ON CONFLICT for * a partitioned table we shouldn't reach to a case where tuple to * be lock is moved to another partition due to concurrent update * of the partition key. */ Assert(!ItemPointerIndicatesMovedPartitions(&tmfd.ctid)); /* * Tell caller to try again from the very start. * * It does not make sense to use the usual EvalPlanQual() style * loop here, as the new version of the row might not conflict * anymore, or the conflicting tuple has actually been deleted. */ ExecClearTuple(existing); return false; case TM_Deleted: if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent delete"))); /* see TM_Updated case */ Assert(!ItemPointerIndicatesMovedPartitions(&tmfd.ctid)); ExecClearTuple(existing); return false; default: elog(ERROR, "unrecognized table_tuple_lock status: %u", test); } /* Success, the tuple is locked. */ /* * Verify that the tuple is visible to our MVCC snapshot if the current * isolation level mandates that. * * It's not sufficient to rely on the check within ExecUpdate() as e.g. * CONFLICT ... WHERE clause may prevent us from reaching that. * * This means we only ever continue when a new command in the current * transaction could see the row, even though in READ COMMITTED mode the * tuple will not be visible according to the current statement's * snapshot. This is in line with the way UPDATE deals with newer tuple * versions. */ ExecCheckTupleVisible(context->estate, relation, existing); /* * Make tuple and any needed join variables available to ExecQual and * ExecProject. The EXCLUDED tuple is installed in ecxt_innertuple, while * the target's existing tuple is installed in the scantuple. EXCLUDED * has been made to reference INNER_VAR in setrefs.c, but there is no * other redirection. */ econtext->ecxt_scantuple = existing; econtext->ecxt_innertuple = excludedSlot; econtext->ecxt_outertuple = NULL; if (!ExecQual(onConflictSetWhere, econtext)) { ExecClearTuple(existing); /* see return below */ InstrCountFiltered1(&mtstate->ps, 1); return true; /* done with the tuple */ } if (resultRelInfo->ri_WithCheckOptions != NIL) { /* * Check target's existing tuple against UPDATE-applicable USING * security barrier quals (if any), enforced here as RLS checks/WCOs. * * The rewriter creates UPDATE RLS checks/WCOs for UPDATE security * quals, and stores them as WCOs of "kind" WCO_RLS_CONFLICT_CHECK, * but that's almost the extent of its special handling for ON * CONFLICT DO UPDATE. * * The rewriter will also have associated UPDATE applicable straight * RLS checks/WCOs for the benefit of the ExecUpdate() call that * follows. INSERTs and UPDATEs naturally have mutually exclusive WCO * kinds, so there is no danger of spurious over-enforcement in the * INSERT or UPDATE path. */ ExecWithCheckOptions(WCO_RLS_CONFLICT_CHECK, resultRelInfo, existing, mtstate->ps.state); } /* Project the new tuple version */ ExecProject(resultRelInfo->ri_onConflict->oc_ProjInfo); /* * Note that it is possible that the target tuple has been modified in * this session, after the above table_tuple_lock. We choose to not error * out in that case, in line with ExecUpdate's treatment of similar cases. * This can happen if an UPDATE is triggered from within ExecQual(), * ExecWithCheckOptions() or ExecProject() above, e.g. by selecting from a * wCTE in the ON CONFLICT's SET. */ /* Execute UPDATE with projection */ *returning = ExecUpdate(context, resultRelInfo, conflictTid, NULL, resultRelInfo->ri_onConflict->oc_ProjSlot, canSetTag); /* * Clear out existing tuple, as there might not be another conflict among * the next input rows. Don't want to hold resources till the end of the * query. */ ExecClearTuple(existing); return true; } static void fireASTriggers(ModifyTableState *node); static void fireBSTriggers(ModifyTableState *node); /* ---------------------------------------------------------------- * ExecModifyTable * * Perform table modifications as required, and return RETURNING results * if needed. * ---------------------------------------------------------------- * * modified version of ExecModifyTable from executor/nodeModifyTable.c */ TupleTableSlot * ExecModifyTable(CustomScanState *cs_node, PlanState *pstate) { ModifyHypertableState *ht_state = (ModifyHypertableState *) cs_node; ModifyTableState *node = castNode(ModifyTableState, pstate); ModifyTableContext context; EState *estate = node->ps.state; CmdType operation = node->operation; ResultRelInfo *resultRelInfo; PlanState *subplanstate; TupleTableSlot *slot; TupleTableSlot *oldSlot; ItemPointer tupleid; ItemPointerData tuple_ctid; HeapTupleData oldtupdata; HeapTuple oldtuple; List *relinfos = NIL; ListCell *lc; ChunkTupleRouting *ctr = ht_state->ctr; CHECK_FOR_INTERRUPTS(); /* * This should NOT get called during EvalPlanQual; we should have passed a * subplan tree to EvalPlanQual, instead. Use a runtime test not just * Assert because this condition is easy to miss in testing. (Note: * although ModifyTable should not get executed within an EvalPlanQual * operation, we do have to allow it to be initialized and shut down in * case it is within a CTE subplan. Hence this test must be here, not in * ExecInitModifyTable.) */ if (estate->es_epq_active != NULL) elog(ERROR, "ModifyTable should not be called during EvalPlanQual"); /* * If we've already completed processing, don't try to do more. We need * this test because ExecPostprocessPlan might call us an extra time, and * our subplan's nodes aren't necessarily robust against being called * extra times. */ if (node->mt_done) return NULL; /* * On first call, fire BEFORE STATEMENT triggers before proceeding. */ if (node->fireBSTriggers) { fireBSTriggers(node); node->fireBSTriggers = false; } /* Preload local variables */ resultRelInfo = node->resultRelInfo + node->mt_lastResultIndex; subplanstate = outerPlanState(node); /* Set global context */ context.ht_state = ht_state; context.mtstate = node; context.epqstate = &node->mt_epqstate; context.estate = estate; /* * For UPDATE/DELETE on compressed hypertable, decompress chunks and * move rows to uncompressed chunks. */ if ((operation == CMD_DELETE || operation == CMD_UPDATE) && !ht_state->comp_chunks_processed) { /* Modify snapshot only if something got decompressed */ if (ts_cm_functions->decompress_target_segments && ts_cm_functions->decompress_target_segments(ht_state)) { ht_state->comp_chunks_processed = true; /* * save snapshot set during ExecutorStart(), since this is the same * snapshot used to SeqScan of uncompressed chunks */ ht_state->snapshot = estate->es_snapshot; CommandCounterIncrement(); /* use a static copy of current transaction snapshot * this needs to be a copy so we don't read trigger updates */ estate->es_snapshot = RegisterSnapshot(GetTransactionSnapshot()); /* mark rows visible */ estate->es_output_cid = GetCurrentCommandId(true); if (ts_guc_max_tuples_decompressed_per_dml > 0) { if (ht_state->tuples_decompressed > ts_guc_max_tuples_decompressed_per_dml) { ereport(ERROR, (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), errmsg("tuple decompression limit exceeded by operation"), errdetail("current limit: %d, tuples decompressed: %lld", ts_guc_max_tuples_decompressed_per_dml, (long long int) ht_state->tuples_decompressed), errhint("Consider increasing " "timescaledb.max_tuples_decompressed_per_dml_transaction or " "set to 0 (unlimited)."))); } } } /* Account for tuples deleted via batch DELETE in compressed chunks */ if (operation == CMD_DELETE && ht_state->tuples_deleted > 0) estate->es_processed += ht_state->tuples_deleted; } /* * Fetch rows from subplan, and execute the required table modification * for each row. */ for (;;) { Oid resultoid = InvalidOid; /* * Reset the per-output-tuple exprcontext. This is needed because * triggers expect to use that context as workspace. It's a bit ugly * to do this below the top level of the plan, however. We might need * to rethink this later. */ ResetPerTupleExprContext(estate); /* * Reset per-tuple memory context used for processing on conflict and * returning clauses, to free any expression evaluation storage * allocated in the previous cycle. */ if (pstate->ps_ExprContext) ResetExprContext(pstate->ps_ExprContext); #if PG17_GE /* * If there is a pending MERGE ... WHEN NOT MATCHED [BY TARGET] action * to execute, do so now --- see the comments in ExecMerge(). */ if (node->mt_merge_pending_not_matched != NULL) { context.planSlot = node->mt_merge_pending_not_matched; slot = ExecMergeNotMatched(&context, node->resultRelInfo, ctr, node->canSetTag); /* Clear the pending action */ node->mt_merge_pending_not_matched = NULL; /* * If we got a RETURNING result, return it to the caller. We'll * continue the work on next call. */ if (slot) return slot; continue; /* continue with the next tuple */ } #endif context.planSlot = ExecProcNode(subplanstate); /* No more tuples to process? */ if (TupIsNull(context.planSlot)) break; if (operation == CMD_INSERT || operation == CMD_MERGE) { TupleTableSlot *slot = context.planSlot; if (operation == CMD_MERGE) { /* * XXX do we need an additional support of NOT MATCHED BY SOURCE * for PG >= 17? See PostgreSQL commit 0294df2f1f84 */ #if PG17_GE List *actionStates = ctr->root_rri->ri_MergeActions[MERGE_WHEN_NOT_MATCHED_BY_TARGET]; #else List *actionStates = ctr->root_rri->ri_notMatchedMergeAction; #endif ListCell *l; foreach (l, actionStates) { MergeActionState *action = (MergeActionState *) lfirst(l); CmdType commandType = action->mas_action->commandType; if (commandType == CMD_INSERT) { action->mas_proj->pi_exprContext->ecxt_innertuple = slot; slot = ExecProject(action->mas_proj); break; } } } /* do tuple routing in short lived memory context */ MemoryContext oldctx = MemoryContextSwitchTo(estate->es_per_tuple_exprcontext->ecxt_per_tuple_memory); Point *point = ts_hyperspace_calculate_point(ctr->hypertable->space, slot); /* Find or create the insert state matching the point */ ctr->cis = ts_chunk_tuple_routing_find_chunk(ctr, point); bool update_counter = ctr->cis->onConflictAction == ONCONFLICT_UPDATE; ts_chunk_tuple_routing_decompress_for_insert(ctr->cis, slot, ctr->estate, update_counter); MemoryContextSwitchTo(oldctx); /* ON CONFLICT DO NOTHING optimization for columnstore */ if (operation == CMD_INSERT && ctr->cis->skip_current_tuple) { ctr->cis->skip_current_tuple = false; if (node->ps.instrument) node->ps.instrument->ntuples2++; continue; } /* direct compress */ if (operation == CMD_INSERT && ht_state->columnstore_insert) { ctr->cis->columnstore_insert = true; /* Flush on chunk change */ if (ht_state->compressor && ht_state->compressor_relid != RelationGetRelid(ctr->cis->rel)) { ts_cm_functions->compressor_flush(ht_state->compressor, ht_state->bulk_writer); ts_cm_functions->compressor_free(ht_state->compressor, ht_state->bulk_writer); ht_state->compressor = NULL; ht_state->compressor_relid = InvalidOid; } if (!ht_state->compressor) { bool sort = ts_guc_enable_direct_compress_insert_sort_batches && !ts_guc_enable_direct_compress_insert_client_sorted; ht_state->compressor = ts_cm_functions->compressor_init(ctr->cis->rel, &ht_state->bulk_writer, sort); ht_state->compressor_relid = RelationGetRelid(ctr->cis->rel); /* if client does not commit to global ordering, set chunk to unordered */ if (!ts_guc_enable_direct_compress_insert_client_sorted) { Chunk *chunk = ts_chunk_get_by_id(ctr->cis->chunk_id, true); if (!ts_chunk_is_unordered(chunk)) ts_chunk_set_unordered(chunk); } } ts_cm_functions->compressor_add_slot(ht_state->compressor, ht_state->bulk_writer, slot); estate->es_processed++; continue; } /* * copy INSERT merge action list to result relation info of corresponding chunk * * XXX do we need an additional support of NOT MATCHED BY SOURCE * for PG >= 17? See PostgreSQL commit 0294df2f1f84 */ if (operation == CMD_MERGE) #if PG17_GE ctr->cis->result_relation_info->ri_MergeActions[MERGE_WHEN_NOT_MATCHED_BY_TARGET] = resultRelInfo->ri_MergeActions[MERGE_WHEN_NOT_MATCHED_BY_TARGET]; #else ctr->cis->result_relation_info->ri_notMatchedMergeAction = resultRelInfo->ri_notMatchedMergeAction; #endif } /* * When there are multiple result relations, each tuple contains a * junk column that gives the OID of the rel from which it came. * Extract it and select the correct result relation. */ if (AttributeNumberIsValid(node->mt_resultOidAttno)) { Datum datum; bool isNull; datum = ExecGetJunkAttribute(context.planSlot, node->mt_resultOidAttno, &isNull); if (isNull) { if (operation == CMD_MERGE) { EvalPlanQualSetSlot(&node->mt_epqstate, context.planSlot); slot = ExecMerge(&context, node->resultRelInfo, ctr, NULL, NULL, node->canSetTag); if (slot) return slot; continue; } elog(ERROR, "tableoid is NULL"); } resultoid = DatumGetObjectId(datum); /* If it's not the same as last time, we need to locate the rel */ if (resultoid != node->mt_lastResultOid) resultRelInfo = ExecLookupResultRelByOid(node, resultoid, false, true); } /* * If resultRelInfo->ri_usesFdwDirectModify is true, all we need to do * here is compute the RETURNING expressions. */ if (resultRelInfo->ri_usesFdwDirectModify) { Assert(resultRelInfo->ri_projectReturning); /* * A scan slot containing the data that was actually inserted, * updated or deleted has already been made available to * ExecProcessReturning by IterateDirectModify, so no need to * provide it here. */ slot = ExecProcessReturning(resultRelInfo, NULL, context.planSlot); return slot; } EvalPlanQualSetSlot(&node->mt_epqstate, context.planSlot); slot = context.planSlot; tupleid = NULL; oldtuple = NULL; /* * For UPDATE/DELETE, fetch the row identity info for the tuple to be * updated/deleted. For a heap relation, that's a TID; otherwise we * may have a wholerow junk attr that carries the old tuple in toto. * Keep this in step with the part of ExecInitModifyTable that sets up * ri_RowIdAttNo. */ if (operation == CMD_UPDATE || operation == CMD_DELETE || operation == CMD_MERGE) { char relkind; Datum datum; bool isNull; relkind = resultRelInfo->ri_RelationDesc->rd_rel->relkind; /* Since this is a hypertable relkind should be RELKIND_RELATION for a local * chunk or RELKIND_FOREIGN_TABLE for a chunk that is a foreign table * (OSM chunks) */ Assert(relkind == RELKIND_RELATION || relkind == RELKIND_FOREIGN_TABLE); if (relkind == RELKIND_RELATION || relkind == RELKIND_MATVIEW || relkind == RELKIND_PARTITIONED_TABLE) { /* ri_RowIdAttNo refers to a ctid attribute */ Assert(AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo)); datum = ExecGetJunkAttribute(slot, resultRelInfo->ri_RowIdAttNo, &isNull); /* * For commands other than MERGE, any tuples having a null row * identifier are errors. For MERGE, we may need to handle * them as WHEN NOT MATCHED clauses if any, so do that. * * Note that we use the node's toplevel resultRelInfo, not any * specific partition's. */ if (isNull) { if (operation == CMD_MERGE) { EvalPlanQualSetSlot(&node->mt_epqstate, context.planSlot); slot = ExecMerge(&context, node->resultRelInfo, ctr, NULL, NULL, node->canSetTag); if (slot) return slot; continue; } elog(ERROR, "ctid is NULL"); } tupleid = (ItemPointer) DatumGetPointer(datum); tuple_ctid = *tupleid; /* be sure we don't free ctid!! */ tupleid = &tuple_ctid; } /* * Use the wholerow attribute, when available, to reconstruct the * old relation tuple. The old tuple serves one or both of two * purposes: 1) it serves as the OLD tuple for row triggers, 2) it * provides values for any unchanged columns for the NEW tuple of * an UPDATE, because the subplan does not produce all the columns * of the target table. * * Note that the wholerow attribute does not carry system columns, * so foreign table triggers miss seeing those, except that we * know enough here to set t_tableOid. Quite separately from * this, the FDW may fetch its own junk attrs to identify the row. * * Other relevant relkinds, currently limited to views, always * have a wholerow attribute. */ else if (AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo)) { datum = ExecGetJunkAttribute(slot, resultRelInfo->ri_RowIdAttNo, &isNull); #if PG17_GE if (isNull) { if (operation == CMD_MERGE) { EvalPlanQualSetSlot(&node->mt_epqstate, context.planSlot); slot = ExecMerge(&context, node->resultRelInfo, ctr, NULL, NULL, node->canSetTag); if (slot) return slot; continue; } elog(ERROR, "wholerow is NULL"); } #else /* shouldn't ever get a null result... */ if (isNull) elog(ERROR, "wholerow is NULL"); #endif oldtupdata.t_data = DatumGetHeapTupleHeader(datum); oldtupdata.t_len = HeapTupleHeaderGetDatumLength(oldtupdata.t_data); ItemPointerSetInvalid(&(oldtupdata.t_self)); /* Historically, view triggers see invalid t_tableOid. */ oldtupdata.t_tableOid = (relkind == RELKIND_VIEW) ? InvalidOid : RelationGetRelid(resultRelInfo->ri_RelationDesc); oldtuple = &oldtupdata; } else { /* Only foreign tables are allowed to omit a row-ID attr */ Assert(relkind == RELKIND_FOREIGN_TABLE); } } switch (operation) { case CMD_INSERT: /* Initialize projection info if first time for this table */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid)) ExecInitInsertProjection(node, resultRelInfo); slot = ExecGetInsertNewTuple(resultRelInfo, context.planSlot); slot = ExecInsert(&context, resultRelInfo, ctr, slot, node->canSetTag); break; case CMD_UPDATE: /* Initialize projection info if first time for this table */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid)) ExecInitUpdateProjection(node, resultRelInfo); /* * Make the new tuple by combining plan's output tuple with * the old tuple being updated. */ oldSlot = resultRelInfo->ri_oldTupleSlot; if (oldtuple != NULL) { /* Use the wholerow junk attr as the old tuple. */ ExecForceStoreHeapTuple(oldtuple, oldSlot, false); } else { /* Fetch the most recent version of old tuple. */ Relation relation = resultRelInfo->ri_RelationDesc; Assert(tupleid != NULL); if (!table_tuple_fetch_row_version(relation, tupleid, SnapshotAny, oldSlot)) elog(ERROR, "failed to fetch tuple being updated"); } slot = ExecGetUpdateNewTuple(resultRelInfo, context.planSlot, oldSlot); context.relaction = NULL; /* Now apply the update. */ slot = ExecUpdate(&context, resultRelInfo, tupleid, oldtuple, slot, node->canSetTag); break; case CMD_DELETE: slot = ExecDelete(&context, resultRelInfo, tupleid, oldtuple, true, false, node->canSetTag, NULL, NULL, NULL); break; case CMD_MERGE: slot = ExecMerge(&context, resultRelInfo, ctr, tupleid, oldtuple, node->canSetTag); break; default: elog(ERROR, "unknown operation"); break; } /* * If we got a RETURNING result, return it to caller. We'll continue * the work on next call. */ if (slot) return slot; } /* * Insert remaining tuples for batch insert. */ relinfos = estate->es_opened_result_relations; if (ht_state->comp_chunks_processed) { UnregisterSnapshot(estate->es_snapshot); estate->es_snapshot = ht_state->snapshot; ht_state->comp_chunks_processed = false; } foreach (lc, relinfos) { resultRelInfo = lfirst(lc); if (resultRelInfo->ri_NumSlots > 0) ExecBatchInsert(node, resultRelInfo, resultRelInfo->ri_Slots, resultRelInfo->ri_PlanSlots, resultRelInfo->ri_NumSlots, estate, node->canSetTag); } /* * We're done, but fire AFTER STATEMENT triggers before exiting. */ fireASTriggers(node); node->mt_done = true; return NULL; } /* * Process BEFORE EACH STATEMENT triggers * * copied verbatim from executor/nodeModifyTable.c */ static void fireBSTriggers(ModifyTableState *node) { ModifyTable *plan = (ModifyTable *) node->ps.plan; ResultRelInfo *resultRelInfo = node->rootResultRelInfo; switch (node->operation) { case CMD_INSERT: ExecBSInsertTriggers(node->ps.state, resultRelInfo); if (plan->onConflictAction == ONCONFLICT_UPDATE) ExecBSUpdateTriggers(node->ps.state, resultRelInfo); break; case CMD_UPDATE: ExecBSUpdateTriggers(node->ps.state, resultRelInfo); break; case CMD_DELETE: ExecBSDeleteTriggers(node->ps.state, resultRelInfo); break; case CMD_MERGE: if (node->mt_merge_subcommands & MERGE_INSERT) ExecBSInsertTriggers(node->ps.state, resultRelInfo); if (node->mt_merge_subcommands & MERGE_UPDATE) ExecBSUpdateTriggers(node->ps.state, resultRelInfo); if (node->mt_merge_subcommands & MERGE_DELETE) ExecBSDeleteTriggers(node->ps.state, resultRelInfo); break; default: elog(ERROR, "unknown operation"); break; } } /* * Process AFTER EACH STATEMENT triggers * * copied verbatim from executor/nodeModifyTable.c */ static void fireASTriggers(ModifyTableState *node) { ModifyTable *plan = (ModifyTable *) node->ps.plan; ResultRelInfo *resultRelInfo = node->rootResultRelInfo; switch (node->operation) { case CMD_INSERT: if (plan->onConflictAction == ONCONFLICT_UPDATE) ExecASUpdateTriggers(node->ps.state, resultRelInfo, node->mt_oc_transition_capture); ExecASInsertTriggers(node->ps.state, resultRelInfo, node->mt_transition_capture); break; case CMD_UPDATE: ExecASUpdateTriggers(node->ps.state, resultRelInfo, node->mt_transition_capture); break; case CMD_DELETE: ExecASDeleteTriggers(node->ps.state, resultRelInfo, node->mt_transition_capture); break; case CMD_MERGE: if (node->mt_merge_subcommands & MERGE_INSERT) ExecASInsertTriggers(node->ps.state, resultRelInfo, node->mt_transition_capture); if (node->mt_merge_subcommands & MERGE_UPDATE) ExecASUpdateTriggers(node->ps.state, resultRelInfo, node->mt_transition_capture); if (node->mt_merge_subcommands & MERGE_DELETE) ExecASDeleteTriggers(node->ps.state, resultRelInfo, node->mt_transition_capture); break; default: elog(ERROR, "unknown operation"); break; } } /* * Check and execute the first qualifying MATCHED action. The current target * tuple is identified by tupleid. * * We start from the first WHEN MATCHED action and check if the WHEN quals * pass, if any. If the WHEN quals for the first action do not pass, we check * the second, then the third and so on. If we reach to the end, no action is * taken and we return true, indicating that no further action is required * for this tuple. * * If we do find a qualifying action, then we attempt to execute the action. * * If the tuple is concurrently updated, EvalPlanQual is run with the updated * tuple to recheck the join quals. Note that the additional quals associated * with individual actions are evaluated by this routine via ExecQual, while * EvalPlanQual checks for the join quals. If EvalPlanQual tells us that the * updated tuple still passes the join quals, then we restart from the first * action to look for a qualifying action. Otherwise, we return false -- * meaning that a NOT MATCHED action must now be executed for the current * source tuple. */ TupleTableSlot * ExecMergeMatched(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ItemPointer tupleid, HeapTuple oldtuple, bool canSetTag, bool *matched) { ModifyTableState *mtstate = context->mtstate; TupleTableSlot *newslot = NULL; EState *estate = context->estate; ExprContext *econtext = mtstate->ps.ps_ExprContext; bool isNull; EPQState *epqstate = &mtstate->mt_epqstate; ListCell *l; TupleTableSlot *rslot = NULL; Assert(*matched == true); /* * If there are no WHEN MATCHED actions, we are done. */ #if PG17_GE if (resultRelInfo->ri_MergeActions[MERGE_WHEN_MATCHED] == NIL) return NULL; #else if (resultRelInfo->ri_matchedMergeAction == NIL) { *matched = true; return NULL; } #endif /* * Make tuple and any needed join variables available to ExecQual and * ExecProject. The target's existing tuple is installed in the * scantuple. Again, this target relation's slot is required only in * the case of a MATCHED tuple and UPDATE/DELETE actions. */ econtext->ecxt_scantuple = resultRelInfo->ri_oldTupleSlot; econtext->ecxt_innertuple = context->planSlot; econtext->ecxt_outertuple = NULL; lmerge_matched:; /* * This routine is only invoked for matched rows, and we must have * found the tupleid of the target row in that case; fetch that * tuple. * * We use SnapshotAny for this because we might get called again * after EvalPlanQual returns us a new tuple, which may not be * visible to our MVCC snapshot. */ #if PG17_GE if (oldtuple != NULL) ExecForceStoreHeapTuple(oldtuple, resultRelInfo->ri_oldTupleSlot, false); else #endif if (!table_tuple_fetch_row_version(resultRelInfo->ri_RelationDesc, tupleid, SnapshotAny, resultRelInfo->ri_oldTupleSlot)) elog(ERROR, "failed to fetch the target tuple"); #if PG17_GE foreach (l, resultRelInfo->ri_MergeActions[MERGE_WHEN_MATCHED]) { #else foreach (l, resultRelInfo->ri_matchedMergeAction) { #endif MergeActionState *relaction = (MergeActionState *) lfirst(l); CmdType commandType = relaction->mas_action->commandType; TM_Result result; UpdateContext updateCxt = { 0 }; /* * Test condition, if any. * * In the absence of any condition, we perform the action * unconditionally (no need to check separately since * ExecQual() will return true if there are no conditions to * evaluate). */ if (!ExecQual(relaction->mas_whenqual, econtext)) continue; /* * Check if the existing target tuple meets the USING checks * of UPDATE/DELETE RLS policies. If those checks fail, we * throw an error. * * The WITH CHECK quals are applied in ExecUpdate() and hence * we need not do anything special to handle them. * * NOTE: We must do this after WHEN quals are evaluated, so * that we check policies only when they matter. */ if (resultRelInfo->ri_WithCheckOptions) { ExecWithCheckOptions(commandType == CMD_UPDATE ? WCO_RLS_MERGE_UPDATE_CHECK : WCO_RLS_MERGE_DELETE_CHECK, resultRelInfo, resultRelInfo->ri_oldTupleSlot, context->mtstate->ps.state); } /* Perform stated action */ switch (commandType) { case CMD_UPDATE: /* * Project the output tuple, and use that to update * the table. We don't need to filter out junk * attributes, because the UPDATE action's targetlist * doesn't have any. */ newslot = ExecProject(relaction->mas_proj); #if PG17_GE mtstate->mt_merge_action = relaction; #else context->relaction = relaction; #endif context->cpUpdateRetrySlot = NULL; if (!ExecUpdatePrologue(context, resultRelInfo, tupleid, NULL, newslot, &result)) { #if PG16_LT result = TM_Ok; #else if (result == TM_Ok) return NULL; #endif /* if not TM_OK, it is concurrent update/delete */ break; } ExecUpdatePrepareSlot(resultRelInfo, newslot, context->estate); result = ExecUpdateAct(context, resultRelInfo, tupleid, NULL, newslot, mtstate->canSetTag, &updateCxt); if (result == TM_Ok) { ExecUpdateEpilogue(context, &updateCxt, resultRelInfo, tupleid, NULL, newslot); mtstate->mt_merge_updated += 1; } break; case CMD_DELETE: #if PG17_GE mtstate->mt_merge_action = relaction; #else context->relaction = relaction; #endif if (!ExecDeletePrologue(context, resultRelInfo, tupleid, NULL, NULL, &result)) { #if PG16_LT result = TM_Ok; #else if (result == TM_Ok) return NULL; /* "do nothing" */ /* if not TM_OK, it is concurrent update/delete */ #endif break; } result = ExecDeleteAct(context, resultRelInfo, tupleid, false); if (result == TM_Ok) { ExecDeleteEpilogue(context, resultRelInfo, tupleid, NULL, false); mtstate->mt_merge_deleted = 1; } break; case CMD_NOTHING: /* Doing nothing is always OK */ result = TM_Ok; break; default: elog(ERROR, "unknown action in MERGE WHEN MATCHED clause"); } switch (result) { case TM_Ok: /* all good; perform final actions */ if (canSetTag) (estate->es_processed)++; break; case TM_SelfModified: if (context->tmfd.cmax != estate->es_output_cid) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION), errmsg("tuple to be updated or deleted was already modified by an " "operation triggered by the current command"), errhint("Consider using an AFTER trigger instead of a BEFORE trigger " "to propagate changes to other rows."))); if (TransactionIdIsCurrentTransactionId(context->tmfd.xmax)) ereport(ERROR, (errcode(ERRCODE_CARDINALITY_VIOLATION), /* translator: %s is a SQL command name */ errmsg("%s command cannot affect row a second time", "MERGE"), errhint("Ensure that not more than one source row matches any one " "target row."))); /* This shouldn't happen */ elog(ERROR, "attempted to update or delete invisible tuple"); break; case TM_Deleted: if (IsolationUsesXactSnapshot()) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent delete"))); /* * If the tuple was already deleted, return to let * caller handle it under NOT MATCHED clauses. */ *matched = false; return NULL; case TM_Updated: { Relation resultRelationDesc; TupleTableSlot *epqslot, *inputslot; LockTupleMode lockmode; /* * The target tuple was concurrently updated * by some other transaction. */ /* * If cpUpdateRetrySlot is set, * ExecCrossPartitionUpdate() must have * detected that the tuple was concurrently * updated, so we restart the search for an * appropriate WHEN MATCHED clause to process * the updated tuple. * * In this case, ExecDelete() would already * have performed EvalPlanQual() on the * latest version of the tuple, which in turn * would already have been loaded into * ri_oldTupleSlot, so no need to do either * of those things. * * XXX why do we not check the WHEN NOT * MATCHED list in this case? */ if (!TupIsNull(context->cpUpdateRetrySlot)) goto lmerge_matched; /* * Otherwise, we run the EvalPlanQual() with * the new version of the tuple. If * EvalPlanQual() does not return a tuple, * then we switch to the NOT MATCHED list of * actions. If it does return a tuple and the * join qual is still satisfied, then we just * need to recheck the MATCHED actions, * starting from the top, and execute the * first qualifying action. */ resultRelationDesc = resultRelInfo->ri_RelationDesc; lockmode = ExecUpdateLockMode(estate, resultRelInfo); inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex); result = table_tuple_lock(resultRelationDesc, tupleid, estate->es_snapshot, inputslot, estate->es_output_cid, lockmode, LockWaitBlock, TUPLE_LOCK_FLAG_FIND_LAST_VERSION, &context->tmfd); switch (result) { case TM_Ok: // TODO: update this to match PG17 epqslot = EvalPlanQual(epqstate, resultRelationDesc, resultRelInfo->ri_RangeTableIndex, inputslot); /* * If we got no tuple, or the tuple * we get has a NULL ctid, go back to * caller: this one is not a MATCHED * tuple anymore, so they can retry * with NOT MATCHED actions. */ if (TupIsNull(epqslot)) return false; (void) ExecGetJunkAttribute(epqslot, resultRelInfo->ri_RowIdAttNo, &isNull); if (isNull) return false; /* * When a tuple was updated and * migrated to another partition * concurrently, the current MERGE * implementation can't follow. * There's probably a better way to * handle this case, but it'd require * recognizing the relation to which * the tuple moved, and setting our * current resultRelInfo to that. */ if (ItemPointerIndicatesMovedPartitions(&context->tmfd.ctid)) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("tuple to be deleted was already moved to another " "partition due to concurrent update"))); /* * A non-NULL ctid means that we are * still dealing with MATCHED case. * Restart the loop so that we apply * all the MATCHED rules again, to * ensure that the first qualifying * WHEN MATCHED action is executed. * * Update tupleid to that of the new * tuple, for the refetch we do at * the top. */ Ensure(tupleid != NULL, "matched tupleid during merge cannot be null"); ItemPointerCopy(&context->tmfd.ctid, tupleid); goto lmerge_matched; case TM_Deleted: /* * tuple already deleted; tell caller * to run NOT MATCHED actions */ *matched = false; return NULL; case TM_SelfModified: /* * This can be reached when following * an update chain from a tuple * updated by another session, * reaching a tuple that was already * updated in this transaction. If * previously modified by this * command, ignore the redundant * update, otherwise error out. * * See also response to * TM_SelfModified in * ht_ExecUpdate(). */ if (context->tmfd.cmax != estate->es_output_cid) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION), errmsg("tuple to be updated or deleted was already modified " "by an operation triggered by the current command"), errhint("Consider using an AFTER trigger instead of a BEFORE " "trigger to propagate changes to other rows."))); if (TransactionIdIsCurrentTransactionId(context->tmfd.xmax)) ereport(ERROR, (errcode(ERRCODE_CARDINALITY_VIOLATION), /* translator: %s is a SQL command name */ errmsg("%s command cannot affect row a second time", "MERGE"), errhint("Ensure that not more than one source row matches any " "one target row."))); /* This shouldn't happen */ elog(ERROR, "attempted to update or delete invisible tuple"); return NULL; default: /* * see table_tuple_lock call in * ht_ExecDelete() */ elog(ERROR, "unexpected table_tuple_lock status: %u", result); return NULL; } } case TM_Invisible: case TM_WouldBlock: case TM_BeingModified: /* these should not occur */ elog(ERROR, "unexpected tuple operation result: %d", result); break; } #if PG17_GE /* Process RETURNING if present */ if (resultRelInfo->ri_projectReturning) { switch (commandType) { case CMD_UPDATE: /* Variable newslot should be set for CMD_UPDATE above */ Assert(newslot != NULL); rslot = ExecProcessReturning(resultRelInfo, newslot, context->planSlot); break; case CMD_DELETE: rslot = ExecProcessReturning(resultRelInfo, resultRelInfo->ri_oldTupleSlot, context->planSlot); break; case CMD_NOTHING: break; default: elog(ERROR, "unrecognized commandType: %d", (int) commandType); } } #endif /* * We've activated one of the WHEN clauses, so we don't * search further. This is required behaviour, not an * optimization. */ break; } /* * Successfully executed an action or no qualifying action was found. */ return rslot; } /* * Execute the first qualifying NOT MATCHED action. */ static TupleTableSlot * ExecMergeNotMatched(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ChunkTupleRouting *ctr, bool canSetTag) { ModifyTableState *mtstate = context->mtstate; ExprContext *econtext = mtstate->ps.ps_ExprContext; List *actionStates = NIL; ListCell *l; TupleTableSlot *rslot = NULL; /* * For INSERT actions, the root relation's merge action is OK since * the INSERT's targetlist and the WHEN conditions can only refer to * the source relation and hence it does not matter which result * relation we work with. * * XXX does this mean that we can avoid creating copies of * actionStates on partitioned tables, for not-matched actions? * * XXX do we need an additional support of NOT MATCHED BY SOURCE * for PG >= 17? See PostgreSQL commit 0294df2f1f84 */ #if PG17_GE actionStates = ctr->cis->result_relation_info->ri_MergeActions[MERGE_WHEN_NOT_MATCHED_BY_TARGET]; #else actionStates = ctr->cis->result_relation_info->ri_notMatchedMergeAction; #endif /* * Make source tuple available to ExecQual and ExecProject. We don't * need the target tuple, since the WHEN quals and targetlist can't * refer to the target columns. */ econtext->ecxt_scantuple = NULL; econtext->ecxt_innertuple = context->planSlot; econtext->ecxt_outertuple = NULL; foreach (l, actionStates) { MergeActionState *action = (MergeActionState *) lfirst(l); CmdType commandType = action->mas_action->commandType; TupleTableSlot *newslot; /* * Test condition, if any. * * In the absence of any condition, we perform the action * unconditionally (no need to check separately since * ExecQual() will return true if there are no conditions to * evaluate). */ if (!ExecQual(action->mas_whenqual, econtext)) continue; /* Perform stated action */ switch (commandType) { case CMD_INSERT: /* * Project the tuple. In case of a partitioned * table, the projection was already built to use the * root's descriptor, so we don't need to map the * tuple here. */ newslot = ExecProject(action->mas_proj); #if PG17_GE mtstate->mt_merge_action = action; #else context->relaction = action; #endif if (ctr->has_dropped_attrs) { AttrMap *map; TupleDesc parenttupdesc, chunktupdesc; TupleTableSlot *chunk_slot = NULL; parenttupdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc); chunktupdesc = RelationGetDescr(ctr->cis->result_relation_info->ri_RelationDesc); /* map from parent to chunk */ #if PG16_LT map = build_attrmap_by_name_if_req(parenttupdesc, chunktupdesc); #else map = build_attrmap_by_name_if_req(parenttupdesc, chunktupdesc, false); #endif if (map != NULL) chunk_slot = execute_attr_map_slot(map, newslot, MakeSingleTupleTableSlot(chunktupdesc, &TTSOpsVirtual)); rslot = ExecInsert(context, resultRelInfo, ctr, (chunk_slot ? chunk_slot : newslot), canSetTag); if (chunk_slot) ExecDropSingleTupleTableSlot(chunk_slot); } else rslot = ExecInsert(context, resultRelInfo, ctr, newslot, canSetTag); mtstate->mt_merge_inserted = 1; break; case CMD_NOTHING: /* Do nothing */ break; default: elog(ERROR, "unknown action in MERGE WHEN NOT MATCHED clause"); } /* * We've activated one of the WHEN clauses, so we don't * search further. This is required behaviour, not an * optimization. */ break; } return rslot; } /* * Perform MERGE. */ TupleTableSlot * ExecMerge(ModifyTableContext *context, ResultRelInfo *resultRelInfo, ChunkTupleRouting *ctr, ItemPointer tupleid, HeapTuple oldtuple, bool canSetTag) { bool matched; TupleTableSlot *rslot = NULL; /*----- * If we are dealing with a WHEN MATCHED case (tupleid is valid), we * execute the first action for which the additional WHEN MATCHED AND * quals pass. If an action without quals is found, that action is * executed. * * Similarly, if we are dealing with WHEN NOT MATCHED case, we look at * the given WHEN NOT MATCHED actions in sequence until one passes. * * Things get interesting in case of concurrent update/delete of the * target tuple. Such concurrent update/delete is detected while we are * executing a WHEN MATCHED action. * * A concurrent update can: * * 1. modify the target tuple so that it no longer satisfies the * additional quals attached to the current WHEN MATCHED action * * In this case, we are still dealing with a WHEN MATCHED case. * We recheck the list of WHEN MATCHED actions from the start and * choose the first one that satisfies the new target tuple. * * 2. modify the target tuple so that the join quals no longer pass and * hence the source tuple no longer has a match. * * In this case, the source tuple no longer matches the target tuple, * so we now instead find a qualifying WHEN NOT MATCHED action to * execute. * * XXX Hmmm, what if the updated tuple would now match one that was * considered NOT MATCHED so far? * * A concurrent delete changes a WHEN MATCHED case to WHEN NOT MATCHED. * * ExecMergeMatched takes care of following the update chain and * re-finding the qualifying WHEN MATCHED action, as long as the updated * target tuple still satisfies the join quals, i.e., it remains a WHEN * MATCHED case. If the tuple gets deleted or the join quals fail, it * returns and we try ExecMergeNotMatched. Given that ExecMergeMatched * always make progress by following the update chain and we never switch * from ExecMergeNotMatched to ExecMergeMatched, there is no risk of a * livelock. */ #if PG17_GE matched = tupleid != NULL || oldtuple != NULL; #else matched = tupleid != NULL; #endif if (matched) rslot = ExecMergeMatched(context, resultRelInfo, tupleid, oldtuple, canSetTag, &matched); /* * Either we were dealing with a NOT MATCHED tuple or * ExecMergeMatched() returned "false", indicating the previously * MATCHED tuple no longer matches. */ if (!matched) { #if PG17_GE if (rslot == NULL) rslot = ExecMergeNotMatched(context, resultRelInfo, ctr, canSetTag); else context->mtstate->mt_merge_pending_not_matched = context->planSlot; #else (void) ExecMergeNotMatched(context, resultRelInfo, ctr, canSetTag); #endif } return rslot; } ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/nodes/vector_agg.h�����������������������������������������������������������0000664�0000000�0000000�00000000651�15100345067�0020245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once /* * This file defines the node name of Vector Aggregation custom node, to be * used in the Apache part of the Timescale extension. The node itself is in the * the TSL part. */ #define VECTOR_AGG_NODE_NAME "VectorAgg" ���������������������������������������������������������������������������������������timescaledb-2.23.0/src/osm_callbacks.c��������������������������������������������������������������0000664�0000000�0000000�00000003246�15100345067�0017610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include "osm_callbacks.h" #include <fmgr.h> #define OSM_CALLBACKS "osm_callbacks" #define OSM_CALLBACKS_VAR_NAME "osm_callbacks_versioned" static OsmCallbacks_Versioned * ts_get_osm_callbacks(void) { OsmCallbacks_Versioned **ptr = (OsmCallbacks_Versioned **) find_rendezvous_variable(OSM_CALLBACKS_VAR_NAME); return *ptr; } /* This interface and version of the struct will be removed once we have a new version of OSM on all * instances */ static OsmCallbacks * ts_get_osm_callbacks_old(void) { OsmCallbacks **ptr = (OsmCallbacks **) find_rendezvous_variable(OSM_CALLBACKS); return *ptr; } chunk_insert_check_hook_type ts_get_osm_chunk_insert_hook() { OsmCallbacks_Versioned *ptr = ts_get_osm_callbacks(); if (ptr) { if (ptr->version_num == 1) return ptr->chunk_insert_check_hook; } else { OsmCallbacks *ptr_old = ts_get_osm_callbacks_old(); if (ptr_old) return ptr_old->chunk_insert_check_hook; } return NULL; } hypertable_drop_hook_type ts_get_osm_hypertable_drop_hook() { OsmCallbacks_Versioned *ptr = ts_get_osm_callbacks(); if (ptr) { if (ptr->version_num == 1) return ptr->hypertable_drop_hook; } else { OsmCallbacks *ptr_old = ts_get_osm_callbacks_old(); if (ptr_old) return ptr_old->hypertable_drop_hook; } return NULL; } hypertable_drop_chunks_hook_type ts_get_osm_hypertable_drop_chunks_hook() { OsmCallbacks_Versioned *ptr = ts_get_osm_callbacks(); if (ptr && ptr->version_num == 1) return ptr->hypertable_drop_chunks_hook; return NULL; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/osm_callbacks.h��������������������������������������������������������������0000664�0000000�0000000�00000003131�15100345067�0017606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <catalog/objectaddress.h> /* range_start and range_end are in PG internal timestamp format. */ typedef int (*chunk_insert_check_hook_type)(Oid ht_oid, int64 range_start, int64 range_end); typedef void (*hypertable_drop_hook_type)(const char *schema_name, const char *table_name); typedef List *(*hypertable_drop_chunks_hook_type)(Oid osm_chunk_oid, const char *hypertable_schema_name, const char *hypertable_name, int64 range_start, int64 range_end); /* * Object Storage Manager callbacks. * * chunk_insert_check_hook - checks whether the specified range is managed by OSM * hypertable_drop_hook - used for OSM catalog cleanups */ /* This struct is retained for backward compatibility. We'll remove this in one * of the upcoming releases */ typedef struct { chunk_insert_check_hook_type chunk_insert_check_hook; hypertable_drop_hook_type hypertable_drop_hook; } OsmCallbacks; typedef struct { int64 version_num; chunk_insert_check_hook_type chunk_insert_check_hook; hypertable_drop_hook_type hypertable_drop_hook; hypertable_drop_chunks_hook_type hypertable_drop_chunks_hook; } OsmCallbacks_Versioned; extern chunk_insert_check_hook_type ts_get_osm_chunk_insert_hook(void); extern hypertable_drop_hook_type ts_get_osm_hypertable_drop_hook(void); extern hypertable_drop_chunks_hook_type ts_get_osm_hypertable_drop_chunks_hook(void); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/partitioning.c���������������������������������������������������������������0000664�0000000�0000000�00000033061�15100345067�0017520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/hash.h> #include <access/htup_details.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/pg_list.h> #include <parser/parse_coerce.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/cash.h> #include <utils/catcache.h> #include <utils/date.h> #include <utils/inet.h> #include <utils/jsonb.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/numeric.h> #include <utils/rangetypes.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "partitioning.h" #include "ts_catalog/catalog.h" #include "utils.h" #define IS_VALID_CLOSED_PARTITIONING_FUNC(proform, argtype) \ ((proform)->prorettype == INT4OID && ((proform)->provolatile == PROVOLATILE_IMMUTABLE) && \ (proform)->pronargs == 1 && \ ((proform)->proargtypes.values[0] == (argtype) || \ (proform)->proargtypes.values[0] == ANYELEMENTOID)) #define IS_VALID_OPEN_PARTITIONING_FUNC(proform, argtype) \ (IS_VALID_OPEN_DIM_TYPE((proform)->prorettype) && \ ((proform)->provolatile == PROVOLATILE_IMMUTABLE) && (proform)->pronargs == 1 && \ ((proform)->proargtypes.values[0] == (argtype) || \ (proform)->proargtypes.values[0] == ANYELEMENTOID)) #define IS_VALID_PARTITIONING_FUNC(proform, dimtype, argtype) \ (((dimtype) == DIMENSION_TYPE_OPEN) ? IS_VALID_OPEN_PARTITIONING_FUNC(proform, argtype) : \ IS_VALID_CLOSED_PARTITIONING_FUNC(proform, argtype)) static bool closed_dim_partitioning_func_filter(Form_pg_proc form, void *arg) { Oid *argtype = arg; return IS_VALID_CLOSED_PARTITIONING_FUNC(form, *argtype); } static bool open_dim_partitioning_func_filter(Form_pg_proc form, void *arg) { Oid *argtype = arg; return IS_VALID_OPEN_PARTITIONING_FUNC(form, *argtype); } bool ts_partitioning_func_is_valid(regproc funcoid, DimensionType dimtype, Oid argtype) { HeapTuple tuple; bool isvalid; AclResult aclresult; tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcoid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for function %u", funcoid); aclresult = object_aclcheck(ProcedureRelationId, funcoid, GetUserId(), ACL_EXECUTE); if (aclresult != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for function %s", get_func_name(funcoid)))); isvalid = IS_VALID_PARTITIONING_FUNC((Form_pg_proc) GETSTRUCT(tuple), dimtype, argtype); ReleaseSysCache(tuple); return isvalid; } Oid ts_partitioning_func_get_closed_default(void) { Oid argtype = ANYELEMENTOID; return ts_lookup_proc_filtered(DEFAULT_PARTITIONING_FUNC_SCHEMA, DEFAULT_PARTITIONING_FUNC_NAME, NULL, closed_dim_partitioning_func_filter, &argtype); } static bool ts_partitioning_func_is_closed_default(const char *schema, const char *funcname) { Assert(schema != NULL && funcname != NULL); return strcmp(DEFAULT_PARTITIONING_FUNC_SCHEMA, schema) == 0 && strcmp(DEFAULT_PARTITIONING_FUNC_NAME, funcname) == 0; } /* * Resolve the partitioning function set for a hypertable. */ static void partitioning_func_set_func_fmgr(PartitioningFunc *pf, Oid argtype, DimensionType dimtype) { Oid funcoid; proc_filter filter = dimtype == DIMENSION_TYPE_CLOSED ? closed_dim_partitioning_func_filter : open_dim_partitioning_func_filter; if (dimtype != DIMENSION_TYPE_CLOSED && dimtype != DIMENSION_TYPE_OPEN) elog(ERROR, "invalid dimension type %u", dimtype); funcoid = ts_lookup_proc_filtered(NameStr(pf->schema), NameStr(pf->name), &pf->rettype, filter, &argtype); if (!OidIsValid(funcoid)) { if (dimtype == DIMENSION_TYPE_CLOSED) ereport(ERROR, (errmsg("invalid partitioning function"), errhint("A partitioning function for a closed (space) dimension " "must be IMMUTABLE and have the signature (anyelement) -> integer"))); else ereport(ERROR, (errmsg("invalid partitioning function"), errhint("A partitioning function for a open (time) dimension " "must be IMMUTABLE, take one argument, and return a supported time " "type"))); } fmgr_info_cxt(funcoid, &pf->func_fmgr, CurrentMemoryContext); } static Oid find_text_coercion_func(Oid type) { Oid funcid; bool is_varlena; CoercionPathType cpt; /* * First look for an explicit cast type. Needed since the output of for * example character(20) not the same as character(20)::text */ cpt = find_coercion_pathway(TEXTOID, type, COERCION_EXPLICIT, &funcid); if (cpt != COERCION_PATH_FUNC) getTypeOutputInfo(type, &funcid, &is_varlena); return funcid; } #define TYPECACHE_HASH_FLAGS (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO) PartitioningInfo * ts_partitioning_info_create(const char *schema, const char *partfunc, const char *partcol, DimensionType dimtype, Oid relid) { PartitioningInfo *pinfo; Oid columntype, varcollid, funccollid = InvalidOid; Var *var; FuncExpr *expr; if (schema == NULL || partfunc == NULL || partcol == NULL) ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("partitioning function information cannot be null"))); pinfo = palloc0(sizeof(PartitioningInfo)); namestrcpy(&pinfo->partfunc.name, partfunc); namestrcpy(&pinfo->column, partcol); pinfo->column_attnum = get_attnum(relid, NameStr(pinfo->column)); pinfo->dimtype = dimtype; /* handle the case that the attribute has been dropped */ if (pinfo->column_attnum == InvalidAttrNumber) return NULL; namestrcpy(&pinfo->partfunc.schema, schema); /* Lookup the type cache entry to access the hash function for the type */ columntype = get_atttype(relid, pinfo->column_attnum); if (dimtype == DIMENSION_TYPE_CLOSED) { TypeCacheEntry *tce = lookup_type_cache(columntype, TYPECACHE_HASH_FLAGS); if (!OidIsValid(tce->hash_proc) && ts_partitioning_func_is_closed_default(schema, partfunc)) elog(ERROR, "could not find hash function for type %s", format_type_be(columntype)); } partitioning_func_set_func_fmgr(&pinfo->partfunc, columntype, dimtype); /* * Prepare a function expression for this function. The partition hash * function needs this to be able to resolve the type of the value to be * hashed. */ varcollid = get_typcollation(columntype); var = makeVar(1, pinfo->column_attnum, columntype, -1, varcollid, 0); expr = makeFuncExpr(pinfo->partfunc.func_fmgr.fn_oid, pinfo->partfunc.rettype, list_make1(var), funccollid, varcollid, COERCE_EXPLICIT_CALL); fmgr_info_set_expr((Node *) expr, &pinfo->partfunc.func_fmgr); return pinfo; } /* * Apply a dimension's partitioning function to a value. * * We need to avoid FunctionCall1(), because we'd like to customize the error * message in case of NULL return values. */ TSDLLEXPORT Datum ts_partitioning_func_apply(PartitioningInfo *pinfo, Oid collation, Datum value) { LOCAL_FCINFO(fcinfo, 1); Datum result; InitFunctionCallInfoData(*fcinfo, &pinfo->partfunc.func_fmgr, 1, collation, NULL, NULL); FC_SET_ARG(fcinfo, 0, value); result = FunctionCallInvoke(fcinfo); if (fcinfo->isnull) elog(ERROR, "partitioning function \"%s.%s\" returned NULL", NameStr(pinfo->partfunc.schema), NameStr(pinfo->partfunc.name)); return result; } /* * Helper function to find the right partition value from a tuple, * for space partitioned hypertables. Since attributes in tuple can * be of different order when compared to physical table columns order, * we pass partition_col_idx which points to correct space partitioned * column in the given tuple. */ TSDLLEXPORT Datum ts_partitioning_func_apply_slot(PartitioningInfo *pinfo, TupleTableSlot *slot, bool *isnull) { Datum value; bool null; Oid collation; value = slot_getattr(slot, pinfo->column_attnum, &null); if (NULL != isnull) *isnull = null; if (null) return 0; collation = TupleDescAttr(slot->tts_tupleDescriptor, AttrNumberGetAttrOffset(pinfo->column_attnum)) ->attcollation; return ts_partitioning_func_apply(pinfo, collation, value); } /* * Resolve the type of the argument passed to a function. * * The type is resolved from the function expression in the function call info. */ static Oid resolve_function_argtype(FunctionCallInfo fcinfo) { FuncExpr *fe; Node *node; Oid argtype; /* Get the function expression from the call info */ fe = (FuncExpr *) fcinfo->flinfo->fn_expr; if (NULL == fe || !IsA(fe, FuncExpr)) elog(ERROR, "no function expression set when invoking partitioning function"); if (list_length(fe->args) != 1) elog(ERROR, "unexpected number of arguments in function expression"); node = linitial(fe->args); switch (nodeTag(node)) { case T_Var: argtype = castNode(Var, node)->vartype; break; case T_Const: argtype = castNode(Const, node)->consttype; break; case T_CoerceViaIO: argtype = castNode(CoerceViaIO, node)->resulttype; break; case T_FuncExpr: /* Argument is function, so our input is its result type */ argtype = castNode(FuncExpr, node)->funcresulttype; break; case T_Param: argtype = castNode(Param, node)->paramtype; break; default: elog(ERROR, "unsupported expression argument node type: %s", ts_get_node_name(node)); } return argtype; } /* * Partitioning function cache. * * Holds type information to avoid repeated lookups. The cache is allocated on a * child memory context of the context that created the associated FmgrInfo * struct. For partitioning functions invoked on the insert path, this is * typically the Hypertable cache's memory context. Hence, the type cache lives * for the duration of the hypertable cache and can be reused across multiple * invocations of the partitioning function, even across transactions. * * If the partitioning function is invoked outside the insert path, the FmgrInfo * and its memory context has a lifetime corresponding to that invocation. */ typedef struct PartFuncCache { Oid argtype; Oid coerce_funcid; TypeCacheEntry *tce; } PartFuncCache; static PartFuncCache * part_func_cache_create(Oid argtype, TypeCacheEntry *tce, Oid coerce_funcid, MemoryContext mcxt) { PartFuncCache *pfc; pfc = MemoryContextAlloc(mcxt, sizeof(PartFuncCache)); pfc->argtype = argtype; pfc->tce = tce; pfc->coerce_funcid = coerce_funcid; return pfc; } /* _timescaledb_catalog.ts_get_partition_for_key(key anyelement) RETURNS INT */ TSDLLEXPORT Datum ts_get_partition_for_key(PG_FUNCTION_ARGS); TS_FUNCTION_INFO_V1(ts_get_partition_for_key); /* * Partition hash function that first converts all inputs to text before * hashing. */ Datum ts_get_partition_for_key(PG_FUNCTION_ARGS) { Datum arg = PG_GETARG_DATUM(0); PartFuncCache *pfc = fcinfo->flinfo->fn_extra; struct varlena *data; uint32 hash_u; int32 res; if (PG_NARGS() != 1) elog(ERROR, "unexpected number of arguments to partitioning function"); if (NULL == pfc) { Oid funcid = InvalidOid; Oid argtype = resolve_function_argtype(fcinfo); if (argtype != TEXTOID) { /* Not TEXT input -> need to convert to text */ funcid = find_text_coercion_func(argtype); if (!OidIsValid(funcid)) elog(ERROR, "could not coerce type %u to text", argtype); } pfc = part_func_cache_create(argtype, NULL, funcid, fcinfo->flinfo->fn_mcxt); fcinfo->flinfo->fn_extra = pfc; } if (pfc->argtype != TEXTOID) { arg = OidFunctionCall1(pfc->coerce_funcid, arg); arg = CStringGetTextDatum(DatumGetCString(arg)); } data = DatumGetTextPP(arg); hash_u = DatumGetUInt32(hash_any((unsigned char *) VARDATA_ANY(data), VARSIZE_ANY_EXHDR(data))); res = (int32) (hash_u & 0x7fffffff); /* Only positive numbers */ PG_FREE_IF_COPY(data, 0); PG_RETURN_INT32(res); } TSDLLEXPORT Datum ts_get_partition_hash(PG_FUNCTION_ARGS); TS_FUNCTION_INFO_V1(ts_get_partition_hash); /* * Compute a partition hash value for any input type. * * ts_get_partition_hash() takes a single argument of anyelement type. We compute * the hash based on the argument type information that we expect to find in the * function expression in the function call context. If no such expression * exists, or the type cannot be resolved from the expression, the function * throws an error. */ Datum ts_get_partition_hash(PG_FUNCTION_ARGS) { Datum arg = PG_GETARG_DATUM(0); PartFuncCache *pfc = fcinfo->flinfo->fn_extra; Datum hash; int32 res; Oid collation; if (PG_NARGS() != 1) elog(ERROR, "unexpected number of arguments to partitioning function"); if (NULL == pfc) { Oid argtype = resolve_function_argtype(fcinfo); TypeCacheEntry *tce = lookup_type_cache(argtype, TYPECACHE_HASH_FLAGS); pfc = part_func_cache_create(argtype, tce, InvalidOid, fcinfo->flinfo->fn_mcxt); fcinfo->flinfo->fn_extra = pfc; } if (!OidIsValid(pfc->tce->hash_proc)) elog(ERROR, "could not find hash function for type %u", pfc->argtype); /* use the supplied collation, if it exists, otherwise use the default for * the type */ collation = PG_GET_COLLATION(); if (!OidIsValid(collation)) collation = pfc->tce->typcollation; hash = FunctionCall1Coll(&pfc->tce->hash_proc_finfo, collation, arg); /* Only positive numbers */ res = (int32) (DatumGetUInt32(hash) & 0x7fffffff); PG_RETURN_INT32(res); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/partitioning.h���������������������������������������������������������������0000664�0000000�0000000�00000003254�15100345067�0017526�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define KEYSPACE_PT_NO_PARTITIONING -1 #include <postgres.h> #include <access/attnum.h> #include <access/htup_details.h> #include <fmgr.h> #include <utils/typcache.h> #include "dimension.h" #include "ts_catalog/catalog.h" #define OPEN_START_TIME -1 #define OPEN_END_TIME PG_INT64_MAX #define DEFAULT_PARTITIONING_FUNC_SCHEMA FUNCTIONS_SCHEMA_NAME #define DEFAULT_PARTITIONING_FUNC_NAME "get_partition_hash" typedef struct PartitioningFunc { NameData schema; NameData name; Oid rettype; /* * Function manager info to call the partitioning function on the * partitioning column's text representation. */ FmgrInfo func_fmgr; } PartitioningFunc; typedef struct PartitioningInfo { NameData column; AttrNumber column_attnum; DimensionType dimtype; PartitioningFunc partfunc; } PartitioningInfo; extern Oid ts_partitioning_func_get_closed_default(void); extern bool ts_partitioning_func_is_valid(regproc funcoid, DimensionType dimtype, Oid argtype); extern PartitioningInfo *ts_partitioning_info_create(const char *schema, const char *partfunc, const char *partcol, DimensionType dimtype, Oid relid); extern TSDLLEXPORT Datum ts_partitioning_func_apply(PartitioningInfo *pinfo, Oid collation, Datum value); /* NOTE: assume the tuple belongs to the root table, use ts_partitioning_func_apply for chunk tuples */ extern TSDLLEXPORT Datum ts_partitioning_func_apply_slot(PartitioningInfo *pinfo, TupleTableSlot *slot, bool *isnull); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/���������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016301�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/CMakeLists.txt�������������������������������������������������������0000664�0000000�0000000�00000000676�15100345067�0021052�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/planner.c ${CMAKE_CURRENT_SOURCE_DIR}/add_hashagg.c ${CMAKE_CURRENT_SOURCE_DIR}/agg_bookend.c ${CMAKE_CURRENT_SOURCE_DIR}/constify_now.c ${CMAKE_CURRENT_SOURCE_DIR}/constraint_cleanup.c ${CMAKE_CURRENT_SOURCE_DIR}/expand_hypertable.c ${CMAKE_CURRENT_SOURCE_DIR}/partialize.c ${CMAKE_CURRENT_SOURCE_DIR}/space_constraint.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ������������������������������������������������������������������timescaledb-2.23.0/src/planner/add_hashagg.c��������������������������������������������������������0000664�0000000�0000000�00000014767�15100345067�0020676�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/namespace.h> #include <miscadmin.h> #include <nodes/extensible.h> #include <nodes/plannodes.h> #include <optimizer/clauses.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/prep.h> #include <optimizer/tlist.h> #include <parser/parsetree.h> #include "compat/compat.h" #include "estimate.h" #include "gapfill.h" #include "guc.h" #include "import/planner.h" #include "planner.h" #include "utils.h" /* This optimization adds a HashAggregate plan to many group by queries. * In plain postgres, many time-series queries will not use a hash aggregate * because the planner will incorrectly assume that the number of rows is much larger than * it actually is and will use the less efficient GroupAggregate instead of a HashAggregate * to prevent running out of memory. * * The planner will assume a large number of rows because the statistics planner for grouping * assumes that the number of distinct items produced by a function is the same as the number of * distinct items going in. This is not true for functions like time_bucket and date_trunc. This * optimization fixes the statistics and adds the HashAggregate plan if appropriate. * */ /* Add a parallel HashAggregate plan. * This code is similar to parts of create_grouping_paths */ static void plan_add_parallel_hashagg(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel, double d_num_groups) { Query *parse = root->parse; Path *cheapest_partial_path = linitial(input_rel->partial_pathlist); PathTarget *target = root->upper_targets[UPPERREL_GROUP_AGG]; PathTarget *partial_grouping_target = ts_make_partial_grouping_target(root, target); AggClauseCosts agg_partial_costs; AggClauseCosts agg_final_costs; Size hashagg_table_size; double total_groups; Path *partial_path; double d_num_partial_groups = ts_estimate_group(root, cheapest_partial_path->rows); /* don't have any special estimate */ if (!IS_VALID_ESTIMATE(d_num_partial_groups)) return; MemSet(&agg_partial_costs, 0, sizeof(AggClauseCosts)); MemSet(&agg_final_costs, 0, sizeof(AggClauseCosts)); if (parse->hasAggs) { /* partial phase */ get_agg_clause_costs(root, AGGSPLIT_INITIAL_SERIAL, &agg_partial_costs); /* final phase */ get_agg_clause_costs(root, AGGSPLIT_FINAL_DESERIAL, &agg_final_costs); get_agg_clause_costs(root, AGGSPLIT_FINAL_DESERIAL, &agg_final_costs); } hashagg_table_size = estimate_hashagg_tablesize(root, cheapest_partial_path, &agg_partial_costs, d_num_partial_groups); /* * Tentatively produce a partial HashAgg Path, depending on if it looks as * if the hash table will fit in work_mem. */ if (hashagg_table_size >= work_mem * UINT64CONST(1024)) return; add_partial_path(output_rel, (Path *) create_agg_path(root, output_rel, cheapest_partial_path, partial_grouping_target, AGG_HASHED, AGGSPLIT_INITIAL_SERIAL, #if PG16_LT parse->groupClause, #else root->processed_groupClause, #endif NIL, &agg_partial_costs, d_num_partial_groups)); if (!output_rel->partial_pathlist) return; partial_path = (Path *) linitial(output_rel->partial_pathlist); total_groups = partial_path->rows * partial_path->parallel_workers; partial_path = (Path *) create_gather_path(root, output_rel, partial_path, partial_grouping_target, NULL, &total_groups); add_path(output_rel, (Path *) create_agg_path(root, output_rel, partial_path, target, AGG_HASHED, AGGSPLIT_FINAL_DESERIAL, #if PG16_LT parse->groupClause, #else root->processed_groupClause, #endif (List *) parse->havingQual, &agg_final_costs, d_num_groups)); } /* This function add a HashAggregate path, if appropriate * it looks like a highly modified create_grouping_paths function * in the postgres planner. */ void ts_plan_add_hashagg(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel) { Query *parse = root->parse; Path *cheapest_path = input_rel->cheapest_total_path; AggClauseCosts agg_costs; bool can_hash; double d_num_groups; Size hashaggtablesize; PathTarget *target = root->upper_targets[UPPERREL_GROUP_AGG]; bool try_parallel_aggregation; /* Custom HashAgg is disabled by default */ if (!ts_guc_enable_custom_hashagg) return; if (parse->groupingSets || !parse->hasAggs || parse->groupClause == NIL) return; /* Don't add HashAgg path if this is a gapfill query */ if (ts_is_gapfill_path(linitial(output_rel->pathlist))) return; MemSet(&agg_costs, 0, sizeof(AggClauseCosts)); get_agg_clause_costs(root, AGGSPLIT_SIMPLE, &agg_costs); get_agg_clause_costs(root, AGGSPLIT_SIMPLE, &agg_costs); can_hash = (parse->groupClause != NIL && root->numOrderedAggs == 0 && grouping_is_hashable(parse->groupClause)); if (!can_hash) return; d_num_groups = ts_estimate_group(root, cheapest_path->rows); /* don't have any special estimate */ if (!IS_VALID_ESTIMATE(d_num_groups)) return; hashaggtablesize = estimate_hashagg_tablesize(root, cheapest_path, &agg_costs, d_num_groups); if (hashaggtablesize >= work_mem * UINT64CONST(1024)) return; if (!output_rel->consider_parallel) { /* Not even parallel-safe. */ try_parallel_aggregation = false; } else if (output_rel->partial_pathlist == NIL) { /* Nothing to use as input for partial aggregate. */ try_parallel_aggregation = false; } else if (root->hasNonPartialAggs || root->hasNonSerialAggs) { /* Insufficient support for partial mode. */ try_parallel_aggregation = false; } else { /* Everything looks good. */ try_parallel_aggregation = true; } if (try_parallel_aggregation) plan_add_parallel_hashagg(root, input_rel, output_rel, d_num_groups); /* * We just need an Agg over the cheapest-total input path, since input * order won't matter. */ add_path(output_rel, (Path *) create_agg_path(root, output_rel, cheapest_path, target, AGG_HASHED, AGGSPLIT_SIMPLE, #if PG16_LT parse->groupClause, #else root->processed_groupClause, #endif (List *) parse->havingQual, &agg_costs, d_num_groups)); } ���������timescaledb-2.23.0/src/planner/agg_bookend.c��������������������������������������������������������0000664�0000000�0000000�00000062746�15100345067�0020723�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * Optimization for FIRST/LAST aggregate functions. * * This module tries to replace FIRST/LAST aggregate functions by subqueries * of the form * (SELECT value FROM tab * WHERE sort IS NOT NULL AND existing-quals * ORDER BY sort ASC/DESC * LIMIT 1) * Given a suitable index on sort column, this can be much faster than the * generic scan-all-the-rows aggregation plan. We can handle multiple * FIRST/LAST aggregates by generating multiple subqueries, and their * orderings can be different. However, if the query also contains some * other aggregates (eg. MIN/MAX), we will skip optimization since we can't * optimize across different aggregate functions. * * Most of the code is borrowed from: * src/backend/optimizer/plan/planagg.c * * */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. */ #include <postgres.h> #include <access/htup_details.h> #include <access/stratnum.h> #include <catalog/namespace.h> #include <catalog/pg_aggregate.h> #include <catalog/pg_proc.h> #include <catalog/pg_type.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/planmain.h> #include <optimizer/subselect.h> #include <optimizer/tlist.h> #include <parser/parse_clause.h> #include <parser/parse_func.h> #include <parser/parsetree.h> #include <rewrite/rewriteManip.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/regproc.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "compat/compat.h" #include "extension.h" #include "planner.h" #include "utils.h" typedef struct FirstLastAggInfo { MinMaxAggInfo *m_agg_info; /* reusing MinMaxAggInfo to avoid code * duplication */ Expr *sort; /* Expression to use for ORDER BY */ } FirstLastAggInfo; typedef struct MutatorContext { MinMaxAggPath *mm_path; } MutatorContext; static bool find_first_last_aggs_walker(Node *node, List **context); static bool build_first_last_path(PlannerInfo *root, FirstLastAggInfo *fl_info, Oid eqop, Oid sortop, bool reverse_sort, bool nulls_first); static void first_last_qp_callback(PlannerInfo *root, void *extra); static Node *mutate_aggref_node(Node *node, MutatorContext *context); static void replace_aggref_in_tlist(MinMaxAggPath *minmaxagg_path); /* * mutate_aggref_node * * Mutator function used by recursive `expression_tree_mutator` * to replace Aggref node with Param node */ Node * mutate_aggref_node(Node *node, MutatorContext *context) { if (node == NULL) return NULL; if (IsA(node, Aggref)) { Aggref *aggref = (Aggref *) node; /* See if the Aggref should be replaced by a Param */ if (context->mm_path != NULL && list_length(aggref->args) == 2) { TargetEntry *curTarget = (TargetEntry *) linitial(aggref->args); ListCell *cell; foreach (cell, context->mm_path->mmaggregates) { MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(cell); if (mminfo->aggfnoid == aggref->aggfnoid && equal(mminfo->target, curTarget->expr)) return (Node *) copyObject(mminfo->param); } } } return expression_tree_mutator(node, mutate_aggref_node, (void *) context); } /* * replace_aggref_in_tlist * * If MinMaxAggPath is chosen, instead of running aggregate * function we will execute subquery that we've generated. Since we * use subquery we need to replace target list Aggref node with Param * node. Param node passes output value from the subquery. * */ void replace_aggref_in_tlist(MinMaxAggPath *minmaxagg_path) { MutatorContext context; context.mm_path = minmaxagg_path; ((Path *) minmaxagg_path)->pathtarget->exprs = (List *) mutate_aggref_node((Node *) ((Path *) minmaxagg_path)->pathtarget->exprs, (void *) &context); } /* Stores function id (FIRST/LAST) with proper comparison strategy */ typedef struct FuncStrategy { Oid func_oid; StrategyNumber strategy; } FuncStrategy; static Oid first_last_arg_types[] = { ANYELEMENTOID, ANYOID }; static struct FuncStrategy first_func_strategy = { .func_oid = InvalidOid, .strategy = BTLessStrategyNumber }; static struct FuncStrategy last_func_strategy = { .func_oid = InvalidOid, .strategy = BTGreaterStrategyNumber }; static FuncStrategy * initialize_func_strategy(FuncStrategy *func_strategy, char *name, int nargs, Oid arg_types[]) { List *l = list_make2(makeString(ts_extension_schema_name()), makeString(name)); func_strategy->func_oid = LookupFuncName(l, nargs, arg_types, false); return func_strategy; } static FuncStrategy * get_func_strategy(Oid func_oid) { if (!OidIsValid(first_func_strategy.func_oid)) initialize_func_strategy(&first_func_strategy, "first", 2, first_last_arg_types); if (!OidIsValid(last_func_strategy.func_oid)) initialize_func_strategy(&last_func_strategy, "last", 2, first_last_arg_types); if (first_func_strategy.func_oid == func_oid) return &first_func_strategy; if (last_func_strategy.func_oid == func_oid) return &last_func_strategy; return NULL; } static bool is_first_last_node(Node *node, List **context) { if (node == NULL) return false; if (IsA(node, Aggref)) { Aggref *aggref = (Aggref *) node; FuncStrategy *func_strategy = get_func_strategy(aggref->aggfnoid); if (func_strategy != NULL) return true; } return expression_tree_walker(node, is_first_last_node, (void *) context); } static bool contains_first_last_node(List *sortClause, List *targetList) { List *exprs = get_sortgrouplist_exprs(sortClause, targetList); ListCell *cell; List *context = NIL; foreach (cell, exprs) { Node *expr = lfirst(cell); bool found = is_first_last_node(expr, &context); if (found) return true; } return false; } /* * preprocess_first_last_aggregates - preprocess FIRST/LAST aggregates * * Check to see whether the query contains FIRST/LAST aggregate functions that * might be optimizable via index scans. If it does, and all the aggregates * are potentially optimizable, then create a MinMaxAggPath(reusing MinMax path implementation)\ * and add it to the (UPPERREL_GROUP_AGG, NULL) upperrel. * * This method is called from create_upper_paths_hook in the UPPERREL_GROUP_AGG stage. * * Note: we are passed the preprocessed targetlist separately, because it's * not necessarily equal to root->parse->targetList. * * Most of the code is borrowed from: preprocess_minmax_aggregates (planagg.c). Few * major differences: * - generate FirstLastAggInfo that wraps MinMaxAggInfo * - generate subquery (path) for FIRST/LAST (we reuse MinMaxAggPath) * - replace Aggref node with Param node * - reject ORDER BY on FIRST/LAST */ void ts_preprocess_first_last_aggregates(PlannerInfo *root, List *tlist) { Query *parse = root->parse; FromExpr *jtnode; RangeTblRef *rtr; RangeTblEntry *rte; List *first_last_aggs; RelOptInfo *grouped_rel; ListCell *lc; List *mm_agg_list; MinMaxAggPath *minmaxagg_path; /* minmax_aggs list should be empty at this point */ Assert(root->minmax_aggs == NIL); /* Nothing to do if query has no aggregates */ if (!parse->hasAggs) return; Assert(!parse->setOperations); /* shouldn't get here if a setop */ Assert(parse->rowMarks == NIL); /* nor if FOR UPDATE */ /* * Reject unoptimizable cases. * * We don't handle the case when agg function is in ORDER BY. The reason * being is that we replace Aggref node before sort keys are being * generated. * * We don't handle GROUP BY or windowing, because our current * implementations of grouping require looking at all the rows anyway, and * so there's not much point in optimizing FIRST/LAST. */ if (parse->groupClause || list_length(parse->groupingSets) > 1 || parse->hasWindowFuncs || contains_first_last_node(parse->sortClause, tlist)) return; /* * Reject if query contains any CTEs; there's no way to build an indexscan * on one so we couldn't succeed here. (If the CTEs are unreferenced, * that's not true, but it doesn't seem worth expending cycles to check.) */ if (parse->cteList) return; /* * We also restrict the query to reference exactly one table, since join * conditions can't be handled reasonably. (We could perhaps handle a * query containing cartesian-product joins, but it hardly seems worth the * trouble.) However, the single table could be buried in several levels * of FromExpr due to subqueries. Note the "single" table could be an * inheritance parent, too, including the case of a UNION ALL subquery * that's been flattened to an appendrel. */ jtnode = parse->jointree; while (IsA(jtnode, FromExpr)) { if (list_length(jtnode->fromlist) != 1) return; jtnode = linitial(jtnode->fromlist); } if (!IsA(jtnode, RangeTblRef)) return; rtr = (RangeTblRef *) jtnode; rte = planner_rt_fetch(rtr->rtindex, root); if (rte->rtekind == RTE_RELATION) /* ordinary relation, ok */; else if (rte->rtekind == RTE_SUBQUERY && rte->inh) /* flattened UNION ALL subquery, ok */; else return; /* * Scan the tlist and HAVING qual to find all the aggregates and verify * all are FIRST/LAST aggregates. Stop as soon as we find one that isn't. */ first_last_aggs = NIL; if (find_first_last_aggs_walker((Node *) tlist, &first_last_aggs)) return; if (find_first_last_aggs_walker(parse->havingQual, &first_last_aggs)) return; /* * OK, there is at least the possibility of performing the optimization. * Build an access path for each aggregate. If any of the aggregates * prove to be non-indexable, give up; there is no point in optimizing * just some of them. */ foreach (lc, first_last_aggs) { FirstLastAggInfo *fl_info = (FirstLastAggInfo *) lfirst(lc); MinMaxAggInfo *mminfo = fl_info->m_agg_info; Oid eqop; bool reverse; /* * We'll need the equality operator that goes with the aggregate's * ordering operator. */ eqop = get_equality_op_for_ordering_op(mminfo->aggsortop, &reverse); if (!OidIsValid(eqop)) /* shouldn't happen */ elog(ERROR, "could not find equality operator for ordering operator %u", mminfo->aggsortop); /* * We can use either an ordering that gives NULLS FIRST or one that * gives NULLS LAST; furthermore there's unlikely to be much * performance difference between them, so it doesn't seem worth * costing out both ways if we get a hit on the first one. NULLS * FIRST is more likely to be available if the operator is a * reverse-sort operator, so try that first if reverse. */ if (build_first_last_path(root, fl_info, eqop, mminfo->aggsortop, reverse, reverse)) continue; if (build_first_last_path(root, fl_info, eqop, mminfo->aggsortop, reverse, !reverse)) continue; /* No indexable path for this aggregate, so fail */ return; } /* * OK, we can do the query this way. We are using MinMaxAggPath to store * First/Last Agg path since the logic is almost the same. MinMaxAggPath * is used later on by planner so by reusing it we don't need to re-invent * planner. * * Prepare to create a MinMaxAggPath node. * * First, create an output Param node for each agg. (If we end up not * using the MinMaxAggPath, we'll waste a PARAM_EXEC slot for each agg, * which is not worth worrying about. We can't wait till create_plan time * to decide whether to make the Param, unfortunately.) */ mm_agg_list = NIL; foreach (lc, first_last_aggs) { FirstLastAggInfo *fl_info = (FirstLastAggInfo *) lfirst(lc); MinMaxAggInfo *mminfo = fl_info->m_agg_info; mminfo->param = SS_make_initplan_output_param(root, exprType((Node *) mminfo->target), -1, exprCollation((Node *) mminfo->target)); mm_agg_list = lcons(mminfo, mm_agg_list); } /* * Create a MinMaxAggPath node with the appropriate estimated costs and * other needed data, and add it to the UPPERREL_GROUP_AGG upperrel, where * it will compete against the standard aggregate implementation. (It * will likely always win, but we need not assume that here.) * * Note: grouping_planner won't have created this upperrel yet, but it's * fine for us to create it first. We will not have inserted the correct * consider_parallel value in it, but MinMaxAggPath paths are currently * never parallel-safe anyway, so that doesn't matter. Likewise, it * doesn't matter that we haven't filled FDW-related fields in the rel. */ grouped_rel = fetch_upper_rel(root, UPPERREL_GROUP_AGG, NULL); minmaxagg_path = create_minmaxagg_path(root, grouped_rel, create_pathtarget(root, tlist), mm_agg_list, (List *) parse->havingQual); /* Let's replace Aggref node since we will use subquery we've generated */ replace_aggref_in_tlist(minmaxagg_path); add_path(grouped_rel, (Path *) minmaxagg_path); } /* * find_first_last_aggs_walker * Recursively scan the Aggref nodes in an expression tree, and check * that each one is a FIRST/LAST aggregate. If so, build a list of the * distinct aggregate calls in the tree. * * Returns TRUE if a non-FIRST/LAST aggregate is found, FALSE otherwise. * (This seemingly-backward definition is used because expression_tree_walker * aborts the scan on TRUE return, which is what we want.) * * Found aggregates are added to the list at *context; it's up to the caller * to initialize the list to NIL. * * This does not descend into subqueries, and so should be used only after * reduction of sublinks to subplans. There mustn't be outer-aggregate * references either. * * Major differences from find_minmax_aggs_walker (planagg.c): * - only allow Aggref with two arguments * - wrap agg info in FirstLastAggInfo */ static bool find_first_last_aggs_walker(Node *node, List **context) { if (node == NULL) return false; if (IsA(node, Aggref)) { Aggref *aggref = (Aggref *) node; Oid aggsortop; TargetEntry *value; TargetEntry *sort; MinMaxAggInfo *mminfo; ListCell *l; FirstLastAggInfo *fl_info; Oid sort_oid; TypeCacheEntry *sort_tce; FuncStrategy *func_strategy; Assert(aggref->agglevelsup == 0); if (list_length(aggref->args) != 2) return true; /* it couldn't be first/last */ /* * ORDER BY is usually irrelevant for FIRST/LAST, but it can change * the outcome if the aggsortop's operator class recognizes * non-identical values as equal. For example, 4.0 and 4.00 are equal * according to numeric_ops, yet distinguishable. If FIRST() receives * more than one value equal to 4.0 and no value less than 4.0, it is * unspecified which of those equal values FIRST() returns. An ORDER * BY expression that differs for each of those equal values of the * argument expression makes the result predictable once again. This * is a niche requirement, and we do not implement it with subquery * paths. In any case, this test lets us reject ordered-set aggregates * quickly. */ if (aggref->aggorder != NIL) return true; /* note: we do not care if DISTINCT is mentioned ... */ /* * We might implement the optimization when a FILTER clause is present * by adding the filter to the quals of the generated subquery. For * now, just punt. */ if (aggref->aggfilter != NULL) return true; /* We sort by second argument (eg. time) */ sort_oid = lsecond_oid(aggref->aggargtypes); func_strategy = get_func_strategy(aggref->aggfnoid); if (func_strategy == NULL) return true; /* not first/last aggregate */ sort_tce = lookup_type_cache(sort_oid, TYPECACHE_BTREE_OPFAMILY); aggsortop = get_opfamily_member(sort_tce->btree_opf, sort_oid, sort_oid, func_strategy->strategy); if (!OidIsValid(aggsortop)) elog(ERROR, "Cannot resolve sort operator for function \"%s\" and type \"%s\"", format_procedure(aggref->aggfnoid), format_type_be(sort_oid)); /* Used in projection */ value = (TargetEntry *) linitial(aggref->args); /* Used in ORDER BY */ sort = (TargetEntry *) lsecond(aggref->args); if (contain_mutable_functions((Node *) sort->expr)) return true; /* not potentially indexable */ if (type_is_rowtype(exprType((Node *) sort->expr))) return true; /* IS NOT NULL would have weird semantics */ /* * Check whether it's already in the list, and add it if not. */ foreach (l, *context) { mminfo = (MinMaxAggInfo *) lfirst(l); if (mminfo->aggfnoid == aggref->aggfnoid && equal(mminfo->target, value->expr)) return false; } mminfo = makeNode(MinMaxAggInfo); mminfo->aggfnoid = aggref->aggfnoid; mminfo->aggsortop = aggsortop; mminfo->target = value->expr; mminfo->subroot = NULL; mminfo->path = NULL; mminfo->pathcost = 0; mminfo->param = NULL; fl_info = palloc(sizeof(FirstLastAggInfo)); fl_info->m_agg_info = mminfo; fl_info->sort = sort->expr; *context = lappend(*context, fl_info); /* * We need not recurse into the argument, since it can't contain any * aggregates. */ return false; } Assert(!IsA(node, SubLink)); return expression_tree_walker(node, find_first_last_aggs_walker, (void *) context); } /* * build_first_last_path * Given a FIRST/LAST aggregate, try to build an indexscan Path it can be * optimized with. * We will generate subquery with value and sort target, where we * SELECT value and we ORDER BY sort. * * If successful, stash the best path in *mminfo and return TRUE. * Otherwise, return FALSE. * * Major differences when compared to build_minmax_path(planagg.c): * - generates different subquery * - works with two target entries (value and sortby) * - resets EquivalenceClass(es) * */ static bool build_first_last_path(PlannerInfo *root, FirstLastAggInfo *fl_info, Oid eqop, Oid sortop, bool reverse_sort, bool nulls_first) { PlannerInfo *subroot; Query *parse; TargetEntry *value_target; TargetEntry *sort_target; List *tlist; NullTest *ntest; SortGroupClause *sortcl; RelOptInfo *final_rel; Path *sorted_path; Cost path_cost; double path_fraction; MinMaxAggInfo *mminfo; ListCell *lc; /* * We are going to construct what is effectively a sub-SELECT query, so * clone the current query level's state and adjust it to make it look * like a subquery. Any outer references will now be one level higher * than before. (This means that when we are done, there will be no Vars * of level 1, which is why the subquery can become an initplan.) */ subroot = (PlannerInfo *) palloc(sizeof(PlannerInfo)); memcpy(subroot, root, sizeof(PlannerInfo)); subroot->query_level++; subroot->parent_root = root; /* reset subplan-related stuff */ subroot->plan_params = NIL; subroot->outer_params = NULL; subroot->init_plans = NIL; /* reset EquivalenceClass since we will create it later on */ subroot->eq_classes = NIL; subroot->parse = parse = copyObject(root->parse); IncrementVarSublevelsUp((Node *) parse, 1, 1); #if PG16_GE /* Reset placeholdersFrozen: https://github.com/postgres/postgres/commit/b3ff6c74 */ subroot->placeholdersFrozen = false; #endif /* append_rel_list might contain outer Vars? */ subroot->append_rel_list = copyObject(root->append_rel_list); IncrementVarSublevelsUp((Node *) subroot->append_rel_list, 1, 1); /* There shouldn't be any OJ info to translate, as yet */ Assert(subroot->join_info_list == NIL); /* and we haven't made equivalence classes, either */ Assert(subroot->eq_classes == NIL); /* and we haven't created PlaceHolderInfos, either */ Assert(subroot->placeholder_list == NIL); mminfo = fl_info->m_agg_info; /*---------- * Generate modified query of the form * (SELECT value FROM tab * WHERE sort IS NOT NULL AND existing-quals * ORDER BY sort ASC/DESC * LIMIT 1) *---------- */ /* * Value and sort target entries but sort target is eliminated later on * from target list */ value_target = makeTargetEntry(copyObject(mminfo->target), (AttrNumber) 1, pstrdup("value"), false); sort_target = makeTargetEntry(copyObject(fl_info->sort), (AttrNumber) 2, pstrdup("sort"), true); tlist = list_make2(value_target, sort_target); subroot->processed_tlist = parse->targetList = tlist; /* No HAVING, no DISTINCT, no aggregates anymore */ parse->havingQual = NULL; subroot->hasHavingQual = false; parse->distinctClause = NIL; parse->hasDistinctOn = false; parse->hasAggs = false; /* * Build "sort IS NOT NULL" expression. Note that target can still be NULL. * We don't need it if the order is NULLS LAST. */ if (nulls_first) { ntest = makeNode(NullTest); ntest->nulltesttype = IS_NOT_NULL; ntest->arg = copyObject(fl_info->sort); /* we checked it wasn't a rowtype in find_minmax_aggs_walker */ ntest->argisrow = false; ntest->location = -1; /* User might have had that in WHERE already */ if (!list_member((List *) parse->jointree->quals, ntest)) parse->jointree->quals = (Node *) lcons(ntest, (List *) parse->jointree->quals); } /* Build suitable ORDER BY clause */ sortcl = makeNode(SortGroupClause); sortcl->tleSortGroupRef = assignSortGroupRef(sort_target, tlist); sortcl->eqop = eqop; sortcl->sortop = sortop; sortcl->nulls_first = nulls_first; sortcl->hashable = false; /* no need to make this accurate */ #if PG18_GE /* Track sort direction in SortGroupClause * https://github.com/postgres/postgres/commit/0d2aa4d4 */ sortcl->reverse_sort = reverse_sort; #endif parse->sortClause = list_make1(sortcl); /* set up expressions for LIMIT 1 */ parse->limitOffset = NULL; parse->limitCount = (Node *) makeConst(INT8OID, -1, InvalidOid, sizeof(int64), Int64GetDatum(1), false, FLOAT8PASSBYVAL); /* * Generate the best paths for this query, telling query_planner that we * have LIMIT 1. */ subroot->tuple_fraction = 1.0; subroot->limit_tuples = 1.0; /* min/max optimizations usually happen before * inheritance-relations are expanded, and thus query_planner will * try to expand our hypertables if they are marked as * inheritance-relations. Since we do not want this, we must mark * hypertables as non-inheritance now. */ foreach (lc, subroot->parse->rtable) { RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc); if (ts_rte_is_hypertable(rte)) { ListCell *prev = NULL; ListCell *next = list_head(subroot->append_rel_list); Assert(rte->inh); rte->inh = false; /* query planner gets confused when entries in the * append_rel_list refer to entries in the relarray that * don't exist. Since we need to expand hypertables in the * subquery, all of the chunk entries will be invalid in * this manner, so we remove them from the list. */ /* Performance Enhancement: This can be made non-quadratic by: * 1) Loop once over all RTEs, storing the relid of any RTE that is a hypertable in * a bitset and setting its 'inh' flag to false 2) Loop over the append_rel_list, * removing any AppendRelInfo that has a parent relid which is in the previously * created bitset (i.e., is a hypertable) */ while (next != NULL) { AppendRelInfo *app = lfirst(next); if (app->parent_reloid == rte->relid) { subroot->append_rel_list = list_delete_cell(subroot->append_rel_list, next); next = prev != NULL ? lnext(subroot->append_rel_list, next) : list_head(subroot->append_rel_list); } else { prev = next; next = lnext(subroot->append_rel_list, next); } } } } final_rel = query_planner(subroot, first_last_qp_callback, NULL); /* we need to disable inheritance so the chunks are re-expanded correctly in the subroot */ foreach (lc, root->parse->rtable) { RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc); if (ts_rte_is_hypertable(rte)) rte->inh = true; } /* * Since we didn't go through subquery_planner() to handle the subquery, * we have to do some of the same cleanup it would do, in particular cope * with params and initplans used within this subquery. (This won't * matter if we end up not using the subplan.) */ SS_identify_outer_params(subroot); SS_charge_for_initplans(subroot, final_rel); /* * Get the best presorted path, that being the one that's cheapest for * fetching just one row. If there's no such path, fail. */ if (final_rel->rows > 1.0) path_fraction = 1.0 / final_rel->rows; else path_fraction = 1.0; sorted_path = get_cheapest_fractional_path_for_pathkeys(final_rel->pathlist, subroot->query_pathkeys, NULL, path_fraction); if (!sorted_path) return false; /* * The path might not return exactly what we want, so fix that. (We * assume that this won't change any conclusions about which was the * cheapest path.) */ sorted_path = apply_projection_to_path(subroot, final_rel, sorted_path, create_pathtarget(subroot, tlist)); /* * Determine cost to get just the first row of the presorted path. * * Note: cost calculation here should match * compare_fractional_path_costs(). */ path_cost = sorted_path->startup_cost + path_fraction * (sorted_path->total_cost - sorted_path->startup_cost); /* Save state for further processing */ mminfo->subroot = subroot; mminfo->path = sorted_path; mminfo->pathcost = path_cost; return true; } /* * Compute query_pathkeys and other pathkeys during query_planner() */ static void first_last_qp_callback(PlannerInfo *root, void *extra) { root->group_pathkeys = NIL; root->window_pathkeys = NIL; root->distinct_pathkeys = NIL; root->sort_pathkeys = make_pathkeys_for_sortclauses(root, root->parse->sortClause, root->parse->targetList); root->query_pathkeys = root->sort_pathkeys; } ��������������������������timescaledb-2.23.0/src/planner/constify_now.c�������������������������������������������������������0000664�0000000�0000000�00000020422�15100345067�0021166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <datatype/timestamp.h> #include <nodes/makefuncs.h> #include <optimizer/optimizer.h> #include <utils/fmgroids.h> #include "cache.h" #include "dimension.h" #include "hypertable.h" #include "hypertable_cache.h" #include "planner.h" /* * This implements an optimization to allow now() expression to be * used during plan time chunk exclusions. Since now() is stable it * would not normally be considered for plan time chunk exclusion. * To enable this behaviour we convert `column > now()` expressions * into `column > const AND column > now()`. Assuming that times * always moves forward this is safe even for prepared statements. * * We consider the following expressions valid for this optimization: * - Var > now() * - Var >= now() * - Var > now() - Interval * - Var > now() + Interval * - Var >= now() - Interval * - Var >= now() + Interval * * Interval needs to be Const in those expressions. */ static const Dimension * get_hypertable_dimension(Oid relid, int flags) { Hypertable *ht = ts_planner_get_hypertable(relid, flags); if (!ht) return NULL; return hyperspace_get_open_dimension(ht->space, 0); } bool is_valid_now_func(Node *node) { if (IsA(node, FuncExpr) && castNode(FuncExpr, node)->funcid == F_NOW) return true; if (IsA(node, SQLValueFunction) && castNode(SQLValueFunction, node)->type == SVFOP_CURRENT_TIMESTAMP) return true; return false; } static bool is_valid_now_expr(OpExpr *op, List *rtable) { int flags = CACHE_FLAG_MISSING_OK | CACHE_FLAG_NOCREATE; /* Var > or Var >= */ if ((op->opfuncid != F_TIMESTAMPTZ_GT && op->opfuncid != F_TIMESTAMPTZ_GE) || !IsA(linitial(op->args), Var)) return false; /* * Check that the constraint is actually on a partitioning * column. We only check for match on first open dimension * because that will be the time column. */ Var *var = linitial_node(Var, op->args); if (var->varlevelsup != 0) return false; Assert((int) var->varno <= list_length(rtable)); RangeTblEntry *rte = list_nth(rtable, var->varno - 1); /* * If this query on a view we might have a subquery here * and need to peek into the subquery range table to check * if the constraints are on a hypertable. */ if (rte->rtekind == RTE_SUBQUERY) { /* * Unfortunately the mechanism used to warm up the * hypertable cache does not apply to hypertables * referenced indirectly eg through VIEWs. So we * have to do the lookup for this hypertable without * CACHE_FLAG_NOCREATE flag. */ flags = CACHE_FLAG_MISSING_OK; TargetEntry *tle = list_nth(rte->subquery->targetList, var->varattno - 1); if (!IsA(tle->expr, Var)) return false; var = castNode(Var, tle->expr); if (var->varlevelsup != 0) return false; #if PG18_GE /* PG18 introduced RTEs for group clauses so * we can use rtable to look up GROUP BY expressions. * * https://github.com/postgres/postgres/commit/247dea89 */ RangeTblEntry *group_rte = list_nth(rte->subquery->rtable, var->varno - 1); if (group_rte->rtekind == RTE_GROUP) { Assert(var->varattno > 0); Expr *node = list_nth(group_rte->groupexprs, var->varattno - 1); if (!IsA(node, Var)) return false; var = castNode(Var, node); Assert(var->varno > 0); if (var->varlevelsup != 0) return false; } #endif rte = list_nth(rte->subquery->rtable, var->varno - 1); } const Dimension *dim = get_hypertable_dimension(rte->relid, flags); if (!dim || dim->fd.column_type != TIMESTAMPTZOID || dim->column_attno != var->varattno) return false; /* Var > now() or Var >= now() */ if (is_valid_now_func(lsecond(op->args))) return true; if (!IsA(lsecond(op->args), OpExpr)) return false; /* Var >|>= now() +|- Const */ OpExpr *op_inner = lsecond_node(OpExpr, op->args); if ((op_inner->opfuncid != F_TIMESTAMPTZ_MI_INTERVAL && op_inner->opfuncid != F_TIMESTAMPTZ_PL_INTERVAL) || !is_valid_now_func(linitial(op_inner->args)) || !IsA(lsecond(op_inner->args), Const)) return false; /* * The consttype check should not be necessary since the * operators we whitelist above already mandates it. */ Const *c = lsecond_node(Const, op_inner->args); Assert(c->consttype == INTERVALOID); if (c->constisnull || c->consttype != INTERVALOID) return false; return true; } static Const * make_now_const() { return makeConst(TIMESTAMPTZOID, -1, InvalidOid, sizeof(TimestampTz), #ifdef TS_DEBUG ts_get_mock_time_or_current_time(), #else TimestampTzGetDatum(GetCurrentTransactionStartTimestamp()), #endif false, FLOAT8PASSBYVAL); } /* returns a copy of the expression with the now() call constified */ /* * op will be OpExpr with Var > now() - Expr */ static OpExpr * constify_now_expr(PlannerInfo *root, OpExpr *op) { op = copyObject(op); op->location = PLANNER_LOCATION_MAGIC; if (is_valid_now_func(lsecond(op->args))) { lsecond(op->args) = make_now_const(); return op; } else { OpExpr *op_inner = lsecond_node(OpExpr, op->args); Const *const_offset = lsecond_node(Const, op_inner->args); Assert(const_offset->consttype == INTERVALOID); Interval *offset = DatumGetIntervalP(const_offset->constvalue); /* * Sanity check that this is a supported expression. We should never * end here if it isn't since this is checked in is_valid_now_expr. */ Assert(is_valid_now_func(linitial(op_inner->args))); Const *now = make_now_const(); linitial(op_inner->args) = now; /* * If the interval has a day component then the calculation needs * to take into account daylight saving time switches and thereby a * day would not always be exactly 24 hours. We mitigate this by * adding a safety buffer to account for these dst switches when * dealing with intervals with day component. These calculations * will be repeated with exact values during execution. * Since dst switches seem to range between -1 and 2 hours we set * the safety buffer to 4 hours. * When dealing with Intervals with month component timezone changes * can result in multiple day differences in the outcome of these * calculations due to different month lengths. When dealing with * months we add a 7 day safety buffer. * For all these calculations it is fine if we exclude less chunks * than strictly required for the operation, additional exclusion * with exact values will happen in the executor. But under no * circumstances must we exclude too much cause there would be * no way for the executor to get those chunks back. */ if (offset->day != 0 || offset->month != 0) { TimestampTz now_value = DatumGetTimestampTz(now->constvalue); if (offset->month != 0) now_value -= 7 * USECS_PER_DAY; if (offset->day != 0) now_value -= 4 * USECS_PER_HOUR; now->constvalue = TimestampTzGetDatum(now_value); } /* * Normally estimate_expression_value is not safe to use during planning * since it also evaluates stable expressions. Since we only allow a * very limited subset of expressions for this optimization it is safe * for those expressions we allowed earlier. * estimate_expression_value should always be able to completely constify * the expression due to the restrictions we impose on the expressions * supported. */ lsecond(op->args) = estimate_expression_value(root, (Node *) op_inner); Assert(IsA(lsecond(op->args), Const)); op->location = PLANNER_LOCATION_MAGIC; return op; } } Node * ts_constify_now(PlannerInfo *root, List *rtable, Node *node) { Assert(node); switch (nodeTag(node)) { case T_OpExpr: if (is_valid_now_expr(castNode(OpExpr, node), rtable)) { List *args = list_make2(copyObject(node), constify_now_expr(root, castNode(OpExpr, node))); return (Node *) makeBoolExpr(AND_EXPR, args, -1); } break; case T_BoolExpr: { List *additions = NIL; ListCell *lc; BoolExpr *be = castNode(BoolExpr, node); /* We only look for top-level AND */ if (be->boolop != AND_EXPR) return node; foreach (lc, be->args) { additions = lappend(additions, ts_constify_now(root, rtable, (Node *) lfirst(lc))); } if (additions) be->args = additions; break; } default: break; } return node; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/constraint_cleanup.c�������������������������������������������������0000664�0000000�0000000�00000005271�15100345067�0022345�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <nodes/pathnodes.h> #include "planner.h" /* * This code deals with removing the intermediate constraints * we added before planning to improve chunk exclusion. */ static bool restrictinfo_is_marked(RestrictInfo *ri) { switch (nodeTag(ri->clause)) { case T_OpExpr: return castNode(OpExpr, ri->clause)->location == PLANNER_LOCATION_MAGIC; case T_ScalarArrayOpExpr: return castNode(ScalarArrayOpExpr, ri->clause)->location == PLANNER_LOCATION_MAGIC; default: break; } return false; } /* * Remove marked constraints from RestrictInfo clause. */ static List * restrictinfo_cleanup(List *restrictinfos, bool *pfiltered) { List *filtered_ri = NIL; ListCell *lc; bool filtered = false; if (!restrictinfos) return NULL; foreach (lc, restrictinfos) { RestrictInfo *ri = (RestrictInfo *) lfirst(lc); if (restrictinfo_is_marked(ri)) { filtered = true; continue; } filtered_ri = lappend(filtered_ri, ri); } if (pfiltered) *pfiltered = filtered; return filtered ? filtered_ri : restrictinfos; } /* * Remove marked constraints from IndexPath. */ static void indexpath_cleanup(IndexPath *path) { ListCell *lc; List *filtered_ic = NIL; path->indexinfo->indrestrictinfo = restrictinfo_cleanup(path->indexinfo->indrestrictinfo, NULL); foreach (lc, path->indexclauses) { IndexClause *iclause = lfirst_node(IndexClause, lc); if (restrictinfo_is_marked(iclause->rinfo)) continue; filtered_ic = lappend(filtered_ic, iclause); } path->indexclauses = filtered_ic; } void ts_planner_constraint_cleanup(PlannerInfo *root, RelOptInfo *rel) { ListCell *lc; bool filtered = false; if (rel->baserestrictinfo) rel->baserestrictinfo = restrictinfo_cleanup(rel->baserestrictinfo, &filtered); /* * If we added constraints those will be present in baserestrictinfo. * If we did not remove anything from baserestrictinfo in the step * above we can skip looking in the paths. */ if (filtered) { /* * For seqscan cleaning up baserestrictinfo is enough but for * BitmapHeapPath and IndexPath we need some extra steps. */ foreach (lc, rel->pathlist) { switch (nodeTag(lfirst(lc))) { case T_BitmapHeapPath: { BitmapHeapPath *path = lfirst_node(BitmapHeapPath, lc); if (IsA(path->bitmapqual, IndexPath)) indexpath_cleanup(castNode(IndexPath, path->bitmapqual)); break; } case T_IndexPath: { indexpath_cleanup(castNode(IndexPath, lfirst(lc))); break; } default: break; } } } } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/expand_hypertable.c��������������������������������������������������0000664�0000000�0000000�00000107230�15100345067�0022146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* This planner optimization reduces planning times when a hypertable has many chunks. * It does this by expanding hypertable chunks manually, eliding the `expand_inherited_tables` * logic used by PG. * * Slow planning time were previously seen because `expand_inherited_tables` expands all chunks of * a hypertable, without regard to constraints present in the query. Then, `get_relation_info` is * called on all chunks before constraint exclusion. Getting the statistics on many chunks ends * up being expensive because RelationGetNumberOfBlocks has to open the file for each relation. * This gets even worse under high concurrency. * * This logic solves this by expanding only the chunks needed to fulfil the query instead of all * chunks. In effect, it moves chunk exclusion up in the planning process. But, we actually don't * use constraint exclusion here, but rather a variant of range exclusion implemented by * HypertableRestrictInfo. * */ #include <postgres.h> #include <catalog/pg_constraint.h> #include <catalog/pg_inherits.h> #include <catalog/pg_namespace.h> #include <catalog/pg_type.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/plannodes.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/prep.h> #include <optimizer/restrictinfo.h> #include <optimizer/tlist.h> #include <parser/parse_func.h> #include <parser/parsetree.h> #include <partitioning/partbounds.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/errcodes.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include <utils/syscache.h> #include "compat/compat.h" #include "chunk.h" #include "cross_module_fn.h" #include "extension.h" #include "extension_constants.h" #include "guc.h" #include "hypertable.h" #include "hypertable_restrict_info.h" #include "import/planner.h" #include "nodes/chunk_append/chunk_append.h" #include "partialize.h" #include "partitioning.h" #include "planner.h" #include "time_utils.h" #include "ts_catalog/array_utils.h" typedef struct CollectQualCtx { PlannerInfo *root; RelOptInfo *rel; List *restrictions; List *join_conditions; List *propagate_conditions; List *all_quals; int join_level; } CollectQualCtx; static void propagate_join_quals(PlannerInfo *root, RelOptInfo *rel, CollectQualCtx *ctx); static bool is_time_bucket_function(Expr *node) { if (IsA(node, FuncExpr) && strncmp(get_func_name(castNode(FuncExpr, node)->funcid), "time_bucket", NAMEDATALEN) == 0) return true; return false; } static void ts_add_append_rel_infos(PlannerInfo *root, List *appinfos) { ListCell *lc; root->append_rel_list = list_concat(root->append_rel_list, appinfos); /* root->append_rel_array is required to be able to hold all the * additional entries by previous call to expand_planner_arrays */ Assert(root->append_rel_array); foreach (lc, appinfos) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); int child_relid = appinfo->child_relid; Assert(child_relid < root->simple_rel_array_size); root->append_rel_array[child_relid] = appinfo; } } /* * Pre-check to determine if an expression is eligible for constification. * A more thorough check is in constify_timestamptz_op_interval. */ static bool is_timestamptz_op_interval(Expr *expr) { OpExpr *op; Const *c1, *c2; if (!IsA(expr, OpExpr)) return false; op = castNode(OpExpr, expr); if (op->opresulttype != TIMESTAMPTZOID || op->args->length != 2 || !IsA(linitial(op->args), Const) || !IsA(llast(op->args), Const)) return false; c1 = linitial_node(Const, op->args); c2 = llast_node(Const, op->args); return (c1->consttype == TIMESTAMPTZOID && c2->consttype == INTERVALOID) || (c1->consttype == INTERVALOID && c2->consttype == TIMESTAMPTZOID); } static Datum int_get_datum(int64 value, Oid type) { switch (type) { case INT2OID: return Int16GetDatum(value); case INT4OID: return Int32GetDatum(value); case INT8OID: return Int64GetDatum(value); case TIMESTAMPOID: return TimestampGetDatum(value); case TIMESTAMPTZOID: return TimestampTzGetDatum(value); default: elog(ERROR, "unsupported datatype in int_get_datum: %s", format_type_be(type)); pg_unreachable(); } } static int64 const_datum_get_int(Const *cnst) { Assert(!cnst->constisnull); switch (cnst->consttype) { case INT2OID: return (int64) (DatumGetInt16(cnst->constvalue)); case INT4OID: return (int64) (DatumGetInt32(cnst->constvalue)); case INT8OID: return DatumGetInt64(cnst->constvalue); case DATEOID: return DatumGetDateADT(cnst->constvalue); case TIMESTAMPOID: return DatumGetTimestamp(cnst->constvalue); case TIMESTAMPTZOID: return DatumGetTimestampTz(cnst->constvalue); default: elog(ERROR, "unsupported datatype in const_datum_get_int: %s", format_type_be(cnst->consttype)); pg_unreachable(); } } /* * Constify expressions of the following form in WHERE clause: * * column OP timestamptz - interval * column OP timestamptz + interval * column OP interval + timestamptz * * Iff interval has no month component. * * Since the operators for timestamptz OP interval are marked * as stable they will not be constified during planning. * However, intervals without a month component can be safely * constified during planning as the result of those calculations * do not depend on the timezone setting. */ static OpExpr * constify_timestamptz_op_interval(PlannerInfo *root, OpExpr *constraint) { Expr *left, *right; OpExpr *op; bool var_on_left = false; Interval *interval; Const *c_ts, *c_int; Datum constified; PGFunction opfunc; Oid ts_pl_int, ts_mi_int, int_pl_ts; /* checked in caller already so only asserting */ Assert(constraint->args->length == 2); left = linitial(constraint->args); right = llast(constraint->args); if (IsA(left, Var) && IsA(right, OpExpr)) { op = castNode(OpExpr, right); var_on_left = true; } else if (IsA(left, OpExpr) && IsA(right, Var)) { op = castNode(OpExpr, left); } else return constraint; ts_pl_int = ts_get_operator("+", PG_CATALOG_NAMESPACE, TIMESTAMPTZOID, INTERVALOID); ts_mi_int = ts_get_operator("-", PG_CATALOG_NAMESPACE, TIMESTAMPTZOID, INTERVALOID); int_pl_ts = ts_get_operator("+", PG_CATALOG_NAMESPACE, INTERVALOID, TIMESTAMPTZOID); if (op->opno == ts_pl_int) { /* TIMESTAMPTZ + INTERVAL */ opfunc = timestamptz_pl_interval; c_ts = linitial_node(Const, op->args); c_int = llast_node(Const, op->args); } else if (op->opno == ts_mi_int) { /* TIMESTAMPTZ - INTERVAL */ opfunc = timestamptz_mi_interval; c_ts = linitial_node(Const, op->args); c_int = llast_node(Const, op->args); } else if (op->opno == int_pl_ts) { /* INTERVAL + TIMESTAMPTZ */ opfunc = timestamptz_pl_interval; c_int = linitial_node(Const, op->args); c_ts = llast_node(Const, op->args); } else return constraint; /* * arg types should match operator and were checked in precheck * so only asserting here */ Assert(c_ts->consttype == TIMESTAMPTZOID); Assert(c_int->consttype == INTERVALOID); if (c_ts->constisnull || c_int->constisnull) return constraint; interval = DatumGetIntervalP(c_int->constvalue); /* * constification is only safe when the interval has no month component * because month length is variable and calculation depends on local timezone */ if (interval->month != 0) return constraint; constified = DirectFunctionCall2(opfunc, c_ts->constvalue, c_int->constvalue); /* * Since constifying intervals with day component does depend on the timezone * this can lead to different results around daylight saving time switches. * So we add a safety buffer when the interval has day components to counteract. */ if (interval->day != 0) { bool add; TimestampTz constified_tstz = DatumGetTimestampTz(constified); switch (constraint->opfuncid) { case F_TIMESTAMPTZ_LE: case F_TIMESTAMPTZ_LT: add = true; break; case F_TIMESTAMPTZ_GE: case F_TIMESTAMPTZ_GT: add = false; break; default: return constraint; } /* * If Var is on wrong side reverse the direction. */ if (!var_on_left) add = !add; /* * The safety buffer is chosen to be 4 hours because daylight saving time * changes seem to be in the range between -1 and 2 hours. */ if (add) constified_tstz += 4 * USECS_PER_HOUR; else constified_tstz -= 4 * USECS_PER_HOUR; constified = TimestampTzGetDatum(constified_tstz); } c_ts = copyObject(c_ts); c_ts->constvalue = constified; if (var_on_left) right = (Expr *) c_ts; else left = (Expr *) c_ts; return (OpExpr *) make_opclause(constraint->opno, constraint->opresulttype, constraint->opretset, left, right, constraint->opcollid, constraint->inputcollid); } static bool extract_opexpr_parts(Expr *node, OpExpr **op, FuncExpr **time_bucket, Expr **value, Oid *opno) { if (!IsA(node, OpExpr)) { return false; } *op = castNode(OpExpr, node); if (list_length((*op)->args) != 2) { return false; } Expr *left = linitial((*op)->args); Expr *right = lsecond((*op)->args); if (IsA(left, FuncExpr) && IsA(right, Const)) { *time_bucket = castNode(FuncExpr, left); *value = right; *opno = (*op)->opno; } else if (IsA(right, FuncExpr)) { *time_bucket = castNode(FuncExpr, right); *value = left; *opno = get_commutator((*op)->opno); if (!OidIsValid(opno)) return false; } else { return false; } if (!is_time_bucket_function((Expr *) *time_bucket) || !IsA(*value, Const) || castNode(Const, *value)->constisnull) { return false; } return true; } /* * Transform time_bucket calls of the following form in WHERE clause: * * time_bucket(width, column) OP value * * Since time_bucket always returns the lower bound of the bucket * for lower bound comparisons the width is not relevant and the * following transformation can be applied: * * time_bucket(width, column) > value * column > value * * Example with values: * * time_bucket(10, column) > 109 * column > 109 * * For upper bound comparisons width needs to be taken into account * and we need to extend the upper bound by width to capture all * possible values. * * time_bucket(width, column) < value * column < value + width * * Example with values: * * time_bucket(10, column) < 100 * column < 100 + 10 * * Expressions with value on the left side will be switched around * when building the expression for RestrictInfo. * * If the transformation cannot be applied, returns NULL. */ Expr * ts_transform_time_bucket_comparison(Expr *node) { FuncExpr *time_bucket; Expr *value; OpExpr *op; Oid opno; if (!extract_opexpr_parts(node, &op, &time_bucket, &value, &opno)) { return NULL; } Const *width = linitial(time_bucket->args); if (!IsA(width, Const) || width->constisnull) return NULL; /* 3 or more args should have Const 3rd arg */ if (list_length(time_bucket->args) > 2 && !IsA(lthird(time_bucket->args), Const)) return NULL; /* 5 args variants should have Const 4th and 5th arg */ if (list_length(time_bucket->args) == 5 && (!IsA(lfourth(time_bucket->args), Const) || !IsA(lfifth(time_bucket->args), Const))) return NULL; Assert(list_length(time_bucket->args) == 2 || list_length(time_bucket->args) == 3 || list_length(time_bucket->args) == 5); TypeCacheEntry *tce; int strategy; tce = lookup_type_cache(exprType((Node *) time_bucket), TYPECACHE_BTREE_OPFAMILY); strategy = get_op_opfamily_strategy(opno, tce->btree_opf); if (strategy == BTGreaterStrategyNumber || strategy == BTGreaterEqualStrategyNumber) { /* Since time_bucket will always shift the input to the left this * transformation is always safe even in the presence of offset variants. * * column > value */ op = copyObject(op); op->args = list_make2(lsecond(time_bucket->args), value); /* * if we switched operator we need to adjust OpExpr as well */ if (op->opno != opno) { op->opno = opno; op->opfuncid = InvalidOid; } return &op->xpr; } else if (strategy == BTLessStrategyNumber || strategy == BTLessEqualStrategyNumber) { /* column < value + width */ Expr *subst; Datum datum; int64 integralValue, integralWidth; switch (tce->type_id) { case INT2OID: case INT4OID: case INT8OID: /* We can support the offset variants of time_bucket as the * amount of shifting they do is never bigger than the bucketing * width. */ integralValue = const_datum_get_int(castNode(Const, value)); integralWidth = const_datum_get_int(width); if (integralValue >= ts_time_get_max(tce->type_id) - integralWidth) return NULL; /* * When the time_bucket constraint matches the start of the bucket * and we have a less than constraint and no offset we can skip * adding the full bucket. */ if (strategy == BTLessStrategyNumber && list_length(time_bucket->args) == 2 && integralValue % integralWidth == 0) datum = int_get_datum(integralValue, tce->type_id); else datum = int_get_datum(integralValue + integralWidth, tce->type_id); subst = (Expr *) makeConst(tce->type_id, -1, InvalidOid, tce->typlen, datum, false, tce->typbyval); break; case DATEOID: { /* We can support the offset/origin variants of time_bucket * as the amount of shifting they do is never bigger than the * bucketing width. */ Assert(width->consttype == INTERVALOID); Interval *interval = DatumGetIntervalP(width->constvalue); /* * Optimization can't be applied when interval has month component. */ if (interval->month != 0) return NULL; /* bail out if interval->time can't be exactly represented as a double */ if (interval->time >= 0x3FFFFFFFFFFFFFLL) return NULL; integralValue = const_datum_get_int(castNode(Const, value)); integralWidth = interval->day + ceil((double) interval->time / (double) USECS_PER_DAY); if (integralValue >= (TS_DATE_END - integralWidth)) return NULL; /* * When the time_bucket constraint matches the start of the bucket * and we have a less than constraint and no offset or origin we can * skip adding the full bucket. */ if (strategy == BTLessStrategyNumber && list_length(time_bucket->args) == 2 && integralValue % integralWidth == 0) datum = DateADTGetDatum(integralValue); else datum = DateADTGetDatum(integralValue + integralWidth); subst = (Expr *) makeConst(tce->type_id, -1, InvalidOid, tce->typlen, datum, false, tce->typbyval); break; } case TIMESTAMPOID: case TIMESTAMPTZOID: { /* We can support the offset/origin/timezone variants of time_bucket * as the amount of shifting they do is never bigger than the * bucketing width. */ Assert(width->consttype == INTERVALOID); Interval *interval = DatumGetIntervalP(width->constvalue); /* * Optimization can't be applied when interval has month component. */ if (interval->month != 0) return NULL; /* * If width interval has day component we merge it with time component */ integralWidth = interval->time; if (interval->day != 0) { /* * if our transformed restriction would overflow we skip adding it */ if (interval->time >= TS_TIMESTAMP_END - interval->day * USECS_PER_DAY) return NULL; integralWidth += interval->day * USECS_PER_DAY; } integralValue = const_datum_get_int(castNode(Const, value)); if (integralValue >= (TS_TIMESTAMP_END - integralWidth)) return NULL; /* * When the time_bucket constraint matches the start of the bucket * and we have a less than constraint and no other modifying arguments * we can skip adding the full bucket. */ if (strategy == BTLessStrategyNumber && list_length(time_bucket->args) == 2 && integralValue % integralWidth == 0) datum = int_get_datum(integralValue, tce->type_id); else datum = int_get_datum(integralValue + integralWidth, tce->type_id); subst = (Expr *) makeConst(tce->type_id, -1, InvalidOid, tce->typlen, datum, false, tce->typbyval); break; } default: return NULL; } /* * adjust toplevel expression if datatypes changed * this can happen when comparing int4 values against int8 time_bucket */ if (tce->type_id != castNode(Const, value)->consttype) { opno = ts_get_operator(get_opname(opno), PG_CATALOG_NAMESPACE, tce->type_id, tce->type_id); if (!OidIsValid(opno)) return NULL; } op = copyObject(op); /* * if we changed operator we need to adjust OpExpr as well */ if (op->opno != opno) { op->opno = opno; op->opfuncid = get_opcode(opno); } op->args = list_make2(lsecond(time_bucket->args), subst); } return &op->xpr; } /* * Since baserestrictinfo is not yet set by the planner, we have to derive * it ourselves. It's safe for us to miss some restrict info clauses (this * will just result in more chunks being included) so this does not need * to be as comprehensive as the PG native derivation. This is inspired * by the derivation in `deconstruct_recurse` in PG */ static Node * process_quals(Node *quals, CollectQualCtx *ctx, bool is_outer_join) { ListCell *lc; ListCell *prev pg_attribute_unused() = NULL; List *additional_quals = NIL; for (lc = list_head((List *) quals); lc != NULL; prev = lc, lc = lnext((List *) quals, lc)) { Expr *qual = lfirst(lc); Relids relids = pull_varnos(ctx->root, (Node *) qual); int num_rels = bms_num_members(relids); /* stop processing if not for current rel */ if (num_rels != 1 || !bms_is_member(ctx->rel->relid, relids)) continue; if (IsA(qual, OpExpr) && list_length(castNode(OpExpr, qual)->args) == 2) { OpExpr *op = castNode(OpExpr, qual); Expr *left = linitial(op->args); Expr *right = lsecond(op->args); if ((IsA(left, Var) && is_timestamptz_op_interval(right)) || (IsA(right, Var) && is_timestamptz_op_interval(left))) { /* * check for constraints with TIMESTAMPTZ OP INTERVAL calculations */ qual = (Expr *) constify_timestamptz_op_interval(ctx->root, op); } else { /* * check for time_bucket comparisons * time_bucket(Const, time_colum) > Const */ Expr *transformed = ts_transform_time_bucket_comparison(qual); if (transformed != NULL) { /* * if we could transform the expression we add it to the list of * quals so it can be used as an index condition */ additional_quals = lappend(additional_quals, transformed); /* * Also use the transformed qual for chunk exclusion. */ qual = transformed; } } } /* Do not include this restriction if this is an outer join. Including * the restriction would exclude chunks and thus rows of the outer * relation when it should show all rows */ if (!is_outer_join) ctx->restrictions = lappend(ctx->restrictions, make_simple_restrictinfo(ctx->root, qual)); } return (Node *) list_concat((List *) quals, additional_quals); } static Node * timebucket_annotate(Node *quals, CollectQualCtx *ctx) { ListCell *lc; List *additional_quals = NIL; foreach (lc, castNode(List, quals)) { Expr *qual = lfirst(lc); Relids relids = pull_varnos(ctx->root, (Node *) qual); int num_rels = bms_num_members(relids); /* stop processing if not for current rel */ if (num_rels != 1 || !bms_is_member(ctx->rel->relid, relids)) continue; /* * check for time_bucket comparisons * time_bucket(Const, time_colum) > Const */ Expr *transformed = ts_transform_time_bucket_comparison(qual); if (transformed != NULL) { /* * if we could transform the expression we add it to the list of * quals so it can be used as an index condition */ additional_quals = lappend(additional_quals, transformed); /* * Also use the transformed qual for chunk exclusion. */ qual = transformed; } ctx->restrictions = lappend(ctx->restrictions, make_simple_restrictinfo(ctx->root, qual)); } return (Node *) list_concat((List *) quals, additional_quals); } /* * collect JOIN information * * This function adds information to two lists in the CollectQualCtx * * join_conditions * * This list contains all equality join conditions and is used by * ChunkAppend to decide whether the ordered append optimization * can be applied. * * propagate_conditions * * This list contains toplevel or INNER JOIN equality conditions. * This list is used for propagating quals to the other side of * a JOIN. */ static void collect_join_quals(Node *quals, CollectQualCtx *ctx, bool can_propagate) { ListCell *lc; foreach (lc, (List *) quals) { Expr *qual = lfirst(lc); Relids relids = pull_varnos(ctx->root, (Node *) qual); int num_rels = bms_num_members(relids); /* * collect quals to propagate to join relations */ if (num_rels == 1 && can_propagate && IsA(qual, OpExpr) && list_length(castNode(OpExpr, qual)->args) == 2) ctx->all_quals = lappend(ctx->all_quals, qual); if (!bms_is_member(ctx->rel->relid, relids)) continue; /* collect equality JOIN conditions for current rel */ if (num_rels == 2 && IsA(qual, OpExpr) && list_length(castNode(OpExpr, qual)->args) == 2) { OpExpr *op = castNode(OpExpr, qual); Expr *left = linitial(op->args); Expr *right = lsecond(op->args); if (IsA(left, Var) && IsA(right, Var)) { Var *ht_var = castNode(Var, (Index) castNode(Var, left)->varno == ctx->rel->relid ? left : right); TypeCacheEntry *tce = lookup_type_cache(ht_var->vartype, TYPECACHE_EQ_OPR); if (op->opno == tce->eq_opr) { ctx->join_conditions = lappend(ctx->join_conditions, op); if (can_propagate) ctx->propagate_conditions = lappend(ctx->propagate_conditions, op); } } continue; } } } static bool collect_quals_walker(Node *node, CollectQualCtx *ctx) { if (node == NULL) return false; if (IsA(node, FromExpr)) { FromExpr *f = castNode(FromExpr, node); f->quals = process_quals(f->quals, ctx, false); /* if this is a nested join we don't propagate join quals */ collect_join_quals(f->quals, ctx, ctx->join_level == 0); } else if (IsA(node, JoinExpr)) { JoinExpr *j = castNode(JoinExpr, node); j->quals = process_quals(j->quals, ctx, IS_OUTER_JOIN(j->jointype)); collect_join_quals(j->quals, ctx, ctx->join_level == 0 && !IS_OUTER_JOIN(j->jointype)); if (IS_OUTER_JOIN(j->jointype)) { ctx->join_level++; bool result = expression_tree_walker(node, collect_quals_walker, ctx); ctx->join_level--; return result; } } return expression_tree_walker(node, collect_quals_walker, ctx); } static int chunk_cmp_chunk_reloid(const void *c1, const void *c2) { Oid lhs = (*(Chunk **) c1)->table_id; Oid rhs = (*(Chunk **) c2)->table_id; if (lhs < rhs) return -1; if (lhs > rhs) return 1; return 0; } static Chunk ** find_children_chunks(HypertableRestrictInfo *hri, Hypertable *ht, bool include_osm, unsigned int *num_chunks) { /* * Unlike find_all_inheritors we do not include parent because if there * are restrictions the parent table cannot fulfill them and since we do * have a trigger blocking inserts on the parent table it cannot contain * any rows. */ Chunk **chunks = ts_hypertable_restrict_info_get_chunks(hri, ht, include_osm, num_chunks); /* * Sort the chunks by oid ascending to roughly match the order provided * by find_inheritance_children. This is mostly needed to avoid test * reference changes. */ qsort((void *) chunks, *num_chunks, sizeof(Chunk *), chunk_cmp_chunk_reloid); return chunks; } static bool should_order_append(PlannerInfo *root, RelOptInfo *rel, Hypertable *ht, List *join_conditions, int *order_attno, bool *reverse) { /* check if optimizations are enabled */ if (!ts_guc_enable_optimizations || !ts_guc_enable_ordered_append || !ts_guc_enable_chunk_append) return false; /* * only do this optimization for hypertables with 1 dimension and queries * with an ORDER BY clause */ if (root->parse->sortClause == NIL) return false; return ts_ordered_append_should_optimize(root, rel, ht, join_conditions, order_attno, reverse); } /** * Get chunks from restrict info. * * If appends are returned in order appends_ordered on rel->fdw_private is set to true. * To make verifying pathkeys easier in set_rel_pathlist the hypertable attno of the column * ordered by is stored in rel->fdw_private. * If the hypertable uses space partitioning the nested oids are stored in nested_oids * on rel->fdw_private when appends are ordered. */ static Chunk ** get_chunks(CollectQualCtx *ctx, PlannerInfo *root, RelOptInfo *rel, Hypertable *ht, bool include_osm, unsigned int *num_chunks) { bool reverse; int order_attno; HypertableRestrictInfo *hri = ts_hypertable_restrict_info_create(rel, ht); /* * This is where the magic happens: use our HypertableRestrictInfo * infrastructure to deduce the appropriate chunks using our range * exclusion */ ts_hypertable_restrict_info_add(hri, root, ctx->restrictions); /* * If fdw_private has not been setup by caller there is no point checking * for ordered append as we can't pass the required metadata in fdw_private * to signal that this is safe to transform in ordered append plan in * set_rel_pathlist. */ if (rel->fdw_private != NULL && should_order_append(root, rel, ht, ctx->join_conditions, &order_attno, &reverse)) { TimescaleDBPrivate *priv = ts_get_private_reloptinfo(rel); List **nested_oids = NULL; priv->appends_ordered = true; priv->order_attno = order_attno; /* * for space partitioning we need extra information about the * time slices of the chunks */ if (ht->space->num_dimensions > 1) nested_oids = &priv->nested_oids; return ts_hypertable_restrict_info_get_chunks_ordered(hri, ht, include_osm, NULL, reverse, nested_oids, num_chunks); } return find_children_chunks(hri, ht, include_osm, num_chunks); } static bool timebucket_annotate_walker(Node *node, CollectQualCtx *ctx) { if (node == NULL) return false; if (IsA(node, FromExpr)) { FromExpr *f = castNode(FromExpr, node); f->quals = timebucket_annotate(f->quals, ctx); } else if (IsA(node, JoinExpr)) { JoinExpr *j = castNode(JoinExpr, node); j->quals = timebucket_annotate(j->quals, ctx); } return expression_tree_walker(node, timebucket_annotate_walker, ctx); } void ts_plan_expand_timebucket_annotate(PlannerInfo *root, RelOptInfo *rel) { CollectQualCtx ctx = { .root = root, .rel = rel, .restrictions = NIL, .all_quals = NIL, .join_conditions = NIL, .propagate_conditions = NIL, }; /* Walk the tree and find restrictions or chunk exclusion functions */ timebucket_annotate_walker((Node *) root->parse->jointree, &ctx); if (ctx.propagate_conditions != NIL) propagate_join_quals(root, rel, &ctx); } /* Inspired by expand_inherited_rtentry but expands * a hypertable chunks into an append relation. */ void ts_plan_expand_hypertable_chunks(Hypertable *ht, PlannerInfo *root, RelOptInfo *rel, bool include_osm) { RangeTblEntry *rte = rt_fetch(rel->relid, root->parse->rtable); Oid parent_oid = rte->relid; Relation oldrelation; Query *parse = root->parse; Index rti = rel->relid; List *appinfos = NIL; CollectQualCtx ctx = { .root = root, .rel = rel, .restrictions = NIL, .all_quals = NIL, .join_conditions = NIL, .propagate_conditions = NIL, .join_level = 0, }; Index first_chunk_index = 0; /* double check our permissions are valid */ Assert(rti != (Index) parse->resultRelation); /* Walk the tree and find restrictions */ collect_quals_walker((Node *) root->parse->jointree, &ctx); /* check join_level bookkeeping is balanced */ Assert(ctx.join_level == 0); if (ctx.propagate_conditions != NIL) propagate_join_quals(root, rel, &ctx); Chunk **chunks = NULL; unsigned int num_chunks = 0; chunks = get_chunks(&ctx, root, rel, ht, include_osm, &num_chunks); /* Can have zero chunks. */ Assert(num_chunks == 0 || chunks != NULL); /* nothing to do here if we have no chunks */ if (!num_chunks) return; /* * We need to mark the RowMark for the hypertable as parent * to trigger inclusion of tableoid to allow for correctly * identifying tuples from individual chunks. */ PlanRowMark *oldrc = get_plan_rowmark(root->rowMarks, rti); if (oldrc) { oldrc->isParent = true; } for (unsigned int i = 0; i < num_chunks; i++) { /* * Add the information about chunks to the baserel info cache for * classify_relation(). */ ts_add_baserel_cache_entry_for_chunk(chunks[i]->table_id, ht); } oldrelation = table_open(parent_oid, NoLock); /* * the simple_*_array structures have already been set, we need to add the * children to them. */ expand_planner_arrays(root, num_chunks); for (unsigned int i = 0; i < num_chunks; i++) { Chunk *chunk = chunks[i]; Oid child_oid = chunk->table_id; Relation newrelation; RangeTblEntry *childrte; Index child_rtindex; AppendRelInfo *appinfo; LOCKMODE chunk_lock = rte->rellockmode; /* Open rel if needed */ Assert(child_oid != parent_oid); newrelation = table_open(child_oid, chunk_lock); /* chunks cannot be temp tables */ Assert(!RELATION_IS_OTHER_TEMP(newrelation)); /* * Build an RTE for the child, and attach to query's rangetable list. * We copy most fields of the parent's RTE, but replace relation OID * and relkind, and set inh = false. Also, set requiredPerms to zero * since all required permissions checks are done on the original RTE. * Likewise, set the child's securityQuals to empty, because we only * want to apply the parent's RLS conditions regardless of what RLS * properties individual children may have. (This is an intentional * choice to make inherited RLS work like regular permissions checks.) * The parent securityQuals will be propagated to children along with * other base restriction clauses, so we don't need to do it here. */ childrte = copyObject(rte); childrte->relid = child_oid; childrte->relkind = newrelation->rd_rel->relkind; childrte->inh = false; /* clear the magic bit */ childrte->ctename = NULL; #if PG16_LT childrte->requiredPerms = 0; #else /* Since PG16, the permission info is maintained separately. Unlink * the old perminfo from the RTE to disable permission checking. */ childrte->perminfoindex = 0; #endif childrte->securityQuals = NIL; parse->rtable = lappend(parse->rtable, childrte); child_rtindex = list_length(parse->rtable); if (first_chunk_index == 0) first_chunk_index = child_rtindex; root->simple_rte_array[child_rtindex] = childrte; Assert(root->simple_rel_array[child_rtindex] == NULL); appinfo = makeNode(AppendRelInfo); appinfo->parent_relid = rti; appinfo->child_relid = child_rtindex; appinfo->parent_reltype = oldrelation->rd_rel->reltype; appinfo->child_reltype = newrelation->rd_rel->reltype; ts_make_inh_translation_list(oldrelation, newrelation, child_rtindex, appinfo); appinfo->parent_reloid = parent_oid; appinfos = lappend(appinfos, appinfo); /* Close child relations, but keep locks */ if (child_oid != parent_oid) table_close(newrelation, NoLock); } table_close(oldrelation, NoLock); ts_add_append_rel_infos(root, appinfos); /* PostgreSQL will not set up the child rels for use, due to the games * we're playing with inheritance, so we must do it ourselves. * build_simple_rel will look things up in the append_rel_array, so we can * only use it after that array has been set up. */ for (unsigned int i = 0; i < num_chunks; i++) { Index child_rtindex = first_chunk_index + i; /* build_simple_rel will add the child to the relarray */ RelOptInfo *child_rel = build_simple_rel(root, child_rtindex, rel); /* * Can't touch fdw_private for OSM chunks, it might be managed by the * OSM extension, or, in the tests, by postgres_fdw. */ Chunk *chunk = chunks[i]; if (!IS_OSM_CHUNK(chunk)) { Assert(chunk->table_id == root->simple_rte_array[child_rtindex]->relid); ts_get_private_reloptinfo(child_rel)->cached_chunk_struct = chunk; } } } static bool restrictinfo_has_qual(List *restrictions, OpExpr *qual) { ListCell *lc_ri; foreach (lc_ri, restrictions) { if (equal(castNode(RestrictInfo, lfirst(lc_ri))->clause, (Expr *) qual)) return true; } return false; } void propagate_join_quals(PlannerInfo *root, RelOptInfo *rel, CollectQualCtx *ctx) { ListCell *lc; if (!ts_guc_enable_qual_propagation) return; /* propagate join constraints */ foreach (lc, ctx->propagate_conditions) { ListCell *lc_qual; OpExpr *op = lfirst(lc); Var *rel_var, *other_var; /* * join_conditions only has OpExpr with 2 Var as arguments * this is enforced in process_quals */ Assert(IsA(op, OpExpr) && list_length(castNode(OpExpr, op)->args) == 2); Assert(IsA(linitial(op->args), Var) && IsA(lsecond(op->args), Var)); /* * check this join condition refers to current hypertable * our Var might be on either side of the expression */ if ((Index) linitial_node(Var, op->args)->varno == rel->relid) { rel_var = linitial_node(Var, op->args); other_var = lsecond_node(Var, op->args); } else if ((Index) lsecond_node(Var, op->args)->varno == rel->relid) { rel_var = lsecond_node(Var, op->args); other_var = linitial_node(Var, op->args); } else continue; foreach (lc_qual, ctx->all_quals) { OpExpr *qual = lfirst(lc_qual); Expr *left = linitial(qual->args); Expr *right = lsecond(qual->args); OpExpr *propagated; /* * check this is Var OP Expr / Expr OP Var * Var needs to reference the relid of the JOIN condition and * Expr must not contain volatile functions */ if (IsA(left, Var) && castNode(Var, left)->varno == other_var->varno && castNode(Var, left)->varattno == other_var->varattno && !IsA(right, Var) && !contain_volatile_functions((Node *) right)) { propagated = copyObject(qual); propagated->args = list_make2(rel_var, lsecond(propagated->args)); } else if (IsA(right, Var) && castNode(Var, right)->varno == other_var->varno && castNode(Var, right)->varattno == other_var->varattno && !IsA(left, Var) && !contain_volatile_functions((Node *) left)) { propagated = copyObject(qual); propagated->args = list_make2(linitial(propagated->args), rel_var); } else continue; /* * check if this is a new qual */ if (restrictinfo_has_qual(ctx->restrictions, propagated)) continue; Relids relids = pull_varnos(ctx->root, (Node *) propagated); RestrictInfo *restrictinfo; restrictinfo = make_restrictinfo_compat(root, (Expr *) propagated, true, false, false, false, false, ctx->root->qual_security_level, relids, NULL, NULL, NULL); ctx->restrictions = lappend(ctx->restrictions, restrictinfo); /* * since hypertable expansion happens later, the propagated * constraints will not be pushed down to the actual scans but stay * as join filter. So we add them either as join filter or to * baserestrictinfo depending on whether they reference only * the currently processed relation or multiple relations. */ if (bms_num_members(relids) == 1 && bms_is_member(rel->relid, relids)) { if (!restrictinfo_has_qual(rel->baserestrictinfo, propagated)) rel->baserestrictinfo = lappend(rel->baserestrictinfo, restrictinfo); } else { root->parse->jointree->quals = (Node *) lappend((List *) root->parse->jointree->quals, propagated); } } } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/partialize.c���������������������������������������������������������0000664�0000000�0000000�00000020737�15100345067�0020622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <nodes/nodeFuncs.h> #include <nodes/nodes.h> #include <nodes/pathnodes.h> #include <nodes/pg_list.h> #include <optimizer/clauses.h> #include <optimizer/optimizer.h> #include <optimizer/planner.h> #include <parser/parse_func.h> #include <utils/lsyscache.h> #include "cross_module_fn.h" #include "debug_assert.h" #include "estimate.h" #include "extension_constants.h" #include "nodes/print.h" #include "partialize.h" #include "utils.h" #define TS_PARTIALFN "partialize_agg" typedef struct PartializeWalkerState { bool found_partialize; bool found_non_partial_agg; bool looking_for_agg; Oid fnoid; PartializeAggFixAggref fix_aggref; } PartializeWalkerState; /* * Look for the partialize function in a target list and mark the wrapped * aggregate as a partial aggregate. * * The partialize function is an expression of the form: * * _timescaledb_functions.partialize_agg(avg(temp)) * * where avg(temp) can be replaced by any aggregate that can be partialized. * * When such an expression is found, this function will mark the Aggref node * for the aggregate as partial. */ static bool check_for_partialize_function_call(Node *node, PartializeWalkerState *state) { if (node == NULL) return false; /* * If the last node we saw was partialize, the next one must be aggregate * we're partializing */ if (state->looking_for_agg && !IsA(node, Aggref)) elog(ERROR, "the input to partialize must be an aggregate"); if (IsA(node, Aggref)) { Aggref *aggref = castNode(Aggref, node); if (state->looking_for_agg) { state->looking_for_agg = false; if (state->fix_aggref != TS_DO_NOT_FIX_AGGSPLIT) { if (state->fix_aggref == TS_FIX_AGGSPLIT_SIMPLE && aggref->aggsplit == AGGSPLIT_SIMPLE) { aggref->aggsplit = AGGSPLIT_INITIAL_SERIAL; } else if (state->fix_aggref == TS_FIX_AGGSPLIT_FINAL && aggref->aggsplit == AGGSPLIT_FINAL_DESERIAL) { aggref->aggsplit = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE | AGGSPLITOP_SERIALIZE | AGGSPLITOP_SKIPFINAL; } if (aggref->aggtranstype == INTERNALOID) aggref->aggtype = BYTEAOID; else aggref->aggtype = aggref->aggtranstype; } } /* We currently cannot handle cases like * SELECT sum(i), partialize(sum(i)) ... * * We check for non-partial aggs to ensure that if any of the aggregates * in a statement are partialized, all of them have to be. */ else if (aggref->aggsplit != AGGSPLIT_INITIAL_SERIAL) state->found_non_partial_agg = true; } else if (IsA(node, FuncExpr) && ((FuncExpr *) node)->funcid == state->fnoid) { state->found_partialize = true; state->looking_for_agg = true; } return expression_tree_walker(node, check_for_partialize_function_call, state); } bool has_partialize_function(Node *node, PartializeAggFixAggref fix_aggref) { Oid partialfnoid = InvalidOid; Oid argtyp[] = { ANYELEMENTOID }; PartializeWalkerState state = { .found_partialize = false, .found_non_partial_agg = false, .looking_for_agg = false, .fix_aggref = fix_aggref, .fnoid = InvalidOid }; List *name = list_make2(makeString(FUNCTIONS_SCHEMA_NAME), makeString(TS_PARTIALFN)); partialfnoid = LookupFuncName(name, lengthof(argtyp), argtyp, false); Assert(OidIsValid(partialfnoid)); state.fnoid = partialfnoid; check_for_partialize_function_call(node, &state); if (state.found_partialize && state.found_non_partial_agg) elog(ERROR, "cannot mix partialized and non-partialized aggregates in the same statement"); return state.found_partialize; } /* * Modify all AggPaths in relation to use partial aggregation. * * Note that there can be both parallel (split) paths and non-parallel * (non-split) paths suggested at this stage, but all of them refer to the * same Aggrefs. Depending on the Path picked, the Aggrefs are "fixed up" by * the PostgreSQL planner at a later stage in planner (in setrefs.c) to match * the choice of Path. For this reason, it is not possible to modify Aggrefs * at this stage AND keep both type of Paths. Therefore, if a split Path is * found, then prune the non-split path. */ static bool partialize_agg_paths(RelOptInfo *rel) { ListCell *lc; bool has_combine = false; List *aggsplit_simple_paths = NIL; List *aggsplit_final_paths = NIL; List *other_paths = NIL; foreach (lc, rel->pathlist) { Path *path = lfirst(lc); if (IsA(path, AggPath)) { AggPath *agg = castNode(AggPath, path); if (agg->aggsplit == AGGSPLIT_SIMPLE) { agg->aggsplit = AGGSPLIT_INITIAL_SERIAL; aggsplit_simple_paths = lappend(aggsplit_simple_paths, path); } else if (agg->aggsplit == AGGSPLIT_FINAL_DESERIAL) { has_combine = true; aggsplit_final_paths = lappend(aggsplit_final_paths, path); } else { other_paths = lappend(other_paths, path); } } else { other_paths = lappend(other_paths, path); } } if (aggsplit_final_paths != NIL) rel->pathlist = list_concat(other_paths, aggsplit_final_paths); else rel->pathlist = list_concat(other_paths, aggsplit_simple_paths); return has_combine; } /* * Turn an aggregate relation into a partial aggregate relation if aggregates * are enclosed by the partialize_agg function. * * The partialize_agg function can "manually" partialize an aggregate. For * instance: * * SELECT time_bucket('1 day', time), device, * _timescaledb_functions.partialize_agg(avg(temp)) * GROUP BY 1, 2; * * Would compute the partial aggregate of avg(temp). * * The plan to compute the relation must be either entirely non-partial or * entirely partial, so it is not possible to mix partials and * non-partials. Note that aggregates can appear in both the target list and the * HAVING clause, for instance: * * SELECT time_bucket('1 day', time), device, avg(temp) * GROUP BY 1, 2 * HAVING avg(temp) > 3; * * Regular partial aggregations executed by the planner (i.e., those not induced * by the partialize_agg function) have their HAVING aggregates transparently * moved to the target list during planning so that the finalize node can use it * when applying the final filter on the resulting groups, obviously omitting * the extra columns in the final output/projection. However, it doesn't make * much sense to transparently do that when partializing with partialize_agg * since it would be odd to return more columns than requested by the * user. Therefore, the caller would have to do that manually. This, in fact, is * also done when materializing continuous aggregates. * * For this reason, HAVING clauses with partialize_agg are blocked, except in * cases where the planner transparently reduces the having expression to a * simple filter (e.g., HAVING device > 3). In such cases, the HAVING clause is * removed and replaced by a filter on the input. * Returns : true if partial aggs were found, false otherwise. * Modifies : output_rel if partials aggs were found. */ bool ts_plan_process_partialize_agg(PlannerInfo *root, RelOptInfo *output_rel) { Query *parse = root->parse; bool found_partialize_agg_func; Assert(IS_UPPER_REL(output_rel)); if (CMD_SELECT != parse->commandType || !parse->hasAggs) return false; found_partialize_agg_func = has_partialize_function((Node *) parse->targetList, TS_DO_NOT_FIX_AGGSPLIT); if (!found_partialize_agg_func) return false; /* partialize_agg() function found. Now turn simple (non-partial) aggs * (AGGSPLIT_SIMPLE) into partials. If the Agg is a combine/final we want * to do the combine but not the final step. However, it is not possible * to change that here at the Path stage because the PostgreSQL planner * will hit an assertion, so we defer that to the plan stage in planner.c. */ bool is_combine = partialize_agg_paths(output_rel); if (!is_combine) has_partialize_function((Node *) parse->targetList, TS_FIX_AGGSPLIT_SIMPLE); /* We cannot check root->hasHavingqual here because sometimes the * planner can replace the HAVING clause with a simple filter. But * root->hashavingqual stays true to remember that the query had a * HAVING clause initially. */ if (NULL != parse->havingQual) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot partialize aggregate with HAVING clause"), errhint("Any aggregates in a HAVING clause need to be partialized in the output " "target list."))); return true; } ���������������������������������timescaledb-2.23.0/src/planner/partialize.h���������������������������������������������������������0000664�0000000�0000000�00000000461�15100345067�0020617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pathnodes.h> #include <optimizer/planner.h> #include "chunk.h" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/planner.c������������������������������������������������������������0000664�0000000�0000000�00000155040�15100345067�0020111�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/tsmapi.h> #include <access/xact.h> #include <catalog/namespace.h> #include <commands/extension.h> #include <executor/nodeAgg.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/parsenodes.h> #include <nodes/plannodes.h> #include <optimizer/appendinfo.h> #include <optimizer/clauses.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/plancat.h> #include <optimizer/planner.h> #include <optimizer/restrictinfo.h> #include <optimizer/tlist.h> #include <parser/parse_param.h> #include <parser/parse_relation.h> #include <parser/parsetree.h> #include <utils/elog.h> #include <utils/fmgroids.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/selfuncs.h> #include <utils/timestamp.h> #include <math.h> #include "annotations.h" #include "chunk.h" #include "cross_module_fn.h" #include "debug_assert.h" #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "extension.h" #include "func_cache.h" #include "guc.h" #include "hypertable.h" #include "hypertable_cache.h" #include "import/allpaths.h" #include "license_guc.h" #include "nodes/chunk_append/chunk_append.h" #include "nodes/constraint_aware_append/constraint_aware_append.h" #include "nodes/modify_hypertable.h" #include "partitioning.h" #include "planner/partialize.h" #include "planner/planner.h" #include "sort_transform.h" #include "utils.h" #include "compat/compat.h" #include <common/hashfn.h> #ifdef USE_TELEMETRY #include "telemetry/functions.h" #endif /* define parameters necessary to generate the baserel info hash table interface */ typedef struct BaserelInfoEntry { Oid reloid; Hypertable *ht; uint32 status; /* hash status */ } BaserelInfoEntry; #define SH_PREFIX BaserelInfo #define SH_ELEMENT_TYPE BaserelInfoEntry #define SH_KEY_TYPE Oid #define SH_KEY reloid #define SH_EQUAL(tb, a, b) ((a) == (b)) #define SH_HASH_KEY(tb, key) murmurhash32(key) #define SH_SCOPE static #define SH_DECLARE #define SH_DEFINE // We don't need most of the generated functions and there is no way to not // generate them. #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-function" #endif // Generate the baserel info hash table functions. #include "lib/simplehash.h" #ifdef __GNUC__ #pragma GCC diagnostic pop #endif void _planner_init(void); void _planner_fini(void); static planner_hook_type prev_planner_hook; static set_rel_pathlist_hook_type prev_set_rel_pathlist_hook; static get_relation_info_hook_type prev_get_relation_info_hook; static create_upper_paths_hook_type prev_create_upper_paths_hook; static void cagg_reorder_groupby_clause(RangeTblEntry *subq_rte, Index rtno, List *outer_sortcl, List *outer_tlist); /* * We mark range table entries (RTEs) in a query with TS_CTE_EXPAND if we'd like * to control table expansion ourselves. We exploit the ctename for this purpose * since it is not used for regular (base) relations. * * Note that we cannot use this mark as a general way to identify hypertable * RTEs. Child RTEs, for instance, will inherit this value from the parent RTE * during expansion. While we can prevent this happening in our custom table * expansion, we also have to account for the case when our custom expansion * is turned off with a GUC. */ static const char *TS_CTE_EXPAND = "ts_expand"; static const char *TS_FK_EXPAND = "ts_fk_expand"; /* * A simplehash hash table that records the chunks and their corresponding * hypertables, and also the plain baserels. We use it to tell whether a * relation is a hypertable chunk, inside the classify_relation function. * It is valid inside the scope of timescaledb_planner(). * That function can be called recursively, e.g. when we evaluate a SQL function, * and this cache is initialized only at the top-level call. */ static struct BaserelInfo_hash *ts_baserel_info = NULL; /* * Add information about a chunk to the baserel info cache. Used to cache the * chunk info at the plan time chunk exclusion. */ void ts_add_baserel_cache_entry_for_chunk(Oid chunk_reloid, Hypertable *hypertable) { Assert(hypertable != NULL); Assert(ts_baserel_info != NULL); bool found = false; BaserelInfoEntry *entry = BaserelInfo_insert(ts_baserel_info, chunk_reloid, &found); if (found) { /* Already cached. */ Assert(entry->ht != NULL); return; } Assert(ts_chunk_get_hypertable_id_by_reloid(chunk_reloid) == hypertable->fd.id); /* Fill the cache entry. */ entry->ht = hypertable; } static void rte_mark_for_expansion(RangeTblEntry *rte) { Assert(rte->rtekind == RTE_RELATION); Assert(rte->ctename == NULL); rte->ctename = (char *) TS_CTE_EXPAND; rte->inh = false; } static void rte_mark_for_fk_expansion(RangeTblEntry *rte) { Assert(rte->rtekind == RTE_RELATION); Assert(rte->ctename == NULL); rte->ctename = (char *) TS_FK_EXPAND; /* * If this is for an FK lookup query inherit should be false * initially for hypertables. */ Assert(!rte->inh); } bool ts_rte_is_marked_for_expansion(const RangeTblEntry *rte) { if (NULL == rte->ctename) return false; if (rte->ctename == TS_CTE_EXPAND || rte->ctename == TS_FK_EXPAND) return true; return strcmp(rte->ctename, TS_CTE_EXPAND) == 0; } /* * Planner-global hypertable cache. * * Each invocation of the planner (and our hooks) should reference the same * cache object. Since we warm the cache when pre-processing the query (prior to * invoking the planner), we'd like to ensure that we use the same cache object * throughout the planning of that query so that we can trust that the cache * holds the objects it was warmed with. Since the planner can be invoked * recursively, we also need to stack and pop cache objects. */ static List *planner_hcaches = NIL; static Cache * planner_hcache_push(void) { Cache *hcache = ts_hypertable_cache_pin(); planner_hcaches = lcons(hcache, planner_hcaches); return hcache; } static void planner_hcache_pop(bool release) { Cache *hcache; Assert(list_length(planner_hcaches) > 0); hcache = linitial(planner_hcaches); planner_hcaches = list_delete_first(planner_hcaches); if (release) { ts_cache_release(&hcache); /* If we pop a stack and discover a new hypertable cache, the basrel * cache can contain invalid entries, so we reset it. */ if (planner_hcaches != NIL && hcache != linitial(planner_hcaches)) BaserelInfo_reset(ts_baserel_info); } } static bool planner_hcache_exists(void) { return planner_hcaches != NIL; } static Cache * planner_hcache_get(void) { if (planner_hcaches == NIL) return NULL; return (Cache *) linitial(planner_hcaches); } /* * Get the Hypertable corresponding to the given relid. * * This function gets a hypertable from a pre-warmed hypertable cache. If * noresolve is specified (true), then it will do a cache-only lookup (i.e., it * will not try to scan metadata for a new entry to put in the cache). This * allows fast lookups during planning to also determine if something is _not_ a * hypertable. */ Hypertable * ts_planner_get_hypertable(const Oid relid, const unsigned int flags) { Cache *cache = planner_hcache_get(); if (NULL == cache) return NULL; return ts_hypertable_cache_get_entry(cache, relid, flags); } bool ts_rte_is_hypertable(const RangeTblEntry *rte) { Hypertable *ht = ts_planner_get_hypertable(rte->relid, CACHE_FLAG_CHECK); return ht != NULL; } #define IS_UPDL_CMD(parse) \ ((parse)->commandType == CMD_UPDATE || (parse)->commandType == CMD_DELETE) typedef struct { Query *rootquery; Query *current_query; PlannerInfo *root; } PreprocessQueryContext; static void preprocess_fk_checks(Query *query, Cache *hcache, PreprocessQueryContext *context); void replace_now_mock_walker(PlannerInfo *root, Node *clause, Oid funcid) { /* whenever we encounter a FuncExpr with now(), replace it with the supplied funcid */ switch (nodeTag(clause)) { case T_FuncExpr: { if (is_valid_now_func(clause)) { FuncExpr *fe = castNode(FuncExpr, clause); fe->funcid = funcid; return; } break; } case T_OpExpr: { ListCell *lc; OpExpr *oe = castNode(OpExpr, clause); foreach (lc, oe->args) { replace_now_mock_walker(root, (Node *) lfirst(lc), funcid); } break; } case T_BoolExpr: { ListCell *lc; BoolExpr *be = castNode(BoolExpr, clause); foreach (lc, be->args) { replace_now_mock_walker(root, (Node *) lfirst(lc), funcid); } break; } default: return; } } /* * Preprocess the query tree, including, e.g., subqueries. * * Preprocessing includes: * * 1. Identifying all range table entries (RTEs) that reference * hypertables. This will also warm the hypertable cache for faster lookup * of both hypertables (cache hit) and non-hypertables (cache miss), * without having to scan the metadata in either case. * * 2. Turning off inheritance for hypertable RTEs that we expand ourselves. * * 3. Reordering of GROUP BY clauses for continuous aggregates. * * 4. Constifying now() expressions for primary time dimension. */ static bool preprocess_query(Node *node, PreprocessQueryContext *context) { if (node == NULL) return false; if (IsA(node, FromExpr) && ts_guc_enable_optimizations) { FromExpr *from = castNode(FromExpr, node); if (from->quals) { if (ts_guc_enable_now_constify) { from->quals = ts_constify_now(context->root, context->current_query->rtable, from->quals); #ifdef TS_DEBUG /* * only replace if GUC is also set. This is used for testing purposes only, * so no need to change the output for other tests in DEBUG builds */ if (ts_current_timestamp_mock != NULL && strlen(ts_current_timestamp_mock) != 0) { Oid funcid_mock; const char *funcname = "ts_now_mock()"; funcid_mock = DatumGetObjectId( DirectFunctionCall1(regprocedurein, CStringGetDatum(funcname))); replace_now_mock_walker(context->root, from->quals, funcid_mock); } #endif } /* * We only amend space constraints for UPDATE/DELETE and SELECT FOR UPDATE * as for normal SELECT we use our own hypertable expansion which can handle * constraints on hashed space dimensions without further help. */ if (context->current_query->commandType != CMD_SELECT || context->current_query->rowMarks != NIL) { from->quals = ts_add_space_constraints(context->root, context->current_query->rtable, from->quals); } } } else if (IsA(node, Query)) { Query *query = castNode(Query, node); Query *prev_query; Cache *hcache = planner_hcache_get(); ListCell *lc; Index rti = 1; bool ret; if (ts_guc_enable_foreign_key_propagation) { preprocess_fk_checks(query, hcache, context); } foreach (lc, query->rtable) { RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc); Hypertable *ht; switch (rte->rtekind) { case RTE_SUBQUERY: if (ts_guc_enable_optimizations && ts_guc_enable_cagg_reorder_groupby && query->commandType == CMD_SELECT) { /* applicable to selects on continuous aggregates */ List *outer_tlist = query->targetList; List *outer_sortcl = query->sortClause; cagg_reorder_groupby_clause(rte, rti, outer_sortcl, outer_tlist); } break; case RTE_RELATION: /* This lookup will warm the cache with all hypertables in the query */ ht = ts_hypertable_cache_get_entry(hcache, rte->relid, CACHE_FLAG_MISSING_OK); if (ht) { /* Mark hypertable RTEs we'd like to expand ourselves */ if (ts_guc_enable_optimizations && ts_guc_enable_constraint_exclusion && !IS_UPDL_CMD(context->rootquery) && query->resultRelation == 0 && query->rowMarks == NIL && rte->inh) rte_mark_for_expansion(rte); if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { int compr_htid = ht->fd.compressed_hypertable_id; /* Also warm the cache with the compressed * companion hypertable */ ts_hypertable_cache_get_entry_by_id(hcache, compr_htid); } } else { /* To properly keep track of SELECT FROM ONLY <chunk> we * have to mark the rte here because postgres will set * rte->inh to false (when it detects the chunk has no * children which is true for all our chunks) before it * reaches set_rel_pathlist hook. But chunks from queries * like SELECT .. FROM ONLY <chunk> has rte->inh set to * false and other chunks have rte->inh set to true. * We want to distinguish between the two cases here by * marking the chunk when rte->inh is true. */ Chunk *chunk = ts_chunk_get_by_relid(rte->relid, false); if (chunk && rte->inh) rte_mark_for_expansion(rte); } break; default: break; } rti++; } prev_query = context->current_query; context->current_query = query; ret = query_tree_walker(query, preprocess_query, context, 0); context->current_query = prev_query; return ret; } return expression_tree_walker(node, preprocess_query, context); } /* * Detect FOREIGN KEY lookup queries and mark the RTE for expansion. * Unfortunately postgres will create lookup queries for foreign keys * with `ONLY` preventing hypertable expansion. Only for declarative * partitioned tables the queries will be created without `ONLY`. * We try to detect these queries here and undo the `ONLY` flag for * these specific queries. * * The implementation of this on the postgres side can be found in * src/backend/utils/adt/ri_triggers.c */ static void preprocess_fk_checks(Query *query, Cache *hcache, PreprocessQueryContext *context) { /* * RI_FKey_cascade_del * * DELETE FROM [ONLY] <fktable> WHERE $1 = fkatt1 [AND ...] */ if (query->commandType == CMD_DELETE && list_length(query->rtable) == 1 && query->jointree->quals && IsA(query->jointree->quals, OpExpr) && (context->root->glob->boundParams || query_contains_extern_params(query))) { RangeTblEntry *rte = linitial_node(RangeTblEntry, query->rtable); if (!rte->inh && rte->rtekind == RTE_RELATION) { Hypertable *ht = ts_hypertable_cache_get_entry(hcache, rte->relid, CACHE_FLAG_MISSING_OK); if (ht) { rte->inh = true; } } } /* * RI_FKey_cascade_upd * * UPDATE [ONLY] <fktable> SET fkatt1 = $1 [, ...] * WHERE $n = fkatt1 [AND ...] */ if (query->commandType == CMD_UPDATE && list_length(query->rtable) == 1 && query->jointree->quals && IsA(query->jointree->quals, OpExpr) && (context->root->glob->boundParams || query_contains_extern_params(query))) { RangeTblEntry *rte = linitial_node(RangeTblEntry, query->rtable); if (!rte->inh && rte->rtekind == RTE_RELATION) { Hypertable *ht = ts_hypertable_cache_get_entry(hcache, rte->relid, CACHE_FLAG_MISSING_OK); if (ht) { rte->inh = true; } } } /* * RI_FKey_check * * The RI_FKey_check query string built is * SELECT 1 FROM [ONLY] <pktable> x WHERE pkatt1 = $1 [AND ...] * FOR KEY SHARE OF x */ if (query->commandType == CMD_SELECT && query->hasForUpdate && list_length(query->rtable) == 1 && (context->root->glob->boundParams || query_contains_extern_params(query))) { RangeTblEntry *rte = linitial_node(RangeTblEntry, query->rtable); if (!rte->inh && rte->rtekind == RTE_RELATION && rte->rellockmode == RowShareLock && list_length(query->jointree->fromlist) == 1 && query->jointree->quals && strcmp(rte->eref->aliasname, "x") == 0) { Hypertable *ht = ts_hypertable_cache_get_entry(hcache, rte->relid, CACHE_FLAG_MISSING_OK); if (ht) { rte_mark_for_fk_expansion(rte); if (TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) query->rowMarks = NIL; } } } /* * RI_Initial_Check query * * The RI_Initial_Check query string built is: * SELECT fk.keycols FROM [ONLY] relname fk * LEFT OUTER JOIN [ONLY] pkrelname pk * ON (pk.pkkeycol1=fk.keycol1 [AND ...]) * WHERE pk.pkkeycol1 IS NULL AND * For MATCH SIMPLE: * (fk.keycol1 IS NOT NULL [AND ...]) * For MATCH FULL: * (fk.keycol1 IS NOT NULL [OR ...]) */ if (query->commandType == CMD_SELECT && list_length(query->rtable) == 3) { RangeTblEntry *rte1 = linitial_node(RangeTblEntry, query->rtable); RangeTblEntry *rte2 = lsecond_node(RangeTblEntry, query->rtable); if (!rte1->inh && !rte2->inh && rte1->rtekind == RTE_RELATION && rte2->rtekind == RTE_RELATION && strcmp(rte1->eref->aliasname, "fk") == 0 && strcmp(rte2->eref->aliasname, "pk") == 0) { if (ts_hypertable_cache_get_entry(hcache, rte1->relid, CACHE_FLAG_MISSING_OK)) { rte_mark_for_fk_expansion(rte1); } if (ts_hypertable_cache_get_entry(hcache, rte2->relid, CACHE_FLAG_MISSING_OK)) { rte_mark_for_fk_expansion(rte2); } } } } static PlannedStmt * timescaledb_planner(Query *parse, const char *query_string, int cursor_opts, ParamListInfo bound_params) { PlannedStmt *stmt; ListCell *lc; /* * Volatile is needed because these are the local variables that are * modified between setjmp/longjmp calls. */ volatile bool reset_baserel_info = false; /* * If we are in an aborted transaction, reject all queries. * While this state will not happen during normal operation it * can happen when executing plpgsql procedures. */ if (IsAbortedTransactionBlockState()) ereport(ERROR, (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION), errmsg("current transaction is aborted, " "commands ignored until end of transaction block"))); planner_hcache_push(); if (ts_baserel_info == NULL) { /* * The calls to timescaledb_planner can be recursive (e.g. when * evaluating an immutable SQL function at planning time). We want to * create and destroy the per-query baserel info table only at the * top-level call, hence this flag. */ reset_baserel_info = true; /* * This is a per-query cache, so we create it in the current memory * context for the top-level call of this function, which hopefully * should exist for the duration of the query. Message or portal * memory contexts could also be suitable, but they don't exist for * SPI calls. */ ts_baserel_info = BaserelInfo_create(CurrentMemoryContext, /* nelements = */ 1, /* private_data = */ NULL); } PG_TRY(); { PreprocessQueryContext context = { 0 }; PlannerGlobal glob = { .boundParams = bound_params, }; PlannerInfo root = { .glob = &glob, }; context.root = &root; context.rootquery = parse; context.current_query = parse; if (ts_extension_is_loaded_and_not_upgrading()) { #ifdef USE_TELEMETRY ts_telemetry_function_info_gather(parse); #endif /* * Preprocess the hypertables in the query and warm up the caches. */ preprocess_query((Node *) parse, &context); if (ts_guc_enable_optimizations) ts_cm_functions->preprocess_query_tsl(parse, &cursor_opts); } if (prev_planner_hook != NULL) /* Call any earlier hooks */ stmt = (prev_planner_hook) (parse, query_string, cursor_opts, bound_params); else /* Call the standard planner */ stmt = standard_planner(parse, query_string, cursor_opts, bound_params); if (ts_extension_is_loaded_and_not_upgrading()) { /* * Our top-level HypertableInsert plan node that wraps ModifyTable needs * to have a final target list that is the same as the ModifyTable plan * node, and we only have access to its final target list after * set_plan_references() (setrefs.c) has run at the end of * standard_planner. Therefore, we fixup the final target list for * HypertableInsert here. */ ts_modify_hypertable_fixup_tlist(stmt->planTree); foreach (lc, stmt->subplans) { Plan *subplan = (Plan *) lfirst(lc); if (subplan) ts_modify_hypertable_fixup_tlist(subplan); } if (IsA(stmt->planTree, Agg)) { Agg *agg = castNode(Agg, stmt->planTree); /* If top-level plan is the finalize step of a partial * aggregation, and it is wrapped in the partialize_agg() * function, we want to do the combine step but skip * finalization (e.g., for avg(), add up individual * sum+counts, but don't compute the final average). */ if (agg->aggsplit == AGGSPLIT_FINAL_DESERIAL && has_partialize_function((Node *) agg->plan.targetlist, TS_FIX_AGGSPLIT_FINAL)) { /* Deserialize input -> combine -> skip the final step -> * serialize again */ agg->aggsplit = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE | AGGSPLITOP_SERIALIZE | AGGSPLITOP_SKIPFINAL; } } ts_cm_functions->tsl_postprocess_plan(stmt); } if (reset_baserel_info) { Assert(ts_baserel_info != NULL); BaserelInfo_destroy(ts_baserel_info); ts_baserel_info = NULL; } } PG_CATCH(); { if (reset_baserel_info) { Assert(ts_baserel_info != NULL); BaserelInfo_destroy(ts_baserel_info); ts_baserel_info = NULL; } /* Pop the cache, but do not release since caches are auto-released on * error */ planner_hcache_pop(false); PG_RE_THROW(); } PG_END_TRY(); planner_hcache_pop(true); return stmt; } static RangeTblEntry * get_parent_rte(const PlannerInfo *root, Index rti) { ListCell *lc; /* Fast path when arrays are setup */ if (root->append_rel_array != NULL && root->append_rel_array[rti] != NULL) { AppendRelInfo *appinfo = root->append_rel_array[rti]; return planner_rt_fetch(appinfo->parent_relid, root); } foreach (lc, root->append_rel_list) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); if (appinfo->child_relid == rti) return planner_rt_fetch(appinfo->parent_relid, root); } return NULL; } /* * Fetch cached baserel entry. If it does not exists, create an entry for this * relid. * If this relid corresponds to a chunk, cache additional chunk * related metadata: like chunk_status and pointer to hypertable entry. * It is okay to cache a pointer to the hypertable, since this cache is * confined to the lifetime of the query and not used across queries. * If the parent reolid is known, the caller can specify it to avoid the costly * lookup. Otherwise pass InvalidOid. */ static BaserelInfoEntry * get_or_add_baserel_from_cache(Oid chunk_reloid, Oid parent_reloid) { Hypertable *ht = NULL; /* First, check if this reloid is in cache. */ bool found = false; BaserelInfoEntry *entry = BaserelInfo_insert(ts_baserel_info, chunk_reloid, &found); if (found) { return entry; } if (OidIsValid(parent_reloid)) { ht = ts_planner_get_hypertable(parent_reloid, CACHE_FLAG_CHECK); #ifdef USE_ASSERT_CHECKING /* Sanity check on the caller-specified hypertable reloid. */ int32 parent_hypertable_id = ts_chunk_get_hypertable_id_by_reloid(chunk_reloid); if (parent_hypertable_id != INVALID_HYPERTABLE_ID) { Assert(ts_hypertable_id_to_relid(parent_hypertable_id, false) == parent_reloid); if (ht != NULL) { Assert(ht->fd.id == parent_hypertable_id); } } #endif } else { /* Hypertable reloid not specified by the caller, look it up by * an expensive metadata scan. */ int32 hypertable_id = ts_chunk_get_hypertable_id_by_reloid(chunk_reloid); if (hypertable_id != INVALID_HYPERTABLE_ID) { /* Hypertable reloid not specified by the caller, look it up. */ parent_reloid = ts_hypertable_id_to_relid(hypertable_id, /* return_invalid */ false); ht = ts_planner_get_hypertable(parent_reloid, CACHE_FLAG_NONE); Assert(ht != NULL); Assert(ht->fd.id == hypertable_id); } } /* Cache the result. */ entry->ht = ht; return entry; } /* * Classify a planned relation. * * This makes use of cache warming that happened during Query preprocessing in * the first planner hook. */ TsRelType ts_classify_relation(const PlannerInfo *root, const RelOptInfo *rel, Hypertable **ht) { Assert(ht != NULL); *ht = NULL; if (rel->reloptkind != RELOPT_BASEREL && rel->reloptkind != RELOPT_OTHER_MEMBER_REL) { return TS_REL_OTHER; } RangeTblEntry *rte = planner_rt_fetch(rel->relid, root); if (rte->relkind == RELKIND_FOREIGN_TABLE) { /* * OSM chunk or other foreign chunk. We can't even access the * fdw_private for it, because it's a foreign chunk managed by a * different extension. Try to ignore it as much as possible. */ return TS_REL_OTHER; } if (!OidIsValid(rte->relid)) { return TS_REL_OTHER; } if (rel->reloptkind == RELOPT_BASEREL) { /* * To correctly classify relations in subqueries we cannot call * ts_planner_get_hypertable with CACHE_FLAG_CHECK which includes * CACHE_FLAG_NOCREATE flag because the rel might not be in cache yet. */ *ht = ts_planner_get_hypertable(rte->relid, CACHE_FLAG_MISSING_OK); if (*ht != NULL) { return TS_REL_HYPERTABLE; } /* * This is either a chunk seen as a standalone table, a compressed chunk * table, or a non-chunk baserel. We need a costly chunk metadata scan * to distinguish between them, so we cache the result of this lookup to * avoid doing it repeatedly. */ BaserelInfoEntry *entry = get_or_add_baserel_from_cache(rte->relid, InvalidOid); *ht = entry->ht; if (*ht) { /* * Note that this works in a slightly weird way for compressed * chunks expanded from a normal hypertable, always saying that they * are standalone. In practice we filter them out by also checking * that the respective hypertable is not an internal compression * hypertable. */ return TS_REL_CHUNK_STANDALONE; } return TS_REL_OTHER; } Assert(rel->reloptkind == RELOPT_OTHER_MEMBER_REL); RangeTblEntry *parent_rte = get_parent_rte(root, rel->relid); /* * An entry of reloptkind RELOPT_OTHER_MEMBER_REL might still * be a hypertable or a chunk here if it was pulled up from a * subquery as happens with UNION ALL for example. So we have to * check for that to properly detect that pattern. */ if (parent_rte->rtekind == RTE_SUBQUERY) { *ht = ts_planner_get_hypertable(rte->relid, rte->inh ? CACHE_FLAG_MISSING_OK : CACHE_FLAG_CHECK); if (*ht) return TS_REL_HYPERTABLE; /* * This is either a chunk seen as a standalone table or a non-chunk baserel. * We need a costly chunk metadata scan to distinguish between them, so we * cache the result of this lookup to avoid doing it repeatedly. */ BaserelInfoEntry *entry = get_or_add_baserel_from_cache(rte->relid, InvalidOid); *ht = entry->ht; if (*ht) return TS_REL_CHUNK_STANDALONE; return TS_REL_OTHER; } if (parent_rte->relid == rte->relid) { /* * A PostgreSQL table expansion peculiarity -- "self child", the root * table that is expanded as a child of itself. This happens when our * expansion code is turned off. */ *ht = ts_planner_get_hypertable(rte->relid, CACHE_FLAG_CHECK); return *ht != NULL ? TS_REL_HYPERTABLE_CHILD : TS_REL_OTHER; } /* * Either an other baserel or a chunk seen when expanding the hypertable. * Use the baserel cache to determine what it is. */ BaserelInfoEntry *entry = get_or_add_baserel_from_cache(rte->relid, parent_rte->relid); *ht = entry->ht; if (*ht) { return TS_REL_CHUNK_CHILD; } return TS_REL_OTHER; } static inline bool should_chunk_append(Hypertable *ht, PlannerInfo *root, RelOptInfo *rel, Path *path, bool ordered, int order_attno) { if ( /* * We only support chunk exclusion on UPDATE/DELETE when no JOIN is involved on PG14+. */ ((root->parse->commandType == CMD_DELETE || root->parse->commandType == CMD_UPDATE) && bms_num_members(root->all_baserels) > 1) || !ts_guc_enable_chunk_append) return false; switch (nodeTag(path)) { case T_AppendPath: /* * If there are clauses that have mutable functions, or clauses that reference * Params this Path might benefit from startup or runtime exclusion */ { AppendPath *append = castNode(AppendPath, path); ListCell *lc; /* Don't create ChunkAppend with no children */ if (list_length(append->subpaths) == 0) return false; foreach (lc, rel->baserestrictinfo) { RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc); if (contain_mutable_functions((Node *) rinfo->clause) || ts_contains_external_param((Node *) rinfo->clause) || ts_contains_join_param((Node *) rinfo->clause)) return true; } return false; break; } case T_MergeAppendPath: /* * Can we do ordered append */ { MergeAppendPath *merge = castNode(MergeAppendPath, path); PathKey *pk; ListCell *lc; if (!ordered || path->pathkeys == NIL || list_length(merge->subpaths) == 0) return false; /* * Do not try to do ordered append if the OSM chunk range is noncontiguous */ if (ht && ts_chunk_get_osm_chunk_id(ht->fd.id) != INVALID_CHUNK_ID) { if (ts_flags_are_set_32(ht->fd.status, HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS)) return false; } /* * If we only have 1 child node there is no need for the * ordered append optimization. We might still benefit from * a ChunkAppend node here due to runtime chunk exclusion * when we have non-immutable constraints. */ if (list_length(merge->subpaths) == 1) { foreach (lc, rel->baserestrictinfo) { RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc); if (contain_mutable_functions((Node *) rinfo->clause) || ts_contains_external_param((Node *) rinfo->clause) || ts_contains_join_param((Node *) rinfo->clause)) return true; } return false; } pk = linitial_node(PathKey, path->pathkeys); /* * Check PathKey is compatible with Ordered Append ordering * we created when expanding hypertable. * Even though ordered is true on the RelOptInfo we have to * double check that current Path fulfills requirements for * Ordered Append transformation because the RelOptInfo may * be used for multiple Paths. */ Expr *em_expr = ts_find_em_expr_for_rel(pk->pk_eclass, rel); /* * If this is a join the ordering information might not be * for the current rel and have no EquivalenceMember. */ if (!em_expr) return false; if (IsA(em_expr, Var) && castNode(Var, em_expr)->varattno == order_attno) return true; if (IsA(em_expr, FuncExpr) && list_length(path->pathkeys) == 1) { FuncExpr *func = castNode(FuncExpr, em_expr); FuncInfo *info = ts_func_cache_get_bucketing_func(func->funcid); Expr *transformed; if (info != NULL) { transformed = info->sort_transform(func); if (IsA(transformed, Var) && castNode(Var, transformed)->varattno == order_attno) return true; } } return false; break; } default: return false; } } static inline bool should_constraint_aware_append(PlannerInfo *root, Hypertable *ht, Path *path) { /* Constraint-aware append currently expects children that scans a real * "relation" (e.g., not an "upper" relation). */ if (root->parse->commandType != CMD_SELECT) return false; return ts_constraint_aware_append_possible(path); } static bool rte_should_expand(const RangeTblEntry *rte) { bool is_hypertable = ts_rte_is_hypertable(rte); return is_hypertable && !rte->inh && ts_rte_is_marked_for_expansion(rte); } static void expand_hypertables(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) { bool set_pathlist_for_current_rel = false; double total_pages; bool reenabled_inheritance = false; for (int i = 1; i < root->simple_rel_array_size; i++) { RangeTblEntry *in_rte = root->simple_rte_array[i]; #if PG18_GE /* RTE could be removed due to self-join * elimination optimization. * * https://github.com/postgres/postgres/commit/5f6f95 */ if (!in_rte) continue; #endif if (rte_should_expand(in_rte) && root->simple_rel_array[i]) { RelOptInfo *in_rel = root->simple_rel_array[i]; Hypertable *ht = ts_planner_get_hypertable(in_rte->relid, CACHE_FLAG_NOCREATE); Assert(ht != NULL && in_rel != NULL); ts_plan_expand_hypertable_chunks(ht, root, in_rel, in_rte->ctename != TS_FK_EXPAND); in_rte->inh = true; reenabled_inheritance = true; /* Redo set_rel_consider_parallel, as results of the call may no longer be valid * here (due to adding more tables to the set of tables under consideration here). * This is especially true if dealing with foreign data wrappers. */ /* * An entry of reloptkind RELOPT_OTHER_MEMBER_REL might still * be a hypertable here if it was pulled up from a subquery * as happens with UNION ALL for example. */ if (in_rel->reloptkind == RELOPT_BASEREL || in_rel->reloptkind == RELOPT_OTHER_MEMBER_REL) { Assert(in_rte->relkind == RELKIND_RELATION); ts_set_rel_size(root, in_rel, i, in_rte); } /* if we're activating inheritance during a hypertable's pathlist * creation then we're past the point at which postgres will add * paths for the children, and we have to do it ourselves. We delay * the actual setting of the pathlists until after this loop, * because set_append_rel_pathlist will eventually call this hook again. */ if (in_rte == rte) { Assert(rti == (Index) i); set_pathlist_for_current_rel = true; } } } if (!reenabled_inheritance) return; total_pages = 0; for (int i = 1; i < root->simple_rel_array_size; i++) { RelOptInfo *brel = root->simple_rel_array[i]; if (brel == NULL) continue; Assert(brel->relid == (Index) i); /* sanity check on array */ if (IS_DUMMY_REL(brel)) continue; if (IS_SIMPLE_REL(brel)) total_pages += (double) brel->pages; } root->total_table_pages = total_pages; if (set_pathlist_for_current_rel) { rel->pathlist = NIL; rel->partial_pathlist = NIL; ts_set_append_rel_pathlist(root, rel, rti, rte); } } static void apply_optimizations(PlannerInfo *root, TsRelType reltype, RelOptInfo *rel, RangeTblEntry *rte, Hypertable *ht) { if (!ts_guc_enable_optimizations) return; switch (reltype) { case TS_REL_HYPERTABLE_CHILD: /* empty table so nothing to optimize */ break; case TS_REL_CHUNK_STANDALONE: case TS_REL_CHUNK_CHILD: { /* * Since the sort optimization adds new paths to the rel it has * to happen before any optimizations that replace pathlist. */ List *transformed_query_pathkeys = ts_sort_transform_get_pathkeys(root, rel, rte, ht); if (transformed_query_pathkeys != NIL) { List *orig_query_pathkeys = root->query_pathkeys; root->query_pathkeys = transformed_query_pathkeys; /* Create index paths with transformed pathkeys */ create_index_paths(root, rel); /* * Call the TSL hooks with the transformed pathkeys as well, so * that the decompression paths also use this optimization. */ if (ts_cm_functions->set_rel_pathlist_query != NULL) ts_cm_functions->set_rel_pathlist_query(root, rel, rel->relid, rte, ht); root->query_pathkeys = orig_query_pathkeys; /* * change returned paths to use original pathkeys. have to go through * all paths since create_index_paths might have modified existing * pathkey. Always safe to do transform since ordering of * transformed_query_pathkey implements ordering of * orig_query_pathkeys. */ ts_sort_transform_replace_pathkeys(rel->pathlist, transformed_query_pathkeys, orig_query_pathkeys); } else { if (ts_cm_functions->set_rel_pathlist_query != NULL) ts_cm_functions->set_rel_pathlist_query(root, rel, rel->relid, rte, ht); } break; } default: break; } if (reltype == TS_REL_HYPERTABLE && (root->parse->commandType == CMD_SELECT || root->parse->commandType == CMD_DELETE || root->parse->commandType == CMD_UPDATE)) { TimescaleDBPrivate *private = ts_get_private_reloptinfo(rel); bool ordered = private->appends_ordered; int order_attno = private->order_attno; List *nested_oids = private->nested_oids; ListCell *lc; Assert(ht != NULL); foreach (lc, rel->pathlist) { Path **pathptr = (Path **) &lfirst(lc); switch (nodeTag(*pathptr)) { case T_AppendPath: case T_MergeAppendPath: if (should_chunk_append(ht, root, rel, *pathptr, ordered, order_attno)) *pathptr = ts_chunk_append_path_create(root, rel, ht, *pathptr, false, ordered, nested_oids); else if (should_constraint_aware_append(root, ht, *pathptr)) *pathptr = ts_constraint_aware_append_path_create(root, *pathptr); break; default: break; } } foreach (lc, rel->partial_pathlist) { Path **pathptr = (Path **) &lfirst(lc); switch (nodeTag(*pathptr)) { case T_AppendPath: case T_MergeAppendPath: if (should_chunk_append(ht, root, rel, *pathptr, false, 0)) *pathptr = ts_chunk_append_path_create(root, rel, ht, *pathptr, true, false, NIL); else if (should_constraint_aware_append(root, ht, *pathptr)) *pathptr = ts_constraint_aware_append_path_create(root, *pathptr); break; default: break; } } } } static bool valid_hook_call(void) { return ts_extension_is_loaded_and_not_upgrading() && planner_hcache_exists(); } static bool dml_involves_hypertable(PlannerInfo *root, Hypertable *ht, Index rti) { Index result_rti = root->parse->resultRelation; RangeTblEntry *result_rte = planner_rt_fetch(result_rti, root); return result_rti == rti || ht->main_table_relid == result_rte->relid; } static void timescaledb_set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte) { TsRelType reltype; Hypertable *ht; /* * Quick exit if this is a relation we're not interested in. * * If the rtekind is a named tuple store, it is a named tuple store *for* * the relation rte->relid (e.g., a transition table for a trigger), but * not the relation itself. */ if (!valid_hook_call() || rte->rtekind == RTE_NAMEDTUPLESTORE || !OidIsValid(rte->relid) || IS_DUMMY_REL(rel)) { if (prev_set_rel_pathlist_hook != NULL) (*prev_set_rel_pathlist_hook)(root, rel, rti, rte); return; } reltype = ts_classify_relation(root, rel, &ht); /* Check for unexpanded hypertable */ if (!rte->inh && ts_rte_is_marked_for_expansion(rte)) expand_hypertables(root, rel, rti, rte); if (ts_guc_enable_optimizations) ts_planner_constraint_cleanup(root, rel); /* Call other extensions. Do it after table expansion. */ if (prev_set_rel_pathlist_hook != NULL) (*prev_set_rel_pathlist_hook)(root, rel, rti, rte); switch (reltype) { case TS_REL_HYPERTABLE_CHILD: if (ts_guc_enable_optimizations && IS_UPDL_CMD(root->parse)) ts_planner_constraint_cleanup(root, rel); break; case TS_REL_CHUNK_STANDALONE: case TS_REL_CHUNK_CHILD: /* Check for UPDATE/DELETE/MERGE (DML) on compressed chunks */ if (IS_UPDL_CMD(root->parse) && dml_involves_hypertable(root, ht, rti)) { if (ts_cm_functions->set_rel_pathlist_dml != NULL) ts_cm_functions->set_rel_pathlist_dml(root, rel, rti, rte, ht); break; } /* * For MERGE command if there is an UPDATE or DELETE action, then * do not allow this to succeed on compressed chunks */ if (root->parse->commandType == CMD_MERGE && dml_involves_hypertable(root, ht, rti)) { ListCell *ml; foreach (ml, root->parse->mergeActionList) { MergeAction *action = (MergeAction *) lfirst(ml); if (action->commandType == CMD_UPDATE || action->commandType == CMD_DELETE) { if (ts_cm_functions->set_rel_pathlist_dml != NULL) ts_cm_functions->set_rel_pathlist_dml(root, rel, rti, rte, ht); } } break; } TS_FALLTHROUGH; default: /* * Set the indexlist for a hypertable parent to NIL since we * should not try to do any index scans on hypertable parents, * similar to how it works for partitioned tables. * * This can happen when building a merge join path and computing * cost for it. See get_actual_variable_range(). * * This has to be after the hypertable is expanded, since the * indexlist is used during hypertable expansion. */ if (reltype == TS_REL_HYPERTABLE) rel->indexlist = NIL; apply_optimizations(root, reltype, rel, rte, ht); break; } } /* This hook is meant to editorialize about the information the planner gets * about a relation. We use it to attach our own metadata to hypertable and * chunk relations that we need during planning. We also expand hypertables * here. */ static void timescaledb_get_relation_info_hook(PlannerInfo *root, Oid relation_objectid, bool inhparent, RelOptInfo *rel) { if (prev_get_relation_info_hook != NULL) prev_get_relation_info_hook(root, relation_objectid, inhparent, rel); if (!valid_hook_call()) return; RangeTblEntry *rte = planner_rt_fetch(rel->relid, root); Query *query = root->parse; Hypertable *ht; const TsRelType type = ts_classify_relation(root, rel, &ht); AclMode requiredPerms = 0; #if PG16_LT requiredPerms = rte->requiredPerms; #else if (rte->perminfoindex > 0) { RTEPermissionInfo *perminfo = getRTEPermissionInfo(query->rteperminfos, rte); requiredPerms = perminfo->requiredPerms; } #endif switch (type) { case TS_REL_HYPERTABLE: { /* Mark hypertable RTEs we'd like to expand ourselves. * Hypertables inside inlineable functions don't get marked during the query * preprocessing step. Therefore we do an extra try here. However, we need to * be careful for UPDATE/DELETE as Postgres (in at least version 12) plans them * in a complicated way (see planner.c:inheritance_planner). First, it runs the * UPDATE/DELETE through the planner as a simulated SELECT. It uses the results * of this fake planning to adapt its own UPDATE/DELETE plan. Then it's planned * a second time as a real UPDATE/DELETE, but with requiredPerms set to 0, as it * assumes permission checking has been done already during the first planner call. * We don't want to touch the UPDATE/DELETEs, so we need to check all the regular * conditions here that are checked during preprocess_query, as well as the * condition that requiredPerms is not requiring UPDATE/DELETE on this rel. */ if (ts_guc_enable_optimizations && ts_guc_enable_constraint_exclusion && inhparent && rte->ctename == NULL && !IS_UPDL_CMD(query) && query->resultRelation == 0 && query->rowMarks == NIL && (requiredPerms & (ACL_UPDATE | ACL_DELETE)) == 0) { rte_mark_for_expansion(rte); } ts_create_private_reloptinfo(rel); ts_plan_expand_timebucket_annotate(root, rel); break; } case TS_REL_CHUNK_STANDALONE: case TS_REL_CHUNK_CHILD: ts_create_private_reloptinfo(rel); /* * We don't want to plan index scans on empty uncompressed tables of * fully compressed chunks. It takes a lot of time, and these tables * are empty anyway. Just reset the indexlist in this case. For * uncompressed or partially compressed chunks, the uncompressed * tables are not empty, so we plan the index scans as usual. * * Normally the index list is reset in ts_set_append_rel_pathlist(), * based on the Chunk struct cached by our hypertable expansion, but * in cases when these functions don't run, we have to do it here. */ const bool use_transparent_decompression = ts_guc_enable_transparent_decompression && TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht); const bool is_standalone_chunk = (type == TS_REL_CHUNK_STANDALONE) && !TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht); const bool is_child_chunk_in_update = (type == TS_REL_CHUNK_CHILD) && IS_UPDL_CMD(query); if (use_transparent_decompression && (is_standalone_chunk || is_child_chunk_in_update)) { const Chunk *chunk = ts_planner_chunk_fetch(root, rel); if (!ts_chunk_is_partial(chunk) && ts_chunk_is_compressed(chunk)) { rel->indexlist = NIL; } } break; case TS_REL_HYPERTABLE_CHILD: /* When postgres expands an inheritance tree it also adds the * parent hypertable as child relation. Since for a hypertable the * parent will never have any data we can mark this relation as * dummy relation so it gets ignored in later steps. This is only * relevant for code paths that use the postgres inheritance code * as we don't include the hypertable as child when expanding the * hypertable ourself. */ if (IS_UPDL_CMD(root->parse)) mark_dummy_rel(rel); break; case TS_REL_OTHER: break; } } static bool join_involves_hypertable(const PlannerInfo *root, const RelOptInfo *rel) { int relid = -1; while ((relid = bms_next_member(rel->relids, relid)) >= 0) { const RangeTblEntry *rte = planner_rt_fetch(relid, root); if (rte != NULL) /* This might give a false positive for chunks in case of PostgreSQL * expansion since the ctename is copied from the parent hypertable * to the chunk */ return ts_rte_is_marked_for_expansion(rte); } return false; } static bool involves_hypertable(PlannerInfo *root, RelOptInfo *rel) { if (rel->reloptkind == RELOPT_JOINREL) return join_involves_hypertable(root, rel); Hypertable *ht; return ts_classify_relation(root, rel, &ht) == TS_REL_HYPERTABLE; } /* * Replace ModifyTablePath paths on hypertables. * * From the ModifyTable description: "Each ModifyTable node contains * a list of one or more subplans, much like an Append node. There * is one subplan per result relation." * * The subplans produce the tuples for INSERT, while the result relation is the * table we'd like to insert into. * * Conceptually, the plan modification looks like this: * * Original plan: * * ^ * | * [ ModifyTable ] -> resultRelation * ^ * | Tuple * | * [ subplan ] * * * Modified plan: * * [ ModifyHypertable ] * ^ * | * [ ModifyTable ] -> resultRelation * ^ * | Tuple * | * [ subplan ] * */ static List * replace_modify_hypertable_paths(PlannerInfo *root, List *pathlist, RelOptInfo *input_rel) { List *new_pathlist = NIL; ListCell *lc; foreach (lc, pathlist) { Path *path = lfirst(lc); if (IsA(path, ModifyTablePath)) { ModifyTablePath *mt = castNode(ModifyTablePath, path); RangeTblEntry *rte = planner_rt_fetch(mt->nominalRelation, root); Hypertable *ht = ts_planner_get_hypertable(rte->relid, CACHE_FLAG_CHECK); /* Direct INSERT into internal compressed hypertable is not supported. * Compressed chunks have no dimensions so we could not do tuple routing. * Additionally internal compressed hypertable has no columns so you * couldn't even insert any actual data. */ if (ht && ht->fd.compression_state == HypertableInternalCompressionTable) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("direct insert into internal compressed hypertable is not " "supported"))); /* Check for DML on chunk directly */ if (!ht) { Chunk *chunk = ts_chunk_get_by_relid(rte->relid, false); if (!chunk) { /* Not a hypertable or chunk, continue */ new_pathlist = lappend(new_pathlist, path); continue; } ht = ts_hypertable_get_by_id(chunk->fd.hypertable_id); if (ht->fd.compression_state == HypertableInternalCompressionTable) { /* * For operations on internal compressed chunks we block modifications * if the chunk belongs to a frozen chunk. * Direct modifications of uncompressed chunks is intercepted by chunk * tuple routing. * In all other cases of direct modification of chunks we dont interfere * and do not add a ModifyHypertable node. */ Chunk *uncompressed = ts_chunk_get_compressed_chunk_parent(chunk); if (ts_chunk_is_frozen(uncompressed)) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("cannot modify compressed chunk belonging to a frozen " "chunk"))); new_pathlist = lappend(new_pathlist, path); continue; } } switch (mt->operation) { case CMD_INSERT: case CMD_UPDATE: case CMD_DELETE: { path = ts_modify_hypertable_path_create(root, mt, input_rel); break; } case CMD_MERGE: { List *firstMergeActionList = linitial(mt->mergeActionLists); ListCell *l; /* * Iterate over merge action to check if there is an INSERT sql. * If so, then add ModifyHypertable node. */ foreach (l, firstMergeActionList) { MergeAction *action = (MergeAction *) lfirst(l); if (action->commandType == CMD_INSERT) { path = ts_modify_hypertable_path_create(root, mt, input_rel); break; } } break; } default: break; } } new_pathlist = lappend(new_pathlist, path); } return new_pathlist; } static void timescaledb_create_upper_paths_hook(PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra) { Query *parse = root->parse; bool partials_found = false; TsRelType reltype = TS_REL_OTHER; Hypertable *ht = NULL; if (prev_create_upper_paths_hook != NULL) prev_create_upper_paths_hook(root, stage, input_rel, output_rel, extra); if (!ts_extension_is_loaded_and_not_upgrading()) return; if (input_rel != NULL) reltype = ts_classify_relation(root, input_rel, &ht); if (output_rel != NULL) { /* Modify for INSERTs on a hypertable */ if (output_rel->pathlist != NIL) output_rel->pathlist = replace_modify_hypertable_paths(root, output_rel->pathlist, input_rel); if (parse->hasAggs && stage == UPPERREL_GROUP_AGG) { /* Existing AggPaths are modified here. * No new AggPaths should be added after this if there * are partials. */ partials_found = ts_plan_process_partialize_agg(root, output_rel); } } if (stage == UPPERREL_GROUP_AGG && output_rel != NULL && ts_guc_enable_optimizations && input_rel != NULL && !IS_DUMMY_REL(input_rel) && involves_hypertable(root, input_rel)) { if (parse->hasAggs) ts_preprocess_first_last_aggregates(root, root->processed_tlist); if (!partials_found) ts_plan_add_hashagg(root, input_rel, output_rel); } if (ts_cm_functions->create_upper_paths_hook != NULL) ts_cm_functions ->create_upper_paths_hook(root, stage, input_rel, output_rel, reltype, ht, extra); } static bool contains_join_param_walker(Node *node, void *context) { if (node == NULL) { return false; } if (IsA(node, Param) && castNode(Param, node)->paramkind == PARAM_EXEC) return true; return expression_tree_walker(node, contains_join_param_walker, context); } bool ts_contains_join_param(Node *node) { return contains_join_param_walker(node, NULL); } static bool contains_external_param_walker(Node *node, void *context) { if (node == NULL) { return false; } if (IsA(node, Param) && castNode(Param, node)->paramkind == PARAM_EXTERN) return true; return expression_tree_walker(node, contains_external_param_walker, context); } bool ts_contains_external_param(Node *node) { return contains_external_param_walker(node, NULL); } static List * fill_missing_groupclause(List *new_groupclause, List *orig_groupclause) { if (new_groupclause != NIL) { ListCell *gl; foreach (gl, orig_groupclause) { SortGroupClause *gc = lfirst_node(SortGroupClause, gl); if (list_member_ptr(new_groupclause, gc)) continue; /* already in list */ new_groupclause = lappend(new_groupclause, gc); } } return new_groupclause; } static bool check_cagg_view_rte(RangeTblEntry *rte) { ContinuousAgg *cagg = NULL; ListCell *rtlc; bool found = false; Query *viewq = rte->subquery; Assert(rte->rtekind == RTE_SUBQUERY); if (list_length(viewq->rtable) != 3) /* a view has 3 entries */ { return false; } /* should cache this information for cont. aggregates */ foreach (rtlc, viewq->rtable) { RangeTblEntry *rte = lfirst_node(RangeTblEntry, rtlc); if (!OidIsValid(rte->relid)) break; cagg = ts_continuous_agg_find_by_relid(rte->relid); if (cagg != NULL) found = true; } return found; } /* Note that it modifies the passed in Query * select * from (select a, b, max(c), min(d) from ... group by a, b) order by b; * is transformed as * SELECT * from (select a, b, max(c), min(d) from .. * group by B desc, A <------ note the change in order here * ) * order by b desc; * we transform only if order by is a subset of group-by * transformation is applicable only to continuous aggregates * Parameters: * subq_rte - rte for subquery (inner query that will be modified) * outer_sortcl -- outer query's sort clause * outer_tlist - outer query's target list */ static void cagg_reorder_groupby_clause(RangeTblEntry *subq_rte, Index rtno, List *outer_sortcl, List *outer_tlist) { bool not_found = true; Query *subq; ListCell *lc; Assert(subq_rte->rtekind == RTE_SUBQUERY); subq = subq_rte->subquery; if (outer_sortcl && subq->groupClause && subq->sortClause == NIL && check_cagg_view_rte(subq_rte)) { List *new_groupclause = NIL; /* we are going to modify this. so make a copy and use it if we replace */ List *subq_groupclause_copy = copyObject(subq->groupClause); foreach (lc, outer_sortcl) { SortGroupClause *outer_sc = (SortGroupClause *) lfirst(lc); TargetEntry *outer_tle = get_sortgroupclause_tle(outer_sc, outer_tlist); not_found = true; if (IsA(outer_tle->expr, Var) && ((Index) ((Var *) outer_tle->expr)->varno == rtno)) { int outer_attno = ((Var *) outer_tle->expr)->varattno; TargetEntry *subq_tle = list_nth(subq->targetList, outer_attno - 1); if (subq_tle->ressortgroupref > 0) { /* get group clause corresponding to this */ SortGroupClause *subq_gclause = get_sortgroupref_clause(subq_tle->ressortgroupref, subq_groupclause_copy); subq_gclause->sortop = outer_sc->sortop; subq_gclause->nulls_first = outer_sc->nulls_first; #if PG18_GE /* Track sort direction in SortGroupClause * https://github.com/postgres/postgres/commit/0d2aa4d4 */ subq_gclause->reverse_sort = outer_sc->reverse_sort; #endif Assert(subq_gclause->eqop == outer_sc->eqop); new_groupclause = lappend(new_groupclause, subq_gclause); not_found = false; } } if (not_found) break; } /* all order by found in group by clause */ if (new_groupclause != NIL && not_found == false) { /* use new groupby clause for this subquery/view */ subq->groupClause = fill_missing_groupclause(new_groupclause, subq_groupclause_copy); } } } void _planner_init(void) { prev_planner_hook = planner_hook; planner_hook = timescaledb_planner; prev_set_rel_pathlist_hook = set_rel_pathlist_hook; set_rel_pathlist_hook = timescaledb_set_rel_pathlist; prev_get_relation_info_hook = get_relation_info_hook; get_relation_info_hook = timescaledb_get_relation_info_hook; prev_create_upper_paths_hook = create_upper_paths_hook; create_upper_paths_hook = timescaledb_create_upper_paths_hook; } void _planner_fini(void) { planner_hook = prev_planner_hook; set_rel_pathlist_hook = prev_set_rel_pathlist_hook; get_relation_info_hook = prev_get_relation_info_hook; create_upper_paths_hook = prev_create_upper_paths_hook; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/planner/planner.h������������������������������������������������������������0000664�0000000�0000000�00000012670�15100345067�0020117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/parsenodes.h> #include <nodes/pathnodes.h> #include <nodes/pg_list.h> #include <parser/parsetree.h> #include "chunk.h" #include "export.h" #include "guc.h" #include "hypertable.h" /* * Constraints created during planning to improve chunk exclusion * will be marked with this value as location so they can be easily * identified and removed when they are no longer needed. * Removal happens in timescaledb_set_rel_pathlist hook. */ #define PLANNER_LOCATION_MAGIC -29811 typedef struct Chunk Chunk; typedef struct Hypertable Hypertable; typedef struct TimescaleDBPrivate { bool appends_ordered; /* attno of the time dimension in the parent table if appends are ordered */ int order_attno; List *nested_oids; List *chunk_oids; /* Cached chunk data for the chunk relinfo. */ Chunk *cached_chunk_struct; /* Cached equivalence members for compressed chunks. List of (EC, EM) Lists. */ List *compressed_ec_em_pairs; } TimescaleDBPrivate; extern TSDLLEXPORT bool ts_rte_is_hypertable(const RangeTblEntry *rte); extern TSDLLEXPORT bool ts_rte_is_marked_for_expansion(const RangeTblEntry *rte); extern TSDLLEXPORT bool ts_contains_external_param(Node *node); extern TSDLLEXPORT bool ts_contains_join_param(Node *node); static inline TimescaleDBPrivate * ts_create_private_reloptinfo(RelOptInfo *rel) { Assert(rel->fdw_private == NULL); rel->fdw_private = palloc0(sizeof(TimescaleDBPrivate)); return rel->fdw_private; } static inline TimescaleDBPrivate * ts_get_private_reloptinfo(RelOptInfo *rel) { /* If rel->fdw_private is not set up here it means the rel got missclassified * and did not get expanded by our code but by postgres native code. * This is not a problem by itself, but probably an oversight on our part. */ Assert(rel->fdw_private); return rel->fdw_private ? rel->fdw_private : ts_create_private_reloptinfo(rel); } /* * TsRelType provides consistent classification of planned relations across * planner hooks. */ typedef enum TsRelType { TS_REL_HYPERTABLE, /* A hypertable with no parent */ TS_REL_CHUNK_STANDALONE, /* Chunk with no parent (i.e., it's part of the * plan as a standalone table. For example, * querying the chunk directly and not via the * parent hypertable). */ TS_REL_HYPERTABLE_CHILD, /* Self child. With PostgreSQL's table expansion, * the root table is expanded as a child of * itself. This happens when our expansion code * is turned off. */ TS_REL_CHUNK_CHILD, /* Chunk with parent and the result of table * expansion. */ TS_REL_OTHER, /* Anything which is none of the above */ } TsRelType; typedef enum PartializeAggFixAggref { TS_DO_NOT_FIX_AGGSPLIT = 0, TS_FIX_AGGSPLIT_SIMPLE = 1, TS_FIX_AGGSPLIT_FINAL = 2 } PartializeAggFixAggref; extern TSDLLEXPORT Hypertable *ts_planner_get_hypertable(const Oid relid, const unsigned int flags); bool has_partialize_function(Node *node, PartializeAggFixAggref fix_aggref); bool ts_plan_process_partialize_agg(PlannerInfo *root, RelOptInfo *output_rel); extern void ts_plan_add_hashagg(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel); extern void ts_preprocess_first_last_aggregates(PlannerInfo *root, List *tlist); extern void ts_plan_expand_hypertable_chunks(Hypertable *ht, PlannerInfo *root, RelOptInfo *rel, bool include_osm); extern void ts_plan_expand_timebucket_annotate(PlannerInfo *root, RelOptInfo *rel); extern Expr *ts_transform_time_bucket_comparison(Expr *); extern Node *ts_constify_now(PlannerInfo *root, List *rtable, Node *node); extern void ts_planner_constraint_cleanup(PlannerInfo *root, RelOptInfo *rel); extern Node *ts_add_space_constraints(PlannerInfo *root, List *rtable, Node *node); extern TSDLLEXPORT void ts_add_baserel_cache_entry_for_chunk(Oid chunk_reloid, Hypertable *hypertable); TsRelType TSDLLEXPORT ts_classify_relation(const PlannerInfo *root, const RelOptInfo *rel, Hypertable **ht); /* * Chunk-equivalent of planner_rt_fetch(), but returns the corresponding chunk * instead of range table entry. * * Returns NULL if this rel is not a chunk. * * This cache should be pre-warmed by hypertable expansion, but it * doesn't run in the following cases: * * 1. if it was a direct query on the chunk; * * 2. if it is not a SELECT QUERY. */ static inline const Chunk * ts_planner_chunk_fetch(const PlannerInfo *root, RelOptInfo *rel) { TimescaleDBPrivate *rel_private; /* The rel can only be a chunk if it is part of a hypertable expansion * (RELOPT_OTHER_MEMBER_REL) or a directly query on the chunk * (RELOPT_BASEREL) */ if (rel->reloptkind != RELOPT_OTHER_MEMBER_REL && rel->reloptkind != RELOPT_BASEREL) return NULL; /* The rel_private entry should have been created as part of classifying * the relation in timescaledb_get_relation_info_hook(). Therefore, * ts_get_private_reloptinfo() asserts that it is already set but falls * back to creating rel_private in release builds for safety. */ rel_private = ts_get_private_reloptinfo(rel); if (NULL == rel_private->cached_chunk_struct) { RangeTblEntry *rte = planner_rt_fetch(rel->relid, root); rel_private->cached_chunk_struct = ts_chunk_get_by_relid(rte->relid, /* fail_if_not_found = */ true); } return rel_private->cached_chunk_struct; } ������������������������������������������������������������������������timescaledb-2.23.0/src/planner/space_constraint.c���������������������������������������������������0000664�0000000�0000000�00000023704�15100345067�0022012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <datatype/timestamp.h> #include <nodes/makefuncs.h> #include <nodes/pg_list.h> #include <optimizer/optimizer.h> #include <parser/parse_func.h> #include <utils/fmgroids.h> #include <utils/typcache.h> #include "cache.h" #include "dimension.h" #include "hypertable.h" #include "hypertable_cache.h" #include "partitioning.h" #include "planner.h" /* * Returns space dimension for a specific column. Returns NULL * if the column is not a space dimension. */ static Dimension * get_space_dimension(Oid relid, AttrNumber varattno) { Hypertable *ht = ts_planner_get_hypertable(relid, CACHE_FLAG_CHECK); if (!ht) return NULL; for (uint16 i = 0; i < ht->space->num_dimensions; i++) { Dimension *dim = &ht->space->dimensions[i]; if (dim->type == DIMENSION_TYPE_CLOSED && dim->column_attno == varattno) { return dim; } } return NULL; } /* * Check if this operator is compatible with the constraints on * the space dimension. This is the equality operator between * left and right in the btree operator family. */ bool ts_is_equality_operator(Oid opno, Oid left, Oid right) { TypeCacheEntry *tce; if (left == right) { /* * When left and right match lookup_type_cache can * directly return the equality operator saving us * one roundtrip. */ tce = lookup_type_cache(left, TYPECACHE_EQ_OPR); return tce && opno == tce->eq_opr; } else { /* * The left and right type might not match when comparing * different integer types eg comparing int2 or int8 * columns with integer literals which default to int4. */ tce = lookup_type_cache(left, TYPECACHE_BTREE_OPFAMILY); if (!tce) return false; Oid eqop = get_opfamily_member(tce->btree_opf, left, right, BTEqualStrategyNumber); return opno == eqop; } } /* * Valid constraints are: Var = Const * Var has to refer to a space partitioning column */ static bool is_valid_space_constraint(OpExpr *op, List *rtable) { Assert(IsA(op, OpExpr)); if (!IsA(linitial(op->args), Var) || !IsA(lsecond(op->args), Const)) return false; Var *var = linitial_node(Var, op->args); if (var->varlevelsup != 0) return false; Const *value = lsecond_node(Const, op->args); if (!ts_is_equality_operator(op->opno, var->vartype, value->consttype)) return false; /* * Check that the constraint is actually on a partitioning column. */ Assert((int) var->varno <= list_length(rtable)); RangeTblEntry *rte = list_nth(rtable, var->varno - 1); Dimension *dim = get_space_dimension(rte->relid, var->varattno); if (!dim) return false; return true; } /* * Valid constraints are: * Var = ANY(ARRAY[Const,Const]) * Var IN (Const,Const) * Var has to refer to a space partitioning column */ static bool is_valid_scalar_space_constraint(ScalarArrayOpExpr *op, List *rtable) { Assert(IsA(op, ScalarArrayOpExpr)); if (!IsA(linitial(op->args), Var) || !IsA(lsecond(op->args), ArrayExpr)) return false; Var *var = linitial_node(Var, op->args); ArrayExpr *arr = castNode(ArrayExpr, lsecond(op->args)); if (arr->multidims || !op->useOr || var->varlevelsup != 0) return false; if (!ts_is_equality_operator(op->opno, var->vartype, arr->element_typeid)) return false; /* * Check that the constraint is actually on a partitioning column. */ Assert((int) var->varno <= list_length(rtable)); RangeTblEntry *rte = list_nth(rtable, var->varno - 1); Dimension *dim = get_space_dimension(rte->relid, var->varattno); if (!dim) return false; ListCell *lc; foreach (lc, arr->elements) { switch (nodeTag(lfirst(lc))) { case T_Const: break; case T_FuncExpr: { FuncExpr *element = lfirst_node(FuncExpr, lc); if (element->funcformat != COERCE_IMPLICIT_CAST || !IsA(linitial(element->args), Const)) return false; break; } default: return false; break; } } return true; } static FuncExpr * make_partfunc_call(Oid funcid, Oid rettype, List *args, Oid inputcollid) { /* build FuncExpr to use in eval_const_expressions */ return makeFuncExpr(funcid /* funcid */, rettype /* rettype */, args /* args */, InvalidOid /* funccollid */, inputcollid /* inputcollid */, COERCE_EXPLICIT_CALL /* fformat */); } /* * Transform a constraint like: device_id = 1 * into * ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) */ static OpExpr * transform_space_constraint(PlannerInfo *root, List *rtable, OpExpr *op) { Var *var = linitial_node(Var, op->args); Const *value = lsecond_node(Const, op->args); Const *part_value; RangeTblEntry *rte = list_nth(rtable, var->varno - 1); Dimension *dim = get_space_dimension(rte->relid, var->varattno); Oid rettype = dim->partitioning->partfunc.rettype; TypeCacheEntry *tce = lookup_type_cache(rettype, TYPECACHE_EQ_OPR); /* build FuncExpr to use in eval_const_expressions */ FuncExpr *partcall = make_partfunc_call(dim->partitioning->partfunc.func_fmgr.fn_oid, rettype, list_make1(value), var->varcollid); /* * We should always be able to constify here */ part_value = castNode(Const, eval_const_expressions(root, (Node *) partcall)); /* build FuncExpr with column reference to use in constraint */ partcall->args = list_make1(copyObject(var)); OpExpr *ret = (OpExpr *) make_opclause(tce->eq_opr /* opno */, BOOLOID /*opresulttype */, false /* opretset */, (Expr *) partcall /* left */, (Expr *) part_value /* right */, InvalidOid /* opcollid */, InvalidOid /* inputcollid */); ret->location = PLANNER_LOCATION_MAGIC; return ret; } /* * Transforms a constraint like: s1 = ANY ('{s1_2,s1_2}'::text[]) * into * ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (_timescaledb_functions.get_partition_hash(s1) = ANY * ('{1583420735,1583420735}'::integer[]))) */ static ScalarArrayOpExpr * transform_scalar_space_constraint(PlannerInfo *root, List *rtable, ScalarArrayOpExpr *op) { Var *var = linitial_node(Var, op->args); RangeTblEntry *rte = list_nth(rtable, var->varno - 1); Dimension *dim = get_space_dimension(rte->relid, var->varattno); Oid rettype = dim->partitioning->partfunc.rettype; TypeCacheEntry *tce = lookup_type_cache(rettype, TYPECACHE_EQ_OPR); List *part_values = NIL; ListCell *lc; /* build FuncExpr to use in eval_const_expressions */ FuncExpr *partcall = make_partfunc_call(dim->partitioning->partfunc.func_fmgr.fn_oid, rettype, NIL, var->varcollid); foreach (lc, lsecond_node(ArrayExpr, op->args)->elements) { Assert(IsA(lfirst(lc), Const) || (IsA(lfirst(lc), FuncExpr) && lfirst_node(FuncExpr, lc)->funcformat == COERCE_IMPLICIT_CAST)); /* * We can skip NULL here as elements are ORed and partitioning dimensions * have NOT NULL constraint. */ if (IsA(lfirst(lc), Const) && lfirst_node(Const, lc)->constisnull) continue; List *args = list_make1(lfirst(lc)); partcall->args = args; part_values = lappend(part_values, castNode(Const, eval_const_expressions(root, (Node *) partcall))); } /* build FuncExpr with column reference to use in constraint */ partcall->args = list_make1(copyObject(var)); ArrayExpr *arr2 = makeNode(ArrayExpr); arr2->array_collid = InvalidOid; arr2->array_typeid = get_array_type(rettype); arr2->element_typeid = rettype; arr2->multidims = false; arr2->location = -1; arr2->elements = part_values; ScalarArrayOpExpr *op2 = makeNode(ScalarArrayOpExpr); op2->opno = tce->eq_opr; op2->args = list_make2(partcall, arr2); op2->inputcollid = InvalidOid; op2->useOr = true; op2->location = PLANNER_LOCATION_MAGIC; return op2; } /* * Transform constraints for hash-based partitioning columns to make * them usable by postgres constraint exclusion. * * If we have an equality condition on a space partitioning column, we add * a corresponding condition on get_partition_hash on this column. These * conditions match the constraints on chunks, so postgres' constraint * exclusion is able to use them and exclude the chunks. * */ Node * ts_add_space_constraints(PlannerInfo *root, List *rtable, Node *node) { Assert(node); switch (nodeTag(node)) { case T_ScalarArrayOpExpr: { if (is_valid_scalar_space_constraint(castNode(ScalarArrayOpExpr, node), rtable)) { List *args = list_make2(node, transform_scalar_space_constraint(root, rtable, castNode(ScalarArrayOpExpr, node))); return (Node *) makeBoolExpr(AND_EXPR, args, -1); } break; } case T_OpExpr: if (is_valid_space_constraint(castNode(OpExpr, node), rtable)) { List *args = list_make2(node, transform_space_constraint(root, rtable, castNode(OpExpr, node))); return (Node *) makeBoolExpr(AND_EXPR, args, -1); } break; case T_BoolExpr: { ListCell *lc; BoolExpr *be = castNode(BoolExpr, node); if (be->boolop == AND_EXPR) { List *additions = NIL; /* * If this is a top-level AND we can just append our transformed constraints * to the list of ANDed expressions. */ foreach (lc, be->args) { switch (nodeTag(lfirst(lc))) { case T_OpExpr: { OpExpr *op = lfirst_node(OpExpr, lc); if (is_valid_space_constraint(op, rtable)) additions = lappend(additions, transform_space_constraint(root, rtable, op)); break; } case T_ScalarArrayOpExpr: { ScalarArrayOpExpr *op = lfirst_node(ScalarArrayOpExpr, lc); if (is_valid_scalar_space_constraint(op, rtable)) additions = lappend(additions, transform_scalar_space_constraint(root, rtable, op)); break; } default: break; } } if (additions) be->args = list_concat(be->args, additions); } break; } default: break; } return node; } ������������������������������������������������������������timescaledb-2.23.0/src/process_utility.c������������������������������������������������������������0000664�0000000�0000000�00000500074�15100345067�0020255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/xact.h> #include <catalog/index.h> #include <catalog/namespace.h> #include <catalog/objectaddress.h> #include <catalog/pg_am.h> #include <catalog/pg_authid.h> #include <catalog/pg_class_d.h> #include <catalog/pg_constraint.h> #include <catalog/pg_inherits.h> #include <catalog/pg_trigger.h> #include <commands/alter.h> #include <commands/cluster.h> #include <commands/copy.h> #include <commands/defrem.h> #include <commands/event_trigger.h> #include <commands/prepare.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <commands/trigger.h> #include <commands/user.h> #include <commands/vacuum.h> #include <executor/spi.h> #include <miscadmin.h> #include <nodes/lockoptions.h> #include <nodes/makefuncs.h> #include <nodes/nodes.h> #include <nodes/parsenodes.h> #include <parser/parse_expr.h> #include <parser/parse_relation.h> #include <parser/parse_type.h> #include <parser/parse_utilcmd.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <tcop/utility.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/guc.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/palloc.h> #include <utils/regproc.h> #include <utils/rel.h> #include <utils/ruleutils.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include "compat/compat.h" #include "annotations.h" #include "chunk.h" #include "chunk_index.h" #include "copy.h" #include "cross_module_fn.h" #include "debug_assert.h" #include "debug_point.h" #include "dimension_vector.h" #include "errors.h" #include "event_trigger.h" #include "export.h" #include "extension.h" #include "extension_constants.h" #include "foreign_key.h" #include "hypercube.h" #include "hypertable.h" #include "hypertable_cache.h" #include "indexing.h" #include "license_guc.h" #include "partitioning.h" #include "process_utility.h" #include "scan_iterator.h" #include "time_utils.h" #include "trigger.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/chunk_column_stats.h" #include "ts_catalog/compression_settings.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/continuous_aggs_watermark.h" #include "tss_callbacks.h" #include "utils.h" #include "with_clause/alter_table_with_clause.h" #include "with_clause/create_materialized_view_with_clause.h" #include "with_clause/create_table_with_clause.h" #include "with_clause/with_clause_parser.h" #ifdef USE_TELEMETRY #include "telemetry/functions.h" #endif void _process_utility_init(void); void _process_utility_fini(void); static ProcessUtility_hook_type prev_ProcessUtility_hook; static bool expect_chunk_modification = false; static ProcessUtilityContext last_process_utility_context = PROCESS_UTILITY_TOPLEVEL; static void check_no_timescale_options(AlterTableCmd *cmd, Oid reloid); static DDLResult process_altertable_set_options(AlterTableCmd *cmd, Hypertable *ht); static DDLResult process_altertable_reset_options(AlterTableCmd *cmd, Hypertable *ht); /* Call the default ProcessUtility and handle PostgreSQL version differences */ static void prev_ProcessUtility(ProcessUtilityArgs *args) { ProcessUtility_hook_type hook = prev_ProcessUtility_hook ? prev_ProcessUtility_hook : standard_ProcessUtility; hook(args->pstmt, args->query_string, args->readonly_tree, args->context, args->params, args->queryEnv, args->dest, args->completion_tag); /* * Reset the last_process_utility_context value that is saved at the * entrance of the TS ProcessUtility hook and can be used for transaction * checks inside refresh_cagg and other procedures. */ ts_process_utility_context_reset(); } static void check_chunk_alter_table_operation_allowed(Oid relid, AlterTableStmt *stmt) { const Chunk *chunk; if (expect_chunk_modification) return; chunk = ts_chunk_get_by_relid(relid, false /* fail_if_not_found */); if (chunk != NULL) { bool all_allowed = true; ListCell *lc; /* only allow if all commands are allowed */ foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { case AT_SetOptions: case AT_ResetOptions: case AT_SetRelOptions: case AT_ResetRelOptions: case AT_ReplaceRelOptions: case AT_SetStatistics: case AT_SetStorage: case AT_DropCluster: case AT_ClusterOn: case AT_EnableRowSecurity: case AT_DisableRowSecurity: case AT_SetTableSpace: case AT_ReAddStatistics: case AT_SetCompression: case AT_SetAccessMethod: case AT_SetLogged: case AT_SetUnLogged: /* allowed on chunks */ break; case AT_AddConstraint: { /* if this is an OSM chunk, block the operation */ if (chunk->fd.osm_chunk) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on OSM chunk tables"))); } break; } case AT_DropConstraint: { /* if this is an OSM chunk, block the operation */ if (chunk->fd.osm_chunk) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on OSM chunk tables"))); } ChunkConstraints *ccs = ts_chunk_constraint_scan_by_chunk_id(chunk->fd.id, 10, CurrentMemoryContext); Assert(cmd->name); for (int i = 0; i < ccs->num_constraints; i++) { ChunkConstraint *cc = &ccs->constraints[i]; if (namestrcmp(&cc->fd.constraint_name, cmd->name) == 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot drop inherited constraint"), errhint("Drop the constraint on the hypertable instead."))); } break; } default: /* disable by default */ all_allowed = false; break; } } if (!all_allowed) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on chunk tables"))); } } /* we block some ALTER commands on continuous aggregate materialization tables */ static void check_continuous_agg_alter_table_allowed(Hypertable *ht, AlterTableStmt *stmt) { ListCell *lc; ContinuousAggHypertableStatus status = ts_continuous_agg_hypertable_status(ht->fd.id); if ((status & HypertableIsMaterialization) == 0) return; /* only allow if all commands are allowed */ foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { case AT_AddIndex: case AT_ReAddIndex: case AT_SetRelOptions: case AT_ReplicaIdentity: /* allowed on materialization tables */ continue; default: /* disable by default */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on materialization tables"))); break; } } } static void check_alter_table_allowed_on_ht_with_compression(Hypertable *ht, AlterTableStmt *stmt) { ListCell *lc; if (!TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) return; /* only allow if all commands are allowed */ foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { /* * ALLOWED: * * This is a whitelist of allowed commands. */ case AT_AddIndex: case AT_AddConstraint: case AT_ReAddIndex: case AT_ResetRelOptions: case AT_ReplaceRelOptions: case AT_SetRelOptions: case AT_ClusterOn: case AT_DropCluster: case AT_ChangeOwner: /* this is passed down in `process_altertable_change_owner` */ case AT_SetTableSpace: /* this is passed down in `process_altertable_set_tablespace_end` */ case AT_SetStatistics: /* should this be pushed down in some way? */ case AT_AddColumn: /* this is passed down */ case AT_ColumnDefault: /* this is passed down */ case AT_DropColumn: /* this is passed down */ case AT_DropConstraint: /* this is passed down */ case AT_ReplicaIdentity: case AT_ReAddStatistics: case AT_SetCompression: case AT_DropNotNull: case AT_SetNotNull: case AT_SetAccessMethod: case AT_SetLogged: case AT_SetUnLogged: continue; /* * BLOCKED: * * List things that we want to explicitly block for documentation purposes * But also block everything else as well. */ case AT_EnableRowSecurity: case AT_DisableRowSecurity: case AT_ForceRowSecurity: case AT_NoForceRowSecurity: default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on hypertables that have columnstore " "enabled"))); break; } } } static void check_altertable_add_column_for_compressed(Hypertable *ht, ColumnDef *col) { if (col->constraints) { bool has_default = false; bool has_notnull = col->is_not_null; ListCell *lc; bool is_bool = false; foreach (lc, col->constraints) { Constraint *constraint = lfirst_node(Constraint, lc); switch (constraint->contype) { /* * These will fail in combination with ADD COLUMN because this will * be a single column constraint and we require all partitioning * columns to be part if the unique/primary key constraint. */ case CONSTR_PRIMARY: case CONSTR_UNIQUE: break; /* * We can safelly ignore NULL constraints because it does nothing * and according to Postgres docs is useless and exist just for * compatibility with other database systems * https://www.postgresql.org/docs/current/ddl-constraints.html#id-1.5.4.6.6 */ case CONSTR_NULL: continue; case CONSTR_NOTNULL: has_notnull = true; continue; /* * check constraints are validated at end of alter table command * in validate_check_constraint */ case CONSTR_CHECK: continue; case CONSTR_DEFAULT: /* * Since default expressions might trigger a table rewrite we * only allow Const here for now. */ if (!IsA(constraint->raw_expr, A_Const)) { if (IsA(constraint->raw_expr, TypeCast) && IsA(castNode(TypeCast, constraint->raw_expr)->arg, A_Const)) { /* * Ignore error only for boolean column, as values like * 'True' or 'False' are treated as TypeCast. */ char *name = strVal(llast(((TypeCast *) constraint->raw_expr)->typeName->names)); is_bool = strstr(name, "bool") ? true : false; } if (!is_bool) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "cannot add column with non-constant default expression " "to a hypertable that has columnstore enabled"))); } has_default = true; continue; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add column with constraints " "to a hypertable that has columnstore enabled"))); break; } } /* require a default for columns added with NOT NULL */ if (has_notnull && !has_default) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add column with NOT NULL constraint without default " "to a hypertable that has columnstore enabled"))); } } if (col->is_not_null || col->identitySequence != NULL) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add column with constraints to a hypertable that has " "columnstore enabled"))); } /* not possible to get non-null value here this is set when * ALTER TABLE ALTER COLUMN ... SET TYPE < > USING ... * but check anyway. */ Assert(col->raw_default == NULL && col->cooked_default == NULL); } static void relation_not_only(RangeVar *rv) { if (!rv->inh) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("ONLY option not supported on hypertable operations"))); } static bool check_table_in_rangevar_list(List *rvlist, Name schema_name, Name table_name) { ListCell *l; foreach (l, rvlist) { RangeVar *rvar = lfirst_node(RangeVar, l); if (strcmp(rvar->relname, NameStr(*table_name)) == 0 && strcmp(rvar->schemaname, NameStr(*schema_name)) == 0) return true; } return false; } static void add_chunk_oid(Hypertable *ht, Oid chunk_relid, void *vargs) { ProcessUtilityArgs *args = vargs; GrantStmt *stmt = castNode(GrantStmt, args->parsetree); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); /* * If chunk is in the same schema as the hypertable it could already be part of * the objects list in the case of "GRANT ALL IN SCHEMA" for example */ if (!check_table_in_rangevar_list(stmt->objects, &chunk->fd.schema_name, &chunk->fd.table_name)) { RangeVar *rv = makeRangeVar(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), -1); stmt->objects = lappend(stmt->objects, rv); } } static DDLResult process_drop_schema_start(DropStmt *stmt) { /* * An error will be raised when we start dropping the functions used by a * background worker, so there is no point in doing anything here. */ if (stmt->behavior == DROP_RESTRICT) return DDL_CONTINUE; /* * Here we are relying on that if we fail to drop one of the * procedures/functions, this transaction will be rolled back so these * changes will not be committed. */ ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, RowExclusiveLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { ListCell *cell; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool schema_isnull, job_id_isnull; int32 job_id = DatumGetInt32(slot_getattr(ti->slot, Anum_bgw_job_id, &job_id_isnull)); Name proc_schema = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_schema, &schema_isnull)); Ensure(!job_id_isnull, "corrupt job entry: job id is null"); Ensure(!schema_isnull, "corrupt job entry: schema for job %d is null", job_id); foreach (cell, stmt->objects) { String *object = lfirst_node(String, cell); if (namestrcmp(proc_schema, strVal(object)) == 0) { CatalogSecurityContext sec_ctx; Assert(stmt->behavior == DROP_CASCADE); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ereport(NOTICE, errmsg("drop cascades to job %d", job_id)); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); } } } return DDL_CONTINUE; } /* * Start of dropping a procedure. * * We can abort the drop here by throwing an error. */ static void process_drop_procedure_start(DropStmt *stmt) { ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, RowExclusiveLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { ListCell *cell; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool schema_isnull, name_isnull, job_id_isnull; Name proc_schema = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_schema, &schema_isnull)); Name proc_name = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_name, &name_isnull)); int32 job_id = DatumGetInt32(slot_getattr(ti->slot, Anum_bgw_job_id, &job_id_isnull)); Ensure(!job_id_isnull, "corrupt job entry: job id was null"); Ensure(!schema_isnull, "corrupt job entry: schema for job %d was null", job_id); Ensure(!name_isnull, "corrupt job entry: name for job %d was null", job_id); TS_DEBUG_LOG("looking at job %d with %s.%s", job_id, NameStr(*proc_schema), NameStr(*proc_name)); foreach (cell, stmt->objects) { ObjectWithArgs *object = castNode(ObjectWithArgs, lfirst(cell)); RangeVar *rel = makeRangeVarFromNameList(object->objname); if (namestrcmp(proc_schema, rel->schemaname) == 0 && namestrcmp(proc_name, rel->relname) == 0) { Assert(stmt->removeType == OBJECT_PROCEDURE || stmt->removeType == OBJECT_FUNCTION); if (stmt->behavior == DROP_RESTRICT) { ereport(ERROR, errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST), errmsg("cannot drop %s because background job %d depends on it", NameListToString(object->objname), job_id), errhint("Use delete_job() to drop the job first.")); } else { CatalogSecurityContext sec_ctx; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ereport(NOTICE, errmsg("drop cascades to job %d", job_id)); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); } } } } } static void replace_attr_if_changed(AttrNumber attno, const char *newvalue, Name name_buf, Datum *values, bool *replace) { if (newvalue) { const Name orig_value = DatumGetName(values[AttrNumberGetAttrOffset(attno)]); if (namestrcmp(orig_value, newvalue) != 0) { namestrcpy(name_buf, newvalue); values[AttrNumberGetAttrOffset(attno)] = NameGetDatum(name_buf); replace[AttrNumberGetAttrOffset(attno)] = true; } } } /* * Update the schema or name of a procedure in the jobs tuple. */ static void ts_bgw_job_update_proc(Relation rel, HeapTuple tuple, TupleDesc tupledesc, const char *newschema, const char *newname) { bool isnull[Natts_bgw_job]; Datum values[Natts_bgw_job]; bool replace[Natts_bgw_job] = { false }; /* Allocated here to make sure that they are alive at the call of * heap_modify_tuple */ NameData proc_name_buf; NameData proc_schema_buf; heap_deform_tuple(tuple, tupledesc, values, isnull); replace_attr_if_changed(Anum_bgw_job_proc_name, newname, &proc_name_buf, values, replace); replace_attr_if_changed(Anum_bgw_job_proc_schema, newschema, &proc_schema_buf, values, replace); HeapTuple new_tuple = heap_modify_tuple(tuple, tupledesc, values, isnull, replace); ts_catalog_update(rel, new_tuple); heap_freetuple(new_tuple); } static void ts_bgw_job_rename_schema_name(const char *old_schema_name, const char *new_schema_name) { ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, RowExclusiveLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { bool should_free, curr_schema_isnull, curr_name_isnull; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Name curr_proc_schema = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_schema, &curr_schema_isnull)); Name curr_proc_name = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_name, &curr_name_isnull)); if (!curr_schema_isnull && namestrcmp(curr_proc_schema, old_schema_name) == 0) { HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); ts_bgw_job_update_proc(ti->scanrel, tuple, ts_scanner_get_tupledesc(ti), new_schema_name, NameStr(*curr_proc_name)); if (should_free) heap_freetuple(tuple); } } } static DDLResult ts_bgw_job_rename_proc(ObjectAddress address, const char *newschema, const char *newname) { ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, RowExclusiveLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { bool should_free, curr_schema_isnull, curr_name_isnull; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Name curr_proc_schema = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_schema, &curr_schema_isnull)); Name curr_proc_name = DatumGetName(slot_getattr(ti->slot, Anum_bgw_job_proc_name, &curr_name_isnull)); const char *old_proc_schema = get_namespace_name(get_func_namespace(address.objectId)); const char *old_proc_name = get_func_name(address.objectId); if (!curr_schema_isnull && !curr_name_isnull && namestrcmp(curr_proc_name, old_proc_name) == 0 && namestrcmp(curr_proc_schema, old_proc_schema) == 0) { HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); ts_bgw_job_update_proc(ti->scanrel, tuple, ts_scanner_get_tupledesc(ti), newschema, newname); if (should_free) heap_freetuple(tuple); } } return DDL_CONTINUE; } static void process_alterprocedureschema(ProcessUtilityArgs *args) { AlterObjectSchemaStmt *stmt = (AlterObjectSchemaStmt *) args->parsetree; Relation relation; Assert(stmt->objectType == OBJECT_PROCEDURE || stmt->objectType == OBJECT_FUNCTION); ObjectAddress address = get_object_address(stmt->objectType, stmt->object, &relation, AccessExclusiveLock, false); ts_bgw_job_rename_proc(address, stmt->newschema, NULL); } /* We use this for both materialized views and views. */ static void process_alterviewschema(ProcessUtilityArgs *args) { AlterObjectSchemaStmt *stmt = (AlterObjectSchemaStmt *) args->parsetree; Oid relid; char *schema; char *name; Assert(stmt->objectType == OBJECT_MATVIEW || stmt->objectType == OBJECT_VIEW); if (NULL == stmt->relation) return; relid = RangeVarGetRelid(stmt->relation, NoLock, true); if (!OidIsValid(relid)) return; schema = get_namespace_name(get_rel_namespace(relid)); name = get_rel_name(relid); ts_continuous_agg_rename_view(schema, name, stmt->newschema, name, &stmt->objectType); } static void process_altertableschema(ProcessUtilityArgs *args) { AlterObjectSchemaStmt *alterstmt = (AlterObjectSchemaStmt *) args->parsetree; Oid relid; Cache *hcache; Hypertable *ht; Assert(alterstmt->objectType == OBJECT_TABLE); if (NULL == alterstmt->relation) return; relid = RangeVarGetRelid(alterstmt->relation, NoLock, true); if (!OidIsValid(relid)) return; ht = ts_hypertable_cache_get_cache_and_entry(relid, CACHE_FLAG_MISSING_OK, &hcache); if (ht == NULL) { ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(relid); if (cagg) { alterstmt->objectType = OBJECT_MATVIEW; process_alterviewschema(args); ts_cache_release(&hcache); return; } Chunk *chunk = ts_chunk_get_by_relid(relid, false); if (NULL != chunk) ts_chunk_set_schema(chunk, alterstmt->newschema); } else { ts_hypertable_set_schema(ht, alterstmt->newschema); } ts_cache_release(&hcache); } /* Change the schema of a hypertable or a chunk */ static DDLResult process_alterobjectschema(ProcessUtilityArgs *args) { AlterObjectSchemaStmt *alterstmt = (AlterObjectSchemaStmt *) args->parsetree; switch (alterstmt->objectType) { case OBJECT_TABLE: process_altertableschema(args); break; case OBJECT_MATVIEW: case OBJECT_VIEW: process_alterviewschema(args); break; case OBJECT_PROCEDURE: case OBJECT_FUNCTION: process_alterprocedureschema(args); break; default: break; } return DDL_CONTINUE; } static DDLResult process_copy(ProcessUtilityArgs *args) { CopyStmt *stmt = (CopyStmt *) args->parsetree; ts_begin_tss_store_callback(); /* * Needed to add the appropriate number of tuples to the completion tag */ uint64 processed; Hypertable *ht = NULL; Cache *hcache = NULL; Oid relid; if (stmt->relation) { relid = RangeVarGetRelid(stmt->relation, NoLock, true); if (!OidIsValid(relid)) return DDL_CONTINUE; ht = ts_hypertable_cache_get_cache_and_entry(relid, CACHE_FLAG_MISSING_OK, &hcache); if (!ht) { Chunk *chunk = ts_chunk_get_by_relid(relid, false); /* target is neither hypertable nor chunk so let postgres handle it */ if (!chunk) { ts_cache_release(&hcache); return DDL_CONTINUE; } ht = ts_hypertable_get_by_id(chunk->fd.hypertable_id); if (ht->fd.compression_state == HypertableInternalCompressionTable) { /* * For operations on internal compressed chunks we block modifications * if the chunk belongs to a frozen chunk otherwise let postgres handle it. * Uncompressed frozen chunks are intercepted as part of tuple routing. */ Chunk *uncompressed = ts_chunk_get_compressed_chunk_parent(chunk); if (ts_chunk_is_frozen(uncompressed)) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("cannot COPY into chunk belonging to a frozen " "chunk"))); ts_cache_release(&hcache); return DDL_CONTINUE; } } } /* We only copy for COPY FROM (which copies into a hypertable). Since * hypertable data are in the hypertable chunks and no data would be * copied, we skip the copy for COPY TO, but print an informative * message. */ if (!stmt->is_from || !stmt->relation) { if (ht && stmt->relation) ereport(NOTICE, (errmsg("hypertable data are in the chunks, no data will be copied"), errdetail("Data for hypertables are stored in the chunks of a hypertable so " "COPY TO of a hypertable will not copy any data."), errhint("Use \"COPY (SELECT * FROM <hypertable>) TO ...\" to copy all data in " "hypertable, or copy each chunk individually."))); if (hcache) ts_cache_release(&hcache); return DDL_CONTINUE; } PreventCommandIfReadOnly("COPY FROM"); /* Performs acl check in here inside `copy_security_check` */ timescaledb_DoCopy(stmt, args->query_string, &processed, ht); args->completion_tag->commandTag = CMDTAG_COPY; args->completion_tag->nprocessed = processed; ts_cache_release(&hcache); ts_end_tss_store_callback(args->query_string, args->pstmt->stmt_location, args->pstmt->stmt_len, args->pstmt->queryId, args->completion_tag->nprocessed); return DDL_DONE; } typedef void (*process_chunk_t)(Hypertable *ht, Oid chunk_relid, void *arg); typedef void (*mt_process_chunk_t)(int32 hypertable_id, Oid chunk_relid, void *arg); /* * Applies a function to each chunk of a hypertable. * * Returns the number of processed chunks, or -1 if the table was not a * hypertable. */ static int foreach_chunk(Hypertable *ht, process_chunk_t process_chunk, void *arg) { List *chunks; ListCell *lc; int n = 0; if (NULL == ht) return -1; chunks = find_inheritance_children(ht->main_table_relid, NoLock); foreach (lc, chunks) { process_chunk(ht, lfirst_oid(lc), arg); n++; } return n; } /* * Applies a function to each compressed internal chunk of a hypertable. * * Returns the number of processed chunks, or -1 if the table was not a * hypertable. */ static int foreach_compressed_chunk(Hypertable *ht, process_chunk_t process_chunk, void *arg) { List *chunks; ListCell *lc; int n = 0; if (!ht || !ht->fd.compressed_hypertable_id) return -1; chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); foreach (lc, chunks) { Chunk *chunk = lfirst(lc); process_chunk(ht, chunk->table_id, arg); n++; } return n; } static int foreach_chunk_multitransaction(Oid relid, MemoryContext mctx, mt_process_chunk_t process_chunk, void *arg) { Cache *hcache; Hypertable *ht; int32 hypertable_id; List *chunks; ListCell *lc; int num_chunks = -1; StartTransactionCommand(); MemoryContextSwitchTo(mctx); LockRelationOid(relid, AccessShareLock); ht = ts_hypertable_cache_get_cache_and_entry(relid, CACHE_FLAG_MISSING_OK, &hcache); if (NULL == ht) { ts_cache_release(&hcache); CommitTransactionCommand(); return -1; } hypertable_id = ht->fd.id; chunks = find_inheritance_children(ht->main_table_relid, NoLock); ts_cache_release(&hcache); CommitTransactionCommand(); num_chunks = list_length(chunks); foreach (lc, chunks) { process_chunk(hypertable_id, lfirst_oid(lc), arg); } list_free(chunks); return num_chunks; } typedef struct VacuumCtx { VacuumRelation *ht_vacuum_rel; List *chunk_rels; } VacuumCtx; /* Adds a chunk to the list of tables to be vacuumed */ static void add_chunk_to_vacuum(Hypertable *ht, Oid chunk_relid, void *arg) { VacuumCtx *ctx = (VacuumCtx *) arg; Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); VacuumRelation *chunk_vacuum_rel; RangeVar *chunk_range_var; chunk_range_var = copyObject(ctx->ht_vacuum_rel->relation); chunk_range_var->relname = NameStr(chunk->fd.table_name); chunk_range_var->schemaname = NameStr(chunk->fd.schema_name); chunk_vacuum_rel = makeVacuumRelation(chunk_range_var, chunk_relid, ctx->ht_vacuum_rel->va_cols); ctx->chunk_rels = lappend(ctx->chunk_rels, chunk_vacuum_rel); /* If we have a compressed chunk make sure to analyze it as well */ if (chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID) { Chunk *comp_chunk = ts_chunk_get_by_id(chunk->fd.compressed_chunk_id, false); /* Compressed chunk might be missing due to concurrent operations */ if (comp_chunk) { chunk_vacuum_rel = makeVacuumRelation(NULL, comp_chunk->table_id, NIL); ctx->chunk_rels = lappend(ctx->chunk_rels, chunk_vacuum_rel); } } } /* * Construct a list of VacuumRelations for all vacuumable rels in * the current database. This is similar to the PostgresQL get_all_vacuum_rels * from vacuum.c. */ static List * ts_get_all_vacuum_rels(bool is_vacuumcmd) { List *vacrels = NIL; Relation pgclass; TableScanDesc scan; HeapTuple tuple; Cache *hcache = ts_hypertable_cache_pin(); pgclass = table_open(RelationRelationId, AccessShareLock); scan = table_beginscan_catalog(pgclass, 0, NULL); while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL) { Form_pg_class classform = (Form_pg_class) GETSTRUCT(tuple); Oid relid; relid = classform->oid; /* check permissions of relation */ if (!vacuum_is_permitted_for_relation_compat(relid, classform, is_vacuumcmd ? VACOPT_VACUUM : VACOPT_ANALYZE)) continue; /* * We include partitioned tables here; depending on which operation is * to be performed, caller will decide whether to process or ignore * them. */ if (classform->relkind != RELKIND_RELATION && classform->relkind != RELKIND_MATVIEW && classform->relkind != RELKIND_PARTITIONED_TABLE) continue; /* * Build VacuumRelation(s) specifying the table OIDs to be processed. * We omit a RangeVar since it wouldn't be appropriate to complain * about failure to open one of these relations later. */ vacrels = lappend(vacrels, makeVacuumRelation(NULL, relid, NIL)); } table_endscan(scan); table_close(pgclass, AccessShareLock); ts_cache_release(&hcache); return vacrels; } /* Vacuums/Analyzes a hypertable and all of it's chunks */ static DDLResult process_vacuum(ProcessUtilityArgs *args) { VacuumStmt *stmt = (VacuumStmt *) args->parsetree; bool is_toplevel = (args->context == PROCESS_UTILITY_TOPLEVEL); VacuumCtx ctx = { .ht_vacuum_rel = NULL, .chunk_rels = NIL, }; ListCell *lc; Hypertable *ht; List *vacuum_rels = NIL; bool is_vacuumcmd; /* save original VacuumRelation list */ List *saved_stmt_rels = stmt->rels; is_vacuumcmd = stmt->is_vacuumcmd; #if PG16_GE if (is_vacuumcmd) { /* Look for new option ONLY_DATABASE_STATS */ foreach (lc, stmt->options) { DefElem *opt = (DefElem *) lfirst(lc); /* if "only_database_stats" is defined then don't execute our custom code and return to * the postgres execution for the proper validations */ if (strcmp(opt->defname, "only_database_stats") == 0) return DDL_CONTINUE; } } #endif if (stmt->rels == NIL) vacuum_rels = ts_get_all_vacuum_rels(is_vacuumcmd); else { Cache *hcache = ts_hypertable_cache_pin(); foreach (lc, stmt->rels) { VacuumRelation *vacuum_rel = lfirst_node(VacuumRelation, lc); Oid table_relid = vacuum_rel->oid; if (!OidIsValid(table_relid) && vacuum_rel->relation != NULL) table_relid = RangeVarGetRelid(vacuum_rel->relation, NoLock, true); if (OidIsValid(table_relid)) { ht = ts_hypertable_cache_get_entry(hcache, table_relid, CACHE_FLAG_MISSING_OK); if (ht) { ctx.ht_vacuum_rel = vacuum_rel; foreach_chunk(ht, add_chunk_to_vacuum, &ctx); } } vacuum_rels = lappend(vacuum_rels, vacuum_rel); } ts_cache_release(&hcache); } stmt->rels = list_concat(ctx.chunk_rels, vacuum_rels); /* The list of rels to vacuum could be empty if we are only vacuuming a * tiered hypertable with no local chunks. In that case, we don't want to vacuum locally. */ if (list_length(stmt->rels) > 0) { PreventCommandDuringRecovery(is_vacuumcmd ? "VACUUM" : "ANALYZE"); /* ACL permission checks inside vacuum_rel and analyze_rel called by this ExecVacuum */ ExecVacuum(args->parse_state, stmt, is_toplevel); } /* Restore original list. stmt->rels which has references to VacuumRelation list is freed up, however VacuumStmt is not cleaned up because of which there is a crash. */ stmt->rels = saved_stmt_rels; return DDL_DONE; } static void process_truncate_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { TruncateStmt *stmt = arg; ObjectAddress objaddr = { .classId = RelationRelationId, .objectId = chunk_relid, }; performDeletion(&objaddr, stmt->behavior, 0); } static bool relation_should_recurse(RangeVar *rv) { return rv->inh; } /* handle forwarding TRUNCATEs to the chunks of a hypertable */ static void handle_truncate_hypertable(ProcessUtilityArgs *args, TruncateStmt *stmt, Hypertable *ht) { /* Delete the metadata */ ts_chunk_delete_by_hypertable_id(ht->fd.id); /* Drop the chunk tables */ foreach_chunk(ht, process_truncate_chunk, stmt); } /* * Truncate a hypertable. */ static DDLResult process_truncate(ProcessUtilityArgs *args) { TruncateStmt *stmt = (TruncateStmt *) args->parsetree; Cache *hcache = ts_hypertable_cache_pin(); ListCell *cell; List *hypertables = NIL, *mat_hypertables = NIL; List *relations = NIL; bool list_changed = false; MemoryContext oldctx, parsetreectx = GetMemoryChunkContext(args->parsetree); /* For all hypertables, we drop the now empty chunks. We also propagate the * TRUNCATE call to the compressed version of the hypertable, if it exists. */ foreach (cell, stmt->relations) { RangeVar *rv = lfirst(cell); Oid relid; bool list_append = false; if (!rv) continue; /* Grab AccessExclusiveLock, same as regular TRUNCATE processing grabs * below. We just do it preemptively here. */ relid = RangeVarGetRelid(rv, AccessExclusiveLock, true); if (!OidIsValid(relid)) { /* We should add invalid relations to the list to raise error on the * standard_ProcessUtility when we're trying to TRUNCATE a nonexistent relation */ list_append = true; } else { switch (get_rel_relkind(relid)) { case RELKIND_VIEW: { ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(relid); if (cagg) { Hypertable *mat_ht, *raw_ht; if (!relation_should_recurse(rv)) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot truncate only a continuous aggregate"))); mat_ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); Assert(mat_ht != NULL); /* Create list item into the same context of the list */ oldctx = MemoryContextSwitchTo(parsetreectx); rv = makeRangeVar(NameStr(mat_ht->fd.schema_name), NameStr(mat_ht->fd.table_name), -1); MemoryContextSwitchTo(oldctx); /* Invalidate the entire continuous aggregate since it no * longer has any data */ raw_ht = ts_hypertable_get_by_id(cagg->data.raw_hypertable_id); Assert(raw_ht != NULL); ts_cm_functions->continuous_agg_invalidate_mat_ht(raw_ht, mat_ht, TS_TIME_NOBEGIN, TS_TIME_NOEND); /* Additionally, this cagg's materialization hypertable could be the * underlying hypertable for other caggs defined on top of it, in that case * we must update the hypertable invalidation log */ ContinuousAggHypertableStatus agg_status; agg_status = ts_continuous_agg_hypertable_status(mat_ht->fd.id); if (agg_status & HypertableIsRawTable) ts_cm_functions->continuous_agg_invalidate_raw_ht(mat_ht, TS_TIME_NOBEGIN, TS_TIME_NOEND); /* mark list as changed because we'll add the materialization hypertable */ list_changed = true; /* list of materialization hypertables to reset the watermark */ mat_hypertables = lappend(mat_hypertables, mat_ht); /* include the materialization hypertable to the list to be handled by the * proper hypertable and chunk truncate code-path later */ hypertables = lappend(hypertables, mat_ht); } list_append = true; break; } case RELKIND_RELATION: /* TRUNCATE for foreign tables not implemented yet. This will raise an error. */ case RELKIND_FOREIGN_TABLE: { list_append = true; Hypertable *ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (ht) { ContinuousAggHypertableStatus agg_status; agg_status = ts_continuous_agg_hypertable_status(ht->fd.id); if ((agg_status & HypertableIsMaterialization) != 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot TRUNCATE a hypertable underlying a continuous " "aggregate"), errhint("TRUNCATE the continuous aggregate instead."))); if (agg_status == HypertableIsRawTable) { /* The truncation invalidates all associated continuous aggregates */ ts_cm_functions->continuous_agg_invalidate_raw_ht(ht, TS_TIME_NOBEGIN, TS_TIME_NOEND); } if (!relation_should_recurse(rv)) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("cannot truncate only a hypertable"), errhint("Do not specify the ONLY keyword, or use truncate" " only on the chunks directly."))); hypertables = lappend(hypertables, ht); break; } Chunk *chunk = ts_chunk_get_by_relid(relid, false); if (chunk != NULL) { /* this is a chunk */ ht = ts_hypertable_cache_get_entry(hcache, chunk->hypertable_relid, CACHE_FLAG_NONE); /* * Block direct TRUNCATE on frozen chunk. */ if (ts_chunk_is_frozen(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot TRUNCATE frozen chunk \"%s\"", get_rel_name(relid)), errhint("Unfreeze the chunk to TRUNCATE it."))); Assert(ht != NULL); /* If the hypertable has continuous aggregates, then invalidate * the truncated region. */ if (ts_continuous_agg_hypertable_status(ht->fd.id) == HypertableIsRawTable) ts_continuous_agg_invalidate_chunk(ht, chunk); /* Truncate the compressed chunk too */ if (chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID) { Chunk *compressed_chunk = ts_chunk_get_by_id(chunk->fd.compressed_chunk_id, false); if (compressed_chunk != NULL && !compressed_chunk->fd.dropped) { /* Create list item into the same context of the list. */ oldctx = MemoryContextSwitchTo(parsetreectx); rv = makeRangeVar(NameStr(compressed_chunk->fd.schema_name), NameStr(compressed_chunk->fd.table_name), -1); MemoryContextSwitchTo(oldctx); list_changed = true; } } /* if the chunk has statistics enabled on it then reset them */ ts_chunk_column_stats_reset_by_chunk_id(chunk->fd.id); } break; } default: /* * Do nothing for other relation types. This is mostly to * placate the static analyzers. */ break; } } /* Append the relation to the list in the same parse tree memory context */ if (list_append) { MemoryContext oldctx = MemoryContextSwitchTo(parsetreectx); relations = lappend(relations, rv); MemoryContextSwitchTo(oldctx); } } /* Update relations list just when changed to include only tables * that hold data. */ if (list_changed) stmt->relations = relations; if (stmt->relations != NIL) { /* Call standard PostgreSQL handler for remaining tables */ prev_ProcessUtility(args); } /* For all hypertables, we drop the now empty chunks */ foreach (cell, hypertables) { Hypertable *ht = lfirst(cell); Assert(ht != NULL); handle_truncate_hypertable(args, stmt, ht); /* propagate to the compressed hypertable */ if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { Hypertable *compressed_ht = ts_hypertable_cache_get_entry_by_id(hcache, ht->fd.compressed_hypertable_id); TruncateStmt compressed_stmt = *stmt; compressed_stmt.relations = list_make1(makeRangeVar(NameStr(compressed_ht->fd.schema_name), NameStr(compressed_ht->fd.table_name), -1)); /* TRUNCATE the compressed hypertable */ ExecuteTruncate(&compressed_stmt); handle_truncate_hypertable(args, stmt, compressed_ht); } } /* For all materialization hypertables, reset the watermark */ foreach (cell, mat_hypertables) { Hypertable *mat_ht = lfirst(cell); Assert(mat_ht != NULL); /* Force update the watermark */ bool isnull; int64 watermark = ts_hypertable_get_open_dim_max_value(mat_ht, 0, &isnull); ts_cagg_watermark_update(mat_ht, watermark, isnull, true); } ts_cache_release(&hcache); return DDL_DONE; } static void process_drop_table_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { DropStmt *stmt = arg; ObjectAddress objaddr = { .classId = RelationRelationId, .objectId = chunk_relid, }; ts_compression_settings_delete(chunk_relid); performDeletion(&objaddr, stmt->behavior, 0); } /* Block drop compressed chunks directly and drop corresponding compressed chunks if * cascade is on. */ static void process_drop_chunk(ProcessUtilityArgs *args, DropStmt *stmt) { ListCell *lc; Cache *hcache = ts_hypertable_cache_pin(); foreach (lc, stmt->objects) { List *object = lfirst(lc); RangeVar *relation = makeRangeVarFromNameList(object); ScanTupLock slice_lock = { .lockmode = LockTupleExclusive, .waitpolicy = LockWaitBlock, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; Chunk *chunk; if (NULL == relation) continue; chunk = ts_chunk_get_by_name_with_memory_context(relation->schemaname, relation->relname, AccessExclusiveLock, &slice_lock, CurrentMemoryContext, false); if (chunk != NULL) { Hypertable *ht; if (ts_chunk_contains_compressed_data(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("dropping columnstore chunks not supported"), errhint("Please drop the corresponding chunk on the rowstore hypertable " "instead."))); /* if cascade is enabled, delete the compressed chunk with cascade too. Otherwise * it would be blocked if there are dependent objects */ if (stmt->behavior == DROP_CASCADE && chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID) { Chunk *compressed_chunk = ts_chunk_get_by_id_with_slice_lock(chunk->fd.compressed_chunk_id, AccessExclusiveLock, &slice_lock, false); /* The chunk may have been delete by a CASCADE */ if (compressed_chunk != NULL) ts_chunk_drop(compressed_chunk, stmt->behavior, DEBUG1); } ht = ts_hypertable_cache_get_entry(hcache, chunk->hypertable_relid, CACHE_FLAG_NONE); Assert(ht != NULL); /* If the hypertable has continuous aggregates, then invalidate * the dropped region. */ if (ts_continuous_agg_hypertable_status(ht->fd.id) == HypertableIsRawTable) ts_continuous_agg_invalidate_chunk(ht, chunk); } } ts_cache_release(&hcache); } /* * We need to drop hypertable chunks and associated compressed hypertables * when dropping hypertables to maintain correct semantics wrt CASCADE modifiers. * Also block dropping compressed hypertables directly. */ static DDLResult process_drop_hypertable(ProcessUtilityArgs *args, DropStmt *stmt) { Cache *hcache = ts_hypertable_cache_pin(); ListCell *lc; DDLResult result = DDL_CONTINUE; foreach (lc, stmt->objects) { List *object = lfirst(lc); RangeVar *relation = makeRangeVarFromNameList(object); Oid relid; if (NULL == relation) continue; relid = RangeVarGetRelid(relation, NoLock, true); if (OidIsValid(relid)) { Hypertable *ht; ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (ht) { if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("dropping columnstore hypertables not supported"), errhint("Please drop the corresponding rowstore hypertable " "instead."))); /* * We need to drop hypertable chunks before the hypertable to avoid the need * to CASCADE such drops; */ foreach_chunk(ht, process_drop_table_chunk, stmt); /* The usual path for deleting an associated compressed hypertable uses * DROP_RESTRICT But if we are using DROP_CASCADE we should propagate that down to * the compressed hypertable. */ if (stmt->behavior == DROP_CASCADE && TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { Hypertable *compressed_hypertable = ts_hypertable_get_by_id(ht->fd.compressed_hypertable_id); List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); foreach (lc, chunks) { Chunk *chunk = lfirst(lc); if (OidIsValid(chunk->table_id)) { ObjectAddress chunk_addr = (ObjectAddress){ .classId = RelationRelationId, .objectId = chunk->table_id, }; /* Drop the postgres table */ performDeletion(&chunk_addr, stmt->behavior, 0); } } ts_hypertable_drop(compressed_hypertable, DROP_CASCADE); } } result = DDL_DONE; } } ts_cache_release(&hcache); return result; } /* * We need to ensure that DROP INDEX uses only one hypertable per query, * otherwise query string might not be reusable for execution on a * data node. */ static void process_drop_hypertable_index(ProcessUtilityArgs *args, DropStmt *stmt) { Cache *hcache = ts_hypertable_cache_pin(); ListCell *lc; foreach (lc, stmt->objects) { List *object = lfirst(lc); RangeVar *relation = makeRangeVarFromNameList(object); Oid ht_relid, index_relid; Hypertable *ht; if (NULL == relation) continue; index_relid = RangeVarGetRelid(relation, NoLock, true); if (!OidIsValid(index_relid)) continue; ht_relid = IndexGetRelation(index_relid, true); if (!OidIsValid(ht_relid)) continue; ht = ts_hypertable_cache_get_entry(hcache, ht_relid, CACHE_FLAG_MISSING_OK); if (ht) { List *chunk_indexes = ts_chunk_index_get_mappings(ht, index_relid); ListCell *lc_index; foreach (lc_index, chunk_indexes) { ChunkIndexMapping *mapping = lfirst(lc_index); Oid chunk_relid = mapping->indexoid; char *schema_name = get_namespace_name(get_rel_namespace(chunk_relid)); char *index_name = get_rel_name(chunk_relid); stmt->objects = lappend(stmt->objects, list_make2(makeString(schema_name), makeString(index_name))); } } } ts_cache_release(&hcache); } /* Note that DROP TABLESPACE does not have a hook in event triggers so cannot go * through process_ddl_sql_drop */ static DDLResult process_drop_tablespace(ProcessUtilityArgs *args) { DropTableSpaceStmt *stmt = (DropTableSpaceStmt *) args->parsetree; int count = ts_tablespace_count_attached(stmt->tablespacename); if (count > 0) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("tablespace \"%s\" is still attached to %d hypertables", stmt->tablespacename, count), errhint("Detach the tablespace from all hypertables before removing it."))); return DDL_CONTINUE; } static void process_grant_add_by_rel(GrantStmt *stmt, RangeVar *relation) { stmt->objects = lappend(stmt->objects, relation); } /* * If it is a "GRANT/REVOKE ON ALL TABLES IN SCHEMA" operation then we need to check if * the rangevar was already added when we added all objects inside the SCHEMA * * This could get a little expensive for schemas containing a lot of objects.. */ static void process_grant_add_by_name(GrantStmt *stmt, bool was_schema_op, Name schema_name, Name table_name) { bool already_added = false; if (was_schema_op) already_added = check_table_in_rangevar_list(stmt->objects, schema_name, table_name); if (!already_added) process_grant_add_by_rel(stmt, makeRangeVar(NameStr(*schema_name), NameStr(*table_name), -1)); } static void process_relations_in_namespace(GrantStmt *stmt, Name schema_name, Oid namespaceId, char relkind) { ScanKeyData key[2]; Relation rel; TableScanDesc scan; HeapTuple tuple; ScanKeyInit(&key[0], Anum_pg_class_relnamespace, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(namespaceId)); ScanKeyInit(&key[1], Anum_pg_class_relkind, BTEqualStrategyNumber, F_CHAREQ, CharGetDatum(relkind)); rel = table_open(RelationRelationId, AccessShareLock); scan = table_beginscan_catalog(rel, 2, key); while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL) { Name relname = palloc(NAMEDATALEN); namestrcpy(relname, NameStr(((Form_pg_class) GETSTRUCT(tuple))->relname)); /* these are being added for the first time into this list */ process_grant_add_by_name(stmt, false, schema_name, relname); } table_endscan(scan); table_close(rel, AccessShareLock); } /* * For "GRANT ALL ON ALL TABLES IN SCHEMA" GrantStmt, the targtype field is ACL_TARGET_ALL_IN_SCHEMA * whereas in regular "GRANT ON TABLE table_name", the targtype field is ACL_TARGET_OBJECT. In the * latter case the objects list contains a list of relation range vars whereas in the former it is * the list of schema names. * * To make things work we change the targtype field from ACL_TARGET_ALL_IN_SCHEMA to * ACL_TARGET_OBJECT and then create a new list of rangevars of all relation type entities in it and * assign it to the "stmt->objects" field. * */ static void process_grant_add_by_schema(GrantStmt *stmt) { ListCell *cell; List *nspnames = stmt->objects; /* * We will be adding rangevars to the "stmt->objects" field in the loop below. So * we track the nspnames separately above and NIL out the objects list */ stmt->objects = NIL; foreach (cell, nspnames) { char *nspname = strVal(lfirst(cell)); Oid namespaceId = LookupExplicitNamespace(nspname, false); Name schema; schema = (Name) palloc(NAMEDATALEN); namestrcpy(schema, nspname); /* Inspired from objectsInSchemaToOids PG function */ process_relations_in_namespace(stmt, schema, namespaceId, RELKIND_RELATION); process_relations_in_namespace(stmt, schema, namespaceId, RELKIND_VIEW); process_relations_in_namespace(stmt, schema, namespaceId, RELKIND_MATVIEW); process_relations_in_namespace(stmt, schema, namespaceId, RELKIND_FOREIGN_TABLE); process_relations_in_namespace(stmt, schema, namespaceId, RELKIND_PARTITIONED_TABLE); } /* change targtype to ACL_TARGET_OBJECT now */ stmt->targtype = ACL_TARGET_OBJECT; } /* * Handle GRANT / REVOKE. * * A revoke is a GrantStmt with 'is_grant' set to false. */ static DDLResult process_grant_and_revoke(ProcessUtilityArgs *args) { GrantStmt *stmt = (GrantStmt *) args->parsetree; DDLResult result = DDL_CONTINUE; /* We let the calling function handle anything that is not * ACL_TARGET_OBJECT or ACL_TARGET_ALL_IN_SCHEMA */ if (stmt->targtype != ACL_TARGET_OBJECT && stmt->targtype != ACL_TARGET_ALL_IN_SCHEMA) return DDL_CONTINUE; switch (stmt->objtype) { case OBJECT_TABLESPACE: /* * If we are granting on a tablespace, we need to apply the REVOKE * first to be able to check remaining permissions. */ prev_ProcessUtility(args); ts_tablespace_validate_revoke(stmt); result = DDL_DONE; break; case OBJECT_TABLE: /* * Collect the hypertables in the grant statement. We only need to * consider those when sending grants to other data nodes. */ { Cache *hcache; ListCell *cell; List *saved_schema_objects = NIL; bool was_schema_op = false; /* * If it's a GRANT/REVOKE ALL IN SCHEMA then we need to collect all * objects in this schema and convert this into an ACL_TARGET_OBJECT * entry with its objects field pointing to rangevars */ if (stmt->targtype == ACL_TARGET_ALL_IN_SCHEMA) { saved_schema_objects = stmt->objects; process_grant_add_by_schema(stmt); was_schema_op = true; } hcache = ts_hypertable_cache_pin(); /* First process all continuous aggregates in the list and add * the associated hypertables and views to the list of objects * to process */ foreach (cell, stmt->objects) { RangeVar *relation = lfirst_node(RangeVar, cell); ContinuousAgg *const cagg = ts_continuous_agg_find_by_rv(relation); if (cagg) { Hypertable *mat_hypertable = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); process_grant_add_by_name(stmt, was_schema_op, &mat_hypertable->fd.schema_name, &mat_hypertable->fd.table_name); process_grant_add_by_name(stmt, was_schema_op, &cagg->data.direct_view_schema, &cagg->data.direct_view_name); process_grant_add_by_name(stmt, was_schema_op, &cagg->data.partial_view_schema, &cagg->data.partial_view_name); } /* * If this is a hypertable and it has a compressed * hypertable associated with it, add it to the list of * hypertables to process. */ Hypertable *hypertable = ts_hypertable_cache_get_entry_rv(hcache, relation); if (hypertable && TS_HYPERTABLE_HAS_COMPRESSION_TABLE(hypertable)) { Hypertable *compressed_hypertable = ts_hypertable_get_by_id(hypertable->fd.compressed_hypertable_id); Assert(compressed_hypertable); process_grant_add_by_name(stmt, was_schema_op, &compressed_hypertable->fd.schema_name, &compressed_hypertable->fd.table_name); List *chunks = ts_chunk_get_by_hypertable_id(hypertable->fd.compressed_hypertable_id); ListCell *cell; foreach (cell, chunks) { Chunk *chunk = lfirst(cell); process_grant_add_by_name(stmt, was_schema_op, &chunk->fd.schema_name, &chunk->fd.table_name); } } } /* Process all hypertables, including those added in the loop above */ foreach (cell, stmt->objects) { RangeVar *relation = lfirst_node(RangeVar, cell); Hypertable *ht = ts_hypertable_cache_get_entry_rv(hcache, relation); if (ht) { foreach_chunk(ht, add_chunk_oid, args); } } ts_cache_release(&hcache); result = DDL_DONE; if (stmt->objects != NIL) prev_ProcessUtility(args); /* Restore ALL IN SCHEMA command type and it's objects */ if (was_schema_op) { stmt->targtype = ACL_TARGET_ALL_IN_SCHEMA; stmt->objects = saved_schema_objects; } break; } default: break; } return result; } static DDLResult process_grant_and_revoke_role(ProcessUtilityArgs *args) { GrantRoleStmt *stmt = (GrantRoleStmt *) args->parsetree; /* * Need to apply the REVOKE first to be able to check remaining * permissions */ prev_ProcessUtility(args); /* We only care about revokes and setting privileges on a specific object */ if (stmt->is_grant) return DDL_DONE; ts_tablespace_validate_revoke_role(stmt); return DDL_DONE; } static void process_drop_view_start(ProcessUtilityArgs *args, DropStmt *stmt) { ListCell *cell; foreach (cell, stmt->objects) { List *const object = lfirst(cell); RangeVar *const rv = makeRangeVarFromNameList(object); ContinuousAgg *const cagg = ts_continuous_agg_find_by_rv(rv); if (cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot drop continuous aggregate using DROP VIEW"), errhint("Use DROP MATERIALIZED VIEW to drop a continuous aggregate."))); } } static void process_drop_continuous_aggregates(ProcessUtilityArgs *args, DropStmt *stmt) { ListCell *lc; int caggs_count = 0; foreach (lc, stmt->objects) { List *const object = lfirst(lc); RangeVar *const rv = makeRangeVarFromNameList(object); ContinuousAgg *const cagg = ts_continuous_agg_find_by_rv(rv); if (cagg) { /* If there is at least one cagg, the drop should be treated as a * DROP VIEW. */ stmt->removeType = OBJECT_VIEW; ++caggs_count; } } /* We check that there were only continuous aggregates or that there were no continuous aggregates. Otherwise, we have a mixture of tables and views and are looking for views only.*/ if (caggs_count > 0 && caggs_count < list_length(stmt->objects)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("mixing continuous aggregates and other objects not allowed"), errhint("Drop continuous aggregates and other objects in separate statements."))); } static bool fetch_role_info(RoleSpec *rolespec, Oid *roleid) { /* Special role specifiers should not be present when dropping a role, * but if they are, we just ignore them */ if (rolespec->roletype != ROLESPEC_CSTRING) return false; /* Fetch the heap tuple from system table. If heaptuple is not valid it * means we did not find a role. We ignore it since the real execution * will handle this. */ HeapTuple tuple = SearchSysCache1(AUTHNAME, PointerGetDatum(rolespec->rolename)); if (!HeapTupleIsValid(tuple)) return false; Form_pg_authid roleform = (Form_pg_authid) GETSTRUCT(tuple); *roleid = roleform->oid; ReleaseSysCache(tuple); return true; } static DDLResult process_drop_role(ProcessUtilityArgs *args) { DropRoleStmt *stmt = (DropRoleStmt *) args->parsetree; ListCell *cell; foreach (cell, stmt->roles) { RoleSpec *rolespec = lfirst(cell); Oid roleid; if (!fetch_role_info(rolespec, &roleid)) continue; ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, AccessShareLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { bool isnull; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Datum value = slot_getattr(ti->slot, Anum_bgw_job_owner, &isnull); if (!isnull && DatumGetObjectId(value) == roleid) { Datum value = slot_getattr(ti->slot, Anum_bgw_job_id, &isnull); Ensure(!isnull, "job id was null"); ereport(ERROR, (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST), errmsg("role \"%s\" cannot be dropped because some objects depend on it", rolespec->rolename), errdetail("owner of job %d", DatumGetInt32(value)))); } } } return DDL_CONTINUE; } static DDLResult process_drop_start(ProcessUtilityArgs *args) { DropStmt *stmt = (DropStmt *) args->parsetree; switch (stmt->removeType) { case OBJECT_TABLE: process_drop_hypertable(args, stmt); TS_FALLTHROUGH; case OBJECT_FOREIGN_TABLE: /* Chunks can be either normal tables, or foreign tables in the case of a tiered * hypertable */ process_drop_chunk(args, stmt); break; case OBJECT_INDEX: process_drop_hypertable_index(args, stmt); break; case OBJECT_MATVIEW: process_drop_continuous_aggregates(args, stmt); break; case OBJECT_VIEW: process_drop_view_start(args, stmt); break; case OBJECT_PROCEDURE: case OBJECT_FUNCTION: process_drop_procedure_start(stmt); break; case OBJECT_SCHEMA: process_drop_schema_start(stmt); break; default: break; } return DDL_CONTINUE; } static void reindex_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { ProcessUtilityArgs *args = arg; ReindexStmt *stmt = (ReindexStmt *) args->parsetree; Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); switch (stmt->kind) { case REINDEX_OBJECT_TABLE: stmt->relation->relname = NameStr(chunk->fd.table_name); stmt->relation->schemaname = NameStr(chunk->fd.schema_name); ExecReindex(NULL, stmt, false); break; case REINDEX_OBJECT_INDEX: /* Not supported, a.t.m. See note in process_reindex(). */ break; default: break; } } /* * Reindex a hypertable and all its chunks. Currently works only for REINDEX * TABLE. */ static DDLResult process_reindex(ProcessUtilityArgs *args) { ReindexStmt *stmt = (ReindexStmt *) args->parsetree; Oid relid; Cache *hcache; Hypertable *ht; DDLResult result = DDL_CONTINUE; if (NULL == stmt->relation) /* Not a case we are interested in */ return DDL_CONTINUE; relid = RangeVarGetRelid(stmt->relation, NoLock, true); if (!OidIsValid(relid)) return DDL_CONTINUE; hcache = ts_hypertable_cache_pin(); switch (stmt->kind) { case REINDEX_OBJECT_TABLE: ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (NULL != ht) { PreventCommandDuringRecovery("REINDEX"); ts_hypertable_permissions_check_by_id(ht->fd.id); if (get_reindex_options(stmt) & REINDEXOPT_CONCURRENTLY) ereport(ERROR, (errmsg("concurrent index creation on hypertables is not supported"))); if (foreach_chunk(ht, reindex_chunk, args) >= 0) result = DDL_DONE; } break; case REINDEX_OBJECT_INDEX: ht = ts_hypertable_cache_get_entry(hcache, IndexGetRelation(relid, true), CACHE_FLAG_MISSING_OK); if (NULL != ht) { ts_hypertable_permissions_check_by_id(ht->fd.id); /* * Recursing to chunks is currently not supported. Need to * look up all chunk indexes that corresponds to the * hypertable's index. */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("reindexing of a specific index on a hypertable is unsupported"), errhint( "As a workaround, it is possible to run REINDEX TABLE to reindex all " "indexes on a hypertable, including all indexes on chunks."))); } break; default: break; } ts_cache_release(&hcache); return result; } static void process_rename_view(Oid relid, RenameStmt *stmt) { char *schema = get_namespace_name(get_rel_namespace(relid)); char *name = get_rel_name(relid); ts_continuous_agg_rename_view(schema, name, schema, stmt->newname, &stmt->renameType); } /* * Rename a hypertable, chunk or continuous aggregate. */ static void process_rename_table(ProcessUtilityArgs *args, Cache *hcache, Oid relid, RenameStmt *stmt) { Hypertable *ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (NULL == ht) { ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(relid); if (cagg) { stmt->renameType = OBJECT_MATVIEW; process_rename_view(relid, stmt); return; } Chunk *chunk = ts_chunk_get_by_relid(relid, false); if (NULL != chunk) ts_chunk_set_name(chunk, stmt->newname); } else { ts_hypertable_set_name(ht, stmt->newname); } } static void process_rename_column(ProcessUtilityArgs *args, Cache *hcache, Oid relid, RenameStmt *stmt) { Hypertable *ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); Dimension *dim; if (!ht) { Chunk *chunk = ts_chunk_get_by_relid(relid, false); if (chunk) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot rename column \"%s\" of hypertable chunk \"%s\"", stmt->subname, get_rel_name(relid)), errhint("Rename the hypertable column instead."))); /* This was not a hypertable and not a chunk, but it could be a * continuous aggregate. * * If this is a continuous aggregate, the rename should be done on the * materialized table. Since the partial view and the direct view are * not referencing the materialized table, we need to handle it here, * and in addition, the dimension table contains the column name, we * need to update the name there. */ ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(relid); if (cagg) { RenameStmt *direct_view_stmt = castNode(RenameStmt, copyObject(stmt)); direct_view_stmt->relation = makeRangeVar(NameStr(cagg->data.direct_view_schema), NameStr(cagg->data.direct_view_name), -1); ExecRenameStmt(direct_view_stmt); RenameStmt *partial_view_stmt = castNode(RenameStmt, copyObject(stmt)); partial_view_stmt->relation = makeRangeVar(NameStr(cagg->data.partial_view_schema), NameStr(cagg->data.partial_view_name), -1); ExecRenameStmt(partial_view_stmt); /* Fetch the main table and it's relid and use that for the * processing below. This is necessary to rebuild the view based * on the table with the renamed columns. */ ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); relid = ht->main_table_relid; RenameStmt *mat_hypertable_stmt = castNode(RenameStmt, copyObject(stmt)); mat_hypertable_stmt->relation = makeRangeVar(NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), -1); ExecRenameStmt(mat_hypertable_stmt); } } else { /* Block renaming columns on the materialization table of a continuous * agg, but only if this was an explicit request for rename on a * materialization table. */ if ((ts_continuous_agg_hypertable_status(ht->fd.id) & HypertableIsMaterialization) != 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("renaming columns on materialization tables is not supported"), errdetail("Column \"%s\" in materialization table \"%s\".", stmt->subname, get_rel_name(relid)), errhint("Rename the column on the continuous aggregate instead."))); } /* * If there were a hypertable or a continuous aggregate, we need to rename * the dimension that we used as well as rebuilding the view. Otherwise, * we don't do anything. * * If it's not a dimension then we also need to check if column statistics * have been enabled on this column. * */ if (ht) { ts_compression_settings_rename_column_cascade(ht->main_table_relid, stmt->subname, stmt->newname); dim = ts_hyperspace_get_mutable_dimension_by_name(ht->space, DIMENSION_TYPE_ANY, stmt->subname); if (dim) ts_dimension_set_name(dim, stmt->newname); else { Form_chunk_column_stats form = ts_chunk_column_stats_lookup(ht->fd.id, INVALID_CHUNK_ID, stmt->subname); if (form != NULL) { ts_chunk_column_stats_set_name(form, stmt->newname); /* refresh the ht entry to accommodate this rename */ if (ht->range_space) pfree(ht->range_space); ht->range_space = ts_chunk_column_stats_range_space_scan(ht->fd.id, ht->main_table_relid, ts_cache_memory_ctx(hcache)); } } if (ts_cm_functions->process_rename_cmd) ts_cm_functions->process_rename_cmd(relid, hcache, stmt); } } static void process_rename_index(ProcessUtilityArgs *args, Cache *hcache, Oid relid, RenameStmt *stmt) { Oid tablerelid = IndexGetRelation(relid, true); Hypertable *ht; if (!OidIsValid(tablerelid)) return; ht = ts_hypertable_cache_get_entry(hcache, tablerelid, CACHE_FLAG_MISSING_OK); if (ht) { ts_chunk_index_rename(ht, relid, stmt->newname); } } /* Visit all internal catalog tables with a schema column to check for applicable rename */ static void process_rename_schema(RenameStmt *stmt) { int i = 0; /* Block any renames of our internal schemas */ for (i = 0; i < NUM_TIMESCALEDB_SCHEMAS; i++) { if (strncmp(stmt->subname, ts_extension_schema_names[i], NAMEDATALEN) == 0) { ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot rename schemas used by the TimescaleDB extension"))); return; } } ts_bgw_job_rename_schema_name(stmt->subname, stmt->newname); ts_chunks_rename_schema_name(stmt->subname, stmt->newname); ts_dimensions_rename_schema_name(stmt->subname, stmt->newname); ts_hypertables_rename_schema_name(stmt->subname, stmt->newname); ts_continuous_agg_rename_schema_name(stmt->subname, stmt->newname); } static void process_rename_procedure(ProcessUtilityArgs *args) { RenameStmt *stmt = (RenameStmt *) args->parsetree; Relation relation; ObjectAddress address = get_object_address(stmt->renameType, stmt->object, &relation, AccessExclusiveLock, false); ts_bgw_job_rename_proc(address, NULL, stmt->newname); } static void rename_hypertable_constraint(Hypertable *ht, Oid chunk_relid, void *arg) { RenameStmt *stmt = (RenameStmt *) arg; Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); ts_chunk_constraint_rename_hypertable_constraint(chunk->fd.id, stmt->subname, stmt->newname); } static void alter_hypertable_constraint(Hypertable *ht, Oid chunk_relid, void *arg) { AlterTableCmd *cmd = (AlterTableCmd *) arg; char *hypertable_constraint_name; #if PG18_LT Constraint *cmd_constraint; Assert(IsA(cmd->def, Constraint)); cmd_constraint = (Constraint *) cmd->def; #else /* PG18 adds ATAlterConstraint struct which is used * instead of Constraint struct * * https://github.com/postgres/postgres/commit/80d7f990 */ ATAlterConstraint *cmd_constraint; Assert(IsA(cmd->def, ATAlterConstraint)); cmd_constraint = (ATAlterConstraint *) cmd->def; #endif hypertable_constraint_name = cmd_constraint->conname; cmd_constraint->conname = ts_chunk_constraint_get_name_from_hypertable_constraint(chunk_relid, hypertable_constraint_name); AlterTableInternal(chunk_relid, list_make1(cmd), false); /* Restore for next iteration */ cmd_constraint->conname = hypertable_constraint_name; } static void validate_hypertable_constraint(Hypertable *ht, Oid chunk_relid, void *arg) { AlterTableCmd *cmd = (AlterTableCmd *) arg; AlterTableCmd *chunk_cmd = copyObject(cmd); chunk_cmd->name = ts_chunk_constraint_get_name_from_hypertable_constraint(chunk_relid, cmd->name); if (chunk_cmd->name == NULL) return; /* do not pass down the VALIDATE RECURSE subtype */ chunk_cmd->subtype = AT_ValidateConstraint; AlterTableInternal(chunk_relid, list_make1(chunk_cmd), false); } static void rename_hypertable_trigger(Hypertable *ht, Oid chunk_relid, void *arg) { RenameStmt *stmt = copyObject(castNode(RenameStmt, arg)); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); stmt->relation = makeRangeVar(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), 0); renametrig(stmt); } static void process_rename_constraint_or_trigger(ProcessUtilityArgs *args, Cache *hcache, Oid relid, RenameStmt *stmt) { Hypertable *ht; ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); Assert(stmt->relation != NULL); if (NULL != ht) { relation_not_only(stmt->relation); if (stmt->renameType == OBJECT_TABCONSTRAINT) foreach_chunk(ht, rename_hypertable_constraint, stmt); else if (stmt->renameType == OBJECT_TRIGGER) foreach_chunk(ht, rename_hypertable_trigger, stmt); } else if (stmt->renameType == OBJECT_TABCONSTRAINT) { Chunk *chunk = ts_chunk_get_by_relid(relid, false); if (NULL != chunk) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("renaming constraints on chunks is not supported"))); } } static DDLResult process_rename(ProcessUtilityArgs *args) { RenameStmt *stmt = (RenameStmt *) args->parsetree; Oid relid = InvalidOid; Cache *hcache; /* Only get the relid if it exists for this stmt */ if (NULL != stmt->relation) { relid = RangeVarGetRelid(stmt->relation, NoLock, true); if (!OidIsValid(relid)) return DDL_CONTINUE; } hcache = ts_hypertable_cache_pin(); switch (stmt->renameType) { case OBJECT_TABLE: process_rename_table(args, hcache, relid, stmt); break; case OBJECT_COLUMN: process_rename_column(args, hcache, relid, stmt); break; case OBJECT_INDEX: process_rename_index(args, hcache, relid, stmt); break; case OBJECT_TABCONSTRAINT: case OBJECT_TRIGGER: process_rename_constraint_or_trigger(args, hcache, relid, stmt); break; case OBJECT_MATVIEW: case OBJECT_VIEW: process_rename_view(relid, stmt); break; case OBJECT_SCHEMA: process_rename_schema(stmt); break; case OBJECT_PROCEDURE: case OBJECT_FUNCTION: process_rename_procedure(args); break; default: break; } ts_cache_release(&hcache); return DDL_CONTINUE; } static void process_altertable_change_owner_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { AlterTableCmd *cmd = arg; Oid roleid = get_rolespec_oid(cmd->newowner, false); ATExecChangeOwner(chunk_relid, roleid, false, AccessExclusiveLock); } static void process_altertable_change_owner(Hypertable *ht, AlterTableCmd *cmd) { Assert(IsA(cmd->newowner, RoleSpec)); foreach_chunk(ht, process_altertable_change_owner_chunk, cmd); if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { Hypertable *compressed_hypertable = ts_hypertable_get_by_id(ht->fd.compressed_hypertable_id); AlterTableInternal(compressed_hypertable->main_table_relid, list_make1(cmd), false); ListCell *lc; List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); foreach (lc, chunks) { Chunk *chunk = lfirst(lc); AlterTableInternal(chunk->table_id, list_make1(cmd), false); } process_altertable_change_owner(compressed_hypertable, cmd); } } typedef struct ChunkConstraintInfo { const AlterTableCmd *cmd; const char *constraint_name; Oid hypertable_constraint_oid; } ChunkConstraintInfo; /* * Unique constraints are validated by postgres during creation * but the postgres process does not cover data present in compressed * chunks or data split between compressed and uncompressed chunks. * When adding unique constraints to chunks with compressed data we * have to check for constraint violation ourself. */ static void validate_index_constraints(Chunk *chunk, const IndexStmt *stmt) { if ((stmt->primary || stmt->unique) && ts_chunk_is_compressed(chunk)) { StringInfoData command; Oid nspcid = get_rel_namespace(chunk->table_id); ListCell *lc; List *dpcontext = deparse_context_for(get_rel_name(chunk->table_id), chunk->table_id); initStringInfo(&command); appendStringInfo(&command, "SELECT EXISTS(SELECT FROM %s.%s", quote_identifier(get_namespace_name(nspcid)), quote_identifier(get_rel_name(chunk->table_id))); /* * Before PG15 NULLs were always considered distinct, with * PG15 the behaviour became configurable. */ if (!stmt->nulls_not_distinct) { int i = 0; appendStringInfo(&command, " WHERE "); foreach (lc, stmt->indexParams) { i++; IndexElem *elem = lfirst_node(IndexElem, lc); appendStringInfo(&command, "%s IS NOT NULL", elem->name ? quote_identifier(elem->name) : deparse_expression((Node *) elem->expr, dpcontext, false, false)); if (i < list_length(stmt->indexParams)) appendStringInfo(&command, " AND "); } Assert(i > 0); } appendStringInfo(&command, " GROUP BY "); int j = 0; foreach (lc, stmt->indexParams) { j++; IndexElem *elem = lfirst_node(IndexElem, lc); appendStringInfo(&command, "%s", elem->name ? quote_identifier(elem->name) : deparse_expression((Node *) elem->expr, dpcontext, false, false)); if (j < list_length(stmt->indexParams)) appendStringInfo(&command, ","); } Assert(j > 0); appendStringInfo(&command, " HAVING count(*) > 1"); appendStringInfo(&command, ")"); if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); int res = SPI_execute(command.data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not verify unique constraint on \"%s\"", get_rel_name(chunk->table_id))))); bool isnull; Datum has_conflicts = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); Assert(!isnull); if (isnull || DatumGetBool(has_conflicts)) ereport(ERROR, (errcode(ERRCODE_UNIQUE_VIOLATION), (errmsg("duplicate key value violates unique constraint")))); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); } } static void validate_check_constraint(Chunk *chunk, Constraint *con) { if (ts_chunk_is_compressed(chunk)) { StringInfoData command; Oid nspcid = get_rel_namespace(chunk->table_id); ParseState *pstate = make_parsestate(NULL); Relation rel = table_open(chunk->table_id, AccessExclusiveLock); ParseNamespaceItem *nsitem = addRangeTableEntryForRelation(pstate, rel, AccessShareLock, NULL, false, true); addNSItemToQuery(pstate, nsitem, true, true, true); List *context = deparse_context_for(get_rel_name(chunk->table_id), chunk->table_id); Node *tf = transformExpr(pstate, con->raw_expr, EXPR_KIND_CHECK_CONSTRAINT); char *deparsed = deparse_expression(tf, context, false, false); initStringInfo(&command); appendStringInfo(&command, "SELECT EXISTS(SELECT FROM %s.%s WHERE NOT (%s))", quote_identifier(get_namespace_name(nspcid)), quote_identifier(RelationGetRelationName(rel)), deparsed); if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); int res = SPI_execute(command.data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not verify check constraint on \"%s\"", get_rel_name(chunk->table_id))))); bool isnull; Datum has_conflicts = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); Assert(!isnull); if (isnull || DatumGetBool(has_conflicts)) ereport(ERROR, (errcode(ERRCODE_CHECK_VIOLATION), errmsg("check constraint \"%s\" of relation \"%s\" is violated by some row", con->conname, RelationGetRelationName(rel)), errtableconstraint(rel, con->conname))); table_close(rel, NoLock); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); } } static void process_add_constraint_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { const ChunkConstraintInfo *info = arg; Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); switch (info->cmd->subtype) { case AT_AddIndex: if (ts_chunk_is_compressed(chunk)) validate_index_constraints(chunk, castNode(IndexStmt, info->cmd->def)); break; case AT_AddConstraint: #if PG16_LT case AT_AddConstraintRecurse: #endif { Constraint *con = castNode(Constraint, info->cmd->def); switch (con->contype) { /* * Unique and primary key constraints are checked as part of * creation of the index enforcing it so nothing to do here. */ case CONSTR_UNIQUE: case CONSTR_PRIMARY: /* * Foreign key constraints are checked by postgres since * the check happens through SPI and we adjust those queries * to include compressed data. */ case CONSTR_FOREIGN: break; #if PG18_GE /* NULL and NOT NULL constraints have been added to * pg_constraints in PG18, we can safely ignore them at end * just like at beginning. * * https://github.com/postgres/postgres/commit/b0e96f31 */ case CONSTR_NULL: case CONSTR_NOTNULL: break; #endif case CONSTR_CHECK: { validate_check_constraint(chunk, con); break; } default: if (ts_chunk_is_compressed(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "operation not supported on hypertables that have columnstore " "data"), errhint("Convert the data to rowstore before retrying the " "operation."))); } break; /* Other AT commands might not be allowed on compressed chunks, but * they are checked at hypertable level in that case */ } default: break; } ts_chunk_constraint_create_on_chunk(ht, chunk, info->hypertable_constraint_oid); } static void process_altertable_add_constraint(Hypertable *ht, const AlterTableCmd *cmd, const char *constraint_name) { ChunkConstraintInfo info = { .cmd = cmd, .constraint_name = constraint_name, .hypertable_constraint_oid = get_relation_constraint_oid(ht->main_table_relid, constraint_name, false), }; foreach_chunk(ht, process_add_constraint_chunk, &info); } static void process_altertable_alter_constraint_end(Hypertable *ht, AlterTableCmd *cmd) { foreach_chunk(ht, alter_hypertable_constraint, cmd); } static void process_altertable_validate_constraint_end(Hypertable *ht, AlterTableCmd *cmd) { foreach_chunk(ht, validate_hypertable_constraint, cmd); } /* * Validate that SET NOT NULL is ok for this chunk. */ static void validate_set_not_null(Hypertable *ht, Oid chunk_relid, void *arg) { Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); if (ts_chunk_is_compressed(chunk)) { StringInfoData command; AlterTableCmd *cmd = (AlterTableCmd *) arg; const CompressionSettings *settings = ts_compression_settings_get(chunk->table_id); Oid nspcid = get_rel_namespace(settings->fd.compress_relid); initStringInfo(&command); appendStringInfo(&command, "SELECT EXISTS(SELECT FROM %s.%s WHERE ", quote_identifier(get_namespace_name(nspcid)), quote_identifier(get_rel_name(settings->fd.compress_relid))); if (ts_array_is_member(settings->fd.segmentby, cmd->name)) { /* For segmentby we can check directly whether NULLS are present */ appendStringInfo(&command, "%s IS NULL", quote_identifier(cmd->name)); } else { /* For other columns we need to check whether we have a DEFAULT in which * case NULL as column value would be fine. * */ HeapTuple atttuple = SearchSysCacheAttName(ht->main_table_relid, cmd->name); Form_pg_attribute attform = ((Form_pg_attribute) GETSTRUCT(atttuple)); if (attform->atthasdef) appendStringInfo(&command, "%s IS NOT NULL AND " "_timescaledb_functions.compressed_data_has_nulls(%s)", quote_identifier(cmd->name), quote_identifier(cmd->name)); else appendStringInfo(&command, "%s IS NULL OR " "_timescaledb_functions.compressed_data_has_nulls(%s)", quote_identifier(cmd->name), quote_identifier(cmd->name)); ReleaseSysCache(atttuple); } appendStringInfo(&command, ")"); if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); int res = SPI_execute(command.data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not verify presence of NULL values on \"%s\"", get_rel_name(chunk_relid))))); bool isnull; Datum has_nulls = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); if (isnull || DatumGetBool(has_nulls)) ereport(ERROR, (errcode(ERRCODE_NOT_NULL_VIOLATION), (errmsg("column \"%s\" of relation \"%s\" contains null values", cmd->name, get_rel_name(chunk_relid))))); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); } } /* * This function checks that we are not dropping NOT NULL from partitioning columns and * that no NULL data is present when adding NOT NULL constraint. */ static void process_altertable_alter_not_null(Hypertable *ht, AlterTableCmd *cmd) { if (cmd->subtype == AT_SetNotNull) foreach_chunk(ht, validate_set_not_null, cmd); if (cmd->subtype == AT_DropNotNull) { for (int i = 0; i < ht->space->num_dimensions; i++) { Dimension *dim = &ht->space->dimensions[i]; if (IS_OPEN_DIMENSION(dim) && strncmp(NameStr(dim->fd.column_name), cmd->name, NAMEDATALEN) == 0) ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot drop not-null constraint from a time-partitioned column"))); } } } static void process_altertable_drop_column(Hypertable *ht, AlterTableCmd *cmd) { int i; bool dropped; for (i = 0; i < ht->space->num_dimensions; i++) { Dimension *dim = &ht->space->dimensions[i]; if (namestrcmp(&dim->fd.column_name, cmd->name) == 0) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("cannot drop column named in partition key"), errdetail("Cannot drop column that is a hypertable partitioning (space or " "time) dimension."))); } /* Delete dimension range entries on this column, if any. */ ts_chunk_column_stats_drop(ht, cmd->name, &dropped); } /* * Verify that a constraint is supported on a hypertable. */ static void verify_constraint_hypertable(Hypertable *ht, Node *constr_node) { ConstrType contype; const char *indexname; List *keys; if (IsA(constr_node, Constraint)) { Constraint *constr = (Constraint *) constr_node; contype = constr->contype; keys = (contype == CONSTR_EXCLUSION) ? constr->exclusions : constr->keys; indexname = constr->indexname; if (contype == CONSTR_FOREIGN) { Oid confrelid = ts_hypertable_relid(constr->pktable); if (OidIsValid(confrelid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables cannot be used as foreign key references of " "hypertables"))); } /* NO INHERIT constraints do not really make sense on a hypertable */ if (constr->is_no_inherit) ereport(ERROR, (errcode(ERRCODE_INVALID_TABLE_DEFINITION), errmsg("cannot have NO INHERIT constraints on hypertable \"%s\"", get_rel_name(ht->main_table_relid)))); } else if (IsA(constr_node, IndexStmt)) { IndexStmt *stmt = (IndexStmt *) constr_node; contype = stmt->primary ? CONSTR_PRIMARY : CONSTR_UNIQUE; keys = stmt->indexParams; indexname = stmt->idxname; } else { elog(ERROR, "unexpected constraint type"); return; } switch (contype) { case CONSTR_FOREIGN: break; case CONSTR_UNIQUE: case CONSTR_PRIMARY: /* * If this constraints is created using an existing index we need * not re-verify it's columns */ if (indexname != NULL) return; ts_indexing_verify_columns(ht->space, keys); break; case CONSTR_EXCLUSION: ts_indexing_verify_columns(ht->space, keys); break; default: break; } } static void verify_constraint(RangeVar *relation, Constraint *constr) { Cache *hcache = ts_hypertable_cache_pin(); Hypertable *ht = ts_hypertable_cache_get_entry_rv(hcache, relation); if (ht) verify_constraint_hypertable(ht, (Node *) constr); ts_cache_release(&hcache); } static void verify_constraint_list(RangeVar *relation, List *constraint_list) { ListCell *lc; foreach (lc, constraint_list) { Constraint *constraint = lfirst(lc); verify_constraint(relation, constraint); } } typedef struct HypertableIndexOptions { /* * true if we should run one transaction per chunk, otherwise use one * transaction for all the chunks */ bool multitransaction; int n_ht_atts; /* Concurrency testing options. */ #ifdef DEBUG /* * If barrier_table is a valid Oid we try to acquire a lock on it at the * start of each chunks sub-transaction. */ Oid barrier_table; /* * if max_chunks >= 0 we'll create indices on at most max_chunks, and * leave the table marked as Invalid when the command ends. */ int32 max_chunks; #endif } HypertableIndexOptions; typedef struct CreateIndexInfo { IndexStmt *stmt; ObjectAddress obj; Oid main_table_relid; HypertableIndexOptions extended_options; MemoryContext mctx; } CreateIndexInfo; /* * Create index on a chunk. * * A chunk index is created based on the original IndexStmt that created the * "parent" index on the hypertable. */ static void process_index_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { CreateIndexInfo *info = (CreateIndexInfo *) arg; Relation hypertable_index_rel; Relation chunk_rel; IndexInfo *indexinfo; Chunk *chunk; chunk = ts_chunk_get_by_relid(chunk_relid, true); if (IS_OSM_CHUNK(chunk)) /*cannot create index on foreign OSM chunk */ { ereport(NOTICE, (errmsg("skipping index creation for tiered data"))); return; } validate_index_constraints(chunk, info->stmt); chunk_rel = table_open(chunk_relid, ShareLock); hypertable_index_rel = index_open(info->obj.objectId, AccessShareLock); indexinfo = BuildIndexInfo(hypertable_index_rel); if (chunk_index_columns_changed(info->extended_options.n_ht_atts, RelationGetDescr(chunk_rel))) ts_adjust_indexinfo_attnos(indexinfo, info->main_table_relid, chunk_rel); ts_chunk_index_create_from_adjusted_index_info(ht->fd.id, hypertable_index_rel, chunk->fd.id, chunk_rel, indexinfo); index_close(hypertable_index_rel, NoLock); table_close(chunk_rel, NoLock); } static void process_index_chunk_multitransaction(int32 hypertable_id, Oid chunk_relid, void *arg) { CreateIndexInfo *info = (CreateIndexInfo *) arg; CatalogSecurityContext sec_ctx; Chunk *chunk; Relation hypertable_index_rel; Relation chunk_rel; IndexInfo *indexinfo; Assert(info->extended_options.multitransaction); /* Start a new transaction for each relation. */ StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); #ifdef DEBUG if (info->extended_options.max_chunks == 0) { PopActiveSnapshot(); CommitTransactionCommand(); return; } /* * if max_chunks is < 0 then we're indexing all the chunks, if it's >= 0 * then we're only indexing some of the chunks, and leaving the root index * marked as invalid */ if (info->extended_options.max_chunks > 0) info->extended_options.max_chunks -= 1; if (OidIsValid(info->extended_options.barrier_table)) { /* * For isolation tests, and debugging, it's useful to be able to * pause CREATE INDEX immediately before it starts working on chunks. * We acquire and immediately release a lock on a barrier table to do * this. */ Relation barrier = relation_open(info->extended_options.barrier_table, AccessExclusiveLock); relation_close(barrier, AccessExclusiveLock); } #endif /* * Change user since chunks are typically located in an internal schema * and chunk indexes require metadata changes. In the single-transaction * case, we do this once for the entire table. */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); /* * Hold a lock on the hypertable index, and the chunk to prevent * from being altered. Since we use the same relids across transactions, * there is a potential issue if the id gets reassigned between one * sub-transaction and the next. CLUSTER has a similar issue. * * We grab a ShareLock on the chunk, because that's what CREATE INDEX * does. For the hypertable's index, we are ok using the weaker * AccessShareLock, since we only need to prevent the index itself from * being ALTERed or DROPped during this part of index creation. */ chunk_rel = table_open(chunk_relid, ShareLock); chunk = ts_chunk_get_by_relid(chunk_relid, true); /* * Validation happens when creating the hypertable's index, which goes * through the usual DefineIndex mechanism. */ if (!IS_OSM_CHUNK(chunk)) /*cannot create index on foreign OSM chunk */ { hypertable_index_rel = index_open(info->obj.objectId, AccessShareLock); indexinfo = BuildIndexInfo(hypertable_index_rel); if (chunk_index_columns_changed(info->extended_options.n_ht_atts, RelationGetDescr(chunk_rel))) ts_adjust_indexinfo_attnos(indexinfo, info->main_table_relid, chunk_rel); ts_chunk_index_create_from_adjusted_index_info(hypertable_id, hypertable_index_rel, chunk->fd.id, chunk_rel, indexinfo); index_close(hypertable_index_rel, NoLock); } else { ereport(NOTICE, (errmsg("skipping index creation for tiered data"))); } validate_index_constraints(chunk, info->stmt); table_close(chunk_rel, NoLock); ts_catalog_restore_user(&sec_ctx); PopActiveSnapshot(); CommitTransactionCommand(); } typedef enum HypertableIndexFlags { HypertableIndexFlagMultiTransaction = 0, #ifdef DEBUG HypertableIndexFlagBarrierTable, HypertableIndexFlagMaxChunks, #endif } HypertableIndexFlags; static const WithClauseDefinition index_with_clauses[] = { [HypertableIndexFlagMultiTransaction] = {.arg_names = {"transaction_per_chunk", NULL}, .type_id = BOOLOID,}, #ifdef DEBUG [HypertableIndexFlagBarrierTable] = {.arg_names = {"barrier_table", NULL}, .type_id = REGCLASSOID,}, [HypertableIndexFlagMaxChunks] = {.arg_names = {"max_chunks", NULL}, .type_id = INT4OID, .default_val = (Datum)-1}, #endif }; static bool multitransaction_create_index_mark_valid(CreateIndexInfo info) { #ifdef DEBUG return info.extended_options.max_chunks < 0; #else return true; #endif } /* * Create an index on a hypertable * * We override CREATE INDEX on hypertables in order to ensure that the index is * created on all of the hypertable's chunks, and to ensure that locks on all * of said chunks are acquired at the correct time. */ static DDLResult process_index_start(ProcessUtilityArgs *args) { IndexStmt *stmt = (IndexStmt *) args->parsetree; Cache *hcache; Hypertable *ht; List *postgres_options = NIL; List *hypertable_options = NIL; WithClauseResult *parsed_with_clauses; CreateIndexInfo info = { .stmt = stmt, #ifdef DEBUG .extended_options = {0, .max_chunks = -1,}, #endif }; ObjectAddress root_table_index; Relation main_table_relation; TupleDesc main_table_desc; Relation main_table_index_relation; LockRelId main_table_index_lock_relid; int sec_ctx; Oid uid = InvalidOid, saved_uid = InvalidOid; ContinuousAgg *cagg = NULL; Assert(IsA(stmt, IndexStmt)); /* * PG11 adds some cases where the relation is not there, namely on * declaratively partitioned tables, with partitioned indexes: * https://github.com/postgres/postgres/commit/8b08f7d4820fd7a8ef6152a9dd8c6e3cb01e5f99 * we don't deal with them so we will just return immediately */ if (NULL == stmt->relation) return DDL_CONTINUE; hcache = ts_hypertable_cache_pin(); ht = ts_hypertable_cache_get_entry_rv(hcache, stmt->relation); if (!ht) { /* Check if the relation is a Continuous Aggregate */ cagg = ts_continuous_agg_find_by_rv(stmt->relation); if (cagg) { /* If the relation is a CAgg and it is finalized */ if (ContinuousAggIsFinalized(cagg)) { ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); } else { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on continuous aggregates that are not " "finalized"), errhint("Run \"CALL cagg_migrate('%s.%s');\" to migrate to the new " "format.", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)))); } } if (!ht) { ts_cache_release(&hcache); return DDL_CONTINUE; } if (stmt->unique) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("continuous aggregates do not support UNIQUE indexes"))); /* Make the RangeVar for the underlying materialization hypertable */ stmt->relation = makeRangeVar(NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), -1); } ts_hypertable_permissions_check_by_id(ht->fd.id); ts_with_clause_filter(stmt->options, &hypertable_options, &postgres_options); stmt->options = postgres_options; parsed_with_clauses = ts_with_clauses_parse(hypertable_options, index_with_clauses, TS_ARRAY_LEN(index_with_clauses)); info.extended_options.multitransaction = DatumGetBool(parsed_with_clauses[HypertableIndexFlagMultiTransaction].parsed); #ifdef DEBUG info.extended_options.max_chunks = DatumGetInt32(parsed_with_clauses[HypertableIndexFlagMaxChunks].parsed); info.extended_options.barrier_table = DatumGetObjectId(parsed_with_clauses[HypertableIndexFlagBarrierTable].parsed); #endif /* Make sure this index is allowed */ if (stmt->concurrent) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support concurrent " "index creation"))); if (info.extended_options.multitransaction && (stmt->unique || stmt->primary || stmt->isconstraint)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "cannot use timescaledb.transaction_per_chunk with UNIQUE or PRIMARY KEY"))); ts_indexing_verify_index(ht->space, stmt); if (info.extended_options.multitransaction) PreventInTransactionBlock(true, "CREATE INDEX ... WITH (timescaledb.transaction_per_chunk)"); if (cagg) { /* * If this is an index creation for cagg, then we need to switch user as the current * user might not have permissions on the internal schema where cagg index will be * created. * Need to restore user soon after this step. */ ts_cagg_permissions_check(ht->main_table_relid, GetUserId()); SWITCH_TO_TS_USER(NameStr(cagg->data.direct_view_schema), uid, saved_uid, sec_ctx); } /* CREATE INDEX on the root table of the hypertable */ root_table_index = ts_indexing_root_table_create_index(stmt, args->query_string, info.extended_options.multitransaction); if (cagg) RESTORE_USER(uid, saved_uid, sec_ctx); /* root_table_index will have 0 objectId if the index already exists * and if_not_exists is true. In that case there is nothing else * to do here. */ if (!OidIsValid(root_table_index.objectId) && stmt->if_not_exists) { ts_cache_release(&hcache); return DDL_DONE; } Assert(OidIsValid(root_table_index.objectId)); /* support ONLY ON clause, index on root table already created */ if (!stmt->relation->inh) { ts_cache_release(&hcache); return DDL_DONE; } info.obj.objectId = root_table_index.objectId; /* collect information required for per chunk index creation */ main_table_relation = table_open(ht->main_table_relid, AccessShareLock); main_table_desc = RelationGetDescr(main_table_relation); main_table_index_relation = index_open(info.obj.objectId, AccessShareLock); main_table_index_lock_relid = main_table_index_relation->rd_lockInfo.lockRelId; info.extended_options.n_ht_atts = main_table_desc->natts; info.main_table_relid = ht->main_table_relid; index_close(main_table_index_relation, NoLock); table_close(main_table_relation, NoLock); /* create chunk indexes using the same transaction for all the chunks */ if (!info.extended_options.multitransaction) { CatalogSecurityContext sec_ctx; /* * Change user since chunk's are typically located in an internal * schema and chunk indexes require metadata changes. In the * multi-transaction case, we do this once per chunk. */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); /* Recurse to each chunk and create a corresponding index. */ foreach_chunk(ht, process_index_chunk, &info); ts_catalog_restore_user(&sec_ctx); ts_cache_release(&hcache); return DDL_DONE; } /* create chunk indexes using a separate transaction for each chunk */ /* * Lock the index for the remainder of the command. Since we're using * multiple transactions for index creation, a regular * transaction-level lock won't prevent the index from being * concurrently ALTERed or DELETEd. Instead, we grab a session level * lock on the index, which we'll release when the command is * finished. (This is the same strategy postgres uses in CREATE INDEX * CONCURRENTLY) */ LockRelationIdForSession(&main_table_index_lock_relid, AccessShareLock); /* * mark the hypertable's index as invalid until all the chunk indexes * are created. This allows us to determine if the CREATE INDEX * completed successfully or not */ ts_indexing_mark_as_invalid(info.obj.objectId); CacheInvalidateRelcacheByRelid(info.main_table_relid); CacheInvalidateRelcacheByRelid(info.obj.objectId); ts_cache_release(&hcache); /* we need a long-lived context in which to store the list of chunks since the per-transaction * context will get freed at the end of each transaction. Fortunately we're within just such a * context now; the PortalContext. */ info.mctx = CurrentMemoryContext; PopActiveSnapshot(); CommitTransactionCommand(); foreach_chunk_multitransaction(info.main_table_relid, info.mctx, process_index_chunk_multitransaction, &info); StartTransactionCommand(); PushActiveSnapshot(GetTransactionSnapshot()); MemoryContextSwitchTo(info.mctx); if (multitransaction_create_index_mark_valid(info)) { /* we're done, the index is now valid */ ts_indexing_mark_as_valid(info.obj.objectId); CacheInvalidateRelcacheByRelid(info.main_table_relid); CacheInvalidateRelcacheByRelid(info.obj.objectId); } PopActiveSnapshot(); CommitTransactionCommand(); StartTransactionCommand(); UnlockRelationIdForSession(&main_table_index_lock_relid, AccessShareLock); DEBUG_WAITPOINT("process_index_start_indexing_done"); return DDL_DONE; } static int chunk_index_mappings_cmp(const void *p1, const void *p2) { const ChunkIndexMapping *lhs = *((ChunkIndexMapping *const *) p1); const ChunkIndexMapping *rhs = *((ChunkIndexMapping *const *) p2); if (lhs->chunkoid < rhs->chunkoid) return -1; if (lhs->chunkoid > rhs->chunkoid) return 1; return 0; } /* * Cluster a hypertable. * * The functionality to cluster all chunks of a hypertable is based on the * regular cluster function's mode to cluster multiple tables. Since clustering * involves taking exclusive locks on all tables for extensive periods of time, * each subtable is clustered in its own transaction. This will release all * locks on subtables once they are done. */ static DDLResult process_cluster_start(ProcessUtilityArgs *args) { ClusterStmt *stmt = (ClusterStmt *) args->parsetree; Cache *hcache; Hypertable *ht; DDLResult result = DDL_CONTINUE; Assert(IsA(stmt, ClusterStmt)); /* If this is a re-cluster on all tables, there is nothing we need to do */ if (NULL == stmt->relation) return DDL_CONTINUE; hcache = ts_hypertable_cache_pin(); ht = ts_hypertable_cache_get_entry_rv(hcache, stmt->relation); if (NULL != ht) { bool is_top_level = (args->context == PROCESS_UTILITY_TOPLEVEL); Oid index_relid; Relation index_rel; List *chunk_indexes; ListCell *lc; MemoryContext old, mcxt; LockRelId cluster_index_lockid; ChunkIndexMapping **mappings = NULL; int i; ts_hypertable_permissions_check_by_id(ht->fd.id); /* * If CLUSTER is run inside a user transaction block; we bail out or * otherwise we'd be holding locks way too long. */ PreventInTransactionBlock(is_top_level, "CLUSTER"); if (NULL == stmt->indexname) { index_relid = ts_indexing_find_clustered_index(ht->main_table_relid); if (!OidIsValid(index_relid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("there is no previously clustered index for table \"%s\"", get_rel_name(ht->main_table_relid)))); } else index_relid = get_relname_relid(stmt->indexname, get_rel_namespace(ht->main_table_relid)); if (!OidIsValid(index_relid)) { /* Let regular process utility handle */ ts_cache_release(&hcache); return DDL_CONTINUE; } /* * DROP INDEX locks the table then the index, to prevent deadlocks we * lock them in the same order. The main table lock will be released * when the current transaction commits, and never taken again. We * will use the index relation to grab a session lock on the index, * which we will hold throughout CLUSTER */ LockRelationOid(ht->main_table_relid, AccessShareLock); index_rel = index_open(index_relid, AccessShareLock); cluster_index_lockid = index_rel->rd_lockInfo.lockRelId; index_close(index_rel, NoLock); /* * mark the main table as clustered, even though it has no data, so * future calls to CLUSTER don't need to pass in the index */ ts_chunk_index_mark_clustered(ht->main_table_relid, index_relid); /* we will keep holding this lock throughout CLUSTER */ LockRelationIdForSession(&cluster_index_lockid, AccessShareLock); /* * The list of chunks and their indexes need to be on a memory context * that will survive moving to a new transaction for each chunk */ mcxt = AllocSetContextCreate(PortalContext, "Hypertable cluster", ALLOCSET_DEFAULT_SIZES); /* * Get a list of chunks and indexes that correspond to the * hypertable's index */ old = MemoryContextSwitchTo(mcxt); chunk_indexes = ts_chunk_index_get_mappings(ht, index_relid); if (list_length(chunk_indexes) > 0) { /* Sort the mappings on chunk OID. This makes the verbose output more * predictable in tests, but isn't strictly necessary. We could also do * it only for "verbose" output, but this doesn't seem worth it as the * cost of sorting is quickly amortized over the actual work to cluster * the chunks. */ mappings = (ChunkIndexMapping **) palloc(sizeof(ChunkIndexMapping *) * list_length(chunk_indexes)); i = 0; foreach (lc, chunk_indexes) mappings[i++] = lfirst(lc); qsort((void *) mappings, list_length(chunk_indexes), sizeof(ChunkIndexMapping *), chunk_index_mappings_cmp); } MemoryContextSwitchTo(old); hcache->release_on_commit = false; /* Commit to get out of starting transaction */ PopActiveSnapshot(); CommitTransactionCommand(); for (i = 0; i < list_length(chunk_indexes); i++) { ChunkIndexMapping *cim = mappings[i]; /* Start a new transaction for each relation. */ StartTransactionCommand(); /* functions in indexes may want a snapshot set */ PushActiveSnapshot(GetTransactionSnapshot()); /* * We must mark each chunk index as clustered before calling * cluster_rel() because it expects indexes that need to be * rechecked (due to new transaction) to already have that mark * set */ ts_chunk_index_mark_clustered(cim->chunkoid, cim->indexoid); /* Do the job. */ /* * Since we keep OIDs between transactions, there is a potential * issue if an OID gets reassigned between two subtransactions */ #if PG18_LT cluster_rel(cim->chunkoid, cim->indexoid, get_cluster_options(stmt)); #else Relation rel = table_open(cim->chunkoid, AccessExclusiveLock); cluster_rel(rel, cim->indexoid, get_cluster_options(stmt)); #endif PopActiveSnapshot(); CommitTransactionCommand(); } hcache->release_on_commit = true; /* Start a new transaction for the cleanup work. */ StartTransactionCommand(); /* Clean up working storage */ MemoryContextDelete(mcxt); UnlockRelationIdForSession(&cluster_index_lockid, AccessShareLock); result = DDL_DONE; } ts_cache_release(&hcache); return result; } typedef struct CreateTableInfo { bool hypertable; WithClauseResult *with_clauses; } CreateTableInfo; static CreateTableInfo create_table_info = { 0 }; /* * Scan the table for a suitable default partitioning column. * * The default partitioning column is the first timestamp column * * Caller is expected to have appropriate lock on the table. */ static char * get_default_partition_column(Oid relid) { Relation rel; TupleDesc tupdesc; int i; char *column_name = NULL; rel = relation_open(relid, NoLock); tupdesc = RelationGetDescr(rel); for (i = 0; i < tupdesc->natts; i++) { Form_pg_attribute att = TupleDescAttr(tupdesc, i); if (att->attisdropped) continue; if (att->atttypid == TIMESTAMPOID || att->atttypid == TIMESTAMPTZOID) { column_name = pstrdup(NameStr(att->attname)); break; } } relation_close(rel, NoLock); return column_name; } /* * Process create table statements. * * NOTE that this function should be called after parse analysis (in an end DDL * trigger or by running parse analysis manually). */ static void process_create_table_end(Node *parsetree) { CreateStmt *stmt = (CreateStmt *) parsetree; ListCell *lc; verify_constraint_list(stmt->relation, stmt->constraints); /* * Only after parse analysis does tableElts contain only ColumnDefs. So, * if we capture this in processUtility, we should be prepared to have * constraint nodes and TableLikeClauses intermixed */ foreach (lc, stmt->tableElts) { ColumnDef *coldef; switch (nodeTag(lfirst(lc))) { case T_ColumnDef: coldef = lfirst(lc); verify_constraint_list(stmt->relation, coldef->constraints); break; case T_Constraint: /* * There should be no Constraints in the list after parse * analysis, but this case is included anyway for completeness */ verify_constraint(stmt->relation, lfirst(lc)); break; case T_TableLikeClause: /* Some as above case */ break; default: break; } } if (create_table_info.hypertable) { Oid table_relid = RangeVarGetRelid(stmt->relation, NoLock, true); char *time_column = NULL; if (create_table_info.with_clauses[CreateTableFlagTimeColumn].is_default) { time_column = get_default_partition_column(table_relid); if (time_column) ereport(NOTICE, (errmsg("using column \"%s\" as partitioning column", time_column), errhint("Use \"timescaledb.partition_column\" to specify a different " "column to use as " "partitioning column."))); else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("partition column could not be determined"), errhint( "Use \"timescaledb.partition_column\" to specify the column to use as " "partitioning column."))); } else time_column = TextDatumGetCString( create_table_info.with_clauses[CreateTableFlagTimeColumn].parsed); NameData time_column_name; NameData associated_schema_name; NameData associated_table_prefix; namestrcpy(&time_column_name, time_column); uint32 flags = 0; bool has_associated_schema = false; bool has_associated_table_prefix = false; if (get_attnum(table_relid, time_column) == InvalidAttrNumber) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" does not exist", time_column))); Oid interval_type = InvalidOid; Datum interval = UnassignedDatum; if (!create_table_info.with_clauses[CreateTableFlagChunkTimeInterval].is_default) { AttrNumber time_attno = get_attnum(table_relid, time_column); Oid time_type = get_atttype(table_relid, time_attno); interval = ts_create_table_parse_chunk_time_interval(create_table_info.with_clauses [CreateTableFlagChunkTimeInterval], time_type, &interval_type); } if (!create_table_info.with_clauses[CreateTableFlagCreateDefaultIndexes].is_default) { if (!DatumGetBool( create_table_info.with_clauses[CreateTableFlagCreateDefaultIndexes].parsed)) flags |= HYPERTABLE_CREATE_DISABLE_DEFAULT_INDEXES; } if (!create_table_info.with_clauses[CreateTableFlagAssociatedSchema].is_default) { has_associated_schema = true; namestrcpy(&associated_schema_name, TextDatumGetCString( create_table_info.with_clauses[CreateTableFlagAssociatedSchema].parsed)); } if (!create_table_info.with_clauses[CreateTableFlagAssociatedTablePrefix].is_default) { has_associated_table_prefix = true; namestrcpy(&associated_table_prefix, TextDatumGetCString( create_table_info.with_clauses[CreateTableFlagAssociatedTablePrefix] .parsed)); } DimensionInfo *open_dim_info = ts_dimension_info_create_open(table_relid, &time_column_name, /* column name */ interval, /* interval */ interval_type, /* interval type */ InvalidOid /* partitioning func */ ); ChunkSizingInfo *csi = ts_chunk_sizing_info_get_default_disabled(table_relid); csi->colname = time_column; CatalogSecurityContext sec_ctx; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); int32 ht_id = ts_catalog_table_next_seq_id(ts_catalog_get(), HYPERTABLE); ts_catalog_restore_user(&sec_ctx); if (ts_hypertable_create_from_info(table_relid, ht_id, flags, /* flags */ open_dim_info, /* open_dim_info */ NULL, /* closed_dim_info */ has_associated_schema ? &associated_schema_name : NULL, /* associated_schema_name */ has_associated_table_prefix ? &associated_table_prefix : NULL, /* associated_table_prefix */ csi)) { bool enable_columnstore; if (ts_license_is_apache() && create_table_info.with_clauses[CreateTableFlagColumnstore].is_default) enable_columnstore = false; else enable_columnstore = DatumGetBool(create_table_info.with_clauses[CreateTableFlagColumnstore].parsed); if (enable_columnstore) { Hypertable *ht = ts_hypertable_get_by_id(ht_id); ts_cm_functions->columnstore_setup(ht, create_table_info.with_clauses); } } } } static inline const char * typename_get_unqual_name(TypeName *tn) { return strVal(llast(tn->names)); } static void process_alter_column_type_start(ParseState *pstate, Hypertable *ht, AlterTableCmd *cmd) { int i; /* check if it's a partitioning column */ for (i = 0; i < ht->space->num_dimensions; i++) { Dimension *dim = &ht->space->dimensions[i]; if (IS_CLOSED_DIMENSION(dim) && strncmp(NameStr(dim->fd.column_name), cmd->name, NAMEDATALEN) == 0) ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot change the type of a hash-partitioned column"))); if (dim->partitioning != NULL && strncmp(NameStr(dim->fd.column_name), cmd->name, NAMEDATALEN) == 0) ereport(ERROR, (errcode(ERRCODE_TS_OPERATION_NOT_SUPPORTED), errmsg("cannot change the type of a column with a custom partitioning " "function"))); } /* * Check if column has statistics enabled on it, if yes we need to check that the * new type is a permissible type. */ Form_chunk_column_stats form = ts_chunk_column_stats_lookup(ht->fd.id, INVALID_CHUNK_ID, cmd->name); if (form != NULL) { ColumnDef *def = (ColumnDef *) cmd->def; TypeName *typeName = def->typeName; Oid newtypid = typenameTypeId(pstate, typeName); /* * We only support a subset of types for ranges right now. If it's a * supported type and ranges have been calculated then we should * still be able to use them for chunk exclusion. * * So, we only do a basic check for compatible new data type. Nothing * else needs to be done. */ switch (newtypid) { case INT2OID: case INT4OID: case INT8OID: case TIMESTAMPOID: case TIMESTAMPTZOID: case DATEOID: break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("data type \"%s\" unsupported for statistics calculation", format_type_be(newtypid)), errhint("Integer-like, timestamp-like data types supported currently." " Disable the stats using disable_column_stats function" " before changing the type"))); } } } static void process_alter_column_type_end(Hypertable *ht, AlterTableCmd *cmd) { ColumnDef *coldef = (ColumnDef *) cmd->def; Oid new_type = TypenameGetTypid(typename_get_unqual_name(coldef->typeName)); Dimension *dim = ts_hyperspace_get_mutable_dimension_by_name(ht->space, DIMENSION_TYPE_ANY, cmd->name); if (NULL == dim) return; ts_dimension_set_type(dim, new_type); ts_process_utility_set_expect_chunk_modification(true); ts_chunk_recreate_all_constraints_for_dimension(ht, dim->fd.id); ts_process_utility_set_expect_chunk_modification(false); } static void process_altertable_clusteron_end(Hypertable *ht, AlterTableCmd *cmd) { Oid index_relid = ts_get_relation_relid(NameStr(ht->fd.schema_name), cmd->name, true); /* If this is part of changing the type of a column that is used in a clustered index * the above lookup might fail. But in this case we don't need to mark the index clustered * as postgres takes care of that already */ if (!OidIsValid(index_relid)) return; List *chunk_indexes = ts_chunk_index_get_mappings(ht, index_relid); ListCell *lc; foreach (lc, chunk_indexes) { ChunkIndexMapping *cim = lfirst(lc); ts_chunk_index_mark_clustered(cim->chunkoid, cim->indexoid); } } /* * Generic function to recurse ALTER TABLE commands to chunks. * * Call with foreach_chunk(). */ static void process_altertable_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { AlterTableCmd *cmd = arg; /* Don't propagate ALTER TABLE SET to foreign tables */ if (get_rel_relkind(chunk_relid) == RELKIND_FOREIGN_TABLE && (cmd->subtype == AT_SetOptions || cmd->subtype == AT_ResetOptions || cmd->subtype == AT_SetRelOptions || cmd->subtype == AT_ReplaceRelOptions || cmd->subtype == AT_ResetRelOptions)) return; AlterTableInternal(chunk_relid, list_make1(cmd), false); } static void process_altertable_chunk_replica_identity(Hypertable *ht, Oid chunk_relid, void *arg) { AlterTableCmd *cmd = castNode(AlterTableCmd, copyObject(arg)); ReplicaIdentityStmt *stmt = castNode(ReplicaIdentityStmt, cmd->def); char relkind = get_rel_relkind(chunk_relid); /* If this is not a local chunk (e.g., it is foreign table representing a * data node or OSM chunk), then we don't set replica identity locally */ if (relkind != RELKIND_RELATION) return; if (stmt->identity_type == REPLICA_IDENTITY_INDEX) { Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); Oid hyper_schema_oid = get_rel_namespace(ht->main_table_relid); Oid hyper_index_oid = get_relname_relid(stmt->name, hyper_schema_oid); Assert(OidIsValid(hyper_index_oid)); Relation chunk_rel = table_open(chunk_relid, AccessExclusiveLock); Oid chunk_index_relid = ts_chunk_index_get_by_hypertable_indexrelid(chunk_rel, hyper_index_oid); table_close(chunk_rel, NoLock); if (!OidIsValid(chunk_index_relid)) elog(ERROR, "chunk \"%s.%s\" has no index corresponding to hypertable index \"%s\"", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), stmt->name); stmt->name = get_rel_name(chunk_index_relid); } AlterTableInternal(chunk_relid, list_make1(cmd), false); } static void process_altertable_replica_identity(Hypertable *ht, AlterTableCmd *cmd) { ReplicaIdentityStmt *stmt = castNode(ReplicaIdentityStmt, cmd->def); if (stmt->identity_type == REPLICA_IDENTITY_INDEX) { Oid hyper_schema_oid = get_rel_namespace(ht->main_table_relid); Oid hyper_index_oid; hyper_index_oid = get_relname_relid(stmt->name, hyper_schema_oid); if (!OidIsValid(hyper_index_oid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("index \"%s\" for table \"%s.%s\" does not exist", stmt->name, NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name)))); } foreach_chunk(ht, process_altertable_chunk_replica_identity, cmd); } static void process_altertable_set_tablespace_end(Hypertable *ht, AlterTableCmd *cmd) { NameData tspc_name; Tablespaces *tspcs; namestrcpy(&tspc_name, cmd->name); tspcs = ts_tablespace_scan(ht->fd.id); if (tspcs->num_tablespaces > 1) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("cannot set new tablespace when multiple tablespaces are attached to " "hypertable \"%s\"", get_rel_name(ht->main_table_relid)), errhint("Detach tablespaces before altering the hypertable."))); if (tspcs->num_tablespaces == 1) { Assert(ts_hypertable_has_tablespace(ht, tspcs->tablespaces[0].tablespace_oid)); ts_tablespace_delete(ht->fd.id, NameStr(tspcs->tablespaces[0].fd.tablespace_name), tspcs->tablespaces[0].tablespace_oid); } ts_tablespace_attach_internal(&tspc_name, ht->main_table_relid, true); foreach_chunk(ht, process_altertable_chunk, cmd); if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { Hypertable *compressed_hypertable = ts_hypertable_get_by_id(ht->fd.compressed_hypertable_id); AlterTableInternal(compressed_hypertable->main_table_relid, list_make1(cmd), false); List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); AlterTableInternal(chunk->table_id, list_make1(cmd), false); } process_altertable_set_tablespace_end(compressed_hypertable, cmd); } } static void process_altertable_end_index(Node *parsetree, CollectedCommand *cmd) { AlterTableStmt *stmt = (AlterTableStmt *) parsetree; Oid indexrelid = AlterTableLookupRelation(stmt, NoLock); Oid tablerelid = IndexGetRelation(indexrelid, false); Cache *hcache; Hypertable *ht; if (!OidIsValid(tablerelid)) return; ht = ts_hypertable_cache_get_cache_and_entry(tablerelid, CACHE_FLAG_MISSING_OK, &hcache); if (NULL != ht) { ListCell *lc; foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { case AT_SetTableSpace: ts_chunk_index_set_tablespace(ht, indexrelid, cmd->name); break; default: break; } } } ts_cache_release(&hcache); } static void process_altertable_chunk_propagate_to_compressed(AlterTableCmd *cmd, Oid relid) { Chunk *chunk = ts_chunk_get_by_relid(relid, false); if (chunk == NULL) return; if (ts_chunk_contains_compressed_data(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("changing tablespace of columnstore chunk is not supported"), errhint("Please use the corresponding chunk on the rowstore hypertable " "instead."))); /* set tablespace for compressed chunk */ if (chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID) { Chunk *compressed_chunk = ts_chunk_get_by_id(chunk->fd.compressed_chunk_id, true); AlterTableInternal(compressed_chunk->table_id, list_make1(cmd), false); } } static DDLResult process_altertable_start_table(ProcessUtilityArgs *args) { AlterTableStmt *stmt = (AlterTableStmt *) args->parsetree; Oid reloid = AlterTableLookupRelation(stmt, NoLock); Cache *hcache; Hypertable *ht; ListCell *lc; if (!OidIsValid(reloid)) return DDL_CONTINUE; check_chunk_alter_table_operation_allowed(reloid, stmt); ht = ts_hypertable_cache_get_cache_and_entry(reloid, CACHE_FLAG_MISSING_OK, &hcache); if (ht != NULL) { ts_hypertable_permissions_check_by_id(ht->fd.id); check_continuous_agg_alter_table_allowed(ht, stmt); check_alter_table_allowed_on_ht_with_compression(ht, stmt); if (!stmt->relation->inh) { /* only allow ALTER TABLE ... SET (option) with ONLY */ foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { case AT_SetRelOptions: case AT_ResetRelOptions: case AT_ReplaceRelOptions: case AT_SetOptions: case AT_ResetOptions: continue; default: relation_not_only(stmt->relation); break; } } } } foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { case AT_AddIndex: { IndexStmt *istmt = (IndexStmt *) cmd->def; Assert(IsA(cmd->def, IndexStmt)); if (NULL != ht && istmt->isconstraint) verify_constraint_hypertable(ht, cmd->def); } break; case AT_SetNotNull: case AT_DropNotNull: if (ht) process_altertable_alter_not_null(ht, cmd); break; case AT_AddColumn: #if PG16_LT case AT_AddColumnRecurse: #endif { ColumnDef *col; ListCell *constraint_lc; Assert(IsA(cmd->def, ColumnDef)); col = (ColumnDef *) cmd->def; if (ht && TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) check_altertable_add_column_for_compressed(ht, col); if (ht) foreach (constraint_lc, col->constraints) verify_constraint_hypertable(ht, lfirst(constraint_lc)); break; } case AT_DropColumn: #if PG16_LT case AT_DropColumnRecurse: #endif if (ht) process_altertable_drop_column(ht, cmd); break; case AT_AddConstraint: #if PG16_LT case AT_AddConstraintRecurse: #endif Assert(IsA(cmd->def, Constraint)); if (ht) verify_constraint_hypertable(ht, cmd->def); break; case AT_AlterColumnType: Assert(IsA(cmd->def, ColumnDef)); if (ht) process_alter_column_type_start(args->parse_state, ht, cmd); break; case AT_AttachPartition: { RangeVar *relation; PartitionCmd *partstmt; partstmt = (PartitionCmd *) cmd->def; relation = partstmt->name; Assert(relation); if (OidIsValid(ts_hypertable_relid(relation))) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support native " "postgres partitioning"))); } break; } case AT_SetRelOptions: { if (ht != NULL) { EventTriggerAlterTableStart(args->parsetree); /* If we dealt with the option, we remove it from the * list. We do not set the result variable since there * could be other options that are not dealt with. */ if (process_altertable_set_options(cmd, ht) == DDL_DONE) stmt->cmds = foreach_delete_current(stmt->cmds, lc); } else { check_no_timescale_options(cmd, reloid); } break; } case AT_ResetRelOptions: case AT_ReplaceRelOptions: if (ht) { process_altertable_reset_options(cmd, ht); } else { check_no_timescale_options(cmd, reloid); } break; case AT_SetTableSpace: case AT_SetLogged: case AT_SetUnLogged: if (!ht) process_altertable_chunk_propagate_to_compressed(cmd, reloid); break; default: break; } } ts_cache_release(&hcache); /* If there are any commands remaining in the list, we need to deal with * them. Otherwise, we just skip the rest. */ return (list_length(stmt->cmds) > 0) ? DDL_CONTINUE : DDL_DONE; } static void continuous_agg_with_clause_perm_check(ContinuousAgg *cagg, Oid view_relid) { Oid ownerid = ts_rel_get_owner(view_relid); if (!has_privs_of_role(GetUserId(), ownerid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of continuous aggregate \"%s\"", get_rel_name(view_relid)))); } static void process_altercontinuousagg_set_with(ContinuousAgg *cagg, Oid view_relid, const List *defelems) { WithClauseResult *parse_results; List *pg_options = NIL, *cagg_options = NIL; continuous_agg_with_clause_perm_check(cagg, view_relid); ts_with_clause_filter(defelems, &cagg_options, &pg_options); if (list_length(pg_options) > 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("only timescaledb parameters allowed in WITH clause for continuous " "aggregate"))); if (list_length(cagg_options) > 0) { parse_results = ts_create_materialized_view_with_clause_parse(cagg_options); ts_cm_functions->continuous_agg_update_options(cagg, parse_results); } } /* Run an alter table command on a relation */ static void alter_table_by_relation(RangeVar *relation, AlterTableCmd *cmd) { const Oid relid = RangeVarGetRelid(relation, NoLock, true); AlterTableInternal(relid, list_make1(cmd), false); } /* Run an alter table command on a relation given by name */ static void alter_table_by_name(Name schema_name, Name table_name, AlterTableCmd *cmd) { alter_table_by_relation(makeRangeVar(NameStr(*schema_name), NameStr(*table_name), -1), cmd); } /* Alter a hypertable and do some extra processing */ static void alter_hypertable_by_id(int32 hypertable_id, AlterTableStmt *stmt, AlterTableCmd *cmd, void (*extra)(Hypertable *, AlterTableCmd *)) { Cache *hcache = ts_hypertable_cache_pin(); Hypertable *ht = ts_hypertable_cache_get_entry_by_id(hcache, hypertable_id); Assert(ht); /* Broken continuous aggregate */ ts_hypertable_permissions_check_by_id(ht->fd.id); check_alter_table_allowed_on_ht_with_compression(ht, stmt); relation_not_only(stmt->relation); AlterTableInternal(ht->main_table_relid, list_make1(cmd), false); (*extra)(ht, cmd); ts_cache_release(&hcache); } static DDLResult process_altertable_start_matview(ProcessUtilityArgs *args) { AlterTableStmt *stmt = (AlterTableStmt *) args->parsetree; const Oid view_relid = RangeVarGetRelid(stmt->relation, NoLock, true); ContinuousAgg *cagg; ListCell *lc; if (!OidIsValid(view_relid)) return DDL_CONTINUE; cagg = ts_continuous_agg_find_by_relid(view_relid); if (cagg == NULL) return DDL_CONTINUE; continuous_agg_with_clause_perm_check(cagg, view_relid); foreach (lc, stmt->cmds) { AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc); switch (cmd->subtype) { case AT_SetRelOptions: if (!IsA(cmd->def, List)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("expected set options to contain a list"))); process_altercontinuousagg_set_with(cagg, view_relid, (List *) cmd->def); break; case AT_ChangeOwner: alter_table_by_relation(stmt->relation, cmd); alter_table_by_name(&cagg->data.partial_view_schema, &cagg->data.partial_view_name, cmd); alter_table_by_name(&cagg->data.direct_view_schema, &cagg->data.direct_view_name, cmd); alter_hypertable_by_id(cagg->data.mat_hypertable_id, stmt, cmd, process_altertable_change_owner); break; case AT_SetTableSpace: alter_hypertable_by_id(cagg->data.mat_hypertable_id, stmt, cmd, process_altertable_set_tablespace_end); break; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter only SET options of a continuous " "aggregate"))); } } /* All commands processed by us, nothing for postgres to do.*/ return DDL_DONE; } static DDLResult process_altertable_start_view(ProcessUtilityArgs *args) { AlterTableStmt *stmt = (AlterTableStmt *) args->parsetree; Oid relid = AlterTableLookupRelation(stmt, NoLock); ContinuousAgg *cagg; ContinuousAggViewType vtyp; const char *view_name; const char *view_schema; /* Check if this is a materialized view and give error if it is. */ cagg = ts_continuous_agg_find_by_relid(relid); if (cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter continuous aggregate using ALTER VIEW"), errhint("Use ALTER MATERIALIZED VIEW to alter a continuous aggregate."))); /* Check if this is an internal view of a continuous aggregate and give * error if attempts are made to alter them. */ view_name = get_rel_name(relid); view_schema = get_namespace_name(get_rel_namespace(relid)); cagg = ts_continuous_agg_find_by_view_name(view_schema, view_name, ContinuousAggAnyView); if (cagg == NULL) return DDL_CONTINUE; vtyp = ts_continuous_agg_view_type(&cagg->data, view_schema, view_name); if (vtyp == ContinuousAggPartialView || vtyp == ContinuousAggDirectView) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter the internal view of a continuous aggregate"))); return DDL_DONE; } static DDLResult process_altertable_start(ProcessUtilityArgs *args) { AlterTableStmt *stmt = (AlterTableStmt *) args->parsetree; switch (stmt->objtype) { case OBJECT_TABLE: return process_altertable_start_table(args); case OBJECT_MATVIEW: return process_altertable_start_matview(args); case OBJECT_VIEW: return process_altertable_start_view(args); default: return DDL_CONTINUE; } } static void process_altertable_end_subcmd(Hypertable *ht, Node *parsetree, ObjectAddress *obj) { AlterTableCmd *cmd = (AlterTableCmd *) parsetree; Assert(IsA(parsetree, AlterTableCmd)); switch (cmd->subtype) { case AT_ChangeOwner: process_altertable_change_owner(ht, cmd); break; case AT_AddIndexConstraint: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support adding a constraint " "using an existing index"))); break; case AT_AddIndex: { IndexStmt *stmt = (IndexStmt *) cmd->def; const char *idxname = stmt->idxname; Assert(IsA(cmd->def, IndexStmt)); Assert(stmt->isconstraint); if (idxname == NULL) idxname = get_rel_name(obj->objectId); process_altertable_add_constraint(ht, cmd, idxname); } break; case AT_AddConstraint: #if PG16_LT case AT_AddConstraintRecurse: #endif { Constraint *stmt = (Constraint *) cmd->def; const char *conname = stmt->conname; Assert(IsA(cmd->def, Constraint)); if (conname == NULL) conname = get_rel_name(obj->objectId); process_altertable_add_constraint(ht, cmd, conname); } break; case AT_AlterColumnType: Assert(IsA(cmd->def, ColumnDef)); process_alter_column_type_end(ht, cmd); break; case AT_EnableTrig: case AT_EnableAlwaysTrig: case AT_EnableReplicaTrig: case AT_DisableTrig: case AT_EnableTrigAll: case AT_DisableTrigAll: case AT_EnableTrigUser: case AT_DisableTrigUser: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support " "enabling or disabling triggers."))); /* Break here to silence compiler */ break; case AT_ClusterOn: process_altertable_clusteron_end(ht, cmd); break; case AT_ReplicaIdentity: process_altertable_replica_identity(ht, cmd); break; case AT_EnableRule: case AT_EnableAlwaysRule: case AT_EnableReplicaRule: case AT_DisableRule: /* should never actually get here but just in case */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support rules"))); /* Break here to silence compiler */ break; case AT_AlterConstraint: process_altertable_alter_constraint_end(ht, cmd); break; case AT_ValidateConstraint: #if PG16_LT case AT_ValidateConstraintRecurse: #endif process_altertable_validate_constraint_end(ht, cmd); break; case AT_SetLogged: case AT_SetUnLogged: foreach_chunk(ht, process_altertable_chunk, cmd); foreach_compressed_chunk(ht, process_altertable_chunk, cmd); break; case AT_DropCluster: case AT_SetNotNull: case AT_DropNotNull: case AT_SetRelOptions: case AT_ResetRelOptions: case AT_ReplaceRelOptions: case AT_DropOids: case AT_SetOptions: case AT_ResetOptions: case AT_ReAddStatistics: case AT_SetCompression: foreach_chunk(ht, process_altertable_chunk, cmd); break; case AT_SetTableSpace: process_altertable_set_tablespace_end(ht, cmd); break; case AT_AddInherit: case AT_DropInherit: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support inheritance"))); case AT_SetStatistics: case AT_SetStorage: case AT_ColumnDefault: case AT_CookedColumnDefault: case AT_AddOf: case AT_DropOf: case AT_AddIdentity: case AT_SetIdentity: case AT_DropIdentity: /* all of the above are handled by default recursion */ break; case AT_EnableRowSecurity: case AT_DisableRowSecurity: case AT_ForceRowSecurity: case AT_NoForceRowSecurity: /* RLS commands should not recurse to chunks */ break; case AT_ReAddConstraint: case AT_ReAddIndex: /* * all of the above are internal commands that are hit in tests * and correctly handled */ break; case AT_AddColumn: #if PG16_LT case AT_AddColumnRecurse: #endif /* this is handled for compressed hypertables by tsl code */ break; case AT_DropColumn: #if PG16_LT case AT_DropColumnRecurse: #endif case AT_DropExpression: /* * adding and dropping columns handled in * process_altertable_start_table */ break; case AT_DropConstraint: #if PG16_LT case AT_DropConstraintRecurse: #endif /* drop constraints handled by process_ddl_sql_drop */ break; case AT_ReAddComment: /* internal command never hit in our test * code, so don't know how to handle */ case AT_AddColumnToView: /* only used with views */ case AT_AlterColumnGenericOptions: /* only used with foreign tables */ case AT_GenericOptions: /* only used with foreign tables */ case AT_ReAddDomainConstraint: /* We should handle this in future, * new subset of constraints in PG11 * currently not hit in test code */ case AT_AttachPartition: /* handled in * process_altertable_start_table but also * here as failsafe */ case AT_DetachPartition: case AT_DetachPartitionFinalize: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on hypertables %d", cmd->subtype))); break; default: break; } if (ts_cm_functions->process_altertable_cmd) ts_cm_functions->process_altertable_cmd(ht, cmd); } static void process_altertable_end_subcmds(Hypertable *ht, List *cmds) { ListCell *lc; foreach (lc, cmds) { CollectedATSubcmd *cmd = lfirst(lc); process_altertable_end_subcmd(ht, cmd->parsetree, &cmd->address); } } static void process_altertable_end_table(Node *parsetree, CollectedCommand *cmd) { AlterTableStmt *stmt = (AlterTableStmt *) parsetree; Oid relid; Cache *hcache; Hypertable *ht; Assert(IsA(stmt, AlterTableStmt)); relid = RangeVarGetRelid(stmt->relation, NoLock, true); if (!OidIsValid(relid)) return; ht = ts_hypertable_cache_get_cache_and_entry(relid, CACHE_FLAG_MISSING_OK, &hcache); if (ht) { switch (cmd->type) { case SCT_Simple: process_altertable_end_subcmd(ht, linitial(stmt->cmds), &cmd->d.simple.secondaryObject); break; case SCT_AlterTable: process_altertable_end_subcmds(ht, cmd->d.alterTable.subcmds); break; default: break; } } /* * Check any ALTER TABLE command is adding a FOREIGN KEY constraint * referencing a hypertable. */ if (cmd->type == SCT_AlterTable) { AlterTableStmt *stmt = castNode(AlterTableStmt, parsetree); ListCell *lc; foreach (lc, stmt->cmds) { AlterTableCmd *subcmd = (AlterTableCmd *) lfirst(lc); if (subcmd->subtype != AT_AddConstraint || castNode(Constraint, subcmd->def)->contype != CONSTR_FOREIGN) continue; Constraint *c = castNode(Constraint, subcmd->def); Oid confrelid = RangeVarGetRelid(c->pktable, AccessShareLock, true); Hypertable *pk = ts_hypertable_cache_get_entry(hcache, confrelid, CACHE_FLAG_MISSING_OK); if (pk) { if (ht) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables cannot be used as foreign key references of " "hypertables"))); ts_fk_propagate(relid, pk); } } } ts_cache_release(&hcache); } static void process_altertable_end(Node *parsetree, CollectedCommand *cmd) { AlterTableStmt *stmt = (AlterTableStmt *) parsetree; switch (stmt->objtype) { case OBJECT_TABLE: process_altertable_end_table(parsetree, cmd); break; case OBJECT_INDEX: process_altertable_end_index(parsetree, cmd); break; default: break; } } static DDLResult process_create_trigger_start(ProcessUtilityArgs *args) { CreateTrigStmt *stmt = (CreateTrigStmt *) args->parsetree; Cache *hcache; Hypertable *ht; ObjectAddress PG_USED_FOR_ASSERTS_ONLY address; Oid relid = RangeVarGetRelid(stmt->relation, NoLock, true); int16 tgtype; TRIGGER_CLEAR_TYPE(tgtype); if (stmt->row) TRIGGER_SETT_ROW(tgtype); tgtype |= stmt->timing; tgtype |= stmt->events; hcache = ts_hypertable_cache_pin(); ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (ht == NULL) { ts_cache_release(&hcache); /* check if it's a cagg. We don't support triggers on them yet */ if (ts_continuous_agg_find_by_relid(relid) != NULL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("triggers are not supported on continuous aggregate"))); if (stmt->transitionRels) if (ts_chunk_get_by_relid(relid, false) != NULL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("triggers with transition tables are not supported on " "hypertable chunks"))); return DDL_CONTINUE; } /* * We do not support ROW triggers with transition tables on hypertables * since these are not supported on inheritance children, and we use * inheritance for our chunks (it is actually not supported for * declarative partition tables either). */ if (stmt->transitionRels && TRIGGER_FOR_ROW(tgtype)) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("ROW triggers with transition tables are not supported on hypertables"))); } /* * We currently don't support delete triggers with transition tables on * compressed tables because deleting a complete segment will not build * a transition table for the delete. */ if (stmt->transitionRels && TRIGGER_FOR_DELETE(tgtype) && TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("DELETE triggers with transition tables not supported"))); } /* * If it is not a ROW trigger, we do not need to create the ROW triggers * on the chunks, so we can return early. */ if (!stmt->row) { ts_cache_release(&hcache); return DDL_CONTINUE; } address = ts_hypertable_create_trigger(ht, stmt, args->query_string); Assert(OidIsValid(address.objectId)); ts_cache_release(&hcache); return DDL_DONE; } static DDLResult process_create_rule_start(ProcessUtilityArgs *args) { RuleStmt *stmt = (RuleStmt *) args->parsetree; if (!OidIsValid(ts_hypertable_relid(stmt->relation))) return DDL_CONTINUE; ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertables do not support rules"))); return DDL_CONTINUE; } /* * Update the owner of a background job given by a heap tuple. * * Note that there is no check for correct privileges here and this is the * responsibility of the caller. */ static void ts_bgw_job_update_owner(Relation rel, HeapTuple tuple, TupleDesc tupledesc, Oid newrole_oid) { bool isnull[Natts_bgw_job]; Datum values[Natts_bgw_job]; bool replace[Natts_bgw_job] = { false }; HeapTuple new_tuple; heap_deform_tuple(tuple, tupledesc, values, isnull); if (DatumGetObjectId(values[AttrNumberGetAttrOffset(Anum_bgw_job_owner)]) != newrole_oid) { values[AttrNumberGetAttrOffset(Anum_bgw_job_owner)] = Int32GetDatum(newrole_oid); replace[AttrNumberGetAttrOffset(Anum_bgw_job_owner)] = true; new_tuple = heap_modify_tuple(tuple, tupledesc, values, isnull, replace); ts_catalog_update(rel, new_tuple); heap_freetuple(new_tuple); } } static DDLResult process_reassign_owned_start(ProcessUtilityArgs *args) { ReassignOwnedStmt *stmt = (ReassignOwnedStmt *) args->parsetree; List *role_ids = roleSpecsToIds(stmt->roles); ScanIterator iterator = ts_scan_iterator_create(BGW_JOB, RowExclusiveLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { bool should_free, isnull; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Datum value = slot_getattr(ti->slot, Anum_bgw_job_owner, &isnull); if (!isnull && list_member_oid(role_ids, DatumGetObjectId(value))) { Oid newrole_oid = get_rolespec_oid(stmt->newrole, false); HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); /* We do not need to check privileges here since ReassignOwnedObjects() will check * the privileges and error out if they are not correct. */ ts_bgw_job_update_owner(ti->scanrel, tuple, ts_scanner_get_tupledesc(ti), newrole_oid); if (should_free) heap_freetuple(tuple); } } return DDL_CONTINUE; } static void check_no_timescale_options(AlterTableCmd *cmd, Oid reloid) { List *pg_options = NIL, *compress_options = NIL; Ensure(IsA(cmd->def, List), "wrong node type used as ALTER TABLE command definition"); List *inpdef = (List *) cmd->def; ts_with_clause_filter(inpdef, &compress_options, &pg_options); if (compress_options != NIL) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("timescaledb table options can only be specified for hypertables"), errdetail("%s is not a hypertable", get_rel_name(reloid)))); } } /* ALTER TABLE <name> SET ( timescaledb.compress, ...) */ static DDLResult process_altertable_set_options(AlterTableCmd *cmd, Hypertable *ht) { List *pg_options = NIL, *tsdb_options = NIL; WithClauseResult *parse_results = NULL; /* split postgres and timescaledb options */ ts_with_clause_filter(castNode(List, cmd->def), &tsdb_options, &pg_options); if (!tsdb_options) return DDL_CONTINUE; parse_results = ts_alter_table_with_clause_parse(tsdb_options); if (ht && !parse_results[AlterTableFlagChunkTimeInterval].is_default) { Dimension *dim = ts_hyperspace_get_mutable_dimension(ht->space, DIMENSION_TYPE_OPEN, 0); Ensure(dim, "hypertable without open dimension"); Oid time_type = get_atttype(dim->main_table_relid, dim->column_attno); Oid interval_type = InvalidOid; Datum interval = ts_create_table_parse_chunk_time_interval(parse_results [AlterTableFlagChunkTimeInterval], time_type, &interval_type); int64 chunk_interval = ts_interval_value_to_internal(interval, interval_type); ts_dimension_set_chunk_interval(dim, chunk_interval); } if (!parse_results[AlterTableFlagColumnstore].is_default || !parse_results[AlterTableFlagOrderBy].is_default || !parse_results[AlterTableFlagSegmentBy].is_default || !parse_results[AlterTableFlagCompressChunkTimeInterval].is_default || !parse_results[AlterTableFlagIndex].is_default) ts_cm_functions->process_compress_table(ht, parse_results); cmd->def = (Node *) pg_options; return cmd->def ? DDL_CONTINUE : DDL_DONE; } static DDLResult process_altertable_reset_options(AlterTableCmd *cmd, Hypertable *ht) { List *pg_options = NIL, *tsdb_options = NIL; WithClauseResult *parse_results = NULL; /* split postgres and timescaledb options */ ts_with_clause_filter(castNode(List, cmd->def), &tsdb_options, &pg_options); if (!tsdb_options) return DDL_CONTINUE; parse_results = ts_alter_table_reset_with_clause_parse(tsdb_options); if (parse_results[AlterTableFlagOrderBy].is_default && parse_results[AlterTableFlagSegmentBy].is_default && parse_results[AlterTableFlagIndex].is_default) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("only columnstore options segmentby and orderby can be reset"))); } CompressionSettings *settings = ts_compression_settings_get(ht->main_table_relid); if (!settings) { return DDL_CONTINUE; } if (!parse_results[AlterTableFlagSegmentBy].is_default) { settings->fd.segmentby = NULL; } if (!parse_results[AlterTableFlagOrderBy].is_default) { settings->fd.index = ts_remove_orderby_sparse_index(settings); settings->fd.orderby = NULL; settings->fd.orderby_desc = NULL; settings->fd.orderby_nullsfirst = NULL; } if (!parse_results[AlterTableFlagIndex].is_default) { settings->fd.index = NULL; ts_add_orderby_sparse_index(settings); } ts_compression_settings_update(settings); return DDL_CONTINUE; } static DDLResult process_viewstmt(ProcessUtilityArgs *args) { ViewStmt *stmt = castNode(ViewStmt, args->parsetree); List *pg_options = NIL; List *cagg_options = NIL; /* Check if user is passing continuous aggregate parameters and print a * useful error message if that is the case. */ ts_with_clause_filter(stmt->options, &cagg_options, &pg_options); if (cagg_options) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot create continuous aggregate with CREATE VIEW"), errhint("Use CREATE MATERIALIZED VIEW to create a continuous aggregate."))); return DDL_CONTINUE; } static DDLResult process_create_table_as(ProcessUtilityArgs *args) { CreateTableAsStmt *stmt = castNode(CreateTableAsStmt, args->parsetree); WithClauseResult *parse_results = NULL; bool is_cagg = false; List *pg_options = NIL, *cagg_options = NIL; if (stmt->objtype == OBJECT_MATVIEW) { /* Check for creation of continuous aggregate */ ts_with_clause_filter(stmt->into->options, &cagg_options, &pg_options); if (cagg_options) { parse_results = ts_create_materialized_view_with_clause_parse(cagg_options); is_cagg = DatumGetBool(parse_results[CreateMaterializedViewFlagContinuous].parsed); } if (!is_cagg) return DDL_CONTINUE; if (pg_options != NIL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported combination of storage parameters"), errdetail("A continuous aggregate does not support standard storage " "parameters."), errhint("Use only parameters with the \"timescaledb.\" prefix when " "creating a continuous aggregate."))); if (!stmt->into->skipData) PreventInTransactionBlock(args->context == PROCESS_UTILITY_TOPLEVEL, "CREATE MATERIALIZED VIEW ... WITH DATA"); return ts_cm_functions->process_cagg_viewstmt(args->parsetree, args->query_string, args->pstmt, parse_results); } return DDL_CONTINUE; } static DDLResult process_create_stmt(ProcessUtilityArgs *args) { CreateStmt *stmt = castNode(CreateStmt, args->parsetree); List *pg_options = NIL, *hypertable_options = NIL; ts_with_clause_filter(stmt->options, &hypertable_options, &pg_options); stmt->options = pg_options; create_table_info.hypertable = false; create_table_info.with_clauses = NULL; /* * We can only convert the table into a hypertable after postgres has created * the initial table so we store the information passed in the WITH clause * and do some initial sanity check and do the actual work of creating the hypertable * in process_create_table_end. */ if (hypertable_options) { create_table_info.with_clauses = ts_create_table_with_clause_parse(hypertable_options); create_table_info.hypertable = DatumGetBool(create_table_info.with_clauses[CreateTableFlagHypertable].parsed); if (!create_table_info.with_clauses[CreateTableFlagHypertable].parsed) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("timescaledb options requires hypertable option"), errhint("Use \"timescaledb.hypertable\" to enable creating a hypertable."))); } return DDL_CONTINUE; } static DDLResult process_refresh_mat_view_start(ProcessUtilityArgs *args) { RefreshMatViewStmt *stmt = castNode(RefreshMatViewStmt, args->parsetree); Oid view_relid = RangeVarGetRelid(stmt->relation, NoLock, true); const ContinuousAgg *cagg; if (!OidIsValid(view_relid)) return DDL_CONTINUE; cagg = ts_continuous_agg_find_by_relid(view_relid); if (cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on continuous aggregate"), errdetail("A continuous aggregate does not support REFRESH MATERIALIZED VIEW."), errhint("Use \"refresh_continuous_aggregate\" or set up a policy to refresh the " "continuous aggregate."))); return DDL_CONTINUE; } static DDLResult preprocess_execute(ProcessUtilityArgs *args) { #ifdef USE_TELEMETRY ListCell *lc; ExecuteStmt *stmt = (ExecuteStmt *) args->parsetree; PreparedStatement *entry = FetchPreparedStatement(stmt->name, false); if (!entry) return DDL_CONTINUE; foreach (lc, entry->plansource->query_list) { Query *query = lfirst_node(Query, lc); ts_telemetry_function_info_gather(query); } #endif return DDL_CONTINUE; } /* * Handle DDL commands before they have been processed by PostgreSQL. */ static DDLResult process_ddl_command_start(ProcessUtilityArgs *args) { bool check_read_only = true; ts_process_utility_handler_t handler; switch (nodeTag(args->parsetree)) { case T_AlterObjectSchemaStmt: handler = process_alterobjectschema; break; case T_TruncateStmt: handler = process_truncate; break; case T_AlterTableStmt: handler = process_altertable_start; break; case T_RenameStmt: handler = process_rename; break; case T_IndexStmt: handler = process_index_start; break; case T_CreateTrigStmt: handler = process_create_trigger_start; break; case T_RuleStmt: handler = process_create_rule_start; break; case T_ReassignOwnedStmt: handler = process_reassign_owned_start; break; case T_DropStmt: /* * Drop associated metadata/chunks but also continue on to drop * the main table. Because chunks are deleted before the main * table is dropped, the drop respects CASCADE in the expected * way. */ handler = process_drop_start; break; case T_DropRoleStmt: handler = process_drop_role; break; case T_DropTableSpaceStmt: handler = process_drop_tablespace; break; case T_GrantStmt: handler = process_grant_and_revoke; break; case T_GrantRoleStmt: handler = process_grant_and_revoke_role; break; case T_CopyStmt: check_read_only = false; handler = process_copy; break; case T_VacuumStmt: handler = process_vacuum; break; case T_ReindexStmt: handler = process_reindex; break; case T_ClusterStmt: handler = process_cluster_start; break; case T_ViewStmt: handler = process_viewstmt; break; case T_RefreshMatViewStmt: handler = process_refresh_mat_view_start; break; case T_CreateTableAsStmt: handler = process_create_table_as; break; case T_CreateStmt: handler = process_create_stmt; break; case T_ExecuteStmt: check_read_only = false; handler = preprocess_execute; break; default: handler = NULL; break; } if (handler == NULL) return DDL_CONTINUE; if (check_read_only) PreventCommandIfReadOnly(CreateCommandName(args->parsetree)); return handler(args); } /* * Handle DDL commands after they've been processed by PostgreSQL. */ static void process_ddl_command_end(CollectedCommand *cmd) { switch (nodeTag(cmd->parsetree)) { case T_CreateStmt: process_create_table_end(cmd->parsetree); break; case T_AlterTableStmt: process_altertable_end(cmd->parsetree, cmd); break; default: break; } } static void process_drop_constraint_on_chunk(Hypertable *ht, Oid chunk_relid, void *arg) { const char *hypertable_constraint_name = arg; Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); /* drop both metadata and table; sql_drop won't be called recursively */ ts_chunk_constraint_delete_by_hypertable_constraint_name(chunk->fd.id, hypertable_constraint_name); } static void process_drop_table_constraint(EventTriggerDropObject *obj) { EventTriggerDropTableConstraint *constraint = (EventTriggerDropTableConstraint *) obj; Hypertable *ht; Assert(obj->type == EVENT_TRIGGER_DROP_TABLE_CONSTRAINT); /* do not use relids because underlying table could be gone */ ht = ts_hypertable_get_by_name(constraint->schema, constraint->table); if (ht != NULL) { CatalogSecurityContext sec_ctx; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); /* Recurse to each chunk and drop the corresponding constraint */ foreach_chunk(ht, process_drop_constraint_on_chunk, (void *) constraint->constraint_name); ts_catalog_restore_user(&sec_ctx); } else { /* Cannot get the full chunk here because it's table might be dropped */ int32 chunk_id; bool found = ts_chunk_get_id(constraint->schema, constraint->table, &chunk_id, true); if (found) ts_chunk_constraint_delete_by_constraint_name(chunk_id, constraint->constraint_name); } } static void process_drop_table(EventTriggerDropObject *obj) { EventTriggerDropRelation *table = (EventTriggerDropRelation *) obj; Assert(obj->type == EVENT_TRIGGER_DROP_TABLE || obj->type == EVENT_TRIGGER_DROP_FOREIGN_TABLE); ts_chunk_delete_by_relid_and_relname(table->relid, table->schema, table->name, DROP_RESTRICT, false); ts_hypertable_delete_by_name(table->schema, table->name); /* * Normally, compression settings are cleaned up when deleting the * hypertable or chunk. However, in some cases, e.g., when a hypertable * delete cascades to chunks, the chunk relids cannot be resolved from the * schema and name because the chunk relations are already dropped by * PostgreSQL when the "drop eventtrigger" is called. Therefore, also try * to delete compression settings here since the eventtrigger gives us the * relid of dropped objects. */ ts_compression_settings_delete_any(table->relid); } static void process_sql_drop_schema(EventTriggerDropObject *obj) { EventTriggerDropSchema *schema = (EventTriggerDropSchema *) obj; int count; Assert(obj->type == EVENT_TRIGGER_DROP_SCHEMA); if (strcmp(schema->schema, INTERNAL_SCHEMA_NAME) == 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot drop the internal schema for extension \"%s\"", EXTENSION_NAME), errhint("Use DROP EXTENSION to remove the extension and the schema."))); /* * Check for any remaining hypertables that use the schema as its * associated schema. For matches, we reset their associated schema to the * INTERNAL schema */ count = ts_hypertable_reset_associated_schema_name(schema->schema); if (count > 0) ereport(NOTICE, (errmsg("the chunk storage schema changed to \"%s\" for %d hypertable%c", INTERNAL_SCHEMA_NAME, count, (count > 1) ? 's' : '\0'))); } static void process_drop_trigger(EventTriggerDropObject *obj) { EventTriggerDropTrigger *trigger_event = (EventTriggerDropTrigger *) obj; Hypertable *ht; Assert(obj->type == EVENT_TRIGGER_DROP_TRIGGER); /* do not use relids because underlying table could be gone */ ht = ts_hypertable_get_by_name(trigger_event->schema, trigger_event->table); if (ht != NULL) { /* Recurse to each chunk and drop the corresponding trigger */ ts_hypertable_drop_trigger(ht->main_table_relid, trigger_event->trigger_name); } } static void process_drop_view(EventTriggerDropView *dropped_view) { ts_continuous_agg_drop(dropped_view->schema, dropped_view->view_name); } static void process_ddl_sql_drop(EventTriggerDropObject *obj) { switch (obj->type) { case EVENT_TRIGGER_DROP_TABLE_CONSTRAINT: process_drop_table_constraint(obj); break; case EVENT_TRIGGER_DROP_TABLE: process_drop_table(obj); break; case EVENT_TRIGGER_DROP_SCHEMA: process_sql_drop_schema(obj); break; case EVENT_TRIGGER_DROP_TRIGGER: process_drop_trigger(obj); break; case EVENT_TRIGGER_DROP_VIEW: process_drop_view((EventTriggerDropView *) obj); break; case EVENT_TRIGGER_DROP_FOREIGN_TABLE: case EVENT_TRIGGER_DROP_FOREIGN_SERVER: case EVENT_TRIGGER_DROP_INDEX: break; } } /* * ProcessUtility hook for DDL commands that have not yet been processed by * PostgreSQL. */ static void timescaledb_ddl_command_start(PlannedStmt *pstmt, const char *query_string, bool readonly_tree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *completion_tag) { last_process_utility_context = context; ProcessUtilityArgs args = { .query_string = query_string, .context = context, .params = params, .readonly_tree = readonly_tree, .dest = dest, .completion_tag = completion_tag, .pstmt = pstmt, .parsetree = pstmt->utilityStmt, .queryEnv = queryEnv, .parse_state = make_parsestate(NULL) }; bool altering_timescaledb = false; DDLResult result; args.parse_state->p_sourcetext = query_string; if (IsA(args.parsetree, AlterExtensionStmt)) { AlterExtensionStmt *stmt = (AlterExtensionStmt *) args.parsetree; altering_timescaledb = (strcmp(stmt->extname, EXTENSION_NAME) == 0); } /* * We don't want to load the extension if we just got the command to alter * it. */ if (altering_timescaledb || !ts_extension_is_loaded_and_not_upgrading()) { prev_ProcessUtility(&args); return; } /* * Since we might alter the parsetree and strip timescaledb options * before passing it to Postgres, we need to make a copy of the original * statement in case it is cached. */ args.pstmt = copyObject(pstmt); args.parsetree = args.pstmt->utilityStmt; result = process_ddl_command_start(&args); if (result == DDL_CONTINUE) prev_ProcessUtility(&args); } static void process_ddl_event_command_end(EventTriggerData *trigdata) { ListCell *lc; /* Inhibit collecting new commands while in the trigger */ EventTriggerInhibitCommandCollection(); switch (nodeTag(trigdata->parsetree)) { case T_AlterTableStmt: case T_CreateTrigStmt: case T_CreateStmt: case T_IndexStmt: foreach (lc, ts_event_trigger_ddl_commands()) process_ddl_command_end(lfirst(lc)); break; default: break; } EventTriggerUndoInhibitCommandCollection(); } static void process_ddl_event_sql_drop(EventTriggerData *trigdata) { ListCell *lc; List *dropped_objects = ts_event_trigger_dropped_objects(); foreach (lc, dropped_objects) process_ddl_sql_drop(lfirst(lc)); } TS_FUNCTION_INFO_V1(ts_timescaledb_process_ddl_event); /* * Event trigger hook for DDL commands that have already been handled by * PostgreSQL (i.e., "ddl_command_end" and "sql_drop" events). */ Datum ts_timescaledb_process_ddl_event(PG_FUNCTION_ARGS) { EventTriggerData *trigdata = (EventTriggerData *) fcinfo->context; if (!CALLED_AS_EVENT_TRIGGER(fcinfo)) elog(ERROR, "not fired by event trigger manager"); if (!ts_extension_is_loaded_and_not_upgrading()) PG_RETURN_NULL(); if (strcmp("ddl_command_end", trigdata->event) == 0) process_ddl_event_command_end(trigdata); else if (strcmp("sql_drop", trigdata->event) == 0) process_ddl_event_sql_drop(trigdata); PG_RETURN_NULL(); } extern void ts_process_utility_set_expect_chunk_modification(bool expect) { expect_chunk_modification = expect; } bool ts_process_utility_is_top_level(void) { return last_process_utility_context == PROCESS_UTILITY_TOPLEVEL; } bool ts_process_utility_is_context_nonatomic(void) { ProcessUtilityContext context = last_process_utility_context; return context == PROCESS_UTILITY_TOPLEVEL || context == PROCESS_UTILITY_QUERY_NONATOMIC; } void ts_process_utility_context_reset(void) { last_process_utility_context = PROCESS_UTILITY_TOPLEVEL; } static void process_utility_xact_abort(XactEvent event, void *arg) { switch (event) { case XACT_EVENT_ABORT: case XACT_EVENT_PARALLEL_ABORT: /* * Reset the expect_chunk_modification flag because it this is an * internal safety flag that is set to true only temporarily * during chunk operations. It should never remain true across * transactions. */ expect_chunk_modification = false; break; default: break; } } static void process_utility_subxact_abort(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg) { switch (event) { case SUBXACT_EVENT_ABORT_SUB: /* see note in process_utility_xact_abort */ expect_chunk_modification = false; break; default: break; } } void _process_utility_init(void) { prev_ProcessUtility_hook = ProcessUtility_hook; ProcessUtility_hook = timescaledb_ddl_command_start; RegisterXactCallback(process_utility_xact_abort, NULL); RegisterSubXactCallback(process_utility_subxact_abort, NULL); } void _process_utility_fini(void) { ProcessUtility_hook = prev_ProcessUtility_hook; UnregisterXactCallback(process_utility_xact_abort, NULL); UnregisterSubXactCallback(process_utility_subxact_abort, NULL); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/process_utility.h������������������������������������������������������������0000664�0000000�0000000�00000007503�15100345067�0020261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/plannodes.h> #include <parser/parse_node.h> #include <tcop/utility.h> #include "cache.h" typedef struct ProcessUtilityArgs { Cache *hcache; PlannedStmt *pstmt; QueryEnvironment *queryEnv; ParseState *parse_state; Node *parsetree; const char *query_string; ProcessUtilityContext context; ParamListInfo params; DestReceiver *dest; QueryCompletion *completion_tag; bool readonly_tree; } ProcessUtilityArgs; typedef enum { DDL_CONTINUE, DDL_DONE } DDLResult; typedef DDLResult (*ts_process_utility_handler_t)(ProcessUtilityArgs *args); extern void ts_process_utility_set_expect_chunk_modification(bool expect); /* * Procedures that use multiple transactions cannot be run in a transaction * block (from a function, from dynamic SQL) or in a subtransaction (from a * procedure block with an EXCEPTION clause). Such procedures use * PreventInTransactionBlock function to check whether they can be run. * * Though currently such checks are incomplete, because * PreventInTransactionBlock requires isTopLevel argument to throw a * consistent error when the call originates from a function. This * isTopLevel flag (that is a bit poorly named - see below) is not readily * available inside C procedures. The source of truth for it - * ProcessUtilityContext parameter is passed to ProcessUtility hooks, but * is not included with the function calls. There is an undocumented * SPI_inside_nonatomic_context function, that would have been sufficient * for isTopLevel flag, but it currently returns false when SPI connection * is absent (that is a valid scenario when C procedures are called from * top-lelev SQL instead of PLPG procedures or DO blocks) so it cannot be * used. * * To work around this the value of ProcessUtilityContext parameter is * saved when TS ProcessUtility hook is entered and can be accessed from * C procedures using new ts_process_utility_is_context_nonatomic function. * The result is called "non-atomic" instead of "top-level" because the way * how isTopLevel flag is determined from the ProcessUtilityContext value * in standard_ProcessUtility is insufficient for C procedures - it * excludes PROCESS_UTILITY_QUERY_NONATOMIC value (used when called from * PLPG procedure without an EXCEPTION clause) that is a valid use case for * C procedures with transactions. See details in the description of * ExecuteCallStmt function. * * It is expected that calls to C procedures are done with CALL and always * pass though the ProcessUtility hook. The ProcessUtilityContext * parameter is set to PROCESS_UTILITY_TOPLEVEL value by default. In * unlikely case when a C procedure is called without passing through * ProcessUtility hook and the call is done in atomic context, then * PreventInTransactionBlock checks will pass, but SPI_commit will fail * when checking that all current active snapshots are portal-owned * snapshots (the same behaviour that was observed before this change). * In atomic context there will be an additional snapshot set in * _SPI_execute_plan, see the snapshot handling invariants description * in that function. */ extern TSDLLEXPORT bool ts_process_utility_is_context_nonatomic(void); /* * Check if we are at top level. */ extern TSDLLEXPORT bool ts_process_utility_is_top_level(void); /* * Currently in TS ProcessUtility hook the saved ProcessUtilityContext * value is reset back to PROCESS_UTILITY_TOPLEVEL on normal exit but * is NOT reset in case of ereport exit. C procedures can call this * function to reset the saved value before doing the checks that can * result in ereport exit. */ extern TSDLLEXPORT void ts_process_utility_context_reset(void); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/scan_iterator.c��������������������������������������������������������������0000664�0000000�0000000�00000003166�15100345067�0017651�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include "scan_iterator.h" TSDLLEXPORT void ts_scan_iterator_set_index(ScanIterator *iterator, CatalogTable table, int indexid) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), table, indexid); } void ts_scan_iterator_end(ScanIterator *iterator) { ts_scanner_end_scan(&iterator->ctx); } void ts_scan_iterator_close(ScanIterator *iterator) { /* Ending a scan is a no-op if already ended */ ts_scanner_end_scan(&iterator->ctx); ts_scanner_close(&iterator->ctx); } TSDLLEXPORT void ts_scan_iterator_scan_key_init(ScanIterator *iterator, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument) { MemoryContext oldmcxt; Assert(iterator->ctx.scankey == NULL || iterator->ctx.scankey == iterator->scankey); iterator->ctx.scankey = iterator->scankey; if (iterator->ctx.nkeys >= EMBEDDED_SCAN_KEY_SIZE) elog(ERROR, "cannot scan more than %d keys", EMBEDDED_SCAN_KEY_SIZE); /* * For rescans, when the scan key is reinitialized during the scan, make * sure the scan key is initialized on the long-lived scankey memory * context. */ oldmcxt = MemoryContextSwitchTo(iterator->ctx.internal.scan_mcxt); ScanKeyInit(&iterator->scankey[iterator->ctx.nkeys++], attributeNumber, strategy, procedure, argument); MemoryContextSwitchTo(oldmcxt); } TSDLLEXPORT void ts_scan_iterator_rescan(ScanIterator *iterator) { ts_scanner_rescan(&iterator->ctx, NULL); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/scan_iterator.h��������������������������������������������������������������0000664�0000000�0000000�00000007726�15100345067�0017664�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/palloc.h> #include "scanner.h" #include "ts_catalog/catalog.h" #define EMBEDDED_SCAN_KEY_SIZE 5 typedef struct ScanIterator { ScannerCtx ctx; TupleInfo *tinfo; ScanKeyData scankey[EMBEDDED_SCAN_KEY_SIZE]; } ScanIterator; #define ts_scan_iterator_create(catalog_table_id, lock_mode, mctx) \ (ScanIterator) \ { \ .ctx = { \ .internal = { \ .ended = true, \ .scan_mcxt = CurrentMemoryContext, \ }, \ .table = catalog_get_table_id(ts_catalog_get(), catalog_table_id), \ .nkeys = 0, \ .scandirection = ForwardScanDirection, \ .lockmode = lock_mode, \ .result_mctx = mctx, \ .flags = SCANNER_F_NOFLAGS, \ }, \ } static inline TupleInfo * ts_scan_iterator_tuple_info(const ScanIterator *iterator) { return iterator->tinfo; } static inline TupleTableSlot * ts_scan_iterator_slot(const ScanIterator *iterator) { return iterator->tinfo->slot; } static inline HeapTuple ts_scan_iterator_fetch_heap_tuple(const ScanIterator *iterator, bool materialize, bool *should_free) { return ts_scanner_fetch_heap_tuple(iterator->tinfo, materialize, should_free); } static inline TupleDesc ts_scan_iterator_tupledesc(const ScanIterator *iterator) { return ts_scanner_get_tupledesc(iterator->tinfo); } static inline MemoryContext ts_scan_iterator_get_result_memory_context(const ScanIterator *iterator) { return iterator->ctx.result_mctx; } static inline void * ts_scan_iterator_alloc_result(const ScanIterator *iterator, Size size) { return MemoryContextAllocZero(iterator->ctx.result_mctx, size); } static inline void ts_scan_iterator_start_scan(ScanIterator *iterator) { ts_scanner_start_scan(&(iterator)->ctx); } static inline TupleInfo * ts_scan_iterator_next(ScanIterator *iterator) { iterator->tinfo = ts_scanner_next(&(iterator)->ctx); return iterator->tinfo; } static inline void ts_scan_iterator_scan_key_reset(ScanIterator *iterator) { iterator->ctx.nkeys = 0; } static inline bool ts_scan_iterator_is_started(ScanIterator *iterator) { return iterator->ctx.internal.started; } void TSDLLEXPORT ts_scan_iterator_set_index(ScanIterator *iterator, CatalogTable table, int indexid); void TSDLLEXPORT ts_scan_iterator_end(ScanIterator *iterator); void TSDLLEXPORT ts_scan_iterator_close(ScanIterator *iterator); void TSDLLEXPORT ts_scan_iterator_scan_key_init(ScanIterator *iterator, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument); /* * Reset the scan to use a new scan key. * * Note that the scan key should typically be reinitialized before a rescan. */ void TSDLLEXPORT ts_scan_iterator_rescan(ScanIterator *iterator); static inline void ts_scan_iterator_start_or_restart_scan(ScanIterator *iterator) { if (ts_scan_iterator_is_started(iterator)) ts_scan_iterator_rescan(iterator); else ts_scan_iterator_start_scan(iterator); } /* You must use `ts_scan_iterator_close` if terminating this loop early */ #define ts_scanner_foreach(scan_iterator) \ for (ts_scan_iterator_start_scan((scan_iterator)); \ ts_scan_iterator_next(scan_iterator) != NULL;) ������������������������������������������timescaledb-2.23.0/src/scanner.c��������������������������������������������������������������������0000664�0000000�0000000�00000033514�15100345067�0016445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/relscan.h> #include <access/xact.h> #include <executor/tuptable.h> #include <storage/bufmgr.h> #include <storage/lmgr.h> #include <storage/procarray.h> #include <utils/palloc.h> #include <utils/rel.h> #include <utils/snapmgr.h> #include "scanner.h" enum ScannerType { ScannerTypeTable, ScannerTypeIndex, }; /* * Scanner can implement both index and heap scans in a single interface. */ typedef struct Scanner { Relation (*openscan)(ScannerCtx *ctx); ScanDesc (*beginscan)(ScannerCtx *ctx); bool (*getnext)(ScannerCtx *ctx); void (*rescan)(ScannerCtx *ctx); void (*endscan)(ScannerCtx *ctx); void (*closescan)(ScannerCtx *ctx); } Scanner; /* Functions implementing heap scans */ static Relation table_scanner_open(ScannerCtx *ctx) { ctx->tablerel = table_open(ctx->table, ctx->lockmode); return ctx->tablerel; } static ScanDesc table_scanner_beginscan(ScannerCtx *ctx) { ctx->internal.scan.table_scan = table_beginscan(ctx->tablerel, ctx->snapshot, ctx->nkeys, ctx->scankey); return ctx->internal.scan; } static bool table_scanner_getnext(ScannerCtx *ctx) { bool success = table_scan_getnextslot(ctx->internal.scan.table_scan, ForwardScanDirection, ctx->internal.tinfo.slot); return success; } static void table_scanner_rescan(ScannerCtx *ctx) { table_rescan(ctx->internal.scan.table_scan, ctx->scankey); } static void table_scanner_endscan(ScannerCtx *ctx) { table_endscan(ctx->internal.scan.table_scan); } static void table_scanner_close(ScannerCtx *ctx) { LOCKMODE lockmode = (ctx->flags & SCANNER_F_KEEPLOCK) ? NoLock : ctx->lockmode; table_close(ctx->tablerel, lockmode); } /* Functions implementing index scans */ static Relation index_scanner_open(ScannerCtx *ctx) { ctx->tablerel = table_open(ctx->table, ctx->lockmode); ctx->indexrel = index_open(ctx->index, ctx->lockmode); return ctx->indexrel; } static ScanDesc index_scanner_beginscan(ScannerCtx *ctx) { InternalScannerCtx *ictx = &ctx->internal; ictx->scan.index_scan = index_beginscan_compat(ctx->tablerel, ctx->indexrel, ctx->snapshot, NULL, ctx->nkeys, ctx->norderbys); ictx->scan.index_scan->xs_want_itup = ctx->want_itup; index_rescan(ictx->scan.index_scan, ctx->scankey, ctx->nkeys, NULL, ctx->norderbys); return ictx->scan; } static bool index_scanner_getnext(ScannerCtx *ctx) { InternalScannerCtx *ictx = &ctx->internal; bool success; success = index_getnext_slot(ictx->scan.index_scan, ctx->scandirection, ictx->tinfo.slot); ictx->tinfo.ituple = ictx->scan.index_scan->xs_itup; ictx->tinfo.ituple_desc = ictx->scan.index_scan->xs_itupdesc; return success; } static void index_scanner_rescan(ScannerCtx *ctx) { index_rescan(ctx->internal.scan.index_scan, ctx->scankey, ctx->nkeys, NULL, ctx->norderbys); } static void index_scanner_endscan(ScannerCtx *ctx) { index_endscan(ctx->internal.scan.index_scan); } static void index_scanner_close(ScannerCtx *ctx) { LOCKMODE lockmode = (ctx->flags & SCANNER_F_KEEPLOCK) ? NoLock : ctx->lockmode; index_close(ctx->indexrel, ctx->lockmode); table_close(ctx->tablerel, lockmode); } /* * Two scanners by type: heap and index scanners. */ static Scanner scanners[] = { [ScannerTypeTable] = { .openscan = table_scanner_open, .beginscan = table_scanner_beginscan, .getnext = table_scanner_getnext, .rescan = table_scanner_rescan, .endscan = table_scanner_endscan, .closescan = table_scanner_close, }, [ScannerTypeIndex] = { .openscan = index_scanner_open, .beginscan = index_scanner_beginscan, .getnext = index_scanner_getnext, .rescan = index_scanner_rescan, .endscan = index_scanner_endscan, .closescan = index_scanner_close, } }; static inline Scanner * scanner_ctx_get_scanner(ScannerCtx *ctx) { if (OidIsValid(ctx->index)) return &scanners[ScannerTypeIndex]; else return &scanners[ScannerTypeTable]; } TSDLLEXPORT void ts_scanner_rescan(ScannerCtx *ctx, const ScanKey scankey) { Scanner *scanner = scanner_ctx_get_scanner(ctx); MemoryContext oldmcxt; /* If scankey is NULL, the existing scan key was already updated or the * old should be reused */ if (NULL != scankey) memcpy(ctx->scankey, scankey, sizeof(*ctx->scankey)); oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); scanner->rescan(ctx); MemoryContextSwitchTo(oldmcxt); } static void prepare_scan(ScannerCtx *ctx) { ctx->internal.ended = false; ctx->internal.registered_snapshot = false; if (ctx->internal.scan_mcxt == NULL) ctx->internal.scan_mcxt = CurrentMemoryContext; if (ctx->snapshot == NULL) { /* * We use SnapshotSelf by default, for historical reasons mostly, but * we probably want to move to an MVCC snapshot as the default. The * difference is that a Self snapshot is an "instant" snapshot and can * see its own changes. More importantly, however, unlike an MVCC * snapshot, a Self snapshot is not subject to the strictness of * SERIALIZABLE isolation mode. * * This is important in case of, e.g., concurrent chunk creation by * two transactions; we'd like a transaction to use a new chunk as * soon as the creating transaction commits, so that there aren't * multiple transactions creating the same chunk and all but one fails * with a conflict. However, under SERIALIZABLE mode a transaction is * only allowed to read data from transactions that were committed * prior to transaction start. This means that two or more * transactions that create the same chunk must have all but the first * committed transaction fail. * * Therefore, we probably want to exempt internal bookkeeping metadata * from full SERIALIZABLE semantics (at least in the case of chunk * creation), or otherwise the INSERT behavior will be different for * hypertables compared to regular tables under SERIALIZABLE * mode. */ MemoryContext oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); ctx->snapshot = RegisterSnapshot(GetSnapshotData(SnapshotSelf)); /* * Invalidate the PG catalog snapshot to ensure it is refreshed and * up-to-date with the snapshot used to scan TimescaleDB * metadata. Since TimescaleDB metadata is often joined with PG * catalog data (e.g., calling get_relname_relid() to fill in chunk * table Oid), this avoids any potential problems where the different * snapshots used to scan TimescaleDB metadata and PG catalog metadata * aren't in sync. * * Ideally, a catalog snapshot would be used to scan TimescaleDB * metadata, but that will change the behavior of chunk creation in * SERIALIZED mode, as described above. */ InvalidateCatalogSnapshot(); ctx->internal.registered_snapshot = true; MemoryContextSwitchTo(oldmcxt); } } TSDLLEXPORT Relation ts_scanner_open(ScannerCtx *ctx) { Scanner *scanner = scanner_ctx_get_scanner(ctx); MemoryContext oldmcxt; Relation rel; Assert(NULL == ctx->tablerel); prepare_scan(ctx); Assert(ctx->internal.scan_mcxt != NULL); oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); rel = scanner->openscan(ctx); MemoryContextSwitchTo(oldmcxt); return rel; } /* * Start either a heap or index scan depending on the information in the * ScannerCtx. ScannerCtx must be setup by caller with the proper information * for the scan, including filters and callbacks for found tuples. */ TSDLLEXPORT void ts_scanner_start_scan(ScannerCtx *ctx) { InternalScannerCtx *ictx = &ctx->internal; Scanner *scanner; TupleDesc tuple_desc; MemoryContext oldmcxt; if (ictx->started) { Assert(!ictx->ended); Assert(ctx->tablerel); Assert(OidIsValid(ctx->table)); return; } if (ctx->tablerel == NULL) { Assert(NULL == ctx->indexrel); ts_scanner_open(ctx); } else { /* * Relations already opened by caller: Only need to prepare the scan * and set relation Oids so that the scanner knows which scanner * implementation to use. Respect the auto-closing behavior set by the * user, which is to auto close if unspecified. */ prepare_scan(ctx); ctx->table = RelationGetRelid(ctx->tablerel); if (NULL != ctx->indexrel) ctx->index = RelationGetRelid(ctx->indexrel); } Assert(ctx->internal.scan_mcxt != NULL); oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); scanner = scanner_ctx_get_scanner(ctx); scanner->beginscan(ctx); tuple_desc = RelationGetDescr(ctx->tablerel); ictx->tinfo.scanrel = ctx->tablerel; ictx->tinfo.mctx = ctx->result_mctx == NULL ? CurrentMemoryContext : ctx->result_mctx; ictx->tinfo.slot = MakeSingleTupleTableSlot(tuple_desc, table_slot_callbacks(ctx->tablerel)); MemoryContextSwitchTo(oldmcxt); /* Call pre-scan handler, if any. */ if (ctx->prescan != NULL) ctx->prescan(ctx->data); ictx->started = true; } static inline bool ts_scanner_limit_reached(ScannerCtx *ctx) { return ctx->limit > 0 && ctx->internal.tinfo.count >= ctx->limit; } static void scanner_cleanup(ScannerCtx *ctx) { InternalScannerCtx *ictx = &ctx->internal; if (ictx->registered_snapshot) { UnregisterSnapshot(ctx->snapshot); ctx->snapshot = NULL; } if (NULL != ictx->tinfo.slot) { ExecDropSingleTupleTableSlot(ictx->tinfo.slot); ictx->tinfo.slot = NULL; } if (NULL != ictx->scan_mcxt) { ictx->scan_mcxt = NULL; } } TSDLLEXPORT void ts_scanner_end_scan(ScannerCtx *ctx) { InternalScannerCtx *ictx = &ctx->internal; Scanner *scanner = scanner_ctx_get_scanner(ctx); MemoryContext oldmcxt; if (ictx->ended) return; /* Call post-scan handler, if any. */ if (ctx->postscan != NULL) ctx->postscan(ictx->tinfo.count, ctx->data); oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); scanner->endscan(ctx); MemoryContextSwitchTo(oldmcxt); scanner_cleanup(ctx); ictx->ended = true; ictx->started = false; } TSDLLEXPORT void ts_scanner_close(ScannerCtx *ctx) { Scanner *scanner = scanner_ctx_get_scanner(ctx); Assert(ctx->internal.ended); if (NULL != ctx->tablerel) { scanner->closescan(ctx); ctx->tablerel = NULL; ctx->indexrel = NULL; } } TSDLLEXPORT TupleInfo * ts_scanner_next(ScannerCtx *ctx) { InternalScannerCtx *ictx = &ctx->internal; Scanner *scanner = scanner_ctx_get_scanner(ctx); bool is_valid = false; if (!ts_scanner_limit_reached(ctx)) { MemoryContext oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); is_valid = scanner->getnext(ctx); MemoryContextSwitchTo(oldmcxt); } while (is_valid) { if (ctx->filter == NULL || ctx->filter(&ictx->tinfo, ctx->data) == SCAN_INCLUDE) { ictx->tinfo.count++; if (ctx->tuplock) { TupleTableSlot *slot = ictx->tinfo.slot; Assert(ctx->snapshot); ictx->tinfo.lockresult = table_tuple_lock(ctx->tablerel, &(slot->tts_tid), ctx->snapshot, slot, GetCurrentCommandId(false), ctx->tuplock->lockmode, ctx->tuplock->waitpolicy, ctx->tuplock->lockflags, &ictx->tinfo.lockfd); } /* stop at a valid tuple */ return &ictx->tinfo; } if (ts_scanner_limit_reached(ctx)) is_valid = false; else { MemoryContext oldmcxt = MemoryContextSwitchTo(ctx->internal.scan_mcxt); is_valid = scanner->getnext(ctx); MemoryContextSwitchTo(oldmcxt); } } if (!(ctx->flags & SCANNER_F_NOEND)) ts_scanner_end_scan(ctx); if (!(ctx->flags & SCANNER_F_NOEND_AND_NOCLOSE)) ts_scanner_close(ctx); return NULL; } /* * Perform either a heap or index scan depending on the information in the * ScannerCtx. ScannerCtx must be setup by caller with the proper information * for the scan, including filters and callbacks for found tuples. * * Return the number of tuples that were found. */ TSDLLEXPORT int ts_scanner_scan(ScannerCtx *ctx) { TupleInfo *tinfo; MemSet(&ctx->internal, 0, sizeof(ctx->internal)); for (ts_scanner_start_scan(ctx); (tinfo = ts_scanner_next(ctx));) { if (ctx->tuple_found != NULL) { ScanTupleResult scan_result = ctx->tuple_found(tinfo, ctx->data); /* Call tuple_found handler. Abort the scan if the handler wants us to */ if (scan_result == SCAN_DONE) { if (!(ctx->flags & SCANNER_F_NOEND)) ts_scanner_end_scan(ctx); if (!(ctx->flags & SCANNER_F_NOEND_AND_NOCLOSE)) ts_scanner_close(ctx); break; } else if (scan_result == SCAN_RESTART_WITH_NEW_SNAPSHOT) { ts_scanner_end_scan(ctx); ctx->internal.tinfo.count = 0; ctx->snapshot = RegisterSnapshot(GetLatestSnapshot()); ts_scanner_start_scan(ctx); /* Since we register the snapshot manually above, * we need to mark it as registered in the scanner but only after we * start the scan since the scanner resets this flag and sets it only * if the snapshot gets registered during scan preparation phase. */ ctx->internal.registered_snapshot = true; } } } return ctx->internal.tinfo.count; } TSDLLEXPORT bool ts_scanner_scan_one(ScannerCtx *ctx, bool fail_if_not_found, const char *item_type) { /* Since this function ignores the custom limit, we assume that no custom limit is set by the * caller. */ Assert(ctx->limit == 0); /* We are interested in a maximum of two tuples to determine whether the addressed tuple is * unique. */ ctx->limit = 2; int num_found = ts_scanner_scan(ctx); switch (num_found) { case 0: if (fail_if_not_found) { elog(ERROR, "%s not found", item_type); } return false; case 1: return true; default: elog(ERROR, "more than one %s found", item_type); return false; } } ItemPointer ts_scanner_get_tuple_tid(TupleInfo *ti) { return &ti->slot->tts_tid; } HeapTuple ts_scanner_fetch_heap_tuple(const TupleInfo *ti, bool materialize, bool *should_free) { return ExecFetchSlotHeapTuple(ti->slot, materialize, should_free); } TupleDesc ts_scanner_get_tupledesc(const TupleInfo *ti) { return ti->slot->tts_tupleDescriptor; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/scanner.h��������������������������������������������������������������������0000664�0000000�0000000�00000011202�15100345067�0016440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/genam.h> #include <access/heapam.h> #include <nodes/lockoptions.h> #include <utils/fmgroids.h> #include "compat/compat.h" #include "utils.h" typedef struct ScanTupLock { LockTupleMode lockmode; LockWaitPolicy waitpolicy; unsigned int lockflags; } ScanTupLock; /* Tuple information passed on to handlers when scanning for tuples. */ typedef struct TupleInfo { Relation scanrel; TupleTableSlot *slot; /* return index tuple if it was requested -- only for index scans */ IndexTuple ituple; TupleDesc ituple_desc; /* * If the user requested a tuple lock, the result of the lock is passed on * in lockresult. */ TM_Result lockresult; /* Failure data in case of failed tuple lock */ TM_FailureData lockfd; int count; /* * The memory context (optionally) set initially in the ScannerCtx. This * can be used to allocate data on in the tuple handle function. */ MemoryContext mctx; } TupleInfo; typedef enum ScanTupleResult { SCAN_DONE, SCAN_CONTINUE, SCAN_RESTART_WITH_NEW_SNAPSHOT } ScanTupleResult; typedef enum ScanFilterResult { SCAN_EXCLUDE, SCAN_INCLUDE } ScanFilterResult; typedef ScanTupleResult (*tuple_found_func)(TupleInfo *ti, void *data); typedef ScanFilterResult (*tuple_filter_func)(const TupleInfo *ti, void *data); typedef void (*postscan_func)(int num_tuples, void *data); typedef union ScanDesc { IndexScanDesc index_scan; TableScanDesc table_scan; } ScanDesc; typedef enum ScannerFlags { SCANNER_F_NOFLAGS = 0x00, SCANNER_F_KEEPLOCK = 0x01, SCANNER_F_NOEND = 0x02, SCANNER_F_NOEND_AND_NOCLOSE = 0x04 | SCANNER_F_NOEND, } ScannerFlags; /* * InternalScannerCtx is used for internal state during scanning and shouldn't * be initialized or touched by the user. */ typedef struct InternalScannerCtx { TupleInfo tinfo; ScanDesc scan; /* * PG scan functions must be called on a memory context that lives * throughout the entire scan. Use the scan_mcxt to ensure that * functions aren't called on, e.g., a per-tuple context. */ MemoryContext scan_mcxt; bool registered_snapshot; bool started; bool ended; } InternalScannerCtx; typedef struct ScannerCtx { InternalScannerCtx internal; /* Fields below this line can be initialized by the user */ Oid table; Oid index; Relation tablerel; Relation indexrel; ScanKey scankey; int flags; int nkeys, norderbys, limit; /* Limit on number of tuples to return. 0 or * less means no limit */ bool want_itup; LOCKMODE lockmode; MemoryContext result_mctx; /* The memory context to allocate the result * on */ const ScanTupLock *tuplock; ScanDirection scandirection; Snapshot snapshot; /* Snapshot requested by the caller. Set automatically * when NULL */ void *data; /* User-provided data passed on to filter() * and tuple_found() */ /* * Optional handler called before a scan starts, but relation locks are * acquired. */ void (*prescan)(void *data); /* * Optional handler called after a scan finishes and before relation locks * are released. Passes on the number of tuples found. */ void (*postscan)(int num_tuples, void *data); /* * Optional handler to filter tuples. Should return SCAN_INCLUDE for * tuples that should be passed on to tuple_found, or SCAN_EXCLUDE * otherwise. */ ScanFilterResult (*filter)(const TupleInfo *ti, void *data); /* * Handler for found tuples. Should return SCAN_CONTINUE to continue the * scan or SCAN_DONE to finish without scanning further tuples. */ ScanTupleResult (*tuple_found)(TupleInfo *ti, void *data); } ScannerCtx; /* Performs an index scan or heap scan and returns the number of matching * tuples. */ extern TSDLLEXPORT Relation ts_scanner_open(ScannerCtx *ctx); extern TSDLLEXPORT void ts_scanner_close(ScannerCtx *ctx); extern TSDLLEXPORT int ts_scanner_scan(ScannerCtx *ctx); extern TSDLLEXPORT bool ts_scanner_scan_one(ScannerCtx *ctx, bool fail_if_not_found, const char *item_type); extern TSDLLEXPORT void ts_scanner_start_scan(ScannerCtx *ctx); extern TSDLLEXPORT void ts_scanner_end_scan(ScannerCtx *ctx); extern TSDLLEXPORT void ts_scanner_rescan(ScannerCtx *ctx, const ScanKey scankey); extern TSDLLEXPORT TupleInfo *ts_scanner_next(ScannerCtx *ctx); extern TSDLLEXPORT ItemPointer ts_scanner_get_tuple_tid(TupleInfo *ti); extern TSDLLEXPORT HeapTuple ts_scanner_fetch_heap_tuple(const TupleInfo *ti, bool materialize, bool *should_free); extern TSDLLEXPORT TupleDesc ts_scanner_get_tupledesc(const TupleInfo *ti); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/sort_transform.c�������������������������������������������������������������0000664�0000000�0000000�00000040023�15100345067�0020067�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/plannodes.h> #include <optimizer/paths.h> #include <optimizer/planner.h> #include <parser/parsetree.h> #include <utils/fmgroids.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include "compat/compat.h" #include "cross_module_fn.h" #include "func_cache.h" #include "hypertable.h" #include "import/allpaths.h" #include "sort_transform.h" /* This optimizations allows GROUP BY clauses that transform time in * order-preserving ways to use indexes on the time field. It works * by transforming sorting clauses from their more complex versions * to simplified ones that can use the plain index, if the transform * is order preserving. * * For example, an ordering on date_trunc('minute', time) can be transformed * to an ordering on time. */ static Expr * transform_timestamp_cast(FuncExpr *func) { /* * transform cast from timestamptz to timestamp * * timestamp(var) => var * * proof: timestamp(time1) >= timestamp(time2) iff time1 > time2 * */ Expr *first; if (list_length(func->args) != 1) return (Expr *) func; first = ts_sort_transform_expr(linitial(func->args)); if (!IsA(first, Var)) return (Expr *) func; return (Expr *) copyObject(first); } static Expr * transform_timestamptz_cast(FuncExpr *func) { /* * Transform cast from date to timestamptz, or timestamp to timestamptz, * or abstime to timestamptz Handles only single-argument versions of the * cast to avoid explicit timezone specifiers * * * timestamptz(var) => var * * proof: timestamptz(time1) >= timestamptz(time2) iff time1 > time2 * */ Expr *first; if (list_length(func->args) != 1) return (Expr *) func; first = ts_sort_transform_expr(linitial(func->args)); if (!IsA(first, Var)) return (Expr *) func; return (Expr *) copyObject(first); } static inline Expr * transform_time_op_const_interval(OpExpr *op) { /* * optimize timestamp(tz) +/- const interval * * Sort of ts + 1 minute fulfilled by sort of ts */ if (list_length(op->args) == 2 && IsA(lsecond(op->args), Const)) { Oid left = exprType((Node *) linitial(op->args)); Oid right = exprType((Node *) lsecond(op->args)); if ((left == TIMESTAMPOID && right == INTERVALOID) || (left == TIMESTAMPTZOID && right == INTERVALOID) || (left == DATEOID && right == INTERVALOID)) { Interval *interval = DatumGetIntervalP((lsecond_node(Const, op->args))->constvalue); if (interval->month != 0 || interval->day != 0) return (Expr *) op; char *name = get_opname(op->opno); if (strncmp(name, "-", NAMEDATALEN) == 0 || strncmp(name, "+", NAMEDATALEN) == 0) { Expr *first = ts_sort_transform_expr((Expr *) linitial(op->args)); if (IsA(first, Var)) return copyObject(first); } } } return (Expr *) op; } static inline Expr * transform_int_op_const(OpExpr *op) { /* * Optimize int op const (or const op int), whenever possible. e.g. sort * of some_int + const fulfilled by sort of some_int same for the * following operator: + - / * * * Note that / is not commutative and const / var does NOT work (namely it * reverses sort order, which we don't handle yet) */ if (list_length(op->args) == 2 && (IsA(lsecond(op->args), Const) || IsA(linitial(op->args), Const))) { Oid left = exprType((Node *) linitial(op->args)); Oid right = exprType((Node *) lsecond(op->args)); if ((left == INT8OID && right == INT8OID) || (left == INT4OID && right == INT4OID) || (left == INT2OID && right == INT2OID)) { char *name = get_opname(op->opno); if (name[1] == '\0') { switch (name[0]) { case '-': case '+': case '*': /* commutative cases */ if (IsA(linitial(op->args), Const)) { Expr *nonconst = ts_sort_transform_expr((Expr *) lsecond(op->args)); if (IsA(nonconst, Var)) return copyObject(nonconst); } else { Expr *nonconst = ts_sort_transform_expr((Expr *) linitial(op->args)); if (IsA(nonconst, Var)) return copyObject(nonconst); } break; case '/': /* only if second arg is const */ if (IsA(lsecond(op->args), Const)) { Expr *nonconst = ts_sort_transform_expr((Expr *) linitial(op->args)); if (IsA(nonconst, Var)) return copyObject(nonconst); } break; default: /* * Do nothing for unknown operators. The explicit empty * branch is to placate the static analyzers. */ break; } } } } return (Expr *) op; } /* sort_transforms_expr returns a simplified sort expression in a form * more common for indexes. Must return same data type & collation too. * * Sort transforms have the following correctness condition: * Any ordering provided by the returned expression is a valid * ordering under the original expression. The reverse need not * be true to apply the transformation to the last member of pathkeys * but it would need to be true to apply the transformation to * arbitrary members of pathkeys. * * Namely if orig_expr(X) > orig_expr(Y) then * new_expr(X) > new_expr(Y). * * Note that if orig_expr(X) = orig_expr(Y) then * the ordering under new_expr is unconstrained. * */ Expr * ts_sort_transform_expr(Expr *orig_expr) { if (IsA(orig_expr, FuncExpr)) { FuncExpr *func = (FuncExpr *) orig_expr; FuncInfo *finfo = ts_func_cache_get_bucketing_func(func->funcid); if (NULL != finfo) { if (NULL == finfo->sort_transform) return orig_expr; return finfo->sort_transform(func); } /* Functions of one argument that convert something to timestamp(tz). */ if (func->funcid == F_TIMESTAMP_DATE || func->funcid == F_TIMESTAMP_TIMESTAMPTZ) { return transform_timestamp_cast(func); } if (func->funcid == F_TIMESTAMPTZ_DATE || func->funcid == F_TIMESTAMPTZ_TIMESTAMP) { return transform_timestamptz_cast(func); } } if (IsA(orig_expr, OpExpr)) { OpExpr *op = (OpExpr *) orig_expr; Oid type_first = exprType((Node *) linitial(op->args)); if (type_first == TIMESTAMPOID || type_first == TIMESTAMPTZOID || type_first == DATEOID) { return transform_time_op_const_interval(op); } if (type_first == INT2OID || type_first == INT4OID || type_first == INT8OID) { return transform_int_op_const(op); } } return orig_expr; } /* sort_transform_ec creates a new EquivalenceClass with transformed * expressions if any of the members of the original EC can be transformed for the sort. */ static EquivalenceClass * sort_transform_ec(PlannerInfo *root, EquivalenceClass *orig, Relids child_relids) { EquivalenceClass *newec = NULL; bool propagate_to_children = false; /* check all members, adding only transformable members to new ec */ EquivalenceMember *ec_mem; #if PG18_GE /* Use specialized iterator to include child ems. * * https://github.com/postgres/postgres/commit/d69d45a5 */ EquivalenceMemberIterator it; setup_eclass_member_iterator(&it, orig, child_relids); while ((ec_mem = eclass_member_iterator_next(&it)) != NULL) { #else ListCell *lc_member; foreach (lc_member, orig->ec_members) { ec_mem = (EquivalenceMember *) lfirst(lc_member); #endif Expr *transformed_expr = ts_sort_transform_expr(ec_mem->em_expr); if (transformed_expr != ec_mem->em_expr) { EquivalenceMember *em; Oid type_oid = exprType((Node *) transformed_expr); List *opfamilies = list_copy(orig->ec_opfamilies); #if PG16_LT /* * if the transform already exists for even one member, assume * exists for all */ EquivalenceClass *exist = get_eclass_for_sort_expr(root, transformed_expr, ec_mem->em_nullable_relids, opfamilies, type_oid, orig->ec_collation, orig->ec_sortref, ec_mem->em_relids, false); #else EquivalenceClass *exist = get_eclass_for_sort_expr(root, transformed_expr, opfamilies, type_oid, orig->ec_collation, orig->ec_sortref, ec_mem->em_relids, false); #endif if (exist != NULL) { return exist; } em = makeNode(EquivalenceMember); em->em_expr = transformed_expr; em->em_relids = bms_copy(ec_mem->em_relids); #if PG16_LT em->em_nullable_relids = bms_copy(ec_mem->em_nullable_relids); #endif em->em_is_const = ec_mem->em_is_const; em->em_is_child = ec_mem->em_is_child; em->em_datatype = type_oid; if (newec == NULL) { /* lazy create the ec. */ newec = makeNode(EquivalenceClass); newec->ec_opfamilies = opfamilies; newec->ec_collation = orig->ec_collation; newec->ec_members = NIL; #if PG18_GE newec->ec_childmembers = NULL; newec->ec_childmembers_size = 0; #endif newec->ec_sources = list_copy(orig->ec_sources); newec->ec_derives_list = list_copy(orig->ec_derives_list); newec->ec_relids = bms_copy(orig->ec_relids); newec->ec_has_const = orig->ec_has_const; /* Even if the original EC has volatile (it has time_bucket_gapfill) * this ordering is purely on the time column, so it is non-volatile * and should be propagated to the children. */ newec->ec_has_volatile = false; #if PG16_LT newec->ec_below_outer_join = orig->ec_below_outer_join; #endif newec->ec_broken = orig->ec_broken; newec->ec_sortref = orig->ec_sortref; newec->ec_merged = orig->ec_merged; /* Volatile ECs only ever have one member, that of the root, * so if the original EC was volatile, we need to propagate the * new EC to the children ourselves. */ propagate_to_children = orig->ec_has_volatile; /* Even though time_bucket_gapfill is marked as VOLATILE to * prevent the planner from removing the call, it's still safe * to use values from child tables in lieu of the output of the * root table. Among other things, this allows us to use the * sort-order from the child tables for the output. */ orig->ec_has_volatile = false; } #if PG18_LT newec->ec_members = lappend(newec->ec_members, em); #else /* Update the child member lists when adding child ems. * * https://github.com/postgres/postgres/commit/d69d45a5 */ if (em->em_is_child) ts_add_child_eq_member(root, newec, em, it.current_relid); else newec->ec_members = lappend(newec->ec_members, em); int i = -1; for (; i >= 0; i = bms_next_member(em->em_relids, i)) { RelOptInfo *child_rel = root->simple_rel_array[i]; child_rel->eclass_indexes = bms_add_member(child_rel->eclass_indexes, root->eq_classes->length); } #endif } } /* if any transforms were found return new ec */ if (newec != NULL) { root->eq_classes = lappend(root->eq_classes, newec); if (propagate_to_children) { Bitmapset *parents = bms_copy(newec->ec_relids); ListCell *lc; int parent; bms_get_singleton_member(parents, &parent); foreach (lc, root->append_rel_list) { AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc); if (appinfo->parent_relid == (Index) parent) { RelOptInfo *parent_rel = root->simple_rel_array[appinfo->parent_relid]; RelOptInfo *child_rel = root->simple_rel_array[appinfo->child_relid]; add_child_rel_equivalences(root, appinfo, parent_rel, child_rel); } } } return newec; } return NULL; } /* * This optimization transforms between equivalent sort operations to try * to find useful indexes. * * For example: an ORDER BY date_trunc('minute', time) can be implemented by * an ordering of time. */ List * ts_sort_transform_get_pathkeys(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte, Hypertable *ht) { /* * We attack this problem in three steps: * * 1) Create a pathkey for the transformed (simplified) sort. * * 2) Use the transformed pathkey to find new useful index paths. * * 3) Transform the pathkey of the new paths back into the original form * to make this transparent to upper levels in the planner. * */ ListCell *lc; List *transformed_query_pathkeys = NIL; PathKey *last_pk; PathKey *new_pk; EquivalenceClass *transformed; /* * nothing to do for empty pathkeys */ if (root->query_pathkeys == NIL) return NIL; /* * These sort transformations are only safe for single member ORDER BY * clauses or as last member of the ORDER BY clause. * Using it for other ORDER BY clauses will result in wrong ordering. */ last_pk = llast(root->query_pathkeys); /* * We can only transform the original pathkey if it references our hypertable. * If it references another one, we might be able to successfully transform * it to a join EC that references both hypertables, but when we replace it * back, we'll get into an incorrect state where the pathkey for the scan * references only a different hypertable and doesn't have an EC member for * ours. */ int desired_ec_relid = rel->relid; if (rel->reloptkind == RELOPT_OTHER_MEMBER_REL) { /* * The EC relids contain only inheritance parents, not individual * children. */ AppendRelInfo *appinfo = root->append_rel_array[rel->relid]; desired_ec_relid = appinfo->parent_relid; } EquivalenceClass *last_pk_eclass = last_pk->pk_eclass; if (!bms_is_member(desired_ec_relid, last_pk_eclass->ec_relids)) { return NIL; } Relids child_relids = NULL; #if PG18_GE /* In PG18, iterating over child ems requires you to * use child relids with a special iterator. Here we gather * them by collecting them from childmembers array. * * https://github.com/postgres/postgres/commit/d69d45a5 */ for (int i = 0; i < last_pk_eclass->ec_childmembers_size; i++) { if (list_length(last_pk_eclass->ec_childmembers[i]) > 0) { child_relids = bms_add_member(child_relids, i); } } #endif /* * Try to apply the transformation. */ transformed = sort_transform_ec(root, last_pk_eclass, child_relids); if (transformed == NULL) return NIL; new_pk = make_canonical_pathkey(root, transformed, last_pk->pk_opfamily, last_pk->pk_cmptype, last_pk->pk_nulls_first); /* * create complete transformed pathkeys */ foreach (lc, root->query_pathkeys) { if (lfirst(lc) != last_pk) transformed_query_pathkeys = lappend(transformed_query_pathkeys, lfirst(lc)); else transformed_query_pathkeys = lappend(transformed_query_pathkeys, new_pk); } return transformed_query_pathkeys; } /* * After we have created new paths with transformed pathkeys, replace them back * with the original pathkeys. */ void ts_sort_transform_replace_pathkeys(void *node, List *transformed_pathkeys, List *original_pathkeys) { if (node == NULL) { return; } if (IsA(node, List)) { List *list = castNode(List, node); ListCell *lc; foreach (lc, list) { ts_sort_transform_replace_pathkeys(lfirst(lc), transformed_pathkeys, original_pathkeys); } return; } Path *path = (Path *) node; if (compare_pathkeys(path->pathkeys, transformed_pathkeys) == PATHKEYS_EQUAL) { path->pathkeys = original_pathkeys; } if (IsA(path, CustomPath)) { /* * We should only see ChunkAppend here. */ CustomPath *custom = castNode(CustomPath, path); ts_sort_transform_replace_pathkeys(custom->custom_paths, transformed_pathkeys, original_pathkeys); } else if (IsA(path, MergeAppendPath)) { MergeAppendPath *append = castNode(MergeAppendPath, path); ts_sort_transform_replace_pathkeys(append->subpaths, transformed_pathkeys, original_pathkeys); } else if (IsA(path, AppendPath)) { AppendPath *append = castNode(AppendPath, path); ts_sort_transform_replace_pathkeys(append->subpaths, transformed_pathkeys, original_pathkeys); } else if (IsA(path, ProjectionPath)) { ProjectionPath *projection = castNode(ProjectionPath, path); ts_sort_transform_replace_pathkeys(projection->subpath, transformed_pathkeys, original_pathkeys); } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/sort_transform.h�������������������������������������������������������������0000664�0000000�0000000�00000001111�15100345067�0020067�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "hypertable.h" #include "import/planner.h" extern Expr *ts_sort_transform_expr(Expr *expr); extern List *ts_sort_transform_get_pathkeys(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte, Hypertable *ht); extern void ts_sort_transform_replace_pathkeys(void *node, List *transformed_pathkeys, List *original_pathkeys); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/subspace_store.README.md�����������������������������������������������������0000664�0000000�0000000�00000004103�15100345067�0021137�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������A subspace store allows you to save data associated with a multidimensional-subspace. We use this to cache per-chunk values, such as `chunk`s or `chunk_insert_state`. Subspaces are defined conceptually via a Hypercube (that is a collection of slices -- one for each dimension). Thus, a subspace is a "rectangular" cutout in a multidimensional space. that is given a hypertable with (ts Timestamp, i int) with intervals of one hour and 2 hash-partitions the subspaces could be: ``` 00:00 01:00 02:00 03:00 ---|-------|-------|-------|-------|--- - - 1 | | | | | ---|-------|-------|-------|-------|--- - - 2 | | | | | ---|-------|-------|-------|-------|--- - - 3 | | | | | ---|-------|-------|-------|-------|--- - - ``` Each subspace is cached in a tree structure, with each level of the tree corresponding to a dimension the hypertable is partitioned on, with the first level always being an open (time) dimension time dimension. Thus, the aforementioned hypertable will have the following tree: ``` SubspaceStore | V SubspaceStoreInternalNode (time) | (.vector) V | o | ... | ... | ... | | V DimensionSlice (00:00 - 01:00) | V SubspaceStoreInternalNode (dim 1) | V . . . | V ChunkInsertState (or other leaf object) ``` Each `SubspaceStoreInternalNode` has a field `descendants` storing a count of the number of leaf objects for that subtree, which we used to ensure `SubspaceStore`s don't grow beyond their maximum size. Currently our strategy when adding to a full `SubspaceStore` is to evict the all elements referenced from the first entry of the top-most vector. The assumption is that the topmost vector indexes based on time, and that the first element stores state for those chunks with the earliest time. If we usually perform operations in time-order, these are the elements least likely to be reused. This eviction-strategy is the only reason that the first level of a `SubspaceStore` is always a open (time) dimension. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/subspace_store.c�������������������������������������������������������������0000664�0000000�0000000�00000015133�15100345067�0020032�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <utils/memutils.h> #include "dimension.h" #include "dimension_slice.h" #include "dimension_vector.h" #include "hypercube.h" #include "subspace_store.h" /* * In terms of datastructures, the subspace store is actually a tree. At the * root of a tree is a DimensionVec representing the different DimensionSlices * for the first dimension. Each of the DimensionSlices of the * first dimension point to a DimensionVec of the second dimension. This recurses * for the N dimensions. The leaf DimensionSlice points to the data being stored. * * */ typedef struct SubspaceStoreInternalNode { DimensionVec *vector; uint16 descendants; bool last_internal_node; } SubspaceStoreInternalNode; typedef struct SubspaceStore { MemoryContext mcxt; uint16 num_dimensions; /* limit growth of store by limiting number of slices in first dimension, 0 for no limit */ uint16 max_items; SubspaceStoreInternalNode *origin; /* origin of the tree */ } SubspaceStore; static inline SubspaceStoreInternalNode * subspace_store_internal_node_create(bool last_internal_node) { SubspaceStoreInternalNode *node = palloc(sizeof(SubspaceStoreInternalNode)); node->vector = ts_dimension_vec_create(DIMENSION_VEC_DEFAULT_SIZE); node->descendants = 0; node->last_internal_node = last_internal_node; return node; } static inline void subspace_store_internal_node_free(void *node) { ts_dimension_vec_free(((SubspaceStoreInternalNode *) node)->vector); pfree(node); } static size_t subspace_store_internal_node_descendants(SubspaceStoreInternalNode *node, int index) { const DimensionSlice *slice = ts_dimension_vec_get(node->vector, index); if (slice == NULL) return 0; if (node->last_internal_node) return 1; return ((SubspaceStoreInternalNode *) slice->storage)->descendants; } SubspaceStore * ts_subspace_store_init(const Hyperspace *space, MemoryContext mcxt, int16 max_items) { MemoryContext old = MemoryContextSwitchTo(mcxt); SubspaceStore *sst = palloc(sizeof(SubspaceStore)); sst->origin = subspace_store_internal_node_create(space->num_dimensions == 1); sst->num_dimensions = space->num_dimensions; /* max_items = 0 is treated as unlimited */ sst->max_items = max_items; sst->mcxt = mcxt; MemoryContextSwitchTo(old); return sst; } void ts_subspace_store_add(SubspaceStore *subspace_store, const Hypercube *hypercube, void *object, void (*object_free)(void *)) { SubspaceStoreInternalNode *node = subspace_store->origin; DimensionSlice *last = NULL; MemoryContext old = MemoryContextSwitchTo(subspace_store->mcxt); int i; Assert(hypercube->num_slices == subspace_store->num_dimensions); for (i = 0; i < hypercube->num_slices; i++) { const DimensionSlice *target = hypercube->slices[i]; DimensionSlice *match; Assert(target->storage == NULL); if (node == NULL) { /* * We should have one internal node per dimension in the * hypertable. If we don't have one for the current dimension, * create one now. (There will always be one for time) */ Assert(last != NULL); last->storage = subspace_store_internal_node_create(i == (hypercube->num_slices - 1)); last->storage_free = subspace_store_internal_node_free; node = last->storage; } Assert(subspace_store->max_items == 0 || node->descendants <= (size_t) subspace_store->max_items); /* * We only call this function on a cache miss, so number of leaves * will definitely increase see `Assert(last != NULL && last->storage * == NULL);` at bottom. */ node->descendants += 1; Assert(0 == node->vector->num_slices || node->vector->slices[0]->fd.dimension_id == target->fd.dimension_id); /* Do we have enough space to store the object? */ if (subspace_store->max_items > 0 && node->descendants > subspace_store->max_items) { /* * Always delete the slice corresponding to the earliest time * range. In the normal case that inserts are performed in * time-order this is the one least likely to be reused. (Note * that we made sure that the first dimension is a time dimension * when creating the subspace_store). If out-of-order inserts are * become significant we may wish to change this to something more * sophisticated like LRU. */ size_t items_removed = subspace_store_internal_node_descendants(node, i); /* * descendants at the root is inclusive of the descendants at the * children, so if we have an overflow it must be in the time dim */ Assert(i == 0); Assert(subspace_store->max_items + 1 == node->descendants); ts_dimension_vec_remove_slice(&node->vector, i); /* * Note we would have to do this to ancestors if this was not the * root. */ node->descendants -= items_removed; } match = ts_dimension_vec_find_slice(node->vector, target->fd.range_start); /* Do we have a slot in this vector for the new object? */ if (match == NULL) { DimensionSlice *copy; /* * create a new copy of the range this slice covers, to store the * object in */ copy = ts_dimension_slice_copy(target); ts_dimension_vec_add_slice_sort(&node->vector, copy); match = copy; } Assert(subspace_store->max_items == 0 || node->descendants <= (size_t) subspace_store->max_items); last = match; /* internal slices point to the next SubspaceStoreInternalNode */ node = last->storage; } Assert(last != NULL && last->storage == NULL); last->storage = object; /* at the end we store the object */ last->storage_free = object_free; MemoryContextSwitchTo(old); } void * ts_subspace_store_get(const SubspaceStore *subspace_store, const Point *target) { int i; DimensionVec *vec = subspace_store->origin->vector; DimensionSlice *match = NULL; Assert(target->cardinality == subspace_store->num_dimensions); /* The internal compressed hypertable has no dimensions as * chunks are created explicitly by compress_chunk and linked * to the source chunk. */ if (subspace_store->num_dimensions == 0) return NULL; for (i = 0; i < target->cardinality; i++) { match = ts_dimension_vec_find_slice(vec, target->coordinates[i]); if (NULL == match) return NULL; vec = ((SubspaceStoreInternalNode *) match->storage)->vector; } Assert(match != NULL); return match->storage; } void ts_subspace_store_free(SubspaceStore *subspace_store) { subspace_store_internal_node_free(subspace_store->origin); pfree(subspace_store); } MemoryContext ts_subspace_store_mcxt(const SubspaceStore *subspace_store) { return subspace_store->mcxt; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/subspace_store.h�������������������������������������������������������������0000664�0000000�0000000�00000002535�15100345067�0020041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "dimension.h" /* A subspace store allows you to save data associated with * a multidimensional-subspace. Subspaces are defined conceptually * via a Hypercube (that is a collection of slices -- one for each dimension). * Thus, a subspace is a "rectangular" cutout in a multidimensional space. */ typedef struct Hypercube Hypercube; typedef struct Point Point; typedef struct SubspaceStore SubspaceStore; extern SubspaceStore *ts_subspace_store_init(const Hyperspace *space, MemoryContext mcxt, int16 max_items); /* Store an object associate with the subspace represented by a hypercube */ extern void ts_subspace_store_add(SubspaceStore *subspace_store, const Hypercube *hypercube, void *object, void (*object_free)(void *)); /* Get the object stored for the subspace that a point is in. * Return the object stored or NULL if this subspace is not in the store. */ extern void *ts_subspace_store_get(const SubspaceStore *subspace_store, const Point *target); extern void ts_subspace_store_free(SubspaceStore *subspace_store); extern MemoryContext ts_subspace_store_mcxt(const SubspaceStore *subspace_store); �������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/�������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016654�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/CMakeLists.txt�����������������������������������������������������0000664�0000000�0000000�00000000524�15100345067�0021415�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Add all *.c to sources in upperlevel directory set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/functions.c ${CMAKE_CURRENT_SOURCE_DIR}/replication.c ${CMAKE_CURRENT_SOURCE_DIR}/stats.c ${CMAKE_CURRENT_SOURCE_DIR}/telemetry_metadata.c ${CMAKE_CURRENT_SOURCE_DIR}/telemetry.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/functions.c��������������������������������������������������������0000664�0000000�0000000�00000031775�15100345067�0021045�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ /* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <access/genam.h> #include <access/htup_details.h> #include <access/table.h> #include <catalog/indexing.h> #include <catalog/pg_depend.h> #include <catalog/pg_extension.h> #include <catalog/pg_proc.h> #include <commands/extension.h> #include <nodes/nodeFuncs.h> #include <port/atomics.h> #include <storage/lwlock.h> #include <utils/fmgroids.h> #include <utils/hsearch.h> #include <utils/regproc.h> #include "functions.h" #include "guc.h" #include "loader/function_telemetry.h" static bool skip_telemetry = false; static LWLock *function_counts_lock = NULL; static HTAB *function_counts; /*************************** * Telemetry draining code * ***************************/ typedef struct AllowedFnHashEntry { Oid fn; } AllowedFnHashEntry; // Get a HTAB of AllowedFnHashEntrys containing all and only those functions // that are within visible_extensions. This function should be equivalent to // the SQL // SELECT objid // FROM pg_catalog.pg_depend, pg_catalog.pg_extension extension // WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass // AND refobjid = extension.oid // AND deptype = 'e' // AND extname IN ('timescaledb','promscale','timescaledb_toolkit') // AND classid = 'pg_catalog.pg_proc'::regclass; static HTAB * allowed_extension_functions(const char **visible_extensions, int num_visible_extensions) { HASHCTL hash_info = { .keysize = sizeof(Oid), .entrysize = sizeof(AllowedFnHashEntry), .hcxt = CurrentMemoryContext, }; HTAB *allowed_fns = hash_create("fn telemetry allowed_functions", 1000, &hash_info, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); Relation depRel = table_open(DependRelationId, AccessShareLock); Oid *visible_extension_ids = palloc(num_visible_extensions * sizeof(Oid)); // get the Oid for each of the visible extensions for (int i = 0; i < num_visible_extensions; i++) visible_extension_ids[i] = get_extension_oid(visible_extensions[i], true); // go through the objects owned by each visible extension, and store the // ones that are functions in the set. for (int i = 0; i < num_visible_extensions; i++) { HeapTuple tup; ScanKeyData key[2]; SysScanDesc scan; Oid extension_id = visible_extension_ids[i]; if (!OidIsValid(extension_id)) continue; // Look in the (referenced object class, referenced object) index for // the allowed extensions. ScanKeyInit(&key[0], Anum_pg_depend_refclassid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(ExtensionRelationId)); ScanKeyInit(&key[1], Anum_pg_depend_refobjid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(extension_id)); scan = systable_beginscan(depRel, DependReferenceIndexId, true, NULL, 2, key); while (HeapTupleIsValid(tup = systable_getnext(scan))) { Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup); // Filter for those objects that have an extension dependencies // exist in pg_proc, those are the functions that live in the extension if (deprec->deptype == 'e' && deprec->classid == ProcedureRelationId) { AllowedFnHashEntry *entry = hash_search(allowed_fns, &deprec->objid, HASH_ENTER, NULL); entry->fn = deprec->objid; } } systable_endscan(scan); } table_close(depRel, AccessShareLock); return allowed_fns; } static fn_telemetry_entry_vec * read_shared_map() { HASH_SEQ_STATUS hash_seq; long i; long num_entries = hash_get_num_entries(function_counts); fn_telemetry_entry_vec *entries = fn_telemetry_entry_vec_create(CurrentMemoryContext, num_entries); LWLockAcquire(function_counts_lock, LW_SHARED); hash_seq_init(&hash_seq, function_counts); // limit to num_entries so we don't hold the lock for a realloc for (i = 0; i < num_entries; i++) { FnTelemetryEntry entry; FnTelemetryHashEntry *hash_entry = hash_seq_search(&hash_seq); if (!hash_entry) break; entry.fn = hash_entry->key; /* * We never remove entries here, merely set their counts to 0. At * steady-state we expect the functions used by most workloads to be * effectively constant, so by keeping the hashmap entries allocated we * reduce contention during the telemetry-gathering stage. If memory * usage become an issue we can delete based off some heuristic, eg. if * the count starts out as 0. */ entry.count = pg_atomic_read_u64(&hash_entry->count); if (entry.count != 0) fn_telemetry_entry_vec_append(entries, entry); } if (i == num_entries) hash_seq_term(&hash_seq); LWLockRelease(function_counts_lock); return entries; } /* * Read the function telemetry shared-memory hashmap for telemetry send. * * This function gathers (function_id, count) pairs from the shared hashmap, * and filters the set for the functions we're allowed to send back. * * In general, we should never send telemetry information about any functions * except for core functions and those is a specified list of extensions * (when originally written, the set of related_extensions along with * timescaledb itself), so this function is designed to make it difficult to do * so. * * @param visible_extensions list of extensions whose functions should be * returned * @param num_visible_extensions length of visible_extensions * @return vector of FnTelemetryEntry containing (function_id, count)s for the * functions in visible_extensions. * */ fn_telemetry_entry_vec * ts_function_telemetry_read(const char **visible_extensions, int num_visible_extensions) { fn_telemetry_entry_vec *entries_to_send; fn_telemetry_entry_vec *all_entries; HTAB *allowed_ext_fns; if (function_counts == NULL) { FnTelemetryRendezvous **rendezvous = (FnTelemetryRendezvous **) find_rendezvous_variable(RENDEZVOUS_FUNCTION_TELEMENTRY); if (*rendezvous == NULL) return NULL; function_counts = (*rendezvous)->function_counts; function_counts_lock = (*rendezvous)->lock; } all_entries = read_shared_map(); entries_to_send = fn_telemetry_entry_vec_create(CurrentMemoryContext, all_entries->num_elements); allowed_ext_fns = allowed_extension_functions(visible_extensions, num_visible_extensions); for (uint32 i = 0; i < all_entries->num_elements; i++) { FnTelemetryEntry *entry = fn_telemetry_entry_vec_at(all_entries, i); bool is_builtin = entry->fn >= 1 && entry->fn <= 9999; bool is_visible = is_builtin || hash_search(allowed_ext_fns, &entry->fn, HASH_FIND, NULL); if (is_visible) fn_telemetry_entry_vec_append(entries_to_send, *entry); } return entries_to_send; } /* * Reset the counts in the function telemetry shared-memory hashmap. * * This function resets the shared function counts after we send back telemetry * in preparation for the next recording cycle. Note that there is no way to * atomically read and reset the counts in the shared hashmap, so writes that * occur between sending the old counts and resetting for the next cycle will be * lost. Since this this telemetry is only ever an approximation of reality, we * believe this loss is acceptable considering that the alternatives are * resetting the counts whenever the telemetry is read (potentially even more * lossy), or holding the lock for the entire telemetry send (to long a * contention window). */ void ts_function_telemetry_reset_counts() { HASH_SEQ_STATUS hash_seq; if (!function_counts) return; LWLockAcquire(function_counts_lock, LW_SHARED); hash_seq_init(&hash_seq, function_counts); // limit to num_entries so we don't hold the lock for a realloc while (true) { FnTelemetryHashEntry *hash_entry = hash_seq_search(&hash_seq); if (!hash_entry) break; /* * We never remove entries here, merely set their counts to 0. At * steady-state we expect the functions used by most workloads to be * effectively constant, so by keeping the hashmap entries allocated we * reduce contention during the telemetry-gathering stage. If memory * usage become an issue we can delete based off some heuristic, eg. if * the count starts out as 0, though we will have to use a stronger * lock. */ pg_atomic_write_u64(&hash_entry->count, 0); } LWLockRelease(function_counts_lock); } /**************************** * Telemetry gathering code * ****************************/ static bool function_telemetry_increment(Oid func_id, HTAB **local_counts) { FnTelemetryEntry *entry; bool found; // if this is the first function we've seen initialize local_counts if (!*local_counts) { HASHCTL hash_info = { .keysize = sizeof(Oid), .entrysize = sizeof(FnTelemetryEntry), .hcxt = CurrentMemoryContext, }; *local_counts = hash_create("fn telemetry local function hash", 10, &hash_info, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); } entry = hash_search(*local_counts, &func_id, HASH_ENTER, &found); if (!found) entry->count = 0; entry->count += 1; return true; } static bool function_gather_checker(Oid func_id, void *context) { function_telemetry_increment(func_id, (HTAB **) context); return false; } static bool function_gather_walker(Node *node, void *context) { bool end_early; if (node == NULL) return false; end_early = check_functions_in_node(node, function_gather_checker, context); if (end_early) return true; if (IsA(node, Query)) { /* Recurse into subselects */ return query_tree_walker((Query *) node, function_gather_walker, context, 0); } return expression_tree_walker(node, function_gather_walker, context); } static HTAB * record_function_counts(Query *query) { HTAB *query_function_counts = NULL; query_tree_walker(query, function_gather_walker, (void *) &query_function_counts, 0); return query_function_counts; } /* * Store a map of (function_oid, count) into shared memory so it can be seen by * the telemetry worker. This insertion works in two phases: * 1. Under a SHARED lock, we increment the counts of all those functions that * are already present in the map, using atomic fetch-add to prevent races. * 2. Under an EXCLUSIVE lock, we insert entries for all those functions that * were not already in the map. * At steady state we expect that vast majority the time all the functions a * query uses will already be in the shared map, so this strategy should * minimize contention between queries. * * @param query_function_counts A hashtable of FnTelemetryEntry storing * function usage counts */ static void store_function_counts_in_shared_mem(HTAB *query_function_counts) { HASH_SEQ_STATUS hash_seq; FnTelemetryEntry *local_entry = NULL; fn_telemetry_entry_vec missing_entries; fn_telemetry_entry_vec_init(&missing_entries, CurrentMemoryContext, 0); /* * Increment the counts of any functions already in the table under a * shared lock; the atomicity of increments will handle concurrency. */ LWLockAcquire(function_counts_lock, LW_SHARED); hash_seq_init(&hash_seq, query_function_counts); while ((local_entry = hash_seq_search(&hash_seq))) { FnTelemetryHashEntry *shared_entry = hash_search(function_counts, &local_entry->fn, HASH_FIND, NULL); if (shared_entry) pg_atomic_fetch_add_u64(&shared_entry->count, local_entry->count); else fn_telemetry_entry_vec_append(&missing_entries, *local_entry); } LWLockRelease(function_counts_lock); /* * If any functions did not have an entries create them under an * exclusive lock */ if (missing_entries.num_elements > 0) { LWLockAcquire(function_counts_lock, LW_EXCLUSIVE); for (uint32 i = 0; i < missing_entries.num_elements; i++) { bool found = false; FnTelemetryEntry *missing_entry = fn_telemetry_entry_vec_at(&missing_entries, i); FnTelemetryHashEntry *shared_entry = hash_search(function_counts, &missing_entry->fn, HASH_ENTER_NULL, &found); if (!shared_entry) break; if (found) pg_atomic_fetch_add_u64(&shared_entry->count, missing_entry->count); else pg_atomic_init_u64(&shared_entry->count, missing_entry->count); } LWLockRelease(function_counts_lock); } } /* * Gather function usage telemetry for a query. * * This function walks a query looking for function Oids, counts their * occurrence, and stores the (function_id, count) set into the shared-memory * function telemetry hashtable for later processing by the telemetry background * worker. */ void ts_telemetry_function_info_gather(Query *query) { HTAB *query_function_counts; if (skip_telemetry || !ts_function_telemetry_on()) return; // At the first time through initialize the shared state if (function_counts == NULL) { FnTelemetryRendezvous **rendezvous = (FnTelemetryRendezvous **) find_rendezvous_variable(RENDEZVOUS_FUNCTION_TELEMENTRY); if (*rendezvous == NULL) { skip_telemetry = true; return; } function_counts = (*rendezvous)->function_counts; function_counts_lock = (*rendezvous)->lock; } query_function_counts = record_function_counts(query); if (query_function_counts) store_function_counts_in_shared_mem(query_function_counts); } ���timescaledb-2.23.0/src/telemetry/functions.h��������������������������������������������������������0000664�0000000�0000000�00000001337�15100345067�0021041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> typedef struct FnTelemetryEntry { Oid fn; uint64 count; } FnTelemetryEntry; #define VEC_PREFIX fn_telemetry_entry #define VEC_ELEMENT_TYPE FnTelemetryEntry #define VEC_DECLARE 1 #define VEC_DEFINE 1 #define VEC_SCOPE static inline #include <adts/vec.h> extern void ts_telemetry_function_info_gather(Query *query); extern fn_telemetry_entry_vec *ts_function_telemetry_read(const char **visible_extensions, int num_visible_extensions); extern void ts_function_telemetry_reset_counts(void); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/replication.c������������������������������������������������������0000664�0000000�0000000�00000003211�15100345067�0021326�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <executor/spi.h> #include <utils/guc.h> #include "replication.h" ReplicationInfo ts_telemetry_replication_info_gather(void) { int res; bool isnull; Datum data; ReplicationInfo info = { .got_num_wal_senders = false, .got_is_wal_receiver = false, }; if (SPI_connect() != SPI_OK_CONNECT) return info; /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); res = SPI_execute("SELECT cast(count(pid) as int) from pg_catalog.pg_stat_get_wal_senders() " "WHERE pid is not null", true, /* read_only */ 0 /*count*/ ); if (res >= 0) { data = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); info.num_wal_senders = DatumGetInt32(data); info.got_num_wal_senders = true; } /* use count() > 0 in case they start having pg_stat_get_wal_receiver() * return no rows when the DB isn't a replica */ res = SPI_execute("SELECT count(pid) > 0 from pg_catalog.pg_stat_get_wal_receiver() WHERE pid " "is not null", true, /* read_only */ 0 /*count*/ ); if (res >= 0) { data = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); info.is_wal_receiver = DatumGetBool(data); info.got_is_wal_receiver = true; } res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); return info; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/replication.h������������������������������������������������������0000664�0000000�0000000�00000000724�15100345067�0021341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "utils.h" typedef struct ReplicationInfo { bool got_num_wal_senders; int32 num_wal_senders; bool got_is_wal_receiver; bool is_wal_receiver; } ReplicationInfo; extern ReplicationInfo ts_telemetry_replication_info_gather(void); ��������������������������������������������timescaledb-2.23.0/src/telemetry/stats.c������������������������������������������������������������0000664�0000000�0000000�00000035113�15100345067�0020161�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/genam.h> #include <access/htup_details.h> #include <access/table.h> #include <access/tableam.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/pg_class.h> #include <catalog/pg_namespace.h> #include <fmgr.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include "chunk.h" #include "debug_point.h" #include "extension.h" #include "hypertable_cache.h" #include "stats.h" #include "ts_catalog/catalog.h" #include "ts_catalog/continuous_agg.h" #include "utils.h" typedef struct StatsContext { TelemetryStats *stats; Snapshot snapshot; } StatsContext; /* * Determine the type of a hypertable. */ static StatsRelType classify_hypertable(const Hypertable *ht) { if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) { /* * This is an internal compression table, but could be for a * regular hypertable, or for an internal materialized * hypertable (cagg). The latter case is currently not handled */ return RELTYPE_COMPRESSION_HYPERTABLE; } else { /* * Not dealing with an internal compression hypertable, but * could be a materialized hypertable (cagg). */ return RELTYPE_HYPERTABLE; } } static StatsRelType classify_chunk(Cache *htcache, const Hypertable **ht, const Chunk *chunk) { StatsRelType parent_reltype; Assert(NULL != chunk); /* Classify the chunk's parent */ *ht = ts_hypertable_cache_get_entry(htcache, chunk->hypertable_relid, CACHE_FLAG_MISSING_OK); Assert(NULL != *ht); parent_reltype = classify_hypertable(*ht); /* Classify the chunk's parent */ switch (parent_reltype) { case RELTYPE_HYPERTABLE: return RELTYPE_CHUNK; case RELTYPE_MATERIALIZED_HYPERTABLE: return RELTYPE_MATERIALIZED_CHUNK; case RELTYPE_COMPRESSION_HYPERTABLE: return RELTYPE_COMPRESSION_CHUNK; default: /* Shouldn't really get here */ return RELTYPE_OTHER; } } static StatsRelType classify_table(const Form_pg_class class, Cache *htcache, const Hypertable **ht, const Chunk **chunk) { Assert(class->relkind == RELKIND_RELATION); if (class->relispartition) return RELTYPE_PARTITION; /* Check if it is a hypertable */ *ht = ts_hypertable_cache_get_entry(htcache, class->oid, CACHE_FLAG_MISSING_OK); if (*ht) return classify_hypertable(*ht); /* Check if it is a chunk */ *chunk = ts_chunk_get_by_relid(class->oid, false); if (NULL != *chunk) return classify_chunk(htcache, ht, *chunk); return RELTYPE_TABLE; } static StatsRelType classify_partitioned_table(const Form_pg_class class) { Assert(class->relkind == RELKIND_PARTITIONED_TABLE); /* * If the partitioned table itself is a partition, then it is a partition * in a multi-dimensional partitioned table. Treat it as a partition so * that only "root" tables are counted as partitioned tables. */ if (class->relispartition) return RELTYPE_PARTITION; return RELTYPE_PARTITIONED_TABLE; } static StatsRelType classify_foreign_table(Cache *htcache, Oid relid, const Hypertable **ht, const Chunk **chunk) { *chunk = ts_chunk_get_by_relid(relid, false); if (*chunk) return classify_chunk(htcache, ht, *chunk); /* * Currently don't care about non-chunk foreign tables, so classify as * "other". */ return RELTYPE_OTHER; } static StatsRelType classify_view(const Form_pg_class class, Cache *htcache, const ContinuousAgg **cagg) { const Catalog *catalog = ts_catalog_get(); if (class->relnamespace == catalog->extension_schema_id[TS_INTERNAL_SCHEMA]) return RELTYPE_OTHER; *cagg = ts_continuous_agg_find_by_relid(class->oid); if (*cagg) return RELTYPE_CONTINUOUS_AGG; return RELTYPE_VIEW; } static StatsRelType classify_relation(const Form_pg_class class, Cache *htcache, const Hypertable **ht, const Chunk **chunk, const ContinuousAgg **cagg) { *chunk = NULL; *ht = NULL; *cagg = NULL; switch (class->relkind) { case RELKIND_RELATION: return classify_table(class, htcache, ht, chunk); case RELKIND_PARTITIONED_TABLE: return classify_partitioned_table(class); case RELKIND_FOREIGN_TABLE: return classify_foreign_table(htcache, class->oid, ht, chunk); case RELKIND_MATVIEW: return RELTYPE_MATVIEW; case RELKIND_VIEW: return classify_view(class, htcache, cagg); default: return RELTYPE_OTHER; } } static void add_storage(StorageStats *stats, Form_pg_class class) { RelationSize relsize; relsize = ts_relation_size_impl(class->oid); stats->relsize.total_size += relsize.total_size; stats->relsize.heap_size += relsize.heap_size; stats->relsize.toast_size += relsize.toast_size; stats->relsize.index_size += relsize.index_size; } static void process_relation(BaseStats *stats, Form_pg_class class) { stats->relcount++; /* * As of PG14, pg_class.reltuples is set to -1 when the row count is * unknown. Make sure we only add the count when the information is * available. */ if (class->reltuples > 0) stats->reltuples += class->reltuples; if (RELKIND_HAS_STORAGE(class->relkind)) add_storage((StorageStats *) stats, class); } static void process_hypertable(HyperStats *hyp, Form_pg_class class, const Hypertable *ht) { process_relation(&hyp->storage.base, class); if (TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) hyp->compressed_hypertable_count++; } static void process_continuous_agg(CaggStats *cs, Form_pg_class class, const ContinuousAgg *cagg) { const Hypertable *mat_ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); Assert(cagg); process_relation(&cs->hyp.storage.base, class); if (TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(mat_ht)) cs->hyp.compressed_hypertable_count++; if (!cagg->data.materialized_only) cs->uses_real_time_aggregation_count++; if (ContinuousAggIsFinalized(cagg)) cs->finalized++; if (cagg->data.parent_mat_hypertable_id != INVALID_HYPERTABLE_ID) cs->nested++; } static void process_partition(HyperStats *stats, Form_pg_class class, bool ischunk) { stats->child_count++; /* * Note that reltuples should be correct even for compressed chunks, since * we "freeze" those stats when a chunk is compressed, and for foreign * table chunks, since we import those stats from data nodes. * * Also, as of PG14, the parent tables include the cumulative stats for * all children, so no need to count the partitions separately since the * sum will be in the root. */ if (ischunk && class->reltuples > 0) { stats->storage.base.reltuples += class->reltuples; } add_storage(&stats->storage, class); } /* * Add a chunk's stats to the parent table. */ static void add_chunk_stats(HyperStats *stats, Form_pg_class class, const Chunk *chunk, const Form_compression_chunk_size fd_compr) { process_partition(stats, class, true); if (ts_chunk_is_compressed(chunk)) stats->compressed_chunk_count++; if (fd_compr) { stats->compressed_heap_size += fd_compr->compressed_heap_size; stats->compressed_indexes_size += fd_compr->compressed_index_size; stats->compressed_toast_size += fd_compr->compressed_toast_size; stats->uncompressed_heap_size += fd_compr->uncompressed_heap_size; stats->uncompressed_indexes_size += fd_compr->uncompressed_index_size; stats->uncompressed_toast_size += fd_compr->uncompressed_toast_size; stats->uncompressed_row_count += fd_compr->numrows_pre_compression; stats->compressed_row_count += fd_compr->numrows_post_compression; stats->compressed_row_frozen_immediately_count += fd_compr->numrows_frozen_immediately; /* Also add compressed sizes to total number for entire table */ stats->storage.relsize.heap_size += fd_compr->compressed_heap_size; stats->storage.relsize.toast_size += fd_compr->compressed_toast_size; stats->storage.relsize.index_size += fd_compr->compressed_index_size; } } static bool get_chunk_compression_stats(StatsContext *statsctx, const Chunk *chunk, Form_compression_chunk_size compr_stats) { TupleInfo *ti; ScanIterator it; bool found = false; if (!ts_chunk_is_compressed(chunk)) return false; it = ts_scan_iterator_create(COMPRESSION_CHUNK_SIZE, AccessShareLock, CurrentMemoryContext); ts_scan_iterator_set_index(&it, COMPRESSION_CHUNK_SIZE, COMPRESSION_CHUNK_SIZE_PKEY); it.ctx.snapshot = statsctx->snapshot; ts_scan_iterator_scan_key_reset(&it); ts_scan_iterator_scan_key_init(&it, Anum_compression_chunk_size_pkey_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk->fd.id)); ts_scan_iterator_start_or_restart_scan(&it); ti = ts_scan_iterator_next(&it); if (ti) { Form_compression_chunk_size fd; bool should_free; HeapTuple tuple = ts_scan_iterator_fetch_heap_tuple(&it, false, &should_free); fd = (Form_compression_chunk_size) GETSTRUCT(tuple); memcpy(compr_stats, fd, sizeof(*fd)); if (should_free) heap_freetuple(tuple); found = true; } ts_scan_iterator_close(&it); return found; } /* * Process a relation identified as being a chunk. * * The chunk could be part of a * * - Hypertable * - Distributed hypertable * - Distributed hypertable member * - Materialized hypertable (cagg) chunk * - Internal compression table for hypertable * - Internal compression table for materialized hypertable (cagg) * * Note that we want to count regular chunks and compressed chunks as part of * the same hypertable, although they are children of different tables * internally. The same applies to chunks that belong to a continuous * aggregate, although in that case there is actually a two-level indirection: * The main cagg view is the user-facing relation we'd like to collect stats * for, while its chunks are actually stored in a materialized hypertable, * and, in a second tier, in a compressed hypertable. */ static void process_chunk(StatsContext *statsctx, StatsRelType chunk_reltype, Form_pg_class class, const Chunk *chunk) { TelemetryStats *stats = statsctx->stats; FormData_compression_chunk_size comp_stats_data; Form_compression_chunk_size compr_stats = NULL; Assert(chunk); /* * Ignore compression chunks since we have a separate metadata table with * stats for them */ if (chunk_reltype == RELTYPE_COMPRESSION_CHUNK) return; if (get_chunk_compression_stats(statsctx, chunk, &comp_stats_data)) compr_stats = &comp_stats_data; switch (chunk_reltype) { case RELTYPE_CHUNK: add_chunk_stats(&stats->hypertables, class, chunk, compr_stats); break; case RELTYPE_MATERIALIZED_CHUNK: add_chunk_stats(&stats->continuous_aggs.hyp, class, chunk, compr_stats); break; default: pg_unreachable(); break; } } static bool is_pg_schema(Oid namespaceid) { static Oid information_schema_oid = InvalidOid; if (namespaceid == PG_CATALOG_NAMESPACE || namespaceid == PG_TOAST_NAMESPACE) return true; if (!OidIsValid(information_schema_oid)) information_schema_oid = get_namespace_oid("information_schema", false); return namespaceid == information_schema_oid; } static bool is_ts_schema(const Catalog *catalog, Oid namespaceid) { int i; for (i = 0; i < _TS_MAX_SCHEMA; i++) { if (namespaceid != catalog->extension_schema_id[TS_INTERNAL_SCHEMA] && namespaceid == catalog->extension_schema_id[i]) return true; } return false; } static bool should_ignore_relation(const Catalog *catalog, Form_pg_class class) { return (is_pg_schema(class->relnamespace) || isAnyTempNamespace(class->relnamespace) || is_ts_schema(catalog, class->relnamespace) || ts_is_catalog_table(class->oid)); } /* * Scan the entire pg_class catalog table for all relations. For each * relation, classify it and gather stats based on the classification. */ void ts_telemetry_stats_gather(TelemetryStats *stats) { const Catalog *catalog = ts_catalog_get(); Relation rel; SysScanDesc scan; Cache *htcache = ts_hypertable_cache_pin(); MemoryContext oldmcxt, relmcxt; StatsContext statsctx = { .stats = stats, .snapshot = GetActiveSnapshot(), }; MemSet(stats, 0, sizeof(*stats)); rel = table_open(RelationRelationId, AccessShareLock); scan = systable_beginscan(rel, ClassOidIndexId, false, NULL, 0, NULL); relmcxt = AllocSetContextCreate(CurrentMemoryContext, "RelationStats", ALLOCSET_DEFAULT_SIZES); while (true) { HeapTuple tup; Form_pg_class class; StatsRelType reltype; const Chunk *chunk = NULL; const Hypertable *ht = NULL; const ContinuousAgg *cagg = NULL; tup = systable_getnext(scan); if (!HeapTupleIsValid(tup)) break; class = (Form_pg_class) GETSTRUCT(tup); if (should_ignore_relation(catalog, class)) continue; /* Lock the relation to ensure it does not disappear while we process * it */ LockRelationOid(class->oid, AccessShareLock); /* Now that the lock is acquired, ensure the relation still * exists. Otherwise, ignore the relation and release the useless * lock. */ if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(class->oid))) { UnlockRelationOid(class->oid, AccessShareLock); continue; } /* * Use temporary per-relation memory context to not accumulate cruft * during processing of pg_class. */ oldmcxt = MemoryContextSwitchTo(relmcxt); MemoryContextReset(relmcxt); reltype = classify_relation(class, htcache, &ht, &chunk, &cagg); DEBUG_WAITPOINT("telemetry_classify_relation"); switch (reltype) { case RELTYPE_HYPERTABLE: Assert(NULL != ht); process_hypertable(&stats->hypertables, class, ht); break; case RELTYPE_TABLE: process_relation(&stats->tables.base, class); break; case RELTYPE_PARTITIONED_TABLE: process_relation(&stats->partitioned_tables.storage.base, class); break; case RELTYPE_CHUNK: case RELTYPE_COMPRESSION_CHUNK: case RELTYPE_MATERIALIZED_CHUNK: Assert(NULL != chunk); process_chunk(&statsctx, reltype, class, chunk); break; case RELTYPE_PARTITION: process_partition(&stats->partitioned_tables, class, false); break; case RELTYPE_VIEW: /* Filter internal cagg views */ if (class->relnamespace != catalog->extension_schema_id[TS_INTERNAL_SCHEMA]) process_relation(&stats->views, class); break; case RELTYPE_MATVIEW: process_relation(&stats->materialized_views.base, class); break; case RELTYPE_CONTINUOUS_AGG: Assert(NULL != cagg); process_continuous_agg(&stats->continuous_aggs, class, cagg); break; /* No stats collected for types below */ case RELTYPE_COMPRESSION_HYPERTABLE: case RELTYPE_MATERIALIZED_HYPERTABLE: case RELTYPE_OTHER: break; } UnlockRelationOid(class->oid, AccessShareLock); MemoryContextSwitchTo(oldmcxt); } systable_endscan(scan); table_close(rel, AccessShareLock); ts_cache_release(&htcache); MemoryContextDelete(relmcxt); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/stats.h������������������������������������������������������������0000664�0000000�0000000�00000004230�15100345067�0020162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "utils.h" typedef enum StatsRelType { RELTYPE_HYPERTABLE, RELTYPE_MATERIALIZED_HYPERTABLE, RELTYPE_COMPRESSION_HYPERTABLE, RELTYPE_CONTINUOUS_AGG, RELTYPE_TABLE, RELTYPE_PARTITIONED_TABLE, RELTYPE_PARTITION, RELTYPE_VIEW, RELTYPE_MATVIEW, RELTYPE_CHUNK, RELTYPE_COMPRESSION_CHUNK, RELTYPE_MATERIALIZED_CHUNK, RELTYPE_OTHER, } StatsRelType; typedef enum StatsType { STATS_TYPE_BASE, STATS_TYPE_STORAGE, STATS_TYPE_HYPER, STATS_TYPE_CAGG, } StatsType; typedef struct BaseStats { int64 relcount; int64 reltuples; } BaseStats; typedef struct StorageStats { BaseStats base; RelationSize relsize; } StorageStats; typedef struct HyperStats { StorageStats storage; int64 replicated_hypertable_count; int64 child_count; int64 replica_chunk_count; /* only includes "additional" replica chunks */ int64 compressed_chunk_count; int64 compressed_hypertable_count; int64 compressed_size; int64 compressed_heap_size; int64 compressed_indexes_size; int64 compressed_toast_size; int64 compressed_row_count; int64 compressed_row_frozen_immediately_count; int64 uncompressed_heap_size; int64 uncompressed_indexes_size; int64 uncompressed_toast_size; int64 uncompressed_row_count; } HyperStats; typedef struct CaggStats { HyperStats hyp; /* "hyper" as field name leads to name conflict on Windows compiler */ int64 uses_real_time_aggregation_count; int64 finalized; int64 nested; } CaggStats; typedef struct TelemetryStats { HyperStats hypertables; HyperStats partitioned_tables; StorageStats tables; StorageStats materialized_views; CaggStats continuous_aggs; BaseStats views; } TelemetryStats; typedef struct TelemetryJobStats { int64 total_runs; int64 total_successes; int64 total_failures; int64 total_crashes; int32 max_consecutive_failures; int32 max_consecutive_crashes; Interval *total_duration; Interval *total_duration_failures; } TelemetryJobStats; extern void ts_telemetry_stats_gather(TelemetryStats *stats); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/telemetry.c��������������������������������������������������������0000664�0000000�0000000�00000114131�15100345067�0021033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/pg_collation.h> #include <commands/extension.h> #include <fmgr.h> #include <miscadmin.h> #include <storage/ipc.h> #include <utils/builtins.h> #include <utils/json.h> #include <utils/jsonb.h> #include <utils/regproc.h> #include <utils/snapmgr.h> #include "compat/compat.h" #include "bgw_policy/policy.h" #include "config.h" #include "extension.h" #include "functions.h" #include "guc.h" #include "hypertable.h" #include "jsonb_utils.h" #include "license_guc.h" #include "net/http.h" #include "replication.h" #include "stats.h" #include "telemetry.h" #include "telemetry_metadata.h" #include "ts_catalog/compression_chunk_size.h" #include "ts_catalog/metadata.h" #include "version.h" #include "cross_module_fn.h" #include <executor/spi.h> #define TS_TELEMETRY_VERSION 2 #define TS_VERSION_JSON_FIELD "current_timescaledb_version" #define TS_IS_UPTODATE_JSON_FIELD "is_up_to_date" /* HTTP request details */ #define MAX_REQUEST_SIZE 4096 #define REQ_TELEMETRY_VERSION "telemetry_version" #define REQ_DB_UUID "db_uuid" #define REQ_EXPORTED_DB_UUID "exported_db_uuid" #define REQ_INSTALL_TIME "installed_time" #define REQ_INSTALL_METHOD "install_method" #define REQ_OS "os_name" #define REQ_OS_VERSION "os_version" #define REQ_OS_RELEASE "os_release" #define REQ_OS_VERSION_PRETTY "os_name_pretty" #define REQ_PS_VERSION "postgresql_version" #define REQ_TS_VERSION "timescaledb_version" #define REQ_BUILD_OS "build_os_name" #define REQ_BUILD_OS_VERSION "build_os_version" #define REQ_BUILD_ARCHITECTURE_BIT_SIZE "build_architecture_bit_size" #define REQ_BUILD_ARCHITECTURE "build_architecture" #define REQ_DATA_VOLUME "data_volume" #define REQ_NUM_POLICY_CAGG_FIXED "num_continuous_aggs_policies_fixed" #define REQ_NUM_POLICY_COMPRESSION_FIXED "num_compression_policies_fixed" #define REQ_NUM_POLICY_REORDER_FIXED "num_reorder_policies_fixed" #define REQ_NUM_POLICY_RETENTION_FIXED "num_retention_policies_fixed" #define REQ_NUM_USER_DEFINED_ACTIONS_FIXED "num_user_defined_actions_fixed" #define REQ_NUM_POLICY_CAGG "num_continuous_aggs_policies" #define REQ_NUM_POLICY_COMPRESSION "num_compression_policies" #define REQ_NUM_POLICY_REORDER "num_reorder_policies" #define REQ_NUM_POLICY_RETENTION "num_retention_policies" #define REQ_NUM_USER_DEFINED_ACTIONS "num_user_defined_actions" #define REQ_RELATED_EXTENSIONS "related_extensions" #define REQ_METADATA "db_metadata" #define REQ_TELEMETRY_EVENT "db_telemetry_events" #define REQ_LICENSE_EDITION_APACHE "apache_only" #define REQ_LICENSE_EDITION_COMMUNITY "community" #define REQ_TS_LAST_TUNE_TIME "last_tuned_time" #define REQ_TS_LAST_TUNE_VERSION "last_tuned_version" #define REQ_INSTANCE_METADATA "instance_metadata" #define REQ_TS_TELEMETRY_CLOUD "cloud" #define REQ_NUM_WAL_SENDERS "num_wal_senders" #define REQ_IS_WAL_RECEIVER "is_wal_receiver" #define PG_PROMETHEUS "pg_prometheus" #define PG_VECTOR "vector" #define TS_AI "ai" #define TS_VECTORSCALE "vectorscale" #define PROMSCALE "promscale" #define POSTGIS "postgis" #define TIMESCALE_ANALYTICS "timescale_analytics" #define TIMESCALEDB_TOOLKIT "timescaledb_toolkit" #define REQ_JOB_STATS_BY_JOB_TYPE "stats_by_job_type" #define REQ_NUM_ERR_BY_SQLERRCODE "errors_by_sqlerrcode" static const char *related_extensions[] = { PG_PROMETHEUS, PROMSCALE, POSTGIS, TIMESCALE_ANALYTICS, TIMESCALEDB_TOOLKIT, PG_VECTOR, TS_AI, TS_VECTORSCALE, }; /* This function counts background worker jobs by type. */ static BgwJobTypeCount bgw_job_type_counts() { ListCell *lc; List *jobs = ts_bgw_job_get_all(sizeof(BgwJob), CurrentMemoryContext); BgwJobTypeCount counts = { 0 }; foreach (lc, jobs) { BgwJob *job = lfirst(lc); if (namestrcmp(&job->fd.proc_schema, FUNCTIONS_SCHEMA_NAME) == 0) { if (namestrcmp(&job->fd.proc_name, "policy_refresh_continuous_aggregate") == 0) { if (job->fd.fixed_schedule) counts.policy_cagg_fixed++; else counts.policy_cagg++; } else if (namestrcmp(&job->fd.proc_name, "policy_compression") == 0) { if (job->fd.fixed_schedule) counts.policy_compression_fixed++; else counts.policy_compression++; } else if (namestrcmp(&job->fd.proc_name, "policy_reorder") == 0) { if (job->fd.fixed_schedule) counts.policy_reorder_fixed++; else counts.policy_reorder++; } else if (namestrcmp(&job->fd.proc_name, "policy_retention") == 0) { if (job->fd.fixed_schedule) counts.policy_retention_fixed++; else counts.policy_retention++; } else if (namestrcmp(&job->fd.proc_name, "policy_telemetry") == 0) counts.policy_telemetry++; } else { if (job->fd.fixed_schedule) counts.user_defined_action_fixed++; else counts.user_defined_action++; } } return counts; } static bool char_in_valid_version_digits(const char c) { switch (c) { case '.': case '-': return true; default: return false; } } /* * Makes sure the server version string is less than MAX_VERSION_STR_LEN * chars, and all digits are "valid". Valid chars are either * alphanumeric or in the array valid_version_digits above. * * Returns false if either of these conditions are false. */ bool ts_validate_server_version(const char *json, VersionResult *result) { Datum version = DirectFunctionCall2(json_object_field_text, CStringGetTextDatum(json), PointerGetDatum(cstring_to_text(TS_VERSION_JSON_FIELD))); memset(result, 0, sizeof(VersionResult)); result->versionstr = text_to_cstring(DatumGetTextPP(version)); if (result->versionstr == NULL) { result->errhint = "no version string in response"; return false; } if (strlen(result->versionstr) > MAX_VERSION_STR_LEN) { result->errhint = "version string is too long"; return false; } for (size_t i = 0; i < strlen(result->versionstr); i++) { if (!isalpha(result->versionstr[i]) && !isdigit(result->versionstr[i]) && !char_in_valid_version_digits(result->versionstr[i])) { result->errhint = "version string has invalid characters"; return false; } } return true; } /* * Parse the JSON response from the TS endpoint. There should be a field * called "current_timescaledb_version". Check this against the local * version, and notify the user if it is behind. */ void ts_check_version_response(const char *json) { VersionResult result; bool is_uptodate = DatumGetBool( DirectFunctionCall2Coll(texteq, C_COLLATION_OID, DirectFunctionCall2Coll(json_object_field_text, C_COLLATION_OID, CStringGetTextDatum(json), PointerGetDatum(cstring_to_text( TS_IS_UPTODATE_JSON_FIELD))), PointerGetDatum(cstring_to_text("true")))); if (is_uptodate) elog(NOTICE, "the \"%s\" extension is up-to-date", EXTENSION_NAME); else { if (!ts_validate_server_version(json, &result)) { elog(NOTICE, "server did not return a valid TimescaleDB version: %s", result.errhint); return; } ereport(LOG, (errmsg("the \"%s\" extension is not up-to-date", EXTENSION_NAME), errhint("The most up-to-date version is %s, the installed version is %s.", result.versionstr, TIMESCALEDB_VERSION_MOD))); } } static int32 get_architecture_bit_size() { return BUILD_POINTER_BYTES * 8; } static void add_job_counts(JsonbParseState *state) { BgwJobTypeCount counts = bgw_job_type_counts(); ts_jsonb_add_int32(state, REQ_NUM_POLICY_CAGG, counts.policy_cagg); ts_jsonb_add_int32(state, REQ_NUM_POLICY_CAGG_FIXED, counts.policy_cagg_fixed); ts_jsonb_add_int32(state, REQ_NUM_POLICY_COMPRESSION, counts.policy_compression); ts_jsonb_add_int32(state, REQ_NUM_POLICY_COMPRESSION_FIXED, counts.policy_compression_fixed); ts_jsonb_add_int32(state, REQ_NUM_POLICY_REORDER, counts.policy_reorder); ts_jsonb_add_int32(state, REQ_NUM_POLICY_REORDER_FIXED, counts.policy_reorder_fixed); ts_jsonb_add_int32(state, REQ_NUM_POLICY_RETENTION, counts.policy_retention); ts_jsonb_add_int32(state, REQ_NUM_POLICY_RETENTION_FIXED, counts.policy_retention_fixed); ts_jsonb_add_int32(state, REQ_NUM_USER_DEFINED_ACTIONS, counts.user_defined_action); ts_jsonb_add_int32(state, REQ_NUM_USER_DEFINED_ACTIONS_FIXED, counts.user_defined_action_fixed); } static JsonbValue * add_errors_by_sqlerrcode_internal(JsonbParseState *parse_state, const char *job_type, Jsonb *sqlerrs_jsonb) { JsonbIterator *it; JsonbIteratorToken type; JsonbValue val; JsonbValue *ret; JsonbValue key = { .type = jbvString, .val.string.val = pstrdup(job_type), .val.string.len = strlen(job_type), }; ret = pushJsonbValue(&parse_state, WJB_KEY, &key); ret = pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); /* we don't expect nested values here */ it = JsonbIteratorInit(&sqlerrs_jsonb->root); type = JsonbIteratorNext(&it, &val, true /*skip_nested*/); if (type != WJB_BEGIN_OBJECT) elog(ERROR, "invalid JSON format"); while ((type = JsonbIteratorNext(&it, &val, true))) { const char *errcode; int64 errcnt; if (type == WJB_END_OBJECT) break; else if (type == WJB_KEY) { errcode = pnstrdup(val.val.string.val, val.val.string.len); /* get the corresponding value for this key */ type = JsonbIteratorNext(&it, &val, true); if (type != WJB_VALUE) elog(ERROR, "unexpected jsonb type"); errcnt = DatumGetInt64(DirectFunctionCall1(numeric_int8, NumericGetDatum(val.val.numeric))); ts_jsonb_add_int64(parse_state, errcode, errcnt); } else elog(ERROR, "unexpected jsonb type"); } ret = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); return ret; } /* this function queries the database through SPI and gets back a set of records that look like (job_type TEXT, jsonb_object_agg JSONB). For example, (user_defined_action, {"P0001": 2, "42883": 5}) (we are expecting about 6 rows depending on how we write the query and if we exclude any jobs) Then for each returned row adds a new kv pair to the jsonb, which looks like "job_type": {"errtype1": errcnt1, ...} */ static void add_errors_by_sqlerrcode(JsonbParseState *parse_state) { int res; StringInfo command; MemoryContext orig_context = CurrentMemoryContext; const char *command_string = "SELECT " "job_type, jsonb_object_agg(sqlerrcode, count) " "FROM" "(" " SELECT (" " CASE " " WHEN proc_schema = \'_timescaledb_functions\'" " AND proc_name ~ " "\'^policy_(retention|compression|reorder|refresh_continuous_" "aggregate|telemetry|job_error_retention)$\' " " THEN proc_name " " ELSE \'user_defined_action\'" " END" " ) as job_type, " " sqlerrcode, " " pg_catalog.COUNT(*) " " FROM " " timescaledb_information.job_errors " " WHERE sqlerrcode IS NOT NULL " " GROUP BY job_type, sqlerrcode " " ORDER BY job_type" ") q " "GROUP BY q.job_type"; if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); command = makeStringInfo(); appendStringInfoString(command, command_string); res = SPI_execute(command->data, true /*read only*/, 0 /* count */); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not get errors by sqlerrcode and job type")))); /* we expect about 6 rows returned, each row is a record (TEXT, JSONB) */ for (uint64 i = 0; i < SPI_processed; i++) { Datum record_jobtype, record_jsonb; bool isnull_jobtype, isnull_jsonb; record_jobtype = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull_jobtype); if (isnull_jobtype) elog(ERROR, "null job type returned"); record_jsonb = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull_jsonb); /* this jsonb looks like {"P0001": 32, "42883": 6} */ Jsonb *sqlerrs_jsonb = isnull_jsonb ? NULL : DatumGetJsonbP(record_jsonb); if (sqlerrs_jsonb == NULL) continue; /* the jsonb object cannot be created in the SPI context or it will be lost */ MemoryContext spi_context = MemoryContextSwitchTo(orig_context); add_errors_by_sqlerrcode_internal(parse_state, TextDatumGetCString(record_jobtype), sqlerrs_jsonb); MemoryContextSwitchTo(spi_context); } /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); Assert(res == SPI_OK_FINISH); } static JsonbValue * add_job_stats_internal(JsonbParseState *state, const char *job_type, TelemetryJobStats *stats) { JsonbValue key = { .type = jbvString, .val.string.val = pstrdup(job_type), .val.string.len = strlen(job_type), }; pushJsonbValue(&state, WJB_KEY, &key); pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int64(state, "total_runs", stats->total_runs); ts_jsonb_add_int64(state, "total_successes", stats->total_successes); ts_jsonb_add_int64(state, "total_failures", stats->total_failures); ts_jsonb_add_int64(state, "total_crashes", stats->total_crashes); ts_jsonb_add_int32(state, "max_consecutive_failures", stats->max_consecutive_failures); ts_jsonb_add_int32(state, "max_consecutive_crashes", stats->max_consecutive_crashes); ts_jsonb_add_interval(state, "total_duration", stats->total_duration); ts_jsonb_add_interval(state, "total_duration_failures", stats->total_duration_failures); return pushJsonbValue(&state, WJB_END_OBJECT, NULL); } static void add_job_stats_by_job_type(JsonbParseState *parse_state) { StringInfo command; int res; MemoryContext orig_context = CurrentMemoryContext; SPITupleTable *tuptable = NULL; const char *command_string = "SELECT (" " CASE " " WHEN j.proc_schema = \'_timescaledb_functions\' AND j.proc_name ~ " "\'^policy_(retention|compression|reorder|refresh_continuous_aggregate|telemetry|job_stat_" "history_retention)$\' " " THEN j.proc_name::TEXT " " ELSE \'user_defined_action\' " " END" ") AS job_type, " " SUM(total_runs)::BIGINT AS total_runs, " " SUM(total_successes)::BIGINT AS total_successes, " " SUM(total_failures)::BIGINT AS total_failures, " " SUM(total_crashes)::BIGINT AS total_crashes, " " SUM(total_duration) AS total_duration, " " SUM(total_duration_failures) AS total_duration_failures, " " MAX(consecutive_failures) AS max_consecutive_failures, " " MAX(consecutive_crashes) AS max_consecutive_crashes " "FROM " " _timescaledb_internal.bgw_job_stat s " " JOIN _timescaledb_config.bgw_job j on j.id = s.job_id " "GROUP BY job_type " "ORDER BY job_type"; if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); command = makeStringInfo(); appendStringInfoString(command, command_string); res = SPI_execute(command->data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not get job statistics by job type")))); /* * a row returned looks like this: * (job_type, total_runs, total_successes, total_failures, total_crashes, total_duration, * total_duration_failures, max_consec_fails, max_consec_crashes) * ("policy_telemetry", 12, 10, 1, 1, 00:00:11, 00:00:01, 1, 1) */ for (uint64 i = 0; i < SPI_processed; i++) { tuptable = SPI_tuptable; TupleDesc tupdesc = tuptable->tupdesc; Datum jobtype_datum; Datum total_runs, total_successes, total_failures, total_crashes; Datum total_duration, total_duration_failures, max_consec_crashes, max_consec_fails; bool isnull_jobtype, isnull_runs, isnull_successes, isnull_failures, isnull_crashes; bool isnull_duration, isnull_duration_failures, isnull_consec_crashes, isnull_consec_fails; jobtype_datum = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull_jobtype); if (isnull_jobtype) elog(ERROR, "null job type returned"); total_runs = SPI_getbinval(tuptable->vals[i], tupdesc, 2, &isnull_runs); total_successes = SPI_getbinval(tuptable->vals[i], tupdesc, 3, &isnull_successes); total_failures = SPI_getbinval(tuptable->vals[i], tupdesc, 4, &isnull_failures); total_crashes = SPI_getbinval(tuptable->vals[i], tupdesc, 5, &isnull_crashes); total_duration = SPI_getbinval(tuptable->vals[i], tupdesc, 6, &isnull_duration); total_duration_failures = SPI_getbinval(tuptable->vals[i], tupdesc, 7, &isnull_duration_failures); max_consec_fails = SPI_getbinval(tuptable->vals[i], tupdesc, 8, &isnull_consec_fails); max_consec_crashes = SPI_getbinval(tuptable->vals[i], tupdesc, 9, &isnull_consec_crashes); if (isnull_jobtype || isnull_runs || isnull_successes || isnull_failures || isnull_crashes || isnull_duration || isnull_consec_crashes || isnull_consec_fails) { elog(ERROR, "null record field returned"); } MemoryContext spi_context = MemoryContextSwitchTo(orig_context); TelemetryJobStats stats = { .total_runs = DatumGetInt64(total_runs), .total_successes = DatumGetInt64(total_successes), .total_failures = DatumGetInt64(total_failures), .total_crashes = DatumGetInt64(total_crashes), .max_consecutive_failures = DatumGetInt32(max_consec_fails), .max_consecutive_crashes = DatumGetInt32(max_consec_crashes), .total_duration = DatumGetIntervalP(total_duration), .total_duration_failures = DatumGetIntervalP(total_duration_failures) }; add_job_stats_internal(parse_state, TextDatumGetCString(jobtype_datum), &stats); MemoryContextSwitchTo(spi_context); } /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); Assert(res == SPI_OK_FINISH); } static int64 get_database_size() { return DatumGetInt64(DirectFunctionCall1(pg_database_size_oid, ObjectIdGetDatum(MyDatabaseId))); } static void add_related_extensions(JsonbParseState *state) { pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL); for (size_t i = 0; i < sizeof(related_extensions) / sizeof(char *); i++) { const char *ext = related_extensions[i]; ts_jsonb_add_bool(state, ext, OidIsValid(get_extension_oid(ext, true))); } pushJsonbValue(&state, WJB_END_OBJECT, NULL); } static char * get_pgversion_string() { StringInfo buf = makeStringInfo(); int major, patch; /* * We have to read the server version from GUC and not use any of * the macros. By using any of the macros we would get the version * the extension is compiled against instead of the version actually * running. */ char *server_version_num_guc = GetConfigOptionByName("server_version_num", NULL, false); long server_version_num = strtol(server_version_num_guc, NULL, 10); major = server_version_num / 10000; patch = server_version_num % 100; Assert(major >= PG_MAJOR_MIN); appendStringInfo(buf, "%d.%d", major, patch); return buf->data; } #define ISO8601_FORMAT "YYYY-MM-DD\"T\"HH24:MI:SSOF" static char * format_iso8601(Datum value) { return TextDatumGetCString( DirectFunctionCall2(timestamptz_to_char, value, CStringGetTextDatum(ISO8601_FORMAT))); } #define REQ_RELKIND_COUNT "num_relations" #define REQ_RELKIND_RELTUPLES "num_reltuples" #define REQ_RELKIND_HEAP_SIZE "heap_size" #define REQ_RELKIND_TOAST_SIZE "toast_size" #define REQ_RELKIND_INDEXES_SIZE "indexes_size" #define REQ_RELKIND_CHILDREN "num_children" #define REQ_RELKIND_REPLICA_CHUNKS "num_replica_chunks" #define REQ_RELKIND_COMPRESSED_CHUNKS "num_compressed_chunks" #define REQ_RELKIND_COMPRESSED_HYPERTABLES "num_compressed_hypertables" #define REQ_RELKIND_COMPRESSED_CAGGS "num_compressed_caggs" #define REQ_RELKIND_UNCOMPRESSED_HEAP_SIZE "uncompressed_heap_size" #define REQ_RELKIND_UNCOMPRESSED_TOAST_SIZE "uncompressed_toast_size" #define REQ_RELKIND_UNCOMPRESSED_INDEXES_SIZE "uncompressed_indexes_size" #define REQ_RELKIND_UNCOMPRESSED_ROWCOUNT "uncompressed_row_count" #define REQ_RELKIND_COMPRESSED_HEAP_SIZE "compressed_heap_size" #define REQ_RELKIND_COMPRESSED_TOAST_SIZE "compressed_toast_size" #define REQ_RELKIND_COMPRESSED_INDEXES_SIZE "compressed_indexes_size" #define REQ_RELKIND_COMPRESSED_ROWCOUNT "compressed_row_count" #define REQ_RELKIND_COMPRESSED_ROWCOUNT_FROZEN_IMMEDIATELY "compressed_row_count_frozen_immediately" #define REQ_RELKIND_CAGG_USES_REAL_TIME_AGGREGATION_COUNT "num_caggs_using_real_time_aggregation" #define REQ_RELKIND_CAGG_FINALIZED "num_caggs_finalized" #define REQ_RELKIND_CAGG_NESTED "num_caggs_nested" static JsonbValue * add_compression_stats_object(JsonbParseState *parse_state, StatsRelType reltype, const HyperStats *hs) { JsonbValue name = { .type = jbvString, .val.string.val = pstrdup("compression"), .val.string.len = strlen("compression"), }; pushJsonbValue(&parse_state, WJB_KEY, &name); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_CHUNKS, hs->compressed_chunk_count); if (reltype == RELTYPE_CONTINUOUS_AGG) ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_CAGGS, hs->compressed_hypertable_count); else ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_HYPERTABLES, hs->compressed_hypertable_count); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_ROWCOUNT, hs->compressed_row_count); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_HEAP_SIZE, hs->compressed_heap_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_TOAST_SIZE, hs->compressed_toast_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_INDEXES_SIZE, hs->compressed_indexes_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COMPRESSED_ROWCOUNT_FROZEN_IMMEDIATELY, hs->compressed_row_frozen_immediately_count); ts_jsonb_add_int64(parse_state, REQ_RELKIND_UNCOMPRESSED_ROWCOUNT, hs->uncompressed_row_count); ts_jsonb_add_int64(parse_state, REQ_RELKIND_UNCOMPRESSED_HEAP_SIZE, hs->uncompressed_heap_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_UNCOMPRESSED_TOAST_SIZE, hs->uncompressed_toast_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_UNCOMPRESSED_INDEXES_SIZE, hs->uncompressed_indexes_size); return pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); } static JsonbValue * add_relkind_stats_object(JsonbParseState *parse_state, const char *relkindname, const BaseStats *stats, StatsRelType reltype, StatsType statstype) { JsonbValue name = { .type = jbvString, .val.string.val = pstrdup(relkindname), .val.string.len = strlen(relkindname), }; pushJsonbValue(&parse_state, WJB_KEY, &name); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int64(parse_state, REQ_RELKIND_COUNT, stats->relcount); if (statstype >= STATS_TYPE_STORAGE) { const StorageStats *ss = (const StorageStats *) stats; ts_jsonb_add_int64(parse_state, REQ_RELKIND_RELTUPLES, stats->reltuples); ts_jsonb_add_int64(parse_state, REQ_RELKIND_HEAP_SIZE, ss->relsize.heap_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_TOAST_SIZE, ss->relsize.toast_size); ts_jsonb_add_int64(parse_state, REQ_RELKIND_INDEXES_SIZE, ss->relsize.index_size); } if (statstype >= STATS_TYPE_HYPER) { const HyperStats *hs = (const HyperStats *) stats; ts_jsonb_add_int64(parse_state, REQ_RELKIND_CHILDREN, hs->child_count); if (reltype != RELTYPE_PARTITIONED_TABLE) add_compression_stats_object(parse_state, reltype, hs); } if (statstype == STATS_TYPE_CAGG) { const CaggStats *cs = (const CaggStats *) stats; ts_jsonb_add_int64(parse_state, REQ_RELKIND_CAGG_USES_REAL_TIME_AGGREGATION_COUNT, cs->uses_real_time_aggregation_count); ts_jsonb_add_int64(parse_state, REQ_RELKIND_CAGG_FINALIZED, cs->finalized); ts_jsonb_add_int64(parse_state, REQ_RELKIND_CAGG_NESTED, cs->nested); } return pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); } static void add_function_call_telemetry(JsonbParseState *state) { fn_telemetry_entry_vec *functions; const char *visible_extensions[(sizeof(related_extensions) / sizeof(char *)) + 1]; if (!ts_function_telemetry_on()) { JsonbValue value = { .type = jbvNull, }; pushJsonbValue(&state, WJB_VALUE, &value); return; } visible_extensions[0] = EXTENSION_NAME; for (size_t i = 1; i < sizeof(visible_extensions) / sizeof(char *); i++) visible_extensions[i] = related_extensions[i - 1]; functions = ts_function_telemetry_read(visible_extensions, sizeof(visible_extensions) / sizeof(char *)); pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL); if (functions) { for (uint32 i = 0; i < functions->num_elements; i++) { FnTelemetryEntry *entry = fn_telemetry_entry_vec_at(functions, i); char *proc_sig = format_procedure_qualified(entry->fn); ts_jsonb_add_int64(state, proc_sig, entry->count); } } pushJsonbValue(&state, WJB_END_OBJECT, NULL); } static void add_replication_telemetry(JsonbParseState *state) { ReplicationInfo info = ts_telemetry_replication_info_gather(); if (info.got_num_wal_senders) ts_jsonb_add_int32(state, REQ_NUM_WAL_SENDERS, info.num_wal_senders); if (info.got_is_wal_receiver) ts_jsonb_add_bool(state, REQ_IS_WAL_RECEIVER, info.is_wal_receiver); } #define REQ_RELS "relations" #define REQ_RELS_TABLES "tables" #define REQ_RELS_PARTITIONED_TABLES "partitioned_tables" #define REQ_RELS_MATVIEWS "materialized_views" #define REQ_RELS_VIEWS "views" #define REQ_RELS_HYPERTABLES "hypertables" #define REQ_RELS_CONTINUOUS_AGGS "continuous_aggregates" #define REQ_FUNCTIONS_USED "functions_used" #define REQ_REPLICATION "replication" #define REQ_ACCESS_METHODS "access_methods" /* * Add the result of a query as a sub-object to the JSONB. * * Each row from the query generates a separate object keyed by one of the * columns. Each row will be represented as an object and stored under the * "key" column. For example, with this query: * * select amname as name, * sum(relpages) as pages, * count(*) as instances * from pg_class join pg_am on relam = pg_am.oid * group by pg_am.oid; * * might generate the object * * { * "brin" : { * "instances" : 44, * "pages" : 432 * }, * "btree" : { * "instances" : 99, * "pages" : 1234 * } * } */ static void add_query_result_dict(JsonbParseState *state, const char *query) { MemoryContext orig_context = CurrentMemoryContext; int res; if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); res = SPI_execute(query, true, 0); Ensure(res >= 0, "could not execute query"); MemoryContext spi_context = MemoryContextSwitchTo(orig_context); (void) pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL); for (uint64 r = 0; r < SPI_processed; r++) { char *key_string = SPI_getvalue(SPI_tuptable->vals[r], SPI_tuptable->tupdesc, 1); JsonbValue key = { .type = jbvString, .val.string.val = pstrdup(key_string), .val.string.len = strlen(key_string), }; (void) pushJsonbValue(&state, WJB_KEY, &key); (void) pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL); for (int c = 1; c < SPI_tuptable->tupdesc->natts; ++c) { bool isnull; Datum val_datum = SPI_getbinval(SPI_tuptable->vals[r], SPI_tuptable->tupdesc, c + 1, &isnull); if (!isnull) { char *key_string = SPI_fname(SPI_tuptable->tupdesc, c + 1); JsonbValue value; ts_jsonb_set_value_by_type(&value, SPI_gettypeid(SPI_tuptable->tupdesc, c + 1), val_datum); ts_jsonb_add_value(state, key_string, &value); } } pushJsonbValue(&state, WJB_END_OBJECT, NULL); } /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); MemoryContextSwitchTo(spi_context); res = SPI_finish(); Assert(res == SPI_OK_FINISH); (void) pushJsonbValue(&state, WJB_END_OBJECT, NULL); } static Jsonb * build_telemetry_report() { JsonbParseState *parse_state = NULL; JsonbValue key; JsonbValue *result; TelemetryStats relstats; VersionOSInfo osinfo; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int32(parse_state, REQ_TELEMETRY_VERSION, TS_TELEMETRY_VERSION); ts_jsonb_add_str(parse_state, REQ_DB_UUID, DatumGetCString(DirectFunctionCall1(uuid_out, ts_metadata_get_uuid()))); ts_jsonb_add_str(parse_state, REQ_EXPORTED_DB_UUID, DatumGetCString( DirectFunctionCall1(uuid_out, ts_metadata_get_exported_uuid()))); ts_jsonb_add_str(parse_state, REQ_INSTALL_TIME, format_iso8601(ts_metadata_get_install_timestamp())); ts_jsonb_add_str(parse_state, REQ_INSTALL_METHOD, TIMESCALEDB_INSTALL_METHOD); if (ts_version_get_os_info(&osinfo)) { ts_jsonb_add_str(parse_state, REQ_OS, osinfo.sysname); ts_jsonb_add_str(parse_state, REQ_OS_VERSION, osinfo.version); ts_jsonb_add_str(parse_state, REQ_OS_RELEASE, osinfo.release); if (osinfo.has_pretty_version) ts_jsonb_add_str(parse_state, REQ_OS_VERSION_PRETTY, osinfo.pretty_version); } else ts_jsonb_add_str(parse_state, REQ_OS, "Unknown"); ts_jsonb_add_str(parse_state, REQ_PS_VERSION, get_pgversion_string()); ts_jsonb_add_str(parse_state, REQ_TS_VERSION, TIMESCALEDB_VERSION_MOD); ts_jsonb_add_str(parse_state, REQ_BUILD_OS, BUILD_OS_NAME); ts_jsonb_add_str(parse_state, REQ_BUILD_OS_VERSION, BUILD_OS_VERSION); ts_jsonb_add_str(parse_state, REQ_BUILD_ARCHITECTURE, BUILD_PROCESSOR); ts_jsonb_add_int32(parse_state, REQ_BUILD_ARCHITECTURE_BIT_SIZE, get_architecture_bit_size()); ts_jsonb_add_int64(parse_state, REQ_DATA_VOLUME, get_database_size()); /* add job execution stats */ key.type = jbvString; key.val.string.val = REQ_NUM_ERR_BY_SQLERRCODE; key.val.string.len = strlen(REQ_NUM_ERR_BY_SQLERRCODE); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); add_errors_by_sqlerrcode(parse_state); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); key.type = jbvString; key.val.string.val = REQ_JOB_STATS_BY_JOB_TYPE; key.val.string.len = strlen(REQ_JOB_STATS_BY_JOB_TYPE); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); add_job_stats_by_job_type(parse_state); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); /* Add relation stats */ ts_telemetry_stats_gather(&relstats); key.type = jbvString; key.val.string.val = REQ_RELS; key.val.string.len = strlen(REQ_RELS); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); add_relkind_stats_object(parse_state, REQ_RELS_TABLES, &relstats.tables.base, RELTYPE_TABLE, STATS_TYPE_STORAGE); add_relkind_stats_object(parse_state, REQ_RELS_PARTITIONED_TABLES, &relstats.partitioned_tables.storage.base, RELTYPE_PARTITIONED_TABLE, STATS_TYPE_HYPER); add_relkind_stats_object(parse_state, REQ_RELS_MATVIEWS, &relstats.materialized_views.base, RELTYPE_MATVIEW, STATS_TYPE_STORAGE); add_relkind_stats_object(parse_state, REQ_RELS_VIEWS, &relstats.views, RELTYPE_VIEW, STATS_TYPE_BASE); add_relkind_stats_object(parse_state, REQ_RELS_HYPERTABLES, &relstats.hypertables.storage.base, RELTYPE_HYPERTABLE, STATS_TYPE_HYPER); add_relkind_stats_object(parse_state, REQ_RELS_CONTINUOUS_AGGS, &relstats.continuous_aggs.hyp.storage.base, RELTYPE_CONTINUOUS_AGG, STATS_TYPE_CAGG); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); add_job_counts(parse_state); /* Add related extensions, which is a nested JSON */ key.type = jbvString; key.val.string.val = REQ_RELATED_EXTENSIONS; key.val.string.len = strlen(REQ_RELATED_EXTENSIONS); pushJsonbValue(&parse_state, WJB_KEY, &key); add_related_extensions(parse_state); /* license */ key.type = jbvString; key.val.string.val = REQ_LICENSE_INFO; key.val.string.len = strlen(REQ_LICENSE_INFO); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); if (ts_license_is_apache()) ts_jsonb_add_str(parse_state, REQ_LICENSE_EDITION, REQ_LICENSE_EDITION_APACHE); else ts_jsonb_add_str(parse_state, REQ_LICENSE_EDITION, REQ_LICENSE_EDITION_COMMUNITY); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); /* add tuned info, which is optional */ if (ts_last_tune_time != NULL) ts_jsonb_add_str(parse_state, REQ_TS_LAST_TUNE_TIME, ts_last_tune_time); if (ts_last_tune_version != NULL) ts_jsonb_add_str(parse_state, REQ_TS_LAST_TUNE_VERSION, ts_last_tune_version); /* add cloud to telemetry when set */ if (ts_telemetry_cloud != NULL) { key.type = jbvString; key.val.string.val = REQ_INSTANCE_METADATA; key.val.string.len = strlen(REQ_INSTANCE_METADATA); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_str(parse_state, REQ_TS_TELEMETRY_CLOUD, ts_telemetry_cloud); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); } /* Add additional content from metadata */ key.type = jbvString; key.val.string.val = REQ_METADATA; key.val.string.len = strlen(REQ_METADATA); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_telemetry_metadata_add_values(parse_state); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); /* Add telemetry events */ key.type = jbvString; key.val.string.val = REQ_TELEMETRY_EVENT; key.val.string.len = strlen(REQ_TELEMETRY_EVENT); pushJsonbValue(&parse_state, WJB_KEY, &key); ts_telemetry_events_add(parse_state); /* Add function call telemetry */ key.type = jbvString; key.val.string.val = REQ_FUNCTIONS_USED; key.val.string.len = strlen(REQ_FUNCTIONS_USED); pushJsonbValue(&parse_state, WJB_KEY, &key); add_function_call_telemetry(parse_state); /* Add replication object */ key.type = jbvString; key.val.string.val = REQ_REPLICATION; key.val.string.len = strlen(REQ_REPLICATION); pushJsonbValue(&parse_state, WJB_KEY, &key); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); add_replication_telemetry(parse_state); pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); key.type = jbvString; key.val.string.val = REQ_ACCESS_METHODS; key.val.string.len = strlen(REQ_ACCESS_METHODS); (void) pushJsonbValue(&parse_state, WJB_KEY, &key); add_query_result_dict(parse_state, "SELECT amname AS name, sum(relpages) AS pages, count(*) AS " "instances FROM pg_class JOIN pg_am ON relam = pg_am.oid " "GROUP BY amname"); /* end of telemetry object */ result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); return JsonbValueToJsonb(result); } HttpRequest * ts_build_version_request(const char *host, const char *path) { HttpRequest *req; Jsonb *json = build_telemetry_report(); /* Fill in HTTP request */ req = ts_http_request_create(HTTP_POST); ts_http_request_set_uri(req, path); ts_http_request_set_version(req, HTTP_VERSION_10); ts_http_request_set_header(req, HTTP_HOST, host); ts_http_request_set_body_jsonb(req, json); return req; } static ConnectionType connection_type(const char *service) { if (strcmp("http", service) == 0) return CONNECTION_PLAIN; else if (strcmp("https", service) == 0) return CONNECTION_SSL; ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("scheme \"%s\" not supported for telemetry", service))); return _CONNECTION_MAX; } Connection * ts_telemetry_connect(const char *host, const char *service) { Connection *conn = ts_connection_create(connection_type(service)); if (conn) { int ret = ts_connection_connect(conn, host, service, 0); if (ret < 0) { const char *errstr = ts_connection_get_and_clear_error(conn); ts_connection_destroy(conn); conn = NULL; ereport(NOTICE, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("telemetry could not connect to \"%s\"", host), errdetail("%s", errstr))); } } return conn; } bool ts_telemetry_main_wrapper() { return ts_telemetry_main(TELEMETRY_HOST, TELEMETRY_PATH, TELEMETRY_SCHEME); } bool ts_telemetry_main(const char *host, const char *path, const char *service) { HttpError err; Connection *conn; HttpRequest *req; HttpResponseState *rsp; /* Declared volatile to suppress the incorrect -Wclobbered warning. */ volatile bool started = false; bool snapshot_set = false; const char *volatile json = NULL; if (!ts_telemetry_on()) return false; if (!IsTransactionOrTransactionBlock()) { started = true; StartTransactionCommand(); } conn = ts_telemetry_connect(host, service); if (conn == NULL) goto cleanup; if (!ActiveSnapshotSet()) { /* Need a valid snapshot to build telemetry information */ PushActiveSnapshot(GetTransactionSnapshot()); snapshot_set = true; } req = ts_build_version_request(host, path); if (snapshot_set) PopActiveSnapshot(); rsp = ts_http_response_state_create(); err = ts_http_send_and_recv(conn, req, rsp); ts_http_request_destroy(req); ts_connection_destroy(conn); if (err != HTTP_ERROR_NONE) { elog(NOTICE, "telemetry error: %s", ts_http_strerror(err)); goto cleanup; } if (!ts_http_response_state_valid_status(rsp)) { elog(NOTICE, "telemetry got unexpected HTTP response status: %d", ts_http_response_state_status_code(rsp)); goto cleanup; } ts_function_telemetry_reset_counts(); ts_telemetry_event_truncate(); /* * Do the version-check. Response is the body of a well-formed HTTP * response, since otherwise the previous line will throw an error. */ PG_TRY(); { json = ts_http_response_state_body_start(rsp); ts_check_version_response(json); } PG_CATCH(); { /* If the response is malformed, ts_check_version_response() will * throw an error, so we capture the error here and print debugging * information. */ FlushErrorState(); ereport(NOTICE, (errcode(ERRCODE_DATA_EXCEPTION), errmsg("malformed telemetry response body"), errdetail("host=%s, service=%s, path=%s: %s", host, service, path, json ? json : "<EMPTY>"))); /* Do not throw an error in this case, there is really nothing wrong with the system. It's only telemetry that is having problems, so we just wrap this up and exit. */ if (started) AbortCurrentTransaction(); return false; } PG_END_TRY(); ts_http_response_state_destroy(rsp); if (started) CommitTransactionCommand(); return true; cleanup: if (started) AbortCurrentTransaction(); return false; } TS_FUNCTION_INFO_V1(ts_telemetry_get_report_jsonb); Datum ts_telemetry_get_report_jsonb(PG_FUNCTION_ARGS) { Jsonb *jb = build_telemetry_report(); ts_function_telemetry_reset_counts(); PG_RETURN_JSONB_P(jb); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/telemetry.h��������������������������������������������������������0000664�0000000�0000000�00000003322�15100345067�0021037�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <utils/builtins.h> #include "compat/compat.h" #include "net/conn.h" #include "net/http.h" #include "utils.h" #include "version.h" #define REQ_LICENSE_INFO "license" #define REQ_LICENSE_EDITION "edition" #define TELEMETRY_SCHEME "https" #define TELEMETRY_HOST "telemetry.timescale.com" #define TELEMETRY_PATH "/v1/metrics" #define MAX_VERSION_STR_LEN 128 typedef struct BgwJobTypeCount { int32 policy_cagg; int32 policy_cagg_fixed; int32 policy_compression; int32 policy_compression_fixed; int32 policy_reorder; int32 policy_reorder_fixed; int32 policy_retention; int32 policy_retention_fixed; int32 policy_telemetry; int32 user_defined_action; int32 user_defined_action_fixed; } BgwJobTypeCount; typedef struct VersionResult { const char *versionstr; const char *errhint; } VersionResult; extern HttpRequest *ts_build_version_request(const char *host, const char *path); extern Connection *ts_telemetry_connect(const char *host, const char *service); extern bool ts_validate_server_version(const char *json, VersionResult *result); extern void ts_check_version_response(const char *json); /* * This function is intended as the main function for a BGW. * Its job is to send metrics and fetch the most up-to-date version of * Timescale via HTTPS. */ extern bool ts_telemetry_main(const char *host, const char *path, const char *service); extern TSDLLEXPORT bool ts_telemetry_main_wrapper(void); extern TSDLLEXPORT Datum ts_telemetry_get_report_jsonb(PG_FUNCTION_ARGS); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/telemetry_metadata.c�����������������������������������������������0000664�0000000�0000000�00000006521�15100345067�0022676�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <commands/tablecmds.h> #include <utils/builtins.h> #include <utils/jsonb.h> #include <utils/timestamp.h> #include "jsonb_utils.h" #include "scan_iterator.h" #include "telemetry/telemetry_metadata.h" #include "ts_catalog/catalog.h" #include "ts_catalog/metadata.h" #include "uuid.h" void ts_telemetry_event_truncate(void) { RangeVar rv = { .schemaname = CATALOG_SCHEMA_NAME, .relname = TELEMETRY_EVENT_TABLE_NAME, }; ExecuteTruncate(&(TruncateStmt){ .type = T_TruncateStmt, .relations = list_make1(&rv), .behavior = DROP_RESTRICT, }); } void ts_telemetry_events_add(JsonbParseState *state) { ScanIterator iterator = ts_scan_iterator_create(TELEMETRY_EVENT, AccessShareLock, CurrentMemoryContext); pushJsonbValue(&state, WJB_BEGIN_ARRAY, NULL); ts_scanner_foreach(&iterator) { TupleInfo *ti = iterator.tinfo; TupleDesc tupdesc = ti->slot->tts_tupleDescriptor; bool created_isnull, tag_isnull, value_isnull; Datum created = slot_getattr(ti->slot, Anum_telemetry_event_created, &created_isnull); Datum tag = slot_getattr(ti->slot, Anum_telemetry_event_tag, &tag_isnull); Datum body = slot_getattr(ti->slot, Anum_telemetry_event_body, &value_isnull); pushJsonbValue(&state, WJB_BEGIN_OBJECT, NULL); if (!created_isnull) ts_jsonb_add_str(state, NameStr( TupleDescAttr(tupdesc, Anum_telemetry_event_created - 1)->attname), DatumGetCString(DirectFunctionCall1(timestamptz_out, created))); if (!tag_isnull) ts_jsonb_add_str(state, NameStr(TupleDescAttr(tupdesc, Anum_telemetry_event_tag - 1)->attname), pstrdup(NameStr(*DatumGetName(tag)))); if (!value_isnull) { JsonbValue jsonb_value; JsonbToJsonbValue(DatumGetJsonbPCopy(body), &jsonb_value); ts_jsonb_add_value(state, NameStr( TupleDescAttr(tupdesc, Anum_telemetry_event_body - 1)->attname), &jsonb_value); } pushJsonbValue(&state, WJB_END_OBJECT, NULL); } pushJsonbValue(&state, WJB_END_ARRAY, NULL); } /* * add all entries from _timescaledb_catalog.metadata */ void ts_telemetry_metadata_add_values(JsonbParseState *state) { Datum key, value; bool key_isnull, value_isnull, include_entry; ScanIterator iterator = ts_scan_iterator_create(METADATA, AccessShareLock, CurrentMemoryContext); iterator.ctx.index = catalog_get_index(ts_catalog_get(), METADATA, METADATA_PKEY_IDX); ts_scanner_foreach(&iterator) { TupleInfo *ti = iterator.tinfo; key = slot_getattr(ti->slot, Anum_metadata_key, &key_isnull); include_entry = !key_isnull && DatumGetBool(slot_getattr(ti->slot, Anum_metadata_include_in_telemetry, &key_isnull)); if (include_entry) { Name key_name = DatumGetName(key); /* skip keys included as toplevel items */ if (namestrcmp(key_name, METADATA_UUID_KEY_NAME) != 0 && namestrcmp(key_name, METADATA_EXPORTED_UUID_KEY_NAME) != 0 && namestrcmp(key_name, METADATA_TIMESTAMP_KEY_NAME) != 0) { value = slot_getattr(ti->slot, Anum_metadata_value, &value_isnull); if (!value_isnull) ts_jsonb_add_str(state, pstrdup(NameStr(*key_name)), pstrdup(TextDatumGetCString(value))); } } } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/telemetry/telemetry_metadata.h�����������������������������������������������0000664�0000000�0000000�00000000702�15100345067�0022676�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/jsonb.h> #include <export.h> extern void ts_telemetry_metadata_add_values(JsonbParseState *state); extern void ts_telemetry_events_add(JsonbParseState *state); extern void ts_telemetry_event_truncate(void); ��������������������������������������������������������������timescaledb-2.23.0/src/time_bucket.c����������������������������������������������������������������0000664�0000000�0000000�00000063015�15100345067�0017306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/datetime.h> #include <utils/fmgrprotos.h> #include <utils/timestamp.h> #include "time_bucket.h" #include "utils.h" #define TIME_BUCKET(period, timestamp, offset, min, max, result) \ do \ { \ if ((period) <= 0) \ ereport(ERROR, \ (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \ errmsg("period must be greater than 0"))); \ if ((offset) != 0) \ { \ /* We need to ensure that the timestamp is in range _after_ the */ \ /* offset is applied: when the offset is positive we need to make */ \ /* sure the resultant time is at least min, and when negative that */ \ /* it is less than the max. */ \ (offset) = (offset) % (period); \ if (((offset) > 0 && (timestamp) < (min) + (offset)) || \ ((offset) < 0 && (timestamp) > (max) + (offset))) \ ereport(ERROR, \ (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), \ errmsg("timestamp out of range"))); \ (timestamp) -= (offset); \ } \ (result) = ((timestamp) / (period)) * (period); \ if ((timestamp) < 0 && (timestamp) % (period)) \ { \ if ((result) < (min) + (period)) \ ereport(ERROR, \ (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), \ errmsg("timestamp out of range"))); \ else \ (result) = (result) - (period); \ } \ (result) += (offset); \ } while (0) TS_FUNCTION_INFO_V1(ts_int16_bucket); TSDLLEXPORT Datum ts_int16_bucket(PG_FUNCTION_ARGS) { int16 result; int16 period = PG_GETARG_INT16(0); int16 timestamp = PG_GETARG_INT16(1); int16 offset = PG_NARGS() > 2 ? PG_GETARG_INT16(2) : 0; TIME_BUCKET(period, timestamp, offset, PG_INT16_MIN, PG_INT16_MAX, result); PG_RETURN_INT16(result); } TS_FUNCTION_INFO_V1(ts_int32_bucket); TSDLLEXPORT Datum ts_int32_bucket(PG_FUNCTION_ARGS) { int32 result; int32 period = PG_GETARG_INT32(0); int32 timestamp = PG_GETARG_INT32(1); int32 offset = PG_NARGS() > 2 ? PG_GETARG_INT32(2) : 0; TIME_BUCKET(period, timestamp, offset, PG_INT32_MIN, PG_INT32_MAX, result); PG_RETURN_INT32(result); } TS_FUNCTION_INFO_V1(ts_int64_bucket); TSDLLEXPORT Datum ts_int64_bucket(PG_FUNCTION_ARGS) { int64 result; int64 period = PG_GETARG_INT64(0); int64 timestamp = PG_GETARG_INT64(1); int64 offset = PG_NARGS() > 2 ? PG_GETARG_INT64(2) : 0; TIME_BUCKET(period, timestamp, offset, PG_INT64_MIN, PG_INT64_MAX, result); PG_RETURN_INT64(result); } #define JAN_3_2000 (2 * USECS_PER_DAY) /* * The default origin is Monday 2000-01-03. We don't use PG epoch since it starts on a saturday. * This makes time-buckets by a week more intuitive and aligns it with date_trunc. Since month * bucketing ignores the day component this makes origin for month buckets 2000-01-01. */ #define DEFAULT_ORIGIN (JAN_3_2000) #define TIME_BUCKET_TS(period, timestamp, result, shift) \ do \ { \ if ((period) <= 0) \ ereport(ERROR, \ (errcode(ERRCODE_INVALID_PARAMETER_VALUE), \ errmsg("period must be greater than 0"))); \ /* shift = shift % period, but use TMODULO */ \ TMODULO(shift, result, period); \ \ if (((shift) > 0 && (timestamp) < DT_NOBEGIN + (shift)) || \ ((shift) < 0 && (timestamp) > DT_NOEND + (shift))) \ ereport(ERROR, \ (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), \ errmsg("timestamp out of range"))); \ (timestamp) -= (shift); \ \ /* result = (timestamp / period) * period */ \ TMODULO(timestamp, result, period); \ if ((timestamp) < 0) \ { \ /* \ * need to subtract another period if remainder < 0 this only happens \ * if timestamp is negative to begin with and there is a remainder \ * after division. Need to subtract another period since division \ * truncates toward 0 in C99. \ */ \ (result) = ((result) * (period)) - (period); \ } \ else \ (result) *= (period); \ \ (result) += (shift); \ } while (0) static void validate_month_bucket(Interval *interval) { /* * Bucketing by a month and non-month cannot be mixed. */ Assert(interval->month); if (interval->day || interval->time) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("month intervals cannot have day or time component"))); } } /* * To bucket by month we get the year and month of a date and convert * that to the nth month since origin. This allows us to treat month * bucketing similar to int bucketing. During this process we ignore * the day component and therefore only support bucketing by full months. */ static DateADT bucket_month(int32 period, DateADT date, DateADT origin) { int32 year, month, day; int32 result; j2date(date + POSTGRES_EPOCH_JDATE, &year, &month, &day); int32 timestamp = (year * 12) + month - 1; j2date(origin + POSTGRES_EPOCH_JDATE, &year, &month, &day); int32 offset = (year * 12) + month - 1; TIME_BUCKET(period, timestamp, offset, PG_INT32_MIN, PG_INT32_MAX, result); year = result / 12; month = result % 12; day = 1; return date2j(year, month + 1, day) - POSTGRES_EPOCH_JDATE; } /* Returns the period in the same representation as Postgres Timestamps. * Note that this is not our internal representation (microseconds). * Always returns an exact value.*/ static inline int64 get_interval_period_timestamp_units(Interval *interval) { if (interval->month != 0) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("interval defined in terms of month, year, century etc. not supported"))); } return interval->time + (interval->day * USECS_PER_DAY); } TS_FUNCTION_INFO_V1(ts_timestamp_bucket); TSDLLEXPORT Datum ts_timestamp_bucket(PG_FUNCTION_ARGS) { Interval *interval = PG_GETARG_INTERVAL_P(0); Timestamp timestamp = PG_GETARG_TIMESTAMP(1); /* * USE NARGS and not IS_NULL to differentiate a NULL argument from a call * with 2 parameters */ Timestamp origin = (PG_NARGS() > 2 ? PG_GETARG_TIMESTAMP(2) : DEFAULT_ORIGIN); Timestamp result; if (TIMESTAMP_NOT_FINITE(timestamp)) PG_RETURN_TIMESTAMP(timestamp); if (interval->month) { DateADT origin_date = 0; validate_month_bucket(interval); DateADT date = DatumGetDateADT(DirectFunctionCall1(timestamp_date, PG_GETARG_DATUM(1))); if (origin != DEFAULT_ORIGIN) origin_date = DatumGetDateADT(DirectFunctionCall1(timestamp_date, TimestampGetDatum(origin))); date = bucket_month(interval->month, date, origin_date); PG_RETURN_DATUM(DirectFunctionCall1(date_timestamp, DateADTGetDatum(date))); } else { int64 period = get_interval_period_timestamp_units(interval); TIME_BUCKET_TS(period, timestamp, result, origin); PG_RETURN_TIMESTAMP(result); } } TS_FUNCTION_INFO_V1(ts_timestamp_offset_bucket); TSDLLEXPORT Datum ts_timestamp_offset_bucket(PG_FUNCTION_ARGS) { Datum period = PG_GETARG_DATUM(0); Datum timestamp = PG_GETARG_DATUM(1); if (TIMESTAMP_NOT_FINITE(DatumGetTimestamp(timestamp))) PG_RETURN_DATUM(timestamp); /* Apply offset. */ timestamp = DirectFunctionCall2(timestamp_mi_interval, timestamp, PG_GETARG_DATUM(2)); timestamp = DirectFunctionCall2(ts_timestamp_bucket, period, timestamp); /* Remove offset. */ timestamp = DirectFunctionCall2(timestamp_pl_interval, timestamp, PG_GETARG_DATUM(2)); PG_RETURN_DATUM(timestamp); } TS_FUNCTION_INFO_V1(ts_timestamptz_bucket); TSDLLEXPORT Datum ts_timestamptz_bucket(PG_FUNCTION_ARGS) { Interval *interval = PG_GETARG_INTERVAL_P(0); TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1); /* * USE NARGS and not IS_NULL to differentiate a NULL argument from a call * with 2 parameters */ TimestampTz origin = (PG_NARGS() > 2 ? PG_GETARG_TIMESTAMPTZ(2) : DEFAULT_ORIGIN); TimestampTz result; if (TIMESTAMP_NOT_FINITE(timestamp)) PG_RETURN_TIMESTAMPTZ(timestamp); if (interval->month) { DateADT origin_date = 0; validate_month_bucket(interval); DateADT date = DatumGetDateADT(DirectFunctionCall1(timestamp_date, PG_GETARG_DATUM(1))); if (origin != DEFAULT_ORIGIN) origin_date = DatumGetDateADT(DirectFunctionCall1(timestamp_date, TimestampTzGetDatum(origin))); date = bucket_month(interval->month, date, origin_date); PG_RETURN_DATUM(DirectFunctionCall1(date_timestamp, DateADTGetDatum(date))); } else { int64 period = get_interval_period_timestamp_units(interval); TIME_BUCKET_TS(period, timestamp, result, origin); PG_RETURN_TIMESTAMPTZ(result); } } TS_FUNCTION_INFO_V1(ts_timestamptz_offset_bucket); TSDLLEXPORT Datum ts_timestamptz_offset_bucket(PG_FUNCTION_ARGS) { Datum period = PG_GETARG_DATUM(0); Datum timestamp = PG_GETARG_DATUM(1); if (TIMESTAMP_NOT_FINITE(DatumGetTimestampTz(timestamp))) PG_RETURN_DATUM(timestamp); /* Apply offset. */ timestamp = DirectFunctionCall2(timestamptz_mi_interval, timestamp, PG_GETARG_DATUM(2)); timestamp = DirectFunctionCall2(ts_timestamptz_bucket, period, timestamp); /* Remove offset. */ timestamp = DirectFunctionCall2(timestamptz_pl_interval, timestamp, PG_GETARG_DATUM(2)); PG_RETURN_DATUM(timestamp); } TS_FUNCTION_INFO_V1(ts_timestamptz_timezone_bucket); /* * time_bucket(bucket_width INTERVAL, ts TIMESTAMPTZ, timezone TEXT, origin TIMESTAMPTZ DEFAULT * NULL, "offset" INTERVAL DEFAULT NULL) RETURNS TIMESTAMPTZ */ TSDLLEXPORT Datum ts_timestamptz_timezone_bucket(PG_FUNCTION_ARGS) { Datum period = PG_GETARG_DATUM(0); Datum timestamp = PG_GETARG_DATUM(1); Datum tzname = PG_GETARG_DATUM(2); /* * When called from SQL we will always have 5 args because default values * will be filled in for missing arguments. When called from C with * DirectFunctionCall number of arguments might be less than 5. */ bool have_origin = PG_NARGS() > 3 && !PG_ARGISNULL(3); bool have_offset = PG_NARGS() > 4 && !PG_ARGISNULL(4); /* * We need to check for NULL arguments here because the function cannot be * defined STRICT due to the optional arguments. */ if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); /* Convert to local timestamp according to timezone */ timestamp = DirectFunctionCall2(timestamptz_zone, tzname, timestamp); if (have_offset) { /* Apply offset. */ timestamp = DirectFunctionCall2(timestamp_mi_interval, timestamp, PG_GETARG_DATUM(4)); } if (have_origin) { Datum origin = DirectFunctionCall2(timestamptz_zone, tzname, PG_GETARG_DATUM(3)); timestamp = DirectFunctionCall3(ts_timestamp_bucket, period, timestamp, origin); } else { timestamp = DirectFunctionCall2(ts_timestamp_bucket, period, timestamp); } if (have_offset) { /* Remove offset. */ timestamp = DirectFunctionCall2(timestamp_pl_interval, timestamp, PG_GETARG_DATUM(4)); } /* Convert back to timezone */ timestamp = DirectFunctionCall2(timestamp_zone, tzname, timestamp); PG_RETURN_DATUM(timestamp); } static inline void check_period_is_daily(int64 period) { int64 day = USECS_PER_DAY; if (period < day) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("interval must not have sub-day precision"))); } if (period % day != 0) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("interval must be a multiple of a day"))); } } TS_FUNCTION_INFO_V1(ts_date_bucket); TSDLLEXPORT Datum ts_date_bucket(PG_FUNCTION_ARGS) { Interval *interval = PG_GETARG_INTERVAL_P(0); DateADT date = PG_GETARG_DATEADT(1); DateADT origin = 0; Timestamp origin_ts = DEFAULT_ORIGIN; Timestamp timestamp, result; if (DATE_NOT_FINITE(date)) PG_RETURN_DATEADT(date); /* convert to timestamp (NOT tz), bucket, convert back to date */ timestamp = DatumGetTimestamp(DirectFunctionCall1(date_timestamp, PG_GETARG_DATUM(1))); Assert(!TIMESTAMP_NOT_FINITE(timestamp)); if (PG_NARGS() > 2) { origin = PG_GETARG_DATEADT(2); if (!interval->month) origin_ts = DatumGetTimestamp(DirectFunctionCall1(date_timestamp, DateADTGetDatum(origin))); } if (interval->month) { validate_month_bucket(interval); date = bucket_month(interval->month, date, origin); PG_RETURN_DATEADT(date); } else { int64 period = get_interval_period_timestamp_units(interval); /* check the period aligns on a date */ check_period_is_daily(period); TIME_BUCKET_TS(period, timestamp, result, origin_ts); PG_RETURN_DATUM(DirectFunctionCall1(timestamp_date, TimestampGetDatum(result))); } } TS_FUNCTION_INFO_V1(ts_date_offset_bucket); TSDLLEXPORT Datum ts_date_offset_bucket(PG_FUNCTION_ARGS) { Datum period = PG_GETARG_DATUM(0); Datum date = PG_GETARG_DATUM(1); if (DATE_NOT_FINITE(DatumGetDateADT(date))) PG_RETURN_DATUM(date); /* Apply offset. */ Datum time = DirectFunctionCall2(date_mi_interval, date, PG_GETARG_DATUM(2)); date = DirectFunctionCall1(timestamp_date, time); date = DirectFunctionCall2(ts_date_bucket, period, date); /* Remove offset. */ time = DirectFunctionCall2(date_pl_interval, date, PG_GETARG_DATUM(2)); date = DirectFunctionCall1(timestamp_date, time); PG_RETURN_DATUM(date); } TSDLLEXPORT int64 ts_time_bucket_by_type(int64 interval, int64 timestamp, Oid timestamp_type) { NullableDatum null_datum = INIT_NULL_DATUM; return ts_time_bucket_by_type_extended(interval, timestamp, timestamp_type, null_datum, null_datum); } /* when working with time_buckets stored in our catalog, we may not know ahead of time which * bucketing function to use, this function dynamically dispatches to the correct time_bucket_<foo> * based on an inputted timestamp_type */ TSDLLEXPORT int64 ts_time_bucket_by_type_extended(int64 interval, int64 timestamp, Oid timestamp_type, NullableDatum offset, NullableDatum origin) { /* Defined offset and origin in one function is not supported */ Assert(offset.isnull == true || origin.isnull == true); Datum timestamp_in_time_type = ts_internal_to_time_value(timestamp, timestamp_type); Datum interval_in_interval_type; Datum time_bucketed; Datum (*bucket_function)(PG_FUNCTION_ARGS); switch (timestamp_type) { case INT2OID: interval_in_interval_type = ts_internal_to_interval_value(interval, timestamp_type); bucket_function = ts_int16_bucket; break; case INT4OID: interval_in_interval_type = ts_internal_to_interval_value(interval, timestamp_type); bucket_function = ts_int32_bucket; break; case INT8OID: interval_in_interval_type = ts_internal_to_interval_value(interval, timestamp_type); bucket_function = ts_int64_bucket; break; case TIMESTAMPOID: interval_in_interval_type = ts_internal_to_interval_value(interval, INTERVALOID); if (offset.isnull) bucket_function = ts_timestamp_bucket; /* handles also origin */ else bucket_function = ts_timestamp_offset_bucket; break; case TIMESTAMPTZOID: interval_in_interval_type = ts_internal_to_interval_value(interval, INTERVALOID); if (offset.isnull) bucket_function = ts_timestamptz_bucket; /* handles also origin */ else bucket_function = ts_timestamptz_offset_bucket; break; case DATEOID: interval_in_interval_type = ts_internal_to_interval_value(interval, INTERVALOID); if (offset.isnull) bucket_function = ts_date_bucket; /* handles also origin */ else bucket_function = ts_date_offset_bucket; break; default: elog(ERROR, "invalid time_bucket type \"%s\"", format_type_be(timestamp_type)); } if (!offset.isnull) { time_bucketed = DirectFunctionCall3(bucket_function, interval_in_interval_type, timestamp_in_time_type, offset.value); } else if (!origin.isnull) { time_bucketed = DirectFunctionCall3(bucket_function, interval_in_interval_type, timestamp_in_time_type, origin.value); } else { time_bucketed = DirectFunctionCall2(bucket_function, interval_in_interval_type, timestamp_in_time_type); } return ts_time_value_to_internal(time_bucketed, timestamp_type); } TS_FUNCTION_INFO_V1(ts_time_bucket_ng_timestamp); TSDLLEXPORT Datum ts_time_bucket_ng_timestamp(PG_FUNCTION_ARGS) { DateADT ts_date; Interval *interval = PG_GETARG_INTERVAL_P(0); Timestamp timestamp = PG_GETARG_TIMESTAMP(1); if (interval->time != 0) { if (interval->month != 0) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("interval can't combine months with minutes or hours"))); } if (TIMESTAMP_NOT_FINITE(timestamp)) PG_RETURN_TIMESTAMP(timestamp); /* * Handle minutes, hours and days. */ Timestamp origin = (PG_NARGS() > 2 ? PG_GETARG_TIMESTAMP(2) : DEFAULT_ORIGIN); if (TIMESTAMP_NOT_FINITE(origin)) PG_RETURN_TIMESTAMP(origin); Timestamp result; int64 period = get_interval_period_timestamp_units(interval); TIME_BUCKET_TS(period, timestamp, result, origin); PG_RETURN_TIMESTAMP(result); } /* * Discard any time information and work with the date. */ ts_date = DatumGetDateADT(DirectFunctionCall1(timestamp_date, PG_GETARG_DATUM(1))); if (PG_NARGS() > 2) { DateADT result; DateADT origin = DatumGetDateADT(DirectFunctionCall1(timestamp_date, PG_GETARG_DATUM(2))); result = DatumGetDateADT(DirectFunctionCall3(ts_time_bucket_ng_date, PG_GETARG_DATUM(0), DateADTGetDatum(ts_date), DateADTGetDatum(origin))); return DirectFunctionCall1(date_timestamp, DateADTGetDatum(result)); } else { DateADT result; result = DatumGetDateADT(DirectFunctionCall2(ts_time_bucket_ng_date, PG_GETARG_DATUM(0), DateADTGetDatum(ts_date))); return DirectFunctionCall1(date_timestamp, DateADTGetDatum(result)); } } TS_FUNCTION_INFO_V1(ts_time_bucket_ng_timestamptz); TSDLLEXPORT Datum ts_time_bucket_ng_timestamptz(PG_FUNCTION_ARGS) { DateADT result; Datum interval = PG_GETARG_DATUM(0); DateADT ts_date = DatumGetDateADT(DirectFunctionCall1(timestamptz_date, PG_GETARG_DATUM(1))); if (PG_NARGS() > 2) { DateADT origin = DatumGetDateADT(DirectFunctionCall1(timestamptz_date, PG_GETARG_DATUM(2))); result = DatumGetDateADT(DirectFunctionCall3(ts_time_bucket_ng_date, interval, DateADTGetDatum(ts_date), DateADTGetDatum(origin))); } else { result = DatumGetDateADT( DirectFunctionCall2(ts_time_bucket_ng_date, interval, DateADTGetDatum(ts_date))); } return DirectFunctionCall1(date_timestamptz, DateADTGetDatum(result)); } TS_FUNCTION_INFO_V1(ts_time_bucket_ng_date); TSDLLEXPORT Datum ts_time_bucket_ng_date(PG_FUNCTION_ARGS) { Interval *interval = PG_GETARG_INTERVAL_P(0); DateADT date = PG_GETARG_DATEADT(1); DateADT origin_date = 0; int origin_year = 2000, origin_month = 1, origin_day = 1; int year, month, day; int delta, bucket_number; if ((interval->time != 0) || ((interval->month != 0) && (interval->day != 0))) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("interval must be either days and weeks, or months and years"))); } if ((interval->month == 0) && (interval->day == 0)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("interval must be at least one day"))); } if (PG_NARGS() > 2) { origin_date = PG_GETARG_DATUM(2); if (DATE_NOT_FINITE(origin_date)) PG_RETURN_DATEADT(origin_date); j2date(origin_date + POSTGRES_EPOCH_JDATE, &origin_year, &origin_month, &origin_day); } if ((origin_day != 1) && (interval->month != 0)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("origin must be the first day of the month"), errhint("When using timestamptz-version of the function, 'origin' is " "converted to provided 'timezone'."))); } if (DATE_NOT_FINITE(date)) PG_RETURN_DATEADT(date); if (interval->month != 0) { /* Handle months and years */ j2date(date + POSTGRES_EPOCH_JDATE, &year, &month, &day); int32 result; int32 offset = (origin_year * 12) + origin_month - 1; int32 timestamp = (year * 12) + month - 1; TIME_BUCKET(interval->month, timestamp, offset, PG_INT32_MIN, PG_INT32_MAX, result); year = result / 12; month = (result % 12) + 1; day = 1; date = date2j(year, month, day) - POSTGRES_EPOCH_JDATE; } else { /* Handle days and weeks */ if (date < origin_date) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("origin must be before the given date"))); } delta = date - origin_date; bucket_number = delta / interval->day; date = origin_date + bucket_number * interval->day; } PG_RETURN_DATEADT(date); } TS_FUNCTION_INFO_V1(ts_time_bucket_ng_timezone); TSDLLEXPORT Datum ts_time_bucket_ng_timezone(PG_FUNCTION_ARGS) { Timestamp result; Datum timestamp; Datum interval = PG_GETARG_DATUM(0); Datum timestamptz = PG_GETARG_DATUM(1); Datum tzname = PG_GETARG_DATUM(2); /* * Convert 'timestamptz' to TIMESTAMP at given 'tzname'. * The code is equal to 'timestamptz AT TIME ZONE tzname'. */ timestamp = DirectFunctionCall2(timestamptz_zone, tzname, timestamptz); /* Then treat resulting timestamp as a regular one */ result = DatumGetTimestamp(DirectFunctionCall2(ts_time_bucket_ng_timestamp, interval, timestamp)); if (TIMESTAMP_NOT_FINITE(result)) PG_RETURN_TIMESTAMP(result); PG_RETURN_DATUM(DirectFunctionCall2(timestamp_zone, tzname, TimestampGetDatum(result))); } TS_FUNCTION_INFO_V1(ts_time_bucket_ng_timezone_origin); TSDLLEXPORT Datum ts_time_bucket_ng_timezone_origin(PG_FUNCTION_ARGS) { Timestamp result; Datum timestamp, origin; Datum interval = PG_GETARG_DATUM(0); Datum timestamptz = PG_GETARG_DATUM(1); Datum origintz = PG_GETARG_DATUM(2); Datum tzname = PG_GETARG_DATUM(3); /* * Convert 'origin' to TIMESTAMP at given 'tzname'. * The code is equal to 'origin AT TIME ZONE tzname'. */ origin = DirectFunctionCall2(timestamptz_zone, tzname, origintz); /* Same for 'timestamptz' */ timestamp = DirectFunctionCall2(timestamptz_zone, tzname, timestamptz); /* Then treat resulting 'timestamp' and 'origin' as a regular ones */ result = DatumGetTimestamp( DirectFunctionCall3(ts_time_bucket_ng_timestamp, interval, timestamp, origin)); if (TIMESTAMP_NOT_FINITE(result)) PG_RETURN_TIMESTAMP(result); PG_RETURN_DATUM(DirectFunctionCall2(timestamp_zone, tzname, TimestampGetDatum(result))); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/time_bucket.h����������������������������������������������������������������0000664�0000000�0000000�00000003011�15100345067�0017301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include "export.h" #define TIME_BUCKET_NG_DEFAULT_ORIGIN_TIMESTAMPSTAMPTZ "2000-01-01 00:00:00+01" #define TIME_BUCKET_NG_DEFAULT_ORIGIN_TIMESTAMP "2000-01-01 00:00:00" #define TIME_BUCKET_NG_DEFAULT_ORIGIN_DATE "2000-01-01" extern TSDLLEXPORT Datum ts_int16_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_int32_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_int64_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_date_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_timestamp_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_timestamptz_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_timestamptz_timezone_bucket(PG_FUNCTION_ARGS); extern TSDLLEXPORT int64 ts_time_bucket_by_type(int64 interval, int64 timestamp, Oid type); extern TSDLLEXPORT int64 ts_time_bucket_by_type_extended(int64 interval, int64 timestamp, Oid type, NullableDatum offset, NullableDatum origin); extern TSDLLEXPORT Datum ts_time_bucket_ng_date(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_time_bucket_ng_timestamp(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_time_bucket_ng_timestamptz(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_time_bucket_ng_timezone(PG_FUNCTION_ARGS); extern TSDLLEXPORT Datum ts_time_bucket_ng_timezone_origin(PG_FUNCTION_ARGS); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/time_utils.c�����������������������������������������������������������������0000664�0000000�0000000�00000040072�15100345067�0017167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <parser/parse_coerce.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/fmgrprotos.h> #include <utils/rangetypes.h> #include <utils/timestamp.h> #include <utils/uuid.h> #include "guc.h" #include "time_utils.h" #include "utils.h" #include "uuid.h" TS_FUNCTION_INFO_V1(ts_make_range_from_internal_time); TS_FUNCTION_INFO_V1(ts_get_internal_time_min); TS_FUNCTION_INFO_V1(ts_get_internal_time_max); static Datum subtract_interval_from_now(Oid timetype, const Interval *interval) { Datum res = DirectFunctionCall1(now, 0); switch (timetype) { case TIMESTAMPOID: res = DirectFunctionCall1(timestamptz_timestamp, res); return DirectFunctionCall2(timestamp_mi_interval, res, IntervalPGetDatum(interval)); case TIMESTAMPTZOID: return DirectFunctionCall2(timestamptz_mi_interval, res, IntervalPGetDatum(interval)); case DATEOID: res = DirectFunctionCall1(timestamptz_timestamp, res); res = DirectFunctionCall2(timestamp_mi_interval, res, IntervalPGetDatum(interval)); return DirectFunctionCall1(timestamp_date, res); case UUIDOID: { res = DirectFunctionCall2(timestamptz_mi_interval, res, IntervalPGetDatum(interval)); pg_uuid_t *uuid = ts_create_uuid_v7_from_unixtime_us(DatumGetTimestampTz(res), true, true); return UUIDPGetDatum(uuid); } default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unknown time type %s", format_type_be(timetype)))); } return res; } Datum ts_time_datum_convert_arg(Datum arg, Oid *argtype, Oid timetype) { Oid type = *argtype; if (!OidIsValid(type) || type == UNKNOWNOID) { Oid infuncid = InvalidOid; Oid typeioparam; type = timetype; getTypeInputInfo(type, &infuncid, &typeioparam); switch (get_func_nargs(infuncid)) { case 1: /* Functions that take one input argument, e.g., the Date function */ arg = OidFunctionCall1(infuncid, arg); break; case 3: /* Timestamp functions take three input arguments */ arg = OidFunctionCall3(infuncid, arg, ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1)); break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time argument"), errhint("Time argument requires an explicit cast."))); } *argtype = type; } return arg; } /* * Get the internal time value from a pseudo-type function argument. * * API functions that take supported time types as arguments often use a * pseudo-type parameter to represent these. For instance, the "any" * pseudo-type is often used to represent any of these supported types. * * The downside of "any", however, is that it lacks type information and often * forces users to add explicit type casts. For instance, with the following * API call * * drop_chunk('conditions', '2020-10-01'); * * the argument type will be UNKNOWNOID. And the user would have to add * an explicit type cast: * * drop_chunks('conditions', '2020-10-01'::date); * * However, we can handle the UNKNOWNOID case since we have the time type * information in internal metadata (e.g., the time column type of a * hypertable) and we can try to convert the argument to that type. * * Thus, there are two cases: * * 1. An explicit cast was done --> the type is given in argtype. * 2. No cast was done --> we try to convert the argument to the known time * type. * * If an unsupported type is given, or the typeless argument has a nonsensical * string, then there will be an error raised. */ int64 ts_time_value_from_arg(Datum arg, Oid argtype, Oid timetype, bool need_now_func) { /* If no explicit cast was done by the user, try to convert the argument * to the time type. */ arg = ts_time_datum_convert_arg(arg, &argtype, timetype); if (IS_INTEGER_TYPE(timetype) && (argtype == INTERVALOID || IS_TIMESTAMP_TYPE(argtype))) { if (need_now_func) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time argument type \"%s\"", format_type_be(argtype)), errhint("Try casting the argument to \"%s\".", format_type_be(timetype)))); /* * The argument type is INTERVAL or TIMESTAMP-like for INTEGER column; this signifies that * chunks are retained based on chunk creation time. Chunk creation time is represented * as TIMESTAMPTZ, the input argument should be typecast to TIMESTAMPTZ. */ if (argtype == INTERVALOID) arg = subtract_interval_from_now(TIMESTAMPTZOID, DatumGetIntervalP(arg)); return DatumGetInt64(arg); } if (argtype == INTERVALOID) { arg = subtract_interval_from_now(timetype, DatumGetIntervalP(arg)); argtype = timetype; } else if (argtype != timetype && !can_coerce_type(1, &argtype, &timetype, COERCION_IMPLICIT)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time argument type \"%s\"", format_type_be(argtype)), errhint("Try casting the argument to \"%s\".", format_type_be(timetype)))); return ts_time_value_to_internal(arg, argtype); } /* * Try to coerce a type to a supported time type. * * To support custom time types in hypertables, we need to know the type's * boundaries in order to, e.g., construct dimensional chunk constraints. The * custom time type will inherit the valid time range of the supported time * type it can be casted to. * * Currently, we only support custom time types that are binary compatible * with bigint and then it also inherits the valid time range of a bigint. */ static Oid coerce_to_time_type(Oid type) { if (ts_type_is_int8_binary_compatible(type)) return INT8OID; elog(ERROR, "unsupported time type \"%s\"", format_type_be(type)); pg_unreachable(); } /* * Get the min time datum for a time type. * * Note that the min is not the same the actual "min" of the underlying * storage for date and timestamps. */ Datum ts_time_datum_get_min(Oid timetype) { switch (timetype) { case DATEOID: return DateADTGetDatum(TS_DATE_MIN); case TIMESTAMPOID: return TimestampGetDatum(TS_TIMESTAMP_MIN); case TIMESTAMPTZOID: return TimestampTzGetDatum(TS_TIMESTAMP_MIN); case INT2OID: return Int16GetDatum(PG_INT16_MIN); case INT4OID: return Int32GetDatum(PG_INT32_MIN); case INT8OID: return Int64GetDatum(PG_INT64_MIN); case UUIDOID: return Int64GetDatum(TS_TIME_UUID_MIN); default: break; } return ts_time_datum_get_min(coerce_to_time_type(timetype)); } /* * Get the end time datum for a time type. * * Note that the end is not the same as "max" (hence not named max). The end * is exclusive for date and timestamps, and might not be the same as the max * value for the underlying storage type (e.g., TIMESTAMP_END is before * PG_INT64_MAX). Instead, the max value for dates and timestamps represent * -Infinity and +Infinity. */ Datum ts_time_datum_get_end(Oid timetype) { switch (timetype) { case DATEOID: return DateADTGetDatum(TS_DATE_END); case TIMESTAMPOID: return TimestampGetDatum(TS_TIMESTAMP_END); case TIMESTAMPTZOID: return TimestampTzGetDatum(TS_TIMESTAMP_END); case INT2OID: case INT4OID: case INT8OID: case UUIDOID: elog(ERROR, "END is not defined for \"%s\"", format_type_be(timetype)); break; default: break; } return ts_time_datum_get_end(coerce_to_time_type(timetype)); } Datum ts_time_datum_get_max(Oid timetype) { switch (timetype) { case DATEOID: return DateADTGetDatum(TS_DATE_END - 1); case TIMESTAMPOID: return TimestampGetDatum(TS_TIMESTAMP_END - 1); case TIMESTAMPTZOID: return TimestampTzGetDatum(TS_TIMESTAMP_END - 1); case INT2OID: return Int16GetDatum(PG_INT16_MAX); case INT4OID: return Int32GetDatum(PG_INT32_MAX); case INT8OID: return Int64GetDatum(PG_INT64_MAX); case UUIDOID: return Int64GetDatum(TS_TIME_UUID_MAX); default: break; } return ts_time_datum_get_max(coerce_to_time_type(timetype)); } Datum ts_time_datum_get_nobegin(Oid timetype) { switch (timetype) { case DATEOID: return DateADTGetDatum(DATEVAL_NOBEGIN); case TIMESTAMPOID: return TimestampGetDatum(DT_NOBEGIN); case TIMESTAMPTZOID: return TimestampTzGetDatum(DT_NOBEGIN); case INT2OID: case INT4OID: case INT8OID: case UUIDOID: elog(ERROR, "NOBEGIN is not defined for \"%s\"", format_type_be(timetype)); break; default: break; } return ts_time_datum_get_nobegin(coerce_to_time_type(timetype)); } Datum ts_time_datum_get_nobegin_or_min(Oid timetype) { if (IS_TIMESTAMP_TYPE(timetype)) return ts_time_datum_get_nobegin(timetype); return ts_time_datum_get_min(timetype); } Datum ts_time_datum_get_noend(Oid timetype) { switch (timetype) { case DATEOID: return DateADTGetDatum(DATEVAL_NOEND); case TIMESTAMPOID: return TimestampGetDatum(DT_NOEND); case TIMESTAMPTZOID: return TimestampTzGetDatum(DT_NOEND); case INT2OID: case INT4OID: case INT8OID: case UUIDOID: elog(ERROR, "NOEND is not defined for \"%s\"", format_type_be(timetype)); break; default: break; } return ts_time_datum_get_noend(coerce_to_time_type(timetype)); } /* * Get the min for a time type in internal time. */ int64 ts_time_get_min(Oid timetype) { switch (timetype) { case DATEOID: return TS_DATE_INTERNAL_MIN; case TIMESTAMPOID: return TS_TIMESTAMP_INTERNAL_MIN; case TIMESTAMPTZOID: return TS_TIMESTAMP_INTERNAL_MIN; case INT2OID: return PG_INT16_MIN; case INT4OID: return PG_INT32_MIN; case INT8OID: return PG_INT64_MIN; case UUIDOID: return TS_TIME_UUID_MIN; default: break; } return ts_time_get_min(coerce_to_time_type(timetype)); } /* * Get the max for a time type in internal time. */ int64 ts_time_get_max(Oid timetype) { switch (timetype) { case DATEOID: return TS_DATE_INTERNAL_END - 1; case TIMESTAMPOID: return TS_TIMESTAMP_INTERNAL_END - 1; case TIMESTAMPTZOID: return TS_TIMESTAMP_INTERNAL_END - 1; case INT2OID: return PG_INT16_MAX; case INT4OID: return PG_INT32_MAX; case INT8OID: return PG_INT64_MAX; case UUIDOID: return TS_TIME_UUID_MAX; default: break; } return ts_time_get_max(coerce_to_time_type(timetype)); } /* * Get the end value time for a time type in internal time. * * The end is not a valid time value (it is exclusive). */ int64 ts_time_get_end(Oid timetype) { switch (timetype) { case DATEOID: return TS_DATE_INTERNAL_END; case TIMESTAMPOID: return TS_TIMESTAMP_INTERNAL_END; case TIMESTAMPTZOID: return TS_TIMESTAMP_INTERNAL_END; case INT2OID: case INT4OID: case INT8OID: case UUIDOID: elog(ERROR, "END is not defined for \"%s\"", format_type_be(timetype)); break; default: break; } return ts_time_get_end(coerce_to_time_type(timetype)); } /* * Return the end (exclusive) or fall back to max. * * Integer time types have no definition for END, so we fall back to max. */ int64 ts_time_get_end_or_max(Oid timetype) { if (IS_TIMESTAMP_TYPE(timetype)) return ts_time_get_end(timetype); return ts_time_get_max(timetype); } int64 ts_time_get_nobegin(Oid timetype) { switch (timetype) { case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: return TS_TIME_NOBEGIN; case INT2OID: case INT4OID: case INT8OID: case UUIDOID: elog(ERROR, "-Infinity not defined for \"%s\"", format_type_be(timetype)); break; default: break; } return ts_time_get_nobegin(coerce_to_time_type(timetype)); } int64 ts_time_get_nobegin_or_min(Oid timetype) { if (IS_TIMESTAMP_TYPE(timetype)) return ts_time_get_nobegin(timetype); return ts_time_get_min(timetype); } int64 ts_time_get_noend(Oid timetype) { switch (timetype) { case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: return TS_TIME_NOEND; case INT2OID: case INT4OID: case INT8OID: case UUIDOID: elog(ERROR, "+Infinity not defined for \"%s\"", format_type_be(timetype)); break; default: break; } return ts_time_get_noend(coerce_to_time_type(timetype)); } int64 ts_time_get_noend_or_max(Oid timetype) { if (IS_TIMESTAMP_TYPE(timetype)) return ts_time_get_noend(timetype); return ts_time_get_max(timetype); } /* * Add an interval to a time value in a saturating way. * * In contrast to, e.g., PG's timestamp_pl_interval, this function adds an * interval in a saturating way without throwing an error in case of * overflow. Instead it clamps to max for integer types end NOEND for date and * timestamp types. */ int64 ts_time_saturating_add(int64 timeval, int64 interval, Oid timetype) { if (timeval > 0 && interval > 0 && timeval > (ts_time_get_max(timetype) - interval)) return ts_time_get_noend_or_max(timetype); if (timeval < 0 && interval < 0 && timeval < (ts_time_get_min(timetype) - interval)) return ts_time_get_nobegin_or_min(timetype); return timeval + interval; } /* * Subtract an interval from a time value in a saturating way. * * In contrast to, e.g., PG's timestamp_mi_interval, this function subtracts * an interval in a saturating way without throwing an error in case of * overflow. Instead, it clamps to min for integer types and NOBEGIN for date * and timestamp types. */ int64 ts_time_saturating_sub(int64 timeval, int64 interval, Oid timetype) { if (timeval < 0 && interval > 0 && timeval < (ts_time_get_min(timetype) + interval)) return ts_time_get_nobegin_or_min(timetype); if (timeval > 0 && interval < 0 && timeval > (ts_time_get_max(timetype) + interval)) return ts_time_get_noend_or_max(timetype); return timeval - interval; } int64 ts_subtract_integer_from_now_saturating(Oid now_func, int64 interval, Oid timetype) { Datum now = OidFunctionCall0(now_func); int64 time_min = ts_time_get_min(timetype); int64 time_max = ts_time_get_max(timetype); int64 nowval, res; Assert(IS_INTEGER_TYPE(timetype)); switch (timetype) { case INT2OID: { nowval = DatumGetInt16(now); break; } case INT4OID: { nowval = DatumGetInt32(now); break; } case INT8OID: { nowval = DatumGetInt64(now); break; } default: elog(ERROR, "unsupported integer time type \"%s\"", format_type_be(timetype)); } if (nowval > 0 && interval < 0 && nowval > time_max + interval) res = time_max; else if (nowval < 0 && interval > 0 && nowval < time_min + interval) res = time_min; else res = nowval - interval; return res; } #ifdef TS_DEBUG /* return mock time for testing */ Datum ts_get_mock_time_or_current_time(void) { Datum res; if (ts_current_timestamp_mock != NULL && strlen(ts_current_timestamp_mock) != 0) { res = DirectFunctionCall3(timestamptz_in, CStringGetDatum(ts_current_timestamp_mock), 0, Int32GetDatum(-1)); return res; } res = TimestampTzGetDatum(GetCurrentTransactionStartTimestamp()); return res; } #endif TS_FUNCTION_INFO_V1(ts_now_mock); /* return mock time for testing */ Datum ts_now_mock(PG_FUNCTION_ARGS) { Datum res; #ifdef TS_DEBUG if (ts_current_timestamp_mock != NULL && strlen(ts_current_timestamp_mock) != 0) { res = DirectFunctionCall3(timestamptz_in, CStringGetDatum(ts_current_timestamp_mock), 0, Int32GetDatum(-1)); return res; } #endif res = TimestampTzGetDatum(GetCurrentTimestamp()); return res; } Datum ts_make_range_from_internal_time(PG_FUNCTION_ARGS) { Oid rngtypid = get_fn_expr_rettype(fcinfo->flinfo); TypeCacheEntry *typcache = range_get_typcache(fcinfo, rngtypid); #if PG16_GE Node *escontext = fcinfo->context; #endif RangeBound lower = { .val = PG_ARGISNULL(1) ? 0 : PG_GETARG_DATUM(1), .infinite = PG_ARGISNULL(1), .inclusive = true, .lower = true, }; RangeBound upper = { .val = PG_ARGISNULL(2) ? 0 : PG_GETARG_DATUM(2), .infinite = PG_ARGISNULL(2), .inclusive = false, .lower = false, }; /* Need to check the types of the lower and upper values. They should * match the returned range. */ PG_RETURN_RANGE_P(make_range_compat(typcache, &lower, &upper, false, escontext)); } Datum ts_get_internal_time_min(PG_FUNCTION_ARGS) { PG_RETURN_INT64(ts_time_get_min(PG_GETARG_OID(0))); } Datum ts_get_internal_time_max(PG_FUNCTION_ARGS) { PG_RETURN_INT64(ts_time_get_max(PG_GETARG_OID(0))); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/time_utils.h�����������������������������������������������������������������0000664�0000000�0000000�00000013603�15100345067�0017174�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "export.h" /* TimescaleDB-specific ranges for valid timestamps and dates: */ #define TS_EPOCH_DIFF (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) #define TS_EPOCH_DIFF_MICROSECONDS (TS_EPOCH_DIFF * USECS_PER_DAY) /* For Timestamps, we need to be able to go from UNIX epoch to POSTGRES epoch * and thus add the difference between the two epochs. This will constrain the * max supported timestamp by the same amount. */ #define TS_TIMESTAMP_MIN MIN_TIMESTAMP #define TS_TIMESTAMP_MAX (TS_TIMESTAMP_END - 1) #define TS_TIMESTAMP_END (END_TIMESTAMP - TS_EPOCH_DIFF_MICROSECONDS) #define TS_TIMESTAMP_INTERNAL_MIN (TS_TIMESTAMP_MIN + TS_EPOCH_DIFF_MICROSECONDS) #define TS_TIMESTAMP_INTERNAL_MAX (TS_TIMESTAMP_INTERNAL_END - 1) #define TS_TIMESTAMP_INTERNAL_END (TS_TIMESTAMP_END + TS_EPOCH_DIFF_MICROSECONDS) /* For Dates, we're limited by the timestamp range (since we internally first * convert dates to timestamps). Naturally the TimescaleDB-specific timestamp * limits apply as well. */ #define TS_DATE_MIN (DATETIME_MIN_JULIAN - POSTGRES_EPOCH_JDATE) #define TS_DATE_MAX (TS_DATE_END - 1) #define TS_DATE_END (TIMESTAMP_END_JULIAN - POSTGRES_EPOCH_JDATE - TS_EPOCH_DIFF) #define TS_DATE_INTERNAL_MIN (TS_TIMESTAMP_MIN + TS_EPOCH_DIFF_MICROSECONDS) #define TS_DATE_INTERNAL_MAX (TS_DATE_INTERNAL_END - 1) #define TS_DATE_INTERNAL_END (TS_TIMESTAMP_END + TS_EPOCH_DIFF_MICROSECONDS) /* * -Infinity and +Infinity in internal (Unix) time. */ #define TS_TIME_NOBEGIN (PG_INT64_MIN) #define TS_TIME_NOEND (PG_INT64_MAX) /* * A UUIDv7 timestamp is 6 bytes milliseconds in Unix epoch (unsigned). * * Since RFC9562 specifies the timestamp as unsigned, the minimum value is * 0. Further, the sub-millisecond part cannot be used as time since the bits * are optional and it is not possible to know if they are random or represent * a time fraction. Therefore, the max value is limited to the milliseconds. */ #define TS_TIME_UUID_MS_MIN (0x000000000000) #define TS_TIME_UUID_MIN (0x000000000000 * 1000) /* microseconds */ #define TS_TIME_UUID_MS_MAX (0xFFFFFFFFFFFF) #define TS_TIME_UUID_MAX (TS_TIME_UUID_MS_MAX * 1000) /* microseconds */ #define IS_INTEGER_TYPE(type) (type == INT2OID || type == INT4OID || type == INT8OID) #define IS_TIMESTAMP_TYPE(type) (type == TIMESTAMPOID || type == TIMESTAMPTZOID || type == DATEOID) #define IS_UUID_TYPE(type) (type == UUIDOID) #define IS_VALID_TIME_TYPE(type) \ (IS_INTEGER_TYPE(type) || IS_TIMESTAMP_TYPE(type) || IS_UUID_TYPE(type)) #define TS_TIME_DATUM_IS_MIN(timeval, type) (timeval == ts_time_datum_get_min(type)) #define TS_TIME_DATUM_IS_MAX(timeval, type) (timeval == ts_time_datum_get_max(type)) #define TS_TIME_DATUM_IS_END(timeval, type) \ (IS_TIMESTAMP_TYPE(type) && timeval == ts_time_datum_get_end(type))) #define TS_TIME_DATUM_IS_NOBEGIN(timeval, type) \ (IS_TIMESTAMP_TYPE(type) && (timeval == ts_time_datum_get_nobegin(type))) #define TS_TIME_DATUM_IS_NOEND(timeval, type) \ (IS_TIMESTAMP_TYPE(type) && (timeval == ts_time_datum_get_noend(type))) #define TS_TIME_DATUM_NOT_FINITE(timeval, type) \ (IS_INTEGER_TYPE(type) || TS_TIME_DATUM_IS_NOBEGIN(timeval, type) || \ TS_TIME_DATUM_IS_NOEND(timeval, type)) #define TS_TIME_IS_MIN(timeval, type) (timeval == ts_time_get_min(type)) #define TS_TIME_IS_MAX(timeval, type) (timeval == ts_time_get_max(type)) #define TS_TIME_IS_END(timeval, type) (IS_TIMESTAMP_TYPE(type) && timeval == ts_time_get_end(type)) #define TS_TIME_IS_NOBEGIN(timeval, type) \ (IS_TIMESTAMP_TYPE(type) && timeval == ts_time_get_nobegin(type)) #define TS_TIME_IS_NOEND(timeval, type) \ (IS_TIMESTAMP_TYPE(type) && timeval == ts_time_get_noend(type)) #define TS_TIME_NOT_FINITE(timeval, type) \ (IS_INTEGER_TYPE(type) || TS_TIME_IS_NOBEGIN(timeval, type) || TS_TIME_IS_NOEND(timeval, type)) extern TSDLLEXPORT int64 ts_time_value_from_arg(Datum arg, Oid argtype, Oid timetype, bool need_now_func); extern TSDLLEXPORT Datum ts_time_datum_convert_arg(Datum arg, Oid *argtype, Oid timetype); extern TSDLLEXPORT Datum ts_time_datum_get_min(Oid timetype); extern TSDLLEXPORT Datum ts_time_datum_get_max(Oid timetype); extern TSDLLEXPORT Datum ts_time_datum_get_end(Oid timetype); extern TSDLLEXPORT Datum ts_time_datum_get_nobegin(Oid timetype); extern TSDLLEXPORT Datum ts_time_datum_get_nobegin_or_min(Oid timetype); extern TSDLLEXPORT Datum ts_time_datum_get_noend(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_min(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_max(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_end(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_end_or_max(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_nobegin(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_nobegin_or_min(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_noend(Oid timetype); extern TSDLLEXPORT int64 ts_time_get_noend_or_max(Oid timetype); extern TSDLLEXPORT int64 ts_time_saturating_add(int64 timeval, int64 interval, Oid timetype); extern TSDLLEXPORT int64 ts_time_saturating_sub(int64 timeval, int64 interval, Oid timetype); extern TSDLLEXPORT int64 ts_subtract_integer_from_now_saturating(Oid now_func, int64 interval, Oid timetype); #ifdef TS_DEBUG extern TSDLLEXPORT Datum ts_get_mock_time_or_current_time(void); #endif bool is_valid_now_func(Node *node); �����������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/timezones.c������������������������������������������������������������������0000664�0000000�0000000�00000002147�15100345067�0017027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include "timezones.h" #include <access/xact.h> #include <datatype/timestamp.h> #include <pgtime.h> #include <port.h> #include <utils/timestamp.h> /* Checks if the given TZ name is valid. */ bool ts_is_valid_timezone_name(const char *tz_name) { pg_tz *tz; int tzoff; struct pg_tm tm; fsec_t fsec; const char *abbrev; bool found = false; TimestampTz now = GetCurrentTransactionStartTimestamp(); pg_tzenum *tzenum = pg_tzenumerate_start(); while (true) { tz = pg_tzenumerate_next(tzenum); if (!tz) break; /* * Convert now() to time in this TZ and skip if conversion fails. * This check is the same that pg_timezone_names() does. */ if (timestamp2tm(now, &tzoff, &tm, &fsec, &abbrev, tz) != 0) continue; if ((!strcmp(tz_name, pg_get_timezone_name(tz))) || (abbrev && !strcmp(tz_name, abbrev))) { found = true; break; } } pg_tzenumerate_end(tzenum); return found; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/timezones.h������������������������������������������������������������������0000664�0000000�0000000�00000000451�15100345067�0017030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include "export.h" extern TSDLLEXPORT bool ts_is_valid_timezone_name(const char *tz_name); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/trigger.c��������������������������������������������������������������������0000664�0000000�0000000�00000011641�15100345067�0016454�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <commands/trigger.h> #include <miscadmin.h> #include <parser/analyze.h> #include <tcop/tcopprot.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/syscache.h> #include "trigger.h" /* * Replicate a trigger on a chunk. * * Given a trigger OID (e.g., a Hypertable trigger), create the equivalent * trigger on a chunk. * * Note: it is assumed that this function is called under a user that has * permissions to modify the chunk since CreateTrigger() performs permissions * checks. */ void ts_trigger_create_on_chunk(Oid trigger_oid, const char *chunk_schema_name, const char *chunk_table_name) { Datum datum_def = DirectFunctionCall1(pg_get_triggerdef, ObjectIdGetDatum(trigger_oid)); const char *def = TextDatumGetCString(datum_def); List *deparsed_list; Node *deparsed_node; CreateTrigStmt *stmt; deparsed_list = pg_parse_query(def); Assert(list_length(deparsed_list) == 1); deparsed_node = linitial(deparsed_list); do { RawStmt *rawstmt = (RawStmt *) deparsed_node; ParseState *pstate = make_parsestate(NULL); Query *query; Assert(IsA(deparsed_node, RawStmt)); pstate->p_sourcetext = def; query = transformTopLevelStmt(pstate, rawstmt); free_parsestate(pstate); stmt = (CreateTrigStmt *) query->utilityStmt; } while (0); Assert(IsA(stmt, CreateTrigStmt)); stmt->relation->relname = (char *) chunk_table_name; stmt->relation->schemaname = (char *) chunk_schema_name; /* Using OR REPLACE option introduced on Postgres 14 */ stmt->replace = true; CreateTrigger(stmt, def, InvalidOid, InvalidOid, InvalidOid, InvalidOid, InvalidOid, InvalidOid, NULL, false, false); CommandCounterIncrement(); /* needed to prevent pg_class being updated * twice */ } typedef bool (*trigger_handler)(const Trigger *trigger, void *arg); static inline void for_each_trigger(Oid relid, trigger_handler on_trigger, void *arg) { Relation rel; rel = table_open(relid, AccessShareLock); if (rel->trigdesc != NULL) { int i; /* * The TriggerDesc from rel->trigdesc seems to be modified during * iterations of the loop and sometimes gets reallocated so we * access trigdesc only through rel->trigdesc. */ for (i = 0; i < rel->trigdesc->numtriggers; i++) { Trigger *trigger = &rel->trigdesc->triggers[i]; if (!on_trigger(trigger, arg)) break; } } table_close(rel, AccessShareLock); } static bool create_trigger_handler(const Trigger *trigger, void *arg) { const Chunk *chunk = arg; if ((TRIGGER_USES_TRANSITION_TABLE(trigger->tgoldtable) || TRIGGER_USES_TRANSITION_TABLE(trigger->tgnewtable)) && TRIGGER_FOR_ROW(trigger->tgtype)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("ROW triggers with transition tables are not supported on hypertable " "chunks"))); if (trigger && TRIGGER_FOR_ROW(trigger->tgtype) && !trigger->tgisinternal) ts_trigger_create_on_chunk(trigger->tgoid, NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); return true; } /* * Create all hypertable triggers on a new chunk. * * Since chunk creation typically happens automatically on hypertable INSERT, we * need to execute the trigger creation under the role of the hypertable owner. * This is due to the use of CreateTrigger(), which does permissions checks. The * user role inserting might have INSERT permissions, but not TRIGGER * permissions (needed to create triggers on a table). * * We assume that the owner of the Hypertable is also the owner of the new * chunk. */ void ts_trigger_create_all_on_chunk(const Chunk *chunk) { int sec_ctx; Oid saved_uid; Oid owner; /* We do not create triggers on foreign table chunks */ if (chunk->relkind == RELKIND_FOREIGN_TABLE) return; Assert(chunk->relkind == RELKIND_RELATION); owner = ts_rel_get_owner(chunk->hypertable_relid); GetUserIdAndSecContext(&saved_uid, &sec_ctx); if (saved_uid != owner) SetUserIdAndSecContext(owner, sec_ctx | SECURITY_LOCAL_USERID_CHANGE); for_each_trigger(chunk->hypertable_relid, create_trigger_handler, (Chunk *) chunk); if (saved_uid != owner) SetUserIdAndSecContext(saved_uid, sec_ctx); } static bool check_for_transition_table(const Trigger *trigger, void *arg) { if ((TRIGGER_USES_TRANSITION_TABLE(trigger->tgnewtable) || TRIGGER_USES_TRANSITION_TABLE(trigger->tgoldtable)) && TRIGGER_FOR_ROW(trigger->tgtype)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("ROW triggers with transition tables are not supported on hypertables"))); return false; } return true; } void ts_check_unsupported_triggers(Oid relid) { for_each_trigger(relid, check_for_transition_table, NULL); } �����������������������������������������������������������������������������������������������timescaledb-2.23.0/src/trigger.h��������������������������������������������������������������������0000664�0000000�0000000�00000001062�15100345067�0016455�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "chunk.h" #include "hypertable.h" #include <catalog/pg_trigger.h> extern void ts_trigger_create_on_chunk(Oid trigger_oid, const char *chunk_schema_name, const char *chunk_table_name); extern TSDLLEXPORT void ts_trigger_create_all_on_chunk(const Chunk *chunk); extern void ts_check_unsupported_triggers(Oid relid); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016762�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/CMakeLists.txt����������������������������������������������������0000664�0000000�0000000�00000001002�15100345067�0021513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/array_utils.c ${CMAKE_CURRENT_SOURCE_DIR}/catalog.c ${CMAKE_CURRENT_SOURCE_DIR}/chunk_column_stats.c ${CMAKE_CURRENT_SOURCE_DIR}/compression_chunk_size.c ${CMAKE_CURRENT_SOURCE_DIR}/compression_settings.c ${CMAKE_CURRENT_SOURCE_DIR}/continuous_agg.c ${CMAKE_CURRENT_SOURCE_DIR}/continuous_aggs_watermark.c ${CMAKE_CURRENT_SOURCE_DIR}/metadata.c ${CMAKE_CURRENT_SOURCE_DIR}/tablespace.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/array_utils.c�����������������������������������������������������0000664�0000000�0000000�00000015452�15100345067�0021473�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_collation.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include "compat/compat.h" #include "array_utils.h" #include "debug_assert.h" /* * Array helper function for internal catalog arrays. * These are not suitable for arbitrary dimension * arrays but only for 1-dimensional arrays as we use * them in our catalog. */ extern TSDLLEXPORT int ts_array_length(ArrayType *arr) { if (!arr || ARR_NDIM(arr) == 0) return 0; Assert(ARR_NDIM(arr) == 1); return ARR_DIMS(arr)[0]; } extern TSDLLEXPORT bool ts_array_equal(ArrayType *left, ArrayType *right) { /* Quick exit if both are NULL or point to same thing. */ if (left == right) return true; if (left == NULL || right == NULL) return false; if (ARR_NDIM(left) == 0 || ARR_NDIM(right) == 0) { if (ARR_NDIM(left) == 0 && ARR_NDIM(right) == 0) return true; else return false; } Assert(left != NULL && right != NULL && ARR_NDIM(left) == 1 && ARR_NDIM(right) == 1); Datum result = OidFunctionCall2Coll(F_ARRAY_EQ, DEFAULT_COLLATION_OID, PointerGetDatum(left), PointerGetDatum(right)); return DatumGetBool(result); } extern TSDLLEXPORT bool ts_array_is_member(ArrayType *arr, const char *name) { bool ret = false; Datum datum; bool null; if (!arr || ARR_NDIM(arr) == 0) return ret; Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == TEXTOID); Assert(name); ArrayIterator it = array_create_iterator(arr, 0, NULL); while (array_iterate(it, &datum, &null)) { Assert(!null); /* * Our internal catalog arrays should either be NULL or * have non-NULL members. During normal operation it should * never have NULL members. If we have NULL members either * the catalog is corrupted or some catalog tampering has * happened. */ Ensure(!null, "array element was NULL"); if (strncmp(TextDatumGetCString(datum), name, NAMEDATALEN) == 0) { ret = true; break; } } array_free_iterator(it); return ret; } extern TSDLLEXPORT void ts_array_append_stringinfo(ArrayType *arr, StringInfo info) { bool first = true; Datum datum; bool null; if (!arr) return; Assert(ARR_NDIM(arr) <= 1); Assert(arr->elemtype == TEXTOID); ArrayIterator it = array_create_iterator(arr, 0, NULL); while (array_iterate(it, &datum, &null)) { Assert(!null); /* * Our internal catalog arrays should either be NULL or * have non-NULL members. During normal operation it should * never have NULL members. If we have NULL members either * the catalog is corrupted or some catalog tampering has * happened. */ Ensure(!null, "array element was NULL"); if (!first) appendStringInfoString(info, ", "); else first = false; appendStringInfo(info, "%s", TextDatumGetCString(datum)); } array_free_iterator(it); } extern TSDLLEXPORT int ts_array_position(ArrayType *arr, const char *name) { int pos = 0; Datum datum; bool found = false; bool null; if (!arr || ARR_NDIM(arr) == 0) return pos; Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == TEXTOID); ArrayIterator it = array_create_iterator(arr, 0, NULL); while (array_iterate(it, &datum, &null)) { pos++; /* * Our internal catalog arrays should either be NULL or * have non-NULL members. During normal operation it should * never have NULL members. If we have NULL members either * the catalog is corrupted or some catalog tampering has * happened. */ Ensure(!null, "array element was NULL"); if (strncmp(TextDatumGetCString(datum), name, NAMEDATALEN) == 0) { found = true; break; } } array_free_iterator(it); return found ? pos : 0; } extern TSDLLEXPORT ArrayType * ts_array_replace_text(ArrayType *arr, const char *old, const char *new) { if (!arr || ARR_NDIM(arr) == 0) return NULL; Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == TEXTOID); Datum datum; bool null; int pos = 1; ArrayIterator it = array_create_iterator(arr, 0, NULL); while (array_iterate(it, &datum, &null)) { /* * Our internal catalog arrays should either be NULL or * have non-NULL members. During normal operation it should * never have NULL members. If we have NULL members either * the catalog is corrupted or some catalog tampering has * happened. */ Ensure(!null, "array element was NULL"); if (strncmp(TextDatumGetCString(datum), old, NAMEDATALEN) == 0) { datum = array_set_element(PointerGetDatum(arr), 1, &pos, CStringGetTextDatum(new), false, -1, -1, false, TYPALIGN_INT); arr = DatumGetArrayTypeP(datum); } pos++; } array_free_iterator(it); return arr; } extern TSDLLEXPORT bool ts_array_get_element_bool(ArrayType *arr, int position) { Assert(arr); Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == BOOLOID); bool isnull; Datum value = array_get_element(PointerGetDatum(arr), 1, &position, -1, 1, true, 'c', &isnull); Ensure(!isnull, "invalid array position"); return DatumGetBool(value); } extern TSDLLEXPORT const char * ts_array_get_element_text(ArrayType *arr, int position) { Assert(arr); Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == TEXTOID); bool isnull; Datum value = array_get_element(PointerGetDatum(arr), 1, &position, -1, -1, false, 'i', &isnull); Ensure(!isnull, "invalid array position"); return TextDatumGetCString(value); } extern TSDLLEXPORT ArrayType * ts_array_add_element_text(ArrayType *arr, const char *value) { if (!arr && value == NULL) { /* return empty array */ return construct_array(NULL, 0, TEXTOID, -1, false, TYPALIGN_INT); } Datum val = CStringGetTextDatum(value); if (!arr) { return construct_array(&val, 1, TEXTOID, -1, false, TYPALIGN_INT); } else { Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == TEXTOID); Datum d = PointerGetDatum(arr); int position = ts_array_length(arr); Assert(position); position++; d = array_set_element(d, 1, &position, val, false, -1, -1, false, TYPALIGN_INT); return DatumGetArrayTypeP(d); } } extern TSDLLEXPORT ArrayType * ts_array_add_element_bool(ArrayType *arr, bool value) { if (!arr) { Datum val = BoolGetDatum(value); return construct_array(&val, 1, BOOLOID, 1, true, TYPALIGN_CHAR); } else { Assert(ARR_NDIM(arr) == 1); Assert(arr->elemtype == BOOLOID); Datum d = PointerGetDatum(arr); int position = ts_array_length(arr); Assert(position); position++; d = array_set_element(d, 1, &position, BoolGetDatum(value), false, -1, 1, true, TYPALIGN_CHAR); return DatumGetArrayTypeP(d); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/array_utils.h�����������������������������������������������������0000664�0000000�0000000�00000002456�15100345067�0021500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <lib/stringinfo.h> #include <utils/array.h> #include "export.h" /* * Array helper function for internal catalog arrays. * These are not suitable for arbitrary dimension * arrays but only for 1-dimensional arrays as we use * them in our catalog. */ extern TSDLLEXPORT int ts_array_length(ArrayType *arr); extern TSDLLEXPORT bool ts_array_equal(ArrayType *left, ArrayType *right); extern TSDLLEXPORT bool ts_array_is_member(ArrayType *arr, const char *name); extern TSDLLEXPORT void ts_array_append_stringinfo(ArrayType *arr, StringInfo info); extern TSDLLEXPORT int ts_array_position(ArrayType *arr, const char *name); extern TSDLLEXPORT bool ts_array_get_element_bool(ArrayType *arr, int position); extern TSDLLEXPORT const char *ts_array_get_element_text(ArrayType *arr, int position); extern TSDLLEXPORT ArrayType *ts_array_add_element_bool(ArrayType *arr, bool value); extern TSDLLEXPORT ArrayType *ts_array_add_element_text(ArrayType *arr, const char *value); extern TSDLLEXPORT ArrayType *ts_array_replace_text(ArrayType *arr, const char *old, const char *new); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/catalog.c���������������������������������������������������������0000664�0000000�0000000�00000062367�15100345067�0020556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/pg_namespace.h> #include <commands/dbcommands.h> #include <commands/sequence.h> #include <miscadmin.h> #include <utils/builtins.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/regproc.h> #include <utils/syscache.h> #include "compat/compat.h" #include "cache_invalidate.h" #include "extension.h" #include "ts_catalog/catalog.h" #include "utils.h" static const TableInfoDef catalog_table_names[_MAX_CATALOG_TABLES + 1] = { [HYPERTABLE] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = HYPERTABLE_TABLE_NAME, }, [DIMENSION] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = DIMENSION_TABLE_NAME, }, [DIMENSION_SLICE] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = DIMENSION_SLICE_TABLE_NAME, }, [CHUNK] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CHUNK_TABLE_NAME, }, [CHUNK_CONSTRAINT] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CHUNK_CONSTRAINT_TABLE_NAME, }, [TABLESPACE] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = TABLESPACE_TABLE_NAME, }, [BGW_JOB] = { .schema_name = CONFIG_SCHEMA_NAME, .table_name = BGW_JOB_TABLE_NAME, }, [BGW_JOB_STAT] = { .schema_name = INTERNAL_SCHEMA_NAME, .table_name = BGW_JOB_STAT_TABLE_NAME, }, [BGW_JOB_STAT_HISTORY] = { .schema_name = INTERNAL_SCHEMA_NAME, .table_name = BGW_JOB_STAT_HISTORY_TABLE_NAME, }, [METADATA] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = METADATA_TABLE_NAME, }, [BGW_POLICY_CHUNK_STATS] = { .schema_name = INTERNAL_SCHEMA_NAME, .table_name = BGW_POLICY_CHUNK_STATS_TABLE_NAME, }, [CONTINUOUS_AGG] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGG_TABLE_NAME, }, [CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_TABLE_NAME, }, [CONTINUOUS_AGGS_INVALIDATION_THRESHOLD] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_TABLE_NAME, }, [CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_TABLE_NAME, }, [CONTINUOUS_AGGS_MATERIALIZATION_RANGES] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGGS_MATERIALIZATION_RANGES_TABLE_NAME, }, [COMPRESSION_SETTINGS] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = COMPRESSION_SETTINGS_TABLE_NAME, }, [COMPRESSION_CHUNK_SIZE] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = COMPRESSION_CHUNK_SIZE_TABLE_NAME, }, [CONTINUOUS_AGGS_BUCKET_FUNCTION] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGGS_BUCKET_FUNCTION_TABLE_NAME, }, [CONTINUOUS_AGGS_WATERMARK] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CONTINUOUS_AGGS_WATERMARK_TABLE_NAME, }, [TELEMETRY_EVENT] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = TELEMETRY_EVENT_TABLE_NAME, }, [CHUNK_COLUMN_STATS] = { .schema_name = CATALOG_SCHEMA_NAME, .table_name = CHUNK_COLUMN_STATS_TABLE_NAME, }, [_MAX_CATALOG_TABLES] = { .schema_name = "invalid schema", .table_name = "invalid table", } }; static const TableIndexDef catalog_table_index_definitions[_MAX_CATALOG_TABLES] = { [HYPERTABLE] = { .length = _MAX_HYPERTABLE_INDEX, .names = (char *[]) { [HYPERTABLE_ID_INDEX] = "hypertable_pkey", [HYPERTABLE_NAME_INDEX] = "hypertable_table_name_schema_name_key", }, }, [DIMENSION] = { .length = _MAX_DIMENSION_INDEX, .names = (char *[]) { [DIMENSION_ID_IDX] = "dimension_pkey", [DIMENSION_HYPERTABLE_ID_COLUMN_NAME_IDX] = "dimension_hypertable_id_column_name_key", }, }, [DIMENSION_SLICE] = { .length = _MAX_DIMENSION_SLICE_INDEX, .names = (char *[]) { [DIMENSION_SLICE_ID_IDX] = "dimension_slice_pkey", [DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX] = "dimension_slice_dimension_id_range_start_range_end_key", }, }, [CHUNK_COLUMN_STATS] = { .length = _MAX_CHUNK_COLUMN_STATS_INDEX, .names = (char *[]) { [CHUNK_COLUMN_STATS_ID_IDX] = "chunk_column_stats_pkey", [CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX] = "chunk_column_stats_ht_id_chunk_id_colname_key", }, }, [CHUNK] = { .length = _MAX_CHUNK_INDEX, .names = (char *[]) { [CHUNK_ID_INDEX] = "chunk_pkey", [CHUNK_HYPERTABLE_ID_INDEX] = "chunk_hypertable_id_idx", [CHUNK_SCHEMA_NAME_INDEX] = "chunk_schema_name_table_name_key", [CHUNK_COMPRESSED_CHUNK_ID_INDEX] = "chunk_compressed_chunk_id_idx", [CHUNK_OSM_CHUNK_INDEX] = "chunk_osm_chunk_idx", [CHUNK_HYPERTABLE_ID_CREATION_TIME_INDEX] = "chunk_hypertable_id_creation_time_idx", }, }, [CHUNK_CONSTRAINT] = { .length = _MAX_CHUNK_CONSTRAINT_INDEX, .names = (char *[]) { [CHUNK_CONSTRAINT_CHUNK_ID_CONSTRAINT_NAME_IDX] = "chunk_constraint_chunk_id_constraint_name_key", [CHUNK_CONSTRAINT_DIMENSION_SLICE_ID_IDX] = "chunk_constraint_dimension_slice_id_idx", }, }, [TABLESPACE] = { .length = _MAX_TABLESPACE_INDEX, .names = (char *[]) { [TABLESPACE_PKEY_IDX] = "tablespace_pkey", [TABLESPACE_HYPERTABLE_ID_TABLESPACE_NAME_IDX] = "tablespace_hypertable_id_tablespace_name_key", }, }, [BGW_JOB] = { .length = _MAX_BGW_JOB_INDEX, .names = (char *[]) { [BGW_JOB_PKEY_IDX] = "bgw_job_pkey", [BGW_JOB_PROC_HYPERTABLE_ID_IDX] = "bgw_job_proc_hypertable_id_idx", }, }, [BGW_JOB_STAT] = { .length = _MAX_BGW_JOB_STAT_INDEX, .names = (char *[]) { [BGW_JOB_STAT_PKEY_IDX] = "bgw_job_stat_pkey", }, }, [BGW_JOB_STAT_HISTORY] = { .length = _MAX_BGW_JOB_STAT_HISTORY_INDEX, .names = (char *[]) { [BGW_JOB_STAT_HISTORY_PKEY_IDX] = "bgw_job_stat_history_pkey", }, }, [METADATA] = { .length = _MAX_METADATA_INDEX, .names = (char *[]) { [METADATA_PKEY_IDX] = "metadata_pkey", }, }, [BGW_POLICY_CHUNK_STATS] = { .length = _MAX_BGW_POLICY_CHUNK_STATS_INDEX, .names = (char *[]) { [BGW_POLICY_CHUNK_STATS_JOB_ID_CHUNK_ID_IDX] = "bgw_policy_chunk_stats_job_id_chunk_id_key", } }, [CONTINUOUS_AGG] = { .length = _MAX_CONTINUOUS_AGG_INDEX, .names = (char *[]) { [CONTINUOUS_AGG_PARTIAL_VIEW_SCHEMA_PARTIAL_VIEW_NAME_KEY] = "continuous_agg_partial_view_schema_partial_view_name_key", [CONTINUOUS_AGG_PKEY] = TS_CAGG_CATALOG_IDX, [CONTINUOUS_AGG_USER_VIEW_SCHEMA_USER_VIEW_NAME_KEY] = "continuous_agg_user_view_schema_user_view_name_key", [CONTINUOUS_AGG_RAW_HYPERTABLE_ID_IDX] = "continuous_agg_raw_hypertable_id_idx" }, }, [CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG] = { .length = _MAX_CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_INDEX, .names = (char *[]) { [CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_IDX] = "continuous_aggs_hypertable_invalidation_log_idx", }, }, [CONTINUOUS_AGGS_INVALIDATION_THRESHOLD] = { .length = _MAX_CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_INDEX, .names = (char *[]) { [CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY] = "continuous_aggs_invalidation_threshold_pkey", }, }, [CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG] = { .length = _MAX_CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_INDEX, .names = (char *[]) { [CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_IDX] = "continuous_aggs_materialization_invalidation_log_idx", }, }, [CONTINUOUS_AGGS_MATERIALIZATION_RANGES] = { .length = _MAX_CONTINUOUS_AGGS_MATERIALIZATION_RANGES_INDEX, .names = (char *[]) { [CONTINUOUS_AGGS_MATERIALIZATION_RANGES_IDX] = "continuous_aggs_materialization_ranges_idx", }, }, [CONTINUOUS_AGGS_WATERMARK] = { .length = _MAX_CONTINUOUS_AGGS_WATERMARK_INDEX, .names = (char *[]) { [CONTINUOUS_AGGS_WATERMARK_PKEY] = "continuous_aggs_watermark_pkey", }, }, [COMPRESSION_SETTINGS] = { .length = _MAX_COMPRESSION_SETTINGS_INDEX, .names = (char *[]) { [COMPRESSION_SETTINGS_PKEY] = "compression_settings_pkey", [COMPRESSION_SETTINGS_COMPRESS_RELID_IDX] = "compression_settings_compress_relid_idx", }, }, [COMPRESSION_CHUNK_SIZE] = { .length = _MAX_COMPRESSION_CHUNK_SIZE_INDEX, .names = (char *[]) { [COMPRESSION_CHUNK_SIZE_PKEY] = "compression_chunk_size_pkey", }, }, [CONTINUOUS_AGGS_BUCKET_FUNCTION] = { .length = _MAX_CONTINUOUS_AGGS_BUCKET_FUNCTION_INDEX, .names = (char *[]) { [CONTINUOUS_AGGS_BUCKET_FUNCTION_PKEY_IDX] = "continuous_aggs_bucket_function_pkey", }, } }; static const char *catalog_table_serial_id_names[_MAX_CATALOG_TABLES] = { [HYPERTABLE] = CATALOG_SCHEMA_NAME ".hypertable_id_seq", [DIMENSION] = CATALOG_SCHEMA_NAME ".dimension_id_seq", [DIMENSION_SLICE] = CATALOG_SCHEMA_NAME ".dimension_slice_id_seq", [CHUNK] = CATALOG_SCHEMA_NAME ".chunk_id_seq", [CHUNK_CONSTRAINT] = CATALOG_SCHEMA_NAME ".chunk_constraint_name", [TABLESPACE] = CATALOG_SCHEMA_NAME ".tablespace_id_seq", [BGW_JOB] = CONFIG_SCHEMA_NAME ".bgw_job_id_seq", [BGW_JOB_STAT] = NULL, [BGW_JOB_STAT_HISTORY] = INTERNAL_SCHEMA_NAME ".bgw_job_stat_history_id_seq", [CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG] = NULL, [CONTINUOUS_AGGS_INVALIDATION_THRESHOLD] = NULL, [CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG] = NULL, [COMPRESSION_SETTINGS] = NULL, [COMPRESSION_CHUNK_SIZE] = NULL, [CHUNK_COLUMN_STATS] = CATALOG_SCHEMA_NAME ".chunk_column_stats_id_seq", }; typedef struct InternalFunctionDef { char *name; int args; } InternalFunctionDef; static const InternalFunctionDef internal_function_definitions[_MAX_INTERNAL_FUNCTIONS] = { [DDL_ADD_CHUNK_CONSTRAINT] = { .name = "chunk_constraint_add_table_constraint", .args = 1, }, [DDL_CONSTRAINT_CLONE] = { .name = "constraint_clone", .args = 2, }, }; /* Names for proxy tables used for cache invalidation. Must match names in * sql/cache.sql */ static const char *cache_proxy_table_names[_MAX_CACHE_TYPES] = { [CACHE_TYPE_HYPERTABLE] = "cache_inval_hypertable", [CACHE_TYPE_BGW_JOB] = "cache_inval_bgw_job", [CACHE_TYPE_EXTENSION] = "cache_inval_extension", }; /* Catalog information for the current database. */ static Catalog s_catalog = { .initialized = false, }; static CatalogDatabaseInfo database_info = { .database_id = InvalidOid, }; static bool catalog_is_valid(Catalog *catalog) { return catalog != NULL && catalog->initialized; } /* * Get the user ID of the catalog owner. */ static Oid catalog_owner(void) { HeapTuple tuple; Oid owner_oid; Oid nsp_oid = get_namespace_oid(CATALOG_SCHEMA_NAME, false); tuple = SearchSysCache1(NAMESPACEOID, ObjectIdGetDatum(nsp_oid)); if (!HeapTupleIsValid(tuple)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_SCHEMA), errmsg("schema with OID %u does not exist", nsp_oid))); owner_oid = ((Form_pg_namespace) GETSTRUCT(tuple))->nspowner; ReleaseSysCache(tuple); return owner_oid; } static const char * catalog_table_name(CatalogTable table) { return catalog_table_names[table].table_name; } static void catalog_database_info_init(CatalogDatabaseInfo *info) { info->database_id = MyDatabaseId; namestrcpy(&info->database_name, get_database_name(MyDatabaseId)); info->schema_id = get_namespace_oid(CATALOG_SCHEMA_NAME, false); info->owner_uid = catalog_owner(); if (!OidIsValid(info->schema_id)) elog(ERROR, "OID lookup failed for schema \"%s\"", CATALOG_SCHEMA_NAME); } TSDLLEXPORT CatalogDatabaseInfo * ts_catalog_database_info_get() { if (!ts_extension_is_loaded()) elog(ERROR, "tried calling catalog_database_info_get when extension isn't loaded"); if (!OidIsValid(database_info.database_id)) { if (!IsTransactionState()) elog(ERROR, "cannot initialize catalog_database_info outside of a transaction"); memset(&database_info, 0, sizeof(CatalogDatabaseInfo)); catalog_database_info_init(&database_info); } return &database_info; } /* * The rest of the arguments are used to populate the first arg. */ void ts_catalog_table_info_init(CatalogTableInfo *tables_info, int max_tables, const TableInfoDef *table_ary, const TableIndexDef *index_ary, const char **serial_id_ary) { int i; for (i = 0; i < max_tables; i++) { Oid id; const char *sequence_name; Size number_indexes, j; id = ts_get_relation_relid((char *) table_ary[i].schema_name, (char *) table_ary[i].table_name, false); if (!OidIsValid(id)) elog(ERROR, "OID lookup failed for table \"%s.%s\"", table_ary[i].schema_name, table_ary[i].table_name); tables_info[i].id = id; number_indexes = index_ary[i].length; Assert(number_indexes <= _MAX_TABLE_INDEXES); for (j = 0; j < number_indexes; j++) { id = ts_get_relation_relid(table_ary[i].schema_name, index_ary[i].names[j], true); if (!OidIsValid(id)) elog(ERROR, "OID lookup failed for table index \"%s\"", index_ary[i].names[j]); tables_info[i].index_ids[j] = id; } tables_info[i].name = table_ary[i].table_name; tables_info[i].schema_name = table_ary[i].schema_name; sequence_name = serial_id_ary[i]; if (NULL != sequence_name) { RangeVar *sequence; #if PG16_LT sequence = makeRangeVarFromNameList(stringToQualifiedNameList(sequence_name)); #else sequence = makeRangeVarFromNameList(stringToQualifiedNameList(sequence_name, NULL)); #endif tables_info[i].serial_relid = RangeVarGetRelid(sequence, NoLock, false); } else tables_info[i].serial_relid = InvalidOid; } } TSDLLEXPORT Catalog * ts_catalog_get(void) { int i; if (!OidIsValid(MyDatabaseId)) elog(ERROR, "invalid database ID"); if (!ts_extension_is_loaded()) elog(ERROR, "tried calling catalog_get when extension isn't loaded"); if (s_catalog.initialized || !IsTransactionState()) return &s_catalog; memset(&s_catalog, 0, sizeof(Catalog)); ts_catalog_table_info_init(s_catalog.tables, _MAX_CATALOG_TABLES, catalog_table_names, catalog_table_index_definitions, catalog_table_serial_id_names); for (i = 0; i < _TS_MAX_SCHEMA; i++) s_catalog.extension_schema_id[i] = get_namespace_oid(ts_extension_schema_names[i], false); for (i = 0; i < _MAX_CACHE_TYPES; i++) s_catalog.caches[i].inval_proxy_id = get_relname_relid(cache_proxy_table_names[i], s_catalog.extension_schema_id[TS_CACHE_SCHEMA]); ts_cache_invalidate_set_proxy_tables(s_catalog.caches[CACHE_TYPE_HYPERTABLE].inval_proxy_id, s_catalog.caches[CACHE_TYPE_BGW_JOB].inval_proxy_id); for (i = 0; i < _MAX_INTERNAL_FUNCTIONS; i++) { InternalFunctionDef def = internal_function_definitions[i]; FuncCandidateList funclist = FuncnameGetCandidates(list_make2(makeString(FUNCTIONS_SCHEMA_NAME), makeString(def.name)), def.args, NULL, false, false, /* include_out_arguments */ false, false); if (funclist == NULL || funclist->next) elog(ERROR, "OID lookup failed for the function \"%s\" with %d args", def.name, def.args); s_catalog.functions[i].function_id = funclist->oid; } s_catalog.initialized = true; return &s_catalog; } void ts_catalog_reset(void) { s_catalog.initialized = false; database_info.database_id = InvalidOid; ts_cache_invalidate_set_proxy_tables(InvalidOid, InvalidOid); } static CatalogTable catalog_get_table(Catalog *catalog, Oid relid) { unsigned int i; if (!catalog_is_valid(catalog)) { const char *schema_name = get_namespace_name(get_rel_namespace(relid)); const char *relname = get_rel_name(relid); for (i = 0; i < _MAX_CATALOG_TABLES; i++) if (strcmp(catalog_table_names[i].schema_name, schema_name) == 0 && strcmp(catalog_table_name(i), relname) == 0) return (CatalogTable) i; return INVALID_CATALOG_TABLE; } for (i = 0; i < _MAX_CATALOG_TABLES; i++) if (catalog->tables[i].id == relid) return (CatalogTable) i; return INVALID_CATALOG_TABLE; } bool ts_is_catalog_table(Oid relid) { return catalog_get_table(ts_catalog_get(), relid) != INVALID_CATALOG_TABLE; } /* * Get the next serial ID for a catalog table, if one exists for the given table. */ TSDLLEXPORT int64 ts_catalog_table_next_seq_id(const Catalog *catalog, CatalogTable table) { Oid relid = catalog->tables[table].serial_relid; if (!OidIsValid(relid)) elog(ERROR, "no serial ID column for table \"%s.%s\"", catalog_table_names[table].schema_name, catalog_table_name(table)); return DatumGetInt64(DirectFunctionCall1(nextval_oid, ObjectIdGetDatum(relid))); } Oid ts_catalog_get_cache_proxy_id(Catalog *catalog, CacheType type) { if (!catalog_is_valid(catalog)) { /* * The catalog can be invalid during upgrade scripts. Try a non-cached * relation lookup, but we need to be in a transaction for * get_namespace_oid() to work. */ if (!IsTransactionState()) return InvalidOid; return ts_get_relation_relid(CACHE_SCHEMA_NAME, (char *) cache_proxy_table_names[type], true); } return catalog->caches[type].inval_proxy_id; } /* * Become the user that owns the catalog schema. * * This might be necessary for users that do operations that require changes to * the catalog. * * The caller should pass a CatalogSecurityContext where the current security * context will be saved. The original security context can later be restored * with ts_catalog_restore_user(). */ TSDLLEXPORT bool ts_catalog_database_info_become_owner(CatalogDatabaseInfo *database_info, CatalogSecurityContext *sec_ctx) { GetUserIdAndSecContext(&sec_ctx->saved_uid, &sec_ctx->saved_security_context); if (sec_ctx->saved_uid != database_info->owner_uid) { SetUserIdAndSecContext(database_info->owner_uid, sec_ctx->saved_security_context | SECURITY_LOCAL_USERID_CHANGE); return true; } return false; } /* * Restore the security context of the original user after becoming the catalog * owner. The user should pass the original CatalogSecurityContext that was used * with ts_catalog_database_info_become_owner(). */ TSDLLEXPORT void ts_catalog_restore_user(CatalogSecurityContext *sec_ctx) { SetUserIdAndSecContext(sec_ctx->saved_uid, sec_ctx->saved_security_context); } /* * Insert a new row into a catalog table. */ void ts_catalog_insert_only(Relation rel, HeapTuple tuple) { CatalogTupleInsert(rel, tuple); ts_catalog_invalidate_cache(RelationGetRelid(rel), CMD_INSERT); } void ts_catalog_insert(Relation rel, HeapTuple tuple) { ts_catalog_insert_only(rel, tuple); /* Make changes visible */ CommandCounterIncrement(); } /* * Insert a new row into a catalog table. */ TSDLLEXPORT void ts_catalog_insert_values(Relation rel, TupleDesc tupdesc, Datum *values, bool *nulls) { HeapTuple tuple = heap_form_tuple(tupdesc, values, nulls); ts_catalog_insert(rel, tuple); heap_freetuple(tuple); } TSDLLEXPORT void ts_catalog_insert_datums(Relation rel, TupleDesc tupdesc, NullableDatum *datums) { HeapTuple tuple = ts_heap_form_tuple(tupdesc, datums); ts_catalog_insert(rel, tuple); heap_freetuple(tuple); } void ts_catalog_update_tid_only(Relation rel, ItemPointer tid, HeapTuple tuple) { CatalogTupleUpdate(rel, tid, tuple); ts_catalog_invalidate_cache(RelationGetRelid(rel), CMD_UPDATE); } void ts_catalog_update_tid(Relation rel, ItemPointer tid, HeapTuple tuple) { ts_catalog_update_tid_only(rel, tid, tuple); /* Make changes visible */ CommandCounterIncrement(); } TSDLLEXPORT void ts_catalog_update(Relation rel, HeapTuple tuple) { ts_catalog_update_tid(rel, &tuple->t_self, tuple); } void ts_catalog_delete_tid_only(Relation rel, ItemPointer tid) { CatalogTupleDelete(rel, tid); ts_catalog_invalidate_cache(RelationGetRelid(rel), CMD_DELETE); } void ts_catalog_delete_tid(Relation rel, ItemPointer tid) { ts_catalog_delete_tid_only(rel, tid); CommandCounterIncrement(); } /* * Invalidate TimescaleDB catalog caches. * * This function should be called whenever a TimescaleDB catalog table changes * in a way that might invalidate associated caches. It is currently called in * two distinct ways: * * 1. If a catalog table changes via the catalog API in catalog.c * 2. Via a trigger if a SQL INSERT/UPDATE/DELETE occurs on a catalog table * * Since triggers (2) require full parsing, planning and execution of SQL * statements, they aren't supported for simple catalog updates via (1) in * native code and are therefore discouraged. Ideally, catalog updates should * happen consistently via method (1) in the future, obviating the need for * triggers on catalog tables that cause side effects. * * The invalidation event is signaled to other backends (processes) via the * relcache invalidation mechanism on a dummy relation (table). * * Parameters: The OID of the catalog table that changed, and the operation * involved (e.g., INSERT, UPDATE, DELETE). */ void ts_catalog_invalidate_cache(Oid catalog_relid, CmdType operation) { Catalog *catalog = ts_catalog_get(); CatalogTable table = catalog_get_table(catalog, catalog_relid); Oid relid; switch (table) { case CHUNK: case CHUNK_CONSTRAINT: case DIMENSION_SLICE: if (operation == CMD_UPDATE || operation == CMD_DELETE) { relid = ts_catalog_get_cache_proxy_id(catalog, CACHE_TYPE_HYPERTABLE); CacheInvalidateRelcacheByRelid(relid); } break; case HYPERTABLE: case DIMENSION: case CONTINUOUS_AGG: case CHUNK_COLUMN_STATS: relid = ts_catalog_get_cache_proxy_id(catalog, CACHE_TYPE_HYPERTABLE); CacheInvalidateRelcacheByRelid(relid); break; case BGW_JOB: relid = ts_catalog_get_cache_proxy_id(catalog, CACHE_TYPE_BGW_JOB); CacheInvalidateRelcacheByRelid(relid); break; default: break; } } /* Scanner helper functions specifically for the catalog tables */ TSDLLEXPORT bool ts_catalog_scan_one(CatalogTable table, int indexid, ScanKeyData *scankey, int num_keys, tuple_found_func tuple_found, LOCKMODE lockmode, char *table_name, void *data) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, table), .index = catalog_get_index(catalog, table, indexid), .nkeys = num_keys, .scankey = scankey, .tuple_found = tuple_found, .data = data, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; return ts_scanner_scan_one(&scanctx, false, table_name); } TSDLLEXPORT void ts_catalog_scan_all(CatalogTable table, int indexid, ScanKeyData *scankey, int num_keys, tuple_found_func tuple_found, LOCKMODE lockmode, void *data) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, table), .index = catalog_get_index(catalog, table, indexid), .nkeys = num_keys, .scankey = scankey, .tuple_found = tuple_found, .data = data, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; ts_scanner_scan(&scanctx); } /* * Copied verbatim from postgres source CatalogIndexInsert which is static * in postgres source code. * We need to have this function available because we do not want to use * simple_heap_insert which is used by CatalogTupleInsert which would * prevent using bulk inserts. */ extern TSDLLEXPORT void ts_catalog_index_insert(ResultRelInfo *indstate, HeapTuple heapTuple) { int i; int numIndexes; RelationPtr relationDescs; Relation heapRelation; TupleTableSlot *slot; IndexInfo **indexInfoArray; Datum values[INDEX_MAX_KEYS]; bool isnull[INDEX_MAX_KEYS]; /* * HOT update does not require index inserts. But with asserts enabled we * want to check that it'd be legal to currently insert into the * table/index. */ #ifndef USE_ASSERT_CHECKING if (HeapTupleIsHeapOnly(heapTuple)) return; #endif /* * Get information from the state structure. Fall out if nothing to do. */ numIndexes = indstate->ri_NumIndices; if (numIndexes == 0) return; relationDescs = indstate->ri_IndexRelationDescs; indexInfoArray = indstate->ri_IndexRelationInfo; heapRelation = indstate->ri_RelationDesc; /* Need a slot to hold the tuple being examined */ slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation), &TTSOpsHeapTuple); ExecStoreHeapTuple(heapTuple, slot, false); /* * for each index, form and insert the index tuple */ for (i = 0; i < numIndexes; i++) { IndexInfo *indexInfo; Relation index; indexInfo = indexInfoArray[i]; index = relationDescs[i]; /* If the index is marked as read-only, ignore it */ if (!indexInfo->ii_ReadyForInserts) continue; /* * Expressional and partial indexes on system catalogs are not * supported, nor exclusion constraints, nor deferred uniqueness */ Assert(indexInfo->ii_Expressions == NIL); Assert(indexInfo->ii_Predicate == NIL); Assert(indexInfo->ii_ExclusionOps == NULL); Assert(index->rd_index->indimmediate); Assert(indexInfo->ii_NumIndexKeyAttrs != 0); /* see earlier check above */ #ifdef USE_ASSERT_CHECKING if (HeapTupleIsHeapOnly(heapTuple)) { Assert(!ReindexIsProcessingIndex(RelationGetRelid(index))); continue; } #endif /* USE_ASSERT_CHECKING */ /* * FormIndexDatum fills in its values and isnull parameters with the * appropriate values for the column(s) of the index. */ FormIndexDatum(indexInfo, slot, NULL, /* no expression eval to do */ values, isnull); /* * The index AM does the rest. */ index_insert(index, /* index relation */ values, /* array of index Datums */ isnull, /* is-null flags */ &(heapTuple->t_self), /* tid of heap tuple */ heapRelation, index->rd_index->indisunique ? UNIQUE_CHECK_YES : UNIQUE_CHECK_NO, false, indexInfo); } ExecDropSingleTupleTableSlot(slot); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/catalog.h���������������������������������������������������������0000664�0000000�0000000�00000116760�15100345067�0020560�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/heapam.h> #include <nodes/nodes.h> #include <utils/jsonb.h> #include <utils/rel.h> #include "export.h" #include "extension_constants.h" #include "scanner.h" /* * TimescaleDB catalog. * * The TimescaleDB catalog contains schema metadata for hypertables, among other * things. The metadata is stored in regular tables. This header file contains * definitions for those tables and should match any table declarations in * sql/pre_install/tables.sql. * * A source file that includes this header has access to a catalog object, * which contains cached information about catalog tables, such as relation * OIDs. * * Generally, definitions and naming should roughly follow how things are done * in Postgres internally. */ typedef enum CatalogTable { HYPERTABLE = 0, DIMENSION, DIMENSION_SLICE, CHUNK, CHUNK_CONSTRAINT, TABLESPACE, BGW_JOB, BGW_JOB_STAT, BGW_JOB_STAT_HISTORY, METADATA, BGW_POLICY_CHUNK_STATS, CONTINUOUS_AGG, CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG, CONTINUOUS_AGGS_MATERIALIZATION_RANGES, COMPRESSION_SETTINGS, COMPRESSION_CHUNK_SIZE, CONTINUOUS_AGGS_BUCKET_FUNCTION, CONTINUOUS_AGGS_WATERMARK, TELEMETRY_EVENT, CHUNK_COLUMN_STATS, /* Don't forget updating catalog.c when adding new tables! */ _MAX_CATALOG_TABLES, } CatalogTable; typedef struct TableInfoDef { const char *schema_name; const char *table_name; } TableInfoDef; typedef struct TableIndexDef { int length; char **names; } TableIndexDef; #define TS_CAGG_CATALOG_IDX "continuous_agg_pkey" #define INVALID_CATALOG_TABLE _MAX_CATALOG_TABLES #define INVALID_INDEXID -1 #define CATALOG_INTERNAL_FUNC(catalog, func) (catalog->functions[func].function_id) #define CatalogInternalCall1(func, datum1) \ OidFunctionCall1(CATALOG_INTERNAL_FUNC(ts_catalog_get(), func), datum1) #define CatalogInternalCall2(func, datum1, datum2) \ OidFunctionCall2(CATALOG_INTERNAL_FUNC(ts_catalog_get(), func), datum1, datum2) #define CatalogInternalCall3(func, datum1, datum2, datum3) \ OidFunctionCall3(CATALOG_INTERNAL_FUNC(ts_catalog_get(), func), datum1, datum2, datum3) #define CatalogInternalCall4(func, datum1, datum2, datum3, datum4) \ OidFunctionCall4(CATALOG_INTERNAL_FUNC(ts_catalog_get(), func), datum1, datum2, datum3, datum4) typedef enum InternalFunction { DDL_ADD_CHUNK_CONSTRAINT, DDL_CONSTRAINT_CLONE, _MAX_INTERNAL_FUNCTIONS, } InternalFunction; /****************************** * * Hypertable table definitions * ******************************/ #define HYPERTABLE_TABLE_NAME "hypertable" /* Hypertable table attribute numbers */ enum Anum_hypertable { Anum_hypertable_id = 1, Anum_hypertable_schema_name, Anum_hypertable_table_name, Anum_hypertable_associated_schema_name, Anum_hypertable_associated_table_prefix, Anum_hypertable_num_dimensions, Anum_hypertable_chunk_sizing_func_schema, Anum_hypertable_chunk_sizing_func_name, Anum_hypertable_chunk_target_size, Anum_hypertable_compression_state, Anum_hypertable_compressed_hypertable_id, Anum_hypertable_status, _Anum_hypertable_max, }; #define Natts_hypertable (_Anum_hypertable_max - 1) typedef struct FormData_hypertable { int32 id; NameData schema_name; NameData table_name; NameData associated_schema_name; NameData associated_table_prefix; int16 num_dimensions; NameData chunk_sizing_func_schema; NameData chunk_sizing_func_name; int64 chunk_target_size; int16 compression_state; int32 compressed_hypertable_id; int32 status; } FormData_hypertable; typedef FormData_hypertable *Form_hypertable; /* Hypertable primary index attribute numbers */ enum Anum_hypertable_pkey_idx { Anum_hypertable_pkey_idx_id = 1, _Anum_hypertable_pkey_max, }; #define Natts_hypertable_pkey_idx (_Anum_hypertable_pkey_max - 1) /* Hypertable name (schema,table) index attribute numbers */ enum Anum_hypertable_name_idx { Anum_hypertable_name_idx_table = 1, Anum_hypertable_name_idx_schema, _Anum_hypertable_name_max, }; #define Natts_hypertable_name_idx (_Anum_hypertable_name_max - 1) enum { HYPERTABLE_ID_INDEX = 0, HYPERTABLE_NAME_INDEX, _MAX_HYPERTABLE_INDEX, }; /****************************** * * Dimension table definitions * ******************************/ #define DIMENSION_TABLE_NAME "dimension" enum Anum_dimension { Anum_dimension_id = 1, Anum_dimension_hypertable_id, Anum_dimension_column_name, Anum_dimension_column_type, Anum_dimension_aligned, Anum_dimension_num_slices, Anum_dimension_partitioning_func_schema, Anum_dimension_partitioning_func, Anum_dimension_interval_length, Anum_dimension_compress_interval_length, Anum_dimension_integer_now_func_schema, Anum_dimension_integer_now_func, _Anum_dimension_max, }; #define Natts_dimension (_Anum_dimension_max - 1) typedef struct FormData_dimension { int32 id; int32 hypertable_id; NameData column_name; Oid column_type; bool aligned; /* closed (space) columns */ int16 num_slices; NameData partitioning_func_schema; NameData partitioning_func; /* open (time) columns */ int64 interval_length; int64 compress_interval_length; NameData integer_now_func_schema; NameData integer_now_func; } FormData_dimension; typedef FormData_dimension *Form_dimension; enum Anum_dimension_id_idx { Anum_dimension_id_idx_id = 1, _Anum_dimension_id_idx_max, }; #define Natts_dimension_id_idx (_Anum_dimension_id_idx_max - 1) enum Anum_dimension_hypertable_id_column_name_idx { Anum_dimension_hypertable_id_column_name_idx_hypertable_id = 1, Anum_dimension_hypertable_id_column_name_idx_column_name, _Anum_dimension_hypertable_id_idx_max, }; #define Natts_dimension_hypertable_id_idx (_Anum_dimension_hypertable_id_idx_max - 1) enum { DIMENSION_ID_IDX = 0, DIMENSION_HYPERTABLE_ID_COLUMN_NAME_IDX, _MAX_DIMENSION_INDEX, }; /****************************** * * Dimension slice table definitions * ******************************/ #define DIMENSION_SLICE_TABLE_NAME "dimension_slice" enum Anum_dimension_slice { Anum_dimension_slice_id = 1, Anum_dimension_slice_dimension_id, Anum_dimension_slice_range_start, Anum_dimension_slice_range_end, _Anum_dimension_slice_max, }; #define Natts_dimension_slice (_Anum_dimension_slice_max - 1) typedef struct FormData_dimension_slice { int32 id; int32 dimension_id; int64 range_start; int64 range_end; } FormData_dimension_slice; typedef FormData_dimension_slice *Form_dimension_slice; enum Anum_dimension_slice_id_idx { Anum_dimension_slice_id_idx_id = 1, _Anum_dimension_slice_id_idx_max, }; #define Natts_dimension_slice_id_idx (_Anum_dimension_slice_id_idx_max - 1) enum Anum_dimension_slice_dimension_id_range_start_range_end_idx { Anum_dimension_slice_dimension_id_range_start_range_end_idx_dimension_id = 1, Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_start, Anum_dimension_slice_dimension_id_range_start_range_end_idx_range_end, _Anum_dimension_slice_dimension_id_range_start_range_end_idx_max, }; #define Natts_dimension_slice_dimension_id_range_start_range_end_idx \ (_Anum_dimension_slice_dimension_id_range_start_range_end_idx_max - 1) enum { DIMENSION_SLICE_ID_IDX = 0, DIMENSION_SLICE_DIMENSION_ID_RANGE_START_RANGE_END_IDX, _MAX_DIMENSION_SLICE_INDEX, }; /****************************** * * Dimension range table definitions * ******************************/ #define CHUNK_COLUMN_STATS_TABLE_NAME "chunk_column_stats" enum Anum_chunk_column_stats { Anum_chunk_column_stats_id = 1, Anum_chunk_column_stats_hypertable_id, Anum_chunk_column_stats_chunk_id, Anum_chunk_column_stats_column_name, Anum_chunk_column_stats_range_start, Anum_chunk_column_stats_range_end, Anum_chunk_column_stats_valid, _Anum_chunk_column_stats_max, }; #define Natts_chunk_column_stats (_Anum_chunk_column_stats_max - 1) typedef struct FormData_chunk_column_stats { int32 id; int32 hypertable_id; int32 chunk_id; NameData column_name; int64 range_start; int64 range_end; bool valid; } FormData_chunk_column_stats; typedef FormData_chunk_column_stats *Form_chunk_column_stats; enum Anum_chunk_column_stats_id_idx { Anum_chunk_column_stats_id_idx_id = 1, _Anum_chunk_column_stats_id_idx_max, }; #define Natts_chunk_column_stats_id_idx (_Anum_chunk_column_stats_id_idx_max - 1) enum Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx { Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id = 1, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_column_name, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_range_start, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_range_end, _Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_max, }; #define Natts_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx \ (_Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_max - 1) enum { CHUNK_COLUMN_STATS_ID_IDX = 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, _MAX_CHUNK_COLUMN_STATS_INDEX, }; /************************* * * Chunk table definitions * *************************/ #define CHUNK_TABLE_NAME "chunk" enum Anum_chunk { Anum_chunk_id = 1, Anum_chunk_hypertable_id, Anum_chunk_schema_name, Anum_chunk_table_name, Anum_chunk_compressed_chunk_id, Anum_chunk_dropped, Anum_chunk_status, Anum_chunk_osm_chunk, Anum_chunk_creation_time, _Anum_chunk_max, }; #define Natts_chunk (_Anum_chunk_max - 1) typedef struct FormData_chunk { int32 id; int32 hypertable_id; NameData schema_name; NameData table_name; int32 compressed_chunk_id; bool dropped; int32 status; bool osm_chunk; TimestampTz creation_time; } FormData_chunk; typedef FormData_chunk *Form_chunk; enum { CHUNK_ID_INDEX = 0, CHUNK_HYPERTABLE_ID_INDEX, CHUNK_SCHEMA_NAME_INDEX, CHUNK_COMPRESSED_CHUNK_ID_INDEX, CHUNK_OSM_CHUNK_INDEX, CHUNK_HYPERTABLE_ID_CREATION_TIME_INDEX, _MAX_CHUNK_INDEX, }; enum Anum_chunk_idx { Anum_chunk_idx_id = 1, }; enum Anum_chunk_hypertable_id_idx { Anum_chunk_hypertable_id_idx_hypertable_id = 1, }; enum Anum_chunk_compressed_chunk_id_idx { Anum_chunk_compressed_chunk_id_idx_compressed_chunk_id = 1, }; enum Anum_chunk_schema_name_idx { Anum_chunk_schema_name_idx_schema_name = 1, Anum_chunk_schema_name_idx_table_name, }; enum Anum_chunk_osm_chunk_idx { Anum_chunk_osm_chunk_idx_osm_chunk = 1, Anum_chunk_osm_chunk_idx_hypertable_id, }; enum Anum_chunk_hypertable_id_creation_time_idx { Anum_chunk_hypertable_id_creation_time_idx_hypertable_id = 1, Anum_chunk_hypertable_id_creation_time_idx_creation_time, }; /************************************ * * Chunk constraint table definitions * ************************************/ #define CHUNK_CONSTRAINT_TABLE_NAME "chunk_constraint" enum Anum_chunk_constraint { Anum_chunk_constraint_chunk_id = 1, Anum_chunk_constraint_dimension_slice_id, Anum_chunk_constraint_constraint_name, Anum_chunk_constraint_hypertable_constraint_name, _Anum_chunk_constraint_max, }; #define Natts_chunk_constraint (_Anum_chunk_constraint_max - 1) /* Do Not use GET_STRUCT with FormData_chunk_constraint. It contains NULLS */ typedef struct FormData_chunk_constraint { int32 chunk_id; int32 dimension_slice_id; NameData constraint_name; NameData hypertable_constraint_name; } FormData_chunk_constraint; typedef FormData_chunk_constraint *Form_chunk_constraint; enum { CHUNK_CONSTRAINT_CHUNK_ID_CONSTRAINT_NAME_IDX = 0, CHUNK_CONSTRAINT_DIMENSION_SLICE_ID_IDX, _MAX_CHUNK_CONSTRAINT_INDEX, }; enum Anum_chunk_constraint_dimension_slice_id_idx { Anum_chunk_constraint_dimension_slice_id_idx_dimension_slice_id = 1, _Anum_chunk_constraint_dimension_slice_id_idx_max, }; enum Anum_chunk_constraint_chunk_id_constraint_name_idx { Anum_chunk_constraint_chunk_id_constraint_name_idx_chunk_id = 1, Anum_chunk_constraint_chunk_id_constraint_name_idx_constraint_name, _Anum_chunk_constraint_chunk_id_constraint_name_idx_max, }; /************************************ * * Tablespace table definitions * ************************************/ #define TABLESPACE_TABLE_NAME "tablespace" enum Anum_tablespace { Anum_tablespace_id = 1, Anum_tablespace_hypertable_id, Anum_tablespace_tablespace_name, _Anum_tablespace_max, }; #define Natts_tablespace (_Anum_tablespace_max - 1) typedef struct FormData_tablespace { int32 id; int32 hypertable_id; NameData tablespace_name; } FormData_tablespace; typedef FormData_tablespace *Form_tablespace; enum { TABLESPACE_PKEY_IDX = 0, TABLESPACE_HYPERTABLE_ID_TABLESPACE_NAME_IDX, _MAX_TABLESPACE_INDEX, }; enum Anum_tablespace_pkey_idx { Anum_tablespace_pkey_idx_tablespace_id = 1, _Anum_tablespace_pkey_idx_max, }; typedef struct FormData_tablespace_pkey_idx { int32 tablespace_id; } FormData_tablespace_pkey_idx; enum Anum_tablespace_hypertable_id_tablespace_name_idx { Anum_tablespace_hypertable_id_tablespace_name_idx_hypertable_id = 1, Anum_tablespace_hypertable_id_tablespace_name_idx_tablespace_name, _Anum_tablespace_hypertable_id_tablespace_name_idx_max, }; typedef struct FormData_tablespace_hypertable_id_tablespace_name_idx { int32 hypertable_id; NameData tablespace_name; } FormData_tablespace_hypertable_id_tablespace_name_idx; /************************************ * * bgw_job table definitions * ************************************/ #define BGW_JOB_TABLE_NAME "bgw_job" enum Anum_bgw_job { Anum_bgw_job_id = 1, Anum_bgw_job_application_name, Anum_bgw_job_schedule_interval, Anum_bgw_job_max_runtime, Anum_bgw_job_max_retries, Anum_bgw_job_retry_period, Anum_bgw_job_proc_schema, Anum_bgw_job_proc_name, Anum_bgw_job_owner, Anum_bgw_job_scheduled, Anum_bgw_job_fixed_schedule, Anum_bgw_job_initial_start, Anum_bgw_job_hypertable_id, Anum_bgw_job_config, Anum_bgw_job_check_schema, Anum_bgw_job_check_name, Anum_bgw_job_timezone, _Anum_bgw_job_max, }; #define Natts_bgw_job (_Anum_bgw_job_max - 1) /* fixed_schedule needs to come before the varlen fields for GETSTRUCT to work */ typedef struct FormData_bgw_job { int32 id; NameData application_name; Interval schedule_interval; Interval max_runtime; int32 max_retries; Interval retry_period; NameData proc_schema; NameData proc_name; Oid owner; bool scheduled; bool fixed_schedule; TimestampTz initial_start; int32 hypertable_id; Jsonb *config; NameData check_schema; NameData check_name; text *timezone; } FormData_bgw_job; typedef FormData_bgw_job *Form_bgw_job; enum { BGW_JOB_PKEY_IDX = 0, BGW_JOB_PROC_HYPERTABLE_ID_IDX, _MAX_BGW_JOB_INDEX, }; enum Anum_bgw_job_pkey_idx { Anum_bgw_job_pkey_idx_id = 1, _Anum_bgw_job_pkey_idx_max, }; #define Natts_bjw_job_pkey_idx (_Anum_bgw_job_pkey_idx_max - 1) enum Anum_bgw_job_proc_hypertable_id_idx { Anum_bgw_job_proc_hypertable_id_idx_proc_schema = 1, Anum_bgw_job_proc_hypertable_id_idx_proc_name, Anum_bgw_job_proc_hypertable_id_idx_hypertable_id, _Anum_bgw_job_proc_hypertable_id_idx_max, }; #define Natts_bgw_job_proc_hypertable_id_idx (_Anum_bgw_job_proc_hypertable_id_idx_max - 1) /************************************ * * bgw_job_stat table definitions * ************************************/ #define BGW_JOB_STAT_TABLE_NAME "bgw_job_stat" enum Anum_bgw_job_stat { Anum_bgw_job_stat_job_id = 1, Anum_bgw_job_stat_last_start, Anum_bgw_job_stat_last_finish, Anum_bgw_job_stat_next_start, Anum_bgw_job_stat_last_successful_finish, Anum_bgw_job_stat_last_run_success, Anum_bgw_job_stat_total_runs, Anum_bgw_job_stat_total_duration, Anum_bgw_job_stat_total_duration_failures, Anum_bgw_job_stat_total_success, Anum_bgw_job_stat_total_failures, Anum_bgw_job_stat_total_crashes, Anum_bgw_job_stat_consecutive_failures, Anum_bgw_job_stat_consecutive_crashes, Anum_bgw_job_stat_flags, _Anum_bgw_job_stat_max, }; #define Natts_bgw_job_stat (_Anum_bgw_job_stat_max - 1) typedef struct FormData_bgw_job_stat { int32 id; TimestampTz last_start; TimestampTz last_finish; TimestampTz next_start; TimestampTz last_successful_finish; bool last_run_success; int64 total_runs; Interval total_duration; Interval total_duration_failures; int64 total_success; int64 total_failures; int64 total_crashes; int32 consecutive_failures; int32 consecutive_crashes; int32 flags; } FormData_bgw_job_stat; typedef FormData_bgw_job_stat *Form_bgw_job_stat; enum { BGW_JOB_STAT_PKEY_IDX = 0, _MAX_BGW_JOB_STAT_INDEX, }; enum Anum_bgw_job_stat_pkey_idx { Anum_bgw_job_stat_pkey_idx_job_id = 1, _Anum_bgw_job_stat_pkey_idx_max, }; #define Natts_bjw_job_stat_pkey_idx (_Anum_bgw_job_stat_pkey_idx_max - 1) #define BGW_JOB_STAT_HISTORY_TABLE_NAME "bgw_job_stat_history" enum Anum_bgw_job_stat_history { Anum_bgw_job_stat_history_id = 1, Anum_bgw_job_stat_history_job_id, Anum_bgw_job_stat_history_pid, Anum_bgw_job_stat_history_execution_start, Anum_bgw_job_stat_history_execution_finish, Anum_bgw_job_stat_history_succeeded, Anum_bgw_job_stat_history_data, _Anum_bgw_job_stat_history_max, }; #define Natts_bgw_job_stat_history (_Anum_bgw_job_stat_history_max - 1) typedef struct FormData_bgw_job_stat_history { int64 id; int32 job_id; int32 pid; TimestampTz execution_start; TimestampTz execution_finish; bool succeeded; Jsonb *data; } FormData_bgw_job_stat_history; typedef FormData_bgw_job_stat_history *Form_bgw_job_stat_history; enum { BGW_JOB_STAT_HISTORY_PKEY_IDX = 0, _MAX_BGW_JOB_STAT_HISTORY_INDEX, }; enum Anum_bgw_job_stat_history_pkey_idx { Anum_bgw_job_stat_history_pkey_idx_id = 1, _Anum_bgw_job_stat_history_pkey_idx_max, }; #define Natts_bjw_job_stat_history_pkey_idx (_Anum_bgw_job_stat_history_pkey_idx_max - 1) /****************************** * * metadata table definitions * ******************************/ #define METADATA_TABLE_NAME "metadata" enum Anum_metadata { Anum_metadata_key = 1, Anum_metadata_value, Anum_metadata_include_in_telemetry, _Anum_metadata_max, }; #define Natts_metadata (_Anum_metadata_max - 1) typedef struct FormData_metadata { NameData key; text *value; } FormData_metadata; typedef FormData_metadata *Form_metadata; /* metadata primary index attribute numbers */ enum Anum_metadata_pkey_idx { Anum_metadata_pkey_idx_id = 1, _Anum_metadata_pkey_max, }; #define Natts_metadata_pkey_idx (_Anum_metadata_pkey_max - 1) enum { METADATA_PKEY_IDX = 0, _MAX_METADATA_INDEX, }; /* * telemetry_event table definition */ #define TELEMETRY_EVENT_TABLE_NAME "telemetry_event" enum Anum_telemetry_event { Anum_telemetry_event_created = 1, Anum_telemetry_event_tag, Anum_telemetry_event_body, _Anum_telemetry_event_max, }; #define Natts_telemetry_event_max (_Anum_telemetry_event_max - 1) /****** BGW_POLICY_CHUNK_STATS TABLE definitions */ #define BGW_POLICY_CHUNK_STATS_TABLE_NAME "bgw_policy_chunk_stats" enum Anum_bgw_policy_chunk_stats { Anum_bgw_policy_chunk_stats_job_id = 1, Anum_bgw_policy_chunk_stats_chunk_id, Anum_bgw_policy_chunk_stats_num_times_job_run, Anum_bgw_policy_chunk_stats_last_time_job_run, _Anum_bgw_policy_chunk_stats_max, }; #define Natts_bgw_policy_chunk_stats (_Anum_bgw_policy_chunk_stats_max - 1) typedef struct FormData_bgw_policy_chunk_stats { int32 job_id; int32 chunk_id; int32 num_times_job_run; TimestampTz last_time_job_run; } FormData_bgw_policy_chunk_stats; typedef FormData_bgw_policy_chunk_stats *Form_bgw_job_chunk_stats; enum { BGW_POLICY_CHUNK_STATS_JOB_ID_CHUNK_ID_IDX = 0, _MAX_BGW_POLICY_CHUNK_STATS_INDEX, }; enum Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx { Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_job_id = 1, Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_chunk_id, _Anum_bgw_policy_chunk_stats_job_id_chunk_id_idx_max, }; typedef struct FormData_bgw_policy_chunk_stats_job_id_chunk_id_idx { int32 job_id; int32 chunk_id; } FormData_bgw_policy_chunk_stats_job_id_chunk_id_idx; /****************************************** * * continuous_agg table definitions * ******************************************/ #define CONTINUOUS_AGG_TABLE_NAME "continuous_agg" typedef enum Anum_continuous_agg { Anum_continuous_agg_mat_hypertable_id = 1, Anum_continuous_agg_raw_hypertable_id, Anum_continuous_agg_parent_mat_hypertable_id, Anum_continuous_agg_user_view_schema, Anum_continuous_agg_user_view_name, Anum_continuous_agg_partial_view_schema, Anum_continuous_agg_partial_view_name, Anum_continuous_agg_direct_view_schema, Anum_continuous_agg_direct_view_name, Anum_continuous_agg_materialize_only, Anum_continuous_agg_finalized, _Anum_continuous_agg_max, } Anum_continuous_agg; #define Natts_continuous_agg (_Anum_continuous_agg_max - 1) typedef struct FormData_continuous_agg { int32 mat_hypertable_id; int32 raw_hypertable_id; int32 parent_mat_hypertable_id; /* Nested Continuous Aggregate */ NameData user_view_schema; NameData user_view_name; NameData partial_view_schema; NameData partial_view_name; NameData direct_view_schema; NameData direct_view_name; bool materialized_only; bool finalized; } FormData_continuous_agg; typedef FormData_continuous_agg *Form_continuous_agg; enum { CONTINUOUS_AGG_PARTIAL_VIEW_SCHEMA_PARTIAL_VIEW_NAME_KEY = 0, CONTINUOUS_AGG_PKEY, CONTINUOUS_AGG_USER_VIEW_SCHEMA_USER_VIEW_NAME_KEY, CONTINUOUS_AGG_RAW_HYPERTABLE_ID_IDX, _MAX_CONTINUOUS_AGG_INDEX, }; typedef enum Anum_continuous_agg_partial_view_schema_partial_view_name_key { Anum_continuous_agg_partial_view_schema_partial_view_name_key_partial_view_schema = 1, Anum_continuous_agg_partial_view_schema_partial_view_name_key_partial_view_name, _Anum_continuous_agg_partial_view_schema_partial_view_name_key_max, } Anum_continuous_agg_partial_view_schema_partial_view_name_key; #define Natts_continuous_agg_partial_view_schema_partial_view_name_key \ (_Anum_continuous_agg_partial_view_schema_partial_view_name_key_max - 1) typedef enum Anum_continuous_agg_pkey { Anum_continuous_agg_pkey_mat_hypertable_id = 1, _Anum_continuous_agg_pkey_max, } Anum_continuous_agg_pkey; #define Natts_continuous_agg_pkey (_Anum_continuous_agg_pkey_max - 1) typedef enum Anum_continuous_agg_user_view_schema_user_view_name_key { Anum_continuous_agg_user_view_schema_user_view_name_key_user_view_schema = 1, Anum_continuous_agg_user_view_schema_user_view_name_key_user_view_name, _Anum_continuous_agg_user_view_schema_user_view_name_key_max, } Anum_continuous_agg_user_view_schema_user_view_name_key; #define Natts_continuous_agg_user_view_schema_user_view_name_key \ (_Anum_continuous_agg_user_view_schema_user_view_name_key_max - 1) typedef enum Anum_continuous_agg_raw_hypertable_id_idx { Anum_continuous_agg_raw_hypertable_id_idx_raw_hypertable_id = 1, _Anum_continuous_agg_raw_hypertable_id_idx_max, } Anum_continuous_agg_raw_hypertable_id_idx; #define Natts_continuous_agg_raw_hypertable_id_idx \ (_Anum_continuous_agg_raw_hypertable_id_idx_max - 1) /*** continuous_aggs_bucket_function table definitions ***/ #define CONTINUOUS_AGGS_BUCKET_FUNCTION_TABLE_NAME "continuous_aggs_bucket_function" typedef enum Anum_continuous_aggs_bucket_function { Anum_continuous_aggs_bucket_function_mat_hypertable_id = 1, Anum_continuous_aggs_bucket_function_function, Anum_continuous_aggs_bucket_function_bucket_width, Anum_continuous_aggs_bucket_function_bucket_origin, Anum_continuous_aggs_bucket_function_bucket_offset, Anum_continuous_aggs_bucket_function_bucket_timezone, Anum_continuous_aggs_bucket_function_bucket_fixed_width, _Anum_continuous_aggs_bucket_function_max, } Anum_continuous_aggs_bucket_function; #define Natts_continuous_aggs_bucket_function (_Anum_continuous_aggs_bucket_function_max - 1) enum { CONTINUOUS_AGGS_BUCKET_FUNCTION_PKEY_IDX = 0, _MAX_CONTINUOUS_AGGS_BUCKET_FUNCTION_INDEX, }; typedef enum Anum_continuous_aggs_bucket_function_pkey { Anum_continuous_aggs_bucket_function_pkey_mat_hypertable_id = 1, _Anum_continuous_aggs_bucket_function_pkey_max, } Anum_continuous_aggs_bucket_function_pkey; #define Natts_continuous_aggs_bucket_function_pkey \ (_Anum_continuous_aggs_bucket_function_pkey_max - 1) /* * CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_TABLE definitions * * The definition of CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_PLUGIN_NAME is * generated from config.h.in and can be found in the generated file. */ #define CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_TABLE_NAME \ "continuous_aggs_hypertable_invalidation_log" typedef enum Anum_continuous_aggs_hypertable_invalidation_log { Anum_continuous_aggs_hypertable_invalidation_log_hypertable_id = 1, Anum_continuous_aggs_hypertable_invalidation_log_lowest_modified_value, Anum_continuous_aggs_hypertable_invalidation_log_greatest_modified_value, _Anum_continuous_aggs_hypertable_invalidation_log_max, } Anum_continuous_aggs_hypertable_invalidation_log; #define Natts_continuous_aggs_hypertable_invalidation_log \ (_Anum_continuous_aggs_hypertable_invalidation_log_max - 1) typedef struct FormData_continuous_aggs_hypertable_invalidation_log { int32 hypertable_id; int64 lowest_modified_value; int64 greatest_modified_value; } FormData_continuous_aggs_hypertable_invalidation_log; typedef FormData_continuous_aggs_hypertable_invalidation_log *Form_continuous_aggs_hypertable_invalidation_log; enum { CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_IDX = 0, _MAX_CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_INDEX, }; typedef enum Anum_continuous_aggs_hypertable_invalidation_log_idx { Anum_continuous_aggs_hypertable_invalidation_log_idx_hypertable_id = 1, Anum_continuous_aggs_hypertable_invalidation_log_idx_lowest_modified_value, _Anum_continuous_aggs_hypertable_invalidation_log_idx_max, } Anum_continuous_aggs_hypertable_invalidation_log_idx; #define Natts_continuous_aggs_hypertable_invalidation_log_idx \ (_Anum_continuous_aggs_hypertable_invalidation_log_idx_max - 1) /****** CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_TABLE definitions*/ #define CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_TABLE_NAME "continuous_aggs_invalidation_threshold" typedef enum Anum_continuous_aggs_invalidation_threshold { Anum_continuous_aggs_invalidation_threshold_hypertable_id = 1, Anum_continuous_aggs_invalidation_threshold_watermark, _Anum_continuous_aggs_invalidation_threshold_max, } Anum_continuous_aggs_invalidation_threshold; #define Natts_continuous_aggs_invalidation_threshold \ (_Anum_continuous_aggs_invalidation_threshold_max - 1) typedef struct FormData_continuous_aggs_invalidation_threshold { int32 hypertable_id; int64 watermark; } FormData_continuous_aggs_invalidation_threshold; typedef FormData_continuous_aggs_invalidation_threshold *Form_continuous_aggs_invalidation_threshold; enum { CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY = 0, _MAX_CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_INDEX, }; typedef enum Anum_continuous_aggs_invalidation_threshold_pkey { Anum_continuous_aggs_invalidation_threshold_pkey_hypertable_id = 1, _Anum_continuous_aggs_invalidation_threshold_pkey_max, } Anum_continuous_aggs_invalidation_threshold_pkey; #define Natts_continuous_aggs_invalidation_threshold_pkey \ (_Anum_continuous_aggs_invalidation_threshold_pkey_max - 1) /****** CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_TABLE definitions*/ #define CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_TABLE_NAME \ "continuous_aggs_materialization_invalidation_log" typedef enum Anum_continuous_aggs_materialization_invalidation_log { Anum_continuous_aggs_materialization_invalidation_log_materialization_id = 1, Anum_continuous_aggs_materialization_invalidation_log_lowest_modified_value, Anum_continuous_aggs_materialization_invalidation_log_greatest_modified_value, _Anum_continuous_aggs_materialization_invalidation_log_max, } Anum_continuous_aggs_materialization_invalidation_log; #define Natts_continuous_aggs_materialization_invalidation_log \ (_Anum_continuous_aggs_materialization_invalidation_log_max - 1) typedef struct FormData_continuous_aggs_materialization_invalidation_log { int32 materialization_id; int64 lowest_modified_value; int64 greatest_modified_value; } FormData_continuous_aggs_materialization_invalidation_log; typedef FormData_continuous_aggs_materialization_invalidation_log *Form_continuous_aggs_materialization_invalidation_log; enum { CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_IDX = 0, _MAX_CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_INDEX, }; typedef enum Anum_continuous_aggs_materialization_invalidation_log_idx { Anum_continuous_aggs_materialization_invalidation_log_idx_materialization_id = 1, Anum_continuous_aggs_materialization_invalidation_log_idx_lowest_modified_value, _Anum_continuous_aggs_materialization_invalidation_log_idx_max, } Anum_continuous_aggs_materialization_invalidation_log_idx; #define Natts_continuous_aggs_materialization_invalidation_log_idx \ (_Anum_continuous_aggs_materialization_invalidation_log_idx_max - 1) /****** CONTINUOUS_AGGS_MATERIALIZATION_RANGES_TABLE definitions*/ #define CONTINUOUS_AGGS_MATERIALIZATION_RANGES_TABLE_NAME "continuous_aggs_materialization_ranges" typedef enum Anum_continuous_aggs_materialization_ranges { Anum_continuous_aggs_materialization_ranges_materialization_id = 1, Anum_continuous_aggs_materialization_ranges_lowest_modified_value, Anum_continuous_aggs_materialization_ranges_greatest_modified_value, _Anum_continuous_aggs_materialization_ranges_max, } Anum_continuous_aggs_materialization_ranges; #define Natts_continuous_aggs_materialization_ranges \ (_Anum_continuous_aggs_materialization_ranges_max - 1) typedef struct FormData_continuous_aggs_materialization_ranges { int32 materialization_id; int64 lowest_modified_value; int64 greatest_modified_value; } FormData_continuous_aggs_materialization_ranges; typedef FormData_continuous_aggs_materialization_ranges *Form_continuous_aggs_materialization_ranges; enum { CONTINUOUS_AGGS_MATERIALIZATION_RANGES_IDX = 0, _MAX_CONTINUOUS_AGGS_MATERIALIZATION_RANGES_INDEX, }; typedef enum Anum_continuous_aggs_materialization_ranges_idx { Anum_continuous_aggs_materialization_ranges_idx_materialization_id = 1, Anum_continuous_aggs_materialization_ranges_idx_lowest_modified_value, _Anum_continuous_aggs_materialization_ranges_idx_max, } Anum_continuous_aggs_materialization_ranges_idx; #define Natts_continuous_aggs_materialization_ranges_idx \ (_Anum_continuous_aggs_materialization_ranges_idx_max - 1) /****** CONTINUOUS_AGGS_WATERMARK_TABLE definitions*/ #define CONTINUOUS_AGGS_WATERMARK_TABLE_NAME "continuous_aggs_watermark" typedef enum Anum_continuous_aggs_watermark { Anum_continuous_aggs_watermark_mat_hypertable_id = 1, Anum_continuous_aggs_watermark_watermark, _Anum_continuous_aggs_watermark_max, } Anum_continuous_aggs_watermark; #define Natts_continuous_aggs_watermark (_Anum_continuous_aggs_watermark_max - 1) typedef struct FormData_continuous_aggs_watermark { int32 mat_hypertable_id; int64 watermark; } FormData_continuous_aggs_watermark; typedef FormData_continuous_aggs_watermark *Form_continuous_aggs_watermark; enum { CONTINUOUS_AGGS_WATERMARK_PKEY = 0, _MAX_CONTINUOUS_AGGS_WATERMARK_INDEX, }; typedef enum Anum_continuous_aggs_watermark_pkey { Anum_continuous_aggs_watermark_pkey_mat_hypertable_id = 1, _Anum_continuous_aggs_watermark_pkey_max, } Anum_continuous_aggs_watermark_pkey; #define Natts_continuous_aggs_watermark_pkey (_Anum_continuous_aggs_watermark_pkey_max - 1) #define COMPRESSION_SETTINGS_TABLE_NAME "compression_settings" typedef enum Anum_compression_settings { Anum_compression_settings_relid = 1, Anum_compression_settings_compress_relid, Anum_compression_settings_segmentby, Anum_compression_settings_orderby, Anum_compression_settings_orderby_desc, Anum_compression_settings_orderby_nullsfirst, Anum_compression_settings_index, _Anum_compression_settings_max, } Anum_compression_settings; #define Natts_compression_settings (_Anum_compression_settings_max - 1) typedef struct FormData_compression_settings { Oid relid; Oid compress_relid; ArrayType *segmentby; ArrayType *orderby; ArrayType *orderby_desc; ArrayType *orderby_nullsfirst; Jsonb *index; } FormData_compression_settings; typedef FormData_compression_settings *Form_compression_settings; enum { COMPRESSION_SETTINGS_PKEY = 0, COMPRESSION_SETTINGS_COMPRESS_RELID_IDX, _MAX_COMPRESSION_SETTINGS_INDEX, }; typedef enum Anum_compression_settings_pkey { Anum_compression_settings_pkey_relid = 1, _Anum_compression_settings_pkey_max, } Anum_compression_settings_pkey; #define Natts_compression_chunk_size_pkey (_Anum_compression_chunk_size_pkey_max - 1) typedef enum Anum_compression_settings_compress_relid_idx { Anum_compression_settings_compress_relid_idx_relid = 1, _Anum_compression_settings_compress_relid_idx_max, } Anum_compression_settings_compress_relid_idx; #define Natts_compression_settings_compress_relid_idx \ (_Anum_compression_settings_compress_relid_idx_max - 1) #define COMPRESSION_CHUNK_SIZE_TABLE_NAME "compression_chunk_size" typedef enum Anum_compression_chunk_size { Anum_compression_chunk_size_chunk_id = 1, Anum_compression_chunk_size_compressed_chunk_id, Anum_compression_chunk_size_uncompressed_heap_size, Anum_compression_chunk_size_uncompressed_toast_size, Anum_compression_chunk_size_uncompressed_index_size, Anum_compression_chunk_size_compressed_heap_size, Anum_compression_chunk_size_compressed_toast_size, Anum_compression_chunk_size_compressed_index_size, Anum_compression_chunk_size_numrows_pre_compression, Anum_compression_chunk_size_numrows_post_compression, Anum_compression_chunk_size_numrows_frozen_immediately, _Anum_compression_chunk_size_max, } Anum_compression_chunk_size; #define Natts_compression_chunk_size (_Anum_compression_chunk_size_max - 1) typedef struct FormData_compression_chunk_size { int32 chunk_id; int32 compressed_chunk_id; int64 uncompressed_heap_size; int64 uncompressed_toast_size; int64 uncompressed_index_size; int64 compressed_heap_size; int64 compressed_toast_size; int64 compressed_index_size; int64 numrows_pre_compression; int64 numrows_post_compression; int64 numrows_frozen_immediately; } FormData_compression_chunk_size; typedef FormData_compression_chunk_size *Form_compression_chunk_size; enum { COMPRESSION_CHUNK_SIZE_PKEY = 0, _MAX_COMPRESSION_CHUNK_SIZE_INDEX, }; typedef enum Anum_compression_chunk_size_pkey { Anum_compression_chunk_size_pkey_chunk_id = 1, _Anum_compression_chunk_size_pkey_max, } Anum_compression_chunk_size_pkey; #define Natts_compression_chunk_size_pkey (_Anum_compression_chunk_size_pkey_max - 1) /* * The maximum number of indexes a catalog table can have. * This needs to be bumped in case of new catalog tables that have more indexes. */ #define _MAX_TABLE_INDEXES 6 typedef enum CacheType { CACHE_TYPE_HYPERTABLE, CACHE_TYPE_BGW_JOB, CACHE_TYPE_EXTENSION, _MAX_CACHE_TYPES } CacheType; typedef struct CatalogTableInfo { const char *schema_name; const char *name; Oid id; Oid serial_relid; Oid index_ids[_MAX_TABLE_INDEXES]; } CatalogTableInfo; typedef struct CatalogDatabaseInfo { NameData database_name; Oid database_id; Oid schema_id; Oid owner_uid; } CatalogDatabaseInfo; typedef struct Catalog { CatalogTableInfo tables[_MAX_CATALOG_TABLES]; Oid extension_schema_id[_TS_MAX_SCHEMA]; struct { Oid inval_proxy_id; } caches[_MAX_CACHE_TYPES]; struct { Oid function_id; } functions[_MAX_INTERNAL_FUNCTIONS]; bool initialized; } Catalog; typedef struct CatalogSecurityContext { Oid saved_uid; int saved_security_context; } CatalogSecurityContext; #define HYPERTABLE_STATUS_DEFAULT 0 /* flag set when hypertable has an attached OSM chunk */ #define HYPERTABLE_STATUS_OSM 1 /* * Currently, the time slice range metadata is updated in * the timescaledb catalog with the min and max of the range managed by OSM. * However, this range has to be contiguous in order to * update our catalog with its min and max value. If it is not contiguous, * then we cannot store the min and max in our catalog because tuple routing * will not work properly with gaps in the range. * When attempting to insert into one of the gaps, which do not in fact contain * tiered data, we error out because this is perceived as an attempt to insert * into tiered chunks, which are immutable. * When the range is noncontiguous, we store [INT64_MAX - 1, INT64_MAX) and set * this flag. * This flag also serves to allow or block the ordered append optimization. When * the range covered by OSM is contiguous, then it is possible to do ordered * append. */ #define HYPERTABLE_STATUS_OSM_CHUNK_NONCONTIGUOUS 2 extern void ts_catalog_table_info_init(CatalogTableInfo *tables, int max_table, const TableInfoDef *table_ary, const TableIndexDef *index_ary, const char **serial_id_ary); extern TSDLLEXPORT CatalogDatabaseInfo *ts_catalog_database_info_get(void); extern TSDLLEXPORT Catalog *ts_catalog_get(void); extern void ts_catalog_reset(void); extern bool ts_is_catalog_table(Oid relid); /* Functions should operate on a passed-in Catalog struct */ static inline Oid catalog_get_table_id(Catalog *catalog, CatalogTable tableid) { return catalog->tables[tableid].id; } static inline Oid catalog_get_index(Catalog *catalog, CatalogTable tableid, int indexid) { return (indexid == INVALID_INDEXID) ? InvalidOid : catalog->tables[tableid].index_ids[indexid]; } extern TSDLLEXPORT int64 ts_catalog_table_next_seq_id(const Catalog *catalog, CatalogTable table); extern Oid ts_catalog_get_cache_proxy_id(Catalog *catalog, CacheType type); /* Functions that modify the actual catalog table on disk */ extern TSDLLEXPORT bool ts_catalog_database_info_become_owner(CatalogDatabaseInfo *database_info, CatalogSecurityContext *sec_ctx); extern TSDLLEXPORT void ts_catalog_restore_user(CatalogSecurityContext *sec_ctx); extern TSDLLEXPORT void ts_catalog_insert_only(Relation rel, HeapTuple tuple); extern TSDLLEXPORT void ts_catalog_insert(Relation rel, HeapTuple tuple); extern TSDLLEXPORT void ts_catalog_insert_values(Relation rel, TupleDesc tupdesc, Datum *values, bool *nulls); extern TSDLLEXPORT void ts_catalog_insert_datums(Relation rel, TupleDesc tupdesc, NullableDatum *datums); extern TSDLLEXPORT void ts_catalog_update_tid_only(Relation rel, ItemPointer tid, HeapTuple tuple); extern TSDLLEXPORT void ts_catalog_update_tid(Relation rel, ItemPointer tid, HeapTuple tuple); extern TSDLLEXPORT void ts_catalog_update(Relation rel, HeapTuple tuple); extern TSDLLEXPORT void ts_catalog_delete_tid_only(Relation rel, ItemPointer tid); extern TSDLLEXPORT void ts_catalog_delete_tid(Relation rel, ItemPointer tid); extern TSDLLEXPORT void ts_catalog_invalidate_cache(Oid catalog_relid, CmdType operation); extern TSDLLEXPORT void ts_catalog_index_insert(ResultRelInfo *indstate, HeapTuple heapTuple); bool TSDLLEXPORT ts_catalog_scan_one(CatalogTable table, int indexid, ScanKeyData *scankey, int num_keys, tuple_found_func tuple_found, LOCKMODE lockmode, char *policy_type, void *data); void TSDLLEXPORT ts_catalog_scan_all(CatalogTable table, int indexid, ScanKeyData *scankey, int num_keys, tuple_found_func tuple_found, LOCKMODE lockmode, void *data); ����������������timescaledb-2.23.0/src/ts_catalog/chunk_column_stats.c����������������������������������������������0000664�0000000�0000000�00000132354�15100345067�0023041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/attnum.h> #include <access/htup.h> #include <access/htup_details.h> #include <access/skey.h> #include <access/stratnum.h> #include <access/tupdesc.h> #include <catalog/pg_collation.h> #include <executor/spi.h> #include <executor/tuptable.h> #include <funcapi.h> #include <nodes/makefuncs.h> #include <optimizer/optimizer.h> #include <parser/parse_coerce.h> #include <parser/parse_collate.h> #include <parser/parse_expr.h> #include <parser/parse_relation.h> #include <rewrite/rewriteManip.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <utils/datum.h> #include <utils/syscache.h> #include "chunk.h" #include "chunk_column_stats.h" #include "dimension_slice.h" #include "guc.h" #include "ts_catalog/catalog.h" /* * Enable chunk column stats attributes */ enum Anum_enable_chunk_column_stats { Anum_enable_chunk_column_stats_id = 1, Anum_enable_chunk_column_stats_enabled, _Anum_enable_chunk_column_stats_max, }; #define Natts_enable_chunk_column_stats (_Anum_enable_chunk_column_stats_max - 1) TS_FUNCTION_INFO_V1(ts_chunk_column_stats_enable); /* * Disable chunk column stats attributes */ enum Anum_disable_chunk_column_stats { Anum_disable_chunk_column_stats_hypertable_id = 1, Anum_disable_chunk_column_stats_column_name, Anum_disable_chunk_column_stats_disabled, _Anum_disable_chunk_column_stats_max, }; #define Natts_disable_chunk_column_stats (_Anum_disable_chunk_column_stats_max - 1) TS_FUNCTION_INFO_V1(ts_chunk_column_stats_disable); /* * Create a datum to be returned by ts_chunk_column_stats_enable DDL function */ static Datum chunk_column_stats_enable_datum(FunctionCallInfo fcinfo, int32 id, bool enabled) { TupleDesc tupdesc; HeapTuple tuple; Datum values[Natts_enable_chunk_column_stats]; bool nulls[Natts_enable_chunk_column_stats] = { false }; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in " "context that cannot accept type record"))); tupdesc = BlessTupleDesc(tupdesc); Assert(tupdesc->natts == Natts_enable_chunk_column_stats); values[AttrNumberGetAttrOffset(Anum_enable_chunk_column_stats_id)] = Int32GetDatum(id); values[AttrNumberGetAttrOffset(Anum_enable_chunk_column_stats_enabled)] = BoolGetDatum(enabled); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } /* * Create a datum to be returned by ts_chunk_column_stats_disable DDL function */ static Datum chunk_column_stats_disable_datum(FunctionCallInfo fcinfo, int32 hypertable_id, Name colname, bool disabled) { TupleDesc tupdesc; HeapTuple tuple; Datum values[Natts_disable_chunk_column_stats]; bool nulls[Natts_disable_chunk_column_stats] = { false }; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in " "context that cannot accept type record"))); tupdesc = BlessTupleDesc(tupdesc); Assert(tupdesc->natts == Natts_disable_chunk_column_stats); values[AttrNumberGetAttrOffset(Anum_disable_chunk_column_stats_hypertable_id)] = Int32GetDatum(hypertable_id); values[AttrNumberGetAttrOffset(Anum_disable_chunk_column_stats_column_name)] = NameGetDatum(colname); values[AttrNumberGetAttrOffset(Anum_disable_chunk_column_stats_disabled)] = BoolGetDatum(disabled); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } static int32 chunk_column_stats_insert_relation(const Relation rel, Form_chunk_column_stats info) { TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_chunk_column_stats] = { 0 }; bool nulls[Natts_chunk_column_stats] = { false }; CatalogSecurityContext sec_ctx; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); info->id = ts_catalog_table_next_seq_id(ts_catalog_get(), CHUNK_COLUMN_STATS); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_id)] = Int32GetDatum(info->id); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_hypertable_id)] = Int32GetDatum(info->hypertable_id); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_chunk_id)] = Int32GetDatum(info->chunk_id); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_column_name)] = NameGetDatum(&info->column_name); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_start)] = Int64GetDatum(info->range_start); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_end)] = Int64GetDatum(info->range_end); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_valid)] = BoolGetDatum(info->valid); if (info->chunk_id == INVALID_CHUNK_ID) nulls[AttrNumberGetAttrOffset(Anum_chunk_column_stats_chunk_id)] = true; ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); return info->id; } static int32 chunk_column_stats_insert(Form_chunk_column_stats info) { Catalog *catalog = ts_catalog_get(); Relation rel; int32 ccol_stats_id; rel = table_open(catalog_get_table_id(catalog, CHUNK_COLUMN_STATS), RowExclusiveLock); ccol_stats_id = chunk_column_stats_insert_relation(rel, info); table_close(rel, RowExclusiveLock); return ccol_stats_id; } static ScanTupleResult chunk_column_stats_tuple_update(TupleInfo *ti, void *data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); FormData_chunk_column_stats *fd = (FormData_chunk_column_stats *) data; Datum values[Natts_chunk_column_stats] = { 0 }; bool isnull[Natts_chunk_column_stats] = { 0 }; bool doReplace[Natts_chunk_column_stats] = { 0 }; values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_start)] = Int64GetDatum(fd->range_start); doReplace[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_start)] = true; values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_end)] = Int64GetDatum(fd->range_end); doReplace[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_end)] = true; values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_valid)] = BoolGetDatum(fd->valid); doReplace[AttrNumberGetAttrOffset(Anum_chunk_column_stats_valid)] = true; HeapTuple new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, isnull, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_DONE; } static int chunk_column_stats_scan_internal(ScanKeyData *scankey, int nkeys, tuple_found_func tuple_found, void *data, int limit, int dimension_index, LOCKMODE lockmode, MemoryContext mctx) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CHUNK_COLUMN_STATS), .index = catalog_get_index(catalog, CHUNK_COLUMN_STATS, dimension_index), .nkeys = nkeys, .limit = limit, .scankey = scankey, .data = data, .tuple_found = tuple_found, .lockmode = lockmode, .scandirection = ForwardScanDirection, .result_mctx = mctx, }; return ts_scanner_scan(&scanctx); } int ts_chunk_column_stats_update_by_id(int32 chunk_column_stats_id, FormData_chunk_column_stats *fd_range) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_chunk_column_stats_id_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_column_stats_id)); return chunk_column_stats_scan_internal(scankey, 1, chunk_column_stats_tuple_update, fd_range, 1, CHUNK_COLUMN_STATS_ID_IDX, RowExclusiveLock, CurrentMemoryContext); } static void ts_chunk_column_stats_validate(Form_chunk_column_stats info, const Oid hypertable_relid, bool if_not_exists) { HeapTuple tuple; Datum datum; bool isnull; Oid column_type; /* Check that the column exists and has not been dropped */ tuple = SearchSysCacheAttName(hypertable_relid, NameStr(info->column_name)); if (!HeapTupleIsValid(tuple)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" does not exist", NameStr(info->column_name)))); datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_atttypid, &isnull); Assert(!isnull); column_type = DatumGetObjectId(datum); ReleaseSysCache(tuple); /* we only support a subset of data types for range calculations right now */ switch (column_type) { case INT2OID: case INT4OID: case INT8OID: case TIMESTAMPOID: case TIMESTAMPTZOID: case DATEOID: break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("data type \"%s\" unsupported for range calculation", format_type_be(column_type)), errhint("Integer-like, timestamp-like data types supported currently"))); } } /* * Track min/max range for a given column in a hypertable */ static Datum ts_chunk_column_stats_add_internal(FunctionCallInfo fcinfo, Oid table_relid, Name colname, bool if_not_exists) { Hypertable *ht; Cache *hcache; Datum retval = 0; int32 ccol_stats_id = 0; FormData_chunk_column_stats fd = { 0 }; Form_chunk_column_stats form; bool enabled = true; ts_hypertable_permissions_check(table_relid, GetUserId()); namestrcpy(&fd.column_name, NameStr(*colname)); LockRelationOid(table_relid, AccessShareLock); ts_chunk_column_stats_validate(&fd, table_relid, if_not_exists); ht = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); /* * Add an entry in the _timescaledb_catalog.chunk_column_stats table. We add * a special entry in the catalog which contains the hypertable_id, the colname, * an invalid id (for the chunk) and PG_INT64_MAX, PG_INT64_MIN as range values * to indicate that ranges should be calculated for this column for chunks. * * We have a uniqueness check on ht_id, colname, chunk_id * * Check if the entry already exists, first. */ form = ts_chunk_column_stats_lookup(ht->fd.id, INVALID_CHUNK_ID, NameStr(*colname)); if (form != NULL) { if (!if_not_exists) { ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("already enabled for column \"%s\"", NameStr(*colname)))); } else { ereport(NOTICE, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("already enabled for column \"%s\", skipping", NameStr(*colname)))); /* return the existing id */ ccol_stats_id = form->id; /* we still return true since it's already enabled */ enabled = true; goto do_return; } } fd.hypertable_id = ht->fd.id; fd.chunk_id = INVALID_CHUNK_ID; fd.range_start = PG_INT64_MIN; fd.range_end = PG_INT64_MAX; fd.valid = true; ccol_stats_id = chunk_column_stats_insert(&fd); /* refresh the ht entry to accommodate this new chunk_column_stats entry */ if (ht->range_space) pfree(ht->range_space); ht->range_space = ts_chunk_column_stats_range_space_scan(ht->fd.id, ht->main_table_relid, ts_cache_memory_ctx(hcache)); /* * If the hypertable has chunks, to make it compatible * we add artificial min/max range entries which will cover -inf / inf * range for all these existing chunks. * * TODO: Maybe have a future version which calculates actual ranges for * compressed chunks in this function itself? Or have an option to this * function which specifies if we should calculate ranges for compressed * chunks. */ if (ts_hypertable_has_chunks(ht->main_table_relid, AccessShareLock)) { ListCell *lc; List *chunk_id_list = ts_chunk_get_chunk_ids_by_hypertable_id(ht->fd.id); Catalog *catalog = ts_catalog_get(); Relation rel; rel = table_open(catalog_get_table_id(catalog, CHUNK_COLUMN_STATS), RowExclusiveLock); foreach (lc, chunk_id_list) { /* other fields are set appropriately in fd above. Only change chunk_id */ fd.chunk_id = lfirst_int(lc); chunk_column_stats_insert_relation(rel, &fd); } table_close(rel, RowExclusiveLock); } do_return: /* return the id of the main entry for this dimension range */ fd.id = ccol_stats_id; retval = chunk_column_stats_enable_datum(fcinfo, fd.id, enabled); ts_cache_release(&hcache); PG_RETURN_DATUM(retval); } /* * Add min/max range tracking for a column in a hypertable. * * Arguments: * 0. Relation ID of table * 1. Column name * 2. IF NOT EXISTS option (bool) */ Datum ts_chunk_column_stats_enable(PG_FUNCTION_ARGS) { Oid hypertable_relid; NameData colname; bool if_not_exists; TS_PREVENT_FUNC_IF_READ_ONLY(); if (!ts_guc_enable_chunk_skipping) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("chunk skipping functionality disabled, " "enable it by first setting timescaledb.enable_chunk_skipping to on"))); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable cannot be NULL"))); hypertable_relid = PG_GETARG_OID(0); if (PG_ARGISNULL(1)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("column name cannot be NULL"))); namestrcpy(&colname, NameStr(*PG_GETARG_NAME(1))); if_not_exists = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); return ts_chunk_column_stats_add_internal(fcinfo, hypertable_relid, &colname, if_not_exists); } /* * Remove min/max range tracking for a column in a hypertable. * * Arguments: * 0. Relation ID of hypertable * 1. Column name * 2. IF NOT EXISTS option (bool) */ Datum ts_chunk_column_stats_disable(PG_FUNCTION_ARGS) { Oid hypertable_relid; NameData colname; bool if_not_exists; Hypertable *ht; Cache *hcache; Datum retval = 0; int delete_count = 0; TS_PREVENT_FUNC_IF_READ_ONLY(); if (!ts_guc_enable_chunk_skipping) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("chunk skipping functionality disabled, " "enable it by first setting timescaledb.enable_chunk_skipping to on"))); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable cannot be NULL"))); hypertable_relid = PG_GETARG_OID(0); if (PG_ARGISNULL(1)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("column name cannot be NULL"))); namestrcpy(&colname, NameStr(*PG_GETARG_NAME(1))); if_not_exists = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); ts_hypertable_permissions_check(hypertable_relid, GetUserId()); LockRelationOid(hypertable_relid, ShareUpdateExclusiveLock); ht = ts_hypertable_cache_get_cache_and_entry(hypertable_relid, CACHE_FLAG_NONE, &hcache); /* * Remove entries from _timescaledb_catalog.chunk_column_stats table. * * There's a special entry in the catalog which contains the hypertable_id, the colname, * an invalid id (for the chunk) and PG_INT64_MAX, PG_INT64_MIN as range values * to indicate that ranges should be calculated for this column for chunks. * * Check if the entry already exists, first. */ if (ts_chunk_column_stats_lookup(ht->fd.id, INVALID_CHUNK_ID, NameStr(colname)) == NULL) { if (!if_not_exists) { ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("statistics not enabled for column \"%s\"", NameStr(colname)))); } else { ereport(NOTICE, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("statistics not enabled for column \"%s\", skipping", NameStr(colname)))); goto do_return; } } /* Delete all entries matching this hypertable_id and column_name. */ delete_count = ts_chunk_column_stats_delete_by_ht_colname(ht->fd.id, NameStr(colname)); /* refresh the ht entry to accommodate this deleted chunk_column_stats entry */ if (ht->range_space) pfree(ht->range_space); ht->range_space = ts_chunk_column_stats_range_space_scan(ht->fd.id, ht->main_table_relid, ts_cache_memory_ctx(hcache)); do_return: retval = chunk_column_stats_disable_datum(fcinfo, ht->fd.id, &colname, delete_count > 0); ts_cache_release(&hcache); PG_RETURN_DATUM(retval); } /* * Dimension range entries are similar to OPEN DIMENSION entries. So, most of * the default fields are similar to them. */ Dimension * ts_chunk_column_stats_fill_dummy_dimension(FormData_chunk_column_stats *r, Oid main_table_relid) { Dimension *d = palloc0(sizeof(Dimension)); d->fd.id = r->id; d->fd.hypertable_id = r->hypertable_id; d->fd.aligned = true; namestrcpy(&d->fd.column_name, NameStr(r->column_name)); d->fd.interval_length = 1; /* a dummy interval length for the dummy dimension */ /* similar to open dimensions except that we don't participate in partitioning */ d->type = DIMENSION_TYPE_STATS; d->column_attno = get_attnum(main_table_relid, NameStr(d->fd.column_name)); d->main_table_relid = main_table_relid; /* rest of the fields are zeroed out */ return d; } /* * Create a CHECK constraint for a min/max range chunk_column_stats entry */ static Constraint * create_col_stats_check_constraint(const Form_chunk_column_stats info, Oid main_table_relid, Oid chunk_relid, const char *name) { Constraint *constr = NULL; Node *rangedef; ColumnRef *colref; List *compexprs = NIL; Oid col_type; int attno; if (info->range_start == PG_INT64_MIN && info->range_end == PG_INT64_MAX) return NULL; colref = makeNode(ColumnRef); colref->fields = list_make1(makeString(pstrdup(NameStr(info->column_name)))); colref->location = -1; /* * Get the column type for later converting the internal format * to string. * * Get the attribute number in the HT for this column, and map to the chunk */ attno = get_attnum(main_table_relid, NameStr(info->column_name)); attno = ts_map_attno(main_table_relid, chunk_relid, attno); col_type = get_atttype(main_table_relid, attno); rangedef = (Node *) colref; /* Elide range constraint for +INF or -INF */ if (info->range_start != PG_INT64_MIN) { A_Const *start_const = makeNode(A_Const); memcpy(&start_const->val, makeString(ts_internal_to_time_string(info->range_start, col_type)), sizeof(start_const->val)); start_const->location = -1; A_Expr *ge_expr = makeSimpleA_Expr(AEXPR_OP, ">=", rangedef, (Node *) start_const, -1); compexprs = lappend(compexprs, ge_expr); } if (info->range_end != PG_INT64_MAX) { A_Const *end_const = makeNode(A_Const); memcpy(&end_const->val, makeString(ts_internal_to_time_string(info->range_end, col_type)), sizeof(end_const->val)); end_const->location = -1; A_Expr *lt_expr = makeSimpleA_Expr(AEXPR_OP, "<", rangedef, (Node *) end_const, -1); compexprs = lappend(compexprs, lt_expr); } constr = makeNode(Constraint); constr->contype = CONSTR_CHECK; constr->conname = name ? pstrdup(name) : NULL; constr->deferrable = false; constr->skip_validation = true; constr->initially_valid = true; Assert(list_length(compexprs) >= 1); if (list_length(compexprs) == 2) constr->raw_expr = (Node *) makeBoolExpr(AND_EXPR, compexprs, -1); else if (list_length(compexprs) == 1) constr->raw_expr = linitial(compexprs); return constr; } /* * Fill in the form for chunk_column_stats. * * Note that it is necessary to deform the tuple since it is not possible to * use GETSTRUCT when chunk_id can be NULL. */ static void fill_form_from_slot(TupleTableSlot *slot, Form_chunk_column_stats form) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); Datum values[_Anum_chunk_column_stats_max]; bool nulls[_Anum_chunk_column_stats_max]; heap_deform_tuple(tuple, slot->tts_tupleDescriptor, values, nulls); form->id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_id)]); form->hypertable_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_hypertable_id)]); if (nulls[AttrNumberGetAttrOffset(Anum_chunk_column_stats_chunk_id)]) form->chunk_id = INVALID_CHUNK_ID; else form->chunk_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_chunk_id)]); namestrcpy(&form->column_name, NameStr(*DatumGetName( values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_column_name)]))); form->range_end = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_end)]); form->range_start = DatumGetInt64(values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_range_start)]); form->valid = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_valid)]); if (should_free) heap_freetuple(tuple); } static ScanTupleResult chunk_column_stats_tuple_found(TupleInfo *ti, void *data) { ChunkRangeSpace *rs = data; Form_chunk_column_stats d = &rs->range_cols[rs->num_range_cols++]; fill_form_from_slot(ti->slot, d); return SCAN_CONTINUE; } ChunkRangeSpace * ts_chunk_column_stats_range_space_scan(int32 hypertable_id, Oid ht_reloid, MemoryContext mctx) { /* We won't have more entries than the number of columns in the HT */ int num_range_cols = ts_get_relnatts(ht_reloid); ChunkRangeSpace *range_space = MemoryContextAllocZero(mctx, CHUNKRANGESPACE_SIZE(num_range_cols)); ScanKeyData scankey[2]; range_space->hypertable_id = hypertable_id; range_space->capacity = num_range_cols; range_space->num_range_cols = 0; /* Perform an index scan on hypertable_id, invalid chunk_id. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); ScanKeyEntryInitialize( &scankey[1], SK_ISNULL | SK_SEARCHNULL, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, InvalidOid, InvalidOid, InvalidOid, Int32GetDatum(INVALID_CHUNK_ID)); chunk_column_stats_scan_internal(scankey, 2, chunk_column_stats_tuple_found, range_space, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, AccessShareLock, mctx); if (range_space->num_range_cols == 0) { pfree(range_space); return NULL; } return range_space; } static ScanTupleResult form_range_tuple_found(TupleInfo *ti, void *data) { Form_chunk_column_stats rg = data; fill_form_from_slot(ti->slot, rg); return SCAN_DONE; } Form_chunk_column_stats ts_chunk_column_stats_lookup(int32 hypertable_id, int32 chunk_id, const char *col_name) { ScanKeyData scankey[3]; Form_chunk_column_stats form_range = palloc0(sizeof(FormData_chunk_column_stats)); form_range->chunk_id = INVALID_CHUNK_ID; /* for clarity */ /* Perform an index scan on hypertable_id, chunk_id, col_name. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); if (chunk_id == INVALID_CHUNK_ID) { ScanKeyEntryInitialize( &scankey[1], SK_ISNULL | SK_SEARCHNULL, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, InvalidOid, InvalidOid, InvalidOid, Int32GetDatum(chunk_id)); } else { ScanKeyInit( &scankey[1], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); } ScanKeyInit( &scankey[2], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_column_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(col_name)); chunk_column_stats_scan_internal(scankey, 3, form_range_tuple_found, form_range, 1, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, AccessShareLock, CurrentMemoryContext); if (strlen(NameStr(form_range->column_name)) == 0) { pfree(form_range); return NULL; } return form_range; } static bool chunk_get_minmax(const Chunk *chunk, Oid col_type, const char *col_name, Datum *minmax) { StringInfoData command; int res; /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); initStringInfo(&command); appendStringInfo(&command, "SELECT pg_catalog.min(%s), pg_catalog.max(%s) FROM %s.%s", quote_identifier(col_name), quote_identifier(col_name), quote_identifier(NameStr(chunk->fd.schema_name)), quote_identifier(NameStr(chunk->fd.table_name))); /* * SPI_connect will switch MemoryContext so we need to keep track * of caller context as we need to copy the values into caller * context. */ MemoryContext caller = CurrentMemoryContext; if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); res = SPI_execute(command.data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not get the min/max values for column \"%s\" of chunk \"%s.%s\"", col_name, chunk->fd.schema_name.data, chunk->fd.table_name.data)))); pfree(command.data); Datum min, max; bool isnull_min = false, isnull_max = false; min = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull_min); max = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull_max); Assert(SPI_gettypeid(SPI_tuptable->tupdesc, 1) == col_type); Assert(SPI_gettypeid(SPI_tuptable->tupdesc, 2) == col_type); bool found = !isnull_min && !isnull_max; if (found) { bool typbyval; int16 typlen; get_typlenbyval(col_type, &typlen, &typbyval); /* Copy the values into caller context */ MemoryContext spi = MemoryContextSwitchTo(caller); minmax[0] = datumCopy(min, typbyval, typlen); minmax[1] = datumCopy(max, typbyval, typlen); MemoryContextSwitchTo(spi); } /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); return found; } /* * Update column dimension ranges in the catalog for the * provided chunk (it's assumed that the chunk is locked * appropriately). * * Calculate actual ranges for the given chunk for the columns * insert these entries. This allows for the * chunk to be picked up when queries use these columns in * WHERE clauses with these ranges. * * Returns the number of column entries that have been added or * updated. */ int ts_chunk_column_stats_calculate(const Hypertable *ht, const Chunk *chunk) { Size i = 0; ChunkRangeSpace *rs = ht->range_space; MemoryContext work_mcxt, orig_mcxt; /* Quick check. Bail out early if none */ if (rs == NULL) return i; work_mcxt = AllocSetContextCreate(CurrentMemoryContext, "dimension-range-work", ALLOCSET_DEFAULT_SIZES); orig_mcxt = MemoryContextSwitchTo(work_mcxt); for (int range_index = 0; range_index < rs->num_range_cols; range_index++) { Datum minmax[2]; AttrNumber attno; char *col_name = NameStr(rs->range_cols[range_index].column_name); Oid col_type; attno = get_attnum(ht->main_table_relid, col_name); attno = ts_map_attno(ht->main_table_relid, chunk->table_id, attno); col_type = get_atttype(chunk->table_id, attno); /* calculate the min/max range for this column on this chunk */ if (chunk_get_minmax(chunk, col_type, col_name, minmax)) { Form_chunk_column_stats range; int64 min = ts_time_value_to_internal(minmax[0], col_type); int64 max = ts_time_value_to_internal(minmax[1], col_type); /* The end value is exclusive to the range, so incr by 1 */ if (max != DIMENSION_SLICE_MAXVALUE) { max++; /* Again, check overflow */ max = REMAP_LAST_COORDINATE(max); } /* * Check if an entry exists for this ht, chunk_id, colname combo. If it exists * and it's not -inf/+inf then it's probably a case of re-computation of the * ranges. In such a case, we compare the stored range_start and range_end entries * and compare with the min/max calculated. * * if min < range_start, then new_range_start = min * if max > range_end, then new_range_end = max * * We need to update the existing entry with changes in the range. * Also, in case of updates, the entry might be marked "invalid" so it needs to be * made "valid" again as well. */ range = ts_chunk_column_stats_lookup(ht->fd.id, chunk->fd.id, col_name); /* Add a new entry if none exists */ if (range == NULL) { FormData_chunk_column_stats fd = { 0 }; fd.hypertable_id = ht->fd.id; fd.chunk_id = chunk->fd.id; namestrcpy(&fd.column_name, col_name); fd.range_start = min; fd.range_end = max; fd.valid = true; chunk_column_stats_insert(&fd); i++; } /* update case */ else if (range->range_start != min || range->range_end != max || !range->valid) { range->range_start = min; range->range_end = max; range->valid = true; ts_chunk_column_stats_update_by_id(range->id, range); i++; } } else ereport(WARNING, errmsg("unable to calculate min/max values for column ranges")); } MemoryContextSwitchTo(orig_mcxt); MemoryContextDelete(work_mcxt); return i; } /* * Insert column dimension ranges in the catalog for the * provided chunk (it's assumed that the chunk is locked * appropriately). * * We insert -inf/+inf entries for the given chunk which means * default selection till the actual ranges get calculated later. * * Returns the number of column entries that have been inserted. */ int ts_chunk_column_stats_insert(const Hypertable *ht, const Chunk *chunk) { Size range_index = 0; ChunkRangeSpace *rs = ht->range_space; MemoryContext work_mcxt, orig_mcxt; /* Quick check. Bail out early if none */ if (rs == NULL) return range_index; work_mcxt = AllocSetContextCreate(CurrentMemoryContext, "dimension-range-work", ALLOCSET_DEFAULT_SIZES); orig_mcxt = MemoryContextSwitchTo(work_mcxt); for (range_index = 0; range_index < rs->num_range_cols; range_index++) { AttrNumber attno; char *col_name = NameStr(rs->range_cols[range_index].column_name); FormData_chunk_column_stats fd = { 0 }; /* Get the attribute number in the HT for this column, and map to the chunk */ attno = get_attnum(ht->main_table_relid, col_name); attno = ts_map_attno(ht->main_table_relid, chunk->table_id, attno); /* insert an entry for this ht_id, chunk_id for this col_name with -inf/+inf range */ fd.hypertable_id = ht->fd.id; fd.chunk_id = chunk->fd.id; namestrcpy(&fd.column_name, col_name); fd.range_start = PG_INT64_MIN; fd.range_end = PG_INT64_MAX; fd.valid = true; chunk_column_stats_insert(&fd); } MemoryContextSwitchTo(orig_mcxt); MemoryContextDelete(work_mcxt); return range_index; } /* * Check if there is a min/max range tracking on this column which is being dropped. * Need to delete the entries from _timescaledb_catalog.chunk_column_stats table in that case. */ void ts_chunk_column_stats_drop(const Hypertable *ht, const char *col_name, bool *dropped) { /* delete all entries belonging to this HT and pointing to this column */ *dropped = (ts_chunk_column_stats_delete_by_ht_colname(ht->fd.id, col_name) > 0); } static ScanTupleResult chunk_column_stats_tuple_delete(TupleInfo *ti, void *data) { CatalogSecurityContext sec_ctx; int *count = data; /* delete catalog entry */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); *count = *count + 1; return SCAN_CONTINUE; } int ts_chunk_column_stats_delete_by_ht_colname(int32 hypertable_id, const char *col_name) { ScanKeyData scankey[2]; int count = 0; /* Perform an index scan on hypertable_id, col_name. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); ScanKeyInit( &scankey[1], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_column_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum((col_name))); chunk_column_stats_scan_internal(scankey, 2, chunk_column_stats_tuple_delete, &count, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); return count; } int ts_chunk_column_stats_delete_by_chunk_id(int32 chunk_id) { ScanKeyData scankey[1]; int count = 0; Assert(chunk_id != INVALID_CHUNK_ID); /* Perform an index scan on chunk_id. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); chunk_column_stats_scan_internal(scankey, 1, chunk_column_stats_tuple_delete, &count, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); return count; } int ts_chunk_column_stats_reset_by_chunk_id(int32 chunk_id) { ScanKeyData scankey[1]; FormData_chunk_column_stats fd = { 0 }; /* reset the range to min and max for all entries belonging to this chunk */ fd.range_start = PG_INT64_MIN; fd.range_end = PG_INT64_MAX; fd.valid = true; Assert(chunk_id != INVALID_CHUNK_ID); /* Perform an index scan on chunk_id. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); return chunk_column_stats_scan_internal(scankey, 1, chunk_column_stats_tuple_update, &fd, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); } int ts_chunk_column_stats_delete_by_hypertable_id(int32 hypertable_id) { ScanKeyData scankey[1]; int count = 0; /* Perform an index scan on hypertable_id. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); chunk_column_stats_scan_internal(scankey, 1, chunk_column_stats_tuple_delete, &count, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); return count; } /* * For min/max ranges we are interested in the occurrence of a value which * possibly lies in multiple entries from _timescaledb_catalog.chunk_column_stats. * * The check for enclosure needs to be run as a FILTER on top of all the matching * entries for the hypertable, column combo. So, we only use ht_id, col_name for * the scan below. */ static int chunk_column_stats_scan_iterator_set(ScanIterator *it, int32 hypertable_id, const char *col_name) { Catalog *catalog = ts_catalog_get(); it->ctx.index = catalog_get_index(catalog, CHUNK_COLUMN_STATS, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX); ts_scan_iterator_scan_key_reset(it); ts_scan_iterator_scan_key_init( it, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); ts_scan_iterator_scan_key_init( it, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_column_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum((col_name))); it->ctx.scandirection = ForwardScanDirection; return it->ctx.nkeys; } /* * We need to get all chunks matching the hypertable ID and the column name. * For each chunk obtained, we need to run a FILTER using the strategies * and the lower/upper bound values provided. * * The EXPLAIN plan is basically like below: * * Index Scan using chunk_column_stats_ht_id_chunk_id_colname_range_start_end_key * on _timescaledb_catalog.chunk_column_stats * Output: chunk_id * Index Cond: ((chunk_column_stats.hypertable_id = :ht_id) AND * (chunk_column_stats.column_name = ':colname')) * Filter: ((chunk_column_stats.range_end BTREE_OP lower_bound/upper_bound) OR * (chunk_column_stats.range_start BTREE_OP lower_bound/upper_bound)) * * The strategies and lower_bound/upper_bound values get assigned in * dimension_restrict_info_range_add function. * * We need to run the "Filter" above ourselves because there's no other PG mechanism for OR * types of checks like these. */ List * ts_chunk_column_stats_get_chunk_ids_by_scan(DimensionRestrictInfo *dri) { ScanIterator it; List *chunkids = NIL; DimensionRestrictInfoOpen *open; Assert(dri && dri->dimension->type == DIMENSION_TYPE_STATS); /* setup the scanner */ it = ts_scan_iterator_create(CHUNK_COLUMN_STATS, AccessShareLock, CurrentMemoryContext); it.ctx.flags |= SCANNER_F_NOEND_AND_NOCLOSE; it.ctx.tuplock = NULL; open = (DimensionRestrictInfoOpen *) dri; /* * We need to get all chunks matching the hypertable ID and the column name. */ chunk_column_stats_scan_iterator_set(&it, dri->dimension->fd.hypertable_id, NameStr(dri->dimension->fd.column_name)); /* * For each chunk obtained, we need to run a FILTER using the strategies * and the lower/upper bound values provided. */ ts_scan_iterator_start_or_restart_scan(&it); ts_scanner_foreach(&it) { FormData_chunk_column_stats fd; bool matched = false; bool chunk_id_isnull; chunk_id_isnull = slot_attisnull( it.tinfo->slot, Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id); /* * We have an entry with INVALID_CHUNK_ID which will match all cases due to * -INF/+INF range entries for it. Ignore that. */ if (chunk_id_isnull) goto done; fill_form_from_slot(it.tinfo->slot, &fd); /* * If an entry is marked "invalid" then it means that the ranges cannot be relied * on. So, we assume the worse case and include this chunk for the scan. * * (Entry is typically marked "invalid" when a compressed chunk becomes partial * due to DML in it.) * * Also, if we have a valid chunnk with -inf/+inf entries then it matches all * queries */ if (!fd.valid || (fd.range_start == PG_INT64_MIN && fd.range_end == PG_INT64_MAX)) { matched = true; goto done; } /* * All data is in int8 format so we do regular comparisons. Also, it's an OR * check so prepare to short circuit if one evaluates to true. * * No real way to know if checking range_start or range_end first will be more * effective. So let's start with range_end checks first. */ switch (open->upper_strategy) { case BTLessEqualStrategyNumber: /* e.g: id <= 90 */ { matched = fd.range_start <= open->upper_bound; } break; case BTLessStrategyNumber: /* e.g: id < 90 */ { matched = fd.range_start < open->upper_bound; } break; default: open->upper_strategy = InvalidStrategy; break; } if (open->upper_strategy != InvalidStrategy && !matched) goto done; /* range_end checks didn't match, check for range_start now */ switch (open->lower_strategy) { case BTGreaterEqualStrategyNumber: { /* range_end is exclusive */ matched = (fd.range_end - 1) >= open->lower_bound; } break; case BTGreaterStrategyNumber: { /* range_end is exclusive */ matched = (fd.range_end - 1) > open->lower_bound; } break; default: /* unsupported strategy */ break; } done: if (matched) chunkids = lappend_int(chunkids, fd.chunk_id); } ts_scan_iterator_close(&it); return chunkids; } /* * Update all entries for this ht_id, old_colname to point to the new_colname */ int ts_chunk_column_stats_set_name(FormData_chunk_column_stats *in_fd, char *new_colname) { ScanIterator it; NameData new_column_name; int count = 0; namestrcpy(&new_column_name, new_colname); /* setup the scanner */ it = ts_scan_iterator_create(CHUNK_COLUMN_STATS, AccessShareLock, CurrentMemoryContext); it.ctx.flags |= SCANNER_F_NOEND_AND_NOCLOSE; it.ctx.tuplock = NULL; /* * We need to get all chunks matching the hypertable ID and the column name. */ chunk_column_stats_scan_iterator_set(&it, in_fd->hypertable_id, NameStr(in_fd->column_name)); /* * For each entry obtained, we need to update the column_name to point to the * new_colname */ ts_scan_iterator_start_or_restart_scan(&it); ts_scanner_foreach(&it) { Datum values[Natts_chunk_column_stats] = { 0 }; bool isnull[Natts_chunk_column_stats] = { false }; bool doReplace[Natts_chunk_column_stats] = { 0 }; bool should_free; TupleInfo *ti = ts_scan_iterator_tuple_info(&it); HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_column_name)] = NameGetDatum(&new_column_name); doReplace[AttrNumberGetAttrOffset(Anum_chunk_column_stats_column_name)] = true; HeapTuple new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, isnull, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); count++; } ts_scan_iterator_close(&it); return count; } static ScanTupleResult invalidate_range_tuple_found(TupleInfo *ti, void *data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); bool valid = false; Datum values[Natts_chunk_column_stats] = { 0 }; bool isnull[Natts_chunk_column_stats] = { 0 }; bool doReplace[Natts_chunk_column_stats] = { 0 }; values[AttrNumberGetAttrOffset(Anum_chunk_column_stats_valid)] = BoolGetDatum(valid); doReplace[AttrNumberGetAttrOffset(Anum_chunk_column_stats_valid)] = true; HeapTuple new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, isnull, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_CONTINUE; } /* * Mark all entries for a given chunk_id as "invalid" */ void ts_chunk_column_stats_set_invalid(int32 hypertable_id, int32 chunk_id) { ScanKeyData scankey[2]; Assert(chunk_id != INVALID_CHUNK_ID); /* Perform an index scan on hypertable_id, chunk_id. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); ScanKeyInit( &scankey[1], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); chunk_column_stats_scan_internal(scankey, 2, invalidate_range_tuple_found, NULL, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); } typedef struct CheckList { Oid chunk_relid; Oid main_table_relid; List *cclist; } CheckList; static ScanTupleResult construct_check_constraint_range_tuple(TupleInfo *ti, void *data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); FormData_chunk_column_stats fd; Constraint *constr; CheckList *checklist = data; fill_form_from_slot(ti->slot, &fd); constr = create_col_stats_check_constraint(&fd, checklist->main_table_relid, checklist->chunk_relid, NULL); if (constr) checklist->cclist = lappend(checklist->cclist, constr); if (should_free) heap_freetuple(tuple); return SCAN_CONTINUE; } /* * Given an input relationObjectId, check that it's a chunk and if yes, check that it * has min/max ranges on it and return a list of constructed check constraint * entries for each such entry. */ List * ts_chunk_column_stats_construct_check_constraints(Relation relation, Oid reloid, Index varno) { FormData_chunk fd; CheckList clist = { 0 }; ListCell *lc; ScanKeyData scankey[2]; ParseState *pstate = NULL; List *result = NIL; /* check if it's not a chunk and return early in that case */ if (!ts_chunk_simple_scan_by_reloid(reloid, &fd, true)) return NIL; clist.chunk_relid = reloid; clist.main_table_relid = ts_hypertable_id_to_relid(fd.hypertable_id, false); Assert(fd.id != INVALID_CHUNK_ID); /* Perform an index scan on hypertable_id, chunk_id. */ ScanKeyInit( &scankey[0], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(fd.hypertable_id)); ScanKeyInit( &scankey[1], Anum_chunk_column_stats_ht_id_chunk_id_column_name_range_start_range_end_idx_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(fd.id)); chunk_column_stats_scan_internal(scankey, 2, construct_check_constraint_range_tuple, &clist, 0, CHUNK_COLUMN_STATS_HT_ID_CHUNK_ID_COLUMN_NAME_IDX, RowExclusiveLock, CurrentMemoryContext); if (clist.cclist) { pstate = make_parsestate(NULL); /* The overall query should be holding an appropriate lock already on this relation */ ParseNamespaceItem *nsitem = addRangeTableEntryForRelation(pstate, relation, AccessShareLock, NULL, false, false); addNSItemToQuery(pstate, nsitem, true, true, true); } foreach (lc, clist.cclist) { Node *expr; Constraint *constr = lfirst(lc); /* Transform raw parsetree to executable expression. */ expr = transformExpr(pstate, constr->raw_expr, EXPR_KIND_CHECK_CONSTRAINT); /* Make sure it yields a boolean result. */ expr = coerce_to_boolean(pstate, expr, "CHECK"); /* Take care of collations. */ assign_expr_collations(pstate, expr); expr = eval_const_expressions(NULL, expr); expr = (Node *) canonicalize_qual((Expr *) expr, true); /* Fix Vars to have the desired varno */ if (varno != 1) ChangeVarNodes(expr, 1, varno, 0); /* * Finally, convert to implicit-AND format (that is, a List) and * append the resulting item(s) to our output list. */ result = list_concat(result, make_ands_implicit((Expr *) expr)); } return result; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/chunk_column_stats.h����������������������������������������������0000664�0000000�0000000�00000004423�15100345067�0023041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "chunk.h" #include "export.h" #include "hypertable_restrict_info.h" /* * A rangespace tracks all columns that need min/max value ranges calculation * for chunks from a given hypertable */ typedef struct ChunkRangeSpace { int32 hypertable_id; uint16 capacity; uint16 num_range_cols; FormData_chunk_column_stats range_cols[FLEXIBLE_ARRAY_MEMBER]; } ChunkRangeSpace; #define CHUNKRANGESPACE_SIZE(num_columns) \ (sizeof(ChunkRangeSpace) + (sizeof(NameData) * (num_columns))) extern ChunkRangeSpace *ts_chunk_column_stats_range_space_scan(int32 hypertable_id, Oid ht_reloid, MemoryContext mctx); extern int ts_chunk_column_stats_update_by_id(int32 chunk_column_stats_id, FormData_chunk_column_stats *fd_range); extern Form_chunk_column_stats ts_chunk_column_stats_lookup(int32 hypertable_id, int32 chunk_id, const char *col_name); extern TSDLLEXPORT int ts_chunk_column_stats_calculate(const Hypertable *ht, const Chunk *chunk); extern int ts_chunk_column_stats_insert(const Hypertable *ht, const Chunk *chunk); extern void ts_chunk_column_stats_drop(const Hypertable *ht, const char *col_name, bool *dropped); extern int ts_chunk_column_stats_delete_by_ht_colname(int32 hypertable_id, const char *col_name); extern TSDLLEXPORT int ts_chunk_column_stats_delete_by_chunk_id(int32 chunk_id); extern TSDLLEXPORT int ts_chunk_column_stats_reset_by_chunk_id(int32 chunk_id); extern int ts_chunk_column_stats_delete_by_hypertable_id(int32 hypertable_id); extern Dimension *ts_chunk_column_stats_fill_dummy_dimension(FormData_chunk_column_stats *r, Oid main_table_relid); extern List *ts_chunk_column_stats_get_chunk_ids_by_scan(DimensionRestrictInfo *dri); extern void ts_chunk_column_stats_set_invalid(int32 hypertable_id, int32 chunk_id); extern int ts_chunk_column_stats_set_name(FormData_chunk_column_stats *in_fd, char *new_colname); extern List *ts_chunk_column_stats_construct_check_constraints(Relation relation, Oid reloid, Index varno); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/compression_chunk_size.c������������������������������������������0000664�0000000�0000000�00000006470�15100345067�0023720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <executor/tuptable.h> #include "export.h" #include "scan_iterator.h" #include "scanner.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_chunk_size.h" static void init_scan_by_uncompressed_chunk_id(ScanIterator *iterator, int32 uncompressed_chunk_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), COMPRESSION_CHUNK_SIZE, COMPRESSION_CHUNK_SIZE_PKEY); ts_scan_iterator_scan_key_init(iterator, Anum_compression_chunk_size_pkey_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(uncompressed_chunk_id)); } TSDLLEXPORT int ts_compression_chunk_size_delete(int32 uncompressed_chunk_id) { ScanIterator iterator = ts_scan_iterator_create(COMPRESSION_CHUNK_SIZE, RowExclusiveLock, CurrentMemoryContext); int count = 0; init_scan_by_uncompressed_chunk_id(&iterator, uncompressed_chunk_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid_only(ti->scanrel, ts_scanner_get_tuple_tid(ti)); count++; } /* Make catalog changes visible */ if (count > 0) CommandCounterIncrement(); return count; } TSDLLEXPORT bool ts_compression_chunk_size_get(int32 chunk_id, Form_compression_chunk_size form) { ScanIterator iterator = ts_scan_iterator_create(COMPRESSION_CHUNK_SIZE, AccessExclusiveLock, CurrentMemoryContext); bool found = false; Assert(form != NULL); init_scan_by_uncompressed_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); memcpy(form, GETSTRUCT(tuple), sizeof(*form)); found = true; Assert(form->chunk_id == chunk_id); if (should_free) heap_freetuple(tuple); break; } ts_scan_iterator_close(&iterator); return found; } TSDLLEXPORT bool ts_compression_chunk_size_update(int32 chunk_id, Form_compression_chunk_size form) { ScanIterator iterator = ts_scan_iterator_create(COMPRESSION_CHUNK_SIZE, RowExclusiveLock, CurrentMemoryContext); bool found = false; CatalogSecurityContext sec_ctx; Assert(form != NULL); init_scan_by_uncompressed_chunk_id(&iterator, chunk_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple copy = heap_copytuple(tuple); Form_compression_chunk_size tupform = (Form_compression_chunk_size) GETSTRUCT(copy); /* Don't update chunk IDs so copy from existing tuple */ form->chunk_id = tupform->chunk_id; form->compressed_chunk_id = tupform->compressed_chunk_id; memcpy(tupform, form, sizeof(FormData_compression_chunk_size)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid_only(ti->scanrel, ts_scanner_get_tuple_tid(ti), copy); ts_catalog_restore_user(&sec_ctx); found = true; heap_freetuple(copy); if (should_free) heap_freetuple(tuple); break; } ts_scan_iterator_close(&iterator); return found; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/compression_chunk_size.h������������������������������������������0000664�0000000�0000000�00000001147�15100345067�0023721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <compat/compat.h> #include <postgres.h> #include <ts_catalog/catalog.h> extern TSDLLEXPORT int ts_compression_chunk_size_delete(int32 uncompressed_chunk_id); extern TSDLLEXPORT bool ts_compression_chunk_size_get(int32 chunk_id, Form_compression_chunk_size form); extern TSDLLEXPORT bool ts_compression_chunk_size_update(int32 chunk_id, Form_compression_chunk_size form); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/compression_settings.c��������������������������������������������0000664�0000000�0000000�00000053744�15100345067�0023424�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_inherits.h> #include <parser/parse_func.h> #include <utils/builtins.h> #include "jsonb_utils.h" #include "scan_iterator.h" #include "scanner.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_settings.h" #include <utils/palloc.h> TSDLLEXPORT const char *ts_sparse_index_type_names[] = { "bloom", "minmax" }; TSDLLEXPORT const char *ts_sparse_index_source_names[] = { "config", "default", "orderby" }; TSDLLEXPORT const char *ts_sparse_index_common_keys[] = { "type", "column", "source", NULL }; static ScanTupleResult compression_settings_tuple_update(TupleInfo *ti, void *data); static HeapTuple compression_settings_formdata_make_tuple(const FormData_compression_settings *fd, TupleDesc desc); /* * Compare two compression settings for equality */ bool ts_compression_settings_equal(const CompressionSettings *left, const CompressionSettings *right) { return ts_array_equal(left->fd.segmentby, right->fd.segmentby) && ts_array_equal(left->fd.orderby, right->fd.orderby) && ts_array_equal(left->fd.orderby_desc, right->fd.orderby_desc) && ts_array_equal(left->fd.orderby_nullsfirst, right->fd.orderby_nullsfirst) && ts_jsonb_equal(left->fd.index, right->fd.index); } /* * Compare two compression settings for equality while ignoring default values. * * This essentially means that any NULL * values should be considered a match because they represent default * values which are determined at chunk level. * * This also means first argument needs to be the hypertable because chunks * cannot have implicit defaults. */ bool ts_compression_settings_equal_with_defaults(const CompressionSettings *ht, const CompressionSettings *chunk) { Assert(!OidIsValid(ht->fd.compress_relid)); return (ht->fd.segmentby == NULL || ts_array_equal(ht->fd.segmentby, chunk->fd.segmentby)) && (ht->fd.orderby == NULL || ts_array_equal(ht->fd.orderby, chunk->fd.orderby)) && (ht->fd.orderby_desc == NULL || ts_array_equal(ht->fd.orderby_desc, chunk->fd.orderby_desc)) && (ht->fd.orderby_nullsfirst == NULL || ts_array_equal(ht->fd.orderby_nullsfirst, chunk->fd.orderby_nullsfirst)) && (ht->fd.index == NULL || ts_jsonb_equal(ht->fd.index, chunk->fd.index)); } CompressionSettings * ts_compression_settings_materialize(const CompressionSettings *src, Oid relid, Oid compress_relid) { CompressionSettings *dst = ts_compression_settings_create(relid, compress_relid, src->fd.segmentby, src->fd.orderby, src->fd.orderby_desc, src->fd.orderby_nullsfirst, src->fd.index); return dst; } CompressionSettings * ts_compression_settings_create(Oid relid, Oid compress_relid, ArrayType *segmentby, ArrayType *orderby, ArrayType *orderby_desc, ArrayType *orderby_nullsfirst, Jsonb *sparse_index) { Catalog *catalog = ts_catalog_get(); CatalogSecurityContext sec_ctx; Relation rel; FormData_compression_settings fd; Assert(OidIsValid(relid)); /* * The default compression settings will always have orderby settings but the user may have * chosen to overwrite it. For both cases all 3 orderby arrays must either have the same number * of entries or be all NULL. */ Assert((orderby && orderby_desc && orderby_nullsfirst) || (!orderby && !orderby_desc && !orderby_nullsfirst)); fd.relid = relid; fd.compress_relid = compress_relid; fd.segmentby = segmentby; fd.orderby = orderby; fd.orderby_desc = orderby_desc; fd.orderby_nullsfirst = orderby_nullsfirst; fd.index = sparse_index; rel = table_open(catalog_get_table_id(catalog, COMPRESSION_SETTINGS), RowExclusiveLock); HeapTuple new_tuple = compression_settings_formdata_make_tuple(&fd, RelationGetDescr(rel)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert(rel, new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); table_close(rel, RowExclusiveLock); return ts_compression_settings_get(relid); } static void compression_settings_fill_from_tuple(CompressionSettings *settings, TupleInfo *ti) { FormData_compression_settings *fd = &settings->fd; Datum values[Natts_compression_settings]; bool nulls[Natts_compression_settings]; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); MemoryContext old = MemoryContextSwitchTo(ti->mctx); fd->relid = DatumGetObjectId(values[AttrNumberGetAttrOffset(Anum_compression_settings_relid)]); if (nulls[AttrNumberGetAttrOffset(Anum_compression_settings_compress_relid)]) fd->compress_relid = InvalidOid; else fd->compress_relid = DatumGetObjectId( values[AttrNumberGetAttrOffset(Anum_compression_settings_compress_relid)]); if (nulls[AttrNumberGetAttrOffset(Anum_compression_settings_segmentby)]) fd->segmentby = NULL; else fd->segmentby = DatumGetArrayTypePCopy( values[AttrNumberGetAttrOffset(Anum_compression_settings_segmentby)]); if (nulls[AttrNumberGetAttrOffset(Anum_compression_settings_orderby)]) fd->orderby = NULL; else fd->orderby = DatumGetArrayTypePCopy( values[AttrNumberGetAttrOffset(Anum_compression_settings_orderby)]); if (nulls[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_desc)]) fd->orderby_desc = NULL; else fd->orderby_desc = DatumGetArrayTypePCopy( values[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_desc)]); if (nulls[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_nullsfirst)]) fd->orderby_nullsfirst = NULL; else fd->orderby_nullsfirst = DatumGetArrayTypePCopy( values[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_nullsfirst)]); if (nulls[AttrNumberGetAttrOffset(Anum_compression_settings_index)]) fd->index = NULL; else fd->index = DatumGetJsonbPCopy(values[AttrNumberGetAttrOffset(Anum_compression_settings_index)]); MemoryContextSwitchTo(old); if (should_free) heap_freetuple(tuple); } static void compression_settings_iterator_init(ScanIterator *iterator, Oid relid, bool by_compress_relid) { int indexid = by_compress_relid ? COMPRESSION_SETTINGS_COMPRESS_RELID_IDX : COMPRESSION_SETTINGS_PKEY; iterator->ctx.index = catalog_get_index(ts_catalog_get(), COMPRESSION_SETTINGS, indexid); ts_scan_iterator_scan_key_init(iterator, by_compress_relid ? Anum_compression_settings_compress_relid_idx_relid : Anum_compression_settings_pkey_relid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relid)); } /* * Get compression settings for a relation. * * When 'by_compress_relid' is false, the 'relid' refers to the "main" * relation being compressed. When it is true the 'relid' refers to the * relation containing the associated compressed data. */ static CompressionSettings * compression_settings_get(Oid relid, bool by_compress_relid) { CompressionSettings *settings = NULL; ScanIterator iterator = ts_scan_iterator_create(COMPRESSION_SETTINGS, AccessShareLock, CurrentMemoryContext); compression_settings_iterator_init(&iterator, relid, by_compress_relid); ts_scanner_start_scan(&iterator.ctx); TupleInfo *ti = ts_scanner_next(&iterator.ctx); if (!ti) return NULL; settings = palloc0(sizeof(CompressionSettings)); compression_settings_fill_from_tuple(settings, ti); ts_scan_iterator_close(&iterator); return settings; } /* * Get the compression settings for the relation referred to by 'relid'. */ TSDLLEXPORT CompressionSettings * ts_compression_settings_get(Oid relid) { return compression_settings_get(relid, false); } /* * Get the compression settings for a relation given its associated compressed * relation. * * Ideally, settings should only be looked up by "primary key", i.e., the * non-compressed chunk's 'relid', and in that case this function wouldn't be * needed. It might be possible to remove this function in the future. */ TSDLLEXPORT CompressionSettings * ts_compression_settings_get_by_compress_relid(Oid relid) { CompressionSettings *settings = compression_settings_get(relid, true); Ensure(settings, "compression settings not found for %s", get_rel_name(relid)); return settings; } /* * Delete compression settings for a relation. * * When 'by_compress_relid' is false, the 'relid' refers to the "main" * relation being compressed. When it is true the 'relid' refers to the * relation containing the associated compressed data. */ static bool compression_settings_delete(Oid relid, bool by_compress_relid) { if (!OidIsValid(relid)) return false; int count = 0; ScanIterator iterator = ts_scan_iterator_create(COMPRESSION_SETTINGS, RowExclusiveLock, CurrentMemoryContext); compression_settings_iterator_init(&iterator, relid, by_compress_relid); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); count++; } return count > 0; } /* * Delete entries matching the non-compressed relation. */ TSDLLEXPORT bool ts_compression_settings_delete(Oid relid) { return compression_settings_delete(relid, false); } /* * Delete entries matching a compressed relation. */ TSDLLEXPORT bool ts_compression_settings_delete_by_compress_relid(Oid relid) { return compression_settings_delete(relid, true); } /* * Delete entries matching either the primary key (non-compressed relation) or * the secondary key (compressed relation). */ TSDLLEXPORT bool ts_compression_settings_delete_any(Oid relid) { if (!ts_compression_settings_delete(relid)) return ts_compression_settings_delete_by_compress_relid(relid); return true; } static void compression_settings_rename_column(CompressionSettings *settings, const char *old, const char *new) { Jsonb *replacejsonb = NULL; bool replaced = false; settings->fd.segmentby = ts_array_replace_text(settings->fd.segmentby, old, new); settings->fd.orderby = ts_array_replace_text(settings->fd.orderby, old, new); /* jsonb filed can not be mutated inplace, a new copy will be created */ if (settings->fd.index && ts_jsonb_has_key_value_str_field(settings->fd.index, ts_sparse_index_common_keys[SparseIndexKeyCol], old)) { replacejsonb = ts_jsonb_replace_key_value_str_field(settings->fd.index, ts_sparse_index_common_keys[SparseIndexKeyCol], old, new, &replaced); } settings->fd.index = replaced ? replacejsonb : settings->fd.index; ts_compression_settings_update(settings); } TSDLLEXPORT void ts_compression_settings_rename_column_cascade(Oid parent_relid, const char *old, const char *new) { CompressionSettings *settings = ts_compression_settings_get(parent_relid); if (settings) compression_settings_rename_column(settings, old, new); List *children = find_inheritance_children(parent_relid, NoLock); ListCell *lc; foreach (lc, children) { Oid relid = lfirst_oid(lc); settings = ts_compression_settings_get(relid); if (settings) compression_settings_rename_column(settings, old, new); } } TSDLLEXPORT int ts_compression_settings_update(CompressionSettings *settings) { Catalog *catalog = ts_catalog_get(); FormData_compression_settings *fd = &settings->fd; ScanKeyData scankey[1]; if (settings->fd.orderby && (settings->fd.segmentby || settings->fd.index)) { Datum datum; bool isnull; ArrayIterator it = array_create_iterator(settings->fd.orderby, 0, NULL); while (array_iterate(it, &datum, &isnull)) { if (settings->fd.segmentby && ts_array_is_member(settings->fd.segmentby, TextDatumGetCString(datum))) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("cannot use column \"%s\" for both ordering and segmenting", TextDatumGetCString(datum)), errhint("Use separate columns for the timescaledb.compress_orderby and" " timescaledb.compress_segmentby options."))); } if (settings->fd.index && ts_contains_sparse_index_config(settings, TextDatumGetCString(datum), ts_sparse_index_type_names [_SparseIndexTypeEnumBloom])) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("the orderby column \"%s\" cannot have a bloom sparse index ", TextDatumGetCString(datum)), errdetail("For orderby columns, a minmax sparse index is added " "automatically and cannot have bloom sparse index."))); } } } if (settings->fd.index && settings->fd.segmentby) { Datum datum; bool isnull; ArrayIterator it = array_create_iterator(settings->fd.segmentby, 0, NULL); while (array_iterate(it, &datum, &isnull)) { for (int i = 0; i < _SparseIndexTypeEnumMax; i++) { if (ts_contains_sparse_index_config(settings, TextDatumGetCString(datum), ts_sparse_index_type_names[i])) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("the segmentby column \"%s\" can not have sparse " "indexes", TextDatumGetCString(datum)))); } } } } /* * The default compression settings will always have orderby settings but the user may have * chosen to overwrite it. For both cases all 3 orderby arrays must either have the same number * of entries or be all NULL. */ Assert( (settings->fd.orderby && settings->fd.orderby_desc && settings->fd.orderby_nullsfirst) || (!settings->fd.orderby && !settings->fd.orderby_desc && !settings->fd.orderby_nullsfirst)); ScanKeyInit(&scankey[0], Anum_compression_settings_pkey_relid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(fd->relid)); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, COMPRESSION_SETTINGS), .index = catalog_get_index(catalog, COMPRESSION_SETTINGS, COMPRESSION_SETTINGS_PKEY), .nkeys = 1, .scankey = scankey, .data = settings, .tuple_found = compression_settings_tuple_update, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; return ts_scanner_scan(&scanctx); } static HeapTuple compression_settings_formdata_make_tuple(const FormData_compression_settings *fd, TupleDesc desc) { Datum values[Natts_compression_settings] = { 0 }; bool nulls[Natts_compression_settings] = { false }; values[AttrNumberGetAttrOffset(Anum_compression_settings_relid)] = ObjectIdGetDatum(fd->relid); if (OidIsValid(fd->compress_relid)) values[AttrNumberGetAttrOffset(Anum_compression_settings_compress_relid)] = ObjectIdGetDatum(fd->compress_relid); else nulls[AttrNumberGetAttrOffset(Anum_compression_settings_compress_relid)] = true; if (fd->segmentby) values[AttrNumberGetAttrOffset(Anum_compression_settings_segmentby)] = PointerGetDatum(fd->segmentby); else nulls[AttrNumberGetAttrOffset(Anum_compression_settings_segmentby)] = true; if (fd->orderby) values[AttrNumberGetAttrOffset(Anum_compression_settings_orderby)] = PointerGetDatum(fd->orderby); else nulls[AttrNumberGetAttrOffset(Anum_compression_settings_orderby)] = true; if (fd->orderby_desc) values[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_desc)] = PointerGetDatum(fd->orderby_desc); else nulls[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_desc)] = true; if (fd->orderby_nullsfirst) values[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_nullsfirst)] = PointerGetDatum(fd->orderby_nullsfirst); else nulls[AttrNumberGetAttrOffset(Anum_compression_settings_orderby_nullsfirst)] = true; if (fd->index) values[AttrNumberGetAttrOffset(Anum_compression_settings_index)] = JsonbPGetDatum(fd->index); else nulls[AttrNumberGetAttrOffset(Anum_compression_settings_index)] = true; return heap_form_tuple(desc, values, nulls); } static ScanTupleResult compression_settings_tuple_update(TupleInfo *ti, void *data) { CompressionSettings *settings = data; HeapTuple new_tuple; CatalogSecurityContext sec_ctx; new_tuple = compression_settings_formdata_make_tuple(&settings->fd, ts_scanner_get_tupledesc(ti)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); return SCAN_DONE; } void ts_convert_sparse_index_config_to_jsonb(JsonbParseState *parse_state, SparseIndexConfig *config) { pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_str(parse_state, ts_sparse_index_common_keys[SparseIndexKeyType], ts_sparse_index_type_names[config->base.type]); /* type */ ts_jsonb_add_str(parse_state, ts_sparse_index_common_keys[SparseIndexKeyCol], config->base.col); /* column */ ts_jsonb_add_str(parse_state, ts_sparse_index_common_keys[SparseIndexKeySource], ts_sparse_index_source_names[config->base.source]); /* source */ pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); } static Jsonb * find_sparse_index_config(Jsonb *jsonb, const char *attname, const char *sparse_index_type) { Oid fnargtypes[] = { JSONBOID, TEXTOID, TEXTOID }; FmgrInfo flinfo; LOCAL_FCINFO(fcinfo, 3); Datum result_datum; if (jsonb == NULL || JB_ROOT_COUNT(jsonb) == 0) return NULL; else if (attname == NULL) elog(ERROR, "sparse index attname is null"); bool valid_type = false; for (int i = 0; i < _SparseIndexTypeEnumMax; i++) { if (strcmp(ts_sparse_index_type_names[i], sparse_index_type) == 0) { valid_type = true; break; } } if (!valid_type) elog(ERROR, "\"%s\" is not a valid sparse index configuration type", sparse_index_type); List *funcname = list_make2(makeString(FUNCTIONS_SCHEMA_NAME), makeString("jsonb_get_matching_index_entry")); Oid fnoid = LookupFuncName(funcname, sizeof(fnargtypes) / sizeof(fnargtypes[0]), fnargtypes, false); if (!OidIsValid(fnoid)) elog(ERROR, "function %s.%s does not exist", FUNCTIONS_SCHEMA_NAME, "jsonb_get_matching_index_entry"); fmgr_info(fnoid, &flinfo); InitFunctionCallInfoData(*fcinfo, &flinfo, 3, InvalidOid, NULL, NULL); FC_SET_ARG(fcinfo, 0, JsonbPGetDatum(jsonb)); FC_SET_ARG(fcinfo, 1, CStringGetTextDatum(attname)); FC_SET_ARG(fcinfo, 2, CStringGetTextDatum(sparse_index_type)); result_datum = FunctionCallInvoke(fcinfo); if (fcinfo->isnull) return NULL; return DatumGetJsonbP(result_datum); } static bool contains_sparse_index_config(Jsonb *jsonb, const char *attname, const char *sparse_index_type) { return (find_sparse_index_config(jsonb, attname, sparse_index_type) != NULL); } /* checks if given attribute has a sparse index of given type */ bool ts_contains_sparse_index_config(CompressionSettings *settings, const char *attname, const char *sparse_index_type) { return contains_sparse_index_config(settings->fd.index, attname, sparse_index_type); } /* adds orderby sparse index settings into fd.index */ Jsonb * ts_add_orderby_sparse_index(CompressionSettings *settings) { Datum datum; bool isnull; JsonbParseState *parse_state = NULL; JsonbIterator *it_json; JsonbValue v; JsonbIteratorToken r; Jsonb *sparse_index = settings->fd.index; /* nothing to do if no orderby columns */ if (!settings->fd.orderby) { return sparse_index; } pushJsonbValue(&parse_state, WJB_BEGIN_ARRAY, NULL); /* add existing sparse index */ if (settings->fd.index) { it_json = JsonbIteratorInit(&sparse_index->root); JsonbIteratorNext(&it_json, &v, false); /* WJB_BEGIN_ARRAY */ while ((r = JsonbIteratorNext(&it_json, &v, true)) != WJB_END_ARRAY) { Assert(r == WJB_ELEM); pushJsonbValue(&parse_state, r, &v); } } /* add orderby sparse settings */ ArrayIterator it = array_create_iterator(settings->fd.orderby, 0, NULL); while (array_iterate(it, &datum, &isnull)) { /* * check if sparse index for column already exists * Validation is done by ts_compression_settings_update */ if (settings->fd.index && ts_jsonb_has_key_value_str_field(settings->fd.index, ts_sparse_index_common_keys[SparseIndexKeyCol], TextDatumGetCString(datum))) { continue; } SparseIndexConfig config; config.base.type = _SparseIndexTypeEnumMinmax; config.base.col = TextDatumGetCString(datum); config.base.source = _SparseIndexSourceEnumOrderby; ts_convert_sparse_index_config_to_jsonb(parse_state, &config); } return JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_ARRAY, NULL)); } /* removed orderby sparse index settings from fd.index */ Jsonb * ts_remove_orderby_sparse_index(CompressionSettings *settings) { JsonbParseState *parse_state = NULL; JsonbContainer *container; JsonbIterator *it_json; JsonbIteratorToken r; JsonbValue v; Jsonb *sparse_index = settings->fd.index; bool removed = false; bool has_object = false; const char *key_name_source = ts_sparse_index_common_keys[SparseIndexKeySource]; const char *value_name_orderby = ts_sparse_index_source_names[_SparseIndexSourceEnumOrderby]; /* nothing to do if no orderby columns */ if (!settings->fd.orderby || !sparse_index) { return sparse_index; } pushJsonbValue(&parse_state, WJB_BEGIN_ARRAY, NULL); it_json = JsonbIteratorInit(&sparse_index->root); JsonbIteratorNext(&it_json, &v, false); /* WJB_BEGIN_ARRAY */ while ((r = JsonbIteratorNext(&it_json, &v, true)) != WJB_END_ARRAY) { Ensure(r == WJB_ELEM && v.type == jbvBinary && JsonContainerIsObject(v.val.binary.data), "sparse index format must be an array of objects"); container = v.val.binary.data; JsonbValue value; getKeyJsonValueFromContainer(container, key_name_source, strlen(key_name_source), &value); if (value.type == jbvString && ((int) strlen(value_name_orderby) == value.val.string.len) && (int) strncmp(value_name_orderby, value.val.string.val, value.val.string.len) == 0) { removed = true; continue; } has_object = true; pushJsonbValue(&parse_state, r, &v); } /* this is a possible edge case, log it just in case */ if (!removed) elog(LOG, "orderby settings existed, but no orderby sparse index was removed"); return has_object ? JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_ARRAY, NULL)) : NULL; } ����������������������������timescaledb-2.23.0/src/ts_catalog/compression_settings.h��������������������������������������������0000664�0000000�0000000�00000005567�15100345067�0023431�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <catalog/pg_type.h> #include "ts_catalog/catalog.h" typedef struct CompressionSettings { FormData_compression_settings fd; } CompressionSettings; typedef enum SparseIndexTypeEnum { _SparseIndexTypeEnumBloom = 0, _SparseIndexTypeEnumMinmax, _SparseIndexTypeEnumMax } SparseIndexTypeEnum; typedef enum SparseIndexSourceEnum { _SparseIndexSourceEnumConfig = 0, _SparseIndexSourceEnumDefault, _SparseIndexSourceEnumOrderby, _SparseIndexSourceEnumMax } SparseIndexSourceEnum; typedef enum SparseIndexConfigKeys { SparseIndexKeyType = 0, SparseIndexKeyCol, SparseIndexKeySource, SparseIndexKeyCustom } SparseIndexConfigKeys; extern TSDLLEXPORT const char *ts_sparse_index_type_names[]; extern TSDLLEXPORT const char *ts_sparse_index_source_names[]; extern TSDLLEXPORT const char *ts_sparse_index_common_keys[]; typedef struct SparseIndexBase { SparseIndexTypeEnum type; char *col; SparseIndexSourceEnum source; } SparseIndexBase; typedef struct SparseIndexConfig { SparseIndexBase base; } SparseIndexConfig; TSDLLEXPORT CompressionSettings * ts_compression_settings_create(Oid relid, Oid compress_relid, ArrayType *segmentby, ArrayType *orderby, ArrayType *orderby_desc, ArrayType *orderby_nullsfirst, Jsonb *sparse_index); TSDLLEXPORT CompressionSettings *ts_compression_settings_get(Oid relid); TSDLLEXPORT CompressionSettings *ts_compression_settings_get_by_compress_relid(Oid relid); TSDLLEXPORT CompressionSettings *ts_compression_settings_materialize(const CompressionSettings *src, Oid relid, Oid compress_relid); TSDLLEXPORT bool ts_compression_settings_delete(Oid relid); TSDLLEXPORT bool ts_compression_settings_delete_by_compress_relid(Oid relid); TSDLLEXPORT bool ts_compression_settings_delete_any(Oid relid); TSDLLEXPORT bool ts_compression_settings_equal(const CompressionSettings *left, const CompressionSettings *right); TSDLLEXPORT bool ts_compression_settings_equal_with_defaults(const CompressionSettings *ht, const CompressionSettings *chunk); TSDLLEXPORT int ts_compression_settings_update(CompressionSettings *settings); TSDLLEXPORT void ts_compression_settings_rename_column_cascade(Oid parent_relid, const char *old, const char *new); TSDLLEXPORT void ts_convert_sparse_index_config_to_jsonb(JsonbParseState *parse_state, SparseIndexConfig *config); TSDLLEXPORT bool ts_contains_sparse_index_config(CompressionSettings *settings, const char *attname, const char *sparse_index_type); TSDLLEXPORT Jsonb *ts_add_orderby_sparse_index(CompressionSettings *settings); TSDLLEXPORT Jsonb *ts_remove_orderby_sparse_index(CompressionSettings *settings); �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/continuous_agg.c��������������������������������������������������0000664�0000000�0000000�00000142501�15100345067�0022155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file handles commands on continuous aggs that should be allowed in * apache only mode. Right now this consists mostly of drop commands */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/dependency.h> #include <catalog/namespace.h> #include <catalog/pg_trigger.h> #include <commands/trigger.h> #include <executor/spi.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <nodes/makefuncs.h> #include <replication/slot.h> #include <storage/lmgr.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/lsyscache.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "bgw/job.h" #include "cross_module_fn.h" #include "errors.h" #include "func_cache.h" #include "hypercube.h" #include "hypertable.h" #include "hypertable_cache.h" #include "scan_iterator.h" #include "time_bucket.h" #include "time_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_settings.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/continuous_aggs_watermark.h" #include "utils.h" #include "with_clause/alter_table_with_clause.h" #define BUCKET_FUNCTION_SERIALIZE_VERSION 1 #define CHECK_NAME_MATCH(name1, name2) (namestrcmp(name1, name2) == 0) TS_FUNCTION_INFO_V1(ts_invalidation_plugin_name); /* * Return the full name of the invalidation plugin, with version and all. */ Datum ts_invalidation_plugin_name(PG_FUNCTION_ARGS) { PG_RETURN_TEXT_P(cstring_to_text(CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_PLUGIN_NAME)); } static void init_scan_by_mat_hypertable_id(ScanIterator *iterator, const int32 mat_hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGG, CONTINUOUS_AGG_PKEY); ts_scan_iterator_scan_key_init(iterator, Anum_continuous_agg_pkey_mat_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(mat_hypertable_id)); } static void init_scan_cagg_bucket_function_by_mat_hypertable_id(ScanIterator *iterator, const int32 mat_hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_BUCKET_FUNCTION, CONTINUOUS_AGGS_BUCKET_FUNCTION_PKEY_IDX); ts_scan_iterator_scan_key_init(iterator, Anum_continuous_aggs_bucket_function_pkey_mat_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(mat_hypertable_id)); } static void init_scan_by_raw_hypertable_id(ScanIterator *iterator, const int32 raw_hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGG, CONTINUOUS_AGG_RAW_HYPERTABLE_ID_IDX); ts_scan_iterator_scan_key_init(iterator, Anum_continuous_agg_raw_hypertable_id_idx_raw_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(raw_hypertable_id)); } static void init_invalidation_threshold_scan_by_hypertable_id(ScanIterator *iterator, const int32 raw_hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY); ts_scan_iterator_scan_key_init(iterator, Anum_continuous_aggs_invalidation_threshold_pkey_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(raw_hypertable_id)); } static void init_hypertable_invalidation_log_scan_by_hypertable_id(ScanIterator *iterator, const int32 raw_hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG, CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_IDX); ts_scan_iterator_scan_key_init( iterator, Anum_continuous_aggs_hypertable_invalidation_log_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(raw_hypertable_id)); } static void init_materialization_invalidation_log_scan_by_materialization_id(ScanIterator *iterator, const int32 materialization_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG, CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_IDX); ts_scan_iterator_scan_key_init( iterator, Anum_continuous_aggs_materialization_invalidation_log_idx_materialization_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(materialization_id)); } static int32 number_of_continuous_aggs_attached(int32 raw_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); int32 count = 0; init_scan_by_raw_hypertable_id(&iterator, raw_hypertable_id); ts_scanner_foreach(&iterator) { count++; } return count; } static void invalidation_threshold_delete(int32 raw_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, RowExclusiveLock, CurrentMemoryContext); init_invalidation_threshold_scan_by_hypertable_id(&iterator, raw_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); } } static void cagg_bucket_function_delete(int32 mat_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_BUCKET_FUNCTION, RowExclusiveLock, CurrentMemoryContext); init_scan_cagg_bucket_function_by_mat_hypertable_id(&iterator, mat_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); } } static void hypertable_invalidation_log_delete(int32 raw_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG, RowExclusiveLock, CurrentMemoryContext); init_hypertable_invalidation_log_scan_by_hypertable_id(&iterator, raw_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); } } void ts_get_invalidation_replication_slot_name(char *slotname, Size szslot) { snprintf(slotname, szslot, "ts_%u_cagg", MyDatabaseId); } void ts_materialization_invalidation_log_delete_inner(int32 mat_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG, RowExclusiveLock, CurrentMemoryContext); elog(DEBUG1, "materialization log delete for hypertable %d", mat_hypertable_id); init_materialization_invalidation_log_scan_by_materialization_id(&iterator, mat_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); } } static HeapTuple continuous_agg_formdata_make_tuple(const FormData_continuous_agg *fd, TupleDesc desc) { Datum values[Natts_continuous_agg]; bool nulls[Natts_continuous_agg] = { false }; memset(values, 0, sizeof(Datum) * Natts_continuous_agg); values[AttrNumberGetAttrOffset(Anum_continuous_agg_mat_hypertable_id)] = Int32GetDatum(fd->mat_hypertable_id); values[AttrNumberGetAttrOffset(Anum_continuous_agg_raw_hypertable_id)] = Int32GetDatum(fd->raw_hypertable_id); if (fd->parent_mat_hypertable_id == INVALID_HYPERTABLE_ID) nulls[AttrNumberGetAttrOffset(Anum_continuous_agg_parent_mat_hypertable_id)] = true; else { values[AttrNumberGetAttrOffset(Anum_continuous_agg_parent_mat_hypertable_id)] = Int32GetDatum(fd->parent_mat_hypertable_id); } values[AttrNumberGetAttrOffset(Anum_continuous_agg_user_view_schema)] = NameGetDatum(&fd->user_view_schema); values[AttrNumberGetAttrOffset(Anum_continuous_agg_user_view_name)] = NameGetDatum(&fd->user_view_name); values[AttrNumberGetAttrOffset(Anum_continuous_agg_partial_view_schema)] = NameGetDatum(&fd->partial_view_schema); values[AttrNumberGetAttrOffset(Anum_continuous_agg_partial_view_name)] = NameGetDatum(&fd->partial_view_name); values[AttrNumberGetAttrOffset(Anum_continuous_agg_direct_view_schema)] = NameGetDatum(&fd->direct_view_schema); values[AttrNumberGetAttrOffset(Anum_continuous_agg_direct_view_name)] = NameGetDatum(&fd->direct_view_name); values[AttrNumberGetAttrOffset(Anum_continuous_agg_materialize_only)] = BoolGetDatum(fd->materialized_only); values[AttrNumberGetAttrOffset(Anum_continuous_agg_finalized)] = BoolGetDatum(fd->finalized); return heap_form_tuple(desc, values, nulls); } static void continuous_agg_formdata_fill(FormData_continuous_agg *fd, const TupleInfo *ti) { bool should_free; HeapTuple tuple; Datum values[Natts_continuous_agg]; bool nulls[Natts_continuous_agg] = { false }; tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, nulls); fd->mat_hypertable_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_continuous_agg_mat_hypertable_id)]); fd->raw_hypertable_id = DatumGetInt32(values[AttrNumberGetAttrOffset(Anum_continuous_agg_raw_hypertable_id)]); if (nulls[AttrNumberGetAttrOffset(Anum_continuous_agg_parent_mat_hypertable_id)]) fd->parent_mat_hypertable_id = INVALID_HYPERTABLE_ID; else fd->parent_mat_hypertable_id = DatumGetInt32( values[AttrNumberGetAttrOffset(Anum_continuous_agg_parent_mat_hypertable_id)]); namestrcpy(&fd->user_view_schema, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_agg_user_view_schema)])); namestrcpy(&fd->user_view_name, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_agg_user_view_name)])); namestrcpy(&fd->partial_view_schema, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_agg_partial_view_schema)])); namestrcpy(&fd->partial_view_name, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_agg_partial_view_name)])); namestrcpy(&fd->direct_view_schema, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_agg_direct_view_schema)])); namestrcpy(&fd->direct_view_name, DatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_agg_direct_view_name)])); fd->materialized_only = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_continuous_agg_materialize_only)]); fd->finalized = DatumGetBool(values[AttrNumberGetAttrOffset(Anum_continuous_agg_finalized)]); if (should_free) heap_freetuple(tuple); } /* * Fill the fields of a integer based bucketing function */ static void cagg_fill_bucket_function_integer_based(ContinuousAggBucketFunction *bf, bool *isnull, Datum *values) { /* Bucket width */ Assert(!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_width)]); const char *bucket_width_str = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_width)]); Assert(strlen(bucket_width_str) > 0); bf->bucket_integer_width = pg_strtoint64(bucket_width_str); /* Bucket origin cannot be used with integer based buckets */ Assert(isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)] == true); /* Bucket offset */ if (!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_offset)]) { const char *offset_str = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_offset)]); bf->bucket_integer_offset = pg_strtoint64(offset_str); } /* Timezones cannot be used with integer based buckets */ Assert(isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_timezone)] == true); } /* * Fill the fields of a time based bucketing function */ static void cagg_fill_bucket_function_time_based(ContinuousAggBucketFunction *bf, bool *isnull, Datum *values) { /* * bucket_width * * The value is stored as TEXT since we have to store the interval value of time * buckets and also the number value of integer based buckets. */ Assert(!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_width)]); const char *bucket_width_str = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_width)]); Assert(strlen(bucket_width_str) > 0); bf->bucket_time_width = DatumGetIntervalP( DirectFunctionCall3(interval_in, CStringGetDatum(bucket_width_str), InvalidOid, -1)); /* Bucket origin */ if (!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)]) { const char *origin_str = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)]); bf->bucket_time_origin = DatumGetTimestamp(DirectFunctionCall3(timestamptz_in, CStringGetDatum(origin_str), ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1))); } else { TIMESTAMP_NOBEGIN(bf->bucket_time_origin); } /* Bucket offset */ if (!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_offset)]) { const char *offset_str = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_offset)]); bf->bucket_time_offset = DatumGetIntervalP( DirectFunctionCall3(interval_in, CStringGetDatum(offset_str), InvalidOid, -1)); } /* Bucket timezone */ if (!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_timezone)]) { bf->bucket_time_timezone = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_timezone)]); } } static void continuous_agg_fill_bucket_function(int32 mat_hypertable_id, ContinuousAggBucketFunction *bf) { ScanIterator iterator; int count = 0; iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_BUCKET_FUNCTION, AccessShareLock, CurrentMemoryContext); init_scan_cagg_bucket_function_by_mat_hypertable_id(&iterator, mat_hypertable_id); ts_scanner_foreach(&iterator) { Datum values[Natts_continuous_aggs_bucket_function]; bool isnull[Natts_continuous_aggs_bucket_function]; bool should_free; HeapTuple tuple = ts_scan_iterator_fetch_heap_tuple(&iterator, false, &should_free); /* * Our usual GETSTRUCT() approach doesn't work when TEXT fields are involved, * thus a more robust approach with heap_deform_tuple() is used here. */ heap_deform_tuple(tuple, ts_scan_iterator_tupledesc(&iterator), values, isnull); /* Bucket function */ Assert(!isnull[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_function)]); const char *bucket_function_str = TextDatumGetCString( values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_function)]); bf->bucket_function = DatumGetObjectId( DirectFunctionCall1(regprocedurein, CStringGetDatum(bucket_function_str))); bf->bucket_time_based = ts_continuous_agg_bucket_on_interval(bf->bucket_function); if (bf->bucket_time_based) { cagg_fill_bucket_function_time_based(bf, isnull, values); } else { cagg_fill_bucket_function_integer_based(bf, isnull, values); } /* Bucket fixed width */ Assert(!isnull[AttrNumberGetAttrOffset( Anum_continuous_aggs_bucket_function_bucket_fixed_width)]); bf->bucket_fixed_interval = DatumGetBool(values[AttrNumberGetAttrOffset( Anum_continuous_aggs_bucket_function_bucket_fixed_width)]); count++; if (should_free) heap_freetuple(tuple); } /* * This function should never be called unless we know that the corresponding * cagg exists and uses a variable-sized bucket. There should be exactly one * entry in .continuous_aggs_bucket_function catalog table for such a cagg. */ if (count != 1) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("invalid or missing information about the bucketing function for cagg"), errdetail("%d", mat_hypertable_id))); } } static void continuous_agg_init(ContinuousAgg *cagg, const Form_continuous_agg fd) { Oid nspid = get_namespace_oid(NameStr(fd->user_view_schema), false); Hypertable *cagg_ht = ts_hypertable_get_by_id(fd->mat_hypertable_id); const Dimension *time_dim; Assert(NULL != cagg_ht); time_dim = hyperspace_get_open_dimension(cagg_ht->space, 0); Assert(NULL != time_dim); cagg->partition_type = ts_dimension_get_partition_type(time_dim); cagg->relid = get_relname_relid(NameStr(fd->user_view_name), nspid); memcpy(&cagg->data, fd, sizeof(cagg->data)); Assert(OidIsValid(cagg->relid)); Assert(OidIsValid(cagg->partition_type)); cagg->bucket_function = palloc0(sizeof(ContinuousAggBucketFunction)); continuous_agg_fill_bucket_function(cagg->data.mat_hypertable_id, cagg->bucket_function); } TSDLLEXPORT ContinuousAggInfo ts_continuous_agg_get_all_caggs_info(int32 raw_hypertable_id) { ContinuousAggInfo all_caggs_info; List *caggs = ts_continuous_aggs_find_by_raw_table_id(raw_hypertable_id); ListCell *lc; all_caggs_info.mat_hypertable_ids = NIL; all_caggs_info.bucket_functions = NIL; Assert(list_length(caggs) > 0); foreach (lc, caggs) { ContinuousAgg *cagg = lfirst(lc); all_caggs_info.bucket_functions = lappend(all_caggs_info.bucket_functions, cagg->bucket_function); all_caggs_info.mat_hypertable_ids = lappend_int(all_caggs_info.mat_hypertable_ids, cagg->data.mat_hypertable_id); } return all_caggs_info; } TSDLLEXPORT ContinuousAggHypertableStatus ts_continuous_agg_hypertable_status(int32 hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); ContinuousAggHypertableStatus status = HypertableIsNotContinuousAgg; ts_scanner_foreach(&iterator) { FormData_continuous_agg data; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); continuous_agg_formdata_fill(&data, ti); if (data.raw_hypertable_id == hypertable_id) status |= HypertableIsRawTable; if (data.mat_hypertable_id == hypertable_id) status |= HypertableIsMaterialization; if (status == HypertableIsMaterializationAndRaw) { ts_scan_iterator_close(&iterator); return status; } } return status; } TSDLLEXPORT bool ts_continuous_agg_hypertable_all_finalized(int32 raw_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); bool all_finalized = true; init_scan_by_raw_hypertable_id(&iterator, raw_hypertable_id); ts_scanner_foreach(&iterator) { FormData_continuous_agg data; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); continuous_agg_formdata_fill(&data, ti); if (!data.finalized) { all_finalized = false; break; } } ts_scan_iterator_close(&iterator); return all_finalized; } TSDLLEXPORT List * ts_continuous_aggs_find_by_raw_table_id(int32 raw_hypertable_id) { List *continuous_aggs = NIL; ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); init_scan_by_raw_hypertable_id(&iterator, raw_hypertable_id); ts_scanner_foreach(&iterator) { ContinuousAgg *ca; FormData_continuous_agg data; MemoryContext oldmctx; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); continuous_agg_formdata_fill(&data, ti); oldmctx = MemoryContextSwitchTo(ts_scan_iterator_get_result_memory_context(&iterator)); ca = palloc0(sizeof(*ca)); continuous_agg_init(ca, &data); continuous_aggs = lappend(continuous_aggs, ca); MemoryContextSwitchTo(oldmctx); } return continuous_aggs; } /* Find a continuous aggregate by the materialized hypertable id */ ContinuousAgg * ts_continuous_agg_find_by_mat_hypertable_id(int32 mat_hypertable_id, bool missing_ok) { ContinuousAgg *ca = NULL; ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, RowExclusiveLock, CurrentMemoryContext); init_scan_by_mat_hypertable_id(&iterator, mat_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); FormData_continuous_agg form; continuous_agg_formdata_fill(&form, ti); /* Note that this scan can only match at most once, so we assert on * `ca` here. */ Assert(ca == NULL); ca = ts_scan_iterator_alloc_result(&iterator, sizeof(*ca)); continuous_agg_init(ca, &form); Assert(ca && ca->data.mat_hypertable_id == mat_hypertable_id); } ts_scan_iterator_close(&iterator); if (ca == NULL && !missing_ok) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid materialized hypertable ID: %d", mat_hypertable_id))); } return ca; } static bool continuous_agg_find_by_name(const char *schema, const char *name, ContinuousAggViewType type, FormData_continuous_agg *fd) { ScanIterator iterator; AttrNumber view_name_attrnum = 0; AttrNumber schema_name_attrnum = 0; int count = 0; Assert(schema); Assert(name); switch (type) { case ContinuousAggUserView: schema_name_attrnum = Anum_continuous_agg_user_view_schema; view_name_attrnum = Anum_continuous_agg_user_view_name; break; case ContinuousAggPartialView: schema_name_attrnum = Anum_continuous_agg_partial_view_schema; view_name_attrnum = Anum_continuous_agg_partial_view_name; break; case ContinuousAggDirectView: schema_name_attrnum = Anum_continuous_agg_direct_view_schema; view_name_attrnum = Anum_continuous_agg_direct_view_name; break; case ContinuousAggAnyView: break; } iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); if (type != ContinuousAggAnyView) { ts_scan_iterator_scan_key_init(&iterator, schema_name_attrnum, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(schema)); ts_scan_iterator_scan_key_init(&iterator, view_name_attrnum, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(name)); } ts_scanner_foreach(&iterator) { ContinuousAggViewType vtype = type; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); FormData_continuous_agg data; continuous_agg_formdata_fill(&data, ti); if (vtype == ContinuousAggAnyView) vtype = ts_continuous_agg_view_type(&data, schema, name); if (vtype != ContinuousAggAnyView) { memcpy(fd, &data, sizeof(*fd)); count++; } } Assert(count <= 1); return count == 1; } ContinuousAgg * ts_continuous_agg_find_by_view_name(const char *schema, const char *name, ContinuousAggViewType type) { FormData_continuous_agg fd; ContinuousAgg *ca; if (!continuous_agg_find_by_name(schema, name, type, &fd)) return NULL; ca = palloc0(sizeof(ContinuousAgg)); continuous_agg_init(ca, &fd); return ca; } ContinuousAgg * ts_continuous_agg_find_userview_name(const char *schema, const char *name) { return ts_continuous_agg_find_by_view_name(schema, name, ContinuousAggUserView); } /* * Find a continuous agg object by the main relid. * * The relid is the user-facing object ID that represents the continuous * aggregate (i.e., the query view's ID). */ ContinuousAgg * ts_continuous_agg_find_by_relid(Oid relid) { const char *relname = get_rel_name(relid); const char *schemaname = get_namespace_name(get_rel_namespace(relid)); if (NULL == relname || NULL == schemaname) return NULL; return ts_continuous_agg_find_userview_name(schemaname, relname); } /* * Find a continuous aggregate by range var. */ ContinuousAgg * ts_continuous_agg_find_by_rv(const RangeVar *rv) { Oid relid; if (rv == NULL) return NULL; relid = RangeVarGetRelid(rv, NoLock, true); if (!OidIsValid(relid)) return NULL; return ts_continuous_agg_find_by_relid(relid); } static ObjectAddress get_and_lock_rel_by_name(const Name schema, const Name name, LOCKMODE mode) { ObjectAddress addr; Oid relid = InvalidOid; Oid nspid = get_namespace_oid(NameStr(*schema), true); if (OidIsValid(nspid)) { relid = get_relname_relid(NameStr(*name), nspid); if (OidIsValid(relid)) LockRelationOid(relid, mode); } ObjectAddressSet(addr, RelationRelationId, relid); return addr; } static ObjectAddress get_and_lock_rel_by_hypertable_id(int32 hypertable_id, LOCKMODE mode) { ObjectAddress addr; Oid relid = ts_hypertable_id_to_relid(hypertable_id, true); if (OidIsValid(relid)) LockRelationOid(relid, mode); ObjectAddressSet(addr, RelationRelationId, relid); return addr; } /* * Drops continuous aggs and all related objects. * * This function is intended to be run by event trigger during CASCADE, * which implies that most of the dependent objects potentially could be * dropped including associated schema. * * These objects are: * * - user view itself * - continuous agg catalog entry * - partial view * - materialization hypertable * - trigger on the raw hypertable (hypertable specified in the user view) * - copy of the user view query (AKA the direct view) * * NOTE: The order in which the objects are dropped should be EXACTLY the * same as in materialize.c * * drop_user_view indicates whether to drop the user view. * (should be false if called as part of the drop-user-view callback) */ static void drop_continuous_agg(FormData_continuous_agg *cadata, bool drop_user_view) { Catalog *catalog; ScanIterator iterator; ObjectAddress user_view = { 0 }; ObjectAddress partial_view = { 0 }; ObjectAddress direct_view = { 0 }; ObjectAddress raw_hypertable = { 0 }; ObjectAddress mat_hypertable = { 0 }; bool raw_hypertable_has_other_caggs; /* Delete the job before taking locks as it kills long-running jobs * which we would otherwise wait on */ List *jobs = ts_bgw_job_find_by_hypertable_id(cadata->mat_hypertable_id); ListCell *lc; foreach (lc, jobs) { BgwJob *job = lfirst(lc); ts_bgw_job_delete_by_id(job->fd.id); } /* * Lock objects. * * Following objects might be already dropped in case of CASCADE * drop including the associated schema object. * * NOTE: the lock order matters, see tsl/src/materialization.c. * Perform all locking upfront. * * AccessExclusiveLock is needed to drop triggers and also prevent * concurrent DML commands. * * It is needed also in the case that we are using WAL-based invalidation * collection since we want to serialize create and drop of continuous * aggregates. */ if (drop_user_view) user_view = get_and_lock_rel_by_name(&cadata->user_view_schema, &cadata->user_view_name, AccessExclusiveLock); raw_hypertable = get_and_lock_rel_by_hypertable_id(cadata->raw_hypertable_id, AccessExclusiveLock); mat_hypertable = get_and_lock_rel_by_hypertable_id(cadata->mat_hypertable_id, AccessExclusiveLock); /* Lock catalogs */ catalog = ts_catalog_get(); LockRelationOid(catalog_get_table_id(catalog, BGW_JOB), RowExclusiveLock); LockRelationOid(catalog_get_table_id(catalog, CONTINUOUS_AGG), RowExclusiveLock); LockRelationOid(catalog_get_table_id(catalog, CONTINUOUS_AGGS_WATERMARK), RowExclusiveLock); raw_hypertable_has_other_caggs = OidIsValid(raw_hypertable.objectId) && number_of_continuous_aggs_attached(cadata->raw_hypertable_id) > 1; if (!raw_hypertable_has_other_caggs) { LockRelationOid(catalog_get_table_id(catalog, CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG), RowExclusiveLock); LockRelationOid(catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), RowExclusiveLock); } /* * Following objects might be already dropped in case of CASCADE * drop including the associated schema object. */ partial_view = get_and_lock_rel_by_name(&cadata->partial_view_schema, &cadata->partial_view_name, AccessExclusiveLock); direct_view = get_and_lock_rel_by_name(&cadata->direct_view_schema, &cadata->direct_view_name, AccessExclusiveLock); /* Delete catalog entry */ iterator = ts_scan_iterator_create(CONTINUOUS_AGG, RowExclusiveLock, CurrentMemoryContext); init_scan_by_mat_hypertable_id(&iterator, cadata->mat_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); FormData_continuous_agg form; continuous_agg_formdata_fill(&form, ti); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); /* Delete all related rows */ if (!raw_hypertable_has_other_caggs) { hypertable_invalidation_log_delete(form.raw_hypertable_id); } ts_materialization_invalidation_log_delete_inner(form.mat_hypertable_id); if (!raw_hypertable_has_other_caggs) { invalidation_threshold_delete(form.raw_hypertable_id); } /* Delete watermark */ ts_cagg_watermark_delete_by_mat_hypertable_id(form.mat_hypertable_id); } cagg_bucket_function_delete(cadata->mat_hypertable_id); /* Perform actual deletions now */ if (OidIsValid(user_view.objectId)) performDeletion(&user_view, DROP_RESTRICT, 0); /* * Drop invalidation slot if there are no hypertables using WAL-based * invalidation collection. * * This is important since there is no actor that reads the slot, which * means that the WAL cannot be pruned. */ if (ts_guc_enable_cagg_wal_based_invalidation) { char slot_name[TS_INVALIDATION_SLOT_NAME_MAX]; ts_get_invalidation_replication_slot_name(slot_name, sizeof(slot_name)); if (ts_guc_enable_cagg_wal_based_invalidation && SearchNamedReplicationSlot(slot_name, true) != NULL) ts_hypertable_drop_invalidation_replication_slot(slot_name); } if (OidIsValid(mat_hypertable.objectId)) { performDeletion(&mat_hypertable, DROP_CASCADE, 0); ts_compression_settings_delete(mat_hypertable.objectId); ts_hypertable_delete_by_id(cadata->mat_hypertable_id); } if (OidIsValid(partial_view.objectId)) performDeletion(&partial_view, DROP_RESTRICT, 0); if (OidIsValid(direct_view.objectId)) performDeletion(&direct_view, DROP_RESTRICT, 0); } /* * This is a called when a hypertable gets dropped. * * If the hypertable is a raw hypertable for a continuous agg, * drop the continuous agg. * * If the hypertable is a materialization hypertable, error out * and force the user to drop the continuous agg instead. */ void ts_continuous_agg_drop_hypertable_callback(int32 hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); ts_scanner_foreach(&iterator) { FormData_continuous_agg data; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); continuous_agg_formdata_fill(&data, ti); if (data.raw_hypertable_id == hypertable_id) drop_continuous_agg(&data, true); if (data.mat_hypertable_id == hypertable_id) ereport(ERROR, (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST), errmsg("cannot drop the materialized table because it is required by a " "continuous aggregate"))); } } /* Block dropping the partial and direct view if the continuous aggregate still exists */ static void drop_internal_view(const FormData_continuous_agg *fd) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); int count = 0; init_scan_by_mat_hypertable_id(&iterator, fd->mat_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); count++; } if (count > 0) ereport(ERROR, (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST), errmsg( "cannot drop the partial/direct view because it is required by a continuous " "aggregate"))); } /* This gets called when a view gets dropped. */ static void continuous_agg_drop_view_callback(FormData_continuous_agg *fd, const char *schema, const char *name) { ContinuousAggViewType vtyp; vtyp = ts_continuous_agg_view_type(fd, schema, name); switch (vtyp) { case ContinuousAggUserView: drop_continuous_agg(fd, false /* The user view has already been dropped */); break; case ContinuousAggPartialView: case ContinuousAggDirectView: drop_internal_view(fd); break; default: elog(ERROR, "unknown continuous aggregate view type"); } } bool ts_continuous_agg_drop(const char *view_schema, const char *view_name) { FormData_continuous_agg fd; bool found = continuous_agg_find_by_name(view_schema, view_name, ContinuousAggAnyView, &fd); if (found) continuous_agg_drop_view_callback(&fd, view_schema, view_name); return found; } static inline bool ts_continuous_agg_is_user_view_schema(FormData_continuous_agg *data, const char *schema) { return CHECK_NAME_MATCH(&data->user_view_schema, schema); } static inline bool ts_continuous_agg_is_partial_view_schema(FormData_continuous_agg *data, const char *schema) { return CHECK_NAME_MATCH(&data->partial_view_schema, schema); } static inline bool ts_continuous_agg_is_direct_view_schema(FormData_continuous_agg *data, const char *schema) { return CHECK_NAME_MATCH(&data->direct_view_schema, schema); } ContinuousAggViewType ts_continuous_agg_view_type(FormData_continuous_agg *data, const char *schema, const char *name) { if (CHECK_NAME_MATCH(&data->user_view_schema, schema) && CHECK_NAME_MATCH(&data->user_view_name, name)) return ContinuousAggUserView; else if (CHECK_NAME_MATCH(&data->partial_view_schema, schema) && CHECK_NAME_MATCH(&data->partial_view_name, name)) return ContinuousAggPartialView; else if (CHECK_NAME_MATCH(&data->direct_view_schema, schema) && CHECK_NAME_MATCH(&data->direct_view_name, name)) return ContinuousAggDirectView; else return ContinuousAggAnyView; } typedef struct CaggRenameCtx { const char *old_schema; const char *old_name; const char *new_schema; const char *new_name; ObjectType *object_type; void (*process_rename)(FormData_continuous_agg *form, bool *do_update, void *data); } CaggRenameCtx; static void continuous_agg_rename_process_rename_schema(FormData_continuous_agg *form, bool *do_update, void *data) { CaggRenameCtx *ctx = (CaggRenameCtx *) data; if (ts_continuous_agg_is_user_view_schema(form, ctx->old_schema)) { namestrcpy(&form->user_view_schema, ctx->new_schema); *do_update = true; } if (ts_continuous_agg_is_partial_view_schema(form, ctx->old_schema)) { namestrcpy(&form->partial_view_schema, ctx->new_schema); *do_update = true; } if (ts_continuous_agg_is_direct_view_schema(form, ctx->old_schema)) { namestrcpy(&form->direct_view_schema, ctx->new_schema); *do_update = true; } } static void continuous_agg_rename_process_rename_view(FormData_continuous_agg *form, bool *do_update, void *data) { CaggRenameCtx *ctx = (CaggRenameCtx *) data; ContinuousAggViewType vtyp; vtyp = ts_continuous_agg_view_type(form, ctx->old_schema, ctx->old_name); switch (vtyp) { case ContinuousAggUserView: { if (*ctx->object_type == OBJECT_VIEW) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter continuous aggregate using ALTER VIEW"), errhint("Use ALTER MATERIALIZED VIEW to alter a continuous aggregate."))); Assert(*ctx->object_type == OBJECT_MATVIEW); *ctx->object_type = OBJECT_VIEW; namestrcpy(&form->user_view_schema, ctx->new_schema); namestrcpy(&form->user_view_name, ctx->new_name); *do_update = true; break; } case ContinuousAggPartialView: { namestrcpy(&form->partial_view_schema, ctx->new_schema); namestrcpy(&form->partial_view_name, ctx->new_name); *do_update = true; break; } case ContinuousAggDirectView: { namestrcpy(&form->direct_view_schema, ctx->new_schema); namestrcpy(&form->direct_view_name, ctx->new_name); *do_update = true; break; } default: break; } } static ScanTupleResult continuous_agg_rename(TupleInfo *ti, void *data) { CaggRenameCtx *ctx = (CaggRenameCtx *) data; FormData_continuous_agg form; bool do_update = false; CatalogSecurityContext sec_ctx; continuous_agg_formdata_fill(&form, ti); ctx->process_rename(&form, &do_update, (void *) ctx); if (do_update) { HeapTuple new_tuple = continuous_agg_formdata_make_tuple(&form, ts_scanner_get_tupledesc(ti)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_update_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti), new_tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(new_tuple); } return SCAN_CONTINUE; } void ts_continuous_agg_rename_schema_name(const char *old_schema, const char *new_schema) { CaggRenameCtx cagg_rename_ctx = { .old_schema = old_schema, .new_schema = new_schema, .process_rename = continuous_agg_rename_process_rename_schema, }; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CONTINUOUS_AGG), .index = InvalidOid, .tuple_found = continuous_agg_rename, .data = &cagg_rename_ctx, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; ts_scanner_scan(&scanctx); } void ts_continuous_agg_rename_view(const char *old_schema, const char *old_name, const char *new_schema, const char *new_name, ObjectType *object_type) { CaggRenameCtx cagg_rename_ctx = { .old_schema = old_schema, .old_name = old_name, .new_schema = new_schema, .new_name = new_name, .object_type = object_type, .process_rename = continuous_agg_rename_process_rename_view, }; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CONTINUOUS_AGG), .index = InvalidOid, .tuple_found = continuous_agg_rename, .data = &cagg_rename_ctx, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; ts_scanner_scan(&scanctx); } static int32 find_raw_hypertable_for_materialization(int32 mat_hypertable_id) { PG_USED_FOR_ASSERTS_ONLY short count = 0; int32 htid = INVALID_HYPERTABLE_ID; ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, RowExclusiveLock, CurrentMemoryContext); init_scan_by_mat_hypertable_id(&iterator, mat_hypertable_id); ts_scanner_foreach(&iterator) { bool isnull; Datum datum = slot_getattr(ts_scan_iterator_slot(&iterator), Anum_continuous_agg_raw_hypertable_id, &isnull); Assert(!isnull); htid = DatumGetInt32(datum); count++; } Assert(count <= 1); ts_scan_iterator_close(&iterator); return htid; } /* Continuous aggregate materialization hypertables inherit integer_now func * from the raw hypertable (unless it was explicitly reset for cont. aggregate. * Walk the materialization hypertable ->raw hypertable tree till * we find a hypertable that has integer_now_func set. */ TSDLLEXPORT const Dimension * ts_continuous_agg_find_integer_now_func_by_materialization_id(int32 mat_htid) { int32 raw_htid = mat_htid; const Dimension *par_dim = NULL; while (raw_htid != INVALID_HYPERTABLE_ID) { Hypertable *raw_ht = ts_hypertable_get_by_id(raw_htid); const Dimension *open_dim = hyperspace_get_open_dimension(raw_ht->space, 0); if (strlen(NameStr(open_dim->fd.integer_now_func)) != 0 && strlen(NameStr(open_dim->fd.integer_now_func_schema)) != 0) { par_dim = open_dim; break; } mat_htid = raw_htid; raw_htid = find_raw_hypertable_for_materialization(mat_htid); } return par_dim; } TSDLLEXPORT void ts_continuous_agg_invalidate_chunk(Hypertable *ht, Chunk *chunk) { int64 start = ts_chunk_primary_dimension_start(chunk); int64 end = ts_chunk_primary_dimension_end(chunk); Assert(hyperspace_get_open_dimension(ht->space, 0)->fd.id == chunk->cube->slices[0]->fd.dimension_id); ts_cm_functions->continuous_agg_invalidate_raw_ht(ht, start, end); } /* Determines if a bucket is using integer or an interval partitioning */ bool ts_continuous_agg_bucket_on_interval(Oid bucket_function) { Assert(OidIsValid(bucket_function)); FuncInfo *func_info = ts_func_cache_get(bucket_function); Ensure(func_info != NULL, "unable to get function info for Oid %d", bucket_function); /* The function has to be a currently allowed function or one of the deprecated bucketing * functions */ Assert(func_info->allowed_in_cagg_definition || IS_DEPRECATED_TIME_BUCKET_NG_FUNC(func_info)); Oid first_bucket_arg = func_info->arg_types[0]; return first_bucket_arg == INTERVALOID; } /* * Calls the desired time bucket function depending on the arguments. If the experimental flag is * set on ContinuousAggBucketFunction, one of time_bucket_ng() versions is used. This is a common * procedure used by ts_compute_* below. */ static Datum generic_time_bucket(const ContinuousAggBucketFunction *bf, Datum timestamp) { FuncInfo *func_info = ts_func_cache_get_bucketing_func(bf->bucket_function); Ensure(func_info != NULL, "unable to get bucket function for Oid %d", bf->bucket_function); bool is_experimental = func_info->origin == ORIGIN_TIMESCALE_EXPERIMENTAL; if (!is_experimental) { if (bf->bucket_time_timezone != NULL) { if (TIMESTAMP_NOT_FINITE(bf->bucket_time_origin)) { /* using default origin */ return DirectFunctionCall3(ts_timestamptz_timezone_bucket, IntervalPGetDatum(bf->bucket_time_width), timestamp, CStringGetTextDatum(bf->bucket_time_timezone)); } else { /* custom origin specified */ return DirectFunctionCall4(ts_timestamptz_timezone_bucket, IntervalPGetDatum(bf->bucket_time_width), timestamp, CStringGetTextDatum(bf->bucket_time_timezone), TimestampTzGetDatum(bf->bucket_time_origin)); } } if (TIMESTAMP_NOT_FINITE(bf->bucket_time_origin)) { /* using default origin */ return DirectFunctionCall2(ts_timestamp_bucket, IntervalPGetDatum(bf->bucket_time_width), timestamp); } else { /* custom origin specified */ return DirectFunctionCall3(ts_timestamp_bucket, IntervalPGetDatum(bf->bucket_time_width), timestamp, TimestampTzGetDatum(bf->bucket_time_origin)); } } else { if (bf->bucket_time_timezone != NULL) { if (TIMESTAMP_NOT_FINITE(bf->bucket_time_origin)) { /* using default origin */ return DirectFunctionCall3(ts_time_bucket_ng_timezone, IntervalPGetDatum(bf->bucket_time_width), timestamp, CStringGetTextDatum(bf->bucket_time_timezone)); } else { /* custom origin specified */ return DirectFunctionCall4(ts_time_bucket_ng_timezone_origin, IntervalPGetDatum(bf->bucket_time_width), timestamp, TimestampTzGetDatum(bf->bucket_time_origin), CStringGetTextDatum(bf->bucket_time_timezone)); } } if (TIMESTAMP_NOT_FINITE(bf->bucket_time_origin)) { /* using default origin */ return DirectFunctionCall2(ts_time_bucket_ng_timestamp, IntervalPGetDatum(bf->bucket_time_width), timestamp); } else { /* custom origin specified */ return DirectFunctionCall3(ts_time_bucket_ng_timestamp, IntervalPGetDatum(bf->bucket_time_width), timestamp, TimestampTzGetDatum(bf->bucket_time_origin)); } } } /* * Adds one bf->bucket_size interval to the timestamp. This is a common * procedure used by ts_compute_* below. * * If bf->bucket_time_timezone is specified, the math happens in this timezone. * Otherwise, it happens in UTC. */ static Datum generic_add_interval(const ContinuousAggBucketFunction *bf, Datum timestamp) { Datum tzname = 0; bool has_timezone = (bf->bucket_time_timezone != NULL); if (has_timezone) { /* * Convert 'timestamp' to TIMESTAMP at given timezone. * The code is equal to 'timestamptz AT TIME ZONE tzname'. */ tzname = CStringGetTextDatum(bf->bucket_time_timezone); timestamp = DirectFunctionCall2(timestamptz_zone, tzname, timestamp); } timestamp = DirectFunctionCall2(timestamp_pl_interval, timestamp, IntervalPGetDatum(bf->bucket_time_width)); if (has_timezone) { Assert(tzname != 0); timestamp = DirectFunctionCall2(timestamp_zone, tzname, timestamp); } return timestamp; } /* * Computes inscribed refresh_window for variable-sized buckets. * * The algorithm is simple: * * end = time_bucket(bucket_size, end) * * if(start != time_bucket(bucket_size, start)) * start = time_bucket(bucket_size, start) + interval bucket_size * */ void ts_compute_inscribed_bucketed_refresh_window_variable(int64 *start, int64 *end, const ContinuousAggBucketFunction *bf) { Datum start_old, end_old, start_aligned, end_aliged; /* * It's OK to use TIMESTAMPOID here. Variable-sized buckets can be used * only for dates, timestamps and timestamptz's. For all these types our * internal time representation is microseconds relative the UNIX epoch. * So the results will be correct regardless of the actual type used in * the CAGG. For more details see ts_internal_to_time_value() implementation. */ start_old = ts_internal_to_time_value(*start, TIMESTAMPOID); end_old = ts_internal_to_time_value(*end, TIMESTAMPOID); start_aligned = generic_time_bucket(bf, start_old); end_aliged = generic_time_bucket(bf, end_old); if (DatumGetTimestamp(start_aligned) != DatumGetTimestamp(start_old)) { start_aligned = generic_add_interval(bf, start_aligned); } *start = ts_time_value_to_internal(start_aligned, TIMESTAMPOID); *end = ts_time_value_to_internal(end_aliged, TIMESTAMPOID); } /* * Computes circumscribed refresh_window for variable-sized buckets. * * The algorithm is simple: * * start = time_bucket(bucket_size, start) * * if(end != time_bucket(bucket_size, end)) * end = time_bucket(bucket_size, end) + interval bucket_size */ void ts_compute_circumscribed_bucketed_refresh_window_variable(int64 *start, int64 *end, const ContinuousAggBucketFunction *bf) { Datum start_old, end_old, start_new, end_new; /* * It's OK to use TIMESTAMPOID here. * See the comment in ts_compute_inscribed_bucketed_refresh_window_variable() */ start_old = ts_internal_to_time_value(*start, TIMESTAMPOID); end_old = ts_internal_to_time_value(*end, TIMESTAMPOID); start_new = generic_time_bucket(bf, start_old); end_new = generic_time_bucket(bf, end_old); if (DatumGetTimestamp(end_new) != DatumGetTimestamp(end_old)) { end_new = generic_add_interval(bf, end_new); } *start = ts_time_value_to_internal(start_new, TIMESTAMPOID); *end = ts_time_value_to_internal(end_new, TIMESTAMPOID); } /* * Calculates the beginning of the next bucket. * * The algorithm is just: * * val = time_bucket(bucket_size, val) + interval bucket_size */ int64 ts_compute_beginning_of_the_next_bucket_variable(int64 timeval, const ContinuousAggBucketFunction *bf) { Datum val_new; Datum val_old; /* * It's OK to use TIMESTAMPOID here. * See the comment in ts_compute_inscribed_bucketed_refresh_window_variable() */ val_old = ts_internal_to_time_value(timeval, TIMESTAMPOID); val_new = generic_time_bucket(bf, val_old); val_new = generic_add_interval(bf, val_new); return ts_time_value_to_internal(val_new, TIMESTAMPOID); } Oid ts_cagg_permissions_check(Oid cagg_oid, Oid userid) { Oid ownerid = ts_rel_get_owner(cagg_oid); if (!has_privs_of_role(userid, ownerid)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("must be owner of continuous aggregate \"%s\"", get_rel_name(cagg_oid)))); return ownerid; } Query * ts_continuous_agg_get_query(ContinuousAgg *cagg) { Oid cagg_view_oid; Relation cagg_view_rel; RuleLock *cagg_view_rules; RewriteRule *rule; Query *cagg_view_query; /* * Get the partial_view definition for the finalized version because * the user view doesn't have the "GROUP BY" clause anymore. */ if (ContinuousAggIsFinalized(cagg)) cagg_view_oid = ts_get_relation_relid(NameStr(cagg->data.partial_view_schema), NameStr(cagg->data.partial_view_name), false); else cagg_view_oid = ts_get_relation_relid(NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name), false); cagg_view_rel = table_open(cagg_view_oid, AccessShareLock); cagg_view_rules = cagg_view_rel->rd_rules; Assert(cagg_view_rules && cagg_view_rules->numLocks == 1); rule = cagg_view_rules->rules[0]; if (rule->event != CMD_SELECT) ereport(ERROR, (errcode(ERRCODE_TS_UNEXPECTED), errmsg("unexpected rule event for view"))); cagg_view_query = (Query *) copyObject(linitial(rule->actions)); table_close(cagg_view_rel, NoLock); return cagg_view_query; } /* * Get the width of a fixed size bucket */ int64 ts_continuous_agg_fixed_bucket_width(const ContinuousAggBucketFunction *bucket_function) { Assert(bucket_function->bucket_fixed_interval == true); if (bucket_function->bucket_time_based) { Interval *interval = bucket_function->bucket_time_width; Assert(interval->month == 0); return interval->time + (interval->day * USECS_PER_DAY); } else { return bucket_function->bucket_integer_width; } } /* * Get the width of a bucket */ int64 ts_continuous_agg_bucket_width(const ContinuousAggBucketFunction *bucket_function) { int64 bucket_width; if (bucket_function->bucket_fixed_interval == false) { /* * There are several cases of variable-sized buckets: * 1. Monthly buckets * 2. Buckets with timezones * 3. Cases 1 and 2 at the same time * * For months we simply take 30 days like on interval_to_int64 and * multiply this number by the number of months in the bucket. This * reduces the task to days/hours/minutes scenario. * * Days/hours/minutes case is handled the same way as for fixed-sized * buckets. The refresh window at least two buckets in size is adequate * for such corner cases as DST. */ /* bucket_function should always be specified for variable-sized buckets */ Assert(bucket_function != NULL); /* ... and bucket_function->bucket_time_width too */ Assert(bucket_function->bucket_time_width != NULL); /* Make a temporary copy of bucket_width */ Interval interval = *bucket_function->bucket_time_width; interval.day += 30 * interval.month; interval.month = 0; bucket_width = ts_interval_value_to_internal(IntervalPGetDatum(&interval), INTERVALOID); } else { bucket_width = ts_continuous_agg_fixed_bucket_width(bucket_function); } return bucket_width; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/continuous_agg.h��������������������������������������������������0000664�0000000�0000000�00000020515�15100345067�0022162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <catalog/pg_type.h> #include <nodes/parsenodes.h> #include "chunk.h" #include "ts_catalog/catalog.h" #include "compat/compat.h" #include "with_clause/with_clause_parser.h" #define TS_INVALIDATION_SLOT_NAME_MAX (32) /*switch to ts user for _timescaledb_internal access */ #define SWITCH_TO_TS_USER(schemaname, newuid, saved_uid, saved_secctx) \ do \ { \ if ((schemaname) && \ strncmp(schemaname, INTERNAL_SCHEMA_NAME, strlen(INTERNAL_SCHEMA_NAME)) == 0) \ (newuid) = ts_catalog_database_info_get()->owner_uid; \ else \ (newuid) = InvalidOid; \ if (OidIsValid((newuid))) \ { \ GetUserIdAndSecContext(&(saved_uid), &(saved_secctx)); \ SetUserIdAndSecContext(uid, (saved_secctx) | SECURITY_LOCAL_USERID_CHANGE); \ } \ } while (0) #define RESTORE_USER(newuid, saved_uid, saved_secctx) \ do \ { \ if (OidIsValid((newuid))) \ SetUserIdAndSecContext(saved_uid, saved_secctx); \ } while (0); /* Does the function belong to a time_bucket_ng function that is no longer allowed * in CAgg definitions? */ #define IS_DEPRECATED_TIME_BUCKET_NG_FUNC(funcinfo) \ ((funcinfo->origin == ORIGIN_TIMESCALE_EXPERIMENTAL) && \ (strcmp("time_bucket_ng", funcinfo->funcname) == 0)) typedef enum ContinuousAggViewType { ContinuousAggUserView = 0, ContinuousAggPartialView, ContinuousAggDirectView, ContinuousAggAnyView } ContinuousAggViewType; typedef enum ContinuousAggInvalidateUsing { ContinuousAggInvalidateUsingDefault = 0, ContinuousAggInvalidateUsingTrigger, ContinuousAggInvalidateUsingWal, } ContinuousAggInvalidateUsing; /* * Information about the bucketing function. */ typedef struct ContinuousAggBucketFunction { /* Oid of the bucketing function. In the catalog table, the regprocedure is used. This ensures * that the Oid is mapped to a string when a backup is taken and the string is converted back to * the Oid when the backup is restored. This way, we can use an Oid in the catalog table even * when a backup is restored and the Oid may have changed. However, the dependency management in * PostgreSQL does not track the Oid. If the function is dropped and a new one is created, the * Oid changes and this value points to a non-existing Oid. This can not happen in real-world * situations since PostgreSQL protects the bucket_function from deletion until the CAgg is * defined. */ Oid bucket_function; Oid bucket_width_type; /* type of bucket_width */ /* Is the interval of the bucket fixed? */ bool bucket_fixed_interval; /* Is the bucket defined on a time datatype ?*/ bool bucket_time_based; /* * Fields that are used for time based buckets */ Interval *bucket_time_width; /* * Custom origin value stored as UTC timestamp. * If not specified, stores infinity. */ TimestampTz bucket_time_origin; Interval *bucket_time_offset; char *bucket_time_timezone; /* * Fields that are used on integer based buckets */ int64 bucket_integer_width; int64 bucket_integer_offset; } ContinuousAggBucketFunction; typedef struct ContinuousAgg { FormData_continuous_agg data; /* Info about the time bucketing function */ ContinuousAggBucketFunction *bucket_function; /* Relid of the user-facing view */ Oid relid; /* Type of the primary partitioning dimension */ Oid partition_type; } ContinuousAgg; static inline bool ContinuousAggIsFinalized(const ContinuousAgg *cagg) { return (cagg->data.finalized == true); } static inline bool ContinuousAggIsHierarchical(const ContinuousAgg *cagg) { return (cagg->data.parent_mat_hypertable_id != INVALID_HYPERTABLE_ID); } typedef enum ContinuousAggHypertableStatus { HypertableIsNotContinuousAgg = 0, HypertableIsMaterialization = 1, HypertableIsRawTable = 2, HypertableIsMaterializationAndRaw = HypertableIsMaterialization | HypertableIsRawTable, } ContinuousAggHypertableStatus; typedef struct ContinuousAggInfo { /* (int32) elements */ List *mat_hypertable_ids; /* (const ContinuousAggBucketFunction *) elements; stores NULL for fixed buckets */ List *bucket_functions; } ContinuousAggInfo; typedef struct ContinuousAggPolicyOffset { Datum value; Oid type; bool isnull; const char *name; } ContinuousAggPolicyOffset; extern TSDLLEXPORT Oid ts_cagg_permissions_check(Oid cagg_oid, Oid userid); extern TSDLLEXPORT ContinuousAggInfo ts_continuous_agg_get_all_caggs_info(int32 raw_hypertable_id); extern TSDLLEXPORT ContinuousAgg * ts_continuous_agg_find_by_mat_hypertable_id(int32 mat_hypertable_id, bool missing_ok); extern TSDLLEXPORT void ts_materialization_invalidation_log_delete_inner(int32 mat_hypertable_id); extern TSDLLEXPORT ContinuousAggHypertableStatus ts_continuous_agg_hypertable_status(int32 hypertable_id); extern TSDLLEXPORT bool ts_continuous_agg_hypertable_all_finalized(int32 raw_hypertable_id); extern TSDLLEXPORT List *ts_continuous_aggs_find_by_raw_table_id(int32 raw_hypertable_id); extern TSDLLEXPORT ContinuousAgg *ts_continuous_agg_find_by_view_name(const char *schema, const char *name, ContinuousAggViewType type); extern TSDLLEXPORT ContinuousAgg *ts_continuous_agg_find_by_relid(Oid relid); extern TSDLLEXPORT ContinuousAgg *ts_continuous_agg_find_by_rv(const RangeVar *rv); extern bool ts_continuous_agg_drop(const char *view_schema, const char *view_name); extern void ts_continuous_agg_drop_hypertable_callback(int32 hypertable_id); extern TSDLLEXPORT ContinuousAggViewType ts_continuous_agg_view_type(FormData_continuous_agg *data, const char *schema, const char *name); extern TSDLLEXPORT void ts_continuous_agg_rename_schema_name(const char *old_schema, const char *new_schema); extern TSDLLEXPORT void ts_continuous_agg_rename_view(const char *old_schema, const char *old_name, const char *new_schema, const char *new_name, ObjectType *object_type); extern TSDLLEXPORT const Dimension * ts_continuous_agg_find_integer_now_func_by_materialization_id(int32 mat_htid); extern ContinuousAgg *ts_continuous_agg_find_userview_name(const char *schema, const char *name); extern TSDLLEXPORT void ts_continuous_agg_invalidate_chunk(Hypertable *ht, Chunk *chunk); extern TSDLLEXPORT bool ts_continuous_agg_bucket_on_interval(Oid bucket_function); extern TSDLLEXPORT void ts_compute_inscribed_bucketed_refresh_window_variable(int64 *start, int64 *end, const ContinuousAggBucketFunction *bf); extern TSDLLEXPORT void ts_compute_circumscribed_bucketed_refresh_window_variable(int64 *start, int64 *end, const ContinuousAggBucketFunction *bf); extern TSDLLEXPORT int64 ts_compute_beginning_of_the_next_bucket_variable( int64 timeval, const ContinuousAggBucketFunction *bf); extern TSDLLEXPORT Query *ts_continuous_agg_get_query(ContinuousAgg *cagg); extern TSDLLEXPORT int64 ts_continuous_agg_fixed_bucket_width(const ContinuousAggBucketFunction *bucket_function); extern TSDLLEXPORT int64 ts_continuous_agg_bucket_width(const ContinuousAggBucketFunction *bucket_function); extern TSDLLEXPORT void ts_get_invalidation_replication_slot_name(char *slotname, Size szslot); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/continuous_aggs_watermark.c���������������������������������������0000664�0000000�0000000�00000027203�15100345067�0024416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * This file handles continuous aggs watermark functions. */ #include <postgres.h> #include <access/xact.h> #include <fmgr.h> #include <miscadmin.h> #include <utils/acl.h> #include <utils/inval.h> #include <utils/snapmgr.h> #include "debug_point.h" #include "guc.h" #include "hypertable.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/continuous_aggs_watermark.h" static void cagg_watermark_init_scan_by_mat_hypertable_id(ScanIterator *iterator, const int32 mat_hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_WATERMARK, CONTINUOUS_AGGS_WATERMARK_PKEY); ts_scan_iterator_scan_key_init(iterator, Anum_continuous_aggs_watermark_pkey_mat_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(mat_hypertable_id)); } int64 ts_cagg_watermark_get(int32 hypertable_id) { PG_USED_FOR_ASSERTS_ONLY short count = 0; Datum watermark = (Datum) 0; bool value_isnull = true; ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_WATERMARK, AccessShareLock, CurrentMemoryContext); /* * The watermark of a CAGG has to be fetched by using the transaction snapshot. * * By default, the ts_scanner uses the SnapshotSelf to perform a scan. However, reading the * watermark must be done using the transaction snapshot in order to ensure that the view on the * watermark and the materialized part of the CAGG match. */ iterator.ctx.snapshot = RegisterSnapshot(GetTransactionSnapshot()); Assert(iterator.ctx.snapshot != NULL); cagg_watermark_init_scan_by_mat_hypertable_id(&iterator, hypertable_id); ts_scanner_foreach(&iterator) { watermark = slot_getattr(ts_scan_iterator_slot(&iterator), Anum_continuous_aggs_watermark_watermark, &value_isnull); count++; } Assert(count <= 1); UnregisterSnapshot(iterator.ctx.snapshot); ts_scan_iterator_close(&iterator); if (value_isnull) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("watermark not defined for continuous aggregate: %d", hypertable_id))); /* Log the read watermark, needed for MVCC tap tests */ ereport(DEBUG5, (errcode(ERRCODE_SUCCESSFUL_COMPLETION), errmsg("watermark for continuous aggregate, '%d' is: " INT64_FORMAT, hypertable_id, DatumGetInt64(watermark)))); return DatumGetInt64(watermark); } TS_FUNCTION_INFO_V1(ts_continuous_agg_watermark); /* * Get the watermark for a real-time aggregation query on a continuous * aggregate. * * The watermark determines where the materialization ends for a continuous * aggregate. It is used by real-time aggregation as the threshold between the * materialized data and real-time data in the UNION query. * * The watermark is stored into `_timescaledb_catalog.continuous_aggs_watermark` * catalog table by the `refresh_continuous_agregate` procedure. It is defined * as the end of the last (highest) bucket in the materialized hypertable of a * continuous aggregate. * * The materialized hypertable ID is given as input argument. */ Datum ts_continuous_agg_watermark(PG_FUNCTION_ARGS) { const int32 mat_hypertable_id = PG_GETARG_INT32(0); ContinuousAgg *cagg; AclResult aclresult; cagg = ts_continuous_agg_find_by_mat_hypertable_id(mat_hypertable_id, false); /* * Preemptive permission check to ensure the function complains about lack * of permissions on the cagg rather than the materialized hypertable */ aclresult = pg_class_aclcheck(cagg->relid, GetUserId(), ACL_SELECT); aclcheck_error(aclresult, OBJECT_MATVIEW, get_rel_name(cagg->relid)); int64 watermark = ts_cagg_watermark_get(cagg->data.mat_hypertable_id); PG_RETURN_INT64(watermark); } static int64 cagg_compute_watermark(ContinuousAgg *cagg, int64 watermark, bool isnull) { if (isnull) { watermark = ts_time_get_min(cagg->partition_type); } else { /* * The materialized hypertable is already bucketed, which means the * max is the start of the last bucket. Add one bucket to move to the * point where the materialized data ends. */ if (cagg->bucket_function->bucket_fixed_interval == false) { /* * Since `value` is already bucketed, `bucketed = true` flag can * be added to ts_compute_beginning_of_the_next_bucket_variable() as * an optimization, if necessary. */ watermark = ts_compute_beginning_of_the_next_bucket_variable(watermark, cagg->bucket_function); } else { watermark = ts_time_saturating_add(watermark, ts_continuous_agg_fixed_bucket_width(cagg->bucket_function), cagg->partition_type); } } return watermark; } TS_FUNCTION_INFO_V1(ts_continuous_agg_watermark_materialized); /* * Get the materialized watermark for a real-time aggregation query on a * continuous aggregate. * * The difference between this function and `ts_continuous_agg_watermark` is * that this one get the max open dimension of the materialization hypertable * instead of get the stored value in the catalog table. */ Datum ts_continuous_agg_watermark_materialized(PG_FUNCTION_ARGS) { const int32 mat_hypertable_id = PG_GETARG_INT32(0); ContinuousAgg *cagg; AclResult aclresult; bool isnull; Hypertable *ht; int64 watermark; cagg = ts_continuous_agg_find_by_mat_hypertable_id(mat_hypertable_id, false); /* * Preemptive permission check to ensure the function complains about lack * of permissions on the cagg rather than the materialized hypertable */ aclresult = pg_class_aclcheck(cagg->relid, GetUserId(), ACL_SELECT); aclcheck_error(aclresult, OBJECT_MATVIEW, get_rel_name(cagg->relid)); ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); watermark = ts_hypertable_get_open_dim_max_value(ht, 0, &isnull); watermark = cagg_compute_watermark(cagg, watermark, isnull); PG_RETURN_INT64(watermark); } TSDLLEXPORT void ts_cagg_watermark_insert(Hypertable *mat_ht, int64 watermark, bool watermark_isnull) { Catalog *catalog = ts_catalog_get(); Relation rel = table_open(catalog_get_table_id(catalog, CONTINUOUS_AGGS_WATERMARK), RowExclusiveLock); TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_continuous_aggs_watermark]; bool nulls[Natts_continuous_aggs_watermark] = { false }; CatalogSecurityContext sec_ctx; /* if trying to insert a NULL watermark then get the MIN value for the time dimension */ if (watermark_isnull) { const Dimension *dim = hyperspace_get_open_dimension(mat_ht->space, 0); if (NULL == dim) elog(ERROR, "invalid open dimension index %d", 0); watermark = ts_time_get_min(ts_dimension_get_partition_type(dim)); } values[AttrNumberGetAttrOffset(Anum_continuous_aggs_watermark_mat_hypertable_id)] = Int32GetDatum(mat_ht->fd.id); values[AttrNumberGetAttrOffset(Anum_continuous_aggs_watermark_watermark)] = Int64GetDatum(watermark); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); table_close(rel, NoLock); } typedef struct WatermarkUpdate { int64 watermark; bool force_update; bool invalidate_rel_cache; Oid ht_relid; } WatermarkUpdate; static ScanTupleResult cagg_watermark_update_scan_internal(TupleInfo *ti, void *data) { WatermarkUpdate *watermark_update = data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); Form_continuous_aggs_watermark form = (Form_continuous_aggs_watermark) GETSTRUCT(tuple); /* If the tuple was modified concurrently, retry the operation and use a new snapshot * to see the updated tuple. */ if (ti->lockresult == TM_Updated) return SCAN_RESTART_WITH_NEW_SNAPSHOT; Ensure(ti->lockresult == TM_Ok, "unable to lock watermark tuple for cagg %d (lock result %d)", watermark_update->ht_relid, ti->lockresult); if (watermark_update->watermark > form->watermark || watermark_update->force_update) { HeapTuple new_tuple = heap_copytuple(tuple); form = (Form_continuous_aggs_watermark) GETSTRUCT(new_tuple); form->watermark = watermark_update->watermark; ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); /* * During query planning, the values of the watermark function are constified using the * constify_cagg_watermark() function. However, this function's value changes when we update * the Cagg (the volatility of the function is STABLE not IMMUTABLE). To ensure that caches, * such as the query plan cache, are properly evicted, we send an invalidation message for * the hypertable. */ if (watermark_update->invalidate_rel_cache) { DEBUG_WAITPOINT("cagg_watermark_update_internal_before_refresh"); CacheInvalidateRelcacheByRelid(watermark_update->ht_relid); } } else { elog(DEBUG1, "hypertable %d existing watermark >= new watermark " INT64_FORMAT " " INT64_FORMAT, form->mat_hypertable_id, form->watermark, watermark_update->watermark); watermark_update->watermark = form->watermark; } if (should_free) heap_freetuple(tuple); return SCAN_DONE; } static void cagg_watermark_update_internal(int32 mat_hypertable_id, Oid ht_relid, int64 new_watermark, bool force_update, bool invalidate_rel_cache) { WatermarkUpdate data = { .watermark = new_watermark, .force_update = force_update, .invalidate_rel_cache = invalidate_rel_cache, .ht_relid = ht_relid }; ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_WATERMARK, RowExclusiveLock, CurrentMemoryContext); cagg_watermark_init_scan_by_mat_hypertable_id(&iterator, mat_hypertable_id); iterator.ctx.tuple_found = cagg_watermark_update_scan_internal; iterator.ctx.data = &data; iterator.ctx.snapshot = RegisterSnapshot(GetLatestSnapshot()); ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; iterator.ctx.tuplock = &scantuplock; iterator.ctx.flags = SCANNER_F_KEEPLOCK; bool watermark_updated = ts_scanner_scan_one(&iterator.ctx, false, "continuous aggregate watermark"); UnregisterSnapshot(iterator.ctx.snapshot); if (!watermark_updated) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("watermark not defined for continuous aggregate: %d", mat_hypertable_id))); } } TSDLLEXPORT void ts_cagg_watermark_update(Hypertable *mat_ht, int64 watermark, bool watermark_isnull, bool force_update) { ContinuousAgg *cagg = ts_continuous_agg_find_by_mat_hypertable_id(mat_ht->fd.id, false); /* If we have a real-time CAgg, it uses a watermark function. So, we have to invalidate the rel * cache to force a replanning of prepared statements. See cagg_watermark_update_internal for * more information. If the GUC enable_cagg_watermark_constify=false then it's not necessary * to invalidate relation cache. */ bool invalidate_rel_cache = !cagg->data.materialized_only && ts_guc_enable_cagg_watermark_constify; watermark = cagg_compute_watermark(cagg, watermark, watermark_isnull); cagg_watermark_update_internal(mat_ht->fd.id, mat_ht->main_table_relid, watermark, force_update, invalidate_rel_cache); } TSDLLEXPORT void ts_cagg_watermark_delete_by_mat_hypertable_id(int32 mat_hypertable_id) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_WATERMARK, RowExclusiveLock, CurrentMemoryContext); cagg_watermark_init_scan_by_mat_hypertable_id(&iterator, mat_hypertable_id); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); } ts_scan_iterator_close(&iterator); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/continuous_aggs_watermark.h���������������������������������������0000664�0000000�0000000�00000001276�15100345067�0024425�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "export.h" #include "hypertable.h" extern TSDLLEXPORT void ts_cagg_watermark_delete_by_mat_hypertable_id(int32 mat_hypertable_id); extern TSDLLEXPORT void ts_cagg_watermark_insert(Hypertable *mat_ht, int64 watermark, bool watermark_isnull); extern TSDLLEXPORT void ts_cagg_watermark_update(Hypertable *mat_ht, int64 watermark, bool watermark_isnull, bool force_update); extern TSDLLEXPORT int64 ts_cagg_watermark_get(int32 hypertable_id); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/metadata.c��������������������������������������������������������0000664�0000000�0000000�00000014131�15100345067�0020706�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <unistd.h> #include <postgres.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <stdlib.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/fmgroids.h> #include <utils/lsyscache.h> #include <utils/uuid.h> #include "scanner.h" #include "ts_catalog/catalog.h" #include "ts_catalog/metadata.h" #include "uuid.h" #include "compat/compat.h" #define TYPE_ERROR(inout, typeid) \ elog(ERROR, "ts_metadata: no %s function for type %u", inout, typeid); static Datum convert_type_to_text(Datum value, Oid from_type) { bool is_varlena; Oid outfunc; getTypeOutputInfo(from_type, &outfunc, &is_varlena); if (!OidIsValid(outfunc)) TYPE_ERROR("output", from_type); return DirectFunctionCall1(textin, OidFunctionCall1(outfunc, value)); } static Datum convert_text_to_type(Datum value, Oid to_type) { Oid value_in; Oid value_ioparam; getTypeInputInfo(to_type, &value_in, &value_ioparam); if (!OidIsValid(value_in)) TYPE_ERROR("input", to_type); value = OidFunctionCall3(value_in, CStringGetDatum(TextDatumGetCString(value)), ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1)); return value; } typedef struct DatumValue { /* * This form is not used for anything. It is here to reference the type so * that pgindent works. It can be removed from this struct in case we * actually use the form type in code */ FormData_metadata *form; Datum value; Oid typeid; bool isnull; } DatumValue; static ScanTupleResult metadata_tuple_get_value(TupleInfo *ti, void *data) { DatumValue *dv = data; dv->value = slot_getattr(ti->slot, Anum_metadata_value, &dv->isnull); if (!dv->isnull) dv->value = convert_text_to_type(dv->value, dv->typeid); return SCAN_DONE; } static Datum metadata_get_value_internal(const char *key, Oid value_type, bool *isnull, LOCKMODE lockmode) { ScanKeyData scankey[1]; DatumValue dv = { .typeid = value_type, .isnull = true, }; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, METADATA), .index = catalog_get_index(catalog, METADATA, METADATA_PKEY_IDX), .nkeys = 1, .scankey = scankey, .tuple_found = metadata_tuple_get_value, .data = &dv, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; ScanKeyInit(&scankey[0], Anum_metadata_key, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(key)); ts_scanner_scan(&scanctx); if (NULL != isnull) *isnull = dv.isnull; return dv.value; } Datum ts_metadata_get_value(const char *metadata_key, Oid value_type, bool *isnull) { return metadata_get_value_internal(metadata_key, value_type, isnull, AccessShareLock); } /* * Insert a row into the metadata table. Acquires a lock in * SHARE ROW EXCLUSIVE mode to conflict with itself, and then verifies that * the desired metadata KV pair still does not exist. Otherwise, exits * without inserting to avoid underlying database error on PK conflict. * Returns the value of the key; this is either the requested insert value or * the existing value if nothing was inserted. */ Datum ts_metadata_insert(const char *metadata_key, Datum metadata_value, Oid type, bool include_in_telemetry) { Datum existing_value; Datum values[Natts_metadata]; bool nulls[Natts_metadata] = { false }; bool isnull = false; Catalog *catalog = ts_catalog_get(); Relation rel; NameData key_data; rel = table_open(catalog_get_table_id(catalog, METADATA), ShareRowExclusiveLock); /* Check for row existence while we have the lock */ existing_value = metadata_get_value_internal(metadata_key, type, &isnull, ShareRowExclusiveLock); if (!isnull) { table_close(rel, ShareRowExclusiveLock); return existing_value; } /* We have to copy the key here because heap_form_tuple will copy NAMEDATALEN * into the tuple instead of checking length. */ namestrcpy(&key_data, metadata_key); /* Insert into the catalog table for persistence */ values[AttrNumberGetAttrOffset(Anum_metadata_key)] = NameGetDatum(&key_data); values[AttrNumberGetAttrOffset(Anum_metadata_value)] = convert_type_to_text(metadata_value, type); values[AttrNumberGetAttrOffset(Anum_metadata_include_in_telemetry)] = BoolGetDatum(include_in_telemetry); ts_catalog_insert_values(rel, RelationGetDescr(rel), values, nulls); table_close(rel, ShareRowExclusiveLock); return metadata_value; } static ScanTupleResult metadata_tuple_delete(TupleInfo *ti, void *data) { ts_catalog_delete_tid(ti->scanrel, ts_scanner_get_tuple_tid(ti)); return SCAN_CONTINUE; } void ts_metadata_drop(const char *metadata_key) { ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, METADATA), .index = catalog_get_index(catalog, METADATA, METADATA_PKEY_IDX), .nkeys = 1, .scankey = scankey, .tuple_found = metadata_tuple_delete, .data = NULL, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, }; ScanKeyInit(&scankey[0], Anum_metadata_key, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(metadata_key)); ts_scanner_scan(&scanctx); } static Datum get_uuid_by_key(const char *key) { bool isnull; Datum uuid; uuid = ts_metadata_get_value(key, UUIDOID, &isnull); if (isnull) uuid = ts_metadata_insert(key, UUIDPGetDatum(ts_uuid_create()), UUIDOID, true); return uuid; } Datum ts_metadata_get_uuid(void) { return get_uuid_by_key(METADATA_UUID_KEY_NAME); } Datum ts_metadata_get_exported_uuid(void) { return get_uuid_by_key(METADATA_EXPORTED_UUID_KEY_NAME); } Datum ts_metadata_get_install_timestamp(void) { bool isnull; Datum timestamp; timestamp = ts_metadata_get_value(METADATA_TIMESTAMP_KEY_NAME, TIMESTAMPTZOID, &isnull); if (isnull) timestamp = ts_metadata_insert(METADATA_TIMESTAMP_KEY_NAME, TimestampTzGetDatum(GetCurrentTimestamp()), TIMESTAMPTZOID, true); return timestamp; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/metadata.h��������������������������������������������������������0000664�0000000�0000000�00000001567�15100345067�0020724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "export.h" #define METADATA_UUID_KEY_NAME "uuid" #define METADATA_EXPORTED_UUID_KEY_NAME "exported_uuid" #define METADATA_TIMESTAMP_KEY_NAME "install_timestamp" extern TSDLLEXPORT Datum ts_metadata_get_value(const char *metadata_key, Oid value_type, bool *isnull); extern TSDLLEXPORT Datum ts_metadata_insert(const char *metadata_key, Datum metadata_value, Oid value_type, bool include_in_telemetry); extern TSDLLEXPORT void ts_metadata_drop(const char *metadata_key); extern TSDLLEXPORT Datum ts_metadata_get_uuid(void); extern Datum ts_metadata_get_exported_uuid(void); extern Datum ts_metadata_get_install_timestamp(void); �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/tablespace.c������������������������������������������������������0000664�0000000�0000000�00000052524�15100345067�0021241�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/pg_tablespace_d.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <fmgr.h> #include <funcapi.h> #include <miscadmin.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/lsyscache.h> #include <utils/spccache.h> #include "compat/compat.h" #include "errors.h" #include "hypertable_cache.h" #include "scanner.h" #include "ts_catalog/catalog.h" #include "ts_catalog/tablespace.h" #include "utils.h" #define TABLESPACE_DEFAULT_CAPACITY 4 static Tablespaces * tablespaces_alloc(int capacity) { Tablespaces *tspcs; tspcs = palloc(sizeof(Tablespaces)); tspcs->capacity = capacity; tspcs->num_tablespaces = 0; tspcs->tablespaces = palloc(sizeof(Tablespace) * tspcs->capacity); return tspcs; } Tablespace * ts_tablespaces_add(Tablespaces *tablespaces, const FormData_tablespace *form, Oid tspc_oid) { Tablespace *tspc; if (tablespaces->num_tablespaces >= tablespaces->capacity) { tablespaces->capacity += TABLESPACE_DEFAULT_CAPACITY; Assert(tablespaces->tablespaces); /* repalloc() does not work with NULL argument */ tablespaces->tablespaces = repalloc(tablespaces->tablespaces, sizeof(Tablespace) * tablespaces->capacity); } tspc = &tablespaces->tablespaces[tablespaces->num_tablespaces++]; memcpy(&tspc->fd, form, sizeof(FormData_tablespace)); tspc->tablespace_oid = tspc_oid; return tspc; } bool ts_tablespaces_contain(const Tablespaces *tablespaces, Oid tspc_oid) { int i; for (i = 0; i < tablespaces->num_tablespaces; i++) if (tspc_oid == tablespaces->tablespaces[i].tablespace_oid) return true; return false; } static ScanTupleResult tablespace_tuple_found(TupleInfo *ti, void *data) { Tablespaces *tspcs = data; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); FormData_tablespace *form = (FormData_tablespace *) GETSTRUCT(tuple); Oid tspcoid = get_tablespace_oid(NameStr(form->tablespace_name), true); if (NULL != tspcs) ts_tablespaces_add(tspcs, form, tspcoid); if (should_free) heap_freetuple(tuple); return SCAN_CONTINUE; } static int tablespace_scan_internal(int indexid, ScanKeyData *scankey, int nkeys, tuple_found_func tuple_found, tuple_filter_func tuple_filter, void *data, int limit, LOCKMODE lockmode) { Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, TABLESPACE), .index = catalog_get_index(catalog, TABLESPACE, indexid), .nkeys = nkeys, .scankey = scankey, .tuple_found = tuple_found, .filter = tuple_filter, .data = data, .limit = limit, .lockmode = lockmode, .scandirection = ForwardScanDirection, }; return ts_scanner_scan(&scanctx); } Tablespaces * ts_tablespace_scan(int32 hypertable_id) { Tablespaces *tspcs = tablespaces_alloc(TABLESPACE_DEFAULT_CAPACITY); ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_tablespace_hypertable_id_tablespace_name_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); tablespace_scan_internal(TABLESPACE_HYPERTABLE_ID_TABLESPACE_NAME_IDX, scankey, 1, tablespace_tuple_found, NULL, tspcs, 0, AccessShareLock); return tspcs; } typedef struct TablespaceScanInfo { CatalogDatabaseInfo *database_info; Cache *hcache; Oid userid; int num_filtered; int stopcount; List *hypertables; /* Hypertables affected, where applicable */ void *data; } TablespaceScanInfo; static int tablespace_scan_by_name(const char *tspcname, tuple_found_func tuple_found, void *data) { ScanKeyData scankey[1]; int nkeys = 0; if (NULL != tspcname) ScanKeyInit(&scankey[nkeys++], Anum_tablespace_tablespace_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(tspcname)); return tablespace_scan_internal(INVALID_INDEXID, scankey, nkeys, tuple_found, NULL, data, 0, AccessShareLock); } int ts_tablespace_count_attached(const char *tspcname) { return tablespace_scan_by_name(tspcname, NULL, NULL); } static void tablespace_validate_revoke_internal(const char *tspcname, tuple_found_func tuple_found, void *stmt) { TablespaceScanInfo info = { .database_info = ts_catalog_database_info_get(), .hcache = ts_hypertable_cache_pin(), .data = stmt, }; tablespace_scan_by_name(tspcname, tuple_found, &info); ts_cache_release(&info.hcache); } static void validate_revoke_create(Oid tspcoid, Oid role, Oid relid) { AclResult aclresult = object_aclcheck(TableSpaceRelationId, tspcoid, role, ACL_CREATE); if (aclresult != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST), errmsg("cannot revoke privilege while tablespace \"%s\" is attached to hypertable " "\"%s\"", get_tablespace_name(tspcoid), get_rel_name(relid)), errhint("Detach the tablespace before revoking the privilege on it."))); } /* * Verify that the REVOKE of permissions on a tablespace does not make it * impossible to use the tablespace for new chunks. * * This check should be done after the REVOKE has been applied. */ static ScanTupleResult revoke_tuple_found(TupleInfo *ti, void *data) { TablespaceScanInfo *info = data; GrantStmt *stmt = info->data; ListCell *lc_role; bool isnull; Datum hyper_id; Datum tablespace_name; Oid tspcoid; Hypertable *ht; Oid relowner; hyper_id = slot_getattr(ti->slot, Anum_tablespace_hypertable_id, &isnull); Assert(!isnull); tablespace_name = slot_getattr(ti->slot, Anum_tablespace_tablespace_name, &isnull); Assert(!isnull); tspcoid = get_tablespace_oid(NameStr(*DatumGetName(tablespace_name)), false); ht = ts_hypertable_cache_get_entry_by_id(info->hcache, DatumGetInt32(hyper_id)); relowner = ts_rel_get_owner(ht->main_table_relid); foreach (lc_role, stmt->grantees) { RoleSpec *role = lfirst(lc_role); Oid roleoid = get_role_oid_or_public(role->rolename); /* Check if this is a role we're interested in */ if (!OidIsValid(roleoid)) continue; /* * A revoke on a tablespace can only be for 'CREATE' (or ALL), so no * need to check which privilege is revoked. */ validate_revoke_create(tspcoid, relowner, ht->main_table_relid); } return SCAN_CONTINUE; } void ts_tablespace_validate_revoke(GrantStmt *stmt) { tablespace_validate_revoke_internal(strVal(linitial(stmt->objects)), revoke_tuple_found, stmt); } /* * Verify that the REVOKE of a role on a tablespace does not make it impossible * to use the tablespace for new chunks. * * This check should be done after the REVOKE has been applied. */ static ScanTupleResult revoke_role_tuple_found(TupleInfo *ti, void *data) { TablespaceScanInfo *info = data; GrantRoleStmt *stmt = info->data; bool isnull; Datum hyper_id; Datum tablespace_name; Oid tspcoid; Hypertable *ht; Oid relowner; ListCell *lc_role; hyper_id = slot_getattr(ti->slot, Anum_tablespace_hypertable_id, &isnull); Assert(!isnull); tablespace_name = slot_getattr(ti->slot, Anum_tablespace_tablespace_name, &isnull); Assert(!isnull); tspcoid = get_tablespace_oid(NameStr(*DatumGetName(tablespace_name)), false); ht = ts_hypertable_cache_get_entry_by_id(info->hcache, DatumGetInt32(hyper_id)); relowner = ts_rel_get_owner(ht->main_table_relid); foreach (lc_role, stmt->grantee_roles) { RoleSpec *rolespec = lfirst(lc_role); Oid grantee = get_rolespec_oid(rolespec, true); /* Only interested in revokes on table owners */ if (grantee != relowner) continue; /* * No need to check which role that was revoked since we are only * interested in the resulting permissions for the table owner. A * table owner could have CREATE on the tablespace from multiple * roles, so revoking one of those roles might not mean the owner no * longer has CREATE on the tablespace. */ validate_revoke_create(tspcoid, relowner, ht->main_table_relid); } return SCAN_CONTINUE; } void ts_tablespace_validate_revoke_role(GrantRoleStmt *stmt) { tablespace_validate_revoke_internal(NULL, revoke_role_tuple_found, stmt); } static int32 tablespace_insert_relation(Relation rel, int32 hypertable_id, const char *tspcname) { TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_tablespace]; bool nulls[Natts_tablespace] = { false }; int32 id; memset(values, 0, sizeof(values)); id = ts_catalog_table_next_seq_id(ts_catalog_get(), TABLESPACE); values[AttrNumberGetAttrOffset(Anum_tablespace_id)] = Int32GetDatum(id); values[AttrNumberGetAttrOffset(Anum_tablespace_hypertable_id)] = Int32GetDatum(hypertable_id); values[AttrNumberGetAttrOffset(Anum_tablespace_tablespace_name)] = DirectFunctionCall1(namein, CStringGetDatum(tspcname)); ts_catalog_insert_values(rel, desc, values, nulls); return id; } static int32 tablespace_insert(int32 hypertable_id, const char *tspcname) { Catalog *catalog = ts_catalog_get(); Relation rel; int32 id; rel = table_open(catalog_get_table_id(catalog, TABLESPACE), RowExclusiveLock); id = tablespace_insert_relation(rel, hypertable_id, tspcname); table_close(rel, RowExclusiveLock); return id; } static ScanTupleResult tablespace_tuple_delete(TupleInfo *ti, void *data) { TablespaceScanInfo *info = data; bool should_free; CatalogSecurityContext sec_ctx; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); FormData_tablespace *form = (FormData_tablespace *) GETSTRUCT(tuple); ts_catalog_database_info_become_owner(info->database_info, &sec_ctx); ts_catalog_delete_tid_only(ti->scanrel, ts_scanner_get_tuple_tid(ti)); ts_catalog_restore_user(&sec_ctx); info->hypertables = lappend_int(info->hypertables, form->hypertable_id); if (should_free) heap_freetuple(tuple); return (info->stopcount == 0 || ti->count < info->stopcount) ? SCAN_CONTINUE : SCAN_DONE; } int ts_tablespace_delete(int32 hypertable_id, const char *tspcname, Oid tspcoid) { ScanKeyData scankey[2]; TablespaceScanInfo info = { .database_info = ts_catalog_database_info_get(), .stopcount = (NULL != tspcname), }; int num_deleted, nkeys = 0; ScanKeyInit(&scankey[nkeys++], Anum_tablespace_hypertable_id_tablespace_name_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); if (NULL != tspcname) ScanKeyInit(&scankey[nkeys++], Anum_tablespace_hypertable_id_tablespace_name_idx_tablespace_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(tspcname)); num_deleted = tablespace_scan_internal(TABLESPACE_HYPERTABLE_ID_TABLESPACE_NAME_IDX, scankey, nkeys, tablespace_tuple_delete, NULL, &info, 0, RowExclusiveLock); if (num_deleted > 0) CommandCounterIncrement(); return num_deleted; } static ScanFilterResult tablespace_tuple_owner_filter(const TupleInfo *ti, void *data) { TablespaceScanInfo *info = data; bool isnull; Datum hyper_id; Hypertable *ht; ScanFilterResult result; hyper_id = slot_getattr(ti->slot, Anum_tablespace_hypertable_id, &isnull); Assert(!isnull); ht = ts_hypertable_cache_get_entry_by_id(info->hcache, DatumGetInt32(hyper_id)); Assert(NULL != ht); if (ts_hypertable_has_privs_of(ht->main_table_relid, info->userid)) result = SCAN_INCLUDE; else { result = SCAN_EXCLUDE; info->num_filtered++; } return result; } /* * Detach a tablespace from all hypertables it is attached to. * * Output parameters: * - `hypertables`: the list of hypertables that the tablespace was removed from. * * Returns: * integer giving the number of tablespaces deleted. */ static int tablespace_delete_from_all(const char *tspcname, Oid userid, List **hypertables) { ScanKeyData scankey[1]; TablespaceScanInfo info = { .database_info = ts_catalog_database_info_get(), .hcache = ts_hypertable_cache_pin(), .userid = userid, }; int num_deleted; ScanKeyInit(&scankey[0], Anum_tablespace_tablespace_name, BTEqualStrategyNumber, F_NAMEEQ, CStringGetDatum(tspcname)); num_deleted = tablespace_scan_internal(INVALID_INDEXID, scankey, 1, tablespace_tuple_delete, tablespace_tuple_owner_filter, &info, 0, RowExclusiveLock); ts_cache_release(&info.hcache); if (num_deleted > 0) CommandCounterIncrement(); if (info.num_filtered > 0) ereport(NOTICE, (errmsg("tablespace \"%s\" remains attached to %d hypertable(s) due to lack of " "permissions", tspcname, info.num_filtered))); *hypertables = info.hypertables; return num_deleted; } TS_FUNCTION_INFO_V1(ts_tablespace_attach); Datum ts_tablespace_attach(PG_FUNCTION_ARGS) { Name tspcname = PG_ARGISNULL(0) ? NULL : PG_GETARG_NAME(0); Oid hypertable_oid = PG_ARGISNULL(1) ? InvalidOid : PG_GETARG_OID(1); bool if_not_attached = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); Relation rel; TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_NARGS() < 2 || PG_NARGS() > 3) elog(ERROR, "invalid number of arguments"); ts_tablespace_attach_internal(tspcname, hypertable_oid, if_not_attached); /* If the hypertable did not have a tablespace assigned, we set one */ rel = relation_open(hypertable_oid, AccessShareLock); if (!OidIsValid(rel->rd_rel->reltablespace)) { AlterTableCmd *const cmd = makeNode(AlterTableCmd); cmd->subtype = AT_SetTableSpace; cmd->name = NameStr(*tspcname); ts_alter_table_with_event_trigger(hypertable_oid, fcinfo->context, list_make1(cmd), false); } relation_close(rel, AccessShareLock); PG_RETURN_VOID(); } void ts_tablespace_attach_internal(Name tspcname, Oid hypertable_oid, bool if_not_attached) { Cache *hcache; Hypertable *ht; Oid tspc_oid; Oid ownerid; AclResult aclresult; CatalogSecurityContext sec_ctx; if (NULL == tspcname) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid tablespace name"))); if (!OidIsValid(hypertable_oid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid hypertable"))); tspc_oid = get_tablespace_oid(NameStr(*tspcname), true); if (!OidIsValid(tspc_oid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("tablespace \"%s\" does not exist", NameStr(*tspcname)), errhint("The tablespace needs to be created" " before attaching it to a hypertable."))); ownerid = ts_hypertable_permissions_check(hypertable_oid, GetUserId()); /* * Only check permissions on tablespace if it is not the database default. * In usual case users can create tables in their database which will use * the default tablespace of the database. This condition makes sure they * can also always move a table from another tablespace to the default of * their own database. Related to this issue in postgres core: * https://www.postgresql.org/message-id/52DC8AEA.7090507%402ndquadrant.com * Which was handled in a similar way. (See * tablecmds.c::ATPrepSetTableSpace) */ if (tspc_oid != MyDatabaseTableSpace) { /* * Note that we check against the table owner rather than the current * user here, since we're not actually creating a table using this * tablespace at this point */ aclresult = object_aclcheck(TableSpaceRelationId, tspc_oid, ownerid, ACL_CREATE); if (aclresult != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for tablespace \"%s\" by table owner \"%s\"", NameStr(*tspcname), GetUserNameFromId(ownerid, true)))); } ht = ts_hypertable_cache_get_cache_and_entry(hypertable_oid, CACHE_FLAG_NONE, &hcache); if (ts_hypertable_has_tablespace(ht, tspc_oid)) { if (if_not_attached) ereport(NOTICE, (errcode(ERRCODE_TS_TABLESPACE_ALREADY_ATTACHED), errmsg("tablespace \"%s\" is already attached to hypertable \"%s\", skipping", NameStr(*tspcname), get_rel_name(hypertable_oid)))); else ereport(ERROR, (errcode(ERRCODE_TS_TABLESPACE_ALREADY_ATTACHED), errmsg("tablespace \"%s\" is already attached to hypertable \"%s\"", NameStr(*tspcname), get_rel_name(hypertable_oid)))); } else { ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); tablespace_insert(ht->fd.id, NameStr(*tspcname)); ts_catalog_restore_user(&sec_ctx); } ts_cache_release(&hcache); } static int tablespace_detach_one(Oid hypertable_oid, const char *tspcname, Oid tspcoid, bool if_attached) { Cache *hcache; Hypertable *ht; int ret = 0; ts_hypertable_permissions_check(hypertable_oid, GetUserId()); ht = ts_hypertable_cache_get_cache_and_entry(hypertable_oid, CACHE_FLAG_NONE, &hcache); if (ts_hypertable_has_tablespace(ht, tspcoid)) ret = ts_tablespace_delete(ht->fd.id, tspcname, tspcoid); else if (if_attached) ereport(NOTICE, (errcode(ERRCODE_TS_TABLESPACE_NOT_ATTACHED), errmsg("tablespace \"%s\" is not attached to hypertable \"%s\", skipping", tspcname, get_rel_name(hypertable_oid)))); else ereport(ERROR, (errcode(ERRCODE_TS_TABLESPACE_NOT_ATTACHED), errmsg("tablespace \"%s\" is not attached to hypertable \"%s\"", tspcname, get_rel_name(hypertable_oid)))); ts_cache_release(&hcache); return ret; } static int tablespace_detach_all(Oid hypertable_oid) { Cache *hcache; Hypertable *ht; int ret; ts_hypertable_permissions_check(hypertable_oid, GetUserId()); ht = ts_hypertable_cache_get_cache_and_entry(hypertable_oid, CACHE_FLAG_NONE, &hcache); ret = ts_tablespace_delete(ht->fd.id, NULL, InvalidOid); ts_cache_release(&hcache); return ret; } static void detach_tablespace_from_hypertable_if_set(Node *detach_cmd, Oid hypertable_oid, Oid tspcoid) { Relation rel; Assert(OidIsValid(hypertable_oid) && OidIsValid(tspcoid)); rel = relation_open(hypertable_oid, AccessShareLock); if (OidIsValid(rel->rd_rel->reltablespace) && rel->rd_rel->reltablespace == tspcoid) { AlterTableCmd *const cmd = makeNode(AlterTableCmd); cmd->subtype = AT_SetTableSpace; cmd->name = "pg_default"; ts_alter_table_with_event_trigger(hypertable_oid, detach_cmd, list_make1(cmd), false); } relation_close(rel, AccessShareLock); } TS_FUNCTION_INFO_V1(ts_tablespace_detach); Datum ts_tablespace_detach(PG_FUNCTION_ARGS) { Name tspcname = PG_ARGISNULL(0) ? NULL : PG_GETARG_NAME(0); Oid hypertable_oid = PG_ARGISNULL(1) ? InvalidOid : PG_GETARG_OID(1); bool if_attached = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); Oid tspcoid; int ret; TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_NARGS() < 1 || PG_NARGS() > 3) elog(ERROR, "invalid number of arguments"); if (NULL == tspcname) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid tablespace name"))); if (!PG_ARGISNULL(1) && !OidIsValid(hypertable_oid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid hypertable"))); tspcoid = get_tablespace_oid(NameStr(*tspcname), true); if (!OidIsValid(tspcoid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("tablespace \"%s\" does not exist", NameStr(*tspcname)))); if (OidIsValid(hypertable_oid)) { ret = tablespace_detach_one(hypertable_oid, NameStr(*tspcname), tspcoid, if_attached); detach_tablespace_from_hypertable_if_set(fcinfo->context, hypertable_oid, tspcoid); } else { List *hypertables = NIL; ListCell *cell; ret = tablespace_delete_from_all(NameStr(*tspcname), GetUserId(), &hypertables); foreach (cell, hypertables) { const int32 hypertable_id = lfirst_int(cell); detach_tablespace_from_hypertable_if_set(fcinfo->context, ts_hypertable_id_to_relid(hypertable_id, false), tspcoid); } } PG_RETURN_INT32(ret); } TS_FUNCTION_INFO_V1(ts_tablespace_detach_all_from_hypertable); Datum ts_tablespace_detach_all_from_hypertable(PG_FUNCTION_ARGS) { const Oid hypertable_relid = PG_GETARG_OID(0); int32 result; AlterTableCmd *const cmd = makeNode(AlterTableCmd); cmd->subtype = AT_SetTableSpace; cmd->name = "pg_default"; TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_NARGS() != 1) elog(ERROR, "invalid number of arguments"); if (PG_ARGISNULL(0)) elog(ERROR, "invalid argument"); result = tablespace_detach_all(hypertable_relid); ts_alter_table_with_event_trigger(hypertable_relid, fcinfo->context, list_make1(cmd), false); PG_RETURN_INT32(result); } TS_FUNCTION_INFO_V1(ts_tablespace_show); Datum ts_tablespace_show(PG_FUNCTION_ARGS) { FuncCallContext *funcctx; Oid hypertable_oid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Cache *hcache; Hypertable *ht; Tablespaces *tspcs; if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; if (!OidIsValid(hypertable_oid)) elog(ERROR, "invalid argument"); funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); funcctx->user_fctx = ts_hypertable_cache_pin(); MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); hcache = funcctx->user_fctx; ht = ts_hypertable_cache_get_entry(hcache, hypertable_oid, CACHE_FLAG_NONE); tspcs = ts_tablespace_scan(ht->fd.id); if (NULL != tspcs && funcctx->call_cntr < (uint64) tspcs->num_tablespaces) { Oid tablespace_oid = tspcs->tablespaces[funcctx->call_cntr].tablespace_oid; const char *tablespace_name = get_tablespace_name(tablespace_oid); Datum name; Assert(tablespace_name != NULL); name = DirectFunctionCall1(namein, CStringGetDatum(tablespace_name)); SRF_RETURN_NEXT(funcctx, name); } else { ts_cache_release(&hcache); SRF_RETURN_DONE(funcctx); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/ts_catalog/tablespace.h������������������������������������������������������0000664�0000000�0000000�00000002210�15100345067�0021231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/parsenodes.h> #include "ts_catalog/catalog.h" typedef struct Tablespace { FormData_tablespace fd; Oid tablespace_oid; } Tablespace; typedef struct Tablespaces { int capacity; int num_tablespaces; Tablespace *tablespaces; } Tablespaces; extern Tablespace *ts_tablespaces_add(Tablespaces *tablespaces, const FormData_tablespace *form, Oid tspc_oid); extern bool ts_tablespaces_contain(const Tablespaces *tablespaces, Oid tspc_oid); extern Tablespaces *ts_tablespace_scan(int32 hypertable_id); extern TSDLLEXPORT void ts_tablespace_attach_internal(Name tspcname, Oid hypertable_oid, bool if_not_attached); extern int ts_tablespace_delete(int32 hypertable_id, const char *tspcname, Oid tspcoid); extern int ts_tablespace_count_attached(const char *tspcname); extern void ts_tablespace_validate_revoke(GrantStmt *stmt); extern void ts_tablespace_validate_revoke_role(GrantRoleStmt *stmt); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/tss_callbacks.c��������������������������������������������������������������0000664�0000000�0000000�00000006112�15100345067�0017616�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* * Currently we finish the execution of some process utility statements * and don't execute other hooks in the chain. * * Because that reason neither ts_stat_statements and pg_stat_statements * are able to track some utility statements, for example COPY ... FROM. * * To be able to track it on ts_stat_statements here we introduce some * callbacks in order to hook pgss_store from TimescaleDB and store * information about the execution of those statements. * * Hooking ts_stat_statements from TimescaleDB is controlled by a new GUC * named `enable_tss_callbacks`. */ #include <postgres.h> #include <executor/instrument.h> #include <fmgr.h> #include <utils/elog.h> #include "guc.h" #include "tss_callbacks.h" static instr_time tss_callback_start_time; static BufferUsage tss_callback_start_bufusage; static WalUsage tss_callback_start_walusage; static TSSCallbacks * ts_get_tss_callbacks(void) { TSSCallbacks **ptr = (TSSCallbacks **) find_rendezvous_variable(TSS_CALLBACKS_VAR_NAME); return *ptr; } static tss_store_hook_type ts_get_tss_store_hook(void) { TSSCallbacks *ptr = ts_get_tss_callbacks(); if (ptr && ptr->version_num == TSS_CALLBACKS_VERSION) return ptr->tss_store_hook; return NULL; } bool ts_is_tss_enabled(void) { if (ts_guc_enable_tss_callbacks) { TSSCallbacks *ptr = ts_get_tss_callbacks(); if (ptr) { if (ptr->version_num != TSS_CALLBACKS_VERSION) { ereport(WARNING, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("version mismatch between timescaledb and ts_stat_statements " "callbacks"), errdetail("Callbacks versions: TimescaleDB (%d) and ts_stat_statements " "(%d)", TSS_CALLBACKS_VERSION, ptr->version_num))); return false; } return ptr->tss_enabled_hook_type(0); /* consider top level statement */ } } return false; } void ts_begin_tss_store_callback(void) { if (!ts_is_tss_enabled()) return; tss_callback_start_bufusage = pgBufferUsage; tss_callback_start_walusage = pgWalUsage; INSTR_TIME_SET_CURRENT(tss_callback_start_time); } void ts_end_tss_store_callback(const char *query, int query_location, int query_len, uint64 query_id, uint64 rows) { instr_time duration; BufferUsage bufusage; WalUsage walusage; tss_store_hook_type hook; if (!ts_is_tss_enabled()) return; hook = ts_get_tss_store_hook(); if (!hook) return; INSTR_TIME_SET_CURRENT(duration); INSTR_TIME_SUBTRACT(duration, tss_callback_start_time); /* calc differences of buffer counters. */ memset(&bufusage, 0, sizeof(BufferUsage)); BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &tss_callback_start_bufusage); /* calc differences of WAL counters. */ memset(&walusage, 0, sizeof(WalUsage)); WalUsageAccumDiff(&walusage, &pgWalUsage, &tss_callback_start_walusage); hook(query, query_location, query_len, query_id, INSTR_TIME_GET_MICROSEC(duration), rows, &bufusage, &walusage); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/tss_callbacks.h��������������������������������������������������������������0000664�0000000�0000000�00000002011�15100345067�0017615�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #define TSS_CALLBACKS_VAR_NAME "tss_callbacks" #define TSS_CALLBACKS_VERSION 1 /* ts_stat_statements -> pgss_store */ typedef void (*tss_store_hook_type)(const char *query, int query_location, int query_len, uint64 query_id, uint64 total_time, uint64 rows, const BufferUsage *bufusage, const WalUsage *walusage); /* ts_stat_statements -> pgss_enabled */ typedef bool (*tss_enabled_hook_type)(int level); /* ts_stat_statements callbacks */ typedef struct TSSCallbacks { uint32_t version_num; tss_store_hook_type tss_store_hook; tss_enabled_hook_type tss_enabled_hook_type; } TSSCallbacks; extern bool ts_is_tss_enabled(void); extern void ts_begin_tss_store_callback(void); extern void ts_end_tss_store_callback(const char *query, int query_location, int query_len, uint64 query_id, uint64 rows); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/utils.c����������������������������������������������������������������������0000664�0000000�0000000�00000155563�15100345067�0016165�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/genam.h> #include <access/heapam.h> #include <access/htup.h> #include <access/htup_details.h> #include <access/reloptions.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/namespace.h> #include <catalog/objectaccess.h> #include <catalog/pg_am.h> #include <catalog/pg_cast.h> #include <catalog/pg_inherits.h> #include <catalog/pg_operator.h> #include <catalog/pg_type.h> #include <commands/event_trigger.h> #include <commands/tablecmds.h> #include <fmgr.h> #include <funcapi.h> #include <nodes/makefuncs.h> #include <parser/parse_coerce.h> #include <parser/parse_func.h> #include <parser/scansup.h> #include <storage/lockdefs.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/catcache.h> #include <utils/date.h> #include <utils/elog.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include <utils/lsyscache.h> #include <utils/relcache.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include <utils/uuid.h> #include "compat/compat.h" #include "chunk.h" #include "cross_module_fn.h" #include "debug_point.h" #include "hypertable_cache.h" #include "jsonb_utils.h" #include "time_utils.h" #include "utils.h" #include "uuid.h" typedef struct { const char *name; AclMode value; } priv_map; TS_FUNCTION_INFO_V1(ts_pg_timestamp_to_unix_microseconds); TS_FUNCTION_INFO_V1(ts_makeaclitem); /* * Convert a Postgres TIMESTAMP to BIGINT microseconds relative the UNIX epoch. */ Datum ts_pg_timestamp_to_unix_microseconds(PG_FUNCTION_ARGS) { TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); if (TIMESTAMP_IS_NOBEGIN(timestamp)) PG_RETURN_INT64(TS_TIME_NOBEGIN); if (TIMESTAMP_IS_NOEND(timestamp)) PG_RETURN_INT64(TS_TIME_NOEND); if (timestamp < TS_TIMESTAMP_MIN) ereport(ERROR, (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), errmsg("timestamp out of range"))); if (timestamp >= TS_TIMESTAMP_END) ereport(ERROR, (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), errmsg("timestamp out of range"))); PG_RETURN_INT64(timestamp + TS_EPOCH_DIFF_MICROSECONDS); } TS_FUNCTION_INFO_V1(ts_pg_unix_microseconds_to_timestamp); TS_FUNCTION_INFO_V1(ts_pg_unix_microseconds_to_timestamp_without_timezone); TS_FUNCTION_INFO_V1(ts_pg_unix_microseconds_to_date); /* * Convert BIGINT microseconds relative the UNIX epoch to a Postgres TIMESTAMP. */ Datum ts_pg_unix_microseconds_to_timestamp(PG_FUNCTION_ARGS) { int64 microseconds = PG_GETARG_INT64(0); if (TS_TIME_IS_NOBEGIN(microseconds, TIMESTAMPTZOID)) PG_RETURN_DATUM(ts_time_datum_get_nobegin(TIMESTAMPTZOID)); if (TS_TIME_IS_NOEND(microseconds, TIMESTAMPTZOID)) PG_RETURN_DATUM(ts_time_datum_get_noend(TIMESTAMPTZOID)); /* * Test that the UNIX us timestamp is within bounds. Note that an int64 at * UNIX epoch and microsecond precision cannot represent the upper limit * of the supported date range (Julian end date), so INT64_MAX-1 is the * natural upper bound for this function. */ if (microseconds < TS_TIMESTAMP_INTERNAL_MIN) ereport(ERROR, (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE), errmsg("timestamp out of range"))); PG_RETURN_TIMESTAMPTZ(microseconds - TS_EPOCH_DIFF_MICROSECONDS); } Datum ts_pg_unix_microseconds_to_date(PG_FUNCTION_ARGS) { int64 microseconds = PG_GETARG_INT64(0); Datum res; if (TS_TIME_IS_NOBEGIN(microseconds, DATEOID)) PG_RETURN_DATUM(ts_time_datum_get_nobegin(DATEOID)); if (TS_TIME_IS_NOEND(microseconds, DATEOID)) PG_RETURN_DATUM(ts_time_datum_get_noend(DATEOID)); res = DirectFunctionCall1(ts_pg_unix_microseconds_to_timestamp, Int64GetDatum(microseconds)); res = DirectFunctionCall1(timestamp_date, res); PG_RETURN_DATUM(res); } static int64 ts_integer_to_internal(Datum time_val, Oid type_oid); /* Convert valid timescale time column type to internal representation */ TSDLLEXPORT int64 ts_time_value_to_internal(Datum time_val, Oid type_oid) { Datum res, tz; /* Handle custom time types. We currently only support binary coercible * types */ if (!IS_VALID_TIME_TYPE(type_oid)) { if (ts_type_is_int8_binary_compatible(type_oid)) return DatumGetInt64(time_val); elog(ERROR, "unknown time type \"%s\"", format_type_be(type_oid)); } if (IS_INTEGER_TYPE(type_oid) || IS_UUID_TYPE(type_oid)) { /* Integer time types have no distinction between min, max and * infinity. We don't want min and max to be turned into infinity for * these types so check for those values first. */ if (TS_TIME_DATUM_IS_MIN(time_val, type_oid)) return ts_time_get_min(type_oid); if (TS_TIME_DATUM_IS_MAX(time_val, type_oid)) return ts_time_get_max(type_oid); } if (TS_TIME_DATUM_IS_NOBEGIN(time_val, type_oid)) return ts_time_get_nobegin(type_oid); if (TS_TIME_DATUM_IS_NOEND(time_val, type_oid)) return ts_time_get_noend(type_oid); switch (type_oid) { case INT8OID: case INT4OID: case INT2OID: return ts_integer_to_internal(time_val, type_oid); case TIMESTAMPOID: /* * for timestamps, ignore timezones, make believe the timestamp is * at UTC */ res = DirectFunctionCall1(ts_pg_timestamp_to_unix_microseconds, time_val); return DatumGetInt64(res); case TIMESTAMPTZOID: res = DirectFunctionCall1(ts_pg_timestamp_to_unix_microseconds, time_val); return DatumGetInt64(res); case DATEOID: tz = DirectFunctionCall1(date_timestamp, time_val); res = DirectFunctionCall1(ts_pg_timestamp_to_unix_microseconds, tz); return DatumGetInt64(res); case UUIDOID: { uint64 unixtime_ms = 0; /* * Extract the unix timestamp from the UUID. Note that we cannot * use the (optional) sub-milliseconds part because there is no * way to know whether it represents time or is random. * * If the UUID is not v7, error out. */ if (!ts_uuid_v7_extract_unixtime(DatumGetUUIDP(time_val), &unixtime_ms, NULL)) { ereport(ERROR, errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("%s is not a version 7 UUID", DatumGetCString(DirectFunctionCall1(uuid_out, time_val))), errdetail( "UUID \"time\" partitioning columns only support version 7 UUIDs.")); } /* Convert to microseconds */ return unixtime_ms * 1000; } default: elog(ERROR, "unknown time type \"%s\"", format_type_be(type_oid)); return -1; } } TSDLLEXPORT int64 ts_interval_value_to_internal(Datum time_val, Oid type_oid) { switch (type_oid) { case INT8OID: case INT4OID: case INT2OID: return ts_integer_to_internal(time_val, type_oid); case INTERVALOID: { Interval *interval = DatumGetIntervalP(time_val); if (interval->month != 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("months and years not supported"), errdetail("An interval must be defined as a fixed duration (such as " "weeks, days, hours, minutes, seconds, etc.)."))); return interval->time + (interval->day * USECS_PER_DAY); } default: elog(ERROR, "unknown interval type \"%s\"", format_type_be(type_oid)); return -1; } } static int64 ts_integer_to_internal(Datum time_val, Oid type_oid) { switch (type_oid) { case INT8OID: return DatumGetInt64(time_val); case INT4OID: return (int64) DatumGetInt32(time_val); case INT2OID: return (int64) DatumGetInt16(time_val); default: elog(ERROR, "unknown interval type \"%s\"", format_type_be(type_oid)); return -1; } } int64 ts_time_value_to_internal_or_infinite(Datum time_val, Oid type_oid) { switch (type_oid) { case TIMESTAMPOID: { Timestamp ts = DatumGetTimestamp(time_val); if (TIMESTAMP_NOT_FINITE(ts)) { if (TIMESTAMP_IS_NOBEGIN(ts)) { return PG_INT64_MIN; } else { return PG_INT64_MAX; } } return ts_time_value_to_internal(time_val, type_oid); } case TIMESTAMPTZOID: { TimestampTz ts = DatumGetTimestampTz(time_val); if (TIMESTAMP_NOT_FINITE(ts)) { if (TIMESTAMP_IS_NOBEGIN(ts)) { return PG_INT64_MIN; } else { return PG_INT64_MAX; } } return ts_time_value_to_internal(time_val, type_oid); } case DATEOID: { DateADT d = DatumGetDateADT(time_val); if (DATE_NOT_FINITE(d)) { if (DATE_IS_NOBEGIN(d)) { return PG_INT64_MIN; } else { return PG_INT64_MAX; } } return ts_time_value_to_internal(time_val, type_oid); } default: return ts_time_value_to_internal(time_val, type_oid); } } TS_FUNCTION_INFO_V1(ts_time_to_internal); Datum ts_time_to_internal(PG_FUNCTION_ARGS) { Datum time = PG_GETARG_DATUM(0); Oid time_type = get_fn_expr_argtype(fcinfo->flinfo, 0); int64 res = ts_time_value_to_internal(time, time_type); PG_RETURN_INT64(res); } static Datum ts_integer_to_internal_value(int64 value, Oid type); /* * convert int64 to Datum according to type * internally we store all times as int64 in the * same format postgres does */ TSDLLEXPORT Datum ts_internal_to_time_value(int64 value, Oid type) { if (TS_TIME_IS_NOBEGIN(value, type)) return ts_time_datum_get_nobegin(type); if (TS_TIME_IS_NOEND(value, type)) return ts_time_datum_get_noend(type); switch (type) { case INT2OID: case INT4OID: case INT8OID: return ts_integer_to_internal_value(value, type); case TIMESTAMPOID: case TIMESTAMPTZOID: /* we continue ts_time_value_to_internal's incorrect handling of TIMESTAMPs for * compatibility */ return DirectFunctionCall1(ts_pg_unix_microseconds_to_timestamp, Int64GetDatum(value)); case DATEOID: return DirectFunctionCall1(ts_pg_unix_microseconds_to_date, Int64GetDatum(value)); case UUIDOID: { /* * Convert the internal unixtime in ms to a UUID with the * non-timestamp bits set to zero. We do not set the version * either, because for ranges we only care about the prefix in * order to divide the whole UUID space into a set of slices. */ const pg_uuid_t *uuid = ts_create_uuid_v7_from_unixtime_us(value, true, false); return UUIDPGetDatum(uuid); } default: if (ts_type_is_int8_binary_compatible(type)) return Int64GetDatum(value); elog(ERROR, "unknown time type \"%s\" in ts_internal_to_time_value", format_type_be(type)); pg_unreachable(); } } TSDLLEXPORT int64 ts_internal_to_time_int64(int64 value, Oid type) { if (TS_TIME_IS_NOBEGIN(value, type)) return ts_time_datum_get_nobegin(type); if (TS_TIME_IS_NOEND(value, type)) return ts_time_datum_get_noend(type); switch (type) { case INT2OID: case INT4OID: case INT8OID: return value; case TIMESTAMPOID: case TIMESTAMPTZOID: case UUIDOID: /* we continue ts_time_value_to_internal's incorrect handling of TIMESTAMPs for * compatibility */ return DatumGetInt64( DirectFunctionCall1(ts_pg_unix_microseconds_to_timestamp, Int64GetDatum(value))); case DATEOID: return DatumGetInt64( DirectFunctionCall1(ts_pg_unix_microseconds_to_date, Int64GetDatum(value))); default: elog(ERROR, "unknown time type \"%s\" in ts_internal_to_time_value", format_type_be(type)); pg_unreachable(); } } TSDLLEXPORT char * ts_datum_to_string(Datum value, Oid type) { Oid typoutputfunc; bool typIsVarlena; FmgrInfo typoutputinfo; getTypeOutputInfo(type, &typoutputfunc, &typIsVarlena); fmgr_info(typoutputfunc, &typoutputinfo); return OutputFunctionCall(&typoutputinfo, value); } TSDLLEXPORT char * ts_internal_to_time_string(int64 value, Oid type) { Datum time_datum = ts_internal_to_time_value(value, type); return ts_datum_to_string(time_datum, type); } TS_FUNCTION_INFO_V1(ts_pg_unix_microseconds_to_interval); Datum ts_pg_unix_microseconds_to_interval(PG_FUNCTION_ARGS) { int64 microseconds = PG_GETARG_INT64(0); Interval *interval = palloc0(sizeof(*interval)); interval->day = microseconds / USECS_PER_DAY; interval->time = microseconds % USECS_PER_DAY; PG_RETURN_INTERVAL_P(interval); } TSDLLEXPORT Datum ts_internal_to_interval_value(int64 value, Oid type) { switch (type) { case INT2OID: case INT4OID: case INT8OID: return ts_integer_to_internal_value(value, type); case INTERVALOID: return DirectFunctionCall1(ts_pg_unix_microseconds_to_interval, Int64GetDatum(value)); default: elog(ERROR, "unknown time type \"%s\" in ts_internal_to_interval_value", format_type_be(type)); pg_unreachable(); } } static Datum ts_integer_to_internal_value(int64 value, Oid type) { switch (type) { case INT2OID: return Int16GetDatum(value); case INT4OID: return Int32GetDatum(value); case INT8OID: return Int64GetDatum(value); default: elog(ERROR, "unknown time type \"%s\" in ts_internal_to_time_value", format_type_be(type)); pg_unreachable(); } } /* Returns approximate period in microseconds */ int64 ts_get_interval_period_approx(Interval *interval) { return interval->time + ((((int64) interval->month * DAYS_PER_MONTH) + interval->day) * USECS_PER_DAY); } #define DAYS_PER_WEEK 7 #define DAYS_PER_QUARTER 89 #define YEARS_PER_DECADE 10 #define YEARS_PER_CENTURY 100 #define YEARS_PER_MILLENNIUM 1000 /* Returns approximate period in microseconds */ int64 ts_date_trunc_interval_period_approx(text *units) { int decode_type, val; char *lowunits = downcase_truncate_identifier(VARDATA_ANY(units), VARSIZE_ANY_EXHDR(units), false); decode_type = DecodeUnits(0, lowunits, &val); if (decode_type != UNITS) return -1; switch (val) { case DTK_WEEK: return DAYS_PER_WEEK * USECS_PER_DAY; case DTK_MILLENNIUM: return YEARS_PER_MILLENNIUM * DAYS_PER_YEAR * USECS_PER_DAY; case DTK_CENTURY: return YEARS_PER_CENTURY * DAYS_PER_YEAR * USECS_PER_DAY; case DTK_DECADE: return YEARS_PER_DECADE * DAYS_PER_YEAR * USECS_PER_DAY; case DTK_YEAR: return 1 * DAYS_PER_YEAR * USECS_PER_DAY; case DTK_QUARTER: return DAYS_PER_QUARTER * USECS_PER_DAY; case DTK_MONTH: return DAYS_PER_MONTH * USECS_PER_DAY; case DTK_DAY: return USECS_PER_DAY; case DTK_HOUR: return USECS_PER_HOUR; case DTK_MINUTE: return USECS_PER_MINUTE; case DTK_SECOND: return USECS_PER_SEC; case DTK_MILLISEC: return USECS_PER_SEC / 1000; case DTK_MICROSEC: return 1; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("timestamp units \"%s\" not supported", lowunits))); } return -1; } Oid ts_inheritance_parent_relid(Oid relid) { Relation catalog; SysScanDesc scan; ScanKeyData skey; Oid parent = InvalidOid; HeapTuple tuple; catalog = table_open(InheritsRelationId, AccessShareLock); ScanKeyInit(&skey, Anum_pg_inherits_inhrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relid)); scan = systable_beginscan(catalog, InheritsRelidSeqnoIndexId, true, NULL, 1, &skey); tuple = systable_getnext(scan); if (HeapTupleIsValid(tuple)) parent = ((Form_pg_inherits) GETSTRUCT(tuple))->inhparent; systable_endscan(scan); table_close(catalog, AccessShareLock); return parent; } TSDLLEXPORT bool ts_type_is_int8_binary_compatible(Oid sourcetype) { HeapTuple tuple; Form_pg_cast castForm; bool result; tuple = SearchSysCache2(CASTSOURCETARGET, ObjectIdGetDatum(sourcetype), ObjectIdGetDatum(INT8OID)); if (!HeapTupleIsValid(tuple)) return false; /* no cast */ castForm = (Form_pg_cast) GETSTRUCT(tuple); result = castForm->castmethod == COERCION_METHOD_BINARY; ReleaseSysCache(tuple); return result; } /* * Create a fresh struct pointer that will contain copied contents of the tuple. * Note that this function uses GETSTRUCT, which will not work correctly for tuple types * that might have variable lengths. * Also note that the function assumes no NULLs in the tuple. */ static void * ts_create_struct_from_tuple(HeapTuple tuple, MemoryContext mctx, size_t alloc_size, size_t copy_size) { void *struct_ptr = MemoryContextAllocZero(mctx, alloc_size); /* * Make sure the function is not used when the tuple contains NULLs. * Also compare the aligned sizes in the assert. */ Assert(copy_size == MAXALIGN(tuple->t_len - tuple->t_data->t_hoff)); memcpy(struct_ptr, GETSTRUCT(tuple), copy_size); return struct_ptr; } void * ts_create_struct_from_slot(TupleTableSlot *slot, MemoryContext mctx, size_t alloc_size, size_t copy_size) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); void *result = ts_create_struct_from_tuple(tuple, mctx, alloc_size, copy_size); if (should_free) heap_freetuple(tuple); return result; } bool ts_function_types_equal(Oid left[], Oid right[], int nargs) { int arg_index; for (arg_index = 0; arg_index < nargs; arg_index++) { if (left[arg_index] != right[arg_index]) return false; } return true; } Oid ts_get_function_oid(const char *funcname, const char *schema_name, int nargs, Oid arg_types[]) { List *qualified_funcname = list_make2(makeString(pstrdup(schema_name)), makeString(pstrdup(funcname))); FuncCandidateList func_candidates; func_candidates = FuncnameGetCandidates(qualified_funcname, nargs, NIL, false, false, /* include_out_arguments */ false, false); while (func_candidates != NULL) { if (func_candidates->nargs == nargs && ts_function_types_equal(func_candidates->args, arg_types, nargs)) return func_candidates->oid; func_candidates = func_candidates->next; } elog(ERROR, "failed to find function %s with %d args in schema \"%s\"", funcname, nargs, schema_name); return InvalidOid; } /* * Find a partitioning function with a given schema and name. * * The caller can optionally pass a filter function and a type of the argument * that the partitioning function should take. */ Oid ts_lookup_proc_filtered(const char *schema, const char *funcname, Oid *rettype, proc_filter filter, void *filter_arg) { Oid namespace_oid = LookupExplicitNamespace(schema, false); regproc func = InvalidOid; CatCList *catlist; int i; /* * We could use SearchSysCache3 to get by (name, args, namespace), but * that would not allow us to check for functions that take either * ANYELEMENTOID or a dimension-specific in the same search. */ catlist = SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(funcname)); for (i = 0; i < catlist->n_members; i++) { HeapTuple proctup = &catlist->members[i]->tuple; Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup); if (procform->pronamespace == namespace_oid && (filter == NULL || filter(procform, filter_arg))) { if (rettype) *rettype = procform->prorettype; func = procform->oid; break; } } ReleaseSysCacheList(catlist); return func; } /* * ts_get_operator * * finds an operator given an exact specification (name, namespace, * left and right type IDs). */ Oid ts_get_operator(const char *name, Oid namespace, Oid left, Oid right) { HeapTuple tup; Oid opoid = InvalidOid; tup = SearchSysCache4(OPERNAMENSP, PointerGetDatum(name), ObjectIdGetDatum(left), ObjectIdGetDatum(right), ObjectIdGetDatum(namespace)); if (HeapTupleIsValid(tup)) { Form_pg_operator oprform = (Form_pg_operator) GETSTRUCT(tup); opoid = oprform->oid; ReleaseSysCache(tup); } return opoid; } /* * ts_get_cast_func * * returns Oid of functions that implements cast from source to target */ Oid ts_get_cast_func(Oid source, Oid target) { Oid result = InvalidOid; HeapTuple casttup; casttup = SearchSysCache2(CASTSOURCETARGET, ObjectIdGetDatum(source), ObjectIdGetDatum(target)); if (HeapTupleIsValid(casttup)) { Form_pg_cast castform = (Form_pg_cast) GETSTRUCT(casttup); result = castform->castfunc; ReleaseSysCache(casttup); } return result; } AppendRelInfo * ts_get_appendrelinfo(PlannerInfo *root, Index rti, bool missing_ok) { ListCell *lc; /* use append_rel_array if it has been setup */ if (root->append_rel_array) { if (root->append_rel_array[rti]) return root->append_rel_array[rti]; if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("no appendrelinfo found for index %d", rti))); return NULL; } foreach (lc, root->append_rel_list) { AppendRelInfo *appinfo = lfirst(lc); if (appinfo->child_relid == rti) return appinfo; } if (!missing_ok) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("no appendrelinfo found for index %d", rti))); return NULL; } /* * Find an equivalence class member expression, all of whose Vars, come from * the indicated relation. * * This function has been copied from find_em_expr_for_rel in * contrib/postgres_fdw/postgres_fdw.c in postgres source. * This function was moved to postgres main in PG13 but was removed * again in PG15. So we use our own implementation for PG15+. */ Expr * ts_find_em_expr_for_rel(EquivalenceClass *ec, RelOptInfo *rel) { EquivalenceMember *em; #if PG18_GE /* Use specialized iterator to include child ems. * * https://github.com/postgres/postgres/commit/d69d45a5 */ EquivalenceMemberIterator it; setup_eclass_member_iterator(&it, ec, bms_make_singleton(rel->relid)); while ((em = eclass_member_iterator_next(&it)) != NULL) { #else ListCell *lc_em; foreach (lc_em, ec->ec_members) { em = lfirst(lc_em); #endif if (bms_is_subset(em->em_relids, rel->relids) && !bms_is_empty(em->em_relids)) { /* * If there is more than one equivalence member whose Vars are * taken entirely from this relation, we'll be content to choose * any one of those. */ return em->em_expr; } } /* We didn't find any suitable equivalence class expression */ return NULL; } bool ts_has_row_security(Oid relid) { HeapTuple tuple; Form_pg_class classform; bool relrowsecurity; bool relforcerowsecurity; /* Fetch relation's relrowsecurity and relforcerowsecurity flags */ tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for relid %u", relid); classform = (Form_pg_class) GETSTRUCT(tuple); relrowsecurity = classform->relrowsecurity; relforcerowsecurity = classform->relforcerowsecurity; ReleaseSysCache(tuple); return (relrowsecurity || relforcerowsecurity); } List * ts_get_reloptions(Oid relid) { HeapTuple tuple; Datum datum; bool isnull; List *options = NIL; Assert(OidIsValid(relid)); tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for relation %u", relid); datum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions, &isnull); if (!isnull && PointerIsValid(DatumGetPointer(datum))) options = untransformRelOptions(datum); ReleaseSysCache(tuple); return options; } /* * Get the integer_now function for a dimension */ Oid ts_get_integer_now_func(const Dimension *open_dim, bool fail_if_not_found) { Oid rettype; Oid now_func = InvalidOid; Oid argtypes[] = { 0 }; rettype = ts_dimension_get_partition_type(open_dim); Assert(IS_INTEGER_TYPE(rettype)); if (strlen(NameStr(open_dim->fd.integer_now_func)) == 0 && strlen(NameStr(open_dim->fd.integer_now_func_schema)) == 0) { if (fail_if_not_found) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), (errmsg("integer_now function not set")))); else return now_func; } List *name = list_make2(makeString((char *) NameStr(open_dim->fd.integer_now_func_schema)), makeString((char *) NameStr(open_dim->fd.integer_now_func))); now_func = LookupFuncName(name, 0, argtypes, false); if (get_func_rettype(now_func) != rettype) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), (errmsg("invalid integer_now function"), errhint("return type of function does not match dimension type")))); return now_func; } /* subtract passed in interval from the now. * Arguments: * now_func : function used to compute now. * interval : integer value * Returns: * now_func() - interval */ int64 ts_sub_integer_from_now(int64 interval, Oid time_dim_type, Oid now_func) { Datum now; int64 res; Assert(IS_INTEGER_TYPE(time_dim_type)); now = OidFunctionCall0(now_func); switch (time_dim_type) { case INT2OID: res = DatumGetInt16(now) - interval; if (res < PG_INT16_MIN || res > PG_INT16_MAX) ereport(ERROR, (errcode(ERRCODE_INTERVAL_FIELD_OVERFLOW), errmsg("integer time overflow"))); return res; case INT4OID: res = DatumGetInt32(now) - interval; if (res < PG_INT32_MIN || res > PG_INT32_MAX) ereport(ERROR, (errcode(ERRCODE_INTERVAL_FIELD_OVERFLOW), errmsg("integer time overflow"))); return res; case INT8OID: { bool overflow = pg_sub_s64_overflow(DatumGetInt64(now), interval, &res); if (overflow) { ereport(ERROR, (errcode(ERRCODE_INTERVAL_FIELD_OVERFLOW), errmsg("integer time overflow"))); } return res; } default: pg_unreachable(); } } TS_FUNCTION_INFO_V1(ts_subtract_integer_from_now); Datum ts_subtract_integer_from_now(PG_FUNCTION_ARGS) { Oid ht_relid = PG_GETARG_OID(0); int64 lag = PG_GETARG_INT64(1); Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(ht_relid, CACHE_FLAG_NONE, &hcache); const Dimension *dim = hyperspace_get_open_dimension(ht->space, 0); if (!dim) elog(ERROR, "hypertable has no open partitioning dimension"); Oid partitioning_type = ts_dimension_get_partition_type(dim); if (!IS_INTEGER_TYPE(partitioning_type)) elog(ERROR, "hypertable has no integer partitioning dimension"); Oid now_func = ts_get_integer_now_func(dim, true); if (!OidIsValid(now_func)) elog(ERROR, "could not find valid integer_now function for hypertable"); int64 res = ts_sub_integer_from_now(lag, partitioning_type, now_func); ts_cache_release(&hcache); return Int64GetDatum(res); } TS_FUNCTION_INFO_V1(ts_relation_size); Datum ts_relation_size(PG_FUNCTION_ARGS) { Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); RelationSize relsize = { 0 }; TupleDesc tupdesc; HeapTuple tuple; Datum values[4] = { 0 }; bool nulls[4] = { false }; /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); if (!OidIsValid(relid)) PG_RETURN_NULL(); relsize = ts_relation_size_impl(relid); tupdesc = BlessTupleDesc(tupdesc); values[0] = Int64GetDatum(relsize.total_size); values[1] = Int64GetDatum(relsize.heap_size); values[2] = Int64GetDatum(relsize.index_size); values[3] = Int64GetDatum(relsize.toast_size); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } RelationSize ts_relation_size_impl(Oid relid) { RelationSize relsize = { 0 }; Datum reloid = ObjectIdGetDatum(relid); Relation rel; DEBUG_WAITPOINT("relation_size_before_lock"); /* Open relation earlier to keep a lock during all function calls */ rel = try_relation_open(relid, AccessShareLock); if (!rel) return relsize; /* Get to total relation size to be our calculation base */ relsize.total_size = DatumGetInt64(DirectFunctionCall1(pg_total_relation_size, reloid)); /* Get the indexes size of the relation (don't consider TOAST indexes) */ relsize.index_size = DatumGetInt64(DirectFunctionCall1(pg_indexes_size, reloid)); /* If exists an associated TOAST calculate the total size (including indexes) */ if (OidIsValid(rel->rd_rel->reltoastrelid)) relsize.toast_size = DatumGetInt64(DirectFunctionCall1(pg_total_relation_size, ObjectIdGetDatum(rel->rd_rel->reltoastrelid))); else relsize.toast_size = 0; relation_close(rel, AccessShareLock); /* Calculate the HEAP size based on the total size and indexes plus toast */ relsize.heap_size = relsize.total_size - (relsize.index_size + relsize.toast_size); return relsize; } /* * Try to get cached size for a provided relation across all forks. The * size is returned in terms of number of blocks. * * The function calls the underlying smgrnblocks if there is no cached * data. That call populates the cache for subsequent invocations. This * cached data gets removed asynchronously by PG relcache invalidations * and then the refresh/cache cycle repeats till the next invalidation. */ static int64 ts_try_relation_cached_size(Relation rel, bool verbose) { BlockNumber result = InvalidBlockNumber, nblocks = 0; ForkNumber forkNum; bool cached = true; if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind)) return (int64) nblocks; /* Get heap size, including FSM and VM */ for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++) { result = RelationGetSmgr(rel)->smgr_cached_nblocks[forkNum]; if (result != InvalidBlockNumber) { nblocks += result; } else { if (smgrexists(RelationGetSmgr(rel), forkNum)) { cached = false; nblocks += smgrnblocks(RelationGetSmgr(rel), forkNum); } } } if (verbose) ereport(DEBUG2, (errmsg("%s for %s", cached ? "Cached size used" : "Fetching actual size", RelationGetRelationName(rel)))); /* convert the size into bytes and return */ return (int64) nblocks * BLCKSZ; } static RelationSize ts_relation_approximate_size_impl(Oid relid) { RelationSize relsize = { 0 }; Relation rel; DEBUG_WAITPOINT("relation_approximate_size_before_lock"); /* Open relation earlier to keep a lock during all function calls */ rel = try_relation_open(relid, AccessShareLock); if (!rel) return relsize; /* Get the main heap size */ relsize.heap_size = ts_try_relation_cached_size(rel, false); /* Get the size of the relation's indexes */ if (rel->rd_rel->relhasindex) { List *index_oids = RelationGetIndexList(rel); ListCell *cell; foreach (cell, index_oids) { Oid idxOid = lfirst_oid(cell); Relation idxRel; idxRel = relation_open(idxOid, AccessShareLock); relsize.index_size += ts_try_relation_cached_size(idxRel, false); relation_close(idxRel, AccessShareLock); } } /* If there's an associated TOAST table, calculate the total size (including its indexes) */ if (OidIsValid(rel->rd_rel->reltoastrelid)) { Relation toastRel; List *index_oids; ListCell *cell; toastRel = relation_open(rel->rd_rel->reltoastrelid, AccessShareLock); relsize.toast_size = ts_try_relation_cached_size(toastRel, false); /* Get the indexes size of the TOAST relation */ index_oids = RelationGetIndexList(toastRel); foreach (cell, index_oids) { Oid idxOid = lfirst_oid(cell); Relation idxRel; idxRel = relation_open(idxOid, AccessShareLock); relsize.toast_size += ts_try_relation_cached_size(idxRel, false); relation_close(idxRel, AccessShareLock); } relation_close(toastRel, AccessShareLock); } relation_close(rel, AccessShareLock); /* Add up the total size based on the heap size, indexes and toast */ relsize.total_size = relsize.heap_size + relsize.index_size + relsize.toast_size; return relsize; } TS_FUNCTION_INFO_V1(ts_relation_approximate_size); Datum ts_relation_approximate_size(PG_FUNCTION_ARGS) { Oid relid = PG_GETARG_OID(0); RelationSize relsize = { 0 }; TupleDesc tupdesc; HeapTuple tuple; Datum values[4] = { 0 }; bool nulls[4] = { false }; /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); /* check if object exists, return NULL otherwise */ if (get_rel_name(relid) == NULL) PG_RETURN_NULL(); relsize = ts_relation_approximate_size_impl(relid); tupdesc = BlessTupleDesc(tupdesc); values[0] = Int64GetDatum(relsize.total_size); values[1] = Int64GetDatum(relsize.heap_size); values[2] = Int64GetDatum(relsize.index_size); values[3] = Int64GetDatum(relsize.toast_size); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } static void init_scan_by_hypertable_id(ScanIterator *iterator, int32 hypertable_id) { iterator->ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_HYPERTABLE_ID_INDEX); ts_scan_iterator_scan_key_init(iterator, Anum_chunk_hypertable_id_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); } #define ADD_RELATIONSIZE(total, rel) \ do \ { \ (total).heap_size += (rel).heap_size; \ (total).toast_size += (rel).toast_size; \ (total).index_size += (rel).index_size; \ (total).total_size += (rel).total_size; \ } while (0) TS_FUNCTION_INFO_V1(ts_hypertable_approximate_size); Datum ts_hypertable_approximate_size(PG_FUNCTION_ARGS) { Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); RelationSize total_relsize = { 0 }; TupleDesc tupdesc; HeapTuple tuple; Datum values[4] = { 0 }; bool nulls[4] = { false }; Cache *hcache; Hypertable *ht; ScanIterator iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); if (!OidIsValid(relid)) PG_RETURN_NULL(); /* go ahead only if this is a hypertable or a CAgg */ hcache = ts_hypertable_cache_pin(); ht = ts_resolve_hypertable_from_table_or_cagg(hcache, relid, true); if (ht == NULL) { ts_cache_release(&hcache); PG_RETURN_NULL(); } /* get the main hypertable size */ total_relsize = ts_relation_approximate_size_impl(relid); iterator = ts_scan_iterator_create(CHUNK, RowExclusiveLock, CurrentMemoryContext); init_scan_by_hypertable_id(&iterator, ht->fd.id); ts_scanner_foreach(&iterator) { bool isnull, dropped, is_osm_chunk; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); Datum id = slot_getattr(ti->slot, Anum_chunk_id, &isnull); Datum comp_id = DatumGetInt32(slot_getattr(ti->slot, Anum_chunk_id, &isnull)); int32 chunk_id, compressed_chunk_id; Oid chunk_relid, compressed_chunk_relid; RelationSize chunk_relsize, compressed_chunk_relsize; if (isnull) continue; /* only consider chunks that are not dropped */ dropped = DatumGetBool(slot_getattr(ti->slot, Anum_chunk_dropped, &isnull)); Assert(!isnull); if (dropped) continue; chunk_id = DatumGetInt32(id); /* avoid if it's an OSM chunk */ is_osm_chunk = slot_getattr(ti->slot, Anum_chunk_osm_chunk, &isnull); Assert(!isnull); if (is_osm_chunk) continue; chunk_relid = ts_chunk_get_relid(chunk_id, false); chunk_relsize = ts_relation_approximate_size_impl(chunk_relid); /* add this chunk's size to the total size */ ADD_RELATIONSIZE(total_relsize, chunk_relsize); /* check if the chunk has a compressed counterpart and add if yes */ comp_id = slot_getattr(ti->slot, Anum_chunk_compressed_chunk_id, &isnull); if (isnull) continue; compressed_chunk_id = DatumGetInt32(comp_id); compressed_chunk_relid = ts_chunk_get_relid(compressed_chunk_id, false); compressed_chunk_relsize = ts_relation_approximate_size_impl(compressed_chunk_relid); /* add this compressed chunk's size to the total size */ ADD_RELATIONSIZE(total_relsize, compressed_chunk_relsize); } ts_scan_iterator_close(&iterator); tupdesc = BlessTupleDesc(tupdesc); values[0] = Int64GetDatum(total_relsize.heap_size); values[1] = Int64GetDatum(total_relsize.index_size); values[2] = Int64GetDatum(total_relsize.toast_size); values[3] = Int64GetDatum(total_relsize.total_size); tuple = heap_form_tuple(tupdesc, values, nulls); ts_cache_release(&hcache); return HeapTupleGetDatum(tuple); } #define STR_VALUE(str) #str #define NODE_CASE(name) \ case T_##name: \ return STR_VALUE(name) /* * Return a string with the name of the node. * */ const char * ts_get_node_name(Node *node) { /* tags are defined in nodes/nodes.h postgres source */ switch (nodeTag(node)) { /* * primitive nodes (primnodes.h) */ NODE_CASE(Alias); NODE_CASE(RangeVar); NODE_CASE(TableFunc); NODE_CASE(IntoClause); NODE_CASE(Var); NODE_CASE(Const); NODE_CASE(Param); NODE_CASE(Aggref); NODE_CASE(GroupingFunc); NODE_CASE(WindowFunc); NODE_CASE(SubscriptingRef); NODE_CASE(FuncExpr); NODE_CASE(NamedArgExpr); NODE_CASE(OpExpr); NODE_CASE(DistinctExpr); NODE_CASE(NullIfExpr); NODE_CASE(ScalarArrayOpExpr); NODE_CASE(BoolExpr); NODE_CASE(SubLink); NODE_CASE(SubPlan); NODE_CASE(AlternativeSubPlan); NODE_CASE(FieldSelect); NODE_CASE(FieldStore); NODE_CASE(RelabelType); NODE_CASE(CoerceViaIO); NODE_CASE(ArrayCoerceExpr); NODE_CASE(ConvertRowtypeExpr); NODE_CASE(CollateExpr); NODE_CASE(CaseExpr); NODE_CASE(CaseWhen); NODE_CASE(CaseTestExpr); NODE_CASE(ArrayExpr); NODE_CASE(RowExpr); NODE_CASE(RowCompareExpr); NODE_CASE(CoalesceExpr); NODE_CASE(MinMaxExpr); NODE_CASE(SQLValueFunction); NODE_CASE(XmlExpr); NODE_CASE(NullTest); NODE_CASE(BooleanTest); NODE_CASE(CoerceToDomain); NODE_CASE(CoerceToDomainValue); NODE_CASE(SetToDefault); NODE_CASE(CurrentOfExpr); NODE_CASE(NextValueExpr); NODE_CASE(InferenceElem); NODE_CASE(TargetEntry); NODE_CASE(RangeTblRef); NODE_CASE(JoinExpr); NODE_CASE(FromExpr); NODE_CASE(OnConflictExpr); /* * plan nodes (plannodes.h) */ #if PG16_LT NODE_CASE(Plan); NODE_CASE(Scan); NODE_CASE(Join); #endif NODE_CASE(Result); NODE_CASE(ProjectSet); NODE_CASE(ModifyTable); NODE_CASE(Append); NODE_CASE(MergeAppend); NODE_CASE(RecursiveUnion); NODE_CASE(BitmapAnd); NODE_CASE(BitmapOr); NODE_CASE(SeqScan); NODE_CASE(SampleScan); NODE_CASE(IndexScan); NODE_CASE(IndexOnlyScan); NODE_CASE(BitmapIndexScan); NODE_CASE(BitmapHeapScan); NODE_CASE(TidScan); NODE_CASE(SubqueryScan); NODE_CASE(FunctionScan); NODE_CASE(ValuesScan); NODE_CASE(TableFuncScan); NODE_CASE(CteScan); NODE_CASE(NamedTuplestoreScan); NODE_CASE(WorkTableScan); NODE_CASE(ForeignScan); NODE_CASE(CustomScan); NODE_CASE(NestLoop); NODE_CASE(MergeJoin); NODE_CASE(HashJoin); NODE_CASE(Material); NODE_CASE(Sort); NODE_CASE(Group); NODE_CASE(Agg); NODE_CASE(WindowAgg); NODE_CASE(Unique); NODE_CASE(Gather); NODE_CASE(GatherMerge); NODE_CASE(Hash); NODE_CASE(SetOp); NODE_CASE(LockRows); NODE_CASE(Limit); /* * planner nodes (pathnodes.h) */ NODE_CASE(IndexPath); NODE_CASE(BitmapHeapPath); NODE_CASE(BitmapAndPath); NODE_CASE(BitmapOrPath); NODE_CASE(TidPath); NODE_CASE(SubqueryScanPath); NODE_CASE(ForeignPath); NODE_CASE(NestPath); NODE_CASE(MergePath); NODE_CASE(HashPath); NODE_CASE(AppendPath); NODE_CASE(MergeAppendPath); NODE_CASE(GroupResultPath); NODE_CASE(MaterialPath); NODE_CASE(UniquePath); NODE_CASE(GatherPath); NODE_CASE(GatherMergePath); NODE_CASE(ProjectionPath); NODE_CASE(ProjectSetPath); NODE_CASE(SortPath); NODE_CASE(GroupPath); NODE_CASE(UpperUniquePath); NODE_CASE(AggPath); NODE_CASE(GroupingSetsPath); NODE_CASE(MinMaxAggPath); NODE_CASE(WindowAggPath); NODE_CASE(SetOpPath); NODE_CASE(RecursiveUnionPath); NODE_CASE(LockRowsPath); NODE_CASE(ModifyTablePath); NODE_CASE(LimitPath); case T_Path: switch (castNode(Path, node)->pathtype) { NODE_CASE(SeqScan); NODE_CASE(SampleScan); NODE_CASE(SubqueryScan); NODE_CASE(FunctionScan); NODE_CASE(TableFuncScan); NODE_CASE(ValuesScan); NODE_CASE(CteScan); NODE_CASE(WorkTableScan); default: return psprintf("Path (%d)", castNode(Path, node)->pathtype); } case T_CustomPath: return psprintf("CustomPath (%s)", castNode(CustomPath, node)->methods->CustomName); default: return psprintf("Node (%d)", nodeTag(node)); } } /* * Implementation marked unused in PostgreSQL lsyscache.c */ int ts_get_relnatts(Oid relid) { HeapTuple tp; Form_pg_class reltup; int result; tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tp)) return InvalidAttrNumber; reltup = (Form_pg_class) GETSTRUCT(tp); result = reltup->relnatts; ReleaseSysCache(tp); return result; } /* * Wrap AlterTableInternal() for event trigger handling. * * AlterTableInternal can be called as a utility command, which is common in a * SQL function that alters a table in some form when called in the form * SELECT <cmd> INTO <table>. This is transformed into a process utility * command (CREATE TABLE AS), which expects an event trigger context to be * set up. * * The "cmd" parameter can be set to a higher-level command that caused the * alter table to occur. If "cmd" is set to NULL, the "cmds" list will be used * instead. */ void ts_alter_table_with_event_trigger(Oid relid, Node *cmd, List *cmds, bool recurse) { if (cmd == NULL) cmd = (Node *) cmds; EventTriggerAlterTableStart(cmd); AlterTableInternal(relid, cmds, recurse); EventTriggerAlterTableEnd(); } void ts_copy_relation_acl(const Oid source_relid, const Oid target_relid, const Oid owner_id) { HeapTuple source_tuple; bool is_null; Datum acl_datum; Relation class_rel; /* We open it here since there is no point in trying to update the tuples * if we cannot open the Relation catalog table */ class_rel = table_open(RelationRelationId, RowExclusiveLock); source_tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(source_relid)); Assert(HeapTupleIsValid(source_tuple)); /* We only bother about setting the ACL if the source relation ACL is * non-null */ acl_datum = SysCacheGetAttr(RELOID, source_tuple, Anum_pg_class_relacl, &is_null); if (!is_null) { HeapTuple target_tuple, newtuple; Datum new_val[Natts_pg_class] = { 0 }; bool new_null[Natts_pg_class] = { false }; bool new_repl[Natts_pg_class] = { false }; Acl *acl = DatumGetAclP(acl_datum); new_repl[AttrNumberGetAttrOffset(Anum_pg_class_relacl)] = true; new_val[AttrNumberGetAttrOffset(Anum_pg_class_relacl)] = PointerGetDatum(acl); /* * ts_copy_relation_acl() is typically used to copy ACLs from the hypertable * to a newly created chunk. The creation is done via DefineRelation(), * which takes an AccessExclusiveLock and should be enough to handle any * inplace update issues. */ AssertSufficientPgClassUpdateLockHeld(target_relid); /* Find the tuple for the target in `pg_class` */ target_tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(target_relid)); Assert(HeapTupleIsValid(target_tuple)); /* Update the relacl for the target tuple to use the acl from the source */ newtuple = heap_modify_tuple(target_tuple, RelationGetDescr(class_rel), new_val, new_null, new_repl); CatalogTupleUpdate(class_rel, &newtuple->t_self, newtuple); /* We need to update the shared dependencies as well to indicate that * the target is dependent on any roles that the source is * dependent on. */ Oid *newmembers; int nnewmembers = aclmembers(acl, &newmembers); /* The list of old members is intentionally empty since we are using * updateAclDependencies to set the ACL for the target. We can use NULL * because getOidListDiff, which is called from updateAclDependencies, * can handle that. */ updateAclDependencies(RelationRelationId, target_relid, 0, owner_id, 0, NULL, nnewmembers, newmembers); heap_freetuple(newtuple); ReleaseSysCache(target_tuple); } ReleaseSysCache(source_tuple); table_close(class_rel, RowExclusiveLock); } /* * Map attno from source relation to target relation by column name */ AttrNumber ts_map_attno(Oid src_rel, Oid dst_rel, AttrNumber attno) { char *attname = get_attname(src_rel, attno, false); AttrNumber dst_attno = get_attnum(dst_rel, attname); /* * For any chunk mappings we do this should never happen. */ if (dst_attno == InvalidAttrNumber) elog(ERROR, "could not map attribute number from relation \"%s\" to \"%s\" for column \"%s\"", get_rel_name(src_rel), get_rel_name(dst_rel), attname); pfree(attname); return dst_attno; } bool ts_relation_has_tuples(Relation rel) { TableScanDesc scandesc = table_beginscan(rel, GetActiveSnapshot(), 0, NULL); TupleTableSlot *slot = MakeSingleTupleTableSlot(RelationGetDescr(rel), table_slot_callbacks(rel)); bool hastuples = table_scan_getnextslot(scandesc, ForwardScanDirection, slot); table_endscan(scandesc); ExecDropSingleTupleTableSlot(slot); return hastuples; } bool ts_table_has_tuples(Oid table_relid, LOCKMODE lockmode) { Relation rel = table_open(table_relid, lockmode); bool hastuples = ts_relation_has_tuples(rel); table_close(rel, lockmode); return hastuples; } /* * This is copied from PostgreSQL 16.0 since versions before 16.0 does not * support lists for privileges. */ static AclMode ts_convert_any_priv_string(text *priv_type_text, const priv_map *privileges) { AclMode result = 0; char *priv_type = text_to_cstring(priv_type_text); char *chunk; char *next_chunk; /* We rely on priv_type being a private, modifiable string */ for (chunk = priv_type; chunk; chunk = next_chunk) { int chunk_len; const priv_map *this_priv; /* Split string at commas */ next_chunk = strchr(chunk, ','); if (next_chunk) *next_chunk++ = '\0'; /* Drop leading/trailing whitespace in this chunk */ while (*chunk && isspace((unsigned char) *chunk)) chunk++; chunk_len = strlen(chunk); while (chunk_len > 0 && isspace((unsigned char) chunk[chunk_len - 1])) chunk_len--; chunk[chunk_len] = '\0'; /* Match to the privileges list */ for (this_priv = privileges; this_priv->name; this_priv++) { if (pg_strcasecmp(this_priv->name, chunk) == 0) { result |= this_priv->value; break; } } if (!this_priv->name) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized privilege type: \"%s\"", chunk))); } pfree(priv_type); return result; } /* * This is copied from PostgreSQL 16.0 since versions before 16.0 does not * support lists for privileges but we need that. */ Datum ts_makeaclitem(PG_FUNCTION_ARGS) { Oid grantee = PG_GETARG_OID(0); Oid grantor = PG_GETARG_OID(1); text *privtext = PG_GETARG_TEXT_PP(2); bool goption = PG_GETARG_BOOL(3); AclItem *result; AclMode priv; static const priv_map any_priv_map[] = { { "SELECT", ACL_SELECT }, { "INSERT", ACL_INSERT }, { "UPDATE", ACL_UPDATE }, { "DELETE", ACL_DELETE }, { "TRUNCATE", ACL_TRUNCATE }, { "REFERENCES", ACL_REFERENCES }, { "TRIGGER", ACL_TRIGGER }, { "EXECUTE", ACL_EXECUTE }, { "USAGE", ACL_USAGE }, { "CREATE", ACL_CREATE }, { "TEMP", ACL_CREATE_TEMP }, { "TEMPORARY", ACL_CREATE_TEMP }, { "CONNECT", ACL_CONNECT }, #if PG16_GE { "SET", ACL_SET }, { "ALTER SYSTEM", ACL_ALTER_SYSTEM }, #endif #if PG17_GE { "MAINTAIN", ACL_MAINTAIN }, #endif { "RULE", 0 }, /* ignore old RULE privileges */ { NULL, 0 } }; priv = ts_convert_any_priv_string(privtext, any_priv_map); result = (AclItem *) palloc(sizeof(AclItem)); result->ai_grantee = grantee; result->ai_grantor = grantor; ACLITEM_SET_PRIVS_GOPTIONS(*result, priv, (goption ? priv : ACL_NO_RIGHTS)); PG_RETURN_ACLITEM_P(result); } /* * heap_form_tuple using NullableDatum array instead of two arrays for * values and nulls */ HeapTuple ts_heap_form_tuple(TupleDesc tupleDescriptor, NullableDatum *datums) { int numElements = tupleDescriptor->natts; Datum *values = palloc0(sizeof(Datum) * numElements); bool *nulls = palloc0(sizeof(bool) * numElements); for (int i = 0; i < numElements; i++) { values[i] = datums[i].value; nulls[i] = datums[i].isnull; } return heap_form_tuple(tupleDescriptor, values, nulls); } /* * To not introduce shared object dependencies on functions in extension update * scripts we use this stub function as placeholder whenever we need to reference * c functions in the update scripts. */ TS_FUNCTION_INFO_V1(ts_update_placeholder); Datum ts_update_placeholder(PG_FUNCTION_ARGS) { elog(ERROR, "this stub function is used only as placeholder during extension updates"); PG_RETURN_NULL(); } /* * Get relation information from the syscache in one call. * * Returns relid and relkind. All are non-optional. */ void ts_get_rel_info_by_name(const char *relnamespace, const char *relname, Oid *relid, char *relkind) { HeapTuple tuple; Form_pg_class cform; Oid namespaceoid = get_namespace_oid(relnamespace, false); tuple = SearchSysCache2(RELNAMENSP, PointerGetDatum(relname), ObjectIdGetDatum(namespaceoid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for relation %s.%s", relnamespace, relname); cform = (Form_pg_class) GETSTRUCT(tuple); *relid = cform->oid; *relkind = cform->relkind; ReleaseSysCache(tuple); } Oid ts_get_rel_am(Oid relid) { HeapTuple tuple; Form_pg_class cform; Oid amoid; tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for relation %u", relid); cform = (Form_pg_class) GETSTRUCT(tuple); amoid = cform->relam; ReleaseSysCache(tuple); return amoid; } /* * Set reloption for relation. * * Most of the code is from ATExecSetRelOptions() in tablecmds.c since that * function is static and we also need to do a slightly different job. */ static void relation_set_reloption_impl(Relation rel, List *options, LOCKMODE lockmode) { Datum repl_val[Natts_pg_class] = { 0 }; bool repl_null[Natts_pg_class] = { false }; bool repl_repl[Natts_pg_class] = { false }; bool isnull; Assert(rel->rd_rel->relkind == RELKIND_RELATION || rel->rd_rel->relkind == RELKIND_TOASTVALUE); if (options == NIL) return; /* nothing to do */ TS_DEBUG_LOG("setting reloptions for %s", RelationGetRelationName(rel)); Relation pgclass = table_open(RelationRelationId, RowExclusiveLock); Oid relid = RelationGetRelid(rel); HeapTuple tuple = SearchSysCacheLockedCopy1(RELOID, ObjectIdGetDatum(relid)); if (!HeapTupleIsValid(tuple)) elog(ERROR, "cache lookup failed for relation %u", relid); #ifdef SYSCACHE_TUPLE_LOCK_NEEDED ItemPointerData otid = tuple->t_self; #endif /* Get the old reloptions */ Datum datum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions, &isnull); /* Generate new proposed reloptions (text array) */ Datum newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, options, NULL, NULL, false, false); (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true); if (newOptions) repl_val[AttrNumberGetAttrOffset(Anum_pg_class_reloptions)] = newOptions; else repl_null[AttrNumberGetAttrOffset(Anum_pg_class_reloptions)] = true; repl_repl[AttrNumberGetAttrOffset(Anum_pg_class_reloptions)] = true; HeapTuple newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass), repl_val, repl_null, repl_repl); CatalogTupleUpdate(pgclass, &newtuple->t_self, newtuple); /* Not sure if we need this one, but keeping it as a precaution */ InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(rel), 0); UnlockSysCacheTuple(pgclass, &otid); heap_freetuple(newtuple); heap_freetuple(tuple); table_close(pgclass, RowExclusiveLock); } /* * Set value of reloptions for given relation. * * This will also set the reloption for the relations' associated relations, * in this case the TOAST table. It is based on ATExecSetRelOptions but we * split out the code to set the reloptions rather than duplicating it. * * The lockmode is needed for taking a correct lock on the toast table for the * already locked relation. It is only used for * * rel: Relation to add reloptions to. * defList: List of DefElem for the new definitions. * lockmode: the mode that the actual tables are locked in. */ void ts_relation_set_reloption(Relation rel, List *options, LOCKMODE lockmode) { Assert(RelationIsValid(rel)); relation_set_reloption_impl(rel, options, lockmode); if (OidIsValid(rel->rd_rel->reltoastrelid)) { Relation toastrel = table_open(rel->rd_rel->reltoastrelid, lockmode); relation_set_reloption_impl(toastrel, options, lockmode); table_close(toastrel, NoLock); } } /* this function fills in a jsonb with the non-null fields of the error data and also includes the proc name and schema in the jsonb we include these here to avoid adding these fields to the table */ Jsonb * ts_errdata_to_jsonb(ErrorData *edata, Name proc_schema, Name proc_name) { JsonbParseState *parse_state = NULL; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); if (edata->sqlerrcode) ts_jsonb_add_str(parse_state, "sqlerrcode", unpack_sql_state(edata->sqlerrcode)); if (edata->message) ts_jsonb_add_str(parse_state, "message", edata->message); if (edata->detail) ts_jsonb_add_str(parse_state, "detail", edata->detail); if (edata->hint) ts_jsonb_add_str(parse_state, "hint", edata->hint); if (edata->filename) ts_jsonb_add_str(parse_state, "filename", edata->filename); if (edata->lineno) ts_jsonb_add_int32(parse_state, "lineno", edata->lineno); if (edata->funcname) ts_jsonb_add_str(parse_state, "funcname", edata->funcname); if (edata->domain) ts_jsonb_add_str(parse_state, "domain", edata->domain); if (edata->context_domain) ts_jsonb_add_str(parse_state, "context_domain", edata->context_domain); if (edata->context) ts_jsonb_add_str(parse_state, "context", edata->context); if (edata->schema_name) ts_jsonb_add_str(parse_state, "schema_name", edata->schema_name); if (edata->table_name) ts_jsonb_add_str(parse_state, "table_name", edata->table_name); if (edata->column_name) ts_jsonb_add_str(parse_state, "column_name", edata->column_name); if (edata->datatype_name) ts_jsonb_add_str(parse_state, "datatype_name", edata->datatype_name); if (edata->constraint_name) ts_jsonb_add_str(parse_state, "constraint_name", edata->constraint_name); if (edata->internalquery) ts_jsonb_add_str(parse_state, "internalquery", edata->internalquery); if (edata->detail_log) ts_jsonb_add_str(parse_state, "detail_log", edata->detail_log); if (strlen(NameStr(*proc_schema)) > 0) ts_jsonb_add_str(parse_state, "proc_schema", NameStr(*proc_schema)); if (strlen(NameStr(*proc_name)) > 0) ts_jsonb_add_str(parse_state, "proc_name", NameStr(*proc_name)); /* we add the schema qualified name here as well*/ JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); return JsonbValueToJsonb(result); } char * ts_get_attr_expr(Relation rel, AttrNumber attno) { TupleConstr *constr = rel->rd_att->constr; char *expr = NULL; for (int i = 0; i < constr->num_defval; i++) { if (constr->defval[i].adnum == attno) { expr = TextDatumGetCString( DirectFunctionCall2(pg_get_expr, CStringGetTextDatum(constr->defval[i].adbin), ObjectIdGetDatum(RelationGetRelid(rel)))); break; } } return expr; } char * ts_list_to_string(List *list, append_cell_func append) { StringInfoData info; ListCell *lc; initStringInfo(&info); foreach (lc, list) { if (!lnext(list, lc)) appendStringInfoString(&info, "and "); append(&info, lc); if (lnext(list, lc)) { if (list_length(list) > 2) appendStringInfoChar(&info, ','); appendStringInfoChar(&info, ' '); } } return info.data; } ���������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/utils.h����������������������������������������������������������������������0000664�0000000�0000000�00000033041�15100345067�0016154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/htup_details.h> #include <access/tupdesc.h> #include <catalog/namespace.h> #include <catalog/pg_proc.h> #include <common/int.h> #include <debug_assert.h> #include <foreign/foreign.h> #include <nodes/extensible.h> #include <nodes/pathnodes.h> #include <optimizer/paths.h> #include <utils/builtins.h> #include <utils/datetime.h> #include <utils/jsonb.h> #include "compat/compat.h" #include "process_utility.h" /* * Macro for debug messages that should *only* be present in debug builds but * which should be removed in release builds. This is typically used for * debug builds for development purposes. * * Note that some debug messages might be relevant to deploy in release build * for debugging production systems. This macro is *not* for those cases. */ #ifdef TS_DEBUG #define TS_DEBUG_LOG(FMT, ...) elog(DEBUG2, "%s - " FMT, __func__, ##__VA_ARGS__) #else #define TS_DEBUG_LOG(FMT, ...) #endif #define UnassignedDatum (Datum) 0 static inline int64 interval_to_usec(Interval *interval) { return (interval->month * DAYS_PER_MONTH * USECS_PER_DAY) + (interval->day * USECS_PER_DAY) + interval->time; } #ifdef TS_DEBUG static inline const char * yes_no(bool value) { return value ? "yes" : "no"; } /* Convert datum to string using the output function. */ static inline const char * datum_as_string(Oid typid, Datum value, bool is_null) { Oid typoutput; bool typIsVarlena; if (is_null) return "<NULL>"; getTypeOutputInfo(typid, &typoutput, &typIsVarlena); return OidOutputFunctionCall(typoutput, value); } static inline const char * slot_as_string(TupleTableSlot *slot) { StringInfoData info; initStringInfo(&info); appendStringInfoString(&info, "{"); for (int i = 0; i < slot->tts_tupleDescriptor->natts; i++) { Form_pg_attribute att = TupleDescAttr(slot->tts_tupleDescriptor, i); if (att->attisdropped) continue; appendStringInfo(&info, "%s: %s", NameStr(att->attname), datum_as_string(att->atttypid, slot->tts_values[i], slot->tts_isnull[i])); if (i + 1 < slot->tts_tupleDescriptor->natts) appendStringInfoString(&info, ", "); } appendStringInfoString(&info, "}"); return info.data; } #endif /* TS_DEBUG */ /* * Get the function name in a PG_FUNCTION. * * The function name is resolved from the function Oid in the functioncall * data. However, this information is not present in case of a direct function * call, so fall back to the C-function name. */ #define TS_FUNCNAME() \ (psprintf("%s()", fcinfo->flinfo ? get_func_name(FC_FN_OID(fcinfo)) : __func__)) #define TS_PREVENT_FUNC_IF_READ_ONLY() PreventCommandIfReadOnly(TS_FUNCNAME()) #define TS_PREVENT_IN_TRANSACTION_BLOCK(CMD) \ do \ { \ bool _isTopLevel = ts_process_utility_is_top_level(); \ /* Reset context before calling PreventInTransactionBlock in case it aborts. */ \ ts_process_utility_context_reset(); \ PreventInTransactionBlock(_isTopLevel, (CMD)); \ } while (0) #define MAX(x, y) ((x) > (y) ? x : y) #define MIN(x, y) ((x) < (y) ? x : y) /* Use a special pseudo-random field 4 value to avoid conflicting with user-advisory-locks */ #define TS_SET_LOCKTAG_ADVISORY(tag, id1, id2, id3) \ SET_LOCKTAG_ADVISORY((tag), (id1), (id2), (id3), 29749) /* find the length of a statically sized array */ #define TS_ARRAY_LEN(array) (sizeof(array) / sizeof(*array)) extern TSDLLEXPORT bool ts_type_is_int8_binary_compatible(Oid sourcetype); typedef bool (*proc_filter)(Form_pg_proc form, void *arg); /* * Convert a column value into the internal time representation. * cannot store a timestamp earlier than MIN_TIMESTAMP, or greater than * END_TIMESTAMP - TS_EPOCH_DIFF_MICROSECONDS * nor dates that cannot be translated to timestamps * Will throw an error for that, or other conversion issues. */ extern TSDLLEXPORT int64 ts_time_value_to_internal(Datum time_val, Oid type); extern int64 ts_time_value_to_internal_or_infinite(Datum time_val, Oid type_oid); extern TSDLLEXPORT int64 ts_interval_value_to_internal(Datum time_val, Oid type_oid); /* * Convert a column from the internal time representation into the specified type */ extern TSDLLEXPORT Datum ts_internal_to_time_value(int64 value, Oid type); extern TSDLLEXPORT int64 ts_internal_to_time_int64(int64 value, Oid type); extern TSDLLEXPORT Datum ts_internal_to_interval_value(int64 value, Oid type); extern TSDLLEXPORT char *ts_datum_to_string(Datum value, Oid type); extern TSDLLEXPORT char *ts_internal_to_time_string(int64 value, Oid type); /* * Return the period in microseconds of the first argument to date_trunc. * This is approximate -- to be used for planning; */ extern int64 ts_date_trunc_interval_period_approx(text *units); /* * Return the interval period in microseconds. * This is approximate -- to be used for planning; */ extern TSDLLEXPORT int64 ts_get_interval_period_approx(Interval *interval); extern TSDLLEXPORT Oid ts_inheritance_parent_relid(Oid relid); extern Oid ts_lookup_proc_filtered(const char *schema, const char *funcname, Oid *rettype, proc_filter filter, void *filter_arg); extern Oid ts_get_operator(const char *name, Oid namespace, Oid left, Oid right); extern bool ts_function_types_equal(Oid left[], Oid right[], int nargs); extern TSDLLEXPORT Oid ts_get_function_oid(const char *funcname, const char *schema_name, int nargs, Oid arg_types[]); extern TSDLLEXPORT Oid ts_get_cast_func(Oid source, Oid target); typedef struct Dimension Dimension; extern TSDLLEXPORT Oid ts_get_integer_now_func(const Dimension *open_dim, bool fail_if_not_found); extern TSDLLEXPORT int64 ts_sub_integer_from_now(int64 interval, Oid time_dim_type, Oid now_func); extern TSDLLEXPORT void *ts_create_struct_from_slot(TupleTableSlot *slot, MemoryContext mctx, size_t alloc_size, size_t copy_size); extern TSDLLEXPORT AppendRelInfo *ts_get_appendrelinfo(PlannerInfo *root, Index rti, bool missing_ok); extern TSDLLEXPORT Expr *ts_find_em_expr_for_rel(EquivalenceClass *ec, RelOptInfo *rel); extern TSDLLEXPORT bool ts_has_row_security(Oid relid); extern TSDLLEXPORT List *ts_get_reloptions(Oid relid); #define STRUCT_FROM_SLOT(slot, mctx, to_type, form_type) \ (to_type *) ts_create_struct_from_slot(slot, mctx, sizeof(to_type), sizeof(form_type)); /* note PG10 has_superclass but PG96 does not so use this */ #define is_inheritance_child(relid) (OidIsValid(ts_inheritance_parent_relid((relid)))) #define is_inheritance_parent(relid) \ (find_inheritance_children(table_relid, AccessShareLock) != NIL) #define is_inheritance_table(relid) (is_inheritance_child(relid) || is_inheritance_parent(relid)) #define INIT_NULL_DATUM \ { \ .value = 0, .isnull = true \ } static inline Datum ts_fetch_att(const void *T, bool attbyval, int attlen) { /* Length should be set to something sensible, otherwise an error will be * raised by fetch_att, so we assert this here to get a stack for * violations. */ Assert(!attbyval || (attlen > 0 && attlen <= 8)); return fetch_att(T, attbyval, attlen); } static inline int64 int64_min(int64 a, int64 b) { if (a <= b) return a; return b; } static inline int64 int64_saturating_add(int64 a, int64 b) { int64 result; bool overflowed = pg_add_s64_overflow(a, b, &result); if (overflowed) result = a < 0 ? PG_INT64_MIN : PG_INT64_MAX; return result; } static inline int64 int64_saturating_sub(int64 a, int64 b) { int64 result; bool overflowed = pg_sub_s64_overflow(a, b, &result); if (overflowed) result = b < 0 ? PG_INT64_MAX : PG_INT64_MIN; return result; } static inline bool ts_flags_are_set_32(uint32 bitmap, uint32 flags) { return (bitmap & flags) == flags; } static inline pg_nodiscard uint32 ts_set_flags_32(uint32 bitmap, uint32 flags) { return bitmap | flags; } static inline uint32 ts_clear_flags_32(uint32 bitmap, uint32 flags) { return bitmap & ~flags; } /** * Try to register a custom scan method. * * When registering a custom scan node, it might be called multiple times when * different databases have different versions of the extension installed, so * this function can be used to try to register a custom scan method but not * fail if it has already been registered. */ static inline void TryRegisterCustomScanMethods(const CustomScanMethods *methods) { if (!GetCustomScanMethods(methods->CustomName, true)) RegisterCustomScanMethods(methods); } typedef struct RelationSize { int64 total_size; int64 heap_size; int64 toast_size; int64 index_size; } RelationSize; extern TSDLLEXPORT RelationSize ts_relation_size_impl(Oid relid); extern TSDLLEXPORT const char *ts_get_node_name(Node *node); extern TSDLLEXPORT int ts_get_relnatts(Oid relid); extern TSDLLEXPORT void ts_alter_table_with_event_trigger(Oid relid, Node *cmd, List *cmds, bool recurse); extern TSDLLEXPORT void ts_copy_relation_acl(const Oid source_relid, const Oid target_relid, const Oid owner_id); extern TSDLLEXPORT bool ts_relation_has_tuples(Relation rel); extern TSDLLEXPORT bool ts_table_has_tuples(Oid table_relid, LOCKMODE lockmode); extern TSDLLEXPORT AttrNumber ts_map_attno(Oid src_rel, Oid dst_rel, AttrNumber attno); /* * Return Oid for a schema-qualified relation. */ static inline Oid ts_get_relation_relid(char const *schema_name, char const *relation_name, bool return_invalid) { Oid schema_oid = get_namespace_oid(schema_name, true); if (OidIsValid(schema_oid)) { Oid rel_oid = get_relname_relid(relation_name, schema_oid); if (!return_invalid) Ensure(OidIsValid(rel_oid), "relation \"%s.%s\" not found", schema_name, relation_name); return rel_oid; } else { if (!return_invalid) Ensure(OidIsValid(schema_oid), "schema \"%s\" not found (during lookup of relation \"%s.%s\")", schema_name, schema_name, relation_name); return InvalidOid; } } struct Hypertable; void replace_now_mock_walker(PlannerInfo *root, Node *clause, Oid funcid); extern TSDLLEXPORT HeapTuple ts_heap_form_tuple(TupleDesc tupleDescriptor, NullableDatum *datums); static inline void ts_datum_set_text_from_cstring(const AttrNumber attno, NullableDatum *datums, const char *value) { if (value != NULL) { datums[AttrNumberGetAttrOffset(attno)].value = PointerGetDatum(cstring_to_text(value)); datums[AttrNumberGetAttrOffset(attno)].isnull = false; } else datums[AttrNumberGetAttrOffset(attno)].isnull = true; } static inline void ts_datum_set_bool(const AttrNumber attno, NullableDatum *datums, const bool value, const bool isnull) { if (!isnull) datums[AttrNumberGetAttrOffset(attno)].value = BoolGetDatum(value); datums[AttrNumberGetAttrOffset(attno)].isnull = isnull; } static inline void ts_datum_set_int32(const AttrNumber attno, NullableDatum *datums, const int32 value, const bool isnull) { if (!isnull) datums[AttrNumberGetAttrOffset(attno)].value = Int32GetDatum(value); datums[AttrNumberGetAttrOffset(attno)].isnull = isnull; } static inline void ts_datum_set_int64(const AttrNumber attno, NullableDatum *datums, const int64 value, const bool isnull) { if (!isnull) datums[AttrNumberGetAttrOffset(attno)].value = Int64GetDatum(value); datums[AttrNumberGetAttrOffset(attno)].isnull = isnull; } static inline void ts_datum_set_timestamptz(const AttrNumber attno, NullableDatum *datums, const TimestampTz value, const bool isnull) { if (!isnull) datums[AttrNumberGetAttrOffset(attno)].value = TimestampTzGetDatum(value); datums[AttrNumberGetAttrOffset(attno)].isnull = isnull; } static inline void ts_datum_set_jsonb(const AttrNumber attno, NullableDatum *datums, const Jsonb *value) { if (value != NULL) { datums[AttrNumberGetAttrOffset(attno)].value = JsonbPGetDatum(value); datums[AttrNumberGetAttrOffset(attno)].isnull = false; } else datums[AttrNumberGetAttrOffset(attno)].isnull = true; } static inline void ts_datum_set_objectid(const AttrNumber attno, NullableDatum *datums, const Oid value) { if (OidIsValid(value)) { datums[AttrNumberGetAttrOffset(attno)].value = ObjectIdGetDatum(value); datums[AttrNumberGetAttrOffset(attno)].isnull = false; } else datums[AttrNumberGetAttrOffset(attno)].isnull = true; } typedef void (*append_cell_func)(StringInfo, ListCell *); extern TSDLLEXPORT void ts_get_rel_info_by_name(const char *relnamespace, const char *relname, Oid *relid, char *relkind); extern TSDLLEXPORT Oid ts_get_rel_am(Oid relid); extern TSDLLEXPORT void ts_relation_set_reloption(Relation rel, List *options, LOCKMODE lockmode); extern TSDLLEXPORT Jsonb *ts_errdata_to_jsonb(ErrorData *edata, Name proc_schema, Name proc_name); extern TSDLLEXPORT char *ts_get_attr_expr(Relation rel, AttrNumber attno); extern TSDLLEXPORT char *ts_list_to_string(List *list, append_cell_func append); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/uuid.c�����������������������������������������������������������������������0000664�0000000�0000000�00000014716�15100345067�0015765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <port/pg_bswap.h> #include <utils/timestamp.h> #include <utils/uuid.h> #include "compat/compat.h" #include "uuid.h" /* * Generates a v4 UUID. Based on function pg_random_uuid() in the pgcrypto contrib module. * * Note that clib on Mac has a uuid_generate() function, so we call this ts_uuid_create(). */ pg_uuid_t * ts_uuid_create(void) { /* * PG9.6 doesn't expose the internals of pg_uuid_t, so we just treat it as * a byte array */ unsigned char *gen_uuid = palloc0(UUID_LEN); bool rand_success = false; rand_success = pg_backend_random((char *) gen_uuid, UUID_LEN); /* * If pg_backend_random() cannot find sources of randomness, then we use * the current timestamp as a "random source". * Timestamps are 8 bytes, so we copy this into bytes 9-16 of the UUID. * If we see all 0s in bytes 0-8 (other than version + * variant), we know * that there is something wrong with the RNG on this instance. */ if (!rand_success) { TimestampTz ts = GetCurrentTimestamp(); memcpy(&gen_uuid[8], &ts, sizeof(TimestampTz)); } gen_uuid[6] = (gen_uuid[6] & 0x0f) | 0x40; /* "version" field */ gen_uuid[8] = (gen_uuid[8] & 0x3f) | 0x80; /* "variant" field */ return (pg_uuid_t *) gen_uuid; } TS_FUNCTION_INFO_V1(ts_uuid_generate); Datum ts_uuid_generate(PG_FUNCTION_ARGS) { PG_RETURN_UUID_P(ts_uuid_create()); } /* * Create a UUIDv7 from a unix timestamp in microseconds. * * Optionally produce a boundary UUID with all otherwise random bits set to * zero that can be used in range queries. The version can also be set to zero * in order to produce partition ranges that excludes the UUID version. */ pg_uuid_t * ts_create_uuid_v7_from_unixtime_us(int64 unixtime_us, bool boundary, bool set_version) { pg_uuid_t *uuid; uint64_t timestamp_be = pg_hton64((unixtime_us / 1000) << 16); if (boundary) { uuid = (pg_uuid_t *) palloc0(UUID_LEN); } else { uuid = (pg_uuid_t *) palloc(UUID_LEN); pg_backend_random(&((char *) uuid)[8], UUID_LEN - 8); } /* Fill the first 48 bits with the timestamp */ memcpy(uuid->data, ×tamp_be, 6); /* The microseconds part of the timestamp, scaled to 12 bits, same as in PG18 */ uint32 ts_micros = (unixtime_us % 1000) * (1 << 12) / 1000; /* * Sub milliseconds timestamps are optional. We store the microseconds part in the * rand_a field as described in the UUID v7 specification. Following the PG18 logic * here. */ uuid->data[6] = (unsigned char) (ts_micros >> 8); uuid->data[7] = (unsigned char) ts_micros; if (set_version) { /* Set version 7 (0111) in bits 6-7 of byte 6, keep random bits 0-5 */ uuid->data[6] = (uuid->data[6] & 0x0F) | 0x70; /* Set variant (10) in bits 4-5 of byte 8, keep random bits 0-3 and 6-7 */ uuid->data[8] = (uuid->data[8] & 0x3F) | 0x80; } return uuid; } pg_uuid_t * ts_create_uuid_v7_from_timestamptz(TimestampTz ts, bool boundary) { int64 epoch_diff_us = ((int64) (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * USECS_PER_DAY); int64 unixtime_us = ts + epoch_diff_us; return ts_create_uuid_v7_from_unixtime_us(unixtime_us, boundary, true); } TS_FUNCTION_INFO_V1(ts_uuid_generate_v7); Datum ts_uuid_generate_v7(PG_FUNCTION_ARGS) { PG_RETURN_UUID_P(ts_create_uuid_v7_from_timestamptz(GetCurrentTimestamp(), false)); } TS_FUNCTION_INFO_V1(ts_uuid_v7_from_timestamptz); Datum ts_uuid_v7_from_timestamptz(PG_FUNCTION_ARGS) { TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); PG_RETURN_UUID_P(ts_create_uuid_v7_from_timestamptz(timestamp, false)); } TS_FUNCTION_INFO_V1(ts_uuid_v7_from_timestamptz_boundary); Datum ts_uuid_v7_from_timestamptz_boundary(PG_FUNCTION_ARGS) { TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(0); PG_RETURN_UUID_P(ts_create_uuid_v7_from_timestamptz(timestamp, true)); } #define UUID_VARIANT(uuid) ((uuid)->data[8] & 0xc0) #define IS_RFC9562_VARIANT(uuid) (UUID_VARIANT(uuid) == 0x80) #define UUID_VERSION(uuid) (((uuid)->data[6] & 0xf0) >> 4) /* * Extract the millisecond Unix epoch timestamp from the UUIDv7, with optional * extra sub-millisecond fraction in microseconds. */ bool ts_uuid_v7_extract_unixtime(const pg_uuid_t *uuid, uint64 *unixtime_ms, uint16 *extra_us) { bool is_uuidv7 = false; /* Check that the variant field corresponds to RFC9562 */ if (IS_RFC9562_VARIANT(uuid)) { /* Get the version from the UUID */ is_uuidv7 = (UUID_VERSION(uuid) == 7); } /* Big endian timestamp in milliseconds from Unix Epoch */ uint64 timestamp_be = 0; memcpy(×tamp_be, uuid->data, 6); /* The timestamp is now milliseconds from Unix Epoch (1970-01-01)*/ *unixtime_ms = (pg_ntoh64(timestamp_be)) >> 16; if (extra_us) { /* Optionally, get the sub ms part as microseconds, reversing the scaling */ *extra_us = (((uuid->data[6] & 0xF) << 8) | uuid->data[7]) * 1000 / (1 << 12); } return is_uuidv7; } TS_FUNCTION_INFO_V1(ts_timestamptz_from_uuid_v7); Datum ts_timestamptz_from_uuid_v7(PG_FUNCTION_ARGS) { pg_uuid_t *uuid = PG_GETARG_UUID_P(0); uint64 unixtime_millis = 0; if (!ts_uuid_v7_extract_unixtime(uuid, &unixtime_millis, NULL)) PG_RETURN_NULL(); /* Milliseconds timestamp from PG Epoch (2000-01-01) */ uint64 timestamp_millis = (unixtime_millis - ((uint64) (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY) * 1000ULL); /* Convert to microseconds */ TimestampTz ts = timestamp_millis * 1000; PG_RETURN_TIMESTAMPTZ(ts); } TS_FUNCTION_INFO_V1(ts_timestamptz_from_uuid_v7_with_microseconds); Datum ts_timestamptz_from_uuid_v7_with_microseconds(PG_FUNCTION_ARGS) { pg_uuid_t *uuid = PG_GETARG_UUID_P(0); uint64 unixtime_millis = 0; uint16 extra_micros = 0; if (!ts_uuid_v7_extract_unixtime(uuid, &unixtime_millis, &extra_micros)) PG_RETURN_NULL(); /* Milliseconds timestamp from PG Epoch (2000-01-01) */ uint64 timestamp_millis = (unixtime_millis - ((uint64) (POSTGRES_EPOCH_JDATE - UNIX_EPOCH_JDATE) * SECS_PER_DAY) * 1000ULL); /* Add up the whole to get microseconds */ TimestampTz ts = timestamp_millis * 1000 + extra_micros; PG_RETURN_TIMESTAMPTZ(ts); } TS_FUNCTION_INFO_V1(ts_uuid_version); Datum ts_uuid_version(PG_FUNCTION_ARGS) { pg_uuid_t *uuid = PG_GETARG_UUID_P(0); int version; /* Check that the variant field corresponds to RFC9562 */ if (!IS_RFC9562_VARIANT(uuid)) PG_RETURN_NULL(); version = UUID_VERSION(uuid); /* Get the version from the UUID */ PG_RETURN_INT32(version); } ��������������������������������������������������timescaledb-2.23.0/src/uuid.h�����������������������������������������������������������������������0000664�0000000�0000000�00000001176�15100345067�0015766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <utils/uuid.h> extern pg_uuid_t *ts_uuid_create(void); extern pg_uuid_t *ts_create_uuid_v7_from_unixtime_us(int64 unixtime_us, bool boundary, bool set_version); extern TSDLLEXPORT pg_uuid_t *ts_create_uuid_v7_from_timestamptz(TimestampTz ts, bool boundary); extern bool ts_uuid_v7_extract_unixtime(const pg_uuid_t *uuid, uint64 *unixtime_ms, uint16 *extra_us); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/version.c��������������������������������������������������������������������0000664�0000000�0000000�00000013722�15100345067�0016500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <string.h> #include <postgres.h> #include <access/htup_details.h> #include <fmgr.h> #include <funcapi.h> #include <storage/fd.h> #include <utils/builtins.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "annotations.h" #include "config.h" #include "gitcommit.h" #include "version.h" /* Export the strings to that we can read them using strings(1). We add a * prefix so that we can easily find it using grep(1). We only bother about * generating them if the relevant symbol is defined. */ #ifdef EXT_GIT_COMMIT_HASH static const char commit_hash[] TS_USED = "commit-hash:" EXT_GIT_COMMIT_HASH; #endif #ifdef EXT_GIT_COMMIT_TAG static const char commit_tag[] TS_USED = "commit-tag:" EXT_GIT_COMMIT_TAG; #endif #ifdef EXT_GIT_COMMIT_TIME static const char commit_time[] TS_USED = "commit-time:" EXT_GIT_COMMIT_TIME; #endif TS_FUNCTION_INFO_V1(ts_get_git_commit); /* Return git commit information defined in header file gitcommit.h. We * support that some of the fields are defined and will only show the fields * that are defined. If no fields are defined, we throw an error notifying the * user that there is no git information available at all. */ #if defined(EXT_GIT_COMMIT_HASH) || defined(EXT_GIT_COMMIT_TAG) || defined(EXT_GIT_COMMIT_TIME) Datum ts_get_git_commit(PG_FUNCTION_ARGS) { TupleDesc tupdesc; HeapTuple tuple; Datum values[3] = { 0 }; bool nulls[3] = { false }; /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); tupdesc = BlessTupleDesc(tupdesc); #ifdef EXT_GIT_COMMIT_TAG values[0] = CStringGetTextDatum(EXT_GIT_COMMIT_TAG); #else nulls[0] = true; #endif #ifdef EXT_GIT_COMMIT_HASH values[1] = CStringGetTextDatum(EXT_GIT_COMMIT_HASH); #else nulls[1] = true; #endif #ifdef EXT_GIT_COMMIT_TIME values[2] = DirectFunctionCall3(timestamptz_in, CStringGetDatum(EXT_GIT_COMMIT_TIME), Int32GetDatum(-1), Int32GetDatum(-1)); #else nulls[2] = true; #endif tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } #else Datum ts_get_git_commit(PG_FUNCTION_ARGS) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("extension not built with any Git commit information"))); } #endif #ifdef WIN32 #include <Windows.h> bool ts_version_get_os_info(VersionOSInfo *info) { DWORD bufsize; void *buffer; VS_FIXEDFILEINFO *vinfo = NULL; UINT vinfo_len = 0; memset(info, 0, sizeof(VersionOSInfo)); bufsize = GetFileVersionInfoSizeA(TEXT("kernel32.dll"), NULL); if (bufsize == 0) return false; buffer = palloc(bufsize); if (!GetFileVersionInfoA(TEXT("kernel32.dll"), 0, bufsize, buffer)) goto error; if (!VerQueryValueA(buffer, TEXT("\\"), &vinfo, &vinfo_len)) goto error; snprintf(info->sysname, VERSION_INFO_LEN - 1, "Windows"); snprintf(info->version, VERSION_INFO_LEN - 1, "%u", HIWORD(vinfo->dwProductVersionMS)); snprintf(info->release, VERSION_INFO_LEN - 1, "%u", LOWORD(vinfo->dwProductVersionMS)); pfree(buffer); return true; error: pfree(buffer); return false; } #elif defined(UNIX) #include <sys/utsname.h> #define OS_RELEASE_FILE "/etc/os-release" #define MAX_READ_LEN 1024 #define NAME_FIELD "PRETTY_NAME=\"" static bool get_pretty_version(char *pretty_version) { FILE *version_file; char *contents = palloc(MAX_READ_LEN); size_t bytes_read; bool got_pretty_version = false; int i; memset(pretty_version, '\0', VERSION_INFO_LEN); /* we cannot use pg_read_file because it doesn't allow absolute paths */ version_file = AllocateFile(OS_RELEASE_FILE, PG_BINARY_R); if (version_file == NULL) return false; fseeko(version_file, 0, SEEK_SET); bytes_read = fread(contents, 1, (size_t) MAX_READ_LEN, version_file); if (bytes_read <= 0) goto cleanup; if (bytes_read < MAX_READ_LEN) contents[bytes_read] = '\0'; else contents[MAX_READ_LEN - 1] = '\0'; contents = strstr(contents, NAME_FIELD); if (contents == NULL) goto cleanup; contents += sizeof(NAME_FIELD) - 1; for (i = 0; i < (VERSION_INFO_LEN - 1); i++) { char c = contents[i]; if (c == '\0' || c == '\n' || c == '\r' || c == '"') break; pretty_version[i] = c; } got_pretty_version = true; cleanup: FreeFile(version_file); return got_pretty_version; } bool ts_version_get_os_info(VersionOSInfo *info) { /* Get the OS name */ struct utsname os_info; uname(&os_info); memset(info, 0, sizeof(VersionOSInfo)); strncpy(info->sysname, os_info.sysname, VERSION_INFO_LEN - 1); strncpy(info->version, os_info.version, VERSION_INFO_LEN - 1); strncpy(info->release, os_info.release, VERSION_INFO_LEN - 1); info->has_pretty_version = get_pretty_version(info->pretty_version); return true; } #else bool ts_version_get_os_info(VersionOSInfo *info) { memset(info, 0, sizeof(VersionOSInfo)); return false; } #endif /* WIN32 */ TS_FUNCTION_INFO_V1(ts_get_os_info); Datum ts_get_os_info(PG_FUNCTION_ARGS) { TupleDesc tupdesc; Datum values[4]; bool nulls[4] = { false }; HeapTuple tuple; VersionOSInfo info; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); if (ts_version_get_os_info(&info)) { values[0] = CStringGetTextDatum(info.sysname); values[1] = CStringGetTextDatum(info.version); values[2] = CStringGetTextDatum(info.release); if (info.has_pretty_version) values[3] = CStringGetTextDatum(info.pretty_version); else nulls[3] = true; } else memset(nulls, true, sizeof(nulls)); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } ����������������������������������������������timescaledb-2.23.0/src/version.h��������������������������������������������������������������������0000664�0000000�0000000�00000001017�15100345067�0016477�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #define VERSION_INFO_LEN 128 typedef struct VersionOSInfo { char sysname[VERSION_INFO_LEN]; char version[VERSION_INFO_LEN]; char release[VERSION_INFO_LEN]; char pretty_version[VERSION_INFO_LEN]; bool has_pretty_version; } VersionOSInfo; extern bool ts_version_get_os_info(VersionOSInfo *info); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017151�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/CMakeLists.txt���������������������������������������������������0000664�0000000�0000000�00000000462�15100345067�0021713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/alter_table_with_clause.c ${CMAKE_CURRENT_SOURCE_DIR}/create_table_with_clause.c ${CMAKE_CURRENT_SOURCE_DIR}/create_materialized_view_with_clause.c ${CMAKE_CURRENT_SOURCE_DIR}/with_clause_parser.c) target_sources(${PROJECT_NAME} PRIVATE ${SOURCES}) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/alter_table_with_clause.c����������������������������������������0000664�0000000�0000000�00000047444�15100345067�0024177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/dependency.h> #include <catalog/namespace.h> #include <catalog/pg_trigger.h> #include <catalog/pg_type.h> #include <commands/trigger.h> #include <fmgr.h> #include <parser/parser.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/lsyscache.h> #include <utils/typcache.h> #include "compat/compat.h" #include "cross_module_fn.h" #include "debug_assert.h" #include "guc.h" #include "jsonb_utils.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/compression_settings.h" #include "alter_table_with_clause.h" static const WithClauseDefinition alter_table_with_clause_def[] = { [AlterTableFlagChunkTimeInterval] = { .arg_names = {"chunk_interval", NULL}, .type_id = TEXTOID, }, [AlterTableFlagColumnstore] = { .arg_names = {"compress", "columnstore", "enable_columnstore", NULL}, .type_id = BOOLOID, .default_val = (Datum)false, }, [AlterTableFlagSegmentBy] = { .arg_names = {"compress_segmentby", "segmentby", "segment_by", NULL}, .type_id = TEXTOID, }, [AlterTableFlagOrderBy] = { .arg_names = {"compress_orderby", "orderby", "order_by", NULL}, .type_id = TEXTOID, }, [AlterTableFlagCompressChunkTimeInterval] = { .arg_names = {"compress_chunk_interval", "compress_chunk_time_interval", NULL}, .type_id = INTERVALOID, }, [AlterTableFlagIndex] = { .arg_names = {"compress_index", "compress_sparse_index", "index", "sparse_index", NULL}, .type_id = TEXTOID, }, }; static const WithClauseDefinition sparse_index_with_clause_def[] = { [_SparseIndexTypeEnumBloom] = { .arg_names = {"compress_bloom", "bloom", NULL}, .type_id = TEXTOID, }, [_SparseIndexTypeEnumMinmax] = { .arg_names = {"compress_minmax", "minmax", "compress_min_max", "min_max", NULL}, .type_id = TEXTOID, }, }; WithClauseResult * ts_alter_table_with_clause_parse(const List *defelems) { return ts_with_clauses_parse(defelems, alter_table_with_clause_def, TS_ARRAY_LEN(alter_table_with_clause_def)); } WithClauseResult * ts_alter_table_reset_with_clause_parse(const List *defelems) { return ts_with_clauses_parse_reset(defelems, alter_table_with_clause_def, TS_ARRAY_LEN(alter_table_with_clause_def)); } static inline void throw_segment_by_error(char *segment_by) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unable to parse segmenting option \"%s\"", segment_by), errhint("The option timescaledb.compress_segmentby must" " be a set of columns separated by commas."))); } static bool select_stmt_as_expected(SelectStmt *stmt) { /* The only parts of the select stmt that are allowed to be set are the order by or group by. * Check that no other fields are set */ if (stmt->distinctClause != NIL || stmt->intoClause != NULL || stmt->targetList != NIL || stmt->whereClause != NULL || stmt->havingClause != NULL || stmt->windowClause != NIL || stmt->valuesLists != NULL || stmt->limitOffset != NULL || stmt->limitCount != NULL || stmt->lockingClause != NIL || stmt->withClause != NULL || stmt->op != 0 || stmt->all != false || stmt->larg != NULL || stmt->rarg != NULL) return false; return true; } static ArrayType * parse_segment_collist(char *inpstr, Hypertable *hypertable) { StringInfoData buf; List *parsed; ListCell *lc; SelectStmt *select; RawStmt *raw; /* segmentby can have empty array */ if (strlen(inpstr) == 0) return ts_array_add_element_text(NULL, NULL); initStringInfo(&buf); /* parse the segment by list exactly how you would a group by */ appendStringInfo(&buf, "SELECT FROM %s.%s GROUP BY %s", quote_identifier(NameStr(hypertable->fd.schema_name)), quote_identifier(NameStr(hypertable->fd.table_name)), inpstr); const MemoryContext oldcontext = CurrentMemoryContext; PG_TRY(); { parsed = raw_parser(buf.data, RAW_PARSE_DEFAULT); } PG_CATCH(); { /* We do this fandango to avoid exhausting the error stack if we get * anything else but a syntax error, for example, an out of memory * error. */ ErrorData *edata; MemoryContextSwitchTo(oldcontext); edata = CopyErrorData(); FlushErrorState(); if (edata->sqlerrcode == ERRCODE_SYNTAX_ERROR) { edata->cursorpos = edata->internalpos = 0; edata->detail = edata->message; edata->message = psprintf("unable to parse segmenting option \"%s\"", inpstr); edata->hint = psprintf("The option timescaledb.compress_segmentby must be a set of " "columns separated by commas."); } ReThrowError(edata); } PG_END_TRY(); if (list_length(parsed) != 1) throw_segment_by_error(inpstr); if (!IsA(linitial(parsed), RawStmt)) throw_segment_by_error(inpstr); raw = linitial(parsed); if (!IsA(raw->stmt, SelectStmt)) throw_segment_by_error(inpstr); select = (SelectStmt *) raw->stmt; if (!select_stmt_as_expected(select)) throw_segment_by_error(inpstr); if (select->sortClause != NIL) throw_segment_by_error(inpstr); ArrayType *segmentby = NULL; foreach (lc, select->groupClause) { if (!IsA(lfirst(lc), ColumnRef)) throw_segment_by_error(inpstr); ColumnRef *cf = lfirst(lc); if (list_length(cf->fields) != 1) throw_segment_by_error(inpstr); if (!IsA(linitial(cf->fields), String)) throw_segment_by_error(inpstr); char *colname = strVal(linitial(cf->fields)); AttrNumber col_attno = get_attnum(hypertable->main_table_relid, colname); if (col_attno == InvalidAttrNumber) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("column \"%s\" does not exist", colname), errhint("The timescaledb.compress_segmentby option must reference a valid " "column."))); } /* get normalized column name */ colname = get_attname(hypertable->main_table_relid, col_attno, false); /* check if segmentby columns are distinct. */ if (ts_array_is_member(segmentby, colname)) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("duplicate column name \"%s\"", colname), errhint("The timescaledb.compress_segmentby option must reference distinct " "column."))); segmentby = ts_array_add_element_text(segmentby, pstrdup(colname)); } return segmentby; } static inline void throw_order_by_error(char *order_by) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unable to parse ordering option \"%s\"", order_by), errhint("The timescaledb.compress_orderby option must be a set of column" " names with sort options, separated by commas." " It is the same format as an ORDER BY clause."))); } /* compress_orderby is parsed same as order by in select queries */ OrderBySettings ts_compress_parse_order_collist(char *inpstr, Hypertable *hypertable) { StringInfoData buf; List *parsed; ListCell *lc; SelectStmt *select; RawStmt *raw; OrderBySettings settings = { 0 }; if (strlen(inpstr) == 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("ordering column can not be empty"), errhint("timescaledb.compress_orderby option must reference a valid " "column or be removed to use default settings."))); initStringInfo(&buf); /* parse the segment by list exactly how you would a order by by */ appendStringInfo(&buf, "SELECT FROM %s.%s ORDER BY %s", quote_identifier(NameStr(hypertable->fd.schema_name)), quote_identifier(NameStr(hypertable->fd.table_name)), inpstr); const MemoryContext oldcontext = CurrentMemoryContext; PG_TRY(); { parsed = raw_parser(buf.data, RAW_PARSE_DEFAULT); } PG_CATCH(); { /* We do this fandango to avoid exhausting the error stack if we get * anything else but a syntax error, for example, an out of memory * error. */ ErrorData *edata; MemoryContextSwitchTo(oldcontext); edata = CopyErrorData(); FlushErrorState(); if (edata->sqlerrcode == ERRCODE_SYNTAX_ERROR) { edata->cursorpos = edata->internalpos = 0; edata->detail = edata->message; edata->message = psprintf("unable to parse ordering option \"%s\"", inpstr); edata->hint = psprintf("The timescaledb.compress_orderby option must be a set of column" " names with sort options, separated by commas." " It is the same format as an ORDER BY clause."); } ReThrowError(edata); } PG_END_TRY(); if (list_length(parsed) != 1) throw_order_by_error(inpstr); if (!IsA(linitial(parsed), RawStmt)) throw_order_by_error(inpstr); raw = linitial(parsed); if (!IsA(raw->stmt, SelectStmt)) throw_order_by_error(inpstr); select = (SelectStmt *) raw->stmt; if (!select_stmt_as_expected(select)) throw_order_by_error(inpstr); if (select->groupClause != NIL) throw_order_by_error(inpstr); foreach (lc, select->sortClause) { SortBy *sort_by; ColumnRef *cf; CompressedParsedCol *col = (CompressedParsedCol *) palloc(sizeof(*col)); bool desc, nullsfirst; if (!IsA(lfirst(lc), SortBy)) throw_order_by_error(inpstr); sort_by = lfirst(lc); if (!IsA(sort_by->node, ColumnRef)) throw_order_by_error(inpstr); cf = (ColumnRef *) sort_by->node; if (list_length(cf->fields) != 1) throw_order_by_error(inpstr); if (!IsA(linitial(cf->fields), String)) throw_order_by_error(inpstr); namestrcpy(&col->colname, strVal(linitial(cf->fields))); char *colname = strVal(linitial(cf->fields)); AttrNumber col_attno = get_attnum(hypertable->main_table_relid, colname); if (col_attno == InvalidAttrNumber) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("column \"%s\" does not exist", NameStr(col->colname)), errhint("The timescaledb.compress_orderby option must reference a valid " "column."))); Oid col_type = get_atttype(hypertable->main_table_relid, col_attno); TypeCacheEntry *type = lookup_type_cache(col_type, TYPECACHE_LT_OPR); if (!OidIsValid(type->lt_opr)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid ordering column type %s", format_type_be(col_type)), errdetail("Could not identify a less-than operator for the type."))); /* get normalized column name */ colname = get_attname(hypertable->main_table_relid, col_attno, false); /* check if orderby columns are distinct. */ if (ts_array_is_member(settings.orderby, colname)) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("duplicate column name \"%s\"", colname), errhint("The timescaledb.compress_orderby option must reference distinct " "column."))); if (sort_by->sortby_dir != SORTBY_ASC && sort_by->sortby_dir != SORTBY_DESC && sort_by->sortby_dir != SORTBY_DEFAULT) throw_order_by_error(inpstr); desc = sort_by->sortby_dir == SORTBY_DESC; if (sort_by->sortby_nulls == SORTBY_NULLS_DEFAULT) { /* default null ordering is LAST for ASC, FIRST for DESC */ nullsfirst = desc; } else { nullsfirst = sort_by->sortby_nulls == SORTBY_NULLS_FIRST; } settings.orderby = ts_array_add_element_text(settings.orderby, pstrdup(colname)); settings.orderby_desc = ts_array_add_element_bool(settings.orderby_desc, desc); settings.orderby_nullsfirst = ts_array_add_element_bool(settings.orderby_nullsfirst, nullsfirst); } Ensure(settings.orderby, "orderby setting is NULL after parsing"); return settings; } static inline void throw_sparse_index_error(char *sparse_index) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unable to parse sparse index option \"%s\"", sparse_index))); } static SparseIndexTypeEnum sparse_index_type_with_clause_parse(const char *parse, const WithClauseDefinition *args, int nargs) { Assert((int) _SparseIndexTypeEnumMax == nargs); int i; for (i = 0; i < nargs; i++) { for (int j = 0; args[i].arg_names[j] != NULL; ++j) { if (pg_strcasecmp(parse, args[i].arg_names[j]) == 0) { return (SparseIndexTypeEnum) i; } } } ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized sparse index type \"%s\"", parse))); return _SparseIndexTypeEnumMax; } static void parse_sparse_index_config(JsonbParseState *parse_state, FuncCall *sparse_index_details, Hypertable *hypertable, ArrayType **collist) { Oid coltypid; char *colname; AttrNumber col_attno; TypeCacheEntry *type_cache; /* extract type */ SparseIndexConfig config; config.base.type = sparse_index_type_with_clause_parse(NameListToString(sparse_index_details->funcname), sparse_index_with_clause_def, TS_ARRAY_LEN(sparse_index_with_clause_def)); config.base.source = _SparseIndexSourceEnumConfig; if (list_length(sparse_index_details->args) != 1) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("sparse index \"%s\" can only have one column", ts_sparse_index_type_names[config.base.type]))); } /* validate and extract column */ Node *arg = list_nth(sparse_index_details->args, 0); if (!IsA(arg, ColumnRef)) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("sparse index %s's first option must reference a valid " "column.", ts_sparse_index_type_names[config.base.type]))); ColumnRef *cf = (ColumnRef *) arg; if (list_length(cf->fields) != 1 || !IsA(linitial(cf->fields), String)) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("invalid sparse index column reference syntax"), errdetail( "Wildcard or qualified references like '*' or 'table.col' are not allowed."))); colname = strVal(linitial(cf->fields)); col_attno = get_attnum(hypertable->main_table_relid, colname); if (col_attno == InvalidAttrNumber) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("column \"%s\" does not exist", colname), errhint("The sparse index %s option must reference a valid " "column.", ts_sparse_index_type_names[config.base.type]))); } /* get normalized column name */ colname = get_attname(hypertable->main_table_relid, col_attno, false); coltypid = get_atttype(hypertable->main_table_relid, col_attno); /* * Note: currently only one sparse index per column is supported. */ if (ts_array_is_member(*collist, colname)) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("duplicate column name \"%s\"", colname), errhint("The sparse index option must reference distinct " "column."))); *collist = ts_array_add_element_text(*collist, pstrdup(colname)); /* extract custom sparse index type config */ switch (config.base.type) { case _SparseIndexTypeEnumBloom: if (!ts_guc_enable_sparse_index_bloom) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("Creating bloom sparse index is disabled"), errhint("Either set \"enable_sparse_index_bloom\" to true or remove the " "bloom filter indexes from \"sparse_index\" configuration of the " "hypertable."))); } /* * The column type must be hashable. For some types we use our own hash functions * which have better characteristics. */ FmgrInfo *finfo = NULL; if (ts_cm_functions->bloom1_get_hash_function(coltypid, &finfo) == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid bloom filter column type %s", format_type_be(coltypid)), errdetail("Could not identify a hashing function for the type."))); config.base.col = colname; break; case _SparseIndexTypeEnumMinmax: type_cache = lookup_type_cache(coltypid, TYPECACHE_LT_OPR); /* * a comparison operator is required for min max operations */ if (!OidIsValid(type_cache->lt_opr)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid minmax column type %s", format_type_be(coltypid)), errdetail("Could not identify a less-than operator for the type."))); config.base.col = colname; break; default: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("Invalid sparse index type"))); } ts_convert_sparse_index_config_to_jsonb(parse_state, &config); } static Jsonb * parse_sparse_index_config_list(char *inpstr, Hypertable *hypertable) { StringInfoData buf; List *parsed; ListCell *lc; SelectStmt *select; RawStmt *raw; JsonbParseState *parse_state = NULL; /* sparse index can have empty input. Return [{"source":"config"}] jsonb */ if (strlen(inpstr) == 0) { pushJsonbValue(&parse_state, WJB_BEGIN_ARRAY, NULL); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_str(parse_state, ts_sparse_index_common_keys[SparseIndexKeySource], ts_sparse_index_source_names[_SparseIndexSourceEnumConfig]); /* source */ JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL)); return JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_ARRAY, NULL)); } initStringInfo(&buf); /* parse the sparse index list exactly how you would targetlist */ appendStringInfo(&buf, "SELECT %s", inpstr); const MemoryContext oldcontext = CurrentMemoryContext; PG_TRY(); { parsed = raw_parser(buf.data, RAW_PARSE_DEFAULT); } PG_CATCH(); { /* We do this fandango to avoid exhausting the error stack if we get * anything else but a syntax error, for example, an out of memory * error. */ ErrorData *edata; MemoryContextSwitchTo(oldcontext); edata = CopyErrorData(); FlushErrorState(); if (edata->sqlerrcode == ERRCODE_SYNTAX_ERROR) { edata->cursorpos = edata->internalpos = 0; edata->detail = edata->message; edata->message = psprintf("unable to parse sparse index option \"%s\"", inpstr); } ReThrowError(edata); } PG_END_TRY(); if (list_length(parsed) != 1) throw_sparse_index_error(inpstr); if (!IsA(linitial(parsed), RawStmt)) throw_sparse_index_error(inpstr); raw = linitial(parsed); if (!IsA(raw->stmt, SelectStmt)) throw_sparse_index_error(inpstr); select = (SelectStmt *) raw->stmt; if (select->targetList == NULL) throw_sparse_index_error(inpstr); /* json format will be * [{"type": "bloom", "source":"config", "column": "u"}, * {"type": "minmax","source":"config", "column": "ts"}] */ pushJsonbValue(&parse_state, WJB_BEGIN_ARRAY, NULL); ArrayType *collist = NULL; foreach (lc, select->targetList) { ResTarget *target = lfirst_node(ResTarget, lc); if (!IsA(target->val, FuncCall)) throw_sparse_index_error(inpstr); FuncCall *fc = (FuncCall *) target->val; parse_sparse_index_config(parse_state, fc, hypertable, &collist); } pfree(collist); return JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_ARRAY, NULL)); } /* returns List of CompressedParsedCol * compress_segmentby = `col1,col2,col3` */ ArrayType * ts_compress_hypertable_parse_segment_by(WithClauseResult segmentby, Hypertable *hypertable) { if (!segmentby.is_default) { return parse_segment_collist(TextDatumGetCString(segmentby.parsed), hypertable); } else return NULL; } /* returns List of CompressedParsedCol * E.g. timescaledb.compress_orderby = 'col1 asc nulls first,col2 desc,col3' */ OrderBySettings ts_compress_hypertable_parse_order_by(WithClauseResult orderby, Hypertable *hypertable) { Ensure(!orderby.is_default, "with clause is not default"); return ts_compress_parse_order_collist(TextDatumGetCString(orderby.parsed), hypertable); } /* returns List of CompressedParsedCol * E.g. timescaledb.compress_orderby = 'col1 asc nulls first,col2 desc,col3' */ Interval * ts_compress_hypertable_parse_chunk_time_interval(WithClauseResult *parsed_options, Hypertable *hypertable) { if (parsed_options[AlterTableFlagCompressChunkTimeInterval].is_default == false) { Datum textarg = parsed_options[AlterTableFlagCompressChunkTimeInterval].parsed; return DatumGetIntervalP(textarg); } else return NULL; } /* returns List of CompressedParsedCol * compress_minmax = `col1,col2,col3` */ Jsonb * ts_compress_hypertable_parse_index(WithClauseResult index, Hypertable *hypertable) { if (!index.is_default) { return parse_sparse_index_config_list(TextDatumGetCString(index.parsed), hypertable); } else return NULL; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/alter_table_with_clause.h����������������������������������������0000664�0000000�0000000�00000003214�15100345067�0024167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <catalog/pg_type.h> #include "chunk.h" #include "ts_catalog/catalog.h" #include "with_clause_parser.h" typedef enum AlterTableFlags { AlterTableFlagChunkTimeInterval = 0, AlterTableFlagColumnstore, AlterTableFlagSegmentBy, AlterTableFlagOrderBy, AlterTableFlagCompressChunkTimeInterval, AlterTableFlagIndex, AlterTableFlagsMax } AlterTableFlags; typedef struct { NameData colname; bool nullsfirst; bool desc; } CompressedParsedCol; typedef struct { ArrayType *orderby; ArrayType *orderby_desc; ArrayType *orderby_nullsfirst; } OrderBySettings; extern TSDLLEXPORT WithClauseResult *ts_alter_table_with_clause_parse(const List *defelems); extern TSDLLEXPORT WithClauseResult *ts_alter_table_reset_with_clause_parse(const List *defelems); extern TSDLLEXPORT ArrayType *ts_compress_hypertable_parse_segment_by(WithClauseResult segmentby, Hypertable *hypertable); extern TSDLLEXPORT OrderBySettings ts_compress_hypertable_parse_order_by(WithClauseResult orderby, Hypertable *hypertable); extern TSDLLEXPORT Interval * ts_compress_hypertable_parse_chunk_time_interval(WithClauseResult *parsed_options, Hypertable *hypertable); extern TSDLLEXPORT OrderBySettings ts_compress_parse_order_collist(char *inpstr, Hypertable *hypertable); extern TSDLLEXPORT Jsonb *ts_compress_hypertable_parse_index(WithClauseResult index, Hypertable *hypertable); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/create_materialized_view_with_clause.c���������������������������0000664�0000000�0000000�00000006773�15100345067�0026750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <nodes/makefuncs.h> #include "compat/compat.h" #include "alter_table_with_clause.h" #include "create_materialized_view_with_clause.h" #include "cross_module_fn.h" #include "ts_catalog/continuous_agg.h" #include "with_clause_parser.h" static const WithClauseDefinition continuous_aggregate_with_clause_def[] = { [CreateMaterializedViewFlagContinuous] = { .arg_names = {"continuous", NULL}, .type_id = BOOLOID, .default_val = (Datum)false, }, [CreateMaterializedViewFlagCreateGroupIndexes] = { .arg_names = {"create_group_indexes", NULL}, .type_id = BOOLOID, .default_val = (Datum)true, }, [CreateMaterializedViewFlagMaterializedOnly] = { .arg_names = {"materialized_only", NULL}, .type_id = BOOLOID, .default_val = (Datum)true, }, [CreateMaterializedViewFlagColumnstore] = { .arg_names = {"columnstore", "enable_columnstore", "compress", NULL}, .type_id = BOOLOID, }, [CreateMaterializedViewFlagFinalized] = { .arg_names = {"finalized", NULL}, .type_id = BOOLOID, .default_val = (Datum)true, }, [CreateMaterializedViewFlagChunkTimeInterval] = { .arg_names = {"chunk_interval", NULL}, .type_id = INTERVALOID, }, [CreateMaterializedViewFlagSegmentBy] = { .arg_names = {"segmentby", "segment_by", "compress_segmentby", NULL}, .type_id = TEXTOID, }, [CreateMaterializedViewFlagOrderBy] = { .arg_names = {"orderby", "order_by", "compress_orderby", NULL}, .type_id = TEXTOID, }, [CreateMaterializedViewFlagCompressChunkTimeInterval] = { .arg_names = {"compress_chunk_interval", "compress_chunk_time_interval", NULL}, .type_id = INTERVALOID, }, }; WithClauseResult * ts_create_materialized_view_with_clause_parse(const List *defelems) { return ts_with_clauses_parse(defelems, continuous_aggregate_with_clause_def, TS_ARRAY_LEN(continuous_aggregate_with_clause_def)); } List * ts_continuous_agg_get_compression_defelems(const WithClauseResult *with_clauses) { List *ret = NIL; for (int i = 0; i < AlterTableFlagsMax; i++) { int option_index = 0; switch (i) { case AlterTableFlagChunkTimeInterval: case AlterTableFlagIndex: continue; break; case AlterTableFlagColumnstore: option_index = CreateMaterializedViewFlagColumnstore; break; case AlterTableFlagSegmentBy: option_index = CreateMaterializedViewFlagSegmentBy; break; case AlterTableFlagOrderBy: option_index = CreateMaterializedViewFlagOrderBy; break; case AlterTableFlagCompressChunkTimeInterval: option_index = CreateMaterializedViewFlagCompressChunkTimeInterval; break; default: elog(ERROR, "Unhandled compression option"); break; } const WithClauseResult *input = &with_clauses[option_index]; WithClauseDefinition def = continuous_aggregate_with_clause_def[option_index]; if (!input->is_default) { Node *value = (Node *) makeString(ts_with_clause_result_deparse_value(input)); DefElem *elem = makeDefElemExtended(EXTENSION_NAMESPACE, (char *) def.arg_names[0], value, DEFELEM_UNSPEC, -1); ret = lappend(ret, elem); } } return ret; } �����timescaledb-2.23.0/src/with_clause/create_materialized_view_with_clause.h���������������������������0000664�0000000�0000000�00000001651�15100345067�0026743�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "with_clause_parser.h" typedef enum CreateMaterializedViewFlags { CreateMaterializedViewFlagContinuous = 0, CreateMaterializedViewFlagCreateGroupIndexes, CreateMaterializedViewFlagMaterializedOnly, CreateMaterializedViewFlagColumnstore, CreateMaterializedViewFlagFinalized, CreateMaterializedViewFlagChunkTimeInterval, CreateMaterializedViewFlagSegmentBy, CreateMaterializedViewFlagOrderBy, CreateMaterializedViewFlagCompressChunkTimeInterval, } CreateMaterializedViewFlags; extern TSDLLEXPORT WithClauseResult * ts_create_materialized_view_with_clause_parse(const List *defelems); extern TSDLLEXPORT List * ts_continuous_agg_get_compression_defelems(const WithClauseResult *with_clauses); ���������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/create_table_with_clause.c���������������������������������������0000664�0000000�0000000�00000005414�15100345067�0024322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <fmgr.h> #include "compat/compat.h" #include "create_table_with_clause.h" #include "with_clause_parser.h" static const WithClauseDefinition create_table_with_clauses_def[] = { [CreateTableFlagHypertable] = {.arg_names = {"hypertable", NULL}, .type_id = BOOLOID,}, [CreateTableFlagColumnstore] = {.arg_names = {"columnstore", "enable_columnstore", "compress", NULL}, .type_id = BOOLOID, .default_val = (Datum)true,}, [CreateTableFlagTimeColumn] = {.arg_names = {"partition_column", "partitioning_column", NULL}, .type_id = TEXTOID,}, [CreateTableFlagChunkTimeInterval] = {.arg_names = {"chunk_interval", NULL}, .type_id = TEXTOID,}, [CreateTableFlagCreateDefaultIndexes] = {.arg_names = {"create_default_indexes", NULL}, .type_id = BOOLOID, .default_val = (Datum) true,}, [CreateTableFlagAssociatedSchema] = {.arg_names = {"associated_schema", NULL}, .type_id = TEXTOID,}, [CreateTableFlagAssociatedTablePrefix] = {.arg_names = {"associated_table_prefix", NULL}, .type_id = TEXTOID,}, [CreateTableFlagSegmentBy] = { .arg_names = {"segmentby", "segment_by", "compress_segmentby", NULL}, .type_id = TEXTOID,}, [CreateTableFlagOrderBy] = { .arg_names = {"orderby", "order_by", "compress_orderby", NULL}, .type_id = TEXTOID,}, [CreateTableFlagIndex] = { .arg_names = {"compress_index", "compress_sparse_index", "index", "sparse_index", NULL}, .type_id = TEXTOID,}, }; WithClauseResult * ts_create_table_with_clause_parse(const List *defelems) { return ts_with_clauses_parse(defelems, create_table_with_clauses_def, TS_ARRAY_LEN(create_table_with_clauses_def)); } Datum ts_create_table_parse_chunk_time_interval(WithClauseResult option, Oid column_type, Oid *interval_type) { if (option.is_default == false) { Datum textarg = option.parsed; switch (column_type) { case INT2OID: { *interval_type = INT2OID; return DirectFunctionCall1(int2in, CStringGetDatum(TextDatumGetCString(textarg))); } case INT4OID: { *interval_type = INT4OID; return DirectFunctionCall1(int4in, CStringGetDatum(TextDatumGetCString(textarg))); } case INT8OID: { *interval_type = INT8OID; return DirectFunctionCall1(int8in, CStringGetDatum(TextDatumGetCString(textarg))); } case TIMESTAMPOID: case TIMESTAMPTZOID: case DATEOID: case UUIDOID: { *interval_type = INTERVALOID; return DirectFunctionCall3(interval_in, CStringGetDatum(TextDatumGetCString(textarg)), InvalidOid, -1); } } } *interval_type = InvalidOid; return UnassignedDatum; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/create_table_with_clause.h���������������������������������������0000664�0000000�0000000�00000001464�15100345067�0024330�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include "with_clause_parser.h" typedef enum CreateTableFlags { CreateTableFlagHypertable = 0, CreateTableFlagColumnstore, CreateTableFlagTimeColumn, CreateTableFlagChunkTimeInterval, CreateTableFlagCreateDefaultIndexes, CreateTableFlagAssociatedSchema, CreateTableFlagAssociatedTablePrefix, CreateTableFlagOrderBy, CreateTableFlagSegmentBy, CreateTableFlagIndex } CreateTableFlags; WithClauseResult *ts_create_table_with_clause_parse(const List *defelems); Datum ts_create_table_parse_chunk_time_interval(WithClauseResult option, Oid column_type, Oid *interval_type); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/with_clause_parser.c���������������������������������������������0000664�0000000�0000000�00000017460�15100345067�0023210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <commands/defrem.h> #include <nodes/parsenodes.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include "debug_assert.h" #include "extension_constants.h" #include "with_clause_parser.h" /* * Filter a list of DefElem based on a namespace. * This function will iterate through DefElem and output up to two lists: * within_namespace: every element within the namespace * not_within_namespace: all the other elements * * That is, given a with clause like: * WITH (foo.foo_para, bar.bar_param, baz.baz_param) * * ts_with_clause_filter(elems, "foo", in, not_in) will have * in = foo.foo_para * not_in = bar.bar_param, baz.baz_param */ void ts_with_clause_filter(const List *def_elems, List **within_namespace, List **not_within_namespace) { ListCell *cell; foreach (cell, def_elems) { DefElem *def = (DefElem *) lfirst(cell); if (def->defnamespace != NULL && (pg_strcasecmp(def->defnamespace, EXTENSION_NAMESPACE) == 0 || pg_strcasecmp(def->defnamespace, EXTENSION_NAMESPACE_ALIAS) == 0)) { if (within_namespace != NULL) *within_namespace = lappend(*within_namespace, def); } else if (not_within_namespace != NULL) { *not_within_namespace = lappend(*not_within_namespace, def); } } } static Datum parse_arg(WithClauseDefinition arg, DefElem *def); static char * ts_with_clause_definition_names(const WithClauseDefinition *args, Size nargs) { StringInfoData buf; Size i; initStringInfo(&buf); for (i = 0; i < nargs; i++) { if (i > 0) appendStringInfoString(&buf, ", "); appendStringInfoString(&buf, args[i].arg_names[0]); } return buf.data; } /* * Deserialize and apply the values in a WITH clause based on the on_arg table. * * This function will go through every element in def_elems and search for a * corresponding argument in args, if one is found it will attempt to deserialize * the argument, using that table elements deserialize function, then apply it * to state. * * This is used to turn the list into a form more useful for our internal * functions */ WithClauseResult * ts_with_clauses_parse(const List *def_elems, const WithClauseDefinition *args, Size nargs) { ListCell *cell; WithClauseResult *results = palloc0(sizeof(*results) * nargs); Size i; for (i = 0; i < nargs; i++) { results[i].definition = &args[i]; results[i].parsed = args[i].default_val; results[i].is_default = true; } foreach (cell, def_elems) { DefElem *def = (DefElem *) lfirst(cell); bool argument_recognized = false; for (i = 0; i < nargs; i++) { for (int j = 0; args[i].arg_names[j] != NULL; ++j) { if (pg_strcasecmp(def->defname, args[i].arg_names[j]) == 0) { argument_recognized = true; if (!results[i].is_default) ereport(ERROR, (errcode(ERRCODE_AMBIGUOUS_PARAMETER), errmsg("duplicate parameter \"%s.%s\"", def->defnamespace, def->defname))); results[i].parsed = parse_arg(args[i], def); results[i].is_default = false; break; } } } if (!argument_recognized) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized parameter \"%s.%s\"", def->defnamespace, def->defname), errhint("Valid timescaledb parameters are: %s", ts_with_clause_definition_names(args, nargs)))); } return results; } /* * This function handles parsing of WITH clauses for ALTER TABLE RESET. * Unlike ts_with_clauses_parse, it does not parse any option values, * as RESET clauses only include option names without associated values. */ WithClauseResult * ts_with_clauses_parse_reset(const List *def_elems, const WithClauseDefinition *args, Size nargs) { ListCell *cell; WithClauseResult *results = palloc0(sizeof(*results) * nargs); Size i; for (i = 0; i < nargs; i++) { results[i].definition = &args[i]; results[i].parsed = args[i].default_val; results[i].is_default = true; } foreach (cell, def_elems) { DefElem *def = (DefElem *) lfirst(cell); bool argument_recognized = false; for (i = 0; i < nargs; i++) { for (int j = 0; args[i].arg_names[j] != NULL; ++j) { if (pg_strcasecmp(def->defname, args[i].arg_names[j]) == 0) { argument_recognized = true; if (!results[i].is_default) ereport(ERROR, (errcode(ERRCODE_AMBIGUOUS_PARAMETER), errmsg("duplicate parameter \"%s.%s\"", def->defnamespace, def->defname))); results[i].is_default = false; break; } } } if (!argument_recognized) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized parameter \"%s.%s\"", def->defnamespace, def->defname), errhint("Valid timescaledb parameters are: %s", ts_with_clause_definition_names(args, nargs)))); } return results; } extern TSDLLEXPORT char * ts_with_clause_result_deparse_value(const WithClauseResult *result) { Ensure(OidIsValid(result->definition->type_id), "argument \"%d\" has invalid OID", result->definition->type_id); return ts_datum_to_string(result->parsed, result->definition->type_id); } static Datum parse_arg(WithClauseDefinition arg, DefElem *def) { char *value; Datum val; Oid in_fn; Oid typIOParam; if (!OidIsValid(arg.type_id)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_PARAMETER), errmsg("argument \"%s.%s\" not implemented", def->defnamespace, def->defname))); if (def->arg != NULL) value = defGetString(def); else if (arg.type_id == BOOLOID) /* for booleans, postgres defines the option timescale.foo to be the same as * timescaledb.foo='true' so if no value is found set it to "true" here */ value = "true"; else ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("parameter \"%s.%s\" must have a value", def->defnamespace, def->defname))); getTypeInputInfo(arg.type_id, &in_fn, &typIOParam); Assert(OidIsValid(in_fn)); /* * We could use InputFunctionCallSafe() here but this is just supported * for PG16 and later, so we opt for checking if the failure is what we * expected and re-throwing the error otherwise. */ PG_TRY(); { val = OidInputFunctionCall(in_fn, value, typIOParam, -1); } PG_CATCH(); { const int sqlerrcode = geterrcode(); /* * We can deal with the Data Exception category and in the Syntax * Error or Access Rule Violation category, but if the error is an * insufficient resources category, for example, an out of memory * error, we should just re-throw it. * * Errors in other categories are unlikely, but we cannot do anything * with them anyway, so just re-throw them as well. */ if (ERRCODE_TO_CATEGORY(sqlerrcode) != ERRCODE_DATA_EXCEPTION && ERRCODE_TO_CATEGORY(sqlerrcode) != ERRCODE_SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION) { PG_RE_THROW(); } FlushErrorState(); /* We are currently using the ErrorContext, but since we are going to * raise an error later, there is no reason to switch memory context * nor restore the resource owner here. */ Form_pg_type typetup; HeapTuple tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(arg.type_id)); if (!HeapTupleIsValid(tup)) elog(ERROR, "cache lookup failed for type of %s.%s '%u'", def->defnamespace, def->defname, arg.type_id); typetup = (Form_pg_type) GETSTRUCT(tup); ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid value for %s.%s '%s'", def->defnamespace, def->defname, value), errhint("%s.%s must be a valid %s", def->defnamespace, def->defname, NameStr(typetup->typname)))); } PG_END_TRY(); return val; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/src/with_clause/with_clause_parser.h���������������������������������������������0000664�0000000�0000000�00000002215�15100345067�0023205�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/parsenodes.h> #include <utils.h> #include "compat/compat.h" typedef struct WithClauseDefinition { /* Alternative names for the parameters. The first one is the "main" one * when it comes to printouts.*/ const char *arg_names[5]; Oid type_id; Datum default_val; } WithClauseDefinition; typedef struct WithClauseResult { const WithClauseDefinition *definition; bool is_default; Datum parsed; } WithClauseResult; extern TSDLLEXPORT void ts_with_clause_filter(const List *def_elems, List **within_namespace, List **not_within_namespace); extern TSDLLEXPORT WithClauseResult * ts_with_clauses_parse(const List *def_elems, const WithClauseDefinition *args, Size nargs); extern TSDLLEXPORT WithClauseResult * ts_with_clauses_parse_reset(const List *def_elems, const WithClauseDefinition *args, Size nargs); extern TSDLLEXPORT char *ts_with_clause_result_deparse_value(const WithClauseResult *result); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015032�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/.gitignore������������������������������������������������������������������0000664�0000000�0000000�00000000104�15100345067�0017015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������results/ dump/ regression.diffs regression.out unit/testoutputs.tmp ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/CMakeLists.txt��������������������������������������������������������������0000664�0000000�0000000�00000011001�15100345067�0017563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(PRIMARY_TEST_DIR ${CMAKE_CURRENT_LIST_DIR}) set(PRIMARY_TEST_DIR ${CMAKE_CURRENT_LIST_DIR} PARENT_SCOPE) set(_local_install_checks) set(_install_checks) # Testing support include(test-defs.cmake) # No checks for REGRESS_CHECKS needed here since all the checks are done in the # parent CMakeLists.txt. if(PG_REGRESS) message(STATUS "Using pg_regress ${PG_REGRESS}") add_custom_target( regresscheck COMMAND ${CMAKE_COMMAND} -E env ${PG_REGRESS_ENV} TEST_PGPORT=${TEST_PGPORT_TEMP_INSTANCE} TEST_SCHEDULE=${TEST_SCHEDULE} ${CMAKE_CURRENT_SOURCE_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_OPTS_EXTRA} ${PG_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_TEMP_INSTANCE} --temp-config=${TEST_OUTPUT_DIR}/postgresql.conf USES_TERMINAL) add_custom_target( regresscheck-rerun COMMAND ${PRIMARY_TEST_DIR}/ci_rerun.sh regresscheck USES_TERMINAL) add_custom_target( regresschecklocal COMMAND ${CMAKE_COMMAND} -E env ${PG_REGRESS_ENV} TEST_PGPORT=${TEST_PGPORT_LOCAL} ${CMAKE_CURRENT_SOURCE_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_OPTS_EXTRA} ${PG_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_LOCAL_INSTANCE} USES_TERMINAL) list(APPEND _local_install_checks regresschecklocal) list(APPEND _install_checks regresscheck) elseif(REQUIRE_ALL_TESTS) message( FATAL_ERROR "All tests were required but 'pg_regress' could not be found") endif() if(PG_ISOLATION_REGRESS) message(STATUS "Using pg_isolation_regress ${PG_ISOLATION_REGRESS}") add_custom_target( isolationcheck COMMAND ${CMAKE_COMMAND} -E env ${PG_ISOLATION_REGRESS_ENV} SPECS_DIR=${CMAKE_CURRENT_SOURCE_DIR}/isolation/specs TEST_PGPORT=${TEST_PGPORT_TEMP_INSTANCE} ${CMAKE_CURRENT_SOURCE_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_ISOLATION_REGRESS_OPTS_EXTRA} ${PG_ISOLATION_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_TEMP_INSTANCE} --temp-config=${TEST_OUTPUT_DIR}/postgresql.conf USES_TERMINAL) add_custom_target( isolationcheck-rerun COMMAND ${PRIMARY_TEST_DIR}/ci_rerun.sh isolationcheck USES_TERMINAL) add_custom_target( isolationchecklocal COMMAND ${CMAKE_COMMAND} -E env ${PG_ISOLATION_REGRESS_ENV} SPECS_DIR=${CMAKE_CURRENT_SOURCE_DIR}/isolation/specs TEST_PGPORT=${TEST_PGPORT_LOCAL} ${CMAKE_CURRENT_SOURCE_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_ISOLATION_REGRESS_OPTS_EXTRA} ${PG_ISOLATION_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_LOCAL_INSTANCE} USES_TERMINAL) list(APPEND _local_install_checks isolationchecklocal) list(APPEND _install_checks isolationcheck) elseif(REQUIRE_ALL_TESTS) message( FATAL_ERROR "All tests were required but 'pg_isolation_regress' could not be found") endif() if(TAP_CHECKS) add_custom_target( provecheck COMMAND rm -rf ${CMAKE_CURRENT_BINARY_DIR}/tmp_check COMMAND CONFDIR=${CMAKE_BINARY_DIR}/test PATH="${PG_BINDIR}:$ENV{PATH}" PG_REGRESS=${PG_REGRESS} SRC_DIR=${PG_SOURCE_DIR} CM_SRC_DIR=${CMAKE_SOURCE_DIR} PG_LIBDIR=${PG_LIBDIR} PG_PKGLIBDIR=${PG_PKGLIBDIR} PG_VERSION_MAJOR=${PG_VERSION_MAJOR} ${PRIMARY_TEST_DIR}/pg_prove.sh USES_TERMINAL) list(APPEND _install_checks provecheck) elseif(REQUIRE_ALL_TESTS) message( FATAL_ERROR "All tests were required but TAP_CHECKS was off (see previous messages why)" ) endif() # We add the installcheck target even when _install_checks is empty as tsl code # might add dependencies to it even when regress checks are disabled. add_custom_target(installcheck DEPENDS ${_install_checks}) # Define a post test hook that is invoked after the installcheck target # finishes. One can use add_dependencies on post hook target to run other # targets after tests complete. This is used, e.g., by code coverage. add_custom_target(installcheck-post-hook COMMENT "Post test hook") add_custom_command( TARGET installcheck POST_BUILD COMMAND cmake --build ${CMAKE_CURRENT_BINARY_DIR} --target installcheck-post-hook) add_custom_target( installcheck-rerun COMMAND ${PRIMARY_TEST_DIR}/ci_rerun.sh installcheck USES_TERMINAL) # installchecklocal tests against an existing postgres instance add_custom_target(installchecklocal DEPENDS ${_local_install_checks}) add_subdirectory(sql) add_subdirectory(isolation) add_subdirectory(t) if(PG_SOURCE_DIR) add_subdirectory(pgtest) endif(PG_SOURCE_DIR) if(CMAKE_BUILD_TYPE MATCHES Debug) add_subdirectory(src) endif(CMAKE_BUILD_TYPE MATCHES Debug) add_subdirectory(perl) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/README.md�������������������������������������������������������������������0000664�0000000�0000000�00000000244�15100345067�0016311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Testing TimescaleDB - [Regression tests](pgtest/README.md) - [Perl-based TAP tests](perl/README.md) - [Background Worker Test Infrastructure](src/bgw/README.md) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/ci_rerun.sh�����������������������������������������������������������������0000775�0000000�0000000�00000001100�15100345067�0017167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/bin/bash subcommand=$1 out_files="regression.out" case "$subcommand" in installcheck) out_files=$(find .. -name "regression.out") ;; regresscheck-shared) out_files="shared/regression.out" ;; isolationcheck|isolationcheck-t) out_files="isolation/regression.out" ;; *) out_files="regression.out" ;; esac failed=$(grep -h -P "^not ok|FAILED" $out_files | sed -r -e 's!^not ok [0-9]+ +[+-] ([a-z0-9_-]+) .*$!\1!' -e 's!^(test| ) ([a-z0-9_-]+) +... FAILED.*$!\2!') failed="${failed//$'\n'/ }" make -k $subcommand TESTS="$failed" ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/�������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016633�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/agg_bookends-15.out������������������������������������������������0000664�0000000�0000000�00000307764�15100345067�0022252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME agg_bookends SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE btest(time timestamp NOT NULL, time_alt timestamp, gp INTEGER, temp float, strid TEXT DEFAULT 'testing'); SELECT schema_name, table_name, created FROM create_hypertable('btest', 'time'); psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time_alt" does not follow best practices schema_name | table_name | created -------------+------------+--------- public | btest | t INSERT INTO btest VALUES('2017-01-20T09:00:01', '2017-01-20T10:00:00', 1, 22.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:59', 1, 21.2); INSERT INTO btest VALUES('2017-01-20T09:00:47', '2017-01-20T09:00:58', 1, 25.1); INSERT INTO btest VALUES('2017-01-20T09:00:02', '2017-01-20T09:00:57', 2, 35.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:56', 2, 30.2); --TOASTED; INSERT INTO btest VALUES('2017-01-20T09:00:43', '2017-01-20T09:01:55', 2, 20.1, repeat('xyz', 1000000) ); CREATE TABLE btest_numeric (time timestamp NOT NULL, quantity numeric); SELECT schema_name, table_name, created FROM create_hypertable('btest_numeric', 'time'); psql:include/agg_bookends_load.sql:16: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices schema_name | table_name | created -------------+---------------+--------- public | btest_numeric | t \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; --- QUERY PLAN --- Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=10.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_7_chunk_btest_numeric_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $1) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) InitPlan 2 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $1) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) InitPlan 2 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (("time" IS NOT NULL) AND ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone)) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: (("time" IS NOT NULL) AND ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone)) -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (last(btest.temp, btest."time")) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; --- QUERY PLAN --- WindowAgg (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- test constants :PREFIX SELECT first(100, 100) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (never executed) -> Seq Scan on _hyper_1_3_chunk (never executed) -> Seq Scan on _hyper_1_4_chunk (never executed) -> Seq Scan on _hyper_1_5_chunk (never executed) -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: btest.time_alt DESC -> Index Scan Backward using _hyper_1_1_chunk_btest_time_alt_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_alt_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_alt_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_4_chunk_btest_time_alt_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_alt_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (abs(last(btest.temp, btest."time"))) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) ROLLBACK; -- we want test results as part of the output too to make sure we produce correct output \set PREFIX '' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; time | gp | temp --------------------------+----+------ Fri Jan 20 09:00:01 2017 | 1 | 22.5 Fri Jan 20 09:00:02 2017 | 2 | 35.5 Fri Jan 20 09:00:21 2017 | 1 | 21.2 Fri Jan 20 09:00:21 2017 | 2 | 30.2 Fri Jan 20 09:00:43 2017 | 2 | 20.1 Fri Jan 20 09:00:47 2017 | 1 | 25.1 :PREFIX SELECT last(temp, time) FROM btest; last ------ 25.1 :PREFIX SELECT first(temp, time) FROM btest; first ------- 22.5 :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 22.5 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 30.2 :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 25.1 2 | 20.1 :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------- 1 | 22.5 2 | 35.5 --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------------------------------------------------------------------------ 1 | ("Fri Jan 20 09:00:01 2017","Fri Jan 20 10:00:00 2017",1,22.5,testing) 2 | ("Fri Jan 20 09:00:02 2017","Fri Jan 20 09:00:57 2017",2,35.5,testing) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; gp | left ----+------------ 1 | testing 2 | xyzxyzxyzx :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 20.1 :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+--------- 1 | testing 2 | testing BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; last ------ 30.5 --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 30.5 -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 35.3 --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 30.5 -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; last ------ 35.3 -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; first ------- 36.5 -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; last ------ 35.3 -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; last ------ 25.1 35.3 -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; last ------ 35.3 -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; last ------ 35.5 -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; max | last --------------------------+------ Mon Jan 20 09:00:43 2020 | 35.3 -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); last ------ 35.3 -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; last ------ 25.1 -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; first ------- 25.1 -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; gp | last ----+------ 1 | 25.1 1 | 25.1 1 | 25.1 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 -- test constants :PREFIX SELECT first(100, 100) FROM btest; first ------- 100 -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; abs ------ 35.3 -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); abs ------ 35.3 ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; first ------- :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; last ------ -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ :PREFIX SELECT first(time, quantity) FROM btest_numeric; first ------- :PREFIX SELECT last(time, quantity) FROM btest_numeric; last ------ -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 ROLLBACK; -- diff results with optimizations disabled and enabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o :DIFF_CMD --- Unoptimized result +++ Optimized result @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on time | gp | temp -- Test partial aggregation CREATE TABLE partial_aggregation (time timestamptz NOT NULL, quantity numeric, longvalue text); SELECT schema_name, table_name, created FROM create_hypertable('partial_aggregation', 'time'); schema_name | table_name | created -------------+---------------------+--------- public | partial_aggregation | t INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 1, 'hello'); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 2, 'world'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 4, 'words'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 5, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 6, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 7, 'words'); -- Use enable_partitionwise_aggregate to create partial aggregates per chunk SET enable_partitionwise_aggregate = ON; SELECT format('SELECT %3$s, %1$s FROM partial_aggregation WHERE %2$s GROUP BY %3$s ORDER BY 1, 2;', function, condition, grouping) FROM unnest(array[ 'first(time, quantity), last(time, quantity)', 'last(longvalue, quantity)', 'last(quantity, longvalue)', 'last(quantity, time)', 'last(time, longvalue)']) AS function, unnest(array[ 'true', $$time < '2021-01-01'$$, 'quantity is null', 'quantity is not null', 'quantity > 3']) AS condition, unnest(array[ '777::text' /* dummy grouping column */, 'longvalue', 'quantity', $$time_bucket('1 year', time)$$, $$time_bucket('3 year', time)$$]) AS grouping \gexec SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+-------+------ 777 | | SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | some SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 4 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 3 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+-------+------ | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- words | words SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 4 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 6 SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+-------+------ | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | more SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | more SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SET enable_partitionwise_aggregate = OFF; ������������timescaledb-2.23.0/test/expected/agg_bookends-16.out������������������������������������������������0000664�0000000�0000000�00000307764�15100345067�0022253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME agg_bookends SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE btest(time timestamp NOT NULL, time_alt timestamp, gp INTEGER, temp float, strid TEXT DEFAULT 'testing'); SELECT schema_name, table_name, created FROM create_hypertable('btest', 'time'); psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time_alt" does not follow best practices schema_name | table_name | created -------------+------------+--------- public | btest | t INSERT INTO btest VALUES('2017-01-20T09:00:01', '2017-01-20T10:00:00', 1, 22.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:59', 1, 21.2); INSERT INTO btest VALUES('2017-01-20T09:00:47', '2017-01-20T09:00:58', 1, 25.1); INSERT INTO btest VALUES('2017-01-20T09:00:02', '2017-01-20T09:00:57', 2, 35.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:56', 2, 30.2); --TOASTED; INSERT INTO btest VALUES('2017-01-20T09:00:43', '2017-01-20T09:01:55', 2, 20.1, repeat('xyz', 1000000) ); CREATE TABLE btest_numeric (time timestamp NOT NULL, quantity numeric); SELECT schema_name, table_name, created FROM create_hypertable('btest_numeric', 'time'); psql:include/agg_bookends_load.sql:16: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices schema_name | table_name | created -------------+---------------+--------- public | btest_numeric | t \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; --- QUERY PLAN --- Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=10.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_7_chunk_btest_numeric_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $1) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) InitPlan 2 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $1) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) InitPlan 2 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (("time" IS NOT NULL) AND ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone)) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: (("time" IS NOT NULL) AND ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone)) -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (last(btest.temp, btest."time")) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) Filter: (temp < '30'::double precision) -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; --- QUERY PLAN --- WindowAgg (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- test constants :PREFIX SELECT first(100, 100) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (never executed) -> Seq Scan on _hyper_1_3_chunk (never executed) -> Seq Scan on _hyper_1_4_chunk (never executed) -> Seq Scan on _hyper_1_5_chunk (never executed) -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: btest.time_alt DESC -> Index Scan Backward using _hyper_1_1_chunk_btest_time_alt_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_alt_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_alt_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_4_chunk_btest_time_alt_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_alt_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (abs(last(btest.temp, btest."time"))) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) ROLLBACK; -- we want test results as part of the output too to make sure we produce correct output \set PREFIX '' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; time | gp | temp --------------------------+----+------ Fri Jan 20 09:00:01 2017 | 1 | 22.5 Fri Jan 20 09:00:02 2017 | 2 | 35.5 Fri Jan 20 09:00:21 2017 | 1 | 21.2 Fri Jan 20 09:00:21 2017 | 2 | 30.2 Fri Jan 20 09:00:43 2017 | 2 | 20.1 Fri Jan 20 09:00:47 2017 | 1 | 25.1 :PREFIX SELECT last(temp, time) FROM btest; last ------ 25.1 :PREFIX SELECT first(temp, time) FROM btest; first ------- 22.5 :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 22.5 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 30.2 :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 25.1 2 | 20.1 :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------- 1 | 22.5 2 | 35.5 --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------------------------------------------------------------------------ 1 | ("Fri Jan 20 09:00:01 2017","Fri Jan 20 10:00:00 2017",1,22.5,testing) 2 | ("Fri Jan 20 09:00:02 2017","Fri Jan 20 09:00:57 2017",2,35.5,testing) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; gp | left ----+------------ 1 | testing 2 | xyzxyzxyzx :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 20.1 :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+--------- 1 | testing 2 | testing BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; last ------ 30.5 --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 30.5 -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 35.3 --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 30.5 -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; last ------ 35.3 -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; first ------- 36.5 -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; last ------ 35.3 -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; last ------ 25.1 35.3 -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; last ------ 35.3 -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; last ------ 35.5 -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; max | last --------------------------+------ Mon Jan 20 09:00:43 2020 | 35.3 -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); last ------ 35.3 -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; last ------ 25.1 -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; first ------- 25.1 -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; gp | last ----+------ 1 | 25.1 1 | 25.1 1 | 25.1 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 -- test constants :PREFIX SELECT first(100, 100) FROM btest; first ------- 100 -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; abs ------ 35.3 -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); abs ------ 35.3 ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; first ------- :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; last ------ -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ :PREFIX SELECT first(time, quantity) FROM btest_numeric; first ------- :PREFIX SELECT last(time, quantity) FROM btest_numeric; last ------ -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 ROLLBACK; -- diff results with optimizations disabled and enabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o :DIFF_CMD --- Unoptimized result +++ Optimized result @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on time | gp | temp -- Test partial aggregation CREATE TABLE partial_aggregation (time timestamptz NOT NULL, quantity numeric, longvalue text); SELECT schema_name, table_name, created FROM create_hypertable('partial_aggregation', 'time'); schema_name | table_name | created -------------+---------------------+--------- public | partial_aggregation | t INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 1, 'hello'); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 2, 'world'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 4, 'words'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 5, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 6, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 7, 'words'); -- Use enable_partitionwise_aggregate to create partial aggregates per chunk SET enable_partitionwise_aggregate = ON; SELECT format('SELECT %3$s, %1$s FROM partial_aggregation WHERE %2$s GROUP BY %3$s ORDER BY 1, 2;', function, condition, grouping) FROM unnest(array[ 'first(time, quantity), last(time, quantity)', 'last(longvalue, quantity)', 'last(quantity, longvalue)', 'last(quantity, time)', 'last(time, longvalue)']) AS function, unnest(array[ 'true', $$time < '2021-01-01'$$, 'quantity is null', 'quantity is not null', 'quantity > 3']) AS condition, unnest(array[ '777::text' /* dummy grouping column */, 'longvalue', 'quantity', $$time_bucket('1 year', time)$$, $$time_bucket('3 year', time)$$]) AS grouping \gexec SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+-------+------ 777 | | SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | some SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 4 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 3 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+-------+------ | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- words | words SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 4 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 6 SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+-------+------ | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | more SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | more SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SET enable_partitionwise_aggregate = OFF; ������������timescaledb-2.23.0/test/expected/agg_bookends-17.out������������������������������������������������0000664�0000000�0000000�00000301706�15100345067�0022242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME agg_bookends SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE btest(time timestamp NOT NULL, time_alt timestamp, gp INTEGER, temp float, strid TEXT DEFAULT 'testing'); SELECT schema_name, table_name, created FROM create_hypertable('btest', 'time'); psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time_alt" does not follow best practices schema_name | table_name | created -------------+------------+--------- public | btest | t INSERT INTO btest VALUES('2017-01-20T09:00:01', '2017-01-20T10:00:00', 1, 22.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:59', 1, 21.2); INSERT INTO btest VALUES('2017-01-20T09:00:47', '2017-01-20T09:00:58', 1, 25.1); INSERT INTO btest VALUES('2017-01-20T09:00:02', '2017-01-20T09:00:57', 2, 35.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:56', 2, 30.2); --TOASTED; INSERT INTO btest VALUES('2017-01-20T09:00:43', '2017-01-20T09:01:55', 2, 20.1, repeat('xyz', 1000000) ); CREATE TABLE btest_numeric (time timestamp NOT NULL, quantity numeric); SELECT schema_name, table_name, created FROM create_hypertable('btest_numeric', 'time'); psql:include/agg_bookends_load.sql:16: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices schema_name | table_name | created -------------+---------------+--------- public | btest_numeric | t \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; --- QUERY PLAN --- Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=10.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_7_chunk_btest_numeric_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (never executed) -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) InitPlan 2 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) InitPlan 2 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone) -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (last(btest.temp, btest."time")) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=0.00 loops=1) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (temp < '30'::double precision) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (temp < '30'::double precision) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Filter: (temp < '30'::double precision) -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; --- QUERY PLAN --- WindowAgg (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- test constants :PREFIX SELECT first(100, 100) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (never executed) -> Seq Scan on _hyper_1_3_chunk (never executed) -> Seq Scan on _hyper_1_4_chunk (never executed) -> Seq Scan on _hyper_1_5_chunk (never executed) -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: btest.time_alt DESC -> Index Scan Backward using _hyper_1_1_chunk_btest_time_alt_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_alt_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_alt_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_4_chunk_btest_time_alt_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_alt_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (abs(last(btest.temp, btest."time"))) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (never executed) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (never executed) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) ROLLBACK; -- we want test results as part of the output too to make sure we produce correct output \set PREFIX '' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; time | gp | temp --------------------------+----+------ Fri Jan 20 09:00:01 2017 | 1 | 22.5 Fri Jan 20 09:00:02 2017 | 2 | 35.5 Fri Jan 20 09:00:21 2017 | 1 | 21.2 Fri Jan 20 09:00:21 2017 | 2 | 30.2 Fri Jan 20 09:00:43 2017 | 2 | 20.1 Fri Jan 20 09:00:47 2017 | 1 | 25.1 :PREFIX SELECT last(temp, time) FROM btest; last ------ 25.1 :PREFIX SELECT first(temp, time) FROM btest; first ------- 22.5 :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 22.5 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 30.2 :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 25.1 2 | 20.1 :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------- 1 | 22.5 2 | 35.5 --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------------------------------------------------------------------------ 1 | ("Fri Jan 20 09:00:01 2017","Fri Jan 20 10:00:00 2017",1,22.5,testing) 2 | ("Fri Jan 20 09:00:02 2017","Fri Jan 20 09:00:57 2017",2,35.5,testing) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; gp | left ----+------------ 1 | testing 2 | xyzxyzxyzx :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 20.1 :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+--------- 1 | testing 2 | testing BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; last ------ 30.5 --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 30.5 -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 35.3 --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 30.5 -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; last ------ 35.3 -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; first ------- 36.5 -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; last ------ 35.3 -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; last ------ 25.1 35.3 -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; last ------ 35.3 -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; last ------ 35.5 -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; max | last --------------------------+------ Mon Jan 20 09:00:43 2020 | 35.3 -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); last ------ 35.3 -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; last ------ 25.1 -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; first ------- 25.1 -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; gp | last ----+------ 1 | 25.1 1 | 25.1 1 | 25.1 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 -- test constants :PREFIX SELECT first(100, 100) FROM btest; first ------- 100 -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; abs ------ 35.3 -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); abs ------ 35.3 ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; first ------- :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; last ------ -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ :PREFIX SELECT first(time, quantity) FROM btest_numeric; first ------- :PREFIX SELECT last(time, quantity) FROM btest_numeric; last ------ -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 ROLLBACK; -- diff results with optimizations disabled and enabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o :DIFF_CMD --- Unoptimized result +++ Optimized result @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on time | gp | temp -- Test partial aggregation CREATE TABLE partial_aggregation (time timestamptz NOT NULL, quantity numeric, longvalue text); SELECT schema_name, table_name, created FROM create_hypertable('partial_aggregation', 'time'); schema_name | table_name | created -------------+---------------------+--------- public | partial_aggregation | t INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 1, 'hello'); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 2, 'world'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 4, 'words'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 5, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 6, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 7, 'words'); -- Use enable_partitionwise_aggregate to create partial aggregates per chunk SET enable_partitionwise_aggregate = ON; SELECT format('SELECT %3$s, %1$s FROM partial_aggregation WHERE %2$s GROUP BY %3$s ORDER BY 1, 2;', function, condition, grouping) FROM unnest(array[ 'first(time, quantity), last(time, quantity)', 'last(longvalue, quantity)', 'last(quantity, longvalue)', 'last(quantity, time)', 'last(time, longvalue)']) AS function, unnest(array[ 'true', $$time < '2021-01-01'$$, 'quantity is null', 'quantity is not null', 'quantity > 3']) AS condition, unnest(array[ '777::text' /* dummy grouping column */, 'longvalue', 'quantity', $$time_bucket('1 year', time)$$, $$time_bucket('3 year', time)$$]) AS grouping \gexec SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+-------+------ 777 | | SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | some SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 4 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 3 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+-------+------ | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- words | words SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 4 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 6 SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+-------+------ | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | more SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | more SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SET enable_partitionwise_aggregate = OFF; ����������������������������������������������������������timescaledb-2.23.0/test/expected/agg_bookends-18.out������������������������������������������������0000664�0000000�0000000�00000301706�15100345067�0022243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME agg_bookends SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE btest(time timestamp NOT NULL, time_alt timestamp, gp INTEGER, temp float, strid TEXT DEFAULT 'testing'); SELECT schema_name, table_name, created FROM create_hypertable('btest', 'time'); psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices psql:include/agg_bookends_load.sql:6: WARNING: column type "timestamp without time zone" used for "time_alt" does not follow best practices schema_name | table_name | created -------------+------------+--------- public | btest | t INSERT INTO btest VALUES('2017-01-20T09:00:01', '2017-01-20T10:00:00', 1, 22.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:59', 1, 21.2); INSERT INTO btest VALUES('2017-01-20T09:00:47', '2017-01-20T09:00:58', 1, 25.1); INSERT INTO btest VALUES('2017-01-20T09:00:02', '2017-01-20T09:00:57', 2, 35.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:56', 2, 30.2); --TOASTED; INSERT INTO btest VALUES('2017-01-20T09:00:43', '2017-01-20T09:01:55', 2, 20.1, repeat('xyz', 1000000) ); CREATE TABLE btest_numeric (time timestamp NOT NULL, quantity numeric); SELECT schema_name, table_name, created FROM create_hypertable('btest_numeric', 'time'); psql:include/agg_bookends_load.sql:16: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices schema_name | table_name | created -------------+---------------+--------- public | btest_numeric | t \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; --- QUERY PLAN --- Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_1_chunk.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.gp -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=10.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_7_chunk_btest_numeric_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_btest_numeric_time_idx on _hyper_2_6_chunk (never executed) -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: btest.gp -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) InitPlan 2 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) InitPlan 2 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest btest_1 (actual rows=1.00 loops=1) Order: btest_1."time" -> Index Scan Backward using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk _hyper_1_5_chunk_1 (never executed) -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Index Cond: ("time" <= 'Fri Jan 20 09:00:02 2017'::timestamp without time zone) -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (last(btest.temp, btest."time")) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=0.00 loops=1) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (temp < '30'::double precision) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (temp < '30'::double precision) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (temp < '30'::double precision) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) Filter: (temp < '30'::double precision) -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" -> Index Scan Backward using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (never executed) Index Cond: ("time" >= 'Fri Jan 20 09:00:47 2017'::timestamp without time zone) -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; --- QUERY PLAN --- WindowAgg (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: btest.gp Sort Method: quicksort -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) -- test constants :PREFIX SELECT first(100, 100) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (never executed) -> Seq Scan on _hyper_1_3_chunk (never executed) -> Seq Scan on _hyper_1_4_chunk (never executed) -> Seq Scan on _hyper_1_5_chunk (never executed) -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: btest.time_alt DESC -> Index Scan Backward using _hyper_1_1_chunk_btest_time_alt_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_2_chunk_btest_time_alt_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_3_chunk_btest_time_alt_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_4_chunk_btest_time_alt_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) -> Index Scan Backward using _hyper_1_5_chunk_btest_time_alt_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) Index Cond: (time_alt IS NOT NULL) --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest (actual rows=1.00 loops=1) Order: btest."time" DESC -> Index Scan using _hyper_1_5_chunk_btest_time_idx on _hyper_1_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_btest_time_idx on _hyper_1_3_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_btest_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_btest_time_idx on _hyper_1_1_chunk (never executed) -> Index Scan using _hyper_1_4_chunk_btest_time_idx on _hyper_1_4_chunk (never executed) -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: (abs(last(btest.temp, btest."time"))) Sort Method: quicksort -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=11.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_5_chunk (actual rows=1.00 loops=1) ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_9_chunk_btest_numeric_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_8_chunk_btest_numeric_time_idx on _hyper_2_8_chunk (never executed) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=2.00 loops=1) TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" -> Index Scan Backward using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (never executed) :PREFIX SELECT last(quantity, time) FROM btest_numeric; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on btest_numeric (actual rows=1.00 loops=1) Order: btest_numeric."time" DESC -> Index Scan using _hyper_2_10_chunk_btest_numeric_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_11_chunk_btest_numeric_time_idx on _hyper_2_11_chunk (never executed) :PREFIX SELECT first(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) :PREFIX SELECT last(time, quantity) FROM btest_numeric; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_10_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_2_11_chunk (actual rows=2.00 loops=1) ROLLBACK; -- we want test results as part of the output too to make sure we produce correct output \set PREFIX '' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; time | gp | temp --------------------------+----+------ Fri Jan 20 09:00:01 2017 | 1 | 22.5 Fri Jan 20 09:00:02 2017 | 2 | 35.5 Fri Jan 20 09:00:21 2017 | 1 | 21.2 Fri Jan 20 09:00:21 2017 | 2 | 30.2 Fri Jan 20 09:00:43 2017 | 2 | 20.1 Fri Jan 20 09:00:47 2017 | 1 | 25.1 :PREFIX SELECT last(temp, time) FROM btest; last ------ 25.1 :PREFIX SELECT first(temp, time) FROM btest; first ------- 22.5 :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 22.5 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 30.2 :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 25.1 2 | 20.1 :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------- 1 | 22.5 2 | 35.5 --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; gp | first ----+------------------------------------------------------------------------ 1 | ("Fri Jan 20 09:00:01 2017","Fri Jan 20 10:00:00 2017",1,22.5,testing) 2 | ("Fri Jan 20 09:00:02 2017","Fri Jan 20 09:00:57 2017",2,35.5,testing) --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; gp | left ----+------------ 1 | testing 2 | xyzxyzxyzx :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 20.1 :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+--------- 1 | testing 2 | testing BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; last ------ 30.5 --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 30.5 -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; gp | last ----+------ 1 | 22.5 2 | 35.3 --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 30.5 -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; last ------ 35.3 -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; first ------- 36.5 -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; first ------- 36.5 -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; last ------ 35.3 -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; last ------ 25.1 35.3 -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; last ------ 35.3 -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; first | last -------+------ 36.5 | 35.3 -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; last ------ 35.5 -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; max | last --------------------------+------ Mon Jan 20 09:00:43 2020 | 35.3 -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); last ------ 35.3 -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; last ------ 25.1 -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; first ------- 25.1 -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; gp | last ----+------ 1 | 25.1 1 | 25.1 1 | 25.1 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 2 | 35.3 -- test constants :PREFIX SELECT first(100, 100) FROM btest; first ------- 100 -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; last ------ 35.3 --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; abs ------ 35.3 -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); abs ------ 35.3 ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; first ------- :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; last ------ -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ :PREFIX SELECT first(time, quantity) FROM btest_numeric; first ------- :PREFIX SELECT last(time, quantity) FROM btest_numeric; last ------ -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; first ------- :PREFIX SELECT last(quantity, time) FROM btest_numeric; last ------ 1 :PREFIX SELECT first(time, quantity) FROM btest_numeric; first -------------------------- Sun Jan 20 09:00:43 2019 :PREFIX SELECT last(time, quantity) FROM btest_numeric; last -------------------------- Sun Jan 20 09:00:43 2019 ROLLBACK; -- diff results with optimizations disabled and enabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; \o :DIFF_CMD --- Unoptimized result +++ Optimized result @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on time | gp | temp -- Test partial aggregation CREATE TABLE partial_aggregation (time timestamptz NOT NULL, quantity numeric, longvalue text); SELECT schema_name, table_name, created FROM create_hypertable('partial_aggregation', 'time'); schema_name | table_name | created -------------+---------------------+--------- public | partial_aggregation | t INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 1, 'hello'); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 2, 'world'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 4, 'words'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 5, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 6, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 7, 'words'); -- Use enable_partitionwise_aggregate to create partial aggregates per chunk SET enable_partitionwise_aggregate = ON; SELECT format('SELECT %3$s, %1$s FROM partial_aggregation WHERE %2$s GROUP BY %3$s ORDER BY 1, 2;', function, condition, grouping) FROM unnest(array[ 'first(time, quantity), last(time, quantity)', 'last(longvalue, quantity)', 'last(quantity, longvalue)', 'last(quantity, time)', 'last(time, longvalue)']) AS function, unnest(array[ 'true', $$time < '2021-01-01'$$, 'quantity is null', 'quantity is not null', 'quantity > 3']) AS condition, unnest(array[ '777::text' /* dummy grouping column */, 'longvalue', 'quantity', $$time_bucket('1 year', time)$$, $$time_bucket('3 year', time)$$]) AS grouping \gexec SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+-------+------ 777 | | SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | first | last ------+------------------------------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | some SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------- 777 | words SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 2 SELECT 777::text, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 4 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 3 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | 6 SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------ 777 | SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Sun Jan 20 09:00:43 2019 PST SELECT 777::text, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY 777::text ORDER BY 1, 2; text | last ------+------------------------------ 777 | Thu Jan 20 09:00:43 2022 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+-------+------ | | SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST world | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | first | last -----------+------------------------------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some world | world | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- hello | hello more | more some | some words | words world | world SELECT longvalue, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------- words | words SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 4 world | 2 SELECT longvalue, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 4 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 world | 2 | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ hello | 1 more | 3 some | 3 words | 6 world | 2 SELECT longvalue, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ words | 6 SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST world | Sun Jan 20 09:00:43 2019 PST | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------ | SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ hello | Sun Jan 20 09:00:43 2019 PST more | Mon Jan 20 09:00:43 2020 PST some | Mon Jan 20 09:00:43 2020 PST words | Thu Jan 20 09:00:43 2022 PST world | Sun Jan 20 09:00:43 2019 PST SELECT longvalue, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY longvalue ORDER BY 1, 2; longvalue | last -----------+------------------------------ words | Thu Jan 20 09:00:43 2022 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+-------+------ | | SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | first | last ----------+------------------------------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 1 | hello 2 | world 3 | some 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------- 4 | words 5 | words 6 | words 7 | words SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ 4 | 4 5 | 5 6 | 6 7 | 7 SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------ | SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 1 | Sun Jan 20 09:00:43 2019 PST 2 | Sun Jan 20 09:00:43 2019 PST 3 | Mon Jan 20 09:00:43 2020 PST 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT quantity, last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY quantity ORDER BY 1, 2; quantity | last ----------+------------------------------ 4 | Thu Jan 20 09:00:43 2022 PST 5 | Thu Jan 20 09:00:43 2022 PST 6 | Fri Jan 20 09:00:43 2023 PST 7 | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | more SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Mon Dec 31 16:00:00 2018 PST | world Tue Dec 31 16:00:00 2019 PST | some Thu Dec 31 16:00:00 2020 PST | some Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Fri Dec 31 16:00:00 2021 PST | words Sat Dec 31 16:00:00 2022 PST | words SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | 2 Tue Dec 31 16:00:00 2019 PST | 3 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Mon Dec 31 16:00:00 2018 PST | 1 Tue Dec 31 16:00:00 2019 PST | 3 Thu Dec 31 16:00:00 2020 PST | 3 Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Fri Dec 31 16:00:00 2021 PST | 4 Sat Dec 31 16:00:00 2022 PST | 6 SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Mon Dec 31 16:00:00 2018 PST | Sun Jan 20 09:00:43 2019 PST Tue Dec 31 16:00:00 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('1 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('1 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Fri Dec 31 16:00:00 2021 PST | Thu Jan 20 09:00:43 2022 PST Sat Dec 31 16:00:00 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+-------+------ Sun Dec 31 16:00:00 2017 PST | | SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST | Mon Jan 20 09:00:43 2020 PST Thu Dec 31 16:00:00 2020 PST | Wed Jan 20 09:00:43 2021 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), first(time, quantity), last(time, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | first | last ------------------------------+------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST | Fri Jan 20 09:00:43 2023 PST SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | more SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Sun Dec 31 16:00:00 2017 PST | some Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(longvalue, quantity) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------- Thu Dec 31 16:00:00 2020 PST | words SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 2 Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 4 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | 3 Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(quantity, time) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Thu Dec 31 16:00:00 2020 PST | 6 SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE true GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE time < '2021-01-01' GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------ Sun Dec 31 16:00:00 2017 PST | SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity is not null GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Sun Dec 31 16:00:00 2017 PST | Sun Jan 20 09:00:43 2019 PST Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SELECT time_bucket('3 year', time), last(time, longvalue) FROM partial_aggregation WHERE quantity > 3 GROUP BY time_bucket('3 year', time) ORDER BY 1, 2; time_bucket | last ------------------------------+------------------------------ Thu Dec 31 16:00:00 2020 PST | Thu Jan 20 09:00:43 2022 PST SET enable_partitionwise_aggregate = OFF; ����������������������������������������������������������timescaledb-2.23.0/test/expected/alter.out����������������������������������������������������������0000664�0000000�0000000�00000115606�15100345067�0020504�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH 'include/query_result_test_equal.sql' -- DROP a table's column before making it a hypertable CREATE TABLE alter_before(id serial, time timestamp, temp float, colorid integer, notes text, notes_2 text); ALTER TABLE alter_before DROP COLUMN id; ALTER TABLE alter_before ALTER COLUMN temp SET (n_distinct = 10); ALTER TABLE alter_before ALTER COLUMN colorid SET (n_distinct = 11); ALTER TABLE alter_before ALTER COLUMN colorid RESET (n_distinct); ALTER TABLE alter_before ALTER COLUMN temp SET STATISTICS 100; ALTER TABLE alter_before ALTER COLUMN notes SET STORAGE EXTERNAL; SELECT create_hypertable('alter_before', 'time', chunk_time_interval => 2628000000000); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------- (1,public,alter_before,t) -- Test error hint for invalid timescaledb options on ALTER TABLE \set ON_ERROR_STOP 0 -- Invalid timescaledb option should show hint with valid options \set VERBOSITY default ALTER TABLE alter_before SET (tsdb.invalid_option = true); ERROR: unrecognized parameter "tsdb.invalid_option" HINT: Valid timescaledb parameters are: chunk_interval, compress, compress_segmentby, compress_orderby, compress_chunk_interval, compress_index ALTER TABLE alter_before SET (timescaledb.nonexistent = false); ERROR: unrecognized parameter "timescaledb.nonexistent" HINT: Valid timescaledb parameters are: chunk_interval, compress, compress_segmentby, compress_orderby, compress_chunk_interval, compress_index \set ON_ERROR_STOP 1 \set VERBOSITY terse INSERT INTO alter_before VALUES ('2017-03-22T09:18:22', 23.5, 1); SELECT * FROM alter_before; time | temp | colorid | notes | notes_2 --------------------------+------+---------+-------+--------- Wed Mar 22 09:18:22 2017 | 23.5 | 1 | | -- Show that deleted column is marked as dropped and that attnums are -- now different for the root table and the chunk -- PG17 made attstattarget NULLABLE and changed the default from -1 to NULL SELECT c.relname, a.attname, a.attnum, a.attoptions, CASE WHEN a.attstattarget = -1 OR (a.attisdropped AND a.attstattarget = 0) THEN NULL ELSE a.attstattarget END attstattarget, a.attstorage FROM pg_attribute a, pg_class c WHERE a.attrelid = c.oid AND (c.relname LIKE '_hyper_1%_chunk' OR c.relname = 'alter_before') AND a.attnum > 0 ORDER BY c.relname, a.attnum; relname | attname | attnum | attoptions | attstattarget | attstorage ------------------+------------------------------+--------+-----------------+---------------+------------ _hyper_1_1_chunk | time | 1 | | | p _hyper_1_1_chunk | temp | 2 | {n_distinct=10} | 100 | p _hyper_1_1_chunk | colorid | 3 | | | p _hyper_1_1_chunk | notes | 4 | | | e _hyper_1_1_chunk | notes_2 | 5 | | | x alter_before | ........pg.dropped.1........ | 1 | | | p alter_before | time | 2 | | | p alter_before | temp | 3 | {n_distinct=10} | 100 | p alter_before | colorid | 4 | | | p alter_before | notes | 5 | | | e alter_before | notes_2 | 6 | | | x -- DROP a table's column after making it a hypertable and having data CREATE TABLE alter_after(id serial, time timestamp, temp float, colorid integer, notes text, notes_2 text); SELECT create_hypertable('alter_after', 'time', chunk_time_interval => 2628000000000); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (2,public,alter_after,t) -- Create first chunk INSERT INTO alter_after (time, temp, colorid) VALUES ('2017-03-22T09:18:22', 23.5, 1); ALTER TABLE alter_after DROP COLUMN id; ALTER TABLE alter_after ALTER COLUMN temp SET (n_distinct = 10); ALTER TABLE alter_after ALTER COLUMN colorid SET (n_distinct = 11); ALTER TABLE alter_after ALTER COLUMN colorid RESET (n_distinct); ALTER TABLE alter_after ALTER COLUMN colorid SET STATISTICS 101; ALTER TABLE alter_after ALTER COLUMN notes_2 SET STORAGE EXTERNAL; -- Creating new chunks after dropping a column should work just fine INSERT INTO alter_after VALUES ('2017-03-22T09:18:23', 21.5, 1), ('2017-05-22T09:18:22', 36.2, 2), ('2017-05-22T09:18:23', 15.2, 2); -- Make sure tuple conversion also works with COPY \COPY alter_after FROM 'data/alter.tsv' NULL AS ''; -- Data should look OK SELECT * FROM alter_after; time | temp | colorid | notes | notes_2 --------------------------+------+---------+-------+--------- Wed Mar 22 09:18:22 2017 | 23.5 | 1 | | Wed Mar 22 09:18:23 2017 | 21.5 | 1 | | Mon May 22 09:18:22 2017 | 36.2 | 2 | | Mon May 22 09:18:23 2017 | 15.2 | 2 | | Tue Aug 22 09:19:22 2017 | 21.4 | 3 | nr1 | n2r1 Wed Aug 23 09:20:17 2017 | 31.5 | 2 | nr2 | n2r2 -- Show that attnums are different for chunks created after DROP -- column SELECT c.relname, a.attname, a.attnum FROM pg_attribute a, pg_class c WHERE a.attrelid = c.oid AND (c.relname LIKE '_hyper_2%_chunk' OR c.relname = 'alter_after') AND a.attnum > 0 ORDER BY c.relname, a.attnum; relname | attname | attnum ------------------+------------------------------+-------- _hyper_2_2_chunk | ........pg.dropped.1........ | 1 _hyper_2_2_chunk | time | 2 _hyper_2_2_chunk | temp | 3 _hyper_2_2_chunk | colorid | 4 _hyper_2_2_chunk | notes | 5 _hyper_2_2_chunk | notes_2 | 6 _hyper_2_3_chunk | time | 1 _hyper_2_3_chunk | temp | 2 _hyper_2_3_chunk | colorid | 3 _hyper_2_3_chunk | notes | 4 _hyper_2_3_chunk | notes_2 | 5 _hyper_2_4_chunk | time | 1 _hyper_2_4_chunk | temp | 2 _hyper_2_4_chunk | colorid | 3 _hyper_2_4_chunk | notes | 4 _hyper_2_4_chunk | notes_2 | 5 alter_after | ........pg.dropped.1........ | 1 alter_after | time | 2 alter_after | temp | 3 alter_after | colorid | 4 alter_after | notes | 5 alter_after | notes_2 | 6 -- Add an ID column again ALTER TABLE alter_after ADD COLUMN id serial; INSERT INTO alter_after (time, temp, colorid) VALUES ('2017-08-22T09:19:14', 12.5, 3); --test thing that we are allowed to do on chunks ALTER TABLE _timescaledb_internal._hyper_2_3_chunk ALTER COLUMN temp RESET (n_distinct); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk ALTER COLUMN temp SET (n_distinct = 20); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk ALTER COLUMN temp SET STATISTICS 201; ALTER TABLE _timescaledb_internal._hyper_2_4_chunk ALTER COLUMN notes SET STORAGE EXTERNAL; -- PG17 made attstattarget NULLABLE and changed the default from -1 to NULL SELECT c.relname, a.attname, a.attnum, a.attoptions, CASE WHEN a.attstattarget = -1 OR (a.attisdropped AND a.attstattarget = 0) THEN NULL ELSE a.attstattarget END attstattarget, a.attstorage FROM pg_attribute a, pg_class c WHERE a.attrelid = c.oid AND (c.relname LIKE '_hyper_2%_chunk' OR c.relname = 'alter_after') AND a.attnum > 0 ORDER BY c.relname, a.attnum; relname | attname | attnum | attoptions | attstattarget | attstorage ------------------+------------------------------+--------+-----------------+---------------+------------ _hyper_2_2_chunk | ........pg.dropped.1........ | 1 | | | p _hyper_2_2_chunk | time | 2 | | | p _hyper_2_2_chunk | temp | 3 | {n_distinct=10} | | p _hyper_2_2_chunk | colorid | 4 | | 101 | p _hyper_2_2_chunk | notes | 5 | | | x _hyper_2_2_chunk | notes_2 | 6 | | | e _hyper_2_2_chunk | id | 7 | | | p _hyper_2_3_chunk | time | 1 | | | p _hyper_2_3_chunk | temp | 2 | | | p _hyper_2_3_chunk | colorid | 3 | | 101 | p _hyper_2_3_chunk | notes | 4 | | | x _hyper_2_3_chunk | notes_2 | 5 | | | e _hyper_2_3_chunk | id | 6 | | | p _hyper_2_4_chunk | time | 1 | | | p _hyper_2_4_chunk | temp | 2 | {n_distinct=20} | 201 | p _hyper_2_4_chunk | colorid | 3 | | 101 | p _hyper_2_4_chunk | notes | 4 | | | e _hyper_2_4_chunk | notes_2 | 5 | | | e _hyper_2_4_chunk | id | 6 | | | p alter_after | ........pg.dropped.1........ | 1 | | | p alter_after | time | 2 | | | p alter_after | temp | 3 | {n_distinct=10} | | p alter_after | colorid | 4 | | 101 | p alter_after | notes | 5 | | | x alter_after | notes_2 | 6 | | | e alter_after | id | 7 | | | p SELECT * FROM alter_after; time | temp | colorid | notes | notes_2 | id --------------------------+------+---------+-------+---------+---- Wed Mar 22 09:18:22 2017 | 23.5 | 1 | | | 1 Wed Mar 22 09:18:23 2017 | 21.5 | 1 | | | 2 Mon May 22 09:18:22 2017 | 36.2 | 2 | | | 3 Mon May 22 09:18:23 2017 | 15.2 | 2 | | | 4 Tue Aug 22 09:19:22 2017 | 21.4 | 3 | nr1 | n2r1 | 5 Wed Aug 23 09:20:17 2017 | 31.5 | 2 | nr2 | n2r2 | 6 Tue Aug 22 09:19:14 2017 | 12.5 | 3 | | | 7 -- test setting reloptions ALTER TABLE _timescaledb_internal._hyper_2_3_chunk SET (parallel_workers=2); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk SET (parallel_workers=4); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk RESET (parallel_workers); SELECT relname, reloptions FROM pg_class WHERE relname IN ('_hyper_2_3_chunk','_hyper_2_4_chunk'); relname | reloptions ------------------+---------------------- _hyper_2_3_chunk | {parallel_workers=2} _hyper_2_4_chunk | -- Need superuser to ALTER chunks in _timescaledb_internal schema \c :TEST_DBNAME :ROLE_SUPERUSER SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE id = 2; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f -- Rename chunk ALTER TABLE _timescaledb_internal._hyper_2_2_chunk RENAME TO new_chunk_name; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE id = 2; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+----------------+---------------------+---------+--------+----------- 2 | 2 | _timescaledb_internal | new_chunk_name | | f | 0 | f -- Set schema ALTER TABLE _timescaledb_internal.new_chunk_name SET SCHEMA public; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE id = 2; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+----------------+---------------------+---------+--------+----------- 2 | 2 | public | new_chunk_name | | f | 0 | f -- Test that we cannot rename chunk columns \set ON_ERROR_STOP 0 ALTER TABLE public.new_chunk_name RENAME COLUMN time TO newtime; ERROR: cannot rename column "time" of hypertable chunk "new_chunk_name" \set ON_ERROR_STOP 1 -- Test that we can set tablespace of a hypertable \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; SET client_min_messages = NOTICE; --test hypertable with tables space CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Test that we can directly change chunk tablespace ALTER TABLE public.new_chunk_name SET TABLESPACE tablespace1; SELECT tablespace FROM pg_tables WHERE tablename = 'new_chunk_name'; tablespace ------------- tablespace1 -- drop all tables to make checking the tests below easier DROP TABLE alter_before; DROP TABLE alter_after; -- should return 0 rows SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename LIKE '\_hyper\__\__\_chunk' ORDER BY tablename; tablename | tablespace -----------+------------ CREATE TABLE hyper_in_space(time bigint, temp float, device int); SELECT create_hypertable('hyper_in_space', 'time', 'device', 4, chunk_time_interval=>1); create_hypertable ----------------------------- (3,public,hyper_in_space,t) INSERT INTO hyper_in_space(time, temp, device) VALUES (1, 20, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (3, 21, 2); INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 23, 1); SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1' ORDER BY tablename; tablename ----------- SET default_tablespace = tablespace1; -- should be inserted in tablespace1 which is now default INSERT INTO hyper_in_space(time, temp, device) VALUES (11, 24, 3); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename LIKE '\_hyper\__\__\_chunk' ORDER BY tablename; tablename | tablespace ------------------+------------- _hyper_3_5_chunk | _hyper_3_6_chunk | _hyper_3_7_chunk | _hyper_3_8_chunk | tablespace1 hyper_in_space | SET default_tablespace TO DEFAULT; ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1' ORDER BY tablename; tablename ------------------ _hyper_3_5_chunk _hyper_3_6_chunk _hyper_3_7_chunk _hyper_3_8_chunk hyper_in_space -- should be inserted in an existing chunk in the new tablespace, -- no new chunks INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 27, 1); -- the new chunk should be create in the new tablespace INSERT INTO hyper_in_space(time, temp, device) VALUES (8, 24, 2); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename LIKE '\_hyper\__\__\_chunk' ORDER BY tablename; tablename | tablespace ------------------+------------- _hyper_3_5_chunk | tablespace1 _hyper_3_6_chunk | tablespace1 _hyper_3_7_chunk | tablespace1 _hyper_3_8_chunk | tablespace1 _hyper_3_9_chunk | tablespace1 hyper_in_space | tablespace1 -- should not fail (unlike attach_tablespace) ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; \set ON_ERROR_STOP 0 -- not an empty tablespace DROP TABLESPACE tablespace1; ERROR: tablespace "tablespace1" is still attached to 1 hypertables \set ON_ERROR_STOP 1 -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'hyper_in_space\', 22)::NAME' \set QUERY2 'SELECT drop_chunks(\'hyper_in_space\', 22)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 5 | 5 SELECT tablename, tablespace FROM pg_tables WHERE tablespace = 'tablespace1' ORDER BY tablename; tablename | tablespace ----------------+------------- hyper_in_space | tablespace1 \set ON_ERROR_STOP 0 -- should not be able to drop tablespace if a hypertable depends on it -- even when there are no chunks DROP TABLESPACE tablespace1; ERROR: tablespace "tablespace1" is still attached to 1 hypertables \set ON_ERROR_STOP 1 DROP TABLE hyper_in_space; CREATE TABLE hyper_in_space(time bigint, temp float, device int) TABLESPACE tablespace1; SELECT create_hypertable('hyper_in_space', 'time', 'device', 4, chunk_time_interval=>1); create_hypertable ----------------------------- (4,public,hyper_in_space,t) INSERT INTO hyper_in_space(time, temp, device) VALUES (1, 20, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (3, 21, 2); INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 23, 1); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; tablename | tablespace -------------------+------------- _hyper_4_10_chunk | tablespace1 _hyper_4_11_chunk | tablespace1 _hyper_4_12_chunk | tablespace1 hyper_in_space | tablespace1 SELECT attach_tablespace('tablespace2', 'hyper_in_space'); attach_tablespace ------------------- \set ON_ERROR_STOP 0 -- should fail as >1 tablespaces are attached ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; ERROR: cannot set new tablespace when multiple tablespaces are attached to hypertable "hyper_in_space" \set ON_ERROR_STOP 1 SELECT detach_tablespace('tablespace2', 'hyper_in_space'); detach_tablespace ------------------- 1 SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 3 | 4 | tablespace1 -- make sure when using ALTER TABLE, table spaces are not accumulated -- as in case of attach_tablespace -- should have one result SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 3 | 4 | tablespace1 ALTER TABLE hyper_in_space SET TABLESPACE tablespace2; -- should have one result SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 5 | 4 | tablespace2 ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; -- should have one result, (same as the first in the block) SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 6 | 4 | tablespace1 SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; tablename | tablespace -------------------+------------- _hyper_4_10_chunk | tablespace1 _hyper_4_11_chunk | tablespace1 _hyper_4_12_chunk | tablespace1 hyper_in_space | tablespace1 -- attach tb2 <-> ALTER SET tb1 <-> detach tb1 should work SELECT detach_tablespace('tablespace1', 'hyper_in_space'); detach_tablespace ------------------- 1 INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 23, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (7, 23, 1); -- Since we have detached tablespace1 the new chunk should not be -- placed there. SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; tablename | tablespace -------------------+------------- _hyper_4_10_chunk | tablespace1 _hyper_4_11_chunk | tablespace1 _hyper_4_12_chunk | tablespace1 _hyper_4_13_chunk | hyper_in_space | SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- -- tablespace functions should handle the default tablespace just as they do others SELECT attach_tablespace('pg_default', 'hyper_in_space'); attach_tablespace ------------------- SELECT attach_tablespace('tablespace2', 'hyper_in_space'); attach_tablespace ------------------- SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; tablename | tablespace -------------------+------------- _hyper_4_10_chunk | tablespace1 _hyper_4_11_chunk | tablespace1 _hyper_4_12_chunk | tablespace1 _hyper_4_13_chunk | hyper_in_space | tablespace2 SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 7 | 4 | pg_default 8 | 4 | tablespace2 INSERT INTO hyper_in_space(time, temp, device) VALUES (12, 22, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (13, 23, 3); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; tablename | tablespace -------------------+------------- _hyper_4_10_chunk | tablespace1 _hyper_4_11_chunk | tablespace1 _hyper_4_12_chunk | tablespace1 _hyper_4_13_chunk | _hyper_4_14_chunk | _hyper_4_15_chunk | tablespace2 hyper_in_space | tablespace2 SELECT detach_tablespace('pg_default', 'hyper_in_space'); detach_tablespace ------------------- 1 ALTER TABLE hyper_in_space SET TABLESPACE pg_default; SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; tablename | tablespace -------------------+------------ _hyper_4_10_chunk | _hyper_4_11_chunk | _hyper_4_12_chunk | _hyper_4_13_chunk | _hyper_4_14_chunk | _hyper_4_15_chunk | hyper_in_space | SELECT detach_tablespace('pg_default', 'hyper_in_space'); detach_tablespace ------------------- 1 DROP TABLE hyper_in_space; -- test altering tablespace on index, issue #903 CREATE TABLE series( time timestamptz not null, device int, value float, CONSTRAINT series_pk PRIMARY KEY (time, device) USING INDEX TABLESPACE tablespace1); SELECT create_hypertable('series', 'time', create_default_indexes => FALSE); create_hypertable --------------------- (5,public,series,t) INSERT INTO series VALUES ('2019-04-21 10:12', 1, 1.01); CREATE INDEX series_value ON series (value, time) TABLESPACE tablespace2; SELECT schemaname, tablename, indexname, tablespace FROM pg_indexes WHERE indexname LIKE '%series%' ORDER BY indexname; schemaname | tablename | indexname | tablespace -----------------------+-------------------+--------------------------------+------------- _timescaledb_internal | _hyper_5_16_chunk | 16_1_series_pk | tablespace1 _timescaledb_internal | _hyper_5_16_chunk | _hyper_5_16_chunk_series_value | tablespace2 public | series | series_pk | tablespace1 public | series | series_value | tablespace2 ALTER INDEX series_pk SET TABLESPACE tablespace2; CREATE INDEX ON series (time) TABLESPACE tablespace1; ALTER INDEX series_value SET TABLESPACE pg_default; INSERT INTO series VALUES ('2019-04-29 10:12', 2, 1.31); SELECT schemaname, tablename, indexname, tablespace FROM pg_indexes WHERE indexname LIKE '%series%' ORDER BY indexname; schemaname | tablename | indexname | tablespace -----------------------+-------------------+-----------------------------------+------------- _timescaledb_internal | _hyper_5_16_chunk | 16_1_series_pk | tablespace2 _timescaledb_internal | _hyper_5_17_chunk | 17_2_series_pk | tablespace2 _timescaledb_internal | _hyper_5_16_chunk | _hyper_5_16_chunk_series_time_idx | tablespace1 _timescaledb_internal | _hyper_5_16_chunk | _hyper_5_16_chunk_series_value | _timescaledb_internal | _hyper_5_17_chunk | _hyper_5_17_chunk_series_time_idx | tablespace1 _timescaledb_internal | _hyper_5_17_chunk | _hyper_5_17_chunk_series_value | public | series | series_pk | tablespace2 public | series | series_time_idx | tablespace1 public | series | series_value | DROP TABLE series; DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Make sure we handle ALTER SCHEMA RENAME for hypertable schemas \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS original_name; CREATE TABLE original_name.my_table ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('original_name.my_table','date'); create_hypertable ------------------------------ (6,original_name,my_table,t) INSERT INTO original_name.my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA original_name RENAME TO new_name; DROP TABLE new_name.my_table; DROP SCHEMA new_name; -- Now make sure schema is renamed for multiple hypertables, but not hypertables not in the schema CREATE SCHEMA IF NOT EXISTS original_name; CREATE TABLE original_name.my_table ( date timestamp with time zone NOT NULL, quantity double precision ); CREATE TABLE original_name.my_table2 ( date timestamp with time zone NOT NULL, quantity double precision ); CREATE TABLE regular_table ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('original_name.my_table','date'); create_hypertable ------------------------------ (7,original_name,my_table,t) SELECT create_hypertable('original_name.my_table2','date'); create_hypertable ------------------------------- (8,original_name,my_table2,t) SELECT create_hypertable('regular_table','date'); create_hypertable ---------------------------- (9,public,regular_table,t) INSERT INTO original_name.my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); INSERT INTO original_name.my_table2 (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); INSERT INTO regular_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA original_name RENAME TO new_name; DROP TABLE new_name.my_table; DROP TABLE new_name.my_table2; DROP TABLE regular_table; DROP SCHEMA new_name; -- These tables should also drop when we drop the whole schema CREATE SCHEMA IF NOT EXISTS original_name; CREATE TABLE original_name.my_table ( date timestamp with time zone NOT NULL, quantity double precision ); CREATE TABLE original_name.my_table2 ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('original_name.my_table','date'); create_hypertable ------------------------------- (10,original_name,my_table,t) SELECT create_hypertable('original_name.my_table2','date'); create_hypertable -------------------------------- (11,original_name,my_table2,t) INSERT INTO original_name.my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); INSERT INTO original_name.my_table2 (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA original_name RENAME TO new_name; DROP SCHEMA new_name CASCADE; NOTICE: drop cascades to 4 other objects SELECT * FROM test.relation WHERE schema = 'new_name'; schema | name | type | owner --------+------+------+------- -- Make sure we can't rename internal schemas \set ON_ERROR_STOP 0 ALTER SCHEMA _timescaledb_internal RENAME TO my_new_schema_name; ERROR: cannot rename schemas used by the TimescaleDB extension ALTER SCHEMA _timescaledb_catalog RENAME TO my_new_schema_name; ERROR: cannot rename schemas used by the TimescaleDB extension ALTER SCHEMA _timescaledb_cache RENAME TO my_new_schema_name; ERROR: cannot rename schemas used by the TimescaleDB extension ALTER SCHEMA _timescaledb_config RENAME TO my_new_schema_name; ERROR: cannot rename schemas used by the TimescaleDB extension \set ON_ERROR_STOP 1 -- Make sure we can rename associated schemas CREATE TABLE my_table ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('my_table','date', associated_schema_name => 'my_associated_schema'); create_hypertable ------------------------ (12,public,my_table,t) INSERT INTO my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA my_associated_schema RENAME TO new_associated_schema; INSERT INTO my_table (date, quantity) VALUES ('2018-08-10T23:00:00+00:00', 20); -- Make sure the schema name is changed in both catalog tables SELECT * from _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 12 | public | my_table | new_associated_schema | _hyper_12 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk from _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+--------------------+---------------------+---------+--------+----------- 24 | 12 | new_associated_schema | _hyper_12_24_chunk | | f | 0 | f 25 | 12 | new_associated_schema | _hyper_12_25_chunk | | f | 0 | f DROP TABLE my_table; -- test renaming unique constraints/indexes CREATE TABLE t_hypertable ( id INTEGER NOT NULL, time TIMESTAMPTZ NOT NULL, value FLOAT NOT NULL CHECK (value > 0), UNIQUE(id, time)); SELECT create_hypertable('t_hypertable', 'time'); create_hypertable ---------------------------- (13,public,t_hypertable,t) INSERT INTO t_hypertable AS h VALUES ( 1, '2020-01-01 00:00:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; INSERT INTO t_hypertable AS h VALUES ( 1, '2021-01-01 00:00:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; BEGIN; ALTER INDEX t_hypertable_id_time_key RENAME TO t_new_constraint; -- chunk_constraint should have updated constraint names SELECT hypertable_constraint_name, constraint_name from _timescaledb_catalog.chunk_constraint WHERE hypertable_constraint_name = 't_new_constraint' ORDER BY 1,2; hypertable_constraint_name | constraint_name ----------------------------+------------------------------------- t_new_constraint | _hyper_13_26_chunk_t_new_constraint t_new_constraint | _hyper_13_27_chunk_t_new_constraint INSERT INTO t_hypertable AS h VALUES ( 1, '2020-01-01 00:01:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; ROLLBACK; BEGIN; ALTER TABLE t_hypertable RENAME CONSTRAINT t_hypertable_id_time_key TO t_new_constraint; -- chunk_constraint should have updated constraint names SELECT hypertable_constraint_name, constraint_name from _timescaledb_catalog.chunk_constraint WHERE hypertable_constraint_name = 't_new_constraint' ORDER BY 1,2; hypertable_constraint_name | constraint_name ----------------------------+----------------------- t_new_constraint | 26_5_t_new_constraint t_new_constraint | 27_6_t_new_constraint INSERT INTO t_hypertable AS h VALUES ( 1, '2020-01-01 00:01:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; ROLLBACK; -- predicate reconstruction when attnos are different in hypertable and chunk CREATE TABLE p_hypertable (a integer not null, b integer, c integer); SELECT create_hypertable('p_hypertable', 'a', chunk_time_interval => int '3'); create_hypertable ---------------------------- (14,public,p_hypertable,t) BEGIN; ALTER TABLE p_hypertable DROP COLUMN b, ADD COLUMN d boolean; CREATE INDEX idx_ht ON p_hypertable(a, c) WHERE d = FALSE; END; INSERT INTO p_hypertable(a, c, d) VALUES (1, 1, FALSE); \d _timescaledb_internal._hyper_14_28_chunk Table "_timescaledb_internal._hyper_14_28_chunk" Column | Type | Collation | Nullable | Default --------+---------+-----------+----------+--------- a | integer | | not null | c | integer | | | d | boolean | | | Indexes: "_hyper_14_28_chunk_idx_ht" btree (a, c) WHERE NOT d "_hyper_14_28_chunk_p_hypertable_a_idx" btree (a DESC) Check constraints: "constraint_34" CHECK (a >= 0 AND a < 3) Inherits: p_hypertable DROP TABLE p_hypertable; -- check none of our hooks interact badly with normal alter view handling CREATE VIEW v1 AS SELECT random(); \set ON_ERROR_STOP 0 -- should error with unrecognized parameter ALTER VIEW v1 SET (autovacuum_enabled = false); ERROR: unrecognized parameter "autovacuum_enabled" \set ON_ERROR_STOP 1 -- issue 4474 -- test hypertable with non-default statistics target -- and chunk creation triggered by non-owner CREATE ROLE role_4474; CREATE TABLE i4474(time timestamptz NOT NULL); SELECT table_name FROM public.create_hypertable( 'i4474', 'time'); table_name ------------ i4474 GRANT SELECT, INSERT on i4474 TO role_4474; -- create chunk as owner INSERT INTO i4474 SELECT '2020-01-01'; -- set statistics ALTER TABLE i4474 ALTER COLUMN time SET statistics 10; -- create chunk as non-owner SET ROLE role_4474; INSERT INTO i4474 SELECT '2021-01-01'; RESET ROLE; DROP TABLE i4474 CASCADE; DROP ROLE role_4474; -- verify that setting replica identity works and chunks inherit the -- root table's setting CREATE TABLE replid(time timestamptz, value int); SELECT create_hypertable('replid', 'time', chunk_time_interval => interval '1 day', create_default_indexes => false); create_hypertable ---------------------- (16,public,replid,t) -- replica identity set to default SELECT relreplident FROM pg_class WHERE relname = 'replid'; relreplident -------------- d INSERT INTO replid VALUES ('2023-01-01', 1); -- the new chunk should have the same replica identity setting SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident --------------------+-------------- _hyper_16_31_chunk | d -- test change to replica identity full ALTER TABLE replid REPLICA IDENTITY FULL; SELECT relname, relreplident FROM pg_class WHERE relname = 'replid' ORDER BY relname; relname | relreplident ---------+-------------- replid | f -- the chunk's setting should also change to FULL SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident --------------------+-------------- _hyper_16_31_chunk | f -- change to replica identity index CREATE UNIQUE INDEX time_key ON replid (time); ALTER TABLE replid REPLICA IDENTITY USING INDEX time_key; SELECT relname, relreplident FROM pg_class WHERE relname = 'replid' ORDER BY relname; relname | relreplident ---------+-------------- replid | i SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident --------------------+-------------- _hyper_16_31_chunk | i SELECT indexrelid::regclass::text AS index_name FROM show_chunks('replid') chid INNER JOIN pg_index i ON (i.indrelid = chid) AND indisreplident=true ORDER BY index_name; index_name --------------------------------------------------- _timescaledb_internal._hyper_16_31_chunk_time_key INSERT INTO replid VALUES ('2023-01-02', 2); -- the new chunk will also have replica identity "index" SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident --------------------+-------------- _hyper_16_31_chunk | i _hyper_16_32_chunk | i SELECT indexrelid::regclass::text AS index_name FROM show_chunks('replid') chid INNER JOIN pg_index i ON (i.indrelid = chid) AND indisreplident=true ORDER BY index_name; index_name --------------------------------------------------- _timescaledb_internal._hyper_16_31_chunk_time_key _timescaledb_internal._hyper_16_32_chunk_time_key -- drop the replica identity index and create a new chunk. The new -- chunk should have replica identity "NOTHING" since this is the -- behavior of replica identity index when the index is dropped. DROP INDEX time_key; INSERT INTO replid VALUES ('2023-01-03', 3); -- no indexes left SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident --------------------+-------------- _hyper_16_31_chunk | i _hyper_16_32_chunk | i _hyper_16_33_chunk | n SELECT indexrelid::regclass::text AS index_name FROM show_chunks('replid') chid INNER JOIN pg_index i ON (i.indrelid = chid) AND indisreplident=true ORDER BY index_name; index_name ------------ -- Alter replica identity directly on a chunk is not supported SELECT ch AS chunk_name FROM show_chunks('replid') ch ORDER BY chunk_name LIMIT 1 \gset ALTER TABLE :chunk_name REPLICA IDENTITY FULL; ERROR: operation not supported on chunk tables ��������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/alternate_users.out������������������������������������������������0000664�0000000�0000000�00000104226�15100345067�0022571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_single.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."one_Partition" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."one_Partition" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; \c :DBNAME :ROLE_SUPERUSER CREATE SCHEMA "one_Partition" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :DBNAME :ROLE_DEFAULT_PERM_USER; SELECT * FROM create_hypertable('"public"."one_Partition"', 'timeCustom', associated_schema_name=>'one_Partition', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 1 | public | one_Partition | t --output command tags \set QUIET off BEGIN; BEGIN \COPY "one_Partition" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on \c :TEST_DBNAME :ROLE_SUPERUSER -- make sure tablespace1 exists -- since there is no CREATE TABLESPACE IF EXISTS we drop with if exists and recreate SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; --needed for ddl ops: CREATE SCHEMA IF NOT EXISTS "customSchema" AUTHORIZATION :ROLE_DEFAULT_PERM_USER_2; --needed for ROLE_DEFAULT_PERM_USER_2 to write to the 'one_Partition' schema which --is owned by ROLE_DEFAULT_PERM_USER GRANT CREATE ON SCHEMA "one_Partition" TO :ROLE_DEFAULT_PERM_USER_2; --test creating and using schema as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT * FROM test.relation WHERE schema='public' ORDER BY schema, name; schema | name | type | owner --------+---------------+-------+------------------- public | one_Partition | table | default_perm_user \set ON_ERROR_STOP 0 SELECT * FROM "one_Partition"; ERROR: permission denied for table one_Partition SELECT set_chunk_time_interval('"one_Partition"', 1::bigint); ERROR: must be owner of hypertable "one_Partition" select add_dimension('"one_Partition"', 'device_id', 2); ERROR: must be owner of hypertable "one_Partition" select attach_tablespace('tablespace1', '"one_Partition"'); ERROR: must be owner of hypertable "one_Partition" \set ON_ERROR_STOP 1 CREATE TABLE "1dim"(time timestamp, temp float); SELECT create_hypertable('"1dim"', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------- (2,public,1dim,t) INSERT INTO "1dim" VALUES('2017-01-20T09:00:01', 22.5); INSERT INTO "1dim" VALUES('2017-01-20T09:00:21', 21.2); INSERT INTO "1dim" VALUES('2017-01-20T09:00:47', 25.1); SELECT * FROM "1dim"; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:21 2017 | 21.2 Fri Jan 20 09:00:47 2017 | 25.1 \ir include/ddl_ops_1.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1, humidity numeric NULL DEFAULT 0, sensor_1 NUMERIC NULL DEFAULT 1, sensor_2 NUMERIC NOT NULL DEFAULT 1, sensor_3 NUMERIC NOT NULL DEFAULT 1, sensor_4 NUMERIC NOT NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1" (time, "Device_id"); CREATE TABLE "customSchema"."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1, humidity numeric NULL DEFAULT 0, sensor_1 NUMERIC NULL DEFAULT 1, sensor_2 NUMERIC NOT NULL DEFAULT 1, sensor_3 NUMERIC NOT NULL DEFAULT 1, sensor_4 NUMERIC NOT NULL DEFAULT 1 ); CREATE INDEX ON "customSchema"."Hypertable_1" (time, "Device_id"); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 3 | public | Hypertable_1 | t SELECT * FROM create_hypertable('"customSchema"."Hypertable_1"', 'time', NULL, 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+--------------+--------------+--------- 4 | customSchema | Hypertable_1 | t SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+--------------+---------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | one_Partition | one_Partition | _hyper_1 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | public | 1dim | _timescaledb_internal | _hyper_2 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 3 | public | Hypertable_1 | _timescaledb_internal | _hyper_3 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 4 | customSchema | Hypertable_1 | _timescaledb_internal | _hyper_4 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 CREATE INDEX ON PUBLIC."Hypertable_1" (time, "temp_c"); CREATE INDEX "ind_humidity" ON PUBLIC."Hypertable_1" (time, "humidity"); CREATE INDEX "ind_sensor_1" ON PUBLIC."Hypertable_1" (time, "sensor_1"); INSERT INTO PUBLIC."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 30, 70, 1, 2, 3, 100); CREATE UNIQUE INDEX "Unique1" ON PUBLIC."Hypertable_1" (time, "Device_id"); CREATE UNIQUE INDEX "Unique1" ON "customSchema"."Hypertable_1" (time); INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 30, 70, 1, 2, 3, 100); INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000001, 'dev1', 30, 70, 1, 2, 3, 100); SELECT * FROM test.show_indexesp('%.%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------+-----------------------------------------------------------------------------+--------------------------+------+--------+---------+-----------+------------ "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_idx" | {timeCustom} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_idx" | {timeCustom} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_idx" | {timeCustom} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_idx" | {time} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Unique1" | {time} | | t | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper_%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_2_4_chunk | _timescaledb_internal._hyper_2_4_chunk_1dim_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_Device_id_time_idx" | {Device_id,time} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_time_temp_c_idx" | {time,temp_c} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal._hyper_3_5_chunk_ind_humidity | {time,humidity} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal._hyper_3_5_chunk_ind_sensor_1 | {time,sensor_1} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Unique1" | {time,Device_id} | | t | f | f | _timescaledb_internal._hyper_4_6_chunk | _timescaledb_internal."_hyper_4_6_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_4_6_chunk | _timescaledb_internal."_hyper_4_6_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_4_6_chunk | _timescaledb_internal."_hyper_4_6_chunk_Unique1" | {time} | | t | f | f | --expect error cases \set ON_ERROR_STOP 0 INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 31, 71, 72, 4, 1, 102); psql:include/ddl_ops_1.sql:57: ERROR: duplicate key value violates unique constraint "_hyper_4_6_chunk_Unique1" CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" ("Device_id"); psql:include/ddl_ops_1.sql:58: ERROR: cannot create a unique index without the column "time" (used in partitioning) CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" (time); psql:include/ddl_ops_1.sql:59: ERROR: cannot create a unique index without the column "Device_id" (used in partitioning) CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" (sensor_1); psql:include/ddl_ops_1.sql:60: ERROR: cannot create a unique index without the column "time" (used in partitioning) UPDATE ONLY PUBLIC."Hypertable_1" SET time = 0 WHERE TRUE; DELETE FROM ONLY PUBLIC."Hypertable_1" WHERE "Device_id" = 'dev1'; \set ON_ERROR_STOP 1 CREATE TABLE my_ht (time BIGINT, val integer); SELECT * FROM create_hypertable('my_ht', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 5 | public | my_ht | t ALTER TABLE my_ht ADD COLUMN val2 integer; SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f -- Should error when adding again \set ON_ERROR_STOP 0 ALTER TABLE my_ht ADD COLUMN val2 integer; psql:include/ddl_ops_1.sql:73: ERROR: column "val2" of relation "my_ht" already exists \set ON_ERROR_STOP 1 -- Should create ALTER TABLE my_ht ADD COLUMN IF NOT EXISTS val3 integer; SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f val3 | integer | f -- Should skip and not error ALTER TABLE my_ht ADD COLUMN IF NOT EXISTS val3 integer; psql:include/ddl_ops_1.sql:81: NOTICE: column "val3" of relation "my_ht" already exists, skipping SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f val3 | integer | f -- Should drop ALTER TABLE my_ht DROP COLUMN IF EXISTS val3; SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f -- Should skip and not error ALTER TABLE my_ht DROP COLUMN IF EXISTS val3; psql:include/ddl_ops_1.sql:89: NOTICE: column "val3" of relation "my_ht" does not exist, skipping SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f --Test default index creation on create_hypertable(). --Make sure that we do not duplicate indexes that already exists -- --No existing indexes: both time and space-time indexes created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 6 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Device_id_Time_idx" | {Device_id,Time} | | f | f | f | "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --Space index exists: only time index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1_with_default_index_enabled" ("Device_id", "Time" DESC); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 7 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Device_id_Time_idx" | {Device_id,Time} | | f | f | f | "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --Time index exists, only partition index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1_with_default_index_enabled" ("Time" DESC); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 8 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Device_id_Time_idx" | {Device_id,Time} | | f | f | f | "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --No space partitioning, only time index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 9 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------------------+---------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --Disable index creation: no default indexes created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, create_default_indexes=>FALSE, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 10 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------+---------+------+--------+---------+-----------+------------ ROLLBACK; \ir include/ddl_ops_2.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN temp_f INTEGER NOT NULL DEFAULT 31; ALTER TABLE PUBLIC."Hypertable_1" DROP COLUMN temp_c; ALTER TABLE PUBLIC."Hypertable_1" DROP COLUMN sensor_4; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN humidity SET DEFAULT 100; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_1 DROP DEFAULT; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2 SET DEFAULT NULL; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_1 SET NOT NULL; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2 DROP NOT NULL; ALTER TABLE PUBLIC."Hypertable_1" RENAME COLUMN sensor_2 TO sensor_2_renamed; ALTER TABLE PUBLIC."Hypertable_1" RENAME COLUMN sensor_3 TO sensor_3_renamed; DROP INDEX "ind_sensor_1"; CREATE OR REPLACE FUNCTION empty_trigger_func() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN END $BODY$; CREATE TRIGGER test_trigger BEFORE UPDATE OR DELETE ON PUBLIC."Hypertable_1" FOR EACH STATEMENT EXECUTE FUNCTION empty_trigger_func(); ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2_renamed SET DATA TYPE int; ALTER INDEX "ind_humidity" RENAME TO "ind_humdity2"; -- Change should be reflected here SELECT * FROM test.show_indexesp('%.%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------+-----------------------------------------------------------------------------+--------------------------+------+--------+---------+-----------+------------ "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | "one_Partition"._hyper_1_1_chunk | "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_idx" | {timeCustom} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | "one_Partition"._hyper_1_2_chunk | "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_idx" | {timeCustom} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | "one_Partition"._hyper_1_3_chunk | "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_idx" | {timeCustom} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_idx" | {time} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Unique1" | {time} | | t | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_2_4_chunk | _timescaledb_internal._hyper_2_4_chunk_1dim_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Hypertable_1_Device_id_time_idx" | {Device_id,time} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal._hyper_3_5_chunk_ind_humdity2 | {time,humidity} | | f | f | f | _timescaledb_internal._hyper_3_5_chunk | _timescaledb_internal."_hyper_3_5_chunk_Unique1" | {time,Device_id} | | t | f | f | _timescaledb_internal._hyper_4_6_chunk | _timescaledb_internal."_hyper_4_6_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_4_6_chunk | _timescaledb_internal."_hyper_4_6_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_4_6_chunk | _timescaledb_internal."_hyper_4_6_chunk_Unique1" | {time} | | t | f | f | --create column with same name as previously renamed one ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN sensor_3 BIGINT NOT NULL DEFAULT 131; --create column with same name as previously dropped one ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN sensor_4 BIGINT NOT NULL DEFAULT 131; --test proper denials for all security definer functions: \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE plain_table_su (time timestamp, temp float); CREATE TABLE hypertable_su (time timestamp, temp float); SELECT create_hypertable('hypertable_su', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------- (11,public,hypertable_su,t) CREATE INDEX "ind_1" ON hypertable_su (time); INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --all of the following should produce errors \set ON_ERROR_STOP 0 SELECT create_hypertable('plain_table_su', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices ERROR: must be owner of hypertable "plain_table_su" CREATE INDEX ON plain_table_su (time, temp); ERROR: must be owner of table plain_table_su CREATE INDEX ON hypertable_su (time, temp); ERROR: must be owner of hypertable "hypertable_su" DROP INDEX "ind_1"; ERROR: must be owner of index ind_1 ALTER INDEX "ind_1" RENAME TO "ind_2"; ERROR: must be owner of index ind_1 \set ON_ERROR_STOP 1 --test that I can't do anything to a non-owned hypertable. \set ON_ERROR_STOP 0 CREATE INDEX ON hypertable_su (time, temp); ERROR: must be owner of hypertable "hypertable_su" SELECT * FROM hypertable_su; ERROR: permission denied for table hypertable_su INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); ERROR: permission denied for table hypertable_su ALTER TABLE hypertable_su ADD COLUMN val2 integer; ERROR: must be owner of table hypertable_su \set ON_ERROR_STOP 1 --grant read permissions \c :TEST_DBNAME :ROLE_SUPERUSER GRANT SELECT ON hypertable_su TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT * FROM hypertable_su; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 \set ON_ERROR_STOP 0 CREATE INDEX ON hypertable_su (time, temp); ERROR: must be owner of hypertable "hypertable_su" INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); ERROR: permission denied for table hypertable_su ALTER TABLE hypertable_su ADD COLUMN val2 integer; ERROR: must be owner of table hypertable_su \set ON_ERROR_STOP 1 --grant read, insert permissions \c :TEST_DBNAME :ROLE_SUPERUSER GRANT SELECT, INSERT ON hypertable_su TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); SELECT * FROM hypertable_su; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:01 2017 | 22.5 \set ON_ERROR_STOP 0 CREATE INDEX ON hypertable_su (time, temp); ERROR: must be owner of hypertable "hypertable_su" ALTER TABLE hypertable_su ADD COLUMN val2 integer; ERROR: must be owner of table hypertable_su \set ON_ERROR_STOP 1 --change owner \c :TEST_DBNAME :ROLE_SUPERUSER ALTER TABLE hypertable_su OWNER TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); SELECT * FROM hypertable_su; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:01 2017 | 22.5 CREATE INDEX ON hypertable_su (time, temp); ALTER TABLE hypertable_su ADD COLUMN val2 integer; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/append-15.out������������������������������������������������������0000664�0000000�0000000�00000377254�15100345067�0021100�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset SET timescaledb.enable_now_constify TO false; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- disable index only scans to avoid some flaky results SET enable_indexonlyscan TO FALSE; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE PARALLEL SAFE AS $BODY$ BEGIN RAISE NOTICE 'Stable function now_s() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_i() RETURNS timestamptz LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'Immutable function now_i() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_v() RETURNS timestamptz LANGUAGE PLPGSQL VOLATILE AS $BODY$ BEGIN RAISE NOTICE 'Volatile function now_v() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE PROCEDURE force_parallel(on_or_off bool) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('server_version_num')::int < 160000 THEN IF on_or_off THEN set force_parallel_mode = 'on'; ELSE set force_parallel_mode = 'off'; END IF; ELSE IF on_or_off THEN set debug_parallel_query = 'on'; ELSE set debug_parallel_query = 'off'; END IF; END IF; END; $$; CREATE TABLE append_test(time timestamptz, temp float, colorid integer, attr jsonb); SELECT create_hypertable('append_test', 'time', chunk_time_interval => 2628000000000); create_hypertable -------------------------- (1,public,append_test,t) -- create three chunks INSERT INTO append_test VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); VACUUM (ANALYZE) append_test; -- Create another hypertable to join with CREATE TABLE join_test(time timestamptz, temp float, colorid integer); SELECT create_hypertable('join_test', 'time', chunk_time_interval => 2628000000000); create_hypertable ------------------------ (2,public,join_test,t) INSERT INTO join_test VALUES ('2017-01-22T09:18:22', 15.2, 1), ('2017-02-22T09:18:22', 24.5, 2), ('2017-08-22T09:18:22', 23.1, 3); VACUUM (ANALYZE) join_test; -- Create another table to join with which is not a hypertable. CREATE TABLE join_test_plain(time timestamptz, temp float, colorid integer, attr jsonb); INSERT INTO join_test_plain VALUES ('2017-01-22T09:18:22', 15.2, 1, '{"a": 1}'), ('2017-02-22T09:18:22', 24.5, 2, '{"b": 2}'), ('2017-08-22T09:18:22', 23.1, 3, '{"c": 3}'); VACUUM (ANALYZE) join_test_plain; -- create hypertable with DATE time dimension CREATE TABLE metrics_date(time DATE NOT NULL); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (3,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_date; -- create hypertable with TIMESTAMP time dimension CREATE TABLE metrics_timestamp(time TIMESTAMP NOT NULL); SELECT create_hypertable('metrics_timestamp','time'); psql:include/append_load.sql:91: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (4,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_timestamp; -- create hypertable with TIMESTAMPTZ time dimension CREATE TABLE metrics_timestamptz(time TIMESTAMPTZ NOT NULL, device_id INT NOT NULL); CREATE INDEX ON metrics_timestamptz(device_id,time); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (5,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 3; VACUUM (ANALYZE) metrics_timestamptz; -- create space partitioned hypertable CREATE TABLE metrics_space(time timestamptz NOT NULL, device_id int NOT NULL, v1 float, v2 float, v3 text); SELECT create_hypertable('metrics_space','time','device_id',3); create_hypertable ---------------------------- (6,public,metrics_space,t) INSERT INTO metrics_space SELECT time, device_id, device_id + 0.25, device_id + 0.75, device_id FROM generate_series('2000-01-01'::timestamptz, '2000-01-14'::timestamptz, '5m'::interval) g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) metrics_space; -- test ChunkAppend projection #2661 CREATE TABLE i2661 ( machine_id int4 NOT NULL, "name" varchar(255) NOT NULL, "timestamp" timestamptz NOT NULL, "first" float4 NULL ); SELECT create_hypertable('i2661', 'timestamp'); psql:include/append_load.sql:123: WARNING: column type "character varying" used for "name" does not follow best practices create_hypertable -------------------- (7,public,i2661,t) INSERT INTO i2661 SELECT 1, 'speed', generate_series('2019-12-31 00:00:00', '2020-01-10 00:00:00', '2m'::interval), 0; VACUUM (ANALYZE) i2661; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be the only output of the results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations'),('timescaledb.enable_chunk_append')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on -- query should exclude all chunks with optimization on :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC; psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: append_test."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Chunks excluded during startup: 3 --query should exclude all chunks and be a MergeAppend :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC limit 1; psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Order: append_test."time" DESC Chunks excluded during startup: 3 -- when optimized, the plan should be a constraint-aware append and -- cover only one chunk. It should be a backward index scan due to -- descending index on time. Should also skip the main table, since it -- cannot hold tuples :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months'; psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- adding ORDER BY and LIMIT should turn the plan into an optimized -- ordered append plan :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time LIMIT 3; psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- no optimized plan for queries with restrictions that can be -- constified at planning time. Regular planning-time constraint -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_i() - interval '2 months' ORDER BY time; psql:include/append_query.sql:37: NOTICE: Immutable function now_i() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > ('Tue Aug 22 10:00:00 2017 PDT'::timestamp with time zone - '@ 2 mons'::interval)) -- currently, we cannot distinguish between stable and volatile -- functions as far as applying our modified plan. However, volatile -- function should not be pre-evaluated to constants, so no chunk -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_v() - interval '2 months' ORDER BY time; psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) -- prepared statement output should be the same regardless of -- optimizations PREPARE query_opt AS SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time; :PREFIX EXECUTE query_opt; psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) DEALLOCATE query_opt; -- aggregates should produce same output :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time > now_s() - interval '4 months' GROUP BY t ORDER BY t DESC; psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: (date_trunc('year'::text, append_test."time")) -> Sort (actual rows=3.00 loops=1) Sort Key: (date_trunc('year'::text, append_test."time")) DESC Sort Method: quicksort -> Result (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=3.00 loops=1) Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -- querying outside the time range should return nothing. This tests -- that ConstraintAwareAppend can handle the case when an Append node -- is turned into a Result node due to no children :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time < '2016-03-22' AND date_part('dow', time) between 1 and 5 GROUP BY t ORDER BY t DESC; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: (date_trunc('year'::text, "time")) -> Sort (actual rows=0.00 loops=1) Sort Key: (date_trunc('year'::text, "time")) DESC Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- a parameterized query can safely constify params, so won't be -- optimized by constraint-aware append since regular constraint -- exclusion works just fine PREPARE query_param AS SELECT * FROM append_test WHERE time > $1 ORDER BY time; :PREFIX EXECUTE query_param(now_s() - interval '2 months'); psql:include/append_query.sql:82: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > 'Thu Jun 22 10:00:00 2017 PDT'::timestamp with time zone) DEALLOCATE query_param; --test with cte :PREFIX WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 30 days'::interval, "time"."time")) Sort Method: quicksort -> Hash Left Join (actual rows=6.00 loops=1) Hash Cond: (time_bucket('@ 30 days'::interval, "time"."time") = data.btime) -> Function Scan on generate_series "time" (actual rows=6.00 loops=1) -> Hash (actual rows=3.00 loops=1) -> Subquery Scan on data (actual rows=3.00 loops=1) -> HashAggregate (actual rows=3.00 loops=1) Group Key: time_bucket('@ 30 days'::interval, append_test."time") -> Result (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=5.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! btime | value ------------------------------+------- Fri Mar 03 16:00:00 2017 PST | 22.5 Sun Apr 02 17:00:00 2017 PDT | Tue May 02 17:00:00 2017 PDT | 25.7 Thu Jun 01 17:00:00 2017 PDT | Sat Jul 01 17:00:00 2017 PDT | Mon Jul 31 17:00:00 2017 PDT | 34.1 -- force nested loop join with no materialization. This tests that the -- inner ConstraintAwareScan supports resetting its scan for every -- iteration of the outer relation loop set enable_hashjoin = 'off'; set enable_mergejoin = 'off'; set enable_material = 'off'; :PREFIX SELECT * FROM append_test a INNER JOIN join_test j ON (a.colorid = j.colorid) WHERE a.time > now_s() - interval '3 hours' AND j.time > now_s() - interval '3 hours'; psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (a.colorid = j.colorid) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk a_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_2_6_chunk j_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) reset enable_hashjoin; reset enable_mergejoin; reset enable_material; -- test constraint_exclusion with date time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamp time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamptz time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with space partitioning and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date AND time < '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp AND time < '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND time < '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -- test filtering on space partition :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (1,2) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=2304.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1534.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Merge Append (actual rows=770.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (VALUES(1)) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND v3 IN (VALUES('1')) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=767.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 3068 -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1534 -> Merge Append (actual rows=385.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1540 -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 770 :PREFIX SELECT * FROM metrics_space WHERE time = (VALUES ('2019-12-24' at time zone 'UTC')) AND v3 NOT IN (VALUES ('1')); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 0 Chunks excluded during runtime: 9 InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) SubPlan 2 -> Result (never executed) -> Index Scan using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -- test CURRENT_DATE -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -- test CURRENT_TIMESTAMP -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -- test now() -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -- query with tablesample and planner exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15' ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Append (actual rows=217.00 loops=1) -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) Rows Removed by Filter: 43 -- query with tablesample and startup exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15'::text::date ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_date (actual rows=217.00 loops=1) Chunks excluded during startup: 2 -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) Rows Removed by Filter: 43 -- query with tablesample, space partitioning and planner exclusion :PREFIX SELECT * FROM metrics_space TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-10'::timestamptz ORDER BY time DESC, device_id; --- QUERY PLAN --- Sort (actual rows=522.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id Sort Method: quicksort -> Append (actual rows=522.00 loops=1) -> Sample Scan on _hyper_6_30_chunk (actual rows=35.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_29_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_28_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_27_chunk (actual rows=65.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 113 -> Sample Scan on _hyper_6_26_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -> Sample Scan on _hyper_6_25_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -- test runtime exclusion -- test runtime exclusion with LATERAL and 2 hypertables :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=1.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=26787) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=4611) Index Cond: ("time" = m1."time") -- test runtime exclusion and startup exclusions :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time AND m2.time < '2000-01-10'::text::timestamptz LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=0.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=0.00 loops=26787) Chunks excluded during startup: 3 Chunks excluded during runtime: 1 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -- test runtime exclusion does not activate for constraints on non-partitioning columns -- should not use runtime exclusion :PREFIX SELECT * FROM append_test a LEFT JOIN LATERAL(SELECT * FROM join_test j WHERE a.colorid = j.colorid ORDER BY time DESC LIMIT 1) j ON true ORDER BY a.time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Order: a."time" -> Index Scan Backward using _hyper_1_1_chunk_append_test_time_idx on _hyper_1_1_chunk a_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_append_test_time_idx on _hyper_1_2_chunk a_2 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_append_test_time_idx on _hyper_1_3_chunk a_3 (never executed) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Order: j."time" DESC Hypertables excluded during runtime: 0 -> Index Scan using _hyper_2_6_chunk_join_test_time_idx on _hyper_2_6_chunk j_1 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_5_chunk_join_test_time_idx on _hyper_2_5_chunk j_2 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_4_chunk_join_test_time_idx on _hyper_2_4_chunk j_3 (actual rows=1.00 loops=1) Filter: (a.colorid = colorid) -- test runtime exclusion with LATERAL and generate_series :PREFIX SELECT g.time FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g(time) LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m WHERE m.time=g.time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop Left Join (actual rows=32.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Result (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time) m ON true; --- QUERY PLAN --- Hash Join (actual rows=96.00 loops=1) Hash Cond: (g."time" = m."time") -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Hash (actual rows=26787.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk m_1 (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk m_2 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk m_3 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk m_4 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk m_5 (actual rows=4611.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time ORDER BY time) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=96.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=3.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=3.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=3.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time>g.time + '1 day' ORDER BY time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=30.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Order: m."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=4) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -- test runtime exclusion with subquery :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE m1.time=(SELECT max(time) FROM metrics_timestamptz); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=3.00 loops=1) Chunks excluded during runtime: 4 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -- test runtime exclusion with correlated subquery :PREFIX SELECT m1.time, (SELECT m2.time FROM metrics_timestamptz m2 WHERE m2.time < m1.time ORDER BY m2.time DESC LIMIT 1) FROM metrics_timestamptz m1 WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Result (actual rows=7776.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=7776.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=3744.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) SubPlan 1 -> Limit (actual rows=1.00 loops=7776) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=7776) Order: m2."time" DESC Chunks excluded during runtime: 3 -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_1 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_2 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_4 (actual rows=1.00 loops=3741) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_5 (actual rows=1.00 loops=4035) Index Cond: ("time" < m1."time") -- test EXISTS :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE EXISTS(SELECT 1 FROM metrics_timestamptz m2 WHERE m1.time < m2.time) ORDER BY m1.time DESC limit 1000; --- QUERY PLAN --- Limit (actual rows=1000.00 loops=1) -> Nested Loop Semi Join (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=1003.00 loops=1) Order: m1."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_1 (actual rows=1003.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_2 (never executed) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_4 (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_5 (never executed) -> Append (actual rows=1.00 loops=1003) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=1003) Index Cond: ("time" > m1."time") -- test constraint exclusion for subqueries with append -- should include 2 chunks :PREFIX SELECT time FROM (SELECT time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY time) m; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=7776.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test constraint exclusion for subqueries with mergeappend -- should include 2 chunks :PREFIX SELECT device_id, time FROM (SELECT device_id, time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time) m; --- QUERY PLAN --- Custom Scan (ConstraintAwareAppend) (actual rows=7776.00 loops=1) Hypertable: metrics_timestamptz Chunks excluded during startup: 3 -> Merge Append (actual rows=7776.00 loops=1) Sort Key: metrics_timestamptz.device_id, metrics_timestamptz."time" -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test LIMIT pushdown -- no aggregates/window functions/SRF should pushdown limit :PREFIX SELECT FROM metrics_timestamptz ORDER BY time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (never executed) -- aggregates should prevent pushdown :PREFIX SELECT count(*) FROM metrics_timestamptz LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT count(*) FROM metrics_space LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- HAVING should prevent pushdown :PREFIX SELECT 1 FROM metrics_timestamptz HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT 1 FROM metrics_space HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- DISTINCT should prevent pushdown SET enable_hashagg TO false; :PREFIX SELECT DISTINCT device_id FROM metrics_timestamptz ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=17859.00 loops=1) Sort Key: metrics_timestamptz.device_id -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=2689.00 loops=1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_19_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_20_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_21_chunk (actual rows=3075.00 loops=1) :PREFIX SELECT DISTINCT device_id FROM metrics_space ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=7491.00 loops=1) Sort Key: metrics_space.device_id -> Index Scan using _hyper_6_22_chunk_metrics_space_device_id_time_idx on _hyper_6_22_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_23_chunk_metrics_space_device_id_time_idx on _hyper_6_23_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_24_chunk_metrics_space_device_id_time_idx on _hyper_6_24_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_26_chunk_metrics_space_device_id_time_idx on _hyper_6_26_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_27_chunk_metrics_space_device_id_time_idx on _hyper_6_27_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_29_chunk_metrics_space_device_id_time_idx on _hyper_6_29_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_30_chunk_metrics_space_device_id_time_idx on _hyper_6_30_chunk (actual rows=1.00 loops=1) RESET enable_hashagg; -- JOINs should prevent pushdown -- when LIMIT gets pushed to a Sort node it will switch to top-N heapsort -- if more tuples then LIMIT are requested this will trigger an error -- to trigger this we need a Sort node that is below ChunkAppend CREATE TABLE join_limit (time timestamptz, device_id int); SELECT table_name FROM create_hypertable('join_limit','time',create_default_indexes:=false); table_name ------------ join_limit CREATE INDEX ON join_limit(time,device_id); INSERT INTO join_limit SELECT time, device_id FROM generate_series('2000-01-01'::timestamptz,'2000-01-21','30m') g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) join_limit; -- get 2nd chunk oid SELECT tableoid AS "CHUNK_OID" FROM join_limit WHERE time > '2000-01-07' ORDER BY time LIMIT 1 \gset --get index name for 2nd chunk SELECT indexrelid::regclass AS "INDEX_NAME" FROM pg_index WHERE indrelid = :CHUNK_OID \gset DROP INDEX :INDEX_NAME; :PREFIX SELECT * FROM metrics_timestamptz m1 INNER JOIN join_limit m2 ON m1.time = m2.time AND m1.device_id=m2.device_id WHERE m1.time > '2000-01-07' ORDER BY m1.time, m1.device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Join (actual rows=3.00 loops=1) Merge Cond: (m2."time" = m1."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 4 -> Custom Scan (ChunkAppend) on join_limit m2 (actual rows=3.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Seq Scan on _hyper_8_35_chunk m2_1 (actual rows=2710.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 650 -> Index Scan using _hyper_8_36_chunk_join_limit_time_device_id_idx on _hyper_8_36_chunk m2_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_join_limit_time_device_id_idx on _hyper_8_37_chunk m2_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=22.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=19.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_1 (actual rows=19.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_4 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) DROP TABLE join_limit; -- test ChunkAppend projection #2661 :PREFIX SELECT ts.timestamp, ht.timestamp FROM ( SELECT generate_series( to_timestamp(FLOOR(EXTRACT (EPOCH FROM '2020-01-01T00:01:00Z'::timestamp) / 300) * 300) AT TIME ZONE 'UTC', '2020-01-01T01:00:00Z', '5 minutes'::interval ) AS timestamp ) ts LEFT JOIN i2661 ht ON (FLOOR(EXTRACT (EPOCH FROM ht."timestamp") / 300) * 300 = EXTRACT (EPOCH FROM ts.timestamp)) AND ht.timestamp > '2019-12-30T00:00:00Z'::timestamp ORDER BY ts.timestamp, ht.timestamp; --- QUERY PLAN --- Sort (actual rows=33.00 loops=1) Sort Key: ts."timestamp", ht."timestamp" Sort Method: quicksort -> Merge Left Join (actual rows=33.00 loops=1) Merge Cond: ((EXTRACT(epoch FROM ts."timestamp")) = ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric))) -> Sort (actual rows=13.00 loops=1) Sort Key: (EXTRACT(epoch FROM ts."timestamp")) Sort Method: quicksort -> Subquery Scan on ts (actual rows=13.00 loops=1) -> ProjectSet (actual rows=13.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Sort (actual rows=514.00 loops=1) Sort Key: ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric)) Sort Method: quicksort -> Result (actual rows=7201.00 loops=1) -> Custom Scan (ChunkAppend) on i2661 ht (actual rows=7201.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_7_31_chunk ht_1 (actual rows=1200.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_32_chunk ht_2 (actual rows=5040.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_33_chunk ht_3 (actual rows=961.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -- #3030 test chunkappend keeps pathkeys when subpath is append -- on PG11 this will not use ChunkAppend but MergeAppend SET enable_seqscan TO FALSE; CREATE TABLE i3030(time timestamptz NOT NULL, a int, b int); SELECT table_name FROM create_hypertable('i3030', 'time', create_default_indexes=>false); table_name ------------ i3030 CREATE INDEX ON i3030(a,time); INSERT INTO i3030 (time,a) SELECT time, a FROM generate_series('2000-01-01'::timestamptz,'2000-01-01 3:00:00'::timestamptz,'1min'::interval) time, generate_series(1,30) a; VACUUM (ANALYZE) i3030; :PREFIX SELECT * FROM i3030 where time BETWEEN '2000-01-01'::text::timestamptz AND '2000-01-03'::text::timestamptz ORDER BY a,time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on i3030 (actual rows=1.00 loops=1) Order: i3030.a, i3030."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_9_38_chunk_i3030_a_time_idx on _hyper_9_38_chunk (actual rows=1.00 loops=1) Index Cond: (("time" >= ('2000-01-01'::cstring)::timestamp with time zone) AND ("time" <= ('2000-01-03'::cstring)::timestamp with time zone)) DROP TABLE i3030; RESET enable_seqscan; --parent runtime exclusion tests: --optimization works with ANY (array) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 (returns $0) -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ($0)) --optimization does not work for ANY subquery (does not force an initplan) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT attr FROM join_test_plain WHERE temp > 100)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Join Filter: (a.attr @> join_test_plain.attr) -> Append (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=1.00 loops=1) -> Materialize (actual rows=0.00 loops=5) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 --works on any strict operator without ANY :PREFIX SELECT * FROM append_test a WHERE a.attr @> (SELECT attr FROM join_test_plain WHERE temp > 100 limit 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 (returns $0) -> Limit (actual rows=0.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> $0) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> $0) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> $0) --optimization works with function calls CREATE OR REPLACE FUNCTION select_tag(_min_temp int) RETURNS jsonb[] LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > _min_temp $function$; :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT select_tag(100))::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ($0)) --optimization does not work when result is null :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT array_agg(attr) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 0 InitPlan 1 (returns $0) -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=0.00 loops=1) Filter: (attr @> ANY ($0)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=0.00 loops=1) Filter: (attr @> ANY ($0)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=0.00 loops=1) Filter: (attr @> ANY ($0)) Rows Removed by Filter: 1 -- Test that ConstraintAwareAppend properly locks relations in -- parallel query mode set timescaledb.enable_chunk_append=false; call force_parallel(true); :PREFIX select time, avg(temp), colorid from append_test where time > now_s() - interval '3 months 20 days' group by time, colorid; psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Gather (actual rows=3.00 loops=1) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> HashAggregate (actual rows=3.00 loops=1) Group Key: append_test."time", append_test.colorid -> Custom Scan (ConstraintAwareAppend) (actual rows=3.00 loops=1) Hypertable: append_test Chunks excluded during startup: 1 -> Append (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) reset timescaledb.enable_chunk_append; reset max_parallel_workers_per_gather; call force_parallel(false); --generate the results into two different files \set ECHO errors --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on --- Unoptimized results +++ Optimized results @@ -1,7 +1,7 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off - timescaledb.enable_chunk_append | on + timescaledb.enable_optimizations | on + timescaledb.enable_chunk_append | off time | temp | colorid | attr ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/append-16.out������������������������������������������������������0000664�0000000�0000000�00000377254�15100345067�0021101�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset SET timescaledb.enable_now_constify TO false; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- disable index only scans to avoid some flaky results SET enable_indexonlyscan TO FALSE; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE PARALLEL SAFE AS $BODY$ BEGIN RAISE NOTICE 'Stable function now_s() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_i() RETURNS timestamptz LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'Immutable function now_i() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_v() RETURNS timestamptz LANGUAGE PLPGSQL VOLATILE AS $BODY$ BEGIN RAISE NOTICE 'Volatile function now_v() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE PROCEDURE force_parallel(on_or_off bool) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('server_version_num')::int < 160000 THEN IF on_or_off THEN set force_parallel_mode = 'on'; ELSE set force_parallel_mode = 'off'; END IF; ELSE IF on_or_off THEN set debug_parallel_query = 'on'; ELSE set debug_parallel_query = 'off'; END IF; END IF; END; $$; CREATE TABLE append_test(time timestamptz, temp float, colorid integer, attr jsonb); SELECT create_hypertable('append_test', 'time', chunk_time_interval => 2628000000000); create_hypertable -------------------------- (1,public,append_test,t) -- create three chunks INSERT INTO append_test VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); VACUUM (ANALYZE) append_test; -- Create another hypertable to join with CREATE TABLE join_test(time timestamptz, temp float, colorid integer); SELECT create_hypertable('join_test', 'time', chunk_time_interval => 2628000000000); create_hypertable ------------------------ (2,public,join_test,t) INSERT INTO join_test VALUES ('2017-01-22T09:18:22', 15.2, 1), ('2017-02-22T09:18:22', 24.5, 2), ('2017-08-22T09:18:22', 23.1, 3); VACUUM (ANALYZE) join_test; -- Create another table to join with which is not a hypertable. CREATE TABLE join_test_plain(time timestamptz, temp float, colorid integer, attr jsonb); INSERT INTO join_test_plain VALUES ('2017-01-22T09:18:22', 15.2, 1, '{"a": 1}'), ('2017-02-22T09:18:22', 24.5, 2, '{"b": 2}'), ('2017-08-22T09:18:22', 23.1, 3, '{"c": 3}'); VACUUM (ANALYZE) join_test_plain; -- create hypertable with DATE time dimension CREATE TABLE metrics_date(time DATE NOT NULL); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (3,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_date; -- create hypertable with TIMESTAMP time dimension CREATE TABLE metrics_timestamp(time TIMESTAMP NOT NULL); SELECT create_hypertable('metrics_timestamp','time'); psql:include/append_load.sql:91: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (4,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_timestamp; -- create hypertable with TIMESTAMPTZ time dimension CREATE TABLE metrics_timestamptz(time TIMESTAMPTZ NOT NULL, device_id INT NOT NULL); CREATE INDEX ON metrics_timestamptz(device_id,time); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (5,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 3; VACUUM (ANALYZE) metrics_timestamptz; -- create space partitioned hypertable CREATE TABLE metrics_space(time timestamptz NOT NULL, device_id int NOT NULL, v1 float, v2 float, v3 text); SELECT create_hypertable('metrics_space','time','device_id',3); create_hypertable ---------------------------- (6,public,metrics_space,t) INSERT INTO metrics_space SELECT time, device_id, device_id + 0.25, device_id + 0.75, device_id FROM generate_series('2000-01-01'::timestamptz, '2000-01-14'::timestamptz, '5m'::interval) g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) metrics_space; -- test ChunkAppend projection #2661 CREATE TABLE i2661 ( machine_id int4 NOT NULL, "name" varchar(255) NOT NULL, "timestamp" timestamptz NOT NULL, "first" float4 NULL ); SELECT create_hypertable('i2661', 'timestamp'); psql:include/append_load.sql:123: WARNING: column type "character varying" used for "name" does not follow best practices create_hypertable -------------------- (7,public,i2661,t) INSERT INTO i2661 SELECT 1, 'speed', generate_series('2019-12-31 00:00:00', '2020-01-10 00:00:00', '2m'::interval), 0; VACUUM (ANALYZE) i2661; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be the only output of the results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations'),('timescaledb.enable_chunk_append')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on -- query should exclude all chunks with optimization on :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC; psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: append_test."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Chunks excluded during startup: 3 --query should exclude all chunks and be a MergeAppend :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC limit 1; psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Order: append_test."time" DESC Chunks excluded during startup: 3 -- when optimized, the plan should be a constraint-aware append and -- cover only one chunk. It should be a backward index scan due to -- descending index on time. Should also skip the main table, since it -- cannot hold tuples :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months'; psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- adding ORDER BY and LIMIT should turn the plan into an optimized -- ordered append plan :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time LIMIT 3; psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- no optimized plan for queries with restrictions that can be -- constified at planning time. Regular planning-time constraint -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_i() - interval '2 months' ORDER BY time; psql:include/append_query.sql:37: NOTICE: Immutable function now_i() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > ('Tue Aug 22 10:00:00 2017 PDT'::timestamp with time zone - '@ 2 mons'::interval)) -- currently, we cannot distinguish between stable and volatile -- functions as far as applying our modified plan. However, volatile -- function should not be pre-evaluated to constants, so no chunk -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_v() - interval '2 months' ORDER BY time; psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) -- prepared statement output should be the same regardless of -- optimizations PREPARE query_opt AS SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time; :PREFIX EXECUTE query_opt; psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) DEALLOCATE query_opt; -- aggregates should produce same output :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time > now_s() - interval '4 months' GROUP BY t ORDER BY t DESC; psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: (date_trunc('year'::text, append_test."time")) -> Sort (actual rows=3.00 loops=1) Sort Key: (date_trunc('year'::text, append_test."time")) DESC Sort Method: quicksort -> Result (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=3.00 loops=1) Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -- querying outside the time range should return nothing. This tests -- that ConstraintAwareAppend can handle the case when an Append node -- is turned into a Result node due to no children :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time < '2016-03-22' AND date_part('dow', time) between 1 and 5 GROUP BY t ORDER BY t DESC; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: (date_trunc('year'::text, "time")) -> Sort (actual rows=0.00 loops=1) Sort Key: (date_trunc('year'::text, "time")) DESC Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- a parameterized query can safely constify params, so won't be -- optimized by constraint-aware append since regular constraint -- exclusion works just fine PREPARE query_param AS SELECT * FROM append_test WHERE time > $1 ORDER BY time; :PREFIX EXECUTE query_param(now_s() - interval '2 months'); psql:include/append_query.sql:82: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > 'Thu Jun 22 10:00:00 2017 PDT'::timestamp with time zone) DEALLOCATE query_param; --test with cte :PREFIX WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 30 days'::interval, "time"."time")) Sort Method: quicksort -> Hash Left Join (actual rows=6.00 loops=1) Hash Cond: (time_bucket('@ 30 days'::interval, "time"."time") = data.btime) -> Function Scan on generate_series "time" (actual rows=6.00 loops=1) -> Hash (actual rows=3.00 loops=1) -> Subquery Scan on data (actual rows=3.00 loops=1) -> HashAggregate (actual rows=3.00 loops=1) Group Key: time_bucket('@ 30 days'::interval, append_test."time") -> Result (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=5.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! btime | value ------------------------------+------- Fri Mar 03 16:00:00 2017 PST | 22.5 Sun Apr 02 17:00:00 2017 PDT | Tue May 02 17:00:00 2017 PDT | 25.7 Thu Jun 01 17:00:00 2017 PDT | Sat Jul 01 17:00:00 2017 PDT | Mon Jul 31 17:00:00 2017 PDT | 34.1 -- force nested loop join with no materialization. This tests that the -- inner ConstraintAwareScan supports resetting its scan for every -- iteration of the outer relation loop set enable_hashjoin = 'off'; set enable_mergejoin = 'off'; set enable_material = 'off'; :PREFIX SELECT * FROM append_test a INNER JOIN join_test j ON (a.colorid = j.colorid) WHERE a.time > now_s() - interval '3 hours' AND j.time > now_s() - interval '3 hours'; psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (a.colorid = j.colorid) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk a_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_2_6_chunk j_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) reset enable_hashjoin; reset enable_mergejoin; reset enable_material; -- test constraint_exclusion with date time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamp time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamptz time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with space partitioning and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date AND time < '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp AND time < '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND time < '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -- test filtering on space partition :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (1,2) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=2304.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1534.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Merge Append (actual rows=770.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (VALUES(1)) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND v3 IN (VALUES('1')) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=767.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 3068 -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1534 -> Merge Append (actual rows=385.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1540 -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 770 :PREFIX SELECT * FROM metrics_space WHERE time = (VALUES ('2019-12-24' at time zone 'UTC')) AND v3 NOT IN (VALUES ('1')); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 0 Chunks excluded during runtime: 9 InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) SubPlan 2 -> Result (never executed) -> Index Scan using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -> Index Scan using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (never executed) Index Cond: ("time" = $0) Filter: (NOT (hashed SubPlan 2)) -- test CURRENT_DATE -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -- test CURRENT_TIMESTAMP -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -- test now() -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -- query with tablesample and planner exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15' ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Append (actual rows=217.00 loops=1) -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) Rows Removed by Filter: 43 -- query with tablesample and startup exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15'::text::date ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_date (actual rows=217.00 loops=1) Chunks excluded during startup: 2 -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) Rows Removed by Filter: 43 -- query with tablesample, space partitioning and planner exclusion :PREFIX SELECT * FROM metrics_space TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-10'::timestamptz ORDER BY time DESC, device_id; --- QUERY PLAN --- Sort (actual rows=522.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id Sort Method: quicksort -> Append (actual rows=522.00 loops=1) -> Sample Scan on _hyper_6_30_chunk (actual rows=35.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_29_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_28_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_27_chunk (actual rows=65.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 113 -> Sample Scan on _hyper_6_26_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -> Sample Scan on _hyper_6_25_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -- test runtime exclusion -- test runtime exclusion with LATERAL and 2 hypertables :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=1.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=26787) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=4611) Index Cond: ("time" = m1."time") -- test runtime exclusion and startup exclusions :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time AND m2.time < '2000-01-10'::text::timestamptz LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=0.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=0.00 loops=26787) Chunks excluded during startup: 3 Chunks excluded during runtime: 1 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -- test runtime exclusion does not activate for constraints on non-partitioning columns -- should not use runtime exclusion :PREFIX SELECT * FROM append_test a LEFT JOIN LATERAL(SELECT * FROM join_test j WHERE a.colorid = j.colorid ORDER BY time DESC LIMIT 1) j ON true ORDER BY a.time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Order: a."time" -> Index Scan Backward using _hyper_1_1_chunk_append_test_time_idx on _hyper_1_1_chunk a_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_append_test_time_idx on _hyper_1_2_chunk a_2 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_append_test_time_idx on _hyper_1_3_chunk a_3 (never executed) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Order: j."time" DESC Hypertables excluded during runtime: 0 -> Index Scan using _hyper_2_6_chunk_join_test_time_idx on _hyper_2_6_chunk j_1 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_5_chunk_join_test_time_idx on _hyper_2_5_chunk j_2 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_4_chunk_join_test_time_idx on _hyper_2_4_chunk j_3 (actual rows=1.00 loops=1) Filter: (a.colorid = colorid) -- test runtime exclusion with LATERAL and generate_series :PREFIX SELECT g.time FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g(time) LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m WHERE m.time=g.time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop Left Join (actual rows=32.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Result (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time) m ON true; --- QUERY PLAN --- Hash Join (actual rows=96.00 loops=1) Hash Cond: (g."time" = m."time") -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Hash (actual rows=26787.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk m_1 (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk m_2 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk m_3 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk m_4 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk m_5 (actual rows=4611.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time ORDER BY time) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=96.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=3.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=3.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=3.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time>g.time + '1 day' ORDER BY time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=30.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Order: m."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=4) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -- test runtime exclusion with subquery :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE m1.time=(SELECT max(time) FROM metrics_timestamptz); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=3.00 loops=1) Chunks excluded during runtime: 4 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (never executed) Index Cond: ("time" = $1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -- test runtime exclusion with correlated subquery :PREFIX SELECT m1.time, (SELECT m2.time FROM metrics_timestamptz m2 WHERE m2.time < m1.time ORDER BY m2.time DESC LIMIT 1) FROM metrics_timestamptz m1 WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Result (actual rows=7776.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=7776.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=3744.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) SubPlan 1 -> Limit (actual rows=1.00 loops=7776) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=7776) Order: m2."time" DESC Chunks excluded during runtime: 3 -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_1 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_2 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_4 (actual rows=1.00 loops=3741) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_5 (actual rows=1.00 loops=4035) Index Cond: ("time" < m1."time") -- test EXISTS :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE EXISTS(SELECT 1 FROM metrics_timestamptz m2 WHERE m1.time < m2.time) ORDER BY m1.time DESC limit 1000; --- QUERY PLAN --- Limit (actual rows=1000.00 loops=1) -> Nested Loop Semi Join (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=1003.00 loops=1) Order: m1."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_1 (actual rows=1003.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_2 (never executed) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_4 (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_5 (never executed) -> Append (actual rows=1.00 loops=1003) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=1003) Index Cond: ("time" > m1."time") -- test constraint exclusion for subqueries with append -- should include 2 chunks :PREFIX SELECT time FROM (SELECT time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY time) m; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=7776.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test constraint exclusion for subqueries with mergeappend -- should include 2 chunks :PREFIX SELECT device_id, time FROM (SELECT device_id, time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time) m; --- QUERY PLAN --- Custom Scan (ConstraintAwareAppend) (actual rows=7776.00 loops=1) Hypertable: metrics_timestamptz Chunks excluded during startup: 3 -> Merge Append (actual rows=7776.00 loops=1) Sort Key: metrics_timestamptz.device_id, metrics_timestamptz."time" -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test LIMIT pushdown -- no aggregates/window functions/SRF should pushdown limit :PREFIX SELECT FROM metrics_timestamptz ORDER BY time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (never executed) -- aggregates should prevent pushdown :PREFIX SELECT count(*) FROM metrics_timestamptz LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT count(*) FROM metrics_space LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- HAVING should prevent pushdown :PREFIX SELECT 1 FROM metrics_timestamptz HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT 1 FROM metrics_space HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- DISTINCT should prevent pushdown SET enable_hashagg TO false; :PREFIX SELECT DISTINCT device_id FROM metrics_timestamptz ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=17859.00 loops=1) Sort Key: metrics_timestamptz.device_id -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=2689.00 loops=1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_19_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_20_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_21_chunk (actual rows=3075.00 loops=1) :PREFIX SELECT DISTINCT device_id FROM metrics_space ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=7491.00 loops=1) Sort Key: metrics_space.device_id -> Index Scan using _hyper_6_22_chunk_metrics_space_device_id_time_idx on _hyper_6_22_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_23_chunk_metrics_space_device_id_time_idx on _hyper_6_23_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_24_chunk_metrics_space_device_id_time_idx on _hyper_6_24_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_26_chunk_metrics_space_device_id_time_idx on _hyper_6_26_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_27_chunk_metrics_space_device_id_time_idx on _hyper_6_27_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_29_chunk_metrics_space_device_id_time_idx on _hyper_6_29_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_30_chunk_metrics_space_device_id_time_idx on _hyper_6_30_chunk (actual rows=1.00 loops=1) RESET enable_hashagg; -- JOINs should prevent pushdown -- when LIMIT gets pushed to a Sort node it will switch to top-N heapsort -- if more tuples then LIMIT are requested this will trigger an error -- to trigger this we need a Sort node that is below ChunkAppend CREATE TABLE join_limit (time timestamptz, device_id int); SELECT table_name FROM create_hypertable('join_limit','time',create_default_indexes:=false); table_name ------------ join_limit CREATE INDEX ON join_limit(time,device_id); INSERT INTO join_limit SELECT time, device_id FROM generate_series('2000-01-01'::timestamptz,'2000-01-21','30m') g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) join_limit; -- get 2nd chunk oid SELECT tableoid AS "CHUNK_OID" FROM join_limit WHERE time > '2000-01-07' ORDER BY time LIMIT 1 \gset --get index name for 2nd chunk SELECT indexrelid::regclass AS "INDEX_NAME" FROM pg_index WHERE indrelid = :CHUNK_OID \gset DROP INDEX :INDEX_NAME; :PREFIX SELECT * FROM metrics_timestamptz m1 INNER JOIN join_limit m2 ON m1.time = m2.time AND m1.device_id=m2.device_id WHERE m1.time > '2000-01-07' ORDER BY m1.time, m1.device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Join (actual rows=3.00 loops=1) Merge Cond: (m2."time" = m1."time") Join Filter: (m2.device_id = m1.device_id) Rows Removed by Join Filter: 4 -> Custom Scan (ChunkAppend) on join_limit m2 (actual rows=3.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Seq Scan on _hyper_8_35_chunk m2_1 (actual rows=2710.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 650 -> Index Scan using _hyper_8_36_chunk_join_limit_time_device_id_idx on _hyper_8_36_chunk m2_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_join_limit_time_device_id_idx on _hyper_8_37_chunk m2_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=22.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=19.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_1 (actual rows=19.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_4 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) DROP TABLE join_limit; -- test ChunkAppend projection #2661 :PREFIX SELECT ts.timestamp, ht.timestamp FROM ( SELECT generate_series( to_timestamp(FLOOR(EXTRACT (EPOCH FROM '2020-01-01T00:01:00Z'::timestamp) / 300) * 300) AT TIME ZONE 'UTC', '2020-01-01T01:00:00Z', '5 minutes'::interval ) AS timestamp ) ts LEFT JOIN i2661 ht ON (FLOOR(EXTRACT (EPOCH FROM ht."timestamp") / 300) * 300 = EXTRACT (EPOCH FROM ts.timestamp)) AND ht.timestamp > '2019-12-30T00:00:00Z'::timestamp ORDER BY ts.timestamp, ht.timestamp; --- QUERY PLAN --- Sort (actual rows=33.00 loops=1) Sort Key: ts."timestamp", ht."timestamp" Sort Method: quicksort -> Merge Left Join (actual rows=33.00 loops=1) Merge Cond: ((EXTRACT(epoch FROM ts."timestamp")) = ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric))) -> Sort (actual rows=13.00 loops=1) Sort Key: (EXTRACT(epoch FROM ts."timestamp")) Sort Method: quicksort -> Subquery Scan on ts (actual rows=13.00 loops=1) -> ProjectSet (actual rows=13.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Sort (actual rows=514.00 loops=1) Sort Key: ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric)) Sort Method: quicksort -> Result (actual rows=7201.00 loops=1) -> Custom Scan (ChunkAppend) on i2661 ht (actual rows=7201.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_7_31_chunk ht_1 (actual rows=1200.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_32_chunk ht_2 (actual rows=5040.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_33_chunk ht_3 (actual rows=961.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -- #3030 test chunkappend keeps pathkeys when subpath is append -- on PG11 this will not use ChunkAppend but MergeAppend SET enable_seqscan TO FALSE; CREATE TABLE i3030(time timestamptz NOT NULL, a int, b int); SELECT table_name FROM create_hypertable('i3030', 'time', create_default_indexes=>false); table_name ------------ i3030 CREATE INDEX ON i3030(a,time); INSERT INTO i3030 (time,a) SELECT time, a FROM generate_series('2000-01-01'::timestamptz,'2000-01-01 3:00:00'::timestamptz,'1min'::interval) time, generate_series(1,30) a; VACUUM (ANALYZE) i3030; :PREFIX SELECT * FROM i3030 where time BETWEEN '2000-01-01'::text::timestamptz AND '2000-01-03'::text::timestamptz ORDER BY a,time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on i3030 (actual rows=1.00 loops=1) Order: i3030.a, i3030."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_9_38_chunk_i3030_a_time_idx on _hyper_9_38_chunk (actual rows=1.00 loops=1) Index Cond: (("time" >= ('2000-01-01'::cstring)::timestamp with time zone) AND ("time" <= ('2000-01-03'::cstring)::timestamp with time zone)) DROP TABLE i3030; RESET enable_seqscan; --parent runtime exclusion tests: --optimization works with ANY (array) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 (returns $0) -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ($0)) --optimization does not work for ANY subquery (does not force an initplan) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT attr FROM join_test_plain WHERE temp > 100)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Join Filter: (a.attr @> join_test_plain.attr) -> Append (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=1.00 loops=1) -> Materialize (actual rows=0.00 loops=5) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 --works on any strict operator without ANY :PREFIX SELECT * FROM append_test a WHERE a.attr @> (SELECT attr FROM join_test_plain WHERE temp > 100 limit 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 (returns $0) -> Limit (actual rows=0.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> $0) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> $0) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> $0) --optimization works with function calls CREATE OR REPLACE FUNCTION select_tag(_min_temp int) RETURNS jsonb[] LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > _min_temp $function$; :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT select_tag(100))::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ($0)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ($0)) --optimization does not work when result is null :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT array_agg(attr) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 0 InitPlan 1 (returns $0) -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=0.00 loops=1) Filter: (attr @> ANY ($0)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=0.00 loops=1) Filter: (attr @> ANY ($0)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=0.00 loops=1) Filter: (attr @> ANY ($0)) Rows Removed by Filter: 1 -- Test that ConstraintAwareAppend properly locks relations in -- parallel query mode set timescaledb.enable_chunk_append=false; call force_parallel(true); :PREFIX select time, avg(temp), colorid from append_test where time > now_s() - interval '3 months 20 days' group by time, colorid; psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Gather (actual rows=3.00 loops=1) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> HashAggregate (actual rows=3.00 loops=1) Group Key: append_test."time", append_test.colorid -> Custom Scan (ConstraintAwareAppend) (actual rows=3.00 loops=1) Hypertable: append_test Chunks excluded during startup: 1 -> Append (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) reset timescaledb.enable_chunk_append; reset max_parallel_workers_per_gather; call force_parallel(false); --generate the results into two different files \set ECHO errors --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on --- Unoptimized results +++ Optimized results @@ -1,7 +1,7 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off - timescaledb.enable_chunk_append | on + timescaledb.enable_optimizations | on + timescaledb.enable_chunk_append | off time | temp | colorid | attr ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/append-17.out������������������������������������������������������0000664�0000000�0000000�00000377471�15100345067�0021103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset SET timescaledb.enable_now_constify TO false; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- disable index only scans to avoid some flaky results SET enable_indexonlyscan TO FALSE; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE PARALLEL SAFE AS $BODY$ BEGIN RAISE NOTICE 'Stable function now_s() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_i() RETURNS timestamptz LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'Immutable function now_i() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_v() RETURNS timestamptz LANGUAGE PLPGSQL VOLATILE AS $BODY$ BEGIN RAISE NOTICE 'Volatile function now_v() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE PROCEDURE force_parallel(on_or_off bool) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('server_version_num')::int < 160000 THEN IF on_or_off THEN set force_parallel_mode = 'on'; ELSE set force_parallel_mode = 'off'; END IF; ELSE IF on_or_off THEN set debug_parallel_query = 'on'; ELSE set debug_parallel_query = 'off'; END IF; END IF; END; $$; CREATE TABLE append_test(time timestamptz, temp float, colorid integer, attr jsonb); SELECT create_hypertable('append_test', 'time', chunk_time_interval => 2628000000000); create_hypertable -------------------------- (1,public,append_test,t) -- create three chunks INSERT INTO append_test VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); VACUUM (ANALYZE) append_test; -- Create another hypertable to join with CREATE TABLE join_test(time timestamptz, temp float, colorid integer); SELECT create_hypertable('join_test', 'time', chunk_time_interval => 2628000000000); create_hypertable ------------------------ (2,public,join_test,t) INSERT INTO join_test VALUES ('2017-01-22T09:18:22', 15.2, 1), ('2017-02-22T09:18:22', 24.5, 2), ('2017-08-22T09:18:22', 23.1, 3); VACUUM (ANALYZE) join_test; -- Create another table to join with which is not a hypertable. CREATE TABLE join_test_plain(time timestamptz, temp float, colorid integer, attr jsonb); INSERT INTO join_test_plain VALUES ('2017-01-22T09:18:22', 15.2, 1, '{"a": 1}'), ('2017-02-22T09:18:22', 24.5, 2, '{"b": 2}'), ('2017-08-22T09:18:22', 23.1, 3, '{"c": 3}'); VACUUM (ANALYZE) join_test_plain; -- create hypertable with DATE time dimension CREATE TABLE metrics_date(time DATE NOT NULL); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (3,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_date; -- create hypertable with TIMESTAMP time dimension CREATE TABLE metrics_timestamp(time TIMESTAMP NOT NULL); SELECT create_hypertable('metrics_timestamp','time'); psql:include/append_load.sql:91: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (4,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_timestamp; -- create hypertable with TIMESTAMPTZ time dimension CREATE TABLE metrics_timestamptz(time TIMESTAMPTZ NOT NULL, device_id INT NOT NULL); CREATE INDEX ON metrics_timestamptz(device_id,time); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (5,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 3; VACUUM (ANALYZE) metrics_timestamptz; -- create space partitioned hypertable CREATE TABLE metrics_space(time timestamptz NOT NULL, device_id int NOT NULL, v1 float, v2 float, v3 text); SELECT create_hypertable('metrics_space','time','device_id',3); create_hypertable ---------------------------- (6,public,metrics_space,t) INSERT INTO metrics_space SELECT time, device_id, device_id + 0.25, device_id + 0.75, device_id FROM generate_series('2000-01-01'::timestamptz, '2000-01-14'::timestamptz, '5m'::interval) g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) metrics_space; -- test ChunkAppend projection #2661 CREATE TABLE i2661 ( machine_id int4 NOT NULL, "name" varchar(255) NOT NULL, "timestamp" timestamptz NOT NULL, "first" float4 NULL ); SELECT create_hypertable('i2661', 'timestamp'); psql:include/append_load.sql:123: WARNING: column type "character varying" used for "name" does not follow best practices create_hypertable -------------------- (7,public,i2661,t) INSERT INTO i2661 SELECT 1, 'speed', generate_series('2019-12-31 00:00:00', '2020-01-10 00:00:00', '2m'::interval), 0; VACUUM (ANALYZE) i2661; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be the only output of the results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations'),('timescaledb.enable_chunk_append')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on -- query should exclude all chunks with optimization on :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC; psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: append_test."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Chunks excluded during startup: 3 --query should exclude all chunks and be a MergeAppend :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC limit 1; psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Order: append_test."time" DESC Chunks excluded during startup: 3 -- when optimized, the plan should be a constraint-aware append and -- cover only one chunk. It should be a backward index scan due to -- descending index on time. Should also skip the main table, since it -- cannot hold tuples :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months'; psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- adding ORDER BY and LIMIT should turn the plan into an optimized -- ordered append plan :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time LIMIT 3; psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- no optimized plan for queries with restrictions that can be -- constified at planning time. Regular planning-time constraint -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_i() - interval '2 months' ORDER BY time; psql:include/append_query.sql:37: NOTICE: Immutable function now_i() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > ('Tue Aug 22 10:00:00 2017 PDT'::timestamp with time zone - '@ 2 mons'::interval)) -- currently, we cannot distinguish between stable and volatile -- functions as far as applying our modified plan. However, volatile -- function should not be pre-evaluated to constants, so no chunk -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_v() - interval '2 months' ORDER BY time; psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) -- prepared statement output should be the same regardless of -- optimizations PREPARE query_opt AS SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time; :PREFIX EXECUTE query_opt; psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) DEALLOCATE query_opt; -- aggregates should produce same output :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time > now_s() - interval '4 months' GROUP BY t ORDER BY t DESC; psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: (date_trunc('year'::text, append_test."time")) -> Sort (actual rows=3.00 loops=1) Sort Key: (date_trunc('year'::text, append_test."time")) DESC Sort Method: quicksort -> Result (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=3.00 loops=1) Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -- querying outside the time range should return nothing. This tests -- that ConstraintAwareAppend can handle the case when an Append node -- is turned into a Result node due to no children :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time < '2016-03-22' AND date_part('dow', time) between 1 and 5 GROUP BY t ORDER BY t DESC; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: (date_trunc('year'::text, "time")) -> Sort (actual rows=0.00 loops=1) Sort Key: (date_trunc('year'::text, "time")) DESC Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- a parameterized query can safely constify params, so won't be -- optimized by constraint-aware append since regular constraint -- exclusion works just fine PREPARE query_param AS SELECT * FROM append_test WHERE time > $1 ORDER BY time; :PREFIX EXECUTE query_param(now_s() - interval '2 months'); psql:include/append_query.sql:82: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > 'Thu Jun 22 10:00:00 2017 PDT'::timestamp with time zone) DEALLOCATE query_param; --test with cte :PREFIX WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 30 days'::interval, "time"."time")) Sort Method: quicksort -> Hash Left Join (actual rows=6.00 loops=1) Hash Cond: (time_bucket('@ 30 days'::interval, "time"."time") = data.btime) -> Function Scan on generate_series "time" (actual rows=6.00 loops=1) -> Hash (actual rows=3.00 loops=1) -> Subquery Scan on data (actual rows=3.00 loops=1) -> HashAggregate (actual rows=3.00 loops=1) Group Key: time_bucket('@ 30 days'::interval, append_test."time") -> Result (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=5.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! btime | value ------------------------------+------- Fri Mar 03 16:00:00 2017 PST | 22.5 Sun Apr 02 17:00:00 2017 PDT | Tue May 02 17:00:00 2017 PDT | 25.7 Thu Jun 01 17:00:00 2017 PDT | Sat Jul 01 17:00:00 2017 PDT | Mon Jul 31 17:00:00 2017 PDT | 34.1 -- force nested loop join with no materialization. This tests that the -- inner ConstraintAwareScan supports resetting its scan for every -- iteration of the outer relation loop set enable_hashjoin = 'off'; set enable_mergejoin = 'off'; set enable_material = 'off'; :PREFIX SELECT * FROM append_test a INNER JOIN join_test j ON (a.colorid = j.colorid) WHERE a.time > now_s() - interval '3 hours' AND j.time > now_s() - interval '3 hours'; psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (a.colorid = j.colorid) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk a_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_2_6_chunk j_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) reset enable_hashjoin; reset enable_mergejoin; reset enable_material; -- test constraint_exclusion with date time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamp time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamptz time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with space partitioning and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date AND time < '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp AND time < '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND time < '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -- test filtering on space partition :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (1,2) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=2304.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1534.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Merge Append (actual rows=770.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (VALUES(1)) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND v3 IN (VALUES('1')) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=767.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 3068 -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1534 -> Merge Append (actual rows=385.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1540 -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 770 :PREFIX SELECT * FROM metrics_space WHERE time = (VALUES ('2019-12-24' at time zone 'UTC')) AND v3 NOT IN (VALUES ('1')); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 0 Chunks excluded during runtime: 9 InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) SubPlan 2 -> Result (never executed) -> Index Scan using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -- test CURRENT_DATE -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -- test CURRENT_TIMESTAMP -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -- test now() -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -- query with tablesample and planner exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15' ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Append (actual rows=217.00 loops=1) -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) Rows Removed by Filter: 43 -- query with tablesample and startup exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15'::text::date ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_date (actual rows=217.00 loops=1) Chunks excluded during startup: 2 -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) Rows Removed by Filter: 43 -- query with tablesample, space partitioning and planner exclusion :PREFIX SELECT * FROM metrics_space TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-10'::timestamptz ORDER BY time DESC, device_id; --- QUERY PLAN --- Sort (actual rows=522.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id Sort Method: quicksort -> Append (actual rows=522.00 loops=1) -> Sample Scan on _hyper_6_30_chunk (actual rows=35.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_29_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_28_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_27_chunk (actual rows=65.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 113 -> Sample Scan on _hyper_6_26_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -> Sample Scan on _hyper_6_25_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -- test runtime exclusion -- test runtime exclusion with LATERAL and 2 hypertables :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=1.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=26787) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=4611) Index Cond: ("time" = m1."time") -- test runtime exclusion and startup exclusions :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time AND m2.time < '2000-01-10'::text::timestamptz LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=0.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=0.00 loops=26787) Chunks excluded during startup: 3 Chunks excluded during runtime: 1 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -- test runtime exclusion does not activate for constraints on non-partitioning columns -- should not use runtime exclusion :PREFIX SELECT * FROM append_test a LEFT JOIN LATERAL(SELECT * FROM join_test j WHERE a.colorid = j.colorid ORDER BY time DESC LIMIT 1) j ON true ORDER BY a.time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Order: a."time" -> Index Scan Backward using _hyper_1_1_chunk_append_test_time_idx on _hyper_1_1_chunk a_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_append_test_time_idx on _hyper_1_2_chunk a_2 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_append_test_time_idx on _hyper_1_3_chunk a_3 (never executed) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Order: j."time" DESC Hypertables excluded during runtime: 0 -> Index Scan using _hyper_2_6_chunk_join_test_time_idx on _hyper_2_6_chunk j_1 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_5_chunk_join_test_time_idx on _hyper_2_5_chunk j_2 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_4_chunk_join_test_time_idx on _hyper_2_4_chunk j_3 (actual rows=1.00 loops=1) Filter: (a.colorid = colorid) -- test runtime exclusion with LATERAL and generate_series :PREFIX SELECT g.time FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g(time) LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m WHERE m.time=g.time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop Left Join (actual rows=32.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Result (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time) m ON true; --- QUERY PLAN --- Hash Join (actual rows=96.00 loops=1) Hash Cond: (g."time" = m."time") -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Hash (actual rows=26787.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk m_1 (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk m_2 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk m_3 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk m_4 (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk m_5 (actual rows=4611.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time ORDER BY time) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=96.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=3.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=3.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=3.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time>g.time + '1 day' ORDER BY time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=30.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Order: m."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=4) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -- test runtime exclusion with subquery :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE m1.time=(SELECT max(time) FROM metrics_timestamptz); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=3.00 loops=1) Chunks excluded during runtime: 4 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=3.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -- test runtime exclusion with correlated subquery :PREFIX SELECT m1.time, (SELECT m2.time FROM metrics_timestamptz m2 WHERE m2.time < m1.time ORDER BY m2.time DESC LIMIT 1) FROM metrics_timestamptz m1 WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Result (actual rows=7776.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=7776.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=3744.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) SubPlan 1 -> Limit (actual rows=1.00 loops=7776) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=7776) Order: m2."time" DESC Chunks excluded during runtime: 3 -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_1 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_2 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_4 (actual rows=1.00 loops=3741) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_5 (actual rows=1.00 loops=4035) Index Cond: ("time" < m1."time") -- test EXISTS :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE EXISTS(SELECT 1 FROM metrics_timestamptz m2 WHERE m1.time < m2.time) ORDER BY m1.time DESC limit 1000; --- QUERY PLAN --- Limit (actual rows=1000.00 loops=1) -> Nested Loop Semi Join (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=1003.00 loops=1) Order: m1."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_1 (actual rows=1003.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_2 (never executed) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_4 (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_5 (never executed) -> Append (actual rows=1.00 loops=1003) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=1003) Index Cond: ("time" > m1."time") -- test constraint exclusion for subqueries with append -- should include 2 chunks :PREFIX SELECT time FROM (SELECT time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY time) m; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=7776.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test constraint exclusion for subqueries with mergeappend -- should include 2 chunks :PREFIX SELECT device_id, time FROM (SELECT device_id, time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time) m; --- QUERY PLAN --- Custom Scan (ConstraintAwareAppend) (actual rows=7776.00 loops=1) Hypertable: metrics_timestamptz Chunks excluded during startup: 3 -> Merge Append (actual rows=7776.00 loops=1) Sort Key: metrics_timestamptz.device_id, metrics_timestamptz."time" -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test LIMIT pushdown -- no aggregates/window functions/SRF should pushdown limit :PREFIX SELECT FROM metrics_timestamptz ORDER BY time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (never executed) -- aggregates should prevent pushdown :PREFIX SELECT count(*) FROM metrics_timestamptz LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT count(*) FROM metrics_space LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- HAVING should prevent pushdown :PREFIX SELECT 1 FROM metrics_timestamptz HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT 1 FROM metrics_space HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- DISTINCT should prevent pushdown SET enable_hashagg TO false; :PREFIX SELECT DISTINCT device_id FROM metrics_timestamptz ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=17859.00 loops=1) Sort Key: metrics_timestamptz.device_id -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=2689.00 loops=1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_19_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_20_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_21_chunk (actual rows=3075.00 loops=1) :PREFIX SELECT DISTINCT device_id FROM metrics_space ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=7491.00 loops=1) Sort Key: metrics_space.device_id -> Index Scan using _hyper_6_22_chunk_metrics_space_device_id_time_idx on _hyper_6_22_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_23_chunk_metrics_space_device_id_time_idx on _hyper_6_23_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_24_chunk_metrics_space_device_id_time_idx on _hyper_6_24_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_26_chunk_metrics_space_device_id_time_idx on _hyper_6_26_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_27_chunk_metrics_space_device_id_time_idx on _hyper_6_27_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_29_chunk_metrics_space_device_id_time_idx on _hyper_6_29_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_30_chunk_metrics_space_device_id_time_idx on _hyper_6_30_chunk (actual rows=1.00 loops=1) RESET enable_hashagg; -- JOINs should prevent pushdown -- when LIMIT gets pushed to a Sort node it will switch to top-N heapsort -- if more tuples then LIMIT are requested this will trigger an error -- to trigger this we need a Sort node that is below ChunkAppend CREATE TABLE join_limit (time timestamptz, device_id int); SELECT table_name FROM create_hypertable('join_limit','time',create_default_indexes:=false); table_name ------------ join_limit CREATE INDEX ON join_limit(time,device_id); INSERT INTO join_limit SELECT time, device_id FROM generate_series('2000-01-01'::timestamptz,'2000-01-21','30m') g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) join_limit; -- get 2nd chunk oid SELECT tableoid AS "CHUNK_OID" FROM join_limit WHERE time > '2000-01-07' ORDER BY time LIMIT 1 \gset --get index name for 2nd chunk SELECT indexrelid::regclass AS "INDEX_NAME" FROM pg_index WHERE indrelid = :CHUNK_OID \gset DROP INDEX :INDEX_NAME; :PREFIX SELECT * FROM metrics_timestamptz m1 INNER JOIN join_limit m2 ON m1.time = m2.time AND m1.device_id=m2.device_id WHERE m1.time > '2000-01-07' ORDER BY m1.time, m1.device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Join (actual rows=3.00 loops=1) Merge Cond: (m2."time" = m1."time") Join Filter: (m2.device_id = m1.device_id) Rows Removed by Join Filter: 4 -> Custom Scan (ChunkAppend) on join_limit m2 (actual rows=3.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Seq Scan on _hyper_8_35_chunk m2_1 (actual rows=2710.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 650 -> Index Scan using _hyper_8_36_chunk_join_limit_time_device_id_idx on _hyper_8_36_chunk m2_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_join_limit_time_device_id_idx on _hyper_8_37_chunk m2_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=22.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=19.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_1 (actual rows=19.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_4 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) DROP TABLE join_limit; -- test ChunkAppend projection #2661 :PREFIX SELECT ts.timestamp, ht.timestamp FROM ( SELECT generate_series( to_timestamp(FLOOR(EXTRACT (EPOCH FROM '2020-01-01T00:01:00Z'::timestamp) / 300) * 300) AT TIME ZONE 'UTC', '2020-01-01T01:00:00Z', '5 minutes'::interval ) AS timestamp ) ts LEFT JOIN i2661 ht ON (FLOOR(EXTRACT (EPOCH FROM ht."timestamp") / 300) * 300 = EXTRACT (EPOCH FROM ts.timestamp)) AND ht.timestamp > '2019-12-30T00:00:00Z'::timestamp ORDER BY ts.timestamp, ht.timestamp; --- QUERY PLAN --- Sort (actual rows=33.00 loops=1) Sort Key: ts."timestamp", ht."timestamp" Sort Method: quicksort -> Merge Left Join (actual rows=33.00 loops=1) Merge Cond: ((EXTRACT(epoch FROM ts."timestamp")) = ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric))) -> Sort (actual rows=13.00 loops=1) Sort Key: (EXTRACT(epoch FROM ts."timestamp")) Sort Method: quicksort -> Subquery Scan on ts (actual rows=13.00 loops=1) -> ProjectSet (actual rows=13.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Sort (actual rows=514.00 loops=1) Sort Key: ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric)) Sort Method: quicksort -> Result (actual rows=7201.00 loops=1) -> Custom Scan (ChunkAppend) on i2661 ht (actual rows=7201.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_7_31_chunk ht_1 (actual rows=1200.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_32_chunk ht_2 (actual rows=5040.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_33_chunk ht_3 (actual rows=961.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -- #3030 test chunkappend keeps pathkeys when subpath is append -- on PG11 this will not use ChunkAppend but MergeAppend SET enable_seqscan TO FALSE; CREATE TABLE i3030(time timestamptz NOT NULL, a int, b int); SELECT table_name FROM create_hypertable('i3030', 'time', create_default_indexes=>false); table_name ------------ i3030 CREATE INDEX ON i3030(a,time); INSERT INTO i3030 (time,a) SELECT time, a FROM generate_series('2000-01-01'::timestamptz,'2000-01-01 3:00:00'::timestamptz,'1min'::interval) time, generate_series(1,30) a; VACUUM (ANALYZE) i3030; :PREFIX SELECT * FROM i3030 where time BETWEEN '2000-01-01'::text::timestamptz AND '2000-01-03'::text::timestamptz ORDER BY a,time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on i3030 (actual rows=1.00 loops=1) Order: i3030.a, i3030."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_9_38_chunk_i3030_a_time_idx on _hyper_9_38_chunk (actual rows=1.00 loops=1) Index Cond: (("time" >= ('2000-01-01'::cstring)::timestamp with time zone) AND ("time" <= ('2000-01-03'::cstring)::timestamp with time zone)) DROP TABLE i3030; RESET enable_seqscan; --parent runtime exclusion tests: --optimization works with ANY (array) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) --optimization does not work for ANY subquery (does not force an initplan) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT attr FROM join_test_plain WHERE temp > 100)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Join Filter: (a.attr @> join_test_plain.attr) -> Append (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=1.00 loops=1) -> Materialize (actual rows=0.00 loops=5) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 --works on any strict operator without ANY :PREFIX SELECT * FROM append_test a WHERE a.attr @> (SELECT attr FROM join_test_plain WHERE temp > 100 limit 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 -> Limit (actual rows=0.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> (InitPlan 1).col1) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> (InitPlan 1).col1) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> (InitPlan 1).col1) --optimization works with function calls CREATE OR REPLACE FUNCTION select_tag(_min_temp int) RETURNS jsonb[] LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > _min_temp $function$; :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT select_tag(100))::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) --optimization does not work when result is null :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT array_agg(attr) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 0 InitPlan 1 -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=0.00 loops=1) Filter: (attr @> ANY ((InitPlan 1).col1)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=0.00 loops=1) Filter: (attr @> ANY ((InitPlan 1).col1)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=0.00 loops=1) Filter: (attr @> ANY ((InitPlan 1).col1)) Rows Removed by Filter: 1 -- Test that ConstraintAwareAppend properly locks relations in -- parallel query mode set timescaledb.enable_chunk_append=false; call force_parallel(true); :PREFIX select time, avg(temp), colorid from append_test where time > now_s() - interval '3 months 20 days' group by time, colorid; psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Gather (actual rows=3.00 loops=1) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> HashAggregate (actual rows=3.00 loops=1) Group Key: append_test."time", append_test.colorid -> Custom Scan (ConstraintAwareAppend) (actual rows=3.00 loops=1) Hypertable: append_test Chunks excluded during startup: 1 -> Append (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) reset timescaledb.enable_chunk_append; reset max_parallel_workers_per_gather; call force_parallel(false); --generate the results into two different files \set ECHO errors --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on --- Unoptimized results +++ Optimized results @@ -1,7 +1,7 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off - timescaledb.enable_chunk_append | on + timescaledb.enable_optimizations | on + timescaledb.enable_chunk_append | off time | temp | colorid | attr �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/append-18.out������������������������������������������������������0000664�0000000�0000000�00000377675�15100345067�0021112�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset SET timescaledb.enable_now_constify TO false; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- disable index only scans to avoid some flaky results SET enable_indexonlyscan TO FALSE; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE PARALLEL SAFE AS $BODY$ BEGIN RAISE NOTICE 'Stable function now_s() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_i() RETURNS timestamptz LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'Immutable function now_i() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_v() RETURNS timestamptz LANGUAGE PLPGSQL VOLATILE AS $BODY$ BEGIN RAISE NOTICE 'Volatile function now_v() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE PROCEDURE force_parallel(on_or_off bool) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('server_version_num')::int < 160000 THEN IF on_or_off THEN set force_parallel_mode = 'on'; ELSE set force_parallel_mode = 'off'; END IF; ELSE IF on_or_off THEN set debug_parallel_query = 'on'; ELSE set debug_parallel_query = 'off'; END IF; END IF; END; $$; CREATE TABLE append_test(time timestamptz, temp float, colorid integer, attr jsonb); SELECT create_hypertable('append_test', 'time', chunk_time_interval => 2628000000000); create_hypertable -------------------------- (1,public,append_test,t) -- create three chunks INSERT INTO append_test VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); VACUUM (ANALYZE) append_test; -- Create another hypertable to join with CREATE TABLE join_test(time timestamptz, temp float, colorid integer); SELECT create_hypertable('join_test', 'time', chunk_time_interval => 2628000000000); create_hypertable ------------------------ (2,public,join_test,t) INSERT INTO join_test VALUES ('2017-01-22T09:18:22', 15.2, 1), ('2017-02-22T09:18:22', 24.5, 2), ('2017-08-22T09:18:22', 23.1, 3); VACUUM (ANALYZE) join_test; -- Create another table to join with which is not a hypertable. CREATE TABLE join_test_plain(time timestamptz, temp float, colorid integer, attr jsonb); INSERT INTO join_test_plain VALUES ('2017-01-22T09:18:22', 15.2, 1, '{"a": 1}'), ('2017-02-22T09:18:22', 24.5, 2, '{"b": 2}'), ('2017-08-22T09:18:22', 23.1, 3, '{"c": 3}'); VACUUM (ANALYZE) join_test_plain; -- create hypertable with DATE time dimension CREATE TABLE metrics_date(time DATE NOT NULL); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (3,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_date; -- create hypertable with TIMESTAMP time dimension CREATE TABLE metrics_timestamp(time TIMESTAMP NOT NULL); SELECT create_hypertable('metrics_timestamp','time'); psql:include/append_load.sql:91: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (4,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_timestamp; -- create hypertable with TIMESTAMPTZ time dimension CREATE TABLE metrics_timestamptz(time TIMESTAMPTZ NOT NULL, device_id INT NOT NULL); CREATE INDEX ON metrics_timestamptz(device_id,time); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (5,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 3; VACUUM (ANALYZE) metrics_timestamptz; -- create space partitioned hypertable CREATE TABLE metrics_space(time timestamptz NOT NULL, device_id int NOT NULL, v1 float, v2 float, v3 text); SELECT create_hypertable('metrics_space','time','device_id',3); create_hypertable ---------------------------- (6,public,metrics_space,t) INSERT INTO metrics_space SELECT time, device_id, device_id + 0.25, device_id + 0.75, device_id FROM generate_series('2000-01-01'::timestamptz, '2000-01-14'::timestamptz, '5m'::interval) g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) metrics_space; -- test ChunkAppend projection #2661 CREATE TABLE i2661 ( machine_id int4 NOT NULL, "name" varchar(255) NOT NULL, "timestamp" timestamptz NOT NULL, "first" float4 NULL ); SELECT create_hypertable('i2661', 'timestamp'); psql:include/append_load.sql:123: WARNING: column type "character varying" used for "name" does not follow best practices create_hypertable -------------------- (7,public,i2661,t) INSERT INTO i2661 SELECT 1, 'speed', generate_series('2019-12-31 00:00:00', '2020-01-10 00:00:00', '2m'::interval), 0; VACUUM (ANALYZE) i2661; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be the only output of the results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations'),('timescaledb.enable_chunk_append')) v(setting); setting | value ----------------------------------+------- timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on -- query should exclude all chunks with optimization on :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC; psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! psql:include/append_query.sql:12: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: append_test."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Chunks excluded during startup: 3 --query should exclude all chunks and be a MergeAppend :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC limit 1; psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! psql:include/append_query.sql:17: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=0.00 loops=1) Order: append_test."time" DESC Chunks excluded during startup: 3 -- when optimized, the plan should be a constraint-aware append and -- cover only one chunk. It should be a backward index scan due to -- descending index on time. Should also skip the main table, since it -- cannot hold tuples :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months'; psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! psql:include/append_query.sql:24: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- adding ORDER BY and LIMIT should turn the plan into an optimized -- ordered append plan :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time LIMIT 3; psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! psql:include/append_query.sql:30: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) -- no optimized plan for queries with restrictions that can be -- constified at planning time. Regular planning-time constraint -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_i() - interval '2 months' ORDER BY time; psql:include/append_query.sql:37: NOTICE: Immutable function now_i() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > ('Tue Aug 22 10:00:00 2017 PDT'::timestamp with time zone - '@ 2 mons'::interval)) -- currently, we cannot distinguish between stable and volatile -- functions as far as applying our modified plan. However, volatile -- function should not be pre-evaluated to constants, so no chunk -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_v() - interval '2 months' ORDER BY time; psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! psql:include/append_query.sql:45: NOTICE: Volatile function now_v() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_v() - '@ 2 mons'::interval)) -- prepared statement output should be the same regardless of -- optimizations PREPARE query_opt AS SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time; :PREFIX EXECUTE query_opt; psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! psql:include/append_query.sql:53: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: append_test."time" Sort Method: quicksort -> Custom Scan (ChunkAppend) on append_test (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 2 mons'::interval)) DEALLOCATE query_opt; -- aggregates should produce same output :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time > now_s() - interval '4 months' GROUP BY t ORDER BY t DESC; psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! psql:include/append_query.sql:62: NOTICE: Stable function now_s() called! --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: (date_trunc('year'::text, append_test."time")) -> Sort (actual rows=3.00 loops=1) Sort Key: (date_trunc('year'::text, append_test."time")) DESC Sort Method: quicksort -> Result (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=3.00 loops=1) Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 4 mons'::interval)) -- querying outside the time range should return nothing. This tests -- that ConstraintAwareAppend can handle the case when an Append node -- is turned into a Result node due to no children :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time < '2016-03-22' AND date_part('dow', time) between 1 and 5 GROUP BY t ORDER BY t DESC; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: (date_trunc('year'::text, "time")) -> Sort (actual rows=0.00 loops=1) Sort Key: (date_trunc('year'::text, "time")) DESC Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- a parameterized query can safely constify params, so won't be -- optimized by constraint-aware append since regular constraint -- exclusion works just fine PREPARE query_param AS SELECT * FROM append_test WHERE time > $1 ORDER BY time; :PREFIX EXECUTE query_param(now_s() - interval '2 months'); psql:include/append_query.sql:82: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > 'Thu Jun 22 10:00:00 2017 PDT'::timestamp with time zone) DEALLOCATE query_param; --test with cte :PREFIX WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! psql:include/append_query.sql:102: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 30 days'::interval, "time"."time")) Sort Method: quicksort -> Hash Left Join (actual rows=6.00 loops=1) Hash Cond: (time_bucket('@ 30 days'::interval, "time"."time") = data.btime) -> Function Scan on generate_series "time" (actual rows=6.00 loops=1) -> Hash (actual rows=3.00 loops=1) -> Subquery Scan on data (actual rows=3.00 loops=1) -> HashAggregate (actual rows=3.00 loops=1) Group Key: time_bucket('@ 30 days'::interval, append_test."time") -> Result (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on append_test (actual rows=5.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ((colorid > 0) AND ("time" > (now_s() - '@ 400 days'::interval))) WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! psql:include/append_query.sql:119: NOTICE: Stable function now_s() called! btime | value ------------------------------+------- Fri Mar 03 16:00:00 2017 PST | 22.5 Sun Apr 02 17:00:00 2017 PDT | Tue May 02 17:00:00 2017 PDT | 25.7 Thu Jun 01 17:00:00 2017 PDT | Sat Jul 01 17:00:00 2017 PDT | Mon Jul 31 17:00:00 2017 PDT | 34.1 -- force nested loop join with no materialization. This tests that the -- inner ConstraintAwareScan supports resetting its scan for every -- iteration of the outer relation loop set enable_hashjoin = 'off'; set enable_mergejoin = 'off'; set enable_material = 'off'; :PREFIX SELECT * FROM append_test a INNER JOIN join_test j ON (a.colorid = j.colorid) WHERE a.time > now_s() - interval '3 hours' AND j.time > now_s() - interval '3 hours'; psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! psql:include/append_query.sql:130: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (a.colorid = j.colorid) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_1_3_chunk a_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Chunks excluded during startup: 2 -> Seq Scan on _hyper_2_6_chunk j_1 (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 hours'::interval)) reset enable_hashjoin; reset enable_mergejoin; reset enable_material; -- test constraint_exclusion with date time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=4609.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_11_chunk_metrics_date_time_idx on _hyper_3_11_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=1440.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_3_9_chunk_metrics_date_time_idx on _hyper_3_9_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_3_10_chunk_metrics_date_time_idx on _hyper_3_10_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamp time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=4896.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=2016.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_16_chunk_metrics_timestamp_time_idx on _hyper_4_16_chunk (actual rows=1441.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=1727.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_4_14_chunk_metrics_timestamp_time_idx on _hyper_4_14_chunk (actual rows=1439.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_4_15_chunk_metrics_timestamp_time_idx on _hyper_4_15_chunk (actual rows=288.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with timestamptz time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > '01-15-2000'::date) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=14688.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=6048.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=4611.00 loops=1) Index Cond: ("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > '01-15-2000'::date) AND ("time" < '01-21-2000'::date)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=5181.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (actual rows=4029.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (actual rows=1152.00 loops=1) Index Cond: (("time" > 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 21 00:00:00 2000 PST'::timestamp with time zone)) -- test constraint_exclusion with space partitioning and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test Const OP Var -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::date < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > '01-10-2000'::date) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamp < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamptz < time ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -- test 2 constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date AND time < '2000-01-15'::date ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > '01-10-2000'::date) AND ("time" < '01-15-2000'::date)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp AND time < '2000-01-15'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000'::timestamp without time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND time < '2000-01-15'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=11520.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7670.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=3068.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=1534.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=3850.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=1540.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=770.00 loops=1) Index Cond: (("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Sat Jan 15 00:00:00 2000 PST'::timestamp with time zone)) -- test filtering on space partition :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (1,2) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=2304.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1534.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2301 -> Merge Append (actual rows=770.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1155 :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (VALUES(1)) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ((device_id = 1) AND ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND v3 IN (VALUES('1')) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1152.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=767.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=767.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 2301 -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 3068 -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1534 -> Merge Append (actual rows=385.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=385.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1155 -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 1540 -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (v3 = '1'::text) Rows Removed by Filter: 770 :PREFIX SELECT * FROM metrics_space WHERE time = (VALUES ('2019-12-24' at time zone 'UTC')) AND v3 NOT IN (VALUES ('1')); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 0 Chunks excluded during runtime: 9 InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) SubPlan 2 -> Result (never executed) -> Index Scan using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -> Index Scan using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (never executed) Index Cond: ("time" = (InitPlan 1).col1) Filter: (NOT (ANY (v3 = (hashed SubPlan 2).col1))) -- test CURRENT_DATE -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_DATE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_DATE) -- test CURRENT_TIMESTAMP -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_TIMESTAMP ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > CURRENT_TIMESTAMP) -- test now() -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date (actual rows=0.00 loops=1) Order: metrics_date."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamp WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp (actual rows=0.00 loops=1) Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_timestamptz WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=0.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX SELECT time FROM metrics_space WHERE time > now() ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_22_chunk_metrics_space_time_idx on _hyper_6_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_23_chunk_metrics_space_time_idx on _hyper_6_23_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_24_chunk_metrics_space_time_idx on _hyper_6_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_25_chunk_metrics_space_time_idx on _hyper_6_25_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_26_chunk_metrics_space_time_idx on _hyper_6_26_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_27_chunk_metrics_space_time_idx on _hyper_6_27_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_6_28_chunk_metrics_space_time_idx on _hyper_6_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_29_chunk_metrics_space_time_idx on _hyper_6_29_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -> Index Scan Backward using _hyper_6_30_chunk_metrics_space_time_idx on _hyper_6_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > now()) -- query with tablesample and planner exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15' ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Append (actual rows=217.00 loops=1) -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > '01-15-2000'::date) Rows Removed by Filter: 43 -- query with tablesample and startup exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15'::text::date ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=217.00 loops=1) Sort Key: metrics_date."time" DESC Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_date (actual rows=217.00 loops=1) Chunks excluded during startup: 2 -> Sample Scan on _hyper_3_11_chunk (actual rows=72.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_10_chunk (actual rows=94.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) -> Sample Scan on _hyper_3_9_chunk (actual rows=51.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > ('2000-01-15'::cstring)::date) Rows Removed by Filter: 43 -- query with tablesample, space partitioning and planner exclusion :PREFIX SELECT * FROM metrics_space TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-10'::timestamptz ORDER BY time DESC, device_id; --- QUERY PLAN --- Sort (actual rows=522.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id Sort Method: quicksort -> Append (actual rows=522.00 loops=1) -> Sample Scan on _hyper_6_30_chunk (actual rows=35.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_29_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_28_chunk (actual rows=61.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sample Scan on _hyper_6_27_chunk (actual rows=65.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 113 -> Sample Scan on _hyper_6_26_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -> Sample Scan on _hyper_6_25_chunk (actual rows=150.00 loops=1) Sampling: bernoulli ('5'::real) REPEATABLE ('0'::double precision) Filter: ("time" > 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 218 -- test runtime exclusion -- test runtime exclusion with LATERAL and 2 hypertables :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=1.00 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=26787) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=1.00 loops=6048) Index Cond: ("time" = m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=4611) Index Cond: ("time" = m1."time") -- test runtime exclusion and startup exclusions :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time AND m2.time < '2000-01-10'::text::timestamptz LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=26787.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=26787.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (actual rows=6048.00 loops=1) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=4611.00 loops=1) -> Limit (actual rows=0.29 loops=26787) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=0.29 loops=26787) Chunks excluded during startup: 3 Chunks excluded during runtime: 1 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=1.00 loops=4032) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=0.62 loops=6048) Index Cond: (("time" < ('2000-01-10'::cstring)::timestamp with time zone) AND ("time" = m1."time")) -- test runtime exclusion does not activate for constraints on non-partitioning columns -- should not use runtime exclusion :PREFIX SELECT * FROM append_test a LEFT JOIN LATERAL(SELECT * FROM join_test j WHERE a.colorid = j.colorid ORDER BY time DESC LIMIT 1) j ON true ORDER BY a.time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on append_test a (actual rows=1.00 loops=1) Order: a."time" -> Index Scan Backward using _hyper_1_1_chunk_append_test_time_idx on _hyper_1_1_chunk a_1 (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_append_test_time_idx on _hyper_1_2_chunk a_2 (never executed) -> Index Scan Backward using _hyper_1_3_chunk_append_test_time_idx on _hyper_1_3_chunk a_3 (never executed) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on join_test j (actual rows=1.00 loops=1) Order: j."time" DESC Hypertables excluded during runtime: 0 -> Index Scan using _hyper_2_6_chunk_join_test_time_idx on _hyper_2_6_chunk j_1 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_5_chunk_join_test_time_idx on _hyper_2_5_chunk j_2 (actual rows=0.00 loops=1) Filter: (a.colorid = colorid) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_4_chunk_join_test_time_idx on _hyper_2_4_chunk j_3 (actual rows=1.00 loops=1) Filter: (a.colorid = colorid) -- test runtime exclusion with LATERAL and generate_series :PREFIX SELECT g.time FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g(time) LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m WHERE m.time=g.time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop Left Join (actual rows=32.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Result (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=1.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=1.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=96.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Append (actual rows=3.00 loops=32) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=0.47 loops=32) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=0.66 loops=32) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=0.66 loops=32) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=0.66 loops=32) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=0.56 loops=32) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time ORDER BY time) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=96.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=3.00 loops=32) Chunks excluded during runtime: 4 -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=3.00 loops=5) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=3.00 loops=7) Index Cond: ("time" = g."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=3.00 loops=6) Index Cond: ("time" = g."time") :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time>g.time + '1 day' ORDER BY time LIMIT 1) m ON true; --- QUERY PLAN --- Nested Loop (actual rows=30.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.94 loops=32) -> Custom Scan (ChunkAppend) on metrics_timestamptz m (actual rows=0.94 loops=32) Order: m."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m_1 (actual rows=1.00 loops=4) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m_2 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m_3 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m_4 (actual rows=1.00 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m_5 (actual rows=0.71 loops=7) Index Cond: ("time" > (g."time" + '@ 1 day'::interval)) -- test runtime exclusion with subquery :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE m1.time=(SELECT max(time) FROM metrics_timestamptz); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=3.00 loops=1) Chunks excluded during runtime: 4 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_4 (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_5 (actual rows=3.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -- test runtime exclusion with correlated subquery :PREFIX SELECT m1.time, (SELECT m2.time FROM metrics_timestamptz m2 WHERE m2.time < m1.time ORDER BY m2.time DESC LIMIT 1) FROM metrics_timestamptz m1 WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Result (actual rows=7776.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=7776.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_1 (actual rows=4032.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_2 (actual rows=3744.00 loops=1) Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) SubPlan 1 -> Limit (actual rows=1.00 loops=7776) -> Custom Scan (ChunkAppend) on metrics_timestamptz m2 (actual rows=1.00 loops=7776) Order: m2."time" DESC Chunks excluded during runtime: 3 -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_1 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_2 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (never executed) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_4 (actual rows=1.00 loops=3741) Index Cond: ("time" < m1."time") -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_5 (actual rows=1.00 loops=4035) Index Cond: ("time" < m1."time") -- test EXISTS :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE EXISTS(SELECT 1 FROM metrics_timestamptz m2 WHERE m1.time < m2.time) ORDER BY m1.time DESC limit 1000; --- QUERY PLAN --- Limit (actual rows=1000.00 loops=1) -> Nested Loop Semi Join (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=1003.00 loops=1) Order: m1."time" DESC -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_1 (actual rows=1003.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_2 (never executed) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_3 (never executed) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_4 (never executed) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m1_5 (never executed) -> Append (actual rows=1.00 loops=1003) -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk m2_1 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m2_2 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m2_3 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m2_4 (actual rows=0.00 loops=1003) Index Cond: ("time" > m1."time") -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m2_5 (actual rows=1.00 loops=1003) Index Cond: ("time" > m1."time") -- test constraint exclusion for subqueries with append -- should include 2 chunks :PREFIX SELECT time FROM (SELECT time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY time) m; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=7776.00 loops=1) Order: metrics_timestamptz."time" Chunks excluded during startup: 3 -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test constraint exclusion for subqueries with mergeappend -- should include 2 chunks :PREFIX SELECT device_id, time FROM (SELECT device_id, time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time) m; --- QUERY PLAN --- Custom Scan (ConstraintAwareAppend) (actual rows=7776.00 loops=1) Hypertable: metrics_timestamptz Chunks excluded during startup: 3 -> Merge Append (actual rows=7776.00 loops=1) Sort Key: metrics_timestamptz.device_id, metrics_timestamptz."time" -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=4032.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=3744.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -- test LIMIT pushdown -- no aggregates/window functions/SRF should pushdown limit :PREFIX SELECT FROM metrics_timestamptz ORDER BY time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz (actual rows=1.00 loops=1) Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_5_17_chunk_metrics_timestamptz_time_idx on _hyper_5_17_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk (never executed) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk (never executed) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk (never executed) -- aggregates should prevent pushdown :PREFIX SELECT count(*) FROM metrics_timestamptz LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT count(*) FROM metrics_space LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- HAVING should prevent pushdown :PREFIX SELECT 1 FROM metrics_timestamptz HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=26787.00 loops=1) -> Seq Scan on _hyper_5_17_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_19_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_20_chunk (actual rows=6048.00 loops=1) -> Seq Scan on _hyper_5_21_chunk (actual rows=4611.00 loops=1) :PREFIX SELECT 1 FROM metrics_space HAVING count(*) > 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) Filter: (count(*) > 1) -> Append (actual rows=37450.00 loops=1) -> Seq Scan on _hyper_6_22_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_23_chunk (actual rows=5376.00 loops=1) -> Seq Scan on _hyper_6_24_chunk (actual rows=2688.00 loops=1) -> Seq Scan on _hyper_6_25_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_26_chunk (actual rows=8064.00 loops=1) -> Seq Scan on _hyper_6_27_chunk (actual rows=4032.00 loops=1) -> Seq Scan on _hyper_6_28_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_29_chunk (actual rows=1540.00 loops=1) -> Seq Scan on _hyper_6_30_chunk (actual rows=770.00 loops=1) -- DISTINCT should prevent pushdown SET enable_hashagg TO false; :PREFIX SELECT DISTINCT device_id FROM metrics_timestamptz ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=17859.00 loops=1) Sort Key: metrics_timestamptz.device_id -> Index Scan using _hyper_5_17_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_17_chunk (actual rows=2689.00 loops=1) -> Index Scan using _hyper_5_18_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_18_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_19_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_19_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_20_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_20_chunk (actual rows=4033.00 loops=1) -> Index Scan using _hyper_5_21_chunk_metrics_timestamptz_device_id_time_idx on _hyper_5_21_chunk (actual rows=3075.00 loops=1) :PREFIX SELECT DISTINCT device_id FROM metrics_space ORDER BY device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=7491.00 loops=1) Sort Key: metrics_space.device_id -> Index Scan using _hyper_6_22_chunk_metrics_space_device_id_time_idx on _hyper_6_22_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_23_chunk_metrics_space_device_id_time_idx on _hyper_6_23_chunk (actual rows=1345.00 loops=1) -> Index Scan using _hyper_6_24_chunk_metrics_space_device_id_time_idx on _hyper_6_24_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_25_chunk_metrics_space_device_id_time_idx on _hyper_6_25_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_26_chunk_metrics_space_device_id_time_idx on _hyper_6_26_chunk (actual rows=2017.00 loops=1) -> Index Scan using _hyper_6_27_chunk_metrics_space_device_id_time_idx on _hyper_6_27_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_6_28_chunk_metrics_space_device_id_time_idx on _hyper_6_28_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_29_chunk_metrics_space_device_id_time_idx on _hyper_6_29_chunk (actual rows=386.00 loops=1) -> Index Scan using _hyper_6_30_chunk_metrics_space_device_id_time_idx on _hyper_6_30_chunk (actual rows=1.00 loops=1) RESET enable_hashagg; -- JOINs should prevent pushdown -- when LIMIT gets pushed to a Sort node it will switch to top-N heapsort -- if more tuples then LIMIT are requested this will trigger an error -- to trigger this we need a Sort node that is below ChunkAppend CREATE TABLE join_limit (time timestamptz, device_id int); SELECT table_name FROM create_hypertable('join_limit','time',create_default_indexes:=false); table_name ------------ join_limit CREATE INDEX ON join_limit(time,device_id); INSERT INTO join_limit SELECT time, device_id FROM generate_series('2000-01-01'::timestamptz,'2000-01-21','30m') g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) join_limit; -- get 2nd chunk oid SELECT tableoid AS "CHUNK_OID" FROM join_limit WHERE time > '2000-01-07' ORDER BY time LIMIT 1 \gset --get index name for 2nd chunk SELECT indexrelid::regclass AS "INDEX_NAME" FROM pg_index WHERE indrelid = :CHUNK_OID \gset DROP INDEX :INDEX_NAME; :PREFIX SELECT * FROM metrics_timestamptz m1 INNER JOIN join_limit m2 ON m1.time = m2.time AND m1.device_id=m2.device_id WHERE m1.time > '2000-01-07' ORDER BY m1.time, m1.device_id LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Join (actual rows=3.00 loops=1) Merge Cond: (m2."time" = m1."time") Join Filter: (m2.device_id = m1.device_id) Rows Removed by Join Filter: 4 -> Custom Scan (ChunkAppend) on join_limit m2 (actual rows=3.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Seq Scan on _hyper_8_35_chunk m2_1 (actual rows=2710.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 650 -> Index Scan using _hyper_8_36_chunk_join_limit_time_device_id_idx on _hyper_8_36_chunk m2_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_join_limit_time_device_id_idx on _hyper_8_37_chunk m2_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=22.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 (actual rows=19.00 loops=1) Order: m1."time" -> Index Scan Backward using _hyper_5_18_chunk_metrics_timestamptz_time_idx on _hyper_5_18_chunk m1_1 (actual rows=19.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_19_chunk_metrics_timestamptz_time_idx on _hyper_5_19_chunk m1_2 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_20_chunk_metrics_timestamptz_time_idx on _hyper_5_20_chunk m1_3 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_21_chunk_metrics_timestamptz_time_idx on _hyper_5_21_chunk m1_4 (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) DROP TABLE join_limit; -- test ChunkAppend projection #2661 :PREFIX SELECT ts.timestamp, ht.timestamp FROM ( SELECT generate_series( to_timestamp(FLOOR(EXTRACT (EPOCH FROM '2020-01-01T00:01:00Z'::timestamp) / 300) * 300) AT TIME ZONE 'UTC', '2020-01-01T01:00:00Z', '5 minutes'::interval ) AS timestamp ) ts LEFT JOIN i2661 ht ON (FLOOR(EXTRACT (EPOCH FROM ht."timestamp") / 300) * 300 = EXTRACT (EPOCH FROM ts.timestamp)) AND ht.timestamp > '2019-12-30T00:00:00Z'::timestamp ORDER BY ts.timestamp, ht.timestamp; --- QUERY PLAN --- Sort (actual rows=33.00 loops=1) Sort Key: (generate_series('Wed Jan 01 00:00:00 2020'::timestamp without time zone, 'Wed Jan 01 01:00:00 2020'::timestamp without time zone, '@ 5 mins'::interval)), ht."timestamp" Sort Method: quicksort -> Hash Right Join (actual rows=33.00 loops=1) Hash Cond: ((floor((EXTRACT(epoch FROM ht."timestamp") / '300'::numeric)) * '300'::numeric) = EXTRACT(epoch FROM (generate_series('Wed Jan 01 00:00:00 2020'::timestamp without time zone, 'Wed Jan 01 01:00:00 2020'::timestamp without time zone, '@ 5 mins'::interval)))) -> Custom Scan (ChunkAppend) on i2661 ht (actual rows=7201.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_7_31_chunk ht_1 (actual rows=1200.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_32_chunk ht_2 (actual rows=5040.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Seq Scan on _hyper_7_33_chunk ht_3 (actual rows=961.00 loops=1) Filter: ("timestamp" > 'Mon Dec 30 00:00:00 2019'::timestamp without time zone) -> Hash (actual rows=13.00 loops=1) -> ProjectSet (actual rows=13.00 loops=1) -> Result (actual rows=1.00 loops=1) -- #3030 test chunkappend keeps pathkeys when subpath is append -- on PG11 this will not use ChunkAppend but MergeAppend SET enable_seqscan TO FALSE; CREATE TABLE i3030(time timestamptz NOT NULL, a int, b int); SELECT table_name FROM create_hypertable('i3030', 'time', create_default_indexes=>false); table_name ------------ i3030 CREATE INDEX ON i3030(a,time); INSERT INTO i3030 (time,a) SELECT time, a FROM generate_series('2000-01-01'::timestamptz,'2000-01-01 3:00:00'::timestamptz,'1min'::interval) time, generate_series(1,30) a; VACUUM (ANALYZE) i3030; :PREFIX SELECT * FROM i3030 where time BETWEEN '2000-01-01'::text::timestamptz AND '2000-01-03'::text::timestamptz ORDER BY a,time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on i3030 (actual rows=1.00 loops=1) Order: i3030.a, i3030."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_9_38_chunk_i3030_a_time_idx on _hyper_9_38_chunk (actual rows=1.00 loops=1) Index Cond: (("time" >= ('2000-01-01'::cstring)::timestamp with time zone) AND ("time" <= ('2000-01-03'::cstring)::timestamp with time zone)) DROP TABLE i3030; RESET enable_seqscan; --parent runtime exclusion tests: --optimization works with ANY (array) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) --optimization does not work for ANY subquery (does not force an initplan) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT attr FROM join_test_plain WHERE temp > 100)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Join Filter: (a.attr @> join_test_plain.attr) -> Append (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=2.00 loops=1) -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=1.00 loops=1) -> Materialize (actual rows=0.00 loops=5) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 --works on any strict operator without ANY :PREFIX SELECT * FROM append_test a WHERE a.attr @> (SELECT attr FROM join_test_plain WHERE temp > 100 limit 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 -> Limit (actual rows=0.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> (InitPlan 1).col1) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> (InitPlan 1).col1) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> (InitPlan 1).col1) --optimization works with function calls CREATE OR REPLACE FUNCTION select_tag(_min_temp int) RETURNS jsonb[] LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > _min_temp $function$; :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT select_tag(100))::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 1 InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_1_chunk a_1 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_2_chunk a_2 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) -> Seq Scan on _hyper_1_3_chunk a_3 (never executed) Filter: (attr @> ANY ((InitPlan 1).col1)) --optimization does not work when result is null :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT array_agg(attr) FROM join_test_plain WHERE temp > 100)::jsonb[]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on append_test a (actual rows=0.00 loops=1) Hypertables excluded during runtime: 0 InitPlan 1 -> Aggregate (actual rows=1.00 loops=1) -> Seq Scan on join_test_plain (actual rows=0.00 loops=1) Filter: (temp > '100'::double precision) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_1_chunk a_1 (actual rows=0.00 loops=1) Filter: (attr @> ANY ((InitPlan 1).col1)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_2_chunk a_2 (actual rows=0.00 loops=1) Filter: (attr @> ANY ((InitPlan 1).col1)) Rows Removed by Filter: 2 -> Seq Scan on _hyper_1_3_chunk a_3 (actual rows=0.00 loops=1) Filter: (attr @> ANY ((InitPlan 1).col1)) Rows Removed by Filter: 1 -- Test that ConstraintAwareAppend properly locks relations in -- parallel query mode set timescaledb.enable_chunk_append=false; call force_parallel(true); :PREFIX select time, avg(temp), colorid from append_test where time > now_s() - interval '3 months 20 days' group by time, colorid; psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! psql:include/append_query.sql:415: NOTICE: Stable function now_s() called! --- QUERY PLAN --- Gather (actual rows=3.00 loops=1) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> HashAggregate (actual rows=3.00 loops=1) Group Key: append_test."time", append_test.colorid -> Custom Scan (ConstraintAwareAppend) (actual rows=3.00 loops=1) Hypertable: append_test Chunks excluded during startup: 1 -> Append (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) -> Seq Scan on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: ("time" > (now_s() - '@ 3 mons 20 days'::interval)) reset timescaledb.enable_chunk_append; reset max_parallel_workers_per_gather; call force_parallel(false); --generate the results into two different files \set ECHO errors --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on timescaledb.enable_chunk_append | on --- Unoptimized results +++ Optimized results @@ -1,7 +1,7 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off - timescaledb.enable_chunk_append | on + timescaledb.enable_optimizations | on + timescaledb.enable_chunk_append | off time | temp | colorid | attr �������������������������������������������������������������������timescaledb-2.23.0/test/expected/baserel_cache.out��������������������������������������������������0000664�0000000�0000000�00000001764�15100345067�0022134�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that the baserel cache is not clobbered if there's an error -- in a SQL function. CREATE TABLE valid_ids ( id UUID PRIMARY KEY ); CREATE FUNCTION DEFAULT_UUID(TEXT DEFAULT '') RETURNS UUID AS $$ BEGIN RETURN COALESCE($1, '')::UUID; EXCEPTION WHEN invalid_text_representation THEN RETURN '00000000-0000-0000-0000-000000000000'; END; $$ LANGUAGE PLPGSQL IMMUTABLE; CREATE FUNCTION KNOWN_ID(UUID, TEXT) RETURNS UUID AS $$ SELECT COALESCE( (SELECT id FROM valid_ids WHERE id = $1), DEFAULT_UUID() ); $$ LANGUAGE SQL; SELECT KNOWN_ID(NULL, ''), KNOWN_ID(NULL, ''); known_id | known_id --------------------------------------+-------------------------------------- 00000000-0000-0000-0000-000000000000 | 00000000-0000-0000-0000-000000000000 ������������timescaledb-2.23.0/test/expected/bgw_launcher.out���������������������������������������������������0000664�0000000�0000000�00000047201�15100345067�0022030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_2 :TEST_DBNAME _2 \c :TEST_DBNAME :ROLE_SUPERUSER -- start bgw since they are stopped for tests by default SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER \ir include/bgw_launcher_utils.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Note on testing: need a couple wrappers that pg_sleep in a loop to wait for changes -- to appear in pg_stat_activity. -- Further Note: PG 9.6 changed what appeared in pg_stat_activity, so the launcher doesn't actually show up. -- we can still test its interactions with its children, but can't test some of the things specific to the launcher. -- So we've added some bits about the version number as needed. CREATE VIEW worker_counts as SELECT count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Launcher') as launcher, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME') as single_scheduler, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2') as single_2_scheduler, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = 'template1') as template1_scheduler FROM pg_stat_activity; CREATE FUNCTION wait_worker_counts(launcher_ct INTEGER, scheduler1_ct INTEGER, scheduler2_ct INTEGER, template1_ct INTEGER) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1..10 LOOP SELECT COUNT(*) from worker_counts where launcher = launcher_ct AND single_scheduler = scheduler1_ct AND single_2_scheduler = scheduler2_ct and template1_scheduler = template1_ct into r; if(r < 1) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE --We have the correct counts! RETURN TRUE; END IF; END LOOP; RETURN FALSE; END $BODY$; CREATE FUNCTION wait_for_bgw_scheduler(_datname NAME, _count INT DEFAULT 1, _ticks INT DEFAULT 10) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1.._ticks LOOP SELECT count(*) FROM pg_stat_activity WHERE application_name = 'TimescaleDB Background Worker Scheduler' AND datname = _datname INTO r; IF(r <> _count) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN 'BGW Scheduler found.'; END IF; END LOOP; RETURN 'BGW Scheduler NOT found.'; END $BODY$; CREATE PROCEDURE kill_database_backends(_datname NAME) LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1..100 LOOP SELECT count(pg_terminate_backend(pg_stat_activity.pid)) FROM pg_stat_activity WHERE datname = _datname AND pg_stat_activity.pid <> pg_backend_pid() INTO r; IF(r = 0) THEN RETURN; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RAISE 'Failed to terminate backends'; END $BODY$; -- When we've connected to test db 2, we should be able to see the cluster launcher -- and the scheduler for test db in pg_stat_activity -- but test db 2 shouldn't have a scheduler because ext not created yet SELECT wait_worker_counts(1,1,0,0); wait_worker_counts -------------------- t -- Now create the extension in test db 2 SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; SELECT wait_worker_counts(1,1,1,0); wait_worker_counts -------------------- t DROP DATABASE :TEST_DBNAME WITH (FORCE); -- Now the db_scheduler for test db should have disappeared SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t -- Now let's restart the scheduler in test db 2 and make sure our backend_start changed SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset -- We'll do this in a txn so that we can see that the worker locks on our txn before continuing BEGIN; SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t SELECT (backend_start > :'orig_backend_start'::timestamptz) backend_start_changed, (wait_event = 'virtualxid') wait_event_changed FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2'; backend_start_changed | wait_event_changed -----------------------+-------------------- t | t COMMIT; SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t SELECT (wait_event IS DISTINCT FROM 'virtualxid') wait_event_changed FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2'; wait_event_changed -------------------- t -- Test stop SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t -- Make sure it doesn't break if we stop twice in a row SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t -- test start SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t -- make sure start is idempotent SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset -- Since we're doing idempotency tests, we're also going to exercise our queue and start 20 times SELECT _timescaledb_functions.start_background_workers() as start_background_workers, * FROM generate_series(1,20); start_background_workers | generate_series --------------------------+----------------- t | 1 t | 2 t | 3 t | 4 t | 5 t | 6 t | 7 t | 8 t | 9 t | 10 t | 11 t | 12 t | 13 t | 14 t | 15 t | 16 t | 17 t | 18 t | 19 t | 20 -- Here we're waiting to see if something shows up in pg_stat_activity, -- so we have to condition our loop in the opposite way. We'll only wait -- half a second in total as well so that tests don't take too long. CREATE FUNCTION wait_equals(TIMESTAMPTZ, TEXT) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r BOOLEAN; BEGIN FOR i in 1..5 LOOP SELECT (backend_start = $1::timestamptz) backend_start_unchanged FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = $2 into r; if(r) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN FALSE; END IF; END LOOP; RETURN TRUE; END $BODY$; select wait_equals(:'orig_backend_start', :'TEST_DBNAME_2'); wait_equals ------------- t -- Make sure restart starts a worker even if it is stopped SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t -- Make sure drop extension statement restarts the worker and on rollback it keeps running -- Now let's restart the scheduler and make sure our backend_start changed SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset BEGIN; DROP EXTENSION timescaledb; SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t ROLLBACK; CREATE FUNCTION wait_greater(TIMESTAMPTZ,TEXT) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r BOOLEAN; BEGIN FOR i in 1..10 LOOP SELECT (backend_start > $1::timestamptz) backend_start_changed FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = $2 into r; if(NOT r) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN TRUE; END IF; END LOOP; RETURN FALSE; END $BODY$; SELECT wait_greater(:'orig_backend_start',:'TEST_DBNAME_2'); wait_greater -------------- t -- Make sure canceling the launcher backend causes a restart of schedulers SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Launcher'; pg_cancel_backend ------------------- t SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t SELECT wait_greater(:'orig_backend_start', :'TEST_DBNAME_2'); wait_greater -------------- t -- Make sure running pre_restore function stops background workers SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t -- Make sure a restart with restoring on first starts the background worker BEGIN; SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t COMMIT; -- Then the worker dies when it sees that restoring is on after the txn commits SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t --And post_restore starts them BEGIN; SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t COMMIT; -- And they stay started SELECT wait_worker_counts(1,0,1,0); wait_worker_counts -------------------- t -- Make sure dropping the extension means that the scheduler is stopped BEGIN; DROP EXTENSION timescaledb; COMMIT; SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t -- Test that background workers are stopped with DROP OWNED ALTER ROLE :ROLE_DEFAULT_PERM_USER WITH SUPERUSER; \c :TEST_DBNAME_2 :ROLE_DEFAULT_PERM_USER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; -- Make sure there is 1 launcher and 1 bgw in test db 2 SELECT wait_worker_counts(launcher_ct=>1, scheduler1_ct=> 0, scheduler2_ct=>1, template1_ct=>0); wait_worker_counts -------------------- t -- drop a non-owner of the extension results in no change to worker counts DROP OWNED BY :ROLE_DEFAULT_PERM_USER_2; SELECT wait_worker_counts(launcher_ct=>1, scheduler1_ct=> 0, scheduler2_ct=>1, template1_ct=>0); wait_worker_counts -------------------- t -- drop of owner of extension results in extension drop and a stop to the bgw DROP OWNED BY :ROLE_DEFAULT_PERM_USER; -- The worker in test db 2 is dead. Note that 0s are respected SELECT wait_worker_counts(launcher_ct=>1, scheduler1_ct=>0, scheduler2_ct=>0, template1_ct=>0); wait_worker_counts -------------------- t \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER ROLE :ROLE_DEFAULT_PERM_USER WITH NOSUPERUSER; -- Connect to the template1 database \c template1 \ir include/bgw_launcher_utils.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Note on testing: need a couple wrappers that pg_sleep in a loop to wait for changes -- to appear in pg_stat_activity. -- Further Note: PG 9.6 changed what appeared in pg_stat_activity, so the launcher doesn't actually show up. -- we can still test its interactions with its children, but can't test some of the things specific to the launcher. -- So we've added some bits about the version number as needed. CREATE VIEW worker_counts as SELECT count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Launcher') as launcher, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME') as single_scheduler, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2') as single_2_scheduler, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = 'template1') as template1_scheduler FROM pg_stat_activity; CREATE FUNCTION wait_worker_counts(launcher_ct INTEGER, scheduler1_ct INTEGER, scheduler2_ct INTEGER, template1_ct INTEGER) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1..10 LOOP SELECT COUNT(*) from worker_counts where launcher = launcher_ct AND single_scheduler = scheduler1_ct AND single_2_scheduler = scheduler2_ct and template1_scheduler = template1_ct into r; if(r < 1) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE --We have the correct counts! RETURN TRUE; END IF; END LOOP; RETURN FALSE; END $BODY$; CREATE FUNCTION wait_for_bgw_scheduler(_datname NAME, _count INT DEFAULT 1, _ticks INT DEFAULT 10) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1.._ticks LOOP SELECT count(*) FROM pg_stat_activity WHERE application_name = 'TimescaleDB Background Worker Scheduler' AND datname = _datname INTO r; IF(r <> _count) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN 'BGW Scheduler found.'; END IF; END LOOP; RETURN 'BGW Scheduler NOT found.'; END $BODY$; CREATE PROCEDURE kill_database_backends(_datname NAME) LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1..100 LOOP SELECT count(pg_terminate_backend(pg_stat_activity.pid)) FROM pg_stat_activity WHERE datname = _datname AND pg_stat_activity.pid <> pg_backend_pid() INTO r; IF(r = 0) THEN RETURN; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RAISE 'Failed to terminate backends'; END $BODY$; BEGIN; -- Then create extension there in a txn and make sure we see a scheduler start SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; SELECT wait_worker_counts(1,0,0,1); wait_worker_counts -------------------- t COMMIT; -- End our transaction and it should immediately exit because it's a template database. SELECT wait_worker_counts(1,0,0,0); wait_worker_counts -------------------- t \c :TEST_DBNAME_2 -- Now try creating a DB from a template with the extension already installed. -- Make sure we see a scheduler start. CREATE DATABASE :TEST_DBNAME; SELECT wait_worker_counts(1,1,0,0); wait_worker_counts -------------------- t DROP DATABASE :TEST_DBNAME WITH (FORCE); -- Now make sure that there's no race between create database and create extension. -- Although to be honest, this race probably wouldn't manifest in this test. \c template1 DROP EXTENSION timescaledb; \c :TEST_DBNAME_2 CREATE DATABASE :TEST_DBNAME; \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb; RESET client_min_messages; \c :TEST_DBNAME_2 SELECT wait_worker_counts(1,1,0,0); wait_worker_counts -------------------- t -- test rename database CREATE DATABASE db_rename_test; \c db_rename_test :ROLE_SUPERUSER SET client_min_messages=error; CREATE EXTENSION timescaledb; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT wait_for_bgw_scheduler('db_rename_test'); wait_for_bgw_scheduler ------------------------ BGW Scheduler found. ALTER DATABASE db_rename_test RENAME TO db_rename_test2; WARNING: you need to manually restart any running background workers after this command DROP DATABASE db_rename_test2 WITH (FORCE); -- test create database with timescaledb database as template SELECT wait_for_bgw_scheduler(:'TEST_DBNAME'); wait_for_bgw_scheduler ------------------------ BGW Scheduler found. CREATE DATABASE db_from_template WITH TEMPLATE :TEST_DBNAME; SELECT wait_for_bgw_scheduler(:'TEST_DBNAME'); wait_for_bgw_scheduler ------------------------ BGW Scheduler found. DROP DATABASE db_from_template WITH (FORCE); -- test alter database set tablespace SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; -- Stop background worker before we change the tablespace of the database (otherwise, the database might be used) SELECT wait_for_bgw_scheduler(:'TEST_DBNAME'); wait_for_bgw_scheduler ------------------------ BGW Scheduler found. -- Connect to TEST_DBNAME (_timescaledb_functions.stop_background_workers() is not available in TEST_DBNAME_2) \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Launcher'; pg_terminate_backend ---------------------- t \c :TEST_DBNAME_2 :ROLE_SUPERUSER -- make sure nobody is using it REVOKE CONNECT ON DATABASE :TEST_DBNAME FROM public; CALL kill_database_backends(:'TEST_DBNAME'); -- Change tablespace ALTER DATABASE :TEST_DBNAME SET TABLESPACE tablespace1; WARNING: you may need to manually restart any running background workers after this command -- tear down test and clean up additional database \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers() \gset REVOKE CONNECT ON DATABASE :TEST_DBNAME_2 FROM public; CALL kill_database_backends(:'TEST_DBNAME_2'); SELECT * FROM pg_stat_activity WHERE datname = :'TEST_DBNAME_2'; datid | datname | pid | leader_pid | usesysid | usename | application_name | client_addr | client_hostname | client_port | backend_start | xact_start | query_start | state_change | wait_event_type | wait_event | state | backend_xid | backend_xmin | query_id | query | backend_type -------+---------+-----+------------+----------+---------+------------------+-------------+-----------------+-------------+---------------+------------+-------------+--------------+-----------------+------------+-------+-------------+--------------+----------+-------+-------------- DROP DATABASE :TEST_DBNAME_2 WITH (force); -- Clean up the template database, removing our test utilities etc \c template1 \ir include/bgw_launcher_utils_cleanup.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP FUNCTION wait_worker_counts(integer, integer, integer, integer); DROP VIEW worker_counts; DROP FUNCTION wait_for_bgw_scheduler(name,int,int); DROP PROCEDURE kill_database_backends(name); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/c_unit_tests.out���������������������������������������������������0000664�0000000�0000000�00000002117�15100345067�0022070�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.time_to_internal_conversion() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_time_to_internal_conversion' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.interval_to_internal_conversion() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_interval_to_internal_conversion' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.adts() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_adts' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.time_utils() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_time_utils' LANGUAGE C; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT test.time_to_internal_conversion(); time_to_internal_conversion ----------------------------- SELECT test.interval_to_internal_conversion(); interval_to_internal_conversion --------------------------------- SELECT test.adts(); adts ------ SELECT test.time_utils(); time_utils ------------ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/catalog_corruption.out���������������������������������������������0000664�0000000�0000000�00000002157�15100345067�0023267�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER --- Test handling of missing dimension slices CREATE TABLE dim_test(time TIMESTAMPTZ, device int); SELECT create_hypertable('dim_test', 'time', chunk_time_interval => INTERVAL '1 day'); create_hypertable ----------------------- (1,public,dim_test,t) -- Create two chunks INSERT INTO dim_test values('2000-01-01 00:00:00', 1); INSERT INTO dim_test values('2020-01-01 00:00:00', 1); SELECT id AS dim_slice_id FROM _timescaledb_catalog.dimension_slice ORDER BY id DESC LIMIT 1 \gset -- Delete the dimension slice for the second chunk DELETE FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id = :dim_slice_id; \set ON_ERROR_STOP 0 -- Select data SELECT * FROM dim_test; ERROR: chunk _hyper_1_2_chunk has no dimension slices -- Select data using ordered append SELECT * FROM dim_test ORDER BY time; ERROR: chunk _hyper_1_2_chunk has no dimension slices \set ON_ERROR_STOP 1 DROP TABLE dim_test; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/chunk_adaptive.out�������������������������������������������������0000664�0000000�0000000�00000117343�15100345067�0022362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- test error handling _timescaledb_functions.calculate_chunk_interval \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.calculate_chunk_interval(0,0,-0); ERROR: could not find a matching hypertable for dimension 0 SELECT _timescaledb_functions.calculate_chunk_interval(1,0,-1); ERROR: chunk_target_size must be positive \set ON_ERROR_STOP 1 -- Valid chunk sizing function for testing CREATE OR REPLACE FUNCTION calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN -1; END $BODY$; -- Chunk sizing function with bad signature CREATE OR REPLACE FUNCTION bad_calculate_chunk_interval( dimension_id INTEGER ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN -1; END $BODY$; -- Set a fixed memory cache size to make tests determinstic -- (independent of available machine memory) SELECT * FROM test.set_memory_cache_size('2GB'); set_memory_cache_size ----------------------- 2147483648 -- test NULL handling \set ON_ERROR_STOP 0 SELECT * FROM set_adaptive_chunking(NULL,NULL); ERROR: invalid hypertable: cannot be NULL \set ON_ERROR_STOP 1 CREATE TABLE test_adaptive(time timestamptz, temp float, location int); \set ON_ERROR_STOP 0 -- Bad signature of sizing func should fail SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', chunk_sizing_func => 'bad_calculate_chunk_interval'); ERROR: invalid function signature \set ON_ERROR_STOP 1 -- Setting sizing func with correct signature should work SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', chunk_sizing_func => 'calculate_chunk_interval'); WARNING: target chunk size for adaptive chunking is less than 10 MB NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ---------------------------- (1,public,test_adaptive,t) DROP TABLE test_adaptive; CREATE TABLE test_adaptive(time timestamptz, temp float, location int); -- Size but no explicit func should use default func SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', create_default_indexes => true); WARNING: target chunk size for adaptive chunking is less than 10 MB NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ---------------------------- (2,public,test_adaptive,t) SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 1048576 -- Check that adaptive chunking sets a 1 day default chunk time -- interval => 86400000000 microseconds SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+--------------------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 2 | 2 | time | timestamp with time zone | t | | | | 86400000000 | | | -- Change the target size SELECT * FROM set_adaptive_chunking('test_adaptive', '2MB'); WARNING: target chunk size for adaptive chunking is less than 10 MB chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 2097152 SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 2097152 \set ON_ERROR_STOP 0 -- Setting NULL func should fail SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB', NULL); ERROR: invalid chunk sizing function \set ON_ERROR_STOP 1 -- Setting NULL size disables adaptive chunking SELECT * FROM set_adaptive_chunking('test_adaptive', NULL); chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 0 SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 0 SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB'); WARNING: target chunk size for adaptive chunking is less than 10 MB chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 1048576 -- Setting size to 'off' should also disable SELECT * FROM set_adaptive_chunking('test_adaptive', 'off'); chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 0 SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 0 -- Setting 0 size should also disable SELECT * FROM set_adaptive_chunking('test_adaptive', '0MB'); chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 0 SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 0 SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB'); WARNING: target chunk size for adaptive chunking is less than 10 MB chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 1048576 -- No warning about small target size if > 10MB SELECT * FROM set_adaptive_chunking('test_adaptive', '11MB'); chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 11534336 -- Setting size to 'estimate' should also estimate size SELECT * FROM set_adaptive_chunking('test_adaptive', 'estimate'); chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 1932735283 SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 1932735283 -- Use a lower memory setting to test that the calculated chunk_target_size is reduced SELECT * FROM test.set_memory_cache_size('512MB'); set_memory_cache_size ----------------------- 536870912 SELECT * FROM set_adaptive_chunking('test_adaptive', 'estimate'); chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 483183820 SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; table_name | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size ---------------+--------------------------+--------------------------+------------------- test_adaptive | _timescaledb_functions | calculate_chunk_interval | 483183820 -- Reset memory settings SELECT * FROM test.set_memory_cache_size('2GB'); set_memory_cache_size ----------------------- 2147483648 -- Set a reasonable test value SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB'); WARNING: target chunk size for adaptive chunking is less than 10 MB chunk_sizing_func | chunk_target_size -------------------------------------------------+------------------- _timescaledb_functions.calculate_chunk_interval | 1048576 -- Show the interval length before and after adaptation SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; id | hypertable_id | interval_length ----+---------------+----------------- 2 | 2 | 86400000000 -- Generate data to create chunks. We use the hash of the time value -- to get determinstic location IDs so that we always spread these -- values the same way across space partitions INSERT INTO test_adaptive SELECT time, random() * 35, _timescaledb_functions.get_partition_hash(time) FROM generate_series('2017-03-07T18:18:03+00'::timestamptz - interval '175 days', '2017-03-07T18:18:03+00'::timestamptz, '2 minutes') as time; SELECT chunk_name, primary_dimension, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive' ORDER BY chunk_name; chunk_name | primary_dimension | range_start | range_end -------------------+-------------------+-------------------------------------+------------------------------------- _hyper_2_10_chunk | time | Fri Sep 23 22:08:15.728855 2016 PDT | Sat Oct 01 13:16:09.024252 2016 PDT _hyper_2_11_chunk | time | Sat Oct 01 13:16:09.024252 2016 PDT | Fri Oct 14 03:19:44.231212 2016 PDT _hyper_2_12_chunk | time | Fri Oct 14 03:19:44.231212 2016 PDT | Wed Oct 26 19:20:54.4938 2016 PDT _hyper_2_13_chunk | time | Wed Oct 26 19:20:54.4938 2016 PDT | Fri Nov 04 04:03:56.248528 2016 PDT _hyper_2_14_chunk | time | Fri Nov 04 04:03:56.248528 2016 PDT | Fri Nov 18 21:58:20.411232 2016 PST _hyper_2_15_chunk | time | Fri Nov 18 21:58:20.411232 2016 PST | Sat Dec 03 16:52:44.573936 2016 PST _hyper_2_16_chunk | time | Sat Dec 03 16:52:44.573936 2016 PST | Sun Dec 18 11:47:08.73664 2016 PST _hyper_2_17_chunk | time | Sun Dec 18 11:47:08.73664 2016 PST | Mon Jan 02 06:41:32.899344 2017 PST _hyper_2_18_chunk | time | Mon Jan 02 06:41:32.899344 2017 PST | Tue Jan 17 01:35:57.062048 2017 PST _hyper_2_19_chunk | time | Tue Jan 17 01:35:57.062048 2017 PST | Tue Jan 31 20:30:21.224752 2017 PST _hyper_2_1_chunk | time | Mon Sep 12 17:00:00 2016 PDT | Tue Sep 13 17:00:00 2016 PDT _hyper_2_20_chunk | time | Tue Jan 31 20:30:21.224752 2017 PST | Wed Feb 15 15:24:45.387456 2017 PST _hyper_2_21_chunk | time | Wed Feb 15 15:24:45.387456 2017 PST | Thu Mar 02 10:19:09.55016 2017 PST _hyper_2_22_chunk | time | Thu Mar 02 10:19:09.55016 2017 PST | Fri Mar 17 06:13:33.712864 2017 PDT _hyper_2_2_chunk | time | Tue Sep 13 17:00:00 2016 PDT | Wed Sep 14 17:00:00 2016 PDT _hyper_2_3_chunk | time | Wed Sep 14 17:00:00 2016 PDT | Thu Sep 15 17:00:00 2016 PDT _hyper_2_4_chunk | time | Thu Sep 15 17:00:00 2016 PDT | Fri Sep 16 15:02:54.2208 2016 PDT _hyper_2_5_chunk | time | Fri Sep 16 15:02:54.2208 2016 PDT | Sun Sep 18 03:12:14.342144 2016 PDT _hyper_2_6_chunk | time | Sun Sep 18 03:12:14.342144 2016 PDT | Mon Sep 19 15:21:34.463488 2016 PDT _hyper_2_7_chunk | time | Mon Sep 19 15:21:34.463488 2016 PDT | Wed Sep 21 03:30:54.584832 2016 PDT _hyper_2_8_chunk | time | Wed Sep 21 03:30:54.584832 2016 PDT | Thu Sep 22 03:45:14.901568 2016 PDT _hyper_2_9_chunk | time | Thu Sep 22 03:45:14.901568 2016 PDT | Fri Sep 23 22:08:15.728855 2016 PDT -- Do same thing without an index on the time column. This affects -- both the calculation of fill-factor of the chunk and its size CREATE TABLE test_adaptive_no_index(time timestamptz, temp float, location int); -- Size but no explicit func should use default func -- No default indexes should warn and use heap scan for min and max SELECT create_hypertable('test_adaptive_no_index', 'time', chunk_target_size => '1MB', create_default_indexes => false); WARNING: target chunk size for adaptive chunking is less than 10 MB WARNING: no index on "time" found for adaptive chunking on hypertable "test_adaptive_no_index" NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ------------------------------------- (3,public,test_adaptive_no_index,t) SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; id | hypertable_id | interval_length ----+---------------+----------------- 2 | 2 | 1277664162704 3 | 3 | 86400000000 INSERT INTO test_adaptive_no_index SELECT time, random() * 35, _timescaledb_functions.get_partition_hash(time) FROM generate_series('2017-03-07T18:18:03+00'::timestamptz - interval '175 days', '2017-03-07T18:18:03+00'::timestamptz, '2 minutes') as time; WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_23_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_23_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_24_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_23_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_24_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_25_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_24_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_25_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_26_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_25_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_26_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_27_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_26_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_27_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_28_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_27_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_28_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_29_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_28_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_29_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_30_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_29_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_30_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_31_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_30_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_31_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_32_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_31_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_32_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_33_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_32_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_33_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_34_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_33_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_34_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_35_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_34_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_35_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_36_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_35_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_36_chunk" WARNING: no index on "time" found for adaptive chunking on chunk "_hyper_3_37_chunk" SELECT chunk_name, primary_dimension, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive_no_index' ORDER BY chunk_name; chunk_name | primary_dimension | range_start | range_end -------------------+-------------------+-------------------------------------+------------------------------------- _hyper_3_23_chunk | time | Mon Sep 12 17:00:00 2016 PDT | Tue Sep 13 17:00:00 2016 PDT _hyper_3_24_chunk | time | Tue Sep 13 17:00:00 2016 PDT | Wed Sep 14 17:00:00 2016 PDT _hyper_3_25_chunk | time | Wed Sep 14 17:00:00 2016 PDT | Thu Sep 15 17:00:00 2016 PDT _hyper_3_26_chunk | time | Thu Sep 15 17:00:00 2016 PDT | Sun Sep 18 02:18:45.310968 2016 PDT _hyper_3_27_chunk | time | Sun Sep 18 02:18:45.310968 2016 PDT | Sun Sep 18 06:20:21.359312 2016 PDT _hyper_3_28_chunk | time | Sun Sep 18 06:20:21.359312 2016 PDT | Wed Sep 21 08:25:00.957966 2016 PDT _hyper_3_29_chunk | time | Wed Sep 21 08:25:00.957966 2016 PDT | Thu Sep 22 03:26:42.599807 2016 PDT _hyper_3_30_chunk | time | Thu Sep 22 03:26:42.599807 2016 PDT | Sun Sep 25 18:03:30.59359 2016 PDT _hyper_3_31_chunk | time | Sun Sep 25 18:03:30.59359 2016 PDT | Sat Oct 08 05:32:02.75732 2016 PDT _hyper_3_32_chunk | time | Sat Oct 08 05:32:02.75732 2016 PDT | Mon Oct 31 07:33:42.652938 2016 PDT _hyper_3_33_chunk | time | Mon Oct 31 07:33:42.652938 2016 PDT | Wed Nov 23 08:35:22.548556 2016 PST _hyper_3_34_chunk | time | Wed Nov 23 08:35:22.548556 2016 PST | Thu Dec 15 09:48:28.1888 2016 PST _hyper_3_35_chunk | time | Thu Dec 15 09:48:28.1888 2016 PST | Wed Jan 11 04:57:38.357845 2017 PST _hyper_3_36_chunk | time | Wed Jan 11 04:57:38.357845 2017 PST | Tue Feb 07 00:06:48.52689 2017 PST _hyper_3_37_chunk | time | Tue Feb 07 00:06:48.52689 2017 PST | Sun Mar 05 19:15:58.695935 2017 PST _hyper_3_38_chunk | time | Sun Mar 05 19:15:58.695935 2017 PST | Sat Apr 01 15:25:08.86498 2017 PDT -- Test added to check that the correct index (i.e. time index) is being used -- to find the min and max. Previously a bug selected the first index listed, -- which in this case is location rather than time and therefore could return -- the wrong min and max if items at the start and end of the index did not have -- the correct min and max timestamps. -- -- In this test, we create chunks with a lot of locations with only one reading -- that is at the beginning of the time frame, and then one location in the middle -- of the range that has two readings, one that is the same as the others and one -- that is larger. The algorithm should use these two readings for min & max; however, -- if it's broken (as it was before), it would choose just the reading that is common -- to all the locations. CREATE TABLE test_adaptive_correct_index(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive_correct_index', 'time', chunk_target_size => '100MB', chunk_time_interval => 86400000000, create_default_indexes => false); WARNING: no index on "time" found for adaptive chunking on hypertable "test_adaptive_correct_index" NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ------------------------------------------ (4,public,test_adaptive_correct_index,t) CREATE INDEX ON test_adaptive_correct_index(location); CREATE INDEX ON test_adaptive_correct_index(time DESC); -- First chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-01T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-01T00:00:00+00'::timestamptz, '2018-01-01T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-01T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- Second chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-02T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-02T00:00:00+00'::timestamptz, '2018-01-02T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-02T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- Third chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-03T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-03T00:00:00+00'::timestamptz, '2018-01-03T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-03T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- This should be the start of the fourth chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-04T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-04T00:00:00+00'::timestamptz, '2018-01-04T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-04T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- If working correctly, this goes in the 4th chunk, otherwise its a separate 5th chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-05T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-05T00:00:00+00'::timestamptz, '2018-01-05T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-05T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- This should show 4 chunks, rather than 5 SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive_correct_index'; count ------- 4 -- The interval_length should no longer be 86400000000 for our hypertable, so 3rd column so be true. -- Note: the exact interval_length is non-deterministic, so we can't use its actual value for tests SELECT id, hypertable_id, interval_length > 86400000000 FROM _timescaledb_catalog.dimension; id | hypertable_id | ?column? ----+---------------+---------- 2 | 2 | t 3 | 3 | t 4 | 4 | t -- Drop because it's size and estimated chunk_interval is non-deterministic so -- we don't want to make other tests flaky. DROP TABLE test_adaptive_correct_index; -- Test with space partitioning. This might affect the estimation -- since there are more chunks in the same time interval and space -- chunks might be unevenly filled. CREATE TABLE test_adaptive_space(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive_space', 'time', 'location', 2, chunk_target_size => '1MB', create_default_indexes => true); WARNING: target chunk size for adaptive chunking is less than 10 MB NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ---------------------------------- (5,public,test_adaptive_space,t) SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; id | hypertable_id | interval_length ----+---------------+----------------- 2 | 2 | 1277664162704 3 | 3 | 2315350169045 5 | 5 | 86400000000 6 | 5 | INSERT INTO test_adaptive_space SELECT time, random() * 35, _timescaledb_functions.get_partition_hash(time) FROM generate_series('2017-03-07T18:18:03+00'::timestamptz - interval '175 days', '2017-03-07T18:18:03+00'::timestamptz, '2 minutes') as time; \x SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive_space' ORDER BY chunk_name; -[ RECORD 1 ]------------------------------------ chunk_name | _hyper_5_43_chunk range_start | Mon Sep 12 17:00:00 2016 PDT range_end | Tue Sep 13 17:00:00 2016 PDT -[ RECORD 2 ]------------------------------------ chunk_name | _hyper_5_44_chunk range_start | Mon Sep 12 17:00:00 2016 PDT range_end | Tue Sep 13 17:00:00 2016 PDT -[ RECORD 3 ]------------------------------------ chunk_name | _hyper_5_45_chunk range_start | Tue Sep 13 17:00:00 2016 PDT range_end | Wed Sep 14 17:00:00 2016 PDT -[ RECORD 4 ]------------------------------------ chunk_name | _hyper_5_46_chunk range_start | Tue Sep 13 17:00:00 2016 PDT range_end | Wed Sep 14 17:00:00 2016 PDT -[ RECORD 5 ]------------------------------------ chunk_name | _hyper_5_47_chunk range_start | Wed Sep 14 17:00:00 2016 PDT range_end | Thu Sep 15 11:47:51.47376 2016 PDT -[ RECORD 6 ]------------------------------------ chunk_name | _hyper_5_48_chunk range_start | Wed Sep 14 17:00:00 2016 PDT range_end | Thu Sep 15 11:47:51.47376 2016 PDT -[ RECORD 7 ]------------------------------------ chunk_name | _hyper_5_49_chunk range_start | Thu Sep 15 11:47:51.47376 2016 PDT range_end | Sat Sep 17 02:40:49.182352 2016 PDT -[ RECORD 8 ]------------------------------------ chunk_name | _hyper_5_50_chunk range_start | Thu Sep 15 11:47:51.47376 2016 PDT range_end | Sat Sep 17 02:40:49.182352 2016 PDT -[ RECORD 9 ]------------------------------------ chunk_name | _hyper_5_51_chunk range_start | Sat Sep 17 02:40:49.182352 2016 PDT range_end | Sun Sep 18 17:33:46.890944 2016 PDT -[ RECORD 10 ]----------------------------------- chunk_name | _hyper_5_52_chunk range_start | Sat Sep 17 02:40:49.182352 2016 PDT range_end | Sun Sep 18 17:33:46.890944 2016 PDT -[ RECORD 11 ]----------------------------------- chunk_name | _hyper_5_53_chunk range_start | Sun Sep 18 17:33:46.890944 2016 PDT range_end | Sun Sep 18 20:35:55.67676 2016 PDT -[ RECORD 12 ]----------------------------------- chunk_name | _hyper_5_54_chunk range_start | Sun Sep 18 17:33:46.890944 2016 PDT range_end | Sun Sep 18 20:35:55.67676 2016 PDT -[ RECORD 13 ]----------------------------------- chunk_name | _hyper_5_55_chunk range_start | Sun Sep 18 20:35:55.67676 2016 PDT range_end | Tue Sep 20 18:46:40.16883 2016 PDT -[ RECORD 14 ]----------------------------------- chunk_name | _hyper_5_56_chunk range_start | Sun Sep 18 20:35:55.67676 2016 PDT range_end | Tue Sep 20 18:46:40.16883 2016 PDT -[ RECORD 15 ]----------------------------------- chunk_name | _hyper_5_57_chunk range_start | Tue Sep 20 18:46:40.16883 2016 PDT range_end | Sun Oct 02 16:44:29.071032 2016 PDT -[ RECORD 16 ]----------------------------------- chunk_name | _hyper_5_58_chunk range_start | Tue Sep 20 18:46:40.16883 2016 PDT range_end | Sun Oct 02 16:44:29.071032 2016 PDT -[ RECORD 17 ]----------------------------------- chunk_name | _hyper_5_59_chunk range_start | Sun Oct 02 16:44:29.071032 2016 PDT range_end | Tue Oct 11 00:37:03.738979 2016 PDT -[ RECORD 18 ]----------------------------------- chunk_name | _hyper_5_60_chunk range_start | Sun Oct 02 16:44:29.071032 2016 PDT range_end | Tue Oct 11 00:37:03.738979 2016 PDT -[ RECORD 19 ]----------------------------------- chunk_name | _hyper_5_61_chunk range_start | Tue Oct 11 00:37:03.738979 2016 PDT range_end | Thu Oct 27 03:05:25.740618 2016 PDT -[ RECORD 20 ]----------------------------------- chunk_name | _hyper_5_62_chunk range_start | Tue Oct 11 00:37:03.738979 2016 PDT range_end | Thu Oct 27 03:05:25.740618 2016 PDT -[ RECORD 21 ]----------------------------------- chunk_name | _hyper_5_63_chunk range_start | Thu Oct 27 03:05:25.740618 2016 PDT range_end | Sun Nov 13 12:38:49.541703 2016 PST -[ RECORD 22 ]----------------------------------- chunk_name | _hyper_5_64_chunk range_start | Thu Oct 27 03:05:25.740618 2016 PDT range_end | Sun Nov 13 12:38:49.541703 2016 PST -[ RECORD 23 ]----------------------------------- chunk_name | _hyper_5_65_chunk range_start | Sun Nov 13 12:38:49.541703 2016 PST range_end | Fri Dec 02 17:45:40.237036 2016 PST -[ RECORD 24 ]----------------------------------- chunk_name | _hyper_5_66_chunk range_start | Sun Nov 13 12:38:49.541703 2016 PST range_end | Fri Dec 02 17:45:40.237036 2016 PST -[ RECORD 25 ]----------------------------------- chunk_name | _hyper_5_67_chunk range_start | Fri Dec 02 17:45:40.237036 2016 PST range_end | Wed Dec 21 22:52:30.932369 2016 PST -[ RECORD 26 ]----------------------------------- chunk_name | _hyper_5_68_chunk range_start | Fri Dec 02 17:45:40.237036 2016 PST range_end | Wed Dec 21 22:52:30.932369 2016 PST -[ RECORD 27 ]----------------------------------- chunk_name | _hyper_5_69_chunk range_start | Wed Dec 21 22:52:30.932369 2016 PST range_end | Tue Jan 10 03:59:21.627702 2017 PST -[ RECORD 28 ]----------------------------------- chunk_name | _hyper_5_70_chunk range_start | Wed Dec 21 22:52:30.932369 2016 PST range_end | Tue Jan 10 03:59:21.627702 2017 PST -[ RECORD 29 ]----------------------------------- chunk_name | _hyper_5_71_chunk range_start | Tue Jan 10 03:59:21.627702 2017 PST range_end | Sun Jan 29 09:06:12.323035 2017 PST -[ RECORD 30 ]----------------------------------- chunk_name | _hyper_5_72_chunk range_start | Tue Jan 10 03:59:21.627702 2017 PST range_end | Sun Jan 29 09:06:12.323035 2017 PST -[ RECORD 31 ]----------------------------------- chunk_name | _hyper_5_73_chunk range_start | Sun Jan 29 09:06:12.323035 2017 PST range_end | Fri Feb 17 14:13:03.018368 2017 PST -[ RECORD 32 ]----------------------------------- chunk_name | _hyper_5_74_chunk range_start | Sun Jan 29 09:06:12.323035 2017 PST range_end | Fri Feb 17 14:13:03.018368 2017 PST -[ RECORD 33 ]----------------------------------- chunk_name | _hyper_5_75_chunk range_start | Fri Feb 17 14:13:03.018368 2017 PST range_end | Wed Mar 08 19:19:53.713701 2017 PST -[ RECORD 34 ]----------------------------------- chunk_name | _hyper_5_76_chunk range_start | Fri Feb 17 14:13:03.018368 2017 PST range_end | Wed Mar 08 19:19:53.713701 2017 PST SELECT * FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_adaptive_space' ORDER BY dimension_number; -[ RECORD 1 ]-----+---------------------------------------- hypertable_schema | public hypertable_name | test_adaptive_space dimension_number | 1 column_name | time column_type | timestamp with time zone dimension_type | Time time_interval | @ 19 days 5 hours 6 mins 50.695333 secs integer_interval | integer_now_func | num_partitions | -[ RECORD 2 ]-----+---------------------------------------- hypertable_schema | public hypertable_name | test_adaptive_space dimension_number | 2 column_name | location column_type | integer dimension_type | Space time_interval | integer_interval | integer_now_func | num_partitions | 2 \x SELECT * FROM chunks_detailed_size('test_adaptive_space') ORDER BY chunk_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+-------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_5_43_chunk | 8192 | 32768 | 0 | 40960 | _timescaledb_internal | _hyper_5_44_chunk | 8192 | 32768 | 0 | 40960 | _timescaledb_internal | _hyper_5_45_chunk | 49152 | 57344 | 0 | 106496 | _timescaledb_internal | _hyper_5_46_chunk | 49152 | 57344 | 0 | 106496 | _timescaledb_internal | _hyper_5_47_chunk | 40960 | 49152 | 0 | 90112 | _timescaledb_internal | _hyper_5_48_chunk | 40960 | 32768 | 0 | 73728 | _timescaledb_internal | _hyper_5_49_chunk | 57344 | 81920 | 0 | 139264 | _timescaledb_internal | _hyper_5_50_chunk | 57344 | 81920 | 0 | 139264 | _timescaledb_internal | _hyper_5_51_chunk | 57344 | 81920 | 0 | 139264 | _timescaledb_internal | _hyper_5_52_chunk | 57344 | 81920 | 0 | 139264 | _timescaledb_internal | _hyper_5_53_chunk | 8192 | 32768 | 0 | 40960 | _timescaledb_internal | _hyper_5_54_chunk | 8192 | 32768 | 0 | 40960 | _timescaledb_internal | _hyper_5_55_chunk | 65536 | 106496 | 0 | 172032 | _timescaledb_internal | _hyper_5_56_chunk | 65536 | 98304 | 0 | 163840 | _timescaledb_internal | _hyper_5_57_chunk | 253952 | 360448 | 0 | 614400 | _timescaledb_internal | _hyper_5_58_chunk | 253952 | 368640 | 0 | 622592 | _timescaledb_internal | _hyper_5_59_chunk | 180224 | 303104 | 0 | 483328 | _timescaledb_internal | _hyper_5_60_chunk | 188416 | 303104 | 0 | 491520 | _timescaledb_internal | _hyper_5_61_chunk | 327680 | 540672 | 0 | 868352 | _timescaledb_internal | _hyper_5_62_chunk | 327680 | 532480 | 0 | 860160 | _timescaledb_internal | _hyper_5_63_chunk | 360448 | 581632 | 0 | 942080 | _timescaledb_internal | _hyper_5_64_chunk | 352256 | 589824 | 0 | 942080 | _timescaledb_internal | _hyper_5_65_chunk | 385024 | 598016 | 0 | 983040 | _timescaledb_internal | _hyper_5_66_chunk | 393216 | 614400 | 0 | 1007616 | _timescaledb_internal | _hyper_5_67_chunk | 385024 | 598016 | 0 | 983040 | _timescaledb_internal | _hyper_5_68_chunk | 393216 | 598016 | 0 | 991232 | _timescaledb_internal | _hyper_5_69_chunk | 393216 | 622592 | 0 | 1015808 | _timescaledb_internal | _hyper_5_70_chunk | 385024 | 606208 | 0 | 991232 | _timescaledb_internal | _hyper_5_71_chunk | 385024 | 614400 | 0 | 999424 | _timescaledb_internal | _hyper_5_72_chunk | 393216 | 622592 | 0 | 1015808 | _timescaledb_internal | _hyper_5_73_chunk | 393216 | 614400 | 0 | 1007616 | _timescaledb_internal | _hyper_5_74_chunk | 385024 | 614400 | 0 | 999424 | _timescaledb_internal | _hyper_5_75_chunk | 360448 | 581632 | 0 | 942080 | _timescaledb_internal | _hyper_5_76_chunk | 368640 | 598016 | 0 | 966656 | SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; id | hypertable_id | interval_length ----+---------------+----------------- 2 | 2 | 1277664162704 3 | 3 | 2315350169045 6 | 5 | 5 | 5 | 1660010695333 -- A previous version stopped working as soon as hypertable_id stopped being -- equal to dimension_id (i.e., there was a hypertable with more than 1 dimension). -- This test comes after test_adaptive_space, which has 2 dimensions, and makes -- sure that it still works. CREATE TABLE test_adaptive_after_multiple_dims(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive_after_multiple_dims', 'time', chunk_target_size => '100MB', create_default_indexes => true); NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ------------------------------------------------ (6,public,test_adaptive_after_multiple_dims,t) INSERT INTO test_adaptive_after_multiple_dims VALUES('2018-01-01T00:00:00+00'::timestamptz, 0.0, 5); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 SELECT * FROM set_adaptive_chunking('test_adaptive', '2MB'); ERROR: must be owner of hypertable "test_adaptive" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now make sure renaming schema gets propagated to the func_schema DROP TABLE test_adaptive; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_chunk_func_schema; CREATE OR REPLACE FUNCTION my_chunk_func_schema.calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN 2; END $BODY$; CREATE TABLE test_adaptive(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', chunk_sizing_func => 'my_chunk_func_schema.calculate_chunk_interval'); WARNING: target chunk size for adaptive chunking is less than 10 MB NOTICE: adaptive chunking is a BETA feature and is not recommended for production deployments create_hypertable ---------------------------- (7,public,test_adaptive,t) ALTER SCHEMA my_chunk_func_schema RENAME TO new_chunk_func_schema; INSERT INTO test_adaptive VALUES (now(), 1.0, 1); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/chunk_merge.out����������������������������������������������������0000664�0000000�0000000�00000013644�15100345067�0021663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_merge_chunks_across_dimension(chunk REGCLASS, merge_chunk REGCLASS, dimension_id INTEGER) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_merge_chunks_across_dimension' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1 ("Time" timestamptz, i integer, value integer); SELECT table_name FROM Create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 hour'); NOTICE: adding not-null constraint to column "Time" table_name ------------ test1 (1 row) SELECT table_name FROM add_dimension('test1', 'i', chunk_time_interval=> 1); NOTICE: adding not-null constraint to column "i" table_name ------------ test1 (1 row) -- This creates chunks 1 - 3 on first hypertable. INSERT INTO test1 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; -- This creates chunks 4 - 6 on first hypertable. INSERT INTO test1 SELECT t, 2, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; CREATE TABLE test2 ("Time" timestamptz, i integer, value integer); SELECT table_name FROM Create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 hour'); NOTICE: adding not-null constraint to column "Time" table_name ------------ test2 (1 row) -- This creates chunks 7 - 9 on second hypertable. INSERT INTO test2 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; SELECT * FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | | f | 0 | f 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | | f | 0 | f 7 | 2 | _timescaledb_internal | _hyper_2_7_chunk | | f | 0 | f 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | | f | 0 | f 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | | f | 0 | f (9 rows) \set ON_ERROR_STOP 0 -- Cannot merge chunks from different hypertables SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_2_7_chunk', 1); ERROR: cannot merge chunks from different hypertables -- Cannot merge non-adjacent chunks SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_3_chunk', 1); ERROR: cannot merge non-adjacent chunks over supplied dimension -- Cannot merge same chunk to itself (its not adjacent to itself). SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_1_chunk', 1); ERROR: cannot merge non-adjacent chunks over supplied dimension -- Cannot merge chunks on with different partitioning schemas. SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_4_chunk', 1); ERROR: cannot merge chunks with different partitioning schemas -- Cannot merge chunks on with non-existant dimension slice. -- NOTE: we are merging the same chunk just so they have the exact same partitioning schema and we don't hit the previous test error. SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_1_chunk', 999); ERROR: cannot find slice for merging dimension \set ON_ERROR_STOP 1 -- Merge on open (time) dimension. SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_5_chunk','_timescaledb_internal._hyper_1_6_chunk', 1); test_merge_chunks_across_dimension ------------------------------------ (1 row) -- Merge on close dimension. SELECT _timescaledb_internal.test_merge_chunks_across_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_4_chunk', 2); test_merge_chunks_across_dimension ------------------------------------ (1 row) SELECT * FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | | f | 0 | f 7 | 2 | _timescaledb_internal | _hyper_2_7_chunk | | f | 0 | f 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | | f | 0 | f 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | | f | 0 | f (7 rows) ��������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/chunk_utils.out����������������������������������������������������0000664�0000000�0000000�00000241517�15100345067�0021726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH 'include/query_result_test_equal.sql' CREATE OR REPLACE FUNCTION dimension_get_time( hypertable_id INT ) RETURNS _timescaledb_catalog.dimension LANGUAGE SQL STABLE AS $BODY$ SELECT * FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = dimension_get_time.hypertable_id AND d.interval_length IS NOT NULL $BODY$; CREATE TABLE PUBLIC.drop_chunk_test1(time bigint, temp float8, device_id text); CREATE TABLE PUBLIC.drop_chunk_test2(time bigint, temp float8, device_id text); CREATE TABLE PUBLIC.drop_chunk_test3(time bigint, temp float8, device_id text); CREATE INDEX ON drop_chunk_test1(time DESC); -- show_chunks() without specifying a table is not allowed \set ON_ERROR_STOP 0 SELECT show_chunks(NULL); ERROR: invalid hypertable or continuous aggregate \set ON_ERROR_STOP 1 SELECT create_hypertable('public.drop_chunk_test1', 'time', chunk_time_interval => 1, create_default_indexes=>false); create_hypertable ------------------------------- (1,public,drop_chunk_test1,t) SELECT create_hypertable('public.drop_chunk_test2', 'time', chunk_time_interval => 1, create_default_indexes=>false); create_hypertable ------------------------------- (2,public,drop_chunk_test2,t) SELECT create_hypertable('public.drop_chunk_test3', 'time', chunk_time_interval => 1, create_default_indexes=>false); create_hypertable ------------------------------- (3,public,drop_chunk_test3,t) -- Add space dimensions to ensure chunks share dimension slices SELECT add_dimension('public.drop_chunk_test1', 'device_id', 2); add_dimension ----------------------------------------- (4,public,drop_chunk_test1,device_id,t) SELECT add_dimension('public.drop_chunk_test2', 'device_id', 2); add_dimension ----------------------------------------- (5,public,drop_chunk_test2,device_id,t) SELECT add_dimension('public.drop_chunk_test3', 'device_id', 2); add_dimension ----------------------------------------- (6,public,drop_chunk_test3,device_id,t) SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+-------------+-------------+----------- SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner --------+------+------+------- SELECT _timescaledb_functions.get_partition_for_key('dev1'::text); get_partition_for_key ----------------------- 1129986420 SELECT _timescaledb_functions.get_partition_for_key('dev7'::varchar(5)); get_partition_for_key ----------------------- 449729092 INSERT INTO PUBLIC.drop_chunk_test1 VALUES(1, 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(2, 2.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(3, 3.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(4, 4.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(5, 5.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(6, 6.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(1, 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(2, 2.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(3, 3.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(4, 4.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(5, 5.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(6, 6.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(1, 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(2, 2.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(3, 3.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(4, 4.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(5, 5.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(6, 6.0, 'dev7'); SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+-------------------+-------------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | 1 | 2 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | 2 | 3 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | 3 | 4 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | 5 | 6 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | 6 | 7 7 | 2 | _timescaledb_internal | _hyper_2_7_chunk | 1 | 2 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | 2 | 3 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | 3 | 4 10 | 2 | _timescaledb_internal | _hyper_2_10_chunk | 4 | 5 11 | 2 | _timescaledb_internal | _hyper_2_11_chunk | 5 | 6 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | 6 | 7 SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_1_1_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_2_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_3_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_4_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_5_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_6_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_10_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_7_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_13_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_14_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_15_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_16_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_17_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_18_chunk | table | default_perm_user -- next two calls of show_chunks should give same set of chunks as above when combined SELECT show_chunks('drop_chunk_test1'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk SELECT * FROM show_chunks('drop_chunk_test2'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk _timescaledb_internal._hyper_2_12_chunk CREATE VIEW dependent_view AS SELECT * FROM _timescaledb_internal._hyper_1_1_chunk; \set ON_ERROR_STOP 0 SELECT drop_chunks('drop_chunk_test1'); ERROR: invalid time range for dropping chunks SELECT drop_chunks('drop_chunk_test1', older_than => 2); ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it SELECT drop_chunks('drop_chunk_test1', older_than => NULL::interval); ERROR: invalid time range for dropping chunks SELECT drop_chunks('drop_chunk_test1', older_than => NULL::int); ERROR: invalid time range for dropping chunks DROP VIEW dependent_view; -- should error because of wrong relative order of time constraints SELECT show_chunks('drop_chunk_test1', older_than=>3, newer_than=>4); ERROR: invalid time range -- Should error because NULL was used for the table name. SELECT drop_chunks(NULL, older_than => 3); ERROR: invalid hypertable or continuous aggregate -- should error because there is no relation with that OID. SELECT drop_chunks(3533, older_than => 3); ERROR: invalid hypertable or continuous aggregate \set ON_ERROR_STOP 1 -- show created constraints and dimension slices for each chunk SELECT c.table_name, cc.constraint_name, ds.id AS dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) FULL OUTER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) ORDER BY c.id; table_name | constraint_name | dimension_slice_id | range_start | range_end -------------------+-----------------+--------------------+----------------------+--------------------- _hyper_1_1_chunk | constraint_1 | 1 | 1 | 2 _hyper_1_1_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_2_chunk | constraint_3 | 3 | 2 | 3 _hyper_1_2_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_3_chunk | constraint_4 | 4 | 3 | 4 _hyper_1_3_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_4_chunk | constraint_5 | 5 | 4 | 5 _hyper_1_4_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_1_5_chunk | constraint_7 | 7 | 5 | 6 _hyper_1_5_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_1_6_chunk | constraint_8 | 8 | 6 | 7 _hyper_1_6_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_2_7_chunk | constraint_9 | 9 | 1 | 2 _hyper_2_7_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_8_chunk | constraint_11 | 11 | 2 | 3 _hyper_2_8_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_9_chunk | constraint_12 | 12 | 3 | 4 _hyper_2_9_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_10_chunk | constraint_13 | 13 | 4 | 5 _hyper_2_10_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_2_11_chunk | constraint_15 | 15 | 5 | 6 _hyper_2_11_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_2_12_chunk | constraint_16 | 16 | 6 | 7 _hyper_2_12_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_3_13_chunk | constraint_17 | 17 | 1 | 2 _hyper_3_13_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_14_chunk | constraint_19 | 19 | 2 | 3 _hyper_3_14_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_15_chunk | constraint_20 | 20 | 3 | 4 _hyper_3_15_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_16_chunk | constraint_21 | 21 | 4 | 5 _hyper_3_16_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 _hyper_3_17_chunk | constraint_23 | 23 | 5 | 6 _hyper_3_17_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 _hyper_3_18_chunk | constraint_24 | 24 | 6 | 7 _hyper_3_18_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 SELECT * FROM _timescaledb_catalog.dimension_slice ORDER BY id; id | dimension_id | range_start | range_end ----+--------------+----------------------+--------------------- 1 | 1 | 1 | 2 2 | 4 | 1073741823 | 9223372036854775807 3 | 1 | 2 | 3 4 | 1 | 3 | 4 5 | 1 | 4 | 5 6 | 4 | -9223372036854775808 | 1073741823 7 | 1 | 5 | 6 8 | 1 | 6 | 7 9 | 2 | 1 | 2 10 | 5 | 1073741823 | 9223372036854775807 11 | 2 | 2 | 3 12 | 2 | 3 | 4 13 | 2 | 4 | 5 14 | 5 | -9223372036854775808 | 1073741823 15 | 2 | 5 | 6 16 | 2 | 6 | 7 17 | 3 | 1 | 2 18 | 6 | 1073741823 | 9223372036854775807 19 | 3 | 2 | 3 20 | 3 | 3 | 4 21 | 3 | 4 | 5 22 | 6 | -9223372036854775808 | 1073741823 23 | 3 | 5 | 6 24 | 3 | 6 | 7 -- Test that truncating chunks works SELECT count(*) FROM _timescaledb_internal._hyper_2_7_chunk; count ------- 1 TRUNCATE TABLE _timescaledb_internal._hyper_2_7_chunk; SELECT count(*) FROM _timescaledb_internal._hyper_2_7_chunk; count ------- 0 -- Drop one chunk "manually" and verify that dimension slices and -- constraints are cleaned up. Each chunk has two constraints and two -- dimension slices. Both constraints should be deleted, but only one -- slice should be deleted since the space-dimension slice is shared -- with other chunks in the same hypertable DROP TABLE _timescaledb_internal._hyper_2_7_chunk; -- Two constraints deleted compared to above SELECT c.table_name, cc.constraint_name, ds.id AS dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) FULL OUTER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) ORDER BY c.id; table_name | constraint_name | dimension_slice_id | range_start | range_end -------------------+-----------------+--------------------+----------------------+--------------------- _hyper_1_1_chunk | constraint_1 | 1 | 1 | 2 _hyper_1_1_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_2_chunk | constraint_3 | 3 | 2 | 3 _hyper_1_2_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_3_chunk | constraint_4 | 4 | 3 | 4 _hyper_1_3_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_4_chunk | constraint_5 | 5 | 4 | 5 _hyper_1_4_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_1_5_chunk | constraint_7 | 7 | 5 | 6 _hyper_1_5_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_1_6_chunk | constraint_8 | 8 | 6 | 7 _hyper_1_6_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_2_8_chunk | constraint_11 | 11 | 2 | 3 _hyper_2_8_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_9_chunk | constraint_12 | 12 | 3 | 4 _hyper_2_9_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_10_chunk | constraint_13 | 13 | 4 | 5 _hyper_2_10_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_2_11_chunk | constraint_15 | 15 | 5 | 6 _hyper_2_11_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_2_12_chunk | constraint_16 | 16 | 6 | 7 _hyper_2_12_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_3_13_chunk | constraint_17 | 17 | 1 | 2 _hyper_3_13_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_14_chunk | constraint_19 | 19 | 2 | 3 _hyper_3_14_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_15_chunk | constraint_20 | 20 | 3 | 4 _hyper_3_15_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_16_chunk | constraint_21 | 21 | 4 | 5 _hyper_3_16_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 _hyper_3_17_chunk | constraint_23 | 23 | 5 | 6 _hyper_3_17_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 _hyper_3_18_chunk | constraint_24 | 24 | 6 | 7 _hyper_3_18_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 -- Only one dimension slice deleted SELECT * FROM _timescaledb_catalog.dimension_slice ORDER BY id; id | dimension_id | range_start | range_end ----+--------------+----------------------+--------------------- 1 | 1 | 1 | 2 2 | 4 | 1073741823 | 9223372036854775807 3 | 1 | 2 | 3 4 | 1 | 3 | 4 5 | 1 | 4 | 5 6 | 4 | -9223372036854775808 | 1073741823 7 | 1 | 5 | 6 8 | 1 | 6 | 7 10 | 5 | 1073741823 | 9223372036854775807 11 | 2 | 2 | 3 12 | 2 | 3 | 4 13 | 2 | 4 | 5 14 | 5 | -9223372036854775808 | 1073741823 15 | 2 | 5 | 6 16 | 2 | 6 | 7 17 | 3 | 1 | 2 18 | 6 | 1073741823 | 9223372036854775807 19 | 3 | 2 | 3 20 | 3 | 3 | 4 21 | 3 | 4 | 5 22 | 6 | -9223372036854775808 | 1073741823 23 | 3 | 5 | 6 24 | 3 | 6 | 7 -- We drop all chunks older than timestamp 2 in all hypertable. This -- is added only to avoid making the diff for this commit larger than -- necessary and make reviews easier. SELECT drop_chunks(format('%1$I.%2$I', schema_name, table_name)::regclass, older_than => 2) FROM _timescaledb_catalog.hypertable; drop_chunks ----------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_3_13_chunk SELECT c.table_name, cc.constraint_name, ds.id AS dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) FULL OUTER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) ORDER BY c.id; table_name | constraint_name | dimension_slice_id | range_start | range_end -------------------+-----------------+--------------------+----------------------+--------------------- _hyper_1_2_chunk | constraint_3 | 3 | 2 | 3 _hyper_1_2_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_3_chunk | constraint_4 | 4 | 3 | 4 _hyper_1_3_chunk | constraint_2 | 2 | 1073741823 | 9223372036854775807 _hyper_1_4_chunk | constraint_5 | 5 | 4 | 5 _hyper_1_4_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_1_5_chunk | constraint_7 | 7 | 5 | 6 _hyper_1_5_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_1_6_chunk | constraint_8 | 8 | 6 | 7 _hyper_1_6_chunk | constraint_6 | 6 | -9223372036854775808 | 1073741823 _hyper_2_8_chunk | constraint_11 | 11 | 2 | 3 _hyper_2_8_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_9_chunk | constraint_12 | 12 | 3 | 4 _hyper_2_9_chunk | constraint_10 | 10 | 1073741823 | 9223372036854775807 _hyper_2_10_chunk | constraint_13 | 13 | 4 | 5 _hyper_2_10_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_2_11_chunk | constraint_15 | 15 | 5 | 6 _hyper_2_11_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_2_12_chunk | constraint_16 | 16 | 6 | 7 _hyper_2_12_chunk | constraint_14 | 14 | -9223372036854775808 | 1073741823 _hyper_3_14_chunk | constraint_19 | 19 | 2 | 3 _hyper_3_14_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_15_chunk | constraint_20 | 20 | 3 | 4 _hyper_3_15_chunk | constraint_18 | 18 | 1073741823 | 9223372036854775807 _hyper_3_16_chunk | constraint_21 | 21 | 4 | 5 _hyper_3_16_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 _hyper_3_17_chunk | constraint_23 | 23 | 5 | 6 _hyper_3_17_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 _hyper_3_18_chunk | constraint_24 | 24 | 6 | 7 _hyper_3_18_chunk | constraint_22 | 22 | -9223372036854775808 | 1073741823 SELECT * FROM _timescaledb_catalog.dimension_slice ORDER BY id; id | dimension_id | range_start | range_end ----+--------------+----------------------+--------------------- 2 | 4 | 1073741823 | 9223372036854775807 3 | 1 | 2 | 3 4 | 1 | 3 | 4 5 | 1 | 4 | 5 6 | 4 | -9223372036854775808 | 1073741823 7 | 1 | 5 | 6 8 | 1 | 6 | 7 10 | 5 | 1073741823 | 9223372036854775807 11 | 2 | 2 | 3 12 | 2 | 3 | 4 13 | 2 | 4 | 5 14 | 5 | -9223372036854775808 | 1073741823 15 | 2 | 5 | 6 16 | 2 | 6 | 7 18 | 6 | 1073741823 | 9223372036854775807 19 | 3 | 2 | 3 20 | 3 | 3 | 4 21 | 3 | 4 | 5 22 | 6 | -9223372036854775808 | 1073741823 23 | 3 | 5 | 6 24 | 3 | 6 | 7 SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+-------------------+-------------+----------- 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | 2 | 3 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | 3 | 4 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | 5 | 6 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | 6 | 7 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | 2 | 3 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | 3 | 4 10 | 2 | _timescaledb_internal | _hyper_2_10_chunk | 4 | 5 11 | 2 | _timescaledb_internal | _hyper_2_11_chunk | 5 | 6 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | 6 | 7 -- next two calls of show_chunks should give same set of chunks as above when combined SELECT show_chunks('drop_chunk_test1'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk SELECT * FROM show_chunks('drop_chunk_test2'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk _timescaledb_internal._hyper_2_12_chunk SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_1_2_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_3_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_4_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_5_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_6_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_10_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_14_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_15_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_16_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_17_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_18_chunk | table | default_perm_user -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test1\', older_than => 3)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test1\', older_than => 3)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+-------------------+-------------+----------- 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | 3 | 4 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | 5 | 6 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | 6 | 7 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | 2 | 3 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | 3 | 4 10 | 2 | _timescaledb_internal | _hyper_2_10_chunk | 4 | 5 11 | 2 | _timescaledb_internal | _hyper_2_11_chunk | 5 | 6 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | 6 | 7 SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_1_3_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_4_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_5_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_6_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_10_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_14_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_15_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_16_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_17_chunk | table | default_perm_user _timescaledb_internal | _hyper_3_18_chunk | table | default_perm_user -- next two calls of show_chunks should give same set of chunks as above when combined SELECT show_chunks('drop_chunk_test1'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk SELECT * FROM show_chunks('drop_chunk_test2'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk _timescaledb_internal._hyper_2_12_chunk -- 2,147,483,647 is the largest int so this tests that BIGINTs work -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test3\', older_than => 2147483648)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test3\', older_than => 2147483648)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 5 | 5 SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2' OR h.table_name = 'drop_chunk_test3') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+-------------------+-------------+----------- 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | 3 | 4 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | 5 | 6 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | 6 | 7 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | 2 | 3 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | 3 | 4 10 | 2 | _timescaledb_internal | _hyper_2_10_chunk | 4 | 5 11 | 2 | _timescaledb_internal | _hyper_2_11_chunk | 5 | 6 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | 6 | 7 SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_1_3_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_4_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_5_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_6_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_10_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user \set ON_ERROR_STOP 0 -- should error because no hypertable SELECT drop_chunks('drop_chunk_test4', older_than => 5); ERROR: relation "drop_chunk_test4" does not exist at character 20 SELECT show_chunks('drop_chunk_test4'); ERROR: relation "drop_chunk_test4" does not exist at character 20 SELECT show_chunks('drop_chunk_test4', 5); ERROR: relation "drop_chunk_test4" does not exist at character 20 \set ON_ERROR_STOP 1 DROP TABLE _timescaledb_internal._hyper_1_6_chunk; SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+-------------------+-------------+----------- 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | 3 | 4 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | 5 | 6 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | 2 | 3 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | 3 | 4 10 | 2 | _timescaledb_internal | _hyper_2_10_chunk | 4 | 5 11 | 2 | _timescaledb_internal | _hyper_2_11_chunk | 5 | 6 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | 6 | 7 SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_1_3_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_4_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_5_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_10_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user -- newer_than tests -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test1\', newer_than=>5)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test1\', newer_than=>5, verbose => true)::NAME' \set ECHO errors psql:include/query_result_test_equal.sql:16: INFO: dropping chunk _timescaledb_internal._hyper_1_5_chunk Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+------------------+-------------+----------- 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | 3 | 4 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 SELECT show_chunks('drop_chunk_test1'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_1_3_chunk | table | default_perm_user _timescaledb_internal | _hyper_1_4_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_10_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test1\', older_than=>4, newer_than=>3)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test1\', older_than=>4, newer_than=>3)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1') ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+------------------+-------------+----------- 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 -- the call of show_chunks should give same set of chunks as above SELECT show_chunks('drop_chunk_test1'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_4_chunk SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' ORDER BY c.id; chunk_id | hypertable_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+-----------------------+-------------------+-------------+----------- 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | 4 | 5 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | 2 | 3 9 | 2 | _timescaledb_internal | _hyper_2_9_chunk | 3 | 4 10 | 2 | _timescaledb_internal | _hyper_2_10_chunk | 4 | 5 11 | 2 | _timescaledb_internal | _hyper_2_11_chunk | 5 | 6 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | 6 | 7 -- We support show/drop chunks using timestamps/interval even with integer partitioning -- the chunk creation time gets used for these. But we need to use "created_before, created_after" -- for these \set ON_ERROR_STOP 0 SELECT show_chunks('drop_chunk_test3', older_than => now()); ERROR: invalid time argument type "timestamp with time zone" SELECT show_chunks('drop_chunk_test2', older_than => now()); ERROR: invalid time argument type "timestamp with time zone" SELECT show_chunks('drop_chunk_test1', newer_than => INTERVAL '15 minutes'); ERROR: invalid time argument type "interval" SELECT show_chunks('drop_chunk_test1', older_than => now(), newer_than => INTERVAL '15 minutes'); ERROR: invalid time argument type "timestamp with time zone" SELECT drop_chunks('drop_chunk_test1', older_than => now()); ERROR: invalid time argument type "timestamp with time zone" -- mix of older_than/newer_than and created_after/created_before doesn't work SELECT show_chunks('drop_chunk_test1', older_than => now(), created_after => INTERVAL '15 minutes'); ERROR: invalid time argument type "timestamp with time zone" SELECT show_chunks('drop_chunk_test1', created_before => now(), newer_than => INTERVAL '15 minutes'); ERROR: invalid time argument type "interval" \set ON_ERROR_STOP 1 SELECT show_chunks('drop_chunk_test3', created_before => now() + INTERVAL '1 hour'); show_chunks ------------- SELECT show_chunks('drop_chunk_test2', created_before => now() + INTERVAL '1 hour'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk _timescaledb_internal._hyper_2_12_chunk SELECT show_chunks('drop_chunk_test1', created_after => INTERVAL '15 minutes'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_4_chunk SELECT show_chunks('drop_chunk_test1', created_before => now() + INTERVAL '1 hour', created_after => INTERVAL '1 hour'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_4_chunk SELECT drop_chunks('drop_chunk_test1', created_before => now() + INTERVAL '1 hour'); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_4_chunk SELECT drop_chunks(format('%1$I.%2$I', schema_name, table_name)::regclass, older_than => 5, newer_than => 4) FROM _timescaledb_catalog.hypertable WHERE schema_name = 'public'; drop_chunks ----------------------------------------- _timescaledb_internal._hyper_2_10_chunk CREATE TABLE PUBLIC.drop_chunk_test_ts(time timestamp, temp float8, device_id text); SELECT create_hypertable('public.drop_chunk_test_ts', 'time', chunk_time_interval => interval '1 minute', create_default_indexes=>false); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------- (4,public,drop_chunk_test_ts,t) CREATE TABLE PUBLIC.drop_chunk_test_tstz(time timestamptz, temp float8, device_id text); SELECT create_hypertable('public.drop_chunk_test_tstz', 'time', chunk_time_interval => interval '1 minute', create_default_indexes=>false); create_hypertable ----------------------------------- (5,public,drop_chunk_test_tstz,t) SET timezone = '+1'; INSERT INTO PUBLIC.drop_chunk_test_ts VALUES(now()-INTERVAL '5 minutes', 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test_ts VALUES(now()+INTERVAL '5 minutes', 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test_tstz VALUES(now()-INTERVAL '5 minutes', 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test_tstz VALUES(now()+INTERVAL '5 minutes', 1.0, 'dev1'); SELECT * FROM test.show_subtables('drop_chunk_test_ts'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_4_19_chunk | _timescaledb_internal._hyper_4_20_chunk | SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_5_21_chunk | _timescaledb_internal._hyper_5_22_chunk | BEGIN; SELECT show_chunks('drop_chunk_test_ts'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_4_19_chunk _timescaledb_internal._hyper_4_20_chunk SELECT show_chunks('drop_chunk_test_ts', now()::timestamp-interval '1 minute'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_4_19_chunk -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', newer_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', newer_than => interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => interval \'6 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', older_than => interval \'6 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 0 | 0 SELECT * FROM test.show_subtables('drop_chunk_test_ts'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_4_19_chunk | \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_ts'); Child | Tablespace -------+------------ SELECT show_chunks('drop_chunk_test_tstz'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_21_chunk _timescaledb_internal._hyper_5_22_chunk SELECT show_chunks('drop_chunk_test_tstz', older_than => now() - interval '1 minute', newer_than => now() - interval '6 minute'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_21_chunk SELECT show_chunks('drop_chunk_test_tstz', newer_than => now() - interval '1 minute'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_22_chunk SELECT show_chunks('drop_chunk_test_tstz', older_than => now() - interval '1 minute'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_21_chunk \set QUERY1 'SELECT show_chunks(older_than => interval \'1 minute\', relation => \'drop_chunk_test_tstz\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_tstz\', interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_5_22_chunk | ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', newer_than => interval \'6 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', newer_than => interval \'6 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 2 | 2 SELECT * FROM test.show_subtables('drop_chunk_test_ts'); Child | Tablespace -------+------------ ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', older_than => interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_ts'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_4_20_chunk | \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_tstz\', older_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_tstz\', older_than => interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_5_22_chunk | ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => now()::timestamp-interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', older_than => now()::timestamp-interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_ts'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_4_20_chunk | \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_tstz\', older_than => now()-interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_tstz\', older_than => now()-interval \'1 minute\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_5_22_chunk | ROLLBACK; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user _timescaledb_internal | _hyper_4_19_chunk | table | default_perm_user _timescaledb_internal | _hyper_4_20_chunk | table | default_perm_user _timescaledb_internal | _hyper_5_21_chunk | table | default_perm_user _timescaledb_internal | _hyper_5_22_chunk | table | default_perm_user \set ON_ERROR_STOP 0 SELECT drop_chunks(interval '1 minute'); ERROR: function drop_chunks(interval) does not exist at character 8 SELECT drop_chunks('drop_chunk_test_ts', (now()-interval '1 minute')); ERROR: invalid time argument type "timestamp with time zone" SELECT drop_chunks('drop_chunk_test3', verbose => true); ERROR: invalid time range for dropping chunks SELECT drop_chunks('drop_chunk_test3', interval '1 minute'); ERROR: invalid time argument type "interval" \set ON_ERROR_STOP 1 -- Interval boundary for INTEGER type columns. It uses chunk creation -- time to identify the affected chunks. SELECT drop_chunks('drop_chunk_test3', created_after => interval '1 minute'); drop_chunks ------------- SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+-------------------+-------+------------------- _timescaledb_internal | _hyper_2_11_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_12_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_8_chunk | table | default_perm_user _timescaledb_internal | _hyper_2_9_chunk | table | default_perm_user _timescaledb_internal | _hyper_4_19_chunk | table | default_perm_user _timescaledb_internal | _hyper_4_20_chunk | table | default_perm_user _timescaledb_internal | _hyper_5_21_chunk | table | default_perm_user _timescaledb_internal | _hyper_5_22_chunk | table | default_perm_user CREATE TABLE PUBLIC.drop_chunk_test_date(time date, temp float8, device_id text); SELECT create_hypertable('public.drop_chunk_test_date', 'time', chunk_time_interval => interval '1 day', create_default_indexes=>false); create_hypertable ----------------------------------- (6,public,drop_chunk_test_date,t) SET timezone = '+100'; INSERT INTO PUBLIC.drop_chunk_test_date VALUES(now()-INTERVAL '2 day', 1.0, 'dev1'); BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_date\', older_than => interval \'1 day\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_date\', older_than => interval \'1 day\')::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_date'); Child | Tablespace -------+------------ ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_date\', older_than => (now()-interval \'1 day\')::date)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_date\', older_than => (now()-interval \'1 day\')::date)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('drop_chunk_test_date'); Child | Tablespace -------+------------ ROLLBACK; SET timezone TO '-5'; CREATE TABLE chunk_id_from_relid_test(time bigint, temp float8, device_id int); SELECT hypertable_id FROM create_hypertable('chunk_id_from_relid_test', 'time', chunk_time_interval => 10) \gset INSERT INTO chunk_id_from_relid_test VALUES (0, 1.1, 0), (0, 1.3, 11), (12, 2.0, 0), (12, 0.1, 11); SELECT _timescaledb_functions.chunk_id_from_relid(tableoid) FROM chunk_id_from_relid_test; chunk_id_from_relid --------------------- 24 24 25 25 DROP TABLE chunk_id_from_relid_test; CREATE TABLE chunk_id_from_relid_test(time bigint, temp float8, device_id int); SELECT hypertable_id FROM create_hypertable('chunk_id_from_relid_test', 'time', chunk_time_interval => 10, partitioning_column => 'device_id', number_partitions => 3) \gset INSERT INTO chunk_id_from_relid_test VALUES (0, 1.1, 2), (0, 1.3, 11), (12, 2.0, 2), (12, 0.1, 11); SELECT _timescaledb_functions.chunk_id_from_relid(tableoid) FROM chunk_id_from_relid_test; chunk_id_from_relid --------------------- 26 27 28 29 \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.chunk_id_from_relid('pg_type'::regclass); ERROR: chunk not found SELECT _timescaledb_functions.chunk_id_from_relid('chunk_id_from_relid_test'::regclass); ERROR: chunk not found -- test drop/show_chunks on custom partition types CREATE FUNCTION extract_time(a jsonb) RETURNS TIMESTAMPTZ LANGUAGE SQL AS $$ SELECT (a->>'time')::TIMESTAMPTZ $$ IMMUTABLE; CREATE TABLE test_weird_type(a jsonb); SELECT create_hypertable('test_weird_type', 'a', time_partitioning_func=>'extract_time'::regproc, chunk_time_interval=>'2 hours'::interval); create_hypertable ------------------------------ (9,public,test_weird_type,t) INSERT INTO test_weird_type VALUES ('{"time":"2019/06/06 1:00+0"}'), ('{"time":"2019/06/06 5:00+0"}'); SELECT * FROM test.show_subtables('test_weird_type'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_9_30_chunk | _timescaledb_internal._hyper_9_31_chunk | SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 4:00+0'::TIMESTAMPTZ); show_chunks ----------------------------------------- _timescaledb_internal._hyper_9_30_chunk SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 10:00+0'::TIMESTAMPTZ); show_chunks ----------------------------------------- _timescaledb_internal._hyper_9_30_chunk _timescaledb_internal._hyper_9_31_chunk -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type\', older_than => \'2019/06/06 5:00+0\'::TIMESTAMPTZ)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type\', older_than => \'2019/06/06 5:00+0\'::TIMESTAMPTZ)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('test_weird_type'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_9_31_chunk | SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 4:00+0'::TIMESTAMPTZ); show_chunks ------------- SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 10:00+0'::TIMESTAMPTZ); show_chunks ----------------------------------------- _timescaledb_internal._hyper_9_31_chunk -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type\', older_than => \'2019/06/06 6:00+0\'::TIMESTAMPTZ)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type\', older_than => \'2019/06/06 6:00+0\'::TIMESTAMPTZ)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('test_weird_type'); Child | Tablespace -------+------------ SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 10:00+0'::TIMESTAMPTZ); show_chunks ------------- DROP TABLE test_weird_type; CREATE FUNCTION extract_int_time(a jsonb) RETURNS BIGINT LANGUAGE SQL AS $$ SELECT (a->>'time')::BIGINT $$ IMMUTABLE; CREATE TABLE test_weird_type_i(a jsonb); SELECT create_hypertable('test_weird_type_i', 'a', time_partitioning_func=>'extract_int_time'::regproc, chunk_time_interval=>5); create_hypertable --------------------------------- (10,public,test_weird_type_i,t) INSERT INTO test_weird_type_i VALUES ('{"time":"0"}'), ('{"time":"5"}'); SELECT * FROM test.show_subtables('test_weird_type_i'); Child | Tablespace ------------------------------------------+------------ _timescaledb_internal._hyper_10_32_chunk | _timescaledb_internal._hyper_10_33_chunk | SELECT show_chunks('test_weird_type_i', older_than=>5); show_chunks ------------------------------------------ _timescaledb_internal._hyper_10_32_chunk SELECT show_chunks('test_weird_type_i', older_than=>10); show_chunks ------------------------------------------ _timescaledb_internal._hyper_10_32_chunk _timescaledb_internal._hyper_10_33_chunk -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type_i\', older_than=>5)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type_i\', older_than => 5)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('test_weird_type_i'); Child | Tablespace ------------------------------------------+------------ _timescaledb_internal._hyper_10_33_chunk | SELECT show_chunks('test_weird_type_i', older_than=>5); show_chunks ------------- SELECT show_chunks('test_weird_type_i', older_than=>10); show_chunks ------------------------------------------ _timescaledb_internal._hyper_10_33_chunk -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type_i\', older_than=>10)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type_i\', older_than => 10)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 SELECT * FROM test.show_subtables('test_weird_type_i'); Child | Tablespace -------+------------ SELECT show_chunks('test_weird_type_i', older_than=>10); show_chunks ------------- DROP TABLE test_weird_type_i CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER ALTER TABLE drop_chunk_test2 OWNER TO :ROLE_DEFAULT_PERM_USER_2; --drop chunks 3 will have a chunk we a dependent object (a view) --we create the dependent object now INSERT INTO PUBLIC.drop_chunk_test3 VALUES(1, 1.0, 'dev1'); SELECT c.schema_name as chunk_schema, c.table_name as chunk_table FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'drop_chunk_test3' ORDER BY c.id \gset create view dependent_view as SELECT * FROM :"chunk_schema".:"chunk_table"; create view dependent_view2 as SELECT * FROM :"chunk_schema".:"chunk_table"; ALTER TABLE drop_chunk_test3 OWNER TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 SELECT drop_chunks('drop_chunk_test1', older_than=>4, newer_than=>3); ERROR: must be owner of hypertable "drop_chunk_test1" --works with modified owner tables -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test2\', older_than=>4, newer_than=>3)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test2\', older_than=>4, newer_than=>3)::NAME' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 1 | 1 \set VERBOSITY default --this fails because there are dependent objects SELECT drop_chunks('drop_chunk_test3', older_than=>100); ERROR: cannot drop table _timescaledb_internal._hyper_3_34_chunk because other objects depend on it DETAIL: view dependent_view depends on table _timescaledb_internal._hyper_3_34_chunk view dependent_view2 depends on table _timescaledb_internal._hyper_3_34_chunk HINT: Use DROP ... to drop the dependent objects. \set VERBOSITY terse \c :TEST_DBNAME :ROLE_SUPERUSER DROP VIEW dependent_view; DROP VIEW dependent_view2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 1 --drop chunks from hypertable with same name in different schema -- order of schema in search_path matters -- \c :TEST_DBNAME :ROLE_SUPERUSER drop table chunk_id_from_relid_test; drop table drop_chunk_test1; drop table drop_chunk_test2; drop table drop_chunk_test3; CREATE SCHEMA try_schema; CREATE SCHEMA test1; CREATE SCHEMA test2; CREATE SCHEMA test3; GRANT CREATE ON SCHEMA try_schema, test1, test2, test3 TO :ROLE_DEFAULT_PERM_USER; GRANT USAGE ON SCHEMA try_schema, test1, test2, test3 TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE try_schema.drop_chunk_test_date(time date, temp float8, device_id text); SELECT create_hypertable('try_schema.drop_chunk_test_date', 'time', chunk_time_interval => interval '1 day', create_default_indexes=>false); create_hypertable ---------------------------------------- (11,try_schema,drop_chunk_test_date,t) INSERT INTO public.drop_chunk_test_date VALUES( '2020-01-10', 100, 'hello'); INSERT INTO try_schema.drop_chunk_test_date VALUES( '2020-01-10', 100, 'hello'); set search_path to try_schema, test1, test2, test3, public; SELECT show_chunks('public.drop_chunk_test_date', older_than=>'1 day'::interval); show_chunks ----------------------------------------- _timescaledb_internal._hyper_6_35_chunk SELECT show_chunks('try_schema.drop_chunk_test_date', older_than=>'1 day'::interval); show_chunks ------------------------------------------ _timescaledb_internal._hyper_11_36_chunk SELECT drop_chunks('drop_chunk_test_date', older_than=> '1 day'::interval); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_36_chunk -- test drop chunks across two tables within the same schema CREATE TABLE test1.hyper1 (time bigint, temp float); CREATE TABLE test1.hyper2 (time bigint, temp float); SELECT create_hypertable('test1.hyper1', 'time', chunk_time_interval => 10); create_hypertable --------------------- (12,test1,hyper1,t) SELECT create_hypertable('test1.hyper2', 'time', chunk_time_interval => 10); create_hypertable --------------------- (13,test1,hyper2,t) INSERT INTO test1.hyper1 VALUES (10, 0.5); INSERT INTO test1.hyper2 VALUES (10, 0.7); SELECT show_chunks('test1.hyper1'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_12_37_chunk SELECT show_chunks('test1.hyper2'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_13_38_chunk -- test drop chunks for given table name across all schemas CREATE TABLE test2.hyperx (time bigint, temp float); CREATE TABLE test3.hyperx (time bigint, temp float); SELECT create_hypertable('test2.hyperx', 'time', chunk_time_interval => 10); create_hypertable --------------------- (14,test2,hyperx,t) SELECT create_hypertable('test3.hyperx', 'time', chunk_time_interval => 10); create_hypertable --------------------- (15,test3,hyperx,t) INSERT INTO test2.hyperx VALUES (10, 0.5); INSERT INTO test3.hyperx VALUES (10, 0.7); SELECT show_chunks('test2.hyperx'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_14_39_chunk SELECT show_chunks('test3.hyperx'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_15_40_chunk -- This will only drop from one of the tables since the one that is -- first in the search path will hide the other one. SELECT drop_chunks('hyperx', older_than => 100); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_14_39_chunk SELECT show_chunks('test2.hyperx'); show_chunks ------------- SELECT show_chunks('test3.hyperx'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_15_40_chunk -- Check CTAS behavior when internal ALTER TABLE gets fired CREATE TABLE PUBLIC.drop_chunk_test4(time bigint, temp float8, device_id text); CREATE TABLE drop_chunks_table_id AS SELECT hypertable_id FROM create_hypertable('public.drop_chunk_test4', 'time', chunk_time_interval => 1); -- TEST for internal api that drops a single chunk -- this drops the table and removes entry from the catalog. -- does not affect any materialized cagg data INSERT INTO test1.hyper1 VALUES (20, 0.5); SELECT chunk_schema as "CHSCHEMA", chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name ; CHSCHEMA | CHNAME -----------------------+-------------------- _timescaledb_internal | _hyper_12_37_chunk _timescaledb_internal | _hyper_12_41_chunk --drop one of the chunks SELECT chunk_schema || '.' || chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset SELECT _timescaledb_functions.drop_chunk(:'CHNAME'); drop_chunk ------------ t SELECT chunk_schema as "CHSCHEMA", chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name ; CHSCHEMA | CHNAME -----------------------+-------------------- _timescaledb_internal | _hyper_12_41_chunk -- "created_before/after" can be used with time partitioning in drop/show chunks SELECT show_chunks('drop_chunk_test_tstz', created_before => now() - INTERVAL '1 hour'); show_chunks ------------- SELECT drop_chunks('drop_chunk_test_tstz', created_before => now() + INTERVAL '1 hour'); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_5_21_chunk _timescaledb_internal._hyper_5_22_chunk SELECT show_chunks('drop_chunk_test_ts'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_4_19_chunk _timescaledb_internal._hyper_4_20_chunk -- "created_before/after" accept timestamptz even though partitioning col is just -- timestamp SELECT show_chunks('drop_chunk_test_ts', created_after => now() - INTERVAL '1 hour', created_before => now()); show_chunks ----------------------------------------- _timescaledb_internal._hyper_4_19_chunk _timescaledb_internal._hyper_4_20_chunk SELECT drop_chunks('drop_chunk_test_ts', created_after => INTERVAL '1 hour', created_before => now()); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_4_19_chunk _timescaledb_internal._hyper_4_20_chunk -- Test views on top of hypertables CREATE TABLE view_test (project_id INT, ts TIMESTAMPTZ NOT NULL); SELECT create_hypertable('view_test', by_range('ts', INTERVAL '1 day')); create_hypertable ------------------- (17,t) -- exactly one partition per project_id SELECT * FROM add_dimension('view_test', 'project_id', chunk_time_interval => 1); -- exactly one partition per project; works for *integer* types dimension_id | schema_name | table_name | column_name | created --------------+-------------+------------+-------------+--------- 22 | try_schema | view_test | project_id | t INSERT INTO view_test (project_id, ts) SELECT g % 25 + 1 AS project_id, i.ts + (g * interval '1 week') / i.total AS ts FROM (SELECT timestamptz '2024-01-01 00:00:00+0', 600) i(ts, total), generate_series(1, i.total) g; -- Create a view on top of this hypertable CREATE VIEW test_view_part_few AS SELECT project_id, ts FROM view_test WHERE project_id = ANY (ARRAY[5, 10, 15]); -- Complicated query on a view involving a range check and a sort SELECT * FROM test_view_part_few WHERE ts BETWEEN '2024-01-04 00:00:00+00'AND '2024-01-05 00:00:00' ORDER BY ts LIMIT 1000; project_id | ts ------------+------------------------------ 10 | Wed Jan 03 16:31:12 2024 PST 15 | Wed Jan 03 17:55:12 2024 PST 5 | Wed Jan 03 22:07:12 2024 PST 10 | Wed Jan 03 23:31:12 2024 PST 15 | Thu Jan 04 00:55:12 2024 PST 5 | Thu Jan 04 05:07:12 2024 PST 10 | Thu Jan 04 06:31:12 2024 PST 15 | Thu Jan 04 07:55:12 2024 PST 5 | Thu Jan 04 12:07:12 2024 PST 10 | Thu Jan 04 13:31:12 2024 PST 15 | Thu Jan 04 14:55:12 2024 PST 5 | Thu Jan 04 19:07:12 2024 PST 10 | Thu Jan 04 20:31:12 2024 PST 15 | Thu Jan 04 21:55:12 2024 PST -- Test chunk_status_text function CREATE TABLE chunk_status_test(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=false); INSERT INTO chunk_status_test VALUES ('2025-01-01'),('2025-02-01'),('2025-03-01'); SELECT _timescaledb_functions.chunk_status_text(i) FROM generate_series(0,15) i; chunk_status_text --------------------------------------- {} {COMPRESSED} {UNORDERED} {COMPRESSED,UNORDERED} {FROZEN} {COMPRESSED,FROZEN} {UNORDERED,FROZEN} {COMPRESSED,UNORDERED,FROZEN} {PARTIAL} {COMPRESSED,PARTIAL} {UNORDERED,PARTIAL} {COMPRESSED,UNORDERED,PARTIAL} {FROZEN,PARTIAL} {COMPRESSED,FROZEN,PARTIAL} {UNORDERED,FROZEN,PARTIAL} {COMPRESSED,UNORDERED,FROZEN,PARTIAL} SELECT chunk, _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('chunk_status_test') chunk; chunk | chunk_status_text -------------------------------------------+------------------- _timescaledb_internal._hyper_18_218_chunk | {} _timescaledb_internal._hyper_18_219_chunk | {} _timescaledb_internal._hyper_18_220_chunk | {} SELECT _timescaledb_functions.chunk_status_text(NULL::int); chunk_status_text ------------------- SELECT _timescaledb_functions.chunk_status_text(NULL::regclass); chunk_status_text ------------------- \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.chunk_status_text(-1); ERROR: invalid chunk status -1 SELECT _timescaledb_functions.chunk_status_text(16); ERROR: invalid chunk status 16 SELECT _timescaledb_functions.chunk_status_text(1000); ERROR: invalid chunk status 1000 SELECT _timescaledb_functions.chunk_status_text(0::regclass); ERROR: invalid Oid SELECT _timescaledb_functions.chunk_status_text('pg_class'::regclass); ERROR: chunk not found \set ON_ERROR_STOP 1 -- Test that function exists and returns an array type SELECT pg_typeof(_timescaledb_functions.chunk_status_text(0)); pg_typeof ----------- text[] ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/chunks.out���������������������������������������������������������0000664�0000000�0000000�00000000302�15100345067�0020652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \unset ECHO ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/cluster.out��������������������������������������������������������0000664�0000000�0000000�00000015634�15100345067�0021056�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE cluster_test(time timestamptz, temp float, location int); SELECT create_hypertable('cluster_test', 'time', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (1,public,cluster_test,t) -- Show default indexes SELECT * FROM test.show_indexes('cluster_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -----------------------+---------+------+--------+---------+-----------+------------ cluster_test_time_idx | {time} | | f | f | f | -- Create two chunks INSERT INTO cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1), ('2017-01-21T09:00:01', 21.3, 2); -- Run cluster CLUSTER VERBOSE cluster_test USING cluster_test_time_idx; INFO: clustering "_timescaledb_internal._hyper_1_1_chunk" using index scan on "_hyper_1_1_chunk_cluster_test_time_idx" INFO: clustering "_timescaledb_internal._hyper_1_2_chunk" using index scan on "_hyper_1_2_chunk_cluster_test_time_idx" -- Create a third chunk INSERT INTO cluster_test VALUES ('2017-01-22T09:00:01', 19.5, 3); -- Show clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------+---------------- cluster_test_time_idx | t _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | t _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | t -- Reorder just our table CLUSTER VERBOSE cluster_test; INFO: clustering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_3_chunk" using index scan on "_hyper_1_3_chunk_cluster_test_time_idx" -- Show clustered indexes, including new chunk SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------+---------------- cluster_test_time_idx | t _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | t _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | t _timescaledb_internal._hyper_1_3_chunk_cluster_test_time_idx | t -- Reorder all tables (although will only be our test table) CLUSTER VERBOSE; INFO: clustering "public.cluster_test" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_3_chunk" using sequential scan and sort -- Change the clustered index CREATE INDEX ON cluster_test (time, location); CLUSTER VERBOSE cluster_test using cluster_test_time_location_idx; INFO: clustering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_3_chunk" using sequential scan and sort -- Show updated clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered -----------------------------------------------------------------------+---------------- cluster_test_time_location_idx | t _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_location_idx | t _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_location_idx | t _timescaledb_internal._hyper_1_3_chunk_cluster_test_time_location_idx | t --check the setting of cluster indexes on hypertables and chunks ALTER TABLE cluster_test CLUSTER ON cluster_test_time_idx; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; indexrelid | indisclustered --------------------------------------------------------------+---------------- cluster_test_time_idx | t _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | t _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | t _timescaledb_internal._hyper_1_3_chunk_cluster_test_time_idx | t CLUSTER VERBOSE cluster_test; INFO: clustering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort INFO: clustering "_timescaledb_internal._hyper_1_3_chunk" using sequential scan and sort ALTER TABLE cluster_test SET WITHOUT CLUSTER; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; indexrelid | indisclustered ------------+---------------- \set ON_ERROR_STOP 0 CLUSTER VERBOSE cluster_test; ERROR: there is no previously clustered index for table "cluster_test" \set ON_ERROR_STOP 1 ALTER TABLE _timescaledb_internal._hyper_1_1_chunk CLUSTER ON _hyper_1_1_chunk_cluster_test_time_idx; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; indexrelid | indisclustered --------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | t CLUSTER VERBOSE _timescaledb_internal._hyper_1_1_chunk; INFO: clustering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort ALTER TABLE _timescaledb_internal._hyper_1_1_chunk SET WITHOUT CLUSTER; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; indexrelid | indisclustered ------------+---------------- \set ON_ERROR_STOP 0 CLUSTER VERBOSE _timescaledb_internal._hyper_1_1_chunk; ERROR: there is no previously clustered index for table "_hyper_1_1_chunk" \set ON_ERROR_STOP 1 -- test alter column type on hypertable with clustering CREATE TABLE cluster_alter(time timestamp, id text, val int); CREATE INDEX idstuff ON cluster_alter USING btree (id ASC NULLS LAST, time); SELECT table_name FROM create_hypertable('cluster_alter', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name --------------- cluster_alter INSERT INTO cluster_alter VALUES('2020-01-01', '123', 1); CLUSTER cluster_alter using idstuff; --attempt the alter table ALTER TABLE cluster_alter ALTER COLUMN id TYPE int USING id::int; CLUSTER cluster_alter; CLUSTER cluster_alter using idstuff; ����������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/constraint.out�����������������������������������������������������0000664�0000000�0000000�00000137613�15100345067�0021563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE hyper ( time BIGINT NOT NULL, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t --check and not-null constraints are inherited through regular inheritance. \set ON_ERROR_STOP 0 INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 9); ERROR: new row for relation "_hyper_1_1_chunk" violates check constraint "hyper_sensor_1_check" INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, NULL, 11); ERROR: null value in column "device_id" of relation "_hyper_1_2_chunk" violates not-null constraint ALTER TABLE hyper ALTER COLUMN time DROP NOT NULL; ERROR: cannot drop not-null constraint from a time-partitioned column ALTER TABLE ONLY hyper ALTER COLUMN sensor_1 SET NOT NULL; ERROR: ONLY option not supported on hypertable operations ALTER TABLE ONLY hyper ALTER COLUMN device_id DROP NOT NULL; ERROR: ONLY option not supported on hypertable operations \set ON_ERROR_STOP 1 INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ALTER TABLE hyper ALTER COLUMN device_id DROP NOT NULL; INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, NULL, 11); --make sure validate works \set ON_ERROR_STOP 0 ALTER TABLE hyper ADD CONSTRAINT bad_check_const CHECK (sensor_1 > 100); ERROR: check constraint "bad_check_const" of relation "_hyper_1_3_chunk" is violated by some row \set ON_ERROR_STOP 1 ALTER TABLE hyper ADD CONSTRAINT bad_check_const CHECK (sensor_1 > 100) NOT VALID; \set ON_ERROR_STOP 0 ALTER TABLE hyper VALIDATE CONSTRAINT bad_check_const; ERROR: check constraint "bad_check_const" of relation "_hyper_1_3_chunk" is violated by some row \set ON_ERROR_STOP 1 ----------------------- UNIQUE CONSTRAINTS ------------------ CREATE TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ( time BIGINT NOT NULL UNIQUE, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------------------------------+--------- 2 | public | hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name | t INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987800000000000, 'dev2', 11); \set ON_ERROR_STOP 0 INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ERROR: duplicate key value violates unique constraint "4_1_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time" \set ON_ERROR_STOP 1 -- Show constraints on main tables SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------------------------------------------------------+----------------------------------------------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 4 | | 4_1_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key 5 | 5 | constraint_5 | 5 | | 5_2_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key SELECT * FROM test.show_constraints('hyper'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+------------+-------+-----------------------------+------------+----------+----------- bad_check_const | c | {sensor_1} | - | (sensor_1 > (100)::numeric) | f | f | f hyper_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-----------------------------------------------------------------+----------------------------+------------+----------+----------- hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key | u | {time} | hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key | | f | f | t --should have unique constraint not just unique index SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 4_1_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | u | {time} | _timescaledb_internal."4_1_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time" | | f | f | t constraint_4 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name DROP CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key; -- The constraint should have been removed from the chunk as well SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 5 | 5 | constraint_5 | SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-------+------------------------------------------------------------------------------------------+------------+----------+----------- constraint_4 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t --uniqueness not enforced INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev3', 11); --shouldn't be able to create constraint \set ON_ERROR_STOP 0 ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_time_key UNIQUE (time); ERROR: could not create unique index "4_3_hyper_unique_time_key" \set ON_ERROR_STOP 1 DELETE FROM hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name WHERE device_id = 'dev3'; -- Try multi-alter table statement with a constraint without a name ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CHECK (time > 0), ADD UNIQUE (time) DEFERRABLE INITIALLY DEFERRED; \set ON_ERROR_STOP 0 BEGIN; --testing deferred checking. The following row has an error, which will not appear until the commit INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev3', 11); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: duplicate key value violates unique constraint "4_4_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time" \set ON_ERROR_STOP 1 SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------------------------------------------------------+----------------------------------------------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 5 | 5 | constraint_5 | 4 | | 4_4_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key 5 | | 5_5_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-----------------------------------------------------------------+----------------------------+------------+----------+----------- hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooooooo_time_check | c | {time} | - | ("time" > 0) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key | u | {time} | hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key | | t | t | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 4_4_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | u | {time} | _timescaledb_internal."4_4_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time" | | t | t | t constraint_4 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooooooo_time_check | c | {time} | - | ("time" > 0) | f | f | t ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name DROP CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key, DROP CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooo_time_check; SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 5 | 5 | constraint_5 | SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-------+----------------------------+------------+----------+----------- hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-------+------------------------------------------------------------------------------------------+------------+----------+----------- constraint_4 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t CREATE UNIQUE INDEX hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx ON hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name (time); \set ON_ERROR_STOP 0 -- Try adding constraint using existing index ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key UNIQUE USING INDEX hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx; NOTICE: ALTER TABLE / ADD CONSTRAINT USING INDEX will rename index "hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx" to "hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key" ERROR: hypertables do not support adding a constraint using an existing index \set ON_ERROR_STOP 1 DROP INDEX hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx; --now can create ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key UNIQUE (time); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------------------------------------+------+------------+-----------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 4_6_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time | u | {time} | _timescaledb_internal."4_6_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time" | | f | f | t constraint_4 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t --test adding constraint with same name to different table -- should fail \set ON_ERROR_STOP 0 ALTER TABLE hyper ADD CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key UNIQUE (time); ERROR: relation "hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key" already exists \set ON_ERROR_STOP 1 --uniquness violation fails \set ON_ERROR_STOP 0 INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ERROR: duplicate key value violates unique constraint "4_6_hyper_unique_with_looooooooooooooooooooooooooooooooooo_time" \set ON_ERROR_STOP 1 --cannot create unique constraint on non-partition column \set ON_ERROR_STOP 0 ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_invalid UNIQUE (device_id); ERROR: cannot create a unique index without the column "time" (used in partitioning) ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD COLUMN new_device_id int UNIQUE; ERROR: cannot create a unique index without the column "time" (used in partitioning) ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name DROP COLUMN device_id, ADD COLUMN new_device_id int UNIQUE; ERROR: cannot create a unique index without the column "time" (used in partitioning) \set ON_ERROR_STOP 1 ----------------------- RENAME CONSTRAINT ------------------ ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key TO new_name; ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name * RENAME CONSTRAINT new_name TO new_name2; ALTER TABLE IF EXISTS hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check TO check_2; SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ------------+------+------------+-----------+----------------------------+------------+----------+----------- check_2 | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t new_name2 | u | {time} | new_name2 | | f | f | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------+------+------------+----------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 4_10_new_name2 | u | {time} | _timescaledb_internal."4_10_new_name2" | | f | f | t check_2 | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t constraint_4 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 5 | 5 | constraint_5 | 4 | | 4_10_new_name2 | new_name2 5 | | 5_11_new_name2 | new_name2 \set ON_ERROR_STOP 0 ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT new_name TO new_name2; ERROR: constraint "new_name" for table "hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name" does not exist ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT new_name2 TO check_2; ERROR: constraint "check_2" for relation "hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name" already exists ALTER TABLE ONLY hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT new_name2 TO new_name; ERROR: ONLY option not supported on hypertable operations ALTER TABLE _timescaledb_internal._hyper_2_4_chunk RENAME CONSTRAINT "4_10_new_name2" TO new_name; ERROR: renaming constraints on chunks is not supported \set ON_ERROR_STOP 1 ----------------------- PRIMARY KEY ------------------ CREATE TABLE hyper_pk ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_pk', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 3 | public | hyper_pk | t INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ERROR: duplicate key value violates unique constraint "6_14_hyper_pk_pkey" \set ON_ERROR_STOP 1 --should have unique constraint not just unique index SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_3_6_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -------------------------+------+------------+--------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 6_14_hyper_pk_pkey | p | {time} | _timescaledb_internal."6_14_hyper_pk_pkey" | | f | f | t constraint_6 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_pk_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t ALTER TABLE hyper_pk DROP CONSTRAINT hyper_pk_pkey; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_3_6_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -------------------------+------+------------+-------+------------------------------------------------------------------------------------------+------------+----------+----------- constraint_6 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_pk_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t --uniqueness not enforced INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev3', 11); --shouldn't be able to create pk \set ON_ERROR_STOP 0 ALTER TABLE hyper_pk ADD CONSTRAINT hyper_pk_pkey PRIMARY KEY (time); ERROR: could not create unique index "6_15_hyper_pk_pkey" ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD COLUMN new_device_id int PRIMARY KEY; ERROR: cannot create a unique index without the column "time" (used in partitioning) \set ON_ERROR_STOP 1 DELETE FROM hyper_pk WHERE device_id = 'dev3'; --cannot create pk constraint on non-partition column \set ON_ERROR_STOP 0 ALTER TABLE hyper_pk ADD CONSTRAINT hyper_pk_invalid PRIMARY KEY (device_id); ERROR: cannot create a unique index without the column "time" (used in partitioning) \set ON_ERROR_STOP 1 --now can create ALTER TABLE hyper_pk ADD CONSTRAINT hyper_pk_pkey PRIMARY KEY (time) DEFERRABLE INITIALLY DEFERRED; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_3_6_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -------------------------+------+------------+--------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 6_16_hyper_pk_pkey | p | {time} | _timescaledb_internal."6_16_hyper_pk_pkey" | | t | t | t constraint_6 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_pk_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t --test adding constraint with same name to different table -- should fail \set ON_ERROR_STOP 0 ALTER TABLE hyper ADD CONSTRAINT hyper_pk_pkey UNIQUE (time); ERROR: relation "hyper_pk_pkey" already exists \set ON_ERROR_STOP 1 --uniquness violation fails \set ON_ERROR_STOP 0 BEGIN; --error here deferred until commit INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: duplicate key value violates unique constraint "6_16_hyper_pk_pkey" \set ON_ERROR_STOP 1 ----------------------- FOREIGN KEY ------------------ CREATE TABLE devices( device_id TEXT NOT NULL, PRIMARY KEY (device_id) ); CREATE TABLE hyper_fk ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_fk', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 4 | public | hyper_fk | t --fail fk constraint \set ON_ERROR_STOP 0 INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ERROR: insert or update on table "_hyper_4_7_chunk" violates foreign key constraint "7_17_hyper_fk_device_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO devices VALUES ('dev2'); INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); --delete should fail \set ON_ERROR_STOP 0 DELETE FROM devices; ERROR: update or delete on table "devices" violates foreign key constraint "hyper_fk_device_id_fkey" on table "hyper_fk" \set ON_ERROR_STOP 1 ALTER TABLE hyper_fk DROP CONSTRAINT hyper_fk_device_id_fkey; --should now be able to add non-fk rows INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000001, 'dev3', 11); --can't add fk because of dev3 row \set ON_ERROR_STOP 0 ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id); ERROR: insert or update on table "hyper_fk" violates foreign key constraint "hyper_fk_device_id_fkey" \set ON_ERROR_STOP 1 --but can add a NOT VALID one ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id) NOT VALID; --which will fail when validated \set ON_ERROR_STOP 0 ALTER TABLE hyper_fk VALIDATE CONSTRAINT hyper_fk_device_id_fkey; ERROR: insert or update on table "hyper_fk" violates foreign key constraint "hyper_fk_device_id_fkey" \set ON_ERROR_STOP 1 ALTER TABLE hyper_fk DROP CONSTRAINT hyper_fk_device_id_fkey; DELETE FROM hyper_fk WHERE device_id = 'dev3'; ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id); \set ON_ERROR_STOP 0 INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000002, 'dev3', 11); ERROR: insert or update on table "_hyper_4_8_chunk" violates foreign key constraint "8_22_hyper_fk_device_id_fkey" \set ON_ERROR_STOP 1 SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_4_8_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ------------------------------+------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 8_20_hyper_fk_pkey | p | {time} | _timescaledb_internal."8_20_hyper_fk_pkey" | | f | f | t 8_22_hyper_fk_device_id_fkey | f | {device_id} | devices_pkey | | f | f | t constraint_8 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_fk_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+------------------------------+---------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 5 | 5 | constraint_5 | 4 | | 4_10_new_name2 | new_name2 5 | | 5_11_new_name2 | new_name2 6 | 6 | constraint_6 | 6 | | 6_16_hyper_pk_pkey | hyper_pk_pkey 8 | 8 | constraint_8 | 8 | | 8_20_hyper_fk_pkey | hyper_fk_pkey 8 | | 8_22_hyper_fk_device_id_fkey | hyper_fk_device_id_fkey --test CASCADE drop behavior DROP TABLE devices CASCADE; NOTICE: drop cascades to 2 other objects SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_4_8_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -------------------------+------+------------+--------------------------------------------+------------------------------------------------------------------------------------------+------------+----------+----------- 8_20_hyper_fk_pkey | p | {time} | _timescaledb_internal."8_20_hyper_fk_pkey" | | f | f | t constraint_8 | c | {time} | - | (("time" >= '1257987700000000000'::bigint) AND ("time" < '1257987700000000010'::bigint)) | f | f | t hyper_fk_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (10)::numeric) | f | f | t SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+--------------------+---------------------------- 3 | 3 | constraint_3 | 4 | 4 | constraint_4 | 5 | 5 | constraint_5 | 4 | | 4_10_new_name2 | new_name2 5 | | 5_11_new_name2 | new_name2 6 | 6 | constraint_6 | 6 | | 6_16_hyper_pk_pkey | hyper_pk_pkey 8 | 8 | constraint_8 | 8 | | 8_20_hyper_fk_pkey | hyper_fk_pkey --the fk went away. INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000002, 'dev3', 11); CREATE TABLE devices( device_id TEXT NOT NULL, PRIMARY KEY (device_id) ); INSERT INTO devices VALUES ('dev2'), ('dev3'); ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id) DEFERRABLE INITIALLY DEFERRED; \set ON_ERROR_STOP 0 BEGIN; --error deferred until commmit INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000003, 'dev4', 11); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: insert or update on table "_hyper_4_8_chunk" violates foreign key constraint "8_23_hyper_fk_device_id_fkey" \set ON_ERROR_STOP 1 ALTER TABLE hyper_fk ALTER CONSTRAINT hyper_fk_device_id_fkey NOT DEFERRABLE; \set ON_ERROR_STOP 0 BEGIN; --error detected right away INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000003, 'dev4', 11); ERROR: insert or update on table "_hyper_4_8_chunk" violates foreign key constraint "8_23_hyper_fk_device_id_fkey" SELECT 1; ERROR: current transaction is aborted, commands ignored until end of transaction block COMMIT; \set ON_ERROR_STOP 1 --this tests that there are no extra chunk_constraints left on hyper_fk TRUNCATE hyper_fk; ----------------------- FOREIGN KEY INTO A HYPERTABLE ------------------ --FOREIGN KEY references into a hypertable are currently broken. --The referencing table will never find the corresponding row in the hypertable --since it will only search the parent. Thus any insert will result in an ERROR --Block such foreign keys or fix. (Hard to block on create table so punting for now) CREATE TABLE hyper_for_ref ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_for_ref', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 5 | public | hyper_for_ref | t \set ON_ERROR_STOP 0 CREATE TABLE referrer ( time BIGINT NOT NULL REFERENCES hyper_for_ref(time) ); \set ON_ERROR_STOP 1 CREATE TABLE referrer2 ( time BIGINT NOT NULL ); \set ON_ERROR_STOP 0 ALTER TABLE referrer2 ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (time) REFERENCES hyper_for_ref(time); \set ON_ERROR_STOP 1 ----------------------- EXCLUSION CONSTRAINT ------------------ CREATE TABLE hyper_ex ( time BIGINT, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10), canceled boolean DEFAULT false, EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) ); SELECT * FROM create_hypertable('hyper_ex', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 6 | public | hyper_ex | t INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); ERROR: conflicting key value violates exclusion constraint "9_25_hyper_ex_time_device_id_excl" \set ON_ERROR_STOP 1 ALTER TABLE hyper_ex DROP CONSTRAINT hyper_ex_time_device_id_excl; --can now add INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); --cannot add because of conflicts \set ON_ERROR_STOP 0 ALTER TABLE hyper_ex ADD CONSTRAINT hyper_ex_time_device_id_excl EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) ; ERROR: could not create exclusion constraint "9_26_hyper_ex_time_device_id_excl" \set ON_ERROR_STOP 1 DELETE FROM hyper_ex WHERE sensor_1 = 12; ALTER TABLE hyper_ex ADD CONSTRAINT hyper_ex_time_device_id_excl EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) DEFERRABLE INITIALLY DEFERRED ; \set ON_ERROR_STOP 0 BEGIN; --error deferred til commit INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: conflicting key value violates exclusion constraint "9_27_hyper_ex_time_device_id_excl" \set ON_ERROR_STOP 1 --cannot add exclusion constraint without partition key. CREATE TABLE hyper_ex_invalid ( time BIGINT, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10), canceled boolean DEFAULT false, EXCLUDE USING btree ( device_id WITH = ) WHERE (not canceled) ); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('hyper_ex_invalid', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: cannot create a unique index without the column "time" (used in partitioning) \set ON_ERROR_STOP 1 --- NO INHERIT constraints (not allowed) ---- CREATE TABLE hyper_noinherit ( time BIGINT, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 0) NO INHERIT ); SELECT * FROM test.show_constraints('hyper_noinherit'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated --------------------------------+------+------------+-------+---------------------------+------------+----------+----------- hyper_noinherit_sensor_1_check | c | {sensor_1} | - | (sensor_1 > (0)::numeric) | f | f | t \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('hyper_noinherit', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: cannot have NO INHERIT constraints on hypertable "hyper_noinherit" \set ON_ERROR_STOP 1 CREATE TABLE hyper_noinherit_alter ( time BIGINT, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('hyper_noinherit_alter', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------+--------- 8 | public | hyper_noinherit_alter | t \set ON_ERROR_STOP 0 ALTER TABLE hyper_noinherit_alter ADD CONSTRAINT check_noinherit CHECK (sensor_1 > 0) NO INHERIT; ERROR: cannot have NO INHERIT constraints on hypertable "hyper_noinherit_alter" -- CREATE TABLE WITH DEFERRED CONSTRAINTS -- CREATE TABLE hyper_unique_deferred ( time BIGINT UNIQUE DEFERRABLE INITIALLY DEFERRED, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique_deferred', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------+--------- 9 | public | hyper_unique_deferred | t INSERT INTO hyper_unique_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 BEGIN; --error here deferred until commit INSERT INTO hyper_unique_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: duplicate key value violates unique constraint "10_28_hyper_unique_deferred_time_key" \set ON_ERROR_STOP 1 --test deferred on create table CREATE TABLE hyper_pk_deferred ( time BIGINT NOT NULL PRIMARY KEY DEFERRABLE INITIALLY DEFERRED, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_pk_deferred', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------+--------- 10 | public | hyper_pk_deferred | t INSERT INTO hyper_pk_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 BEGIN; --error here deferred until commit INSERT INTO hyper_pk_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: duplicate key value violates unique constraint "11_29_hyper_pk_deferred_pkey" \set ON_ERROR_STOP 1 --test that deferred works on create table too CREATE TABLE hyper_fk_deferred ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL REFERENCES devices(device_id) DEFERRABLE INITIALLY DEFERRED, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_fk_deferred', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------+--------- 11 | public | hyper_fk_deferred | t \set ON_ERROR_STOP 0 BEGIN; --error deferred until commmit INSERT INTO hyper_fk_deferred(time, device_id,sensor_1) VALUES (1257987700000000003, 'dev4', 11); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: insert or update on table "_hyper_11_12_chunk" violates foreign key constraint "12_30_hyper_fk_deferred_device_id_fkey" \set ON_ERROR_STOP 1 CREATE TABLE hyper_ex_deferred ( time BIGINT, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10), canceled boolean DEFAULT false, EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) DEFERRABLE INITIALLY DEFERRED ); SELECT * FROM create_hypertable('hyper_ex_deferred', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------+--------- 12 | public | hyper_ex_deferred | t INSERT INTO hyper_ex_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); \set ON_ERROR_STOP 0 BEGIN; --error deferred til commit INSERT INTO hyper_ex_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); SELECT 1; ?column? ---------- 1 COMMIT; ERROR: conflicting key value violates exclusion constraint "13_33_hyper_ex_deferred_time_device_id_excl" \set ON_ERROR_STOP 1 -- Make sure renaming schemas won't break dropping constraints \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE hyper_unique ( time BIGINT NOT NULL UNIQUE, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique', 'time', chunk_time_interval => 10, associated_schema_name => 'my_associated_schema'); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 13 | public | hyper_unique | t INSERT INTO hyper_unique(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ALTER SCHEMA my_associated_schema RENAME TO new_associated_schema; ALTER TABLE hyper_unique DROP CONSTRAINT hyper_unique_time_key; -- test for constraint validation crash, see #1183 CREATE TABLE test_validate(time timestamp NOT NULL, a TEXT, b TEXT); SELECT * FROM create_hypertable('test_validate', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 14 | public | test_validate | t INSERT INTO test_validate values(now(), 'a', 'b'); ALTER TABLE test_validate ADD COLUMN c TEXT, ADD CONSTRAINT c_not_null CHECK (c IS NOT NULL) NOT VALID; UPDATE test_validate SET c = ''; ALTER TABLE test_validate VALIDATE CONSTRAINT c_not_null; DROP TABLE test_validate; -- test for hypertables constraints both using index tablespaces and not See #2604 SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; SET client_min_messages = NOTICE; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLE fk_tbl ( id int, CONSTRAINT pkfk PRIMARY KEY (id) USING INDEX TABLESPACE tablespace1); CREATE TABLE tbl ( fk_id int, id int, time timestamp, CONSTRAINT pk PRIMARY KEY (time, id) USING INDEX TABLESPACE tablespace1 DEFERRABLE INITIALLY DEFERRED); SELECT create_hypertable('tbl', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------- (15,public,tbl,t) ALTER TABLE tbl ADD CONSTRAINT fk_con FOREIGN KEY (fk_id) REFERENCES fk_tbl(id) ON UPDATE SET NULL ON DELETE SET NULL; INSERT INTO fk_tbl VALUES(1); INSERT INTO tbl VALUES ( 1, 1, now() ); DROP TABLE tbl; DROP TABLE fk_tbl; DROP TABLESPACE IF EXISTS tablespace1; ���������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/copy.out�����������������������������������������������������������0000664�0000000�0000000�00000063300�15100345067�0020340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o --old chunks COPY "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; \copy "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; --new chunks COPY "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; \copy "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; COPY (SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1) TO STDOUT; 1257894000000000000 dev1 1.5 1 2 t 1257894000000000000 dev1 1.5 2 \N \N 1257894000000000000 dev2 1.5 1 \N \N 1257894000000000000 dev2 1.5 2 \N \N 1257894000000000000 dev3 1.5 2 \N \N 1257894000000000000 dev3 1.5 2 \N \N 1257894000000001000 dev1 2.5 3 \N \N 1257894001000000000 dev1 3.5 4 \N \N 1257894002000000000 dev1 2.5 3 \N \N 1257894002000000000 dev1 5.5 6 \N t 1257894002000000000 dev1 5.5 7 \N f 1257897600000000000 dev1 4.5 5 \N f 1257987600000000000 dev1 1.5 1 \N \N 1257987600000000000 dev1 1.5 2 \N \N 2257894000000000000 dev3 1.5 2 \N \N 2257894000000000000 dev3 1.5 2 \N \N ---test hypertable with FK CREATE TABLE "meta" ("id" serial PRIMARY KEY); CREATE TABLE "hyper" ( "meta_id" integer NOT NULL REFERENCES meta(id), "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper', 'time', chunk_time_interval => 100); create_hypertable -------------------- (2,public,hyper,t) INSERT INTO "meta" ("id") values (1); \copy hyper (time, meta_id, value) FROM STDIN DELIMITER ','; COPY hyper (time, meta_id, value) FROM STDIN DELIMITER ','; \set ON_ERROR_STOP 0 \copy hyper (time, meta_id, value) FROM STDIN DELIMITER ','; ERROR: insert or update on table "_hyper_2_6_chunk" violates foreign key constraint "6_1_hyper_meta_id_fkey" COPY hyper (time, meta_id, value) FROM STDIN DELIMITER ','; ERROR: insert or update on table "_hyper_2_6_chunk" violates foreign key constraint "6_1_hyper_meta_id_fkey" \set ON_ERROR_STOP 1 COPY (SELECT * FROM hyper ORDER BY time, meta_id) TO STDOUT; 1 1 1 1 2 1 --test that copy works with a low setting for max_open_chunks_per_insert set timescaledb.max_open_chunks_per_insert = 1; CREATE TABLE "hyper2" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper2', 'time', chunk_time_interval => 10); create_hypertable --------------------- (3,public,hyper2,t) \copy hyper2 from data/copy_data.csv with csv header ; -- test copy with blocking trigger CREATE FUNCTION gt_10() RETURNS trigger AS $func$ BEGIN IF NEW."time" < 11 THEN RETURN NULL; END IF; RETURN NEW; END $func$ LANGUAGE plpgsql; CREATE TABLE "trigger_test" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('trigger_test', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (4,public,trigger_test,t) CREATE TRIGGER check_time BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION gt_10(); \copy trigger_test from data/copy_data.csv with csv header ; SELECT * FROM trigger_test ORDER BY time; time | value ------+-------------------- 11 | 0.795640022493899 12 | 0.631451691035181 13 | 0.0958626130595803 14 | 0.929304684977978 15 | 0.524866581428796 16 | 0.919249163009226 17 | 0.878917074296623 18 | 0.68551931809634 19 | 0.594833800103515 20 | 0.819584367796779 21 | 0.474171321373433 22 | 0.938535195309669 23 | 0.333933369256556 24 | 0.274582070298493 25 | 0.602348630782217 -- Test that if we copy from stdin to a hypertable and violate a null -- constraint, it does not crash and generate an appropriate error -- message. CREATE TABLE test(a INT NOT NULL, b TIMESTAMPTZ); SELECT create_hypertable('test', 'b'); create_hypertable ------------------- (5,public,test,t) \set ON_ERROR_STOP 0 COPY TEST (a,b) FROM STDIN (delimiter ',', null 'N'); ERROR: null value in column "a" of relation "_hyper_5_13_chunk" violates not-null constraint \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages TO NOTICE; -- Do a basic test of COPY with a wrong PROGRAM COPY hyper FROM PROGRAM 'error'; ERROR: program "error" failed \set ON_ERROR_STOP 1 ---------------------------------------------------------------- -- Testing COPY TO. ---------------------------------------------------------------- -- COPY TO using a hypertable will not copy any tuples, but should -- show a notice. COPY hyper TO STDOUT DELIMITER ','; NOTICE: hypertable data are in the chunks, no data will be copied -- COPY TO using a query should display all the tuples and not show a -- notice. COPY (SELECT * FROM hyper) TO STDOUT DELIMITER ','; 1,1,1 1,2,1 ---------------------------------------------------------------- -- Testing multi-buffer optimization. ---------------------------------------------------------------- CREATE TABLE "hyper_copy" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper_copy', 'time', chunk_time_interval => 2); create_hypertable ------------------------- (6,public,hyper_copy,t) -- First copy call with default client_min_messages, to get rid of the -- building index "_hyper_XXX_chunk_hyper_copy_time_idx" on table "_hyper_XXX_chunk" serially -- messages \copy hyper_copy FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). SELECT count(*) FROM hyper_copy; count ------- 50 -- Limit number of open chunks SET timescaledb.max_open_chunks_per_insert = 1; \copy hyper_copy FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). SELECT count(*) FROM hyper_copy; count ------- 75 -- Before trigger disable the multi-buffer optimization CREATE OR REPLACE FUNCTION empty_test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- Before trigger (CIM_SINGLE should be used) CREATE TRIGGER hyper_copy_trigger_insert_before BEFORE INSERT ON hyper_copy FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy FROM data/copy_data.csv WITH csv header; DEBUG: Using normal unbuffered copy operation (TS_CIM_SINGLE) because triggers are defined on the destination table. SELECT count(*) FROM hyper_copy; count ------- 100 -- Suppress 'DEBUG: EventTriggerInvoke XXXX' messages RESET client_min_messages; DROP TRIGGER hyper_copy_trigger_insert_before ON hyper_copy; SET client_min_messages TO DEBUG1; -- After trigger (CIM_MULTI_CONDITIONAL should be used) CREATE TRIGGER hyper_copy_trigger_insert_after AFTER INSERT ON hyper_copy FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). SELECT count(*) FROM hyper_copy; count ------- 125 -- Insert data into the chunks in random order COPY hyper_copy FROM STDIN DELIMITER ',' NULL AS 'null'; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). SELECT count(*) FROM hyper_copy; count ------- 154 RESET client_min_messages; RESET timescaledb.max_open_chunks_per_insert; ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (no index on destination hypertable). ---------------------------------------------------------------- CREATE TABLE "hyper_copy_noindex" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper_copy_noindex', 'time', chunk_time_interval => 10, create_default_indexes => false); create_hypertable --------------------------------- (7,public,hyper_copy_noindex,t) -- No trigger \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). RESET client_min_messages; SELECT count(*) FROM hyper_copy_noindex; count ------- 50 -- Before trigger (CIM_SINGLE should be used) CREATE TRIGGER hyper_copy_trigger_insert_before BEFORE INSERT ON hyper_copy_noindex FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; DEBUG: Using normal unbuffered copy operation (TS_CIM_SINGLE) because triggers are defined on the destination table. RESET client_min_messages; SELECT count(*) FROM hyper_copy_noindex; count ------- 100 -- After trigger (CIM_MULTI_CONDITIONAL should be used) DROP TRIGGER hyper_copy_trigger_insert_before ON hyper_copy_noindex; CREATE TRIGGER hyper_copy_trigger_insert_after AFTER INSERT ON hyper_copy_noindex FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). RESET client_min_messages; SELECT count(*) FROM hyper_copy_noindex; count ------- 150 ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (more chunks than MAX_PARTITION_BUFFERS). ---------------------------------------------------------------- CREATE TABLE "hyper_copy_large" ( "time" timestamp NOT NULL, "value" double precision NOT NULL ); -- Genate data that will create more than 32 (MAX_PARTITION_BUFFERS) -- chunks on the 10 second chunk_time_interval partitioned hypertable. INSERT INTO hyper_copy_large SELECT time, random() AS value FROM generate_series('2022-01-01', '2022-01-31', INTERVAL '1 hour') AS g1(time) ORDER BY time; SELECT COUNT(*) FROM hyper_copy_large; count ------- 721 -- Migrate data to chunks by using copy SELECT create_hypertable('hyper_copy_large', 'time', chunk_time_interval => INTERVAL '1 hour', migrate_data => 'true'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices NOTICE: migrating data to chunks create_hypertable ------------------------------- (8,public,hyper_copy_large,t) SELECT COUNT(*) FROM hyper_copy_large; count ------- 721 ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (triggers on chunks). ---------------------------------------------------------------- CREATE TABLE "table_with_chunk_trigger" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); -- This trigger counts the already inserted tuples in -- the table table_with_chunk_trigger. CREATE OR REPLACE FUNCTION count_test_chunk_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ DECLARE cnt INTEGER; BEGIN SELECT count(*) FROM table_with_chunk_trigger INTO cnt; RAISE WARNING 'Trigger counted % tuples in table table_with_chunk_trigger', cnt; IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- Create hypertable and chunks SELECT create_hypertable('table_with_chunk_trigger', 'time', chunk_time_interval => 1); create_hypertable --------------------------------------- (9,public,table_with_chunk_trigger,t) -- Insert data to create all missing chunks \copy table_with_chunk_trigger from data/copy_data.csv with csv header; SELECT count(*) FROM table_with_chunk_trigger; count ------- 25 -- Chunk 1: 1-2, Chunk 2: 2-3, Chunk 3: 3-4, Chunk 4: 4-5 SELECT chunk_schema, chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'table_with_chunk_trigger' AND range_end_integer=5 \gset -- Create before trigger on the 4th chunk CREATE TRIGGER table_with_chunk_trigger_before_trigger BEFORE INSERT ON :chunk_schema.:chunk_name FOR EACH ROW EXECUTE FUNCTION count_test_chunk_trigger(); -- Insert data -- 25 tuples are already imported. The trigger is executed before tuples -- are copied into the 4th chunk. So, the trigger should report 25+3 = 28 -- This test requires that the multi-insert buffers of the other chunks -- are flushed before the trigger is executed. SET client_min_messages TO DEBUG1; \copy table_with_chunk_trigger FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). WARNING: Trigger counted 28 tuples in table table_with_chunk_trigger RESET client_min_messages; SELECT count(*) FROM table_with_chunk_trigger; count ------- 50 DROP TRIGGER table_with_chunk_trigger_before_trigger ON :chunk_schema.:chunk_name; -- Create after trigger CREATE TRIGGER table_with_chunk_trigger_after_trigger AFTER INSERT ON :chunk_schema.:chunk_name FOR EACH ROW EXECUTE FUNCTION count_test_chunk_trigger(); -- Insert data -- 50 tuples are already imported. The trigger is executed after all -- tuples are imported. So, the trigger should report 50+25 = 75 SET client_min_messages TO DEBUG1; \copy table_with_chunk_trigger FROM data/copy_data.csv WITH csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). WARNING: Trigger counted 75 tuples in table table_with_chunk_trigger RESET client_min_messages; SELECT count(*) FROM table_with_chunk_trigger; count ------- 75 -- Hypertable with after row trigger and no index DROP TABLE table_with_chunk_trigger; CREATE TABLE "table_with_chunk_trigger" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); -- Create hypertable and chunks SELECT create_hypertable('table_with_chunk_trigger', 'time', chunk_time_interval => 1, create_default_indexes => false); create_hypertable ---------------------------------------- (10,public,table_with_chunk_trigger,t) -- Insert data to create all missing chunks \copy table_with_chunk_trigger from data/copy_data.csv with csv header; SELECT count(*) FROM table_with_chunk_trigger; count ------- 25 -- Chunk 1: 1-2, Chunk 2: 2-3, Chunk 3: 3-4, Chunk 4: 4-5 SELECT chunk_schema, chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'table_with_chunk_trigger' AND range_end_integer=5 \gset -- Create after trigger CREATE TRIGGER table_with_chunk_trigger_after_trigger AFTER INSERT ON :chunk_schema.:chunk_name FOR EACH ROW EXECUTE FUNCTION count_test_chunk_trigger(); \copy table_with_chunk_trigger from data/copy_data.csv with csv header; WARNING: Trigger counted 50 tuples in table table_with_chunk_trigger SELECT count(*) FROM table_with_chunk_trigger; count ------- 50 ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (Hypertable without before insert trigger) ---------------------------------------------------------------- CREATE TABLE "table_without_bf_trigger" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('table_without_bf_trigger', 'time', chunk_time_interval => 1); create_hypertable ---------------------------------------- (11,public,table_without_bf_trigger,t) \copy table_without_bf_trigger from data/copy_data.csv with csv header; SET client_min_messages TO DEBUG1; \copy table_without_bf_trigger from data/copy_data.csv with csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). RESET client_min_messages; SELECT count(*) FROM table_without_bf_trigger; count ------- 50 -- After trigger (CIM_MULTI_CONDITIONAL should be used) CREATE TRIGGER table_with_chunk_trigger_after_trigger AFTER INSERT ON table_without_bf_trigger FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); SET client_min_messages TO DEBUG1; \copy table_without_bf_trigger from data/copy_data.csv with csv header; DEBUG: Using optimized multi-buffer copy operation (TS_CIM_MULTI_CONDITIONAL). RESET client_min_messages; SELECT count(*) FROM table_without_bf_trigger; count ------- 75 ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (Chunks with different layouts) ---------------------------------------------------------------- -- Time is not the first attribute of the hypertable CREATE TABLE "table_with_layout_change" ( "value1" real NOT NULL DEFAULT 1, "value2" smallint DEFAULT NULL, "value3" bigint DEFAULT NULL, "time" bigint NOT NULL, "value4" double precision NOT NULL DEFAULT 4, "value5" double precision NOT NULL DEFAULT 5 ); SELECT create_hypertable('table_with_layout_change', 'time', chunk_time_interval => 1); create_hypertable ---------------------------------------- (12,public,table_with_layout_change,t) -- Chunk 1 (time = 1) COPY table_with_layout_change FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change; value1 | value2 | value3 | time | value4 | value5 --------+--------+--------+------+--------+-------- 100 | 200 | 300 | 1 | 400 | 500 -- Drop the first attribute ALTER TABLE table_with_layout_change DROP COLUMN value1; SELECT * FROM table_with_layout_change; value2 | value3 | time | value4 | value5 --------+--------+------+--------+-------- 200 | 300 | 1 | 400 | 500 -- COPY into existing chunk (time = 1) COPY table_with_layout_change FROM STDIN DELIMITER ',' NULL AS 'null'; -- Create new chunk (time = 2) COPY table_with_layout_change FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value5; value2 | value3 | time | value4 | value5 --------+--------+------+--------+-------- 200 | 300 | 1 | 400 | 500 201 | 301 | 1 | 401 | 501 202 | 302 | 2 | 402 | 502 -- Create new chunk (time = 2), insert in different order COPY table_with_layout_change (time, value5, value4, value3, value2) FROM STDIN DELIMITER ',' NULL AS 'null'; COPY table_with_layout_change (value5, value4, value3, value2, time) FROM STDIN DELIMITER ',' NULL AS 'null'; COPY table_with_layout_change (value5, value4, value3, time, value2) FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value5; value2 | value3 | time | value4 | value5 --------+--------+------+--------+-------- 200 | 300 | 1 | 400 | 500 201 | 301 | 1 | 401 | 501 202 | 302 | 2 | 402 | 502 203 | 303 | 2 | 403 | 503 204 | 304 | 2 | 404 | 504 205 | 305 | 2 | 405 | 505 -- Drop the last attribute and add a new one ALTER TABLE table_with_layout_change DROP COLUMN value5; ALTER TABLE table_with_layout_change ADD COLUMN value6 double precision NOT NULL default 600; SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value6; value2 | value3 | time | value4 | value6 --------+--------+------+--------+-------- 200 | 300 | 1 | 400 | 600 201 | 301 | 1 | 401 | 600 202 | 302 | 2 | 402 | 600 203 | 303 | 2 | 403 | 600 204 | 304 | 2 | 404 | 600 205 | 305 | 2 | 405 | 600 -- COPY in first chunk (time = 1) COPY table_with_layout_change (time, value2, value3, value4, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; -- COPY in second chunk (time = 2) COPY table_with_layout_change (time, value2, value3, value4, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; -- COPY in new chunk (time = 3) COPY table_with_layout_change (time, value2, value3, value4, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; -- COPY in all chunks, different attribute order COPY table_with_layout_change (value3, value4, time, value6, value2) FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value6; value2 | value3 | time | value4 | value6 --------+--------+------+--------+-------- 200 | 300 | 1 | 400 | 600 201 | 301 | 1 | 401 | 600 206 | 306 | 1 | 406 | 606 211 | 311 | 1 | 411 | 611 202 | 302 | 2 | 402 | 600 203 | 303 | 2 | 403 | 600 204 | 304 | 2 | 404 | 600 205 | 305 | 2 | 405 | 600 207 | 307 | 2 | 407 | 607 210 | 310 | 2 | 410 | 610 208 | 308 | 3 | 408 | 608 209 | 309 | 3 | 409 | 609 -- Drop first column ALTER TABLE table_with_layout_change DROP COLUMN value2; SELECT * FROM table_with_layout_change ORDER BY time, value3, value4, value6; value3 | time | value4 | value6 --------+------+--------+-------- 300 | 1 | 400 | 600 301 | 1 | 401 | 600 306 | 1 | 406 | 606 311 | 1 | 411 | 611 302 | 2 | 402 | 600 303 | 2 | 403 | 600 304 | 2 | 404 | 600 305 | 2 | 405 | 600 307 | 2 | 407 | 607 310 | 2 | 410 | 610 308 | 3 | 408 | 608 309 | 3 | 409 | 609 -- COPY in all exiting chunks and create a new one (time 4) COPY table_with_layout_change (value3, value4, time, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change ORDER BY time, value3, value4, value6; value3 | time | value4 | value6 --------+------+--------+-------- 300 | 1 | 400 | 600 301 | 1 | 401 | 600 306 | 1 | 406 | 606 311 | 1 | 411 | 611 315 | 1 | 415 | 615 302 | 2 | 402 | 600 303 | 2 | 403 | 600 304 | 2 | 404 | 600 305 | 2 | 405 | 600 307 | 2 | 407 | 607 310 | 2 | 410 | 610 313 | 2 | 413 | 613 308 | 3 | 408 | 608 309 | 3 | 409 | 609 312 | 3 | 412 | 612 314 | 4 | 414 | 614 -- Drop the last two columns ALTER TABLE table_with_layout_change DROP COLUMN value4; ALTER TABLE table_with_layout_change DROP COLUMN value6; -- COPY in all exiting chunks and create a new one (time 5) COPY table_with_layout_change (value3, time) FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change ORDER BY time, value3; value3 | time --------+------ 300 | 1 301 | 1 306 | 1 311 | 1 315 | 1 317 | 1 302 | 2 303 | 2 304 | 2 305 | 2 307 | 2 310 | 2 313 | 2 316 | 2 308 | 3 309 | 3 312 | 3 318 | 3 314 | 4 320 | 4 319 | 5 -- Drop the last of the initial attributes and add a new one ALTER TABLE table_with_layout_change DROP COLUMN value3; ALTER TABLE table_with_layout_change ADD COLUMN value7 double precision NOT NULL default 700; -- COPY in all exiting chunks and create a new one (time 6) COPY table_with_layout_change (value7, time) FROM STDIN DELIMITER ',' NULL AS 'null'; SELECT * FROM table_with_layout_change ORDER BY time, value7; time | value7 ------+-------- 1 | 700 1 | 700 1 | 700 1 | 700 1 | 700 1 | 700 1 | 722 2 | 700 2 | 700 2 | 700 2 | 700 2 | 700 2 | 700 2 | 700 2 | 700 2 | 721 3 | 700 3 | 700 3 | 700 3 | 700 3 | 723 4 | 700 4 | 700 4 | 726 5 | 700 5 | 724 6 | 725 -- verify check constraints work CREATE TABLE test_check(a INT, b TIMESTAMPTZ); ALTER TABLE test_check ADD CONSTRAINT c1 CHECK (a > 7); SELECT table_name FROM create_hypertable('test_check', 'b'); table_name ------------ test_check COPY test_check(a,b) FROM STDIN (delimiter ',', null 'N'); \set ON_ERROR_STOP 0 COPY test_check(a,b) FROM STDIN (delimiter ',', null 'N'); ERROR: new row for relation "_hyper_13_832_chunk" violates check constraint "c1" \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/copy_memory_usage.out����������������������������������������������0000664�0000000�0000000�00000012413�15100345067�0023113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that transaction memory usage with COPY doesn't grow. -- We need memory usage in PortalContext after the completion of the query, so -- we'll have to log it from a trigger that runs after the query is completed. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; create table uk_price_paid(price integer, "date" date, postcode1 text, postcode2 text, type smallint, is_new bool, duration smallint, addr1 text, addr2 text, street text, locality text, town text, district text, country text, category smallint); -- Aim to about 100 partitions, the data is from 1995 to 2022. select create_hypertable('uk_price_paid', 'date', chunk_time_interval => interval '90 day'); create_hypertable ---------------------------- (1,public,uk_price_paid,t) -- This is where we log the memory usage. create table portal_memory_log(id serial, bytes bigint); -- Returns the amount of memory currently allocated in a given -- memory context. Only works for PortalContext, and doesn't work for PG 12. create or replace function ts_debug_allocated_bytes(text) returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; -- Log current memory usage into the log table. create function log_memory() returns trigger as $$ begin insert into portal_memory_log values (default, ts_debug_allocated_bytes('PortalContext')); return new; end; $$ language plpgsql; -- Prepare version dependent TopTransactionContext total memory usage query. -- Using prepared statements to avoid contaminating memory usage numbers. -- PG18 removed parent column so we have to use path to get TopTransactionContext child entries. -- https://github.com/postgres/postgres/commit/f0d11275 create or replace function prepare_transaction_total_memory_usage_stmt() returns void language plpgsql as $$ begin if current_setting('server_version_num')::int < 180000 then prepare total_stmt as select sum(total_bytes) from pg_backend_memory_contexts where parent = 'TopTransactionContext'; else prepare total_stmt as select sum(m.total_bytes) from pg_backend_memory_contexts m inner join pg_backend_memory_contexts p on (m.path[m.level-1] = p.path[p.level]) where p.name = 'TopTransactionContext'; end if; end; $$; -- Add a trigger that runs after completion of each INSERT/COPY and logs the -- current memory usage. create trigger check_update after insert on uk_price_paid for each statement execute function log_memory(); -- Memory leaks often happen on cache invalidation, so make sure they are -- invalidated often and independently (at co-prime periods). set timescaledb.max_open_chunks_per_insert = 2; set timescaledb.max_cached_chunks_per_hypertable = 3; -- Try increasingly larger data sets by concatenating the same file multiple -- times. \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; select count(*) from portal_memory_log; count ------- 5 -- Check that the memory doesn't increase with file size by using linear regression. select * from portal_memory_log where ( select regr_slope(bytes, id - 1) / regr_intercept(bytes, id - 1)::float > 0.05 from portal_memory_log ); id | bytes ----+------- -- Test plpgsql leaks CREATE TABLE test_ht(tm timestamptz, val float8); SELECT * FROM create_hypertable('test_ht', 'tm'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | test_ht | t -- Use a plpgsql function to insert into the hypertable CREATE OR REPLACE FUNCTION to_double(_in text, INOUT _out double precision) LANGUAGE plpgsql IMMUTABLE parallel safe AS $$ BEGIN SELECT CAST(_in AS double precision) INTO _out; EXCEPTION WHEN others THEN --do nothing: _out already carries default END; $$; -- TopTransactionContext usage needs to remain the same after every insert -- There was a leak earlier in the child CurTransactionContext SELECT prepare_transaction_total_memory_usage_stmt(); prepare_transaction_total_memory_usage_stmt --------------------------------------------- BEGIN; INSERT INTO test_ht VALUES ('1980-01-01 00:00:00-00', to_double('23.11', 0)); EXECUTE total_stmt; sum ------- 16384 INSERT INTO test_ht VALUES ('1980-02-01 00:00:00-00', to_double('24.11', 0)); EXECUTE total_stmt; sum ------- 16384 COMMIT; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/copy_where.out�����������������������������������������������������0000664�0000000�0000000�00000006275�15100345067�0021542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ------- TEST 1: Restrictive copy from file CREATE TABLE "copy_golden" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); \COPY copy_golden (time, value) FROM data/copy_data.csv WITH CSV HEADER SELECT * FROM copy_golden ORDER BY TIME; time | value ------+-------------------- 1 | 0.951734602451324 2 | 0.717823888640851 3 | 0.543408489786088 4 | 0.641131274402142 5 | 0.12689296528697 6 | 0.0126486560329795 7 | 0.213605496101081 8 | 0.132784110959619 9 | 0.381155731156468 10 | 0.284836102742702 11 | 0.795640022493899 12 | 0.631451691035181 13 | 0.0958626130595803 14 | 0.929304684977978 15 | 0.524866581428796 16 | 0.919249163009226 17 | 0.878917074296623 18 | 0.68551931809634 19 | 0.594833800103515 20 | 0.819584367796779 21 | 0.474171321373433 22 | 0.938535195309669 23 | 0.333933369256556 24 | 0.274582070298493 25 | 0.602348630782217 CREATE TABLE "copy_control" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); \COPY copy_control (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time > 10; SELECT * FROM copy_control ORDER BY TIME; time | value ------+-------------------- 11 | 0.795640022493899 12 | 0.631451691035181 13 | 0.0958626130595803 14 | 0.929304684977978 15 | 0.524866581428796 16 | 0.919249163009226 17 | 0.878917074296623 18 | 0.68551931809634 19 | 0.594833800103515 20 | 0.819584367796779 21 | 0.474171321373433 22 | 0.938535195309669 23 | 0.333933369256556 24 | 0.274582070298493 25 | 0.602348630782217 CREATE TABLE "copy_test" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('copy_test', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (1,public,copy_test,t) \COPY copy_test (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time > 10; SELECT * FROM copy_test ORDER BY TIME; time | value ------+-------------------- 11 | 0.795640022493899 12 | 0.631451691035181 13 | 0.0958626130595803 14 | 0.929304684977978 15 | 0.524866581428796 16 | 0.919249163009226 17 | 0.878917074296623 18 | 0.68551931809634 19 | 0.594833800103515 20 | 0.819584367796779 21 | 0.474171321373433 22 | 0.938535195309669 23 | 0.333933369256556 24 | 0.274582070298493 25 | 0.602348630782217 -- Verify attempting to use subqueries fails the same as non-hypertables \set ON_ERROR_STOP 0 \COPY copy_control (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time IN (SELECT time FROM copy_golden); ERROR: cannot use subquery in COPY FROM WHERE condition at character 74 \COPY copy_test (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time IN (SELECT time FROM copy_golden); ERROR: cannot use subquery in COPY FROM WHERE condition at character 71 \set ON_ERROR_STOP 1 DROP TABLE copy_golden; DROP TABLE copy_control; DROP TABLE copy_test; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/create_chunks.out��������������������������������������������������0000664�0000000�0000000�00000030571�15100345067�0022210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- This test will create chunks in two dimenisions, time (x) and -- space (y), where the time dimension is aligned. The figure below -- shows the expected result. The chunk number in the figure -- indicates the creation order. -- -- + -- + -- + +-----+ +-----+ -- + | 2 | | 3 | -- + | +---+-+ | -- + +-----+ 5 |6+-----+ -- + | 1 +---+-+-----+ +---------+ -- + | | |4| 7 | | 8 | -- +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- -- 0 5 10 15 20 -- -- Partitioning: -- -- Chunk # | time | space -- 1 | 3 | 2 -- 4 | 1 | 3 -- 5 | 5 | 3 -- CREATE TABLE chunk_test(time integer, temp float8, tag integer, color integer); SELECT create_hypertable('chunk_test', 'time', 'tag', 2, chunk_time_interval => 3); create_hypertable ------------------------- (1,public,chunk_test,t) INSERT INTO chunk_test VALUES (4, 24.3, 1, 1); SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+----------------------+------------ 1 | 1 | 3 | 6 2 | 2 | -9223372036854775808 | 1073741823 INSERT INTO chunk_test VALUES (4, 24.3, 2, 1); INSERT INTO chunk_test VALUES (10, 24.3, 2, 1); SELECT c.table_name AS chunk_name, d.id AS dimension_id, ds.id AS slice_id, range_start, range_end FROM _timescaledb_catalog.chunk c LEFT JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) LEFT JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) LEFT JOIN _timescaledb_catalog.dimension d ON (d.id = ds.dimension_id) LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test' ORDER BY c.id, d.id; chunk_name | dimension_id | slice_id | range_start | range_end ------------------+--------------+----------+----------------------+--------------------- _hyper_1_1_chunk | 1 | 1 | 3 | 6 _hyper_1_1_chunk | 2 | 2 | -9223372036854775808 | 1073741823 _hyper_1_2_chunk | 1 | 1 | 3 | 6 _hyper_1_2_chunk | 2 | 3 | 1073741823 | 9223372036854775807 _hyper_1_3_chunk | 1 | 4 | 9 | 12 _hyper_1_3_chunk | 2 | 3 | 1073741823 | 9223372036854775807 \c :TEST_DBNAME :ROLE_SUPERUSER SELECT set_number_partitions('chunk_test', 3); set_number_partitions ----------------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT set_chunk_time_interval('chunk_test', 1::bigint); set_chunk_time_interval ------------------------- INSERT INTO chunk_test VALUES (8, 24.3, 11233, 1); SELECT set_chunk_time_interval('chunk_test', 5::bigint); set_chunk_time_interval ------------------------- SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 2 | 1 | tag | integer | f | 3 | _timescaledb_functions | get_partition_hash | | | | 1 | 1 | time | integer | t | | | | 5 | | | INSERT INTO chunk_test VALUES (7, 24.3, 79669, 1); INSERT INTO chunk_test VALUES (8, 24.3, 79669, 1); INSERT INTO chunk_test VALUES (10, 24.3, 11233, 1); INSERT INTO chunk_test VALUES (16, 24.3, 11233, 1); SELECT c.table_name AS chunk_name, d.id AS dimension_id, ds.id AS slice_id, range_start, range_end FROM _timescaledb_catalog.chunk c LEFT JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) LEFT JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) LEFT JOIN _timescaledb_catalog.dimension d ON (d.id = ds.dimension_id) LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test' ORDER BY c.id, d.id; chunk_name | dimension_id | slice_id | range_start | range_end ------------------+--------------+----------+----------------------+--------------------- _hyper_1_1_chunk | 1 | 1 | 3 | 6 _hyper_1_1_chunk | 2 | 2 | -9223372036854775808 | 1073741823 _hyper_1_2_chunk | 1 | 1 | 3 | 6 _hyper_1_2_chunk | 2 | 3 | 1073741823 | 9223372036854775807 _hyper_1_3_chunk | 1 | 4 | 9 | 12 _hyper_1_3_chunk | 2 | 3 | 1073741823 | 9223372036854775807 _hyper_1_4_chunk | 1 | 5 | 8 | 9 _hyper_1_4_chunk | 2 | 6 | -9223372036854775808 | 715827882 _hyper_1_5_chunk | 1 | 7 | 6 | 8 _hyper_1_5_chunk | 2 | 8 | 715827882 | 1431655764 _hyper_1_6_chunk | 1 | 5 | 8 | 9 _hyper_1_6_chunk | 2 | 8 | 715827882 | 1431655764 _hyper_1_7_chunk | 1 | 4 | 9 | 12 _hyper_1_7_chunk | 2 | 6 | -9223372036854775808 | 715827882 _hyper_1_8_chunk | 1 | 9 | 15 | 20 _hyper_1_8_chunk | 2 | 6 | -9223372036854775808 | 715827882 --test the edges of an open partition -- INT_64_MAX and INT_64_MIN. CREATE TABLE chunk_test_ends(time bigint, temp float8, tag integer, color integer); SELECT create_hypertable('chunk_test_ends', 'time', chunk_time_interval => 5); create_hypertable ------------------------------ (2,public,chunk_test_ends,t) INSERT INTO chunk_test_ends VALUES ((-9223372036854775808)::bigint, 23.1, 11233, 1); INSERT INTO chunk_test_ends VALUES (9223372036854775807::bigint, 24.1, 11233, 1); --try to hit cache INSERT INTO chunk_test_ends VALUES (9223372036854775807::bigint, 24.2, 11233, 1); INSERT INTO chunk_test_ends VALUES (9223372036854775807::bigint, 24.3, 11233, 1), (9223372036854775807::bigint, 24.4, 11233, 1); INSERT INTO chunk_test_ends VALUES ((-9223372036854775808)::bigint, 23.2, 11233, 1); INSERT INTO chunk_test_ends VALUES ((-9223372036854775808)::bigint, 23.3, 11233, 1), ((-9223372036854775808)::bigint, 23.4, 11233, 1); SELECT * FROM chunk_test_ends ORDER BY time asc, tag, temp; time | temp | tag | color ----------------------+------+-------+------- -9223372036854775808 | 23.1 | 11233 | 1 -9223372036854775808 | 23.2 | 11233 | 1 -9223372036854775808 | 23.3 | 11233 | 1 -9223372036854775808 | 23.4 | 11233 | 1 9223372036854775807 | 24.1 | 11233 | 1 9223372036854775807 | 24.2 | 11233 | 1 9223372036854775807 | 24.3 | 11233 | 1 9223372036854775807 | 24.4 | 11233 | 1 --further tests of set_chunk_time_interval CREATE TABLE chunk_test2(time TIMESTAMPTZ, temp float8, tag integer, color integer); SELECT create_hypertable('chunk_test2', 'time', 'tag', 2, chunk_time_interval => 3); WARNING: unexpected interval: smaller than one second create_hypertable -------------------------- (3,public,chunk_test2,t) SELECT interval_length FROM _timescaledb_catalog.dimension d LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test2' ORDER BY d.id; interval_length ----------------- 3 -- should work since time column is non-INT SELECT set_chunk_time_interval('chunk_test2', INTERVAL '1 minute'); set_chunk_time_interval ------------------------- SELECT interval_length FROM _timescaledb_catalog.dimension d LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test2' ORDER BY d.id; interval_length ----------------- 60000000 -- should still work for non-INT time columns SELECT set_chunk_time_interval('chunk_test2', 1000000); set_chunk_time_interval ------------------------- SELECT interval_length FROM _timescaledb_catalog.dimension d LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test2' ORDER BY d.id; interval_length ----------------- 1000000 \set ON_ERROR_STOP 0 select set_chunk_time_interval(NULL,NULL::interval); ERROR: hypertable cannot be NULL -- should fail since time column is an int SELECT set_chunk_time_interval('chunk_test', INTERVAL '1 minute'); ERROR: invalid interval type for integer dimension -- should fail since its not a valid way to represent time SELECT set_chunk_time_interval('chunk_test', 'foo'::TEXT); ERROR: invalid interval type for integer dimension SELECT set_chunk_time_interval('chunk_test', NULL::BIGINT); ERROR: invalid interval: an explicit interval must be specified SELECT set_chunk_time_interval('chunk_test2', NULL::BIGINT); ERROR: invalid interval: an explicit interval must be specified SELECT set_chunk_time_interval('chunk_test2', NULL::INTERVAL); ERROR: invalid interval: an explicit interval must be specified \set ON_ERROR_STOP 1 -- Issue https://github.com/timescale/timescaledb/issues/7406 CREATE TABLE test_ht (time TIMESTAMPTZ, v1 INTEGER); SELECT create_hypertable('test_ht', by_range('time', INTERVAL '1 hour')); create_hypertable ------------------- (4,t) CREATE TABLE test_tb (time TIMESTAMPTZ, v1 INTEGER); CREATE OR REPLACE FUNCTION test_tb_trg_insert() RETURNS TRIGGER AS $$ BEGIN INSERT INTO test_ht VALUES (NEW.time, NEW.v1); RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_tb_trg_insert AFTER INSERT ON test_tb FOR EACH ROW EXECUTE FUNCTION test_tb_trg_insert(); -- Creating new chunk inside a trigger called by -- a DDL statement should not fail. CREATE TABLE test_output AS WITH inserted AS ( INSERT INTO test_tb VALUES (NOW(), 1), (NOW(), 2) RETURNING * ) SELECT * FROM inserted; -- Check the DEFAULT REPLICA IDENTITY of the chunks SELECT relname, relreplident FROM show_chunks('test_ht') ch JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident -------------------+-------------- _hyper_4_11_chunk | d -- Clean up TRUNCATE test_ht, test_tb; DROP TABLE test_output; -- Change the DEFAULT REPLICA IDENTITY of the chunks ALTER TABLE test_ht REPLICA IDENTITY FULL; -- Internally we force new chunks have the same REPLICA IDENTITY -- as the parent table. CREATE TABLE test_output AS WITH inserted AS ( INSERT INTO test_tb VALUES (NOW(), 1), (NOW(), 2) RETURNING * ) SELECT * FROM inserted; -- Check current new REPLICA IDENTITY FULL in the chunks SELECT relname, relreplident FROM show_chunks('test_ht') ch JOIN pg_class c ON (ch = c.oid) ORDER BY relname; relname | relreplident -------------------+-------------- _hyper_4_12_chunk | f -- All tables should have the same number of rows SELECT count(*) FROM test_tb; count ------- 2 SELECT count(*) FROM test_ht; count ------- 2 SELECT count(*) FROM test_output; count ------- 2 -- test ALTER TABLE SET (tsdb.chunk_interval) on a hypertable CREATE TABLE t_with(time timestamptz not null, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 't_with'; time_interval --------------- @ 7 days ALTER TABLE t_with SET (tsdb.chunk_interval = '1 hour'); SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 't_with'; time_interval --------------- @ 1 hour ���������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/create_hypertable.out����������������������������������������������0000664�0000000�0000000�00000175255�15100345067�0023065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER create schema test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; create schema chunk_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER; create table test_schema.test_table(time BIGINT, temp float8, device_id text, device_type text, location text, id int, id2 int); \set ON_ERROR_STOP 0 -- get_create_command should fail since hypertable isn't made yet SELECT * FROM _timescaledb_functions.get_create_command('test_table'); ERROR: hypertable "test_table" not found \set ON_ERROR_STOP 1 SELECT * FROM test.relation WHERE schema = 'test_schema'; schema | name | type | owner -------------+------------+-------+------------------- test_schema | test_table | table | default_perm_user \d _timescaledb_catalog.chunk Table "_timescaledb_catalog.chunk" Column | Type | Collation | Nullable | Default ---------------------+--------------------------+-----------+----------+-------------------------------------------------------- id | integer | | not null | nextval('_timescaledb_catalog.chunk_id_seq'::regclass) hypertable_id | integer | | not null | schema_name | name | | not null | table_name | name | | not null | compressed_chunk_id | integer | | | dropped | boolean | | not null | false status | integer | | not null | 0 osm_chunk | boolean | | not null | false creation_time | timestamp with time zone | | not null | Indexes: "chunk_pkey" PRIMARY KEY, btree (id) "chunk_compressed_chunk_id_idx" btree (compressed_chunk_id) "chunk_hypertable_id_creation_time_idx" btree (hypertable_id, creation_time) "chunk_hypertable_id_idx" btree (hypertable_id) "chunk_osm_chunk_idx" btree (osm_chunk, hypertable_id) "chunk_schema_name_table_name_key" UNIQUE CONSTRAINT, btree (schema_name, table_name) Foreign-key constraints: "chunk_compressed_chunk_id_fkey" FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk(id) "chunk_hypertable_id_fkey" FOREIGN KEY (hypertable_id) REFERENCES _timescaledb_catalog.hypertable(id) Referenced by: TABLE "_timescaledb_internal.bgw_policy_chunk_stats" CONSTRAINT "bgw_policy_chunk_stats_chunk_id_fkey" FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE TABLE "_timescaledb_catalog.chunk_column_stats" CONSTRAINT "chunk_column_stats_chunk_id_fkey" FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) TABLE "_timescaledb_catalog.chunk" CONSTRAINT "chunk_compressed_chunk_id_fkey" FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk(id) TABLE "_timescaledb_catalog.chunk_constraint" CONSTRAINT "chunk_constraint_chunk_id_fkey" FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) TABLE "_timescaledb_catalog.compression_chunk_size" CONSTRAINT "compression_chunk_size_chunk_id_fkey" FOREIGN KEY (chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE TABLE "_timescaledb_catalog.compression_chunk_size" CONSTRAINT "compression_chunk_size_compressed_chunk_id_fkey" FOREIGN KEY (compressed_chunk_id) REFERENCES _timescaledb_catalog.chunk(id) ON DELETE CASCADE create table test_schema.test_table_no_not_null(time BIGINT, device_id text); \set ON_ERROR_STOP 0 -- Permission denied with unprivileged role SET ROLE :ROLE_DEFAULT_PERM_USER_2; select * from create_hypertable('test_schema.test_table_no_not_null', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: permission denied for schema test_schema at character 33 -- CREATE on schema is not enough SET ROLE :ROLE_DEFAULT_PERM_USER; GRANT ALL ON SCHEMA test_schema TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; select * from create_hypertable('test_schema.test_table_no_not_null', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: must be owner of hypertable "test_table_no_not_null" \set ON_ERROR_STOP 1 -- Should work with when granted table owner role RESET ROLE; GRANT :ROLE_DEFAULT_PERM_USER TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; select * from create_hypertable('test_schema.test_table_no_not_null', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+------------------------+--------- 1 | test_schema | test_table_no_not_null | t \set ON_ERROR_STOP 0 insert into test_schema.test_table_no_not_null (device_id) VALUES('foo'); ERROR: NULL value in column "time" violates not-null constraint \set ON_ERROR_STOP 1 insert into test_schema.test_table_no_not_null (time, device_id) VALUES(1, 'foo'); RESET ROLE; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- No permissions on associated schema should fail select * from create_hypertable('test_schema.test_table', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month'), associated_schema_name => 'chunk_schema'); ERROR: permissions denied: cannot create chunks in schema "chunk_schema" \set ON_ERROR_STOP 1 -- Granting permissions on chunk_schema should make things work RESET ROLE; GRANT CREATE ON SCHEMA chunk_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; select * from create_hypertable('test_schema.test_table', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month'), associated_schema_name => 'chunk_schema'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | test_schema | test_table | t -- Check that the insert block trigger exists SELECT * FROM test.show_triggers('test_schema.test_table'); Trigger | Type | Function ---------+------+---------- SELECT * FROM _timescaledb_functions.get_create_command('test_table'); get_create_command -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT create_hypertable('test_schema.test_table', 'time', 'device_id', 2, chunk_time_interval => 2592000000000, create_default_indexes=>FALSE); --test adding one more closed dimension select add_dimension('test_schema.test_table', 'location', 4); add_dimension --------------------------------------- (5,test_schema,test_table,location,t) select * from _timescaledb_catalog.hypertable where table_name = 'test_table'; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 2 | test_schema | test_table | chunk_schema | _hyper_2 | 3 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 select * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | bigint | t | | | | 2592000000000 | | | 2 | 1 | device_id | text | f | 2 | _timescaledb_functions | get_partition_hash | | | | 3 | 2 | time | bigint | t | | | | 2592000000000 | | | 4 | 2 | device_id | text | f | 2 | _timescaledb_functions | get_partition_hash | | | | 5 | 2 | location | text | f | 4 | _timescaledb_functions | get_partition_hash | | | | --test that we can change the number of partitions and that 1 is allowed SELECT set_number_partitions('test_schema.test_table', 1, 'location'); set_number_partitions ----------------------- select * from _timescaledb_catalog.dimension WHERE column_name = 'location'; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 5 | 2 | location | text | f | 1 | _timescaledb_functions | get_partition_hash | | | | SELECT set_number_partitions('test_schema.test_table', 2, 'location'); set_number_partitions ----------------------- select * from _timescaledb_catalog.dimension WHERE column_name = 'location'; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 5 | 2 | location | text | f | 2 | _timescaledb_functions | get_partition_hash | | | | \set ON_ERROR_STOP 0 --must give an explicit dimension when there are multiple space dimensions SELECT set_number_partitions('test_schema.test_table', 3); ERROR: hypertable "test_table" has multiple space dimensions --too few SELECT set_number_partitions('test_schema.test_table', 0, 'location'); ERROR: invalid number of partitions: must be between 1 and 32767 -- Too many SELECT set_number_partitions('test_schema.test_table', 32768, 'location'); ERROR: invalid number of partitions: must be between 1 and 32767 -- get_create_command only works on tables w/ 1 or 2 dimensions SELECT * FROM _timescaledb_functions.get_create_command('test_table'); ERROR: get_create_command only supports hypertables with up to 2 dimensions \set ON_ERROR_STOP 1 --test adding one more open dimension select add_dimension('test_schema.test_table', 'id', chunk_time_interval => 1000); add_dimension --------------------------------- (6,test_schema,test_table,id,t) select * from _timescaledb_catalog.hypertable where table_name = 'test_table'; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 2 | test_schema | test_table | chunk_schema | _hyper_2 | 4 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 select * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | bigint | t | | | | 2592000000000 | | | 2 | 1 | device_id | text | f | 2 | _timescaledb_functions | get_partition_hash | | | | 3 | 2 | time | bigint | t | | | | 2592000000000 | | | 4 | 2 | device_id | text | f | 2 | _timescaledb_functions | get_partition_hash | | | | 5 | 2 | location | text | f | 2 | _timescaledb_functions | get_partition_hash | | | | 6 | 2 | id | integer | t | | | | 1000 | | | -- Test add_dimension: can use interval types for TIMESTAMPTZ columns CREATE TABLE dim_test_time(time TIMESTAMPTZ, time2 TIMESTAMPTZ, time3 BIGINT, temp float8, device int, location int); SELECT create_hypertable('dim_test_time', 'time'); create_hypertable ---------------------------- (3,public,dim_test_time,t) SELECT add_dimension('dim_test_time', 'time2', chunk_time_interval => INTERVAL '1 day'); add_dimension ---------------------------------- (8,public,dim_test_time,time2,t) -- Test add_dimension: only integral should work on BIGINT columns \set ON_ERROR_STOP 0 SELECT add_dimension('dim_test_time', 'time3', chunk_time_interval => INTERVAL '1 day'); ERROR: invalid interval type for bigint dimension -- string is not a valid type SELECT add_dimension('dim_test_time', 'time3', chunk_time_interval => 'foo'::TEXT); ERROR: invalid interval type for bigint dimension \set ON_ERROR_STOP 1 SELECT add_dimension('dim_test_time', 'time3', chunk_time_interval => 500); add_dimension ---------------------------------- (9,public,dim_test_time,time3,t) -- Test add_dimension: integrals should work on TIMESTAMPTZ columns CREATE TABLE dim_test_time2(time TIMESTAMPTZ, time2 TIMESTAMPTZ, temp float8, device int, location int); SELECT create_hypertable('dim_test_time2', 'time'); create_hypertable ----------------------------- (4,public,dim_test_time2,t) SELECT add_dimension('dim_test_time2', 'time2', chunk_time_interval => 500); WARNING: unexpected interval: smaller than one second add_dimension ------------------------------------ (11,public,dim_test_time2,time2,t) --adding a dimension twice should not fail with 'if_not_exists' SELECT add_dimension('dim_test_time2', 'time2', chunk_time_interval => 500, if_not_exists => true); NOTICE: column "time2" is already a dimension, skipping add_dimension ------------------------------------ (11,public,dim_test_time2,time2,f) \set ON_ERROR_STOP 0 --adding on a non-hypertable CREATE TABLE not_hypertable(time TIMESTAMPTZ, temp float8, device int, location int); SELECT add_dimension('not_hypertable', 'time', chunk_time_interval => 500); ERROR: table "not_hypertable" is not a hypertable --adding a non-exist column SELECT add_dimension('test_schema.test_table', 'nope', 2); ERROR: column "nope" does not exist --adding the same dimension twice should fail select add_dimension('test_schema.test_table', 'location', 2); ERROR: column "location" is already a dimension --adding dimension with both number_partitions and chunk_time_interval should fail select add_dimension('test_schema.test_table', 'id2', number_partitions => 2, chunk_time_interval => 1000); ERROR: cannot specify both the number of partitions and an interval \set ON_ERROR_STOP 1 -- test adding a new dimension on a non-empty table CREATE TABLE dim_test(time TIMESTAMPTZ, device int); SELECT create_hypertable('dim_test', 'time', chunk_time_interval => INTERVAL '1 day'); create_hypertable ----------------------- (5,public,dim_test,t) CREATE VIEW dim_test_slices AS SELECT c.id AS chunk_id, c.hypertable_id, ds.dimension_id, cc.dimension_slice_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test' ORDER BY c.id, ds.dimension_id; INSERT INTO dim_test VALUES ('2004-10-10 00:00:00+00', 1); INSERT INTO dim_test VALUES ('2004-10-20 00:00:00+00', 2); SELECT * FROM dim_test_slices; chunk_id | hypertable_id | dimension_id | dimension_slice_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+--------------------+-----------------------+------------------+------------------+------------------ 2 | 5 | 12 | 3 | _timescaledb_internal | _hyper_5_2_chunk | 1097366400000000 | 1097452800000000 3 | 5 | 12 | 4 | _timescaledb_internal | _hyper_5_3_chunk | 1098230400000000 | 1098316800000000 SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_2_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated --------------+------+---------+-------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- constraint_3 | c | {time} | - | (("time" >= 'Sat Oct 09 17:00:00 2004 PDT'::timestamp with time zone) AND ("time" < 'Sun Oct 10 17:00:00 2004 PDT'::timestamp with time zone)) | f | f | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_3_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated --------------+------+---------+-------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- constraint_4 | c | {time} | - | (("time" >= 'Tue Oct 19 17:00:00 2004 PDT'::timestamp with time zone) AND ("time" < 'Wed Oct 20 17:00:00 2004 PDT'::timestamp with time zone)) | f | f | t -- add dimension to the existing chunks by adding -inf/inf dimension slices SELECT add_dimension('dim_test', 'device', 2); add_dimension ------------------------------- (13,public,dim_test,device,t) SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_2_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated --------------+------+---------+-------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- constraint_3 | c | {time} | - | (("time" >= 'Sat Oct 09 17:00:00 2004 PDT'::timestamp with time zone) AND ("time" < 'Sun Oct 10 17:00:00 2004 PDT'::timestamp with time zone)) | f | f | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_3_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated --------------+------+---------+-------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- constraint_4 | c | {time} | - | (("time" >= 'Tue Oct 19 17:00:00 2004 PDT'::timestamp with time zone) AND ("time" < 'Wed Oct 20 17:00:00 2004 PDT'::timestamp with time zone)) | f | f | t SELECT * FROM dim_test_slices; chunk_id | hypertable_id | dimension_id | dimension_slice_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+--------------------+-----------------------+------------------+----------------------+--------------------- 2 | 5 | 12 | 3 | _timescaledb_internal | _hyper_5_2_chunk | 1097366400000000 | 1097452800000000 2 | 5 | 13 | 5 | _timescaledb_internal | _hyper_5_2_chunk | -9223372036854775808 | 9223372036854775807 3 | 5 | 12 | 4 | _timescaledb_internal | _hyper_5_3_chunk | 1098230400000000 | 1098316800000000 3 | 5 | 13 | 5 | _timescaledb_internal | _hyper_5_3_chunk | -9223372036854775808 | 9223372036854775807 -- newer chunks have proper dimension slices range INSERT INTO dim_test VALUES ('2004-10-30 00:00:00+00', 3); SELECT * FROM dim_test_slices; chunk_id | hypertable_id | dimension_id | dimension_slice_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+--------------------+-----------------------+------------------+----------------------+--------------------- 2 | 5 | 12 | 3 | _timescaledb_internal | _hyper_5_2_chunk | 1097366400000000 | 1097452800000000 2 | 5 | 13 | 5 | _timescaledb_internal | _hyper_5_2_chunk | -9223372036854775808 | 9223372036854775807 3 | 5 | 12 | 4 | _timescaledb_internal | _hyper_5_3_chunk | 1098230400000000 | 1098316800000000 3 | 5 | 13 | 5 | _timescaledb_internal | _hyper_5_3_chunk | -9223372036854775808 | 9223372036854775807 4 | 5 | 12 | 6 | _timescaledb_internal | _hyper_5_4_chunk | 1099094400000000 | 1099180800000000 4 | 5 | 13 | 7 | _timescaledb_internal | _hyper_5_4_chunk | 1073741823 | 9223372036854775807 SELECT * FROM dim_test ORDER BY time; time | device ------------------------------+-------- Sat Oct 09 17:00:00 2004 PDT | 1 Tue Oct 19 17:00:00 2004 PDT | 2 Fri Oct 29 17:00:00 2004 PDT | 3 DROP VIEW dim_test_slices; DROP TABLE dim_test; -- test add_dimension() with existing data on table with space partitioning CREATE TABLE dim_test(time TIMESTAMPTZ, device int, data int); SELECT create_hypertable('dim_test', 'time', 'device', 2, chunk_time_interval => INTERVAL '1 day'); create_hypertable ----------------------- (6,public,dim_test,t) CREATE VIEW dim_test_slices AS SELECT c.id AS chunk_id, c.hypertable_id, ds.dimension_id, cc.dimension_slice_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test' ORDER BY c.id, ds.dimension_id; INSERT INTO dim_test VALUES ('2004-10-10 00:00:00+00', 1, 3); INSERT INTO dim_test VALUES ('2004-10-20 00:00:00+00', 2, 2); SELECT * FROM dim_test_slices; chunk_id | hypertable_id | dimension_id | dimension_slice_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+--------------------+-----------------------+------------------+----------------------+--------------------- 5 | 6 | 14 | 8 | _timescaledb_internal | _hyper_6_5_chunk | 1097366400000000 | 1097452800000000 5 | 6 | 15 | 9 | _timescaledb_internal | _hyper_6_5_chunk | -9223372036854775808 | 1073741823 6 | 6 | 14 | 10 | _timescaledb_internal | _hyper_6_6_chunk | 1098230400000000 | 1098316800000000 6 | 6 | 15 | 11 | _timescaledb_internal | _hyper_6_6_chunk | 1073741823 | 9223372036854775807 -- new dimension slice will cover full range on existing chunks SELECT add_dimension('dim_test', 'data', 1); add_dimension ----------------------------- (16,public,dim_test,data,t) SELECT * FROM dim_test_slices; chunk_id | hypertable_id | dimension_id | dimension_slice_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+--------------------+-----------------------+------------------+----------------------+--------------------- 5 | 6 | 14 | 8 | _timescaledb_internal | _hyper_6_5_chunk | 1097366400000000 | 1097452800000000 5 | 6 | 15 | 9 | _timescaledb_internal | _hyper_6_5_chunk | -9223372036854775808 | 1073741823 5 | 6 | 16 | 12 | _timescaledb_internal | _hyper_6_5_chunk | -9223372036854775808 | 9223372036854775807 6 | 6 | 14 | 10 | _timescaledb_internal | _hyper_6_6_chunk | 1098230400000000 | 1098316800000000 6 | 6 | 15 | 11 | _timescaledb_internal | _hyper_6_6_chunk | 1073741823 | 9223372036854775807 6 | 6 | 16 | 12 | _timescaledb_internal | _hyper_6_6_chunk | -9223372036854775808 | 9223372036854775807 INSERT INTO dim_test VALUES ('2004-10-30 00:00:00+00', 3, 1); SELECT * FROM dim_test_slices; chunk_id | hypertable_id | dimension_id | dimension_slice_id | chunk_schema | chunk_table | range_start | range_end ----------+---------------+--------------+--------------------+-----------------------+------------------+----------------------+--------------------- 5 | 6 | 14 | 8 | _timescaledb_internal | _hyper_6_5_chunk | 1097366400000000 | 1097452800000000 5 | 6 | 15 | 9 | _timescaledb_internal | _hyper_6_5_chunk | -9223372036854775808 | 1073741823 5 | 6 | 16 | 12 | _timescaledb_internal | _hyper_6_5_chunk | -9223372036854775808 | 9223372036854775807 6 | 6 | 14 | 10 | _timescaledb_internal | _hyper_6_6_chunk | 1098230400000000 | 1098316800000000 6 | 6 | 15 | 11 | _timescaledb_internal | _hyper_6_6_chunk | 1073741823 | 9223372036854775807 6 | 6 | 16 | 12 | _timescaledb_internal | _hyper_6_6_chunk | -9223372036854775808 | 9223372036854775807 7 | 6 | 14 | 13 | _timescaledb_internal | _hyper_6_7_chunk | 1099094400000000 | 1099180800000000 7 | 6 | 15 | 11 | _timescaledb_internal | _hyper_6_7_chunk | 1073741823 | 9223372036854775807 7 | 6 | 16 | 12 | _timescaledb_internal | _hyper_6_7_chunk | -9223372036854775808 | 9223372036854775807 SELECT * FROM dim_test ORDER BY time; time | device | data ------------------------------+--------+------ Sat Oct 09 17:00:00 2004 PDT | 1 | 3 Tue Oct 19 17:00:00 2004 PDT | 2 | 2 Fri Oct 29 17:00:00 2004 PDT | 3 | 1 DROP VIEW dim_test_slices; DROP TABLE dim_test; -- should not fail on non-empty table with 'if_not_exists' in case the dimension exists select add_dimension('test_schema.test_table', 'location', 2, if_not_exists => true); NOTICE: column "location" is already a dimension, skipping add_dimension --------------------------------------- (5,test_schema,test_table,location,f) --test partitioning in only time dimension create table test_schema.test_1dim(time timestamp, temp float); select create_hypertable('test_schema.test_1dim', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------- (7,test_schema,test_1dim,t) SELECT * FROM _timescaledb_functions.get_create_command('test_1dim'); get_create_command -------------------------------------------------------------------------------------------------------------------------------- SELECT create_hypertable('test_schema.test_1dim', 'time', chunk_time_interval => 604800000000, create_default_indexes=>FALSE); SELECT * FROM test.relation WHERE schema = 'test_schema'; schema | name | type | owner -------------+------------------------+-------+------------------- test_schema | test_1dim | table | default_perm_user test_schema | test_table | table | default_perm_user test_schema | test_table_no_not_null | table | default_perm_user select create_hypertable('test_schema.test_1dim', 'time', if_not_exists => true); NOTICE: table "test_1dim" is already a hypertable, skipping create_hypertable ----------------------------- (7,test_schema,test_1dim,f) -- Should error when creating again without if_not_exists set to true \set ON_ERROR_STOP 0 select create_hypertable('test_schema.test_1dim', 'time'); ERROR: table "test_1dim" is already a hypertable \set ON_ERROR_STOP 1 -- if_not_exist should also work with data in the hypertable insert into test_schema.test_1dim VALUES ('2004-10-19 10:23:54+02', 1.0); select create_hypertable('test_schema.test_1dim', 'time', if_not_exists => true); NOTICE: table "test_1dim" is already a hypertable, skipping create_hypertable ----------------------------- (7,test_schema,test_1dim,f) -- Should error when creating again without if_not_exists set to true \set ON_ERROR_STOP 0 select create_hypertable('test_schema.test_1dim', 'time'); ERROR: table "test_1dim" is already a hypertable \set ON_ERROR_STOP 1 -- Test partitioning functions CREATE OR REPLACE FUNCTION invalid_partfunc(source integer) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN NULL; END $BODY$; CREATE OR REPLACE FUNCTION time_partfunc(source text) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN timezone('UTC', to_timestamp(source)); END $BODY$; CREATE TABLE test_schema.test_invalid_func(time timestamptz, temp float8, device text); \set ON_ERROR_STOP 0 -- should fail due to invalid signature SELECT create_hypertable('test_schema.test_invalid_func', 'time', 'device', 2, partitioning_func => 'invalid_partfunc'); ERROR: invalid partitioning function SELECT create_hypertable('test_schema.test_invalid_func', 'time'); create_hypertable ------------------------------------- (8,test_schema,test_invalid_func,t) -- should also fail due to invalid signature SELECT add_dimension('test_schema.test_invalid_func', 'device', 2, partitioning_func => 'invalid_partfunc'); ERROR: invalid partitioning function \set ON_ERROR_STOP 1 -- Test open-dimension function CREATE TABLE test_schema.open_dim_part_func(time text, temp float8, device text, event_time text); \set ON_ERROR_STOP 0 -- should fail due to invalid signature SELECT create_hypertable('test_schema.open_dim_part_func', 'time', time_partitioning_func => 'invalid_partfunc'); ERROR: invalid partitioning function \set ON_ERROR_STOP 1 SELECT create_hypertable('test_schema.open_dim_part_func', 'time', time_partitioning_func => 'time_partfunc'); create_hypertable -------------------------------------- (9,test_schema,open_dim_part_func,t) \set ON_ERROR_STOP 0 -- should fail due to invalid signature SELECT add_dimension('test_schema.open_dim_part_func', 'event_time', chunk_time_interval => interval '1 day', partitioning_func => 'invalid_partfunc'); ERROR: invalid partitioning function \set ON_ERROR_STOP 1 SELECT add_dimension('test_schema.open_dim_part_func', 'event_time', chunk_time_interval => interval '1 day', partitioning_func => 'time_partfunc'); add_dimension -------------------------------------------------- (20,test_schema,open_dim_part_func,event_time,t) --test data migration create table test_schema.test_migrate(time timestamp, temp float); insert into test_schema.test_migrate VALUES ('2004-10-19 10:23:54+02', 1.0), ('2004-12-19 10:23:54+02', 2.0); select * from only test_schema.test_migrate; time | temp --------------------------+------ Tue Oct 19 10:23:54 2004 | 1 Sun Dec 19 10:23:54 2004 | 2 \set ON_ERROR_STOP 0 --should fail without migrate_data => true select create_hypertable('test_schema.test_migrate', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices ERROR: table "test_migrate" is not empty \set ON_ERROR_STOP 1 select create_hypertable('test_schema.test_migrate', 'time', migrate_data => true); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices NOTICE: migrating data to chunks create_hypertable --------------------------------- (10,test_schema,test_migrate,t) --there should be two new chunks select * from _timescaledb_catalog.hypertable where table_name = 'test_migrate'; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+--------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 10 | test_schema | test_migrate | _timescaledb_internal | _hyper_10 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 select id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk from _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+--------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 8 | 7 | _timescaledb_internal | _hyper_7_8_chunk | | f | 0 | f 9 | 10 | _timescaledb_internal | _hyper_10_9_chunk | | f | 0 | f 10 | 10 | _timescaledb_internal | _hyper_10_10_chunk | | f | 0 | f select * from test_schema.test_migrate; time | temp --------------------------+------ Tue Oct 19 10:23:54 2004 | 1 Sun Dec 19 10:23:54 2004 | 2 --main table should now be empty select * from only test_schema.test_migrate; time | temp ------+------ select * from only _timescaledb_internal._hyper_10_9_chunk; time | temp --------------------------+------ Tue Oct 19 10:23:54 2004 | 1 select * from only _timescaledb_internal._hyper_10_10_chunk; time | temp --------------------------+------ Sun Dec 19 10:23:54 2004 | 2 create table test_schema.test_migrate_empty(time timestamp, temp float); select create_hypertable('test_schema.test_migrate_empty', 'time', migrate_data => true); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------------- (11,test_schema,test_migrate_empty,t) CREATE TYPE test_type AS (time timestamp, temp float); CREATE TABLE test_table_of_type OF test_type; SELECT create_hypertable('test_table_of_type', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------------- (12,public,test_table_of_type,t) INSERT INTO test_table_of_type VALUES ('2004-10-19 10:23:54+02', 1.0), ('2004-12-19 10:23:54+02', 2.0); \set ON_ERROR_STOP 0 DROP TYPE test_type; ERROR: cannot drop type test_type because other objects depend on it \set ON_ERROR_STOP 1 DROP TYPE test_type CASCADE; NOTICE: drop cascades to 3 other objects CREATE TABLE test_table_of_type (time timestamp, temp float); SELECT create_hypertable('test_table_of_type', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------------- (13,public,test_table_of_type,t) INSERT INTO test_table_of_type VALUES ('2004-10-19 10:23:54+02', 1.0), ('2004-12-19 10:23:54+02', 2.0); CREATE TYPE test_type AS (time timestamp, temp float); ALTER TABLE test_table_of_type OF test_type; \set ON_ERROR_STOP 0 DROP TYPE test_type; ERROR: cannot drop type test_type because other objects depend on it \set ON_ERROR_STOP 1 BEGIN; DROP TYPE test_type CASCADE; NOTICE: drop cascades to 3 other objects ROLLBACK; ALTER TABLE test_table_of_type NOT OF; DROP TYPE test_type; -- Reset GRANTS \c :TEST_DBNAME :ROLE_SUPERUSER REVOKE :ROLE_DEFAULT_PERM_USER FROM :ROLE_DEFAULT_PERM_USER_2; -- Test custom partitioning functions CREATE OR REPLACE FUNCTION partfunc_not_immutable(source anyelement) RETURNS INTEGER LANGUAGE PLPGSQL AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_bad_return_type(source anyelement) RETURNS BIGINT LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_bad_arg_type(source text) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_bad_multi_arg(source anyelement, extra_arg integer) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_valid(source anyelement) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; create table test_schema.test_partfunc(time timestamptz, temp float, device int); -- Test that create_hypertable fails due to invalid partitioning function \set ON_ERROR_STOP 0 select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_not_immutable'); ERROR: invalid partitioning function select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_bad_return_type'); ERROR: invalid partitioning function select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_bad_arg_type'); ERROR: invalid partitioning function select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_bad_multi_arg'); ERROR: invalid partitioning function \set ON_ERROR_STOP 1 -- Test that add_dimension fails due to invalid partitioning function select create_hypertable('test_schema.test_partfunc', 'time'); create_hypertable ---------------------------------- (14,test_schema,test_partfunc,t) \set ON_ERROR_STOP 0 select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_not_immutable'); ERROR: invalid partitioning function select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_bad_return_type'); ERROR: invalid partitioning function select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_bad_arg_type'); ERROR: invalid partitioning function select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_bad_multi_arg'); ERROR: invalid partitioning function \set ON_ERROR_STOP 1 -- A valid function should work: select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_valid'); add_dimension ----------------------------------------- (26,test_schema,test_partfunc,device,t) -- check get_create_command produces valid command CREATE TABLE test_schema.test_sql_cmd(time TIMESTAMPTZ, temp FLOAT8, device_id TEXT, device_type TEXT, location TEXT, id INT, id2 INT); SELECT create_hypertable('test_schema.test_sql_cmd','time'); create_hypertable --------------------------------- (15,test_schema,test_sql_cmd,t) SELECT * FROM _timescaledb_functions.get_create_command('test_sql_cmd'); get_create_command ----------------------------------------------------------------------------------------------------------------------------------- SELECT create_hypertable('test_schema.test_sql_cmd', 'time', chunk_time_interval => 604800000000, create_default_indexes=>FALSE); SELECT _timescaledb_functions.get_create_command('test_sql_cmd') AS create_cmd; \gset create_cmd ----------------------------------------------------------------------------------------------------------------------------------- SELECT create_hypertable('test_schema.test_sql_cmd', 'time', chunk_time_interval => 604800000000, create_default_indexes=>FALSE); DROP TABLE test_schema.test_sql_cmd CASCADE; CREATE TABLE test_schema.test_sql_cmd(time TIMESTAMPTZ, temp FLOAT8, device_id TEXT, device_type TEXT, location TEXT, id INT, id2 INT); SELECT test.execute_sql(:'create_cmd'); execute_sql ----------------------------------------------------------------------------------------------------------------------------------- SELECT create_hypertable('test_schema.test_sql_cmd', 'time', chunk_time_interval => 604800000000, create_default_indexes=>FALSE); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_table_int(time bigint, junk int); SELECT hypertable_id AS "TEST_TABLE_INT_HYPERTABLE_ID" FROM create_hypertable('test_table_int', 'time', chunk_time_interval => 1) \gset \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_schema; create or replace function my_schema.dummy_now2() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; grant execute on ALL FUNCTIONS IN SCHEMA my_schema to public; create or replace function dummy_now3() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; grant execute on ALL FUNCTIONS IN SCHEMA my_schema to public; REVOKE execute ON function dummy_now3() FROM PUBLIC; CREATE SCHEMA IF NOT EXISTS my_user_schema; GRANT ALL ON SCHEMA my_user_schema to PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER create or replace function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; create or replace function my_user_schema.dummy_now4() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; select set_integer_now_func('test_table_int', 'dummy_now'); set_integer_now_func ---------------------- select * from _timescaledb_catalog.dimension WHERE hypertable_id = :TEST_TABLE_INT_HYPERTABLE_ID; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 29 | 17 | time | bigint | t | | | | 1 | | public | dummy_now -- show chunks works with "created_before" and errors out with time used in "older_than" SELECT SHOW_CHUNKS('test_table_int', older_than => 10); show_chunks ------------- SELECT SHOW_CHUNKS('test_table_int', created_before => now()); show_chunks ------------- \set ON_ERROR_STOP 0 SELECT SHOW_CHUNKS('test_table_int', older_than => now()); ERROR: invalid time argument type "timestamp with time zone" select set_integer_now_func('test_table_int', 'dummy_now'); ERROR: custom time function already set for hypertable "test_table_int" select set_integer_now_func('test_table_int', 'my_schema.dummy_now2', replace_if_exists => TRUE); ERROR: permission denied for schema my_schema at character 47 select set_integer_now_func('test_table_int', 'dummy_now3', replace_if_exists => TRUE); ERROR: permission denied for function dummy_now3 -- test invalid oid as the integer_now_func select set_integer_now_func('test_table_int', 1, replace_if_exists => TRUE); ERROR: cache lookup failed for function 1 \set ON_ERROR_STOP select set_integer_now_func('test_table_int', 'my_user_schema.dummy_now4', replace_if_exists => TRUE); set_integer_now_func ---------------------- \c :TEST_DBNAME :ROLE_SUPERUSER ALTER SCHEMA my_user_schema RENAME TO my_new_schema; select * from _timescaledb_catalog.dimension WHERE hypertable_id = :TEST_TABLE_INT_HYPERTABLE_ID; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 29 | 17 | time | bigint | t | | | | 1 | | my_new_schema | dummy_now4 -- github issue #4650 CREATE TABLE sample_table ( cpu double precision null, time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, name varchar(100) default 'this is a default string value', UNIQUE(sensor_id, time) ); ALTER TABLE sample_table DROP COLUMN name; -- below creation should not report any warnings. SELECT * FROM create_hypertable('sample_table', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 18 | public | sample_table | t -- cleanup DROP TABLE sample_table CASCADE; -- github issue 4684 -- test PARTITION BY HASH CREATE TABLE regular( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_regular_pky PRIMARY KEY (id) ) PARTITION BY HASH (id); DO $$ BEGIN FOR i IN 1..2 LOOP EXECUTE format(' CREATE TABLE %I PARTITION OF regular FOR VALUES WITH (MODULUS 2, REMAINDER %s)', 'regular_' || i, i - 1 ); END LOOP; END; $$; INSERT INTO regular SELECT generate_series(1,1000), 44,55; CREATE TABLE timescale ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES regular(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'timescale', time_column_name => 'ts' ); create_hypertable ------------------------- (19,public,timescale,t) -- creates chunk1 INSERT INTO timescale SELECT now(), generate_series(1,200), 43; -- creates chunk2 INSERT INTO timescale SELECT now() + interval '20' day, generate_series(1,200), 43; -- creates chunk3 INSERT INTO timescale SELECT now() + interval '40' day, generate_series(1,200), 43; -- show chunks SELECT SHOW_CHUNKS('timescale'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_19_15_chunk _timescaledb_internal._hyper_19_16_chunk _timescaledb_internal._hyper_19_17_chunk \set ON_ERROR_STOP 0 -- record goes into chunk1 violating FK constraint as value 1001 is not present in regular table INSERT INTO timescale SELECT now(), 1001, 43; ERROR: insert or update on table "_hyper_19_15_chunk" violates foreign key constraint "15_1_timescale_id_fkey" -- record goes into chunk2 violating FK constraint as value 1002 is not present in regular table INSERT INTO timescale SELECT now() + interval '20' day, 1002, 43; ERROR: insert or update on table "_hyper_19_16_chunk" violates foreign key constraint "16_2_timescale_id_fkey" -- record goes into chunk3 violating FK constraint as value 1003 is not present in regular table INSERT INTO timescale SELECT now() + interval '40' day, 1003, 43; ERROR: insert or update on table "_hyper_19_17_chunk" violates foreign key constraint "17_3_timescale_id_fkey" \set ON_ERROR_STOP 1 -- cleanup DROP TABLE regular cascade; NOTICE: drop cascades to 4 other objects DROP TABLE timescale cascade; -- test PARTITION BY RANGE CREATE TABLE regular( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_regular_pky PRIMARY KEY (id) ) PARTITION BY RANGE (id); CREATE TABLE regular_1_500 PARTITION OF regular FOR VALUES FROM (1) TO (500); CREATE TABLE regular_500_1000 PARTITION OF regular FOR VALUES FROM (500) TO (801); INSERT INTO regular SELECT generate_series(1,800), 44,55; CREATE TABLE timescale ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES regular(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'timescale', time_column_name => 'ts' ); create_hypertable ------------------------- (20,public,timescale,t) -- creates chunk1 INSERT INTO timescale SELECT now(), generate_series(1,200), 43; -- creates chunk2 INSERT INTO timescale SELECT now() + interval '20' day, generate_series(200,400), 43; -- creates chunk3 INSERT INTO timescale SELECT now() + interval '40' day, generate_series(400,600), 43; -- show chunks SELECT SHOW_CHUNKS('timescale'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_20_18_chunk _timescaledb_internal._hyper_20_19_chunk _timescaledb_internal._hyper_20_20_chunk \set ON_ERROR_STOP 0 -- FK constraint violation as value 801 is not present in regular table INSERT INTO timescale SELECT now(), 801, 43; ERROR: insert or update on table "_hyper_20_18_chunk" violates foreign key constraint "18_4_timescale_id_fkey" -- FK constraint violation as value 902 is not present in regular table INSERT INTO timescale SELECT now() + interval '20' day, 902, 43; ERROR: insert or update on table "_hyper_20_19_chunk" violates foreign key constraint "19_5_timescale_id_fkey" -- FK constraint violation as value 1003 is not present in regular table INSERT INTO timescale SELECT now() + interval '40' day, 1003, 43; ERROR: insert or update on table "_hyper_20_20_chunk" violates foreign key constraint "20_6_timescale_id_fkey" \set ON_ERROR_STOP 1 -- cleanup DROP TABLE regular cascade; NOTICE: drop cascades to 4 other objects DROP TABLE timescale cascade; -- test PARTITION BY LIST CREATE TABLE regular( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_regular_pky PRIMARY KEY (id) ) PARTITION BY LIST (id); CREATE TABLE regular_1_2_3_4 PARTITION OF regular FOR VALUES IN (1,2,3,4); CREATE TABLE regular_5_6_7_8 PARTITION OF regular FOR VALUES IN (5,6,7,8); INSERT INTO regular SELECT generate_series(1,8), 44,55; CREATE TABLE timescale ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES regular(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'timescale', time_column_name => 'ts' ); create_hypertable ------------------------- (21,public,timescale,t) insert into timescale values (now(), 1,2); insert into timescale values (now(), 2,2); insert into timescale values (now(), 3,2); insert into timescale values (now(), 4,2); insert into timescale values (now(), 5,2); insert into timescale values (now(), 6,2); insert into timescale values (now(), 7,2); insert into timescale values (now(), 8,2); \set ON_ERROR_STOP 0 -- FK constraint violation as value 9 is not present in regular table insert into timescale values (now(), 9,2); ERROR: insert or update on table "_hyper_21_21_chunk" violates foreign key constraint "21_7_timescale_id_fkey" -- FK constraint violation as value 10 is not present in regular table insert into timescale values (now(), 10,2); ERROR: insert or update on table "_hyper_21_21_chunk" violates foreign key constraint "21_7_timescale_id_fkey" -- FK constraint violation as value 111 is not present in regular table insert into timescale values (now(), 111,2); ERROR: insert or update on table "_hyper_21_21_chunk" violates foreign key constraint "21_7_timescale_id_fkey" \set ON_ERROR_STOP 1 -- cleanup DROP TABLE regular cascade; NOTICE: drop cascades to 2 other objects DROP TABLE timescale cascade; -- github issue 4872 -- If subplan of ChunkAppend is TidRangeScan, then SELECT on -- hypertable fails with error "invalid child of chunk append: Node (26)" create table tidrangescan_test ( time timestamp with time zone, some_column bigint ); select create_hypertable('tidrangescan_test', 'time'); create_hypertable --------------------------------- (22,public,tidrangescan_test,t) insert into tidrangescan_test (time, some_column) values ('2023-02-12 00:00:00+02:40', 1); insert into tidrangescan_test (time, some_column) values ('2023-02-12 00:00:10+02:40', 2); insert into tidrangescan_test (time, some_column) values ('2023-02-12 00:00:20+02:40', 3); -- Below query will generate plan as -- Custom Scan (ChunkAppend) -- -> Tid Range Scan -- However when traversing ChunkAppend node, Tid Range Scan node is not -- recognised as a valid child node of ChunkAppend which causes error -- "invalid child of chunk append: Node (26)" when below query is executed select * from tidrangescan_test where time > '2023-02-12 00:00:00+02:40'::timestamp with time zone - interval '5 years' and ctid < '(1,1)'::tid ORDER BY time; time | some_column ------------------------------+------------- Sat Feb 11 13:20:00 2023 PST | 1 Sat Feb 11 13:20:10 2023 PST | 2 Sat Feb 11 13:20:20 2023 PST | 3 drop table tidrangescan_test; \set VERBOSITY default set client_min_messages = WARNING; -- test creating a hypertable from table referenced by a foreign key fails with -- error "cannot have FOREIGN KEY constraints to hypertable". create table test_schema.fk_parent(time timestamptz, id int, unique(time, id)); create table test_schema.fk_child( time timestamptz, id int, foreign key (time, id) references test_schema.fk_parent(time, id) ); select create_hypertable ('test_schema.fk_child', 'time'); create_hypertable ----------------------------- (23,test_schema,fk_child,t) \set ON_ERROR_STOP 0 select create_hypertable ('test_schema.fk_parent', 'time'); ERROR: cannot have FOREIGN KEY constraints to hypertable "fk_parent" HINT: Remove all FOREIGN KEY constraints to table "fk_parent" before making it a hypertable. \set ON_ERROR_STOP 1 -- create default indexes on chunks when migrating data CREATE TABLE test(time TIMESTAMPTZ, val BIGINT); CREATE INDEX test_val_idx ON test(val); INSERT INTO test VALUES('2024-01-01 00:00:00-03', 500); SELECT FROM create_hypertable('test', 'time', migrate_data=>TRUE); -- -- should return ALL indexes for hypertable and chunk SELECT * FROM test.show_indexes('test') ORDER BY 1; Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------+---------+------+--------+---------+-----------+------------ test_val_idx | {val} | | f | f | f | test_time_idx | {time} | | f | f | f | SELECT * FROM show_chunks('test') ch, LATERAL test.show_indexes(ch) ORDER BY 1, 2; ch | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------+--------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_24_23_chunk | _timescaledb_internal._hyper_24_23_chunk_test_val_idx | {val} | | f | f | f | _timescaledb_internal._hyper_24_23_chunk | _timescaledb_internal._hyper_24_23_chunk_test_time_idx | {time} | | f | f | f | DROP TABLE test; -- don't create default indexes on chunks when migrating data CREATE TABLE test(time TIMESTAMPTZ, val BIGINT); CREATE INDEX test_val_idx ON test(val); INSERT INTO test VALUES('2024-01-01 00:00:00-03', 500); SELECT FROM create_hypertable('test', 'time', create_default_indexes => FALSE, migrate_data=>TRUE); -- -- should NOT return default indexes for hypertable and chunk -- only user indexes should be returned SELECT * FROM test.show_indexes('test') ORDER BY 1; Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------+---------+------+--------+---------+-----------+------------ test_val_idx | {val} | | f | f | f | SELECT * FROM show_chunks('test') ch, LATERAL test.show_indexes(ch) ORDER BY 1, 2; ch | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------+-------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_25_24_chunk | _timescaledb_internal._hyper_25_24_chunk_test_val_idx | {val} | | f | f | f | DROP TABLE test; -- test creating a hypertable with a primary key where the partitioning column is not part of the primary key CREATE TABLE test_schema.partition_not_pk (id INT NOT NULL, device_id INT NOT NULL, time TIMESTAMPTZ NOT NULL, a TEXT NOT NULL, PRIMARY KEY (id)); \set ON_ERROR_STOP 0 select create_hypertable ('test_schema.partition_not_pk', 'time'); ERROR: cannot create a unique index without the column "time" (used in partitioning) HINT: If you're creating a hypertable on a table with a primary key, ensure the partitioning column is part of the primary or composite key. \set ON_ERROR_STOP 1 DROP TABLE test_schema.partition_not_pk; -- test creating a hypertable with a composite key where the partitioning column is not part of the composite key CREATE TABLE test_schema.partition_not_pk (id INT NOT NULL, device_id INT NOT NULL, time TIMESTAMPTZ NOT NULL, a TEXT NOT NULL, PRIMARY KEY (id, device_id)); \set ON_ERROR_STOP 0 select create_hypertable ('test_schema.partition_not_pk', 'time'); ERROR: cannot create a unique index without the column "time" (used in partitioning) HINT: If you're creating a hypertable on a table with a primary key, ensure the partitioning column is part of the primary or composite key. \set ON_ERROR_STOP 1 DROP TABLE test_schema.partition_not_pk; -- test hypertable is not created for a table that is a part of a publication explicitly SET client_min_messages = ERROR; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); CREATE PUBLICATION publication_test; ALTER PUBLICATION publication_test ADD TABLE test; \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); ERROR: cannot create hypertable for table "test" because it is part of a publication \set ON_ERROR_STOP 1 INSERT INTO test (timestamp) values (now()); ALTER PUBLICATION publication_test DROP TABLE test; DROP PUBLICATION publication_test; DROP TABLE test; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); CREATE PUBLICATION publication_test1; CREATE PUBLICATION publication_test2; ALTER PUBLICATION publication_test1 ADD TABLE test; ALTER PUBLICATION publication_test2 ADD TABLE test; \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); ERROR: cannot create hypertable for table "test" because it is part of a publication \set ON_ERROR_STOP 1 INSERT INTO test (timestamp) values (now()); ALTER PUBLICATION publication_test1 DROP TABLE test; ALTER PUBLICATION publication_test2 DROP TABLE test; DROP PUBLICATION publication_test1; DROP PUBLICATION publication_test2; DROP TABLE test; -- test hypertable is not created for a table that is a part of a publication implicitly CREATE PUBLICATION publication_test FOR ALL tables; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); ERROR: cannot create hypertable for table "test" because it is part of a publication \set ON_ERROR_STOP 1 DROP PUBLICATION publication_test; DROP TABLE test; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); CREATE PUBLICATION publication_test FOR ALL tables; \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); ERROR: cannot create hypertable for table "test" because it is part of a publication \set ON_ERROR_STOP 1 DROP PUBLICATION publication_test; DROP TABLE test; RESET client_min_messages; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/create_table.out���������������������������������������������������0000664�0000000�0000000�00000003572�15100345067�0022005�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that we can verify constraints on regular tables CREATE TABLE test_hyper_pk(time TIMESTAMPTZ PRIMARY KEY, temp FLOAT, device INT); CREATE TABLE test_pk(device INT PRIMARY KEY); CREATE TABLE test_like(LIKE test_pk); SELECT create_hypertable('test_hyper_pk', 'time'); create_hypertable ---------------------------- (1,public,test_hyper_pk,t) \set ON_ERROR_STOP 0 -- Foreign key constraints that reference hypertables are currently unsupported CREATE TABLE test_fk(time TIMESTAMPTZ REFERENCES test_hyper_pk(time)); \set ON_ERROR_STOP 1 CREATE TABLE test_delete(time timestamp with time zone PRIMARY KEY, temp float); SELECT create_hypertable('test_delete', 'time'); create_hypertable -------------------------- (2,public,test_delete,t) INSERT INTO test_delete VALUES('2017-01-20T09:00:01', 22.5); INSERT INTO test_delete VALUES('2017-01-20T09:00:21', 21.2); INSERT INTO test_delete VALUES('2017-01-20T09:00:47', 25.1); INSERT INTO test_delete VALUES('2020-01-20T09:00:47', 25.1); INSERT INTO test_delete VALUES('2021-01-20T09:00:47', 25.1); SELECT * FROM test_delete WHERE temp = 25.1 ORDER BY time; time | temp ------------------------------+------ Fri Jan 20 09:00:47 2017 PST | 25.1 Mon Jan 20 09:00:47 2020 PST | 25.1 Wed Jan 20 09:00:47 2021 PST | 25.1 CREATE OR replace FUNCTION test_delete_row_count() RETURNS void AS $$ DECLARE v_cnt numeric; BEGIN v_cnt := 0; DELETE FROM test_delete WHERE temp = 25.1; GET DIAGNOSTICS v_cnt = ROW_COUNT; IF v_cnt != 3 THEN RAISE EXCEPTION 'unexpected result'; END IF; END; $$ LANGUAGE plpgsql; SELECT test_delete_row_count(); test_delete_row_count ----------------------- ��������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/create_table_with.out����������������������������������������������0000664�0000000�0000000�00000034261�15100345067�0023037�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- our user needs permission to create schema for the schema tests \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :TEST_DBNAME TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- create table with non-tsdb option should not be affected CREATE TABLE t1(time timestamptz, device text, value float) WITH (autovacuum_enabled); DROP TABLE t1; -- test error cases \set ON_ERROR_STOP 0 \set VERBOSITY default CREATE TABLE t2(time float, device text, value float) WITH (tsdb.hypertable); ERROR: partition column could not be determined HINT: Use "timescaledb.partition_column" to specify the column to use as partitioning column. CREATE TABLE t2(time float, device text, value float) WITH (timescaledb.hypertable); ERROR: partition column could not be determined HINT: Use "timescaledb.partition_column" to specify the column to use as partitioning column. CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=NULL); ERROR: column "null" does not exist CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=''); ERROR: column "" does not exist CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='foo'); ERROR: column "foo" does not exist CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.partition_column='time'); ERROR: timescaledb options requires hypertable option HINT: Use "timescaledb.hypertable" to enable creating a hypertable. CREATE TABLE t2(time timestamptz, device text, value float) WITH (timescaledb.partition_column='time'); ERROR: timescaledb options requires hypertable option HINT: Use "timescaledb.hypertable" to enable creating a hypertable. CREATE TABLE t2(time timestamptz , device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='foo'); ERROR: invalid input syntax for type interval: "foo" CREATE TABLE t2(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); ERROR: invalid input syntax for type smallint: "3 months" CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes='time'); ERROR: invalid value for tsdb.create_default_indexes 'time' HINT: tsdb.create_default_indexes must be a valid bool CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=2); ERROR: invalid value for tsdb.create_default_indexes '2' HINT: tsdb.create_default_indexes must be a valid bool CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=-1); ERROR: invalid value for tsdb.create_default_indexes '-1' HINT: tsdb.create_default_indexes must be a valid bool CREATE TABLE t2(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=true); ERROR: functionality not supported under the current "apache" license. Learn more at https://tsdb.co/pdbir1r3 HINT: To access all features and the best time-series experience, try out Timescale Cloud. CREATE TABLE t2(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore,tsdb.hypertable,tsdb.partition_column='time'); ERROR: functionality not supported under the current "apache" license. Learn more at https://tsdb.co/pdbir1r3 HINT: To access all features and the best time-series experience, try out Timescale Cloud. -- Test error hint for invalid timescaledb options during CREATE TABLE CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.invalid_option = true); ERROR: unrecognized parameter "tsdb.invalid_option" HINT: Valid timescaledb parameters are: hypertable, columnstore, partition_column, chunk_interval, create_default_indexes, associated_schema, associated_table_prefix, orderby, segmentby, compress_index CREATE TABLE t2(time timestamptz, device text, value float) WITH (timescaledb.nonexistent_param = false); ERROR: unrecognized parameter "timescaledb.nonexistent_param" HINT: Valid timescaledb parameters are: hypertable, columnstore, partition_column, chunk_interval, create_default_indexes, associated_schema, associated_table_prefix, orderby, segmentby, compress_index \set ON_ERROR_STOP 1 \set VERBOSITY terse BEGIN; CREATE TABLE t3(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE t4(time timestamp, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,timescaledb.partition_column='time'); CREATE TABLE t5(time date, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',autovacuum_enabled); CREATE TABLE t6(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,timescaledb.hypertable,tsdb.partition_column='time'); CREATE TABLE t7(time timestamptz, device text, value float) WITH (timescaledb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; hypertable_name ----------------- t3 t4 t5 t6 t7 ROLLBACK; -- IF NOT EXISTS BEGIN; CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); NOTICE: relation "t7" already exists, skipping CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float); NOTICE: relation "t7" already exists, skipping SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; hypertable_name ----------------- t7 ROLLBACK; -- table won't be converted to hypertable unless it is in the initial CREATE TABLE BEGIN; CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); NOTICE: relation "t8" already exists, skipping CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); NOTICE: relation "t8" already exists, skipping SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; hypertable_name ----------------- ROLLBACK; -- chunk_interval BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='8weeks'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | time_interval -----------------+-------------+--------------------------+--------------- t9 | time | timestamp with time zone | @ 56 days ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamp NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='23 days'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | time_interval -----------------+-------------+-----------------------------+--------------- t9 | time | timestamp without time zone | @ 23 days ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time date NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | time_interval -----------------+-------------+-------------+--------------- t9 | time | date | @ 90 days ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int2 NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=12); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | integer_interval -----------------+-------------+-------------+------------------ t9 | time | smallint | 12 ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int4 NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=3453); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | integer_interval -----------------+-------------+-------------+------------------ t9 | time | integer | 3453 ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int8 NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=32768); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | integer_interval -----------------+-------------+-------------+------------------ t9 | time | bigint | 32768 ROLLBACK; -- create_default_indexes BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid -------------- t10_time_idx ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL PRIMARY KEY, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid ------------ t10_pkey ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL UNIQUE, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid -------------- t10_time_key ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=true); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid -------------- t10_time_idx ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=false); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid ------------ ROLLBACK; -- associated_schema BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; associated_schema_name ------------------------ _timescaledb_internal ROLLBACK; BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; associated_schema_name ------------------------ abc INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; relname -------------------------------- _hyper_21_1_chunk _hyper_21_1_chunk_t11_time_idx ROLLBACK; BEGIN; CREATE SCHEMA abc2; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc2'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; associated_schema_name ------------------------ abc2 INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc2'::regnamespace ORDER BY 1; relname -------------------------------- _hyper_22_2_chunk _hyper_22_2_chunk_t11_time_idx ROLLBACK; -- associated_table_prefix BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; associated_table_prefix ------------------------- _hyper_23 ROLLBACK; BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc', tsdb.associated_table_prefix='tbl_prefix'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; associated_table_prefix ------------------------- tbl_prefix INSERT INTO t12 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; relname --------------------------------- tbl_prefix_3_chunk tbl_prefix_3_chunk_t12_time_idx ROLLBACK; -- default partition column BEGIN; CREATE TABLE t13(time timestamptz, device text, value float) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column CREATE TABLE t14("TiMe" timestamptz, device text, value float) WITH (tsdb.hypertable); NOTICE: using column "TiMe" as partitioning column SELECT hypertable_name, column_name FROM timescaledb_information.dimensions WHERE hypertable_name IN ('t13','t14') ORDER BY 1; hypertable_name | column_name -----------------+------------- t13 | time t14 | TiMe ROLLBACK; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/cursor.out���������������������������������������������������������0000664�0000000�0000000�00000003710�15100345067�0020702�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE cursor_test(time timestamptz, device_id int, temp float); SELECT create_hypertable('cursor_test','time'); create_hypertable -------------------------- (1,public,cursor_test,t) INSERT INTO cursor_test SELECT '2000-01-01',1,0.5; INSERT INTO cursor_test SELECT '2001-01-01',1,0.5; INSERT INTO cursor_test SELECT '2002-01-01',1,0.5; \set ON_ERROR_STOP 0 BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test; FETCH NEXT FROM c1; time | device_id | temp ------------------------------+-----------+------ Sat Jan 01 00:00:00 2000 PST | 1 | 0.5 -- this will produce an error on PG < 14 because PostgreSQL checks -- for the existence of a scan node with the relation id for every relation -- used in the update plan in the plan of the cursor. UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; COMMIT; -- test cursor with no chunks left after runtime exclusion BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test WHERE time > now(); UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; ERROR: cursor "c1" is not a simply updatable scan of table "_hyper_1_1_chunk" COMMIT; -- test cursor with no chunks left after planning exclusion BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test WHERE time > '2010-01-01'; UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; ERROR: cursor "c1" is not a simply updatable scan of table "_hyper_1_1_chunk" COMMIT; \set ON_ERROR_STOP 1 SET timescaledb.enable_constraint_exclusion TO off; BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test; FETCH NEXT FROM c1; time | device_id | temp ------------------------------+-----------+------ Sat Jan 01 00:00:00 2000 PST | 1 | 0.7 UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; COMMIT; ��������������������������������������������������������timescaledb-2.23.0/test/expected/custom_type.out����������������������������������������������������0000664�0000000�0000000�00000006357�15100345067�0021752�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages TO WARNING; CREATE OR REPLACE FUNCTION customtype_in(cstring) RETURNS customtype AS 'timestamptz_in' LANGUAGE internal IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_out(customtype) RETURNS cstring AS 'timestamptz_out' LANGUAGE internal IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_recv(internal) RETURNS customtype AS 'timestamptz_recv' LANGUAGE internal IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_send(customtype) RETURNS bytea AS 'timestamptz_send' LANGUAGE internal IMMUTABLE STRICT; SET client_min_messages TO DEFAULT; CREATE TYPE customtype ( INPUT = customtype_in, OUTPUT = customtype_out, RECEIVE = customtype_recv, SEND = customtype_send, LIKE = TIMESTAMPTZ ); CREATE CAST (customtype AS bigint) WITHOUT FUNCTION AS ASSIGNMENT; CREATE CAST (bigint AS customtype) WITHOUT FUNCTION AS IMPLICIT; CREATE CAST (customtype AS timestamptz) WITHOUT FUNCTION AS ASSIGNMENT; CREATE CAST (timestamptz AS customtype) WITHOUT FUNCTION AS ASSIGNMENT; CREATE OR REPLACE FUNCTION customtype_lt(customtype, customtype) RETURNS bool AS 'timestamp_lt' LANGUAGE internal IMMUTABLE STRICT; CREATE OPERATOR < ( LEFTARG = customtype, RIGHTARG = customtype, PROCEDURE = customtype_lt, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OR REPLACE FUNCTION customtype_ge(customtype, customtype) RETURNS bool AS 'timestamp_ge' LANGUAGE internal IMMUTABLE STRICT; CREATE OPERATOR >= ( LEFTARG = customtype, RIGHTARG = customtype, PROCEDURE = customtype_ge, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE customtype_test(time_custom customtype, val int); \set ON_ERROR_STOP 0 -- Using interval type for chunk time interval should fail with custom time type SELECT create_hypertable('customtype_test', 'time_custom', chunk_time_interval => INTERVAL '1 day', create_default_indexes=>false); ERROR: invalid interval type for customtype dimension \set ON_ERROR_STOP 1 SELECT create_hypertable('customtype_test', 'time_custom', chunk_time_interval => 10e6::bigint, create_default_indexes=>false); create_hypertable ------------------------------ (1,public,customtype_test,t) INSERT INTO customtype_test VALUES ('2001-01-01 01:02:03'::customtype, 10); INSERT INTO customtype_test VALUES ('2001-01-01 01:02:03'::customtype, 10); INSERT INTO customtype_test VALUES ('2001-01-01 01:02:03'::customtype, 10); EXPLAIN (buffers off, costs off) SELECT * FROM customtype_test; --- QUERY PLAN --- Seq Scan on _hyper_1_1_chunk INSERT INTO customtype_test VALUES ('2001-01-01 01:02:23'::customtype, 11); EXPLAIN (buffers off, costs off) SELECT * FROM customtype_test; --- QUERY PLAN --- Append -> Seq Scan on _hyper_1_1_chunk -> Seq Scan on _hyper_1_2_chunk SELECT * FROM customtype_test; time_custom | val ------------------------------+----- Mon Jan 01 01:02:03 2001 PST | 10 Mon Jan 01 01:02:03 2001 PST | 10 Mon Jan 01 01:02:03 2001 PST | 10 Mon Jan 01 01:02:23 2001 PST | 11 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/ddl.out������������������������������������������������������������0000664�0000000�0000000�00000103057�15100345067�0020135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS "customSchema" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \ir include/ddl_ops_1.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1, humidity numeric NULL DEFAULT 0, sensor_1 NUMERIC NULL DEFAULT 1, sensor_2 NUMERIC NOT NULL DEFAULT 1, sensor_3 NUMERIC NOT NULL DEFAULT 1, sensor_4 NUMERIC NOT NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1" (time, "Device_id"); CREATE TABLE "customSchema"."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1, humidity numeric NULL DEFAULT 0, sensor_1 NUMERIC NULL DEFAULT 1, sensor_2 NUMERIC NOT NULL DEFAULT 1, sensor_3 NUMERIC NOT NULL DEFAULT 1, sensor_4 NUMERIC NOT NULL DEFAULT 1 ); CREATE INDEX ON "customSchema"."Hypertable_1" (time, "Device_id"); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | Hypertable_1 | t SELECT * FROM create_hypertable('"customSchema"."Hypertable_1"', 'time', NULL, 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+--------------+--------------+--------- 2 | customSchema | Hypertable_1 | t SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+--------------+--------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | Hypertable_1 | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | customSchema | Hypertable_1 | _timescaledb_internal | _hyper_2 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 CREATE INDEX ON PUBLIC."Hypertable_1" (time, "temp_c"); CREATE INDEX "ind_humidity" ON PUBLIC."Hypertable_1" (time, "humidity"); CREATE INDEX "ind_sensor_1" ON PUBLIC."Hypertable_1" (time, "sensor_1"); INSERT INTO PUBLIC."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 30, 70, 1, 2, 3, 100); CREATE UNIQUE INDEX "Unique1" ON PUBLIC."Hypertable_1" (time, "Device_id"); CREATE UNIQUE INDEX "Unique1" ON "customSchema"."Hypertable_1" (time); INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 30, 70, 1, 2, 3, 100); INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000001, 'dev1', 30, 70, 1, 2, 3, 100); SELECT * FROM test.show_indexesp('%.%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------------------------------+--------------------------------------------------+------------------+------+--------+---------+-----------+------------ "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_idx" | {time} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Unique1" | {time} | | t | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper_%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_Device_id_time_idx" | {Device_id,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_time_temp_c_idx" | {time,temp_c} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_ind_humidity | {time,humidity} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_ind_sensor_1 | {time,sensor_1} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Unique1" | {time,Device_id} | | t | f | f | _timescaledb_internal._hyper_2_2_chunk | _timescaledb_internal."_hyper_2_2_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_2_2_chunk | _timescaledb_internal."_hyper_2_2_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_2_2_chunk | _timescaledb_internal."_hyper_2_2_chunk_Unique1" | {time} | | t | f | f | --expect error cases \set ON_ERROR_STOP 0 INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 31, 71, 72, 4, 1, 102); psql:include/ddl_ops_1.sql:57: ERROR: duplicate key value violates unique constraint "_hyper_2_2_chunk_Unique1" CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" ("Device_id"); psql:include/ddl_ops_1.sql:58: ERROR: cannot create a unique index without the column "time" (used in partitioning) CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" (time); psql:include/ddl_ops_1.sql:59: ERROR: cannot create a unique index without the column "Device_id" (used in partitioning) CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" (sensor_1); psql:include/ddl_ops_1.sql:60: ERROR: cannot create a unique index without the column "time" (used in partitioning) UPDATE ONLY PUBLIC."Hypertable_1" SET time = 0 WHERE TRUE; DELETE FROM ONLY PUBLIC."Hypertable_1" WHERE "Device_id" = 'dev1'; \set ON_ERROR_STOP 1 CREATE TABLE my_ht (time BIGINT, val integer); SELECT * FROM create_hypertable('my_ht', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 3 | public | my_ht | t ALTER TABLE my_ht ADD COLUMN val2 integer; SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f -- Should error when adding again \set ON_ERROR_STOP 0 ALTER TABLE my_ht ADD COLUMN val2 integer; psql:include/ddl_ops_1.sql:73: ERROR: column "val2" of relation "my_ht" already exists \set ON_ERROR_STOP 1 -- Should create ALTER TABLE my_ht ADD COLUMN IF NOT EXISTS val3 integer; SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f val3 | integer | f -- Should skip and not error ALTER TABLE my_ht ADD COLUMN IF NOT EXISTS val3 integer; psql:include/ddl_ops_1.sql:81: NOTICE: column "val3" of relation "my_ht" already exists, skipping SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f val3 | integer | f -- Should drop ALTER TABLE my_ht DROP COLUMN IF EXISTS val3; SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f -- Should skip and not error ALTER TABLE my_ht DROP COLUMN IF EXISTS val3; psql:include/ddl_ops_1.sql:89: NOTICE: column "val3" of relation "my_ht" does not exist, skipping SELECT * FROM test.show_columns('my_ht'); Column | Type | NotNull --------+---------+--------- time | bigint | t val | integer | f val2 | integer | f --Test default index creation on create_hypertable(). --Make sure that we do not duplicate indexes that already exists -- --No existing indexes: both time and space-time indexes created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 4 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Device_id_Time_idx" | {Device_id,Time} | | f | f | f | "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --Space index exists: only time index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1_with_default_index_enabled" ("Device_id", "Time" DESC); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 5 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Device_id_Time_idx" | {Device_id,Time} | | f | f | f | "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --Time index exists, only partition index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1_with_default_index_enabled" ("Time" DESC); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 6 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Device_id_Time_idx" | {Device_id,Time} | | f | f | f | "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --No space partitioning, only time index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 7 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------------------+---------+------+--------+---------+-----------+------------ "Hypertable_1_with_default_index_enabled_Time_idx" | {Time} | | f | f | f | ROLLBACK; --Disable index creation: no default indexes created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, create_default_indexes=>FALSE, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------------------------+--------- 8 | public | Hypertable_1_with_default_index_enabled | t SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------+---------+------+--------+---------+-----------+------------ ROLLBACK; SELECT * FROM PUBLIC."Hypertable_1"; time | Device_id | temp_c | humidity | sensor_1 | sensor_2 | sensor_3 | sensor_4 ---------------------+-----------+--------+----------+----------+----------+----------+---------- 1257894000000000000 | dev1 | 30 | 70 | 1 | 2 | 3 | 100 SELECT * FROM ONLY PUBLIC."Hypertable_1"; time | Device_id | temp_c | humidity | sensor_1 | sensor_2 | sensor_3 | sensor_4 ------+-----------+--------+----------+----------+----------+----------+---------- EXPLAIN (buffers off, costs off) SELECT * FROM ONLY PUBLIC."Hypertable_1"; --- QUERY PLAN --- Seq Scan on "Hypertable_1" SELECT * FROM test.show_columns('PUBLIC."Hypertable_1"'); Column | Type | NotNull -----------+---------+--------- time | bigint | t Device_id | text | t temp_c | integer | t humidity | numeric | f sensor_1 | numeric | f sensor_2 | numeric | t sensor_3 | numeric | t sensor_4 | numeric | t SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); Column | Type | NotNull -----------+---------+--------- time | bigint | t Device_id | text | t temp_c | integer | t humidity | numeric | f sensor_1 | numeric | f sensor_2 | numeric | t sensor_3 | numeric | t sensor_4 | numeric | t \ir include/ddl_ops_2.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN temp_f INTEGER NOT NULL DEFAULT 31; ALTER TABLE PUBLIC."Hypertable_1" DROP COLUMN temp_c; ALTER TABLE PUBLIC."Hypertable_1" DROP COLUMN sensor_4; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN humidity SET DEFAULT 100; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_1 DROP DEFAULT; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2 SET DEFAULT NULL; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_1 SET NOT NULL; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2 DROP NOT NULL; ALTER TABLE PUBLIC."Hypertable_1" RENAME COLUMN sensor_2 TO sensor_2_renamed; ALTER TABLE PUBLIC."Hypertable_1" RENAME COLUMN sensor_3 TO sensor_3_renamed; DROP INDEX "ind_sensor_1"; CREATE OR REPLACE FUNCTION empty_trigger_func() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN END $BODY$; CREATE TRIGGER test_trigger BEFORE UPDATE OR DELETE ON PUBLIC."Hypertable_1" FOR EACH STATEMENT EXECUTE FUNCTION empty_trigger_func(); ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2_renamed SET DATA TYPE int; ALTER INDEX "ind_humidity" RENAME TO "ind_humdity2"; -- Change should be reflected here SELECT * FROM test.show_indexesp('%.%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------------------------------+--------------------------------------------------+------------------+------+--------+---------+-----------+------------ "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Hypertable_1_time_idx" | {time} | | f | f | f | "customSchema"."Hypertable_1" | "customSchema"."Unique1" | {time} | | t | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------------+------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Hypertable_1_Device_id_time_idx" | {Device_id,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_ind_humdity2 | {time,humidity} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_Unique1" | {time,Device_id} | | t | f | f | _timescaledb_internal._hyper_2_2_chunk | _timescaledb_internal."_hyper_2_2_chunk_Hypertable_1_time_Device_id_idx" | {time,Device_id} | | f | f | f | _timescaledb_internal._hyper_2_2_chunk | _timescaledb_internal."_hyper_2_2_chunk_Hypertable_1_time_idx" | {time} | | f | f | f | _timescaledb_internal._hyper_2_2_chunk | _timescaledb_internal."_hyper_2_2_chunk_Unique1" | {time} | | t | f | f | --create column with same name as previously renamed one ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN sensor_3 BIGINT NOT NULL DEFAULT 131; --create column with same name as previously dropped one ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN sensor_4 BIGINT NOT NULL DEFAULT 131; SELECT * FROM test.show_columns('PUBLIC."Hypertable_1"'); Column | Type | NotNull ------------------+---------+--------- time | bigint | t Device_id | text | t humidity | numeric | f sensor_1 | numeric | t sensor_2_renamed | integer | f sensor_3_renamed | numeric | t temp_f | integer | t sensor_3 | bigint | t sensor_4 | bigint | t SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); Column | Type | NotNull ------------------+---------+--------- time | bigint | t Device_id | text | t humidity | numeric | f sensor_1 | numeric | t sensor_2_renamed | integer | f sensor_3_renamed | numeric | t temp_f | integer | t sensor_3 | bigint | t sensor_4 | bigint | t SELECT * FROM PUBLIC."Hypertable_1"; time | Device_id | humidity | sensor_1 | sensor_2_renamed | sensor_3_renamed | temp_f | sensor_3 | sensor_4 ---------------------+-----------+----------+----------+------------------+------------------+--------+----------+---------- 1257894000000000000 | dev1 | 70 | 1 | 2 | 3 | 31 | 131 | 131 -- alter column tests CREATE TABLE alter_test(time timestamptz, temp float, color varchar(10)); -- create hypertable with two chunks SELECT create_hypertable('alter_test', 'time', 'color', 2, chunk_time_interval => 2628000000000); WARNING: column type "character varying" used for "color" does not follow best practices create_hypertable ------------------------- (9,public,alter_test,t) INSERT INTO alter_test VALUES ('2017-01-20T09:00:01', 17.5, 'blue'), ('2017-01-21T09:00:01', 19.1, 'yellow'), ('2017-04-20T09:00:01', 89.5, 'green'), ('2017-04-21T09:00:01', 17.1, 'black'); SELECT * FROM test.show_columns('alter_test'); Column | Type | NotNull --------+--------------------------+--------- time | timestamp with time zone | t temp | double precision | f color | character varying | f SELECT * FROM test.show_columnsp('_timescaledb_internal._hyper_9_%chunk'); Relation | Kind | Column | Column type | NotNull ----------------------------------------+------+--------+--------------------------+--------- _timescaledb_internal._hyper_9_3_chunk | r | time | timestamp with time zone | t _timescaledb_internal._hyper_9_3_chunk | r | temp | double precision | f _timescaledb_internal._hyper_9_3_chunk | r | color | character varying | f _timescaledb_internal._hyper_9_4_chunk | r | time | timestamp with time zone | t _timescaledb_internal._hyper_9_4_chunk | r | temp | double precision | f _timescaledb_internal._hyper_9_4_chunk | r | color | character varying | f _timescaledb_internal._hyper_9_5_chunk | r | time | timestamp with time zone | t _timescaledb_internal._hyper_9_5_chunk | r | temp | double precision | f _timescaledb_internal._hyper_9_5_chunk | r | color | character varying | f -- show the column name and type of the partitioning dimension in the -- metadata table SELECT * FROM _timescaledb_catalog.dimension WHERE hypertable_id = 9; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+--------------------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 15 | 9 | color | character varying | f | 2 | _timescaledb_functions | get_partition_hash | | | | 14 | 9 | time | timestamp with time zone | t | | | | 2628000000000 | | | EXPLAIN (buffers off, costs off) SELECT * FROM alter_test WHERE time > '2017-05-20T10:00:01'; --- QUERY PLAN --- Append -> Index Scan using _hyper_9_4_chunk_alter_test_time_idx on _hyper_9_4_chunk Index Cond: ("time" > 'Sat May 20 10:00:01 2017 PDT'::timestamp with time zone) -> Index Scan using _hyper_9_5_chunk_alter_test_time_idx on _hyper_9_5_chunk Index Cond: ("time" > 'Sat May 20 10:00:01 2017 PDT'::timestamp with time zone) -- rename column and change its type ALTER TABLE alter_test RENAME COLUMN time TO time_us; --converting timestamptz->timestamp should happen under UTC SET timezone = 'UTC'; ALTER TABLE alter_test ALTER COLUMN time_us TYPE timestamp; RESET timezone; ALTER TABLE alter_test RENAME COLUMN color TO colorname; \set ON_ERROR_STOP 0 -- Changing types on hash-partitioned columns is not safe for some -- types and is therefore blocked. ALTER TABLE alter_test ALTER COLUMN colorname TYPE text; ERROR: cannot change the type of a hash-partitioned column \set ON_ERROR_STOP 1 SELECT * FROM test.show_columns('alter_test'); Column | Type | NotNull -----------+-----------------------------+--------- time_us | timestamp without time zone | t temp | double precision | f colorname | character varying | f SELECT * FROM test.show_columnsp('_timescaledb_internal._hyper_9_%chunk'); Relation | Kind | Column | Column type | NotNull ----------------------------------------+------+-----------+-----------------------------+--------- _timescaledb_internal._hyper_9_3_chunk | r | time_us | timestamp without time zone | t _timescaledb_internal._hyper_9_3_chunk | r | temp | double precision | f _timescaledb_internal._hyper_9_3_chunk | r | colorname | character varying | f _timescaledb_internal._hyper_9_4_chunk | r | time_us | timestamp without time zone | t _timescaledb_internal._hyper_9_4_chunk | r | temp | double precision | f _timescaledb_internal._hyper_9_4_chunk | r | colorname | character varying | f _timescaledb_internal._hyper_9_5_chunk | r | time_us | timestamp without time zone | t _timescaledb_internal._hyper_9_5_chunk | r | temp | double precision | f _timescaledb_internal._hyper_9_5_chunk | r | colorname | character varying | f -- show that the metadata has been updated SELECT * FROM _timescaledb_catalog.dimension WHERE hypertable_id = 9; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-----------------------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 15 | 9 | colorname | character varying | f | 2 | _timescaledb_functions | get_partition_hash | | | | 14 | 9 | time_us | timestamp without time zone | t | | | | 2628000000000 | | | -- constraint exclusion should still work with updated column EXPLAIN (buffers off, costs off) SELECT * FROM alter_test WHERE time_us > '2017-05-20T10:00:01'; --- QUERY PLAN --- Append -> Seq Scan on _hyper_9_4_chunk Filter: (time_us > 'Sat May 20 10:00:01 2017'::timestamp without time zone) -> Seq Scan on _hyper_9_5_chunk Filter: (time_us > 'Sat May 20 10:00:01 2017'::timestamp without time zone) \set ON_ERROR_STOP 0 -- verify that we cannot change the column type to something incompatible ALTER TABLE alter_test ALTER COLUMN colorname TYPE varchar(3); ERROR: cannot change the type of a hash-partitioned column -- conversion that messes up partitioning fails ALTER TABLE alter_test ALTER COLUMN time_us TYPE timestamptz USING time_us::timestamptz+INTERVAL '1 year'; ERROR: check constraint "constraint_4" of relation "_hyper_9_3_chunk" is violated by some row -- dropping column that messes up partiitoning fails ALTER TABLE alter_test DROP COLUMN colorname; ERROR: cannot drop column named in partition key --ONLY blocked ALTER TABLE ONLY alter_test RENAME COLUMN colorname TO colorname2; ERROR: inherited column "colorname" must be renamed in child tables too ALTER TABLE ONLY alter_test ALTER COLUMN colorname TYPE varchar(10); ERROR: ONLY option not supported on hypertable operations \set ON_ERROR_STOP 1 CREATE TABLE alter_test_bigint(time bigint, temp float); SELECT create_hypertable('alter_test_bigint', 'time', chunk_time_interval => 2628000000000); create_hypertable --------------------------------- (10,public,alter_test_bigint,t) \set ON_ERROR_STOP 0 -- Changing type of time dimension to a non-supported type -- shall not be allowed ALTER TABLE alter_test_bigint ALTER COLUMN time TYPE TEXT; ERROR: cannot change data type of hypertable column "time" from bigint to text -- dropping open time dimension shall not be allowed. ALTER TABLE alter_test_bigint DROP COLUMN time; ERROR: cannot drop column named in partition key \set ON_ERROR_STOP 1 -- test expression index creation where physical layout of chunks differs from hypertable CREATE TABLE i2504(time timestamp NOT NULL, a int, b int, c int, d int); select create_hypertable('i2504', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------- (11,public,i2504,t) INSERT INTO i2504 VALUES (now(), 1, 2, 3, 4); ALTER TABLE i2504 DROP COLUMN b; INSERT INTO i2504(time, a, c, d) VALUES (now() - interval '1 year', 1, 2, 3), (now() - interval '2 years', 1, 2, 3); CREATE INDEX idx2 ON i2504(a,d) WHERE c IS NOT NULL; DROP INDEX idx2; CREATE INDEX idx2 ON i2504(a,d) WITH (timescaledb.transaction_per_chunk) WHERE c IS NOT NULL; -- Make sure custom composite types are supported as dimensions CREATE TYPE TUPLE as (val1 int4, val2 int4); CREATE TABLE part_custom_dim (time TIMESTAMPTZ, combo TUPLE, device TEXT); \set ON_ERROR_STOP 0 -- should fail on PG < 14 because no partitioning function supplied and the given custom type -- has no default hash function -- on PG14 custom types are hashable SELECT create_hypertable('part_custom_dim', 'time', 'combo', 4); create_hypertable ------------------------------- (12,public,part_custom_dim,t) \set ON_ERROR_STOP 1 -- immutable functions with sub-transaction (issue #4489) CREATE FUNCTION i4489(value TEXT DEFAULT '') RETURNS INTEGER AS $$ BEGIN RETURN value::INTEGER; EXCEPTION WHEN invalid_text_representation THEN RETURN 0; END; $$ LANGUAGE PLPGSQL IMMUTABLE; -- should return 1 (one) in both cases SELECT i4489('1'), i4489('1'); i4489 | i4489 -------+------- 1 | 1 -- should return 0 (zero) in all cases handled by the exception SELECT i4489(), i4489(); i4489 | i4489 -------+------- 0 | 0 SELECT i4489('a'), i4489('a'); i4489 | i4489 -------+------- 0 | 0 -- test ALTER TABLE ONLY for hypertables CREATE TABLE at_test(time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column -- adding column only on the parent table should be blocked \set ON_ERROR_STOP 0 ALTER TABLE ONLY at_test ADD COLUMN value INT; ERROR: ONLY option not supported on hypertable operations \set ON_ERROR_STOP 1 ALTER TABLE ONLY at_test SET (autovacuum_enabled = false); ALTER TABLE ONLY at_test RESET (autovacuum_enabled); -- test again after creating some chunks INSERT INTO at_test VALUES ('2025-01-01'); INSERT INTO at_test VALUES ('2025-02-01'); ALTER TABLE ONLY at_test SET (autovacuum_enabled = false); ALTER TABLE ONLY at_test RESET (autovacuum_enabled); -- test DDL inside function CREATE OR REPLACE FUNCTION ddl_function() RETURNS VOID LANGUAGE PLPGSQL AS $$ BEGIN DROP TABLE IF EXISTS func_table; CREATE TABLE func_table(time timestamptz) WITH (tsdb.hypertable); END $$; SELECT ddl_function(); NOTICE: table "func_table" does not exist, skipping NOTICE: using column "time" as partitioning column ddl_function -------------- SELECT hypertable_name from timescaledb_information.hypertables WHERE hypertable_name='func_table'; hypertable_name ----------------- func_table SELECT ddl_function(); NOTICE: using column "time" as partitioning column ddl_function -------------- SELECT hypertable_name from timescaledb_information.hypertables WHERE hypertable_name='func_table'; hypertable_name ----------------- func_table ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/ddl_errors.out�����������������������������������������������������0000664�0000000�0000000�00000014023�15100345067�0021523�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); CREATE INDEX ON PUBLIC."Hypertable_1" (time, "Device_id"); -- Default integer interval is supported as part of -- hypertable generalization, verify additional secnarios \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable(NULL, NULL); ERROR: relation cannot be NULL SELECT * FROM create_hypertable('"public"."Hypertable_1"', NULL); ERROR: partition column cannot be NULL -- space dimensions require explicit number of partitions SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: invalid number of partitions for dimension "Device_id" SELECT * FROM create_hypertable('"public"."Hypertable_1_mispelled"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: relation "public.Hypertable_1_mispelled" does not exist at character 33 SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time_mispelled', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: column "time_mispelled" does not exist SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'Device_id', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: invalid type for dimension "Device_id" SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id_mispelled', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: column "Device_id_mispelled" does not exist INSERT INTO PUBLIC."Hypertable_1" VALUES(1,'dev_1', 3); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: table "Hypertable_1" is not empty DELETE FROM PUBLIC."Hypertable_1" ; \set ON_ERROR_STOP 1 SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | Hypertable_1 | t \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: table "Hypertable_1" is already a hypertable \set ON_ERROR_STOP 1 INSERT INTO "Hypertable_1" VALUES (0, 1, 0); \set ON_ERROR_STOP 0 ALTER TABLE _timescaledb_internal._hyper_1_1_chunk ALTER COLUMN temp_c DROP NOT NULL; ERROR: operation not supported on chunk tables \set ON_ERROR_STOP 1 CREATE TABLE PUBLIC."Parent" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); \set ON_ERROR_STOP 0 ALTER TABLE "Hypertable_1" INHERIT "Parent"; ERROR: hypertables do not support inheritance ALTER TABLE _timescaledb_internal._hyper_1_1_chunk INHERIT "Parent"; ERROR: operation not supported on chunk tables ALTER TABLE _timescaledb_internal._hyper_1_1_chunk NO INHERIT "Parent"; ERROR: operation not supported on chunk tables \set ON_ERROR_STOP 1 CREATE TABLE PUBLIC."Child" () INHERITS ("Parent"); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Parent"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: table "Parent" is already partitioned SELECT * FROM create_hypertable('"public"."Child"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: table "Child" is already partitioned \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 CREATE TEMPORARY TABLE temp_table (time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column ERROR: table "temp_table" cannot be temporary \set ON_ERROR_STOP 1 CREATE TEMP TABLE "Hypertable_temp" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"Hypertable_temp"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: table "Hypertable_temp" cannot be temporary ALTER TABLE "Hypertable_1" SET UNLOGGED; \set ON_ERROR_STOP 1 ALTER TABLE "Hypertable_1" SET LOGGED; CREATE TABLE PUBLIC."Hypertable_1_rule" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); CREATE RULE notify_me AS ON UPDATE TO "Hypertable_1_rule" DO ALSO NOTIFY "Hypertable_1_rule"; \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Hypertable_1_rule"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: hypertables do not support rules \set ON_ERROR_STOP 1 ALTER TABLE "Hypertable_1_rule" DISABLE RULE notify_me; \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Hypertable_1_rule"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ERROR: hypertables do not support rules \set ON_ERROR_STOP 1 DROP RULE notify_me ON "Hypertable_1_rule"; SELECT * FROM create_hypertable('"public"."Hypertable_1_rule"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------+--------- 3 | public | Hypertable_1_rule | t \set ON_ERROR_STOP 0 CREATE RULE notify_me AS ON UPDATE TO "Hypertable_1_rule" DO ALSO NOTIFY "Hypertable_1_rule"; ERROR: hypertables do not support rules \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 SELECT add_dimension(NULL,NULL); ERROR: hypertable cannot be NULL \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 SELECT attach_tablespace(NULL,NULL); ERROR: invalid tablespace name \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 select set_number_partitions(NULL,NULL); ERROR: hypertable cannot be NULL \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/ddl_extra.out������������������������������������������������������0000664�0000000�0000000�00000010640�15100345067�0021333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION show_columns_ext(rel regclass) RETURNS TABLE("Column" name, "Type" text, "NotNull" boolean, "Compression" text) LANGUAGE SQL STABLE AS $BODY$ SELECT a.attname, format_type(t.oid, t.typtypmod), a.attnotnull, (CASE WHEN a.attcompression = 'l' THEN 'lz4' WHEN a.attcompression = 'p' THEN 'pglz' ELSE '' END) FROM pg_attribute a, pg_type t WHERE a.attrelid = rel AND a.atttypid = t.oid AND a.attnum >= 0 ORDER BY a.attnum; $BODY$; CREATE TABLE conditions ( time TIMESTAMP NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time', chunk_time_interval := '1 day'::interval); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (1,public,conditions,t) INSERT INTO conditions SELECT generate_series('2021-10-10 00:00'::timestamp, '2021-10-11 00:00'::timestamp, '1 day'), 'POR', 55, 75; CREATE VIEW t AS SELECT 'conditions'::regclass AS r UNION ALL SELECT * FROM show_chunks('conditions'); SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; r | Column | Type | NotNull | Compression ----------------------------------------+----------+------+---------+------------- conditions | location | text | t | _timescaledb_internal._hyper_1_1_chunk | location | text | t | _timescaledb_internal._hyper_1_2_chunk | location | text | t | ALTER TABLE conditions ALTER COLUMN location SET COMPRESSION pglz; SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; r | Column | Type | NotNull | Compression ----------------------------------------+----------+------+---------+------------- conditions | location | text | t | pglz _timescaledb_internal._hyper_1_1_chunk | location | text | t | pglz _timescaledb_internal._hyper_1_2_chunk | location | text | t | pglz INSERT INTO conditions VALUES ('2021-10-12 00:00'::timestamp, 'BRA', 66, 77); SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; r | Column | Type | NotNull | Compression ----------------------------------------+----------+------+---------+------------- conditions | location | text | t | pglz _timescaledb_internal._hyper_1_1_chunk | location | text | t | pglz _timescaledb_internal._hyper_1_2_chunk | location | text | t | pglz _timescaledb_internal._hyper_1_3_chunk | location | text | t | pglz ALTER TABLE conditions ALTER COLUMN location SET COMPRESSION default; SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; r | Column | Type | NotNull | Compression ----------------------------------------+----------+------+---------+------------- conditions | location | text | t | _timescaledb_internal._hyper_1_1_chunk | location | text | t | _timescaledb_internal._hyper_1_2_chunk | location | text | t | _timescaledb_internal._hyper_1_3_chunk | location | text | t | \set ON_ERROR_STOP 0 -- failing test because compression is not allowed in "non-TOASTable" datatypes ALTER TABLE conditions ALTER COLUMN temperature SET COMPRESSION pglz; ERROR: column data type double precision does not support compression SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'temperature' ORDER BY 1, 2; r | Column | Type | NotNull | Compression ----------------------------------------+-------------+------------------+---------+------------- conditions | temperature | double precision | f | _timescaledb_internal._hyper_1_1_chunk | temperature | double precision | f | _timescaledb_internal._hyper_1_2_chunk | temperature | double precision | f | _timescaledb_internal._hyper_1_3_chunk | temperature | double precision | f | ������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/debug_utils.out����������������������������������������������������0000664�0000000�0000000�00000001552�15100345067�0021675�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT _timescaledb_debug.extension_state(); extension_state ----------------- created RESET ROLE; DO $$ DECLARE module text; BEGIN SELECT probin INTO module FROM pg_proc WHERE proname = 'extension_state' AND pronamespace = '_timescaledb_debug'::regnamespace; EXECUTE format('CREATE FUNCTION extension_state() RETURNS TEXT AS ''%s'', ''ts_extension_get_state'' LANGUAGE C', module); END $$; DROP EXTENSION timescaledb; SELECT * FROM extension_state(); extension_state ----------------- unknown \c CREATE EXTENSION timescaledb; SELECT * FROM extension_state(); extension_state ----------------- created ������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/delete.out���������������������������������������������������������0000664�0000000�0000000�00000026557�15100345067�0020645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | DELETE FROM "two_Partitions" WHERE series_0 = 1.5; DELETE FROM "two_Partitions" WHERE series_0 = 100; SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f -- Make sure DELETE isn't optimized if it includes Append plans -- Need to turn of nestloop to make append appear the same on PG96 and PG10 set enable_nestloop = 'off'; CREATE OR REPLACE FUNCTION series_val() RETURNS integer LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN 5; END; $BODY$; -- ConstraintAwareAppend applied for SELECT EXPLAIN (buffers off, costs off) SELECT FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()); --- QUERY PLAN --- Hash Join Hash Cond: ("two_Partitions".series_1 = "two_Partitions_1".series_1) -> Custom Scan (ChunkAppend) on "two_Partitions" Chunks excluded during startup: 0 -> Index Only Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_1_chunk Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_2_chunk Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_3_chunk Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_4_chunk Index Cond: (series_1 > (series_val())::double precision) -> Hash -> HashAggregate Group Key: "two_Partitions_1".series_1 -> Custom Scan (ChunkAppend) on "two_Partitions" "two_Partitions_1" Chunks excluded during startup: 0 -> Index Only Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_1_chunk _hyper_1_1_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_2_chunk _hyper_1_2_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_3_chunk _hyper_1_3_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_4_chunk _hyper_1_4_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -- ConstraintAwareAppend NOT applied for DELETE EXPLAIN (buffers off, costs off) DELETE FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on "two_Partitions" Delete on _hyper_1_1_chunk "two_Partitions_2" Delete on _hyper_1_2_chunk "two_Partitions_3" Delete on _hyper_1_3_chunk "two_Partitions_4" Delete on _hyper_1_4_chunk "two_Partitions_5" -> Hash Join Hash Cond: ("two_Partitions".series_1 = "two_Partitions_1".series_1) -> Append -> Seq Scan on _hyper_1_1_chunk "two_Partitions_2" -> Seq Scan on _hyper_1_2_chunk "two_Partitions_3" -> Seq Scan on _hyper_1_3_chunk "two_Partitions_4" -> Seq Scan on _hyper_1_4_chunk "two_Partitions_5" -> Hash -> HashAggregate Group Key: "two_Partitions_1".series_1 -> Append -> Index Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_1_chunk "two_Partitions_6" Index Cond: (series_1 > (series_val())::double precision) -> Index Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_2_chunk "two_Partitions_7" Index Cond: (series_1 > (series_val())::double precision) -> Index Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_3_chunk "two_Partitions_8" Index Cond: (series_1 > (series_val())::double precision) -> Index Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" on _hyper_1_4_chunk "two_Partitions_9" Index Cond: (series_1 > (series_val())::double precision) SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f BEGIN; DELETE FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()); SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257897600000000000 | dev1 | 4.5 | 5 | | f ROLLBACK; BEGIN; DELETE FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()) RETURNING "timeCustom"; timeCustom --------------------- 1257894002000000000 1257894002000000000 SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257897600000000000 | dev1 | 4.5 | 5 | | f ROLLBACK; -- test update on chunks directly CREATE TABLE direct_delete(time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO direct_delete VALUES ('2020-01-01'); SELECT show_chunks('direct_delete') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) DELETE FROM :CHUNK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on _hyper_2_5_chunk -> Seq Scan on _hyper_2_5_chunk EXPLAIN (costs off, timing off, summary off) DELETE FROM ONLY :CHUNK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on _hyper_2_5_chunk -> Seq Scan on _hyper_2_5_chunk -- DELETE should succeed BEGIN; DELETE FROM :CHUNK RETURNING *; time ------------------------------ Wed Jan 01 00:00:00 2020 PST ROLLBACK; BEGIN; DELETE FROM ONLY :CHUNK RETURNING *; time ------------------------------ Wed Jan 01 00:00:00 2020 PST ROLLBACK; �������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_extension.out�������������������������������������������������0000664�0000000�0000000�00000010506�15100345067�0022426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE drop_test(time timestamp, temp float8, device text); SELECT create_hypertable('drop_test', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------ (1,public,drop_test,t) SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | drop_test | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 INSERT INTO drop_test VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); SELECT * FROM drop_test; time | temp | device ---------------------------------+------+-------- Mon Mar 20 09:17:00.936242 2017 | 23.4 | dev1 \c :TEST_DBNAME :ROLE_SUPERUSER DROP EXTENSION timescaledb CASCADE; NOTICE: drop cascades to table _timescaledb_internal._hyper_1_1_chunk \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Querying the original table should not return any rows since all of -- them actually existed in chunks that are now gone SELECT * FROM drop_test; time | temp | device ------+------+-------- \c :TEST_DBNAME :ROLE_SUPERUSER -- Recreate the extension SET client_min_messages=error; CREATE EXTENSION timescaledb; RESET client_min_messages; -- Test that calling twice generates proper error \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb; ERROR: extension "timescaledb" has already been loaded with another version \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- CREATE twice with IF NOT EXISTS should be OK CREATE EXTENSION IF NOT EXISTS timescaledb; NOTICE: extension "timescaledb" already exists, skipping -- Make the table a hypertable again SELECT create_hypertable('drop_test', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------ (1,public,drop_test,t) SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | drop_test | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 INSERT INTO drop_test VALUES('Mon Mar 20 09:18:19.100462 2017', 22.1, 'dev1'); SELECT * FROM drop_test; time | temp | device ---------------------------------+------+-------- Mon Mar 20 09:18:19.100462 2017 | 22.1 | dev1 --test drops thru cascades of other objects \c :TEST_DBNAME :ROLE_SUPERUSER -- Stop background workers to prevent them from interfering with the drop public schema SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SET client_min_messages TO ERROR; REVOKE CONNECT ON DATABASE :TEST_DBNAME FROM public; SELECT count(pg_terminate_backend(pg_stat_activity.pid)) AS TERMINATED FROM pg_stat_activity WHERE pg_stat_activity.datname = :'TEST_DBNAME' AND pg_stat_activity.pid <> pg_backend_pid() \gset RESET client_min_messages; -- drop the public schema and all its objects DROP SCHEMA public CASCADE; NOTICE: drop cascades to 3 other objects \dn List of schemas Name | Owner ------+------------ test | super_user ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_hypertable.out������������������������������������������������0000664�0000000�0000000�00000015743�15100345067�0022561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT * from _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ CREATE TABLE should_drop (time timestamp, temp float8); SELECT create_hypertable('should_drop', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (1,public,should_drop,t) CREATE TABLE hyper_with_dependencies (time timestamp, temp float8); SELECT create_hypertable('hyper_with_dependencies', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------------- (2,public,hyper_with_dependencies,t) CREATE VIEW dependent_view AS SELECT * FROM hyper_with_dependencies; INSERT INTO hyper_with_dependencies VALUES (now(), 1.0); \set ON_ERROR_STOP 0 DROP TABLE hyper_with_dependencies; ERROR: cannot drop table hyper_with_dependencies because other objects depend on it \set ON_ERROR_STOP 1 DROP TABLE hyper_with_dependencies CASCADE; NOTICE: drop cascades to view dependent_view -- check that the view is dropped SELECT oid FROM pg_class WHERE relname = 'dependent_view'; oid ----- CREATE TABLE chunk_with_dependencies (time timestamp, temp float8); SELECT create_hypertable('chunk_with_dependencies', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------------- (3,public,chunk_with_dependencies,t) INSERT INTO chunk_with_dependencies VALUES (now(), 1.0); CREATE VIEW dependent_view_chunk AS SELECT * FROM _timescaledb_internal._hyper_3_2_chunk; \set ON_ERROR_STOP 0 DROP TABLE chunk_with_dependencies; ERROR: cannot drop table _timescaledb_internal._hyper_3_2_chunk because other objects depend on it \set ON_ERROR_STOP 1 DROP TABLE chunk_with_dependencies CASCADE; NOTICE: drop cascades to view dependent_view_chunk -- check that the view is dropped SELECT oid FROM pg_class WHERE relname = 'dependent_view_chunk'; oid ----- -- Calling create hypertable again will increment hypertable ID -- although no new hypertable is created. Make sure we can handle this. SELECT create_hypertable('should_drop', 'time', if_not_exists => true); NOTICE: table "should_drop" is already a hypertable, skipping create_hypertable -------------------------- (1,public,should_drop,f) SELECT * from _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+-------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | should_drop | _timescaledb_internal | _hyper_1 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-----------------------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp without time zone | t | | | | 604800000000 | | | DROP TABLE should_drop; CREATE TABLE should_drop (time timestamp, temp float8); SELECT create_hypertable('should_drop', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (4,public,should_drop,t) INSERT INTO should_drop VALUES (now(), 1.0); SELECT * from _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+-------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 4 | public | should_drop | _timescaledb_internal | _hyper_4 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-----------------------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 4 | 4 | time | timestamp without time zone | t | | | | 604800000000 | | | -- test dropping multiple objects at once CREATE TABLE t1 (time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO t1 VALUES ('2025-01-01'); CREATE TABLE t2 (time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO t2 VALUES ('2025-01-01'); CREATE TABLE t3 (time timestamptz); DROP TABLE t1, t2, t3; �����������������������������timescaledb-2.23.0/test/expected/drop_owned-15.out��������������������������������������������������0000664�0000000�0000000�00000031154�15100345067�0021753�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA hypertable_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.default_perm_user (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.default_perm_user', 'time', 'location', 2); create_hypertable ------------------------------------------- (1,hypertable_schema,default_perm_user,t) INSERT INTO hypertable_schema.default_perm_user VALUES ('2001-01-01 01:01:01', 23.3, 1); RESET ROLE; CREATE TABLE hypertable_schema.superuser (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.superuser', 'time', 'location', 2); create_hypertable ----------------------------------- (2,hypertable_schema,superuser,t) INSERT INTO hypertable_schema.superuser VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+-------------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | hypertable_schema | default_perm_user | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP OWNED BY :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP TABLE hypertable_schema.superuser; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+-------------+----------- SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- -- test drop owned in database without extension installed \c :TEST_DBNAME :ROLE_SUPERUSER CREATE database test_drop_owned; \c test_drop_owned DROP OWNED BY :ROLE_SUPERUSER; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test_drop_owned WITH (FORCE); -- Test that dependencies on roles are added to chunks when creating -- new chunks. If that is not done, DROP OWNED BY will not revoke the -- privilege on the chunk. CREATE TABLE sensor_data(time timestamptz not null, cpu double precision null); SELECT * FROM create_hypertable('sensor_data','time'); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 3 | public | sensor_data | t INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-01'::timestamptz, '2020-01-24'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+-------------------+-------------------+---------- public | sensor_data | table | | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | | | _timescaledb_internal | _hyper_3_4_chunk | table | | | _timescaledb_internal | _hyper_3_5_chunk | table | | | _timescaledb_internal | _hyper_3_6_chunk | table | | | _timescaledb_internal | _hyper_3_7_chunk | table | | | GRANT SELECT ON sensor_data TO :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+--------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | -- Insert more chunks after adding the user to the hypertable. These -- will now get the privileges of the hypertable. INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-20'::timestamptz, '2020-02-05'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | -- This should revoke the privileges on both the hypertable and the chunks. DROP OWNED BY :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+-------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxt/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxt/super_user | | ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_owned-16.out��������������������������������������������������0000664�0000000�0000000�00000031154�15100345067�0021754�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA hypertable_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.default_perm_user (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.default_perm_user', 'time', 'location', 2); create_hypertable ------------------------------------------- (1,hypertable_schema,default_perm_user,t) INSERT INTO hypertable_schema.default_perm_user VALUES ('2001-01-01 01:01:01', 23.3, 1); RESET ROLE; CREATE TABLE hypertable_schema.superuser (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.superuser', 'time', 'location', 2); create_hypertable ----------------------------------- (2,hypertable_schema,superuser,t) INSERT INTO hypertable_schema.superuser VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+-------------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | hypertable_schema | default_perm_user | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP OWNED BY :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP TABLE hypertable_schema.superuser; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+-------------+----------- SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- -- test drop owned in database without extension installed \c :TEST_DBNAME :ROLE_SUPERUSER CREATE database test_drop_owned; \c test_drop_owned DROP OWNED BY :ROLE_SUPERUSER; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test_drop_owned WITH (FORCE); -- Test that dependencies on roles are added to chunks when creating -- new chunks. If that is not done, DROP OWNED BY will not revoke the -- privilege on the chunk. CREATE TABLE sensor_data(time timestamptz not null, cpu double precision null); SELECT * FROM create_hypertable('sensor_data','time'); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 3 | public | sensor_data | t INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-01'::timestamptz, '2020-01-24'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+-------------------+-------------------+---------- public | sensor_data | table | | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | | | _timescaledb_internal | _hyper_3_4_chunk | table | | | _timescaledb_internal | _hyper_3_5_chunk | table | | | _timescaledb_internal | _hyper_3_6_chunk | table | | | _timescaledb_internal | _hyper_3_7_chunk | table | | | GRANT SELECT ON sensor_data TO :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+--------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | -- Insert more chunks after adding the user to the hypertable. These -- will now get the privileges of the hypertable. INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-20'::timestamptz, '2020-02-05'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user=r/super_user | | -- This should revoke the privileges on both the hypertable and the chunks. DROP OWNED BY :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+-------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxt/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxt/super_user | | ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_owned-17.out��������������������������������������������������0000664�0000000�0000000�00000031167�15100345067�0021761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA hypertable_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.default_perm_user (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.default_perm_user', 'time', 'location', 2); create_hypertable ------------------------------------------- (1,hypertable_schema,default_perm_user,t) INSERT INTO hypertable_schema.default_perm_user VALUES ('2001-01-01 01:01:01', 23.3, 1); RESET ROLE; CREATE TABLE hypertable_schema.superuser (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.superuser', 'time', 'location', 2); create_hypertable ----------------------------------- (2,hypertable_schema,superuser,t) INSERT INTO hypertable_schema.superuser VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+-------------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | hypertable_schema | default_perm_user | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP OWNED BY :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP TABLE hypertable_schema.superuser; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+-------------+----------- SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- -- test drop owned in database without extension installed \c :TEST_DBNAME :ROLE_SUPERUSER CREATE database test_drop_owned; \c test_drop_owned DROP OWNED BY :ROLE_SUPERUSER; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test_drop_owned WITH (FORCE); -- Test that dependencies on roles are added to chunks when creating -- new chunks. If that is not done, DROP OWNED BY will not revoke the -- privilege on the chunk. CREATE TABLE sensor_data(time timestamptz not null, cpu double precision null); SELECT * FROM create_hypertable('sensor_data','time'); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 3 | public | sensor_data | t INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-01'::timestamptz, '2020-01-24'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+-------------------+-------------------+---------- public | sensor_data | table | | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | | | _timescaledb_internal | _hyper_3_4_chunk | table | | | _timescaledb_internal | _hyper_3_5_chunk | table | | | _timescaledb_internal | _hyper_3_6_chunk | table | | | _timescaledb_internal | _hyper_3_7_chunk | table | | | GRANT SELECT ON sensor_data TO :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+--------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | -- Insert more chunks after adding the user to the hypertable. These -- will now get the privileges of the hypertable. INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-20'::timestamptz, '2020-02-05'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | -- This should revoke the privileges on both the hypertable and the chunks. DROP OWNED BY :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+--------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxtm/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxtm/super_user | | ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_owned-18.out��������������������������������������������������0000664�0000000�0000000�00000031167�15100345067�0021762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA hypertable_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.default_perm_user (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.default_perm_user', 'time', 'location', 2); create_hypertable ------------------------------------------- (1,hypertable_schema,default_perm_user,t) INSERT INTO hypertable_schema.default_perm_user VALUES ('2001-01-01 01:01:01', 23.3, 1); RESET ROLE; CREATE TABLE hypertable_schema.superuser (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.superuser', 'time', 'location', 2); create_hypertable ----------------------------------- (2,hypertable_schema,superuser,t) INSERT INTO hypertable_schema.superuser VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+-------------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | hypertable_schema | default_perm_user | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP OWNED BY :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 2 | hypertable_schema | superuser | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 2 | 2 | _timescaledb_internal | _hyper_2_2_chunk | | f | 0 | f DROP TABLE hypertable_schema.superuser; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+-------------+----------- SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- -- test drop owned in database without extension installed \c :TEST_DBNAME :ROLE_SUPERUSER CREATE database test_drop_owned; \c test_drop_owned DROP OWNED BY :ROLE_SUPERUSER; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test_drop_owned WITH (FORCE); -- Test that dependencies on roles are added to chunks when creating -- new chunks. If that is not done, DROP OWNED BY will not revoke the -- privilege on the chunk. CREATE TABLE sensor_data(time timestamptz not null, cpu double precision null); SELECT * FROM create_hypertable('sensor_data','time'); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 3 | public | sensor_data | t INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-01'::timestamptz, '2020-01-24'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+-------------------+-------------------+---------- public | sensor_data | table | | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | | | _timescaledb_internal | _hyper_3_4_chunk | table | | | _timescaledb_internal | _hyper_3_5_chunk | table | | | _timescaledb_internal | _hyper_3_6_chunk | table | | | _timescaledb_internal | _hyper_3_7_chunk | table | | | GRANT SELECT ON sensor_data TO :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+--------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | -- Insert more chunks after adding the user to the hypertable. These -- will now get the privileges of the hypertable. INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-20'::timestamptz, '2020-02-05'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxtm/super_user+| | | | | default_perm_user=r/super_user | | -- This should revoke the privileges on both the hypertable and the chunks. DROP OWNED BY :ROLE_DEFAULT_PERM_USER; \dp sensor_data Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------+-------+--------------------------------+-------------------+---------- public | sensor_data | table | super_user=arwdDxtm/super_user | | \dp _timescaledb_internal._hyper_3* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_3_3_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_4_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_5_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_6_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_7_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_3_8_chunk | table | super_user=arwdDxtm/super_user | | ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_rename_hypertable.out�����������������������������������������0000664�0000000�0000000�00000044101�15100345067�0024076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); Relation | Kind | Column | Column type | NotNull ------------------------------------------------------------------------------------+------+-------------+------------------+--------- _timescaledb_internal._hyper_1_1_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_1_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_1_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_2_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_2_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_2_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_3_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_3_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_3_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_4_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_4_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_4_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f -- Test that renaming hypertable works SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); Column | Type | NotNull -------------+------------------+--------- timeCustom | bigint | t device_id | text | t series_0 | double precision | f series_1 | double precision | f series_2 | double precision | f series_bool | boolean | f ALTER TABLE "two_Partitions" RENAME TO "newname"; SELECT * FROM "newname"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257894002000000000 | dev1 | 2.5 | 3 | | 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | newname | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "newschema" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ALTER TABLE "newname" SET SCHEMA "newschema"; SELECT * FROM "newschema"."newname"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257894002000000000 | dev1 | 2.5 | 3 | | 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | newschema | newname | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 DROP TABLE "newschema"."newname"; SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT schema, name FROM test.relation WHERE schema IN ('public', '_timescaledb_catalog', '_timescaledb_internal'); schema | name -----------------------+-------------------------------------------------- _timescaledb_catalog | chunk _timescaledb_catalog | chunk_column_stats _timescaledb_catalog | chunk_constraint _timescaledb_catalog | compression_algorithm _timescaledb_catalog | compression_chunk_size _timescaledb_catalog | compression_settings _timescaledb_catalog | continuous_agg _timescaledb_catalog | continuous_agg_migrate_plan _timescaledb_catalog | continuous_agg_migrate_plan_step _timescaledb_catalog | continuous_aggs_bucket_function _timescaledb_catalog | continuous_aggs_hypertable_invalidation_log _timescaledb_catalog | continuous_aggs_invalidation_threshold _timescaledb_catalog | continuous_aggs_materialization_invalidation_log _timescaledb_catalog | continuous_aggs_materialization_ranges _timescaledb_catalog | continuous_aggs_watermark _timescaledb_catalog | dimension _timescaledb_catalog | dimension_slice _timescaledb_catalog | hypertable _timescaledb_catalog | metadata _timescaledb_catalog | tablespace _timescaledb_catalog | telemetry_event _timescaledb_internal | bgw_job_stat _timescaledb_internal | bgw_job_stat_history _timescaledb_internal | bgw_policy_chunk_stats _timescaledb_internal | compressed_chunk_stats _timescaledb_internal | hypertable_chunk_local_size -- Test that renaming ordinary table works CREATE TABLE renametable (foo int); ALTER TABLE "renametable" RENAME TO "newname_none_ht"; SELECT * FROM "newname_none_ht"; foo ----- ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/drop_schema.out����������������������������������������������������0000664�0000000�0000000�00000016760�15100345067�0021662�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA chunk_schema1; CREATE SCHEMA chunk_schema2; CREATE SCHEMA hypertable_schema; CREATE SCHEMA extra_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; GRANT ALL ON SCHEMA chunk_schema1 TO :ROLE_DEFAULT_PERM_USER; GRANT ALL ON SCHEMA chunk_schema2 TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.test1 (time timestamptz, temp float, location int); CREATE TABLE hypertable_schema.test2 (time timestamptz, temp float, location int); --create two identical tables with their own chunk schemas SELECT create_hypertable('hypertable_schema.test1', 'time', 'location', 2, associated_schema_name => 'chunk_schema1'); create_hypertable ------------------------------- (1,hypertable_schema,test1,t) SELECT create_hypertable('hypertable_schema.test2', 'time', 'location', 2, associated_schema_name => 'chunk_schema2'); create_hypertable ------------------------------- (2,hypertable_schema,test2,t) INSERT INTO hypertable_schema.test1 VALUES ('2001-01-01 01:01:01', 23.3, 1); INSERT INTO hypertable_schema.test2 VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | hypertable_schema | test1 | chunk_schema1 | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | hypertable_schema | test2 | chunk_schema2 | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+---------------+------------------+---------------------+---------+--------+----------- 1 | 1 | chunk_schema1 | _hyper_1_1_chunk | | f | 0 | f 2 | 2 | chunk_schema2 | _hyper_2_2_chunk | | f | 0 | f RESET ROLE; --drop the associated schema. We drop the extra schema to show we can --handle multi-schema drops DROP SCHEMA chunk_schema1, extra_schema CASCADE; NOTICE: drop cascades to table chunk_schema1._hyper_1_1_chunk NOTICE: the chunk storage schema changed to "_timescaledb_internal" for 1 hypertable SET ROLE :ROLE_DEFAULT_PERM_USER; --show that the metadata for the table using the dropped schema is --changed. The other table is not affected. SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | hypertable_schema | test1 | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | hypertable_schema | test2 | chunk_schema2 | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+---------------+------------------+---------------------+---------+--------+----------- 2 | 2 | chunk_schema2 | _hyper_2_2_chunk | | f | 0 | f --new chunk should be created in the internal associated schema INSERT INTO hypertable_schema.test1 VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 2 | 2 | chunk_schema2 | _hyper_2_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f RESET ROLE; --dropping the internal schema should not work \set ON_ERROR_STOP 0 DROP SCHEMA _timescaledb_internal CASCADE; ERROR: cannot drop schema _timescaledb_internal because extension timescaledb requires it \set ON_ERROR_STOP 1 --dropping the hypertable schema should delete everything DROP SCHEMA hypertable_schema CASCADE; NOTICE: drop cascades to 4 other objects SET ROLE :ROLE_DEFAULT_PERM_USER; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+------------------------+-------------------+-------------------+--------------------------+-------- SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+-------------+----------- SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+-----------------+---------------------------- ����������������timescaledb-2.23.0/test/expected/dump_meta.out������������������������������������������������������0000664�0000000�0000000�00000034251�15100345067�0021344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 1 | public | two_Partitions | t \set QUIET off BEGIN; BEGIN \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on \ir ../../scripts/dump_meta_data.sql -- -- This file is licensed under the Apache License, see LICENSE-APACHE -- at the top level directory of the TimescaleDB distribution. -- This script will dump relevant meta data from internal TimescaleDB tables -- that can help our engineers trouble shoot. -- -- usage: -- psql [your connect flags] -d your_timescale_db < dump_meta_data.sql > dumpfile.txt \echo 'TimescaleDB meta data dump' TimescaleDB meta data dump </exclude_from_test> \echo 'List of tables' List of tables SELECT n.nspname as "Schema", c.relname as "Name", CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 't' THEN 'TOAST table' WHEN 'f' THEN 'foreign table' WHEN 'p' THEN 'partitioned table' WHEN 'I' THEN 'partitioned index' END as "Type", pg_catalog.pg_get_userbyid(c.relowner) as "Owner" FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam WHERE c.relkind IN ('r','p','') AND n.nspname <> 'pg_catalog' AND n.nspname !~ '^pg_toast' AND n.nspname <> 'information_schema' AND pg_catalog.pg_table_is_visible(c.oid) ORDER BY 1,2; Schema | Name | Type | Owner --------+----------------+-------+------------------- public | two_Partitions | table | default_perm_user \echo 'List of hypertables' List of hypertables SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+----------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | two_Partitions | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 \echo 'List of chunk indexes' List of chunk indexes SELECT ch.id AS chunk_id, ci.indexrelid::regclass::text AS index_name, h.id AS hypertable_id FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = h.id JOIN pg_index ci ON ci.indrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass ORDER BY h.id, ch.id, ci.indrelid::regclass::text; chunk_id | index_name | hypertable_id ----------+------------------------------------------------------------------------------------+--------------- 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | 1 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | 1 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | 1 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | 1 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | 1 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | 1 1 | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | 1 2 | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | 1 3 | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | 1 4 | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | 1 \echo 'Size of hypertables' Size of hypertables SELECT hypertable, table_bytes, index_bytes, toast_bytes, total_bytes FROM ( SELECT *, total_bytes-index_bytes-COALESCE(toast_bytes,0) AS table_bytes FROM ( SELECT pgc.oid::regclass::text as hypertable, sum(pg_total_relation_size('"' || c.schema_name || '"."' || c.table_name || '"'))::bigint as total_bytes, sum(pg_indexes_size('"' || c.schema_name || '"."' || c.table_name || '"'))::bigint AS index_bytes, sum(pg_total_relation_size(reltoastrelid))::bigint AS toast_bytes FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c, pg_class pgc, pg_namespace pns WHERE c.hypertable_id = h.id AND pgc.relname = h.table_name AND pns.oid = pgc.relnamespace AND pns.nspname = h.schema_name AND relkind = 'r' AND c.dropped is false GROUP BY pgc.oid ) sub1 ) sub2; hypertable | table_bytes | index_bytes | toast_bytes | total_bytes ------------------+-------------+-------------+-------------+------------- "two_Partitions" | 32768 | 417792 | 32768 | 483328 \echo 'Chunk sizes:' Chunk sizes: SELECT chunk_id, chunk_table, partitioning_columns, partitioning_column_types, partitioning_hash_functions, ranges, table_bytes, index_bytes, toast_bytes, total_bytes FROM ( SELECT *, total_bytes-index_bytes-COALESCE(toast_bytes,0) AS table_bytes FROM ( SELECT c.id as chunk_id, '"' || c.schema_name || '"."' || c.table_name || '"' as chunk_table, pg_total_relation_size('"' || c.schema_name || '"."' || c.table_name || '"') AS total_bytes, pg_indexes_size('"' || c.schema_name || '"."' || c.table_name || '"') AS index_bytes, pg_total_relation_size(reltoastrelid) AS toast_bytes, array_agg(d.column_name ORDER BY d.interval_length, d.column_name ASC) as partitioning_columns, array_agg(d.column_type ORDER BY d.interval_length, d.column_name ASC) as partitioning_column_types, array_agg(d.partitioning_func_schema || '.' || d.partitioning_func ORDER BY d.interval_length, d.column_name ASC) as partitioning_hash_functions, array_agg('[' || _timescaledb_functions.range_value_to_pretty(range_start, column_type) || ',' || _timescaledb_functions.range_value_to_pretty(range_end, column_type) || ')' ORDER BY d.interval_length, d.column_name ASC) as ranges FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension d, _timescaledb_catalog.dimension_slice ds, pg_class pgc, pg_namespace pns WHERE pgc.relname = h.table_name AND pns.oid = pgc.relnamespace AND pns.nspname = h.schema_name AND relkind = 'r' AND c.hypertable_id = h.id AND c.id = cc.chunk_id AND cc.dimension_slice_id = ds.id AND ds.dimension_id = d.id AND c.dropped is false GROUP BY c.id, pgc.reltoastrelid, pgc.oid ORDER BY c.id ) sub1 ) sub2; chunk_id | chunk_table | partitioning_columns | partitioning_column_types | partitioning_hash_functions | ranges | table_bytes | index_bytes | toast_bytes | total_bytes ----------+--------------------------------------------+------------------------+---------------------------+--------------------------------------------------+-------------------------------------------------------------------+-------------+-------------+-------------+------------- 1 | "_timescaledb_internal"."_hyper_1_1_chunk" | {timeCustom,device_id} | {bigint,text} | {NULL,_timescaledb_functions.get_partition_hash} | {"['1257892416000000000','1257895008000000000')","[1073741823,)"} | 8192 | 114688 | 8192 | 131072 2 | "_timescaledb_internal"."_hyper_1_2_chunk" | {timeCustom,device_id} | {bigint,text} | {NULL,_timescaledb_functions.get_partition_hash} | {"['1257897600000000000','1257900192000000000')","[1073741823,)"} | 8192 | 106496 | 8192 | 122880 3 | "_timescaledb_internal"."_hyper_1_3_chunk" | {timeCustom,device_id} | {bigint,text} | {NULL,_timescaledb_functions.get_partition_hash} | {"['1257985728000000000','1257988320000000000')","[1073741823,)"} | 8192 | 98304 | 8192 | 114688 4 | "_timescaledb_internal"."_hyper_1_4_chunk" | {timeCustom,device_id} | {bigint,text} | {NULL,_timescaledb_functions.get_partition_hash} | {"['1257892416000000000','1257895008000000000')","[,1073741823)"} | 8192 | 98304 | 8192 | 114688 \echo 'Hypertable index sizes' Hypertable index sizes SET search_path TO pg_catalog, pg_temp; SELECT i.indrelid::regclass AS hypertable, i.indexrelid::regclass AS index_name, public.hypertable_index_size(i.indexrelid::regclass) AS index_bytes FROM _timescaledb_catalog.hypertable h JOIN pg_index i ON i.indrelid = format('%I.%I',h.schema_name,h.table_name)::regclass ORDER BY i.indrelid::regclass::text, i.indexrelid::regclass::text; hypertable | index_name | index_bytes -------------------------+----------------------------------------------------+------------- public."two_Partitions" | public."two_Partitions_device_id_timeCustom_idx" | 73728 public."two_Partitions" | public."two_Partitions_timeCustom_device_id_idx" | 73728 public."two_Partitions" | public."two_Partitions_timeCustom_idx" | 73728 public."two_Partitions" | public."two_Partitions_timeCustom_series_0_idx" | 73728 public."two_Partitions" | public."two_Partitions_timeCustom_series_1_idx" | 73728 public."two_Partitions" | public."two_Partitions_timeCustom_series_2_idx" | 49152 public."two_Partitions" | public."two_Partitions_timeCustom_series_bool_idx" | 57344 RESET search_path; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/extension_scripts.out����������������������������������������������0000664�0000000�0000000�00000005065�15100345067�0023155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER DROP EXTENSION timescaledb; -- test that installation script errors when any of our internal schemas already exists \set ON_ERROR_STOP 0 CREATE SCHEMA _timescaledb_catalog; CREATE EXTENSION timescaledb; ERROR: schema "_timescaledb_catalog" already exists DROP SCHEMA _timescaledb_catalog; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA _timescaledb_internal; CREATE EXTENSION timescaledb; ERROR: schema "_timescaledb_internal" already exists DROP SCHEMA _timescaledb_internal; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA _timescaledb_cache; CREATE EXTENSION timescaledb; ERROR: schema "_timescaledb_cache" already exists DROP SCHEMA _timescaledb_cache; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA _timescaledb_config; CREATE EXTENSION timescaledb; ERROR: schema "_timescaledb_config" already exists DROP SCHEMA _timescaledb_config; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA timescaledb_experimental; CREATE EXTENSION timescaledb; ERROR: schema "timescaledb_experimental" already exists DROP SCHEMA timescaledb_experimental; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA timescaledb_information; CREATE EXTENSION timescaledb; ERROR: schema "timescaledb_information" already exists DROP SCHEMA timescaledb_information; -- test that installation script errors when any of the function in public schema already exists -- we don't test every public function but just a few common ones \c :TEST_DBNAME :ROLE_SUPERUSER CREATE FUNCTION time_bucket(int,int) RETURNS int LANGUAGE SQL AS $$ SELECT 1::int; $$; CREATE EXTENSION timescaledb; ERROR: function "time_bucket" already exists with same argument types DROP FUNCTION time_bucket; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION show_chunks(relation regclass, older_than "any" DEFAULT NULL, newer_than "any" DEFAULT NULL, created_before "any" DEFAULT NULL, created_after "any" DEFAULT NULL) RETURNS SETOF regclass language internal as 'pg_partition_ancestors'; CREATE EXTENSION timescaledb; ERROR: function "show_chunks" already exists with same argument types DROP FUNCTION show_chunks; -- Create a user that is not all-lowercase CREATE USER "FooBar" WITH SUPERUSER; \c :TEST_DBNAME "FooBar" SET client_min_messages TO error; CREATE EXTENSION timescaledb; DROP EXTENSION timescaledb; RESET client_min_messages; \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER "FooBar"; SET client_min_messages TO ERROR; CREATE EXTENSION timescaledb; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/generated_as_identity.out������������������������������������������0000664�0000000�0000000�00000004342�15100345067�0023721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE table test_gen ( id int generated by default AS IDENTITY primary key, payload text ); SELECT create_hypertable('test_gen', 'id', chunk_time_interval=>10); create_hypertable ----------------------- (1,public,test_gen,t) insert into test_gen (payload) select generate_series(1,15) returning *; id | payload ----+--------- 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 select * from test_gen; id | payload ----+--------- 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 \set ON_ERROR_STOP 0 insert into test_gen values('1', 'a'); ERROR: duplicate key value violates unique constraint "1_1_test_gen_pkey" \set ON_ERROR_STOP 1 ALTER TABLE test_gen ALTER COLUMN id DROP IDENTITY; \set ON_ERROR_STOP 0 insert into test_gen (payload) select generate_series(15,20) returning *; ERROR: NULL value in column "id" violates not-null constraint \set ON_ERROR_STOP 1 ALTER TABLE test_gen ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY; \set ON_ERROR_STOP 0 insert into test_gen (payload) select generate_series(15,20) returning *; ERROR: duplicate key value violates unique constraint "1_1_test_gen_pkey" \set ON_ERROR_STOP 1 ALTER TABLE test_gen ALTER COLUMN id SET GENERATED BY DEFAULT RESTART 100; insert into test_gen (payload) select generate_series(15,20) returning *; id | payload -----+--------- 100 | 15 101 | 16 102 | 17 103 | 18 104 | 19 105 | 20 select * from test_gen; id | payload -----+--------- 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 100 | 15 101 | 16 102 | 17 103 | 18 104 | 19 105 | 20 SELECT * FROM test.show_subtables('test_gen'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/grant_hypertable-15.out��������������������������������������������0000664�0000000�0000000�00000062740�15100345067�0023152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable and show that it does not have any privileges SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '5 days'::interval); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | conditions | t INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------+-------------------+---------- public | conditions | table | | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | | | _timescaledb_internal | _hyper_1_2_chunk | table | | | _timescaledb_internal | _hyper_1_3_chunk | table | | | -- Add privileges and show that they propagate to the chunks GRANT SELECT, INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | -- Create some more chunks and show that they also get the privileges. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-10 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | -- Revoke one of the privileges and show that it propagate to the -- chunks. REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | -- Add some more chunks and show that it inherits the grants from the -- hypertable. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-20 00:00'::timestamp, '2018-12-30 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | -- Change grants of one chunk explicitly and check that it is possible \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | GRANT UPDATE ON _timescaledb_internal._hyper_1_1_chunk TO PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_1_chunk FROM PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =w/super_user | | -- Check that revoking a permission first on the chunk and then on the -- hypertable that was added through the hypertable (INSERT and -- SELECT, in this case) still do not copy permissions from the -- hypertable (so there should not be a select permission to public on -- the chunk but there should be one on the hypertable). GRANT INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_2_chunk FROM PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user | | -- Check that granting permissions through hypertable does not remove -- separate grants on chunk. GRANT UPDATE ON _timescaledb_internal._hyper_1_3_chunk TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | GRANT INSERT ON conditions TO PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | -- Check that GRANT ALL IN SCHEMA adds privileges to the parent -- and also goes to chunks in another schema GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+----------------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user +| | | | | =w/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user +| | | | | =rw/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | -- Check that REVOKE ALL IN SCHEMA removes privileges of the parent -- and also goes to chunks in another schema REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =w/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | -- Create chunks in the same schema as the hypertable and check that -- they also get the same privileges as the hypertable CREATE TABLE measurements( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable with chunks in the same schema SELECT * FROM create_hypertable('public.measurements', 'time', chunk_time_interval => '5 days'::interval, associated_schema_name => 'public'); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 2 | public | measurements | t INSERT INTO measurements SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; -- GRANT ALL and check privileges GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+----------------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+----------------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | -- REVOKE ALL and check privileges REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+-------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxt/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+-------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxt/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxt/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxt/super_user | | -- GRANT/REVOKE in an empty schema (Issue #4581) CREATE SCHEMA test_grant; GRANT ALL ON ALL TABLES IN SCHEMA test_grant TO :ROLE_DEFAULT_PERM_USER_2; REVOKE ALL ON ALL TABLES IN SCHEMA test_grant FROM :ROLE_DEFAULT_PERM_USER_2; ��������������������������������timescaledb-2.23.0/test/expected/grant_hypertable-16.out��������������������������������������������0000664�0000000�0000000�00000062740�15100345067�0023153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable and show that it does not have any privileges SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '5 days'::interval); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | conditions | t INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------+-------------------+---------- public | conditions | table | | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | | | _timescaledb_internal | _hyper_1_2_chunk | table | | | _timescaledb_internal | _hyper_1_3_chunk | table | | | -- Add privileges and show that they propagate to the chunks GRANT SELECT, INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | -- Create some more chunks and show that they also get the privileges. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-10 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | -- Revoke one of the privileges and show that it propagate to the -- chunks. REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | -- Add some more chunks and show that it inherits the grants from the -- hypertable. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-20 00:00'::timestamp, '2018-12-30 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | -- Change grants of one chunk explicitly and check that it is possible \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | GRANT UPDATE ON _timescaledb_internal._hyper_1_1_chunk TO PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_1_chunk FROM PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =w/super_user | | -- Check that revoking a permission first on the chunk and then on the -- hypertable that was added through the hypertable (INSERT and -- SELECT, in this case) still do not copy permissions from the -- hypertable (so there should not be a select permission to public on -- the chunk but there should be one on the hypertable). GRANT INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user+| | | | | =ar/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_2_chunk FROM PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user | | -- Check that granting permissions through hypertable does not remove -- separate grants on chunk. GRANT UPDATE ON _timescaledb_internal._hyper_1_3_chunk TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | GRANT INSERT ON conditions TO PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | -- Check that GRANT ALL IN SCHEMA adds privileges to the parent -- and also goes to chunks in another schema GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+----------------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user +| | | | | =w/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user +| | | | | =rw/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | -- Check that REVOKE ALL IN SCHEMA removes privileges of the parent -- and also goes to chunks in another schema REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxt/super_user+| | | | | =w/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxt/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxt/super_user+| | | | | =rw/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | -- Create chunks in the same schema as the hypertable and check that -- they also get the same privileges as the hypertable CREATE TABLE measurements( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable with chunks in the same schema SELECT * FROM create_hypertable('public.measurements', 'time', chunk_time_interval => '5 days'::interval, associated_schema_name => 'public'); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 2 | public | measurements | t INSERT INTO measurements SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; -- GRANT ALL and check privileges GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+----------------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+----------------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxt/super_user +| | | | | default_perm_user_2=arwdDxt/super_user | | -- REVOKE ALL and check privileges REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+-------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxt/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxt/super_user+| | | | | =r/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+-------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxt/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxt/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxt/super_user | | -- GRANT/REVOKE in an empty schema (Issue #4581) CREATE SCHEMA test_grant; GRANT ALL ON ALL TABLES IN SCHEMA test_grant TO :ROLE_DEFAULT_PERM_USER_2; REVOKE ALL ON ALL TABLES IN SCHEMA test_grant FROM :ROLE_DEFAULT_PERM_USER_2; ��������������������������������timescaledb-2.23.0/test/expected/grant_hypertable-17.out��������������������������������������������0000664�0000000�0000000�00000063243�15100345067�0023153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable and show that it does not have any privileges SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '5 days'::interval); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | conditions | t INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------+-------------------+---------- public | conditions | table | | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | | | _timescaledb_internal | _hyper_1_2_chunk | table | | | _timescaledb_internal | _hyper_1_3_chunk | table | | | -- Add privileges and show that they propagate to the chunks GRANT SELECT, INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | -- Create some more chunks and show that they also get the privileges. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-10 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | -- Revoke one of the privileges and show that it propagate to the -- chunks. REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | -- Add some more chunks and show that it inherits the grants from the -- hypertable. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-20 00:00'::timestamp, '2018-12-30 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | -- Change grants of one chunk explicitly and check that it is possible \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | GRANT UPDATE ON _timescaledb_internal._hyper_1_1_chunk TO PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_1_chunk FROM PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =w/super_user | | -- Check that revoking a permission first on the chunk and then on the -- hypertable that was added through the hypertable (INSERT and -- SELECT, in this case) still do not copy permissions from the -- hypertable (so there should not be a select permission to public on -- the chunk but there should be one on the hypertable). GRANT INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_2_chunk FROM PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user | | -- Check that granting permissions through hypertable does not remove -- separate grants on chunk. GRANT UPDATE ON _timescaledb_internal._hyper_1_3_chunk TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | GRANT INSERT ON conditions TO PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | -- Check that GRANT ALL IN SCHEMA adds privileges to the parent -- and also goes to chunks in another schema GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-----------------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user +| | | | | =w/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user +| | | | | =rw/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | -- Check that REVOKE ALL IN SCHEMA removes privileges of the parent -- and also goes to chunks in another schema REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =w/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | -- Create chunks in the same schema as the hypertable and check that -- they also get the same privileges as the hypertable CREATE TABLE measurements( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable with chunks in the same schema SELECT * FROM create_hypertable('public.measurements', 'time', chunk_time_interval => '5 days'::interval, associated_schema_name => 'public'); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 2 | public | measurements | t INSERT INTO measurements SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; -- GRANT ALL and check privileges GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+-----------------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+-----------------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | -- REVOKE ALL and check privileges REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+--------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxtm/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+--------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxtm/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxtm/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxtm/super_user | | -- GRANT/REVOKE in an empty schema (Issue #4581) CREATE SCHEMA test_grant; GRANT ALL ON ALL TABLES IN SCHEMA test_grant TO :ROLE_DEFAULT_PERM_USER_2; REVOKE ALL ON ALL TABLES IN SCHEMA test_grant FROM :ROLE_DEFAULT_PERM_USER_2; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/grant_hypertable-18.out��������������������������������������������0000664�0000000�0000000�00000063243�15100345067�0023154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable and show that it does not have any privileges SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '5 days'::interval); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | conditions | t INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-------------------+-------------------+---------- public | conditions | table | | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | | | _timescaledb_internal | _hyper_1_2_chunk | table | | | _timescaledb_internal | _hyper_1_3_chunk | table | | | -- Add privileges and show that they propagate to the chunks GRANT SELECT, INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | -- Create some more chunks and show that they also get the privileges. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-10 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | -- Revoke one of the privileges and show that it propagate to the -- chunks. REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | -- Add some more chunks and show that it inherits the grants from the -- hypertable. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-20 00:00'::timestamp, '2018-12-30 00:00'::timestamp, '1h') AS time; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | -- Change grants of one chunk explicitly and check that it is possible \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | GRANT UPDATE ON _timescaledb_internal._hyper_1_1_chunk TO PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_1_chunk FROM PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =w/super_user | | -- Check that revoking a permission first on the chunk and then on the -- hypertable that was added through the hypertable (INSERT and -- SELECT, in this case) still do not copy permissions from the -- hypertable (so there should not be a select permission to public on -- the chunk but there should be one on the hypertable). GRANT INSERT ON conditions TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | =ar/super_user | | REVOKE SELECT ON _timescaledb_internal._hyper_1_2_chunk FROM PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_2_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user | | -- Check that granting permissions through hypertable does not remove -- separate grants on chunk. GRANT UPDATE ON _timescaledb_internal._hyper_1_3_chunk TO PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | GRANT INSERT ON conditions TO PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal._hyper_1_3_chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | -- Check that GRANT ALL IN SCHEMA adds privileges to the parent -- and also goes to chunks in another schema GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-----------------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user +| | | | | =w/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user +| | | | | =rw/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | -- Check that REVOKE ALL IN SCHEMA removes privileges of the parent -- and also goes to chunks in another schema REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z _timescaledb_internal.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | =w/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | =rw/super_user | | _timescaledb_internal | _hyper_1_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_5_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_6_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | _timescaledb_internal | _hyper_1_7_chunk | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | -- Create chunks in the same schema as the hypertable and check that -- they also get the same privileges as the hypertable CREATE TABLE measurements( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable with chunks in the same schema SELECT * FROM create_hypertable('public.measurements', 'time', chunk_time_interval => '5 days'::interval, associated_schema_name => 'public'); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 2 | public | measurements | t INSERT INTO measurements SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; -- GRANT ALL and check privileges GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+-----------------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+-----------------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user +| | | | | =r/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+-----------------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxtm/super_user +| | | | | default_perm_user_2=arwdDxtm/super_user | | -- REVOKE ALL and check privileges REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z measurements Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+--------------+-------+--------------------------------+-------------------+---------- public | measurements | table | super_user=arwdDxtm/super_user | | \z conditions Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+------------+-------+--------------------------------+-------------------+---------- public | conditions | table | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | \z public.*chunk Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+-------------------+-------+--------------------------------+-------------------+---------- public | _hyper_2_10_chunk | table | super_user=arwdDxtm/super_user | | public | _hyper_2_8_chunk | table | super_user=arwdDxtm/super_user | | public | _hyper_2_9_chunk | table | super_user=arwdDxtm/super_user | | -- GRANT/REVOKE in an empty schema (Issue #4581) CREATE SCHEMA test_grant; GRANT ALL ON ALL TABLES IN SCHEMA test_grant TO :ROLE_DEFAULT_PERM_USER_2; REVOKE ALL ON ALL TABLES IN SCHEMA test_grant FROM :ROLE_DEFAULT_PERM_USER_2; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/hash.out�����������������������������������������������������������0000664�0000000�0000000�00000017530�15100345067�0020315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test hashing Const values. We should expect the same hash value for -- all integer types when values are compatible SELECT _timescaledb_functions.get_partition_hash(1::int); get_partition_hash -------------------- 242423622 SELECT _timescaledb_functions.get_partition_hash(1::bigint); get_partition_hash -------------------- 242423622 SELECT _timescaledb_functions.get_partition_hash(1::smallint); get_partition_hash -------------------- 242423622 SELECT _timescaledb_functions.get_partition_hash(true); get_partition_hash -------------------- 242423622 -- Floating point types should also hash the same for compatible values SELECT _timescaledb_functions.get_partition_hash(1.0::real); get_partition_hash -------------------- 376496956 SELECT _timescaledb_functions.get_partition_hash(1.0::double precision); get_partition_hash -------------------- 376496956 -- Float aliases SELECT _timescaledb_functions.get_partition_hash(1.0::float); get_partition_hash -------------------- 376496956 SELECT _timescaledb_functions.get_partition_hash(1.0::float4); get_partition_hash -------------------- 376496956 SELECT _timescaledb_functions.get_partition_hash(1.0::float8); get_partition_hash -------------------- 376496956 SELECT _timescaledb_functions.get_partition_hash(1.0::numeric); get_partition_hash -------------------- 1324868424 -- 'name' and '"char"' are internal PostgreSQL types, which are not -- intended for use by the general user. They are included here only -- for completeness -- https://www.postgresql.org/docs/10/static/datatype-character.html#datatype-character-special-table SELECT _timescaledb_functions.get_partition_hash('c'::name); get_partition_hash -------------------- 1903644986 SELECT _timescaledb_functions.get_partition_hash('c'::"char"); get_partition_hash -------------------- 203891234 -- String and character hashes should also have the same output for -- compatible values SELECT _timescaledb_functions.get_partition_hash('c'::char); get_partition_hash -------------------- 1903644986 SELECT _timescaledb_functions.get_partition_hash('c'::varchar(2)); get_partition_hash -------------------- 1903644986 SELECT _timescaledb_functions.get_partition_hash('c'::text); get_partition_hash -------------------- 1903644986 -- 'c' is 0x63 in ASCII SELECT _timescaledb_functions.get_partition_hash(E'\\x63'::bytea); get_partition_hash -------------------- 1903644986 -- Time and date types SELECT _timescaledb_functions.get_partition_hash(interval '1 day'); get_partition_hash -------------------- 93502988 SELECT _timescaledb_functions.get_partition_hash('2017-03-22T09:18:23'::timestamp); get_partition_hash -------------------- 307315039 SELECT _timescaledb_functions.get_partition_hash('2017-03-22T09:18:23'::timestamptz); get_partition_hash -------------------- 1195163597 SELECT _timescaledb_functions.get_partition_hash('2017-03-22'::date); get_partition_hash -------------------- 693590295 SELECT _timescaledb_functions.get_partition_hash('10:00:00'::time); get_partition_hash -------------------- 1380652790 SELECT _timescaledb_functions.get_partition_hash('10:00:00-1'::timetz); get_partition_hash -------------------- 769387140 -- Other types SELECT _timescaledb_functions.get_partition_hash(ARRAY[1,2,3]); get_partition_hash -------------------- 1822090118 SELECT _timescaledb_functions.get_partition_hash('08002b:010203'::macaddr); get_partition_hash -------------------- 294987870 SELECT _timescaledb_functions.get_partition_hash('192.168.100.128/25'::cidr); get_partition_hash -------------------- 1612896565 SELECT _timescaledb_functions.get_partition_hash('192.168.100.128'::inet); get_partition_hash -------------------- 1952516432 SELECT _timescaledb_functions.get_partition_hash('2001:4f8:3:ba:2e0:81ff:fe22:d1f1'::inet); get_partition_hash -------------------- 933321588 SELECT _timescaledb_functions.get_partition_hash('2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'::cidr); get_partition_hash -------------------- 933321588 SELECT _timescaledb_functions.get_partition_hash('{ "foo": "bar" }'::jsonb); get_partition_hash -------------------- 208840587 SELECT _timescaledb_functions.get_partition_hash('4b6a5eec-b344-11e7-abc4-cec278b6b50a'::uuid); get_partition_hash -------------------- 504202548 SELECT _timescaledb_functions.get_partition_hash(1::regclass); get_partition_hash -------------------- 242423622 SELECT _timescaledb_functions.get_partition_hash(int4range(10, 20)); get_partition_hash -------------------- 1202375768 SELECT _timescaledb_functions.get_partition_hash(int8range(10, 20)); get_partition_hash -------------------- 1202375768 SELECT _timescaledb_functions.get_partition_hash(numrange(10, 20)); get_partition_hash -------------------- 1083987536 SELECT _timescaledb_functions.get_partition_hash(tsrange('2017-03-22T09:18:23', '2017-03-23T09:18:23')); get_partition_hash -------------------- 2079608838 SELECT _timescaledb_functions.get_partition_hash(tstzrange('2017-03-22T09:18:23+01', '2017-03-23T09:18:23+00')); get_partition_hash -------------------- 1255083771 -- Test hashing Var values CREATE TABLE hash_test(id int, value text); INSERT INTO hash_test VALUES (1, 'test'); -- Test Vars SELECT _timescaledb_functions.get_partition_hash(id) FROM hash_test; get_partition_hash -------------------- 242423622 SELECT _timescaledb_functions.get_partition_hash(value) FROM hash_test; get_partition_hash -------------------- 1771415073 -- Test coerced value SELECT _timescaledb_functions.get_partition_hash(id::text) FROM hash_test; get_partition_hash -------------------- 1516350201 -- Test legacy function that converts values to text first SELECT _timescaledb_functions.get_partition_for_key('4b6a5eec-b344-11e7-abc4-cec278b6b50a'::text); get_partition_for_key ----------------------- 934882099 SELECT _timescaledb_functions.get_partition_for_key('4b6a5eec-b344-11e7-abc4-cec278b6b50a'::varchar); get_partition_for_key ----------------------- 934882099 SELECT _timescaledb_functions.get_partition_for_key(187); get_partition_for_key ----------------------- 1161071810 SELECT _timescaledb_functions.get_partition_for_key(187::bigint); get_partition_for_key ----------------------- 1161071810 SELECT _timescaledb_functions.get_partition_for_key(187::numeric); get_partition_for_key ----------------------- 1161071810 SELECT _timescaledb_functions.get_partition_for_key(187::double precision); get_partition_for_key ----------------------- 1161071810 SELECT _timescaledb_functions.get_partition_for_key(int4range(10, 20)); get_partition_for_key ----------------------- 505239042 SELECT _timescaledb_functions.get_partition_hash('08002b:010203'::macaddr); get_partition_hash -------------------- 294987870 -- Test inside IMMUTABLE function (Issue #4575) CREATE FUNCTION my_get_partition_hash(INTEGER) RETURNS INTEGER AS 'SELECT _timescaledb_functions.get_partition_hash($1);' LANGUAGE SQL IMMUTABLE; CREATE FUNCTION my_get_partition_for_key(INTEGER) RETURNS INTEGER AS 'SELECT _timescaledb_functions.get_partition_for_key($1);' LANGUAGE SQL IMMUTABLE; SELECT my_get_partition_hash(1); my_get_partition_hash ----------------------- 242423622 SELECT my_get_partition_for_key(1); my_get_partition_for_key -------------------------- 1516350201 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/histogram_test-15.out����������������������������������������������0000664�0000000�0000000�00000007332�15100345067�0022650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- table 1 CREATE TABLE "hitest1"(key real, val varchar(40)); -- insertions INSERT INTO "hitest1" VALUES(0, 'hi'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(3, 'yo'); INSERT INTO "hitest1" VALUES(4, 'howdy'); INSERT INTO "hitest1" VALUES(5, 'hola'); INSERT INTO "hitest1" VALUES(6, 'ya'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(1, 'sup'); -- table 2 CREATE TABLE "hitest2"(name varchar(30), score integer, qualify boolean); -- insertions INSERT INTO "hitest2" VALUES('Tom', 6, TRUE); INSERT INTO "hitest2" VALUES('Mary', 4, FALSE); INSERT INTO "hitest2" VALUES('Jaq', 3, FALSE); INSERT INTO "hitest2" VALUES('Jane', 10, TRUE); -- standard 2 bucket SELECT histogram(key, 0, 9, 2) FROM hitest1; histogram ----------- {0,8,2,0} -- standard multi-bucket SELECT histogram(key, 0, 9, 5) FROM hitest1; histogram ----------------- {0,4,3,2,1,0,0} -- standard 3 bucket SELECT val, histogram(key, 0, 7, 3) FROM hitest1 GROUP BY val ORDER BY val; val | histogram -------+------------- hello | {0,2,0,0,0} hi | {0,1,0,0,0} hola | {0,0,0,1,0} howdy | {0,0,1,0,0} sup | {0,3,0,0,0} ya | {0,0,0,1,0} yo | {0,0,1,0,0} -- standard element beneath lb SELECT histogram(key, 1, 7, 3) FROM hitest1; histogram ------------- {1,5,2,2,0} -- standard element above ub SELECT histogram(key, 0, 3, 3) FROM hitest1; histogram ------------- {0,1,3,2,4} -- standard element beneath and above lb and ub, respectively SELECT histogram(key, 1, 3, 2) FROM hitest1; histogram ----------- {1,3,2,4} -- standard 1 bucket SELECT histogram(key, 1, 3, 1) FROM hitest1; histogram ----------- {1,5,4} -- standard 2 bucket SELECT qualify, histogram(score, 0, 10, 2) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------- f | {0,2,0,0} t | {0,0,1,1} -- standard multi-bucket SELECT qualify, histogram(score, 0, 10, 5) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------------- f | {0,0,1,1,0,0,0} t | {0,0,0,0,1,0,1} -- check number of buckets is constant \set ON_ERROR_STOP 0 select histogram(i,10,90,case when i=1 then 1 else 1000000 end) FROM generate_series(1,100) i; ERROR: number of buckets must not change between calls \set ON_ERROR_STOP 1 CREATE TABLE weather ( time TIMESTAMPTZ NOT NULL, city TEXT, temperature FLOAT, PRIMARY KEY(time, city) ); -- There is a bug in width_bucket() causing a NaN as a result, so we -- check that it is not causing a crash in histogram(). SELECT * FROM create_hypertable('weather', 'time', 'city', 3); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | weather | t INSERT INTO weather VALUES ('2023-02-10 09:16:51.133584+00','city1',10.4), ('2023-02-10 11:16:51.611618+00','city1',10.3), ('2023-02-10 06:58:59.999999+00','city1',10.3), ('2023-02-10 01:58:59.999999+00','city1',10.3), ('2023-02-09 01:58:59.999999+00','city1',10.3), ('2023-02-10 08:58:59.999999+00','city1',10.3), ('2023-03-23 06:12:02.73765+00 ','city1', 9.7), ('2023-03-23 06:12:06.990998+00','city1',11.7); -- This will currently generate an error on PG15 and prior versions \set ON_ERROR_STOP 0 SELECT histogram(temperature, -1.79769e+308, 1.79769e+308,10) FROM weather GROUP BY city; ERROR: index -2147483648 from "width_bucket" out of range \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/histogram_test-16.out����������������������������������������������0000664�0000000�0000000�00000007363�15100345067�0022655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- table 1 CREATE TABLE "hitest1"(key real, val varchar(40)); -- insertions INSERT INTO "hitest1" VALUES(0, 'hi'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(3, 'yo'); INSERT INTO "hitest1" VALUES(4, 'howdy'); INSERT INTO "hitest1" VALUES(5, 'hola'); INSERT INTO "hitest1" VALUES(6, 'ya'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(1, 'sup'); -- table 2 CREATE TABLE "hitest2"(name varchar(30), score integer, qualify boolean); -- insertions INSERT INTO "hitest2" VALUES('Tom', 6, TRUE); INSERT INTO "hitest2" VALUES('Mary', 4, FALSE); INSERT INTO "hitest2" VALUES('Jaq', 3, FALSE); INSERT INTO "hitest2" VALUES('Jane', 10, TRUE); -- standard 2 bucket SELECT histogram(key, 0, 9, 2) FROM hitest1; histogram ----------- {0,8,2,0} -- standard multi-bucket SELECT histogram(key, 0, 9, 5) FROM hitest1; histogram ----------------- {0,4,3,2,1,0,0} -- standard 3 bucket SELECT val, histogram(key, 0, 7, 3) FROM hitest1 GROUP BY val ORDER BY val; val | histogram -------+------------- hello | {0,2,0,0,0} hi | {0,1,0,0,0} hola | {0,0,0,1,0} howdy | {0,0,1,0,0} sup | {0,3,0,0,0} ya | {0,0,0,1,0} yo | {0,0,1,0,0} -- standard element beneath lb SELECT histogram(key, 1, 7, 3) FROM hitest1; histogram ------------- {1,5,2,2,0} -- standard element above ub SELECT histogram(key, 0, 3, 3) FROM hitest1; histogram ------------- {0,1,3,2,4} -- standard element beneath and above lb and ub, respectively SELECT histogram(key, 1, 3, 2) FROM hitest1; histogram ----------- {1,3,2,4} -- standard 1 bucket SELECT histogram(key, 1, 3, 1) FROM hitest1; histogram ----------- {1,5,4} -- standard 2 bucket SELECT qualify, histogram(score, 0, 10, 2) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------- f | {0,2,0,0} t | {0,0,1,1} -- standard multi-bucket SELECT qualify, histogram(score, 0, 10, 5) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------------- f | {0,0,1,1,0,0,0} t | {0,0,0,0,1,0,1} -- check number of buckets is constant \set ON_ERROR_STOP 0 select histogram(i,10,90,case when i=1 then 1 else 1000000 end) FROM generate_series(1,100) i; ERROR: number of buckets must not change between calls \set ON_ERROR_STOP 1 CREATE TABLE weather ( time TIMESTAMPTZ NOT NULL, city TEXT, temperature FLOAT, PRIMARY KEY(time, city) ); -- There is a bug in width_bucket() causing a NaN as a result, so we -- check that it is not causing a crash in histogram(). SELECT * FROM create_hypertable('weather', 'time', 'city', 3); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | weather | t INSERT INTO weather VALUES ('2023-02-10 09:16:51.133584+00','city1',10.4), ('2023-02-10 11:16:51.611618+00','city1',10.3), ('2023-02-10 06:58:59.999999+00','city1',10.3), ('2023-02-10 01:58:59.999999+00','city1',10.3), ('2023-02-09 01:58:59.999999+00','city1',10.3), ('2023-02-10 08:58:59.999999+00','city1',10.3), ('2023-03-23 06:12:02.73765+00 ','city1', 9.7), ('2023-03-23 06:12:06.990998+00','city1',11.7); -- This will currently generate an error on PG15 and prior versions \set ON_ERROR_STOP 0 SELECT histogram(temperature, -1.79769e+308, 1.79769e+308,10) FROM weather GROUP BY city; histogram --------------------------- {0,0,0,0,0,0,8,0,0,0,0,0} \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/histogram_test-17.out����������������������������������������������0000664�0000000�0000000�00000007363�15100345067�0022656�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- table 1 CREATE TABLE "hitest1"(key real, val varchar(40)); -- insertions INSERT INTO "hitest1" VALUES(0, 'hi'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(3, 'yo'); INSERT INTO "hitest1" VALUES(4, 'howdy'); INSERT INTO "hitest1" VALUES(5, 'hola'); INSERT INTO "hitest1" VALUES(6, 'ya'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(1, 'sup'); -- table 2 CREATE TABLE "hitest2"(name varchar(30), score integer, qualify boolean); -- insertions INSERT INTO "hitest2" VALUES('Tom', 6, TRUE); INSERT INTO "hitest2" VALUES('Mary', 4, FALSE); INSERT INTO "hitest2" VALUES('Jaq', 3, FALSE); INSERT INTO "hitest2" VALUES('Jane', 10, TRUE); -- standard 2 bucket SELECT histogram(key, 0, 9, 2) FROM hitest1; histogram ----------- {0,8,2,0} -- standard multi-bucket SELECT histogram(key, 0, 9, 5) FROM hitest1; histogram ----------------- {0,4,3,2,1,0,0} -- standard 3 bucket SELECT val, histogram(key, 0, 7, 3) FROM hitest1 GROUP BY val ORDER BY val; val | histogram -------+------------- hello | {0,2,0,0,0} hi | {0,1,0,0,0} hola | {0,0,0,1,0} howdy | {0,0,1,0,0} sup | {0,3,0,0,0} ya | {0,0,0,1,0} yo | {0,0,1,0,0} -- standard element beneath lb SELECT histogram(key, 1, 7, 3) FROM hitest1; histogram ------------- {1,5,2,2,0} -- standard element above ub SELECT histogram(key, 0, 3, 3) FROM hitest1; histogram ------------- {0,1,3,2,4} -- standard element beneath and above lb and ub, respectively SELECT histogram(key, 1, 3, 2) FROM hitest1; histogram ----------- {1,3,2,4} -- standard 1 bucket SELECT histogram(key, 1, 3, 1) FROM hitest1; histogram ----------- {1,5,4} -- standard 2 bucket SELECT qualify, histogram(score, 0, 10, 2) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------- f | {0,2,0,0} t | {0,0,1,1} -- standard multi-bucket SELECT qualify, histogram(score, 0, 10, 5) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------------- f | {0,0,1,1,0,0,0} t | {0,0,0,0,1,0,1} -- check number of buckets is constant \set ON_ERROR_STOP 0 select histogram(i,10,90,case when i=1 then 1 else 1000000 end) FROM generate_series(1,100) i; ERROR: number of buckets must not change between calls \set ON_ERROR_STOP 1 CREATE TABLE weather ( time TIMESTAMPTZ NOT NULL, city TEXT, temperature FLOAT, PRIMARY KEY(time, city) ); -- There is a bug in width_bucket() causing a NaN as a result, so we -- check that it is not causing a crash in histogram(). SELECT * FROM create_hypertable('weather', 'time', 'city', 3); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | weather | t INSERT INTO weather VALUES ('2023-02-10 09:16:51.133584+00','city1',10.4), ('2023-02-10 11:16:51.611618+00','city1',10.3), ('2023-02-10 06:58:59.999999+00','city1',10.3), ('2023-02-10 01:58:59.999999+00','city1',10.3), ('2023-02-09 01:58:59.999999+00','city1',10.3), ('2023-02-10 08:58:59.999999+00','city1',10.3), ('2023-03-23 06:12:02.73765+00 ','city1', 9.7), ('2023-03-23 06:12:06.990998+00','city1',11.7); -- This will currently generate an error on PG15 and prior versions \set ON_ERROR_STOP 0 SELECT histogram(temperature, -1.79769e+308, 1.79769e+308,10) FROM weather GROUP BY city; histogram --------------------------- {0,0,0,0,0,0,8,0,0,0,0,0} \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/histogram_test-18.out����������������������������������������������0000664�0000000�0000000�00000007363�15100345067�0022657�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- table 1 CREATE TABLE "hitest1"(key real, val varchar(40)); -- insertions INSERT INTO "hitest1" VALUES(0, 'hi'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(3, 'yo'); INSERT INTO "hitest1" VALUES(4, 'howdy'); INSERT INTO "hitest1" VALUES(5, 'hola'); INSERT INTO "hitest1" VALUES(6, 'ya'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(1, 'sup'); -- table 2 CREATE TABLE "hitest2"(name varchar(30), score integer, qualify boolean); -- insertions INSERT INTO "hitest2" VALUES('Tom', 6, TRUE); INSERT INTO "hitest2" VALUES('Mary', 4, FALSE); INSERT INTO "hitest2" VALUES('Jaq', 3, FALSE); INSERT INTO "hitest2" VALUES('Jane', 10, TRUE); -- standard 2 bucket SELECT histogram(key, 0, 9, 2) FROM hitest1; histogram ----------- {0,8,2,0} -- standard multi-bucket SELECT histogram(key, 0, 9, 5) FROM hitest1; histogram ----------------- {0,4,3,2,1,0,0} -- standard 3 bucket SELECT val, histogram(key, 0, 7, 3) FROM hitest1 GROUP BY val ORDER BY val; val | histogram -------+------------- hello | {0,2,0,0,0} hi | {0,1,0,0,0} hola | {0,0,0,1,0} howdy | {0,0,1,0,0} sup | {0,3,0,0,0} ya | {0,0,0,1,0} yo | {0,0,1,0,0} -- standard element beneath lb SELECT histogram(key, 1, 7, 3) FROM hitest1; histogram ------------- {1,5,2,2,0} -- standard element above ub SELECT histogram(key, 0, 3, 3) FROM hitest1; histogram ------------- {0,1,3,2,4} -- standard element beneath and above lb and ub, respectively SELECT histogram(key, 1, 3, 2) FROM hitest1; histogram ----------- {1,3,2,4} -- standard 1 bucket SELECT histogram(key, 1, 3, 1) FROM hitest1; histogram ----------- {1,5,4} -- standard 2 bucket SELECT qualify, histogram(score, 0, 10, 2) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------- f | {0,2,0,0} t | {0,0,1,1} -- standard multi-bucket SELECT qualify, histogram(score, 0, 10, 5) FROM hitest2 GROUP BY qualify ORDER BY qualify; qualify | histogram ---------+----------------- f | {0,0,1,1,0,0,0} t | {0,0,0,0,1,0,1} -- check number of buckets is constant \set ON_ERROR_STOP 0 select histogram(i,10,90,case when i=1 then 1 else 1000000 end) FROM generate_series(1,100) i; ERROR: number of buckets must not change between calls \set ON_ERROR_STOP 1 CREATE TABLE weather ( time TIMESTAMPTZ NOT NULL, city TEXT, temperature FLOAT, PRIMARY KEY(time, city) ); -- There is a bug in width_bucket() causing a NaN as a result, so we -- check that it is not causing a crash in histogram(). SELECT * FROM create_hypertable('weather', 'time', 'city', 3); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | weather | t INSERT INTO weather VALUES ('2023-02-10 09:16:51.133584+00','city1',10.4), ('2023-02-10 11:16:51.611618+00','city1',10.3), ('2023-02-10 06:58:59.999999+00','city1',10.3), ('2023-02-10 01:58:59.999999+00','city1',10.3), ('2023-02-09 01:58:59.999999+00','city1',10.3), ('2023-02-10 08:58:59.999999+00','city1',10.3), ('2023-03-23 06:12:02.73765+00 ','city1', 9.7), ('2023-03-23 06:12:06.990998+00','city1',11.7); -- This will currently generate an error on PG15 and prior versions \set ON_ERROR_STOP 0 SELECT histogram(temperature, -1.79769e+308, 1.79769e+308,10) FROM weather GROUP BY city; histogram --------------------------- {0,0,0,0,0,0,8,0,0,0,0,0} \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/index.out����������������������������������������������������������0000664�0000000�0000000�00000130704�15100345067�0020500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE index_test(time timestamptz, temp float); SELECT create_hypertable('index_test', 'time'); create_hypertable ------------------------- (1,public,index_test,t) -- Default indexes created SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------------+---------+------+--------+---------+-----------+------------ index_test_time_idx | {time} | | f | f | f | DROP TABLE index_test; CREATE TABLE index_test(time timestamptz, device integer, temp float); -- Create index before create_hypertable() CREATE UNIQUE INDEX index_test_time_idx ON index_test (time); \set ON_ERROR_STOP 0 -- Creating a hypertable from a table with an index that doesn't cover -- all partitioning columns should fail SELECT create_hypertable('index_test', 'time', 'device', 2); ERROR: cannot create a unique index without the column "device" (used in partitioning) \set ON_ERROR_STOP 1 -- Partitioning on only time should work SELECT create_hypertable('index_test', 'time'); create_hypertable ------------------------- (3,public,index_test,t) INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 1, 17.5); -- Check that index is also created on chunk SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------------+---------+------+--------+---------+-----------+------------ index_test_time_idx | {time} | | t | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_3_1_chunk | _timescaledb_internal._hyper_3_1_chunk_index_test_time_idx | {time} | | t | f | f | -- Create another chunk INSERT INTO index_test VALUES ('2017-05-20T09:00:01', 3, 17.5); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_3_1_chunk | _timescaledb_internal._hyper_3_1_chunk_index_test_time_idx | {time} | | t | f | f | _timescaledb_internal._hyper_3_2_chunk | _timescaledb_internal._hyper_3_2_chunk_index_test_time_idx | {time} | | t | f | f | -- Delete the index on only one chunk DROP INDEX _timescaledb_internal._hyper_3_1_chunk_index_test_time_idx; SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_3_2_chunk | _timescaledb_internal._hyper_3_2_chunk_index_test_time_idx | {time} | | t | f | f | -- Recreate table with new partitioning DROP TABLE index_test; CREATE TABLE index_test(id serial, time timestamptz, device integer, temp float); SELECT * FROM test.show_columns('index_test'); Column | Type | NotNull --------+--------------------------+--------- id | integer | t time | timestamp with time zone | f device | integer | f temp | double precision | f -- Test that we can handle difference in attnos across hypertable and -- chunks by dropping the ID column ALTER TABLE index_test DROP COLUMN id; SELECT * FROM test.show_columns('index_test'); Column | Type | NotNull --------+--------------------------+--------- time | timestamp with time zone | f device | integer | f temp | double precision | f -- No pre-existing UNIQUE index, so partitioning on two columns should work SELECT create_hypertable('index_test', 'time', 'device', 2); create_hypertable ------------------------- (4,public,index_test,t) INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 1, 17.5); \set ON_ERROR_STOP 0 -- Create unique index without all partitioning columns should fail CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time); ERROR: cannot create a unique index without the column "device" (used in partitioning) \set ON_ERROR_STOP 1 CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time, device); -- Regular index need not cover all partitioning columns CREATE INDEX ON index_test (time, temp); -- Create another chunk INSERT INTO index_test VALUES ('2017-04-20T09:00:01', 1, 17.5); -- New index should have been recursed to chunks SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_device_idx | {time,device} | | t | f | f | index_test_time_idx | {time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_device_idx | {time,device} | | t | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_device_idx | {time,device} | | t | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | ALTER INDEX index_test_time_idx RENAME TO index_test_time_idx2; -- Metadata and index should have changed name SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_device_idx | {time,device} | | t | f | f | index_test_time_idx2 | {time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_idx2 | {time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_device_idx | {time,device} | | t | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_idx2 | {time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_device_idx | {time,device} | | t | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | DROP INDEX index_test_time_idx2; DROP INDEX index_test_time_device_idx; -- Index should have been dropped SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | -- Create index with long name to see how this is handled on chunks CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates ON index_test (time DESC, temp); CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2 ON index_test (time DESC, temp DESC); SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ a_hypertable_index_with_a_very_very_long_name_that_truncates | {time,temp} | | f | f | f | a_hypertable_index_with_a_very_very_long_name_that_truncates_2 | {time,temp} | | f | f | f | index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+---------------------------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_a_hypertable_index_with_a_very_very_long_name_ | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_a_hypertable_index_with_a_very_very_long_nam_1 | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_a_hypertable_index_with_a_very_very_long_name_ | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_a_hypertable_index_with_a_very_very_long_nam_1 | {time,temp} | | f | f | f | DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates; DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2; \set ON_ERROR_STOP 0 -- Create index CONCURRENTLY CREATE UNIQUE INDEX CONCURRENTLY index_test_time_device_idx ON index_test (time, device); ERROR: hypertables do not support concurrent index creation \set ON_ERROR_STOP 1 -- Test tablespaces. Chunk indexes should end up in same tablespace as -- main index. \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; SET client_min_messages = NOTICE; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE INDEX index_test_time_idx ON index_test (time) TABLESPACE tablespace1; SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------- index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_idx | {time} | | f | f | f | tablespace1 index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_idx | {time} | | f | f | f | tablespace1 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ALTER INDEX index_test_time_idx SET TABLESPACE tablespace2; SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------- index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_idx | {time} | | f | f | f | tablespace2 index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_idx | {time} | | f | f | f | tablespace2 _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_idx | {time} | | f | f | f | tablespace2 -- Add constraint index ALTER TABLE index_test ADD UNIQUE (time, device); SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------- index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_device_key | {time,device} | | t | f | f | index_test_time_idx | {time} | | f | f | f | tablespace2 index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal._hyper_4_3_chunk_index_test_time_idx | {time} | | f | f | f | tablespace2 _timescaledb_internal._hyper_4_3_chunk | _timescaledb_internal."3_1_index_test_time_device_key" | {time,device} | | t | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal._hyper_4_4_chunk_index_test_time_idx | {time} | | f | f | f | tablespace2 _timescaledb_internal._hyper_4_4_chunk | _timescaledb_internal."4_2_index_test_time_device_key" | {time,device} | | t | f | f | -- Constraints are added to chunk_constraint table. SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+--------------------------------+---------------------------- 3 | 3 | constraint_3 | 3 | 4 | constraint_4 | 4 | 5 | constraint_5 | 4 | 4 | constraint_4 | 3 | | 3_1_index_test_time_device_key | index_test_time_device_key 4 | | 4_2_index_test_time_device_key | index_test_time_device_key DROP TABLE index_test; -- Create table in a tablespace CREATE TABLE index_test(time timestamptz, temp float, device int) TABLESPACE tablespace1; -- Default indexes should be in the table's tablespace SELECT create_hypertable('index_test', 'time'); create_hypertable ------------------------- (5,public,index_test,t) -- Explicitly defining an index tablespace should work and propagate -- to chunks CREATE INDEX ON index_test (time, device) TABLESPACE tablespace2; -- New indexes without explicit tablespaces should use the default -- tablespace CREATE INDEX ON index_test (device); -- Create chunk INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 17.5); -- Check that the tablespaces of chunk indexes match the tablespace of -- the main index SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------- index_test_device_idx | {device} | | f | f | f | index_test_time_device_idx | {time,device} | | f | f | f | tablespace2 index_test_time_idx | {time} | | f | f | f | tablespace1 SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_time_device_idx | {time,device} | | f | f | f | tablespace2 _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_device_idx | {device} | | f | f | f | tablespace1 -- Creating a new index should propagate to existing chunks, including -- the given tablespace CREATE INDEX ON index_test (time, temp) TABLESPACE tablespace2; SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------- index_test_device_idx | {device} | | f | f | f | index_test_time_device_idx | {time,device} | | f | f | f | tablespace2 index_test_time_idx | {time} | | f | f | f | tablespace1 index_test_time_temp_idx | {time,temp} | | f | f | f | tablespace2 SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_time_device_idx | {time,device} | | f | f | f | tablespace2 _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_device_idx | {device} | | f | f | f | tablespace1 _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal._hyper_5_5_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | tablespace2 -- Cleanup DROP TABLE index_test CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Test expression indexes CREATE TABLE index_expr_test(id serial, time timestamptz, temp float, meta jsonb); -- Screw up the attribute numbers ALTER TABLE index_expr_test DROP COLUMN id; CREATE INDEX ON index_expr_test ((meta ->> 'field')) ; INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, '{"field": "value1"}'); INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, '{"field": "value2"}'); EXPLAIN (verbose, buffers off, costs off) SELECT * FROM index_expr_test WHERE meta ->> 'field' = 'value1'; --- QUERY PLAN --- Index Scan using index_expr_test_expr_idx on public.index_expr_test Output: "time", temp, meta Index Cond: ((index_expr_test.meta ->> 'field'::text) = 'value1'::text) SELECT * FROM index_expr_test WHERE meta ->> 'field' = 'value1'; time | temp | meta ------------------------------+------+--------------------- Fri Jan 20 09:00:01 2017 PST | 17.5 | {"field": "value1"} -- Test INDEX DROP error for multiple objects CREATE TABLE index_test(time timestamptz, temp float); CREATE UNIQUE INDEX index_test_idx ON index_test (time, temp); SELECT create_hypertable('index_test', 'time'); create_hypertable ------------------------- (6,public,index_test,t) CREATE TABLE index_test_2(time timestamptz, temp float); CREATE UNIQUE INDEX index_test_2_idx ON index_test_2 (time, temp); \set ON_ERROR_STOP 0 DROP INDEX index_test_idx, index_test_2_idx; \set ON_ERROR_STOP 1 -- test expression index with dropped columns CREATE TABLE idx_expr_test(filler int, time timestamptz, meta text); SELECT table_name FROM create_hypertable('idx_expr_test', 'time'); table_name --------------- idx_expr_test ALTER TABLE idx_expr_test DROP COLUMN filler; CREATE INDEX tag_idx ON idx_expr_test(('foo'||meta)); INSERT INTO idx_expr_test(time, meta) VALUES ('2000-01-01', 'bar'); DROP TABLE idx_expr_test CASCADE; -- test multicolumn expression index with dropped columns CREATE TABLE idx_expr_test(filler int, time timestamptz, t1 text, t2 text, t3 text); SELECT table_name FROM create_hypertable('idx_expr_test', 'time'); table_name --------------- idx_expr_test ALTER TABLE idx_expr_test DROP COLUMN filler; CREATE INDEX tag_idx ON idx_expr_test((t1||t2||t3)); INSERT INTO idx_expr_test(time, t1, t2, t3) VALUES ('2000-01-01', 'foo', 'bar', 'baz'); DROP TABLE idx_expr_test CASCADE; -- test index with predicate and dropped columns CREATE TABLE idx_predicate_test(filler int, time timestamptz); SELECT table_name FROM create_hypertable('idx_predicate_test', 'time'); table_name -------------------- idx_predicate_test ALTER TABLE idx_predicate_test DROP COLUMN filler; ALTER TABLE idx_predicate_test ADD COLUMN b1 bool; CREATE INDEX idx_predicate_test_b1 ON idx_predicate_test(b1) WHERE b1=true; INSERT INTO idx_predicate_test VALUES ('2000-01-01',true); DROP TABLE idx_predicate_test; -- test index with table references CREATE TABLE idx_tableref_test(time timestamptz); SELECT table_name FROM create_hypertable('idx_tableref_test', 'time'); table_name ------------------- idx_tableref_test -- we use security definer to prevent function inlining CREATE OR REPLACE FUNCTION tableref_func(t idx_tableref_test) RETURNS timestamptz LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $f$ SELECT t.time; $f$; -- try creating index with no existing chunks CREATE INDEX tableref_idx ON idx_tableref_test(tableref_func(idx_tableref_test)); -- insert data to trigger chunk creation INSERT INTO idx_tableref_test SELECT '2000-01-01'; DROP INDEX tableref_idx; -- try creating index on hypertable with existing chunks CREATE INDEX tableref_idx ON idx_tableref_test(tableref_func(idx_tableref_test)); -- test index creation with if not exists CREATE TABLE idx_exists(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('idx_exists', 'time'); table_name ------------ idx_exists -- should be skipped since this index was already created by create_hypertable CREATE INDEX IF NOT EXISTS idx_exists_time_idx ON idx_exists(time DESC); NOTICE: relation "idx_exists_time_idx" already exists, skipping -- should create index CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); -- should be skipped since it was created in previous command CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); NOTICE: relation "idx_exists_time_asc_idx" already exists, skipping DROP INDEX idx_exists_time_asc_idx; INSERT INTO idx_exists VALUES ('2000-01-01'),('2001-01-01'); -- should create index CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); -- should be skipped since it was created in previous command CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); NOTICE: relation "idx_exists_time_asc_idx" already exists, skipping -- test reindex CREATE TABLE reindex_test(time timestamp, temp float, PRIMARY KEY(time, temp)); CREATE UNIQUE INDEX reindex_test_time_unique_idx ON reindex_test(time); -- create hypertable with three chunks SELECT create_hypertable('reindex_test', 'time', chunk_time_interval => 2628000000000); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------- (12,public,reindex_test,t) INSERT INTO reindex_test VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); SELECT * FROM test.show_columns('reindex_test'); Column | Type | NotNull --------+-----------------------------+--------- time | timestamp without time zone | t temp | double precision | t SELECT * FROM test.show_subtables('reindex_test'); Child | Tablespace ------------------------------------------+------------ _timescaledb_internal._hyper_12_12_chunk | _timescaledb_internal._hyper_12_13_chunk | _timescaledb_internal._hyper_12_14_chunk | _timescaledb_internal._hyper_12_15_chunk | _timescaledb_internal._hyper_12_16_chunk | -- show reindexing REINDEX (VERBOSE) TABLE reindex_test; INFO: index "12_3_reindex_test_pkey" was reindexed INFO: index "_hyper_12_12_chunk_reindex_test_time_unique_idx" was reindexed INFO: index "13_4_reindex_test_pkey" was reindexed INFO: index "_hyper_12_13_chunk_reindex_test_time_unique_idx" was reindexed INFO: index "14_5_reindex_test_pkey" was reindexed INFO: index "_hyper_12_14_chunk_reindex_test_time_unique_idx" was reindexed INFO: index "15_6_reindex_test_pkey" was reindexed INFO: index "_hyper_12_15_chunk_reindex_test_time_unique_idx" was reindexed INFO: index "16_7_reindex_test_pkey" was reindexed INFO: index "_hyper_12_16_chunk_reindex_test_time_unique_idx" was reindexed \set ON_ERROR_STOP 0 -- REINDEX TABLE CONCURRENTLY on hypertables is not supported REINDEX TABLE CONCURRENTLY reindex_test; ERROR: concurrent index creation on hypertables is not supported -- this one currently doesn't recurse to chunks and instead gives an -- error REINDEX (VERBOSE) INDEX reindex_test_time_unique_idx; ERROR: reindexing of a specific index on a hypertable is unsupported \set ON_ERROR_STOP 1 -- show reindexing on a normal table CREATE TABLE reindex_norm(time timestamp, temp float); CREATE UNIQUE INDEX reindex_norm_time_unique_idx ON reindex_norm(time); INSERT INTO reindex_norm VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); REINDEX (VERBOSE) TABLE reindex_norm; INFO: index "reindex_norm_time_unique_idx" was reindexed REINDEX (VERBOSE) INDEX reindex_norm_time_unique_idx; INFO: index "reindex_norm_time_unique_idx" was reindexed SELECT * FROM test.show_constraintsp('_timescaledb_internal._hyper_12%'); Table | Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ------------------------------------------+------------------------+------+-------------+------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- _timescaledb_internal._hyper_12_12_chunk | 12_3_reindex_test_pkey | p | {time,temp} | _timescaledb_internal."12_3_reindex_test_pkey" | | f | f | t _timescaledb_internal._hyper_12_12_chunk | constraint_13 | c | {time} | - | (("time" >= 'Thu Jan 19 10:00:00 2017'::timestamp without time zone) AND ("time" < 'Sat Feb 18 20:00:00 2017'::timestamp without time zone)) | f | f | t _timescaledb_internal._hyper_12_13_chunk | 13_4_reindex_test_pkey | p | {time,temp} | _timescaledb_internal."13_4_reindex_test_pkey" | | f | f | t _timescaledb_internal._hyper_12_13_chunk | constraint_14 | c | {time} | - | (("time" >= 'Tue Mar 21 06:00:00 2017'::timestamp without time zone) AND ("time" < 'Thu Apr 20 16:00:00 2017'::timestamp without time zone)) | f | f | t _timescaledb_internal._hyper_12_14_chunk | 14_5_reindex_test_pkey | p | {time,temp} | _timescaledb_internal."14_5_reindex_test_pkey" | | f | f | t _timescaledb_internal._hyper_12_14_chunk | constraint_15 | c | {time} | - | (("time" >= 'Thu Apr 20 16:00:00 2017'::timestamp without time zone) AND ("time" < 'Sun May 21 02:00:00 2017'::timestamp without time zone)) | f | f | t _timescaledb_internal._hyper_12_15_chunk | 15_6_reindex_test_pkey | p | {time,temp} | _timescaledb_internal."15_6_reindex_test_pkey" | | f | f | t _timescaledb_internal._hyper_12_15_chunk | constraint_16 | c | {time} | - | (("time" >= 'Sun May 21 02:00:00 2017'::timestamp without time zone) AND ("time" < 'Tue Jun 20 12:00:00 2017'::timestamp without time zone)) | f | f | t _timescaledb_internal._hyper_12_16_chunk | 16_7_reindex_test_pkey | p | {time,temp} | _timescaledb_internal."16_7_reindex_test_pkey" | | f | f | t _timescaledb_internal._hyper_12_16_chunk | constraint_17 | c | {time} | - | (("time" >= 'Tue Jun 20 12:00:00 2017'::timestamp without time zone) AND ("time" < 'Thu Jul 20 22:00:00 2017'::timestamp without time zone)) | f | f | t SELECT * FROM reindex_norm; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 17.5 Sat Jan 21 09:00:01 2017 | 19.1 Thu Apr 20 09:00:01 2017 | 89.5 Fri Apr 21 09:00:01 2017 | 17.1 Tue Jun 20 09:00:01 2017 | 18.5 Wed Jun 21 09:00:01 2017 | 11 CREATE TABLE ht_dropped(time timestamptz, d0 int, d1 int, c0 int, c1 int, c2 int); SELECT create_hypertable('ht_dropped','time'); create_hypertable -------------------------- (13,public,ht_dropped,t) INSERT INTO ht_dropped(time,c0,c1,c2) SELECT '2000-01-01',1,2,3; ALTER TABLE ht_dropped DROP COLUMN d0; INSERT INTO ht_dropped(time,c0,c1,c2) SELECT '2001-01-01',1,2,3; ALTER TABLE ht_dropped DROP COLUMN d1; INSERT INTO ht_dropped(time,c0,c1,c2) SELECT '2002-01-01',1,2,3; CREATE INDEX ON ht_dropped(c0,c1,c2) WHERE c1 IS NOT NULL; CREATE INDEX ON ht_dropped(c0,c1,c2) WITH(timescaledb.transaction_per_chunk) WHERE c2 IS NOT NULL; SELECT oid::TEXT AS "Chunk", i.* FROM (SELECT tableoid::REGCLASS FROM ht_dropped GROUP BY tableoid) ch (oid) LEFT JOIN LATERAL ( SELECT * FROM test.show_indexes (ch.oid)) i ON TRUE ORDER BY 1, 2; Chunk | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------+-------------------------------------------------------------------+------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_13_17_chunk | _timescaledb_internal._hyper_13_17_chunk_ht_dropped_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_13_17_chunk | _timescaledb_internal._hyper_13_17_chunk_ht_dropped_c0_c1_c2_idx | {c0,c1,c2} | | f | f | f | _timescaledb_internal._hyper_13_17_chunk | _timescaledb_internal._hyper_13_17_chunk_ht_dropped_c0_c1_c2_idx1 | {c0,c1,c2} | | f | f | f | _timescaledb_internal._hyper_13_18_chunk | _timescaledb_internal._hyper_13_18_chunk_ht_dropped_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_13_18_chunk | _timescaledb_internal._hyper_13_18_chunk_ht_dropped_c0_c1_c2_idx | {c0,c1,c2} | | f | f | f | _timescaledb_internal._hyper_13_18_chunk | _timescaledb_internal._hyper_13_18_chunk_ht_dropped_c0_c1_c2_idx1 | {c0,c1,c2} | | f | f | f | _timescaledb_internal._hyper_13_19_chunk | _timescaledb_internal._hyper_13_19_chunk_ht_dropped_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_13_19_chunk | _timescaledb_internal._hyper_13_19_chunk_ht_dropped_c0_c1_c2_idx | {c0,c1,c2} | | f | f | f | _timescaledb_internal._hyper_13_19_chunk | _timescaledb_internal._hyper_13_19_chunk_ht_dropped_c0_c1_c2_idx1 | {c0,c1,c2} | | f | f | f | -- #3056 check chunk index column name mapping CREATE TABLE i3056(c int, order_number int NOT NULL, date_created timestamptz NOT NULL); CREATE INDEX ON i3056(order_number) INCLUDE(order_number); CREATE INDEX ON i3056(date_created, (order_number % 5)) INCLUDE(order_number); SELECT table_name FROM create_hypertable('i3056', 'date_created'); table_name ------------ i3056 ALTER TABLE i3056 DROP COLUMN c; INSERT INTO i3056(order_number,date_created) VALUES (1, '2000-01-01'); -- #5908 test CREATE INDEX ON ONLY main table CREATE TABLE test(time timestamptz, temp float); SELECT create_hypertable('test', 'time'); create_hypertable -------------------- (15,public,test,t) INSERT INTO test (time,temp) VALUES (generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::float); SELECT * FROM show_chunks('test'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_15_21_chunk _timescaledb_internal._hyper_15_22_chunk SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_15_21_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_15_21_chunk_test_time_idx | {time} | | f | f | f | -- create index per chunk CREATE INDEX _hyper_15_21_chunk_test_temp_idx ON _timescaledb_internal._hyper_15_21_chunk(temp); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_15_21_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_15_21_chunk_test_temp_idx | {temp} | | f | f | f | _timescaledb_internal._hyper_15_21_chunk_test_time_idx | {time} | | f | f | f | SELECT * FROM test.show_indexes('test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------+---------+------+--------+---------+-----------+------------ test_time_idx | {time} | | f | f | f | -- create index only on main table CREATE INDEX test_temp_idx ON ONLY test (time); SELECT * FROM test.show_indexes('test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------+---------+------+--------+---------+-----------+------------ test_temp_idx | {time} | | f | f | f | test_time_idx | {time} | | f | f | f | SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_15_21_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace --------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_15_21_chunk_test_temp_idx | {temp} | | f | f | f | _timescaledb_internal._hyper_15_21_chunk_test_time_idx | {time} | | f | f | f | ������������������������������������������������������������timescaledb-2.23.0/test/expected/information_views.out����������������������������������������������0000664�0000000�0000000�00000026251�15100345067�0023134�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT * FROM timescaledb_information.hypertables; hypertable_schema | hypertable_name | owner | num_dimensions | num_chunks | compression_enabled | tablespaces | primary_dimension | primary_dimension_type -------------------+-----------------+-------+----------------+------------+---------------------+-------------+-------------------+------------------------ -- create simple hypertable with 1 chunk CREATE TABLE ht1(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('ht1','time'); create_hypertable ------------------- (1,public,ht1,t) INSERT INTO ht1 SELECT '2000-01-01'::TIMESTAMPTZ; -- create simple hypertable with 1 chunk and toasted data CREATE TABLE ht2(time TIMESTAMPTZ NOT NULL, data TEXT); SELECT create_hypertable('ht2','time'); create_hypertable ------------------- (2,public,ht2,t) INSERT INTO ht2 SELECT '2000-01-01'::TIMESTAMPTZ, repeat('8k',4096); SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; hypertable_schema | hypertable_name | owner | num_dimensions | num_chunks | compression_enabled | tablespaces | primary_dimension | primary_dimension_type -------------------+-----------------+-------------------+----------------+------------+---------------------+-------------+-------------------+-------------------------- public | ht1 | default_perm_user | 1 | 1 | f | | time | timestamp with time zone public | ht2 | default_perm_user | 1 | 1 | f | | time | timestamp with time zone \c :TEST_DBNAME :ROLE_SUPERUSER -- create schema open and hypertable with 3 chunks CREATE SCHEMA open; GRANT USAGE ON SCHEMA open TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE open.open_ht(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('open.open_ht','time'); create_hypertable -------------------- (3,open,open_ht,t) INSERT INTO open.open_ht SELECT '2000-01-01'::TIMESTAMPTZ; INSERT INTO open.open_ht SELECT '2001-01-01'::TIMESTAMPTZ; INSERT INTO open.open_ht SELECT '2002-01-01'::TIMESTAMPTZ; -- create schema closed and hypertable CREATE SCHEMA closed; CREATE TABLE closed.closed_ht(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('closed.closed_ht','time'); create_hypertable ------------------------ (4,closed,closed_ht,t) INSERT INTO closed.closed_ht SELECT '2000-01-01'::TIMESTAMPTZ; SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; hypertable_schema | hypertable_name | owner | num_dimensions | num_chunks | compression_enabled | tablespaces | primary_dimension | primary_dimension_type -------------------+-----------------+-------------------+----------------+------------+---------------------+-------------+-------------------+-------------------------- closed | closed_ht | super_user | 1 | 1 | f | | time | timestamp with time zone open | open_ht | super_user | 1 | 3 | f | | time | timestamp with time zone public | ht1 | default_perm_user | 1 | 1 | f | | time | timestamp with time zone public | ht2 | default_perm_user | 1 | 1 | f | | time | timestamp with time zone \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 0 \x SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; -[ RECORD 1 ]----------+------------------------- hypertable_schema | closed hypertable_name | closed_ht owner | super_user num_dimensions | 1 num_chunks | 1 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -[ RECORD 2 ]----------+------------------------- hypertable_schema | open hypertable_name | open_ht owner | super_user num_dimensions | 1 num_chunks | 3 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -[ RECORD 3 ]----------+------------------------- hypertable_schema | public hypertable_name | ht1 owner | default_perm_user num_dimensions | 1 num_chunks | 1 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -[ RECORD 4 ]----------+------------------------- hypertable_schema | public hypertable_name | ht2 owner | default_perm_user num_dimensions | 1 num_chunks | 1 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -- filter by schema SELECT * FROM timescaledb_information.hypertables WHERE hypertable_schema = 'closed' ORDER BY hypertable_schema, hypertable_name; -[ RECORD 1 ]----------+------------------------- hypertable_schema | closed hypertable_name | closed_ht owner | super_user num_dimensions | 1 num_chunks | 1 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -- filter by table name SELECT * FROM timescaledb_information.hypertables WHERE hypertable_name = 'ht1' ORDER BY hypertable_schema, hypertable_name; -[ RECORD 1 ]----------+------------------------- hypertable_schema | public hypertable_name | ht1 owner | default_perm_user num_dimensions | 1 num_chunks | 1 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -- filter by owner SELECT * FROM timescaledb_information.hypertables WHERE owner = 'super_user' ORDER BY hypertable_schema, hypertable_name; -[ RECORD 1 ]----------+------------------------- hypertable_schema | closed hypertable_name | closed_ht owner | super_user num_dimensions | 1 num_chunks | 1 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -[ RECORD 2 ]----------+------------------------- hypertable_schema | open hypertable_name | open_ht owner | super_user num_dimensions | 1 num_chunks | 3 compression_enabled | f tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone \x ---Add integer table -- CREATE TABLE test_table_int(time bigint, junk int); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (5,public,test_table_int,t) CREATE OR REPLACE function table_int_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; SELECT set_integer_now_func('test_table_int', 'table_int_now'); set_integer_now_func ---------------------- INSERT into test_table_int SELECT generate_series( 1, 20), 100; \d timescaledb_information.chunks View "timescaledb_information.chunks" Column | Type | Collation | Nullable | Default ------------------------+--------------------------+-----------+----------+--------- hypertable_schema | name | | | hypertable_name | name | | | chunk_schema | name | | | chunk_name | name | | | primary_dimension | name | | | primary_dimension_type | regtype | | | range_start | timestamp with time zone | | | range_end | timestamp with time zone | | | range_start_integer | bigint | | | range_end_integer | bigint | | | is_compressed | boolean | | | chunk_tablespace | name | | | chunk_creation_time | timestamp with time zone | | | SELECT hypertable_schema, hypertable_name, chunk_schema, chunk_name, primary_dimension, primary_dimension_type, range_start, range_end, range_start_integer, range_end_integer, is_compressed, chunk_tablespace, data_nodes FROM timescaledb_information.chunks WHERE hypertable_name = 'ht1' ORDER BY chunk_name; ERROR: column "data_nodes" does not exist at character 294 SELECT hypertable_schema, hypertable_name, chunk_schema, chunk_name, primary_dimension, primary_dimension_type, range_start, range_end, range_start_integer, range_end_integer, is_compressed, chunk_tablespace, data_nodes FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int' ORDER BY chunk_name; ERROR: column "data_nodes" does not exist at character 294 \x SELECT * FROM timescaledb_information.dimensions ORDER BY hypertable_name, dimension_number; -[ RECORD 1 ]-----+------------------------- hypertable_schema | closed hypertable_name | closed_ht dimension_number | 1 column_name | time column_type | timestamp with time zone dimension_type | Time time_interval | @ 7 days integer_interval | integer_now_func | num_partitions | -[ RECORD 2 ]-----+------------------------- hypertable_schema | public hypertable_name | ht1 dimension_number | 1 column_name | time column_type | timestamp with time zone dimension_type | Time time_interval | @ 7 days integer_interval | integer_now_func | num_partitions | -[ RECORD 3 ]-----+------------------------- hypertable_schema | public hypertable_name | ht2 dimension_number | 1 column_name | time column_type | timestamp with time zone dimension_type | Time time_interval | @ 7 days integer_interval | integer_now_func | num_partitions | -[ RECORD 4 ]-----+------------------------- hypertable_schema | open hypertable_name | open_ht dimension_number | 1 column_name | time column_type | timestamp with time zone dimension_type | Time time_interval | @ 7 days integer_interval | integer_now_func | num_partitions | -[ RECORD 5 ]-----+------------------------- hypertable_schema | public hypertable_name | test_table_int dimension_number | 1 column_name | time column_type | bigint dimension_type | Time time_interval | integer_interval | 10 integer_now_func | table_int_now num_partitions | \x �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/insert-15.out������������������������������������������������������0000664�0000000�0000000�00000115526�15100345067�0021125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET enable_seqscan TO off; \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 1 | public | two_Partitions | t \set QUIET off BEGIN; BEGIN \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); Relation | Kind | Column | Column type | NotNull ------------------------------------------------------------------------------------+------+-------------+------------------+--------- _timescaledb_internal._hyper_1_1_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_1_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_1_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_2_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_2_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_2_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_3_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_3_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_3_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_4_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_4_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_4_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------------------------+--------------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | SELECT * FROM ONLY "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ------------+-----------+----------+----------+----------+------------- CREATE TABLE error_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('error_test', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (2,public,error_test,t) \set QUIET off INSERT INTO error_test VALUES ('Mon Mar 20 09:18:20.1 2017', 21.3, 'dev1'); INSERT 0 1 \set ON_ERROR_STOP 0 -- generate insert error INSERT INTO error_test VALUES ('Mon Mar 20 09:18:22.3 2017', 21.1, NULL); ERROR: null value in column "device" of relation "_hyper_2_6_chunk" violates not-null constraint \set ON_ERROR_STOP 1 INSERT INTO error_test VALUES ('Mon Mar 20 09:18:25.7 2017', 22.4, 'dev2'); INSERT 0 1 \set QUIET on SELECT * FROM error_test; time | temp | device ----------------------------+------+-------- Mon Mar 20 09:18:20.1 2017 | 21.3 | dev1 Mon Mar 20 09:18:25.7 2017 | 22.4 | dev2 --test character(9) partition keys since there were issues with padding causing partitioning errors CREATE TABLE tick_character ( symbol character(9) NOT NULL, mid REAL NOT NULL, spread REAL NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('tick_character', 'time', 'symbol', 2); create_hypertable ----------------------------- (3,public,tick_character,t) INSERT INTO tick_character ( symbol, mid, spread, time ) VALUES ( 'GBPJPY', 142.639000, 5.80, 'Mon Mar 20 09:18:22.3 2017') RETURNING time, symbol, mid; time | symbol | mid --------------------------------+-----------+--------- Mon Mar 20 09:18:22.3 2017 PDT | GBPJPY | 142.639 SELECT * FROM tick_character; symbol | mid | spread | time -----------+---------+--------+-------------------------------- GBPJPY | 142.639 | 5.8 | Mon Mar 20 09:18:22.3 2017 PDT CREATE TABLE date_col_test(time date, temp float8, device text NOT NULL); SELECT create_hypertable('date_col_test', 'time', 'device', 1000, chunk_time_interval => INTERVAL '1 Day'); create_hypertable ---------------------------- (4,public,date_col_test,t) INSERT INTO date_col_test VALUES ('2001-02-01', 98, 'dev1'), ('2001-03-02', 98, 'dev1'); SELECT * FROM date_col_test WHERE time > '2001-01-01'; time | temp | device ------------+------+-------- 02-01-2001 | 98 | dev1 03-02-2001 | 98 | dev1 -- Out-of-order insertion regression test. -- this used to trip an assert in subspace_store.c checking that -- max_open_chunks_per_insert was obeyed set timescaledb.max_open_chunks_per_insert=1; CREATE TABLE chunk_assert_fail(i bigint, j bigint); SELECT create_hypertable('chunk_assert_fail', 'i', 'j', 1000, chunk_time_interval=>1); create_hypertable -------------------------------- (5,public,chunk_assert_fail,t) insert into chunk_assert_fail values (1, 1), (1, 2), (2,1); select * from chunk_assert_fail; i | j ---+--- 1 | 1 1 | 2 2 | 1 CREATE TABLE one_space_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('one_space_test', 'time', 'device', 1); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------- (6,public,one_space_test,t) INSERT INTO one_space_test VALUES ('2001-01-01 01:01:01', 1.0, 'device'), ('2002-01-01 01:02:01', 1.0, 'device'); SELECT * FROM one_space_test; time | temp | device --------------------------+------+-------- Mon Jan 01 01:01:01 2001 | 1 | device Tue Jan 01 01:02:01 2002 | 1 | device --CTE & EXPLAIN ANALYZE TESTS WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:02:01', 1.0, 'device') RETURNING *) SELECT * FROM insert_cte; time | temp | device --------------------------+------+-------- Mon Jan 01 01:02:01 2001 | 1 | device EXPLAIN (analyze, buffers off, costs off, timing off) --can't turn summary off in 9.6 so instead grep it away at end. WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:03:01', 1.0, 'device') ) SELECT 1 \g | grep -v "Planning" | grep -v "Execution" --- QUERY PLAN --- Result (actual rows=1.00 loops=1) CTE insert_cte -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on one_space_test (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) -- INSERTs can exclude chunks based on constraints EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Only Scan using _hyper_5_11_chunk_chunk_assert_fail_j_i_idx on _hyper_5_11_chunk -> Index Only Scan using _hyper_5_12_chunk_chunk_assert_fail_j_i_idx on _hyper_5_12_chunk -> Index Only Scan using _hyper_5_13_chunk_chunk_assert_fail_j_i_idx on _hyper_5_13_chunk EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i < 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Scan using _hyper_5_11_chunk_chunk_assert_fail_i_idx on _hyper_5_11_chunk Index Cond: (i = 1) -> Index Scan using _hyper_5_12_chunk_chunk_assert_fail_i_idx on _hyper_5_12_chunk Index Cond: (i = 1) EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Index Scan using _hyper_5_13_chunk_chunk_assert_fail_i_idx on _hyper_5_13_chunk Index Cond: (i > 1) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; CREATE TABLE timestamp_inf(time TIMESTAMP); SELECT create_hypertable('timestamp_inf', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------- (7,public,timestamp_inf,t) INSERT INTO timestamp_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) CREATE TABLE date_inf(time DATE); SELECT create_hypertable('date_inf', 'time'); create_hypertable ----------------------- (8,public,date_inf,t) INSERT INTO date_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" < 'infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" < 'infinity'::date) EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" > '-infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" > '-infinity'::date) -- test INSERT with cached plans / plpgsql functions -- https://github.com/timescale/timescaledb/issues/1809 CREATE TABLE status_table(a int, b int, last_ts timestamptz, UNIQUE(a,b)); CREATE TABLE metrics(time timestamptz NOT NULL, value float); CREATE TABLE metrics2(time timestamptz NOT NULL, value float); SELECT (create_hypertable(t,'time')).table_name FROM (VALUES ('metrics'),('metrics2')) v(t); table_name ------------ metrics metrics2 INSERT INTO metrics VALUES ('2000-01-01',random()), ('2000-02-01',random()), ('2000-03-01',random()); CREATE OR REPLACE FUNCTION insert_test() RETURNS VOID LANGUAGE plpgsql AS $$ DECLARE r RECORD; BEGIN FOR r IN SELECT * FROM metrics LOOP WITH foo AS ( INSERT INTO metrics2 SELECT * FROM metrics RETURNING * ) INSERT INTO status_table (a,b, last_ts) VALUES (1,1, now()) ON CONFLICT (a,b) DO UPDATE SET last_ts=(SELECT max(time) FROM metrics); END LOOP; END; $$; SELECT insert_test(), insert_test(), insert_test(); insert_test | insert_test | insert_test -------------+-------------+------------- | | -- test Postgres crashes on INSERT ... SELECT ... WHERE NOT EXISTS with empty table -- https://github.com/timescale/timescaledb/issues/1883 CREATE TABLE readings ( toe TIMESTAMPTZ NOT NULL, sensor_id INT NOT NULL, value INT NOT NULL ); SELECT create_hypertable( 'readings', 'toe', chunk_time_interval => interval '1 day', if_not_exists => TRUE, migrate_data => TRUE ); create_hypertable ------------------------ (11,public,readings,t) EXPLAIN (buffers off, costs off) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); --- QUERY PLAN --- Custom Scan (ModifyHypertable) InitPlan 1 (returns $0) -> Result One-Time Filter: false -> Insert on readings -> Result One-Time Filter: (NOT $0) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); DROP TABLE readings; CREATE TABLE sample_table ( sequence INTEGER NOT NULL, time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value NUMERIC NOT NULL, UNIQUE (sequence, time) ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '1 day'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 12 | public | sample_table | t INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); \set ON_ERROR_STOP 0 INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-07-21', TIMESTAMP '2019-08-01', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); ERROR: duplicate key value violates unique constraint "27_1_sample_table_sequence_time_key" \set ON_ERROR_STOP 1 INSERT INTO sample_table (sequence,time,value) VALUES (7,generate_series(TIMESTAMP '2019-01-01', TIMESTAMP '2019-07-01', '10 minutes'), ROUND(RANDOM()*10)::int); DROP TABLE sample_table; -- test on conflict clause on columns with default value -- issue #3037 CREATE TABLE i3037(time timestamptz PRIMARY KEY); SELECT create_hypertable('i3037','time'); create_hypertable --------------------- (13,public,i3037,t) ALTER TABLE i3037 ADD COLUMN value float DEFAULT 0; INSERT INTO i3037 VALUES ('2000-01-01'); INSERT INTO i3037 VALUES ('2000-01-01') ON CONFLICT(time) DO UPDATE SET value = EXCLUDED.value; -- test inserting into chunks directly CREATE TABLE direct_insert(time timestamptz, meta text) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO direct_insert VALUES ('2020-01-01'); SELECT show_chunks('direct_insert') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) INSERT INTO :CHUNK VALUES ('2020-01-01'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on _hyper_14_231_chunk -> Result -- correct time range should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; time | meta ------------------------------+------ Wed Jan 01 00:00:00 2020 PST | -- incorrect time range should fail \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2020-01-01'), ('2021-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint INSERT INTO :CHUNK VALUES ('2025-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint \set ON_ERROR_STOP 1 -- test that triggers on chunks work CREATE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'trigger called'; NEW.meta = 'triggered'; RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_trigger BEFORE INSERT ON direct_insert FOR EACH ROW EXECUTE PROCEDURE test_trigger(); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- test upsert DELETE FROM direct_insert; ALTER TABLE direct_insert ADD CONSTRAINT direct_insert_pkey PRIMARY KEY (time); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- DO NOTHING should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT DO NOTHING RETURNING *; NOTICE: trigger called time | meta ------+------ INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET meta = 'update' RETURNING *; NOTICE: trigger called time | meta ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | update \set ON_ERROR_STOP 0 -- conflict should fail INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called ERROR: duplicate key value violates unique constraint "231_205_direct_insert_pkey" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = '2000-01-01' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = EXCLUDED.time + '1 year' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/insert-16.out������������������������������������������������������0000664�0000000�0000000�00000115526�15100345067�0021126�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET enable_seqscan TO off; \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 1 | public | two_Partitions | t \set QUIET off BEGIN; BEGIN \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); Relation | Kind | Column | Column type | NotNull ------------------------------------------------------------------------------------+------+-------------+------------------+--------- _timescaledb_internal._hyper_1_1_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_1_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_1_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_2_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_2_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_2_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_3_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_3_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_3_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_4_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_4_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_4_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------------------------+--------------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | SELECT * FROM ONLY "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ------------+-----------+----------+----------+----------+------------- CREATE TABLE error_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('error_test', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (2,public,error_test,t) \set QUIET off INSERT INTO error_test VALUES ('Mon Mar 20 09:18:20.1 2017', 21.3, 'dev1'); INSERT 0 1 \set ON_ERROR_STOP 0 -- generate insert error INSERT INTO error_test VALUES ('Mon Mar 20 09:18:22.3 2017', 21.1, NULL); ERROR: null value in column "device" of relation "_hyper_2_6_chunk" violates not-null constraint \set ON_ERROR_STOP 1 INSERT INTO error_test VALUES ('Mon Mar 20 09:18:25.7 2017', 22.4, 'dev2'); INSERT 0 1 \set QUIET on SELECT * FROM error_test; time | temp | device ----------------------------+------+-------- Mon Mar 20 09:18:20.1 2017 | 21.3 | dev1 Mon Mar 20 09:18:25.7 2017 | 22.4 | dev2 --test character(9) partition keys since there were issues with padding causing partitioning errors CREATE TABLE tick_character ( symbol character(9) NOT NULL, mid REAL NOT NULL, spread REAL NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('tick_character', 'time', 'symbol', 2); create_hypertable ----------------------------- (3,public,tick_character,t) INSERT INTO tick_character ( symbol, mid, spread, time ) VALUES ( 'GBPJPY', 142.639000, 5.80, 'Mon Mar 20 09:18:22.3 2017') RETURNING time, symbol, mid; time | symbol | mid --------------------------------+-----------+--------- Mon Mar 20 09:18:22.3 2017 PDT | GBPJPY | 142.639 SELECT * FROM tick_character; symbol | mid | spread | time -----------+---------+--------+-------------------------------- GBPJPY | 142.639 | 5.8 | Mon Mar 20 09:18:22.3 2017 PDT CREATE TABLE date_col_test(time date, temp float8, device text NOT NULL); SELECT create_hypertable('date_col_test', 'time', 'device', 1000, chunk_time_interval => INTERVAL '1 Day'); create_hypertable ---------------------------- (4,public,date_col_test,t) INSERT INTO date_col_test VALUES ('2001-02-01', 98, 'dev1'), ('2001-03-02', 98, 'dev1'); SELECT * FROM date_col_test WHERE time > '2001-01-01'; time | temp | device ------------+------+-------- 02-01-2001 | 98 | dev1 03-02-2001 | 98 | dev1 -- Out-of-order insertion regression test. -- this used to trip an assert in subspace_store.c checking that -- max_open_chunks_per_insert was obeyed set timescaledb.max_open_chunks_per_insert=1; CREATE TABLE chunk_assert_fail(i bigint, j bigint); SELECT create_hypertable('chunk_assert_fail', 'i', 'j', 1000, chunk_time_interval=>1); create_hypertable -------------------------------- (5,public,chunk_assert_fail,t) insert into chunk_assert_fail values (1, 1), (1, 2), (2,1); select * from chunk_assert_fail; i | j ---+--- 1 | 1 1 | 2 2 | 1 CREATE TABLE one_space_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('one_space_test', 'time', 'device', 1); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------- (6,public,one_space_test,t) INSERT INTO one_space_test VALUES ('2001-01-01 01:01:01', 1.0, 'device'), ('2002-01-01 01:02:01', 1.0, 'device'); SELECT * FROM one_space_test; time | temp | device --------------------------+------+-------- Mon Jan 01 01:01:01 2001 | 1 | device Tue Jan 01 01:02:01 2002 | 1 | device --CTE & EXPLAIN ANALYZE TESTS WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:02:01', 1.0, 'device') RETURNING *) SELECT * FROM insert_cte; time | temp | device --------------------------+------+-------- Mon Jan 01 01:02:01 2001 | 1 | device EXPLAIN (analyze, buffers off, costs off, timing off) --can't turn summary off in 9.6 so instead grep it away at end. WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:03:01', 1.0, 'device') ) SELECT 1 \g | grep -v "Planning" | grep -v "Execution" --- QUERY PLAN --- Result (actual rows=1.00 loops=1) CTE insert_cte -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on one_space_test (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) -- INSERTs can exclude chunks based on constraints EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Only Scan using _hyper_5_11_chunk_chunk_assert_fail_j_i_idx on _hyper_5_11_chunk -> Index Only Scan using _hyper_5_12_chunk_chunk_assert_fail_j_i_idx on _hyper_5_12_chunk -> Index Only Scan using _hyper_5_13_chunk_chunk_assert_fail_j_i_idx on _hyper_5_13_chunk EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i < 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Scan using _hyper_5_11_chunk_chunk_assert_fail_i_idx on _hyper_5_11_chunk Index Cond: (i = 1) -> Index Scan using _hyper_5_12_chunk_chunk_assert_fail_i_idx on _hyper_5_12_chunk Index Cond: (i = 1) EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Index Scan using _hyper_5_13_chunk_chunk_assert_fail_i_idx on _hyper_5_13_chunk Index Cond: (i > 1) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; CREATE TABLE timestamp_inf(time TIMESTAMP); SELECT create_hypertable('timestamp_inf', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------- (7,public,timestamp_inf,t) INSERT INTO timestamp_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) CREATE TABLE date_inf(time DATE); SELECT create_hypertable('date_inf', 'time'); create_hypertable ----------------------- (8,public,date_inf,t) INSERT INTO date_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" < 'infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" < 'infinity'::date) EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" > '-infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" > '-infinity'::date) -- test INSERT with cached plans / plpgsql functions -- https://github.com/timescale/timescaledb/issues/1809 CREATE TABLE status_table(a int, b int, last_ts timestamptz, UNIQUE(a,b)); CREATE TABLE metrics(time timestamptz NOT NULL, value float); CREATE TABLE metrics2(time timestamptz NOT NULL, value float); SELECT (create_hypertable(t,'time')).table_name FROM (VALUES ('metrics'),('metrics2')) v(t); table_name ------------ metrics metrics2 INSERT INTO metrics VALUES ('2000-01-01',random()), ('2000-02-01',random()), ('2000-03-01',random()); CREATE OR REPLACE FUNCTION insert_test() RETURNS VOID LANGUAGE plpgsql AS $$ DECLARE r RECORD; BEGIN FOR r IN SELECT * FROM metrics LOOP WITH foo AS ( INSERT INTO metrics2 SELECT * FROM metrics RETURNING * ) INSERT INTO status_table (a,b, last_ts) VALUES (1,1, now()) ON CONFLICT (a,b) DO UPDATE SET last_ts=(SELECT max(time) FROM metrics); END LOOP; END; $$; SELECT insert_test(), insert_test(), insert_test(); insert_test | insert_test | insert_test -------------+-------------+------------- | | -- test Postgres crashes on INSERT ... SELECT ... WHERE NOT EXISTS with empty table -- https://github.com/timescale/timescaledb/issues/1883 CREATE TABLE readings ( toe TIMESTAMPTZ NOT NULL, sensor_id INT NOT NULL, value INT NOT NULL ); SELECT create_hypertable( 'readings', 'toe', chunk_time_interval => interval '1 day', if_not_exists => TRUE, migrate_data => TRUE ); create_hypertable ------------------------ (11,public,readings,t) EXPLAIN (buffers off, costs off) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); --- QUERY PLAN --- Custom Scan (ModifyHypertable) InitPlan 1 (returns $0) -> Result One-Time Filter: false -> Insert on readings -> Result One-Time Filter: (NOT $0) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); DROP TABLE readings; CREATE TABLE sample_table ( sequence INTEGER NOT NULL, time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value NUMERIC NOT NULL, UNIQUE (sequence, time) ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '1 day'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 12 | public | sample_table | t INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); \set ON_ERROR_STOP 0 INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-07-21', TIMESTAMP '2019-08-01', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); ERROR: duplicate key value violates unique constraint "27_1_sample_table_sequence_time_key" \set ON_ERROR_STOP 1 INSERT INTO sample_table (sequence,time,value) VALUES (7,generate_series(TIMESTAMP '2019-01-01', TIMESTAMP '2019-07-01', '10 minutes'), ROUND(RANDOM()*10)::int); DROP TABLE sample_table; -- test on conflict clause on columns with default value -- issue #3037 CREATE TABLE i3037(time timestamptz PRIMARY KEY); SELECT create_hypertable('i3037','time'); create_hypertable --------------------- (13,public,i3037,t) ALTER TABLE i3037 ADD COLUMN value float DEFAULT 0; INSERT INTO i3037 VALUES ('2000-01-01'); INSERT INTO i3037 VALUES ('2000-01-01') ON CONFLICT(time) DO UPDATE SET value = EXCLUDED.value; -- test inserting into chunks directly CREATE TABLE direct_insert(time timestamptz, meta text) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO direct_insert VALUES ('2020-01-01'); SELECT show_chunks('direct_insert') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) INSERT INTO :CHUNK VALUES ('2020-01-01'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on _hyper_14_231_chunk -> Result -- correct time range should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; time | meta ------------------------------+------ Wed Jan 01 00:00:00 2020 PST | -- incorrect time range should fail \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2020-01-01'), ('2021-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint INSERT INTO :CHUNK VALUES ('2025-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint \set ON_ERROR_STOP 1 -- test that triggers on chunks work CREATE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'trigger called'; NEW.meta = 'triggered'; RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_trigger BEFORE INSERT ON direct_insert FOR EACH ROW EXECUTE PROCEDURE test_trigger(); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- test upsert DELETE FROM direct_insert; ALTER TABLE direct_insert ADD CONSTRAINT direct_insert_pkey PRIMARY KEY (time); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- DO NOTHING should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT DO NOTHING RETURNING *; NOTICE: trigger called time | meta ------+------ INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET meta = 'update' RETURNING *; NOTICE: trigger called time | meta ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | update \set ON_ERROR_STOP 0 -- conflict should fail INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called ERROR: duplicate key value violates unique constraint "231_205_direct_insert_pkey" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = '2000-01-01' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = EXCLUDED.time + '1 year' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/insert-17.out������������������������������������������������������0000664�0000000�0000000�00000115530�15100345067�0021122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET enable_seqscan TO off; \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 1 | public | two_Partitions | t \set QUIET off BEGIN; BEGIN \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); Relation | Kind | Column | Column type | NotNull ------------------------------------------------------------------------------------+------+-------------+------------------+--------- _timescaledb_internal._hyper_1_1_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_1_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_1_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_2_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_2_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_2_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_3_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_3_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_3_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_4_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_4_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_4_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------------------------+--------------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | SELECT * FROM ONLY "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ------------+-----------+----------+----------+----------+------------- CREATE TABLE error_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('error_test', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (2,public,error_test,t) \set QUIET off INSERT INTO error_test VALUES ('Mon Mar 20 09:18:20.1 2017', 21.3, 'dev1'); INSERT 0 1 \set ON_ERROR_STOP 0 -- generate insert error INSERT INTO error_test VALUES ('Mon Mar 20 09:18:22.3 2017', 21.1, NULL); ERROR: null value in column "device" of relation "_hyper_2_6_chunk" violates not-null constraint \set ON_ERROR_STOP 1 INSERT INTO error_test VALUES ('Mon Mar 20 09:18:25.7 2017', 22.4, 'dev2'); INSERT 0 1 \set QUIET on SELECT * FROM error_test; time | temp | device ----------------------------+------+-------- Mon Mar 20 09:18:20.1 2017 | 21.3 | dev1 Mon Mar 20 09:18:25.7 2017 | 22.4 | dev2 --test character(9) partition keys since there were issues with padding causing partitioning errors CREATE TABLE tick_character ( symbol character(9) NOT NULL, mid REAL NOT NULL, spread REAL NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('tick_character', 'time', 'symbol', 2); create_hypertable ----------------------------- (3,public,tick_character,t) INSERT INTO tick_character ( symbol, mid, spread, time ) VALUES ( 'GBPJPY', 142.639000, 5.80, 'Mon Mar 20 09:18:22.3 2017') RETURNING time, symbol, mid; time | symbol | mid --------------------------------+-----------+--------- Mon Mar 20 09:18:22.3 2017 PDT | GBPJPY | 142.639 SELECT * FROM tick_character; symbol | mid | spread | time -----------+---------+--------+-------------------------------- GBPJPY | 142.639 | 5.8 | Mon Mar 20 09:18:22.3 2017 PDT CREATE TABLE date_col_test(time date, temp float8, device text NOT NULL); SELECT create_hypertable('date_col_test', 'time', 'device', 1000, chunk_time_interval => INTERVAL '1 Day'); create_hypertable ---------------------------- (4,public,date_col_test,t) INSERT INTO date_col_test VALUES ('2001-02-01', 98, 'dev1'), ('2001-03-02', 98, 'dev1'); SELECT * FROM date_col_test WHERE time > '2001-01-01'; time | temp | device ------------+------+-------- 02-01-2001 | 98 | dev1 03-02-2001 | 98 | dev1 -- Out-of-order insertion regression test. -- this used to trip an assert in subspace_store.c checking that -- max_open_chunks_per_insert was obeyed set timescaledb.max_open_chunks_per_insert=1; CREATE TABLE chunk_assert_fail(i bigint, j bigint); SELECT create_hypertable('chunk_assert_fail', 'i', 'j', 1000, chunk_time_interval=>1); create_hypertable -------------------------------- (5,public,chunk_assert_fail,t) insert into chunk_assert_fail values (1, 1), (1, 2), (2,1); select * from chunk_assert_fail; i | j ---+--- 1 | 1 1 | 2 2 | 1 CREATE TABLE one_space_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('one_space_test', 'time', 'device', 1); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------- (6,public,one_space_test,t) INSERT INTO one_space_test VALUES ('2001-01-01 01:01:01', 1.0, 'device'), ('2002-01-01 01:02:01', 1.0, 'device'); SELECT * FROM one_space_test; time | temp | device --------------------------+------+-------- Mon Jan 01 01:01:01 2001 | 1 | device Tue Jan 01 01:02:01 2002 | 1 | device --CTE & EXPLAIN ANALYZE TESTS WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:02:01', 1.0, 'device') RETURNING *) SELECT * FROM insert_cte; time | temp | device --------------------------+------+-------- Mon Jan 01 01:02:01 2001 | 1 | device EXPLAIN (analyze, buffers off, costs off, timing off) --can't turn summary off in 9.6 so instead grep it away at end. WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:03:01', 1.0, 'device') ) SELECT 1 \g | grep -v "Planning" | grep -v "Execution" --- QUERY PLAN --- Result (actual rows=1.00 loops=1) CTE insert_cte -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on one_space_test (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) -- INSERTs can exclude chunks based on constraints EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Only Scan using _hyper_5_11_chunk_chunk_assert_fail_j_i_idx on _hyper_5_11_chunk -> Index Only Scan using _hyper_5_12_chunk_chunk_assert_fail_j_i_idx on _hyper_5_12_chunk -> Index Only Scan using _hyper_5_13_chunk_chunk_assert_fail_j_i_idx on _hyper_5_13_chunk EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i < 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Scan using _hyper_5_11_chunk_chunk_assert_fail_i_idx on _hyper_5_11_chunk Index Cond: (i = 1) -> Index Scan using _hyper_5_12_chunk_chunk_assert_fail_i_idx on _hyper_5_12_chunk Index Cond: (i = 1) EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Index Scan using _hyper_5_13_chunk_chunk_assert_fail_i_idx on _hyper_5_13_chunk Index Cond: (i > 1) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; CREATE TABLE timestamp_inf(time TIMESTAMP); SELECT create_hypertable('timestamp_inf', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------- (7,public,timestamp_inf,t) INSERT INTO timestamp_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) CREATE TABLE date_inf(time DATE); SELECT create_hypertable('date_inf', 'time'); create_hypertable ----------------------- (8,public,date_inf,t) INSERT INTO date_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" < 'infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" < 'infinity'::date) EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" > '-infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" > '-infinity'::date) -- test INSERT with cached plans / plpgsql functions -- https://github.com/timescale/timescaledb/issues/1809 CREATE TABLE status_table(a int, b int, last_ts timestamptz, UNIQUE(a,b)); CREATE TABLE metrics(time timestamptz NOT NULL, value float); CREATE TABLE metrics2(time timestamptz NOT NULL, value float); SELECT (create_hypertable(t,'time')).table_name FROM (VALUES ('metrics'),('metrics2')) v(t); table_name ------------ metrics metrics2 INSERT INTO metrics VALUES ('2000-01-01',random()), ('2000-02-01',random()), ('2000-03-01',random()); CREATE OR REPLACE FUNCTION insert_test() RETURNS VOID LANGUAGE plpgsql AS $$ DECLARE r RECORD; BEGIN FOR r IN SELECT * FROM metrics LOOP WITH foo AS ( INSERT INTO metrics2 SELECT * FROM metrics RETURNING * ) INSERT INTO status_table (a,b, last_ts) VALUES (1,1, now()) ON CONFLICT (a,b) DO UPDATE SET last_ts=(SELECT max(time) FROM metrics); END LOOP; END; $$; SELECT insert_test(), insert_test(), insert_test(); insert_test | insert_test | insert_test -------------+-------------+------------- | | -- test Postgres crashes on INSERT ... SELECT ... WHERE NOT EXISTS with empty table -- https://github.com/timescale/timescaledb/issues/1883 CREATE TABLE readings ( toe TIMESTAMPTZ NOT NULL, sensor_id INT NOT NULL, value INT NOT NULL ); SELECT create_hypertable( 'readings', 'toe', chunk_time_interval => interval '1 day', if_not_exists => TRUE, migrate_data => TRUE ); create_hypertable ------------------------ (11,public,readings,t) EXPLAIN (buffers off, costs off) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); --- QUERY PLAN --- Custom Scan (ModifyHypertable) InitPlan 1 -> Result One-Time Filter: false -> Insert on readings -> Result One-Time Filter: (NOT (InitPlan 1).col1) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); DROP TABLE readings; CREATE TABLE sample_table ( sequence INTEGER NOT NULL, time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value NUMERIC NOT NULL, UNIQUE (sequence, time) ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '1 day'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 12 | public | sample_table | t INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); \set ON_ERROR_STOP 0 INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-07-21', TIMESTAMP '2019-08-01', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); ERROR: duplicate key value violates unique constraint "27_1_sample_table_sequence_time_key" \set ON_ERROR_STOP 1 INSERT INTO sample_table (sequence,time,value) VALUES (7,generate_series(TIMESTAMP '2019-01-01', TIMESTAMP '2019-07-01', '10 minutes'), ROUND(RANDOM()*10)::int); DROP TABLE sample_table; -- test on conflict clause on columns with default value -- issue #3037 CREATE TABLE i3037(time timestamptz PRIMARY KEY); SELECT create_hypertable('i3037','time'); create_hypertable --------------------- (13,public,i3037,t) ALTER TABLE i3037 ADD COLUMN value float DEFAULT 0; INSERT INTO i3037 VALUES ('2000-01-01'); INSERT INTO i3037 VALUES ('2000-01-01') ON CONFLICT(time) DO UPDATE SET value = EXCLUDED.value; -- test inserting into chunks directly CREATE TABLE direct_insert(time timestamptz, meta text) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO direct_insert VALUES ('2020-01-01'); SELECT show_chunks('direct_insert') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) INSERT INTO :CHUNK VALUES ('2020-01-01'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on _hyper_14_231_chunk -> Result -- correct time range should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; time | meta ------------------------------+------ Wed Jan 01 00:00:00 2020 PST | -- incorrect time range should fail \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2020-01-01'), ('2021-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint INSERT INTO :CHUNK VALUES ('2025-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint \set ON_ERROR_STOP 1 -- test that triggers on chunks work CREATE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'trigger called'; NEW.meta = 'triggered'; RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_trigger BEFORE INSERT ON direct_insert FOR EACH ROW EXECUTE PROCEDURE test_trigger(); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- test upsert DELETE FROM direct_insert; ALTER TABLE direct_insert ADD CONSTRAINT direct_insert_pkey PRIMARY KEY (time); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- DO NOTHING should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT DO NOTHING RETURNING *; NOTICE: trigger called time | meta ------+------ INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET meta = 'update' RETURNING *; NOTICE: trigger called time | meta ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | update \set ON_ERROR_STOP 0 -- conflict should fail INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called ERROR: duplicate key value violates unique constraint "231_205_direct_insert_pkey" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = '2000-01-01' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = EXCLUDED.time + '1 year' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/insert-18.out������������������������������������������������������0000664�0000000�0000000�00000115530�15100345067�0021123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET enable_seqscan TO off; \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 1 | public | two_Partitions | t \set QUIET off BEGIN; BEGIN \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); Relation | Kind | Column | Column type | NotNull ------------------------------------------------------------------------------------+------+-------------+------------------+--------- _timescaledb_internal._hyper_1_1_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_1_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_1_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_1_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_2_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_2_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_2_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_2_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_3_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_3_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_3_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_3_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f _timescaledb_internal._hyper_1_4_chunk | r | timeCustom | bigint | t _timescaledb_internal._hyper_1_4_chunk | r | device_id | text | t _timescaledb_internal._hyper_1_4_chunk | r | series_0 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_1 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_2 | double precision | f _timescaledb_internal._hyper_1_4_chunk | r | series_bool | boolean | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | i | device_id | text | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | i | series_0 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | i | series_1 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | i | series_2 | double precision | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | timeCustom | bigint | f _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | i | series_bool | boolean | f SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------------------------+--------------------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."_hyper_1_2_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal."_hyper_1_3_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal._hyper_1_4_chunk | _timescaledb_internal."_hyper_1_4_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | SELECT * FROM ONLY "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ------------+-----------+----------+----------+----------+------------- CREATE TABLE error_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('error_test', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (2,public,error_test,t) \set QUIET off INSERT INTO error_test VALUES ('Mon Mar 20 09:18:20.1 2017', 21.3, 'dev1'); INSERT 0 1 \set ON_ERROR_STOP 0 -- generate insert error INSERT INTO error_test VALUES ('Mon Mar 20 09:18:22.3 2017', 21.1, NULL); ERROR: null value in column "device" of relation "_hyper_2_6_chunk" violates not-null constraint \set ON_ERROR_STOP 1 INSERT INTO error_test VALUES ('Mon Mar 20 09:18:25.7 2017', 22.4, 'dev2'); INSERT 0 1 \set QUIET on SELECT * FROM error_test; time | temp | device ----------------------------+------+-------- Mon Mar 20 09:18:20.1 2017 | 21.3 | dev1 Mon Mar 20 09:18:25.7 2017 | 22.4 | dev2 --test character(9) partition keys since there were issues with padding causing partitioning errors CREATE TABLE tick_character ( symbol character(9) NOT NULL, mid REAL NOT NULL, spread REAL NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('tick_character', 'time', 'symbol', 2); create_hypertable ----------------------------- (3,public,tick_character,t) INSERT INTO tick_character ( symbol, mid, spread, time ) VALUES ( 'GBPJPY', 142.639000, 5.80, 'Mon Mar 20 09:18:22.3 2017') RETURNING time, symbol, mid; time | symbol | mid --------------------------------+-----------+--------- Mon Mar 20 09:18:22.3 2017 PDT | GBPJPY | 142.639 SELECT * FROM tick_character; symbol | mid | spread | time -----------+---------+--------+-------------------------------- GBPJPY | 142.639 | 5.8 | Mon Mar 20 09:18:22.3 2017 PDT CREATE TABLE date_col_test(time date, temp float8, device text NOT NULL); SELECT create_hypertable('date_col_test', 'time', 'device', 1000, chunk_time_interval => INTERVAL '1 Day'); create_hypertable ---------------------------- (4,public,date_col_test,t) INSERT INTO date_col_test VALUES ('2001-02-01', 98, 'dev1'), ('2001-03-02', 98, 'dev1'); SELECT * FROM date_col_test WHERE time > '2001-01-01'; time | temp | device ------------+------+-------- 02-01-2001 | 98 | dev1 03-02-2001 | 98 | dev1 -- Out-of-order insertion regression test. -- this used to trip an assert in subspace_store.c checking that -- max_open_chunks_per_insert was obeyed set timescaledb.max_open_chunks_per_insert=1; CREATE TABLE chunk_assert_fail(i bigint, j bigint); SELECT create_hypertable('chunk_assert_fail', 'i', 'j', 1000, chunk_time_interval=>1); create_hypertable -------------------------------- (5,public,chunk_assert_fail,t) insert into chunk_assert_fail values (1, 1), (1, 2), (2,1); select * from chunk_assert_fail; i | j ---+--- 1 | 1 1 | 2 2 | 1 CREATE TABLE one_space_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('one_space_test', 'time', 'device', 1); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------- (6,public,one_space_test,t) INSERT INTO one_space_test VALUES ('2001-01-01 01:01:01', 1.0, 'device'), ('2002-01-01 01:02:01', 1.0, 'device'); SELECT * FROM one_space_test; time | temp | device --------------------------+------+-------- Mon Jan 01 01:01:01 2001 | 1 | device Tue Jan 01 01:02:01 2002 | 1 | device --CTE & EXPLAIN ANALYZE TESTS WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:02:01', 1.0, 'device') RETURNING *) SELECT * FROM insert_cte; time | temp | device --------------------------+------+-------- Mon Jan 01 01:02:01 2001 | 1 | device EXPLAIN (analyze, buffers off, costs off, timing off) --can't turn summary off in 9.6 so instead grep it away at end. WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:03:01', 1.0, 'device') ) SELECT 1 \g | grep -v "Planning" | grep -v "Execution" --- QUERY PLAN --- Result (actual rows=1.00 loops=1) CTE insert_cte -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on one_space_test (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) -- INSERTs can exclude chunks based on constraints EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Only Scan using _hyper_5_11_chunk_chunk_assert_fail_j_i_idx on _hyper_5_11_chunk -> Index Only Scan using _hyper_5_12_chunk_chunk_assert_fail_j_i_idx on _hyper_5_12_chunk -> Index Only Scan using _hyper_5_13_chunk_chunk_assert_fail_j_i_idx on _hyper_5_13_chunk EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i < 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Append -> Index Scan using _hyper_5_11_chunk_chunk_assert_fail_i_idx on _hyper_5_11_chunk Index Cond: (i = 1) -> Index Scan using _hyper_5_12_chunk_chunk_assert_fail_i_idx on _hyper_5_12_chunk Index Cond: (i = 1) EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on chunk_assert_fail -> Index Scan using _hyper_5_13_chunk_chunk_assert_fail_i_idx on _hyper_5_13_chunk Index Cond: (i > 1) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on one_space_test -> Limit -> Append -> Index Scan using _hyper_6_14_chunk_one_space_test_time_idx on _hyper_6_14_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Scan using _hyper_6_15_chunk_one_space_test_time_idx on _hyper_6_15_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; CREATE TABLE timestamp_inf(time TIMESTAMP); SELECT create_hypertable('timestamp_inf', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------- (7,public,timestamp_inf,t) INSERT INTO timestamp_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" < 'infinity'::timestamp without time zone) EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on timestamp_inf -> Limit -> Append -> Index Only Scan using _hyper_7_16_chunk_timestamp_inf_time_idx on _hyper_7_16_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) -> Index Only Scan using _hyper_7_17_chunk_timestamp_inf_time_idx on _hyper_7_17_chunk Index Cond: ("time" > '-infinity'::timestamp without time zone) CREATE TABLE date_inf(time DATE); SELECT create_hypertable('date_inf', 'time'); create_hypertable ----------------------- (8,public,date_inf,t) INSERT INTO date_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time < 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" < 'infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" < 'infinity'::date) EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time >= 'infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time <= '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Result One-Time Filter: false EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time > '-infinity' LIMIT 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on date_inf -> Limit -> Append -> Index Only Scan using _hyper_8_18_chunk_date_inf_time_idx on _hyper_8_18_chunk Index Cond: ("time" > '-infinity'::date) -> Index Only Scan using _hyper_8_19_chunk_date_inf_time_idx on _hyper_8_19_chunk Index Cond: ("time" > '-infinity'::date) -- test INSERT with cached plans / plpgsql functions -- https://github.com/timescale/timescaledb/issues/1809 CREATE TABLE status_table(a int, b int, last_ts timestamptz, UNIQUE(a,b)); CREATE TABLE metrics(time timestamptz NOT NULL, value float); CREATE TABLE metrics2(time timestamptz NOT NULL, value float); SELECT (create_hypertable(t,'time')).table_name FROM (VALUES ('metrics'),('metrics2')) v(t); table_name ------------ metrics metrics2 INSERT INTO metrics VALUES ('2000-01-01',random()), ('2000-02-01',random()), ('2000-03-01',random()); CREATE OR REPLACE FUNCTION insert_test() RETURNS VOID LANGUAGE plpgsql AS $$ DECLARE r RECORD; BEGIN FOR r IN SELECT * FROM metrics LOOP WITH foo AS ( INSERT INTO metrics2 SELECT * FROM metrics RETURNING * ) INSERT INTO status_table (a,b, last_ts) VALUES (1,1, now()) ON CONFLICT (a,b) DO UPDATE SET last_ts=(SELECT max(time) FROM metrics); END LOOP; END; $$; SELECT insert_test(), insert_test(), insert_test(); insert_test | insert_test | insert_test -------------+-------------+------------- | | -- test Postgres crashes on INSERT ... SELECT ... WHERE NOT EXISTS with empty table -- https://github.com/timescale/timescaledb/issues/1883 CREATE TABLE readings ( toe TIMESTAMPTZ NOT NULL, sensor_id INT NOT NULL, value INT NOT NULL ); SELECT create_hypertable( 'readings', 'toe', chunk_time_interval => interval '1 day', if_not_exists => TRUE, migrate_data => TRUE ); create_hypertable ------------------------ (11,public,readings,t) EXPLAIN (buffers off, costs off) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); --- QUERY PLAN --- Custom Scan (ModifyHypertable) InitPlan 1 -> Result One-Time Filter: false -> Insert on readings -> Result One-Time Filter: (NOT (InitPlan 1).col1) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); DROP TABLE readings; CREATE TABLE sample_table ( sequence INTEGER NOT NULL, time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value NUMERIC NOT NULL, UNIQUE (sequence, time) ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '1 day'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 12 | public | sample_table | t INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); \set ON_ERROR_STOP 0 INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-07-21', TIMESTAMP '2019-08-01', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); ERROR: duplicate key value violates unique constraint "27_1_sample_table_sequence_time_key" \set ON_ERROR_STOP 1 INSERT INTO sample_table (sequence,time,value) VALUES (7,generate_series(TIMESTAMP '2019-01-01', TIMESTAMP '2019-07-01', '10 minutes'), ROUND(RANDOM()*10)::int); DROP TABLE sample_table; -- test on conflict clause on columns with default value -- issue #3037 CREATE TABLE i3037(time timestamptz PRIMARY KEY); SELECT create_hypertable('i3037','time'); create_hypertable --------------------- (13,public,i3037,t) ALTER TABLE i3037 ADD COLUMN value float DEFAULT 0; INSERT INTO i3037 VALUES ('2000-01-01'); INSERT INTO i3037 VALUES ('2000-01-01') ON CONFLICT(time) DO UPDATE SET value = EXCLUDED.value; -- test inserting into chunks directly CREATE TABLE direct_insert(time timestamptz, meta text) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO direct_insert VALUES ('2020-01-01'); SELECT show_chunks('direct_insert') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) INSERT INTO :CHUNK VALUES ('2020-01-01'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on _hyper_14_231_chunk -> Result -- correct time range should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; time | meta ------------------------------+------ Wed Jan 01 00:00:00 2020 PST | -- incorrect time range should fail \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2020-01-01'), ('2021-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint INSERT INTO :CHUNK VALUES ('2025-01-01') RETURNING *; ERROR: new row for relation "_hyper_14_231_chunk" violates chunk constraint \set ON_ERROR_STOP 1 -- test that triggers on chunks work CREATE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'trigger called'; NEW.meta = 'triggered'; RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_trigger BEFORE INSERT ON direct_insert FOR EACH ROW EXECUTE PROCEDURE test_trigger(); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- test upsert DELETE FROM direct_insert; ALTER TABLE direct_insert ADD CONSTRAINT direct_insert_pkey PRIMARY KEY (time); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called time | meta ------------------------------+----------- Wed Jan 01 00:00:00 2020 PST | triggered -- DO NOTHING should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT DO NOTHING RETURNING *; NOTICE: trigger called time | meta ------+------ INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET meta = 'update' RETURNING *; NOTICE: trigger called time | meta ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | update \set ON_ERROR_STOP 0 -- conflict should fail INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; NOTICE: trigger called ERROR: duplicate key value violates unique constraint "231_205_direct_insert_pkey" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = '2000-01-01' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = EXCLUDED.time + '1 year' RETURNING *; NOTICE: trigger called ERROR: new row for relation "_hyper_14_231_chunk" violates check constraint "constraint_237" \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/insert_many.out����������������������������������������������������0000664�0000000�0000000�00000113733�15100345067�0021724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE many_partitions_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('many_partitions_test', 'time', 'device', 1000); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------------------- (1,public,many_partitions_test,t) --NOTE: how much slower the first two queries are -- they are creating chunks INSERT INTO many_partitions_test SELECT to_timestamp(ser), ser, ser::text FROM generate_series(1,100) ser; INSERT INTO many_partitions_test SELECT to_timestamp(ser), ser, ser::text FROM generate_series(101,200) ser; INSERT INTO many_partitions_test SELECT to_timestamp(ser), ser, (ser-201)::text FROM generate_series(201,300) ser; SELECT * FROM many_partitions_test ORDER BY time DESC LIMIT 2; time | temp | device --------------------------+------+-------- Wed Dec 31 16:05:00 1969 | 300 | 99 Wed Dec 31 16:04:59 1969 | 299 | 98 SELECT count(*) FROM many_partitions_test; count ------- 300 CREATE TABLE many_partitions_test_1m (time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('many_partitions_test_1m', 'time', 'device', 1000); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------------- (2,public,many_partitions_test_1m,t) EXPLAIN (verbose on, buffers off, costs off) INSERT INTO many_partitions_test_1m(time, temp, device) SELECT time_bucket('1 minute', time) AS period, avg(temp), device FROM many_partitions_test GROUP BY period, device; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on public.many_partitions_test_1m -> HashAggregate Output: (time_bucket('@ 1 min'::interval, many_partitions_test."time")), avg(many_partitions_test.temp), many_partitions_test.device Group Key: time_bucket('@ 1 min'::interval, many_partitions_test."time"), many_partitions_test.device -> Result Output: time_bucket('@ 1 min'::interval, many_partitions_test."time"), many_partitions_test.device, many_partitions_test.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.temp, _hyper_1_1_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.temp, _hyper_1_2_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.temp, _hyper_1_3_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.temp, _hyper_1_4_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk."time", _hyper_1_5_chunk.temp, _hyper_1_5_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk."time", _hyper_1_6_chunk.temp, _hyper_1_6_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk."time", _hyper_1_7_chunk.temp, _hyper_1_7_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk."time", _hyper_1_8_chunk.temp, _hyper_1_8_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk."time", _hyper_1_9_chunk.temp, _hyper_1_9_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk."time", _hyper_1_10_chunk.temp, _hyper_1_10_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_11_chunk Output: _hyper_1_11_chunk."time", _hyper_1_11_chunk.temp, _hyper_1_11_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_12_chunk Output: _hyper_1_12_chunk."time", _hyper_1_12_chunk.temp, _hyper_1_12_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_13_chunk Output: _hyper_1_13_chunk."time", _hyper_1_13_chunk.temp, _hyper_1_13_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_14_chunk Output: _hyper_1_14_chunk."time", _hyper_1_14_chunk.temp, _hyper_1_14_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_15_chunk Output: _hyper_1_15_chunk."time", _hyper_1_15_chunk.temp, _hyper_1_15_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_16_chunk Output: _hyper_1_16_chunk."time", _hyper_1_16_chunk.temp, _hyper_1_16_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk Output: _hyper_1_17_chunk."time", _hyper_1_17_chunk.temp, _hyper_1_17_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_18_chunk Output: _hyper_1_18_chunk."time", _hyper_1_18_chunk.temp, _hyper_1_18_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_19_chunk Output: _hyper_1_19_chunk."time", _hyper_1_19_chunk.temp, _hyper_1_19_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_20_chunk Output: _hyper_1_20_chunk."time", _hyper_1_20_chunk.temp, _hyper_1_20_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_21_chunk Output: _hyper_1_21_chunk."time", _hyper_1_21_chunk.temp, _hyper_1_21_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_22_chunk Output: _hyper_1_22_chunk."time", _hyper_1_22_chunk.temp, _hyper_1_22_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_23_chunk Output: _hyper_1_23_chunk."time", _hyper_1_23_chunk.temp, _hyper_1_23_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_24_chunk Output: _hyper_1_24_chunk."time", _hyper_1_24_chunk.temp, _hyper_1_24_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk Output: _hyper_1_25_chunk."time", _hyper_1_25_chunk.temp, _hyper_1_25_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_26_chunk Output: _hyper_1_26_chunk."time", _hyper_1_26_chunk.temp, _hyper_1_26_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_27_chunk Output: _hyper_1_27_chunk."time", _hyper_1_27_chunk.temp, _hyper_1_27_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_28_chunk Output: _hyper_1_28_chunk."time", _hyper_1_28_chunk.temp, _hyper_1_28_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_29_chunk Output: _hyper_1_29_chunk."time", _hyper_1_29_chunk.temp, _hyper_1_29_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_30_chunk Output: _hyper_1_30_chunk."time", _hyper_1_30_chunk.temp, _hyper_1_30_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_31_chunk Output: _hyper_1_31_chunk."time", _hyper_1_31_chunk.temp, _hyper_1_31_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_32_chunk Output: _hyper_1_32_chunk."time", _hyper_1_32_chunk.temp, _hyper_1_32_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_33_chunk Output: _hyper_1_33_chunk."time", _hyper_1_33_chunk.temp, _hyper_1_33_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_34_chunk Output: _hyper_1_34_chunk."time", _hyper_1_34_chunk.temp, _hyper_1_34_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_35_chunk Output: _hyper_1_35_chunk."time", _hyper_1_35_chunk.temp, _hyper_1_35_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_36_chunk Output: _hyper_1_36_chunk."time", _hyper_1_36_chunk.temp, _hyper_1_36_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_37_chunk Output: _hyper_1_37_chunk."time", _hyper_1_37_chunk.temp, _hyper_1_37_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_38_chunk Output: _hyper_1_38_chunk."time", _hyper_1_38_chunk.temp, _hyper_1_38_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_39_chunk Output: _hyper_1_39_chunk."time", _hyper_1_39_chunk.temp, _hyper_1_39_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_40_chunk Output: _hyper_1_40_chunk."time", _hyper_1_40_chunk.temp, _hyper_1_40_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_41_chunk Output: _hyper_1_41_chunk."time", _hyper_1_41_chunk.temp, _hyper_1_41_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_42_chunk Output: _hyper_1_42_chunk."time", _hyper_1_42_chunk.temp, _hyper_1_42_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_43_chunk Output: _hyper_1_43_chunk."time", _hyper_1_43_chunk.temp, _hyper_1_43_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_44_chunk Output: _hyper_1_44_chunk."time", _hyper_1_44_chunk.temp, _hyper_1_44_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_45_chunk Output: _hyper_1_45_chunk."time", _hyper_1_45_chunk.temp, _hyper_1_45_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_46_chunk Output: _hyper_1_46_chunk."time", _hyper_1_46_chunk.temp, _hyper_1_46_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_47_chunk Output: _hyper_1_47_chunk."time", _hyper_1_47_chunk.temp, _hyper_1_47_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_48_chunk Output: _hyper_1_48_chunk."time", _hyper_1_48_chunk.temp, _hyper_1_48_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_49_chunk Output: _hyper_1_49_chunk."time", _hyper_1_49_chunk.temp, _hyper_1_49_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_50_chunk Output: _hyper_1_50_chunk."time", _hyper_1_50_chunk.temp, _hyper_1_50_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_51_chunk Output: _hyper_1_51_chunk."time", _hyper_1_51_chunk.temp, _hyper_1_51_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_52_chunk Output: _hyper_1_52_chunk."time", _hyper_1_52_chunk.temp, _hyper_1_52_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_53_chunk Output: _hyper_1_53_chunk."time", _hyper_1_53_chunk.temp, _hyper_1_53_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_54_chunk Output: _hyper_1_54_chunk."time", _hyper_1_54_chunk.temp, _hyper_1_54_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_55_chunk Output: _hyper_1_55_chunk."time", _hyper_1_55_chunk.temp, _hyper_1_55_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_56_chunk Output: _hyper_1_56_chunk."time", _hyper_1_56_chunk.temp, _hyper_1_56_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_57_chunk Output: _hyper_1_57_chunk."time", _hyper_1_57_chunk.temp, _hyper_1_57_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_58_chunk Output: _hyper_1_58_chunk."time", _hyper_1_58_chunk.temp, _hyper_1_58_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_59_chunk Output: _hyper_1_59_chunk."time", _hyper_1_59_chunk.temp, _hyper_1_59_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_60_chunk Output: _hyper_1_60_chunk."time", _hyper_1_60_chunk.temp, _hyper_1_60_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_61_chunk Output: _hyper_1_61_chunk."time", _hyper_1_61_chunk.temp, _hyper_1_61_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_62_chunk Output: _hyper_1_62_chunk."time", _hyper_1_62_chunk.temp, _hyper_1_62_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_63_chunk Output: _hyper_1_63_chunk."time", _hyper_1_63_chunk.temp, _hyper_1_63_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_64_chunk Output: _hyper_1_64_chunk."time", _hyper_1_64_chunk.temp, _hyper_1_64_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_65_chunk Output: _hyper_1_65_chunk."time", _hyper_1_65_chunk.temp, _hyper_1_65_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_66_chunk Output: _hyper_1_66_chunk."time", _hyper_1_66_chunk.temp, _hyper_1_66_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_67_chunk Output: _hyper_1_67_chunk."time", _hyper_1_67_chunk.temp, _hyper_1_67_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_68_chunk Output: _hyper_1_68_chunk."time", _hyper_1_68_chunk.temp, _hyper_1_68_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_69_chunk Output: _hyper_1_69_chunk."time", _hyper_1_69_chunk.temp, _hyper_1_69_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_70_chunk Output: _hyper_1_70_chunk."time", _hyper_1_70_chunk.temp, _hyper_1_70_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_71_chunk Output: _hyper_1_71_chunk."time", _hyper_1_71_chunk.temp, _hyper_1_71_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_72_chunk Output: _hyper_1_72_chunk."time", _hyper_1_72_chunk.temp, _hyper_1_72_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_73_chunk Output: _hyper_1_73_chunk."time", _hyper_1_73_chunk.temp, _hyper_1_73_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_74_chunk Output: _hyper_1_74_chunk."time", _hyper_1_74_chunk.temp, _hyper_1_74_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_75_chunk Output: _hyper_1_75_chunk."time", _hyper_1_75_chunk.temp, _hyper_1_75_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_76_chunk Output: _hyper_1_76_chunk."time", _hyper_1_76_chunk.temp, _hyper_1_76_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_77_chunk Output: _hyper_1_77_chunk."time", _hyper_1_77_chunk.temp, _hyper_1_77_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_78_chunk Output: _hyper_1_78_chunk."time", _hyper_1_78_chunk.temp, _hyper_1_78_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_79_chunk Output: _hyper_1_79_chunk."time", _hyper_1_79_chunk.temp, _hyper_1_79_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_80_chunk Output: _hyper_1_80_chunk."time", _hyper_1_80_chunk.temp, _hyper_1_80_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_81_chunk Output: _hyper_1_81_chunk."time", _hyper_1_81_chunk.temp, _hyper_1_81_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_82_chunk Output: _hyper_1_82_chunk."time", _hyper_1_82_chunk.temp, _hyper_1_82_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_83_chunk Output: _hyper_1_83_chunk."time", _hyper_1_83_chunk.temp, _hyper_1_83_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_84_chunk Output: _hyper_1_84_chunk."time", _hyper_1_84_chunk.temp, _hyper_1_84_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_85_chunk Output: _hyper_1_85_chunk."time", _hyper_1_85_chunk.temp, _hyper_1_85_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_86_chunk Output: _hyper_1_86_chunk."time", _hyper_1_86_chunk.temp, _hyper_1_86_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_87_chunk Output: _hyper_1_87_chunk."time", _hyper_1_87_chunk.temp, _hyper_1_87_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_88_chunk Output: _hyper_1_88_chunk."time", _hyper_1_88_chunk.temp, _hyper_1_88_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_89_chunk Output: _hyper_1_89_chunk."time", _hyper_1_89_chunk.temp, _hyper_1_89_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_90_chunk Output: _hyper_1_90_chunk."time", _hyper_1_90_chunk.temp, _hyper_1_90_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_91_chunk Output: _hyper_1_91_chunk."time", _hyper_1_91_chunk.temp, _hyper_1_91_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_92_chunk Output: _hyper_1_92_chunk."time", _hyper_1_92_chunk.temp, _hyper_1_92_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_93_chunk Output: _hyper_1_93_chunk."time", _hyper_1_93_chunk.temp, _hyper_1_93_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_94_chunk Output: _hyper_1_94_chunk."time", _hyper_1_94_chunk.temp, _hyper_1_94_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_95_chunk Output: _hyper_1_95_chunk."time", _hyper_1_95_chunk.temp, _hyper_1_95_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_96_chunk Output: _hyper_1_96_chunk."time", _hyper_1_96_chunk.temp, _hyper_1_96_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_97_chunk Output: _hyper_1_97_chunk."time", _hyper_1_97_chunk.temp, _hyper_1_97_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_98_chunk Output: _hyper_1_98_chunk."time", _hyper_1_98_chunk.temp, _hyper_1_98_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_99_chunk Output: _hyper_1_99_chunk."time", _hyper_1_99_chunk.temp, _hyper_1_99_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_100_chunk Output: _hyper_1_100_chunk."time", _hyper_1_100_chunk.temp, _hyper_1_100_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_101_chunk Output: _hyper_1_101_chunk."time", _hyper_1_101_chunk.temp, _hyper_1_101_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_102_chunk Output: _hyper_1_102_chunk."time", _hyper_1_102_chunk.temp, _hyper_1_102_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_103_chunk Output: _hyper_1_103_chunk."time", _hyper_1_103_chunk.temp, _hyper_1_103_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_104_chunk Output: _hyper_1_104_chunk."time", _hyper_1_104_chunk.temp, _hyper_1_104_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_105_chunk Output: _hyper_1_105_chunk."time", _hyper_1_105_chunk.temp, _hyper_1_105_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_106_chunk Output: _hyper_1_106_chunk."time", _hyper_1_106_chunk.temp, _hyper_1_106_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_107_chunk Output: _hyper_1_107_chunk."time", _hyper_1_107_chunk.temp, _hyper_1_107_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_108_chunk Output: _hyper_1_108_chunk."time", _hyper_1_108_chunk.temp, _hyper_1_108_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_109_chunk Output: _hyper_1_109_chunk."time", _hyper_1_109_chunk.temp, _hyper_1_109_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_110_chunk Output: _hyper_1_110_chunk."time", _hyper_1_110_chunk.temp, _hyper_1_110_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_111_chunk Output: _hyper_1_111_chunk."time", _hyper_1_111_chunk.temp, _hyper_1_111_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_112_chunk Output: _hyper_1_112_chunk."time", _hyper_1_112_chunk.temp, _hyper_1_112_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_113_chunk Output: _hyper_1_113_chunk."time", _hyper_1_113_chunk.temp, _hyper_1_113_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_114_chunk Output: _hyper_1_114_chunk."time", _hyper_1_114_chunk.temp, _hyper_1_114_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_115_chunk Output: _hyper_1_115_chunk."time", _hyper_1_115_chunk.temp, _hyper_1_115_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_116_chunk Output: _hyper_1_116_chunk."time", _hyper_1_116_chunk.temp, _hyper_1_116_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_117_chunk Output: _hyper_1_117_chunk."time", _hyper_1_117_chunk.temp, _hyper_1_117_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_118_chunk Output: _hyper_1_118_chunk."time", _hyper_1_118_chunk.temp, _hyper_1_118_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_119_chunk Output: _hyper_1_119_chunk."time", _hyper_1_119_chunk.temp, _hyper_1_119_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_120_chunk Output: _hyper_1_120_chunk."time", _hyper_1_120_chunk.temp, _hyper_1_120_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_121_chunk Output: _hyper_1_121_chunk."time", _hyper_1_121_chunk.temp, _hyper_1_121_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_122_chunk Output: _hyper_1_122_chunk."time", _hyper_1_122_chunk.temp, _hyper_1_122_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_123_chunk Output: _hyper_1_123_chunk."time", _hyper_1_123_chunk.temp, _hyper_1_123_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_124_chunk Output: _hyper_1_124_chunk."time", _hyper_1_124_chunk.temp, _hyper_1_124_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_125_chunk Output: _hyper_1_125_chunk."time", _hyper_1_125_chunk.temp, _hyper_1_125_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_126_chunk Output: _hyper_1_126_chunk."time", _hyper_1_126_chunk.temp, _hyper_1_126_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_127_chunk Output: _hyper_1_127_chunk."time", _hyper_1_127_chunk.temp, _hyper_1_127_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_128_chunk Output: _hyper_1_128_chunk."time", _hyper_1_128_chunk.temp, _hyper_1_128_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_129_chunk Output: _hyper_1_129_chunk."time", _hyper_1_129_chunk.temp, _hyper_1_129_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_130_chunk Output: _hyper_1_130_chunk."time", _hyper_1_130_chunk.temp, _hyper_1_130_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_131_chunk Output: _hyper_1_131_chunk."time", _hyper_1_131_chunk.temp, _hyper_1_131_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_132_chunk Output: _hyper_1_132_chunk."time", _hyper_1_132_chunk.temp, _hyper_1_132_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_133_chunk Output: _hyper_1_133_chunk."time", _hyper_1_133_chunk.temp, _hyper_1_133_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_134_chunk Output: _hyper_1_134_chunk."time", _hyper_1_134_chunk.temp, _hyper_1_134_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_135_chunk Output: _hyper_1_135_chunk."time", _hyper_1_135_chunk.temp, _hyper_1_135_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_136_chunk Output: _hyper_1_136_chunk."time", _hyper_1_136_chunk.temp, _hyper_1_136_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_137_chunk Output: _hyper_1_137_chunk."time", _hyper_1_137_chunk.temp, _hyper_1_137_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_138_chunk Output: _hyper_1_138_chunk."time", _hyper_1_138_chunk.temp, _hyper_1_138_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_139_chunk Output: _hyper_1_139_chunk."time", _hyper_1_139_chunk.temp, _hyper_1_139_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_140_chunk Output: _hyper_1_140_chunk."time", _hyper_1_140_chunk.temp, _hyper_1_140_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_141_chunk Output: _hyper_1_141_chunk."time", _hyper_1_141_chunk.temp, _hyper_1_141_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_142_chunk Output: _hyper_1_142_chunk."time", _hyper_1_142_chunk.temp, _hyper_1_142_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_143_chunk Output: _hyper_1_143_chunk."time", _hyper_1_143_chunk.temp, _hyper_1_143_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_144_chunk Output: _hyper_1_144_chunk."time", _hyper_1_144_chunk.temp, _hyper_1_144_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_145_chunk Output: _hyper_1_145_chunk."time", _hyper_1_145_chunk.temp, _hyper_1_145_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_146_chunk Output: _hyper_1_146_chunk."time", _hyper_1_146_chunk.temp, _hyper_1_146_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_147_chunk Output: _hyper_1_147_chunk."time", _hyper_1_147_chunk.temp, _hyper_1_147_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_148_chunk Output: _hyper_1_148_chunk."time", _hyper_1_148_chunk.temp, _hyper_1_148_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_149_chunk Output: _hyper_1_149_chunk."time", _hyper_1_149_chunk.temp, _hyper_1_149_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_150_chunk Output: _hyper_1_150_chunk."time", _hyper_1_150_chunk.temp, _hyper_1_150_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_151_chunk Output: _hyper_1_151_chunk."time", _hyper_1_151_chunk.temp, _hyper_1_151_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_152_chunk Output: _hyper_1_152_chunk."time", _hyper_1_152_chunk.temp, _hyper_1_152_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_153_chunk Output: _hyper_1_153_chunk."time", _hyper_1_153_chunk.temp, _hyper_1_153_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_154_chunk Output: _hyper_1_154_chunk."time", _hyper_1_154_chunk.temp, _hyper_1_154_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_155_chunk Output: _hyper_1_155_chunk."time", _hyper_1_155_chunk.temp, _hyper_1_155_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_156_chunk Output: _hyper_1_156_chunk."time", _hyper_1_156_chunk.temp, _hyper_1_156_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_157_chunk Output: _hyper_1_157_chunk."time", _hyper_1_157_chunk.temp, _hyper_1_157_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_158_chunk Output: _hyper_1_158_chunk."time", _hyper_1_158_chunk.temp, _hyper_1_158_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_159_chunk Output: _hyper_1_159_chunk."time", _hyper_1_159_chunk.temp, _hyper_1_159_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_160_chunk Output: _hyper_1_160_chunk."time", _hyper_1_160_chunk.temp, _hyper_1_160_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_161_chunk Output: _hyper_1_161_chunk."time", _hyper_1_161_chunk.temp, _hyper_1_161_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_162_chunk Output: _hyper_1_162_chunk."time", _hyper_1_162_chunk.temp, _hyper_1_162_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_163_chunk Output: _hyper_1_163_chunk."time", _hyper_1_163_chunk.temp, _hyper_1_163_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_164_chunk Output: _hyper_1_164_chunk."time", _hyper_1_164_chunk.temp, _hyper_1_164_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_165_chunk Output: _hyper_1_165_chunk."time", _hyper_1_165_chunk.temp, _hyper_1_165_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_166_chunk Output: _hyper_1_166_chunk."time", _hyper_1_166_chunk.temp, _hyper_1_166_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_167_chunk Output: _hyper_1_167_chunk."time", _hyper_1_167_chunk.temp, _hyper_1_167_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_168_chunk Output: _hyper_1_168_chunk."time", _hyper_1_168_chunk.temp, _hyper_1_168_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_169_chunk Output: _hyper_1_169_chunk."time", _hyper_1_169_chunk.temp, _hyper_1_169_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_170_chunk Output: _hyper_1_170_chunk."time", _hyper_1_170_chunk.temp, _hyper_1_170_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_171_chunk Output: _hyper_1_171_chunk."time", _hyper_1_171_chunk.temp, _hyper_1_171_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_172_chunk Output: _hyper_1_172_chunk."time", _hyper_1_172_chunk.temp, _hyper_1_172_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_173_chunk Output: _hyper_1_173_chunk."time", _hyper_1_173_chunk.temp, _hyper_1_173_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_174_chunk Output: _hyper_1_174_chunk."time", _hyper_1_174_chunk.temp, _hyper_1_174_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_175_chunk Output: _hyper_1_175_chunk."time", _hyper_1_175_chunk.temp, _hyper_1_175_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_176_chunk Output: _hyper_1_176_chunk."time", _hyper_1_176_chunk.temp, _hyper_1_176_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_177_chunk Output: _hyper_1_177_chunk."time", _hyper_1_177_chunk.temp, _hyper_1_177_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_178_chunk Output: _hyper_1_178_chunk."time", _hyper_1_178_chunk.temp, _hyper_1_178_chunk.device INSERT INTO many_partitions_test_1m(time, temp, device) SELECT time_bucket('1 minute', time) AS period, avg(temp), device FROM many_partitions_test GROUP BY period, device; SELECT * FROM many_partitions_test_1m ORDER BY time, device LIMIT 10; time | temp | device --------------------------+------+-------- Wed Dec 31 16:00:00 1969 | 1 | 1 Wed Dec 31 16:00:00 1969 | 10 | 10 Wed Dec 31 16:00:00 1969 | 11 | 11 Wed Dec 31 16:00:00 1969 | 12 | 12 Wed Dec 31 16:00:00 1969 | 13 | 13 Wed Dec 31 16:00:00 1969 | 14 | 14 Wed Dec 31 16:00:00 1969 | 15 | 15 Wed Dec 31 16:00:00 1969 | 16 | 16 Wed Dec 31 16:00:00 1969 | 17 | 17 Wed Dec 31 16:00:00 1969 | 18 | 18 �������������������������������������timescaledb-2.23.0/test/expected/insert_returning.out�����������������������������������������������0000664�0000000�0000000�00000003772�15100345067�0022776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE standard_table ( standard_id integer PRIMARY KEY, name text not null ); CREATE TABLE hypertable ( time timestamptz not null, name text not null, standard_id integer not null ); select * from create_hypertable('hypertable', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hypertable | t INSERT INTO standard_table (standard_id, name) VALUES (1, 'standard_1'); INSERT INTO hypertable (time, name, standard_id) VALUES ('2021-01-01 01:01:01+00', 'hypertable_1', 1); INSERT INTO hypertable (time, name, standard_id) VALUES ('2022-02-02 02:02:02+00', 'hypertable_2', 1) RETURNING *, EXISTS ( SELECT * FROM standard_table WHERE standard_table.standard_id = hypertable.standard_id ); time | name | standard_id | exists ------------------------------+--------------+-------------+-------- Tue Feb 01 18:02:02 2022 PST | hypertable_2 | 1 | t INSERT INTO hypertable (time, name, standard_id) VALUES ('2023-03-03 03:03:03+00', 'hypertable_3', 1) RETURNING *, EXISTS ( SELECT * FROM standard_table WHERE standard_table.standard_id = hypertable.standard_id ); time | name | standard_id | exists ------------------------------+--------------+-------------+-------- Thu Mar 02 19:03:03 2023 PST | hypertable_3 | 1 | t INSERT INTO hypertable (time, name, standard_id) VALUES ('2024-04-04 04:04:04+00', 'hypertable_4', 2) RETURNING *, EXISTS ( SELECT * FROM standard_table WHERE standard_table.standard_id = hypertable.standard_id ); time | name | standard_id | exists ------------------------------+--------------+-------------+-------- Wed Apr 03 21:04:04 2024 PDT | hypertable_4 | 2 | f ������timescaledb-2.23.0/test/expected/insert_single.out��������������������������������������������������0000664�0000000�0000000�00000066044�15100345067�0022243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_single.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."one_Partition" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."one_Partition" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; \c :DBNAME :ROLE_SUPERUSER CREATE SCHEMA "one_Partition" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :DBNAME :ROLE_DEFAULT_PERM_USER; SELECT * FROM create_hypertable('"public"."one_Partition"', 'timeCustom', associated_schema_name=>'one_Partition', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 1 | public | one_Partition | t --output command tags \set QUIET off BEGIN; BEGIN \COPY "one_Partition" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on SELECT * FROM test.show_columnsp('"one_Partition".%'); Relation | Kind | Column | Column type | NotNull -----------------------------------------------------------------------------+------+-------------+------------------+--------- "one_Partition"._hyper_1_1_chunk | r | timeCustom | bigint | t "one_Partition"._hyper_1_1_chunk | r | device_id | text | t "one_Partition"._hyper_1_1_chunk | r | series_0 | double precision | f "one_Partition"._hyper_1_1_chunk | r | series_1 | double precision | f "one_Partition"._hyper_1_1_chunk | r | series_2 | double precision | f "one_Partition"._hyper_1_1_chunk | r | series_bool | boolean | f "one_Partition"."_hyper_1_1_chunk_one_Partition_device_id_timeCustom_idx" | i | device_id | text | f "one_Partition"."_hyper_1_1_chunk_one_Partition_device_id_timeCustom_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_0_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_0_idx" | i | series_0 | double precision | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" | i | series_1 | double precision | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_2_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_2_idx" | i | series_2 | double precision | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_bool_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_1_chunk_one_Partition_timeCustom_series_bool_idx" | i | series_bool | boolean | f "one_Partition"._hyper_1_2_chunk | r | timeCustom | bigint | t "one_Partition"._hyper_1_2_chunk | r | device_id | text | t "one_Partition"._hyper_1_2_chunk | r | series_0 | double precision | f "one_Partition"._hyper_1_2_chunk | r | series_1 | double precision | f "one_Partition"._hyper_1_2_chunk | r | series_2 | double precision | f "one_Partition"._hyper_1_2_chunk | r | series_bool | boolean | f "one_Partition"."_hyper_1_2_chunk_one_Partition_device_id_timeCustom_idx" | i | device_id | text | f "one_Partition"."_hyper_1_2_chunk_one_Partition_device_id_timeCustom_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_0_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_0_idx" | i | series_0 | double precision | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" | i | series_1 | double precision | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_2_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_2_idx" | i | series_2 | double precision | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_bool_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_2_chunk_one_Partition_timeCustom_series_bool_idx" | i | series_bool | boolean | f "one_Partition"._hyper_1_3_chunk | r | timeCustom | bigint | t "one_Partition"._hyper_1_3_chunk | r | device_id | text | t "one_Partition"._hyper_1_3_chunk | r | series_0 | double precision | f "one_Partition"._hyper_1_3_chunk | r | series_1 | double precision | f "one_Partition"._hyper_1_3_chunk | r | series_2 | double precision | f "one_Partition"._hyper_1_3_chunk | r | series_bool | boolean | f "one_Partition"."_hyper_1_3_chunk_one_Partition_device_id_timeCustom_idx" | i | device_id | text | f "one_Partition"."_hyper_1_3_chunk_one_Partition_device_id_timeCustom_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_0_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_0_idx" | i | series_0 | double precision | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" | i | series_1 | double precision | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_2_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_2_idx" | i | series_2 | double precision | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_bool_idx" | i | timeCustom | bigint | f "one_Partition"."_hyper_1_3_chunk_one_Partition_timeCustom_series_bool_idx" | i | series_bool | boolean | f SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | --test that we can insert data into a 1-dimensional table (only time partitioning) CREATE TABLE "1dim"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim"', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------- (2,public,1dim,t) INSERT INTO "1dim" VALUES('2017-01-20T09:00:01', 22.5) RETURNING *; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 INSERT INTO "1dim" VALUES('2017-01-20T09:00:21', 21.2); INSERT INTO "1dim" VALUES('2017-01-20T09:00:47', 25.1); SELECT * FROM "1dim"; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:21 2017 | 21.2 Fri Jan 20 09:00:47 2017 | 25.1 CREATE TABLE regular_table (time timestamp, temp float); INSERT INTO regular_table SELECT * FROM "1dim"; SELECT * FROM regular_table; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:21 2017 | 21.2 Fri Jan 20 09:00:47 2017 | 25.1 TRUNCATE TABLE regular_table; INSERT INTO regular_table VALUES('2017-01-20T09:00:59', 29.2); INSERT INTO "1dim" SELECT * FROM regular_table; SELECT * FROM "1dim"; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:21 2017 | 21.2 Fri Jan 20 09:00:47 2017 | 25.1 Fri Jan 20 09:00:59 2017 | 29.2 SELECT "1dim" FROM "1dim"; 1dim ----------------------------------- ("Fri Jan 20 09:00:01 2017",22.5) ("Fri Jan 20 09:00:21 2017",21.2) ("Fri Jan 20 09:00:47 2017",25.1) ("Fri Jan 20 09:00:59 2017",29.2) --test that we can insert pre-1970 dates CREATE TABLE "1dim_pre1970"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim_pre1970"', 'time', chunk_time_interval=> INTERVAL '1 Month'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------- (3,public,1dim_pre1970,t) INSERT INTO "1dim_pre1970" VALUES('1969-12-01T19:00:00', 21.2); INSERT INTO "1dim_pre1970" VALUES('1969-12-20T09:00:00', 25.1); INSERT INTO "1dim_pre1970" VALUES('1970-01-20T09:00:00', 26.6); INSERT INTO "1dim_pre1970" VALUES('1969-02-20T09:00:00', 29.9); --should show warning BEGIN; CREATE TABLE "1dim_usec_interval"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim_usec_interval"', 'time', chunk_time_interval=> 10); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices WARNING: unexpected interval: smaller than one second create_hypertable --------------------------------- (4,public,1dim_usec_interval,t) INSERT INTO "1dim_usec_interval" VALUES('1969-12-01T19:00:00', 21.2); ROLLBACK; CREATE TABLE "1dim_usec_interval"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim_usec_interval"', 'time', chunk_time_interval=> 1000000); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------- (5,public,1dim_usec_interval,t) INSERT INTO "1dim_usec_interval" VALUES('1969-12-01T19:00:00', 21.2); CREATE TABLE "1dim_neg"(time INTEGER, temp float); SELECT create_hypertable('"1dim_neg"', 'time', chunk_time_interval=>10); create_hypertable ----------------------- (6,public,1dim_neg,t) INSERT INTO "1dim_neg" VALUES (-20, 21.2); INSERT INTO "1dim_neg" VALUES (-19, 21.2); INSERT INTO "1dim_neg" VALUES (-1, 21.2); INSERT INTO "1dim_neg" VALUES (0, 21.2); INSERT INTO "1dim_neg" VALUES (1, 21.2); INSERT INTO "1dim_neg" VALUES (19, 21.2); INSERT INTO "1dim_neg" VALUES (20, 21.2); SELECT * FROM "1dim_pre1970"; time | temp --------------------------+------ Mon Dec 01 19:00:00 1969 | 21.2 Sat Dec 20 09:00:00 1969 | 25.1 Tue Jan 20 09:00:00 1970 | 26.6 Thu Feb 20 09:00:00 1969 | 29.9 SELECT * FROM "1dim_neg"; time | temp ------+------ -20 | 21.2 -19 | 21.2 -1 | 21.2 0 | 21.2 1 | 21.2 19 | 21.2 20 | 21.2 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+-------------------+---------------------+---------+--------+----------- 1 | 1 | one_Partition | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | one_Partition | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | one_Partition | _hyper_1_3_chunk | | f | 0 | f 4 | 2 | _timescaledb_internal | _hyper_2_4_chunk | | f | 0 | f 5 | 3 | _timescaledb_internal | _hyper_3_5_chunk | | f | 0 | f 6 | 3 | _timescaledb_internal | _hyper_3_6_chunk | | f | 0 | f 7 | 3 | _timescaledb_internal | _hyper_3_7_chunk | | f | 0 | f 8 | 3 | _timescaledb_internal | _hyper_3_8_chunk | | f | 0 | f 10 | 5 | _timescaledb_internal | _hyper_5_10_chunk | | f | 0 | f 11 | 6 | _timescaledb_internal | _hyper_6_11_chunk | | f | 0 | f 12 | 6 | _timescaledb_internal | _hyper_6_12_chunk | | f | 0 | f 13 | 6 | _timescaledb_internal | _hyper_6_13_chunk | | f | 0 | f 14 | 6 | _timescaledb_internal | _hyper_6_14_chunk | | f | 0 | f 15 | 6 | _timescaledb_internal | _hyper_6_15_chunk | | f | 0 | f SELECT * FROM _timescaledb_catalog.dimension_slice; id | dimension_id | range_start | range_end ----+--------------+---------------------+--------------------- 1 | 1 | 1257892416000000000 | 1257895008000000000 2 | 1 | 1257897600000000000 | 1257900192000000000 3 | 1 | 1257985728000000000 | 1257988320000000000 4 | 2 | 1484784000000000 | 1485388800000000 5 | 3 | -5184000000000 | -2592000000000 6 | 3 | -2592000000000 | 0 7 | 3 | 0 | 2592000000000 8 | 3 | -28512000000000 | -25920000000000 10 | 5 | -2610000000000 | -2609999000000 11 | 6 | -20 | -10 12 | 6 | -10 | 0 13 | 6 | 0 | 10 14 | 6 | 10 | 20 15 | 6 | 20 | 30 -- Create a three-dimensional table CREATE TABLE "3dim" (time timestamp, temp float, device text, location text); SELECT create_hypertable('"3dim"', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------- (7,public,3dim,t) SELECT add_dimension('"3dim"', 'location', 2); add_dimension ---------------------------- (9,public,3dim,location,t) INSERT INTO "3dim" VALUES('2017-01-20T09:00:01', 22.5, 'blue', 'nyc'); INSERT INTO "3dim" VALUES('2017-01-20T09:00:21', 21.2, 'brown', 'sthlm'); INSERT INTO "3dim" VALUES('2017-01-20T09:00:47', 25.1, 'yellow', 'la'); --show the constraints on the three-dimensional chunk SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_7_16_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ---------------+------+------------+-------+----------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- constraint_16 | c | {time} | - | (("time" >= 'Thu Jan 19 00:00:00 2017'::timestamp without time zone) AND ("time" < 'Thu Jan 26 00:00:00 2017'::timestamp without time zone)) | f | f | t constraint_17 | c | {device} | - | (_timescaledb_functions.get_partition_hash(device) < 1073741823) | f | f | t constraint_18 | c | {location} | - | (_timescaledb_functions.get_partition_hash(location) >= 1073741823) | f | f | t --queries should work in three dimensions SELECT * FROM "3dim"; time | temp | device | location --------------------------+------+--------+---------- Fri Jan 20 09:00:01 2017 | 22.5 | blue | nyc Fri Jan 20 09:00:47 2017 | 25.1 | yellow | la Fri Jan 20 09:00:21 2017 | 21.2 | brown | sthlm -- test that explain works EXPLAIN (BUFFERS FALSE, COSTS FALSE) INSERT INTO "3dim" VALUES('2017-01-21T09:00:01', 32.9, 'green', 'nyc'), ('2017-01-21T09:00:47', 27.3, 'purple', 'la') RETURNING *; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on "3dim" -> Values Scan on "*VALUES*" EXPLAIN (BUFFERS FALSE, COSTS FALSE) WITH "3dim_insert" AS ( INSERT INTO "3dim" VALUES('2017-01-21T09:01:44', 19.3, 'black', 'la') RETURNING time, temp ), regular_insert AS ( INSERT INTO regular_table VALUES('2017-01-21T10:00:51', 14.3) RETURNING time, temp ) INSERT INTO "1dim" (SELECT time, temp FROM "3dim_insert" UNION SELECT time, temp FROM regular_insert); --- QUERY PLAN --- Custom Scan (ModifyHypertable) CTE 3dim_insert -> Custom Scan (ModifyHypertable) -> Insert on "3dim" -> Result CTE regular_insert -> Insert on regular_table -> Result -> Insert on "1dim" -> Unique -> Sort Sort Key: "3dim_insert"."time", "3dim_insert".temp -> Append -> CTE Scan on "3dim_insert" -> CTE Scan on regular_insert -- test prepared statement INSERT PREPARE "1dim_plan" (timestamp, float) AS INSERT INTO "1dim" VALUES($1, $2) ON CONFLICT (time) DO NOTHING; EXECUTE "1dim_plan" ('2017-04-17 23:35', 31.4); EXECUTE "1dim_plan" ('2017-04-17 23:35', 32.6); -- test prepared statement with generic plan (forced when no parameters) PREPARE "1dim_plan_generic" AS INSERT INTO "1dim" VALUES('2017-05-18 17:24', 18.3); EXECUTE "1dim_plan_generic"; SELECT * FROM "1dim" ORDER BY time; time | temp --------------------------+------ Fri Jan 20 09:00:01 2017 | 22.5 Fri Jan 20 09:00:21 2017 | 21.2 Fri Jan 20 09:00:47 2017 | 25.1 Fri Jan 20 09:00:59 2017 | 29.2 Mon Apr 17 23:35:00 2017 | 31.4 Thu May 18 17:24:00 2017 | 18.3 SELECT * FROM "3dim" ORDER BY (time, device); time | temp | device | location --------------------------+------+--------+---------- Fri Jan 20 09:00:01 2017 | 22.5 | blue | nyc Fri Jan 20 09:00:21 2017 | 21.2 | brown | sthlm Fri Jan 20 09:00:47 2017 | 25.1 | yellow | la -- Test large intervals as default interval for integer is -- supported as part of hypertable generalization \set ON_ERROR_STOP 0 CREATE TABLE "inttime_err"(time INTEGER PRIMARY KEY, temp float); SELECT create_hypertable('"inttime_err"', 'time', chunk_time_interval=>2147483648); ERROR: invalid interval: must be between 1 and 2147483647 \set ON_ERROR_STOP 1 SELECT create_hypertable('"inttime_err"', 'time', chunk_time_interval=>2147483647); create_hypertable -------------------------- (8,public,inttime_err,t) -- Test large intervals as default interval is supported -- for integer types as part of hypertable generalization. \set ON_ERROR_STOP 0 CREATE TABLE "smallinttime_err"(time SMALLINT PRIMARY KEY, temp float); SELECT create_hypertable('"smallinttime_err"', 'time', chunk_time_interval=>32768); ERROR: invalid interval: must be between 1 and 32767 \set ON_ERROR_STOP 1 SELECT create_hypertable('"smallinttime_err"', 'time', chunk_time_interval=>32767); create_hypertable ------------------------------- (9,public,smallinttime_err,t) --make sure date inserts work even when the timezone changes the CREATE TABLE hyper_date(time date, temp float); SELECT create_hypertable('"hyper_date"', 'time'); create_hypertable -------------------------- (10,public,hyper_date,t) SET timezone=+1; INSERT INTO "hyper_date" VALUES('2011-01-26', 22.5); RESET timezone; --make sure timestamp inserts work even when the timezone changes the SET timezone = 'UTC'; CREATE TABLE "test_tz"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"test_tz"', 'time', chunk_time_interval=> INTERVAL '1 day'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------- (11,public,test_tz,t) INSERT INTO "test_tz" VALUES('2017-09-22 10:00:00', 21.2); INSERT INTO "test_tz" VALUES('2017-09-21 19:00:00', 21.2); SET timezone = 'US/central'; INSERT INTO "test_tz" VALUES('2017-09-21 19:01:00', 21.2); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_10_20_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ---------------+------+---------+-------+--------------------------------------------------------------------+------------+----------+----------- constraint_23 | c | {time} | - | (("time" >= '01-20-2011'::date) AND ("time" < '01-27-2011'::date)) | f | f | t SELECT * FROM test_tz; time | temp --------------------------+------ Fri Sep 22 10:00:00 2017 | 21.2 Thu Sep 21 19:00:00 2017 | 21.2 Thu Sep 21 19:01:00 2017 | 21.2 -- test various memory settings -- SET timescaledb.max_open_chunks_per_insert = 10; SET timescaledb.max_cached_chunks_per_hypertable = 10; CREATE TABLE "nondefault_mem_settings"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"nondefault_mem_settings"', 'time', chunk_time_interval=> INTERVAL '1 Month'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------------- (12,public,nondefault_mem_settings,t) INSERT INTO "nondefault_mem_settings" VALUES('2000-12-01T19:00:00', 21.2); INSERT INTO "nondefault_mem_settings" VALUES('2001-12-20T09:00:00', 25.1); --lowest possible SET timescaledb.max_open_chunks_per_insert = 1; SET timescaledb.max_cached_chunks_per_hypertable = 1; INSERT INTO "nondefault_mem_settings" VALUES ('2001-01-20T09:00:00', 26.6), ('2002-02-20T09:00:00', 27.9), ('2003-02-20T09:00:00', 28.9); INSERT INTO "nondefault_mem_settings" VALUES ('2001-03-20T09:00:00', 30.6), ('2002-03-20T09:00:00', 31.9), ('2003-03-20T09:00:00', 32.9); --warning about mismatched cache sizes SET timescaledb.max_open_chunks_per_insert = 100; WARNING: insert cache size is larger than hypertable chunk cache size SET timescaledb.max_cached_chunks_per_hypertable = 10; WARNING: insert cache size is larger than hypertable chunk cache size INSERT INTO "nondefault_mem_settings" VALUES ('2001-05-20T09:00:00', 36.6), ('2002-05-20T09:00:00', 37.9), ('2003-05-20T09:00:00', 38.9); --unlimited SET timescaledb.max_open_chunks_per_insert = 0; SET timescaledb.max_cached_chunks_per_hypertable = 0; INSERT INTO "nondefault_mem_settings" VALUES ('2001-04-20T09:00:00', 33.6), ('2002-04-20T09:00:00', 34.9), ('2003-04-20T09:00:00', 35.9); SELECT * FROM "nondefault_mem_settings"; time | temp --------------------------+------ Fri Dec 01 19:00:00 2000 | 21.2 Thu Dec 20 09:00:00 2001 | 25.1 Sat Jan 20 09:00:00 2001 | 26.6 Wed Feb 20 09:00:00 2002 | 27.9 Thu Feb 20 09:00:00 2003 | 28.9 Tue Mar 20 09:00:00 2001 | 30.6 Wed Mar 20 09:00:00 2002 | 31.9 Thu Mar 20 09:00:00 2003 | 32.9 Sun May 20 09:00:00 2001 | 36.6 Mon May 20 09:00:00 2002 | 37.9 Tue May 20 09:00:00 2003 | 38.9 Fri Apr 20 09:00:00 2001 | 33.6 Sat Apr 20 09:00:00 2002 | 34.9 Sun Apr 20 09:00:00 2003 | 35.9 --test rollback BEGIN; \set QUIET off CREATE TABLE "data_records" ("time" bigint NOT NULL, "value" integer CHECK (VALUE >= 0)); CREATE TABLE SELECT create_hypertable('data_records', 'time', chunk_time_interval => 2592000000); create_hypertable ---------------------------- (13,public,data_records,t) INSERT INTO "data_records" ("time", "value") VALUES (0, 1); INSERT 0 1 SAVEPOINT savepoint_1; SAVEPOINT INSERT INTO "data_records" ("time", "value") VALUES (1, 0); INSERT 0 1 ROLLBACK TO SAVEPOINT savepoint_1; ROLLBACK INSERT INTO "data_records" ("time", "value") VALUES (2, 1); INSERT 0 1 SAVEPOINT savepoint_2; SAVEPOINT \set ON_ERROR_STOP 0 INSERT INTO "data_records" ("time", "value") VALUES (3, -1); ERROR: new row for relation "_hyper_13_37_chunk" violates check constraint "data_records_value_check" \set ON_ERROR_STOP 1 ROLLBACK TO SAVEPOINT savepoint_2; ROLLBACK INSERT INTO "data_records" ("time", "value") VALUES (4, 1); INSERT 0 1 SAVEPOINT savepoint_3; SAVEPOINT INSERT INTO "data_records" ("time", "value") VALUES (5, 0); INSERT 0 1 ROLLBACK TO SAVEPOINT savepoint_3; ROLLBACK SELECT * FROM data_records; time | value ------+------- 0 | 1 2 | 1 4 | 1 \set QUIET on ROLLBACK; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/lateral.out��������������������������������������������������������0000664�0000000�0000000�00000015475�15100345067�0021024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE regular_table(name text, junk text); CREATE TABLE ht(time timestamptz NOT NULL, location text); SELECT create_hypertable('ht', 'time'); create_hypertable ------------------- (1,public,ht,t) INSERT INTO ht(time) select timestamp 'epoch' + (i * interval '1 second') from generate_series(1, 100) as T(i); INSERT INTO regular_table values('name', 'junk'); SELECT * FROM regular_table ik LEFT JOIN LATERAL (select max(time::timestamptz) from ht s where ik.name='name' and s.time < now()) s on true; name | junk | max ------+------+------------------------------ name | junk | Thu Jan 01 00:01:40 1970 PST select * from regular_table ik LEFT JOIN LATERAL (select max(time::timestamptz) from ht s where ik.name='name' and s.time > now()) s on true; name | junk | max ------+------+----- name | junk | DROP TABLE regular_table; DROP TABLE ht; CREATE TABLE orders(id int, user_id int, time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('orders', 'time'); create_hypertable --------------------- (2,public,orders,t) INSERT INTO orders values(1,1,timestamp 'epoch' + '1 second'); INSERT INTO orders values(2,1,timestamp 'epoch' + '2 second'); INSERT INTO orders values(3,1,timestamp 'epoch' + '3 second'); INSERT INTO orders values(4,2,timestamp 'epoch' + '4 second'); INSERT INTO orders values(5,1,timestamp 'epoch' + '5 second'); INSERT INTO orders values(6,3,timestamp 'epoch' + '6 second'); INSERT INTO orders values(7,1,timestamp 'epoch' + '7 second'); INSERT INTO orders values(8,4,timestamp 'epoch' + '8 second'); INSERT INTO orders values(9,2,timestamp 'epoch' + '9 second'); -- Need a LATERAL query with a reference to the upper-level table and -- with a restriction on time -- Upper-level table constraint should be a constant in order to trigger -- creation of a one-time filter in the planner SELECT user_id, first_order_time, max_time FROM (SELECT user_id, min(time) AS first_order_time FROM orders GROUP BY user_id) o1 LEFT JOIN LATERAL (SELECT max(time) AS max_time FROM orders WHERE o1.user_id = '2' AND time > now()) o2 ON true ORDER BY user_id, first_order_time, max_time; user_id | first_order_time | max_time ---------+------------------------------+---------- 1 | Thu Jan 01 00:00:01 1970 PST | 2 | Thu Jan 01 00:00:04 1970 PST | 3 | Thu Jan 01 00:00:06 1970 PST | 4 | Thu Jan 01 00:00:08 1970 PST | SELECT user_id, first_order_time, max_time FROM (SELECT user_id, min(time) AS first_order_time FROM orders GROUP BY user_id) o1 LEFT JOIN LATERAL (SELECT max(time) AS max_time FROM orders WHERE o1.user_id = '2' AND time < now()) o2 ON true ORDER BY user_id, first_order_time, max_time; user_id | first_order_time | max_time ---------+------------------------------+------------------------------ 1 | Thu Jan 01 00:00:01 1970 PST | 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:09 1970 PST 3 | Thu Jan 01 00:00:06 1970 PST | 4 | Thu Jan 01 00:00:08 1970 PST | -- Nested LATERALs SELECT user_id, first_order_time, time1, min_time FROM (SELECT user_id, min(time) AS first_order_time FROM orders GROUP BY user_id) o1 LEFT JOIN LATERAL (SELECT user_id as o2user_id, time AS time1 FROM orders WHERE o1.user_id = '2' AND time < now()) o2 ON true LEFT JOIN LATERAL (SELECT min(time) as min_time FROM orders WHERE o2.o2user_id = '1' AND time < now()) o3 ON true ORDER BY user_id, first_order_time, time1, min_time; user_id | first_order_time | time1 | min_time ---------+------------------------------+------------------------------+------------------------------ 1 | Thu Jan 01 00:00:01 1970 PST | | 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:01 1970 PST | Thu Jan 01 00:00:01 1970 PST 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:02 1970 PST | Thu Jan 01 00:00:01 1970 PST 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:03 1970 PST | Thu Jan 01 00:00:01 1970 PST 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:04 1970 PST | 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:05 1970 PST | Thu Jan 01 00:00:01 1970 PST 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:06 1970 PST | 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:07 1970 PST | Thu Jan 01 00:00:01 1970 PST 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:08 1970 PST | 2 | Thu Jan 01 00:00:04 1970 PST | Thu Jan 01 00:00:09 1970 PST | 3 | Thu Jan 01 00:00:06 1970 PST | | 4 | Thu Jan 01 00:00:08 1970 PST | | -- Cleanup DROP TABLE orders; ---- OUTER JOIN tests --- --github issue 2500 CREATE TABLE t1_timescale (a int, b int); CREATE TABLE t2 (a int, b int); SELECT create_hypertable('t1_timescale', 'a', chunk_time_interval=>1000); create_hypertable --------------------------- (3,public,t1_timescale,t) INSERT into t2 values (3, 3), (15 , 15); INSERT into t1_timescale select generate_series(5, 25, 1), 77; UPDATE t1_timescale SET b = 15 WHERE a = 15; SELECT * FROM t1_timescale FULL OUTER JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 ORDER BY 1, 2, 3, 4; a | b | a | b ----+----+----+---- 5 | 77 | | 6 | 77 | | 7 | 77 | | 8 | 77 | | 9 | 77 | | 10 | 77 | | 11 | 77 | | 12 | 77 | | 13 | 77 | | 14 | 77 | | 15 | 15 | 15 | 15 16 | 77 | | 17 | 77 | | 18 | 77 | | 19 | 77 | | 20 | 77 | | 21 | 77 | | 22 | 77 | | 23 | 77 | | 24 | 77 | | 25 | 77 | | | | 3 | 3 SELECT * FROM t1_timescale LEFT OUTER JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 WHERE t1_timescale.a=5 ORDER BY 1, 2, 3, 4; a | b | a | b ---+----+---+--- 5 | 77 | | SELECT * FROM t1_timescale RIGHT JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 ORDER BY 1, 2, 3, 4; a | b | a | b ----+----+----+---- 15 | 15 | 15 | 15 | | 3 | 3 SELECT * FROM t1_timescale RIGHT JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 WHERE t1_timescale.a=5 ORDER BY 1, 2, 3, 4; a | b | a | b ---+---+---+--- SELECT * FROM t1_timescale LEFT OUTER JOIN t2 on t1_timescale.a=t2.a and t2.b between 10 and 20 WHERE t1_timescale.a IN ( 10, 15, 20, 25) ORDER BY 1, 2, 3, 4; a | b | a | b ----+----+----+---- 10 | 77 | | 15 | 15 | 15 | 15 20 | 77 | | 25 | 77 | | SELECT * FROM t1_timescale RIGHT OUTER JOIN t2 on t1_timescale.a=t2.a and t2.b between 10 and 20 ORDER BY 1, 2, 3, 4; a | b | a | b ----+----+----+---- 15 | 15 | 15 | 15 | | 3 | 3 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/license.out��������������������������������������������������������0000664�0000000�0000000�00000006565�15100345067�0021022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ECHO queries SHOW timescaledb.license; timescaledb.license --------------------- apache SELECT _timescaledb_functions.tsl_loaded(); tsl_loaded ------------ f SET timescaledb.license='apache'; ERROR: invalid value for parameter "timescaledb.license": "apache" DETAIL: Cannot change a license in a running session. HINT: Change the license in the configuration file or server command line. SET timescaledb.license='timescale'; ERROR: invalid value for parameter "timescaledb.license": "timescale" DETAIL: Cannot change a license in a running session. HINT: Change the license in the configuration file or server command line. SET timescaledb.license='something_else'; ERROR: invalid value for parameter "timescaledb.license": "something_else" DETAIL: Unrecognized license type. HINT: Supported license types are 'timescale' or 'apache'. SELECT locf(1); ERROR: function "locf" is not supported under the current "apache" license HINT: Upgrade your license to 'timescale' to use this free community feature. SELECT interpolate(1); ERROR: function "interpolate" is not supported under the current "apache" license HINT: Upgrade your license to 'timescale' to use this free community feature. SELECT time_bucket_gapfill(1,1,1,1); ERROR: function "time_bucket_gapfill" is not supported under the current "apache" license HINT: Upgrade your license to 'timescale' to use this free community feature. CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS VOID AS $$ DECLARE BEGIN END; $$ LANGUAGE plpgsql; SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb); ERROR: function "add_job" is not supported under the current "apache" license HINT: Upgrade your license to 'timescale' to use this free community feature. DROP FUNCTION custom_func; CREATE TABLE metrics(time timestamptz NOT NULL, value float); SELECT create_hypertable('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics SET (timescaledb.compress); ERROR: functionality not supported under the current "apache" license. Learn more at https://tsdb.co/pdbir1r3 HINT: To access all features and the best time-series experience, try out Timescale Cloud. INSERT INTO metrics VALUES ('2022-01-01 00:00:00', 1), ('2022-01-01 01:00:00', 2), ('2022-01-01 02:00:00', 3); CREATE MATERIALIZED VIEW metrics_hourly WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, AVG(value), MAX(value), MIN(value) FROM metrics GROUP BY bucket WITH NO DATA; ERROR: functionality not supported under the current "apache" license. Learn more at https://tsdb.co/pdbir1r3 HINT: To access all features and the best time-series experience, try out Timescale Cloud. CREATE MATERIALIZED VIEW metrics_hourly AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, AVG(value), MAX(value), MIN(value) FROM metrics GROUP BY bucket; CALL refresh_continuous_aggregate('metrics_hourly', NULL, NULL); ERROR: function "refresh_continuous_aggregate" is not supported under the current "apache" license HINT: Upgrade your license to 'timescale' to use this free community feature. DROP MATERIALIZED VIEW metrics_hourly; DROP TABLE metrics; �������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/loader-oss.out�����������������������������������������������������0000664�0000000�0000000�00000046257�15100345067�0021452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_2 :TEST_DBNAME _2 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE :"TEST_DBNAME_2"; DROP EXTENSION timescaledb; --no extension SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) SELECT 1; ?column? ---------- 1 (1 row) \c :TEST_DBNAME :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-1'; WARNING: mock init "mock-1" SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data (2 rows) CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-1'; WARNING: mock post_analyze_hook "mock-1" NOTICE: extension "timescaledb" already exists, skipping CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-2'; WARNING: mock post_analyze_hook "mock-1" NOTICE: extension "timescaledb" already exists, skipping DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-1" \set ON_ERROR_STOP 0 --test that we cannot accidentally load another library version CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-2'; ERROR: extension "timescaledb" has already been loaded with another version \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER --no extension SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) SELECT 1; ?column? ---------- 1 (1 row) CREATE EXTENSION timescaledb VERSION 'mock-1'; WARNING: mock init "mock-1" --same backend as create extension; SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --start new backend; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) --test fn call after load SELECT mock_function(); WARNING: mock post_analyze_hook "mock-1" WARNING: mock function call "mock-1" mock_function --------------- (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data (2 rows) \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --test fn call as first command SELECT mock_function(); WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" WARNING: mock function call "mock-1" mock_function --------------- (1 row) --use guc to prevent loading \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.disable_load = 'on'; SELECT 1; ?column? ---------- 1 (1 row) SELECT 1; ?column? ---------- 1 (1 row) SET timescaledb.disable_load = 'off'; SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) \set ON_ERROR_STOP 0 SET timescaledb.disable_load = 'not bool'; WARNING: mock post_analyze_hook "mock-1" ERROR: parameter "timescaledb.disable_load" requires a Boolean value \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER RESET ALL; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.disable_load TO DEFAULT; SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) \c :TEST_DBNAME :ROLE_SUPERUSER RESET timescaledb.disable_load; SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.other = 'on'; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) \set ON_ERROR_STOP 0 --cannot update extension after .so of previous version already loaded ALTER EXTENSION timescaledb UPDATE TO 'mock-2'; ERROR: extension "timescaledb" cannot be updated after the old version has already been loaded \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) CREATE EXTENSION timescaledb VERSION 'mock-1'; WARNING: mock init "mock-1" SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --start a new backend to update \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER EXTENSION timescaledb UPDATE TO 'mock-2'; WARNING: mock init "mock-2" SELECT 1; WARNING: mock post_analyze_hook "mock-2" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --drop extension DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-2" SELECT 1; ?column? ---------- 1 (1 row) SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-2'; WARNING: mock init "mock-2" SELECT 1; WARNING: mock post_analyze_hook "mock-2" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data (2 rows) -- test db 1 still has old version \c :TEST_DBNAME :ROLE_SUPERUSER SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --try a broken upgrade \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT * FROM test.extension; WARNING: mock init "mock-2" WARNING: mock post_analyze_hook "mock-2" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data (2 rows) \set ON_ERROR_STOP 0 ALTER EXTENSION timescaledb UPDATE TO 'mock-3'; ERROR: extension "timescaledb" cannot be updated after the old version has already been loaded \set ON_ERROR_STOP 1 --should still be on mock-2 SELECT 1; WARNING: mock post_analyze_hook "mock-2" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --drop extension DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-2" SELECT 1; ?column? ---------- 1 (1 row) SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) --create extension anew, only upgrade was broken \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-3'; WARNING: mock init "mock-3" SELECT 1; WARNING: mock post_analyze_hook "mock-3" ?column? ---------- 1 (1 row) SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-3" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-3 | public | Enables scalable inserts and complex queries for time-series data (2 rows) DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-3" SELECT 1; ?column? ---------- 1 (1 row) --mismatched version errors \c :TEST_DBNAME_2 :ROLE_SUPERUSER --mock-4 has mismatched versions, so the .so load should be fatal SELECT format($$\! utils/test_fatal_command.sh %1$s "CREATE EXTENSION timescaledb VERSION 'mock-4'"$$, :'TEST_DBNAME_2') as command_to_run \gset :command_to_run FATAL: extension "timescaledb" version mismatch: shared library version mock-4-mismatch; SQL version mock-4 server closed the connection unexpectedly This probably means the server terminated abnormally before or while processing the request. connection to server was lost --mock-4 not installed. SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) \c :TEST_DBNAME_2 :ROLE_SUPERUSER --broken version and drop CREATE EXTENSION timescaledb VERSION 'mock-broken'; WARNING: mock init "mock-broken" \set ON_ERROR_STOP 0 --intentional broken version SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" SELECT 1; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" SELECT 1; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" --cannot drop extension; already loaded broken version DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER --can drop extension now. Since drop first command. DROP EXTENSION timescaledb; SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) --broken version and update to fixed \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-broken'; WARNING: mock init "mock-broken" \set ON_ERROR_STOP 0 --intentional broken version SELECT 1; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" --cannot update extension; already loaded bad version ALTER EXTENSION timescaledb UPDATE TO 'mock-5'; ERROR: extension "timescaledb" cannot be updated after the old version has already been loaded \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER --can update extension now. ALTER EXTENSION timescaledb UPDATE TO 'mock-5'; WARNING: mock init "mock-5" SELECT 1; WARNING: mock post_analyze_hook "mock-5" ?column? ---------- 1 (1 row) SELECT mock_function(); WARNING: mock post_analyze_hook "mock-5" WARNING: mock function call "mock-5" mock_function --------------- (1 row) \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER EXTENSION timescaledb UPDATE TO 'mock-6'; WARNING: mock init "mock-6" --The mock-5->mock_6 upgrade is intentionally broken. --The mock_function was never changed to point to mock-6 in the update script. --Thus mock_function is defined incorrectly to point to the mock-5.so --This will now be a FATAL error. SELECT format($$\! utils/test_fatal_command.sh %1$s "SELECT mock_function()"$$, :'TEST_DBNAME_2') as command_to_run \gset WARNING: mock post_analyze_hook "mock-6" :command_to_run WARNING: mock init "mock-6" WARNING: mock post_analyze_hook "mock-6" FATAL: extension "timescaledb" version mismatch: shared library version mock-5; SQL version mock-6 server closed the connection unexpectedly This probably means the server terminated abnormally before or while processing the request. connection to server was lost SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-6" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-6 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --TEST: create extension when old .so already loaded \c :TEST_DBNAME :ROLE_SUPERUSER --force load of extension with (SELECT * FROM test.extension;) SELECT * FROM test.extension; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data (2 rows) DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-1" SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb VERSION 'mock-2'; ERROR: extension "timescaledb" has already been loaded with another version \set ON_ERROR_STOP 1 SELECT * FROM test.extension; List of installed extensions Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (1 row) --can create in a new session. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-2'; WARNING: mock init "mock-2" SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" List of installed extensions Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data (2 rows) --make sure parallel workers started after a 'DISCARD ALL' work CREATE TABLE test (i int, j double precision); WARNING: mock post_analyze_hook "mock-2" INSERT INTO test SELECT x, x+0.1 FROM generate_series(1,100) AS x; WARNING: mock post_analyze_hook "mock-2" DISCARD ALL; WARNING: mock post_analyze_hook "mock-2" SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); WARNING: mock post_analyze_hook "mock-2" set_config ------------ on (1 row) SET max_parallel_workers_per_gather = 1; WARNING: mock post_analyze_hook "mock-2" SELECT count(*) FROM test; WARNING: mock post_analyze_hook "mock-2" WARNING: mock init "mock-2" count ------- 100 (1 row) -- clean up additional database \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE :"TEST_DBNAME_2" WITH (FORCE); WARNING: mock init "mock-2" WARNING: mock post_analyze_hook "mock-2" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/loader-tsl.out�����������������������������������������������������0000664�0000000�0000000�00000043637�15100345067�0021447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_2 :TEST_DBNAME _2 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE :"TEST_DBNAME_2"; DROP EXTENSION timescaledb; --no extension SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language SELECT 1; ?column? ---------- 1 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-1'; WARNING: mock init "mock-1" SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-1'; WARNING: mock post_analyze_hook "mock-1" NOTICE: extension "timescaledb" already exists, skipping CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-2'; WARNING: mock post_analyze_hook "mock-1" NOTICE: extension "timescaledb" already exists, skipping DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-1" \set ON_ERROR_STOP 0 --test that we cannot accidentally load another library version CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-2'; ERROR: extension "timescaledb" has already been loaded with another version \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER --no extension SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language SELECT 1; ?column? ---------- 1 CREATE EXTENSION timescaledb VERSION 'mock-1'; WARNING: mock init "mock-1" --same backend as create extension; SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data --start new backend; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 --test fn call after load SELECT mock_function(); WARNING: mock post_analyze_hook "mock-1" WARNING: mock function call "mock-1" mock_function --------------- SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --test fn call as first command SELECT mock_function(); WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" WARNING: mock function call "mock-1" mock_function --------------- --use guc to prevent loading \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.disable_load = 'on'; SELECT 1; ?column? ---------- 1 SELECT 1; ?column? ---------- 1 SET timescaledb.disable_load = 'off'; SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 \set ON_ERROR_STOP 0 SET timescaledb.disable_load = 'not bool'; WARNING: mock post_analyze_hook "mock-1" ERROR: parameter "timescaledb.disable_load" requires a Boolean value \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER RESET ALL; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.disable_load TO DEFAULT; SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 \c :TEST_DBNAME :ROLE_SUPERUSER RESET timescaledb.disable_load; SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.other = 'on'; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" SELECT 1; WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 \set ON_ERROR_STOP 0 --cannot update extension after .so of previous version already loaded ALTER EXTENSION timescaledb UPDATE TO 'mock-2'; ERROR: extension "timescaledb" cannot be updated after the old version has already been loaded \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language CREATE EXTENSION timescaledb VERSION 'mock-1'; WARNING: mock init "mock-1" SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data --start a new backend to update \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER EXTENSION timescaledb UPDATE TO 'mock-2'; WARNING: mock init "mock-2" SELECT 1; WARNING: mock post_analyze_hook "mock-2" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data --drop extension DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-2" SELECT 1; ?column? ---------- 1 SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-2'; WARNING: mock init "mock-2" SELECT 1; WARNING: mock post_analyze_hook "mock-2" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data -- test db 1 still has old version \c :TEST_DBNAME :ROLE_SUPERUSER SELECT 1; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-1" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data --try a broken upgrade \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT * FROM test.extension; WARNING: mock init "mock-2" WARNING: mock post_analyze_hook "mock-2" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data \set ON_ERROR_STOP 0 ALTER EXTENSION timescaledb UPDATE TO 'mock-3'; ERROR: extension "timescaledb" cannot be updated after the old version has already been loaded \set ON_ERROR_STOP 1 --should still be on mock-2 SELECT 1; WARNING: mock post_analyze_hook "mock-2" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data --drop extension DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-2" SELECT 1; ?column? ---------- 1 SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language --create extension anew, only upgrade was broken \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-3'; WARNING: mock init "mock-3" SELECT 1; WARNING: mock post_analyze_hook "mock-3" ?column? ---------- 1 SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-3" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-3 | public | Enables scalable inserts and complex queries for time-series data DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-3" SELECT 1; ?column? ---------- 1 --mismatched version errors \c :TEST_DBNAME_2 :ROLE_SUPERUSER --mock-4 has mismatched versions, so the .so load should be fatal SELECT format($$\! utils/test_fatal_command.sh %1$s "CREATE EXTENSION timescaledb VERSION 'mock-4'"$$, :'TEST_DBNAME_2') as command_to_run \gset :command_to_run FATAL: extension "timescaledb" version mismatch: shared library version mock-4-mismatch; SQL version mock-4 server closed the connection unexpectedly This probably means the server terminated abnormally before or while processing the request. connection to server was lost --mock-4 not installed. SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language \c :TEST_DBNAME_2 :ROLE_SUPERUSER --broken version and drop CREATE EXTENSION timescaledb VERSION 'mock-broken'; WARNING: mock init "mock-broken" \set ON_ERROR_STOP 0 --intentional broken version SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" SELECT 1; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" SELECT 1; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" --cannot drop extension; already loaded broken version DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER --can drop extension now. Since drop first command. DROP EXTENSION timescaledb; SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language --broken version and update to fixed \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-broken'; WARNING: mock init "mock-broken" \set ON_ERROR_STOP 0 --intentional broken version SELECT 1; WARNING: mock post_analyze_hook "mock-broken" ERROR: mock broken "mock-broken" --cannot update extension; already loaded bad version ALTER EXTENSION timescaledb UPDATE TO 'mock-5'; ERROR: extension "timescaledb" cannot be updated after the old version has already been loaded \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER --can update extension now. ALTER EXTENSION timescaledb UPDATE TO 'mock-5'; WARNING: mock init "mock-5" SELECT 1; WARNING: mock post_analyze_hook "mock-5" ?column? ---------- 1 SELECT mock_function(); WARNING: mock post_analyze_hook "mock-5" WARNING: mock function call "mock-5" mock_function --------------- \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER EXTENSION timescaledb UPDATE TO 'mock-6'; WARNING: mock init "mock-6" --The mock-5->mock_6 upgrade is intentionally broken. --The mock_function was never changed to point to mock-6 in the update script. --Thus mock_function is defined incorrectly to point to the mock-5.so --This will now be a FATAL error. SELECT format($$\! utils/test_fatal_command.sh %1$s "SELECT mock_function()"$$, :'TEST_DBNAME_2') as command_to_run \gset WARNING: mock post_analyze_hook "mock-6" :command_to_run WARNING: mock init "mock-6" WARNING: mock post_analyze_hook "mock-6" FATAL: extension "timescaledb" version mismatch: shared library version mock-5; SQL version mock-6 server closed the connection unexpectedly This probably means the server terminated abnormally before or while processing the request. connection to server was lost SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-6" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-6 | public | Enables scalable inserts and complex queries for time-series data --TEST: create extension when old .so already loaded \c :TEST_DBNAME :ROLE_SUPERUSER SELECT * FROM test.extension; WARNING: mock init "mock-1" WARNING: mock post_analyze_hook "mock-1" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-1 | public | Enables scalable inserts and complex queries for time-series data DROP EXTENSION timescaledb; WARNING: mock post_analyze_hook "mock-1" SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb VERSION 'mock-2'; ERROR: extension "timescaledb" has already been loaded with another version \set ON_ERROR_STOP 1 SELECT * FROM test.extension; Name | Version | Schema | Description ---------+---------+------------+------------------------------ plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language --can create in a new session. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-2'; WARNING: mock init "mock-2" SELECT * FROM test.extension; WARNING: mock post_analyze_hook "mock-2" Name | Version | Schema | Description -------------+---------+------------+------------------------------------------------------------------- plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language timescaledb | mock-2 | public | Enables scalable inserts and complex queries for time-series data --make sure parallel workers started after a 'DISCARD ALL' work CREATE TABLE test (i int, j double precision); WARNING: mock post_analyze_hook "mock-2" INSERT INTO test SELECT x, x+0.1 FROM generate_series(1,100) AS x; WARNING: mock post_analyze_hook "mock-2" DISCARD ALL; WARNING: mock post_analyze_hook "mock-2" SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); WARNING: mock post_analyze_hook "mock-2" set_config ------------ on SET max_parallel_workers_per_gather = 1; WARNING: mock post_analyze_hook "mock-2" SELECT count(*) FROM test; WARNING: mock post_analyze_hook "mock-2" WARNING: mock init "mock-2" count ------- 100 CREATE EXTENSION timescaledb_osm VERSION 'mock-1'; WARNING: mock post_analyze_hook "mock-2" WARNING: mock post_analyze_hook "mock-2" WARNING: OSM-mock-1 _PG_init WARNING: got lwlock osm lock WARNING: mock post_analyze_hook "mock-2" WARNING: mock post_analyze_hook "mock-2" -- Test that OSM process utility hook works: it should see this DROP TABLE. DROP TABLE test; WARNING: mock post_analyze_hook "mock-2" NOTICE: OSM-mock-1 got DROP TABLE 'test' -- clean up additional database \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE :"TEST_DBNAME_2" WITH (FORCE); WARNING: mock init "mock-2" WARNING: mock post_analyze_hook "mock-2" �������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/merge.out����������������������������������������������������������0000664�0000000�0000000�00000076460�15100345067�0020500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Create target table with location and temperature CREATE TABLE target ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL, to_be_dropped text ); SELECT create_hypertable( 'target', 'time', chunk_time_interval => INTERVAL '5 seconds'); create_hypertable --------------------- (1,public,target,t) INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- This makes sure we have one column with attisdropped and one column -- with atthasmissing set to true. These two cases can cause problems -- with chunk dispatch execution when merging using a when-clause with -- inserts. Unfortunately they are hard to trigger, so this is not a -- definitive test. ALTER TABLE target DROP COLUMN to_be_dropped; ALTER TABLE target ADD COLUMN val text default 'string -'; -- Create source table with location and temperature CREATE TABLE source ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable( 'source', 'time', chunk_time_interval => INTERVAL '5 seconds'); create_hypertable --------------------- (2,public,source,t) -- Generate data that overlaps with target table INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- Print table/rows/num of chunks select * from target order by time, location asc; time | location | temperature | val ------------------------------+----------+-------------+---------- Fri Jan 01 00:00:00 2021 PST | 1 | 14 | string - Fri Jan 01 00:00:00 2021 PST | 2 | 14 | string - Fri Jan 01 00:00:00 2021 PST | 3 | 14 | string - Fri Jan 01 00:00:00 2021 PST | 4 | 14 | string - Fri Jan 01 00:00:05 2021 PST | 1 | 14 | string - Fri Jan 01 00:00:05 2021 PST | 2 | 14 | string - Fri Jan 01 00:00:05 2021 PST | 3 | 14 | string - Fri Jan 01 00:00:05 2021 PST | 4 | 14 | string - select * from source order by time, location asc; time | location | temperature ------------------------------+----------+------------- Fri Jan 01 00:00:05 2021 PST | 1 | 80 Fri Jan 01 00:00:05 2021 PST | 2 | 80 Fri Jan 01 00:00:05 2021 PST | 3 | 80 Fri Jan 01 00:00:05 2021 PST | 4 | 80 Fri Jan 01 00:00:10 2021 PST | 1 | 80 Fri Jan 01 00:00:10 2021 PST | 2 | 80 Fri Jan 01 00:00:10 2021 PST | 3 | 80 Fri Jan 01 00:00:10 2021 PST | 4 | 80 -- CREATE normal PostgreSQL tables CREATE TABLE target_pg AS SELECT * FROM target; CREATE TABLE source_pg AS SELECT * FROM source; -- Merge UPDATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- Merge UPDATE matched rows for hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- Merge DELETE matched rows for hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- clean up tables DELETE FROM target_pg; DELETE FROM target; DELETE FROM source_pg; DELETE FROM source; INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO target_pg SELECT * FROM target; INSERT INTO source_pg SELECT * FROM source; -- Merge UPDATE matched rows and INSERT new row for unmatched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE' WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- Merge UPDATE matched rows and INSERT new row for unmatched rows for hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE' WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge INSERT with constant literals for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- Merge INSERT with constant literals for hypertables MERGE INTO target t USING source s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge with INSERT/DELETE/UPDATE on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.location = 560076 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.location = 560083 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- Merge with INSERT/DELETE/UPDATE on hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.location = 560076 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.location = 560083 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge with Subqueries on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location > (SELECT count(*) FROM source_pg) WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (SELECT count(*) FROM target_pg) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'SUBQUERY string - INSERTED BY MERGE'); -- Merge with Subqueries on hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location > (SELECT count(*) FROM source) WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (SELECT count(*) FROM target) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'SUBQUERY string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- clean up tables DELETE FROM target_pg; DELETE FROM target; DELETE FROM source_pg; DELETE FROM source; -- TEST with target as hypertable and source as normal PG table INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO target_pg SELECT * FROM target; INSERT INTO source_pg SELECT * FROM source; -- Merge UPDATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- Merge UPDATE with target as hypertables and source as normal PG tables MERGE INTO target t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- Merge DELETE with target as hypertables and source as normal PG tables MERGE INTO target t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge INSERT with constant literals for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- Merge INSERT with constant literals for target as hypertables and source as normal PG tables MERGE INTO target t USING source s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge with INSERT/DELETE/UPDATE on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- Merge with INSERT/DELETE/UPDATE on target as hypertables and source as normal PG tables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same DROP TABLE target_pg CASCADE; DROP TABLE target CASCADE; DROP TABLE source_pg CASCADE; DROP TABLE source CASCADE; -- test MERGE with source being a PARTITION table CREATE TABLE source_pg( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_source_pky PRIMARY KEY (id) ) PARTITION BY LIST (id); CREATE TABLE source_1_2_3_4 PARTITION OF source_pg FOR VALUES IN (1,2,3,4); CREATE TABLE source_5_6_7_8 PARTITION OF source_pg FOR VALUES IN (5,6,7,8); INSERT INTO source_pg SELECT generate_series(1,8), 44,55; CREATE TABLE target ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES source_pg(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'target', time_column_name => 'ts' ); create_hypertable --------------------- (3,public,target,t) insert into target values ('2023-01-12 00:00:05'::timestamp with time zone, 1,2); insert into target values ('2023-01-12 00:00:10'::timestamp with time zone, 2,2); insert into target values ('2023-01-12 00:00:15'::timestamp with time zone, 3,2); insert into target values ('2023-01-12 00:00:20'::timestamp with time zone, 4,2); insert into target values ('2023-01-14 00:00:25'::timestamp with time zone, 5,2); insert into target values ('2023-01-14 00:00:30'::timestamp with time zone, 6,2); insert into target values ('2023-01-14 00:00:35'::timestamp with time zone, 7,2); insert into target values ('2023-01-14 00:00:40'::timestamp with time zone, 8,2); CREATE TABLE target_pg AS SELECT * FROM target; -- Merge UPDATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.id = s.id WHEN MATCHED THEN UPDATE SET dev = (t.dev + s.dev)/2; -- Merge UPDATE matched rows for hypertables MERGE INTO target t USING source_pg s ON t.id = s.id WHEN MATCHED THEN UPDATE SET dev = (t.dev + s.dev)/2; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.id = s.id WHEN MATCHED THEN DELETE; -- Merge DELETE matched rows for hypertables MERGE INTO target t USING source_pg s ON t.id = s.id WHEN MATCHED THEN DELETE; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- clean up tables DROP TABLE target_pg CASCADE; DROP TABLE target CASCADE; DROP TABLE source_pg CASCADE; -- test MERGE with hypertables with time and space partitions CREATE TABLE target ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('target', 'time', 'device_id', 5); create_hypertable --------------------- (4,public,target,t) SELECT add_dimension('target', 'device_id_peer', 5); add_dimension ------------------------------------ (6,public,target,device_id_peer,t) SELECT add_dimension('target', 'v2', 5); add_dimension ------------------------ (7,public,target,v2,t) INSERT INTO target (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); CREATE TABLE source ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int ); SELECT create_hypertable ('source', 'time', 'device_id', 3); create_hypertable --------------------- (5,public,source,t) INSERT INTO source (time, device_id, filler_2, filler_3, filler_1) SELECT time, device_id, device_id + 134, device_id + 209, device_id + 0.50127 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); -- create PG tables to compare PG target and hypertable target tables CREATE table target_pg as SELECT * FROM target; CREATE table source_pg as SELECT * FROM source; -- Merge UDPATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET filler_2 = s.filler_1 + 100; -- Merge UDPATE matched rows for space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET filler_2 = s.filler_1 + 100; SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- Merge DELETE matched rows for space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge INSERT matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); -- Merge INSERT matched rows for space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- Merge with INSERT/DELETE/UPDATE on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED AND t.device_id_peer = 2 THEN UPDATE SET filler_2 = s.filler_1 + s.filler_2 + s.filler_3 + 100 WHEN MATCHED AND t.device_id_peer = 7 THEN DELETE WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); -- Merge with INSERT/DELETE/UPDATE on space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED AND t.device_id_peer = 2 THEN UPDATE SET filler_2 = s.filler_1 + s.filler_2 + s.filler_3 + 100 WHEN MATCHED AND t.device_id_peer = 7 THEN DELETE WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same -- clean up tables DROP TABLE target_pg CASCADE; DROP TABLE target CASCADE; DROP TABLE source_pg CASCADE; DROP TABLE source CASCADE; -- TEST with parition column place after similar data type column CREATE TABLE target ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float, partition_column TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('target', 'partition_column'); create_hypertable --------------------- (6,public,target,t) INSERT INTO target (time, device_id, device_id_peer, v0, v1, v2, v3, partition_column) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL, time + interval '10m' FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); CREATE TABLE source ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int ); SELECT create_hypertable ('source', 'time', 'device_id', 3); create_hypertable --------------------- (7,public,source,t) INSERT INTO source (time, device_id, filler_2, filler_3, filler_1) SELECT time, device_id, device_id + 134, device_id + 209, device_id + 0.50127 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); -- create PG tables to compare PG target and hypertable target tables CREATE table target_pg as SELECT * FROM target; MERGE INTO target_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, device_id_peer, v0, v1, v2, v3, partition_column) VALUES ('2010-01-06 05:30:00+05:30', 23, 2, 11, 22, 33, 44, '2023-01-06 05:33:00+05:30'); MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, device_id_peer, v0, v1, v2, v3, partition_column) VALUES ('2010-01-06 05:30:00+05:30', 23, 2, 11, 22, 33, 44, '2023-01-06 05:33:00+05:30'); SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same MERGE INTO target_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; result -------- same MERGE INTO target_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); -- time dimension column is NULL, this will report an null constraint violation error \set ON_ERROR_STOP 0 MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); ERROR: NULL value in column "partition_column" violates not-null constraint \set ON_ERROR_STOP 1 DROP TABLE target CASCADE; DROP TABLE target_pg CASCADE; DROP TABLE source CASCADE; -- TEST with target table have CHECK constraints CREATE TABLE target ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL CHECK (temperature > 10), val text default 'string -' ); SELECT create_hypertable( 'target', 'time', chunk_time_interval => INTERVAL '5 seconds'); create_hypertable --------------------- (8,public,target,t) INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- Create source table with location and temperature CREATE TABLE source ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL ); -- Generate data that overlaps with target table INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- CREATE normal PostgreSQL tables CREATE TABLE target_pg AS SELECT * FROM target; -- Merge UPDATE/DELETE with DO NOTHING on pg tables MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN DO NOTHING; -- Merge UPDATE/DELETE with DO NOTHING on hypertable MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN DO NOTHING; -- Error cases for Merge \set ON_ERROR_STOP 0 -- Merge UPDATE should fail with check constraint violation MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE'; -- Merge UPDATE should fail with check constraint violation MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE'; ERROR: new row for relation "_hyper_8_24_chunk" violates check constraint "target_temperature_check" -- Merge error with unreachable WHEN clause on pg tables MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.time < now() THEN DELETE WHEN NOT MATCHED THEN DO NOTHING; ERROR: unreachable WHEN clause specified after unconditional WHEN clause -- Merge error with unreachable WHEN clause on hypertable MERGE INTO target t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.time < now() THEN DELETE WHEN NOT MATCHED THEN DO NOTHING; ERROR: unreachable WHEN clause specified after unconditional WHEN clause -- Merge error with unknown action in MERGE WHEN MATCHED clause on pg tables MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN SELECT 1; ERROR: syntax error at or near "SELECT" at character 105 -- Merge error with unknown action in MERGE WHEN MATCHED clause on hypertable MERGE INTO target t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN SELECT 1; ERROR: syntax error at or near "SELECT" at character 102 -- Merge error cannot affect row a second time on pg tables MERGE INTO target_pg t USING source s ON t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 28, val = val || ' UPDATED BY MERGE'; ERROR: MERGE command cannot affect row a second time -- Merge error cannot affect row a second time on hypertable MERGE INTO target t USING source s ON t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 28, val = val || ' UPDATED BY MERGE'; ERROR: MERGE command cannot affect row a second time \set ON_ERROR_STOP 1 DROP TABLE target CASCADE; DROP TABLE target_pg CASCADE; DROP TABLE source CASCADE; -- TEST for PERMISSIONS CREATE USER priv_user; CREATE USER non_priv_user; CREATE TABLE target ( value DOUBLE PRECISION NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT table_name FROM create_hypertable( 'target'::regclass, 'time'::name, chunk_time_interval=>interval '8 hours', create_default_indexes=> false); table_name ------------ target SELECT '2022-10-10 14:33:44.1234+05:30' as start_date \gset INSERT INTO target (value, time) SELECT 1,t from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '5m') t cross join generate_series(1,3) s; CREATE TABLE source ( time TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL, value DOUBLE PRECISION NOT NULL ); SELECT table_name FROM create_hypertable( 'source'::regclass, 'time'::name, chunk_time_interval=>interval '6 hours', create_default_indexes=> false); table_name ------------ source ALTER TABLE target OWNER TO priv_user; ALTER TABLE source OWNER TO priv_user; GRANT SELECT ON source TO non_priv_user; SET SESSION AUTHORIZATION non_priv_user; \set ON_ERROR_STOP 0 -- non_priv_user does not have UPDATE privilege on target table MERGE INTO target USING source ON target.time = source.time WHEN MATCHED THEN UPDATE SET value = 0; ERROR: permission denied for table target -- non_priv_user does not have DELETE privilege on target table MERGE INTO target USING source ON target.time = source.time WHEN MATCHED THEN DELETE; ERROR: permission denied for table target -- non_priv_user does not have INSERT privilege on target table MERGE INTO target USING source ON target.time = source.time WHEN NOT MATCHED THEN INSERT VALUES (10, '2023-01-15 00:00:10'::timestamp with time zone); ERROR: permission denied for table target \set ON_ERROR_STOP 1 RESET SESSION AUTHORIZATION; DROP TABLE target; DROP TABLE source; DROP USER priv_user; DROP USER non_priv_user; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/metadata.out�������������������������������������������������������0000664�0000000�0000000�00000011113�15100345067�0021141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_uuid() RETURNS UUID AS :MODULE_PATHNAME, 'ts_test_uuid' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_exported_uuid() RETURNS UUID AS :MODULE_PATHNAME, 'ts_test_exported_uuid' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_install_timestamp() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_test_install_timestamp' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; INSERT INTO _timescaledb_catalog.metadata (key, value, include_in_telemetry) SELECT 'metadata_test', 'FOO', TRUE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- uuid and install_timestamp should already be in the table before we generate SELECT COUNT(*) from _timescaledb_catalog.metadata; count ------- 4 SELECT _timescaledb_internal.test_uuid() as uuid_1 \gset SELECT _timescaledb_internal.test_exported_uuid() as uuid_ex_1 \gset SELECT _timescaledb_internal.test_install_timestamp() as timestamp_1 \gset -- Check that there is exactly 1 UUID row SELECT COUNT(*) from _timescaledb_catalog.metadata where key='uuid'; count ------- 1 -- Check that exported_uuid and timestamp are also generated SELECT COUNT(*) from _timescaledb_catalog.metadata where key='exported_uuid'; count ------- 1 SELECT COUNT(*) from _timescaledb_catalog.metadata where key='install_timestamp'; count ------- 1 -- Make sure that the UUID is idempotent SELECT _timescaledb_internal.test_uuid() = :'uuid_1' as uuids_equal; uuids_equal ------------- t SELECT _timescaledb_internal.test_uuid() = :'uuid_1' as uuids_equal; uuids_equal ------------- t -- Also make sure install_time and exported_uuid are idempotent SELECT _timescaledb_internal.test_exported_uuid() = :'uuid_ex_1' as exported_uuids_equal; exported_uuids_equal ---------------------- t SELECT _timescaledb_internal.test_exported_uuid() = :'uuid_ex_1' as exported_uuids_equal; exported_uuids_equal ---------------------- t SELECT _timescaledb_internal.test_install_timestamp() = :'timestamp_1' as timestamps_equal; timestamps_equal ------------------ t SELECT _timescaledb_internal.test_install_timestamp() = :'timestamp_1' as timestamps_equal; timestamps_equal ------------------ t -- Now make sure that only the exported_uuid is exported on pg_dump \c postgres :ROLE_SUPERUSER \setenv PGOPTIONS '--client-min-messages=warning' \! utils/pg_dump_aux_dump.sh dump/instmeta.sql ALTER DATABASE :TEST_DBNAME SET timescaledb.restoring='on'; -- Redirect to /dev/null to suppress NOTICE \! utils/pg_dump_aux_restore.sh dump/instmeta.sql ALTER DATABASE :TEST_DBNAME SET timescaledb.restoring='off'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Should have all 3 row, because pg_dump includes the insertion of uuid and timestamp. SELECT COUNT(*) FROM _timescaledb_catalog.metadata; count ------- 5 -- Verify that this is the old exported_uuid SELECT _timescaledb_internal.test_exported_uuid() = :'uuid_ex_1' as exported_uuids_equal; exported_uuids_equal ---------------------- t -- Verify that the uuid is new SELECT _timescaledb_internal.test_uuid() = :'uuid_1' as exported_uuids_diff; exported_uuids_diff --------------------- f -- Verify that the install_timestamp got restored SELECT _timescaledb_internal.test_install_timestamp() = :'timestamp_1' as timestamps_equal; timestamps_equal ------------------ t SELECT * FROM _timescaledb_catalog.metadata WHERE key = 'metadata_test'; key | value | include_in_telemetry ---------------+-------+---------------------- metadata_test | FOO | t -- check metadata version matches expected value SELECT x.extversion = m.value AS "version match" FROM pg_extension x JOIN _timescaledb_catalog.metadata m ON m.key='timescaledb_version' WHERE x.extname='timescaledb'; version match --------------- t -- test version check in post_restore \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.metadata SET value = '1.2.3' WHERE key = 'timescaledb_version'; \set ON_ERROR_STOP 0 -- set verbosity to sqlstate to suppress version dependant error message \set VERBOSITY sqlstate SELECT timescaledb_post_restore(); ERROR: P0001 \set ON_ERROR_STOP 1 UPDATE _timescaledb_catalog.metadata m SET value = x.extversion FROM pg_extension x WHERE m.key = 'timescaledb_version' AND x.extname='timescaledb'; SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/multi_transaction_index.out����������������������������������������0000664�0000000�0000000�00000055420�15100345067�0024320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE index_test(id serial, time timestamptz, device integer, temp float); SELECT * FROM test.show_columns('index_test'); Column | Type | NotNull --------+--------------------------+--------- id | integer | t time | timestamp with time zone | f device | integer | f temp | double precision | f -- Test that we can handle difference in attnos across hypertable and -- chunks by dropping the ID column ALTER TABLE index_test DROP COLUMN id; SELECT * FROM test.show_columns('index_test'); Column | Type | NotNull --------+--------------------------+--------- time | timestamp with time zone | f device | integer | f temp | double precision | f -- No pre-existing UNIQUE index, so partitioning on two columns should work SELECT create_hypertable('index_test', 'time', 'device', 2); create_hypertable ------------------------- (1,public,index_test,t) INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 1, 17.5); \set ON_ERROR_STOP 0 -- cannot create a UNIQUE index with transaction_per_chunk CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time) WITH (timescaledb.transaction_per_chunk); ERROR: cannot use timescaledb.transaction_per_chunk with UNIQUE or PRIMARY KEY CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time, device) WITH(timescaledb.transaction_per_chunk); ERROR: cannot use timescaledb.transaction_per_chunk with UNIQUE or PRIMARY KEY \set ON_ERROR_STOP 1 CREATE INDEX index_test_time_device_idx ON index_test (time, device) WITH (timescaledb.transaction_per_chunk); -- Regular index need not cover all partitioning columns CREATE INDEX ON index_test (time, temp) WITH (timescaledb.transaction_per_chunk); -- Create another chunk INSERT INTO index_test VALUES ('2017-04-20T09:00:01', 1, 17.5); -- New index should have been recursed to chunks SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_device_idx | {time,device} | | f | f | f | index_test_time_idx | {time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk') ORDER BY 1,2; Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_device_idx | {time,device} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_device_idx | {time,device} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | ALTER INDEX index_test_time_idx RENAME TO index_test_time_idx2; -- Metadata and index should have changed name SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_device_idx | {time,device} | | f | f | f | index_test_time_idx2 | {time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk') ORDER BY 1,2; Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_idx2 | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_device_idx | {time,device} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_idx2 | {time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_device_idx | {time,device} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | DROP INDEX index_test_time_idx2; DROP INDEX index_test_time_device_idx; -- Index should have been dropped SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | -- Create index with long name to see how this is handled on chunks CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates ON index_test (time ASC, temp DESC) WITH (timescaledb.transaction_per_chunk); CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2 ON index_test (time DESC, temp ASC) WITH (timescaledb.transaction_per_chunk); SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ a_hypertable_index_with_a_very_very_long_name_that_truncates | {time,temp} | | f | f | f | a_hypertable_index_with_a_very_very_long_name_that_truncates_2 | {time,temp} | | f | f | f | index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+---------------------------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_a_hypertable_index_with_a_very_very_long_name_ | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_a_hypertable_index_with_a_very_very_long_nam_1 | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_a_hypertable_index_with_a_very_very_long_name_ | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_a_hypertable_index_with_a_very_very_long_nam_1 | {time,temp} | | f | f | f | DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates; DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2; SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | -- Add constraint index ALTER TABLE index_test ADD UNIQUE (time, device); SELECT * FROM test.show_indexes('index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------+---------------+------+--------+---------+-----------+------------ index_test_device_time_idx | {device,time} | | f | f | f | index_test_time_device_key | {time,device} | | t | f | f | index_test_time_temp_idx | {time,temp} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+-------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal."1_1_index_test_time_device_key" | {time,device} | | t | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_device_time_idx | {device,time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_index_test_time_temp_idx | {time,temp} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal."2_2_index_test_time_device_key" | {time,device} | | t | f | f | -- Constraints are added to chunk_constraint table. SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+--------------------------------+---------------------------- 1 | 1 | constraint_1 | 1 | 2 | constraint_2 | 2 | 3 | constraint_3 | 2 | 2 | constraint_2 | 1 | | 1_1_index_test_time_device_key | index_test_time_device_key 2 | | 2_2_index_test_time_device_key | index_test_time_device_key DROP TABLE index_test; -- Test that indexes are planned correctly CREATE TABLE index_expr_test(id serial, time timestamptz, temp float, meta int); select create_hypertable('index_expr_test', 'time'); create_hypertable ------------------------------ (2,public,index_expr_test,t) -- Screw up the attribute numbers ALTER TABLE index_expr_test DROP COLUMN id; CREATE INDEX ON index_expr_test (meta) WITH (timescaledb.transaction_per_chunk); INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, 1); INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, 2); SET enable_seqscan TO false; SET enable_bitmapscan TO false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM index_expr_test WHERE meta = 1; --- QUERY PLAN --- Index Scan using _hyper_2_3_chunk_index_expr_test_meta_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk."time", _hyper_2_3_chunk.temp, _hyper_2_3_chunk.meta Index Cond: (_hyper_2_3_chunk.meta = 1) SELECT * FROM index_expr_test WHERE meta = 1; time | temp | meta ------------------------------+------+------ Fri Jan 20 09:00:01 2017 PST | 17.5 | 1 SET enable_seqscan TO default; SET enable_bitmapscan TO default; \set ON_ERROR_STOP 0 -- cannot create a transaction_per_chunk index within a transaction block BEGIN; CREATE INDEX ON index_expr_test (temp) WITH (timescaledb.transaction_per_chunk); ERROR: CREATE INDEX ... WITH (timescaledb.transaction_per_chunk) cannot run inside a transaction block ROLLBACK; \set ON_ERROR_STOP 1 DROP TABLE index_expr_test CASCADE; CREATE TABLE partial_index_test(time INTEGER); SELECT create_hypertable('partial_index_test', 'time', chunk_time_interval => 1, create_default_indexes => false); create_hypertable --------------------------------- (3,public,partial_index_test,t) -- create 3 chunks INSERT INTO partial_index_test(time) SELECT generate_series(0, 2); select * from partial_index_test order by 1; time ------ 0 1 2 -- create indexes on only 1 of the chunks CREATE INDEX ON partial_index_test (time) WITH (timescaledb.transaction_per_chunk, timescaledb.max_chunks='1'); SELECT * FROM test.show_indexes('partial_index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -----------------------------+---------+------+--------+---------+-----------+------------ partial_index_test_time_idx | {time} | | f | f | f | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------+---------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_3_4_chunk | _timescaledb_internal._hyper_3_4_chunk_partial_index_test_time_idx | {time} | | f | f | f | -- regerssion test for bug fixed by PR #1008. -- this caused an assertion failure when a MergeAppend node contained unsorted children SET enable_bitmapscan TO false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; --- QUERY PLAN --- Limit Output: partial_index_test."time" -> Custom Scan (ChunkAppend) on public.partial_index_test Output: partial_index_test."time" Order: partial_index_test."time" Startup Exclusion: false Runtime Exclusion: false -> Index Only Scan using _hyper_3_4_chunk_partial_index_test_time_idx on _timescaledb_internal._hyper_3_4_chunk Output: _hyper_3_4_chunk."time" Index Cond: (_hyper_3_4_chunk."time" < 2) -> Sort Output: _hyper_3_5_chunk."time" Sort Key: _hyper_3_5_chunk."time" -> Seq Scan on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk."time" Filter: (_hyper_3_5_chunk."time" < 2) SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; time ------ 0 1 -- we can drop the partially created index DROP INDEX partial_index_test_time_idx; SELECT * FROM test.show_indexes('partial_index_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------+---------+------+--------+---------+-----------+------------ SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------+-------+---------+------+--------+---------+-----------+------------ EXPLAIN (verbose, buffers off, costs off) SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; --- QUERY PLAN --- Limit Output: partial_index_test."time" -> Sort Output: partial_index_test."time" Sort Key: partial_index_test."time" -> Append -> Seq Scan on _timescaledb_internal._hyper_3_4_chunk Output: _hyper_3_4_chunk."time" Filter: (_hyper_3_4_chunk."time" < 2) -> Seq Scan on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk."time" Filter: (_hyper_3_5_chunk."time" < 2) SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; time ------ 0 1 SET enable_seqscan TO true; SET enable_bitmapscan TO true; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CREATE INDEX ON partial_index_test (time) WITH (timescaledb.transaction_per_chunk, timescaledb.max_chunks='1'); ERROR: must be owner of hypertable "partial_index_test" \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/net.out������������������������������������������������������������0000664�0000000�0000000�00000002475�15100345067�0020162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_http_parsing(int) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_http_parsing' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_http_parsing_full() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_http_parsing_full' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_http_request_build() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_http_request_build' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_conn() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_conn' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT _timescaledb_internal.test_http_parsing(10000); test_http_parsing ------------------- SELECT _timescaledb_internal.test_http_parsing_full(); test_http_parsing_full ------------------------ SELECT _timescaledb_internal.test_http_request_build(); test_http_request_build ------------------------- SELECT _timescaledb_internal.test_conn(); test_conn ----------- ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/null_exclusion-15.out����������������������������������������������0000664�0000000�0000000�00000013355�15100345067�0022661�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. create table metrics(ts timestamp, id int, value float); select create_hypertable('metrics', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ---------------------- (1,public,metrics,t) insert into metrics values ('2022-02-02 02:02:02', 2, 2.), ('2023-03-03 03:03:03', 3, 3.); analyze metrics; -- non-const condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) Index Cond: (ts IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) Index Cond: (ts IS NOT NULL) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= $1) -> Seq Scan on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (ts >= $1) -- two non-const conditions explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) Index Cond: (ts IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) Index Cond: (ts IS NOT NULL) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= $1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ((ts >= $1) AND (id = 1)) Rows Removed by Filter: 1 -- condition that becomes const null after evaluating the param explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= $1) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (ts >= $1) -- const null condition and some other condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= $1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ((ts >= $1) AND (id = 1)) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/null_exclusion-16.out����������������������������������������������0000664�0000000�0000000�00000013355�15100345067�0022662�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. create table metrics(ts timestamp, id int, value float); select create_hypertable('metrics', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ---------------------- (1,public,metrics,t) insert into metrics values ('2022-02-02 02:02:02', 2, 2.), ('2023-03-03 03:03:03', 3, 3.); analyze metrics; -- non-const condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) Index Cond: (ts IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) Index Cond: (ts IS NOT NULL) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= $1) -> Seq Scan on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (ts >= $1) -- two non-const conditions explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) Index Cond: (ts IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) Index Cond: (ts IS NOT NULL) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= $1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ((ts >= $1) AND (id = 1)) Rows Removed by Filter: 1 -- condition that becomes const null after evaluating the param explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= $1) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (ts >= $1) -- const null condition and some other condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Index Cond: (ts IS NOT NULL) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= $1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ((ts >= $1) AND (id = 1)) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/null_exclusion-17.out����������������������������������������������0000664�0000000�0000000�00000012435�15100345067�0022661�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. create table metrics(ts timestamp, id int, value float); select create_hypertable('metrics', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ---------------------- (1,public,metrics,t) insert into metrics values ('2022-02-02 02:02:02', 2, 2.), ('2023-03-03 03:03:03', 3, 3.); analyze metrics; -- non-const condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= (InitPlan 2).col1) -> Seq Scan on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (ts >= (InitPlan 2).col1) -- two non-const conditions explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) Rows Removed by Filter: 1 -- condition that becomes const null after evaluating the param explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= (InitPlan 2).col1) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (ts >= (InitPlan 2).col1) -- const null condition and some other condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/null_exclusion-18.out����������������������������������������������0000664�0000000�0000000�00000012435�15100345067�0022662�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. create table metrics(ts timestamp, id int, value float); select create_hypertable('metrics', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ---------------------- (1,public,metrics,t) insert into metrics values ('2022-02-02 02:02:02', 2, 2.), ('2023-03-03 03:03:03', 3, 3.); analyze metrics; -- non-const condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= (InitPlan 2).col1) -> Seq Scan on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (ts >= (InitPlan 2).col1) -- two non-const conditions explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 1 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1.ts DESC -> Index Only Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) Rows Removed by Filter: 1 -- condition that becomes const null after evaluating the param explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: (ts >= (InitPlan 2).col1) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (ts >= (InitPlan 2).col1) -- const null condition and some other condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1) and id = 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=0.00 loops=1) Order: metrics_1.ts DESC -> Index Scan using _hyper_1_2_chunk_metrics_ts_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_1_chunk_metrics_ts_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=0.00 loops=1) Filter: (id = '-1'::integer) Rows Removed by Filter: 1 -> Seq Scan on _hyper_1_1_chunk (never executed) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ((ts >= (InitPlan 2).col1) AND (id = 1)) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/parallel-15.out����������������������������������������������������0000664�0000000�0000000�00000103722�15100345067�0021410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --parallel queries require big-ish tables so collect them all here --so that we need to generate queries only once. -- output with analyze is not stable because it depends on worker assignment \set PREFIX 'EXPLAIN (buffers off, costs off)' \set CHUNK1 _timescaledb_internal._hyper_1_1_chunk \set CHUNK2 _timescaledb_internal._hyper_1_2_chunk CREATE TABLE test (i int, j double precision, ts timestamp); SELECT create_hypertable('test','i',chunk_time_interval:=500000); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------- (1,public,test,t) INSERT INTO test SELECT x, x+0.1, _timescaledb_functions.to_timestamp(x*1000) FROM generate_series(0,1000000-1,10) AS x; ANALYZE test; ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=2); SET work_mem TO '50MB'; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost TO 0; EXPLAIN (buffers off, costs off) SELECT first(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT first(i, j) FROM "test"; first ------- 0 EXPLAIN (buffers off, costs off) SELECT last(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT last(i, j) FROM "test"; last -------- 999990 EXPLAIN (buffers off, costs off) SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> Finalize GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Partial GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk -- test single copy parallel plan with parallel chunk append :PREFIX SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" WHERE length(version()) > 0 GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> Finalize GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Partial GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; sec | last --------------------------+------ Wed Dec 31 16:00:00 1969 | 990 Wed Dec 31 16:00:01 1969 | 1990 Wed Dec 31 16:00:02 1969 | 2990 Wed Dec 31 16:00:03 1969 | 3990 Wed Dec 31 16:00:04 1969 | 4990 --test variants of histogram EXPLAIN (buffers off, costs off) SELECT histogram(i, 1, 1000000, 2) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000000, 2) FROM "test"; histogram ------------------- {1,50000,49999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 1,1000001,10) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000001, 10) FROM "test"; histogram ------------------------------------------------------------------ {1,10000,10000,10000,10000,10000,10000,10000,10000,10000,9999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 0,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 0, 100000, 5) FROM "test"; histogram ------------------------------------ {0,2000,2000,2000,2000,2000,90000} EXPLAIN (buffers off, costs off) SELECT histogram(i, 10,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 10, 100000, 5) FROM "test"; histogram ------------------------------------ {1,2000,2000,2000,2000,1999,90000} EXPLAIN (buffers off, costs off) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk Filter: ((i)::double precision = '-1'::double precision) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: ((i)::double precision = '-1'::double precision) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); histogram ----------- -- test parallel ChunkAppend :PREFIX SELECT i FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Result One-Time Filter: (length(version()) > 0) -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_2_chunk :PREFIX SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i > 1) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 1) SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 -- test parallel ChunkAppend with only work done in the parallel workers SET parallel_leader_participation = off; SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 RESET parallel_leader_participation; -- Test parallel chunk append is used (index scan is disabled to trigger a parallel chunk append) SET parallel_tuple_cost = 0; SET enable_indexscan = OFF; :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; --- QUERY PLAN --- Sort Sort Key: test.i, _hyper_1_1_chunk_1.i -> Merge Left Join Merge Cond: (test.i = _hyper_1_1_chunk_1.i) -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: test.i -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk -> Materialize -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _hyper_1_1_chunk_1.i -> Parallel Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 Filter: (i < 500000) SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; i | j | ts | i | j | ts ----+------+-----------------------------+----+------+----------------------------- 0 | 0.1 | Wed Dec 31 16:00:00 1969 | 0 | 0.1 | Wed Dec 31 16:00:00 1969 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 | 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 | 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 | 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 | 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 | 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 | 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 | 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 | 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 | 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 SET enable_indexscan = ON; -- Test normal chunk append can be used in a parallel worker :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Limit -> Incremental Sort Sort Key: _hyper_1_2_chunk.i, test.i Presorted Key: _hyper_1_2_chunk.i -> Nested Loop -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i >= 999000) -> Materialize -> Custom Scan (ChunkAppend) on test Order: test.i -> Index Scan Backward using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 Index Cond: (i >= 400000) SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; i | j | ts | i | j | ts --------+----------+--------------------------+--------+----------+----------------------------- 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400000 | 400000.1 | Wed Dec 31 16:06:40 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400010 | 400010.1 | Wed Dec 31 16:06:40.01 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400020 | 400020.1 | Wed Dec 31 16:06:40.02 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400030 | 400030.1 | Wed Dec 31 16:06:40.03 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400040 | 400040.1 | Wed Dec 31 16:06:40.04 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400050 | 400050.1 | Wed Dec 31 16:06:40.05 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400060 | 400060.1 | Wed Dec 31 16:06:40.06 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400070 | 400070.1 | Wed Dec 31 16:06:40.07 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400080 | 400080.1 | Wed Dec 31 16:06:40.08 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400090 | 400090.1 | Wed Dec 31 16:06:40.09 1969 -- Test parallel ChunkAppend reinit SET enable_material = off; SET min_parallel_table_scan_size = 0; SET min_parallel_index_scan_size = 0; SET enable_hashjoin = 'off'; SET enable_nestloop = 'off'; CREATE TABLE sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL); SELECT FROM create_hypertable(relation=>'sensor_data', time_column_name=> 'time'); -- -- Sensors 1 and 2 INSERT INTO sensor_data SELECT time, sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '3 months') AS g1(time), generate_series(1, 2, 1) AS g2(sensor_id) ORDER BY time; -- Sensor 100 INSERT INTO sensor_data SELECT time, 100 as sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '1 year') AS g1(time) ORDER BY time; :PREFIX SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: s2."time", s1."time", s1.sensor_id, s2.sensor_id -> Nested Loop -> Parallel Custom Scan (ChunkAppend) on sensor_data s1 Chunks excluded during startup: 80 -> Parallel Bitmap Heap Scan on _hyper_2_83_chunk s1_1 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_83_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_84_chunk s1_2 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_84_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_85_chunk s1_3 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_85_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_86_chunk s1_4 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_86_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_87_chunk s1_5 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_87_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_88_chunk s1_6 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_88_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_89_chunk s1_7 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_89_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_90_chunk s1_8 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_90_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_91_chunk s1_9 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_91_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Custom Scan (ChunkAppend) on sensor_data s2 Order: s2."time" -> Index Scan Backward using _hyper_2_83_chunk_sensor_data_time_idx on _hyper_2_83_chunk s2_1 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_84_chunk_sensor_data_time_idx on _hyper_2_84_chunk s2_2 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_85_chunk_sensor_data_time_idx on _hyper_2_85_chunk s2_3 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_86_chunk_sensor_data_time_idx on _hyper_2_86_chunk s2_4 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_87_chunk_sensor_data_time_idx on _hyper_2_87_chunk s2_5 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -- Check query result SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 -- Ensure the same result is produced if only the parallel workers have to produce them (i.e., the pstate is reinitialized properly) SET parallel_leader_participation = off; SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET parallel_leader_participation; -- Ensure the same query result is produced by a sequencial query SET max_parallel_workers_per_gather TO 0; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET enable_material; RESET min_parallel_table_scan_size; RESET min_parallel_index_scan_size; RESET enable_hashjoin; RESET enable_nestloop; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on -- test worker assignment -- first chunk should have 1 worker and second chunk should have 2 SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 400000) SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; count ------- 60000 -- test worker assignment -- first chunk should have 2 worker and second chunk should have 1 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; count ------- 60000 -- test ChunkAppend with # workers < # childs SET max_parallel_workers_per_gather TO 1; :PREFIX SELECT count(*) FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 1 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT count(*) FROM "test" WHERE length(version()) > 0; count -------- 100000 -- test ChunkAppend with # workers > # childs SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 500000) SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; count ------- 50000 RESET max_parallel_workers_per_gather; -- test partial and non-partial plans -- these will not be parallel on PG < 11 ALTER TABLE :CHUNK1 SET (parallel_workers=0); ALTER TABLE :CHUNK2 SET (parallel_workers=2); :PREFIX SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i > 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 400000) ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=0); :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) ALTER TABLE :CHUNK1 RESET (parallel_workers); ALTER TABLE :CHUNK2 RESET (parallel_workers); -- now() is not marked parallel safe in PostgreSQL < 12 so using now() -- in a query will prevent parallelism but CURRENT_TIMESTAMP and -- transaction_timestamp() are marked parallel safe :PREFIX SELECT i FROM "test" WHERE ts < CURRENT_TIMESTAMP; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < CURRENT_TIMESTAMP) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < CURRENT_TIMESTAMP) :PREFIX SELECT i FROM "test" WHERE ts < transaction_timestamp(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < transaction_timestamp()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < transaction_timestamp()) -- this won't be parallel query because now() is parallel restricted in PG < 12 :PREFIX SELECT i FROM "test" WHERE ts < now(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < now()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < now()) ����������������������������������������������timescaledb-2.23.0/test/expected/parallel-16.out����������������������������������������������������0000664�0000000�0000000�00000103767�15100345067�0021422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --parallel queries require big-ish tables so collect them all here --so that we need to generate queries only once. -- output with analyze is not stable because it depends on worker assignment \set PREFIX 'EXPLAIN (buffers off, costs off)' \set CHUNK1 _timescaledb_internal._hyper_1_1_chunk \set CHUNK2 _timescaledb_internal._hyper_1_2_chunk CREATE TABLE test (i int, j double precision, ts timestamp); SELECT create_hypertable('test','i',chunk_time_interval:=500000); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------- (1,public,test,t) INSERT INTO test SELECT x, x+0.1, _timescaledb_functions.to_timestamp(x*1000) FROM generate_series(0,1000000-1,10) AS x; ANALYZE test; ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=2); SET work_mem TO '50MB'; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost TO 0; EXPLAIN (buffers off, costs off) SELECT first(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT first(i, j) FROM "test"; first ------- 0 EXPLAIN (buffers off, costs off) SELECT last(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT last(i, j) FROM "test"; last -------- 999990 EXPLAIN (buffers off, costs off) SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> Finalize GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Partial GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk -- test single copy parallel plan with parallel chunk append :PREFIX SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" WHERE length(version()) > 0 GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> Finalize GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Partial GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; sec | last --------------------------+------ Wed Dec 31 16:00:00 1969 | 990 Wed Dec 31 16:00:01 1969 | 1990 Wed Dec 31 16:00:02 1969 | 2990 Wed Dec 31 16:00:03 1969 | 3990 Wed Dec 31 16:00:04 1969 | 4990 --test variants of histogram EXPLAIN (buffers off, costs off) SELECT histogram(i, 1, 1000000, 2) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000000, 2) FROM "test"; histogram ------------------- {1,50000,49999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 1,1000001,10) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000001, 10) FROM "test"; histogram ------------------------------------------------------------------ {1,10000,10000,10000,10000,10000,10000,10000,10000,10000,9999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 0,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 0, 100000, 5) FROM "test"; histogram ------------------------------------ {0,2000,2000,2000,2000,2000,90000} EXPLAIN (buffers off, costs off) SELECT histogram(i, 10,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 10, 100000, 5) FROM "test"; histogram ------------------------------------ {1,2000,2000,2000,2000,1999,90000} EXPLAIN (buffers off, costs off) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk Filter: ((i)::double precision = '-1'::double precision) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: ((i)::double precision = '-1'::double precision) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); histogram ----------- -- test parallel ChunkAppend :PREFIX SELECT i FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Result One-Time Filter: (length(version()) > 0) -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_2_chunk :PREFIX SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i > 1) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 1) SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 -- test parallel ChunkAppend with only work done in the parallel workers SET parallel_leader_participation = off; SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 RESET parallel_leader_participation; -- Test parallel chunk append is used (index scan is disabled to trigger a parallel chunk append) SET parallel_tuple_cost = 0; SET enable_indexscan = OFF; :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; --- QUERY PLAN --- Incremental Sort Sort Key: test.i, _hyper_1_1_chunk_1.i Presorted Key: test.i -> Merge Left Join Merge Cond: (test.i = _hyper_1_1_chunk_1.i) -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: test.i -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk -> Materialize -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _hyper_1_1_chunk_1.i -> Parallel Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 Filter: (i < 500000) SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; i | j | ts | i | j | ts ----+------+-----------------------------+----+------+----------------------------- 0 | 0.1 | Wed Dec 31 16:00:00 1969 | 0 | 0.1 | Wed Dec 31 16:00:00 1969 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 | 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 | 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 | 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 | 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 | 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 | 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 | 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 | 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 | 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 SET enable_indexscan = ON; -- Test normal chunk append can be used in a parallel worker :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Limit -> Incremental Sort Sort Key: _hyper_1_2_chunk.i, test.i Presorted Key: _hyper_1_2_chunk.i -> Nested Loop -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i >= 999000) -> Materialize -> Custom Scan (ChunkAppend) on test Order: test.i -> Index Scan Backward using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 Index Cond: (i >= 400000) SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; i | j | ts | i | j | ts --------+----------+--------------------------+--------+----------+----------------------------- 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400000 | 400000.1 | Wed Dec 31 16:06:40 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400010 | 400010.1 | Wed Dec 31 16:06:40.01 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400020 | 400020.1 | Wed Dec 31 16:06:40.02 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400030 | 400030.1 | Wed Dec 31 16:06:40.03 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400040 | 400040.1 | Wed Dec 31 16:06:40.04 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400050 | 400050.1 | Wed Dec 31 16:06:40.05 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400060 | 400060.1 | Wed Dec 31 16:06:40.06 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400070 | 400070.1 | Wed Dec 31 16:06:40.07 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400080 | 400080.1 | Wed Dec 31 16:06:40.08 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400090 | 400090.1 | Wed Dec 31 16:06:40.09 1969 -- Test parallel ChunkAppend reinit SET enable_material = off; SET min_parallel_table_scan_size = 0; SET min_parallel_index_scan_size = 0; SET enable_hashjoin = 'off'; SET enable_nestloop = 'off'; CREATE TABLE sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL); SELECT FROM create_hypertable(relation=>'sensor_data', time_column_name=> 'time'); -- -- Sensors 1 and 2 INSERT INTO sensor_data SELECT time, sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '3 months') AS g1(time), generate_series(1, 2, 1) AS g2(sensor_id) ORDER BY time; -- Sensor 100 INSERT INTO sensor_data SELECT time, 100 as sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '1 year') AS g1(time) ORDER BY time; :PREFIX SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: s2."time", s1."time", s1.sensor_id, s2.sensor_id -> Nested Loop -> Parallel Custom Scan (ChunkAppend) on sensor_data s1 Chunks excluded during startup: 80 -> Parallel Bitmap Heap Scan on _hyper_2_83_chunk s1_1 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_83_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_84_chunk s1_2 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_84_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_85_chunk s1_3 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_85_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_86_chunk s1_4 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_86_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_87_chunk s1_5 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_87_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_88_chunk s1_6 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_88_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_89_chunk s1_7 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_89_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_90_chunk s1_8 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_90_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_91_chunk s1_9 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_91_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Custom Scan (ChunkAppend) on sensor_data s2 Order: s2."time" -> Index Scan Backward using _hyper_2_83_chunk_sensor_data_time_idx on _hyper_2_83_chunk s2_1 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_84_chunk_sensor_data_time_idx on _hyper_2_84_chunk s2_2 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_85_chunk_sensor_data_time_idx on _hyper_2_85_chunk s2_3 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_86_chunk_sensor_data_time_idx on _hyper_2_86_chunk s2_4 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_87_chunk_sensor_data_time_idx on _hyper_2_87_chunk s2_5 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -- Check query result SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 -- Ensure the same result is produced if only the parallel workers have to produce them (i.e., the pstate is reinitialized properly) SET parallel_leader_participation = off; SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET parallel_leader_participation; -- Ensure the same query result is produced by a sequencial query SET max_parallel_workers_per_gather TO 0; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET enable_material; RESET min_parallel_table_scan_size; RESET min_parallel_index_scan_size; RESET enable_hashjoin; RESET enable_nestloop; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on -- test worker assignment -- first chunk should have 1 worker and second chunk should have 2 SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 400000) SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; count ------- 60000 -- test worker assignment -- first chunk should have 2 worker and second chunk should have 1 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; count ------- 60000 -- test ChunkAppend with # workers < # childs SET max_parallel_workers_per_gather TO 1; :PREFIX SELECT count(*) FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 1 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT count(*) FROM "test" WHERE length(version()) > 0; count -------- 100000 -- test ChunkAppend with # workers > # childs SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 500000) SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; count ------- 50000 RESET max_parallel_workers_per_gather; -- test partial and non-partial plans -- these will not be parallel on PG < 11 ALTER TABLE :CHUNK1 SET (parallel_workers=0); ALTER TABLE :CHUNK2 SET (parallel_workers=2); :PREFIX SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i > 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 400000) ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=0); :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) ALTER TABLE :CHUNK1 RESET (parallel_workers); ALTER TABLE :CHUNK2 RESET (parallel_workers); -- now() is not marked parallel safe in PostgreSQL < 12 so using now() -- in a query will prevent parallelism but CURRENT_TIMESTAMP and -- transaction_timestamp() are marked parallel safe :PREFIX SELECT i FROM "test" WHERE ts < CURRENT_TIMESTAMP; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < CURRENT_TIMESTAMP) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < CURRENT_TIMESTAMP) :PREFIX SELECT i FROM "test" WHERE ts < transaction_timestamp(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < transaction_timestamp()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < transaction_timestamp()) -- this won't be parallel query because now() is parallel restricted in PG < 12 :PREFIX SELECT i FROM "test" WHERE ts < now(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < now()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < now()) ���������timescaledb-2.23.0/test/expected/parallel-17.out����������������������������������������������������0000664�0000000�0000000�00000103767�15100345067�0021423�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --parallel queries require big-ish tables so collect them all here --so that we need to generate queries only once. -- output with analyze is not stable because it depends on worker assignment \set PREFIX 'EXPLAIN (buffers off, costs off)' \set CHUNK1 _timescaledb_internal._hyper_1_1_chunk \set CHUNK2 _timescaledb_internal._hyper_1_2_chunk CREATE TABLE test (i int, j double precision, ts timestamp); SELECT create_hypertable('test','i',chunk_time_interval:=500000); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------- (1,public,test,t) INSERT INTO test SELECT x, x+0.1, _timescaledb_functions.to_timestamp(x*1000) FROM generate_series(0,1000000-1,10) AS x; ANALYZE test; ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=2); SET work_mem TO '50MB'; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost TO 0; EXPLAIN (buffers off, costs off) SELECT first(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT first(i, j) FROM "test"; first ------- 0 EXPLAIN (buffers off, costs off) SELECT last(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT last(i, j) FROM "test"; last -------- 999990 EXPLAIN (buffers off, costs off) SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> Finalize GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Partial GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk -- test single copy parallel plan with parallel chunk append :PREFIX SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" WHERE length(version()) > 0 GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> Finalize GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Partial GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; sec | last --------------------------+------ Wed Dec 31 16:00:00 1969 | 990 Wed Dec 31 16:00:01 1969 | 1990 Wed Dec 31 16:00:02 1969 | 2990 Wed Dec 31 16:00:03 1969 | 3990 Wed Dec 31 16:00:04 1969 | 4990 --test variants of histogram EXPLAIN (buffers off, costs off) SELECT histogram(i, 1, 1000000, 2) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000000, 2) FROM "test"; histogram ------------------- {1,50000,49999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 1,1000001,10) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000001, 10) FROM "test"; histogram ------------------------------------------------------------------ {1,10000,10000,10000,10000,10000,10000,10000,10000,10000,9999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 0,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 0, 100000, 5) FROM "test"; histogram ------------------------------------ {0,2000,2000,2000,2000,2000,90000} EXPLAIN (buffers off, costs off) SELECT histogram(i, 10,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 10, 100000, 5) FROM "test"; histogram ------------------------------------ {1,2000,2000,2000,2000,1999,90000} EXPLAIN (buffers off, costs off) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk Filter: ((i)::double precision = '-1'::double precision) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: ((i)::double precision = '-1'::double precision) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); histogram ----------- -- test parallel ChunkAppend :PREFIX SELECT i FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Result One-Time Filter: (length(version()) > 0) -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_2_chunk :PREFIX SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i > 1) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 1) SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 -- test parallel ChunkAppend with only work done in the parallel workers SET parallel_leader_participation = off; SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 RESET parallel_leader_participation; -- Test parallel chunk append is used (index scan is disabled to trigger a parallel chunk append) SET parallel_tuple_cost = 0; SET enable_indexscan = OFF; :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; --- QUERY PLAN --- Incremental Sort Sort Key: test.i, _hyper_1_1_chunk_1.i Presorted Key: test.i -> Merge Left Join Merge Cond: (test.i = _hyper_1_1_chunk_1.i) -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: test.i -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk -> Materialize -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _hyper_1_1_chunk_1.i -> Parallel Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 Filter: (i < 500000) SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; i | j | ts | i | j | ts ----+------+-----------------------------+----+------+----------------------------- 0 | 0.1 | Wed Dec 31 16:00:00 1969 | 0 | 0.1 | Wed Dec 31 16:00:00 1969 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 | 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 | 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 | 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 | 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 | 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 | 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 | 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 | 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 | 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 SET enable_indexscan = ON; -- Test normal chunk append can be used in a parallel worker :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Limit -> Incremental Sort Sort Key: _hyper_1_2_chunk.i, test.i Presorted Key: _hyper_1_2_chunk.i -> Nested Loop -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i >= 999000) -> Materialize -> Custom Scan (ChunkAppend) on test Order: test.i -> Index Scan Backward using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 Index Cond: (i >= 400000) SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; i | j | ts | i | j | ts --------+----------+--------------------------+--------+----------+----------------------------- 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400000 | 400000.1 | Wed Dec 31 16:06:40 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400010 | 400010.1 | Wed Dec 31 16:06:40.01 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400020 | 400020.1 | Wed Dec 31 16:06:40.02 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400030 | 400030.1 | Wed Dec 31 16:06:40.03 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400040 | 400040.1 | Wed Dec 31 16:06:40.04 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400050 | 400050.1 | Wed Dec 31 16:06:40.05 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400060 | 400060.1 | Wed Dec 31 16:06:40.06 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400070 | 400070.1 | Wed Dec 31 16:06:40.07 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400080 | 400080.1 | Wed Dec 31 16:06:40.08 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400090 | 400090.1 | Wed Dec 31 16:06:40.09 1969 -- Test parallel ChunkAppend reinit SET enable_material = off; SET min_parallel_table_scan_size = 0; SET min_parallel_index_scan_size = 0; SET enable_hashjoin = 'off'; SET enable_nestloop = 'off'; CREATE TABLE sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL); SELECT FROM create_hypertable(relation=>'sensor_data', time_column_name=> 'time'); -- -- Sensors 1 and 2 INSERT INTO sensor_data SELECT time, sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '3 months') AS g1(time), generate_series(1, 2, 1) AS g2(sensor_id) ORDER BY time; -- Sensor 100 INSERT INTO sensor_data SELECT time, 100 as sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '1 year') AS g1(time) ORDER BY time; :PREFIX SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: s2."time", s1."time", s1.sensor_id, s2.sensor_id -> Nested Loop -> Parallel Custom Scan (ChunkAppend) on sensor_data s1 Chunks excluded during startup: 80 -> Parallel Bitmap Heap Scan on _hyper_2_83_chunk s1_1 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_83_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_84_chunk s1_2 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_84_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_85_chunk s1_3 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_85_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_86_chunk s1_4 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_86_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_87_chunk s1_5 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_87_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_88_chunk s1_6 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_88_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_89_chunk s1_7 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_89_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_90_chunk s1_8 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_90_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_91_chunk s1_9 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_91_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Custom Scan (ChunkAppend) on sensor_data s2 Order: s2."time" -> Index Scan Backward using _hyper_2_83_chunk_sensor_data_time_idx on _hyper_2_83_chunk s2_1 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_84_chunk_sensor_data_time_idx on _hyper_2_84_chunk s2_2 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_85_chunk_sensor_data_time_idx on _hyper_2_85_chunk s2_3 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_86_chunk_sensor_data_time_idx on _hyper_2_86_chunk s2_4 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_87_chunk_sensor_data_time_idx on _hyper_2_87_chunk s2_5 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -- Check query result SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 -- Ensure the same result is produced if only the parallel workers have to produce them (i.e., the pstate is reinitialized properly) SET parallel_leader_participation = off; SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET parallel_leader_participation; -- Ensure the same query result is produced by a sequencial query SET max_parallel_workers_per_gather TO 0; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET enable_material; RESET min_parallel_table_scan_size; RESET min_parallel_index_scan_size; RESET enable_hashjoin; RESET enable_nestloop; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on -- test worker assignment -- first chunk should have 1 worker and second chunk should have 2 SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 400000) SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; count ------- 60000 -- test worker assignment -- first chunk should have 2 worker and second chunk should have 1 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; count ------- 60000 -- test ChunkAppend with # workers < # childs SET max_parallel_workers_per_gather TO 1; :PREFIX SELECT count(*) FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 1 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT count(*) FROM "test" WHERE length(version()) > 0; count -------- 100000 -- test ChunkAppend with # workers > # childs SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 500000) SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; count ------- 50000 RESET max_parallel_workers_per_gather; -- test partial and non-partial plans -- these will not be parallel on PG < 11 ALTER TABLE :CHUNK1 SET (parallel_workers=0); ALTER TABLE :CHUNK2 SET (parallel_workers=2); :PREFIX SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i > 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 400000) ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=0); :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) ALTER TABLE :CHUNK1 RESET (parallel_workers); ALTER TABLE :CHUNK2 RESET (parallel_workers); -- now() is not marked parallel safe in PostgreSQL < 12 so using now() -- in a query will prevent parallelism but CURRENT_TIMESTAMP and -- transaction_timestamp() are marked parallel safe :PREFIX SELECT i FROM "test" WHERE ts < CURRENT_TIMESTAMP; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < CURRENT_TIMESTAMP) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < CURRENT_TIMESTAMP) :PREFIX SELECT i FROM "test" WHERE ts < transaction_timestamp(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < transaction_timestamp()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < transaction_timestamp()) -- this won't be parallel query because now() is parallel restricted in PG < 12 :PREFIX SELECT i FROM "test" WHERE ts < now(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < now()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < now()) ���������timescaledb-2.23.0/test/expected/parallel-18.out����������������������������������������������������0000664�0000000�0000000�00000102705�15100345067�0021413�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --parallel queries require big-ish tables so collect them all here --so that we need to generate queries only once. -- output with analyze is not stable because it depends on worker assignment \set PREFIX 'EXPLAIN (buffers off, costs off)' \set CHUNK1 _timescaledb_internal._hyper_1_1_chunk \set CHUNK2 _timescaledb_internal._hyper_1_2_chunk CREATE TABLE test (i int, j double precision, ts timestamp); SELECT create_hypertable('test','i',chunk_time_interval:=500000); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------- (1,public,test,t) INSERT INTO test SELECT x, x+0.1, _timescaledb_functions.to_timestamp(x*1000) FROM generate_series(0,1000000-1,10) AS x; ANALYZE test; ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=2); SET work_mem TO '50MB'; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost TO 0; EXPLAIN (buffers off, costs off) SELECT first(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT first(i, j) FROM "test"; first ------- 0 EXPLAIN (buffers off, costs off) SELECT last(i, j) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT last(i, j) FROM "test"; last -------- 999990 EXPLAIN (buffers off, costs off) SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk -- test single copy parallel plan with parallel chunk append :PREFIX SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" WHERE length(version()) > 0 GROUP BY sec ORDER BY sec LIMIT 5; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, test.ts)) -> Result -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; sec | last --------------------------+------ Wed Dec 31 16:00:00 1969 | 990 Wed Dec 31 16:00:01 1969 | 1990 Wed Dec 31 16:00:02 1969 | 2990 Wed Dec 31 16:00:03 1969 | 3990 Wed Dec 31 16:00:04 1969 | 4990 --test variants of histogram EXPLAIN (buffers off, costs off) SELECT histogram(i, 1, 1000000, 2) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000000, 2) FROM "test"; histogram ------------------- {1,50000,49999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 1,1000001,10) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 1, 1000001, 10) FROM "test"; histogram ------------------------------------------------------------------ {1,10000,10000,10000,10000,10000,10000,10000,10000,10000,9999,0} EXPLAIN (buffers off, costs off) SELECT histogram(i, 0,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 0, 100000, 5) FROM "test"; histogram ------------------------------------ {0,2000,2000,2000,2000,2000,90000} EXPLAIN (buffers off, costs off) SELECT histogram(i, 10,100000,5) FROM "test"; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk -> Parallel Seq Scan on _hyper_1_2_chunk SELECT histogram(i, 10, 100000, 5) FROM "test"; histogram ------------------------------------ {1,2000,2000,2000,2000,1999,90000} EXPLAIN (buffers off, costs off) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Parallel Append -> Parallel Seq Scan on _hyper_1_1_chunk Filter: ((i)::double precision = '-1'::double precision) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: ((i)::double precision = '-1'::double precision) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); histogram ----------- -- test parallel ChunkAppend :PREFIX SELECT i FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Result One-Time Filter: (length(version()) > 0) -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Seq Scan on _hyper_1_2_chunk :PREFIX SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i > 1) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 1) SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 -- test parallel ChunkAppend with only work done in the parallel workers SET parallel_leader_participation = off; SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; count ------- 99999 RESET parallel_leader_participation; -- Test parallel chunk append is used (index scan is disabled to trigger a parallel chunk append) SET parallel_tuple_cost = 0; SET enable_indexscan = OFF; :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; --- QUERY PLAN --- Incremental Sort Sort Key: test.i, _hyper_1_1_chunk_1.i Presorted Key: test.i -> Merge Left Join Merge Cond: (test.i = _hyper_1_1_chunk_1.i) -> Limit -> Result One-Time Filter: (length(version()) > 0) -> Custom Scan (ChunkAppend) on test Order: test.i Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Scan Backward using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk -> Materialize -> Limit -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _hyper_1_1_chunk_1.i -> Parallel Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 Filter: (i < 500000) SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; i | j | ts | i | j | ts ----+------+-----------------------------+----+------+----------------------------- 0 | 0.1 | Wed Dec 31 16:00:00 1969 | 0 | 0.1 | Wed Dec 31 16:00:00 1969 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 | 10 | 10.1 | Wed Dec 31 16:00:00.01 1969 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 | 20 | 20.1 | Wed Dec 31 16:00:00.02 1969 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 | 30 | 30.1 | Wed Dec 31 16:00:00.03 1969 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 | 40 | 40.1 | Wed Dec 31 16:00:00.04 1969 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 | 50 | 50.1 | Wed Dec 31 16:00:00.05 1969 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 | 60 | 60.1 | Wed Dec 31 16:00:00.06 1969 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 | 70 | 70.1 | Wed Dec 31 16:00:00.07 1969 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 | 80 | 80.1 | Wed Dec 31 16:00:00.08 1969 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 | 90 | 90.1 | Wed Dec 31 16:00:00.09 1969 SET enable_indexscan = ON; -- Test normal chunk append can be used in a parallel worker :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Limit -> Incremental Sort Sort Key: _hyper_1_2_chunk.i, test.i Presorted Key: _hyper_1_2_chunk.i -> Nested Loop -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i >= 999000) -> Materialize -> Custom Scan (ChunkAppend) on test Order: test.i -> Index Scan Backward using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Index Scan Backward using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 Index Cond: (i >= 400000) SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; i | j | ts | i | j | ts --------+----------+--------------------------+--------+----------+----------------------------- 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400000 | 400000.1 | Wed Dec 31 16:06:40 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400010 | 400010.1 | Wed Dec 31 16:06:40.01 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400020 | 400020.1 | Wed Dec 31 16:06:40.02 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400030 | 400030.1 | Wed Dec 31 16:06:40.03 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400040 | 400040.1 | Wed Dec 31 16:06:40.04 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400050 | 400050.1 | Wed Dec 31 16:06:40.05 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400060 | 400060.1 | Wed Dec 31 16:06:40.06 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400070 | 400070.1 | Wed Dec 31 16:06:40.07 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400080 | 400080.1 | Wed Dec 31 16:06:40.08 1969 999000 | 999000.1 | Wed Dec 31 16:16:39 1969 | 400090 | 400090.1 | Wed Dec 31 16:06:40.09 1969 -- Test parallel ChunkAppend reinit SET enable_material = off; SET min_parallel_table_scan_size = 0; SET min_parallel_index_scan_size = 0; SET enable_hashjoin = 'off'; SET enable_nestloop = 'off'; CREATE TABLE sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL); SELECT FROM create_hypertable(relation=>'sensor_data', time_column_name=> 'time'); -- -- Sensors 1 and 2 INSERT INTO sensor_data SELECT time, sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '3 months') AS g1(time), generate_series(1, 2, 1) AS g2(sensor_id) ORDER BY time; -- Sensor 100 INSERT INTO sensor_data SELECT time, 100 as sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '1 year') AS g1(time) ORDER BY time; :PREFIX SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; --- QUERY PLAN --- Incremental Sort Sort Key: s2."time", s1."time", s1.sensor_id, s2.sensor_id Presorted Key: s2."time" -> Nested Loop -> Custom Scan (ChunkAppend) on sensor_data s2 Order: s2."time" -> Index Scan Backward using _hyper_2_83_chunk_sensor_data_time_idx on _hyper_2_83_chunk s2_1 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_84_chunk_sensor_data_time_idx on _hyper_2_84_chunk s2_2 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_85_chunk_sensor_data_time_idx on _hyper_2_85_chunk s2_3 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_86_chunk_sensor_data_time_idx on _hyper_2_86_chunk s2_4 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_2_87_chunk_sensor_data_time_idx on _hyper_2_87_chunk s2_5 Index Cond: (("time" > 'Wed Jan 01 00:00:30 2020 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 01 00:00:30 2021 PST'::timestamp with time zone)) -> Gather Workers Planned: 4 -> Parallel Custom Scan (ChunkAppend) on sensor_data s1 Chunks excluded during startup: 80 -> Parallel Bitmap Heap Scan on _hyper_2_83_chunk s1_1 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_83_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_84_chunk s1_2 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_84_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_85_chunk s1_3 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_85_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_86_chunk s1_4 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_86_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_87_chunk s1_5 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_87_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_88_chunk s1_6 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_88_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_89_chunk s1_7 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_89_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_90_chunk s1_8 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_90_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -> Parallel Bitmap Heap Scan on _hyper_2_91_chunk s1_9 Recheck Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) Filter: (sensor_id > 50) -> Bitmap Index Scan on _hyper_2_91_chunk_sensor_data_time_idx Index Cond: ("time" > ('2020-01-01 00:00:30'::cstring)::timestamp with time zone) -- Check query result SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 -- Ensure the same result is produced if only the parallel workers have to produce them (i.e., the pstate is reinitialized properly) SET parallel_leader_participation = off; SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET parallel_leader_participation; -- Ensure the same query result is produced by a sequencial query SET max_parallel_workers_per_gather TO 0; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; time | sensor_id | time | sensor_id ------------------------------+-----------+------------------------------+----------- Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Apr 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Wed Jul 01 00:00:30 2020 PDT | 2 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Fri Jan 01 00:00:30 2021 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 1 Sat Jan 01 00:00:30 2022 PST | 100 | Thu Oct 01 00:00:30 2020 PDT | 2 RESET enable_material; RESET min_parallel_table_scan_size; RESET min_parallel_index_scan_size; RESET enable_hashjoin; RESET enable_nestloop; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on -- test worker assignment -- first chunk should have 1 worker and second chunk should have 2 SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i >= 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 400000) SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; count ------- 60000 -- test worker assignment -- first chunk should have 2 worker and second chunk should have 1 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; count ------- 60000 -- test ChunkAppend with # workers < # childs SET max_parallel_workers_per_gather TO 1; :PREFIX SELECT count(*) FROM "test" WHERE length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 1 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk SELECT count(*) FROM "test" WHERE length(version()) > 0; count -------- 100000 -- test ChunkAppend with # workers > # childs SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i >= 500000) SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; count ------- 50000 RESET max_parallel_workers_per_gather; -- test partial and non-partial plans -- these will not be parallel on PG < 11 ALTER TABLE :CHUNK1 SET (parallel_workers=0); ALTER TABLE :CHUNK2 SET (parallel_workers=2); :PREFIX SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_1_chunk_test_i_idx on _hyper_1_1_chunk Index Cond: (i > 400000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_2_chunk Filter: (i > 400000) ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=0); :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; --- QUERY PLAN --- Finalize Aggregate -> Gather Workers Planned: 2 -> Partial Aggregate -> Result One-Time Filter: (length(version()) > 0) -> Parallel Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Result One-Time Filter: (length(version()) > 0) -> Index Only Scan using _hyper_1_2_chunk_test_i_idx on _hyper_1_2_chunk Index Cond: (i < 600000) -> Result One-Time Filter: (length(version()) > 0) -> Parallel Seq Scan on _hyper_1_1_chunk Filter: (i < 600000) ALTER TABLE :CHUNK1 RESET (parallel_workers); ALTER TABLE :CHUNK2 RESET (parallel_workers); -- now() is not marked parallel safe in PostgreSQL < 12 so using now() -- in a query will prevent parallelism but CURRENT_TIMESTAMP and -- transaction_timestamp() are marked parallel safe :PREFIX SELECT i FROM "test" WHERE ts < CURRENT_TIMESTAMP; --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < CURRENT_TIMESTAMP) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < CURRENT_TIMESTAMP) :PREFIX SELECT i FROM "test" WHERE ts < transaction_timestamp(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < transaction_timestamp()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < transaction_timestamp()) -- this won't be parallel query because now() is parallel restricted in PG < 12 :PREFIX SELECT i FROM "test" WHERE ts < now(); --- QUERY PLAN --- Gather Workers Planned: 1 Single Copy: true -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (ts < now()) -> Seq Scan on _hyper_1_2_chunk Filter: (ts < now()) �����������������������������������������������������������timescaledb-2.23.0/test/expected/partition.out������������������������������������������������������0000664�0000000�0000000�00000064246�15100345067�0021411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE part_legacy(time timestamptz, temp float, device int); SELECT create_hypertable('part_legacy', 'time', 'device', 2, partitioning_func => '_timescaledb_functions.get_partition_for_key'); create_hypertable -------------------------- (1,public,part_legacy,t) -- Show legacy partitioning function is used SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+--------------------------+---------+------------+--------------------------+-----------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp with time zone | t | | | | 604800000000 | | | 2 | 1 | device | integer | f | 2 | _timescaledb_functions | get_partition_for_key | | | | INSERT INTO part_legacy VALUES ('2017-03-22T09:18:23', 23.4, 1); INSERT INTO part_legacy VALUES ('2017-03-22T09:18:23', 23.4, 76); VACUUM part_legacy; -- Show two chunks and CHECK constraint with cast SELECT * FROM test.show_constraintsp('_timescaledb_internal._hyper_1_%_chunk'); Table | Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------------------------+--------------+------+----------+-------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- _timescaledb_internal._hyper_1_1_chunk | constraint_1 | c | {time} | - | (("time" >= 'Wed Mar 15 17:00:00 2017 PDT'::timestamp with time zone) AND ("time" < 'Wed Mar 22 17:00:00 2017 PDT'::timestamp with time zone)) | f | f | t _timescaledb_internal._hyper_1_1_chunk | constraint_2 | c | {device} | - | (_timescaledb_functions.get_partition_for_key(device) >= 1073741823) | f | f | t _timescaledb_internal._hyper_1_2_chunk | constraint_1 | c | {time} | - | (("time" >= 'Wed Mar 15 17:00:00 2017 PDT'::timestamp with time zone) AND ("time" < 'Wed Mar 22 17:00:00 2017 PDT'::timestamp with time zone)) | f | f | t _timescaledb_internal._hyper_1_2_chunk | constraint_3 | c | {device} | - | (_timescaledb_functions.get_partition_for_key(device) < 1073741823) | f | f | t -- Make sure constraint exclusion works on device column BEGIN; -- For plan stability between versions SET LOCAL enable_bitmapscan = false; SET LOCAL enable_indexscan = false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_legacy WHERE device = 1; --- QUERY PLAN --- Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.temp, _hyper_1_1_chunk.device Filter: (_hyper_1_1_chunk.device = 1) COMMIT; CREATE TABLE part_new(time timestamptz, temp float, device int); SELECT create_hypertable('part_new', 'time', 'device', 2); create_hypertable ----------------------- (2,public,part_new,t) SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+--------------------------+---------+------------+--------------------------+-----------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp with time zone | t | | | | 604800000000 | | | 2 | 1 | device | integer | f | 2 | _timescaledb_functions | get_partition_for_key | | | | 3 | 2 | time | timestamp with time zone | t | | | | 604800000000 | | | 4 | 2 | device | integer | f | 2 | _timescaledb_functions | get_partition_hash | | | | INSERT INTO part_new VALUES ('2017-03-22T09:18:23', 23.4, 1); INSERT INTO part_new VALUES ('2017-03-22T09:18:23', 23.4, 2); VACUUM part_new; -- Show two chunks and CHECK constraint without cast SELECT * FROM test.show_constraintsp('_timescaledb_internal._hyper_2_%_chunk'); Table | Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------------------------+--------------+------+----------+-------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- _timescaledb_internal._hyper_2_3_chunk | constraint_4 | c | {time} | - | (("time" >= 'Wed Mar 15 17:00:00 2017 PDT'::timestamp with time zone) AND ("time" < 'Wed Mar 22 17:00:00 2017 PDT'::timestamp with time zone)) | f | f | t _timescaledb_internal._hyper_2_3_chunk | constraint_5 | c | {device} | - | (_timescaledb_functions.get_partition_hash(device) < 1073741823) | f | f | t _timescaledb_internal._hyper_2_4_chunk | constraint_4 | c | {time} | - | (("time" >= 'Wed Mar 15 17:00:00 2017 PDT'::timestamp with time zone) AND ("time" < 'Wed Mar 22 17:00:00 2017 PDT'::timestamp with time zone)) | f | f | t _timescaledb_internal._hyper_2_4_chunk | constraint_6 | c | {device} | - | (_timescaledb_functions.get_partition_hash(device) >= 1073741823) | f | f | t -- Make sure constraint exclusion works on device column BEGIN; -- For plan stability between versions SET LOCAL enable_bitmapscan = false; SET LOCAL enable_indexscan = false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_new WHERE device = 1; --- QUERY PLAN --- Seq Scan on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk."time", _hyper_2_3_chunk.temp, _hyper_2_3_chunk.device Filter: (_hyper_2_3_chunk.device = 1) COMMIT; CREATE TABLE part_new_convert1(time timestamptz, temp float8, device int); SELECT create_hypertable('part_new_convert1', 'time', 'temp', 2); create_hypertable -------------------------------- (3,public,part_new_convert1,t) INSERT INTO part_new_convert1 VALUES ('2017-03-22T09:18:23', 1.0, 2); \set ON_ERROR_STOP 0 -- Changing the type of a hash-partitioned column should not be supported ALTER TABLE part_new_convert1 ALTER COLUMN temp TYPE numeric; ERROR: cannot change the type of a hash-partitioned column \set ON_ERROR_STOP 1 -- Should be able to change if not hash partitioned though ALTER TABLE part_new_convert1 ALTER COLUMN time TYPE timestamp; SELECT * FROM test.show_columnsp('_timescaledb_internal._hyper_3_%_chunk'); Relation | Kind | Column | Column type | NotNull ----------------------------------------+------+--------+-----------------------------+--------- _timescaledb_internal._hyper_3_5_chunk | r | time | timestamp without time zone | t _timescaledb_internal._hyper_3_5_chunk | r | temp | double precision | f _timescaledb_internal._hyper_3_5_chunk | r | device | integer | f CREATE TABLE part_add_dim(time timestamptz, temp float8, device int, location int); SELECT create_hypertable('part_add_dim', 'time', 'temp', 2); create_hypertable --------------------------- (4,public,part_add_dim,t) \set ON_ERROR_STOP 0 SELECT add_dimension('part_add_dim', 'location', 2, partitioning_func => 'bad_func'); ERROR: function "bad_func" does not exist at character 74 \set ON_ERROR_STOP 1 SELECT add_dimension('part_add_dim', 'location', 2, partitioning_func => '_timescaledb_functions.get_partition_for_key'); add_dimension ------------------------------------ (9,public,part_add_dim,location,t) SELECT * FROM _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-----------------------------+---------+------------+--------------------------+-----------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp with time zone | t | | | | 604800000000 | | | 2 | 1 | device | integer | f | 2 | _timescaledb_functions | get_partition_for_key | | | | 3 | 2 | time | timestamp with time zone | t | | | | 604800000000 | | | 4 | 2 | device | integer | f | 2 | _timescaledb_functions | get_partition_hash | | | | 6 | 3 | temp | double precision | f | 2 | _timescaledb_functions | get_partition_hash | | | | 5 | 3 | time | timestamp without time zone | t | | | | 604800000000 | | | 7 | 4 | time | timestamp with time zone | t | | | | 604800000000 | | | 8 | 4 | temp | double precision | f | 2 | _timescaledb_functions | get_partition_hash | | | | 9 | 4 | location | integer | f | 2 | _timescaledb_functions | get_partition_for_key | | | | -- Test that we support custom SQL-based partitioning functions and -- that our native partitioning function handles function expressions -- as argument CREATE OR REPLACE FUNCTION custom_partfunc(source anyelement) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval INTEGER; BEGIN retval = _timescaledb_functions.get_partition_hash(substring(source::text FROM '[A-za-z0-9 ]+')); RAISE NOTICE 'hash value for % is %', source, retval; RETURN retval; END $BODY$; CREATE TABLE part_custom_func(time timestamptz, temp float8, device text); SELECT create_hypertable('part_custom_func', 'time', 'device', 2, partitioning_func => 'custom_partfunc'); create_hypertable ------------------------------- (5,public,part_custom_func,t) SELECT _timescaledb_functions.get_partition_hash(substring('dev1' FROM '[A-za-z0-9 ]+')); get_partition_hash -------------------- 1129986420 SELECT _timescaledb_functions.get_partition_hash('dev1'::text); get_partition_hash -------------------- 1129986420 SELECT _timescaledb_functions.get_partition_hash('dev7'::text); get_partition_hash -------------------- 449729092 INSERT INTO part_custom_func VALUES ('2017-03-22T09:18:23', 23.4, 'dev1'), ('2017-03-22T09:18:23', 23.4, 'dev7'); NOTICE: hash value for dev1 is 1129986420 NOTICE: hash value for dev1 is 1129986420 NOTICE: hash value for dev7 is 449729092 NOTICE: hash value for dev7 is 449729092 SELECT * FROM test.show_subtables('part_custom_func'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_5_6_chunk | _timescaledb_internal._hyper_5_7_chunk | -- This first test is slightly trivial, but segfaulted in old versions CREATE TYPE simpl AS (val1 int4); CREATE OR REPLACE FUNCTION simpl_type_hash(ANYELEMENT) RETURNS int4 AS $$ SELECT $1.val1; $$ LANGUAGE SQL IMMUTABLE; CREATE TABLE simpl_partition ("timestamp" TIMESTAMPTZ, object simpl); SELECT create_hypertable( 'simpl_partition', 'timestamp', 'object', 1000, chunk_time_interval => interval '1 day', partitioning_func=>'simpl_type_hash'); create_hypertable ------------------------------ (6,public,simpl_partition,t) INSERT INTO simpl_partition VALUES ('2017-03-22T09:18:23', ROW(1)::simpl); SELECT * from simpl_partition; timestamp | object ------------------------------+-------- Wed Mar 22 09:18:23 2017 PDT | (1) -- Also test that the fix works when we have more chunks than allowed at once SET timescaledb.max_open_chunks_per_insert=1; INSERT INTO simpl_partition VALUES ('2017-03-22T10:18:23', ROW(0)::simpl), ('2017-03-22T10:18:23', ROW(1)::simpl), ('2017-03-22T10:18:23', ROW(2)::simpl), ('2017-03-22T10:18:23', ROW(3)::simpl), ('2017-03-22T10:18:23', ROW(4)::simpl), ('2017-03-22T10:18:23', ROW(5)::simpl); SET timescaledb.max_open_chunks_per_insert=default; SELECT * from simpl_partition; timestamp | object ------------------------------+-------- Wed Mar 22 09:18:23 2017 PDT | (1) Wed Mar 22 10:18:23 2017 PDT | (0) Wed Mar 22 10:18:23 2017 PDT | (1) Wed Mar 22 10:18:23 2017 PDT | (2) Wed Mar 22 10:18:23 2017 PDT | (3) Wed Mar 22 10:18:23 2017 PDT | (4) Wed Mar 22 10:18:23 2017 PDT | (5) -- Test that index creation is handled correctly. CREATE TABLE hyper_with_index(time timestamptz, temp float, device int); CREATE UNIQUE INDEX temp_index ON hyper_with_index(temp); \set ON_ERROR_STOP 0 SELECT create_hypertable('hyper_with_index', 'time'); ERROR: cannot create a unique index without the column "time" (used in partitioning) SELECT create_hypertable('hyper_with_index', 'time', 'device', 2); ERROR: cannot create a unique index without the column "time" (used in partitioning) SELECT create_hypertable('hyper_with_index', 'time', 'temp', 2); ERROR: cannot create a unique index without the column "time" (used in partitioning) \set ON_ERROR_STOP 1 DROP INDEX temp_index; CREATE UNIQUE INDEX time_index ON hyper_with_index(time); \set ON_ERROR_STOP 0 -- should error because device not in index SELECT create_hypertable('hyper_with_index', 'time', 'device', 4); ERROR: cannot create a unique index without the column "device" (used in partitioning) \set ON_ERROR_STOP 1 SELECT create_hypertable('hyper_with_index', 'time'); create_hypertable -------------------------------- (11,public,hyper_with_index,t) -- make sure user created index is used. -- not using \d or \d+ because output syntax differs -- between postgres 9 and postgres 10. SELECT indexname FROM pg_indexes WHERE tablename = 'hyper_with_index'; indexname ------------ time_index \set ON_ERROR_STOP 0 SELECT add_dimension('hyper_with_index', 'device', 4); ERROR: cannot create a unique index without the column "device" (used in partitioning) \set ON_ERROR_STOP 1 DROP INDEX time_index; CREATE UNIQUE INDEX time_space_index ON hyper_with_index(time, device); SELECT add_dimension('hyper_with_index', 'device', 4); add_dimension --------------------------------------- (23,public,hyper_with_index,device,t) CREATE TABLE hyper_with_primary(time TIMESTAMPTZ PRIMARY KEY, temp float, device int); \set ON_ERROR_STOP 0 SELECT create_hypertable('hyper_with_primary', 'time', 'device', 4); ERROR: cannot create a unique index without the column "device" (used in partitioning) \set ON_ERROR_STOP 1 SELECT create_hypertable('hyper_with_primary', 'time'); create_hypertable ---------------------------------- (13,public,hyper_with_primary,t) \set ON_ERROR_STOP 0 SELECT add_dimension('hyper_with_primary', 'device', 4); ERROR: cannot create a unique index without the column "device" (used in partitioning) \set ON_ERROR_STOP 1 -- NON-unique indexes can still be created CREATE INDEX temp_index ON hyper_with_index(temp); -- Make sure custom composite types are supported as dimensions CREATE TYPE TUPLE as (val1 int4, val2 int4); CREATE FUNCTION tuple_hash(value ANYELEMENT) RETURNS INT4 LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'custom hash value is: %', value.val1+value.val2; RETURN value.val1+value.val2; END $BODY$; CREATE TABLE part_custom_dim (time TIMESTAMPTZ, combo TUPLE, device TEXT); SELECT create_hypertable('part_custom_dim', 'time', 'combo', 4, partitioning_func=>'tuple_hash'); create_hypertable ------------------------------- (14,public,part_custom_dim,t) INSERT INTO part_custom_dim(time, combo) VALUES (now(), (1,2)); NOTICE: custom hash value is: 3 NOTICE: custom hash value is: 3 DROP TABLE part_custom_dim; -- Now make sure that renaming partitioning_func_schema will get updated properly \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_partitioning_schema; CREATE FUNCTION my_partitioning_schema.tuple_hash(value ANYELEMENT) RETURNS INT4 LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'custom hash value is: %', value.val1+value.val2; RETURN value.val1+value.val2; END $BODY$; CREATE TABLE part_custom_dim (time TIMESTAMPTZ, combo TUPLE, device TEXT); SELECT create_hypertable('part_custom_dim', 'time', 'combo', 4, partitioning_func=>'my_partitioning_schema.tuple_hash'); create_hypertable ------------------------------- (15,public,part_custom_dim,t) INSERT INTO part_custom_dim(time, combo) VALUES (now(), (1,2)); NOTICE: custom hash value is: 3 NOTICE: custom hash value is: 3 ALTER SCHEMA my_partitioning_schema RENAME TO new_partitioning_schema; -- Inserts should work even after we rename the schema INSERT INTO part_custom_dim(time, combo) VALUES (now(), (3,4)); NOTICE: custom hash value is: 7 NOTICE: custom hash value is: 7 -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION time_partfunc(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RAISE NOTICE 'time value for % is %', unixtime, timezone('UTC', retval); RETURN retval; END $BODY$; CREATE OR REPLACE FUNCTION time_partfunc_bad_parameters(unixtime float8, extra text) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE OR REPLACE FUNCTION time_partfunc_bad_return_type(unixtime float8) RETURNS FLOAT8 LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT unixtime; $BODY$; CREATE TABLE part_time_func(time float8, temp float8, device text); \set ON_ERROR_STOP 0 -- Should fail due to invalid time column SELECT create_hypertable('part_time_func', 'time'); ERROR: invalid type for dimension "time" -- Should fail due to bad signature of time partitioning function SELECT create_hypertable('part_time_func', 'time', time_partitioning_func => 'time_partfunc_bad_parameters'); ERROR: invalid partitioning function SELECT create_hypertable('part_time_func', 'time', time_partitioning_func => 'time_partfunc_bad_return_type'); ERROR: invalid partitioning function \set ON_ERROR_STOP 1 -- Should work with time partitioning function that returns a valid time type SELECT create_hypertable('part_time_func', 'time', time_partitioning_func => 'time_partfunc'); create_hypertable ------------------------------ (16,public,part_time_func,t) INSERT INTO part_time_func VALUES (1530214157.134, 23.4, 'dev1'), (1533214157.8734, 22.3, 'dev7'); NOTICE: time value for 1530214157.134 is Thu Jun 28 19:29:17.134 2018 NOTICE: time value for 1530214157.134 is Thu Jun 28 19:29:17.134 2018 NOTICE: time value for 1530214157.134 is Thu Jun 28 19:29:17.134 2018 NOTICE: time value for 1530214157.134 is Thu Jun 28 19:29:17.134 2018 NOTICE: time value for 1533214157.8734 is Thu Aug 02 12:49:17.8734 2018 NOTICE: time value for 1533214157.8734 is Thu Aug 02 12:49:17.8734 2018 NOTICE: time value for 1533214157.8734 is Thu Aug 02 12:49:17.8734 2018 NOTICE: time value for 1533214157.8734 is Thu Aug 02 12:49:17.8734 2018 SELECT time, temp, device FROM part_time_func; time | temp | device -----------------+------+-------- 1530214157.134 | 23.4 | dev1 1533214157.8734 | 22.3 | dev7 SELECT time_partfunc(time) at time zone 'UTC', temp, device FROM part_time_func; NOTICE: time value for 1530214157.134 is Thu Jun 28 19:29:17.134 2018 NOTICE: time value for 1533214157.8734 is Thu Aug 02 12:49:17.8734 2018 timezone | temp | device -------------------------------+------+-------- Thu Jun 28 19:29:17.134 2018 | 23.4 | dev1 Thu Aug 02 12:49:17.8734 2018 | 22.3 | dev7 SELECT * FROM test.show_subtables('part_time_func'); Child | Tablespace ------------------------------------------+------------ _timescaledb_internal._hyper_16_11_chunk | _timescaledb_internal._hyper_16_12_chunk | SELECT (test.show_constraints("Child")).* FROM test.show_subtables('part_time_func'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ---------------+------+---------+-------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- constraint_18 | c | {time} | - | ((time_partfunc("time") >= 'Wed Jun 27 17:00:00 2018 PDT'::timestamp with time zone) AND (time_partfunc("time") < 'Wed Jul 04 17:00:00 2018 PDT'::timestamp with time zone)) | f | f | t constraint_19 | c | {time} | - | ((time_partfunc("time") >= 'Wed Aug 01 17:00:00 2018 PDT'::timestamp with time zone) AND (time_partfunc("time") < 'Wed Aug 08 17:00:00 2018 PDT'::timestamp with time zone)) | f | f | t SELECT (test.show_indexes("Child")).* FROM test.show_subtables('part_time_func'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------+---------+---------------------+--------+---------+-----------+------------ _timescaledb_internal._hyper_16_11_chunk_part_time_func_expr_idx | {expr} | time_partfunc(expr) | f | f | f | _timescaledb_internal._hyper_16_12_chunk_part_time_func_expr_idx | {expr} | time_partfunc(expr) | f | f | f | -- Check that constraint exclusion works with time partitioning -- function (scan only one chunk) -- No exclusion EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_time_func; --- QUERY PLAN --- Append -> Seq Scan on _timescaledb_internal._hyper_16_11_chunk Output: _hyper_16_11_chunk."time", _hyper_16_11_chunk.temp, _hyper_16_11_chunk.device -> Seq Scan on _timescaledb_internal._hyper_16_12_chunk Output: _hyper_16_12_chunk."time", _hyper_16_12_chunk.temp, _hyper_16_12_chunk.device -- Exclude using the function on time EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_time_func WHERE time_partfunc(time) < '2018-07-01'; --- QUERY PLAN --- Index Scan using _hyper_16_11_chunk_part_time_func_expr_idx on _timescaledb_internal._hyper_16_11_chunk Output: _hyper_16_11_chunk."time", _hyper_16_11_chunk.temp, _hyper_16_11_chunk.device Index Cond: (time_partfunc(_hyper_16_11_chunk."time") < 'Sun Jul 01 00:00:00 2018 PDT'::timestamp with time zone) -- Exclude using the same date but as a UNIX timestamp. Won't do an -- index scan since the index is on the time function expression EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_time_func WHERE time < 1530403200.0; NOTICE: time value for 1530403200 is Sun Jul 01 00:00:00 2018 --- QUERY PLAN --- Seq Scan on _timescaledb_internal._hyper_16_11_chunk Output: _hyper_16_11_chunk."time", _hyper_16_11_chunk.temp, _hyper_16_11_chunk.device Filter: (_hyper_16_11_chunk."time" < '1530403200'::double precision) -- Check that inserts will fail if we use a time partitioning function -- that returns NULL CREATE OR REPLACE FUNCTION time_partfunc_null_ret(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN NULL; END $BODY$; CREATE TABLE part_time_func_null_ret(time float8, temp float8, device text); SELECT create_hypertable('part_time_func_null_ret', 'time', time_partitioning_func => 'time_partfunc_null_ret'); create_hypertable --------------------------------------- (17,public,part_time_func_null_ret,t) \set ON_ERROR_STOP 0 INSERT INTO part_time_func_null_ret VALUES (1530214157.134, 23.4, 'dev1'), (1533214157.8734, 22.3, 'dev7'); ERROR: partitioning function "public.time_partfunc_null_ret" returned NULL \set ON_ERROR_STOP 1 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/partitioning.out���������������������������������������������������0000664�0000000�0000000�00000003024�15100345067�0022072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Should expect an error when creating a hypertable from a partition \set ON_ERROR_STOP 0 CREATE TABLE partitioned_ht_create(time timestamptz, temp float, device int) PARTITION BY RANGE (time); SELECT create_hypertable('partitioned_ht_create', 'time'); ERROR: table "partitioned_ht_create" is already partitioned \set ON_ERROR_STOP 1 -- Should expect an error when attaching a hypertable to a partition \set ON_ERROR_STOP 0 CREATE TABLE partitioned_attachment_vanilla(time timestamptz, temp float, device int) PARTITION BY RANGE (time); CREATE TABLE attachment_hypertable(time timestamptz, temp float, device int); SELECT create_hypertable('attachment_hypertable', 'time'); create_hypertable ------------------------------------ (1,public,attachment_hypertable,t) ALTER TABLE partitioned_attachment_vanilla ATTACH PARTITION attachment_hypertable FOR VALUES FROM ('2016-07-01') TO ('2016-08-01'); ERROR: hypertables do not support native postgres partitioning \set ON_ERROR_STOP 1 -- Should not expect an error when attaching a normal table to a partition CREATE TABLE partitioned_vanilla(time timestamptz, temp float, device int) PARTITION BY RANGE (time); CREATE TABLE attachment_vanilla(time timestamptz, temp float, device int); ALTER TABLE partitioned_vanilla ATTACH PARTITION attachment_vanilla FOR VALUES FROM ('2016-07-01') TO ('2016-08-01'); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/partitionwise-15.out�����������������������������������������������0000664�0000000�0000000�00000112473�15100345067�0022520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- Create a two dimensional hypertable CREATE TABLE hyper (time timestamptz, device int, temp float); SELECT * FROM create_hypertable('hyper', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t -- Create a similar PostgreSQL partitioned table CREATE TABLE pg2dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg2dim_h1 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 0) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h2 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 1) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h1_t1 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h1_t2 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); CREATE TABLE pg2dim_h2_t1 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h2_t2 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); -- Create a 1-dimensional partitioned table for comparison CREATE TABLE pg1dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg1dim_h1 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE pg1dim_h2 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 1); INSERT INTO hyper VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg2dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg1dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); SELECT * FROM test.show_subtables('hyper'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal._hyper_1_4_chunk | SELECT * FROM pg2dim_h1_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:01:00 2018 PST | 1 | 2.3 SELECT * FROM pg2dim_h1_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:01:00 2018 PDT | 1 | 7.6 SELECT * FROM pg2dim_h2_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:02:00 2018 PST | 3 | 3.1 SELECT * FROM pg2dim_h2_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:02:00 2018 PDT | 3 | 9 -- Compare partitionwise aggreate enabled/disabled. First run queries -- on PG partitioned tables for reference. -- All partition keys covered by GROUP BY SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Append -> Seq Scan on public.pg1dim_h1 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -> Seq Scan on public.pg1dim_h2 pg1dim_2 Output: pg1dim_2.device, pg1dim_2.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> Append -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Seq Scan on public.pg1dim_h1 pg1dim Output: pg1dim.device, pg1dim.temp -> HashAggregate Output: pg1dim_1.device, avg(pg1dim_1.temp) Group Key: pg1dim_1.device -> Seq Scan on public.pg1dim_h2 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -- All partition keys not covered by GROUP BY (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> Finalize HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Partial HashAggregate Output: pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -- All partition keys covered by GROUP BY (full partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4."time", pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> Append -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim."time", pg2dim.device, pg2dim.temp -> HashAggregate Output: pg2dim_1."time", pg2dim_1.device, avg(pg2dim_1.temp) Group Key: pg2dim_1."time", pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> HashAggregate Output: pg2dim_2."time", pg2dim_2.device, avg(pg2dim_2.temp) Group Key: pg2dim_2."time", pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> HashAggregate Output: pg2dim_3."time", pg2dim_3.device, avg(pg2dim_3.temp) Group Key: pg2dim_3."time", pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -- All partition keys not covered by GROUP BY because of date_trunc -- expression on time (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: date_trunc('month'::text, pg2dim_4."time"), pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Finalize HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: date_trunc('month'::text, pg2dim."time"), pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: date_trunc('month'::text, pg2dim."time"), pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_1."time")), pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_2."time")), pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_3."time")), pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -- Now run on hypertable -- All partition keys not covered by GROUP BY (partial partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation since date_trunc(time) is not a partition key SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Also test time_bucket SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Test partitionwise joins, mostly to see that we do not break -- anything CREATE TABLE hyper_meta (time timestamptz, device int, info text); SELECT * FROM create_hypertable('hyper_meta', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_meta | t INSERT INTO hyper_meta VALUES ('2018-02-19 13:01', 1, 'device_1'), ('2018-02-19 13:02', 3, 'device_3'); SET enable_partitionwise_join = 'off'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Merge Join Output: pg2."time", pg2.device, pg2.temp, pg1.temp Merge Cond: (pg1.device = pg2.device) -> Sort Output: pg1.temp, pg1.device Sort Key: pg1.device -> Append -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2."time", pg2.device, pg2.temp Sort Key: pg2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_1 Output: pg2_1."time", pg2_1.device, pg2_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_4 Output: pg2_4."time", pg2_4.device, pg2_4.temp SET enable_partitionwise_join = 'on'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Append -> Merge Join Output: pg2_2."time", pg2_2.device, pg2_2.temp, pg1_1.temp Merge Cond: (pg1_1.device = pg2_2.device) -> Sort Output: pg1_1.temp, pg1_1.device Sort Key: pg1_1.device -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Sort Output: pg2_2."time", pg2_2.device, pg2_2.temp Sort Key: pg2_2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Merge Join Output: pg2_5."time", pg2_5.device, pg2_5.temp, pg1_2.temp Merge Cond: (pg1_2.device = pg2_5.device) -> Sort Output: pg1_2.temp, pg1_2.device Sort Key: pg1_2.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2_5."time", pg2_5.device, pg2_5.temp Sort Key: pg2_5.device -> Append -> Seq Scan on public.pg2dim_h2_t1 pg2_5 Output: pg2_5."time", pg2_5.device, pg2_5.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_6 Output: pg2_6."time", pg2_6.device, pg2_6.temp -- Test hypertable with time partitioning function CREATE OR REPLACE FUNCTION time_func(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RETURN retval; END $BODY$; CREATE TABLE hyper_timepart (time float8, device int, temp float); SELECT * FROM create_hypertable('hyper_timepart', 'time', 'device', 2, time_partitioning_func => 'time_func'); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 3 | public | hyper_timepart | t -- Planner won't pick push-down aggs on table with time function -- unless a certain amount of data SELECT setseed(1); setseed --------- INSERT INTO hyper_timepart SELECT x, ceil(random() * 8), random() * 20 FROM generate_series(0,5000-1) AS x; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Grouping on original time column should be pushed-down SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp -- Applying the time partitioning function should also allow push-down -- on open dimensions :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. :PREFIX SELECT time_func(time), _timescaledb_functions.get_partition_hash(device), avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) -> Incremental Sort Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), _timescaledb_functions.get_partition_hash(hyper_timepart.device), hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Test removal of redundant group key optimization in PG16 -- All lower versions include the redundant key on device column :PREFIX SELECT device, avg(temp) FROM hyper_timepart WHERE device = 1 GROUP BY 1 LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_3_8_chunk.device, (avg(_hyper_3_8_chunk.temp)) -> GroupAggregate Output: _hyper_3_8_chunk.device, avg(_hyper_3_8_chunk.temp) Group Key: _hyper_3_8_chunk.device -> Index Scan using _hyper_3_8_chunk_hyper_timepart_device_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp Index Cond: (_hyper_3_8_chunk.device = 1) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/partitionwise-16.out�����������������������������������������������0000664�0000000�0000000�00000112417�15100345067�0022517�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- Create a two dimensional hypertable CREATE TABLE hyper (time timestamptz, device int, temp float); SELECT * FROM create_hypertable('hyper', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t -- Create a similar PostgreSQL partitioned table CREATE TABLE pg2dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg2dim_h1 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 0) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h2 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 1) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h1_t1 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h1_t2 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); CREATE TABLE pg2dim_h2_t1 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h2_t2 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); -- Create a 1-dimensional partitioned table for comparison CREATE TABLE pg1dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg1dim_h1 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE pg1dim_h2 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 1); INSERT INTO hyper VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg2dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg1dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); SELECT * FROM test.show_subtables('hyper'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal._hyper_1_4_chunk | SELECT * FROM pg2dim_h1_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:01:00 2018 PST | 1 | 2.3 SELECT * FROM pg2dim_h1_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:01:00 2018 PDT | 1 | 7.6 SELECT * FROM pg2dim_h2_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:02:00 2018 PST | 3 | 3.1 SELECT * FROM pg2dim_h2_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:02:00 2018 PDT | 3 | 9 -- Compare partitionwise aggreate enabled/disabled. First run queries -- on PG partitioned tables for reference. -- All partition keys covered by GROUP BY SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Append -> Seq Scan on public.pg1dim_h1 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -> Seq Scan on public.pg1dim_h2 pg1dim_2 Output: pg1dim_2.device, pg1dim_2.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> Append -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Seq Scan on public.pg1dim_h1 pg1dim Output: pg1dim.device, pg1dim.temp -> HashAggregate Output: pg1dim_1.device, avg(pg1dim_1.temp) Group Key: pg1dim_1.device -> Seq Scan on public.pg1dim_h2 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -- All partition keys not covered by GROUP BY (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> Finalize HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Partial HashAggregate Output: pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -- All partition keys covered by GROUP BY (full partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4."time", pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> Append -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim."time", pg2dim.device, pg2dim.temp -> HashAggregate Output: pg2dim_1."time", pg2dim_1.device, avg(pg2dim_1.temp) Group Key: pg2dim_1."time", pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> HashAggregate Output: pg2dim_2."time", pg2dim_2.device, avg(pg2dim_2.temp) Group Key: pg2dim_2."time", pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> HashAggregate Output: pg2dim_3."time", pg2dim_3.device, avg(pg2dim_3.temp) Group Key: pg2dim_3."time", pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -- All partition keys not covered by GROUP BY because of date_trunc -- expression on time (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: date_trunc('month'::text, pg2dim_4."time"), pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Finalize HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: date_trunc('month'::text, pg2dim."time"), pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: date_trunc('month'::text, pg2dim."time"), pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_1."time")), pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_2."time")), pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_3."time")), pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -- Now run on hypertable -- All partition keys not covered by GROUP BY (partial partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation since date_trunc(time) is not a partition key SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Also test time_bucket SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Test partitionwise joins, mostly to see that we do not break -- anything CREATE TABLE hyper_meta (time timestamptz, device int, info text); SELECT * FROM create_hypertable('hyper_meta', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_meta | t INSERT INTO hyper_meta VALUES ('2018-02-19 13:01', 1, 'device_1'), ('2018-02-19 13:02', 3, 'device_3'); SET enable_partitionwise_join = 'off'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Merge Join Output: pg2."time", pg2.device, pg2.temp, pg1.temp Merge Cond: (pg1.device = pg2.device) -> Sort Output: pg1.temp, pg1.device Sort Key: pg1.device -> Append -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2."time", pg2.device, pg2.temp Sort Key: pg2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_1 Output: pg2_1."time", pg2_1.device, pg2_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_4 Output: pg2_4."time", pg2_4.device, pg2_4.temp SET enable_partitionwise_join = 'on'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Append -> Merge Join Output: pg2_2."time", pg2_2.device, pg2_2.temp, pg1_1.temp Merge Cond: (pg1_1.device = pg2_2.device) -> Sort Output: pg1_1.temp, pg1_1.device Sort Key: pg1_1.device -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Sort Output: pg2_2."time", pg2_2.device, pg2_2.temp Sort Key: pg2_2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Merge Join Output: pg2_5."time", pg2_5.device, pg2_5.temp, pg1_2.temp Merge Cond: (pg1_2.device = pg2_5.device) -> Sort Output: pg1_2.temp, pg1_2.device Sort Key: pg1_2.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2_5."time", pg2_5.device, pg2_5.temp Sort Key: pg2_5.device -> Append -> Seq Scan on public.pg2dim_h2_t1 pg2_5 Output: pg2_5."time", pg2_5.device, pg2_5.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_6 Output: pg2_6."time", pg2_6.device, pg2_6.temp -- Test hypertable with time partitioning function CREATE OR REPLACE FUNCTION time_func(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RETURN retval; END $BODY$; CREATE TABLE hyper_timepart (time float8, device int, temp float); SELECT * FROM create_hypertable('hyper_timepart', 'time', 'device', 2, time_partitioning_func => 'time_func'); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 3 | public | hyper_timepart | t -- Planner won't pick push-down aggs on table with time function -- unless a certain amount of data SELECT setseed(1); setseed --------- INSERT INTO hyper_timepart SELECT x, ceil(random() * 8), random() * 20 FROM generate_series(0,5000-1) AS x; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Grouping on original time column should be pushed-down SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp -- Applying the time partitioning function should also allow push-down -- on open dimensions :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. :PREFIX SELECT time_func(time), _timescaledb_functions.get_partition_hash(device), avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) -> Incremental Sort Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), _timescaledb_functions.get_partition_hash(hyper_timepart.device), hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Test removal of redundant group key optimization in PG16 -- All lower versions include the redundant key on device column :PREFIX SELECT device, avg(temp) FROM hyper_timepart WHERE device = 1 GROUP BY 1 LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_3_8_chunk.device, (avg(_hyper_3_8_chunk.temp)) -> GroupAggregate Output: _hyper_3_8_chunk.device, avg(_hyper_3_8_chunk.temp) -> Index Scan using _hyper_3_8_chunk_hyper_timepart_device_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp Index Cond: (_hyper_3_8_chunk.device = 1) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/partitionwise-17.out�����������������������������������������������0000664�0000000�0000000�00000112417�15100345067�0022520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- Create a two dimensional hypertable CREATE TABLE hyper (time timestamptz, device int, temp float); SELECT * FROM create_hypertable('hyper', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t -- Create a similar PostgreSQL partitioned table CREATE TABLE pg2dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg2dim_h1 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 0) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h2 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 1) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h1_t1 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h1_t2 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); CREATE TABLE pg2dim_h2_t1 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h2_t2 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); -- Create a 1-dimensional partitioned table for comparison CREATE TABLE pg1dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg1dim_h1 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE pg1dim_h2 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 1); INSERT INTO hyper VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg2dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg1dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); SELECT * FROM test.show_subtables('hyper'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal._hyper_1_4_chunk | SELECT * FROM pg2dim_h1_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:01:00 2018 PST | 1 | 2.3 SELECT * FROM pg2dim_h1_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:01:00 2018 PDT | 1 | 7.6 SELECT * FROM pg2dim_h2_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:02:00 2018 PST | 3 | 3.1 SELECT * FROM pg2dim_h2_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:02:00 2018 PDT | 3 | 9 -- Compare partitionwise aggreate enabled/disabled. First run queries -- on PG partitioned tables for reference. -- All partition keys covered by GROUP BY SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Append -> Seq Scan on public.pg1dim_h1 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -> Seq Scan on public.pg1dim_h2 pg1dim_2 Output: pg1dim_2.device, pg1dim_2.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> Append -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Seq Scan on public.pg1dim_h1 pg1dim Output: pg1dim.device, pg1dim.temp -> HashAggregate Output: pg1dim_1.device, avg(pg1dim_1.temp) Group Key: pg1dim_1.device -> Seq Scan on public.pg1dim_h2 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -- All partition keys not covered by GROUP BY (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> Finalize HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Partial HashAggregate Output: pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -- All partition keys covered by GROUP BY (full partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4."time", pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> Append -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim."time", pg2dim.device, pg2dim.temp -> HashAggregate Output: pg2dim_1."time", pg2dim_1.device, avg(pg2dim_1.temp) Group Key: pg2dim_1."time", pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> HashAggregate Output: pg2dim_2."time", pg2dim_2.device, avg(pg2dim_2.temp) Group Key: pg2dim_2."time", pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> HashAggregate Output: pg2dim_3."time", pg2dim_3.device, avg(pg2dim_3.temp) Group Key: pg2dim_3."time", pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -- All partition keys not covered by GROUP BY because of date_trunc -- expression on time (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: date_trunc('month'::text, pg2dim_4."time"), pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Finalize HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: date_trunc('month'::text, pg2dim."time"), pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: date_trunc('month'::text, pg2dim."time"), pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_1."time")), pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_2."time")), pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_3."time")), pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -- Now run on hypertable -- All partition keys not covered by GROUP BY (partial partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation since date_trunc(time) is not a partition key SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Also test time_bucket SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Test partitionwise joins, mostly to see that we do not break -- anything CREATE TABLE hyper_meta (time timestamptz, device int, info text); SELECT * FROM create_hypertable('hyper_meta', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_meta | t INSERT INTO hyper_meta VALUES ('2018-02-19 13:01', 1, 'device_1'), ('2018-02-19 13:02', 3, 'device_3'); SET enable_partitionwise_join = 'off'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Merge Join Output: pg2."time", pg2.device, pg2.temp, pg1.temp Merge Cond: (pg1.device = pg2.device) -> Sort Output: pg1.temp, pg1.device Sort Key: pg1.device -> Append -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2."time", pg2.device, pg2.temp Sort Key: pg2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_1 Output: pg2_1."time", pg2_1.device, pg2_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_4 Output: pg2_4."time", pg2_4.device, pg2_4.temp SET enable_partitionwise_join = 'on'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Append -> Merge Join Output: pg2_2."time", pg2_2.device, pg2_2.temp, pg1_1.temp Merge Cond: (pg1_1.device = pg2_2.device) -> Sort Output: pg1_1.temp, pg1_1.device Sort Key: pg1_1.device -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Sort Output: pg2_2."time", pg2_2.device, pg2_2.temp Sort Key: pg2_2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Merge Join Output: pg2_5."time", pg2_5.device, pg2_5.temp, pg1_2.temp Merge Cond: (pg1_2.device = pg2_5.device) -> Sort Output: pg1_2.temp, pg1_2.device Sort Key: pg1_2.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2_5."time", pg2_5.device, pg2_5.temp Sort Key: pg2_5.device -> Append -> Seq Scan on public.pg2dim_h2_t1 pg2_5 Output: pg2_5."time", pg2_5.device, pg2_5.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_6 Output: pg2_6."time", pg2_6.device, pg2_6.temp -- Test hypertable with time partitioning function CREATE OR REPLACE FUNCTION time_func(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RETURN retval; END $BODY$; CREATE TABLE hyper_timepart (time float8, device int, temp float); SELECT * FROM create_hypertable('hyper_timepart', 'time', 'device', 2, time_partitioning_func => 'time_func'); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 3 | public | hyper_timepart | t -- Planner won't pick push-down aggs on table with time function -- unless a certain amount of data SELECT setseed(1); setseed --------- INSERT INTO hyper_timepart SELECT x, ceil(random() * 8), random() * 20 FROM generate_series(0,5000-1) AS x; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Grouping on original time column should be pushed-down SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp -- Applying the time partitioning function should also allow push-down -- on open dimensions :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. :PREFIX SELECT time_func(time), _timescaledb_functions.get_partition_hash(device), avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) -> Incremental Sort Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), _timescaledb_functions.get_partition_hash(hyper_timepart.device), hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Test removal of redundant group key optimization in PG16 -- All lower versions include the redundant key on device column :PREFIX SELECT device, avg(temp) FROM hyper_timepart WHERE device = 1 GROUP BY 1 LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_3_8_chunk.device, (avg(_hyper_3_8_chunk.temp)) -> GroupAggregate Output: _hyper_3_8_chunk.device, avg(_hyper_3_8_chunk.temp) -> Index Scan using _hyper_3_8_chunk_hyper_timepart_device_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp Index Cond: (_hyper_3_8_chunk.device = 1) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/partitionwise-18.out�����������������������������������������������0000664�0000000�0000000�00000112417�15100345067�0022521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- Create a two dimensional hypertable CREATE TABLE hyper (time timestamptz, device int, temp float); SELECT * FROM create_hypertable('hyper', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t -- Create a similar PostgreSQL partitioned table CREATE TABLE pg2dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg2dim_h1 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 0) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h2 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 1) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h1_t1 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h1_t2 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); CREATE TABLE pg2dim_h2_t1 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h2_t2 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); -- Create a 1-dimensional partitioned table for comparison CREATE TABLE pg1dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg1dim_h1 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE pg1dim_h2 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 1); INSERT INTO hyper VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg2dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg1dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); SELECT * FROM test.show_subtables('hyper'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal._hyper_1_4_chunk | SELECT * FROM pg2dim_h1_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:01:00 2018 PST | 1 | 2.3 SELECT * FROM pg2dim_h1_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:01:00 2018 PDT | 1 | 7.6 SELECT * FROM pg2dim_h2_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:02:00 2018 PST | 3 | 3.1 SELECT * FROM pg2dim_h2_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:02:00 2018 PDT | 3 | 9 -- Compare partitionwise aggreate enabled/disabled. First run queries -- on PG partitioned tables for reference. -- All partition keys covered by GROUP BY SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Append -> Seq Scan on public.pg1dim_h1 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -> Seq Scan on public.pg1dim_h2 pg1dim_2 Output: pg1dim_2.device, pg1dim_2.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> Append -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Seq Scan on public.pg1dim_h1 pg1dim Output: pg1dim.device, pg1dim.temp -> HashAggregate Output: pg1dim_1.device, avg(pg1dim_1.temp) Group Key: pg1dim_1.device -> Seq Scan on public.pg1dim_h2 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -- All partition keys not covered by GROUP BY (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> Finalize HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Partial HashAggregate Output: pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -- All partition keys covered by GROUP BY (full partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4."time", pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> Append -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim."time", pg2dim.device, pg2dim.temp -> HashAggregate Output: pg2dim_1."time", pg2dim_1.device, avg(pg2dim_1.temp) Group Key: pg2dim_1."time", pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> HashAggregate Output: pg2dim_2."time", pg2dim_2.device, avg(pg2dim_2.temp) Group Key: pg2dim_2."time", pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> HashAggregate Output: pg2dim_3."time", pg2dim_3.device, avg(pg2dim_3.temp) Group Key: pg2dim_3."time", pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -- All partition keys not covered by GROUP BY because of date_trunc -- expression on time (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: date_trunc('month'::text, pg2dim_4."time"), pg2dim_4.device, pg2dim_4.temp SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Finalize HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: date_trunc('month'::text, pg2dim."time"), pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: date_trunc('month'::text, pg2dim."time"), pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_1."time")), pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_2."time")), pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_3."time")), pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -- Now run on hypertable -- All partition keys not covered by GROUP BY (partial partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Sort Output: hyper.device, (avg(hyper.temp)) Sort Key: hyper.device -> HashAggregate Output: hyper.device, avg(hyper.temp) Group Key: hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: hyper."time", hyper.device, (avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> HashAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation since date_trunc(time) is not a partition key SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (date_trunc('month'::text, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (date_trunc('month'::text, hyper."time")), hyper.device -> HashAggregate Output: (date_trunc('month'::text, hyper."time")), hyper.device, avg(hyper.temp) Group Key: date_trunc('month'::text, hyper."time"), hyper.device -> Result Output: date_trunc('month'::text, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Also test time_bucket SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, (avg(hyper.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, hyper."time")), hyper.device, avg(hyper.temp) Group Key: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device -> Result Output: time_bucket('@ 1 mon'::interval, hyper."time"), hyper.device, hyper.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp -- Test partitionwise joins, mostly to see that we do not break -- anything CREATE TABLE hyper_meta (time timestamptz, device int, info text); SELECT * FROM create_hypertable('hyper_meta', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_meta | t INSERT INTO hyper_meta VALUES ('2018-02-19 13:01', 1, 'device_1'), ('2018-02-19 13:02', 3, 'device_3'); SET enable_partitionwise_join = 'off'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Merge Join Output: pg2."time", pg2.device, pg2.temp, pg1.temp Merge Cond: (pg1.device = pg2.device) -> Sort Output: pg1.temp, pg1.device Sort Key: pg1.device -> Append -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2."time", pg2.device, pg2.temp Sort Key: pg2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_1 Output: pg2_1."time", pg2_1.device, pg2_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_4 Output: pg2_4."time", pg2_4.device, pg2_4.temp SET enable_partitionwise_join = 'on'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; --- QUERY PLAN --- Merge Join Output: h."time", h.device, h.temp, hm.info Merge Cond: (hm.device = h.device) -> Merge Append Sort Key: hm.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h."time", h.device, h.temp -> Merge Append Sort Key: h.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; --- QUERY PLAN --- Append -> Merge Join Output: pg2_2."time", pg2_2.device, pg2_2.temp, pg1_1.temp Merge Cond: (pg1_1.device = pg2_2.device) -> Sort Output: pg1_1.temp, pg1_1.device Sort Key: pg1_1.device -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Sort Output: pg2_2."time", pg2_2.device, pg2_2.temp Sort Key: pg2_2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Merge Join Output: pg2_5."time", pg2_5.device, pg2_5.temp, pg1_2.temp Merge Cond: (pg1_2.device = pg2_5.device) -> Sort Output: pg1_2.temp, pg1_2.device Sort Key: pg1_2.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2_5."time", pg2_5.device, pg2_5.temp Sort Key: pg2_5.device -> Append -> Seq Scan on public.pg2dim_h2_t1 pg2_5 Output: pg2_5."time", pg2_5.device, pg2_5.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_6 Output: pg2_6."time", pg2_6.device, pg2_6.temp -- Test hypertable with time partitioning function CREATE OR REPLACE FUNCTION time_func(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RETURN retval; END $BODY$; CREATE TABLE hyper_timepart (time float8, device int, temp float); SELECT * FROM create_hypertable('hyper_timepart', 'time', 'device', 2, time_partitioning_func => 'time_func'); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 3 | public | hyper_timepart | t -- Planner won't pick push-down aggs on table with time function -- unless a certain amount of data SELECT setseed(1); setseed --------- INSERT INTO hyper_timepart SELECT x, ceil(random() * 8), random() * 20 FROM generate_series(0,5000-1) AS x; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Grouping on original time column should be pushed-down SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) -> Sort Output: hyper_timepart."time", hyper_timepart.device, (avg(hyper_timepart.temp)) Sort Key: hyper_timepart."time", hyper_timepart.device -> HashAggregate Output: hyper_timepart."time", hyper_timepart.device, avg(hyper_timepart.temp) Group Key: hyper_timepart."time", hyper_timepart.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp -- Applying the time partitioning function should also allow push-down -- on open dimensions :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), hyper_timepart.device, (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), hyper_timepart.device, avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), hyper_timepart.device -> Incremental Sort Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), hyper_timepart.device Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), hyper_timepart.device, hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. :PREFIX SELECT time_func(time), _timescaledb_functions.get_partition_hash(device), avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; --- QUERY PLAN --- Limit Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), (avg(hyper_timepart.temp)) -> GroupAggregate Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), avg(hyper_timepart.temp) Group Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) -> Incremental Sort Output: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)), hyper_timepart.temp Sort Key: (time_func(hyper_timepart."time")), (_timescaledb_functions.get_partition_hash(hyper_timepart.device)) Presorted Key: (time_func(hyper_timepart."time")) -> Result Output: (time_func(hyper_timepart."time")), _timescaledb_functions.get_partition_hash(hyper_timepart.device), hyper_timepart.temp -> Merge Append Sort Key: (time_func(hyper_timepart."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") -- Test removal of redundant group key optimization in PG16 -- All lower versions include the redundant key on device column :PREFIX SELECT device, avg(temp) FROM hyper_timepart WHERE device = 1 GROUP BY 1 LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_3_8_chunk.device, (avg(_hyper_3_8_chunk.temp)) -> GroupAggregate Output: _hyper_3_8_chunk.device, avg(_hyper_3_8_chunk.temp) -> Index Scan using _hyper_3_8_chunk_hyper_timepart_device_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp Index Cond: (_hyper_3_8_chunk.device = 1) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/partitionwise.out��������������������������������������������������0000664�0000000�0000000�00000135376�15100345067�0022304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (VERBOSE, COSTS OFF)' -- Create a two dimensional hypertable CREATE TABLE hyper (time timestamptz, device int, temp float); SELECT * FROM create_hypertable('hyper', 'time', 'device', 2); NOTICE: adding not-null constraint to column "time" hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t (1 row) -- Create a similar PostgreSQL partitioned table CREATE TABLE pg2dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg2dim_h1 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 0) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h2 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 1) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h1_t1 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h1_t2 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); CREATE TABLE pg2dim_h2_t1 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h2_t2 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); -- Create a 1-dimensional partitioned table for comparison CREATE TABLE pg1dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg1dim_h1 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE pg1dim_h2 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 1); INSERT INTO hyper VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg2dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg1dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); SELECT * FROM test.show_subtables('hyper'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal._hyper_1_4_chunk | (4 rows) SELECT * FROM pg2dim_h1_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:01:00 2018 PST | 1 | 2.3 (1 row) SELECT * FROM pg2dim_h1_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:01:00 2018 PDT | 1 | 7.6 (1 row) SELECT * FROM pg2dim_h2_t1; time | device | temp ------------------------------+--------+------ Mon Feb 19 13:02:00 2018 PST | 3 | 3.1 (1 row) SELECT * FROM pg2dim_h2_t2; time | device | temp ------------------------------+--------+------ Fri Oct 19 13:02:00 2018 PDT | 3 | 9 (1 row) -- Compare partitionwise aggreate enabled/disabled. First run queries -- on PG partitioned tables for reference. -- All partition keys covered by GROUP BY SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; QUERY PLAN ------------------------------------------------------------ Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Append -> Seq Scan on public.pg1dim_h1 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp -> Seq Scan on public.pg1dim_h2 pg1dim_2 Output: pg1dim_2.device, pg1dim_2.temp (11 rows) SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; QUERY PLAN ------------------------------------------------------------ Sort Output: pg1dim.device, (avg(pg1dim.temp)) Sort Key: pg1dim.device -> Append -> HashAggregate Output: pg1dim.device, avg(pg1dim.temp) Group Key: pg1dim.device -> Seq Scan on public.pg1dim_h1 pg1dim Output: pg1dim.device, pg1dim.temp -> HashAggregate Output: pg1dim_1.device, avg(pg1dim_1.temp) Group Key: pg1dim_1.device -> Seq Scan on public.pg1dim_h2 pg1dim_1 Output: pg1dim_1.device, pg1dim_1.temp (14 rows) -- All partition keys not covered by GROUP BY (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; QUERY PLAN ------------------------------------------------------------ Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4.device, pg2dim_4.temp (15 rows) SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; QUERY PLAN ------------------------------------------------------------------------- Sort Output: pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim.device -> Finalize HashAggregate Output: pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim.device -> Append -> Partial HashAggregate Output: pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3.device, pg2dim_3.temp (27 rows) -- All partition keys covered by GROUP BY (full partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ----------------------------------------------------------------------------- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: pg2dim_4."time", pg2dim_4.device, pg2dim_4.temp (15 rows) SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ----------------------------------------------------------------------------- Sort Output: pg2dim."time", pg2dim.device, (avg(pg2dim.temp)) Sort Key: pg2dim."time", pg2dim.device -> Append -> HashAggregate Output: pg2dim."time", pg2dim.device, avg(pg2dim.temp) Group Key: pg2dim."time", pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: pg2dim."time", pg2dim.device, pg2dim.temp -> HashAggregate Output: pg2dim_1."time", pg2dim_1.device, avg(pg2dim_1.temp) Group Key: pg2dim_1."time", pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: pg2dim_1."time", pg2dim_1.device, pg2dim_1.temp -> HashAggregate Output: pg2dim_2."time", pg2dim_2.device, avg(pg2dim_2.temp) Group Key: pg2dim_2."time", pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: pg2dim_2."time", pg2dim_2.device, pg2dim_2.temp -> HashAggregate Output: pg2dim_3."time", pg2dim_3.device, avg(pg2dim_3.temp) Group Key: pg2dim_3."time", pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: pg2dim_3."time", pg2dim_3.device, pg2dim_3.temp (24 rows) -- All partition keys not covered by GROUP BY because of date_trunc -- expression on time (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN -------------------------------------------------------------------------------------------------------- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2dim_4 Output: date_trunc('month'::text, pg2dim_4."time"), pg2dim_4.device, pg2dim_4.temp (15 rows) SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------- Sort Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, (avg(pg2dim.temp)) Sort Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Finalize HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, avg(pg2dim.temp) Group Key: (date_trunc('month'::text, pg2dim."time")), pg2dim.device -> Append -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim."time")), pg2dim.device, PARTIAL avg(pg2dim.temp) Group Key: date_trunc('month'::text, pg2dim."time"), pg2dim.device -> Seq Scan on public.pg2dim_h1_t1 pg2dim Output: date_trunc('month'::text, pg2dim."time"), pg2dim.device, pg2dim.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_1."time")), pg2dim_1.device, PARTIAL avg(pg2dim_1.temp) Group Key: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device -> Seq Scan on public.pg2dim_h1_t2 pg2dim_1 Output: date_trunc('month'::text, pg2dim_1."time"), pg2dim_1.device, pg2dim_1.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_2."time")), pg2dim_2.device, PARTIAL avg(pg2dim_2.temp) Group Key: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device -> Seq Scan on public.pg2dim_h2_t1 pg2dim_2 Output: date_trunc('month'::text, pg2dim_2."time"), pg2dim_2.device, pg2dim_2.temp -> Partial HashAggregate Output: (date_trunc('month'::text, pg2dim_3."time")), pg2dim_3.device, PARTIAL avg(pg2dim_3.temp) Group Key: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device -> Seq Scan on public.pg2dim_h2_t2 pg2dim_3 Output: date_trunc('month'::text, pg2dim_3."time"), pg2dim_3.device, pg2dim_3.temp (27 rows) -- Now run on hypertable -- All partition keys not covered by GROUP BY (partial partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; QUERY PLAN ---------------------------------------------------------------------------- Sort Output: _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: _hyper_1_1_chunk.device -> HashAggregate Output: _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: _hyper_1_1_chunk.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (15 rows) SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; QUERY PLAN ----------------------------------------------------------------------------------------- Sort Output: _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: _hyper_1_1_chunk.device -> Finalize HashAggregate Output: _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: _hyper_1_1_chunk.device -> Append -> Partial HashAggregate Output: _hyper_1_1_chunk.device, PARTIAL avg(_hyper_1_1_chunk.temp) Group Key: _hyper_1_1_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Partial HashAggregate Output: _hyper_1_2_chunk.device, PARTIAL avg(_hyper_1_2_chunk.temp) Group Key: _hyper_1_2_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Partial HashAggregate Output: _hyper_1_3_chunk.device, PARTIAL avg(_hyper_1_3_chunk.temp) Group Key: _hyper_1_3_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Partial HashAggregate Output: _hyper_1_4_chunk.device, PARTIAL avg(_hyper_1_4_chunk.temp) Group Key: _hyper_1_4_chunk.device -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (27 rows) -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ----------------------------------------------------------------------------------------------------- Sort Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device -> HashAggregate Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (15 rows) SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------- Finalize GroupAggregate Output: hyper."time", hyper.device, avg(hyper.temp) Group Key: hyper."time", hyper.device -> Sort Output: hyper."time", hyper.device, (PARTIAL avg(hyper.temp)) Sort Key: hyper."time", hyper.device -> Custom Scan (ChunkAppend) on public.hyper Output: hyper."time", hyper.device, (PARTIAL avg(hyper.temp)) Order: hyper."time" Startup Exclusion: false Runtime Exclusion: false -> Merge Append Sort Key: _hyper_1_1_chunk."time" -> Partial GroupAggregate Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, PARTIAL avg(_hyper_1_1_chunk.temp) Group Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device -> Sort Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device -> Index Scan Backward using _hyper_1_1_chunk_hyper_time_idx on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Partial GroupAggregate Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, PARTIAL avg(_hyper_1_2_chunk.temp) Group Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device -> Sort Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device -> Index Scan Backward using _hyper_1_2_chunk_hyper_time_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Merge Append Sort Key: _hyper_1_3_chunk."time" -> Partial GroupAggregate Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, PARTIAL avg(_hyper_1_3_chunk.temp) Group Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device -> Sort Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device -> Index Scan Backward using _hyper_1_3_chunk_hyper_time_idx on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Partial GroupAggregate Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, PARTIAL avg(_hyper_1_4_chunk.temp) Group Key: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device -> Sort Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp Sort Key: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device -> Index Scan Backward using _hyper_1_4_chunk_hyper_time_idx on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (47 rows) -- Partial aggregation since date_trunc(time) is not a partition key SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN --------------------------------------------------------------------------------------------------------------------------- Sort Output: (date_trunc('month'::text, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: (date_trunc('month'::text, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device -> HashAggregate Output: (date_trunc('month'::text, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: date_trunc('month'::text, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device -> Result Output: date_trunc('month'::text, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (17 rows) -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN --------------------------------------------------------------------------------------------------------------------------- Sort Output: (date_trunc('month'::text, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: (date_trunc('month'::text, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device -> HashAggregate Output: (date_trunc('month'::text, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: date_trunc('month'::text, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device -> Result Output: date_trunc('month'::text, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (17 rows) -- Also test time_bucket SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------- Sort Output: (time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device -> Result Output: time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (17 rows) SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------- Sort Output: (time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, (avg(_hyper_1_1_chunk.temp)) Sort Key: (time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device -> HashAggregate Output: (time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device, avg(_hyper_1_1_chunk.temp) Group Key: time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device -> Result Output: time_bucket('@ 1 mon'::interval, _hyper_1_1_chunk."time"), _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device, _hyper_1_1_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device, _hyper_1_2_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device, _hyper_1_3_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device, _hyper_1_4_chunk.temp (17 rows) -- Test partitionwise joins, mostly to see that we do not break -- anything CREATE TABLE hyper_meta (time timestamptz, device int, info text); SELECT * FROM create_hypertable('hyper_meta', 'time', 'device', 2); NOTICE: adding not-null constraint to column "time" hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_meta | t (1 row) INSERT INTO hyper_meta VALUES ('2018-02-19 13:01', 1, 'device_1'), ('2018-02-19 13:02', 3, 'device_3'); SET enable_partitionwise_join = 'off'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------- Merge Join Output: h_1."time", h_1.device, h_1.temp, hm_1.info Merge Cond: (hm_1.device = h_1.device) -> Merge Append Sort Key: hm_1.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h_1."time", h_1.device, h_1.temp -> Merge Append Sort Key: h_1.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp (21 rows) :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; QUERY PLAN -------------------------------------------------------------------- Merge Join Output: pg2."time", pg2.device, pg2.temp, pg1.temp Merge Cond: (pg1.device = pg2.device) -> Sort Output: pg1.temp, pg1.device Sort Key: pg1.device -> Append -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2."time", pg2.device, pg2.temp Sort Key: pg2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_1 Output: pg2_1."time", pg2_1.device, pg2_1.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h2_t1 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_4 Output: pg2_4."time", pg2_4.device, pg2_4.temp (23 rows) SET enable_partitionwise_join = 'on'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------- Merge Join Output: h_1."time", h_1.device, h_1.temp, hm_1.info Merge Cond: (hm_1.device = h_1.device) -> Merge Append Sort Key: hm_1.device -> Index Scan using _hyper_2_5_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_5_chunk hm_1 Output: hm_1.info, hm_1.device -> Index Scan using _hyper_2_6_chunk_hyper_meta_device_time_idx on _timescaledb_internal._hyper_2_6_chunk hm_2 Output: hm_2.info, hm_2.device -> Materialize Output: h_1."time", h_1.device, h_1.temp -> Merge Append Sort Key: h_1.device -> Index Scan using _hyper_1_1_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_1_chunk h_1 Output: h_1."time", h_1.device, h_1.temp -> Index Scan using _hyper_1_2_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_2_chunk h_2 Output: h_2."time", h_2.device, h_2.temp -> Index Scan using _hyper_1_3_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_3_chunk h_3 Output: h_3."time", h_3.device, h_3.temp -> Index Scan using _hyper_1_4_chunk_hyper_device_time_idx on _timescaledb_internal._hyper_1_4_chunk h_4 Output: h_4."time", h_4.device, h_4.temp (21 rows) :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; QUERY PLAN -------------------------------------------------------------------------- Append -> Merge Join Output: pg2_2."time", pg2_2.device, pg2_2.temp, pg1_1.temp Merge Cond: (pg1_1.device = pg2_2.device) -> Sort Output: pg1_1.temp, pg1_1.device Sort Key: pg1_1.device -> Seq Scan on public.pg1dim_h1 pg1_1 Output: pg1_1.temp, pg1_1.device -> Sort Output: pg2_2."time", pg2_2.device, pg2_2.temp Sort Key: pg2_2.device -> Append -> Seq Scan on public.pg2dim_h1_t1 pg2_2 Output: pg2_2."time", pg2_2.device, pg2_2.temp -> Seq Scan on public.pg2dim_h1_t2 pg2_3 Output: pg2_3."time", pg2_3.device, pg2_3.temp -> Merge Join Output: pg2_5."time", pg2_5.device, pg2_5.temp, pg1_2.temp Merge Cond: (pg1_2.device = pg2_5.device) -> Sort Output: pg1_2.temp, pg1_2.device Sort Key: pg1_2.device -> Seq Scan on public.pg1dim_h2 pg1_2 Output: pg1_2.temp, pg1_2.device -> Sort Output: pg2_5."time", pg2_5.device, pg2_5.temp Sort Key: pg2_5.device -> Append -> Seq Scan on public.pg2dim_h2_t1 pg2_5 Output: pg2_5."time", pg2_5.device, pg2_5.temp -> Seq Scan on public.pg2dim_h2_t2 pg2_6 Output: pg2_6."time", pg2_6.device, pg2_6.temp (33 rows) -- Test hypertable with time partitioning function CREATE OR REPLACE FUNCTION time_func(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RETURN retval; END $BODY$; CREATE TABLE hyper_timepart (time float8, device int, temp float); SELECT * FROM create_hypertable('hyper_timepart', 'time', 'device', 2, time_partitioning_func => 'time_func'); NOTICE: adding not-null constraint to column "time" hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 3 | public | hyper_timepart | t (1 row) -- Planner won't pick push-down aggs on table with time function -- unless a certain amount of data SELECT setseed(1); setseed --------- (1 row) INSERT INTO hyper_timepart SELECT x, ceil(random() * 8), random() * 20 FROM generate_series(0,5000-1) AS x; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; QUERY PLAN ----------------------------------------------------------------------------------------------------------- Limit Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, (avg(_hyper_3_7_chunk.temp)) -> Sort Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, (avg(_hyper_3_7_chunk.temp)) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device -> HashAggregate Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, avg(_hyper_3_7_chunk.temp) Group Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device -> Append -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp (13 rows) :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------------------- Limit Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, (avg(_hyper_3_7_chunk.temp)) -> GroupAggregate Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, avg(_hyper_3_7_chunk.temp) Group Key: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device -> Incremental Sort Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp Sort Key: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device Presorted Key: (time_func(_hyper_3_7_chunk."time")) -> Result Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Merge Append Sort Key: (time_func(_hyper_3_7_chunk."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") (17 rows) -- Grouping on original time column should be pushed-down SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------ Limit Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, (avg(_hyper_3_7_chunk.temp)) -> Sort Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, (avg(_hyper_3_7_chunk.temp)) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device -> Finalize HashAggregate Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, avg(_hyper_3_7_chunk.temp) Group Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device -> Append -> Partial HashAggregate Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, PARTIAL avg(_hyper_3_7_chunk.temp) Group Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Partial HashAggregate Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, PARTIAL avg(_hyper_3_8_chunk.temp) Group Key: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp (19 rows) -- Applying the time partitioning function should also allow push-down -- on open dimensions :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------------------- Limit Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, (avg(_hyper_3_7_chunk.temp)) -> GroupAggregate Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, avg(_hyper_3_7_chunk.temp) Group Key: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device -> Incremental Sort Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp Sort Key: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device Presorted Key: (time_func(_hyper_3_7_chunk."time")) -> Result Output: (time_func(_hyper_3_7_chunk."time")), _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp -> Merge Append Sort Key: (time_func(_hyper_3_7_chunk."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") (17 rows) -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. :PREFIX SELECT time_func(time), _timescaledb_functions.get_partition_hash(device), avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------- Limit Output: (time_func(_hyper_3_7_chunk."time")), (_timescaledb_functions.get_partition_hash(_hyper_3_7_chunk.device)), (avg(_hyper_3_7_chunk.temp)) -> GroupAggregate Output: (time_func(_hyper_3_7_chunk."time")), (_timescaledb_functions.get_partition_hash(_hyper_3_7_chunk.device)), avg(_hyper_3_7_chunk.temp) Group Key: (time_func(_hyper_3_7_chunk."time")), (_timescaledb_functions.get_partition_hash(_hyper_3_7_chunk.device)) -> Incremental Sort Output: (time_func(_hyper_3_7_chunk."time")), (_timescaledb_functions.get_partition_hash(_hyper_3_7_chunk.device)), _hyper_3_7_chunk.temp Sort Key: (time_func(_hyper_3_7_chunk."time")), (_timescaledb_functions.get_partition_hash(_hyper_3_7_chunk.device)) Presorted Key: (time_func(_hyper_3_7_chunk."time")) -> Result Output: (time_func(_hyper_3_7_chunk."time")), _timescaledb_functions.get_partition_hash(_hyper_3_7_chunk.device), _hyper_3_7_chunk.temp -> Merge Append Sort Key: (time_func(_hyper_3_7_chunk."time")) -> Index Scan Backward using _hyper_3_7_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_7_chunk Output: _hyper_3_7_chunk."time", _hyper_3_7_chunk.device, _hyper_3_7_chunk.temp, time_func(_hyper_3_7_chunk."time") -> Index Scan Backward using _hyper_3_8_chunk_hyper_timepart_expr_idx on _timescaledb_internal._hyper_3_8_chunk Output: _hyper_3_8_chunk."time", _hyper_3_8_chunk.device, _hyper_3_8_chunk.temp, time_func(_hyper_3_8_chunk."time") (17 rows) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/pg_dump.out��������������������������������������������������������0000664�0000000�0000000�00000101672�15100345067�0021026�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_EXTRA :TEST_DBNAME _extra \o /dev/null \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION bgw_wait(database TEXT, timeout INT, raise_error BOOLEAN DEFAULT TRUE) RETURNS VOID AS :MODULE_PATHNAME, 'ts_bgw_wait' LANGUAGE C VOLATILE; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME ALTER TABLE PUBLIC."two_Partitions" SET SCHEMA "test_schema"; -- Test that we can restore constraints ALTER TABLE "test_schema"."two_Partitions" ADD CONSTRAINT timeCustom_device_id_series_2_key UNIQUE ("timeCustom", device_id, series_2); -- Test that we can restore triggers CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN RETURN NEW; END $BODY$; -- Test that a custom chunk sizing function is restored CREATE OR REPLACE FUNCTION custom_calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN -1; END $BODY$; SELECT * FROM set_adaptive_chunking('"test_schema"."two_Partitions"', '1 MB', 'custom_calculate_chunk_interval'); WARNING: target chunk size for adaptive chunking is less than 10 MB chunk_sizing_func | chunk_target_size ---------------------------------+------------------- custom_calculate_chunk_interval | 1048576 -- Chunk sizing func set SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+----------------+------------------------+-------------------------+----------------+--------------------------+---------------------------------+-------------------+-------------------+--------------------------+-------- 1 | test_schema | two_Partitions | _timescaledb_internal | _hyper_1 | 2 | public | custom_calculate_chunk_interval | 1048576 | 0 | | 0 SELECT proname, pronamespace, pronargs FROM pg_proc WHERE proname = 'custom_calculate_chunk_interval'; proname | pronamespace | pronargs ---------------------------------+--------------+---------- custom_calculate_chunk_interval | 2200 | 3 CREATE TRIGGER restore_trigger BEFORE INSERT ON "test_schema"."two_Partitions" FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- Save the number of dependent objects so we can make sure we have the same number later SELECT count(*) as num_dependent_objects FROM pg_depend WHERE refclassid = 'pg_extension'::regclass AND refobjid = (SELECT oid FROM pg_extension WHERE extname = 'timescaledb') \gset SELECT * FROM test.show_columns('"test_schema"."two_Partitions"'); Column | Type | NotNull -------------+------------------+--------- timeCustom | bigint | t device_id | text | t series_0 | double precision | f series_1 | double precision | f series_2 | double precision | f series_bool | boolean | f SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); Column | Type | NotNull -------------+------------------+--------- timeCustom | bigint | t device_id | text | t series_0 | double precision | f series_1 | double precision | f series_2 | double precision | f series_bool | boolean | f SELECT * FROM test.show_indexes('"test_schema"."two_Partitions"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------------------------------------------------+---------------------------------+------+--------+---------+-----------+------------ test_schema.timecustom_device_id_series_2_key | {timeCustom,device_id,series_2} | | t | f | f | test_schema."two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | test_schema."two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | test_schema."two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | test_schema."two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | test_schema."two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | test_schema."two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | test_schema."two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------------------------+---------------------------------+------+--------+---------+-----------+------------ _timescaledb_internal."1_1_timecustom_device_id_series_2_key" | {timeCustom,device_id,series_2} | | t | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | SELECT * FROM test.show_constraints('"test_schema"."two_Partitions"'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------+------+---------------------------------+-----------------------------------------------+------+------------+----------+----------- timecustom_device_id_series_2_key | u | {timeCustom,device_id,series_2} | test_schema.timecustom_device_id_series_2_key | | f | f | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_1_1_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ---------------------------------------+------+---------------------------------+---------------------------------------------------------------+------------------------------------------------------------------------------------------------------+------------+----------+----------- 1_1_timecustom_device_id_series_2_key | u | {timeCustom,device_id,series_2} | _timescaledb_internal."1_1_timecustom_device_id_series_2_key" | | f | f | t constraint_1 | c | {timeCustom} | - | (("timeCustom" >= '1257892416000000000'::bigint) AND ("timeCustom" < '1257895008000000000'::bigint)) | f | f | t constraint_2 | c | {device_id} | - | (_timescaledb_functions.get_partition_hash(device_id) >= 1073741823) | f | f | t SELECT * FROM test.show_triggers('"test_schema"."two_Partitions"'); Trigger | Type | Function -----------------+------+-------------- restore_trigger | 7 | test_trigger SELECT * FROM test.show_triggers('_timescaledb_internal._hyper_1_1_chunk'); Trigger | Type | Function -----------------+------+-------------- restore_trigger | 7 | test_trigger SELECT * FROM "test_schema"."two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | SELECT * FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f SELECT * FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257897600000000000 | dev1 | 4.5 | 5 | | f -- Show all constraints SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+---------------------------------------+----------------------------------- 1 | 1 | constraint_1 | 1 | 2 | constraint_2 | 2 | 3 | constraint_3 | 2 | 2 | constraint_2 | 3 | 4 | constraint_4 | 3 | 2 | constraint_2 | 4 | 1 | constraint_1 | 4 | 5 | constraint_5 | 1 | | 1_1_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key 2 | | 2_2_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key 3 | | 3_3_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key 4 | | 4_4_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key INSERT INTO _timescaledb_catalog.metadata VALUES ('exported_uuid', 'original_uuid', true); INSERT INTO _timescaledb_catalog.metadata VALUES ('metadata_test', 'FOO', false); \c postgres :ROLE_SUPERUSER -- We shell out to a script in order to grab the correct hostname from the -- environmental variables that originally called this psql command. Sadly -- vars passed to psql do not work in \! commands so we can't do it that way. \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; --create a exported uuid before restoring (mocks telemetry running before restore) INSERT INTO _timescaledb_catalog.metadata VALUES ('exported_uuid', 'new_db_uuid', true); -- disable background jobs UPDATE _timescaledb_config.bgw_job SET scheduled = false; RESET client_min_messages; SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t SHOW timescaledb.restoring; timescaledb.restoring ----------------------- on -- reconnect and check GUC value in new session \c SHOW timescaledb.restoring; timescaledb.restoring ----------------------- on \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql -- Now run our post-restore function. SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t SHOW timescaledb.restoring; timescaledb.restoring ----------------------- off -- timescaledb_post_restore restarts background worker so we have to stop them -- to make sure they dont interfere with this database being used as template below SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t --should be same as count above SELECT count(*) = :num_dependent_objects as dependent_objects_match FROM pg_depend WHERE refclassid = 'pg_extension'::regclass AND refobjid = (SELECT oid FROM pg_extension WHERE extname = 'timescaledb'); dependent_objects_match ------------------------- t --we should have the original uuid from the backed up db set as the exported_uuid SELECT value = 'original_uuid' FROM _timescaledb_catalog.metadata WHERE key='exported_uuid'; ?column? ---------- t SELECT count(*) = 1 FROM _timescaledb_catalog.metadata WHERE key LIKE 'exported%'; ?column? ---------- t --we should have the original value of metadata_test SELECT * FROM _timescaledb_catalog.metadata WHERE key='metadata_test'; key | value | include_in_telemetry ---------------+-------+---------------------- metadata_test | FOO | f --main table and chunk schemas should be the same SELECT * FROM test.show_columns('"test_schema"."two_Partitions"'); Column | Type | NotNull -------------+------------------+--------- timeCustom | bigint | t device_id | text | t series_0 | double precision | f series_1 | double precision | f series_2 | double precision | f series_bool | boolean | f SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); Column | Type | NotNull -------------+------------------+--------- timeCustom | bigint | t device_id | text | t series_0 | double precision | f series_1 | double precision | f series_2 | double precision | f series_bool | boolean | f SELECT * FROM test.show_indexes('"test_schema"."two_Partitions"'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------------------------------------------------+---------------------------------+------+--------+---------+-----------+------------ test_schema.timecustom_device_id_series_2_key | {timeCustom,device_id,series_2} | | t | f | f | test_schema."two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | test_schema."two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | test_schema."two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | test_schema."two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | test_schema."two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | test_schema."two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | test_schema."two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------------------------+---------------------------------+------+--------+---------+-----------+------------ _timescaledb_internal."1_1_timecustom_device_id_series_2_key" | {timeCustom,device_id,series_2} | | t | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_device_id_timeCustom_idx" | {device_id,timeCustom} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" | {timeCustom,device_id} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_idx" | {timeCustom} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_0_idx" | {timeCustom,series_0} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" | {timeCustom,series_1} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_2_idx" | {timeCustom,series_2} | | f | f | f | _timescaledb_internal."_hyper_1_1_chunk_two_Partitions_timeCustom_series_bool_idx" | {timeCustom,series_bool} | | f | f | f | SELECT * FROM test.show_constraints('"test_schema"."two_Partitions"'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------------------+------+---------------------------------+-----------------------------------------------+------+------------+----------+----------- timecustom_device_id_series_2_key | u | {timeCustom,device_id,series_2} | test_schema.timecustom_device_id_series_2_key | | f | f | t SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_1_1_chunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ---------------------------------------+------+---------------------------------+---------------------------------------------------------------+------------------------------------------------------------------------------------------------------+------------+----------+----------- 1_1_timecustom_device_id_series_2_key | u | {timeCustom,device_id,series_2} | _timescaledb_internal."1_1_timecustom_device_id_series_2_key" | | f | f | t constraint_1 | c | {timeCustom} | - | (("timeCustom" >= '1257892416000000000'::bigint) AND ("timeCustom" < '1257895008000000000'::bigint)) | f | f | t constraint_2 | c | {device_id} | - | (_timescaledb_functions.get_partition_hash(device_id) >= 1073741823) | f | f | t SELECT * FROM test.show_triggers('"test_schema"."two_Partitions"'); Trigger | Type | Function -----------------+------+-------------- restore_trigger | 7 | test_trigger SELECT * FROM test.show_triggers('_timescaledb_internal._hyper_1_1_chunk'); Trigger | Type | Function -----------------+------+-------------- restore_trigger | 7 | test_trigger --data should be the same SELECT * FROM "test_schema"."two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | SELECT * FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f SELECT * FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY "timeCustom", device_id, series_0, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257897600000000000 | dev1 | 4.5 | 5 | | f SELECT * FROM _timescaledb_catalog.chunk_constraint; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+---------------------------------------+----------------------------------- 1 | 1 | constraint_1 | 1 | 2 | constraint_2 | 2 | 3 | constraint_3 | 2 | 2 | constraint_2 | 3 | 4 | constraint_4 | 3 | 2 | constraint_2 | 4 | 1 | constraint_1 | 4 | 5 | constraint_5 | 1 | | 1_1_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key 2 | | 2_2_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key 3 | | 3_3_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key 4 | | 4_4_timecustom_device_id_series_2_key | timecustom_device_id_series_2_key --Chunk sizing function should have been restored SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+----------------+------------------------+-------------------------+----------------+--------------------------+---------------------------------+-------------------+-------------------+--------------------------+-------- 1 | test_schema | two_Partitions | _timescaledb_internal | _hyper_1 | 2 | public | custom_calculate_chunk_interval | 1048576 | 0 | | 0 SELECT proname, pronamespace, pronargs FROM pg_proc WHERE proname = 'custom_calculate_chunk_interval'; proname | pronamespace | pronargs ---------------------------------+--------------+---------- custom_calculate_chunk_interval | 2200 | 3 --check simple ddl still works ALTER TABLE "test_schema"."two_Partitions" ADD COLUMN series_3 integer; INSERT INTO "test_schema"."two_Partitions"("timeCustom", device_id, series_0, series_1, series_3) VALUES (1357894000000000000, 'dev5', 1.5, 2, 4); SELECT * FROM ONLY "test_schema"."two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool | series_3 ------------+-----------+----------+----------+----------+-------------+---------- --query for the extension tables/sequences that will not be dumped by pg_dump (should --be empty except for views and explicitly excluded tables) SELECT objid::regclass FROM pg_catalog.pg_depend WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass AND refobjid = (select oid from pg_extension where extname='timescaledb') AND deptype = 'e' AND classid='pg_catalog.pg_class'::pg_catalog.regclass AND objid NOT IN (select unnest(extconfig) from pg_extension where extname='timescaledb') ORDER BY objid::regclass::text COLLATE "C"; objid --------------------------------------------------------- _timescaledb_cache.cache_inval_bgw_job _timescaledb_cache.cache_inval_extension _timescaledb_cache.cache_inval_hypertable _timescaledb_catalog.compression_algorithm _timescaledb_catalog.tablespace_id_seq _timescaledb_catalog.telemetry_event _timescaledb_internal.bgw_job_stat _timescaledb_internal.bgw_job_stat_history _timescaledb_internal.bgw_job_stat_history_id_seq _timescaledb_internal.bgw_policy_chunk_stats _timescaledb_internal.compressed_chunk_stats _timescaledb_internal.hypertable_chunk_local_size timescaledb_experimental.policies timescaledb_information.chunk_columnstore_settings timescaledb_information.chunk_compression_settings timescaledb_information.chunks timescaledb_information.compression_settings timescaledb_information.continuous_aggregates timescaledb_information.dimensions timescaledb_information.hypertable_columnstore_settings timescaledb_information.hypertable_compression_settings timescaledb_information.hypertables timescaledb_information.job_errors timescaledb_information.job_history timescaledb_information.job_stats timescaledb_information.jobs -- Make sure we can't run our restoring functions as a normal perm user as that would disable functionality for the whole db \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Hides error messages in cases where error messages differ between Postgres versions create or replace function get_sqlstate(in_text TEXT) RETURNS TEXT AS $$ BEGIN BEGIN EXECUTE in_text; EXCEPTION WHEN others THEN GET STACKED DIAGNOSTICS in_text = RETURNED_SQLSTATE; END; RETURN in_text; END; $$ LANGUAGE PLPGSQL; SELECT get_sqlstate('SELECT timescaledb_pre_restore()'); get_sqlstate -------------- 42501 SELECT get_sqlstate('SELECT timescaledb_post_restore()'); get_sqlstate -------------- 42501 drop function get_sqlstate(TEXT); -- Check that the extension can be copied from an existing database -- without explicitly installing it. Stop background workers since we -- cannot have any backends connected to the database when cloning it. \c :TEST_DBNAME :ROLE_SUPERUSER SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t SELECT bgw_wait(:'TEST_DBNAME', 60, FALSE); bgw_wait ---------- -- Force other sessions connected to the TEST_DBNAME to be finished \c postgres :ROLE_SUPERUSER REVOKE CONNECT ON DATABASE :TEST_DBNAME FROM public; ALTER DATABASE :TEST_DBNAME allow_connections = off; SET client_min_messages TO ERROR; SELECT COUNT(pg_catalog.pg_terminate_backend(pid))>=0 FROM pg_stat_activity WHERE datname = ':TEST_DBNAME'; ?column? ---------- t RESET client_min_messages; CREATE DATABASE :TEST_DBNAME_EXTRA WITH TEMPLATE :TEST_DBNAME; ALTER DATABASE :TEST_DBNAME allow_connections = on; GRANT CONNECT ON DATABASE :TEST_DBNAME TO public; -- Connect to the database and do some basic stuff to check that the -- extension works. \c :TEST_DBNAME_EXTRA :ROLE_DEFAULT_PERM_USER CREATE TABLE test_tz(time timestamptz not null, temp float8, device text); SELECT create_hypertable('test_tz', 'time', 'device', 2); create_hypertable ---------------------- (2,public,test_tz,t) SELECT id, schema_name, table_name FROM _timescaledb_catalog.hypertable; id | schema_name | table_name ----+-------------+---------------- 1 | test_schema | two_Partitions 2 | public | test_tz INSERT INTO test_tz VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_tz VALUES('Mon Mar 20 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_tz ORDER BY time; time | temp | device -------------------------------------+------+-------- Mon Mar 20 09:17:00.936242 2017 PDT | 23.4 | dev1 Mon Mar 20 09:27:00.936242 2017 PDT | 22 | dev2 Mon Mar 20 09:28:00.936242 2017 PDT | 21.2 | dev1 Mon Mar 20 09:37:00.936242 2017 PDT | 30 | dev3 \c :TEST_DBNAME :ROLE_SUPERUSER -- make sure nobody is using it SET client_min_messages TO ERROR; REVOKE CONNECT ON DATABASE :TEST_DBNAME_EXTRA FROM public; SELECT count(pg_terminate_backend(pg_stat_activity.pid)) AS TERMINATED FROM pg_stat_activity WHERE pg_stat_activity.datname = :'TEST_DBNAME_EXTRA' AND pg_stat_activity.pid <> pg_backend_pid() \gset RESET client_min_messages; DROP DATABASE :TEST_DBNAME_EXTRA WITH (FORCE); ����������������������������������������������������������������������timescaledb-2.23.0/test/expected/pg_dump_unprivileged.out�������������������������������������������0000664�0000000�0000000�00000001756�15100345067�0023605�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c template1 :ROLE_SUPERUSER SET client_min_messages TO ERROR; CREATE EXTENSION IF NOT EXISTS timescaledb; RESET client_min_messages; CREATE USER dump_unprivileged CREATEDB; \c template1 dump_unprivileged CREATE database dump_unprivileged; \! utils/pg_dump_unprivileged.sh Database dumped successfully \c dump_unprivileged :ROLE_SUPERUSER DROP EXTENSION timescaledb; GRANT ALL ON DATABASE dump_unprivileged TO dump_unprivileged; \c dump_unprivileged dump_unprivileged -- Create the timescale extension and table as underprivileged user CREATE EXTENSION timescaledb; CREATE TABLE t1 (a int); -- pg_dump currently fails when dumped \! utils/pg_dump_unprivileged.sh Database dumped successfully \c template1 :ROLE_SUPERUSER DROP EXTENSION timescaledb; DROP DATABASE dump_unprivileged WITH (FORCE); DROP USER dump_unprivileged; ������������������timescaledb-2.23.0/test/expected/pg_join.out��������������������������������������������������������0000664�0000000�0000000�00000014253�15100345067�0021016�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- this test suite is based on the postgres join tests -- -- the tests have been adjusted to work with hypertables -- statements that would generate an error have been commented out -- because errors don't play nicely with psql output redirection -- plan output has been disabled, because we are not interested in -- the actual plans produced but in the correctness of the results -- we need superuser because some of the tests modify statistics \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME join SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset set client_min_messages to warning; \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- these table definitions have been adjusted from -- table defintions of the postgres test suite CREATE TABLE INT2_TBL(f1 int2, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('int2_tbl','ts'); table_name ------------ int2_tbl INSERT INTO INT2_TBL(f1) VALUES ('0 '); INSERT INTO INT2_TBL(f1) VALUES (' 1234 '); INSERT INTO INT2_TBL(f1) VALUES (' -1234'); -- largest and smallest values INSERT INTO INT2_TBL(f1) VALUES ('32767'); INSERT INTO INT2_TBL(f1) VALUES ('-32767'); CREATE TABLE INT4_TBL(f1 int4, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('int4_tbl','ts'); table_name ------------ int4_tbl INSERT INTO INT4_TBL(f1) VALUES (' 0 '); INSERT INTO INT4_TBL(f1) VALUES ('123456 '); INSERT INTO INT4_TBL(f1) VALUES (' -123456'); -- largest and smallest values INSERT INTO INT4_TBL(f1) VALUES ('2147483647'); INSERT INTO INT4_TBL(f1) VALUES ('-2147483647'); CREATE TABLE INT8_TBL(q1 int8, q2 int8, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('int8_tbl','ts'); table_name ------------ int8_tbl INSERT INTO INT8_TBL VALUES(' 123 ',' 456'); INSERT INTO INT8_TBL VALUES('123 ','4567890123456789'); INSERT INTO INT8_TBL VALUES('4567890123456789','123'); INSERT INTO INT8_TBL VALUES(+4567890123456789,'4567890123456789'); INSERT INTO INT8_TBL VALUES('+4567890123456789','-4567890123456789'); CREATE TABLE FLOAT8_TBL(f1 float8, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('float8_tbl','ts'); table_name ------------ float8_tbl INSERT INTO FLOAT8_TBL(f1) VALUES (' 0.0 '); INSERT INTO FLOAT8_TBL(f1) VALUES ('1004.30 '); INSERT INTO FLOAT8_TBL(f1) VALUES (' -34.84'); INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e+200'); INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e-200'); CREATE TABLE TEXT_TBL (f1 text, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('text_tbl','ts'); table_name ------------ text_tbl INSERT INTO TEXT_TBL VALUES ('doh!'); INSERT INTO TEXT_TBL VALUES ('hi de ho neighbor'); CREATE TABLE a (aa TEXT); CREATE TABLE b (bb TEXT) INHERITS (a); CREATE TABLE c (cc TEXT) INHERITS (a); CREATE TABLE d (dd TEXT) INHERITS (b,c,a); INSERT INTO a(aa) VALUES('aaa'); INSERT INTO a(aa) VALUES('aaaa'); INSERT INTO a(aa) VALUES('aaaaa'); INSERT INTO a(aa) VALUES('aaaaaa'); INSERT INTO a(aa) VALUES('aaaaaaa'); INSERT INTO a(aa) VALUES('aaaaaaaa'); INSERT INTO b(aa) VALUES('bbb'); INSERT INTO b(aa) VALUES('bbbb'); INSERT INTO b(aa) VALUES('bbbbb'); INSERT INTO b(aa) VALUES('bbbbbb'); INSERT INTO b(aa) VALUES('bbbbbbb'); INSERT INTO b(aa) VALUES('bbbbbbbb'); INSERT INTO c(aa) VALUES('ccc'); INSERT INTO c(aa) VALUES('cccc'); INSERT INTO c(aa) VALUES('ccccc'); INSERT INTO c(aa) VALUES('cccccc'); INSERT INTO c(aa) VALUES('ccccccc'); INSERT INTO c(aa) VALUES('cccccccc'); INSERT INTO d(aa) VALUES('ddd'); INSERT INTO d(aa) VALUES('dddd'); INSERT INTO d(aa) VALUES('ddddd'); INSERT INTO d(aa) VALUES('dddddd'); INSERT INTO d(aa) VALUES('ddddddd'); INSERT INTO d(aa) VALUES('dddddddd'); CREATE TABLE onek ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 name, stringu2 name, string4 name ); SELECT table_name FROM create_hypertable('onek','unique2',chunk_time_interval:=1000); table_name ------------ onek \copy onek FROM 'data/onek.data' CREATE TABLE tenk1 ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 name, stringu2 name, string4 name ); SELECT table_name FROM create_hypertable('tenk1','unique2',chunk_time_interval:=1000); table_name ------------ tenk1 \copy tenk1 FROM 'data/tenk.data' CREATE TABLE tenk2 ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 name, stringu2 name, string4 name ); SELECT table_name FROM create_hypertable('tenk2','unique2',chunk_time_interval:=1000); table_name ------------ tenk2 INSERT INTO tenk2 SELECT * FROM tenk1; \set PREFIX '' \set ECHO errors --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ setting | value ----------------------------------+------- - timescaledb.enable_optimizations | off + timescaledb.enable_optimizations | on table_name �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plain.out����������������������������������������������������������0000664�0000000�0000000�00000004677�15100345067�0020505�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Tests for plain PostgreSQL commands to ensure that they work while -- the TimescaleDB extension is loaded. This is a mix of statements -- added mostly as regression checks when bugs are discovered and -- fixed. CREATE TABLE regular_table(time timestamp, temp float8, tag text, color integer); -- Renaming indexes should work CREATE INDEX time_color_idx ON regular_table(time, color); ALTER INDEX time_color_idx RENAME TO time_color_idx2; ALTER TABLE regular_table ALTER COLUMN color TYPE bigint; SELECT * FROM test.show_columns('regular_table'); Column | Type | NotNull --------+-----------------------------+--------- time | timestamp without time zone | f temp | double precision | f tag | text | f color | bigint | f SELECT * FROM test.show_indexes('regular_table'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -----------------+--------------+------+--------+---------+-----------+------------ time_color_idx2 | {time,color} | | f | f | f | -- Renaming types should work CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple'); ALTER TYPE rainbow RENAME TO colors; \dT+ List of data types Schema | Name | Internal name | Size | Elements | Owner | Access privileges | Description --------+--------+---------------+------+----------+-------------------+-------------------+------------- public | colors | colors | 4 | red +| default_perm_user | | | | | | orange +| | | | | | | yellow +| | | | | | | green +| | | | | | | blue +| | | | | | | purple | | | REINDEX TABLE regular_table; \c :TEST_DBNAME :ROLE_SUPERUSER REINDEX SCHEMA public; -- Not only simple statements should work CREATE TABLE a (aa TEXT); CREATE TABLE z (b TEXT, PRIMARY KEY(aa, b)) inherits (a); �����������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_expand_hypertable-15.out��������������������������������������0000664�0000000�0000000�00000613320�15100345067�0024324�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_expand_hypertable_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --single time dimension CREATE TABLE hyper ("time_broken" bigint NOT NULL, "value" integer); ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper', 'time', chunk_time_interval => 10); create_hypertable -------------------- (1,public,hyper,t) INSERT INTO hyper SELECT g, g FROM generate_series(0,1000) g; --insert a point with INT_MAX_64 INSERT INTO hyper (time, value) SELECT 9223372036854775807::bigint, 0; --time and space CREATE TABLE hyper_w_space ("time_broken" bigint NOT NULL, "device_id" text, "value" integer); ALTER TABLE hyper_w_space DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper_w_space', 'time', 'device_id', 4, chunk_time_interval => 10); create_hypertable ---------------------------- (2,public,hyper_w_space,t) INSERT INTO hyper_w_space (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE VIEW hyper_w_space_view AS (SELECT * FROM hyper_w_space); --with timestamp and space CREATE TABLE tag (id serial PRIMARY KEY, name text); CREATE TABLE hyper_ts ("time_broken" timestamptz NOT NULL, "device_id" text, tag_id INT REFERENCES tag(id), "value" integer); ALTER TABLE hyper_ts DROP COLUMN time_broken, ADD COLUMN time TIMESTAMPTZ; SELECT create_hypertable('hyper_ts', 'time', 'device_id', 2, chunk_time_interval => '10 seconds'::interval); create_hypertable ----------------------- (3,public,hyper_ts,t) INSERT INTO tag(name) SELECT 'tag'||g FROM generate_series(0,10) g; INSERT INTO hyper_ts (time, device_id, tag_id, value) SELECT to_timestamp(g), 'dev' || g, (random() /10)+1, g FROM generate_series(0,30) g; --one in the future INSERT INTO hyper_ts (time, device_id, tag_id, value) VALUES ('2100-01-01 02:03:04 PST', 'dev101', 1, 0); --time partitioning function CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc ("time" float8 NOT NULL, "device_id" text, "value" integer); SELECT create_hypertable('hyper_timefunc', 'time', 'device_id', 4, chunk_time_interval => 10, time_partitioning_func => 'unix_to_timestamp'); psql:include/plan_expand_hypertable_load.sql:57: WARNING: unexpected interval: smaller than one second create_hypertable ----------------------------- (4,public,hyper_timefunc,t) INSERT INTO hyper_timefunc (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE TABLE metrics_timestamp(time timestamp); SELECT create_hypertable('metrics_timestamp','time'); psql:include/plan_expand_hypertable_load.sql:62: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'1d'::interval); CREATE TABLE metrics_timestamptz(time timestamptz, device_id int); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (6,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 3; --create a second table to test joins with CREATE TABLE metrics_timestamptz_2 (LIKE metrics_timestamptz); SELECT create_hypertable('metrics_timestamptz_2','time'); create_hypertable ------------------------------------ (7,public,metrics_timestamptz_2,t) INSERT INTO metrics_timestamptz_2 SELECT * FROM metrics_timestamptz; INSERT INTO metrics_timestamptz_2 VALUES ('2000-12-01'::timestamptz, 3); CREATE TABLE metrics_date(time date); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (8,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date,'2000-02-01'::date,'1d'::interval); ANALYZE hyper; ANALYZE hyper_w_space; ANALYZE tag; ANALYZE hyper_ts; ANALYZE hyper_timefunc; -- create normal table for JOIN tests CREATE TABLE regular_timestamptz(time timestamptz); INSERT INTO regular_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval); \ir include/plan_expand_hypertable_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --we want to see how our logic excludes chunks --and not how much work constraint_exclusion does SET constraint_exclusion = 'off'; \qecho test upper bounds test upper bounds :PREFIX SELECT * FROM hyper WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) :PREFIX SELECT * FROM hyper WHERE time < 11 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 11) -> Seq Scan on _hyper_1_2_chunk Filter: ("time" < 11) :PREFIX SELECT * FROM hyper WHERE time = 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = 10) :PREFIX SELECT * FROM hyper WHERE 10 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (10 >= "time") -> Seq Scan on _hyper_1_2_chunk Filter: (10 >= "time") \qecho test lower bounds test lower bounds :PREFIX SELECT * FROM hyper WHERE time >= 10 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 10) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE 10 < time and 20 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_2_chunk Filter: ((10 < "time") AND (20 >= "time")) -> Seq Scan on _hyper_1_3_chunk Filter: ((10 < "time") AND (20 >= "time")) :PREFIX SELECT * FROM hyper WHERE time >= 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 9) AND ("time" < 20)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 9) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE time > 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 9) AND ("time" < 20)) \qecho test empty result test empty result :PREFIX SELECT * FROM hyper WHERE time < 0; --- QUERY PLAN --- Result One-Time Filter: false \qecho test expression evaluation test expression evaluation :PREFIX SELECT * FROM hyper WHERE time < (5*2)::smallint; --- QUERY PLAN --- Seq Scan on _hyper_1_1_chunk Filter: ("time" < '10'::smallint) \qecho test logic at INT64_MAX test logic at INT64_MAX :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775806'::bigint) :PREFIX SELECT * FROM hyper WHERE time >= 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" >= '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" > '9223372036854775806'::bigint) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper WHERE time < 10 ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper WHERE time < 10); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho no space constraint no space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < 10) \qecho valid space constraint valid space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev'||(2+3) = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) \qecho only space constraint only space constraint :PREFIX SELECT * FROM hyper_w_space WHERE 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_106_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_109_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_111_chunk Filter: ('dev5'::text = device_id) \qecho unhandled space constraint unhandled space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id > 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) \qecho use of OR - does not filter chunks use of OR - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND (device_id = 'dev5' or device_id = 'dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper_w_space WHERE time < 10 and device_id = 'dev5'); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho view view :PREFIX SELECT * FROM hyper_w_space_view WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - simple IN statement - simple :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - two chunks IN statement - two chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho IN statement - one chunk IN statement - one chunk :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev4','dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev4,dev5}'::text[]))) \qecho NOT IN - does not filter chunks NOT IN - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id NOT IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) \qecho IN statement with subquery - does not filter chunks IN statement with subquery - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN (SELECT 'dev5'::text) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho ANY ANY :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho ANY with intersection ANY with intersection :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev6','dev7']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_105_chunk.value -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[])) AND (device_id = ANY ('{dev6,dev7}'::text[]))) \qecho ANY without intersection shouldnt scan any chunks ANY without intersection shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev8','dev9']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho ANY/IN/ALL only works for equals operator ANY/IN/ALL only works for equals operator :PREFIX SELECT * FROM hyper_w_space WHERE device_id < ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_104_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_105_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_106_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_107_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_108_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_109_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_110_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_111_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_112_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_113_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_114_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_115_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) \qecho ALL with equals and different values shouldnt scan any chunks ALL with equals and different values shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE device_id = ALL(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho Multi AND Multi AND :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND time < 100 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ("time" < 100)) \qecho Time dimension doesnt filter chunks when using IN/ANY with multiple arguments Time dimension doesnt filter chunks when using IN/ANY with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1,2]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_107_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_108_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_109_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_110_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_111_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_112_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_113_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_114_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_115_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) \qecho Time dimension chunk filtering works for ANY with single argument Time dimension chunk filtering works for ANY with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with single argument Time dimension chunk filtering works for ALL with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with multiple arguments Time dimension chunk filtering works for ALL with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1,10,20,30]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) \qecho AND intersection using IN and EQUALS AND intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_110_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_114_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) \qecho AND with no intersection using IN and EQUALS AND with no intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev3' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho timestamps timestamps \qecho these should work since they are immutable functions these should work since they are immutable functions :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969 PST'::timestamptz ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp AT TIME ZONE 'PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) \qecho these should not work since uses stable functions; these should not work since uses stable functions; :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < ('Wed Dec 31 16:00:10 1969'::timestamp::timestamptz) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE NOW() < time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 7 -> Seq Scan on _hyper_3_123_chunk Filter: (now() < "time") \qecho joins joins :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Semi Join -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text) AND (tag_id = 1)) -> Seq Scan on tag Filter: (id = 1) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) or (time < to_timestamp(10) and device_id = 'dev1') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts -> Seq Scan on _hyper_3_116_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) SubPlan 1 -> Seq Scan on tag Filter: (id = 1) -> Seq Scan on _hyper_3_117_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_118_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_119_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_120_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_121_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_122_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_123_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.name='tag1') and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (_hyper_3_116_chunk.tag_id = tag.id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Merge Join Merge Cond: (tag.id = _hyper_3_116_chunk.tag_id) -> Index Scan using tag_pkey on tag -> Sort Sort Key: _hyper_3_116_chunk.tag_id -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE tag.name = 'tag1' and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (_hyper_3_116_chunk.tag_id = tag.id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) \qecho test constraint exclusion for constraints in ON clause of JOINs test constraint exclusion for constraints in ON clause of JOINs \qecho should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho must not exclude on m1 must not exclude on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") Join Filter: (m1."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho should exclude chunks on m2 should exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m1 should exclude chunks on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho must not exclude chunks on m2 must not exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time, m2.time; --- QUERY PLAN --- Sort Sort Key: m1."time", m2."time" -> Merge Left Join Merge Cond: (m2."time" = m1."time") Join Filter: (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho time_bucket exclusion time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND (time_bucket('10'::bigint, "time") < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) \qecho timestamp time_bucket exclusion timestamp time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamp; count ------- 5 :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) >= '2000-01-15' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) \qecho timestamptz time_bucket exclusion timestamptz time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamptz; count ------- 5 :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) \qecho test overflow behaviour of time_bucket exclusion test overflow behaviour of time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time > 950 AND time_bucket(10, time) < '9223372036854775807'::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_96_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_97_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_98_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_99_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_100_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_101_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_102_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) \qecho test timestamp upper boundary test timestamp upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1000d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho test timestamptz upper boundary test timestamptz upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1000d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho time_bucket exclusion with run-time constants time_bucket exclusion with run-time constants -- These queries have a stable time_bucket expression, because the text::interval conversion is stable. PREPARE P1(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P2(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P3(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P4(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; -- These queries have an immutable time_bucket expression, because the parameter is passed as interval, and no conversion is involved. PREPARE P5(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P6(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P7(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P8(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; SET plan_cache_mode TO 'force_custom_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) SET plan_cache_mode TO 'force_generic_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) RESET plan_cache_mode; DEALLOCATE P1; DEALLOCATE P2; DEALLOCATE P3; DEALLOCATE P4; DEALLOCATE P5; DEALLOCATE P6; DEALLOCATE P7; DEALLOCATE P8; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 100 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 20 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 20)) :PREFIX SELECT * FROM hyper WHERE time_bucket(1, time) > 11 AND time_bucket(1, time) < 19 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 11) AND ("time" < '19'::bigint) AND (time_bucket('1'::bigint, "time") > 11) AND (time_bucket('1'::bigint, "time") < 19)) :PREFIX SELECT * FROM hyper WHERE 10 < time_bucket(10, time) AND 20 > time_bucket(10,time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (10 < time_bucket('10'::bigint, "time")) AND (20 > time_bucket('10'::bigint, "time"))) \qecho time_bucket exclusion with date time_bucket exclusion with date :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: ("time" < '01-03-2000'::date) Filter: (time_bucket('@ 1 day'::interval, "time") < '01-03-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date Order: metrics_date."time" -> Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) -> Index Only Scan Backward using _hyper_8_172_chunk_metrics_date_time_idx on _hyper_8_172_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) \qecho time_bucket exclusion with timestamp time_bucket exclusion with timestamp :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) \qecho time_bucket exclusion with timestamptz time_bucket exclusion with timestamptz :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Mon Jan 03 06:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 6 hours'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) >= '2000-01-03' AND time_bucket('6h',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho time_bucket exclusion with timestamptz and day interval time_bucket exclusion with timestamptz and day interval :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Tue Jan 04 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('7d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho no transformation no transformation :PREFIX SELECT * FROM hyper WHERE time_bucket(10 + floor(random())::int, time) > 10 AND time_bucket(10 + floor(random())::int, time) < 100 AND time < 150 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Custom Scan (ChunkAppend) on hyper Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_11_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_12_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_13_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_14_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_15_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) \qecho exclude chunks based on time column with partitioning function. This exclude chunks based on time column with partitioning function. This \qecho transparently applies the time partitioning function on the time transparently applies the time partitioning function on the time \qecho value to be able to exclude chunks (similar to a closed dimension). value to be able to exclude chunks (similar to a closed dimension). :PREFIX SELECT * FROM hyper_timefunc WHERE time < 4 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_125_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_126_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_127_chunk Filter: ("time" < '4'::double precision) \qecho excluding based on time expression is currently unoptimized excluding based on time expression is currently unoptimized :PREFIX SELECT * FROM hyper_timefunc WHERE unix_to_timestamp(time) < 'Wed Dec 31 16:00:04 1969 PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_125_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_126_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_127_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_128_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_129_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_130_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_131_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_132_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_133_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_134_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_135_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_136_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_137_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_138_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_139_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_140_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_141_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_142_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_143_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_144_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_145_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_146_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_147_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_148_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_149_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_150_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_151_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_152_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_153_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_154_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) \qecho test qual propagation for joins test qual propagation for joins RESET constraint_exclusion; \qecho nothing to propagate nothing to propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho OR constraints should not propagate OR constraints should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' OR m1.time > '2001-01-01' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho test single constraint test single constraint \qecho constraint should be on both scans constraint should be on both scans \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test 2 constraints on single relation test 2 constraints on single relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" = m1."time") :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test 2 constraints with 1 constraint on each relation test 2 constraints with 1 constraint on each relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of INNER JOIN test constraints in ON clause of INNER JOIN :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of LEFT JOIN test constraints in ON clause of LEFT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of RIGHT JOIN test constraints in ON clause of RIGHT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Gather Merge Workers Planned: 2 -> Sort Sort Key: m1."time" -> Parallel Hash Left Join Hash Cond: (m2."time" = m1."time") Join Filter: ((m2."time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Parallel Append -> Parallel Seq Scan on _hyper_7_165_chunk m2_1 -> Parallel Seq Scan on _hyper_7_166_chunk m2_2 -> Parallel Seq Scan on _hyper_7_167_chunk m2_3 -> Parallel Seq Scan on _hyper_7_168_chunk m2_4 -> Parallel Seq Scan on _hyper_7_169_chunk m2_5 -> Parallel Seq Scan on _hyper_7_170_chunk m2_6 -> Parallel Hash -> Parallel Append -> Parallel Seq Scan on _hyper_6_160_chunk m1_1 -> Parallel Seq Scan on _hyper_6_161_chunk m1_2 -> Parallel Seq Scan on _hyper_6_162_chunk m1_3 -> Parallel Seq Scan on _hyper_6_163_chunk m1_4 -> Parallel Seq Scan on _hyper_6_164_chunk m1_5 \qecho test equality condition not in ON clause test equality condition not in ON clause :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test constraints not joined on test constraints not joined on \qecho device_id constraint must not propagate device_id constraint must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test multiple join conditions test multiple join conditions \qecho device_id constraint should propagate device_id constraint should propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m1.device_id = m2.device_id AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) -> Index Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) \qecho test join with 3 tables test join with 3 tables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time INNER JOIN metrics_timestamptz m3 ON m2.time=m3.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m3_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m3_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m3_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m3_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m3_5 Index Cond: ("time" = m1."time") \qecho test non-Const constraints test non-Const constraints :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10'::text::timestamptz ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 3 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 4 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) \qecho test now() test now() :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < now() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < now()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < now()) \qecho test volatile function test volatile function \qecho should not propagate should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m2.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho test JOINs with normal table test JOINs with normal table \qecho will not propagate because constraints are only added to hypertables will not propagate because constraints are only added to hypertables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 \qecho test JOINs with normal table test JOINs with normal table :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 Filter: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test quals are not pushed into OUTER JOIN test quals are not pushed into OUTER JOIN CREATE TABLE outer_join_1 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE outer_join_2 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'time')) FROM (VALUES ('outer_join_1'),('outer_join_2')) v(tbl); table_name -------------- outer_join_1 outer_join_2 INSERT INTO outer_join_1 VALUES(1,'a'), (2,'b'); INSERT INTO outer_join_2 VALUES(1,'a'); :PREFIX SELECT one.id, two.name FROM outer_join_1 one LEFT OUTER JOIN outer_join_2 two ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join Join Filter: (one.id = two.id) -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) :PREFIX SELECT one.id, two.name FROM outer_join_2 two RIGHT OUTER JOIN outer_join_1 one ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join Join Filter: (one.id = two.id) -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) DROP TABLE outer_join_1; DROP TABLE outer_join_2; -- test UNION between regular table and hypertable SELECT time FROM regular_timestamptz UNION SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test UNION ALL between regular table and hypertable SELECT time FROM regular_timestamptz UNION ALL SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test nested join qual propagation :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON true WHERE o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id AND o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON true WHERE o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id AND o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id WHERE o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id WHERE o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) \set ECHO errors RESET timescaledb.enable_optimizations; CREATE TABLE t(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('t','time'); table_name ------------ t INSERT INTO t VALUES ('2000-01-01'), ('2010-01-01'), ('2020-01-01'); EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) SET timescaledb.enable_qual_propagation TO false; EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 -> Index Only Scan Backward using _hyper_15_184_chunk_t_time_idx on _hyper_15_184_chunk t2_3 RESET timescaledb.enable_qual_propagation; CREATE TABLE test (a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('public.test', 'time'); table_name ------------ test INSERT INTO test SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; CREATE OR REPLACE FUNCTION test_f(_ts timestamptz) RETURNS SETOF test LANGUAGE SQL STABLE PARALLEL SAFE AS $f$ SELECT DISTINCT ON (a) * FROM test WHERE time >= _ts ORDER BY a, time DESC $f$; EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 CREATE TABLE t1 (a int, b int NOT NULL); SELECT create_hypertable('t1', 'b', chunk_time_interval=>10); create_hypertable ------------------- (17,public,t1,t) CREATE TABLE t2 (a int, b int NOT NULL); SELECT create_hypertable('t2', 'b', chunk_time_interval=>10); create_hypertable ------------------- (18,public,t2,t) CREATE OR REPLACE FUNCTION f_t1(_a int, _b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (a) * FROM t1 WHERE a = _a and b = _b ORDER BY a, b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t2(_a int, _b int) RETURNS SETOF t2 LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) j.* FROM f_t1(_a, _b) sc, t2 j WHERE j.b = _b AND j.a = _a ORDER BY j.a, j.b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t1_2(_b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) jt.* FROM t1 j, f_t1(j.a, _b) jt $function$; EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10); --- QUERY PLAN --- Subquery Scan on f_t1_2 -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Unique -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10) sc, f_t2(sc.a, 10); --- QUERY PLAN --- Nested Loop -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Unique -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) -> Unique -> Nested Loop -> Unique -> Index Scan using t1_b_idx on t1 t1_1 Index Cond: (b = 10) Filter: (a = t1.a) -> Index Scan using t2_b_idx on t2 j_1 Index Cond: (b = 10) Filter: (a = t1.a) --TEST END-- ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_expand_hypertable-16.out��������������������������������������0000664�0000000�0000000�00000613210�15100345067�0024323�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_expand_hypertable_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --single time dimension CREATE TABLE hyper ("time_broken" bigint NOT NULL, "value" integer); ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper', 'time', chunk_time_interval => 10); create_hypertable -------------------- (1,public,hyper,t) INSERT INTO hyper SELECT g, g FROM generate_series(0,1000) g; --insert a point with INT_MAX_64 INSERT INTO hyper (time, value) SELECT 9223372036854775807::bigint, 0; --time and space CREATE TABLE hyper_w_space ("time_broken" bigint NOT NULL, "device_id" text, "value" integer); ALTER TABLE hyper_w_space DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper_w_space', 'time', 'device_id', 4, chunk_time_interval => 10); create_hypertable ---------------------------- (2,public,hyper_w_space,t) INSERT INTO hyper_w_space (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE VIEW hyper_w_space_view AS (SELECT * FROM hyper_w_space); --with timestamp and space CREATE TABLE tag (id serial PRIMARY KEY, name text); CREATE TABLE hyper_ts ("time_broken" timestamptz NOT NULL, "device_id" text, tag_id INT REFERENCES tag(id), "value" integer); ALTER TABLE hyper_ts DROP COLUMN time_broken, ADD COLUMN time TIMESTAMPTZ; SELECT create_hypertable('hyper_ts', 'time', 'device_id', 2, chunk_time_interval => '10 seconds'::interval); create_hypertable ----------------------- (3,public,hyper_ts,t) INSERT INTO tag(name) SELECT 'tag'||g FROM generate_series(0,10) g; INSERT INTO hyper_ts (time, device_id, tag_id, value) SELECT to_timestamp(g), 'dev' || g, (random() /10)+1, g FROM generate_series(0,30) g; --one in the future INSERT INTO hyper_ts (time, device_id, tag_id, value) VALUES ('2100-01-01 02:03:04 PST', 'dev101', 1, 0); --time partitioning function CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc ("time" float8 NOT NULL, "device_id" text, "value" integer); SELECT create_hypertable('hyper_timefunc', 'time', 'device_id', 4, chunk_time_interval => 10, time_partitioning_func => 'unix_to_timestamp'); psql:include/plan_expand_hypertable_load.sql:57: WARNING: unexpected interval: smaller than one second create_hypertable ----------------------------- (4,public,hyper_timefunc,t) INSERT INTO hyper_timefunc (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE TABLE metrics_timestamp(time timestamp); SELECT create_hypertable('metrics_timestamp','time'); psql:include/plan_expand_hypertable_load.sql:62: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'1d'::interval); CREATE TABLE metrics_timestamptz(time timestamptz, device_id int); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (6,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 3; --create a second table to test joins with CREATE TABLE metrics_timestamptz_2 (LIKE metrics_timestamptz); SELECT create_hypertable('metrics_timestamptz_2','time'); create_hypertable ------------------------------------ (7,public,metrics_timestamptz_2,t) INSERT INTO metrics_timestamptz_2 SELECT * FROM metrics_timestamptz; INSERT INTO metrics_timestamptz_2 VALUES ('2000-12-01'::timestamptz, 3); CREATE TABLE metrics_date(time date); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (8,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date,'2000-02-01'::date,'1d'::interval); ANALYZE hyper; ANALYZE hyper_w_space; ANALYZE tag; ANALYZE hyper_ts; ANALYZE hyper_timefunc; -- create normal table for JOIN tests CREATE TABLE regular_timestamptz(time timestamptz); INSERT INTO regular_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval); \ir include/plan_expand_hypertable_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --we want to see how our logic excludes chunks --and not how much work constraint_exclusion does SET constraint_exclusion = 'off'; \qecho test upper bounds test upper bounds :PREFIX SELECT * FROM hyper WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) :PREFIX SELECT * FROM hyper WHERE time < 11 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 11) -> Seq Scan on _hyper_1_2_chunk Filter: ("time" < 11) :PREFIX SELECT * FROM hyper WHERE time = 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = 10) :PREFIX SELECT * FROM hyper WHERE 10 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (10 >= "time") -> Seq Scan on _hyper_1_2_chunk Filter: (10 >= "time") \qecho test lower bounds test lower bounds :PREFIX SELECT * FROM hyper WHERE time >= 10 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 10) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE 10 < time and 20 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_2_chunk Filter: ((10 < "time") AND (20 >= "time")) -> Seq Scan on _hyper_1_3_chunk Filter: ((10 < "time") AND (20 >= "time")) :PREFIX SELECT * FROM hyper WHERE time >= 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 9) AND ("time" < 20)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 9) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE time > 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 9) AND ("time" < 20)) \qecho test empty result test empty result :PREFIX SELECT * FROM hyper WHERE time < 0; --- QUERY PLAN --- Result One-Time Filter: false \qecho test expression evaluation test expression evaluation :PREFIX SELECT * FROM hyper WHERE time < (5*2)::smallint; --- QUERY PLAN --- Seq Scan on _hyper_1_1_chunk Filter: ("time" < '10'::smallint) \qecho test logic at INT64_MAX test logic at INT64_MAX :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775806'::bigint) :PREFIX SELECT * FROM hyper WHERE time >= 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" >= '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" > '9223372036854775806'::bigint) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper WHERE time < 10 ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper WHERE time < 10); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho no space constraint no space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < 10) \qecho valid space constraint valid space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev'||(2+3) = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) \qecho only space constraint only space constraint :PREFIX SELECT * FROM hyper_w_space WHERE 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_106_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_109_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_111_chunk Filter: ('dev5'::text = device_id) \qecho unhandled space constraint unhandled space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id > 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) \qecho use of OR - does not filter chunks use of OR - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND (device_id = 'dev5' or device_id = 'dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper_w_space WHERE time < 10 and device_id = 'dev5'); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho view view :PREFIX SELECT * FROM hyper_w_space_view WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - simple IN statement - simple :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - two chunks IN statement - two chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho IN statement - one chunk IN statement - one chunk :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev4','dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev4,dev5}'::text[]))) \qecho NOT IN - does not filter chunks NOT IN - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id NOT IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) \qecho IN statement with subquery - does not filter chunks IN statement with subquery - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN (SELECT 'dev5'::text) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho ANY ANY :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho ANY with intersection ANY with intersection :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev6','dev7']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_105_chunk.value -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[])) AND (device_id = ANY ('{dev6,dev7}'::text[]))) \qecho ANY without intersection shouldnt scan any chunks ANY without intersection shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev8','dev9']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho ANY/IN/ALL only works for equals operator ANY/IN/ALL only works for equals operator :PREFIX SELECT * FROM hyper_w_space WHERE device_id < ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_104_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_105_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_106_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_107_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_108_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_109_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_110_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_111_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_112_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_113_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_114_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_115_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) \qecho ALL with equals and different values shouldnt scan any chunks ALL with equals and different values shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE device_id = ALL(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho Multi AND Multi AND :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND time < 100 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ("time" < 100)) \qecho Time dimension doesnt filter chunks when using IN/ANY with multiple arguments Time dimension doesnt filter chunks when using IN/ANY with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1,2]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_107_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_108_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_109_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_110_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_111_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_112_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_113_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_114_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_115_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) \qecho Time dimension chunk filtering works for ANY with single argument Time dimension chunk filtering works for ANY with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with single argument Time dimension chunk filtering works for ALL with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with multiple arguments Time dimension chunk filtering works for ALL with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1,10,20,30]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) \qecho AND intersection using IN and EQUALS AND intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_110_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_114_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) \qecho AND with no intersection using IN and EQUALS AND with no intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev3' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho timestamps timestamps \qecho these should work since they are immutable functions these should work since they are immutable functions :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969 PST'::timestamptz ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp AT TIME ZONE 'PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) \qecho these should not work since uses stable functions; these should not work since uses stable functions; :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < ('Wed Dec 31 16:00:10 1969'::timestamp::timestamptz) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE NOW() < time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 7 -> Seq Scan on _hyper_3_123_chunk Filter: (now() < "time") \qecho joins joins :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Semi Join -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text) AND (tag_id = 1)) -> Seq Scan on tag Filter: (id = 1) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) or (time < to_timestamp(10) and device_id = 'dev1') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts -> Seq Scan on _hyper_3_116_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) SubPlan 1 -> Seq Scan on tag Filter: (id = 1) -> Seq Scan on _hyper_3_117_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_118_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_119_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_120_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_121_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_122_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_123_chunk Filter: ((hashed SubPlan 1) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.name='tag1') and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (_hyper_3_116_chunk.tag_id = tag.id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Merge Join Merge Cond: (tag.id = _hyper_3_116_chunk.tag_id) -> Index Scan using tag_pkey on tag -> Sort Sort Key: _hyper_3_116_chunk.tag_id -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE tag.name = 'tag1' and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (tag.id = _hyper_3_116_chunk.tag_id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) \qecho test constraint exclusion for constraints in ON clause of JOINs test constraint exclusion for constraints in ON clause of JOINs \qecho should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho must not exclude on m1 must not exclude on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") Join Filter: (m1."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho should exclude chunks on m2 should exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m1 should exclude chunks on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho must not exclude chunks on m2 must not exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time, m2.time; --- QUERY PLAN --- Sort Sort Key: m1."time", m2."time" -> Merge Left Join Merge Cond: (m2."time" = m1."time") Join Filter: (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho time_bucket exclusion time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND (time_bucket('10'::bigint, "time") < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) \qecho timestamp time_bucket exclusion timestamp time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamp; count ------- 5 :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) >= '2000-01-15' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) \qecho timestamptz time_bucket exclusion timestamptz time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamptz; count ------- 5 :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) \qecho test overflow behaviour of time_bucket exclusion test overflow behaviour of time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time > 950 AND time_bucket(10, time) < '9223372036854775807'::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_96_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_97_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_98_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_99_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_100_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_101_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_102_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) \qecho test timestamp upper boundary test timestamp upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1000d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho test timestamptz upper boundary test timestamptz upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1000d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho time_bucket exclusion with run-time constants time_bucket exclusion with run-time constants -- These queries have a stable time_bucket expression, because the text::interval conversion is stable. PREPARE P1(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P2(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P3(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P4(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; -- These queries have an immutable time_bucket expression, because the parameter is passed as interval, and no conversion is involved. PREPARE P5(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P6(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P7(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P8(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; SET plan_cache_mode TO 'force_custom_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) SET plan_cache_mode TO 'force_generic_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) RESET plan_cache_mode; DEALLOCATE P1; DEALLOCATE P2; DEALLOCATE P3; DEALLOCATE P4; DEALLOCATE P5; DEALLOCATE P6; DEALLOCATE P7; DEALLOCATE P8; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 100 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 20 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 20)) :PREFIX SELECT * FROM hyper WHERE time_bucket(1, time) > 11 AND time_bucket(1, time) < 19 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 11) AND ("time" < '19'::bigint) AND (time_bucket('1'::bigint, "time") > 11) AND (time_bucket('1'::bigint, "time") < 19)) :PREFIX SELECT * FROM hyper WHERE 10 < time_bucket(10, time) AND 20 > time_bucket(10,time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (10 < time_bucket('10'::bigint, "time")) AND (20 > time_bucket('10'::bigint, "time"))) \qecho time_bucket exclusion with date time_bucket exclusion with date :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: ("time" < '01-03-2000'::date) Filter: (time_bucket('@ 1 day'::interval, "time") < '01-03-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date Order: metrics_date."time" -> Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) -> Index Only Scan Backward using _hyper_8_172_chunk_metrics_date_time_idx on _hyper_8_172_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) \qecho time_bucket exclusion with timestamp time_bucket exclusion with timestamp :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) \qecho time_bucket exclusion with timestamptz time_bucket exclusion with timestamptz :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Mon Jan 03 06:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 6 hours'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) >= '2000-01-03' AND time_bucket('6h',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho time_bucket exclusion with timestamptz and day interval time_bucket exclusion with timestamptz and day interval :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Tue Jan 04 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('7d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho no transformation no transformation :PREFIX SELECT * FROM hyper WHERE time_bucket(10 + floor(random())::int, time) > 10 AND time_bucket(10 + floor(random())::int, time) < 100 AND time < 150 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Custom Scan (ChunkAppend) on hyper Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_11_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_12_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_13_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_14_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_15_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) \qecho exclude chunks based on time column with partitioning function. This exclude chunks based on time column with partitioning function. This \qecho transparently applies the time partitioning function on the time transparently applies the time partitioning function on the time \qecho value to be able to exclude chunks (similar to a closed dimension). value to be able to exclude chunks (similar to a closed dimension). :PREFIX SELECT * FROM hyper_timefunc WHERE time < 4 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_125_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_126_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_127_chunk Filter: ("time" < '4'::double precision) \qecho excluding based on time expression is currently unoptimized excluding based on time expression is currently unoptimized :PREFIX SELECT * FROM hyper_timefunc WHERE unix_to_timestamp(time) < 'Wed Dec 31 16:00:04 1969 PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_125_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_126_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_127_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_128_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_129_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_130_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_131_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_132_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_133_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_134_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_135_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_136_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_137_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_138_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_139_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_140_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_141_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_142_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_143_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_144_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_145_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_146_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_147_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_148_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_149_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_150_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_151_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_152_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_153_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_154_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) \qecho test qual propagation for joins test qual propagation for joins RESET constraint_exclusion; \qecho nothing to propagate nothing to propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho OR constraints should not propagate OR constraints should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' OR m1.time > '2001-01-01' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho test single constraint test single constraint \qecho constraint should be on both scans constraint should be on both scans \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test 2 constraints on single relation test 2 constraints on single relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" = m1."time") :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test 2 constraints with 1 constraint on each relation test 2 constraints with 1 constraint on each relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of INNER JOIN test constraints in ON clause of INNER JOIN :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of LEFT JOIN test constraints in ON clause of LEFT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of RIGHT JOIN test constraints in ON clause of RIGHT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Gather Merge Workers Planned: 2 -> Sort Sort Key: m1."time" -> Parallel Hash Left Join Hash Cond: (m2."time" = m1."time") Join Filter: ((m2."time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Parallel Append -> Parallel Seq Scan on _hyper_7_165_chunk m2_1 -> Parallel Seq Scan on _hyper_7_166_chunk m2_2 -> Parallel Seq Scan on _hyper_7_167_chunk m2_3 -> Parallel Seq Scan on _hyper_7_168_chunk m2_4 -> Parallel Seq Scan on _hyper_7_169_chunk m2_5 -> Parallel Seq Scan on _hyper_7_170_chunk m2_6 -> Parallel Hash -> Parallel Append -> Parallel Seq Scan on _hyper_6_160_chunk m1_1 -> Parallel Seq Scan on _hyper_6_161_chunk m1_2 -> Parallel Seq Scan on _hyper_6_162_chunk m1_3 -> Parallel Seq Scan on _hyper_6_163_chunk m1_4 -> Parallel Seq Scan on _hyper_6_164_chunk m1_5 \qecho test equality condition not in ON clause test equality condition not in ON clause :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test constraints not joined on test constraints not joined on \qecho device_id constraint must not propagate device_id constraint must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test multiple join conditions test multiple join conditions \qecho device_id constraint should propagate device_id constraint should propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m1.device_id = m2.device_id AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) -> Index Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) \qecho test join with 3 tables test join with 3 tables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time INNER JOIN metrics_timestamptz m3 ON m2.time=m3.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m3_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m3_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m3_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m3_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m3_5 Index Cond: ("time" = m1."time") \qecho test non-Const constraints test non-Const constraints :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10'::text::timestamptz ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 3 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 4 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) \qecho test now() test now() :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < now() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < now()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < now()) \qecho test volatile function test volatile function \qecho should not propagate should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m2.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho test JOINs with normal table test JOINs with normal table \qecho will not propagate because constraints are only added to hypertables will not propagate because constraints are only added to hypertables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 \qecho test JOINs with normal table test JOINs with normal table :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 Filter: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test quals are not pushed into OUTER JOIN test quals are not pushed into OUTER JOIN CREATE TABLE outer_join_1 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE outer_join_2 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'time')) FROM (VALUES ('outer_join_1'),('outer_join_2')) v(tbl); table_name -------------- outer_join_1 outer_join_2 INSERT INTO outer_join_1 VALUES(1,'a'), (2,'b'); INSERT INTO outer_join_2 VALUES(1,'a'); :PREFIX SELECT one.id, two.name FROM outer_join_1 one LEFT OUTER JOIN outer_join_2 two ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) :PREFIX SELECT one.id, two.name FROM outer_join_2 two RIGHT OUTER JOIN outer_join_1 one ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) DROP TABLE outer_join_1; DROP TABLE outer_join_2; -- test UNION between regular table and hypertable SELECT time FROM regular_timestamptz UNION SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test UNION ALL between regular table and hypertable SELECT time FROM regular_timestamptz UNION ALL SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test nested join qual propagation :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON true WHERE o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id AND o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON true WHERE o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id AND o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id WHERE o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id WHERE o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) \set ECHO errors RESET timescaledb.enable_optimizations; CREATE TABLE t(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('t','time'); table_name ------------ t INSERT INTO t VALUES ('2000-01-01'), ('2010-01-01'), ('2020-01-01'); EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) SET timescaledb.enable_qual_propagation TO false; EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 -> Index Only Scan Backward using _hyper_15_184_chunk_t_time_idx on _hyper_15_184_chunk t2_3 RESET timescaledb.enable_qual_propagation; CREATE TABLE test (a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('public.test', 'time'); table_name ------------ test INSERT INTO test SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; CREATE OR REPLACE FUNCTION test_f(_ts timestamptz) RETURNS SETOF test LANGUAGE SQL STABLE PARALLEL SAFE AS $f$ SELECT DISTINCT ON (a) * FROM test WHERE time >= _ts ORDER BY a, time DESC $f$; EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 CREATE TABLE t1 (a int, b int NOT NULL); SELECT create_hypertable('t1', 'b', chunk_time_interval=>10); create_hypertable ------------------- (17,public,t1,t) CREATE TABLE t2 (a int, b int NOT NULL); SELECT create_hypertable('t2', 'b', chunk_time_interval=>10); create_hypertable ------------------- (18,public,t2,t) CREATE OR REPLACE FUNCTION f_t1(_a int, _b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (a) * FROM t1 WHERE a = _a and b = _b ORDER BY a, b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t2(_a int, _b int) RETURNS SETOF t2 LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) j.* FROM f_t1(_a, _b) sc, t2 j WHERE j.b = _b AND j.a = _a ORDER BY j.a, j.b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t1_2(_b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) jt.* FROM t1 j, f_t1(j.a, _b) jt $function$; EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10); --- QUERY PLAN --- Subquery Scan on f_t1_2 -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Limit -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10) sc, f_t2(sc.a, 10); --- QUERY PLAN --- Nested Loop -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Limit -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) -> Limit -> Nested Loop -> Limit -> Index Scan using t1_b_idx on t1 t1_1 Index Cond: (b = 10) Filter: (a = t1.a) -> Index Scan using t2_b_idx on t2 j_1 Index Cond: (b = 10) Filter: (a = t1.a) --TEST END-- ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_expand_hypertable-17.out��������������������������������������0000664�0000000�0000000�00000613470�15100345067�0024334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_expand_hypertable_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --single time dimension CREATE TABLE hyper ("time_broken" bigint NOT NULL, "value" integer); ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper', 'time', chunk_time_interval => 10); create_hypertable -------------------- (1,public,hyper,t) INSERT INTO hyper SELECT g, g FROM generate_series(0,1000) g; --insert a point with INT_MAX_64 INSERT INTO hyper (time, value) SELECT 9223372036854775807::bigint, 0; --time and space CREATE TABLE hyper_w_space ("time_broken" bigint NOT NULL, "device_id" text, "value" integer); ALTER TABLE hyper_w_space DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper_w_space', 'time', 'device_id', 4, chunk_time_interval => 10); create_hypertable ---------------------------- (2,public,hyper_w_space,t) INSERT INTO hyper_w_space (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE VIEW hyper_w_space_view AS (SELECT * FROM hyper_w_space); --with timestamp and space CREATE TABLE tag (id serial PRIMARY KEY, name text); CREATE TABLE hyper_ts ("time_broken" timestamptz NOT NULL, "device_id" text, tag_id INT REFERENCES tag(id), "value" integer); ALTER TABLE hyper_ts DROP COLUMN time_broken, ADD COLUMN time TIMESTAMPTZ; SELECT create_hypertable('hyper_ts', 'time', 'device_id', 2, chunk_time_interval => '10 seconds'::interval); create_hypertable ----------------------- (3,public,hyper_ts,t) INSERT INTO tag(name) SELECT 'tag'||g FROM generate_series(0,10) g; INSERT INTO hyper_ts (time, device_id, tag_id, value) SELECT to_timestamp(g), 'dev' || g, (random() /10)+1, g FROM generate_series(0,30) g; --one in the future INSERT INTO hyper_ts (time, device_id, tag_id, value) VALUES ('2100-01-01 02:03:04 PST', 'dev101', 1, 0); --time partitioning function CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc ("time" float8 NOT NULL, "device_id" text, "value" integer); SELECT create_hypertable('hyper_timefunc', 'time', 'device_id', 4, chunk_time_interval => 10, time_partitioning_func => 'unix_to_timestamp'); psql:include/plan_expand_hypertable_load.sql:57: WARNING: unexpected interval: smaller than one second create_hypertable ----------------------------- (4,public,hyper_timefunc,t) INSERT INTO hyper_timefunc (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE TABLE metrics_timestamp(time timestamp); SELECT create_hypertable('metrics_timestamp','time'); psql:include/plan_expand_hypertable_load.sql:62: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'1d'::interval); CREATE TABLE metrics_timestamptz(time timestamptz, device_id int); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (6,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 3; --create a second table to test joins with CREATE TABLE metrics_timestamptz_2 (LIKE metrics_timestamptz); SELECT create_hypertable('metrics_timestamptz_2','time'); create_hypertable ------------------------------------ (7,public,metrics_timestamptz_2,t) INSERT INTO metrics_timestamptz_2 SELECT * FROM metrics_timestamptz; INSERT INTO metrics_timestamptz_2 VALUES ('2000-12-01'::timestamptz, 3); CREATE TABLE metrics_date(time date); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (8,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date,'2000-02-01'::date,'1d'::interval); ANALYZE hyper; ANALYZE hyper_w_space; ANALYZE tag; ANALYZE hyper_ts; ANALYZE hyper_timefunc; -- create normal table for JOIN tests CREATE TABLE regular_timestamptz(time timestamptz); INSERT INTO regular_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval); \ir include/plan_expand_hypertable_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --we want to see how our logic excludes chunks --and not how much work constraint_exclusion does SET constraint_exclusion = 'off'; \qecho test upper bounds test upper bounds :PREFIX SELECT * FROM hyper WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) :PREFIX SELECT * FROM hyper WHERE time < 11 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 11) -> Seq Scan on _hyper_1_2_chunk Filter: ("time" < 11) :PREFIX SELECT * FROM hyper WHERE time = 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = 10) :PREFIX SELECT * FROM hyper WHERE 10 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (10 >= "time") -> Seq Scan on _hyper_1_2_chunk Filter: (10 >= "time") \qecho test lower bounds test lower bounds :PREFIX SELECT * FROM hyper WHERE time >= 10 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 10) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE 10 < time and 20 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_2_chunk Filter: ((10 < "time") AND (20 >= "time")) -> Seq Scan on _hyper_1_3_chunk Filter: ((10 < "time") AND (20 >= "time")) :PREFIX SELECT * FROM hyper WHERE time >= 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 9) AND ("time" < 20)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 9) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE time > 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 9) AND ("time" < 20)) \qecho test empty result test empty result :PREFIX SELECT * FROM hyper WHERE time < 0; --- QUERY PLAN --- Result One-Time Filter: false \qecho test expression evaluation test expression evaluation :PREFIX SELECT * FROM hyper WHERE time < (5*2)::smallint; --- QUERY PLAN --- Seq Scan on _hyper_1_1_chunk Filter: ("time" < '10'::smallint) \qecho test logic at INT64_MAX test logic at INT64_MAX :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775806'::bigint) :PREFIX SELECT * FROM hyper WHERE time >= 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" >= '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" > '9223372036854775806'::bigint) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper WHERE time < 10 ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper WHERE time < 10); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho no space constraint no space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < 10) \qecho valid space constraint valid space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev'||(2+3) = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) \qecho only space constraint only space constraint :PREFIX SELECT * FROM hyper_w_space WHERE 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_106_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_109_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_111_chunk Filter: ('dev5'::text = device_id) \qecho unhandled space constraint unhandled space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id > 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) \qecho use of OR - does not filter chunks use of OR - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND (device_id = 'dev5' or device_id = 'dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper_w_space WHERE time < 10 and device_id = 'dev5'); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho view view :PREFIX SELECT * FROM hyper_w_space_view WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - simple IN statement - simple :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - two chunks IN statement - two chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho IN statement - one chunk IN statement - one chunk :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev4','dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev4,dev5}'::text[]))) \qecho NOT IN - does not filter chunks NOT IN - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id NOT IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) \qecho IN statement with subquery - does not filter chunks IN statement with subquery - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN (SELECT 'dev5'::text) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho ANY ANY :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho ANY with intersection ANY with intersection :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev6','dev7']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_105_chunk.value -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[])) AND (device_id = ANY ('{dev6,dev7}'::text[]))) \qecho ANY without intersection shouldnt scan any chunks ANY without intersection shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev8','dev9']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho ANY/IN/ALL only works for equals operator ANY/IN/ALL only works for equals operator :PREFIX SELECT * FROM hyper_w_space WHERE device_id < ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_104_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_105_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_106_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_107_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_108_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_109_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_110_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_111_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_112_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_113_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_114_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_115_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) \qecho ALL with equals and different values shouldnt scan any chunks ALL with equals and different values shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE device_id = ALL(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho Multi AND Multi AND :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND time < 100 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ("time" < 100)) \qecho Time dimension doesnt filter chunks when using IN/ANY with multiple arguments Time dimension doesnt filter chunks when using IN/ANY with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1,2]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_107_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_108_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_109_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_110_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_111_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_112_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_113_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_114_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_115_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) \qecho Time dimension chunk filtering works for ANY with single argument Time dimension chunk filtering works for ANY with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with single argument Time dimension chunk filtering works for ALL with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with multiple arguments Time dimension chunk filtering works for ALL with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1,10,20,30]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) \qecho AND intersection using IN and EQUALS AND intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_110_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_114_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) \qecho AND with no intersection using IN and EQUALS AND with no intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev3' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho timestamps timestamps \qecho these should work since they are immutable functions these should work since they are immutable functions :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969 PST'::timestamptz ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp AT TIME ZONE 'PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) \qecho these should not work since uses stable functions; these should not work since uses stable functions; :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < ('Wed Dec 31 16:00:10 1969'::timestamp::timestamptz) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE NOW() < time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 7 -> Seq Scan on _hyper_3_123_chunk Filter: (now() < "time") \qecho joins joins :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Semi Join -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text) AND (tag_id = 1)) -> Seq Scan on tag Filter: (id = 1) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) or (time < to_timestamp(10) and device_id = 'dev1') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts -> Seq Scan on _hyper_3_116_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) SubPlan 1 -> Seq Scan on tag Filter: (id = 1) -> Seq Scan on _hyper_3_117_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_118_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_119_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_120_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_121_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_122_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_123_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.name='tag1') and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (_hyper_3_116_chunk.tag_id = tag.id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Merge Join Merge Cond: (tag.id = _hyper_3_116_chunk.tag_id) -> Index Scan using tag_pkey on tag -> Sort Sort Key: _hyper_3_116_chunk.tag_id -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE tag.name = 'tag1' and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (tag.id = _hyper_3_116_chunk.tag_id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) \qecho test constraint exclusion for constraints in ON clause of JOINs test constraint exclusion for constraints in ON clause of JOINs \qecho should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho must not exclude on m1 must not exclude on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") Join Filter: (m1."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho should exclude chunks on m2 should exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m1 should exclude chunks on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho must not exclude chunks on m2 must not exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time, m2.time; --- QUERY PLAN --- Sort Sort Key: m1."time", m2."time" -> Merge Left Join Merge Cond: (m2."time" = m1."time") Join Filter: (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho time_bucket exclusion time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND (time_bucket('10'::bigint, "time") < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) \qecho timestamp time_bucket exclusion timestamp time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamp; count ------- 5 :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) >= '2000-01-15' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) \qecho timestamptz time_bucket exclusion timestamptz time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamptz; count ------- 5 :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) \qecho test overflow behaviour of time_bucket exclusion test overflow behaviour of time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time > 950 AND time_bucket(10, time) < '9223372036854775807'::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_96_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_97_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_98_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_99_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_100_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_101_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_102_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) \qecho test timestamp upper boundary test timestamp upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1000d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho test timestamptz upper boundary test timestamptz upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1000d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho time_bucket exclusion with run-time constants time_bucket exclusion with run-time constants -- These queries have a stable time_bucket expression, because the text::interval conversion is stable. PREPARE P1(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P2(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P3(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P4(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; -- These queries have an immutable time_bucket expression, because the parameter is passed as interval, and no conversion is involved. PREPARE P5(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P6(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P7(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P8(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; SET plan_cache_mode TO 'force_custom_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) SET plan_cache_mode TO 'force_generic_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) RESET plan_cache_mode; DEALLOCATE P1; DEALLOCATE P2; DEALLOCATE P3; DEALLOCATE P4; DEALLOCATE P5; DEALLOCATE P6; DEALLOCATE P7; DEALLOCATE P8; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 100 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 20 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 20)) :PREFIX SELECT * FROM hyper WHERE time_bucket(1, time) > 11 AND time_bucket(1, time) < 19 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 11) AND ("time" < '19'::bigint) AND (time_bucket('1'::bigint, "time") > 11) AND (time_bucket('1'::bigint, "time") < 19)) :PREFIX SELECT * FROM hyper WHERE 10 < time_bucket(10, time) AND 20 > time_bucket(10,time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (10 < time_bucket('10'::bigint, "time")) AND (20 > time_bucket('10'::bigint, "time"))) \qecho time_bucket exclusion with date time_bucket exclusion with date :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: ("time" < '01-03-2000'::date) Filter: (time_bucket('@ 1 day'::interval, "time") < '01-03-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date Order: metrics_date."time" -> Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) -> Index Only Scan Backward using _hyper_8_172_chunk_metrics_date_time_idx on _hyper_8_172_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) \qecho time_bucket exclusion with timestamp time_bucket exclusion with timestamp :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) \qecho time_bucket exclusion with timestamptz time_bucket exclusion with timestamptz :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Mon Jan 03 06:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 6 hours'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) >= '2000-01-03' AND time_bucket('6h',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho time_bucket exclusion with timestamptz and day interval time_bucket exclusion with timestamptz and day interval :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Tue Jan 04 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('7d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho no transformation no transformation :PREFIX SELECT * FROM hyper WHERE time_bucket(10 + floor(random())::int, time) > 10 AND time_bucket(10 + floor(random())::int, time) < 100 AND time < 150 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Custom Scan (ChunkAppend) on hyper Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_11_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_12_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_13_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_14_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_15_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) \qecho exclude chunks based on time column with partitioning function. This exclude chunks based on time column with partitioning function. This \qecho transparently applies the time partitioning function on the time transparently applies the time partitioning function on the time \qecho value to be able to exclude chunks (similar to a closed dimension). value to be able to exclude chunks (similar to a closed dimension). :PREFIX SELECT * FROM hyper_timefunc WHERE time < 4 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_125_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_126_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_127_chunk Filter: ("time" < '4'::double precision) \qecho excluding based on time expression is currently unoptimized excluding based on time expression is currently unoptimized :PREFIX SELECT * FROM hyper_timefunc WHERE unix_to_timestamp(time) < 'Wed Dec 31 16:00:04 1969 PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_125_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_126_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_127_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_128_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_129_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_130_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_131_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_132_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_133_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_134_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_135_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_136_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_137_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_138_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_139_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_140_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_141_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_142_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_143_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_144_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_145_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_146_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_147_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_148_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_149_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_150_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_151_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_152_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_153_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_154_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) \qecho test qual propagation for joins test qual propagation for joins RESET constraint_exclusion; \qecho nothing to propagate nothing to propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho OR constraints should not propagate OR constraints should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' OR m1.time > '2001-01-01' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho test single constraint test single constraint \qecho constraint should be on both scans constraint should be on both scans \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test 2 constraints on single relation test 2 constraints on single relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" = m1."time") :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test 2 constraints with 1 constraint on each relation test 2 constraints with 1 constraint on each relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of INNER JOIN test constraints in ON clause of INNER JOIN :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of LEFT JOIN test constraints in ON clause of LEFT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of RIGHT JOIN test constraints in ON clause of RIGHT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Gather Merge Workers Planned: 2 -> Sort Sort Key: m1."time" -> Parallel Hash Left Join Hash Cond: (m2."time" = m1."time") Join Filter: ((m2."time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Parallel Append -> Parallel Seq Scan on _hyper_7_165_chunk m2_1 -> Parallel Seq Scan on _hyper_7_166_chunk m2_2 -> Parallel Seq Scan on _hyper_7_167_chunk m2_3 -> Parallel Seq Scan on _hyper_7_168_chunk m2_4 -> Parallel Seq Scan on _hyper_7_169_chunk m2_5 -> Parallel Seq Scan on _hyper_7_170_chunk m2_6 -> Parallel Hash -> Parallel Append -> Parallel Seq Scan on _hyper_6_160_chunk m1_1 -> Parallel Seq Scan on _hyper_6_161_chunk m1_2 -> Parallel Seq Scan on _hyper_6_162_chunk m1_3 -> Parallel Seq Scan on _hyper_6_163_chunk m1_4 -> Parallel Seq Scan on _hyper_6_164_chunk m1_5 \qecho test equality condition not in ON clause test equality condition not in ON clause :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test constraints not joined on test constraints not joined on \qecho device_id constraint must not propagate device_id constraint must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test multiple join conditions test multiple join conditions \qecho device_id constraint should propagate device_id constraint should propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m1.device_id = m2.device_id AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) -> Index Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) \qecho test join with 3 tables test join with 3 tables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time INNER JOIN metrics_timestamptz m3 ON m2.time=m3.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m3_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m3_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m3_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m3_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m3_5 Index Cond: ("time" = m1."time") \qecho test non-Const constraints test non-Const constraints :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10'::text::timestamptz ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 3 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 4 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) \qecho test now() test now() :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < now() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < now()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < now()) \qecho test volatile function test volatile function \qecho should not propagate should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m2.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho test JOINs with normal table test JOINs with normal table \qecho will not propagate because constraints are only added to hypertables will not propagate because constraints are only added to hypertables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 \qecho test JOINs with normal table test JOINs with normal table :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 Filter: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test quals are not pushed into OUTER JOIN test quals are not pushed into OUTER JOIN CREATE TABLE outer_join_1 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE outer_join_2 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'time')) FROM (VALUES ('outer_join_1'),('outer_join_2')) v(tbl); table_name -------------- outer_join_1 outer_join_2 INSERT INTO outer_join_1 VALUES(1,'a'), (2,'b'); INSERT INTO outer_join_2 VALUES(1,'a'); :PREFIX SELECT one.id, two.name FROM outer_join_1 one LEFT OUTER JOIN outer_join_2 two ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) :PREFIX SELECT one.id, two.name FROM outer_join_2 two RIGHT OUTER JOIN outer_join_1 one ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) DROP TABLE outer_join_1; DROP TABLE outer_join_2; -- test UNION between regular table and hypertable SELECT time FROM regular_timestamptz UNION SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test UNION ALL between regular table and hypertable SELECT time FROM regular_timestamptz UNION ALL SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test nested join qual propagation :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON true WHERE o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id AND o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON true WHERE o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id AND o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id WHERE o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id WHERE o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) \set ECHO errors RESET timescaledb.enable_optimizations; CREATE TABLE t(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('t','time'); table_name ------------ t INSERT INTO t VALUES ('2000-01-01'), ('2010-01-01'), ('2020-01-01'); EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) SET timescaledb.enable_qual_propagation TO false; EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 -> Index Only Scan Backward using _hyper_15_184_chunk_t_time_idx on _hyper_15_184_chunk t2_3 RESET timescaledb.enable_qual_propagation; CREATE TABLE test (a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('public.test', 'time'); table_name ------------ test INSERT INTO test SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; CREATE OR REPLACE FUNCTION test_f(_ts timestamptz) RETURNS SETOF test LANGUAGE SQL STABLE PARALLEL SAFE AS $f$ SELECT DISTINCT ON (a) * FROM test WHERE time >= _ts ORDER BY a, time DESC $f$; EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 CREATE TABLE t1 (a int, b int NOT NULL); SELECT create_hypertable('t1', 'b', chunk_time_interval=>10); create_hypertable ------------------- (17,public,t1,t) CREATE TABLE t2 (a int, b int NOT NULL); SELECT create_hypertable('t2', 'b', chunk_time_interval=>10); create_hypertable ------------------- (18,public,t2,t) CREATE OR REPLACE FUNCTION f_t1(_a int, _b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (a) * FROM t1 WHERE a = _a and b = _b ORDER BY a, b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t2(_a int, _b int) RETURNS SETOF t2 LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) j.* FROM f_t1(_a, _b) sc, t2 j WHERE j.b = _b AND j.a = _a ORDER BY j.a, j.b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t1_2(_b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) jt.* FROM t1 j, f_t1(j.a, _b) jt $function$; EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10); --- QUERY PLAN --- Subquery Scan on f_t1_2 -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Limit -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10) sc, f_t2(sc.a, 10); --- QUERY PLAN --- Nested Loop -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Limit -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) -> Limit -> Nested Loop -> Limit -> Index Scan using t1_b_idx on t1 t1_1 Index Cond: (b = 10) Filter: (a = t1.a) -> Index Scan using t2_b_idx on t2 j_1 Index Cond: (b = 10) Filter: (a = t1.a) --TEST END-- ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_expand_hypertable-18.out��������������������������������������0000664�0000000�0000000�00000613470�15100345067�0024335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_expand_hypertable_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --single time dimension CREATE TABLE hyper ("time_broken" bigint NOT NULL, "value" integer); ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper', 'time', chunk_time_interval => 10); create_hypertable -------------------- (1,public,hyper,t) INSERT INTO hyper SELECT g, g FROM generate_series(0,1000) g; --insert a point with INT_MAX_64 INSERT INTO hyper (time, value) SELECT 9223372036854775807::bigint, 0; --time and space CREATE TABLE hyper_w_space ("time_broken" bigint NOT NULL, "device_id" text, "value" integer); ALTER TABLE hyper_w_space DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper_w_space', 'time', 'device_id', 4, chunk_time_interval => 10); create_hypertable ---------------------------- (2,public,hyper_w_space,t) INSERT INTO hyper_w_space (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE VIEW hyper_w_space_view AS (SELECT * FROM hyper_w_space); --with timestamp and space CREATE TABLE tag (id serial PRIMARY KEY, name text); CREATE TABLE hyper_ts ("time_broken" timestamptz NOT NULL, "device_id" text, tag_id INT REFERENCES tag(id), "value" integer); ALTER TABLE hyper_ts DROP COLUMN time_broken, ADD COLUMN time TIMESTAMPTZ; SELECT create_hypertable('hyper_ts', 'time', 'device_id', 2, chunk_time_interval => '10 seconds'::interval); create_hypertable ----------------------- (3,public,hyper_ts,t) INSERT INTO tag(name) SELECT 'tag'||g FROM generate_series(0,10) g; INSERT INTO hyper_ts (time, device_id, tag_id, value) SELECT to_timestamp(g), 'dev' || g, (random() /10)+1, g FROM generate_series(0,30) g; --one in the future INSERT INTO hyper_ts (time, device_id, tag_id, value) VALUES ('2100-01-01 02:03:04 PST', 'dev101', 1, 0); --time partitioning function CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc ("time" float8 NOT NULL, "device_id" text, "value" integer); SELECT create_hypertable('hyper_timefunc', 'time', 'device_id', 4, chunk_time_interval => 10, time_partitioning_func => 'unix_to_timestamp'); psql:include/plan_expand_hypertable_load.sql:57: WARNING: unexpected interval: smaller than one second create_hypertable ----------------------------- (4,public,hyper_timefunc,t) INSERT INTO hyper_timefunc (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE TABLE metrics_timestamp(time timestamp); SELECT create_hypertable('metrics_timestamp','time'); psql:include/plan_expand_hypertable_load.sql:62: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,metrics_timestamp,t) INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'1d'::interval); CREATE TABLE metrics_timestamptz(time timestamptz, device_id int); SELECT create_hypertable('metrics_timestamptz','time'); create_hypertable ---------------------------------- (6,public,metrics_timestamptz,t) INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 3; --create a second table to test joins with CREATE TABLE metrics_timestamptz_2 (LIKE metrics_timestamptz); SELECT create_hypertable('metrics_timestamptz_2','time'); create_hypertable ------------------------------------ (7,public,metrics_timestamptz_2,t) INSERT INTO metrics_timestamptz_2 SELECT * FROM metrics_timestamptz; INSERT INTO metrics_timestamptz_2 VALUES ('2000-12-01'::timestamptz, 3); CREATE TABLE metrics_date(time date); SELECT create_hypertable('metrics_date','time'); create_hypertable --------------------------- (8,public,metrics_date,t) INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date,'2000-02-01'::date,'1d'::interval); ANALYZE hyper; ANALYZE hyper_w_space; ANALYZE tag; ANALYZE hyper_ts; ANALYZE hyper_timefunc; -- create normal table for JOIN tests CREATE TABLE regular_timestamptz(time timestamptz); INSERT INTO regular_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval); \ir include/plan_expand_hypertable_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --we want to see how our logic excludes chunks --and not how much work constraint_exclusion does SET constraint_exclusion = 'off'; \qecho test upper bounds test upper bounds :PREFIX SELECT * FROM hyper WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) :PREFIX SELECT * FROM hyper WHERE time < 11 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 11) -> Seq Scan on _hyper_1_2_chunk Filter: ("time" < 11) :PREFIX SELECT * FROM hyper WHERE time = 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = 10) :PREFIX SELECT * FROM hyper WHERE 10 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (10 >= "time") -> Seq Scan on _hyper_1_2_chunk Filter: (10 >= "time") \qecho test lower bounds test lower bounds :PREFIX SELECT * FROM hyper WHERE time >= 10 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 10) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE 10 < time and 20 >= time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_2_chunk Filter: ((10 < "time") AND (20 >= "time")) -> Seq Scan on _hyper_1_3_chunk Filter: ((10 < "time") AND (20 >= "time")) :PREFIX SELECT * FROM hyper WHERE time >= 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper.value -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 9) AND ("time" < 20)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" >= 9) AND ("time" < 20)) :PREFIX SELECT * FROM hyper WHERE time > 9 and time < 20 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk.value -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 9) AND ("time" < 20)) \qecho test empty result test empty result :PREFIX SELECT * FROM hyper WHERE time < 0; --- QUERY PLAN --- Result One-Time Filter: false \qecho test expression evaluation test expression evaluation :PREFIX SELECT * FROM hyper WHERE time < (5*2)::smallint; --- QUERY PLAN --- Seq Scan on _hyper_1_1_chunk Filter: ("time" < '10'::smallint) \qecho test logic at INT64_MAX test logic at INT64_MAX :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" = '9223372036854775806'::bigint) :PREFIX SELECT * FROM hyper WHERE time >= 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" >= '9223372036854775807'::bigint) :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775807::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775806::bigint ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_102_chunk.value -> Seq Scan on _hyper_1_102_chunk Filter: ("time" > '9223372036854775806'::bigint) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper WHERE time < 10 ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.value -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper WHERE time < 10); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_1_1_chunk Filter: ("time" < 10) \qecho no space constraint no space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < 10) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < 10) \qecho valid space constraint valid space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev'||(2+3) = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ('dev5'::text = device_id)) \qecho only space constraint only space constraint :PREFIX SELECT * FROM hyper_w_space WHERE 'dev5' = device_id ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_106_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_109_chunk Filter: ('dev5'::text = device_id) -> Seq Scan on _hyper_2_111_chunk Filter: ('dev5'::text = device_id) \qecho unhandled space constraint unhandled space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id > 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id > 'dev5'::text)) \qecho use of OR - does not filter chunks use of OR - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND (device_id = 'dev5' or device_id = 'dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ((device_id = 'dev5'::text) OR (device_id = 'dev6'::text))) \qecho cte cte :PREFIX WITH cte AS( SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ) SELECT * FROM cte ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho subquery subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper_w_space WHERE time < 10 and device_id = 'dev5'); --- QUERY PLAN --- Result SubPlan 1 -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho view view :PREFIX SELECT * FROM hyper_w_space_view WHERE time < 10 and device_id = 'dev5' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - simple IN statement - simple :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho IN statement - two chunks IN statement - two chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho IN statement - one chunk IN statement - one chunk :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev4','dev5') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev4,dev5}'::text[]))) \qecho NOT IN - does not filter chunks NOT IN - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id NOT IN ('dev5','dev6') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id <> ALL ('{dev5,dev6}'::text[]))) \qecho IN statement with subquery - does not filter chunks IN statement with subquery - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN (SELECT 'dev5'::text) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_106_chunk.value -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = 'dev5'::text)) \qecho ANY ANY :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[]))) \qecho ANY with intersection ANY with intersection :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev6','dev7']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_2_105_chunk.value -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND (device_id = ANY ('{dev5,dev6}'::text[])) AND (device_id = ANY ('{dev6,dev7}'::text[]))) \qecho ANY without intersection shouldnt scan any chunks ANY without intersection shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev8','dev9']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho ANY/IN/ALL only works for equals operator ANY/IN/ALL only works for equals operator :PREFIX SELECT * FROM hyper_w_space WHERE device_id < ANY(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_104_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_105_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_106_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_107_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_108_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_109_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_110_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_111_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_112_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_113_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_114_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) -> Seq Scan on _hyper_2_115_chunk Filter: (device_id < ANY ('{dev5,dev6}'::text[])) \qecho ALL with equals and different values shouldnt scan any chunks ALL with equals and different values shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE device_id = ALL(ARRAY['dev5','dev6']) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho Multi AND Multi AND :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND time < 100 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_104_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_105_chunk Filter: (("time" < 10) AND ("time" < 100)) -> Seq Scan on _hyper_2_106_chunk Filter: (("time" < 10) AND ("time" < 100)) \qecho Time dimension doesnt filter chunks when using IN/ANY with multiple arguments Time dimension doesnt filter chunks when using IN/ANY with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1,2]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_107_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_108_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_109_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_110_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_111_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_112_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_113_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_114_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_115_chunk Filter: ("time" < ANY ('{1,2}'::integer[])) \qecho Time dimension chunk filtering works for ANY with single argument Time dimension chunk filtering works for ANY with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ANY ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ANY ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with single argument Time dimension chunk filtering works for ALL with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1}'::integer[])) \qecho Time dimension chunk filtering works for ALL with multiple arguments Time dimension chunk filtering works for ALL with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1,10,20,30]) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_104_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_105_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) -> Seq Scan on _hyper_2_106_chunk Filter: ("time" < ALL ('{1,10,20,30}'::integer[])) \qecho AND intersection using IN and EQUALS AND intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_w_space.value -> Append -> Seq Scan on _hyper_2_103_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_110_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) -> Seq Scan on _hyper_2_114_chunk Filter: ((device_id = ANY ('{dev1,dev2}'::text[])) AND (device_id = 'dev1'::text)) \qecho AND with no intersection using IN and EQUALS AND with no intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev3' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: value -> Result One-Time Filter: false \qecho timestamps timestamps \qecho these should work since they are immutable functions these should work since they are immutable functions :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969 PST'::timestamptz ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp AT TIME ZONE 'PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Append -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) \qecho these should not work since uses stable functions; these should not work since uses stable functions; :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < 'Wed Dec 31 16:00:10 1969'::timestamp without time zone) :PREFIX SELECT * FROM hyper_ts WHERE time < ('Wed Dec 31 16:00:10 1969'::timestamp::timestamptz) ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 6 -> Seq Scan on _hyper_3_116_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) -> Seq Scan on _hyper_3_117_chunk Filter: ("time" < ('Wed Dec 31 16:00:10 1969'::timestamp without time zone)::timestamp with time zone) :PREFIX SELECT * FROM hyper_ts WHERE NOW() < time ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts Chunks excluded during startup: 7 -> Seq Scan on _hyper_3_123_chunk Filter: (now() < "time") \qecho joins joins :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Semi Join -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text) AND (tag_id = 1)) -> Seq Scan on tag Filter: (id = 1) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) or (time < to_timestamp(10) and device_id = 'dev1') ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_ts.value -> Custom Scan (ChunkAppend) on hyper_ts -> Seq Scan on _hyper_3_116_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) SubPlan 1 -> Seq Scan on tag Filter: (id = 1) -> Seq Scan on _hyper_3_117_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_118_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_119_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_120_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_121_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_122_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) -> Seq Scan on _hyper_3_123_chunk Filter: ((ANY (tag_id = (hashed SubPlan 1).col1)) OR (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text))) :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.name='tag1') and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (_hyper_3_116_chunk.tag_id = tag.id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Merge Join Merge Cond: (tag.id = _hyper_3_116_chunk.tag_id) -> Index Scan using tag_pkey on tag -> Sort Sort Key: _hyper_3_116_chunk.tag_id -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE tag.name = 'tag1' and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: _hyper_3_116_chunk.value -> Nested Loop Join Filter: (tag.id = _hyper_3_116_chunk.tag_id) -> Seq Scan on _hyper_3_116_chunk Filter: (("time" < 'Wed Dec 31 16:00:10 1969 PST'::timestamp with time zone) AND (device_id = 'dev1'::text)) -> Seq Scan on tag Filter: (name = 'tag1'::text) \qecho test constraint exclusion for constraints in ON clause of JOINs test constraint exclusion for constraints in ON clause of JOINs \qecho should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho must not exclude on m1 must not exclude on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") Join Filter: (m1."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho should exclude chunks on m2 should exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho should exclude chunks on m1 should exclude chunks on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho must not exclude chunks on m2 must not exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time, m2.time; --- QUERY PLAN --- Sort Sort Key: m1."time", m2."time" -> Merge Left Join Merge Cond: (m2."time" = m1."time") Join Filter: (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho time_bucket exclusion time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND (time_bucket('10'::bigint, "time") < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time") < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time") <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk."time" -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '10'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time"))) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 11::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) < '11'::bigint)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) <= 10::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" <= '20'::bigint) AND (time_bucket('10'::bigint, "time", '5'::bigint) <= '10'::bigint)) :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '20'::bigint) AND ('10'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time, 5) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < '21'::bigint) AND ('11'::bigint > time_bucket('10'::bigint, "time", '5'::bigint))) \qecho timestamp time_bucket exclusion timestamp time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamp; count ------- 5 :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) >= '2000-01-15' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Sat Jan 15 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) < 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) <= 'Wed Jan 05 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) > 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000'::timestamp without time zone) >= 'Tue Jan 25 00:00:00 2000'::timestamp without time zone) \qecho timestamptz time_bucket exclusion timestamptz time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamptz; count ------- 5 :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time") >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", '@ 3 days'::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') < '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" < 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) < 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') <= '2000-01-05' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: ("time" <= 'Wed Jan 12 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) <= 'Wed Jan 05 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') > '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) > 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') >= '2000-01-25' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Index Cond: ("time" >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 7 days'::interval, "time", 'Europe/Berlin'::text, NULL::timestamp with time zone, NULL::interval) >= 'Tue Jan 25 00:00:00 2000 PST'::timestamp with time zone) \qecho test overflow behaviour of time_bucket exclusion test overflow behaviour of time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time > 950 AND time_bucket(10, time) < '9223372036854775807'::bigint ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_96_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_97_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_98_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_99_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_100_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_101_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) -> Seq Scan on _hyper_1_102_chunk Filter: (("time" > 950) AND (time_bucket('10'::bigint, "time") < '9223372036854775807'::bigint)) \qecho test timestamp upper boundary test timestamp upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1000d',time) < '294276-01-01'::timestamp ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276'::timestamp without time zone) \qecho test timestamptz upper boundary test timestamptz upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 day'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho transformation would be out of range transformation would be out of range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1000d',time) < '294276-01-01'::timestamptz ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1000 days'::interval, "time") < 'Sat Jan 01 00:00:00 294276 PST'::timestamp with time zone) \qecho time_bucket exclusion with run-time constants time_bucket exclusion with run-time constants -- These queries have a stable time_bucket expression, because the text::interval conversion is stable. PREPARE P1(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P2(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P3(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P4(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; -- These queries have an immutable time_bucket expression, because the parameter is passed as interval, and no conversion is involved. PREPARE P5(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P6(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P7(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P8(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; SET plan_cache_mode TO 'force_custom_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(('60 mins'::cstring)::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket('@ 1 hour'::interval, "time") > ('2000-01-01 UTC'::cstring)::timestamp without time zone) SET plan_cache_mode TO 'force_generic_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 5 :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket(($1)::interval, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp with time zone) :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" Chunks excluded during startup: 0 -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_157_chunk_metrics_timestamp_time_idx on _hyper_5_157_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_158_chunk_metrics_timestamp_time_idx on _hyper_5_158_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) -> Index Only Scan Backward using _hyper_5_159_chunk_metrics_timestamp_time_idx on _hyper_5_159_chunk Filter: (time_bucket($1, "time") > ($2)::timestamp without time zone) RESET plan_cache_mode; DEALLOCATE P1; DEALLOCATE P2; DEALLOCATE P3; DEALLOCATE P4; DEALLOCATE P5; DEALLOCATE P6; DEALLOCATE P7; DEALLOCATE P8; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 100 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Append -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" > 10) AND ("time" < '100'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 100)) :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 20 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (time_bucket('10'::bigint, "time") > 10) AND (time_bucket('10'::bigint, "time") < 20)) :PREFIX SELECT * FROM hyper WHERE time_bucket(1, time) > 11 AND time_bucket(1, time) < 19 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 11) AND ("time" < '19'::bigint) AND (time_bucket('1'::bigint, "time") > 11) AND (time_bucket('1'::bigint, "time") < 19)) :PREFIX SELECT * FROM hyper WHERE 10 < time_bucket(10, time) AND 20 > time_bucket(10,time) ORDER BY time; --- QUERY PLAN --- Sort Sort Key: _hyper_1_2_chunk."time" -> Seq Scan on _hyper_1_2_chunk Filter: (("time" > 10) AND ("time" < '20'::bigint) AND (10 < time_bucket('10'::bigint, "time")) AND (20 > time_bucket('10'::bigint, "time"))) \qecho time_bucket exclusion with date time_bucket exclusion with date :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: ("time" < '01-03-2000'::date) Filter: (time_bucket('@ 1 day'::interval, "time") < '01-03-2000'::date) :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_date Order: metrics_date."time" -> Index Only Scan Backward using _hyper_8_171_chunk_metrics_date_time_idx on _hyper_8_171_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) -> Index Only Scan Backward using _hyper_8_172_chunk_metrics_date_time_idx on _hyper_8_172_chunk Index Cond: (("time" >= '01-03-2000'::date) AND ("time" <= '01-11-2000'::date)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= '01-03-2000'::date) AND (time_bucket('@ 1 day'::interval, "time") <= '01-10-2000'::date)) \qecho time_bucket exclusion with timestamp time_bucket exclusion with timestamp :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: ("time" < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamp Order: metrics_timestamp."time" -> Index Only Scan Backward using _hyper_5_155_chunk_metrics_timestamp_time_idx on _hyper_5_155_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) -> Index Only Scan Backward using _hyper_5_156_chunk_metrics_timestamp_time_idx on _hyper_5_156_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000'::timestamp without time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000'::timestamp without time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000'::timestamp without time zone)) \qecho time_bucket exclusion with timestamptz time_bucket exclusion with timestamptz :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Mon Jan 03 06:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 6 hours'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) >= '2000-01-03' AND time_bucket('6h',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 10 06:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 6 hours'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 6 hours'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho time_bucket exclusion with timestamptz and day interval time_bucket exclusion with timestamptz and day interval :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; --- QUERY PLAN --- Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: ("time" < 'Tue Jan 04 00:00:00 2000 PST'::timestamp with time zone) Filter: (time_bucket('@ 1 day'::interval, "time") < 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Tue Jan 11 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 1 day'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('7d',time) <= '2000-01-10' ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_timestamptz Order: metrics_timestamptz."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk Index Cond: (("time" >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND ("time" <= 'Mon Jan 17 00:00:00 2000 PST'::timestamp with time zone)) Filter: ((time_bucket('@ 1 day'::interval, "time") >= 'Mon Jan 03 00:00:00 2000 PST'::timestamp with time zone) AND (time_bucket('@ 7 days'::interval, "time") <= 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho no transformation no transformation :PREFIX SELECT * FROM hyper WHERE time_bucket(10 + floor(random())::int, time) > 10 AND time_bucket(10 + floor(random())::int, time) < 100 AND time < 150 ORDER BY time; --- QUERY PLAN --- Sort Sort Key: hyper."time" -> Custom Scan (ChunkAppend) on hyper Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_2_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_3_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_4_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_5_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_6_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_7_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_8_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_9_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_10_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_11_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_12_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_13_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_14_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) -> Seq Scan on _hyper_1_15_chunk Filter: (("time" < 150) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") > 10) AND (time_bucket(((10 + (floor(random()))::integer))::bigint, "time") < 100)) \qecho exclude chunks based on time column with partitioning function. This exclude chunks based on time column with partitioning function. This \qecho transparently applies the time partitioning function on the time transparently applies the time partitioning function on the time \qecho value to be able to exclude chunks (similar to a closed dimension). value to be able to exclude chunks (similar to a closed dimension). :PREFIX SELECT * FROM hyper_timefunc WHERE time < 4 ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_125_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_126_chunk Filter: ("time" < '4'::double precision) -> Seq Scan on _hyper_4_127_chunk Filter: ("time" < '4'::double precision) \qecho excluding based on time expression is currently unoptimized excluding based on time expression is currently unoptimized :PREFIX SELECT * FROM hyper_timefunc WHERE unix_to_timestamp(time) < 'Wed Dec 31 16:00:04 1969 PST' ORDER BY value; --- QUERY PLAN --- Sort Sort Key: hyper_timefunc.value -> Append -> Seq Scan on _hyper_4_124_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_125_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_126_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_127_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_128_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_129_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_130_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_131_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_132_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_133_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_134_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_135_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_136_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_137_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_138_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_139_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_140_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_141_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_142_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_143_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_144_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_145_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_146_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_147_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_148_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_149_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_150_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_151_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_152_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_153_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_154_chunk Filter: (to_timestamp("time") < 'Wed Dec 31 16:00:04 1969 PST'::timestamp with time zone) \qecho test qual propagation for joins test qual propagation for joins RESET constraint_exclusion; \qecho nothing to propagate nothing to propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; --- QUERY PLAN --- Sort Sort Key: m1."time" -> Merge Right Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho OR constraints should not propagate OR constraints should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' OR m1.time > '2001-01-01' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) OR ("time" > 'Mon Jan 01 00:00:00 2001 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 \qecho test single constraint test single constraint \qecho constraint should be on both scans constraint should be on both scans \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test 2 constraints on single relation test 2 constraints on single relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" = m1."time") :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test 2 constraints with 1 constraint on each relation test 2 constraints with 1 constraint on each relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of INNER JOIN test constraints in ON clause of INNER JOIN :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of LEFT JOIN test constraints in ON clause of LEFT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Left Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test constraints in ON clause of RIGHT JOIN test constraints in ON clause of RIGHT JOIN \qecho must not propagate must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Gather Merge Workers Planned: 2 -> Sort Sort Key: m1."time" -> Parallel Hash Left Join Hash Cond: (m2."time" = m1."time") Join Filter: ((m2."time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND (m2."time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Parallel Append -> Parallel Seq Scan on _hyper_7_165_chunk m2_1 -> Parallel Seq Scan on _hyper_7_166_chunk m2_2 -> Parallel Seq Scan on _hyper_7_167_chunk m2_3 -> Parallel Seq Scan on _hyper_7_168_chunk m2_4 -> Parallel Seq Scan on _hyper_7_169_chunk m2_5 -> Parallel Seq Scan on _hyper_7_170_chunk m2_6 -> Parallel Hash -> Parallel Append -> Parallel Seq Scan on _hyper_6_160_chunk m1_1 -> Parallel Seq Scan on _hyper_6_161_chunk m1_2 -> Parallel Seq Scan on _hyper_6_162_chunk m1_3 -> Parallel Seq Scan on _hyper_6_163_chunk m1_4 -> Parallel Seq Scan on _hyper_6_164_chunk m1_5 \qecho test equality condition not in ON clause test equality condition not in ON clause :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test constraints not joined on test constraints not joined on \qecho device_id constraint must not propagate device_id constraint must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Only Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) \qecho test multiple join conditions test multiple join conditions \qecho device_id constraint should propagate device_id constraint should propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m1.device_id = m2.device_id AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) -> Index Scan using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" = m1."time") AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) Filter: (device_id = 1) \qecho test join with 3 tables test join with 3 tables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time INNER JOIN metrics_timestamptz m3 ON m2.time=m3.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Nested Loop -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Append -> Index Only Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m3_1 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m3_2 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m3_3 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m3_4 Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m3_5 Index Cond: ("time" = m1."time") \qecho test non-Const constraints test non-Const constraints :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10'::text::timestamptz ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 3 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 4 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) \qecho test now() test now() :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < now() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Index Cond: ("time" < now()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Index Cond: ("time" < now()) \qecho test volatile function test volatile function \qecho should not propagate should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m2.time < clock_timestamp() ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 m2 Order: m2."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk m2_1 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk m2_2 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_167_chunk_metrics_timestamptz_2_time_idx on _hyper_7_167_chunk m2_3 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk m2_4 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk m2_5 Filter: ("time" < clock_timestamp()) -> Index Only Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk m2_6 Filter: ("time" < clock_timestamp()) -> Materialize -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 -> Index Only Scan Backward using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk m1_3 -> Index Only Scan Backward using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk m1_4 -> Index Only Scan Backward using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk m1_5 \qecho test JOINs with normal table test JOINs with normal table \qecho will not propagate because constraints are only added to hypertables will not propagate because constraints are only added to hypertables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 \qecho test JOINs with normal table test JOINs with normal table :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m2.time < '2000-01-10' ORDER BY m1.time; --- QUERY PLAN --- Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics_timestamptz m1 Order: m1."time" -> Index Only Scan Backward using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk m1_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk m1_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: m2."time" -> Seq Scan on regular_timestamptz m2 Filter: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) \qecho test quals are not pushed into OUTER JOIN test quals are not pushed into OUTER JOIN CREATE TABLE outer_join_1 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE outer_join_2 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'time')) FROM (VALUES ('outer_join_1'),('outer_join_2')) v(tbl); table_name -------------- outer_join_1 outer_join_2 INSERT INTO outer_join_1 VALUES(1,'a'), (2,'b'); INSERT INTO outer_join_2 VALUES(1,'a'); :PREFIX SELECT one.id, two.name FROM outer_join_1 one LEFT OUTER JOIN outer_join_2 two ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) :PREFIX SELECT one.id, two.name FROM outer_join_2 two RIGHT OUTER JOIN outer_join_1 one ON one.id=two.id WHERE one.id=2; --- QUERY PLAN --- Nested Loop Left Join -> Seq Scan on _hyper_9_176_chunk one Filter: (id = 2) -> Materialize -> Seq Scan on _hyper_10_177_chunk two Filter: (id = 2) DROP TABLE outer_join_1; DROP TABLE outer_join_2; -- test UNION between regular table and hypertable SELECT time FROM regular_timestamptz UNION SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test UNION ALL between regular table and hypertable SELECT time FROM regular_timestamptz UNION ALL SELECT time FROM metrics_timestamptz ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Thu Jan 20 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Fri Jan 21 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sat Jan 22 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Sun Jan 23 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Mon Jan 24 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Wed Jan 26 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Thu Jan 27 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Fri Jan 28 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sat Jan 29 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Sun Jan 30 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Mon Jan 31 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST Tue Feb 01 00:00:00 2000 PST -- test nested join qual propagation :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON true WHERE o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id AND o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON true WHERE o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id AND o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id WHERE o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id WHERE o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: o1_m1."time", o2_m1."time" -> Merge Full Join Merge Cond: (o2_m1."time" = o1_m1."time") -> Nested Loop -> Merge Append Sort Key: o2_m2."time" -> Index Scan Backward using _hyper_7_168_chunk_metrics_timestamptz_2_time_idx on _hyper_7_168_chunk o2_m2_1 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_169_chunk_metrics_timestamptz_2_time_idx on _hyper_7_169_chunk o2_m2_2 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Index Scan Backward using _hyper_7_170_chunk_metrics_timestamptz_2_time_idx on _hyper_7_170_chunk o2_m2_3 Index Cond: ("time" > 'Thu Jan 20 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 2) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o2_m1_1 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o2_m1_2 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o2_m1_3 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o2_m1_4 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o2_m1_5 Index Cond: ("time" = o2_m2."time") Filter: (device_id = 2) -> Materialize -> Nested Loop -> Custom Scan (ChunkAppend) on metrics_timestamptz_2 o1_m2 Order: o1_m2."time" -> Index Scan Backward using _hyper_7_165_chunk_metrics_timestamptz_2_time_idx on _hyper_7_165_chunk o1_m2_1 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan Backward using _hyper_7_166_chunk_metrics_timestamptz_2_time_idx on _hyper_7_166_chunk o1_m2_2 Index Cond: ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Append -> Index Scan using _hyper_6_160_chunk_metrics_timestamptz_time_idx on _hyper_6_160_chunk o1_m1_1 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_161_chunk_metrics_timestamptz_time_idx on _hyper_6_161_chunk o1_m1_2 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_162_chunk_metrics_timestamptz_time_idx on _hyper_6_162_chunk o1_m1_3 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_163_chunk_metrics_timestamptz_time_idx on _hyper_6_163_chunk o1_m1_4 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) -> Index Scan using _hyper_6_164_chunk_metrics_timestamptz_time_idx on _hyper_6_164_chunk o1_m1_5 Index Cond: ("time" = o1_m2."time") Filter: (device_id = 1) \set ECHO errors RESET timescaledb.enable_optimizations; CREATE TABLE t(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('t','time'); table_name ------------ t INSERT INTO t VALUES ('2000-01-01'), ('2010-01-01'), ('2020-01-01'); EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) SET timescaledb.enable_qual_propagation TO false; EXPLAIN (buffers off, costs off) SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; --- QUERY PLAN --- Merge Join Merge Cond: (t1."time" = t2."time") -> Merge Append Sort Key: t1."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t1_1 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t1_2 Index Cond: ("time" < 'Fri Jan 01 00:00:00 2010 PST'::timestamp with time zone) -> Materialize -> Merge Append Sort Key: t2."time" -> Index Only Scan Backward using _hyper_15_182_chunk_t_time_idx on _hyper_15_182_chunk t2_1 -> Index Only Scan Backward using _hyper_15_183_chunk_t_time_idx on _hyper_15_183_chunk t2_2 -> Index Only Scan Backward using _hyper_15_184_chunk_t_time_idx on _hyper_15_184_chunk t2_3 RESET timescaledb.enable_qual_propagation; CREATE TABLE test (a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('public.test', 'time'); table_name ------------ test INSERT INTO test SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; CREATE OR REPLACE FUNCTION test_f(_ts timestamptz) RETURNS SETOF test LANGUAGE SQL STABLE PARALLEL SAFE AS $f$ SELECT DISTINCT ON (a) * FROM test WHERE time >= _ts ORDER BY a, time DESC $f$; EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 EXPLAIN (buffers off, costs off) SELECT * FROM test_f(now()); --- QUERY PLAN --- Unique -> Sort Sort Key: test.a, test."time" DESC -> Custom Scan (ChunkAppend) on test Chunks excluded during startup: 4 CREATE TABLE t1 (a int, b int NOT NULL); SELECT create_hypertable('t1', 'b', chunk_time_interval=>10); create_hypertable ------------------- (17,public,t1,t) CREATE TABLE t2 (a int, b int NOT NULL); SELECT create_hypertable('t2', 'b', chunk_time_interval=>10); create_hypertable ------------------- (18,public,t2,t) CREATE OR REPLACE FUNCTION f_t1(_a int, _b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (a) * FROM t1 WHERE a = _a and b = _b ORDER BY a, b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t2(_a int, _b int) RETURNS SETOF t2 LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) j.* FROM f_t1(_a, _b) sc, t2 j WHERE j.b = _b AND j.a = _a ORDER BY j.a, j.b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t1_2(_b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) jt.* FROM t1 j, f_t1(j.a, _b) jt $function$; EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10); --- QUERY PLAN --- Subquery Scan on f_t1_2 -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Limit -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) EXPLAIN (buffers off, costs off) SELECT * FROM f_t1_2(10) sc, f_t2(sc.a, 10); --- QUERY PLAN --- Nested Loop -> Unique -> Sort Sort Key: j.a -> Nested Loop -> Seq Scan on t1 j -> Limit -> Index Scan using t1_b_idx on t1 Index Cond: (b = 10) Filter: (a = j.a) -> Limit -> Nested Loop -> Limit -> Index Scan using t1_b_idx on t1 t1_1 Index Cond: (b = 10) Filter: (a = t1.a) -> Index Scan using t2_b_idx on t2 j_1 Index Cond: (b = 10) Filter: (a = t1.a) --TEST END-- ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_hashagg-15.out������������������������������������������������0000664�0000000�0000000�00000033252�15100345067�0022230�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET max_parallel_workers_per_gather TO 0; \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_hashagg_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE metric (id SERIAL PRIMARY KEY, value INT); CREATE TABLE hyper(time TIMESTAMP NOT NULL, time_int BIGINT, time_broken DATE, metricid int, value double precision); CREATE TABLE regular(time TIMESTAMP NOT NULL, time_int BIGINT, time_date DATE, metricid int, value double precision); SELECT create_hypertable('hyper', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE); psql:include/plan_hashagg_load.sql:9: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (1,public,hyper,t) ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time_date DATE; INSERT INTO metric(value) SELECT random()*100 FROM generate_series(0,10); INSERT INTO hyper SELECT t, EXTRACT(EPOCH FROM t), (EXTRACT(EPOCH FROM t)::int % 10)+1, 1.0, t::date FROM generate_series('2001-01-01', '2001-01-10', INTERVAL '1 second') t; INSERT INTO regular(time, time_int, time_date, metricid, value) SELECT t, EXTRACT(EPOCH FROM t), t::date, (EXTRACT(EPOCH FROM t)::int % 10) + 1, 1.0 FROM generate_series('2001-01-01', '2001-01-02', INTERVAL '1 second') t; --test some queries before analyze; EXPLAIN (buffers off, costs off) SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) EXPLAIN (buffers off, costs off) SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: date_trunc('minute'::text, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc(time float8 NOT NULL, metricid int, VALUE double precision, time_date DATE); SELECT create_hypertable('hyper_timefunc', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE, time_partitioning_func => 'unix_to_timestamp'); create_hypertable ----------------------------- (2,public,hyper_timefunc,t) INSERT INTO hyper_timefunc SELECT time_int, metricid, VALUE, time_date FROM hyper; ANALYZE metric; ANALYZE hyper; ANALYZE regular; ANALYZE hyper_timefunc; \ir include/plan_hashagg_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. :PREFIX SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 hour', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --should be too many groups will not hashaggregate :PREFIX SELECT time_bucket('1 second', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int, 10) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date)) DESC -> HashAggregate Group Key: time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 0 --can't optimize invalid time unit :PREFIX SELECT date_trunc('invalid', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 1 :PREFIX SELECT date_trunc('day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone)) DESC -> HashAggregate Group Key: date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --joins --with hypertable, optimize :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(hyper.value) as avg FROM hyper JOIN metric ON (hyper.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC, metric.id -> Hash Join Hash Cond: (_hyper_1_1_chunk.metricid = metric.id) -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Hash -> Seq Scan on metric --no hypertable involved, no optimization :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(regular.value) as avg FROM regular JOIN metric ON (regular.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)) DESC, metric.id -> Nested Loop Join Filter: (regular.metricid = metric.id) -> Seq Scan on regular Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Seq Scan on metric -- Try with time partitioning function. Currently not optimized for hash aggregates :PREFIX SELECT time_bucket('1 minute', unix_to_timestamp(time)) AS MetricMinuteTs, AVG(value) as avg FROM hyper_timefunc WHERE unix_to_timestamp(time) >= '2001-01-04T00:00:00' AND unix_to_timestamp(time) <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) DESC -> Result -> Seq Scan on _hyper_2_2_chunk Filter: ((to_timestamp("time") >= 'Thu Jan 04 00:00:00 2001 PST'::timestamp with time zone) AND (to_timestamp("time") <= 'Fri Jan 05 01:00:00 2001 PST'::timestamp with time zone)) \set ECHO none psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_hashagg-16.out������������������������������������������������0000664�0000000�0000000�00000033252�15100345067�0022231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET max_parallel_workers_per_gather TO 0; \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_hashagg_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE metric (id SERIAL PRIMARY KEY, value INT); CREATE TABLE hyper(time TIMESTAMP NOT NULL, time_int BIGINT, time_broken DATE, metricid int, value double precision); CREATE TABLE regular(time TIMESTAMP NOT NULL, time_int BIGINT, time_date DATE, metricid int, value double precision); SELECT create_hypertable('hyper', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE); psql:include/plan_hashagg_load.sql:9: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (1,public,hyper,t) ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time_date DATE; INSERT INTO metric(value) SELECT random()*100 FROM generate_series(0,10); INSERT INTO hyper SELECT t, EXTRACT(EPOCH FROM t), (EXTRACT(EPOCH FROM t)::int % 10)+1, 1.0, t::date FROM generate_series('2001-01-01', '2001-01-10', INTERVAL '1 second') t; INSERT INTO regular(time, time_int, time_date, metricid, value) SELECT t, EXTRACT(EPOCH FROM t), t::date, (EXTRACT(EPOCH FROM t)::int % 10) + 1, 1.0 FROM generate_series('2001-01-01', '2001-01-02', INTERVAL '1 second') t; --test some queries before analyze; EXPLAIN (buffers off, costs off) SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) EXPLAIN (buffers off, costs off) SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: date_trunc('minute'::text, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc(time float8 NOT NULL, metricid int, VALUE double precision, time_date DATE); SELECT create_hypertable('hyper_timefunc', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE, time_partitioning_func => 'unix_to_timestamp'); create_hypertable ----------------------------- (2,public,hyper_timefunc,t) INSERT INTO hyper_timefunc SELECT time_int, metricid, VALUE, time_date FROM hyper; ANALYZE metric; ANALYZE hyper; ANALYZE regular; ANALYZE hyper_timefunc; \ir include/plan_hashagg_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. :PREFIX SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 hour', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --should be too many groups will not hashaggregate :PREFIX SELECT time_bucket('1 second', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int, 10) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date)) DESC -> HashAggregate Group Key: time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 0 --can't optimize invalid time unit :PREFIX SELECT date_trunc('invalid', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 1 :PREFIX SELECT date_trunc('day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone)) DESC -> HashAggregate Group Key: date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --joins --with hypertable, optimize :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(hyper.value) as avg FROM hyper JOIN metric ON (hyper.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC, metric.id -> Hash Join Hash Cond: (_hyper_1_1_chunk.metricid = metric.id) -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Hash -> Seq Scan on metric --no hypertable involved, no optimization :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(regular.value) as avg FROM regular JOIN metric ON (regular.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)) DESC, metric.id -> Nested Loop Join Filter: (metric.id = regular.metricid) -> Seq Scan on regular Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Seq Scan on metric -- Try with time partitioning function. Currently not optimized for hash aggregates :PREFIX SELECT time_bucket('1 minute', unix_to_timestamp(time)) AS MetricMinuteTs, AVG(value) as avg FROM hyper_timefunc WHERE unix_to_timestamp(time) >= '2001-01-04T00:00:00' AND unix_to_timestamp(time) <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) DESC -> Result -> Seq Scan on _hyper_2_2_chunk Filter: ((to_timestamp("time") >= 'Thu Jan 04 00:00:00 2001 PST'::timestamp with time zone) AND (to_timestamp("time") <= 'Fri Jan 05 01:00:00 2001 PST'::timestamp with time zone)) \set ECHO none psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_hashagg-17.out������������������������������������������������0000664�0000000�0000000�00000033252�15100345067�0022232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET max_parallel_workers_per_gather TO 0; \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_hashagg_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE metric (id SERIAL PRIMARY KEY, value INT); CREATE TABLE hyper(time TIMESTAMP NOT NULL, time_int BIGINT, time_broken DATE, metricid int, value double precision); CREATE TABLE regular(time TIMESTAMP NOT NULL, time_int BIGINT, time_date DATE, metricid int, value double precision); SELECT create_hypertable('hyper', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE); psql:include/plan_hashagg_load.sql:9: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (1,public,hyper,t) ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time_date DATE; INSERT INTO metric(value) SELECT random()*100 FROM generate_series(0,10); INSERT INTO hyper SELECT t, EXTRACT(EPOCH FROM t), (EXTRACT(EPOCH FROM t)::int % 10)+1, 1.0, t::date FROM generate_series('2001-01-01', '2001-01-10', INTERVAL '1 second') t; INSERT INTO regular(time, time_int, time_date, metricid, value) SELECT t, EXTRACT(EPOCH FROM t), t::date, (EXTRACT(EPOCH FROM t)::int % 10) + 1, 1.0 FROM generate_series('2001-01-01', '2001-01-02', INTERVAL '1 second') t; --test some queries before analyze; EXPLAIN (buffers off, costs off) SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) EXPLAIN (buffers off, costs off) SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: date_trunc('minute'::text, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc(time float8 NOT NULL, metricid int, VALUE double precision, time_date DATE); SELECT create_hypertable('hyper_timefunc', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE, time_partitioning_func => 'unix_to_timestamp'); create_hypertable ----------------------------- (2,public,hyper_timefunc,t) INSERT INTO hyper_timefunc SELECT time_int, metricid, VALUE, time_date FROM hyper; ANALYZE metric; ANALYZE hyper; ANALYZE regular; ANALYZE hyper_timefunc; \ir include/plan_hashagg_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. :PREFIX SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 hour', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --should be too many groups will not hashaggregate :PREFIX SELECT time_bucket('1 second', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int, 10) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date)) DESC -> HashAggregate Group Key: time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 0 --can't optimize invalid time unit :PREFIX SELECT date_trunc('invalid', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 1 :PREFIX SELECT date_trunc('day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone)) DESC -> HashAggregate Group Key: date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --joins --with hypertable, optimize :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(hyper.value) as avg FROM hyper JOIN metric ON (hyper.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC, metric.id -> Hash Join Hash Cond: (_hyper_1_1_chunk.metricid = metric.id) -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Hash -> Seq Scan on metric --no hypertable involved, no optimization :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(regular.value) as avg FROM regular JOIN metric ON (regular.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)) DESC, metric.id -> Nested Loop Join Filter: (metric.id = regular.metricid) -> Seq Scan on regular Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Seq Scan on metric -- Try with time partitioning function. Currently not optimized for hash aggregates :PREFIX SELECT time_bucket('1 minute', unix_to_timestamp(time)) AS MetricMinuteTs, AVG(value) as avg FROM hyper_timefunc WHERE unix_to_timestamp(time) >= '2001-01-04T00:00:00' AND unix_to_timestamp(time) <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) DESC -> Result -> Seq Scan on _hyper_2_2_chunk Filter: ((to_timestamp("time") >= 'Thu Jan 04 00:00:00 2001 PST'::timestamp with time zone) AND (to_timestamp("time") <= 'Fri Jan 05 01:00:00 2001 PST'::timestamp with time zone)) \set ECHO none psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_hashagg-18.out������������������������������������������������0000664�0000000�0000000�00000033252�15100345067�0022233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET max_parallel_workers_per_gather TO 0; \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_hashagg_load.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE metric (id SERIAL PRIMARY KEY, value INT); CREATE TABLE hyper(time TIMESTAMP NOT NULL, time_int BIGINT, time_broken DATE, metricid int, value double precision); CREATE TABLE regular(time TIMESTAMP NOT NULL, time_int BIGINT, time_date DATE, metricid int, value double precision); SELECT create_hypertable('hyper', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE); psql:include/plan_hashagg_load.sql:9: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (1,public,hyper,t) ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time_date DATE; INSERT INTO metric(value) SELECT random()*100 FROM generate_series(0,10); INSERT INTO hyper SELECT t, EXTRACT(EPOCH FROM t), (EXTRACT(EPOCH FROM t)::int % 10)+1, 1.0, t::date FROM generate_series('2001-01-01', '2001-01-10', INTERVAL '1 second') t; INSERT INTO regular(time, time_int, time_date, metricid, value) SELECT t, EXTRACT(EPOCH FROM t), t::date, (EXTRACT(EPOCH FROM t)::int % 10) + 1, 1.0 FROM generate_series('2001-01-01', '2001-01-02', INTERVAL '1 second') t; --test some queries before analyze; EXPLAIN (buffers off, costs off) SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) EXPLAIN (buffers off, costs off) SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> HashAggregate Group Key: date_trunc('minute'::text, _hyper_1_1_chunk."time") -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc(time float8 NOT NULL, metricid int, VALUE double precision, time_date DATE); SELECT create_hypertable('hyper_timefunc', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE, time_partitioning_func => 'unix_to_timestamp'); create_hypertable ----------------------------- (2,public,hyper_timefunc,t) INSERT INTO hyper_timefunc SELECT time_int, metricid, VALUE, time_date FROM hyper; ANALYZE metric; ANALYZE hyper; ANALYZE regular; ANALYZE hyper_timefunc; \ir include/plan_hashagg_query.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. :PREFIX SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 hour', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 hour'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --should be too many groups will not hashaggregate :PREFIX SELECT time_bucket('1 second', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.metricid -> Sort Sort Key: (time_bucket('@ 1 sec'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.metricid -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket(60, time_int, 10) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) -> Sort Sort Key: (time_bucket('60'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT time_bucket('1 day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date)) DESC -> HashAggregate Group Key: time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.time_date) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) :PREFIX SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 0 --can't optimize invalid time unit :PREFIX SELECT date_trunc('invalid', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) -> Sort Sort Key: (date_trunc('invalid'::text, _hyper_1_1_chunk."time")) DESC -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) \set ON_ERROR_STOP 1 :PREFIX SELECT date_trunc('day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- Sort Sort Key: (date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone)) DESC -> HashAggregate Group Key: date_trunc('day'::text, (_hyper_1_1_chunk.time_date)::timestamp with time zone) -> Result -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) --joins --with hypertable, optimize :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(hyper.value) as avg FROM hyper JOIN metric ON (hyper.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, _hyper_1_1_chunk.time_int, '10'::bigint)) DESC, metric.id -> Hash Join Hash Cond: (_hyper_1_1_chunk.metricid = metric.id) -> Seq Scan on _hyper_1_1_chunk Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Hash -> Seq Scan on metric --no hypertable involved, no optimization :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(regular.value) as avg FROM regular JOIN metric ON (regular.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)), metric.id -> Sort Sort Key: (time_bucket('3600'::bigint, regular.time_int, '10'::bigint)) DESC, metric.id -> Nested Loop Join Filter: (metric.id = regular.metricid) -> Seq Scan on regular Filter: (("time" >= 'Thu Jan 04 00:00:00 2001'::timestamp without time zone) AND ("time" <= 'Fri Jan 05 01:00:00 2001'::timestamp without time zone)) -> Seq Scan on metric -- Try with time partitioning function. Currently not optimized for hash aggregates :PREFIX SELECT time_bucket('1 minute', unix_to_timestamp(time)) AS MetricMinuteTs, AVG(value) as avg FROM hyper_timefunc WHERE unix_to_timestamp(time) >= '2001-01-04T00:00:00' AND unix_to_timestamp(time) <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --- QUERY PLAN --- GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) -> Sort Sort Key: (time_bucket('@ 1 min'::interval, to_timestamp(_hyper_2_2_chunk."time"))) DESC -> Result -> Seq Scan on _hyper_2_2_chunk Filter: ((to_timestamp("time") >= 'Thu Jan 04 00:00:00 2001 PST'::timestamp with time zone) AND (to_timestamp("time") <= 'Fri Jan 05 01:00:00 2001 PST'::timestamp with time zone)) \set ECHO none psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone psql:include/plan_hashagg_query.sql:60: ERROR: unit "invalid" not recognized for type timestamp without time zone ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_hypertable_inline.out�����������������������������������������0000664�0000000�0000000�00000010667�15100345067�0024105�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- test hypertable classification when query is in an inlineable function \set PREFIX 'EXPLAIN (buffers off, costs off)' CREATE TABLE test (a int, b bigint NOT NULL); SELECT create_hypertable('public.test', 'b', chunk_time_interval=>10); create_hypertable ------------------- (1,public,test,t) INSERT INTO test SELECT i, i FROM generate_series(1, 20) i; CREATE OR REPLACE FUNCTION test_f(_ts bigint) RETURNS SETOF test LANGUAGE SQL STABLE as $f$ SELECT DISTINCT ON (a) * FROM test WHERE b >= _ts AND b <= _ts + 2 $f$; -- plans must be the same in both cases -- specifically, the first plan should not contain the parent hypertable -- as that is a sign the pruning was not done successfully :PREFIX SELECT * FROM test_f(5); --- QUERY PLAN --- Unique -> Sort Sort Key: _hyper_1_1_chunk.a -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk Index Cond: ((b >= '5'::bigint) AND (b <= '7'::bigint)) :PREFIX SELECT DISTINCT ON (a) * FROM test WHERE b >= 5 AND b <= 5 + 2; --- QUERY PLAN --- Unique -> Sort Sort Key: _hyper_1_1_chunk.a -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk Index Cond: ((b >= 5) AND (b <= 7)) -- test with FOR UPDATE CREATE OR REPLACE FUNCTION test_f(_ts bigint) RETURNS SETOF test LANGUAGE SQL STABLE as $f$ SELECT * FROM test WHERE b >= _ts AND b <= _ts + 2 FOR UPDATE $f$; -- pruning should not be done by TimescaleDb in this case -- specifically, the parent hypertable must exist in the output plan :PREFIX SELECT * FROM test_f(5); --- QUERY PLAN --- Subquery Scan on test_f -> LockRows -> Append -> Seq Scan on test test_1 Filter: ((b >= '5'::bigint) AND (b <= '7'::bigint)) -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk test_2 Index Cond: ((b >= '5'::bigint) AND (b <= '7'::bigint)) :PREFIX SELECT * FROM test WHERE b >= 5 AND b <= 5 + 2 FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on test test_1 Filter: ((b >= 5) AND (b <= 7)) -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk test_2 Index Cond: ((b >= 5) AND (b <= 7)) -- test with CTE -- these cases are just to make sure we're everything is alright with -- the way we identify hypertables to prune chunks - we abuse ctename -- for this purpose. So double-check if we're not breaking plans -- with CTEs here. CREATE OR REPLACE FUNCTION test_f(_ts bigint) RETURNS SETOF test LANGUAGE SQL STABLE as $f$ WITH ct AS MATERIALIZED ( SELECT DISTINCT ON (a) * FROM test WHERE b >= _ts AND b <= _ts + 2 ) SELECT * FROM ct $f$; :PREFIX SELECT * FROM test_f(5); --- QUERY PLAN --- CTE Scan on ct CTE ct -> Unique -> Sort Sort Key: _hyper_1_1_chunk.a -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk Index Cond: ((b >= '5'::bigint) AND (b <= '7'::bigint)) :PREFIX WITH ct AS MATERIALIZED ( SELECT DISTINCT ON (a) * FROM test WHERE b >= 5 AND b <= 5 + 2 ) SELECT * FROM ct; --- QUERY PLAN --- CTE Scan on ct CTE ct -> Unique -> Sort Sort Key: _hyper_1_1_chunk.a -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk Index Cond: ((b >= 5) AND (b <= 7)) -- CTE within CTE :PREFIX WITH ct AS MATERIALIZED ( SELECT * FROM test_f(5) ) SELECT * FROM ct; --- QUERY PLAN --- CTE Scan on ct CTE ct -> CTE Scan on ct ct_1 CTE ct -> Unique -> Sort Sort Key: _hyper_1_1_chunk.a -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk Index Cond: ((b >= '5'::bigint) AND (b <= '7'::bigint)) -- CTE within NO MATERIALIZED CTE :PREFIX WITH ct AS NOT MATERIALIZED ( SELECT * FROM test_f(5) ) SELECT * FROM ct; --- QUERY PLAN --- CTE Scan on ct CTE ct -> Unique -> Sort Sort Key: _hyper_1_1_chunk.a -> Index Scan using _hyper_1_1_chunk_test_b_idx on _hyper_1_1_chunk Index Cond: ((b >= '5'::bigint) AND (b <= '7'::bigint)) �������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_ordered_append-15.out�����������������������������������������0000664�0000000�0000000�00000077150�15100345067�0023606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- we run these with analyze to confirm that nodes that are not -- needed to fulfill the limit are not executed -- unfortunately this doesn't work on PostgreSQL 9.6 which lacks -- the ability to turn off analyze timing summary so we run -- them without ANALYZE on PostgreSQL 9.6, but since LATERAL plans -- are different across versions we need version specific output -- here anyway. \set TEST_BASE_NAME plan_ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_NO_ANALYZE 'EXPLAIN (buffers off, costs off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2000-01-08T0:00:00+0'::timestamptz; END; $BODY$; CREATE TABLE devices(device_id INT PRIMARY KEY, name TEXT); INSERT INTO devices VALUES (1,'Device 1'), (2,'Device 2'), (3,'Device 3'); -- create a second table where we create chunks in reverse order CREATE TABLE ordered_append_reverse(time timestamptz NOT NULL, device_id INT, value float); SELECT create_hypertable('ordered_append_reverse','time'); create_hypertable ------------------------------------- (1,public,ordered_append_reverse,t) INSERT INTO ordered_append_reverse SELECT generate_series('2000-01-18'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 0.5; -- table where dimension column is last column CREATE TABLE IF NOT EXISTS dimension_last( id INT8 NOT NULL, device_id INT NOT NULL, name TEXT NOT NULL, time timestamptz NOT NULL ); SELECT create_hypertable('dimension_last', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (2,public,dimension_last,t) -- table with only dimension column CREATE TABLE IF NOT EXISTS dimension_only( time timestamptz NOT NULL ); SELECT create_hypertable('dimension_only', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (3,public,dimension_only,t) INSERT INTO dimension_last SELECT 1,1,'Device 1',generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-04 23:59:00+0'::timestamptz,'1m'::interval); INSERT INTO dimension_only VALUES ('2000-01-01'), ('2000-01-03'), ('2000-01-05'), ('2000-01-07'); ANALYZE devices; ANALYZE ordered_append_reverse; ANALYZE dimension_last; ANALYZE dimension_only; -- create hypertable with indexes not on all chunks CREATE TABLE ht_missing_indexes(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_missing_indexes','time'); create_hypertable --------------------------------- (4,public,ht_missing_indexes,t) INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 1, 0.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 2, 1.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 3, 2.5; -- drop index from 2nd chunk of ht_missing_indexes SELECT format('%I.%I',i.schemaname,i.indexname) AS "INDEX_NAME" FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable ht ON c.hypertable_id = ht.id INNER JOIN pg_indexes i ON i.schemaname = c.schema_name AND i.tablename=c.table_name WHERE ht.table_name = 'ht_missing_indexes' ORDER BY c.id LIMIT 1 OFFSET 1 \gset DROP INDEX :INDEX_NAME; ANALYZE ht_missing_indexes; -- create hypertable with with dropped columns CREATE TABLE ht_dropped_columns(c1 int, c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_dropped_columns','time'); create_hypertable --------------------------------- (5,public,ht_dropped_columns,t) ALTER TABLE ht_dropped_columns DROP COLUMN c1; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-01'::timestamptz,'2000-01-02'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c2; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-08'::timestamptz,'2000-01-09'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c3; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-15'::timestamptz,'2000-01-16'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c4; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-22'::timestamptz,'2000-01-23'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c5; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-29'::timestamptz,'2000-01-30'::timestamptz,'1m'::interval), 1, 0.5; ANALYZE ht_dropped_columns; CREATE TABLE space2(time timestamptz NOT NULL, device_id int NOT NULL, tag_id int NOT NULL, value float); SELECT create_hypertable('space2','time','device_id',number_partitions:=3); create_hypertable --------------------- (6,public,space2,t) SELECT add_dimension('space2','tag_id',number_partitions:=3); add_dimension ---------------------------- (8,public,space2,tag_id,t) INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 1, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 2, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 3, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 3, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 3, 3.5; ANALYZE space2; CREATE TABLE space3(time timestamptz NOT NULL, x int NOT NULL, y int NOT NULL, z int NOT NULL, value float); SELECT create_hypertable('space3','time','x',number_partitions:=2); create_hypertable --------------------- (7,public,space3,t) SELECT add_dimension('space3','y',number_partitions:=2); add_dimension ------------------------ (11,public,space3,y,t) SELECT add_dimension('space3','z',number_partitions:=2); add_dimension ------------------------ (12,public,space3,z,t) INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2, 1.5; ANALYZE space3; CREATE TABLE sortopt_test(time timestamptz NOT NULL, device TEXT); SELECT create_hypertable('sortopt_test','time',create_default_indexes:=false); create_hypertable --------------------------- (8,public,sortopt_test,t) -- since alpine does not support locales we cant test collations in our ci -- CREATE COLLATION IF NOT EXISTS en_US(LOCALE='en_US.utf8'); -- CREATE INDEX time_device_utf8 ON sortopt_test(time, device COLLATE "en_US"); CREATE INDEX time_device_nullsfirst ON sortopt_test(time, device NULLS FIRST); CREATE INDEX time_device_nullslast ON sortopt_test(time, device DESC NULLS LAST); INSERT INTO sortopt_test SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 'Device 1'; ANALYZE sortopt_test; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- print chunks ordered by time to ensure ordering we want SELECT ht.table_name AS hypertable, c.table_name AS chunk, ds.range_start FROM _timescaledb_catalog.chunk c INNER JOIN LATERAL(SELECT * FROM _timescaledb_catalog.chunk_constraint cc WHERE c.id = cc.chunk_id ORDER BY cc.dimension_slice_id LIMIT 1) cc ON true INNER JOIN _timescaledb_catalog.dimension_slice ds ON ds.id=cc.dimension_slice_id INNER JOIN _timescaledb_catalog.dimension d ON ds.dimension_id = d.id INNER JOIN _timescaledb_catalog.hypertable ht ON d.hypertable_id = ht.id ORDER BY ht.table_name, range_start, chunk; hypertable | chunk | range_start ------------------------+-------------------+---------------------- dimension_last | _hyper_2_4_chunk | 946684800000000 dimension_last | _hyper_2_5_chunk | 946771200000000 dimension_last | _hyper_2_6_chunk | 946857600000000 dimension_last | _hyper_2_7_chunk | 946944000000000 dimension_only | _hyper_3_8_chunk | 946684800000000 dimension_only | _hyper_3_9_chunk | 946857600000000 dimension_only | _hyper_3_10_chunk | 947030400000000 dimension_only | _hyper_3_11_chunk | 947203200000000 ht_dropped_columns | _hyper_5_15_chunk | 946512000000000 ht_dropped_columns | _hyper_5_16_chunk | 947116800000000 ht_dropped_columns | _hyper_5_17_chunk | 947721600000000 ht_dropped_columns | _hyper_5_18_chunk | 948326400000000 ht_dropped_columns | _hyper_5_19_chunk | 948931200000000 ht_missing_indexes | _hyper_4_12_chunk | 946512000000000 ht_missing_indexes | _hyper_4_13_chunk | 947116800000000 ht_missing_indexes | _hyper_4_14_chunk | 947721600000000 ordered_append_reverse | _hyper_1_3_chunk | 946512000000000 ordered_append_reverse | _hyper_1_2_chunk | 947116800000000 ordered_append_reverse | _hyper_1_1_chunk | 947721600000000 sortopt_test | _hyper_8_55_chunk | 946512000000000 sortopt_test | _hyper_8_54_chunk | 947116800000000 space2 | _hyper_6_21_chunk | -9223372036854775808 space2 | _hyper_6_23_chunk | -9223372036854775808 space2 | _hyper_6_25_chunk | -9223372036854775808 space2 | _hyper_6_27_chunk | -9223372036854775808 space2 | _hyper_6_33_chunk | -9223372036854775808 space2 | _hyper_6_29_chunk | 946512000000000 space2 | _hyper_6_31_chunk | 946512000000000 space2 | _hyper_6_35_chunk | 946512000000000 space2 | _hyper_6_37_chunk | 946512000000000 space2 | _hyper_6_20_chunk | 947116800000000 space2 | _hyper_6_22_chunk | 947116800000000 space2 | _hyper_6_24_chunk | 947116800000000 space2 | _hyper_6_26_chunk | 947116800000000 space2 | _hyper_6_28_chunk | 947116800000000 space2 | _hyper_6_30_chunk | 947116800000000 space2 | _hyper_6_32_chunk | 947116800000000 space2 | _hyper_6_34_chunk | 947116800000000 space2 | _hyper_6_36_chunk | 947116800000000 space3 | _hyper_7_39_chunk | -9223372036854775808 space3 | _hyper_7_41_chunk | -9223372036854775808 space3 | _hyper_7_43_chunk | -9223372036854775808 space3 | _hyper_7_45_chunk | -9223372036854775808 space3 | _hyper_7_47_chunk | -9223372036854775808 space3 | _hyper_7_49_chunk | -9223372036854775808 space3 | _hyper_7_51_chunk | -9223372036854775808 space3 | _hyper_7_53_chunk | 946512000000000 space3 | _hyper_7_38_chunk | 947116800000000 space3 | _hyper_7_40_chunk | 947116800000000 space3 | _hyper_7_42_chunk | 947116800000000 space3 | _hyper_7_44_chunk | 947116800000000 space3 | _hyper_7_46_chunk | 947116800000000 space3 | _hyper_7_48_chunk | 947116800000000 space3 | _hyper_7_50_chunk | 947116800000000 space3 | _hyper_7_52_chunk | 947116800000000 -- test ASC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" -> Index Scan Backward using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (never executed) -- test DESC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" DESC -> Index Scan using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d',time), device_id, name FROM dimension_last ORDER BY time_bucket('1d',time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day',time), device_id, name FROM dimension_last ORDER BY 1,2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test with table with only dimension column :PREFIX SELECT * FROM dimension_only ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on dimension_only (actual rows=1.00 loops=1) Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk (never executed) -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk (never executed) -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk (never executed) -- test LEFT JOIN against hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last LEFT JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop Left Join Join Filter: (dimension_last."time" = dimension_only."time") -> Custom Scan (ChunkAppend) on dimension_last Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk -> Materialize -> Append -> Seq Scan on _hyper_3_11_chunk -> Seq Scan on _hyper_3_10_chunk -> Seq Scan on _hyper_3_9_chunk -> Seq Scan on _hyper_3_8_chunk -- test INNER JOIN against non-hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last INNER JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop -> Custom Scan (ChunkAppend) on dimension_only Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk -> Append -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk Index Cond: ("time" = dimension_only."time") -- test join against non-hypertable :PREFIX SELECT * FROM dimension_last INNER JOIN devices USING(device_id) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) Join Filter: (dimension_last.device_id = devices.device_id) -> Custom Scan (ChunkAppend) on dimension_last (actual rows=2.00 loops=1) Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk (never executed) -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk (never executed) -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk (never executed) -> Materialize (actual rows=1.00 loops=2) -> Seq Scan on devices (actual rows=1.00 loops=1) -- test hypertable with index missing on one chunk :PREFIX SELECT time, device_id, value FROM ht_missing_indexes ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" -> Index Scan Backward using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" -> Seq Scan on _hyper_4_13_chunk (never executed) -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE device_id = 2 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" DESC -> Index Scan using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" DESC -> Seq Scan on _hyper_4_13_chunk (never executed) Filter: (device_id = 2) -> Index Scan using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (never executed) Filter: (device_id = 2) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE time > '2000-01-07' ORDER BY time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=10.00 loops=1) Order: ht_missing_indexes."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_4_13_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _hyper_4_13_chunk (actual rows=24477.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5763 -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=1.00 loops=1) Order: ht_dropped_columns."time" -> Index Scan Backward using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (never executed) -> Index Scan Backward using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (never executed) -> Index Scan Backward using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (never executed) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns WHERE device_id = 1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=7205.00 loops=1) Order: ht_dropped_columns."time" DESC -> Index Scan using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -- test hypertable with 2 space dimensions :PREFIX SELECT time, device_id, value FROM space2 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space2 (actual rows=116649.00 loops=1) Order: space2."time" DESC -> Merge Append (actual rows=56169.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_36_chunk_space2_time_idx on _hyper_6_36_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_34_chunk_space2_time_idx on _hyper_6_34_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_32_chunk_space2_time_idx on _hyper_6_32_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_30_chunk_space2_time_idx on _hyper_6_30_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_28_chunk_space2_time_idx on _hyper_6_28_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_26_chunk_space2_time_idx on _hyper_6_26_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_24_chunk_space2_time_idx on _hyper_6_24_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_22_chunk_space2_time_idx on _hyper_6_22_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_20_chunk_space2_time_idx on _hyper_6_20_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=60480.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_37_chunk_space2_time_idx on _hyper_6_37_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_35_chunk_space2_time_idx on _hyper_6_35_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_33_chunk_space2_time_idx on _hyper_6_33_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_31_chunk_space2_time_idx on _hyper_6_31_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_29_chunk_space2_time_idx on _hyper_6_29_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_27_chunk_space2_time_idx on _hyper_6_27_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_25_chunk_space2_time_idx on _hyper_6_25_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_23_chunk_space2_time_idx on _hyper_6_23_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_21_chunk_space2_time_idx on _hyper_6_21_chunk (actual rows=6720.00 loops=1) -- test hypertable with 3 space dimensions :PREFIX SELECT time FROM space3 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space3 (actual rows=103688.00 loops=1) Order: space3."time" DESC -> Merge Append (actual rows=49928.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_52_chunk_space3_time_idx on _hyper_7_52_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_50_chunk_space3_time_idx on _hyper_7_50_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_48_chunk_space3_time_idx on _hyper_7_48_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_46_chunk_space3_time_idx on _hyper_7_46_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_44_chunk_space3_time_idx on _hyper_7_44_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_42_chunk_space3_time_idx on _hyper_7_42_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_40_chunk_space3_time_idx on _hyper_7_40_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_38_chunk_space3_time_idx on _hyper_7_38_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=53760.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_53_chunk_space3_time_idx on _hyper_7_53_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_51_chunk_space3_time_idx on _hyper_7_51_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_49_chunk_space3_time_idx on _hyper_7_49_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_47_chunk_space3_time_idx on _hyper_7_47_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_45_chunk_space3_time_idx on _hyper_7_45_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_43_chunk_space3_time_idx on _hyper_7_43_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_41_chunk_space3_time_idx on _hyper_7_41_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_39_chunk_space3_time_idx on _hyper_7_39_chunk (actual rows=6720.00 loops=1) -- test COLLATION -- cant be tested in our ci because alpine doesnt support locales -- :PREFIX SELECT * FROM sortopt_test ORDER BY time, device COLLATE "en_US.utf8"; -- test NULLS FIRST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device NULLS FIRST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device NULLS FIRST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullsfirst on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullsfirst on _hyper_8_54_chunk (actual rows=6241.00 loops=1) -- test NULLS LAST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device DESC NULLS LAST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device DESC NULLS LAST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullslast on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullslast on _hyper_8_54_chunk (actual rows=6241.00 loops=1) --generate the results into two different files \set ECHO errors ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_ordered_append-16.out�����������������������������������������0000664�0000000�0000000�00000077150�15100345067�0023607�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- we run these with analyze to confirm that nodes that are not -- needed to fulfill the limit are not executed -- unfortunately this doesn't work on PostgreSQL 9.6 which lacks -- the ability to turn off analyze timing summary so we run -- them without ANALYZE on PostgreSQL 9.6, but since LATERAL plans -- are different across versions we need version specific output -- here anyway. \set TEST_BASE_NAME plan_ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_NO_ANALYZE 'EXPLAIN (buffers off, costs off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2000-01-08T0:00:00+0'::timestamptz; END; $BODY$; CREATE TABLE devices(device_id INT PRIMARY KEY, name TEXT); INSERT INTO devices VALUES (1,'Device 1'), (2,'Device 2'), (3,'Device 3'); -- create a second table where we create chunks in reverse order CREATE TABLE ordered_append_reverse(time timestamptz NOT NULL, device_id INT, value float); SELECT create_hypertable('ordered_append_reverse','time'); create_hypertable ------------------------------------- (1,public,ordered_append_reverse,t) INSERT INTO ordered_append_reverse SELECT generate_series('2000-01-18'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 0.5; -- table where dimension column is last column CREATE TABLE IF NOT EXISTS dimension_last( id INT8 NOT NULL, device_id INT NOT NULL, name TEXT NOT NULL, time timestamptz NOT NULL ); SELECT create_hypertable('dimension_last', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (2,public,dimension_last,t) -- table with only dimension column CREATE TABLE IF NOT EXISTS dimension_only( time timestamptz NOT NULL ); SELECT create_hypertable('dimension_only', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (3,public,dimension_only,t) INSERT INTO dimension_last SELECT 1,1,'Device 1',generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-04 23:59:00+0'::timestamptz,'1m'::interval); INSERT INTO dimension_only VALUES ('2000-01-01'), ('2000-01-03'), ('2000-01-05'), ('2000-01-07'); ANALYZE devices; ANALYZE ordered_append_reverse; ANALYZE dimension_last; ANALYZE dimension_only; -- create hypertable with indexes not on all chunks CREATE TABLE ht_missing_indexes(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_missing_indexes','time'); create_hypertable --------------------------------- (4,public,ht_missing_indexes,t) INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 1, 0.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 2, 1.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 3, 2.5; -- drop index from 2nd chunk of ht_missing_indexes SELECT format('%I.%I',i.schemaname,i.indexname) AS "INDEX_NAME" FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable ht ON c.hypertable_id = ht.id INNER JOIN pg_indexes i ON i.schemaname = c.schema_name AND i.tablename=c.table_name WHERE ht.table_name = 'ht_missing_indexes' ORDER BY c.id LIMIT 1 OFFSET 1 \gset DROP INDEX :INDEX_NAME; ANALYZE ht_missing_indexes; -- create hypertable with with dropped columns CREATE TABLE ht_dropped_columns(c1 int, c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_dropped_columns','time'); create_hypertable --------------------------------- (5,public,ht_dropped_columns,t) ALTER TABLE ht_dropped_columns DROP COLUMN c1; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-01'::timestamptz,'2000-01-02'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c2; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-08'::timestamptz,'2000-01-09'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c3; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-15'::timestamptz,'2000-01-16'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c4; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-22'::timestamptz,'2000-01-23'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c5; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-29'::timestamptz,'2000-01-30'::timestamptz,'1m'::interval), 1, 0.5; ANALYZE ht_dropped_columns; CREATE TABLE space2(time timestamptz NOT NULL, device_id int NOT NULL, tag_id int NOT NULL, value float); SELECT create_hypertable('space2','time','device_id',number_partitions:=3); create_hypertable --------------------- (6,public,space2,t) SELECT add_dimension('space2','tag_id',number_partitions:=3); add_dimension ---------------------------- (8,public,space2,tag_id,t) INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 1, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 2, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 3, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 3, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 3, 3.5; ANALYZE space2; CREATE TABLE space3(time timestamptz NOT NULL, x int NOT NULL, y int NOT NULL, z int NOT NULL, value float); SELECT create_hypertable('space3','time','x',number_partitions:=2); create_hypertable --------------------- (7,public,space3,t) SELECT add_dimension('space3','y',number_partitions:=2); add_dimension ------------------------ (11,public,space3,y,t) SELECT add_dimension('space3','z',number_partitions:=2); add_dimension ------------------------ (12,public,space3,z,t) INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2, 1.5; ANALYZE space3; CREATE TABLE sortopt_test(time timestamptz NOT NULL, device TEXT); SELECT create_hypertable('sortopt_test','time',create_default_indexes:=false); create_hypertable --------------------------- (8,public,sortopt_test,t) -- since alpine does not support locales we cant test collations in our ci -- CREATE COLLATION IF NOT EXISTS en_US(LOCALE='en_US.utf8'); -- CREATE INDEX time_device_utf8 ON sortopt_test(time, device COLLATE "en_US"); CREATE INDEX time_device_nullsfirst ON sortopt_test(time, device NULLS FIRST); CREATE INDEX time_device_nullslast ON sortopt_test(time, device DESC NULLS LAST); INSERT INTO sortopt_test SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 'Device 1'; ANALYZE sortopt_test; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- print chunks ordered by time to ensure ordering we want SELECT ht.table_name AS hypertable, c.table_name AS chunk, ds.range_start FROM _timescaledb_catalog.chunk c INNER JOIN LATERAL(SELECT * FROM _timescaledb_catalog.chunk_constraint cc WHERE c.id = cc.chunk_id ORDER BY cc.dimension_slice_id LIMIT 1) cc ON true INNER JOIN _timescaledb_catalog.dimension_slice ds ON ds.id=cc.dimension_slice_id INNER JOIN _timescaledb_catalog.dimension d ON ds.dimension_id = d.id INNER JOIN _timescaledb_catalog.hypertable ht ON d.hypertable_id = ht.id ORDER BY ht.table_name, range_start, chunk; hypertable | chunk | range_start ------------------------+-------------------+---------------------- dimension_last | _hyper_2_4_chunk | 946684800000000 dimension_last | _hyper_2_5_chunk | 946771200000000 dimension_last | _hyper_2_6_chunk | 946857600000000 dimension_last | _hyper_2_7_chunk | 946944000000000 dimension_only | _hyper_3_8_chunk | 946684800000000 dimension_only | _hyper_3_9_chunk | 946857600000000 dimension_only | _hyper_3_10_chunk | 947030400000000 dimension_only | _hyper_3_11_chunk | 947203200000000 ht_dropped_columns | _hyper_5_15_chunk | 946512000000000 ht_dropped_columns | _hyper_5_16_chunk | 947116800000000 ht_dropped_columns | _hyper_5_17_chunk | 947721600000000 ht_dropped_columns | _hyper_5_18_chunk | 948326400000000 ht_dropped_columns | _hyper_5_19_chunk | 948931200000000 ht_missing_indexes | _hyper_4_12_chunk | 946512000000000 ht_missing_indexes | _hyper_4_13_chunk | 947116800000000 ht_missing_indexes | _hyper_4_14_chunk | 947721600000000 ordered_append_reverse | _hyper_1_3_chunk | 946512000000000 ordered_append_reverse | _hyper_1_2_chunk | 947116800000000 ordered_append_reverse | _hyper_1_1_chunk | 947721600000000 sortopt_test | _hyper_8_55_chunk | 946512000000000 sortopt_test | _hyper_8_54_chunk | 947116800000000 space2 | _hyper_6_21_chunk | -9223372036854775808 space2 | _hyper_6_23_chunk | -9223372036854775808 space2 | _hyper_6_25_chunk | -9223372036854775808 space2 | _hyper_6_27_chunk | -9223372036854775808 space2 | _hyper_6_33_chunk | -9223372036854775808 space2 | _hyper_6_29_chunk | 946512000000000 space2 | _hyper_6_31_chunk | 946512000000000 space2 | _hyper_6_35_chunk | 946512000000000 space2 | _hyper_6_37_chunk | 946512000000000 space2 | _hyper_6_20_chunk | 947116800000000 space2 | _hyper_6_22_chunk | 947116800000000 space2 | _hyper_6_24_chunk | 947116800000000 space2 | _hyper_6_26_chunk | 947116800000000 space2 | _hyper_6_28_chunk | 947116800000000 space2 | _hyper_6_30_chunk | 947116800000000 space2 | _hyper_6_32_chunk | 947116800000000 space2 | _hyper_6_34_chunk | 947116800000000 space2 | _hyper_6_36_chunk | 947116800000000 space3 | _hyper_7_39_chunk | -9223372036854775808 space3 | _hyper_7_41_chunk | -9223372036854775808 space3 | _hyper_7_43_chunk | -9223372036854775808 space3 | _hyper_7_45_chunk | -9223372036854775808 space3 | _hyper_7_47_chunk | -9223372036854775808 space3 | _hyper_7_49_chunk | -9223372036854775808 space3 | _hyper_7_51_chunk | -9223372036854775808 space3 | _hyper_7_53_chunk | 946512000000000 space3 | _hyper_7_38_chunk | 947116800000000 space3 | _hyper_7_40_chunk | 947116800000000 space3 | _hyper_7_42_chunk | 947116800000000 space3 | _hyper_7_44_chunk | 947116800000000 space3 | _hyper_7_46_chunk | 947116800000000 space3 | _hyper_7_48_chunk | 947116800000000 space3 | _hyper_7_50_chunk | 947116800000000 space3 | _hyper_7_52_chunk | 947116800000000 -- test ASC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" -> Index Scan Backward using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (never executed) -- test DESC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" DESC -> Index Scan using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d',time), device_id, name FROM dimension_last ORDER BY time_bucket('1d',time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day',time), device_id, name FROM dimension_last ORDER BY 1,2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test with table with only dimension column :PREFIX SELECT * FROM dimension_only ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on dimension_only (actual rows=1.00 loops=1) Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk (never executed) -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk (never executed) -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk (never executed) -- test LEFT JOIN against hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last LEFT JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop Left Join Join Filter: (dimension_last."time" = dimension_only."time") -> Custom Scan (ChunkAppend) on dimension_last Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk -> Materialize -> Append -> Seq Scan on _hyper_3_11_chunk -> Seq Scan on _hyper_3_10_chunk -> Seq Scan on _hyper_3_9_chunk -> Seq Scan on _hyper_3_8_chunk -- test INNER JOIN against non-hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last INNER JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop -> Custom Scan (ChunkAppend) on dimension_only Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk -> Append -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk Index Cond: ("time" = dimension_only."time") -- test join against non-hypertable :PREFIX SELECT * FROM dimension_last INNER JOIN devices USING(device_id) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) Join Filter: (devices.device_id = dimension_last.device_id) -> Custom Scan (ChunkAppend) on dimension_last (actual rows=2.00 loops=1) Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk (never executed) -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk (never executed) -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk (never executed) -> Materialize (actual rows=1.00 loops=2) -> Seq Scan on devices (actual rows=1.00 loops=1) -- test hypertable with index missing on one chunk :PREFIX SELECT time, device_id, value FROM ht_missing_indexes ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" -> Index Scan Backward using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" -> Seq Scan on _hyper_4_13_chunk (never executed) -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE device_id = 2 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" DESC -> Index Scan using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" DESC -> Seq Scan on _hyper_4_13_chunk (never executed) Filter: (device_id = 2) -> Index Scan using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (never executed) Filter: (device_id = 2) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE time > '2000-01-07' ORDER BY time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=10.00 loops=1) Order: ht_missing_indexes."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_4_13_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _hyper_4_13_chunk (actual rows=24477.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5763 -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=1.00 loops=1) Order: ht_dropped_columns."time" -> Index Scan Backward using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (never executed) -> Index Scan Backward using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (never executed) -> Index Scan Backward using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (never executed) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns WHERE device_id = 1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=7205.00 loops=1) Order: ht_dropped_columns."time" DESC -> Index Scan using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -- test hypertable with 2 space dimensions :PREFIX SELECT time, device_id, value FROM space2 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space2 (actual rows=116649.00 loops=1) Order: space2."time" DESC -> Merge Append (actual rows=56169.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_36_chunk_space2_time_idx on _hyper_6_36_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_34_chunk_space2_time_idx on _hyper_6_34_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_32_chunk_space2_time_idx on _hyper_6_32_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_30_chunk_space2_time_idx on _hyper_6_30_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_28_chunk_space2_time_idx on _hyper_6_28_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_26_chunk_space2_time_idx on _hyper_6_26_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_24_chunk_space2_time_idx on _hyper_6_24_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_22_chunk_space2_time_idx on _hyper_6_22_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_20_chunk_space2_time_idx on _hyper_6_20_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=60480.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_37_chunk_space2_time_idx on _hyper_6_37_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_35_chunk_space2_time_idx on _hyper_6_35_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_33_chunk_space2_time_idx on _hyper_6_33_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_31_chunk_space2_time_idx on _hyper_6_31_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_29_chunk_space2_time_idx on _hyper_6_29_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_27_chunk_space2_time_idx on _hyper_6_27_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_25_chunk_space2_time_idx on _hyper_6_25_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_23_chunk_space2_time_idx on _hyper_6_23_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_21_chunk_space2_time_idx on _hyper_6_21_chunk (actual rows=6720.00 loops=1) -- test hypertable with 3 space dimensions :PREFIX SELECT time FROM space3 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space3 (actual rows=103688.00 loops=1) Order: space3."time" DESC -> Merge Append (actual rows=49928.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_52_chunk_space3_time_idx on _hyper_7_52_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_50_chunk_space3_time_idx on _hyper_7_50_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_48_chunk_space3_time_idx on _hyper_7_48_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_46_chunk_space3_time_idx on _hyper_7_46_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_44_chunk_space3_time_idx on _hyper_7_44_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_42_chunk_space3_time_idx on _hyper_7_42_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_40_chunk_space3_time_idx on _hyper_7_40_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_38_chunk_space3_time_idx on _hyper_7_38_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=53760.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_53_chunk_space3_time_idx on _hyper_7_53_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_51_chunk_space3_time_idx on _hyper_7_51_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_49_chunk_space3_time_idx on _hyper_7_49_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_47_chunk_space3_time_idx on _hyper_7_47_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_45_chunk_space3_time_idx on _hyper_7_45_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_43_chunk_space3_time_idx on _hyper_7_43_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_41_chunk_space3_time_idx on _hyper_7_41_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_39_chunk_space3_time_idx on _hyper_7_39_chunk (actual rows=6720.00 loops=1) -- test COLLATION -- cant be tested in our ci because alpine doesnt support locales -- :PREFIX SELECT * FROM sortopt_test ORDER BY time, device COLLATE "en_US.utf8"; -- test NULLS FIRST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device NULLS FIRST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device NULLS FIRST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullsfirst on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullsfirst on _hyper_8_54_chunk (actual rows=6241.00 loops=1) -- test NULLS LAST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device DESC NULLS LAST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device DESC NULLS LAST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullslast on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullslast on _hyper_8_54_chunk (actual rows=6241.00 loops=1) --generate the results into two different files \set ECHO errors ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_ordered_append-17.out�����������������������������������������0000664�0000000�0000000�00000077150�15100345067�0023610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- we run these with analyze to confirm that nodes that are not -- needed to fulfill the limit are not executed -- unfortunately this doesn't work on PostgreSQL 9.6 which lacks -- the ability to turn off analyze timing summary so we run -- them without ANALYZE on PostgreSQL 9.6, but since LATERAL plans -- are different across versions we need version specific output -- here anyway. \set TEST_BASE_NAME plan_ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_NO_ANALYZE 'EXPLAIN (buffers off, costs off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2000-01-08T0:00:00+0'::timestamptz; END; $BODY$; CREATE TABLE devices(device_id INT PRIMARY KEY, name TEXT); INSERT INTO devices VALUES (1,'Device 1'), (2,'Device 2'), (3,'Device 3'); -- create a second table where we create chunks in reverse order CREATE TABLE ordered_append_reverse(time timestamptz NOT NULL, device_id INT, value float); SELECT create_hypertable('ordered_append_reverse','time'); create_hypertable ------------------------------------- (1,public,ordered_append_reverse,t) INSERT INTO ordered_append_reverse SELECT generate_series('2000-01-18'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 0.5; -- table where dimension column is last column CREATE TABLE IF NOT EXISTS dimension_last( id INT8 NOT NULL, device_id INT NOT NULL, name TEXT NOT NULL, time timestamptz NOT NULL ); SELECT create_hypertable('dimension_last', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (2,public,dimension_last,t) -- table with only dimension column CREATE TABLE IF NOT EXISTS dimension_only( time timestamptz NOT NULL ); SELECT create_hypertable('dimension_only', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (3,public,dimension_only,t) INSERT INTO dimension_last SELECT 1,1,'Device 1',generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-04 23:59:00+0'::timestamptz,'1m'::interval); INSERT INTO dimension_only VALUES ('2000-01-01'), ('2000-01-03'), ('2000-01-05'), ('2000-01-07'); ANALYZE devices; ANALYZE ordered_append_reverse; ANALYZE dimension_last; ANALYZE dimension_only; -- create hypertable with indexes not on all chunks CREATE TABLE ht_missing_indexes(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_missing_indexes','time'); create_hypertable --------------------------------- (4,public,ht_missing_indexes,t) INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 1, 0.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 2, 1.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 3, 2.5; -- drop index from 2nd chunk of ht_missing_indexes SELECT format('%I.%I',i.schemaname,i.indexname) AS "INDEX_NAME" FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable ht ON c.hypertable_id = ht.id INNER JOIN pg_indexes i ON i.schemaname = c.schema_name AND i.tablename=c.table_name WHERE ht.table_name = 'ht_missing_indexes' ORDER BY c.id LIMIT 1 OFFSET 1 \gset DROP INDEX :INDEX_NAME; ANALYZE ht_missing_indexes; -- create hypertable with with dropped columns CREATE TABLE ht_dropped_columns(c1 int, c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_dropped_columns','time'); create_hypertable --------------------------------- (5,public,ht_dropped_columns,t) ALTER TABLE ht_dropped_columns DROP COLUMN c1; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-01'::timestamptz,'2000-01-02'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c2; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-08'::timestamptz,'2000-01-09'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c3; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-15'::timestamptz,'2000-01-16'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c4; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-22'::timestamptz,'2000-01-23'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c5; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-29'::timestamptz,'2000-01-30'::timestamptz,'1m'::interval), 1, 0.5; ANALYZE ht_dropped_columns; CREATE TABLE space2(time timestamptz NOT NULL, device_id int NOT NULL, tag_id int NOT NULL, value float); SELECT create_hypertable('space2','time','device_id',number_partitions:=3); create_hypertable --------------------- (6,public,space2,t) SELECT add_dimension('space2','tag_id',number_partitions:=3); add_dimension ---------------------------- (8,public,space2,tag_id,t) INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 1, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 2, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 3, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 3, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 3, 3.5; ANALYZE space2; CREATE TABLE space3(time timestamptz NOT NULL, x int NOT NULL, y int NOT NULL, z int NOT NULL, value float); SELECT create_hypertable('space3','time','x',number_partitions:=2); create_hypertable --------------------- (7,public,space3,t) SELECT add_dimension('space3','y',number_partitions:=2); add_dimension ------------------------ (11,public,space3,y,t) SELECT add_dimension('space3','z',number_partitions:=2); add_dimension ------------------------ (12,public,space3,z,t) INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2, 1.5; ANALYZE space3; CREATE TABLE sortopt_test(time timestamptz NOT NULL, device TEXT); SELECT create_hypertable('sortopt_test','time',create_default_indexes:=false); create_hypertable --------------------------- (8,public,sortopt_test,t) -- since alpine does not support locales we cant test collations in our ci -- CREATE COLLATION IF NOT EXISTS en_US(LOCALE='en_US.utf8'); -- CREATE INDEX time_device_utf8 ON sortopt_test(time, device COLLATE "en_US"); CREATE INDEX time_device_nullsfirst ON sortopt_test(time, device NULLS FIRST); CREATE INDEX time_device_nullslast ON sortopt_test(time, device DESC NULLS LAST); INSERT INTO sortopt_test SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 'Device 1'; ANALYZE sortopt_test; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- print chunks ordered by time to ensure ordering we want SELECT ht.table_name AS hypertable, c.table_name AS chunk, ds.range_start FROM _timescaledb_catalog.chunk c INNER JOIN LATERAL(SELECT * FROM _timescaledb_catalog.chunk_constraint cc WHERE c.id = cc.chunk_id ORDER BY cc.dimension_slice_id LIMIT 1) cc ON true INNER JOIN _timescaledb_catalog.dimension_slice ds ON ds.id=cc.dimension_slice_id INNER JOIN _timescaledb_catalog.dimension d ON ds.dimension_id = d.id INNER JOIN _timescaledb_catalog.hypertable ht ON d.hypertable_id = ht.id ORDER BY ht.table_name, range_start, chunk; hypertable | chunk | range_start ------------------------+-------------------+---------------------- dimension_last | _hyper_2_4_chunk | 946684800000000 dimension_last | _hyper_2_5_chunk | 946771200000000 dimension_last | _hyper_2_6_chunk | 946857600000000 dimension_last | _hyper_2_7_chunk | 946944000000000 dimension_only | _hyper_3_8_chunk | 946684800000000 dimension_only | _hyper_3_9_chunk | 946857600000000 dimension_only | _hyper_3_10_chunk | 947030400000000 dimension_only | _hyper_3_11_chunk | 947203200000000 ht_dropped_columns | _hyper_5_15_chunk | 946512000000000 ht_dropped_columns | _hyper_5_16_chunk | 947116800000000 ht_dropped_columns | _hyper_5_17_chunk | 947721600000000 ht_dropped_columns | _hyper_5_18_chunk | 948326400000000 ht_dropped_columns | _hyper_5_19_chunk | 948931200000000 ht_missing_indexes | _hyper_4_12_chunk | 946512000000000 ht_missing_indexes | _hyper_4_13_chunk | 947116800000000 ht_missing_indexes | _hyper_4_14_chunk | 947721600000000 ordered_append_reverse | _hyper_1_3_chunk | 946512000000000 ordered_append_reverse | _hyper_1_2_chunk | 947116800000000 ordered_append_reverse | _hyper_1_1_chunk | 947721600000000 sortopt_test | _hyper_8_55_chunk | 946512000000000 sortopt_test | _hyper_8_54_chunk | 947116800000000 space2 | _hyper_6_21_chunk | -9223372036854775808 space2 | _hyper_6_23_chunk | -9223372036854775808 space2 | _hyper_6_25_chunk | -9223372036854775808 space2 | _hyper_6_27_chunk | -9223372036854775808 space2 | _hyper_6_33_chunk | -9223372036854775808 space2 | _hyper_6_29_chunk | 946512000000000 space2 | _hyper_6_31_chunk | 946512000000000 space2 | _hyper_6_35_chunk | 946512000000000 space2 | _hyper_6_37_chunk | 946512000000000 space2 | _hyper_6_20_chunk | 947116800000000 space2 | _hyper_6_22_chunk | 947116800000000 space2 | _hyper_6_24_chunk | 947116800000000 space2 | _hyper_6_26_chunk | 947116800000000 space2 | _hyper_6_28_chunk | 947116800000000 space2 | _hyper_6_30_chunk | 947116800000000 space2 | _hyper_6_32_chunk | 947116800000000 space2 | _hyper_6_34_chunk | 947116800000000 space2 | _hyper_6_36_chunk | 947116800000000 space3 | _hyper_7_39_chunk | -9223372036854775808 space3 | _hyper_7_41_chunk | -9223372036854775808 space3 | _hyper_7_43_chunk | -9223372036854775808 space3 | _hyper_7_45_chunk | -9223372036854775808 space3 | _hyper_7_47_chunk | -9223372036854775808 space3 | _hyper_7_49_chunk | -9223372036854775808 space3 | _hyper_7_51_chunk | -9223372036854775808 space3 | _hyper_7_53_chunk | 946512000000000 space3 | _hyper_7_38_chunk | 947116800000000 space3 | _hyper_7_40_chunk | 947116800000000 space3 | _hyper_7_42_chunk | 947116800000000 space3 | _hyper_7_44_chunk | 947116800000000 space3 | _hyper_7_46_chunk | 947116800000000 space3 | _hyper_7_48_chunk | 947116800000000 space3 | _hyper_7_50_chunk | 947116800000000 space3 | _hyper_7_52_chunk | 947116800000000 -- test ASC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" -> Index Scan Backward using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (never executed) -- test DESC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" DESC -> Index Scan using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d',time), device_id, name FROM dimension_last ORDER BY time_bucket('1d',time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day',time), device_id, name FROM dimension_last ORDER BY 1,2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test with table with only dimension column :PREFIX SELECT * FROM dimension_only ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on dimension_only (actual rows=1.00 loops=1) Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk (never executed) -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk (never executed) -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk (never executed) -- test LEFT JOIN against hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last LEFT JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop Left Join Join Filter: (dimension_last."time" = dimension_only."time") -> Custom Scan (ChunkAppend) on dimension_last Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk -> Materialize -> Append -> Seq Scan on _hyper_3_11_chunk -> Seq Scan on _hyper_3_10_chunk -> Seq Scan on _hyper_3_9_chunk -> Seq Scan on _hyper_3_8_chunk -- test INNER JOIN against non-hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last INNER JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop -> Custom Scan (ChunkAppend) on dimension_only Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk -> Append -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk Index Cond: ("time" = dimension_only."time") -- test join against non-hypertable :PREFIX SELECT * FROM dimension_last INNER JOIN devices USING(device_id) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) Join Filter: (devices.device_id = dimension_last.device_id) -> Custom Scan (ChunkAppend) on dimension_last (actual rows=2.00 loops=1) Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk (never executed) -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk (never executed) -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk (never executed) -> Materialize (actual rows=1.00 loops=2) -> Seq Scan on devices (actual rows=1.00 loops=1) -- test hypertable with index missing on one chunk :PREFIX SELECT time, device_id, value FROM ht_missing_indexes ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" -> Index Scan Backward using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" -> Seq Scan on _hyper_4_13_chunk (never executed) -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE device_id = 2 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" DESC -> Index Scan using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" DESC -> Seq Scan on _hyper_4_13_chunk (never executed) Filter: (device_id = 2) -> Index Scan using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (never executed) Filter: (device_id = 2) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE time > '2000-01-07' ORDER BY time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=10.00 loops=1) Order: ht_missing_indexes."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_4_13_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _hyper_4_13_chunk (actual rows=24477.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5763 -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=1.00 loops=1) Order: ht_dropped_columns."time" -> Index Scan Backward using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (never executed) -> Index Scan Backward using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (never executed) -> Index Scan Backward using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (never executed) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns WHERE device_id = 1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=7205.00 loops=1) Order: ht_dropped_columns."time" DESC -> Index Scan using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -- test hypertable with 2 space dimensions :PREFIX SELECT time, device_id, value FROM space2 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space2 (actual rows=116649.00 loops=1) Order: space2."time" DESC -> Merge Append (actual rows=56169.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_36_chunk_space2_time_idx on _hyper_6_36_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_34_chunk_space2_time_idx on _hyper_6_34_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_32_chunk_space2_time_idx on _hyper_6_32_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_30_chunk_space2_time_idx on _hyper_6_30_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_28_chunk_space2_time_idx on _hyper_6_28_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_26_chunk_space2_time_idx on _hyper_6_26_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_24_chunk_space2_time_idx on _hyper_6_24_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_22_chunk_space2_time_idx on _hyper_6_22_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_20_chunk_space2_time_idx on _hyper_6_20_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=60480.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_37_chunk_space2_time_idx on _hyper_6_37_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_35_chunk_space2_time_idx on _hyper_6_35_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_33_chunk_space2_time_idx on _hyper_6_33_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_31_chunk_space2_time_idx on _hyper_6_31_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_29_chunk_space2_time_idx on _hyper_6_29_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_27_chunk_space2_time_idx on _hyper_6_27_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_25_chunk_space2_time_idx on _hyper_6_25_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_23_chunk_space2_time_idx on _hyper_6_23_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_21_chunk_space2_time_idx on _hyper_6_21_chunk (actual rows=6720.00 loops=1) -- test hypertable with 3 space dimensions :PREFIX SELECT time FROM space3 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space3 (actual rows=103688.00 loops=1) Order: space3."time" DESC -> Merge Append (actual rows=49928.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_52_chunk_space3_time_idx on _hyper_7_52_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_50_chunk_space3_time_idx on _hyper_7_50_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_48_chunk_space3_time_idx on _hyper_7_48_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_46_chunk_space3_time_idx on _hyper_7_46_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_44_chunk_space3_time_idx on _hyper_7_44_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_42_chunk_space3_time_idx on _hyper_7_42_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_40_chunk_space3_time_idx on _hyper_7_40_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_38_chunk_space3_time_idx on _hyper_7_38_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=53760.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_53_chunk_space3_time_idx on _hyper_7_53_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_51_chunk_space3_time_idx on _hyper_7_51_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_49_chunk_space3_time_idx on _hyper_7_49_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_47_chunk_space3_time_idx on _hyper_7_47_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_45_chunk_space3_time_idx on _hyper_7_45_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_43_chunk_space3_time_idx on _hyper_7_43_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_41_chunk_space3_time_idx on _hyper_7_41_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_39_chunk_space3_time_idx on _hyper_7_39_chunk (actual rows=6720.00 loops=1) -- test COLLATION -- cant be tested in our ci because alpine doesnt support locales -- :PREFIX SELECT * FROM sortopt_test ORDER BY time, device COLLATE "en_US.utf8"; -- test NULLS FIRST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device NULLS FIRST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device NULLS FIRST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullsfirst on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullsfirst on _hyper_8_54_chunk (actual rows=6241.00 loops=1) -- test NULLS LAST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device DESC NULLS LAST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device DESC NULLS LAST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullslast on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullslast on _hyper_8_54_chunk (actual rows=6241.00 loops=1) --generate the results into two different files \set ECHO errors ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/plan_ordered_append-18.out�����������������������������������������0000664�0000000�0000000�00000077150�15100345067�0023611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- we run these with analyze to confirm that nodes that are not -- needed to fulfill the limit are not executed -- unfortunately this doesn't work on PostgreSQL 9.6 which lacks -- the ability to turn off analyze timing summary so we run -- them without ANALYZE on PostgreSQL 9.6, but since LATERAL plans -- are different across versions we need version specific output -- here anyway. \set TEST_BASE_NAME plan_ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_NO_ANALYZE 'EXPLAIN (buffers off, costs off)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2000-01-08T0:00:00+0'::timestamptz; END; $BODY$; CREATE TABLE devices(device_id INT PRIMARY KEY, name TEXT); INSERT INTO devices VALUES (1,'Device 1'), (2,'Device 2'), (3,'Device 3'); -- create a second table where we create chunks in reverse order CREATE TABLE ordered_append_reverse(time timestamptz NOT NULL, device_id INT, value float); SELECT create_hypertable('ordered_append_reverse','time'); create_hypertable ------------------------------------- (1,public,ordered_append_reverse,t) INSERT INTO ordered_append_reverse SELECT generate_series('2000-01-18'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 0.5; -- table where dimension column is last column CREATE TABLE IF NOT EXISTS dimension_last( id INT8 NOT NULL, device_id INT NOT NULL, name TEXT NOT NULL, time timestamptz NOT NULL ); SELECT create_hypertable('dimension_last', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (2,public,dimension_last,t) -- table with only dimension column CREATE TABLE IF NOT EXISTS dimension_only( time timestamptz NOT NULL ); SELECT create_hypertable('dimension_only', 'time', chunk_time_interval => interval '1day', if_not_exists => True); create_hypertable ----------------------------- (3,public,dimension_only,t) INSERT INTO dimension_last SELECT 1,1,'Device 1',generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-04 23:59:00+0'::timestamptz,'1m'::interval); INSERT INTO dimension_only VALUES ('2000-01-01'), ('2000-01-03'), ('2000-01-05'), ('2000-01-07'); ANALYZE devices; ANALYZE ordered_append_reverse; ANALYZE dimension_last; ANALYZE dimension_only; -- create hypertable with indexes not on all chunks CREATE TABLE ht_missing_indexes(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_missing_indexes','time'); create_hypertable --------------------------------- (4,public,ht_missing_indexes,t) INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 1, 0.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 2, 1.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 3, 2.5; -- drop index from 2nd chunk of ht_missing_indexes SELECT format('%I.%I',i.schemaname,i.indexname) AS "INDEX_NAME" FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable ht ON c.hypertable_id = ht.id INNER JOIN pg_indexes i ON i.schemaname = c.schema_name AND i.tablename=c.table_name WHERE ht.table_name = 'ht_missing_indexes' ORDER BY c.id LIMIT 1 OFFSET 1 \gset DROP INDEX :INDEX_NAME; ANALYZE ht_missing_indexes; -- create hypertable with with dropped columns CREATE TABLE ht_dropped_columns(c1 int, c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_dropped_columns','time'); create_hypertable --------------------------------- (5,public,ht_dropped_columns,t) ALTER TABLE ht_dropped_columns DROP COLUMN c1; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-01'::timestamptz,'2000-01-02'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c2; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-08'::timestamptz,'2000-01-09'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c3; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-15'::timestamptz,'2000-01-16'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c4; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-22'::timestamptz,'2000-01-23'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c5; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-29'::timestamptz,'2000-01-30'::timestamptz,'1m'::interval), 1, 0.5; ANALYZE ht_dropped_columns; CREATE TABLE space2(time timestamptz NOT NULL, device_id int NOT NULL, tag_id int NOT NULL, value float); SELECT create_hypertable('space2','time','device_id',number_partitions:=3); create_hypertable --------------------- (6,public,space2,t) SELECT add_dimension('space2','tag_id',number_partitions:=3); add_dimension ---------------------------- (8,public,space2,tag_id,t) INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 1, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 2, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 3, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 3, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 3, 3.5; ANALYZE space2; CREATE TABLE space3(time timestamptz NOT NULL, x int NOT NULL, y int NOT NULL, z int NOT NULL, value float); SELECT create_hypertable('space3','time','x',number_partitions:=2); create_hypertable --------------------- (7,public,space3,t) SELECT add_dimension('space3','y',number_partitions:=2); add_dimension ------------------------ (11,public,space3,y,t) SELECT add_dimension('space3','z',number_partitions:=2); add_dimension ------------------------ (12,public,space3,z,t) INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2, 1.5; ANALYZE space3; CREATE TABLE sortopt_test(time timestamptz NOT NULL, device TEXT); SELECT create_hypertable('sortopt_test','time',create_default_indexes:=false); create_hypertable --------------------------- (8,public,sortopt_test,t) -- since alpine does not support locales we cant test collations in our ci -- CREATE COLLATION IF NOT EXISTS en_US(LOCALE='en_US.utf8'); -- CREATE INDEX time_device_utf8 ON sortopt_test(time, device COLLATE "en_US"); CREATE INDEX time_device_nullsfirst ON sortopt_test(time, device NULLS FIRST); CREATE INDEX time_device_nullslast ON sortopt_test(time, device DESC NULLS LAST); INSERT INTO sortopt_test SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 'Device 1'; ANALYZE sortopt_test; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- print chunks ordered by time to ensure ordering we want SELECT ht.table_name AS hypertable, c.table_name AS chunk, ds.range_start FROM _timescaledb_catalog.chunk c INNER JOIN LATERAL(SELECT * FROM _timescaledb_catalog.chunk_constraint cc WHERE c.id = cc.chunk_id ORDER BY cc.dimension_slice_id LIMIT 1) cc ON true INNER JOIN _timescaledb_catalog.dimension_slice ds ON ds.id=cc.dimension_slice_id INNER JOIN _timescaledb_catalog.dimension d ON ds.dimension_id = d.id INNER JOIN _timescaledb_catalog.hypertable ht ON d.hypertable_id = ht.id ORDER BY ht.table_name, range_start, chunk; hypertable | chunk | range_start ------------------------+-------------------+---------------------- dimension_last | _hyper_2_4_chunk | 946684800000000 dimension_last | _hyper_2_5_chunk | 946771200000000 dimension_last | _hyper_2_6_chunk | 946857600000000 dimension_last | _hyper_2_7_chunk | 946944000000000 dimension_only | _hyper_3_8_chunk | 946684800000000 dimension_only | _hyper_3_9_chunk | 946857600000000 dimension_only | _hyper_3_10_chunk | 947030400000000 dimension_only | _hyper_3_11_chunk | 947203200000000 ht_dropped_columns | _hyper_5_15_chunk | 946512000000000 ht_dropped_columns | _hyper_5_16_chunk | 947116800000000 ht_dropped_columns | _hyper_5_17_chunk | 947721600000000 ht_dropped_columns | _hyper_5_18_chunk | 948326400000000 ht_dropped_columns | _hyper_5_19_chunk | 948931200000000 ht_missing_indexes | _hyper_4_12_chunk | 946512000000000 ht_missing_indexes | _hyper_4_13_chunk | 947116800000000 ht_missing_indexes | _hyper_4_14_chunk | 947721600000000 ordered_append_reverse | _hyper_1_3_chunk | 946512000000000 ordered_append_reverse | _hyper_1_2_chunk | 947116800000000 ordered_append_reverse | _hyper_1_1_chunk | 947721600000000 sortopt_test | _hyper_8_55_chunk | 946512000000000 sortopt_test | _hyper_8_54_chunk | 947116800000000 space2 | _hyper_6_21_chunk | -9223372036854775808 space2 | _hyper_6_23_chunk | -9223372036854775808 space2 | _hyper_6_25_chunk | -9223372036854775808 space2 | _hyper_6_27_chunk | -9223372036854775808 space2 | _hyper_6_33_chunk | -9223372036854775808 space2 | _hyper_6_29_chunk | 946512000000000 space2 | _hyper_6_31_chunk | 946512000000000 space2 | _hyper_6_35_chunk | 946512000000000 space2 | _hyper_6_37_chunk | 946512000000000 space2 | _hyper_6_20_chunk | 947116800000000 space2 | _hyper_6_22_chunk | 947116800000000 space2 | _hyper_6_24_chunk | 947116800000000 space2 | _hyper_6_26_chunk | 947116800000000 space2 | _hyper_6_28_chunk | 947116800000000 space2 | _hyper_6_30_chunk | 947116800000000 space2 | _hyper_6_32_chunk | 947116800000000 space2 | _hyper_6_34_chunk | 947116800000000 space2 | _hyper_6_36_chunk | 947116800000000 space3 | _hyper_7_39_chunk | -9223372036854775808 space3 | _hyper_7_41_chunk | -9223372036854775808 space3 | _hyper_7_43_chunk | -9223372036854775808 space3 | _hyper_7_45_chunk | -9223372036854775808 space3 | _hyper_7_47_chunk | -9223372036854775808 space3 | _hyper_7_49_chunk | -9223372036854775808 space3 | _hyper_7_51_chunk | -9223372036854775808 space3 | _hyper_7_53_chunk | 946512000000000 space3 | _hyper_7_38_chunk | 947116800000000 space3 | _hyper_7_40_chunk | 947116800000000 space3 | _hyper_7_42_chunk | 947116800000000 space3 | _hyper_7_44_chunk | 947116800000000 space3 | _hyper_7_46_chunk | 947116800000000 space3 | _hyper_7_48_chunk | 947116800000000 space3 | _hyper_7_50_chunk | 947116800000000 space3 | _hyper_7_52_chunk | 947116800000000 -- test ASC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" -> Index Scan Backward using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (never executed) -- test DESC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ordered_append_reverse (actual rows=1.00 loops=1) Order: ordered_append_reverse."time" DESC -> Index Scan using _hyper_1_1_chunk_ordered_append_reverse_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_ordered_append_reverse_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan using _hyper_1_3_chunk_ordered_append_reverse_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d',time), device_id, name FROM dimension_last ORDER BY time_bucket('1d',time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day',time), device_id, name FROM dimension_last ORDER BY 1,2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, dimension_last."time")), dimension_last.device_id Sort Method: top-N heapsort -> Result (actual rows=5760.00 loops=1) -> Append (actual rows=5760.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_6_chunk (actual rows=1440.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=1440.00 loops=1) -- test with table with only dimension column :PREFIX SELECT * FROM dimension_only ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on dimension_only (actual rows=1.00 loops=1) Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk (never executed) -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk (never executed) -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk (never executed) -- test LEFT JOIN against hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last LEFT JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop Left Join Join Filter: (dimension_last."time" = dimension_only."time") -> Custom Scan (ChunkAppend) on dimension_last Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk -> Materialize -> Append -> Seq Scan on _hyper_3_11_chunk -> Seq Scan on _hyper_3_10_chunk -> Seq Scan on _hyper_3_9_chunk -> Seq Scan on _hyper_3_8_chunk -- test INNER JOIN against non-hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last INNER JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit -> Nested Loop -> Custom Scan (ChunkAppend) on dimension_only Order: dimension_only."time" DESC -> Index Only Scan using _hyper_3_11_chunk_dimension_only_time_idx on _hyper_3_11_chunk -> Index Only Scan using _hyper_3_10_chunk_dimension_only_time_idx on _hyper_3_10_chunk -> Index Only Scan using _hyper_3_9_chunk_dimension_only_time_idx on _hyper_3_9_chunk -> Index Only Scan using _hyper_3_8_chunk_dimension_only_time_idx on _hyper_3_8_chunk -> Append -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk Index Cond: ("time" = dimension_only."time") -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk Index Cond: ("time" = dimension_only."time") -- test join against non-hypertable :PREFIX SELECT * FROM dimension_last INNER JOIN devices USING(device_id) ORDER BY dimension_last.time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) Join Filter: (devices.device_id = dimension_last.device_id) -> Custom Scan (ChunkAppend) on dimension_last (actual rows=2.00 loops=1) Order: dimension_last."time" DESC -> Index Scan using _hyper_2_7_chunk_dimension_last_time_idx on _hyper_2_7_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_2_6_chunk_dimension_last_time_idx on _hyper_2_6_chunk (never executed) -> Index Scan using _hyper_2_5_chunk_dimension_last_time_idx on _hyper_2_5_chunk (never executed) -> Index Scan using _hyper_2_4_chunk_dimension_last_time_idx on _hyper_2_4_chunk (never executed) -> Materialize (actual rows=1.00 loops=2) -> Seq Scan on devices (actual rows=1.00 loops=1) -- test hypertable with index missing on one chunk :PREFIX SELECT time, device_id, value FROM ht_missing_indexes ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" -> Index Scan Backward using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" -> Seq Scan on _hyper_4_13_chunk (never executed) -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE device_id = 2 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=1.00 loops=1) Order: ht_missing_indexes."time" DESC -> Index Scan using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Sort (never executed) Sort Key: _hyper_4_13_chunk."time" DESC -> Seq Scan on _hyper_4_13_chunk (never executed) Filter: (device_id = 2) -> Index Scan using _hyper_4_12_chunk_ht_missing_indexes_time_idx on _hyper_4_12_chunk (never executed) Filter: (device_id = 2) -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE time > '2000-01-07' ORDER BY time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on ht_missing_indexes (actual rows=10.00 loops=1) Order: ht_missing_indexes."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_4_13_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _hyper_4_13_chunk (actual rows=24477.00 loops=1) Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5763 -> Index Scan Backward using _hyper_4_14_chunk_ht_missing_indexes_time_idx on _hyper_4_14_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=1.00 loops=1) Order: ht_dropped_columns."time" -> Index Scan Backward using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (never executed) -> Index Scan Backward using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (never executed) -> Index Scan Backward using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (never executed) -> Index Scan Backward using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (never executed) -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns WHERE device_id = 1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on ht_dropped_columns (actual rows=7205.00 loops=1) Order: ht_dropped_columns."time" DESC -> Index Scan using _hyper_5_19_chunk_ht_dropped_columns_time_idx on _hyper_5_19_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_18_chunk_ht_dropped_columns_time_idx on _hyper_5_18_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_17_chunk_ht_dropped_columns_time_idx on _hyper_5_17_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_16_chunk_ht_dropped_columns_time_idx on _hyper_5_16_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_5_15_chunk_ht_dropped_columns_time_idx on _hyper_5_15_chunk (actual rows=1441.00 loops=1) Filter: (device_id = 1) -- test hypertable with 2 space dimensions :PREFIX SELECT time, device_id, value FROM space2 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space2 (actual rows=116649.00 loops=1) Order: space2."time" DESC -> Merge Append (actual rows=56169.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_36_chunk_space2_time_idx on _hyper_6_36_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_34_chunk_space2_time_idx on _hyper_6_34_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_32_chunk_space2_time_idx on _hyper_6_32_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_30_chunk_space2_time_idx on _hyper_6_30_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_28_chunk_space2_time_idx on _hyper_6_28_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_26_chunk_space2_time_idx on _hyper_6_26_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_24_chunk_space2_time_idx on _hyper_6_24_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_22_chunk_space2_time_idx on _hyper_6_22_chunk (actual rows=6241.00 loops=1) -> Index Scan using _hyper_6_20_chunk_space2_time_idx on _hyper_6_20_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=60480.00 loops=1) Sort Key: space2."time" DESC -> Index Scan using _hyper_6_37_chunk_space2_time_idx on _hyper_6_37_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_35_chunk_space2_time_idx on _hyper_6_35_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_33_chunk_space2_time_idx on _hyper_6_33_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_31_chunk_space2_time_idx on _hyper_6_31_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_29_chunk_space2_time_idx on _hyper_6_29_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_27_chunk_space2_time_idx on _hyper_6_27_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_25_chunk_space2_time_idx on _hyper_6_25_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_23_chunk_space2_time_idx on _hyper_6_23_chunk (actual rows=6720.00 loops=1) -> Index Scan using _hyper_6_21_chunk_space2_time_idx on _hyper_6_21_chunk (actual rows=6720.00 loops=1) -- test hypertable with 3 space dimensions :PREFIX SELECT time FROM space3 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space3 (actual rows=103688.00 loops=1) Order: space3."time" DESC -> Merge Append (actual rows=49928.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_52_chunk_space3_time_idx on _hyper_7_52_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_50_chunk_space3_time_idx on _hyper_7_50_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_48_chunk_space3_time_idx on _hyper_7_48_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_46_chunk_space3_time_idx on _hyper_7_46_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_44_chunk_space3_time_idx on _hyper_7_44_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_42_chunk_space3_time_idx on _hyper_7_42_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_40_chunk_space3_time_idx on _hyper_7_40_chunk (actual rows=6241.00 loops=1) -> Index Only Scan using _hyper_7_38_chunk_space3_time_idx on _hyper_7_38_chunk (actual rows=6241.00 loops=1) -> Merge Append (actual rows=53760.00 loops=1) Sort Key: space3."time" DESC -> Index Only Scan using _hyper_7_53_chunk_space3_time_idx on _hyper_7_53_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_51_chunk_space3_time_idx on _hyper_7_51_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_49_chunk_space3_time_idx on _hyper_7_49_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_47_chunk_space3_time_idx on _hyper_7_47_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_45_chunk_space3_time_idx on _hyper_7_45_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_43_chunk_space3_time_idx on _hyper_7_43_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_41_chunk_space3_time_idx on _hyper_7_41_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_7_39_chunk_space3_time_idx on _hyper_7_39_chunk (actual rows=6720.00 loops=1) -- test COLLATION -- cant be tested in our ci because alpine doesnt support locales -- :PREFIX SELECT * FROM sortopt_test ORDER BY time, device COLLATE "en_US.utf8"; -- test NULLS FIRST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device NULLS FIRST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device NULLS FIRST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullsfirst on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullsfirst on _hyper_8_54_chunk (actual rows=6241.00 loops=1) -- test NULLS LAST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device DESC NULLS LAST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on sortopt_test (actual rows=12961.00 loops=1) Order: sortopt_test."time", sortopt_test.device DESC NULLS LAST -> Index Only Scan using _hyper_8_55_chunk_time_device_nullslast on _hyper_8_55_chunk (actual rows=6720.00 loops=1) -> Index Only Scan using _hyper_8_54_chunk_time_device_nullslast on _hyper_8_54_chunk (actual rows=6241.00 loops=1) --generate the results into two different files \set ECHO errors ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/query.out����������������������������������������������������������0000664�0000000�0000000�00000042011�15100345067�0020527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME query SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (buffers OFF, costs OFF)' \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC.hyper_1 ( time TIMESTAMP NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain" ON PUBLIC.hyper_1 (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1"'::regclass, 'time'::name, number_partitions => 1, create_default_indexes=>false); psql:include/query_load.sql:13: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper_1 | t INSERT INTO hyper_1 SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1 SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.hyper_1_tz ( time TIMESTAMPTZ NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_tz" ON PUBLIC.hyper_1_tz (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1_tz"'::regclass, 'time'::name, number_partitions => 1, create_default_indexes=>false); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_1_tz | t INSERT INTO hyper_1_tz SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1_tz SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.hyper_1_int ( time int NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_int" ON PUBLIC.hyper_1_int (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1_int"'::regclass, 'time'::name, number_partitions => 1, chunk_time_interval=>10000, create_default_indexes=>FALSE); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 3 | public | hyper_1_int | t INSERT INTO hyper_1_int SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1_int SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.hyper_1_date ( time date NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_date" ON PUBLIC.hyper_1_date (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1_date"'::regclass, 'time'::name, number_partitions => 1, chunk_time_interval=>86400000000, create_default_indexes=>FALSE); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 4 | public | hyper_1_date | t INSERT INTO hyper_1_date SELECT to_timestamp(ser)::date, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1_date SELECT to_timestamp(ser)::date, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; --below needed to create enough unique dates to trigger an index scan INSERT INTO hyper_1_date SELECT to_timestamp(ser*100)::date, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.plain_table ( time TIMESTAMPTZ NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_plain_table" ON PUBLIC.plain_table (time DESC, series_0); INSERT INTO plain_table SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO plain_table SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; -- Table with a time partitioning function CREATE TABLE PUBLIC.hyper_timefunc ( time float8 NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE INDEX "time_plain_timefunc" ON PUBLIC.hyper_timefunc (to_timestamp(time) DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_timefunc"'::regclass, 'time'::name, number_partitions => 1, create_default_indexes=>false, time_partitioning_func => 'unix_to_timestamp'); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 5 | public | hyper_timefunc | t INSERT INTO hyper_timefunc SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_timefunc SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; ANALYZE plain_table; ANALYZE hyper_timefunc; ANALYZE hyper_1; ANALYZE hyper_1_tz; ANALYZE hyper_1_int; ANALYZE hyper_1_date; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SHOW timescaledb.enable_optimizations; timescaledb.enable_optimizations ---------------------------------- on --non-aggregates use MergeAppend in both optimized and non-optimized :PREFIX SELECT * FROM hyper_1 ORDER BY "time" DESC limit 2; --- QUERY PLAN --- Limit -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT * FROM hyper_timefunc ORDER BY unix_to_timestamp("time") DESC limit 2; --- QUERY PLAN --- Limit -> Index Scan using _hyper_5_19_chunk_time_plain_timefunc on _hyper_5_19_chunk --Aggregates use MergeAppend only in optimized :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_date GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('minute'::text, (hyper_1_date."time")::timestamp with time zone)) -> Result -> Merge Append Sort Key: (date_trunc('minute'::text, (hyper_1_date."time")::timestamp with time zone)) DESC -> Index Scan using _hyper_4_6_chunk_time_plain_date on _hyper_4_6_chunk -> Index Scan using _hyper_4_7_chunk_time_plain_date on _hyper_4_7_chunk -> Index Scan using _hyper_4_8_chunk_time_plain_date on _hyper_4_8_chunk -> Index Scan using _hyper_4_9_chunk_time_plain_date on _hyper_4_9_chunk -> Index Scan using _hyper_4_10_chunk_time_plain_date on _hyper_4_10_chunk -> Index Scan using _hyper_4_11_chunk_time_plain_date on _hyper_4_11_chunk -> Index Scan using _hyper_4_12_chunk_time_plain_date on _hyper_4_12_chunk -> Index Scan using _hyper_4_13_chunk_time_plain_date on _hyper_4_13_chunk -> Index Scan using _hyper_4_14_chunk_time_plain_date on _hyper_4_14_chunk -> Index Scan using _hyper_4_15_chunk_time_plain_date on _hyper_4_15_chunk -> Index Scan using _hyper_4_16_chunk_time_plain_date on _hyper_4_16_chunk -> Index Scan using _hyper_4_17_chunk_time_plain_date on _hyper_4_17_chunk -> Index Scan using _hyper_4_18_chunk_time_plain_date on _hyper_4_18_chunk --the minute and second results should be diff :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT date_trunc('second', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('second'::text, _hyper_1_1_chunk."time")) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk --test that when index on time used by constraint, still works correctly :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 WHERE time < to_timestamp(900) GROUP BY t ORDER BY t DESC LIMIT 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('minute'::text, hyper_1."time")) -> Result -> Custom Scan (ChunkAppend) on hyper_1 Order: date_trunc('minute'::text, hyper_1."time") DESC Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk Index Cond: ("time" < 'Wed Dec 31 16:15:00 1969 PST'::timestamp with time zone) --test on table with time partitioning function. Currently not --optimized to use index for ordering since the index is an expression --on time (e.g., timefunc(time)), and we currently don't handle that --case. :PREFIX SELECT date_trunc('minute', to_timestamp(time)) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_timefunc WHERE to_timestamp(time) < to_timestamp(900) GROUP BY t ORDER BY t DESC LIMIT 2; --- QUERY PLAN --- Limit -> Sort Sort Key: (date_trunc('minute'::text, to_timestamp(_hyper_5_19_chunk."time"))) DESC -> HashAggregate Group Key: date_trunc('minute'::text, to_timestamp(_hyper_5_19_chunk."time")) -> Result -> Index Scan using _hyper_5_19_chunk_time_plain_timefunc on _hyper_5_19_chunk Index Cond: (to_timestamp("time") < 'Wed Dec 31 16:15:00 1969 PST'::timestamp with time zone) BEGIN; --test that still works with an expression index on data_trunc. DROP INDEX "time_plain"; CREATE INDEX "time_trunc" ON PUBLIC.hyper_1 (date_trunc('minute', time)); ANALYZE hyper_1; :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Result -> Index Scan Backward using _hyper_1_1_chunk_time_trunc on _hyper_1_1_chunk --test that works with both indexes CREATE INDEX "time_plain" ON PUBLIC.hyper_1 (time DESC, series_0); ANALYZE hyper_1; :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (date_trunc('minute'::text, _hyper_1_1_chunk."time")) -> Result -> Index Scan Backward using _hyper_1_1_chunk_time_trunc on _hyper_1_1_chunk :PREFIX SELECT time_bucket('1 minute', time) t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric, 5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric,5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time", '@ 30 secs'::interval)) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT time_bucket('1 minute', time - INTERVAL '30 seconds') t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric,5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, (_hyper_1_1_chunk."time" - '@ 30 secs'::interval))) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT time_bucket('1 minute', time - INTERVAL '30 seconds') + INTERVAL '30 seconds' t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric,5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: ((time_bucket('@ 1 min'::interval, (_hyper_1_1_chunk."time" - '@ 30 secs'::interval)) + '@ 30 secs'::interval)) -> Result -> Index Scan using _hyper_1_1_chunk_time_plain on _hyper_1_1_chunk :PREFIX SELECT time_bucket('1 minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_tz GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, _hyper_2_2_chunk."time")) -> Result -> Index Scan using _hyper_2_2_chunk_time_plain_tz on _hyper_2_2_chunk :PREFIX SELECT time_bucket('1 minute', time::timestamp) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_tz GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket('@ 1 min'::interval, (_hyper_2_2_chunk."time")::timestamp without time zone)) -> Result -> Index Scan using _hyper_2_2_chunk_time_plain_tz on _hyper_2_2_chunk :PREFIX SELECT time_bucket(10, time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_int GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket(10, hyper_1_int."time")) -> Result -> Custom Scan (ChunkAppend) on hyper_1_int Order: time_bucket(10, hyper_1_int."time") DESC -> Index Scan using _hyper_3_5_chunk_time_plain_int on _hyper_3_5_chunk -> Index Scan using _hyper_3_4_chunk_time_plain_int on _hyper_3_4_chunk -> Index Scan using _hyper_3_3_chunk_time_plain_int on _hyper_3_3_chunk :PREFIX SELECT time_bucket(10, time, 2) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_int GROUP BY t ORDER BY t DESC limit 2; --- QUERY PLAN --- Limit -> GroupAggregate Group Key: (time_bucket(10, hyper_1_int."time", 2)) -> Result -> Custom Scan (ChunkAppend) on hyper_1_int Order: time_bucket(10, hyper_1_int."time", 2) DESC -> Index Scan using _hyper_3_5_chunk_time_plain_int on _hyper_3_5_chunk -> Index Scan using _hyper_3_4_chunk_time_plain_int on _hyper_3_4_chunk -> Index Scan using _hyper_3_3_chunk_time_plain_int on _hyper_3_3_chunk ROLLBACK; -- sort order optimization should not be applied to non-hypertables :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM plain_table WHERE time < to_timestamp(900) GROUP BY t ORDER BY t DESC LIMIT 2; --- QUERY PLAN --- Limit -> Sort Sort Key: (date_trunc('minute'::text, "time")) DESC -> HashAggregate Group Key: date_trunc('minute'::text, "time") -> Index Scan using time_plain_plain_table on plain_table Index Cond: ("time" < 'Wed Dec 31 16:15:00 1969 PST'::timestamp with time zone) --generate the results into two different files \set ECHO errors --- Unoptimized result +++ Optimized result @@ -1,6 +1,6 @@ timescaledb.enable_optimizations ---------------------------------- - off + on time | series_0 | series_1 | series_2 ?column? ---------- Done �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/relocate_extension.out���������������������������������������������0000664�0000000�0000000�00000017644�15100345067�0023272�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH 'include/query_result_test_equal.sql' \c postgres :ROLE_SUPERUSER DROP DATABASE :TEST_DBNAME WITH (FORCE); CREATE DATABASE :TEST_DBNAME; \c :TEST_DBNAME CREATE SCHEMA "testSchema0"; SET client_min_messages=error; CREATE EXTENSION IF NOT EXISTS timescaledb SCHEMA "testSchema0"; RESET client_min_messages; CREATE TABLE test_ts(time timestamp, temp float8, device text); CREATE TABLE test_tz(time timestamptz, temp float8, device text); CREATE TABLE test_dt(time date, temp float8, device text); SELECT "testSchema0".create_hypertable('test_ts', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------- (1,public,test_ts,t) SELECT "testSchema0".create_hypertable('test_tz', 'time', 'device', 2); create_hypertable ---------------------- (2,public,test_tz,t) SELECT "testSchema0".create_hypertable('test_dt', 'time', 'device', 2); create_hypertable ---------------------- (3,public,test_dt,t) SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | test_ts | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 2 | public | test_tz | _timescaledb_internal | _hyper_2 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 3 | public | test_dt | _timescaledb_internal | _hyper_3 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 INSERT INTO test_ts VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_ts VALUES('Mon Mar 20 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_ts VALUES('Mon Mar 20 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_ts VALUES('Mon Mar 20 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_ts ORDER BY time; time | temp | device ---------------------------------+------+-------- Mon Mar 20 09:17:00.936242 2017 | 23.4 | dev1 Mon Mar 20 09:27:00.936242 2017 | 22 | dev2 Mon Mar 20 09:28:00.936242 2017 | 21.2 | dev1 Mon Mar 20 09:37:00.936242 2017 | 30 | dev3 INSERT INTO test_tz VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_tz VALUES('Mon Mar 20 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_tz ORDER BY time; time | temp | device -------------------------------------+------+-------- Mon Mar 20 09:17:00.936242 2017 PDT | 23.4 | dev1 Mon Mar 20 09:27:00.936242 2017 PDT | 22 | dev2 Mon Mar 20 09:28:00.936242 2017 PDT | 21.2 | dev1 Mon Mar 20 09:37:00.936242 2017 PDT | 30 | dev3 INSERT INTO test_dt VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_dt VALUES('Mon Mar 21 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_dt VALUES('Mon Mar 22 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_dt VALUES('Mon Mar 23 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_dt ORDER BY time; time | temp | device ------------+------+-------- 03-20-2017 | 23.4 | dev1 03-21-2017 | 22 | dev2 03-22-2017 | 21.2 | dev1 03-23-2017 | 30 | dev3 -- testing time_bucket START SELECT AVG(temp) AS avg_tmp, "testSchema0".time_bucket('5 minutes', time, INTERVAL '1 minutes') AS ten_min FROM test_ts GROUP BY ten_min ORDER BY avg_tmp; avg_tmp | ten_min ---------+-------------------------- 21.6 | Mon Mar 20 09:26:00 2017 23.4 | Mon Mar 20 09:16:00 2017 30 | Mon Mar 20 09:36:00 2017 SELECT AVG(temp) AS avg_tmp, "testSchema0".time_bucket('5 minutes', time, INTERVAL '1 minutes') AS ten_min FROM test_tz GROUP BY ten_min ORDER BY avg_tmp; avg_tmp | ten_min ---------+------------------------------ 21.6 | Mon Mar 20 09:26:00 2017 PDT 23.4 | Mon Mar 20 09:16:00 2017 PDT 30 | Mon Mar 20 09:36:00 2017 PDT SELECT AVG(temp) AS avg_tmp, "testSchema0".time_bucket('1 day', time, INTERVAL '-0.5 day') AS ten_min FROM test_dt GROUP BY ten_min ORDER BY avg_tmp; avg_tmp | ten_min ---------+------------ 21.2 | 03-21-2017 22 | 03-20-2017 23.4 | 03-19-2017 30 | 03-22-2017 -- testing time_bucket END -- testing drop_chunks START -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT "testSchema0".show_chunks(older_than => \'2017-03-01\'::timestamp, relation => \'test_ts\')::REGCLASS::TEXT' \set QUERY2 'SELECT "testSchema0".drop_chunks(\'test_ts\', \'2017-03-01\'::timestamp)::TEXT' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 0 | 0 SELECT * FROM test_ts ORDER BY time; time | temp | device ---------------------------------+------+-------- Mon Mar 20 09:17:00.936242 2017 | 23.4 | dev1 Mon Mar 20 09:27:00.936242 2017 | 22 | dev2 Mon Mar 20 09:28:00.936242 2017 | 21.2 | dev1 Mon Mar 20 09:37:00.936242 2017 | 30 | dev3 \set QUERY1 'SELECT "testSchema0".show_chunks(older_than => interval \'1 minutes\', relation => \'test_tz\')::REGCLASS::TEXT' \set QUERY2 'SELECT "testSchema0".drop_chunks(\'test_tz\', interval \'1 minutes\')::TEXT' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 2 | 2 SELECT * FROM test_tz ORDER BY time; time | temp | device ------+------+-------- \set QUERY1 'SELECT "testSchema0".show_chunks(older_than => interval \'1 minutes\', relation => \'test_dt\')::REGCLASS::TEXT' \set QUERY2 'SELECT "testSchema0".drop_chunks(\'test_dt\', interval \'1 minutes\')::TEXT' \set ECHO errors Different Rows | Total Rows from Query 1 | Total Rows from Query 2 ----------------+-------------------------+------------------------- 0 | 3 | 3 SELECT * FROM test_dt ORDER BY time; time | temp | device ------+------+-------- -- testing drop_chunks END -- testing hypertable_detailed_size START SELECT * FROM "testSchema0".hypertable_detailed_size('test_ts'); table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 16384 | 81920 | 24576 | 122880 | -- testing hypertable_detailed_size END SELECT * FROM "testSchema0".hypertable_index_size('test_ts_time_idx'); hypertable_index_size ----------------------- 40960 SELECT * FROM "testSchema0".hypertable_index_size('test_ts_device_time_idx'); hypertable_index_size ----------------------- 40960 CREATE SCHEMA "testSchema"; \set ON_ERROR_STOP 0 ALTER EXTENSION timescaledb SET SCHEMA "testSchema"; ERROR: extension "timescaledb" does not support SET SCHEMA \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/reloptions.out�����������������������������������������������������0000664�0000000�0000000�00000004423�15100345067�0021565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE reloptions_test(time integer, temp float8, color integer) WITH (fillfactor=75, autovacuum_vacuum_threshold=100); SELECT create_hypertable('reloptions_test', 'time', chunk_time_interval => 3); create_hypertable ------------------------------ (1,public,reloptions_test,t) INSERT INTO reloptions_test VALUES (4, 24.3, 1), (9, 13.3, 2); -- Show that reloptions are inherited by chunks SELECT relname, reloptions FROM pg_class WHERE relname ~ '^_hyper.*' AND relkind = 'r'; relname | reloptions ------------------+------------------------------------------------- _hyper_1_1_chunk | {fillfactor=75,autovacuum_vacuum_threshold=100} _hyper_1_2_chunk | {fillfactor=75,autovacuum_vacuum_threshold=100} -- Alter reloptions. We support multiple options for the ALTER TABLE ALTER TABLE reloptions_test SET (fillfactor=80, parallel_workers=8); ALTER TABLE reloptions_test SET (fillfactor=80), SET (parallel_workers=8); SELECT relname, reloptions FROM pg_class WHERE relname ~ '^_hyper.*' AND relkind = 'r'; relname | reloptions ------------------+-------------------------------------------------------------------- _hyper_1_1_chunk | {autovacuum_vacuum_threshold=100,fillfactor=80,parallel_workers=8} _hyper_1_2_chunk | {autovacuum_vacuum_threshold=100,fillfactor=80,parallel_workers=8} ALTER TABLE reloptions_test RESET (fillfactor); SELECT relname, reloptions FROM pg_class WHERE relname ~ '^_hyper.*' AND relkind = 'r'; relname | reloptions ------------------+------------------------------------------------------ _hyper_1_1_chunk | {autovacuum_vacuum_threshold=100,parallel_workers=8} _hyper_1_2_chunk | {autovacuum_vacuum_threshold=100,parallel_workers=8} -- Test reloptions on a regular table CREATE TABLE reloptions_test2(time integer, temp float8, color integer); ALTER TABLE reloptions_test2 SET (fillfactor=80, parallel_workers=8); ALTER TABLE reloptions_test2 SET (fillfactor=80), SET (parallel_workers=8); DROP TABLE reloptions_test2; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/repair.out���������������������������������������������������������0000664�0000000�0000000�00000005100�15100345067�0020642�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- We are testing different repair functions here to make sure that -- they work as expected. \c :TEST_DBNAME :ROLE_SUPERUSER \set TMP_USER :TEST_DBNAME _wizard CREATE USER :TMP_USER; CREATE USER "Random L User"; CREATE TABLE test_table_1(time timestamptz not null, temp float); SELECT create_hypertable('test_table_1', by_range('time', '1 day'::interval)); create_hypertable ------------------- (1,t) INSERT INTO test_table_1(time,temp) SELECT time, 100 * random() FROM generate_series( '2000-01-01'::timestamptz, '2000-01-05'::timestamptz, '1min'::interval ) time; CREATE TABLE test_table_2(time timestamptz not null, temp float); SELECT create_hypertable('test_table_2', by_range('time', '1 day'::interval)); create_hypertable ------------------- (2,t) INSERT INTO test_table_2(time,temp) SELECT time, 100 * random() FROM generate_series( '2000-01-01'::timestamptz, '2000-01-05'::timestamptz, '1min'::interval ) time; GRANT ALL ON test_table_1 TO :TMP_USER; GRANT ALL ON test_table_2 TO :TMP_USER; GRANT SELECT, INSERT ON test_table_1 TO "Random L User"; GRANT INSERT ON test_table_2 TO "Random L User"; -- Break the relacl of the table by deleting users DELETE FROM pg_authid WHERE rolname IN (:'TMP_USER', 'Random L User'); CREATE TABLE saved (LIKE pg_class); INSERT INTO saved SELECT * FROM pg_class; CALL _timescaledb_functions.repair_relation_acls(); -- The only thing we should see here are the relations we broke and -- the privileges we added for that user. No other relations should be -- touched. WITH lhs AS (SELECT oid, aclexplode(relacl) FROM pg_class), rhs AS (SELECT oid, aclexplode(relacl) FROM saved) SELECT rhs.oid::regclass FROM lhs FULL OUTER JOIN rhs ON row(lhs) = row(rhs) WHERE lhs.oid IS NULL AND rhs.oid IS NOT NULL GROUP BY rhs.oid; oid ----------------------------------------- test_table_1 _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk test_table_2 _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk DROP TABLE saved; DROP TABLE test_table_1; DROP TABLE test_table_2; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/rowsecurity-15.out�������������������������������������������������0000664�0000000�0000000�00000553346�15100345067�0022226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Test of Row-level security feature -- -- Clean up in case a prior regression run failed \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET timescaledb.enable_constraint_exclusion TO off; -- Suppress NOTICE messages when users/groups don't exist SET client_min_messages TO 'warning'; DROP USER IF EXISTS regress_rls_alice; DROP USER IF EXISTS regress_rls_bob; DROP USER IF EXISTS regress_rls_carol; DROP USER IF EXISTS regress_rls_dave; DROP USER IF EXISTS regress_rls_exempt_user; DROP ROLE IF EXISTS regress_rls_group1; DROP ROLE IF EXISTS regress_rls_group2; DROP SCHEMA IF EXISTS regress_rls_schema CASCADE; RESET client_min_messages; -- initial setup CREATE USER regress_rls_alice NOLOGIN; CREATE USER regress_rls_bob NOLOGIN; CREATE USER regress_rls_carol NOLOGIN; CREATE USER regress_rls_dave NOLOGIN; CREATE USER regress_rls_exempt_user BYPASSRLS NOLOGIN; CREATE ROLE regress_rls_group1 NOLOGIN; CREATE ROLE regress_rls_group2 NOLOGIN; GRANT regress_rls_group1 TO regress_rls_bob; GRANT regress_rls_group2 TO regress_rls_carol; CREATE SCHEMA regress_rls_schema; GRANT ALL ON SCHEMA regress_rls_schema to public; SET search_path = regress_rls_schema; -- setup of malicious function CREATE OR REPLACE FUNCTION f_leak(text) RETURNS bool COST 0.0000001 LANGUAGE plpgsql AS 'BEGIN RAISE NOTICE ''f_leak => %'', $1; RETURN true; END'; GRANT EXECUTE ON FUNCTION f_leak(text) TO public; -- BASIC Row-Level Security Scenario SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE uaccount ( pguser name primary key, seclv int ); GRANT SELECT ON uaccount TO public; INSERT INTO uaccount VALUES ('regress_rls_alice', 99), ('regress_rls_bob', 1), ('regress_rls_carol', 2), ('regress_rls_dave', 3); CREATE TABLE category ( cid int primary key, cname text ); GRANT ALL ON category TO public; INSERT INTO category VALUES (11, 'novel'), (22, 'science fiction'), (33, 'technology'), (44, 'manga'); CREATE TABLE document ( did int primary key, cid int references category(cid), dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON document TO public; SELECT public.create_hypertable('document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------- (1,regress_rls_schema,document,t) INSERT INTO document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 22, 2, 'regress_rls_bob', 'my science fiction'), ( 4, 44, 1, 'regress_rls_bob', 'my first manga'), ( 5, 44, 2, 'regress_rls_bob', 'my second manga'), ( 6, 22, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 33, 2, 'regress_rls_carol', 'great technology book'), ( 8, 44, 1, 'regress_rls_carol', 'great manga'), ( 9, 22, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 33, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE document ENABLE ROW LEVEL SECURITY; -- user's security level must be higher than or equal to document's CREATE POLICY p1 ON document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- try to create a policy of bogus type CREATE POLICY p1 ON document AS UGLY USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); ERROR: unrecognized row security option "ugly" LINE 1: CREATE POLICY p1 ON document AS UGLY ^ HINT: Only PERMISSIVE or RESTRICTIVE policies are supported currently. -- but Dave isn't allowed to anything at cid 50 or above -- this is to make sure that we sort the policies by name first -- when applying WITH CHECK, a later INSERT by Dave should fail due -- to p1r first CREATE POLICY p2r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44 AND cid < 50); -- and Dave isn't allowed to see manga documents CREATE POLICY p1r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44); \dp Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------------------+----------+-------+---------------------------------------------+-------------------+-------------------------------------------- regress_rls_schema | category | table | regress_rls_alice=arwdDxt/regress_rls_alice+| | | | | =arwdDxt/regress_rls_alice | | regress_rls_schema | document | table | regress_rls_alice=arwdDxt/regress_rls_alice+| | p1: + | | | =arwdDxt/regress_rls_alice | | (u): (dlevel <= ( SELECT uaccount.seclv + | | | | | FROM uaccount + | | | | | WHERE (uaccount.pguser = CURRENT_USER)))+ | | | | | p2r (RESTRICTIVE): + | | | | | (u): ((cid <> 44) AND (cid < 50)) + | | | | | to: regress_rls_dave + | | | | | p1r (RESTRICTIVE): + | | | | | (u): (cid <> 44) + | | | | | to: regress_rls_dave regress_rls_schema | uaccount | table | regress_rls_alice=arwdDxt/regress_rls_alice+| | | | | =r/regress_rls_alice | | \d document Table "regress_rls_schema.document" Column | Type | Collation | Nullable | Default ---------+---------+-----------+----------+--------- did | integer | | not null | cid | integer | | | dlevel | integer | | not null | dauthor | name | | | dtitle | text | | | Indexes: "document_pkey" PRIMARY KEY, btree (did) Foreign-key constraints: "document_cid_fkey" FOREIGN KEY (cid) REFERENCES category(cid) Policies: POLICY "p1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "p1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid <> 44)) POLICY "p2r" AS RESTRICTIVE TO regress_rls_dave USING (((cid <> 44) AND (cid < 50))) Number of child tables: 6 (Use \d+ to list them.) SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename = 'document' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+-----------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | document | p1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | document | p1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid <> 44) | regress_rls_schema | document | p2r | RESTRICTIVE | {regress_rls_dave} | ALL | ((cid <> 44) AND (cid < 50)) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 44 | 1 | regress_rls_bob | my first manga 6 | 22 | 1 | regress_rls_carol | great science fiction 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 44 | 4 | 1 | regress_rls_bob | my first manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (document.cid = category.cid) InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Hash -> Seq Scan on category -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (category.cid = document.cid) InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on category -> Hash -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -- 44 would technically fail for both p2r and p1r, but we should get an error -- back from p1r for this because it sorts first INSERT INTO document VALUES (100, 44, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p1r" for table "document" -- Just to see a p2r error INSERT INTO document VALUES (100, 55, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p2r" for table "document" -- only owner can change policies ALTER POLICY p1 ON document USING (true); --fail ERROR: must be owner of table document DROP POLICY p1 ON document; --fail ERROR: must be owner of relation document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+-------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-----------------+--------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-----------------------+----------------- 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Index Scan using category_pkey on category Index Cond: (cid = document.cid) -- interaction of FK/PK constraints SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY p2 ON category USING (CASE WHEN current_user = 'regress_rls_bob' THEN cid IN (11, 33) WHEN current_user = 'regress_rls_carol' THEN cid IN (22, 44) ELSE false END); ALTER TABLE category ENABLE ROW LEVEL SECURITY; -- cannot delete PK referenced by invisible FK SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-----------------+--------------------+-----+------------ 1 | 11 | 1 | regress_rls_bob | my first novel | 11 | novel 2 | 11 | 2 | regress_rls_bob | my second novel | 11 | novel 3 | 22 | 2 | regress_rls_bob | my science fiction | | 4 | 44 | 1 | regress_rls_bob | my first manga | | 5 | 44 | 2 | regress_rls_bob | my second manga | | | | | | | 33 | technology \set VERBOSITY sqlstate DELETE FROM category WHERE cid = 33; -- fails with FK violation ERROR: 23503 \set VERBOSITY default -- can insert FK referencing invisible PK SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-------------------+-----------------------+-----+----------------- 6 | 22 | 1 | regress_rls_carol | great science fiction | 22 | science fiction 7 | 33 | 2 | regress_rls_carol | great technology book | | 8 | 44 | 1 | regress_rls_carol | great manga | 44 | manga INSERT INTO document VALUES (11, 33, 1, current_user, 'hoge'); -- UNIQUE or PRIMARY KEY constraint violation DOES reveal presence of row SET SESSION AUTHORIZATION regress_rls_bob; INSERT INTO document VALUES (8, 44, 1, 'regress_rls_bob', 'my third manga'); -- Must fail with unique violation, revealing presence of did we can't see ERROR: duplicate key value violates unique constraint "5_10_document_pkey" DETAIL: Key (did)=(8) already exists. SELECT * FROM document WHERE did = 8; -- and confirm we can't see it did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- RLS policies are checked before constraints INSERT INTO document VALUES (8, 44, 1, 'regress_rls_carol', 'my third manga'); -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" UPDATE document SET did = 8, dauthor = 'regress_rls_carol' WHERE did = 5; -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database superuser does bypass RLS policy when disabled RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS disabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- -- Table inheritance and RLS policy -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE t1 (a int, junk1 text, b text); ALTER TABLE t1 DROP COLUMN junk1; -- just a disturbing factor GRANT ALL ON t1 TO public; COPY t1 FROM stdin; CREATE TABLE t2 (c float) INHERITS (t1); GRANT ALL ON t2 TO public; COPY t2 FROM stdin; CREATE TABLE t3 (c text, b text, a int); ALTER TABLE t3 INHERIT t1; GRANT ALL ON t3 TO public; COPY t3(a,b,c) FROM stdin; CREATE POLICY p1 ON t1 FOR ALL TO PUBLIC USING (a % 2 = 0); -- be even number CREATE POLICY p2 ON t2 FOR ALL TO PUBLIC USING (a % 2 = 1); -- be odd number ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; ALTER TABLE t2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- reference to system column SELECT ctid, * FROM t1; ctid | a | b -------+---+----- (0,2) | 2 | bbb (0,4) | 4 | dad (0,2) | 2 | bcd (0,4) | 4 | def (0,2) | 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- reference to whole-row reference SELECT *, t1 FROM t1; a | b | t1 ---+-----+--------- 2 | bbb | (2,bbb) 4 | dad | (4,dad) 2 | bcd | (2,bcd) 4 | def | (4,def) 2 | yyy | (2,yyy) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- for share/update lock SELECT * FROM t1 FOR SHARE; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- union all query SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; a | b | ctid ---+-----+------- 1 | abc | (0,1) 3 | cde | (0,3) 1 | xxx | (0,1) 2 | yyy | (0,2) 3 | zzz | (0,3) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; --- QUERY PLAN --- Append -> Seq Scan on t2 Filter: ((a % 2) = 1) -> Seq Scan on t3 -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- -- Hyper Tables -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE hyper_document ( did int, cid int, dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON hyper_document TO public; SELECT public.create_hypertable('hyper_document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------------- (2,regress_rls_schema,hyper_document,t) INSERT INTO hyper_document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 99, 2, 'regress_rls_bob', 'my science textbook'), ( 4, 55, 1, 'regress_rls_bob', 'my first satire'), ( 5, 99, 2, 'regress_rls_bob', 'my history book'), ( 6, 11, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 99, 2, 'regress_rls_carol', 'great technology book'), ( 8, 55, 2, 'regress_rls_carol', 'great satire'), ( 9, 11, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 99, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE hyper_document ENABLE ROW LEVEL SECURITY; GRANT ALL ON _timescaledb_internal._hyper_2_9_chunk TO public; -- Create policy on parent -- user's security level must be higher than or equal to document's CREATE POLICY pp1 ON hyper_document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- Dave is only allowed to see cid < 55 CREATE POLICY pp1r ON hyper_document AS RESTRICTIVE TO regress_rls_dave USING (cid < 55); \d+ hyper_document Table "regress_rls_schema.hyper_document" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ---------+---------+-----------+----------+---------+----------+--------------+------------- did | integer | | not null | | plain | | cid | integer | | | | plain | | dlevel | integer | | not null | | plain | | dauthor | name | | | | plain | | dtitle | text | | | | extended | | Indexes: "hyper_document_did_idx" btree (did DESC) Policies: POLICY "pp1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "pp1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid < 55)) Child tables: _timescaledb_internal._hyper_2_10_chunk, _timescaledb_internal._hyper_2_11_chunk, _timescaledb_internal._hyper_2_12_chunk, _timescaledb_internal._hyper_2_13_chunk, _timescaledb_internal._hyper_2_14_chunk, _timescaledb_internal._hyper_2_9_chunk SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename like '%hyper_document%' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+----------------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | hyper_document | pp1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | hyper_document | pp1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid < 55) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first satire NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 55 | 1 | regress_rls_bob | my first satire 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -- pp1 ERROR INSERT INTO hyper_document VALUES (1, 11, 5, 'regress_rls_dave', 'testing pp1'); -- fail ERROR: new row violates row-level security policy for table "hyper_document" -- pp1r ERROR INSERT INTO hyper_document VALUES (1, 99, 1, 'regress_rls_dave', 'testing pp1r'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- Show that RLS policy does not apply for direct inserts to children -- This should fail with RLS POLICY pp1r violation. INSERT INTO hyper_document VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- But this should succeed. INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- success -- We still cannot see the row using the parent SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction -- But we can if we look directly SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- Turn on RLS and create policy on child to show RLS is checked before constraints SET SESSION AUTHORIZATION regress_rls_alice; ALTER TABLE _timescaledb_internal._hyper_2_9_chunk ENABLE ROW LEVEL SECURITY; CREATE POLICY pp3 ON _timescaledb_internal._hyper_2_9_chunk AS RESTRICTIVE USING (cid < 55); -- This should fail with RLS violation now. SET SESSION AUTHORIZATION regress_rls_dave; INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables - round 2'); -- fail ERROR: new row violates row-level security policy for table "_hyper_2_9_chunk" -- And now we cannot see directly into the partition either, due to RLS SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- The parent looks same as before -- viewpoint from regress_rls_dave SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -- only owner can change policies ALTER POLICY pp1 ON hyper_document USING (true); --fail ERROR: must be owner of table hyper_document DROP POLICY pp1 ON hyper_document; --fail ERROR: must be owner of relation hyper_document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY pp1 ON hyper_document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+--------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 -> Seq Scan on hyper_document hyper_document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- When RLS disabled, other users get ERROR. SET SESSION AUTHORIZATION regress_rls_dave; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "hyper_document" SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "_hyper_2_9_chunk" -- Check behavior with a policy that uses a SubPlan not an InitPlan. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE POLICY pp3 ON hyper_document AS RESTRICTIVE USING ((SELECT dlevel <= seclv FROM uaccount WHERE pguser = current_user)); SET SESSION AUTHORIZATION regress_rls_carol; INSERT INTO hyper_document VALUES (100, 11, 5, 'regress_rls_carol', 'testing pp3'); -- fail ERROR: new row violates row-level security policy "pp3" for table "hyper_document" ----- Dependencies ----- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE dependee (x integer, y integer); SELECT public.create_hypertable('dependee', 'x', chunk_time_interval=>2); create_hypertable ----------------------------------- (3,regress_rls_schema,dependee,t) CREATE TABLE dependent (x integer, y integer); SELECT public.create_hypertable('dependent', 'x', chunk_time_interval=>2); create_hypertable ------------------------------------ (4,regress_rls_schema,dependent,t) CREATE POLICY d1 ON dependent FOR ALL TO PUBLIC USING (x = (SELECT d.x FROM dependee d WHERE d.y = y)); DROP TABLE dependee; -- Should fail without CASCADE due to dependency on row security qual? ERROR: cannot drop table dependee because other objects depend on it DETAIL: policy d1 on table dependent depends on table dependee HINT: Use DROP ... CASCADE to drop the dependent objects too. DROP TABLE dependee CASCADE; NOTICE: drop cascades to policy d1 on table dependent EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM dependent; -- After drop, should be unqualified --- QUERY PLAN --- Seq Scan on dependent ----- RECURSION ---- -- -- Simple recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec1 (x integer, y integer); SELECT public.create_hypertable('rec1', 'x', chunk_time_interval=>2); create_hypertable ------------------------------- (5,regress_rls_schema,rec1,t) CREATE POLICY r1 ON rec1 USING (x = (SELECT r.x FROM rec1 r WHERE y = r.y)); ALTER TABLE rec1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, direct recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec2 (a integer, b integer); SELECT public.create_hypertable('rec2', 'x', chunk_time_interval=>2); ERROR: column "x" does not exist ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2 WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1 WHERE y = b)); ALTER TABLE rec2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via views -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rec1v AS SELECT * FROM rec1; CREATE VIEW rec2v AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); ALTER POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via views ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via .s.b views -- SET SESSION AUTHORIZATION regress_rls_bob; \set VERBOSITY terse \\ -- suppress cascade details DROP VIEW rec1v, rec2v CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE VIEW rec1v WITH (security_barrier) AS SELECT * FROM rec1; CREATE VIEW rec2v WITH (security_barrier) AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via s.b. views ERROR: infinite recursion detected in policy for relation "rec1" -- -- recursive RLS and VIEWs in policy -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE s1 (a int, b text); SELECT public.create_hypertable('s1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (6,regress_rls_schema,s1,t) INSERT INTO s1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE TABLE s2 (x int, y text); SELECT public.create_hypertable('s2', 'x', chunk_time_interval=>2); create_hypertable ----------------------------- (7,regress_rls_schema,s2,t) INSERT INTO s2 (SELECT x, md5(x::text) FROM generate_series(-6,6) x); GRANT SELECT ON s1, s2 TO regress_rls_bob; CREATE POLICY p1 ON s1 USING (a in (select x from s2 where y like '%2f%')); CREATE POLICY p2 ON s2 USING (x in (select a from s1 where b like '%22%')); CREATE POLICY p3 ON s1 FOR INSERT WITH CHECK (a = (SELECT a FROM s1)); ALTER TABLE s1 ENABLE ROW LEVEL SECURITY; ALTER TABLE s2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW v2 AS SELECT * FROM s2 WHERE y like '%af%'; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" INSERT INTO s1 VALUES (1, 'foo'); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3 on s1; ALTER POLICY p2 ON s2 USING (x % 2 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c a | b ---+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b); --- QUERY PLAN --- Seq Scan on s1 Filter: ((hashed SubPlan 1) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON s1 USING (a in (select x from v2)); -- using VIEW in RLS policy SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => 0267aaf632e87a63288a08331f22c7c3 NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc a | b ----+---------------------------------- -4 | 0267aaf632e87a63288a08331f22c7c3 6 | 1679091c5a880faf6fb5e6087eb1b2dc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM s1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on s1 Chunks excluded during startup: 0 -> Seq Scan on s1 s1_1 Filter: ((hashed SubPlan 1) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: ((hashed SubPlan 1) AND f_leak(b)) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; xx | x | y ----+----+---------------------------------- -6 | -6 | 596a3d04481816330f07e4f97510c28f -4 | -4 | 0267aaf632e87a63288a08331f22c7c3 2 | 2 | c81e728d9d4c2f636f067f89cc14862c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; --- QUERY PLAN --- Result -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) SubPlan 2 -> Limit -> Result -> Custom Scan (ChunkAppend) on s1 -> Seq Scan on s1 s1_1 Filter: (hashed SubPlan 1) SubPlan 1 -> Append -> Seq Scan on s2 s2_10 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_11 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_12 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_13 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_14 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_15 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_16 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_17 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: (hashed SubPlan 1) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p2 ON s2 USING (x in (select a from s1 where b like '%d2%')); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion via view) ERROR: infinite recursion detected in policy for relation "s1" -- prepared statement with regress_rls_alice privilege PREPARE p1(int) AS SELECT * FROM t1 WHERE a <= $1; EXECUTE p1(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a <= 2) AND ((a % 2) = 0)) -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- plan cache should be invalidated EXECUTE p1(2); a | b ---+----- 1 | aba 2 | bbb 1 | abc 2 | bcd 1 | xxx 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a <= 2) -> Seq Scan on t2 t1_2 Filter: (a <= 2) -> Seq Scan on t3 t1_3 Filter: (a <= 2) PREPARE p2(int) AS SELECT * FROM t1 WHERE a = $1; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a = 2) -> Seq Scan on t2 t1_2 Filter: (a = 2) -> Seq Scan on t3 t1_3 Filter: (a = 2) -- also, case when privilege switch from superuser SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a = 2) AND ((a % 2) = 0)) -- -- UPDATE / DELETE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_bob; EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Result -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b = b || b WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); --- QUERY PLAN --- Update on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); NOTICE: f_leak => bbbbbb NOTICE: f_leak => daddad -- returning clause with system column UPDATE only t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,9) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,10) | 4 | daddad_updt | (4,daddad_updt) UPDATE t1 SET b = b WHERE f_leak(b) RETURNING *; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy a | b ---+------------- 2 | bbbbbb_updt 4 | daddad_updt 2 | bcdbcd 4 | defdef 2 | yyyyyy UPDATE t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,14) | 4 | daddad_updt | (4,daddad_updt) (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,10) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- updates with from clause EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t3 Filter: ((a = 2) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); NOTICE: f_leak => cde NOTICE: f_leak => yyyyyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde -- updates with from clause self join EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; --- QUERY PLAN --- Update on t2 t2_1 -> Nested Loop Join Filter: (t2_1.b = t2_2.b) -> Seq Scan on t2 t2_1 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t2 t2_2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; NOTICE: f_leak => cde NOTICE: f_leak => cde a | b | c | a | b | c | t2_1 | t2_2 ---+-----+-----+---+-----+-----+-------------+------------- 3 | cde | 3.3 | 3 | cde | 3.3 | (3,cde,3.3) | (3,cde,3.3) EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; --- QUERY PLAN --- Update on t1 t1_1 Update on t1 t1_1_1 Update on t2 t1_1_2 Update on t3 t1_1_3 -> Nested Loop Join Filter: (t1_1.b = t1_2.b) -> Append -> Seq Scan on t1 t1_1_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_1_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_1_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Materialize -> Append -> Seq Scan on t1 t1_2_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_2_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; NOTICE: f_leak => daddad_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => defdef NOTICE: f_leak => defdef a | b | a | b | t1_1 | t1_2 ---+-------------+---+-------------+-----------------+----------------- 4 | daddad_updt | 4 | daddad_updt | (4,daddad_updt) | (4,daddad_updt) 4 | defdef | 4 | defdef | (4,defdef) | (4,defdef) RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 ORDER BY a,b; a | b ---+------------- 1 | aba 1 | abc 1 | xxx 2 | bbbbbb_updt 2 | bcdbcd 2 | yyyyyy 3 | ccc 3 | cde 3 | zzz 4 | daddad_updt 4 | defdef SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM only t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 Delete on t1 t1_1 Delete on t2 t1_2 Delete on t3 t1_3 -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM only t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,15) | 4 | daddad_updt | (4,daddad_updt) DELETE FROM t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+--------+------------ (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,13) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- -- S.b. view on top of Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE b1 (a int, b text); SELECT public.create_hypertable('b1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (8,regress_rls_schema,b1,t) INSERT INTO b1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE POLICY p1 ON b1 USING (a % 2 = 0); ALTER TABLE b1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON b1 TO regress_rls_bob; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW bv1 WITH (security_barrier) AS SELECT * FROM b1 WHERE a > 0 WITH CHECK OPTION; GRANT ALL ON bv1 TO regress_rls_carol; SET SESSION AUTHORIZATION regress_rls_carol; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM bv1 WHERE f_leak(b); --- QUERY PLAN --- Subquery Scan on bv1 Filter: f_leak(bv1.b) -> Append -> Seq Scan on b1 b1_1 Filter: ((a > 0) AND ((a % 2) = 0)) -> Index Scan using _hyper_8_39_chunk_b1_a_idx on _hyper_8_39_chunk b1_2 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_40_chunk_b1_a_idx on _hyper_8_40_chunk b1_3 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_4 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_5 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_43_chunk_b1_a_idx on _hyper_8_43_chunk b1_6 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_44_chunk_b1_a_idx on _hyper_8_44_chunk b1_7 Index Cond: (a > 0) Filter: ((a % 2) = 0) SELECT * FROM bv1 WHERE f_leak(b); NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 a | b ----+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 INSERT INTO bv1 VALUES (-1, 'xxx'); -- should fail view WCO ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (11, 'xxx'); -- should fail RLS check ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (12, 'xxx'); -- ok EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on b1 Update on _hyper_8_41_chunk b1_1 -> Result -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_1 Index Cond: ((a > 0) AND (a = 4)) Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on b1 Delete on _hyper_8_42_chunk b1_1 -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_1 Index Cond: ((a > 0) AND (a = 6)) Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM b1; a | b -----+---------------------------------- -10 | 1b0fd9efa5279c4203b7c70233f86dbf -9 | 252e691406782824eec43d7eadc3d256 -8 | a8d2ec85eaf98407310b72eb73dda247 -7 | 74687a12d3915d3c4d83f1af7b3683d5 -6 | 596a3d04481816330f07e4f97510c28f -5 | 47c1b025fa18ea96c33fbb6718688c0f -4 | 0267aaf632e87a63288a08331f22c7c3 -3 | b3149ecea4628efd23d2f86e5a723472 -2 | 5d7b9adcbe1c629ec722529dd12e5129 -1 | 6bb61e3b7bce0931da574d19d1d82c88 0 | cfcd208495d565ef66e7dff9f98764da 1 | c4ca4238a0b923820dcc509a6f75849b 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | yyy 7 | 8f14e45fceea167a5a36dedd4bea2543 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | xxx -- -- INSERT ... ON CONFLICT DO UPDATE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p1r ON document; CREATE POLICY p1 ON document FOR SELECT USING (true); CREATE POLICY p2 ON document FOR INSERT WITH CHECK (dauthor = current_user); CREATE POLICY p3 ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Exists... SELECT * FROM document WHERE did = 2; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------- 2 | 11 | 2 | regress_rls_bob | my second novel -- ...so violates actual WITH CHECK OPTION within UPDATE (not INSERT, since -- alternative UPDATE path happens to be taken): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, dauthor = EXCLUDED.dauthor; ERROR: new row violates row-level security policy for table "document" -- Violates USING qual for UPDATE policy p3. -- -- UPDATE path is taken, but UPDATE fails purely because *existing* row to be -- updated is not a "novel"/cid 11 (row is not leaked, even though we have -- SELECT privileges sufficient to see the row in this instance): INSERT INTO document VALUES (33, 22, 1, 'regress_rls_bob', 'okay science fiction'); -- preparation for next statement INSERT INTO document VALUES (33, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'Some novel, replaces sci-fi') -- takes UPDATE path ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fine (we UPDATE, since INSERT WCOs and UPDATE security barrier quals + WCOs -- not violated): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------- 2 | 11 | 2 | regress_rls_bob | my first novel -- Fine (we INSERT, so "cid = 33" ("technology") isn't evaluated): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 11 | 1 | regress_rls_bob | some technology novel -- Fine (same query, but we UPDATE, so "cid = 33", ("technology") is not the -- case in respect of *existing* tuple): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 33 | 1 | regress_rls_bob | some technology novel -- Same query a third time, but now fails due to existing tuple finally not -- passing quals: INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Don't fail just because INSERT doesn't satisfy WITH CHECK option that -- originated as a barrier/USING() qual from the UPDATE. Note that the UPDATE -- path *isn't* taken, and so UPDATE-related policy does not apply: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------------------------- 79 | 33 | 1 | regress_rls_bob | technology book, can only insert -- But this time, the same statement fails, because the UPDATE path is taken, -- and updating the row just inserted falls afoul of security barrier qual -- (enforced as WCO) -- what we might have updated target tuple to is -- irrelevant, in fact. INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Test default USING qual enforced as WCO SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p2 ON document; DROP POLICY p3 ON document; CREATE POLICY p3_with_default ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')); SET SESSION AUTHORIZATION regress_rls_bob; -- Just because WCO-style enforcement of USING quals occurs with -- existing/target tuple does not mean that the implementation can be allowed -- to fail to also enforce this qual against the final tuple appended to -- relation (since in the absence of an explicit WCO, this is also interpreted -- as an UPDATE/ALL WCO in general). -- -- UPDATE path is taken here (fails due to existing tuple). Note that this is -- not reported as a "USING expression", because it's an RLS UPDATE check that originated as -- a USING qual for the purposes of RLS in general, as opposed to an explicit -- USING qual that is ordinarily a security barrier. We leave it up to the -- UPDATE to make this fail: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" -- UPDATE path is taken here. Existing tuple passes, since it's cid -- corresponds to "novel", but default USING qual is enforced against -- post-UPDATE tuple too (as always when updating with a policy that lacks an -- explicit WCO), and so this fails: INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET cid = EXCLUDED.cid, dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3_with_default ON document; -- -- Test ALL policies with ON CONFLICT DO UPDATE (much the same as existing UPDATE -- tests) -- CREATE POLICY p3_with_all ON document FOR ALL USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Fails, since ALL WCO is enforced in insert path: INSERT INTO document VALUES (80, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33; ERROR: new row violates row-level security policy for table "document" -- Fails, since ALL policy USING qual is enforced (existing, target tuple is in -- violation, since it has the "manga" cid): INSERT INTO document VALUES (4, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fails, since ALL WCO are enforced: INSERT INTO document VALUES (1, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dauthor = 'regress_rls_carol'; ERROR: new row violates row-level security policy for table "document" -- -- ROLE/GROUP -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE z1 (a int, b text); SELECT public.create_hypertable('z1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (9,regress_rls_schema,z1,t) CREATE TABLE z2 (a int, b text); SELECT public.create_hypertable('z2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (10,regress_rls_schema,z2,t) GRANT SELECT ON z1,z2 TO regress_rls_group1, regress_rls_group2, regress_rls_bob, regress_rls_carol; INSERT INTO z1 VALUES (1, 'aba'), (2, 'bbb'), (3, 'ccc'), (4, 'dad'); CREATE POLICY p1 ON z1 TO regress_rls_group1 USING (a % 2 = 0); CREATE POLICY p2 ON z1 TO regress_rls_group2 USING (a % 2 = 1); ALTER TABLE z1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test AS SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test2 AS WITH q AS MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test4 AS WITH q AS (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test6 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test6; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test3 AS WITH q AS MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test5 AS WITH q AS (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test7 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test7; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET ROLE regress_rls_group1; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) SET ROLE regress_rls_group2; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -- -- Views should follow policy for view owner. -- -- View and Table owner are the same. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_bob; -- Query as role that is not owner of view or table. Should return all records. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) -- Query as view/table owner. Should return all records. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) DROP VIEW rls_view; -- View and Table owners are different. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_alice; -- Query as role that is not owner of view but is owner of table. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not owner of table but is owner of view. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not the owner of the table or view without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view -- Query as role that is not the owner of the table or view with permissions. SET SESSION AUTHORIZATION regress_rls_bob; GRANT SELECT ON rls_view TO regress_rls_carol; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_bob; DROP VIEW rls_view; -- -- Command specific -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE x1 (a int, b text, c text); SELECT public.create_hypertable('x1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (11,regress_rls_schema,x1,t) GRANT ALL ON x1 TO PUBLIC; INSERT INTO x1 VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_carol'), (4, 'def', 'regress_rls_carol'), (5, 'efg', 'regress_rls_bob'), (6, 'fgh', 'regress_rls_bob'), (7, 'fgh', 'regress_rls_carol'), (8, 'fgh', 'regress_rls_carol'); CREATE POLICY p0 ON x1 FOR ALL USING (c = current_user); CREATE POLICY p1 ON x1 FOR SELECT USING (a % 2 = 0); CREATE POLICY p2 ON x1 FOR INSERT WITH CHECK (a % 2 = 1); CREATE POLICY p3 ON x1 FOR UPDATE USING (a % 2 = 0); CREATE POLICY p4 ON x1 FOR DELETE USING (a < 8); ALTER TABLE x1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+-----+------------------- 1 | abc | regress_rls_bob 2 | bcd | regress_rls_bob 4 | def | regress_rls_carol 5 | efg | regress_rls_bob 6 | fgh | regress_rls_bob 8 | fgh | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+----------+------------------- 1 | abc_updt | regress_rls_bob 2 | bcd_updt | regress_rls_bob 4 | def_updt | regress_rls_carol 5 | efg_updt | regress_rls_bob 6 | fgh_updt | regress_rls_bob 8 | fgh_updt | regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+----------+------------------- 2 | bcd_updt | regress_rls_bob 3 | cde | regress_rls_carol 4 | def_updt | regress_rls_carol 6 | fgh_updt | regress_rls_bob 7 | fgh | regress_rls_carol 8 | fgh_updt | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol DELETE FROM x1 WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde_updt NOTICE: f_leak => bcd_updt_updt NOTICE: f_leak => def_updt_updt NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt_updt NOTICE: f_leak => fgh_updt_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol -- -- Duplicate Policy Names -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE y1 (a int, b text); SELECT public.create_hypertable('y1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (12,regress_rls_schema,y1,t) INSERT INTO y1 VALUES(1,2); CREATE TABLE y2 (a int, b text); SELECT public.create_hypertable('y2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (13,regress_rls_schema,y2,t) GRANT ALL ON y1, y2 TO regress_rls_bob; CREATE POLICY p1 ON y1 FOR ALL USING (a % 2 = 0); CREATE POLICY p2 ON y1 FOR SELECT USING (a > 2); CREATE POLICY p1 ON y1 FOR SELECT USING (a % 2 = 1); --fail ERROR: policy "p1" for table "y1" already exists CREATE POLICY p1 ON y2 FOR ALL USING (a % 2 = 0); --OK ALTER TABLE y1 ENABLE ROW LEVEL SECURITY; ALTER TABLE y2 ENABLE ROW LEVEL SECURITY; -- -- Expression structure with SBV -- -- Create view as table owner. RLS should NOT be applied. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: (f_leak(b) AND (a = 1)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: f_leak(b) DROP VIEW rls_sbv; -- Create view as role that does not own table. RLS should be applied. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: ((a = 1) AND ((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: (((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) DROP VIEW rls_sbv; -- -- Expression structure -- SET SESSION AUTHORIZATION regress_rls_alice; INSERT INTO y2 (SELECT x, md5(x::text) FROM generate_series(0,20) x); CREATE POLICY p2 ON y2 USING (a % 3 = 0); CREATE POLICY p3 ON y2 USING (a % 4 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM y2 WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -- -- Qual push-down of leaky functions, when not referring to table -- SELECT * FROM y2 WHERE f_leak('abc'); NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak('abc'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) CREATE TABLE test_qual_pushdown ( abc text ); INSERT INTO test_qual_pushdown VALUES ('abc'),('def'); SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); NOTICE: f_leak => abc NOTICE: f_leak => def a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); --- QUERY PLAN --- Hash Join Hash Cond: (y2.b = test_qual_pushdown.abc) -> Append -> Seq Scan on y2 y2_1 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Hash -> Seq Scan on test_qual_pushdown Filter: f_leak(abc) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); --- QUERY PLAN --- Hash Join Hash Cond: (test_qual_pushdown.abc = y2.b) -> Seq Scan on test_qual_pushdown -> Hash -> Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) DROP TABLE test_qual_pushdown; -- -- Plancache invalidate on user change. -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP TABLE t1 CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE TABLE t1 (a integer); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (14,regress_rls_schema,t1,t) GRANT SELECT ON t1 TO regress_rls_bob, regress_rls_carol; CREATE POLICY p1 ON t1 TO regress_rls_bob USING ((a % 2) = 0); CREATE POLICY p2 ON t1 TO regress_rls_carol USING ((a % 4) = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; -- Prepare as regress_rls_bob SET ROLE regress_rls_bob; PREPARE role_inval AS SELECT * FROM t1; -- Check plan EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- Change to regress_rls_carol SET ROLE regress_rls_carol; -- Check plan- should be different EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 4) = 0) -- Change back to regress_rls_bob SET ROLE regress_rls_bob; -- Check plan- should be back to original EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- -- CTE and RLS -- RESET SESSION AUTHORIZATION; DROP TABLE t1 CASCADE; CREATE TABLE t1 (a integer, b text); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (15,regress_rls_schema,t1,t) CREATE POLICY p1 ON t1 USING (a % 2 = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON t1 TO regress_rls_bob; INSERT INTO t1 (SELECT x, md5(x::text) FROM generate_series(0,20) x); SET SESSION AUTHORIZATION regress_rls_bob; WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; --- QUERY PLAN --- CTE Scan on cte1 CTE cte1 -> Custom Scan (ChunkAppend) on t1 Chunks excluded during startup: 0 -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: (((a % 2) = 0) AND f_leak(b)) WITH cte1 AS (UPDATE t1 SET a = a + 1 RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (UPDATE t1 SET a = a RETURNING *) SELECT * FROM cte1; --ok a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 WITH cte1 AS (INSERT INTO t1 VALUES (21, 'Fail') RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (INSERT INTO t1 VALUES (20, 'Success') RETURNING *) SELECT * FROM cte1; --ok a | b ----+--------- 20 | Success -- -- Rename Policy -- RESET SESSION AUTHORIZATION; ALTER POLICY p1 ON t1 RENAME TO p1; --fail ERROR: policy "p1" for table "t1" already exists SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p1 | t1 ALTER POLICY p1 ON t1 RENAME TO p2; --ok SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p2 | t1 -- -- Check INSERT SELECT -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE TABLE t2 (a integer, b text); SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (16,regress_rls_schema,t2,t) INSERT INTO t2 (SELECT * FROM t1); EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO t2 (SELECT * FROM t1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on t2 -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: ((a % 2) = 0) SELECT * FROM t2; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t2; --- QUERY PLAN --- Append -> Seq Scan on t2 t2_1 -> Seq Scan on _hyper_16_80_chunk t2_2 -> Seq Scan on _hyper_16_81_chunk t2_3 -> Seq Scan on _hyper_16_82_chunk t2_4 -> Seq Scan on _hyper_16_83_chunk t2_5 -> Seq Scan on _hyper_16_84_chunk t2_6 -> Seq Scan on _hyper_16_85_chunk t2_7 -> Seq Scan on _hyper_16_86_chunk t2_8 -> Seq Scan on _hyper_16_87_chunk t2_9 -> Seq Scan on _hyper_16_88_chunk t2_10 -> Seq Scan on _hyper_16_89_chunk t2_11 -> Seq Scan on _hyper_16_90_chunk t2_12 CREATE TABLE t3 AS SELECT * FROM t1; SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); ERROR: table "t2" is already a hypertable SELECT * FROM t3; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success SELECT * INTO t4 FROM t1; SELECT * FROM t4; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success -- -- RLS with JOIN -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE blog (id integer, author text, post text); SELECT public.create_hypertable('blog', 'id', chunk_time_interval=>2); create_hypertable -------------------------------- (17,regress_rls_schema,blog,t) CREATE TABLE comment (blog_id integer, message text); SELECT public.create_hypertable('comment', 'blog_id', chunk_time_interval=>2); create_hypertable ----------------------------------- (18,regress_rls_schema,comment,t) GRANT ALL ON blog, comment TO regress_rls_bob; CREATE POLICY blog_1 ON blog USING (id % 2 = 0); ALTER TABLE blog ENABLE ROW LEVEL SECURITY; INSERT INTO blog VALUES (1, 'alice', 'blog #1'), (2, 'bob', 'blog #1'), (3, 'alice', 'blog #2'), (4, 'alice', 'blog #3'), (5, 'john', 'blog #1'); INSERT INTO comment VALUES (1, 'cool blog'), (1, 'fun blog'), (3, 'crazy blog'), (5, 'what?'), (4, 'insane!'), (2, 'who did it?'); SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN with Non-RLS. SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! -- Check Non-RLS JOIN with RLS. SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY comment_1 ON comment USING (blog_id < 4); ALTER TABLE comment ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN RLS SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE blog; DROP TABLE comment; -- -- Default Deny Policy -- RESET SESSION AUTHORIZATION; DROP POLICY p2 ON t1; ALTER TABLE t1 OWNER TO regress_rls_alice; -- Check that default deny does not apply to superuser. RESET SESSION AUTHORIZATION; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny does not apply to table owner. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny applies to non-owner/non-superuser when RLS on. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false -- -- COPY TO/FROM -- RESET SESSION AUTHORIZATION; DROP TABLE copy_t CASCADE; ERROR: table "copy_t" does not exist CREATE TABLE copy_t (a integer, b text); SELECT public.create_hypertable('copy_t', 'a', chunk_time_interval=>2); create_hypertable ---------------------------------- (19,regress_rls_schema,copy_t,t) CREATE POLICY p1 ON copy_t USING (a % 2 = 0); ALTER TABLE copy_t ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_t TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_t (SELECT x, md5(x::text) FROM generate_series(0,10) x); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 2,c81e728d9d4c2f636f067f89cc14862c 4,a87ff679a2f3e71d9181a67b7542122c 6,1679091c5a880faf6fb5e6087eb1b2dc 8,c9f0f895fb98ab9159f51fd0297e236d 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_t -- Check COPY relation TO; keep it just one row to avoid reordering issues RESET SESSION AUTHORIZATION; SET row_security TO ON; CREATE TABLE copy_rel_to (a integer, b text); SELECT public.create_hypertable('copy_rel_to', 'a', chunk_time_interval=>2); create_hypertable --------------------------------------- (20,regress_rls_schema,copy_rel_to,t) CREATE POLICY p1 ON copy_rel_to USING (a % 2 = 0); ALTER TABLE copy_rel_to ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_rel_to TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_rel_to VALUES (1, md5('1')); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_rel_to -- Check COPY FROM as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY copy_t FROM STDIN; --ok SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - would be affected by RLS. ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY copy_t FROM STDIN; --fail - COPY FROM not supported by RLS. ERROR: COPY FROM not supported with row-level security HINT: Use INSERT statements instead. -- Check COPY FROM as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t SET row_security TO ON; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t RESET SESSION AUTHORIZATION; DROP TABLE copy_t; DROP TABLE copy_rel_to CASCADE; -- Check WHERE CURRENT OF SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE current_check (currentid int, payload text, rlsuser text); SELECT public.create_hypertable('current_check', 'currentid', chunk_time_interval=>10); create_hypertable ----------------------------------------- (21,regress_rls_schema,current_check,t) GRANT ALL ON current_check TO PUBLIC; INSERT INTO current_check VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_bob'), (4, 'def', 'regress_rls_bob'); CREATE POLICY p1 ON current_check FOR SELECT USING (currentid % 2 = 0); CREATE POLICY p2 ON current_check FOR DELETE USING (currentid = 4 AND rlsuser = current_user); CREATE POLICY p3 ON current_check FOR UPDATE USING (currentid = 4) WITH CHECK (rlsuser = current_user); ALTER TABLE current_check ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Can SELECT even rows SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def | regress_rls_bob -- Cannot UPDATE row 2 UPDATE current_check SET payload = payload || '_new' WHERE currentid = 2 RETURNING *; currentid | payload | rlsuser -----------+---------+--------- BEGIN; -- WHERE CURRENT OF does not work with custom scan nodes -- so we have to disable chunk append here SET timescaledb.enable_chunk_append TO false; DECLARE current_check_cursor SCROLL CURSOR FOR SELECT * FROM current_check; -- Returns rows that can be seen according to SELECT policy, like plain SELECT -- above (even rows) FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob -- Still cannot UPDATE row 2 through cursor UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- -- Can update row 4 through cursor, which is the next visible row FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def_new | regress_rls_bob -- Plan should be a subquery TID scan EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE current_check SET payload = payload WHERE CURRENT OF current_check_cursor; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on current_check Update on _hyper_21_104_chunk current_check_1 -> Tid Scan on _hyper_21_104_chunk current_check_1 TID Cond: CURRENT OF current_check_cursor Filter: ((currentid = 4) AND ((currentid % 2) = 0)) -- Similarly can only delete row 4 FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob RESET timescaledb.enable_chunk_append; COMMIT; -- -- check pg_stats view filtering -- SET row_security TO ON; SET SESSION AUTHORIZATION regress_rls_alice; ANALYZE current_check; -- Stats visible SELECT row_security_active('current_check'); row_security_active --------------------- f SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals -----------+------------------- currentid | payload | rlsuser | {regress_rls_bob} SET SESSION AUTHORIZATION regress_rls_bob; -- Stats not visible SELECT row_security_active('current_check'); row_security_active --------------------- t SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals ---------+------------------ -- -- Collation support -- BEGIN; CREATE TABLE coll_t (c) AS VALUES ('bar'::text); CREATE POLICY coll_p ON coll_t USING (c < ('foo'::text COLLATE "C")); ALTER TABLE coll_t ENABLE ROW LEVEL SECURITY; GRANT SELECT ON coll_t TO regress_rls_alice; SELECT (string_to_array(polqual, ':'))[7] AS inputcollid FROM pg_policy WHERE polrelid = 'coll_t'::regclass; inputcollid ------------------ inputcollid 950 SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM coll_t; c ----- bar ROLLBACK; -- -- Shared Object Dependencies -- RESET SESSION AUTHORIZATION; BEGIN; CREATE ROLE regress_rls_eve; CREATE ROLE regress_rls_frank; CREATE TABLE tbl1 (c) AS VALUES ('bar'::text); GRANT SELECT ON TABLE tbl1 TO regress_rls_eve; CREATE POLICY P ON tbl1 TO regress_rls_eve, regress_rls_frank USING (true); SELECT refclassid::regclass, deptype FROM pg_depend WHERE classid = 'pg_policy'::regclass AND refobjid = 'tbl1'::regclass; refclassid | deptype ------------+--------- pg_class | a SELECT refclassid::regclass, deptype FROM pg_shdepend WHERE classid = 'pg_policy'::regclass AND refobjid IN ('regress_rls_eve'::regrole, 'regress_rls_frank'::regrole); refclassid | deptype ------------+--------- pg_authid | r pg_authid | r SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on POLICY p ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 target of policy p on table tbl1 ROLLBACK TO q; ALTER POLICY p ON tbl1 TO regress_rls_frank USING (true); SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on GRANT SELECT ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 ROLLBACK TO q; REVOKE ALL ON TABLE tbl1 FROM regress_rls_eve; SAVEPOINT q; DROP ROLE regress_rls_eve; --succeeds ROLLBACK TO q; SAVEPOINT q; DROP ROLE regress_rls_frank; --fails due to dependency on POLICY p ERROR: role "regress_rls_frank" cannot be dropped because some objects depend on it DETAIL: target of policy p on table tbl1 ROLLBACK TO q; DROP POLICY p ON tbl1; SAVEPOINT q; DROP ROLE regress_rls_frank; -- succeeds ROLLBACK TO q; ROLLBACK; -- cleanup -- -- Converting table to view -- BEGIN; CREATE TABLE t (c int); SELECT public.create_hypertable('t', 'c', chunk_time_interval=>2); create_hypertable ----------------------------- (22,regress_rls_schema,t,t) CREATE POLICY p ON t USING (c % 2 = 1); ALTER TABLE t ENABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to row level security enabled ERROR: hypertables do not support rules ROLLBACK TO q; ALTER TABLE t DISABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to policy p on t ERROR: hypertables do not support rules ROLLBACK TO q; DROP POLICY p ON t; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- succeeds ERROR: hypertables do not support rules ROLLBACK; -- -- Policy expression handling -- BEGIN; CREATE TABLE t (c) AS VALUES ('bar'::text); CREATE POLICY p ON t USING (max(c)); -- fails: aggregate functions are not allowed in policy expressions ERROR: aggregate functions are not allowed in policy expressions ROLLBACK; -- -- Non-target relations are only subject to SELECT policies -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (23,regress_rls_schema,r1,t) CREATE TABLE r2 (a int); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (24,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); GRANT ALL ON r1, r2 TO regress_rls_bob; CREATE POLICY p1 ON r1 USING (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON r2 FOR SELECT USING (true); CREATE POLICY p2 ON r2 FOR INSERT WITH CHECK (false); CREATE POLICY p3 ON r2 FOR UPDATE USING (false); CREATE POLICY p4 ON r2 FOR DELETE USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM r1; a ---- 10 20 SELECT * FROM r2; a ---- 10 20 -- r2 is read-only INSERT INTO r2 VALUES (2); -- Not allowed ERROR: new row violates row-level security policy for table "r2" \pset tuples_only 1 UPDATE r2 SET a = 2 RETURNING *; -- Updates nothing DELETE FROM r2 RETURNING *; -- Deletes nothing \pset tuples_only 0 -- r2 can be used as a non-target relation in DML INSERT INTO r1 SELECT a + 1 FROM r2 RETURNING *; -- OK a ---- 11 21 UPDATE r1 SET a = r2.a + 2 FROM r2 WHERE r1.a = r2.a RETURNING *; -- OK ERROR: new row for relation "_hyper_23_105_chunk" violates check constraint "constraint_105" DELETE FROM r1 USING r2 WHERE r1.a = r2.a + 2 RETURNING *; -- OK a | a ---+--- SELECT * FROM r1; a ---- 10 11 20 21 SELECT * FROM r2; a ---- 10 20 SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE r1; DROP TABLE r2; -- -- FORCE ROW LEVEL SECURITY applies RLS to owners too -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (25,regress_rls_schema,r1,t) INSERT INTO r1 VALUES (10), (20); CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No error, but no rows TABLE r1; a --- -- RLS error INSERT INTO r1 VALUES (1); ERROR: new row violates row-level security policy for table "r1" -- No error (unable to see any rows to update) UPDATE r1 SET a = 1; TABLE r1; a --- -- No error (unable to see any rows to delete) DELETE FROM r1; TABLE r1; a --- SET row_security = off; -- these all fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. UPDATE r1 SET a = 1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DELETE FROM r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DROP TABLE r1; -- -- FORCE ROW LEVEL SECURITY does not break RI -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (26,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Errors due to rows in r2 DELETE FROM r1; ERROR: update or delete on table "r1" violates foreign key constraint "r2_a_fkey" on table "r2" DETAIL: Key (a)=(10) is still referenced from table "r2". -- Reset r2 to no-RLS DROP POLICY p1 ON r2; ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; ALTER TABLE r2 DISABLE ROW LEVEL SECURITY; -- clean out r2 for INSERT test below DELETE FROM r2; -- Change r1 to not allow rows to be seen CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No rows seen TABLE r1; a --- -- No error, RI still sees that row exists in r1 INSERT INTO r2 VALUES (10); DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded DELETE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON DELETE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (27,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Deletes all records from both DELETE FROM r1; -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify no rows in r2 now TABLE r2; a --- DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded UPDATE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON UPDATE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (28,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Updates records in both (terse output to not print CONTEXT, which can be different). \set VERBOSITY terse UPDATE r1 SET a = a+5; ERROR: new row for relation "_hyper_28_117_chunk" violates check constraint "constraint_117" \set VERBOSITY default -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify records in r2 updated TABLE r2; a ---- 10 20 DROP TABLE r2; DROP TABLE r1; -- -- Test INSERT+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (29,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (false); CREATE POLICY p2 ON r1 FOR INSERT WITH CHECK (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine INSERT INTO r1 VALUES (10), (20); -- No error, but no rows TABLE r1; a --- SET row_security = off; -- fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. SET row_security = on; -- Error INSERT INTO r1 VALUES (10), (20) RETURNING *; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- -- Test UPDATE+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>100); create_hypertable ------------------------------ (30,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (a < 20); CREATE POLICY p2 ON r1 FOR UPDATE USING (a < 20) WITH CHECK (true); CREATE POLICY p3 ON r1 FOR INSERT WITH CHECK (true); INSERT INTO r1 VALUES (10); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine UPDATE r1 SET a = 30; -- Show updated rows ALTER TABLE r1 NO FORCE ROW LEVEL SECURITY; TABLE r1; a ---- 30 -- reset value in r1 for test with RETURNING UPDATE r1 SET a = 10; -- Verify row reset TABLE r1; a ---- 10 ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Error UPDATE r1 SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- UPDATE path of INSERT ... ON CONFLICT DO UPDATE should also error out INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- Should still error out without RETURNING (use of arbiter always requires -- SELECT permissions) INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" -- ON CONFLICT ON CONSTRAINT INSERT INTO r1 VALUES (10) ON CONFLICT ON CONSTRAINT r1_pkey DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- Check dependency handling RESET SESSION AUTHORIZATION; CREATE TABLE dep1 (c1 int); SELECT public.create_hypertable('dep1', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (31,regress_rls_schema,dep1,t) CREATE TABLE dep2 (c1 int); SELECT public.create_hypertable('dep2', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (32,regress_rls_schema,dep2,t) CREATE POLICY dep_p1 ON dep1 TO regress_rls_bob USING (c1 > (select max(dep2.c1) from dep2)); ALTER POLICY dep_p1 ON dep1 TO regress_rls_bob,regress_rls_carol; -- Should return one SELECT count(*) = 1 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t ALTER POLICY dep_p1 ON dep1 USING (true); -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_bob'); ?column? ---------- t -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_carol'); ?column? ---------- t -- Should return zero SELECT count(*) = 0 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t -- DROP OWNED BY testing RESET SESSION AUTHORIZATION; CREATE ROLE regress_rls_dob_role1; CREATE ROLE regress_rls_dob_role2; CREATE TABLE dob_t1 (c1 int); SELECT public.create_hypertable('dob_t1', 'c1', chunk_time_interval=>2); create_hypertable ---------------------------------- (33,regress_rls_schema,dob_t1,t) CREATE TABLE dob_t2 (c1 int) PARTITION BY RANGE (c1); CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should fail, already gone ERROR: policy "p1" for table "dob_t1" does not exist CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should succeed CREATE POLICY p1 ON dob_t2 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t2; -- should succeed DROP USER regress_rls_dob_role1; DROP USER regress_rls_dob_role2; -- -- Clean up objects -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP SCHEMA regress_rls_schema CASCADE; NOTICE: drop cascades to 116 other objects \set VERBOSITY default DROP USER regress_rls_alice; DROP USER regress_rls_bob; DROP USER regress_rls_carol; DROP USER regress_rls_dave; DROP USER regress_rls_exempt_user; DROP ROLE regress_rls_group1; DROP ROLE regress_rls_group2; -- Arrange to have a few policies left over, for testing -- pg_dump/pg_restore CREATE SCHEMA regress_rls_schema; CREATE TABLE rls_tbl (c1 int); SELECT public.create_hypertable('rls_tbl', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------- (34,regress_rls_schema,rls_tbl,t) ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl USING (c1 > 5); CREATE POLICY p2 ON rls_tbl FOR SELECT USING (c1 <= 3); CREATE POLICY p3 ON rls_tbl FOR UPDATE USING (c1 <= 3) WITH CHECK (c1 > 5); CREATE POLICY p4 ON rls_tbl FOR DELETE USING (c1 <= 3); CREATE TABLE rls_tbl_force (c1 int); SELECT public.create_hypertable('rls_tbl_force', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------------- (35,regress_rls_schema,rls_tbl_force,t) ALTER TABLE rls_tbl_force ENABLE ROW LEVEL SECURITY; ALTER TABLE rls_tbl_force FORCE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl_force USING (c1 = 5) WITH CHECK (c1 < 5); CREATE POLICY p2 ON rls_tbl_force FOR SELECT USING (c1 = 8); CREATE POLICY p3 ON rls_tbl_force FOR UPDATE USING (c1 = 8) WITH CHECK (c1 >= 5); CREATE POLICY p4 ON rls_tbl_force FOR DELETE USING (c1 = 8); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/rowsecurity-16.out�������������������������������������������������0000664�0000000�0000000�00000553346�15100345067�0022227�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Test of Row-level security feature -- -- Clean up in case a prior regression run failed \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET timescaledb.enable_constraint_exclusion TO off; -- Suppress NOTICE messages when users/groups don't exist SET client_min_messages TO 'warning'; DROP USER IF EXISTS regress_rls_alice; DROP USER IF EXISTS regress_rls_bob; DROP USER IF EXISTS regress_rls_carol; DROP USER IF EXISTS regress_rls_dave; DROP USER IF EXISTS regress_rls_exempt_user; DROP ROLE IF EXISTS regress_rls_group1; DROP ROLE IF EXISTS regress_rls_group2; DROP SCHEMA IF EXISTS regress_rls_schema CASCADE; RESET client_min_messages; -- initial setup CREATE USER regress_rls_alice NOLOGIN; CREATE USER regress_rls_bob NOLOGIN; CREATE USER regress_rls_carol NOLOGIN; CREATE USER regress_rls_dave NOLOGIN; CREATE USER regress_rls_exempt_user BYPASSRLS NOLOGIN; CREATE ROLE regress_rls_group1 NOLOGIN; CREATE ROLE regress_rls_group2 NOLOGIN; GRANT regress_rls_group1 TO regress_rls_bob; GRANT regress_rls_group2 TO regress_rls_carol; CREATE SCHEMA regress_rls_schema; GRANT ALL ON SCHEMA regress_rls_schema to public; SET search_path = regress_rls_schema; -- setup of malicious function CREATE OR REPLACE FUNCTION f_leak(text) RETURNS bool COST 0.0000001 LANGUAGE plpgsql AS 'BEGIN RAISE NOTICE ''f_leak => %'', $1; RETURN true; END'; GRANT EXECUTE ON FUNCTION f_leak(text) TO public; -- BASIC Row-Level Security Scenario SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE uaccount ( pguser name primary key, seclv int ); GRANT SELECT ON uaccount TO public; INSERT INTO uaccount VALUES ('regress_rls_alice', 99), ('regress_rls_bob', 1), ('regress_rls_carol', 2), ('regress_rls_dave', 3); CREATE TABLE category ( cid int primary key, cname text ); GRANT ALL ON category TO public; INSERT INTO category VALUES (11, 'novel'), (22, 'science fiction'), (33, 'technology'), (44, 'manga'); CREATE TABLE document ( did int primary key, cid int references category(cid), dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON document TO public; SELECT public.create_hypertable('document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------- (1,regress_rls_schema,document,t) INSERT INTO document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 22, 2, 'regress_rls_bob', 'my science fiction'), ( 4, 44, 1, 'regress_rls_bob', 'my first manga'), ( 5, 44, 2, 'regress_rls_bob', 'my second manga'), ( 6, 22, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 33, 2, 'regress_rls_carol', 'great technology book'), ( 8, 44, 1, 'regress_rls_carol', 'great manga'), ( 9, 22, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 33, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE document ENABLE ROW LEVEL SECURITY; -- user's security level must be higher than or equal to document's CREATE POLICY p1 ON document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- try to create a policy of bogus type CREATE POLICY p1 ON document AS UGLY USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); ERROR: unrecognized row security option "ugly" LINE 1: CREATE POLICY p1 ON document AS UGLY ^ HINT: Only PERMISSIVE or RESTRICTIVE policies are supported currently. -- but Dave isn't allowed to anything at cid 50 or above -- this is to make sure that we sort the policies by name first -- when applying WITH CHECK, a later INSERT by Dave should fail due -- to p1r first CREATE POLICY p2r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44 AND cid < 50); -- and Dave isn't allowed to see manga documents CREATE POLICY p1r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44); \dp Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------------------+----------+-------+---------------------------------------------+-------------------+-------------------------------------------- regress_rls_schema | category | table | regress_rls_alice=arwdDxt/regress_rls_alice+| | | | | =arwdDxt/regress_rls_alice | | regress_rls_schema | document | table | regress_rls_alice=arwdDxt/regress_rls_alice+| | p1: + | | | =arwdDxt/regress_rls_alice | | (u): (dlevel <= ( SELECT uaccount.seclv + | | | | | FROM uaccount + | | | | | WHERE (uaccount.pguser = CURRENT_USER)))+ | | | | | p2r (RESTRICTIVE): + | | | | | (u): ((cid <> 44) AND (cid < 50)) + | | | | | to: regress_rls_dave + | | | | | p1r (RESTRICTIVE): + | | | | | (u): (cid <> 44) + | | | | | to: regress_rls_dave regress_rls_schema | uaccount | table | regress_rls_alice=arwdDxt/regress_rls_alice+| | | | | =r/regress_rls_alice | | \d document Table "regress_rls_schema.document" Column | Type | Collation | Nullable | Default ---------+---------+-----------+----------+--------- did | integer | | not null | cid | integer | | | dlevel | integer | | not null | dauthor | name | | | dtitle | text | | | Indexes: "document_pkey" PRIMARY KEY, btree (did) Foreign-key constraints: "document_cid_fkey" FOREIGN KEY (cid) REFERENCES category(cid) Policies: POLICY "p1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "p1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid <> 44)) POLICY "p2r" AS RESTRICTIVE TO regress_rls_dave USING (((cid <> 44) AND (cid < 50))) Number of child tables: 6 (Use \d+ to list them.) SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename = 'document' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+-----------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | document | p1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | document | p1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid <> 44) | regress_rls_schema | document | p2r | RESTRICTIVE | {regress_rls_dave} | ALL | ((cid <> 44) AND (cid < 50)) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 44 | 1 | regress_rls_bob | my first manga 6 | 22 | 1 | regress_rls_carol | great science fiction 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 44 | 4 | 1 | regress_rls_bob | my first manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (document.cid = category.cid) InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Hash -> Seq Scan on category -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (category.cid = document.cid) InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on category -> Hash -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= $0) AND f_leak(dtitle)) -- 44 would technically fail for both p2r and p1r, but we should get an error -- back from p1r for this because it sorts first INSERT INTO document VALUES (100, 44, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p1r" for table "document" -- Just to see a p2r error INSERT INTO document VALUES (100, 55, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p2r" for table "document" -- only owner can change policies ALTER POLICY p1 ON document USING (true); --fail ERROR: must be owner of table document DROP POLICY p1 ON document; --fail ERROR: must be owner of relation document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+-------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-----------------+--------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-----------------------+----------------- 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Index Scan using category_pkey on category Index Cond: (cid = document.cid) -- interaction of FK/PK constraints SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY p2 ON category USING (CASE WHEN current_user = 'regress_rls_bob' THEN cid IN (11, 33) WHEN current_user = 'regress_rls_carol' THEN cid IN (22, 44) ELSE false END); ALTER TABLE category ENABLE ROW LEVEL SECURITY; -- cannot delete PK referenced by invisible FK SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-----------------+--------------------+-----+------------ 1 | 11 | 1 | regress_rls_bob | my first novel | 11 | novel 2 | 11 | 2 | regress_rls_bob | my second novel | 11 | novel 3 | 22 | 2 | regress_rls_bob | my science fiction | | 4 | 44 | 1 | regress_rls_bob | my first manga | | 5 | 44 | 2 | regress_rls_bob | my second manga | | | | | | | 33 | technology \set VERBOSITY sqlstate DELETE FROM category WHERE cid = 33; -- fails with FK violation ERROR: 23503 \set VERBOSITY default -- can insert FK referencing invisible PK SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-------------------+-----------------------+-----+----------------- 6 | 22 | 1 | regress_rls_carol | great science fiction | 22 | science fiction 7 | 33 | 2 | regress_rls_carol | great technology book | | 8 | 44 | 1 | regress_rls_carol | great manga | 44 | manga INSERT INTO document VALUES (11, 33, 1, current_user, 'hoge'); -- UNIQUE or PRIMARY KEY constraint violation DOES reveal presence of row SET SESSION AUTHORIZATION regress_rls_bob; INSERT INTO document VALUES (8, 44, 1, 'regress_rls_bob', 'my third manga'); -- Must fail with unique violation, revealing presence of did we can't see ERROR: duplicate key value violates unique constraint "5_10_document_pkey" DETAIL: Key (did)=(8) already exists. SELECT * FROM document WHERE did = 8; -- and confirm we can't see it did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- RLS policies are checked before constraints INSERT INTO document VALUES (8, 44, 1, 'regress_rls_carol', 'my third manga'); -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" UPDATE document SET did = 8, dauthor = 'regress_rls_carol' WHERE did = 5; -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database superuser does bypass RLS policy when disabled RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS disabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- -- Table inheritance and RLS policy -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE t1 (a int, junk1 text, b text); ALTER TABLE t1 DROP COLUMN junk1; -- just a disturbing factor GRANT ALL ON t1 TO public; COPY t1 FROM stdin; CREATE TABLE t2 (c float) INHERITS (t1); GRANT ALL ON t2 TO public; COPY t2 FROM stdin; CREATE TABLE t3 (c text, b text, a int); ALTER TABLE t3 INHERIT t1; GRANT ALL ON t3 TO public; COPY t3(a,b,c) FROM stdin; CREATE POLICY p1 ON t1 FOR ALL TO PUBLIC USING (a % 2 = 0); -- be even number CREATE POLICY p2 ON t2 FOR ALL TO PUBLIC USING (a % 2 = 1); -- be odd number ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; ALTER TABLE t2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- reference to system column SELECT ctid, * FROM t1; ctid | a | b -------+---+----- (0,2) | 2 | bbb (0,4) | 4 | dad (0,2) | 2 | bcd (0,4) | 4 | def (0,2) | 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- reference to whole-row reference SELECT *, t1 FROM t1; a | b | t1 ---+-----+--------- 2 | bbb | (2,bbb) 4 | dad | (4,dad) 2 | bcd | (2,bcd) 4 | def | (4,def) 2 | yyy | (2,yyy) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- for share/update lock SELECT * FROM t1 FOR SHARE; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- union all query SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; a | b | ctid ---+-----+------- 1 | abc | (0,1) 3 | cde | (0,3) 1 | xxx | (0,1) 2 | yyy | (0,2) 3 | zzz | (0,3) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; --- QUERY PLAN --- Append -> Seq Scan on t2 Filter: ((a % 2) = 1) -> Seq Scan on t3 -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- -- Hyper Tables -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE hyper_document ( did int, cid int, dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON hyper_document TO public; SELECT public.create_hypertable('hyper_document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------------- (2,regress_rls_schema,hyper_document,t) INSERT INTO hyper_document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 99, 2, 'regress_rls_bob', 'my science textbook'), ( 4, 55, 1, 'regress_rls_bob', 'my first satire'), ( 5, 99, 2, 'regress_rls_bob', 'my history book'), ( 6, 11, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 99, 2, 'regress_rls_carol', 'great technology book'), ( 8, 55, 2, 'regress_rls_carol', 'great satire'), ( 9, 11, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 99, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE hyper_document ENABLE ROW LEVEL SECURITY; GRANT ALL ON _timescaledb_internal._hyper_2_9_chunk TO public; -- Create policy on parent -- user's security level must be higher than or equal to document's CREATE POLICY pp1 ON hyper_document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- Dave is only allowed to see cid < 55 CREATE POLICY pp1r ON hyper_document AS RESTRICTIVE TO regress_rls_dave USING (cid < 55); \d+ hyper_document Table "regress_rls_schema.hyper_document" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ---------+---------+-----------+----------+---------+----------+--------------+------------- did | integer | | not null | | plain | | cid | integer | | | | plain | | dlevel | integer | | not null | | plain | | dauthor | name | | | | plain | | dtitle | text | | | | extended | | Indexes: "hyper_document_did_idx" btree (did DESC) Policies: POLICY "pp1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "pp1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid < 55)) Child tables: _timescaledb_internal._hyper_2_10_chunk, _timescaledb_internal._hyper_2_11_chunk, _timescaledb_internal._hyper_2_12_chunk, _timescaledb_internal._hyper_2_13_chunk, _timescaledb_internal._hyper_2_14_chunk, _timescaledb_internal._hyper_2_9_chunk SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename like '%hyper_document%' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+----------------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | hyper_document | pp1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | hyper_document | pp1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid < 55) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first satire NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 55 | 1 | regress_rls_bob | my first satire 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -- pp1 ERROR INSERT INTO hyper_document VALUES (1, 11, 5, 'regress_rls_dave', 'testing pp1'); -- fail ERROR: new row violates row-level security policy for table "hyper_document" -- pp1r ERROR INSERT INTO hyper_document VALUES (1, 99, 1, 'regress_rls_dave', 'testing pp1r'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- Show that RLS policy does not apply for direct inserts to children -- This should fail with RLS POLICY pp1r violation. INSERT INTO hyper_document VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- But this should succeed. INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- success -- We still cannot see the row using the parent SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction -- But we can if we look directly SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- Turn on RLS and create policy on child to show RLS is checked before constraints SET SESSION AUTHORIZATION regress_rls_alice; ALTER TABLE _timescaledb_internal._hyper_2_9_chunk ENABLE ROW LEVEL SECURITY; CREATE POLICY pp3 ON _timescaledb_internal._hyper_2_9_chunk AS RESTRICTIVE USING (cid < 55); -- This should fail with RLS violation now. SET SESSION AUTHORIZATION regress_rls_dave; INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables - round 2'); -- fail ERROR: new row violates row-level security policy for table "_hyper_2_9_chunk" -- And now we cannot see directly into the partition either, due to RLS SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- The parent looks same as before -- viewpoint from regress_rls_dave SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= $0) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 (returns $0) -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= $0) AND f_leak(dtitle)) -- only owner can change policies ALTER POLICY pp1 ON hyper_document USING (true); --fail ERROR: must be owner of table hyper_document DROP POLICY pp1 ON hyper_document; --fail ERROR: must be owner of relation hyper_document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY pp1 ON hyper_document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+--------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 -> Seq Scan on hyper_document hyper_document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- When RLS disabled, other users get ERROR. SET SESSION AUTHORIZATION regress_rls_dave; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "hyper_document" SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "_hyper_2_9_chunk" -- Check behavior with a policy that uses a SubPlan not an InitPlan. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE POLICY pp3 ON hyper_document AS RESTRICTIVE USING ((SELECT dlevel <= seclv FROM uaccount WHERE pguser = current_user)); SET SESSION AUTHORIZATION regress_rls_carol; INSERT INTO hyper_document VALUES (100, 11, 5, 'regress_rls_carol', 'testing pp3'); -- fail ERROR: new row violates row-level security policy "pp3" for table "hyper_document" ----- Dependencies ----- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE dependee (x integer, y integer); SELECT public.create_hypertable('dependee', 'x', chunk_time_interval=>2); create_hypertable ----------------------------------- (3,regress_rls_schema,dependee,t) CREATE TABLE dependent (x integer, y integer); SELECT public.create_hypertable('dependent', 'x', chunk_time_interval=>2); create_hypertable ------------------------------------ (4,regress_rls_schema,dependent,t) CREATE POLICY d1 ON dependent FOR ALL TO PUBLIC USING (x = (SELECT d.x FROM dependee d WHERE d.y = y)); DROP TABLE dependee; -- Should fail without CASCADE due to dependency on row security qual? ERROR: cannot drop table dependee because other objects depend on it DETAIL: policy d1 on table dependent depends on table dependee HINT: Use DROP ... CASCADE to drop the dependent objects too. DROP TABLE dependee CASCADE; NOTICE: drop cascades to policy d1 on table dependent EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM dependent; -- After drop, should be unqualified --- QUERY PLAN --- Seq Scan on dependent ----- RECURSION ---- -- -- Simple recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec1 (x integer, y integer); SELECT public.create_hypertable('rec1', 'x', chunk_time_interval=>2); create_hypertable ------------------------------- (5,regress_rls_schema,rec1,t) CREATE POLICY r1 ON rec1 USING (x = (SELECT r.x FROM rec1 r WHERE y = r.y)); ALTER TABLE rec1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, direct recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec2 (a integer, b integer); SELECT public.create_hypertable('rec2', 'x', chunk_time_interval=>2); ERROR: column "x" does not exist ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2 WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1 WHERE y = b)); ALTER TABLE rec2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via views -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rec1v AS SELECT * FROM rec1; CREATE VIEW rec2v AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); ALTER POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via views ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via .s.b views -- SET SESSION AUTHORIZATION regress_rls_bob; \set VERBOSITY terse \\ -- suppress cascade details DROP VIEW rec1v, rec2v CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE VIEW rec1v WITH (security_barrier) AS SELECT * FROM rec1; CREATE VIEW rec2v WITH (security_barrier) AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via s.b. views ERROR: infinite recursion detected in policy for relation "rec1" -- -- recursive RLS and VIEWs in policy -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE s1 (a int, b text); SELECT public.create_hypertable('s1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (6,regress_rls_schema,s1,t) INSERT INTO s1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE TABLE s2 (x int, y text); SELECT public.create_hypertable('s2', 'x', chunk_time_interval=>2); create_hypertable ----------------------------- (7,regress_rls_schema,s2,t) INSERT INTO s2 (SELECT x, md5(x::text) FROM generate_series(-6,6) x); GRANT SELECT ON s1, s2 TO regress_rls_bob; CREATE POLICY p1 ON s1 USING (a in (select x from s2 where y like '%2f%')); CREATE POLICY p2 ON s2 USING (x in (select a from s1 where b like '%22%')); CREATE POLICY p3 ON s1 FOR INSERT WITH CHECK (a = (SELECT a FROM s1)); ALTER TABLE s1 ENABLE ROW LEVEL SECURITY; ALTER TABLE s2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW v2 AS SELECT * FROM s2 WHERE y like '%af%'; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" INSERT INTO s1 VALUES (1, 'foo'); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3 on s1; ALTER POLICY p2 ON s2 USING (x % 2 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c a | b ---+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b); --- QUERY PLAN --- Seq Scan on s1 Filter: ((hashed SubPlan 1) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON s1 USING (a in (select x from v2)); -- using VIEW in RLS policy SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => 0267aaf632e87a63288a08331f22c7c3 NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc a | b ----+---------------------------------- -4 | 0267aaf632e87a63288a08331f22c7c3 6 | 1679091c5a880faf6fb5e6087eb1b2dc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM s1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on s1 Chunks excluded during startup: 0 -> Seq Scan on s1 s1_1 Filter: ((hashed SubPlan 1) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: ((hashed SubPlan 1) AND f_leak(b)) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: ((hashed SubPlan 1) AND f_leak(b)) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; xx | x | y ----+----+---------------------------------- -6 | -6 | 596a3d04481816330f07e4f97510c28f -4 | -4 | 0267aaf632e87a63288a08331f22c7c3 2 | 2 | c81e728d9d4c2f636f067f89cc14862c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; --- QUERY PLAN --- Result -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) SubPlan 2 -> Limit -> Result -> Custom Scan (ChunkAppend) on s1 -> Seq Scan on s1 s1_1 Filter: (hashed SubPlan 1) SubPlan 1 -> Append -> Seq Scan on s2 s2_10 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_11 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_12 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_13 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_14 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_15 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_16 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_17 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: (hashed SubPlan 1) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: (hashed SubPlan 1) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p2 ON s2 USING (x in (select a from s1 where b like '%d2%')); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion via view) ERROR: infinite recursion detected in policy for relation "s1" -- prepared statement with regress_rls_alice privilege PREPARE p1(int) AS SELECT * FROM t1 WHERE a <= $1; EXECUTE p1(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a <= 2) AND ((a % 2) = 0)) -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- plan cache should be invalidated EXECUTE p1(2); a | b ---+----- 1 | aba 2 | bbb 1 | abc 2 | bcd 1 | xxx 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a <= 2) -> Seq Scan on t2 t1_2 Filter: (a <= 2) -> Seq Scan on t3 t1_3 Filter: (a <= 2) PREPARE p2(int) AS SELECT * FROM t1 WHERE a = $1; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a = 2) -> Seq Scan on t2 t1_2 Filter: (a = 2) -> Seq Scan on t3 t1_3 Filter: (a = 2) -- also, case when privilege switch from superuser SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a = 2) AND ((a % 2) = 0)) -- -- UPDATE / DELETE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_bob; EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Result -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b = b || b WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); --- QUERY PLAN --- Update on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); NOTICE: f_leak => bbbbbb NOTICE: f_leak => daddad -- returning clause with system column UPDATE only t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,9) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,10) | 4 | daddad_updt | (4,daddad_updt) UPDATE t1 SET b = b WHERE f_leak(b) RETURNING *; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy a | b ---+------------- 2 | bbbbbb_updt 4 | daddad_updt 2 | bcdbcd 4 | defdef 2 | yyyyyy UPDATE t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,14) | 4 | daddad_updt | (4,daddad_updt) (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,10) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- updates with from clause EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t3 Filter: ((a = 2) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); NOTICE: f_leak => cde NOTICE: f_leak => yyyyyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde -- updates with from clause self join EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; --- QUERY PLAN --- Update on t2 t2_1 -> Nested Loop Join Filter: (t2_1.b = t2_2.b) -> Seq Scan on t2 t2_1 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t2 t2_2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; NOTICE: f_leak => cde NOTICE: f_leak => cde a | b | c | a | b | c | t2_1 | t2_2 ---+-----+-----+---+-----+-----+-------------+------------- 3 | cde | 3.3 | 3 | cde | 3.3 | (3,cde,3.3) | (3,cde,3.3) EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; --- QUERY PLAN --- Update on t1 t1_1 Update on t1 t1_1_1 Update on t2 t1_1_2 Update on t3 t1_1_3 -> Nested Loop Join Filter: (t1_1.b = t1_2.b) -> Append -> Seq Scan on t1 t1_1_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_1_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_1_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Materialize -> Append -> Seq Scan on t1 t1_2_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_2_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; NOTICE: f_leak => daddad_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => defdef NOTICE: f_leak => defdef a | b | a | b | t1_1 | t1_2 ---+-------------+---+-------------+-----------------+----------------- 4 | daddad_updt | 4 | daddad_updt | (4,daddad_updt) | (4,daddad_updt) 4 | defdef | 4 | defdef | (4,defdef) | (4,defdef) RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 ORDER BY a,b; a | b ---+------------- 1 | aba 1 | abc 1 | xxx 2 | bbbbbb_updt 2 | bcdbcd 2 | yyyyyy 3 | ccc 3 | cde 3 | zzz 4 | daddad_updt 4 | defdef SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM only t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 Delete on t1 t1_1 Delete on t2 t1_2 Delete on t3 t1_3 -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM only t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,15) | 4 | daddad_updt | (4,daddad_updt) DELETE FROM t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+--------+------------ (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,13) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- -- S.b. view on top of Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE b1 (a int, b text); SELECT public.create_hypertable('b1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (8,regress_rls_schema,b1,t) INSERT INTO b1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE POLICY p1 ON b1 USING (a % 2 = 0); ALTER TABLE b1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON b1 TO regress_rls_bob; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW bv1 WITH (security_barrier) AS SELECT * FROM b1 WHERE a > 0 WITH CHECK OPTION; GRANT ALL ON bv1 TO regress_rls_carol; SET SESSION AUTHORIZATION regress_rls_carol; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM bv1 WHERE f_leak(b); --- QUERY PLAN --- Subquery Scan on bv1 Filter: f_leak(bv1.b) -> Append -> Seq Scan on b1 b1_1 Filter: ((a > 0) AND ((a % 2) = 0)) -> Index Scan using _hyper_8_39_chunk_b1_a_idx on _hyper_8_39_chunk b1_2 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_40_chunk_b1_a_idx on _hyper_8_40_chunk b1_3 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_4 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_5 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_43_chunk_b1_a_idx on _hyper_8_43_chunk b1_6 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_44_chunk_b1_a_idx on _hyper_8_44_chunk b1_7 Index Cond: (a > 0) Filter: ((a % 2) = 0) SELECT * FROM bv1 WHERE f_leak(b); NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 a | b ----+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 INSERT INTO bv1 VALUES (-1, 'xxx'); -- should fail view WCO ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (11, 'xxx'); -- should fail RLS check ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (12, 'xxx'); -- ok EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on b1 Update on _hyper_8_41_chunk b1_1 -> Result -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_1 Index Cond: ((a > 0) AND (a = 4)) Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on b1 Delete on _hyper_8_42_chunk b1_1 -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_1 Index Cond: ((a > 0) AND (a = 6)) Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM b1; a | b -----+---------------------------------- -10 | 1b0fd9efa5279c4203b7c70233f86dbf -9 | 252e691406782824eec43d7eadc3d256 -8 | a8d2ec85eaf98407310b72eb73dda247 -7 | 74687a12d3915d3c4d83f1af7b3683d5 -6 | 596a3d04481816330f07e4f97510c28f -5 | 47c1b025fa18ea96c33fbb6718688c0f -4 | 0267aaf632e87a63288a08331f22c7c3 -3 | b3149ecea4628efd23d2f86e5a723472 -2 | 5d7b9adcbe1c629ec722529dd12e5129 -1 | 6bb61e3b7bce0931da574d19d1d82c88 0 | cfcd208495d565ef66e7dff9f98764da 1 | c4ca4238a0b923820dcc509a6f75849b 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | yyy 7 | 8f14e45fceea167a5a36dedd4bea2543 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | xxx -- -- INSERT ... ON CONFLICT DO UPDATE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p1r ON document; CREATE POLICY p1 ON document FOR SELECT USING (true); CREATE POLICY p2 ON document FOR INSERT WITH CHECK (dauthor = current_user); CREATE POLICY p3 ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Exists... SELECT * FROM document WHERE did = 2; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------- 2 | 11 | 2 | regress_rls_bob | my second novel -- ...so violates actual WITH CHECK OPTION within UPDATE (not INSERT, since -- alternative UPDATE path happens to be taken): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, dauthor = EXCLUDED.dauthor; ERROR: new row violates row-level security policy for table "document" -- Violates USING qual for UPDATE policy p3. -- -- UPDATE path is taken, but UPDATE fails purely because *existing* row to be -- updated is not a "novel"/cid 11 (row is not leaked, even though we have -- SELECT privileges sufficient to see the row in this instance): INSERT INTO document VALUES (33, 22, 1, 'regress_rls_bob', 'okay science fiction'); -- preparation for next statement INSERT INTO document VALUES (33, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'Some novel, replaces sci-fi') -- takes UPDATE path ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fine (we UPDATE, since INSERT WCOs and UPDATE security barrier quals + WCOs -- not violated): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------- 2 | 11 | 2 | regress_rls_bob | my first novel -- Fine (we INSERT, so "cid = 33" ("technology") isn't evaluated): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 11 | 1 | regress_rls_bob | some technology novel -- Fine (same query, but we UPDATE, so "cid = 33", ("technology") is not the -- case in respect of *existing* tuple): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 33 | 1 | regress_rls_bob | some technology novel -- Same query a third time, but now fails due to existing tuple finally not -- passing quals: INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Don't fail just because INSERT doesn't satisfy WITH CHECK option that -- originated as a barrier/USING() qual from the UPDATE. Note that the UPDATE -- path *isn't* taken, and so UPDATE-related policy does not apply: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------------------------- 79 | 33 | 1 | regress_rls_bob | technology book, can only insert -- But this time, the same statement fails, because the UPDATE path is taken, -- and updating the row just inserted falls afoul of security barrier qual -- (enforced as WCO) -- what we might have updated target tuple to is -- irrelevant, in fact. INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Test default USING qual enforced as WCO SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p2 ON document; DROP POLICY p3 ON document; CREATE POLICY p3_with_default ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')); SET SESSION AUTHORIZATION regress_rls_bob; -- Just because WCO-style enforcement of USING quals occurs with -- existing/target tuple does not mean that the implementation can be allowed -- to fail to also enforce this qual against the final tuple appended to -- relation (since in the absence of an explicit WCO, this is also interpreted -- as an UPDATE/ALL WCO in general). -- -- UPDATE path is taken here (fails due to existing tuple). Note that this is -- not reported as a "USING expression", because it's an RLS UPDATE check that originated as -- a USING qual for the purposes of RLS in general, as opposed to an explicit -- USING qual that is ordinarily a security barrier. We leave it up to the -- UPDATE to make this fail: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" -- UPDATE path is taken here. Existing tuple passes, since it's cid -- corresponds to "novel", but default USING qual is enforced against -- post-UPDATE tuple too (as always when updating with a policy that lacks an -- explicit WCO), and so this fails: INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET cid = EXCLUDED.cid, dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3_with_default ON document; -- -- Test ALL policies with ON CONFLICT DO UPDATE (much the same as existing UPDATE -- tests) -- CREATE POLICY p3_with_all ON document FOR ALL USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Fails, since ALL WCO is enforced in insert path: INSERT INTO document VALUES (80, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33; ERROR: new row violates row-level security policy for table "document" -- Fails, since ALL policy USING qual is enforced (existing, target tuple is in -- violation, since it has the "manga" cid): INSERT INTO document VALUES (4, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fails, since ALL WCO are enforced: INSERT INTO document VALUES (1, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dauthor = 'regress_rls_carol'; ERROR: new row violates row-level security policy for table "document" -- -- ROLE/GROUP -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE z1 (a int, b text); SELECT public.create_hypertable('z1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (9,regress_rls_schema,z1,t) CREATE TABLE z2 (a int, b text); SELECT public.create_hypertable('z2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (10,regress_rls_schema,z2,t) GRANT SELECT ON z1,z2 TO regress_rls_group1, regress_rls_group2, regress_rls_bob, regress_rls_carol; INSERT INTO z1 VALUES (1, 'aba'), (2, 'bbb'), (3, 'ccc'), (4, 'dad'); CREATE POLICY p1 ON z1 TO regress_rls_group1 USING (a % 2 = 0); CREATE POLICY p2 ON z1 TO regress_rls_group2 USING (a % 2 = 1); ALTER TABLE z1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test AS SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test2 AS WITH q AS MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test4 AS WITH q AS (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test6 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test6; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test3 AS WITH q AS MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test5 AS WITH q AS (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test7 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test7; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET ROLE regress_rls_group1; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) SET ROLE regress_rls_group2; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -- -- Views should follow policy for view owner. -- -- View and Table owner are the same. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_bob; -- Query as role that is not owner of view or table. Should return all records. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) -- Query as view/table owner. Should return all records. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) DROP VIEW rls_view; -- View and Table owners are different. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_alice; -- Query as role that is not owner of view but is owner of table. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not owner of table but is owner of view. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not the owner of the table or view without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view -- Query as role that is not the owner of the table or view with permissions. SET SESSION AUTHORIZATION regress_rls_bob; GRANT SELECT ON rls_view TO regress_rls_carol; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_bob; DROP VIEW rls_view; -- -- Command specific -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE x1 (a int, b text, c text); SELECT public.create_hypertable('x1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (11,regress_rls_schema,x1,t) GRANT ALL ON x1 TO PUBLIC; INSERT INTO x1 VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_carol'), (4, 'def', 'regress_rls_carol'), (5, 'efg', 'regress_rls_bob'), (6, 'fgh', 'regress_rls_bob'), (7, 'fgh', 'regress_rls_carol'), (8, 'fgh', 'regress_rls_carol'); CREATE POLICY p0 ON x1 FOR ALL USING (c = current_user); CREATE POLICY p1 ON x1 FOR SELECT USING (a % 2 = 0); CREATE POLICY p2 ON x1 FOR INSERT WITH CHECK (a % 2 = 1); CREATE POLICY p3 ON x1 FOR UPDATE USING (a % 2 = 0); CREATE POLICY p4 ON x1 FOR DELETE USING (a < 8); ALTER TABLE x1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+-----+------------------- 1 | abc | regress_rls_bob 2 | bcd | regress_rls_bob 4 | def | regress_rls_carol 5 | efg | regress_rls_bob 6 | fgh | regress_rls_bob 8 | fgh | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+----------+------------------- 1 | abc_updt | regress_rls_bob 2 | bcd_updt | regress_rls_bob 4 | def_updt | regress_rls_carol 5 | efg_updt | regress_rls_bob 6 | fgh_updt | regress_rls_bob 8 | fgh_updt | regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+----------+------------------- 2 | bcd_updt | regress_rls_bob 3 | cde | regress_rls_carol 4 | def_updt | regress_rls_carol 6 | fgh_updt | regress_rls_bob 7 | fgh | regress_rls_carol 8 | fgh_updt | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol DELETE FROM x1 WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde_updt NOTICE: f_leak => bcd_updt_updt NOTICE: f_leak => def_updt_updt NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt_updt NOTICE: f_leak => fgh_updt_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol -- -- Duplicate Policy Names -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE y1 (a int, b text); SELECT public.create_hypertable('y1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (12,regress_rls_schema,y1,t) INSERT INTO y1 VALUES(1,2); CREATE TABLE y2 (a int, b text); SELECT public.create_hypertable('y2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (13,regress_rls_schema,y2,t) GRANT ALL ON y1, y2 TO regress_rls_bob; CREATE POLICY p1 ON y1 FOR ALL USING (a % 2 = 0); CREATE POLICY p2 ON y1 FOR SELECT USING (a > 2); CREATE POLICY p1 ON y1 FOR SELECT USING (a % 2 = 1); --fail ERROR: policy "p1" for table "y1" already exists CREATE POLICY p1 ON y2 FOR ALL USING (a % 2 = 0); --OK ALTER TABLE y1 ENABLE ROW LEVEL SECURITY; ALTER TABLE y2 ENABLE ROW LEVEL SECURITY; -- -- Expression structure with SBV -- -- Create view as table owner. RLS should NOT be applied. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: (f_leak(b) AND (a = 1)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: f_leak(b) DROP VIEW rls_sbv; -- Create view as role that does not own table. RLS should be applied. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: ((a = 1) AND ((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: (((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) DROP VIEW rls_sbv; -- -- Expression structure -- SET SESSION AUTHORIZATION regress_rls_alice; INSERT INTO y2 (SELECT x, md5(x::text) FROM generate_series(0,20) x); CREATE POLICY p2 ON y2 USING (a % 3 = 0); CREATE POLICY p3 ON y2 USING (a % 4 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM y2 WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -- -- Qual push-down of leaky functions, when not referring to table -- SELECT * FROM y2 WHERE f_leak('abc'); NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak('abc'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) CREATE TABLE test_qual_pushdown ( abc text ); INSERT INTO test_qual_pushdown VALUES ('abc'),('def'); SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); NOTICE: f_leak => abc NOTICE: f_leak => def a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); --- QUERY PLAN --- Hash Join Hash Cond: (y2.b = test_qual_pushdown.abc) -> Append -> Seq Scan on y2 y2_1 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Hash -> Seq Scan on test_qual_pushdown Filter: f_leak(abc) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); --- QUERY PLAN --- Hash Join Hash Cond: (test_qual_pushdown.abc = y2.b) -> Seq Scan on test_qual_pushdown -> Hash -> Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) DROP TABLE test_qual_pushdown; -- -- Plancache invalidate on user change. -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP TABLE t1 CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE TABLE t1 (a integer); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (14,regress_rls_schema,t1,t) GRANT SELECT ON t1 TO regress_rls_bob, regress_rls_carol; CREATE POLICY p1 ON t1 TO regress_rls_bob USING ((a % 2) = 0); CREATE POLICY p2 ON t1 TO regress_rls_carol USING ((a % 4) = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; -- Prepare as regress_rls_bob SET ROLE regress_rls_bob; PREPARE role_inval AS SELECT * FROM t1; -- Check plan EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- Change to regress_rls_carol SET ROLE regress_rls_carol; -- Check plan- should be different EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 4) = 0) -- Change back to regress_rls_bob SET ROLE regress_rls_bob; -- Check plan- should be back to original EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- -- CTE and RLS -- RESET SESSION AUTHORIZATION; DROP TABLE t1 CASCADE; CREATE TABLE t1 (a integer, b text); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (15,regress_rls_schema,t1,t) CREATE POLICY p1 ON t1 USING (a % 2 = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON t1 TO regress_rls_bob; INSERT INTO t1 (SELECT x, md5(x::text) FROM generate_series(0,20) x); SET SESSION AUTHORIZATION regress_rls_bob; WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; --- QUERY PLAN --- CTE Scan on cte1 CTE cte1 -> Custom Scan (ChunkAppend) on t1 Chunks excluded during startup: 0 -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: (((a % 2) = 0) AND f_leak(b)) WITH cte1 AS (UPDATE t1 SET a = a + 1 RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (UPDATE t1 SET a = a RETURNING *) SELECT * FROM cte1; --ok a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 WITH cte1 AS (INSERT INTO t1 VALUES (21, 'Fail') RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (INSERT INTO t1 VALUES (20, 'Success') RETURNING *) SELECT * FROM cte1; --ok a | b ----+--------- 20 | Success -- -- Rename Policy -- RESET SESSION AUTHORIZATION; ALTER POLICY p1 ON t1 RENAME TO p1; --fail ERROR: policy "p1" for table "t1" already exists SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p1 | t1 ALTER POLICY p1 ON t1 RENAME TO p2; --ok SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p2 | t1 -- -- Check INSERT SELECT -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE TABLE t2 (a integer, b text); SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (16,regress_rls_schema,t2,t) INSERT INTO t2 (SELECT * FROM t1); EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO t2 (SELECT * FROM t1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on t2 -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: ((a % 2) = 0) SELECT * FROM t2; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t2; --- QUERY PLAN --- Append -> Seq Scan on t2 t2_1 -> Seq Scan on _hyper_16_80_chunk t2_2 -> Seq Scan on _hyper_16_81_chunk t2_3 -> Seq Scan on _hyper_16_82_chunk t2_4 -> Seq Scan on _hyper_16_83_chunk t2_5 -> Seq Scan on _hyper_16_84_chunk t2_6 -> Seq Scan on _hyper_16_85_chunk t2_7 -> Seq Scan on _hyper_16_86_chunk t2_8 -> Seq Scan on _hyper_16_87_chunk t2_9 -> Seq Scan on _hyper_16_88_chunk t2_10 -> Seq Scan on _hyper_16_89_chunk t2_11 -> Seq Scan on _hyper_16_90_chunk t2_12 CREATE TABLE t3 AS SELECT * FROM t1; SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); ERROR: table "t2" is already a hypertable SELECT * FROM t3; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success SELECT * INTO t4 FROM t1; SELECT * FROM t4; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success -- -- RLS with JOIN -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE blog (id integer, author text, post text); SELECT public.create_hypertable('blog', 'id', chunk_time_interval=>2); create_hypertable -------------------------------- (17,regress_rls_schema,blog,t) CREATE TABLE comment (blog_id integer, message text); SELECT public.create_hypertable('comment', 'blog_id', chunk_time_interval=>2); create_hypertable ----------------------------------- (18,regress_rls_schema,comment,t) GRANT ALL ON blog, comment TO regress_rls_bob; CREATE POLICY blog_1 ON blog USING (id % 2 = 0); ALTER TABLE blog ENABLE ROW LEVEL SECURITY; INSERT INTO blog VALUES (1, 'alice', 'blog #1'), (2, 'bob', 'blog #1'), (3, 'alice', 'blog #2'), (4, 'alice', 'blog #3'), (5, 'john', 'blog #1'); INSERT INTO comment VALUES (1, 'cool blog'), (1, 'fun blog'), (3, 'crazy blog'), (5, 'what?'), (4, 'insane!'), (2, 'who did it?'); SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN with Non-RLS. SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! -- Check Non-RLS JOIN with RLS. SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY comment_1 ON comment USING (blog_id < 4); ALTER TABLE comment ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN RLS SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE blog; DROP TABLE comment; -- -- Default Deny Policy -- RESET SESSION AUTHORIZATION; DROP POLICY p2 ON t1; ALTER TABLE t1 OWNER TO regress_rls_alice; -- Check that default deny does not apply to superuser. RESET SESSION AUTHORIZATION; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny does not apply to table owner. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny applies to non-owner/non-superuser when RLS on. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false -- -- COPY TO/FROM -- RESET SESSION AUTHORIZATION; DROP TABLE copy_t CASCADE; ERROR: table "copy_t" does not exist CREATE TABLE copy_t (a integer, b text); SELECT public.create_hypertable('copy_t', 'a', chunk_time_interval=>2); create_hypertable ---------------------------------- (19,regress_rls_schema,copy_t,t) CREATE POLICY p1 ON copy_t USING (a % 2 = 0); ALTER TABLE copy_t ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_t TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_t (SELECT x, md5(x::text) FROM generate_series(0,10) x); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 2,c81e728d9d4c2f636f067f89cc14862c 4,a87ff679a2f3e71d9181a67b7542122c 6,1679091c5a880faf6fb5e6087eb1b2dc 8,c9f0f895fb98ab9159f51fd0297e236d 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_t -- Check COPY relation TO; keep it just one row to avoid reordering issues RESET SESSION AUTHORIZATION; SET row_security TO ON; CREATE TABLE copy_rel_to (a integer, b text); SELECT public.create_hypertable('copy_rel_to', 'a', chunk_time_interval=>2); create_hypertable --------------------------------------- (20,regress_rls_schema,copy_rel_to,t) CREATE POLICY p1 ON copy_rel_to USING (a % 2 = 0); ALTER TABLE copy_rel_to ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_rel_to TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_rel_to VALUES (1, md5('1')); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_rel_to -- Check COPY FROM as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY copy_t FROM STDIN; --ok SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - would be affected by RLS. ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY copy_t FROM STDIN; --fail - COPY FROM not supported by RLS. ERROR: COPY FROM not supported with row-level security HINT: Use INSERT statements instead. -- Check COPY FROM as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t SET row_security TO ON; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t RESET SESSION AUTHORIZATION; DROP TABLE copy_t; DROP TABLE copy_rel_to CASCADE; -- Check WHERE CURRENT OF SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE current_check (currentid int, payload text, rlsuser text); SELECT public.create_hypertable('current_check', 'currentid', chunk_time_interval=>10); create_hypertable ----------------------------------------- (21,regress_rls_schema,current_check,t) GRANT ALL ON current_check TO PUBLIC; INSERT INTO current_check VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_bob'), (4, 'def', 'regress_rls_bob'); CREATE POLICY p1 ON current_check FOR SELECT USING (currentid % 2 = 0); CREATE POLICY p2 ON current_check FOR DELETE USING (currentid = 4 AND rlsuser = current_user); CREATE POLICY p3 ON current_check FOR UPDATE USING (currentid = 4) WITH CHECK (rlsuser = current_user); ALTER TABLE current_check ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Can SELECT even rows SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def | regress_rls_bob -- Cannot UPDATE row 2 UPDATE current_check SET payload = payload || '_new' WHERE currentid = 2 RETURNING *; currentid | payload | rlsuser -----------+---------+--------- BEGIN; -- WHERE CURRENT OF does not work with custom scan nodes -- so we have to disable chunk append here SET timescaledb.enable_chunk_append TO false; DECLARE current_check_cursor SCROLL CURSOR FOR SELECT * FROM current_check; -- Returns rows that can be seen according to SELECT policy, like plain SELECT -- above (even rows) FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob -- Still cannot UPDATE row 2 through cursor UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- -- Can update row 4 through cursor, which is the next visible row FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def_new | regress_rls_bob -- Plan should be a subquery TID scan EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE current_check SET payload = payload WHERE CURRENT OF current_check_cursor; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on current_check Update on _hyper_21_104_chunk current_check_1 -> Tid Scan on _hyper_21_104_chunk current_check_1 TID Cond: CURRENT OF current_check_cursor Filter: ((currentid = 4) AND ((currentid % 2) = 0)) -- Similarly can only delete row 4 FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob RESET timescaledb.enable_chunk_append; COMMIT; -- -- check pg_stats view filtering -- SET row_security TO ON; SET SESSION AUTHORIZATION regress_rls_alice; ANALYZE current_check; -- Stats visible SELECT row_security_active('current_check'); row_security_active --------------------- f SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals -----------+------------------- currentid | payload | rlsuser | {regress_rls_bob} SET SESSION AUTHORIZATION regress_rls_bob; -- Stats not visible SELECT row_security_active('current_check'); row_security_active --------------------- t SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals ---------+------------------ -- -- Collation support -- BEGIN; CREATE TABLE coll_t (c) AS VALUES ('bar'::text); CREATE POLICY coll_p ON coll_t USING (c < ('foo'::text COLLATE "C")); ALTER TABLE coll_t ENABLE ROW LEVEL SECURITY; GRANT SELECT ON coll_t TO regress_rls_alice; SELECT (string_to_array(polqual, ':'))[7] AS inputcollid FROM pg_policy WHERE polrelid = 'coll_t'::regclass; inputcollid ------------------ inputcollid 950 SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM coll_t; c ----- bar ROLLBACK; -- -- Shared Object Dependencies -- RESET SESSION AUTHORIZATION; BEGIN; CREATE ROLE regress_rls_eve; CREATE ROLE regress_rls_frank; CREATE TABLE tbl1 (c) AS VALUES ('bar'::text); GRANT SELECT ON TABLE tbl1 TO regress_rls_eve; CREATE POLICY P ON tbl1 TO regress_rls_eve, regress_rls_frank USING (true); SELECT refclassid::regclass, deptype FROM pg_depend WHERE classid = 'pg_policy'::regclass AND refobjid = 'tbl1'::regclass; refclassid | deptype ------------+--------- pg_class | a SELECT refclassid::regclass, deptype FROM pg_shdepend WHERE classid = 'pg_policy'::regclass AND refobjid IN ('regress_rls_eve'::regrole, 'regress_rls_frank'::regrole); refclassid | deptype ------------+--------- pg_authid | r pg_authid | r SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on POLICY p ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 target of policy p on table tbl1 ROLLBACK TO q; ALTER POLICY p ON tbl1 TO regress_rls_frank USING (true); SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on GRANT SELECT ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 ROLLBACK TO q; REVOKE ALL ON TABLE tbl1 FROM regress_rls_eve; SAVEPOINT q; DROP ROLE regress_rls_eve; --succeeds ROLLBACK TO q; SAVEPOINT q; DROP ROLE regress_rls_frank; --fails due to dependency on POLICY p ERROR: role "regress_rls_frank" cannot be dropped because some objects depend on it DETAIL: target of policy p on table tbl1 ROLLBACK TO q; DROP POLICY p ON tbl1; SAVEPOINT q; DROP ROLE regress_rls_frank; -- succeeds ROLLBACK TO q; ROLLBACK; -- cleanup -- -- Converting table to view -- BEGIN; CREATE TABLE t (c int); SELECT public.create_hypertable('t', 'c', chunk_time_interval=>2); create_hypertable ----------------------------- (22,regress_rls_schema,t,t) CREATE POLICY p ON t USING (c % 2 = 1); ALTER TABLE t ENABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to row level security enabled ERROR: hypertables do not support rules ROLLBACK TO q; ALTER TABLE t DISABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to policy p on t ERROR: hypertables do not support rules ROLLBACK TO q; DROP POLICY p ON t; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- succeeds ERROR: hypertables do not support rules ROLLBACK; -- -- Policy expression handling -- BEGIN; CREATE TABLE t (c) AS VALUES ('bar'::text); CREATE POLICY p ON t USING (max(c)); -- fails: aggregate functions are not allowed in policy expressions ERROR: aggregate functions are not allowed in policy expressions ROLLBACK; -- -- Non-target relations are only subject to SELECT policies -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (23,regress_rls_schema,r1,t) CREATE TABLE r2 (a int); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (24,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); GRANT ALL ON r1, r2 TO regress_rls_bob; CREATE POLICY p1 ON r1 USING (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON r2 FOR SELECT USING (true); CREATE POLICY p2 ON r2 FOR INSERT WITH CHECK (false); CREATE POLICY p3 ON r2 FOR UPDATE USING (false); CREATE POLICY p4 ON r2 FOR DELETE USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM r1; a ---- 10 20 SELECT * FROM r2; a ---- 10 20 -- r2 is read-only INSERT INTO r2 VALUES (2); -- Not allowed ERROR: new row violates row-level security policy for table "r2" \pset tuples_only 1 UPDATE r2 SET a = 2 RETURNING *; -- Updates nothing DELETE FROM r2 RETURNING *; -- Deletes nothing \pset tuples_only 0 -- r2 can be used as a non-target relation in DML INSERT INTO r1 SELECT a + 1 FROM r2 RETURNING *; -- OK a ---- 11 21 UPDATE r1 SET a = r2.a + 2 FROM r2 WHERE r1.a = r2.a RETURNING *; -- OK ERROR: new row for relation "_hyper_23_105_chunk" violates check constraint "constraint_105" DELETE FROM r1 USING r2 WHERE r1.a = r2.a + 2 RETURNING *; -- OK a | a ---+--- SELECT * FROM r1; a ---- 10 11 20 21 SELECT * FROM r2; a ---- 10 20 SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE r1; DROP TABLE r2; -- -- FORCE ROW LEVEL SECURITY applies RLS to owners too -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (25,regress_rls_schema,r1,t) INSERT INTO r1 VALUES (10), (20); CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No error, but no rows TABLE r1; a --- -- RLS error INSERT INTO r1 VALUES (1); ERROR: new row violates row-level security policy for table "r1" -- No error (unable to see any rows to update) UPDATE r1 SET a = 1; TABLE r1; a --- -- No error (unable to see any rows to delete) DELETE FROM r1; TABLE r1; a --- SET row_security = off; -- these all fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. UPDATE r1 SET a = 1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DELETE FROM r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DROP TABLE r1; -- -- FORCE ROW LEVEL SECURITY does not break RI -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (26,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Errors due to rows in r2 DELETE FROM r1; ERROR: update or delete on table "r1" violates foreign key constraint "r2_a_fkey" on table "r2" DETAIL: Key (a)=(10) is still referenced from table "r2". -- Reset r2 to no-RLS DROP POLICY p1 ON r2; ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; ALTER TABLE r2 DISABLE ROW LEVEL SECURITY; -- clean out r2 for INSERT test below DELETE FROM r2; -- Change r1 to not allow rows to be seen CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No rows seen TABLE r1; a --- -- No error, RI still sees that row exists in r1 INSERT INTO r2 VALUES (10); DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded DELETE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON DELETE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (27,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Deletes all records from both DELETE FROM r1; -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify no rows in r2 now TABLE r2; a --- DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded UPDATE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON UPDATE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (28,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Updates records in both (terse output to not print CONTEXT, which can be different). \set VERBOSITY terse UPDATE r1 SET a = a+5; ERROR: new row for relation "_hyper_28_117_chunk" violates check constraint "constraint_117" \set VERBOSITY default -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify records in r2 updated TABLE r2; a ---- 10 20 DROP TABLE r2; DROP TABLE r1; -- -- Test INSERT+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (29,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (false); CREATE POLICY p2 ON r1 FOR INSERT WITH CHECK (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine INSERT INTO r1 VALUES (10), (20); -- No error, but no rows TABLE r1; a --- SET row_security = off; -- fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. SET row_security = on; -- Error INSERT INTO r1 VALUES (10), (20) RETURNING *; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- -- Test UPDATE+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>100); create_hypertable ------------------------------ (30,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (a < 20); CREATE POLICY p2 ON r1 FOR UPDATE USING (a < 20) WITH CHECK (true); CREATE POLICY p3 ON r1 FOR INSERT WITH CHECK (true); INSERT INTO r1 VALUES (10); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine UPDATE r1 SET a = 30; -- Show updated rows ALTER TABLE r1 NO FORCE ROW LEVEL SECURITY; TABLE r1; a ---- 30 -- reset value in r1 for test with RETURNING UPDATE r1 SET a = 10; -- Verify row reset TABLE r1; a ---- 10 ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Error UPDATE r1 SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- UPDATE path of INSERT ... ON CONFLICT DO UPDATE should also error out INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- Should still error out without RETURNING (use of arbiter always requires -- SELECT permissions) INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" -- ON CONFLICT ON CONSTRAINT INSERT INTO r1 VALUES (10) ON CONFLICT ON CONSTRAINT r1_pkey DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- Check dependency handling RESET SESSION AUTHORIZATION; CREATE TABLE dep1 (c1 int); SELECT public.create_hypertable('dep1', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (31,regress_rls_schema,dep1,t) CREATE TABLE dep2 (c1 int); SELECT public.create_hypertable('dep2', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (32,regress_rls_schema,dep2,t) CREATE POLICY dep_p1 ON dep1 TO regress_rls_bob USING (c1 > (select max(dep2.c1) from dep2)); ALTER POLICY dep_p1 ON dep1 TO regress_rls_bob,regress_rls_carol; -- Should return one SELECT count(*) = 1 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t ALTER POLICY dep_p1 ON dep1 USING (true); -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_bob'); ?column? ---------- t -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_carol'); ?column? ---------- t -- Should return zero SELECT count(*) = 0 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t -- DROP OWNED BY testing RESET SESSION AUTHORIZATION; CREATE ROLE regress_rls_dob_role1; CREATE ROLE regress_rls_dob_role2; CREATE TABLE dob_t1 (c1 int); SELECT public.create_hypertable('dob_t1', 'c1', chunk_time_interval=>2); create_hypertable ---------------------------------- (33,regress_rls_schema,dob_t1,t) CREATE TABLE dob_t2 (c1 int) PARTITION BY RANGE (c1); CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should fail, already gone ERROR: policy "p1" for table "dob_t1" does not exist CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should succeed CREATE POLICY p1 ON dob_t2 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t2; -- should succeed DROP USER regress_rls_dob_role1; DROP USER regress_rls_dob_role2; -- -- Clean up objects -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP SCHEMA regress_rls_schema CASCADE; NOTICE: drop cascades to 116 other objects \set VERBOSITY default DROP USER regress_rls_alice; DROP USER regress_rls_bob; DROP USER regress_rls_carol; DROP USER regress_rls_dave; DROP USER regress_rls_exempt_user; DROP ROLE regress_rls_group1; DROP ROLE regress_rls_group2; -- Arrange to have a few policies left over, for testing -- pg_dump/pg_restore CREATE SCHEMA regress_rls_schema; CREATE TABLE rls_tbl (c1 int); SELECT public.create_hypertable('rls_tbl', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------- (34,regress_rls_schema,rls_tbl,t) ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl USING (c1 > 5); CREATE POLICY p2 ON rls_tbl FOR SELECT USING (c1 <= 3); CREATE POLICY p3 ON rls_tbl FOR UPDATE USING (c1 <= 3) WITH CHECK (c1 > 5); CREATE POLICY p4 ON rls_tbl FOR DELETE USING (c1 <= 3); CREATE TABLE rls_tbl_force (c1 int); SELECT public.create_hypertable('rls_tbl_force', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------------- (35,regress_rls_schema,rls_tbl_force,t) ALTER TABLE rls_tbl_force ENABLE ROW LEVEL SECURITY; ALTER TABLE rls_tbl_force FORCE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl_force USING (c1 = 5) WITH CHECK (c1 < 5); CREATE POLICY p2 ON rls_tbl_force FOR SELECT USING (c1 = 8); CREATE POLICY p3 ON rls_tbl_force FOR UPDATE USING (c1 = 8) WITH CHECK (c1 >= 5); CREATE POLICY p4 ON rls_tbl_force FOR DELETE USING (c1 = 8); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/rowsecurity-17.out�������������������������������������������������0000664�0000000�0000000�00000555734�15100345067�0022233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Test of Row-level security feature -- -- Clean up in case a prior regression run failed \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET timescaledb.enable_constraint_exclusion TO off; -- Suppress NOTICE messages when users/groups don't exist SET client_min_messages TO 'warning'; DROP USER IF EXISTS regress_rls_alice; DROP USER IF EXISTS regress_rls_bob; DROP USER IF EXISTS regress_rls_carol; DROP USER IF EXISTS regress_rls_dave; DROP USER IF EXISTS regress_rls_exempt_user; DROP ROLE IF EXISTS regress_rls_group1; DROP ROLE IF EXISTS regress_rls_group2; DROP SCHEMA IF EXISTS regress_rls_schema CASCADE; RESET client_min_messages; -- initial setup CREATE USER regress_rls_alice NOLOGIN; CREATE USER regress_rls_bob NOLOGIN; CREATE USER regress_rls_carol NOLOGIN; CREATE USER regress_rls_dave NOLOGIN; CREATE USER regress_rls_exempt_user BYPASSRLS NOLOGIN; CREATE ROLE regress_rls_group1 NOLOGIN; CREATE ROLE regress_rls_group2 NOLOGIN; GRANT regress_rls_group1 TO regress_rls_bob; GRANT regress_rls_group2 TO regress_rls_carol; CREATE SCHEMA regress_rls_schema; GRANT ALL ON SCHEMA regress_rls_schema to public; SET search_path = regress_rls_schema; -- setup of malicious function CREATE OR REPLACE FUNCTION f_leak(text) RETURNS bool COST 0.0000001 LANGUAGE plpgsql AS 'BEGIN RAISE NOTICE ''f_leak => %'', $1; RETURN true; END'; GRANT EXECUTE ON FUNCTION f_leak(text) TO public; -- BASIC Row-Level Security Scenario SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE uaccount ( pguser name primary key, seclv int ); GRANT SELECT ON uaccount TO public; INSERT INTO uaccount VALUES ('regress_rls_alice', 99), ('regress_rls_bob', 1), ('regress_rls_carol', 2), ('regress_rls_dave', 3); CREATE TABLE category ( cid int primary key, cname text ); GRANT ALL ON category TO public; INSERT INTO category VALUES (11, 'novel'), (22, 'science fiction'), (33, 'technology'), (44, 'manga'); CREATE TABLE document ( did int primary key, cid int references category(cid), dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON document TO public; SELECT public.create_hypertable('document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------- (1,regress_rls_schema,document,t) INSERT INTO document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 22, 2, 'regress_rls_bob', 'my science fiction'), ( 4, 44, 1, 'regress_rls_bob', 'my first manga'), ( 5, 44, 2, 'regress_rls_bob', 'my second manga'), ( 6, 22, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 33, 2, 'regress_rls_carol', 'great technology book'), ( 8, 44, 1, 'regress_rls_carol', 'great manga'), ( 9, 22, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 33, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE document ENABLE ROW LEVEL SECURITY; -- user's security level must be higher than or equal to document's CREATE POLICY p1 ON document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- try to create a policy of bogus type CREATE POLICY p1 ON document AS UGLY USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); ERROR: unrecognized row security option "ugly" LINE 1: CREATE POLICY p1 ON document AS UGLY ^ HINT: Only PERMISSIVE or RESTRICTIVE policies are supported currently. -- but Dave isn't allowed to anything at cid 50 or above -- this is to make sure that we sort the policies by name first -- when applying WITH CHECK, a later INSERT by Dave should fail due -- to p1r first CREATE POLICY p2r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44 AND cid < 50); -- and Dave isn't allowed to see manga documents CREATE POLICY p1r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44); \dp Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------------------+----------+-------+----------------------------------------------+-------------------+-------------------------------------------- regress_rls_schema | category | table | regress_rls_alice=arwdDxtm/regress_rls_alice+| | | | | =arwdDxtm/regress_rls_alice | | regress_rls_schema | document | table | regress_rls_alice=arwdDxtm/regress_rls_alice+| | p1: + | | | =arwdDxtm/regress_rls_alice | | (u): (dlevel <= ( SELECT uaccount.seclv + | | | | | FROM uaccount + | | | | | WHERE (uaccount.pguser = CURRENT_USER)))+ | | | | | p2r (RESTRICTIVE): + | | | | | (u): ((cid <> 44) AND (cid < 50)) + | | | | | to: regress_rls_dave + | | | | | p1r (RESTRICTIVE): + | | | | | (u): (cid <> 44) + | | | | | to: regress_rls_dave regress_rls_schema | uaccount | table | regress_rls_alice=arwdDxtm/regress_rls_alice+| | | | | =r/regress_rls_alice | | \d document Table "regress_rls_schema.document" Column | Type | Collation | Nullable | Default ---------+---------+-----------+----------+--------- did | integer | | not null | cid | integer | | | dlevel | integer | | not null | dauthor | name | | | dtitle | text | | | Indexes: "document_pkey" PRIMARY KEY, btree (did) Foreign-key constraints: "document_cid_fkey" FOREIGN KEY (cid) REFERENCES category(cid) Policies: POLICY "p1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "p1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid <> 44)) POLICY "p2r" AS RESTRICTIVE TO regress_rls_dave USING (((cid <> 44) AND (cid < 50))) Number of child tables: 6 (Use \d+ to list them.) SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename = 'document' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+-----------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | document | p1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | document | p1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid <> 44) | regress_rls_schema | document | p2r | RESTRICTIVE | {regress_rls_dave} | ALL | ((cid <> 44) AND (cid < 50)) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 44 | 1 | regress_rls_bob | my first manga 6 | 22 | 1 | regress_rls_carol | great science fiction 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 44 | 4 | 1 | regress_rls_bob | my first manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (document.cid = category.cid) InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Hash -> Seq Scan on category -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (category.cid = document.cid) InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on category -> Hash -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- 44 would technically fail for both p2r and p1r, but we should get an error -- back from p1r for this because it sorts first INSERT INTO document VALUES (100, 44, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p1r" for table "document" -- Just to see a p2r error INSERT INTO document VALUES (100, 55, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p2r" for table "document" -- only owner can change policies ALTER POLICY p1 ON document USING (true); --fail ERROR: must be owner of table document DROP POLICY p1 ON document; --fail ERROR: must be owner of relation document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+-------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-----------------+--------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-----------------------+----------------- 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Index Scan using category_pkey on category Index Cond: (cid = document.cid) -- interaction of FK/PK constraints SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY p2 ON category USING (CASE WHEN current_user = 'regress_rls_bob' THEN cid IN (11, 33) WHEN current_user = 'regress_rls_carol' THEN cid IN (22, 44) ELSE false END); ALTER TABLE category ENABLE ROW LEVEL SECURITY; -- cannot delete PK referenced by invisible FK SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-----------------+--------------------+-----+------------ 1 | 11 | 1 | regress_rls_bob | my first novel | 11 | novel 2 | 11 | 2 | regress_rls_bob | my second novel | 11 | novel 3 | 22 | 2 | regress_rls_bob | my science fiction | | 4 | 44 | 1 | regress_rls_bob | my first manga | | 5 | 44 | 2 | regress_rls_bob | my second manga | | | | | | | 33 | technology \set VERBOSITY sqlstate DELETE FROM category WHERE cid = 33; -- fails with FK violation ERROR: 23503 \set VERBOSITY default -- can insert FK referencing invisible PK SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-------------------+-----------------------+-----+----------------- 6 | 22 | 1 | regress_rls_carol | great science fiction | 22 | science fiction 7 | 33 | 2 | regress_rls_carol | great technology book | | 8 | 44 | 1 | regress_rls_carol | great manga | 44 | manga INSERT INTO document VALUES (11, 33, 1, current_user, 'hoge'); -- UNIQUE or PRIMARY KEY constraint violation DOES reveal presence of row SET SESSION AUTHORIZATION regress_rls_bob; INSERT INTO document VALUES (8, 44, 1, 'regress_rls_bob', 'my third manga'); -- Must fail with unique violation, revealing presence of did we can't see ERROR: duplicate key value violates unique constraint "5_10_document_pkey" DETAIL: Key (did)=(8) already exists. SELECT * FROM document WHERE did = 8; -- and confirm we can't see it did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- RLS policies are checked before constraints INSERT INTO document VALUES (8, 44, 1, 'regress_rls_carol', 'my third manga'); -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" UPDATE document SET did = 8, dauthor = 'regress_rls_carol' WHERE did = 5; -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database superuser does bypass RLS policy when disabled RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS disabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- -- Table inheritance and RLS policy -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE t1 (a int, junk1 text, b text); ALTER TABLE t1 DROP COLUMN junk1; -- just a disturbing factor GRANT ALL ON t1 TO public; COPY t1 FROM stdin; CREATE TABLE t2 (c float) INHERITS (t1); GRANT ALL ON t2 TO public; COPY t2 FROM stdin; CREATE TABLE t3 (c text, b text, a int); ALTER TABLE t3 INHERIT t1; GRANT ALL ON t3 TO public; COPY t3(a,b,c) FROM stdin; CREATE POLICY p1 ON t1 FOR ALL TO PUBLIC USING (a % 2 = 0); -- be even number CREATE POLICY p2 ON t2 FOR ALL TO PUBLIC USING (a % 2 = 1); -- be odd number ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; ALTER TABLE t2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- reference to system column SELECT ctid, * FROM t1; ctid | a | b -------+---+----- (0,2) | 2 | bbb (0,4) | 4 | dad (0,2) | 2 | bcd (0,4) | 4 | def (0,2) | 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- reference to whole-row reference SELECT *, t1 FROM t1; a | b | t1 ---+-----+--------- 2 | bbb | (2,bbb) 4 | dad | (4,dad) 2 | bcd | (2,bcd) 4 | def | (4,def) 2 | yyy | (2,yyy) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- for share/update lock SELECT * FROM t1 FOR SHARE; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- union all query SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; a | b | ctid ---+-----+------- 1 | abc | (0,1) 3 | cde | (0,3) 1 | xxx | (0,1) 2 | yyy | (0,2) 3 | zzz | (0,3) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; --- QUERY PLAN --- Append -> Seq Scan on t2 Filter: ((a % 2) = 1) -> Seq Scan on t3 -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- -- Hyper Tables -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE hyper_document ( did int, cid int, dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON hyper_document TO public; SELECT public.create_hypertable('hyper_document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------------- (2,regress_rls_schema,hyper_document,t) INSERT INTO hyper_document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 99, 2, 'regress_rls_bob', 'my science textbook'), ( 4, 55, 1, 'regress_rls_bob', 'my first satire'), ( 5, 99, 2, 'regress_rls_bob', 'my history book'), ( 6, 11, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 99, 2, 'regress_rls_carol', 'great technology book'), ( 8, 55, 2, 'regress_rls_carol', 'great satire'), ( 9, 11, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 99, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE hyper_document ENABLE ROW LEVEL SECURITY; GRANT ALL ON _timescaledb_internal._hyper_2_9_chunk TO public; -- Create policy on parent -- user's security level must be higher than or equal to document's CREATE POLICY pp1 ON hyper_document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- Dave is only allowed to see cid < 55 CREATE POLICY pp1r ON hyper_document AS RESTRICTIVE TO regress_rls_dave USING (cid < 55); \d+ hyper_document Table "regress_rls_schema.hyper_document" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ---------+---------+-----------+----------+---------+----------+--------------+------------- did | integer | | not null | | plain | | cid | integer | | | | plain | | dlevel | integer | | not null | | plain | | dauthor | name | | | | plain | | dtitle | text | | | | extended | | Indexes: "hyper_document_did_idx" btree (did DESC) Policies: POLICY "pp1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "pp1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid < 55)) Child tables: _timescaledb_internal._hyper_2_10_chunk, _timescaledb_internal._hyper_2_11_chunk, _timescaledb_internal._hyper_2_12_chunk, _timescaledb_internal._hyper_2_13_chunk, _timescaledb_internal._hyper_2_14_chunk, _timescaledb_internal._hyper_2_9_chunk SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename like '%hyper_document%' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+----------------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | hyper_document | pp1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | hyper_document | pp1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid < 55) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first satire NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 55 | 1 | regress_rls_bob | my first satire 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- pp1 ERROR INSERT INTO hyper_document VALUES (1, 11, 5, 'regress_rls_dave', 'testing pp1'); -- fail ERROR: new row violates row-level security policy for table "hyper_document" -- pp1r ERROR INSERT INTO hyper_document VALUES (1, 99, 1, 'regress_rls_dave', 'testing pp1r'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- Show that RLS policy does not apply for direct inserts to children -- This should fail with RLS POLICY pp1r violation. INSERT INTO hyper_document VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- But this should succeed. INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- success -- We still cannot see the row using the parent SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction -- But we can if we look directly SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- Turn on RLS and create policy on child to show RLS is checked before constraints SET SESSION AUTHORIZATION regress_rls_alice; ALTER TABLE _timescaledb_internal._hyper_2_9_chunk ENABLE ROW LEVEL SECURITY; CREATE POLICY pp3 ON _timescaledb_internal._hyper_2_9_chunk AS RESTRICTIVE USING (cid < 55); -- This should fail with RLS violation now. SET SESSION AUTHORIZATION regress_rls_dave; INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables - round 2'); -- fail ERROR: new row violates row-level security policy for table "_hyper_2_9_chunk" -- And now we cannot see directly into the partition either, due to RLS SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- The parent looks same as before -- viewpoint from regress_rls_dave SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- only owner can change policies ALTER POLICY pp1 ON hyper_document USING (true); --fail ERROR: must be owner of table hyper_document DROP POLICY pp1 ON hyper_document; --fail ERROR: must be owner of relation hyper_document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY pp1 ON hyper_document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+--------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 -> Seq Scan on hyper_document hyper_document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- When RLS disabled, other users get ERROR. SET SESSION AUTHORIZATION regress_rls_dave; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "hyper_document" SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "_hyper_2_9_chunk" -- Check behavior with a policy that uses a SubPlan not an InitPlan. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE POLICY pp3 ON hyper_document AS RESTRICTIVE USING ((SELECT dlevel <= seclv FROM uaccount WHERE pguser = current_user)); SET SESSION AUTHORIZATION regress_rls_carol; INSERT INTO hyper_document VALUES (100, 11, 5, 'regress_rls_carol', 'testing pp3'); -- fail ERROR: new row violates row-level security policy "pp3" for table "hyper_document" ----- Dependencies ----- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE dependee (x integer, y integer); SELECT public.create_hypertable('dependee', 'x', chunk_time_interval=>2); create_hypertable ----------------------------------- (3,regress_rls_schema,dependee,t) CREATE TABLE dependent (x integer, y integer); SELECT public.create_hypertable('dependent', 'x', chunk_time_interval=>2); create_hypertable ------------------------------------ (4,regress_rls_schema,dependent,t) CREATE POLICY d1 ON dependent FOR ALL TO PUBLIC USING (x = (SELECT d.x FROM dependee d WHERE d.y = y)); DROP TABLE dependee; -- Should fail without CASCADE due to dependency on row security qual? ERROR: cannot drop table dependee because other objects depend on it DETAIL: policy d1 on table dependent depends on table dependee HINT: Use DROP ... CASCADE to drop the dependent objects too. DROP TABLE dependee CASCADE; NOTICE: drop cascades to policy d1 on table dependent EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM dependent; -- After drop, should be unqualified --- QUERY PLAN --- Seq Scan on dependent ----- RECURSION ---- -- -- Simple recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec1 (x integer, y integer); SELECT public.create_hypertable('rec1', 'x', chunk_time_interval=>2); create_hypertable ------------------------------- (5,regress_rls_schema,rec1,t) CREATE POLICY r1 ON rec1 USING (x = (SELECT r.x FROM rec1 r WHERE y = r.y)); ALTER TABLE rec1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, direct recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec2 (a integer, b integer); SELECT public.create_hypertable('rec2', 'x', chunk_time_interval=>2); ERROR: column "x" does not exist ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2 WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1 WHERE y = b)); ALTER TABLE rec2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via views -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rec1v AS SELECT * FROM rec1; CREATE VIEW rec2v AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); ALTER POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via views ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via .s.b views -- SET SESSION AUTHORIZATION regress_rls_bob; \set VERBOSITY terse \\ -- suppress cascade details DROP VIEW rec1v, rec2v CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE VIEW rec1v WITH (security_barrier) AS SELECT * FROM rec1; CREATE VIEW rec2v WITH (security_barrier) AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via s.b. views ERROR: infinite recursion detected in policy for relation "rec1" -- -- recursive RLS and VIEWs in policy -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE s1 (a int, b text); SELECT public.create_hypertable('s1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (6,regress_rls_schema,s1,t) INSERT INTO s1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE TABLE s2 (x int, y text); SELECT public.create_hypertable('s2', 'x', chunk_time_interval=>2); create_hypertable ----------------------------- (7,regress_rls_schema,s2,t) INSERT INTO s2 (SELECT x, md5(x::text) FROM generate_series(-6,6) x); GRANT SELECT ON s1, s2 TO regress_rls_bob; CREATE POLICY p1 ON s1 USING (a in (select x from s2 where y like '%2f%')); CREATE POLICY p2 ON s2 USING (x in (select a from s1 where b like '%22%')); CREATE POLICY p3 ON s1 FOR INSERT WITH CHECK (a = (SELECT a FROM s1)); ALTER TABLE s1 ENABLE ROW LEVEL SECURITY; ALTER TABLE s2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW v2 AS SELECT * FROM s2 WHERE y like '%af%'; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" INSERT INTO s1 VALUES (1, 'foo'); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3 on s1; ALTER POLICY p2 ON s2 USING (x % 2 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c a | b ---+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b); --- QUERY PLAN --- Seq Scan on s1 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON s1 USING (a in (select x from v2)); -- using VIEW in RLS policy SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => 0267aaf632e87a63288a08331f22c7c3 NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc a | b ----+---------------------------------- -4 | 0267aaf632e87a63288a08331f22c7c3 6 | 1679091c5a880faf6fb5e6087eb1b2dc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM s1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on s1 Chunks excluded during startup: 0 -> Seq Scan on s1 s1_1 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; xx | x | y ----+----+---------------------------------- -6 | -6 | 596a3d04481816330f07e4f97510c28f -4 | -4 | 0267aaf632e87a63288a08331f22c7c3 2 | 2 | c81e728d9d4c2f636f067f89cc14862c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; --- QUERY PLAN --- Result -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) SubPlan 2 -> Limit -> Result -> Custom Scan (ChunkAppend) on s1 -> Seq Scan on s1 s1_1 Filter: (ANY (a = (hashed SubPlan 1).col1)) SubPlan 1 -> Append -> Seq Scan on s2 s2_10 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_11 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_12 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_13 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_14 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_15 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_16 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_17 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: (ANY (a = (hashed SubPlan 1).col1)) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p2 ON s2 USING (x in (select a from s1 where b like '%d2%')); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion via view) ERROR: infinite recursion detected in policy for relation "s1" -- prepared statement with regress_rls_alice privilege PREPARE p1(int) AS SELECT * FROM t1 WHERE a <= $1; EXECUTE p1(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a <= 2) AND ((a % 2) = 0)) -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- plan cache should be invalidated EXECUTE p1(2); a | b ---+----- 1 | aba 2 | bbb 1 | abc 2 | bcd 1 | xxx 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a <= 2) -> Seq Scan on t2 t1_2 Filter: (a <= 2) -> Seq Scan on t3 t1_3 Filter: (a <= 2) PREPARE p2(int) AS SELECT * FROM t1 WHERE a = $1; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a = 2) -> Seq Scan on t2 t1_2 Filter: (a = 2) -> Seq Scan on t3 t1_3 Filter: (a = 2) -- also, case when privilege switch from superuser SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a = 2) AND ((a % 2) = 0)) -- -- UPDATE / DELETE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_bob; EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Result -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b = b || b WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); --- QUERY PLAN --- Update on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); NOTICE: f_leak => bbbbbb NOTICE: f_leak => daddad -- returning clause with system column UPDATE only t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,9) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,10) | 4 | daddad_updt | (4,daddad_updt) UPDATE t1 SET b = b WHERE f_leak(b) RETURNING *; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy a | b ---+------------- 2 | bbbbbb_updt 4 | daddad_updt 2 | bcdbcd 4 | defdef 2 | yyyyyy UPDATE t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,14) | 4 | daddad_updt | (4,daddad_updt) (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,10) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- updates with from clause EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t3 Filter: ((a = 2) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); NOTICE: f_leak => cde NOTICE: f_leak => yyyyyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde -- updates with from clause self join EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; --- QUERY PLAN --- Update on t2 t2_1 -> Nested Loop Join Filter: (t2_1.b = t2_2.b) -> Seq Scan on t2 t2_1 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t2 t2_2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; NOTICE: f_leak => cde NOTICE: f_leak => cde a | b | c | a | b | c | t2_1 | t2_2 ---+-----+-----+---+-----+-----+-------------+------------- 3 | cde | 3.3 | 3 | cde | 3.3 | (3,cde,3.3) | (3,cde,3.3) EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; --- QUERY PLAN --- Update on t1 t1_1 Update on t1 t1_1_1 Update on t2 t1_1_2 Update on t3 t1_1_3 -> Nested Loop Join Filter: (t1_1.b = t1_2.b) -> Append -> Seq Scan on t1 t1_1_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_1_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_1_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Materialize -> Append -> Seq Scan on t1 t1_2_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_2_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; NOTICE: f_leak => daddad_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => defdef NOTICE: f_leak => defdef a | b | a | b | t1_1 | t1_2 ---+-------------+---+-------------+-----------------+----------------- 4 | daddad_updt | 4 | daddad_updt | (4,daddad_updt) | (4,daddad_updt) 4 | defdef | 4 | defdef | (4,defdef) | (4,defdef) RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 ORDER BY a,b; a | b ---+------------- 1 | aba 1 | abc 1 | xxx 2 | bbbbbb_updt 2 | bcdbcd 2 | yyyyyy 3 | ccc 3 | cde 3 | zzz 4 | daddad_updt 4 | defdef SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM only t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 Delete on t1 t1_1 Delete on t2 t1_2 Delete on t3 t1_3 -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM only t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,15) | 4 | daddad_updt | (4,daddad_updt) DELETE FROM t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+--------+------------ (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,13) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- -- S.b. view on top of Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE b1 (a int, b text); SELECT public.create_hypertable('b1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (8,regress_rls_schema,b1,t) INSERT INTO b1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE POLICY p1 ON b1 USING (a % 2 = 0); ALTER TABLE b1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON b1 TO regress_rls_bob; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW bv1 WITH (security_barrier) AS SELECT * FROM b1 WHERE a > 0 WITH CHECK OPTION; GRANT ALL ON bv1 TO regress_rls_carol; SET SESSION AUTHORIZATION regress_rls_carol; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM bv1 WHERE f_leak(b); --- QUERY PLAN --- Subquery Scan on bv1 Filter: f_leak(bv1.b) -> Append -> Seq Scan on b1 b1_1 Filter: ((a > 0) AND ((a % 2) = 0)) -> Index Scan using _hyper_8_39_chunk_b1_a_idx on _hyper_8_39_chunk b1_2 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_40_chunk_b1_a_idx on _hyper_8_40_chunk b1_3 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_4 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_5 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_43_chunk_b1_a_idx on _hyper_8_43_chunk b1_6 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_44_chunk_b1_a_idx on _hyper_8_44_chunk b1_7 Index Cond: (a > 0) Filter: ((a % 2) = 0) SELECT * FROM bv1 WHERE f_leak(b); NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 a | b ----+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 INSERT INTO bv1 VALUES (-1, 'xxx'); -- should fail view WCO ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (11, 'xxx'); -- should fail RLS check ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (12, 'xxx'); -- ok EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on b1 Update on _hyper_8_41_chunk b1_1 -> Result -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_1 Index Cond: ((a > 0) AND (a = 4)) Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on b1 Delete on _hyper_8_42_chunk b1_1 -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_1 Index Cond: ((a > 0) AND (a = 6)) Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM b1; a | b -----+---------------------------------- -10 | 1b0fd9efa5279c4203b7c70233f86dbf -9 | 252e691406782824eec43d7eadc3d256 -8 | a8d2ec85eaf98407310b72eb73dda247 -7 | 74687a12d3915d3c4d83f1af7b3683d5 -6 | 596a3d04481816330f07e4f97510c28f -5 | 47c1b025fa18ea96c33fbb6718688c0f -4 | 0267aaf632e87a63288a08331f22c7c3 -3 | b3149ecea4628efd23d2f86e5a723472 -2 | 5d7b9adcbe1c629ec722529dd12e5129 -1 | 6bb61e3b7bce0931da574d19d1d82c88 0 | cfcd208495d565ef66e7dff9f98764da 1 | c4ca4238a0b923820dcc509a6f75849b 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | yyy 7 | 8f14e45fceea167a5a36dedd4bea2543 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | xxx -- -- INSERT ... ON CONFLICT DO UPDATE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p1r ON document; CREATE POLICY p1 ON document FOR SELECT USING (true); CREATE POLICY p2 ON document FOR INSERT WITH CHECK (dauthor = current_user); CREATE POLICY p3 ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Exists... SELECT * FROM document WHERE did = 2; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------- 2 | 11 | 2 | regress_rls_bob | my second novel -- ...so violates actual WITH CHECK OPTION within UPDATE (not INSERT, since -- alternative UPDATE path happens to be taken): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, dauthor = EXCLUDED.dauthor; ERROR: new row violates row-level security policy for table "document" -- Violates USING qual for UPDATE policy p3. -- -- UPDATE path is taken, but UPDATE fails purely because *existing* row to be -- updated is not a "novel"/cid 11 (row is not leaked, even though we have -- SELECT privileges sufficient to see the row in this instance): INSERT INTO document VALUES (33, 22, 1, 'regress_rls_bob', 'okay science fiction'); -- preparation for next statement INSERT INTO document VALUES (33, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'Some novel, replaces sci-fi') -- takes UPDATE path ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fine (we UPDATE, since INSERT WCOs and UPDATE security barrier quals + WCOs -- not violated): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------- 2 | 11 | 2 | regress_rls_bob | my first novel -- Fine (we INSERT, so "cid = 33" ("technology") isn't evaluated): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 11 | 1 | regress_rls_bob | some technology novel -- Fine (same query, but we UPDATE, so "cid = 33", ("technology") is not the -- case in respect of *existing* tuple): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 33 | 1 | regress_rls_bob | some technology novel -- Same query a third time, but now fails due to existing tuple finally not -- passing quals: INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Don't fail just because INSERT doesn't satisfy WITH CHECK option that -- originated as a barrier/USING() qual from the UPDATE. Note that the UPDATE -- path *isn't* taken, and so UPDATE-related policy does not apply: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------------------------- 79 | 33 | 1 | regress_rls_bob | technology book, can only insert -- But this time, the same statement fails, because the UPDATE path is taken, -- and updating the row just inserted falls afoul of security barrier qual -- (enforced as WCO) -- what we might have updated target tuple to is -- irrelevant, in fact. INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Test default USING qual enforced as WCO SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p2 ON document; DROP POLICY p3 ON document; CREATE POLICY p3_with_default ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')); SET SESSION AUTHORIZATION regress_rls_bob; -- Just because WCO-style enforcement of USING quals occurs with -- existing/target tuple does not mean that the implementation can be allowed -- to fail to also enforce this qual against the final tuple appended to -- relation (since in the absence of an explicit WCO, this is also interpreted -- as an UPDATE/ALL WCO in general). -- -- UPDATE path is taken here (fails due to existing tuple). Note that this is -- not reported as a "USING expression", because it's an RLS UPDATE check that originated as -- a USING qual for the purposes of RLS in general, as opposed to an explicit -- USING qual that is ordinarily a security barrier. We leave it up to the -- UPDATE to make this fail: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" -- UPDATE path is taken here. Existing tuple passes, since it's cid -- corresponds to "novel", but default USING qual is enforced against -- post-UPDATE tuple too (as always when updating with a policy that lacks an -- explicit WCO), and so this fails: INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET cid = EXCLUDED.cid, dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3_with_default ON document; -- -- Test ALL policies with ON CONFLICT DO UPDATE (much the same as existing UPDATE -- tests) -- CREATE POLICY p3_with_all ON document FOR ALL USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Fails, since ALL WCO is enforced in insert path: INSERT INTO document VALUES (80, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33; ERROR: new row violates row-level security policy for table "document" -- Fails, since ALL policy USING qual is enforced (existing, target tuple is in -- violation, since it has the "manga" cid): INSERT INTO document VALUES (4, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fails, since ALL WCO are enforced: INSERT INTO document VALUES (1, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dauthor = 'regress_rls_carol'; ERROR: new row violates row-level security policy for table "document" -- -- ROLE/GROUP -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE z1 (a int, b text); SELECT public.create_hypertable('z1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (9,regress_rls_schema,z1,t) CREATE TABLE z2 (a int, b text); SELECT public.create_hypertable('z2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (10,regress_rls_schema,z2,t) GRANT SELECT ON z1,z2 TO regress_rls_group1, regress_rls_group2, regress_rls_bob, regress_rls_carol; INSERT INTO z1 VALUES (1, 'aba'), (2, 'bbb'), (3, 'ccc'), (4, 'dad'); CREATE POLICY p1 ON z1 TO regress_rls_group1 USING (a % 2 = 0); CREATE POLICY p2 ON z1 TO regress_rls_group2 USING (a % 2 = 1); ALTER TABLE z1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test AS SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test2 AS WITH q AS MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test4 AS WITH q AS (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test6 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test6; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test3 AS WITH q AS MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test5 AS WITH q AS (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test7 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test7; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET ROLE regress_rls_group1; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) SET ROLE regress_rls_group2; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -- -- Views should follow policy for view owner. -- -- View and Table owner are the same. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_bob; -- Query as role that is not owner of view or table. Should return all records. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) -- Query as view/table owner. Should return all records. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) DROP VIEW rls_view; -- View and Table owners are different. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_alice; -- Query as role that is not owner of view but is owner of table. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not owner of table but is owner of view. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not the owner of the table or view without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view -- Query as role that is not the owner of the table or view with permissions. SET SESSION AUTHORIZATION regress_rls_bob; GRANT SELECT ON rls_view TO regress_rls_carol; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_bob; DROP VIEW rls_view; -- -- Command specific -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE x1 (a int, b text, c text); SELECT public.create_hypertable('x1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (11,regress_rls_schema,x1,t) GRANT ALL ON x1 TO PUBLIC; INSERT INTO x1 VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_carol'), (4, 'def', 'regress_rls_carol'), (5, 'efg', 'regress_rls_bob'), (6, 'fgh', 'regress_rls_bob'), (7, 'fgh', 'regress_rls_carol'), (8, 'fgh', 'regress_rls_carol'); CREATE POLICY p0 ON x1 FOR ALL USING (c = current_user); CREATE POLICY p1 ON x1 FOR SELECT USING (a % 2 = 0); CREATE POLICY p2 ON x1 FOR INSERT WITH CHECK (a % 2 = 1); CREATE POLICY p3 ON x1 FOR UPDATE USING (a % 2 = 0); CREATE POLICY p4 ON x1 FOR DELETE USING (a < 8); ALTER TABLE x1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+-----+------------------- 1 | abc | regress_rls_bob 2 | bcd | regress_rls_bob 4 | def | regress_rls_carol 5 | efg | regress_rls_bob 6 | fgh | regress_rls_bob 8 | fgh | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+----------+------------------- 1 | abc_updt | regress_rls_bob 2 | bcd_updt | regress_rls_bob 4 | def_updt | regress_rls_carol 5 | efg_updt | regress_rls_bob 6 | fgh_updt | regress_rls_bob 8 | fgh_updt | regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+----------+------------------- 2 | bcd_updt | regress_rls_bob 3 | cde | regress_rls_carol 4 | def_updt | regress_rls_carol 6 | fgh_updt | regress_rls_bob 7 | fgh | regress_rls_carol 8 | fgh_updt | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol DELETE FROM x1 WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde_updt NOTICE: f_leak => bcd_updt_updt NOTICE: f_leak => def_updt_updt NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt_updt NOTICE: f_leak => fgh_updt_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol -- -- Duplicate Policy Names -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE y1 (a int, b text); SELECT public.create_hypertable('y1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (12,regress_rls_schema,y1,t) INSERT INTO y1 VALUES(1,2); CREATE TABLE y2 (a int, b text); SELECT public.create_hypertable('y2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (13,regress_rls_schema,y2,t) GRANT ALL ON y1, y2 TO regress_rls_bob; CREATE POLICY p1 ON y1 FOR ALL USING (a % 2 = 0); CREATE POLICY p2 ON y1 FOR SELECT USING (a > 2); CREATE POLICY p1 ON y1 FOR SELECT USING (a % 2 = 1); --fail ERROR: policy "p1" for table "y1" already exists CREATE POLICY p1 ON y2 FOR ALL USING (a % 2 = 0); --OK ALTER TABLE y1 ENABLE ROW LEVEL SECURITY; ALTER TABLE y2 ENABLE ROW LEVEL SECURITY; -- -- Expression structure with SBV -- -- Create view as table owner. RLS should NOT be applied. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: (f_leak(b) AND (a = 1)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: f_leak(b) DROP VIEW rls_sbv; -- Create view as role that does not own table. RLS should be applied. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: ((a = 1) AND ((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: (((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) DROP VIEW rls_sbv; -- -- Expression structure -- SET SESSION AUTHORIZATION regress_rls_alice; INSERT INTO y2 (SELECT x, md5(x::text) FROM generate_series(0,20) x); CREATE POLICY p2 ON y2 USING (a % 3 = 0); CREATE POLICY p3 ON y2 USING (a % 4 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM y2 WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -- -- Qual push-down of leaky functions, when not referring to table -- SELECT * FROM y2 WHERE f_leak('abc'); NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak('abc'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) CREATE TABLE test_qual_pushdown ( abc text ); INSERT INTO test_qual_pushdown VALUES ('abc'),('def'); SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); NOTICE: f_leak => abc NOTICE: f_leak => def a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); --- QUERY PLAN --- Hash Join Hash Cond: (y2.b = test_qual_pushdown.abc) -> Append -> Seq Scan on y2 y2_1 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Hash -> Seq Scan on test_qual_pushdown Filter: f_leak(abc) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); --- QUERY PLAN --- Hash Join Hash Cond: (test_qual_pushdown.abc = y2.b) -> Seq Scan on test_qual_pushdown -> Hash -> Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) DROP TABLE test_qual_pushdown; -- -- Plancache invalidate on user change. -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP TABLE t1 CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE TABLE t1 (a integer); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (14,regress_rls_schema,t1,t) GRANT SELECT ON t1 TO regress_rls_bob, regress_rls_carol; CREATE POLICY p1 ON t1 TO regress_rls_bob USING ((a % 2) = 0); CREATE POLICY p2 ON t1 TO regress_rls_carol USING ((a % 4) = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; -- Prepare as regress_rls_bob SET ROLE regress_rls_bob; PREPARE role_inval AS SELECT * FROM t1; -- Check plan EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- Change to regress_rls_carol SET ROLE regress_rls_carol; -- Check plan- should be different EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 4) = 0) -- Change back to regress_rls_bob SET ROLE regress_rls_bob; -- Check plan- should be back to original EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- -- CTE and RLS -- RESET SESSION AUTHORIZATION; DROP TABLE t1 CASCADE; CREATE TABLE t1 (a integer, b text); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (15,regress_rls_schema,t1,t) CREATE POLICY p1 ON t1 USING (a % 2 = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON t1 TO regress_rls_bob; INSERT INTO t1 (SELECT x, md5(x::text) FROM generate_series(0,20) x); SET SESSION AUTHORIZATION regress_rls_bob; WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; --- QUERY PLAN --- CTE Scan on cte1 CTE cte1 -> Custom Scan (ChunkAppend) on t1 Chunks excluded during startup: 0 -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: (((a % 2) = 0) AND f_leak(b)) WITH cte1 AS (UPDATE t1 SET a = a + 1 RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (UPDATE t1 SET a = a RETURNING *) SELECT * FROM cte1; --ok a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 WITH cte1 AS (INSERT INTO t1 VALUES (21, 'Fail') RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (INSERT INTO t1 VALUES (20, 'Success') RETURNING *) SELECT * FROM cte1; --ok a | b ----+--------- 20 | Success -- -- Rename Policy -- RESET SESSION AUTHORIZATION; ALTER POLICY p1 ON t1 RENAME TO p1; --fail ERROR: policy "p1" for table "t1" already exists SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p1 | t1 ALTER POLICY p1 ON t1 RENAME TO p2; --ok SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p2 | t1 -- -- Check INSERT SELECT -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE TABLE t2 (a integer, b text); SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (16,regress_rls_schema,t2,t) INSERT INTO t2 (SELECT * FROM t1); EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO t2 (SELECT * FROM t1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on t2 -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: ((a % 2) = 0) SELECT * FROM t2; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t2; --- QUERY PLAN --- Append -> Seq Scan on t2 t2_1 -> Seq Scan on _hyper_16_80_chunk t2_2 -> Seq Scan on _hyper_16_81_chunk t2_3 -> Seq Scan on _hyper_16_82_chunk t2_4 -> Seq Scan on _hyper_16_83_chunk t2_5 -> Seq Scan on _hyper_16_84_chunk t2_6 -> Seq Scan on _hyper_16_85_chunk t2_7 -> Seq Scan on _hyper_16_86_chunk t2_8 -> Seq Scan on _hyper_16_87_chunk t2_9 -> Seq Scan on _hyper_16_88_chunk t2_10 -> Seq Scan on _hyper_16_89_chunk t2_11 -> Seq Scan on _hyper_16_90_chunk t2_12 CREATE TABLE t3 AS SELECT * FROM t1; SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); ERROR: table "t2" is already a hypertable SELECT * FROM t3; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success SELECT * INTO t4 FROM t1; SELECT * FROM t4; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success -- -- RLS with JOIN -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE blog (id integer, author text, post text); SELECT public.create_hypertable('blog', 'id', chunk_time_interval=>2); create_hypertable -------------------------------- (17,regress_rls_schema,blog,t) CREATE TABLE comment (blog_id integer, message text); SELECT public.create_hypertable('comment', 'blog_id', chunk_time_interval=>2); create_hypertable ----------------------------------- (18,regress_rls_schema,comment,t) GRANT ALL ON blog, comment TO regress_rls_bob; CREATE POLICY blog_1 ON blog USING (id % 2 = 0); ALTER TABLE blog ENABLE ROW LEVEL SECURITY; INSERT INTO blog VALUES (1, 'alice', 'blog #1'), (2, 'bob', 'blog #1'), (3, 'alice', 'blog #2'), (4, 'alice', 'blog #3'), (5, 'john', 'blog #1'); INSERT INTO comment VALUES (1, 'cool blog'), (1, 'fun blog'), (3, 'crazy blog'), (5, 'what?'), (4, 'insane!'), (2, 'who did it?'); SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN with Non-RLS. SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! -- Check Non-RLS JOIN with RLS. SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY comment_1 ON comment USING (blog_id < 4); ALTER TABLE comment ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN RLS SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE blog; DROP TABLE comment; -- -- Default Deny Policy -- RESET SESSION AUTHORIZATION; DROP POLICY p2 ON t1; ALTER TABLE t1 OWNER TO regress_rls_alice; -- Check that default deny does not apply to superuser. RESET SESSION AUTHORIZATION; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny does not apply to table owner. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny applies to non-owner/non-superuser when RLS on. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false -- -- COPY TO/FROM -- RESET SESSION AUTHORIZATION; DROP TABLE copy_t CASCADE; ERROR: table "copy_t" does not exist CREATE TABLE copy_t (a integer, b text); SELECT public.create_hypertable('copy_t', 'a', chunk_time_interval=>2); create_hypertable ---------------------------------- (19,regress_rls_schema,copy_t,t) CREATE POLICY p1 ON copy_t USING (a % 2 = 0); ALTER TABLE copy_t ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_t TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_t (SELECT x, md5(x::text) FROM generate_series(0,10) x); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 2,c81e728d9d4c2f636f067f89cc14862c 4,a87ff679a2f3e71d9181a67b7542122c 6,1679091c5a880faf6fb5e6087eb1b2dc 8,c9f0f895fb98ab9159f51fd0297e236d 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_t -- Check COPY relation TO; keep it just one row to avoid reordering issues RESET SESSION AUTHORIZATION; SET row_security TO ON; CREATE TABLE copy_rel_to (a integer, b text); SELECT public.create_hypertable('copy_rel_to', 'a', chunk_time_interval=>2); create_hypertable --------------------------------------- (20,regress_rls_schema,copy_rel_to,t) CREATE POLICY p1 ON copy_rel_to USING (a % 2 = 0); ALTER TABLE copy_rel_to ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_rel_to TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_rel_to VALUES (1, md5('1')); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_rel_to -- Check COPY FROM as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY copy_t FROM STDIN; --ok SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - would be affected by RLS. ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY copy_t FROM STDIN; --fail - COPY FROM not supported by RLS. ERROR: COPY FROM not supported with row-level security HINT: Use INSERT statements instead. -- Check COPY FROM as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t SET row_security TO ON; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t RESET SESSION AUTHORIZATION; DROP TABLE copy_t; DROP TABLE copy_rel_to CASCADE; -- Check WHERE CURRENT OF SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE current_check (currentid int, payload text, rlsuser text); SELECT public.create_hypertable('current_check', 'currentid', chunk_time_interval=>10); create_hypertable ----------------------------------------- (21,regress_rls_schema,current_check,t) GRANT ALL ON current_check TO PUBLIC; INSERT INTO current_check VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_bob'), (4, 'def', 'regress_rls_bob'); CREATE POLICY p1 ON current_check FOR SELECT USING (currentid % 2 = 0); CREATE POLICY p2 ON current_check FOR DELETE USING (currentid = 4 AND rlsuser = current_user); CREATE POLICY p3 ON current_check FOR UPDATE USING (currentid = 4) WITH CHECK (rlsuser = current_user); ALTER TABLE current_check ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Can SELECT even rows SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def | regress_rls_bob -- Cannot UPDATE row 2 UPDATE current_check SET payload = payload || '_new' WHERE currentid = 2 RETURNING *; currentid | payload | rlsuser -----------+---------+--------- BEGIN; -- WHERE CURRENT OF does not work with custom scan nodes -- so we have to disable chunk append here SET timescaledb.enable_chunk_append TO false; DECLARE current_check_cursor SCROLL CURSOR FOR SELECT * FROM current_check; -- Returns rows that can be seen according to SELECT policy, like plain SELECT -- above (even rows) FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob -- Still cannot UPDATE row 2 through cursor UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- -- Can update row 4 through cursor, which is the next visible row FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def_new | regress_rls_bob -- Plan should be a subquery TID scan EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE current_check SET payload = payload WHERE CURRENT OF current_check_cursor; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on current_check Update on _hyper_21_104_chunk current_check_1 -> Tid Scan on _hyper_21_104_chunk current_check_1 TID Cond: CURRENT OF current_check_cursor Filter: ((currentid = 4) AND ((currentid % 2) = 0)) -- Similarly can only delete row 4 FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob RESET timescaledb.enable_chunk_append; COMMIT; -- -- check pg_stats view filtering -- SET row_security TO ON; SET SESSION AUTHORIZATION regress_rls_alice; ANALYZE current_check; -- Stats visible SELECT row_security_active('current_check'); row_security_active --------------------- f SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals -----------+------------------- currentid | payload | rlsuser | {regress_rls_bob} SET SESSION AUTHORIZATION regress_rls_bob; -- Stats not visible SELECT row_security_active('current_check'); row_security_active --------------------- t SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals ---------+------------------ -- -- Collation support -- BEGIN; CREATE TABLE coll_t (c) AS VALUES ('bar'::text); CREATE POLICY coll_p ON coll_t USING (c < ('foo'::text COLLATE "C")); ALTER TABLE coll_t ENABLE ROW LEVEL SECURITY; GRANT SELECT ON coll_t TO regress_rls_alice; SELECT (string_to_array(polqual, ':'))[7] AS inputcollid FROM pg_policy WHERE polrelid = 'coll_t'::regclass; inputcollid ------------------ inputcollid 950 SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM coll_t; c ----- bar ROLLBACK; -- -- Shared Object Dependencies -- RESET SESSION AUTHORIZATION; BEGIN; CREATE ROLE regress_rls_eve; CREATE ROLE regress_rls_frank; CREATE TABLE tbl1 (c) AS VALUES ('bar'::text); GRANT SELECT ON TABLE tbl1 TO regress_rls_eve; CREATE POLICY P ON tbl1 TO regress_rls_eve, regress_rls_frank USING (true); SELECT refclassid::regclass, deptype FROM pg_depend WHERE classid = 'pg_policy'::regclass AND refobjid = 'tbl1'::regclass; refclassid | deptype ------------+--------- pg_class | a SELECT refclassid::regclass, deptype FROM pg_shdepend WHERE classid = 'pg_policy'::regclass AND refobjid IN ('regress_rls_eve'::regrole, 'regress_rls_frank'::regrole); refclassid | deptype ------------+--------- pg_authid | r pg_authid | r SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on POLICY p ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 target of policy p on table tbl1 ROLLBACK TO q; ALTER POLICY p ON tbl1 TO regress_rls_frank USING (true); SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on GRANT SELECT ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 ROLLBACK TO q; REVOKE ALL ON TABLE tbl1 FROM regress_rls_eve; SAVEPOINT q; DROP ROLE regress_rls_eve; --succeeds ROLLBACK TO q; SAVEPOINT q; DROP ROLE regress_rls_frank; --fails due to dependency on POLICY p ERROR: role "regress_rls_frank" cannot be dropped because some objects depend on it DETAIL: target of policy p on table tbl1 ROLLBACK TO q; DROP POLICY p ON tbl1; SAVEPOINT q; DROP ROLE regress_rls_frank; -- succeeds ROLLBACK TO q; ROLLBACK; -- cleanup -- -- Converting table to view -- BEGIN; CREATE TABLE t (c int); SELECT public.create_hypertable('t', 'c', chunk_time_interval=>2); create_hypertable ----------------------------- (22,regress_rls_schema,t,t) CREATE POLICY p ON t USING (c % 2 = 1); ALTER TABLE t ENABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to row level security enabled ERROR: hypertables do not support rules ROLLBACK TO q; ALTER TABLE t DISABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to policy p on t ERROR: hypertables do not support rules ROLLBACK TO q; DROP POLICY p ON t; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- succeeds ERROR: hypertables do not support rules ROLLBACK; -- -- Policy expression handling -- BEGIN; CREATE TABLE t (c) AS VALUES ('bar'::text); CREATE POLICY p ON t USING (max(c)); -- fails: aggregate functions are not allowed in policy expressions ERROR: aggregate functions are not allowed in policy expressions ROLLBACK; -- -- Non-target relations are only subject to SELECT policies -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (23,regress_rls_schema,r1,t) CREATE TABLE r2 (a int); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (24,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); GRANT ALL ON r1, r2 TO regress_rls_bob; CREATE POLICY p1 ON r1 USING (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON r2 FOR SELECT USING (true); CREATE POLICY p2 ON r2 FOR INSERT WITH CHECK (false); CREATE POLICY p3 ON r2 FOR UPDATE USING (false); CREATE POLICY p4 ON r2 FOR DELETE USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM r1; a ---- 10 20 SELECT * FROM r2; a ---- 10 20 -- r2 is read-only INSERT INTO r2 VALUES (2); -- Not allowed ERROR: new row violates row-level security policy for table "r2" \pset tuples_only 1 UPDATE r2 SET a = 2 RETURNING *; -- Updates nothing DELETE FROM r2 RETURNING *; -- Deletes nothing \pset tuples_only 0 -- r2 can be used as a non-target relation in DML INSERT INTO r1 SELECT a + 1 FROM r2 RETURNING *; -- OK a ---- 11 21 UPDATE r1 SET a = r2.a + 2 FROM r2 WHERE r1.a = r2.a RETURNING *; -- OK ERROR: new row for relation "_hyper_23_105_chunk" violates check constraint "constraint_105" DELETE FROM r1 USING r2 WHERE r1.a = r2.a + 2 RETURNING *; -- OK a | a ---+--- SELECT * FROM r1; a ---- 10 11 20 21 SELECT * FROM r2; a ---- 10 20 SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE r1; DROP TABLE r2; -- -- FORCE ROW LEVEL SECURITY applies RLS to owners too -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (25,regress_rls_schema,r1,t) INSERT INTO r1 VALUES (10), (20); CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No error, but no rows TABLE r1; a --- -- RLS error INSERT INTO r1 VALUES (1); ERROR: new row violates row-level security policy for table "r1" -- No error (unable to see any rows to update) UPDATE r1 SET a = 1; TABLE r1; a --- -- No error (unable to see any rows to delete) DELETE FROM r1; TABLE r1; a --- SET row_security = off; -- these all fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. UPDATE r1 SET a = 1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DELETE FROM r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DROP TABLE r1; -- -- FORCE ROW LEVEL SECURITY does not break RI -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (26,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Errors due to rows in r2 DELETE FROM r1; ERROR: update or delete on table "r1" violates foreign key constraint "r2_a_fkey" on table "r2" DETAIL: Key (a)=(10) is still referenced from table "r2". -- Reset r2 to no-RLS DROP POLICY p1 ON r2; ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; ALTER TABLE r2 DISABLE ROW LEVEL SECURITY; -- clean out r2 for INSERT test below DELETE FROM r2; -- Change r1 to not allow rows to be seen CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No rows seen TABLE r1; a --- -- No error, RI still sees that row exists in r1 INSERT INTO r2 VALUES (10); DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded DELETE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON DELETE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (27,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Deletes all records from both DELETE FROM r1; -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify no rows in r2 now TABLE r2; a --- DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded UPDATE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON UPDATE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (28,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Updates records in both (terse output to not print CONTEXT, which can be different). \set VERBOSITY terse UPDATE r1 SET a = a+5; ERROR: new row for relation "_hyper_28_117_chunk" violates check constraint "constraint_117" \set VERBOSITY default -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify records in r2 updated TABLE r2; a ---- 10 20 DROP TABLE r2; DROP TABLE r1; -- -- Test INSERT+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (29,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (false); CREATE POLICY p2 ON r1 FOR INSERT WITH CHECK (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine INSERT INTO r1 VALUES (10), (20); -- No error, but no rows TABLE r1; a --- SET row_security = off; -- fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. SET row_security = on; -- Error INSERT INTO r1 VALUES (10), (20) RETURNING *; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- -- Test UPDATE+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>100); create_hypertable ------------------------------ (30,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (a < 20); CREATE POLICY p2 ON r1 FOR UPDATE USING (a < 20) WITH CHECK (true); CREATE POLICY p3 ON r1 FOR INSERT WITH CHECK (true); INSERT INTO r1 VALUES (10); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine UPDATE r1 SET a = 30; -- Show updated rows ALTER TABLE r1 NO FORCE ROW LEVEL SECURITY; TABLE r1; a ---- 30 -- reset value in r1 for test with RETURNING UPDATE r1 SET a = 10; -- Verify row reset TABLE r1; a ---- 10 ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Error UPDATE r1 SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- UPDATE path of INSERT ... ON CONFLICT DO UPDATE should also error out INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- Should still error out without RETURNING (use of arbiter always requires -- SELECT permissions) INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" -- ON CONFLICT ON CONSTRAINT INSERT INTO r1 VALUES (10) ON CONFLICT ON CONSTRAINT r1_pkey DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- Check dependency handling RESET SESSION AUTHORIZATION; CREATE TABLE dep1 (c1 int); SELECT public.create_hypertable('dep1', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (31,regress_rls_schema,dep1,t) CREATE TABLE dep2 (c1 int); SELECT public.create_hypertable('dep2', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (32,regress_rls_schema,dep2,t) CREATE POLICY dep_p1 ON dep1 TO regress_rls_bob USING (c1 > (select max(dep2.c1) from dep2)); ALTER POLICY dep_p1 ON dep1 TO regress_rls_bob,regress_rls_carol; -- Should return one SELECT count(*) = 1 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t ALTER POLICY dep_p1 ON dep1 USING (true); -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_bob'); ?column? ---------- t -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_carol'); ?column? ---------- t -- Should return zero SELECT count(*) = 0 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t -- DROP OWNED BY testing RESET SESSION AUTHORIZATION; CREATE ROLE regress_rls_dob_role1; CREATE ROLE regress_rls_dob_role2; CREATE TABLE dob_t1 (c1 int); SELECT public.create_hypertable('dob_t1', 'c1', chunk_time_interval=>2); create_hypertable ---------------------------------- (33,regress_rls_schema,dob_t1,t) CREATE TABLE dob_t2 (c1 int) PARTITION BY RANGE (c1); CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should fail, already gone ERROR: policy "p1" for table "dob_t1" does not exist CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should succeed CREATE POLICY p1 ON dob_t2 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t2; -- should succeed DROP USER regress_rls_dob_role1; DROP USER regress_rls_dob_role2; -- -- Clean up objects -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP SCHEMA regress_rls_schema CASCADE; NOTICE: drop cascades to 116 other objects \set VERBOSITY default DROP USER regress_rls_alice; DROP USER regress_rls_bob; DROP USER regress_rls_carol; DROP USER regress_rls_dave; DROP USER regress_rls_exempt_user; DROP ROLE regress_rls_group1; DROP ROLE regress_rls_group2; -- Arrange to have a few policies left over, for testing -- pg_dump/pg_restore CREATE SCHEMA regress_rls_schema; CREATE TABLE rls_tbl (c1 int); SELECT public.create_hypertable('rls_tbl', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------- (34,regress_rls_schema,rls_tbl,t) ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl USING (c1 > 5); CREATE POLICY p2 ON rls_tbl FOR SELECT USING (c1 <= 3); CREATE POLICY p3 ON rls_tbl FOR UPDATE USING (c1 <= 3) WITH CHECK (c1 > 5); CREATE POLICY p4 ON rls_tbl FOR DELETE USING (c1 <= 3); CREATE TABLE rls_tbl_force (c1 int); SELECT public.create_hypertable('rls_tbl_force', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------------- (35,regress_rls_schema,rls_tbl_force,t) ALTER TABLE rls_tbl_force ENABLE ROW LEVEL SECURITY; ALTER TABLE rls_tbl_force FORCE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl_force USING (c1 = 5) WITH CHECK (c1 < 5); CREATE POLICY p2 ON rls_tbl_force FOR SELECT USING (c1 = 8); CREATE POLICY p3 ON rls_tbl_force FOR UPDATE USING (c1 = 8) WITH CHECK (c1 >= 5); CREATE POLICY p4 ON rls_tbl_force FOR DELETE USING (c1 = 8); ������������������������������������timescaledb-2.23.0/test/expected/rowsecurity-18.out�������������������������������������������������0000664�0000000�0000000�00000556004�15100345067�0022223�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Test of Row-level security feature -- -- Clean up in case a prior regression run failed \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET timescaledb.enable_constraint_exclusion TO off; -- Suppress NOTICE messages when users/groups don't exist SET client_min_messages TO 'warning'; DROP USER IF EXISTS regress_rls_alice; DROP USER IF EXISTS regress_rls_bob; DROP USER IF EXISTS regress_rls_carol; DROP USER IF EXISTS regress_rls_dave; DROP USER IF EXISTS regress_rls_exempt_user; DROP ROLE IF EXISTS regress_rls_group1; DROP ROLE IF EXISTS regress_rls_group2; DROP SCHEMA IF EXISTS regress_rls_schema CASCADE; RESET client_min_messages; -- initial setup CREATE USER regress_rls_alice NOLOGIN; CREATE USER regress_rls_bob NOLOGIN; CREATE USER regress_rls_carol NOLOGIN; CREATE USER regress_rls_dave NOLOGIN; CREATE USER regress_rls_exempt_user BYPASSRLS NOLOGIN; CREATE ROLE regress_rls_group1 NOLOGIN; CREATE ROLE regress_rls_group2 NOLOGIN; GRANT regress_rls_group1 TO regress_rls_bob; GRANT regress_rls_group2 TO regress_rls_carol; CREATE SCHEMA regress_rls_schema; GRANT ALL ON SCHEMA regress_rls_schema to public; SET search_path = regress_rls_schema; -- setup of malicious function CREATE OR REPLACE FUNCTION f_leak(text) RETURNS bool COST 0.0000001 LANGUAGE plpgsql AS 'BEGIN RAISE NOTICE ''f_leak => %'', $1; RETURN true; END'; GRANT EXECUTE ON FUNCTION f_leak(text) TO public; -- BASIC Row-Level Security Scenario SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE uaccount ( pguser name primary key, seclv int ); GRANT SELECT ON uaccount TO public; INSERT INTO uaccount VALUES ('regress_rls_alice', 99), ('regress_rls_bob', 1), ('regress_rls_carol', 2), ('regress_rls_dave', 3); CREATE TABLE category ( cid int primary key, cname text ); GRANT ALL ON category TO public; INSERT INTO category VALUES (11, 'novel'), (22, 'science fiction'), (33, 'technology'), (44, 'manga'); CREATE TABLE document ( did int primary key, cid int references category(cid), dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON document TO public; SELECT public.create_hypertable('document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------- (1,regress_rls_schema,document,t) INSERT INTO document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 22, 2, 'regress_rls_bob', 'my science fiction'), ( 4, 44, 1, 'regress_rls_bob', 'my first manga'), ( 5, 44, 2, 'regress_rls_bob', 'my second manga'), ( 6, 22, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 33, 2, 'regress_rls_carol', 'great technology book'), ( 8, 44, 1, 'regress_rls_carol', 'great manga'), ( 9, 22, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 33, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE document ENABLE ROW LEVEL SECURITY; -- user's security level must be higher than or equal to document's CREATE POLICY p1 ON document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- try to create a policy of bogus type CREATE POLICY p1 ON document AS UGLY USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); ERROR: unrecognized row security option "ugly" LINE 1: CREATE POLICY p1 ON document AS UGLY ^ HINT: Only PERMISSIVE or RESTRICTIVE policies are supported currently. -- but Dave isn't allowed to anything at cid 50 or above -- this is to make sure that we sort the policies by name first -- when applying WITH CHECK, a later INSERT by Dave should fail due -- to p1r first CREATE POLICY p2r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44 AND cid < 50); -- and Dave isn't allowed to see manga documents CREATE POLICY p1r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44); \dp Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------------------+----------+-------+----------------------------------------------+-------------------+-------------------------------------------- regress_rls_schema | category | table | regress_rls_alice=arwdDxtm/regress_rls_alice+| | | | | =arwdDxtm/regress_rls_alice | | regress_rls_schema | document | table | regress_rls_alice=arwdDxtm/regress_rls_alice+| | p1: + | | | =arwdDxtm/regress_rls_alice | | (u): (dlevel <= ( SELECT uaccount.seclv + | | | | | FROM uaccount + | | | | | WHERE (uaccount.pguser = CURRENT_USER)))+ | | | | | p2r (RESTRICTIVE): + | | | | | (u): ((cid <> 44) AND (cid < 50)) + | | | | | to: regress_rls_dave + | | | | | p1r (RESTRICTIVE): + | | | | | (u): (cid <> 44) + | | | | | to: regress_rls_dave regress_rls_schema | uaccount | table | regress_rls_alice=arwdDxtm/regress_rls_alice+| | | | | =r/regress_rls_alice | | \d document Table "regress_rls_schema.document" Column | Type | Collation | Nullable | Default ---------+---------+-----------+----------+--------- did | integer | | not null | cid | integer | | | dlevel | integer | | not null | dauthor | name | | | dtitle | text | | | Indexes: "document_pkey" PRIMARY KEY, btree (did) Foreign-key constraints: "document_cid_fkey" FOREIGN KEY (cid) REFERENCES category(cid) Policies: POLICY "p1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "p1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid <> 44)) POLICY "p2r" AS RESTRICTIVE TO regress_rls_dave USING (((cid <> 44) AND (cid < 50))) Number of child tables: 6 (Use \d+ to list them.) SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename = 'document' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+-----------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | document | p1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | document | p1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid <> 44) | regress_rls_schema | document | p2r | RESTRICTIVE | {regress_rls_dave} | ALL | ((cid <> 44) AND (cid < 50)) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 44 | 1 | regress_rls_bob | my first manga 6 | 22 | 1 | regress_rls_carol | great science fiction 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 44 | 4 | 1 | regress_rls_bob | my first manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Hash Join Hash Cond: (document.cid = category.cid) InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Hash -> Seq Scan on category -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-------------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 22 | 9 | 1 | regress_rls_dave | awesome science fiction | science fiction 33 | 10 | 2 | regress_rls_dave | awesome technology book | technology EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Nested Loop InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((cid <> 44) AND (cid <> 44) AND (cid < 50) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Index Scan using category_pkey on category Index Cond: (cid = document.cid) -- 44 would technically fail for both p2r and p1r, but we should get an error -- back from p1r for this because it sorts first INSERT INTO document VALUES (100, 44, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p1r" for table "document" -- Just to see a p2r error INSERT INTO document VALUES (100, 55, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail ERROR: new row violates row-level security policy "p2r" for table "document" -- only owner can change policies ALTER POLICY p1 ON document USING (true); --fail ERROR: must be owner of table document DROP POLICY p1 ON document; --fail ERROR: must be owner of relation document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+-------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science fiction NOTICE: f_leak => my first manga NOTICE: f_leak => my second manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-----------------+--------------------+----------------- 11 | 1 | 1 | regress_rls_bob | my first novel | novel 11 | 2 | 2 | regress_rls_bob | my second novel | novel 22 | 3 | 2 | regress_rls_bob | my science fiction | science fiction 44 | 4 | 1 | regress_rls_bob | my first manga | manga 44 | 5 | 2 | regress_rls_bob | my second manga | manga -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great manga cid | did | dlevel | dauthor | dtitle | cname -----+-----+--------+-------------------+-----------------------+----------------- 22 | 6 | 1 | regress_rls_carol | great science fiction | science fiction 33 | 7 | 2 | regress_rls_carol | great technology book | technology 44 | 8 | 1 | regress_rls_carol | great manga | manga EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); --- QUERY PLAN --- Nested Loop -> Custom Scan (ChunkAppend) on document Chunks excluded during startup: 0 -> Seq Scan on document document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_1_chunk document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_2_chunk document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_3_chunk document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_4_chunk document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_5_chunk document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_1_6_chunk document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Index Scan using category_pkey on category Index Cond: (cid = document.cid) -- interaction of FK/PK constraints SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY p2 ON category USING (CASE WHEN current_user = 'regress_rls_bob' THEN cid IN (11, 33) WHEN current_user = 'regress_rls_carol' THEN cid IN (22, 44) ELSE false END); ALTER TABLE category ENABLE ROW LEVEL SECURITY; -- cannot delete PK referenced by invisible FK SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-----------------+--------------------+-----+------------ 1 | 11 | 1 | regress_rls_bob | my first novel | 11 | novel 2 | 11 | 2 | regress_rls_bob | my second novel | 11 | novel 3 | 22 | 2 | regress_rls_bob | my science fiction | | 4 | 44 | 1 | regress_rls_bob | my first manga | | 5 | 44 | 2 | regress_rls_bob | my second manga | | | | | | | 33 | technology \set VERBOSITY sqlstate DELETE FROM category WHERE cid = 33; -- fails with FK violation ERROR: 23503 \set VERBOSITY default -- can insert FK referencing invisible PK SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; did | cid | dlevel | dauthor | dtitle | cid | cname -----+-----+--------+-------------------+-----------------------+-----+----------------- 6 | 22 | 1 | regress_rls_carol | great science fiction | 22 | science fiction 7 | 33 | 2 | regress_rls_carol | great technology book | | 8 | 44 | 1 | regress_rls_carol | great manga | 44 | manga INSERT INTO document VALUES (11, 33, 1, current_user, 'hoge'); -- UNIQUE or PRIMARY KEY constraint violation DOES reveal presence of row SET SESSION AUTHORIZATION regress_rls_bob; INSERT INTO document VALUES (8, 44, 1, 'regress_rls_bob', 'my third manga'); -- Must fail with unique violation, revealing presence of did we can't see ERROR: duplicate key value violates unique constraint "5_10_document_pkey" DETAIL: Key (did)=(8) already exists. SELECT * FROM document WHERE did = 8; -- and confirm we can't see it did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- RLS policies are checked before constraints INSERT INTO document VALUES (8, 44, 1, 'regress_rls_carol', 'my third manga'); -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" UPDATE document SET did = 8, dauthor = 'regress_rls_carol' WHERE did = 5; -- Should fail with RLS check violation, not duplicate key violation ERROR: new row violates row-level security policy for table "document" -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database superuser does bypass RLS policy when disabled RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- RLS policy does not apply to table owner when RLS disabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO OFF; SELECT * FROM document; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 22 | 2 | regress_rls_bob | my science fiction 4 | 44 | 1 | regress_rls_bob | my first manga 5 | 44 | 2 | regress_rls_bob | my second manga 6 | 22 | 1 | regress_rls_carol | great science fiction 7 | 33 | 2 | regress_rls_carol | great technology book 8 | 44 | 1 | regress_rls_carol | great manga 9 | 22 | 1 | regress_rls_dave | awesome science fiction 10 | 33 | 2 | regress_rls_dave | awesome technology book 11 | 33 | 1 | regress_rls_carol | hoge SELECT * FROM category; cid | cname -----+----------------- 11 | novel 22 | science fiction 33 | technology 44 | manga -- -- Table inheritance and RLS policy -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE t1 (a int, junk1 text, b text); ALTER TABLE t1 DROP COLUMN junk1; -- just a disturbing factor GRANT ALL ON t1 TO public; COPY t1 FROM stdin; CREATE TABLE t2 (c float) INHERITS (t1); GRANT ALL ON t2 TO public; COPY t2 FROM stdin; CREATE TABLE t3 (c text, b text, a int); ALTER TABLE t3 INHERIT t1; GRANT ALL ON t3 TO public; COPY t3(a,b,c) FROM stdin; CREATE POLICY p1 ON t1 FOR ALL TO PUBLIC USING (a % 2 = 0); -- be even number CREATE POLICY p2 ON t2 FOR ALL TO PUBLIC USING (a % 2 = 1); -- be odd number ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; ALTER TABLE t2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- reference to system column SELECT ctid, * FROM t1; ctid | a | b -------+---+----- (0,2) | 2 | bbb (0,4) | 4 | dad (0,2) | 2 | bcd (0,4) | 4 | def (0,2) | 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- reference to whole-row reference SELECT *, t1 FROM t1; a | b | t1 ---+-----+--------- 2 | bbb | (2,bbb) 4 | dad | (4,dad) 2 | bcd | (2,bcd) 4 | def | (4,def) 2 | yyy | (2,yyy) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) -- for share/update lock SELECT * FROM t1 FOR SHARE; a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on t2 t1_2 Filter: ((a % 2) = 0) -> Seq Scan on t3 t1_3 Filter: ((a % 2) = 0) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy a | b ---+----- 2 | bbb 4 | dad 2 | bcd 4 | def 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -- union all query SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; a | b | ctid ---+-----+------- 1 | abc | (0,1) 3 | cde | (0,3) 1 | xxx | (0,1) 2 | yyy | (0,2) 3 | zzz | (0,3) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; --- QUERY PLAN --- Append -> Seq Scan on t2 Filter: ((a % 2) = 1) -> Seq Scan on t3 -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- -- Hyper Tables -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE hyper_document ( did int, cid int, dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON hyper_document TO public; SELECT public.create_hypertable('hyper_document', 'did', chunk_time_interval=>2); create_hypertable ----------------------------------------- (2,regress_rls_schema,hyper_document,t) INSERT INTO hyper_document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 99, 2, 'regress_rls_bob', 'my science textbook'), ( 4, 55, 1, 'regress_rls_bob', 'my first satire'), ( 5, 99, 2, 'regress_rls_bob', 'my history book'), ( 6, 11, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 99, 2, 'regress_rls_carol', 'great technology book'), ( 8, 55, 2, 'regress_rls_carol', 'great satire'), ( 9, 11, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 99, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE hyper_document ENABLE ROW LEVEL SECURITY; GRANT ALL ON _timescaledb_internal._hyper_2_9_chunk TO public; -- Create policy on parent -- user's security level must be higher than or equal to document's CREATE POLICY pp1 ON hyper_document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- Dave is only allowed to see cid < 55 CREATE POLICY pp1r ON hyper_document AS RESTRICTIVE TO regress_rls_dave USING (cid < 55); \d+ hyper_document Table "regress_rls_schema.hyper_document" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ---------+---------+-----------+----------+---------+----------+--------------+------------- did | integer | | not null | | plain | | cid | integer | | | | plain | | dlevel | integer | | not null | | plain | | dauthor | name | | | | plain | | dtitle | text | | | | extended | | Indexes: "hyper_document_did_idx" btree (did DESC) Policies: POLICY "pp1" USING ((dlevel <= ( SELECT uaccount.seclv FROM uaccount WHERE (uaccount.pguser = CURRENT_USER)))) POLICY "pp1r" AS RESTRICTIVE TO regress_rls_dave USING ((cid < 55)) Not-null constraints: "hyper_document_did_not_null" NOT NULL "did" "hyper_document_dlevel_not_null" NOT NULL "dlevel" Child tables: _timescaledb_internal._hyper_2_10_chunk, _timescaledb_internal._hyper_2_11_chunk, _timescaledb_internal._hyper_2_12_chunk, _timescaledb_internal._hyper_2_13_chunk, _timescaledb_internal._hyper_2_14_chunk, _timescaledb_internal._hyper_2_9_chunk SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename like '%hyper_document%' ORDER BY policyname; schemaname | tablename | policyname | permissive | roles | cmd | qual | with_check --------------------+----------------+------------+-------------+--------------------+-----+--------------------------------------------+------------ regress_rls_schema | hyper_document | pp1 | PERMISSIVE | {public} | ALL | (dlevel <= ( SELECT uaccount.seclv +| | | | | | | FROM uaccount +| | | | | | | WHERE (uaccount.pguser = CURRENT_USER))) | regress_rls_schema | hyper_document | pp1r | RESTRICTIVE | {regress_rls_dave} | ALL | (cid < 55) | -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my first satire NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 4 | 55 | 1 | regress_rls_bob | my first satire 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- pp1 ERROR INSERT INTO hyper_document VALUES (1, 11, 5, 'regress_rls_dave', 'testing pp1'); -- fail ERROR: new row violates row-level security policy for table "hyper_document" -- pp1r ERROR INSERT INTO hyper_document VALUES (1, 99, 1, 'regress_rls_dave', 'testing pp1r'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- Show that RLS policy does not apply for direct inserts to children -- This should fail with RLS POLICY pp1r violation. INSERT INTO hyper_document VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- fail ERROR: new row violates row-level security policy "pp1r" for table "hyper_document" -- But this should succeed. INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- success -- We still cannot see the row using the parent SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction -- But we can if we look directly SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- Turn on RLS and create policy on child to show RLS is checked before constraints SET SESSION AUTHORIZATION regress_rls_alice; ALTER TABLE _timescaledb_internal._hyper_2_9_chunk ENABLE ROW LEVEL SECURITY; CREATE POLICY pp3 ON _timescaledb_internal._hyper_2_9_chunk AS RESTRICTIVE USING (cid < 55); -- This should fail with RLS violation now. SET SESSION AUTHORIZATION regress_rls_dave; INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables - round 2'); -- fail ERROR: new row violates row-level security policy for table "_hyper_2_9_chunk" -- And now we cannot see directly into the partition either, due to RLS SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+---------+-------- -- The parent looks same as before -- viewpoint from regress_rls_dave SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => great science fiction NOTICE: f_leak => awesome science fiction did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 6 | 11 | 1 | regress_rls_carol | great science fiction 9 | 11 | 1 | regress_rls_dave | awesome science fiction EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((cid < 55) AND (dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => testing RLS with hypertables NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire NOTICE: f_leak => awesome science fiction NOTICE: f_leak => awesome technology book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 InitPlan 1 -> Index Scan using uaccount_pkey on uaccount Index Cond: (pguser = CURRENT_USER) -> Seq Scan on hyper_document hyper_document_1 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dlevel <= (InitPlan 1).col1) AND f_leak(dtitle)) -- only owner can change policies ALTER POLICY pp1 ON hyper_document USING (true); --fail ERROR: must be owner of table hyper_document DROP POLICY pp1 ON hyper_document; --fail ERROR: must be owner of relation hyper_document SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY pp1 ON hyper_document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => my first novel NOTICE: f_leak => my second novel NOTICE: f_leak => my science textbook NOTICE: f_leak => my first satire NOTICE: f_leak => my history book did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+--------------------- 1 | 11 | 1 | regress_rls_bob | my first novel 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; NOTICE: f_leak => great science fiction NOTICE: f_leak => great technology book NOTICE: f_leak => great satire did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+----------------------- 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); --- QUERY PLAN --- Custom Scan (ChunkAppend) on hyper_document Chunks excluded during startup: 0 -> Seq Scan on hyper_document hyper_document_1 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_9_chunk hyper_document_2 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_10_chunk hyper_document_3 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_11_chunk hyper_document_4 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_12_chunk hyper_document_5 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_13_chunk hyper_document_6 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -> Seq Scan on _hyper_2_14_chunk hyper_document_7 Filter: ((dauthor = CURRENT_USER) AND f_leak(dtitle)) -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables 2 | 11 | 2 | regress_rls_bob | my second novel 3 | 99 | 2 | regress_rls_bob | my science textbook 4 | 55 | 1 | regress_rls_bob | my first satire 5 | 99 | 2 | regress_rls_bob | my history book 6 | 11 | 1 | regress_rls_carol | great science fiction 7 | 99 | 2 | regress_rls_carol | great technology book 8 | 55 | 2 | regress_rls_carol | great satire 9 | 11 | 1 | regress_rls_dave | awesome science fiction 10 | 99 | 2 | regress_rls_dave | awesome technology book SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; did | cid | dlevel | dauthor | dtitle -----+-----+--------+------------------+------------------------------ 1 | 11 | 1 | regress_rls_bob | my first novel 1 | 55 | 1 | regress_rls_dave | testing RLS with hypertables -- When RLS disabled, other users get ERROR. SET SESSION AUTHORIZATION regress_rls_dave; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "hyper_document" SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; ERROR: query would be affected by row-level security policy for table "_hyper_2_9_chunk" -- Check behavior with a policy that uses a SubPlan not an InitPlan. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE POLICY pp3 ON hyper_document AS RESTRICTIVE USING ((SELECT dlevel <= seclv FROM uaccount WHERE pguser = current_user)); SET SESSION AUTHORIZATION regress_rls_carol; INSERT INTO hyper_document VALUES (100, 11, 5, 'regress_rls_carol', 'testing pp3'); -- fail ERROR: new row violates row-level security policy "pp3" for table "hyper_document" ----- Dependencies ----- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE dependee (x integer, y integer); SELECT public.create_hypertable('dependee', 'x', chunk_time_interval=>2); create_hypertable ----------------------------------- (3,regress_rls_schema,dependee,t) CREATE TABLE dependent (x integer, y integer); SELECT public.create_hypertable('dependent', 'x', chunk_time_interval=>2); create_hypertable ------------------------------------ (4,regress_rls_schema,dependent,t) CREATE POLICY d1 ON dependent FOR ALL TO PUBLIC USING (x = (SELECT d.x FROM dependee d WHERE d.y = y)); DROP TABLE dependee; -- Should fail without CASCADE due to dependency on row security qual? ERROR: cannot drop table dependee because other objects depend on it DETAIL: policy d1 on table dependent depends on table dependee HINT: Use DROP ... CASCADE to drop the dependent objects too. DROP TABLE dependee CASCADE; NOTICE: drop cascades to policy d1 on table dependent EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM dependent; -- After drop, should be unqualified --- QUERY PLAN --- Seq Scan on dependent ----- RECURSION ---- -- -- Simple recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec1 (x integer, y integer); SELECT public.create_hypertable('rec1', 'x', chunk_time_interval=>2); create_hypertable ------------------------------- (5,regress_rls_schema,rec1,t) CREATE POLICY r1 ON rec1 USING (x = (SELECT r.x FROM rec1 r WHERE y = r.y)); ALTER TABLE rec1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, direct recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec2 (a integer, b integer); SELECT public.create_hypertable('rec2', 'x', chunk_time_interval=>2); ERROR: column "x" does not exist ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2 WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1 WHERE y = b)); ALTER TABLE rec2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via views -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rec1v AS SELECT * FROM rec1; CREATE VIEW rec2v AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); ALTER POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via views ERROR: infinite recursion detected in policy for relation "rec1" -- -- Mutual recursion via .s.b views -- SET SESSION AUTHORIZATION regress_rls_bob; \set VERBOSITY terse \\ -- suppress cascade details DROP VIEW rec1v, rec2v CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE VIEW rec1v WITH (security_barrier) AS SELECT * FROM rec1; CREATE VIEW rec2v WITH (security_barrier) AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via s.b. views ERROR: infinite recursion detected in policy for relation "rec1" -- -- recursive RLS and VIEWs in policy -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE s1 (a int, b text); SELECT public.create_hypertable('s1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (6,regress_rls_schema,s1,t) INSERT INTO s1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE TABLE s2 (x int, y text); SELECT public.create_hypertable('s2', 'x', chunk_time_interval=>2); create_hypertable ----------------------------- (7,regress_rls_schema,s2,t) INSERT INTO s2 (SELECT x, md5(x::text) FROM generate_series(-6,6) x); GRANT SELECT ON s1, s2 TO regress_rls_bob; CREATE POLICY p1 ON s1 USING (a in (select x from s2 where y like '%2f%')); CREATE POLICY p2 ON s2 USING (x in (select a from s1 where b like '%22%')); CREATE POLICY p3 ON s1 FOR INSERT WITH CHECK (a = (SELECT a FROM s1)); ALTER TABLE s1 ENABLE ROW LEVEL SECURITY; ALTER TABLE s2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW v2 AS SELECT * FROM s2 WHERE y like '%af%'; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" INSERT INTO s1 VALUES (1, 'foo'); -- fail (infinite recursion) ERROR: infinite recursion detected in policy for relation "s1" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3 on s1; ALTER POLICY p2 ON s2 USING (x % 2 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c a | b ---+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b); --- QUERY PLAN --- Seq Scan on s1 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%2f%'::text)) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON s1 USING (a in (select x from v2)); -- using VIEW in RLS policy SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK NOTICE: f_leak => 0267aaf632e87a63288a08331f22c7c3 NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc a | b ----+---------------------------------- -4 | 0267aaf632e87a63288a08331f22c7c3 6 | 1679091c5a880faf6fb5e6087eb1b2dc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM s1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on s1 Chunks excluded during startup: 0 -> Seq Scan on s1 s1_1 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) SubPlan 1 -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: ((ANY (a = (hashed SubPlan 1).col1)) AND f_leak(b)) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; xx | x | y ----+----+---------------------------------- -6 | -6 | 596a3d04481816330f07e4f97510c28f -4 | -4 | 0267aaf632e87a63288a08331f22c7c3 2 | 2 | c81e728d9d4c2f636f067f89cc14862c EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; --- QUERY PLAN --- Result -> Append -> Seq Scan on s2 s2_1 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_2 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_3 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_4 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_5 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_6 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_7 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_8 Filter: (((x % 2) = 0) AND (y ~~ '%28%'::text)) SubPlan 2 -> Limit -> Result -> Custom Scan (ChunkAppend) on s1 -> Seq Scan on s1 s1_1 Filter: (ANY (a = (hashed SubPlan 1).col1)) SubPlan 1 -> Append -> Seq Scan on s2 s2_10 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_27_chunk s2_11 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_28_chunk s2_12 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_29_chunk s2_13 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_30_chunk s2_14 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_31_chunk s2_15 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_32_chunk s2_16 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_7_33_chunk s2_17 Filter: (((x % 2) = 0) AND (y ~~ '%af%'::text)) -> Seq Scan on _hyper_6_16_chunk s1_2 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_17_chunk s1_3 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_18_chunk s1_4 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_19_chunk s1_5 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_20_chunk s1_6 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_21_chunk s1_7 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_22_chunk s1_8 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_23_chunk s1_9 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_24_chunk s1_10 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_25_chunk s1_11 Filter: (ANY (a = (hashed SubPlan 1).col1)) -> Seq Scan on _hyper_6_26_chunk s1_12 Filter: (ANY (a = (hashed SubPlan 1).col1)) SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p2 ON s2 USING (x in (select a from s1 where b like '%d2%')); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion via view) ERROR: infinite recursion detected in policy for relation "s1" -- prepared statement with regress_rls_alice privilege PREPARE p1(int) AS SELECT * FROM t1 WHERE a <= $1; EXECUTE p1(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a <= 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a <= 2) AND ((a % 2) = 0)) -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => cde NOTICE: f_leak => def NOTICE: f_leak => xxx NOTICE: f_leak => yyy NOTICE: f_leak => zzz a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad 1 | abc 2 | bcd 3 | cde 4 | def 1 | xxx 2 | yyy 3 | zzz EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: f_leak(b) -> Seq Scan on t2 t1_2 Filter: f_leak(b) -> Seq Scan on t3 t1_3 Filter: f_leak(b) -- plan cache should be invalidated EXECUTE p1(2); a | b ---+----- 1 | aba 2 | bbb 1 | abc 2 | bcd 1 | xxx 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a <= 2) -> Seq Scan on t2 t1_2 Filter: (a <= 2) -> Seq Scan on t3 t1_3 Filter: (a <= 2) PREPARE p2(int) AS SELECT * FROM t1 WHERE a = $1; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: (a = 2) -> Seq Scan on t2 t1_2 Filter: (a = 2) -> Seq Scan on t3 t1_3 Filter: (a = 2) -- also, case when privilege switch from superuser SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXECUTE p2(2); a | b ---+----- 2 | bbb 2 | bcd 2 | yyy EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t2 t1_2 Filter: ((a = 2) AND ((a % 2) = 0)) -> Seq Scan on t3 t1_3 Filter: ((a = 2) AND ((a % 2) = 0)) -- -- UPDATE / DELETE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_bob; EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Result -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b = b || b WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => yyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); --- QUERY PLAN --- Update on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); NOTICE: f_leak => bbbbbb NOTICE: f_leak => daddad -- returning clause with system column UPDATE only t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,9) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,10) | 4 | daddad_updt | (4,daddad_updt) UPDATE t1 SET b = b WHERE f_leak(b) RETURNING *; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy a | b ---+------------- 2 | bbbbbb_updt 4 | daddad_updt 2 | bcdbcd 4 | defdef 2 | yyyyyy UPDATE t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,14) | 4 | daddad_updt | (4,daddad_updt) (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,10) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- updates with from clause EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t3 Filter: ((a = 2) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); NOTICE: f_leak => cde NOTICE: f_leak => yyyyyy EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t1 Update on t1 t1_1 Update on t2 t1_2 Update on t3 t1_3 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); --- QUERY PLAN --- Update on t2 -> Nested Loop -> Seq Scan on t2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Append -> Seq Scan on t1 t1_1 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: ((a = 3) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); NOTICE: f_leak => cde -- updates with from clause self join EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; --- QUERY PLAN --- Update on t2 t2_1 -> Nested Loop Join Filter: (t2_1.b = t2_2.b) -> Seq Scan on t2 t2_1 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) -> Seq Scan on t2 t2_2 Filter: ((a = 3) AND ((a % 2) = 1) AND f_leak(b)) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; NOTICE: f_leak => cde NOTICE: f_leak => cde a | b | c | a | b | c | t2_1 | t2_2 ---+-----+-----+---+-----+-----+-------------+------------- 3 | cde | 3.3 | 3 | cde | 3.3 | (3,cde,3.3) | (3,cde,3.3) EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; --- QUERY PLAN --- Update on t1 t1_1 Update on t1 t1_1_1 Update on t2 t1_1_2 Update on t3 t1_1_3 -> Nested Loop Join Filter: (t1_1.b = t1_2.b) -> Append -> Seq Scan on t1 t1_1_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_1_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_1_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Materialize -> Append -> Seq Scan on t1 t1_2_1 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2_2 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_2_3 Filter: ((a = 4) AND ((a % 2) = 0) AND f_leak(b)) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; NOTICE: f_leak => daddad_updt NOTICE: f_leak => daddad_updt NOTICE: f_leak => defdef NOTICE: f_leak => defdef a | b | a | b | t1_1 | t1_2 ---+-------------+---+-------------+-----------------+----------------- 4 | daddad_updt | 4 | daddad_updt | (4,daddad_updt) | (4,daddad_updt) 4 | defdef | 4 | defdef | (4,defdef) | (4,defdef) RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 ORDER BY a,b; a | b ---+------------- 1 | aba 1 | abc 1 | xxx 2 | bbbbbb_updt 2 | bcdbcd 2 | yyyyyy 3 | ccc 3 | cde 3 | zzz 4 | daddad_updt 4 | defdef SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM only t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 -> Seq Scan on t1 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM t1 WHERE f_leak(b); --- QUERY PLAN --- Delete on t1 Delete on t1 t1_1 Delete on t2 t1_2 Delete on t3 t1_3 -> Append -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t2 t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on t3 t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM only t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bbbbbb_updt NOTICE: f_leak => daddad_updt ctid | a | b | t1 --------+---+-------------+----------------- (0,13) | 2 | bbbbbb_updt | (2,bbbbbb_updt) (0,15) | 4 | daddad_updt | (4,daddad_updt) DELETE FROM t1 WHERE f_leak(b) RETURNING ctid, *, t1; NOTICE: f_leak => bcdbcd NOTICE: f_leak => defdef NOTICE: f_leak => yyyyyy ctid | a | b | t1 --------+---+--------+------------ (0,9) | 2 | bcdbcd | (2,bcdbcd) (0,13) | 4 | defdef | (4,defdef) (0,6) | 2 | yyyyyy | (2,yyyyyy) -- -- S.b. view on top of Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE b1 (a int, b text); SELECT public.create_hypertable('b1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (8,regress_rls_schema,b1,t) INSERT INTO b1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE POLICY p1 ON b1 USING (a % 2 = 0); ALTER TABLE b1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON b1 TO regress_rls_bob; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW bv1 WITH (security_barrier) AS SELECT * FROM b1 WHERE a > 0 WITH CHECK OPTION; GRANT ALL ON bv1 TO regress_rls_carol; SET SESSION AUTHORIZATION regress_rls_carol; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM bv1 WHERE f_leak(b); --- QUERY PLAN --- Subquery Scan on bv1 Filter: f_leak(bv1.b) -> Append -> Seq Scan on b1 b1_1 Filter: ((a > 0) AND ((a % 2) = 0)) -> Index Scan using _hyper_8_39_chunk_b1_a_idx on _hyper_8_39_chunk b1_2 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_40_chunk_b1_a_idx on _hyper_8_40_chunk b1_3 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_4 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_5 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_43_chunk_b1_a_idx on _hyper_8_43_chunk b1_6 Index Cond: (a > 0) Filter: ((a % 2) = 0) -> Index Scan using _hyper_8_44_chunk_b1_a_idx on _hyper_8_44_chunk b1_7 Index Cond: (a > 0) Filter: ((a % 2) = 0) SELECT * FROM bv1 WHERE f_leak(b); NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 a | b ----+---------------------------------- 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 INSERT INTO bv1 VALUES (-1, 'xxx'); -- should fail view WCO ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (11, 'xxx'); -- should fail RLS check ERROR: new row violates row-level security policy for table "b1" INSERT INTO bv1 VALUES (12, 'xxx'); -- ok EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on b1 Update on _hyper_8_41_chunk b1_1 -> Result -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_41_chunk_b1_a_idx on _hyper_8_41_chunk b1_1 Index Cond: ((a > 0) AND (a = 4)) Filter: (((a % 2) = 0) AND f_leak(b)) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on b1 Delete on _hyper_8_42_chunk b1_1 -> Custom Scan (ChunkAppend) on b1 Chunks excluded during startup: 0 -> Index Scan using _hyper_8_42_chunk_b1_a_idx on _hyper_8_42_chunk b1_1 Index Cond: ((a > 0) AND (a = 6)) Filter: (((a % 2) = 0) AND f_leak(b)) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM b1; a | b -----+---------------------------------- -10 | 1b0fd9efa5279c4203b7c70233f86dbf -9 | 252e691406782824eec43d7eadc3d256 -8 | a8d2ec85eaf98407310b72eb73dda247 -7 | 74687a12d3915d3c4d83f1af7b3683d5 -6 | 596a3d04481816330f07e4f97510c28f -5 | 47c1b025fa18ea96c33fbb6718688c0f -4 | 0267aaf632e87a63288a08331f22c7c3 -3 | b3149ecea4628efd23d2f86e5a723472 -2 | 5d7b9adcbe1c629ec722529dd12e5129 -1 | 6bb61e3b7bce0931da574d19d1d82c88 0 | cfcd208495d565ef66e7dff9f98764da 1 | c4ca4238a0b923820dcc509a6f75849b 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | yyy 7 | 8f14e45fceea167a5a36dedd4bea2543 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | xxx -- -- INSERT ... ON CONFLICT DO UPDATE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p1r ON document; CREATE POLICY p1 ON document FOR SELECT USING (true); CREATE POLICY p2 ON document FOR INSERT WITH CHECK (dauthor = current_user); CREATE POLICY p3 ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Exists... SELECT * FROM document WHERE did = 2; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------- 2 | 11 | 2 | regress_rls_bob | my second novel -- ...so violates actual WITH CHECK OPTION within UPDATE (not INSERT, since -- alternative UPDATE path happens to be taken): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, dauthor = EXCLUDED.dauthor; ERROR: new row violates row-level security policy for table "document" -- Violates USING qual for UPDATE policy p3. -- -- UPDATE path is taken, but UPDATE fails purely because *existing* row to be -- updated is not a "novel"/cid 11 (row is not leaked, even though we have -- SELECT privileges sufficient to see the row in this instance): INSERT INTO document VALUES (33, 22, 1, 'regress_rls_bob', 'okay science fiction'); -- preparation for next statement INSERT INTO document VALUES (33, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'Some novel, replaces sci-fi') -- takes UPDATE path ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fine (we UPDATE, since INSERT WCOs and UPDATE security barrier quals + WCOs -- not violated): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------- 2 | 11 | 2 | regress_rls_bob | my first novel -- Fine (we INSERT, so "cid = 33" ("technology") isn't evaluated): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 11 | 1 | regress_rls_bob | some technology novel -- Fine (same query, but we UPDATE, so "cid = 33", ("technology") is not the -- case in respect of *existing* tuple): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+----------------------- 78 | 33 | 1 | regress_rls_bob | some technology novel -- Same query a third time, but now fails due to existing tuple finally not -- passing quals: INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Don't fail just because INSERT doesn't satisfy WITH CHECK option that -- originated as a barrier/USING() qual from the UPDATE. Note that the UPDATE -- path *isn't* taken, and so UPDATE-related policy does not apply: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; did | cid | dlevel | dauthor | dtitle -----+-----+--------+-----------------+---------------------------------- 79 | 33 | 1 | regress_rls_bob | technology book, can only insert -- But this time, the same statement fails, because the UPDATE path is taken, -- and updating the row just inserted falls afoul of security barrier qual -- (enforced as WCO) -- what we might have updated target tuple to is -- irrelevant, in fact. INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Test default USING qual enforced as WCO SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p2 ON document; DROP POLICY p3 ON document; CREATE POLICY p3_with_default ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')); SET SESSION AUTHORIZATION regress_rls_bob; -- Just because WCO-style enforcement of USING quals occurs with -- existing/target tuple does not mean that the implementation can be allowed -- to fail to also enforce this qual against the final tuple appended to -- relation (since in the absence of an explicit WCO, this is also interpreted -- as an UPDATE/ALL WCO in general). -- -- UPDATE path is taken here (fails due to existing tuple). Note that this is -- not reported as a "USING expression", because it's an RLS UPDATE check that originated as -- a USING qual for the purposes of RLS in general, as opposed to an explicit -- USING qual that is ordinarily a security barrier. We leave it up to the -- UPDATE to make this fail: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" -- UPDATE path is taken here. Existing tuple passes, since it's cid -- corresponds to "novel", but default USING qual is enforced against -- post-UPDATE tuple too (as always when updating with a policy that lacks an -- explicit WCO), and so this fails: INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET cid = EXCLUDED.cid, dtitle = EXCLUDED.dtitle RETURNING *; ERROR: new row violates row-level security policy for table "document" SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3_with_default ON document; -- -- Test ALL policies with ON CONFLICT DO UPDATE (much the same as existing UPDATE -- tests) -- CREATE POLICY p3_with_all ON document FOR ALL USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Fails, since ALL WCO is enforced in insert path: INSERT INTO document VALUES (80, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33; ERROR: new row violates row-level security policy for table "document" -- Fails, since ALL policy USING qual is enforced (existing, target tuple is in -- violation, since it has the "manga" cid): INSERT INTO document VALUES (4, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; ERROR: new row violates row-level security policy (USING expression) for table "document" -- Fails, since ALL WCO are enforced: INSERT INTO document VALUES (1, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dauthor = 'regress_rls_carol'; ERROR: new row violates row-level security policy for table "document" -- -- ROLE/GROUP -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE z1 (a int, b text); SELECT public.create_hypertable('z1', 'a', chunk_time_interval=>2); create_hypertable ----------------------------- (9,regress_rls_schema,z1,t) CREATE TABLE z2 (a int, b text); SELECT public.create_hypertable('z2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (10,regress_rls_schema,z2,t) GRANT SELECT ON z1,z2 TO regress_rls_group1, regress_rls_group2, regress_rls_bob, regress_rls_carol; INSERT INTO z1 VALUES (1, 'aba'), (2, 'bbb'), (3, 'ccc'), (4, 'dad'); CREATE POLICY p1 ON z1 TO regress_rls_group1 USING (a % 2 = 0); CREATE POLICY p2 ON z1 TO regress_rls_group2 USING (a % 2 = 1); ALTER TABLE z1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test AS SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test2 AS WITH q AS MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test4 AS WITH q AS (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test6 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test6; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 PREPARE plancache_test3 AS WITH q AS MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test5 AS WITH q AS (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) PREPARE plancache_test7 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test7; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET ROLE regress_rls_group1; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) SET ROLE regress_rls_group2; SELECT * FROM z1 WHERE f_leak(b); NOTICE: f_leak => aba NOTICE: f_leak => ccc a | b ---+----- 1 | aba 3 | ccc EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; --- QUERY PLAN --- Nested Loop CTE q -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -> CTE Scan on q -> Materialize -> Seq Scan on z2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; --- QUERY PLAN --- Nested Loop CTE q -> Seq Scan on z2 -> CTE Scan on q -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; --- QUERY PLAN --- Nested Loop -> Seq Scan on z2 -> Materialize -> Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 1) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 1) AND f_leak(b)) -- -- Views should follow policy for view owner. -- -- View and Table owner are the same. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_bob; -- Query as role that is not owner of view or table. Should return all records. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) -- Query as view/table owner. Should return all records. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => aba NOTICE: f_leak => bbb NOTICE: f_leak => ccc NOTICE: f_leak => dad a | b ---+----- 1 | aba 2 | bbb 3 | ccc 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: f_leak(b) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: f_leak(b) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: f_leak(b) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: f_leak(b) DROP VIEW rls_view; -- View and Table owners are different. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_alice; -- Query as role that is not owner of view but is owner of table. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not owner of table but is owner of view. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -- Query as role that is not the owner of the table or view without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --fail - permission denied. ERROR: permission denied for view rls_view -- Query as role that is not the owner of the table or view with permissions. SET SESSION AUTHORIZATION regress_rls_bob; GRANT SELECT ON rls_view TO regress_rls_carol; SELECT * FROM rls_view; NOTICE: f_leak => bbb NOTICE: f_leak => dad a | b ---+----- 2 | bbb 4 | dad EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --- QUERY PLAN --- Custom Scan (ChunkAppend) on z1 Chunks excluded during startup: 0 -> Seq Scan on z1 z1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_49_chunk z1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_50_chunk z1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_9_51_chunk z1_4 Filter: (((a % 2) = 0) AND f_leak(b)) SET SESSION AUTHORIZATION regress_rls_bob; DROP VIEW rls_view; -- -- Command specific -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE x1 (a int, b text, c text); SELECT public.create_hypertable('x1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (11,regress_rls_schema,x1,t) GRANT ALL ON x1 TO PUBLIC; INSERT INTO x1 VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_carol'), (4, 'def', 'regress_rls_carol'), (5, 'efg', 'regress_rls_bob'), (6, 'fgh', 'regress_rls_bob'), (7, 'fgh', 'regress_rls_carol'), (8, 'fgh', 'regress_rls_carol'); CREATE POLICY p0 ON x1 FOR ALL USING (c = current_user); CREATE POLICY p1 ON x1 FOR SELECT USING (a % 2 = 0); CREATE POLICY p2 ON x1 FOR INSERT WITH CHECK (a % 2 = 1); CREATE POLICY p3 ON x1 FOR UPDATE USING (a % 2 = 0); CREATE POLICY p4 ON x1 FOR DELETE USING (a < 8); ALTER TABLE x1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+-----+------------------- 1 | abc | regress_rls_bob 2 | bcd | regress_rls_bob 4 | def | regress_rls_carol 5 | efg | regress_rls_bob 6 | fgh | regress_rls_bob 8 | fgh | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => abc NOTICE: f_leak => bcd NOTICE: f_leak => def NOTICE: f_leak => efg NOTICE: f_leak => fgh NOTICE: f_leak => fgh a | b | c ---+----------+------------------- 1 | abc_updt | regress_rls_bob 2 | bcd_updt | regress_rls_bob 4 | def_updt | regress_rls_carol 5 | efg_updt | regress_rls_bob 6 | fgh_updt | regress_rls_bob 8 | fgh_updt | regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+----------+------------------- 2 | bcd_updt | regress_rls_bob 3 | cde | regress_rls_carol 4 | def_updt | regress_rls_carol 6 | fgh_updt | regress_rls_bob 7 | fgh | regress_rls_carol 8 | fgh_updt | regress_rls_carol UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde NOTICE: f_leak => bcd_updt NOTICE: f_leak => def_updt NOTICE: f_leak => fgh NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol DELETE FROM x1 WHERE f_leak(b) RETURNING *; NOTICE: f_leak => cde_updt NOTICE: f_leak => bcd_updt_updt NOTICE: f_leak => def_updt_updt NOTICE: f_leak => fgh_updt NOTICE: f_leak => fgh_updt_updt NOTICE: f_leak => fgh_updt_updt a | b | c ---+---------------+------------------- 3 | cde_updt | regress_rls_carol 2 | bcd_updt_updt | regress_rls_bob 4 | def_updt_updt | regress_rls_carol 7 | fgh_updt | regress_rls_carol 6 | fgh_updt_updt | regress_rls_bob 8 | fgh_updt_updt | regress_rls_carol -- -- Duplicate Policy Names -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE y1 (a int, b text); SELECT public.create_hypertable('y1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (12,regress_rls_schema,y1,t) INSERT INTO y1 VALUES(1,2); CREATE TABLE y2 (a int, b text); SELECT public.create_hypertable('y2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (13,regress_rls_schema,y2,t) GRANT ALL ON y1, y2 TO regress_rls_bob; CREATE POLICY p1 ON y1 FOR ALL USING (a % 2 = 0); CREATE POLICY p2 ON y1 FOR SELECT USING (a > 2); CREATE POLICY p1 ON y1 FOR SELECT USING (a % 2 = 1); --fail ERROR: policy "p1" for table "y1" already exists CREATE POLICY p1 ON y2 FOR ALL USING (a % 2 = 0); --OK ALTER TABLE y1 ENABLE ROW LEVEL SECURITY; ALTER TABLE y2 ENABLE ROW LEVEL SECURITY; -- -- Expression structure with SBV -- -- Create view as table owner. RLS should NOT be applied. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: (f_leak(b) AND (a = 1)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: f_leak(b) DROP VIEW rls_sbv; -- Create view as role that does not own table. RLS should be applied. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y1 Chunks excluded during startup: 0 -> Seq Scan on y1 y1_1 Filter: ((a = 1) AND ((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) -> Index Scan using _hyper_12_57_chunk_y1_a_idx on _hyper_12_57_chunk y1_2 Index Cond: (a = 1) Filter: (((a > 2) OR ((a % 2) = 0)) AND f_leak(b)) DROP VIEW rls_sbv; -- -- Expression structure -- SET SESSION AUTHORIZATION regress_rls_alice; INSERT INTO y2 (SELECT x, md5(x::text) FROM generate_series(0,20) x); CREATE POLICY p2 ON y2 USING (a % 3 = 0); CREATE POLICY p3 ON y2 USING (a % 4 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM y2 WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak(b); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -- -- Qual push-down of leaky functions, when not referring to table -- SELECT * FROM y2 WHERE f_leak('abc'); NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc NOTICE: f_leak => abc a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak('abc'); --- QUERY PLAN --- Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (f_leak('abc'::text) AND (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0))) CREATE TABLE test_qual_pushdown ( abc text ); INSERT INTO test_qual_pushdown VALUES ('abc'),('def'); SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); NOTICE: f_leak => abc NOTICE: f_leak => def a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); --- QUERY PLAN --- Hash Join Hash Cond: (y2.b = test_qual_pushdown.abc) -> Append -> Seq Scan on y2 y2_1 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: (((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) -> Hash -> Seq Scan on test_qual_pushdown Filter: f_leak(abc) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => eccbc87e4b5ce2fe28308fd9f2a7baf3 NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => 45c48cce2e2d7fbdea1afc51c7c6ad26 NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => 9bf31c7ff062936a96d3c8bd1f8f2ff3 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b | abc ---+---+----- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); --- QUERY PLAN --- Hash Join Hash Cond: (test_qual_pushdown.abc = y2.b) -> Seq Scan on test_qual_pushdown -> Hash -> Custom Scan (ChunkAppend) on y2 Chunks excluded during startup: 0 -> Seq Scan on y2 y2_1 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_58_chunk y2_2 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_59_chunk y2_3 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_60_chunk y2_4 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_61_chunk y2_5 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_62_chunk y2_6 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_63_chunk y2_7 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_64_chunk y2_8 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_65_chunk y2_9 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_66_chunk y2_10 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_67_chunk y2_11 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) -> Seq Scan on _hyper_13_68_chunk y2_12 Filter: ((((a % 4) = 0) OR ((a % 3) = 0) OR ((a % 2) = 0)) AND f_leak(b)) DROP TABLE test_qual_pushdown; -- -- Plancache invalidate on user change. -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP TABLE t1 CASCADE; NOTICE: drop cascades to 2 other objects \set VERBOSITY default CREATE TABLE t1 (a integer); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (14,regress_rls_schema,t1,t) GRANT SELECT ON t1 TO regress_rls_bob, regress_rls_carol; CREATE POLICY p1 ON t1 TO regress_rls_bob USING ((a % 2) = 0); CREATE POLICY p2 ON t1 TO regress_rls_carol USING ((a % 4) = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; -- Prepare as regress_rls_bob SET ROLE regress_rls_bob; PREPARE role_inval AS SELECT * FROM t1; -- Check plan EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- Change to regress_rls_carol SET ROLE regress_rls_carol; -- Check plan- should be different EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 4) = 0) -- Change back to regress_rls_bob SET ROLE regress_rls_bob; -- Check plan- should be back to original EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; --- QUERY PLAN --- Seq Scan on t1 Filter: ((a % 2) = 0) -- -- CTE and RLS -- RESET SESSION AUTHORIZATION; DROP TABLE t1 CASCADE; CREATE TABLE t1 (a integer, b text); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (15,regress_rls_schema,t1,t) CREATE POLICY p1 ON t1 USING (a % 2 = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON t1 TO regress_rls_bob; INSERT INTO t1 (SELECT x, md5(x::text) FROM generate_series(0,20) x); SET SESSION AUTHORIZATION regress_rls_bob; WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; NOTICE: f_leak => cfcd208495d565ef66e7dff9f98764da NOTICE: f_leak => c81e728d9d4c2f636f067f89cc14862c NOTICE: f_leak => a87ff679a2f3e71d9181a67b7542122c NOTICE: f_leak => 1679091c5a880faf6fb5e6087eb1b2dc NOTICE: f_leak => c9f0f895fb98ab9159f51fd0297e236d NOTICE: f_leak => d3d9446802a44259755d38e6d163e820 NOTICE: f_leak => c20ad4d76fe97759aa27a0c99bff6710 NOTICE: f_leak => aab3238922bcc25a6f606eb525ffdc56 NOTICE: f_leak => c74d97b01eae257e44aa9d5bade97baf NOTICE: f_leak => 6f4922f45568161a8cdf4ad2299f6d23 NOTICE: f_leak => 98f13708210194c475687be6106a3b84 a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 EXPLAIN (BUFFERS OFF, COSTS OFF) WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; --- QUERY PLAN --- CTE Scan on cte1 CTE cte1 -> Custom Scan (ChunkAppend) on t1 Chunks excluded during startup: 0 -> Seq Scan on t1 t1_1 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: (((a % 2) = 0) AND f_leak(b)) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: (((a % 2) = 0) AND f_leak(b)) WITH cte1 AS (UPDATE t1 SET a = a + 1 RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (UPDATE t1 SET a = a RETURNING *) SELECT * FROM cte1; --ok a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 WITH cte1 AS (INSERT INTO t1 VALUES (21, 'Fail') RETURNING *) SELECT * FROM cte1; --fail ERROR: new row violates row-level security policy for table "t1" WITH cte1 AS (INSERT INTO t1 VALUES (20, 'Success') RETURNING *) SELECT * FROM cte1; --ok a | b ----+--------- 20 | Success -- -- Rename Policy -- RESET SESSION AUTHORIZATION; ALTER POLICY p1 ON t1 RENAME TO p1; --fail ERROR: policy "p1" for table "t1" already exists SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p1 | t1 ALTER POLICY p1 ON t1 RENAME TO p2; --ok SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; polname | relname ---------+--------- p2 | t1 -- -- Check INSERT SELECT -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE TABLE t2 (a integer, b text); SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (16,regress_rls_schema,t2,t) INSERT INTO t2 (SELECT * FROM t1); EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO t2 (SELECT * FROM t1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on t2 -> Append -> Seq Scan on t1 t1_1 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_69_chunk t1_2 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_70_chunk t1_3 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_71_chunk t1_4 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_72_chunk t1_5 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_73_chunk t1_6 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_74_chunk t1_7 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_75_chunk t1_8 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_76_chunk t1_9 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_77_chunk t1_10 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_78_chunk t1_11 Filter: ((a % 2) = 0) -> Seq Scan on _hyper_15_79_chunk t1_12 Filter: ((a % 2) = 0) SELECT * FROM t2; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t2; --- QUERY PLAN --- Append -> Seq Scan on t2 t2_1 -> Seq Scan on _hyper_16_80_chunk t2_2 -> Seq Scan on _hyper_16_81_chunk t2_3 -> Seq Scan on _hyper_16_82_chunk t2_4 -> Seq Scan on _hyper_16_83_chunk t2_5 -> Seq Scan on _hyper_16_84_chunk t2_6 -> Seq Scan on _hyper_16_85_chunk t2_7 -> Seq Scan on _hyper_16_86_chunk t2_8 -> Seq Scan on _hyper_16_87_chunk t2_9 -> Seq Scan on _hyper_16_88_chunk t2_10 -> Seq Scan on _hyper_16_89_chunk t2_11 -> Seq Scan on _hyper_16_90_chunk t2_12 CREATE TABLE t3 AS SELECT * FROM t1; SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); ERROR: table "t2" is already a hypertable SELECT * FROM t3; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success SELECT * INTO t4 FROM t1; SELECT * FROM t4; a | b ----+---------------------------------- 0 | cfcd208495d565ef66e7dff9f98764da 2 | c81e728d9d4c2f636f067f89cc14862c 4 | a87ff679a2f3e71d9181a67b7542122c 6 | 1679091c5a880faf6fb5e6087eb1b2dc 8 | c9f0f895fb98ab9159f51fd0297e236d 10 | d3d9446802a44259755d38e6d163e820 12 | c20ad4d76fe97759aa27a0c99bff6710 14 | aab3238922bcc25a6f606eb525ffdc56 16 | c74d97b01eae257e44aa9d5bade97baf 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success -- -- RLS with JOIN -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE blog (id integer, author text, post text); SELECT public.create_hypertable('blog', 'id', chunk_time_interval=>2); create_hypertable -------------------------------- (17,regress_rls_schema,blog,t) CREATE TABLE comment (blog_id integer, message text); SELECT public.create_hypertable('comment', 'blog_id', chunk_time_interval=>2); create_hypertable ----------------------------------- (18,regress_rls_schema,comment,t) GRANT ALL ON blog, comment TO regress_rls_bob; CREATE POLICY blog_1 ON blog USING (id % 2 = 0); ALTER TABLE blog ENABLE ROW LEVEL SECURITY; INSERT INTO blog VALUES (1, 'alice', 'blog #1'), (2, 'bob', 'blog #1'), (3, 'alice', 'blog #2'), (4, 'alice', 'blog #3'), (5, 'john', 'blog #1'); INSERT INTO comment VALUES (1, 'cool blog'), (1, 'fun blog'), (3, 'crazy blog'), (5, 'what?'), (4, 'insane!'), (2, 'who did it?'); SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN with Non-RLS. SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! -- Check Non-RLS JOIN with RLS. SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? 4 | alice | insane! SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY comment_1 ON comment USING (blog_id < 4); ALTER TABLE comment ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN RLS SELECT id, author, message FROM blog JOIN comment ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SELECT id, author, message FROM comment JOIN blog ON id = blog_id; id | author | message ----+--------+------------- 2 | bob | who did it? SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE blog; DROP TABLE comment; -- -- Default Deny Policy -- RESET SESSION AUTHORIZATION; DROP POLICY p2 ON t1; ALTER TABLE t1 OWNER TO regress_rls_alice; -- Check that default deny does not apply to superuser. RESET SESSION AUTHORIZATION; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny does not apply to table owner. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM t1; a | b ----+---------------------------------- 1 | c4ca4238a0b923820dcc509a6f75849b 0 | cfcd208495d565ef66e7dff9f98764da 3 | eccbc87e4b5ce2fe28308fd9f2a7baf3 2 | c81e728d9d4c2f636f067f89cc14862c 5 | e4da3b7fbbce2345d7772b0674a318d5 4 | a87ff679a2f3e71d9181a67b7542122c 7 | 8f14e45fceea167a5a36dedd4bea2543 6 | 1679091c5a880faf6fb5e6087eb1b2dc 9 | 45c48cce2e2d7fbdea1afc51c7c6ad26 8 | c9f0f895fb98ab9159f51fd0297e236d 11 | 6512bd43d9caa6e02c990b0a82652dca 10 | d3d9446802a44259755d38e6d163e820 13 | c51ce410c124a10e0db5e4b97fc2af39 12 | c20ad4d76fe97759aa27a0c99bff6710 15 | 9bf31c7ff062936a96d3c8bd1f8f2ff3 14 | aab3238922bcc25a6f606eb525ffdc56 17 | 70efdf2ec9b086079795c442636b55fb 16 | c74d97b01eae257e44aa9d5bade97baf 19 | 1f0e3dad99908345f7439f8ffabdffc4 18 | 6f4922f45568161a8cdf4ad2299f6d23 20 | 98f13708210194c475687be6106a3b84 20 | Success EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Append -> Seq Scan on t1 t1_1 -> Seq Scan on _hyper_15_69_chunk t1_2 -> Seq Scan on _hyper_15_70_chunk t1_3 -> Seq Scan on _hyper_15_71_chunk t1_4 -> Seq Scan on _hyper_15_72_chunk t1_5 -> Seq Scan on _hyper_15_73_chunk t1_6 -> Seq Scan on _hyper_15_74_chunk t1_7 -> Seq Scan on _hyper_15_75_chunk t1_8 -> Seq Scan on _hyper_15_76_chunk t1_9 -> Seq Scan on _hyper_15_77_chunk t1_10 -> Seq Scan on _hyper_15_78_chunk t1_11 -> Seq Scan on _hyper_15_79_chunk t1_12 -- Check that default deny applies to non-owner/non-superuser when RLS on. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; a | b ---+--- EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; --- QUERY PLAN --- Result One-Time Filter: false -- -- COPY TO/FROM -- RESET SESSION AUTHORIZATION; DROP TABLE copy_t CASCADE; ERROR: table "copy_t" does not exist CREATE TABLE copy_t (a integer, b text); SELECT public.create_hypertable('copy_t', 'a', chunk_time_interval=>2); create_hypertable ---------------------------------- (19,regress_rls_schema,copy_t,t) CREATE POLICY p1 ON copy_t USING (a % 2 = 0); ALTER TABLE copy_t ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_t TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_t (SELECT x, md5(x::text) FROM generate_series(0,10) x); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 2,c81e728d9d4c2f636f067f89cc14862c 4,a87ff679a2f3e71d9181a67b7542122c 6,1679091c5a880faf6fb5e6087eb1b2dc 8,c9f0f895fb98ab9159f51fd0297e236d 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok 0,cfcd208495d565ef66e7dff9f98764da 1,c4ca4238a0b923820dcc509a6f75849b 2,c81e728d9d4c2f636f067f89cc14862c 3,eccbc87e4b5ce2fe28308fd9f2a7baf3 4,a87ff679a2f3e71d9181a67b7542122c 5,e4da3b7fbbce2345d7772b0674a318d5 6,1679091c5a880faf6fb5e6087eb1b2dc 7,8f14e45fceea167a5a36dedd4bea2543 8,c9f0f895fb98ab9159f51fd0297e236d 9,45c48cce2e2d7fbdea1afc51c7c6ad26 10,d3d9446802a44259755d38e6d163e820 -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_t -- Check COPY relation TO; keep it just one row to avoid reordering issues RESET SESSION AUTHORIZATION; SET row_security TO ON; CREATE TABLE copy_rel_to (a integer, b text); SELECT public.create_hypertable('copy_rel_to', 'a', chunk_time_interval=>2); create_hypertable --------------------------------------- (20,regress_rls_schema,copy_rel_to,t) CREATE POLICY p1 ON copy_rel_to USING (a % 2 = 0); ALTER TABLE copy_rel_to ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_rel_to TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_rel_to VALUES (1, md5('1')); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok 1,c4ca4238a0b923820dcc509a6f75849b -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: query would be affected by row-level security policy for table "copy_rel_to" SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied ERROR: permission denied for table copy_rel_to -- Check COPY FROM as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY copy_t FROM STDIN; --ok SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - would be affected by RLS. ERROR: query would be affected by row-level security policy for table "copy_t" SET row_security TO ON; COPY copy_t FROM STDIN; --fail - COPY FROM not supported by RLS. ERROR: COPY FROM not supported with row-level security HINT: Use INSERT statements instead. -- Check COPY FROM as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO ON; COPY copy_t FROM STDIN; --ok -- Check COPY FROM as user without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t SET row_security TO ON; COPY copy_t FROM STDIN; --fail - permission denied. ERROR: permission denied for table copy_t RESET SESSION AUTHORIZATION; DROP TABLE copy_t; DROP TABLE copy_rel_to CASCADE; -- Check WHERE CURRENT OF SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE current_check (currentid int, payload text, rlsuser text); SELECT public.create_hypertable('current_check', 'currentid', chunk_time_interval=>10); create_hypertable ----------------------------------------- (21,regress_rls_schema,current_check,t) GRANT ALL ON current_check TO PUBLIC; INSERT INTO current_check VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_bob'), (4, 'def', 'regress_rls_bob'); CREATE POLICY p1 ON current_check FOR SELECT USING (currentid % 2 = 0); CREATE POLICY p2 ON current_check FOR DELETE USING (currentid = 4 AND rlsuser = current_user); CREATE POLICY p3 ON current_check FOR UPDATE USING (currentid = 4) WITH CHECK (rlsuser = current_user); ALTER TABLE current_check ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Can SELECT even rows SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def | regress_rls_bob -- Cannot UPDATE row 2 UPDATE current_check SET payload = payload || '_new' WHERE currentid = 2 RETURNING *; currentid | payload | rlsuser -----------+---------+--------- BEGIN; -- WHERE CURRENT OF does not work with custom scan nodes -- so we have to disable chunk append here SET timescaledb.enable_chunk_append TO false; DECLARE current_check_cursor SCROLL CURSOR FOR SELECT * FROM current_check; -- Returns rows that can be seen according to SELECT policy, like plain SELECT -- above (even rows) FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob -- Still cannot UPDATE row 2 through cursor UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- -- Can update row 4 through cursor, which is the next visible row FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob 4 | def_new | regress_rls_bob -- Plan should be a subquery TID scan EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE current_check SET payload = payload WHERE CURRENT OF current_check_cursor; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on current_check Update on _hyper_21_104_chunk current_check_1 -> Tid Scan on _hyper_21_104_chunk current_check_1 TID Cond: CURRENT OF current_check_cursor Filter: ((currentid = 4) AND ((currentid % 2) = 0)) -- Similarly can only delete row 4 FETCH ABSOLUTE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+--------- FETCH RELATIVE 1 FROM current_check_cursor; currentid | payload | rlsuser -----------+---------+----------------- 4 | def | regress_rls_bob DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; currentid | payload | rlsuser -----------+---------+----------------- 4 | def_new | regress_rls_bob SELECT * FROM current_check; currentid | payload | rlsuser -----------+---------+----------------- 2 | bcd | regress_rls_bob RESET timescaledb.enable_chunk_append; COMMIT; -- -- check pg_stats view filtering -- SET row_security TO ON; SET SESSION AUTHORIZATION regress_rls_alice; ANALYZE current_check; -- Stats visible SELECT row_security_active('current_check'); row_security_active --------------------- f SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals -----------+------------------- currentid | payload | rlsuser | {regress_rls_bob} SET SESSION AUTHORIZATION regress_rls_bob; -- Stats not visible SELECT row_security_active('current_check'); row_security_active --------------------- t SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; attname | most_common_vals ---------+------------------ -- -- Collation support -- BEGIN; CREATE TABLE coll_t (c) AS VALUES ('bar'::text); CREATE POLICY coll_p ON coll_t USING (c < ('foo'::text COLLATE "C")); ALTER TABLE coll_t ENABLE ROW LEVEL SECURITY; GRANT SELECT ON coll_t TO regress_rls_alice; SELECT (string_to_array(polqual, ':'))[7] AS inputcollid FROM pg_policy WHERE polrelid = 'coll_t'::regclass; inputcollid ------------------ inputcollid 950 SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM coll_t; c ----- bar ROLLBACK; -- -- Shared Object Dependencies -- RESET SESSION AUTHORIZATION; BEGIN; CREATE ROLE regress_rls_eve; CREATE ROLE regress_rls_frank; CREATE TABLE tbl1 (c) AS VALUES ('bar'::text); GRANT SELECT ON TABLE tbl1 TO regress_rls_eve; CREATE POLICY P ON tbl1 TO regress_rls_eve, regress_rls_frank USING (true); SELECT refclassid::regclass, deptype FROM pg_depend WHERE classid = 'pg_policy'::regclass AND refobjid = 'tbl1'::regclass; refclassid | deptype ------------+--------- pg_class | a SELECT refclassid::regclass, deptype FROM pg_shdepend WHERE classid = 'pg_policy'::regclass AND refobjid IN ('regress_rls_eve'::regrole, 'regress_rls_frank'::regrole); refclassid | deptype ------------+--------- pg_authid | r pg_authid | r SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on POLICY p ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 target of policy p on table tbl1 ROLLBACK TO q; ALTER POLICY p ON tbl1 TO regress_rls_frank USING (true); SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on GRANT SELECT ERROR: role "regress_rls_eve" cannot be dropped because some objects depend on it DETAIL: privileges for table tbl1 ROLLBACK TO q; REVOKE ALL ON TABLE tbl1 FROM regress_rls_eve; SAVEPOINT q; DROP ROLE regress_rls_eve; --succeeds ROLLBACK TO q; SAVEPOINT q; DROP ROLE regress_rls_frank; --fails due to dependency on POLICY p ERROR: role "regress_rls_frank" cannot be dropped because some objects depend on it DETAIL: target of policy p on table tbl1 ROLLBACK TO q; DROP POLICY p ON tbl1; SAVEPOINT q; DROP ROLE regress_rls_frank; -- succeeds ROLLBACK TO q; ROLLBACK; -- cleanup -- -- Converting table to view -- BEGIN; CREATE TABLE t (c int); SELECT public.create_hypertable('t', 'c', chunk_time_interval=>2); create_hypertable ----------------------------- (22,regress_rls_schema,t,t) CREATE POLICY p ON t USING (c % 2 = 1); ALTER TABLE t ENABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to row level security enabled ERROR: hypertables do not support rules ROLLBACK TO q; ALTER TABLE t DISABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to policy p on t ERROR: hypertables do not support rules ROLLBACK TO q; DROP POLICY p ON t; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- succeeds ERROR: hypertables do not support rules ROLLBACK; -- -- Policy expression handling -- BEGIN; CREATE TABLE t (c) AS VALUES ('bar'::text); CREATE POLICY p ON t USING (max(c)); -- fails: aggregate functions are not allowed in policy expressions ERROR: aggregate functions are not allowed in policy expressions ROLLBACK; -- -- Non-target relations are only subject to SELECT policies -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (23,regress_rls_schema,r1,t) CREATE TABLE r2 (a int); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (24,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); GRANT ALL ON r1, r2 TO regress_rls_bob; CREATE POLICY p1 ON r1 USING (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON r2 FOR SELECT USING (true); CREATE POLICY p2 ON r2 FOR INSERT WITH CHECK (false); CREATE POLICY p3 ON r2 FOR UPDATE USING (false); CREATE POLICY p4 ON r2 FOR DELETE USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM r1; a ---- 10 20 SELECT * FROM r2; a ---- 10 20 -- r2 is read-only INSERT INTO r2 VALUES (2); -- Not allowed ERROR: new row violates row-level security policy for table "r2" \pset tuples_only 1 UPDATE r2 SET a = 2 RETURNING *; -- Updates nothing DELETE FROM r2 RETURNING *; -- Deletes nothing \pset tuples_only 0 -- r2 can be used as a non-target relation in DML INSERT INTO r1 SELECT a + 1 FROM r2 RETURNING *; -- OK a ---- 11 21 UPDATE r1 SET a = r2.a + 2 FROM r2 WHERE r1.a = r2.a RETURNING *; -- OK ERROR: new row for relation "_hyper_23_105_chunk" violates check constraint "constraint_105" DELETE FROM r1 USING r2 WHERE r1.a = r2.a + 2 RETURNING *; -- OK a | a ---+--- SELECT * FROM r1; a ---- 10 11 20 21 SELECT * FROM r2; a ---- 10 20 SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE r1; DROP TABLE r2; -- -- FORCE ROW LEVEL SECURITY applies RLS to owners too -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (25,regress_rls_schema,r1,t) INSERT INTO r1 VALUES (10), (20); CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No error, but no rows TABLE r1; a --- -- RLS error INSERT INTO r1 VALUES (1); ERROR: new row violates row-level security policy for table "r1" -- No error (unable to see any rows to update) UPDATE r1 SET a = 1; TABLE r1; a --- -- No error (unable to see any rows to delete) DELETE FROM r1; TABLE r1; a --- SET row_security = off; -- these all fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. UPDATE r1 SET a = 1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DELETE FROM r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. DROP TABLE r1; -- -- FORCE ROW LEVEL SECURITY does not break RI -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (26,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Errors due to rows in r2 DELETE FROM r1; ERROR: update or delete on table "r1" violates foreign key constraint "r2_a_fkey" on table "r2" DETAIL: Key (a)=(10) is still referenced from table "r2". -- Reset r2 to no-RLS DROP POLICY p1 ON r2; ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; ALTER TABLE r2 DISABLE ROW LEVEL SECURITY; -- clean out r2 for INSERT test below DELETE FROM r2; -- Change r1 to not allow rows to be seen CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No rows seen TABLE r1; a --- -- No error, RI still sees that row exists in r1 INSERT INTO r2 VALUES (10); DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded DELETE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON DELETE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (27,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Deletes all records from both DELETE FROM r1; -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify no rows in r2 now TABLE r2; a --- DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded UPDATE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON UPDATE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (28,regress_rls_schema,r2,t) INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Updates records in both (terse output to not print CONTEXT, which can be different). \set VERBOSITY terse UPDATE r1 SET a = a+5; ERROR: new row for relation "_hyper_28_117_chunk" violates check constraint "constraint_117" \set VERBOSITY default -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify records in r2 updated TABLE r2; a ---- 10 20 DROP TABLE r2; DROP TABLE r1; -- -- Test INSERT+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); create_hypertable ------------------------------ (29,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (false); CREATE POLICY p2 ON r1 FOR INSERT WITH CHECK (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine INSERT INTO r1 VALUES (10), (20); -- No error, but no rows TABLE r1; a --- SET row_security = off; -- fail, would be affected by RLS TABLE r1; ERROR: query would be affected by row-level security policy for table "r1" HINT: To disable the policy for the table's owner, use ALTER TABLE NO FORCE ROW LEVEL SECURITY. SET row_security = on; -- Error INSERT INTO r1 VALUES (10), (20) RETURNING *; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- -- Test UPDATE+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>100); create_hypertable ------------------------------ (30,regress_rls_schema,r1,t) CREATE POLICY p1 ON r1 FOR SELECT USING (a < 20); CREATE POLICY p2 ON r1 FOR UPDATE USING (a < 20) WITH CHECK (true); CREATE POLICY p3 ON r1 FOR INSERT WITH CHECK (true); INSERT INTO r1 VALUES (10); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine UPDATE r1 SET a = 30; -- Show updated rows ALTER TABLE r1 NO FORCE ROW LEVEL SECURITY; TABLE r1; a ---- 30 -- reset value in r1 for test with RETURNING UPDATE r1 SET a = 10; -- Verify row reset TABLE r1; a ---- 10 ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Error UPDATE r1 SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- UPDATE path of INSERT ... ON CONFLICT DO UPDATE should also error out INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30 RETURNING *; ERROR: new row violates row-level security policy for table "r1" -- Should still error out without RETURNING (use of arbiter always requires -- SELECT permissions) INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" -- ON CONFLICT ON CONSTRAINT INSERT INTO r1 VALUES (10) ON CONFLICT ON CONSTRAINT r1_pkey DO UPDATE SET a = 30; ERROR: new row violates row-level security policy for table "r1" DROP TABLE r1; -- Check dependency handling RESET SESSION AUTHORIZATION; CREATE TABLE dep1 (c1 int); SELECT public.create_hypertable('dep1', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (31,regress_rls_schema,dep1,t) CREATE TABLE dep2 (c1 int); SELECT public.create_hypertable('dep2', 'c1', chunk_time_interval=>2); create_hypertable -------------------------------- (32,regress_rls_schema,dep2,t) CREATE POLICY dep_p1 ON dep1 TO regress_rls_bob USING (c1 > (select max(dep2.c1) from dep2)); ALTER POLICY dep_p1 ON dep1 TO regress_rls_bob,regress_rls_carol; -- Should return one SELECT count(*) = 1 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t ALTER POLICY dep_p1 ON dep1 USING (true); -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_bob'); ?column? ---------- t -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_carol'); ?column? ---------- t -- Should return zero SELECT count(*) = 0 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ?column? ---------- t -- DROP OWNED BY testing RESET SESSION AUTHORIZATION; CREATE ROLE regress_rls_dob_role1; CREATE ROLE regress_rls_dob_role2; CREATE TABLE dob_t1 (c1 int); SELECT public.create_hypertable('dob_t1', 'c1', chunk_time_interval=>2); create_hypertable ---------------------------------- (33,regress_rls_schema,dob_t1,t) CREATE TABLE dob_t2 (c1 int) PARTITION BY RANGE (c1); CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should fail, already gone ERROR: policy "p1" for table "dob_t1" does not exist CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should succeed CREATE POLICY p1 ON dob_t2 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t2; -- should succeed DROP USER regress_rls_dob_role1; DROP USER regress_rls_dob_role2; -- -- Clean up objects -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP SCHEMA regress_rls_schema CASCADE; NOTICE: drop cascades to 116 other objects \set VERBOSITY default DROP USER regress_rls_alice; DROP USER regress_rls_bob; DROP USER regress_rls_carol; DROP USER regress_rls_dave; DROP USER regress_rls_exempt_user; DROP ROLE regress_rls_group1; DROP ROLE regress_rls_group2; -- Arrange to have a few policies left over, for testing -- pg_dump/pg_restore CREATE SCHEMA regress_rls_schema; CREATE TABLE rls_tbl (c1 int); SELECT public.create_hypertable('rls_tbl', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------- (34,regress_rls_schema,rls_tbl,t) ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl USING (c1 > 5); CREATE POLICY p2 ON rls_tbl FOR SELECT USING (c1 <= 3); CREATE POLICY p3 ON rls_tbl FOR UPDATE USING (c1 <= 3) WITH CHECK (c1 > 5); CREATE POLICY p4 ON rls_tbl FOR DELETE USING (c1 <= 3); CREATE TABLE rls_tbl_force (c1 int); SELECT public.create_hypertable('rls_tbl_force', 'c1', chunk_time_interval=>2); create_hypertable ----------------------------------------- (35,regress_rls_schema,rls_tbl_force,t) ALTER TABLE rls_tbl_force ENABLE ROW LEVEL SECURITY; ALTER TABLE rls_tbl_force FORCE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl_force USING (c1 = 5) WITH CHECK (c1 < 5); CREATE POLICY p2 ON rls_tbl_force FOR SELECT USING (c1 = 8); CREATE POLICY p3 ON rls_tbl_force FOR UPDATE USING (c1 = 8) WITH CHECK (c1 >= 5); CREATE POLICY p4 ON rls_tbl_force FOR DELETE USING (c1 = 8); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/size_utils.out�����������������������������������������������������0000664�0000000�0000000�00000124661�15100345067�0021570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+----------------+--------- 1 | public | two_Partitions | t \set QUIET off BEGIN; BEGIN \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COPY 7 COMMIT; COMMIT INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT 0 4 INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); INSERT 0 1 \set QUIET on SELECT * FROM hypertable_detailed_size('"public"."two_Partitions"'); table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 32768 | 475136 | 40960 | 548864 | SELECT * FROM hypertable_index_size('"public"."two_Partitions_device_id_timeCustom_idx"'); hypertable_index_size ----------------------- 73728 SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_device_id_idx"'); hypertable_index_size ----------------------- 73728 SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_idx"'); hypertable_index_size ----------------------- 73728 SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_0_idx"'); hypertable_index_size ----------------------- 73728 SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_1_idx"'); hypertable_index_size ----------------------- 73728 SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_2_idx"'); hypertable_index_size ----------------------- 49152 SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_bool_idx"'); hypertable_index_size ----------------------- 57344 SELECT * FROM chunks_detailed_size('"public"."two_Partitions"') order by chunk_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_1_1_chunk | 8192 | 114688 | 8192 | 131072 | _timescaledb_internal | _hyper_1_2_chunk | 8192 | 106496 | 8192 | 122880 | _timescaledb_internal | _hyper_1_3_chunk | 8192 | 98304 | 8192 | 114688 | _timescaledb_internal | _hyper_1_4_chunk | 8192 | 98304 | 8192 | 114688 | CREATE TABLE timestamp_partitioned(time TIMESTAMP, value TEXT); SELECT * FROM create_hypertable('timestamp_partitioned', 'time', 'value', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------+--------- 2 | public | timestamp_partitioned | t INSERT INTO timestamp_partitioned VALUES('2004-10-19 10:23:54', '10'); INSERT INTO timestamp_partitioned VALUES('2004-12-19 10:23:54', '30'); SELECT * FROM chunks_detailed_size('timestamp_partitioned') order by chunk_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_2_5_chunk | 8192 | 32768 | 8192 | 49152 | _timescaledb_internal | _hyper_2_6_chunk | 8192 | 32768 | 8192 | 49152 | CREATE TABLE timestamp_partitioned_2(time TIMESTAMP, value CHAR(9)); SELECT * FROM create_hypertable('timestamp_partitioned_2', 'time', 'value', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------------+--------- 3 | public | timestamp_partitioned_2 | t INSERT INTO timestamp_partitioned_2 VALUES('2004-10-19 10:23:54', '10'); INSERT INTO timestamp_partitioned_2 VALUES('2004-12-19 10:23:54', '30'); SELECT * FROM chunks_detailed_size('timestamp_partitioned_2') order by chunk_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_3_7_chunk | 8192 | 32768 | 0 | 40960 | _timescaledb_internal | _hyper_3_8_chunk | 8192 | 32768 | 0 | 40960 | CREATE TABLE toast_test(time TIMESTAMP, value TEXT); -- Set storage type to EXTERNAL to prevent PostgreSQL from compressing my -- easily compressable string and instead store it with TOAST ALTER TABLE toast_test ALTER COLUMN value SET STORAGE EXTERNAL; SELECT * FROM create_hypertable('toast_test', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 4 | public | toast_test | t INSERT INTO toast_test VALUES('2004-10-19 10:23:54', $$ this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. $$); SELECT * FROM chunks_detailed_size('toast_test'); chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_4_9_chunk | 8192 | 16384 | 24576 | 49152 | -- -- Tests for approximate_row_count() -- -- Regular table -- CREATE TABLE approx_count(time TIMESTAMP, value int); INSERT INTO approx_count VALUES('2004-01-01 10:00:01', 1); INSERT INTO approx_count VALUES('2004-01-01 10:00:02', 2); INSERT INTO approx_count VALUES('2004-01-01 10:00:03', 3); INSERT INTO approx_count VALUES('2004-01-01 10:00:04', 4); INSERT INTO approx_count VALUES('2004-01-01 10:00:05', 5); INSERT INTO approx_count VALUES('2004-01-01 10:00:06', 6); INSERT INTO approx_count VALUES('2004-01-01 10:00:07', 7); SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 0 ANALYZE approx_count; SELECT count(*) FROM approx_count; count ------- 7 SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 7 DROP TABLE approx_count; -- Regular table with basic inheritance -- CREATE TABLE approx_count(id int); INSERT INTO approx_count VALUES(1); SELECT count(*) FROM approx_count; count ------- 1 SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 0 ANALYZE approx_count; SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 1 CREATE TABLE approx_count_child(id2 int) INHERITS (approx_count); INSERT INTO approx_count_child VALUES(0); SELECT count(*) FROM approx_count; count ------- 2 SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 1 ANALYZE approx_count_child; SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 2 DROP TABLE approx_count CASCADE; NOTICE: drop cascades to table approx_count_child -- Regular table with nested inheritance -- CREATE TABLE approx_count(id int); CREATE TABLE approx_count_a(id2 int) INHERITS (approx_count); CREATE TABLE approx_count_b(id3 int) INHERITS (approx_count_a); CREATE TABLE approx_count_c(id4 int) INHERITS (approx_count_b); INSERT INTO approx_count_a VALUES(0); INSERT INTO approx_count_b VALUES(1); INSERT INTO approx_count_c VALUES(2); INSERT INTO approx_count VALUES(3); SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 0 ANALYZE approx_count_a; ANALYZE approx_count_b; ANALYZE approx_count_c; ANALYZE approx_count; SELECT count(*) FROM approx_count; count ------- 4 SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 4 SELECT count(*) FROM approx_count_a; count ------- 3 SELECT * FROM approximate_row_count('approx_count_a'); approximate_row_count ----------------------- 3 SELECT count(*) FROM approx_count_b; count ------- 2 SELECT * FROM approximate_row_count('approx_count_b'); approximate_row_count ----------------------- 2 SELECT count(*) FROM approx_count_c; count ------- 1 SELECT * FROM approximate_row_count('approx_count_c'); approximate_row_count ----------------------- 1 DROP TABLE approx_count CASCADE; NOTICE: drop cascades to 3 other objects -- table with declarative partitioning -- CREATE TABLE approx_count_dp(time TIMESTAMP, value int) PARTITION BY RANGE(time); CREATE TABLE approx_count_dp0 PARTITION OF approx_count_dp FOR VALUES FROM ('2004-01-01 00:00:00') TO ('2005-01-01 00:00:00'); CREATE TABLE approx_count_dp1 PARTITION OF approx_count_dp FOR VALUES FROM ('2005-01-01 00:00:00') TO ('2006-01-01 00:00:00'); CREATE TABLE approx_count_dp2 PARTITION OF approx_count_dp FOR VALUES FROM ('2006-01-01 00:00:00') TO ('2007-01-01 00:00:00'); INSERT INTO approx_count_dp VALUES('2004-01-01 10:00:00', 1); INSERT INTO approx_count_dp VALUES('2004-01-01 11:00:00', 1); INSERT INTO approx_count_dp VALUES('2004-01-01 12:00:01', 1); INSERT INTO approx_count_dp VALUES('2005-01-01 10:00:00', 1); INSERT INTO approx_count_dp VALUES('2005-01-01 11:00:00', 1); INSERT INTO approx_count_dp VALUES('2005-01-01 12:00:01', 1); INSERT INTO approx_count_dp VALUES('2006-01-01 10:00:00', 1); INSERT INTO approx_count_dp VALUES('2006-01-01 11:00:00', 1); INSERT INTO approx_count_dp VALUES('2006-01-01 12:00:01', 1); SELECT count(*) FROM approx_count_dp; count ------- 9 SELECT count(*) FROM approx_count_dp0; count ------- 3 SELECT count(*) FROM approx_count_dp1; count ------- 3 SELECT count(*) FROM approx_count_dp2; count ------- 3 SELECT * FROM approximate_row_count('approx_count_dp'); approximate_row_count ----------------------- 0 ANALYZE approx_count_dp; SELECT * FROM approximate_row_count('approx_count_dp'); approximate_row_count ----------------------- 9 SELECT * FROM approximate_row_count('approx_count_dp0'); approximate_row_count ----------------------- 3 SELECT * FROM approximate_row_count('approx_count_dp1'); approximate_row_count ----------------------- 3 SELECT * FROM approximate_row_count('approx_count_dp2'); approximate_row_count ----------------------- 3 CREATE TABLE approx_count_dp_nested(time TIMESTAMP, device_id int, value int) PARTITION BY RANGE(time); CREATE TABLE approx_count_dp_nested_0 PARTITION OF approx_count_dp_nested FOR VALUES FROM ('2004-01-01 00:00:00') TO ('2005-01-01 00:00:00') PARTITION BY RANGE (device_id); CREATE TABLE approx_count_dp_nested_0_0 PARTITION OF approx_count_dp_nested_0 FOR VALUES FROM (0) TO (10); CREATE TABLE approx_count_dp_nested_0_1 PARTITION OF approx_count_dp_nested_0 FOR VALUES FROM (10) TO (20); CREATE TABLE approx_count_dp_nested_1 PARTITION OF approx_count_dp_nested FOR VALUES FROM ('2005-01-01 00:00:00') TO ('2006-01-01 00:00:00') PARTITION BY RANGE (device_id); CREATE TABLE approx_count_dp_nested_1_0 PARTITION OF approx_count_dp_nested_1 FOR VALUES FROM (0) TO (10); CREATE TABLE approx_count_dp_nested_1_1 PARTITION OF approx_count_dp_nested_1 FOR VALUES FROM (10) TO (20); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 1, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 2, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 3, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 11, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 12, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 13, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 1, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 2, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 3, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 11, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 12, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 13, 1); SELECT * FROM approximate_row_count('approx_count_dp_nested'); approximate_row_count ----------------------- 0 ANALYZE approx_count_dp_nested; SELECT (SELECT count(*) FROM approx_count_dp_nested) AS dp_nested, (SELECT count(*) FROM approx_count_dp_nested_0) AS dp_nested_0, (SELECT count(*) FROM approx_count_dp_nested_0_0) AS dp_nested_0_0, (SELECT count(*) FROM approx_count_dp_nested_0_1) AS dp_nested_0_1, (SELECT count(*) FROM approx_count_dp_nested_1) AS dp_nested_1, (SELECT count(*) FROM approx_count_dp_nested_1_0) AS dp_nested_1_0, (SELECT count(*) FROM approx_count_dp_nested_1_1) AS dp_nested_1_1 UNION ALL SELECT approximate_row_count('approx_count_dp_nested'), approximate_row_count('approx_count_dp_nested_0'), approximate_row_count('approx_count_dp_nested_0_0'), approximate_row_count('approx_count_dp_nested_0_1'), approximate_row_count('approx_count_dp_nested_1'), approximate_row_count('approx_count_dp_nested_1_0'), approximate_row_count('approx_count_dp_nested_1_1'); dp_nested | dp_nested_0 | dp_nested_0_0 | dp_nested_0_1 | dp_nested_1 | dp_nested_1_0 | dp_nested_1_1 -----------+-------------+---------------+---------------+-------------+---------------+--------------- 12 | 6 | 3 | 3 | 6 | 3 | 3 12 | 6 | 3 | 3 | 6 | 3 | 3 -- Hypertable -- CREATE TABLE approx_count(time TIMESTAMP, value int); SELECT * FROM create_hypertable('approx_count', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 5 | public | approx_count | t INSERT INTO approx_count VALUES('2004-01-01 10:00:01', 1); INSERT INTO approx_count VALUES('2004-01-01 10:00:02', 2); INSERT INTO approx_count VALUES('2004-01-01 10:00:03', 3); INSERT INTO approx_count VALUES('2004-01-01 10:00:04', 4); INSERT INTO approx_count VALUES('2004-01-01 10:00:05', 5); INSERT INTO approx_count VALUES('2004-01-01 10:00:06', 6); INSERT INTO approx_count VALUES('2004-01-01 10:00:07', 7); INSERT INTO approx_count VALUES('2004-01-01 10:00:08', 8); INSERT INTO approx_count VALUES('2004-01-01 10:00:09', 9); INSERT INTO approx_count VALUES('2004-01-01 10:00:10', 10); SELECT count(*) FROM approx_count; count ------- 10 SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 0 ANALYZE approx_count; SELECT * FROM approximate_row_count('approx_count'); approximate_row_count ----------------------- 10 \set ON_ERROR_STOP 0 SELECT * FROM approximate_row_count('unexisting'); ERROR: relation "unexisting" does not exist at character 37 SELECT * FROM approximate_row_count(); ERROR: function approximate_row_count() does not exist at character 15 SELECT * FROM approximate_row_count(NULL); approximate_row_count ----------------------- \set ON_ERROR_STOP 1 -- Test size functions with invalid or non-existing OID SELECT * FROM hypertable_size(0); hypertable_size ----------------- SELECT * FROM hypertable_detailed_size(0) ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- SELECT * FROM chunks_detailed_size(0) ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM hypertable_compression_stats(0) ORDER BY node_name; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM chunk_compression_stats(0) ORDER BY node_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_index_size(0); hypertable_index_size ----------------------- SELECT * FROM _timescaledb_functions.relation_size(0); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ | | | SELECT * FROM hypertable_size(1); hypertable_size ----------------- SELECT * FROM hypertable_detailed_size(1) ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- SELECT * FROM chunks_detailed_size(1) ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM hypertable_compression_stats(1) ORDER BY node_name; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM chunk_compression_stats(1) ORDER BY node_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_index_size(1); hypertable_index_size ----------------------- SELECT * FROM _timescaledb_functions.relation_size(1); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 -- Test size functions with NULL input SELECT * FROM hypertable_size(NULL); hypertable_size ----------------- SELECT * FROM hypertable_detailed_size(NULL) ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- SELECT * FROM chunks_detailed_size(NULL) ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM hypertable_compression_stats(NULL) ORDER BY node_name; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM chunk_compression_stats(NULL) ORDER BY node_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_index_size(NULL); hypertable_index_size ----------------------- SELECT * FROM _timescaledb_functions.relation_size(NULL); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ | | | -- Test approximate size functions with invalid input SELECT * FROM hypertable_approximate_size(0); hypertable_approximate_size ----------------------------- SELECT * FROM hypertable_approximate_detailed_size(0); table_bytes | index_bytes | toast_bytes | total_bytes -------------+-------------+-------------+------------- | | | SELECT * FROM _timescaledb_functions.relation_approximate_size(0); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ | | | SELECT * FROM hypertable_approximate_size(NULL); hypertable_approximate_size ----------------------------- SELECT * FROM hypertable_approximate_detailed_size(NULL); table_bytes | index_bytes | toast_bytes | total_bytes -------------+-------------+-------------+------------- | | | SELECT * FROM _timescaledb_functions.relation_approximate_size(NULL); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ -- Test size on view, sequence and composite type CREATE VIEW view1 as SELECT 1; SELECT * FROM _timescaledb_functions.relation_approximate_size('view1'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 SELECT * FROM _timescaledb_functions.relation_size('view1'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 CREATE SEQUENCE test_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; SELECT * FROM _timescaledb_functions.relation_approximate_size('test_id_seq'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 8192 | 0 | 0 SELECT * FROM _timescaledb_functions.relation_size('test_id_seq'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 8192 | 0 | 0 CREATE TYPE test_type AS (time timestamp, temp float); SELECT * FROM _timescaledb_functions.relation_approximate_size('test_type'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 SELECT * FROM _timescaledb_functions.relation_size('test_type'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 -- Test size functions on regular table CREATE TABLE hypersize(time timestamptz, device int); CREATE INDEX hypersize_time_idx ON hypersize (time); \set ON_ERROR_STOP 0 \set VERBOSITY default \set SHOW_CONTEXT never SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx'); pg_relation_size | pg_table_size | pg_indexes_size | pg_total_relation_size | pg_relation_size ------------------+---------------+-----------------+------------------------+------------------ 0 | 0 | 8192 | 8192 | 8192 SELECT * FROM _timescaledb_functions.relation_size('hypersize'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 0 | 8192 | 0 SELECT * FROM hypertable_size('hypersize'); hypertable_size ----------------- SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM hypertable_compression_stats('hypersize') ORDER BY node_name; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM chunk_compression_stats('hypersize') ORDER BY node_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_index_size('hypersize_time_idx'); hypertable_index_size ----------------------- 8192 SELECT * FROM _timescaledb_functions.relation_approximate_size('hypersize'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 0 | 8192 | 0 SELECT * FROM hypertable_approximate_size('hypersize'); ERROR: "hypersize" is not a hypertable or a continuous aggregate HINT: The operation is only possible on a hypertable or continuous aggregate. SELECT * FROM hypertable_approximate_detailed_size('hypersize'); ERROR: "hypersize" is not a hypertable or a continuous aggregate HINT: The operation is only possible on a hypertable or continuous aggregate. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Test size functions on empty hypertable SELECT * FROM create_hypertable('hypersize', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 6 | public | hypersize | t SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx'); pg_relation_size | pg_table_size | pg_indexes_size | pg_total_relation_size | pg_relation_size ------------------+---------------+-----------------+------------------------+------------------ 0 | 0 | 8192 | 8192 | 8192 SELECT * FROM _timescaledb_functions.relation_size('hypersize'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 0 | 8192 | 0 SELECT * FROM hypertable_size('hypersize'); hypertable_size ----------------- 8192 SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 0 | 8192 | 0 | 8192 | SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM hypertable_compression_stats('hypersize') ORDER BY node_name; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM chunk_compression_stats('hypersize') ORDER BY node_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_index_size('hypersize_time_idx'); hypertable_index_size ----------------------- 8192 SELECT * FROM _timescaledb_functions.relation_approximate_size('hypersize'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 0 | 8192 | 0 SELECT * FROM hypertable_approximate_size('hypersize'); hypertable_approximate_size ----------------------------- 8192 SELECT * FROM hypertable_approximate_detailed_size('hypersize'); table_bytes | index_bytes | toast_bytes | total_bytes -------------+-------------+-------------+------------- 0 | 8192 | 0 | 8192 -- Test size functions on non-empty hypertable INSERT INTO hypersize VALUES('2021-02-25', 1); SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx'); pg_relation_size | pg_table_size | pg_indexes_size | pg_total_relation_size | pg_relation_size ------------------+---------------+-----------------+------------------------+------------------ 0 | 0 | 8192 | 8192 | 8192 SELECT pg_relation_size(ch), pg_table_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch) FROM show_chunks('hypersize') ch ORDER BY ch; pg_relation_size | pg_table_size | pg_indexes_size | pg_total_relation_size ------------------+---------------+-----------------+------------------------ 8192 | 8192 | 16384 | 24576 SELECT * FROM show_chunks('hypersize') ch JOIN LATERAL _timescaledb_functions.relation_size(ch) ON true; ch | total_size | heap_size | index_size | toast_size -----------------------------------------+------------+-----------+------------+------------ _timescaledb_internal._hyper_6_11_chunk | 24576 | 8192 | 16384 | 0 SELECT * FROM hypertable_size('hypersize'); hypertable_size ----------------- 32768 SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 8192 | 24576 | 0 | 32768 | SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+-------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_6_11_chunk | 8192 | 16384 | 0 | 24576 | SELECT * FROM hypertable_compression_stats('hypersize') ORDER BY node_name; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM chunk_compression_stats('hypersize') ORDER BY node_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_index_size('hypersize_time_idx'); hypertable_index_size ----------------------- 24576 SELECT * FROM _timescaledb_functions.relation_approximate_size('hypersize'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 8192 | 0 | 8192 | 0 SELECT * FROM hypertable_approximate_size('hypersize'); hypertable_approximate_size ----------------------------- 32768 SELECT * FROM hypertable_approximate_detailed_size('hypersize'); table_bytes | index_bytes | toast_bytes | total_bytes -------------+-------------+-------------+------------- 8192 | 24576 | 0 | 32768 -- Test approx size functions with toast entries SELECT * FROM _timescaledb_functions.relation_approximate_size('toast_test'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 16384 | 0 | 8192 | 8192 SELECT * FROM hypertable_approximate_size('toast_test'); hypertable_approximate_size ----------------------------- 65536 SELECT * FROM hypertable_approximate_detailed_size('toast_test'); table_bytes | index_bytes | toast_bytes | total_bytes -------------+-------------+-------------+------------- 8192 | 24576 | 32768 | 65536 -- Test approx size function against a regular table \set ON_ERROR_STOP 0 CREATE TABLE regular(time TIMESTAMP, value TEXT); SELECT * FROM hypertable_approximate_size('regular'); ERROR: "regular" is not a hypertable or a continuous aggregate \set ON_ERROR_STOP 1 -- Test approx size functions with dropped chunks CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; SELECT * FROM hypertable_approximate_size('drop_chunks_table'); hypertable_approximate_size ----------------------------- 81920 SELECT drop_chunks('drop_chunks_table', older_than => 19); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_7_12_chunk SELECT * FROM hypertable_approximate_size('drop_chunks_table'); hypertable_approximate_size ----------------------------- 57344 -- github issue #4857 -- below procedure should not crash SET client_min_messages = ERROR; do $$ DECLARE o INT; BEGIN FOR c IN 1..20 LOOP ANALYZE; END LOOP; END; $$; RESET client_min_messages; �������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/sort_optimization.out����������������������������������������������0000664�0000000�0000000�00000010533�15100345067�0023163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF) ' CREATE TABLE order_test(time int NOT NULL, device_id int, value float); CREATE INDEX ON order_test(time,device_id); CREATE INDEX ON order_test(device_id,time); SELECT create_hypertable('order_test','time',chunk_time_interval:=1000); create_hypertable ------------------------- (1,public,order_test,t) INSERT INTO order_test SELECT 0,10,0.5; INSERT INTO order_test SELECT 1,9,0.5; INSERT INTO order_test SELECT 2,8,0.5; -- we want to see here that index scans are possible for the chosen expressions -- so we disable seqscan so we dont need to worry about other factors which would -- make PostgreSQL prefer seqscan over index scan SET enable_seqscan TO off; -- test sort optimization with single member order by SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1; time_bucket | device_id | value -------------+-----------+------- 0 | 10 | 0.5 0 | 9 | 0.5 0 | 8 | 0.5 -- should use index scan :PREFIX SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1; --- QUERY PLAN --- Result -> Index Scan Backward using _hyper_1_1_chunk_order_test_time_idx on _hyper_1_1_chunk -- test sort optimization with ordering by multiple columns and time_bucket not last SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1,2; time_bucket | device_id | value -------------+-----------+------- 0 | 8 | 0.5 0 | 9 | 0.5 0 | 10 | 0.5 SET enable_seqscan TO default; -- must not use index scan :PREFIX SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: (time_bucket(10, _hyper_1_1_chunk."time")), _hyper_1_1_chunk.device_id -> Result -> Seq Scan on _hyper_1_1_chunk SET enable_seqscan TO off; -- test sort optimization with ordering by multiple columns and time_bucket as last member SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 2,1; time_bucket | device_id | value -------------+-----------+------- 0 | 8 | 0.5 0 | 9 | 0.5 0 | 10 | 0.5 -- should use index scan :PREFIX SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 2,1; --- QUERY PLAN --- Result -> Index Scan using _hyper_1_1_chunk_order_test_device_id_time_idx on _hyper_1_1_chunk -- test sort optimization with interval calculation with non-fixed interval -- #7097 CREATE TABLE i7097_1(time timestamptz NOT NULL, quantity float, "isText" boolean); CREATE TABLE i7097_2(time timestamptz NOT NULL, quantity float, "isText" boolean); CREATE INDEX ON i7097_1(time) WHERE "isText" IS NULL; CREATE INDEX ON i7097_2(time) WHERE "isText" IS NULL; SELECT table_name FROM create_hypertable('i7097_1', 'time', create_default_indexes => false); table_name ------------ i7097_1 SELECT table_name FROM create_hypertable('i7097_2', 'time', create_default_indexes => false); table_name ------------ i7097_2 INSERT INTO i7097_1(time, quantity) SELECT time, round((random() * (100-3) + 3)::NUMERIC) AS quantity FROM generate_series('2023-01-01T00:00:00+01:00', '2023-05-01T00:00:00+01:00', interval 'PT10M') AS t(time); INSERT INTO i7097_2(time, quantity) SELECT time, round((random() * (100-3) + 3)::NUMERIC) AS quantity FROM generate_series('2023-01-01T00:00:00+01:00', '2023-05-01T00:00:00+01:00', interval 'PT10M') AS t(time); VACUUM ANALYZE i7097_1, i7097_2; SET TIME ZONE 'Europe/Paris'; WITH "cte1" AS (SELECT time + interval 'P1Y' AS time, avg(quantity) AS quantity FROM i7097_1 WHERE time >= '2024-03-31T00:00:00+01:00'::timestamptz - interval 'P1Y' AND time < '2024-03-31T23:59:59+02:00'::timestamptz + (- interval 'P1Y') AND "isText" IS NULL GROUP BY 1 ORDER BY 1 ASC), "cte2" AS (SELECT time + interval 'P1Y' AS time, avg(quantity) AS quantity FROM i7097_2 WHERE time >= '2024-03-31T00:00:00+01:00'::timestamptz - interval 'P1Y' AND time < '2024-03-31T23:59:59+02:00'::timestamptz + (- interval 'P1Y') AND "isText" IS NULL GROUP BY 1 ORDER BY 1 ASC) SELECT count(*) FROM (SELECT time, cte1.quantity + cte2.quantity FROM cte1 FULL OUTER JOIN cte2 USING (time)) j; count ------- 138 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/sql_query.out������������������������������������������������������0000664�0000000�0000000�00000046414�15100345067�0021421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o SELECT * FROM PUBLIC."two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257894002000000000 | dev1 | 2.5 | 3 | | 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions"; --- QUERY PLAN --- Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.series_0, _hyper_1_1_chunk.series_1, _hyper_1_1_chunk.series_2, _hyper_1_1_chunk.series_bool -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.series_0, _hyper_1_2_chunk.series_1, _hyper_1_2_chunk.series_2, _hyper_1_2_chunk.series_bool -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.series_0, _hyper_1_3_chunk.series_1, _hyper_1_3_chunk.series_2, _hyper_1_3_chunk.series_bool -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool \echo "The following queries should NOT scan two_Partitions._hyper_1_1_chunk" "The following queries should NOT scan two_Partitions._hyper_1_1_chunk" EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions" WHERE device_id = 'dev2'; --- QUERY PLAN --- Index Scan using "_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool Index Cond: (_hyper_1_4_chunk.device_id = 'dev2'::text) EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions" WHERE device_id = 'dev'||'2'; --- QUERY PLAN --- Index Scan using "_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool Index Cond: (_hyper_1_4_chunk.device_id = 'dev2'::text) EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions" WHERE 'dev'||'2' = device_id; --- QUERY PLAN --- Index Scan using "_hyper_1_4_chunk_two_Partitions_device_id_timeCustom_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool Index Cond: (_hyper_1_4_chunk.device_id = 'dev2'::text) --test integer partition key CREATE TABLE "int_part"(time timestamp, object_id int, temp float); SELECT create_hypertable('"int_part"', 'time', 'object_id', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------- (2,public,int_part,t) INSERT INTO "int_part" VALUES('2017-01-20T09:00:01', 1, 22.5); INSERT INTO "int_part" VALUES('2017-01-20T09:00:01', 2, 22.5); --check that there are two chunks SELECT * FROM test.show_subtables('int_part'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_2_5_chunk | _timescaledb_internal._hyper_2_6_chunk | SELECT * FROM "int_part" WHERE object_id = 1; time | object_id | temp --------------------------+-----------+------ Fri Jan 20 09:00:01 2017 | 1 | 22.5 --check that queries with IN/ANY/= work for the "time" column SELECT * FROM "int_part" WHERE time IN (NULL); time | object_id | temp ------+-----------+------ SELECT * FROM "int_part" WHERE time = ANY (NULL); time | object_id | temp ------+-----------+------ SELECT * FROM "int_part" WHERE time = NULL; time | object_id | temp ------+-----------+------ --make sure this touches only one partititon EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM "int_part" WHERE object_id = 1; --- QUERY PLAN --- Index Scan using _hyper_2_5_chunk_int_part_object_id_time_idx on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.object_id, _hyper_2_5_chunk.temp Index Cond: (_hyper_2_5_chunk.object_id = 1) --Need to verify space partitions are currently pruned in this query --EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM "two_Partitions" WHERE device_id IN ('dev2', 'dev21'); \echo "The following shows non-aggregated queries with time desc using merge append" "The following shows non-aggregated queries with time desc using merge append" EXPLAIN (verbose ON, buffers off, costs off)SELECT * FROM PUBLIC."two_Partitions" ORDER BY "timeCustom" DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit Output: "two_Partitions"."timeCustom", "two_Partitions".device_id, "two_Partitions".series_0, "two_Partitions".series_1, "two_Partitions".series_2, "two_Partitions".series_bool -> Custom Scan (ChunkAppend) on public."two_Partitions" Output: "two_Partitions"."timeCustom", "two_Partitions".device_id, "two_Partitions".series_0, "two_Partitions".series_1, "two_Partitions".series_2, "two_Partitions".series_bool Order: "two_Partitions"."timeCustom" DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false -> Index Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.series_0, _hyper_1_3_chunk.series_1, _hyper_1_3_chunk.series_2, _hyper_1_3_chunk.series_bool -> Index Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.series_0, _hyper_1_2_chunk.series_1, _hyper_1_2_chunk.series_2, _hyper_1_2_chunk.series_bool -> Merge Append Sort Key: "two_Partitions"."timeCustom" DESC NULLS LAST -> Index Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool -> Index Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.series_0, _hyper_1_1_chunk.series_1, _hyper_1_1_chunk.series_2, _hyper_1_1_chunk.series_bool --shows that more specific indexes are used if the WHERE clauses "match", uses the series_1 index here. EXPLAIN (verbose ON, buffers off, costs off)SELECT * FROM PUBLIC."two_Partitions" WHERE series_1 IS NOT NULL ORDER BY "timeCustom" DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit Output: "two_Partitions"."timeCustom", "two_Partitions".device_id, "two_Partitions".series_0, "two_Partitions".series_1, "two_Partitions".series_2, "two_Partitions".series_bool -> Custom Scan (ChunkAppend) on public."two_Partitions" Output: "two_Partitions"."timeCustom", "two_Partitions".device_id, "two_Partitions".series_0, "two_Partitions".series_1, "two_Partitions".series_2, "two_Partitions".series_bool Order: "two_Partitions"."timeCustom" DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false -> Index Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.series_0, _hyper_1_3_chunk.series_1, _hyper_1_3_chunk.series_2, _hyper_1_3_chunk.series_bool -> Index Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.series_0, _hyper_1_2_chunk.series_1, _hyper_1_2_chunk.series_2, _hyper_1_2_chunk.series_bool -> Merge Append Sort Key: "two_Partitions"."timeCustom" DESC NULLS LAST -> Index Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool -> Index Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.series_0, _hyper_1_1_chunk.series_1, _hyper_1_1_chunk.series_2, _hyper_1_1_chunk.series_bool --here the "match" is implication series_1 > 1 => series_1 IS NOT NULL EXPLAIN (verbose ON, buffers off, costs off)SELECT * FROM PUBLIC."two_Partitions" WHERE series_1 > 1 ORDER BY "timeCustom" DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit Output: "two_Partitions"."timeCustom", "two_Partitions".device_id, "two_Partitions".series_0, "two_Partitions".series_1, "two_Partitions".series_2, "two_Partitions".series_bool -> Custom Scan (ChunkAppend) on public."two_Partitions" Output: "two_Partitions"."timeCustom", "two_Partitions".device_id, "two_Partitions".series_0, "two_Partitions".series_1, "two_Partitions".series_2, "two_Partitions".series_bool Order: "two_Partitions"."timeCustom" DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false -> Index Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.series_0, _hyper_1_3_chunk.series_1, _hyper_1_3_chunk.series_2, _hyper_1_3_chunk.series_bool Index Cond: (_hyper_1_3_chunk.series_1 > '1'::double precision) -> Index Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.series_0, _hyper_1_2_chunk.series_1, _hyper_1_2_chunk.series_2, _hyper_1_2_chunk.series_bool Index Cond: (_hyper_1_2_chunk.series_1 > '1'::double precision) -> Merge Append Sort Key: "two_Partitions"."timeCustom" DESC NULLS LAST -> Index Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.series_0, _hyper_1_4_chunk.series_1, _hyper_1_4_chunk.series_2, _hyper_1_4_chunk.series_bool Index Cond: (_hyper_1_4_chunk.series_1 > '1'::double precision) -> Index Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_series_1_idx" on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.series_0, _hyper_1_1_chunk.series_1, _hyper_1_1_chunk.series_2, _hyper_1_1_chunk.series_bool Index Cond: (_hyper_1_1_chunk.series_1 > '1'::double precision) --note that without time transform things work too EXPLAIN (verbose ON, buffers off, costs off)SELECT "timeCustom" t, min(series_0) FROM PUBLIC."two_Partitions" GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit Output: "two_Partitions"."timeCustom", (min("two_Partitions".series_0)) -> GroupAggregate Output: "two_Partitions"."timeCustom", min("two_Partitions".series_0) Group Key: "two_Partitions"."timeCustom" -> Custom Scan (ChunkAppend) on public."two_Partitions" Output: "two_Partitions"."timeCustom", "two_Partitions".series_0 Order: "two_Partitions"."timeCustom" DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false -> Index Scan using "_hyper_1_3_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.series_0 -> Index Scan using "_hyper_1_2_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.series_0 -> Merge Append Sort Key: "two_Partitions"."timeCustom" DESC NULLS LAST -> Index Scan using "_hyper_1_4_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.series_0 -> Index Scan using "_hyper_1_1_chunk_two_Partitions_timeCustom_device_id_idx" on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.series_0 --The query should still use the index on timeCustom, even though the GROUP BY/ORDER BY is on the transformed time 't'. --However, current query plans show that it does not. EXPLAIN (verbose ON, buffers off, costs off)SELECT "timeCustom"/10 t, min(series_0) FROM PUBLIC."two_Partitions" GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit Output: (("two_Partitions"."timeCustom" / 10)), (min("two_Partitions".series_0)) -> Sort Output: (("two_Partitions"."timeCustom" / 10)), (min("two_Partitions".series_0)) Sort Key: (("two_Partitions"."timeCustom" / 10)) DESC NULLS LAST -> HashAggregate Output: (("two_Partitions"."timeCustom" / 10)), min("two_Partitions".series_0) Group Key: ("two_Partitions"."timeCustom" / 10) -> Result Output: ("two_Partitions"."timeCustom" / 10), "two_Partitions".series_0 -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.series_0 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.series_0 -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.series_0 -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.series_0 EXPLAIN (verbose ON, buffers off, costs off)SELECT "timeCustom"%10 t, min(series_0) FROM PUBLIC."two_Partitions" GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit Output: (("two_Partitions"."timeCustom" % '10'::bigint)), (min("two_Partitions".series_0)) -> Sort Output: (("two_Partitions"."timeCustom" % '10'::bigint)), (min("two_Partitions".series_0)) Sort Key: (("two_Partitions"."timeCustom" % '10'::bigint)) DESC NULLS LAST -> HashAggregate Output: (("two_Partitions"."timeCustom" % '10'::bigint)), min("two_Partitions".series_0) Group Key: ("two_Partitions"."timeCustom" % '10'::bigint) -> Result Output: ("two_Partitions"."timeCustom" % '10'::bigint), "two_Partitions".series_0 -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."timeCustom", _hyper_1_1_chunk.series_0 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."timeCustom", _hyper_1_2_chunk.series_0 -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."timeCustom", _hyper_1_3_chunk.series_0 -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."timeCustom", _hyper_1_4_chunk.series_0 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/symbol_conflict.out������������������������������������������������0000664�0000000�0000000�00000002072�15100345067�0022553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Test for symbol conflicts between the loader module and the -- versioned extension module. -- This test fails on, e.g. Linux, unless compiled with -fvisibility=hidden CREATE OR REPLACE FUNCTION hello_loader() RETURNS TEXT AS 'timescaledb', 'loader_hello' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; SELECT hello_loader(); hello_loader ------------------- hello from loader CREATE OR REPLACE FUNCTION hello_timescaledb() RETURNS TEXT AS :MODULE_PATHNAME, 'timescaledb_hello' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- This calls an internal function with a conflicting name in the loader SELECT hello_loader(); hello_loader ------------------- hello from loader -- This calls the identically named internal function in the versioned extension SELECT hello_timescaledb(); hello_timescaledb ------------------------ hello from timescaledb ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/tableam.out��������������������������������������������������������0000664�0000000�0000000�00000002300�15100345067�0020764�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test support for setting table access method on hypertables \c :TEST_DBNAME :ROLE_SUPERUSER -- create a new access method that reuses the heap handler CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE testam (time timestamptz, device int, temp float) USING testam; SELECT create_hypertable('testam', 'time', 'device', 2); create_hypertable --------------------- (1,public,testam,t) -- show that the hypertable is using the 'testam' table access method SELECT amname AS hypertable_amname FROM pg_class cl, pg_am am WHERE cl.oid = 'testam'::regclass AND cl.relam = am.oid; hypertable_amname ------------------- testam -- insert data to create a chunk INSERT INTO testam VALUES('2020-01-22:11:30', 1, 29.3); -- make sure the table access method for a chunk is the same as the -- hypertable root SELECT amname AS chunk_amname FROM pg_class cl, pg_am am, show_chunks('testam') ch WHERE cl.oid = ch AND cl.relam = am.oid; chunk_amname -------------- testam ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/tableam_alter.out��������������������������������������������������0000664�0000000�0000000�00000005340�15100345067�0022162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test support for setting table access method on hypertables using -- ALTER TABLE. It should propagate to the chunks. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE VIEW chunk_info AS SELECT hypertable_name AS hypertable, chunk_name AS chunk, amname FROM timescaledb_information.chunks ch JOIN pg_class cl ON (format('%I.%I', ch.chunk_schema, ch.chunk_name)::regclass = cl.oid) JOIN pg_am am ON (am.oid = cl.relam); CREATE TABLE test_table (time timestamptz not null, device int, temp float); SELECT create_hypertable('test_table', by_range('time')); create_hypertable ------------------- (1,t) INSERT INTO test_table SELECT ts, 10 * random(), 100 * random() FROM generate_series('2001-01-01'::timestamp, '2001-02-01', '1d'::interval) as x(ts); SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; relname | amname ------------+-------- test_table | heap SELECT * FROM chunk_info WHERE hypertable = 'test_table'; hypertable | chunk | amname ------------+------------------+-------- test_table | _hyper_1_1_chunk | heap test_table | _hyper_1_2_chunk | heap test_table | _hyper_1_3_chunk | heap test_table | _hyper_1_4_chunk | heap test_table | _hyper_1_5_chunk | heap test_table | _hyper_1_6_chunk | heap -- Test setting the access method together with other options. This -- should not generate an error. ALTER TABLE test_table SET ACCESS METHOD testam, SET (autovacuum_vacuum_threshold = 100); -- Create more chunks. These will use the new access method, but the -- old chunks will use the old access method. INSERT INTO test_table SELECT ts, 10 * random(), 100 * random() FROM generate_series('2001-02-01'::timestamp, '2001-03-01', '1d'::interval) as x(ts); SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; relname | amname ------------+-------- test_table | testam SELECT * FROM chunk_info WHERE hypertable = 'test_table'; hypertable | chunk | amname ------------+-------------------+-------- test_table | _hyper_1_1_chunk | heap test_table | _hyper_1_2_chunk | heap test_table | _hyper_1_3_chunk | heap test_table | _hyper_1_4_chunk | heap test_table | _hyper_1_5_chunk | heap test_table | _hyper_1_6_chunk | heap test_table | _hyper_1_7_chunk | testam test_table | _hyper_1_8_chunk | testam test_table | _hyper_1_9_chunk | testam test_table | _hyper_1_10_chunk | testam ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/tableam_alter_defaults.out�����������������������������������������0000664�0000000�0000000�00000006375�15100345067�0024062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test support for setting table access method on hypertables using -- ALTER TABLE for version 17 and later. This is in addition to the -- tests in tableam_alter.sql. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE VIEW chunk_info AS SELECT hypertable_name AS hypertable, chunk_name AS chunk, amname FROM timescaledb_information.chunks ch JOIN pg_class cl ON (format('%I.%I', ch.chunk_schema, ch.chunk_name)::regclass = cl.oid) JOIN pg_am am ON (am.oid = cl.relam); CREATE TABLE test_table (time timestamptz not null, device int, temp float); SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; relname | amname ------------+-------- test_table | heap -- Check that setting default access method of a normal table works. ALTER TABLE test_table SET ACCESS METHOD DEFAULT; -- Check that changing the access method and then changing it back -- works. ALTER TABLE test_table SET ACCESS METHOD testam; ALTER TABLE test_table SET ACCESS METHOD DEFAULT; -- Check that setting default access method of a hypertable works. SELECT create_hypertable('test_table', by_range('time')); create_hypertable ------------------- (1,t) ALTER TABLE test_table SET ACCESS METHOD DEFAULT; SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; relname | amname ------------+-------- test_table | heap -- Test setting the access method together with other options. This -- should not generate an error. ALTER TABLE test_table SET ACCESS METHOD testam, SET (autovacuum_vacuum_threshold = 100); -- Add some rows to generate a chunk. This should get the access -- method of the hypertable. INSERT INTO test_table SELECT ts, 10 * random(), 100 * random() FROM generate_series('2001-01-01'::timestamp, '2001-01-14', '1d'::interval) as x(ts); SELECT * FROM chunk_info WHERE hypertable = 'test_table'; hypertable | chunk | amname ------------+------------------+-------- test_table | _hyper_1_1_chunk | testam test_table | _hyper_1_2_chunk | testam test_table | _hyper_1_3_chunk | testam -- Setting it to the default method after we have set it to a test -- access method should work fine also on a hypertable. SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; relname | amname ------------+-------- test_table | testam ALTER TABLE test_table SET ACCESS METHOD DEFAULT; SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; relname | amname ------------+-------- test_table | heap SELECT chunk FROM show_chunks('test_table') t(chunk) limit 1 \gset ALTER TABLE :chunk SET ACCESS METHOD DEFAULT; SELECT * FROM chunk_info WHERE hypertable = 'test_table'; hypertable | chunk | amname ------------+------------------+-------- test_table | _hyper_1_1_chunk | heap test_table | _hyper_1_2_chunk | testam test_table | _hyper_1_3_chunk | testam �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/tablespace.out�����������������������������������������������������0000664�0000000�0000000�00000047566�15100345067�0021511�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set ON_ERROR_STOP 0 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW hypertable_tablespaces AS SELECT cls.relname AS hypertable, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM _timescaledb_catalog.hypertable, LATERAL (SELECT * FROM pg_class WHERE oid = format('%I.%I', schema_name, table_name)::regclass) AS cls ORDER BY hypertable, tablespace; GRANT SELECT ON hypertable_tablespaces TO PUBLIC; --Test hypertable with tablespace. Tablespaces are cluster-wide, so we --attach the test name as prefix to allow tests to be executed in --parallel. CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --assigning a tablespace via the main table should work CREATE TABLE tspace_2dim(time timestamp, temp float, device text) TABLESPACE tablespace1; SELECT create_hypertable('tspace_2dim', 'time', 'device', 2); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (1,public,tspace_2dim,t) INSERT INTO tspace_2dim VALUES ('2017-01-20T09:00:01', 24.3, 'blue'); -- Tablespace for tspace_2dim should be set SELECT * FROM hypertable_tablespaces WHERE hypertable = 'tspace_2dim'; hypertable | tablespace -------------+------------- tspace_2dim | tablespace1 SELECT show_tablespaces('tspace_2dim'); show_tablespaces ------------------ tablespace1 --verify that the table chunk has the correct tablespace SELECT relname, spcname FROM pg_class c INNER JOIN pg_tablespace t ON (c.reltablespace = t.oid) INNER JOIN _timescaledb_catalog.chunk ch ON (ch.table_name = c.relname); relname | spcname ------------------+------------- _hyper_1_1_chunk | tablespace1 --check some error conditions SELECT attach_tablespace(NULL,NULL); ERROR: invalid tablespace name SELECT attach_tablespace('tablespace2', NULL); ERROR: invalid hypertable SELECT attach_tablespace(NULL, 'tspace_2dim'); ERROR: invalid tablespace name SELECT attach_tablespace('none_existing_tablespace', 'tspace_2dim'); ERROR: tablespace "none_existing_tablespace" does not exist SELECT attach_tablespace('tablespace2', 'none_existing_table'); ERROR: relation "none_existing_table" does not exist at character 41 SELECT detach_tablespace(NULL); ERROR: invalid tablespace name SELECT detach_tablespaces(NULL); ERROR: invalid argument SELECT show_tablespaces(NULL); show_tablespaces ------------------ --attach another tablespace without first creating it --> should generate error SELECT attach_tablespace('tablespace2', 'tspace_2dim'); ERROR: tablespace "tablespace2" does not exist --attach the same tablespace twice to same table should also generate error SELECT attach_tablespace('tablespace1', 'tspace_2dim'); ERROR: tablespace "tablespace1" is already attached to hypertable "tspace_2dim" --no error if if_not_attached is given SELECT attach_tablespace('tablespace1', 'tspace_2dim', if_not_attached => true); NOTICE: tablespace "tablespace1" is already attached to hypertable "tspace_2dim", skipping attach_tablespace ------------------- \c :TEST_DBNAME :ROLE_SUPERUSER --Tablespaces are cluster-wide, so we attach the test name as prefix --to allow tests to be executed in parallel. CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER_2 LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --attach without permissions on the table should fail SELECT attach_tablespace('tablespace2', 'tspace_2dim'); ERROR: must be owner of hypertable "tspace_2dim" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --attach without permissions on the tablespace should also fail SELECT attach_tablespace('tablespace2', 'tspace_2dim'); ERROR: permission denied for tablespace "tablespace2" by table owner "default_perm_user" \c :TEST_DBNAME :ROLE_SUPERUSER GRANT :ROLE_DEFAULT_PERM_USER_2 TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --should work with permissions on both the table and the tablespace SELECT attach_tablespace('tablespace2', 'tspace_2dim'); attach_tablespace ------------------- SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 1 | 1 | tablespace1 2 | 1 | tablespace2 SELECT * FROM show_tablespaces('tspace_2dim'); show_tablespaces ------------------ tablespace1 tablespace2 --insert into another chunk INSERT INTO tspace_2dim VALUES ('2017-01-20T09:00:01', 24.3, 'brown'); SELECT * FROM test.show_subtables('tspace_2dim'); Child | Tablespace ----------------------------------------+------------- _timescaledb_internal._hyper_1_1_chunk | tablespace1 _timescaledb_internal._hyper_1_2_chunk | tablespace2 --indexes should inherit the tablespace of their chunk SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_tspace_2dim_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_tspace_2dim_device_time_idx | {device,time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_tspace_2dim_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_tspace_2dim_device_time_idx | {device,time} | | f | f | f | tablespace1 \x SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; -[ RECORD 1 ]----------+---------------------------- hypertable_schema | public hypertable_name | tspace_2dim owner | default_perm_user num_dimensions | 2 num_chunks | 2 compression_enabled | f tablespaces | {tablespace1,tablespace2} primary_dimension | time primary_dimension_type | timestamp without time zone SELECT hypertable_schema, hypertable_name, chunk_schema, chunk_name, chunk_tablespace FROM timescaledb_information.chunks ORDER BY chunk_name; -[ RECORD 1 ]-----+---------------------- hypertable_schema | public hypertable_name | tspace_2dim chunk_schema | _timescaledb_internal chunk_name | _hyper_1_1_chunk chunk_tablespace | tablespace1 -[ RECORD 2 ]-----+---------------------- hypertable_schema | public hypertable_name | tspace_2dim chunk_schema | _timescaledb_internal chunk_name | _hyper_1_2_chunk chunk_tablespace | tablespace2 \x -- SET ROLE :ROLE_DEFAULT_PERM_USER_2; CREATE TABLE tspace_1dim(time timestamp, temp float, device text); SELECT create_hypertable('tspace_1dim', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (2,public,tspace_1dim,t) --user doesn't have permission on tablespace1 --> error SELECT attach_tablespace('tablespace1', 'tspace_1dim'); ERROR: permission denied for tablespace "tablespace1" by table owner "default_perm_user_2" --grant permission to tablespace1 SET ROLE :ROLE_DEFAULT_PERM_USER; GRANT CREATE ON TABLESPACE tablespace1 TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; --should work fine now. Test SELECT INTO utility statements to ensure --internal alter table function call works with event triggers. SELECT true INTO attached FROM attach_tablespace('tablespace1', 'tspace_1dim'); SELECT attach_tablespace('tablespace2', 'tspace_1dim'); attach_tablespace ------------------- -- Tablespace for tspace_1dim should be set and attached SELECT * FROM hypertable_tablespaces WHERE hypertable = 'tspace_1dim'; hypertable | tablespace -------------+------------- tspace_1dim | tablespace1 SELECT show_tablespaces('tspace_1dim'); show_tablespaces ------------------ tablespace1 tablespace2 --trying to revoke permissions while attached should fail SET ROLE :ROLE_DEFAULT_PERM_USER; REVOKE CREATE ON TABLESPACE tablespace1 FROM :ROLE_DEFAULT_PERM_USER_2; ERROR: cannot revoke privilege while tablespace "tablespace1" is attached to hypertable "tspace_1dim" REVOKE ALL ON TABLESPACE tablespace1 FROM :ROLE_DEFAULT_PERM_USER_2; ERROR: cannot revoke privilege while tablespace "tablespace1" is attached to hypertable "tspace_1dim" SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 1 | 1 | tablespace1 2 | 1 | tablespace2 3 | 2 | tablespace1 4 | 2 | tablespace2 INSERT INTO tspace_1dim VALUES ('2017-01-20T09:00:01', 24.3, 'blue'); INSERT INTO tspace_1dim VALUES ('2017-03-20T09:00:01', 24.3, 'brown'); SELECT * FROM test.show_subtablesp('tspace_%'); Parent | Child | Tablespace -------------+----------------------------------------+------------- tspace_2dim | _timescaledb_internal._hyper_1_1_chunk | tablespace1 tspace_2dim | _timescaledb_internal._hyper_1_2_chunk | tablespace2 tspace_1dim | _timescaledb_internal._hyper_2_3_chunk | tablespace1 tspace_1dim | _timescaledb_internal._hyper_2_4_chunk | tablespace2 --indexes should inherit the tablespace of their chunk, unless the --parent index has a tablespace set, in which case the chunks' --corresponding indexes are pinned to the parent index's --tablespace. The parent index can have a tablespace set in two cases: --(1) if explicitly set in CREATE INDEX, or (2) if the main table was --created with a tablespace, because then default indexes will be --created in that tablespace too. SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+--------------------------------------------------------------------+---------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_tspace_2dim_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_tspace_2dim_device_time_idx | {device,time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_tspace_2dim_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_tspace_2dim_device_time_idx | {device,time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_2_3_chunk | _timescaledb_internal._hyper_2_3_chunk_tspace_1dim_time_idx | {time} | | f | f | f | tablespace2 _timescaledb_internal._hyper_2_4_chunk | _timescaledb_internal._hyper_2_4_chunk_tspace_1dim_time_idx | {time} | | f | f | f | tablespace1 --detach tablespace1 from tspace_2dim should fail due to lack of permissions SELECT detach_tablespace('tablespace1', 'tspace_2dim'); ERROR: must be owner of hypertable "tspace_2dim" --detach tablespace1 from all tables. Should only detach from --'tspace_1dim' (1 tablespace) due to lack of permissions SELECT * FROM hypertable_tablespaces; hypertable | tablespace -------------+------------- tspace_1dim | tablespace1 tspace_2dim | tablespace1 SELECT * INTO detached FROM detach_tablespace('tablespace1'); NOTICE: tablespace "tablespace1" remains attached to 1 hypertable(s) due to lack of permissions SELECT * FROM detached; detach_tablespace ------------------- 1 SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 1 | 1 | tablespace1 2 | 1 | tablespace2 4 | 2 | tablespace2 SELECT * FROM show_tablespaces('tspace_1dim'); show_tablespaces ------------------ tablespace2 SELECT * FROM show_tablespaces('tspace_2dim'); show_tablespaces ------------------ tablespace1 tablespace2 SELECT * FROM hypertable_tablespaces; hypertable | tablespace -------------+------------- tspace_1dim | tspace_2dim | tablespace1 --it should now be possible to revoke permissions on tablespace1 SET ROLE :ROLE_DEFAULT_PERM_USER; REVOKE CREATE ON TABLESPACE tablespace1 FROM :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; --detach the other tablespace SELECT detach_tablespace('tablespace2', 'tspace_1dim'); detach_tablespace ------------------- 1 SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 1 | 1 | tablespace1 2 | 1 | tablespace2 SELECT * FROM show_tablespaces('tspace_1dim'); show_tablespaces ------------------ SELECT * FROM show_tablespaces('tspace_2dim'); show_tablespaces ------------------ tablespace1 tablespace2 SELECT * FROM hypertable_tablespaces; hypertable | tablespace -------------+------------- tspace_1dim | tspace_2dim | tablespace1 --detaching tablespace2 from a table without permissions should fail SELECT detach_tablespace('tablespace2', 'tspace_2dim'); ERROR: must be owner of hypertable "tspace_2dim" SELECT detach_tablespaces('tspace_2dim'); ERROR: must be owner of hypertable "tspace_2dim" \c :TEST_DBNAME :ROLE_SUPERUSER -- PERM_USER_2 owns tablespace2, and PERM_USER owns the table -- 'tspace_2dim', which has tablespace2 attached. Revoking PERM_USER_2 -- FROM PERM_USER should therefore fail REVOKE :ROLE_DEFAULT_PERM_USER_2 FROM :ROLE_DEFAULT_PERM_USER; ERROR: cannot revoke privilege while tablespace "tablespace2" is attached to hypertable "tspace_2dim" SET ROLE :ROLE_DEFAULT_PERM_USER_2; --set other user should make detach work SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * INTO detached_all FROM detach_tablespaces('tspace_2dim'); SELECT * FROM detached_all; detach_tablespaces -------------------- 2 SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- SELECT * FROM show_tablespaces('tspace_1dim'); show_tablespaces ------------------ SELECT * FROM show_tablespaces('tspace_2dim'); show_tablespaces ------------------ \c :TEST_DBNAME :ROLE_SUPERUSER -- It should now be possible to revoke PERM_USER_2 from PERM_USER -- since tablespace2 is no longer attched to tspace_2dim REVOKE :ROLE_DEFAULT_PERM_USER_2 FROM :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; --detaching twice should fail SELECT detach_tablespace('tablespace2', 'tspace_2dim'); ERROR: tablespace "tablespace2" is not attached to hypertable "tspace_2dim" --adding if_attached should only generate notice SELECT detach_tablespace('tablespace2', 'tspace_2dim', if_attached => true); NOTICE: tablespace "tablespace2" is not attached to hypertable "tspace_2dim", skipping detach_tablespace ------------------- 0 --attach tablespaces again to verify that tablespaces are cleaned up --when tables are dropped \c :TEST_DBNAME :ROLE_SUPERUSER SELECT attach_tablespace('tablespace2', 'tspace_1dim'); attach_tablespace ------------------- SELECT attach_tablespace('tablespace1', 'tspace_2dim'); attach_tablespace ------------------- SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 5 | 2 | tablespace2 6 | 1 | tablespace1 DROP TABLE tspace_1dim; SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- 6 | 1 | tablespace1 DROP TABLE tspace_2dim; SELECT * FROM _timescaledb_catalog.tablespace; id | hypertable_id | tablespace_name ----+---------------+----------------- -- Create two tables and attach multiple tablespaces to them. Verify -- that dropping a tablespace from multiple tables work as expected. CREATE TABLE tbl_1(time timestamp, temp float, device text); SELECT create_hypertable('tbl_1', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (3,public,tbl_1,t) CREATE TABLE tbl_2(time timestamp, temp float, device text); SELECT create_hypertable('tbl_2', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (4,public,tbl_2,t) CREATE TABLE tbl_3(time timestamp, temp float, device text); SELECT create_hypertable('tbl_3', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (5,public,tbl_3,t) SELECT * FROM hypertable_tablespaces; hypertable | tablespace ------------+------------ tbl_1 | tbl_2 | tbl_3 | SELECT * FROM show_tablespaces('tbl_1'); show_tablespaces ------------------ SELECT * FROM show_tablespaces('tbl_2'); show_tablespaces ------------------ SELECT * FROM show_tablespaces('tbl_3'); show_tablespaces ------------------ SELECT attach_tablespace('tablespace1', 'tbl_1'); attach_tablespace ------------------- SELECT attach_tablespace('tablespace2', 'tbl_1'); attach_tablespace ------------------- SELECT attach_tablespace('tablespace2', 'tbl_2'); attach_tablespace ------------------- SELECT attach_tablespace('tablespace2', 'tbl_3'); attach_tablespace ------------------- SELECT * FROM hypertable_tablespaces; hypertable | tablespace ------------+------------- tbl_1 | tablespace1 tbl_2 | tablespace2 tbl_3 | tablespace2 SELECT * FROM show_tablespaces('tbl_1'); show_tablespaces ------------------ tablespace1 tablespace2 SELECT * FROM show_tablespaces('tbl_2'); show_tablespaces ------------------ tablespace2 SELECT * FROM show_tablespaces('tbl_3'); show_tablespaces ------------------ tablespace2 SELECT detach_tablespace('tablespace2'); detach_tablespace ------------------- 3 SELECT * FROM hypertable_tablespaces; hypertable | tablespace ------------+------------- tbl_1 | tablespace1 tbl_2 | tbl_3 | SELECT * FROM show_tablespaces('tbl_1'); show_tablespaces ------------------ tablespace1 SELECT * FROM show_tablespaces('tbl_2'); show_tablespaces ------------------ SELECT * FROM show_tablespaces('tbl_3'); show_tablespaces ------------------ DROP TABLE tbl_1; DROP TABLE tbl_2; DROP TABLE tbl_3; -- verify that one cannot DROP a tablespace while it is attached to a -- hypertable CREATE TABLE tbl_1(time timestamp, temp float, device text); SELECT create_hypertable('tbl_1', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------- (6,public,tbl_1,t) SELECT attach_tablespace('tablespace1', 'tbl_1'); attach_tablespace ------------------- SELECT * FROM show_tablespaces('tbl_1'); show_tablespaces ------------------ tablespace1 DROP TABLESPACE tablespace1; ERROR: tablespace "tablespace1" is still attached to 1 hypertables --after detaching we should now be able to drop the tablespace SELECT detach_tablespace('tablespace1', 'tbl_1'); detach_tablespace ------------------- 1 DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; ������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/telemetry.out������������������������������������������������������0000664�0000000�0000000�00000062331�15100345067�0021403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_status(int) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_status' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_status_ssl(int) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_status_ssl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_status_mock(text) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_status_mock' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_validate_server_version(response text) RETURNS TEXT AS :MODULE_PATHNAME, 'ts_test_validate_server_version' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_telemetry_main_conn(text, text) RETURNS BOOLEAN AS :MODULE_PATHNAME, 'ts_test_telemetry_main_conn' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_telemetry(host text = NULL, servname text = NULL, port int = NULL) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_telemetry' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_privacy() RETURNS BOOLEAN AS :MODULE_PATHNAME, 'ts_test_privacy' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test_check_version_response(response text) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_check_version_response' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; INSERT INTO _timescaledb_catalog.metadata VALUES ('foo','bar',TRUE); INSERT INTO _timescaledb_catalog.metadata VALUES ('bar','baz',FALSE); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT _timescaledb_internal.test_status_ssl(200); test_status_ssl ----------------- {"status": 200} SELECT _timescaledb_internal.test_status_ssl(201); test_status_ssl ----------------- {"status": 201} \set ON_ERROR_STOP 0 SELECT _timescaledb_internal.test_status_ssl(304); ERROR: endpoint sent back unexpected HTTP status: 304 SELECT _timescaledb_internal.test_status_ssl(400); ERROR: endpoint sent back unexpected HTTP status: 400 SELECT _timescaledb_internal.test_status_ssl(401); ERROR: endpoint sent back unexpected HTTP status: 401 SELECT _timescaledb_internal.test_status_ssl(404); ERROR: endpoint sent back unexpected HTTP status: 404 SELECT _timescaledb_internal.test_status_ssl(500); ERROR: endpoint sent back unexpected HTTP status: 500 SELECT _timescaledb_internal.test_status_ssl(503); ERROR: endpoint sent back unexpected HTTP status: 503 \set ON_ERROR_STOP 1 -- This function runs the test 5 times, because each time the internal C function is choosing a random length to send from the server on each socket read. We hit many cases this way. CREATE OR REPLACE FUNCTION mocker(TEXT) RETURNS SETOF TEXT AS $BODY$ DECLARE r TEXT; BEGIN FOR i in 1..5 LOOP SELECT _timescaledb_internal.test_status_mock($1) INTO r; RETURN NEXT r; END LOOP; RETURN; END $BODY$ LANGUAGE 'plpgsql'; select * from mocker( E'HTTP/1.1 200 OK\r\n' 'Content-Type: application/json; charset=utf-8\r\n' 'Date: Thu, 12 Jul 2018 18:33:04 GMT\r\n' 'ETag: W/\"e-upYEWCL+q6R/++2nWHz5b76hBgo\"\r\n' 'Server: nginx\r\n' 'Vary: Accept-Encoding\r\n' 'Content-Length: 14\r\n' 'Connection: Close\r\n\r\n' '{\"status\":200}'); mocker ----------------- {"status": 200} {"status": 200} {"status": 200} {"status": 200} {"status": 200} select * from mocker( E'HTTP/1.1 201 OK\r\n' 'Content-Type: application/json; charset=utf-8\r\n' 'Vary: Accept-Encoding\r\n' 'Content-Length: 14\r\n' 'Connection: Close\r\n\r\n' '{\"status\":201}'); mocker ----------------- {"status": 201} {"status": 201} {"status": 201} {"status": 201} {"status": 201} \set ON_ERROR_STOP 0 \set test_string 'HTTP/1.1 404 Not Found\r\nContent-Length: 14\r\nConnection: Close\r\n\r\n{\"status\":404}'; SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: endpoint sent back unexpected HTTP status: 404 SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: endpoint sent back unexpected HTTP status: 404 SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: endpoint sent back unexpected HTTP status: 404 SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: endpoint sent back unexpected HTTP status: 404 SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: endpoint sent back unexpected HTTP status: 404 \set test_string 'Content-Length: 14\r\nConnection: Close\r\n\r\n{\"status\":404}'; SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response \set test_string 'HTTP/1.1 404 Not Found\r\nContent-Length: 14\r\nConnection: Close\r\n{\"status\":404}'; SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response SELECT _timescaledb_internal.test_status_mock(:'test_string'); ERROR: could not parse HTTP response \set ON_ERROR_STOP 1 -- Test parsing version response SELECT * FROM _timescaledb_internal.test_validate_server_version('{"status": "200", "current_timescaledb_version": "10.1.0"}'); test_validate_server_version ------------------------------ 10.1.0 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1"}'); test_validate_server_version ------------------------------ 10.1 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10"}'); test_validate_server_version ------------------------------ 10 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "9.2.0"}'); test_validate_server_version ------------------------------ 9.2.0 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "9.1.2"}'); test_validate_server_version ------------------------------ 9.1.2 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0"}'); test_validate_server_version ------------------------------ 1.0.0 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-rc1"}'); test_validate_server_version ------------------------------ 1.0.0-rc1 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-rc2"}'); test_validate_server_version ------------------------------ 1.0.0-rc2 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-rc1"}'); test_validate_server_version ------------------------------ 1.0.0-rc1 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-alpha"}'); test_validate_server_version ------------------------------ 1.0.0-alpha SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "123456789"}'); test_validate_server_version ------------------------------ 123456789 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "!@#$%"}'); test_validate_server_version ------------------------------ SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": ""}'); test_validate_server_version ------------------------------ SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": " 10 "}'); test_validate_server_version ------------------------------ SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "a"}'); test_validate_server_version ------------------------------ a SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "a.b.c"}'); test_validate_server_version ------------------------------ a.b.c SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1.1a"}'); test_validate_server_version ------------------------------ 10.1.1a SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1.1+rc1"}'); test_validate_server_version ------------------------------ SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1.1.1"}'); test_validate_server_version ------------------------------ 10.1.1.1 SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"}'); test_validate_server_version ------------------------------ ---------------------------------------------------------------- -- Test well-formed response and valid versions SELECT test_check_version_response('{"current_timescaledb_version": "1.6.1", "is_up_to_date": true}'); NOTICE: the "timescaledb" extension is up-to-date test_check_version_response ----------------------------- SELECT test_check_version_response('{"current_timescaledb_version": "1.6.1", "is_up_to_date": false}'); test_check_version_response ----------------------------- SELECT test_check_version_response('{"current_timescaledb_version": "10.1", "is_up_to_date": false}'); test_check_version_response ----------------------------- SELECT test_check_version_response('{"current_timescaledb_version": "10.1.1-rc1", "is_up_to_date": false}'); test_check_version_response ----------------------------- ---------------------------------------------------------------- -- Test well-formed response but invalid versions SELECT test_check_version_response('{"current_timescaledb_version": "1.0.0-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "is_up_to_date": false}'); NOTICE: server did not return a valid TimescaleDB version: version string is too long test_check_version_response ----------------------------- SELECT test_check_version_response('{"current_timescaledb_version": "10.1.1+rc1", "is_up_to_date": false}'); NOTICE: server did not return a valid TimescaleDB version: version string has invalid characters test_check_version_response ----------------------------- SELECT test_check_version_response('{"current_timescaledb_version": "@10.1.1", "is_up_to_date": false}'); NOTICE: server did not return a valid TimescaleDB version: version string has invalid characters test_check_version_response ----------------------------- SELECT test_check_version_response('{"current_timescaledb_version": "10.1.1@", "is_up_to_date": false}'); NOTICE: server did not return a valid TimescaleDB version: version string has invalid characters test_check_version_response ----------------------------- ---------------------------------------------------------------- -- Test malformed responses \set ON_ERROR_STOP 0 -- Empty response SELECT test_check_version_response('{}'); ERROR: malformed telemetry response body -- Field "is_up_to_date" missing SELECT test_check_version_response('{"current_timescaledb_version": "1.6.1"}'); ERROR: malformed telemetry response body -- Field "current_timescaledb_version" is missing SELECT test_check_version_response('{"is_up_to_date": false}'); ERROR: malformed telemetry response body \set ON_ERROR_STOP 1 SET timescaledb.telemetry_level=basic; -- Connect to a bogus host and path to test error handling in telemetry_main() SELECT _timescaledb_internal.test_telemetry_main_conn('noservice.timescale.com', 'path'); NOTICE: telemetry could not connect to "noservice.timescale.com" test_telemetry_main_conn -------------------------- f -- Test telemetry report contents SET timescaledb.telemetry_level=basic; SELECT * FROM jsonb_object_keys(get_telemetry_report()) AS key WHERE key != 'os_name_pretty'; key ------------------------------------ db_uuid license os_name relations os_release os_version data_volume db_metadata replication build_os_name access_methods functions_used install_method installed_time last_tuned_time build_os_version exported_db_uuid instance_metadata stats_by_job_type telemetry_version build_architecture last_tuned_version postgresql_version related_extensions db_telemetry_events timescaledb_version errors_by_sqlerrcode num_reorder_policies num_retention_policies num_compression_policies num_user_defined_actions num_reorder_policies_fixed build_architecture_bit_size num_continuous_aggs_policies num_retention_policies_fixed num_compression_policies_fixed num_user_defined_actions_fixed num_continuous_aggs_policies_fixed CREATE MATERIALIZED VIEW telemetry_report AS SELECT t FROM get_telemetry_report() t; -- check telemetry picks up flagged content from metadata SELECT t -> 'db_metadata' FROM telemetry_report; ?column? ---------------- {"foo": "bar"} -- check timescaledb_telemetry.cloud SELECT t -> 'instance_metadata' FROM telemetry_report; ?column? ----------------- {"cloud": "ci"} -- Check access methods SELECT t->'access_methods' ? 'btree', t->'access_methods' ? 'heap', CAST(t->'access_methods'->'btree'->'pages' AS int) > 0, CAST(t->'access_methods'->'btree'->'instances' AS int) > 0 FROM telemetry_report; ?column? | ?column? | ?column? | ?column? ----------+----------+----------+---------- t | t | t | t WITH t AS ( SELECT t -> 'relations' AS rels FROM telemetry_report ) SELECT rels -> 'hypertables' -> 'num_relations' AS num_hypertables, rels -> 'continuous_aggregates' -> 'num_relations' AS num_caggs FROM t; num_hypertables | num_caggs -----------------+----------- 0 | 0 CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); table_name ----------------- device_readings REFRESH MATERIALIZED VIEW telemetry_report; WITH t AS ( SELECT t -> 'relations' AS rels FROM telemetry_report ) SELECT rels -> 'hypertables' -> 'num_relations' AS num_hypertables, rels -> 'continuous_aggregates' -> 'num_relations' AS num_caggs FROM t; num_hypertables | num_caggs -----------------+----------- 1 | 0 set datestyle to iso; -- check that installed_time formatting in telemetry report does not depend on local date settings SELECT t -> 'installed_time' AS installed_time FROM telemetry_report \gset set datestyle to sql; SELECT t-> 'installed_time' AS installed_time2 FROM telemetry_report \gset SELECT :'installed_time' = :'installed_time2' AS equal, length(:'installed_time'), length(:'installed_time2'); equal | length | length -------+--------+-------- t | 24 | 24 RESET datestyle; -- test function call telemetry CREATE FUNCTION not_visible_in_telemetry() RETURNS INT AS $$ SELECT 1; $$ LANGUAGE SQL; -- drain old function call telemetry so we have fixed out put; SELECT FROM get_telemetry_report(); -- -- call some arbirary functions SELECT 1 + 1, not_visible_in_telemetry(), 1 + 1, abs(-1), not_visible_in_telemetry() WHERE 1 + 1 = 2; ?column? | not_visible_in_telemetry | ?column? | abs | not_visible_in_telemetry ----------+--------------------------+----------+-----+-------------------------- 2 | 1 | 2 | 1 | 1 -- call some aggregates SELECT min(not_visible_in_telemetry()), sum(not_visible_in_telemetry()); min | sum -----+----- 1 | 1 -- check that we can record from a prepared statement PREPARE record_from_prepared AS SELECT 1 - 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 EXECUTE record_from_prepared; ?column? ---------- 0 DEALLOCATE record_from_prepared; SELECT get_telemetry_report()->'functions_used'; ?column? --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"pg_catalog.count()": 1, "pg_catalog.sum(bigint)": 4, "pg_catalog.abs(integer)": 1, "pg_catalog.max(integer)": 2, "pg_catalog.min(integer)": 1, "pg_catalog.sum(integer)": 1, "pg_catalog.int8(numeric)": 4, "pg_catalog.sum(interval)": 2, "pg_catalog.current_database()": 1, "public.get_telemetry_report()": 1, "pg_catalog.text(pg_catalog.name)": 1, "pg_catalog.int4eq(integer,integer)": 3, "pg_catalog.int4mi(integer,integer)": 11, "pg_catalog.int4pl(integer,integer)": 3, "pg_catalog.concat(pg_catalog.\"any\")": 3, "pg_catalog.pg_get_userbyid(pg_catalog.oid)": 1, "pg_catalog.nameeq(pg_catalog.name,pg_catalog.name)": 2, "pg_catalog.texteq(pg_catalog.text,pg_catalog.text)": 1, "pg_catalog.nameregexeq(pg_catalog.name,pg_catalog.text)": 1, "pg_catalog.textregexeq(pg_catalog.text,pg_catalog.text)": 1, "pg_catalog.jsonb_object_agg(pg_catalog.\"any\",pg_catalog.\"any\")": 1, "pg_catalog.jsonb_object_field(pg_catalog.jsonb,pg_catalog.text)": 16, "pg_catalog.jsonb_object_field_text(pg_catalog.jsonb,pg_catalog.text)": 15, "pg_catalog.pg_has_role(pg_catalog.name,pg_catalog.oid,pg_catalog.text)": 1, "pg_catalog.pg_has_role(pg_catalog.name,pg_catalog.name,pg_catalog.text)": 1} -- check the report again to see if resetting works SELECT get_telemetry_report()->'functions_used'; ?column? ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"pg_catalog.count()": 1, "pg_catalog.sum(bigint)": 4, "pg_catalog.max(integer)": 2, "pg_catalog.int8(numeric)": 4, "pg_catalog.sum(interval)": 2, "pg_catalog.current_database()": 1, "public.get_telemetry_report()": 1, "pg_catalog.text(pg_catalog.name)": 1, "pg_catalog.int4eq(integer,integer)": 2, "pg_catalog.concat(pg_catalog.\"any\")": 3, "pg_catalog.pg_get_userbyid(pg_catalog.oid)": 1, "pg_catalog.nameeq(pg_catalog.name,pg_catalog.name)": 2, "pg_catalog.texteq(pg_catalog.text,pg_catalog.text)": 1, "pg_catalog.nameregexeq(pg_catalog.name,pg_catalog.text)": 1, "pg_catalog.textregexeq(pg_catalog.text,pg_catalog.text)": 1, "pg_catalog.jsonb_object_agg(pg_catalog.\"any\",pg_catalog.\"any\")": 1, "pg_catalog.jsonb_object_field(pg_catalog.jsonb,pg_catalog.text)": 16, "pg_catalog.jsonb_object_field_text(pg_catalog.jsonb,pg_catalog.text)": 15, "pg_catalog.pg_has_role(pg_catalog.name,pg_catalog.oid,pg_catalog.text)": 1, "pg_catalog.pg_has_role(pg_catalog.name,pg_catalog.name,pg_catalog.text)": 1} \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.metadata; SET timescaledb.telemetry_level=off; -- returns false which means telemetry got canceled SELECT * FROM _timescaledb_internal.test_privacy(); test_privacy -------------- f RESET timescaledb.telemetry_level; -- returns false which means telemetry got canceled SELECT * FROM _timescaledb_internal.test_privacy(); test_privacy -------------- f -- To make sure nothing was sent, we check the UUID table to make sure no exported UUID row was created SELECT key from _timescaledb_catalog.metadata; key ----- \set ON_ERROR_STOP 0 -- test that the telemetry gathering code doesn't break nonexistent statements EXECUTE noexistent_statement; ERROR: prepared statement "noexistent_statement" does not exist \c :TEST_DBNAME :ROLE_SUPERUSER -- Insert some data into the telemetry event table INSERT INTO _timescaledb_catalog.telemetry_event(tag, body) VALUES ('ummagumma', '{"title": "Careful with that Axe Eugene!"}'), ('kaboom', '{"title": "Where is that kaboom?"}'); -- Check that it is present in the telemetry report SELECT * FROM jsonb_to_recordset(get_telemetry_report()->'db_telemetry_events') AS x(tag name, body text); tag | body -----------+-------------------------------------------- ummagumma | {"title": "Careful with that Axe Eugene!"} kaboom | {"title": "Where is that kaboom?"} �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/test_tss_callbacks.out���������������������������������������������0000664�0000000�0000000�00000003137�15100345067�0023237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.setup_tss_hook_v0() RETURNS VOID AS :MODULE_PATHNAME, 'ts_setup_tss_hook_v0' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.setup_tss_hook_v1() RETURNS VOID AS :MODULE_PATHNAME, 'ts_setup_tss_hook_v1' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.teardown_tss_hook_v1() RETURNS VOID AS :MODULE_PATHNAME, 'ts_teardown_tss_hook_v1' LANGUAGE C VOLATILE; SELECT test.setup_tss_hook_v1(); setup_tss_hook_v1 ------------------- CREATE TABLE copy_test ( "time" timestamptz NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('copy_test', 'time'); create_hypertable ------------------------ (1,public,copy_test,t) -- We should se a mock message COPY copy_test FROM STDIN DELIMITER ','; NOTICE: test_tss_callbacks (mock): query=COPY copy_test FROM STDIN DELIMITER ',';, len=39, id=0, rows=2 SELECT test.teardown_tss_hook_v1(); teardown_tss_hook_v1 ---------------------- -- Without the hook registered we cannot see the mock message COPY copy_test FROM STDIN DELIMITER ','; -- Test for mismatch version SELECT test.setup_tss_hook_v0(); setup_tss_hook_v0 ------------------- -- Warning because the mismatch versions COPY copy_test FROM STDIN DELIMITER ','; WARNING: version mismatch between timescaledb and ts_stat_statements callbacks WARNING: version mismatch between timescaledb and ts_stat_statements callbacks ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/test_utils.out�����������������������������������������������������0000664�0000000�0000000�00000013103�15100345067�0021561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.condition() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_condition' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test.int64_eq() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_int64_eq' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test.ptr_eq() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_ptr_eq' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test.double_eq() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_double_eq' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; SET ROLE :ROLE_DEFAULT_PERM_USER; -- We're testing that the test utils work and generate errors on -- failing conditions \set ON_ERROR_STOP 0 SELECT test.condition(); ERROR: TestFailure | (true_value == false_value) SELECT test.int64_eq(); ERROR: TestFailure | (big == small) [32532978 == 3242234] SELECT test.ptr_eq(); ERROR: TestFailure | (true_ptr == false_ptr) SELECT test.double_eq(); ERROR: TestFailure | (big_double == small_double) [923423478.324200 == 324.300000] \set ON_ERROR_STOP 1 -- Test debug points -- \set ECHO all \c :TEST_DBNAME :ROLE_SUPERUSER -- debug point already enabled SELECT debug_waitpoint_enable('test_debug_point'); debug_waitpoint_enable ------------------------ \set ON_ERROR_STOP 0 SELECT debug_waitpoint_enable('test_debug_point'); ERROR: debug point "test_debug_point" already enabled \set ON_ERROR_STOP 1 SELECT debug_waitpoint_release('test_debug_point'); debug_waitpoint_release ------------------------- -- debug point not enabled \set ON_ERROR_STOP 0 SELECT debug_waitpoint_release('test_debug_point'); WARNING: you don't own a lock of type ExclusiveLock ERROR: cannot release debug point "test_debug_point" \set ON_ERROR_STOP 1 -- error injections -- CREATE OR REPLACE FUNCTION test_error_injection(TEXT) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_error_injection' LANGUAGE C VOLATILE STRICT; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT test_error_injection('test_error'); test_error_injection ---------------------- SELECT debug_waitpoint_enable('test_error'); debug_waitpoint_enable ------------------------ \set ON_ERROR_STOP 0 SELECT test_error_injection('test_error'); ERROR: error injected at debug point 'test_error' \set ON_ERROR_STOP 1 SELECT debug_waitpoint_release('test_error'); debug_waitpoint_release ------------------------- SELECT test_error_injection('test_error'); test_error_injection ---------------------- -- Test Scanner RESET ROLE; CREATE OR REPLACE FUNCTION test.scanner() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_scanner' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; SET ROLE :ROLE_DEFAULT_PERM_USER; -- Create two chunks to scan in the test CREATE TABLE hyper (time timestamptz, temp float); SELECT create_hypertable('hyper', 'time'); create_hypertable -------------------- (1,public,hyper,t) INSERT INTO hyper VALUES ('2021-01-01', 1.0), ('2022-01-01', 2.0); SELECT test.scanner(); NOTICE: 1. Scan: "_timescaledb_internal._hyper_1_1_chunk" NOTICE: 1. Scan: "_timescaledb_internal._hyper_1_2_chunk" NOTICE: 2. Scan with filter: "_timescaledb_internal._hyper_1_1_chunk" NOTICE: 3. ReScan: "_timescaledb_internal._hyper_1_2_chunk" NOTICE: 4. IndexScan: "_timescaledb_internal._hyper_1_2_chunk" scanner --------- -- Test errdata_to_jsonb RESET ROLE; CREATE OR REPLACE FUNCTION test.errdata_to_jsonb() RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_errdata_to_jsonb' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; SELECT test.errdata_to_jsonb(); errdata_to_jsonb ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"hint": "test error hint", "detail": "test error detail", "domain": "test error domain", "lineno": 123, "context": "test error context", "message": "test error message", "filename": "test error filename", "funcname": "test error function", "proc_name": "proc_name", "detail_log": "test error detail log", "sqlerrcode": "22023", "table_name": "test error table", "column_name": "test error column", "proc_schema": "proc_schema", "schema_name": "test error schema", "datatype_name": "test error datatype", "internalquery": "test error internal query", "context_domain": "test error context domain", "constraint_name": "test error constraint"} �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/timestamp-15.out���������������������������������������������������0000664�0000000�0000000�00000272735�15100345067�0021632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Utility function for grouping/slotting time with a given interval. CREATE OR REPLACE FUNCTION date_group( field timestamp, group_interval interval ) RETURNS timestamp LANGUAGE SQL STABLE AS $BODY$ SELECT to_timestamp((EXTRACT(EPOCH from $1)::int / EXTRACT(EPOCH from group_interval)::int) * EXTRACT(EPOCH from group_interval)::int)::timestamp; $BODY$; CREATE TABLE PUBLIC."testNs" ( "timeCustom" TIMESTAMP NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."testNs" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "testNs" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM create_hypertable('"public"."testNs"', 'timeCustom', 'device_id', 2, associated_schema_name=>'testNs' ); WARNING: column type "timestamp without time zone" used for "timeCustom" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | testNs | t \c :TEST_DBNAME INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 1), ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 2), ('2009-11-10T23:00:02+00:00', 'dev1', 2.5, 3); INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 1), ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 2); SELECT * FROM PUBLIC."testNs"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 1 | | Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 2 | | Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET client_min_messages = WARNING; \echo 'The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC' The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC SET timezone = 'UTC'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sun Sep 13 00:00:00 2009 | 8.5 SET timezone = 'EST'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sat Sep 12 19:00:00 2009 | 8.5 \echo 'The rest of the queries will be the same in output between UTC and EST' The rest of the queries will be the same in output between UTC and EST SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 SET timezone = 'UTC'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'EST'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 ------------------------------------ -- Test time conversion functions -- ------------------------------------ \set ON_ERROR_STOP 0 SET timezone = 'UTC'; -- Conversion to timestamp using Postgres built-in function taking -- double. Gives inaccurate result on Postgres <= 9.6.2. Accurate on -- Postgres >= 9.6.3. SELECT to_timestamp(1486480176.236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- extension-specific version taking microsecond UNIX timestamp SELECT _timescaledb_functions.to_timestamp(1486480176236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- Should be the inverse of the statement above. SELECT _timescaledb_functions.to_unix_microseconds('2017-02-07 15:09:36.236538+00'); to_unix_microseconds ---------------------- 1486480176236538 -- For timestamps, BIGINT MAX represents +Infinity and BIGINT MIN -- -Infinity. We keep this notion for UNIX epoch time: SELECT _timescaledb_functions.to_unix_microseconds('+infinity'); ERROR: invalid input syntax for type timestamp with time zone: "+infinity" at character 52 SELECT _timescaledb_functions.to_timestamp(9223372036854775807); to_timestamp -------------- infinity SELECT _timescaledb_functions.to_unix_microseconds('-infinity'); to_unix_microseconds ---------------------- -9223372036854775808 SELECT _timescaledb_functions.to_timestamp(-9223372036854775808); to_timestamp -------------- -infinity -- In UNIX microseconds, the largest bigint value below infinity -- (BIGINT MAX) is smaller than internal date upper bound and should -- therefore be OK. Further, converting to the internal postgres epoch -- cannot overflow a 64-bit INTEGER since the postgres epoch is at a -- later date compared to the UNIX epoch, and is therefore represented -- by a smaller number SELECT _timescaledb_functions.to_timestamp(9223372036854775806); to_timestamp --------------------------------------- Sun Jan 10 04:00:54.775806 294247 UTC -- Julian day zero is -210866803200000000 microseconds from UNIX epoch SELECT _timescaledb_functions.to_timestamp(-210866803200000000); to_timestamp --------------------------------- Mon Nov 24 00:00:00 4714 UTC BC \set VERBOSITY default -- Going beyond Julian day zero should give out-of-range error SELECT _timescaledb_functions.to_timestamp(-210866803200000001); ERROR: timestamp out of range -- Lower bound on date (should return the Julian day zero UNIX timestamp above) SELECT _timescaledb_functions.to_unix_microseconds('4714-11-24 00:00:00+00 BC'); to_unix_microseconds ---------------------- -210866803200000000 -- Going beyond lower bound on date should return out-of-range SELECT _timescaledb_functions.to_unix_microseconds('4714-11-23 23:59:59.999999+00 BC'); ERROR: timestamp out of range: "4714-11-23 23:59:59.999999+00 BC" LINE 1: ...ELECT _timescaledb_functions.to_unix_microseconds('4714-11-2... ^ -- The upper bound for Postgres TIMESTAMPTZ SELECT timestamp '294276-12-31 23:59:59.999999+00'; timestamp ----------------------------------- Sun Dec 31 23:59:59.999999 294276 -- Going beyond the upper bound, should fail SELECT timestamp '294276-12-31 23:59:59.999999+00' + interval '1 us'; ERROR: timestamp out of range -- Cannot represent the upper bound timestamp with a UNIX microsecond timestamp -- since the Postgres epoch is at a later date than the UNIX epoch. SELECT _timescaledb_functions.to_unix_microseconds('294276-12-31 23:59:59.999999+00'); ERROR: timestamp out of range -- Subtracting the difference between the two epochs (10957 days) should bring -- us within range. SELECT timestamp '294276-12-31 23:59:59.999999+00' - interval '10957 days'; ?column? ----------------------------------- Fri Jan 01 23:59:59.999999 294247 SELECT _timescaledb_functions.to_unix_microseconds('294247-01-01 23:59:59.999999'); to_unix_microseconds ---------------------- 9223371331199999999 -- Adding one microsecond should take us out-of-range again SELECT timestamp '294247-01-01 23:59:59.999999' + interval '1 us'; ?column? ---------------------------- Sat Jan 02 00:00:00 294247 SELECT _timescaledb_functions.to_unix_microseconds(timestamp '294247-01-01 23:59:59.999999' + interval '1 us'); ERROR: timestamp out of range --no time_bucketing of dates not by integer # of days SELECT time_bucket('1 hour', DATE '2012-01-01'); ERROR: interval must not have sub-day precision SELECT time_bucket('25 hour', DATE '2012-01-01'); ERROR: interval must be a multiple of a day \set ON_ERROR_STOP 1 SELECT time_bucket(INTERVAL '1 day', TIMESTAMP '2011-01-02 01:01:01'); time_bucket -------------------------- Sun Jan 02 00:00:00 2011 SELECT time, time_bucket(INTERVAL '2 day ', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-01 01:01:01', TIMESTAMP '2011-01-02 01:01:01', TIMESTAMP '2011-01-03 01:01:01', TIMESTAMP '2011-01-04 01:01:01' ]) AS time; time | time_bucket --------------------------+-------------------------- Sat Jan 01 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Sun Jan 02 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Mon Jan 03 01:01:01 2011 | Mon Jan 03 00:00:00 2011 Tue Jan 04 01:01:01 2011 | Mon Jan 03 00:00:00 2011 SELECT int_def, time_bucket(int_def,TIMESTAMP '2011-01-02 01:01:01.111') FROM unnest(ARRAY[ INTERVAL '1 millisecond', INTERVAL '1 second', INTERVAL '1 minute', INTERVAL '1 hour', INTERVAL '1 day', INTERVAL '2 millisecond', INTERVAL '2 second', INTERVAL '2 minute', INTERVAL '2 hour', INTERVAL '2 day' ]) AS int_def; int_def | time_bucket --------------+------------------------------ @ 0.001 secs | Sun Jan 02 01:01:01.111 2011 @ 1 sec | Sun Jan 02 01:01:01 2011 @ 1 min | Sun Jan 02 01:01:00 2011 @ 1 hour | Sun Jan 02 01:00:00 2011 @ 1 day | Sun Jan 02 00:00:00 2011 @ 0.002 secs | Sun Jan 02 01:01:01.11 2011 @ 2 secs | Sun Jan 02 01:01:00 2011 @ 2 mins | Sun Jan 02 01:00:00 2011 @ 2 hours | Sun Jan 02 00:00:00 2011 @ 2 days | Sat Jan 01 00:00:00 2011 \set ON_ERROR_STOP 0 SELECT time_bucket(INTERVAL '1 year 1d',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component SELECT time_bucket(INTERVAL '1 month 1 minute',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component \set ON_ERROR_STOP 1 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '1970-01-01 00:59:59.999999', TIMESTAMP '1970-01-01 01:01:00', TIMESTAMP '1970-01-01 01:04:59.999999', TIMESTAMP '1970-01-01 01:05:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Thu Jan 01 00:59:59.999999 1970 | Thu Jan 01 00:55:00 1970 Thu Jan 01 01:01:00 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:04:59.999999 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:05:00 1970 | Thu Jan 01 01:05:00 1970 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:04:59.999999', TIMESTAMP '2011-01-02 01:05:00', TIMESTAMP '2011-01-02 01:09:59.999999', TIMESTAMP '2011-01-02 01:10:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:04:59.999999 2011 | Sun Jan 02 01:00:00 2011 Sun Jan 02 01:05:00 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:09:59.999999 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:10:00 2011 | Sun Jan 02 01:10:00 2011 --offset with interval SELECT time, time_bucket(INTERVAL '5 minute', time , INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:02:59.999999', TIMESTAMP '2011-01-02 01:03:00', TIMESTAMP '2011-01-02 01:07:59.999999', TIMESTAMP '2011-01-02 01:08:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:02:59.999999 2011 | Sun Jan 02 00:58:00 2011 Sun Jan 02 01:03:00 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:07:59.999999 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:08:00 2011 | Sun Jan 02 01:08:00 2011 --offset with infinity -- timestamp SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp '-Infinity', timestamp 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- timestamptz SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- Date SELECT date, time_bucket(INTERVAL '1 week', date, INTERVAL '1 day') FROM unnest(ARRAY[ date '-Infinity', date 'Infinity' ]) AS date; date | time_bucket -----------+------------- -infinity | -infinity infinity | infinity --example to align with an origin SELECT time, time_bucket(INTERVAL '5 minute', time - (TIMESTAMP '2011-01-02 00:02:00' - TIMESTAMP 'epoch')) + (TIMESTAMP '2011-01-02 00:02:00'-TIMESTAMP 'epoch') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | ?column? ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 --rounding version SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2.5 minutes') + INTERVAL '2 minutes 30 seconds' FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:05:01', TIMESTAMP '2011-01-02 01:07:29', TIMESTAMP '2011-01-02 01:02:30', TIMESTAMP '2011-01-02 01:07:30', TIMESTAMP '2011-01-02 01:02:29' ]) AS time; time | ?column? --------------------------+-------------------------- Sun Jan 02 01:05:01 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:29 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:02:30 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:30 2011 | Sun Jan 02 01:10:00 2011 Sun Jan 02 01:02:29 2011 | Sun Jan 02 01:00:00 2011 --time_bucket with timezone should mimick date_trunc SET timezone TO 'UTC'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 01:00:00 2011 UTC | Sun Jan 02 01:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 23:00:00 2011 UTC | Sat Jan 01 23:00:00 2011 UTC SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 00:00:00 2011 UTC | Sat Jan 01 00:00:00 2011 UTC --what happens with a local tz SET timezone TO 'America/New_York'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 01:00:00 2011 EST | Sun Jan 02 01:00:00 2011 EST Sat Jan 01 19:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sat Jan 01 19:00:00 2011 EST Sat Jan 01 18:01:01 2011 EST | Sat Jan 01 18:00:00 2011 EST | Sat Jan 01 18:00:00 2011 EST --Note the timestamp tz input is aligned with UTC day /not/ local day. different than date_trunc. SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --can force local bucketing with simple cast. SELECT time, time_bucket(INTERVAL '1 day', time::timestamp), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+--------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 | Mon Jan 03 00:00:00 2011 EST --can also use interval to correct SELECT time, time_bucket(INTERVAL '1 day', time, -INTERVAL '19 hours'), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --dst: same local hour bucketed as two different hours. SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST | Sun Nov 05 01:00:00 2017 EST --local alignment changes when bucketing by UTC across dst boundary SELECT time, time_bucket(INTERVAL '2 hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 03:00:00 2017 EST --local alignment is preserved when bucketing by local time across DST boundary. SELECT time, time_bucket(INTERVAL '2 hour', time::timestamp) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+-------------------------- Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 00:00:00 2017 Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 02:00:00 2017 SELECT time, time_bucket(10::smallint, time) AS time_bucket_smallint, time_bucket(10::int, time) AS time_bucket_int, time_bucket(10::bigint, time) AS time_bucket_bigint FROM unnest(ARRAY[ '-11', '-10', '-9', '-1', '0', '1', '99', '100', '109', '110' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -11 | -20 | -20 | -20 -10 | -10 | -10 | -10 -9 | -10 | -10 | -10 -1 | -10 | -10 | -10 0 | 0 | 0 | 0 1 | 0 | 0 | 0 99 | 90 | 90 | 90 100 | 100 | 100 | 100 109 | 100 | 100 | 100 110 | 110 | 110 | 110 SELECT time, time_bucket(10::smallint, time, 2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, 2::int) AS time_bucket_int, time_bucket(10::bigint, time, 2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-9', '-8', '-7', '1', '2', '3', '101', '102', '111', '112' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -9 | -18 | -18 | -18 -8 | -8 | -8 | -8 -7 | -8 | -8 | -8 1 | -8 | -8 | -8 2 | 2 | 2 | 2 3 | 2 | 2 | 2 101 | 92 | 92 | 92 102 | 102 | 102 | 102 111 | 102 | 102 | 102 112 | 112 | 112 | 112 SELECT time, time_bucket(10::smallint, time, -2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, -2::int) AS time_bucket_int, time_bucket(10::bigint, time, -2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-13', '-12', '-11', '-3', '-2', '-1', '97', '98', '107', '108' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -13 | -22 | -22 | -22 -12 | -12 | -12 | -12 -11 | -12 | -12 | -12 -3 | -12 | -12 | -12 -2 | -2 | -2 | -2 -1 | -2 | -2 | -2 97 | 88 | 88 | 88 98 | 98 | 98 | 98 107 | 98 | 98 | 98 108 | 108 | 108 | 108 \set ON_ERROR_STOP 0 SELECT time_bucket(10::smallint, '-32768'::smallint); ERROR: timestamp out of range SELECT time_bucket(10::smallint, '-32761'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, 1000::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, '32767'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '32767'::smallint, '-32768'::smallint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::smallint, time) FROM unnest(ARRAY[ '-32760', '-32759', '32767' ]::smallint[]) AS time; time | time_bucket --------+------------- -32760 | -32760 -32759 | -32760 32767 | 32760 \set ON_ERROR_STOP 0 SELECT time_bucket(10::int, '-2147483648'::int); ERROR: timestamp out of range SELECT time_bucket(10::int, '-2147483641'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483000'::int, 1::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483648'::int, '2147483647'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '2147483647'::int, '-2147483648'::int); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::int, time) FROM unnest(ARRAY[ '-2147483640', '-2147483639', '2147483647' ]::int[]) AS time; time | time_bucket -------------+------------- -2147483640 | -2147483640 -2147483639 | -2147483640 2147483647 | 2147483640 \set ON_ERROR_STOP 0 SELECT time_bucket(10::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range SELECT time_bucket(10::bigint, '-9223372036854775801'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775000'::bigint, 1::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775808'::bigint, '9223372036854775807'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '9223372036854775807'::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::bigint, time) FROM unnest(ARRAY[ '-9223372036854775800', '-9223372036854775799', '9223372036854775807' ]::bigint[]) AS time; time | time_bucket ----------------------+---------------------- -9223372036854775800 | -9223372036854775800 -9223372036854775799 | -9223372036854775800 9223372036854775807 | 9223372036854775800 SELECT time, time_bucket(INTERVAL '1 day', time::date) FROM unnest(ARRAY[ date '2017-11-05', date '2017-11-06' ]) AS time; time | time_bucket ------------+------------- 11-05-2017 | 11-05-2017 11-06-2017 | 11-06-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date) FROM unnest(ARRAY[ date '2017-11-04', date '2017-11-05', date '2017-11-08', date '2017-11-09' ]) AS time; time | time_bucket ------------+------------- 11-04-2017 | 11-01-2017 11-05-2017 | 11-05-2017 11-08-2017 | 11-05-2017 11-09-2017 | 11-09-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date, INTERVAL '2 day') FROM unnest(ARRAY[ date '2017-11-06', date '2017-11-07', date '2017-11-10', date '2017-11-11' ]) AS time; time | time_bucket ------------+------------- 11-06-2017 | 11-03-2017 11-07-2017 | 11-07-2017 11-10-2017 | 11-07-2017 11-11-2017 | 11-11-2017 -- 2019-09-24 is a Monday, and we want to ensure that time_bucket returns the week starting with a Monday as date_trunc does, -- Rather than a Saturday which is the date of the PostgreSQL epoch SELECT time, time_bucket(INTERVAL '1 week', time::date) FROM unnest(ARRAY[ date '2018-09-16', date '2018-09-17', date '2018-09-23', date '2018-09-24' ]) AS time; time | time_bucket ------------+------------- 09-16-2018 | 09-10-2018 09-17-2018 | 09-17-2018 09-23-2018 | 09-17-2018 09-24-2018 | 09-24-2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '2018-09-16', timestamp without time zone '2018-09-17', timestamp without time zone '2018-09-23', timestamp without time zone '2018-09-24' ]) AS time; time | time_bucket --------------------------+-------------------------- Sun Sep 16 00:00:00 2018 | Mon Sep 10 00:00:00 2018 Mon Sep 17 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Sun Sep 23 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Mon Sep 24 00:00:00 2018 | Mon Sep 24 00:00:00 2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '2018-09-16', timestamp with time zone '2018-09-17', timestamp with time zone '2018-09-23', timestamp with time zone '2018-09-24' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sun Sep 16 00:00:00 2018 EDT | Sun Sep 09 20:00:00 2018 EDT Mon Sep 17 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Sun Sep 23 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Mon Sep 24 00:00:00 2018 EDT | Sun Sep 23 20:00:00 2018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '-Infinity', timestamp without time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '4714-11-24 01:01:01.0 BC', timestamp without time zone '294276-12-31 23:59:59.9999' ]) AS time; time | time_bucket | ?column? ---------------------------------+-----------------------------+---------- Mon Nov 24 01:01:01 4714 BC | Mon Nov 24 00:00:00 4714 BC | t Sun Dec 31 23:59:59.9999 294276 | Mon Dec 25 00:00:00 294276 | t --1000 years later weeks still align. SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-20', timestamp without time zone '3018-09-21', timestamp without time zone '3018-09-22' ]) AS time; time | time_bucket | ?column? --------------------------+--------------------------+---------- Mon Sep 14 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Sun Sep 20 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Mon Sep 21 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t Tue Sep 22 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t --weeks align for timestamptz as well if cast to local time, (but not if done at UTC). SELECT time, date_trunc('week', time) = time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time::timestamp) FROM unnest(ARRAY[ timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-20', timestamp with time zone '3018-09-21', timestamp with time zone '3018-09-22' ]) AS time; time | ?column? | ?column? ------------------------------+----------+---------- Mon Sep 14 00:00:00 3018 EDT | f | t Sun Sep 20 00:00:00 3018 EDT | f | t Mon Sep 21 00:00:00 3018 EDT | f | t Tue Sep 22 00:00:00 3018 EDT | f | t --check functions with origin --note that the default origin is at 0 UTC, using origin parameter it is easy to provide a EDT origin point \x SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time::timestamp) no_epoch_local, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-03 00:00:00+0') always_true, time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamptz 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp with time zone '2000-01-01 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-01 00:00:00+0', timestamp with time zone '2000-01-03 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-03 00:00:00+0', timestamp with time zone '2000-01-01', timestamp with time zone '2000-01-02', timestamp with time zone '2000-01-03', timestamp with time zone '3018-09-12', timestamp with time zone '3018-09-13', timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]--+----------------------------- time | Fri Dec 31 18:59:59 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 24 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 2 ]--+----------------------------- time | Fri Dec 31 19:00:00 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 3 ]--+----------------------------- time | Sun Jan 02 18:59:59 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 4 ]--+----------------------------- time | Sun Jan 02 19:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 5 ]--+----------------------------- time | Sat Jan 01 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 6 ]--+----------------------------- time | Sun Jan 02 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 7 ]--+----------------------------- time | Mon Jan 03 00:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Jan 02 23:00:00 2000 EST -[ RECORD 8 ]--+----------------------------- time | Sat Sep 12 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 06 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 9 ]--+----------------------------- time | Sun Sep 13 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 10 ]-+----------------------------- time | Mon Sep 14 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT -[ RECORD 11 ]-+----------------------------- time | Tue Sep 15 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamp '2000-01-03 00:00:00') always_true, time_bucket(INTERVAL '1 week', time, timestamp '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamp 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp without time zone '2000-01-01 00:00:00'- interval '1 second', timestamp without time zone '2000-01-01 00:00:00', timestamp without time zone '2000-01-03 00:00:00'- interval '1 second', timestamp without time zone '2000-01-03 00:00:00', timestamp without time zone '2000-01-01', timestamp without time zone '2000-01-02', timestamp without time zone '2000-01-03', timestamp without time zone '3018-09-12', timestamp without time zone '3018-09-13', timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]------------------------- time | Fri Dec 31 23:59:59 1999 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Dec 25 00:00:00 1999 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 2 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 3 ]------------------------- time | Sun Jan 02 23:59:59 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 4 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 5 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 6 ]------------------------- time | Sun Jan 02 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 7 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 8 ]------------------------- time | Sat Sep 12 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 06 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 9 ]------------------------- time | Sun Sep 13 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 10 ]------------------------ time | Mon Sep 14 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 -[ RECORD 11 ]------------------------ time | Tue Sep 15 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, date '2000-01-03') always_true, time_bucket(INTERVAL '1 week', time, date '2000-01-01') pg_epoch, time_bucket(INTERVAL '1 week', time, (timestamp 'epoch')::date) unix_epoch, time_bucket(INTERVAL '1 week', time, date '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, date '3018-09-14') custom_2 FROM unnest(ARRAY[ date '1999-12-31', date '2000-01-01', date '2000-01-02', date '2000-01-03', date '3018-09-12', date '3018-09-13', date '3018-09-14', date '3018-09-15' ]) AS time; -[ RECORD 1 ]----------- time | 12-31-1999 no_epoch | 12-27-1999 always_true | t pg_epoch | 12-25-1999 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 2 ]----------- time | 01-01-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 3 ]----------- time | 01-02-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 12-27-1999 -[ RECORD 4 ]----------- time | 01-03-2000 no_epoch | 01-03-2000 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 01-03-2000 -[ RECORD 5 ]----------- time | 09-12-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-06-3018 custom_2 | 09-07-3018 -[ RECORD 6 ]----------- time | 09-13-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-07-3018 -[ RECORD 7 ]----------- time | 09-14-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 -[ RECORD 8 ]----------- time | 09-15-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 \x --really old origin works if date around that time SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC', timestamp without time zone '4710-11-25 01:01:01.0 BC', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket -----------------------------+----------------------------- Sat Nov 24 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Sun Nov 25 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Mon Jan 01 00:00:00 2001 | Sat Dec 30 01:01:01 2000 Thu Jan 01 00:00:00 3001 | Sat Dec 27 01:01:01 3000 SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '294270-12-30 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '294270-12-29 23:59:59.9999', timestamp without time zone '294270-12-30 23:59:59.9999', timestamp without time zone '294270-12-31 23:59:59.9999', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket ---------------------------------+--------------------------------- Thu Dec 29 23:59:59.9999 294270 | Fri Dec 23 23:59:59.9999 294270 Fri Dec 30 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Sat Dec 31 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Mon Jan 01 00:00:00 2001 | Fri Dec 29 23:59:59.9999 2000 Thu Jan 01 00:00:00 3001 | Fri Dec 26 23:59:59.9999 3000 \set ON_ERROR_STOP 0 --really old origin + very new data + long period errors SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '294270-12-31 23:59:59.9999' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp with time zone '4710-11-25 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp with time zone '294270-12-30 23:59:59.9999' ]) AS time; ERROR: timestamp out of range --really high origin + old data + long period errors out SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp without time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp with time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp with time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range \set ON_ERROR_STOP 1 ------------------------------------------- --- Test time_bucket with month periods --- ------------------------------------------- SET datestyle TO ISO; SELECT time::date, time_bucket('1 month', time::date) AS "1m", time_bucket('2 month', time::date) AS "2m", time_bucket('3 month', time::date) AS "3m", time_bucket('1 month', time::date, '2000-02-01'::date) AS "1m origin", time_bucket('2 month', time::date, '2000-02-01'::date) AS "2m origin", time_bucket('3 month', time::date, '2000-02-01'::date) AS "3m origin" FROM generate_series('1990-01-03'::date,'1990-06-03'::date,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------+------------+------------+------------+------------+------------+------------ 1990-01-03 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1989-12-01 | 1989-11-01 1990-02-03 | 1990-02-01 | 1990-01-01 | 1990-01-01 | 1990-02-01 | 1990-02-01 | 1990-02-01 1990-03-03 | 1990-03-01 | 1990-03-01 | 1990-01-01 | 1990-03-01 | 1990-02-01 | 1990-02-01 1990-04-03 | 1990-04-01 | 1990-03-01 | 1990-04-01 | 1990-04-01 | 1990-04-01 | 1990-02-01 1990-05-03 | 1990-05-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 1990-06-03 | 1990-06-01 | 1990-05-01 | 1990-04-01 | 1990-06-01 | 1990-06-01 | 1990-05-01 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamp) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamp) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamp) AS "3m origin" FROM generate_series('1990-01-03'::timestamp,'1990-06-03'::timestamp,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+--------------------- 1990-01-03 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1989-12-01 00:00:00 | 1989-11-01 00:00:00 1990-02-03 00:00:00 | 1990-02-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-03-03 00:00:00 | 1990-03-01 00:00:00 | 1990-03-01 00:00:00 | 1990-01-01 00:00:00 | 1990-03-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-04-03 00:00:00 | 1990-04-01 00:00:00 | 1990-03-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-02-01 00:00:00 1990-05-03 00:00:00 | 1990-05-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 1990-06-03 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-06-01 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamptz) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamptz) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamptz) AS "3m origin" FROM generate_series('1990-01-03'::timestamptz,'1990-06-03'::timestamptz,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1990-01-03 00:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-11-30 19:00:00-05 | 1989-10-31 19:00:00-05 1990-02-03 00:00:00-05 | 1990-01-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-03-03 00:00:00-05 | 1990-02-28 19:00:00-05 | 1990-02-28 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-04-03 00:00:00-04 | 1990-03-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-05-03 00:00:00-04 | 1990-04-30 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 1990-06-03 00:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-05-31 20:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 --------------------------------------- --- Test time_bucket with timezones --- --------------------------------------- -- test NULL args SELECT time_bucket(NULL::interval,now(),'Europe/Berlin'), time_bucket('1day',NULL::timestamptz,'Europe/Berlin'), time_bucket('1day',now(),NULL::text), time_bucket('1day','2020-02-03','Europe/Berlin',NULL), time_bucket('1day','2020-02-03','Europe/Berlin','2020-04-01',NULL), time_bucket('1day','2020-02-03','Europe/Berlin',NULL,NULL), time_bucket('1day','2020-02-03','Europe/Berlin',"offset":=NULL::interval), time_bucket('1day','2020-02-03','Europe/Berlin',origin:=NULL::timestamptz); time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket -------------+-------------+-------------+------------------------+------------------------+------------------------+------------------------+------------------------ | | | 2020-02-02 18:00:00-05 | 2020-02-03 00:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 SET datestyle TO ISO; SELECT time_bucket('1day', ts) AS "UTC", time_bucket('1day', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1day', ts, 'Europe/London') AS "London", time_bucket('1day', ts, 'America/New_York') AS "New York", time_bucket('1day', ts, 'PST') AS "PST", time_bucket('1day', ts, current_setting('timezone')) AS "current" FROM generate_series('1999-12-31 17:00'::timestamptz,'2000-01-02 3:00'::timestamptz, '1hour'::interval) ts; UTC | Berlin | London | New York | PST | current ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-12-30 19:00:00-05 | 1999-12-30 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-30 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 2000-01-01 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-02 03:00:00-05 | 2000-01-02 00:00:00-05 SELECT time_bucket('1month', ts) AS "UTC", time_bucket('1month', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1month', ts, 'America/New_York') AS "New York", time_bucket('1month', ts, current_setting('timezone')) AS "current", time_bucket('2month', ts, current_setting('timezone')) AS "2m", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp) AS "2m origin", time_bucket('2month', ts, current_setting('timezone'), "offset":='14 day'::interval) AS "2m offset", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp, '7 day'::interval) AS "2m offset + origin" FROM generate_series('1999-12-01'::timestamptz,'2000-09-01'::timestamptz, '9 day'::interval) ts; UTC | Berlin | New York | current | 2m | 2m origin | 2m offset | 2m offset + origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-10-08 00:00:00-04 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 RESET datestyle; ------------------------------------------------------------ --- Test timescaledb_experimental.time_bucket_ng function -- ------------------------------------------------------------ -- not supported functionality \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 hour', '2001-02-03' :: date) AS result; ERROR: interval must be either days and weeks, or months and years SELECT timescaledb_experimental.time_bucket_ng('0 days', '2001-02-03' :: date) AS result; ERROR: interval must be at least one day SELECT timescaledb_experimental.time_bucket_ng('1 month', '2001-02-03' :: date, origin => '2000-01-02') AS result; ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. SELECT timescaledb_experimental.time_bucket_ng('1 month', '2000-01-02' :: date, origin => '2001-01-01') AS result; result ------------ 01-01-2000 SELECT timescaledb_experimental.time_bucket_ng('1 day', '2000-01-02' :: date, origin => '2001-01-01') AS result; ERROR: origin must be before the given date SELECT timescaledb_experimental.time_bucket_ng('1 month 3 hours', '2021-11-22' :: timestamp) AS result; ERROR: interval can't combine months with minutes or hours -- timestamp is less than the default 'origin' value SELECT timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, timezone => 'MSK'); ERROR: origin must be before the given date -- 'origin' in Europe/Moscow timezone is not the first day of the month at given time zone (UTC in this case) select timescaledb_experimental.time_bucket_ng('1 month', '2021-07-12 12:34:56 Europe/Moscow' :: timestamptz, origin => '2021-06-01 00:00:00 Europe/Moscow' :: timestamptz, timezone => 'UTC'); ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. \set ON_ERROR_STOP 1 -- wrappers SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp) AS result; result -------------------------- Fri Jan 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz) AS result; result ------------------------------ Fri Jan 01 00:00:00 2021 EST SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp, origin => '2021-06-01') AS result; result -------------------------- Tue Jun 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz, origin => '2021-06-01') AS result; result ------------------------------ Tue Jun 01 00:00:00 2021 EDT -- null argument SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, timezone => 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null interval SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null, timezone => 'Europe/Moscow') AS result; result -------- -- infinity argument SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, timezone => 'Europe/Moscow') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity -- infinite origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity -- test for invalid timezone argument SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => null) AS result; result -------- \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => 'Europe/Ololondon') AS result; ERROR: time zone "Europe/Ololondon" not recognized \set ON_ERROR_STOP 1 -- Make sure time_bucket_ng() supports seconds, minutes, and hours. -- We happen to know that the internal implementation is the same -- as for time_bucket(), thus there is no reason to execute all the tests -- we already have for time_bucket(). These two functions will most likely -- be merged eventually anyway. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:30:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:00:00 2021 -- Same as above, but with provided 'origin' argument. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:25:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:10:00 2021 -- N days / weeks buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2019-12-31 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-02 | 2020-01-02 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-03 | 2020-01-03 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-06 | 2020-01-06 | 2020-01-06 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-07 | 2020-01-07 | 2020-01-06 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-08 | 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-09 | 2020-01-09 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-04 | 2020-01-04 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-10 | 2020-01-11 | 2020-01-04 2020-01-12 | 2020-01-12 | 2020-01-12 | 2020-01-10 | 2020-01-11 | 2020-01-04 -- N days / weeks buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-02 | 2020-01-02 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-03 | 2020-01-03 | 2020-01-03 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-04 | 2020-01-04 | 2020-01-03 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-05 | 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-06 | 2020-01-06 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-01 | 2020-01-01 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-09 | 2020-01-09 | 2020-01-09 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-10 | 2020-01-10 | 2020-01-09 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-11 | 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-12 | 2020-01-12 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 -- N month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-04-01 | 2020-01-01 | 2020-01-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-01-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-06-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-07-01 | 2020-09-01 | 2020-06-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-10-01 | 2020-09-01 | 2020-06-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 -- N month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2019-11-01 | 2020-01-01 | 2019-10-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-02-01 | 2020-01-01 | 2019-10-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-08-01 | 2020-05-01 | 2020-08-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 -- N years / N years, M month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2015-07-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2016-01-01 | 2016-01-01 | 2015-01-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2016-07-01 | 2016-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-01-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-07-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2017-07-01 | 2015-01-01 2018-01-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2018-07-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-01-01 | 2019-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-07-01 | 2019-01-01 | 2019-07-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2020-01-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 2020-07-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 -- N years / N years, M month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2014-06-01 | 2013-12-01 | 2014-06-01 | 2012-12-01 | 2012-06-01 2015-07-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-01-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-07-01 | 2016-06-01 | 2015-06-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-01-01 | 2016-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-07-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2018-01-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2017-12-01 | 2015-06-01 2018-07-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-01-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-07-01 | 2019-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-01-01 | 2019-06-01 | 2019-12-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-07-01 | 2020-06-01 | 2019-12-01 | 2020-06-01 | 2020-06-01 | 2018-06-01 -- Test timezones support with different bucket sizes BEGIN; -- Timestamptz type is displayed in the session timezone. -- To get consistent results during the test we temporary set the session -- timezone to the known one. SET TIME ZONE '+00'; -- Moscow is UTC+3 in the year 2021. Let's say you are dealing with '1 day' bucket. -- In order to calculate the beginning of the bucket you have to take LOCAL -- Moscow time and throw away the time. You will get the midnight. The new day -- starts 3 hours EARLIER in Moscow than in UTC+0 time zone, thus resulting -- timestamp will be 3 hours LESS than for UTC+0. SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow', 'UTC']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-04-30 21:00:00 +00 1 year | Europe/Moscow | 2020-12-31 21:00:00 +00 12 hours | UTC | 2021-07-12 00:00:00 +00 1 day | UTC | 2021-07-12 00:00:00 +00 1 month | UTC | 2021-07-01 00:00:00 +00 4 months | UTC | 2021-05-01 00:00:00 +00 1 year | UTC | 2021-01-01 00:00:00 +00 -- Same as above, but with 'origin' SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array['2021-06-01 00:00:00 Europe/Moscow' :: timestamptz]) as origin_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, origin => origin_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-05-31 21:00:00 +00 1 year | Europe/Moscow | 2021-05-31 21:00:00 +00 -- Overwritten origin allows to work with dates earlier than the default origin SELECT to_char(timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, origin => '1900-01-01 00:00:00 MSK', timezone => 'MSK'), 'YYYY-MM-DD HH24:MI:SS TZ'); to_char ------------------------- 1998-12-31 21:00:00 +00 -- Restore previously used time zone. ROLLBACK; ------------------------------------- --- Test time input functions -- ------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.interval_to_internal(coltype REGTYPE, value ANYELEMENT = NULL::BIGINT) RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_dimension_interval_to_internal_test' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT test.interval_to_internal('TIMESTAMP'::regtype, INTERVAL '1 day'); interval_to_internal ---------------------- 86400000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400000000); interval_to_internal ---------------------- 86400000000 ---should give warning SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400); WARNING: unexpected interval: smaller than one second HINT: The interval is specified in microseconds. interval_to_internal ---------------------- 86400 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('BIGINT'::regtype, 2147483649::bigint); interval_to_internal ---------------------- 2147483649 -- Default interval for integer is supported as part of -- hypertable generalization SELECT test.interval_to_internal('INT'::regtype); interval_to_internal ---------------------- 100000 SELECT test.interval_to_internal('SMALLINT'::regtype); interval_to_internal ---------------------- 10000 SELECT test.interval_to_internal('BIGINT'::regtype); interval_to_internal ---------------------- 1000000 SELECT test.interval_to_internal('TIMESTAMPTZ'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('DATE'::regtype); interval_to_internal ---------------------- 604800000000 \set VERBOSITY terse \set ON_ERROR_STOP 0 SELECT test.interval_to_internal('INT'::regtype, 2147483649::bigint); ERROR: invalid interval: must be between 1 and 2147483647 SELECT test.interval_to_internal('SMALLINT'::regtype, 32768::bigint); ERROR: invalid interval: must be between 1 and 32767 SELECT test.interval_to_internal('TEXT'::regtype, 32768::bigint); ERROR: invalid type for dimension "testcol" SELECT test.interval_to_internal('INT'::regtype, INTERVAL '1 day'); ERROR: invalid interval type for integer dimension \set ON_ERROR_STOP 1 �����������������������������������timescaledb-2.23.0/test/expected/timestamp-16.out���������������������������������������������������0000664�0000000�0000000�00000272706�15100345067�0021631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Utility function for grouping/slotting time with a given interval. CREATE OR REPLACE FUNCTION date_group( field timestamp, group_interval interval ) RETURNS timestamp LANGUAGE SQL STABLE AS $BODY$ SELECT to_timestamp((EXTRACT(EPOCH from $1)::int / EXTRACT(EPOCH from group_interval)::int) * EXTRACT(EPOCH from group_interval)::int)::timestamp; $BODY$; CREATE TABLE PUBLIC."testNs" ( "timeCustom" TIMESTAMP NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."testNs" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "testNs" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM create_hypertable('"public"."testNs"', 'timeCustom', 'device_id', 2, associated_schema_name=>'testNs' ); WARNING: column type "timestamp without time zone" used for "timeCustom" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | testNs | t \c :TEST_DBNAME INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 1), ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 2), ('2009-11-10T23:00:02+00:00', 'dev1', 2.5, 3); INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 1), ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 2); SELECT * FROM PUBLIC."testNs"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 1 | | Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 2 | | Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET client_min_messages = WARNING; \echo 'The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC' The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC SET timezone = 'UTC'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sun Sep 13 00:00:00 2009 | 8.5 SET timezone = 'EST'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sat Sep 12 19:00:00 2009 | 8.5 \echo 'The rest of the queries will be the same in output between UTC and EST' The rest of the queries will be the same in output between UTC and EST SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 SET timezone = 'UTC'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'EST'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 ------------------------------------ -- Test time conversion functions -- ------------------------------------ \set ON_ERROR_STOP 0 SET timezone = 'UTC'; -- Conversion to timestamp using Postgres built-in function taking -- double. Gives inaccurate result on Postgres <= 9.6.2. Accurate on -- Postgres >= 9.6.3. SELECT to_timestamp(1486480176.236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- extension-specific version taking microsecond UNIX timestamp SELECT _timescaledb_functions.to_timestamp(1486480176236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- Should be the inverse of the statement above. SELECT _timescaledb_functions.to_unix_microseconds('2017-02-07 15:09:36.236538+00'); to_unix_microseconds ---------------------- 1486480176236538 -- For timestamps, BIGINT MAX represents +Infinity and BIGINT MIN -- -Infinity. We keep this notion for UNIX epoch time: SELECT _timescaledb_functions.to_unix_microseconds('+infinity'); to_unix_microseconds ---------------------- 9223372036854775807 SELECT _timescaledb_functions.to_timestamp(9223372036854775807); to_timestamp -------------- infinity SELECT _timescaledb_functions.to_unix_microseconds('-infinity'); to_unix_microseconds ---------------------- -9223372036854775808 SELECT _timescaledb_functions.to_timestamp(-9223372036854775808); to_timestamp -------------- -infinity -- In UNIX microseconds, the largest bigint value below infinity -- (BIGINT MAX) is smaller than internal date upper bound and should -- therefore be OK. Further, converting to the internal postgres epoch -- cannot overflow a 64-bit INTEGER since the postgres epoch is at a -- later date compared to the UNIX epoch, and is therefore represented -- by a smaller number SELECT _timescaledb_functions.to_timestamp(9223372036854775806); to_timestamp --------------------------------------- Sun Jan 10 04:00:54.775806 294247 UTC -- Julian day zero is -210866803200000000 microseconds from UNIX epoch SELECT _timescaledb_functions.to_timestamp(-210866803200000000); to_timestamp --------------------------------- Mon Nov 24 00:00:00 4714 UTC BC \set VERBOSITY default -- Going beyond Julian day zero should give out-of-range error SELECT _timescaledb_functions.to_timestamp(-210866803200000001); ERROR: timestamp out of range -- Lower bound on date (should return the Julian day zero UNIX timestamp above) SELECT _timescaledb_functions.to_unix_microseconds('4714-11-24 00:00:00+00 BC'); to_unix_microseconds ---------------------- -210866803200000000 -- Going beyond lower bound on date should return out-of-range SELECT _timescaledb_functions.to_unix_microseconds('4714-11-23 23:59:59.999999+00 BC'); ERROR: timestamp out of range: "4714-11-23 23:59:59.999999+00 BC" LINE 1: ...ELECT _timescaledb_functions.to_unix_microseconds('4714-11-2... ^ -- The upper bound for Postgres TIMESTAMPTZ SELECT timestamp '294276-12-31 23:59:59.999999+00'; timestamp ----------------------------------- Sun Dec 31 23:59:59.999999 294276 -- Going beyond the upper bound, should fail SELECT timestamp '294276-12-31 23:59:59.999999+00' + interval '1 us'; ERROR: timestamp out of range -- Cannot represent the upper bound timestamp with a UNIX microsecond timestamp -- since the Postgres epoch is at a later date than the UNIX epoch. SELECT _timescaledb_functions.to_unix_microseconds('294276-12-31 23:59:59.999999+00'); ERROR: timestamp out of range -- Subtracting the difference between the two epochs (10957 days) should bring -- us within range. SELECT timestamp '294276-12-31 23:59:59.999999+00' - interval '10957 days'; ?column? ----------------------------------- Fri Jan 01 23:59:59.999999 294247 SELECT _timescaledb_functions.to_unix_microseconds('294247-01-01 23:59:59.999999'); to_unix_microseconds ---------------------- 9223371331199999999 -- Adding one microsecond should take us out-of-range again SELECT timestamp '294247-01-01 23:59:59.999999' + interval '1 us'; ?column? ---------------------------- Sat Jan 02 00:00:00 294247 SELECT _timescaledb_functions.to_unix_microseconds(timestamp '294247-01-01 23:59:59.999999' + interval '1 us'); ERROR: timestamp out of range --no time_bucketing of dates not by integer # of days SELECT time_bucket('1 hour', DATE '2012-01-01'); ERROR: interval must not have sub-day precision SELECT time_bucket('25 hour', DATE '2012-01-01'); ERROR: interval must be a multiple of a day \set ON_ERROR_STOP 1 SELECT time_bucket(INTERVAL '1 day', TIMESTAMP '2011-01-02 01:01:01'); time_bucket -------------------------- Sun Jan 02 00:00:00 2011 SELECT time, time_bucket(INTERVAL '2 day ', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-01 01:01:01', TIMESTAMP '2011-01-02 01:01:01', TIMESTAMP '2011-01-03 01:01:01', TIMESTAMP '2011-01-04 01:01:01' ]) AS time; time | time_bucket --------------------------+-------------------------- Sat Jan 01 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Sun Jan 02 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Mon Jan 03 01:01:01 2011 | Mon Jan 03 00:00:00 2011 Tue Jan 04 01:01:01 2011 | Mon Jan 03 00:00:00 2011 SELECT int_def, time_bucket(int_def,TIMESTAMP '2011-01-02 01:01:01.111') FROM unnest(ARRAY[ INTERVAL '1 millisecond', INTERVAL '1 second', INTERVAL '1 minute', INTERVAL '1 hour', INTERVAL '1 day', INTERVAL '2 millisecond', INTERVAL '2 second', INTERVAL '2 minute', INTERVAL '2 hour', INTERVAL '2 day' ]) AS int_def; int_def | time_bucket --------------+------------------------------ @ 0.001 secs | Sun Jan 02 01:01:01.111 2011 @ 1 sec | Sun Jan 02 01:01:01 2011 @ 1 min | Sun Jan 02 01:01:00 2011 @ 1 hour | Sun Jan 02 01:00:00 2011 @ 1 day | Sun Jan 02 00:00:00 2011 @ 0.002 secs | Sun Jan 02 01:01:01.11 2011 @ 2 secs | Sun Jan 02 01:01:00 2011 @ 2 mins | Sun Jan 02 01:00:00 2011 @ 2 hours | Sun Jan 02 00:00:00 2011 @ 2 days | Sat Jan 01 00:00:00 2011 \set ON_ERROR_STOP 0 SELECT time_bucket(INTERVAL '1 year 1d',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component SELECT time_bucket(INTERVAL '1 month 1 minute',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component \set ON_ERROR_STOP 1 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '1970-01-01 00:59:59.999999', TIMESTAMP '1970-01-01 01:01:00', TIMESTAMP '1970-01-01 01:04:59.999999', TIMESTAMP '1970-01-01 01:05:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Thu Jan 01 00:59:59.999999 1970 | Thu Jan 01 00:55:00 1970 Thu Jan 01 01:01:00 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:04:59.999999 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:05:00 1970 | Thu Jan 01 01:05:00 1970 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:04:59.999999', TIMESTAMP '2011-01-02 01:05:00', TIMESTAMP '2011-01-02 01:09:59.999999', TIMESTAMP '2011-01-02 01:10:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:04:59.999999 2011 | Sun Jan 02 01:00:00 2011 Sun Jan 02 01:05:00 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:09:59.999999 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:10:00 2011 | Sun Jan 02 01:10:00 2011 --offset with interval SELECT time, time_bucket(INTERVAL '5 minute', time , INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:02:59.999999', TIMESTAMP '2011-01-02 01:03:00', TIMESTAMP '2011-01-02 01:07:59.999999', TIMESTAMP '2011-01-02 01:08:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:02:59.999999 2011 | Sun Jan 02 00:58:00 2011 Sun Jan 02 01:03:00 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:07:59.999999 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:08:00 2011 | Sun Jan 02 01:08:00 2011 --offset with infinity -- timestamp SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp '-Infinity', timestamp 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- timestamptz SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- Date SELECT date, time_bucket(INTERVAL '1 week', date, INTERVAL '1 day') FROM unnest(ARRAY[ date '-Infinity', date 'Infinity' ]) AS date; date | time_bucket -----------+------------- -infinity | -infinity infinity | infinity --example to align with an origin SELECT time, time_bucket(INTERVAL '5 minute', time - (TIMESTAMP '2011-01-02 00:02:00' - TIMESTAMP 'epoch')) + (TIMESTAMP '2011-01-02 00:02:00'-TIMESTAMP 'epoch') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | ?column? ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 --rounding version SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2.5 minutes') + INTERVAL '2 minutes 30 seconds' FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:05:01', TIMESTAMP '2011-01-02 01:07:29', TIMESTAMP '2011-01-02 01:02:30', TIMESTAMP '2011-01-02 01:07:30', TIMESTAMP '2011-01-02 01:02:29' ]) AS time; time | ?column? --------------------------+-------------------------- Sun Jan 02 01:05:01 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:29 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:02:30 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:30 2011 | Sun Jan 02 01:10:00 2011 Sun Jan 02 01:02:29 2011 | Sun Jan 02 01:00:00 2011 --time_bucket with timezone should mimick date_trunc SET timezone TO 'UTC'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 01:00:00 2011 UTC | Sun Jan 02 01:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 23:00:00 2011 UTC | Sat Jan 01 23:00:00 2011 UTC SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 00:00:00 2011 UTC | Sat Jan 01 00:00:00 2011 UTC --what happens with a local tz SET timezone TO 'America/New_York'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 01:00:00 2011 EST | Sun Jan 02 01:00:00 2011 EST Sat Jan 01 19:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sat Jan 01 19:00:00 2011 EST Sat Jan 01 18:01:01 2011 EST | Sat Jan 01 18:00:00 2011 EST | Sat Jan 01 18:00:00 2011 EST --Note the timestamp tz input is aligned with UTC day /not/ local day. different than date_trunc. SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --can force local bucketing with simple cast. SELECT time, time_bucket(INTERVAL '1 day', time::timestamp), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+--------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 | Mon Jan 03 00:00:00 2011 EST --can also use interval to correct SELECT time, time_bucket(INTERVAL '1 day', time, -INTERVAL '19 hours'), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --dst: same local hour bucketed as two different hours. SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST | Sun Nov 05 01:00:00 2017 EST --local alignment changes when bucketing by UTC across dst boundary SELECT time, time_bucket(INTERVAL '2 hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 03:00:00 2017 EST --local alignment is preserved when bucketing by local time across DST boundary. SELECT time, time_bucket(INTERVAL '2 hour', time::timestamp) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+-------------------------- Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 00:00:00 2017 Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 02:00:00 2017 SELECT time, time_bucket(10::smallint, time) AS time_bucket_smallint, time_bucket(10::int, time) AS time_bucket_int, time_bucket(10::bigint, time) AS time_bucket_bigint FROM unnest(ARRAY[ '-11', '-10', '-9', '-1', '0', '1', '99', '100', '109', '110' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -11 | -20 | -20 | -20 -10 | -10 | -10 | -10 -9 | -10 | -10 | -10 -1 | -10 | -10 | -10 0 | 0 | 0 | 0 1 | 0 | 0 | 0 99 | 90 | 90 | 90 100 | 100 | 100 | 100 109 | 100 | 100 | 100 110 | 110 | 110 | 110 SELECT time, time_bucket(10::smallint, time, 2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, 2::int) AS time_bucket_int, time_bucket(10::bigint, time, 2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-9', '-8', '-7', '1', '2', '3', '101', '102', '111', '112' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -9 | -18 | -18 | -18 -8 | -8 | -8 | -8 -7 | -8 | -8 | -8 1 | -8 | -8 | -8 2 | 2 | 2 | 2 3 | 2 | 2 | 2 101 | 92 | 92 | 92 102 | 102 | 102 | 102 111 | 102 | 102 | 102 112 | 112 | 112 | 112 SELECT time, time_bucket(10::smallint, time, -2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, -2::int) AS time_bucket_int, time_bucket(10::bigint, time, -2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-13', '-12', '-11', '-3', '-2', '-1', '97', '98', '107', '108' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -13 | -22 | -22 | -22 -12 | -12 | -12 | -12 -11 | -12 | -12 | -12 -3 | -12 | -12 | -12 -2 | -2 | -2 | -2 -1 | -2 | -2 | -2 97 | 88 | 88 | 88 98 | 98 | 98 | 98 107 | 98 | 98 | 98 108 | 108 | 108 | 108 \set ON_ERROR_STOP 0 SELECT time_bucket(10::smallint, '-32768'::smallint); ERROR: timestamp out of range SELECT time_bucket(10::smallint, '-32761'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, 1000::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, '32767'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '32767'::smallint, '-32768'::smallint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::smallint, time) FROM unnest(ARRAY[ '-32760', '-32759', '32767' ]::smallint[]) AS time; time | time_bucket --------+------------- -32760 | -32760 -32759 | -32760 32767 | 32760 \set ON_ERROR_STOP 0 SELECT time_bucket(10::int, '-2147483648'::int); ERROR: timestamp out of range SELECT time_bucket(10::int, '-2147483641'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483000'::int, 1::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483648'::int, '2147483647'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '2147483647'::int, '-2147483648'::int); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::int, time) FROM unnest(ARRAY[ '-2147483640', '-2147483639', '2147483647' ]::int[]) AS time; time | time_bucket -------------+------------- -2147483640 | -2147483640 -2147483639 | -2147483640 2147483647 | 2147483640 \set ON_ERROR_STOP 0 SELECT time_bucket(10::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range SELECT time_bucket(10::bigint, '-9223372036854775801'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775000'::bigint, 1::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775808'::bigint, '9223372036854775807'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '9223372036854775807'::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::bigint, time) FROM unnest(ARRAY[ '-9223372036854775800', '-9223372036854775799', '9223372036854775807' ]::bigint[]) AS time; time | time_bucket ----------------------+---------------------- -9223372036854775800 | -9223372036854775800 -9223372036854775799 | -9223372036854775800 9223372036854775807 | 9223372036854775800 SELECT time, time_bucket(INTERVAL '1 day', time::date) FROM unnest(ARRAY[ date '2017-11-05', date '2017-11-06' ]) AS time; time | time_bucket ------------+------------- 11-05-2017 | 11-05-2017 11-06-2017 | 11-06-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date) FROM unnest(ARRAY[ date '2017-11-04', date '2017-11-05', date '2017-11-08', date '2017-11-09' ]) AS time; time | time_bucket ------------+------------- 11-04-2017 | 11-01-2017 11-05-2017 | 11-05-2017 11-08-2017 | 11-05-2017 11-09-2017 | 11-09-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date, INTERVAL '2 day') FROM unnest(ARRAY[ date '2017-11-06', date '2017-11-07', date '2017-11-10', date '2017-11-11' ]) AS time; time | time_bucket ------------+------------- 11-06-2017 | 11-03-2017 11-07-2017 | 11-07-2017 11-10-2017 | 11-07-2017 11-11-2017 | 11-11-2017 -- 2019-09-24 is a Monday, and we want to ensure that time_bucket returns the week starting with a Monday as date_trunc does, -- Rather than a Saturday which is the date of the PostgreSQL epoch SELECT time, time_bucket(INTERVAL '1 week', time::date) FROM unnest(ARRAY[ date '2018-09-16', date '2018-09-17', date '2018-09-23', date '2018-09-24' ]) AS time; time | time_bucket ------------+------------- 09-16-2018 | 09-10-2018 09-17-2018 | 09-17-2018 09-23-2018 | 09-17-2018 09-24-2018 | 09-24-2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '2018-09-16', timestamp without time zone '2018-09-17', timestamp without time zone '2018-09-23', timestamp without time zone '2018-09-24' ]) AS time; time | time_bucket --------------------------+-------------------------- Sun Sep 16 00:00:00 2018 | Mon Sep 10 00:00:00 2018 Mon Sep 17 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Sun Sep 23 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Mon Sep 24 00:00:00 2018 | Mon Sep 24 00:00:00 2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '2018-09-16', timestamp with time zone '2018-09-17', timestamp with time zone '2018-09-23', timestamp with time zone '2018-09-24' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sun Sep 16 00:00:00 2018 EDT | Sun Sep 09 20:00:00 2018 EDT Mon Sep 17 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Sun Sep 23 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Mon Sep 24 00:00:00 2018 EDT | Sun Sep 23 20:00:00 2018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '-Infinity', timestamp without time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '4714-11-24 01:01:01.0 BC', timestamp without time zone '294276-12-31 23:59:59.9999' ]) AS time; time | time_bucket | ?column? ---------------------------------+-----------------------------+---------- Mon Nov 24 01:01:01 4714 BC | Mon Nov 24 00:00:00 4714 BC | t Sun Dec 31 23:59:59.9999 294276 | Mon Dec 25 00:00:00 294276 | t --1000 years later weeks still align. SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-20', timestamp without time zone '3018-09-21', timestamp without time zone '3018-09-22' ]) AS time; time | time_bucket | ?column? --------------------------+--------------------------+---------- Mon Sep 14 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Sun Sep 20 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Mon Sep 21 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t Tue Sep 22 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t --weeks align for timestamptz as well if cast to local time, (but not if done at UTC). SELECT time, date_trunc('week', time) = time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time::timestamp) FROM unnest(ARRAY[ timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-20', timestamp with time zone '3018-09-21', timestamp with time zone '3018-09-22' ]) AS time; time | ?column? | ?column? ------------------------------+----------+---------- Mon Sep 14 00:00:00 3018 EDT | f | t Sun Sep 20 00:00:00 3018 EDT | f | t Mon Sep 21 00:00:00 3018 EDT | f | t Tue Sep 22 00:00:00 3018 EDT | f | t --check functions with origin --note that the default origin is at 0 UTC, using origin parameter it is easy to provide a EDT origin point \x SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time::timestamp) no_epoch_local, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-03 00:00:00+0') always_true, time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamptz 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp with time zone '2000-01-01 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-01 00:00:00+0', timestamp with time zone '2000-01-03 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-03 00:00:00+0', timestamp with time zone '2000-01-01', timestamp with time zone '2000-01-02', timestamp with time zone '2000-01-03', timestamp with time zone '3018-09-12', timestamp with time zone '3018-09-13', timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]--+----------------------------- time | Fri Dec 31 18:59:59 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 24 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 2 ]--+----------------------------- time | Fri Dec 31 19:00:00 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 3 ]--+----------------------------- time | Sun Jan 02 18:59:59 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 4 ]--+----------------------------- time | Sun Jan 02 19:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 5 ]--+----------------------------- time | Sat Jan 01 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 6 ]--+----------------------------- time | Sun Jan 02 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 7 ]--+----------------------------- time | Mon Jan 03 00:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Jan 02 23:00:00 2000 EST -[ RECORD 8 ]--+----------------------------- time | Sat Sep 12 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 06 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 9 ]--+----------------------------- time | Sun Sep 13 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 10 ]-+----------------------------- time | Mon Sep 14 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT -[ RECORD 11 ]-+----------------------------- time | Tue Sep 15 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamp '2000-01-03 00:00:00') always_true, time_bucket(INTERVAL '1 week', time, timestamp '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamp 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp without time zone '2000-01-01 00:00:00'- interval '1 second', timestamp without time zone '2000-01-01 00:00:00', timestamp without time zone '2000-01-03 00:00:00'- interval '1 second', timestamp without time zone '2000-01-03 00:00:00', timestamp without time zone '2000-01-01', timestamp without time zone '2000-01-02', timestamp without time zone '2000-01-03', timestamp without time zone '3018-09-12', timestamp without time zone '3018-09-13', timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]------------------------- time | Fri Dec 31 23:59:59 1999 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Dec 25 00:00:00 1999 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 2 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 3 ]------------------------- time | Sun Jan 02 23:59:59 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 4 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 5 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 6 ]------------------------- time | Sun Jan 02 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 7 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 8 ]------------------------- time | Sat Sep 12 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 06 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 9 ]------------------------- time | Sun Sep 13 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 10 ]------------------------ time | Mon Sep 14 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 -[ RECORD 11 ]------------------------ time | Tue Sep 15 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, date '2000-01-03') always_true, time_bucket(INTERVAL '1 week', time, date '2000-01-01') pg_epoch, time_bucket(INTERVAL '1 week', time, (timestamp 'epoch')::date) unix_epoch, time_bucket(INTERVAL '1 week', time, date '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, date '3018-09-14') custom_2 FROM unnest(ARRAY[ date '1999-12-31', date '2000-01-01', date '2000-01-02', date '2000-01-03', date '3018-09-12', date '3018-09-13', date '3018-09-14', date '3018-09-15' ]) AS time; -[ RECORD 1 ]----------- time | 12-31-1999 no_epoch | 12-27-1999 always_true | t pg_epoch | 12-25-1999 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 2 ]----------- time | 01-01-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 3 ]----------- time | 01-02-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 12-27-1999 -[ RECORD 4 ]----------- time | 01-03-2000 no_epoch | 01-03-2000 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 01-03-2000 -[ RECORD 5 ]----------- time | 09-12-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-06-3018 custom_2 | 09-07-3018 -[ RECORD 6 ]----------- time | 09-13-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-07-3018 -[ RECORD 7 ]----------- time | 09-14-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 -[ RECORD 8 ]----------- time | 09-15-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 \x --really old origin works if date around that time SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC', timestamp without time zone '4710-11-25 01:01:01.0 BC', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket -----------------------------+----------------------------- Sat Nov 24 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Sun Nov 25 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Mon Jan 01 00:00:00 2001 | Sat Dec 30 01:01:01 2000 Thu Jan 01 00:00:00 3001 | Sat Dec 27 01:01:01 3000 SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '294270-12-30 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '294270-12-29 23:59:59.9999', timestamp without time zone '294270-12-30 23:59:59.9999', timestamp without time zone '294270-12-31 23:59:59.9999', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket ---------------------------------+--------------------------------- Thu Dec 29 23:59:59.9999 294270 | Fri Dec 23 23:59:59.9999 294270 Fri Dec 30 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Sat Dec 31 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Mon Jan 01 00:00:00 2001 | Fri Dec 29 23:59:59.9999 2000 Thu Jan 01 00:00:00 3001 | Fri Dec 26 23:59:59.9999 3000 \set ON_ERROR_STOP 0 --really old origin + very new data + long period errors SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '294270-12-31 23:59:59.9999' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp with time zone '4710-11-25 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp with time zone '294270-12-30 23:59:59.9999' ]) AS time; ERROR: timestamp out of range --really high origin + old data + long period errors out SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp without time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp with time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp with time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range \set ON_ERROR_STOP 1 ------------------------------------------- --- Test time_bucket with month periods --- ------------------------------------------- SET datestyle TO ISO; SELECT time::date, time_bucket('1 month', time::date) AS "1m", time_bucket('2 month', time::date) AS "2m", time_bucket('3 month', time::date) AS "3m", time_bucket('1 month', time::date, '2000-02-01'::date) AS "1m origin", time_bucket('2 month', time::date, '2000-02-01'::date) AS "2m origin", time_bucket('3 month', time::date, '2000-02-01'::date) AS "3m origin" FROM generate_series('1990-01-03'::date,'1990-06-03'::date,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------+------------+------------+------------+------------+------------+------------ 1990-01-03 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1989-12-01 | 1989-11-01 1990-02-03 | 1990-02-01 | 1990-01-01 | 1990-01-01 | 1990-02-01 | 1990-02-01 | 1990-02-01 1990-03-03 | 1990-03-01 | 1990-03-01 | 1990-01-01 | 1990-03-01 | 1990-02-01 | 1990-02-01 1990-04-03 | 1990-04-01 | 1990-03-01 | 1990-04-01 | 1990-04-01 | 1990-04-01 | 1990-02-01 1990-05-03 | 1990-05-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 1990-06-03 | 1990-06-01 | 1990-05-01 | 1990-04-01 | 1990-06-01 | 1990-06-01 | 1990-05-01 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamp) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamp) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamp) AS "3m origin" FROM generate_series('1990-01-03'::timestamp,'1990-06-03'::timestamp,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+--------------------- 1990-01-03 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1989-12-01 00:00:00 | 1989-11-01 00:00:00 1990-02-03 00:00:00 | 1990-02-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-03-03 00:00:00 | 1990-03-01 00:00:00 | 1990-03-01 00:00:00 | 1990-01-01 00:00:00 | 1990-03-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-04-03 00:00:00 | 1990-04-01 00:00:00 | 1990-03-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-02-01 00:00:00 1990-05-03 00:00:00 | 1990-05-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 1990-06-03 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-06-01 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamptz) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamptz) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamptz) AS "3m origin" FROM generate_series('1990-01-03'::timestamptz,'1990-06-03'::timestamptz,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1990-01-03 00:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-11-30 19:00:00-05 | 1989-10-31 19:00:00-05 1990-02-03 00:00:00-05 | 1990-01-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-03-03 00:00:00-05 | 1990-02-28 19:00:00-05 | 1990-02-28 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-04-03 00:00:00-04 | 1990-03-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-05-03 00:00:00-04 | 1990-04-30 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 1990-06-03 00:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-05-31 20:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 --------------------------------------- --- Test time_bucket with timezones --- --------------------------------------- -- test NULL args SELECT time_bucket(NULL::interval,now(),'Europe/Berlin'), time_bucket('1day',NULL::timestamptz,'Europe/Berlin'), time_bucket('1day',now(),NULL::text), time_bucket('1day','2020-02-03','Europe/Berlin',NULL), time_bucket('1day','2020-02-03','Europe/Berlin','2020-04-01',NULL), time_bucket('1day','2020-02-03','Europe/Berlin',NULL,NULL), time_bucket('1day','2020-02-03','Europe/Berlin',"offset":=NULL::interval), time_bucket('1day','2020-02-03','Europe/Berlin',origin:=NULL::timestamptz); time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket -------------+-------------+-------------+------------------------+------------------------+------------------------+------------------------+------------------------ | | | 2020-02-02 18:00:00-05 | 2020-02-03 00:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 SET datestyle TO ISO; SELECT time_bucket('1day', ts) AS "UTC", time_bucket('1day', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1day', ts, 'Europe/London') AS "London", time_bucket('1day', ts, 'America/New_York') AS "New York", time_bucket('1day', ts, 'PST') AS "PST", time_bucket('1day', ts, current_setting('timezone')) AS "current" FROM generate_series('1999-12-31 17:00'::timestamptz,'2000-01-02 3:00'::timestamptz, '1hour'::interval) ts; UTC | Berlin | London | New York | PST | current ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-12-30 19:00:00-05 | 1999-12-30 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-30 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 2000-01-01 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-02 03:00:00-05 | 2000-01-02 00:00:00-05 SELECT time_bucket('1month', ts) AS "UTC", time_bucket('1month', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1month', ts, 'America/New_York') AS "New York", time_bucket('1month', ts, current_setting('timezone')) AS "current", time_bucket('2month', ts, current_setting('timezone')) AS "2m", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp) AS "2m origin", time_bucket('2month', ts, current_setting('timezone'), "offset":='14 day'::interval) AS "2m offset", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp, '7 day'::interval) AS "2m offset + origin" FROM generate_series('1999-12-01'::timestamptz,'2000-09-01'::timestamptz, '9 day'::interval) ts; UTC | Berlin | New York | current | 2m | 2m origin | 2m offset | 2m offset + origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-10-08 00:00:00-04 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 RESET datestyle; ------------------------------------------------------------ --- Test timescaledb_experimental.time_bucket_ng function -- ------------------------------------------------------------ -- not supported functionality \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 hour', '2001-02-03' :: date) AS result; ERROR: interval must be either days and weeks, or months and years SELECT timescaledb_experimental.time_bucket_ng('0 days', '2001-02-03' :: date) AS result; ERROR: interval must be at least one day SELECT timescaledb_experimental.time_bucket_ng('1 month', '2001-02-03' :: date, origin => '2000-01-02') AS result; ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. SELECT timescaledb_experimental.time_bucket_ng('1 month', '2000-01-02' :: date, origin => '2001-01-01') AS result; result ------------ 01-01-2000 SELECT timescaledb_experimental.time_bucket_ng('1 day', '2000-01-02' :: date, origin => '2001-01-01') AS result; ERROR: origin must be before the given date SELECT timescaledb_experimental.time_bucket_ng('1 month 3 hours', '2021-11-22' :: timestamp) AS result; ERROR: interval can't combine months with minutes or hours -- timestamp is less than the default 'origin' value SELECT timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, timezone => 'MSK'); ERROR: origin must be before the given date -- 'origin' in Europe/Moscow timezone is not the first day of the month at given time zone (UTC in this case) select timescaledb_experimental.time_bucket_ng('1 month', '2021-07-12 12:34:56 Europe/Moscow' :: timestamptz, origin => '2021-06-01 00:00:00 Europe/Moscow' :: timestamptz, timezone => 'UTC'); ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. \set ON_ERROR_STOP 1 -- wrappers SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp) AS result; result -------------------------- Fri Jan 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz) AS result; result ------------------------------ Fri Jan 01 00:00:00 2021 EST SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp, origin => '2021-06-01') AS result; result -------------------------- Tue Jun 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz, origin => '2021-06-01') AS result; result ------------------------------ Tue Jun 01 00:00:00 2021 EDT -- null argument SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, timezone => 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null interval SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null, timezone => 'Europe/Moscow') AS result; result -------- -- infinity argument SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, timezone => 'Europe/Moscow') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity -- infinite origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity -- test for invalid timezone argument SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => null) AS result; result -------- \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => 'Europe/Ololondon') AS result; ERROR: time zone "Europe/Ololondon" not recognized \set ON_ERROR_STOP 1 -- Make sure time_bucket_ng() supports seconds, minutes, and hours. -- We happen to know that the internal implementation is the same -- as for time_bucket(), thus there is no reason to execute all the tests -- we already have for time_bucket(). These two functions will most likely -- be merged eventually anyway. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:30:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:00:00 2021 -- Same as above, but with provided 'origin' argument. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:25:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:10:00 2021 -- N days / weeks buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2019-12-31 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-02 | 2020-01-02 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-03 | 2020-01-03 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-06 | 2020-01-06 | 2020-01-06 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-07 | 2020-01-07 | 2020-01-06 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-08 | 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-09 | 2020-01-09 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-04 | 2020-01-04 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-10 | 2020-01-11 | 2020-01-04 2020-01-12 | 2020-01-12 | 2020-01-12 | 2020-01-10 | 2020-01-11 | 2020-01-04 -- N days / weeks buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-02 | 2020-01-02 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-03 | 2020-01-03 | 2020-01-03 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-04 | 2020-01-04 | 2020-01-03 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-05 | 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-06 | 2020-01-06 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-01 | 2020-01-01 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-09 | 2020-01-09 | 2020-01-09 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-10 | 2020-01-10 | 2020-01-09 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-11 | 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-12 | 2020-01-12 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 -- N month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-04-01 | 2020-01-01 | 2020-01-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-01-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-06-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-07-01 | 2020-09-01 | 2020-06-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-10-01 | 2020-09-01 | 2020-06-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 -- N month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2019-11-01 | 2020-01-01 | 2019-10-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-02-01 | 2020-01-01 | 2019-10-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-08-01 | 2020-05-01 | 2020-08-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 -- N years / N years, M month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2015-07-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2016-01-01 | 2016-01-01 | 2015-01-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2016-07-01 | 2016-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-01-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-07-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2017-07-01 | 2015-01-01 2018-01-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2018-07-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-01-01 | 2019-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-07-01 | 2019-01-01 | 2019-07-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2020-01-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 2020-07-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 -- N years / N years, M month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2014-06-01 | 2013-12-01 | 2014-06-01 | 2012-12-01 | 2012-06-01 2015-07-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-01-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-07-01 | 2016-06-01 | 2015-06-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-01-01 | 2016-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-07-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2018-01-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2017-12-01 | 2015-06-01 2018-07-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-01-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-07-01 | 2019-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-01-01 | 2019-06-01 | 2019-12-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-07-01 | 2020-06-01 | 2019-12-01 | 2020-06-01 | 2020-06-01 | 2018-06-01 -- Test timezones support with different bucket sizes BEGIN; -- Timestamptz type is displayed in the session timezone. -- To get consistent results during the test we temporary set the session -- timezone to the known one. SET TIME ZONE '+00'; -- Moscow is UTC+3 in the year 2021. Let's say you are dealing with '1 day' bucket. -- In order to calculate the beginning of the bucket you have to take LOCAL -- Moscow time and throw away the time. You will get the midnight. The new day -- starts 3 hours EARLIER in Moscow than in UTC+0 time zone, thus resulting -- timestamp will be 3 hours LESS than for UTC+0. SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow', 'UTC']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-04-30 21:00:00 +00 1 year | Europe/Moscow | 2020-12-31 21:00:00 +00 12 hours | UTC | 2021-07-12 00:00:00 +00 1 day | UTC | 2021-07-12 00:00:00 +00 1 month | UTC | 2021-07-01 00:00:00 +00 4 months | UTC | 2021-05-01 00:00:00 +00 1 year | UTC | 2021-01-01 00:00:00 +00 -- Same as above, but with 'origin' SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array['2021-06-01 00:00:00 Europe/Moscow' :: timestamptz]) as origin_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, origin => origin_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-05-31 21:00:00 +00 1 year | Europe/Moscow | 2021-05-31 21:00:00 +00 -- Overwritten origin allows to work with dates earlier than the default origin SELECT to_char(timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, origin => '1900-01-01 00:00:00 MSK', timezone => 'MSK'), 'YYYY-MM-DD HH24:MI:SS TZ'); to_char ------------------------- 1998-12-31 21:00:00 +00 -- Restore previously used time zone. ROLLBACK; ------------------------------------- --- Test time input functions -- ------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.interval_to_internal(coltype REGTYPE, value ANYELEMENT = NULL::BIGINT) RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_dimension_interval_to_internal_test' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT test.interval_to_internal('TIMESTAMP'::regtype, INTERVAL '1 day'); interval_to_internal ---------------------- 86400000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400000000); interval_to_internal ---------------------- 86400000000 ---should give warning SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400); WARNING: unexpected interval: smaller than one second HINT: The interval is specified in microseconds. interval_to_internal ---------------------- 86400 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('BIGINT'::regtype, 2147483649::bigint); interval_to_internal ---------------------- 2147483649 -- Default interval for integer is supported as part of -- hypertable generalization SELECT test.interval_to_internal('INT'::regtype); interval_to_internal ---------------------- 100000 SELECT test.interval_to_internal('SMALLINT'::regtype); interval_to_internal ---------------------- 10000 SELECT test.interval_to_internal('BIGINT'::regtype); interval_to_internal ---------------------- 1000000 SELECT test.interval_to_internal('TIMESTAMPTZ'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('DATE'::regtype); interval_to_internal ---------------------- 604800000000 \set VERBOSITY terse \set ON_ERROR_STOP 0 SELECT test.interval_to_internal('INT'::regtype, 2147483649::bigint); ERROR: invalid interval: must be between 1 and 2147483647 SELECT test.interval_to_internal('SMALLINT'::regtype, 32768::bigint); ERROR: invalid interval: must be between 1 and 32767 SELECT test.interval_to_internal('TEXT'::regtype, 32768::bigint); ERROR: invalid type for dimension "testcol" SELECT test.interval_to_internal('INT'::regtype, INTERVAL '1 day'); ERROR: invalid interval type for integer dimension \set ON_ERROR_STOP 1 ����������������������������������������������������������timescaledb-2.23.0/test/expected/timestamp-17.out���������������������������������������������������0000664�0000000�0000000�00000272706�15100345067�0021632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Utility function for grouping/slotting time with a given interval. CREATE OR REPLACE FUNCTION date_group( field timestamp, group_interval interval ) RETURNS timestamp LANGUAGE SQL STABLE AS $BODY$ SELECT to_timestamp((EXTRACT(EPOCH from $1)::int / EXTRACT(EPOCH from group_interval)::int) * EXTRACT(EPOCH from group_interval)::int)::timestamp; $BODY$; CREATE TABLE PUBLIC."testNs" ( "timeCustom" TIMESTAMP NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."testNs" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "testNs" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM create_hypertable('"public"."testNs"', 'timeCustom', 'device_id', 2, associated_schema_name=>'testNs' ); WARNING: column type "timestamp without time zone" used for "timeCustom" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | testNs | t \c :TEST_DBNAME INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 1), ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 2), ('2009-11-10T23:00:02+00:00', 'dev1', 2.5, 3); INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 1), ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 2); SELECT * FROM PUBLIC."testNs"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 1 | | Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 2 | | Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET client_min_messages = WARNING; \echo 'The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC' The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC SET timezone = 'UTC'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sun Sep 13 00:00:00 2009 | 8.5 SET timezone = 'EST'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sat Sep 12 19:00:00 2009 | 8.5 \echo 'The rest of the queries will be the same in output between UTC and EST' The rest of the queries will be the same in output between UTC and EST SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 SET timezone = 'UTC'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'EST'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 ------------------------------------ -- Test time conversion functions -- ------------------------------------ \set ON_ERROR_STOP 0 SET timezone = 'UTC'; -- Conversion to timestamp using Postgres built-in function taking -- double. Gives inaccurate result on Postgres <= 9.6.2. Accurate on -- Postgres >= 9.6.3. SELECT to_timestamp(1486480176.236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- extension-specific version taking microsecond UNIX timestamp SELECT _timescaledb_functions.to_timestamp(1486480176236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- Should be the inverse of the statement above. SELECT _timescaledb_functions.to_unix_microseconds('2017-02-07 15:09:36.236538+00'); to_unix_microseconds ---------------------- 1486480176236538 -- For timestamps, BIGINT MAX represents +Infinity and BIGINT MIN -- -Infinity. We keep this notion for UNIX epoch time: SELECT _timescaledb_functions.to_unix_microseconds('+infinity'); to_unix_microseconds ---------------------- 9223372036854775807 SELECT _timescaledb_functions.to_timestamp(9223372036854775807); to_timestamp -------------- infinity SELECT _timescaledb_functions.to_unix_microseconds('-infinity'); to_unix_microseconds ---------------------- -9223372036854775808 SELECT _timescaledb_functions.to_timestamp(-9223372036854775808); to_timestamp -------------- -infinity -- In UNIX microseconds, the largest bigint value below infinity -- (BIGINT MAX) is smaller than internal date upper bound and should -- therefore be OK. Further, converting to the internal postgres epoch -- cannot overflow a 64-bit INTEGER since the postgres epoch is at a -- later date compared to the UNIX epoch, and is therefore represented -- by a smaller number SELECT _timescaledb_functions.to_timestamp(9223372036854775806); to_timestamp --------------------------------------- Sun Jan 10 04:00:54.775806 294247 UTC -- Julian day zero is -210866803200000000 microseconds from UNIX epoch SELECT _timescaledb_functions.to_timestamp(-210866803200000000); to_timestamp --------------------------------- Mon Nov 24 00:00:00 4714 UTC BC \set VERBOSITY default -- Going beyond Julian day zero should give out-of-range error SELECT _timescaledb_functions.to_timestamp(-210866803200000001); ERROR: timestamp out of range -- Lower bound on date (should return the Julian day zero UNIX timestamp above) SELECT _timescaledb_functions.to_unix_microseconds('4714-11-24 00:00:00+00 BC'); to_unix_microseconds ---------------------- -210866803200000000 -- Going beyond lower bound on date should return out-of-range SELECT _timescaledb_functions.to_unix_microseconds('4714-11-23 23:59:59.999999+00 BC'); ERROR: timestamp out of range: "4714-11-23 23:59:59.999999+00 BC" LINE 1: ...ELECT _timescaledb_functions.to_unix_microseconds('4714-11-2... ^ -- The upper bound for Postgres TIMESTAMPTZ SELECT timestamp '294276-12-31 23:59:59.999999+00'; timestamp ----------------------------------- Sun Dec 31 23:59:59.999999 294276 -- Going beyond the upper bound, should fail SELECT timestamp '294276-12-31 23:59:59.999999+00' + interval '1 us'; ERROR: timestamp out of range -- Cannot represent the upper bound timestamp with a UNIX microsecond timestamp -- since the Postgres epoch is at a later date than the UNIX epoch. SELECT _timescaledb_functions.to_unix_microseconds('294276-12-31 23:59:59.999999+00'); ERROR: timestamp out of range -- Subtracting the difference between the two epochs (10957 days) should bring -- us within range. SELECT timestamp '294276-12-31 23:59:59.999999+00' - interval '10957 days'; ?column? ----------------------------------- Fri Jan 01 23:59:59.999999 294247 SELECT _timescaledb_functions.to_unix_microseconds('294247-01-01 23:59:59.999999'); to_unix_microseconds ---------------------- 9223371331199999999 -- Adding one microsecond should take us out-of-range again SELECT timestamp '294247-01-01 23:59:59.999999' + interval '1 us'; ?column? ---------------------------- Sat Jan 02 00:00:00 294247 SELECT _timescaledb_functions.to_unix_microseconds(timestamp '294247-01-01 23:59:59.999999' + interval '1 us'); ERROR: timestamp out of range --no time_bucketing of dates not by integer # of days SELECT time_bucket('1 hour', DATE '2012-01-01'); ERROR: interval must not have sub-day precision SELECT time_bucket('25 hour', DATE '2012-01-01'); ERROR: interval must be a multiple of a day \set ON_ERROR_STOP 1 SELECT time_bucket(INTERVAL '1 day', TIMESTAMP '2011-01-02 01:01:01'); time_bucket -------------------------- Sun Jan 02 00:00:00 2011 SELECT time, time_bucket(INTERVAL '2 day ', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-01 01:01:01', TIMESTAMP '2011-01-02 01:01:01', TIMESTAMP '2011-01-03 01:01:01', TIMESTAMP '2011-01-04 01:01:01' ]) AS time; time | time_bucket --------------------------+-------------------------- Sat Jan 01 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Sun Jan 02 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Mon Jan 03 01:01:01 2011 | Mon Jan 03 00:00:00 2011 Tue Jan 04 01:01:01 2011 | Mon Jan 03 00:00:00 2011 SELECT int_def, time_bucket(int_def,TIMESTAMP '2011-01-02 01:01:01.111') FROM unnest(ARRAY[ INTERVAL '1 millisecond', INTERVAL '1 second', INTERVAL '1 minute', INTERVAL '1 hour', INTERVAL '1 day', INTERVAL '2 millisecond', INTERVAL '2 second', INTERVAL '2 minute', INTERVAL '2 hour', INTERVAL '2 day' ]) AS int_def; int_def | time_bucket --------------+------------------------------ @ 0.001 secs | Sun Jan 02 01:01:01.111 2011 @ 1 sec | Sun Jan 02 01:01:01 2011 @ 1 min | Sun Jan 02 01:01:00 2011 @ 1 hour | Sun Jan 02 01:00:00 2011 @ 1 day | Sun Jan 02 00:00:00 2011 @ 0.002 secs | Sun Jan 02 01:01:01.11 2011 @ 2 secs | Sun Jan 02 01:01:00 2011 @ 2 mins | Sun Jan 02 01:00:00 2011 @ 2 hours | Sun Jan 02 00:00:00 2011 @ 2 days | Sat Jan 01 00:00:00 2011 \set ON_ERROR_STOP 0 SELECT time_bucket(INTERVAL '1 year 1d',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component SELECT time_bucket(INTERVAL '1 month 1 minute',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component \set ON_ERROR_STOP 1 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '1970-01-01 00:59:59.999999', TIMESTAMP '1970-01-01 01:01:00', TIMESTAMP '1970-01-01 01:04:59.999999', TIMESTAMP '1970-01-01 01:05:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Thu Jan 01 00:59:59.999999 1970 | Thu Jan 01 00:55:00 1970 Thu Jan 01 01:01:00 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:04:59.999999 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:05:00 1970 | Thu Jan 01 01:05:00 1970 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:04:59.999999', TIMESTAMP '2011-01-02 01:05:00', TIMESTAMP '2011-01-02 01:09:59.999999', TIMESTAMP '2011-01-02 01:10:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:04:59.999999 2011 | Sun Jan 02 01:00:00 2011 Sun Jan 02 01:05:00 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:09:59.999999 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:10:00 2011 | Sun Jan 02 01:10:00 2011 --offset with interval SELECT time, time_bucket(INTERVAL '5 minute', time , INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:02:59.999999', TIMESTAMP '2011-01-02 01:03:00', TIMESTAMP '2011-01-02 01:07:59.999999', TIMESTAMP '2011-01-02 01:08:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:02:59.999999 2011 | Sun Jan 02 00:58:00 2011 Sun Jan 02 01:03:00 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:07:59.999999 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:08:00 2011 | Sun Jan 02 01:08:00 2011 --offset with infinity -- timestamp SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp '-Infinity', timestamp 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- timestamptz SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- Date SELECT date, time_bucket(INTERVAL '1 week', date, INTERVAL '1 day') FROM unnest(ARRAY[ date '-Infinity', date 'Infinity' ]) AS date; date | time_bucket -----------+------------- -infinity | -infinity infinity | infinity --example to align with an origin SELECT time, time_bucket(INTERVAL '5 minute', time - (TIMESTAMP '2011-01-02 00:02:00' - TIMESTAMP 'epoch')) + (TIMESTAMP '2011-01-02 00:02:00'-TIMESTAMP 'epoch') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | ?column? ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 --rounding version SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2.5 minutes') + INTERVAL '2 minutes 30 seconds' FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:05:01', TIMESTAMP '2011-01-02 01:07:29', TIMESTAMP '2011-01-02 01:02:30', TIMESTAMP '2011-01-02 01:07:30', TIMESTAMP '2011-01-02 01:02:29' ]) AS time; time | ?column? --------------------------+-------------------------- Sun Jan 02 01:05:01 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:29 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:02:30 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:30 2011 | Sun Jan 02 01:10:00 2011 Sun Jan 02 01:02:29 2011 | Sun Jan 02 01:00:00 2011 --time_bucket with timezone should mimick date_trunc SET timezone TO 'UTC'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 01:00:00 2011 UTC | Sun Jan 02 01:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 23:00:00 2011 UTC | Sat Jan 01 23:00:00 2011 UTC SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 00:00:00 2011 UTC | Sat Jan 01 00:00:00 2011 UTC --what happens with a local tz SET timezone TO 'America/New_York'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 01:00:00 2011 EST | Sun Jan 02 01:00:00 2011 EST Sat Jan 01 19:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sat Jan 01 19:00:00 2011 EST Sat Jan 01 18:01:01 2011 EST | Sat Jan 01 18:00:00 2011 EST | Sat Jan 01 18:00:00 2011 EST --Note the timestamp tz input is aligned with UTC day /not/ local day. different than date_trunc. SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --can force local bucketing with simple cast. SELECT time, time_bucket(INTERVAL '1 day', time::timestamp), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+--------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 | Mon Jan 03 00:00:00 2011 EST --can also use interval to correct SELECT time, time_bucket(INTERVAL '1 day', time, -INTERVAL '19 hours'), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --dst: same local hour bucketed as two different hours. SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST | Sun Nov 05 01:00:00 2017 EST --local alignment changes when bucketing by UTC across dst boundary SELECT time, time_bucket(INTERVAL '2 hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 03:00:00 2017 EST --local alignment is preserved when bucketing by local time across DST boundary. SELECT time, time_bucket(INTERVAL '2 hour', time::timestamp) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+-------------------------- Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 00:00:00 2017 Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 02:00:00 2017 SELECT time, time_bucket(10::smallint, time) AS time_bucket_smallint, time_bucket(10::int, time) AS time_bucket_int, time_bucket(10::bigint, time) AS time_bucket_bigint FROM unnest(ARRAY[ '-11', '-10', '-9', '-1', '0', '1', '99', '100', '109', '110' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -11 | -20 | -20 | -20 -10 | -10 | -10 | -10 -9 | -10 | -10 | -10 -1 | -10 | -10 | -10 0 | 0 | 0 | 0 1 | 0 | 0 | 0 99 | 90 | 90 | 90 100 | 100 | 100 | 100 109 | 100 | 100 | 100 110 | 110 | 110 | 110 SELECT time, time_bucket(10::smallint, time, 2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, 2::int) AS time_bucket_int, time_bucket(10::bigint, time, 2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-9', '-8', '-7', '1', '2', '3', '101', '102', '111', '112' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -9 | -18 | -18 | -18 -8 | -8 | -8 | -8 -7 | -8 | -8 | -8 1 | -8 | -8 | -8 2 | 2 | 2 | 2 3 | 2 | 2 | 2 101 | 92 | 92 | 92 102 | 102 | 102 | 102 111 | 102 | 102 | 102 112 | 112 | 112 | 112 SELECT time, time_bucket(10::smallint, time, -2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, -2::int) AS time_bucket_int, time_bucket(10::bigint, time, -2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-13', '-12', '-11', '-3', '-2', '-1', '97', '98', '107', '108' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -13 | -22 | -22 | -22 -12 | -12 | -12 | -12 -11 | -12 | -12 | -12 -3 | -12 | -12 | -12 -2 | -2 | -2 | -2 -1 | -2 | -2 | -2 97 | 88 | 88 | 88 98 | 98 | 98 | 98 107 | 98 | 98 | 98 108 | 108 | 108 | 108 \set ON_ERROR_STOP 0 SELECT time_bucket(10::smallint, '-32768'::smallint); ERROR: timestamp out of range SELECT time_bucket(10::smallint, '-32761'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, 1000::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, '32767'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '32767'::smallint, '-32768'::smallint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::smallint, time) FROM unnest(ARRAY[ '-32760', '-32759', '32767' ]::smallint[]) AS time; time | time_bucket --------+------------- -32760 | -32760 -32759 | -32760 32767 | 32760 \set ON_ERROR_STOP 0 SELECT time_bucket(10::int, '-2147483648'::int); ERROR: timestamp out of range SELECT time_bucket(10::int, '-2147483641'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483000'::int, 1::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483648'::int, '2147483647'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '2147483647'::int, '-2147483648'::int); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::int, time) FROM unnest(ARRAY[ '-2147483640', '-2147483639', '2147483647' ]::int[]) AS time; time | time_bucket -------------+------------- -2147483640 | -2147483640 -2147483639 | -2147483640 2147483647 | 2147483640 \set ON_ERROR_STOP 0 SELECT time_bucket(10::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range SELECT time_bucket(10::bigint, '-9223372036854775801'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775000'::bigint, 1::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775808'::bigint, '9223372036854775807'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '9223372036854775807'::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::bigint, time) FROM unnest(ARRAY[ '-9223372036854775800', '-9223372036854775799', '9223372036854775807' ]::bigint[]) AS time; time | time_bucket ----------------------+---------------------- -9223372036854775800 | -9223372036854775800 -9223372036854775799 | -9223372036854775800 9223372036854775807 | 9223372036854775800 SELECT time, time_bucket(INTERVAL '1 day', time::date) FROM unnest(ARRAY[ date '2017-11-05', date '2017-11-06' ]) AS time; time | time_bucket ------------+------------- 11-05-2017 | 11-05-2017 11-06-2017 | 11-06-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date) FROM unnest(ARRAY[ date '2017-11-04', date '2017-11-05', date '2017-11-08', date '2017-11-09' ]) AS time; time | time_bucket ------------+------------- 11-04-2017 | 11-01-2017 11-05-2017 | 11-05-2017 11-08-2017 | 11-05-2017 11-09-2017 | 11-09-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date, INTERVAL '2 day') FROM unnest(ARRAY[ date '2017-11-06', date '2017-11-07', date '2017-11-10', date '2017-11-11' ]) AS time; time | time_bucket ------------+------------- 11-06-2017 | 11-03-2017 11-07-2017 | 11-07-2017 11-10-2017 | 11-07-2017 11-11-2017 | 11-11-2017 -- 2019-09-24 is a Monday, and we want to ensure that time_bucket returns the week starting with a Monday as date_trunc does, -- Rather than a Saturday which is the date of the PostgreSQL epoch SELECT time, time_bucket(INTERVAL '1 week', time::date) FROM unnest(ARRAY[ date '2018-09-16', date '2018-09-17', date '2018-09-23', date '2018-09-24' ]) AS time; time | time_bucket ------------+------------- 09-16-2018 | 09-10-2018 09-17-2018 | 09-17-2018 09-23-2018 | 09-17-2018 09-24-2018 | 09-24-2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '2018-09-16', timestamp without time zone '2018-09-17', timestamp without time zone '2018-09-23', timestamp without time zone '2018-09-24' ]) AS time; time | time_bucket --------------------------+-------------------------- Sun Sep 16 00:00:00 2018 | Mon Sep 10 00:00:00 2018 Mon Sep 17 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Sun Sep 23 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Mon Sep 24 00:00:00 2018 | Mon Sep 24 00:00:00 2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '2018-09-16', timestamp with time zone '2018-09-17', timestamp with time zone '2018-09-23', timestamp with time zone '2018-09-24' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sun Sep 16 00:00:00 2018 EDT | Sun Sep 09 20:00:00 2018 EDT Mon Sep 17 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Sun Sep 23 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Mon Sep 24 00:00:00 2018 EDT | Sun Sep 23 20:00:00 2018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '-Infinity', timestamp without time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '4714-11-24 01:01:01.0 BC', timestamp without time zone '294276-12-31 23:59:59.9999' ]) AS time; time | time_bucket | ?column? ---------------------------------+-----------------------------+---------- Mon Nov 24 01:01:01 4714 BC | Mon Nov 24 00:00:00 4714 BC | t Sun Dec 31 23:59:59.9999 294276 | Mon Dec 25 00:00:00 294276 | t --1000 years later weeks still align. SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-20', timestamp without time zone '3018-09-21', timestamp without time zone '3018-09-22' ]) AS time; time | time_bucket | ?column? --------------------------+--------------------------+---------- Mon Sep 14 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Sun Sep 20 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Mon Sep 21 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t Tue Sep 22 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t --weeks align for timestamptz as well if cast to local time, (but not if done at UTC). SELECT time, date_trunc('week', time) = time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time::timestamp) FROM unnest(ARRAY[ timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-20', timestamp with time zone '3018-09-21', timestamp with time zone '3018-09-22' ]) AS time; time | ?column? | ?column? ------------------------------+----------+---------- Mon Sep 14 00:00:00 3018 EDT | f | t Sun Sep 20 00:00:00 3018 EDT | f | t Mon Sep 21 00:00:00 3018 EDT | f | t Tue Sep 22 00:00:00 3018 EDT | f | t --check functions with origin --note that the default origin is at 0 UTC, using origin parameter it is easy to provide a EDT origin point \x SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time::timestamp) no_epoch_local, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-03 00:00:00+0') always_true, time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamptz 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp with time zone '2000-01-01 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-01 00:00:00+0', timestamp with time zone '2000-01-03 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-03 00:00:00+0', timestamp with time zone '2000-01-01', timestamp with time zone '2000-01-02', timestamp with time zone '2000-01-03', timestamp with time zone '3018-09-12', timestamp with time zone '3018-09-13', timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]--+----------------------------- time | Fri Dec 31 18:59:59 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 24 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 2 ]--+----------------------------- time | Fri Dec 31 19:00:00 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 3 ]--+----------------------------- time | Sun Jan 02 18:59:59 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 4 ]--+----------------------------- time | Sun Jan 02 19:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 5 ]--+----------------------------- time | Sat Jan 01 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 6 ]--+----------------------------- time | Sun Jan 02 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 7 ]--+----------------------------- time | Mon Jan 03 00:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Jan 02 23:00:00 2000 EST -[ RECORD 8 ]--+----------------------------- time | Sat Sep 12 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 06 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 9 ]--+----------------------------- time | Sun Sep 13 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 10 ]-+----------------------------- time | Mon Sep 14 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT -[ RECORD 11 ]-+----------------------------- time | Tue Sep 15 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamp '2000-01-03 00:00:00') always_true, time_bucket(INTERVAL '1 week', time, timestamp '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamp 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp without time zone '2000-01-01 00:00:00'- interval '1 second', timestamp without time zone '2000-01-01 00:00:00', timestamp without time zone '2000-01-03 00:00:00'- interval '1 second', timestamp without time zone '2000-01-03 00:00:00', timestamp without time zone '2000-01-01', timestamp without time zone '2000-01-02', timestamp without time zone '2000-01-03', timestamp without time zone '3018-09-12', timestamp without time zone '3018-09-13', timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]------------------------- time | Fri Dec 31 23:59:59 1999 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Dec 25 00:00:00 1999 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 2 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 3 ]------------------------- time | Sun Jan 02 23:59:59 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 4 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 5 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 6 ]------------------------- time | Sun Jan 02 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 7 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 8 ]------------------------- time | Sat Sep 12 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 06 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 9 ]------------------------- time | Sun Sep 13 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 10 ]------------------------ time | Mon Sep 14 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 -[ RECORD 11 ]------------------------ time | Tue Sep 15 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, date '2000-01-03') always_true, time_bucket(INTERVAL '1 week', time, date '2000-01-01') pg_epoch, time_bucket(INTERVAL '1 week', time, (timestamp 'epoch')::date) unix_epoch, time_bucket(INTERVAL '1 week', time, date '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, date '3018-09-14') custom_2 FROM unnest(ARRAY[ date '1999-12-31', date '2000-01-01', date '2000-01-02', date '2000-01-03', date '3018-09-12', date '3018-09-13', date '3018-09-14', date '3018-09-15' ]) AS time; -[ RECORD 1 ]----------- time | 12-31-1999 no_epoch | 12-27-1999 always_true | t pg_epoch | 12-25-1999 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 2 ]----------- time | 01-01-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 3 ]----------- time | 01-02-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 12-27-1999 -[ RECORD 4 ]----------- time | 01-03-2000 no_epoch | 01-03-2000 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 01-03-2000 -[ RECORD 5 ]----------- time | 09-12-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-06-3018 custom_2 | 09-07-3018 -[ RECORD 6 ]----------- time | 09-13-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-07-3018 -[ RECORD 7 ]----------- time | 09-14-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 -[ RECORD 8 ]----------- time | 09-15-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 \x --really old origin works if date around that time SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC', timestamp without time zone '4710-11-25 01:01:01.0 BC', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket -----------------------------+----------------------------- Sat Nov 24 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Sun Nov 25 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Mon Jan 01 00:00:00 2001 | Sat Dec 30 01:01:01 2000 Thu Jan 01 00:00:00 3001 | Sat Dec 27 01:01:01 3000 SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '294270-12-30 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '294270-12-29 23:59:59.9999', timestamp without time zone '294270-12-30 23:59:59.9999', timestamp without time zone '294270-12-31 23:59:59.9999', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket ---------------------------------+--------------------------------- Thu Dec 29 23:59:59.9999 294270 | Fri Dec 23 23:59:59.9999 294270 Fri Dec 30 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Sat Dec 31 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Mon Jan 01 00:00:00 2001 | Fri Dec 29 23:59:59.9999 2000 Thu Jan 01 00:00:00 3001 | Fri Dec 26 23:59:59.9999 3000 \set ON_ERROR_STOP 0 --really old origin + very new data + long period errors SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '294270-12-31 23:59:59.9999' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp with time zone '4710-11-25 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp with time zone '294270-12-30 23:59:59.9999' ]) AS time; ERROR: timestamp out of range --really high origin + old data + long period errors out SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp without time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp with time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp with time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range \set ON_ERROR_STOP 1 ------------------------------------------- --- Test time_bucket with month periods --- ------------------------------------------- SET datestyle TO ISO; SELECT time::date, time_bucket('1 month', time::date) AS "1m", time_bucket('2 month', time::date) AS "2m", time_bucket('3 month', time::date) AS "3m", time_bucket('1 month', time::date, '2000-02-01'::date) AS "1m origin", time_bucket('2 month', time::date, '2000-02-01'::date) AS "2m origin", time_bucket('3 month', time::date, '2000-02-01'::date) AS "3m origin" FROM generate_series('1990-01-03'::date,'1990-06-03'::date,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------+------------+------------+------------+------------+------------+------------ 1990-01-03 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1989-12-01 | 1989-11-01 1990-02-03 | 1990-02-01 | 1990-01-01 | 1990-01-01 | 1990-02-01 | 1990-02-01 | 1990-02-01 1990-03-03 | 1990-03-01 | 1990-03-01 | 1990-01-01 | 1990-03-01 | 1990-02-01 | 1990-02-01 1990-04-03 | 1990-04-01 | 1990-03-01 | 1990-04-01 | 1990-04-01 | 1990-04-01 | 1990-02-01 1990-05-03 | 1990-05-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 1990-06-03 | 1990-06-01 | 1990-05-01 | 1990-04-01 | 1990-06-01 | 1990-06-01 | 1990-05-01 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamp) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamp) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamp) AS "3m origin" FROM generate_series('1990-01-03'::timestamp,'1990-06-03'::timestamp,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+--------------------- 1990-01-03 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1989-12-01 00:00:00 | 1989-11-01 00:00:00 1990-02-03 00:00:00 | 1990-02-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-03-03 00:00:00 | 1990-03-01 00:00:00 | 1990-03-01 00:00:00 | 1990-01-01 00:00:00 | 1990-03-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-04-03 00:00:00 | 1990-04-01 00:00:00 | 1990-03-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-02-01 00:00:00 1990-05-03 00:00:00 | 1990-05-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 1990-06-03 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-06-01 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamptz) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamptz) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamptz) AS "3m origin" FROM generate_series('1990-01-03'::timestamptz,'1990-06-03'::timestamptz,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1990-01-03 00:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-11-30 19:00:00-05 | 1989-10-31 19:00:00-05 1990-02-03 00:00:00-05 | 1990-01-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-03-03 00:00:00-05 | 1990-02-28 19:00:00-05 | 1990-02-28 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-04-03 00:00:00-04 | 1990-03-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-05-03 00:00:00-04 | 1990-04-30 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 1990-06-03 00:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-05-31 20:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 --------------------------------------- --- Test time_bucket with timezones --- --------------------------------------- -- test NULL args SELECT time_bucket(NULL::interval,now(),'Europe/Berlin'), time_bucket('1day',NULL::timestamptz,'Europe/Berlin'), time_bucket('1day',now(),NULL::text), time_bucket('1day','2020-02-03','Europe/Berlin',NULL), time_bucket('1day','2020-02-03','Europe/Berlin','2020-04-01',NULL), time_bucket('1day','2020-02-03','Europe/Berlin',NULL,NULL), time_bucket('1day','2020-02-03','Europe/Berlin',"offset":=NULL::interval), time_bucket('1day','2020-02-03','Europe/Berlin',origin:=NULL::timestamptz); time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket -------------+-------------+-------------+------------------------+------------------------+------------------------+------------------------+------------------------ | | | 2020-02-02 18:00:00-05 | 2020-02-03 00:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 SET datestyle TO ISO; SELECT time_bucket('1day', ts) AS "UTC", time_bucket('1day', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1day', ts, 'Europe/London') AS "London", time_bucket('1day', ts, 'America/New_York') AS "New York", time_bucket('1day', ts, 'PST') AS "PST", time_bucket('1day', ts, current_setting('timezone')) AS "current" FROM generate_series('1999-12-31 17:00'::timestamptz,'2000-01-02 3:00'::timestamptz, '1hour'::interval) ts; UTC | Berlin | London | New York | PST | current ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-12-30 19:00:00-05 | 1999-12-30 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-30 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 2000-01-01 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-02 03:00:00-05 | 2000-01-02 00:00:00-05 SELECT time_bucket('1month', ts) AS "UTC", time_bucket('1month', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1month', ts, 'America/New_York') AS "New York", time_bucket('1month', ts, current_setting('timezone')) AS "current", time_bucket('2month', ts, current_setting('timezone')) AS "2m", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp) AS "2m origin", time_bucket('2month', ts, current_setting('timezone'), "offset":='14 day'::interval) AS "2m offset", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp, '7 day'::interval) AS "2m offset + origin" FROM generate_series('1999-12-01'::timestamptz,'2000-09-01'::timestamptz, '9 day'::interval) ts; UTC | Berlin | New York | current | 2m | 2m origin | 2m offset | 2m offset + origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-10-08 00:00:00-04 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 RESET datestyle; ------------------------------------------------------------ --- Test timescaledb_experimental.time_bucket_ng function -- ------------------------------------------------------------ -- not supported functionality \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 hour', '2001-02-03' :: date) AS result; ERROR: interval must be either days and weeks, or months and years SELECT timescaledb_experimental.time_bucket_ng('0 days', '2001-02-03' :: date) AS result; ERROR: interval must be at least one day SELECT timescaledb_experimental.time_bucket_ng('1 month', '2001-02-03' :: date, origin => '2000-01-02') AS result; ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. SELECT timescaledb_experimental.time_bucket_ng('1 month', '2000-01-02' :: date, origin => '2001-01-01') AS result; result ------------ 01-01-2000 SELECT timescaledb_experimental.time_bucket_ng('1 day', '2000-01-02' :: date, origin => '2001-01-01') AS result; ERROR: origin must be before the given date SELECT timescaledb_experimental.time_bucket_ng('1 month 3 hours', '2021-11-22' :: timestamp) AS result; ERROR: interval can't combine months with minutes or hours -- timestamp is less than the default 'origin' value SELECT timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, timezone => 'MSK'); ERROR: origin must be before the given date -- 'origin' in Europe/Moscow timezone is not the first day of the month at given time zone (UTC in this case) select timescaledb_experimental.time_bucket_ng('1 month', '2021-07-12 12:34:56 Europe/Moscow' :: timestamptz, origin => '2021-06-01 00:00:00 Europe/Moscow' :: timestamptz, timezone => 'UTC'); ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. \set ON_ERROR_STOP 1 -- wrappers SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp) AS result; result -------------------------- Fri Jan 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz) AS result; result ------------------------------ Fri Jan 01 00:00:00 2021 EST SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp, origin => '2021-06-01') AS result; result -------------------------- Tue Jun 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz, origin => '2021-06-01') AS result; result ------------------------------ Tue Jun 01 00:00:00 2021 EDT -- null argument SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, timezone => 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null interval SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null, timezone => 'Europe/Moscow') AS result; result -------- -- infinity argument SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, timezone => 'Europe/Moscow') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity -- infinite origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity -- test for invalid timezone argument SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => null) AS result; result -------- \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => 'Europe/Ololondon') AS result; ERROR: time zone "Europe/Ololondon" not recognized \set ON_ERROR_STOP 1 -- Make sure time_bucket_ng() supports seconds, minutes, and hours. -- We happen to know that the internal implementation is the same -- as for time_bucket(), thus there is no reason to execute all the tests -- we already have for time_bucket(). These two functions will most likely -- be merged eventually anyway. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:30:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:00:00 2021 -- Same as above, but with provided 'origin' argument. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:25:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:10:00 2021 -- N days / weeks buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2019-12-31 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-02 | 2020-01-02 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-03 | 2020-01-03 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-06 | 2020-01-06 | 2020-01-06 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-07 | 2020-01-07 | 2020-01-06 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-08 | 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-09 | 2020-01-09 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-04 | 2020-01-04 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-10 | 2020-01-11 | 2020-01-04 2020-01-12 | 2020-01-12 | 2020-01-12 | 2020-01-10 | 2020-01-11 | 2020-01-04 -- N days / weeks buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-02 | 2020-01-02 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-03 | 2020-01-03 | 2020-01-03 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-04 | 2020-01-04 | 2020-01-03 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-05 | 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-06 | 2020-01-06 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-01 | 2020-01-01 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-09 | 2020-01-09 | 2020-01-09 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-10 | 2020-01-10 | 2020-01-09 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-11 | 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-12 | 2020-01-12 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 -- N month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-04-01 | 2020-01-01 | 2020-01-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-01-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-06-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-07-01 | 2020-09-01 | 2020-06-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-10-01 | 2020-09-01 | 2020-06-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 -- N month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2019-11-01 | 2020-01-01 | 2019-10-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-02-01 | 2020-01-01 | 2019-10-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-08-01 | 2020-05-01 | 2020-08-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 -- N years / N years, M month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2015-07-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2016-01-01 | 2016-01-01 | 2015-01-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2016-07-01 | 2016-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-01-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-07-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2017-07-01 | 2015-01-01 2018-01-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2018-07-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-01-01 | 2019-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-07-01 | 2019-01-01 | 2019-07-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2020-01-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 2020-07-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 -- N years / N years, M month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2014-06-01 | 2013-12-01 | 2014-06-01 | 2012-12-01 | 2012-06-01 2015-07-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-01-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-07-01 | 2016-06-01 | 2015-06-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-01-01 | 2016-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-07-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2018-01-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2017-12-01 | 2015-06-01 2018-07-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-01-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-07-01 | 2019-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-01-01 | 2019-06-01 | 2019-12-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-07-01 | 2020-06-01 | 2019-12-01 | 2020-06-01 | 2020-06-01 | 2018-06-01 -- Test timezones support with different bucket sizes BEGIN; -- Timestamptz type is displayed in the session timezone. -- To get consistent results during the test we temporary set the session -- timezone to the known one. SET TIME ZONE '+00'; -- Moscow is UTC+3 in the year 2021. Let's say you are dealing with '1 day' bucket. -- In order to calculate the beginning of the bucket you have to take LOCAL -- Moscow time and throw away the time. You will get the midnight. The new day -- starts 3 hours EARLIER in Moscow than in UTC+0 time zone, thus resulting -- timestamp will be 3 hours LESS than for UTC+0. SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow', 'UTC']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-04-30 21:00:00 +00 1 year | Europe/Moscow | 2020-12-31 21:00:00 +00 12 hours | UTC | 2021-07-12 00:00:00 +00 1 day | UTC | 2021-07-12 00:00:00 +00 1 month | UTC | 2021-07-01 00:00:00 +00 4 months | UTC | 2021-05-01 00:00:00 +00 1 year | UTC | 2021-01-01 00:00:00 +00 -- Same as above, but with 'origin' SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array['2021-06-01 00:00:00 Europe/Moscow' :: timestamptz]) as origin_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, origin => origin_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-05-31 21:00:00 +00 1 year | Europe/Moscow | 2021-05-31 21:00:00 +00 -- Overwritten origin allows to work with dates earlier than the default origin SELECT to_char(timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, origin => '1900-01-01 00:00:00 MSK', timezone => 'MSK'), 'YYYY-MM-DD HH24:MI:SS TZ'); to_char ------------------------- 1998-12-31 21:00:00 +00 -- Restore previously used time zone. ROLLBACK; ------------------------------------- --- Test time input functions -- ------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.interval_to_internal(coltype REGTYPE, value ANYELEMENT = NULL::BIGINT) RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_dimension_interval_to_internal_test' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT test.interval_to_internal('TIMESTAMP'::regtype, INTERVAL '1 day'); interval_to_internal ---------------------- 86400000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400000000); interval_to_internal ---------------------- 86400000000 ---should give warning SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400); WARNING: unexpected interval: smaller than one second HINT: The interval is specified in microseconds. interval_to_internal ---------------------- 86400 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('BIGINT'::regtype, 2147483649::bigint); interval_to_internal ---------------------- 2147483649 -- Default interval for integer is supported as part of -- hypertable generalization SELECT test.interval_to_internal('INT'::regtype); interval_to_internal ---------------------- 100000 SELECT test.interval_to_internal('SMALLINT'::regtype); interval_to_internal ---------------------- 10000 SELECT test.interval_to_internal('BIGINT'::regtype); interval_to_internal ---------------------- 1000000 SELECT test.interval_to_internal('TIMESTAMPTZ'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('DATE'::regtype); interval_to_internal ---------------------- 604800000000 \set VERBOSITY terse \set ON_ERROR_STOP 0 SELECT test.interval_to_internal('INT'::regtype, 2147483649::bigint); ERROR: invalid interval: must be between 1 and 2147483647 SELECT test.interval_to_internal('SMALLINT'::regtype, 32768::bigint); ERROR: invalid interval: must be between 1 and 32767 SELECT test.interval_to_internal('TEXT'::regtype, 32768::bigint); ERROR: invalid type for dimension "testcol" SELECT test.interval_to_internal('INT'::regtype, INTERVAL '1 day'); ERROR: invalid interval type for integer dimension \set ON_ERROR_STOP 1 ����������������������������������������������������������timescaledb-2.23.0/test/expected/timestamp-18.out���������������������������������������������������0000664�0000000�0000000�00000272706�15100345067�0021633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Utility function for grouping/slotting time with a given interval. CREATE OR REPLACE FUNCTION date_group( field timestamp, group_interval interval ) RETURNS timestamp LANGUAGE SQL STABLE AS $BODY$ SELECT to_timestamp((EXTRACT(EPOCH from $1)::int / EXTRACT(EPOCH from group_interval)::int) * EXTRACT(EPOCH from group_interval)::int)::timestamp; $BODY$; CREATE TABLE PUBLIC."testNs" ( "timeCustom" TIMESTAMP NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."testNs" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "testNs" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM create_hypertable('"public"."testNs"', 'timeCustom', 'device_id', 2, associated_schema_name=>'testNs' ); WARNING: column type "timestamp without time zone" used for "timeCustom" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | testNs | t \c :TEST_DBNAME INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 1), ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 2), ('2009-11-10T23:00:02+00:00', 'dev1', 2.5, 3); INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 1), ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 2); SELECT * FROM PUBLIC."testNs"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 1 | | Thu Nov 12 01:00:00 2009 | dev1 | 1.5 | 2 | | Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET client_min_messages = WARNING; \echo 'The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC' The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC SET timezone = 'UTC'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sun Sep 13 00:00:00 2009 | 8.5 SET timezone = 'EST'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Sat Sep 12 19:00:00 2009 | 8.5 \echo 'The rest of the queries will be the same in output between UTC and EST' The rest of the queries will be the same in output between UTC and EST SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 SET timezone = 'UTC'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'EST'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool --------------------------+-----------+----------+----------+----------+------------- Tue Nov 10 23:00:02 2009 | dev1 | 2.5 | 3 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 1 | | Tue Nov 10 23:00:00 2009 | dev2 | 1.5 | 2 | | SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Tue Nov 10 00:00:00 2009 | 5.5 Thu Nov 12 00:00:00 2009 | 3 SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; time | sum --------------------------+----- Mon Nov 09 19:00:00 2009 | 5.5 Wed Nov 11 19:00:00 2009 | 3 ------------------------------------ -- Test time conversion functions -- ------------------------------------ \set ON_ERROR_STOP 0 SET timezone = 'UTC'; -- Conversion to timestamp using Postgres built-in function taking -- double. Gives inaccurate result on Postgres <= 9.6.2. Accurate on -- Postgres >= 9.6.3. SELECT to_timestamp(1486480176.236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- extension-specific version taking microsecond UNIX timestamp SELECT _timescaledb_functions.to_timestamp(1486480176236538); to_timestamp ------------------------------------- Tue Feb 07 15:09:36.236538 2017 UTC -- Should be the inverse of the statement above. SELECT _timescaledb_functions.to_unix_microseconds('2017-02-07 15:09:36.236538+00'); to_unix_microseconds ---------------------- 1486480176236538 -- For timestamps, BIGINT MAX represents +Infinity and BIGINT MIN -- -Infinity. We keep this notion for UNIX epoch time: SELECT _timescaledb_functions.to_unix_microseconds('+infinity'); to_unix_microseconds ---------------------- 9223372036854775807 SELECT _timescaledb_functions.to_timestamp(9223372036854775807); to_timestamp -------------- infinity SELECT _timescaledb_functions.to_unix_microseconds('-infinity'); to_unix_microseconds ---------------------- -9223372036854775808 SELECT _timescaledb_functions.to_timestamp(-9223372036854775808); to_timestamp -------------- -infinity -- In UNIX microseconds, the largest bigint value below infinity -- (BIGINT MAX) is smaller than internal date upper bound and should -- therefore be OK. Further, converting to the internal postgres epoch -- cannot overflow a 64-bit INTEGER since the postgres epoch is at a -- later date compared to the UNIX epoch, and is therefore represented -- by a smaller number SELECT _timescaledb_functions.to_timestamp(9223372036854775806); to_timestamp --------------------------------------- Sun Jan 10 04:00:54.775806 294247 UTC -- Julian day zero is -210866803200000000 microseconds from UNIX epoch SELECT _timescaledb_functions.to_timestamp(-210866803200000000); to_timestamp --------------------------------- Mon Nov 24 00:00:00 4714 UTC BC \set VERBOSITY default -- Going beyond Julian day zero should give out-of-range error SELECT _timescaledb_functions.to_timestamp(-210866803200000001); ERROR: timestamp out of range -- Lower bound on date (should return the Julian day zero UNIX timestamp above) SELECT _timescaledb_functions.to_unix_microseconds('4714-11-24 00:00:00+00 BC'); to_unix_microseconds ---------------------- -210866803200000000 -- Going beyond lower bound on date should return out-of-range SELECT _timescaledb_functions.to_unix_microseconds('4714-11-23 23:59:59.999999+00 BC'); ERROR: timestamp out of range: "4714-11-23 23:59:59.999999+00 BC" LINE 1: ...ELECT _timescaledb_functions.to_unix_microseconds('4714-11-2... ^ -- The upper bound for Postgres TIMESTAMPTZ SELECT timestamp '294276-12-31 23:59:59.999999+00'; timestamp ----------------------------------- Sun Dec 31 23:59:59.999999 294276 -- Going beyond the upper bound, should fail SELECT timestamp '294276-12-31 23:59:59.999999+00' + interval '1 us'; ERROR: timestamp out of range -- Cannot represent the upper bound timestamp with a UNIX microsecond timestamp -- since the Postgres epoch is at a later date than the UNIX epoch. SELECT _timescaledb_functions.to_unix_microseconds('294276-12-31 23:59:59.999999+00'); ERROR: timestamp out of range -- Subtracting the difference between the two epochs (10957 days) should bring -- us within range. SELECT timestamp '294276-12-31 23:59:59.999999+00' - interval '10957 days'; ?column? ----------------------------------- Fri Jan 01 23:59:59.999999 294247 SELECT _timescaledb_functions.to_unix_microseconds('294247-01-01 23:59:59.999999'); to_unix_microseconds ---------------------- 9223371331199999999 -- Adding one microsecond should take us out-of-range again SELECT timestamp '294247-01-01 23:59:59.999999' + interval '1 us'; ?column? ---------------------------- Sat Jan 02 00:00:00 294247 SELECT _timescaledb_functions.to_unix_microseconds(timestamp '294247-01-01 23:59:59.999999' + interval '1 us'); ERROR: timestamp out of range --no time_bucketing of dates not by integer # of days SELECT time_bucket('1 hour', DATE '2012-01-01'); ERROR: interval must not have sub-day precision SELECT time_bucket('25 hour', DATE '2012-01-01'); ERROR: interval must be a multiple of a day \set ON_ERROR_STOP 1 SELECT time_bucket(INTERVAL '1 day', TIMESTAMP '2011-01-02 01:01:01'); time_bucket -------------------------- Sun Jan 02 00:00:00 2011 SELECT time, time_bucket(INTERVAL '2 day ', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-01 01:01:01', TIMESTAMP '2011-01-02 01:01:01', TIMESTAMP '2011-01-03 01:01:01', TIMESTAMP '2011-01-04 01:01:01' ]) AS time; time | time_bucket --------------------------+-------------------------- Sat Jan 01 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Sun Jan 02 01:01:01 2011 | Sat Jan 01 00:00:00 2011 Mon Jan 03 01:01:01 2011 | Mon Jan 03 00:00:00 2011 Tue Jan 04 01:01:01 2011 | Mon Jan 03 00:00:00 2011 SELECT int_def, time_bucket(int_def,TIMESTAMP '2011-01-02 01:01:01.111') FROM unnest(ARRAY[ INTERVAL '1 millisecond', INTERVAL '1 second', INTERVAL '1 minute', INTERVAL '1 hour', INTERVAL '1 day', INTERVAL '2 millisecond', INTERVAL '2 second', INTERVAL '2 minute', INTERVAL '2 hour', INTERVAL '2 day' ]) AS int_def; int_def | time_bucket --------------+------------------------------ @ 0.001 secs | Sun Jan 02 01:01:01.111 2011 @ 1 sec | Sun Jan 02 01:01:01 2011 @ 1 min | Sun Jan 02 01:01:00 2011 @ 1 hour | Sun Jan 02 01:00:00 2011 @ 1 day | Sun Jan 02 00:00:00 2011 @ 0.002 secs | Sun Jan 02 01:01:01.11 2011 @ 2 secs | Sun Jan 02 01:01:00 2011 @ 2 mins | Sun Jan 02 01:00:00 2011 @ 2 hours | Sun Jan 02 00:00:00 2011 @ 2 days | Sat Jan 01 00:00:00 2011 \set ON_ERROR_STOP 0 SELECT time_bucket(INTERVAL '1 year 1d',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component SELECT time_bucket(INTERVAL '1 month 1 minute',TIMESTAMP '2011-01-02 01:01:01.111'); ERROR: month intervals cannot have day or time component \set ON_ERROR_STOP 1 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '1970-01-01 00:59:59.999999', TIMESTAMP '1970-01-01 01:01:00', TIMESTAMP '1970-01-01 01:04:59.999999', TIMESTAMP '1970-01-01 01:05:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Thu Jan 01 00:59:59.999999 1970 | Thu Jan 01 00:55:00 1970 Thu Jan 01 01:01:00 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:04:59.999999 1970 | Thu Jan 01 01:00:00 1970 Thu Jan 01 01:05:00 1970 | Thu Jan 01 01:05:00 1970 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:04:59.999999', TIMESTAMP '2011-01-02 01:05:00', TIMESTAMP '2011-01-02 01:09:59.999999', TIMESTAMP '2011-01-02 01:10:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:04:59.999999 2011 | Sun Jan 02 01:00:00 2011 Sun Jan 02 01:05:00 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:09:59.999999 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:10:00 2011 | Sun Jan 02 01:10:00 2011 --offset with interval SELECT time, time_bucket(INTERVAL '5 minute', time , INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:02:59.999999', TIMESTAMP '2011-01-02 01:03:00', TIMESTAMP '2011-01-02 01:07:59.999999', TIMESTAMP '2011-01-02 01:08:00' ]) AS time; time | time_bucket ---------------------------------+-------------------------- Sun Jan 02 01:02:59.999999 2011 | Sun Jan 02 00:58:00 2011 Sun Jan 02 01:03:00 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:07:59.999999 2011 | Sun Jan 02 01:03:00 2011 Sun Jan 02 01:08:00 2011 | Sun Jan 02 01:08:00 2011 --offset with infinity -- timestamp SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp '-Infinity', timestamp 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- timestamptz SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity -- Date SELECT date, time_bucket(INTERVAL '1 week', date, INTERVAL '1 day') FROM unnest(ARRAY[ date '-Infinity', date 'Infinity' ]) AS date; date | time_bucket -----------+------------- -infinity | -infinity infinity | infinity --example to align with an origin SELECT time, time_bucket(INTERVAL '5 minute', time - (TIMESTAMP '2011-01-02 00:02:00' - TIMESTAMP 'epoch')) + (TIMESTAMP '2011-01-02 00:02:00'-TIMESTAMP 'epoch') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; time | ?column? ---------------------------------+-------------------------- Sun Jan 02 01:01:59.999999 2011 | Sun Jan 02 00:57:00 2011 Sun Jan 02 01:02:00 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:06:59.999999 2011 | Sun Jan 02 01:02:00 2011 Sun Jan 02 01:07:00 2011 | Sun Jan 02 01:07:00 2011 --rounding version SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2.5 minutes') + INTERVAL '2 minutes 30 seconds' FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:05:01', TIMESTAMP '2011-01-02 01:07:29', TIMESTAMP '2011-01-02 01:02:30', TIMESTAMP '2011-01-02 01:07:30', TIMESTAMP '2011-01-02 01:02:29' ]) AS time; time | ?column? --------------------------+-------------------------- Sun Jan 02 01:05:01 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:29 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:02:30 2011 | Sun Jan 02 01:05:00 2011 Sun Jan 02 01:07:30 2011 | Sun Jan 02 01:10:00 2011 Sun Jan 02 01:02:29 2011 | Sun Jan 02 01:00:00 2011 --time_bucket with timezone should mimick date_trunc SET timezone TO 'UTC'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 01:00:00 2011 UTC | Sun Jan 02 01:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 23:00:00 2011 UTC | Sat Jan 01 23:00:00 2011 UTC SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sun Jan 02 00:01:01 2011 UTC | Sun Jan 02 00:00:00 2011 UTC | Sun Jan 02 00:00:00 2011 UTC Sat Jan 01 23:01:01 2011 UTC | Sat Jan 01 00:00:00 2011 UTC | Sat Jan 01 00:00:00 2011 UTC --what happens with a local tz SET timezone TO 'America/New_York'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 01:00:00 2011 EST | Sun Jan 02 01:00:00 2011 EST Sat Jan 01 19:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sat Jan 01 19:00:00 2011 EST Sat Jan 01 18:01:01 2011 EST | Sat Jan 01 18:00:00 2011 EST | Sat Jan 01 18:00:00 2011 EST --Note the timestamp tz input is aligned with UTC day /not/ local day. different than date_trunc. SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sat Jan 01 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Sun Jan 02 19:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --can force local bucketing with simple cast. SELECT time, time_bucket(INTERVAL '1 day', time::timestamp), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+--------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 | Mon Jan 03 00:00:00 2011 EST --can also use interval to correct SELECT time, time_bucket(INTERVAL '1 day', time, -INTERVAL '19 hours'), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Jan 02 01:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Sun Jan 02 19:01:01 2011 EST | Sun Jan 02 00:00:00 2011 EST | Sun Jan 02 00:00:00 2011 EST Mon Jan 03 18:01:01 2011 EST | Mon Jan 03 00:00:00 2011 EST | Mon Jan 03 00:00:00 2011 EST --dst: same local hour bucketed as two different hours. SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07' ]) AS time; time | time_bucket | date_trunc ------------------------------+------------------------------+------------------------------ Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT | Sun Nov 05 01:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST | Sun Nov 05 01:00:00 2017 EST --local alignment changes when bucketing by UTC across dst boundary SELECT time, time_bucket(INTERVAL '2 hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 EDT Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 01:00:00 2017 EST Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 03:00:00 2017 EST --local alignment is preserved when bucketing by local time across DST boundary. SELECT time, time_bucket(INTERVAL '2 hour', time::timestamp) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; time | time_bucket ------------------------------+-------------------------- Sat Nov 04 23:05:00 2017 EDT | Sat Nov 04 22:00:00 2017 Sun Nov 05 01:05:00 2017 EDT | Sun Nov 05 00:00:00 2017 Sun Nov 05 01:05:00 2017 EST | Sun Nov 05 00:00:00 2017 Sun Nov 05 03:05:00 2017 EST | Sun Nov 05 02:00:00 2017 SELECT time, time_bucket(10::smallint, time) AS time_bucket_smallint, time_bucket(10::int, time) AS time_bucket_int, time_bucket(10::bigint, time) AS time_bucket_bigint FROM unnest(ARRAY[ '-11', '-10', '-9', '-1', '0', '1', '99', '100', '109', '110' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -11 | -20 | -20 | -20 -10 | -10 | -10 | -10 -9 | -10 | -10 | -10 -1 | -10 | -10 | -10 0 | 0 | 0 | 0 1 | 0 | 0 | 0 99 | 90 | 90 | 90 100 | 100 | 100 | 100 109 | 100 | 100 | 100 110 | 110 | 110 | 110 SELECT time, time_bucket(10::smallint, time, 2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, 2::int) AS time_bucket_int, time_bucket(10::bigint, time, 2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-9', '-8', '-7', '1', '2', '3', '101', '102', '111', '112' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -9 | -18 | -18 | -18 -8 | -8 | -8 | -8 -7 | -8 | -8 | -8 1 | -8 | -8 | -8 2 | 2 | 2 | 2 3 | 2 | 2 | 2 101 | 92 | 92 | 92 102 | 102 | 102 | 102 111 | 102 | 102 | 102 112 | 112 | 112 | 112 SELECT time, time_bucket(10::smallint, time, -2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, -2::int) AS time_bucket_int, time_bucket(10::bigint, time, -2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-13', '-12', '-11', '-3', '-2', '-1', '97', '98', '107', '108' ]::smallint[]) AS time; time | time_bucket_smallint | time_bucket_int | time_bucket_bigint ------+----------------------+-----------------+-------------------- -13 | -22 | -22 | -22 -12 | -12 | -12 | -12 -11 | -12 | -12 | -12 -3 | -12 | -12 | -12 -2 | -2 | -2 | -2 -1 | -2 | -2 | -2 97 | 88 | 88 | 88 98 | 98 | 98 | 98 107 | 98 | 98 | 98 108 | 108 | 108 | 108 \set ON_ERROR_STOP 0 SELECT time_bucket(10::smallint, '-32768'::smallint); ERROR: timestamp out of range SELECT time_bucket(10::smallint, '-32761'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, 1000::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '-32768'::smallint, '32767'::smallint); ERROR: timestamp out of range select time_bucket(10::smallint, '32767'::smallint, '-32768'::smallint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::smallint, time) FROM unnest(ARRAY[ '-32760', '-32759', '32767' ]::smallint[]) AS time; time | time_bucket --------+------------- -32760 | -32760 -32759 | -32760 32767 | 32760 \set ON_ERROR_STOP 0 SELECT time_bucket(10::int, '-2147483648'::int); ERROR: timestamp out of range SELECT time_bucket(10::int, '-2147483641'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483000'::int, 1::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '-2147483648'::int, '2147483647'::int); ERROR: timestamp out of range SELECT time_bucket(1000::int, '2147483647'::int, '-2147483648'::int); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::int, time) FROM unnest(ARRAY[ '-2147483640', '-2147483639', '2147483647' ]::int[]) AS time; time | time_bucket -------------+------------- -2147483640 | -2147483640 -2147483639 | -2147483640 2147483647 | 2147483640 \set ON_ERROR_STOP 0 SELECT time_bucket(10::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range SELECT time_bucket(10::bigint, '-9223372036854775801'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775000'::bigint, 1::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '-9223372036854775808'::bigint, '9223372036854775807'::bigint); ERROR: timestamp out of range SELECT time_bucket(1000::bigint, '9223372036854775807'::bigint, '-9223372036854775808'::bigint); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::bigint, time) FROM unnest(ARRAY[ '-9223372036854775800', '-9223372036854775799', '9223372036854775807' ]::bigint[]) AS time; time | time_bucket ----------------------+---------------------- -9223372036854775800 | -9223372036854775800 -9223372036854775799 | -9223372036854775800 9223372036854775807 | 9223372036854775800 SELECT time, time_bucket(INTERVAL '1 day', time::date) FROM unnest(ARRAY[ date '2017-11-05', date '2017-11-06' ]) AS time; time | time_bucket ------------+------------- 11-05-2017 | 11-05-2017 11-06-2017 | 11-06-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date) FROM unnest(ARRAY[ date '2017-11-04', date '2017-11-05', date '2017-11-08', date '2017-11-09' ]) AS time; time | time_bucket ------------+------------- 11-04-2017 | 11-01-2017 11-05-2017 | 11-05-2017 11-08-2017 | 11-05-2017 11-09-2017 | 11-09-2017 SELECT time, time_bucket(INTERVAL '4 day', time::date, INTERVAL '2 day') FROM unnest(ARRAY[ date '2017-11-06', date '2017-11-07', date '2017-11-10', date '2017-11-11' ]) AS time; time | time_bucket ------------+------------- 11-06-2017 | 11-03-2017 11-07-2017 | 11-07-2017 11-10-2017 | 11-07-2017 11-11-2017 | 11-11-2017 -- 2019-09-24 is a Monday, and we want to ensure that time_bucket returns the week starting with a Monday as date_trunc does, -- Rather than a Saturday which is the date of the PostgreSQL epoch SELECT time, time_bucket(INTERVAL '1 week', time::date) FROM unnest(ARRAY[ date '2018-09-16', date '2018-09-17', date '2018-09-23', date '2018-09-24' ]) AS time; time | time_bucket ------------+------------- 09-16-2018 | 09-10-2018 09-17-2018 | 09-17-2018 09-23-2018 | 09-17-2018 09-24-2018 | 09-24-2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '2018-09-16', timestamp without time zone '2018-09-17', timestamp without time zone '2018-09-23', timestamp without time zone '2018-09-24' ]) AS time; time | time_bucket --------------------------+-------------------------- Sun Sep 16 00:00:00 2018 | Mon Sep 10 00:00:00 2018 Mon Sep 17 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Sun Sep 23 00:00:00 2018 | Mon Sep 17 00:00:00 2018 Mon Sep 24 00:00:00 2018 | Mon Sep 24 00:00:00 2018 SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '2018-09-16', timestamp with time zone '2018-09-17', timestamp with time zone '2018-09-23', timestamp with time zone '2018-09-24' ]) AS time; time | time_bucket ------------------------------+------------------------------ Sun Sep 16 00:00:00 2018 EDT | Sun Sep 09 20:00:00 2018 EDT Mon Sep 17 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Sun Sep 23 00:00:00 2018 EDT | Sun Sep 16 20:00:00 2018 EDT Mon Sep 24 00:00:00 2018 EDT | Sun Sep 23 20:00:00 2018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '-Infinity', timestamp without time zone 'Infinity' ]) AS time; time | time_bucket -----------+------------- -infinity | -infinity infinity | infinity SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '4714-11-24 01:01:01.0 BC', timestamp without time zone '294276-12-31 23:59:59.9999' ]) AS time; time | time_bucket | ?column? ---------------------------------+-----------------------------+---------- Mon Nov 24 01:01:01 4714 BC | Mon Nov 24 00:00:00 4714 BC | t Sun Dec 31 23:59:59.9999 294276 | Mon Dec 25 00:00:00 294276 | t --1000 years later weeks still align. SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-20', timestamp without time zone '3018-09-21', timestamp without time zone '3018-09-22' ]) AS time; time | time_bucket | ?column? --------------------------+--------------------------+---------- Mon Sep 14 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Sun Sep 20 00:00:00 3018 | Mon Sep 14 00:00:00 3018 | t Mon Sep 21 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t Tue Sep 22 00:00:00 3018 | Mon Sep 21 00:00:00 3018 | t --weeks align for timestamptz as well if cast to local time, (but not if done at UTC). SELECT time, date_trunc('week', time) = time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time::timestamp) FROM unnest(ARRAY[ timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-20', timestamp with time zone '3018-09-21', timestamp with time zone '3018-09-22' ]) AS time; time | ?column? | ?column? ------------------------------+----------+---------- Mon Sep 14 00:00:00 3018 EDT | f | t Sun Sep 20 00:00:00 3018 EDT | f | t Mon Sep 21 00:00:00 3018 EDT | f | t Tue Sep 22 00:00:00 3018 EDT | f | t --check functions with origin --note that the default origin is at 0 UTC, using origin parameter it is easy to provide a EDT origin point \x SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time::timestamp) no_epoch_local, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-03 00:00:00+0') always_true, time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamptz 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp with time zone '2000-01-01 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-01 00:00:00+0', timestamp with time zone '2000-01-03 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-03 00:00:00+0', timestamp with time zone '2000-01-01', timestamp with time zone '2000-01-02', timestamp with time zone '2000-01-03', timestamp with time zone '3018-09-12', timestamp with time zone '3018-09-13', timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]--+----------------------------- time | Fri Dec 31 18:59:59 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 24 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 2 ]--+----------------------------- time | Fri Dec 31 19:00:00 1999 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 3 ]--+----------------------------- time | Sun Jan 02 18:59:59 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 4 ]--+----------------------------- time | Sun Jan 02 19:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 5 ]--+----------------------------- time | Sat Jan 01 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Dec 25 23:00:00 1999 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 6 ]--+----------------------------- time | Sun Jan 02 00:00:00 2000 EST no_epoch | Sun Dec 26 19:00:00 1999 EST no_epoch_local | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Dec 26 23:00:00 1999 EST -[ RECORD 7 ]--+----------------------------- time | Mon Jan 03 00:00:00 2000 EST no_epoch | Sun Jan 02 19:00:00 2000 EST no_epoch_local | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Fri Dec 31 19:00:00 1999 EST unix_epoch | Wed Dec 29 19:00:00 1999 EST custom_1 | Sat Jan 01 23:00:00 2000 EST custom_2 | Sun Jan 02 23:00:00 2000 EST -[ RECORD 8 ]--+----------------------------- time | Sat Sep 12 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 06 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 9 ]--+----------------------------- time | Sun Sep 13 00:00:00 3018 EDT no_epoch | Sun Sep 06 20:00:00 3018 EDT no_epoch_local | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 07 00:00:00 3018 EDT -[ RECORD 10 ]-+----------------------------- time | Mon Sep 14 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT -[ RECORD 11 ]-+----------------------------- time | Tue Sep 15 00:00:00 3018 EDT no_epoch | Sun Sep 13 20:00:00 3018 EDT no_epoch_local | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Fri Sep 11 20:00:00 3018 EDT unix_epoch | Wed Sep 09 20:00:00 3018 EDT custom_1 | Sun Sep 13 00:00:00 3018 EDT custom_2 | Mon Sep 14 00:00:00 3018 EDT SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamp '2000-01-03 00:00:00') always_true, time_bucket(INTERVAL '1 week', time, timestamp '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamp 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp without time zone '2000-01-01 00:00:00'- interval '1 second', timestamp without time zone '2000-01-01 00:00:00', timestamp without time zone '2000-01-03 00:00:00'- interval '1 second', timestamp without time zone '2000-01-03 00:00:00', timestamp without time zone '2000-01-01', timestamp without time zone '2000-01-02', timestamp without time zone '2000-01-03', timestamp without time zone '3018-09-12', timestamp without time zone '3018-09-13', timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-15' ]) AS time; -[ RECORD 1 ]------------------------- time | Fri Dec 31 23:59:59 1999 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Dec 25 00:00:00 1999 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 2 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 3 ]------------------------- time | Sun Jan 02 23:59:59 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 4 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 5 ]------------------------- time | Sat Jan 01 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Dec 26 00:00:00 1999 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 6 ]------------------------- time | Sun Jan 02 00:00:00 2000 no_epoch | Mon Dec 27 00:00:00 1999 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Dec 27 00:00:00 1999 -[ RECORD 7 ]------------------------- time | Mon Jan 03 00:00:00 2000 no_epoch | Mon Jan 03 00:00:00 2000 always_true | t pg_epoch | Sat Jan 01 00:00:00 2000 unix_epoch | Thu Dec 30 00:00:00 1999 custom_1 | Sun Jan 02 00:00:00 2000 custom_2 | Mon Jan 03 00:00:00 2000 -[ RECORD 8 ]------------------------- time | Sat Sep 12 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 06 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 9 ]------------------------- time | Sun Sep 13 00:00:00 3018 no_epoch | Mon Sep 07 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 07 00:00:00 3018 -[ RECORD 10 ]------------------------ time | Mon Sep 14 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 -[ RECORD 11 ]------------------------ time | Tue Sep 15 00:00:00 3018 no_epoch | Mon Sep 14 00:00:00 3018 always_true | t pg_epoch | Sat Sep 12 00:00:00 3018 unix_epoch | Thu Sep 10 00:00:00 3018 custom_1 | Sun Sep 13 00:00:00 3018 custom_2 | Mon Sep 14 00:00:00 3018 SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, date '2000-01-03') always_true, time_bucket(INTERVAL '1 week', time, date '2000-01-01') pg_epoch, time_bucket(INTERVAL '1 week', time, (timestamp 'epoch')::date) unix_epoch, time_bucket(INTERVAL '1 week', time, date '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, date '3018-09-14') custom_2 FROM unnest(ARRAY[ date '1999-12-31', date '2000-01-01', date '2000-01-02', date '2000-01-03', date '3018-09-12', date '3018-09-13', date '3018-09-14', date '3018-09-15' ]) AS time; -[ RECORD 1 ]----------- time | 12-31-1999 no_epoch | 12-27-1999 always_true | t pg_epoch | 12-25-1999 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 2 ]----------- time | 01-01-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 12-26-1999 custom_2 | 12-27-1999 -[ RECORD 3 ]----------- time | 01-02-2000 no_epoch | 12-27-1999 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 12-27-1999 -[ RECORD 4 ]----------- time | 01-03-2000 no_epoch | 01-03-2000 always_true | t pg_epoch | 01-01-2000 unix_epoch | 12-30-1999 custom_1 | 01-02-2000 custom_2 | 01-03-2000 -[ RECORD 5 ]----------- time | 09-12-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-06-3018 custom_2 | 09-07-3018 -[ RECORD 6 ]----------- time | 09-13-3018 no_epoch | 09-07-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-07-3018 -[ RECORD 7 ]----------- time | 09-14-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 -[ RECORD 8 ]----------- time | 09-15-3018 no_epoch | 09-14-3018 always_true | t pg_epoch | 09-12-3018 unix_epoch | 09-10-3018 custom_1 | 09-13-3018 custom_2 | 09-14-3018 \x --really old origin works if date around that time SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC', timestamp without time zone '4710-11-25 01:01:01.0 BC', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket -----------------------------+----------------------------- Sat Nov 24 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Sun Nov 25 01:01:01 4710 BC | Sat Nov 24 01:01:01 4710 BC Mon Jan 01 00:00:00 2001 | Sat Dec 30 01:01:01 2000 Thu Jan 01 00:00:00 3001 | Sat Dec 27 01:01:01 3000 SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '294270-12-30 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '294270-12-29 23:59:59.9999', timestamp without time zone '294270-12-30 23:59:59.9999', timestamp without time zone '294270-12-31 23:59:59.9999', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; time | time_bucket ---------------------------------+--------------------------------- Thu Dec 29 23:59:59.9999 294270 | Fri Dec 23 23:59:59.9999 294270 Fri Dec 30 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Sat Dec 31 23:59:59.9999 294270 | Fri Dec 30 23:59:59.9999 294270 Mon Jan 01 00:00:00 2001 | Fri Dec 29 23:59:59.9999 2000 Thu Jan 01 00:00:00 3001 | Fri Dec 26 23:59:59.9999 3000 \set ON_ERROR_STOP 0 --really old origin + very new data + long period errors SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '294270-12-31 23:59:59.9999' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp with time zone '4710-11-25 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp with time zone '294270-12-30 23:59:59.9999' ]) AS time; ERROR: timestamp out of range --really high origin + old data + long period errors out SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp without time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp with time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp with time zone '4710-11-24 01:01:01.0 BC' ]) AS time; ERROR: timestamp out of range \set ON_ERROR_STOP 1 ------------------------------------------- --- Test time_bucket with month periods --- ------------------------------------------- SET datestyle TO ISO; SELECT time::date, time_bucket('1 month', time::date) AS "1m", time_bucket('2 month', time::date) AS "2m", time_bucket('3 month', time::date) AS "3m", time_bucket('1 month', time::date, '2000-02-01'::date) AS "1m origin", time_bucket('2 month', time::date, '2000-02-01'::date) AS "2m origin", time_bucket('3 month', time::date, '2000-02-01'::date) AS "3m origin" FROM generate_series('1990-01-03'::date,'1990-06-03'::date,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------+------------+------------+------------+------------+------------+------------ 1990-01-03 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1990-01-01 | 1989-12-01 | 1989-11-01 1990-02-03 | 1990-02-01 | 1990-01-01 | 1990-01-01 | 1990-02-01 | 1990-02-01 | 1990-02-01 1990-03-03 | 1990-03-01 | 1990-03-01 | 1990-01-01 | 1990-03-01 | 1990-02-01 | 1990-02-01 1990-04-03 | 1990-04-01 | 1990-03-01 | 1990-04-01 | 1990-04-01 | 1990-04-01 | 1990-02-01 1990-05-03 | 1990-05-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 | 1990-04-01 | 1990-05-01 1990-06-03 | 1990-06-01 | 1990-05-01 | 1990-04-01 | 1990-06-01 | 1990-06-01 | 1990-05-01 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamp) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamp) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamp) AS "3m origin" FROM generate_series('1990-01-03'::timestamp,'1990-06-03'::timestamp,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+--------------------- 1990-01-03 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1989-12-01 00:00:00 | 1989-11-01 00:00:00 1990-02-03 00:00:00 | 1990-02-01 00:00:00 | 1990-01-01 00:00:00 | 1990-01-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-03-03 00:00:00 | 1990-03-01 00:00:00 | 1990-03-01 00:00:00 | 1990-01-01 00:00:00 | 1990-03-01 00:00:00 | 1990-02-01 00:00:00 | 1990-02-01 00:00:00 1990-04-03 00:00:00 | 1990-04-01 00:00:00 | 1990-03-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-04-01 00:00:00 | 1990-02-01 00:00:00 1990-05-03 00:00:00 | 1990-05-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-05-01 00:00:00 1990-06-03 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 | 1990-04-01 00:00:00 | 1990-06-01 00:00:00 | 1990-06-01 00:00:00 | 1990-05-01 00:00:00 SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamptz) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamptz) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamptz) AS "3m origin" FROM generate_series('1990-01-03'::timestamptz,'1990-06-03'::timestamptz,'1month'::interval) time; time | 1m | 2m | 3m | 1m origin | 2m origin | 3m origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1990-01-03 00:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-11-30 19:00:00-05 | 1989-10-31 19:00:00-05 1990-02-03 00:00:00-05 | 1990-01-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-03-03 00:00:00-05 | 1990-02-28 19:00:00-05 | 1990-02-28 19:00:00-05 | 1989-12-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-01-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-04-03 00:00:00-04 | 1990-03-31 19:00:00-05 | 1990-02-28 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-03-31 19:00:00-05 | 1990-01-31 19:00:00-05 1990-05-03 00:00:00-04 | 1990-04-30 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-04-30 20:00:00-04 1990-06-03 00:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 | 1990-03-31 19:00:00-05 | 1990-05-31 20:00:00-04 | 1990-05-31 20:00:00-04 | 1990-04-30 20:00:00-04 --------------------------------------- --- Test time_bucket with timezones --- --------------------------------------- -- test NULL args SELECT time_bucket(NULL::interval,now(),'Europe/Berlin'), time_bucket('1day',NULL::timestamptz,'Europe/Berlin'), time_bucket('1day',now(),NULL::text), time_bucket('1day','2020-02-03','Europe/Berlin',NULL), time_bucket('1day','2020-02-03','Europe/Berlin','2020-04-01',NULL), time_bucket('1day','2020-02-03','Europe/Berlin',NULL,NULL), time_bucket('1day','2020-02-03','Europe/Berlin',"offset":=NULL::interval), time_bucket('1day','2020-02-03','Europe/Berlin',origin:=NULL::timestamptz); time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket | time_bucket -------------+-------------+-------------+------------------------+------------------------+------------------------+------------------------+------------------------ | | | 2020-02-02 18:00:00-05 | 2020-02-03 00:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 | 2020-02-02 18:00:00-05 SET datestyle TO ISO; SELECT time_bucket('1day', ts) AS "UTC", time_bucket('1day', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1day', ts, 'Europe/London') AS "London", time_bucket('1day', ts, 'America/New_York') AS "New York", time_bucket('1day', ts, 'PST') AS "PST", time_bucket('1day', ts, current_setting('timezone')) AS "current" FROM generate_series('1999-12-31 17:00'::timestamptz,'2000-01-02 3:00'::timestamptz, '1hour'::interval) ts; UTC | Berlin | London | New York | PST | current ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-12-30 19:00:00-05 | 1999-12-30 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-30 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-30 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 1999-12-31 00:00:00-05 | 1999-12-31 03:00:00-05 | 1999-12-31 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-31 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 1999-12-31 19:00:00-05 | 2000-01-01 18:00:00-05 | 1999-12-31 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-01 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-01 03:00:00-05 | 2000-01-02 00:00:00-05 2000-01-01 19:00:00-05 | 2000-01-01 18:00:00-05 | 2000-01-01 19:00:00-05 | 2000-01-02 00:00:00-05 | 2000-01-02 03:00:00-05 | 2000-01-02 00:00:00-05 SELECT time_bucket('1month', ts) AS "UTC", time_bucket('1month', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1month', ts, 'America/New_York') AS "New York", time_bucket('1month', ts, current_setting('timezone')) AS "current", time_bucket('2month', ts, current_setting('timezone')) AS "2m", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp) AS "2m origin", time_bucket('2month', ts, current_setting('timezone'), "offset":='14 day'::interval) AS "2m offset", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp, '7 day'::interval) AS "2m offset + origin" FROM generate_series('1999-12-01'::timestamptz,'2000-09-01'::timestamptz, '9 day'::interval) ts; UTC | Berlin | New York | current | 2m | 2m origin | 2m offset | 2m offset + origin ------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------+------------------------ 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-10-08 00:00:00-04 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-11-30 19:00:00-05 | 1999-11-30 18:00:00-05 | 1999-12-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 1999-11-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 1999-12-31 19:00:00-05 | 1999-12-31 18:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 1999-12-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 1999-12-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-01-31 19:00:00-05 | 2000-01-31 18:00:00-05 | 2000-02-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-01-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-02-29 19:00:00-05 | 2000-02-29 18:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-02-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-02-08 00:00:00-05 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-03-31 19:00:00-05 | 2000-03-31 17:00:00-05 | 2000-04-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-01 00:00:00-05 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-03-15 00:00:00-05 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-04-30 20:00:00-04 | 2000-04-30 18:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-04-01 00:00:00-05 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-04-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-05-31 20:00:00-04 | 2000-05-31 18:00:00-04 | 2000-06-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-05-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-06-30 20:00:00-04 | 2000-06-30 18:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-06-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-06-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 2000-07-31 20:00:00-04 | 2000-07-31 18:00:00-04 | 2000-08-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-01 00:00:00-04 | 2000-08-01 00:00:00-04 | 2000-07-15 00:00:00-04 | 2000-08-08 00:00:00-04 RESET datestyle; ------------------------------------------------------------ --- Test timescaledb_experimental.time_bucket_ng function -- ------------------------------------------------------------ -- not supported functionality \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 hour', '2001-02-03' :: date) AS result; ERROR: interval must be either days and weeks, or months and years SELECT timescaledb_experimental.time_bucket_ng('0 days', '2001-02-03' :: date) AS result; ERROR: interval must be at least one day SELECT timescaledb_experimental.time_bucket_ng('1 month', '2001-02-03' :: date, origin => '2000-01-02') AS result; ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. SELECT timescaledb_experimental.time_bucket_ng('1 month', '2000-01-02' :: date, origin => '2001-01-01') AS result; result ------------ 01-01-2000 SELECT timescaledb_experimental.time_bucket_ng('1 day', '2000-01-02' :: date, origin => '2001-01-01') AS result; ERROR: origin must be before the given date SELECT timescaledb_experimental.time_bucket_ng('1 month 3 hours', '2021-11-22' :: timestamp) AS result; ERROR: interval can't combine months with minutes or hours -- timestamp is less than the default 'origin' value SELECT timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, timezone => 'MSK'); ERROR: origin must be before the given date -- 'origin' in Europe/Moscow timezone is not the first day of the month at given time zone (UTC in this case) select timescaledb_experimental.time_bucket_ng('1 month', '2021-07-12 12:34:56 Europe/Moscow' :: timestamptz, origin => '2021-06-01 00:00:00 Europe/Moscow' :: timestamptz, timezone => 'UTC'); ERROR: origin must be the first day of the month HINT: When using timestamptz-version of the function, 'origin' is converted to provided 'timezone'. \set ON_ERROR_STOP 1 -- wrappers SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp) AS result; result -------------------------- Fri Jan 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz) AS result; result ------------------------------ Fri Jan 01 00:00:00 2021 EST SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp, origin => '2021-06-01') AS result; result -------------------------- Tue Jun 01 00:00:00 2021 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz, origin => '2021-06-01') AS result; result ------------------------------ Tue Jun 01 00:00:00 2021 EDT -- null argument SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, timezone => 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null interval SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, 'Europe/Moscow') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01') AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result -------- -- null origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null) AS result; result -------- SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null, timezone => 'Europe/Moscow') AS result; result -------- -- infinity argument SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, timezone => 'Europe/Moscow') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp) AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp, origin => '2021-06-01') AS result; result ---------- infinity -- infinite origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity') AS result; result ---------- infinity SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity', timezone => 'Europe/Moscow') AS result; result ---------- infinity -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; result ---------- infinity -- test for invalid timezone argument SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => null) AS result; result -------- \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => 'Europe/Ololondon') AS result; ERROR: time zone "Europe/Ololondon" not recognized \set ON_ERROR_STOP 1 -- Make sure time_bucket_ng() supports seconds, minutes, and hours. -- We happen to know that the internal implementation is the same -- as for time_bucket(), thus there is no reason to execute all the tests -- we already have for time_bucket(). These two functions will most likely -- be merged eventually anyway. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:30:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp) AS result; result -------------------------- Mon Jul 12 12:00:00 2021 -- Same as above, but with provided 'origin' argument. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:34:30 2021 SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:25:00 2021 SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; result -------------------------- Mon Jul 12 12:10:00 2021 -- N days / weeks buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2019-12-31 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-02 | 2020-01-02 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-03 | 2020-01-03 | 2020-01-02 | 2020-01-01 | 2019-12-28 | 2019-12-26 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-06 | 2020-01-06 | 2020-01-06 | 2020-01-04 | 2020-01-04 | 2020-01-04 2020-01-07 | 2020-01-07 | 2020-01-06 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-08 | 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-09 | 2020-01-09 | 2020-01-08 | 2020-01-07 | 2020-01-04 | 2020-01-04 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-10 | 2020-01-04 | 2020-01-04 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-10 | 2020-01-11 | 2020-01-04 2020-01-12 | 2020-01-12 | 2020-01-12 | 2020-01-10 | 2020-01-11 | 2020-01-04 -- N days / weeks buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; d | d1 | d2 | d3 | w1 | w1d2 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-02 | 2020-01-02 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-03 | 2020-01-03 | 2020-01-03 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-01-04 | 2020-01-04 | 2020-01-03 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-05 | 2020-01-05 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-06 | 2020-01-06 | 2020-01-05 | 2020-01-04 | 2020-01-01 | 2020-01-01 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-07 | 2020-01-01 | 2020-01-01 2020-01-08 | 2020-01-08 | 2020-01-07 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-09 | 2020-01-09 | 2020-01-09 | 2020-01-07 | 2020-01-08 | 2020-01-01 2020-01-10 | 2020-01-10 | 2020-01-09 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-11 | 2020-01-11 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 2020-01-12 | 2020-01-12 | 2020-01-11 | 2020-01-10 | 2020-01-08 | 2020-01-10 -- N month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-01-01 | 2020-01-01 | 2020-01-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-04-01 | 2020-01-01 | 2020-01-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-01-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-04-01 | 2020-05-01 | 2020-06-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-06-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-07-01 | 2020-09-01 | 2020-06-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-10-01 | 2020-09-01 | 2020-06-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-10-01 | 2020-09-01 | 2020-11-01 -- N month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; d | m1 | m2 | m3 | m4 | m5 ------------+------------+------------+------------+------------+------------ 2020-01-01 | 2020-01-01 | 2020-01-01 | 2019-11-01 | 2020-01-01 | 2019-10-01 2020-02-01 | 2020-02-01 | 2020-01-01 | 2020-02-01 | 2020-01-01 | 2019-10-01 2020-03-01 | 2020-03-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-04-01 | 2020-04-01 | 2020-03-01 | 2020-02-01 | 2020-01-01 | 2020-03-01 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-06-01 | 2020-06-01 | 2020-05-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-07-01 | 2020-07-01 | 2020-07-01 | 2020-05-01 | 2020-05-01 | 2020-03-01 2020-08-01 | 2020-08-01 | 2020-07-01 | 2020-08-01 | 2020-05-01 | 2020-08-01 2020-09-01 | 2020-09-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-10-01 | 2020-10-01 | 2020-09-01 | 2020-08-01 | 2020-09-01 | 2020-08-01 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 2020-12-01 | 2020-12-01 | 2020-11-01 | 2020-11-01 | 2020-09-01 | 2020-08-01 -- N years / N years, M month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2015-07-01 | 2015-01-01 | 2015-01-01 | 2014-01-01 | 2015-01-01 | 2015-01-01 2016-01-01 | 2016-01-01 | 2015-01-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2016-07-01 | 2016-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-01-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2015-01-01 | 2015-01-01 2017-07-01 | 2017-01-01 | 2016-07-01 | 2016-01-01 | 2017-07-01 | 2015-01-01 2018-01-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2018-07-01 | 2018-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-01-01 | 2019-01-01 | 2018-01-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2019-07-01 | 2019-01-01 | 2019-07-01 | 2018-01-01 | 2017-07-01 | 2018-01-01 2020-01-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 2020-07-01 | 2020-01-01 | 2019-07-01 | 2020-01-01 | 2020-01-01 | 2018-01-01 -- N years / N years, M month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; d | y1 | y1m6 | y2 | y2m6 | y3 ------------+------------+------------+------------+------------+------------ 2015-01-01 | 2014-06-01 | 2013-12-01 | 2014-06-01 | 2012-12-01 | 2012-06-01 2015-07-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-01-01 | 2015-06-01 | 2015-06-01 | 2014-06-01 | 2015-06-01 | 2015-06-01 2016-07-01 | 2016-06-01 | 2015-06-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-01-01 | 2016-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2017-07-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2015-06-01 | 2015-06-01 2018-01-01 | 2017-06-01 | 2016-12-01 | 2016-06-01 | 2017-12-01 | 2015-06-01 2018-07-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-01-01 | 2018-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2019-07-01 | 2019-06-01 | 2018-06-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-01-01 | 2019-06-01 | 2019-12-01 | 2018-06-01 | 2017-12-01 | 2018-06-01 2020-07-01 | 2020-06-01 | 2019-12-01 | 2020-06-01 | 2020-06-01 | 2018-06-01 -- Test timezones support with different bucket sizes BEGIN; -- Timestamptz type is displayed in the session timezone. -- To get consistent results during the test we temporary set the session -- timezone to the known one. SET TIME ZONE '+00'; -- Moscow is UTC+3 in the year 2021. Let's say you are dealing with '1 day' bucket. -- In order to calculate the beginning of the bucket you have to take LOCAL -- Moscow time and throw away the time. You will get the midnight. The new day -- starts 3 hours EARLIER in Moscow than in UTC+0 time zone, thus resulting -- timestamp will be 3 hours LESS than for UTC+0. SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow', 'UTC']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-04-30 21:00:00 +00 1 year | Europe/Moscow | 2020-12-31 21:00:00 +00 12 hours | UTC | 2021-07-12 00:00:00 +00 1 day | UTC | 2021-07-12 00:00:00 +00 1 month | UTC | 2021-07-01 00:00:00 +00 4 months | UTC | 2021-05-01 00:00:00 +00 1 year | UTC | 2021-01-01 00:00:00 +00 -- Same as above, but with 'origin' SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array['2021-06-01 00:00:00 Europe/Moscow' :: timestamptz]) as origin_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, origin => origin_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; bs | tz | res ----------+---------------+------------------------- 12 hours | Europe/Moscow | 2021-07-12 09:00:00 +00 1 day | Europe/Moscow | 2021-07-11 21:00:00 +00 1 month | Europe/Moscow | 2021-06-30 21:00:00 +00 4 months | Europe/Moscow | 2021-05-31 21:00:00 +00 1 year | Europe/Moscow | 2021-05-31 21:00:00 +00 -- Overwritten origin allows to work with dates earlier than the default origin SELECT to_char(timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, origin => '1900-01-01 00:00:00 MSK', timezone => 'MSK'), 'YYYY-MM-DD HH24:MI:SS TZ'); to_char ------------------------- 1998-12-31 21:00:00 +00 -- Restore previously used time zone. ROLLBACK; ------------------------------------- --- Test time input functions -- ------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.interval_to_internal(coltype REGTYPE, value ANYELEMENT = NULL::BIGINT) RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_dimension_interval_to_internal_test' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT test.interval_to_internal('TIMESTAMP'::regtype, INTERVAL '1 day'); interval_to_internal ---------------------- 86400000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400000000); interval_to_internal ---------------------- 86400000000 ---should give warning SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400); WARNING: unexpected interval: smaller than one second HINT: The interval is specified in microseconds. interval_to_internal ---------------------- 86400 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('BIGINT'::regtype, 2147483649::bigint); interval_to_internal ---------------------- 2147483649 -- Default interval for integer is supported as part of -- hypertable generalization SELECT test.interval_to_internal('INT'::regtype); interval_to_internal ---------------------- 100000 SELECT test.interval_to_internal('SMALLINT'::regtype); interval_to_internal ---------------------- 10000 SELECT test.interval_to_internal('BIGINT'::regtype); interval_to_internal ---------------------- 1000000 SELECT test.interval_to_internal('TIMESTAMPTZ'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('TIMESTAMP'::regtype); interval_to_internal ---------------------- 604800000000 SELECT test.interval_to_internal('DATE'::regtype); interval_to_internal ---------------------- 604800000000 \set VERBOSITY terse \set ON_ERROR_STOP 0 SELECT test.interval_to_internal('INT'::regtype, 2147483649::bigint); ERROR: invalid interval: must be between 1 and 2147483647 SELECT test.interval_to_internal('SMALLINT'::regtype, 32768::bigint); ERROR: invalid interval: must be between 1 and 32767 SELECT test.interval_to_internal('TEXT'::regtype, 32768::bigint); ERROR: invalid type for dimension "testcol" SELECT test.interval_to_internal('INT'::regtype, INTERVAL '1 day'); ERROR: invalid interval type for integer dimension \set ON_ERROR_STOP 1 ����������������������������������������������������������timescaledb-2.23.0/test/expected/triggers.out�������������������������������������������������������0000664�0000000�0000000�00000067377�15100345067�0021236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE hyper ( time BIGINT NOT NULL, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ DECLARE cnt INTEGER; BEGIN SELECT count(*) INTO cnt FROM hyper; RAISE WARNING 'FIRING trigger when: % level: % op: % cnt: % trigger_name %', tg_when, tg_level, tg_op, cnt, tg_name; IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- row triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert BEFORE INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update BEFORE UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete BEFORE delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all BEFORE INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- row triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_after AFTER INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_insert_after_when_dev1 AFTER INSERT ON hyper FOR EACH ROW WHEN (NEW.device_id = 'dev1') EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_after AFTER UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_after AFTER delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all_after AFTER INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- statement triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert_s_before BEFORE INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_before BEFORE UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_before BEFORE DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); -- statement triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_s_after AFTER INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_after AFTER UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_after AFTER DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); -- CONSTRAINT TRIGGER CREATE CONSTRAINT TRIGGER _0_test_trigger_constraint_insert AFTER INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE CONSTRAINT TRIGGER _0_test_trigger_constraint_update AFTER UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE CONSTRAINT TRIGGER _0_test_trigger_constraint_delete AFTER DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t --test triggers before create_hypertable INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987600000000000, 'dev1', 1); WARNING: FIRING trigger when: BEFORE level: STATEMENT op: INSERT cnt: 0 trigger_name _0_test_trigger_insert_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 0 trigger_name _0_test_trigger_insert WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 0 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_after_when_dev1 WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_s_after INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 1), (1257987800000000000, 'dev2', 1); WARNING: FIRING trigger when: BEFORE level: STATEMENT op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 1 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 2 trigger_name _0_test_trigger_insert WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 2 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_insert_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_insert_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 3 trigger_name _0_test_trigger_insert_s_after UPDATE hyper SET sensor_1 = 2; WARNING: FIRING trigger when: BEFORE level: STATEMENT op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_s_after DELETE FROM hyper; WARNING: FIRING trigger when: BEFORE level: STATEMENT op: DELETE cnt: 3 trigger_name _0_test_trigger_delete_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 3 trigger_name _0_test_trigger_delete WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 2 trigger_name _0_test_trigger_delete WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 2 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 1 trigger_name _0_test_trigger_delete WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 1 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_s_after --test drop trigger DROP TRIGGER _0_test_trigger_insert ON hyper; DROP TRIGGER _0_test_trigger_insert_s_before ON hyper; DROP TRIGGER _0_test_trigger_insert_after ON hyper; DROP TRIGGER _0_test_trigger_insert_s_after ON hyper; INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987600000000000, 'dev1', 1); WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 0 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_after_when_dev1 WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name z_test_trigger_all_after INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 1), (1257987800000000000, 'dev2', 1); WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 1 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 2 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name z_test_trigger_all_after DROP TRIGGER _0_test_trigger_update ON hyper; DROP TRIGGER _0_test_trigger_update_s_before ON hyper; DROP TRIGGER _0_test_trigger_update_after ON hyper; DROP TRIGGER _0_test_trigger_update_s_after ON hyper; UPDATE hyper SET sensor_1 = 2; WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after DROP TRIGGER _0_test_trigger_delete ON hyper; DROP TRIGGER _0_test_trigger_delete_s_before ON hyper; DROP TRIGGER _0_test_trigger_delete_after ON hyper; DROP TRIGGER _0_test_trigger_delete_s_after ON hyper; DELETE FROM hyper; WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 2 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 1 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after DROP TRIGGER z_test_trigger_all ON hyper; DROP TRIGGER z_test_trigger_all_after ON hyper; --test create trigger on hypertable -- row triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert BEFORE INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update BEFORE UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete BEFORE delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all BEFORE INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- row triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_after AFTER INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_after AFTER UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_after AFTER delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all_after AFTER INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- statement triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert_s_before BEFORE INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_before BEFORE UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_before BEFORE DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); -- statement triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_s_after AFTER INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_after AFTER UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_after AFTER DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987600000000000, 'dev1', 1); WARNING: FIRING trigger when: BEFORE level: STATEMENT op: INSERT cnt: 0 trigger_name _0_test_trigger_insert_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 0 trigger_name _0_test_trigger_insert WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 0 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_after_when_dev1 WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 1 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_s_after INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 1), (1257987800000000000, 'dev2', 1); WARNING: FIRING trigger when: BEFORE level: STATEMENT op: INSERT cnt: 1 trigger_name _0_test_trigger_insert_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 1 trigger_name _0_test_trigger_insert WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 1 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 2 trigger_name _0_test_trigger_insert WARNING: FIRING trigger when: BEFORE level: ROW op: INSERT cnt: 2 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_insert_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_constraint_insert WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name _0_test_trigger_insert_after WARNING: FIRING trigger when: AFTER level: ROW op: INSERT cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 3 trigger_name _0_test_trigger_insert_s_after UPDATE hyper SET sensor_1 = 2; WARNING: FIRING trigger when: BEFORE level: STATEMENT op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update WARNING: FIRING trigger when: BEFORE level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_constraint_update WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_after WARNING: FIRING trigger when: AFTER level: ROW op: UPDATE cnt: 3 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: UPDATE cnt: 3 trigger_name _0_test_trigger_update_s_after DELETE FROM hyper; WARNING: FIRING trigger when: BEFORE level: STATEMENT op: DELETE cnt: 3 trigger_name _0_test_trigger_delete_s_before WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 3 trigger_name _0_test_trigger_delete WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 3 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 2 trigger_name _0_test_trigger_delete WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 2 trigger_name z_test_trigger_all WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 1 trigger_name _0_test_trigger_delete WARNING: FIRING trigger when: BEFORE level: ROW op: DELETE cnt: 1 trigger_name z_test_trigger_all WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_constraint_delete WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_after WARNING: FIRING trigger when: AFTER level: ROW op: DELETE cnt: 0 trigger_name z_test_trigger_all_after WARNING: FIRING trigger when: AFTER level: STATEMENT op: DELETE cnt: 0 trigger_name _0_test_trigger_delete_s_after CREATE TABLE vehicles ( vehicle_id INTEGER PRIMARY KEY, vin_number CHAR(17), last_checkup TIMESTAMP ); CREATE TABLE color ( color_id INTEGER PRIMARY KEY, notes text ); CREATE TABLE location ( time TIMESTAMP NOT NULL, vehicle_id INTEGER REFERENCES vehicles (vehicle_id), color_id INTEGER, --no reference since gonna populate a hypertable latitude FLOAT, longitude FLOAT ); CREATE OR REPLACE FUNCTION create_vehicle_trigger_fn() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN INSERT INTO vehicles VALUES(NEW.vehicle_id, NULL, NULL) ON CONFLICT DO NOTHING; RETURN NEW; END $BODY$; CREATE OR REPLACE FUNCTION create_color_trigger_fn() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN --test subtxns within triggers BEGIN INSERT INTO color VALUES(NEW.color_id, 'n/a'); EXCEPTION WHEN unique_violation THEN -- Nothing to do, just continue END; RETURN NEW; END $BODY$; CREATE TRIGGER create_color_trigger BEFORE INSERT OR UPDATE ON location FOR EACH ROW EXECUTE FUNCTION create_color_trigger_fn(); SELECT create_hypertable('location', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------- (2,public,location,t) --make color also a hypertable SELECT create_hypertable('color', 'color_id', chunk_time_interval=>10); create_hypertable -------------------- (3,public,color,t) -- Test that we can create and use triggers with another user GRANT TRIGGER, INSERT, SELECT, UPDATE ON location TO :ROLE_DEFAULT_PERM_USER_2; GRANT SELECT, INSERT, UPDATE ON color TO :ROLE_DEFAULT_PERM_USER_2; GRANT SELECT, INSERT, UPDATE ON vehicles TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2; CREATE TRIGGER create_vehicle_trigger BEFORE INSERT OR UPDATE ON location FOR EACH ROW EXECUTE FUNCTION create_vehicle_trigger_fn(); INSERT INTO location VALUES('2017-01-01 01:02:03', 1, 1, 40.7493226,-73.9771259); INSERT INTO location VALUES('2017-01-01 01:02:04', 1, 20, 24.7493226,-73.9771259); INSERT INTO location VALUES('2017-01-01 01:02:03', 23, 1, 40.7493226,-73.9771269); INSERT INTO location VALUES('2017-01-01 01:02:03', 53, 20, 40.7493226,-73.9771269); UPDATE location SET vehicle_id = 52 WHERE vehicle_id = 53; SELECT * FROM location; time | vehicle_id | color_id | latitude | longitude --------------------------+------------+----------+------------+------------- Sun Jan 01 01:02:03 2017 | 1 | 1 | 40.7493226 | -73.9771259 Sun Jan 01 01:02:04 2017 | 1 | 20 | 24.7493226 | -73.9771259 Sun Jan 01 01:02:03 2017 | 23 | 1 | 40.7493226 | -73.9771269 Sun Jan 01 01:02:03 2017 | 52 | 20 | 40.7493226 | -73.9771269 SELECT * FROM vehicles; vehicle_id | vin_number | last_checkup ------------+------------+-------------- 1 | | 23 | | 53 | | 52 | | SELECT * FROM color; color_id | notes ----------+------- 1 | n/a 20 | n/a -- switch back to default user to run some dropping tests \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- test that disable trigger is disallowed ALTER TABLE location DISABLE TRIGGER create_vehicle_trigger; ERROR: hypertables do not support enabling or disabling triggers. \set ON_ERROR_STOP 1 -- test that drop trigger works DROP TRIGGER create_color_trigger ON location; DROP TRIGGER create_vehicle_trigger ON location; -- test that drop trigger doesn't cause leftovers that mean that dropping chunks or hypertables no longer works SELECT count(1) FROM pg_depend d WHERE d.classid = 'pg_trigger'::regclass AND NOT EXISTS (SELECT 1 FROM pg_trigger WHERE oid = d.objid); count ------- 0 DROP TABLE location; -- test triggers with transition tables -- test creating hypertable from table with triggers with transition tables CREATE TABLE transition_test(time timestamptz NOT NULL); CREATE TRIGGER t1_stmt AFTER INSERT ON transition_test REFERENCING NEW TABLE AS new_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t1_row AFTER INSERT ON transition_test REFERENCING NEW TABLE AS new_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- We do not support ROW triggers with transition tables, so we need -- to remove it to be able to create the hypertable. \set ON_ERROR_STOP 0 SELECT create_hypertable('transition_test','time'); ERROR: ROW triggers with transition tables are not supported on hypertables \set ON_ERROR_STOP 1 DROP TRIGGER t1_row ON transition_test; SELECT create_hypertable('transition_test','time'); create_hypertable ------------------------------ (4,public,transition_test,t) -- Insert some rows to create a chunk INSERT INTO transition_test values ('2020-01-10'); WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 0 trigger_name t1_stmt SELECT chunk FROM show_chunks('transition_test') tbl(chunk) limit 1 \gset -- test creating trigger with transition tables on existing hypertable CREATE TRIGGER t3 AFTER UPDATE ON transition_test REFERENCING NEW TABLE AS new_trans OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t4 AFTER DELETE ON transition_test REFERENCING OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); INSERT INTO transition_test values ('2020-01-11'); WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 0 trigger_name t1_stmt COPY transition_test FROM STDIN; WARNING: FIRING trigger when: AFTER level: STATEMENT op: INSERT cnt: 0 trigger_name t1_stmt UPDATE transition_test SET time = '2020-01-12' WHERE time = '2020-01-11'; WARNING: FIRING trigger when: AFTER level: STATEMENT op: UPDATE cnt: 0 trigger_name t3 DELETE FROM transition_test WHERE time = '2020-01-12'; WARNING: FIRING trigger when: AFTER level: STATEMENT op: DELETE cnt: 0 trigger_name t4 \set ON_ERROR_STOP 0 CREATE TRIGGER t3 AFTER UPDATE ON :chunk REFERENCING NEW TABLE AS new_trans OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); ERROR: triggers with transition tables are not supported on hypertable chunks CREATE TRIGGER t4 AFTER DELETE ON :chunk REFERENCING OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); ERROR: triggers with transition tables are not supported on hypertable chunks CREATE TRIGGER t5 AFTER INSERT ON transition_test REFERENCING NEW TABLE AS new_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); ERROR: ROW triggers with transition tables are not supported on hypertables CREATE TRIGGER t6 AFTER UPDATE ON transition_test REFERENCING NEW TABLE AS new_trans OLD TABLE AS old_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); ERROR: ROW triggers with transition tables are not supported on hypertables CREATE TRIGGER t7 AFTER DELETE ON transition_test REFERENCING OLD TABLE AS old_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); ERROR: ROW triggers with transition tables are not supported on hypertables \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/truncate.out�������������������������������������������������������0000664�0000000�0000000�00000027713�15100345067�0021223�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+----------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | two_Partitions | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f SELECT * FROM test.show_subtables('"two_Partitions"'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_3_chunk | _timescaledb_internal._hyper_1_4_chunk | SELECT * FROM "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257894002000000000 | dev1 | 2.5 | 3 | | 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | SET client_min_messages = WARNING; TRUNCATE "two_Partitions"; SELECT * FROM _timescaledb_catalog.hypertable; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+----------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 1 | public | two_Partitions | _timescaledb_internal | _hyper_1 | 2 | _timescaledb_functions | calculate_chunk_interval | 0 | 0 | | 0 SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- -- should be empty SELECT * FROM test.show_subtables('"two_Partitions"'); Child | Tablespace -------+------------ SELECT * FROM "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ------------+-----------+----------+----------+----------+------------- INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | | f | 0 | f 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | | f | 0 | f 7 | 1 | _timescaledb_internal | _hyper_1_7_chunk | | f | 0 | f CREATE VIEW dependent_view AS SELECT * FROM _timescaledb_internal._hyper_1_5_chunk; CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ DECLARE cnt INTEGER; BEGIN RAISE WARNING 'FIRING trigger when: % level: % op: % cnt: % trigger_name %', tg_when, tg_level, tg_op, cnt, tg_name; IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- test truncate on a chunk CREATE TRIGGER _test_truncate_before BEFORE TRUNCATE ON _timescaledb_internal._hyper_1_5_chunk FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _test_truncate_after AFTER TRUNCATE ON _timescaledb_internal._hyper_1_5_chunk FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); \set ON_ERROR_STOP 0 TRUNCATE "two_Partitions"; WARNING: FIRING trigger when: BEFORE level: STATEMENT op: TRUNCATE cnt: <NULL> trigger_name _test_truncate_before WARNING: FIRING trigger when: AFTER level: STATEMENT op: TRUNCATE cnt: <NULL> trigger_name _test_truncate_after ERROR: cannot drop table _timescaledb_internal._hyper_1_5_chunk because other objects depend on it -- cannot TRUNCATE ONLY a hypertable TRUNCATE ONLY "two_Partitions" CASCADE; ERROR: cannot truncate only a hypertable \set ON_ERROR_STOP 1 -- create a regular table to make sure we can truncate it in the same call CREATE TABLE truncate_normal (color int); INSERT INTO truncate_normal VALUES (1); SELECT * FROM truncate_normal; color ------- 1 -- fix for bug #3580 \set ON_ERROR_STOP 0 TRUNCATE nonexistentrelation; ERROR: relation "nonexistentrelation" does not exist \set ON_ERROR_STOP 1 CREATE TABLE truncate_nested (color int); INSERT INTO truncate_nested VALUES (2); SELECT * FROM truncate_normal, truncate_nested; color | color -------+------- 1 | 2 CREATE FUNCTION fn_truncate_nested() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN TRUNCATE truncate_nested; RETURN NEW; END; $$; CREATE TRIGGER tg_truncate_nested BEFORE TRUNCATE ON truncate_normal FOR EACH STATEMENT EXECUTE FUNCTION fn_truncate_nested(); TRUNCATE truncate_normal; SELECT * FROM truncate_normal, truncate_nested; color | color -------+------- INSERT INTO truncate_normal VALUES (3); INSERT INTO truncate_nested VALUES (4); SELECT * FROM truncate_normal, truncate_nested; color | color -------+------- 3 | 4 TRUNCATE truncate_normal; SELECT * FROM truncate_normal, truncate_nested; color | color -------+------- INSERT INTO truncate_normal VALUES (5); INSERT INTO truncate_nested VALUES (6); SELECT * FROM truncate_normal, truncate_nested; color | color -------+------- 5 | 6 SELECT * FROM test.show_subtables('"two_Partitions"'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_5_chunk | _timescaledb_internal._hyper_1_6_chunk | _timescaledb_internal._hyper_1_7_chunk | TRUNCATE "two_Partitions", truncate_normal CASCADE; WARNING: FIRING trigger when: BEFORE level: STATEMENT op: TRUNCATE cnt: <NULL> trigger_name _test_truncate_before WARNING: FIRING trigger when: AFTER level: STATEMENT op: TRUNCATE cnt: <NULL> trigger_name _test_truncate_after -- should be empty SELECT * FROM test.show_subtables('"two_Partitions"'); Child | Tablespace -------+------------ SELECT * FROM "two_Partitions"; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ------------+-----------+----------+----------+----------+------------- SELECT * FROM truncate_normal, truncate_nested; color | color -------+------- -- test TRUNCATE can be performed by a user -- with TRUNCATE privilege who is not table owner \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE owner WITH LOGIN; CREATE ROLE truncator WITH LOGIN; CREATE DATABASE test_trunc_ht OWNER owner; \c test_trunc_ht :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb; RESET client_min_messages; \c test_trunc_ht owner CREATE TABLE test_hypertable (time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value DOUBLE PRECISION); SELECT create_hypertable('test_hypertable', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------------ (1,public,test_hypertable,t) -- fail since we don't have TRUNCATE privileges yet \set ON_ERROR_STOP 0 \c test_trunc_ht truncator TRUNCATE TABLE test_hypertable; ERROR: permission denied for table test_hypertable \set ON_ERROR_STOP 1 \c test_trunc_ht owner GRANT TRUNCATE ON test_hypertable TO truncator; -- now succeed after privilege was granted \c test_trunc_ht truncator; TRUNCATE TABLE test_hypertable; \c :TEST_DBNAME :ROLE_SUPERUSER -- set client_min_messages to ERROR to suppress warnings about orphaned files SET client_min_messages TO ERROR; DROP DATABASE test_trunc_ht WITH (FORCE); DROP ROLE owner; DROP ROLE truncator; �����������������������������������������������������timescaledb-2.23.0/test/expected/trusted_extension.out����������������������������������������������0000664�0000000�0000000�00000004032�15100345067�0023151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE trusted_test; GRANT CREATE ON DATABASE trusted_test TO :ROLE_1; \c trusted_test :ROLE_READ_ONLY \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb; ERROR: permission denied to create extension "timescaledb" \set ON_ERROR_STOP 1 \c trusted_test :ROLE_1 -- user shouldn't have superuser privilege SELECT rolsuper FROM pg_roles WHERE rolname=user; rolsuper ---------- f SET client_min_messages TO ERROR; CREATE EXTENSION timescaledb; RESET client_min_messages; CREATE TABLE t(time timestamptz); SELECT create_hypertable('t','time'); create_hypertable ------------------- (1,public,t,t) INSERT INTO t VALUES ('2000-01-01'), ('2001-01-01'); SELECT * FROM t ORDER BY 1; time ------------------------------ Sat Jan 01 00:00:00 2000 PST Mon Jan 01 00:00:00 2001 PST SELECT * FROM timescaledb_information.hypertables; hypertable_schema | hypertable_name | owner | num_dimensions | num_chunks | compression_enabled | tablespaces | primary_dimension | primary_dimension_type -------------------+-----------------+-------------+----------------+------------+---------------------+-------------+-------------------+-------------------------- public | t | test_role_1 | 1 | 2 | f | | time | timestamp with time zone SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; schema | name | type | owner -----------------------+------------------+-------+------------- _timescaledb_internal | _hyper_1_1_chunk | table | test_role_1 _timescaledb_internal | _hyper_1_2_chunk | table | test_role_1 DROP EXTENSION timescaledb CASCADE; NOTICE: drop cascades to 2 other objects \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE trusted_test WITH (FORCE); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/ts_merge-15.out����������������������������������������������������0000664�0000000�0000000�00000255747�15100345067�0021440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET client_min_messages TO error; \set TEST_BASE_NAME ts_merge SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_load_ht.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_HT_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_ht_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_HYPERTABLE", format('%s/results/%s_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_NO_HYPERTABLE" \gset SELECT format('\! diff -u --label "Base pg table results" --label "Hypertable results" %s %s', :'TEST_RESULTS_WITH_HYPERTABLE', :'TEST_RESULTS_WITH_NO_HYPERTABLE') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); -- run tests on normal table \o :TEST_RESULTS_WITH_NO_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: MERGE not supported in WITH query LINE 1: WITH foo AS ( ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: MERGE not supported in COPY -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:72: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; execute foom; ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; psql:include/ts_merge_query.sql:778: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING *; ^ ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:811: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); psql:include/ts_merge_query.sql:826: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. SELECT * from tv; psql:include/ts_merge_query.sql:827: ERROR: current transaction is aborted, commands ignored until end of transaction block SELECT * from target; -- should also update the underlying table psql:include/ts_merge_query.sql:828: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:841: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; psql:include/ts_merge_query.sql:952: ERROR: syntax error at or near "RETURNING" LINE 6: RETURNING *; ^ SELECT * FROM sq_target WHERE tid = 1; psql:include/ts_merge_query.sql:953: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o \ir :TEST_LOAD_HT_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target', 'tid', chunk_time_interval => 3); create_hypertable --------------------- (1,public,target,t) CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target2', 'tid', chunk_time_interval => 3); create_hypertable ---------------------- (2,public,target2,t) CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('sq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (3,public,sq_target,t) CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); SELECT create_hypertable('wq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (4,public,wq_target,t) CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); -- some complex joins on the source side CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); SELECT create_hypertable('cj_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (5,public,cj_target,t) CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); SELECT create_hypertable('fs_target', 'a', chunk_time_interval => 3); create_hypertable ------------------------ (6,public,fs_target,t) -- run tests on hypertable \o :TEST_RESULTS_WITH_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: MERGE not supported in WITH query LINE 1: WITH foo AS ( ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: MERGE not supported in COPY -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:72: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "2_2_target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; psql:include/ts_merge_query.sql:277: ERROR: cannot drop not-null constraint from a time-partitioned column -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ HINT: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; psql:include/ts_merge_query.sql:685: ERROR: prepared statement "foom" already exists execute foom; psql:include/ts_merge_query.sql:686: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; psql:include/ts_merge_query.sql:695: ERROR: prepared statement "foom2" already exists --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); psql:include/ts_merge_query.sql:697: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; psql:include/ts_merge_query.sql:778: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING *; ^ ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:811: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); psql:include/ts_merge_query.sql:826: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. SELECT * from tv; psql:include/ts_merge_query.sql:827: ERROR: current transaction is aborted, commands ignored until end of transaction block SELECT * from target; -- should also update the underlying table psql:include/ts_merge_query.sql:828: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:841: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; psql:include/ts_merge_query.sql:952: ERROR: syntax error at or near "RETURNING" LINE 6: RETURNING *; ^ SELECT * FROM sq_target WHERE tid = 1; psql:include/ts_merge_query.sql:953: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o :DIFF_CMD �������������������������timescaledb-2.23.0/test/expected/ts_merge-16.out����������������������������������������������������0000664�0000000�0000000�00000255767�15100345067�0021443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET client_min_messages TO error; \set TEST_BASE_NAME ts_merge SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_load_ht.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_HT_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_ht_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_HYPERTABLE", format('%s/results/%s_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_NO_HYPERTABLE" \gset SELECT format('\! diff -u --label "Base pg table results" --label "Hypertable results" %s %s', :'TEST_RESULTS_WITH_HYPERTABLE', :'TEST_RESULTS_WITH_NO_HYPERTABLE') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); -- run tests on normal table \o :TEST_RESULTS_WITH_NO_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: MERGE not supported in WITH query LINE 1: WITH foo AS ( ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: MERGE not supported in COPY -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:72: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; execute foom; ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; psql:include/ts_merge_query.sql:778: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING *; ^ ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:811: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); psql:include/ts_merge_query.sql:826: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. SELECT * from tv; psql:include/ts_merge_query.sql:827: ERROR: current transaction is aborted, commands ignored until end of transaction block SELECT * from target; -- should also update the underlying table psql:include/ts_merge_query.sql:828: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:841: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; psql:include/ts_merge_query.sql:952: ERROR: syntax error at or near "RETURNING" LINE 6: RETURNING *; ^ SELECT * FROM sq_target WHERE tid = 1; psql:include/ts_merge_query.sql:953: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o \ir :TEST_LOAD_HT_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target', 'tid', chunk_time_interval => 3); create_hypertable --------------------- (1,public,target,t) CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target2', 'tid', chunk_time_interval => 3); create_hypertable ---------------------- (2,public,target2,t) CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('sq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (3,public,sq_target,t) CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); SELECT create_hypertable('wq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (4,public,wq_target,t) CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); -- some complex joins on the source side CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); SELECT create_hypertable('cj_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (5,public,cj_target,t) CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); SELECT create_hypertable('fs_target', 'a', chunk_time_interval => 3); create_hypertable ------------------------ (6,public,fs_target,t) -- run tests on hypertable \o :TEST_RESULTS_WITH_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: MERGE not supported in WITH query LINE 1: WITH foo AS ( ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: MERGE not supported in COPY -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:72: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "2_2_target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; psql:include/ts_merge_query.sql:277: ERROR: cannot drop not-null constraint from a time-partitioned column -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; psql:include/ts_merge_query.sql:685: ERROR: prepared statement "foom" already exists execute foom; psql:include/ts_merge_query.sql:686: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; psql:include/ts_merge_query.sql:695: ERROR: prepared statement "foom2" already exists --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); psql:include/ts_merge_query.sql:697: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; psql:include/ts_merge_query.sql:778: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING *; ^ ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:811: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); psql:include/ts_merge_query.sql:826: ERROR: cannot execute MERGE on relation "tv" DETAIL: This operation is not supported for views. SELECT * from tv; psql:include/ts_merge_query.sql:827: ERROR: current transaction is aborted, commands ignored until end of transaction block SELECT * from target; -- should also update the underlying table psql:include/ts_merge_query.sql:828: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; psql:include/ts_merge_query.sql:841: ERROR: syntax error at or near "RETURNING" LINE 10: RETURNING merge_action(), t.*; ^ ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; psql:include/ts_merge_query.sql:952: ERROR: syntax error at or near "RETURNING" LINE 6: RETURNING *; ^ SELECT * FROM sq_target WHERE tid = 1; psql:include/ts_merge_query.sql:953: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o :DIFF_CMD ���������timescaledb-2.23.0/test/expected/ts_merge-17.out����������������������������������������������������0000664�0000000�0000000�00000251567�15100345067�0021436�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET client_min_messages TO error; \set TEST_BASE_NAME ts_merge SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_load_ht.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_HT_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_ht_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_HYPERTABLE", format('%s/results/%s_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_NO_HYPERTABLE" \gset SELECT format('\! diff -u --label "Base pg table results" --label "Hypertable results" %s %s', :'TEST_RESULTS_WITH_HYPERTABLE', :'TEST_RESULTS_WITH_NO_HYPERTABLE') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); -- run tests on normal table \o :TEST_RESULTS_WITH_NO_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: WITH query "foo" does not have a RETURNING clause LINE 4: ) SELECT * FROM foo; ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: COPY query must have a RETURNING clause -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; execute foom; ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from tv; SELECT * from target; -- should also update the underlying table ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o \ir :TEST_LOAD_HT_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target', 'tid', chunk_time_interval => 3); create_hypertable --------------------- (1,public,target,t) CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target2', 'tid', chunk_time_interval => 3); create_hypertable ---------------------- (2,public,target2,t) CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('sq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (3,public,sq_target,t) CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); SELECT create_hypertable('wq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (4,public,wq_target,t) CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); -- some complex joins on the source side CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); SELECT create_hypertable('cj_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (5,public,cj_target,t) CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); SELECT create_hypertable('fs_target', 'a', chunk_time_interval => 3); create_hypertable ------------------------ (6,public,fs_target,t) -- run tests on hypertable \o :TEST_RESULTS_WITH_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: WITH query "foo" does not have a RETURNING clause LINE 4: ) SELECT * FROM foo; ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: COPY query must have a RETURNING clause -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "2_2_target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; psql:include/ts_merge_query.sql:277: ERROR: cannot drop not-null constraint from a time-partitioned column -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; psql:include/ts_merge_query.sql:685: ERROR: prepared statement "foom" already exists execute foom; psql:include/ts_merge_query.sql:686: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; psql:include/ts_merge_query.sql:695: ERROR: prepared statement "foom2" already exists --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); psql:include/ts_merge_query.sql:697: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from tv; SELECT * from target; -- should also update the underlying table ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o :DIFF_CMD �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/ts_merge-18.out����������������������������������������������������0000664�0000000�0000000�00000251567�15100345067�0021437�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET client_min_messages TO error; \set TEST_BASE_NAME ts_merge SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_load_ht.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_HT_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_ht_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_HYPERTABLE", format('%s/results/%s_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_NO_HYPERTABLE" \gset SELECT format('\! diff -u --label "Base pg table results" --label "Hypertable results" %s %s', :'TEST_RESULTS_WITH_HYPERTABLE', :'TEST_RESULTS_WITH_NO_HYPERTABLE') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); -- run tests on normal table \o :TEST_RESULTS_WITH_NO_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: WITH query "foo" does not have a RETURNING clause LINE 4: ) SELECT * FROM foo; ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: COPY query must have a RETURNING clause -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; execute foom; ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from tv; SELECT * from target; -- should also update the underlying table ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o \ir :TEST_LOAD_HT_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target', 'tid', chunk_time_interval => 3); create_hypertable --------------------- (1,public,target,t) CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; matched | tid | balance | sid | delta ---------+-----+---------+-----+------- t | 1 | 10 | | t | 2 | 20 | | t | 3 | 30 | | ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target2', 'tid', chunk_time_interval => 3); create_hypertable ---------------------- (2,public,target2,t) CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('sq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (3,public,sq_target,t) CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); SELECT create_hypertable('wq_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (4,public,wq_target,t) CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); -- some complex joins on the source side CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); SELECT create_hypertable('cj_target', 'tid', chunk_time_interval => 3); create_hypertable ------------------------ (5,public,cj_target,t) CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); SELECT create_hypertable('fs_target', 'a', chunk_time_interval => 3); create_hypertable ------------------------ (6,public,fs_target,t) -- run tests on hypertable \o :TEST_RESULTS_WITH_HYPERTABLE \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:12: ERROR: syntax error at or near "RANDOMWORD" LINE 1: MERGE INTO target t RANDOMWORD ^ -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:18: ERROR: syntax error at or near "INSERT" LINE 5: INSERT DEFAULT VALUES; ^ -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; psql:include/ts_merge_query.sql:24: ERROR: syntax error at or near "INTO" LINE 5: INSERT INTO target DEFAULT VALUES; ^ -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); psql:include/ts_merge_query.sql:30: ERROR: syntax error at or near "," LINE 5: INSERT VALUES (1,1), (2,2); ^ -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); psql:include/ts_merge_query.sql:36: ERROR: syntax error at or near "SELECT" LINE 5: INSERT SELECT (1, 1); ^ -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:42: ERROR: syntax error at or near "UPDATE" LINE 5: UPDATE SET balance = 0; ^ -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; psql:include/ts_merge_query.sql:48: ERROR: syntax error at or near "target" LINE 5: UPDATE target SET balance = 0; ^ -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; psql:include/ts_merge_query.sql:53: ERROR: name "target" specified more than once DETAIL: The name is used both as MERGE target table and data source. -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; psql:include/ts_merge_query.sql:58: ERROR: WITH query "foo" does not have a RETURNING clause LINE 4: ) SELECT * FROM foo; ^ -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; psql:include/ts_merge_query.sql:63: ERROR: COPY query must have a RETURNING clause -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:81: ERROR: cannot execute MERGE on relation "mv" DETAIL: This operation is not supported for materialized views. DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:90: ERROR: permission denied for table source2 GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:99: ERROR: permission denied for table target GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:108: ERROR: permission denied for table target2 MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:114: ERROR: permission denied for table target2 -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; psql:include/ts_merge_query.sql:122: ERROR: invalid reference to FROM-clause entry for table "t" LINE 2: USING (SELECT * FROM source WHERE t.tid > sid) s ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; psql:include/ts_merge_query.sql:241: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; psql:include/ts_merge_query.sql:249: ERROR: MERGE command cannot affect row a second time HINT: Ensure that not more than one source row matches any one target row. ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); psql:include/ts_merge_query.sql:265: ERROR: duplicate key value violates unique constraint "2_2_target_pkey" DETAIL: Key (tid)=(4) already exists. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:266: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; psql:include/ts_merge_query.sql:277: ERROR: cannot drop not-null constraint from a time-partitioned column -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:356: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); psql:include/ts_merge_query.sql:364: ERROR: invalid reference to FROM-clause entry for table "t" LINE 5: INSERT (tid, balance) VALUES (t.tid, s.delta); ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM target ORDER BY tid; psql:include/ts_merge_query.sql:365: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); psql:include/ts_merge_query.sql:408: ERROR: invalid reference to FROM-clause entry for table "t" LINE 3: WHEN NOT MATCHED AND t.balance = 100 THEN ^ DETAIL: There is an entry for table "t", but it cannot be referenced from this part of the query. SELECT * FROM wq_target; psql:include/ts_merge_query.sql:409: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; psql:include/ts_merge_query.sql:477: ERROR: cannot use system column "xmin" in MERGE WHEN condition LINE 3: WHEN MATCHED AND t.xmin = t.xmax THEN ^ MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; psql:include/ts_merge_query.sql:685: ERROR: prepared statement "foom" already exists execute foom; psql:include/ts_merge_query.sql:686: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; psql:include/ts_merge_query.sql:695: ERROR: prepared statement "foom2" already exists --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); psql:include/ts_merge_query.sql:697: ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; psql:include/ts_merge_query.sql:732: ERROR: column reference "balance" is ambiguous LINE 5: UPDATE SET balance = balance + delta ^ ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from tv; SELECT * from target; -- should also update the underlying table ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; \o :DIFF_CMD �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/update.out���������������������������������������������������������0000664�0000000�0000000�00000025126�15100345067�0020654�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_single.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."one_Partition" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."one_Partition" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; \c :DBNAME :ROLE_SUPERUSER CREATE SCHEMA "one_Partition" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :DBNAME :ROLE_DEFAULT_PERM_USER; SELECT * FROM create_hypertable('"public"."one_Partition"', 'timeCustom', associated_schema_name=>'one_Partition', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); --output command tags \set QUIET off BEGIN; \COPY "one_Partition" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on \o -- Make sure UPDATE isn't optimized if it includes Append plans -- Need to turn of nestloop to make append appear the same on PG96 and PG10 set enable_nestloop = 'off'; CREATE OR REPLACE FUNCTION series_val() RETURNS integer LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN 5; END; $BODY$; -- ConstraintAwareAppend applied for SELECT EXPLAIN (buffers off, costs off) SELECT FROM "one_Partition" WHERE series_1 IN (SELECT series_1 FROM "one_Partition" WHERE series_1 > series_val()); --- QUERY PLAN --- Hash Join Hash Cond: ("one_Partition".series_1 = "one_Partition_1".series_1) -> Custom Scan (ChunkAppend) on "one_Partition" Chunks excluded during startup: 0 -> Index Only Scan using "_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_1_chunk Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_2_chunk Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_3_chunk Index Cond: (series_1 > (series_val())::double precision) -> Hash -> HashAggregate Group Key: "one_Partition_1".series_1 -> Custom Scan (ChunkAppend) on "one_Partition" "one_Partition_1" Chunks excluded during startup: 0 -> Index Only Scan using "_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_1_chunk _hyper_1_1_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_2_chunk _hyper_1_2_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -> Index Only Scan using "_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_3_chunk _hyper_1_3_chunk_1 Index Cond: (series_1 > (series_val())::double precision) -- ConstraintAwareAppend NOT applied for UPDATE EXPLAIN (buffers off, costs off) UPDATE "one_Partition" SET series_1 = 8 WHERE series_1 IN (SELECT series_1 FROM "one_Partition" WHERE series_1 > series_val()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on "one_Partition" Update on _hyper_1_1_chunk "one_Partition_2" Update on _hyper_1_2_chunk "one_Partition_3" Update on _hyper_1_3_chunk "one_Partition_4" -> Hash Join Hash Cond: ("one_Partition".series_1 = "one_Partition_1".series_1) -> Append -> Seq Scan on _hyper_1_1_chunk "one_Partition_2" -> Seq Scan on _hyper_1_2_chunk "one_Partition_3" -> Seq Scan on _hyper_1_3_chunk "one_Partition_4" -> Hash -> HashAggregate Group Key: "one_Partition_1".series_1 -> Append -> Index Scan using "_hyper_1_1_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_1_chunk "one_Partition_5" Index Cond: (series_1 > (series_val())::double precision) -> Index Scan using "_hyper_1_2_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_2_chunk "one_Partition_6" Index Cond: (series_1 > (series_val())::double precision) -> Index Scan using "_hyper_1_3_chunk_one_Partition_timeCustom_series_1_idx" on _hyper_1_3_chunk "one_Partition_7" Index Cond: (series_1 > (series_val())::double precision) SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 6 | | t 1257894002000000000 | dev1 | 5.5 | 7 | | f 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | UPDATE "one_Partition" SET series_1 = 8 WHERE series_1 IN (SELECT series_1 FROM "one_Partition" WHERE series_1 > series_val()); SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 1 | 2 | t 1257894000000000000 | dev1 | 1.5 | 2 | | 1257894000000000000 | dev2 | 1.5 | 1 | | 1257894000000000000 | dev2 | 1.5 | 2 | | 1257894000000001000 | dev1 | 2.5 | 3 | | 1257894001000000000 | dev1 | 3.5 | 4 | | 1257894002000000000 | dev1 | 2.5 | 3 | | 1257894002000000000 | dev1 | 5.5 | 8 | | f 1257894002000000000 | dev1 | 5.5 | 8 | | t 1257897600000000000 | dev1 | 4.5 | 5 | | f 1257987600000000000 | dev1 | 1.5 | 1 | | 1257987600000000000 | dev1 | 1.5 | 2 | | UPDATE "one_Partition" SET series_1 = 47; UPDATE "one_Partition" SET series_bool = true; SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; timeCustom | device_id | series_0 | series_1 | series_2 | series_bool ---------------------+-----------+----------+----------+----------+------------- 1257894000000000000 | dev1 | 1.5 | 47 | 2 | t 1257894000000000000 | dev1 | 1.5 | 47 | | t 1257894000000000000 | dev2 | 1.5 | 47 | | t 1257894000000000000 | dev2 | 1.5 | 47 | | t 1257894000000001000 | dev1 | 2.5 | 47 | | t 1257894001000000000 | dev1 | 3.5 | 47 | | t 1257894002000000000 | dev1 | 2.5 | 47 | | t 1257894002000000000 | dev1 | 5.5 | 47 | | t 1257894002000000000 | dev1 | 5.5 | 47 | | t 1257897600000000000 | dev1 | 4.5 | 47 | | t 1257987600000000000 | dev1 | 1.5 | 47 | | t 1257987600000000000 | dev1 | 1.5 | 47 | | t -- test update on chunks directly CREATE TABLE direct_update(time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO direct_update VALUES ('2020-01-01'); SELECT show_chunks('direct_update') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) UPDATE :CHUNK SET time = time + INTERVAL '1 minute'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on _hyper_2_4_chunk -> Seq Scan on _hyper_2_4_chunk EXPLAIN (costs off, timing off, summary off) UPDATE ONLY :CHUNK SET time = time + INTERVAL '1 minute'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on _hyper_2_4_chunk -> Seq Scan on _hyper_2_4_chunk -- correct time range should succeed UPDATE :CHUNK SET time = time + INTERVAL '1 minute' RETURNING *; time ------------------------------ Wed Jan 01 00:01:00 2020 PST UPDATE ONLY :CHUNK SET time = time + INTERVAL '1 minute' RETURNING *; time ------------------------------ Wed Jan 01 00:02:00 2020 PST -- crossing chunk boundary should fail \set ON_ERROR_STOP 0 UPDATE :CHUNK SET time = time + INTERVAL '1 month' RETURNING *; ERROR: new row for relation "_hyper_2_4_chunk" violates check constraint "constraint_4" UPDATE ONLY :CHUNK SET time = time + INTERVAL '1 month' RETURNING *; ERROR: new row for relation "_hyper_2_4_chunk" violates check constraint "constraint_4" \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/upsert.out���������������������������������������������������������0000664�0000000�0000000�00000070026�15100345067�0020713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE upsert_test(time timestamp PRIMARY KEY, temp float, color text); SELECT create_hypertable('upsert_test', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (1,public,upsert_test,t) INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 22.5, 'yellow') RETURNING *; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 22.5 | yellow INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 23.8, 'yellow') ON CONFLICT (time) DO UPDATE SET temp = 23.8 RETURNING *; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 23.8 | yellow INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 78.4, 'yellow') ON CONFLICT DO NOTHING; SELECT * FROM upsert_test; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 23.8 | yellow -- Test 'Tuples Inserted' and 'Conflicting Tuples' values in EXPLAIN ANALYZE EXPLAIN (VERBOSE, ANALYZE, BUFFERS FALSE, COSTS FALSE, TIMING FALSE, SUMMARY FALSE) INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 28.5, 'blue'), ('2017-01-20T09:00:01', 21.9, 'red'), ('2017-01-20T10:00:01', 2.4, 'pink') ON CONFLICT DO NOTHING; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on public.upsert_test (actual rows=0.00 loops=1) Conflict Resolution: NOTHING Tuples Inserted: 1 Conflicting Tuples: 2 -> Values Scan on "*VALUES*" (actual rows=3.00 loops=1) Output: "*VALUES*".column1, "*VALUES*".column2, "*VALUES*".column3 -- Test ON CONFLICT ON CONSTRAINT INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 12.3, 'yellow') ON CONFLICT ON CONSTRAINT upsert_test_pkey DO UPDATE SET temp = 12.3 RETURNING time, temp, color; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 12.3 | yellow -- Test that update generates error on conflicts \set ON_ERROR_STOP 0 INSERT INTO upsert_test VALUES ('2017-01-21T09:00:01', 22.5, 'yellow') RETURNING *; time | temp | color --------------------------+------+-------- Sat Jan 21 09:00:01 2017 | 22.5 | yellow UPDATE upsert_test SET time = '2017-01-20T09:00:01'; ERROR: duplicate key value violates unique constraint "1_1_upsert_test_pkey" \set ON_ERROR_STOP 1 -- Test with UNIQUE index on multiple columns instead of PRIMARY KEY constraint CREATE TABLE upsert_test_unique(time timestamp, temp float, color text); SELECT create_hypertable('upsert_test_unique', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------- (2,public,upsert_test_unique,t) CREATE UNIQUE INDEX time_color_idx ON upsert_test_unique (time, color); INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 22.5, 'yellow') RETURNING *; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 22.5 | yellow INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 21.2, 'brown'); SELECT * FROM upsert_test_unique ORDER BY time, color DESC; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 22.5 | yellow Fri Jan 20 09:00:01 2017 | 21.2 | brown INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 31.8, 'yellow') ON CONFLICT (time, color) DO UPDATE SET temp = 31.8; INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 54.3, 'yellow') ON CONFLICT DO NOTHING; SELECT * FROM upsert_test_unique ORDER BY time, color DESC; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 31.8 | yellow Fri Jan 20 09:00:01 2017 | 21.2 | brown -- Test with multiple UNIQUE indexes CREATE TABLE upsert_test_multi_unique(time timestamp, temp float, color text); SELECT create_hypertable('upsert_test_multi_unique', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------------- (3,public,upsert_test_multi_unique,t) ALTER TABLE upsert_test_multi_unique ADD CONSTRAINT multi_time_temp UNIQUE (time, temp); CREATE UNIQUE INDEX multi_time_color_idx ON upsert_test_multi_unique (time, color); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'yellow'); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-21T09:00:01', 25.9, 'yellow'); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 23.5, 'brown'); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT DO NOTHING; SELECT * FROM upsert_test_multi_unique ORDER BY time, color DESC; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 25.9 | yellow Fri Jan 20 09:00:01 2017 | 23.5 | brown Sat Jan 21 09:00:01 2017 | 25.9 | yellow INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'blue') ON CONFLICT (time, temp) DO UPDATE SET color = 'blue'; INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 23.5, 'orange') ON CONFLICT ON CONSTRAINT multi_time_temp DO UPDATE SET color = excluded.color; SELECT * FROM upsert_test_multi_unique ORDER BY time, color DESC; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 23.5 | orange Fri Jan 20 09:00:01 2017 | 25.9 | blue Sat Jan 21 09:00:01 2017 | 25.9 | yellow INSERT INTO upsert_test_multi_unique VALUES ('2017-01-21T09:00:01', 45.7, 'yellow') ON CONFLICT (time, color) DO UPDATE SET temp = 45.7; SELECT * FROM upsert_test_multi_unique ORDER BY time, color DESC; time | temp | color --------------------------+------+-------- Fri Jan 20 09:00:01 2017 | 23.5 | orange Fri Jan 20 09:00:01 2017 | 25.9 | blue Sat Jan 21 09:00:01 2017 | 45.7 | yellow \set ON_ERROR_STOP 0 -- Here the constraint in the ON CONFLICT clause is not the one that is -- actually violated by the INSERT, so it should still fail. INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 23.5, 'purple') ON CONFLICT (time, color) DO UPDATE set temp = 23.5; ERROR: duplicate key value violates unique constraint "3_2_multi_time_temp" INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 22.5, 'orange') ON CONFLICT ON CONSTRAINT multi_time_temp DO UPDATE set color = 'orange'; ERROR: duplicate key value violates unique constraint "_hyper_3_3_chunk_multi_time_color_idx" \set ON_ERROR_STOP 1 CREATE TABLE upsert_test_space(time timestamp, device_id_1 char(20), to_drop int, temp float, color text); --drop two columns; create one. ALTER TABLE upsert_test_space DROP to_drop; ALTER TABLE upsert_test_space DROP device_id_1, ADD device_id char(20); ALTER TABLE upsert_test_space ADD CONSTRAINT time_space_constraint UNIQUE (time, device_id); SELECT create_hypertable('upsert_test_space', 'time', 'device_id', 2, partitioning_func=>'_timescaledb_functions.get_partition_for_key'::regproc); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (4,public,upsert_test_space,t) INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 25.9, 'yellow') RETURNING *; time | temp | color | device_id --------------------------+------+--------+---------------------- Fri Jan 20 09:00:01 2017 | 25.9 | yellow | dev1 INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 25.9, 'yellow'); INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 23.5, 'green') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 23.5, 'orange') ON CONFLICT ON CONSTRAINT time_space_constraint DO UPDATE SET color = excluded.color; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 23.5, 'orange3') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color||' (originally '|| upsert_test_space.color ||')' RETURNING *; time | temp | color | device_id --------------------------+------+-----------------------------+---------------------- Fri Jan 20 09:00:01 2017 | 25.9 | orange3 (originally yellow) | dev2 INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev3', 23.5, 'orange3.1') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color||' (originally '|| upsert_test_space.color ||')' RETURNING *; time | temp | color | device_id --------------------------+------+-----------+---------------------- Fri Jan 20 09:00:01 2017 | 23.5 | orange3.1 | dev3 INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 23.5, 'orange4') ON CONFLICT (time, device_id) DO NOTHING RETURNING *; time | temp | color | device_id ------+------+-------+----------- INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev4', 23.5, 'orange5') ON CONFLICT (time, device_id) DO NOTHING RETURNING *; time | temp | color | device_id --------------------------+------+---------+---------------------- Fri Jan 20 09:00:01 2017 | 23.5 | orange5 | dev4 INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange5') ON CONFLICT (time, device_id) DO NOTHING RETURNING *; time | temp | color | device_id --------------------------+------+---------+---------------------- Fri Jan 20 09:00:01 2017 | 23.5 | orange5 | dev5 INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange6') ON CONFLICT ON CONSTRAINT time_space_constraint DO NOTHING RETURNING *; time | temp | color | device_id ------+------+-------+----------- --restore a column with the same name as a previously deleted one; ALTER TABLE upsert_test_space ADD device_id_1 char(20); INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_1) VALUES ('2017-01-20T09:00:01', 'dev4', 23.5, 'orange5.1', 'dev-id-1') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color||' (originally '|| upsert_test_space.color ||')' RETURNING *; time | temp | color | device_id | device_id_1 --------------------------+------+--------------------------------+----------------------+------------- Fri Jan 20 09:00:01 2017 | 23.5 | orange5.1 (originally orange5) | dev4 | INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange6') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color WHERE upsert_test_space.temp < 20 RETURNING *; time | temp | color | device_id | device_id_1 ------+------+-------+-----------+------------- INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange7') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color WHERE excluded.temp < 20 RETURNING *; time | temp | color | device_id | device_id_1 ------+------+-------+-----------+------------- INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 3.5, 'orange7') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color, temp=excluded.temp WHERE excluded.temp < 20 RETURNING *; time | temp | color | device_id | device_id_1 --------------------------+------+---------+----------------------+------------- Fri Jan 20 09:00:01 2017 | 3.5 | orange7 | dev5 | INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color WHERE upsert_test_space.temp < 20 RETURNING *; time | temp | color | device_id | device_id_1 --------------------------+------+---------+----------------------+------------- Fri Jan 20 09:00:01 2017 | 3.5 | orange8 | dev5 | INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_1) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-1-new') ON CONFLICT (time, device_id) DO UPDATE SET device_id_1 = excluded.device_id_1 RETURNING *; time | temp | color | device_id | device_id_1 --------------------------+------+---------+----------------------+---------------------- Fri Jan 20 09:00:01 2017 | 3.5 | orange8 | dev5 | device-id-1-new INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_1) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-1-new') ON CONFLICT (time, device_id) DO UPDATE SET device_id_1 = 'device-id-1-new-2', color = 'orange9' RETURNING *; time | temp | color | device_id | device_id_1 --------------------------+------+---------+----------------------+---------------------- Fri Jan 20 09:00:01 2017 | 3.5 | orange9 | dev5 | device-id-1-new-2 SELECT * FROM upsert_test_space; time | temp | color | device_id | device_id_1 --------------------------+------+--------------------------------+----------------------+---------------------- Fri Jan 20 09:00:01 2017 | 25.9 | orange | dev1 | Fri Jan 20 09:00:01 2017 | 25.9 | orange3 (originally yellow) | dev2 | Fri Jan 20 09:00:01 2017 | 23.5 | orange3.1 | dev3 | Fri Jan 20 09:00:01 2017 | 23.5 | orange5.1 (originally orange5) | dev4 | Fri Jan 20 09:00:01 2017 | 3.5 | orange9 | dev5 | device-id-1-new-2 ALTER TABLE upsert_test_space DROP device_id_1, ADD device_id_2 char(20); INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_2) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-2') ON CONFLICT (time, device_id) DO UPDATE SET device_id_2 = 'device-id-2-new', color = 'orange10' RETURNING *; time | temp | color | device_id | device_id_2 --------------------------+------+----------+----------------------+---------------------- Fri Jan 20 09:00:01 2017 | 3.5 | orange10 | dev5 | device-id-2-new --test inserting to to a chunk already in the chunk dispatch cache again. INSERT INTO upsert_test_space as current (time, device_id, temp, color, device_id_2) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-2'), ('2018-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-2'), ('2017-01-20T09:00:01', 'dev3', 43.5, 'orange7', 'device-id-2'), ('2018-01-21T09:00:01', 'dev5', 43.5, 'orange9', 'device-id-2') ON CONFLICT (time, device_id) DO UPDATE SET device_id_2 = coalesce(excluded.device_id_2,current.device_id_2), color = coalesce(excluded.color,current.color) RETURNING *; time | temp | color | device_id | device_id_2 --------------------------+------+---------+----------------------+---------------------- Fri Jan 20 09:00:01 2017 | 3.5 | orange8 | dev5 | device-id-2 Sat Jan 20 09:00:01 2018 | 43.5 | orange8 | dev5 | device-id-2 Fri Jan 20 09:00:01 2017 | 23.5 | orange7 | dev3 | device-id-2 Sun Jan 21 09:00:01 2018 | 43.5 | orange9 | dev5 | device-id-2 WITH CTE AS ( INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT DO NOTHING RETURNING * ) SELECT 1; ?column? ---------- 1 WITH CTE AS ( INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple'), ('2017-01-20T09:00:01', 29.9, 'purple1') ON CONFLICT DO NOTHING RETURNING * ) SELECT * FROM CTE; time | temp | color --------------------------+------+--------- Fri Jan 20 09:00:01 2017 | 29.9 | purple1 WITH CTE AS ( INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'blue') ON CONFLICT (time, temp) DO UPDATE SET color = 'blue' RETURNING * ) SELECT * FROM CTE; time | temp | color --------------------------+------+------- Fri Jan 20 09:00:01 2017 | 25.9 | blue --test error conditions when an index is dropped on a chunk DROP INDEX _timescaledb_internal._hyper_3_3_chunk_multi_time_color_idx; --everything is ok if not used as an arbiter index INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT DO NOTHING RETURNING *; time | temp | color ------+------+------- --errors out if used as an arbiter index \set ON_ERROR_STOP 0 INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT (time, color) DO NOTHING RETURNING *; ERROR: could not find arbiter index for hypertable index "multi_time_color_idx" on chunk "_hyper_3_3_chunk" \set ON_ERROR_STOP 1 --create table with one chunk that has a tup_conv_map and one that does not --to ensure this, create a chunk before altering the table this chunk will not have a tup_conv_map CREATE TABLE upsert_test_diffchunk(time timestamp, device_id char(20), to_drop int, temp float, color text); SELECT create_hypertable('upsert_test_diffchunk', 'time', chunk_time_interval=> interval '1 month'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------------------ (5,public,upsert_test_diffchunk,t) CREATE UNIQUE INDEX time_device_idx ON upsert_test_diffchunk (time, device_id); --this is the chunk with no tup_conv_map INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 25.9, 'yellow') RETURNING *; time | device_id | to_drop | temp | color --------------------------+----------------------+---------+------+-------- Fri Jan 20 09:00:01 2017 | dev1 | | 25.9 | yellow INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 25.9, 'yellow') RETURNING *; time | device_id | to_drop | temp | color --------------------------+----------------------+---------+------+-------- Fri Jan 20 09:00:01 2017 | dev2 | | 25.9 | yellow --alter the table ALTER TABLE upsert_test_diffchunk DROP to_drop; ALTER TABLE upsert_test_diffchunk ADD device_id_2 char(20); --new chunk that does have a tup conv map INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2019-01-20T09:00:01', 'dev1', 23.5, 'orange') ; INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2019-01-20T09:00:01', 'dev2', 23.5, 'orange') ; select * from upsert_test_diffchunk order by time, device_id; time | device_id | temp | color | device_id_2 --------------------------+----------------------+------+--------+------------- Fri Jan 20 09:00:01 2017 | dev1 | 25.9 | yellow | Fri Jan 20 09:00:01 2017 | dev2 | 25.9 | yellow | Sun Jan 20 09:00:01 2019 | dev1 | 23.5 | orange | Sun Jan 20 09:00:01 2019 | dev2 | 23.5 | orange | --make sure current works INSERT INTO upsert_test_diffchunk as current (time, device_id, temp, color, device_id_2) VALUES ('2019-01-20T09:00:01', 'dev1', 43.5, 'orange2', 'device-id-2'), ('2017-01-20T09:00:01', 'dev1', 43.5, 'yellow2', 'device-id-2'), ('2019-01-20T09:00:01', 'dev2', 43.5, 'orange2', 'device-id-2') ON CONFLICT (time, device_id) DO UPDATE SET device_id_2 = coalesce(excluded.device_id_2,current.device_id_2), temp = coalesce(excluded.temp,current.temp) , color = coalesce(excluded.color,current.color); select * from upsert_test_diffchunk order by time, device_id; time | device_id | temp | color | device_id_2 --------------------------+----------------------+------+---------+---------------------- Fri Jan 20 09:00:01 2017 | dev1 | 43.5 | yellow2 | device-id-2 Fri Jan 20 09:00:01 2017 | dev2 | 25.9 | yellow | Sun Jan 20 09:00:01 2019 | dev1 | 43.5 | orange2 | device-id-2 Sun Jan 20 09:00:01 2019 | dev2 | 43.5 | orange2 | device-id-2 --arbiter index tests CREATE TABLE upsert_test_arbiter(time timestamp, to_drop int); SELECT create_hypertable('upsert_test_arbiter', 'time', chunk_time_interval=> interval '1 month'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------------------- (6,public,upsert_test_arbiter,t) --this is the chunk with no tup_conv_map INSERT INTO upsert_test_arbiter (time, to_drop) VALUES ('2017-01-20T09:00:01', 1) RETURNING *; time | to_drop --------------------------+--------- Fri Jan 20 09:00:01 2017 | 1 INSERT INTO upsert_test_arbiter (time, to_drop) VALUES ('2017-01-21T09:00:01', 2) RETURNING *; time | to_drop --------------------------+--------- Sat Jan 21 09:00:01 2017 | 2 INSERT INTO upsert_test_arbiter (time, to_drop) VALUES ('2017-03-20T09:00:01', 3) RETURNING *; time | to_drop --------------------------+--------- Mon Mar 20 09:00:01 2017 | 3 --alter the table ALTER TABLE upsert_test_arbiter DROP to_drop; ALTER TABLE upsert_test_arbiter ADD device_id char(20) DEFAULT 'dev1'; CREATE UNIQUE INDEX arbiter_time_device_idx ON upsert_test_arbiter (time, device_id); INSERT INTO upsert_test_arbiter as current (time, device_id) VALUES ('2018-01-21T09:00:01', 'dev1'), ('2017-01-20T09:00:01', 'dev1'), ('2017-01-21T09:00:01', 'dev2'), ('2018-01-21T09:00:01', 'dev2') ON CONFLICT (time, device_id) DO UPDATE SET device_id = coalesce(excluded.device_id,current.device_id) RETURNING *; time | device_id --------------------------+---------------------- Sun Jan 21 09:00:01 2018 | dev1 Fri Jan 20 09:00:01 2017 | dev1 Sat Jan 21 09:00:01 2017 | dev2 Sun Jan 21 09:00:01 2018 | dev2 with cte as ( INSERT INTO upsert_test_arbiter (time, device_id) VALUES ('2017-01-21T09:00:01', 'dev2'), ('2018-01-21T09:00:01', 'dev2') ON CONFLICT (time, device_id) DO UPDATE SET device_id = 'dev3' RETURNING *) select * from cte; time | device_id --------------------------+---------------------- Sat Jan 21 09:00:01 2017 | dev3 Sun Jan 21 09:00:01 2018 | dev3 -- test ON CONFLICT with prepared statements CREATE TABLE prepared_test(time timestamptz PRIMARY KEY, value float CHECK(value > 0)); SELECT create_hypertable('prepared_test','time'); create_hypertable ---------------------------- (7,public,prepared_test,t) CREATE TABLE source_data(time timestamptz PRIMARY KEY, value float); INSERT INTO source_data VALUES('2000-01-01',0.5), ('2001-01-01',0.5); -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the prepared statement 10 times -- check that an error in the prepared statement does not lead to the plan becoming unusable PREPARE prep_insert_select AS INSERT INTO prepared_test select * from source_data ON CONFLICT (time) DO UPDATE SET value = EXCLUDED.value; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; --this insert will create an invalid tuple in source_data --so that future calls to prep_insert_select will fail INSERT INTO source_data VALUES('2000-01-02',-0.5); \set ON_ERROR_STOP 0 EXECUTE prep_insert_select; ERROR: new row for relation "_hyper_7_11_chunk" violates check constraint "prepared_test_value_check" EXECUTE prep_insert_select; ERROR: new row for relation "_hyper_7_11_chunk" violates check constraint "prepared_test_value_check" \set ON_ERROR_STOP 1 DELETE FROM source_data WHERE value <= 0; EXECUTE prep_insert_select; PREPARE prep_insert AS INSERT INTO prepared_test VALUES('2000-01-01',0.5) ON CONFLICT (time) DO UPDATE SET value = EXCLUDED.value; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the prepared statement 10 times EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; SELECT * FROM prepared_test; time | value ------------------------------+------- Sat Jan 01 00:00:00 2000 PST | 0.5 Mon Jan 01 00:00:00 2001 PST | 0.5 DELETE FROM prepared_test; -- test ON CONFLICT with functions CREATE OR REPLACE FUNCTION test_upsert(t timestamptz, v float) RETURNS VOID AS $sql$ BEGIN INSERT INTO prepared_test VALUES(t,v) ON CONFLICT (time) DO UPDATE SET value = EXCLUDED.value; END; $sql$ LANGUAGE PLPGSQL; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the function 10 times SELECT counter,test_upsert('2000-01-01',0.5) FROM generate_series(1,10) AS g(counter); counter | test_upsert ---------+------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | SELECT * FROM prepared_test; time | value ------------------------------+------- Sat Jan 01 00:00:00 2000 PST | 0.5 DELETE FROM prepared_test; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the function 10 times SELECT counter,test_upsert('2000-01-01',0.5) FROM generate_series(1,10) AS g(counter); counter | test_upsert ---------+------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | SELECT * FROM prepared_test; time | value ------------------------------+------- Sat Jan 01 00:00:00 2000 PST | 0.5 DELETE FROM prepared_test; -- run it again to ensure INSERT path is still working as well SELECT counter,test_upsert('2000-01-01',0.5) FROM generate_series(1,10) AS g(counter); counter | test_upsert ---------+------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | SELECT * FROM prepared_test; time | value ------------------------------+------- Sat Jan 01 00:00:00 2000 PST | 0.5 DELETE FROM prepared_test; -- test ON CONFLICT with functions CREATE OR REPLACE FUNCTION test_upsert2(t timestamptz, v float) RETURNS VOID AS $sql$ BEGIN INSERT INTO prepared_test VALUES(t,v) ON CONFLICT (time) DO UPDATE SET value = prepared_test.value + 1.0; END; $sql$ LANGUAGE PLPGSQL; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the function 10 times SELECT counter,test_upsert2('2000-01-01',1.0) FROM generate_series(1,10) AS g(counter); counter | test_upsert2 ---------+-------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | SELECT * FROM prepared_test; time | value ------------------------------+------- Sat Jan 01 00:00:00 2000 PST | 10 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/util.out�����������������������������������������������������������0000664�0000000�0000000�00000012021�15100345067�0020335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set ECHO errors item ------------------------------------ db_util_wizard=a/db_util_wizard db_util_wizard=ar/db_util_wizard db_util_wizard=a*/db_util_wizard db_util_wizard=a*r*/db_util_wizard [NULL] [NULL] [NULL] [NULL] =a*r*/db_util_wizard db_util_wizard=a*r*/0 SELECT _timescaledb_functions.align_to_bucket('5 minutes'::interval, rng::tstzrange) FROM data; align_to_bucket ----------------------------------------------------------------- ["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:15:00 2025 PDT") ["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:20:00 2025 PDT") ["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:20:00 2025 PDT") \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.align_to_bucket(null, null); ERROR: could not determine polymorphic type because input has type unknown SELECT _timescaledb_functions.align_to_bucket(null::interval, null::tstzrange); align_to_bucket ----------------- [NULL] SELECT _timescaledb_functions.align_to_bucket( null::interval, '["2025-04-25 11:10:00+02","2025-04-25 11:14:00+02"]'::tstzrange ); align_to_bucket ----------------- [NULL] \set ON_ERROR_STOP 1 SELECT typ, _timescaledb_functions.get_internal_time_min(typ), _timescaledb_functions.get_internal_time_max(typ) FROM (VALUES ('bigint'::regtype), ('int'::regtype), ('smallint'::regtype), ('timestamp'::regtype), ('timestamptz'::regtype), ('date'::regtype), (null::regtype) ) t(typ); typ | get_internal_time_min | get_internal_time_max -----------------------------+-----------------------+----------------------- bigint | -9223372036854775808 | 9223372036854775807 integer | -2147483648 | 2147483647 smallint | -32768 | 32767 timestamp without time zone | -210866803200000000 | 9223371331199999999 timestamp with time zone | -210866803200000000 | 9223371331199999999 date | -210866803200000000 | 9223371331199999999 [NULL] | [NULL] | [NULL] \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.get_internal_time_min(0); ERROR: cache lookup failed for type 0 SELECT _timescaledb_functions.get_internal_time_max(0); ERROR: cache lookup failed for type 0 \set ON_ERROR_STOP 1 WITH tstzranges AS ( SELECT vid, rng::tstzrange, lower(rng::tstzrange) AS lower_ts, upper(rng::tstzrange) AS upper_ts FROM data ), usecranges AS ( SELECT vid, _timescaledb_functions.to_unix_microseconds(lower_ts) AS lower_usec, _timescaledb_functions.to_unix_microseconds(upper_ts) AS upper_usec FROM tstzranges ) SELECT _timescaledb_functions.make_multirange_from_internal_time(rng, lower_usec, upper_usec), _timescaledb_functions.make_range_from_internal_time(rng, lower_ts, upper_ts) FROM tstzranges join usecranges using (vid); make_multirange_from_internal_time | make_range_from_internal_time -------------------------------------------------------------------+----------------------------------------------------------------- {["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:14:00 2025 PDT")} | ["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:14:00 2025 PDT") {["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:17:00 2025 PDT")} | ["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:17:00 2025 PDT") {["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:20:00 2025 PDT")} | ["Fri Apr 25 02:10:00 2025 PDT","Fri Apr 25 02:20:00 2025 PDT") WITH tsranges AS ( SELECT vid, rng::tsrange, lower(rng::tsrange) AS lower_ts, upper(rng::tsrange) AS upper_ts FROM data ), usecranges AS ( SELECT vid, _timescaledb_functions.to_unix_microseconds(lower_ts) AS lower_usec, _timescaledb_functions.to_unix_microseconds(upper_ts) AS upper_usec FROM tsranges ) SELECT _timescaledb_functions.make_multirange_from_internal_time(rng, lower_usec, upper_usec), _timescaledb_functions.make_range_from_internal_time(rng, lower_ts, upper_ts) FROM tsranges join usecranges using (vid); make_multirange_from_internal_time | make_range_from_internal_time -----------------------------------------------------------+--------------------------------------------------------- {["Fri Apr 25 18:10:00 2025","Fri Apr 25 18:14:00 2025")} | ["Fri Apr 25 11:10:00 2025","Fri Apr 25 11:14:00 2025") {["Fri Apr 25 18:10:00 2025","Fri Apr 25 18:17:00 2025")} | ["Fri Apr 25 11:10:00 2025","Fri Apr 25 11:17:00 2025") {["Fri Apr 25 18:10:00 2025","Fri Apr 25 18:20:00 2025")} | ["Fri Apr 25 11:10:00 2025","Fri Apr 25 11:20:00 2025") ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/uuid.out�����������������������������������������������������������0000664�0000000�0000000�00000053240�15100345067�0020336�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- -- Test "time" partitioning on UUIDv7 -- -- CREATE TABLE uuid_events(id uuid primary key, device int, temp float); \set ON_ERROR_STOP 0 -- Test invalid interval type SELECT create_hypertable('uuid_events', 'id', chunk_time_interval => true); ERROR: invalid interval type for uuid dimension \set ON_ERROR_STOP 1 SELECT create_hypertable('uuid_events', 'id', chunk_time_interval => interval '1 day'); create_hypertable -------------------------- (1,public,uuid_events,t) -- -- Test that inserting boundary values generates the right constraints -- on chunks. -- -- First value with min time: 00000000-0000-7000-8000-000000000000 BEGIN; INSERT INTO uuid_events VALUES ('00000000-0000-7000-8000-000000000000', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+---------+----------------------------------------------+----------------------------------------------------------------------------------------------------------------+------------+----------+----------- 1_1_uuid_events_pkey | p | {id} | _timescaledb_internal."1_1_uuid_events_pkey" | | f | f | t constraint_1 | c | {id} | - | ((id >= '00000000-0000-0000-0000-000000000000'::uuid) AND (id < '00000526-5c00-0000-0000-000000000000'::uuid)) | f | f | t SELECT uuid_timestamp(id), device, temp FROM uuid_events ORDER BY id; uuid_timestamp | device | temp ------------------------------+--------+------ Wed Dec 31 16:00:00 1969 PST | 1 | 1 -- Update v7 UUID to a v4 UUID that doesn't violate the chunk's range -- constraint. Currently we don't prevent this "loophole". UPDATE uuid_events SET id = '00000000-0001-4000-8000-000000000000' WHERE id = '00000000-0000-7000-8000-000000000000'; SELECT uuid_timestamp(id), device, temp FROM uuid_events ORDER BY id; uuid_timestamp | device | temp ----------------+--------+------ | 1 | 1 -- Update v7 UUID to a v4 that violates the chunk constraint: \set ON_ERROR_STOP 0 UPDATE uuid_events SET id = 'ffff0000-0000-4000-8000-000000000000' WHERE id = '00000000-0001-4000-8000-000000000000'; ERROR: new row for relation "_hyper_1_1_chunk" violates check constraint "constraint_1" \set ON_ERROR_STOP 1 ROLLBACK; -- Last value with min time: 00000000-0000-7fff-bfff-ffffffffffff BEGIN; INSERT INTO uuid_events VALUES ('00000000-0000-7fff-bfff-ffffffffffff', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+---------+----------------------------------------------+----------------------------------------------------------------------------------------------------------------+------------+----------+----------- 2_2_uuid_events_pkey | p | {id} | _timescaledb_internal."2_2_uuid_events_pkey" | | f | f | t constraint_2 | c | {id} | - | ((id >= '00000000-0000-0000-0000-000000000000'::uuid) AND (id < '00000526-5c00-0000-0000-000000000000'::uuid)) | f | f | t ROLLBACK; -- First value with max time: ffffffff-ffff-7000-8000-000000000000 BEGIN; INSERT INTO uuid_events VALUES ('ffffffff-ffff-7000-8000-000000000000', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+---------+----------------------------------------------+------------------------------------------------------+------------+----------+----------- 3_3_uuid_events_pkey | p | {id} | _timescaledb_internal."3_3_uuid_events_pkey" | | f | f | t constraint_3 | c | {id} | - | (id >= 'fffffed0-3000-0000-0000-000000000000'::uuid) | f | f | t ROLLBACK; -- (Max time with min value) + 1 BEGIN; INSERT INTO uuid_events VALUES ('ffffffff-ffff-7000-8000-000000000001', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+---------+----------------------------------------------+------------------------------------------------------+------------+----------+----------- 4_4_uuid_events_pkey | p | {id} | _timescaledb_internal."4_4_uuid_events_pkey" | | f | f | t constraint_4 | c | {id} | - | (id >= 'fffffed0-3000-0000-0000-000000000000'::uuid) | f | f | t ROLLBACK; -- Last value with max time: ffffffff-ffff-7fff-bfff-ffffffffffff BEGIN; INSERT INTO uuid_events VALUES ('ffffffff-ffff-7fff-bfff-ffffffffffff', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+---------+----------------------------------------------+------------------------------------------------------+------------+----------+----------- 5_5_uuid_events_pkey | p | {id} | _timescaledb_internal."5_5_uuid_events_pkey" | | f | f | t constraint_5 | c | {id} | - | (id >= 'fffffed0-3000-0000-0000-000000000000'::uuid) | f | f | t ROLLBACK; -- -- It is possible to generate UUIDs like follows, but the random -- generator used doesn't respect setseed() so used constant UUIDs for -- determinism. -- -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-01 01:00 PST'), 1, 1.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-01 02:00 PST'), 2, 2.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-02 01:00 PST'), 3, 3.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-02 02:00 PST'), 4, 4.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-03 03:00 PST'), 5, 5.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-03 10:00 PST'), 6, 6.0); -- INSERT INTO uuid_events VALUES ('0194214e-cd00-7000-a9a7-63f1416dab45', 2, 2.0), ('01942117-de80-7000-8121-f12b2b69dd96', 1, 1.0), ('0194263e-3a80-7000-8f40-82c987b1bc1f', 3, 3.0), ('01942675-2900-7000-8db1-a98694b18785', 4, 4.0), ('01942bd2-7380-7000-9bc4-5f97443907b8', 5, 5.0), ('01942d52-f900-7000-866e-07d6404d53c1', 6, 6.0); SELECT * FROM show_chunks('uuid_events'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ----------------------+------+---------+----------------------------------------------+----------------------------------------------------------------------------------------------------------------+------------+----------+----------- 6_6_uuid_events_pkey | p | {id} | _timescaledb_internal."6_6_uuid_events_pkey" | | f | f | t constraint_6 | c | {id} | - | ((id >= '01941f29-7c00-0000-0000-000000000000'::uuid) AND (id < '0194244f-d800-0000-0000-000000000000'::uuid)) | f | f | t 7_7_uuid_events_pkey | p | {id} | _timescaledb_internal."7_7_uuid_events_pkey" | | f | f | t constraint_7 | c | {id} | - | ((id >= '0194244f-d800-0000-0000-000000000000'::uuid) AND (id < '01942976-3400-0000-0000-000000000000'::uuid)) | f | f | t 8_8_uuid_events_pkey | p | {id} | _timescaledb_internal."8_8_uuid_events_pkey" | | f | f | t constraint_8 | c | {id} | - | ((id >= '01942976-3400-0000-0000-000000000000'::uuid) AND (id < '01942e9c-9000-0000-0000-000000000000'::uuid)) | f | f | t SELECT id, device, temp FROM uuid_events; id | device | temp --------------------------------------+--------+------ 0194214e-cd00-7000-a9a7-63f1416dab45 | 2 | 2 01942117-de80-7000-8121-f12b2b69dd96 | 1 | 1 0194263e-3a80-7000-8f40-82c987b1bc1f | 3 | 3 01942675-2900-7000-8db1-a98694b18785 | 4 | 4 01942bd2-7380-7000-9bc4-5f97443907b8 | 5 | 5 01942d52-f900-7000-866e-07d6404d53c1 | 6 | 6 SELECT uuid_timestamp(id), device, temp FROM uuid_events; uuid_timestamp | device | temp ------------------------------+--------+------ Wed Jan 01 02:00:00 2025 PST | 2 | 2 Wed Jan 01 01:00:00 2025 PST | 1 | 1 Thu Jan 02 01:00:00 2025 PST | 3 | 3 Thu Jan 02 02:00:00 2025 PST | 4 | 4 Fri Jan 03 03:00:00 2025 PST | 5 | 5 Fri Jan 03 10:00:00 2025 PST | 6 | 6 SELECT uuid_timestamp(id), device, temp FROM uuid_events ORDER BY id; uuid_timestamp | device | temp ------------------------------+--------+------ Wed Jan 01 01:00:00 2025 PST | 1 | 1 Wed Jan 01 02:00:00 2025 PST | 2 | 2 Thu Jan 02 01:00:00 2025 PST | 3 | 3 Thu Jan 02 02:00:00 2025 PST | 4 | 4 Fri Jan 03 03:00:00 2025 PST | 5 | 5 Fri Jan 03 10:00:00 2025 PST | 6 | 6 SELECT _timescaledb_functions.to_timestamp(range_start) AS range_start, _timescaledb_functions.to_timestamp(range_end) AS range_end FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.dimension d ON (ds.dimension_id = d.id) JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.table_name = 'uuid_events'; range_start | range_end ------------------------------+------------------------------ Tue Dec 31 16:00:00 2024 PST | Wed Jan 01 16:00:00 2025 PST Wed Jan 01 16:00:00 2025 PST | Thu Jan 02 16:00:00 2025 PST Thu Jan 02 16:00:00 2025 PST | Fri Jan 03 16:00:00 2025 PST SELECT _timescaledb_functions.to_timestamp(range_start) AS chunk_range_start, _timescaledb_functions.to_timestamp(range_end) AS chunk_range_end FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.dimension d ON (ds.dimension_id = d.id) JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.table_name = 'uuid_events' LIMIT 1 OFFSET 1 \gset -- Test that chunk exclusion on uuidv7 column works SELECT :'chunk_range_start', to_uuidv7_boundary(:'chunk_range_start'); ?column? | to_uuidv7_boundary ------------------------------+-------------------------------------- Wed Jan 01 16:00:00 2025 PST | 0194244f-d800-7000-8000-000000000000 -- Exclude all but one chunk EXPLAIN (verbose, buffers off, costs off, timing off) SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_start'); --- QUERY PLAN --- Result Output: uuid_timestamp(_hyper_1_6_chunk.id), _hyper_1_6_chunk.device, _hyper_1_6_chunk.temp -> Index Scan using "6_6_uuid_events_pkey" on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.id, _hyper_1_6_chunk.device, _hyper_1_6_chunk.temp Index Cond: (_hyper_1_6_chunk.id < '0194244f-d800-7000-8000-000000000000'::uuid) SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_start'); uuid_timestamp | device | temp ------------------------------+--------+------ Wed Jan 01 01:00:00 2025 PST | 1 | 1 Wed Jan 01 02:00:00 2025 PST | 2 | 2 -- Exclude only one chunk. Add ordering (DESC) EXPLAIN (verbose, buffers off, costs off, timing off) SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_end') ORDER BY id DESC; --- QUERY PLAN --- Result Output: uuid_timestamp(uuid_events.id), uuid_events.device, uuid_events.temp, uuid_events.id -> Custom Scan (ChunkAppend) on public.uuid_events Output: uuid_events.id, uuid_events.device, uuid_events.temp Order: uuid_events.id DESC Startup Exclusion: false Runtime Exclusion: false -> Index Scan Backward using "7_7_uuid_events_pkey" on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.id, _hyper_1_7_chunk.device, _hyper_1_7_chunk.temp Index Cond: (_hyper_1_7_chunk.id < '01942976-3400-7000-8000-000000000000'::uuid) -> Index Scan Backward using "6_6_uuid_events_pkey" on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.id, _hyper_1_6_chunk.device, _hyper_1_6_chunk.temp Index Cond: (_hyper_1_6_chunk.id < '01942976-3400-7000-8000-000000000000'::uuid) SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_end') ORDER BY id DESC; uuid_timestamp | device | temp ------------------------------+--------+------ Thu Jan 02 02:00:00 2025 PST | 4 | 4 Thu Jan 02 01:00:00 2025 PST | 3 | 3 Wed Jan 01 02:00:00 2025 PST | 2 | 2 Wed Jan 01 01:00:00 2025 PST | 1 | 1 CREATE VIEW chunk_ranges AS SELECT chunk_name, _timescaledb_functions.to_timestamp(range_start_integer) AS range_start, _timescaledb_functions.to_timestamp(range_end_integer) AS range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'uuid_events'; SELECT * FROM chunk_ranges; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_6_chunk | Tue Dec 31 16:00:00 2024 PST | Wed Jan 01 16:00:00 2025 PST _hyper_1_7_chunk | Wed Jan 01 16:00:00 2025 PST | Thu Jan 02 16:00:00 2025 PST _hyper_1_8_chunk | Thu Jan 02 16:00:00 2025 PST | Fri Jan 03 16:00:00 2025 PST SELECT show_chunks('uuid_events', older_than => INTERVAL '1 day'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk SELECT show_chunks('uuid_events', older_than => '2025-01-02'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_6_chunk SELECT show_chunks('uuid_events', newer_than => '2025-01-02'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_8_chunk SELECT drop_chunks('uuid_events', older_than => '2025-01-02'); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_6_chunk SELECT show_chunks('uuid_events'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk -- Insert non-v7 UUIDs \set ON_ERROR_STOP 0 INSERT INTO uuid_events SELECT 'a8961135-cd89-4c4b-aa05-79df642407dd', 5, 5.0; ERROR: a8961135-cd89-4c4b-aa05-79df642407dd is not a version 7 UUID \set ON_ERROR_STOP 1 -- Insert as v7 UUID and later change to non-v7 to show effect on show_chunks() -- and drop_chunks() INSERT INTO uuid_events SELECT 'a8961135-cd89-7000-aa05-79df642407dd', 5, 5.0; SELECT * FROM chunk_ranges; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_7_chunk | Wed Jan 01 16:00:00 2025 PST | Thu Jan 02 16:00:00 2025 PST _hyper_1_8_chunk | Thu Jan 02 16:00:00 2025 PST | Fri Jan 03 16:00:00 2025 PST _hyper_1_9_chunk | Sun Nov 26 16:00:00 7843 PST | Mon Nov 27 16:00:00 7843 PST UPDATE uuid_events SET id = 'a8961135-cd89-4c4b-aa05-79df642407dd' WHERE id = 'a8961135-cd89-7000-aa05-79df642407dd'; SELECT show_chunks('uuid_events', newer_than => '2025-01-02'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_9_chunk SELECT drop_chunks('uuid_events', newer_than => '2025-01-02'); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_9_chunk SELECT * FROM chunk_ranges; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_7_chunk | Wed Jan 01 16:00:00 2025 PST | Thu Jan 02 16:00:00 2025 PST INSERT INTO uuid_events SELECT to_uuidv7(now()), 6, 6.0; SELECT show_chunks('uuid_events', newer_than => INTERVAL '2 months'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_1_10_chunk SELECT drop_chunks('uuid_events', newer_than => INTERVAL '2 months'); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_1_10_chunk SELECT show_chunks('uuid_events', newer_than => INTERVAL '2 months'); show_chunks ------------- DROP TABLE uuid_events; BEGIN; -- Test UUID partition when using CREATE TABLE ... WITH CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ) WITH ( tsdb.hypertable, tsdb.partition_column='event_id', tsdb.chunk_interval='2 hours' ); -- Verify that the chunk time interval is two hours SELECT ((interval_length/1000000)/60)/60 AS hours FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; hours ------- 2 ROLLBACK; -- Test a different interval BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ) WITH ( tsdb.hypertable, tsdb.partition_column='event_id', tsdb.chunk_interval='2 months' ); -- Verify that the chunk time interval is two hours SELECT (((interval_length/1000000)/60)/60)/24 AS days FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; days ------ 60 ROLLBACK; -- Verify same behavior without CREATE TABLE WITH: BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ); SELECT create_hypertable('events', 'event_id', chunk_time_interval => interval '2 hours'); WARNING: column type "character varying" used for "entity_id" does not follow best practices WARNING: column type "character varying" used for "event_type" does not follow best practices create_hypertable --------------------- (4,public,events,t) -- Verify that the chunk time interval is two hours SELECT ((interval_length/1000000)/60)/60 AS hours FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; hours ------- 2 ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ); SELECT create_hypertable('events', 'event_id', chunk_time_interval => interval '2 months'); WARNING: column type "character varying" used for "entity_id" does not follow best practices WARNING: column type "character varying" used for "event_type" does not follow best practices create_hypertable --------------------- (5,public,events,t) -- Verify that the chunk time interval is two hours SELECT (((interval_length/1000000)/60)/60)/24 AS days FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; days ------ 60 ROLLBACK; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/vacuum.out���������������������������������������������������������0000664�0000000�0000000�00000033441�15100345067�0020671�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE vacuum_test(time timestamp, temp float); -- create hypertable with three chunks SELECT create_hypertable('vacuum_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (1,public,vacuum_test,t) INSERT INTO vacuum_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); -- no stats SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -----------+---------+------------------+------------ SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'vacuum_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -----------+---------+------------------+------------ VACUUM ANALYZE vacuum_test; -- stats should exist for all three chunks SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct ------------------+---------+---------------------------------------------------------+------------ _hyper_1_1_chunk | temp | {17.5,19.1} | -1 _hyper_1_1_chunk | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017"} | -1 _hyper_1_2_chunk | temp | {17.1,89.5} | -1 _hyper_1_2_chunk | time | {"Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017"} | -1 _hyper_1_3_chunk | temp | {11,18.5} | -1 _hyper_1_3_chunk | time | {"Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 -- stats should exist on parent hypertable SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'vacuum_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -------------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------ vacuum_test | temp | {11,17.1,17.5,18.5,19.1,89.5} | -1 vacuum_test | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017","Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017","Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 DROP TABLE vacuum_test; --test plain analyze (no_vacuum) CREATE TABLE analyze_test(time timestamp, temp float); SELECT create_hypertable('analyze_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------- (2,public,analyze_test,t) INSERT INTO analyze_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); -- no stats SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -----------+---------+------------------+------------ SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'analyze_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -----------+---------+------------------+------------ ANALYZE analyze_test; -- stats should exist for all three chunks SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct ------------------+---------+---------------------------------------------------------+------------ _hyper_2_4_chunk | temp | {17.5,19.1} | -1 _hyper_2_4_chunk | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017"} | -1 _hyper_2_5_chunk | temp | {17.1,89.5} | -1 _hyper_2_5_chunk | time | {"Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017"} | -1 _hyper_2_6_chunk | temp | {11,18.5} | -1 _hyper_2_6_chunk | time | {"Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 -- stats should exist on parent hypertable SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'analyze_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct --------------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------ analyze_test | temp | {11,17.1,17.5,18.5,19.1,89.5} | -1 analyze_test | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017","Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017","Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 DROP TABLE analyze_test; -- Run vacuum on a normal (non-hypertable) table CREATE TABLE vacuum_norm(time timestamp, temp float); INSERT INTO vacuum_norm VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); VACUUM ANALYZE vacuum_norm; DROP TABLE vacuum_norm; --Similar to normal vacuum tests, but PG11 introduced ability to vacuum multiple tables at once, we make sure that works for hypertables as well. CREATE TABLE vacuum_test(time timestamp, temp float); -- create hypertable with three chunks SELECT create_hypertable('vacuum_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (3,public,vacuum_test,t) INSERT INTO vacuum_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); CREATE TABLE analyze_test(time timestamp, temp float); SELECT create_hypertable('analyze_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------- (4,public,analyze_test,t) INSERT INTO analyze_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); CREATE TABLE vacuum_norm(time timestamp, temp float); INSERT INTO vacuum_norm VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); -- no stats SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -----------+---------+------------------+------------ SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -----------+---------+------------------+------------ VACUUM ANALYZE vacuum_norm, vacuum_test, analyze_test; -- stats should exist for all 6 chunks SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct -------------------+---------+---------------------------------------------------------+------------ _hyper_3_7_chunk | temp | {17.5,19.1} | -1 _hyper_3_7_chunk | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017"} | -1 _hyper_3_8_chunk | temp | {17.1,89.5} | -1 _hyper_3_8_chunk | time | {"Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017"} | -1 _hyper_3_9_chunk | temp | {11,18.5} | -1 _hyper_3_9_chunk | time | {"Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 _hyper_4_10_chunk | temp | {17.5,19.1} | -1 _hyper_4_10_chunk | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017"} | -1 _hyper_4_11_chunk | temp | {17.1,89.5} | -1 _hyper_4_11_chunk | time | {"Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017"} | -1 _hyper_4_12_chunk | temp | {11,18.5} | -1 _hyper_4_12_chunk | time | {"Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 -- stats should exist on parent hypertable and normal table SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); tablename | attname | histogram_bounds | n_distinct --------------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------ analyze_test | temp | {11,17.1,17.5,18.5,19.1,89.5} | -1 analyze_test | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017","Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017","Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 vacuum_norm | temp | {11,17.1,17.5,18.5,19.1,89.5} | -1 vacuum_norm | time | {"Fri Jan 20 09:00:01 2017","Sat Jan 21 09:00:01 2017","Thu Apr 20 09:00:01 2017","Fri Apr 21 09:00:01 2017","Tue Jun 20 09:00:01 2017","Wed Jun 21 09:00:01 2017"} | -1 vacuum_test | temp | {11,17.1,17.5,18.5,19.1,89.5} | -1 vacuum_test | time | {"Fri Jan 20 16:00:01 2017","Sat Jan 21 16:00:01 2017","Thu Apr 20 16:00:01 2017","Fri Apr 21 16:00:01 2017","Tue Jun 20 16:00:01 2017","Wed Jun 21 16:00:01 2017"} | -1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/expected/vacuum_parallel.out������������������������������������������������0000664�0000000�0000000�00000003733�15100345067�0022546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- PG13 introduced parallel VACUUM functionality. It gets invoked when a table -- has two or more indexes on it. Read up more at -- https://www.postgresql.org/docs/13/sql-vacuum.html#PARALLEL CREATE TABLE vacuum_test(time timestamp NOT NULL, temp1 float, temp2 int); -- create hypertable -- we create chunks in public schema cause otherwise we would need -- elevated privileges to create indexes directly SELECT create_hypertable('vacuum_test', 'time', create_default_indexes => false, associated_schema_name => 'public'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (1,public,vacuum_test,t) -- parallel vacuum needs the index size to be larger than min_parallel_index_scan_size to kick in SET min_parallel_index_scan_size TO 0; INSERT INTO vacuum_test SELECT TIMESTAMP 'epoch' + (i * INTERVAL '4h'), i, i+1 FROM generate_series(1, 100) as T(i); -- create indexes on the temp columns -- we create indexes manually because otherwise vacuum verbose output -- would be different between 13.2 and 13.3+ -- 13.2 would try to vacuum the parent table index too while 13.3+ wouldn't CREATE INDEX ON _hyper_1_1_chunk(time); CREATE INDEX ON _hyper_1_1_chunk(temp1); CREATE INDEX ON _hyper_1_1_chunk(temp2); CREATE INDEX ON _hyper_1_2_chunk(time); CREATE INDEX ON _hyper_1_2_chunk(temp1); CREATE INDEX ON _hyper_1_2_chunk(temp2); CREATE INDEX ON _hyper_1_3_chunk(time); CREATE INDEX ON _hyper_1_3_chunk(temp1); CREATE INDEX ON _hyper_1_3_chunk(temp2); -- INSERT only will not trigger vacuum on indexes for PG13.3+ UPDATE vacuum_test SET time = time + '1s'::interval, temp1 = random(), temp2 = random(); -- we should see two parallel workers for each chunk VACUUM (PARALLEL 3) vacuum_test; DROP TABLE vacuum_test; �������������������������������������timescaledb-2.23.0/test/expected/version.out��������������������������������������������������������0000664�0000000�0000000�00000000772�15100345067�0021057�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that get_os_info returns 3 x text select pg_typeof(sysname) AS sysname_type,pg_typeof(version) AS version_type,pg_typeof(release) AS release_type from _timescaledb_functions.get_os_info(); sysname_type | version_type | release_type --------------+--------------+-------------- text | text | text ������timescaledb-2.23.0/test/isolation/������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017033�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/CMakeLists.txt����������������������������������������������������0000664�0000000�0000000�00000000030�15100345067�0021564�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������add_subdirectory(specs) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/���������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020634�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/concurrent_add_dimension.out�����������������������������0000664�0000000�0000000�00000004710�15100345067�0026426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������unused step name: s1_wp_enable unused step name: s1_wp_release Parsed test spec with 3 sessions starting permutation: s3_wp_enable s1_add_dimension s2_add_dimension s3_wp_release s3_query step s3_wp_enable: SELECT debug_waitpoint_enable('add_dimension_ht_lock'); debug_waitpoint_enable ---------------------- step s1_add_dimension: SELECT column_name FROM add_dimension('dim_test', 'device', 2); <waiting ...> step s2_add_dimension: SELECT column_name FROM add_dimension('dim_test', 'device', 1); <waiting ...> step s3_wp_release: SELECT debug_waitpoint_release('add_dimension_ht_lock'); debug_waitpoint_release ----------------------- step s1_add_dimension: <... completed> column_name ----------- device step s2_add_dimension: <... completed> ERROR: column "device" is already a dimension step s3_query: SELECT count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test'; count ----- 2 starting permutation: s3_chunk_wp_enable s1_create_chunk s2_add_dimension2 s3_chunk_wp_release s3_query step s3_chunk_wp_enable: SELECT debug_waitpoint_enable('chunk_create_for_point'); debug_waitpoint_enable ---------------------- step s1_create_chunk: INSERT INTO dim_test VALUES ('2004-10-20 00:00:00+00', 1, 2); <waiting ...> step s2_add_dimension2: SELECT column_name FROM add_dimension('dim_test', 'device2', 1); <waiting ...> step s3_chunk_wp_release: SELECT debug_waitpoint_release('chunk_create_for_point'); debug_waitpoint_release ----------------------- step s1_create_chunk: <... completed> step s2_add_dimension2: <... completed> column_name ----------- device2 step s3_query: SELECT count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test'; count ----- 4 ��������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/concurrent_query_and_drop_chunks.out���������������������0000664�0000000�0000000�00000003367�15100345067�0030226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 4 sessions starting permutation: s2_query s1_wp_enable s2_query s1_drop_chunks s1_wp_release s2_show_num_chunks step s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Sun Jan 03 10:30:00 2021 PST| 2| 2 step s1_wp_enable: SELECT debug_waitpoint_enable('hypertable_expansion_before_lock_chunk'); debug_waitpoint_enable ---------------------- step s2_query: SELECT * FROM measurements ORDER BY 1; <waiting ...> step s1_drop_chunks: SELECT count(*) FROM drop_chunks('measurements', TIMESTAMPTZ '2020-03-01'); count ----- 1 step s1_wp_release: SELECT debug_waitpoint_release('hypertable_expansion_before_lock_chunk'); debug_waitpoint_release ----------------------- step s2_query: <... completed> time |device|temp ----------------------------+------+---- Sun Jan 03 10:30:00 2021 PST| 2| 2 step s2_show_num_chunks: SELECT count(*) FROM show_chunks('measurements') ORDER BY 1; count ----- 1 starting permutation: s3_wp_enable s4_hypertable_size s3_drop_chunks s3_wp_release step s3_wp_enable: SELECT debug_waitpoint_enable('relation_size_before_lock'); debug_waitpoint_enable ---------------------- step s4_hypertable_size: SELECT count(*) FROM hypertable_size('measurements'); <waiting ...> step s3_drop_chunks: SELECT count(*) FROM drop_chunks('measurements', TIMESTAMPTZ '2020-03-01'); count ----- 1 step s3_wp_release: SELECT debug_waitpoint_release('relation_size_before_lock'); debug_waitpoint_release ----------------------- step s4_hypertable_size: <... completed> count ----- 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/deadlock_dropchunks_select.out���������������������������0000664�0000000�0000000�00000005021�15100345067�0026730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s1b s2a s2b step s1a: SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); count ----- 24 step s1b: COMMIT; step s2a: SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; typ|loc|mtim ---+---+---- step s2b: COMMIT; starting permutation: s1a s2a s1b s2b step s1a: SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); count ----- 24 step s2a: SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; <waiting ...> step s1b: COMMIT; step s2a: <... completed> typ|loc|mtim ---+---+---- step s2b: COMMIT; starting permutation: s1a s2a s2b s1b step s1a: SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); count ----- 24 step s2a: SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; <waiting ...> step s2a: <... completed> ERROR: canceling statement due to lock timeout step s2b: COMMIT; step s1b: COMMIT; starting permutation: s2a s1a s1b s2b step s2a: SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; typ|loc|mtim ---+---+---- step s1a: SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); <waiting ...> step s1a: <... completed> ERROR: canceling statement due to lock timeout step s1b: COMMIT; step s2b: COMMIT; starting permutation: s2a s1a s2b s1b step s2a: SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; typ|loc|mtim ---+---+---- step s1a: SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); <waiting ...> step s2b: COMMIT; step s1a: <... completed> count ----- 24 step s1b: COMMIT; starting permutation: s2a s2b s1a s1b step s2a: SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; typ|loc|mtim ---+---+---- step s2b: COMMIT; step s1a: SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); count ----- 24 step s1b: COMMIT; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/dropchunks_race.out��������������������������������������0000664�0000000�0000000�00000007355�15100345067�0024551�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 5 sessions starting permutation: s3_chunks_found_wait s1_drop_chunks s2_drop_chunks s3_chunks_found_release s3_show_missing_slices s3_show_num_chunks s3_show_data step s3_chunks_found_wait: SELECT debug_waitpoint_enable('drop_chunks_chunks_found'); debug_waitpoint_enable ---------------------- step s1_drop_chunks: SELECT count(*) FROM drop_chunks('dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); <waiting ...> step s2_drop_chunks: SELECT count(*) FROM drop_chunks('dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); <waiting ...> step s3_chunks_found_release: SELECT debug_waitpoint_release('drop_chunks_chunks_found'); debug_waitpoint_release ----------------------- step s1_drop_chunks: <... completed> count ----- 1 step s2_drop_chunks: <... completed> count ----- 0 step s3_show_missing_slices: SELECT count(*) FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id NOT IN (SELECT id FROM _timescaledb_catalog.dimension_slice); count ----- 0 step s3_show_num_chunks: SELECT count(*) FROM show_chunks('dropchunks_race_t1') ORDER BY 1; count ----- 0 step s3_show_data: SELECT * FROM dropchunks_race_t1 ORDER BY 1; time|device|temp ----+------+---- starting permutation: s4_chunks_dropped_wait s1_drop_chunks s5_insert_new_chunk s4_chunks_dropped_release s3_show_missing_slices s3_show_num_chunks s3_show_data step s4_chunks_dropped_wait: SELECT debug_waitpoint_enable('drop_chunks_end'); debug_waitpoint_enable ---------------------- step s1_drop_chunks: SELECT count(*) FROM drop_chunks('dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); <waiting ...> step s5_insert_new_chunk: INSERT INTO dropchunks_race_t1 VALUES ('2020-03-01 10:30', 1, 2.2); <waiting ...> step s4_chunks_dropped_release: SELECT debug_waitpoint_release('drop_chunks_end'); debug_waitpoint_release ----------------------- step s1_drop_chunks: <... completed> count ----- 1 step s5_insert_new_chunk: <... completed> step s3_show_missing_slices: SELECT count(*) FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id NOT IN (SELECT id FROM _timescaledb_catalog.dimension_slice); count ----- 0 step s3_show_num_chunks: SELECT count(*) FROM show_chunks('dropchunks_race_t1') ORDER BY 1; count ----- 1 step s3_show_data: SELECT * FROM dropchunks_race_t1 ORDER BY 1; time |device|temp ----------------------------+------+---- Sun Mar 01 10:30:00 2020 PST| 1| 2.2 starting permutation: s4_chunks_dropped_wait s1_drop_chunks s5_insert_old_chunk s4_chunks_dropped_release s3_show_missing_slices s3_show_num_chunks s3_show_data step s4_chunks_dropped_wait: SELECT debug_waitpoint_enable('drop_chunks_end'); debug_waitpoint_enable ---------------------- step s1_drop_chunks: SELECT count(*) FROM drop_chunks('dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); <waiting ...> step s5_insert_old_chunk: INSERT INTO dropchunks_race_t1 VALUES ('2020-01-02 10:31', 1, 1.1); <waiting ...> step s4_chunks_dropped_release: SELECT debug_waitpoint_release('drop_chunks_end'); debug_waitpoint_release ----------------------- step s1_drop_chunks: <... completed> count ----- 1 step s5_insert_old_chunk: <... completed> step s3_show_missing_slices: SELECT count(*) FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id NOT IN (SELECT id FROM _timescaledb_catalog.dimension_slice); count ----- 0 step s3_show_num_chunks: SELECT count(*) FROM show_chunks('dropchunks_race_t1') ORDER BY 1; count ----- 1 step s3_show_data: SELECT * FROM dropchunks_race_t1 ORDER BY 1; time |device|temp ----------------------------+------+---- Thu Jan 02 10:31:00 2020 PST| 1| 1.1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/insert_dropchunks_race.out�������������������������������0000664�0000000�0000000�00000001041�15100345067�0026117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s2a s1b s2b s1c step s1a: INSERT INTO insert_dropchunks_race_t1 VALUES ('2020-01-03 10:30', 3, 33.4); step s2a: SELECT COUNT(*) FROM drop_chunks('insert_dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); <waiting ...> step s1b: COMMIT; step s2a: <... completed> count ----- 2 step s2b: COMMIT; step s1c: SELECT COUNT(*) FROM _timescaledb_catalog.chunk_constraint LEFT JOIN _timescaledb_catalog.dimension_slice sl ON dimension_slice_id = sl.id WHERE sl.id IS NULL; count ----- 0 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/isolation_nop.out����������������������������������������0000664�0000000�0000000�00000000247�15100345067�0024245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 1 sessions starting permutation: s1a table_name --------------- ts_cluster_test step s1a: SELECT pg_sleep(0); pg_sleep -------- ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/multi_transaction_indexing.out���������������������������0000664�0000000�0000000�00000005324�15100345067�0027015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 8 sessions starting permutation: CI I1 Ic Bc P Sc step CI: CREATE INDEX test_index ON ts_index_test(location) WITH (timescaledb.transaction_per_chunk, timescaledb.barrier_table='barrier'); <waiting ...> step I1: INSERT INTO ts_index_test VALUES (31, 6.4, 1); step Ic: COMMIT; step Bc: ROLLBACK; step CI: <... completed> step P: SELECT * FROM hypertable_index_size('test_index'); hypertable_index_size --------------------- 73728 step Sc: COMMIT; starting permutation: I1 CI Bc Ic P Sc step I1: INSERT INTO ts_index_test VALUES (31, 6.4, 1); step CI: CREATE INDEX test_index ON ts_index_test(location) WITH (timescaledb.transaction_per_chunk, timescaledb.barrier_table='barrier'); <waiting ...> step Bc: ROLLBACK; step Ic: COMMIT; step CI: <... completed> step P: SELECT * FROM hypertable_index_size('test_index'); hypertable_index_size --------------------- 73728 step Sc: COMMIT; starting permutation: S1 CI Bc Sc P Ic step S1: SELECT * FROM ts_index_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step CI: CREATE INDEX test_index ON ts_index_test(location) WITH (timescaledb.transaction_per_chunk, timescaledb.barrier_table='barrier'); <waiting ...> step Bc: ROLLBACK; step CI: <... completed> step Sc: COMMIT; step P: SELECT * FROM hypertable_index_size('test_index'); hypertable_index_size --------------------- 57344 step Ic: COMMIT; starting permutation: F WPE CI DI Bc WPR P Ic Sc step F: SET client_min_messages TO 'error'; step WPE: SELECT debug_waitpoint_enable('process_index_start_indexing_done'); debug_waitpoint_enable ---------------------- step CI: CREATE INDEX test_index ON ts_index_test(location) WITH (timescaledb.transaction_per_chunk, timescaledb.barrier_table='barrier'); <waiting ...> step DI: DROP INDEX test_index; <waiting ...> step Bc: ROLLBACK; step DI: <... completed> step WPR: SELECT debug_waitpoint_release('process_index_start_indexing_done'); debug_waitpoint_release ----------------------- step CI: <... completed> step P: SELECT * FROM hypertable_index_size('test_index'); ERROR: relation "test_index" does not exist step Ic: COMMIT; step Sc: COMMIT; starting permutation: CI RI Bc P Ic Sc step CI: CREATE INDEX test_index ON ts_index_test(location) WITH (timescaledb.transaction_per_chunk, timescaledb.barrier_table='barrier'); <waiting ...> step RI: ALTER TABLE test_index RENAME COLUMN location TO height; <waiting ...> step Bc: ROLLBACK; step CI: <... completed> step RI: <... completed> step P: SELECT * FROM hypertable_index_size('test_index'); hypertable_index_size --------------------- 57344 step Ic: COMMIT; step Sc: COMMIT; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/read_committed_insert.out��������������������������������0000664�0000000�0000000�00000003645�15100345067�0025741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s1c s2a s2b table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s1c: COMMIT; step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s2b: COMMIT; starting permutation: s1a s2a s1c s2b table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); <waiting ...> step s1c: COMMIT; step s2a: <... completed> step s2b: COMMIT; starting permutation: s1a s2a s2b s1c table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); <waiting ...> step s2a: <... completed> ERROR: canceling statement due to lock timeout step s2b: COMMIT; step s1c: COMMIT; starting permutation: s2a s1a s1c s2b table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); <waiting ...> step s1a: <... completed> ERROR: canceling statement due to lock timeout step s1c: COMMIT; step s2b: COMMIT; starting permutation: s2a s1a s2b s1c table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); <waiting ...> step s2b: COMMIT; step s1a: <... completed> step s1c: COMMIT; starting permutation: s2a s2b s1a s1c table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s2b: COMMIT; step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s1c: COMMIT; �������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/read_uncommitted_insert.out������������������������������0000664�0000000�0000000�00000003645�15100345067�0026304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s1c s2a s2b table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s1c: COMMIT; step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s2b: COMMIT; starting permutation: s1a s2a s1c s2b table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); <waiting ...> step s1c: COMMIT; step s2a: <... completed> step s2b: COMMIT; starting permutation: s1a s2a s2b s1c table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); <waiting ...> step s2a: <... completed> ERROR: canceling statement due to lock timeout step s2b: COMMIT; step s1c: COMMIT; starting permutation: s2a s1a s1c s2b table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); <waiting ...> step s1a: <... completed> ERROR: canceling statement due to lock timeout step s1c: COMMIT; step s2b: COMMIT; starting permutation: s2a s1a s2b s1c table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); <waiting ...> step s2b: COMMIT; step s1a: <... completed> step s1c: COMMIT; starting permutation: s2a s2b s1a s1c table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s2b: COMMIT; step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s1c: COMMIT; �������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/repeatable_read_insert.out�������������������������������0000664�0000000�0000000�00000003645�15100345067�0026060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s1c s2a s2b table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s1c: COMMIT; step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s2b: COMMIT; starting permutation: s1a s2a s1c s2b table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); <waiting ...> step s1c: COMMIT; step s2a: <... completed> step s2b: COMMIT; starting permutation: s1a s2a s2b s1c table_name --------------- ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); <waiting ...> step s2a: <... completed> ERROR: canceling statement due to lock timeout step s2b: COMMIT; step s1c: COMMIT; starting permutation: s2a s1a s1c s2b table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); <waiting ...> step s1a: <... completed> ERROR: canceling statement due to lock timeout step s1c: COMMIT; step s2b: COMMIT; starting permutation: s2a s1a s2b s1c table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); <waiting ...> step s2b: COMMIT; step s1a: <... completed> step s1c: COMMIT; starting permutation: s2a s2b s1a s1c table_name --------------- ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); step s2b: COMMIT; step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); step s1c: COMMIT; �������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/serializable_insert.out����������������������������������0000664�0000000�0000000�00000004225�15100345067�0025422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s1c s2a s2c schema_name|table_name -----------+--------------- public |ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s1c: COMMIT; step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s2c: COMMIT; starting permutation: s1a s2a s1c s2c schema_name|table_name -----------+--------------- public |ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); <waiting ...> step s1c: COMMIT; step s2a: <... completed> step s2c: COMMIT; starting permutation: s1a s2a s2c s1c schema_name|table_name -----------+--------------- public |ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); <waiting ...> step s2a: <... completed> ERROR: canceling statement due to lock timeout step s2c: COMMIT; step s1c: COMMIT; starting permutation: s2a s1a s1c s2c schema_name|table_name -----------+--------------- public |ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); <waiting ...> step s1a: <... completed> ERROR: canceling statement due to lock timeout step s1c: COMMIT; step s2c: COMMIT; starting permutation: s2a s1a s2c s1c schema_name|table_name -----------+--------------- public |ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); <waiting ...> step s2c: COMMIT; step s1a: <... completed> step s1c: COMMIT; starting permutation: s2a s2c s1a s1c schema_name|table_name -----------+--------------- public |ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s2c: COMMIT; step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s1c: COMMIT; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/expected/serializable_insert_rollback.out�������������������������0000664�0000000�0000000�00000004241�15100345067�0027271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1a s1c s2a s2c schema_name|table_name -----------+--------------- public |ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s1c: ROLLBACK; step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s2c: COMMIT; starting permutation: s1a s2a s1c s2c schema_name|table_name -----------+--------------- public |ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); <waiting ...> step s1c: ROLLBACK; step s2a: <... completed> step s2c: COMMIT; starting permutation: s1a s2a s2c s1c schema_name|table_name -----------+--------------- public |ts_cluster_test step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); <waiting ...> step s2a: <... completed> ERROR: canceling statement due to lock timeout step s2c: COMMIT; step s1c: ROLLBACK; starting permutation: s2a s1a s1c s2c schema_name|table_name -----------+--------------- public |ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); <waiting ...> step s1a: <... completed> ERROR: canceling statement due to lock timeout step s1c: ROLLBACK; step s2c: COMMIT; starting permutation: s2a s1a s2c s1c schema_name|table_name -----------+--------------- public |ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); <waiting ...> step s2c: COMMIT; step s1a: <... completed> step s1c: ROLLBACK; starting permutation: s2a s2c s1a s1c schema_name|table_name -----------+--------------- public |ts_cluster_test step s2a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); step s2c: COMMIT; step s1a: INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); step s1c: ROLLBACK; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020150�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/CMakeLists.txt����������������������������������������������0000664�0000000�0000000�00000001370�15100345067�0022711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(TEST_FILES deadlock_dropchunks_select.spec insert_dropchunks_race.spec isolation_nop.spec read_committed_insert.spec read_uncommitted_insert.spec repeatable_read_insert.spec serializable_insert_rollback.spec serializable_insert.spec) file(REMOVE ${ISOLATION_TEST_SCHEDULE}) set(TEST_TEMPLATES) if(CMAKE_BUILD_TYPE MATCHES Debug) list(APPEND TEST_FILES concurrent_add_dimension.spec concurrent_query_and_drop_chunks.spec dropchunks_race.spec multi_transaction_indexing.spec) endif(CMAKE_BUILD_TYPE MATCHES Debug) foreach(TEST_FILE ${TEST_FILES}) string(REGEX REPLACE "(.+)\.spec" "\\1" TESTS_TO_RUN ${TEST_FILE}) file(APPEND ${ISOLATION_TEST_SCHEDULE} "test: ${TESTS_TO_RUN}\n") endforeach(TEST_FILE) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/concurrent_add_dimension.spec�������������������������������0000664�0000000�0000000�00000004261�15100345067�0026066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { DROP TABLE IF EXISTS dim_test; CREATE TABLE dim_test(time TIMESTAMPTZ, device int, device2 int); SELECT table_name FROM create_hypertable('dim_test', 'time', chunk_time_interval => INTERVAL '1 day'); INSERT INTO dim_test VALUES ('2004-10-10 00:00:00+00', 1, 1); } teardown { DROP TABLE dim_test; } session "s1" step "s1_wp_enable" { SELECT debug_waitpoint_enable('add_dimension_ht_lock'); } step "s1_wp_release" { SELECT debug_waitpoint_release('add_dimension_ht_lock'); } step "s1_add_dimension" { SELECT column_name FROM add_dimension('dim_test', 'device', 2); } step "s1_create_chunk" { INSERT INTO dim_test VALUES ('2004-10-20 00:00:00+00', 1, 2); } session "s2" step "s2_add_dimension" { SELECT column_name FROM add_dimension('dim_test', 'device', 1); } step "s2_add_dimension2" { SELECT column_name FROM add_dimension('dim_test', 'device2', 1); } session "s3" step "s3_wp_enable" { SELECT debug_waitpoint_enable('add_dimension_ht_lock'); } step "s3_wp_release" { SELECT debug_waitpoint_release('add_dimension_ht_lock'); } step "s3_chunk_wp_enable" { SELECT debug_waitpoint_enable('chunk_create_for_point'); } step "s3_chunk_wp_release" { SELECT debug_waitpoint_release('chunk_create_for_point'); } step "s3_query" { SELECT count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test'; } # Test concurrent add_dimension() call with existing data # permutation "s3_wp_enable" "s1_add_dimension" "s2_add_dimension" "s3_wp_release" "s3_query" # Test concurrent chunk creation during add_dimension() call # permutation "s3_chunk_wp_enable" "s1_create_chunk" "s2_add_dimension2" "s3_chunk_wp_release" "s3_query" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/concurrent_query_and_drop_chunks.spec�����������������������0000664�0000000�0000000�00000003665�15100345067�0027666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { DROP TABLE IF EXISTS measurements; CREATE TABLE measurements (time timestamptz, device int, temp float); SELECT create_hypertable('measurements', 'time', 'device', 2); INSERT INTO measurements VALUES ('2020-01-03 10:30', 1, 1.0), ('2021-01-03 10:30', 2, 2.0); } teardown { DROP TABLE measurements; } # # Test concurrent querying and drop chunks. # session "s1" step "s1_wp_enable" { SELECT debug_waitpoint_enable('hypertable_expansion_before_lock_chunk'); } step "s1_wp_release" { SELECT debug_waitpoint_release('hypertable_expansion_before_lock_chunk'); } step "s1_drop_chunks" { SELECT count(*) FROM drop_chunks('measurements', TIMESTAMPTZ '2020-03-01'); } session "s2" step "s2_show_num_chunks" { SELECT count(*) FROM show_chunks('measurements') ORDER BY 1; } step "s2_query" { SELECT * FROM measurements ORDER BY 1; } session "s3" step "s3_wp_enable" { SELECT debug_waitpoint_enable('relation_size_before_lock'); } step "s3_wp_release" { SELECT debug_waitpoint_release('relation_size_before_lock'); } step "s3_drop_chunks" { SELECT count(*) FROM drop_chunks('measurements', TIMESTAMPTZ '2020-03-01'); } session "s4" step "s4_hypertable_size" { SELECT count(*) FROM hypertable_size('measurements'); } # The wait point happens after chunks have been found for table # expansion, but before the chunks are locked. Because one chunk # will dropped before the lock is acqurired, the chunk should # also be ignored. permutation "s2_query" "s1_wp_enable" "s2_query" "s1_drop_chunks" "s1_wp_release" "s2_show_num_chunks" # The wait point happens before the relation_size get the lock # for the relation and one chunk will be dropped in another session # don't leading to race conditions permutation "s3_wp_enable" "s4_hypertable_size" "s3_drop_chunks" "s3_wp_release" ���������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/deadlock_dropchunks_select.spec�����������������������������0000664�0000000�0000000�00000002676�15100345067�0026404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. ##github issue 865 deadlock between select and drop chunks setup { CREATE TABLE ST ( sid int PRIMARY KEY, typ text) ; CREATE TABLE SL ( lid int PRIMARY KEY, loc text) ; CREATE TABLE DT ( sid int REFERENCES ST(sid), lid int REFERENCES SL(lid), mtim timestamp with time zone ) ; SELECT create_hypertable('DT', 'mtim', chunk_time_interval => interval '1 day'); INSERT INTO SL VALUES (1, 'LA'); INSERT INTO ST VALUES (1, 'T1'); INSERT INTO DT (sid,lid,mtim) SELECT 1,1, generate_series( '2018-12-01 00:00'::timestamp, '2018-12-31 12:00','1 minute') ; } teardown { DROP TABLE DT; DROP table ST; DROP table SL; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '5000ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s1a" { SELECT count (*) FROM drop_chunks('dt', '2018-12-25 00:00'::timestamptz); } step "s1b" { COMMIT; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '5000ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s2a" { SELECT typ, loc, mtim FROM DT , SL , ST WHERE SL.lid = DT.lid AND ST.sid = DT.sid AND mtim >= '2018-12-01 03:00:00+00' AND mtim <= '2018-12-01 04:00:00+00' AND typ = 'T1' ; } step "s2b" { COMMIT; } ������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/dropchunks_race.spec����������������������������������������0000664�0000000�0000000�00000005121�15100345067�0024175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { DROP TABLE IF EXISTS dropchunks_race_t1; CREATE TABLE dropchunks_race_t1 (time timestamptz, device int, temp float); SELECT create_hypertable('dropchunks_race_t1', 'time', 'device', 2); INSERT INTO dropchunks_race_t1 VALUES ('2020-01-03 10:30', 1, 32.2); } teardown { DROP TABLE dropchunks_race_t1; } session "s1" step "s1_drop_chunks" { SELECT count(*) FROM drop_chunks('dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); } session "s2" step "s2_drop_chunks" { SELECT count(*) FROM drop_chunks('dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); } session "s3" step "s3_chunks_found_wait" { SELECT debug_waitpoint_enable('drop_chunks_chunks_found'); } step "s3_chunks_found_release" { SELECT debug_waitpoint_release('drop_chunks_chunks_found'); } step "s3_show_missing_slices" { SELECT count(*) FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id NOT IN (SELECT id FROM _timescaledb_catalog.dimension_slice); } step "s3_show_num_chunks" { SELECT count(*) FROM show_chunks('dropchunks_race_t1') ORDER BY 1; } step "s3_show_data" { SELECT * FROM dropchunks_race_t1 ORDER BY 1; } session "s4" step "s4_chunks_dropped_wait" { SELECT debug_waitpoint_enable('drop_chunks_end'); } step "s4_chunks_dropped_release" { SELECT debug_waitpoint_release('drop_chunks_end'); } session "s5" step "s5_insert_old_chunk" { INSERT INTO dropchunks_race_t1 VALUES ('2020-01-02 10:31', 1, 1.1); } step "s5_insert_new_chunk" { INSERT INTO dropchunks_race_t1 VALUES ('2020-03-01 10:30', 1, 2.2); } # Test race between two drop_chunks processes. permutation "s3_chunks_found_wait" "s1_drop_chunks" "s2_drop_chunks" "s3_chunks_found_release" "s3_show_missing_slices" "s3_show_num_chunks" "s3_show_data" # Test race between drop_chunks and an insert into a new chunk. The # new chunk will share a slice with the chunk that is about to be # dropped. The shared slice must persist after drop_chunks completes, # or otherwise the new chunk will lack one slice. permutation "s4_chunks_dropped_wait" "s1_drop_chunks" "s5_insert_new_chunk" "s4_chunks_dropped_release" "s3_show_missing_slices" "s3_show_num_chunks" "s3_show_data" # Test race between drop_chunks and an insert into the chunk being # concurrently dropped. The chunk and slices should be recreated. permutation "s4_chunks_dropped_wait" "s1_drop_chunks" "s5_insert_old_chunk" "s4_chunks_dropped_release" "s3_show_missing_slices" "s3_show_num_chunks" "s3_show_data" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/insert_dropchunks_race.spec���������������������������������0000664�0000000�0000000�00000003512�15100345067�0025563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. # Race condition between insert and drop_chunks # # If an insert need to create a new chunk, it will look for existing # dimension slices to see if any need to be added: if slices already # exist, they do not need to be re-constructed and constraints can be # added that reference these slices. If chunks are dropped, there is a # cleanup of unreferenced dimension slices which can possibly remove # unreferenced dimension slices if transactions creating new chunks do # not lock the dimension slices for read. # # This isolation test check that a concurrent insert and drop_chunks # do not accidentally create a broken state by adding chunk # constraints that reference non-existing dimension slices. setup { DROP TABLE IF EXISTS insert_dropchunks_race_t1; CREATE TABLE insert_dropchunks_race_t1 (time timestamptz, device int, temp float); SELECT create_hypertable('insert_dropchunks_race_t1', 'time', 'device', 2); INSERT INTO insert_dropchunks_race_t1 VALUES ('2020-01-03 10:30', 1, 32.2); } teardown { DROP TABLE insert_dropchunks_race_t1; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; } step "s1a" { INSERT INTO insert_dropchunks_race_t1 VALUES ('2020-01-03 10:30', 3, 33.4); } step "s1b" { COMMIT; } step "s1c" { SELECT COUNT(*) FROM _timescaledb_catalog.chunk_constraint LEFT JOIN _timescaledb_catalog.dimension_slice sl ON dimension_slice_id = sl.id WHERE sl.id IS NULL; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; } step "s2a" { SELECT COUNT(*) FROM drop_chunks('insert_dropchunks_race_t1', TIMESTAMPTZ '2020-03-01'); } step "s2b" { COMMIT; } permutation "s1a" "s2a" "s1b" "s2b" "s1c" ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/isolation_nop.spec������������������������������������������0000664�0000000�0000000�00000000734�15100345067�0023705�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup{ CREATE TABLE ts_cluster_test(time timestamptz, temp float, location int); SELECT table_name from create_hypertable('ts_cluster_test', 'time', chunk_time_interval => interval '1 day'); } teardown { DROP TABLE ts_cluster_test; } session "s1" step "s1a" { SELECT pg_sleep(0); } ������������������������������������timescaledb-2.23.0/test/isolation/specs/multi_transaction_indexing.spec�����������������������������0000664�0000000�0000000�00000011034�15100345067�0026447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { CREATE TABLE ts_index_test(time int, temp float, location int); SELECT create_hypertable('ts_index_test', 'time', chunk_time_interval => 10, create_default_indexes => false); INSERT INTO ts_index_test VALUES (1, 23.4, 1), (11, 21.3, 2), (21, 19.5, 3); CREATE TABLE barrier(i INTEGER); } teardown { DROP TABLE ts_index_test; DROP TABLE barrier; } session "Waitpoints" step "WPE" { SELECT debug_waitpoint_enable('process_index_start_indexing_done'); } step "WPR" { SELECT debug_waitpoint_release('process_index_start_indexing_done'); } session "CREATE INDEX" step "F" { SET client_min_messages TO 'error'; } step "CI" { CREATE INDEX test_index ON ts_index_test(location) WITH (timescaledb.transaction_per_chunk, timescaledb.barrier_table='barrier'); } session "RELEASE BARRIER" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; LOCK TABLE barrier;} step "Bc" { ROLLBACK; } session "SELECT" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "S1" { SELECT * FROM ts_index_test; } step "Sc" { COMMIT; } session "INSERT CHUNK" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "I1" { INSERT INTO ts_index_test VALUES (31, 6.4, 1); } step "Ic" { COMMIT; } session "DROP INDEX" step "DI" { DROP INDEX test_index; } session "RENAME COLUMN" step "RI" { ALTER TABLE test_index RENAME COLUMN location TO height; } session "COUNT INDEXES" step "P" { SELECT * FROM hypertable_index_size('test_index'); } # we need to COMMIT every transaction started in setup regardless of whether we use them # inserts work between chunks permutation "CI" "I1" "Ic" "Bc" "P" "Sc" # create blocks on insert permutation "I1" "CI" "Bc" "Ic" "P" "Sc" # create blocks on select permutation "S1" "CI" "Bc" "Sc" "P" "Ic" # drop works (the error message outputs an OID, remove the "F" to see the error) permutation "F" "WPE" "CI" "DI" "Bc" "WPR" "P" "Ic" "Sc" # rename should block permutation "CI" "RI" "Bc" "P" "Ic" "Sc" # Ideally we would declare these functions in setup, and use them to check that the actual index # exist on the relevant chunks in these tests. Unfortunately, in older versions of postgres # (IIRC until 10.4) there was an arbitrary limit that each SQL statement in an isolation test could # be no longer than 1024 characters. Instead, we currently use the number of bytes indexs take # as a proxy. Once we deprecate the old version, or add some other way to get index info we should # switch to this. # # -- functions from testsupport.sql duplicated here becasue we cannot include sql files # CREATE OR REPLACE FUNCTION show_columns(rel regclass) # RETURNS TABLE("Column" name, # "Type" text, # "Nullable" boolean) LANGUAGE SQL STABLE AS # $BODY$ # SELECT a.attname, # format_type(t.oid, t.typtypmod), # a.attnotnull # FROM pg_attribute a, pg_type t # WHERE a.attrelid = rel # AND a.atttypid = t.oid # AND a.attnum >= 0 # ORDER BY a.attnum; # $BODY$; # # CREATE OR REPLACE FUNCTION show_indexesp(pattern text) # RETURNS TABLE("Table" regclass, # "Index" regclass, # "Columns" name[], # "Expr" text, # "Unique" boolean, # "Primary" boolean, # "Exclusion" boolean, # "Tablespace" name) LANGUAGE PLPGSQL STABLE AS # $BODY$ # DECLARE # schema_name name = split_part(pattern, '.', 1); # table_name name = split_part(pattern, '.', 2); # BEGIN # IF schema_name = '' OR table_name = '' THEN # schema_name := current_schema(); # table_name := pattern; # END IF; # # RETURN QUERY # SELECT c.oid::regclass, # i.indexrelid::regclass, # array(SELECT "Column" FROM show_columns(i.indexrelid)), # pg_get_expr(i.indexprs, c.oid, true), # i.indisunique, # i.indisprimary, # i.indisexclusion, # (SELECT t.spcname FROM pg_class cc, pg_tablespace t WHERE cc.oid = i.indexrelid AND t.oid = cc.reltablespace) # FROM pg_class c, pg_index i # WHERE format('%I.%I', c.relnamespace::regnamespace::name, c.relname) LIKE format('%I.%s', schema_name, table_name) # AND c.oid = i.indrelid # ORDER BY c.oid, i.indexrelid; # END # $BODY$; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/read_committed_insert.spec����������������������������������0000664�0000000�0000000�00000001643�15100345067�0025374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { CREATE TABLE ts_cluster_test(time timestamptz, temp float, location int); SELECT table_name from create_hypertable('ts_cluster_test', 'time', chunk_time_interval => interval '1 day'); } teardown { DROP TABLE ts_cluster_test; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s1a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); } step "s1c" { COMMIT; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s2a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); } step "s2b" { COMMIT; } ���������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/read_uncommitted_insert.spec��������������������������������0000664�0000000�0000000�00000001645�15100345067�0025741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { CREATE TABLE ts_cluster_test(time timestamptz, temp float, location int); SELECT table_name from create_hypertable('ts_cluster_test', 'time', chunk_time_interval => interval '1 day'); } teardown { DROP TABLE ts_cluster_test; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s1a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); } step "s1c" { COMMIT; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s2a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); } step "s2b" { COMMIT; } �������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/repeatable_read_insert.spec���������������������������������0000664�0000000�0000000�00000001643�15100345067�0025513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { CREATE TABLE ts_cluster_test(time timestamptz, temp float, location int); SELECT table_name from create_hypertable('ts_cluster_test', 'time', chunk_time_interval => interval '1 day'); } teardown { DROP TABLE ts_cluster_test; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL REPEATABLE READ; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s1a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T090001', 23.4, 1); } step "s1c" { COMMIT; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL REPEATABLE READ; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s2a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T090002', 0.72, 1); } step "s2b" { COMMIT; } ���������������������������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/serializable_insert.spec������������������������������������0000664�0000000�0000000�00000001665�15100345067�0025066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { CREATE TABLE ts_cluster_test(time timestamptz, temp float, location int); SELECT schema_name, table_name FROM create_hypertable('ts_cluster_test', 'time', chunk_time_interval => interval '1 day'); } teardown { DROP TABLE ts_cluster_test; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s1a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); } step "s1c" { COMMIT; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s2a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); } step "s2c" { COMMIT; } ���������������������������������������������������������������������������timescaledb-2.23.0/test/isolation/specs/serializable_insert_rollback.spec���������������������������0000664�0000000�0000000�00000001667�15100345067�0026741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Apache License 2.0. # Please see the included NOTICE for copyright information and # LICENSE-APACHE for a copy of the license. setup { CREATE TABLE ts_cluster_test(time timestamptz, temp float, location int); SELECT schema_name, table_name FROM create_hypertable('ts_cluster_test', 'time', chunk_time_interval => interval '1 day'); } teardown { DROP TABLE ts_cluster_test; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s1a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1); } step "s1c" { ROLLBACK; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "s2a" { INSERT INTO ts_cluster_test VALUES ('2017-01-20T09:00:02', 0.72, 1); } step "s2c" { COMMIT; } �������������������������������������������������������������������������timescaledb-2.23.0/test/perl/�����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015774�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/perl/CMakeLists.txt���������������������������������������������������������0000664�0000000�0000000�00000000364�15100345067�0020537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(PERL_FILES TimescaleNode.pm) # Check if PostgreSQL was compiled with --enable-tap-tests if(TAP_CHECKS AND EXISTS "${PG_PKGLIBDIR}/pgxs/src/test/perl") install(FILES ${PERL_FILES} DESTINATION "${PG_PKGLIBDIR}/pgxs/src/test/perl") endif() ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/perl/README.md��������������������������������������������������������������0000664�0000000�0000000�00000005163�15100345067�0017260�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Perl-based TAP tests `test/perl/` contains shared infrastructure that's used by Perl-based tests across the source tree The tests are invoked via perl's `prove` command. By default every test in the t/ subdirectory is run. Individual test(s) can be run instead by passing something like `PROVE_TESTS="t/001_testname.pl t/002_othertestname.pl"` to make. You should prefer to write tests using `pg_regress`, or isolation tester specs, if possible. Note that all tests and test tools should have perltidy run on them using perltidy, for example: ``` perltidy --profile=$TS_SRC_DIR/.perltidyrc /path/to/taptest ``` ## Writing tests Tests are written using Perl's `Test::More` with some PostgreSQL-specific infrastructure from `src/test/perl` providing node management, support for invoking `psql` to run queries and get results, etc. You should read the documentation for `Test::More` before trying to write tests. The PG specific infrastructure has been extended via the `TimescaleNode` class in this directory to add timescale specific configuration parameters and some often used helper functions. Test scripts in the t/ subdirectory of a suite are executed in alphabetical order. Each test script should begin with: ``` use strict; use warnings; use TimescaleNode; use TestLib; # Replace with the number of tests to execute: use Test::More tests => 1; ``` then it will generally need to set up one or more nodes, run commands against them and evaluate the results. For example: ``` my $node = get_new_ts_node('access_node'); $node->init; $node->start; my $ret = $node->safe_psql('postgres', 'SELECT 1'); is($ret, '1', 'SELECT 1 returns 1'); $node->stop('fast'); ``` `Test::More::like` entails use of the qr// operator. Avoid Perl 5.8.8 bug #39185 by not using the "$" regular expression metacharacter in qr// when also using the "/m" modifier. Instead of "$", use "\n" or "(?=\n|\z)". Read the `Test::More` documentation for more on how to write tests: ``` perldoc Test::More ``` For available PostgreSQL-specific test methods and some example tests read the perldoc for the test modules, e.g.: ``` cd $COMMUNITY_PG_SRCS perldoc src/test/perl/PostgresNode.pm ``` ## Required Perl Tests must run on perl `5.8.0` and newer. `perlbrew` is a good way to obtain such a Perl; see http://perlbrew.pl . Just install and ``` perlbrew --force install 5.8.0 perlbrew use 5.8.0 perlbrew install-cpanm cpanm install IPC::Run ``` then re-run configure to ensure the correct Perl is used when running tests. To verify that the right Perl was found: ``` grep ^PERL= config.log ``` �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/perl/TimescaleNode.pm�������������������������������������������������������0000664�0000000�0000000�00000003643�15100345067�0021054�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # This class extends PostgresNode with Timescale-specific # routines for setup. package TimescaleNode; # Using linebreaks here to prevent perltidy from performing vertical alignment. # This functionality has changed in recent perltidy versions (e.g., 2021 10 29) # and would restrict the versions of perltidy that can be used to format the # sources. use parent PostgreSQL::Test::Cluster; use PostgreSQL::Test::Utils qw(slurp_file); use strict; use warnings; use Carp 'verbose'; $SIG{__DIE__} = \&Carp::confess; sub create { my ($class, $name, %kwargs) = @_; my $self = $class->new($name); $self->init(%kwargs); $self->start(%kwargs); $self->safe_psql('postgres', 'CREATE EXTENSION timescaledb'); return $self; } # initialize the data directory and add TS specific parameters sub init { my ($self, %kwargs) = @_; $self->SUPER::init(%kwargs); # append into postgresql.conf from Timescale # template config file $self->append_conf('postgresql.conf', slurp_file("$ENV{'CONFDIR'}/postgresql.conf")); $self->append_conf('postgresql.conf', 'datestyle=ISO'); } # helper function to check output from PSQL for a query sub psql_is { my ($self, $db, $query, $expected_stdout, $testname) = @_; my ($psql_rc, $psql_out, $psql_err) = $self->SUPER::psql($db, $query); PostgreSQL::Test::Cluster::ok(!$psql_rc, "$testname: err_code check"); PostgreSQL::Test::Cluster::is($psql_err, '', "$testname: error_msg check"); PostgreSQL::Test::Cluster::is($psql_out, $expected_stdout, "$testname: psql output check"); } # remove leading and trailing whitespace sub strip { my ($str) = @_; $str =~ s/^\s+|\s+$//g; return $str; } sub safe_psql { my ($self, $db, $query) = @_; my $psql_out = $self->SUPER::safe_psql($db, $query); return strip($psql_out); } 1; ���������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pg_hba.conf.in��������������������������������������������������������������0000664�0000000�0000000�00000002632�15100345067�0017531�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# TYPE DATABASE USER ADDRESS METHOD # "local" is for Unix domain socket connections only @TEST_HBA_LOCAL@ all all trust @TEST_HBA_LOCAL@ replication all trust # IPv4 local connections: hostssl all @TEST_ROLE_CLUSTER_SUPERUSER@ 127.0.0.1/32 cert clientcert=verify-full hostssl all @TEST_ROLE_1@ 127.0.0.1/32 cert clientcert=verify-full host all @TEST_ROLE_2@ 127.0.0.1/32 password host all @TEST_ROLE_3@ 127.0.0.1/32 password host all all 127.0.0.1/32 trust host replication all 127.0.0.1/32 trust # IPv6 local connections: hostssl all @TEST_ROLE_CLUSTER_SUPERUSER@ ::1/128 cert clientcert=verify-full hostssl all @TEST_ROLE_1@ ::1/128 cert clientcert=verify-full host all @TEST_ROLE_2@ ::1/128 password host all @TEST_ROLE_3@ ::1/128 password host all all ::1/128 trust ������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pg_prove.sh�����������������������������������������������������������������0000775�0000000�0000000�00000003553�15100345067�0017220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # Wrapper around perl prove utility to control running of TAP tests # # The following control variable is supported: # # PROVE_TESTS only run TAP tests from this list # e.g make provecheck PROVE_TESTS="t/foo.pl t/bar.pl" # # Note that you can also use regular expressions to run multiple # taps tests matching the pattern: # # e.g make provecheck PROVE_TESTS="t/*chunk*" # PROVE_TESTS=${PROVE_TESTS:-} PROVE=${PROVE:-prove} echo "SKIPS: ${SKIPS}" # If PROVE_TESTS is specified then run those subset of TAP tests even if # TESTS is also specified if [ -z "$PROVE_TESTS" ] && [ -z "${SKIPS}" ] then # Exit early if we are running with TESTS=expr if [ -n "$TESTS" ] then exit 0 fi FINAL_TESTS=$(ls -1 t/*.pl 2>/dev/null) elif [ -z "$PROVE_TESTS" ] && [ -n "${SKIPS}" ] then ALL_TESTS=$(ls -1 t/*.pl 2>/dev/null) FILTERED_TESTS="" # disable path expansion to make SKIPS='*' work set -f # to support wildcards in SKIPS we match the SKIPS # list against the actual list of tests for test_name in ${ALL_TESTS}; do for test_pattern in ${SKIPS}; do # shellcheck disable=SC2053 # We do want to match globs in $test_pattern here. if [[ $test_name == t/${test_pattern}.pl ]]; then continue 2 fi done FILTERED_TESTS="${FILTERED_TESTS}\n${test_name}" done FINAL_TESTS=$(echo -e "${FILTERED_TESTS}" | tr '\n' ' ' | sed -e 's/^ *//') else FINAL_TESTS=$PROVE_TESTS fi if [ -z "$FINAL_TESTS" ] then echo "No TAP tests to run for the current configuration, skipping..." exit 0; fi PG_VERSION_MAJOR=${PG_VERSION_MAJOR} ${PROVE} \ -I "${SRC_DIR}/src/test/perl" \ -I "${CM_SRC_DIR}/test/perl" \ -I "${PG_LIBDIR}/pgxs/src/test/perl" \ -I "${PG_PKGLIBDIR}/pgxs/src/test/perl" \ -I "${PG_LIBDIR}/postgresql/pgxs/src/test/perl" \ $FINAL_TESTS �����������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pg_regress.sh���������������������������������������������������������������0000775�0000000�0000000�00000017171�15100345067�0017540�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # shellcheck disable=SC2053 # Wrapper around pg_regress and pg_isolation_regress to be able to control the schedule with environment variables # # The following control variables are supported: # # TESTS only run tests from this list # IGNORES failure of tests in this list will not lead to test failure # SKIPS tests from this list are not run # # In TESTS you may use wildcards to match multiple test names # TESTS="compression*" will match all tests whose name starts with compression # TESTS="*compression*" will match all tests that have compression anywhere in the name # Wildcard matching also applies to version specific tests so compression-13 # would also be matched by those patterns. CURRENT_DIR=$(dirname $0) EXE_DIR=${EXE_DIR:-${CURRENT_DIR}} PG_REGRESS=${PG_REGRESS:-pg_regress} PG_REGRESS_DIFF_OPTS=-u TEST_SCHEDULE=${TEST_SCHEDULE:-} TEMP_SCHEDULE=${CURRENT_DIR}/temp_schedule SCHEDULE= TESTS=${TESTS:-} IGNORES=${IGNORES:-} SKIPS=${SKIPS:-} PSQL=${PSQL:-psql} PSQL="${PSQL} -X" # Prevent any .psqlrc files from being executed during the tests PG_VERSION_MAJOR=$(${PSQL} --version | awk '{split($3,v,"[.a-z]"); print v[1]}') # check if test matches any of the patterns in a list # $1 list of patterns or test names # $2 test name # we use == intentionally and not =~ because the pattern syntax differs between # those two and == allows for simpler patterns. With == the pattern to match # all bgw tests would be "*bgw*" while with =~ it would be ".*bgw.*" matches() { for pattern in $1; do if [[ $2 == $pattern ]]; then return 0 fi done return 1 } if [[ -z ${TEST_SCHEDULE} ]]; then echo "No test schedule supplied please set TEST_SCHEDULE" exit 1; fi # PG16 removed the `ignore` feature from `pg_regress` # so as an workaround if we have any IGNORES entry then # we merge it together with SKIPS and cleanup the IGNORES # https://github.com/postgres/postgres/commit/bd8d453e9b5f8b632a400a9e796fc041aed76d82 if [[ ${PG_VERSION_MAJOR} -ge 16 ]]; then if [[ -n ${IGNORES} ]]; then if [[ -n ${SKIPS} ]]; then SKIPS="${SKIPS} ${IGNORES}" else SKIPS="${IGNORES}" fi IGNORES="" fi fi echo "TESTS ${TESTS}" if [[ ${PG_VERSION_MAJOR} -lt 16 ]]; then echo "IGNORES ${IGNORES}" fi echo "SKIPS ${SKIPS}" if [[ -z ${TESTS} ]] && [[ -z ${SKIPS} ]] && [[ -z ${IGNORES} ]]; then # no filter variables set # nothing to do here and we can use the cmake generated schedule SCHEDULE=${TEST_SCHEDULE} elif [[ -z ${TESTS} && ( -n ${SKIPS} || -n ${IGNORES} ) ]]; then # If we only have IGNORES or SKIPS we can use the cmake created schedule # and just prepend ignore lines for the tests whose result should be # ignored and strip out the skipped tests. This will allow us to retain # the parallel groupings from the supplied schedule. echo > ${TEMP_SCHEDULE} ALL_TESTS=$(grep -a '^test: ' ${TEST_SCHEDULE} | sed -e 's!^test: !!' |tr '\n' ' ') # to support wildcards in IGNORES we match the IGNORES # list against the actual list of tests if [[ -n ${IGNORES} ]]; then for test_pattern in ${IGNORES}; do for test_name in ${ALL_TESTS}; do if [[ -n ${test_name} ]] && [[ $test_name == $test_pattern ]]; then echo "ignore: ${test_name}" >> ${TEMP_SCHEDULE} fi done for test_name in ${SKIPS} do if [[ -n ${test_name} && ${test_name} == ${test_pattern} ]] then echo "The ignored pattern '${test_name}' matches the skipped pattern '${test_pattern}'. This is not allowed." exit 1 fi done done fi cat ${TEST_SCHEDULE} >> ${TEMP_SCHEDULE} # to support wildcards in SKIPS we match the SKIPS # list against the actual list of tests if [[ -n ${SKIPS} ]]; then for test_pattern in ${SKIPS}; do for test_name in ${ALL_TESTS}; do if [[ $test_name == $test_pattern ]]; then sed -e "s!^test:\s*${test_name}\s*\$!!" -i.backup ${TEMP_SCHEDULE} sed -e "s!\b${test_name}\b!!" -i.backup ${TEMP_SCHEDULE} fi done done fi SCHEDULE=${TEMP_SCHEDULE} else # TESTS was specified so we need to create a new schedule based on that ALL_TESTS=$(grep -a '^test: ' ${TEST_SCHEDULE} | sed -e 's!^test: !!' |tr '\n' ' ') if [[ -z "${TESTS}" ]]; then TESTS=${ALL_TESTS} fi # build new test list in current_tests removing entries in SKIPS and # validating against schedule as TESTS might contain tests from # multiple suites and not apply to current run current_tests="" for test_pattern in ${TESTS}; do for test_name in ${ALL_TESTS}; do if ! matches "${SKIPS}" "${test_name}"; then if [[ $test_name == $test_pattern ]]; then current_tests="${current_tests} ${test_name}" fi fi done done # if none of the tests survived filtering we can exit early if [[ -z "${current_tests}" ]]; then exit 0 fi current_tests=$(echo "${current_tests}" | tr ' ' '\n' | sort) TESTS=${current_tests} echo > ${TEMP_SCHEDULE} # to support wildcards in IGNORES we match the IGNORES # list against the actual list of tests for test_pattern in ${IGNORES}; do for test_name in ${ALL_TESTS}; do if ! matches "${SKIPS}" "${test_name}"; then if [[ $test_name == $test_pattern ]]; then echo "ignore: ${test_name}" >> ${TEMP_SCHEDULE} fi fi done done for t in ${TESTS}; do echo "test: ${t}" >> ${TEMP_SCHEDULE} done SCHEDULE=${TEMP_SCHEDULE} fi function cleanup() { rm -rf ${EXE_DIR}/sql/dump rm -rf ${TEST_TABLESPACE1_PREFIX} rm -rf ${TEST_TABLESPACE2_PREFIX} rm -rf ${TEST_TABLESPACE3_PREFIX} rm -f ${TEMP_SCHEDULE} cat <<EOF | ${PSQL} -U ${USER} -h ${TEST_PGHOST} -p ${TEST_PGPORT} -d template1 >/dev/null 2>&1 DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; DROP TABLESPACE IF EXISTS tablespace3; EOF rm -rf ${TEST_OUTPUT_DIR}/.pg_init } trap cleanup EXIT # Generating a prefix directory for all test tablespaces. This should # be used to build a full path for the tablespace. Note that we # terminate the prefix with the directory separator so that we can # easily generate paths independent of the OS. # # This mktemp line will work on both OSX and GNU systems TEST_TABLESPACE1_PREFIX=${TEST_TABLESPACE1_PREFIX:-$(mktemp -d 2>/dev/null || mktemp -d -t 'timescaledb_regress')/} TEST_TABLESPACE2_PREFIX=${TEST_TABLESPACE2_PREFIX:-$(mktemp -d 2>/dev/null || mktemp -d -t 'timescaledb_regress')/} TEST_TABLESPACE3_PREFIX=${TEST_TABLESPACE3_PREFIX:-$(mktemp -d 2>/dev/null || mktemp -d -t 'timescaledb_regress')/} # Creating some defaults for transitioning tests to use the prefix. TEST_TABLESPACE1_PATH=${TEST_TABLESPACE1_PATH:-${TEST_TABLESPACE1_PREFIX}_default} TEST_TABLESPACE2_PATH=${TEST_TABLESPACE2_PATH:-${TEST_TABLESPACE2_PREFIX}_default} TEST_TABLESPACE3_PATH=${TEST_TABLESPACE3_PATH:-${TEST_TABLESPACE3_PREFIX}_default} mkdir -p $TEST_TABLESPACE1_PATH $TEST_TABLESPACE2_PATH $TEST_TABLESPACE3_PATH export TEST_TABLESPACE1_PREFIX TEST_TABLESPACE2_PREFIX TEST_TABLESPACE3_PREFIX export TEST_TABLESPACE1_PATH TEST_TABLESPACE2_PATH TEST_TABLESPACE3_PATH rm -rf ${TEST_OUTPUT_DIR}/.pg_init mkdir -p ${EXE_DIR}/sql/dump export PG_REGRESS_DIFF_OPTS # If so configured, we run the tests with faketime utility to change the current # time. This helps catch the mistakes with using the current time in test # references. We can't do this for isolation tests because this breaks the # waiting mechanism in isolation tester. if [[ "${PG_REGRESS_USE_FAKETIME}" == "1" ]] then PG_REGRESS_FAKETIME="${FAKETIME}" fi PG_REGRESS_OPTS="${PG_REGRESS_OPTS} --schedule=${SCHEDULE}" ${PG_REGRESS_FAKETIME} ${PG_REGRESS} "$@" ${PG_REGRESS_OPTS} �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pgpass.conf.in��������������������������������������������������������������0000664�0000000�0000000�00000000231�15100345067�0017577�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Only TEST_ROLE_2 should have password in passfile # TEST_ROLE_3 needs to rely on, e.g., user mappings in the DB *:*:*:@TEST_ROLE_2@:@TEST_ROLE_2_PASS@ �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pgtest.conf.in��������������������������������������������������������������0000664�0000000�0000000�00000000166�15100345067�0017617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# postgresql.conf settings for PostgreSQL test suite shared_preload_libraries=timescaledb @TELEMETRY_DEFAULT_SETTING@ ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pgtest/���������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016340�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pgtest/CMakeLists.txt�������������������������������������������������������0000664�0000000�0000000�00000005035�15100345067�0021103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(PG_REGRESS_DIR ${PG_SOURCE_DIR}/src/test/regress CACHE PATH "Path to PostgreSQL's regress directory") # input and output directory got removed in PG15 set(PGTEST_DIRS ${PG_REGRESS_DIR}/data ${PG_REGRESS_DIR}/sql ${PG_REGRESS_DIR}/expected) if(EXISTS ${PG_REGRESS_DIR}/input AND EXISTS ${PG_REGRESS_DIR}/output) list(APPEND PGTEST_DIRS ${PG_REGRESS_DIR}/input ${PG_REGRESS_DIR}/output) endif() # Copy the input and output files from PostgreSQL's test suite. The test suite # generates some SQL scripts and output files from template source files and # require directories to be colocated file(COPY ${PGTEST_DIRS} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) file(READ ${PG_REGRESS_DIR}/parallel_schedule PG_TEST_SCHEDULE) # create directory for tablespace test file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/testtablespace) # Tests to ignore set(PG_IGNORE_TESTS amutils database event_trigger jsonb_jsonpath opr_sanity sanity_check type_sanity create_am # Ignoring because it spawns different number of workers in different # versions. select_parallel psql) # Modify the test schedule to ignore some tests foreach(IGNORE_TEST ${PG_IGNORE_TESTS}) # ignored schedules was removed in PG16 # https://github.com/postgres/postgres/commit/bd8d453e9b5f8b632a400a9e796fc041aed76d82 if(${PG_VERSION_MAJOR} LESS "16") string(CONCAT PG_TEST_SCHEDULE "ignore: ${IGNORE_TEST}\n" ${PG_TEST_SCHEDULE}) else() # remove the ignored test from the schedule string(REPLACE "test: ${IGNORE_TEST}\n" "" PG_TEST_SCHEDULE "${PG_TEST_SCHEDULE}") string(REPLACE " ${IGNORE_TEST} " " " PG_TEST_SCHEDULE "${PG_TEST_SCHEDULE}") string(REPLACE " ${IGNORE_TEST}\n" "\n" PG_TEST_SCHEDULE "${PG_TEST_SCHEDULE}") endif() endforeach(IGNORE_TEST) # Write the final test schedule file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/schedule ${PG_TEST_SCHEDULE}) # Need --dlpath set to PostgreSQL's test directory so that the tests can load # libraries there set(PG_REGRESS_OPTS_PGTEST --schedule=${CMAKE_CURRENT_BINARY_DIR}/schedule --load-extension=timescaledb --dlpath=${PG_REGRESS_DIR}) add_custom_target( pginstallcheck COMMAND ${PG_REGRESS} ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_OPTS_PGTEST} ${PG_REGRESS_OPTS_TEMP_INSTANCE_PGTEST} USES_TERMINAL) add_custom_target( pginstallchecklocal COMMAND ${PG_REGRESS} ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_OPTS_PGTEST} ${PG_REGRESS_OPTS_LOCAL_INSTANCE} USES_TERMINAL) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/pgtest/README.md������������������������������������������������������������0000664�0000000�0000000�00000001750�15100345067�0017622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# PostgreSQL tests for TimescaleDB The CMake configuration within this directory makes it possible to run the standard PostgreSQL test suite with the TimescaleDB extension loaded. This is useful to ensure that TimescaleDBs modifications planner and DDL hooks are compatible with standard PostgreSQL. ## Running The configuration within adds a new CMake target, `pginstallcheck`, that allows running the PostgreSQL test suite using a modified test schedule. The target requires access to the PostgreSQL source code, which can be configured via the `PG_SOURCE_DIR` CMake variable. The source tree needs to be compiled, at least the `src/test/regress` directory. If the path to a PostgreSQL source tree is not auto-detected, this variable can be set manually to point to the right location. ``` # In top-level directory of a TimescaleDB source tree $ mkdir build && cd build $ cmake -DPG_SOURCE_DIR=<path/to/pg/source> .. ``` Once CMake is correctly configured, run: ``` $ make pginstallcheck ``` ������������������������timescaledb-2.23.0/test/postgres-asan-instrumentation-PG18GE.patch����������������������������������0000664�0000000�0000000�00000003446�15100345067�0025002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������diff --git a/src/backend/utils/misc/stack_depth.c b/src/backend/utils/misc/stack_depth.c index 8f7cf531fbc..2f7b1cebbe6 100644 --- a/src/backend/utils/misc/stack_depth.c +++ b/src/backend/utils/misc/stack_depth.c @@ -108,6 +108,12 @@ check_stack_depth(void) bool stack_is_too_deep(void) { + /* + * Pointer arithmetics to determine stack depth doesn't work under + * AddressSanitizer. + */ + return false; + char stack_top_loc; ssize_t stack_depth; diff --git a/src/include/utils/memdebug.h b/src/include/utils/memdebug.h index e88b4c6e8e..4ccbbf0146 100644 --- a/src/include/utils/memdebug.h +++ b/src/include/utils/memdebug.h @@ -19,6 +19,31 @@ #ifdef USE_VALGRIND #include <valgrind/memcheck.h> + +#elif __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) + +#include <sanitizer/asan_interface.h> + +#define VALGRIND_MAKE_MEM_DEFINED(addr, size) \ + ASAN_UNPOISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MAKE_MEM_NOACCESS(addr, size) \ + ASAN_POISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MAKE_MEM_UNDEFINED(addr, size) \ + ASAN_UNPOISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MEMPOOL_ALLOC(context, addr, size) \ + ASAN_UNPOISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MEMPOOL_FREE(context, addr) \ + ASAN_POISON_MEMORY_REGION(addr, 1 /* Length unknown, poison first byte. */) + +#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size) do {} while (0) +#define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed) do {} while (0) +#define VALGRIND_DESTROY_MEMPOOL(context) do {} while (0) +#define VALGRIND_MEMPOOL_CHANGE(context, optr, nptr, size) do {} while (0) + #else #define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size) do {} while (0) #define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed) do {} while (0) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/postgres-asan-instrumentation.patch�����������������������������������������0000664�0000000�0000000�00000003305�15100345067�0024103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 2c50575b37..11b6c688c7 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -3492,6 +4476,12 @@ check_stack_depth(void) bool stack_is_too_deep(void) { + /* + * Pointer arithmetics to determine stack depth doesn't work under + * AddressSanitizer. + */ + return false; + char stack_top_loc; long stack_depth; diff --git a/src/include/utils/memdebug.h b/src/include/utils/memdebug.h index e88b4c6e8e..4ccbbf0146 100644 --- a/src/include/utils/memdebug.h +++ b/src/include/utils/memdebug.h @@ -19,6 +19,31 @@ #ifdef USE_VALGRIND #include <valgrind/memcheck.h> + +#elif __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) + +#include <sanitizer/asan_interface.h> + +#define VALGRIND_MAKE_MEM_DEFINED(addr, size) \ + ASAN_UNPOISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MAKE_MEM_NOACCESS(addr, size) \ + ASAN_POISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MAKE_MEM_UNDEFINED(addr, size) \ + ASAN_UNPOISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MEMPOOL_ALLOC(context, addr, size) \ + ASAN_UNPOISON_MEMORY_REGION(addr, size) + +#define VALGRIND_MEMPOOL_FREE(context, addr) \ + ASAN_POISON_MEMORY_REGION(addr, 1 /* Length unknown, poison first byte. */) + +#define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size) do {} while (0) +#define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed) do {} while (0) +#define VALGRIND_DESTROY_MEMPOOL(context) do {} while (0) +#define VALGRIND_MEMPOOL_CHANGE(context, optr, nptr, size) do {} while (0) + #else #define VALGRIND_CHECK_MEM_IS_DEFINED(addr, size) do {} while (0) #define VALGRIND_CREATE_MEMPOOL(context, redzones, zeroed) do {} while (0) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/postgresql.conf.in����������������������������������������������������������0000664�0000000�0000000�00000001574�15100345067�0020520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# NOTE: any changes here require changes to tsl/test/postgresql.conf. Its prefix # must be the same as this file. autovacuum=true datestyle='Postgres, MDY' hba_file='@TEST_PG_HBA_FILE@' log_destination='jsonlog,stderr' log_directory='@TEST_PG_LOG_DIRECTORY@' log_filename='postmaster.log' log_line_prefix='%m: %u [%p] %d ' logging_collector=true max_worker_processes=24 random_page_cost=1.0 shared_preload_libraries=timescaledb timescaledb.last_tuned='1971-02-03 04:05:06.789012 -0300' timescaledb.last_tuned_version='0.0.1' timescaledb.passfile='@TEST_PASSFILE@' timescaledb_telemetry.cloud='ci' timezone='US/Pacific' # Set extra_float_digits=0 to retain the pre PG12 rounding behaviour # of floating point numbers, which are needed to make our tests work. extra_float_digits=0 @TELEMETRY_DEFAULT_SETTING@ timescaledb.license='apache' timescaledb.enable_compression_ratio_warnings=false ������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/runner.sh�������������������������������������������������������������������0000775�0000000�0000000�00000014567�15100345067�0016717�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash set -u set -e CURRENT_DIR=$(dirname $0) EXE_DIR=${EXE_DIR:-${CURRENT_DIR}} PG_REGRESS_PSQL=$1 PSQL=${PSQL:-$PG_REGRESS_PSQL} PSQL="${PSQL} -X" # Prevent any .psqlrc files from being executed during the tests TEST_PGUSER=${TEST_PGUSER:-postgres} TEST_INPUT_DIR=${TEST_INPUT_DIR:-${EXE_DIR}} TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR:-${EXE_DIR}} TEST_SUPPORT_FILE=${CURRENT_DIR}/sql/utils/testsupport.sql TEST_SUPPORT_FILE_INIT=${CURRENT_DIR}/sql/utils/testsupport_init.sql # PGAPPNAME will be 'pg_regress/test' so we cut off the prefix # to get the name of the test CURRENT_TEST=${PGAPPNAME##pg_regress/} # Since different PG version tests cannot run in parallel in the same instance, # we remove the trailing version suffix to get a good symbol that can be # used as identifier as well. TEST_DBNAME="db_${CURRENT_TEST%%-[0-9][0-9]}" # Read the extension version from version.config read -r VERSION < ${CURRENT_DIR}/../version.config EXT_VERSION=${VERSION##version = } #docker doesn't set user USER=${USER:-$(whoami)} TEST_SPINWAIT_ITERS=${TEST_SPINWAIT_ITERS:-1000} TEST_ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER:-super_user} TEST_ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER:-default_perm_user} TEST_ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2:-default_perm_user_2} # Users for clustering. These users have password auth enabled in pg_hba.conf TEST_ROLE_CLUSTER_SUPERUSER=${TEST_ROLE_CLUSTER_SUPERUSER:-cluster_superuser} TEST_ROLE_1=${TEST_ROLE_1:-test_role_1} TEST_ROLE_2=${TEST_ROLE_2:-test_role_2} TEST_ROLE_2_PASS=${TEST_ROLE_2_PASS:-pass} TEST_ROLE_3=${TEST_ROLE_3:-test_role_3} TEST_ROLE_3_PASS=${TEST_ROLE_3_PASS:-pass} TEST_ROLE_4=${TEST_ROLE_4:-test_role_4} TEST_ROLE_4_PASS=${TEST_ROLE_4_PASS:-pass} TEST_ROLE_READ_ONLY=${TEST_ROLE_READ_ONLY:-test_role_read_only} shift # Drop test database and make it less verbose in case of dropping a # distributed database. function cleanup { cat <<EOF | ${PSQL} "$@" -U $TEST_ROLE_SUPERUSER -d postgres -v ECHO=none >/dev/null 2>&1 SET client_min_messages=ERROR; DROP DATABASE "${TEST_DBNAME}"; EOF } trap cleanup EXIT # setup clusterwide settings on first run # we use mkdir here because it is an atomic operation unlike existence of a lockfile # where creating and checking are 2 separate operations if mkdir ${TEST_OUTPUT_DIR}/.pg_init 2>/dev/null; then ${PSQL} "$@" -U ${USER} -d template1 -v ECHO=none >/dev/null 2>&1 <<EOF SET client_min_messages=ERROR; DO \$\$ BEGIN IF current_setting('server_version_num')::int >= 150000 THEN GRANT CREATE ON SCHEMA public TO ${TEST_PGUSER}; GRANT CREATE ON SCHEMA public TO ${TEST_ROLE_DEFAULT_PERM_USER}; GRANT CREATE ON SCHEMA public TO ${TEST_ROLE_DEFAULT_PERM_USER_2}; GRANT CREATE ON SCHEMA public TO ${TEST_ROLE_1}; GRANT CREATE ON SCHEMA public TO ${TEST_ROLE_2}; GRANT CREATE ON SCHEMA public TO ${TEST_ROLE_3}; GRANT CREATE ON SCHEMA public TO ${TEST_ROLE_4}; END IF; END \$\$ LANGUAGE PLPGSQL; ALTER USER ${TEST_ROLE_SUPERUSER} WITH SUPERUSER; ALTER USER ${TEST_ROLE_CLUSTER_SUPERUSER} WITH SUPERUSER; ALTER USER ${TEST_ROLE_1} WITH CREATEDB CREATEROLE; ALTER USER ${TEST_ROLE_2} WITH CREATEDB PASSWORD '${TEST_ROLE_2_PASS}'; ALTER USER ${TEST_ROLE_3} WITH CREATEDB PASSWORD '${TEST_ROLE_3_PASS}'; ALTER USER ${TEST_ROLE_4} WITH CREATEDB PASSWORD '${TEST_ROLE_4_PASS}'; EOF ${PSQL} "$@" -U $TEST_ROLE_SUPERUSER -d template1 \ -v ECHO=none \ -v MODULE_PATHNAME="'timescaledb-${EXT_VERSION}'" \ -v TSL_MODULE_PATHNAME="'timescaledb-tsl-${EXT_VERSION}'" \ -v TEST_SPINWAIT_ITERS=${TEST_SPINWAIT_ITERS} \ -f ${TEST_SUPPORT_FILE} >/dev/null 2>&1 ${PSQL} "$@" -U ${USER} -d postgres -v ECHO=none -c "ALTER USER ${TEST_ROLE_SUPERUSER} WITH SUPERUSER;" >/dev/null touch ${TEST_OUTPUT_DIR}/.pg_init/done fi # we need to wait for cluster setup to finish cause with parallel schedule # multiple instances will be running and mkdir will only succeed on the first runner while [ ! -f ${TEST_OUTPUT_DIR}/.pg_init/done ]; do sleep 0.2; done cd ${EXE_DIR}/sql # create database and install timescaledb ${PSQL} "$@" -U $TEST_ROLE_SUPERUSER -d postgres -v ECHO=none -c "CREATE DATABASE \"${TEST_DBNAME}\";" ${PSQL} "$@" -U $TEST_ROLE_SUPERUSER -d ${TEST_DBNAME} -v ECHO=none -c "SET client_min_messages=error; CREATE EXTENSION timescaledb;" ${PSQL} "$@" -U $TEST_ROLE_SUPERUSER -d ${TEST_DBNAME} \ -v ECHO=none \ -v MODULE_PATHNAME="'timescaledb-${EXT_VERSION}'" \ -v TSL_MODULE_PATHNAME="'timescaledb-tsl-${EXT_VERSION}'" \ -v TEST_SPINWAIT_ITERS=${TEST_SPINWAIT_ITERS} \ -f ${TEST_SUPPORT_FILE_INIT} >/dev/null 2>&1 export TEST_DBNAME # we strip out any output between <exclude_from_test></exclude_from_test> # and the part about memory usage in EXPLAIN ANALYZE output of Sort nodes # also ignore the Postgres rehashing catalog debug messages from 'src/backend/utils/cache/catcache.c' ${PSQL} -U ${TEST_PGUSER} \ -v ON_ERROR_STOP=1 \ -v VERBOSITY=terse \ -v ECHO=all \ -v TEST_DBNAME="${TEST_DBNAME}" \ -v TEST_TABLESPACE1_PREFIX=${TEST_TABLESPACE1_PREFIX} \ -v TEST_TABLESPACE2_PREFIX=${TEST_TABLESPACE2_PREFIX} \ -v TEST_TABLESPACE3_PREFIX=${TEST_TABLESPACE3_PREFIX} \ -v TEST_TABLESPACE1_PATH=\'${TEST_TABLESPACE1_PATH}\' \ -v TEST_TABLESPACE2_PATH=\'${TEST_TABLESPACE2_PATH}\' \ -v TEST_TABLESPACE3_PATH=\'${TEST_TABLESPACE3_PATH}\' \ -v TEST_INPUT_DIR=${TEST_INPUT_DIR} \ -v TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR} \ -v TEST_SPINWAIT_ITERS=${TEST_SPINWAIT_ITERS} \ -v ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER} \ -v ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER} \ -v ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2} \ -v ROLE_CLUSTER_SUPERUSER=${TEST_ROLE_CLUSTER_SUPERUSER} \ -v ROLE_1=${TEST_ROLE_1} \ -v ROLE_2=${TEST_ROLE_2} \ -v ROLE_3=${TEST_ROLE_3} \ -v ROLE_4=${TEST_ROLE_4} \ -v ROLE_READ_ONLY=${TEST_ROLE_READ_ONLY} \ -v ROLE_2_PASS=${TEST_ROLE_2_PASS} \ -v ROLE_3_PASS=${TEST_ROLE_3_PASS} \ -v ROLE_4_PASS=${TEST_ROLE_4_PASS} \ -v MODULE_PATHNAME="'timescaledb-${EXT_VERSION}'" \ -v TSL_MODULE_PATHNAME="'timescaledb-tsl-${EXT_VERSION}'" \ -v TEST_SUPPORT_FILE=${TEST_SUPPORT_FILE} \ -v TEST_SUPPORT_FILE_INIT=${TEST_SUPPORT_FILE_INIT} \ "$@" -d ${TEST_DBNAME} 2>&1 | ${CURRENT_DIR}/runner_cleanup_output.sh �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/runner_cleanup_output.sh����������������������������������������������������0000775�0000000�0000000�00000003146�15100345067�0022035�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash set -u set -e RUNNER=${1:-""} sed -E -e '/<exclude_from_test>/,/<\/exclude_from_test>/d' \ -e 's! Disk: [0-9]+kB!!' \ -e 's! Memory: [0-9]+kB!!' \ -e 's! Memory Usage: [0-9]+kB!!' \ -e 's! Average Peak Memory: [0-9]+kB!!' \ -e 's!ERROR: permission denied for materialized view!ERROR: permission denied for view!' \ -e 's/(actual rows=[0-9]+) /\1.00 /' \ -e '/^ ?\([0-9]+ row[s]?\)$/d' \ -e '/ +QUERY PLAN +/{N;s/ +QUERY PLAN +\n-+/--- QUERY PLAN ---/;}' \ -e '/Disabled: true/d' \ -e '/Heap Fetches: [0-9]+/d' \ -e '/Buckets: [0-9]\+/d' \ -e '/Index Searches: [0-9]+/d' \ -e '/Storage: Memory Maximum Storage: [0-9]+kB/d' \ -e '/Window: /d' \ -e '/Batches: [0-9]+/d' \ -e '/found [0-9]+ removable, [0-9]+ nonremovable row versions in [0-9]+ pages/d' | \ grep -av 'DEBUG: rehashing catalog cache id' | \ grep -av 'DEBUG: compacted fsync request queue from' | \ grep -av 'DEBUG: creating and filling new WAL file' | \ grep -av 'DEBUG: done creating and filling new WAL file' | \ grep -av 'DEBUG: flushed relation because a checkpoint occurred concurrently' | \ grep -av 'NOTICE: cancelling the background worker for job' | \ if [ "${RUNNER}" = "shared" ]; then \ sed -e 's!_[0-9]\{1,\}_[0-9]\{1,\}_chunk!_X_X_chunk!g'; \ else \ cat; \ fi | \ if [ "${RUNNER}" = "isolation" ]; then \ sed -e 's!_[0-9]\{1,\}_[0-9]\{1,\}_chunk!_X_X_chunk!g' \ -e 's!hypertable_[0-9]\{1,\}!hypertable_X!g' \ -e 's!constraint_[0-9]\{1,\}!constraint_X!g' \ -e 's!with OID [0-9]\{1,\}!with OID X!g'; \ else \ cat; \ fi ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/runner_isolation.sh���������������������������������������������������������0000775�0000000�0000000�00000001610�15100345067�0020761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash # # Wrapper for the PostgreSQL isolationtest runner. It replaces # the chunks IDs in the output of the tests by _X_X_. So, even # if the IDs change, the tests will not fail. ############################################################## set -e set -u CURRENT_DIR=$(dirname $0) ISOLATIONTEST=$1 shift # Note that removing the chunk numbers is not enough. The chunk numbers also # influence the alignment of the EXPLAIN output, so not only we have to replace # them, we also have to remove the "----"s and the trailing spaces. The aligned # output format in isolation tester is hardcoded, we cannot change it. Moreover, # the chunk numbers influence the names of indexes if they are long enough to be # truncated, so the only way to get a stable explain output is to run such a test # in a separate database. $ISOLATIONTEST "$@" | ${CURRENT_DIR}/runner_cleanup_output.sh "isolation" ������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/runner_shared.sh������������������������������������������������������������0000775�0000000�0000000�00000006627�15100345067�0020243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env bash set -u set -e CURRENT_DIR=$(dirname $0) EXE_DIR=${EXE_DIR:-${CURRENT_DIR}} PG_REGRESS_PSQL=$1 PSQL=${PSQL:-$PG_REGRESS_PSQL} PSQL="${PSQL} -X" # Prevent any .psqlrc files from being executed during the tests TEST_PGUSER=${TEST_PGUSER:-postgres} TEST_INPUT_DIR=${TEST_INPUT_DIR:-${EXE_DIR}} TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR:-${EXE_DIR}} TEST_SUPPORT_FILE=${CURRENT_DIR}/sql/utils/testsupport.sql TEST_SUPPORT_FILE_INIT=${CURRENT_DIR}/sql/utils/testsupport_init.sql # Read the extension version from version.config read -r VERSION < ${CURRENT_DIR}/../version.config EXT_VERSION=${VERSION##version = } # PGAPPNAME will be 'pg_regress/test' so we cut off the prefix # to get the name of the test TEST_BASE_NAME=${PGAPPNAME##pg_regress/} # if this is a versioned test our name will have version as suffix # so we cut off suffix to get base name if [[ ${TEST_BASE_NAME} == *-1[0-9] ]]; then TEST_BASE_NAME=${TEST_BASE_NAME%???} fi #docker doesn't set user USER=${USER:-$(whoami)} TEST_ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER:-super_user} TEST_ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER:-default_perm_user} TEST_ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2:-default_perm_user_2} shift # setup clusterwide settings on first run # we use mkdir here because it is an atomic operation unlike existence of a lockfile # where creating and checking are 2 separate operations if mkdir ${TEST_OUTPUT_DIR}/.pg_init 2>/dev/null; then ${PSQL} "$@" -U ${USER} -d postgres -v ECHO=none -c "ALTER USER ${TEST_ROLE_SUPERUSER} WITH SUPERUSER;" >/dev/null ${PSQL} -U ${USER} \ -v MODULE_PATHNAME="'timescaledb-${EXT_VERSION}'" \ -v ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER} \ -v ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2} \ -v ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER} \ -v TEST_BASE_NAME=${TEST_BASE_NAME} \ -v TEST_DBNAME="${TEST_DBNAME}" \ -v TEST_INPUT_DIR=${TEST_INPUT_DIR} \ -v TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR} \ -v TEST_SUPPORT_FILE=${TEST_SUPPORT_FILE} \ -v TEST_SUPPORT_FILE_INIT=${TEST_SUPPORT_FILE_INIT} \ -v TSL_MODULE_PATHNAME="'timescaledb-tsl-${EXT_VERSION}'" \ "$@" -d ${TEST_DBNAME} < ${TEST_INPUT_DIR}/shared/sql/include/shared_setup.sql >/dev/null touch ${TEST_OUTPUT_DIR}/.pg_init/done fi # we need to wait for cluster setup to finish cause with parallel schedule # multiple instances will be running and mkdir will only succeed on the first runner while [ ! -f ${TEST_OUTPUT_DIR}/.pg_init/done ]; do sleep 0.2; done cd ${EXE_DIR}/sql # we strip out any output between <exclude_from_test></exclude_from_test> # and the part about memory usage in EXPLAIN ANALYZE output of Sort nodes # also ignore the Postgres rehashing catalog debug messages from 'src/backend/utils/cache/catcache.c' ${PSQL} -U ${TEST_PGUSER} \ -v ON_ERROR_STOP=1 \ -v VERBOSITY=terse \ -v ECHO=all \ -v TEST_DBNAME="${TEST_DBNAME}" \ -v TEST_BASE_NAME=${TEST_BASE_NAME} \ -v TEST_INPUT_DIR=${TEST_INPUT_DIR} \ -v TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR} \ -v ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER} \ -v ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER} \ -v ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2} \ -v MODULE_PATHNAME="'timescaledb-${EXT_VERSION}'" \ -v TSL_MODULE_PATHNAME="'timescaledb-tsl-${EXT_VERSION}'" \ "$@" -d ${TEST_DBNAME} 2>&1 | ${CURRENT_DIR}/runner_cleanup_output.sh "shared" ���������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015631�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/.gitignore��������������������������������������������������������������0000664�0000000�0000000�00000000702�15100345067�0017620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/agg_bookends-*.sql /alternate_users-*.sql /append-*.sql /cluster-*.sql /drop_owned-*.sql /grant_hypertable-*.sql /histogram_test-*.sql /insert-*.sql /insert_many-*.sql /null_exclusion-*.sql /parallel-*.sql /partitioning-*.sql /partitionwise-*.sql /plan_expand_hypertable-*.sql /plan_hashagg-*.sql /plan_hashagg_optimized-*.sql /plan_hypertable_cache-*.sql /plan_ordered_append-*.sql /rowsecurity-*.sql /timestamp-*.sql /ts_merge-*.sql /loader-*.sql ��������������������������������������������������������������timescaledb-2.23.0/test/sql/CMakeLists.txt����������������������������������������������������������0000664�0000000�0000000�00000010377�15100345067�0020401�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������include(GenerateTestSchedule) set(TEST_FILES alter.sql alternate_users.sql baserel_cache.sql catalog_corruption.sql chunks.sql chunk_adaptive.sql chunk_utils.sql cluster.sql create_chunks.sql create_hypertable.sql create_table.sql create_table_with.sql constraint.sql copy.sql copy_where.sql cursor.sql ddl.sql ddl_errors.sql ddl_extra.sql debug_utils.sql delete.sql drop_extension.sql drop_hypertable.sql drop_rename_hypertable.sql drop_schema.sql dump_meta.sql extension_scripts.sql generated_as_identity.sql hash.sql index.sql information_views.sql insert_many.sql insert_single.sql insert_returning.sql lateral.sql merge.sql partition.sql partitioning.sql pg_join.sql plain.sql plan_hypertable_inline.sql query.sql relocate_extension.sql reloptions.sql repair.sql size_utils.sql sort_optimization.sql sql_query.sql tableam.sql tableam_alter.sql tablespace.sql triggers.sql truncate.sql trusted_extension.sql update.sql upsert.sql util.sql uuid.sql vacuum.sql vacuum_parallel.sql version.sql license.sql) set(TEST_TEMPLATES agg_bookends.sql.in append.sql.in drop_owned.sql.in grant_hypertable.sql.in histogram_test.sql.in insert.sql.in null_exclusion.sql.in plan_hashagg.sql.in rowsecurity.sql.in parallel.sql.in partitionwise.sql.in plan_expand_hypertable.sql.in plan_ordered_append.sql.in timestamp.sql.in ts_merge.sql.in) # Loader test must distinguish between Apache and TSL builds so we parametrize # this here set(LOADER_TEST_FILE loader-${TEST_LICENSE_SUFFIX}) configure_file(loader.sql.in ${CMAKE_CURRENT_SOURCE_DIR}/${LOADER_TEST_FILE}.sql) # tests that fail or are unreliable when run in parallel bgw tests need to run # first otherwise they are flaky set(SOLO_TESTS alter alternate_users bgw_launcher chunk_utils index pg_dump_unprivileged tablespace telemetry net) list(APPEND SOLO_TESTS ${LOADER_TEST_FILE}) if(CMAKE_BUILD_TYPE MATCHES Debug) list( APPEND TEST_FILES bgw_launcher.sql c_unit_tests.sql copy_memory_usage.sql metadata.sql multi_transaction_index.sql net.sql pg_dump.sql symbol_conflict.sql test_tss_callbacks.sql test_utils.sql ${LOADER_TEST_FILE}.sql) if(USE_TELEMETRY) list(APPEND TEST_FILES telemetry.sql) endif() endif(CMAKE_BUILD_TYPE MATCHES Debug) if((${PG_VERSION_MAJOR} GREATER_EQUAL "17")) list(APPEND TEST_FILES tableam_alter_defaults.sql) endif() # pg_dump_unprivileged.sql was fixed by an upstream change to pg_dump in 15.6, # and 16.2 if(((${PG_VERSION_MAJOR} EQUAL "15") AND (${PG_VERSION_MINOR} GREATER_EQUAL "6") ) OR ((${PG_VERSION_MAJOR} EQUAL "16") AND (${PG_VERSION_MINOR} GREATER_EQUAL "2"))) list(APPEND TEST_FILES pg_dump_unprivileged.sql) endif() # only test custom type if we are in 64-bit architecture if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "8") list(APPEND TEST_FILES custom_type.sql) endif() # Regression tests that vary with PostgreSQL version. Generated test files are # put in the original source directory since all tests must be in the same # directory. These files are updated when the template is edited, but not when # the output file is deleted. If the output is deleted either recreate it # manually, or rerun cmake on the root dir. foreach(TEMPLATE_FILE ${TEST_TEMPLATES}) string(LENGTH ${TEMPLATE_FILE} TEMPLATE_NAME_LEN) math(EXPR TEMPLATE_NAME_LEN ${TEMPLATE_NAME_LEN}-7) string(SUBSTRING ${TEMPLATE_FILE} 0 ${TEMPLATE_NAME_LEN} TEMPLATE) set(TEST_FILE ${TEMPLATE}-${TEST_VERSION_SUFFIX}.sql) configure_file(${TEMPLATE_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/${TEST_FILE} @ONLY) list(APPEND TEST_FILES ${TEST_FILE}) endforeach(TEMPLATE_FILE) if(NOT TEST_GROUP_SIZE) set(PARALLEL_GROUP_SIZE 20) else() set(PARALLEL_GROUP_SIZE ${TEST_GROUP_SIZE}) endif() # Generate a test schedule for each configuration. generate_test_schedule( ${TEST_SCHEDULE} TEST_FILES ${TEST_FILES} SOLO ${SOLO_TESTS} GROUP_SIZE ${PARALLEL_GROUP_SIZE}) add_subdirectory(loader) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/agg_bookends.sql.in�����������������������������������������������������0000664�0000000�0000000�00000006510�15100345067�0021403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME agg_bookends SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME \ir :TEST_QUERY_NAME -- we want test results as part of the output too to make sure we produce correct output \set PREFIX '' \ir :TEST_QUERY_NAME -- diff results with optimizations disabled and enabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME \o :DIFF_CMD -- Test partial aggregation CREATE TABLE partial_aggregation (time timestamptz NOT NULL, quantity numeric, longvalue text); SELECT schema_name, table_name, created FROM create_hypertable('partial_aggregation', 'time'); INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2018-01-20T09:00:43', NULL, NULL); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 1, 'hello'); INSERT INTO partial_aggregation VALUES('2019-01-20T09:00:43', 2, 'world'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2020-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'some'); INSERT INTO partial_aggregation VALUES('2021-01-20T09:00:43', 3, 'more'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 4, 'words'); INSERT INTO partial_aggregation VALUES('2022-01-20T09:00:43', 5, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 6, 'words'); INSERT INTO partial_aggregation VALUES('2023-01-20T09:00:43', 7, 'words'); -- Use enable_partitionwise_aggregate to create partial aggregates per chunk SET enable_partitionwise_aggregate = ON; SELECT format('SELECT %3$s, %1$s FROM partial_aggregation WHERE %2$s GROUP BY %3$s ORDER BY 1, 2;', function, condition, grouping) FROM unnest(array[ 'first(time, quantity), last(time, quantity)', 'last(longvalue, quantity)', 'last(quantity, longvalue)', 'last(quantity, time)', 'last(time, longvalue)']) AS function, unnest(array[ 'true', $$time < '2021-01-01'$$, 'quantity is null', 'quantity is not null', 'quantity > 3']) AS condition, unnest(array[ '777::text' /* dummy grouping column */, 'longvalue', 'quantity', $$time_bucket('1 year', time)$$, $$time_bucket('3 year', time)$$]) AS grouping \gexec SET enable_partitionwise_aggregate = OFF; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/alter.sql���������������������������������������������������������������0000664�0000000�0000000�00000052022�15100345067�0017462�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH 'include/query_result_test_equal.sql' -- DROP a table's column before making it a hypertable CREATE TABLE alter_before(id serial, time timestamp, temp float, colorid integer, notes text, notes_2 text); ALTER TABLE alter_before DROP COLUMN id; ALTER TABLE alter_before ALTER COLUMN temp SET (n_distinct = 10); ALTER TABLE alter_before ALTER COLUMN colorid SET (n_distinct = 11); ALTER TABLE alter_before ALTER COLUMN colorid RESET (n_distinct); ALTER TABLE alter_before ALTER COLUMN temp SET STATISTICS 100; ALTER TABLE alter_before ALTER COLUMN notes SET STORAGE EXTERNAL; SELECT create_hypertable('alter_before', 'time', chunk_time_interval => 2628000000000); -- Test error hint for invalid timescaledb options on ALTER TABLE \set ON_ERROR_STOP 0 -- Invalid timescaledb option should show hint with valid options \set VERBOSITY default ALTER TABLE alter_before SET (tsdb.invalid_option = true); ALTER TABLE alter_before SET (timescaledb.nonexistent = false); \set ON_ERROR_STOP 1 \set VERBOSITY terse INSERT INTO alter_before VALUES ('2017-03-22T09:18:22', 23.5, 1); SELECT * FROM alter_before; -- Show that deleted column is marked as dropped and that attnums are -- now different for the root table and the chunk -- PG17 made attstattarget NULLABLE and changed the default from -1 to NULL SELECT c.relname, a.attname, a.attnum, a.attoptions, CASE WHEN a.attstattarget = -1 OR (a.attisdropped AND a.attstattarget = 0) THEN NULL ELSE a.attstattarget END attstattarget, a.attstorage FROM pg_attribute a, pg_class c WHERE a.attrelid = c.oid AND (c.relname LIKE '_hyper_1%_chunk' OR c.relname = 'alter_before') AND a.attnum > 0 ORDER BY c.relname, a.attnum; -- DROP a table's column after making it a hypertable and having data CREATE TABLE alter_after(id serial, time timestamp, temp float, colorid integer, notes text, notes_2 text); SELECT create_hypertable('alter_after', 'time', chunk_time_interval => 2628000000000); -- Create first chunk INSERT INTO alter_after (time, temp, colorid) VALUES ('2017-03-22T09:18:22', 23.5, 1); ALTER TABLE alter_after DROP COLUMN id; ALTER TABLE alter_after ALTER COLUMN temp SET (n_distinct = 10); ALTER TABLE alter_after ALTER COLUMN colorid SET (n_distinct = 11); ALTER TABLE alter_after ALTER COLUMN colorid RESET (n_distinct); ALTER TABLE alter_after ALTER COLUMN colorid SET STATISTICS 101; ALTER TABLE alter_after ALTER COLUMN notes_2 SET STORAGE EXTERNAL; -- Creating new chunks after dropping a column should work just fine INSERT INTO alter_after VALUES ('2017-03-22T09:18:23', 21.5, 1), ('2017-05-22T09:18:22', 36.2, 2), ('2017-05-22T09:18:23', 15.2, 2); -- Make sure tuple conversion also works with COPY \COPY alter_after FROM 'data/alter.tsv' NULL AS ''; -- Data should look OK SELECT * FROM alter_after; -- Show that attnums are different for chunks created after DROP -- column SELECT c.relname, a.attname, a.attnum FROM pg_attribute a, pg_class c WHERE a.attrelid = c.oid AND (c.relname LIKE '_hyper_2%_chunk' OR c.relname = 'alter_after') AND a.attnum > 0 ORDER BY c.relname, a.attnum; -- Add an ID column again ALTER TABLE alter_after ADD COLUMN id serial; INSERT INTO alter_after (time, temp, colorid) VALUES ('2017-08-22T09:19:14', 12.5, 3); --test thing that we are allowed to do on chunks ALTER TABLE _timescaledb_internal._hyper_2_3_chunk ALTER COLUMN temp RESET (n_distinct); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk ALTER COLUMN temp SET (n_distinct = 20); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk ALTER COLUMN temp SET STATISTICS 201; ALTER TABLE _timescaledb_internal._hyper_2_4_chunk ALTER COLUMN notes SET STORAGE EXTERNAL; -- PG17 made attstattarget NULLABLE and changed the default from -1 to NULL SELECT c.relname, a.attname, a.attnum, a.attoptions, CASE WHEN a.attstattarget = -1 OR (a.attisdropped AND a.attstattarget = 0) THEN NULL ELSE a.attstattarget END attstattarget, a.attstorage FROM pg_attribute a, pg_class c WHERE a.attrelid = c.oid AND (c.relname LIKE '_hyper_2%_chunk' OR c.relname = 'alter_after') AND a.attnum > 0 ORDER BY c.relname, a.attnum; SELECT * FROM alter_after; -- test setting reloptions ALTER TABLE _timescaledb_internal._hyper_2_3_chunk SET (parallel_workers=2); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk SET (parallel_workers=4); ALTER TABLE _timescaledb_internal._hyper_2_4_chunk RESET (parallel_workers); SELECT relname, reloptions FROM pg_class WHERE relname IN ('_hyper_2_3_chunk','_hyper_2_4_chunk'); -- Need superuser to ALTER chunks in _timescaledb_internal schema \c :TEST_DBNAME :ROLE_SUPERUSER SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE id = 2; -- Rename chunk ALTER TABLE _timescaledb_internal._hyper_2_2_chunk RENAME TO new_chunk_name; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE id = 2; -- Set schema ALTER TABLE _timescaledb_internal.new_chunk_name SET SCHEMA public; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE id = 2; -- Test that we cannot rename chunk columns \set ON_ERROR_STOP 0 ALTER TABLE public.new_chunk_name RENAME COLUMN time TO newtime; \set ON_ERROR_STOP 1 -- Test that we can set tablespace of a hypertable \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; SET client_min_messages = NOTICE; --test hypertable with tables space CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Test that we can directly change chunk tablespace ALTER TABLE public.new_chunk_name SET TABLESPACE tablespace1; SELECT tablespace FROM pg_tables WHERE tablename = 'new_chunk_name'; -- drop all tables to make checking the tests below easier DROP TABLE alter_before; DROP TABLE alter_after; -- should return 0 rows SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename LIKE '\_hyper\__\__\_chunk' ORDER BY tablename; CREATE TABLE hyper_in_space(time bigint, temp float, device int); SELECT create_hypertable('hyper_in_space', 'time', 'device', 4, chunk_time_interval=>1); INSERT INTO hyper_in_space(time, temp, device) VALUES (1, 20, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (3, 21, 2); INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 23, 1); SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1' ORDER BY tablename; SET default_tablespace = tablespace1; -- should be inserted in tablespace1 which is now default INSERT INTO hyper_in_space(time, temp, device) VALUES (11, 24, 3); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename LIKE '\_hyper\__\__\_chunk' ORDER BY tablename; SET default_tablespace TO DEFAULT; ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1' ORDER BY tablename; -- should be inserted in an existing chunk in the new tablespace, -- no new chunks INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 27, 1); -- the new chunk should be create in the new tablespace INSERT INTO hyper_in_space(time, temp, device) VALUES (8, 24, 2); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename LIKE '\_hyper\__\__\_chunk' ORDER BY tablename; -- should not fail (unlike attach_tablespace) ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; \set ON_ERROR_STOP 0 -- not an empty tablespace DROP TABLESPACE tablespace1; \set ON_ERROR_STOP 1 -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'hyper_in_space\', 22)::NAME' \set QUERY2 'SELECT drop_chunks(\'hyper_in_space\', 22)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT tablename, tablespace FROM pg_tables WHERE tablespace = 'tablespace1' ORDER BY tablename; \set ON_ERROR_STOP 0 -- should not be able to drop tablespace if a hypertable depends on it -- even when there are no chunks DROP TABLESPACE tablespace1; \set ON_ERROR_STOP 1 DROP TABLE hyper_in_space; CREATE TABLE hyper_in_space(time bigint, temp float, device int) TABLESPACE tablespace1; SELECT create_hypertable('hyper_in_space', 'time', 'device', 4, chunk_time_interval=>1); INSERT INTO hyper_in_space(time, temp, device) VALUES (1, 20, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (3, 21, 2); INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 23, 1); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; SELECT attach_tablespace('tablespace2', 'hyper_in_space'); \set ON_ERROR_STOP 0 -- should fail as >1 tablespaces are attached ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; \set ON_ERROR_STOP 1 SELECT detach_tablespace('tablespace2', 'hyper_in_space'); SELECT * FROM _timescaledb_catalog.tablespace; -- make sure when using ALTER TABLE, table spaces are not accumulated -- as in case of attach_tablespace -- should have one result SELECT * FROM _timescaledb_catalog.tablespace; ALTER TABLE hyper_in_space SET TABLESPACE tablespace2; -- should have one result SELECT * FROM _timescaledb_catalog.tablespace; ALTER TABLE hyper_in_space SET TABLESPACE tablespace1; -- should have one result, (same as the first in the block) SELECT * FROM _timescaledb_catalog.tablespace; SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; -- attach tb2 <-> ALTER SET tb1 <-> detach tb1 should work SELECT detach_tablespace('tablespace1', 'hyper_in_space'); INSERT INTO hyper_in_space(time, temp, device) VALUES (5, 23, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (7, 23, 1); -- Since we have detached tablespace1 the new chunk should not be -- placed there. SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; SELECT * FROM _timescaledb_catalog.tablespace; -- tablespace functions should handle the default tablespace just as they do others SELECT attach_tablespace('pg_default', 'hyper_in_space'); SELECT attach_tablespace('tablespace2', 'hyper_in_space'); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; SELECT * FROM _timescaledb_catalog.tablespace; INSERT INTO hyper_in_space(time, temp, device) VALUES (12, 22, 1); INSERT INTO hyper_in_space(time, temp, device) VALUES (13, 23, 3); SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; SELECT detach_tablespace('pg_default', 'hyper_in_space'); ALTER TABLE hyper_in_space SET TABLESPACE pg_default; SELECT tablename, tablespace FROM pg_tables WHERE tablename = 'hyper_in_space' OR tablename ~ '_hyper_\d+_\d+_chunk' ORDER BY tablename; SELECT detach_tablespace('pg_default', 'hyper_in_space'); DROP TABLE hyper_in_space; -- test altering tablespace on index, issue #903 CREATE TABLE series( time timestamptz not null, device int, value float, CONSTRAINT series_pk PRIMARY KEY (time, device) USING INDEX TABLESPACE tablespace1); SELECT create_hypertable('series', 'time', create_default_indexes => FALSE); INSERT INTO series VALUES ('2019-04-21 10:12', 1, 1.01); CREATE INDEX series_value ON series (value, time) TABLESPACE tablespace2; SELECT schemaname, tablename, indexname, tablespace FROM pg_indexes WHERE indexname LIKE '%series%' ORDER BY indexname; ALTER INDEX series_pk SET TABLESPACE tablespace2; CREATE INDEX ON series (time) TABLESPACE tablespace1; ALTER INDEX series_value SET TABLESPACE pg_default; INSERT INTO series VALUES ('2019-04-29 10:12', 2, 1.31); SELECT schemaname, tablename, indexname, tablespace FROM pg_indexes WHERE indexname LIKE '%series%' ORDER BY indexname; DROP TABLE series; DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Make sure we handle ALTER SCHEMA RENAME for hypertable schemas \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS original_name; CREATE TABLE original_name.my_table ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('original_name.my_table','date'); INSERT INTO original_name.my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA original_name RENAME TO new_name; DROP TABLE new_name.my_table; DROP SCHEMA new_name; -- Now make sure schema is renamed for multiple hypertables, but not hypertables not in the schema CREATE SCHEMA IF NOT EXISTS original_name; CREATE TABLE original_name.my_table ( date timestamp with time zone NOT NULL, quantity double precision ); CREATE TABLE original_name.my_table2 ( date timestamp with time zone NOT NULL, quantity double precision ); CREATE TABLE regular_table ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('original_name.my_table','date'); SELECT create_hypertable('original_name.my_table2','date'); SELECT create_hypertable('regular_table','date'); INSERT INTO original_name.my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); INSERT INTO original_name.my_table2 (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); INSERT INTO regular_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA original_name RENAME TO new_name; DROP TABLE new_name.my_table; DROP TABLE new_name.my_table2; DROP TABLE regular_table; DROP SCHEMA new_name; -- These tables should also drop when we drop the whole schema CREATE SCHEMA IF NOT EXISTS original_name; CREATE TABLE original_name.my_table ( date timestamp with time zone NOT NULL, quantity double precision ); CREATE TABLE original_name.my_table2 ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('original_name.my_table','date'); SELECT create_hypertable('original_name.my_table2','date'); INSERT INTO original_name.my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); INSERT INTO original_name.my_table2 (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA original_name RENAME TO new_name; DROP SCHEMA new_name CASCADE; SELECT * FROM test.relation WHERE schema = 'new_name'; -- Make sure we can't rename internal schemas \set ON_ERROR_STOP 0 ALTER SCHEMA _timescaledb_internal RENAME TO my_new_schema_name; ALTER SCHEMA _timescaledb_catalog RENAME TO my_new_schema_name; ALTER SCHEMA _timescaledb_cache RENAME TO my_new_schema_name; ALTER SCHEMA _timescaledb_config RENAME TO my_new_schema_name; \set ON_ERROR_STOP 1 -- Make sure we can rename associated schemas CREATE TABLE my_table ( date timestamp with time zone NOT NULL, quantity double precision ); SELECT create_hypertable('my_table','date', associated_schema_name => 'my_associated_schema'); INSERT INTO my_table (date, quantity) VALUES ('2018-07-04T21:00:00+00:00', 8); ALTER SCHEMA my_associated_schema RENAME TO new_associated_schema; INSERT INTO my_table (date, quantity) VALUES ('2018-08-10T23:00:00+00:00', 20); -- Make sure the schema name is changed in both catalog tables SELECT * from _timescaledb_catalog.hypertable; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk from _timescaledb_catalog.chunk; DROP TABLE my_table; -- test renaming unique constraints/indexes CREATE TABLE t_hypertable ( id INTEGER NOT NULL, time TIMESTAMPTZ NOT NULL, value FLOAT NOT NULL CHECK (value > 0), UNIQUE(id, time)); SELECT create_hypertable('t_hypertable', 'time'); INSERT INTO t_hypertable AS h VALUES ( 1, '2020-01-01 00:00:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; INSERT INTO t_hypertable AS h VALUES ( 1, '2021-01-01 00:00:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; BEGIN; ALTER INDEX t_hypertable_id_time_key RENAME TO t_new_constraint; -- chunk_constraint should have updated constraint names SELECT hypertable_constraint_name, constraint_name from _timescaledb_catalog.chunk_constraint WHERE hypertable_constraint_name = 't_new_constraint' ORDER BY 1,2; INSERT INTO t_hypertable AS h VALUES ( 1, '2020-01-01 00:01:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; ROLLBACK; BEGIN; ALTER TABLE t_hypertable RENAME CONSTRAINT t_hypertable_id_time_key TO t_new_constraint; -- chunk_constraint should have updated constraint names SELECT hypertable_constraint_name, constraint_name from _timescaledb_catalog.chunk_constraint WHERE hypertable_constraint_name = 't_new_constraint' ORDER BY 1,2; INSERT INTO t_hypertable AS h VALUES ( 1, '2020-01-01 00:01:00', 3.2) ON CONFLICT (id, time) DO UPDATE SET value = h.value + EXCLUDED.value; ROLLBACK; -- predicate reconstruction when attnos are different in hypertable and chunk CREATE TABLE p_hypertable (a integer not null, b integer, c integer); SELECT create_hypertable('p_hypertable', 'a', chunk_time_interval => int '3'); BEGIN; ALTER TABLE p_hypertable DROP COLUMN b, ADD COLUMN d boolean; CREATE INDEX idx_ht ON p_hypertable(a, c) WHERE d = FALSE; END; INSERT INTO p_hypertable(a, c, d) VALUES (1, 1, FALSE); \d _timescaledb_internal._hyper_14_28_chunk DROP TABLE p_hypertable; -- check none of our hooks interact badly with normal alter view handling CREATE VIEW v1 AS SELECT random(); \set ON_ERROR_STOP 0 -- should error with unrecognized parameter ALTER VIEW v1 SET (autovacuum_enabled = false); \set ON_ERROR_STOP 1 -- issue 4474 -- test hypertable with non-default statistics target -- and chunk creation triggered by non-owner CREATE ROLE role_4474; CREATE TABLE i4474(time timestamptz NOT NULL); SELECT table_name FROM public.create_hypertable( 'i4474', 'time'); GRANT SELECT, INSERT on i4474 TO role_4474; -- create chunk as owner INSERT INTO i4474 SELECT '2020-01-01'; -- set statistics ALTER TABLE i4474 ALTER COLUMN time SET statistics 10; -- create chunk as non-owner SET ROLE role_4474; INSERT INTO i4474 SELECT '2021-01-01'; RESET ROLE; DROP TABLE i4474 CASCADE; DROP ROLE role_4474; -- verify that setting replica identity works and chunks inherit the -- root table's setting CREATE TABLE replid(time timestamptz, value int); SELECT create_hypertable('replid', 'time', chunk_time_interval => interval '1 day', create_default_indexes => false); -- replica identity set to default SELECT relreplident FROM pg_class WHERE relname = 'replid'; INSERT INTO replid VALUES ('2023-01-01', 1); -- the new chunk should have the same replica identity setting SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; -- test change to replica identity full ALTER TABLE replid REPLICA IDENTITY FULL; SELECT relname, relreplident FROM pg_class WHERE relname = 'replid' ORDER BY relname; -- the chunk's setting should also change to FULL SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; -- change to replica identity index CREATE UNIQUE INDEX time_key ON replid (time); ALTER TABLE replid REPLICA IDENTITY USING INDEX time_key; SELECT relname, relreplident FROM pg_class WHERE relname = 'replid' ORDER BY relname; SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; SELECT indexrelid::regclass::text AS index_name FROM show_chunks('replid') chid INNER JOIN pg_index i ON (i.indrelid = chid) AND indisreplident=true ORDER BY index_name; INSERT INTO replid VALUES ('2023-01-02', 2); -- the new chunk will also have replica identity "index" SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; SELECT indexrelid::regclass::text AS index_name FROM show_chunks('replid') chid INNER JOIN pg_index i ON (i.indrelid = chid) AND indisreplident=true ORDER BY index_name; -- drop the replica identity index and create a new chunk. The new -- chunk should have replica identity "NOTHING" since this is the -- behavior of replica identity index when the index is dropped. DROP INDEX time_key; INSERT INTO replid VALUES ('2023-01-03', 3); -- no indexes left SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; SELECT indexrelid::regclass::text AS index_name FROM show_chunks('replid') chid INNER JOIN pg_index i ON (i.indrelid = chid) AND indisreplident=true ORDER BY index_name; -- Alter replica identity directly on a chunk is not supported SELECT ch AS chunk_name FROM show_chunks('replid') ch ORDER BY chunk_name LIMIT 1 \gset ALTER TABLE :chunk_name REPLICA IDENTITY FULL; SELECT relname, relreplident FROM show_chunks('replid') ch INNER JOIN pg_class c ON (ch = c.oid) ORDER BY relname; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/alternate_users.sql�����������������������������������������������������0000664�0000000�0000000�00000007224�15100345067�0021557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_single.sql \c :TEST_DBNAME :ROLE_SUPERUSER -- make sure tablespace1 exists -- since there is no CREATE TABLESPACE IF EXISTS we drop with if exists and recreate SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; --needed for ddl ops: CREATE SCHEMA IF NOT EXISTS "customSchema" AUTHORIZATION :ROLE_DEFAULT_PERM_USER_2; --needed for ROLE_DEFAULT_PERM_USER_2 to write to the 'one_Partition' schema which --is owned by ROLE_DEFAULT_PERM_USER GRANT CREATE ON SCHEMA "one_Partition" TO :ROLE_DEFAULT_PERM_USER_2; --test creating and using schema as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT * FROM test.relation WHERE schema='public' ORDER BY schema, name; \set ON_ERROR_STOP 0 SELECT * FROM "one_Partition"; SELECT set_chunk_time_interval('"one_Partition"', 1::bigint); select add_dimension('"one_Partition"', 'device_id', 2); select attach_tablespace('tablespace1', '"one_Partition"'); \set ON_ERROR_STOP 1 CREATE TABLE "1dim"(time timestamp, temp float); SELECT create_hypertable('"1dim"', 'time'); INSERT INTO "1dim" VALUES('2017-01-20T09:00:01', 22.5); INSERT INTO "1dim" VALUES('2017-01-20T09:00:21', 21.2); INSERT INTO "1dim" VALUES('2017-01-20T09:00:47', 25.1); SELECT * FROM "1dim"; \ir include/ddl_ops_1.sql \ir include/ddl_ops_2.sql --test proper denials for all security definer functions: \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE plain_table_su (time timestamp, temp float); CREATE TABLE hypertable_su (time timestamp, temp float); SELECT create_hypertable('hypertable_su', 'time'); CREATE INDEX "ind_1" ON hypertable_su (time); INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --all of the following should produce errors \set ON_ERROR_STOP 0 SELECT create_hypertable('plain_table_su', 'time'); CREATE INDEX ON plain_table_su (time, temp); CREATE INDEX ON hypertable_su (time, temp); DROP INDEX "ind_1"; ALTER INDEX "ind_1" RENAME TO "ind_2"; \set ON_ERROR_STOP 1 --test that I can't do anything to a non-owned hypertable. \set ON_ERROR_STOP 0 CREATE INDEX ON hypertable_su (time, temp); SELECT * FROM hypertable_su; INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); ALTER TABLE hypertable_su ADD COLUMN val2 integer; \set ON_ERROR_STOP 1 --grant read permissions \c :TEST_DBNAME :ROLE_SUPERUSER GRANT SELECT ON hypertable_su TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT * FROM hypertable_su; \set ON_ERROR_STOP 0 CREATE INDEX ON hypertable_su (time, temp); INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); ALTER TABLE hypertable_su ADD COLUMN val2 integer; \set ON_ERROR_STOP 1 --grant read, insert permissions \c :TEST_DBNAME :ROLE_SUPERUSER GRANT SELECT, INSERT ON hypertable_su TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); SELECT * FROM hypertable_su; \set ON_ERROR_STOP 0 CREATE INDEX ON hypertable_su (time, temp); ALTER TABLE hypertable_su ADD COLUMN val2 integer; \set ON_ERROR_STOP 1 --change owner \c :TEST_DBNAME :ROLE_SUPERUSER ALTER TABLE hypertable_su OWNER TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 INSERT INTO hypertable_su VALUES('2017-01-20T09:00:01', 22.5); SELECT * FROM hypertable_su; CREATE INDEX ON hypertable_su (time, temp); ALTER TABLE hypertable_su ADD COLUMN val2 integer; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/append.sql.in�����������������������������������������������������������0000664�0000000�0000000�00000003242�15100345067�0020227�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset SET timescaledb.enable_now_constify TO false; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- disable index only scans to avoid some flaky results SET enable_indexonlyscan TO FALSE; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \ir :TEST_LOAD_NAME \ir :TEST_QUERY_NAME --generate the results into two different files \set ECHO errors SET client_min_messages TO error; \set PREFIX '' -- get results with optimizations disabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME \o -- get query results with all optimizations \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME \o :DIFF_CMD -- get query results with constraint aware append \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_chunk_append TO false; \ir :TEST_QUERY_NAME \o :DIFF_CMD ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/baserel_cache.sql�������������������������������������������������������0000664�0000000�0000000�00000001416�15100345067�0021114�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that the baserel cache is not clobbered if there's an error -- in a SQL function. CREATE TABLE valid_ids ( id UUID PRIMARY KEY ); CREATE FUNCTION DEFAULT_UUID(TEXT DEFAULT '') RETURNS UUID AS $$ BEGIN RETURN COALESCE($1, '')::UUID; EXCEPTION WHEN invalid_text_representation THEN RETURN '00000000-0000-0000-0000-000000000000'; END; $$ LANGUAGE PLPGSQL IMMUTABLE; CREATE FUNCTION KNOWN_ID(UUID, TEXT) RETURNS UUID AS $$ SELECT COALESCE( (SELECT id FROM valid_ids WHERE id = $1), DEFAULT_UUID() ); $$ LANGUAGE SQL; SELECT KNOWN_ID(NULL, ''), KNOWN_ID(NULL, ''); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/bgw_launcher.sql��������������������������������������������������������0000664�0000000�0000000�00000023372�15100345067�0021021�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_2 :TEST_DBNAME _2 \c :TEST_DBNAME :ROLE_SUPERUSER -- start bgw since they are stopped for tests by default SELECT _timescaledb_functions.start_background_workers(); CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER \ir include/bgw_launcher_utils.sql -- When we've connected to test db 2, we should be able to see the cluster launcher -- and the scheduler for test db in pg_stat_activity -- but test db 2 shouldn't have a scheduler because ext not created yet SELECT wait_worker_counts(1,1,0,0); -- Now create the extension in test db 2 SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; SELECT wait_worker_counts(1,1,1,0); DROP DATABASE :TEST_DBNAME WITH (FORCE); -- Now the db_scheduler for test db should have disappeared SELECT wait_worker_counts(1,0,1,0); -- Now let's restart the scheduler in test db 2 and make sure our backend_start changed SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset -- We'll do this in a txn so that we can see that the worker locks on our txn before continuing BEGIN; SELECT _timescaledb_functions.restart_background_workers(); SELECT wait_worker_counts(1,0,1,0); SELECT (backend_start > :'orig_backend_start'::timestamptz) backend_start_changed, (wait_event = 'virtualxid') wait_event_changed FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2'; COMMIT; SELECT wait_worker_counts(1,0,1,0); SELECT (wait_event IS DISTINCT FROM 'virtualxid') wait_event_changed FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2'; -- Test stop SELECT _timescaledb_functions.stop_background_workers(); SELECT wait_worker_counts(1,0,0,0); -- Make sure it doesn't break if we stop twice in a row SELECT _timescaledb_functions.stop_background_workers(); SELECT wait_worker_counts(1,0,0,0); -- test start SELECT _timescaledb_functions.start_background_workers(); SELECT wait_worker_counts(1,0,1,0); -- make sure start is idempotent SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset -- Since we're doing idempotency tests, we're also going to exercise our queue and start 20 times SELECT _timescaledb_functions.start_background_workers() as start_background_workers, * FROM generate_series(1,20); -- Here we're waiting to see if something shows up in pg_stat_activity, -- so we have to condition our loop in the opposite way. We'll only wait -- half a second in total as well so that tests don't take too long. CREATE FUNCTION wait_equals(TIMESTAMPTZ, TEXT) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r BOOLEAN; BEGIN FOR i in 1..5 LOOP SELECT (backend_start = $1::timestamptz) backend_start_unchanged FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = $2 into r; if(r) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN FALSE; END IF; END LOOP; RETURN TRUE; END $BODY$; select wait_equals(:'orig_backend_start', :'TEST_DBNAME_2'); -- Make sure restart starts a worker even if it is stopped SELECT _timescaledb_functions.stop_background_workers(); SELECT wait_worker_counts(1,0,0,0); SELECT _timescaledb_functions.restart_background_workers(); SELECT wait_worker_counts(1,0,1,0); -- Make sure drop extension statement restarts the worker and on rollback it keeps running -- Now let's restart the scheduler and make sure our backend_start changed SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset BEGIN; DROP EXTENSION timescaledb; SELECT wait_worker_counts(1,0,1,0); ROLLBACK; CREATE FUNCTION wait_greater(TIMESTAMPTZ,TEXT) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r BOOLEAN; BEGIN FOR i in 1..10 LOOP SELECT (backend_start > $1::timestamptz) backend_start_changed FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = $2 into r; if(NOT r) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN TRUE; END IF; END LOOP; RETURN FALSE; END $BODY$; SELECT wait_greater(:'orig_backend_start',:'TEST_DBNAME_2'); -- Make sure canceling the launcher backend causes a restart of schedulers SELECT backend_start as orig_backend_start FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2' \gset SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Launcher'; SELECT wait_worker_counts(1,0,1,0); SELECT wait_greater(:'orig_backend_start', :'TEST_DBNAME_2'); -- Make sure running pre_restore function stops background workers SELECT timescaledb_pre_restore(); SELECT wait_worker_counts(1,0,0,0); -- Make sure a restart with restoring on first starts the background worker BEGIN; SELECT _timescaledb_functions.restart_background_workers(); SELECT wait_worker_counts(1,0,1,0); COMMIT; -- Then the worker dies when it sees that restoring is on after the txn commits SELECT wait_worker_counts(1,0,0,0); --And post_restore starts them BEGIN; SELECT timescaledb_post_restore(); SELECT wait_worker_counts(1,0,1,0); COMMIT; -- And they stay started SELECT wait_worker_counts(1,0,1,0); -- Make sure dropping the extension means that the scheduler is stopped BEGIN; DROP EXTENSION timescaledb; COMMIT; SELECT wait_worker_counts(1,0,0,0); -- Test that background workers are stopped with DROP OWNED ALTER ROLE :ROLE_DEFAULT_PERM_USER WITH SUPERUSER; \c :TEST_DBNAME_2 :ROLE_DEFAULT_PERM_USER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; -- Make sure there is 1 launcher and 1 bgw in test db 2 SELECT wait_worker_counts(launcher_ct=>1, scheduler1_ct=> 0, scheduler2_ct=>1, template1_ct=>0); -- drop a non-owner of the extension results in no change to worker counts DROP OWNED BY :ROLE_DEFAULT_PERM_USER_2; SELECT wait_worker_counts(launcher_ct=>1, scheduler1_ct=> 0, scheduler2_ct=>1, template1_ct=>0); -- drop of owner of extension results in extension drop and a stop to the bgw DROP OWNED BY :ROLE_DEFAULT_PERM_USER; -- The worker in test db 2 is dead. Note that 0s are respected SELECT wait_worker_counts(launcher_ct=>1, scheduler1_ct=>0, scheduler2_ct=>0, template1_ct=>0); \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER ROLE :ROLE_DEFAULT_PERM_USER WITH NOSUPERUSER; -- Connect to the template1 database \c template1 \ir include/bgw_launcher_utils.sql BEGIN; -- Then create extension there in a txn and make sure we see a scheduler start SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; SELECT wait_worker_counts(1,0,0,1); COMMIT; -- End our transaction and it should immediately exit because it's a template database. SELECT wait_worker_counts(1,0,0,0); \c :TEST_DBNAME_2 -- Now try creating a DB from a template with the extension already installed. -- Make sure we see a scheduler start. CREATE DATABASE :TEST_DBNAME; SELECT wait_worker_counts(1,1,0,0); DROP DATABASE :TEST_DBNAME WITH (FORCE); -- Now make sure that there's no race between create database and create extension. -- Although to be honest, this race probably wouldn't manifest in this test. \c template1 DROP EXTENSION timescaledb; \c :TEST_DBNAME_2 CREATE DATABASE :TEST_DBNAME; \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb; RESET client_min_messages; \c :TEST_DBNAME_2 SELECT wait_worker_counts(1,1,0,0); -- test rename database CREATE DATABASE db_rename_test; \c db_rename_test :ROLE_SUPERUSER SET client_min_messages=error; CREATE EXTENSION timescaledb; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT wait_for_bgw_scheduler('db_rename_test'); ALTER DATABASE db_rename_test RENAME TO db_rename_test2; DROP DATABASE db_rename_test2 WITH (FORCE); -- test create database with timescaledb database as template SELECT wait_for_bgw_scheduler(:'TEST_DBNAME'); CREATE DATABASE db_from_template WITH TEMPLATE :TEST_DBNAME; SELECT wait_for_bgw_scheduler(:'TEST_DBNAME'); DROP DATABASE db_from_template WITH (FORCE); -- test alter database set tablespace SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; -- Stop background worker before we change the tablespace of the database (otherwise, the database might be used) SELECT wait_for_bgw_scheduler(:'TEST_DBNAME'); -- Connect to TEST_DBNAME (_timescaledb_functions.stop_background_workers() is not available in TEST_DBNAME_2) \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE backend_type = 'TimescaleDB Background Worker Launcher'; \c :TEST_DBNAME_2 :ROLE_SUPERUSER -- make sure nobody is using it REVOKE CONNECT ON DATABASE :TEST_DBNAME FROM public; CALL kill_database_backends(:'TEST_DBNAME'); -- Change tablespace ALTER DATABASE :TEST_DBNAME SET TABLESPACE tablespace1; -- tear down test and clean up additional database \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers() \gset REVOKE CONNECT ON DATABASE :TEST_DBNAME_2 FROM public; CALL kill_database_backends(:'TEST_DBNAME_2'); SELECT * FROM pg_stat_activity WHERE datname = :'TEST_DBNAME_2'; DROP DATABASE :TEST_DBNAME_2 WITH (force); -- Clean up the template database, removing our test utilities etc \c template1 \ir include/bgw_launcher_utils_cleanup.sql ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/c_unit_tests.sql��������������������������������������������������������0000664�0000000�0000000�00000001640�15100345067�0021056�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.time_to_internal_conversion() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_time_to_internal_conversion' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.interval_to_internal_conversion() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_interval_to_internal_conversion' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.adts() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_adts' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.time_utils() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_time_utils' LANGUAGE C; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT test.time_to_internal_conversion(); SELECT test.interval_to_internal_conversion(); SELECT test.adts(); SELECT test.time_utils(); ������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/catalog_corruption.sql��������������������������������������������������0000664�0000000�0000000�00000001704�15100345067�0022252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER --- Test handling of missing dimension slices CREATE TABLE dim_test(time TIMESTAMPTZ, device int); SELECT create_hypertable('dim_test', 'time', chunk_time_interval => INTERVAL '1 day'); -- Create two chunks INSERT INTO dim_test values('2000-01-01 00:00:00', 1); INSERT INTO dim_test values('2020-01-01 00:00:00', 1); SELECT id AS dim_slice_id FROM _timescaledb_catalog.dimension_slice ORDER BY id DESC LIMIT 1 \gset -- Delete the dimension slice for the second chunk DELETE FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id = :dim_slice_id; \set ON_ERROR_STOP 0 -- Select data SELECT * FROM dim_test; -- Select data using ordered append SELECT * FROM dim_test ORDER BY time; \set ON_ERROR_STOP 1 DROP TABLE dim_test; ������������������������������������������������������������timescaledb-2.23.0/test/sql/chunk_adaptive.sql������������������������������������������������������0000664�0000000�0000000�00000032417�15100345067�0021346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- test error handling _timescaledb_functions.calculate_chunk_interval \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.calculate_chunk_interval(0,0,-0); SELECT _timescaledb_functions.calculate_chunk_interval(1,0,-1); \set ON_ERROR_STOP 1 -- Valid chunk sizing function for testing CREATE OR REPLACE FUNCTION calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN -1; END $BODY$; -- Chunk sizing function with bad signature CREATE OR REPLACE FUNCTION bad_calculate_chunk_interval( dimension_id INTEGER ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN -1; END $BODY$; -- Set a fixed memory cache size to make tests determinstic -- (independent of available machine memory) SELECT * FROM test.set_memory_cache_size('2GB'); -- test NULL handling \set ON_ERROR_STOP 0 SELECT * FROM set_adaptive_chunking(NULL,NULL); \set ON_ERROR_STOP 1 CREATE TABLE test_adaptive(time timestamptz, temp float, location int); \set ON_ERROR_STOP 0 -- Bad signature of sizing func should fail SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', chunk_sizing_func => 'bad_calculate_chunk_interval'); \set ON_ERROR_STOP 1 -- Setting sizing func with correct signature should work SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', chunk_sizing_func => 'calculate_chunk_interval'); DROP TABLE test_adaptive; CREATE TABLE test_adaptive(time timestamptz, temp float, location int); -- Size but no explicit func should use default func SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', create_default_indexes => true); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; -- Check that adaptive chunking sets a 1 day default chunk time -- interval => 86400000000 microseconds SELECT * FROM _timescaledb_catalog.dimension; -- Change the target size SELECT * FROM set_adaptive_chunking('test_adaptive', '2MB'); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; \set ON_ERROR_STOP 0 -- Setting NULL func should fail SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB', NULL); \set ON_ERROR_STOP 1 -- Setting NULL size disables adaptive chunking SELECT * FROM set_adaptive_chunking('test_adaptive', NULL); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB'); -- Setting size to 'off' should also disable SELECT * FROM set_adaptive_chunking('test_adaptive', 'off'); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; -- Setting 0 size should also disable SELECT * FROM set_adaptive_chunking('test_adaptive', '0MB'); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB'); -- No warning about small target size if > 10MB SELECT * FROM set_adaptive_chunking('test_adaptive', '11MB'); -- Setting size to 'estimate' should also estimate size SELECT * FROM set_adaptive_chunking('test_adaptive', 'estimate'); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; -- Use a lower memory setting to test that the calculated chunk_target_size is reduced SELECT * FROM test.set_memory_cache_size('512MB'); SELECT * FROM set_adaptive_chunking('test_adaptive', 'estimate'); SELECT table_name, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size FROM _timescaledb_catalog.hypertable; -- Reset memory settings SELECT * FROM test.set_memory_cache_size('2GB'); -- Set a reasonable test value SELECT * FROM set_adaptive_chunking('test_adaptive', '1MB'); -- Show the interval length before and after adaptation SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; -- Generate data to create chunks. We use the hash of the time value -- to get determinstic location IDs so that we always spread these -- values the same way across space partitions INSERT INTO test_adaptive SELECT time, random() * 35, _timescaledb_functions.get_partition_hash(time) FROM generate_series('2017-03-07T18:18:03+00'::timestamptz - interval '175 days', '2017-03-07T18:18:03+00'::timestamptz, '2 minutes') as time; SELECT chunk_name, primary_dimension, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive' ORDER BY chunk_name; -- Do same thing without an index on the time column. This affects -- both the calculation of fill-factor of the chunk and its size CREATE TABLE test_adaptive_no_index(time timestamptz, temp float, location int); -- Size but no explicit func should use default func -- No default indexes should warn and use heap scan for min and max SELECT create_hypertable('test_adaptive_no_index', 'time', chunk_target_size => '1MB', create_default_indexes => false); SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; INSERT INTO test_adaptive_no_index SELECT time, random() * 35, _timescaledb_functions.get_partition_hash(time) FROM generate_series('2017-03-07T18:18:03+00'::timestamptz - interval '175 days', '2017-03-07T18:18:03+00'::timestamptz, '2 minutes') as time; SELECT chunk_name, primary_dimension, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive_no_index' ORDER BY chunk_name; -- Test added to check that the correct index (i.e. time index) is being used -- to find the min and max. Previously a bug selected the first index listed, -- which in this case is location rather than time and therefore could return -- the wrong min and max if items at the start and end of the index did not have -- the correct min and max timestamps. -- -- In this test, we create chunks with a lot of locations with only one reading -- that is at the beginning of the time frame, and then one location in the middle -- of the range that has two readings, one that is the same as the others and one -- that is larger. The algorithm should use these two readings for min & max; however, -- if it's broken (as it was before), it would choose just the reading that is common -- to all the locations. CREATE TABLE test_adaptive_correct_index(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive_correct_index', 'time', chunk_target_size => '100MB', chunk_time_interval => 86400000000, create_default_indexes => false); CREATE INDEX ON test_adaptive_correct_index(location); CREATE INDEX ON test_adaptive_correct_index(time DESC); -- First chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-01T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-01T00:00:00+00'::timestamptz, '2018-01-01T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-01T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- Second chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-02T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-02T00:00:00+00'::timestamptz, '2018-01-02T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-02T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- Third chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-03T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-03T00:00:00+00'::timestamptz, '2018-01-03T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-03T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- This should be the start of the fourth chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-04T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-04T00:00:00+00'::timestamptz, '2018-01-04T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-04T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- If working correctly, this goes in the 4th chunk, otherwise its a separate 5th chunk INSERT INTO test_adaptive_correct_index SELECT '2018-01-05T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(1, 1000) as val; INSERT INTO test_adaptive_correct_index SELECT time, 0.0, '1500' FROM generate_series('2018-01-05T00:00:00+00'::timestamptz, '2018-01-05T20:00:00+00'::timestamptz, '10 hours') as time; INSERT INTO test_adaptive_correct_index SELECT '2018-01-05T00:00:00+00'::timestamptz, val, val + 1 FROM generate_series(2001, 3000) as val; -- This should show 4 chunks, rather than 5 SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive_correct_index'; -- The interval_length should no longer be 86400000000 for our hypertable, so 3rd column so be true. -- Note: the exact interval_length is non-deterministic, so we can't use its actual value for tests SELECT id, hypertable_id, interval_length > 86400000000 FROM _timescaledb_catalog.dimension; -- Drop because it's size and estimated chunk_interval is non-deterministic so -- we don't want to make other tests flaky. DROP TABLE test_adaptive_correct_index; -- Test with space partitioning. This might affect the estimation -- since there are more chunks in the same time interval and space -- chunks might be unevenly filled. CREATE TABLE test_adaptive_space(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive_space', 'time', 'location', 2, chunk_target_size => '1MB', create_default_indexes => true); SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; INSERT INTO test_adaptive_space SELECT time, random() * 35, _timescaledb_functions.get_partition_hash(time) FROM generate_series('2017-03-07T18:18:03+00'::timestamptz - interval '175 days', '2017-03-07T18:18:03+00'::timestamptz, '2 minutes') as time; \x SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test_adaptive_space' ORDER BY chunk_name; SELECT * FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_adaptive_space' ORDER BY dimension_number; \x SELECT * FROM chunks_detailed_size('test_adaptive_space') ORDER BY chunk_name; SELECT id, hypertable_id, interval_length FROM _timescaledb_catalog.dimension; -- A previous version stopped working as soon as hypertable_id stopped being -- equal to dimension_id (i.e., there was a hypertable with more than 1 dimension). -- This test comes after test_adaptive_space, which has 2 dimensions, and makes -- sure that it still works. CREATE TABLE test_adaptive_after_multiple_dims(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive_after_multiple_dims', 'time', chunk_target_size => '100MB', create_default_indexes => true); INSERT INTO test_adaptive_after_multiple_dims VALUES('2018-01-01T00:00:00+00'::timestamptz, 0.0, 5); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 SELECT * FROM set_adaptive_chunking('test_adaptive', '2MB'); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now make sure renaming schema gets propagated to the func_schema DROP TABLE test_adaptive; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_chunk_func_schema; CREATE OR REPLACE FUNCTION my_chunk_func_schema.calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN 2; END $BODY$; CREATE TABLE test_adaptive(time timestamptz, temp float, location int); SELECT create_hypertable('test_adaptive', 'time', chunk_target_size => '1MB', chunk_sizing_func => 'my_chunk_func_schema.calculate_chunk_interval'); ALTER SCHEMA my_chunk_func_schema RENAME TO new_chunk_func_schema; INSERT INTO test_adaptive VALUES (now(), 1.0, 1); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/chunk_utils.sql���������������������������������������������������������0000664�0000000�0000000�00000103236�15100345067�0020707�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH 'include/query_result_test_equal.sql' CREATE OR REPLACE FUNCTION dimension_get_time( hypertable_id INT ) RETURNS _timescaledb_catalog.dimension LANGUAGE SQL STABLE AS $BODY$ SELECT * FROM _timescaledb_catalog.dimension d WHERE d.hypertable_id = dimension_get_time.hypertable_id AND d.interval_length IS NOT NULL $BODY$; CREATE TABLE PUBLIC.drop_chunk_test1(time bigint, temp float8, device_id text); CREATE TABLE PUBLIC.drop_chunk_test2(time bigint, temp float8, device_id text); CREATE TABLE PUBLIC.drop_chunk_test3(time bigint, temp float8, device_id text); CREATE INDEX ON drop_chunk_test1(time DESC); -- show_chunks() without specifying a table is not allowed \set ON_ERROR_STOP 0 SELECT show_chunks(NULL); \set ON_ERROR_STOP 1 SELECT create_hypertable('public.drop_chunk_test1', 'time', chunk_time_interval => 1, create_default_indexes=>false); SELECT create_hypertable('public.drop_chunk_test2', 'time', chunk_time_interval => 1, create_default_indexes=>false); SELECT create_hypertable('public.drop_chunk_test3', 'time', chunk_time_interval => 1, create_default_indexes=>false); -- Add space dimensions to ensure chunks share dimension slices SELECT add_dimension('public.drop_chunk_test1', 'device_id', 2); SELECT add_dimension('public.drop_chunk_test2', 'device_id', 2); SELECT add_dimension('public.drop_chunk_test3', 'device_id', 2); SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; SELECT _timescaledb_functions.get_partition_for_key('dev1'::text); SELECT _timescaledb_functions.get_partition_for_key('dev7'::varchar(5)); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(1, 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(2, 2.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(3, 3.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(4, 4.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(5, 5.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test1 VALUES(6, 6.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(1, 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(2, 2.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(3, 3.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(4, 4.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(5, 5.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test2 VALUES(6, 6.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(1, 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(2, 2.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(3, 3.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(4, 4.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(5, 5.0, 'dev7'); INSERT INTO PUBLIC.drop_chunk_test3 VALUES(6, 6.0, 'dev7'); SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; -- next two calls of show_chunks should give same set of chunks as above when combined SELECT show_chunks('drop_chunk_test1'); SELECT * FROM show_chunks('drop_chunk_test2'); CREATE VIEW dependent_view AS SELECT * FROM _timescaledb_internal._hyper_1_1_chunk; \set ON_ERROR_STOP 0 SELECT drop_chunks('drop_chunk_test1'); SELECT drop_chunks('drop_chunk_test1', older_than => 2); SELECT drop_chunks('drop_chunk_test1', older_than => NULL::interval); SELECT drop_chunks('drop_chunk_test1', older_than => NULL::int); DROP VIEW dependent_view; -- should error because of wrong relative order of time constraints SELECT show_chunks('drop_chunk_test1', older_than=>3, newer_than=>4); -- Should error because NULL was used for the table name. SELECT drop_chunks(NULL, older_than => 3); -- should error because there is no relation with that OID. SELECT drop_chunks(3533, older_than => 3); \set ON_ERROR_STOP 1 -- show created constraints and dimension slices for each chunk SELECT c.table_name, cc.constraint_name, ds.id AS dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) FULL OUTER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) ORDER BY c.id; SELECT * FROM _timescaledb_catalog.dimension_slice ORDER BY id; -- Test that truncating chunks works SELECT count(*) FROM _timescaledb_internal._hyper_2_7_chunk; TRUNCATE TABLE _timescaledb_internal._hyper_2_7_chunk; SELECT count(*) FROM _timescaledb_internal._hyper_2_7_chunk; -- Drop one chunk "manually" and verify that dimension slices and -- constraints are cleaned up. Each chunk has two constraints and two -- dimension slices. Both constraints should be deleted, but only one -- slice should be deleted since the space-dimension slice is shared -- with other chunks in the same hypertable DROP TABLE _timescaledb_internal._hyper_2_7_chunk; -- Two constraints deleted compared to above SELECT c.table_name, cc.constraint_name, ds.id AS dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) FULL OUTER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) ORDER BY c.id; -- Only one dimension slice deleted SELECT * FROM _timescaledb_catalog.dimension_slice ORDER BY id; -- We drop all chunks older than timestamp 2 in all hypertable. This -- is added only to avoid making the diff for this commit larger than -- necessary and make reviews easier. SELECT drop_chunks(format('%1$I.%2$I', schema_name, table_name)::regclass, older_than => 2) FROM _timescaledb_catalog.hypertable; SELECT c.table_name, cc.constraint_name, ds.id AS dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) FULL OUTER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) ORDER BY c.id; SELECT * FROM _timescaledb_catalog.dimension_slice ORDER BY id; SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; -- next two calls of show_chunks should give same set of chunks as above when combined SELECT show_chunks('drop_chunk_test1'); SELECT * FROM show_chunks('drop_chunk_test2'); SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test1\', older_than => 3)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test1\', older_than => 3)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; -- next two calls of show_chunks should give same set of chunks as above when combined SELECT show_chunks('drop_chunk_test1'); SELECT * FROM show_chunks('drop_chunk_test2'); -- 2,147,483,647 is the largest int so this tests that BIGINTs work -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test3\', older_than => 2147483648)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test3\', older_than => 2147483648)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2' OR h.table_name = 'drop_chunk_test3') ORDER BY c.id; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; \set ON_ERROR_STOP 0 -- should error because no hypertable SELECT drop_chunks('drop_chunk_test4', older_than => 5); SELECT show_chunks('drop_chunk_test4'); SELECT show_chunks('drop_chunk_test4', 5); \set ON_ERROR_STOP 1 DROP TABLE _timescaledb_internal._hyper_1_6_chunk; SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1' OR h.table_name = 'drop_chunk_test2') ORDER BY c.id; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; -- newer_than tests -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test1\', newer_than=>5)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test1\', newer_than=>5, verbose => true)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1') ORDER BY c.id; SELECT show_chunks('drop_chunk_test1'); SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '_hyper%'; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test1\', older_than=>4, newer_than=>3)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test1\', older_than=>4, newer_than=>3)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' AND (h.table_name = 'drop_chunk_test1') ORDER BY c.id; -- the call of show_chunks should give same set of chunks as above SELECT show_chunks('drop_chunk_test1'); SELECT c.id AS chunk_id, c.hypertable_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN dimension_get_time(h.id) time_dimension ON(true) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = time_dimension.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.schema_name = 'public' ORDER BY c.id; -- We support show/drop chunks using timestamps/interval even with integer partitioning -- the chunk creation time gets used for these. But we need to use "created_before, created_after" -- for these \set ON_ERROR_STOP 0 SELECT show_chunks('drop_chunk_test3', older_than => now()); SELECT show_chunks('drop_chunk_test2', older_than => now()); SELECT show_chunks('drop_chunk_test1', newer_than => INTERVAL '15 minutes'); SELECT show_chunks('drop_chunk_test1', older_than => now(), newer_than => INTERVAL '15 minutes'); SELECT drop_chunks('drop_chunk_test1', older_than => now()); -- mix of older_than/newer_than and created_after/created_before doesn't work SELECT show_chunks('drop_chunk_test1', older_than => now(), created_after => INTERVAL '15 minutes'); SELECT show_chunks('drop_chunk_test1', created_before => now(), newer_than => INTERVAL '15 minutes'); \set ON_ERROR_STOP 1 SELECT show_chunks('drop_chunk_test3', created_before => now() + INTERVAL '1 hour'); SELECT show_chunks('drop_chunk_test2', created_before => now() + INTERVAL '1 hour'); SELECT show_chunks('drop_chunk_test1', created_after => INTERVAL '15 minutes'); SELECT show_chunks('drop_chunk_test1', created_before => now() + INTERVAL '1 hour', created_after => INTERVAL '1 hour'); SELECT drop_chunks('drop_chunk_test1', created_before => now() + INTERVAL '1 hour'); SELECT drop_chunks(format('%1$I.%2$I', schema_name, table_name)::regclass, older_than => 5, newer_than => 4) FROM _timescaledb_catalog.hypertable WHERE schema_name = 'public'; CREATE TABLE PUBLIC.drop_chunk_test_ts(time timestamp, temp float8, device_id text); SELECT create_hypertable('public.drop_chunk_test_ts', 'time', chunk_time_interval => interval '1 minute', create_default_indexes=>false); CREATE TABLE PUBLIC.drop_chunk_test_tstz(time timestamptz, temp float8, device_id text); SELECT create_hypertable('public.drop_chunk_test_tstz', 'time', chunk_time_interval => interval '1 minute', create_default_indexes=>false); SET timezone = '+1'; INSERT INTO PUBLIC.drop_chunk_test_ts VALUES(now()-INTERVAL '5 minutes', 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test_ts VALUES(now()+INTERVAL '5 minutes', 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test_tstz VALUES(now()-INTERVAL '5 minutes', 1.0, 'dev1'); INSERT INTO PUBLIC.drop_chunk_test_tstz VALUES(now()+INTERVAL '5 minutes', 1.0, 'dev1'); SELECT * FROM test.show_subtables('drop_chunk_test_ts'); SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); BEGIN; SELECT show_chunks('drop_chunk_test_ts'); SELECT show_chunks('drop_chunk_test_ts', now()::timestamp-interval '1 minute'); -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', newer_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', newer_than => interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => interval \'6 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', older_than => interval \'6 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_ts'); \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_ts'); SELECT show_chunks('drop_chunk_test_tstz'); SELECT show_chunks('drop_chunk_test_tstz', older_than => now() - interval '1 minute', newer_than => now() - interval '6 minute'); SELECT show_chunks('drop_chunk_test_tstz', newer_than => now() - interval '1 minute'); SELECT show_chunks('drop_chunk_test_tstz', older_than => now() - interval '1 minute'); \set QUERY1 'SELECT show_chunks(older_than => interval \'1 minute\', relation => \'drop_chunk_test_tstz\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_tstz\', interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', newer_than => interval \'6 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', newer_than => interval \'6 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_ts'); ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', older_than => interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_ts'); \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_tstz\', older_than => interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_tstz\', older_than => interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_ts\', older_than => now()::timestamp-interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_ts\', older_than => now()::timestamp-interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_ts'); \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_tstz\', older_than => now()-interval \'1 minute\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_tstz\', older_than => now()-interval \'1 minute\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_tstz'); ROLLBACK; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; \set ON_ERROR_STOP 0 SELECT drop_chunks(interval '1 minute'); SELECT drop_chunks('drop_chunk_test_ts', (now()-interval '1 minute')); SELECT drop_chunks('drop_chunk_test3', verbose => true); SELECT drop_chunks('drop_chunk_test3', interval '1 minute'); \set ON_ERROR_STOP 1 -- Interval boundary for INTEGER type columns. It uses chunk creation -- time to identify the affected chunks. SELECT drop_chunks('drop_chunk_test3', created_after => interval '1 minute'); SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; CREATE TABLE PUBLIC.drop_chunk_test_date(time date, temp float8, device_id text); SELECT create_hypertable('public.drop_chunk_test_date', 'time', chunk_time_interval => interval '1 day', create_default_indexes=>false); SET timezone = '+100'; INSERT INTO PUBLIC.drop_chunk_test_date VALUES(now()-INTERVAL '2 day', 1.0, 'dev1'); BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_date\', older_than => interval \'1 day\')::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_date\', older_than => interval \'1 day\')::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_date'); ROLLBACK; BEGIN; -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test_date\', older_than => (now()-interval \'1 day\')::date)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test_date\', older_than => (now()-interval \'1 day\')::date)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('drop_chunk_test_date'); ROLLBACK; SET timezone TO '-5'; CREATE TABLE chunk_id_from_relid_test(time bigint, temp float8, device_id int); SELECT hypertable_id FROM create_hypertable('chunk_id_from_relid_test', 'time', chunk_time_interval => 10) \gset INSERT INTO chunk_id_from_relid_test VALUES (0, 1.1, 0), (0, 1.3, 11), (12, 2.0, 0), (12, 0.1, 11); SELECT _timescaledb_functions.chunk_id_from_relid(tableoid) FROM chunk_id_from_relid_test; DROP TABLE chunk_id_from_relid_test; CREATE TABLE chunk_id_from_relid_test(time bigint, temp float8, device_id int); SELECT hypertable_id FROM create_hypertable('chunk_id_from_relid_test', 'time', chunk_time_interval => 10, partitioning_column => 'device_id', number_partitions => 3) \gset INSERT INTO chunk_id_from_relid_test VALUES (0, 1.1, 2), (0, 1.3, 11), (12, 2.0, 2), (12, 0.1, 11); SELECT _timescaledb_functions.chunk_id_from_relid(tableoid) FROM chunk_id_from_relid_test; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.chunk_id_from_relid('pg_type'::regclass); SELECT _timescaledb_functions.chunk_id_from_relid('chunk_id_from_relid_test'::regclass); -- test drop/show_chunks on custom partition types CREATE FUNCTION extract_time(a jsonb) RETURNS TIMESTAMPTZ LANGUAGE SQL AS $$ SELECT (a->>'time')::TIMESTAMPTZ $$ IMMUTABLE; CREATE TABLE test_weird_type(a jsonb); SELECT create_hypertable('test_weird_type', 'a', time_partitioning_func=>'extract_time'::regproc, chunk_time_interval=>'2 hours'::interval); INSERT INTO test_weird_type VALUES ('{"time":"2019/06/06 1:00+0"}'), ('{"time":"2019/06/06 5:00+0"}'); SELECT * FROM test.show_subtables('test_weird_type'); SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 4:00+0'::TIMESTAMPTZ); SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 10:00+0'::TIMESTAMPTZ); -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type\', older_than => \'2019/06/06 5:00+0\'::TIMESTAMPTZ)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type\', older_than => \'2019/06/06 5:00+0\'::TIMESTAMPTZ)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('test_weird_type'); SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 4:00+0'::TIMESTAMPTZ); SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 10:00+0'::TIMESTAMPTZ); -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type\', older_than => \'2019/06/06 6:00+0\'::TIMESTAMPTZ)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type\', older_than => \'2019/06/06 6:00+0\'::TIMESTAMPTZ)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('test_weird_type'); SELECT show_chunks('test_weird_type', older_than=>'2019/06/06 10:00+0'::TIMESTAMPTZ); DROP TABLE test_weird_type; CREATE FUNCTION extract_int_time(a jsonb) RETURNS BIGINT LANGUAGE SQL AS $$ SELECT (a->>'time')::BIGINT $$ IMMUTABLE; CREATE TABLE test_weird_type_i(a jsonb); SELECT create_hypertable('test_weird_type_i', 'a', time_partitioning_func=>'extract_int_time'::regproc, chunk_time_interval=>5); INSERT INTO test_weird_type_i VALUES ('{"time":"0"}'), ('{"time":"5"}'); SELECT * FROM test.show_subtables('test_weird_type_i'); SELECT show_chunks('test_weird_type_i', older_than=>5); SELECT show_chunks('test_weird_type_i', older_than=>10); -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type_i\', older_than=>5)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type_i\', older_than => 5)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('test_weird_type_i'); SELECT show_chunks('test_weird_type_i', older_than=>5); SELECT show_chunks('test_weird_type_i', older_than=>10); -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'test_weird_type_i\', older_than=>10)::NAME' \set QUERY2 'SELECT drop_chunks(\'test_weird_type_i\', older_than => 10)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test.show_subtables('test_weird_type_i'); SELECT show_chunks('test_weird_type_i', older_than=>10); DROP TABLE test_weird_type_i CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER ALTER TABLE drop_chunk_test2 OWNER TO :ROLE_DEFAULT_PERM_USER_2; --drop chunks 3 will have a chunk we a dependent object (a view) --we create the dependent object now INSERT INTO PUBLIC.drop_chunk_test3 VALUES(1, 1.0, 'dev1'); SELECT c.schema_name as chunk_schema, c.table_name as chunk_table FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'drop_chunk_test3' ORDER BY c.id \gset create view dependent_view as SELECT * FROM :"chunk_schema".:"chunk_table"; create view dependent_view2 as SELECT * FROM :"chunk_schema".:"chunk_table"; ALTER TABLE drop_chunk_test3 OWNER TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 SELECT drop_chunks('drop_chunk_test1', older_than=>4, newer_than=>3); --works with modified owner tables -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT show_chunks(\'drop_chunk_test2\', older_than=>4, newer_than=>3)::NAME' \set QUERY2 'SELECT drop_chunks(\'drop_chunk_test2\', older_than=>4, newer_than=>3)::NAME' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all \set VERBOSITY default --this fails because there are dependent objects SELECT drop_chunks('drop_chunk_test3', older_than=>100); \set VERBOSITY terse \c :TEST_DBNAME :ROLE_SUPERUSER DROP VIEW dependent_view; DROP VIEW dependent_view2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 1 --drop chunks from hypertable with same name in different schema -- order of schema in search_path matters -- \c :TEST_DBNAME :ROLE_SUPERUSER drop table chunk_id_from_relid_test; drop table drop_chunk_test1; drop table drop_chunk_test2; drop table drop_chunk_test3; CREATE SCHEMA try_schema; CREATE SCHEMA test1; CREATE SCHEMA test2; CREATE SCHEMA test3; GRANT CREATE ON SCHEMA try_schema, test1, test2, test3 TO :ROLE_DEFAULT_PERM_USER; GRANT USAGE ON SCHEMA try_schema, test1, test2, test3 TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE try_schema.drop_chunk_test_date(time date, temp float8, device_id text); SELECT create_hypertable('try_schema.drop_chunk_test_date', 'time', chunk_time_interval => interval '1 day', create_default_indexes=>false); INSERT INTO public.drop_chunk_test_date VALUES( '2020-01-10', 100, 'hello'); INSERT INTO try_schema.drop_chunk_test_date VALUES( '2020-01-10', 100, 'hello'); set search_path to try_schema, test1, test2, test3, public; SELECT show_chunks('public.drop_chunk_test_date', older_than=>'1 day'::interval); SELECT show_chunks('try_schema.drop_chunk_test_date', older_than=>'1 day'::interval); SELECT drop_chunks('drop_chunk_test_date', older_than=> '1 day'::interval); -- test drop chunks across two tables within the same schema CREATE TABLE test1.hyper1 (time bigint, temp float); CREATE TABLE test1.hyper2 (time bigint, temp float); SELECT create_hypertable('test1.hyper1', 'time', chunk_time_interval => 10); SELECT create_hypertable('test1.hyper2', 'time', chunk_time_interval => 10); INSERT INTO test1.hyper1 VALUES (10, 0.5); INSERT INTO test1.hyper2 VALUES (10, 0.7); SELECT show_chunks('test1.hyper1'); SELECT show_chunks('test1.hyper2'); -- test drop chunks for given table name across all schemas CREATE TABLE test2.hyperx (time bigint, temp float); CREATE TABLE test3.hyperx (time bigint, temp float); SELECT create_hypertable('test2.hyperx', 'time', chunk_time_interval => 10); SELECT create_hypertable('test3.hyperx', 'time', chunk_time_interval => 10); INSERT INTO test2.hyperx VALUES (10, 0.5); INSERT INTO test3.hyperx VALUES (10, 0.7); SELECT show_chunks('test2.hyperx'); SELECT show_chunks('test3.hyperx'); -- This will only drop from one of the tables since the one that is -- first in the search path will hide the other one. SELECT drop_chunks('hyperx', older_than => 100); SELECT show_chunks('test2.hyperx'); SELECT show_chunks('test3.hyperx'); -- Check CTAS behavior when internal ALTER TABLE gets fired CREATE TABLE PUBLIC.drop_chunk_test4(time bigint, temp float8, device_id text); CREATE TABLE drop_chunks_table_id AS SELECT hypertable_id FROM create_hypertable('public.drop_chunk_test4', 'time', chunk_time_interval => 1); -- TEST for internal api that drops a single chunk -- this drops the table and removes entry from the catalog. -- does not affect any materialized cagg data INSERT INTO test1.hyper1 VALUES (20, 0.5); SELECT chunk_schema as "CHSCHEMA", chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name ; --drop one of the chunks SELECT chunk_schema || '.' || chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset SELECT _timescaledb_functions.drop_chunk(:'CHNAME'); SELECT chunk_schema as "CHSCHEMA", chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name ; -- "created_before/after" can be used with time partitioning in drop/show chunks SELECT show_chunks('drop_chunk_test_tstz', created_before => now() - INTERVAL '1 hour'); SELECT drop_chunks('drop_chunk_test_tstz', created_before => now() + INTERVAL '1 hour'); SELECT show_chunks('drop_chunk_test_ts'); -- "created_before/after" accept timestamptz even though partitioning col is just -- timestamp SELECT show_chunks('drop_chunk_test_ts', created_after => now() - INTERVAL '1 hour', created_before => now()); SELECT drop_chunks('drop_chunk_test_ts', created_after => INTERVAL '1 hour', created_before => now()); -- Test views on top of hypertables CREATE TABLE view_test (project_id INT, ts TIMESTAMPTZ NOT NULL); SELECT create_hypertable('view_test', by_range('ts', INTERVAL '1 day')); -- exactly one partition per project_id SELECT * FROM add_dimension('view_test', 'project_id', chunk_time_interval => 1); -- exactly one partition per project; works for *integer* types INSERT INTO view_test (project_id, ts) SELECT g % 25 + 1 AS project_id, i.ts + (g * interval '1 week') / i.total AS ts FROM (SELECT timestamptz '2024-01-01 00:00:00+0', 600) i(ts, total), generate_series(1, i.total) g; -- Create a view on top of this hypertable CREATE VIEW test_view_part_few AS SELECT project_id, ts FROM view_test WHERE project_id = ANY (ARRAY[5, 10, 15]); -- Complicated query on a view involving a range check and a sort SELECT * FROM test_view_part_few WHERE ts BETWEEN '2024-01-04 00:00:00+00'AND '2024-01-05 00:00:00' ORDER BY ts LIMIT 1000; -- Test chunk_status_text function CREATE TABLE chunk_status_test(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=false); INSERT INTO chunk_status_test VALUES ('2025-01-01'),('2025-02-01'),('2025-03-01'); SELECT _timescaledb_functions.chunk_status_text(i) FROM generate_series(0,15) i; SELECT chunk, _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('chunk_status_test') chunk; SELECT _timescaledb_functions.chunk_status_text(NULL::int); SELECT _timescaledb_functions.chunk_status_text(NULL::regclass); \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.chunk_status_text(-1); SELECT _timescaledb_functions.chunk_status_text(16); SELECT _timescaledb_functions.chunk_status_text(1000); SELECT _timescaledb_functions.chunk_status_text(0::regclass); SELECT _timescaledb_functions.chunk_status_text('pg_class'::regclass); \set ON_ERROR_STOP 1 -- Test that function exists and returns an array type SELECT pg_typeof(_timescaledb_functions.chunk_status_text(0)); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/chunks.sql��������������������������������������������������������������0000664�0000000�0000000�00000014475�15100345067�0017660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \unset ECHO \o /dev/null \ir include/test_utils.sql \o \set ECHO errors \set VERBOSITY default \o /dev/null \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.dimension_calculate_default_range_open( dimension_value BIGINT, interval_length BIGINT, dimension_type CSTRING, OUT range_start BIGINT, OUT range_end BIGINT) AS :MODULE_PATHNAME, 'ts_dimension_calculate_open_range_default' LANGUAGE C STABLE; CREATE OR REPLACE FUNCTION _timescaledb_internal.dimension_calculate_default_range_closed( dimension_value BIGINT, num_slices SMALLINT, OUT range_start BIGINT, OUT range_end BIGINT) AS :MODULE_PATHNAME, 'ts_dimension_calculate_closed_range_default' LANGUAGE C STABLE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --open SELECT assert_equal(0::bigint, actual_range_start), assert_equal(10::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(0,10, 'int8') AS res(actual_range_start, actual_range_end); SELECT assert_equal(0::bigint, actual_range_start), assert_equal(10::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(9,10, 'int4') AS res(actual_range_start, actual_range_end); SELECT assert_equal(10::bigint, actual_range_start), assert_equal(20::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(10,10, 'int2') AS res(actual_range_start, actual_range_end); SELECT assert_equal(-10::bigint, actual_range_start), assert_equal(0::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-1,10, 'int8') AS res(actual_range_start, actual_range_end); SELECT assert_equal(-10::bigint, actual_range_start), assert_equal(0::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-10,10, 'int4') AS res(actual_range_start, actual_range_end); SELECT assert_equal(-20::bigint, actual_range_start), assert_equal(-10::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-11,10, 'int2') AS res(actual_range_start, actual_range_end); --test that the ends are cut as needed to prevent overflow/undeflow. --------------- -- BIGINT --------------- SELECT assert_equal(-9223372036854775808, actual_range_start), assert_equal(-9223372036854775800::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-9223372036854775808,10, 'int8') AS res(actual_range_start, actual_range_end); SELECT assert_equal(-9223372036854775808, actual_range_start), assert_equal(-9223372036854775800::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-9223372036854775807,10, 'int8') AS res(actual_range_start, actual_range_end); SELECT assert_equal(9223372036854775800::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(9223372036854775807,10, 'int8') AS res(actual_range_start, actual_range_end); SELECT assert_equal(9223372036854775800::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(9223372036854775806,10, 'int8') AS res(actual_range_start, actual_range_end); --------------- -- INT --------------- SELECT assert_equal(-9223372036854775808, actual_range_start), assert_equal(-2147483640::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-2147483648,10, 'int4') AS res(actual_range_start, actual_range_end); SELECT assert_equal(-9223372036854775808, actual_range_start), assert_equal(-2147483640::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-2147483647,10, 'int4') AS res(actual_range_start, actual_range_end); SELECT assert_equal(2147483640::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(2147483647,10, 'int4') AS res(actual_range_start, actual_range_end); SELECT assert_equal(2147483640::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(2147483646,10, 'int4') AS res(actual_range_start, actual_range_end); --------------- -- SMALLINT --------------- SELECT assert_equal(-9223372036854775808, actual_range_start), assert_equal(-32760::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-32768,10, 'int2') AS res(actual_range_start, actual_range_end); SELECT assert_equal(-9223372036854775808, actual_range_start), assert_equal(-32760::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(-32767,10, 'int2') AS res(actual_range_start, actual_range_end); SELECT assert_equal(32760::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(32767,10, 'int2') AS res(actual_range_start, actual_range_end); SELECT assert_equal(32760::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_open(32766,10, 'int2') AS res(actual_range_start, actual_range_end); --closed SELECT assert_equal((-9223372036854775808)::bigint, actual_range_start), assert_equal(1073741823::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_closed(0,2::smallint) AS res(actual_range_start, actual_range_end); SELECT assert_equal(1073741823::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_closed(1073741824,2::smallint) AS res(actual_range_start, actual_range_end); SELECT assert_equal((-9223372036854775808)::bigint, actual_range_start), assert_equal(9223372036854775807::bigint, actual_range_end) FROM _timescaledb_internal.dimension_calculate_default_range_closed(1073741824,1::smallint) AS res(actual_range_start, actual_range_end); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/cluster.sql�������������������������������������������������������������0000664�0000000�0000000�00000005560�15100345067�0020041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE cluster_test(time timestamptz, temp float, location int); SELECT create_hypertable('cluster_test', 'time', chunk_time_interval => interval '1 day'); -- Show default indexes SELECT * FROM test.show_indexes('cluster_test'); -- Create two chunks INSERT INTO cluster_test VALUES ('2017-01-20T09:00:01', 23.4, 1), ('2017-01-21T09:00:01', 21.3, 2); -- Run cluster CLUSTER VERBOSE cluster_test USING cluster_test_time_idx; -- Create a third chunk INSERT INTO cluster_test VALUES ('2017-01-22T09:00:01', 19.5, 3); -- Show clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- Reorder just our table CLUSTER VERBOSE cluster_test; -- Show clustered indexes, including new chunk SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- Reorder all tables (although will only be our test table) CLUSTER VERBOSE; -- Change the clustered index CREATE INDEX ON cluster_test (time, location); CLUSTER VERBOSE cluster_test using cluster_test_time_location_idx; -- Show updated clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; --check the setting of cluster indexes on hypertables and chunks ALTER TABLE cluster_test CLUSTER ON cluster_test_time_idx; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; CLUSTER VERBOSE cluster_test; ALTER TABLE cluster_test SET WITHOUT CLUSTER; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; \set ON_ERROR_STOP 0 CLUSTER VERBOSE cluster_test; \set ON_ERROR_STOP 1 ALTER TABLE _timescaledb_internal._hyper_1_1_chunk CLUSTER ON _hyper_1_1_chunk_cluster_test_time_idx; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; CLUSTER VERBOSE _timescaledb_internal._hyper_1_1_chunk; ALTER TABLE _timescaledb_internal._hyper_1_1_chunk SET WITHOUT CLUSTER; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1,2; \set ON_ERROR_STOP 0 CLUSTER VERBOSE _timescaledb_internal._hyper_1_1_chunk; \set ON_ERROR_STOP 1 -- test alter column type on hypertable with clustering CREATE TABLE cluster_alter(time timestamp, id text, val int); CREATE INDEX idstuff ON cluster_alter USING btree (id ASC NULLS LAST, time); SELECT table_name FROM create_hypertable('cluster_alter', 'time'); INSERT INTO cluster_alter VALUES('2020-01-01', '123', 1); CLUSTER cluster_alter using idstuff; --attempt the alter table ALTER TABLE cluster_alter ALTER COLUMN id TYPE int USING id::int; CLUSTER cluster_alter; CLUSTER cluster_alter using idstuff; ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/constraint.sql����������������������������������������������������������0000664�0000000�0000000�00000051265�15100345067�0020547�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE hyper ( time BIGINT NOT NULL, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); --check and not-null constraints are inherited through regular inheritance. \set ON_ERROR_STOP 0 INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 9); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, NULL, 11); ALTER TABLE hyper ALTER COLUMN time DROP NOT NULL; ALTER TABLE ONLY hyper ALTER COLUMN sensor_1 SET NOT NULL; ALTER TABLE ONLY hyper ALTER COLUMN device_id DROP NOT NULL; \set ON_ERROR_STOP 1 INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ALTER TABLE hyper ALTER COLUMN device_id DROP NOT NULL; INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, NULL, 11); --make sure validate works \set ON_ERROR_STOP 0 ALTER TABLE hyper ADD CONSTRAINT bad_check_const CHECK (sensor_1 > 100); \set ON_ERROR_STOP 1 ALTER TABLE hyper ADD CONSTRAINT bad_check_const CHECK (sensor_1 > 100) NOT VALID; \set ON_ERROR_STOP 0 ALTER TABLE hyper VALIDATE CONSTRAINT bad_check_const; \set ON_ERROR_STOP 1 ----------------------- UNIQUE CONSTRAINTS ------------------ CREATE TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ( time BIGINT NOT NULL UNIQUE, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name', 'time', chunk_time_interval => 10); INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987800000000000, 'dev2', 11); \set ON_ERROR_STOP 0 INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 1 -- Show constraints on main tables SELECT * FROM _timescaledb_catalog.chunk_constraint; SELECT * FROM test.show_constraints('hyper'); SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); --should have unique constraint not just unique index SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name DROP CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key; -- The constraint should have been removed from the chunk as well SELECT * FROM _timescaledb_catalog.chunk_constraint; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); --uniqueness not enforced INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev3', 11); --shouldn't be able to create constraint \set ON_ERROR_STOP 0 ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_time_key UNIQUE (time); \set ON_ERROR_STOP 1 DELETE FROM hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name WHERE device_id = 'dev3'; -- Try multi-alter table statement with a constraint without a name ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CHECK (time > 0), ADD UNIQUE (time) DEFERRABLE INITIALLY DEFERRED; \set ON_ERROR_STOP 0 BEGIN; --testing deferred checking. The following row has an error, which will not appear until the commit INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev3', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 SELECT * FROM _timescaledb_catalog.chunk_constraint; SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name DROP CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key, DROP CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooo_time_check; SELECT * FROM _timescaledb_catalog.chunk_constraint; SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); CREATE UNIQUE INDEX hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx ON hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name (time); \set ON_ERROR_STOP 0 -- Try adding constraint using existing index ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key UNIQUE USING INDEX hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx; \set ON_ERROR_STOP 1 DROP INDEX hyper_unique_with_looooooooooooooooooooooooooooooooo_time_idx; --now can create ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key UNIQUE (time); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); --test adding constraint with same name to different table -- should fail \set ON_ERROR_STOP 0 ALTER TABLE hyper ADD CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key UNIQUE (time); \set ON_ERROR_STOP 1 --uniquness violation fails \set ON_ERROR_STOP 0 INSERT INTO hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 1 --cannot create unique constraint on non-partition column \set ON_ERROR_STOP 0 ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD CONSTRAINT hyper_unique_invalid UNIQUE (device_id); ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD COLUMN new_device_id int UNIQUE; ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name DROP COLUMN device_id, ADD COLUMN new_device_id int UNIQUE; \set ON_ERROR_STOP 1 ----------------------- RENAME CONSTRAINT ------------------ ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooooooooo_time_key TO new_name; ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name * RENAME CONSTRAINT new_name TO new_name2; ALTER TABLE IF EXISTS hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT hyper_unique_with_looooooooooooooooooooooooooooo_sensor_1_check TO check_2; SELECT * FROM test.show_constraints('hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_2_4_chunk'); SELECT * FROM _timescaledb_catalog.chunk_constraint; \set ON_ERROR_STOP 0 ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT new_name TO new_name2; ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT new_name2 TO check_2; ALTER TABLE ONLY hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name RENAME CONSTRAINT new_name2 TO new_name; ALTER TABLE _timescaledb_internal._hyper_2_4_chunk RENAME CONSTRAINT "4_10_new_name2" TO new_name; \set ON_ERROR_STOP 1 ----------------------- PRIMARY KEY ------------------ CREATE TABLE hyper_pk ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_pk', 'time', chunk_time_interval => 10); INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 1 --should have unique constraint not just unique index SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_3_6_chunk'); ALTER TABLE hyper_pk DROP CONSTRAINT hyper_pk_pkey; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_3_6_chunk'); --uniqueness not enforced INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev3', 11); --shouldn't be able to create pk \set ON_ERROR_STOP 0 ALTER TABLE hyper_pk ADD CONSTRAINT hyper_pk_pkey PRIMARY KEY (time); ALTER TABLE hyper_unique_with_looooooooooooooooooooooooooooooooooooong_name ADD COLUMN new_device_id int PRIMARY KEY; \set ON_ERROR_STOP 1 DELETE FROM hyper_pk WHERE device_id = 'dev3'; --cannot create pk constraint on non-partition column \set ON_ERROR_STOP 0 ALTER TABLE hyper_pk ADD CONSTRAINT hyper_pk_invalid PRIMARY KEY (device_id); \set ON_ERROR_STOP 1 --now can create ALTER TABLE hyper_pk ADD CONSTRAINT hyper_pk_pkey PRIMARY KEY (time) DEFERRABLE INITIALLY DEFERRED; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_3_6_chunk'); --test adding constraint with same name to different table -- should fail \set ON_ERROR_STOP 0 ALTER TABLE hyper ADD CONSTRAINT hyper_pk_pkey UNIQUE (time); \set ON_ERROR_STOP 1 --uniquness violation fails \set ON_ERROR_STOP 0 BEGIN; --error here deferred until commit INSERT INTO hyper_pk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 ----------------------- FOREIGN KEY ------------------ CREATE TABLE devices( device_id TEXT NOT NULL, PRIMARY KEY (device_id) ); CREATE TABLE hyper_fk ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_fk', 'time', chunk_time_interval => 10); --fail fk constraint \set ON_ERROR_STOP 0 INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 1 INSERT INTO devices VALUES ('dev2'); INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); --delete should fail \set ON_ERROR_STOP 0 DELETE FROM devices; \set ON_ERROR_STOP 1 ALTER TABLE hyper_fk DROP CONSTRAINT hyper_fk_device_id_fkey; --should now be able to add non-fk rows INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000001, 'dev3', 11); --can't add fk because of dev3 row \set ON_ERROR_STOP 0 ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id); \set ON_ERROR_STOP 1 --but can add a NOT VALID one ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id) NOT VALID; --which will fail when validated \set ON_ERROR_STOP 0 ALTER TABLE hyper_fk VALIDATE CONSTRAINT hyper_fk_device_id_fkey; \set ON_ERROR_STOP 1 ALTER TABLE hyper_fk DROP CONSTRAINT hyper_fk_device_id_fkey; DELETE FROM hyper_fk WHERE device_id = 'dev3'; ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id); \set ON_ERROR_STOP 0 INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000002, 'dev3', 11); \set ON_ERROR_STOP 1 SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_4_8_chunk'); SELECT * FROM _timescaledb_catalog.chunk_constraint; --test CASCADE drop behavior DROP TABLE devices CASCADE; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_4_8_chunk'); SELECT * FROM _timescaledb_catalog.chunk_constraint; --the fk went away. INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000002, 'dev3', 11); CREATE TABLE devices( device_id TEXT NOT NULL, PRIMARY KEY (device_id) ); INSERT INTO devices VALUES ('dev2'), ('dev3'); ALTER TABLE hyper_fk ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (device_id) REFERENCES devices(device_id) DEFERRABLE INITIALLY DEFERRED; \set ON_ERROR_STOP 0 BEGIN; --error deferred until commmit INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000003, 'dev4', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 ALTER TABLE hyper_fk ALTER CONSTRAINT hyper_fk_device_id_fkey NOT DEFERRABLE; \set ON_ERROR_STOP 0 BEGIN; --error detected right away INSERT INTO hyper_fk(time, device_id,sensor_1) VALUES (1257987700000000003, 'dev4', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 --this tests that there are no extra chunk_constraints left on hyper_fk TRUNCATE hyper_fk; ----------------------- FOREIGN KEY INTO A HYPERTABLE ------------------ --FOREIGN KEY references into a hypertable are currently broken. --The referencing table will never find the corresponding row in the hypertable --since it will only search the parent. Thus any insert will result in an ERROR --Block such foreign keys or fix. (Hard to block on create table so punting for now) CREATE TABLE hyper_for_ref ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_for_ref', 'time', chunk_time_interval => 10); \set ON_ERROR_STOP 0 CREATE TABLE referrer ( time BIGINT NOT NULL REFERENCES hyper_for_ref(time) ); \set ON_ERROR_STOP 1 CREATE TABLE referrer2 ( time BIGINT NOT NULL ); \set ON_ERROR_STOP 0 ALTER TABLE referrer2 ADD CONSTRAINT hyper_fk_device_id_fkey FOREIGN KEY (time) REFERENCES hyper_for_ref(time); \set ON_ERROR_STOP 1 ----------------------- EXCLUSION CONSTRAINT ------------------ CREATE TABLE hyper_ex ( time BIGINT, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10), canceled boolean DEFAULT false, EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) ); SELECT * FROM create_hypertable('hyper_ex', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); \set ON_ERROR_STOP 1 ALTER TABLE hyper_ex DROP CONSTRAINT hyper_ex_time_device_id_excl; --can now add INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); --cannot add because of conflicts \set ON_ERROR_STOP 0 ALTER TABLE hyper_ex ADD CONSTRAINT hyper_ex_time_device_id_excl EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) ; \set ON_ERROR_STOP 1 DELETE FROM hyper_ex WHERE sensor_1 = 12; ALTER TABLE hyper_ex ADD CONSTRAINT hyper_ex_time_device_id_excl EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) DEFERRABLE INITIALLY DEFERRED ; \set ON_ERROR_STOP 0 BEGIN; --error deferred til commit INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 --cannot add exclusion constraint without partition key. CREATE TABLE hyper_ex_invalid ( time BIGINT, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10), canceled boolean DEFAULT false, EXCLUDE USING btree ( device_id WITH = ) WHERE (not canceled) ); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('hyper_ex_invalid', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 --- NO INHERIT constraints (not allowed) ---- CREATE TABLE hyper_noinherit ( time BIGINT, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 0) NO INHERIT ); SELECT * FROM test.show_constraints('hyper_noinherit'); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('hyper_noinherit', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 CREATE TABLE hyper_noinherit_alter ( time BIGINT, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('hyper_noinherit_alter', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 0 ALTER TABLE hyper_noinherit_alter ADD CONSTRAINT check_noinherit CHECK (sensor_1 > 0) NO INHERIT; -- CREATE TABLE WITH DEFERRED CONSTRAINTS -- CREATE TABLE hyper_unique_deferred ( time BIGINT UNIQUE DEFERRABLE INITIALLY DEFERRED, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique_deferred', 'time', chunk_time_interval => 10); INSERT INTO hyper_unique_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 BEGIN; --error here deferred until commit INSERT INTO hyper_unique_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 --test deferred on create table CREATE TABLE hyper_pk_deferred ( time BIGINT NOT NULL PRIMARY KEY DEFERRABLE INITIALLY DEFERRED, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_pk_deferred', 'time', chunk_time_interval => 10); INSERT INTO hyper_pk_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); \set ON_ERROR_STOP 0 BEGIN; --error here deferred until commit INSERT INTO hyper_pk_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 --test that deferred works on create table too CREATE TABLE hyper_fk_deferred ( time BIGINT NOT NULL PRIMARY KEY, device_id TEXT NOT NULL REFERENCES devices(device_id) DEFERRABLE INITIALLY DEFERRED, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_fk_deferred', 'time', chunk_time_interval => 10); \set ON_ERROR_STOP 0 BEGIN; --error deferred until commmit INSERT INTO hyper_fk_deferred(time, device_id,sensor_1) VALUES (1257987700000000003, 'dev4', 11); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 CREATE TABLE hyper_ex_deferred ( time BIGINT, device_id TEXT NOT NULL REFERENCES devices(device_id), sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10), canceled boolean DEFAULT false, EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) DEFERRABLE INITIALLY DEFERRED ); SELECT * FROM create_hypertable('hyper_ex_deferred', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); INSERT INTO hyper_ex_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); \set ON_ERROR_STOP 0 BEGIN; --error deferred til commit INSERT INTO hyper_ex_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 12); SELECT 1; COMMIT; \set ON_ERROR_STOP 1 -- Make sure renaming schemas won't break dropping constraints \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE hyper_unique ( time BIGINT NOT NULL UNIQUE, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique', 'time', chunk_time_interval => 10, associated_schema_name => 'my_associated_schema'); INSERT INTO hyper_unique(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); ALTER SCHEMA my_associated_schema RENAME TO new_associated_schema; ALTER TABLE hyper_unique DROP CONSTRAINT hyper_unique_time_key; -- test for constraint validation crash, see #1183 CREATE TABLE test_validate(time timestamp NOT NULL, a TEXT, b TEXT); SELECT * FROM create_hypertable('test_validate', 'time'); INSERT INTO test_validate values(now(), 'a', 'b'); ALTER TABLE test_validate ADD COLUMN c TEXT, ADD CONSTRAINT c_not_null CHECK (c IS NOT NULL) NOT VALID; UPDATE test_validate SET c = ''; ALTER TABLE test_validate VALIDATE CONSTRAINT c_not_null; DROP TABLE test_validate; -- test for hypertables constraints both using index tablespaces and not See #2604 SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; SET client_min_messages = NOTICE; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLE fk_tbl ( id int, CONSTRAINT pkfk PRIMARY KEY (id) USING INDEX TABLESPACE tablespace1); CREATE TABLE tbl ( fk_id int, id int, time timestamp, CONSTRAINT pk PRIMARY KEY (time, id) USING INDEX TABLESPACE tablespace1 DEFERRABLE INITIALLY DEFERRED); SELECT create_hypertable('tbl', 'time'); ALTER TABLE tbl ADD CONSTRAINT fk_con FOREIGN KEY (fk_id) REFERENCES fk_tbl(id) ON UPDATE SET NULL ON DELETE SET NULL; INSERT INTO fk_tbl VALUES(1); INSERT INTO tbl VALUES ( 1, 1, now() ); DROP TABLE tbl; DROP TABLE fk_tbl; DROP TABLESPACE IF EXISTS tablespace1; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/copy.sql����������������������������������������������������������������0000664�0000000�0000000�00000041670�15100345067�0017334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql \o --old chunks COPY "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; 1257894000000000000,dev3,1.5,2 \. \copy "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; 1257894000000000000,dev3,1.5,2 \. --new chunks COPY "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; 2257894000000000000,dev3,1.5,2 \. \copy "two_Partitions"("timeCustom", device_id, series_0, series_1) FROM STDIN DELIMITER ','; 2257894000000000000,dev3,1.5,2 \. COPY (SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1) TO STDOUT; ---test hypertable with FK CREATE TABLE "meta" ("id" serial PRIMARY KEY); CREATE TABLE "hyper" ( "meta_id" integer NOT NULL REFERENCES meta(id), "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper', 'time', chunk_time_interval => 100); INSERT INTO "meta" ("id") values (1); \copy hyper (time, meta_id, value) FROM STDIN DELIMITER ','; 1,1,1 \. COPY hyper (time, meta_id, value) FROM STDIN DELIMITER ','; 2,1,1 \. \set ON_ERROR_STOP 0 \copy hyper (time, meta_id, value) FROM STDIN DELIMITER ','; 1,2,1 \. COPY hyper (time, meta_id, value) FROM STDIN DELIMITER ','; 2,2,1 \. \set ON_ERROR_STOP 1 COPY (SELECT * FROM hyper ORDER BY time, meta_id) TO STDOUT; --test that copy works with a low setting for max_open_chunks_per_insert set timescaledb.max_open_chunks_per_insert = 1; CREATE TABLE "hyper2" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper2', 'time', chunk_time_interval => 10); \copy hyper2 from data/copy_data.csv with csv header ; -- test copy with blocking trigger CREATE FUNCTION gt_10() RETURNS trigger AS $func$ BEGIN IF NEW."time" < 11 THEN RETURN NULL; END IF; RETURN NEW; END $func$ LANGUAGE plpgsql; CREATE TABLE "trigger_test" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('trigger_test', 'time', chunk_time_interval => 10); CREATE TRIGGER check_time BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION gt_10(); \copy trigger_test from data/copy_data.csv with csv header ; SELECT * FROM trigger_test ORDER BY time; -- Test that if we copy from stdin to a hypertable and violate a null -- constraint, it does not crash and generate an appropriate error -- message. CREATE TABLE test(a INT NOT NULL, b TIMESTAMPTZ); SELECT create_hypertable('test', 'b'); \set ON_ERROR_STOP 0 COPY TEST (a,b) FROM STDIN (delimiter ',', null 'N'); N,'2020-01-01' \. \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages TO NOTICE; -- Do a basic test of COPY with a wrong PROGRAM COPY hyper FROM PROGRAM 'error'; \set ON_ERROR_STOP 1 ---------------------------------------------------------------- -- Testing COPY TO. ---------------------------------------------------------------- -- COPY TO using a hypertable will not copy any tuples, but should -- show a notice. COPY hyper TO STDOUT DELIMITER ','; -- COPY TO using a query should display all the tuples and not show a -- notice. COPY (SELECT * FROM hyper) TO STDOUT DELIMITER ','; ---------------------------------------------------------------- -- Testing multi-buffer optimization. ---------------------------------------------------------------- CREATE TABLE "hyper_copy" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper_copy', 'time', chunk_time_interval => 2); -- First copy call with default client_min_messages, to get rid of the -- building index "_hyper_XXX_chunk_hyper_copy_time_idx" on table "_hyper_XXX_chunk" serially -- messages \copy hyper_copy FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy FROM data/copy_data.csv WITH csv header; SELECT count(*) FROM hyper_copy; -- Limit number of open chunks SET timescaledb.max_open_chunks_per_insert = 1; \copy hyper_copy FROM data/copy_data.csv WITH csv header; SELECT count(*) FROM hyper_copy; -- Before trigger disable the multi-buffer optimization CREATE OR REPLACE FUNCTION empty_test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- Before trigger (CIM_SINGLE should be used) CREATE TRIGGER hyper_copy_trigger_insert_before BEFORE INSERT ON hyper_copy FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy FROM data/copy_data.csv WITH csv header; SELECT count(*) FROM hyper_copy; -- Suppress 'DEBUG: EventTriggerInvoke XXXX' messages RESET client_min_messages; DROP TRIGGER hyper_copy_trigger_insert_before ON hyper_copy; SET client_min_messages TO DEBUG1; -- After trigger (CIM_MULTI_CONDITIONAL should be used) CREATE TRIGGER hyper_copy_trigger_insert_after AFTER INSERT ON hyper_copy FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy FROM data/copy_data.csv WITH csv header; SELECT count(*) FROM hyper_copy; -- Insert data into the chunks in random order COPY hyper_copy FROM STDIN DELIMITER ',' NULL AS 'null'; 5,1 7,1 1,1 0,5 15,3 0,7 17,2 20,1 5,6 19,1 18,2 17,1 16,1 15,1 14,1 13,1 12,1 11,1 10,1 11,1 12,2 13,2 14,2 15,2 16,2 17,2 18,2 19,2 20,2 \. SELECT count(*) FROM hyper_copy; RESET client_min_messages; RESET timescaledb.max_open_chunks_per_insert; ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (no index on destination hypertable). ---------------------------------------------------------------- CREATE TABLE "hyper_copy_noindex" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('hyper_copy_noindex', 'time', chunk_time_interval => 10, create_default_indexes => false); -- No trigger \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; RESET client_min_messages; SELECT count(*) FROM hyper_copy_noindex; -- Before trigger (CIM_SINGLE should be used) CREATE TRIGGER hyper_copy_trigger_insert_before BEFORE INSERT ON hyper_copy_noindex FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; RESET client_min_messages; SELECT count(*) FROM hyper_copy_noindex; -- After trigger (CIM_MULTI_CONDITIONAL should be used) DROP TRIGGER hyper_copy_trigger_insert_before ON hyper_copy_noindex; CREATE TRIGGER hyper_copy_trigger_insert_after AFTER INSERT ON hyper_copy_noindex FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; SET client_min_messages TO DEBUG1; \copy hyper_copy_noindex FROM data/copy_data.csv WITH csv header; RESET client_min_messages; SELECT count(*) FROM hyper_copy_noindex; ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (more chunks than MAX_PARTITION_BUFFERS). ---------------------------------------------------------------- CREATE TABLE "hyper_copy_large" ( "time" timestamp NOT NULL, "value" double precision NOT NULL ); -- Genate data that will create more than 32 (MAX_PARTITION_BUFFERS) -- chunks on the 10 second chunk_time_interval partitioned hypertable. INSERT INTO hyper_copy_large SELECT time, random() AS value FROM generate_series('2022-01-01', '2022-01-31', INTERVAL '1 hour') AS g1(time) ORDER BY time; SELECT COUNT(*) FROM hyper_copy_large; -- Migrate data to chunks by using copy SELECT create_hypertable('hyper_copy_large', 'time', chunk_time_interval => INTERVAL '1 hour', migrate_data => 'true'); SELECT COUNT(*) FROM hyper_copy_large; ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (triggers on chunks). ---------------------------------------------------------------- CREATE TABLE "table_with_chunk_trigger" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); -- This trigger counts the already inserted tuples in -- the table table_with_chunk_trigger. CREATE OR REPLACE FUNCTION count_test_chunk_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ DECLARE cnt INTEGER; BEGIN SELECT count(*) FROM table_with_chunk_trigger INTO cnt; RAISE WARNING 'Trigger counted % tuples in table table_with_chunk_trigger', cnt; IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- Create hypertable and chunks SELECT create_hypertable('table_with_chunk_trigger', 'time', chunk_time_interval => 1); -- Insert data to create all missing chunks \copy table_with_chunk_trigger from data/copy_data.csv with csv header; SELECT count(*) FROM table_with_chunk_trigger; -- Chunk 1: 1-2, Chunk 2: 2-3, Chunk 3: 3-4, Chunk 4: 4-5 SELECT chunk_schema, chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'table_with_chunk_trigger' AND range_end_integer=5 \gset -- Create before trigger on the 4th chunk CREATE TRIGGER table_with_chunk_trigger_before_trigger BEFORE INSERT ON :chunk_schema.:chunk_name FOR EACH ROW EXECUTE FUNCTION count_test_chunk_trigger(); -- Insert data -- 25 tuples are already imported. The trigger is executed before tuples -- are copied into the 4th chunk. So, the trigger should report 25+3 = 28 -- This test requires that the multi-insert buffers of the other chunks -- are flushed before the trigger is executed. SET client_min_messages TO DEBUG1; \copy table_with_chunk_trigger FROM data/copy_data.csv WITH csv header; RESET client_min_messages; SELECT count(*) FROM table_with_chunk_trigger; DROP TRIGGER table_with_chunk_trigger_before_trigger ON :chunk_schema.:chunk_name; -- Create after trigger CREATE TRIGGER table_with_chunk_trigger_after_trigger AFTER INSERT ON :chunk_schema.:chunk_name FOR EACH ROW EXECUTE FUNCTION count_test_chunk_trigger(); -- Insert data -- 50 tuples are already imported. The trigger is executed after all -- tuples are imported. So, the trigger should report 50+25 = 75 SET client_min_messages TO DEBUG1; \copy table_with_chunk_trigger FROM data/copy_data.csv WITH csv header; RESET client_min_messages; SELECT count(*) FROM table_with_chunk_trigger; -- Hypertable with after row trigger and no index DROP TABLE table_with_chunk_trigger; CREATE TABLE "table_with_chunk_trigger" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); -- Create hypertable and chunks SELECT create_hypertable('table_with_chunk_trigger', 'time', chunk_time_interval => 1, create_default_indexes => false); -- Insert data to create all missing chunks \copy table_with_chunk_trigger from data/copy_data.csv with csv header; SELECT count(*) FROM table_with_chunk_trigger; -- Chunk 1: 1-2, Chunk 2: 2-3, Chunk 3: 3-4, Chunk 4: 4-5 SELECT chunk_schema, chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'table_with_chunk_trigger' AND range_end_integer=5 \gset -- Create after trigger CREATE TRIGGER table_with_chunk_trigger_after_trigger AFTER INSERT ON :chunk_schema.:chunk_name FOR EACH ROW EXECUTE FUNCTION count_test_chunk_trigger(); \copy table_with_chunk_trigger from data/copy_data.csv with csv header; SELECT count(*) FROM table_with_chunk_trigger; ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (Hypertable without before insert trigger) ---------------------------------------------------------------- CREATE TABLE "table_without_bf_trigger" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('table_without_bf_trigger', 'time', chunk_time_interval => 1); \copy table_without_bf_trigger from data/copy_data.csv with csv header; SET client_min_messages TO DEBUG1; \copy table_without_bf_trigger from data/copy_data.csv with csv header; RESET client_min_messages; SELECT count(*) FROM table_without_bf_trigger; -- After trigger (CIM_MULTI_CONDITIONAL should be used) CREATE TRIGGER table_with_chunk_trigger_after_trigger AFTER INSERT ON table_without_bf_trigger FOR EACH ROW EXECUTE FUNCTION empty_test_trigger(); SET client_min_messages TO DEBUG1; \copy table_without_bf_trigger from data/copy_data.csv with csv header; RESET client_min_messages; SELECT count(*) FROM table_without_bf_trigger; ---------------------------------------------------------------- -- Testing multi-buffer optimization -- (Chunks with different layouts) ---------------------------------------------------------------- -- Time is not the first attribute of the hypertable CREATE TABLE "table_with_layout_change" ( "value1" real NOT NULL DEFAULT 1, "value2" smallint DEFAULT NULL, "value3" bigint DEFAULT NULL, "time" bigint NOT NULL, "value4" double precision NOT NULL DEFAULT 4, "value5" double precision NOT NULL DEFAULT 5 ); SELECT create_hypertable('table_with_layout_change', 'time', chunk_time_interval => 1); -- Chunk 1 (time = 1) COPY table_with_layout_change FROM STDIN DELIMITER ',' NULL AS 'null'; 100,200,300,1,400,500 \. SELECT * FROM table_with_layout_change; -- Drop the first attribute ALTER TABLE table_with_layout_change DROP COLUMN value1; SELECT * FROM table_with_layout_change; -- COPY into existing chunk (time = 1) COPY table_with_layout_change FROM STDIN DELIMITER ',' NULL AS 'null'; 201,301,1,401,501 \. -- Create new chunk (time = 2) COPY table_with_layout_change FROM STDIN DELIMITER ',' NULL AS 'null'; 202,302,2,402,502 \. SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value5; -- Create new chunk (time = 2), insert in different order COPY table_with_layout_change (time, value5, value4, value3, value2) FROM STDIN DELIMITER ',' NULL AS 'null'; 2,503,403,303,203 \. COPY table_with_layout_change (value5, value4, value3, value2, time) FROM STDIN DELIMITER ',' NULL AS 'null'; 504,404,304,204,2 \. COPY table_with_layout_change (value5, value4, value3, time, value2) FROM STDIN DELIMITER ',' NULL AS 'null'; 505,405,305,2,205 \. SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value5; -- Drop the last attribute and add a new one ALTER TABLE table_with_layout_change DROP COLUMN value5; ALTER TABLE table_with_layout_change ADD COLUMN value6 double precision NOT NULL default 600; SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value6; -- COPY in first chunk (time = 1) COPY table_with_layout_change (time, value2, value3, value4, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; 1,206,306,406,606 \. -- COPY in second chunk (time = 2) COPY table_with_layout_change (time, value2, value3, value4, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; 2,207,307,407,607 \. -- COPY in new chunk (time = 3) COPY table_with_layout_change (time, value2, value3, value4, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; 3,208,308,408,608 \. -- COPY in all chunks, different attribute order COPY table_with_layout_change (value3, value4, time, value6, value2) FROM STDIN DELIMITER ',' NULL AS 'null'; 309,409,3,609,209 310,410,2,610,210 311,411,1,611,211 \. SELECT * FROM table_with_layout_change ORDER BY time, value2, value3, value4, value6; -- Drop first column ALTER TABLE table_with_layout_change DROP COLUMN value2; SELECT * FROM table_with_layout_change ORDER BY time, value3, value4, value6; -- COPY in all exiting chunks and create a new one (time 4) COPY table_with_layout_change (value3, value4, time, value6) FROM STDIN DELIMITER ',' NULL AS 'null'; 312,412,3,612 313,413,2,613 314,414,4,614 315,415,1,615 \. SELECT * FROM table_with_layout_change ORDER BY time, value3, value4, value6; -- Drop the last two columns ALTER TABLE table_with_layout_change DROP COLUMN value4; ALTER TABLE table_with_layout_change DROP COLUMN value6; -- COPY in all exiting chunks and create a new one (time 5) COPY table_with_layout_change (value3, time) FROM STDIN DELIMITER ',' NULL AS 'null'; 316,2 317,1 318,3 319,5 320,4 \. SELECT * FROM table_with_layout_change ORDER BY time, value3; -- Drop the last of the initial attributes and add a new one ALTER TABLE table_with_layout_change DROP COLUMN value3; ALTER TABLE table_with_layout_change ADD COLUMN value7 double precision NOT NULL default 700; -- COPY in all exiting chunks and create a new one (time 6) COPY table_with_layout_change (value7, time) FROM STDIN DELIMITER ',' NULL AS 'null'; 721,2 722,1 723,3 724,5 725,6 726,4 \. SELECT * FROM table_with_layout_change ORDER BY time, value7; -- verify check constraints work CREATE TABLE test_check(a INT, b TIMESTAMPTZ); ALTER TABLE test_check ADD CONSTRAINT c1 CHECK (a > 7); SELECT table_name FROM create_hypertable('test_check', 'b'); COPY test_check(a,b) FROM STDIN (delimiter ',', null 'N'); 8,'2020-01-01' \. \set ON_ERROR_STOP 0 COPY test_check(a,b) FROM STDIN (delimiter ',', null 'N'); 3,'2020-01-01' \. \set ON_ERROR_STOP 1 ������������������������������������������������������������������������timescaledb-2.23.0/test/sql/copy_memory_usage.sql���������������������������������������������������0000664�0000000�0000000�00000011550�15100345067�0022102�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that transaction memory usage with COPY doesn't grow. -- We need memory usage in PortalContext after the completion of the query, so -- we'll have to log it from a trigger that runs after the query is completed. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; create table uk_price_paid(price integer, "date" date, postcode1 text, postcode2 text, type smallint, is_new bool, duration smallint, addr1 text, addr2 text, street text, locality text, town text, district text, country text, category smallint); -- Aim to about 100 partitions, the data is from 1995 to 2022. select create_hypertable('uk_price_paid', 'date', chunk_time_interval => interval '90 day'); -- This is where we log the memory usage. create table portal_memory_log(id serial, bytes bigint); -- Returns the amount of memory currently allocated in a given -- memory context. Only works for PortalContext, and doesn't work for PG 12. create or replace function ts_debug_allocated_bytes(text) returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; -- Log current memory usage into the log table. create function log_memory() returns trigger as $$ begin insert into portal_memory_log values (default, ts_debug_allocated_bytes('PortalContext')); return new; end; $$ language plpgsql; -- Prepare version dependent TopTransactionContext total memory usage query. -- Using prepared statements to avoid contaminating memory usage numbers. -- PG18 removed parent column so we have to use path to get TopTransactionContext child entries. -- https://github.com/postgres/postgres/commit/f0d11275 create or replace function prepare_transaction_total_memory_usage_stmt() returns void language plpgsql as $$ begin if current_setting('server_version_num')::int < 180000 then prepare total_stmt as select sum(total_bytes) from pg_backend_memory_contexts where parent = 'TopTransactionContext'; else prepare total_stmt as select sum(m.total_bytes) from pg_backend_memory_contexts m inner join pg_backend_memory_contexts p on (m.path[m.level-1] = p.path[p.level]) where p.name = 'TopTransactionContext'; end if; end; $$; -- Add a trigger that runs after completion of each INSERT/COPY and logs the -- current memory usage. create trigger check_update after insert on uk_price_paid for each statement execute function log_memory(); -- Memory leaks often happen on cache invalidation, so make sure they are -- invalidated often and independently (at co-prime periods). set timescaledb.max_open_chunks_per_insert = 2; set timescaledb.max_cached_chunks_per_hypertable = 3; -- Try increasingly larger data sets by concatenating the same file multiple -- times. \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; \copy uk_price_paid from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz) <(zcat < data/prices-10k-random-1.tsv.gz)"'; select count(*) from portal_memory_log; -- Check that the memory doesn't increase with file size by using linear regression. select * from portal_memory_log where ( select regr_slope(bytes, id - 1) / regr_intercept(bytes, id - 1)::float > 0.05 from portal_memory_log ); -- Test plpgsql leaks CREATE TABLE test_ht(tm timestamptz, val float8); SELECT * FROM create_hypertable('test_ht', 'tm'); -- Use a plpgsql function to insert into the hypertable CREATE OR REPLACE FUNCTION to_double(_in text, INOUT _out double precision) LANGUAGE plpgsql IMMUTABLE parallel safe AS $$ BEGIN SELECT CAST(_in AS double precision) INTO _out; EXCEPTION WHEN others THEN --do nothing: _out already carries default END; $$; -- TopTransactionContext usage needs to remain the same after every insert -- There was a leak earlier in the child CurTransactionContext SELECT prepare_transaction_total_memory_usage_stmt(); BEGIN; INSERT INTO test_ht VALUES ('1980-01-01 00:00:00-00', to_double('23.11', 0)); EXECUTE total_stmt; INSERT INTO test_ht VALUES ('1980-02-01 00:00:00-00', to_double('24.11', 0)); EXECUTE total_stmt; COMMIT; ��������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/copy_where.sql����������������������������������������������������������0000664�0000000�0000000�00000002555�15100345067�0020525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ------- TEST 1: Restrictive copy from file CREATE TABLE "copy_golden" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); \COPY copy_golden (time, value) FROM data/copy_data.csv WITH CSV HEADER SELECT * FROM copy_golden ORDER BY TIME; CREATE TABLE "copy_control" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); \COPY copy_control (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time > 10; SELECT * FROM copy_control ORDER BY TIME; CREATE TABLE "copy_test" ( "time" bigint NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('copy_test', 'time', chunk_time_interval => 10); \COPY copy_test (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time > 10; SELECT * FROM copy_test ORDER BY TIME; -- Verify attempting to use subqueries fails the same as non-hypertables \set ON_ERROR_STOP 0 \COPY copy_control (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time IN (SELECT time FROM copy_golden); \COPY copy_test (time, value) FROM data/copy_data.csv WITH CSV HEADER WHERE time IN (SELECT time FROM copy_golden); \set ON_ERROR_STOP 1 DROP TABLE copy_golden; DROP TABLE copy_control; DROP TABLE copy_test; ���������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/create_chunks.sql�������������������������������������������������������0000664�0000000�0000000�00000016324�15100345067�0021176�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- This test will create chunks in two dimenisions, time (x) and -- space (y), where the time dimension is aligned. The figure below -- shows the expected result. The chunk number in the figure -- indicates the creation order. -- -- + -- + -- + +-----+ +-----+ -- + | 2 | | 3 | -- + | +---+-+ | -- + +-----+ 5 |6+-----+ -- + | 1 +---+-+-----+ +---------+ -- + | | |4| 7 | | 8 | -- +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- -- 0 5 10 15 20 -- -- Partitioning: -- -- Chunk # | time | space -- 1 | 3 | 2 -- 4 | 1 | 3 -- 5 | 5 | 3 -- CREATE TABLE chunk_test(time integer, temp float8, tag integer, color integer); SELECT create_hypertable('chunk_test', 'time', 'tag', 2, chunk_time_interval => 3); INSERT INTO chunk_test VALUES (4, 24.3, 1, 1); SELECT * FROM _timescaledb_catalog.dimension_slice; INSERT INTO chunk_test VALUES (4, 24.3, 2, 1); INSERT INTO chunk_test VALUES (10, 24.3, 2, 1); SELECT c.table_name AS chunk_name, d.id AS dimension_id, ds.id AS slice_id, range_start, range_end FROM _timescaledb_catalog.chunk c LEFT JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) LEFT JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) LEFT JOIN _timescaledb_catalog.dimension d ON (d.id = ds.dimension_id) LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test' ORDER BY c.id, d.id; \c :TEST_DBNAME :ROLE_SUPERUSER SELECT set_number_partitions('chunk_test', 3); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT set_chunk_time_interval('chunk_test', 1::bigint); INSERT INTO chunk_test VALUES (8, 24.3, 11233, 1); SELECT set_chunk_time_interval('chunk_test', 5::bigint); SELECT * FROM _timescaledb_catalog.dimension; INSERT INTO chunk_test VALUES (7, 24.3, 79669, 1); INSERT INTO chunk_test VALUES (8, 24.3, 79669, 1); INSERT INTO chunk_test VALUES (10, 24.3, 11233, 1); INSERT INTO chunk_test VALUES (16, 24.3, 11233, 1); SELECT c.table_name AS chunk_name, d.id AS dimension_id, ds.id AS slice_id, range_start, range_end FROM _timescaledb_catalog.chunk c LEFT JOIN _timescaledb_catalog.chunk_constraint cc ON (c.id = cc.chunk_id) LEFT JOIN _timescaledb_catalog.dimension_slice ds ON (ds.id = cc.dimension_slice_id) LEFT JOIN _timescaledb_catalog.dimension d ON (d.id = ds.dimension_id) LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test' ORDER BY c.id, d.id; --test the edges of an open partition -- INT_64_MAX and INT_64_MIN. CREATE TABLE chunk_test_ends(time bigint, temp float8, tag integer, color integer); SELECT create_hypertable('chunk_test_ends', 'time', chunk_time_interval => 5); INSERT INTO chunk_test_ends VALUES ((-9223372036854775808)::bigint, 23.1, 11233, 1); INSERT INTO chunk_test_ends VALUES (9223372036854775807::bigint, 24.1, 11233, 1); --try to hit cache INSERT INTO chunk_test_ends VALUES (9223372036854775807::bigint, 24.2, 11233, 1); INSERT INTO chunk_test_ends VALUES (9223372036854775807::bigint, 24.3, 11233, 1), (9223372036854775807::bigint, 24.4, 11233, 1); INSERT INTO chunk_test_ends VALUES ((-9223372036854775808)::bigint, 23.2, 11233, 1); INSERT INTO chunk_test_ends VALUES ((-9223372036854775808)::bigint, 23.3, 11233, 1), ((-9223372036854775808)::bigint, 23.4, 11233, 1); SELECT * FROM chunk_test_ends ORDER BY time asc, tag, temp; --further tests of set_chunk_time_interval CREATE TABLE chunk_test2(time TIMESTAMPTZ, temp float8, tag integer, color integer); SELECT create_hypertable('chunk_test2', 'time', 'tag', 2, chunk_time_interval => 3); SELECT interval_length FROM _timescaledb_catalog.dimension d LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test2' ORDER BY d.id; -- should work since time column is non-INT SELECT set_chunk_time_interval('chunk_test2', INTERVAL '1 minute'); SELECT interval_length FROM _timescaledb_catalog.dimension d LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test2' ORDER BY d.id; -- should still work for non-INT time columns SELECT set_chunk_time_interval('chunk_test2', 1000000); SELECT interval_length FROM _timescaledb_catalog.dimension d LEFT JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.schema_name = 'public' AND h.table_name = 'chunk_test2' ORDER BY d.id; \set ON_ERROR_STOP 0 select set_chunk_time_interval(NULL,NULL::interval); -- should fail since time column is an int SELECT set_chunk_time_interval('chunk_test', INTERVAL '1 minute'); -- should fail since its not a valid way to represent time SELECT set_chunk_time_interval('chunk_test', 'foo'::TEXT); SELECT set_chunk_time_interval('chunk_test', NULL::BIGINT); SELECT set_chunk_time_interval('chunk_test2', NULL::BIGINT); SELECT set_chunk_time_interval('chunk_test2', NULL::INTERVAL); \set ON_ERROR_STOP 1 -- Issue https://github.com/timescale/timescaledb/issues/7406 CREATE TABLE test_ht (time TIMESTAMPTZ, v1 INTEGER); SELECT create_hypertable('test_ht', by_range('time', INTERVAL '1 hour')); CREATE TABLE test_tb (time TIMESTAMPTZ, v1 INTEGER); CREATE OR REPLACE FUNCTION test_tb_trg_insert() RETURNS TRIGGER AS $$ BEGIN INSERT INTO test_ht VALUES (NEW.time, NEW.v1); RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_tb_trg_insert AFTER INSERT ON test_tb FOR EACH ROW EXECUTE FUNCTION test_tb_trg_insert(); -- Creating new chunk inside a trigger called by -- a DDL statement should not fail. CREATE TABLE test_output AS WITH inserted AS ( INSERT INTO test_tb VALUES (NOW(), 1), (NOW(), 2) RETURNING * ) SELECT * FROM inserted; -- Check the DEFAULT REPLICA IDENTITY of the chunks SELECT relname, relreplident FROM show_chunks('test_ht') ch JOIN pg_class c ON (ch = c.oid) ORDER BY relname; -- Clean up TRUNCATE test_ht, test_tb; DROP TABLE test_output; -- Change the DEFAULT REPLICA IDENTITY of the chunks ALTER TABLE test_ht REPLICA IDENTITY FULL; -- Internally we force new chunks have the same REPLICA IDENTITY -- as the parent table. CREATE TABLE test_output AS WITH inserted AS ( INSERT INTO test_tb VALUES (NOW(), 1), (NOW(), 2) RETURNING * ) SELECT * FROM inserted; -- Check current new REPLICA IDENTITY FULL in the chunks SELECT relname, relreplident FROM show_chunks('test_ht') ch JOIN pg_class c ON (ch = c.oid) ORDER BY relname; -- All tables should have the same number of rows SELECT count(*) FROM test_tb; SELECT count(*) FROM test_ht; SELECT count(*) FROM test_output; -- test ALTER TABLE SET (tsdb.chunk_interval) on a hypertable CREATE TABLE t_with(time timestamptz not null, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 't_with'; ALTER TABLE t_with SET (tsdb.chunk_interval = '1 hour'); SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 't_with'; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/create_hypertable.sql���������������������������������������������������0000664�0000000�0000000�00000071640�15100345067�0022044�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER create schema test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; create schema chunk_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER; create table test_schema.test_table(time BIGINT, temp float8, device_id text, device_type text, location text, id int, id2 int); \set ON_ERROR_STOP 0 -- get_create_command should fail since hypertable isn't made yet SELECT * FROM _timescaledb_functions.get_create_command('test_table'); \set ON_ERROR_STOP 1 SELECT * FROM test.relation WHERE schema = 'test_schema'; \d _timescaledb_catalog.chunk create table test_schema.test_table_no_not_null(time BIGINT, device_id text); \set ON_ERROR_STOP 0 -- Permission denied with unprivileged role SET ROLE :ROLE_DEFAULT_PERM_USER_2; select * from create_hypertable('test_schema.test_table_no_not_null', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); -- CREATE on schema is not enough SET ROLE :ROLE_DEFAULT_PERM_USER; GRANT ALL ON SCHEMA test_schema TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; select * from create_hypertable('test_schema.test_table_no_not_null', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 -- Should work with when granted table owner role RESET ROLE; GRANT :ROLE_DEFAULT_PERM_USER TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; select * from create_hypertable('test_schema.test_table_no_not_null', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 0 insert into test_schema.test_table_no_not_null (device_id) VALUES('foo'); \set ON_ERROR_STOP 1 insert into test_schema.test_table_no_not_null (time, device_id) VALUES(1, 'foo'); RESET ROLE; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- No permissions on associated schema should fail select * from create_hypertable('test_schema.test_table', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month'), associated_schema_name => 'chunk_schema'); \set ON_ERROR_STOP 1 -- Granting permissions on chunk_schema should make things work RESET ROLE; GRANT CREATE ON SCHEMA chunk_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; select * from create_hypertable('test_schema.test_table', 'time', 'device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month'), associated_schema_name => 'chunk_schema'); -- Check that the insert block trigger exists SELECT * FROM test.show_triggers('test_schema.test_table'); SELECT * FROM _timescaledb_functions.get_create_command('test_table'); --test adding one more closed dimension select add_dimension('test_schema.test_table', 'location', 4); select * from _timescaledb_catalog.hypertable where table_name = 'test_table'; select * from _timescaledb_catalog.dimension; --test that we can change the number of partitions and that 1 is allowed SELECT set_number_partitions('test_schema.test_table', 1, 'location'); select * from _timescaledb_catalog.dimension WHERE column_name = 'location'; SELECT set_number_partitions('test_schema.test_table', 2, 'location'); select * from _timescaledb_catalog.dimension WHERE column_name = 'location'; \set ON_ERROR_STOP 0 --must give an explicit dimension when there are multiple space dimensions SELECT set_number_partitions('test_schema.test_table', 3); --too few SELECT set_number_partitions('test_schema.test_table', 0, 'location'); -- Too many SELECT set_number_partitions('test_schema.test_table', 32768, 'location'); -- get_create_command only works on tables w/ 1 or 2 dimensions SELECT * FROM _timescaledb_functions.get_create_command('test_table'); \set ON_ERROR_STOP 1 --test adding one more open dimension select add_dimension('test_schema.test_table', 'id', chunk_time_interval => 1000); select * from _timescaledb_catalog.hypertable where table_name = 'test_table'; select * from _timescaledb_catalog.dimension; -- Test add_dimension: can use interval types for TIMESTAMPTZ columns CREATE TABLE dim_test_time(time TIMESTAMPTZ, time2 TIMESTAMPTZ, time3 BIGINT, temp float8, device int, location int); SELECT create_hypertable('dim_test_time', 'time'); SELECT add_dimension('dim_test_time', 'time2', chunk_time_interval => INTERVAL '1 day'); -- Test add_dimension: only integral should work on BIGINT columns \set ON_ERROR_STOP 0 SELECT add_dimension('dim_test_time', 'time3', chunk_time_interval => INTERVAL '1 day'); -- string is not a valid type SELECT add_dimension('dim_test_time', 'time3', chunk_time_interval => 'foo'::TEXT); \set ON_ERROR_STOP 1 SELECT add_dimension('dim_test_time', 'time3', chunk_time_interval => 500); -- Test add_dimension: integrals should work on TIMESTAMPTZ columns CREATE TABLE dim_test_time2(time TIMESTAMPTZ, time2 TIMESTAMPTZ, temp float8, device int, location int); SELECT create_hypertable('dim_test_time2', 'time'); SELECT add_dimension('dim_test_time2', 'time2', chunk_time_interval => 500); --adding a dimension twice should not fail with 'if_not_exists' SELECT add_dimension('dim_test_time2', 'time2', chunk_time_interval => 500, if_not_exists => true); \set ON_ERROR_STOP 0 --adding on a non-hypertable CREATE TABLE not_hypertable(time TIMESTAMPTZ, temp float8, device int, location int); SELECT add_dimension('not_hypertable', 'time', chunk_time_interval => 500); --adding a non-exist column SELECT add_dimension('test_schema.test_table', 'nope', 2); --adding the same dimension twice should fail select add_dimension('test_schema.test_table', 'location', 2); --adding dimension with both number_partitions and chunk_time_interval should fail select add_dimension('test_schema.test_table', 'id2', number_partitions => 2, chunk_time_interval => 1000); \set ON_ERROR_STOP 1 -- test adding a new dimension on a non-empty table CREATE TABLE dim_test(time TIMESTAMPTZ, device int); SELECT create_hypertable('dim_test', 'time', chunk_time_interval => INTERVAL '1 day'); CREATE VIEW dim_test_slices AS SELECT c.id AS chunk_id, c.hypertable_id, ds.dimension_id, cc.dimension_slice_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test' ORDER BY c.id, ds.dimension_id; INSERT INTO dim_test VALUES ('2004-10-10 00:00:00+00', 1); INSERT INTO dim_test VALUES ('2004-10-20 00:00:00+00', 2); SELECT * FROM dim_test_slices; SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_2_chunk'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_3_chunk'); -- add dimension to the existing chunks by adding -inf/inf dimension slices SELECT add_dimension('dim_test', 'device', 2); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_2_chunk'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_5_3_chunk'); SELECT * FROM dim_test_slices; -- newer chunks have proper dimension slices range INSERT INTO dim_test VALUES ('2004-10-30 00:00:00+00', 3); SELECT * FROM dim_test_slices; SELECT * FROM dim_test ORDER BY time; DROP VIEW dim_test_slices; DROP TABLE dim_test; -- test add_dimension() with existing data on table with space partitioning CREATE TABLE dim_test(time TIMESTAMPTZ, device int, data int); SELECT create_hypertable('dim_test', 'time', 'device', 2, chunk_time_interval => INTERVAL '1 day'); CREATE VIEW dim_test_slices AS SELECT c.id AS chunk_id, c.hypertable_id, ds.dimension_id, cc.dimension_slice_id, c.schema_name AS chunk_schema, c.table_name AS chunk_table, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h ON (c.hypertable_id = h.id) INNER JOIN _timescaledb_catalog.dimension td ON (h.id = td.hypertable_id) INNER JOIN _timescaledb_catalog.dimension_slice ds ON (ds.dimension_id = td.id) INNER JOIN _timescaledb_catalog.chunk_constraint cc ON (cc.dimension_slice_id = ds.id AND cc.chunk_id = c.id) WHERE h.table_name = 'dim_test' ORDER BY c.id, ds.dimension_id; INSERT INTO dim_test VALUES ('2004-10-10 00:00:00+00', 1, 3); INSERT INTO dim_test VALUES ('2004-10-20 00:00:00+00', 2, 2); SELECT * FROM dim_test_slices; -- new dimension slice will cover full range on existing chunks SELECT add_dimension('dim_test', 'data', 1); SELECT * FROM dim_test_slices; INSERT INTO dim_test VALUES ('2004-10-30 00:00:00+00', 3, 1); SELECT * FROM dim_test_slices; SELECT * FROM dim_test ORDER BY time; DROP VIEW dim_test_slices; DROP TABLE dim_test; -- should not fail on non-empty table with 'if_not_exists' in case the dimension exists select add_dimension('test_schema.test_table', 'location', 2, if_not_exists => true); --test partitioning in only time dimension create table test_schema.test_1dim(time timestamp, temp float); select create_hypertable('test_schema.test_1dim', 'time'); SELECT * FROM _timescaledb_functions.get_create_command('test_1dim'); SELECT * FROM test.relation WHERE schema = 'test_schema'; select create_hypertable('test_schema.test_1dim', 'time', if_not_exists => true); -- Should error when creating again without if_not_exists set to true \set ON_ERROR_STOP 0 select create_hypertable('test_schema.test_1dim', 'time'); \set ON_ERROR_STOP 1 -- if_not_exist should also work with data in the hypertable insert into test_schema.test_1dim VALUES ('2004-10-19 10:23:54+02', 1.0); select create_hypertable('test_schema.test_1dim', 'time', if_not_exists => true); -- Should error when creating again without if_not_exists set to true \set ON_ERROR_STOP 0 select create_hypertable('test_schema.test_1dim', 'time'); \set ON_ERROR_STOP 1 -- Test partitioning functions CREATE OR REPLACE FUNCTION invalid_partfunc(source integer) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN NULL; END $BODY$; CREATE OR REPLACE FUNCTION time_partfunc(source text) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN timezone('UTC', to_timestamp(source)); END $BODY$; CREATE TABLE test_schema.test_invalid_func(time timestamptz, temp float8, device text); \set ON_ERROR_STOP 0 -- should fail due to invalid signature SELECT create_hypertable('test_schema.test_invalid_func', 'time', 'device', 2, partitioning_func => 'invalid_partfunc'); SELECT create_hypertable('test_schema.test_invalid_func', 'time'); -- should also fail due to invalid signature SELECT add_dimension('test_schema.test_invalid_func', 'device', 2, partitioning_func => 'invalid_partfunc'); \set ON_ERROR_STOP 1 -- Test open-dimension function CREATE TABLE test_schema.open_dim_part_func(time text, temp float8, device text, event_time text); \set ON_ERROR_STOP 0 -- should fail due to invalid signature SELECT create_hypertable('test_schema.open_dim_part_func', 'time', time_partitioning_func => 'invalid_partfunc'); \set ON_ERROR_STOP 1 SELECT create_hypertable('test_schema.open_dim_part_func', 'time', time_partitioning_func => 'time_partfunc'); \set ON_ERROR_STOP 0 -- should fail due to invalid signature SELECT add_dimension('test_schema.open_dim_part_func', 'event_time', chunk_time_interval => interval '1 day', partitioning_func => 'invalid_partfunc'); \set ON_ERROR_STOP 1 SELECT add_dimension('test_schema.open_dim_part_func', 'event_time', chunk_time_interval => interval '1 day', partitioning_func => 'time_partfunc'); --test data migration create table test_schema.test_migrate(time timestamp, temp float); insert into test_schema.test_migrate VALUES ('2004-10-19 10:23:54+02', 1.0), ('2004-12-19 10:23:54+02', 2.0); select * from only test_schema.test_migrate; \set ON_ERROR_STOP 0 --should fail without migrate_data => true select create_hypertable('test_schema.test_migrate', 'time'); \set ON_ERROR_STOP 1 select create_hypertable('test_schema.test_migrate', 'time', migrate_data => true); --there should be two new chunks select * from _timescaledb_catalog.hypertable where table_name = 'test_migrate'; select id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk from _timescaledb_catalog.chunk; select * from test_schema.test_migrate; --main table should now be empty select * from only test_schema.test_migrate; select * from only _timescaledb_internal._hyper_10_9_chunk; select * from only _timescaledb_internal._hyper_10_10_chunk; create table test_schema.test_migrate_empty(time timestamp, temp float); select create_hypertable('test_schema.test_migrate_empty', 'time', migrate_data => true); CREATE TYPE test_type AS (time timestamp, temp float); CREATE TABLE test_table_of_type OF test_type; SELECT create_hypertable('test_table_of_type', 'time'); INSERT INTO test_table_of_type VALUES ('2004-10-19 10:23:54+02', 1.0), ('2004-12-19 10:23:54+02', 2.0); \set ON_ERROR_STOP 0 DROP TYPE test_type; \set ON_ERROR_STOP 1 DROP TYPE test_type CASCADE; CREATE TABLE test_table_of_type (time timestamp, temp float); SELECT create_hypertable('test_table_of_type', 'time'); INSERT INTO test_table_of_type VALUES ('2004-10-19 10:23:54+02', 1.0), ('2004-12-19 10:23:54+02', 2.0); CREATE TYPE test_type AS (time timestamp, temp float); ALTER TABLE test_table_of_type OF test_type; \set ON_ERROR_STOP 0 DROP TYPE test_type; \set ON_ERROR_STOP 1 BEGIN; DROP TYPE test_type CASCADE; ROLLBACK; ALTER TABLE test_table_of_type NOT OF; DROP TYPE test_type; -- Reset GRANTS \c :TEST_DBNAME :ROLE_SUPERUSER REVOKE :ROLE_DEFAULT_PERM_USER FROM :ROLE_DEFAULT_PERM_USER_2; -- Test custom partitioning functions CREATE OR REPLACE FUNCTION partfunc_not_immutable(source anyelement) RETURNS INTEGER LANGUAGE PLPGSQL AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_bad_return_type(source anyelement) RETURNS BIGINT LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_bad_arg_type(source text) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_bad_multi_arg(source anyelement, extra_arg integer) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; CREATE OR REPLACE FUNCTION partfunc_valid(source anyelement) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN _timescaledb_functions.get_partition_hash(source); END $BODY$; create table test_schema.test_partfunc(time timestamptz, temp float, device int); -- Test that create_hypertable fails due to invalid partitioning function \set ON_ERROR_STOP 0 select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_not_immutable'); select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_bad_return_type'); select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_bad_arg_type'); select create_hypertable('test_schema.test_partfunc', 'time', 'device', 2, partitioning_func => 'partfunc_bad_multi_arg'); \set ON_ERROR_STOP 1 -- Test that add_dimension fails due to invalid partitioning function select create_hypertable('test_schema.test_partfunc', 'time'); \set ON_ERROR_STOP 0 select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_not_immutable'); select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_bad_return_type'); select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_bad_arg_type'); select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_bad_multi_arg'); \set ON_ERROR_STOP 1 -- A valid function should work: select add_dimension('test_schema.test_partfunc', 'device', 2, partitioning_func => 'partfunc_valid'); -- check get_create_command produces valid command CREATE TABLE test_schema.test_sql_cmd(time TIMESTAMPTZ, temp FLOAT8, device_id TEXT, device_type TEXT, location TEXT, id INT, id2 INT); SELECT create_hypertable('test_schema.test_sql_cmd','time'); SELECT * FROM _timescaledb_functions.get_create_command('test_sql_cmd'); SELECT _timescaledb_functions.get_create_command('test_sql_cmd') AS create_cmd; \gset DROP TABLE test_schema.test_sql_cmd CASCADE; CREATE TABLE test_schema.test_sql_cmd(time TIMESTAMPTZ, temp FLOAT8, device_id TEXT, device_type TEXT, location TEXT, id INT, id2 INT); SELECT test.execute_sql(:'create_cmd'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_table_int(time bigint, junk int); SELECT hypertable_id AS "TEST_TABLE_INT_HYPERTABLE_ID" FROM create_hypertable('test_table_int', 'time', chunk_time_interval => 1) \gset \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_schema; create or replace function my_schema.dummy_now2() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; grant execute on ALL FUNCTIONS IN SCHEMA my_schema to public; create or replace function dummy_now3() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; grant execute on ALL FUNCTIONS IN SCHEMA my_schema to public; REVOKE execute ON function dummy_now3() FROM PUBLIC; CREATE SCHEMA IF NOT EXISTS my_user_schema; GRANT ALL ON SCHEMA my_user_schema to PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER create or replace function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; create or replace function my_user_schema.dummy_now4() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; select set_integer_now_func('test_table_int', 'dummy_now'); select * from _timescaledb_catalog.dimension WHERE hypertable_id = :TEST_TABLE_INT_HYPERTABLE_ID; -- show chunks works with "created_before" and errors out with time used in "older_than" SELECT SHOW_CHUNKS('test_table_int', older_than => 10); SELECT SHOW_CHUNKS('test_table_int', created_before => now()); \set ON_ERROR_STOP 0 SELECT SHOW_CHUNKS('test_table_int', older_than => now()); select set_integer_now_func('test_table_int', 'dummy_now'); select set_integer_now_func('test_table_int', 'my_schema.dummy_now2', replace_if_exists => TRUE); select set_integer_now_func('test_table_int', 'dummy_now3', replace_if_exists => TRUE); -- test invalid oid as the integer_now_func select set_integer_now_func('test_table_int', 1, replace_if_exists => TRUE); \set ON_ERROR_STOP select set_integer_now_func('test_table_int', 'my_user_schema.dummy_now4', replace_if_exists => TRUE); \c :TEST_DBNAME :ROLE_SUPERUSER ALTER SCHEMA my_user_schema RENAME TO my_new_schema; select * from _timescaledb_catalog.dimension WHERE hypertable_id = :TEST_TABLE_INT_HYPERTABLE_ID; -- github issue #4650 CREATE TABLE sample_table ( cpu double precision null, time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, name varchar(100) default 'this is a default string value', UNIQUE(sensor_id, time) ); ALTER TABLE sample_table DROP COLUMN name; -- below creation should not report any warnings. SELECT * FROM create_hypertable('sample_table', 'time'); -- cleanup DROP TABLE sample_table CASCADE; -- github issue 4684 -- test PARTITION BY HASH CREATE TABLE regular( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_regular_pky PRIMARY KEY (id) ) PARTITION BY HASH (id); DO $$ BEGIN FOR i IN 1..2 LOOP EXECUTE format(' CREATE TABLE %I PARTITION OF regular FOR VALUES WITH (MODULUS 2, REMAINDER %s)', 'regular_' || i, i - 1 ); END LOOP; END; $$; INSERT INTO regular SELECT generate_series(1,1000), 44,55; CREATE TABLE timescale ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES regular(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'timescale', time_column_name => 'ts' ); -- creates chunk1 INSERT INTO timescale SELECT now(), generate_series(1,200), 43; -- creates chunk2 INSERT INTO timescale SELECT now() + interval '20' day, generate_series(1,200), 43; -- creates chunk3 INSERT INTO timescale SELECT now() + interval '40' day, generate_series(1,200), 43; -- show chunks SELECT SHOW_CHUNKS('timescale'); \set ON_ERROR_STOP 0 -- record goes into chunk1 violating FK constraint as value 1001 is not present in regular table INSERT INTO timescale SELECT now(), 1001, 43; -- record goes into chunk2 violating FK constraint as value 1002 is not present in regular table INSERT INTO timescale SELECT now() + interval '20' day, 1002, 43; -- record goes into chunk3 violating FK constraint as value 1003 is not present in regular table INSERT INTO timescale SELECT now() + interval '40' day, 1003, 43; \set ON_ERROR_STOP 1 -- cleanup DROP TABLE regular cascade; DROP TABLE timescale cascade; -- test PARTITION BY RANGE CREATE TABLE regular( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_regular_pky PRIMARY KEY (id) ) PARTITION BY RANGE (id); CREATE TABLE regular_1_500 PARTITION OF regular FOR VALUES FROM (1) TO (500); CREATE TABLE regular_500_1000 PARTITION OF regular FOR VALUES FROM (500) TO (801); INSERT INTO regular SELECT generate_series(1,800), 44,55; CREATE TABLE timescale ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES regular(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'timescale', time_column_name => 'ts' ); -- creates chunk1 INSERT INTO timescale SELECT now(), generate_series(1,200), 43; -- creates chunk2 INSERT INTO timescale SELECT now() + interval '20' day, generate_series(200,400), 43; -- creates chunk3 INSERT INTO timescale SELECT now() + interval '40' day, generate_series(400,600), 43; -- show chunks SELECT SHOW_CHUNKS('timescale'); \set ON_ERROR_STOP 0 -- FK constraint violation as value 801 is not present in regular table INSERT INTO timescale SELECT now(), 801, 43; -- FK constraint violation as value 902 is not present in regular table INSERT INTO timescale SELECT now() + interval '20' day, 902, 43; -- FK constraint violation as value 1003 is not present in regular table INSERT INTO timescale SELECT now() + interval '40' day, 1003, 43; \set ON_ERROR_STOP 1 -- cleanup DROP TABLE regular cascade; DROP TABLE timescale cascade; -- test PARTITION BY LIST CREATE TABLE regular( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_regular_pky PRIMARY KEY (id) ) PARTITION BY LIST (id); CREATE TABLE regular_1_2_3_4 PARTITION OF regular FOR VALUES IN (1,2,3,4); CREATE TABLE regular_5_6_7_8 PARTITION OF regular FOR VALUES IN (5,6,7,8); INSERT INTO regular SELECT generate_series(1,8), 44,55; CREATE TABLE timescale ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES regular(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'timescale', time_column_name => 'ts' ); insert into timescale values (now(), 1,2); insert into timescale values (now(), 2,2); insert into timescale values (now(), 3,2); insert into timescale values (now(), 4,2); insert into timescale values (now(), 5,2); insert into timescale values (now(), 6,2); insert into timescale values (now(), 7,2); insert into timescale values (now(), 8,2); \set ON_ERROR_STOP 0 -- FK constraint violation as value 9 is not present in regular table insert into timescale values (now(), 9,2); -- FK constraint violation as value 10 is not present in regular table insert into timescale values (now(), 10,2); -- FK constraint violation as value 111 is not present in regular table insert into timescale values (now(), 111,2); \set ON_ERROR_STOP 1 -- cleanup DROP TABLE regular cascade; DROP TABLE timescale cascade; -- github issue 4872 -- If subplan of ChunkAppend is TidRangeScan, then SELECT on -- hypertable fails with error "invalid child of chunk append: Node (26)" create table tidrangescan_test ( time timestamp with time zone, some_column bigint ); select create_hypertable('tidrangescan_test', 'time'); insert into tidrangescan_test (time, some_column) values ('2023-02-12 00:00:00+02:40', 1); insert into tidrangescan_test (time, some_column) values ('2023-02-12 00:00:10+02:40', 2); insert into tidrangescan_test (time, some_column) values ('2023-02-12 00:00:20+02:40', 3); -- Below query will generate plan as -- Custom Scan (ChunkAppend) -- -> Tid Range Scan -- However when traversing ChunkAppend node, Tid Range Scan node is not -- recognised as a valid child node of ChunkAppend which causes error -- "invalid child of chunk append: Node (26)" when below query is executed select * from tidrangescan_test where time > '2023-02-12 00:00:00+02:40'::timestamp with time zone - interval '5 years' and ctid < '(1,1)'::tid ORDER BY time; drop table tidrangescan_test; \set VERBOSITY default set client_min_messages = WARNING; -- test creating a hypertable from table referenced by a foreign key fails with -- error "cannot have FOREIGN KEY constraints to hypertable". create table test_schema.fk_parent(time timestamptz, id int, unique(time, id)); create table test_schema.fk_child( time timestamptz, id int, foreign key (time, id) references test_schema.fk_parent(time, id) ); select create_hypertable ('test_schema.fk_child', 'time'); \set ON_ERROR_STOP 0 select create_hypertable ('test_schema.fk_parent', 'time'); \set ON_ERROR_STOP 1 -- create default indexes on chunks when migrating data CREATE TABLE test(time TIMESTAMPTZ, val BIGINT); CREATE INDEX test_val_idx ON test(val); INSERT INTO test VALUES('2024-01-01 00:00:00-03', 500); SELECT FROM create_hypertable('test', 'time', migrate_data=>TRUE); -- should return ALL indexes for hypertable and chunk SELECT * FROM test.show_indexes('test') ORDER BY 1; SELECT * FROM show_chunks('test') ch, LATERAL test.show_indexes(ch) ORDER BY 1, 2; DROP TABLE test; -- don't create default indexes on chunks when migrating data CREATE TABLE test(time TIMESTAMPTZ, val BIGINT); CREATE INDEX test_val_idx ON test(val); INSERT INTO test VALUES('2024-01-01 00:00:00-03', 500); SELECT FROM create_hypertable('test', 'time', create_default_indexes => FALSE, migrate_data=>TRUE); -- should NOT return default indexes for hypertable and chunk -- only user indexes should be returned SELECT * FROM test.show_indexes('test') ORDER BY 1; SELECT * FROM show_chunks('test') ch, LATERAL test.show_indexes(ch) ORDER BY 1, 2; DROP TABLE test; -- test creating a hypertable with a primary key where the partitioning column is not part of the primary key CREATE TABLE test_schema.partition_not_pk (id INT NOT NULL, device_id INT NOT NULL, time TIMESTAMPTZ NOT NULL, a TEXT NOT NULL, PRIMARY KEY (id)); \set ON_ERROR_STOP 0 select create_hypertable ('test_schema.partition_not_pk', 'time'); \set ON_ERROR_STOP 1 DROP TABLE test_schema.partition_not_pk; -- test creating a hypertable with a composite key where the partitioning column is not part of the composite key CREATE TABLE test_schema.partition_not_pk (id INT NOT NULL, device_id INT NOT NULL, time TIMESTAMPTZ NOT NULL, a TEXT NOT NULL, PRIMARY KEY (id, device_id)); \set ON_ERROR_STOP 0 select create_hypertable ('test_schema.partition_not_pk', 'time'); \set ON_ERROR_STOP 1 DROP TABLE test_schema.partition_not_pk; -- test hypertable is not created for a table that is a part of a publication explicitly SET client_min_messages = ERROR; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); CREATE PUBLICATION publication_test; ALTER PUBLICATION publication_test ADD TABLE test; \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); \set ON_ERROR_STOP 1 INSERT INTO test (timestamp) values (now()); ALTER PUBLICATION publication_test DROP TABLE test; DROP PUBLICATION publication_test; DROP TABLE test; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); CREATE PUBLICATION publication_test1; CREATE PUBLICATION publication_test2; ALTER PUBLICATION publication_test1 ADD TABLE test; ALTER PUBLICATION publication_test2 ADD TABLE test; \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); \set ON_ERROR_STOP 1 INSERT INTO test (timestamp) values (now()); ALTER PUBLICATION publication_test1 DROP TABLE test; ALTER PUBLICATION publication_test2 DROP TABLE test; DROP PUBLICATION publication_test1; DROP PUBLICATION publication_test2; DROP TABLE test; -- test hypertable is not created for a table that is a part of a publication implicitly CREATE PUBLICATION publication_test FOR ALL tables; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); \set ON_ERROR_STOP 1 DROP PUBLICATION publication_test; DROP TABLE test; CREATE TABLE test (timestamp TIMESTAMPTZ NOT NULL); CREATE PUBLICATION publication_test FOR ALL tables; \set ON_ERROR_STOP 0 SELECT create_hypertable('test', 'timestamp'); \set ON_ERROR_STOP 1 DROP PUBLICATION publication_test; DROP TABLE test; RESET client_min_messages; ������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/create_table.sql��������������������������������������������������������0000664�0000000�0000000�00000002751�15100345067�0020771�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that we can verify constraints on regular tables CREATE TABLE test_hyper_pk(time TIMESTAMPTZ PRIMARY KEY, temp FLOAT, device INT); CREATE TABLE test_pk(device INT PRIMARY KEY); CREATE TABLE test_like(LIKE test_pk); SELECT create_hypertable('test_hyper_pk', 'time'); \set ON_ERROR_STOP 0 -- Foreign key constraints that reference hypertables are currently unsupported CREATE TABLE test_fk(time TIMESTAMPTZ REFERENCES test_hyper_pk(time)); \set ON_ERROR_STOP 1 CREATE TABLE test_delete(time timestamp with time zone PRIMARY KEY, temp float); SELECT create_hypertable('test_delete', 'time'); INSERT INTO test_delete VALUES('2017-01-20T09:00:01', 22.5); INSERT INTO test_delete VALUES('2017-01-20T09:00:21', 21.2); INSERT INTO test_delete VALUES('2017-01-20T09:00:47', 25.1); INSERT INTO test_delete VALUES('2020-01-20T09:00:47', 25.1); INSERT INTO test_delete VALUES('2021-01-20T09:00:47', 25.1); SELECT * FROM test_delete WHERE temp = 25.1 ORDER BY time; CREATE OR replace FUNCTION test_delete_row_count() RETURNS void AS $$ DECLARE v_cnt numeric; BEGIN v_cnt := 0; DELETE FROM test_delete WHERE temp = 25.1; GET DIAGNOSTICS v_cnt = ROW_COUNT; IF v_cnt != 3 THEN RAISE EXCEPTION 'unexpected result'; END IF; END; $$ LANGUAGE plpgsql; SELECT test_delete_row_count(); �����������������������timescaledb-2.23.0/test/sql/create_table_with.sql���������������������������������������������������0000664�0000000�0000000�00000023227�15100345067�0022025�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- our user needs permission to create schema for the schema tests \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :TEST_DBNAME TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- create table with non-tsdb option should not be affected CREATE TABLE t1(time timestamptz, device text, value float) WITH (autovacuum_enabled); DROP TABLE t1; -- test error cases \set ON_ERROR_STOP 0 \set VERBOSITY default CREATE TABLE t2(time float, device text, value float) WITH (tsdb.hypertable); CREATE TABLE t2(time float, device text, value float) WITH (timescaledb.hypertable); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=NULL); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=''); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='foo'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.partition_column='time'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (timescaledb.partition_column='time'); CREATE TABLE t2(time timestamptz , device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='foo'); CREATE TABLE t2(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes='time'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=2); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=-1); CREATE TABLE t2(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=true); CREATE TABLE t2(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore,tsdb.hypertable,tsdb.partition_column='time'); -- Test error hint for invalid timescaledb options during CREATE TABLE CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.invalid_option = true); CREATE TABLE t2(time timestamptz, device text, value float) WITH (timescaledb.nonexistent_param = false); \set ON_ERROR_STOP 1 \set VERBOSITY terse BEGIN; CREATE TABLE t3(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE t4(time timestamp, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,timescaledb.partition_column='time'); CREATE TABLE t5(time date, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',autovacuum_enabled); CREATE TABLE t6(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,timescaledb.hypertable,tsdb.partition_column='time'); CREATE TABLE t7(time timestamptz, device text, value float) WITH (timescaledb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; ROLLBACK; -- IF NOT EXISTS BEGIN; CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; ROLLBACK; -- table won't be converted to hypertable unless it is in the initial CREATE TABLE BEGIN; CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; ROLLBACK; -- chunk_interval BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='8weeks'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamp NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='23 days'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time date NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int2 NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=12); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int4 NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=3453); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int8 NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=32768); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; ROLLBACK; -- create_default_indexes BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL PRIMARY KEY, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL UNIQUE, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=true); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=false); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; -- associated_schema BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; ROLLBACK; BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; ROLLBACK; BEGIN; CREATE SCHEMA abc2; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc2'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc2'::regnamespace ORDER BY 1; ROLLBACK; -- associated_table_prefix BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; ROLLBACK; BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.columnstore=false,tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc', tsdb.associated_table_prefix='tbl_prefix'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; INSERT INTO t12 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; ROLLBACK; -- default partition column BEGIN; CREATE TABLE t13(time timestamptz, device text, value float) WITH (tsdb.hypertable); CREATE TABLE t14("TiMe" timestamptz, device text, value float) WITH (tsdb.hypertable); SELECT hypertable_name, column_name FROM timescaledb_information.dimensions WHERE hypertable_name IN ('t13','t14') ORDER BY 1; ROLLBACK; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/cursor.sql��������������������������������������������������������������0000664�0000000�0000000�00000002664�15100345067�0017677�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE cursor_test(time timestamptz, device_id int, temp float); SELECT create_hypertable('cursor_test','time'); INSERT INTO cursor_test SELECT '2000-01-01',1,0.5; INSERT INTO cursor_test SELECT '2001-01-01',1,0.5; INSERT INTO cursor_test SELECT '2002-01-01',1,0.5; \set ON_ERROR_STOP 0 BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test; FETCH NEXT FROM c1; -- this will produce an error on PG < 14 because PostgreSQL checks -- for the existence of a scan node with the relation id for every relation -- used in the update plan in the plan of the cursor. UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; COMMIT; -- test cursor with no chunks left after runtime exclusion BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test WHERE time > now(); UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; COMMIT; -- test cursor with no chunks left after planning exclusion BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test WHERE time > '2010-01-01'; UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; COMMIT; \set ON_ERROR_STOP 1 SET timescaledb.enable_constraint_exclusion TO off; BEGIN; DECLARE c1 SCROLL CURSOR FOR SELECT * FROM cursor_test; FETCH NEXT FROM c1; UPDATE cursor_test SET temp = 0.7 WHERE CURRENT OF c1; COMMIT; ����������������������������������������������������������������������������timescaledb-2.23.0/test/sql/custom_type.sql���������������������������������������������������������0000664�0000000�0000000�00000005370�15100345067�0020732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages TO WARNING; CREATE OR REPLACE FUNCTION customtype_in(cstring) RETURNS customtype AS 'timestamptz_in' LANGUAGE internal IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_out(customtype) RETURNS cstring AS 'timestamptz_out' LANGUAGE internal IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_recv(internal) RETURNS customtype AS 'timestamptz_recv' LANGUAGE internal IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_send(customtype) RETURNS bytea AS 'timestamptz_send' LANGUAGE internal IMMUTABLE STRICT; SET client_min_messages TO DEFAULT; CREATE TYPE customtype ( INPUT = customtype_in, OUTPUT = customtype_out, RECEIVE = customtype_recv, SEND = customtype_send, LIKE = TIMESTAMPTZ ); CREATE CAST (customtype AS bigint) WITHOUT FUNCTION AS ASSIGNMENT; CREATE CAST (bigint AS customtype) WITHOUT FUNCTION AS IMPLICIT; CREATE CAST (customtype AS timestamptz) WITHOUT FUNCTION AS ASSIGNMENT; CREATE CAST (timestamptz AS customtype) WITHOUT FUNCTION AS ASSIGNMENT; CREATE OR REPLACE FUNCTION customtype_lt(customtype, customtype) RETURNS bool AS 'timestamp_lt' LANGUAGE internal IMMUTABLE STRICT; CREATE OPERATOR < ( LEFTARG = customtype, RIGHTARG = customtype, PROCEDURE = customtype_lt, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OR REPLACE FUNCTION customtype_ge(customtype, customtype) RETURNS bool AS 'timestamp_ge' LANGUAGE internal IMMUTABLE STRICT; CREATE OPERATOR >= ( LEFTARG = customtype, RIGHTARG = customtype, PROCEDURE = customtype_ge, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE customtype_test(time_custom customtype, val int); \set ON_ERROR_STOP 0 -- Using interval type for chunk time interval should fail with custom time type SELECT create_hypertable('customtype_test', 'time_custom', chunk_time_interval => INTERVAL '1 day', create_default_indexes=>false); \set ON_ERROR_STOP 1 SELECT create_hypertable('customtype_test', 'time_custom', chunk_time_interval => 10e6::bigint, create_default_indexes=>false); INSERT INTO customtype_test VALUES ('2001-01-01 01:02:03'::customtype, 10); INSERT INTO customtype_test VALUES ('2001-01-01 01:02:03'::customtype, 10); INSERT INTO customtype_test VALUES ('2001-01-01 01:02:03'::customtype, 10); EXPLAIN (buffers off, costs off) SELECT * FROM customtype_test; INSERT INTO customtype_test VALUES ('2001-01-01 01:02:23'::customtype, 11); EXPLAIN (buffers off, costs off) SELECT * FROM customtype_test; SELECT * FROM customtype_test; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/�������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016542�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/alter.tsv����������������������������������������������������������0000664�0000000�0000000�00000000110�15100345067�0020377�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������2017-08-22T09:19:22 21.4 3 nr1 n2r1 2017-08-23T09:20:17 31.5 2 nr2 n2r2 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/copy_data.csv������������������������������������������������������0000664�0000000�0000000�00000001033�15100345067�0021217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������generate_series,random 1,0.951734602451324 2,0.717823888640851 3,0.543408489786088 4,0.641131274402142 5,0.12689296528697 6,0.0126486560329795 7,0.213605496101081 8,0.132784110959619 9,0.381155731156468 10,0.284836102742702 11,0.795640022493899 12,0.631451691035181 13,0.0958626130595803 14,0.929304684977978 15,0.524866581428796 16,0.919249163009226 17,0.878917074296623 18,0.68551931809634 19,0.594833800103515 20,0.819584367796779 21,0.474171321373433 22,0.938535195309669 23,0.333933369256556 24,0.274582070298493 25,0.602348630782217 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/ds1_dev1_1.tsv�����������������������������������������������������0000664�0000000�0000000�00000000372�15100345067�0021130�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������1257894000000000000 dev1 1.5 1 2 true 1257894000000000000 dev1 1.5 2 1257894000000001000 dev1 2.5 3 1257894001000000000 dev1 3.5 4 1257897600000000000 dev1 4.5 5 false 1257894002000000000 dev1 5.5 6 true 1257894002000000000 dev1 5.5 7 false ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/onek.data����������������������������������������������������������0000664�0000000�0000000�00000161674�15100345067�0020350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������147 0 1 3 7 7 7 47 147 147 147 14 15 RFAAAA AAAAAA AAAAxx 931 1 1 3 1 11 1 31 131 431 931 2 3 VJAAAA BAAAAA HHHHxx 714 2 0 2 4 14 4 14 114 214 714 8 9 MBAAAA CAAAAA OOOOxx 711 3 1 3 1 11 1 11 111 211 711 2 3 JBAAAA DAAAAA VVVVxx 883 4 1 3 3 3 3 83 83 383 883 6 7 ZHAAAA EAAAAA AAAAxx 439 5 1 3 9 19 9 39 39 439 439 18 19 XQAAAA FAAAAA HHHHxx 670 6 0 2 0 10 0 70 70 170 670 0 1 UZAAAA GAAAAA OOOOxx 543 7 1 3 3 3 3 43 143 43 543 6 7 XUAAAA HAAAAA VVVVxx 425 8 1 1 5 5 5 25 25 425 425 10 11 JQAAAA IAAAAA AAAAxx 800 9 0 0 0 0 0 0 0 300 800 0 1 UEAAAA JAAAAA HHHHxx 489 10 1 1 9 9 9 89 89 489 489 18 19 VSAAAA KAAAAA OOOOxx 494 11 0 2 4 14 4 94 94 494 494 8 9 ATAAAA LAAAAA VVVVxx 880 12 0 0 0 0 0 80 80 380 880 0 1 WHAAAA MAAAAA AAAAxx 611 13 1 3 1 11 1 11 11 111 611 2 3 NXAAAA NAAAAA HHHHxx 226 14 0 2 6 6 6 26 26 226 226 12 13 SIAAAA OAAAAA OOOOxx 774 15 0 2 4 14 4 74 174 274 774 8 9 UDAAAA PAAAAA VVVVxx 298 16 0 2 8 18 8 98 98 298 298 16 17 MLAAAA QAAAAA AAAAxx 682 17 0 2 2 2 2 82 82 182 682 4 5 GAAAAA RAAAAA HHHHxx 864 18 0 0 4 4 4 64 64 364 864 8 9 GHAAAA SAAAAA OOOOxx 183 19 1 3 3 3 3 83 183 183 183 6 7 BHAAAA TAAAAA VVVVxx 885 20 1 1 5 5 5 85 85 385 885 10 11 BIAAAA UAAAAA AAAAxx 997 21 1 1 7 17 7 97 197 497 997 14 15 JMAAAA VAAAAA HHHHxx 966 22 0 2 6 6 6 66 166 466 966 12 13 ELAAAA WAAAAA OOOOxx 389 23 1 1 9 9 9 89 189 389 389 18 19 ZOAAAA XAAAAA VVVVxx 846 24 0 2 6 6 6 46 46 346 846 12 13 OGAAAA YAAAAA AAAAxx 206 25 0 2 6 6 6 6 6 206 206 12 13 YHAAAA ZAAAAA HHHHxx 239 26 1 3 9 19 9 39 39 239 239 18 19 FJAAAA ABAAAA OOOOxx 365 27 1 1 5 5 5 65 165 365 365 10 11 BOAAAA BBAAAA VVVVxx 204 28 0 0 4 4 4 4 4 204 204 8 9 WHAAAA CBAAAA AAAAxx 690 29 0 2 0 10 0 90 90 190 690 0 1 OAAAAA DBAAAA HHHHxx 69 30 1 1 9 9 9 69 69 69 69 18 19 RCAAAA EBAAAA OOOOxx 358 31 0 2 8 18 8 58 158 358 358 16 17 UNAAAA FBAAAA VVVVxx 269 32 1 1 9 9 9 69 69 269 269 18 19 JKAAAA GBAAAA AAAAxx 663 33 1 3 3 3 3 63 63 163 663 6 7 NZAAAA HBAAAA HHHHxx 608 34 0 0 8 8 8 8 8 108 608 16 17 KXAAAA IBAAAA OOOOxx 398 35 0 2 8 18 8 98 198 398 398 16 17 IPAAAA JBAAAA VVVVxx 330 36 0 2 0 10 0 30 130 330 330 0 1 SMAAAA KBAAAA AAAAxx 529 37 1 1 9 9 9 29 129 29 529 18 19 JUAAAA LBAAAA HHHHxx 555 38 1 3 5 15 5 55 155 55 555 10 11 JVAAAA MBAAAA OOOOxx 746 39 0 2 6 6 6 46 146 246 746 12 13 SCAAAA NBAAAA VVVVxx 558 40 0 2 8 18 8 58 158 58 558 16 17 MVAAAA OBAAAA AAAAxx 574 41 0 2 4 14 4 74 174 74 574 8 9 CWAAAA PBAAAA HHHHxx 343 42 1 3 3 3 3 43 143 343 343 6 7 FNAAAA QBAAAA OOOOxx 120 43 0 0 0 0 0 20 120 120 120 0 1 QEAAAA RBAAAA VVVVxx 461 44 1 1 1 1 1 61 61 461 461 2 3 TRAAAA SBAAAA AAAAxx 754 45 0 2 4 14 4 54 154 254 754 8 9 ADAAAA TBAAAA HHHHxx 772 46 0 0 2 12 2 72 172 272 772 4 5 SDAAAA UBAAAA OOOOxx 749 47 1 1 9 9 9 49 149 249 749 18 19 VCAAAA VBAAAA VVVVxx 386 48 0 2 6 6 6 86 186 386 386 12 13 WOAAAA WBAAAA AAAAxx 9 49 1 1 9 9 9 9 9 9 9 18 19 JAAAAA XBAAAA HHHHxx 771 50 1 3 1 11 1 71 171 271 771 2 3 RDAAAA YBAAAA OOOOxx 470 51 0 2 0 10 0 70 70 470 470 0 1 CSAAAA ZBAAAA VVVVxx 238 52 0 2 8 18 8 38 38 238 238 16 17 EJAAAA ACAAAA AAAAxx 86 53 0 2 6 6 6 86 86 86 86 12 13 IDAAAA BCAAAA HHHHxx 56 54 0 0 6 16 6 56 56 56 56 12 13 ECAAAA CCAAAA OOOOxx 767 55 1 3 7 7 7 67 167 267 767 14 15 NDAAAA DCAAAA VVVVxx 363 56 1 3 3 3 3 63 163 363 363 6 7 ZNAAAA ECAAAA AAAAxx 655 57 1 3 5 15 5 55 55 155 655 10 11 FZAAAA FCAAAA HHHHxx 394 58 0 2 4 14 4 94 194 394 394 8 9 EPAAAA GCAAAA OOOOxx 223 59 1 3 3 3 3 23 23 223 223 6 7 PIAAAA HCAAAA VVVVxx 946 60 0 2 6 6 6 46 146 446 946 12 13 KKAAAA ICAAAA AAAAxx 863 61 1 3 3 3 3 63 63 363 863 6 7 FHAAAA JCAAAA HHHHxx 913 62 1 1 3 13 3 13 113 413 913 6 7 DJAAAA KCAAAA OOOOxx 737 63 1 1 7 17 7 37 137 237 737 14 15 JCAAAA LCAAAA VVVVxx 65 64 1 1 5 5 5 65 65 65 65 10 11 NCAAAA MCAAAA AAAAxx 251 65 1 3 1 11 1 51 51 251 251 2 3 RJAAAA NCAAAA HHHHxx 686 66 0 2 6 6 6 86 86 186 686 12 13 KAAAAA OCAAAA OOOOxx 971 67 1 3 1 11 1 71 171 471 971 2 3 JLAAAA PCAAAA VVVVxx 775 68 1 3 5 15 5 75 175 275 775 10 11 VDAAAA QCAAAA AAAAxx 577 69 1 1 7 17 7 77 177 77 577 14 15 FWAAAA RCAAAA HHHHxx 830 70 0 2 0 10 0 30 30 330 830 0 1 YFAAAA SCAAAA OOOOxx 787 71 1 3 7 7 7 87 187 287 787 14 15 HEAAAA TCAAAA VVVVxx 898 72 0 2 8 18 8 98 98 398 898 16 17 OIAAAA UCAAAA AAAAxx 588 73 0 0 8 8 8 88 188 88 588 16 17 QWAAAA VCAAAA HHHHxx 872 74 0 0 2 12 2 72 72 372 872 4 5 OHAAAA WCAAAA OOOOxx 397 75 1 1 7 17 7 97 197 397 397 14 15 HPAAAA XCAAAA VVVVxx 51 76 1 3 1 11 1 51 51 51 51 2 3 ZBAAAA YCAAAA AAAAxx 381 77 1 1 1 1 1 81 181 381 381 2 3 ROAAAA ZCAAAA HHHHxx 632 78 0 0 2 12 2 32 32 132 632 4 5 IYAAAA ADAAAA OOOOxx 31 79 1 3 1 11 1 31 31 31 31 2 3 FBAAAA BDAAAA VVVVxx 855 80 1 3 5 15 5 55 55 355 855 10 11 XGAAAA CDAAAA AAAAxx 699 81 1 3 9 19 9 99 99 199 699 18 19 XAAAAA DDAAAA HHHHxx 562 82 0 2 2 2 2 62 162 62 562 4 5 QVAAAA EDAAAA OOOOxx 681 83 1 1 1 1 1 81 81 181 681 2 3 FAAAAA FDAAAA VVVVxx 585 84 1 1 5 5 5 85 185 85 585 10 11 NWAAAA GDAAAA AAAAxx 35 85 1 3 5 15 5 35 35 35 35 10 11 JBAAAA HDAAAA HHHHxx 962 86 0 2 2 2 2 62 162 462 962 4 5 ALAAAA IDAAAA OOOOxx 282 87 0 2 2 2 2 82 82 282 282 4 5 WKAAAA JDAAAA VVVVxx 254 88 0 2 4 14 4 54 54 254 254 8 9 UJAAAA KDAAAA AAAAxx 514 89 0 2 4 14 4 14 114 14 514 8 9 UTAAAA LDAAAA HHHHxx 406 90 0 2 6 6 6 6 6 406 406 12 13 QPAAAA MDAAAA OOOOxx 544 91 0 0 4 4 4 44 144 44 544 8 9 YUAAAA NDAAAA VVVVxx 704 92 0 0 4 4 4 4 104 204 704 8 9 CBAAAA ODAAAA AAAAxx 948 93 0 0 8 8 8 48 148 448 948 16 17 MKAAAA PDAAAA HHHHxx 412 94 0 0 2 12 2 12 12 412 412 4 5 WPAAAA QDAAAA OOOOxx 200 95 0 0 0 0 0 0 0 200 200 0 1 SHAAAA RDAAAA VVVVxx 583 96 1 3 3 3 3 83 183 83 583 6 7 LWAAAA SDAAAA AAAAxx 486 97 0 2 6 6 6 86 86 486 486 12 13 SSAAAA TDAAAA HHHHxx 666 98 0 2 6 6 6 66 66 166 666 12 13 QZAAAA UDAAAA OOOOxx 436 99 0 0 6 16 6 36 36 436 436 12 13 UQAAAA VDAAAA VVVVxx 842 100 0 2 2 2 2 42 42 342 842 4 5 KGAAAA WDAAAA AAAAxx 99 101 1 3 9 19 9 99 99 99 99 18 19 VDAAAA XDAAAA HHHHxx 656 102 0 0 6 16 6 56 56 156 656 12 13 GZAAAA YDAAAA OOOOxx 673 103 1 1 3 13 3 73 73 173 673 6 7 XZAAAA ZDAAAA VVVVxx 371 104 1 3 1 11 1 71 171 371 371 2 3 HOAAAA AEAAAA AAAAxx 869 105 1 1 9 9 9 69 69 369 869 18 19 LHAAAA BEAAAA HHHHxx 569 106 1 1 9 9 9 69 169 69 569 18 19 XVAAAA CEAAAA OOOOxx 616 107 0 0 6 16 6 16 16 116 616 12 13 SXAAAA DEAAAA VVVVxx 612 108 0 0 2 12 2 12 12 112 612 4 5 OXAAAA EEAAAA AAAAxx 505 109 1 1 5 5 5 5 105 5 505 10 11 LTAAAA FEAAAA HHHHxx 922 110 0 2 2 2 2 22 122 422 922 4 5 MJAAAA GEAAAA OOOOxx 221 111 1 1 1 1 1 21 21 221 221 2 3 NIAAAA HEAAAA VVVVxx 388 112 0 0 8 8 8 88 188 388 388 16 17 YOAAAA IEAAAA AAAAxx 567 113 1 3 7 7 7 67 167 67 567 14 15 VVAAAA JEAAAA HHHHxx 58 114 0 2 8 18 8 58 58 58 58 16 17 GCAAAA KEAAAA OOOOxx 316 115 0 0 6 16 6 16 116 316 316 12 13 EMAAAA LEAAAA VVVVxx 659 116 1 3 9 19 9 59 59 159 659 18 19 JZAAAA MEAAAA AAAAxx 501 117 1 1 1 1 1 1 101 1 501 2 3 HTAAAA NEAAAA HHHHxx 815 118 1 3 5 15 5 15 15 315 815 10 11 JFAAAA OEAAAA OOOOxx 638 119 0 2 8 18 8 38 38 138 638 16 17 OYAAAA PEAAAA VVVVxx 696 120 0 0 6 16 6 96 96 196 696 12 13 UAAAAA QEAAAA AAAAxx 734 121 0 2 4 14 4 34 134 234 734 8 9 GCAAAA REAAAA HHHHxx 237 122 1 1 7 17 7 37 37 237 237 14 15 DJAAAA SEAAAA OOOOxx 816 123 0 0 6 16 6 16 16 316 816 12 13 KFAAAA TEAAAA VVVVxx 917 124 1 1 7 17 7 17 117 417 917 14 15 HJAAAA UEAAAA AAAAxx 844 125 0 0 4 4 4 44 44 344 844 8 9 MGAAAA VEAAAA HHHHxx 657 126 1 1 7 17 7 57 57 157 657 14 15 HZAAAA WEAAAA OOOOxx 952 127 0 0 2 12 2 52 152 452 952 4 5 QKAAAA XEAAAA VVVVxx 519 128 1 3 9 19 9 19 119 19 519 18 19 ZTAAAA YEAAAA AAAAxx 792 129 0 0 2 12 2 92 192 292 792 4 5 MEAAAA ZEAAAA HHHHxx 275 130 1 3 5 15 5 75 75 275 275 10 11 PKAAAA AFAAAA OOOOxx 319 131 1 3 9 19 9 19 119 319 319 18 19 HMAAAA BFAAAA VVVVxx 487 132 1 3 7 7 7 87 87 487 487 14 15 TSAAAA CFAAAA AAAAxx 945 133 1 1 5 5 5 45 145 445 945 10 11 JKAAAA DFAAAA HHHHxx 584 134 0 0 4 4 4 84 184 84 584 8 9 MWAAAA EFAAAA OOOOxx 765 135 1 1 5 5 5 65 165 265 765 10 11 LDAAAA FFAAAA VVVVxx 814 136 0 2 4 14 4 14 14 314 814 8 9 IFAAAA GFAAAA AAAAxx 359 137 1 3 9 19 9 59 159 359 359 18 19 VNAAAA HFAAAA HHHHxx 548 138 0 0 8 8 8 48 148 48 548 16 17 CVAAAA IFAAAA OOOOxx 811 139 1 3 1 11 1 11 11 311 811 2 3 FFAAAA JFAAAA VVVVxx 531 140 1 3 1 11 1 31 131 31 531 2 3 LUAAAA KFAAAA AAAAxx 104 141 0 0 4 4 4 4 104 104 104 8 9 AEAAAA LFAAAA HHHHxx 33 142 1 1 3 13 3 33 33 33 33 6 7 HBAAAA MFAAAA OOOOxx 404 143 0 0 4 4 4 4 4 404 404 8 9 OPAAAA NFAAAA VVVVxx 995 144 1 3 5 15 5 95 195 495 995 10 11 HMAAAA OFAAAA AAAAxx 408 145 0 0 8 8 8 8 8 408 408 16 17 SPAAAA PFAAAA HHHHxx 93 146 1 1 3 13 3 93 93 93 93 6 7 PDAAAA QFAAAA OOOOxx 794 147 0 2 4 14 4 94 194 294 794 8 9 OEAAAA RFAAAA VVVVxx 833 148 1 1 3 13 3 33 33 333 833 6 7 BGAAAA SFAAAA AAAAxx 615 149 1 3 5 15 5 15 15 115 615 10 11 RXAAAA TFAAAA HHHHxx 333 150 1 1 3 13 3 33 133 333 333 6 7 VMAAAA UFAAAA OOOOxx 357 151 1 1 7 17 7 57 157 357 357 14 15 TNAAAA VFAAAA VVVVxx 999 152 1 3 9 19 9 99 199 499 999 18 19 LMAAAA WFAAAA AAAAxx 515 153 1 3 5 15 5 15 115 15 515 10 11 VTAAAA XFAAAA HHHHxx 685 154 1 1 5 5 5 85 85 185 685 10 11 JAAAAA YFAAAA OOOOxx 692 155 0 0 2 12 2 92 92 192 692 4 5 QAAAAA ZFAAAA VVVVxx 627 156 1 3 7 7 7 27 27 127 627 14 15 DYAAAA AGAAAA AAAAxx 654 157 0 2 4 14 4 54 54 154 654 8 9 EZAAAA BGAAAA HHHHxx 115 158 1 3 5 15 5 15 115 115 115 10 11 LEAAAA CGAAAA OOOOxx 75 159 1 3 5 15 5 75 75 75 75 10 11 XCAAAA DGAAAA VVVVxx 14 160 0 2 4 14 4 14 14 14 14 8 9 OAAAAA EGAAAA AAAAxx 148 161 0 0 8 8 8 48 148 148 148 16 17 SFAAAA FGAAAA HHHHxx 201 162 1 1 1 1 1 1 1 201 201 2 3 THAAAA GGAAAA OOOOxx 862 163 0 2 2 2 2 62 62 362 862 4 5 EHAAAA HGAAAA VVVVxx 634 164 0 2 4 14 4 34 34 134 634 8 9 KYAAAA IGAAAA AAAAxx 589 165 1 1 9 9 9 89 189 89 589 18 19 RWAAAA JGAAAA HHHHxx 142 166 0 2 2 2 2 42 142 142 142 4 5 MFAAAA KGAAAA OOOOxx 545 167 1 1 5 5 5 45 145 45 545 10 11 ZUAAAA LGAAAA VVVVxx 983 168 1 3 3 3 3 83 183 483 983 6 7 VLAAAA MGAAAA AAAAxx 87 169 1 3 7 7 7 87 87 87 87 14 15 JDAAAA NGAAAA HHHHxx 335 170 1 3 5 15 5 35 135 335 335 10 11 XMAAAA OGAAAA OOOOxx 915 171 1 3 5 15 5 15 115 415 915 10 11 FJAAAA PGAAAA VVVVxx 286 172 0 2 6 6 6 86 86 286 286 12 13 ALAAAA QGAAAA AAAAxx 361 173 1 1 1 1 1 61 161 361 361 2 3 XNAAAA RGAAAA HHHHxx 97 174 1 1 7 17 7 97 97 97 97 14 15 TDAAAA SGAAAA OOOOxx 98 175 0 2 8 18 8 98 98 98 98 16 17 UDAAAA TGAAAA VVVVxx 377 176 1 1 7 17 7 77 177 377 377 14 15 NOAAAA UGAAAA AAAAxx 525 177 1 1 5 5 5 25 125 25 525 10 11 FUAAAA VGAAAA HHHHxx 448 178 0 0 8 8 8 48 48 448 448 16 17 GRAAAA WGAAAA OOOOxx 154 179 0 2 4 14 4 54 154 154 154 8 9 YFAAAA XGAAAA VVVVxx 866 180 0 2 6 6 6 66 66 366 866 12 13 IHAAAA YGAAAA AAAAxx 741 181 1 1 1 1 1 41 141 241 741 2 3 NCAAAA ZGAAAA HHHHxx 172 182 0 0 2 12 2 72 172 172 172 4 5 QGAAAA AHAAAA OOOOxx 843 183 1 3 3 3 3 43 43 343 843 6 7 LGAAAA BHAAAA VVVVxx 378 184 0 2 8 18 8 78 178 378 378 16 17 OOAAAA CHAAAA AAAAxx 804 185 0 0 4 4 4 4 4 304 804 8 9 YEAAAA DHAAAA HHHHxx 596 186 0 0 6 16 6 96 196 96 596 12 13 YWAAAA EHAAAA OOOOxx 77 187 1 1 7 17 7 77 77 77 77 14 15 ZCAAAA FHAAAA VVVVxx 572 188 0 0 2 12 2 72 172 72 572 4 5 AWAAAA GHAAAA AAAAxx 444 189 0 0 4 4 4 44 44 444 444 8 9 CRAAAA HHAAAA HHHHxx 47 190 1 3 7 7 7 47 47 47 47 14 15 VBAAAA IHAAAA OOOOxx 274 191 0 2 4 14 4 74 74 274 274 8 9 OKAAAA JHAAAA VVVVxx 40 192 0 0 0 0 0 40 40 40 40 0 1 OBAAAA KHAAAA AAAAxx 339 193 1 3 9 19 9 39 139 339 339 18 19 BNAAAA LHAAAA HHHHxx 13 194 1 1 3 13 3 13 13 13 13 6 7 NAAAAA MHAAAA OOOOxx 878 195 0 2 8 18 8 78 78 378 878 16 17 UHAAAA NHAAAA VVVVxx 53 196 1 1 3 13 3 53 53 53 53 6 7 BCAAAA OHAAAA AAAAxx 939 197 1 3 9 19 9 39 139 439 939 18 19 DKAAAA PHAAAA HHHHxx 928 198 0 0 8 8 8 28 128 428 928 16 17 SJAAAA QHAAAA OOOOxx 886 199 0 2 6 6 6 86 86 386 886 12 13 CIAAAA RHAAAA VVVVxx 267 200 1 3 7 7 7 67 67 267 267 14 15 HKAAAA SHAAAA AAAAxx 105 201 1 1 5 5 5 5 105 105 105 10 11 BEAAAA THAAAA HHHHxx 312 202 0 0 2 12 2 12 112 312 312 4 5 AMAAAA UHAAAA OOOOxx 552 203 0 0 2 12 2 52 152 52 552 4 5 GVAAAA VHAAAA VVVVxx 918 204 0 2 8 18 8 18 118 418 918 16 17 IJAAAA WHAAAA AAAAxx 114 205 0 2 4 14 4 14 114 114 114 8 9 KEAAAA XHAAAA HHHHxx 805 206 1 1 5 5 5 5 5 305 805 10 11 ZEAAAA YHAAAA OOOOxx 875 207 1 3 5 15 5 75 75 375 875 10 11 RHAAAA ZHAAAA VVVVxx 225 208 1 1 5 5 5 25 25 225 225 10 11 RIAAAA AIAAAA AAAAxx 495 209 1 3 5 15 5 95 95 495 495 10 11 BTAAAA BIAAAA HHHHxx 150 210 0 2 0 10 0 50 150 150 150 0 1 UFAAAA CIAAAA OOOOxx 759 211 1 3 9 19 9 59 159 259 759 18 19 FDAAAA DIAAAA VVVVxx 149 212 1 1 9 9 9 49 149 149 149 18 19 TFAAAA EIAAAA AAAAxx 480 213 0 0 0 0 0 80 80 480 480 0 1 MSAAAA FIAAAA HHHHxx 1 214 1 1 1 1 1 1 1 1 1 2 3 BAAAAA GIAAAA OOOOxx 557 215 1 1 7 17 7 57 157 57 557 14 15 LVAAAA HIAAAA VVVVxx 295 216 1 3 5 15 5 95 95 295 295 10 11 JLAAAA IIAAAA AAAAxx 854 217 0 2 4 14 4 54 54 354 854 8 9 WGAAAA JIAAAA HHHHxx 420 218 0 0 0 0 0 20 20 420 420 0 1 EQAAAA KIAAAA OOOOxx 414 219 0 2 4 14 4 14 14 414 414 8 9 YPAAAA LIAAAA VVVVxx 758 220 0 2 8 18 8 58 158 258 758 16 17 EDAAAA MIAAAA AAAAxx 879 221 1 3 9 19 9 79 79 379 879 18 19 VHAAAA NIAAAA HHHHxx 332 222 0 0 2 12 2 32 132 332 332 4 5 UMAAAA OIAAAA OOOOxx 78 223 0 2 8 18 8 78 78 78 78 16 17 ADAAAA PIAAAA VVVVxx 851 224 1 3 1 11 1 51 51 351 851 2 3 TGAAAA QIAAAA AAAAxx 592 225 0 0 2 12 2 92 192 92 592 4 5 UWAAAA RIAAAA HHHHxx 979 226 1 3 9 19 9 79 179 479 979 18 19 RLAAAA SIAAAA OOOOxx 989 227 1 1 9 9 9 89 189 489 989 18 19 BMAAAA TIAAAA VVVVxx 752 228 0 0 2 12 2 52 152 252 752 4 5 YCAAAA UIAAAA AAAAxx 214 229 0 2 4 14 4 14 14 214 214 8 9 GIAAAA VIAAAA HHHHxx 453 230 1 1 3 13 3 53 53 453 453 6 7 LRAAAA WIAAAA OOOOxx 540 231 0 0 0 0 0 40 140 40 540 0 1 UUAAAA XIAAAA VVVVxx 597 232 1 1 7 17 7 97 197 97 597 14 15 ZWAAAA YIAAAA AAAAxx 356 233 0 0 6 16 6 56 156 356 356 12 13 SNAAAA ZIAAAA HHHHxx 720 234 0 0 0 0 0 20 120 220 720 0 1 SBAAAA AJAAAA OOOOxx 367 235 1 3 7 7 7 67 167 367 367 14 15 DOAAAA BJAAAA VVVVxx 762 236 0 2 2 2 2 62 162 262 762 4 5 IDAAAA CJAAAA AAAAxx 986 237 0 2 6 6 6 86 186 486 986 12 13 YLAAAA DJAAAA HHHHxx 924 238 0 0 4 4 4 24 124 424 924 8 9 OJAAAA EJAAAA OOOOxx 779 239 1 3 9 19 9 79 179 279 779 18 19 ZDAAAA FJAAAA VVVVxx 684 240 0 0 4 4 4 84 84 184 684 8 9 IAAAAA GJAAAA AAAAxx 413 241 1 1 3 13 3 13 13 413 413 6 7 XPAAAA HJAAAA HHHHxx 479 242 1 3 9 19 9 79 79 479 479 18 19 LSAAAA IJAAAA OOOOxx 731 243 1 3 1 11 1 31 131 231 731 2 3 DCAAAA JJAAAA VVVVxx 409 244 1 1 9 9 9 9 9 409 409 18 19 TPAAAA KJAAAA AAAAxx 372 245 0 0 2 12 2 72 172 372 372 4 5 IOAAAA LJAAAA HHHHxx 139 246 1 3 9 19 9 39 139 139 139 18 19 JFAAAA MJAAAA OOOOxx 717 247 1 1 7 17 7 17 117 217 717 14 15 PBAAAA NJAAAA VVVVxx 539 248 1 3 9 19 9 39 139 39 539 18 19 TUAAAA OJAAAA AAAAxx 318 249 0 2 8 18 8 18 118 318 318 16 17 GMAAAA PJAAAA HHHHxx 208 250 0 0 8 8 8 8 8 208 208 16 17 AIAAAA QJAAAA OOOOxx 797 251 1 1 7 17 7 97 197 297 797 14 15 REAAAA RJAAAA VVVVxx 661 252 1 1 1 1 1 61 61 161 661 2 3 LZAAAA SJAAAA AAAAxx 50 253 0 2 0 10 0 50 50 50 50 0 1 YBAAAA TJAAAA HHHHxx 102 254 0 2 2 2 2 2 102 102 102 4 5 YDAAAA UJAAAA OOOOxx 484 255 0 0 4 4 4 84 84 484 484 8 9 QSAAAA VJAAAA VVVVxx 108 256 0 0 8 8 8 8 108 108 108 16 17 EEAAAA WJAAAA AAAAxx 140 257 0 0 0 0 0 40 140 140 140 0 1 KFAAAA XJAAAA HHHHxx 996 258 0 0 6 16 6 96 196 496 996 12 13 IMAAAA YJAAAA OOOOxx 687 259 1 3 7 7 7 87 87 187 687 14 15 LAAAAA ZJAAAA VVVVxx 241 260 1 1 1 1 1 41 41 241 241 2 3 HJAAAA AKAAAA AAAAxx 923 261 1 3 3 3 3 23 123 423 923 6 7 NJAAAA BKAAAA HHHHxx 500 262 0 0 0 0 0 0 100 0 500 0 1 GTAAAA CKAAAA OOOOxx 536 263 0 0 6 16 6 36 136 36 536 12 13 QUAAAA DKAAAA VVVVxx 490 264 0 2 0 10 0 90 90 490 490 0 1 WSAAAA EKAAAA AAAAxx 773 265 1 1 3 13 3 73 173 273 773 6 7 TDAAAA FKAAAA HHHHxx 19 266 1 3 9 19 9 19 19 19 19 18 19 TAAAAA GKAAAA OOOOxx 534 267 0 2 4 14 4 34 134 34 534 8 9 OUAAAA HKAAAA VVVVxx 941 268 1 1 1 1 1 41 141 441 941 2 3 FKAAAA IKAAAA AAAAxx 477 269 1 1 7 17 7 77 77 477 477 14 15 JSAAAA JKAAAA HHHHxx 173 270 1 1 3 13 3 73 173 173 173 6 7 RGAAAA KKAAAA OOOOxx 113 271 1 1 3 13 3 13 113 113 113 6 7 JEAAAA LKAAAA VVVVxx 526 272 0 2 6 6 6 26 126 26 526 12 13 GUAAAA MKAAAA AAAAxx 727 273 1 3 7 7 7 27 127 227 727 14 15 ZBAAAA NKAAAA HHHHxx 302 274 0 2 2 2 2 2 102 302 302 4 5 QLAAAA OKAAAA OOOOxx 789 275 1 1 9 9 9 89 189 289 789 18 19 JEAAAA PKAAAA VVVVxx 447 276 1 3 7 7 7 47 47 447 447 14 15 FRAAAA QKAAAA AAAAxx 884 277 0 0 4 4 4 84 84 384 884 8 9 AIAAAA RKAAAA HHHHxx 718 278 0 2 8 18 8 18 118 218 718 16 17 QBAAAA SKAAAA OOOOxx 818 279 0 2 8 18 8 18 18 318 818 16 17 MFAAAA TKAAAA VVVVxx 466 280 0 2 6 6 6 66 66 466 466 12 13 YRAAAA UKAAAA AAAAxx 131 281 1 3 1 11 1 31 131 131 131 2 3 BFAAAA VKAAAA HHHHxx 503 282 1 3 3 3 3 3 103 3 503 6 7 JTAAAA WKAAAA OOOOxx 364 283 0 0 4 4 4 64 164 364 364 8 9 AOAAAA XKAAAA VVVVxx 934 284 0 2 4 14 4 34 134 434 934 8 9 YJAAAA YKAAAA AAAAxx 542 285 0 2 2 2 2 42 142 42 542 4 5 WUAAAA ZKAAAA HHHHxx 146 286 0 2 6 6 6 46 146 146 146 12 13 QFAAAA ALAAAA OOOOxx 652 287 0 0 2 12 2 52 52 152 652 4 5 CZAAAA BLAAAA VVVVxx 566 288 0 2 6 6 6 66 166 66 566 12 13 UVAAAA CLAAAA AAAAxx 788 289 0 0 8 8 8 88 188 288 788 16 17 IEAAAA DLAAAA HHHHxx 168 290 0 0 8 8 8 68 168 168 168 16 17 MGAAAA ELAAAA OOOOxx 736 291 0 0 6 16 6 36 136 236 736 12 13 ICAAAA FLAAAA VVVVxx 795 292 1 3 5 15 5 95 195 295 795 10 11 PEAAAA GLAAAA AAAAxx 103 293 1 3 3 3 3 3 103 103 103 6 7 ZDAAAA HLAAAA HHHHxx 763 294 1 3 3 3 3 63 163 263 763 6 7 JDAAAA ILAAAA OOOOxx 256 295 0 0 6 16 6 56 56 256 256 12 13 WJAAAA JLAAAA VVVVxx 63 296 1 3 3 3 3 63 63 63 63 6 7 LCAAAA KLAAAA AAAAxx 702 297 0 2 2 2 2 2 102 202 702 4 5 ABAAAA LLAAAA HHHHxx 390 298 0 2 0 10 0 90 190 390 390 0 1 APAAAA MLAAAA OOOOxx 116 299 0 0 6 16 6 16 116 116 116 12 13 MEAAAA NLAAAA VVVVxx 354 300 0 2 4 14 4 54 154 354 354 8 9 QNAAAA OLAAAA AAAAxx 162 301 0 2 2 2 2 62 162 162 162 4 5 GGAAAA PLAAAA HHHHxx 71 302 1 3 1 11 1 71 71 71 71 2 3 TCAAAA QLAAAA OOOOxx 916 303 0 0 6 16 6 16 116 416 916 12 13 GJAAAA RLAAAA VVVVxx 565 304 1 1 5 5 5 65 165 65 565 10 11 TVAAAA SLAAAA AAAAxx 509 305 1 1 9 9 9 9 109 9 509 18 19 PTAAAA TLAAAA HHHHxx 20 306 0 0 0 0 0 20 20 20 20 0 1 UAAAAA ULAAAA OOOOxx 813 307 1 1 3 13 3 13 13 313 813 6 7 HFAAAA VLAAAA VVVVxx 80 308 0 0 0 0 0 80 80 80 80 0 1 CDAAAA WLAAAA AAAAxx 400 309 0 0 0 0 0 0 0 400 400 0 1 KPAAAA XLAAAA HHHHxx 888 310 0 0 8 8 8 88 88 388 888 16 17 EIAAAA YLAAAA OOOOxx 825 311 1 1 5 5 5 25 25 325 825 10 11 TFAAAA ZLAAAA VVVVxx 401 312 1 1 1 1 1 1 1 401 401 2 3 LPAAAA AMAAAA AAAAxx 158 313 0 2 8 18 8 58 158 158 158 16 17 CGAAAA BMAAAA HHHHxx 973 314 1 1 3 13 3 73 173 473 973 6 7 LLAAAA CMAAAA OOOOxx 324 315 0 0 4 4 4 24 124 324 324 8 9 MMAAAA DMAAAA VVVVxx 873 316 1 1 3 13 3 73 73 373 873 6 7 PHAAAA EMAAAA AAAAxx 676 317 0 0 6 16 6 76 76 176 676 12 13 AAAAAA FMAAAA HHHHxx 199 318 1 3 9 19 9 99 199 199 199 18 19 RHAAAA GMAAAA OOOOxx 304 319 0 0 4 4 4 4 104 304 304 8 9 SLAAAA HMAAAA VVVVxx 338 320 0 2 8 18 8 38 138 338 338 16 17 ANAAAA IMAAAA AAAAxx 743 321 1 3 3 3 3 43 143 243 743 6 7 PCAAAA JMAAAA HHHHxx 730 322 0 2 0 10 0 30 130 230 730 0 1 CCAAAA KMAAAA OOOOxx 130 323 0 2 0 10 0 30 130 130 130 0 1 AFAAAA LMAAAA VVVVxx 224 324 0 0 4 4 4 24 24 224 224 8 9 QIAAAA MMAAAA AAAAxx 216 325 0 0 6 16 6 16 16 216 216 12 13 IIAAAA NMAAAA HHHHxx 2 326 0 2 2 2 2 2 2 2 2 4 5 CAAAAA OMAAAA OOOOxx 836 327 0 0 6 16 6 36 36 336 836 12 13 EGAAAA PMAAAA VVVVxx 443 328 1 3 3 3 3 43 43 443 443 6 7 BRAAAA QMAAAA AAAAxx 777 329 1 1 7 17 7 77 177 277 777 14 15 XDAAAA RMAAAA HHHHxx 126 330 0 2 6 6 6 26 126 126 126 12 13 WEAAAA SMAAAA OOOOxx 117 331 1 1 7 17 7 17 117 117 117 14 15 NEAAAA TMAAAA VVVVxx 633 332 1 1 3 13 3 33 33 133 633 6 7 JYAAAA UMAAAA AAAAxx 310 333 0 2 0 10 0 10 110 310 310 0 1 YLAAAA VMAAAA HHHHxx 622 334 0 2 2 2 2 22 22 122 622 4 5 YXAAAA WMAAAA OOOOxx 268 335 0 0 8 8 8 68 68 268 268 16 17 IKAAAA XMAAAA VVVVxx 384 336 0 0 4 4 4 84 184 384 384 8 9 UOAAAA YMAAAA AAAAxx 460 337 0 0 0 0 0 60 60 460 460 0 1 SRAAAA ZMAAAA HHHHxx 475 338 1 3 5 15 5 75 75 475 475 10 11 HSAAAA ANAAAA OOOOxx 624 339 0 0 4 4 4 24 24 124 624 8 9 AYAAAA BNAAAA VVVVxx 826 340 0 2 6 6 6 26 26 326 826 12 13 UFAAAA CNAAAA AAAAxx 680 341 0 0 0 0 0 80 80 180 680 0 1 EAAAAA DNAAAA HHHHxx 306 342 0 2 6 6 6 6 106 306 306 12 13 ULAAAA ENAAAA OOOOxx 896 343 0 0 6 16 6 96 96 396 896 12 13 MIAAAA FNAAAA VVVVxx 30 344 0 2 0 10 0 30 30 30 30 0 1 EBAAAA GNAAAA AAAAxx 576 345 0 0 6 16 6 76 176 76 576 12 13 EWAAAA HNAAAA HHHHxx 551 346 1 3 1 11 1 51 151 51 551 2 3 FVAAAA INAAAA OOOOxx 639 347 1 3 9 19 9 39 39 139 639 18 19 PYAAAA JNAAAA VVVVxx 975 348 1 3 5 15 5 75 175 475 975 10 11 NLAAAA KNAAAA AAAAxx 882 349 0 2 2 2 2 82 82 382 882 4 5 YHAAAA LNAAAA HHHHxx 160 350 0 0 0 0 0 60 160 160 160 0 1 EGAAAA MNAAAA OOOOxx 522 351 0 2 2 2 2 22 122 22 522 4 5 CUAAAA NNAAAA VVVVxx 620 352 0 0 0 0 0 20 20 120 620 0 1 WXAAAA ONAAAA AAAAxx 719 353 1 3 9 19 9 19 119 219 719 18 19 RBAAAA PNAAAA HHHHxx 88 354 0 0 8 8 8 88 88 88 88 16 17 KDAAAA QNAAAA OOOOxx 614 355 0 2 4 14 4 14 14 114 614 8 9 QXAAAA RNAAAA VVVVxx 54 356 0 2 4 14 4 54 54 54 54 8 9 CCAAAA SNAAAA AAAAxx 209 357 1 1 9 9 9 9 9 209 209 18 19 BIAAAA TNAAAA HHHHxx 67 358 1 3 7 7 7 67 67 67 67 14 15 PCAAAA UNAAAA OOOOxx 809 359 1 1 9 9 9 9 9 309 809 18 19 DFAAAA VNAAAA VVVVxx 982 360 0 2 2 2 2 82 182 482 982 4 5 ULAAAA WNAAAA AAAAxx 817 361 1 1 7 17 7 17 17 317 817 14 15 LFAAAA XNAAAA HHHHxx 187 362 1 3 7 7 7 87 187 187 187 14 15 FHAAAA YNAAAA OOOOxx 992 363 0 0 2 12 2 92 192 492 992 4 5 EMAAAA ZNAAAA VVVVxx 580 364 0 0 0 0 0 80 180 80 580 0 1 IWAAAA AOAAAA AAAAxx 658 365 0 2 8 18 8 58 58 158 658 16 17 IZAAAA BOAAAA HHHHxx 222 366 0 2 2 2 2 22 22 222 222 4 5 OIAAAA COAAAA OOOOxx 667 367 1 3 7 7 7 67 67 167 667 14 15 RZAAAA DOAAAA VVVVxx 715 368 1 3 5 15 5 15 115 215 715 10 11 NBAAAA EOAAAA AAAAxx 990 369 0 2 0 10 0 90 190 490 990 0 1 CMAAAA FOAAAA HHHHxx 22 370 0 2 2 2 2 22 22 22 22 4 5 WAAAAA GOAAAA OOOOxx 362 371 0 2 2 2 2 62 162 362 362 4 5 YNAAAA HOAAAA VVVVxx 376 372 0 0 6 16 6 76 176 376 376 12 13 MOAAAA IOAAAA AAAAxx 246 373 0 2 6 6 6 46 46 246 246 12 13 MJAAAA JOAAAA HHHHxx 300 374 0 0 0 0 0 0 100 300 300 0 1 OLAAAA KOAAAA OOOOxx 231 375 1 3 1 11 1 31 31 231 231 2 3 XIAAAA LOAAAA VVVVxx 151 376 1 3 1 11 1 51 151 151 151 2 3 VFAAAA MOAAAA AAAAxx 29 377 1 1 9 9 9 29 29 29 29 18 19 DBAAAA NOAAAA HHHHxx 297 378 1 1 7 17 7 97 97 297 297 14 15 LLAAAA OOAAAA OOOOxx 403 379 1 3 3 3 3 3 3 403 403 6 7 NPAAAA POAAAA VVVVxx 716 380 0 0 6 16 6 16 116 216 716 12 13 OBAAAA QOAAAA AAAAxx 260 381 0 0 0 0 0 60 60 260 260 0 1 AKAAAA ROAAAA HHHHxx 170 382 0 2 0 10 0 70 170 170 170 0 1 OGAAAA SOAAAA OOOOxx 285 383 1 1 5 5 5 85 85 285 285 10 11 ZKAAAA TOAAAA VVVVxx 82 384 0 2 2 2 2 82 82 82 82 4 5 EDAAAA UOAAAA AAAAxx 958 385 0 2 8 18 8 58 158 458 958 16 17 WKAAAA VOAAAA HHHHxx 175 386 1 3 5 15 5 75 175 175 175 10 11 TGAAAA WOAAAA OOOOxx 671 387 1 3 1 11 1 71 71 171 671 2 3 VZAAAA XOAAAA VVVVxx 822 388 0 2 2 2 2 22 22 322 822 4 5 QFAAAA YOAAAA AAAAxx 573 389 1 1 3 13 3 73 173 73 573 6 7 BWAAAA ZOAAAA HHHHxx 723 390 1 3 3 3 3 23 123 223 723 6 7 VBAAAA APAAAA OOOOxx 195 391 1 3 5 15 5 95 195 195 195 10 11 NHAAAA BPAAAA VVVVxx 197 392 1 1 7 17 7 97 197 197 197 14 15 PHAAAA CPAAAA AAAAxx 755 393 1 3 5 15 5 55 155 255 755 10 11 BDAAAA DPAAAA HHHHxx 42 394 0 2 2 2 2 42 42 42 42 4 5 QBAAAA EPAAAA OOOOxx 897 395 1 1 7 17 7 97 97 397 897 14 15 NIAAAA FPAAAA VVVVxx 309 396 1 1 9 9 9 9 109 309 309 18 19 XLAAAA GPAAAA AAAAxx 724 397 0 0 4 4 4 24 124 224 724 8 9 WBAAAA HPAAAA HHHHxx 474 398 0 2 4 14 4 74 74 474 474 8 9 GSAAAA IPAAAA OOOOxx 345 399 1 1 5 5 5 45 145 345 345 10 11 HNAAAA JPAAAA VVVVxx 678 400 0 2 8 18 8 78 78 178 678 16 17 CAAAAA KPAAAA AAAAxx 757 401 1 1 7 17 7 57 157 257 757 14 15 DDAAAA LPAAAA HHHHxx 600 402 0 0 0 0 0 0 0 100 600 0 1 CXAAAA MPAAAA OOOOxx 184 403 0 0 4 4 4 84 184 184 184 8 9 CHAAAA NPAAAA VVVVxx 155 404 1 3 5 15 5 55 155 155 155 10 11 ZFAAAA OPAAAA AAAAxx 136 405 0 0 6 16 6 36 136 136 136 12 13 GFAAAA PPAAAA HHHHxx 889 406 1 1 9 9 9 89 89 389 889 18 19 FIAAAA QPAAAA OOOOxx 95 407 1 3 5 15 5 95 95 95 95 10 11 RDAAAA RPAAAA VVVVxx 549 408 1 1 9 9 9 49 149 49 549 18 19 DVAAAA SPAAAA AAAAxx 81 409 1 1 1 1 1 81 81 81 81 2 3 DDAAAA TPAAAA HHHHxx 679 410 1 3 9 19 9 79 79 179 679 18 19 DAAAAA UPAAAA OOOOxx 27 411 1 3 7 7 7 27 27 27 27 14 15 BBAAAA VPAAAA VVVVxx 748 412 0 0 8 8 8 48 148 248 748 16 17 UCAAAA WPAAAA AAAAxx 107 413 1 3 7 7 7 7 107 107 107 14 15 DEAAAA XPAAAA HHHHxx 870 414 0 2 0 10 0 70 70 370 870 0 1 MHAAAA YPAAAA OOOOxx 848 415 0 0 8 8 8 48 48 348 848 16 17 QGAAAA ZPAAAA VVVVxx 764 416 0 0 4 4 4 64 164 264 764 8 9 KDAAAA AQAAAA AAAAxx 535 417 1 3 5 15 5 35 135 35 535 10 11 PUAAAA BQAAAA HHHHxx 211 418 1 3 1 11 1 11 11 211 211 2 3 DIAAAA CQAAAA OOOOxx 625 419 1 1 5 5 5 25 25 125 625 10 11 BYAAAA DQAAAA VVVVxx 96 420 0 0 6 16 6 96 96 96 96 12 13 SDAAAA EQAAAA AAAAxx 828 421 0 0 8 8 8 28 28 328 828 16 17 WFAAAA FQAAAA HHHHxx 229 422 1 1 9 9 9 29 29 229 229 18 19 VIAAAA GQAAAA OOOOxx 602 423 0 2 2 2 2 2 2 102 602 4 5 EXAAAA HQAAAA VVVVxx 742 424 0 2 2 2 2 42 142 242 742 4 5 OCAAAA IQAAAA AAAAxx 451 425 1 3 1 11 1 51 51 451 451 2 3 JRAAAA JQAAAA HHHHxx 991 426 1 3 1 11 1 91 191 491 991 2 3 DMAAAA KQAAAA OOOOxx 301 427 1 1 1 1 1 1 101 301 301 2 3 PLAAAA LQAAAA VVVVxx 510 428 0 2 0 10 0 10 110 10 510 0 1 QTAAAA MQAAAA AAAAxx 299 429 1 3 9 19 9 99 99 299 299 18 19 NLAAAA NQAAAA HHHHxx 961 430 1 1 1 1 1 61 161 461 961 2 3 ZKAAAA OQAAAA OOOOxx 3 431 1 3 3 3 3 3 3 3 3 6 7 DAAAAA PQAAAA VVVVxx 106 432 0 2 6 6 6 6 106 106 106 12 13 CEAAAA QQAAAA AAAAxx 591 433 1 3 1 11 1 91 191 91 591 2 3 TWAAAA RQAAAA HHHHxx 700 434 0 0 0 0 0 0 100 200 700 0 1 YAAAAA SQAAAA OOOOxx 841 435 1 1 1 1 1 41 41 341 841 2 3 JGAAAA TQAAAA VVVVxx 829 436 1 1 9 9 9 29 29 329 829 18 19 XFAAAA UQAAAA AAAAxx 508 437 0 0 8 8 8 8 108 8 508 16 17 OTAAAA VQAAAA HHHHxx 750 438 0 2 0 10 0 50 150 250 750 0 1 WCAAAA WQAAAA OOOOxx 665 439 1 1 5 5 5 65 65 165 665 10 11 PZAAAA XQAAAA VVVVxx 157 440 1 1 7 17 7 57 157 157 157 14 15 BGAAAA YQAAAA AAAAxx 694 441 0 2 4 14 4 94 94 194 694 8 9 SAAAAA ZQAAAA HHHHxx 176 442 0 0 6 16 6 76 176 176 176 12 13 UGAAAA ARAAAA OOOOxx 950 443 0 2 0 10 0 50 150 450 950 0 1 OKAAAA BRAAAA VVVVxx 970 444 0 2 0 10 0 70 170 470 970 0 1 ILAAAA CRAAAA AAAAxx 496 445 0 0 6 16 6 96 96 496 496 12 13 CTAAAA DRAAAA HHHHxx 429 446 1 1 9 9 9 29 29 429 429 18 19 NQAAAA ERAAAA OOOOxx 907 447 1 3 7 7 7 7 107 407 907 14 15 XIAAAA FRAAAA VVVVxx 72 448 0 0 2 12 2 72 72 72 72 4 5 UCAAAA GRAAAA AAAAxx 186 449 0 2 6 6 6 86 186 186 186 12 13 EHAAAA HRAAAA HHHHxx 713 450 1 1 3 13 3 13 113 213 713 6 7 LBAAAA IRAAAA OOOOxx 432 451 0 0 2 12 2 32 32 432 432 4 5 QQAAAA JRAAAA VVVVxx 735 452 1 3 5 15 5 35 135 235 735 10 11 HCAAAA KRAAAA AAAAxx 516 453 0 0 6 16 6 16 116 16 516 12 13 WTAAAA LRAAAA HHHHxx 964 454 0 0 4 4 4 64 164 464 964 8 9 CLAAAA MRAAAA OOOOxx 840 455 0 0 0 0 0 40 40 340 840 0 1 IGAAAA NRAAAA VVVVxx 550 456 0 2 0 10 0 50 150 50 550 0 1 EVAAAA ORAAAA AAAAxx 360 457 0 0 0 0 0 60 160 360 360 0 1 WNAAAA PRAAAA HHHHxx 827 458 1 3 7 7 7 27 27 327 827 14 15 VFAAAA QRAAAA OOOOxx 959 459 1 3 9 19 9 59 159 459 959 18 19 XKAAAA RRAAAA VVVVxx 454 460 0 2 4 14 4 54 54 454 454 8 9 MRAAAA SRAAAA AAAAxx 819 461 1 3 9 19 9 19 19 319 819 18 19 NFAAAA TRAAAA HHHHxx 745 462 1 1 5 5 5 45 145 245 745 10 11 RCAAAA URAAAA OOOOxx 279 463 1 3 9 19 9 79 79 279 279 18 19 TKAAAA VRAAAA VVVVxx 426 464 0 2 6 6 6 26 26 426 426 12 13 KQAAAA WRAAAA AAAAxx 70 465 0 2 0 10 0 70 70 70 70 0 1 SCAAAA XRAAAA HHHHxx 637 466 1 1 7 17 7 37 37 137 637 14 15 NYAAAA YRAAAA OOOOxx 417 467 1 1 7 17 7 17 17 417 417 14 15 BQAAAA ZRAAAA VVVVxx 586 468 0 2 6 6 6 86 186 86 586 12 13 OWAAAA ASAAAA AAAAxx 314 469 0 2 4 14 4 14 114 314 314 8 9 CMAAAA BSAAAA HHHHxx 101 470 1 1 1 1 1 1 101 101 101 2 3 XDAAAA CSAAAA OOOOxx 205 471 1 1 5 5 5 5 5 205 205 10 11 XHAAAA DSAAAA VVVVxx 969 472 1 1 9 9 9 69 169 469 969 18 19 HLAAAA ESAAAA AAAAxx 217 473 1 1 7 17 7 17 17 217 217 14 15 JIAAAA FSAAAA HHHHxx 281 474 1 1 1 1 1 81 81 281 281 2 3 VKAAAA GSAAAA OOOOxx 984 475 0 0 4 4 4 84 184 484 984 8 9 WLAAAA HSAAAA VVVVxx 366 476 0 2 6 6 6 66 166 366 366 12 13 COAAAA ISAAAA AAAAxx 483 477 1 3 3 3 3 83 83 483 483 6 7 PSAAAA JSAAAA HHHHxx 838 478 0 2 8 18 8 38 38 338 838 16 17 GGAAAA KSAAAA OOOOxx 64 479 0 0 4 4 4 64 64 64 64 8 9 MCAAAA LSAAAA VVVVxx 981 480 1 1 1 1 1 81 181 481 981 2 3 TLAAAA MSAAAA AAAAxx 538 481 0 2 8 18 8 38 138 38 538 16 17 SUAAAA NSAAAA HHHHxx 39 482 1 3 9 19 9 39 39 39 39 18 19 NBAAAA OSAAAA OOOOxx 60 483 0 0 0 0 0 60 60 60 60 0 1 ICAAAA PSAAAA VVVVxx 874 484 0 2 4 14 4 74 74 374 874 8 9 QHAAAA QSAAAA AAAAxx 955 485 1 3 5 15 5 55 155 455 955 10 11 TKAAAA RSAAAA HHHHxx 347 486 1 3 7 7 7 47 147 347 347 14 15 JNAAAA SSAAAA OOOOxx 227 487 1 3 7 7 7 27 27 227 227 14 15 TIAAAA TSAAAA VVVVxx 44 488 0 0 4 4 4 44 44 44 44 8 9 SBAAAA USAAAA AAAAxx 446 489 0 2 6 6 6 46 46 446 446 12 13 ERAAAA VSAAAA HHHHxx 605 490 1 1 5 5 5 5 5 105 605 10 11 HXAAAA WSAAAA OOOOxx 570 491 0 2 0 10 0 70 170 70 570 0 1 YVAAAA XSAAAA VVVVxx 895 492 1 3 5 15 5 95 95 395 895 10 11 LIAAAA YSAAAA AAAAxx 760 493 0 0 0 0 0 60 160 260 760 0 1 GDAAAA ZSAAAA HHHHxx 428 494 0 0 8 8 8 28 28 428 428 16 17 MQAAAA ATAAAA OOOOxx 628 495 0 0 8 8 8 28 28 128 628 16 17 EYAAAA BTAAAA VVVVxx 933 496 1 1 3 13 3 33 133 433 933 6 7 XJAAAA CTAAAA AAAAxx 263 497 1 3 3 3 3 63 63 263 263 6 7 DKAAAA DTAAAA HHHHxx 729 498 1 1 9 9 9 29 129 229 729 18 19 BCAAAA ETAAAA OOOOxx 860 499 0 0 0 0 0 60 60 360 860 0 1 CHAAAA FTAAAA VVVVxx 76 500 0 0 6 16 6 76 76 76 76 12 13 YCAAAA GTAAAA AAAAxx 293 501 1 1 3 13 3 93 93 293 293 6 7 HLAAAA HTAAAA HHHHxx 296 502 0 0 6 16 6 96 96 296 296 12 13 KLAAAA ITAAAA OOOOxx 124 503 0 0 4 4 4 24 124 124 124 8 9 UEAAAA JTAAAA VVVVxx 568 504 0 0 8 8 8 68 168 68 568 16 17 WVAAAA KTAAAA AAAAxx 337 505 1 1 7 17 7 37 137 337 337 14 15 ZMAAAA LTAAAA HHHHxx 464 506 0 0 4 4 4 64 64 464 464 8 9 WRAAAA MTAAAA OOOOxx 582 507 0 2 2 2 2 82 182 82 582 4 5 KWAAAA NTAAAA VVVVxx 207 508 1 3 7 7 7 7 7 207 207 14 15 ZHAAAA OTAAAA AAAAxx 518 509 0 2 8 18 8 18 118 18 518 16 17 YTAAAA PTAAAA HHHHxx 513 510 1 1 3 13 3 13 113 13 513 6 7 TTAAAA QTAAAA OOOOxx 127 511 1 3 7 7 7 27 127 127 127 14 15 XEAAAA RTAAAA VVVVxx 396 512 0 0 6 16 6 96 196 396 396 12 13 GPAAAA STAAAA AAAAxx 781 513 1 1 1 1 1 81 181 281 781 2 3 BEAAAA TTAAAA HHHHxx 233 514 1 1 3 13 3 33 33 233 233 6 7 ZIAAAA UTAAAA OOOOxx 709 515 1 1 9 9 9 9 109 209 709 18 19 HBAAAA VTAAAA VVVVxx 325 516 1 1 5 5 5 25 125 325 325 10 11 NMAAAA WTAAAA AAAAxx 143 517 1 3 3 3 3 43 143 143 143 6 7 NFAAAA XTAAAA HHHHxx 824 518 0 0 4 4 4 24 24 324 824 8 9 SFAAAA YTAAAA OOOOxx 122 519 0 2 2 2 2 22 122 122 122 4 5 SEAAAA ZTAAAA VVVVxx 10 520 0 2 0 10 0 10 10 10 10 0 1 KAAAAA AUAAAA AAAAxx 41 521 1 1 1 1 1 41 41 41 41 2 3 PBAAAA BUAAAA HHHHxx 618 522 0 2 8 18 8 18 18 118 618 16 17 UXAAAA CUAAAA OOOOxx 161 523 1 1 1 1 1 61 161 161 161 2 3 FGAAAA DUAAAA VVVVxx 801 524 1 1 1 1 1 1 1 301 801 2 3 VEAAAA EUAAAA AAAAxx 768 525 0 0 8 8 8 68 168 268 768 16 17 ODAAAA FUAAAA HHHHxx 642 526 0 2 2 2 2 42 42 142 642 4 5 SYAAAA GUAAAA OOOOxx 803 527 1 3 3 3 3 3 3 303 803 6 7 XEAAAA HUAAAA VVVVxx 317 528 1 1 7 17 7 17 117 317 317 14 15 FMAAAA IUAAAA AAAAxx 938 529 0 2 8 18 8 38 138 438 938 16 17 CKAAAA JUAAAA HHHHxx 649 530 1 1 9 9 9 49 49 149 649 18 19 ZYAAAA KUAAAA OOOOxx 738 531 0 2 8 18 8 38 138 238 738 16 17 KCAAAA LUAAAA VVVVxx 344 532 0 0 4 4 4 44 144 344 344 8 9 GNAAAA MUAAAA AAAAxx 399 533 1 3 9 19 9 99 199 399 399 18 19 JPAAAA NUAAAA HHHHxx 609 534 1 1 9 9 9 9 9 109 609 18 19 LXAAAA OUAAAA OOOOxx 677 535 1 1 7 17 7 77 77 177 677 14 15 BAAAAA PUAAAA VVVVxx 478 536 0 2 8 18 8 78 78 478 478 16 17 KSAAAA QUAAAA AAAAxx 452 537 0 0 2 12 2 52 52 452 452 4 5 KRAAAA RUAAAA HHHHxx 261 538 1 1 1 1 1 61 61 261 261 2 3 BKAAAA SUAAAA OOOOxx 449 539 1 1 9 9 9 49 49 449 449 18 19 HRAAAA TUAAAA VVVVxx 433 540 1 1 3 13 3 33 33 433 433 6 7 RQAAAA UUAAAA AAAAxx 5 541 1 1 5 5 5 5 5 5 5 10 11 FAAAAA VUAAAA HHHHxx 664 542 0 0 4 4 4 64 64 164 664 8 9 OZAAAA WUAAAA OOOOxx 887 543 1 3 7 7 7 87 87 387 887 14 15 DIAAAA XUAAAA VVVVxx 546 544 0 2 6 6 6 46 146 46 546 12 13 AVAAAA YUAAAA AAAAxx 253 545 1 1 3 13 3 53 53 253 253 6 7 TJAAAA ZUAAAA HHHHxx 235 546 1 3 5 15 5 35 35 235 235 10 11 BJAAAA AVAAAA OOOOxx 258 547 0 2 8 18 8 58 58 258 258 16 17 YJAAAA BVAAAA VVVVxx 621 548 1 1 1 1 1 21 21 121 621 2 3 XXAAAA CVAAAA AAAAxx 998 549 0 2 8 18 8 98 198 498 998 16 17 KMAAAA DVAAAA HHHHxx 236 550 0 0 6 16 6 36 36 236 236 12 13 CJAAAA EVAAAA OOOOxx 537 551 1 1 7 17 7 37 137 37 537 14 15 RUAAAA FVAAAA VVVVxx 769 552 1 1 9 9 9 69 169 269 769 18 19 PDAAAA GVAAAA AAAAxx 921 553 1 1 1 1 1 21 121 421 921 2 3 LJAAAA HVAAAA HHHHxx 951 554 1 3 1 11 1 51 151 451 951 2 3 PKAAAA IVAAAA OOOOxx 240 555 0 0 0 0 0 40 40 240 240 0 1 GJAAAA JVAAAA VVVVxx 644 556 0 0 4 4 4 44 44 144 644 8 9 UYAAAA KVAAAA AAAAxx 352 557 0 0 2 12 2 52 152 352 352 4 5 ONAAAA LVAAAA HHHHxx 613 558 1 1 3 13 3 13 13 113 613 6 7 PXAAAA MVAAAA OOOOxx 784 559 0 0 4 4 4 84 184 284 784 8 9 EEAAAA NVAAAA VVVVxx 61 560 1 1 1 1 1 61 61 61 61 2 3 JCAAAA OVAAAA AAAAxx 144 561 0 0 4 4 4 44 144 144 144 8 9 OFAAAA PVAAAA HHHHxx 94 562 0 2 4 14 4 94 94 94 94 8 9 QDAAAA QVAAAA OOOOxx 270 563 0 2 0 10 0 70 70 270 270 0 1 KKAAAA RVAAAA VVVVxx 942 564 0 2 2 2 2 42 142 442 942 4 5 GKAAAA SVAAAA AAAAxx 756 565 0 0 6 16 6 56 156 256 756 12 13 CDAAAA TVAAAA HHHHxx 321 566 1 1 1 1 1 21 121 321 321 2 3 JMAAAA UVAAAA OOOOxx 36 567 0 0 6 16 6 36 36 36 36 12 13 KBAAAA VVAAAA VVVVxx 232 568 0 0 2 12 2 32 32 232 232 4 5 YIAAAA WVAAAA AAAAxx 430 569 0 2 0 10 0 30 30 430 430 0 1 OQAAAA XVAAAA HHHHxx 177 570 1 1 7 17 7 77 177 177 177 14 15 VGAAAA YVAAAA OOOOxx 220 571 0 0 0 0 0 20 20 220 220 0 1 MIAAAA ZVAAAA VVVVxx 109 572 1 1 9 9 9 9 109 109 109 18 19 FEAAAA AWAAAA AAAAxx 419 573 1 3 9 19 9 19 19 419 419 18 19 DQAAAA BWAAAA HHHHxx 135 574 1 3 5 15 5 35 135 135 135 10 11 FFAAAA CWAAAA OOOOxx 610 575 0 2 0 10 0 10 10 110 610 0 1 MXAAAA DWAAAA VVVVxx 956 576 0 0 6 16 6 56 156 456 956 12 13 UKAAAA EWAAAA AAAAxx 626 577 0 2 6 6 6 26 26 126 626 12 13 CYAAAA FWAAAA HHHHxx 375 578 1 3 5 15 5 75 175 375 375 10 11 LOAAAA GWAAAA OOOOxx 976 579 0 0 6 16 6 76 176 476 976 12 13 OLAAAA HWAAAA VVVVxx 152 580 0 0 2 12 2 52 152 152 152 4 5 WFAAAA IWAAAA AAAAxx 308 581 0 0 8 8 8 8 108 308 308 16 17 WLAAAA JWAAAA HHHHxx 445 582 1 1 5 5 5 45 45 445 445 10 11 DRAAAA KWAAAA OOOOxx 326 583 0 2 6 6 6 26 126 326 326 12 13 OMAAAA LWAAAA VVVVxx 422 584 0 2 2 2 2 22 22 422 422 4 5 GQAAAA MWAAAA AAAAxx 972 585 0 0 2 12 2 72 172 472 972 4 5 KLAAAA NWAAAA HHHHxx 45 586 1 1 5 5 5 45 45 45 45 10 11 TBAAAA OWAAAA OOOOxx 725 587 1 1 5 5 5 25 125 225 725 10 11 XBAAAA PWAAAA VVVVxx 753 588 1 1 3 13 3 53 153 253 753 6 7 ZCAAAA QWAAAA AAAAxx 493 589 1 1 3 13 3 93 93 493 493 6 7 ZSAAAA RWAAAA HHHHxx 601 590 1 1 1 1 1 1 1 101 601 2 3 DXAAAA SWAAAA OOOOxx 463 591 1 3 3 3 3 63 63 463 463 6 7 VRAAAA TWAAAA VVVVxx 303 592 1 3 3 3 3 3 103 303 303 6 7 RLAAAA UWAAAA AAAAxx 59 593 1 3 9 19 9 59 59 59 59 18 19 HCAAAA VWAAAA HHHHxx 595 594 1 3 5 15 5 95 195 95 595 10 11 XWAAAA WWAAAA OOOOxx 807 595 1 3 7 7 7 7 7 307 807 14 15 BFAAAA XWAAAA VVVVxx 424 596 0 0 4 4 4 24 24 424 424 8 9 IQAAAA YWAAAA AAAAxx 521 597 1 1 1 1 1 21 121 21 521 2 3 BUAAAA ZWAAAA HHHHxx 341 598 1 1 1 1 1 41 141 341 341 2 3 DNAAAA AXAAAA OOOOxx 571 599 1 3 1 11 1 71 171 71 571 2 3 ZVAAAA BXAAAA VVVVxx 165 600 1 1 5 5 5 65 165 165 165 10 11 JGAAAA CXAAAA AAAAxx 908 601 0 0 8 8 8 8 108 408 908 16 17 YIAAAA DXAAAA HHHHxx 351 602 1 3 1 11 1 51 151 351 351 2 3 NNAAAA EXAAAA OOOOxx 334 603 0 2 4 14 4 34 134 334 334 8 9 WMAAAA FXAAAA VVVVxx 636 604 0 0 6 16 6 36 36 136 636 12 13 MYAAAA GXAAAA AAAAxx 138 605 0 2 8 18 8 38 138 138 138 16 17 IFAAAA HXAAAA HHHHxx 438 606 0 2 8 18 8 38 38 438 438 16 17 WQAAAA IXAAAA OOOOxx 391 607 1 3 1 11 1 91 191 391 391 2 3 BPAAAA JXAAAA VVVVxx 395 608 1 3 5 15 5 95 195 395 395 10 11 FPAAAA KXAAAA AAAAxx 502 609 0 2 2 2 2 2 102 2 502 4 5 ITAAAA LXAAAA HHHHxx 85 610 1 1 5 5 5 85 85 85 85 10 11 HDAAAA MXAAAA OOOOxx 786 611 0 2 6 6 6 86 186 286 786 12 13 GEAAAA NXAAAA VVVVxx 619 612 1 3 9 19 9 19 19 119 619 18 19 VXAAAA OXAAAA AAAAxx 440 613 0 0 0 0 0 40 40 440 440 0 1 YQAAAA PXAAAA HHHHxx 949 614 1 1 9 9 9 49 149 449 949 18 19 NKAAAA QXAAAA OOOOxx 691 615 1 3 1 11 1 91 91 191 691 2 3 PAAAAA RXAAAA VVVVxx 348 616 0 0 8 8 8 48 148 348 348 16 17 KNAAAA SXAAAA AAAAxx 506 617 0 2 6 6 6 6 106 6 506 12 13 MTAAAA TXAAAA HHHHxx 192 618 0 0 2 12 2 92 192 192 192 4 5 KHAAAA UXAAAA OOOOxx 369 619 1 1 9 9 9 69 169 369 369 18 19 FOAAAA VXAAAA VVVVxx 311 620 1 3 1 11 1 11 111 311 311 2 3 ZLAAAA WXAAAA AAAAxx 273 621 1 1 3 13 3 73 73 273 273 6 7 NKAAAA XXAAAA HHHHxx 770 622 0 2 0 10 0 70 170 270 770 0 1 QDAAAA YXAAAA OOOOxx 191 623 1 3 1 11 1 91 191 191 191 2 3 JHAAAA ZXAAAA VVVVxx 90 624 0 2 0 10 0 90 90 90 90 0 1 MDAAAA AYAAAA AAAAxx 163 625 1 3 3 3 3 63 163 163 163 6 7 HGAAAA BYAAAA HHHHxx 350 626 0 2 0 10 0 50 150 350 350 0 1 MNAAAA CYAAAA OOOOxx 55 627 1 3 5 15 5 55 55 55 55 10 11 DCAAAA DYAAAA VVVVxx 488 628 0 0 8 8 8 88 88 488 488 16 17 USAAAA EYAAAA AAAAxx 215 629 1 3 5 15 5 15 15 215 215 10 11 HIAAAA FYAAAA HHHHxx 732 630 0 0 2 12 2 32 132 232 732 4 5 ECAAAA GYAAAA OOOOxx 688 631 0 0 8 8 8 88 88 188 688 16 17 MAAAAA HYAAAA VVVVxx 520 632 0 0 0 0 0 20 120 20 520 0 1 AUAAAA IYAAAA AAAAxx 62 633 0 2 2 2 2 62 62 62 62 4 5 KCAAAA JYAAAA HHHHxx 423 634 1 3 3 3 3 23 23 423 423 6 7 HQAAAA KYAAAA OOOOxx 242 635 0 2 2 2 2 42 42 242 242 4 5 IJAAAA LYAAAA VVVVxx 193 636 1 1 3 13 3 93 193 193 193 6 7 LHAAAA MYAAAA AAAAxx 648 637 0 0 8 8 8 48 48 148 648 16 17 YYAAAA NYAAAA HHHHxx 459 638 1 3 9 19 9 59 59 459 459 18 19 RRAAAA OYAAAA OOOOxx 196 639 0 0 6 16 6 96 196 196 196 12 13 OHAAAA PYAAAA VVVVxx 476 640 0 0 6 16 6 76 76 476 476 12 13 ISAAAA QYAAAA AAAAxx 903 641 1 3 3 3 3 3 103 403 903 6 7 TIAAAA RYAAAA HHHHxx 974 642 0 2 4 14 4 74 174 474 974 8 9 MLAAAA SYAAAA OOOOxx 603 643 1 3 3 3 3 3 3 103 603 6 7 FXAAAA TYAAAA VVVVxx 12 644 0 0 2 12 2 12 12 12 12 4 5 MAAAAA UYAAAA AAAAxx 599 645 1 3 9 19 9 99 199 99 599 18 19 BXAAAA VYAAAA HHHHxx 914 646 0 2 4 14 4 14 114 414 914 8 9 EJAAAA WYAAAA OOOOxx 7 647 1 3 7 7 7 7 7 7 7 14 15 HAAAAA XYAAAA VVVVxx 213 648 1 1 3 13 3 13 13 213 213 6 7 FIAAAA YYAAAA AAAAxx 174 649 0 2 4 14 4 74 174 174 174 8 9 SGAAAA ZYAAAA HHHHxx 392 650 0 0 2 12 2 92 192 392 392 4 5 CPAAAA AZAAAA OOOOxx 674 651 0 2 4 14 4 74 74 174 674 8 9 YZAAAA BZAAAA VVVVxx 650 652 0 2 0 10 0 50 50 150 650 0 1 AZAAAA CZAAAA AAAAxx 8 653 0 0 8 8 8 8 8 8 8 16 17 IAAAAA DZAAAA HHHHxx 492 654 0 0 2 12 2 92 92 492 492 4 5 YSAAAA EZAAAA OOOOxx 322 655 0 2 2 2 2 22 122 322 322 4 5 KMAAAA FZAAAA VVVVxx 315 656 1 3 5 15 5 15 115 315 315 10 11 DMAAAA GZAAAA AAAAxx 380 657 0 0 0 0 0 80 180 380 380 0 1 QOAAAA HZAAAA HHHHxx 353 658 1 1 3 13 3 53 153 353 353 6 7 PNAAAA IZAAAA OOOOxx 892 659 0 0 2 12 2 92 92 392 892 4 5 IIAAAA JZAAAA VVVVxx 932 660 0 0 2 12 2 32 132 432 932 4 5 WJAAAA KZAAAA AAAAxx 993 661 1 1 3 13 3 93 193 493 993 6 7 FMAAAA LZAAAA HHHHxx 859 662 1 3 9 19 9 59 59 359 859 18 19 BHAAAA MZAAAA OOOOxx 806 663 0 2 6 6 6 6 6 306 806 12 13 AFAAAA NZAAAA VVVVxx 145 664 1 1 5 5 5 45 145 145 145 10 11 PFAAAA OZAAAA AAAAxx 373 665 1 1 3 13 3 73 173 373 373 6 7 JOAAAA PZAAAA HHHHxx 418 666 0 2 8 18 8 18 18 418 418 16 17 CQAAAA QZAAAA OOOOxx 865 667 1 1 5 5 5 65 65 365 865 10 11 HHAAAA RZAAAA VVVVxx 462 668 0 2 2 2 2 62 62 462 462 4 5 URAAAA SZAAAA AAAAxx 24 669 0 0 4 4 4 24 24 24 24 8 9 YAAAAA TZAAAA HHHHxx 920 670 0 0 0 0 0 20 120 420 920 0 1 KJAAAA UZAAAA OOOOxx 672 671 0 0 2 12 2 72 72 172 672 4 5 WZAAAA VZAAAA VVVVxx 92 672 0 0 2 12 2 92 92 92 92 4 5 ODAAAA WZAAAA AAAAxx 721 673 1 1 1 1 1 21 121 221 721 2 3 TBAAAA XZAAAA HHHHxx 646 674 0 2 6 6 6 46 46 146 646 12 13 WYAAAA YZAAAA OOOOxx 910 675 0 2 0 10 0 10 110 410 910 0 1 AJAAAA ZZAAAA VVVVxx 909 676 1 1 9 9 9 9 109 409 909 18 19 ZIAAAA AABAAA AAAAxx 630 677 0 2 0 10 0 30 30 130 630 0 1 GYAAAA BABAAA HHHHxx 482 678 0 2 2 2 2 82 82 482 482 4 5 OSAAAA CABAAA OOOOxx 559 679 1 3 9 19 9 59 159 59 559 18 19 NVAAAA DABAAA VVVVxx 853 680 1 1 3 13 3 53 53 353 853 6 7 VGAAAA EABAAA AAAAxx 141 681 1 1 1 1 1 41 141 141 141 2 3 LFAAAA FABAAA HHHHxx 266 682 0 2 6 6 6 66 66 266 266 12 13 GKAAAA GABAAA OOOOxx 835 683 1 3 5 15 5 35 35 335 835 10 11 DGAAAA HABAAA VVVVxx 164 684 0 0 4 4 4 64 164 164 164 8 9 IGAAAA IABAAA AAAAxx 629 685 1 1 9 9 9 29 29 129 629 18 19 FYAAAA JABAAA HHHHxx 203 686 1 3 3 3 3 3 3 203 203 6 7 VHAAAA KABAAA OOOOxx 411 687 1 3 1 11 1 11 11 411 411 2 3 VPAAAA LABAAA VVVVxx 930 688 0 2 0 10 0 30 130 430 930 0 1 UJAAAA MABAAA AAAAxx 435 689 1 3 5 15 5 35 35 435 435 10 11 TQAAAA NABAAA HHHHxx 563 690 1 3 3 3 3 63 163 63 563 6 7 RVAAAA OABAAA OOOOxx 960 691 0 0 0 0 0 60 160 460 960 0 1 YKAAAA PABAAA VVVVxx 733 692 1 1 3 13 3 33 133 233 733 6 7 FCAAAA QABAAA AAAAxx 967 693 1 3 7 7 7 67 167 467 967 14 15 FLAAAA RABAAA HHHHxx 668 694 0 0 8 8 8 68 68 168 668 16 17 SZAAAA SABAAA OOOOxx 994 695 0 2 4 14 4 94 194 494 994 8 9 GMAAAA TABAAA VVVVxx 129 696 1 1 9 9 9 29 129 129 129 18 19 ZEAAAA UABAAA AAAAxx 954 697 0 2 4 14 4 54 154 454 954 8 9 SKAAAA VABAAA HHHHxx 68 698 0 0 8 8 8 68 68 68 68 16 17 QCAAAA WABAAA OOOOxx 79 699 1 3 9 19 9 79 79 79 79 18 19 BDAAAA XABAAA VVVVxx 121 700 1 1 1 1 1 21 121 121 121 2 3 REAAAA YABAAA AAAAxx 740 701 0 0 0 0 0 40 140 240 740 0 1 MCAAAA ZABAAA HHHHxx 902 702 0 2 2 2 2 2 102 402 902 4 5 SIAAAA ABBAAA OOOOxx 695 703 1 3 5 15 5 95 95 195 695 10 11 TAAAAA BBBAAA VVVVxx 455 704 1 3 5 15 5 55 55 455 455 10 11 NRAAAA CBBAAA AAAAxx 89 705 1 1 9 9 9 89 89 89 89 18 19 LDAAAA DBBAAA HHHHxx 893 706 1 1 3 13 3 93 93 393 893 6 7 JIAAAA EBBAAA OOOOxx 202 707 0 2 2 2 2 2 2 202 202 4 5 UHAAAA FBBAAA VVVVxx 132 708 0 0 2 12 2 32 132 132 132 4 5 CFAAAA GBBAAA AAAAxx 782 709 0 2 2 2 2 82 182 282 782 4 5 CEAAAA HBBAAA HHHHxx 512 710 0 0 2 12 2 12 112 12 512 4 5 STAAAA IBBAAA OOOOxx 857 711 1 1 7 17 7 57 57 357 857 14 15 ZGAAAA JBBAAA VVVVxx 248 712 0 0 8 8 8 48 48 248 248 16 17 OJAAAA KBBAAA AAAAxx 858 713 0 2 8 18 8 58 58 358 858 16 17 AHAAAA LBBAAA HHHHxx 527 714 1 3 7 7 7 27 127 27 527 14 15 HUAAAA MBBAAA OOOOxx 450 715 0 2 0 10 0 50 50 450 450 0 1 IRAAAA NBBAAA VVVVxx 712 716 0 0 2 12 2 12 112 212 712 4 5 KBAAAA OBBAAA AAAAxx 153 717 1 1 3 13 3 53 153 153 153 6 7 XFAAAA PBBAAA HHHHxx 587 718 1 3 7 7 7 87 187 87 587 14 15 PWAAAA QBBAAA OOOOxx 593 719 1 1 3 13 3 93 193 93 593 6 7 VWAAAA RBBAAA VVVVxx 249 720 1 1 9 9 9 49 49 249 249 18 19 PJAAAA SBBAAA AAAAxx 128 721 0 0 8 8 8 28 128 128 128 16 17 YEAAAA TBBAAA HHHHxx 675 722 1 3 5 15 5 75 75 175 675 10 11 ZZAAAA UBBAAA OOOOxx 929 723 1 1 9 9 9 29 129 429 929 18 19 TJAAAA VBBAAA VVVVxx 156 724 0 0 6 16 6 56 156 156 156 12 13 AGAAAA WBBAAA AAAAxx 415 725 1 3 5 15 5 15 15 415 415 10 11 ZPAAAA XBBAAA HHHHxx 28 726 0 0 8 8 8 28 28 28 28 16 17 CBAAAA YBBAAA OOOOxx 18 727 0 2 8 18 8 18 18 18 18 16 17 SAAAAA ZBBAAA VVVVxx 255 728 1 3 5 15 5 55 55 255 255 10 11 VJAAAA ACBAAA AAAAxx 793 729 1 1 3 13 3 93 193 293 793 6 7 NEAAAA BCBAAA HHHHxx 554 730 0 2 4 14 4 54 154 54 554 8 9 IVAAAA CCBAAA OOOOxx 467 731 1 3 7 7 7 67 67 467 467 14 15 ZRAAAA DCBAAA VVVVxx 410 732 0 2 0 10 0 10 10 410 410 0 1 UPAAAA ECBAAA AAAAxx 651 733 1 3 1 11 1 51 51 151 651 2 3 BZAAAA FCBAAA HHHHxx 287 734 1 3 7 7 7 87 87 287 287 14 15 BLAAAA GCBAAA OOOOxx 640 735 0 0 0 0 0 40 40 140 640 0 1 QYAAAA HCBAAA VVVVxx 245 736 1 1 5 5 5 45 45 245 245 10 11 LJAAAA ICBAAA AAAAxx 21 737 1 1 1 1 1 21 21 21 21 2 3 VAAAAA JCBAAA HHHHxx 83 738 1 3 3 3 3 83 83 83 83 6 7 FDAAAA KCBAAA OOOOxx 228 739 0 0 8 8 8 28 28 228 228 16 17 UIAAAA LCBAAA VVVVxx 323 740 1 3 3 3 3 23 123 323 323 6 7 LMAAAA MCBAAA AAAAxx 594 741 0 2 4 14 4 94 194 94 594 8 9 WWAAAA NCBAAA HHHHxx 528 742 0 0 8 8 8 28 128 28 528 16 17 IUAAAA OCBAAA OOOOxx 276 743 0 0 6 16 6 76 76 276 276 12 13 QKAAAA PCBAAA VVVVxx 598 744 0 2 8 18 8 98 198 98 598 16 17 AXAAAA QCBAAA AAAAxx 635 745 1 3 5 15 5 35 35 135 635 10 11 LYAAAA RCBAAA HHHHxx 868 746 0 0 8 8 8 68 68 368 868 16 17 KHAAAA SCBAAA OOOOxx 290 747 0 2 0 10 0 90 90 290 290 0 1 ELAAAA TCBAAA VVVVxx 468 748 0 0 8 8 8 68 68 468 468 16 17 ASAAAA UCBAAA AAAAxx 689 749 1 1 9 9 9 89 89 189 689 18 19 NAAAAA VCBAAA HHHHxx 799 750 1 3 9 19 9 99 199 299 799 18 19 TEAAAA WCBAAA OOOOxx 210 751 0 2 0 10 0 10 10 210 210 0 1 CIAAAA XCBAAA VVVVxx 346 752 0 2 6 6 6 46 146 346 346 12 13 INAAAA YCBAAA AAAAxx 957 753 1 1 7 17 7 57 157 457 957 14 15 VKAAAA ZCBAAA HHHHxx 905 754 1 1 5 5 5 5 105 405 905 10 11 VIAAAA ADBAAA OOOOxx 523 755 1 3 3 3 3 23 123 23 523 6 7 DUAAAA BDBAAA VVVVxx 899 756 1 3 9 19 9 99 99 399 899 18 19 PIAAAA CDBAAA AAAAxx 867 757 1 3 7 7 7 67 67 367 867 14 15 JHAAAA DDBAAA HHHHxx 11 758 1 3 1 11 1 11 11 11 11 2 3 LAAAAA EDBAAA OOOOxx 320 759 0 0 0 0 0 20 120 320 320 0 1 IMAAAA FDBAAA VVVVxx 766 760 0 2 6 6 6 66 166 266 766 12 13 MDAAAA GDBAAA AAAAxx 84 761 0 0 4 4 4 84 84 84 84 8 9 GDAAAA HDBAAA HHHHxx 507 762 1 3 7 7 7 7 107 7 507 14 15 NTAAAA IDBAAA OOOOxx 471 763 1 3 1 11 1 71 71 471 471 2 3 DSAAAA JDBAAA VVVVxx 517 764 1 1 7 17 7 17 117 17 517 14 15 XTAAAA KDBAAA AAAAxx 234 765 0 2 4 14 4 34 34 234 234 8 9 AJAAAA LDBAAA HHHHxx 988 766 0 0 8 8 8 88 188 488 988 16 17 AMAAAA MDBAAA OOOOxx 473 767 1 1 3 13 3 73 73 473 473 6 7 FSAAAA NDBAAA VVVVxx 66 768 0 2 6 6 6 66 66 66 66 12 13 OCAAAA ODBAAA AAAAxx 530 769 0 2 0 10 0 30 130 30 530 0 1 KUAAAA PDBAAA HHHHxx 834 770 0 2 4 14 4 34 34 334 834 8 9 CGAAAA QDBAAA OOOOxx 894 771 0 2 4 14 4 94 94 394 894 8 9 KIAAAA RDBAAA VVVVxx 481 772 1 1 1 1 1 81 81 481 481 2 3 NSAAAA SDBAAA AAAAxx 280 773 0 0 0 0 0 80 80 280 280 0 1 UKAAAA TDBAAA HHHHxx 705 774 1 1 5 5 5 5 105 205 705 10 11 DBAAAA UDBAAA OOOOxx 218 775 0 2 8 18 8 18 18 218 218 16 17 KIAAAA VDBAAA VVVVxx 560 776 0 0 0 0 0 60 160 60 560 0 1 OVAAAA WDBAAA AAAAxx 123 777 1 3 3 3 3 23 123 123 123 6 7 TEAAAA XDBAAA HHHHxx 289 778 1 1 9 9 9 89 89 289 289 18 19 DLAAAA YDBAAA OOOOxx 189 779 1 1 9 9 9 89 189 189 189 18 19 HHAAAA ZDBAAA VVVVxx 541 780 1 1 1 1 1 41 141 41 541 2 3 VUAAAA AEBAAA AAAAxx 876 781 0 0 6 16 6 76 76 376 876 12 13 SHAAAA BEBAAA HHHHxx 504 782 0 0 4 4 4 4 104 4 504 8 9 KTAAAA CEBAAA OOOOxx 643 783 1 3 3 3 3 43 43 143 643 6 7 TYAAAA DEBAAA VVVVxx 73 784 1 1 3 13 3 73 73 73 73 6 7 VCAAAA EEBAAA AAAAxx 465 785 1 1 5 5 5 65 65 465 465 10 11 XRAAAA FEBAAA HHHHxx 861 786 1 1 1 1 1 61 61 361 861 2 3 DHAAAA GEBAAA OOOOxx 355 787 1 3 5 15 5 55 155 355 355 10 11 RNAAAA HEBAAA VVVVxx 441 788 1 1 1 1 1 41 41 441 441 2 3 ZQAAAA IEBAAA AAAAxx 219 789 1 3 9 19 9 19 19 219 219 18 19 LIAAAA JEBAAA HHHHxx 839 790 1 3 9 19 9 39 39 339 839 18 19 HGAAAA KEBAAA OOOOxx 271 791 1 3 1 11 1 71 71 271 271 2 3 LKAAAA LEBAAA VVVVxx 212 792 0 0 2 12 2 12 12 212 212 4 5 EIAAAA MEBAAA AAAAxx 904 793 0 0 4 4 4 4 104 404 904 8 9 UIAAAA NEBAAA HHHHxx 244 794 0 0 4 4 4 44 44 244 244 8 9 KJAAAA OEBAAA OOOOxx 751 795 1 3 1 11 1 51 151 251 751 2 3 XCAAAA PEBAAA VVVVxx 944 796 0 0 4 4 4 44 144 444 944 8 9 IKAAAA QEBAAA AAAAxx 305 797 1 1 5 5 5 5 105 305 305 10 11 TLAAAA REBAAA HHHHxx 617 798 1 1 7 17 7 17 17 117 617 14 15 TXAAAA SEBAAA OOOOxx 891 799 1 3 1 11 1 91 91 391 891 2 3 HIAAAA TEBAAA VVVVxx 653 800 1 1 3 13 3 53 53 153 653 6 7 DZAAAA UEBAAA AAAAxx 845 801 1 1 5 5 5 45 45 345 845 10 11 NGAAAA VEBAAA HHHHxx 936 802 0 0 6 16 6 36 136 436 936 12 13 AKAAAA WEBAAA OOOOxx 91 803 1 3 1 11 1 91 91 91 91 2 3 NDAAAA XEBAAA VVVVxx 442 804 0 2 2 2 2 42 42 442 442 4 5 ARAAAA YEBAAA AAAAxx 498 805 0 2 8 18 8 98 98 498 498 16 17 ETAAAA ZEBAAA HHHHxx 987 806 1 3 7 7 7 87 187 487 987 14 15 ZLAAAA AFBAAA OOOOxx 194 807 0 2 4 14 4 94 194 194 194 8 9 MHAAAA BFBAAA VVVVxx 927 808 1 3 7 7 7 27 127 427 927 14 15 RJAAAA CFBAAA AAAAxx 607 809 1 3 7 7 7 7 7 107 607 14 15 JXAAAA DFBAAA HHHHxx 119 810 1 3 9 19 9 19 119 119 119 18 19 PEAAAA EFBAAA OOOOxx 182 811 0 2 2 2 2 82 182 182 182 4 5 AHAAAA FFBAAA VVVVxx 606 812 0 2 6 6 6 6 6 106 606 12 13 IXAAAA GFBAAA AAAAxx 849 813 1 1 9 9 9 49 49 349 849 18 19 RGAAAA HFBAAA HHHHxx 34 814 0 2 4 14 4 34 34 34 34 8 9 IBAAAA IFBAAA OOOOxx 683 815 1 3 3 3 3 83 83 183 683 6 7 HAAAAA JFBAAA VVVVxx 134 816 0 2 4 14 4 34 134 134 134 8 9 EFAAAA KFBAAA AAAAxx 331 817 1 3 1 11 1 31 131 331 331 2 3 TMAAAA LFBAAA HHHHxx 808 818 0 0 8 8 8 8 8 308 808 16 17 CFAAAA MFBAAA OOOOxx 703 819 1 3 3 3 3 3 103 203 703 6 7 BBAAAA NFBAAA VVVVxx 669 820 1 1 9 9 9 69 69 169 669 18 19 TZAAAA OFBAAA AAAAxx 264 821 0 0 4 4 4 64 64 264 264 8 9 EKAAAA PFBAAA HHHHxx 277 822 1 1 7 17 7 77 77 277 277 14 15 RKAAAA QFBAAA OOOOxx 877 823 1 1 7 17 7 77 77 377 877 14 15 THAAAA RFBAAA VVVVxx 783 824 1 3 3 3 3 83 183 283 783 6 7 DEAAAA SFBAAA AAAAxx 791 825 1 3 1 11 1 91 191 291 791 2 3 LEAAAA TFBAAA HHHHxx 171 826 1 3 1 11 1 71 171 171 171 2 3 PGAAAA UFBAAA OOOOxx 564 827 0 0 4 4 4 64 164 64 564 8 9 SVAAAA VFBAAA VVVVxx 230 828 0 2 0 10 0 30 30 230 230 0 1 WIAAAA WFBAAA AAAAxx 881 829 1 1 1 1 1 81 81 381 881 2 3 XHAAAA XFBAAA HHHHxx 890 830 0 2 0 10 0 90 90 390 890 0 1 GIAAAA YFBAAA OOOOxx 374 831 0 2 4 14 4 74 174 374 374 8 9 KOAAAA ZFBAAA VVVVxx 697 832 1 1 7 17 7 97 97 197 697 14 15 VAAAAA AGBAAA AAAAxx 4 833 0 0 4 4 4 4 4 4 4 8 9 EAAAAA BGBAAA HHHHxx 385 834 1 1 5 5 5 85 185 385 385 10 11 VOAAAA CGBAAA OOOOxx 739 835 1 3 9 19 9 39 139 239 739 18 19 LCAAAA DGBAAA VVVVxx 623 836 1 3 3 3 3 23 23 123 623 6 7 ZXAAAA EGBAAA AAAAxx 547 837 1 3 7 7 7 47 147 47 547 14 15 BVAAAA FGBAAA HHHHxx 532 838 0 0 2 12 2 32 132 32 532 4 5 MUAAAA GGBAAA OOOOxx 383 839 1 3 3 3 3 83 183 383 383 6 7 TOAAAA HGBAAA VVVVxx 181 840 1 1 1 1 1 81 181 181 181 2 3 ZGAAAA IGBAAA AAAAxx 327 841 1 3 7 7 7 27 127 327 327 14 15 PMAAAA JGBAAA HHHHxx 701 842 1 1 1 1 1 1 101 201 701 2 3 ZAAAAA KGBAAA OOOOxx 111 843 1 3 1 11 1 11 111 111 111 2 3 HEAAAA LGBAAA VVVVxx 977 844 1 1 7 17 7 77 177 477 977 14 15 PLAAAA MGBAAA AAAAxx 431 845 1 3 1 11 1 31 31 431 431 2 3 PQAAAA NGBAAA HHHHxx 456 846 0 0 6 16 6 56 56 456 456 12 13 ORAAAA OGBAAA OOOOxx 368 847 0 0 8 8 8 68 168 368 368 16 17 EOAAAA PGBAAA VVVVxx 32 848 0 0 2 12 2 32 32 32 32 4 5 GBAAAA QGBAAA AAAAxx 125 849 1 1 5 5 5 25 125 125 125 10 11 VEAAAA RGBAAA HHHHxx 847 850 1 3 7 7 7 47 47 347 847 14 15 PGAAAA SGBAAA OOOOxx 485 851 1 1 5 5 5 85 85 485 485 10 11 RSAAAA TGBAAA VVVVxx 387 852 1 3 7 7 7 87 187 387 387 14 15 XOAAAA UGBAAA AAAAxx 288 853 0 0 8 8 8 88 88 288 288 16 17 CLAAAA VGBAAA HHHHxx 919 854 1 3 9 19 9 19 119 419 919 18 19 JJAAAA WGBAAA OOOOxx 393 855 1 1 3 13 3 93 193 393 393 6 7 DPAAAA XGBAAA VVVVxx 953 856 1 1 3 13 3 53 153 453 953 6 7 RKAAAA YGBAAA AAAAxx 798 857 0 2 8 18 8 98 198 298 798 16 17 SEAAAA ZGBAAA HHHHxx 940 858 0 0 0 0 0 40 140 440 940 0 1 EKAAAA AHBAAA OOOOxx 198 859 0 2 8 18 8 98 198 198 198 16 17 QHAAAA BHBAAA VVVVxx 25 860 1 1 5 5 5 25 25 25 25 10 11 ZAAAAA CHBAAA AAAAxx 190 861 0 2 0 10 0 90 190 190 190 0 1 IHAAAA DHBAAA HHHHxx 820 862 0 0 0 0 0 20 20 320 820 0 1 OFAAAA EHBAAA OOOOxx 15 863 1 3 5 15 5 15 15 15 15 10 11 PAAAAA FHBAAA VVVVxx 427 864 1 3 7 7 7 27 27 427 427 14 15 LQAAAA GHBAAA AAAAxx 349 865 1 1 9 9 9 49 149 349 349 18 19 LNAAAA HHBAAA HHHHxx 785 866 1 1 5 5 5 85 185 285 785 10 11 FEAAAA IHBAAA OOOOxx 340 867 0 0 0 0 0 40 140 340 340 0 1 CNAAAA JHBAAA VVVVxx 292 868 0 0 2 12 2 92 92 292 292 4 5 GLAAAA KHBAAA AAAAxx 17 869 1 1 7 17 7 17 17 17 17 14 15 RAAAAA LHBAAA HHHHxx 985 870 1 1 5 5 5 85 185 485 985 10 11 XLAAAA MHBAAA OOOOxx 645 871 1 1 5 5 5 45 45 145 645 10 11 VYAAAA NHBAAA VVVVxx 631 872 1 3 1 11 1 31 31 131 631 2 3 HYAAAA OHBAAA AAAAxx 761 873 1 1 1 1 1 61 161 261 761 2 3 HDAAAA PHBAAA HHHHxx 707 874 1 3 7 7 7 7 107 207 707 14 15 FBAAAA QHBAAA OOOOxx 776 875 0 0 6 16 6 76 176 276 776 12 13 WDAAAA RHBAAA VVVVxx 856 876 0 0 6 16 6 56 56 356 856 12 13 YGAAAA SHBAAA AAAAxx 978 877 0 2 8 18 8 78 178 478 978 16 17 QLAAAA THBAAA HHHHxx 710 878 0 2 0 10 0 10 110 210 710 0 1 IBAAAA UHBAAA OOOOxx 604 879 0 0 4 4 4 4 4 104 604 8 9 GXAAAA VHBAAA VVVVxx 291 880 1 3 1 11 1 91 91 291 291 2 3 FLAAAA WHBAAA AAAAxx 747 881 1 3 7 7 7 47 147 247 747 14 15 TCAAAA XHBAAA HHHHxx 837 882 1 1 7 17 7 37 37 337 837 14 15 FGAAAA YHBAAA OOOOxx 722 883 0 2 2 2 2 22 122 222 722 4 5 UBAAAA ZHBAAA VVVVxx 925 884 1 1 5 5 5 25 125 425 925 10 11 PJAAAA AIBAAA AAAAxx 49 885 1 1 9 9 9 49 49 49 49 18 19 XBAAAA BIBAAA HHHHxx 832 886 0 0 2 12 2 32 32 332 832 4 5 AGAAAA CIBAAA OOOOxx 336 887 0 0 6 16 6 36 136 336 336 12 13 YMAAAA DIBAAA VVVVxx 185 888 1 1 5 5 5 85 185 185 185 10 11 DHAAAA EIBAAA AAAAxx 434 889 0 2 4 14 4 34 34 434 434 8 9 SQAAAA FIBAAA HHHHxx 284 890 0 0 4 4 4 84 84 284 284 8 9 YKAAAA GIBAAA OOOOxx 812 891 0 0 2 12 2 12 12 312 812 4 5 GFAAAA HIBAAA VVVVxx 810 892 0 2 0 10 0 10 10 310 810 0 1 EFAAAA IIBAAA AAAAxx 252 893 0 0 2 12 2 52 52 252 252 4 5 SJAAAA JIBAAA HHHHxx 965 894 1 1 5 5 5 65 165 465 965 10 11 DLAAAA KIBAAA OOOOxx 110 895 0 2 0 10 0 10 110 110 110 0 1 GEAAAA LIBAAA VVVVxx 698 896 0 2 8 18 8 98 98 198 698 16 17 WAAAAA MIBAAA AAAAxx 283 897 1 3 3 3 3 83 83 283 283 6 7 XKAAAA NIBAAA HHHHxx 533 898 1 1 3 13 3 33 133 33 533 6 7 NUAAAA OIBAAA OOOOxx 662 899 0 2 2 2 2 62 62 162 662 4 5 MZAAAA PIBAAA VVVVxx 329 900 1 1 9 9 9 29 129 329 329 18 19 RMAAAA QIBAAA AAAAxx 250 901 0 2 0 10 0 50 50 250 250 0 1 QJAAAA RIBAAA HHHHxx 407 902 1 3 7 7 7 7 7 407 407 14 15 RPAAAA SIBAAA OOOOxx 823 903 1 3 3 3 3 23 23 323 823 6 7 RFAAAA TIBAAA VVVVxx 852 904 0 0 2 12 2 52 52 352 852 4 5 UGAAAA UIBAAA AAAAxx 871 905 1 3 1 11 1 71 71 371 871 2 3 NHAAAA VIBAAA HHHHxx 118 906 0 2 8 18 8 18 118 118 118 16 17 OEAAAA WIBAAA OOOOxx 912 907 0 0 2 12 2 12 112 412 912 4 5 CJAAAA XIBAAA VVVVxx 458 908 0 2 8 18 8 58 58 458 458 16 17 QRAAAA YIBAAA AAAAxx 926 909 0 2 6 6 6 26 126 426 926 12 13 QJAAAA ZIBAAA HHHHxx 328 910 0 0 8 8 8 28 128 328 328 16 17 QMAAAA AJBAAA OOOOxx 980 911 0 0 0 0 0 80 180 480 980 0 1 SLAAAA BJBAAA VVVVxx 259 912 1 3 9 19 9 59 59 259 259 18 19 ZJAAAA CJBAAA AAAAxx 900 913 0 0 0 0 0 0 100 400 900 0 1 QIAAAA DJBAAA HHHHxx 137 914 1 1 7 17 7 37 137 137 137 14 15 HFAAAA EJBAAA OOOOxx 159 915 1 3 9 19 9 59 159 159 159 18 19 DGAAAA FJBAAA VVVVxx 243 916 1 3 3 3 3 43 43 243 243 6 7 JJAAAA GJBAAA AAAAxx 472 917 0 0 2 12 2 72 72 472 472 4 5 ESAAAA HJBAAA HHHHxx 796 918 0 0 6 16 6 96 196 296 796 12 13 QEAAAA IJBAAA OOOOxx 382 919 0 2 2 2 2 82 182 382 382 4 5 SOAAAA JJBAAA VVVVxx 911 920 1 3 1 11 1 11 111 411 911 2 3 BJAAAA KJBAAA AAAAxx 179 921 1 3 9 19 9 79 179 179 179 18 19 XGAAAA LJBAAA HHHHxx 778 922 0 2 8 18 8 78 178 278 778 16 17 YDAAAA MJBAAA OOOOxx 405 923 1 1 5 5 5 5 5 405 405 10 11 PPAAAA NJBAAA VVVVxx 265 924 1 1 5 5 5 65 65 265 265 10 11 FKAAAA OJBAAA AAAAxx 556 925 0 0 6 16 6 56 156 56 556 12 13 KVAAAA PJBAAA HHHHxx 16 926 0 0 6 16 6 16 16 16 16 12 13 QAAAAA QJBAAA OOOOxx 706 927 0 2 6 6 6 6 106 206 706 12 13 EBAAAA RJBAAA VVVVxx 497 928 1 1 7 17 7 97 97 497 497 14 15 DTAAAA SJBAAA AAAAxx 708 929 0 0 8 8 8 8 108 208 708 16 17 GBAAAA TJBAAA HHHHxx 46 930 0 2 6 6 6 46 46 46 46 12 13 UBAAAA UJBAAA OOOOxx 901 931 1 1 1 1 1 1 101 401 901 2 3 RIAAAA VJBAAA VVVVxx 416 932 0 0 6 16 6 16 16 416 416 12 13 AQAAAA WJBAAA AAAAxx 307 933 1 3 7 7 7 7 107 307 307 14 15 VLAAAA XJBAAA HHHHxx 166 934 0 2 6 6 6 66 166 166 166 12 13 KGAAAA YJBAAA OOOOxx 178 935 0 2 8 18 8 78 178 178 178 16 17 WGAAAA ZJBAAA VVVVxx 499 936 1 3 9 19 9 99 99 499 499 18 19 FTAAAA AKBAAA AAAAxx 257 937 1 1 7 17 7 57 57 257 257 14 15 XJAAAA BKBAAA HHHHxx 342 938 0 2 2 2 2 42 142 342 342 4 5 ENAAAA CKBAAA OOOOxx 850 939 0 2 0 10 0 50 50 350 850 0 1 SGAAAA DKBAAA VVVVxx 313 940 1 1 3 13 3 13 113 313 313 6 7 BMAAAA EKBAAA AAAAxx 831 941 1 3 1 11 1 31 31 331 831 2 3 ZFAAAA FKBAAA HHHHxx 57 942 1 1 7 17 7 57 57 57 57 14 15 FCAAAA GKBAAA OOOOxx 37 943 1 1 7 17 7 37 37 37 37 14 15 LBAAAA HKBAAA VVVVxx 511 944 1 3 1 11 1 11 111 11 511 2 3 RTAAAA IKBAAA AAAAxx 578 945 0 2 8 18 8 78 178 78 578 16 17 GWAAAA JKBAAA HHHHxx 100 946 0 0 0 0 0 0 100 100 100 0 1 WDAAAA KKBAAA OOOOxx 935 947 1 3 5 15 5 35 135 435 935 10 11 ZJAAAA LKBAAA VVVVxx 821 948 1 1 1 1 1 21 21 321 821 2 3 PFAAAA MKBAAA AAAAxx 294 949 0 2 4 14 4 94 94 294 294 8 9 ILAAAA NKBAAA HHHHxx 575 950 1 3 5 15 5 75 175 75 575 10 11 DWAAAA OKBAAA OOOOxx 272 951 0 0 2 12 2 72 72 272 272 4 5 MKAAAA PKBAAA VVVVxx 491 952 1 3 1 11 1 91 91 491 491 2 3 XSAAAA QKBAAA AAAAxx 43 953 1 3 3 3 3 43 43 43 43 6 7 RBAAAA RKBAAA HHHHxx 167 954 1 3 7 7 7 67 167 167 167 14 15 LGAAAA SKBAAA OOOOxx 457 955 1 1 7 17 7 57 57 457 457 14 15 PRAAAA TKBAAA VVVVxx 647 956 1 3 7 7 7 47 47 147 647 14 15 XYAAAA UKBAAA AAAAxx 180 957 0 0 0 0 0 80 180 180 180 0 1 YGAAAA VKBAAA HHHHxx 48 958 0 0 8 8 8 48 48 48 48 16 17 WBAAAA WKBAAA OOOOxx 553 959 1 1 3 13 3 53 153 53 553 6 7 HVAAAA XKBAAA VVVVxx 188 960 0 0 8 8 8 88 188 188 188 16 17 GHAAAA YKBAAA AAAAxx 262 961 0 2 2 2 2 62 62 262 262 4 5 CKAAAA ZKBAAA HHHHxx 728 962 0 0 8 8 8 28 128 228 728 16 17 ACAAAA ALBAAA OOOOxx 581 963 1 1 1 1 1 81 181 81 581 2 3 JWAAAA BLBAAA VVVVxx 937 964 1 1 7 17 7 37 137 437 937 14 15 BKAAAA CLBAAA AAAAxx 370 965 0 2 0 10 0 70 170 370 370 0 1 GOAAAA DLBAAA HHHHxx 590 966 0 2 0 10 0 90 190 90 590 0 1 SWAAAA ELBAAA OOOOxx 421 967 1 1 1 1 1 21 21 421 421 2 3 FQAAAA FLBAAA VVVVxx 693 968 1 1 3 13 3 93 93 193 693 6 7 RAAAAA GLBAAA AAAAxx 906 969 0 2 6 6 6 6 106 406 906 12 13 WIAAAA HLBAAA HHHHxx 802 970 0 2 2 2 2 2 2 302 802 4 5 WEAAAA ILBAAA OOOOxx 38 971 0 2 8 18 8 38 38 38 38 16 17 MBAAAA JLBAAA VVVVxx 790 972 0 2 0 10 0 90 190 290 790 0 1 KEAAAA KLBAAA AAAAxx 726 973 0 2 6 6 6 26 126 226 726 12 13 YBAAAA LLBAAA HHHHxx 23 974 1 3 3 3 3 23 23 23 23 6 7 XAAAAA MLBAAA OOOOxx 641 975 1 1 1 1 1 41 41 141 641 2 3 RYAAAA NLBAAA VVVVxx 524 976 0 0 4 4 4 24 124 24 524 8 9 EUAAAA OLBAAA AAAAxx 169 977 1 1 9 9 9 69 169 169 169 18 19 NGAAAA PLBAAA HHHHxx 6 978 0 2 6 6 6 6 6 6 6 12 13 GAAAAA QLBAAA OOOOxx 943 979 1 3 3 3 3 43 143 443 943 6 7 HKAAAA RLBAAA VVVVxx 26 980 0 2 6 6 6 26 26 26 26 12 13 ABAAAA SLBAAA AAAAxx 469 981 1 1 9 9 9 69 69 469 469 18 19 BSAAAA TLBAAA HHHHxx 968 982 0 0 8 8 8 68 168 468 968 16 17 GLAAAA ULBAAA OOOOxx 947 983 1 3 7 7 7 47 147 447 947 14 15 LKAAAA VLBAAA VVVVxx 133 984 1 1 3 13 3 33 133 133 133 6 7 DFAAAA WLBAAA AAAAxx 52 985 0 0 2 12 2 52 52 52 52 4 5 ACAAAA XLBAAA HHHHxx 660 986 0 0 0 0 0 60 60 160 660 0 1 KZAAAA YLBAAA OOOOxx 780 987 0 0 0 0 0 80 180 280 780 0 1 AEAAAA ZLBAAA VVVVxx 963 988 1 3 3 3 3 63 163 463 963 6 7 BLAAAA AMBAAA AAAAxx 561 989 1 1 1 1 1 61 161 61 561 2 3 PVAAAA BMBAAA HHHHxx 402 990 0 2 2 2 2 2 2 402 402 4 5 MPAAAA CMBAAA OOOOxx 437 991 1 1 7 17 7 37 37 437 437 14 15 VQAAAA DMBAAA VVVVxx 112 992 0 0 2 12 2 12 112 112 112 4 5 IEAAAA EMBAAA AAAAxx 247 993 1 3 7 7 7 47 47 247 247 14 15 NJAAAA FMBAAA HHHHxx 579 994 1 3 9 19 9 79 179 79 579 18 19 HWAAAA GMBAAA OOOOxx 379 995 1 3 9 19 9 79 179 379 379 18 19 POAAAA HMBAAA VVVVxx 74 996 0 2 4 14 4 74 74 74 74 8 9 WCAAAA IMBAAA AAAAxx 744 997 0 0 4 4 4 44 144 244 744 8 9 QCAAAA JMBAAA HHHHxx 0 998 0 0 0 0 0 0 0 0 0 0 1 AAAAAA KMBAAA OOOOxx 278 999 0 2 8 18 8 78 78 278 278 16 17 SKAAAA LMBAAA VVVVxx ��������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/prices-10k-random-1.tsv.gz�����������������������������������������0000664�0000000�0000000�00001124440�15100345067�0023217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������‹3‚jbprices-10k-random-1.tsv�´ýÉrãÊ’- qžB³;9ûúf`#�€IqÛüïÿ¿/÷ðˆ�ERTV}VeI(ólŠ"<¼YMeaDU•ÿ…ÿDiЕAÔœ‚( ¿ ⤠‚ÝTïëãÛ4ÖmÐC;ú²¯7Cw¥ÿEW/Ýôfþ:üO†ò®Å?aöOsùgkÞ6Oè]û®éôMÏ»ý8ó¥æ®þöþ' ù ã0Êþ é“–Á²’ º áwœêv§·ýxž» öã±›‚ãy³»tC?n>‚y?§y˜:ÿ2üO™˜wNþ‰¢Â(zûª¹˜Ïe|†÷àR÷A°§æjþ¤ßŠ9-ã ï˜òŽaüO˜þCÿýÐ%I.ÿ)½cäa4‡i³? ;úÏÞê?Ýp¦O5ž—ý½I×·óÝŸ–ëÐ͇¶ pñV-}¹z¢ß˜&™ùô *þSTqÿenÏoó¶—¥ÞÑý¡»ÝÚgJw¨íé³m7uô·A3u›žÞßn;ÒW¦'Pš'ZÒÛãKÍKTét¢/Ä·‰é|¢uÐŽõÇüÖN‡?ô•ú=ãÔ>¹Ð›‡ež•¸k9ÿ‚$ØlszÛóÞ|…ÍeZÞ†îrm[zÀÍø§›¬DúœËå°¼ëwZB˾{ûS÷ÝÛ¸}ÛõõqœvõðàoÃÿU•ñm ±ªâ,8u¸kó â* ›ƒßо»ËàSåãóùè楣§ÐíÛŒý°^St³*¬�z—m${ý*1Ý«e˜—¾»Œc+OÞ?—ú£ãÇå_Ñïy»ŽÓ‡þ‚(/䓇´jc<Žf*‚¬Ì'§¿ØöõòåÁåÐ÷ãåm7Ñ hÍÍ}·?Oó²ºn¦ñØßÛÈQ‘ºÅL·¨¤µCA¢h{o1·]=ìé×Ð;OËMŒ˜›ý‘.ßÎ'ZëØ+Ýüý÷”i&¿[ðºAsG¿«üì°´èÿ,¯åm×Ñ£ëæ·M?Ò>_ÿ¢¦ûºûJ ü£(û8(¦+ïoºU1­¦é<Ì—Ãæãm^¦®[(BÔúßµØ æEß÷X›=ž;6^¤OVmœ§>¡|ÚkôHéÝ»iºnÆñØÈ*¤ÅÛƒ¾p¡[7 ]úÀ^ ÄrWâ·u4=Ñ´YÌB¢›ÒõG~„æ–ÔÃŽ"6sXh}™ÐÔô eÍçyî¾èÝóDo -Ñ¡ò Z4¤bÓÐf¡p†Þh~ãl¦ñÒŒ‚6½eÝ·´ºzõÖ¡ ´hâà°£›²ØS1uOq¹»ÊÚ?ô¼©ÌËÔµÍth)P}_ŽQiîwɱ•îH“eûnfÁAˆ¾þýgS½¡5Bwd?MOGUsž°›¦çÕBÿ¼©í¶Õá†ÐÃ&Zw%Ey³o£Àß5òÙ7õÔ#ŠÓþÿC{�«÷yÜ.´)6Ð/™Ï[¢©Y/qdΆùHŸŸv„‰¢iŒíD[d0gc€µ ½Ï‚—ïwEßU¢AãÝšø}§¬øqÒ·¥_Õ˜5¡¯¼,Æ/ýk:\ªXBMhBM΂Ô�:h­;s6¶´“–šî° ‘M׺7[ý€˜_dzöÒ¥]ê(WH&=¶h™Ð·›ëðè™"Û…V"ß‹º5ÿïÿÌoýuXÿ`ŽGúfz†¹³,JS{æcãtæ§A¹¿Ú#Ÿ²ži¤;FO™““> ï°tm#t¥gKiçñ#¥ouýÄ=£ÿÓÀðv­iÍo(ÃXoîQ°é†eªûõ ¼û—tŽ•&z†|Ó`ÚGaµ[óŒ8z"Yë;,Uù2ô+/ØúºŽxè^ÆEïÙTôñé?Løãïñ`¶õt4A?>ºáÐ_øéð/øÆ /ƒþ°?S<³ü‹Ž‡çêŒO¯«Wt\G:ŠÓ÷wåèÑo%‡á·(wãßþƒD ØütÌ»Óòá?Ð̼H_2¤xÑ—ü2 ¡éjÊ ÿº ¥õ4pòE~ØâkšÞÓ1ÍÉÒæ|¤¸…t5Õ@’sd¥ÓyNÒ ›·�éФkk0ûT/›ý¥¾ÒYD‰ÁØ›7ßQn¼áÓƤ®wÿ–"nî2Î7(Z¥t”ź“ðË:óÛ‚é¼£°&^ê gŸ¾U†TÏlŽìÚÞÇZLU;˜[r¤ÿ=Ÿ&¯tÂÌx ÇGùêÓŸèö#ÿ’*‘Û° ²zѨ•H“нÂf;ÕÓ‡¦¬Ý)ôìÇ;»3N4PRð—ìèK&ÛÙäH è·Ñ ~£ì˜v¦ü–t„tÈŸieÓ‚_°ÓÃÄ-"ü?E1J¾‹Zs�毧îíÔãP¢øM_ÇäÁ”ÔŽËìÏ~C«rSå´Ï¥JíÙA¹LœÓŽnQÑè>ÁÙq¢MÎa> 4»º©gzWz4Íáy[àÖب•˜¨s°§%Di>½÷»]Gôô·Ó¸ãí/çßžr~ìs¼í?ãðePt_VùýÛq'Ùî·yQ¸ò õv”ȳ-@“ÁÊ.–N’„ËÔQ¸×Ê•ÂÌÅt¤ÝÈ )Šìw^gÒt�ÍùIé̵½{¬f±K62ÜŒí5ª©¶‡u„ãyârÉœNœgœFڿϯèÝãо;•mt@PêHoÖSˆ0­äŽŠ)Š¼ÌWwWSGÙðÙ+,–Ë„‚¹Ûi.ƒtÞSlBÝþouO¥ÕöT ºµþ ÷FƒvŠ DŸ‘³lvÞ:™û«f1ÍÈ;Ÿò.Ž^ • Ùô*‹ì¡P™…H‹Þ«õ�îMƒÿÎF4Z†È{o_±ÙsiPÐ.”*ÖúY ,éë,ÛfGIy= ”uA;Nšêó™E?ÏQÍ Þ˜>¥éЬ‚]O‘=;}š�¶Ùק®7M äz´’w´Æäž,Ý…êGÊI¯.¿Gù(É#ZÔòTé¼*‚™2v �)?Q¤x²Yæÿ¾Q°jŠ˜Ë‘¶ã}i:q[¿àœ÷9:ï^ñA³:,5[é¡©³?ÑöÌÞÿÕK;ŒìdÚê.Fä϶¦z>b1-«Å”±Fì†4è¾â [ô>©Þ˜ê«É4øL ÝP6<›­Ü}uxJæ¥íþHåç%Ê~¦?òéb|ŒSøŠÏ*›—ž2r>:û®£Uú½ì.ܹŽÎUt~ÍZJ&H³'ÊÞ© ´”¬7sGüËýuh¹Y­úJj̸¤LˆÊÓ´{×–œ“Ð!ÙùÁL÷];ÿZÄê+D^Åšã)ž¦2Höµ²DmV/{/ßâÅp¢÷ò¯º-Ÿ÷´:»+'F´D´ŒG­]HâC;¢xׄ*§/pÚ”)~½!ÙÁ;Qê"LÞ#yù—ÛéwT!e9¦„Ê8nŽY g³X¦šŠÖA6íM!øø6’®iù› »ˆÏ0ñ“I«'vŽoT¦Ûó©]¼$Û˜"a®MÛŸ¹#õíOJSM4yãb…ôf“6D+T–=­A]ϦÐ×ï ÖÔÔa®ÉÀ> ’¶1¡€ºu \ ˆ\¨‘hC¹ x>O½ÐâK܉‘ ÞlѶô3ÒÖ vT<ÓâãgçZR²2´w.èt®l{K#£“”ÃÜèº.¨Úœ‡ž’y=1^>Hs¯j°Ë/yPuƒyë´DR4mé;ên¹ía±¶Žú2HŠ¶çÞo÷xE¶iÆ`ççˆö—?Øœ³võÐê‘ÄŽÏkân@ž´º¬û¹¾Sùç5rá<.iž¶æy¾×ó ð¿o‘¦Æò©å 5ÝMCŒYúºß¾I’FE%qœs IiIϽF�ÚRe†Ö¦xÍa:Ò²áÖðÝËÛoS…®£¯Š8™R….¿¡¢•„ï3˜Lét»\¸!úsÌÕ±òiÖh}Öæ1Ð×ÜQJ‡öËah§3=Ÿàã0}`5â©H$¦2µHâ]ÑVrKUšV·í‡<(®ÚÃéFûÅë=îÞšóæc= 3îjô»ƒ(ôêô”{ÜK»Ú$5tßG ¹»zj»Áœv”Cðûзè)rbà]j ’¥îŽsѶ½&Aµ×î|JõøŒ–›)Ù^ÚX¶ùH_¿£{Ï´‚¤:Ãa\§ÒCw¹³w¢ÿ¤%eJöÜÄÙÝSÚE‹;–P`~CÑŸÒh¹»’/Þ¼ÜïÀf®÷…ÞGEËžŽƒÏOóÍ9Ì7õðÈ#31€VȼAG–‹E*Mi½Nwθ 4â&QIoŒŠZçB9Îúz[SF7™mB‡¦ûƒƒ‰ÄHiŽê[?ýGnq¢*Öf•òÓ‘ÂANÛ…vú_S-£™û^Jª7*!Û©ÃiQ_gÊ)²còe/芴£™C­£’ÃŽ è¶RîO7Ää¬cJÊI1;Ñ\Ã<Õ…OzÜ}·ÜièÇÚ©E.CÙb|,.ãÏÙü®4´G3}¾ÍÞ¾?zÚ\IÊ° ëM%ìΪÌ°Äx6ÜîHÞÏþr¤ÿµÍÏUæF Ï:Ú@¨äͨ’–\ÈL§úhü UPXAXú¨cè>ÉœãŠZ‚n‰$7ßv‘û•öÖöJò¤¹E„ a×a•›0p¯÷eÓÓ3B .ש[‡Æ"ö’»ï;~¡êk´¡J÷v8/o8þûV”5ºBCwmÐL=J4n§+i\`Ö´$ž]öª_ö¨€nÚÄ‘üny&œ—Í;Ú%õÅ4 1òÅ"y£OÛ\9ƒdz†‘¤ì…uað­L¨\ógd,ŸI7's×ÐÜÐ3’¶'…‰‘~šº]Sd‡î ­Ü©¡ßn^ðÉ+³ãRþäT+¸ig¾i2!ÂùV/”ì]ô� “¤VÞOEÙ'aìÛ2(kMO’@:©óõséî„”ln[ ’úáì¢rä^5iï¤2ïÝ#©üÜ{ „éÜâ8‘G«ýÛW»B¿üÑùKé´þl4µ>̦°07yõW²Ï´}}ûê5<ðqK^ =7³¤ÇƒÈ+ßæýæ^ŠšÕKDoV¸°ÏÛ]Oa?k2V`aæHoNÒ#¤ÏÙ޼ܩ±½a '×ÁŒ¸ÿ©5XlÓ<»´á~Á&<·ŠMG¸Ø7Úƒ(éam¥?jÎgùé/ûÁqÛgIJ諤­ŽSN‹?lÿö€ÿš˜Q2M=Ó‘ÔÓFî~bÈïý§ªüö-•ýÓ¸ö[¤d {ZjvàG¹Kƒm¯ëþA²¡ŒPšCÝáæáTë’¾¤S% ’åSÛ¶ià¥}“i3ò|òCŸÃSèÒ†0”)%¥<”Eu¶zÍ i c”ÀßãÔ×x:—ç ëDPz†ÿ/ƒaGçUøYë¢ÂÆÑÎmÓZùþèDI 7æ§Ew‡¢ÄăØÛ§‚úÛÁnè€O¨D©‚̖ƨ¾»£Ü[·z/#~š¿>ýé&ÍO4�¡[ŒT?Ø)Xæ½íÞòŽ>,K§¹ ÿ�O„žèH¥ÉùÐKx°'»Ý)ˆÞs©)ûé®ÞöCšrÍäì8qïÆì˜vwÁ掶?šÏ.³£lTÇÚ¶ë縠ȶ@"žÎ`5ʇ>ŽÏŠ¹)ô 5dpŽóôs”‹>_¼%­„ñO­Íç×znyê£n(]Ûì)ʽ_Í'Ř²––žÙÇô¹¹zÚN BÛ³S~;ï©‚«¢bTÍë‹¥QXDRv°¹ÅÊàŽŸâ»ŸˆÇØš›KÃÖ¼a†í�`Åê¹Q"¶÷®8ϘÆkÝã)ßÌédcÆ(œvç4(É%>JmsCó23‹ôÖØÕ–e™Ý0öå©£õ·:îÀøa[&W5IXÏw7´ùy~SÚ?a„S\Ú<H†“Ž9cžvŸMÖõ|›¨øaPïx,ð™Öñ÷Ü(­€‡ Œb §½®*võaXŸÖ>í!œ-*µï«g×îLéû~Ò1]Ä«=GÌ91¸wÓïÞ~mxæfÈ<\ò 3­* ÓM`ÒÌu¡ÙðŒé[˜ÍBS¦æ8œ(¯«-ˆ¨àaO‚¥ãûÑÍT,ÑÅá4óú3P útÒ"tÐ( ýšƒ’+Ù1Û­¦t‡©|G\]$½}°Wì3SP£ca&mïæo@N!wã¯/÷5£Ê¯nÇ‹¼ÿ½®wD7Õõ1€ì¡ˆEGäéK£õ¦Þjídè!‹_„ÏŽŠÔý-ZÜ¿=Š}Œ'…/ P1C2M7c EŒv¡t4fZµÈÆÐäPgŽ•Žë¦}ïÕ(2+]Š²YhI[E•¢w“ Rñ°¼ˆ@@ž\'£¤Ö¸g¦_‘{óTÕU|ZNTsúÀ-“²˜<L_7‡åŠŠèÑϼWÅX‚º’VMÔ¾¯[“6Cm…CU‰-çÛCðgå;— u¸9Ò¯ùÔ3©ÐmÛ`{Ž”¯˜—30b3/ÎÎ�?b›«pmJÏu³-â Ü¶§ZÓ9v¥w¤’ŠŠ6ztËLçtOu$ýeGÇeYËuÓŸ‡`¢ ³mi±]d^5í—;HcéÂcŠiiçT$aʳk‡pKçÞ•¿œJô?ð xä'¾9×£©ôµ±r8,æ±ånÛjFQc»Õ2iJ£"×þ¾´ãç® ’mmÒá=F2ç ÏÏöp-BswîÑúŸf¡Ò.nw9Ì÷[ÑQéµ<M(ƒªm5"§¨ì@èM¹øáÃôŒl¯îɌ،¯üe0 ·'J‘ÛöRÖ<h{Ê…kí(¢\©'4‰;—J¶õ¤Xµ/)}ÌÂ�n…rëŠjcÍÃŽ5Uä›Ë!ÊîÑþNÒš×­[hnçqº°ùCÇmÙ_l‹;pç³âÊΗuß/¤&éLN~Ó<Š"=ùYP%Ôä›&MÑ’”R:3I£Àù( ÝY¶¤wI¿â¶ ]’küfŠ¸ iG·Cûÿ ã½}ý>°"èÓÓ=&AÚ™åšP)îfÇôrÆøÎhh^úsÿò~ŸV·wÌ£AK=¥Zy»õ²îù< È¡°¨´K \Âuà@¸‡‹þ‰y•ÍÝLʳ£ƒ@ÙÑ-Ñ#¥<šn6\w,R¥Qy±¦ŠŠ*òOD‹© â¦ÑÀQHÉI"ïqç_šes»| m=qË…Öåf¤í\6­y´–ænøô¶§eóF¡„"›~%i•¾qEÛ½ õ¿Ý½¿¢ê«åù»†ø4u!>b´õ2P¼MzeÍ× @òT"LPÎ8“‚óæCaé÷À¿©Õ ÚõT´´¢ÍM“#1jûx;ÎíÄ]Ø =ã°×Eæ1׃œ¿È‘0µ&¼6«ŠSÉ’!½å¡ÌòiÒŒ=¥×Í8Àç1Ehß´°ÐÙê<O©§;6Ê)g€3tµ¼¡„é@ÿãG¯tžån Œ Úç³éÕý’¯ß"Úž,›“,$aB¾è*Fqö”},ºKJ´Ô›=£tzÕG™Oõýåý§H¼8„S ˜?":–gmSí€-»ê!à>©¶‘¾øAË ïŒSW€ÈÒ\mñ¨­B)êýÍ‘öXº×n{¼ÆÛŸs÷ß·Äð&ê`ÂÔ܌ȥÜàøà®t3% £—¹pXóï®s"”uØ Xí´§°_ôE¢ÑI³ÎöhC‘ûÑö\Ì€º?]k‘+/6£utŠæV‚,¥Ï‚|RTj„ÌnƲÁR–;¬¨dNPx.è®VÐ'â.”Ü›¯é»×µ©Ðct̉- r©ÏÒ_¿P¢wš§±Wü£óú3÷Þj´Ù‘›d(™Qø º‹-Ïa€ÈŸV¨Áøéh2ª‚}›e§ƒ$Æ;JYÄoÕrx}µC_`q˜•Wâ~·-îÎæi%–tߣȣ¸2£tYä=]Ö]ÝdU^™ð(Àï´¹z‰%9ô*LN²=Á¸x×ÿ¥€äÖÌâp&âw/ýoV ¦ÙË…±u@~J8v:ÓÕ;ª;6Œ÷xð«#?ÜÇŸÿ JŽ‰e:È“–Ÿ � @Ó.tŠüd�/Œ)>-W¾´›ŸÍSË"Ê >£Z³<+žòÏb3¯?hÿ\ÿ¡„Ž>¨Ÿ²hâ’fT5Áá0Lô ÊeR¨¡kh]HI:â5UÜ£h°oèy±Â_ÔA§Ø2ÑÛ¤öÔÅ19éB…¿éåíëkß™?OÝp9В𠤹—yrYÙ´töS`àÞ;ê}íPQê‹r¿ä.~£å6‘D=†K$´A4'Ìy>¦9úOÈê 3;?~$A1L¶nt_·ˆœ ¶ï;ZοÁ­»ui(eÔÕòeÛ†ÈqÎóž©ÌÞ^o¬Gÿ‰ªÔG]›Ñ É‚p×xgJ;½-ã„–ª ±º í-Š´¯v©HÈø΀Iì¨QTµÌ½õ{g"[Üq|kÎÒ/ÓAN"oɉó ÀþÃ=´Zn„ðŠ>nž{ãºR<}üZ~›DšyÿðA©ÌÀÙ¯ ó±é&]þþ8ß2ÿ÷ÐS¨é„Ëεé'¢ã‚ãAŠ|­0(££å™žBÝÓoœ¿UÃ¥;ÞðÞy°ÿ¢Ç0ýëËéÓÐa«w…Vía[Ù× W 9ú>È-×FHØ—Ùbó¯î)1<½Ã¾ëÑSsWk(fzsgtVO´yߕĦ–  i‡úhk¤¾îîip‡yZe[ú[ûŠî™.O†¨fÊÚ²÷ÞÄÞˆ™²CÇ`gs›é±ö]ƒŽ–d‚õ-�·2D·Í>¥"ø}k7†Ìêëap÷Š’JËåü?P~}“¹ä^4– �¶ï¼.ݾFËœg&¡xá©–qæ3ËQ Òº ?}ã¸ÆÞá5vZ··ðê#/Ì£„fPêLk/<YðvRwDã„‹ufõÔìXPœ S0èÌÒ•W"̨™ÇÃ1. u,$ùQ`βT™>Ò;ïA"þÔà $bª8OÈÄM¨¿—p*‚íf¥+®ÀL!éèû,‚ØâV9JtÄãeàŒ€×'GFÇ­ä±ÂŒøßаPòÔ›@1ø>¿¨:_ô¾ƒ*N)\¿¥mcn‰Ì-Ö/â=õ2C<Ç$²¯w/oC@œ_]ƒîy”yÍrоéÀˆO /H1|Û¸cvôÖG¤jÏ)¸\7ÒÕüÖ†J¼\€›73Þ¾ÑIEÊT•zrá‰Ó*ŽÊÞåmç:«\î]¢ ì² :Û¡)ò Jš6˜˜(BPªoó:Zò`ÿص^—?Ê\!ŸZŒRJÀ-î8ä>ÛQ2½ùîB›]tîD/j¯îþ^„£f¨ÓxÂÇ«‘)ÿž¬BTêƒË ·eÌ%\1mI92fo,çEÚÑçIÃ#Ïä³"XÝÒ­¢ÒãA,ÂÐRmk$²žÛ3+öë‰ct…Ê£-—´’§$ß(‰Ý ›×•o8;õì¯xÚþ1F§Øª‘aêëã8s9€OÎEP ÚšÞ%‘R£Ä“éúÉÿÌ…O 8É8ÿûomUžR–½Î{Â3Õà6n&í^{üX ³ç¥‘ápÂã;š#Œ\ÒãÔP égÓBÚœ—¾žg'P`v-Û*eÍ&¤Û³ý·(îÈmOYôí@5]o;ÛLE)è1EÅàþZéý”^!-ÿSŸ¹mž€aç6Sžú«Ô¯:r{üè;'&x¬IÊëwÇî§ ¥:mºÝ®–nðïÈ“qä£Ì7š¯%w‚Ô©”è¹AÆI;p%BiiÏý@¹« 5D ™Ò>*ÍAœj×vpD‡fœ>í¿Ü`þ|hʼ*¸”A^+äO è#͇q0u�=—Ÿð75�ÅËYUm45º�¸;…ÚJ7ÃãlÍݧ…Ø@^zbÔd£ÐxðJJžy(Š£=äfåDEVŠAZãÒÛ—{Œ&×ÌŽ 9ýc¡[¶®r¡/=tº¶((i3õ PQ…‡¬ó.Ý&Š7`cæ+#©¤7në;ûšÆVqw Œ÷0Œ‘ßÃÔ¨*‚´?968Ö`7)ÂiêÚö@üÎÅ·\ ôHóhŤﭕži„˜ZKüíâÈ<ÐSÉ“¢™>ü»¦ZEÅâQJ/oþøü…T7)=F/ó'»<ˆw;÷0M³…·ç˲$eâOàƒë);¸Ø <—×]͸;-˜Æaqu=.óeìï>Ôh„åÁì¼ã@fJºUEÌ_‚ª–I˜ù¿Ö…¥_îRÐÜL`Ì*ä'‰M;À½NTBB¼RªR«m,ã™ à”õÐíïµ ¥©2ä~Í—ºåȵÜ\óïóúý«Ö©ùϹ@áhé­ºÖÁ.çÃiqóS7ÐJ¥3Çhc@Þé{çªÌø…ÁnÿÚ>‰*í¸7ú;Õ´8ôKQzº Ü$ÃìÚ�íÚæzvÁNm˜˜’!g[œH§É Û¡CAo„ÙåÆŠý•¦Œ¦ˆ¥"wM4ˆ/,eÆ2Ü Ó\€Â(rsU¢7ã¬f`n¯ðÑM¢Ø¹Yn�yÍ\R-ç gxCâ¿�åD¾N�k¿´{º³µ~ð§(( Õ0]Çö<qÍ1žz»»?ùsD.6(žã£''…·Ocôžr N)…óPNç—i°‘ˆgØhÓ™Y··C­ šõñ†5íõ•íÿÄ¿z„°ìGN|Y­ Nƒ¸þ2­µŒî[Mß°í,Ö—PÓ×ÿÒ»Q˜0C¡`Ñ­d rs—`@sëæ—ƒ¸äÛÿ�®%ž†çÓ§¾ ¦õ¯Ì¬ê hõ}w•œ ›[Þëž D¤˜Œ/6 %,G1q hye0EÀÆ°¢Å´K!#§ï–fô J63¥XâtþÎ ’™ßjŒJËè&\lèŠ *6·ž0¡ `Ú®¯)‰ùM{ÖÍý£r";Z.¦¬Y†>výÑ9Á@%Ý»ºmÊÆaaûð" CÅ,’³m±ñÁKAìGôrúÐÿXLú#úlÑ|:lœÞÄæÜ÷£,4”À²t!DU‘­ÉƒÝ@\õ~²° $IcËMvyÇýضÝÌ„½z†ÏZ!xhul¶)gmÐ~ÃnÞPÖXc+e”‚ Žˆ`˜‰”¿úáUÌ^Rde©`àzèÀ ƒ|Ù{‰OÝŸöµ•œú!/°ú3u¶™èKÞ5ªA6Óö{ .='9@êñð�a™/}ÿƒ´ŸÞ‚¢þÕ}‹L¦ôó›! ’ZwA"êw”^[ä ¨×n²VÀ¶öã2ÝüƤ`•9 0œÃD(ÙÛs(sͬ ÍÓOêœqa:"•éì¿RÊstÉmŲû+÷[ØóJ;ÛBÆb!uÓù¶¯‚äý_˸â&.S Q\ÉÿoæÍ%­¯3pþ¥ÈZì®ÞaE46:>æcf¦…s@÷ÌÑžO*Jø˸xº3?¤`Q¶‰>ÎA³÷ÆÍJ˜TÉ8e¹‘wbsQ<@‘>º}4ëI-X"#eë½U ‰¥É©Y.•ÿšêß¿tPàÜéO&,7sƒ|;(Â;’-’ð9÷SwñšGr»©WܱRífOa+k-43¢6×/¢õ„†šîâÎ'*üÆæßsíÞkkÖÓîª9ºc»£‹37Ò¤¥*oSOR 2Óíî_úС &à8´X>­B”Ýf v':áý?ùM;¦»Ö@¾ÈPÖv8Ñ›ïŠúDGü:kF”�_YLàÈ[ƒ:¤ oŠVRÊfp¬†|½ÚcÚ6ií/(¢º `@g»GÊMiµÒ"ÌèÃBSWIºE.)ЛùXˆ=›i}¦¼èú‹R“ãF•ÊQÍÒ*ƒõHz n‡¿ÆªŠÂUœ>cFQ|Õúè.Z¬gS±ð¹Fïj ìp’^¹!]r{aRþ]’³ #¥;§#µùóL/¯·’(\Õ.I€¤"z×Ó±—RÖ4„«R5Bœ¼­CÎÿ¥°X±ØdŸË³  „{•/ìðŠž]åSp>9Eçj:OcpW¤,ñ¤y™2ŽÙGh‰÷^jô¸_™ð0 ¢]Gq:ÒÆŸÏ^t/]9»^¨Ú᛾. ‡ì·w‰hVŒ5/´(cÆF!’CøU4Úže‡Ié5y2Üìi{w*aôHKiÌA•Â„Ya Äûêê hé#a0ÿ‡Äi»ø¨Ä³;~#mZ:Ñx8û¼š†z¹ö©³Õ­k{àß™Ž2-KïÖ€÷uò†ÚÇzw:tvxiŽÂïG!~ È¡m^Ò¦´c 4š!aÎ[ú×ùWԾȟ2 âÜ Ž­õvç,ª…¥g 8.Ï_f£Û 4wÍ＃ -BòKKñBxc§¥I=t77öáŒÙÂ÷÷ =ÍxŽ¶:z‹ãb£´†•‚ø8ô¬|mÆã”SnŒÐñw¹è) Jï©ëµëŠx"Í{Ÿµ­¸¾ïßCæn ÎÃÔ ÝóE…SŒâ}K¬Ù0N(zÕ£ÓÆþ‡Çðj•zë6^ÁÍ( =±� bG²Hª<àà<% Š`,¡vûêõxåÄ£¨ÛÏè«}~ê¾D÷€.X²­Œž5½#–·È<aŽhz·^°`õ×!àúlžß¨Ü#Áq*pþ‘Ñ3°â˜¯‡­NqXlr'ÝIZ=ü”%?ù>jO×eUfܲüÔ2# be ü¹c™yÒ}"ùÌRÓVÎ'ÂGI_gZ îýôØŽ!¾‘ÿ¥Å¶F–çÇ/€ìÌ êÞNz¶§23pàÁ‘økÐþNVÿ¦ ‚ó Ša¼XÂKìMŽ’�ĦýÛó¿ñûÑ•Ñ°¾ŽÛ¢úêI X� Û•Æ'õþ %¨s#][A¦ ÂæË2Ö„g-­:*ówÀ_ Ô÷l{°Ê\~ÅL§^ø¾³]ún8êk{aéâ3=Ù§ÃE;Þµ°üy ëë_YÛ_ÌA¥ çifc Ÿíºp ÃÀÕô81V„I&å0yùëÓƒH2£ÏâßP—+ãÅfArM»ÕœÜPó€]ä‡Ò©æ’+r \ ‘ñ»¾³­–V]h€Æ™R0Z3FyÅd¾•ñÔ&qfäy†ûÛ½дÖßÏíì5,0B®¢*xËÈsã•g«)oˆ‚+¤©™(eÉSÍ·‡‰iHðÎ¥/hd??‡Â© ¢k—ÒBIirºúYÜô‹,Üùf† T™–ÿûÖµÇ3¶Èýj..=ëËl.´N¡áhE˜:Z ̵áJϦ©ñ©õbƒâ›Q ž�CéÑ¥y°>ì ‘µµ°túBÇð+Èí]ߤ™x‹n îüCÙ—¡§Ê{€bL|Rd<St uŸ<‘ät'sœfÄš»${wôKˆØ{™':ZûM“ ZcmÇÉ{Ü”ã ÔšÊQê8¡N]&AGêÃѬ£%ß3É�%´(ßëþu3>@f›Á,—ñ ½;ZT6AðÍ CÍ?¬§£_³?h±ä§‹¹!Q«fׇ‡Ÿ:Ö› Hã¿ôèoõX4BdL;6GÚ´i­ó¸Þ˜fÇ_¬ž³z±])ÛõMxîèÙų gtºÓìénÒá'œê*¼I×=½UoGò±þèLHþC¸~°ÃmMƒŒ!ãÜô~yh ¼cŸÛuˆ=WFë¦-m×{H²¿ Þ&¡+²EÔh‚J˜‚b�²<1“Rl3ŒßèOÓQ¤Ú\d¶U/³å¶þMì`}‡~æ¤Èèp1ÁɯC›dßûÉ⊠˜êf½Ã™`¶@7ú*ÞLëüý0+°÷Ž¬»:sH°/‚}‚­¾1”I7ËlúEÄ"ƒ¤Ë)6,ÜXÒܸ ´lEÖ]Êc|n –æd³çjôPÛÞ´ãÈ œO#¾v^U€<eõ!¡A»îrmñ'ÎþJºèl/m;ñªT³Ï¸¶ÐÌ'¬�ÃÛ‰g»ÃÏ–CŽ˜Ú97|†ÚÜúªà&ÊÉ ¾¬ŸêCœCšÔ´~z~ãY»4HTY´pw®Ágf2¦À[¸øý¿ËžÄy‘fN9ø+¬vTaU3[/Tdg¤ŠŽq{ 4ÈÔ´í¹µ¶+÷”€Ñt™+sŠ} +êódg#®<¹9P#îÉç]ÿþ§2ts&OàLN)*§/×q£µr‚¤™•@c»nºCw”NPÉ]w8!Žñ,¶!t�v(\Õ;)Ï@¤üz£3 ÁœnŒ/*#?K uØÍwï|^øjhääSïYìÏ»•hÏ0“Ê5[4ˆàI*U|ºW(…:<©¤¸Ó¯)•:Kš5½WÛªNÄ\v ³%ƒ­NŽu¿0Ê}Ћ¶F}§zø’Dç)P]ÃLÕFYSWPâ°³ êL¥óu}Ï™æ>0öÛsÈ<¹™JÈJU,“É@sv~-:Øÿ¿Ž°ôà.å±õ¤ÄP¢ €[6z²@*QŸ‰§ß; ¡Î+ÂSw!n6ç7Ãœ‹Usc7âÞåó˜Î›ÇŽ&$ÝîË0; _‹ýôÇØh@"ú¦Ø°ônQ,Ž)™¦çcñ¬³PÖ•Kœ½K=+Ÿÿ•aX¬zâ´i êkO$£³– ²ÊÆa‘ ×=MÛŸ"¬¤œŽ8£$�n{ï~l\XÌ€›J+Iò¼—'­6µj¶:²íÖ:=´LÔ¹˜Âª"}·¾7ݽåd1�¦]jÐ}I{½À‡O̪°éN”­š1Lxv›)yO¨q•²úÁ¢ØüKl?ꂉ÷™a§Æo@!ZÈ„¡²*@|:|Ii,¯·Ê¸Yì]­Ð^« ¼^uƒ)[憟(‘™tòã)•ñ¨3Æ!Âèf ,FþÖjöÄ™ý?ç%c1ˆ‰býÙ¶±¶tÄ}@_›ÛÑ7˜•‡Ø•2Î#-§Øª¯©œ*ÞO7Ëq¼)ô?H‰ÿcœïóÐd,*¼Ã\ä;TU;À2èNLƒc-Êx ¡aì)¼•V2ˤ‡=•Ymm"Ùù³wlƒW5Ûµ²•i ŒqÐHK-ú€…m'vkŠ%ô:h¯\ûíºÊèà¦"È÷ƒ3@’²›%èDAd³¥O}]‹k¯½¡bO1Þ“ÊÚg˜÷ΊܾD³‰œ¡Ñb*ƒìȬ󤶮Êmseú@eÀûõöÕŒ M¯ŒÇ~›-Ëzž=žåz˜ë­Y°JûŸž¡b¼¸¹äÛäF>­žq MM§Hä<’sÌVψî^©Â;ôÏÔ¹RÇý�/¶À<‚¢Ê²sRlsW󌸽¥Ù†I-/xhû[5¿DrsÊåw£•º3%W) xÖšã7pá4ux-Nk§=}ÂFÛÆwZÂ+mwŠkkž©kyHóæÚ•2,Ç4 ’ÝÉé7L(£0ùc%1Àô=Ý"Vr£¤¸>›ÐÁã«•Iï¾n/&â=í¾DâªÈ9Vì){ï¤gßu¥h3·Oezž5¥"ÏQWmVPGäÝÖSÒ3±÷ü\l {~å)nF¥é±Ã+¦ßÙ–ðð,ŇÈcº¿uŠ±$A¬JM7ºSˆ!Ø ÙóZøöv°ÍŠ^P²üQ/'ÎUS¬0R‡ãWdíÎÀÍЀ،ã dƒ@±B‡ƒÌÀoþÁ!Ö©›§Ç}¾ëµbÅ3£;þµ�F¼Ò›¯Œ7˜ÁJdôáò<ˆ?µ@Dã3N éWšÞ –É,9×È^*Ò’”¡˜á ™rçÑ¿¨h’UŠƒyf{ëût%oÃN!/8bqƒþé»öt§¿ÿÅ=sŽ(Õq*WV¨p'ª¬j«úQ5Ú=zÔ\Á@qåGÙG!Ò¹a3c`»?»(Ó@œjvJí¿gX@³ÍŽ„ óŸÓ¯<yp~}7Ü‹1»Xüv…Ó­WO<È“ÏKô'Höê7@êÔßQðí:çûæO/ùÓȉ+ ð‚~g½5ù†Ù!•› 4ÑîZ1=’ú*Ạ̃؆má诿œJsîÁtRI¦|¿½×¿YèoyÒø}ÿä•t¡EZ¥µ†ŽŒÖ¬ô>pl$a—×JË‘•a> )LÚËÆvŸäƒÈyõ_< ÿ5c˹…šCþŒhZ£›Jϱ%æIl^ÿpÕ>"Kk˜^?ŸiëÇñx PxÍ7tñ`=ž¶Š9ç‚ …ÝË>)(¢®Ã¯‡ë‘ÈŽ¨<HÈ>?4£iïæ½ÚDP¨±X¦{Î8²?æØsL@£ØUµ[OC¹§cÆëilÆÉ<¸×¢Ö¥#äÒ ~÷å‚Ñ#FÝJ¥9hüÓÐÉ÷„¬ÌiAN±~à<S�æ_Fà`öKÃܼ~sŒñ]J™Ü¼ÙRªï4ÞŠ¡=R„BåÅÕ¥çËå�Û—÷qâ-¢8.5¾ÿ·*…¯GUflá”Z*$¤lP0k˦ÇÆMeè,jx]Ò)ñ¾ós i=©ã†¸¨HƒO4½ nzý²ÖRIV^HÞ ǵ ¥2?ûñüB÷ÂÝ¥‘ßÿFý„G¤•'§Õx0qV› ÆMã—È™¬ý�þùG70ÒO³ØRsöÔŒK˜].Z®@@уã±�Ø/K-2Ft+é /8HË“µ×ÍUœœexvg듳ºþ ÚÜ´¹q;ìÐ`pªc&;à»4«'™8>Þ¼Š‚A½œÝwTGRd¾Ö@ŒkÖ9$%›ë]ßÁGÂ(ñ”8™¨�!Îü:X9–ÀGæÀùë£ÎØšZTfßÀ¡ê&‡õ¤ÿé…Ó©͈õÞ°*Ío<+ûš–άH<ž6,Šå¼âß»²AÉu Øg“ (ë)q‹©†¼ƒ¦gñ<0›�OrUH¤w½à4Àqÿ¶hÀø?HŸa¾+ã‚u’»«þà–ó}ÀS”d’Ö ×o·=<‹Prß®Ï)—T¶2ðÖo>`,!áGõ‚0÷Õ €]¦“±ÜùâH›©¾l=] ßC~RÏ‘‰5ÂÑ9­: ¨i®ÝR–Ԧ΃^©I"bW6[îgþ]Êd ²ÞÌq»¾Ïs¢¸È|NtJ_6óæ^iÂÝ ³i xQ;÷÷®þáEõ jßô¬¯¬ôÙáˆ2¥Aú¯LEbôf¦ŽÂí|-Ñu�c§¦N‚%zN‡†rÈõêO²•v"íÑÉÎåòÔºñ¦´|ÄñDڈЀœUH›žxçãz¢ÜáÑ#ÜJ¢ó kT¨,´ti•yïU´^Ä%UÎ< á3k¦,ªþTîs0FÜ àZjƒíU0J9ßnzîÝ©ØXÛBÔ¹U©Óvòt†zÐ5Í…s£Ýw~Û]±¯ò›š3˜¶Î(Kƒíû}'Ù‡ä6˺’€›Ðn¦ÙÚr’Õ¤Àl™ÝãvûýKgòª©«Q§2ŽÞóôÉ2U!Å1\¬2ÂsÁâÈ׆¥¥¦?JgöÅt‘éx�tÙنžt\wõ¸Ó'U‘e· €?ü›Ô%ÍÌ;§ÄƒZÄ 32 ŽšmVEæ³>¯‰˜(™³‘å® b²ñÄ6”Æ;ÿ¥{£Å»—ýP:D0[6ô)=©1‚Hˆ-Ú›ò˜· …P‘Ú9Oó†sžq:ÎÜÅÆyâ‡õ)™�EmD¾q¡}\¬}heð°¢quWfãµv]š­4%¡¡L9C­¤*�±DóÁˆV²¨˜Ãà52N’:ä!gÕ›?´³ýâ:ü]=õJtúEZºðÇO†îÑ»bjœU4³C¬BßS#÷ x¤ç9ÊûÉ OðdÔÊ ŸˆòN'I)Y GoÇÒ•ãpQ3eÉ•%5‚X;‹‰”ŠlNtZñν‰Ïéû£ÅìêåUYjE`Ü€fËZ·³~çª.oeæ ¬êß4´Bg3c{{ΰ=å}>¸•b^×ë<W-ÕJA •ÏCcÑŒ÷Á{60Zƒ7z>Ïó¿¼È<ð.ÝŸ–“½vK8I…mÒ¦ÿÕ¼wm—ä[ÜÃ!œé~Ù³}¬?pOæÿ¾™®“<”¥æ8#NM £n &²Û¯Îùʯë`²3ÓÚ) È,çO=AÜV@îb¤SØ÷;*œâ€IxúÔgDZª÷ã¨OÔJ€üJ‰.±yœ@„3 @ÕîVÇ|P4†Œyj ¼~ÒZÌ<ÿGF–°üqÿé r×»¶žfO÷ød'ÙÆô ;gì$,Òw‡ðú�Üx&éësq»¤Jó²*”[d΄œ¥7~ã­Y#ÈÀÑü€(,Ò ž ùy8,³¡¾¨úøü¸7yf>¯ßµYÎÂÆ‘/¹Ò1Ýȹ"Rd=£ïòù®´œAá{PµtÕ+:ûemÊøx~¸ïÚÁXuQ28 -d^wÀ7©Ï0v ŸFpÉÞ=ÓÑIŒØ=XÙO…Û×U%Ï|˜~XHëòÜ[í¡n£Mx ’RC‘˜¡ô¿ocš±…gõsiøÞylVŠV6S‚ô:\~yìšhM‰¢Èè—œú¸rGpâI#!Úa_ššû¡9ÊŠ•¬a†IkïU…�^AÍu²B û®?šGz÷Ò]U 4ÊMc袼;yŒ2Zé”v­f—c+ŠÔÌ[Aãô ‡‰V¨;D\‚7&·›jéÈpêZOón~t%m‘úWºMMK{½hO®·bL]y¶”±vý‘ï›d7k…>yD­?±äo3{ê•ÍyØ¡÷+/ß L×í òã:B­ò½vwcê6ËhõÚŠÆNy:FÑÚA7‡î¸ûÌÿAÂÉ«¾è_n±!lã¼ëõÕ�àUð&Єøÿï(‹þžÙ_”$¡ð"¦‰çuïQs…*íj«Ï+§Ò/HãQQø$P€N´ÚýY̲œ¸ÎKØ@WT ðZÊj«Nm$E q§zflðÑ)¿õfÅ‘g4Íb‹Cä!ªèíŸ7J3€f¼RäB•­ :ÖIkçÚèëôg7æýÕiM%‡‡ElKÇŒ­ŒóšÈ4¨MržÌ—djþÏaøÇöBž4E;TûRË@Q ¦¶Û:ÑN¢coóöq˜)S…A¼+€¾šô1ó¹¿&§:/kk¯«Îâ!vÀT›äôzY6¯C?’{v©‚jZ\µ„ü¼µD ­)Qzßg¤kºrLGa¤§éS�üâ,Âó9íVÀQä8aµ¥cͳIœ/LïµÓ•xócD‰’6èD €?W”;µšŒ*!*ÁTÈÜnžMó 8ÞXâÝýþÍ­3]ê÷‹b†=äA:÷^W ø†,ŽÜ‹œÈí…†š2\‘X"�ŠËVN:÷Äì ­ût "rzŒ V«2 ^p8ÓçZZ«±›”|Ó8‹ØòíŸ^4kðb̽&ë βÍhÅýg<™':GUžyzrtû.uT[m”D¡©o½íw9 ÃCkË´<õ³Å™§ J‘“i£ñ¶õT†à<,­Ö|5OCµ¬Ñ‡ÔÈ,¬ÔŸAæ=ý9cI“_$Ay4M²³èšÁS`†—,ýBtzÖOOÓÐg¨Âðm ~j<§ðD‰ ©Oiô7ÍH©ý©»Ì¬Ðú­¿ÄáÊ08 š¾ ˜}2·ÊC{Êf‹ ™A•z¡þ \ÃÄív>.a³¬dk¢ß´j}ƒ…ïWw£ifUéÈÙë)äÁ¶–$Ã0(¶mûŽÕ{—äID•›-š!ÆK_ÞÌòM3Q‡ð©zqß=õÎ.æ¦ôN®'/oF[AFE÷t×+°ùîJ"tŽœ$´€ƒëž‚?ò™âý"‰c_ì*œ‹Ñ~ñ*¼íÔaêæºÉwÆß•…'Ba¢�f>ù¢g‚ü–“í/-V3„çFr¨Jj¶žý‡;¬ ‹müÍ­[=t¨q-TÝ•6³N¥ÿò§sÀÌîCþXÕ¦o0À••ñmüä�p)+Å¡Ó7æ4eáŒîÒYS-:úöwrÛÈ™q‰hò hfS½\' s»–×-CsÀS™ò…ŽÆSïí©o �Ú q¡a/¤gŠ~N!J»‚ã=¾ÐÒé"Œkp�YØ#oßzàÖ»bRXXð‰·%u˜ø]c(|³)æN1øóEN¯%˜cõx|Þ§¶˜…aéíeHª Ù+IÓá HêÂú6¿§é¾!'4üÍ ¼¡)×yELû<­Ç ‡Æv[Æ1£$™Øeû7`»õfÞÈ󕻊ýN~Ç€�×OU­W…_ÄàÚRöÄÄ€Ùƒ<«y¢|ZºvrÊ hw¥Í—ãS{ÚÍ­ðxϘ èî8ôFã4 mÁÌÔ %#¢•²ÏNçŅ˾^n0ºÓyÞ›ü=À%…OÙƒŸCXªx˜M·:JOƒè¤Þ‚¶ ËàÂìÔè›Ë{®òœ°Å¶DC!¨°l¹ðK 2최dnö#Þ¿iU;9Õ_çÝMÿ¹.èÄT†¾%ží1Çø~È’›Õð= ÚÑT>Ónª¼ïÌC°¹Œx[o2Ùãê@gÜ.xñ„,œêž¾¾|{d‘§¾Çâ½LY‹¡X~v_ž6Æ©ë•ê=Á!òWºhUè éyÆ8(O‹íÓS{ï¦?‡Ù§ìTŒžãlšìw/=dÆO2¿‡nòûä<.xËå¨0H2¦€0*A¡ –¼îOeò"»A*Á˜2Þ÷>‡¶¡3£ê0ÿlMI_Õ¡òŒÊÙñ$æ) N¶÷zvc•*à ›»+MpÌëž?>Ñ)ŠÊ•E¸ï"$´¯=ò÷Žk–ÝÞ.¿ÓrçFÅÞK}³$”Iàëáº;„ªgëù"éٙęÆà…r¾¶µ¯¾$§XhÀΕGÚ6®%o!‹$˜YñY¨}Ì7¼÷7?Õ¸*G Å;Ý©À ² ã·“AËÍ'ª£ßRWeͬ¤Ï\N0ÚZ}·Ìߧ •'ìÄ¢6û3eà¶=•�KG·ùL™ IŠŽŸFçÞ!ì?̈Lȸ?ý <–™SÝù˜ißX™Õ}â4ÊÑÖ68T¤ú|¤q%•E¤°ÑwT-“kKšYŸeù óôGŠN\®äðÎidF¤?f¶ëO{ˆÿ®@IÒ¢O`¸cÚ¸¸!¹›SfŸOò½_R-IJŸÍÇ|ºë{•ñŠ˜ Œà¯ú tò5­¨Ï3m¢¶“‘Ñ–²s€{—¨@CŸŠ‡a.+]|]=“).Õ­‚ƒZÿ]\»’‚…`Ù¬8«öc»“²9Ðj>ÌßœïØ«N`á#Ôe.ƒ|ÿ¯#Jh]f:Œv‡š1í`Ï1ûz+©®üUc6\¦ou\6›á1sq ß8~˜bè)¯ÆÊcÅ&x]¶ÉSE™"¬ŠLó4ÅZLàºÐ\‹,U:R±?Ðe³ÞºØ”È¥%¿7Áñ÷lÙÐ3äb辦ÛR>º f¢—z_ÌëÚÝ,2}}د ç!R1¶fýâ½êÍP~ ÓvSãaT³£ßë–ÒâæÏï†Ö<ƘɅÁ´+ƒb¯e/l®Q–©ûƒŠÌƒe'CImÈþ8œôŒvYmcìéîU“Ž ÒŒ'ž­€ý-Ùi³g™ýï÷EœâÐPD²‹PNÙ6x<�tT© §ûGôŸ,Í ­æái Ž½Osõˆ–ìüz´–¦(e ׿|¨ìäè*Ól‡/Vì°²§™eÿ{?¬8É}õQqö££ç´õ�Eõ‡-Vååç1Œd0L%~dïûU?XA·jNÚw›½@·ükœJ=ä¾{ïk}Ž’âkäçÎgNj€5_ä•x9¶zTšDŸoÜYxA$@o(6pÚÚa¿òhU¨O´¹`ļ-©ZíTh­÷å:¼]‘CmØh¡Òà2±hÎ KôúàÒëF²y×ÓfN–Åûè=É'41ƒáJÏNѵTÊJ¨z 1oÃ]Ó�l¢ˆ^ö™êúFÛ+õfc4RüËýu�¶å¦vˆ3o$Ä„¨KKÕ`Þ(Þª¨aEåÂY½áä1ù$’ÛÍ~iöa¢ßz¬7pÜú[NM¼L}]Ç„Åöb´´­!üÁ1’"ˆt´"®3ž6…9ûýq#Í|¡Ù^ˆ-²Åþ°6ûqì=åžÍ.a¼KFÐÍÃf0Cæ¹ Q¨3ÊQöi¶7ÕÝ2Nºfúôª|T”¦4Ä;mì©‚X•Q„0w74W„wÏPHÆò¡°†¦„y¹ßÒ­ÏÍ­˜Þ)¤«öZ7Ëtf¾.OgpÊY–ý,¦()²õĤº1ÛÎåEHƒ9<pi")½±½›³2½óW¾Ö¿ªíl.e 6+à†j,†ÍAoÆÉ×_²·‹•hoÔiäuë5Å=ü˜9Ÿ)V¼c@*¢A òr@öDÉN§ˆ/u€ó5%˜_hm9yÇŒœÃ´òÚ_ÛND� ÿoèÉ«‰í”ͬ*ÖV6²ç°â;úOTⵇíöá«/ýSjò´£:ƪîŠk3w7Ý–äÅB[Ò³ïZ9p‘Ú2B™%}?ûQ`èjðmCñTŸ¥J}Ö}ëSG;ú´ú®<.ÀÓ³)øT1LüMKËÊó‰>}øñ+ ÒÅöÍ­œãË$‚Ðx„"l-[”Y,é™M|™†Þ<„–êÇB$,U©v¾Ôƒhè™Kw^w¯Y©Y«t›Ã$ØŸ¸ ¶ª ;¿t0,dta��­Œí•á|S8K ŸþJY!Ë¿¶^an€W`ÿÄ ¹—ýe©[Ÿ¬"³9R wZL  ´gHZ<ù=A“Èw•\v”½ä­ ¤žÆy±N¼£ª=Ÿ¦s»å4à¼ý›Z”y²\·õ5P‹íà(72Ø_jôpÍ ¥£½Ë‡"Pqª~~²á燱ñ§Œ^„ K sz¸óO¯ŒbKO;VŠòáBYÞ¢c^uO'zˆßäRhë�£ô=^•pÍì¾=Ì>¬’[.'½/@±“»ï®žù”y<¼Aâ\‹/öHK®k³_/ų4Î|7vU™Tr kŽBíÞÜâßÀãÄ&L6$ ¹áxLÿ팹oÄ{ŠÔºÍÿ§cé%Ù<Í ÌÖ?ÖWHñÿ÷­(QæðÊsŸ¿Í,«äÆN¥¹E¥£ê§pÀÍšÿ¾¥j< |ƒ^ŒÒ˜cUj‹*C·‰Äë!n¾¼Ž+Xi‡y[û ¿syÈ<[ ØÍ”öÍïšöLÒãQ¬µ§LH7öê>ƒ=q¼VƒªQ…'^<~0$I«Xn¨ßîâÒõ—+Ü<ônêŠ4‹W<ŸHÀdE£Ñ’f‹È*ÚÜá9šì3£ÀiÁ­TçqK¬RQSÓÁ59¾,níÇ@úÓÜÂtuûJõ*tZø|Åb~k1*•a:ƒ•ëìæ~v™÷õbF)îéÎEÓVù4ç «ÔG6õеv9™ëä.DUräf–yñ¬X±^4² ÚkRXß+S”»¦“ Ãv,½Wà¨Üœh`%œ'щaSp| KÆ«¶šQœF#õ¼Êî-AVˆ'E¯8(­)$¥%íäå^”ß-}•R•²¿VÞð›êþØ_@K…‰^¹c¹å5ãýkc0Eõ²y£gQmþУ.†«ÞyÌ8ú–qÚɯ/‚å<ï¨2’?oÖ|ûrrt:zte†Îs¬=‚Ênc¥§ñ@O`,<n—ã$!l "!å³”»¶ÎZ´Ã4nìØfeæÉE¡)Ü–l+yUùˆÔZ#�)Õ¤‡GI͉ÞôÜ¢é)‘çq ̆ÑÒXopÊ'[6Q¨ûsØpmî&ÿ;(Ën nöST­¢w!u¶ãz%.=å3EÎø¸2¬²yGw?{$©MnúŠÝ±µIçåÀÃÄf﹞¢Âì¹#Žÿ…IbDˬp]JÖ:~ÀkxXÔV„[­ fÕ”ÊbD7ãðy†$ácïe‡ø+8g+‚~ ”ðsëXœGªŸ|Un_¿w2Î92‰…µ…11¸× <¼Ç3Äý»˜•žýwÊ]щ~t& ^2^ƒ!Y¯š"§ s©øe[ñ»ÆëÈiÿ+\‘?XD¬ç¼¥CgyJx(œ†}Æô±wª|…FÉ©kÕáÑÓ¼ÅûúŠ‹Ù?,KþŠÅ4r@fÎ,Ùlq|ûÑ0z0¡S~ü¢ÝmÿÕ_€|ŸùhÒj¥(j4_ŸŠF²YU ª/AXé¼.…%UµW°”Üœ[ðûJ!QÔF&z·üÜzI0N÷7P0B§Ù}Pèg1ž¦DlüÏr'¿3f¬‚ј=)t"«¤•aà’cà=m/nG¥ÚDÜ ¤Úzté.ªù[±{iqø ç«üq7›õ­Ê,­¦ad?yúyJä7oi]_°?Ή©ŽÌ .¬sK´6]U�Ý/IÔ "ö€wQé—Ÿž»è†"ÉA Œ)–BXÙÄ(NðPw çt°òЩQpë’2J…ç½öèo;kd–'¤ˆãwGµÊüôEêë*þHÕ„-uö„ÞÏ-&4þÜ+ŒâUO ñ±p¥´bÒ0ðéºÜù4 ©Wã›\m}ñÜLÝùn²Æ3­÷Óz\¿·µìD[¿î¨ŠTÆ¡ÃivLg"Ã(+ˆ†©+›¾QX¤Ôv²}ë’]ˆ1ß2ÙÉ;çà;<<ð”Ãæ‘b7F‡^Ø)Ö³([.vÏ QÖ’W3òPù[3g¡² i3£Âäê}V”öÎá'ê£].Æ%´‚ "ý.#ýsZ'.B:e¥i…@VrßÙfêú絧òá0øXr^Œ®;¿¯¯"e'åW&™‹uÊbzžwüŒ=Ï縟͖îÍÞæ²°ÙÀü…Ó=ü.Í{²îc‹ÌÈ0èi„ÐÜ»¾Õ³—óì·ÃÌ]¼o?þœäj íg|©!ÅÓê£ EåøjÔ ½ÓixE‚ÏÕ6‚& (Ò8iUÞ#a»œcç-Hróêí©L›o0رŸG‹ÉîˆQügíÀ˧ýÆÿ°í’4[³„ú¹òøÎ  ©ýa+†=P”ôQ´zw7©$¶)0¥_½ÓZ|–‡Êò)Môw~fö‡Õ-IVúM0a0¯ÞŸ<óyÖ]N:}jÕmÓ+jôYÃÕ0w¬mk¡„ .ÒR…i„$ÍAT+^ú½S‹Ö>±tG";ßI„á=ˆ ‹Qø±5qQ:o&Ô'¾}ôvs^aCÎgÌݸs%у¾¨¿ßwŽ}®ÌUSàm¨XXvš¢ÐRDSû ]…‘Ô‹@=QâØXsïÎôöy§¹ 6ôaY {cÌg® ýçËò£:SVúŒb |¯hµ)¤˜5 vH®d¿1³‹k·ËõĨ]iúS<î# Ju,$Š>f®¸œÛÃÈUOWªD2ñµtËÞZè>×ËòBu¬~ÑGZéÕ°Ó~gŠ:}Ú[§ÿV¾,«aŠiݨ™ð2€e¨*I§£9‘”ÌЖöþþîù^ŸºaI‚.C·ùW°÷Ò«>¹iף˓¶_qsØ–@¹þ4_û~yhî­fèìüK»‹Â¶C GoóK‘š5 $‹]ëT‰niH8 c#äS ¯×\‰H<½ótreÛ¼PJº©·’ŽOY(q™™ûj6Úb¶zÉ™ç´óÆYÉãñ•Ï²±Ç¨ŒMXÞYåÚLÎz94¥ ûÐ ,Nbw1(|OÒ§ŸVÑz1ÑF*ÿ+äÑMunÿ…e™{¢‘a?•AfņúC_oœVV"`bÞóvšÆ?#e?;q¤58„äo ê°H‹Ò®u:Cú™v“­Î�×ßÂÌÙNæX^¤Ù b…áû§›Ž_žÏÊ_�›«È÷â¥<­½i=F¦¨jº/.AW/wøè.ÿ̘›»YPì•Mq <UY¤ç¶Qú‰½||öUÞX(çÓ<ˆ¬®1Œ âØRi܉_”=òUÂXùÂ�³=ÒÈp–cÏ4»÷Zæã‡tCWî5oÙ,ôþb±zäÆj¯~µº”9Á¢]c±|z]ìçŒTç¼ mjs>$`E7Ùœ ÂuÓŒuXKç«fÂá83Ì‹åÔ¸~øk)Öd¥·AY´¢¹õ`”àÏ-Ú–ªOIGÑH)uÓ_Y(p˜1‰úŽMH¬fjbT¸4¾-Ù05ŒÀ«G’ämŠî¹eÒé'±©G{æx̨å¸Ó®—106Ú—©å£Ô*L²*i7Ho•OÀ@$í—7ª¡STÇm×ÄÏøm8�jPÏëÞƒ{Ã¥wê¶y’­ƒjœú&Í»£½Üi5QDzü§ÄÓ»_ k™s Mxi#�ØuR-xnRû:}9Ç) øÈù Jj· ðFòj¤SmØ;v=V2CîÈ·hx‰gÓ+¶Úó¥ðÈqñöNÃgñlðÉ&(y‹â5|)¥\š—½a-T¿Öóÿû?VXÕºvÚÔÕue57>J¡¿±½öíM¾mû¬2«‚î+IyërZÍhÏ ,öÂï|èÑuáñí]šÈ¸rL3LÌ^Çv ;™ºOG4`‘’Z¼¶«Ê·p=;úȶƒ<-{¤Ñ6¸P\oÆz¢Í‚Ôú%‡ï̹> òq^háçèÅæs"M4‡¶=ƒÃ%€€qøîô~U+ÀÂz½§Ba~{ò7õ`Ú׎7Æn §¦¹»;ÇAõi-“Ð`ÈžÚ`Ðâ.zçÊáìb®•ighðéà*�¦ÁT_zÑ µp”:´M~vNø€#)iMþLùà‰eTÃÏo—ìب––¹×ÕeóGº)T ïß­Qöèw–BïÉ+]^VVÁ÷ó\.ö´Î(-CΞ!8’,\Sõè‹Á'prþ÷’Ð}ý–Õ÷ö\¯¨ßQб kAËœ­ÚÁ öÝQÌÌv5=,-?¥Å÷ án×–ÈïGœˆ§ÓäAydâÏûúÇ„ÛÖáQb8Õ}G‰Nõ9y†îÃèî ºàî²Uøó.¿Ù>&yxcúyù“er}2T lJ¤7ý6lâÔþæ§[Ê}µj¨‡1d/SÎíŬ:œBéHL´…fJ¦G�i 6L»ª©þX]=ªbþJh�D²<OD^ú,f páÐ=Rˆ³è†b6ÏQÂ'­LÀ—š‘DRÎ"%±’Ü!!Ù3vŽd 馕´Pjuå»?Òb²§*úáŽÂõáDÏ nNN¹­ÇoT÷$øË"ò/¡F«“71HýžuÅgÁ1 ²¡õtÃP-l<ÌÝ3äm²’UnO ÞþfÔŸœH¯YÝ0ÖК§Üžæ¥fAðܬ=kl#æÈ ÷ ~î—«œá«ôõ;:V> ÞÚŒTäŸg³ÔÑc­›†²l)w˜bAOÜÂ7ï^Ú†JîYèòáÞ }t7V õí Çn¢ ¥¹ÚW‰1:0¼åp|ÿû£wÖxFøIÚ«g®#ô1[9¼f&PŽ7Å$¤ñô}¦³jéÕô¿ÆÅúš¡^„¸]J9Ìõ¥T>ò8Á¢ø„[¯Y¢6›ÅPèÚì뮟ö´€ÀŒ7ÉÄÏíG}ÍÈ<³ÎskÄU¡1©8X“Š×»ùq¹rÀ�[ééÕ“[®áë^L%Ý0ýÎ9r¥nÂu:ºà©•sÁÒ‚wAÍA`¿6ž¹»ü«èä“8Ÿ°Gu²À‹8§î XíY¤{ž z¬Ä6ñ´eP¬Ťâ›rôœ$/[ûß¿\å*¹³E•X~¤ƒ&ª;ÓzÄûƒf4Š©±Ôt¤³ØPí½ûCS+ç™òWàac9]ÛQú-º% {ý-•¨¨Ü‰òúĘ·2b´RSžH£ç¦Ž;˜äœôåaO,RÒÌÔ´<ÅJ{ÜL˜Ø¿ ÿèj Tœ½´ìS'Ä1F§Õäòiê~”ôHkJà¬Þß,mÈû—ßTù2çýi4Ïwðm˜<qxÚ‹ ZÜ&7¨ØõëÞ•Ö•ÖWè!MÅWTëá^¤ \PI$Ãá’è/œ9Ëd¥ÎOu2%Ÿùþìmj§Ÿopç„ãÛÅw ‡ìÆn0‚Räÿ®Üño]DTô´Ï»Áh‹¤«Ø ÷é,H¬—�|tZÕ±jgs@w‰ø®e±Óq+9 H³»˜1šø·y½–$C¢âÒªêCÍ ¥f¬ûxàªv•RIPtžÃ¨¦FïZa® Ÿ qî^mYeè}ú*X¶´äϪ¾›âx< º¿;|û+EOùÈ—©£w×zËòÆ’rØÑq¯Ì¼,#_•ß£�ezuÇj+LW`Ì” Z½º¯˜6óëj"²P|C*Í0h£½³×F` ÿû–qx_ §ýµg^.ý­rc½<éàË>PHüÜb¦gÕ×ΤþR+SÂb¾d»Cð¨Þoµ¡ç©À2VÁöJGÝJà ;¥=Ì{Â@]âáìó+“NYÍrÚ‹§>fÝÏØé\P[Ÿ¿ÌùÕ Ð 6%F§§™‘“ª¶Wž¨+²Ýíÿ3óßÜBà—è„Ÿ–²¿ýóåZ ¸tœvó] ñÌÍÎ;©C_"ºBçV†U'žò×Ýü7ÙB{B—‰Ê>­]ZeÀÞÕ“‚ _Ññ’Z>J–™’?‚ðšmºõ‘íNóšAFëÈΞÅÎèšë›á8¯ÜÃM‹e =w@ßN–ÎP¢E3,ÎÝÜ_Îܘãñ„½%:©ª‰Ï­Òxþù<XT‘ÃùáEÍ?§]˜)´΋ û±h£\´¼täOÙЄ˵h|ÂðZÁZ@„΋=R(&}thu8)À_´À“ÐCçÌà­éÓ~yî‹ZO¨~ü Zú‘¶º£Ìà›=½Ùçât€fCÓ©ñ—¢Ýñ1\ÿt.¾Æ,2¯EšóPóXx:%’9÷HAZ9ÜLðºW€l¥éÙ¡yúàð¨¤� )®Æää�z�Nà12HÐMm;£÷/=]¦Ðô•†ÜŠ+YÅÄ{ŒeüY w˜~ðçž)ÍàßxÎd«r†‡AÏáÓ”é€ØzVðزÝ?ýª=5¹_Ï&P­6¢ó*`’ÎÞ›Dø"ÿ3‹Žó·¿yÈKÎÒ4s³Rñ+¦ÃóÝúhWk ¦ FzBfgœÄÓ…+&µž?ŠpmôuKJü`]k•{(ö:!�þ¢Ìg?{õ™—9Š¥Tæžôd¥‹_ükÓÅÐ5™[@ý8>+2'ÁÄ™îßK(Q ×öÝ ¢ýù8ÛщDζà?‚ƒ¯6tRŸV…Öª13ñ®¾ŸBê i1à }ý‡áÏa­Ô%Ú…„ªà\$Ù•wø‹ìÚ؆óü7\eM/«¼s“«yBæó?ÊÐòÀaÛŒ <�H”h×›Ãëö0Ùï‚©Sxö$®Ž\ÊþÐ÷Zg¥?½`€ºx S#Ôäë4}ZSµÞÌÏ^Dqä LÓžXæ<(y¯:šÎ\µšõ57¿‡Û9)Ui½PŽÐ‡AÕh¿º/§YhEý=ï?6µA 7ßé«®Üb>Â?2*d-&å-gmM^e]GQâ³_XíRzòÆ¥˜Jœ(Ïù£uúѼ´ì±æ®×Û’0L{®û¢.ûš=¨ð<öãÑaÿ©¾ˆ^|ŸÔYMËÌp(¹•+¢æ¾Þ.F·Ã$ÓÓN\»BæY!æOA4ïM—Ö@1¢ÞßÈ~x*A*w5xÌÁ *è¸6Ü@4öPôßuÂú™+”ܘ}Î…&ÅðØ ²/Ï{çß®³»íµÕ”Xs\¡¾å”@ÕjK'�Å£óÕÖ½m Ž­¡Ïz˜Ç]Ç 8wÖSååNlÄv¤%U¬gDÆÆ`ã䚎Àjßs-!ö>.7õxœÎ8ì2K¯BÂÍe;·¾=rΩ<¡W–Gizº)ï[“¡@½ bIoÍRÍ^péˆÄE(NÍá)Ͼ~œ Ju²¯-†{l„|¥•= °0šGÞSÓzÌ7R¢. †ÊÕ–µ%œYs>Ù•2¦Ìé¤TÚÆìg©{ rxx¬ýxûé\ƒ&tXÒ=£º4Z±ÀÀÜéÆ\-—¸ù ¥ÉÂgÍLï½+¤ÏŒáXõÂËð¦q²ùCO³²µI™pØíÝ1Ï;¨pšìÚ¨“þLáŽãÄgÿÙžfxnÝDVfç|ž²4cßJôÖ/è'5;O3âÔœ&zŸåuÆMšjÁŸxû<f ƒÎËä‘RO¦e¡Ë’/|ÜŒÌë>¦ V¨q(XÝü,tSA4Lá”ï{˨ qCþ(N¿o_= XYÙVq¶?œ0,V.;p6¢ÿ·«'FÉXæ…7¶Rɲ)´LI-Zé—žê”9 gÎi8µ¸y»“|l ‹¡;ÊܬHfè…󼸒â-d~x- ÇÖÚXô…±“ ûW§e@S¶ÓÁ]K¦ ƒ¹Žo[Š™´—~Àž'‰£„æXÓ²Aqía^®°žÐ_xQhÐæ2zª ÿ<{ß`èºÖ �CϦ (g›–ÌåoúF÷ïžÅ,=ÓTAø®ã,œ\-Ë÷`-RqBµWý¬'2ìm:0ï«=cCº;¨”€1bï½5”uuÀûX$ìôbu$¸ögfÄg‡ŠZõ�{¿Öšo¹jÆ[OÚæyþWžŽX$eaÐîó îóôQµÛM„l…DíGÑûÐÖÞÝFÞm[/)<Œ(ß½vI‚ܦÁ2¯‡ƒ¹Òq#m½àˆ‰÷¦# ı« ¸äi0±ŠÖ™é]鳧Éœ ¯õøŠüfÚû±TAdÑͬîŠVÆäØԴլȠ»~[åÙ*GÊ‚®E:„°*Ú2‹ŠÌôÌŠ€O<Î3‘ñ^“‚~+˜õ{§Xøc=:IŽ)ýÜ^¬ Œ9ÇÍ"É+<A¨l4¶^Rt0FQ1XË š¿¼)â"E»zÑŠ{¶ÐKÖ?=AÿÅ‘óvg¡Hª¼qWÿ5•7û3ðªHK÷Õ Œéã1‡Õ€îÜЧ~ k5÷L„$éŒKf_9Y•u$và ãŒî¯Ãðøs,I€¼QÃ2ô´Ñ)V ;î.ª’é©­~OÐÙáhn.ž÷1 ùUmqéNîDÍÞ;oO‹Ó1æªå/íê^J†_(@ºž†´‘M~™€ýnÈ ìS€ç€ Âyš[FÿÉ=HhÉ©8ìÛbÛ,ÉD±‡–ØUÍóÿܾ-u}ýˆ›%}ŸbRÜ8‰ „Ý·ýu;]©Â™Ø_[JÁ«»ÝÒƒ9 ‡qwÇüd­\ 'ð! ÂZw|§~ÜØÝ%Hw0Väb$t²:g³ÌX˶ŸN ½éú?0»óEð’ÖªÜOà†¼>ì[Ï×5¼ë#‚×ÓùÄ3d*±nš" Šyr,P:Dì¤XX‚ãQKÚ^Ü\ÿfÿ­ô�!6à8k,C¡R„E{UtEð@tâ® Eú4}¿€óNŽ3ÌûߌY‚ãDžOfúpê4‡Ï­Z:Ͻ×Õý}ÙöÄ!NÙœdùDÏ—›ãfª9t=@è‚e¡gÏßÂÌëªB”Æ®}(«±`¬Øâ`{Ø&Ûlz8ì@ñ´±Ì½§Cìè?E²²¤zl¢evú×d%fÙÅûZQPD7¼¤¦Èƒè«öÔˆµ³¥R¢!•Ä äS­‹g6h}:9è*87TXÝËŒ='HŽ«IΤJÇ?³…¬v™¬v¨Îƒ¼]¼?RŠvíjâ¿é>÷@[qî0Ú8ŒŠ`ßÒ“)Ì NÒÁ™C·ÊkJo±và†Øf¬¨¸þ×kt r~;³qê~Ûƒ¡Â7x_÷2âk&ƒlñT|gIJ¯§)†‚¼H³²úv0ã¥Æ“6†éñÊØêžœt¬9ªÑ È L—RMtu¤Ñ%QðÇ$Ñý×µ±„6 #*ÖÌZ÷ä ;vôV–è~·á'¾ã�HÛT!dí§Sßhê v拳¥ÐC!':/sÓ˜J38ÑΞ÷ƒ®:ë]l)ðϯìyªöQ"(ì*®ɶ–ÂË~huƒ~Æ Ëœ‰â&­°& ’nöö„ØitNHéwÝ¢ÆKs@Í%‡8kSvê6tĹ©ò®^D´œ–nßýlãf+…qè~ï½ô“¥&ð¤5÷‚úI\f>«#LPgA5,î“#–Ú¦ t„ÔTÞÔ¾¶º£Ã2˜ö,9­wðݹ›†ÙJ©lÀnÂ=¸y½yã4ôZW±ñ¬/N½—_x‚Fâpú ãä@Ïó{þöÔ¾>t8“ˆU[æ¹  ·Ø9±4‰YfnÔM7ˆÛ²‰K¢Ê©n³¶"µ"˜óŒàmþŽw»Ô'pOé¥Sƒç8gSÖ7°Wß«©ïèÆD׶§s«¿X‡IJCõDI¯‘Å1´<åT962%¾…¡ÒÈ'.2žpæ»UjËUŠÃ¿5•Y\ÐhI´#Gd¡J¶¸K]}h!kþÃþðS‘B À†Ý7ÏM•Þc´Ü cÜx¥W²…ȧ8H­Ù!eä¡qú™÷wp”¯Œ Yy–¢ô0xžUÇn¡Seì šî ?+xʪÙMÍ£ÂìÛÏhݨt°I9*®#U¸eóéˆXœýˆì¦I.é¨ËžéêéÒ¯CAæ=‹éÏ¥¦ôò4›÷­ÌÈt¯Þ™Æ p:x ß êýn ƒ?ÚM©Ç£zÙoÆ¡¶¸³qdîj•Zñ¬DåêvXò­)œ—]ïmSôVÄ[ÍP {cõ‰‡3Ôÿv”­JkÝ©y”¹o3Lok}è3T¢²k¬Bë KõÙf¯Z©L·Ùœ|±ÖË­ÇÎ#Ùÿ~™Äv´×ïË–ïÐÉ}•ýxâÎ6P~¹kTàž¤kE”y@Z~Ë@»©ªOVmÆ–ð‰:ü>Ä\”[ó^€5æU¥­ì�?5 æñƒþ(?5c1<ñh“Rä2‚lú&¸#1“|ûè0@{úkR­\>!u…^ð—=¢iYÛG€¯Äíåc×°^Æ}¸_ê�©˜t\Mt:Ïã86D—€ô 屎à¹þé{kÈ@òäAp"z©‚¨ë­{~(.Í÷Gú£>uc#6ô†ŒJØwçUq¡²UQ­Ÿ î:È[ÂFjZÙû…Šìd;³¥ZÈ[—DÞ¶òg[oX\äVÓ LWGÖE‚7ôçÞ< ,šÓáÄj¿Fð³ƒÃ<³éCÛi¶woTzŃM®#* ‹©s‹Óá- £0é9hÔß°ŸÊÌæÌ–¥f6õõM0ýÚÝ‚Œ$ŸêÞÓç¿Ï¶{"&Y_†Ìvµèü¬ZuP÷|¸\…s÷ß7íYÛ¿çßf~�¸õæO êôBƇҕ­ÍS~ #¬æé�³ ×úêyWNpï §Ú|cdås¢cŤ…{j Z[ø¨¬~3(!¥¦÷¸ /Á2£¨ôiC6”™†Q1Rîtêtjéw Jï:©ÍˆžFzßjof0äëZÑùÀ’/Cp B‘w7ÚR7?ùQbÆTM ãþâMÔ+­«c5Jø—"7q/ ùªªG÷’²‰éÝ;ý¡§Ñ$âùµüù¤{Y–~'BÅø•¦A1Ížþ2‹™Ö_vàÙK9d¼”~tî̼¡<J]Æ[F»/OЇÒuÃÌÿ „eZº»oÐFºùìõÛsÿQߟú<¬hiadoleŠõ™‚èxY èÑAP_¢fž¸Qués/¯†N¡áâ6ãU†æšÙA‰8¡ó.U£\ð´?ýµ—@æ0R.m,È-‡e²¯ åòÐWrq ”¾°~z˹…Z¶|3o€´¿8%ñ;ñE¥—ð¢(Z¡ cüî<HfMzsÓ㎆#Ì›ó`a¯ýž¬}Í—œÅ!ãzïhí´Q>®¶Ñ߉›i?j@Ú±º©rJaé9T'ý ™AV¹$¤3ª}ÃpEìr‰}ºñ[Kõà/´gà ÇNM2¥ìc¬àÃ+EÅ)²Pm·mèÅÓÖÛuC÷§6á¹u}×/!p°B”¤”'%…i½ÁÐü<wVõ<þ¿V£›½é»úîßíkLˆv·Úº®$•s…{:nNžbkøœ'�8×4ˆ »y…ÍFÖáÏ&c2µ‚-&ÕmÒ®g?IãobÓ&4çe“ TÚÊYËADŽx]¨挞Χe>&8Ôj:Ëø³¿ÐÉJ¢,ó˜ûÀK 4Ù°ÍÒµ#D¸mN?¨³®¯ƒ7­¡Mn@Ë-ÎÍxÒnò„G¤¿a7Ñ6bÆæíÖ¿©{¢ÌÙæŠÐæ[aÛZ­û‘BlÐq“H?úUšõâZ'ÿb �¶û«îJJߟ’Æmç#X»¥ 2çêiò“”&JgÑš ØOñþìÐP�RG• ~µ¡ O7‘]´ƒ D÷~Ñéäé¯X–-ɸœõØRßç_•³Ò`ýAîlï4|¡ù¾ÔÇšª §ŸêšÁÆ“bÝþ®þšë/‰M{EÜR¶µ©7ãJç²¹4tºñ�£ª­)C šö-x"ƒÊÝ…fŒNÛ¡C²¨ÁQ"&Êz+èÓûA$®ð~Ô߯ž~Ô üÈÓv2KwŠVï¤àÜ] ºÉî¤`÷¡î­¦£mšˆÓA<ñ J|'(Ê}šüžV ,ËL¿P(QðdØw^oŸ¼)üæG3·sŸ úèò™œj}´hž[‹/ÊéWoö¶³Ü{òˆ+Õ9neluL#NVájx<ÆúØý˜ÖÚá±@5íÓ ±>´%ü§×Æåš…ý:I‹|rGÄδ¡JW^ÄŽK©¥NvͶWTX€œSŽ÷àoQʬ¢éWM;zâƒâhu;Ú¸Š‘q± c×ÂïHK+°Î´·¯‘§|œ'™ !¶Añwé þmo›¤¢=qo’š¬Ufè¬Z 2Ö“7‘ÚuØ\l¬®=ØÄÃm:ÇÎ)$Á;‡$>ï<Kkóc5ŽëiqQò×èéIU® •„×ÚÏÑæ=]g; „Q2F—‚¦„ÅÃd£:M hçÔ8œ=ÀflÉh‰ÁØO;HRí5^DŃÑ~p z‚é4>Üüè3n¤;=ÚÐ6§Sd¬´ÚXŸP…^Ò+2ü9Íèöœº8È®ª˹È�î9 =„£ˆ™A9H‡º«¾Ÿ'‘î*ã\±£ýœ~úæ[üá§É'–2{ÕK7Z{¦†L‰¦ü¡þò´ð$´ùÂäw0ﳡýi#|›(–ÎS7ãïZ|êJ­k/nkEœÝ¤U-0 ØãXàë¦â΢x¸kŠ#‚²²õÙ€±+ð’o’«Ò?ïð„¤¥f¦ï¸„¤Œ} Czt�ÒAGvˆÅ¢JìH@—ÚDú›¢ÒP˶˜žß½±lÃY‡¨ÿPQü†UŠnÔ0%IP.V) "wERO·HðžÐNÛ.w¬f’ĦÜRç4{Øœ9‚reÒ7ãò·F´Îm†÷ -�çθS¡à”õiq¼U‡—\:‹ÜŠE`�Dù½ƒ ?Wº£ðJ×Jª 3l%pæå¹ ‰³mÀÖRñ<(Ä¥2燜€6˜]nIìOšn±ïÍL¡¦ÉAtºxÀé#´™©Z3P| f#>¸»jÏ­í{íÍ´ðE`”1EɧÎÃÐ ´Mð7ƺð%tѪµÃ6yM ð´÷Ü`ž<kiCü~ñ½ê,Ý>Îyu6ôî dEΠ‹Ò3À@Í7@ÃlÄ›×õ�;Ï|F(DŸk”÷“‚*ãL»²YJ—ÎnìÅ–E¦³ Rá| çEˆ#tzÚÃH¡åÂØÞu…fN«ìÒYI›é°Ù)Úü„…VX¤’žs$½â› 0‹Ç¾¿²Göï�dQžû¸4(Òö-¢¡ö\ûcíù÷ô‹˜E{—wοÄë’çè5³q4]ð†š¼?zŽõ2ûþÑ„8÷PÝ 3ú)EHj«úÇ7c°ªÂh'»Æ²1N¡ôígy’­.Åj·½¦A±÷`<Ðict*z²jpÎ#9óò)ë±€Dÿ‰*WÚ<ï'×;¤85žx<‚ Ò”«]•¬7õ« c±•Ê ƒ|·U¡~8Š1/Ã_£úº‘L¦™dU¯#2¾ªQqô'US60F†¼‘µ,eàèý�ç@w”sŒ©:ÛÉI<ËÒŒ™‚ô›ÒÖÎj(:‹œ …³d˜<’d%6½aÖz®•­ä£Á£¬'n.N眶9,}f_§,E²Vc½ð)nÈ–¶÷È¢LCûègßëP”!²`™³ í¶–â‘ÓFC#Aky€g?¡‚q¼héüÎ#Ý¿’B„ÁcGŒãeçt£„&ðñ“Ç }z”6É|kL¨ÐRrn×°zÆé¿o©™o2׃}0àW_îso\¸ãMý¯“—å"Ma.ÕØa·;š¡¸<w³W>ó�+sã7IK‰Ô´•Œÿ/º¥gl©d)8/Y; ÙP¾q—°eåèó´Bà_g¤êœþNî±iE–à ړׇŸ7ûqì­R ÍõÍ‚/ÑÅâLòž*`¬wøêà²-)“Óý³}Ùx»;xÍ 7ñ9˜è�eù|«®’5˜xsú¤~¯!õ I¹=÷ÕæWÛ+E§¡ír TXm·ãl¥‡ù˜ÕK)] K%‰Ìé0ï¨tœ;Ù.ø óÎ̸¶¯²8ÖðŠo.ÔG†—‰vï°[Y6^x¢,È y1twW—+í æÜîD€33 ú3m¨É'ïŸFzçɢ̘´EŒE\𰧺_Cwÿò›‡(òÆ™=þuì ªÐFÏXžÿS5¯#µR Á•£;Rj6( /–‘£¡€ó™d~v4Ô;òUìN<!hÓ‰WPúÒx'ž˜ì=+?ó¬iSwa¾žQîJ»Øu:¤4ƒmOyV%‹9ÇŒIK¸Ü:ö<jÚAeeð' •3 Ù9D(¾(§1¶O :n +ôRïµaíé?ò(ÖV±Â-œ¯°ÛmgS›‰*¶MGÅ0r*ûùáCvâb³{w¹é¦®=ì�[¹K¿©U˜ Õ@-¾°‰Q)Üyn�Ñn?°7æëÑÐëÛ0/|æᚺEÕøä௛QSx™‹ÕwÿìÇe‰{ ݸ·ö]œÄ™ˆ!"-Ú¹Us|ƒs47ž÷ t\¾{ÀÎÒÝîjõuK£\¡·ÞÊ@4¿±(ZyÇ"Óÿðd?Êà’éûÙ6ýîª[P?*A™Uûâ‰KpÄñxY<�0ýwÓÕN*ñxÇGÿuöy Áͬ'={ •Ûƒ2êÖ¤0wÚFeWl[ÖHÒè>ý«¨/ž~Õ‚n+çY%,wŒèôyf×óã·*%òû ´*'J#óÓ§U¸llXU–0W(Ï&UQ¶Ò9¢ZyØUA>mÍGØ6¹c^MÑC÷) õ%ÚÑw ]‰YíQnbÒRçA¶=ñoZ?‹9“XÎU˜ÕL &liãÅš0ñõ Ñ9�VÇb€ØÿüÚúÈ¿BqO|¡Fžíë"HšÙó~çÈiE°ê¶KO”«Ì± •7ÒOŠÿYýê<;û®{áuC»Ê¾HÉŠ¤Æ«1cÆj©5VžËɾʹº¦—Ù|–¯ZcI:ýNg/dVÅ\[%Ú¿ÑaH2ß½±*@SmhºVbX…SÝø)>ëÿä‰6JºCLÄï©öL»›z' #‡ÀðÑ3«yüÛ<3¯á¶ÂžxßøZòrÏ Ê“²cFàš×ã;QŸ±½ÒneL”6c”Íì †kÙÅ~2b‹^ýP¿ªVþëæÈ!-{„²Îð±¾àiKÌPtŒÚÃ<?œHe).…‘HŽdDÍC”fµÆpêBYëDüôOžö"g¸ìØÐ'T¾h$ •Ùj:¾èÕ3í«"ª¼¯ºÄBgÆ»I)ã’÷°6‘‹¢Õ£‘®Á¦†þŸ ˆî^jv˜{.è|@²Ë_tÞÛZ»ÛìYüFGæz†ET£]1 T‰f#è¶>ÊD6¾OI°¢‚»a%‘V›$r¶lRµÑ0ç~ ëHnP*P*é¤êÓôÄŒ¿œù*&Áx ŠöòT' ý¾3œe*Xj4²:3hÁ!%Öï8tœÎö•ÅY¶WèïÒ£·òI·™¨Æ}¿Ã”Yû+þô%ì-2X¤õOm­X(Â5)à¯t¿NµÖÑýaÓY險–;XS”9ïúzþ+]dçò.óÞX\qÊÓ*<³…×ø{? ±¶Õ×æ@¾ûÁNä Xtk×Ú#è<p£É^ˆŒ1eP\ÍÞð†ó¸J+§¡_0ª³:éᕳº§$íêîÚOhÎ"tk–ÞÔô\ZMÑú‘Ö­êË­T…`ýeU²�9÷.¬p”„™G/€Ñ×6§¨pu¨1Êm£zÆ->ÖƒaŽ˜«'Á;ÊóÌ#CR]u©)1¬¬C„¾˜_ú ]Q+ŽÍe’éò#ÁØ!H3Œö/ðc´”}¶w;+“Àêuf2ü«0ñ’!™8ÐÖ ¼³Ö¨óáðý'b*)ù™æוç"ÂJ‚t€æô˜73¡”°ãÙ†.Í=åÞõ\ݳyŒWà ÝúpB'w±J9!#Ü177Àê¿�«Œ2,–nn÷( OÞ´dÃdA |4®ÖƒôÓñ(ç¹Ì0~ªpU†¾¶P<{Ra§[‰ Ø0¨µÄˆyoeÀí哼4¯üü¹®”-YÁqó4ÍàôÁüÔr\xrÍŠcšòZ·AjŸGf“žKÎ*ÃRÂÁ6¥Åh! C�ö?oð %0ÌAß_®ífìZHÛ§=-¶~Û\a¾ ǽ¿B¨ÎnÚ¬ˆiEÝ{ÐœfºÖÜRÕÿ<¨EŠf”¨ÆÊ–hÆn뢈ÊU‹„݆6•×<4ÚÃO&XIY…V‰‘HSA?äÝ< )ç Ù+MYêTÀiͲ²ò¤=õ³BtXødUVˆ¦Goµ›¨òèÀ$´_ZM¥g½Æ†¬ÁÿùîÑ1éû)Ö_‰ð§éJ¥$a€`t>yÝ\Ž»Ãy‘îá|à/‘‚Eâ/dŠ­×øÍúì1Gÿëžr4}œòÒÒ¶8¬G×wøÔIæ+"‡0ÌÌ‚Ðz‹E0ó/Uù=š¦ëÚÝFVÞNrQêS(¡*ŒSi@ë~œÒGÇ£TV¯ÿ~u'd¡ïÌ^Et®gÍÚ6{(Vo‹`ƒé–`NÄxÌ,ùQ¼$öûlï„(Ö;Ç‘šÎ�ѽ(Žîhe>Ä2Ã}oeí)Pþ9l(%>Ô6£ù•XfdíŽ5p-ÀËÅV{�²{ †Ÿ”§r3p–”÷ÌÞ•©£R/qÍ‘-÷k.:|ÌsDLu_Nñâ<»¡¡/ÛØèpûu.CpÞH©ë.îCP³ÐG;Ñ{N{*ÉË¡¶F<’ïzUækúYúV¹t_/mTïŠm=QÌîÞ.ûɯ˜r;Å Ò‚z6üÏ–ÝóïùÃÕ Ñ/{4 ÂaÐð—q@�½õ”ÏãéU¬4Í< !~‘4J¥ï�cNg¾¡Ê?+`8ÜSb0„¨;9dèÊ!y˜¨§«QâOúב…±”¦W¿ÙÒ™u:©X-ayúHGÇë“ 0lœ¦·{ø�çµõ/&Ùø‡òç„ ÔÃá²YåÐÑ3t¼ºˆ“С·> ,ßý?µ•ÅÑÐ «iÑo¤-XÆðHçîY‘ôHq[®ž6{“£§AÇØ«7äJB�3úê·¯÷KüV<»?Óá5=v•Ÿ›ùzz¹º2´a³O›yŠç4›B›õìz¶÷®Vñ:ñ­1ûõô˜]½ún;Ñ¡Lç—¸Èß}QT„'öàmfÊØ@6­#ºEƒëÈ-.ØbùÔAÑ–W€+gÚóÿk_ÿÍ„4[YNQ9pɹ‰d—ñdŒÍÙ×¼½Ú¿r<X÷ã{ê–f~×À€?·n¦q^ÝôE̓iFS'Ù>•^äLKÿù›wZd«°�Ê5ªùâtcÄÐÀÔdì¸à.¶õFfcFeãåÝòC½löÍÙà©Ù]¨”G®þb4KP»'ÝÖSÆ·Š­ í^+ߣ°òQTvÓ*H­œ5¬.ÝÕ`êKõdó²:L£L‘8¹IÛ¹ÊÖz¦@ÖBH-å’e¾ó-Ý‘ÍèÚä©‹Íì{Dõ:@¡@°1˜Á {Ùd"󛕱vÁ\N (ßuXö‡ú˺Œ2ÐK½ÊI3ý ¨® `8EUVH=|_›yU‘SÎK aV´Ê¸`¿útb™Ó¯ÿmök½eÂÐ@6/Œ²,½4Énö+íüEôÞ‚ÎÐ=£[xsZø<=…vˆâ\<×N9ëa…ËÞëC}@c‡¼þFQÄo‘³>Ø›Q¯k ξø¯=ùéßÑ7øFaf½—-z“]oFù”´^ÛYð¾Ø½XÍÝ$M´0³š9ö¬—÷¨ï¹’A4¹(¨và X`FŽôl ýK§V7gW’0û "Ç[·ãdb9žX¤™Ïùñý.êÎK-ç3ë%1DÍ•Oò^qA¶ª¼BCÊ‚íµôô(ÈõÝ(òš‰ÄßR ã¤ÿ ªoà¥×t“¾ýÅöÚ··©g’ùÉŠ%8i>•\%g¥Ð†2èÇq‡®æÔíóú‡;‰gQ­4 ’`:R<,­ôN$ÒbÜñ“É•4T@ÃaÙóÊŽwq«ÈØñ©X8Ú_=Yì-<ÉYú(†{Çñ£»?~?•cßš3fÁ1‚e×Éõa7#ÕƒrOÐÎö¨±)ùæW’F¾š/4ƨl‰­ÏZÊ{œÍŽ–Ñr?Ò> ºq¥lØÂôJ¥°S›dÁÊœ  à¶-2?—þ>[‡ Ùç­™+ îx‹Ü"#\ß„ Lvyþ7žÙ@(pË j)”Ô}jy—…âåj„öcß0ùá5¥”²È<ávJög½Õµ§"#ƉÒƒƒn<¿Œ_ô"w„m“£,©'L{ì– UnØD¥ÊlûA™£$¥ÂÁ ²¸o6€îY¼~ÿ}<RN´98×ÒëpÛöleÂ7u7XÜ¿dD¶Ÿ c’ÿ' RçÈQ¬cÆñ 8¨Ì~á óÇ"s†™aI_! ²zv{ìXCÐÇþv,Öµìgî€�|å.Ê2Nۺ쫙óYzÐ [ʨŠÆ‡Ç|¿;ã #“ÿ¬νP±H4¬«BÁfaÜ:Ö#âia•­"'’ö-šW–tDþ÷-Ï°DGª–ð¹UŒ€n,ËW*+àÛ_üL#(¼”O‡a(ƒ¤·‰ÈŒ�­LÖ—ÌóïänÉZˆ’ yÓ©ñì˽á±éÑñ¨ãÍ+2•ùN§<u\\øPãDÊ‚Üfè˜Ç÷5šÒç£áã*a#CÜî ,ãÐUG!›]$íÖv f2øpsÚö˜P–ŠkžÛ¯Œ.,éµ0½ù-˜¨×Ê®ŠYuù(ÂG·§Ðwû,O©[¤€ øâïÞًܧôú®&sW&ØÖÇÙæ-ŽVN*Æý7í cT{r%ýƦ“ÖÖ‹¨¿<\½?•.CEIùà§BÕðèçâ×wô7 RÕ5¬/Z‡CâuË�HCj*Õ·qxÂÌôS!ÑNß&%§ñv$=Õ-²)ÃøÓag"ÝÙöõ±\»î6ó³NàçäW‹øM!r]o¥MW«ã.×Éœè”*npi-OnL‚Ne×vGœUèv/PYÜÕíˆÕ JJ© êžÞ´tŽÎÝþvªwÎÊQ¼ùÜÅèC¸øFxˆnäÐ'X³×Î5XQì9³ð ÜKŒ°ÄOúFT‹Z`¸’‰öš¿S¶©xå(ÎjŠ‡©ï¬‹Âï„>³N‚$9ë¾@¤±|Sîá¸bsáŒÝêÄ•©ÛSÜG­>iÓ„B¢ó§îÜy2¨í4^û“o/ ”¢Ór¿/šæ7ôö¹Îax¾õ2u@@‘•LKÒ~<Jîº#Å€èZÿdF V�€ž¯P­ y©’4œÿ†ø˜yVšÚ; RÅ÷ÚÓ2F;Ç<ךysü�¼Ë;RjQ–ùò—PŒ§Gœ´Zd½͙P©¶¶Ñ£aYÃu¯«Ìã̶Aè“ í¦O¡²n$«jû¾1ßm.ïüÝ÷=œ­…þZH¤D'!§Æ‰%wlÞFÅѬ©Àê^ °Gÿñ«eQnúù§‰Ž¹ú]×P&°”/”{^$Å°öf‡0¥§rݽw C-ÌÒ ½ÌèCÆ_B)AÎœõå'ž{¼0¢ät·(ÑÖ{’1óü+R‰ª…… C—RDÕǑǾՠI;^}ö¯¬‡ÈSƒ±™òÆ´œÞݸ#@|Uw:3z]þ5´¨1®óuIÖ°Ôüs\R• #–¤6˜QX­£ŠV08eEÝŸAé„LèTDo¼05FмuûNe,~fòy JóHYÝÒõÜâuº+~;`ç\ °™ÑüÝw=ŽæÅIåF…i3Ñê›}AÚ¶ëNÎ5€( ÀÏЛëÞ ªÁ’eˆUu:j ¯lf²ÌE¶À8rô½o8óH'É÷ùáÚð4AÖÚÞ1QVæUÉÊÇ–rôk k+9¯OÅ{@Å(ÓGß­pvEÀ?uÄ–M|c¯§_˜B¥™©ÔßòøjÖâ±D8iîz‹0ëƒa™_)œ—ÞŠÎq°ôgªv,e€ð¬-×Ý©aUYa)™n óYí”1 \ }¾næ å"ñÏ>¯v¬qÅ2¸ÐðOõ…ÊÙPO>Ÿ.þWhÞѲÜy¥Èx FYõVõ RóFoÝ/‘9eE¡3Ì™Ïý õ¶(HÒ)žÜ0~„{¿pÉËB?§Gg­©ìhmÏVôõYsˆá6ÿ˺N*7±/%¨k]§Åsî¥@¾§Käïó¹’Ô•HÇUc‰éC;h·®O±‡h?ª)�S2ÿg¤MõÃíÞ(ÎM$ÿ~žyØÔ—Æùzž¿LUi/žZjžm(KÔäAܾ{ž®=6:÷A:;åÛÉ·vWOyëQ¾Ò Ê(7ÈiY][ÃØO¾ŽÓ}Ñù#ºm߯ïTõñÊ7“ŠYŠgÅyïáÃXžÐzLÃn%ÓZ^Q*×…>WDT˯Oß –ªÉÉUEûÃÐq^ÏBˆùèük~îm'cA¹ÓµI¦qYXˆw¡K­ïà¿Ò®ë¡‡[;7ºHe öhtBøÛñçâ¾êÓ�ív¹2y$Ð×ïû9²=ÂÊæ1ä}ë)õîêÉê3±"á/Qï©Òl¬‰žMGç}ØÔÖD­d Ûªx™Kc´!»þÆìN÷¸µÒ‚Ì «z-#Œ ðÿµ2Àßþâ¡Gó X€&)ÕYA�‰“Ƹ BÉùJÓUÉÈo#ßý¿…r°³Cg#eó®dPX@‘Ö0vÒ-��Į̂տëåà|5 E9ÓÑû[òAÛA\²ÅhQ<zwZâ쥉•¶CêøGÂ9Ý®4 ²ýÙ0vn!ç|xõ§—•A_W@<rNqP~êRCYÉÖ;gOa/n®�9ä‰ßW¬<6eÎú9TnÇ{=û€ý6ú¢º¤ÑÐûËÀÜt§reX‹b”ž¡Kfnöiä_ïMžn7C‰ ¹ïkñÑ‹;x$[ÑïiíRpŠìy”²Bô‡/%üC`ÊÕùi„A:HÓg_œë䌹„gÒñ3’FYDYlÝ*�ªœ‹ a@Yd’�úœbÛ°ðýí)3‚‰7mð²ò§ätGY“<™¬Œ œ‡Ù3ðùIÜéi*€äØ%A1kk€TeÁ|AÅ̉ä@~"še9ü©oötf' 5e*ˆC·¤›i$n½Ë» øVjsAD¹®�;T^g7Y©e€%ŽseUh¾®!šnê£AŠšZ<’†0·xßšù) )-ãÉ 7‹v/ý�ÅMrÇ@¨D¾G{<1½íÔ 68QLëZQà|{÷Ãÿ<á[i²(繡øêµýÙŸƒ£ž•2æåT_2÷8Ûs¸•Ð6¤sHÃÖ®¯ÛŒ£!‡§QÚn°¢ß £Qšß¤«X"™«Kúáú?öÇ»’ÇmpùÓ&2"5ÕAQ­ÕzAÀïÍÓHN<ÖyÁK½ã8ÉRὤFÑu¢mZÍ;OhiXSŸ– ûú„΋ÚtdǾ¨¢zÊ¢'¶u÷0³²ËQÒÆMe´ö·Ï ¦ÄÊ¡ÏlÌ!ÜÕwá×8ô=­) {ŒÀv†W ¸í¾¼ƒzÍxNH´#ÛBϘxT'í;$ÆòБ5ÖErˆÇ0™ þ×Ðql¿<9J:*¯#¥’¶…qê€rík‡¼ÏØ,ŠÌ% EïYîwæãr»gê.ŠÇ…¸¶ÒÇólý^TÝuN„¥)†D‡ 3‰8N5ó8«àýÜèˆs ç'b‘çžXA龦³÷ìƒ.8}„ÓdM ¹³Bï'>sÊf¶³½o5âÐCÓ-1¹Í?}-/Ckî»Ëð@éÀé£6yçæÌRPòسÞÄÉ,Í[šñ!=dÖœD°5%Bë·“aÎúC§^BT ·×´1СïžaðÄ^¡Ö™ZÞúppÖ²x(”Ga–;±(ºÏm_Ršªd5iBZ±4’íùd’0ûª’£>ôtmjëLŸ™ª4/Iµšjãü{ï¦??Ïþ¥câ6ñ[‚ýD5Qß8+lÚMËÅÙéPr#Â/$t[v0?#;£.—óκuŒˆ¬R%ýà þöÛD¥z¾Ä†ÕCB¸o]E­ËKfOY·‚èÈ€B÷hĉ¯õÃ~Ål*?{jÙhæ1Ô«>·,Ž¾aç÷9ÕÓ³ ÒcñŽ9÷bý)#?ÊẙiöFú»ÄJý´Ù„ée·Ã§®„jZƒdô®üÒÃm«›MƒiWÑç»Co©÷œ+ª: ùAŠìî·¿øÑë,õZ6‹±7Y}Yt$¨nÆŠcÓs…PÜÞÔ› Hï¯C+ûtµ JW0y‹ÃgïÂÕç3¥ÜýúPFåÿ‚/™*:N­ñúb¬â¹‘É­ÏŸ;ƒÎ8Tnó)©^?ìpêM­G{†&Òì9QËÑsó*],ª½‡»Þ äæô3f¬mí9Ê mÛ^¡`ŽŸ§Åë9Hëžß8ïôSxå†c5Ë Œ«]*N»þˆÄƒßyîz ý_ý‚*ó‡ïkë26g0ï_B΂îêdKSÅ¿Þ½òÞQPËt“ǯ¸dÖš#&þòÓÒ3–ëpyÁ-x¼ÚÕñ5’V íߌ™eŽJyÁ`˜év™¼–±øÄŠ‚]B.TlÍgÇ}4vŽ-ôÿƒû` nïúˆ,ì‰xJa@ž�­fÖd2Ê ®tq§çK¶®í–rKµ”ñgÞÝè.Ú6€gøô?AËr52„v]dÍì ìkú ó½Ïû$Ù­Ô§QzE ÏIÒ«õ~°¨N“«ˆopçG(èŒçöÛŒ$rämæF`­l ï—^ßQ#>d| </ÓƒÔ+k*.–dìiwN<`.ã0XMú¢ïos8ÆÅž§­¸H5�çÙ䈈 ¬æ7T#Ë…“ T#:[mšÝŒ\…]äÿi˜Fþì‘‹œ¦zè½yÕzŠÙ«„>¤9ø‚ò~–{×ìOÕ  ¿líÇ:]5••. ³Ù‡µÖˆø žÂ¦°ê‘`LZÒ¸Ñ>†È£€�7ãi-GÉúÄ.}çÄqw¦Å•Mg¯{Á¼p.ÿu6‰&b‚Þ¥5ƺǓWÎ|× ÏkZ KkÕ)Ã7;O<õ|˜ûÃéy[Är^Ų(÷«º÷Xn›Ã,ƒM؆s±ÞÍ4_ã¤ëaÁÙeSé^Û‘b)dfk”B§Y=§ãÏÏS#Ãÿ³Pæña¾Ûù¨ôfŠ3ûp�j–(mÍ/¢Ìr·¢ó„ù*w«@% ¾Ø©>¸r~Ò:>蜙›zÇæuK‰/”ï®qÐ3²Lý²Êl€t6Æ,�0Õ^/@øáöÕˆ)}#žEEêfÜA™ç”…8ÌÁ…Fd(Y{ØtlQI cJ/,õ$ñhʱ r|Ö^+Hdšgëv§DÃùg¥Ï2r $FE²ÿbf ¢"A¢SŠõÉ^r_L<« öö_IP\´{…fíi¢óÁ$_üÇËÄ¢þ°­¿žOvÃ<óÙPIÐi/ P,Ìpi­?{¯Kõ¼_åñØÏêCçýÕ’~ÞþyË"58v½Sµ0°æãÁt_·çþ¾ÁUæ§ Ì®(éµ ,>Æ,—î”tÏ!À "0dô\"ÆÍcS#ZØT@ÿÔÎuâXÏÀËS¸y6ȶ Bþ í,{ñméW…gDÅÅù’ñçb1ÂMÀ-Õ£Ñ_Y©Î½|·¶–1HJCíóCè˜-®V_EGymñ¸Ô`ž\MeÃÍu:XÒÉÊìçî%¸c™/³NõHû7j”´‰6æ2ªm7ƒ 9?óšœ'ï4?#×ü4ú´%Á”²F½ÖU wG__µùSó½¡J°ßNì´ýdª©ži.¼ú„ÂÏÖ52èVÌίì[E»‹[Lƒ?{c-T &çZàó&òÌDã4Ñ;5Ú™-£@©,væF'®ñ£€Kqj%:\­~ƒÌfú©E£dðdçæ„œRJÑ€öß5˜öWˆA—«ùóÆ” C4t>.“uŸÏ€"ìkzŽñwÏ2ôÏgŒã:‹Þuiàt–YŠo¦à;ï\¹ŽrœùPÈ’’E Ñß/6íÊíy$yÕ{#ËùÿÓ\™¹T·çé›2çsÉÌüf ¨û¯Å(#]–´ÖC?þ. þÈÚðeÁu¤ì9nt¢lPi‰Ç7éi¤sÔlpE.ÌÓ[Iù‘Ö~y®]±ÕÑ.è)ÜÚ3l—[hÄOŒIñ*3Ëò•fŠÁÃä“Â6gUÛ²ƒnD?I;<cHY<òÓÞMó€m«Ì®>Þ’„@S5Ãä{2>žd*>~@\÷ÓêÜNuçÃH óÃSæºg-l:w¯ÿåcmG&³< ÛKi¨ÁÁ@ÿËÝØ×ê%ý³¿Tš:Xú÷±ØgR7K;ñ±àR˃øûFZyÇÓ¢7K”­× ¥s‘oª•ì Ú0ö]‹| ª²ÞB1C»’ {ÿ4å §3fc`ç#»^„y•þÔŠ›è›†òõìýjÎNvŠõ¤E` 6™ 'ð¿ÔŽLãÐëYRÏjð ‡ä)öH™7çAĉüK)MîzÜ’š]$B’̹ ÊéâÕ®}ý¯”óªæÝÊ7ºÔ=æ€îõV¸>öz‰ 3]Çå�‚w?O%-;³f×úq©›°ÜMŸà¼U+Bž Rcs˜>š«ÇùÆ Cü×ÐŽ<ô £¤ûìk¿`ZÉÕwíŽjS÷¯IøW¾« à ‚°bi—ñý=pWkæ’,o¬÷pÂWÅÍöW—ºrë,- mX,ÂQµrm|Ó§ó€Z80„qóâ³T #è¼ùªN¯¸”™ôx&ÈNçÝlÿÏac'¸’pá›Qö_RvkÝÌùå¤û}Ïù'ÿFÚó ?~Ðñ}ZóšÝ°{v`a°£ø çè¿Áᯰl=×Öe iz¢iX›¦s{ídÏ>‚ôF*�j$-“`{M‚j>{µe;<Øä1y?¿r-¼PècE°ŸhCÚVsÌÁ×Ö£?žmZÓ¨næ3‡¬æl½5ËQ?.ÝF¿öØ™NýÂ#€ÆÈ™@2_<>ÅFY&þŸß§i”­é }OÕ\±WÙ·i?δÛx}ü÷­ÈM­p.­ÈQ ßÑäsji^ƒQ4œýÚQùã°Ô»s§õ'™ï8q™ÃÐzô•‡‘bñžvAgÕsW©Ãa¥bƒ•ºü¡C mþÿ)hŒÄjZt³ð,G2­OùóJÛpÞO£ù5Þ%b§sŠ¾�¢}úù©¶;ˆçˆ’‡žG í76¿ð¾ÏO^<qeŒBaŒ~Nc…D1æèhyUšÔ6o"Á„!,CàëônÞS¸²œ8}=òÎJ¥zðõ¶ƒWLѹCHÇ.OGsþ.²è©²¡ŒIvæ`“M×ï`ÚpÛcÚ| w™^¹Õ|‘¶ÀeKt±ÅÄÙÉêÆ4z‰¦ ¯˜Ø8ZƒçÈÊ-ý•Ãslß97ÜÝfNè{\}5o AX(ÈD0ž™1Ç_áÕÓp%™C„½Æ¡Ä ‹¶:©¤—õC8ÌZ~©y|<¬?70ö}1ÚâoÃù‡äùFrÏ\=$XĹOl¢àÉjÓ ­lÖa™‘y÷2~ЮˆÂÈyAA3…î>c;í!$ìØ>Ì€¤v¢6Á.kŠ5\ý ó±ŸÿÃHwWè›a»Åö°Äïm©~UÀ_ì¶Òƒ’e8† ¬n¦É¤YY^9ò¢þ¤Ç9g¨GA£½ÏÂ@ßE ñÎX–îO˜M1ÿxœŒ„‡Åsû!ªA74€ˆõywž—³ruËä•E”¢mþöwƒu5ÖIæ™ už‡ÔC󉤆Eó™­=r_UÚÄ‹ºK™ßtŸ–CíÊQòèé%‹ÊàAWÍóáv=ûY~SÅi0Òë*’x—‰Ž¡¦*¢»v ö4gK%„¹Žë “¤‹«üùD)$ŽÊ•½hH{;R«ß ÅõsC%©³ÙâÆ %þ6tZ„+#R‘¾+ÊñXozŠ>ÿ/ XÇÃã3ÿjœz>x¸A9åut—¢¶óÈ'eçóAÊîyÝüAï”g>8rÕ;JN²y¯Lj‹çFíh‚Ð:äØÞ8ÚrívçÊiÄ,4ÊÐ7;׃W\ìçÄ€.æ.`¬Èñó)¨' KcÑ=oú<Èv{ÏwÛáßq@©+6ñÌ^@f? ð³]T”…Ù¤Þ‚N/{7ëùÞ¨Fzñü@_Ò&Œ ãØe]1”A@ÿP }CZâ´1Š­È/œ»N=p_µ}³•avi¼¥§OëEU/ô}ï«"|·i/½ö‹g *%Ó q5Úoz5j ‹¥\;1¹—TåŠÊ—#¡8ă渽º™ØB)7sÑ géåIs\¹ÙjÅ7ÓFšÎv6Ô ÛeE*Ä‹c‚Çd/]S<us¤{$¡è6iË”~Ñ7¸TÀYéþœ(õåw²‡ñÿ`;ßXžRŽË™ý§'ŇTɺÙüúx°rñXT¥£]2ò+{JżV”.…èu¬íÆÐÝù›çš7QåóÁ0~ÅܯV<UÆàãΕUÏì˜ÊÊ!EµŸ‡ ÛÙ„“-Ñimë9Ð_EKõQ’în…Iý¶÷ÚCù/„Û`6%ªkè ^¦î‹ãíÍ+¢nâÛ€‚ YWA5y1˲8 ­½CáÖ eùt#Í(£Ø¬UV^¯¯•0³ùg_æïa·¢´ð‰ؽˆE{OÝz#·9˜bSC”‡°Îü.×鶫….š¢)‘†AÒî­égX“7A™®üíkä*Gœ^ Ý¢·‹)w»h (JVä,²ˆÙ=y;kš•˜1õ0D,ð˜šôUqÀ²2~/¸ÝÕjö-‹¸S³LôœjU̓5äµ»x ýÎÓhþÜ Œ†âŸsÅ+=¡9®w—mEoèE]̽€µâÅJ5{ÔȈÓŸ6H»Ê I쮞œ¥¨{ >Š,£ ÔY„¡û‰ªõ¬?8zWʈÊóÅ$¥‡T4î×ʯÑ"H̲)éN(¼ ¿ïúzTeÅß*¦T¡ßÑã¡/Ò]=ç6Ì2äß°ÔgÞÔ7¯æím 'J M³i P­îyʇ=à Բ¡anTƒiì™Ë+aµ+Vdõ@ŠûJ‚¼ÓÍx"›_¢µÉùŸ‚‰^å™/ŒƒTŸ%AÆkfºA{hóvÞºm} ÝåÚ¶ÁéÒ÷û®?íåJ›4�B²kANÌ¢Ì7tOP<ÓB_I½úîÌ{º¯0x÷ò‘gfæõJ™ÆÓwH¾¬¤@ˆ"íOÊe:çwèEFý®ýŒßã‘U ´ÐþêŠ,·Ë¥àõ/F‰U<Ž•ó#’¾ DÛ«ëðáѦÿ^Ð7NKÔD}G™þlJôªí™óá)C,D0agÉBýŽõ•}íþû–D^ãRõ›#´¼ä¾Á Þ=Ó3¾Žæ;}©“(|ÑДÅßõ'.¸<³u×6|^fk6<ŒÜ¢“Ë+òµµë¯,Ü"-’e–OÕÕ¹7³³¶Ü%«ïXñïäd|s“‚½—€ètP ‡§&`ûpÒ^|t”<ü*Và¥1ÒS»BQþ]“Ü´XŸ6š÷Ü‹>—ëlþô¸ë1Sé£SZ´ –””‘ê[Añ‘X/!³Ê`åÀ~ê« èôí!îÝÐÝ«yÌn,šÌ¿pZ°ž¾FÂ}?Ø”G§/¯ßÍ6…NEÉ?ȇ¹í€ƒçæ'zV@=[ùe(ƒì(6Ń’-cg˜#M““Á¼@®ñGåÇ4No(ö0Ê wÖV€™øÈ=w îˆHý,'•gQá)Vebª’ö³?é¤|‹ßìhÏSåe{•$®À€SgW1� òíÖ´w¡ÛÂ�OoŽ¢­Œ–Ÿ"AóÔ‡žCMa¤czúò8 èÀ-Km»÷`ÒÙùâÞ¥S&ÓµÓä0Ñ›…ƒíw³ú>ÚvÀËCH®(z}ˆM |”õÝNÝnôLµC;:‘z]‘`êÐm=o41ÚIÐàà}÷Ò Yló$5M ”I~j¡§M€ep§Ýç‰Ëcö"²öªê@ÊØæAâtÙ0 =Ñ~äfD±aÏÉ„ŠGØ ÎŽK,ìzÑ6ÎoÄÜã<vâOø̘c¢»xR:ÐS:+IŒòè1ï3&Êð!ÖCDà³wж[_Àƒ êµQ}óêèÙʽ6Ï Ì0”QCÇ®P+™å·7àF+ÌgšÆÏ}kãâV鯙ééuZñÀdg©{(ŒÔöž¼L ²^S d·x÷€ØÆÉ@Y¼¨û3b7JªÕì3 6—,ÈûÖkÎP1¡0ýä•ìk}$Q7?yä¡pÅY�ÚÙ¬÷ä*Êä·¦3¹éTt½8´Œ,±+2ô Ã© Ú/óKWa*‡x‡Lb'Ü…1ÜÅ$©Üí¼üv=b­cäFGÅD°çÖu$ Õb#6&Ü�^¤µ¶C5a·íWãbŸÓØ|8í¨ßjÐ9É%ñUÉ�ò¢Öêf¨û¦­uŒ ×Üü ô¸[À×ìW”妩%9F´Wz.ÓÉó­í¯ô z!éæ'³¥X-§‘)|cžü‡t\\Rö»™–ëÞ¹[ª†1ò~ÿŒý'öéæ<Ÿ»$(-º'¢$/`N0KÑüŽ;i Ž¿‘f¦"þÔ{ht Z¯y5^dÉ ãû²…‰ÅZÇQfÒ‘ÙÌLjfv|-‹v<�â¬`OìÅu¥¨Ý{zÙzƒÔS…õ–;i%wõG WW*ã4‚ˆ·¥IS £:5_01èÏž‡ÑT"‡–Yß|A]>a ƒ“eÙ{µóšŸÂ<3ªSòF¿Èø¢Ä‹| K× :·k¡ž÷Îk{fS¬gü¼kúP2ò÷ÚïÄPTšœrѯVMæ¹SR"¹ƒáoU+ó›¾#sÓí˜U&]P@ÚéÊw!qWfN˜ˆ~AÍW| ÐGa_ôyu<,Êö…öXôŸ<O|Îh˜Rz’Åt›lR‰óª=†v°ÁÇ;n{ÄtŠÞ7rÅáJ«ê:­–÷«çgj’·â„}ûz1W9|7‹¦,Ÿtö¤ïê[– êùÓ9¢WÁ •ˆ,i�5UYéé«q©»o‹ ¯/N¸®…šÕeÅhý–±óOÓ—ÄC«TÜ™§'øåÿ›Cë$ìT˜ÿG<–Ý?‘ÌX3äl´å]lÊ‹^‰[àAdÇHÓü¬Qãá鑲ŒP,éã X|†–œoWÐOÕ*\‚bå3¸bäÅ™Â0G7û˜¥«þÜè+ˆ¢êüþ$ƒòø_"ª– ×:H„éåA\ëä Ḵ̡Ỡ=ÖG‰r—'bòO{Hƒx™\®ÅΠ(+½ôÜäú¯¡I ……f »¨ âÓÙ p .ÓK?û‹nÏ™W$ÜW¹&AìÌžq*žZª—@3‰ˆ5؉T¨ðÍ`éï>=h.ß^À[ƒ¿„™å‰Ck±k™²Ø‚Á�Îm(£?Œf¦Ô�ßÄÍ/1¤}Õ™6Î4fŽ3ˆû´’Zy €Ï;ïµÿ‚+k¾2{¥ÕÎnÇyu£ø#¤UÙ,ÜÌB^·;¶,{áMÓ#`Ì{2[ÂR…mn“õg¨÷¸X#Gàç“é¹ê^jW º•.Ÿ…œÈзëëã8tÿo‘@%®ï”²Ð­˜êSóc$sßÕ.Ñÿµ'k”ç…+sQÝ}QŒ‹ÚÖŸÿAáQ2ÕµÖá9´7N2QåጸmºÃç†ÁdHV WÞ ?Ï×OlÏŒµþ¸à¢liy÷ª檿ÓwŒóþS{õVÓ×àÜ®î|=ë Ð5IËXÇÚž—3=E¿˜æ ¦KÜylú+Ή¿3¿WSÉa5i]ç¤Ã·-@ûëÐ2$Ô»z@ÊÓt/”€› ó³luþ€ý¯‰¨ùèÿ›~qXf,P–*3¦”‘o;ÓOÄs9ÕýÁC¬ó$ÐSéùwX„«,‰™RµÙÎöKG\ùÑÙîgç»Èãœ0XøÄwt®=½$:ý¶‹¹«.+bzõô ¾ã�j~ ³ò|¶¢’¬²Ñ»å^©ø�'š«RÎp΃ÊÜa%¶õÖáûçAZQ…k@EC‡ì»µÍ¢À ²M¶SõZĉ2?¡ŒUã=g*Øh9l‘:ýz›d7‚o”ÊÓÂßÀa¶G¤1$u”À{êÈ,±ÌÇ·¶¸ØPÆøÐ0ð&}Ç)êýKzFéʸFð�l¼@¸§óMÁòKb6|¬hdÌ¡ç.l·nH�¹™?Rv|@Ê)Ã5X¾G¿ø¨€qÑ4‘öUV^\ø]Vîá¦Aºë=««Ýˆ’dˆ ÃjfF·jnø —…‘oØL{€µAd½‹oG&b˜bò‘Müîd‡±Ó —êwìË ÙëÒ(Ñ9�y÷„fãÊOàèžoüKÓYcU2^°ÒþWXâYR¥ƒRNŠºKÙ~ïq8±o OÃM6~Ç|õž·Å Ì5ÌEØ‚0b*�eÛ"Pt‡~ô®(—?"ê,Raý3SGB_»+ »<HÞ§äí‹Œ½l(ÇîŽx3Snïµw ø1=\6/rv½ 9¬úc~gn,`NfÑÛîTB7Qþ.…£`Á¡ÁXI­.ïøKAµòµBÂ2X m·'‡¸kúŸêÊ»ŽîmgꣳžÒ÷ÁQŠóÌÌdx¿5y¤óÉóÍ$ªâF¾õØq?ïƒG¯,#ÿ½jÒ¹£éQv_Idï[Ïð™SN)pE9´¡ïÊ“røus£(m“MñÎþ÷æøG |BÝ ñ<²sÃÊ€|;ø„~ZÜGÄ ¤-»2~ìïø¦®,€AÏŠ²çA¡úêÊ#­ë#†z‚g"÷(ôðM¸}5I;B䪅¾x‹I綱˜8©¯Cÿ!ýE{Á˜èy¿ %e¸ÅøÌMª €ÙàÍyØÕhr¡ â3š²Ž„Ñt<VÃ*{ðùcíì /¸íî8ÝÅ)³®ÛJí“Ž1Ó]<8&x‚Á�‚YÝ�Å©h`;Ùõ‘ú䩺FoÂÃ3Ìö³³ªbÎJU8Æf¨ÕR¨|AÊÆ奺4Ë|9ØÈãã&Û“¡ð�F9ŸãEea%Eìpj/V’)Ö6UTãÐ�Y±øD”ÞäpHÛŒ”¿4K,B‹�ŽbñB¡O|ê\¿±žvg…k[ä7òˆ¡ïpD¿àc¡e)Ö Z0 …è,Í‹mYß¿¾£MîåŌςBö€‡Ù.^Ç®è÷ˆšýŽbF÷Wgµih÷”"´ƒ9€újÔÆM¬dõ\¹l–>Hg¥¶Œ¥í}.L˜ù꟨ݧ$H-|8HŸ×t0Äæ\ß]=Ê(³²ÊV8òa‚o×)_ `°fª)&€¡eöínœÄCÓŒY®tê3˜èæG‡äH$ƒ`Ù. ³½ë9Wehê ,à©�š²˜ãÿGçHõ‰$5QìBÊÃvß)¡‡¶…¾ÀEYóRrIÈRgcO_ ŸU„jœ›óô¯M/ËIˆsg–Ö/‹±Rm›mgUXI3é\ŒÐýµÅPýçA&Ä62m€b5Ía ŸïÑ«'X!T~ŠAŒäŒO*7ÄZ6h³ñÍP¨Ø_C9£ÿd¥ÏS¤X:~ÑI÷þ.X.]çÑOÛWrýû9Eè«0‡ÐÊÁ­ïO¶Œ§[Ï´‘GÅ©E5¢ã²Gks™ïI¸ZhFÈ€W` q-:ï®ûæ Ì~¸à™Ÿe‰ààV/߯œ¢Cd[o´wç $Ë«(S²ù÷vœþxÀD ¿óÔ²òû€\Yèâ|ö X˜ K ص.„Ñ1:¿ý,Éö-Ü·¥!�»2ˆ;£ª€›/¶ ÷ô¥¼K=tžÿ•¯Â )!£Œ˜Ž¢®÷* ùÔ ^¦¥•qv}èðšÅ>pÖuA'þ»¶LÙØÀêUg:@âpŽ‹ß>÷ÕŽÃÔõ$°ƒC{2ôô±ÿ=ÛÒªïFãZ|l&%è*Ξ›˜BÓšvF¸_¼AøÒQ¿ËsîeáÍ]pjRúAq-lÕ)®?·ë(qâ‰€Ä Ÿv¢©u\bg¥TöM·¬Ì]G€õ¦Lû½×¡r>œQæ`()†N(®’î•Ñ_²YFœg¾¢L%Ð…DV­Ûú´¯•ð•¨—K4ã$¼õÌ80«œ>%'=¦TEÿ镸›qü,žïØóûŸ¤ªjiœЕ;ÛAƒ€QÝc¢l&_‡Ýù6ÑoôǼ.za§žÒuX¤&¶T¤»O ³æ�¿Àœõ¾-‘=zs.PL»<ˆ¬Â:,´»‰gMTmHêêIžê³L+÷rS¶€Ä#Ÿ´eØ ãò{Á*ô*gºå< t8ÙP$Õд昿›Z·j”„…¤¿ávï¹°Ãè‡ù¨Æ8%äü÷!R(587!nA´)‚t7)$jÁ}¯ÙzÐÑÌ{óÇþS¹^n"WÄWm ÃT‘e>:ÑÁýï[ªÒ»€åђ䶋W7顆êæÞQVE&Õâ;mÇ'e=x~z£JÉmlµ·þ…öVÌÚˆ¼¶Öz9ûw‡‡ùàÖ¬¯R’2§àÔÕÞÕª(óæ°h“T¨ F¸5)zR•ÜËáLU¦÷+~ú3šºÍä„ôÀºcV0Tš¦¢ OxGY3ëw|ÓÂQÃø8?õiÚ?Ó¸ÁtEÖ$™ÿû*#UÝ«75ÁwöÂKôe.Ä‹G*ÃÏÓ§RÃke0ØËãÙÔ’½EGaù¤Jyõ`Z3ÇåTvL¦³Ë8AÅʼ€+‘ùê­9DÀ¦›=»ùÏÔì8N?zý$VF$3ÒiðÌOÊ5¤ ¼=`áQ !Áþ’VVêê8¨¦Æô°z¦÷Æc�×-º¶móay­ J­„hWd“µƒœ>#Œ˜ÿ÷HT8q4@QMZÐå­Ø¹6’^ :ƽáX3}¹ÓaÞŒ§Ç(ñ¿yÈ}®bs rª�Íâž6p5X¨"/½aÜvÚ±Ò q^\ô C¼ŒÙ‰%Ì�s ÜÕŽ§ /šÎMű§ëoqèg™ô®#äèÏWO-C �–´öhonR(Æùåo-iéKH˾ȂèÓwZÐËfuú—œ}|5 R¸“Ð^ûRÄL–0·ó•qÒúœd:€Æ‹¾(¦ZKÓ‰vJ¾íÎ; Ø–û~ê.ƽù‘Z[”Y­40K~ª=]/:~‡ñËsÃ}úÍãÕ’äº#ÙKkÞ‘‚Ì{}‡Ã¦6#ÄóémÏ7¶5Ýwý"]%ïòNåPY4ª0³º/Z=ñ§~p<³úbä]ѾXðg1°nJꩶЊq½b¯¹Í ·í’Å»BåŒ]ê|ƒ%ç™™'žséÌA¡Æ°­91µåiêm7ÚÂcÏR{U¦ðà|<ÏwúÊ£Jëø@ÎÝÁâ*ÏsÑÄõB6Ùb“I3žYÍ“ñú|4I<yØR°ÀNlk×5$ *?qŽS¯tFëÿDÏÂUóHŽiYM¬ãÛ1~³b–GRÆŽáá_ÕÌn0›™¶DÚŸ=”’[qáÖå?óùÔMÿ`¢vïo@,g�)Ú¸v¹™õ‰!1=öúìÀ8¡À>ŽÎ‘ö¥óÿ”Sò–€Ã(ôûúôUŽ âlÌK ò•ÀÜ)£û7*J*ûl0/¥ ‚iDÙ7nB³¯ÿ¥[à ×¾Íø…êk¶žÊ$¢¢}1¢”–Äšf¯I°ERGÇmÓ°ñµ2 î¦"µ[ãߊ6ªBÐænÜ‚hfkñÍ(óSvè”A8ÍfS_@÷BÝÅÝ-yÓÌô²` %Õ(£8%µ«ôBDàúQVyÃw‚Љ–a7y½fÀúNj�³q÷òyÂ;%¶�à–£%mEÖ[6tZJKÚjt®‘RÆX@ôó|ò·²ëÐ!XþòüîÂñ›L¹¾l)�bIêm[R‰5—­O|Ù“Ø:F6\`·[\¶ž…o®‚Ål×t~B¯D^á®<ßö“"`Ú3¯™Kˆ14섶ÿ‰–‰Äü•—¡ÝL±áå´¤)ÛöVŠüùÃ`†�sÝ$…¸‹KýС!N{£ÎÖ�0†åÀÁ#[J?Šafïë듹—K™Cô‡o£½mhñÔMcw£ö~v q2»‘A3·!ú´*ô­?§t¥ÍäòmŠ-ýo§ÅŸL…üb€b¦GÕÙ‡&(f¯ÂÝÔmk2ÑúYô Ì]‚Zñ#«vètôêþL»Ù„mþÂ2ú›/õÀPÇ›WÜGÒ•§é¡…¯ þ‚¦þ0ÔR2VÝê;ÿ\ø'I¡¦XR>ÌKDÃÉ˨)Óm,ögAOðÖöÖ‚Pí”ëø½ KÙ¦jÝ®ŒÒŽ‚‰Ì±Ý@w5úŒ+Ð\4ï$ÏÖÒ²œéùâI=Y‘FÓE¢»aI´ÔUòå©Hæ¡5*ö|-@ã²R¥‘·/]Îñ†),ŸúëŸâm|ú"ëM^hÄïï:s„"‹aCÉ_`Òµ/M˜ øyy§€<Pÿè¶^>°6fzЇ¡›ÿ�ٺ垨"à®çBUä>§…ÖÚØWTÁ,ža8O •«nMzû@Ïš-ç‚Â[FçÎ3K'ÎÊ0žmEÅ”??ݸ–%žÙ{i³HÏcÒùEï=¼»¿¤¯/°þ…�Q–¯ ÌâªR̪)A·³`6š ²j(Ïàøö²»Šº€É¤@R£v kë­—r±Âg,ΪõLgR/huBrÝýC'1Ö%R•/†U _ÊÛOá�Å7Þt­,ré Ū{¤Úä˜èí+Ó•›M–gsiî þÙAÒž<Ž†¾¢GÚýA«!rƒKIÜécîÛ˜•‹£9 +†Pчò¬=^eé9õm> h«î  ·œ<M^ét韽|Ð{Wn];â=[›mB'ÀdÈcó̌Ұ\©jW—Óžîj[¿m®8÷ïý/'òˆÁ“ÔN»A]ØeÄ]#‰ÿ¯WMiâkÅFÌÕ ÂYr}^roƒ*0íîÈ eQE¾X´œà6˜%x.Ý°ê0d0*>ˆ�ËzÒ÷„šå®™ÉH`¦§­×hëEVÈcÖýÿˆi¸ôÍH«õê3ÀOÜ$#ï½Y¯j©!ÿøƒ,Lâ!–*ÔUsÄM«ÏG>€äl…l¡€w\¢ŸøEGyîK nÙüQÅ PT–´9œ¼ß°ƒÃ·ý¹?ÚŸœ¶è#Iž•*SF…šN`³¬TÆFQëfqÉg¾µA¸ð²‡ŒËØ\Aqˆlƒ·âìþÀ3iûj4¾Wø6ǺœBqî‰Eð<:Ù$¨ô5Üupÿ”ÇbmÅUìyÎazö²8ºeJ¾ Lrª/¬Síq°ÜÕ–-î…„U@<Š¶ï¶PAM,ò3r£O<¹ôÿĬ'uY3[^Ž_ vnm€„´Åî Ò6b%ðT¹¾‰À-`rä'ŸÝÙÍŽn Dt±‚úlˆÝ¼ ÜVÞi…’eþz€Ä„¾ñ—'WòÑ]ÕeÂÓLº}5X»2_ÑY0Zåaóµ7=û­Íå°y;TGþ÷-6Ú$0¨tçÌsDP –Á(«Ì7´JP‡ArÖ2…QSë,¢ÛaÇMY0‚Aw:¡@6<3M’ØoÓD)D¾Ò ùüôîÐÜ[« ®RiÙ¿j=–:ªžŒ9ögàRú‹WñÖ㌑ÂD€ÍË_bG~L¤û Ó½21~è{ʹ–ô;ZAòjîUÒz\?–™_“¢ÿNû YTâ ^`§ºUù0I+O¾ŸÞiÚÑgNæÅ,) á¤(“.BF™Ü¥³T{óoa-§;/”Þ¤²À¤r™©y_<rÝÑæjýñh1‰D,ÕL°®5ðÂgÚ‡q戰‘Ø‘Žt¯ úâ¹!?|Qú Lü§ÿ÷æ7ãÐñœÝgž <ÚT]QF<×¾« å>ý hw)8ÝÕ~<3†Lw»¡?�,¡°ysòÈ\÷ÕÖÄø~¿Õgã ýL+úOlI ™=ûÀ@>©rNŒ jz’´Ñ?l·�³ ì1iqÕ0éSÄÀ=SjœW…JéðØ`˜â,(úÞ+ã¬N„1ýãÃE–‚¬»ÖDÕ=eså"?ØV¢ÚƒQôÞ g;S~ï ¼J~¡÷UfkÑÃe S¢jÔ‹=¼Y–~«q7DÔe§ñ8Ð!'§'å@'$\ʳHTw*7CªÚä¨?†¾q=Y®¨ˆ8zR,ÛŽÝGìëãu¥K‡'›m N@ëÉYÒR^v}=33 •R,½î¦ªëƒK_‡A +ÇU_ó \@××Ã1E°×{I’"*·ŠyÞÙ`‚ g$0å¹áù¶]¬²Èƒ´_<ôేý¾­‚´ýòÀzà5UÈÑÞûþ¸=`·?)Ȩ̈üR<9˜¦j·uGŸ‚¢Fn,Ö#Ý%íÎGs÷’…ÖoÜ~Oˆ.ÉE£ ÇkÚÛ G­¯Éu˜?:ô[îø¢ÄAcE7áHåTÕ6+%Mº9ÌÐP¶Á])Ç[{UZä7™úf¡eÚúªo Åˆ 23¡MZ§ÓrÛ–•¹9ï ÔuèÄ’ h‘µ.‰ùuýb‰0±éÿìë$(?;¯�;L š©Ö€”š èÀ{¹£¨§BUƒÛš‚vþÞZšp‘S«œL%F‰Ê éÿtmÇ}nwõ@..Ü 'Ämg%OP„ ¨qdÇýkª_ш)æ=Œ¿W±'¹±·LÙà6›ÿÕß‹°4Ê@Ö®NgqûÌìÖîR>»«à2SiÙé˜1«ÖM§M__÷œO?z´º‰cl†ðóð”À­gõÑÓ£sÐü%·^­Ôž)Z(_sù†U}´´»'‚àx§UCñ­Uvøñ•ßxÑ"3ß‹ŒužI¢šˆöÀºï=„Š,ºß³I³Lw¢Gòú…‡>O–„ÒZŸ“ewƒ˜¦%ø¾3ó*öbüǵ§»Þ’¤]w:\)¹ÐN§gm‚vĵ8JÌû󲨌âïvz–û¢c¬B‰xûåA,OÓôÔÿ" ‰ð¦*ÒUA²«Í釬z¬?ØÉÁ‚¥å\ú¹ø‹ã•yHÙ³íNcAÌ æ¦”ɆèS¤‰ ÁËÉ{”…~B à=MÒÝ¿NÛ‡ÿ+ƒöŒ¡=Àràítž(_5±ý-Κ=Eʤ·Èüa°¯´_¹G 3yâã×¥,œw–ø~Qù—žf§ÅuìvµÅâ¿; LÁzTïEYz£§t¤Œ£ZO’ÈÔ¿æ]Ï“Ø´{ã¹>uìùÙ¢Øg{ºó_š<W<‰µ¿@é,ˆ/ôû«"»ÝwÛj×hL WŠ_磄G*.¢¿ìTáýrPQ˜Pêá90V>ÌÝoõ pÇWëÄ,µ¬í$Þ1”ãqÀDu?»~;UÍÖ\…2hŠ$ÈYî‚A|nÕ „FZE€oÈ[L¬ºý‹gxç°¸14C?]ÎÇþï<¬•Ö_´ðýŽGat’?([+œðL¢ºçc/ƒuø…tRúƒžÑCÝÇb” QµÛm=Ñž¾^èë§ýµ½nºÃty²ï’([É>¢5’†Aj•G*W‰j­WY þ$"í?zá…±'R ÇÖÜz”¥‚Uœßº¯e:Ï ÒZ:ir9_Wyâˆíç…8à*5ÄQa­Ø1H<˹µyÉo+y¸’p'c‚ ‹/l�ÛöŠâÐ œæ8*}Qi*2NÅ’l:¹0u¼}N•+÷kãÀ’«fðW`4 ®Úö$MjM_ºu0€ß&>ÖJ"ŠŒNy‚ÒªæÄ€¯ø*Ì HZÎô]°^¨ÝT‰ƒ%Z1Å+«+‹šzÇcJzZèwžê3}û3;YþE³3WBhIÐ.PÓÕ4A2 ½¦EÉž`Ýü¦žø‹bj£ÔjXww|…׶Âaýü$ˆ÷ƒB±“ô<¬åxL,hä_>Èäã•ÉW‰0íÊ ´·f¼ íà&7Hv’•8ómôæÇÐ1ž+“ó¶Ûg*j䜄 tRŒ×Däò©ñ L›{¿£0¸û4û”óBgDå¦ô¾íÕ÷ŒÉsÒŠ’Ö¼)ù–Ù –_G°R8ªœ.°B&€Ùo·¯çÍ~{¯þ5ˆÈyØL¤K(A§ˆ[km^%øÜŠVÚŒ§ö†™3Û×µø³ßyÌùy^1à²dNeR�öõZuë.­èÉ+ì4ú&y"iÜ):Úqù¢»-ñp26S}Tá*~¦g 2´Gëÿh¨U›«æœ1ÔÍfà”ëÓª\”ÈþÆ w ÑC»f¢ˆ1HáòÓ?™ÌÓ™›—pë*èÞÙƒ²§n Û)ú4´ç<s.gÒåêFˆÒBÚ ™Ö.Þ°‡ÒØÑzÝÜŸvß|[gPR:1ÏÐêøWÇÅ8ÐhespµªçßœÕïж.V`7{Ï‘‹Xï¦3þ½åŸÐ1U<<Â’/)=ò‡œÓî08V~°Žÿ$W›Ê¯U®¬ÝHdà+Š4‰µkJ*àƒŒgðýdaþ,–f®M›n~¤õ»gdr¬¯.ÞÜ*Öè«‚üó•ÃWB»r΃ÐÊZDl^EÙ‚X[þª„¥ÏK…¯ìLÃÖ¹û—~Í¿ |{ bÖc—GÌc¿™¹ˆí`‰éd™11_8ÇSü+Ô mæESÌ�7ˆ(û°ÑÀÆ“{WŽÛé~Üed!Ϊݚ¤BŒ“i¾É„ñ©úfänD(€:@[:;Êvë óÉ�"_ëˆù²�}åÃnÏX~¾'žù¢ûºò<«‘ˆmÑÔåÿ DL‘–³™-p2ª/Òìéë[é§üVùu:‚Vø¥°!¸1Ug®YGn/^ƒŒ—R8 TÄ“jÓ@¤]?šÊ–§¯øã>ì¥*²Õ8¼a.½÷@ ÿäòQÄ%î6ï+M&qæKÆÒ~e;­dP_;Ö"®Å Ö¸#_ZöÂyÑGËÇͲªÞ°£¥Ò èéü×gx‚ÙÜ’'~—zšÇÓ‹rä…³§mµÓÑ XAZ�ð2q«§Ž'n7¯kMìÒÃmª‚b¯©y^ZyOÇè…k:lB0’IÊœæÆÚ,#—<ÖVt‹Ixæœ�Ë~o⇭¹ÄïGpæǶ嬌–X ŠB­øÝŸë2² mî »Éújg)…Á“p—OT‡H1lZå‡V†Z\Ÿ¬„¥ŸÂ³PËa‡<Ï"±8›{ÔOCÒ WÀUü<ƒí5 {«‘¶/‡?®i]àcÙ¼<Ö_´ãÒƒÉl÷µg©BãLtœLP±àšP6QU$ΉòÆðÆÂ/R溼qShqfÐ×?q[šñEÇ…«¨ThdqñçälpgßhËìÇYºqÞAôªmŸäsa雡'¼ÀŸ|Pâ<t»þðo eˆ7:‡ç˜ÑvÈå•tSèÝkN£È=fŸµA¼DņËùÝ›Ì6$ b•™:ïñ¥Ç¡)½H„'Ê­Šdhï!VC§±óì‹(Ž|Wà¹{{Þ{ƒ|îKlTÿm7ÖòÀxÈfbú“[X1 TÆÔg0+FeBb˜ìwŒî˳—¨!Ù¤D›ýÁ Öïˆs%±G´ŠXWþ˜i³un®’k!3R‡Ó×q6J˜p@ù©DWä=ã”m+Xbòýâ@G@oÞ6g¸öÙ8C¡ks>=ž¼±ÑòáÞ$¦áb¿h0àî1ÒUëŸz°F›æÇ'­MuóSӸℋÞŒ×krÛ³¿ªÁùPÜ2‹åozF¥33’ DÙOó2šžK®”l–=²þÛuî[ÑÐoäQEK©lJ'WëÑyο¡/iJ:Q$Bæ¦Ûì¹; lX3}£ov~¤‘*b#x&5q/{´5@ãWÓ4ˆñ³U½zƒ½%ƒÓ¥{ô·è`$.%,æF_#éÕžSKU¬¶¯é„›ßL×Á”5/"ü|.ã©Ð⪛_¥oÿ¼UwdFl„2SÛ¿@:[nK$HçPÀI¥5œAš ›Gø?R°†ùÏà$+‚~SÅ-^ ‡’ÏÁÓD7 'á3³ãÐ^°½¦ó®ã&ÐacM·3œ<ôu}àºKÄÆ8¶“aGŒRmtwñî)[AR©ºÛÆ ¤´‰¡–á&ó/o§Þóf=Ò�“½Bƒ’"pÚ%Ìnƒ<O˜õ¹7õ l(Bžvÿþì9çð×gËzîö nU >ôîp´âÄÞÛ•  èÕX“ry ¬È•(1Ú1¤±§÷ÜŠûö7áª$ó„æâ‚’kº¿ç^Gcâ%ÔÏ«bOz c/Þvæ5à®j̼I¿+u|é°Òž-'Å+„žæuóë)oá‰Îqâ3íèŸï¦<C×i¤’wÀ½š™!wOèè•>Øo ¡\µÍÃ`Ð塀÷ýÜjs¾ú]+©ëÖÕý¿õü…¤¡€_DµTÒmÜÁÔmp¬äæ^d®;Ï™ø>‰ƒ 2†é ›#å9׫ŽªYTõ Å—cݳ­¡¼Ø–a²R÷bt 2”®,,Øè+-tQßW-J 7GPAœ;,�¯Þ o>·"Hc^¿Û«æ¥£²ôëü‘P1¶xÓ؆ÙÁŠîá•~@.ΙN¦õw)-º´m£ɿᛊËOr.q­ôý Ѳ è?EU²ý])'$å‰ @“2ߌõ‡å9~t¨ž¹¯D9KªÈ\¸“³ÖÖosáôV¼ÞØq·÷zØýái¦«ßàüdêq¶˜§ gõþå¶ R.¿Óü¢½CX%Æ>}C7ªw^ûFªÊ™Y<½²i^dN¤–îíÇi–«& b¢A Jo5c0à°×ÿò;?w"4¬1°|Òxÿ²~<QJMWÅ<M$Álj’ò«ÿºR†‹,ýJøú)TÜèçvç!’ òIÆF×n¤ï­/EÊ’"¼q<!H”ÝbN0@—Y=^©ÈAw4 Ó¹yÇ´ˆLœ@‡8m-dq‡nÌÕµž ¡¤z0å¦}À´¦²UeŒùË*й*ή»ö3˜­¨|w(]Žtì:/5ç^¬œÕ:;{:J£[lì@8­wίÀ¸9Z{4ۄꆩ#¥7>R1^.žÓ(ࢾnã/¤‚œï·J �7”½_QÍH,âuÀ¦W¬»ÖÌ^ø>!B»sTÎúZ>â‹@ܬj#Õ‰þ²`ôPzŠP§Ñg~šçE}¾»4ƒ+T•„¢@/ÉõËç“Z¡dF­½íY:9±O=s úê•äαC£~“$ˆ-{µù‘R)HJ÷ò§kÛýè¡á f‰xqDûYçþtp|P§Š`½-ŸyaW…í[GÜZj¦,ˆ&í¿ExÓMOe‘¸ñ¦é¤Jo¡<EèeY T|åAâÄÍ)†œ‡ƒK4–éÀ}Ý.ì–bŒÇB qèfˆ)[Ó“ =S`1e¤ÎÖIÍÏrýXsGÞÀ¯ a¡Û3ìm®±Öõ´Kç§$F€5fÊ6bö0Y…=l‘4kñ—0$[@ÉnNk@ÍW·ž¿(Ÿ9^`š–æîëŸêé<ܺšøM~ÆÂå1ŸZUGobC¡Õæ|Ðås¹íjFÖ¼Æ4®"§*ÁB½ÓÅåä³ÍÄXsÆ®¥“‰Â›ñd¤M6S}1ÈeýOÏ>v~†“µ¦ª”‹'É™,ª™ªb¶pøeù)òN^sŒFQ'}<°­õ×ñ,cPA[‚©™Ú“–ß%úV~ƒç±Ø§.¦MÑ+ÆLÍŒ›ŠiR{ 1Gq~lFÿå¦S‘”N.Ÿâ‡6v5/ž&ù|ÝÔø8ÿøèà>'êïW÷ªÁ ÀlŠÓ#ìÅN:¦‰`¥hó‹â%XºWàõo¾Á³š¢TCû®:]-�8­Qâ�÷.³ cÇ –#Å…»]j ±Ðï¥õº¹]™”¥Y§¨›Ì{bØØð l&i/u?4žyËÃ×É Ð©Úr½±çX‡˜-¥…P‚:#kcˆ<Ù+gœš†ßiJ)ÍVj‹«‰ù£SŸbá,»<I‘"šÕšµFi¥‰ƒ1"u×S5~ò„ ÿt{�>ÑTò5Œ‹ÂC3…´ oÄ š›š”‰„~îˆãØ íá´Â±§Þ›0aeó'Fåº÷Ô‡zîÔ+ì™[²M8Bf‡ÐŽ¦"—ËŠ…Ö¹1ÿ­ê�7Ýnè¼jø'NÛŽ8¹ÙŸÃŸâƒN(8‚úÌx„OÕ¡î\ñK#K³uu.DeÖ>/P|IwF$|¿x°”m ‚Â_÷…ñG»õ±n”#é@nÎtfÈç]~7cNc7ÚàÞ|Ÿ€ì|ñ@Õt*Sºt°³ ¬]Š°öõ>²"=«EƸ/uÉ:ÉN…¢þåjÇ•Hi讪ÁîÍsG¹êˆÕúS´‰Q|0¼šöÞÔÿ‘©B=jèÃ]]”7Íž]`碸ѥtˆµ©áè.[{:£kM¦½øÙ )ròrØ@U/·dfö3Á)o'0?K9|Bf4玘 eÓày™óÈc‡–~ïÊ2¼c@¥Y %Šî_e\uv¾¢í«šõ‰'ùÆ»1VÙû»kòó™Ð$˜¶Ö‡U=ÒÀb%Ï*3æˆÌào0)ùÒPa8‹ zôþG~òé ZCÕBéý÷5 ¬]OˆPG˜•×â<€Øb¹†ƒâÐí)Qʬ‘’‚Ë6 Ò­¥¶p÷£û‚Lm=}>LêîGù.M8ãÐ0%/[”ÓV;G"F§o‡AȇÁ1Ú×þŽ;Z§¥O 1& E£3`tDºÞd|´h‡šE…~eŸç©¶]T‘%>©ÃóSD×ù¿oêÞ`Â’ýµw?ÊûÂó1k(°è{3{ÌdêÛiDly¡^x€úLØeU¼OÀeK1—]A•Ï²Û+aô^,4] ›–Ñ$Û¶5÷&r%3¸/·®ªã Kõïr§³X$¾h3…–KMo½ÿò$w)ɦÚÖ³kè™—ÏÛüKcUy÷+ÈñºDGd:Rîת?DÉ¢¾ÞdGgM-qªÚù×À®ŠïïÈÄÂ>DQ:æôÞ¶¥–IÃîèƒú·×ûk¤0Æ–ë>~AÙÁPq‰¾<"Ú•Žz|é‡Lx¤ù”¯ê]Â]ª ÜŸT@éd“zÈib¦™m%³Wd·ÇmV°GÑa\†4¨:ëR0uÖ–±ñ²> tO¨°PCèlóðI'm:� ý–?õù‹ 7JÐ/¿kì¤<½ Ì¥q²°µ*(±éë\ïÓ¸Fh²žåæÞ˜‚“ËMCï=+J 6ŒGª£Ù®Õ`˜Æso KÆfÍd àÕûƒ­h݇@6Ð䙵¼èÏLmÏF/ý¯„ ªÂ¡ ƒoPjà˜§û(@¯0Š™vŠ ÏݶB5³½"|èDÁàÈàÎLF”pÀ¼wåV)Rˆ”Á»[LU­\ÆØÝ–¥å¬¶scDýÈn;Õ›åÙÁkXŠÍì¾’˜¶ƒõ²*VVÕî‘QÀÎœ(SIì>ͶŽ½¢$Î#Zrý<štåïN±$vG¡¶îè½ØÔ‰Ñçù�ÄD*˜ÜÂpÆò¿\òÒ­�0Ý CR®¼èè+uqÚi‚ 7%�,<ª¸²Ó¸°TÝ-Î…fÀÛï@k¿4„vÄ™âÑypd+^ó‘þÇ#Týªœx6>Ü1úü‰5qgü¨ð8Q6#4Ý8˜;'ª{.蹇e`cO†#¦½`l‚~m=/·£¨£ Ÿï:óÉs ns†Æ|ùuñJ-y žãßÅø\°%ð  ö§ip¤š!´Êú)K,ñM{Š•Þ4¼÷¬ÝS¦.UAyH %æLQî@Ýbñ` ¢yLœÍÑ)Ã}rä@zªjÛÆ2´Œ»šÌ¤Ì±æjVÏ5ÑF¤üb`‹çíϧ”9Á3¥Ú^=Q‹ãˆe¹cÉ#Ï‚ùѵP,X4À´&k£[xyÎE·úœ!<b:ž¦±×Š\C·ª—Yö(tšÞ¤6 }‹ü}qdÔZ`P[SU*÷¸»y]µ¯*—4 óy.ƒb±S5ø,¿c†ý¶Ã²Xq!Kðý[Š^™G ¢È¶�d5·®ï'_EÀt(�øsé“i4ñp¥ŠmcâwÆå:'“&hwýÇ,`sÁÍbtê©Od¬RÜЪʬa(nÜ¿(L,ÛpqX ‡M0±?˜&iæÓ§Bö`J‚b¸ºç´9ÌNÙúEߥ(tžÃÒ¾ÔtL—_g3à3Hí¤çE4JÝÕ±Þl \Ê[Ýjð–—°Hö}ÖºwͶ-OFÌ{ëaõýâþafY ¸Þ+ÅØËEËÌ8ð ‘ )=·j ñ#œºî:ßû+ÐeoÛ¼ÅÊË£`eñì¤îqúÎé!6èVB|n á@ÜÈ?”·]³(5à{4/¢Nͪ nÑêÔÈèzϨ1‘5ŒŒøÄŽuÚöƒg:F ~Xè­­܆YmüD~옥V�?7Ý€[â½RZ•æ‡-°¼ÝÑSgù ×âëÿ¥, 4¡qÔiG (¬ÚŽ¢1”ƒ*Ò]îQuíÄ]‹{^±¹C‹°ûoÓÒgÏš³WêìkôY¡›¯ì>Óèz¡ãå¨lWMñn³¥Ó t þìoúítEx¦ )Ú雞r¨W¥Ó“4öMÎh¡Ê8¥ëЀ§',$ú‹AJ¤8LáÁ'h¡õ~ÓÔ–¡hÉÊ]÷!¬à̬N&º[˜sRfk¯#tè£Æ’˜K=’þ¦GŸV¡Ï¶ ‹àc‰¡´u¼³šª’3¢jîLõŒ×»ž®I¬X¸ùJ)EbËdÌo8Ú”T6èîŒ3ÖÉ3?¿r-7VÐwJ°,kG¡ûüïÁR©öe!0 WâU÷…g]낧/`ù€#u–ChÜÇíÕçõäâÛ ‚01FÀ)::{O£W.-7.Š:½¾¬yzJ/èÅŸ•ÖgTnnñã[ƒ‹~èåž5\, ÈE~êCĺëÀ6»‹¼ü ®“3É+a¿™2¾Èت*¢|‚x>fö3 ÔÈØiÁ¹^2ÂŒ’ÉÞó2öô9”æ~ëZñ8¹¼GaÐîó µÌÍQÚ/fà ’_û"Y¬_L«ÞaŒþ€©Üì-|Oƒç—Ä9çÁ^}‰æ¶;¡k²íصÒBŸ _…æ†,ÑvY¤€n³PJ”Âxi°à"Ÿû˜8™£Ò43´öÞuKfL§îN{«üzJ|‹0¤dÃÄwS e]4"o©;r9O—óÕ?u2¬oJbðtýuºæ/¸›˜t‰î–×±RöŒæLÓÿÆH>rÓ5#¯–íÝAá8i43sîùö‚3[£³¶}x ¾T¸(„#e[˜†QÒo°ç!Ïh�4“ÁºŒ¹Tuã Ÿÿ£§|ŠACŒŽöëΣ»œ¦q>u‹‘V¡G¯>ñP¼°ÀlK’ Z´…³±Ê.:]EÙìxê¾D긘Ûæ³Ü^¦¼eIec ê`Ò‡Ú~zd|º ºBº»©{�}^ÒiÌ”•‘v¦ì…¯b¾5îÂPTÕ8 çåTí…H”ub õ á ŠXV_Õ4{Ÿ½“mi]èŸWK¼ùŠÄ´µÓ@ <FºTÁ©ö_\²’†Y‘9#r„€2(/;8¥ ¦òš p9´û2ò‹éÚ™ô.iÃ÷f«M එÆ%sïÛùÞ»Z›>ºïŸcUÒá@Ф³bîÖJRif‰ŽÑ�V­ù>þò¸ˆÒØHÜÆÙŸ*¶hR¡ÒþLëHLº«-—Y¥ëͨ«LoóL‹åŽŸ„ÐŽÐ2Qȯg—yz‰Ú…ª†ÊQ q9w š2óNîOpfƒéÐv 9ëç<ÀšLÿÕQ„ D¬ lOý‘XPT'¤‹%L»ß°ÎmÆX™º÷4Ñ'}¿zê·ž`”Ê(ZK_Wå{œUqæ4Y5‡R¢ídö½ 4³ª­ôŠ_:Pé^T¶1'J—™Vãø¹ïM—fwÞJ>?ŒË›Nw[3 à_[p1 ¨¿ê8ƒ[�ÒDÜAÏff{s¾Â‰­)@ßLJ.íë0Ÿ(µù™?:(Î ý gèrãSÄã½b‹¸”¨¶dänÌm—øa·8 C_ö?âN˜å³”+ ܳoY€qÏé$m¯{¼ÈAã¼y0ô*O~Gφ›m|^jWײ½ý±ðzDœ†~@a( 6£%—‘m k]kàöõqF^ÆeaÐ4 wT\ßM›Sœ#T– 1ºô¶*q[ÿWÅR•‡‡•Â;Ë]äýà5bxv½ìÇáꪻ—’õheºB§Éø• ×¥ª‚5êúrX†Î8Ã>~‘‚ÿŒ:f?ä˜æ<øÙûJ¤8L%¤Ø΂Z¿S”L™o°?§An™àP.aÒ㡶Š‰ÿ“fºe?Æ §§0;ŸÍžž®-¬{r-?Jû² “'roèNÇ$Ⱦ”®È”¯³ƒMSRö²4®¡ÎI©ºÑGi{—:é(#?³¦ƒþ°«‚¼Uj¨q6Ö¼‰ÏRqÅáÃæÆN¹æÃQV hzi±™)KMÂ4ëž·«ñ8ž>îOö27ö?&ãi­Ü'TÛ¢ cG¶ªLú£á¸Õ 6î3Y0ƒ[~]´[•ó~ÝNŠ~ ð¼¡~p}S€âèG[ø]&Á kØ6B…ì)žâS7æ0×î·‹ß 2w»ã,S0,“ã jòõÕóké[BR ”¾Ô¢”GäðÌ+0Tæ†óyËÜ!œ‹¹U9í YëÿcàÖ©‚/üŠí4»;xéXUL"1Ǭ- ÒOeÌSè0È°‚÷(@0„éaÿruBzœ_V÷‡‰&-ÝCóí®¯|ÿ³CefÉt†áVU{Øn¿½Bl¸Zw'(8AòuRÍ’‹^ú˜JØ×ÒŠw÷䱧^-%T7ÐW°vñyó¹z±s‰Îöh%YŒ³¢• iž”x4‡þ§VŸ™šNàek?ç7&ÇjGá‘oKA Àì:צwz÷ƒÍé¿Z,èyý£P‡no“í‘Éô¼€‡n}zóÚMÍCs›pTBŸfö®¾áNS7"‹ÝS‘ –r¾Û�1Y“Ãî;zÈT9¼…‹ýùøíËbEpÊ¡žQÙd%ÈÅŠ2ÝhøÛyc<E_Y”hO¡k×ÓBAÒÌÿWŠ b½¨áÖ{íqC`<VÄk@K áŸ$(Ú³22:M×9ųþ¡Æ�C„BÏŽ9rŸšÇš’í.H§Ï²KLô¼~©Þ]e+ë©u¯Ãæä¹Q,‘H`â�ÞÄÖûG•k«ˆeż›ßmï!֜̎í©ÜÿËÞV‘õ¶bç�è¡d­6Bࡵ/˜ jÍùpØøˆî‡ÂvYœy^…kÐÉuþòBÒ>XÔq£ë±#½Vû¡ïýôKæ ÊPªÀvÇi·ó”æy ï„‚þÆé8‹WÏÃ�‚ÃEÁÒ[Zï£÷x0 <ÅXén°VóE½mŠýZOç\l‡V1¾â<WA¼ŸUNµpë³Üu^w–딈θG?ƒ¶r£<Ó£§úòR`‹Ø1¢?w’Ñ»Á‰Û¡˜Õ† ÀOÞµO™„ óà·Â‘.c4ê|ác<aµÖ(bNƒØ*=‚5vóø_­ë+Œâ ý¼*¨lÚ…&ái¤âCd`è?•Y­½x,¡ áó�±þ)ÂqJÎy¨„OÎï}ª;†8Û‹‡BÒ9¡0~i#ço³»VHD 5|Peü³<+\£>%ZüE¯‘Y î{k›còY|¿‘M¶2äQnDŠèkPEÙµŽ›EY6ëøp™Æ/<Cú^ e?|Ÿt%‰ÍBpØœ¶I7…;A¢œ¥øI9ÈR¶ Ãõæ(Ѳ5@TxNrÊmÆKsX¨©ÙEƼ÷~ìùvÜÐiª¶ó¨ÚΨ”×®¸´ƒ  ÌZósq÷]f3HS®ÜÖ5³ÙÎë#È|’e^ãŒÂéf¤Àgë1`w`~3Ь<ÕËÒêQ™Ü4wNc$Ó²#Õ°Þ! ÑaÓÌX·¦„µñ ,«ÒËc£u‰ÎAÚ¨ªÌoX»6Lhò†°Ø³7 ­‡vù‘-â§;^gb´ã)îúŒN:ª=ýT·-\É�sz¦:_ÞX§ÃoYÐØß…þ/5NrG9ãÓq8Auúôò”cÝÍ{ªK¯ô“ằ›vˆEµqà'o¹þÉ”¤ŸÁ¨ñÍ‘~Á¶U}™ÜÈ·5rGÍ·š Ót ï^Yìlá5KÖÚ§´ÞÏg¯uE¥/Ë= Åt–`—׋¢‘QѼ·B3¸ï‡©~] #^YXÃnJRÏ>Kä±ÜÃŽqx,o20@e«òv0%#eº£Ð<ŠkÕ_žl>O5,¤ù¯õ"c¿`«IÐí6¥X½³¹é»®W~‡O¹ƒ@èqŠãöÒxf_¨oŒÜÿÄkÛL±ñbî¡ã˜ž¶n¾!äyVÿ3“\0kÐ)ÿÿ³ö&Û­ëJ¶h›ùîÝÎÙ9XMR¤ ›¢d’Z²öxÿÿ/f�U{¼#¯E{-Ë$ˆbó‹¿Ã>ÙÔ`…Æ-”ð-ÌPdœïý”ŽM±¡eÁM®‡BQYù:žì®IUר㓂ÙYýéËI†¾Ô[D¸°AÑCËØ9Á}@Œïdúî¼›îª4%eìÓÕn×ú²à\ƒÆ8æ.F=è®7ÃeIî=Ù¸ùM_Q£Tä2n~œÍ fŸ;>äñ¯GÇÄ掹‘ÛÖ%Õþg¯LßÃàTE»v#=;óúЪÕöh_Cqm{±Ú-F$n­D»{â‘XV^Äþ�jY�šUëožÈX|ó©¡}í6î~_£Þs¬`¶3å/T nµß2ïŽG.oè`§bÅù ±ÁT¶ªœûÀÂ#+³ó‰I'ó ´Âˆ¬_«%Tù‚ÈýöŠ+ÚPçß3ìœk_ô´Â3gSò‚ÖöÒ=køûX½,v§"ËAP\ª‚ÂÚŸªWïF'çVËÖ{ŽœÄ„]TÄAÕ(5B,ÅÐñ;` â"vÍÈ»M$ÓèIÇnì6,ú®gK”ªc0“èÁöƒU›ºaȦ!ð1k*_ÍçïüÄ»¼‘g±ÎKÖ¬du†{¬õj«X[ˆþk^Hñ�C:C0žáÕw· L¬ýG«´ÑŽøþø•ŽëàÏŬcP®=|Z[,]N<Mj_ï'G[K\[P—í�.+TGÆåæ AqçÎz&û‰>…ðàøt\Ô ~îÝ.£+ž£¶¢£f«ST°v ÞÝŸ““Á£•øJx,ñ ºLLØéQ—]ãE¤á€™öêSÎC®Z–“•7REV½RÁØç–Þúòí ‹9Uß…»Ø¤}¡ó']ʧ:q”dž…$L4ù*û¬ÑqÌÙ‘Îî¥~°gÝVÛÐÐÂNŸFÀÔGcÜø|FÞÁ"=ìcmmµ(èÈ%~gcç¢Ò½IšäsòÖГ2šñZx*\{UÕjʪòœd"iœÇÖI|Ýs={çü¿®sþ¿¯›èqZ¹Ó¹b²ñ¡BK6†Y÷÷ 9†ŽáYA s~T^¡IuRË,v[qæžY=§½Ã™2™­Žw¬yºÛ¾–8ruLÓñ†¡Æm¶”T¾˜æû¢Š"éþ·c}Á5Xz«Ãa6 ‚‡…=[3´®Œ$í0ÐYUŽÚ€Øɺ¿¬ `9´”r£Ê_ïù„¥×v§t=ãÖ*ÓiˆFÍn¸*ž] áسΨøDçFç[™ôà¿üÓïÉ÷¤…o.J»fÅöcç­m£xcæh¬Ìeêùõ’HCO¶RÈÚ¬òk•1m¸÷~¨‡ç =¨_[^X³$1© ßÕ^àNШår,8T/¸ÛÓûíöp»Øµp°2톇¼„*ó•'Qh@ ¶¢îñÇ?ì¿,Þ†P¼¯“–>%JÇ3ä!-÷CÆƘmð@ô©Ù­™¥Ó…R]‡T S ø¾x`�Ž&C“2÷£ÝñlzùÝ=‹ødñ `jφa›):f‡¹{Ï8!Ë|n)Ú»>öäí¤3ö¦¸mžÓð^ºÍ=ûΣë3(x„|Zò »¿QB~¶f®D¥í.¬«Ya̤^¡ u®Á…Œ0<X1gˆ*Èá"`ÒÛŒ§µü Ð4ñ `9*¸UÃ4­ÙMoÛÃfÓǽ`}’BúלË8×,ª0Bë=ßÍ¿†™¡ß0n¨pèý¤“Ñqß\^L/âÜv>ÅÝp¢ý¹Ve¾2CÝQ¥üîòx¦©¾Ë‘”AR7šÝˆ§Žã Ëé 0²c<\ê~Áç´‰Ö 1ëi5cý­Î#\³Î» ^1«š§ ‘ IfåØÜÌ–évãy ! ›¶‡ƒÅà©UÆkËŒ(.2_j ì&”“ËóÀèá–÷gg{"WëÏ¿uX89€N"%ž­ŽZÂj¾£×¸ÀJ‚ÎLVᯬØú!±áÎO<y[î, WÒ–AÕ;½‘<ð‡Í6ƒyŸÜ§Y’ƶÍ*Û9âµZ_p™Ö±Ò)äF8‰¹ê]SĪ‡ØOchÞoÿ,ç÷”å¯æÌx|©š ©87µ ö‡2Ch [Eiécl(Hn[ú{ŒÂ•xÑ©}á ÅÛö„ÏÀ´ß<ÑèòDêeÀ½G‰Õ¨r„ßc¬4$áþ̆.ý¦³Fyx�Ä»àð“bBÖy\H«Þ$¿F²=¸æagÈÌå58µ¼>·GÊü*+ Ò¨Þ;Õ±iÉÝw~”õ焽Mõ[°{ZÄÙ¢‘ØlcŠ#k[ŸæžnŽgW1áÃ^<`y$^…s†e`'9ó}b/JàNÆAÑ;l\AY‰ŸäßÚYXoq`EU7ı4IÎ °åÔOÆ‚žîàðì'¦Ww˜©aæSÙª‚ìÇâaÕ×Ð#ë&y`²î¯%ñ*-®Bƒ ;Óé^ö?¦‘û]=ïæ)½# … $ Š ‡ÔXÞšŽmŒ2;ý§œ‹{.ÛôÏ?�.ÜsÙ®b¿œ¦ ƒ–t­I?ÚjPH®ÕckÞóÕ„5[Ø¡²½ã§7†æ‘‰©†ÌþÝ/Õ³¢4Ë<þ+( ™kex!™;Ö³çoþÞ ŸÅ¾N ôµ›H² ?ˆá´Œk†=a¢-€°§Z QšÛ>ÎÊ­À ˜¬N'bNb6§]/Ƚ+›§Vº2£kÚ7n"N7Ö‘ŒÞÂÖùª”Wkèÿ'5A‰îŽ¬ißø­ý‘/ºBv’ÄPg•…shá,ú½À=lóáøßôÏ,Á«2Èê#ÜsK볘ǵA÷J׶ûž·ì‰œÏþñh@IåÓ!1Ìêè ZwžÎŽÁLóÜÌvCï^¡vªœBU"hUé\Q ›]·êÓe¢¨‚¾ÏkÈpjJX˜@¸§›qü׳ÞªÓâ_H�&>•„càt�^p=›IèYÙ$†ÑªÓ'Õ0èÿzÑÃ$ŽÑ8wO¡È=UqÐ¥ßsìéï°c¾,W¾á…lø+MÇ^I F©gÂúhUÜ‘€PbŒ]Oñ’¾ý¬žx ©Ä{Ÿ´žàó¾Þ Îf”'"bk‘:§ik&*wÂzT8!¨”¨ØÏÝÎÈqÆÃjÛÖÖbb«Jy—óeè ±´{§ÎwŽ>)°uÅç¨ê?•š*e¾œô†Ë+*Œtc<Á4Ðà$+ˆé£ÌnìÑ4më3eÖ;it]½¢€K|õù0fÕò¬S h,ýé™}ÆÕ¶WŽaå¿É™1îšf B§•¦Î|ƒÅÃz¸Ì8çt<SœýNKªç%×;_äÀ=®¼–¡,×16ʾ’¸¿xCzZo:¾S@èÕ­Åc¡T9›z£æ%?µ¶Ì§ƒ…%ýÕeoU"1ÈEß<ä¹ßuå‘8ØáümíѸly`ˆ°:n€«µ[~wuĤ!U‹ÍÅrÛSTß¾OYRÎÛÿ;­2uÙ0SÅÊ:ÊVT Âäa©\”Ä˿™žî\®Õþ‰¸ã£.¬éüéYNlG9;Jü30vZ-$žÒ`>ƒ£2;_ÛYÜÖƒD´uÇj” ž(Á¼7J·z#L’í\ÑAïcêÌ)fÓ2DI]¦×¸êÒÓ ä0¹9ÁPúç_oÙ„Ã~×w$Y/x1<¯R×ÉaÊfKŸ­8©šö*Å «‡®Ó½¯˜¬¤>Þ8m]crQ@CO%ªß¸ïé^öûõw÷qQ'Iæ»ÈF°}¡oI¸­hôˆ¯œ«¢$r ^RÛwåUñ “cÓA7ô6ÿ<B7q/œXÓãü;DPêóiµ]$MãÉ*SF R…Ú¤Ú¹G%/Å>boψ˜}ß%Aüi­KáÿN²¡í¬h4—5}†ãÍ»ôJ1žºì…è,¼å¤`[Odþ}µí<õ%{)S†p`eõ/bð÷íÿ*ˆEEa¯ˆÔ +2TÐ5õ»ñÜ$ iFÑÀ©.¾½3·J}§u.ÝÆ Å͵Êλ– Ç‘Ç ! Xñ•2ÿjÕ5xQÌ왺oUäÀSë;òè‘Œ‰}÷gáû<Q÷Sö2wù ›1maìÛk~‚÷ÞãLf3båÈð áÞ•2ËÎ… KØÍ~¶ÿzŸÓöÐpg_†êHw:½oæn·1G¿4Äêy*Î3�— lŽÍ|­ÝO°ûsY4ûøˆÔo1¾ãÔTAne!ñ¹µ…ØñaaBžñtB¢(t~ñp¦=$YÀéÇüʧ|¥gíÅ~4ÃÈNÅVƒ®M×›a(*$íÍ?4P‰)Ï¥#ÌSõïát£Vl@ÉÛŽ”¹}1ßÔ\ˆ®ÉÁ o#JâÕ3nè"éV½òHD¥œ?÷où"Q©½zñÊè ò"¨¦O§Mx–.ºyÊ€õ˜®í{D^:ï\îp°”Hecm$¥6´ø½pˆç9‰½ÌJñ9˜SJô vÜ8u¶<¬>_X)rù¾ÞvQ³ì ÷=Q ö6‹§r:rf&¿Š‚ŽmÖÝL4ޓ注™Ü¸Ñ÷PÌ­€>Ò»Õ®ÿÀaÜ´[7HÇ-W¯êDfJô†_s$bE´[!éj)=sá¦z—ï¯Z^š;eÉP«©DŽÕµúW)šxƒ>Ö“;Ž½—ERÅ„ykƒŠÁ3-“¤Ê|ePzÌÇžbnR{P>¨‡“®.Z ó©½Í¡Ýï†û]¢øZÂp8Ó»µ¬hì†EWí•i§ZÓO£ðù¯wòŒN¸ìø7‚±ouË–¬”·G+º”ÒwZ[”çs‰¤ÌCm°Zg€46íÀ üP²ýÙï<Ö½.Ÿ¢Á-ÝËÓ§gËzë ÿ¶Ò¨,ï¬/¯•¨ã$ôÝøà˾‡ãéâ)]N B±Ì‹šn�š7ö‚-3|½Lzú¼qGOjÌ,taü½~vî¬ñX:#ØaV6Þ<x ÚºfÙ¢ŸÛî¦é±÷º¶0¢MDô®ª/n'ª‰¯s÷|BgEïE©$fåOŠò–*ÉnD}brw�!EAÿ!¶ÆzʉXd\´¬sKu‡ÑzG覾Ї>Ó¶hÇšî0ò2ï‹s‹ˆRÓ‚ Õ”Ÿ:3)È%á8y4“âÑÇáñ¨|‡î7K®Ûltl›†pdf‡”ÑP-0è4­×vPOqò{ÎjóãÍóÕ÷ÐaCï˜~ŸD‘#:»d@•¶ÜÕncêí?n‡à�È:í'ð´¹EkôÐþ·ñ?ò½KÆ|Q†9¬=ã6„¤nü/|ï£(öY” °­é‹+Ð+l꾦jïOí@;ðeá«™„EÐ$€_N¦êéë“ÐãŒzb\Û*%c†•šuþ¦Oe™»îoÄå}K@Û{N¾Ù,®­çλCz —°%2ÊÌšÞƒ� „è~7[‚!&<ñÄøŒ;ˆfˆöÕ2¥¼µöT6KepÅMCá«Þ(©:b(û8èÅÓ8wõ¹ÎG[çîÑO}ŵpé8*D·Áb4* Pì@]–À‹ÖSô?K]› ò”þ’Ñ!gh~Ÿ\п7æ~6ðÎ Êã8~%-5ú}ý5Ð6?"ß×ÐùëqwêeÈÜ>Žôô¿'ß©P6üÂ?CíërSGnFˆ;_«&bÚ|d¥V†MjàÏž^9wáx, ‰ÚQͺÉÍ£[–k?ú½…ŸêQ%éBö:¡•[Rxöú ʺá²ök×\ÕPÏ)Uæ«xÖRQ¿ñZ�˸̗žÑ?<lŠ°^Žilk•Uþ@n0 vHö«yZeËLgµ§ÃkøVgdòjúpòkîç¥RTGʃ„šÍï/€ýGO>#Y»©ïÈn®n1„‹¼c5c†Ó æ x¬/ŽßH‡ /ô¥?V‘ùnRa*ÒËÉV#~žn4ÕÅ´ª­Kßoõ—uj, L†bÆyÅN!ÔSv´m÷ŽÞ É݉™€¢%–ô HŸ®‰‚ÊA}°&5>ÌDÿóÙÔÑ>º ƒ¡œsn|n(:JÔÄ:æãq‚gñ™…Ñš¾"Hé�‹]‰ÙýFj‰óhSÁ/<7pdEäËÄ)××ù·S½ŽMˆs{¼zeõ#C£,\h7äÁ„pò£–!NN˜yIoBWãÂ7¨D^‘FÌõ’wN²‹'¨iPvïÃê"XÏ8[/Ú7óH5XômÁVôé÷ëS_›b =€É]øÅ¢‚öÔ/#Ãc¥•Rû ò¾>?à®êk--Ê ܈xÒpŒ`(hw‹twŽô§ÍàÓOö6Ó³ãdñú•50ÒpÁ£›¿« ø\{:à3M˜Â(ý õúæÃŒ£ä^;Õ˜°ž¢[jí¥á%OOŒn$Û ¨ÅÛif4PÈ|[ŸÇ»´ÊÂ…­%’‘°·ÁıL*ýÛl$*<3™Øž`[ÅkPn¼úñÁùÙ V„ g´D6zןO¿žSb G*?÷øEbqÁDs÷310Î )¨ÑŸR÷21.®€å}GÏ÷¸u£RÌÑqÄ›{D\2¯_¸Ô¿ÝLMÜy™3¤Å¬蔄Ãe5n™6 Çú¼†T2Zl«¯­èj?IßC'gþi æAÙ©W~­Ô†Á4¤öõÁ°Xr_Ñ҃ŠT±A0À¬žÜJƲ¼ßØ. K ©€9Шu-´§ Œìlýxš¹Þ Œr%l…¦ô†©A¹<Ž,mhô¿dm÷ÅPìÇî¶ÁHK¯GÆžÉëòûNp¦k?º?u°:ï(À4f]wîÕ[.‗Be&gËçȲW¦#§,¼é_*ÈD¡ª2:šAËt@tƒ5ŒÌ®÷'u˜Z*⽫—ª Efœ>WbHïiÛ C#ólÕÇÓ¦¹,¾^éÄÃAÚeغj„°g±é͇OÉOtl-ÔMV_pÞ¼w¥´›øËœ³jtÚ 7(Ø×—¥Â3Îx•®§”"SfÁ Ø†üº?n©¸ Þ”ò;•ÒÂ÷`ÚÌž424-}HsȽ6ŽC¼Lo=Úg7Kj;:Ž!ñb€“ý ÓÃ@Ñ 5è*1!Ó;éµG¢ÿû’Îù“ƒÉž·;—øü¥u’øÀ¨§1t¸WïQŠ¨ÿî€JãsÚÓ2ƒœ’ðžöãؾx–±Oøb5ðÕÊÚ¢‡D|Ýï“gSߎwqCŽ³EÁ,/ ²Vôöš¶õz6D%p¿=ÓŽ¬1«=О�kÿõ2‚éÒzXÛQE÷ƒ’þŽÈÀRr÷! ò*”©0J=wÎ7îBáIÕ2aïH²ÜLŠ†‚vÚçé¸óZçt¦T±`|y %·-X_þ$žÜGH#ÎÿSϘPbÎRì©Vë؀ק¬˜+²¹ø{=ì²¥j?ýGÔ©Ñ9œÀàF§*A…Ùµz³Ò‚$‘Ú±l#'µÛÚÑL¹!c ŽðÇ<@ys ;¸[©™Eý=ÅÿEaf½E•¡í©DßêzMÑF)«ç] ÐØ̼'æ¸ÝüH½f|ø"æn.!΋àêÇ­¶bA·™.ÿâß±õ­mh©ì7Jp0î6vó,ÌÐÁ,×Á¯Ò›¿ÈwbëA›ªF�¡õpˆ,e±:ï˜ÅW>’SD›³vÙqý--icÑ›¢Ìì-¸é×Êžx4iÐ÷iTMí$@ŒH Áããáîé¤Øø—íÒxÁæ|º¶]¨Æ�>’ÉÑÊŠrgv7b0lµ2^yE:ÏÙÐ0U»Ÿ’ŽcW^ EV÷3ÇêÐû³wpÞ¥íuîHRÆóL‘/"1vŒ–„7µ¦ôþ4ñ/A!óOsù‡…p8~#Ó˜zy…¨>tŠ«YI·¨ÂVŒ¥¥]£]ñöúuW7hðÌË‚8"š<¨Z;wMY%€r•Zo“¬¤‘W÷w³ &èYsùˆR/µÊ`xѹªW ˆ\õt-Ó¬WwPh”»9%o¬: NUwöÀå”n këÈÎ~éêÎÃ*˜ˆ ”På{Ãg|³®NLÍðÍ®%–²+ƒ„aoUÏ#(/g:‡]Ú‘f´>»îë}…»dé ËŠüeZ`2D§©X\c{¯à~öÞQ•ù–A¢:_&' MyrG•µH¹yw!ôH7èÑÝHf¦Kô4h&Úqu£ý;ã?Ô@÷†X~-¶¦‹‚8M0~)ØpÖ$í©•(ðwC«ßíyÄÙ‚OÌh¥Â¹%t™Ñ·d•Z¨Ý‘kyƒ³­«1Ce‰”Ëoˆ .ó¯Œ'¼¨ªVÅ*€:9�:dEäªÈóᬠ_V"×çàQÃ7Ëšø?‰[eê÷Ž(Ü{Êvlç|VzK|É&ý« Ed«FqïŲKË ½(¼hpF<KÛØॠèÝz³¶Ìt_sµ«oý¶Knr¬}L‹âÔšÁf9­h5ÈM<v(Úù‰{5ÌsV.$œiÕÑö‡»ÑÚë]ŒÜäµhù7tar7Í€[jzHF5žî>ª#‡pkêÕéh¾>rmpé4#ibÀÚ„¿BÅÌk5g«›‚ÜwQ¨Š+l1ª£ØÊ&·ÿëwåŠ&Iò«ª(+<t)£äýŸÎû¸,¬eQô�¿Ufy¥f8_±ƒØ9 ŠYÇiH©ò±î†û*åÁ‡åÛ÷8°ï‰Õ¤•vãã“MršÓBkO¹âÿ&Š<™Ø¨oCáÄŽ^Ðç¥U�®¥(ÜE‰YÓR¡?·yw G’ÔµöˆyÚˆbÑÝA8¸»cÊâùè)ô‡6`vj½¥&zÌNï óc€?‘ J"ë\Âþ-È6[|²Z v= »Fiä7Â7:qèi´¦hZ\Ðhµèš˜#‡K‡h‹ì„­¶rÃeÿú¶fÊ¢ÌÙ6Mîj°`¿0\2( jàæø§Û¿ér§aéwÏ�Œ{ë—V1Í’Ö†TÿµCIzfŠa´zfÍ·ÃÓ¡ÜBmO \¾Ü‚¶QŒ|%§l"£sV9–˜×}"ú™é?=‚³z/“(5MUâô»“º³–` ÖÕÊÄ÷ò¼/>w%6­¯y¢/¡e‹²fŠÚº½ bÓw,ºsÿòÊ*Ÿ”GU“6]·õEtF8­¬)›€ýyjÅwÕî‰Â?ûÚÖöOÎÔ"2 ¹Ð Ç-ýÆYÓêúx¤­¼Úêo6m”F~°´ïÙµLŸxÞ#)<Üq)ÀT&¤³Ö® ãè £L¦ûÓ½Ÿ¤éB›ºóÛl;»é»™:š_ðâykÕé ¤ÀL46c]¼ª»ÿïÿTÎÒ™õÆg9c¨ŒUl7q/þ¥ç·,/Xv}¤­„Ê8È`…1v:¦–ó;Rf‰oŠ¨)[ìW²e'ôïr6;Ÿ(^ú°Qi 119Ã:É4é=á$ôÐ3´)úýq^~­Á,ëi}è….úÚ™×ò+0`ÙA|´ó•L:–¶g„ZnM•™ñsô.=÷Ì84lǾÆQÔn<mÚc“¦VbtöÏnøg}ÄÉíOœ²Yd[\ʆa¢«3ˆ¥Swð*à@¼ÚÖ]ïdÚÒ]‹Òw)¬çO”V +ò•L˜2qôF´›Û[«3%†óÛ±{ ÿ­bbV´ì›±;w/„m“rQ{Ñöl/(‰;å¤~˜öµ ™i½(×ëþÁùÍ(vþœÏh‘j,CÅÖÓú¦–ó{{q;$Š  [—4È¥³|ÖÓž%ru@„mtà™Ö´¥{"U®¢¥¹=aÊ •¯$¨F[²jZVN[ïÒ7ñ¿Ñÿ”˜.»†bÀ<=ÐV½$•)‘iŒ,oº¢+pƒŸƒç-õ•Ý°Dw¿ŠÖÃWè…,¦”„»øÊmœ{¸1RZ²Ý줷&Mk^:¨Ãø2¿ºÿS”yáBž;R‹`¹™Ò–©KwîU9ÎÌ¢ät®„õB„“êÂJ>/ µ(ªÑÇaœ&œªn‘ªònDƒs¼§;Yx#»^àŽV9%fT6ŸŠ¦t§×¥ˆ§xÍKE(‰¶-Ô—:$j ëh†Ï¸X>Öó/–@b£ae†äíœsc»«[:¥×à *ñçlã†ó™–÷Í5Yßç«òŸ1€²AQ,µ qèÁûN¦¯*å(Ë]1ÈPÿýWTÉ Ëÿ!|»)µ צµüaü™-Û5È^·ÎÊ¥UäeèŽU§ÌÛÒœéç3ò²ÿ¢ •ùöxœ^nzD Ëk‹Ó ™‹ÉÕŽÙy˸Ë;î2aZd®S Ò3š\½ÉÆÊPP8Z}8ÙJ{(ñ7^{ =xð/jžk¥ü�¢ßóù¯¶¼½ñ—5UA†Á™3áò&OÆboŒÍŠÐ&ÀçiŒ36§0Ý(Ù^½™_ÄÔɼ>Ò}Aåìé¶zh†}6f¶R8O$Õ;wSÝÊÓkÏ™ •y3yÚ(Œ=Ù^$ƒ2Rß“Àµ,d-t–º¾x‡“cg„Ú6œ"CÅô-ÄY¾P²¸ò¤ï[õFþµgãßzþ¯Ê™ØW6É‘{pÍ1xüº.TÌ Nãçí²C‹¥84æ{MBIé·zadÜ%éõô;ºNäùGâŒ)Ð RÛa¬D«Â1šçñƒë§#Ëí£0H;E ÈÝï;Z4§ý‡ÑR¯¶ÛXêwCy £ûO­¹×'¸*êØ8JMÆŽPêŒ.¬š)&t÷€#©×qæ.}fú¬[%â ó±Ð“ÿE¯Ë‰”&#huÒÜnìZ×®0Ÿžò3éݘ|X½¦?ùÊÔMP…$Œ)¥@?úÝvv‡ÙpyGqÛ!a”yOëÆ¥V1Àzû£«ïXl ‹Ü\pÌÞ¤Oqõd‹©k²(D\¶.W@ë{¨R÷†HDF¾‘B˜± ]ûãæXE×ïhýN‰.õ¼R8OØ¡?Ü͈YqJtÇ8T¾-ž;~»ðQ7Q×µG¨?׬t¾ììN ôî]ÝzZdáR¤a…=}*°®¨ØZÚ4P~*ªQ·Rª¾‚A와 ­òf,m Þ¡ ›ÿ; dYús¡Ƙh¿ý¸°/læ�öaü>‰¦¾.}13Ï]¢OA÷CaåÓWÜhN}“ƒ¨ûéØœpñb×Z± ô³Ö ¸p"\T†‹Äòä©,ílcPdf®_=Ãñã>ªª …£Ó9asB7ÚÏ@‡¢¹ö·XásølaXÆF»É™‘h¥Ûxº!�¦tóÿ½dS¹ 6³Šþ¡7ãi˜Ø¸Í>«èï;'ž½,òvSoò•;̈́ʇ…Up<ÐþKNZÑy; mÅöÒEw¹ãî:WNžÅkMŸóZËæ™éÀ6ÈSŠ~òD2çKÛíË‚:h'À˜w[Šq9 B†žÌC\ûð2ÉÃU„—mkX m&wq%’{Ã_µz(ÝàP|Cw¶aœ">’KbOטñaì¶ÞôÖŒ"à\s{8Z=·w¼bÔ€ƒ’ÍãHo;o=ÄùÔ:ÿâëâùn­„g¶…G?eµgÿ?í:Esm „€~}ç»ã®g½Y:²fÖ¢Ûνw¥ÜÃ<uUE†[3ƒŸöª%‡8Ñ$úSo­¶ì¿ô‰»ÅÅ5ÝÉáw23_5tCòéÛklÓÇöÁ‹k´˜ÿ‰ÁŠqGáh…JT[žËFA]S¡:̦–$fœ®(~dÛªOz>zîá²V #|Çsdûzö'e¶êO°Î° ½@3† %®!}–Nc”ƒW¯ž‹HTb³¥ô•n¾TsÈÊ„(hÎÒƒ—jýÑ50ü.å6‹Ç~_<Ì ‹ô6]­ÄÕágËn0gmïÊÜÜ,÷gúTÅniÏÄÓųBè»ÖYÒžëËÿðB`|6¹ô Τ7X‚±Ê’«5§ápn^Ræ‡bøþV§9ö9|Ë:0n· ȧ5FÇýh~Só€*ªBql/Íš²É À(†m„–’¬ÑBùúD‘<®"§­ÁP¥Ãô@¦ÖÈËß/œ§}GVK»êCŽ©À©Ëqåý/!>h÷þ‘Í@ä\m¿u‰--ã¬QIp9 C«Ì6v_.çåÒŽtW»$æµÓ2ý·šN,¶õù¥S¢sÐÍ ßmè¨`·+ÐÔþ°©="æ úòÞÏ®ª ƒ2–à€ÛaÔ¬=uºéˆ½a}«)ëg¹É¼}ÏõÓZ ñÙ€¾å¶¥?ª;ûâ!»ñË£ÛJýÅç ئ‘Bw 2²Ð§°R8<Ó1w²á "½†µ¬µ=Ó§ãQèc©D‰ãY·§›Þ×í…sŒƒq ÆÓ,H>óŠÚ±È<Ð1­•î'LÞW[Vz‚¦»ö!|:Ž½Ù O“ÏðO{ECÐÑlþ>+Yº=ôü1­'f|ƒ¾²fât§ªŽ²…NUì¿2ÆЙ¢·° æfM˜¼ú™Xĵt„­øÂØ öø6{nß4svÿÖpGöÄzò¸ÛozâµzX•~ªé]|46&»mï<:(Ý™‡¡Oo.‚! âAû0Q•ëxºÛ¾xso S×–;硶Yº”ת‚¦J‚rpÒu…t«Œ’.ŽìãÉççtèw<±'¶,7‹Å½é‘âè”&UÒsP¦ŠùÌÝùË�q½ËÛ~»o+ íÑÞ( ’¦w‰ qͶ?’’Öpì}l²p©<¥Ö ¼¨ƒ²¸€‡ý ì ú‘.y¯½úv¿ÌjY¤Æø…i«Q§à9*ë�ä0¬ ¡5AáñÒ¶OÈ«ÖÚDZ“1‹ƒÐ­ùÑ4z:…ϼUNj%í•ÄÕDö´A|¦ß_‹€[ÏRqVèØ Å:‰ gµU¦l²ë´j§ŽVö2|cŽž-äliÃíSTŒŸf{Xq,Y:XLîAž3ú|!‰ÑÝ/¸ŒùbÞFo}<�Uú­K9ϸÍc‡ßê"}ýêFì eÔiA5Sso‹¨ÝÈî>XTq£ßÿ­m8#`Ìt1€›>Kƒl«k ôÕW=cd+ÊÞ°ëé>4ÂŽþ‰Ùçt›hˆËn®YK÷xĶÍ6G-¾+|]%¢œÿêÇ>›%âñ€º¤J®ÇEµ}eb™U®¸ ?×ëµ€‡ºÕ×µ(mº0:sÚ2´â†Ú“›0Àÿ|�ê˨MãéJAóÌBc²›Ô¢$þ–ñq[Œªkë‚rÙ71ãѯæ& P‰Ã·×w}豓ÙÅ·3ÓçÖ+ ŸŽ]_Ýhôç(uA€òWÜ}ë" ^1}vºÓ£¶2ÜsÎ.8r°e,WEöÂ\®#Ë2£ôô&¨–ãѳ-¥3ÒÑw}<Ö£kŠÛ 4 Dº¿ÅVA¨ Á,ËjI°ÍÛ€*q‡uʺ£œb{¶ ,ŠvðÐêæ_a-ËK‡Ó} Ã%µD‰aïkí͘ó$Z1‡q?a4(±Ó{XËç–dW(‘îùéä©FHOÔ9Ö³Rzv e/îŒÁ8X¦8ƒ ǵ® {~y}Ë4bÓ1t•mˆ~$òçÄþ(Éð‡W”©v”3ev*“ºn¦9{ÅÕ|ÈÙ,B?˜ÑiÖŸè±~Z}ª ê£[U=1À‰Û+ÞWg_æf&xèé©*§A¼`×ØÀ²^Ú¢ÿnåÊß=b¹ï`ÍƆv&l—›Öï°ë¾ÞPŽóÒûâlCk˜Lõ ÕÉÁshõÌÆ›c¿çd´‡£I}–íÊåw°y‰3oTÂÌ Š[½mÐqÌ=Z…°ÕaØ©ì›ü1ßðcXOQ2öÞ½¢Û#T«lÍQÝÕRë']dŒôº(H×?fùïV ò†, †žVàS^›Q¾h¶”NOÔ–æï$Hzk[— ßÕb T˜°¯©½¸eÙ»^ug:Kí@gêVØÁ8ŠÅ�ÍU#�:ðhol>."áðÜ<ŠKWÁ²ñÞyÀš]«%«§³ ½v¯Ë¼YŸ ëî©êæ6pà]àÅÊcG‰ôáËtp—ßùïbN‘C„ÝFÅebø5ÆeoàÙüÅ &,„ÚÄ©'aÍY&”7Q¢žøͯÛÑqè»r/äÆh§– ªçÉžñ®ÿ"SsíšÒ8@ž5ÛZâXÁžÎhö·Š™NMVF©é… ›”6è1©š6BžuDòüJ‡s@K+FOó¯ªA�[;6n¼Ó.{Âð\Ф0¯éýÜ¢%à£ÂÊÚ<j<B×åï„÷Ë,ôt¶h¡MÝz‹ÓŠb´¶–j—¬¾œåWTy|èŒ%Î Õg™‹(’Ö;¶!òf¥:a:wŸ§|c0õã¬ÜAm‰70úªÏOÛõ§»T7Mç[g½JºÊrQ‹•°s¥4¢U6tl5 ÷q‚S‹Î:ÃùˆÁå7öÓǾM›o7èñŒnnH÷SBüQkdâ„““¯f€©·JtÝU`²’óÜCF$šš,ØB©@#bNF2W—)”Ñ™0x£6D¤úN€©;Ã+ˆ±¬ùxƒ¹-ô}Õ1‰<—Ž«ˆ²Ó<¨z]œiÈjÐkJí!ù®å†œÀjÊqmµ0Å®Á ´A|d:ôWbÊêž*Cº?mzz{rÄè׬:h˜Þ4q¹brWLp4 øi4ž1&`N<, ÆmF¥£vó7p³_ùÈÿíaÓ*¬~éþÀÊQœ–Ñejèþ@{Æx<9TvæŽ%öfYmi/—V 7Mš6ÊVxÞ¿…iD Pï4¡­il;TU]9-ØxŽÎ^™õ®‡wTÅ þx0¨Œ:¬ÚEÍ’06m¾´Ø2„ç^9‡ éW¨X¦T—ÖnMÀéÆ;?NÓ" (ÈöSV¿ÚRaµ¸Àèìyñq0=<ïƱîõe™¾z*ŒìŒµª¡ Ò)‡|I“fp÷¾  ¶¼ˆp‰$cÇ8Ê+ÇðŠÑ€l¶Èæ;태pì1ª¢:Ÿ¸Á%d¢bË ºŠ±1-ŸÒ3aõ~׆*iÔÑøpqŸÑ •3ãdËÈúZu°‡´!ÿóÑÁ³o“‡ð,îyãêš$=zc ¯½‚ÊcÖPñ5À aä,¬7å͡3ïJå<Ý^J'¦Œ72n­íDbè»ÑÿÎà⚘Vˆ[V~Ñ_V˜a·²`ªü–ƧX/­²òE³ –‚2êoëö[rÙmMHY wzSsqGÉs=çR<hèéŽNg¿ýÙ:ן:€—õ×»F�ÑÇDI0ß¿Ïnc5%@rW8°3™TÛ´ò™¯Ûª÷êŒxi sŠÿ³,O,þZb~ª½;§A᾽眒ꣅ:Œ¸ô<ŠÝ±P¦3¡`µœè·zsâÔíÉá²+oe >ÔÓ©7ƒUÀ¢EصKk^„`!ùÝzÿV™/ÅŒGÞ9´ö´˜Ðéàø°­Ï_lj+POîpßÅ$®É-3šÃOÖŒNÎ58FŸ`ñ— œ`ùb“§=Àep°mé\8Û žãHËÀ<QÑŸcý˜wÜ$(ð¤Ze—J¯AZ[Ü¡?mYJOÌNlÕŠÓ°SÝ•G0㡸9¥ŸŠ²£Ã‘ÑÜÓs€8åÐ>3tʪ%0=‚HØÿ8•J•Q�É[cÏ$ôÌx6¡…Ò8-”‚ÙæÜ‚åÛ>’÷ÇÁ‘¢ ieÑBSƒI.5cxßѧ¦°×tFÓ¶Óº'ÁV<°%$:¦E²üìgD*Q‰x,ñUFUœã·£'ñ K2_íò¿Á"• ;‡(8¯)·ï[_ÝtXÖ't$·â{W·V®™o _–: Rëʆšhº&Íq7 b1Þ£Ûæaf[«›¨öTáß^ a½¯×"—Íÿ¤ÌêÇü¶á¶wbî”·rËV¾/ßrñî®ßÏ耎”k%Vú‹œ^NÀÒ3â@§-+}5Å •JMç}è(U ?• 5-œu–\Àiâ‡3r.…š‰ì•ŠÛ¨[Qe ÌiÌ^¦a×xZKŒõcœ‰)ž7‡ÑG’›ï¶ âî°à¦Ú«Ö’×Xt¢?,ÃœªPZúoZÅ$>¤ ƒ}(›z’æÎé!çžàŸø*Í|+ƒ*h†Ä#§ìൻr›zÀD¹ËMÉ9kúd”ÏôÊŒ“3£3*¦Â<t¦/Âd¦g] k[™¤»ŽÞIO¥V ýeÞN'㽜,Ë|e a\#l•cêÔƒL1 Í]ü§(„Þ©¢¸p!Í�ËÊ·‹séFiiüµÃImOÔ Õ¾†âqƒ²5)"2ëùSˆ,‚Ü–F‘*)yÓá0 R£fg¼ÇTÁ,r˜d†qO´ÄÃSí ã¿1lGÃ]‘üͦÙã)ˆ³B[à+[¯ýFò­­ßé°?ò ÕýD1Ü är¿ÁwU ôú¹dÓdAöSRÎ|J„£Lõþú"æ <éš(N­ï³½ -ûY-©§¡‡6æp×P6’-Ü+ÉüóÝþO‹ÔëÄ�Ò“à€ã¥UçU»yU÷kúCè¯`÷ €`kÏX5y¹›¶&YæSø3:^iE%çÆ[LàŒÛã–-¾ÍW”ÜûÎkr…ÆSõØÁŒdë©å‚¢S[>�Œ|àÛ{‚aÀFözù`dQ9h\Ä­ñUC÷§°e­�p�£ÕÓ†«¬ñoÐúQ˜g-¢•K‹*:)~•R@:]­ÐQéS�j[6ÿN8=ÝÀƒç* "«W“Èã Ël˜–ÐøÖÓÊCXî׬r¢¸#éÃAÄïteþÏY'Prƒ�a¹Þð¿b7®/}{7ˆ=iú=ý9•eÛ"­-œ<ÝLõžÌµ)Œë@ƆhyS{°yÚê{Æ•3[fþ§Ÿ—¶h¢ %'4 ŒME‘bPÐÔhé¡JJjFb;Ìøú®þ·³sñíeªªw‰Îÿ.BIØ: ’¹óÞžßÚÌF ‡OhˆîuÛ}œÇŽ’³¥DKV9ÝBð¿T9:wP€í×AZ=eòeþD¼Ä}€ãmÙ¨>ù È-BÀùð#ž }„o­œžØŠEú8c  «§–ãÚ˜ BÕ­ÝÍ«­wÝ—N¥ )öAç±¼U1øñ1'ÜÆïñà­’ªr«Œí•¦½aÙ¶ŽÆ­µ§*æ1\Îp‡ï^ú-´Ènqþ»i5L ðÀ9Ò”çä{ìO{J3]û·•ŠÓ8ó…㔟)<£å™ö;½ÃÆ3ÉËÍI€cAÚ¼G÷Vاtöa&©— 1ÝîkŒËe1K-ߧÃ^¾ò1ØqƒÐµ2­Ñpf"Õ<°BUë`½¨E¬hÏ6¼ªQ\}+‰Êµˆi¶<;r·“Gg⻾ûïœV› $)æžó ÞüX1ZZõÇñ@÷×Ì@ –•÷/Uè›”b §Ÿm{O_mÚb"dlˆ µŽõ«®~áõ%q>‰2f癶jÎ\Vž¿f³ÙwÚ‰í—&ª ÊæÚ­3ö sór‚Ëᓨ§ ùJS‹ÜñÓ-cÓ¿âÌ¿¦£e–®[£ÊIÇ„k ;^¸ ôp’Ÿi£Mº5YЗA>N¾p¯Yű¼e•¿d7£Õ6ƒìs6)nÂÉto€æ3>™ðäY–—fág£²¨³F¶ÄÅEŒ>ŸuA¥d¹ÃùÊòÈ'õSßêÄ¡ç²¢$ù }öˆ²ýOéýáb ¼/‚¬·üÕÔÍk;!*ó:Ú`³ÏnqºMæ|C£³…ÇG�;.dX3>¡."z–úû�«ˆþÒ©|–8ºóûÂ0¹ž~AÏN ží0Ü‘´�㣀ÞQ ÕQðp܃7Z±ª#Fbl• þ6Þþë¤'`ï(o6ùí6¢}ôÆ%=Gí´HÔZCôŠÅ~SÚ�vä m/ôiZ'w±Év¤­j¿6<6®å!–}ÐCD/‹±½¸²…)EH‡ô%£]¢ñgµíPð&gB‰§«÷HQ/‹Ã…‡FœéÿW£¶%((^@®‡iG‘éM„V.¿?56ïøËywéõCRÔnì­cÄ E|®‘MŒ¥“ë~ÓSEiî¼Ø+Ïþݺ­(KêÎ#¤7Ì9µ#7ô¢‡N!Qš–ŽþÉO¸ÄbRG˜}}0«7ÕY¹ò‹³Äô_Ž8è®NÒGÐĤŠ¼Â™ÎÉã!S×ú*A:ˆ‡?'sx®hNæësÿ¾8Y¦LaÐßÖvÀfÔþ[»†) d3‚JÜØÏöâªkED† \IHÙõÆiYKûH”*$ï–]øœ™óc‚XK(*H\JÏ7pÇW'†³Ùb¸^À,(6¶±ÕA·a èD‘a“×kû¿¸ôD7YIûÉF ÷Žžf‰óÆBª> ÜšÀ¬þUé{7°á¥B´ØçÁ)ªRÉ9ïèÎê-Ǫ7±ÇNp‰‡ÇHyÖQFX~þx¾ƒ Ï\úXÀQÜýé ?ÙbâTˆXŸêŠLkÕ— Eè‘rÚÓ]°­ ô:øÐÿø4îó¢ÔqIØ�=•NËë4¯¹wüåÊŽþðoÒè›Né‘‚ÅCî2°>=ñvv"èÂ9ͧy+L/%- †$õh³Õ’¨Dc— §]íyz¬¾¤6ºfÆ%–î_ ÒÕ´têYsLž8¿®dÚõØ…O£4rà2 v?ô9"ã}½aò,E´{¨˜f&sA÷ïšú›…ÅqæºÚÒG\·êÏgg¶ÞË×h®gÚ…¶…ÎÔô�ÖtÌ:‘–ŒV7åÞõTSçJÌxI›ã±1¡PuïGè°_õy*JÕå¨EP}6žM.PMº ÷¦Wô”Y_8T³´ f; Ì`|åU¸Òˆþóß²ì=ë5F‚æAQÁ)èPHfª©×;ÁÛšü¹é�qº8<®’ÂÉ ÅöQh³Ò è^}‰t©Vãíé]ªp×í€/JKŸÁ@gÕñ@'aë$J3¤Tˆ5bd8$sù…RZ,KÐ’ç0†ø“²#AlˆÚR•öÄLOrCKŠÊ§çæú±°FIúåtô ’\ì.´|hý·x °=_¤µéÂW& ÚÉøÑÿ¢ ö¼x¶õOç"®Åí þjoñ ¢Œ ·¡! ªYó´’݉ LDÄ`>ÄÖÇ™Ãóõ÷jpŸšÒ-Š mµ.b:JþUs[nû—¶ýØpD7s[ƒ¼ >ó…’\Š~[:[*g.¶­É{? é{ÝÑÍææêØxä¾þ¤‡¶[ñ|õݾjé1Yº‚Êt•»Šü ˆ¹Ãu:ùÄã'ŽÒ…ÌhlaÉ/áÌñÔrÓÄX)£Ò@'ë|éת/cùSÝÒ^x!jx°W“Nþ©OtžL'¡âÇb‹î›°;3ö8ɲ¥HÄê�œÚÉïОð¼=*½=Ü¥;&½î>> L>N'FÊøîLaÙPÈ9Šß{¿‡–áó¹‹Ã8ÙŒÁS sl‘‘`§jfO‘ÉÎ'oîš8“Q�îO´Z.Gëúµëik t h6x=—¡/²È–”ýÁîGwÝÈ;ª7MóÖï›Ñ3ŸšÍiÚñ£`ŒêZ,Óÿz9毩svíxÏì7誡“%].Ϭû‰owYúFÊpzf\ B+̘ò¬NÊ¿:‘ôL×í¶`‘q+[Û÷ºM”Þž/ýº(¾•/¼’4óž6U›žõ¬�›I²õ­÷Èó÷/íÁ[¹¨˜@€IûÓùüDº»½€õ^6“ÊÕÒÛ5y$ ºy{+4A@IOI׹ŠBO°h¥óª±“q^ISW/´ž´7¿øæµÊtåÐ"Àï%PII>¸1¤óÎÚ¿R>ÏS§é±f2ã™­±¦´Z\Ä1Bƒ:&ÄCá®9gЭ‘ŒçSa­Ø1Z"ëÑK;u6e.P€ÞÚZ³(Ü=`"ËæD›.ÜZø\¤ÖX,ybý»Ze߸ÜÈÏ’ìÄEµWÛ–#?ňþáØ×Ús§?]E¡ÙAëúû7RË(M8þ,˜Ïô{ çx—9òª²ëŽÛ Oœ1œ&Œ¦ä«uêµYÅÔ£éÚØrÿ·…Q.d{èÔ“ µ::ÀÔvÌ1Î5zp5ë®ÆÃþ®tCûoMOõ<QŽðÙúŠäJyådt¹±1S¾~½FGéؘ»O¨õfJúZ푤€´ì Õ!¨4§ëøàRS¿,¹2;n&Jrª~ö”ùèc ãaJÓ[?ª¿p¨ò`dÒL§Ùö¢Oʱ`£( ÿÎgÖq‹C#]5O´¡gÅËÆ<øÿ¨PÖ¶F .ÖFÌLðÊXö¶Ižyv ´Cš!øtp(Qœì†µ¿¯>Ør½ú¾¦(•%IèEÁ„ï^„vÖ¢ QgÖŠåÖðý–ÏÃF“gæ8À!ˆyâP‡Ážóï[ç†O*£¢ÕÃB5Z+Â%e†ñÄÐSˆH3–êE}_V>-ˆvʹ¥[4Óu¦íµ“ù¬é;G¹Ñ*°‰¨Ì …e®9ôõFõ O–>°‘ÔàÔ®»ïºðàsF8/mú’ÄAsËU)¡28èåpûë9à#|y¶ ±$†Ð¿o{«üAi‰ñØòàEuÚqÓŽG1Æt:cଡ%ò@… N¨q‹ÑÉÉs5—’õbkŽF²MS¾Þ¯ò0MrüÓ´U3ã ‡EšHwíNŸÛz7]Œ"4Ô "B.n–OêµjXý•ŒôÓR«fë/—N¼Ì-¢T›Ÿ ‡PFaÉçų!^&iAX¦Î¯Æaq´ìˆ†tZ�ç@F9÷8&zw˜{2R'ý.õk³ÔaOEY‰#Ýÿi°*7Ʊqôrfy;#ÞºkõÑ]ua¡š£²M ­·g¢}½c|§ú9äçKh”G.ÕåÕ'RÄö6c™ôl^,Ýv+KüTˆ¸tžÈÂÊY()ßZk3ÐQN{‡} ”èt¤>/©#{ÆKTB-•Þ½Ófò žŠÏõ®Ñ:Ö^¬¶bW…˜Ï ÷ÁÅëíL‘êdS,ÀRò㺶çÝ Ý.{q?Áõ¶y¼““S̯% Ö}w‚uâÅbÏ3ñ¶u‘Ç 8T,ò–Éd5°üàBýå«ß•´, _6ˆR¶í ontéÂEÆÙÿ°Ùê®ù;¯1ÇñH B¤™hå[Û—•*’™ä/Ôã<l]ÄC:ªÊ£ ³vô,ÄCÇJ=ŽõlHS^5þninÛ‘ªÓ9%€i‰„|ãK4g¼€p=Þ3—HJ?Ç¥|å ú,ø}A>œLmÔ—gd£0[,׊Y-³ª0ÔïÄIj'xû¬º(+NJÌ ÙSA²óôñ çÞqÉQÞœþýóË›Èý0^ò‹ßxY™4 i•´Ÿ5§W•ÓV,[ŠÿR¤%ѹ·m ÍmÃÌBûxó±oêEÃ(á-ÝhÕV_ú ÛaB™=ØàíÃÆ–Ç¡˜yÉÀ÷ÆòüêÒ{ãÒ™7É =ô”?]PºâÃPw§ýý"zĹçø“!^¯þ€Õ®œÒÌŒµ›æâTx*ç`m4ª³:  ÜüžíO”µ¾Â†ë?fUÛ-%¹ëúǾ>ONgÎíÿa¤,<m{86xÊ6C£þ ÙÇÈÉ=+à_©2FQî>y„S§¡gàì"2…4=JîÑh%Q §ü[{õ°æŽýÎpÈÃœ†Žö“ª;ÁqP@¸6-E[òaáÎÕÍA'ڵʄvž9™˜i©tœº}45[„اxÇ8*©Pö#T•A6–`|&T)Wá3¥0tœSÆÙôÚØŽ?©Ÿª8ó`wÈö[( ŸmI#~jdû:£vÞ êâÕ@??^«âQ ~Q@õ®cf³u¡l°í~ËÓ±Ì{) ’‚»>{¾øý¾Ì$È–wy›éûòDìÙÁºÉå÷¿]mŒŽï“1¬/ïË%[L©c¦€DŸ3Ô*#î*í;uÿÑ#I2rIw:ÂHLcJ^ Þ¹‰iíüè(Œ£W(˜” Â!?*ŽÑ0‡’Ô³x­ô3Rx´<æm'(ð®]Õ¢J&–ô¾÷C_ãEü /2ÀS‡Q(ÚÖ­#öXp”žÕS7,¿¡ ¢Fp5ÕQ  Ù@}l¨ðÜž¼†ëÂ{M,àüDšµ &ƒÛÉ$?'‘Pû¥à®ÏAæ±—ŒófLêJ÷£ã³Ñu8 ¨{3Õ«4+¤<÷ÊMŸåA8¯M‰Ræj µS=ò¹À DŒLK7}B]Ù:èyÞÚrzDhd€Õá1¾Äªí•a/ü³bßÚŽ8ÎëlªÊiÓÕ+# #X_ ÿ.˜ÆIn˜¬,õ8•Žá]ÝtÍËÄuZXèkþ’¹Ñ˜Š–Å¡–v ‘¥Üšût0¼¸×GHKÏ@˜5Û·u¤ë­)Át~lî*Î&æ@šEPÊ]<âÐ'©k†äH èø«ÃÎÔWŒS,ÌÕ;^2±VçÆhn6LWp7ÇQ˜—äl76p@'Ê؆`MÅ¿^ VÌ´¯gKé<óU©¸]­iɸÊ 2ëðׇ.Ú¼´p™+>",oY]‹1 ›¾¦ûéÊû?å8mk÷Í<Wç4(×µÙièÕt’A¦ufüÎ{æ›Ýniâd˜xÜ®˜›V$oùa4¯TùgÌSúçæPÐäi·ÿªÐ2ÕžÇn^¬qú ­ç&ðh¸Ûd/3Ž5ÛMTÍ·K‡é9Ï1ÛØújJŒ5zÆ<WÓEÑæ…%=Q`¨LœŒÜ(¾›t‡žÒ„½wõ�dÝäË'ª5ó~òòßÕ”XÍáEû«“‡]±JÇ¿[8Þ\G2¼Ë¶r|iœÊ ¨DuÝ\9ûÑ…ÒSÉÒÅ?t"gñr/ù‹V¾á£Ã*¦uT˜ò`ú‚¢þöbê”�@ï›ë@58Mb/~æ øÒ/^íj+ê¾½@_f0/‘O=0®\¨|Á„–Roqº‘÷{RFÖÈ\|~:eþ'RåñXé}`ÆÃã¿^#²ž¾O Ó7‹öæîGIákâ©x¢BgsÑYr¡ctzÚÓ@¡–ÉXL”U. ý»?¤õ¿@Ý¡ËP¸°]ØWŠžÃÔ 2{|u­E)wUø–îBnm9  MÁ²»¬{å•üa²Ãó(Á”ØÒkB¶ePL Ke³JzHSký Àñ7b–/ç ÉRsEÓ‚ª¾8 =&{ø~êôW|Ñs.„uË —ü¼N‚„õ! ðWf ¼ye4'\·éÁy—ÅV“VlIš- ikôß+ ‡‡yú[/ªÂFÌðõ)%+‚¯××ÎçT2Aò+-4¾Oà`½ÀüDUºPSÎy€žm¿M,€H³72úÏGVÕ:\£\µ£_¨ýWÃõ,ôUpéà£0™Ù89Ú«Óz›÷ãd¤|a&ˆ N!Œšõ7›ý¬W�7¹(ò™7ˆ£çäFiuÜÀò´V†žk ƒÈ2-$y=_„3õtm–׳Ö›.zmà§|¼î&!#0a˜ÈoA‰çâÈÌ;¨•¦ßŸnÐx¬[HÃ[�1ÝÓÜ}ªNš.´Œ)2úrš½y‹«ðãŸpÓ¦^ŽšÝ·t\¶l‘£WÏúY±'$“±OG—IÿéeÛR” »#>"Ô†Gý¼,¿àB£×®gs¼¡Š£íÖC€›Û,ÖAô&®Kq8ŠÐ‘ݜ슪±É:ìÆÝCïèòР–JSŸî6 A4“Ù›`Š®èùcU[]$y\W¯"'IÙépŸ’–§.ÕcÙŽý·‡Á4‰ƒËÃSÓŽ)ÃÌøgÌ5Ÿ?R Öd’5‹bé�µFN‰è.ã|OÙxÉOØÐ<´]ãáØMžÐ¥x“¨p¿i\®�1JÌwÌ ÷‡ÞØ’Ñ©¤ã¹¶Ìt:A²•.VÛ6Sf À ‘“û¶kÂTŠ´Lyëëã>œ³VcålÊ•(PÑ!Ôºü¼ÆŒƒ™<;³g; øaÿ,^¿öÐï‡l NÈ9>0Ñã7‚A¾bÁ£U~ªÌ„”OžÝ{㥬ð=º!QSiÕ ®§nÛ‰FÒ•žýn¢žpž® ™”À(9vÌ‚’Uë¬l›Q+ºOñ”žÕBŸ³ …œåYO†”ÍΣä¡ðg”ØÓyt™/¼ÔÒ`* ©#>nv£÷lÙÜ/•]#g^šÛ~<$”Zã<^$þi)†3²šḦ¿<'mÚ6§aï†`AIVÓEn‰F0­V7¯lN }@WvtÉ‚]ÿõ|¹fžfP™ÙdÏN––<`û.åî»ónºk]Â[©‰ "Â4YìZ#$pXMW¾ƒÎ¨¬…wª-¸ÜyçˆÄõ¡‡P§´‰%ÅêýªE÷‘Ùï3ôÀ±L­®ø4áÏ,”¾ZË!A¨±2Ͻޔ³ËÎаM3ö˜s4žf7ySW@8jžðÙ‹{=}í%[QããBN»öz^GZ£EXÓ-‘Ƀò;õIFµ«šZñºC6RpÈféhBY°í (r¥2Qúòþ�¹ ” Z%qø7œÅKÞƒ0º™;$‡_ª ôÒ“%FEQ™Ü–ÉáÍQ¾Öº( H+�`'¿=r3¤ysZ“çÖÛ!âqaßôgͳGÅhê‹oØKGJß­¶�-þsùgƒ.šPfïðœo~�jnûuÜ“ÝÃ%¤lÔ,wÈ=9ï¹PßøQ;ý¬T¥_!d:×¾tËÜ 3çú4PIĆ–Ì“OgÈÛ±§M [kæxX:uæfµ^ �÷h¾@�Áj††ìÅ=[Èdu#›ho—›ÉRSX(±¨m(\¬tiu´còY;íQ±÷¸­ß €yeÒÚÌlôáLq<gkòÈxñ¸¸Ñ»½¯¶` ¹¯ÃHâÛEB ¸‡(dï+ÝÓ4 é±Ú‡úÛ©P™$ª¯t÷»už&ÏÂtû—æ­Ô…]ãÉMª 7“o‚i\€1| œQ¦Kªdœ£/Ví0s ÜnŽÓ’ûHõ®œ«N„_£º—·òD‰ arÄT±•>4Œ¢ÚŸª%ÓÛ‰=·k*"Çza?mZêAzÜxh-¥øK—¯co iôxü«xau"ZŽ%%ïú\rñ1Þ!JTJ/Ï—áCÙ%ô¦ú#ŠßÊa[Žà¬ƒ·À¦}˜(Âä6˜±1`2lÃb`3Wn¡¿“™O.x1‹0ÅAuú±Ð¯Ú(ãªNqœ†s å…òšÜ…&Äþ`šòšMŸÑÃ?[½ŸHÆÅ?fåQ5¿eã<Qõ³.¥Þåñ·.6ã‘Áa¦ ʵÕWŒ ­Ç\d1EþzImõbÑÿ)¨.ÄXË680Õb8€p‹/àD¯ Ùq²®fó½é}:`n‚j¬hP¼Æ¨;§x’„jN¢ÿ [æQÕýO9Óˆp¥FÿG8‘%!öÐ Òü• t%¾ðÓpÈ­ÊDç™hð_öŒ©‘“šÑ-5¨C8uêÒSÓÀ,ô™Q¥ £NNG&GªU³ ‡•ç/Š >’þ™É¥B®C¦|ÓßÄXàl°=?̦ƎÞ�Ö>6¡‡Ü_†§x`sà«ÐC‚Š ýQæ4”,FGµ§Ç8BƒÝñOŸ±c¿;BQÓPþ'“?"™8¢åç+¯sØ›×E»?_(ÌÑÉÔvY$míå¸tê¬=È‘Â(A}¹5Oó!d?9AÓ[l\iæ÷hÓV_…6YùŽ"ùÀã•oKöÐ0Þšnq“öFØåš`ÎÝèÀ^IÁL{Zêã§çÍ)÷áL‡á$¨y¹%‚E¾\>לô%q#¨¶Î?ôõÀ<óµÙ°d�~Û:¢Øm6|E¨¬Ê…¯|lò j·^¾Ú�ÛïY†°G؇ÅÈ=î敆ÚO„Ö6�h]¿û·†Ï›]÷ é1/ÏÞ=ÉQfZ^DDÛœîHç<'Gu±Íˆ¹{Ï› ¡ˆm¯nÏí(ôE©´ÚÁÕwVÐ"¬ˆ;*°?jb†t^ æù!l§Ð¯ÄÉðéïê¶ì¾ùÀkÐy¨0ÚÝqÑØ =Ù VX>Žq|6ÖÛhƒ‘¨�žÖ§žÿj5ðÓ×+í_ϱù}Ìjî] Û.‡ßzÞEÅR:¤‚H´=lÕ‘Ç"`çÜ8¯Ì˜Ö W/È÷TL€ç£ÎlOÛÄYnó ‹_¹ü‘M¦rc)¼Úã“Ž'§ü°¯ÿ5c:èà'ÌÿïÿÁù`NÂ{?{y:z¨(2úN”a…AúÝjó‘‰â…ÀàT âíÜÊag9DÓãí§@Sp¯†Œ²„EsÌ|}DÁ«®óÐƆŸ–nɆA@vC_CAŽ{šÏ]73×ê”òz…ÆRÚXåg˜2Ö€{ š{WhcM%aMað`oÑ]”ysƒÞÙz€Æ(+<Rržè‡ t]ƒÃÊgÞ', Æú¸¦ù^,%s6ƒÕý[É¡ØÒÌT‘wõ6™ˆ †Æ×@ŸVÍæËŸfƒ¤Û‹›ºs¹ã ½äAÙ+z4 EF^|=åýYî¼Ä—Äÿæ*'VU« w<�6gU€DªS†*ÚK¼ Îÿ0–E7ßÞôèçË‚@B—IÏŸí¥gO÷»±)Ü_±e" »â=Ø, jÍ%Ñ¿º‹I¶ºiR¦(šã>E$azâ@ðëkŠ r±Ñ™Gš·oeÖ¹êw(Ê”›îšÆÍl¯t¸2ßQ°Ï{YsôH—P¥9œ / |êñêvG¡ß=€‚�ø\ ~Ç–}è7˜’ð­˜)©lv_¯.ÎQ+ƒVk >»Ùé5P8é™I¨SÄWnõVz,4Ä‚Ý1NÙRÞ¼g"§¡aße¢ýØ­¾®y¡wÿØnwéù4­Ñ…I˜“åÕ {Öf€ ‡q*„æˇ±]~9S/‹üº@xZÓ @Ú‹;äíŽ"PûtÍ ÇìÈFhœr_dÜqçü®ÊÌóvÀBÈ«p:ÜÌû:´nTèþN¢¹v5^©8ª³’Ë6§”îWûít_œ·ôaQåjDZ‰B¦|–žô!Ì€õæþ˜¢0Ø» ¨ñõV! ˜y$hs¤H¿[~ÔžV» (š^ƒÀW7 Ñ^€âC=µøÏA]=dA¾½ør÷»¾Ý×óø;Å5ú뙉s–™]ö„›6ãMïò5Úä+ÈÓbPq[ =.Š²ÈsžàŽ3t>ªVU!ª’õ¡`dGqeÙÉ}Ôiµ¾ñ¡”ÊIpìiÿ'k]§”ËÔ£t¹ñ’ñó¼X¶úD1Õßû~7Ûác¸ß*Ôœ|šÝ’N&wÝ/ûNçïp¢½3WÌYÝxúó& ÛL w•=Ó«j9óH畘BQö±¶™7;–wê9J3nŸw&-W,8ÏŠÍ4©î \,s6ÊÐ7êßûÒA›OÅHu[úû3^àƒBL…¨jôÐô”HO\<¥�ÎG*÷Tž€?¦­CØEO¹z< ×dñ"[ôÕR­ýu±£é<í蜡Ån”ÚßXæ‰'<ƒ·-¨ôˆƒ²™½tÒDq ž•Ñ<^~÷P 9I=X”_èÖ÷ÞVÛ#ŸÆÃÍaF¬Þ»Š¬ø ÑWˆƒŽj÷ò[Û!û(ûÅ:Ïaê‘’ ¿Ï-p¹#KCL%}û©•{.õ‘‡‘ì:0Žf˜Ayò]îØÙYÆ M‚¤Þz¬ä¦ÂÁMøajá+Lh‘Ç™ãG&Ft7¬õö"…SÃFf¶t$ÿ²»eêP/ÜÖgÙ¥F‡QœÕÀç~×oÚhÊÜÂT»3ÄRn¢Xý©’®!Ò£qÜYEWñkìê¯î¼Â,sþ9³/¶”Á%ÍÖsq;Žò8\›Êüľޛž/˜6–N÷€‡u‚ wޱЎ•üëÓ`›¹W·Q¨7„Ѿ<e mi ¤‘*Nƒ§©wõÚJ€­¬eÌÀØý­+úxõ§®ucC„0îË~6¾8“Æöœ…ÁM=Uë–©À\ Q¢ðaªö‰ŸÞÕKäú¨±X@UTiUAøS+b²àòhÍ›æäLwA÷óýÊ* û¤™1FVô µ!J*ž×ìXå=+ƒô)݉L›V˜ûô?œ×„ûT2㦃  |5ÌPœJ½?xpíºR¾Æg,~¶[1z¤Âñ²^_†AûRõ~_K뮨~€붳ÞhËï=¸p‘ó„F®rÁ 3ÏâÄAÊ5gÉK’ÌbÕã4t÷„JJ‰ÚúÓ‹°ìÏÄ3û ¿ìÍ½Æ ÐäÄ ðJ¸`BF˜îÉñÛ™dÛÃÙ¸{6˜û8Qœ†žé ºó�u‡£N±wøñtä(ê1ëèfE|ª<¡¤‚]òK}eº`ðK[¯PC°ÕNf³u"9⨉x!óû¶k¥X{ªøâ“­3¦Ëž©êˆ·«Ìf1º0f-¨³ët„¬×Ä^íwÇX‘ÂzEeæè‘o‘;ðTÇxkù¾3wáPÅB?”N#H eõöGª<4ˆ¯æð}I¡"ñ¨ì 7n* ?ƒÇ¤4‹Ú m9Ê BƒÝüà•cl™Ã¿³©s¾7¦>(%OÒP·¦o–;øjÑ;EÊQP¡L ªžé¿¹XWÿ|fÞ7ýìð[¤x•^”˜Í«ì"?û©ì€`Ûµz “V¾¼#Ôº;fp%ì�%‰‡©¾1x±-n{ãEÄ?ÐmÁ¸ôãéO=˜iÁea(r8§É ã×�gn¿‘ÂI‹Ð³ sxsŠÑtsÙ&†}÷·ÄÚ¶¾†úÈ5§ð/ôÅ™- Žj»4ˆ­,['¡\è}~9ð6 ™O{Êé'}번5Õ~‹¶Çïà/–›šçˆî|eÕ>XåàÅÀI›Ã$¥«ÿrÝß.Â…J]€]Nªñ"+Fçât|Ýr[æòÐON|x%Bï.²ymšft„¢¦[7îÕû 6Ç­{Rô?Iu…/<v0Oמ½¥×6yÃÐÅ hþß¡;ÌÓkTg@Ë™I0:rŸê“ 2S»EúÇ|þÕöÔïåç÷²á4Ï034ô™Jlô7$ýQÉ÷ æ~ÙÒm®„”ãɶ¨ˆl—žLã€}$§ÑiJŠ¬]wvQýjýôm!ÏG+åÛvR�>XŠ…-wOÃjµ·0Á4ó—5LêÓ ûžž“™êb«Í‘’îƒHY¼cQŸ/ Í¥ºUô‡ê>E!g3IÛ²âŸ<2‘8ù•Ýî–‚ÏrÞ"÷'pôþAÓƒJúÐ"ÕVu#ˆaM{O[·Û N»š®ß¡…/I1B—ÙƯ&H,!+ ¬Î ü‚wçQoͨâëqžè¤ÎŸn*²­Ï}'ÿµTjå¥nܸ£Üžîace’sî Xø„ZêcÚq¡ œËñ×4²?溕ÇëŸxÚHûðS#ÒµgñRÎuénÅçwìr›h·´½7ƒéJÃ?°?ˆ^žSd¥5uwa„ë´üææ[ÂxlT˶#}й6~®HeÅ3¶¦T3„ó®HÆ¾à•«Aaã­øÓ6}ÄßµG†¨éázøwÞîËÝ ß.ƒç‰UBتò˜î”w¦ ÷½_Û#°¥âé ™ÔZCì!DGM¦ü²³Sï_úú|7§Û tsï|+–“°0&msqC+©&äW¾E’µ2Ç™ÉßØ8<êôhÏñž5Õ€Ú|yÇ„ºˆã@½àü'ŠáÛëìè÷k°> ˜t9¸4¶çââjBé aoòxP÷6µ[Âø/¾ !¯—ßØ”GIfÍDqbTÁL‰gi»†âO p‡ŠJþFº¨ŠÌ³¬¨{ú�¸¯z®<Fmõ—AMûü”ó:óÌ2¿ @JôEæä|0X7äº�2aŒ×ù½«û¬+š²ÒF쎘þ *ÎÒ׈ C '½€q ÂV>´J3>­¹g¾:ÐP÷ú½ç‘ üFà_/ôt­‡‰)´â~hl{ÚwW(ÊLk6*ŒX?A¨¢Qq"ØSÁWÌÈ›RjÄ”ÑçrÒÖ�F¼�ª`{DT·ðÀ’ù¿ý´ûWÛ5ÛnßÆ¿?Šs[¯ãi‹4K˜0p::Òsë3€– HÜÖs×ð£3É¡ˆU-'U· Òj¡g,0tÓª0…qÐò½^Ã?roØÆMÉsM÷¹·šì<v6ÜeE´ŒµÈhr#­ÍÔ½K ?Ò… 2›ºAuälნKv3Œ„‰e½ÜnMÝ¢Ô:pÎÙhõ¶–V[²„ùáhÕ³7ãn?)~\twLšnŽ¹*šqh-ƒ‰ŽÚW†¤Ëž'§ûW¨9§Òš‘æ {ï ^k”½—§`ÛŸöüÚQæ»:üç#1¯2x†+’꣚^e¯ÞìñfEæ±BFIÒŸÖ¨Ü å¿ê*ÛíM dæ 7ñ oµÍiOwCëÑSÌ0‘£99%{þ­¸}ËÜÑ—Z 3Ï¢ƒýWýìkÇÝWmŠ‡s݃ÜÍ–Å¿á3©c3±ŠQ;€¹€ÚL‘£Ç<£ÆŸYj§G‹ssWwÄs«ÐƒÑ=;ePn7šÖcnrb:/¼¯®Ç‚dÐÇâY€ ´@eyÊøƒ(1Un è»#Ñ `t³£vý—ÜuzP¦½ŒG¼£Ÿ ì6Ýôªg†<×½Ò°`kôCî/-UÍð¬ ÎmÍ>Oìc}ÿí™a¡÷?oéñ~0äŽÆ^åiæì‹p®¸[&Ûîme¶¼!”*7icÂ=GÍ|ѵà½æop´.¡Ùeé*ËPÓ•_jveiè ‘ÛAªçèDØ3îò#µQ‚Òá<=ÜSYg6Tš–ÇÁÒfŽ'+ýÎA}âêE.òýˆ(‹ü‰9Îr矛\2 PÕg ¯ˆåÁ‚àÂHvó¨YëàUÈ¢J ãx{øÛz/c+ð*ÖCaÞ˜Ú(Ë9UÑ/U”ΣU{-°fWm©í|VT+ Öš´—¢xQž†-#­1-âóET,ôÂWÓøØó–b¨7EY:\&§¢tfËs<t{Ý·‰oEÕ$ò*®�ÃüimæKå`}ÿ•éû™_°ÄtŒ"<)�Çï泧è}îX“@­W6Áµ/,P¨BôÕÈ‘ åk]²Qu²Ç~×ðµADH¢QÉ ÉQÓ»Ⱦ¾»š×-UáóÄ.qoé#—®‰*’V£)ë[«CI(ŨðÔ m„~¯cOü:A&ìéÓW2óbÉÎ:¨tªV ÒNÚRØœ†Àܯû°N‡Oµ Ê£æ4¨>µ9„ Þê¶`ÚŒ7ü0âÜ:¾^šôà€³´rÐ WÂeZ"ÿðŸ%,ÅEÎSþñ/§8ŒªóÛ ÓDe•%XPÚ(¹mvuxð0|iµvk½V*IW˜™Ñtf±¥­wÿdzcçÑ{2 n”ºÂzzø» hlvÜö’ùM[zƒî_z²Ê¢¢‘K=úSQ*'ì‚}­ð˜&7†(¨XÎV!8÷âºs¦Qzýêb¶÷†¬KÓ²‹pge#ÑvÅ¿1\K¼² TäAZkŽ³Lên`´µVZ+»ŸýË¿±ªÈÓÐÆ„ØÞ ÄÁSim; O–¾·ãœÕ¼J÷™ t±¤m##qç*÷8Ïë*HNëF"Ç*«ÉÁÿµ¿(±Øz¬WoZ<$ƧZË}ã¹øб¸óˆroô’ckWUâ¸Åìt69ªaô{*¨Déæ`èþµhmu¢Yê» /§Œ†HôKÚÆ£?P™ûÇ#Ús³� Ž• #ûâªðŠ†2 è÷Ÿ)δí@úvâ‰óX Ýñ!Ù”B#Mɨð|´¬ý*ð•}ø0ø \xd%03#•=O”R„ã·K¥#q®w½¥ƒ 1Îý¡——ª°©íj –Û1·U“Œ[° D¬¡ï*‘à]>_ÜÒ²l/ôÖýÅ뇛9’™µ�Åáñ©¥uV.dš¡™PÑ)¦í˜Šµ‡û®qè¨ÛѽX®m™PèYÍEP v4ƒ.PÍ­ºs~åK¸G\xI s>¶è'[«ŠR É\ÿún2›TvW þrÀìùò¯×È]Õ­ÕçC“²÷4äôúo"¤ ¹Ÿ)¢¬¯ƒ×´­õkYÖ4ö´ˆØË}['´"5ŒU9ϘŽ¯]£åýHÒ;Ê*‰ÆT*†AØÖ¢rÅìØî²`ÂP‰cnÔK¼sYZ°/>9T¾(5<Y-¯s:é «`t#_ÙÂÃl/´®¬Ò;æ–Sxn<–¿%*®ã¸;�çöŠ—U®gÌXÅvHƒìØhDyHrv\Ú7;0öèŒEÈ$ ¾fZˆñÖðÂ’ïB[Ó]V_›#E;ùʧBÇE»wjf¾^ä}­‹Þ857l”ñz–FÙ’ž,Dÿé-’‘ÖS ñ.ÂâBdþfP¾¥£¡VaaVŠì„/dŽÌ_ëÞÚQf¨Š._³(ÒxðúùcÓÆŲ~Éù;,ÒÛ»?|Ì46 ™v´‰&ûl1‚ür ½s×Ú[÷¨“¤á¢T+ÀÔÂOM¤‘ôö»ãqG§±¡Æ¡CÍ£R ªM•ãu¦íÙùô;ZV¡a°;Ò.ø´CÈŽ)ÖwÛƒFçÝqblþõ«õ8Hšr0Õ¯œf+(ØÞ0fžóüâ$õa˜”aÀ)#:Ù&~Xˆ5€0LÉù¿Î-ã_gX·«˜1cÌ CÓj­8Ap VõØÍQ³Jêû®ÿš;„e±Iw+ †MD›O/æRq @îAA샗ěìóù¥©øö1\PÖf¢­œýa2¼ó}Uoô7‰bÜý©`_‰Ç,Ȭó3(Ü›÷T1yÀª ȳšé•ô@Qø–l°é¡À–ýûíiùÕÇ#Ó¶ìóè©kpqN0è]‹Ö×Â… ÞëÏíÆ¿ô3ò̓׮1Qé¦v2ìbŸÈš«ãø«bwQ÷–…+/BÜ&™ÅN–¥ì$]À*¿eI”……jTGi\2~ºôyµÇ“Žlê“PÊèý'Ô_ÏÇiæ§Bà®PüªÆ­ëdq®Í>¾BÑZÕN„âI„}#gtl¸}»#}»±¦›¬ƒSûд¯nÚ@èá:,Ý™H÷(Û§ ‰r¸¢vuV…²n׋ ±´Á5âþWa7ÉÚçt<hÙ·³a#ÃàòÚâx7¾‚Çã=µw`RἆP¾ñÓ°Vζ9çN¶¿¾žÇŽÎC}ÁsÈÝT)2„ü*(浧aÒ6ƒb¨°{ôîå²¼.Ã…$¯Vwõ›9Ý,ÏßwQœ-ÀHe@‰^Ú+@5NkXÕ£AIþÌãû'ˆööñ@_âÍ¿^ezè;Zñb¢nÑGÏõk+²i,GhÓ[›Gu$¥ÓYŸ;@õâ‹-àÆa>»¶ËÚ'”.mÊhü'®=åØP ¦¨ sb\¿ÞgfD•ãés„8Ór?~C£îç²­¿˜újÞØ™3Þ¹Z’uÕmBQ[úËÉŠÆåØXó¿Çz7x6½Çšµé )ç9Ó>¹Vx³v˜ì‰a‡é Õ60ÄŒï5̶½~}�¾°3-Î=HAßÎ)›Í®<¶7n·ïnËð÷ÕšVPµíÕˆ%‹RàkÍVÝp¡HòD!ö§:,gpìª úV ¨ZX½ÒÒê½|fiçuÂZ»Á‘çÈE¾²t½æÆsáÆÀº>–4ávR&|{1mǃSŸðÆ!’ˆÁÞLÚÁ« èÑOh¥k̮»ÁhR]•8y±ØûQFqi®uLdmž÷šlq<aHp ¶â³q·„v)yÆ…S c„Ãì55¨Àg†&ÏxŸqƉÏ:‹+Pƒ‚Ê.ZàA|ÈqnÓ·‡¶wÓ<ã+ͱ€RØïå¿ø'Išr:¹è†Ÿ=u}ËïÀgœàÈô”{"M7€C©€‘!-“õ ]™ñÓ½}>ÎŒf|XóŽ~–—fVáB< †M’Åim:Hó�"“MßÕ²ªõB¢ñ£åE>pŠ’hAZ?Ï\*xŒß†é0w yÂk¹§Ãx8ùd¯þ²—DüÝ®_™û9.4º$(¿õ¼îÃñÂ䘆2MÎD� ¶ Š÷ùC#jº–¬ßvèsZ’£ìÃ0fÇùDÆúŸt‰ÿé)¿ýÉs?©\ïQaìì7'zÈQv£ï®ßf‹†ckgc¢ ËJË’Ž2>'fÎV²²§T(ðä° ø¿”§Ž¸Í~?£ ÀÛÜ¢p|‰˜k£2H6sºS]»s âûI&0z±ìÆf±Kƒøí¦ nÎÚ+I›Àï®xîx¿AÞŽ$óÒÑ X°¯‚üódxÁ•qnr¶PÞƒ»yÿܳE*»þ5çAÚª:N§öзVЙže³EGsñ^(+Êù¥(S‡íÑj08t¬a{d´Ïi,ÖòG`Ç@ª4´§ D.M¤WéócZN*ì•­ ù�pA–$!mbÑ5â]÷5C¿ Ó»Cold*l&êÓÛõÖDÈ.ýÈseÊpèÍèwôy&²ÄÇ#nÞüàÞ/ò;?«t t§3«‚6í±YQJ§Õ×À˜$HAÀ`:Ö‚5ï™»Æq”yÀä8ƒ!e䈋B´îkM V}½ò,(¯¾½u¤,j~ȹᢗ¯Ô],aû�9pFeÖ_‚wç>Ö¯,S"§™aý_ôëÒÖšÑåµ´?ט¿Ú×Z£¹ø5Ð=(ÇmÓ¾vÝÓñ;h·hçÓÇ]6o.aþíq÷-õ)4Vÿ¦§ÀÐkz†³q½'z÷‡Öˆ„ ¬å«=<5UŽÏ1…›ÒS¬‰zY“Iμ¼íŠ†ö@Q5+CŸÚkÊ[=áã²Ä}àt«Óúž»'Δà7ˆÞɬ»!íSÌÓ.žpë/DN¬sY¼vȃò8{ŠDì™bŽªÑúÃù]pª¥bóL�´  vëQÕä pTéró±º'a¿‰ôÿ¦ß­ YÄèzJŸ?ÊtŽÜ c^ûÀÙ¶hÁAá+B‡ˆ°HÞ8bÿ˜Fj9÷Õanhá®îÉTäžÓlV5Ó§ª&hôa”0…F·M› L—½{ô㎽ÕNÀõbzS™daÜäžh-:øÆ›Ó ñfJ,W2&BüÈ‚d¼xâ¬xJGV1‰ ªâõ 0ÈæG|Ýù^ý¿s§@dUÌÞƒM~@ˆï¶²&))0Û¸•ƒÉÉn0÷VÛ?4ûa¨‚lž=c^¿—dôŽÞKÄã$¼È£~Ë«ôæ¹ß[áoaRçÜÒ˜q/ŽÀ¿Ì’£ÿɪ…Bx§†rÚo…îòF@“¤s¸TZt¤•%š¸²$N?æ4Ví&eæë"u^nÕ„H‹«�¤uÅÑà™Ìyœ8±ÂûEt]æÖ䀶ÇåC„—aD?¢þ==K"v݃v[mù탘óÑ7.|²hÝMŒ+»k gáR„ª°2¨fåñ%<jX€öð0Ä„vö|¼Cq˜žõ`‚“,®«|Ð)N©«2¥%9óšmÓ•gÊ¢©fº–”“l¶tÎuÈ|Ír´Qü¶ªïÏg-‰¯€ö/ª#J•úßõ¸â0qÈ_n>›Z” Z÷ã¥sç¬Ã̾žM3_ýî1ò}0뙶l:j°×Ûw¥¶ÓÜðUï &Øzv° m÷ÚɶyŽ÷®l·ÏÚË`Ü3Èfò qrÒ‘z½êë–ò„ñ®(ˆ¥ìåÆ‘eèò$¨ê+½”zê²ê6eî­»BG³ h'.ªqä0WÒÒbi¹@O!)”Ža ÚF´s:2*ãvúCÓ4Éý¢”"÷¸…âÆÆÁ ’ÅžSªýÌý�óòéXxØþkhuÈ‚ÐÊÈ2<–ª^JÒJó›wG¦=qZ¯,éÁÆPï¦DÜ ÚD‘ØØ|�t8O(.Öæ4{Âwt`­Ò(ŒÚQæÆÚi¬¥„ÕC+wá™{­Õ–7ÜÞ˜VgÁ‚ÑNMê¼Ñwm’¤_üxaÆ>D›U FPO’[О.§¬Å'4`q¸sÑ ² "ÏÔzNÝõM]† `BºNqÌÛmc)zøÖ,A{°{Uâ æ±ËöH™è¬³ >Uéø‡æE§ð à׫t[†;ȸ,qœ6!^0çÑ OÕÙ÷–zÓvìΤrï’8Èãh/ø]õÔÃ÷‰Nűü³Ó²nìa¸p…9±Ã"W‚Kð*džî¨šfÎVpå=…Ûd«µ¸ÜñyŸ:P¢®|ó|ë“RüÉ(˜­Ö²¾ð*4=<,:̳›:j¥Æ97ÜoÏ =8ÄŽn|MelòíùÚn/ž53Ñý«ÃUÇëd[cÆBG‰é¯ EóÓi‰ÁV{–¢^‚úŸ|jßš9ƒÈeÇ£7q�íÈwV?ï•­!'Êž¾¡Ìüi]däÊÏ=…Ž¾g(ÜÅÖL¯E2ÐÉÆ<ÝPŦ6ql”e²æÿ|Ä¥róò…¤€Út‹^êò;¨Ó­ó[ Ñ"y!_ÕçèÒsN©ê¦§4‰þq× 6Ñ]Ùã#V›ËX:" n¥ =’#­žëó Ë7Ú(zœçM¤ôÏ_À5G%óä¡X§Õ–ö”ÙlÝE<ÌëcBiÀ¦F*f¢xÔMÁE™ç[¨ú8ˆ1††ù’&ny2Ø¢÷ë[$'Ú¨ø¢LÝ€o™à åû£€ÅÚ‘¤ÎT[ÊW¯¼ÔÙë,ˆÖªq²Nôv¢;%S«7$å}¾?ã'æ2Öd8Z 'v{8gû® ƒ0 òŸ¾ªådìÙž„ "ô ú¾xàû}×Åòûç…®ð¡Æ›3=½ZQ®X™E¯û«5)¬[¹ˆYí»”Ê&OöMôQ ’¤ž…(¯û®æ<¿�êAL¡œGzËè»ó‚X7,=gᆴôè&OwцV+¬0wÈaÅ£Ê�Ž)ÚD›î‰"ÖÍ€-J³ÅT>£ÐM5i7+øâ06FæÄù5&#”fí•cã“x^†.óä&ÁÐѺH·ßñ"ïÞ@²eå°S†va…÷¾{Ø6T™ÂHª±˜ja䎽©âÑWÅ^á.ŒmM¬Vº·—¡å^Û²Š·ÉPµBaù¢‚ËqññEpÕ=¬ý-oþ¤ëiÛ[MÖtaæòØ- Šµ"ÃK‚u[ÛÁÆžwu刹r.ÝNV‚™=ž§Ÿ©ôdd!ÿL'z6ÿìñáoòŠ.à C&=.Å +¡sµóæ`"[c© Ì* Ä+¥ýõœŸG>‚žb|Ño­C¼f,´öÞÔ ú^ºvå¼y‚¸9KÐh‹ o:Ÿ@8· 9}Ga[iâ⤠…Ë„öòhí+P%‹9íò}•#õ=SÖ¸PãšR='ŠEýèT˜(ƒß³5õfïÀùqšëhå>¾–Ÿ-vX»ú4ÏƃƒÄbaFQîCL(~ÐûùÑ› Ëf”Ádªõ`çò ¦£Ù¯ÄVËpáSÈ=±ýX »Dξ²±ß0¡G¶ÛÐRîUj¡Z—cå&ø”;%º£0¹ÐßAæðùprfArS–Ž Ô×.ðÙR‡êRœEõÑë^º3k‡ÈÚ½ˆŠå›ë«ð$ÁÅ›äÉïÉ ™¬®¿ P\;åò"£—Sø,ÆÝÒô’6Òé½{PÇȳB•ÑÁýÇŠTÄë݉›&àF¬ú2UÆ™+$(MSèéïŬ›ÐÍÝat ?–ÈסíÍ^CRßIJ%Ó4š­êÝÇ«`QStôä9¨²·‰ÅZ.hIwèËŠV:”«éHJ­Z4ó©€e ²5«Üµ«Ó‘òσgæËÐÁ<©Y[­œVôº¶Ö@v6†L¦]"KTÜ H®Z¨/Óc{�Œn ³ÒÙ8d :Ͷ2·EzPxT_H0£5n¬¢XZ.íÁí<ô±¯Ž5KÌ—Ç*k-™ En¼ð!¡yÓ¯­ÇÜ(Ö´Ÿ¾r ’£VG&]â˜Íâã»*n¶ñÈ+peÏ4²¨æØYsBÊ/ Ó]m)|Lý=a^%ÇýÑ»O“g¾Iñ†¡<oq±­CÅ% ÂY7ÿzÞß}WC®Ì83¿‰ÎÎU Á˜Ž%Øÿ÷¢›” €ƒ€0Ó9V�¯w­ø»ÿò^º2·¬,¸k¡ÄÁž¶dÚŒNDÊS9‘1äYöÓ»,œÜý—8²g˜ŠWÕSɘž4NÓ¼ëlO`Ów“qáe£ˆ›Êé/€NâbÞ™Òù#Ñ{ &£î!rݸ)æUøí”’ w32ÏgSéó@_r+ø: e–L§v½7 uàƒ´EC|ix”&EætI ÌÐÓ£ÞX®qÙ–Ï–‘m*®9tžæË»-ŽDßø‘`*â ìk¨È:€½:‚jXXŒô.Æ~̸²·ÐGR`ôiX«?1$Ø-ųrú|ÔYóÔ-O:ÞåëC± ‘û/JBŠz4E§ÔNÑb0•ØÜø,—çÖËbZöPl«(#—õñ,GÚiÏ<©Aé�ÿ¢Ì;Kw�ötìs<§&zŒ¾˜¶Q°¯·râî5OÌÎT¬ŽÿzR냦}O@¿ŒýN8Ó-$ŸgOM%>äme•| "…’W?kœ±òw{—~¦0“8 cAlù1ó·fQ½uj×wš%^ÎÂnTŒ¬†}QH$¾¬t€�tƒçP@zö™¾eÂ�½ˆ¤oSù—‰ˆ´Øú«úO‰/FÉ6‚ðIÅ~™‰¥ÐbX§ÙöÎìe9 5û+¹“2ó{èX÷´­#GVFÞËxB)cOG«ûðpJål•Ec-‡â_ÄŽ,ÌìäšÏõb]Ñ‘IÉÎqq)«ñŽ å5–1 }½hJÕt8·½«?×ýnAý¡î•Fª{ÕǾo~#&eaKXŒkϺóÔ~pö‰V‚X¦K®²eä·õ‘¿÷î.½ˆP„&#à´ÎZ+®1×ð¹Ë{#Ýž-eæŸ-!ÏÙ£YS[¨À�Ãa‡É:Æ–èå´=ñÄI (j2Þ‰ÎâHÝ�ßìsEžŽElôÃé¥Oß+^¢îïa&S¥ißeVzmWVç¿@/:–y ¢–׎¤×æºñ­¹î;vºš‰à…ªïŠ£v²Lº¦â–óf]WEeèaT°-™rEÁ ´U#’LйŽ=wvŸÑ­"n•$úñ@ë­°vRQr 8¢S—ÞãiŸÕB 9O®ú·™­÷g÷gW[Zyt+l|Ì®¹v4WašiFê¡h,æDúÎ÷Œb|›Óšzþ­nmEr ß±óÒŽºíúg·Ð  ýâ/*"ß³RG0-š>¶˜ÑñœLë]>M_°Šäž¹üõËï¢ÿ)³E>> ˆ5Î<èãÁ¢Á¡Ð¾ñš ¨îŽ“Ožx %>¹˜’¶7¬øðb ]a<Qè(û-·Öö�/Ï}ãvoðÅ]”éÍ™Ižù˜Z¶ÃH1¬G×°‚@ÛóÈÜ„gÆT„·É‚oôð×èþPÉ ·õKqf9MC(5>Êb6Ǹb…9xÊfQxöÆD©Ñ¨;ìÿõÜÕP{w#«IªýÒ{~Q/Úôi0 ´áú£GE42ÄÌd1(­7ÌáîÊ,WŠÑ$`¦ýÅkåSîý%†Ffœ¶ÌáØ ÷]2žÏSTA³1Œ­¹]½už,”­>.ã%%³ÙLCûìÌp^È•Ìá‡Bó·†þÑïx H:š" ¦Æ ›ãF益yäáàÙ"kú9ÄL;c>a Å©T»›–Ý K*D¾võ+%ÈÌ¡äJ£ "X—R!§ê6¡0J³à-áÁti”Òv¢ç»=›YF’¬Ô¨UPUòáOÇ#-^ì`Ú}ãæån_.¼&èƒBƒ¡¿ŸZª²™TÖM¢uaåÞÓaPµ`1ñ‚¶kå¼u­¶í \¯õ.Éü«[A½Ð@Ï·'™ì™ ™Š˜¦X’·´Sï¼¹–´ªWÿÄDõÐsÅt¿Co@™,5,‚,.púÏGjjÙ,ÔQñÛ�Ê8\HDÒŸ¬BnÄ•˜u˜$¥õˆLï`JÏý)ASÑsø´µLÉB~,äÜVéêw|ìŲUóË5%qEõÖà, dqI#]NU7'5 >’;qt}™»–ÐPñëMÀÇæYÆz­z¤î -•Èz*Ú i“Ѩë4짣ðææ¸oÑ%]Ú‘¬çv0u6îÔ´h0gõÜò(V\ŽóG7QÌŒxÖ«lÏsêÙaJú烞þÛaö”Z¼e¢íáG ê¡9 ½é¬CÏØ¡ ¶<:<‚ «>rá‹‚þÍ2N2‚É>{1A¶>ú¤FˆÞjªóë™sDÏÓ�–"Û@è혒ã¦H(Z!˜.bVy¿3xúDgÐõîë*å¹iÔ‡¦b:Ú·ÉÏZ½’�/:ÓíàgnL"ú šqøªôïDrš„>p2§ÙÓIó`ËÛ\eMgõÀL 7bAf PÌߥXjjG8‹H³æ6s¬èdä +ÈÅÌHOƒ+Aõ˜øû F*Î= W¸œã<°æŒÂÜwg‹�Gå&¼Î>€MW!51Iܵt/5ð¦`£/ÊÏèöB÷ÁÁ##Æ›më/Úto , m¸,¿Û×€’ ôhº‰sÿXç Å‚ÎÚþA…à4Ÿj ·¿Gd{Fi‹ å!¤F¼­½$A2w.Q£ÿÖɃ¿�Gq{í4ˆ*ÏÀžlHƒ”‘¾ç'ÝÞx¦¹o aÇ6NŒZPʃĪfP+¤âý5E7Ó­„Ñ»’³[^Í0m+:LÍ(œŠ²³Ví†2üeMß"TDi¸€ÙGÌJEQèã Às£Â‹ µŽŽú15ŽSWÃ�9Ì–ÞÙælHßý˜©ŽËF‚¢ÂD¼§¨ã!Î9vµ™¿aüns„é4 ‡í@Іï.ããÌ�ÌÉ`îv›A]Àz—¤siR¥Œ,0t$oxÞø¾tìñ5l¸M3A;±H-‘äT? õG¬<mÿeWOÜÕð°n¡ÿéÂ<-f¶ e>Ø=žÇk{¶~>õe¢`%Õ—»ˆœu®fè_ò…A»„´ò?[ =¦#}E…… ã¹ øôD�M2–vŒ,Â9eaá–ŒÄý¿Wt,ÊE%SPÎ £­Ù‚Dy[Ï;D²L­.¯òÎLÛª%ÓÓ2t´Ã kï/óƾ¿tS@it;wòï¢)³; Gg¾³tò@¢\�ÇßsÀ—ôWPý°ˆ‘QeŽGý¼.Ò6§´j˜ÖJ‡UwÍdŠ0˜AóL‰£‹“íÍc.óH� \!´ÐoÜ0x>ÐyÀÜ!{&¿­ráÖ”Psá1K…dºnm ÌÙ±ë¥óa~E³kŹqÖç­Dl½@^BYO³¥=Uuž8z·&ßtîÇ…~ÿ«âµDÅ‚IU›>‹=M$y†NLêç„„süxJæ2×ãg@Ñ™þò¸?Û¤×^»æi¤æïú×µ…5RF=æI·!(‰| púÅóñèÔHYÏÄF5º>[EïúÜÕ=Ÿå; }q*»šœBµS´åY—Gïw/½âØ)˜!S¬Þ×zÔä€Vîö‡yK[¶³†9oâÛm+ŽÕ‰Ñïìü¦æ‚JðþRA#‰·¾ÕÀ3ŸŽnyÒ³ô%<ìãož±c“ !+%ý½zaÓ·Cyö?“¸ÇêWšcgiæу O7@ãåSCmƒÎõÍ®Ÿì*ºÔ\`›Å˯×RrÙ"0˜vkÖ«ãŸôuxKH¾×ÞÀû׬X$ršˆ%ÝšÁkëÒ_í ºÓJ™%ø»+þì~ãð HZ¸†7/Õ~¢ûuúÇd D’e¶Â;`ÚìZšx�Áºd¤Žžùo6[l1-†—ub"=gÐË–-e‘_?Á¢sN‚lúñdóÏ]ÃÅ»ù¼¿šÔÜ nRšòŸÂm«Yå¬(Õ·¶Ôbä$Æu�¡´zV–´‹c[ o÷µ¼Ã™Yê#æ••ã\@ÕŸ.vÚUvý ®¨…‰gÌ4™4(­¼ (¨ß'(Þ®ÔËóQ;Å5õ„Þ^ÉL5öfÊ@Jnʯf§iÚ‡ôó¶'”[AF£ t>*€þ²ù¯¸qUfAßKÞ'±…MÆÆ.U@/ªÈI/b^ç¥ ó(˜“‚Y¾$hTÁy¹OããJyª/›Yo“L3 Së1”8öEÆhÊŽB^d"1eî)à›Ø4UF3…i“÷r…t¨W´–Xû«m¤Öø‚Çðõ0ÔŠƒë¯ }ùÂÅT\$h!åHaá²ö|ÄheQMç€AA×nÎh=*ÊõEl(·dxÜãaÒèß­ëûºB†0:CÆÅí =ßDnwöI”kÍQÉÄÂ�«âEÞ| ‡³hûÕÖšwßkØêô)cÆ5递÷®”ãáLß.ÂDЦ®Ð_:íñi …<—\Š„œ­ûuTyR$êSžwû#†Gôß­¶”š0‚hF×÷Ó/HU¹#«J7àª=û_0ù5-»²~߸ð)¤ôÇ ìh¾Ü‚< ÆYM:›1`L¢bÁ%(qŠÓo°J60xÚÕŒ;‘^³àcÚ]KùÉSÀÄ©ŒÙšf¬‚êSSB|x±v}¬$ ®DBä®îñºãÌcÕEHzè7X!:P6¹i¦ §õšáðïf;‘YÅc—†"ˆl¶±2´~~‘-pßÐÇ B¢†Å#ëÉq…©²¤sÓ .\s"OBŠp�OÔ¢L‡v¨r7t2X0òµAÙ_–9ÞVj„fiAeAö­øÛÏå³Koca¿K7k u#æöŠb”å±ôþå¯KÁ[HƒdsòÜ`è¾µO9>í_±–$ì ŠÌ¦Ös8 ä8Af%úÞO!~·22•6½K«#*îömÅõÓî‹Âû±tFo o-¿ípMn}ÖM êm£oK²ÐÉÃì¢:¾53¨íÍ$‹ z-cäõì ±v¬ÙKO4⸧e~ôT¦¸p÷Eà;`9Ô&ƒß'T«´ƒ˜$ZÌ—ð2moOyj¹QfÖ´¤ ³ïæ;RžUœ/fy`8GgJ:µÒØ2rÇüfXXYtŠWTM\ï÷¾Å5|¹-‰ô=\¯/[ÓÚ�Ôãw0˜ÇT†=þ~¬)YÚµ 7ÓroO#åö§é/<”Ò©e= )G+ñæ~=Tš~ͱ£$âÓ¢«A,êÁCÑS"Sm×!?^J�?×÷NU™tBWÛè­­k Õ?ôÙ÷Ö’y7RؾzY„þ\],n‘"É:…-TËïì$Tf:tUþé-�Å7—Åè.¸€eŸ7ÞoÿmRÍ7—¬‰qõeIžá}:Ð[—71ÖÓ“tàÿîÕbªg>_DèAŠµÊ ¦'‡“Áº>«”+O†œð푧²þ´“•‚sž¶c�Ѻô¦_wç S×{ýR; 6ÚÓY0Ÿ« ¶µ>æÓbnˆ†°q{ñBµ7_Pöèm§"ˆû“Üåס‘Ö¤bl»µÕpW7C@÷df†vì! ¢™~ŠìôäUâiU¬TöÃ` ©X^e>ÿ|¦#$ÛÎNÁšõ²”èvâƒÔSØŽT mŽm…Fr5YÉMA4ç6Ÿ*4áPC/u::/´¿Ró¯Å6â,áOëD·Ä™„qÂ\ Cö¶‹ç<%³pÌ{óO-ã²’1£ozüÖ 7¢|vIž« [ÅuEµfÐ#@À¤£ÂL8’Úêk¸å¨EÎC3L wlÚ@Üs½5÷¿tr„–m7€™g^è_žŽ]¿)X°Cç–ö–½áLÍOˆš9Þ÷ZûÏÇj ùU“;È()Ç;ÿµ4õxá!ì–ãÏÙÛ +�~8Lp Ò'ox+çÚÔN €¹Ýž­ú]ÆmÝTÛYìy7³FK͆WpõâUbŠ‡`¢­š•P׳§‘¤jôoö'õñH·“rà0sx?Æ*`I\A)ëÙS"›kÌð0ƒ³1Hmð[< ûp‡à~‹'É®Ìå únqtš“ÉÒ_Š{/F—ɧŹFÙ:Œ@ÉF°ÆvËu"drýOßýcüˆêm»c™¥*DžøNP „« ­Óì@?ŒçßjÖÈm¸KHÞïð~M_7—[]WKÖ1så4X_ÀŒRäOå,ê´a~O‘Ö]k°¸õ´æÏS$íÆ¡èÖ§ñßNjx q —ëëÕðÆrÖJ#µ‡|™Çqè¡ _ž ÕTO¸`Öðâã¼÷'­H'mαsºYÃpø±ó²ešûîÔ¬,|ãg‘~–dÍTm\´ÝfµÑjL±>Œm²–¥w]šÜÿ©7EP®KàÑV» O"–aú¡³i§Eæê„ ö<ˆkµŒéíE´GͪîþV%>fD-–í& Âõ§idå~ÝÁX:¾7FÞæk@Ÿ@qv€5 ™×dV×1«Ìð²ïè�þþ×ñTx*d¤¿vä,MW£±?z[ië¤Ånö“†d¦Ád¸SÀ<^PqòzÂÓxÄÖ( ¿—Š±h_YÓ˜P±)íÎƺ®‹\‰ýrßÚ°ðý“YÌ!#Ù©8ƒúG­+ŸíÄ;QÈ,£j¯î€Ã²«ØĶi÷'ÛÚäµ¼L÷ûk3%Pè2´vA=¡Üá³öê7ÓL¾îuöÝy7Ý%fÇñRvØô±mB’ö’ÝÁæ ·dšjž/Ý 3ìÈ3<5^3=úSk릞Sߺ¯OÃÊÈAÜUírE„P›šç,?í7ÖSñßë×Û²¡²?ü_´]$³Û‰vç°‹оž{à_ôÕ1~à˜ž®œã…TÊB×kÒFܘû%S¢4àÍ«ð¶oúq”%(*6ÇMaIæe}=Í#³þvVkVu¯Ý꣤r ÞŒÔ0)Ï5ËTÙ…ÉQbuÖ°äµúy9ú #>Ь(.ÚaD¡âw$ îèÒýVE¥7±çÊnÚä< 3)ZlhÁˆÈ€­Sö+ÓçwK^Ö*7ÿÈiñDýS*,,ˆQ|uÔ¹¶^‹k¹©ÇëQœûÝZÚâ &<CkŽ›‰Ç&ÚôòŸ´0ƒ¹¹í†–wmßR0Ê<"17‰!|[}Nã†RulïZc<ý¦úIR.8ÐP­>S\«ü'b‹SŒzÇš'r"ƒröGŒÛʱ÷¦ƒ0ûá†úŽ;%ß\ðFÚþtw~â•3¡ÉÐIj¬u2æ?gº»N"ñþøçÎÏ®g©Ãjá¯*E,TÛcsÂG±Æv|–¥T$}Yææ›Ê`‘j£EìJ ý] ÌÜŸb±8ðˆêQJ™_5_¢RPÌI^*§IiSšÒ¶¼1löŽïRvè½s¥L+–꧒R÷±ö¬+ÙRÆþ5ŽOŽñšj±sdÝ3„ƒ£õê@©¤…¼ê0×{àÇnÉïU”¶Tˆ€‡wh§C`¢)Gg]ómÇ4TCjúàîY÷1Ôÿv÷~tkn´ô£0R„tëgŠ¸§?}DïÆÊB(`Ïeçò»ÇéEá”.b/xÂø@Ñù% ­.¨ºf=‚¥¤µŠW/t¬£°\èT`YQ3y¤pˆ”³z‡Et«"È#•×óH †c5C O—Ë#úE7'ƒPït!Ä£7¡a �)‚p£í;ú/6c­€Ç*/ Ðc úÌêÿÎ1Kq㌺ÚÓBªÖ'óË”‰1¢‘ Z k}7îVx”Aô|ŸÌ’©JŸƒ·q:eæÎÜîêws­:7¿áéÆž"9Ú]à@&æ1(´iº‹¤#›W’T™9VŸ˜=c Éÿâ×3C翬N¦T•óñèòçó(ìoµègù"qè¶oš ¨zœqÓ>Gž”ÞB ÕdA çݦ_€€”K¥˜Œi,‚â<{í_üáÖ/ŒB—;òÒÕª©l;gŽfe'¶‹NÚ£ç‰\Ó‡e¾èßF;ñ½Ø8 )ÕmJ¸O 4 Ú݆*³­ÍX1uÑ›!u&äþ“ñdE#XåC÷+¹ÿÔ³,`¼Åj¤tÔ… ${ª™u¿ß‰æþ#‘“¨H}¹›4¦ï‡yá1AÿÕDZ?íÙZ‚jvî/^l4VuN´<j”£ .™uPäÉìÁ‡èrÊ  M’õ”»žRÚŒ {òÿj,q=éλˆn-ÅÙZ-*£¦'h9“žÑ§ï'>DíÅ£ÎOî…ñ’MôöG+¼šFYM‹JÀ“k*qÀ@; ùêd„¡Ý¥'·i4¼s(œ„A1(ܧ@)|±æ@TuCƒ‘6ÏXiúz…N2ŸÕŒÍ ®ú≆®ŸÎŽÌLw½¾Î³UQ uæ8Ãï,™t¶Ðw¨7Ág½3ºIÍn³Ùð3¿™»=¨¼ :ÍÔÕbƒZá}V ±ˆf~'3‹„´*¥ž‡ÊcwÆкH–æZ™¤PÙ ÒØ™…‡­Çñ(D…ßµ%}§¶˜„¢u, ”û1PLçmïåÂiš.àeÐTô­­!¡ýˆ³Ù¨1ã?“üñ'®B_>Bu }¬³çè„Žã>ŠÐZîâv̆³«ËH,^\–»ÕÊâ}=ÐŒ_dzæn`¾¾á|¡ïü¨k[ûŠó'ÎbÓÕKXJ¤6â ÅàÖ¢Çóqò(O…Ròı¿¸Iö<›Îp§' 6z´«!©ç=T뺭 ì}´ã1ª µÉl—‹N˜v³ýé»^ëqœ-†‚YÐΈ“Óóbfó^[N-°ä™‘rGÖòGÝ”Cêí,ضqª–iŽ©º*&›°¸=Âkèr’¶twÆc©e63£<aƒåØ3JsCj`EÀ‰'+SôN–GŽ#è—=øE»±8öJª0nÔ¥òwæÄI–ÛúWbããÒip}²KÍnåÒù8´»Õaî^Â᪥7$L³ ²˜�À€ØR¡¿5>vx¥ˆ…þ+ òí7sgšTó\B_«ªe ¡ öÈM©„=µn,1ÕýN`$‚§}ôT†ò7‚ÊqX^1¡¦}õÉ“kó;,ÓX„½œNóݬ,Ž<1[6&ùšé@™Tš£‡©ÒU¡Üȸ„Û1þZ†Ë.(º«oýö*»Ò2é°Ž>­*uˆóxõÕïü9ì5§|f–ldr´;…nÈ@¥M:O¾iZ=û@—gzË¡³ZÀÿUÁ¸¡p‘üXˆ¼JqZm#Ô£æ9•g[zs¥¬›àóNIt~†<H·GÇêR2âxã‘°+8å +pV¨*ßþëpm[§üФßëo¥RP?gàTÖµ5}¬®±°iæÔ®ùÿ´(¿•Ò•Û³<Snké1» %¢©ŒañòóŸ4H­’|¦ ÿϨ,hÝ}õÝu³FŒâwtô ©ú4Ä-5ì�KHÿÕNWü›ˆM‹$dÒ Û ~ÚÍ÷Í|êð§îßâ„åÕ•¦T3%i­Ó´^×ýÊÂòŽð)âÓ_ ¥©àμ1¼‘Ú8¡òupNìÓnú².õAs¢¤ïÂ#ƒ ò#·Ãƒp1üBsuSY½ñttÙxBZ6TìpãS_ßQ¤QætÑÏ¢”H3�Y f¡µþª„M"¯ ŠÆpp¦·l>={^ÔÓ½aúc•òªrC%ÛMl;«Ž-9ðjäd{n÷/u÷䱈t°#="üHhxütÈŽ*ñšUÍ:)þôö>Óº%ÇZËÖ ­5g¶¶¯/LQ4oߥ1[É|ùP²seèì&ÅjG9 ÇYn;¸=Xð­t 5OèàL¤_ïå|InÀo ÁñÙZôöa茖0oý´B”µušâÍÂÎS<¦út¿gU±î!6/ôÀfù�ž)q÷Ù'®<b{®þ$,.[žýAÈs”bfŹÝÅM•TwÀ¡KC »­6m]µ®7ÿÄp\I<–N5ô>íIɬLÄeô3CoßR"­‰‰"Æ6'Ï5Ÿ_AëvÉ d¦s0R´bÍ…©§ È}Ù¦¬æ¶ÄîyÒ’‡^ø½9–ð…,1móeƒ5ÓŠÁå5¬ÚàW¨ÂGĽÈgQ°Jl_ÓñxÚ¸Á�ROéûØxWÂúà<×çä¹G€«˜°†&~ÙXËÛ¨æÐtôÌ™Þ)e²r! ×$:HŽvl˜3üágÞº‚÷×$ç<ϲôôy;|Ü^§T¢l´œÒºÞÐ'ÝîþÊËÅR±IRÖ"Š :né­éðc5˜CX;ƒ¾§›_9DDÎRå´±Kk’Ä"G:ép{>IFõZ´<ËN_E°Zƒ’ô©b¤ìBO…¨*»Ñv0^++D‘Ç©DŒ>©Uâƒû,wöô>ÛB6â`e¾=æ®Rhßp§ˆ‹‚­1cpDžnõuEäÉ Ï¢YJ+eÛy7b®ûæ0¿Û!­¼q>€¸¢ô–úù5­!Ñj,¥·+q·[÷i;j/ ?Yhr“Õî*x+ÿ—4¹4¾2ó:Ž”™œç”°¯)½gùúÔóës¬(ô'^QÈÖ#áç¿*YG·,€sýɪåÿÖzÄBEãÐ ²n[|œÝžì/´ãeŽÃ¥LÛù2vºåoDÚ’Ê ·’¸=Ut*vŠÜ* <xh0nRþW £±*ŒŠîÅøy¤c.;)í¡0(·Ýð5!ÿ—i/VØP@a9¨@œ-U9S MaXl#S TÌ“>›˜znm,e@[  ¡ñ¦ìM7|Ö{%àMH8íÅ :pZ.D9Ñ’ž·žc4<.⯼=tHˆéͦ—VY·ÖY‘Õ›´8ØþСbݬòôãŸS`*X_°k�¦2)îò»§ù$òÂÁ~€kN1×2SÚ[Ûæ^·çòz2•ïßVx^·œÇµ‡žS(»a(=¥?ã⼌ÿž?÷ܱC<¨¾Ï(5=*ä¢Ñ!?�Ú ‚×ã¡ãÜ÷tNìîtË“0÷wwó¥²¼ÝÈh@ì¯dδÍZ/Üê£Ì«hR¦Ð&èx(xZ CGɨ¡´+„à<Y䙘É\¾+N'FÈU9ý¥ ~¨·ÓÇ÷©~í¹’VH•y%ë ­œO]9�Üÿ٭攈ÍÔRxu 3¬/´(9ê]EëX%Ñ rïÊ ÞhyÇô­qRˆÚ¼ä*òÇz‚g´-—©× …eLeG¾µ²Ã™ãýVtJ,ê.ÿì†Á(y làúä¾ÉB³Y*Дщ¦Í“,,¯“¬’bû]t—µJcüUX«1¤Ç0:^ãÔõÞ>Ò1îc ÿB02æ ; ŠãÆs8„›Ó (Òƒ:0«fࡽ�Î_B«´³Ôô*ƒþ˜6ZtjY¡?Å^G 8Å¡Ž0X�ÆRq˜ç ™$É}£Ú©ãΠÖoyÜá0mëËdÎeÊᬄäxaÑ ›Jᯡ1”Yè—GO%bs\”QúéñÙ§“¢6?ºv¢½*ßÚAZ{âE\nú"Èl^ «®®ÄÐÀОáÖÜ3ï™">…/úžnðÒЃ®sßÞÕpH3o ±Çí¼d;{^€±wV(CSÎ×àçÊ+çJ3=¦w¤Ä_vK{=ùÍÚœŒãÕ[ãåŸÝ¿~Ý•9¶ÃÁ|¡À§b(q†²¡$)kÑÚæ4@T  ø“}î~Q|eÞÇÅÄ`9D¥@Ð…=Ξ–‹ÊÂ:U™F$ŒðèÛÍÅE{4Í/hwfuüb˜æxåÜžÁ`0‘Aì¦U°ãø#Ì;WN(‹ãÌ#lD OŽº­É¥8MòaQ¾¿Å'»€–…†>)‚¼½xµ×¢ ¥ÍµcÍVž÷TPŠxÁË!Lãó¡€s‚[``Ê Ó׿Q¨Šâ…å ¦³SNÁGW´•gëË€ºTpt<Ý%;ƒl®›¸„-aY”¯ŠÖÏà9›¾n—hÛ]¿ç6ðCÖ"]¨n0r˜Ã­…YØ3âl‹ó÷åVb¿Ib&~Pü-:‚Ên<hŸ¤*4p{ÁƒÁ9§µ§žk‹ù=7 ‡ ô2lÉ�’zD[Àx‘Жކï¶F@·ÎDÞƒ#„ °¦‰ÿÅ÷EÆæ m©ý$s45UÜP‡p +7šº?÷‹§ ÂêDÁkT¢¼ß~Ø$.½Q~,Ü$(¬×Œ“8æJÚgyü=9$Ñ)rf=öÌføö%Ý|:Š;Õz?4抽û/lÊééw°§K‹ÌZÄ'ÑQI(˜’"d°‰;þÞÉ#ϦEPHç)Z€·CFÌK¦Ä¹k#ìðˆªê¨GÜ–¦÷˜Z6}{”lÈSZ©ª©é+³ïÌv¢%£ÃÏ‹¿ó8þCeêA}¸nÇÞ4f#å¼1ŸµéáA[}[‡%fú°¶ê“ FÊò/œú|cNl,nk±y´DŒ0>×YMÏZ3p†* õßñ?¼AªØ|LèV(°1…ŸVš)6úKÅïT½ò—uÿm ˆ=jvàšè„.ZbñzÖ^á}/åW4<c`Z­RU¦…è|XëœÚ-Fœœ+!ŠghÕf›¼ç¸k€Ê_.™<´6)BÕe×Qu*ã£Ú@˜]Œ_Ðt¯ô\PæS%€ŠœƒÆ%»UmTÃ_6¨ãpA¹¤ÛÜSêÿu}Ç5;eX’èó ‰¾›‡fv4œ­ë˜§h�"uMQe.Ÿ–7=²ê i8 OÖÅWß“Ué׉òÄúÔßh„ñ‚Í ä$Z+¦,ãéûž ýcòÚ$Ì e<1¾Ž‡ŠT³6Š8Ðá(7ï"$oˆ{©bðÑ¿;¢ßÛ9.Ú• &}0Ãm“Wùxâ¸îŸÊUQež I4C ‡³ãþïG½k©Vµ¼@•"®ì<9£‘gy|é€ÊIìèXKj¨,H­qL�ðX˜‹_Ö B›×Ápe#ݯ¥"ë¥(æî­zV/µÔn¤meÅÍ´|¹]´‹®/¦)øüÙdÝt÷¦Žò ŸœÎ*iõ¼ÛÃÓ¤›ÅsÜ»º3iw´1Û-D4BC Á¨a­ö§ë¥j}{|è”`cóô÷”bT£ï_¼Úžœ`ýÆföw”%!¸`C¬OEF\ŠˆµMµï„¯GLu:¤"¦Š{·Ž…®ÆêT(40ü® Ã&Q©I}‹3Ï3O”ˆ`çTkKã¼½Ì7)K&‡Ž~º‚ìåbP™ù.÷aôUµ–J²öª“£è÷$¯œ´FÊ&[X&׉3íiì¹ÅÇÝ�†h)|On“V¤åôõx¡dãùĤ~'>Bäå!ýСóæï’Ê1cD‘"2EIÍPa ežF'M _©IçÙ•«Ó‹öhÈ,ôÆæ6Þƒqý fz-ÌbpèPù·öÚº}}¢p51Úø÷Š(Œë{¿‚Ê:MîœÑÓ>Wl‡nº‹eÔðéí½ã/ô­B]fb$Ì€âú_un å¹"'c‡BñÊ ;vù•PœÄqè÷Hw°áЊ¦C†Vï M÷¢áŒÂß–Ã|vѱ@çIÝûgYì*§F´5 ²~v¤«£cQábnÅûÞw×pT¤Ù¶Ï¸Øhî »£=PĬÕoÍiÁ„=„ÇÆÁ&2ðXÚ×Û¯š5yOiÜ;µ·›¼RH}ÿp†=2wßvqeŒ/ ÌˆÛ—žÎÕ I-;ˆÕ·tr½²‘À;ËAÞ:³¬³Lìë²Ñ}ÏîIyÐ1h´hË~örvµË{ šÂÌD©GŒ‰¨,o�ݦ/º=ÙVÄrîL¦épTFc=ªâŸþ‹ÔÇ®þZŠ€Äª”.êh@ýÎUÏ^ª¦zoo}¿<_u®¾¯Y•çàÈ: ÍѨ3f¿l-Jð+÷#ÃѸ/PpO²€ûkæøä±w?Ñ *ë£M�`„2Ûp‰†í‰ææå4×9K±û(›"Rº™}êp6qlãÞœ†M. Õ×Np\(X®Ö}*©5à’„T€C&h\+j»¢x*G¿Ha×è#Ð;”Þå qNzº™/~‡â‹Ò‹öì4øðy¥ÈÈ?\ýŠABÚWуÖEéòZ,MôaÙÆJÑ®VŸX gc|‰GÍ]T©£0Г­¦70„Ìsïc[ßv›[/+, ½ß» /QJø? ŠœâÐ^R„‹b´—*(>gÇ)«Ã梉ÒC3}`¤çûš³î!äŠA)ÂÚb÷&3”Á× žÞ“Zˆ­Åud´ÎmTG«¿”ðDÒÆ©UFe>¡ojÊ™‡ŠðN\TûìÈŠN)a�#Ê\•ŸïDŸõÚ¢èí>´h•È!sh&µF©ñ×â³¥²öÙŽ44ŸšÆŒzÔBV_ýõžûXÌuU~+fæ¤ÀUTÙP*72~Ýo€u]U$Lʈ W5èöbŸÚ{»<ßy×4Æl<0•h K¯­L¸o|$ã…ø'ôÇÐt<*dUÿÌKRFˆD‹…³þ·Æny¹X¢lFëÀim°ØÆÍ=%Æ~Ñb«^9âxü1Q>À¼´!Cd¿ŸŠ.Ây°¯ÏrKONMKçP»6 /ž&™çðݪŠ~Ÿ99—ßÍ[„zžßZ5¦qJÿç¦á!ý%EPUõì¡ÝMêÑŽÌ¢ûÃ5Œ1 ¯‡¥{n^9‰¸’ᨠTeŸÊLcà æÝð²Zw< øó2ÏçÖ¨ÉV ƨ;2YöÙÓ”A„?̶ëþ+§Í"½Ö‡Y}øiA1±ôßKƒsë=$S¸’ïš™6ÛJûK¦Œ«uN7Üê !ÚñIbtUkyz݇Glúz¥:<ø)ÝøÄ;0ÕìðCõ ¹(ˆñÓãë¹q¡“R¨Œ­’ô‰%Ë Eyéb…~ÇaK†S‹CÏÖ¼üݼ4v]týi %Aú=˜½@aoqB‡¦±=aÞiè/8*êAªuî©_½Ø’©¬"V¿ÚÐr g åFÉ)¦ˆÉ'¶¹5´Ô«;CAß›0_pv¢£J‡Å‘âÀ¥Ï#ªÆö.ƒ'ªŠE{9ƒ0Bo´Ý�ªÄ Ðêi”¬ ýAµPþ…ˆHÚd¯vYB[^1 öäö `j;Stö;ÿ«h |`xCæêÚÏ£¯« ëþõHiÈ90ýS/ ET·šÙØ}ýÅ(PTy½ìa¼§5ê_eÜ4Ð|6rŒï‚{]zÁ”ö0¦D„2˜úl§€i`°H,ÌŸ²­wÞ:^á­Õ]µèˆ@™q3·Œ^ -ûšýËf×MâJ¿}ë}Îñ …PC8ê9em<hÙC~Û<Bª‚yJ¹a-ê©ë•Å´ôÛÊ<gÈe�̪Šéìäpé@?a´Ð£ˆaÊ9ÝlÖ{^4ZÊYDeBLj1¹Ÿ¥èµDÆ#Î ÓwG‹:Ÿ@ù]§1I²\TÌYP~¶Vf¯N>7aùܲóÂ{WƤ¿ìoí™Wi2if•ìÆöl53!uŠŒ"û,HÐCàõ0ÑË<BG8ìF›%Œß@ñÿPI8O|Ê)(›I†§©Æ$�m§Þoê¸æNš/t@;BÌÿ[{© Œ6ìðx?1T>Øò;ÎëéÿYƒÛ° zú˜ål=2;ðDÐüMã=‰$ã0ô•Ò1ÜèçE.Ç™ëÊáÝ¿Øí ;ÂPô¯_Ý1Ž”Þ²³þW‹l‰’B“LØUÂŒS@v«y¬á8<ý1ñTÑ…ýE¼6‡›j(ï9«yŸ=9’(³NàRLÈÝ Î½9ƒ-ï|‚ËK!_¨#z6ãÀ=Íi׃cgBy_Ôö[¿Èl±‚)ÀÑ '{7 œ#Ý,zä|3áǾý;ÕÔʪa³ErÞ« ýWô §Qô…™Ã› Js+"f®ê'çIêÁHŸJ©Hj;êùaÞfR«Qô“$ô[ºô¤O U'k1hµµº¿æ†©ÕÑâ›­ŒÊî‚‘ ÕÆŠ cµNKú ..™ëå1+à”z–| :õö2~Ì—v½ë_| ¤B¾PϦó�˜çøólôã�€•·ÿh«ËÇæ°éA�ƒ�ÁÔ]¬êql¾³gÏò{êY™y°¥v^pö˜ôb_V[.RZWAÞ¨¡ ~ [ôŸ(D ¾¿PHx0ñ>‹kOø5*˜,ãߢïÁÁÏٻ؄¥Ç ·¢ðÂ'KLN(ʲVÈ\~Ÿ:ìË%úX§ÛrA¤; çX~º„SÃn²«ž3Hú…êrRÄVø¾@hjúU™õ1ˆªkO1Z;” KçÛsF’mñ@ZÄv ;ËS¤Ãìáb¿jD2ª -‹£þRx¤ Mç5¥ÑóèÚ±} ɯõåûœ>v<MB/Š3¤(›d­RŠ@´,Ü¢ÀK\Ze>D* Ö—"È?µïD›vÀýà$ž ôÀµãÄ@pŽž×<”èrÅõÇ×)eâvòVΪßžÂÔiÔ�S-&’)–’âhï´ 9?ô­¿0;Ïç£ØúaZÅËï¼CnZbôÿË®u2VíáO· †>‡Q)AI¡ÜbâS™ieeY>Gžš€àj%tìnú ^í™ å ã¤«PÎh¹y›žVqæ‰@A!ö+ù¶öl0·‡ã—+‹€Pÿ*îâz�.èãùOÔÚÖjPÞ§ñµ)IÏoT„Âÿ|TVßhAüý•Kžr5­“ÊtJ~{v´œ²Òå=Lx³'r¿±W뉨ûÔO˜¥%v°º¥€ÕMôÇt”¨Ð•*õa¯8JÌžÝ_æx¥”(¶µÛutz'%¼í~,|é cÙd‡Æ¯¢×Q¶H)´A¯$}瘳hCem ͇’ï¹wò[  vÕoka€ßÈ)rý‘9z¢)q“nTñˆ,°©ŸsìÍ´âWn깰׳ÙIQ#5¥½3L<Ö†§|JCh·¹ÜºóE>‘Ï…Ý‘–EÕ¯=èÃB¹§¥eÝõ»”fÏ i²`}`$r΃¢¯]ž÷§pÕ${ÚXxm9™ùN´ ŠïOsK6ÝÈPëΖÖêIÜ�µ.þofV|_ä ¨ôÜ¡ÔÒ ž3¼êH …oËŒ¶Ö×N·ÎNW¤–Óà<äA8¯ ^¥÷ «Ôªºÿo¨"ÇÞcÛö„ò¼³Ì‡"` È@Z9R…wù7­âbéE뎒\*‹MQÒ’TãžôÇ$[º\;:Á(˜„Fð°vÊ|‡:êVÀD]ûPB‡Kræçþ¥a‚^3Bã´ôNé8ZÍȃì{ãÐï#ƒéž+uó™èRœW¾å;ŠÇœlj=áhQD‹Œî­/¿{pKR'¢Â:§0-¢OücÁ…P¸‚œ¼rÏ#†&ü¦Þ¥©žïö1U¢5JÌtfÓӻϵǺ°‚r_ÞõªN׊ã(Þ4HZÛöC¢~bìv„P?õ+¶ú/6{6¨â^öÂxˆƒÕyp¶×é =ïÖˆ‡Üdˆež-åH¾fŒØ¾;Ë@/K>Ù}l¾1ÂéY*ñŒÛñ\!åD÷b«w¥…õ8ÐmZèæ;ª ©À]ƒéX?Zín˜”ºueÏè[e˜èôÔ‰·’]V§¾?HóÇ»„™£Èf[ñì(ó @²T¬Gµ"åpkÄÊÞ¸ÝzýÅxúÙ?C÷3Ó­é˜pñH[ÞlJS  ú~Ÿ Z. „Š!5îj» åõ L–ık:°jHG9ÖÆŽ~ÙÕuWgãbö+Ûæ<µ"Uœ#|y:å®à¡î)Â*óP8·]Í-½ç¸Q«W.Ú4«?ygör<í<«ó,ÆE„Tµ¿†Ó ØHCuí"^ÞÔFòt1PݦqPáá0ík§(ÞìFŠ‡Ìçò.ï™#§É"C/‚¦*ƒò³W` ªÜËÆÆ16Fý‰®m¡Úç.n2ÜÌO ™–\÷ôa-“�Ùë?;nß;;Z·1‘ó®n„ ¯¤ãÖ§AuMaa$š¼‘èëÆu”]3>8�à&QëöÆZÀž´I àêp¢ô)5Lä…áXb…‰€\SDô诽Æ"m2Šýq±³Ó¿®9ñY¯ÍdäDqB?×ßw†H2ëNéÈK©høöFž”JP:_wJ|ÆWO{—iîµxùlØÓ!\lή²Ÿä´ñ+p6¼³mM¸[ôY|žHñ…)Ô¼ZÉ:w¨øÀ4šÝ¦€¦}.pœ^pO5½í°,7 ®@ÙfõÚÁÏ€2¤ 4­ hSÿ ÂÖ?C¸LßéÚ2ƒOƒÌÎMtd¬¥û²äÐĹ'£Yàš!û¹ÑÂЗì£;1NâêÕèxé|”G‹* âÅàͶ) t‘îty0åŽQp逨Qµ¾£÷Ö™oÔÂBX[ÒNZу;KOmg+Ù$œ,÷`œ¢>g MŒ,½‹2õI˜°!ÚgèP¿œ}F <y¬†BË m‰oÏ”Õe˦¶;1¶ææ«¿ÒE)gñøh™iÚGAþ0»îÁïèyäÀ¨aã=\̹¼:ŒS½ÕEˆî!f5°¨iñJ3Ї­C™18ôUPZ}^€È§Ëªæû®v[f¶âFúok^îÇ„ØPŒ¢ÒÑ-TR£æ¨že©á‘! ~H)/—¢È‘“!;‹*!iPŽÖ6 C¸šBë8XòEççj{Ü;NÈš!–H“éñ¦“©š>G¬AM·Z™bãÎfÓìÖahì×ôeo J —4È6 ÊÁÁÉÜsCš ßþ-o¬2ôñ!€ŸîË 9õæó¦@Š6Ýê00 [E=ê´*핧ȱä¦èoõ€3'x"%Ø6¸Ÿ“WÂо|ñÀ[ž¼òbÁBËÂl½ópIƒy‹»î;èO€8^ÑèÞ5<Ž<î±_!IJ[……D’¹ÿ¯Kþ÷u¦äüã8S‚%yI»õ¨:_ô¼uœtWn陣·răȂvÈéÔÕÑ+Z¡®~曀þx3ÇpWwd¼‰¤(fîŽ�‘©ÏRÅýº­Ípwœ¸áxýêŽqC° æ#ÎÉkºö,N=ØÀ¹=ô—ÊsÐ\m:ÎÌÿ[þŸùL)ß½ÝÑŒ\ÓÕ7'®¹5{ š øÓ®÷ü/PZ:¹\û®d'Ëò�@PÓý …÷0îöà”~˜*¤Æçd€ûÎL’jíµDä<Ró¨ÙŽÆ±Y#oŒe¦aɽ·ŠìcŽÍPo5Ó*ª{3r>Ðþqê`Xèôñšúâ]ݶƒ|ˆyŠ¤võ‡bõZuòQ¤}¶Xû'«í÷R¢9¢@á6K‚6-,1Oj€…´¤¹Œ�Ë‚þ�oÜlåÞQ—÷ªk–ˆj&Tð–Ü“8T¯ëžÊe÷p¶:ü3Ž”zìk«"a¨«oY“Ü•‡°hŸé WÀ”7°Võ¹†¿³ÙŠ= 8«èìÄ3íµòˆ‰r—³A<ÄLM¼ãì;pÄÊX²LhÂçÖ|:6zrìÉbþôŸþ°»Ý|1__¹ñfpfGøSKz¤ÇCgÇÊôž\²¤Kþ^6Ìn3ÝFãæ8¸ª‰Æ1 ݃— Ö'aN9ͽ7E,âlaiK»h['Añ=Z‚à­ÂP¤uÄ‘ PÕ¢˜#ÙùÓ\:ržVïuè趇I‹‡Èä¨>Òëh©Ø…é‚Ê`뾚i%y«Ó¤¡œNôægÏú…&nÎ>ÏÜ_lrÆrWbÉ(úÑáiòÀï½ \WEGW¯µiÂ¥•í¡BL¨ŠÌØO½k1f�±€î¢vø^Š¥-tÓ´),¥4{c0@§õÄ´.V÷Y_¸ ¹êz¢z*7³8+ .ÖâK®gýd$DÀ±ul>UN~-ºîs ÷à9OQ �pçÄp ú|_K‹WøÂ%·|*O‡�gF^¥Vï1æÆž4°y#™oÀ¨E§BÏó;L+©_Ýù‚»å)Æ<ÜZÇÙÁ‰'’ñÒãÄ2¦ 3 ￵C¸ ö‚JؘïƒÃ,Qê‰Lúš ˜¥ÂG4ùwã7X0”Bâ"ì€Ç’5Ön04Ç&zA¡ë7¦ŒÍ‚¦¢Õ¿ÑŠ•™ñâ ‹`Õ¤T·Žžºb_ŸYªÑh2XGÕ;W6êé‰fä%ºõ™ B¼1“˜)dÔ'ê<‹¯¢[ßåEoí¸)›„!¶§ ór­µi+¹F5-O„[³Ä"»2¸ûš)̳U9JH &@o͇FÁ9ÛþÐwz´Ù<1WFInŠ¥Õšitš�F2·“õ"y-9ŸeŽæ‰¶†û¾h<Î 0srðô¥Ð÷/d¿#ËhËŒ÷KßC´°ÖÌ(¿ï,cÜ^zùLŠ]ò^‹oÐñLg/¨¾ž:JƒáL*.ndQ`zmÜKä„œC¡ÓÁ+¥÷�ˆÊ* `xׯÌ©'Æüµ¦ú­ù׳¾2¨:wÕÓ±žA¡±ùžô,-mkµ*ÄK–»®¾µÎ妚2Ôéãló¤>ZƒŠ·`|uXm)¯jG·þh¿‹ó'¶û”5>l èŒ~Ý«¾y%Èuelpߎp/—&Uùf/i âVÊê%ƒ4*§Z b§Îz­ô!gÎŒ[ÄÐÃ…;Ë©½r!£H©óv¤2hì­é*)èï¨Ø¢åÀ¤ÛÃäâÀA7…ƒn¡Üù=ÜãF°°ÄƒV)ÚYe¨ÔΛà™ïD[2V‘0?È>·f¤iƾ«Î)5¼t.¢‰±ù[­³ Ÿu½Pi9Ñ[^H½ ²“pËÇú0ñ²Xš§õ ]J4HÿàxV<æk¶qáKÏBÎPêÈÖ)´(o\ˆèjyh%´o~ð1¤~†A í<VA>jÊ"ôJvÎÝaþ_ >((ø—¬f7R(õ ¢¬\ì±8˜¾0xŸ¬Ž… º‹Ç9xSæÖ/¹ >F†$HÚÆ›¢RXB*¢qoDßk!ùÎ{â µE¥m~c+˜vèõèÁ=Ñä‚ZÊbʺZ+Y±®íäP¼Ü¢åoÇÊpþwä |ÈC…ÚiP/ž~ñŒ¿ÕÞù{÷äÙÝñiY™à6PF;øúw”#o‡w¦DÏÊ<¿-[y¹º0Ò[*KÇÁ™RUúAeàˆ ·t¯çËd¾zQX¡e³¤¾âÆÿÑÈç¼#Ìæ+-Ç8 ·§’íT–D/–(ø_{ŠTž‰±ô.fxIw³b$lÊßâìý€ÿéØ4áµL¤B·fpV‡žÊ埳–u`Ò ‡7v)¼·ÆÃåÍÑŠãx3î-DíŸûec0¼Ÿ‡ë5CÝcã²+ ZôÛ[k^Ms…‚Œnƒäf3£Á.uó9¾[ý×qg9¨&ªý§ã¦GOÌJ##·feÑ*èÛ¦A5]¿ÞŠ‚#ýÇ+3½wuýâÔ:rß÷¼.‚b«œˆ²X õJF´ò‡¹[Tº?;)£Hq´©6öô”'Ux.YZxv_Ür@U²íz#½|ÿRÛI‘]›ªauV­'ç$DL'ÞôTˆ²$Š]º@ ”dÙ§92îàô?^³ø�§Ó>Š…A[†ó¿èÀûÍs™º©{É4U”Ö^Ò}SÏŸVZ=ôë88‹üåKãóÈóT@3¥éãä‰; ìÐ0?¾‘˜~‰gvó»Ìø¾N¨ºÂA‰Ïm{lâê…¤yMeµÃ»/C«›°«„l3ø¶V(6´¬AòÓD’ÓŒ¬û¿@GY¾Ð=â>Ád¹º%ù€1ÞŒçQ ðׯžKTi%ô6߶Í`uŸÍß²w{Ä}õ>äæÛŸ;æ½1ãÔ² ·6¹X\«z µöýÞ*b_W½µrªÓFE+€MÜï,fF¯,Õs÷¼\X¦´æbQ˜¶Í.Qd¶ƒ—Ž¶5œDÝÅêp¼#ˆ£Ä±Qkd^±þÖR ùÑôuéݘá³ß˜Ç†·ei=(Ÿ¨ýæìO—«MJL]Få N'0Œ(  �@4*Tçš–Á¦Ã†ÍõM&žC9¥ Î_ôë>ÕÕ!1Ö³ßvÞŠ‡w32[îÐzW¬ËUþÄê°³P 4ÇÇaÛíMô°Ùv¼ŒÛÖ)(* ]اÔQûr ‰g€Üѹ£Gv„B…”§¿‡?-fâ%V¥�ŠNªõŒÝdHàÖfñ(ÑKDQ”ä>PÝUsJ\TÀ!Ã2|n�ü®pú;bêqe¾ ¥2`žÎÞ¨“J[óG1v¢ä3˜Å �ŽrJ}ñ&ä·ÙáƒÉrÚZìUÈb^—ê Ö(,œX7´æ!¢­¢9Q&§Dn6ÓùV€»Z"x×<Yê†+Lš*&D"^™û­(ÝÖðFÞÆcq3Zæ™*÷<¯f†ÏˆzßYò‰ý–€íÈÚ£k1IÃÓÖ¡£¢­7Cí)¿möeÑb¬‚F.¨“Ÿg‡¿§·lÆîHËT¾òŠéX‘Èvq Ì< &«&b|öÎl–G¶òf¿âaäiè!_ÑBûB?èS“—„’gËÞ^(©ç/3¶3RügE‚zh)¹ú’‰#¨Ñ!‹%+ÿ¡?*¯›6H·" ªÍXyÂmê°e]I–’ôÇ5…&>¹n2-*)ü݆Úd§W¡O{1Т×#熫NXEßNG¢€­çñqDcøej ¾Òu¾æ<H-,ðMˆ­™üŠu…,r”Ÿ6ž¤×ìD Ë/^Mì¾-Ÿ=E£ ÑŒ“¾ì;O•D7‰[ŠgÍï�Ý”sRÔó¼Qy}JÀ‹‚Ý‘R¹bÈf }ÊŒþ@;Ë؉=v£µg^àÁ~jª ˜?M…ɧ OÑng!Ì“§•ÞØî¸íȶh¼ÿË"J²|©óÄ$Èwb,3ªÝ¸Ú²ò€É³$ßÛ4sê8Ï%³£Tol´c¦îߤÙ|¯E¼ÑTM/Õh’p!–‰ûIñ½µí:v¦uöez’zˆy6ž¾Ê ê¬é[¤Zz¾€Ê 4”›ž7ã4N‹Ôâl  ’ —¹vù®@ž© iì.˜SŽ«ƒ5'ÊûÉÊ´Té]xaóMÈ:ù¶Úa¹NlÔ‡çm uâ6–ÜTni%ÍÉ“£Û×6Sç¡Þ쵑ŸàÇ 5,œŸ"¨&ŵ3û?Z»‹¶>÷àHêëL9²nh%Äqå è¡¿8Ò2Œ¦^y¾‰QùP£ŽKÍuÝÑNêË[ïè¼ð3 ¥ZœñÓ çÝèð çËW÷ÎM°ÇŠ­1`+–õZoeïØF°Á˨­ØK1á{ëا!pÃÇ­½ŽÔüß57#g UFmÊæ[±mpŸÑGd:GôZQØ&HUfé#U‘³’·»º âË·×¢W]b“�ž÷}Ö©»ú =ËøÝŸË¡ ªF{YE*'.F…h{$ÓæS±6š@0ŽO½³ç"åô)& {K±D ¨…Uõg€ £V w@i ¤÷†½3@Iÿ4Ë°»÷3Êè–T¸‡3ÖüÝâÇ‹n8=ð:N†Ú#m»£WÁlë~·®ìë33ä´(2ÏgdtcNˆˆf;Êá”´dÆz°tÝÔ£´ÒÔÍI ‘Í‹ lÊS9˜˜Ê)ZèÄ_(ªÌ·:YkŽ’ ï“‹ñFêÅSØèheVØýK-Tô¾P9:îó ?*º.R!6•uÕ<i ª…ê{èöØÏn¹k<t¯ìHj¥´‡Ho¥ ( ÐñÇSu™™Îp<!'-“ø•š‹;xkCÍͧ§Ï†RÆf_eê“5Vý·ÂÅέ0æ¿:As„Jã‹&’ ²•]Ï®Nfû̽ð¤8*ÂÓ+ì<4Wa.¨ÔˆîŸG¯ë×B*Ϥ†¹ä\³6p.0‚Ð<•ÙG}sªC�³¡ÊãÙ Wd¾2å‹#îDf5Øe¬:öÒY/iÅâò¡goQú‚ŒÀºVA¹Ý˜s9)ÄŒh©Ðû\Çžo™Aªô•ÙÕQsˆ2ZŽœ]ràúæ9…²Œ3O½!d±ÂøgRH”Xˆµl{ Ð÷õ 5w:hO]„ºZûÅ0˜§BéçFîÉð?IC_Ž &Yò²¡óBÞq7¯êÅ&OûnÞrq};®ü¯ÏùÊ• Ç~È‚ô¬j:1 Ã´ ì¼Ðé T~o©Úuÿ§èŠf¾›v  pÛ“ëlN=<6[ ôÿPëkÆ ¢ÙÒªÕÇè¾A„ä?iQ«î»§ËýÝš<[PÙ �$ƒ¨ñDUVý¥µ^ÚäF!Ã`#ŸF‚H¥l¢ÂèžMSl(Ub\PȤ®ÞŒ“({y²¿rCŒÃ¥·¬Ë tLÈ"Çr LpXö­šîç.«8}ÿÛ˜ë"ÈG@»æ³£¾ØÔp¹ÛûœÜÄ.õe۰͉>s5¨æÌÜÕÿ¢2§<;Ÿ¢Q#m«Ç¦–k™&«Ê&Cï5Ù0œ¾|•6Õíµ”¬û7+ Vh¢0'‰icýxÝhÓÆ’­÷vËÊp+JèxH�m´¹³Îhur$«¤H+èësmý<ó=Ÿ),oNIBGúÚ¡ïð¬øcR!7É‘r¶uÑ|‹¼“•s„Ó€ÍÆS•ÔYs¡]ÏÍCŒPýñÃZH·x‘8^Ì2¢`_™Í>9ͪ{Ÿ*ûGðÈcøÉÝhgJ ;Šs:>×ÒPëèÎÐ[ô‚Ó4øà¶v:Qèᦙ^¹!b]{"®i¨QÛ÷î‘Åê¤| R~´¦e˜Ž«mÈÝðt¨iRµ¡—@^÷8#Pp¦D)¬ w/ wzÌó¨®c±LÌc-h÷ù•Gˆv4Ô˜WÆnñ·o1ÏB£ÜTµ?ªÖz >zN‰Jw³¤Ý¿ú`SíšH±äëJP%ŽÛ‹§Ú*aÆ¿v¨¸é/Z{Cª{8œ'ãùúd`‘zm$I1÷_ô%Ý*ø p;¯¸VÖ¬Ï( ¼fE�+uîK2 òž-Oï@‰}·ÚSÎR7ÞŒoÞîÐdC£ñ:BØß1©×»²9xéRÆ$N´Ò~ëñð D>’?téÕDáeÁQ°ˆ}©;6u‰é1kÇ&MØÿnƒ@}kæ™/PF§ ˜^7šl¾‰ në9Ì·Tö _ë ók»@enÓ FÒŸª¦ÉN® YÞÎȹzhöú×Ïòæ+m AJMÚ“ÇgCœ²·áú§v{è^o05Â6ÂgÀ̃Ð7ÁDB¨›XáQ’û*;fÄ1ÿé»Ö—¾ín¤G!y¼�&$AÛCwTÆ,Îi±ŒÂèF:¨¹Xê[»QTríUŸL……ž›NÔ·5¨¸5?RUo¥¼ÐÜ‚ Üº ¯õÕªExµ[äñQdr<¤aPý4Þ<DìéÍ-_Ó9°eƒ™'¹%øÁIZÐ?è_ßz8–¡ucZ”*O˜TVH&2»~ÊiÓkø*Ù¦wJ‘¿¥‡GiîÎpVÛrâ–J”q.ó]Sgo|›_ïé-:|"äq)8,·„sÄÀ�*X@£E{Vµ<÷•Œ%#¨2É~tŠ†Ö„¢W€‹ãÇ°Ìù–©¢ºè|ppÎXI¤W¨æÛ ŽÙM=v³•Ò›Qé°ˆî 1#+‰pŠh²§x]~ëï 5ÿCËt¬yvþŸ<Uâ§ûVïÀû Õ«Ü*u8ZÑ ë;ôo¶*³.g:ë[ç7ºï„,)Þ[ÈÀ–›d£×½ØS²6ô: ;¦ˆÇ@¶-@H´ÍpªøJг¡|!ÿVd@Dõ[¢Õ›�µ=vt½:ÀBBt)ßmØ{%[üô¦h'ÏT YœkˆªûäƒW×öp°Ý·´Ò¬Î7XéÛúÌ4<íÙ=*h;™®éí ÜÊ»Äm/¼Ìps4Y£=x­wó¿ãárM§y¸b}š¸èËü$Ð4ûö\hôÌßîë³i`Îp9ñ/¥b\ÊáYnZhtÇdõ§³Âã.¬ñÞÔÆ[™Az‡*—²ãÆê¬Å-Œ[à,m p ›ÆíÄîC+ž‡¯wt`⥙w 'w*·l[ ! GßZS`PN¨tn'á·ZóÎl52ÈÏ34·z—*N¹!O¾k‡{ SL <@ÓõÞÃùb§Þð¢UÄHR3œ:lØA®Ûì¦å7wüÑ¢¤X˜­ÄÁ@‰ZÑZw`º1m÷}Oõr_1õù½NH’¥¾L­CJqó"b‰ÏðRL}ÒîZì¦Wà¶*­ªÈL·y/ gz·b£(hfvu³’Ö*õ¦� ŽgƒKƒoÉù•Ç¾æ}ƒô©ê¶žÂ.ܘ¬À.­Ž¯Ž³m½$垀h¼€ G°±Nƒ¤Ñ¤»¼µS(„Îqïi%< òÈŒ¹¡GƺçØÇ`Ù © Ô:°¾Üèi÷ç¢ržbÚKU U´pmODÅ;Ywºasíÿ)ÀÕHw¿–ðÎCßì“èm$ŒYì ‹ª›ºzŒdJ~Ð@ydÃ)ÿ«úòJ_¨bÁG¬‘jÓ(&»´FìNÍ” 4Üåê�écrw+m.O01FÔçÚÉL;HX¹NåCPH…Íb”ø²vôÐ’A8Ëì^:é> „4í|gÞ`´Äžþ –t «·ŒKŽÄf¿‡úëƒem8œà×lÐ axdSMðX’$}&W4”DÎt£¸”7v.ã÷Ïù'G¾5R5îlІHƒìÛÚC²Þ9í{…­ÍãQÜÂ.îÊð,Xéqë4�v Œr¡m²/‹ } .U¼XeBH>GÔs?ª 9t¨{ϲ•“À9¼ËÇE¶ÈâAì|–¤UÒÜrñö=€\¤Î»±2òÌ"³Üýë…”"÷0»™z�e.Õl,1°‹EüJ¦£ôÆ?,©1Œó$,ôõi„†&dQÇ=‚-¥$²;×—‘KmBu•lÖJãyªXM6­›w0±ÅÜq¶±¯™™¥x»$[ä6ôÖÓTy²“t×ó\«zL‘›,~(³gKpà×ûs W&Fmº�o\:ÅN{]ÒrŸ$šy磲._‡Ú+´Çãz½ŸP!7š:Z½moueCDyÄLÛ>ùV¿.¤{Jⶓü�‡QÍà„ÄxC„3 }1u°hèPÎÇ£÷RIiúìrt{ß»ò(Š3Áà,·]Z\Î<¹ö‘aÙËɹ%F3—8†ôg[=,ÐPå <lŒ«Û»»øæVDA2Âû¥÷ePò£¿ (C±ØÈ+äOYø¤M ¡i%sc¢FlìÇa½V ¢æ�õ–»³ò4M$Ôè|P%{útñšÁ$Ž®±ð¼wù<7ŠS§k,NX@<–Vs Ò¤ð7¦ÕõûÿK/ÄÊ—–¦ŽRPJqíž‹üÕƒ?ŒÑ0Æ:è°æ%~'û,ß±óÖÿJM`Áp:†k•Ñ[æüÉ9yìædL˜ÝQ]›6'išÿWEµ74zø«Ø(|€GÏaù}êØ?ëÄÆ‘î­79&¾¦±0nì™z�F½!ÉÐ_üK¤/‘¢¿¿¯Kzk•X×=gÚ ÃûFÑ+GY—%2Ê%Œƒ-Ó~Ž“y4xH…¦h†¸~¾t/„(¢ÂÑcÅ’½ÉiÌjk—ÎèÝ!µ(<œiÉ<àÌG…J܉Î~J*ÐÉêã"Xfã‰[H¿/Fä÷ª*_â+6Ê-*Ÿ^e·AµXÿÃø÷õÜV_¯PÃIéË¢Ÿ ÔÍÉZa<`Øh{S¤™¶^óÕCUyï¼ü%©Gb|+ß*ˆ¿?}ëZW»£;Çq°u‡yzƒš¤ ¯R�9�*Úz¾ß\øÑc›C0|>c¶ßç΋%ÔB0òþz‚ñFÁæ‘Úq_¦Í¡eoBzäøÒ×Óo| #Ûí²i꙲Õ4È.IÖùÏGjò <¦^÷À^x81³ÄôàÅCfP€S.fHÚö…*ÿ+ÿ›¯äUζ…‘Ê*¬tn:åT^ÎŒ�TãÕ·ë+ëh.�â*h€•³­ˆ8T%Ë¿-®ÂÔëd±Àö¶ÎƒxÖêÇ̸tVÊ;…ÙðrÉÑõ©t™o:ÈSƉ ¶äÇò˜ £ %"Ât£iîÞ¿7+I½‰k\€˜[[–ö u*ÿw¼Ä¨ÒÈ&c+ZË›Œq–Þµ{[AÚZÏÃt(ôëù°Á*‡ÇŠÐ0`‡ÜêØy¾ ΣÁö Þ´ÇÕœ/£ Öe¥$Ø1† 'Ssmÿ„U/þ«ïð¢Âm–KÙŽg«m§Sa€«¡çÝíŃó0*]i 8´“ k~<[4Vfª[x8²Â©ÀêÆ,^Õ8’öèV7æQéëôžýD!û<»æ~‰ íÒ[¼ás‘ê@Øꀟ¶Šé‹­…ì/“™u¸ñ¢5j)•=ž§b¥î0‘½  ?~(§ün=Ÿ X‘¥#üòåViŠi/sß—,bçÐFí¨*MöHü¥Z¹‡«Ã©[`½SøØÖž…w7(B᥾\ö¥—¦a0lÛŒ¶Ól[½y`z8ôèy“ÿa}lÆSyò{¨׬IkÞÖiÔ>S«Ml.’Œì<$UŒ£'è*ÃI‹qrqZ»òþW„âÌË)…®2ÇAe?nŒaÇãÂçùW&ÙÑÿ$‰›³RcpFŠ0«‚ºAK.1l¶ºÕ¹­—p¾+_,å�c Ó:?×^ùL™Þš…üEˆ.½GÎbSvOVTD„ÇL!‡þDõJ¾Gx¯ ð=Z€ü‚sET£®Tú¼­öAü*$ãQóôŒÖtÊd¾DY”û"NO* “£’J@ã¤n÷qÓ_€v_µî¿U.}•{ºÉ«? œÕO$Î6N´Å­ˆ±÷<ž¬¯(4C©†³`/@ûŽÝ¸ó ¢¿Åb$±Fì`þ°¡Û_: å;y DYgB;–3=×íò™ÞÂ,ùÊ9ÙïzñtažèKÚŸ]](ŽcÕ¯çÓô_Ó¢ oÐ#ãÀrÍÂ*Á27Ës?Sj«x-ÎýœPÁâÛ{f×¥³éÆ‚€Aô©f•LjÔqWÿûo-0+__zir¶T{‰ƒù\Pò¢ØÔ(0œgO„,§'#Yõ+µ¦¿M›Sòzq§ýñÀÌN¯÷³L„ždDje-Pºó7}ðxVÐܘêÃÌ©ïšØ!^‰u#FÂÞ7wY¥‰7dÆ~ö]„Ö™{¬/lÜ<öG›rÐÍàÄDQY1Ob_ïŒè¹öµÒwR-É GÏKg©*€MDyì‰\n•YgØ î« ¯5òArÓJU]elýòÅÚ熡Z£ò£0C>j£ë1e7†X0Ç:=ù1òý˧µÐÓÍà„kš)YO,´Çéq÷Õ9éG#ÚzsqcI/,Âæ·å·5êÀv”ÞÙ=ó›Ôü8ætGÖÚŸ Y(Ù97¢¢ÿcì#ÕjBCÒ×EÛ!I ±b7;J žùxñ,Z%¡Gîf¤"Ãå=Ä—,=’4¼ˆ$fd‡íÀœuRU#iz›”í F?Ž ÃJQ—_d”Ç­R-ò„Ãœ¬J “gOÇe{]^þÐÁ©¥Ѫ¾²^Ç´è11Ä~™SÿÊdÂêd¦Xm/tª,htZ~1ÐÄ@ô¸W¸|¹é#$¥oú™–º­E zø 'ýîW†àø�®\)ö帅iʱµ½ÙM´Õ—ö&šËš²ðÙ´ÇÎPmbõã}m^¯ú+ŠPâ–žuZkv´J­Ñ8”÷Þõ_2ž±Tža:³ìVw'1¡´ŸzÕbâP«Ÿ Ó‘†ÿÛêª ß MŠ0\š£ÍiPXE«•Ùç}k‡Ë2ø(¢“¤‹”þšùØ=;R™÷íÌG†Ë¾k=»ØXû%QjÀÕ{ºéYói@*Qxײt SÔ{ØÑÎFde#í&¼;½1ƒñä<J}kæ/Ó¢95´w׵ʃҟ~@Y.°òFib<îbE¦±iÇyˆ =˜cÝè÷]‡Ã­q&ží«t˜ï¦ßqè)ÌSÍÕ4t2l„*w´¨Lƒ# dzw¯±7Ž\/V |´(›o·ž årÖÙ£‰œ9–›×+ÐXTøy6\PŒç6<A¥98ºÆ•}Æ+72É|$.½5 Ü·üsÈwjlÄß9¹[ú›ØS:n`­iuÜ3Ö™º«P Q.nWr®·úBg\;.7? uG#.8!£\÷èd«zokiÁÑYûo÷4TTn ̇D»Í‚jR— 6Ñë).BZÙà˜Ñøä@›•ŸÁÄ0Á9\µ73Ór CCÚÓŸM8¾s:_gV]»øç§*ý©ÇIÐHŸGzÓŸ³c©T®Ç¹SÔ#¼C»¶Ä}ŽÅóxæë H¿ÌåâÐ6gÅÁaºÐ}² S–ÃcMÀÑ‚Ò›úÂ-uIv~æ’ïæ¾õ~ –°Ž­ÒB‰"Ñ”ËZH´õøO7ýC·¤¦ÿ–aº=Ô·L¸<OÍË@›­*#eŠ…E9,ý5.U¢ ,¼Gxt†t¤¯·ŸN3Jf7”QÑÂê=¥è~å|ùïõ׶6 Þñ(ðYNeóšØ¨ó÷uF'GëÊ3üå¬Ê`ÀOlà ”3 z²ƒé¤*yÿšK¼Èkè$ï~€û›Ôý#OËé ƨÊÈÎÜÝ]+)’.<ÂsO=¨bï©ž‰V°Î"¬Ö§PÞa;EV¾Ç÷Ȳ+“ðbßëÖ㆚n~‰uqUæÝsdùï"M“/:½jå)æ\A)‹öz´r¦íÓÑüõ > ËÐÃKÀþgLƒjÖ*¼bñ)úüâmËÊ_ñËÌ—E¢»„‰}ÕakK‹5 2êãr_ŽíËÌw²¦r ª­¥`JJÑG=ƨRèSš—GJ©IYøú'à^ôTtß®‰Mç;÷&ºP(^3+9³hùËG±((XÁ@ùÜa"¦qzê˜KnÒ ·8çáÊ‹š`:°s4“ü>ç’i~üÂÂ=r•ŠÈÔ=X~?Z•ƒO²¢ºÎ¸Q>§:Üý2ËúýuÑœ‡WÞ­p:Š¦OOSÞdB3á©×ÑQ».&8ãêO8½s£nºs{Å:ÅBoNÿþ[ó&»ú¬§gm½8É}¦0CÙÒK¦{c®úÁz¦$  è<-© èïu]nú/Qê–~<@(ú%]ëR"�ßàlŠéE˜åÿÒÄ™ 0¢ ²ÎŸZs¶$¹êͨÚí©[¾^ÿ„kƒ¾©£Ê&û4_c¶á¾cœã»¢Â– '\UP`g¾U6—°uë[ V'€£cÕCê*µ*Sôh ”« U8ø`DXD¡öàe´¯‚òûèÐ3 ¡;œh Ì�HÊr¿ æL—,Åá`ÿçÅÝMC°ÛÇ$(6/y!ƒk22÷‡k[KÕû8{*?Tyw|{øÑ@¡ÈD!s-š–KÕuGbcºK0’¶'*ÿó‘&jè}¥~òŽøÉRÅrj#†F†ŒyòŒ˜j´Äacção±1 ÏÛM\ªæ$ˆ¾5âXXfþ_‹›‚¬C:Fyå|[o-\æŠ)E´W#$”’¹T”!6¶*_€8ó]a³Èï03#Ö8¥±¹hê2»Œõ¶ÒÀ·ÇeÞÊGÊ$ów÷¿Y4R2o-±"jäx´hHñAùÜR×^º­?Î( )îþO™nà¾R´96tXGµÒšÑZ3UR€m}þ2ê�lÙó½ÔY¿Ã|ZÆ€ÄRÚ1P"Ï»Ús\ß 0ßzº_©?v(bS1ð†Ç º+‚¢Óý±x8}¿ÑjJ³Ð'"Ò­Úîw6/.jƒ8\…¹»¡ù>=>È2'ñb†n5E–½‡”~O¹[¯ÚÜæ›'|U+-›‡;ŸÕFÃTý¢ì»ñ›CoäK` Þ¥…e<E—^ç„[gý”Óy`]ÂÄBóåf­¯'‡Bâ8í¢‡ŽéTôY{¥-;®[ëÑ×C©Ø*V¦±00dè6Î6¼¹ŒF5—ÂŒMûÚ%~F•ð°ÍHàs ßU|ÿx@ ¨}ucgù<oië#„O(’©Ì›ÁX±ü^ý;Šäi¸�è°z�}ðü4ëûªaC[ðÂÞDZÆ9ä[A[xìaWB*ËÜÒä¾½´ñzŠƒ*„ÁDOôó}dŸÙÉ‘1ºQÙüõ…*™fmâŠ@ïû™ó@Cm·KBÃ)GK–€{~åè"¢OF¡ùÐÓVcfiSÃQç¨ £·,“\-Ç›Ž#õfQƒ.mµ{zJmƒuv¦'Þæ¾¥œøú²t§ºcGuõ‹Ygàp^Õ PÈqŒó$ëÏ»t"¼‰Ø]h |v7{êëÝh©&5X¾,…,Ï<Á+±§%Ø­ër¿¢®ì–*m™]°z7ÛêÍGÜ{=â3üs:‚z N¶TSZÀC×·¨òc/P=Ì°X«4%L¿*Qö„α}ï ˜|4¥¸ ²é_#Jž$×J?S}Æ­pØìW0íhá.rä}]1üÏt:ž0kåUÓ¡L}M0èj e~+b±CúnZcHµ;<µ÷lêÒ8ôÕf M·Åȸž¬¤µvƒ$ÍêdŽåq� 9"«I_ìjL—f¾ ½¹Ìfõ Xu”X*b»ÒN]¯žÍªÐG¤²÷n+eg~öôG)…@È؈­4z)öBͺ=±~ \Å*GD¢Ð7uÖ±œâˆ9Å$SQå™å<LGž¬3V‡Äƒ#dØŸVBÉ4¢!tb h“ÐûXŸVwi«¶XËT²oÊó ¹´Þâ㧅B]}k>lÞÃÚÊJŒâCh°%Lb´Ú•ÇÃêˉ)°ð2'‰×4bþÑpLÓ è­·s.†¾¿˜¾Ñ꼇f ¬×uç^Ñ­ö«@èÅQH,¾;o¸Å0;ërÓ±´øÛs Û0Rú£"Âz0c9kFZèâ{Š„HC‡±`Uív‹¬ S0…ògmÙ{«”fûJ5F|8¦Ø Œ`šðN•ö¤\àœG“ˆI:–s´ö{WÕ=ñÞš;Œ¿Ÿ=‹\ØÊÇþÆã/]vaÂÀçd<Ù‘Ÿh1ÃçMÊôÄ+$Î]µÎ„´ž6G<=ژדÊ=ß*ݪòÜò Ž£ØÑ“E:éL7!µ€XÕžirDOÚ(•ô AôBËÒtZg|l<EmTÁ·ònþ‰ã0”ð2¥H˜¶˜KûæRKæòß»²å^ªÁÎfÇÝ?Ì$öþqL´Y4¦4L×0¯ÏÕ¸’¥Ysç´,È,ì¢0N»³àÓ~ùDºg™–øF| Ñ`ÿ·ÊèŒu'É‘åÃÝï6Þë?úâÞâµÔ^Øéìú?r/ ±mŠ–ß8µ{á,d‡™f¤ìÿG‰SFX×ÐÇSËßÖÊFÚ@ëÝÕ£b£ô€F¼¢Îkp* AlÐå0CV =fúëž-…7*™ÿ(ª#gpÀDº�¾¥óËiq””à‘ š–N²nÕ“–ÊÈŠpB%¢ÊLŒAÏüÁJÏ>ÛW ÏQ˜§Qñ’6î|b"¸U°½¦WEXä­<BD+îÌö“70ñªÅÛ€Ì;õê;_ØÎrz‘<�I¥÷÷8½{1»£Š–ùή%Ú´Z…G@gkSŸf‹K¡eAK®[^Þ+cèù%aj{îè0L1jô“×;ŽXwõZÝLÑŒòúadrèFQÒ~ù0çáò;ºíeétQåÞŸ² ïtì‚Ài¸ö¦Ës°Þ~ì?_CÅúõ|‡2—,\t ™¨’: aÓàKû[ZVV:+b‘X¿�sÕo6÷KTzíE"Š¥qWÛ åRצ~ ½(¯†„Ó!AK ñœô¦JÁ–¡Ð±§kÝ4ª%j>bÇì8².0”ùBËŠÖàá' *;GEªŠ±£å·R«³‹òÞ‘›<ªê|ÛÀ*UVð㈳´8mÒ�”ëºrcù^/Ž}½ghEP¶Öb2¾£Â¯NA¦H¸úöaG6IBOZIŒ¬éÈú<yðUÊFŒNíÃPèý’/ïJ¶Xfm·­À ‡Ñ ŸÅ£™Ù ý¨H*ŠÚÈ/a[ù’ ô0vØè¹bú~P̆ݹ!¡º-fTã—8¶¸X@ÖSÚÂqP6zòæ1+,Áú˜{Õ&ÌD·òú«¯c]p•‹WeÇ£PA˜;ÓÞµ%éî"ä€4õÆ\iê‘ï"ƒ‰Ï‚r<{BèPíg‘B¯ÛËøL}:Qsq_¤kµÕA½ÿéxäƒh7AmîÕsÉJ>Cl+ëeO+Ïò21‚ÕÅš‰¶‡1PNüŽ¹‰§"ù~3Ç«üŬ‹Nª;ê=¿'àq=awÐû&…w‡le滢haßÚ‘á|ÙC³ÜÉt'q²�ÞÕÀ{k˜& zRlÛ*ˆ¶Âw‘“¡©ÎØïz'´½zÂ/ C_ñ=¤dt!x;ÄxÃ>Sy˜¾€üh³[oc�sã“DÙ‚å£/¤§§È 8Š§a±íöÌ{è4˜‘´5%X§ý Ò#+�ozÊû/:ŽÃOí”ÀµjD)Ìæ¢ârI‰ÅÂÙd\½BŠÛÔÙK‚áH9QÞÿë‰÷mÆz·ù·—=ÄGæë°ºí¾¶£<þ¡`ëz¸F1>[zwÛ!‰3ñ~ñŠÕ;`K“BÂÙ„uW͇MºDâu<�2ÞønrÓih:ºáèl“8ö]½.ôw"bŒ³¦Dnpp……ÃárÍì©-Ã!,´Ã‹b¢ã¿>ßsH2_>�¶oû”-õv&ퟬ©¦˜áy˜{&ž�=ófš†nòñèô<8QV’u=1n:Jú¤Üÿò/—8A?3ÉPùP‘Ðv´¼åBx#@‘kÚ'ÿ?mo²Ý¸’l Žq¾B³šä¹ }3°‘@@QŒUÿÿeÛÌÍÝA±SdÖ»ë‰NEîæÖìæb¾òA5ÒÚö †ba¼Döq3©Ö9sEd—ùÒQõë­^7ÊY«#¥#»×öOì4Ii-vº€m_°¢Ì¦ÝmvËKTgqææ¨[ú Gk¾ À3ÇC¿›lôe2[)¹6×ý”An¥"aY~hˆ> ð¬6oæ§)”äa&¬w ~ø»Já&Ìˤõ±>PP2ƒ¸×M»¼C…RÕA¢AùçðG÷¶›¬›À©ßÔîÄ ÿNÕè¶yî0î€/ÅJõºÿž÷lÂÂqì·ÝèŠÜ0nwçù28f2§—ü•Ý4ÞæºàõOÔ„…{ìm ê´eb¸'ž6t|ªV‰…¾¨Êœ¡,at »™¡…®”Î}}1Žk'�!ÔÚ& <7Þšú~¥ Böy°§J±l­^•˜vêÎ1ù8Dñ¯{ 6[UùÙ h/”gQLeÁãmm ÿŠ|½]˜»$_ÌkhjtzÅàsu«—¡;Ϭ›dk£LÍõꙶT_q‰ Óx ¥¶rPZG»éÃI䙘بPÎ/¶{S»ŸS¼Ò«‘bîA6ýô334ËéuQØÌu"ñ¼€þ|n¼ÃOŠ�n™×NgI·(HïÙ^[`ia ôº§Å9 &>±iÛÙÚ Á™¶OÖ¦©W?¸žIœygÄ?%µ7?µòd/{ùÞOœmL3*CãqÁëK½¨`äjÜÕ¿Ììø·§÷Gm˜„EæÍÄà†yŒà‹ã‡§+v¨9Z.™_{ÖF† ±=Afº³«É@O©’Cm6PV1esñ7úLQšúF–´Lg¸ ÛÉsºe•!íÅ¿½Ÿèî+ŒìfwÐ’­UÀê+¡]<¯tï²[užwú€>COùš›MÇúž›|œ¸õ‰óNÂÐ3M¦Jî5<Bö\[…ϦûYé†û<úl/ ­M£äA*ý‰Â…~ÅõTÚæ#…á´\àsÃmHzÀ½"o(¥’¦‰Çe§ òµ£C·Þx sS#Þ¡ }˜ã8‘Qxo&¬ßµVÕðÑÞRˆ¶øãI^¯G-®HFô(¬)# û‹Œ*TÛ&¥ª×Ì×òXe¶0šá�hß{`pGÎõE¥™»ØOŠœ÷««È‡•X«@º%ƒ†i0j*”7¶ñù_ÀÛœ•PdÚ”h÷•ãÆôþ‹xE±é´öÚf¯vûrON¥Df±ÛäAÔôÀ„�שÜÉôÀ¼<˜&qéÜf˜•ÁÞ†6-Š]ØoP‚êcý¥¿aæ©ì³-ë�Ô¥%`Wf´ m›õ'KVxè@Fæ®ÖÐáïüh²B ãæl÷{MU!�RiÂQ&øûwm¡D¡ É€išßÖ=Äýy“×´¥íŒêZ)òÎs’) HþÇù¦1|UŒ¥ÒO`k»FômôõŽÇ¶Ÿ,ì`ä©óË„`Ñ5ƒaá·¢!o,k,* w5Çô–Nq¨2žCö€(!lvxa(‘MŠ’Ô1#MU¬Í¤N奬¦­S©’ºÊ~¹M¿Ô5*,a™•A´QØ125hgزô#³ˆ¢ñJ˜£Ì—€é/݉ð¤âŸt5Æ× 5%Þ7ÔÌJÏ|)XzܲÜÛÙÔ𠤺ìâ´Y®…�n Ð}4 q<¦9 G݀˔N®çeèêöõš–^æ™?¿¯¨�+ƒð{T«(9О­È‹…WèM9Ãj¡ü]~+ø#ÂÙ®t&«×uQ JG>OfÓQ²ˆ$̽‰ƒªûÖa`!çy}~}ÕIkáÊÎ:;+(¥@(!²ŒÖ¦«„‘3Äê[1üÍ}UæC¬(þ˜çõqÐT ¥Îkó‘1”©3¼;±¢"Ž§}ýn{õW/®o{îT9E…eÜP ·j{„˜aœÆ³·=(+2†î’¢¸ìÎÎgÆ~WT麆aŒôÖÙÛ¿oð°XÀÅ}+ZÐ/éÒE†ç™/fÁp¦%ù©0o9Ö–½ Ü/9gÉ5jÓiwöXìeÚµ/óµò¸Ê<}â08€HÙwŠÉâ ¸P‰ûÁYÆs˜q:?b©W†$½Ícpì€îd>p e= n¹‘ÇS±ë.$ÁÇLAµÛšàšZº™½˜…xKžüõþœ@ÄÏÒvÇQMÇÝ÷ªë§ yTBaŒS4>F6*æGÇîlz÷ÌוÊ Í!þ<zð ñW¼fè]‚CôO©òÜH¤CU5EùOýÜ hW nµî?ñ¼Eònœ ßxŽ³K£JzÚ]ÄkŸa¿æ-$éÝDÁp•´sH¡W>1ÔÁ]ý‡UQmù# óµNƒxúã%3Çñ�ad k½Àaïy‹XCæ\)ÕA{ž˜A 1Å~Žín_^î¸T¤ÌŒ"˜De›ZUc±wçÌHКÌÖåëMé·bÆ€qg¤G˽!Zþ72ª<ô»èL ›œmdÄœëî¾Ò“×£6weZʼ.XÁ1L%4n•,ϱ-¯’-ADÚÚZ¥>´p‹þIòГuÆÒÛ”AÚhô-xhQº£W{@Ï.íß’znñlCñ1Ç´äÚÙ â#–4õ*swPã`£1£ªŽ†î99çHÈÓ1¼çŠh³ ‘˜,ꆩ~(>'Ž[ÆsåÂ)œ•Ó0Hß­~/¤˜àŠz<©¦é¾ÅEö•`œ yÄ\*‚‹qã7c¡ëeÄ`¿Ã›ð¶©E´„¸ØŽeä¦"Êy°kºo>‹vyš>Êœÿ£w%D¤¦ä|Þx¢ó /J δ[¿ŽÅ÷}= Ÿ9Æ ¡fZ ½‹\:B»‰Î;açÊäßétìÆéÞ+ÔÁ:©\}»œŽ ;œjÆhÜzÓ1 H¼áñ‹io.“ N¨Ë^…&øX飫žèkïZd×9QGK»íiŒÃÌ“”5þ¿¬Ø­™–êfÁÆÛÑ÷Æ›]÷­g·þ‹‘ü¼ê~wõ‡¦Y¶à§à§A9*%$‹ �ª,Ê|ƒSO KÞã?çi 3õ¦Ý¹§ÂMOnÙ¼,Ì€Ù@k�"öØÛ¥-Á˜Kÿ§Ÿº~‡^ìëÖ“ë=-¦Ã‘Qn~¿SCí׸6Î418ä (áx>¹)ƒuάQÈ£<L¸¡T ü¼X¨ 8 ázŒcövšÛúþ&èb2<_¦é¼ ž‚" Ü4?×ðÂíT2úûCÓp_^ÙMÃižLÎõ¨jÄ<„ä|ä`É<ò>ÌJ›2̘€ë/­7–Ùî³ÿ¤^€¶I@E`JµÔ·vÀŽøt´š±Ì‰þ°Ë"X<²`‹ÝÄ[áT,ѧz€òRÀv”–T¶Ñ’–t¡U§2}{ÍRVä »ÛÂx‚:=ÌÕwØìoô¹W[‹ïù…hžšŽGh¨Ç=ÞºÉæ;ø<ëÅ[±+¸˜ãÊ•l”ˆ¡ðɶ&R¾ýÌ|²oû+1q„ìÊ»oØ€¬ÿéÙ´¯;™l˜é’ôi½¬‰kPÊZn¤O‘Õ*ݪ=TJJêÎÔoÓ®†Úd‚I�MДö…îôS½¾j锘P²¾P&8è„Lb #Ù)¤^ìö m8ÑG¨4?å1å�!&±…_:Âgîdaè攂¿¬&lR¨>ˆ¤YDJEõè+–«ñ¤§·Ma[Åûd²Ë‚y"Öµq½ñ­–­x—WÝYWe^@þ-ÔÐj’!icÑI‘”bµ ʶ¾ºé5ݲr›?Áó9šõ„Ù}]\9 †‰‹Qü žçÐ^í ]4Eâm¯’e£¯ÖGùö,t¾•VÎÝ´%²Þáqh`t|®E¢…XøÌ`éSèZ‚½r°EW½ˆ5â‹ l­Ùleë~ß 7Í‚ÝÈíÆäh)Çœ zxÚjÎ% 3)PLlû%~¸pj£BH?bðßžlšŽÛC'àÞú¿Ô<iþÔPwú¤äμ Ãojaœ²e†Ìéç@IæûGÄ\Ñ’±y:[û5–¸Äó½¦Oh®îTD•—`1T_ìx¢äѼPyÝñ%õš¤¬)ßÐ}/Íì?f^ÊÂêøƒ’`†Ð¼ iP•W™ò´Ï(•Ûø‚0(È­è ¿j~?ïRvÙ-�bžF®j2b:QÆ£Š¤)íYiäÙãëì7üX'Ùš™Á×4ÄA|ì”w—2lÍ}$\?3¶ò<Âó ÙÛ6l_=æS f‚"E¤s¿ñù:va…“Ð}÷RÎl0øþž’"^Y6EReÎQ˜–Íå¬&ñ¬�G©r5sÌà÷=ñî]·vÚÓeê=÷vgÞU Ó±§/E¯r8vÙŽ•Ñ̓5¤<†ìLz î[¹,£Ÿ tòpËÔóž…ò�ÍæS^œŒ9ŸX\Þñ/b'‡(]:ÙƒbºX½?ƨÓb<µ»ÃB@Šï<ò/&X•Ñz£6PH; š¦ôÐIô£ê�}}`©Ÿö�×Ü¥ j:De7Z‡e×›÷÷®>8 Ã…#×t¦:©×ÆIíieY>WV—÷™¸¡¥Lи£ûÛ{UÙ ë5BwxW¯F?Á¼Ã?òÁÔ ü 7̓iä‘[2hQýZÀ ³>ËÄ@˜†vð`åpCþx&fZ2^#÷Þµ=Q<‘\:Ý¿ÝZÞpj´‚ÕPaâÄÒ» ÏÊﻬ{]š™ ÐP\Lœè'+C³AX‰ÌßJ Æa•y¨b38?=Ï)°¥VŠ8Õ1ž¾>›qf%™á$ ,ÎNcb!ÇmÀ•ñÐú/qV–BGgý@µðÜ[=@ÕYÔÏüb£vqçÕƒO˜x]™ tO»¢jzO" ›><MŠ}½áòüqêCO!¥]lÆ& ~lðm­z.¬ņæÂúúE1òÜ#ø$£mЃ­é<E€¥@ç¶u:ù·`¿ÞGŽÌšU™J]nÑ>P¨lO$áÃþXÉý%¥ºÂU°pÌÔQºo©ÐQPÓq5ïÑà Ç›°m}MK¾ëÅcï•É|ìy¦âÖCñbÔ.GóáÈHŸ`C‹VÈŠF¯ƒï×)öNx/5¢”SŸÑ1£n)ì«·…R•Ñ N#ó7牳_f}Ôh][Ñ!£ç¤Ää›?–!C/ɸ+ìÍ2ˆÚž×´û×�ÎQ…g¤mé´\ñ¯v¥ßˆX˜9¡Ûû©@2 =ÿŸ7Àµ$Å,Ä1…ײ&€ø‹çÑÔ¹w˜ó‰›¥2Q|µE`«-Ú83Nœ®·÷@Ê"/y¬Äžé”xT¶êDZC©…IûBf{®Ã@=í¥ âqpñ¹Ýl«–…3 Pu8ºmL’Vt“T1AÉ:Múݾ{ûØõj²¤&¢TAŒõ`–’x­•ŒuN;Ô[ëÈÉ0‡Ý ÍúÚâ²`ñ·J?¸³b.Äæì`†A? j–3\5ϾI­1¼Š]éj³¼š¶–¦þw7ü»†`Þ4Ýø‰§§‘\ÙÐœ¿àÑg[wèæ³2µ“ÜõÓóÁe>~ƒÂn² ,ìW™�åY‡}g¾î¡Þz ¼ÙRÑÓµäCtµ¦ƒ'­5ÇË =Ééºo8³…òÔ¡Ò$ôƒ):‰"gÓ»ð÷õùâä= þ$IK-OQ ñiÑ­Ax˜:S&à·…²¼Õº¾LŒÈèΦÔÂ[—¯Ú…¸õª¥Zí†L ÖÊÖ‚¢K£ÞÆ«ü)wM¢n»­E×½O'] Ôµ"gçn„?‚¬ª€‹Ú—ôw kcÛq[úôþ|Ä›;þL‚Á>ÕùN³+PÏ{~{æ” nÙ»4XЛ³þÔ³Íe&$tNyægJ» W?ÁTr¿›¸A·ZÓÂQKŠgCÊÔÁzÍydÉhŠ­Ž‹+¢K`?áT¿ýî¨í{KÑ•©Pµžö±Ÿ.äaN«_ UE0˜³zdÌ5ihCl](Ï+aS/̲]ÀYÃrO$Ù8c‹Z_XÊ)OKÞˆzɳ|Mͧ%0•tèhÕµ³,á‚ØÛVÅ_oã0qý.ž yÚ¢jù¨7ðtT»Ð_v ù‚ƒ +YM08Ï&ÉËy$7Ìl›ËkÃÚ8KB¯ Ç¾:P8ÊÖ–—1‚/SMY¡T'õq[ôÃWwc¬ µ¸UvLŠy¿ÑP›ŒúC'/„µ¨}9`VU§ã<´.OØl/ íÊF‚QÔ£ 3€Ã´yy`̨uÌZ 7'J—ªõä$-ö;Š0ŠhvÜ·Ó61ú¶‡â[ˆ°e’õ"ˆ»O}Ó åF·ýVOâQ–î Î h´Á*‰ke䬶”ì™E¢ì–_°`,îŸAyëUáÍ¡í6ãŠÝPån”‚œ/t¸Ï}¿íú]°9Óî¡è«ï˨çù¸ƒb[;¡Îà‰«dZ"5¯’:Õƒh¸Ûžz" Ò3pÉÓfëu¡ÑŒ—é ߘ¿ä“[3³˜a§ù&´òîÜßK®äî8ñ¸÷A£²ý$Å5žkÑ= Ë^š'‚c=»0s¶Ä: ”s7UÉŽ6ÎTS‡PRXôœv3}\{ñ“¾.Ì (?íÓŠ±ËÆДÊôu·:OŠz]iÜ#¥’– ÆÇÛ=•wÿòçb‰¢*ô>=Êwƃ0BòwêçÎ .õ86¬ÿ"…\Uؾ&„$ lÊ–Ö—‚Û?±5,¦ qA´ÀxßÎ]S写:ç% !Ô£óì/FFùº˜Ü9‡ðu×;å^= ~~…ÃM£ÅÌîf[Z7ÑçàIƒ¯à¡ˆ4PÕÎl1cTÙw­æW9AQ9F<» ›,(6äËÀÀÎ/öà ; ͯû¹‘ù㉻‰ðÁe˜i‘]±J ÔíWcL ,ì 6½åç»G„_ŽjDï¤sG ŒlSºÇÌÍþQÕDªËÊ(ˆL”¦¦Û‹§N}©|åÐnHäõnX(®ü^v¼ÊM«–ý�Ž½S>·"²néÞÙ©ñü¶Ãäûi8)cœK‡x9½µ¶±Áf䘓MãÕ±[ÏÜï ÍÏMVØAO~Ëö^÷Ö·ôa”�{Ö[ ¼„ÎË¥÷ZG¿­G2gÈT×Ŭ½•AÝš©¿ %yyÛwg'þΊð.£Bä~ÞõŸY† É;åK©å1WàýR l¥›c4†Úuoü¬ÐY`ü<P,B‚_R€‹"˼ÑOMCë¨#Àáô‡Ípãé¼5œ„C„ÂŽJöûv>ï˜ ^¯VêM³½ íO«H'$½!$„ô›Ófô4¨ÑJ¢“Æ“¶ym)9”›éŒ/ê ·uÔ9sÅgŒMNì5_×Tf³ÜçYFRøh;ŠÇ.)‚²ûã Ÿ±ÞïÍvº¸s½^ îç'!Š(5JýÎcDõÖÑbZ´SÍ™ø’c™íkJ Uœé*ú˜Úîçqá¶ëú)$œãüø€¿0•F/¦û ã¼\nL¥‚Ķžr)¾qxpÑ1´è®®©jq™ùòÕT™uß -ŽZÓ¿êŽB© ¦±X¦9ìààðÑ-ú?Wí²"[HþÆtÀÅ!Ë÷ƒÄ×wú}ž&)å=cœé LJ¾žøW÷-Û7X4rJZÓôäˆ?SU– G3DÀŒWLÕÞvýAÞx¸àlí1q(~oŠÀÕåv¬‚¢×ÂqÉÈŸ³‰6ç‘Øûç †w´üâ!™Gà¦xèK: UZ(.Yj^èɲé §GD§<öMÖÀp±ÛU ƒé9�ÔÓ0ÖLÒa[]¼oüý³ˆÄÀ+Ž´Á?/ÎO :Î æ,í±W„�sPÆTUªËh•J»ûª‡¹Vd6:æ¡é˜ËhÂsFÐZmQ²yZ†øì&ß®‚¼k¼ƒÃ‰´ž õãTÛS`Ì‘O2›9nßÝíÆ ËFðŒ7Õ¢p÷:sâ‚í…é%¶ÎðýèÖ†Œ/¬kí †¶ö¤P“Pz³UC";ê¼€-É¥mÉ\çÆ'O÷*”ÿˆìöIGL˜…UD Y›^Üj|¿Mi˜Á à’†u¶¡Fö›ÞSa¿B2lN†iÅ5ÌÃðí«3Ü¿U›¨ÔâÝÎDQ(§埂-éü>öÙd¯aSóLÁfÜHi|Ô~"zôè¬ÖÂdð/¥OýŒßš–Ž=ØŒN¿FOÖÜøÍQ„k©T®ÌÊŒ .˜ôÛ(…nŽžóOÛÕ–ø[ _VXjdz8ïZÀ™®5>èåENhæš«’¬¾*_’¥4+®â¼¡¸¯.Ø»|aÑ„‹6.¼ °÷õìáÉ ®jz;Ó¯\ÿçr)7âª_&Ê# ¢7ñæ<ü &÷!,T=œ©4¨u$šPBë©<àέé]!fÕ“gx„ù#§Î“l©A¼š¡¬fS­ª0¬xZÿ|cùá±ÁÞ´¸¦Ó ¦±ìÓÈ2ÁCÅAuñ)†œ `cöÅ-ìÓ ”ͶD šÆ=ÔȔŠ6o<ÉïèÇYè‹ÙAϵK‚|;9öq ¶æä¼7xg{ŠM}úC °’ù5bA5N³ õS$x2-ˆÕžDp°læÀê°Ò¨6ËýÍ.ØÉ3H€®²Ë ~©,³“‘".ú ÚQ›;h¨C“¡pçY2u~-¦ŒsÝjàë­]‚jäáB:æ’,ok+½aˆaè›LWq=-¾O¨'þ·ìßñÍ1‹igô—oè©O¸‰Ãs ‹RG£Ò ΃iƒêž¤ÙI0¼®Wá¹r8ë š?ÄγГ|fXò@EÒúl Å€ë‹õÁ�j¢aŸ¾kÀáI.XÓ\P¬} –€&“ÆÙrsÝt×D‘—ÄТ8õqÜÒÆ âIA¡eÆVN“‹x*îÝЪ:ö³ïéª<Œ/ÒÌÀÓ 8½;+W^ÖüŽÒSpÍ(Iä8¼3ÏL½Yà}à¤nt(n…ùx0.b®iàÃjÆ&inÜ_b‰²Ô¬|†Kcë‹ÜÐýŸ g¬Ëmu‚¹Ñ¼}ÅK7²¢kŠ@šz×£vªÁ1ᮊ}(÷ÐÐ-Ý<èDkñ ÒÞ")*æ¿zÏy×®NGÚß7‹Ò0ó¦t°{™è¾CD(²˜Ö±[áŸí,@ñ…6}î ExµÛ°†“ kVQ°pªdž;—4æ•Ç"-EÃMA Çøc÷ºJÅclG†M×ïVõB'ºcì>aFé‚âA7›OúÏ‹ÁZpìFpvNê—òF‹F0>?~dèãWVdTì/ºëŽÏVâldÜXGý6-dèLNùyÂ|šþŠÿ÷ÿ¡šý2 ÷¿1ƒ_ô"~ÔÀYäKÓ)¾Ï‚l£AuB&ýÛ¦ñ?Cì/ΗNÐ÷ׯ·a]>CŠ 4MEëâÝê]W¸½T6¨eýÏìÿnU¥ûSXôk�Å=?ª¨X`ïù«£ÐŸ^‹}Ý‹êKrÚž¿ÏætMÙŒƒ¼‰H¯'ïiî0ÌÌ–S9u®mKÇ ¤¼É¯Uœl“L¦þ¦EfòÌ8Ì-ÚS´Nš‰²™ªÖ&h‡úC†9VÜZ¡aÑùô—’ljްPÉï,ìV½{ž XcÛ³—ñ<%"™oÎHËèc.)lÜ{ÒÑ}8B,Þ©ˆdûMo«}›;Ç™©N c@&±²Z©t àGmʇÄ«™°£HK–ÍÄ4Í|$5å~-ËɨüÏJI0dì˜Åk… Äö^4G"[Z¶$NhøìY–K‡Ð`¢cáR5í;ÜôÕÇýQQœÆeYÚŒ•>ðÇ …¡^¡`Ð�^ºól¤º#U,ò•ãç™þˆ»È<mµ§|ägK‘´J§Bò™�Ûk!­©ÏB¥Ié•Šaµ0‹L¥6Œ¾$ýü¶é㦳Úá¯k"î(‰5»2P|¡ßtÒ”+¯jn¸ÿÙõ·õoV–(„³YñØQZRÙîæ|gpÌeZ~�[¨`Ó±fm³ù0e èT{>‰HyR1‚æïÀ¯˜&+îˆ1ŽòErC÷¶†ˆ2Ô3öµ]X×»^ÚÃ+KÉÈ|ËE|TT±E\bøvìö¾ž,íÝâ«÷6*ÿ¸:ÝùùÍaÏ:èf;ð!­tvsõ%hzJ.6ƒy.õJ”ÚÈÐ%ePZíxé—u>Á€Á„ÅwWÂ(Rj;Ð*Ûžþúr£ÚK(ÝX´˜å½XT¬(BÊü¥L&i/!Š u^ ³Ï5ßior' Ä×»¾Oƒ6Së.Z[ÝäÙ)Ñ Š× �¼êM‡|±Døw)•í“¶í»ß›Ò5=“ÏMø½·\ÐÓ²€àкˆUlÒÉÀø›þ*è>ß’U§¹ÜŒ]ß0¯ª8‡C˸ ÓãÈ:„~ªö7Ñݵîlì5í xø¦lõ[c>9z ¸{(b:€»`„¸ÄOOšb›v*\x§W…*+Oq¥W0Œ”ÜÌvøñ°rì,vä†ÌÄ•DŠsG:œã:éžû»a¿J©Åa’î5GÏ¿J—(˜0$S ´¢o^ÂM@Sæ×ÖýNìo]ùq\†.¯¸Ê™‚žÁî¢ãþ)>#-““mlÒé¸ßMŒ§[î]™ºm©…xSâËOž¥±²C6¿›& þ.. a£ºP×R¯h;,ÀP ³•iw$³n2î�ö‡õüŸ7ª\¿8Ëy͡Ꙃ׊8Ï|„ )0+ç£Cÿ1sfÛç¡lKðÇëBK+vn´Ó %AÞ+• çà¶þ¢{P«ÄÉy×v‡c7Üìr…ˆK¦«ü82oÈm�#ôT•þË)f£ô T<ÔÒÏ1þ¥¥“VáÔiOÁ5=jùn^3±LNqi€zGX¶J}yŒ£EÚöéÜzp©©^Súa6ìy·‘ŒÏ¼ÒÏ¡èO~œ=¥×öfÃœ¶£¥ŽkÇ!ç­­€Ï½‘Þ¦´ûH«F†8f´ »féb”X.(<}Û, vý§B´¯ ‚lº08²q:z) wÿÚ·÷züÚM ¹s”½ó øž³CEƒiCq¶îÝâït+¬…�é8nÜ•A€/´Ú¯•Û=ìÅó‘>{÷à¾\L:”)’Üð—ƒÕŒP5'12R¼)¶Ežh§ÈÓŒ&¤k€¶ÄÖfžf{€$ù»cOr¾Ý-ã”û>à%Œ×fNÓˆÂ5ôy~Øgß´ÑŽÏg(gäÚPaý‡ï ©phݱ /ÃmOGÍ᧪K(æ“‚Ç–*ã—µªéãÎꕳ8ÞŒÈ=L†II…t¸waÙTÎ$7Ò†—ÿ­CÕ_‡Ä´Q0­\6xïúç "I4ß•Ì( -‚ì¤Èúä:ñŠËiÛ i¿v¬ûeãÿæ!íá·%Á½úÊ‚b­x;&ìúÕa0ݺÏ*b¯3+m•sM'AØö^Ó¿¡|c;½y`ðþ²ß?è g¾Îm(±ái?ÍéB)¨Ìn¤!—rƒ@ŠÃßòäeäN2îþ±µjµm<C‡kŽ)«eœ àcæn‘9B½éIˆšÊéVɱE°H]x& iEæ/ëQü[FnäÕ¹òǬö´šFµöL„¤Ó9d‡»‡–w¥€Ö’§Çæꊠ¬7^ÍL¹È‡Cƒ/ó,:æo¶°Ë…Xœ1–)ùôíÜN}?‰%´Üó-–¨Ÿ_�4¹;À½•éH7»ŸŒ·£訫¬à’éëRÈÝýé<¢î,Õ]EΩ%7–ÃH'nõ©ù*2ÁwÚ¸G*à5tØ﵃3Šº*])DKx¸ñ'å‹–€yªå¹s¨ÉFýºŒéeè>Ù¸ðð±<¹î¾1q´î¦©š[‹•3øó<ÏÒ‹Ÿ­½¨H® eö ;@ÈÒkØO¶yÃŒÆËiÓjx=2EA7½ÖCGØ€šfZCß¼îN©]m‹xž¸ÌîuÙ×ò9ÁÌ ˜Ÿ}~{6‘”mÖhÚÔ80»wIë;wyš'l6>Íà‘áV 7Mð«¹ö€ ý­³Ãáßz‚?ŸeR†‹y^Ìç*ˆ[5ú8XŠÀÈâ„ <S­­Ä/æçÅc…ò,öKz¼mq:b‘¬´ÿ7µ¤û�0/sï¯_­3ªúZP´iZZ—™õEO#Î.ûݺþV)K�mŸpÃ’Äb˜¤Ëç¨ÓŽ3»¹Ž»o[«>í6G¹×›# à”ËIÓJ¼£tn%¥áA*3LÌ uÙn³ìEÂ]Ä~p¡cus¢e×­GUg>¼ºÝp×H¾ò»é¦r”Šý±‹ƒ²W·–¨ŠZïGJÄV‡VœXa±,VKaGUÒi@c„è)П‹Ì~K•ãÔ¦¢YŒwÐ�tö}Z†j;‹óG5ÝÀôwa Óã6™ÝaYì³P(¼O9m°OGjn´kì»ÂÈ;°¶asWwu;žù’ƒŒáæ Te· ëѤ;ŒXÉPéÌÄ*óh1a-æ©žý¶ðxôë´ƒèÛž†nâôi{vv-#}•eþò€ $’iÖØCCÛ¹lïwþ˱¯ÏÄÔ™òù¨UÀˆs­ä‰f£Un^߀Lì¡G-ä:M2ÇA DBØÕh¿H<ŠÔ½yÊÖQš‚±ilMW][;Þ5Æô—/ÅMoêLÅ¥C–³ÆÉ¡§¸o­¯&ìx—vr¾”«­¡A^_Ü\ª¹(ýFM‚@Ûx Z4Ò–}¥.ˆŠÌ‡5³<C„ømfBaÔ­6^JÙ£Ê<ô"zêŠe¡ÍD.Šk-¸GG1,ä£Cséßa[&>“µ·Ê í,·-R>—Vô|p8£oo©LTZ+«â=D×:\û~û|+Þ�qg< iGÆXr:èYõ˜_K¨Ï힃'[k•˜âM3žj 9ðhBQmäãÑ°{ÉXÃzçñùøßj›ÓyvÚ˜ˆ°žÎù¶?œµ†ù²èbò ÆÃmëNlsñÌñ†TQd†T"]B™¹so{'%¨gZh&†¼âÍíÜ&"#Í ít²ƒqHóö—AD]ti?qÐŽÃÔbÃQ-&G ÒZçE˜Øn,–[Fþz/žª÷¿çjc¹K«h!![¼a@À,RsóÝ÷̯¶ß>¤°Fié[ †´„ΙN =Á~o©2ñÔ–Ÿ!MdŽ-#–ZžZèåeò Ç#ì;9Ó•I¯n1€ÔXS‹OúEk‡@ZTÎZ‹VHb€x;aVÜyá…§^†7�ÿUå­!ùo‹ ¨?=… ßhi1è=iŠz‘wýŸ7߇µŒz_ùß (}#mð·´Žßž˜”µFϵ<í™ÎrŽÅ¶/P9·?žŽméxN;[,±A Gµ§†rÑÕË-eakæ$enÛ´ZÏ£¦¥?`9b\zH{^ãÃ+ª -QÖlD‹è]Gh;>|l_x½Ëô¶›„×x§·Ç…Ïå\cxÝÔ^zëô~Õ¢—!rÿöÝ¿ÚWýùdò]’p)ée‡µ¡Ñ؜҂]ú,’d¦?„î@p8÷T«êBëã[è}( ÃpAéKdð@Mmè£uõ$%6t–¨â݇c8£kT†uNS)õ¹¦ÛµVå¶41Rá’S4t×YÃïy¢ç²’Œð@a®?õ1ŸÙ!xŠ*'°]Bö y °•€'D7Ä¢4æ ãƽ£JkË‹~Ü�]•Ë•Y¤ûÖézB_êƒî¡¶®ÌÌ«òì_m“ø.’6ö&wR¸7|A‡ÑóÁ•e?-ö›jÁŽû&·Ãjθ!£}M½Q/ :ÒGxs5ü±ãV¤w%=}$$·áö™Ñ6ëcHGwžWÖ´7ö¸%üxSÒX8 Z ävž:,DB¹µ>k/RÐ O?&”óLVbÌ£`^„7ÅdîO­=²~)†Êel-9wU¯ÓB¾Ö’Ñ×Z{yfyGXZÌ[˵¶%w·º¶8�…ø8ëÖüS)Ýëmĉ/2@‡ãýqÛªÆS¥“⨧`ð‚Öƒùz»ŒÑÁ B°T`êþîç|+Êø6v˜(e‚^PFÑIœ·¡,‹ËD Rf%C¯ 앺·º$³¶Â¸0@Ï¡9Ìõ°[½M`Fw¯­«w*¹lN°ï¶r¯ñâ–±Ê+^ŒUêp|ltkŽ ¶¦´õçzwh¨ià×’ŒÕï¡®Q¾^Ž…ÙÞÄ©à«8•Ç¶+¹=˜`´a­™é°0ú<2á»Mž»Ž‹Ìs¨¢íÚÎtcÆï¥$EÀ~Õ‹æ’¨é…ɹF–àwH÷,öÚí9²¯Ý¦ ²Æ9«„Á¹€±0Òòp¯¾í(å¥ìÄÒš•Y“(ã+Qã>òiò”¢ë––6E>ØAx“I'øtä à%2Bê‰Xq!ŽÑneUT¢˜åÃÆq·YNs1ÚŒ§¡Ø­„•@Cóu¿A¥ã»ï€Âóêpnvó‹ÀÐÌ ž1:¹3”“áÓ¤œ@pÔôôµYšOTSŒ‡¼}5Ó;*ÙjÓg¶xdó±by–< sùŠ?H!o›¾¦#ïöOÑ9O²e?n*è„ìOX†ñ·àÊ$Ÿi­@uЋܨ\üÔà‰ËðºýÙÑ ó®‚QŽÇ\OÝ×ná/Í*Ï\@Üg©ÇpI« µjšiÊ}‹}çIÌÜ™ÜX6‚¸…P*3n@)´„_–0ÇZørxÑI¼§€èwײØ9—ôë}YWA¿8Ñet:£T~0ÞLÓ/z«¦f#ÓG[±ßJà®Û\çAz>ù IÃh «Höðh”ž­Ié]ê›Ç–R-ð䦡›uµ±gNc ×vC¢ÊKàêu±ÓxÊ‹ƒ¾-ƒ¸Ý8HQÚl¤ gz·Û Ýâòp¦Â]¾z½X!Ý$‘XT—­Ö£I‰äyÚu¿TÖ³ ’Üè„CãÙéY4£Oä.,âëÒwO=à3à@uì<@A¸´â$4DœöÄ­îØý>™•Æ::.Ž × %½Þá4ðNjq¤àÎÜÓ HéEšû?,}NQÖô›„p*F÷]¿ûSÃZÁÜ¿áÊ DÖ#Z[Á”‘U)JÙ›½_Ì@±-ܽ¹yõ#4Ù0¡žÌš'«¨€‘*SŠ½Y ^x:ã]šX’&™?‚L`Nw¢¢Pgª:((`a�w~wìa`ÔŠè6ÛUß³ \’슯Õ÷P²Ú=8Üêa¬ûÞÁõxOÕ´f¼+:Ë›Ýf«i¶÷ ¥c¹kí²ìjM™Sd3§Ü€¯-™`˜/T‡P0·´^Úúmu0 ®×ë[?âCÚx¬^×l)ô@Ý©DP"ãº{ÛSÖ!ßÃ`Ú ¯I‚Uzý!˲ í,Í Rd‡ÕÇÎ7%µˆÈ'W~‡4TšÄ!ŠM«-'*}�aG%¹?”>h½á]ÚÖX¾PŸ�þƒîp¯ÀÑ—Yµ3zþ…ÞOG½Â5Õ¥Îl¶´•;ëj‹qgëšnßi1Þ½^²I2F~6 P!Pie´Õ{ÿïÍbáE¡éÓ‰¯P§ <Hö`wüç~nÀ;´dˆc;/ 9À¿Ì¿‹ Ý*à?*äT¿m(Xìý%0÷ôí™°ZSúží%w¦®£¿årÄ/ö®^Ý—vlXZ¿tJh³÷‹7Õƒ¯É@ߥ1k^äã?@d‡~Z„*¯¥¨2kÒ¹¿Œ¤[]°�ù·¸À¥cGûýc06/žøàB‡0-üAÝ©y¢t?î;Oó\ïdtoe1ñ{¹Ñsû’1Þ™3Åbþ;$í·ÎV¶¥P"úçô/¦ûd÷%jÑ3éEfP—“[yŸwàh7®¾¢‰8d³6à_°u¬6[Ä,¯ÈXù§Ô°lEé‚~ƒŽ)Wë»ý’ýMV^q ›Mƒ75“\9Åÿ {¨˜*P(þ¢péNÐCÄMÅäîªÁ“¹’ç‚V ßÜ´\´sëÿÇò^@ÓÑÞ˜–¢‰·u´Ó"óµY�êéÑ7Š}uSd­Íã‡ý"ð4;<L¬³N þìqòK øÆb]1§m�'ÑóŒ[u«]ïÄZ;UFõ‰©ZlëBådö©ê)€7ô»xþQ½P\_)'#ëÈÅ,‚˜©#A|T¸Ó(˜ÙOQ‘‡7Æ'ú/eÞc { Çe°ÿHƒh«µfzãZ›ã®OãÁ9þ.࡬Å8”6J”V)§œLË¥“ÓÖ¯¡ÕJUüÞñÒqsäÆ>ñ¤ÖÌ\»KèýOµ³¯lzWŒòv¦µCeÀ_ѽr¯òƒ# &UPYk6ävÄŽ'yìçûèXmŠÄ, U³JLtØçæ¬-…ºˆ©Ä0;ßµ•ßpϦ+ÒJéš#< š!9ÒŠü¦=t0ê…¼D*ÔNþ{ÀxáL±.öubU‡< Òéݯtå\…y@žã®îØáØhez)ÛueCïñb°<L7û5«®Ø©Åa¡Áym©øVa~;OÑSJÊzï_œLd±oÚ;iŠ#±•å†Ú£6=Õ(ö:|<Š#Elñ~BøÄ/ÿ(9gõŸÙ ßnÏöZ†ûÒ?|óé|¥Ä÷Û:®V<ÑwV§òwÍ%›E'¥"6yPžµþc:4€6¾Û°{Mz0N^aDÕXJ©ñNðÃz]‹AÖ™{Áø”"Í.c¥~„-suÍrë?6ûùУñô©'´áPe®62ý£–9YqΤ¼’ú[¦…13?Ž–Ã&qœã¿ÄÌÑïLԋЯÇ)ËYà_Ó=½IJ`'í­¨xÁ¬ÞˆE]}û8‘”Þ!’2 “ëÆçÎúÚz¨üš­“;û0€É’4k¡…³ÞÉOf�@±Ê€úFÿ¶ôå§<è)ï̶ßë‚݇ó‡H ú—?+#ËJˆ 3v¤’/ˆ…EIÕˆ‘ý^çÈÖ“áÊ›a1ÚÍ Õ¿©cq¨0Çq·‚_¬Èq[¡Sî^ºÃ×® T\¾g·è0Ÿ;5YI˜½®o:–ÞÔ•Ž¶Èx0Z£àá­F \ÃN{f|ÈÙvº[1Ù4្W¾ˆ0-µéÑâÛ\¼–+–+7ƒ4Òm±¥ÒÞ†a“ ß u$$‚;ÊÝã­>F4Ad¢Ž–%CÎ6‡ÖÛê¿òGÍ"ŸVf”Ÿ¤AÑ*#R~ÊF°‘^nWßÞÍZ*¯ß(Þ$mjfQ†¬'_`|®o[:>0:gjÆÂÖŒ[ZoÍiÚšì„Ò<>a£¶·l‰žÕ‹…6dÛTèÒiÓM¶£Â-:O*ÃÉø w؆!Aâ.7¢Ì³¥m÷]ápe Øwµ¹Im}îwÀ;›Wž¨C ÎÓl4†1Iƒê2x¤i3Oçii·Z! Ô×3zRX¼64TËÁ %@Û‹¦õÔrùNÃj.Ov!ë×›ey#"ÆîüC»…Þ‘¾íµYÅK{8Ywj÷Ó0;wûFò?y½'ÂZ„ øNBudJ¿§6¨êã©Ÿ¸¹h$Ì D×X Ò–¦›Ì²ìÏPTÑ?©×‹Xpt¤ÔçÝâW’:—5#K4)W}"}½2’ö3ÖË¢£7EšÇúcÑ߶FnIðm ]ßweÚ•œ‹*Œ¥vìš+‹Æ‡ê-΄H0Gi°§³ºè´E”Ó2Þ°£¥~T³Ô¼ öo]¤Nf ™øÊX¥L$dL⯠âilj){àÑYu³4¿v÷¤µkoø鯈vÝJÝ,ôÝ£È(õõ=N;«g“_KÛ?`å»ó!3lí>É™ç¼*ÇÓÑ ¼Ïö1Î|]•3žn(mªúµEdK% QTÍ bο¢Ì綼X¸øqÌŸ´&ªùäi2ñ¿z[ŸFLÕ5£™–t!Ýô[.õï‰èMU ¶Î)…Í?vŠý °ÐGŸ`€O.ït€ÍË´Ø6ÒÓ–ãý­Ùu#´eA¨f?#ïê†Yb´¬¤ (™¬lUÂ#ý™õÂYšÖTÍ•¯¾•ßõÃÆ2÷­aaÐ|ò‡E#ÕxÃÊCñ®°cO pW­ØÑ~tÿÒþÕ<p¦p©;º I°§"?][ NµçÝà›Щ/Y‡$÷½iò¸ú&Â_·é3z:ÖŽ/f?êÑ͹€|žÕ>óÖåÏÛ5©KcÝÛ£ˆÊꋇ©Ç ͤE` (%@ïÖ^ðêëkŒ\Tù8ÄDœ9ËîÝ3´» ¶¡ú£Þp€zèeÁ}¢æ•6á»í²²Õ´NzÑnØfè{Çϵ—FBî†þiåË ÍÛÒnßêøÝørÆ1ýçÍ*b+üì/glYúã:Ît8vµgðÖàž;«Q.65÷ëj&­þDTK©ž0(+ ·[¯ÅÀÁØ%_ï®hûΙpe؃Vhãa®ìqÓw¡§Î‰[WZ繓do =L‡òIKo( ‰>ÎòÐiŸ[WÊë¾:ÈQQÒYc)'êMªféõ¼¼àüWVÎË€GàÛ#&ùïkŸ¤™H³w­sä­+†y1êïŠQ’ZÒ5eŒŒG[ÁEbnàÆùâ—ÂðÃ+S.›”î±Á>‚ªÝ8!1öy¶°¡Ó¸çÏ aýÌ=·Ñ¦Ý”AÒhU‹©ç4{8»Û]®›—öþ„Þ &Gvsªè8»òƒS>}æ·Me ÏLƒ'QÛ#º~Öù¹‡_)ÅÌì0ûòožmìû,ÅÌ+9:µ– @:¦f!|xÏŠÎ ¾‹FüX€®î¬dD‚ìÔ&ÞÎoåF–Vša‚6PnZ/‹Ý×›áÐïji¥ž�Zã$ËM·/ßkɱ"ä4€€ò^{™-·÷L/ÂÖŸŠŠÛzDP PdØ&ŒSvç-2 ŽŽHYfO …x¯öŒò(–NÊZôyôЈðÛb0¯<Å—ä± O‘ˆ *ÆÀ¯0å%´<Çùb”âüí_úZ:Äלæƒ&º×¯7„Y=lÖ“eMj¡ºßRYÙÛþ²gMVøjbaô´L£w[‰L¼´¢­ŠÇaBþozÏÈÝ–jY!¨)N„æÐt)Ý‹û¿ÑÛŽ<>Ñ©‹Z%_@í]Vè[Ù¢öA‡n±"S,ŸÍ …Æ°uðE.ûŒ·(ÏZÃú×ãiÚ20ôÔÌsêÌcY‘È3¼¶U;=ç3ko#Yµ¯êŒub™AË£ rÆô“ñ¼Úx~ÅŽðÊš0¬BÏ„"tJ…“w 8ÌK½—a‹rö¼Ó|ñÍbX˜xƒ1FnSv\Ò=Ò®.Åì¹ÞõÖèúéCÕ‚€ ¤8¹a—‹Ãþ•$Ê¢ÌcZSŒÙéGï­ EÐ9LP”Æ/8œáqG+G,^%áp‰Gg k„ˆÞ° âYî#¤\,y zB@DcAÖû,y°æ8Mm2}çjìÅ€ó c¢ä¦Œv–à”jݱ 'dIæ¹÷Ré»ý¦êtœÝ’g{?l{ƒ˜3Ôv£c_W`¦ŽS°¨OKOû-Vš‰¶k4ªtÁÚ/g?Œ±þ$mѪ ¿Ãn±âÃÿ¨Ê‰2í66fIäßiÛ*háY?¬:8 hyq‰h‘©YPÌ…2ሮXCò; boa¤®ŒàÏ‹ãÊ(5n%ä+³©öÀ�›ÃèÆ3Ϲ�…í3ŠÛ^œ[¨«Ø‘ûqŸÆ?'G‘t. 0ŠdŠå¡dêo v:™‡$õDì! È$ªÚ³UžTNî⪑Çi戎0â¥Skî­¥z.ôISxz1ƒwÍGß]-avœ¬“ŠSYÍ{R)²„ÍŸÁ‘ýÛÅŽûuoåoY|i�‹"é/š8C%‰ŽÀãΤ- o¶_sâ§J\Ô”2Fƒ›lºo4¤Ê:y> YÅü|],‰…'¥¥LóÆN) 6’ÇÊ*\hxåÁü™p.ê†MÀNŒŽ¬m‹×Ú<Œ Jy¹¢¡rOtê‹ ^O¤Meà¿L`€ ñáœ/ÒοQPdž}ÁA £ôÖm¬²D›v‡¶"½™ÊÕ/'J6n{!µBf> i¿‡´ÚîØFÈNÝDvÚçYܹ¶`Y·.¥K¯[ò9K�)Œ ƒ(.¹« í4½rø<ŽqØ^ @5>o}bEÛÇã ',À„_¸h´\t`¥ ¸#vÕ[Öñ4É$E/=—ô×|X²ty¤…Á=ÿ¨][[/J#z ¦$Êï¹³¦N:8üè¿>œ!&kãšÝ3Í%wñUR„APqi¼œK+}×7êæ K<oOf\6¬–pôXrÍŽŠS×Íøµ7¢õî²´\=ÆÕà µHô ìùJak dÁ:¥}:;¹Vú�êÌöõ‰ [¤P¼™; ÇŽv«¾x6`RHDHÛÊ ´ µ„l€1ä%cx%ÑB¾~ ù[]ÌÒ3åª8P�Ô7",¦0HéŸ×#ùM÷Fj zóF*ƒŸES³ eŸáF¬ŽPYî;zŽëZÿ”¿ÎSFx¨‘%Ksî„`ZúE}öíryhí{Ögí¹<xMËÿ±2r±@dD8µè—¢î°Í+£ø'¦ÀÛÚtžíŹëϸÀë¸P…Q¶0ÏËiÙE_A:j1™D5ªUä!w€xfòƒM` ¸n̲òljvÄj‚Q3Xå úï:€bP p¢0Ó–Œ'{9­(=”gb­óBÛUŒ0²×ŠB…žæEvrýD™Êñ@™ôI?ZuÛeÆÃûåa¬Î}^æ[¨BÌý»²cíj\Á€QõýeÆÙÙ5zš àïÖÓå~!RªJ!ã0ü<E¾E"“U¿Ü„öÄaóÇW¬&->ñeÙUJ}ßé& aL FG½ouWâPqcÜU$y’™’•º¦#[V};!Yð<5P‰OžMA̾§l$ýÑ #¼'˜F¾ºšJ-” ›ð#CÛN@þMù”k�÷Æ0¨,M,Ž%ëšKì¼Ñ*1ƒ ž¡÷zCì4óhÍØecvhe%IúØïÇŠUùœR•™ïó•dª³?[g ¹ê–vt´öf”ö5‹X¼ Óàæð© 7-Upk¬bfÁF4æ´yů;  Pªa=µ}÷ Ïù�ˆ¾5áz‰éi½|CÇ,ÿP´G+úçs; z Y-sÁýùŠ ÕͤsT—¾«‚b=ôdYš®¹¢>(§j‡y�>´„¢Ì·¢©jÓôÄå¶F^;3N'ÇhÄìAiÚ*˜Æã4æt{ófö‚RlhWv3–¥,ÎeU0]Ò »lU’'‘’‚u~d/|Vw–úÇ€‡î°³ªäJ­hØ@[NS–4ÀïÕ…ò¦7zZ=þ#« !¡(’–:(•¾™ÙÕXÄŒ*^b” ÿG¤FçŒbÇÖÃü I‘s#Ê[´ž¡ý7LlÃûãâ†j;&†˜¾=!Ý]÷*Jó�Œ¹ÊF{T�ü@bGg htÜƸû<@Þˆ2_–”í<½iáã]°uzçy~Û¨¶HhE9üXò fg¡QL³ÀE‡¶MaliW<´Õ`þP>ývíDÀ×7˜Æ<(N;ßiï}Q,ÈWÏLÌ¿|L^̼&»°´vÅh»8Ó4c7vÞÀ3Xf¸=ŒGÊV½6ß‚=uïçÑ?I”¸7Ï;$)®Žw¨%>—/'Ä… cUÛMBÁ£³9V‰®ÖùƒÕV¬»–¹ ¹cXŸüj ]XgæZtÀÖ³’|o|å„; `Ò›lÝfôÕRöµÝÐ -j_kU¢”ÁÔwµö—}rßÔ„6샨m¼‰Ü†ÞÇîàíd*üãb`ó2s@LÊCÇ }RÚÎb4°¯Ûî}úØ¡²hw§=§ïõŸ?o«z >,-|Ö§¹~è#Wî`fÊÒjOïrôà®Çn>ᬷ•Ã~ö“8ƒ¸KË<¨ðÿ\†K§Á†²þíÚ|\ŒÊ¹ Êøžp甿T© dÙÍtÚ ¿0¡¿EÉ£Q¡újðÆ)ßµ±(˜¦+"JVTax*§Ïœqbµ t­Ë± òïVy@`<\z5˜k©ýj™ÆåÂP&b¯ØÜ[4[_à8šðŽ3Yúœÿþ5<*ãÌt¤uÚAQ©³ã¿ÌuélHÞb¿yXÂd ³ß~ØÙ¾]¤þÜL]Ø=É8ôVW˜¢¹öœ·‡ ßÑDÜA«Qáy"Àþ¥¸‰—¼AÓÒËR°Æø~ Š¸ßÞŸö íÔWxþaa  ,Yø"”àoúÌS{maƒ ÛÊ•`s8µúrƒÐ’-` ÒÓ‘×£×~b@½,xɒ؆>(vÃô�ä%ÞãÝ[øq³ª.²]òj>ŒÓc;é»ÙÈ{Ñ[Ì}}¾Ñ¡O«Ü×7ÆAÿ $S×ZÚL‡E²uã}t}ƒ”áC*”Wö qì;¸Ññw®ßµ5ì-n÷·eYÚónìL@K{DåN«î1ƨ ýhÅÜךOÕÏ]CÀ@u&NüwMÓw:–‘ƒægQ¾=Ò²þ6ÐôZ;x†ùŸ�–ݧ| _h›3± ™ÑîNXfɶ±(¤±eå‹$!x ½í©¼q;çAúþé(ï20à]Ë­s{!ôJš%‰­æ§±�©‚¨?››W ×Jvø[qŸ8ŠlœÂÑH;e‚gÅrÑÍ8ÒޙػPdéŸ!Åý)ÛÆLE ­_ñ‚ι½ .ð±¡f›/;:„ž'/6^,êZóåî0¸\9_º>´^,Â…tSœ)Aέºb”ÕÒë`é\ÓÁ=ïf&—h\´M&‰1?‰¯á,‚tŒ~›µ©M«…쎩î^óø£Â·úCœÈ%o.VMSœC½^ †gñaç;ô+äKTzÊälQÖ^yÚüÆ„yu‚ó΄¦jÏôûñ„“ŽÛœ/t$vÕOQ`ßç½4ݳyp›¬AÏI‚ümðòá£ôiϳ~P£MÚ¹ýävA¿£êÔ¶ÎÛ·ýnŠ#Ü׋¬j§¥S×qkå^˜36Í¥JB ³ÁôËßâ#hI8„IŽÔá<Ò¼wžãêÀ.K ›ûêÄd÷Bçc ®ŸGîEëB\nh WãÅëPà8©{ºw†/L¹–žAÜ\}ûªdg¶±ƒfäWæu,_Ù”Äèa]ÛiÜõÕˆ|êZ,Þ(qÊ"‘MˆàÜCËÁÈÍ� �÷-öY䇯w^þ�ü%ÊóŸIný+3Æ™ÎTò[wîX|ÕýaøK›—ÂGvbæ‘ádV247lëÓØÑb—ÔŸO§#2¶Øú…Æç°¡Ù‚v6¨_S»°-7†Îú§(–»}fÃ/$_’Ŭ7¶-}ôSm¿$»¢Þáþ ZåÔR`œäÐûØ”1u7ÔnÓ¬°ºl|pRl9zÓtÕÏÝ É×ýüÂÚE‹ý¥uSëV ôètHºä]{b;‚ŸRû–ï­'€Oï<a_iOPXÈÀÀûÙט*r“å¡v|…•çÁ•ðˆ‘~U÷Çœ¯t ò?Y¢-`gß õÌr+¬§&eÁ‹ Á í§�µpT NÓÑêà”4`᤯z°pÀ×jQìA^» VÄ•õèñ¼EÏ[ZP\ Jƒûaÿu3Œ“álÊÿ¦« ümI’Y 'Zî¿Ój¬çÆÀ„!5)Ì•«o5 FN~Œï$>ó”ŠÙ“ã´Ñâü"A´Kºo=ƽËGŒ û`2ã·Ðl« ¶â‰À}íPÿPièÑQ~Í̉Â|Ñb+‚õ%£»wt6 òáè—Ôh7âŒÇ²ZõtJQÚ2Ýú÷”9YuWW$Y<-øtÚYd‚ü°Gè øÁyƒLþÂVÛ@VtÌGëbÜRB™54&Üçé×mÍ¥c/€£m}9ó#„p§reºl“ÅÞ½“0lý¢wm¥€KkŸ’A^W¿Wìý,®!6SŽ ;¢cﺪêé¯ûIÑ`¯ë ;FGdÓfó8ôtÃ!¸±¡#¾®uÃ?X d¥š÷ÚPÕÎ<(Ø'ßô§XmäÂiiŠ»à/‚Lì5¾Ñ×¢\®†aˆµýÜ×ôOvcÀº€|Çq¤Ö<h¢0×î6;ÌIݥǕÅ 1æ3ÚI­fŽ1NÊ.&v_6›uÇݪ“¸p%ˆLÊ]¤ÓÛ†çÎ@õ;>¶Nt@™*d®EËäqwÛåTªpÝô´0·s.fxoÂÉèøËdT_n·)XV‹ÈÖ/º3ÑÖwÐåvk79Š>4QYÿ¬û©¾)ZïÁ›x”Þ§A<& ÉRnw8ÂàsÊDgžåÅèÍöhcû¶{Oß2JTBÜüJvQKþØùZsU ‰„Sõ¿±RSAOžUñø‹r²ò¨‡DÁÏd§Ûô‡äÛIv%Ìu„tìðiç ùDÈÜIΔۗ wTŠ°†c­©s@Ñ~ó$Zþ{¥Õ"òm¶Že¶Ú÷Ä€xu˜UúÅ´å¯ÚC–ß“P:[ èßMI‡Þg[S!d¹h6`ÕÒ"cÜœ}])YaVT)uˆòØø½ñ˜,¿¼›ôÌ:´È|ñÖÊ‚l;9tÀ+èQö&ÅX|ö®îsC…á y CÖ¦.’Ör „Æ ŒŽ“Ï¿*”¦™'‡· œ!mìÖ0žf§_Œ?þ ›ÍöÆ’öºlkh™úf�¥•A4ªU,óÏ–”ë„h(@IZrƒ^íô"ñò ¬?­'iàB¸?Ö¬tzò)w~a ™&Aµ®ó³OØþ¢c>Á"›yÕõ«}ß$ é}<+ÒMŸ%Ì}q¾#ƒ‘PYã^¡ãǾŠ.ÓRÆ=F&­í€/H5¶äæÆÒÑ:r¼bÓ©¥2íýÃÁ� 7c ³~G}ZÃNQàbÏ(ài²(Š€VL‚¬Û˜#:E¢ð$ŸZJ°ŒïUzF§A»VËO¹Ò¤Ïì%ù'7r„¤È–Ki®éS̵kŽ—Ž`<ü£„1#¢tðv¯x‰¥žB8øÀ”ÞP%¾ÕÁ7œ[pÇ<õÝD–×þýì&Q£ gèô�¾Ëøa"â:ü4 yÖ•U Ò W*ò‡ÆcµŠtöaTÐåÁÊó¥¯LbÅÈD´Ø·šRÐÜ" p:YJÓ¨‚†ä!@˜ö;YñËï<¥û ·²‘VTÆØâE§|®çÙäHX¹6•”øþ=¸IStõFñú͉šÞBäoÙ&ï_V«£³X2 1úØžäîg S‡·ÁŠ-<EFyj?>©L…‹­ŽUQç:µ½åøå©pdí2#Ü…ÑYÕ« +LÍûº½°Œ± Ê/Ñ"òП¹Pðiª2·Ÿï$:>ª Ùµ- 7.~öÜ«Ð CàƒbÌRJHÃôÿƒ…ö¿D3µ#rÁÎþ |P§EåqÜí±‡½ÇÝ 1!žÇ|8|x9ä#1S«R™CÓÒa‹ÛdY¡À@ 5'ͪ& h~ƒÉ´,åÕžžoÒª InnК½Q.›{±ëÄ‹:‡ÊŒp»¥„£=›ÁP‘@ nmoZÚ¨%ÀáÌÉ©HØÀ°d˜/o7¿¹Ei²©>Ø)¢[Q[oör˜iåQq­Óíå <¾'Ê8†çÓÉÓs€6¯‡§…‰œYd“Ö_ ð±5\MÌ(šÒß$(k m`æ45­Í ×’–wº:œmC¿X*dy½JSÏ1>SŠõî\Êtö/ëÑ´ú, ‹mM9‡oÐœ3"..?U‡¥*¹òŠ7hµŽ6·_|Á:‰Þºz`7š†>huì¬Ó¾;òj?úm¯zNGEì3a5u(‚ªöÜ›{¤:|T. ÛC÷Äç#]„l­P‰sëÏÁš|¼4–â™Ün/TŒY-³ Âñ{Œ«v(CP5‹×"†•**v[Iºt# ñ ØS…~þÑy}Êýk“Ù]˼™+—†,—=_ŠcUuÔêM§ô7l8Ù¢‚iE M#¼;¡ÓÐdN™Ñž]�T'sÈFÈ™kŽ´²£†Ó oúãB�Ú1C»ò °‚D• Éàz&ƒ*êå¬Æeˆc®»|Ÿãij‚:Ì*^¿›Ð‰'00yºUcÚ·¾; 貺ÔM—œÌI‡IÓ¸Š î,Ö7BHK— Ôg”Ý´øzErŽ#óQÓ{';Y&èë³@ÐD̲Dªj[7´xœ½ÈÑ.¼b0d;Ú6B-ÿǃgbÚÅ !nwÇÇ}á2±JIâuyiuÔ‚ÑÈÂÙ½7Ç©|ó DãQ§JzìhY`Hí»²;5Û˜ß(œLÏUl+¯ ‹Rªñè°øT}Pê?hnÚ{`þè€�™&š›lZaBw™ùfh´UºotjS—2÷äsë´Ùj?mÞz½@w‰çÊ_î»_-æÏoÅc'cV®dj¹‰n±ÊÒ‰©+¹þé¬AïC_´Û9~õ½fºkªGqá× ’±¶žN!@bµ°õÚõÏ”°du¥@4`âÙ×FK‘ "úØíÁµ½¦Þî4ûdOg؇©OißQÀ;¸áõj»§Oh/|lú‚#àìp1O­‹Þ*MWLÁího¸%MUŽL Ÿÿ€uË¢›Æö’ñií‘‚<VÍæ0uÏ–›z–Ý9ÒüÊHŽšàîþ§KzšûŽòP™mh¾î»¡Ý ‡Ø ËŠhø<až|…™}Z'TöÔbé Q œ_UYú[q…<æª!høçÔÕ¡åqÐ1àO(’æ}²¤Ìny}›Iµÿ#ý¤N1ÀÈ+®{è IÓù°=¡-ø©M†ÕXRþƘUå5èÙ¢•ó7£¶´¨,_<bäËDO#´UY*ˈÛ8Üõå¡kÝ\þnѦ á1¸± 5tT‡ê$pncrî%^(–¡¿ìMÂwDb©îY@Ø: ²fmR™T9ÓÙ:\­ê#›Í/ymïÓ…ÆôèØÑûw® ‘g¥RÆN+:†´Ë‰ Ì¬ç?x>Ê|l xm,§¸+:uvÃÐçˇæ Íaƒn 즧å7õx®kŸÒ¤¡Ia¦ìñhÌ°Ú,ƒº7 G{ñÔ#ªôÒû‚«ÏŠ¹ŸN ‘«déúðé¯|û¢’Ü-/À ‚yäÁµv~ ø§ýÑhÉvôͼµ¯T8Ž;®M¬NCy†%·þ†*ˆæð~X„–R 浘&Šî¸K'© ŠÆòê‹2ÂMí¡ÎxòÌžð*ö ÌW±¯F ™Â© TÞÚa ;$RÊ·}럋ç•/ÝL÷dÿAq"í¬àLˆ töê‘;ëÉ€s< MS±­éù *yV•KÏK•Ì¿§œû÷b¢l¸0Ë8ˆd˜û±ãƒÞ¢=ñ&/õÚÜÒò•XÜL |öÞðŒÂY?Ù0*ºŸÿNÐäþw_·~bÖ•¤Wßâ¤.rF£ßÏOB›{P´õYlý,_äb-‹2ôåmy¸#©ÉšMÔ8ƒè&õ¦x×·(¦¬):7”ÒÙÉ.[à»QuÔÕ/éeTL꡸yrøFã{ë©ZžŽTšóYYœ%â÷²|±PÇÊ7|¤{Á²ZÝT>VtÖŸ;UÒº‚½Ž(ËÂØËÿQ°ô¹'åtúàËÅÊŒ¾ïfÔâ»GZ"Öÿ*” –•‡µu7¥2œv« Þ{ªš/6ìá}ç¾Q8òíÑEú#bž¦íåôpÿm(¾¥™%©´„ÚâGÊ<V18‚;]–½úª•›œ¨ÑÏôQÙøíaÚ›ÃƯŽ)vÍÛöeoóÝSCT jj�!-|ºÓƪ5P·xÙHÀ`IEóU#ò­ï|ðPfÒôû²Ï‹EÇ�}Û^Î/ý1³nuÔ7G«—œKáa­•{J? ]Ç@t›EB(Y,MåR?öërÇAe=D¬Zí&Çb„ýѶ{S§M_ï#:i·êiˆê+ýšCO‹¨lE ¶º$è”i$Ò[,¾{ì®Uf®cÂýjn¸WŸÚ2a8 {ƒçõ çžg\¦µ?ѹ[aûip,V)pšôi5kÏÂÞ¿±\T¡Cî• H dµÖÊÎG@N<^0Yºtþ¦Ãê Ž`Cw˜_iÑh±1ÞõÀ‘VÐÆ*I…ìjä‹%qa:(¥Ö;ÑT¸Í®O O1‰™Iã†w4~š»óæÃ@,ð°ùR÷³ÇÙ¢äB¹¹JªE eùIª¿-û+4„O«­Ù ÀyžÃyº²"·“ {Ÿ<ÏôæPÏJvbÝ®ws›Ö"SûX9o½Žó"ód?"E*(o</©€G¹ïÂIy…’™OÖ»ì=ƒÎkTCÄmØS‹ÏÇÝ^àÓÍ_$„×ÙaéÁ8n²¡t1)M+e5'åa˜Cò¿p•ŽâÄ¢ìð;ˠǼì¸V c„Zê,‚¿ërR8]iT¸{Vçï{f©ŸVÉ›¸yl"à#ûꋈ*¢`5C™â¨4< ºéƒ»ÚñëýÄìŠ÷�¤˜gšû–fÈÁ™ÙÕl< ¹½• ½Åèú5ËËÚZ M˜ž,»¥­€õÛ¸½ìÇW»ëd{š96|h?Æ—?.i×d  ‰ |=þ¬qê‹úSMÑA~PùÄ”ýœ�<ýg9õôõ†"xeDk*sÇ{4aœhz‘1ŸÔKà»D5Æ¥Ö† æ9Õ4: :•´®àKNojx2Jw#§­±¸pPq¡Œ¬Fà'O#ŠVë§QPˆ÷ ¨¶5­¾ êò©ý6`Ÿ¹%e‰EvÚô *rӑ؈Ll1‡©m%¥¢4ù&\,rã쇄ƈŸI·c"€4³©¦‘…Ó<hÛG7ϬBè]ý�àF¾m°pÇúŽ¢õ»ÓÁ§¥§ð '£ôø*ü§Š\ˆåaq“Y§3­ÐŸ»Y?¾×4# ‹l8,Èy£Ü.ô$Øòš%´eSÒÃëÿ¦,®rºáã­¡L©¬íòÁh½í�’µyäKC—®™À�–Õ–žè¬í>`o7ã(K½9׸)Ç |þ_¨ ÷¼~™¯Öô -ÔÚM(lBÑ©º=Ð{ò H�Â`ŸPJ: G…ì½*[@$^¶%q²­ÒçÍèM*† Iøa�ˆAGX¸ÏžUsk ÖÝLÎNÊkùy*’oÀÛÉã¹V—´b#–GßÁnd<z * þt"k)ÏkYqVÀ2Ì?KÜÔë¼Ä8ºÏY~kÜÇ=¥[õÍëž©PL‘µvF:PSžjåþcs2”†àE§Òêλ’©ïl¾å®‘al‘)®fmë©~,`T˜°êFj ƒÿ­C5»CøØ¡üïxˆ¡ÖþD³j:,èý0I­l^”Ð0ô™@ô¡Ç=˜[£vÑ}ÙõT2Ê ©èxI4·nyG.V𖦣<îUð°šë¯]=(!fÚÎHË®;O/ [;—84=Þ¶+¨¨µ"§E`á uí?dTÔ�.~•yÒT9‡7ZÙS”–èÏŠ¦Tø~\à‹dáéüÌ´ññã ”¿÷½iU{îÄ r”*È?³½®Ç71<–{e¿7®mgÝ?HZ\ÑS˜ĸI¡ ­}©‚åÂÇš‚©Jh{š–¯ Q®Vó… „ãÒÆî…hi;Ëg>¼Ï¼«;ºáU�i¨ãËßP±6k×íëé`ÏŸ'òm…'{ÁÉ\8f«6¨”S:Üò¿ô/íiðÚ¹VøsGz¨MKù~b}tÕø`C»| &éÙH >çc¦„¢ÑÏŽ´Þ‰#š›M•j³L—¹xMlȉ0 ð™N=…åOº±RÍnhMaoKe`û‡æua”ù”°’ŽzËþâü΋JeŒ~1¹ÂŠô;X*âr�i´2øð¾¤ÜÜ$Üåë/Wf7 %Avü4·»íf(Y,<¶Šà$ÛØÿB-sžîØóZP<äõg*ZêÉkbn¬%àë¾ô”§‰^ëòX¦í¿ äû·¿ìjF'‰³žÃƒÈ <—Õ{ç= £¥ä W=Öœ«2ßþ&ÎkZÿiÓ¹ÑjïÉ°OPl6G`«ªžD2<ÀÒÐiŸ.¶«ÚJÖÈ'5(/èÛ‹W¥¡ËÒ´6Cƒ³X­².°¼“)b:¥³54Õ¹`"Ö‰ò…ÂÚ/£%æÛª¤ÀtÒR™3/å¢J¨/0j׈5ߨO—óÄ^¸*d ø0þJvíwFsàæÕõºÉ¼ù\GO«3iô€o„™xÛõ²Šœ!wÏû8Ù‚o¦Áp®‚b8zíR`€\KvÞQh[R˜€\ÔõøpÚ×g£|#R²$×j¤ßcwSŠ-&ªok*‹(¹B…Y$¿ð–ðqU‚ð8eÖ.Œ¡¥;î'ìY(§£ŠŒLÂÃäŠk/]be|ev![)ÝŸµgy"Jjµú¥ c^‰Ðx3Î'©cŠrDkò‚¤ªÀða¥)¦ûµ§ˆŠæ‚E [Üÿ8ho”˜á|šaç:«øV„§ÚsÐó=ñŸ9)ŽœQÚO¿WóêÂDZõv¤Ýûç¨hMèrµ�uˆ¨ŸØ÷˜mawÊ2Ò »i»E?ÖÂ-ÔªpÜV”Š*�\VžãðØïùÏÚŒ«¨½¸Ñªv´ÆDõ–Y×Ý q¸ÝH4¦íÿöЭʅ9,�¢1§ÒÉÉŸLÌU»z ÿ.aË]XOÔȇ˜Ó1´e¥'íLg™0Ú$^j Ø¢ûvÖ—òƉKˆcDàÝ1 ÊîõEŠ�‡°¾Pj6ve¬ÊLÎYƒêñXæc눜¬n&êô6ü}n]Æ–»ýÆö=Ϻ‚%Ó„{k¶£M †¿.Kݳ'—ò/;Ê.ÑS¢$,åŽJ¾‰2™13'{‘c?_8ÏóÔêO •ƒÛÚñÛÑ–à0n´h.�"ËW§Ë{£]znlÀËС_Õæ:ƒÌocL®M–áµSn_Þî»D‰/ €ý2æž5Ë\ôoe0³ YÝ{¾¯5y&“FûŒçÝÊ ³w&.¨ùùM!r¿ïf¾­p(Óý|Û©E4V!'^jGé€_Sùgóý2ó'›7îéö¿Nðžsâ<è6<ä—/UÁòå†SnõÍ© *‹ c:0zMžµTö h›_9é`2›ÕUéBŠ¥Vgªý>ƒÀÓ°©Á— èŠ+NÌ70X…VZîí&‹Ê!AY¯ã<PE<œTÚ>´º oÒ­uÃ_yÀb±v–¬AN™$8ý)–§©»Är ]'>O[î©òåo´d¢Ä'±‡ »¼¦VúENTÑ2ü_nÝ«^®Yå¼£QïC0‹%bB3¹lÒ2Z1eCž„\PÒ9P¡Ózg^û$p€ºÐ¹Ìûoü~¬¥¹bæÊ}=ÅGŠ®¿¿Ïä²ü%ÑF®@¹ ¢VyÈyÎÖÙêIÝDºñ³ë_T”.ÁOyèRËéâõ(#D‰Ï:í]»‘ÒÁ¼Þm¯eÙUŸwÕäA|VædrðŽ¶¿Lg»Þü¬—+4ÂpÕ·Ea¸Eb\1l ÆúéÝÎ$ 2¡“®Ý«üƒrq„•AÓR.Øù%É|a—°M–{‚aéó•(tž¿h-iÓ¡ äd°Ãß[)žië@6[à‘·ê“&Œ¯üÿ¼id-‚u7hó+ß™¾e8‡½¸IÆŠ£Ì°§*ã†;@`;gõ¾ÈÈà]{ævƒÈÝPyv $àoD¼¬¥b¨ºÕ«mZÒQ¡üð³€f6by˜€¾�†©J—cÝ_½,jÆÂïkG¬Hv.ƒªÕ..{Dá14µ£Bw°PÙVû¥êÌѧþÆ·ªÊ|Ñr&\æyñxÞlëHwŒÚ¿Ýûeå J¨ÖŸõ`ç½Ïýý‹^Òݲ˜ÛÌØhæýøSïð™œ�iÝ°á|f­_‚ï„€l¡€ÃB.†„ª2ø7ÝÈr™= $U¢áÒÍÌGRŸ'à{—¶eÆ¢š‘ Õñì47(~éÔh'd'Æ“#Æ܇„xm$tð%”N½Ïžî=E¯õ’èoýÚ RA³+åw8¬¨ŸÎfWrà $æãÎòèxºÌF`êĬ-cà‹¤Ù·=âå™™ç†Ãoþ\K3\#æ$Iæ#ÏrøA”AQ[ =°é&Ã×ùí¼í:1ô¹Gá×y£ÑÿgH'Åó~t¤)Þ¤n¬ŠÛÂmôW0ª¶Š{EE>ªæ­)ºô;Ô¬J;•TkéÒ¾w}† .Uô},ÎÙ¾gÉÛ¿o(hÏc÷AžLx¶‡i¾àoÒŸÿx¼°WšŠ¶væèYþ}ðM±Ì¦›þB·‡¼¢Dø|«}”vµ§"ý"À ËGÞGŸ ‰Õ%'ª™÷õÒ 3CÙ(5ù7Bdöýíá[h…¸tø¯ƒ¤J£Øpê‹ZÁ`kÖ$Hø‘Ì«X*ý’ÇÓšBŠTû¡ÔC¦ÈkÙÝ"Y´áyÚõ÷Á£iåy¬qc®½D0#^T,Öí`w{awg)#A¯ìRØÞÀNTCdí.Æ‚Üì©‘æÐÒ“œiêúærÓ[3öC%,sÝÑó¿¤ÈG™Ó¾žT#Ž¡øW/?Œr¼yEÁX¤½Ûµÿ¾}Ý*ø”žn‡ˆÍF‚Vr8*L·‰V%`FšNc]¯îä1ÈÍ@,(‡Vå°[^ˆÂÆmR9¾Ó¸W6튢£i½-OSöLñ׊±@øOªf�üx½këÁ‚õÃÔü}gýÚrãœG¶ Ë.X0—n¹ùô±|ûòN©PùZ`À¥6ÅÉN•§bŽÎ¬£p²ÓÈP`}]râs§c%ÚbÌÀM»ÙsµB±ý}Ömå2tö$mzúË[m:á/§¢Ÿˆ[îËíîRûg&óénæ߶Üå¼Ë,‡ßÜF몱w–²‹Î/ÓTšQЪ±ËRÕ�˜›ç}å —Åò¦™(¤†Û­-«#&5ñ�â ”?µNáÆñ_bˆójáBÙ£s„Ãɶ*5k\TüqÙ²|U¸-*}YÁ€%¥ª'׋ê “¨Z¬­Î·±ž:(‘@ß|#£—Û"álze 1ƒ¬ºdAù©v*°À£àîã4N³Éz Þs?´(AÅ76-½ÖŽ«= 2:‚VË(öÉ œ½ kœ[YaÁÙ¢EGïŸ[]ãÌzÍØÙ1w·X+H4†ƒf»5eäº~lz~`õšoGÌÇ6ëܾ‰� U÷ú˜>‡ B-Ú3è#ÛÖ­�¢ýh0Ýý{Õ6ÀÕ»©NÐÖ¦8ÿþÇcbø *Ö&Ê6ç_ÊØšrÇjû*È›V=Þ,g‘Y˜\ì<ÆÜDèA4ã`þ,‚t«'ÊtÂMàÛÌJ»½©ˆ¿�3'³YÕ§Óƒz?YQŽÒ3àŠ�è™?i%NªÄ܃j¶b¥&£råˆÿ£h—Éï0R‘uñ_¯”lJëÖ!öh°h³ZYf1ÃIñ~ÊÄ6(n;½­iÉ"[{}T'±(ÿ€–שöÂ9ý ,‡*PˆD ]|”A:×^¬5ËœSÚ!Io{¯<w˜ç÷f¾ùò™§@ZçAÕX4n(žó ûÇÉÛß‚Y?�\û^c©©o¥U’3NC*†â4VÖ‰åäT#ä·Ui¡z¥ÚNéKÞZ¥*ÌlÇË´;l¬]nÓœ™èæ]Ñþé†úô¶9c:¹ü!+óåB R¨«ÏWÜSÊõÖmú3$õyg í£‹PõP%Óeí͹®‚Ä8xùö—•Õ¬ ç©{f¶¼©o¥¸F ,cÈ|RenQIÙ² VøSÈFUdK*ˆ?†ßjŒ|Mibòöºä£oxÇy7@ùSabäü»(qXCÍ’ÙÐö|¥à€n¥áYµðN˜:§¿³o¤2ôÓñ¨x´$uÆ=é—b™$åÁ¼Nƒääù"uý×ÎeætK·bhúP¡OÁT_PW¹]Ïì ÛÀª/©O¦}†ýRËÏŒ2~-FEñÂ唲å-E™rÛyYïmz«Ÿ1½HYå¡_‘|ÇW"€ýD°< Lš“�ßÆñ¡¶ U¡‘¸j/g€6ë £tÞYݘzÃ3@O}(ˆ¿¥Ö™¦™•G&Ê@.[³˜9Š†™%ád â{.Ýÿæ‘Sžû¹&HSŠŠ:G5ÈhZW²M{i$ãa–ܯÇqìu¿Xƒcµ§`P}ÛõÆ"Øœ”«2Š€™/°|ļӰSá›ÂÀcÎ5·›Ùäm2e£êÙèŸÏ"k¢Ê¾ÆiäB #ŽLí´3å³í'ǯ?RÖ#qð·ØÑÌ'|#ó¯©h¬jíR%O ñ·¾�Þ•DѾþè¸ð_¸Õ ñ0e‹J©ÓC<I¸œµBrÿ]ÿ(ÊÒØzUŒ:¬‘3ÌGÓ}FjÛú·%ÆåmµƒÑÝzqé­Ç=œ5:›€.¿þùÁ!Ýôô4jm¤¦Œn[_”ßÖt·/mÀqq£((©z »ÉwJrF<,y"'5."“ÓL´ùã­VþìïÐÇQùwÈ·b®<8üù@e§'GúêˆÀºzņM> yP¼kô+ÐÅïÐÑ e’!}c"ÎÕ+pÀÙ“”vWñ6-æ±&±“ÄÔSfr €nB ŒG&öꆅ¦®F;0 † ã‰í›&Ó‰h†áRÃ5ŠÑ¥Â¼V^8†Òù>^Ù8#Ýr‹d|[ÄÝè!AâÇuøã_<ÚOºt%¶œdë“^Ë™€ÀÑ8⬆{X»ÓîélqE5£½œE«²8‡úƒù~†2ÂÛú‚q÷*Xuë¡Û®Ín9ð&yº¹ÑåYCôU…-8ðdaâ8â9Ü€W²Hè„„_†#æO‡~·=ÝÀrªRš¹À<%T.{Ôíf¬=!ei¶Lñâzð]D'z䣡Aª=DtÇf¿Ïv<\E'EàÇŽ2C“®étz„‚JSÇ" Ye’SëN»,õå s’ú*/aCbJ¼ ù/jÆ3+þŒ5œN •z™©i3¥T¼ ƒ©e ,#ä¿1‘quoâlS¿g<O+Í%$gx¡è È�Ú³�c®'�{“Žoåå-ÅLgPPša Sn& Z¥H‡èüŽCš{Âl["ŽÍ'Õ^Ø×dO2½øÏ[\…A}DK8È[QÜ¿pr¶L>Êa»0$T÷4¶½šcJÖuM­ØÀùÿ¬Z®å†ÝøÙ–1œ›kÉ[¦+ÓƒE«uï Tm»ón¶z^õ$Tô[ݵ˜q°„ßøÉr]öšITÙc+kËþ~k:ºô¿ØõÒ¼uåÇ*Ë@|7Úå…%Eb‚v¶BÈ:öý˜äV:Ýx1¹<¢>Ì…âÒÊ” ÁEÄ‘[dúè(š¦‡ŽžQš.䑬}«eÆâ «ÕI"*ŽÉpZþJ×Ñ%”(¾£›Ö̉й§,úK[z¯ÙŒú6hÌþä(ë(F±±Ø¨UáÄ/Úåw¾†Ù1ÞÀ¶Ÿ|¤ íú3­³n—â}ΣepMëáJ)Æó}÷Tk;zˆ˜X@ñpöÎ ‘½wuxbøWþè;‚{€/8‹‚µk=Ùô÷(ÝP�cØžU3—Ö+Àõî„ÔRŠ DÙžÝ8¡¡ÓÆ &ŒÉ„XûN‹ø:c |1dÉ”Ì<™ªRLPÀåjÎî uçµM~‘ øb£¬'ß×”-¿-�ÇÃúœ†s~Å›¾u¥à£Ø—M…Ü &~ɶQø…áÑÊ‹§T=M5‘3ÿ›3RÇáúÛT¦ÄÕZ.TÕ¢·”ÓžRiËe§Yà‘<-)wPß.WEæqÙéH:|ÓsˆlInñ¯P~šéöÛ ÕÙbÝ,qw¸ÑKK‡ífErÁ Ù&G¦{ì;Fjš£à%”¥ÔÈxº@ªD,„;=ñŒçÞ¢<OÁ#‚¢Z¶AÔ³ <^L º¥$„{V”;ìæmu|qbŠ"õ »h¡KÀftÃÈŠ`ï<Bö¼µšðAèô÷3µãžrcžù“èÝÑ4ódS1ˆUX…]ÈyûõŽ®®M‰ÂØôgHxdŸ”PGÇSo\gL³ê2\ØàÔùÚ½¤œ-À¥Ä ~‡ý´ï\]òÔ pá è«!2€~GÚZ °>w{ýC~÷ÞI”Ùü7TuLy-�ã Sò l꽧;ÚS‰=´îâ º!ŠÔ¶¡4>°«Ú·‘ŠJ ´vç‰^=ŒVn]ØŽOæõS©>*E°*””„N”�zZt ‰²•ÝÀ¼IÝLYTd®{RjCsÖî,¢‹û€v(†k/£´ãÜ+ù8G8vIʶÄ6|-œy׋ˆý3UÅ«îïZ •Ç%7ñ ZÃŽ6]™Lî´Až®êa8€‘M)ôO¾s”ånª17ª‚ÄÒçñôðp%WŒ0iv= _´ÐË|/ ƒm[¥u,^ö>ñ„Þ€êqÎ48Ÿ½‹pWŸ—ÏkÎì™ `å†æ×ã^V­ÓK™Î%Ô׈ðí{½÷Dû8™ahlzúóÊ“’s±òÅô�zªt¾͹;Ÿß¿üÙôK<Ñv¦í·�Kæï­×œ£3"ÃèÀ?"¾\ŸVL °›5Cr X¶€|Ò;³(XvÔ“Æ,€©._¿¹)E¼0åĈ!k>D•+Ér˜5¡£©/\ 'Ð<)û=cO"Td/›hf«kiÞnÑG?”$î£8,ÂPÀÒQÅpòâøÇkŽ}–Ë&O`½®‡*/ Í`ªÁnkÏV€{Z[Éo ú‘¬èŃ¾ÜsBñ†©¹¹]#eÁ½¬­TßBîf.S÷•]""1}ê­ÄD…L¡ŽÎêtõÕXV¡Æ´¡;?ö¬‰JccÅ"˜óÆAñá©ÆD PK_ÀL“0öq·‘¤º‹àó´\íñJªW«#A?b:Gp·ÿcÒöãx˜Ž”v©®¦2§ «Z<ŠyÃ{4ò¨\xÃQÐY¿WZ8?´®±—œ‡4·‘×iÞFʳ…!hœ1RßÇ(ëtò¹kÒé ½N 4£�ÀC*–`è‘f,‰(±ïÒ a¶¦ Â÷I©©Ä„ ×d˪¾&Nù…>x{mdátÉ#ƒÍØmhõ½Ÿ=ÂÇWµS˜çÞ0Iœ…Ë[2õàœkûx+tå8=—îÆeïÈÚ£WßÙQŠÅ´x?®hZ–➘ì¢É‚â4x ™÷zuh.¦Ûµ›¦@ðKýÀT¾Â GÌ€|cM¡>:ÁÑI ÁoÁú„ÿÅ°<\È8Q`è©BJÞ'ÓbO$qÓb¹Ø™ ¼KàVý1Î"åì/!×ßHŒÈþ ˜ZÜ)a N‚Ó°2Ê€}\Ö(%‡…Ë<÷‰þI‹l©K:ŒUu'ÇÖG:‚›%w§«'¿d²$ö%Sæ˜xhöQJá%TE²L¦‡NF×)�L3¸å´¿n*•Ç‰k‡E¬:îË ŽžíØ ÖRjû+bJ?+<,ù êé}[Õ·ë”JùŸ7›„ÊØ äÖ‹oT‰ 2;e§§ œMh§Ž"¡n_}DÌj»;åCýЛê̱WO pês*3z…†ðoø Ôl'fÃÒKáùÃó£éî‰e©Êtø~{ zcZV3ç›·Ô$?OèŠNž`©TûÂ3q!NVyë-ZÀ$‡G' …ké+ñX5„c Ò ß¨ý]%¹:BŒ¸vÇéäX……~/=&ïÒ¶›’Ì÷¨¤Ê »ð}kŤ†½ÕÆjbÈJIp’sºþ/ºü¦ÙÌ`(n$Ö³ŽîÔ…žƒ‘c£;‚zýªm06I¹u ÎûÎ]Õt^6 N"_U j[D¸V¸2ñ €3Kpi…YGÌǺΣ·H“|á3M‰ù�éRµnA÷æ&šu®~bà^Æ™FL®äwÇ”ýÄy íR4@ùN\ ˆü‰’B¬ ¬ÎÉúByÙ¨ ‡*´¢§'p<œP¤þÛwÿ®/”y3Çç*cðçm<(‚}}uVÌU àS·y©Ô}YCòmK1k²w@n:áÛ÷c<’„ž< ¨ðwøÔÓ½aë‡ÿ+‡$_0€< Qd'Üš2b¬üIä§ÊÈjvæf*ÉPœªi<Ϻ/UÑû/q8¶“XšYáN<sïÉYpäc‘¸ ø"Øw˜—»Š69èf™![™&óhâ¢ïÖÈZ©ªÕk¦áÂãV sFÁêÛ“>ë»Ú˜‡¹¹å½&@Ç‹… s%x̪3Ú·X´!’da¥|¬E{J¹‹/Ò }Î.ÌL+Ûo3Wƒ…øû ‰ÝàŒ¿ž3ÓìhVüc£¸V®ux^äÆCú;ª:þ‚ØZž¸ê‡ÁµL¬íŽMHÆãëú6Iæ 6Á8å?õ£×ݦÁìÃÙc»=v<L²Ó~¨v‡Ç³ûÈM}1ÒÔL¥›øÜ^a€Y·§ñ*Œ»,[%â‘œe§O…dBIh'4†ÞKÊ«nþp¦êº>ºêÃÈÕðàa×úú·O ™ ¥?‡º]>Ä©!¶�*dÓ¾3}ƒ²Œ§6ü=3º)ÝüÖÈwMtZkG÷BßÁrG¨héï.«í"+qÅ5+‰Püë{ú’^´¸. |}CÙæeÏóÂq[Sà†ÝÌÐàMÍ«ækÞ7èÝ'™§ü€ÁÀ˜qc_Òÿ6iëyÜÊ·<ÛªÜoP#Sï «iTŒ±²8ºÚŦMÝy7ÝÌÿ³"ól ÌiûöÇwEqõ‰ï­|jÛ™éÁßÐÓå²îyJ[œ-S„è¾éÄ´ž<JEù5œ<[¦;tu÷-S“&ûv·Q\]Ióì;ªåggfìR`LƒLÚ‘MM;N„ :£•§Jl±‡D`°ðÔ!‘œÿ¸Á5#÷pÐ_ËÂ<Ïow¦>=óð ½×¸uS–ÚÐÖ¿í’òöó’½9D¸2v(=!ZŽ…7Òˆ…—cæ_bDu8S[mUëI^—ª‰Q„Èš-îÍv£o \SÍ2,š³Ž—iŠ/¾±Ò,QQ„KÑ·Õžö‰Ý10õ¾«^Ý’ãFõaÇÒ±¼+ܦ#6ƒ—ú'íiØ1mb=OÿySä\à<ÜüÕ<ù‰uá†,ÌzX(MÞX©øJš‹õÊ™0>šGiêR.úxÏ <ÿðLµqù`‡,ia.ò#ñ»ªIoÆz¿'Ö~†Uòø÷gâV†ó'ßáÚº9¦fǸeq§î¸N2*ïãÇÈ1¨8¥áhGd8fúº½0È^›¯´ÏÒþ30àå··­43g!‚©´ë³ ;Ztd±â2|Íz7÷NB¯§ËݧfJèÄìT`"9ÇÝ„£t·8eèF‘&ÿ+¢j­“›mj ð‰ØÓ¶‡¥ûÿÂõHCˆnR–ÑöIPl¢ˆÅs<ìƒk‰Š+T†Ýum=jGþö%º@J)<>ÓA3‹šÏ®Ø1¢V@'3Ý3ô†Ï与S¤•ªÌ”ÊšþüÑJF-Æ ¿o.醕¹ %§&ÊAûű ÈFÏÝ3 }wŒ!œØmb˜ Ù¢AñQX+‰|C5»!y=åÄñ²K0øæÛÄØÃØÐz>C2šYhø~FZãu]M(I[0=«R2赜ŽÊù­¸ìë;%@Ñ'%¯B[#!$)ûBÌY }Y± ªÉàÕLâQÜè¹vW[XÃÂӟͬÑWò‡óáKª™ÿ%•ïÃY7:Ô&‹Q\ÙiŒBSO¼Y~ãð—/œh׿`¤é,¾`µPf„jj?~úƒ„ä;þ¨Pq€ØHæ­qP¬UŽ]ƒñ€éôÚQš$:Éb?À‹l³¶DV+ûæòfL½å;Z8fKÝÇʦ‘G1—Iáa[û,JxÌœ Ð6Ïi¥3 úê•'ö™OIf#:"ÆwGŸlê’0'54–š}½;øά¹TatÔ¤EºUS/ôj†3tgÚòÀî4J}wn»ë2H§AuKâÀùÈ:U=,"óbŒÌ‹GÆäÙCŸ6´óúèŽÉ©ÞO9žZ5á}ÙeÆæW¡±=s³YÛ`¸Ói cXÊkçgöÜLí�<#†aˆD³'Òé|sêϲåeðÁ]ïë-]ô4öµ…L›8ȧw¯à6(9{†³ øë·®ÞXÛ˜Ósw吏(Vf†T´Ð.¼èŠ„jžå�Êz<LXxT¦ü¼Xlõ8ôN¸Ï3ãô¨¶ƒFÜ,pÆÒË›;û´_™ù…âxæ<·èiŒ:Ç‹Q $l¬¼Ñ ÃÑY&\rŒbò,»‰ÚØ-¿þ‰=È!O…JŠí·ªåäÏTôX Ö=ÀzÁt 2JÒº-ÍH‚ŸDÚj 3ÂFr²zÿÔüFœX³:V?~:Qé A#ÈÓr+‚xÛéÎNaÿ¸ëÏÌõÑ®m9ôw5îZ OZNIµp=¯Äs²ì´&.ÃÀXKjwÇøMÞ1žd•r“®1™ëVSxÈDÒÓl.Öâ¥"$ª2a”J 5bqÅ*H.“¤(ynéöiëÜéã9o<Úc´µŠ\¤•kÊ—H2);¯<×�¸a$ï}¬O½Ïrjj#ÍâM-Ééá4•·Ó gUZö 6 å; :Ö´ù`‡™¯@÷jwD*5÷î;‹Cœ™gÑò/Ŧ]Gn€ë!&¢Žœ!à3ë~F桵¬Zqp»sý$]¨ÓÒ ž¬ˆ[Xq HÛ~ ý¯LÍ£¼È<cØ)醗­æ—YภºöEy?kæœ/¢è¦¯?q&±ç—FTê íÙµJ‡ú¸SIÑ×  (ñ0ª¬]3Púè¼AÔy7ø@Æp¢=Á»ÍAǘlOóúyÂ8j­’á@„ÓâÛÔVØuɹ»vUKµê»/Þüaèq½rW¬œƒ²y·¶æÚÿêÔèNiì\>æ—%µâÊ©0\f€ükcq© äe†›‚÷=_3¼3ƒd_Ù结¢ç~ÅŽÖˆäUãA¬‚­ÓêjðÐv½YýíqX¬¨v§²\âæ*DDFäi߃5”a¼5‹i&”8z9ÒðEÓᲦ)ÞÕµpJš;t8§vôÁ‡wÏRq…€Ðî”ÌùªÒæ+ê›yêžsÊxÉM¤ß'ã ßS‹vƒ˜<wT9Š ¾ ߀´º÷c‰Ýý²2\ð‰Ñ¿BNk½>ʘk% nø/k‰“PÓßÀ-xÔ.ÇöTÓÑf5lÑÕ_0æ è�¼ô¬¥æû|"/C4»í%[’˜ÀœXk´VºY ˜fç‰)Ü•¿JJëú±}ª†z‚Ž#¹Ä–)Z]ýæ„Håè WÀIÛrxŠüH z4FðÜò¼ýMÐíæ;1c4z“Oís/<ˆ^Ó†ŽËj::_ŠÔ²$d»y†ÅλŸyW?ËžT'>†è�Ë#Ø"¯-îîê=“’xv¦R¼“Ÿc\Â…0ÃÛoŒ©|¥LU«3D ºÕ¨Yé7œÞ fó¼ÚM r#ÜÐLtÛÒZ[YG:-¦Ó¤üçÌŒ8“ <ÖRû÷¦ÀQê]™;ÇÒ±q¯H,èŠÐ³ï1RamÁ ¥ÍÛgâ>e‘yjÉ”ÉÏEP}*2h­!óEyfÝ!.íY¯¶&·_fÅ‚j-PÛ-æ齧—JgæV¦S³¢º³›gz= óåÍp –ßÑ‚*ÂC¨hC³Æpœ@:Í1)÷¹¸ÜÍÚ7*2_Ÿ&„æ %”Íôfjzä׺øb“Â-‚ìÎÎuœêT;73£óˆ_ÔzÀkž6˃Ø3{Ó›WiËÜp|O iúü¬ˆNžá;ÝT¯E¥îäw…°5›qOSásD–e…I…̯ƒ*<üJØ?W †TÁpF*|òAŽ—Îj¾ff[d^É_õ «Ý»$xv%Î2RTBÖšª¾=Á]è|Tùðnxì¶:f)à••q5ñ4î삶EwÞXsÝúÙ V„¾6œIÌ@Ž¬Åd…@¸Ï HŽq·‚Z=íúáiu…Vç y8{Ïsxî&ñÈXæ“Ÿ&ÇiîÀعh.f %–kWHБģ<39¦hC¿lIJ÷HÀ·•3W¦‹KÛ¢¬ßòÀ(ÙÎŽëü;s”8K¯4¢¹Ø ×­Nn�"ª1VsDZ^Ü“¦Ü‹u—Â`¸¹ŒãhµÎÓ q¢M)–Ûº³žmTÔÕÂð‘W„.¥?oúzA¶¸ýS*)ç%K¶Ú,ز¹bŒRþþeÕ’¢Z¨¦A;WA>m0æÌëRë Óx«Z·À £ë1˜SûÚ€%Ê<ÿ¦ˆ§Ä ¤™'Ï–¨;…ý› ŒwØqîK¤Ç0ȆØÍqír(6F¾ˆ=÷NN£†¹d‘¾È†v JK=^W†L¸½ÐFìtAZÌø.†ðþç-noµ˜ÙŽ>™yËâ›;À2«>5ŽÍËÊú±bš3í¾{�, fÁŸ˜ ÉÞîáYóÒïÀ¡¾G°´6ÖI.:DÈ„¬Üä,bi�äR€¼ñƒ™ráb”ö !ýTwµ.!‹ØyöýŠbß`Ý8èÙ:÷ºªi%àŒ½ø—å $W˜c8ÕV2SÉ®ˆ àGyâøDè4ñÐ9Š4=8d³©~a!^ÌÛò‰ \6×R/ôtc«ÂÏZ>Ø5°™vR�MÐY¿ JÌv©“‘gØ *ÞC'"$&ƒ1ž<»wœ£üOËà4+<6+ò™RÂÓZÅþCæd@#Ìú…pþ*JZ·|Õ^N)Ú¦uÆT•ó:~¡ó�13LÚuÙÌÒxâ—ûßx9ò¥”þr UXÕµëB°•“/˜…í²¥Ì}蟖GVk# ¢ãÅ/‡N3aÙK6âI”yèbµeeïKÁ>8ØŽõ¬Xé')R/azÆ1yÓ{¼XZØ|³Åó>NødŠ %|6iσ•|H¹°—{ÆÇ9í+*ttôõùÖ ¯ã0iW¾¤UOJ£ ˸ó5T0 „ðhe\;ôY' Qp9×Tö•BËÚC‹Rn ìL­ÊçÍKÁôš6Y°OP‘k&TÄÌ-Ù;">Ád\ïµXkv%1†WyŠ|:[ƘLþÄ�·_§´Çç‡Êrh=’}ݯ)¶¾êN™2ˆˆ™Ä‰Ñ²:õ®Ü2 •ÈªÌ^±b¯©Z•N[ZÄöš6îäu5õ·&tÐÒ“yº…¥ˆv E»Š&›Î„»\Zrþõ§oQ½Û/㟪T„~@7©û¦’Öšg éË þY-mœ#ºðBºvgªƒk$må|fø4 †±ôhf¨&7e¡Ú"hÇúâ“#YYvtTSŽÆ»ÿIKNýßÿôPnó`hj0Ýûæhå5+‚(«b¯uGz[§LLPÒײ8»Ú {KwVQ{<í¦~w´¯Ìy-H15˜ÇËiIÇúÛ6A4ó¾~]h[ÅÎ^D¤E>ôSgŽ ÃÊ‘NÄ_ª‡Z)„XÝ'† ýèEj†ü§/[tøkp#d¦I¸ìį¶ -·S#¤úèo³Ô®±jÈwý«¡4»/É‚ì]uôvò||R ˜Qüyq¥19 :Œh JL³ ÿVßà¾(!´  îú]åæ¬ibÓP¦¿€–ɱqqq^Ë^á¾üWDÞÌUôôÿËéìuãÎ[êêL]o]ý” Š36AO€’0JVß­?qˆŽ—£|˜Ç¥ ¥ªFNà:Ž&–¨®\›ß7GoIÿùþîèØߘCÍBö.¯»zÑ?ié=¢e\Ï?{[bH"6²¬ûÊ»@ÊÐ^>º –`™©qšGù1S‰QLÚ•¡OóyÂJTãúfd_bÑ–gÀ˜•N€–smD#Åk81¼È$*î´ôÑÐ,Ó7Rú~R5C ™ÖØFE]Õ=”¼ Î••N­Ÿ{ÊF¢ÏΩÜçÁ`ðï9î{©Æߧ06ã�þ4¥¥3žå”š¶µq§¼oã~ßÓÝ‚\M nì¿g÷éóM}׌ãdÙ*ÆÝ°ãõå{æ 2¥>„ÛFš±åЀ3(³"3ºé²êh)6TA¦eÀkMµ§}….PäZÑ<Ðç÷hmŸªZúdݦ{5—Ó<Շ̚c¥§«Ã:"_”ì eÑ&€N#Ž:fí~§Ù[ºIéQ¾¾7A|½ž<¨Ì‚tR÷o¢²ÐŽ‡áuV|î©2±vV WÅF‡}ÀW£¸ €!ïÅÒ%`=m•òóp<å8o¬»BS¶åðÒ¨…ØÓ(Eüʺp=<)]V3àD[C³OC«e€Œt‹¤1¶¯ÇÈ''b–ss­ ¿®‰¤†üpë´Â¬0ýHéëÄɧ,d\ï0óFÃn°ö8Ìð«EÃPWà#ƨuPã„+úð©µÂÚèHgÏ]~ÅÈaÂ;ª¤yl¾4ä•LdšÇÙ2õH©Bn/ž_"ÞÚ©¡?·ZŽR§‰(=^`8"+ÌÄõÀ«lYßody´PŠ¥·<ûÆÉLZ8ôÖüÓE"ÙÙ)å 9µHä=Ôeb^ë•ä¬Ì4l`[ˆ6z~«+X}QÞUÎצŠ¶žÞh_õÝ‚„9ièØ µÖoׯýVø‹T^z�´ÛA‡…ãIÛ“ÍhLƒgu:š¯Ðàéx¯\‘²,ØYä´Ë¾èƒ·šnA;˜}KÖPá¹²” ÂYÀ‰ÊôÐúE®è3+L`ö[4fÓ*y Œ²•W–Ðe¤ÙkYrÃê¯5Ãaߎ´IŒ —þ=/üQ˜/•ŒyÒá¤HûŠ•‰>žyîêóV¡ßx 9î¡MÄŒ§È¤u´­à O p¿à®v³…-ì[é#¶½Ã·+¸ÅP]%qŠT³“¶êã-s†d!¤æ!�÷Go®<×,A:±Œá‘eíänÓå7=� îiSÝÐÛM½–7Xò”‘P!ºý¾œütÚ;\„QÂé{åÚ§ â¾KˆÖ±u™ðÐs7½±]¹ÂjÊRÛÓj¾ë¿”/ÀÓ�ãÓúûœÔǃ1D~¥Qv.°NÉœ¡xÉ\­ñp2»ñ™qÊ ¾;\•< ÿkÅ-‡”’ÕçÁÀutÉ3-ÝP‘¿,L©‘ƒÁ&$â[6ŽÞXëØ_ö*ÓÄ6‡Ó©ÿ3³ÒáÓTSŠ™]”p ¯‹· ™%;_ÚGÁ>¿L§þÏ‹h©¡ Õö³BLY²Ã°ðyÆÌ‹ThÍŒI0nhÏZve86wÇV‘öׯÑ?¥—g‹ŒAWRqÒx.€ A¬ÃïJÛDiä‘•ûY'¨ìà3J•e'À+X¶˜F´ ¶«úÜß6µ‹¼t˜'<óg䵂!ƒ%6•ñ«wöļ†·©LS¬@¹‰{L“cïëóºöŠoú[×F_Ã]ýô©ñh ,¢Ï¡Ò WTCPuŸ¦†ûõk–CyîtéDsˆèóŸ: âOLÛ¬6LK‘äO7ÙWÊCNÏœâ—Í¢Ðt« Ë”¼+™ä° ÂâÅ» OqkI²«0<¤gd¥ÖJùaItæ2DgÁ¯Œï (µa êå°„ƒe”šØ}GovÈýÜ ‹ÝÕfFK±¦'®„Iû>ga.]ø?»<°>ͧý [óºŽá‹ÃHXÛ¹Ÿ¡,bUk£Ðt=µ]Ê€X*Ê]¼Fá‰ÃÔ5èr6+¤5š­ŠF|1Bl­×h¬LI#å™bP³ñÆ]¬»zø*ì7| ßÿ€…!Å‹õøÝ·ÄÒÁ‹½G(P/ÿ¶Ý¿}ýï:Û¶7~bP¥l±¼$“üà–”NÓHžÒ°¡]“^´Ïn½ NWòg¾&µÑ=, )†(e­£é°5½a~jv£m˜<Z–’CE¶Nl]<W‡Æ÷\{ÑŸÕ’8%8û¦=½ï¬Õ²òÔz V†³÷f´:Ò Õ«c}É‚tÛøŒ cJ¡Ã«EpXg¿?~ôSôÌòley¦ÍMÖý+涻+Û üìÃË.Ž¦w,j<ˆ5èyí+VÑò .ܽkª› á4Ñ hE@¸”k\“Mç¦õ zò=Œhý-Œ¼àÊÂ7ýXøFUé[ÅQðž×ŸUÄZÇ}ZrrÔ\»Hg&B¨÷Òì²r‘Šå®Á¢Ÿj²¸ïZœ•¿²ŠÊãZTK=DÑeÁ¯kqgü‚®Øj]¾Þ”O ßö�¶É@¬‡Ã§‡Xï[+ˆ` ·|T¾YªØi.$|†)Ù³¾ylïm!¸}ÔÝêc{`ã$ÿúx€÷°|õIvÚÐcI¹Þ˜Z´Xdxb<ÿ"Œ$I-ñDpïç)5þÞ‘ñX‡D Ÿî†]÷ú¥?^¯[ ±/?µé‘nE¯+ kÓi.oM‚"àâŽ>¤»èêIss« ÁÒ ű ÓwÛµ.“âÌÖiÆÌŸÏÄ}þPnDçó ë—±edçrôj~& ߇`ùÜSf¡à‰ªKr€-[tº ZâV ü v•äOQAzú´náY&5;Àwøì¢bÕ—Ÿ%ižU•Žî9u<±bW(ü_IO‘M¿u@,8²å워7U¥*nÃv´+³í$‘•±óÛ×¢·5èÍͧn†â>d]„ ßävŠqyÓuâÊ7*\ÜÖ)50m<³Â?ZÑFe**]»Þ^_ïxÍð\Lþm¬óAêÏõíÇòw¿D\R؆”A5+'!Ó¢s2ý­\½Šë«V!Eê7ND) [¦åŽóʸ¯ÿ˜Ý>(3†ŠA] ;8«q‚† å°Ò¾bÞ ô</}?? /,D2.Œ}Ÿ9i:üÿá3gΛ&Ã~i!îZCR6¼ýaŽaß}Qh6™K äxÉm=ö×#K¿½ÆYúo)Kqú}“EZä­jBg{7 ƒMÌ"éÉŠ$œNm@ ð?’Mà®l÷þ‘:ÏÞÚl¾4iDÊØÚt;ž˜ü¥û’m­–ž ¨ 9‡\©§cç”Z}—ö¥c{§~ÙA?Piqn=’.zƒB• d¿ëGõ¤»<³(\Agvw¤<d­1lͲ­rþ}tÏ⮥“éÑf¥ã1áUàÎhg”Ó¤AÞ}ú€µ‹f?Ö Ñ˜Çôã.ÃÂÂXdM)êtz-4ÑXÆWˆÅàŽ2í-­ÚÈD³`øt¡;Ù¡×Ì,Óc¨œt.rjy•íUÞÂçÊ£ï(@§ïï®b$.oñeß10c8‹D<û³¦vCæÀü¦£¯ ªcÁÙ´w€åÛ&™bÖ¢N3 Ǽ.ýbÞÿ៳\æ,#Õ„STb¹V†3W Tøñ’Ì÷õâþa;6G>I燅D$€Á×µ¡Ê¥õ%­”¿§½Ø¡û>M&ÊTAݶœ™è ïlÞ–ô‘èŸÒóIªpBN:}×YJš/´Ë•~‘Ñÿ@~Gœ¾Åë…iëV¯ ì�ç‚ø²õ¦ÔÓeU³s¯ÁBv“ª}¼ZSfIæ'¡#N£8é^„ŒµÞˆp’qô¬W+L˜,†)r,g·üÎ=kD:tiTõuƒýt‚½VÄ+ÐaìØÑwOm³tÁä£]0aÄ'EYB¼… ÍñÒšYß1£àlî>çdÜ…¼?á6IÐSœŽ¾·^B0ßžðóŽiœdˆÜý•#r�fHÉnôÉù€”±‚~çäu̸Kz®[Š)tÿ©nfÎ+„^/2ê8hë$(?-ì£b.D¤ëÚáhmøh@5u ˆ<I&‹Õ¨2ZV�‡AÙh›xÈI$N—|˜uýMƒhá¶rªÚ‹[B¢áýœåéÛëfâmˆJ�}äf,ųªZÁr =—Zéë’Ò=Fç m¼ƒo9n°»º’%+R£Á…¶ž¨%Á±=Q¤`™4 Dóé%1Bõ�·š0 öT%ß³3Qõ¬ßX¬ ˜Œœœ¾Þ†ÉÅNÁýÎ`ŸPÅÕLÞ,†Š¨%›²œþrŽÎ¯ª-è”Xz¶a4 U¢vÒQU¨±º¦ó =·[MºNq¸ð®¢“ìïÊt½u*LXÕÖŒE NLDÍÌÕ]ÞPU™ï‡Á\+ƒl²þaÉÇC§Þ8à=iè{šcÆ=LëR°½¨¶¾t ¶º5Z†ø1ß³æ>Њ¶õ¹uF.¨1ÿõè^\6Ý]৉Ê,Á|ÕÆuûî»vÆÉïkœ:þ]Ü ßü»dØ-TB5Œ¤¬¼?rÎb_¯Àâ0¿êD#$ñ.šxd¬‰7¶‹79_0âf¯î0•ùbÈZÓHÕÕûçnŽ>¸ƒXL¬4ÎgÙíËðç8óóHCQ@ õ8F<¡?=zwç)RÞzddœï-S(±*8U <d. D˜ÛÂz*gž¯k(w´6úw«Åküß|Ll%®¢:7Xþ5ì׸å&Ó-ðæ3�a8J ©jµ»(ðgúíðfâüßd!ɻѭ¨[Ì´^m!I—p Bm‡ú×Vcðá²ò&Eì Iõ¤=yôÕöôÑyèôBêV.HÃàšA4¡‘«Ã ·µiÚü¼°:™/s ,1¯ìKqÝ38ÛÝl²9[cìÉÉr ¯É‚v¦#¯U8 Kk¾gÏÓÄíÒbÿrOcÓ­><v¸M*“ß5„:oÕG½ŠZÖµz8½B±ÍãÌçæÀ.†âN³õÄDÙÎ à�vC›t5UlJó@«5“ˆù´–v"莜µ`ð¯oçišfž½Sþž?ÎHmâªæ²hî*˜¬g@Ðe¯*©·ÁìÖÇQ€Ftšt I´^›oǹûÆ6–Ƕ—ç*‡igž´@$’€Y­Û}6Žu‰.˜ª{µ mà}ôlõl§ùÿÞ/=R¨¢½D§(§írxf\¦pÒ}Á•q‘þ,fØàØœ| f]°†’ç{{nÀW©x•œeKžÊ‰GèNÆõZmSÆÐÐ Rº2Ï¡;P\~’DEÿä.퀜¿Ó÷Úã’p‚l'™¯8—©+ ™¥5ÍÐén.:®‡h¨hF˜™/ëd©Ö ·$/ÇaZJ`¿÷§~Þq++²%_ïÖô`×=Ù¶ž}ÄÚM‹œHeÕPŠÎŽ¶oc‡wˆ!7mEBžd²,¼¢mp¯×Â>à ¯“ì¿îì¦^¥P ¶$£³Èêà0’r]ئ´{ôñ•g­éÈêØÓaZlÌþp<Ö-‡à#o»¯ ‡5ñm;ËÜ}^A®¾èKÁ¹j¤Ú°3]Ðñ´i.‹¯WÓÛ„cwIŒþ½“[6Ö/1pÍŠÕ®ï¤:¿3´–eöˆƒ©¤Ê®ß¸öØ - Õз‡–ª­ú5Âz•-èõ¥Xb½ö$𶶸˜Þ56 žS?û}1+ÏðK$;ϱ±ÅdÐ1¦Æ}'UÁ –í]±ÿJ•Ù£+Ѷï'5Ë$ÛҀѵú +¿¢0LcLõ‘e‡`ßtµDmͱ~™»‹(>Îh°’2ëí–çKŸ­–þj”zsA.N[*¢òoß3q@ë›nÊ#ÎeLž¤_±À%ºÐ›Ï# "ß:7…“ðš’ͧR¯½¹{2ì¦` F Š²[»´ðfcl§ „«ŽßªÖ€:Šr½=ÑšÀÊÐ�uGÔ?¶.^<_¡ÄtÚSékÅ>+±‘ô<-–«{P«¼ð‘"ÒZ6y£9–OŽ¶ˆÈãô.ëž¹?‹o,Žê´ *Kû¡ƒ¼^ÝÜ Ôfþx’²H–Öî¹\5/wDâÌwÏ+ Zgß„žn R)ƒ—&½FÎu˳¦ù)™-Mܬ=aá[Ê‹ní…J7D·¶M¯‘.3Å0ß/Œ1R(ƒ´Q⨰FÅ×4‚˜ ý„¿xñ8™$ü¢‘Ñ;KŒ}¹À"P°o¶ô «Á*“°¶«p;Å+ñî¬/Õþ~$ ÇØè$Û ³lNÈ‚õá›O yËדã¤,Aejp†6Á> Ò‹ºqWAMyʼ±+…kÆÁÇ,¾Ð$ŒþÉrÇ)áðNŸ? ÊwEëƒCÖþºþv*Zaø×àGî%QòurßG pÛI§ýXãÚé郾�ܶƒhÁÕ /<ÒFµ:¬.1²M¤hGMõxÚãVìÄôìöa—¥JÒoÁŠÝ½ªĶ6ÖW³†ûBÝ…ÓK1Fmìÿö}´Ø#΋f ú(êP–Þ:MïúÁÙ>)¶ —¦Ó> Ò£ÕoÌ”4Ÿ``Ô_ÜîÖ—{"ˆ*Û±-Ý•Ý‘îq8´–¼YKôr»‘#%þ¹AìÁ0uaÜkÁ÷)Ïõ0Ȧ¢°Ú꽊Œ¸î·võV’ì~âÍÍ¿”~…@µ¦;Õ]YfËAú-ùöÛÛóMÝóçl¬3Â*Ú.fãÕ«m ·¨“JzÑ‚œŒZ~X˦[ÌÐ"óÜš�4Z§tŸ­»L 0èðwÕq%#k Ù=ôôgÊñü¶—ñm¾´ë]ÿä[€½J·dxXr„9ÎñäŒ {Ô½hü ¢"±‰ciÚæ5¦H–D  õ�6Þ­YýáXkìé.T¼‘è –ÝÚ3[•XâÑV(ÅãV¯¼Ü‚/VÞøw|C…kÑ;«U,²É ÎrÓˆG°!ÝÙ¡¥k[PEÿ¥/Öõlú¨•í|c6GÙ÷ÄJD’HìOâæ#ôqÚ–Ø¢PNÊÓ�šçÖƒ |VTþ¨à9è[î-:`ÐÜqxó‡[¹{|L5Ð$²›Q-=/ÛúÔ$MCß€Þ J>¥ut£ˆ.ÓvèÝÑ„}U2?¶J)F$–BKÊu†ëÙq¾cŒÑ-ÙúŽù™e†‚`)F·'VdëÌÜçKZˆn Ã¯Ú 99?áÀG’ÎVgŽÐBUwøÂ$ )©i¯36‡C—OÜÊ,r?rðÔÐ:Ê?'m–oÿ¾A”œ]wwƒ…  ’!»æu+—ñ *šË‰¬Ñ{Ñxˆ#åS‚+!�+]}ø„9èÕPûè äe­Ž¬pÛa/ Àw‡Á Aè矊Þ/ŒuÍŠŒeØ4æA5^<Bö²–ýëáOf>Z‘’.ö™]OÞ¨M+/SÁ<±™þ‰²Ø‡€@WŽ¥¦‡ÖñÎöü²Ö´ýUšÁAÆ/v6a¶%•Å_·àóµß˜‘ÞC_(¶�ðôµŽïhµ5XÒ[:î>˜n.S{0¿æ§NR¥‚ÓW|&3–n³œ~7‰P› •¯± ¢ÒÙ•ãìLÍí¶Ü»A+œÉ6a2ãâý·×5¿5 “®Ðñ>|S9½kµ©[N‰ }ÿx¸UݼL?.=›F!O ™ vªŒ¥Ó¢š¦Uªú6ߺºÓ˜ñ{šEÐ 1•§A»‹¢@m6°ê^ÜÑ¿ˆþ‰ã"ó˜ˌ»Œ$VÖšIäS»P”:ŒGµ¯²W÷•-Æ<4L’yUåh%L2fÉŽŒõüÇ_u|,m@œeèQï)a(Œèú¥oR¯õ$N¼ÚRØmÛz§,üѦ(ƒèh‰ã’! H*xP[ïe—=·¡Èò+-ù™‡¶[•MíÌ» ¡­qØ{±‘þ ܾı˜:ñûwçx`ã£ñ1íší„¬Û›�a/VÛ½O &AÊö :BgD }Nk,þ¯*o>: ÷ìÅHû¹.–+]¹ ¡%ƒ>M܃ҔiT^N�f)Ï_å»Ìz´SÑ[&A¹ë1’ƒªúô­ö¹?u B…zû¹ÒäY•¢ðæ˜aèæ’<(ZÐÁz‡>ÏM¤ª¥ÔŠ~Ÿ˜Õ¨¡7ƒ¿9¡}yõÓtÝ.9™8—TsªWL¦Þ Br™'ùm3bÕ«ûÈò(ý£>¤ÌacR ÜÇnØ Ó©7\¹ÄVÆÔi–e#5TÝ·,éö#x§¹/öMµçþ#Ř{öµªëqÓÍêCúщ_}`ÒòëןI"g£ô0.‡œöÀû§W×îø©¬äAg ã*;l5oɇ®k $ÊÎ�)±åѾ†Ä¶¨ÀW´Ô@ÛÖ"驯3UK dµ¦ªy”y¶Ü”`5ˆw]ʉîn´שE’#ì«ÔEOËÍ Ï±í,Š2ôOD’t²qƒY [¦gÛ‹+Þ‘•1Œ+™JC[`«÷Ÿ›Ò>ìIí8‘•Nß(Õ¹I©¹¡S¸Ì û‚îV›•­g0Å=vãjG‡½u;ø!õÌ íˆ?èâ&÷]/:-VÜö5OŸ,qÝ@ñ__cÖœ}ýùùmÞöµj2ð¼¯oèaxÂqîZÜÅ짊™)þ\,ÐT Ìð¡¤÷ìtŠÐ×…¡¸ }³u’»=Ýïå3‡`€‰ÁJ8»Í`µb_ãH›Œœûg€ rÖ9R¦²‡eïœwÜÇ5²WT&Yá{ Óê†$(¬D9š(C½™Ð¯ÓyòÓô+ŠrŸ= ÀcK«žÍúvë‘RÝ´ªoªñ>.bGLÅW<Ž­nßXua›vŠ×Oaö±²ïccÞ&6uÖ³nÝ8\«Ñ•Í V8”Öûþ+±ßù÷‰ÞºþtÂ+ìGwñÍ&ùi*MýÇžóÚØ07³3Zqq§Š!)Àfõ—éóá>r¡Ø\XØ͸¾ò½º³M,M—û] éÖÁ{]Ñ<"þB>©¤y`'õå®÷€G»ÁP+FñFËjÐIiF:}¦ygùø”¼4È/i·Øß7~æNRO¯žež‡‘nRÚ_¼§Þ×è{œÔ€ƒÔ‘8T«‹¥.甽¼¿{Ðq“lGZñ._)ªÂ‡Ó™6éψ[í+lΗa]ëiÄ¢N"¶ ×ëWoÖg}›Æ=•Ï½B¼A«¬/ý^«–�ÆØ *»Ø*q×þð' ²‚®âªÌNâÙåì9nPs03Ãk÷ðkq°ó+{DÂl¯üÖ&ÀŽ°eeíþ­”º «¢ÅÀªlSM…rÓ/€ TI{"ÛSî{æq±y¦»m‹ ý´LYP‡(1Ä[ôÍ=í‡`{j1R”[u_g ŠGK›Q¶˜6ú ŠX9ì*΀†] !F™'>…Ž,ì¹Dé’þ~²Á.õ¹¾¯@œ#IJÌÖ–"ÒÑÑ ŽgSä<¥g/c½Ù¨Å¤†¼ðX ÇDS_ž’’\±f ´Ów5ŽÙ.«ÿ6 ƒì·”Õ(×Ë3M\‰óÄ¡dÙ\V7÷½aJÙtÏuã'‡C+ÐSU•.ËØJÚfˆ;€\ÅSë�°æ 146ôD(a¹mŠäøÕ©«·sd£FbÄF)ß´«…-"Cœ[ÞMKœ::ò”„ä'ÅBàÂnè ÒÊð¿Þlká"MHDc¶°©qýùÒÈéÆŸì©ÎläM*î–dtd—AÕ4^…Õv½Ê_ëþE ŒêY>ÍÄâæxØÁJ5âSO'’5`ÆM$µe£™g€dæ@㇞Š•‹:(ÆÁ]aK;ZÞº šæ–Î\EM,“È)6.Kã»õjq•,ƈ™SXÓ'ÔoŒØPµïûÌi•U1ãwæèöF6ÛžjÊ) ‚ãpþ«¾^™caóGui¥Œ‚Ǧ aýí ãÀ¿ñô_aØü :Ay9öduŒÅ¡…=îôcßÖ]¶#YÑåƒ?ß@yW{+ÀåÚ‚Rê‚Äþñ'ðÌLôžÜÕø÷$Ëxt® 6“Ž}?*èi³ƒ…Ú‘r\O†5±2/(ó¼TŠÓÁq KifsQY ’'ÀØ݈ÎÒ&v´j}ÜÖüHorËnß=ÂŨ8vœ."pl ÝêpÍíNÒÌw‚€XÒÑøsôØúçýùÎpGXöB3×u^,„sÈîUÖ˜pƒyÀôÆ’Ù}·ŸÌŒ®åvbSS¤Úø ‰4Ë®ü.·”k¤§Ù£è‹€áÊ )ù7Ù añK¸`>Ólš‘†j†nó¤ �ÈôÈ¡ï]¾¦¼§,JÉ”èÓ»4Èm&Ì[LÍzmyòzbñ!Ëo0ZÏÈ·óy3õ]äCïõëEËƶŒ¨òO‚ÄD~ãC¦,òõ¼Au¨¤š·n¿=�Ô£HV+ôpõúC#E$¡¥›ykÂ)í�÷ÔM!$½";^j×AˆôUÐЉë³ç·}ú뫘UKÒ‘Ñ·ÆæÁIP† ·÷¬ÞŠÍ­¨Ýß ¥§NîòƒL–ºÊ’%xÍtµ7EîÞMžÛλp � #7eîJþ©ë&*p 9oõߢáKOÈ6GVÌö$i¯C¶\ºÁ½9—ðš= äaRßF‚nÙ¸¡§�Í,ÑЃçf’VÍt<¬zÆÞvg}&á±}ÈìÇK1÷H=ÓÌœ*¤D–Ž?‹™‡t÷Zìöâ¬Ü¾êÝ¿÷½7eÁèO¢š6ÆG¬¿ ¿`¢“t|œ¯„ô²,’%_É\ó€‰Ò§¾ñæ€/ìæíÎ2K 1‹—0EAé¿"žD:Ì’þÈ8&ëQïÙ…>üÙM•^m¤[äû耻A•shyÀ‘Ù-á6ûxÌÛMs?=zW¥uŽ9)ø÷»µˆ_+]½(y{.à OMÄŸ±€þŽè¹ïmffå7zhE–ʱ辣£½øôùaÇí¡vê>;íúL36eÔø@!Vл7…Ÿ<Áƒ»†Ògã9CðâW_h‰µî_Ù›úy+½ßŠå±w`@T‰}}»~BÄ`ÿ|]wƒ)>®©îIè›ÚPfv¦-[ÖªHJ6—žlûl²ÜëgÊ‚¦—àé3×=•�žXÖ!‡dßmΛÿï‹Ðiy©W?ÄÃÔ¦Åê÷uB æÛ‰·Ý…c,«/Öü ×7¤»wÇ‹Âq€JY3EGÏÔv,‡þ´ojQ{¿L MŸG FÕ•D¡.†–2%Û•y@i:wûc_[Ÿ'¿q©±ññP¬êÙUšÑ{OÅjÒ4ž¯á03BÊœ]Oç YâEâX°Ë µ0ñ„‹àzà/Ý…~} ÷ø¶¡m5¡UDÖ8Üp¼v"‰"fMi<„*ë ÃÑæØ ãö0¹�†•wj‡ÃÛ;!6Bßæ|1_#guœ=áí r2ÖV#ödwävoOÐÏǽ³K"÷³ÿ„?¥ðíP¾®øôÆP…7ì<"‹SÍßî½zÒØÆ@.KqÆôfoÒ{‘Ù:mž-»þ6q. ÝøAÔ)Ž,³ÜjPI=Ú¾Å_<>þúx^ŸÆž‡¢�½ûÔûõØíJ4UuCG‚NJn÷]eÄÔÚKd£5y«å`õŒ€!:šôXuôvÛÛ2ôb¶@I[O¨?ï•ãÎÊO @}vlGpmzŠ±íÑ ºôXÆS.…¸<ð;‹,MKÀfE°ÝУšTxO[ÙLÚ½‚B¦Ëÿx&Ã송1ªñœi¬ mùrRŒM¡=–9ÞJ£øE]—ÜiØÑ•n.[õJADÁaf}ïLQ¸Ý͆8$‚‰üÕ´Ol%&Ú+°-J‚¬þö< eæ¤qäwvJ*’Âó C/éLAü¨t¹(Õ›>xÒl¿Ä æqµ¤·7[й¶ŸÞ�ƒA—_ §¤ ùz[&¤Zuª\˜Ý{gô¯H©¤šÓçx Ì(´By¢ ±¶Š ÿÅGcÝf•#çÆTƒª2kÀ”&VUÜD‚ ¬7Ò{ˆ(ã± †‘jÌO«îÇæôI¹`R�ün¼*¿¥¬,$ÑÀˆ!Ž´­]^î€bÛ1Œf2 üîz ½aD2]ñð*ŽÆiŸ€¯{ù3ßÓ ,#ØhjcJ—¦ëí¸ËbÃãIJ Eè,¨VSöíîg!³Ù…rm®{‡UFÆL—Ñ{eß°ç=ó̦†êvo€YvkÚÂúºbÂëŸÿiEKÕ‰TPíávöf¸2pžE×xö›¸öÜ›�ð$nžò <^<ô…Økò&j‡ScØq] UÞô\ͱ^ã­jWÙ³§o16«lC ^'lÄÓI‘7b0%HV§A´4LT_4—nüÈåÊ&™©Î¨­‘lÁo¸…s4tgkܺú—qïÿÒçë~–ÁÞ_Æ‚aÒÝn´a^¶œ¹"¸ndßúÙævV.æ`R¨äþÜz@ÎCÁ±Y¥‰Ò/ ø¨Ê¾pX¨”j/ôW|Ï®ûŸ¹I‡³óŽq¡æýÞï?4ÚKçÍ,ä=ʾjÔ¤41^äªûz׊öÅ­+.äÕÂ_´2†¯§ÁSj§ÐYoêŒ÷ ÇW2ILó¤…{BrútP{ZåûzÞ ¬Ø[©±hÓ"ó_YƒÀibơߺövWãáÈÐxAÙ½ ˜ŠÒ…›ýY[ÀáÚÖÉÏñ°ÂסœEÐ2zaµ°»¥ö­¸9µ:˜R?#Ž'9Ì'Ö-3d<uvºkñd»í1Wlqp^'A2ž=¤«Ê˜ÓÒHhz¾÷ q±C{‰F|ÓSý:yˆ8^vm×5>Ñï1à.Yºoîk '‘q¯@¡ÕµÛb¸hc¢8zŒýuɼ„øIŠ²Æ"(ºÑ«™™1ÁÒSó¸­‡Z•Oê¢,^¤D!¤¹Š kìáÊy¬Öâ"hºþ‹î¨ìÝ÷M*B¸çÔR k;?Ž.øàè‡J‰¾ëS®væ qÅ<CCìS‹Wôî) )éÀ¬š¹>Éâ[¾šn±'1c±I²ò`·áŒvë5äè=ëÙá” tèúõ ”(òzL„j(6ÇÛÞ›j €˜kÑXú½,¥†axÒQÖv§´µîùUéG·‘õ/"î/{.Ø:À 3¥ÎCäõlÀ�éhïN¢20}t€cM.Aò2™¥Ý LXšøLûxüc«Êz–MkwSOÏÝ]ø�Zf ¾¿%f´Ì4rJ´ÙOìÝ3Æ3˜:M‹w“´§ÅhžÊÚ¹nTOø–vcá¡U•§P$04ühwM7ZˆåHÑžË`{±ÊWùÂþ¡Vg ìõ-¡6`Ý&• ¼øÜ=”UŽ`ËšyPëu,ƒx8{ƒɃeÌêw5”b²ë‰‡ôi(õ¨L>1xV0]jOýô�¼ÁÔu_Mú@ßWÇwõàüýĉ“%ÞX®[WËôÁÓˆ’ÞÙWk+ˆY¨¶ÞËκQäÁŒr3Þ¦�p´²x—þñašäèë«–r‹“œ*H4©œï+7©ÏÁïM½Ò§úѶÃ$»hg¼ˆ¸‡´é¦Ér<ÆþmÚî–šó¯Ò&ÓÜ]‡úcp¦#x¼Š€þçG˜~ÚôŒ6¸·”ÂoØÐÇ®l#OÜ/=J3ž{ši¿;Šè˜bP<ZæKºwá!x» ìjlµ§êm¯¶™hË,ÆíK‹ãòÜ.YºÃéâÏä47訹°j˜è2Åœ~1o^N¤¯'6q膬⨹Q6:}zJÙe“Õ´¤ß# +Ï3Êž§”[Y‘õãq�O¹/Ë’öõï<¥èÄ�r[Fæ µgÏB§\¡gËò9ÊÚyÅ…rÒ4sÈ:TVç*(ÏJóÅìf‚­œ”#„Cç—àO/uoC4‡O‡Y[Ò¡ìţ"·ù¬ÊZÝØ»ÅÓŠõ\æÝhVFê•®YAbã¹ Ñ ×v¡É:YZM wE©&ȸõxîîýÔ§@©$c²Ê¶vÕ [:Wºäq­ç58cQYբı§3böÁ’´Ï¼j ‡®°@Ÿ¶Á}‹$~ ã~–(†“jÂäçü‰aRo èÊË`•Úª±[p*J`V¦ÑÇâ}ÎÛ—·Õd=ÍL‰4@ãZµÝÒÔ¨½š¸¤óPwñŠã’m„DFBj€k¢Rg:L~Ð5øÕ®¾ îTÛ˜)Ç .e’yb߈²Š'këã‰ßÈ%„nA*èmß×]Úèš{†4ÌUbhóiûŽåÇ'À+ÅÍ%xþYd¾iÂ7•öå ãäŒeüêã^oÃúÔócPöu‘V'¡çŠ’ e\ÃA;p•ðG³|�ô1Íâ’þëxó0M¢Ð§e�?&´™·'«T‹Ým§È‰Ê™ºZeÐ gkÐÿ~ í)ú8˜œYÀaù ÿ¢Ðø¬šÁó^Z×]'ßt@#O0TôaÚm„ýd` ý…‡ì[5±0 é¦|ε˜N©Z¢¹ñkþ˜i„V©˜ÑR+Ûh³µ»˜tÍ]Ýè¢W®žÈÏyÑÙ†w)Döø8&סˆEkÍqÍÕ?¥"3žØŒ#£Ì�ÉÇðÇÜ#hŒ@ÞÜêšr×ó�Â4ónli/&hDw0½èÿØ:R¶Ãäœ~÷þ‰Gå$sèèãÁbû2Óx±ð'{ã Ú* [ºY)37‰�ŸYí‹ ëÏ®CB[öx°Ì“f¬wŠuïÊ2”ã%îà ª$«µ"¢bž+XmÅñ4}˜@9õ]mšø¸X™_ÝÌgœÄ>æ3E¤ªQ54Z…?¢ô†Nöö|Su•n;š�¬Ò{B‘ëf³$\—Ü&¸£n¼ –‹îÝ|âL@0æ¯#ø²hÁ~‹ŒOê»U¦„É •"xÑ(5J¼Âœí5×(Þh§};ôu]GI²#ƽݺ¢›-¤-¡ýCŸñ»U¹¡ÕöðÖ`ÒÃD{úPNÀŸŽn#&ý£²=âµ@FG|¬½–| :—0V»ù¿¶: ðXá_m„“Òù89CÒŠE«‡4™œÏ´ÙyKÞnçx¡e‘ÿ±q hçÌÛ‚E0äƃҎŒÿ‡C†àÞØŸZ0}âkÆ°ê¸ étvƒe*Ž¾¢Å]z‚%¾…B? a$ãEåÙ6}Ýz5ç„-[F«÷zÀ_ýoßý‹yíÏ`8 ¥w~[è ARDbæ­Þ|ðPŽ'ÎŽ¸'ù²_SîYY‰a0Ýšh£¡£‡ Jâ­VÊÐ/o»½ÇÝ»TFqœ9·mDghvÛ&�8ÐXîfÜ)\IZÌÿ’ïîÆfG¬c¨ôz&àn>=Æа:ì¤_‡ª«ÌÁ›™¥Ò«Œ^Á¼ØgKÏÅ[ŠÒ´¥h j“4ØGGm°¥:¡m¨,!�‰ñSý…HÈ3~Õyè ª ׳Â�[9-Œóuæ:ÜúÉc§,˼"„þž7–³‚BJÖ;ûF§×ØÓQž-Íæ³F ¥Ž#Ó^hêÒS|çÿ1E™ÀjGP(ÙñËæÚrº¨tŠà{‘&Þ‰Œöš$Èk=ܨ“3yŽ'kƒÍ³¨S9í3öRJÞ‹®ñ(”î­»ÝìqÇ@üDO%OïMzËØiV1^nµF«zûn]Æ>‡ØWçÍéž «lamHI{MUåÉ ÃŸV€KZmO*ü'ºô+úÝ$÷ýé4ç'·iª¡ôwì¼ÒuÕ­‡· ¬¿ƒÕy¿95ÚÔ|Sø+ßð·¹î!”ñó'ú[t˜"dÎç*ˆfK OYw¶·L_m×þ¼xÒÀU4·tÌéৢ­`–¾æº_Ÿå'{¹©)ÛŒ„J&€š.Óͨ¿”é;<ã¼1²Jñói8ûÇÖkÞâ¾·�ý¾§¨YL*¡IQqs¾ôëZ)ˆ,j®5EeX¾5»ÍVe¾½o`*äÖQŒ›?îÁ†P€Èï§fGÉ™;r{)ºï–®±5Ä,Í»B€$ׄ§DÂc`çú¶×$w„H¨"JêZ¯;çAÚé¬uÕ×òÆžÃlìOƒ§TþË :NÂ¥uÆjKk?›•ä—Q8>…E¹¥FN.¿½¸A×rŽ’9Ó9ðMû÷}ë‘Ä™Ï"Y61ëرšßòÅa¸ý î"ùië¹ð?V(äºÚ,óWðQV Zì3 ÿŒªœþøE4Ûiú‰þ+ú;¶ý]šE÷T<#sÊàhXAC·ÿöù0.ewò…Åígt{¢Ëè6¦ú˃áxzØê©J_4 A´¢ ¼q¾dÓzß+$AÈù†âÔ¯‚|Ü~P 9Lz›µ#˜“`Ë•Á‹±:2 Qˆº¶§ÇïÈy‰ÞHÙ\,˜†¡x=hªlÆ„´<w7ÚJŽU«IÕ+¾œö?¾—ÏòC9ÀSRÙZàf‹` ‹ÀxˆŒ_ÊAüÚ`?)ýžl iÄ"ˆR%ewƒzb}_QÝ0ß9D{qKød˜ÜÖEÂØ땆-›zÂ0H©½~BT®¾Ã¤ƒ›*=TUfzÑ^Ö]k5™¤†mmr¼bÝ3¯ëè𧵥v·dÂØ-^ƒgÚNµ–Êe o¦¥QÙS>}T¤©ÝíEdo2ËÿÙrîlp¾¸7pšSgØgžd&k+ù™ÑnC±úÝA®)þYd€Üi}y ¹˜&žÀ+L›2Ȭ/FŒôD­JÈAl)ƃˆ^š)²…IL=Ö¦§›zFÌM³™Fz8C™óºŸì›8]H´p²ˆ±,ÊGê/ƒ2ÔtPð¹Í]¾›f‰'ÇZ1ÈæÚGÛ{‹ßí§öòa6‘qÑ~b¦…‘sƒdõÌ™Î÷Z—3ݯA÷Ä_c×u›Ýë挖T)¦³QÐewf¨Úô4„uðç¬[T\ŽrëafÞ™XªtÔ‘\(ÎÐe0 }:P—‹* '­´ ¸ÒVŽ~ïú†´£Ï`L…ÌñûÅ {ó¯ÿó–[äO¢&Žÿ¥*{xÝ ™,Û{Ç1%_r_÷£BtW¶Y ½‰)N>1œ‡j¯Õ²:ÀŽÎèÕ¬Áæ¦gÕ㤠üÚ§{ô† ß6õ Ércч¢ÒzÊû8Oêñ¢ÀS«Â|†Ô€ìœÛ—JÏÒÁþpWºOãRG;S¤k.h€Ü0,ÔxÔ{1i{ÃîyÉ`5²-OéØE¥˜Y¥­f…ytdþoE•»¹ï2ªW¾="ÿæ@7ÌÚ1;¾î;&¸™ _‘ˆ[™0ƳêH9×t®wŠ½ èG‰ø…{–b3õ£{™z£R–€[Õ =YWø¤$�¢§FôGMš±ø‘`Eåt¦Ev-j[3•J%É»lm]PV¿=ôûNè,ÐBö"£^¸oÚóâ~{- •Îfª: ³¡5Ëôì?oYüöï[fš ðRîX‡\ùb¿UÏwœn.¸\gõ? -AªÞqËÔK,'Ý]-K¢Â‰ã @fÑ ƒt´mÃŒºnø躣ìƒÚ”‰¨Ó9õ»­§ËŸÜÁšEƒ®¦ÂÔõÁ–>kõ ¨¦°ñÖtõ ÑãøBߤ0GfÌ“ ¥g£Í_«d)᲌®÷\"Ó£“ŒÁc‘'uÙZç¥H?XM€Õh™(úâŒ.2¶‹Fç–vj6u®y¨?ü^ê‰qsF×éÚ–·tØ\ì±*hÚÐâÑ£å®0jµž"tËy ¤T;+'p"~Ó²Z‘ÏšzX–˜u!¦¢}ßIÐbͲۚéÙbñQjúV3znÈtŽ¿½¯W+¨÷ZÓ³{PЫó0]eXsÁÒ!éÎœú~b²êŽï6üì(ãÀ0¨në÷ûŠ…|†ÓÌâ#Y"® ’AÓ4Z¨Èy{÷&qîâ!¶˜Êv³Îs3:nÚ<HØZˆÿ¯dcçîËs‹z&Ll .8'£Ý¿=åAÕû CT¢[£ZòOå4·òkô(ö(D¦ÖåÚmGéÑÁýÂÝÆ*»U3ƈööŠ*<ƒmž_n[:ã­Ý0¸p ÅÜàtÕKâŽU¼àæÆtlV¦jòÕ¶{»*¿Õ³4Ldu.Zb÷ÍÇJç="MšaC¿Ì¶ÝF¼üé êàÈVAÕˆ+'*ãÙ¾}ïÖ§–’“Õö ‰¸ÉO÷Ý·æÀÞåÃéNQež~>ÏÕž~WÞ:b¥FŠ„æ8Äòd¤;YƒŽ_4¸Z4AåAñ ìõ™ÎèÊRŸÙŠ{¯º#!þW>ƒYèRÓ¢ð¡w`÷Âß99ž=Kéæ„ã Ù!U}·éÜxÑ;gî x§Q¼°î ’+¡©í<j¢@°¼ˆ4aþübÆ'Á‰ïOM°h<ÝŸ}ÝMo—ñí2m(Q€L?Ì‚ë‘roÈ{—ZN/¿§€â† ÒóŸGôCO­‘?›Ï‡7J‚(“ÇΠ ˆ‹î#@êÃ¥$ÅÝCלaQè5 á<OY)ÕÑrÿ›“êìýi›ÃÈÚáØi0@¾Ùô‘ÚsõZÊLð ¼jìwOkbu˜æÚïFQæËZ0t¢GMŠ(ðÐѦS�•‘Y¢…¹vù¢9Êßf[y£x¦"-%w,–Þºùïÿy[üoeʇÌä•ÿ6÷U†R¦¡2ŒŽû‡ò„Ѷ®«y Ïý5P×££ULëË ®ÿ8b#Pä'+!‚¸îG6©×äaþ<€âvÒÆ#ÚËìòép¹ÿ%ÿ¶JöÔ){ؔͷihC ÄúýZ2Ù¥oÅö5›(̦ãïÏðîëzUÕ‚HÅ_mäq ý“y† ªk ÿni¥?šú[Ð}Ü—+‰Í([8áÐ ¢Í·ƒ¯`Þó|Ø}HQö?ìÅDïÞøX‹!Û¸›0¡¶'ü´Û[—yiÝÄr@©¨œÿYþlÁô½wmýõtìéK9=é.€bh¥\t9uCÝKsàÿ¬F OUÆ}·©±ˆÌʈ¾ÍŸmœ}Ä7z˜oLÈ„øʬ-ÉÃ<t ?ÁÿÄ™.„®ÿ1aø ø»0‚ ¬1I×áÏâ@¼Çj)=3v?v(g,í�¢X>;øïÑ[Pr­'ØI‚tûîñT·õ™Ž%îŽóãĪ¿[ÿâíŽÖNé©<3< íÕ¢4£þ¶¥šZý±-9ª ú´­[Z€´)¡LCz•e6Ƕþª™¦e^\Ó/©Ê(sâ÷”LtKš³ƒ+ÑŸÏX—°qK”K´×€zYî¶YC7ÜÒl±Æ?�4¹áZÄ, t• á.g¨ £—aS`¶ßq_Ìã ”?쎴¢NçhÚY…Ax|Î>¸&»éž nìœvp’Ǭ–5G—Ø |È´Ì^Ъn¨K¤!‚XøÏâ×ÿy£ô܃LR¶…ÚÜ=<€?DYf L,'¦“¥Aò>›­—@}raöf¸…6ö"{ÌwoföD?Eè’[ŽWÛßvöÉ=SuÂ05�Ó¡bëO r!ßr­¨?ø¾Ä† =A›‚a`.EŸ¹¶ÞÕAåƒ ×\ÜåæbÛ±shãæÈ‚¾âÏMq“—íåcUn‹cÿ%è¶àÛž=pàD|±iîͨ•žc€Ñã>‹3$GÑØlÔÙÍrGÁýyÒßbë1}P¨4lù˜gqm!u’‹Ó“^SE>‡èž‚´ŒˆÑ'cín0„ãþÄ#Ð_ñQÓ… B*Z˜å§RsòTüµzÎÅ„wÍ8 èÓ¡_—Å,Ü8AT+‡. Òù²Õ3)mYų̈Z-9?�Y¼õ³ë.·c Gj“H¿.;ª÷¶1Âê6<Ôäô¬(.3¥Z@¨—þÕABLßöÝ›ÑbºFtçè.µúrCŸ7J}²0¸Š Ý–ª³.ß¹, †ŒÂAum9 ‹ÏFÆ‘Ú=‰úž=;1¾«%Œ[Nj ³“éƒÙ^Á\·Ú(éz«\°h5eW}óãbͧvÊòR!ž†EÈÇ+âž89ò{J3Ïç ÙN;vgçq¶û殂y½–C±V6‘]zšTÃYßHö°0&¬ºZ^Ö\Nâ¬È¬â=P´ô†½UÌ2®Ž”ôìV«º¥lûò‹¥ýÙBº'2£ké93P ¸ÉñàÞœãÊ?ÐjEFClš‹ uEÝÖ¡ãÆiæ´“ü–†æ «=¼&�-4i à Æ£5±-¥ç¬[$ý»þ]£`§Äæ•ŸxÓ¶Ì;hò\ePÙÕ™TŒ«²f¶®ˆ–å~oѫ̪ \Bª&ê*H¶ê®£Ýt#ÆÀ²˜§Ùw¢ok®Ó­*»ú MA gÒŸ*Z‘yÊ6]œ½SñÖÈLe;ÀÌ&Y7ŠôȾ/PÝÉÝÀ'+\²œ"$R‘•ÀL.ÐÆv3E'Ýj±1ï-ú™­pùÜ¢ê~r “gÏ%ûx™W[ÇéÆÞ÷<jM¹ÚÖF âƇ#Ï6;dÄÑ1 ŠoK3ì‹cÅÜSt¿Wª åêv={ò�h%Ý7øÊßÖ0˜¥@Û ÷þè<íÅVƒ„Ä@±•àVËØ$¤ñŠb>zÓÝÑPPl1,ã†%¦5X^ Bh.Ø#Xûƒ‘XHL7K$ši&ˆ<âÊ©¢ê/V¢]¢Ýü‡Í²”où¢ësšEËÜHœ'Êh˜Ö`´CÆ®}s†®?%§ïIOç0ù¶ÝI¸IS~¾LÛP¬Õ0ÃÒÒR+ËÌ•s7VåCÔÀ3É‚)–¡CMádc‡7 :á—éÒ¶o0%ì©„û]{: „ijW¨å°bÆç»sû ›À Pþ‚®=CK—>ù¯E2¢ÅRàÈÓ{g•KÒ}5Ì< ÑŒÃ¹‡&ÞLf‚iìx ¢ˆÉq¢<}`>Y®åøî™±qæ9�¢Ž[”|j›‘½7$¾›á\ î]ßs;°"ÒÀˆàøNwæè(è('°òyA÷Õ‰FÂ]kàÄwÖb’;÷\Þ{eÙúWŽ!ð»ÎK¤•Œç(èc¤ÖáÆ l¸©À§áW'\gkØ­>®l ËÐQ%#v1€›ÿ©ÞR¥6Rl×Ñ6Nqs}Kk1ë¹u$Î/5ž>Œð6;b>`¾v´êWîßÅc^z2æ—׫9µçX–4L,[+F<œ>€âpOàÂ_RšÇ¹J¡RÇ?®‘)­dI=ÄMGæqVìfm¤Ÿî ^ÅÕµ†·­®pÊ­²Ê*/ôx—ý^'îX¹ÅóWL5¹UN´ê—¼ÍØqŸa†7êÛ<üî*ªû¨ ‚úT´xcGê)VS1ŠäA}ÅL’ñóB÷ò;6.˼€ {mµƒ^æê¼[ï/<²Móß{yòV¢1Ì<†¬=hŸò@m§“ªßµµ±¸N³·‰b®A"2†W;ß÷ÈÑ?Iû|YxI½+=HÔ-‚4�LÇ�¤ÆÃþ¦è`¤V<ñþ3À;Ç£7Dêú½T!¶sÒh-?`òyÖÁ<„e" ½.{lÆË`qµûŽûH§qþ—,õ *Ã~ ÞiUÅb``-¾Æ #µÝÕÔÑ 6ÒãJ{H<G+”·m¸²]×¹ ×ÝÆ=Û’‚3¼b§?îuZ% ‚sGGfåJÀ€{“`ª™Ã…Ã6kÕ§Þ\Üè¨æ¥Ã×�˜€Ng„ïŸjÀz!h2*èq›3‰r_x+¦©ÏéÀŸ¬sÈý}Anà;ë€zœÐ)vÞó[9�…3ÑRZ5XJÝÖ“ÓÃ:7-OªLGØ@BOz¸þö†ïº[ÿ…Q/n¶TƒDïg…UbPoô ÜÔ­7å†z£æå7Î7.C_çÒÅ}DÇ?ÇcX:Þ7JùöoZ[ ¤§¿E´ÃÛµç¦J1†3ûŠpøÕ ?õ:_[O'c¬[QÛUQ#­ýíÆpT9N¡€*œ¨ïulV ÿk¨oùº’¿²¢Š<ä&  *Ž>•WžÅíAä&Û/ãœ2Uj6÷1§¼6 ƒ¤½xPžéó´Ùú‡¹òðHXVa·ÜA}ŸÐ$ô´^3§Œ8¶Î[¨é6P€2“ ¿ÓEŒÊØ÷ÔF¿‡Š³ª¾ø ÿ®…ʱAš=ôN‹|•̉¥¢-‰08A+Û*+½âªèhÔ}¢J7<Õ¦Ÿ•'EK‡›_Hó†iuè¼¢÷Qpµþ_±Q:r~¨=az¬m«ëž-¢µèŒ˜úÀž7?`3– )ÀQqXïú$\tnîæ…~Ï¿ç á/ÆÒ¹§ìË­Õ(Ⱦ'ÏuÓQÔ°zõCÇ´ó'+Õ5°¹?ƒgs¦Š@elÀþ\n–ð{áFþ±ù¹àF~Û8šð4™iªíX6þ‡Â/ sé4C3Ëâ©é•Ô:&=¹W�Πg¶éUÕª†v<)7(€ææélLŸJ›U™¯¾€–\—Y­XeVn2nl¶×ýws˜çUæ3;¸Jëò È̺÷ Œy¤;4XG‡u¾ó±é}0¡¸p‡@¦·Y‡9øXPù•¡µ5ˆRcìÝÓÉ”Ýý©AgóÎ'žy™ï¬ÆS#Ýaã‹[ L½-Çu—Õnµ.B9¬*¾xm-j ʼ/ÎDµ™‡íîY”ú6 í Ý‚¼Ñîê¾îGo£¿u·†â‡¼,-t#¥âˆ©œÑa¿qkCëõ0xÈ‹¿’ÐIýH-¬±Ž²ºâÓ§S"±^ïLÚFÔ¢ÉÀå5w5n¨ê-%2StÈikÖ³çÿˆ XØ]Ûšæ×G7Ï"wà®nôš«Ôºl+ºZ'%=Æwo£¬ÎT+€¢q0ªiëÝæa¾ÐùÓ¶0ãègo«Ë€ÝH)ë­ÁÉÎew+{oh ÅŸv—¥I³ë}wñ“*¿¹—ø³[˜† ±fô\¨¹[3YŒÍD»ªHmmÛM"~ø6‚´×˜Ö$LE î¥TNÍÞÛÊ=UWtÓM3`§å·2¹±Ÿ,¬37¿e3û¦öI(ÈÚÝ´µÊ› 0HtW«ž+œS¨¢«nª˜ùct—="áÉUƒ´õ!âe²Ø^¿ÂÝ·NÝVn…ÒD�]™Ð¡cMB •:œ ‹Ø"ø„ß0pÊ™:×ûÎâ÷Ъ^8ÝU“ùÿô‰œÊ‚8L%hïÚó*b…½¶ƒù¨ˆL\( ôÇ8ÿ¡§qï{ß~RóÌ;7sªIÌ¿fàªf†9CšÖ]­¤ Î{ ¹EP}ªb‚UšÁ9Ç¡3.&{QÑ/Íý9?D9‘-¬pZ¶yYf— PâÜ)[‰šÖ_<o½þÞÀäüyëèŽ/Ê”ÌxdÝè©z¡~cJXq0…Þ"ç Gý4ÃkE‹Ò2[}%HGj¯šÎ½ÜÏ�ÁB9ýôÑYþ›Ÿ5êh1‰à“‚~$=õ+[Ùè:8õ=Z¢G݆3¤ù½ÃMÛë"G ‚ ­{º¸ôåqœ—jåª)¡žBÚö0w3²ºÓýç-cy_<0"6Àþݑþœª¶7z^¼šUúôƒ»!ÀÀ5G;¡ž¨•-y’2çz¾Žv|<X3@Ax�6Ú ¼ì�Z‘z;G¸ZGè6}»ò’´½ÁÏHÇ'îÇÎ[’‰—¾—xó#¤ÂÞ³<¦›>w"fårŽ`®¿v¼>%ZNV£°ôñ&Tà#;/?UFo8ík+-ð~èÝN5!%5/`)ÑÕJŸÛµŸÔÐUF‹Ð~ä9E=w¤3-ŠS» `õœ Yõew€Ý8Ë OâŽù‘Jˆ²ÓÒ܇ñpžÒíh»Ž©NˆíÜ X‰™exOé-Ô�{›Ãˉ²XAò)6¡´ ö›ÁB^]ÿ]ã6† ¢v×”:Ì:,’oà[A©rŸ]"Óñ¤êw”Э¹¨IVáhA)A4Õ†_„4ãý=´ÇÓ†¶|½ jYú¦ñ ^m–¢sÃÓöÔO; ¤ïý†6½h•žn"'×ó„ªÈBHr½tZí¿Äž¥+nžü¿¢`§n…ñé¤L¸"9!@çæ7=³Ñ´†fÕ£¾û‹|Ø>t£ý”!? 5ü®é¸SorgŠӱwÈØîÐÖ'î2 {eÒ|#\6TøÙøµvW¢ §aÙ½ý5:ÌÝlXÐà”·-`<@ÄüH‡Åž½eÞ{ý!°+ä!zžÚmAÄ•ÀGNÔÝ!n]ý¬%âª0µxfÌ/PU­á—ظY. %,óáh´Ìg79×OŒnœùÐô¦ó�¿»ºwØY>Å-;6nºo„ZÍ-¯¾•fßÉÇJ!,HL‹0ªáäN»ÍXO“„ Ždr3ÌDzÆ2¿j¤—N]I"ËS¿û턽G½$ÊSd–ÉÏG(`EÙÙërRÖÊ30s®ýþVDIé~î’ï?R*OZÅLÂfkË××ÇDz Ö¸"æô‘Uôöê¶ë1 R̦3Ð/­Ó2Ë ´|9¤‰iF†ÛÏ©°YƒFÒç܉…’,8¾ô±œ(r[ôîð…üs£›¶¡Š1í7¾Õ§Å0Ë-û<éèp¨·/í»;˜! GÊ—æÁ}Ñ:œÔå‹Ö¯Ñè ê”'ÜW«iè#·ôFÌ꧈økFâÑ›hÒÀ€is„\ × Ý$GìÃë<¨@8¼‡…„a’„>u3ÐCBÂ8;ò€ûÔ q|„édïx¨šÜVJ¬HKdt/º„÷Š™ôÁA¬¾ho8Vq¤ ·lƒ¬VoØkh²¬Lüú>‚®U ?¿Öe[¾øˆVœqàF1²Å/²v´?œ9 ¾¯ì@»§³ÞÕ€Ân1ikÌ®në;Ýõõµ´84ƒüpNÊõÆì¡5ŽR°ü¸Ì"<ô>":“á2‘šÿ8ž†á²ïZ/0: ¹ÒО;ºO“Z‚¬Xmlj€ÉÛC”“îœ0·nÑûž:!dž ›•TTƒ lMüÝï-b±E_ˆ(h©Ä0ÌÝ°€|»õûæ¦@¿|КˆO /–lþ YãTê÷k(æ®k?GYå·ÙAOè·%ÛÉmX˳­w½XÿèŹ“qù5ë5ò5Ã$èÛ$(mƒM2›la:qÞ×lRo¶ g¬"³è3G g¨²‹•Lš6BuWzs#ìõÂ0 ŒÍ…I­+J+误gç[+'“Â*ЫFÑóؾ&ŽKßÒÞ·ƒF¸åСŽ?¶ë½ß¶q¸³Û"+; ÐW™¨ž/Zí³Áýƒ¯å½åsCCž©Æ¢ù ÃmI)¯Û?õ‰´¡ Á‡¾¤¼5DZöº[ †½Òá´ý0e›4 ò^Ëb‰N[â7jO®‹—·gˆÖÞ½4£ÊI² µÍê8lÐè`k«ýHKþ(Öñ&£rÁž¸¢R¤ ˆMF§,äû*ëN›ÍÄ#¹·Òýàîr}áùÞŽSÄŸßþäºF™ß™ŒQÄF€tžN]²ÿÄÀ'³Öû¼I‘IÈ@D¢¼X—…ké‰n £³È|«ZZðZâò´ë?¤ü Æ(MÜCfT_?¡Ÿ5¶ž.F…žxÈÞ 6ò)KCdœ}’Pž¿V.(“1Œå’xŒÍÅé} ‡³(,8ÞL]åš¼¤-l56r´øêúÓÈü‘–97Rôõ¾Õwš›9Ø==Éäô‡?v̇©3š¦Ï=›£ÞÛ;”´ß—²99•Ù”›òËV—~&^T­iòŸÑ'Äû¿fƒPÅ‹9zÆMH‘óÛt 5–JÛ“‘kýU¯&±‚o‘ÑøkÆ’‚œÿéûË€³„ß{:׬Mý³“ŸøÍ1`•7ô%ê”\4)SxÝ©£@™ |H -{q@_x¼Ï5ßxŒÛŽÍ©ë§0Y-?–LÃP5xúþé¡ÚXŒKä¿*Á­Ú©èPÅÁ> ²^Ok°>¸±«¤#³à.¼$u1—ïøj¤ß0逽d»–ntö³Fqè®òPâ;ÆlNè:íd¬ уC™�Œ?߶»N³Ü ¡wáꢚyÑÜÉx-L'$Q@ùu‹ñø}Bò.òªüà x¹ñ4Ñë¯Ã –‹’^è´Ç°ÞÂ>Zqi±»'TªŠÍ·9ˆóëIF,V‘ìe•²Â !!Ó6 ©­OVB@Òÿ‹HwõÅç—Õôã…}3é0ÆÓßõµ[͇‘Þ߈'¥AÇ {ž-ú©”XÚ×Û½Tg3Îa¨@÷IPM¾çº¯\1˜Óó¹µAæ J¬Ði™•BèëÓH»ŸQ×Te—èr^K­™‘õòåÇ/ÊUè06òÊê¹5‚»3<b¤ª6ìEc›Ì›1ñ¼ÙBUÃÙJ�xH žîØ)4Ê,ú_c87¸êר@z_Ñ"òК9–m?вíß=y—ºõ�V¯6+ã*óšÊtWÆ=°!ÖBmªÀèhIОJóL‡y×óym_oQ:bÿÓïXÕ›µšÀ,g_ïìjìèÙApÒ]ÜP„Eú’->9E ª—ºÎóά›FGñ‰ ^˜@„Pí@‘§þÄ£ƒ¶ ôWñYU,ª©õ¬^E/K2:K«Ø°úš˜ñÏÁ² åÎ5SƒPlÁîÑ׺=Wù§¥¢´‰€“b¬j1>ð[?ô£y%C7ß&j.¬þÔ“—ˆþ)½ñÚµŒý(ÚÖŸ¾mådSýkØ•DҦ̃y hjgQ%árX«Áyì¨VÑ&4.pæð¯JpphtJ!xBˆÕÃxQn‚OŸ¶01ûŽCèC„Ìûth!=#ÌoTñW Å£D±O¹±UFÊC·ŸžÔ¬‰&¿â†½ý•Í}T…¾Ð Cä '®º ÆU¥ÆN:¶Aj>=ýÞ<å´t-4Ë^­–&1 Îk:8B4ÁiúýþܶÈ z”?s‚cxKni¬,`ÞL_�äGaâÅBui¤"+±Ã¡FýpÌŒ<Âg3#¯u­³NzÀâc(:»¦é»;®·ÂéÚ…><å¿¡ÎMÈÕ ñÿûÿèØÓ˜Þ›—eY)H±,„ÐOWÅvòŒ¦ »ËÄ›v œ¤j¯~¨dÇ¡/Q¡™CL‘‚+pŒÊ„T·ÙÃvź‡f)ŠŸ)‘lôà̳ڴÏý£íµÀך ±êvGà­3ê['àbTÁ–9Å-¨Èú¯æF¼ŒƒwY[¹¯Bùo†½¥=í{¡;ú'O³…ÈFl˜[ ½õÿF‡¾ZÇÅêKoõö l·Ÿ¼•ˆ–Yæc?BÖ²`…z6§<�8´æ/‡Î ¢ÒÖ¹!üPiîÞ7f3¶}Äu§ì<kNºÂª¦"’k<;Zè}ÙèŸ8W4ÕM:|ƒ°ÖžMÌÚò¾”6Ð仞F¬·Shø™óHë$éÖžµÉ±Wo}G;¤.ˆŽÝð‡ž&¨�d(}¾È–÷¥î™ÖGÞLÚé‹ ÀB’Šo7½f÷v’Ÿø¨Ï{ùj±%¡ß¦Ã¦€Ðê•jVdB ÛÙ¢³©íú¿[690'ÚCîšTzÚ)Ìh;**¶芊éM8• 8göõ Ë®€¥”|¹ªŠÂÈ jÄÜÍJrÚ>ï^äVÍ1GiÒqJòM‘öd‘y·q¬jÌ2LìyÓêôJä7² ÎTFÄT§ôtŒå[=ý8ÌhyŒÛË�ãnàD  ÌÏÚîÔŽ5Ûùœ)ÂÒÐWO:2(þ)Ò%�c ˜éÍ›“¼z(nM¡"ãìsD[­Þy{Ö–½‘è$¨†ù;œÖ=ÀV¤­i™j"Ï Æ-¤L[7ƒsùeðŽŸƒAÅÞíGÖv%1øÜrïVq»/¥ëÀ¯ÙFÕÄtÙõëm`m¦‹hq´4ck®’‰È7‡õC¯Gsc Ð9Ò;vœ@“«+WxSkfÍJËïO'ã3øNeT,NTfqP­%e¡ÔFP)Ѳ¢ml¢žxt1íSÕ;@Š{]°,öZé nbHåurøÖ+¤˜9-ºÐ ã>÷KJÖyæyŠˆ6$’Zi»æleÞžU1ë½Ã+Ò<�TYÓêa§Æ�Ît†Fb{SÌŸš�õ9 t&ñFÆO½oâJ·³ä!ô§LUvšpCÎƱÖ0ê™~Kœû­B £Â零¾lyÍÓ²9)ú^böe…ãg³œæÇ\Uk‘¢xº"ON÷×ÎHð×cþ|#¡.½‚sž` –%ˆ­&‘LÜÐ>w]«rÌ/h¡FÊ­A…úybHx£š1 7‡±ýÁÍ¥µø ä.r¾y•1›…ÉOyÖ£œ½% Üw<#‰Q„‘ìÏüzò®’£jtŠE=Ùýj›:rD’»S²vÁ¡ýaÆŒ+Ù1õø£ƒÇÍÃïÀær"f"-Û^ò <2+˺9(~äg1 Y~s³ñ¼z##­? a)ëK—2µÃa¥}ͬ»ÊY¶Ò5[ŽGS{´ä’Æ‹ð„ì'íÜ{õlÒ)§7\ÕT̽›éCv|b´‚"Ç~7õwáºSžÕ¯¤sMïÛù@²BƒU D ñw³6xdn„£ ô©À�ô†ò'#Â1SQÆÖÓ¡ß±K‡½øñ´¼d>’qUé6Þ©®A ÓrµdÏì¿ iç…? §¤èTÊÖµ£;>äC-°Ç€²›ÞxÌ©Ï1ÿm.Œ¬»ÑSñdæÆl·Œ–¯öÄDÏU[ÄA>©‹bÜ´\¶ÉNltÛ»o0#žLŒ¡Fc%Ü}w\/^RŸ¥þLÜÝå"šæ³,"‹÷)Åèײ4qºÀõÂœq½ÖŽíºÀµoäs赆xùý €Îuo©bQ ñèEŒ\¸§¤âŒó®é@V±0KëØœ/ôaï¡Éäa¤Êr²ŸRðB¢Ó¯Ÿsb™Fiëܼ¼î—¤¡Spãúõ<8&A‡¿.¸ªùðcëOóõ†¿ÏC‹™„Ó?:ZO/ºçFÄMG$f¬~÷ÔO¢E°¦]7� ¢ôŸž§ÌÕ˜j೚->þö±Óq/«â‘VAþÙzÚßàãÌ\ :è¬?Ç›Õ µÛ÷͈$C ÌfÇðÕÁ¤öâ'¸¼êþuÖá:܇šËè½õ_ÓQ£0÷±Ú`sOJv“¦ ¯™DPœ5n_w*}-(3º“«=ˆ4Ÿžç*çŽ]ÿuØŒàEú(h0uĪÇÒ5J¿G‹ð‚•˜t'SRŠ\’7>ªè9KcV÷þO z.¬(ÑK£/ioû»a® 4îðÔ½zû}@Ì<•#–¡½@9±2ô¸'"Å‘nw3H'òòØ74ý–2þ¢ŒN"]ìZ7;üêoø-«!ŽãÌÕ3÷ ‹§ÑÄäFÛú¬¦ÅÌLÅ2-õ®ÝŸ°Òïèà‘«Ê¸BÞÖô¦Ÿº¯ÄÆóƒrSíä«'í=kÚBíxc°;B]ÕŽ5¸*¢qó¦ëÈtÜcã·cSÇ‹1oŸêoü ŒX–Nÿ¨¸ÓûCR'ŸeŠ§-­®æì ýz­à¡ÕaêíÿÇÚŸl7®$Û¢hùêÝN樋&@€…‚�Åïÿ¿ãÙ4ssw°ÖZgÜsƒÖNŠÜÍ­˜ÅÄžF lñ‰´†@»ÜtïrI(ci@Ìh%YBYh›Ãs=ïlC…¢‘p)ð‹Ás¡Ú@Îl•x.ªpL€@=eNukà>C¿,ÖKüÏ‚Öú>¦aV\‹ ‡UæCgŠ`·¡úªÛºìúK¬œä³¿íö'±Ã%qÿæpÅY›­Ei€Oˆg¿¶…+2_ãRÒ°ñÊ­ðµ¥0ÚÉ6X8ºòÑ⇧ü¤$Í}† •…»M„­]µD%Á$Ê7&U~û>%©ç Qá`„tfg7,®{0í8Ð@ßs¶Ö|¡ÂOg:Ó£ú$GQí¯Ð×àE­S¨ïŠïè¨óx6w ?øj.'u$Ž”÷U¥|WéÛ7(,«aòpc¬õÇG—t£q0Ö#µþõ° ¯˜O«™Î¼Y{ º¶ Û •æ_ŠËG,]³JŠÐ™ýpâ×ý$tn·?¾FrýG©‡tR‹ ª½3dI·«Ü±§KùæôF‘•¸‚5}SC†Íৠs[¢‹µhÄUoju05@7Í:Ý)zïT¿ÖÏ65‘j®)8v®Ó¹Ç ÂÀÍW¢*€¨?}u¯ a­°»1ˆ*)ÁKAñ®Í1WZC=‡áþØÍLhðÎÿ×´ø8L}m àÑ�k,ÿ£ ²¨ûÖ³ƒ :;ý œ{syfw¶[úFN^ƒe'¢T@[ª¾§%ÜešT_qùâ¼XÄd‡N >ÊÁºÐñ‚é÷l§'*ŽêhöÊ[8‚Œ–tçÏ<Ñ'/êÑQíÇ]÷§>õ?6Ýœv“&I� Ö"I¸ê1 @ýt÷—´N#÷‡˜y^§A¼¶�´âº=ÚÉ«)ñ‚>4÷é6}ÖŸwuƒËɼÃ[tÒf`¡¶Vn,å={ì¬Ð¾ü@› #+Ê(½0©òbt—¢d ­´ËŽ‡VŸ×[ñ¦ÜzdŒºËüö'º 3]ý„üÕÓ™e¬~’RßùõöqÄ_+F£!áÝ\ð­ßúÿ7î7UÇæ‚¡,΢J~áù>~ÞK3î¿an O$GS1«Þû?f7ß–f¾ì'%ç?ÜÂìú½@SàÆ×Ä1ÏÖ§C»;.H åÂÝ.ÂÑYá¬z¥˜Î×^JtM“z"nV.R ´ GÊ[­Æ€QØvƒúÓéÃy¨¾Þw‚3Â϶í:ÍiÎÓX  Û -–æ¿úÑ™Æìšo½º¤¬ÚÊ £ ýš:ÇN§$÷0éoßí¶Å™îc‡€Ó¤Ñ?5ËŽ¿÷ µ'ZÐÕUÉ´ûÌ—Lïl b”îèýkUÏ‹òÒçÌ —€¿{Oy×¾Z( QÍÖAç=ÿô+Dl'$OÏ]Š}+ õD#JëBqÏ #±0~tƒêñƒÓE–wLÌ¢Ì÷´bE þÍ·g¦z¬1nÀ”„ý7Ñ]ý§Š‰Ž'«ÆÏ¢¾z©=o›é¸[9'Žk¬×;à/•€6íiJ·ö‹f´¼§�„Éy·²¢QtÇz}Y¶-3–•Ç `»î¯Zm†¬¼VƒEi¡`±÷×òýÊÝ•2ø4 _ÅŸ‘ÙÌ{–:¢ì¤æV<¦¼—“,BÍáÑÅ°9Q^û‚úÓi€ÕÄ™»¢}‡A�ÝQy“ú*ó H ˆA3ú>9ÿ@ê1›ô¼¬8šÙæ3ir”Ò-�ŸÇ¿ŠÿzÓ0[¡;÷DT♊Uââÿ+v“ØðäN+3Ê�h¡¸ñ¥Î«xèÝöÇ•o\;MÅdáüU‰6_:ØÌ&A½ÍÓçeQöD’/KœJ«žœ¡^u:Ê-EOÅtýåLk­ÍÎÿ½pÜq”ìSyz¤;¬9³ÌìÀ*ÿqþÁ…žô*÷;:ø¶R¡ÿ}þáŽjQZ.ôsÙó‘U‰à=oZ)æIü£]Å•Å™éL�²é[×z+‡óÑ ì~g©”&~Ë€Lz̳%}±7÷ÏÂÒö8¦í$쪡“·üñ}ÿжmA/9Ñ;_>„„;«C—õF“vâ+s´Ì«SRˆÂ¬š‚N’¿ŽsO'!3VäqàÂßéúË›îki•ùbxcK§Ï·j´$ûˆ’gžNaáÿú ô¶ãFk¢œþHíT?&s`µ¾n»ß&ÌYæ+†R¾<£ñk† )øéò¿ðÏ|ÉßSSZQg“Mèf8×í äŒÜ¿Š]á8ÅpAS}åLÒ•˜»Ê,'Y±™0]³;~!)ì.¡ÚpL°ÓìwÚ€ÀZ€ˆ·+טZÕ”_”ëkÄvÙ0ÕM&Šdáù”«?ymŽ6°–2D|]uŒâÞõj”T^hÊ°Š ^KÖ[ïØÒÌž›¥S·<sŒë6Á{Ô/Ûh‰Œíy_Ó—ìÿº2g%¾œ�`ùC´lÐæ›Uc xWôš4-âÌAc¡´ˆ¸rlq°æ©™ ‡uÿGò»w”îl­‹ÈCŸÕ±6n”ò)ª` ÄÍ;öص>yÃK™†46@±*Ù�§ØÎ&¢'³Sû?ˆça<¢F2Ompâr1”†¬Ê>õa§˜QAÜ.Ûý…ýãý‡&ï( ðªÀáQAÄšTTw '·ýÞ<þÙdÞ?¼Åa€©©r¦0ù(’'£ß†¾Äž©™ÙuŸ0ü'rN>T÷yò@fÇÓ¦é1ýÚšöüiSÍ8°Nj<hX!´> †KkuÏEò)ÆyLd–è-ÓñÛ³i9Ô_Rçi‘´9L²þ©k–™ƒ À´þI¿g¯ÿŠ¶Dºw£”ÜäºÝFü;èoðMoPó¯ßÑÆ냈œ+ÁC&L¹¡ [œ/Ã`гÂI¤ÿ³þP|Ýß­ió¥~\A÷›–ópòìîé ŒV={DþêbU M·hBô-§µgàTÓ[{ˆ7Ú1Þ�@ä}§‘ªd‹É}ðÕMGzzñxà*•*dwqÝ€JO‰œsËÃå{Åhù~ +-œú]wúØwgZø;hžë‹lcŸº°¤18ª sÑÀc`¿ZËWbCÒNˆœFXºierG÷þ%›õY ¢˜>O”º¤ëƒ4]·¥Íe´þêó+6lÂr«íÒ &JBObxU“²ÑŠëÚ3¦uÎ¥í…ÒñZ M¯ù¬yv…8h¥O6 Šcµ•9”M#ù&[¡d\<²Ø}ù1X÷˜¤ýx¢+›º—Ef•Q” m_O�£T§ø±Q2Úô´úZ œY*“:UÐÞÖ4Ë=›L|Ï h;¾Ðܸ£÷<>úÒiì6äã&:n�*ùê‡$ù.­õ==á°ë¼Æ¹;Ÿ.c=З—²P¸#öðfˆÒiŽÄe]É-éc3x0‰„‰öÑd?û‡ßáh_9ñšûú|ò{M¼`1ý­ýp¶‡soÖ»ðÌ[ÎÇ@áŸHÙEYì‹S ;ö ~ÖÞ¹“Óýô!­�T‡Eņo`~^é'Ìß‰Î2ôXÓ±Á9½¸1Ž2_úY_IÛi ËfZ¯zåî*¸äÉ#µF QeDx}¤–ˉÊÛBüe¹û‹lFÛ*|ø _q:2ýDõdmÍ 1ã¤\)Œþ…7ºŸ¾·4gRC—C áÇZ3ïƒ ]ŒH垸+´¾Aü­ºà·‘i¸ÌL²¡Øžüüx,‹éx=%¬™Õž@zÐ þàô¦æƒ_ýè·XrS¡cÊæ:›¢Uèý†÷IÆQ¸æ$búåÚBz º«–¹àcƒ¯ûn_VœJ±Ê›S”óQUHb¥þ½ÌÁ¡Ê]Ýv.ãÜI*Ë0fB>µ½ £B&T¡N³¥êù³û‹^Ó]Kc7RÈ°¡r¡l×–àÉàêM»Ð)Dkxpâ‹¥ £¢}1hبЃë>IPâôÆšQ mVâíH:Ê|M:.Ž]œÅÆC;r=ÜYØy€¦ úÙ†KŠÚ¤å)¦d¾Ó|Ç‘3Õ¦Œ±+MÅh>é¡-Jx#òŠOG ‚ áH­öžû¼•H ™#MEÄ ððlÔÕöÐn D!ßÃB#Ø Ó ]‰/سƒ ô)< „ ÇB€K‚öBÉäål¹Ýµ‘OrÊДÒ ÖÓ¨‰ü}~wGþ‡ÜNévòJE6eg¶dã ž 2vPá3ûéX»‹¡ü•DìÕk»ly>yÀ>žf_‹åÒ*­ÿf™Ó°§°ÖÉ$}¾ÉªÖ¾ðJâ#"ýì%Ά~0— Æ }‡Ñ~ÿ´Ù$™×Ñ Ðgûè¨8FŒÂ65e°î€üUÓ=÷ä_D‹ks¢@÷¹ñ$b¡&nÙáNÉôŽ¦©{¬ ÏYÍK)þŸÖÎ|‡zM‘Œ¾+z«ç¡;ae°&�‘ǦÏ~·ãî `¢ßƒÆãÄàq¢Ê ‡b¹õ§7\X´R¡þåtõnÞòÎßȽY)›”÷ ZìqÅ4Mtˆ4Y¸“¹ ˜AyâqbI1SÚQ³UöÓ nEDx÷þ•`²ÓôÎY¿% ÎëÒƒS›¤Pö=~€YïÖtÿ—O�4¶Ÿ+ôSܹ. ²îäå¨[àTåt^”ú,©E9 ñˆçN»½òA9‚.;p^p²`èá¯lx´â•)y¢Ç4‹8Ff›ÛeÒ {<¿{NëW1m«‚§ð±õùŒ,XÎ6S«?ÂÇ.{y˜±B'$r %a)€ÜóÕÉ�w‚·2waNâÕOÎÎP–tº¿±>Ã9·$[ìv’¡½èŽlqaD‚m+  ¯r- ­vçc€q»R^î®,\€“ÀÎ0Ä&Óq •¸ªc„‡Î j[*ÑC [?¶¥RÀ<Ê š(ejµtx´•8’mÄ&Èçrãö¬5[Q.U«ò¬¼½L;À•¾T´I˜BOøBQZ.È6CAôSû8ÏíÏé=á‹Áå¼€÷ Ìë´Ïr<@ã`AüÈŒUýûégž]QU¦ ÐÅOO&Ë–XG-d÷7½'«3+šÍ U9Žâzv½=�Ìëžj5'âí†8ì®P6 \5Xºt™ùI UØ>0,5Æ¢ƒøñC¡"÷†?žqâÙÞM–š…™×–†#ù–JÀ£blÒ\lB=ͽw|K–&é’/EixÎñúÛ3¬PW-“~EiŽ–u ¿»"ÈZ–Fsm?vGtcw¦%¿|¿²pœºYFÛÁûâÇ;Dçú<Ȥ»ß í$Íür²0šM‚qO«ù¢‹#¯P&éº:3ÜZmé5Tò Ö¡Ìié îŽì|€Œ@ Ž 7eÛµWfÂF!z¿×5“]í«ßr³,AÜ�·Ž7Ìš6\0ÁôÃJŸÑInìÁº:ÀQÉ⌮Qëõ ™—Ówy”›Þcn¯!!‚*Rdè6ËxñP÷œ™ÅÁ‡Ö•†Ä¤DQY®=ANg)=äâxòÚ4†Ì¦ø^ÑÝ—.׼ߗŒS<wpJy“££¤"Cßõ{Çùw`ÈXK‰¸ 9C…wÜxžÞ®ö0”æGJ¼¥Îßs1 ¨ö.[•jŽ™”Ó{‚B°Mã”zº›*ŠòÏaÓx¤7z7~|tœSäb`xG+éæGÊ'Îó¯×6€8ÏEáìRxµ)ÆŒ}Ó³Õ“áÊý9û‰¢ˆU”A.(­åê¨7{×,\5Í0õ–EòËþrVú‰rŒ¿‘SºÖS™•‘˜H(·®ìï½»ð¢å92(ù8Òçþn<\G”½6 nûæu1ŠŽŠj¡£¢{шµšiv«/”¦QónŸ$.³¥Oü¹.¨¦³I}Äê}SmŠeêi¸ã ¸ �zqBï çREFŒÆvô§˜¶ûä&ÑÀïCMʘÝõ'þÚÞ¿(»l˘èvÀBjmA»ñ°¯MZbª¹¦ùÔ4“Kt‰yØ Þ†íØÁ’(Ê¢¶åS§s!nøRÁ<Ò'Þº¶ã^³ÿú9Ø&ö¥ƒc3£Ù®=´Hx Û"~ÃÇ’`~¯.¾\TEyYF­áiDöךv)mâÃGƒ> ÔYí¬’zÃêL€}”0·ÙÆ-’r·ê+Pà‘Æ[UëúÌ<ózÅÒòü†ÖAí¢Y7S‹¹¥™ œZÕÆPí´{vK‘0œõ‰øÇF–¨ÊwfHØÝ*‚⤠¬ï€nswOÖW¥ˆÀ‰n}I|Ï*%óéÁ06­é‘ÛÆW„ñÞÊû·µà!î\øÚí® uXU¦ÇóçxÃ5…coR;Î+¸•áB/©B+JÄŽ­²×à)â®,ûÎ]IL·þš¶-UúQÚagÊ÷af»fÅAl®¨I*·øÌË5JÊlÉ”9B½rkÍG!KE„ýô÷gÀ&Ãå’t’Aƒ6¦¥®YFY²jžu@Ïq·ŸTìæW*´±£BVÆîܦìó•¥ÒúïŽ6W fJlˆ¹ÝZ;J=Œá?éGˆ+‡ÌA)Ž™ØœlÕm78Þ†Ç!&ª¢8ç¶È{ôær¡©ÅAL½-)á>ÑwÁ©dNÖÜè¡ZàÒƒK”áâKP¥vJÒ m:£ ƒï±Ã Ô<ýÅÄT9¹ø)¸±};QÄ*W œm«ÚºÃÆ–à<[§(iµ0T@)7‹èW„WÞ‚õ‘õæãLŸþÃiv´õž‚@U8üDΓ¤ŽU8è_(k4¤DnTYCøŸ²0æ]/^\òu}<dE±¡³姧»D™°ìxcÚ´U …g=îÌV›jQ”±5c|P¤£¼ZÏ~ÁlÍSg!Ä©x3Q0¨_%�C•s� É×Å<•Ãü>×¹È2)0K;¢¸³ÂTÜØvÝqu ÕvzF°2Ùh*T6 =_ØÚ÷ÞÞ:ŸX‹œÕ™þL;[lÿF8ŠÓ/Q á) qq%”0‹~Ñ\L“XY bgº§Õ–€©ˆvb�h4Ã@UïÁOµÑæá¹ÛdÁ¹;b-Ö8È'Oèáû^ˆ¯‚L‰óÆ1B0Á4Íá,¿âò쎴Çã¶õíí: 39ï@*ª±iÝõ»h’ÙÌìFZ#ö>jÁ‰ì˜SWHl,ŒéË’ úf VF~[žÅJ!$ÓûœM Ló Z\Ümºõ°³=K>&ÝüBù�’¹ˆ2Ĥ’Î:v¥²VJ­¶ôµ÷"^” 0TÌ�‰Û¦9 ýeØ yA‚vgSí_!è“pa ’È»óÁ‚1q|‹³Ò}\ä–¥¿ï:ÙºRä)2tÀ⠙מìì0Á6oOë’““Ým†Å:gŽ2CX«{ø u­‡µÀŒäX·-´ya¦œþ|>ìÏׇ~’y‹’ÏËË!§ti̧–ôP&§{,rê³WÆ`ÞQÄIRÛÙdK(åA:LN¥Id‘1nW€ö¸kmå]ÿ3èUá`™lð9tô÷«—%L¹ßääîþ)Î׺å©`Á¶¥E¼ÑÁRÄ–ü|8ØaRì<z·§¦<š¯qtod ¡Z Ì´ã& <%cËHg8ïaYœY|·î^s6h¤(}cA8®é„À„'ýùt5ü±£“óðÕYSö±>rûâ«C§†›Žµ�B^Îeß18G8ïzÈ[{V,*Ìf_Ò»ò•”0©æÉ Ý[‘Æü U‹—;«³ôÏŽ;¶O@Õ±ZiÈ–¢ù÷ c´{X„ªô â R=Ñ;füŠ”dìÓ*l‰ÑðÿÐoГ”T7=ÈjÍ×7†³Š9¬rŽ&êÐ7˜}eD•^+©GQ좔Ïa™À¦c‘…N²µ”ÙÈôþôžö´âÊŸ|P©6ÍY67²êw½U:²ÛðÞ•rìokÂB§ ¯*t+¡¤»U×-4W7‡¶­í„ƒc¸šŸ1{Þ¬È=µ5¶PŸò$(fE~ã½Ï`¸;“=þ‘#IÛÁ{Çè<ƒêDqœ.ü%aˀɵ|‰}w€cô¢'³çénxϨ!vmá—5[T7moŒhÐO[J¾ëcTºtAÖ%#£ÏÙÅŒ–ÂäÓÕRò—ØÀ4Ž¢4r”*‰éÓ}~š ê;:ON}ýa]Ó?L’’G` Õ]{ßÇ÷-ÚÔ³úåó3D‘’Z Ç%g†6AÀXÅ„ÿÇSúÇ“8UK®ø´¡±Ðò,yöóz„w;?ëÕ×Ä€kl<ÚÜ»^èÞ¥IÍ®Õo¬ì¦Œª`ð0ã¡7ŠD g[)OS‡wu¿ÔâHâ̳¦=€s6kµ_Ó[Áev.?ÿèœuî$©éÀpÐÿ:Qc:îà³öÇ/c…ËÔ«{‚ëO9k;ÿ·<øïG©ä;ôp·Ë¸ì½æp'y‘y¨hZ—ÝÜŒûÆt÷'4[謓‡@PѬõ¸:õýÁôR‘«Š".¼BŠý#ìƼQÁà™np§v×ÑC6Ò6óxwÉúQ¡n•qF:ÊuÊúäÉx¤;çØÑ÷ ƒ¿j$•GwD;tð”ECÍ©q#hfZ“+»ô|Y÷VõÍþÀºžúCêcôÞhN…©P®‡þz!í¬¢6ËzX-uô„Ž´tð[¦ÈiÚ¢K¬¯o'HYžùžTX31mV=( æ#ß#zeðx3ë$LK`Æ óõ83#ÉÒ ªè̪Áí²©~«ß2³$ó}«)Œn”£gMã±1Ô¤^Fi AF@ìß5È1ä|§¬ˆép_åçÑë± V-ÇX ˆÍ"Rl@Ä-äÈò¼Ã’§¥ãÜän`Ç]4:Œ÷ƒÅ­½IL’åÞСջ]$À…‹…f:}Á }µAç ðçß]¹©/|79^M�Îr/Ý%oLC2 ßŽ7ÌÖÀ¤ª‘ö}³Ÿ¿n@`±F¨݈|Ü]Ýqû+âÜvÁXÒbžÒ n-"c‡Õ™mÇ<�ýoÊðÚál4)훺ñt_ºãtØk)ú[ÙGZÍÍàj$ƒLÑfŠÜ7Üø‚4ô°á›ñƒ”K`Œ#ؘ žžGíwZ¸û9<¯ØºÙãíæœK8¨Ì3ÌÙ¤½®^u“TÉŒ¤¢åÿŒ){"uâ&¨W1Í®Q7mëapáä ÔËù|W°9Eà®Ï^¥uD²Á)�å`ƒ•¤»çy›i£27^Âl8}ª˜½ÔzhoRÇû‡œ¿öœö±³)úëeˆ5â<1eÿ«iw&}�XìÓB7d¦Úäb+oùËŸ( d‘³¶È9ºR½–ÛñûÜõˆdˆ¿3€Š’ˆ³É´©éÔ@§s«fù“—Ç¡Árg0ÞZ9MØŠ}Š¸ Lø‹†`’/` 0æ„iW㕶{î�; Â*…[ç€ÝÑÈd?¯R¿¥†bª¦ŒõäO¬<¬+6pwž D b€¹#lHp΃ꢳƒu}ê¿ÀÑ5¼ ƒyÖ®q ø­6„ãV¦ã0´ ºÆ‰Cà8™åÐòÌ€>@å}–çY«ˆÐ¤aóD{*ëŽv ž¾a×mYÖvü•îcjùŒ"üX²=p1¨`A.Vì†Ø¤©…°m¼qÇôd›ë‰û›lÆÌœÿ€|?m=ïQº¥*³‹ÄµHæ‰-Oâ+1ò9Ûαgªr¨¿ÌÓE?Ÿs?ee-êWü®×Ý6Ë”n0Š¼-ê1btýÇŠ7ÔÎn§¦Ff|š- ÅNˆÛ.ÖUIJ·TÀÒº ¾éåØùæô ®7ôw:ñ6˜œ¡£þaM׺Hp÷—Hk™§L@!Ÿ’Õp«¾Ï�ª5'Ó•´ºðõ]™Åùjî¡wbl­c_’–Õq( xÚÙÐá%žzšÒÝA ;iÎÐSi m—éÊ?uì°©C™NëjFüp4wk{Ò¼ëîžå€sdƒfö¨â~%ûÃÔøýß›[ ¶"Ém=í‘<sjîÙÒ•ô/¦Ì×*ÂÉ@èF³‹ØÎ)¶œäíÐc™y 7rO$¶òš±•»"ˆlôˆE5VLŽŒ«Å–;̶úƒën0ZC×rUy¼0‘, ÀE©×çÚzÉ3 v5ZWVuë-M,õ̉Ä_&¨OšÙœX¼f,kõÖ(/ÇÔ€»¸=+p™—ûéGæƒí ¦Ã_oì½`x²×Û�þȪtèÇ>9@?f¨Y<„™ÏÈæØv*ëú’ÕPV™Gìfý$¨†o›¤¬`ù‡û½•zxÏ/>ñ5f0Øìé}í|šE_ìƒ5Ûå ¯g¬ˆyy@ ¯g4î¢ÏÎë4ŒÝ¦Vº2ßè× “Ä(duŸlÛyônáã|çä÷ŸÊ�—(ÓõóšK«ª2H(“à® XÄÑ63¢+oRÉÒÂû¢Z}¢û>÷ž})ëÿ`à·QEŠZ÷T‘ª§’›Û ž[,{Õo÷7{þ‹íúG#%ñ¶õ‹¼¨ÆÙlOUÖ¨°_.\4Y<§åÈg~ÌO´ž¶lhDn?ÛC÷H |ŸŒ„Ó]ÉZ¥¨‹†7¢šk�7³ÐñpKy"}÷V»O7!Ë„XwœÎÅqOÁ1m‹(¹öèFkí2±+ Œ6ÝEÿO+øcÄhÊ  .;“`ácÿK[ÔÌWV¥µµÂ9^þl½sâÐï}”äK …J£‡Šf;ûÝb.°¿÷l°7X@„á<>½ºc]ŒûÇYÊgâ¾÷Ý­Çn¼ ö)~4}ýççàw„££$Y Åb.š>M†™ €²i>ÉðQ„YûÊZ.÷ô$Õ÷b×n¸ð‘¨ÐoÀ†2ÅŽ’jXÅýŽÃwôŸª\4ƒA'}òšB5#ŒN$¯âñ´i.æß›qGéw®"þŠ lOÞ3¿cߘÑ|ýá Œ—åOôáëa^²u¼<^*šv�q£$Å”µÉ[GåþÇèÐä TDª®‚ª×NÊtz¸¿Ú?ÕQ³ƒ›Å5 8+B£a&“p3™d{ÚtãADÿûA[ØûagKd7ëx=üˆÂb¡–kE»‡BpäøGTeJW¯¯ z<Váõ‘ Pì÷'xýô}žQv¸öŒ_)íÜé2p¸°èÚ;¨¨Ä¦>|° 2…Ù£"gâZØ£ŒÈ3+~s \bÏ [UåÔ1²$“Ýô´Š’ã¹ýô½×³9œ¸D•öÄß?6¥ó´±ôÐy“ø‘¤YJ÷@xe9ËþLtJ&[­fá%|˜g[à7õJÀÈÎÍòêG V×Hà yìiY®ÿ*óEP$my»þN(ö€¿« õZZýó¸RîÐêt´¼ë' ׸L+†[ ‚µéO‘vh íw†• ’ cw~eãr:¶ƒmÚÌÛÃtâ:yžÍó½5È{ÜèÊcÅ%©”ÙöHŸ­¸$Ìa(´ó”ã::5>èߣÀ·"Æ+'J²Œ/„Òv²ú¨Æ¢EÔ‹ì=çÐréÈú¦�‰bºÞ.Ú ç®ë)dJ\Ðøù/⨠ÙÂØDìƒ.‰e«s<Ò¾ªúî¼›î÷æÒ,ó$ûÀa¥8²ƒLˆ^5ïìfûú˜Ä‡úÝZìÕ¬6ÑtÒŒk·FѸl-`ÿWb-i¶0”ª‚q'"}¾9¤ÆÕ–µZL rD®7J›ü… ƒ!µª)N÷sÄNÿŒÃØ‹V0&ù3}Äê~¦|Æü‘2íR÷ˆ¬3Ç›C3y(ƒÜ†iøqÕs!¨' ººîe(ƒ_=ðVª*?› ±ÚCeEÏ° ÚžT LZ¯w½±æ¾©™eVù"HV·iN…L㉟rnjŽ•gþÊŠ5G`"T³ªµØ§´Å#ÏÌå9Û K[!ò¹1øF#ßG?/›¶•—«´´XüЌ݊áÿ¾VT’ù;Âp„2‚ð[“ë†nš€ÛŒ]`D‡«–éÇÝ(%­ÿï°J_Ü™sQ¼T‹˜ÎÄ^”ï(Ö#—}¨ ¨÷„°íážCÞy¤@Ÿ5ŸŽÖqb‹Êv ‹KËïPò'œx.…>¤ ²sÔ‹Ç>´¹åÞ Ãåû ŸlúæÐÒ׉‚÷šþqäè-ìPÒ�çÝkEž'ÀÖÐÿùÖÒÔ&LËy€üæ„4Ì\G¾yJ0ãëÎî…Ôð_1³Ì÷z¨QæKcDÚQêT»™K)™˜{OïI4×ÂÙWc ½á¬ýLtÀ»¢ÍtBÿ­ÿ }]7Û§:˜RË~×Ö¶‹úæý*=2ç„0½íh�S.`+Ü÷<*lí­Ët,ƒt«¡xUuëÔB±£<„ÒñiËœúÞ|üù¯^ÀçS—ÑÜt–Ói*9A}¬ú®§sMbçîüez5w¤4< g sN ØŽÈSÖÇï;Kdþ5ç?öœY¿{ )E:›½v3ÔU7¶WCg|Ç;æÝ©jäs +QåE9¡’fYQã¯\„ggo’†V»¯~ö½Ðè§& R»!_ÐÖ P{‘ð¡‡.b§b_ö„ Jø�.°õ~ïwûŽ“ƒÄ`ÿ/ÎHö‚÷TÉÿ;…u鉚± Í”çAôùíZoëÚR/eR‚â_àâï¢l£2\’ÀW?íÄ'¬f0|4 mLõz /賤W?žxаTHŽ´‰¢lYO‡|%�–TvšþkȘ‰ t‘ê8zŽä,¾ÿÑtÊ¡v ‘w©#2OðùÇp>ÊúÚ붶PIÞ0>²Í`ƒ…¤u’àÍZ„Uc¡ÇûzÃ}¨ç€|¦ƒÚ²’¹¦,"ŸÔÛ‘}Òp÷ÜpK ¿;î0AëY¯°Í=œ"c‰VkŠÆr“U¥®ïiq³ã7fã¹> LÙÛšnà»áŽ2š±æTçô -r-3¹Âl¦OÒNÓÂg ßëa2 ¨cOœ­u3æIq“¦üüÕT–%= EøØanÕß-*ŠHšP�>…ÏEª»Ë%J$ur2ˆ:×t뛋² 1¾Y`¿eý.fqèè ŽVž÷Þ%Ê[wç±S©¼Ý@¸ù[‘™h£NnbÖµg`ÆÁ´Ê/€³\Bhqð»U¦v ﱑKkØgWG]Pü„@¥<„ÿ~$©—at€ôcl±êx3+ó¤FYÕ;h¨âNª_nˆò]ÄÓ'ß{÷,v#t‘ÜëÒ0H~jOã˜öh F·áÂ]\þ÷±/’ÐÕ¥zL„o—åAhbLL‡zê´b§Šáéyy,~ ÖÒ~€ðqvζò3Ü“¾wuû¤«ÌçGÈñVZk锑ÇñæÏþ‡…Ôí豫ìEç 2'j#üOÊ|C§7•°ZçsºaÅà·QSôög¸–3Œ ¼¦ëˆÚÔͪªô`J#3»R ÏR8ã^vÑøÌŽNCnUõ½;Sèè/ÌF~\í¿8O{ƒU±Ð¯æ¦höù¸ñÈ_»^Øy6ï¥ÔÑðõÞœ:…žÖ£ÁVë„ÖÒQµòSÙ¢“üJ³úÑu˜©èC×£Eȶ ·Ï áÓ*ïž#S”§O¯BÜpË•wè?7¤*³…›.ÝÃta¢Z%%> <óÌT=ÞŸê-XÒ`}Õôȃ=íβûTO¡øj@(÷³[Q1½ÒŒb×ÛàBŒ!Ë`Dfð¡±èx‹»¡1`ìêI5)t›'×#R–²){]g‚¶Z}¹‘Ø3­:ÓŠÌy1Ìòr6ùtiÒ–?÷-lÃolvÌÇ`Ø`È5b”w§Ð­*´Âzü‹O x*Þ¦ÊAÎ1‰ˆôü^9šd©oWÊB¬twòqò˜V@»‹[ðz1]¦Gq6|Áfú ¬!OòoÂÑ,¤õ¿|îsžÜ/v9¸…TsN[§´LENo}Ê)W;3@¤q®~|è%ùÊXÀã¨Ø@T%ûΟê¦àÿ­ÿ_'vd 'ÔfýÆÀ¡aT;¢M%ý=©ÞÞ@ 9Z+tÒ½š'ZÂáºS‘»ðÎŒæ ›(Î3ÖOÇßöH¹S£fèžp ÷€†©žÜÊXѽ>¤w8iíX D e…½:ì×P?’ðànÿoDîéj<”ÈéoÌߺš75C )0lôÙ¤pIœ2ö}ã¡n¶{†ÿOžOϱ¦cç«Öá=Kïòþ“Vø_¤3- ï[Éb´Èžè…�ò§c’˜\á+¨4‡ßiçªâDq7{päýa˜´æäˆÞ‘%Š¢…O�­É¦È‚b®¼ëMf CÿF�?NCƒzîL›k´¨Ø»Ø™Ä?¼C#±Ì ý·6ä‰Ö«1‹ù†9žYPì4JÆ€3çÚŽ^³®w&ÒûÏü)ÌÐW«f¿Âv[å¬üLx26cæ¡ÙBdÕ*z‚”ѽp2®<" ›·¤‰õÖ̦Þ9ŠÝ†Òþ$'8_0YÍê+ìMä©)G†«qìhÑÒY®ý‰ÉÓøò}0Þ6ň•>h)Cã*nÛÞ—$Ùà“•ÇmázÒxÿú;J$^tîÑFµ\@¯dr«ÒtÝQ«Gßó_áHŒÝ½c(sO¦ìGOæõÐ[S±×¢ßÖºÚ 9!ÙI9ÔìÓYYDeAøU¼²P.õOg ÙZµ?åÒ£FŒúôh²…·7 U&‹µÝÚC|<©î¨XÏ#h'å¯nLæó͸nï~À4´UŒaY_†a¡Ž"óµc ³(”è~‡JlAh‰ÈCXÞ·Ý!‹b“ç©É*'KÞ¿w¦QQº3Ë‘NÒ*¨ìŒèÑ£ ôRÁV"gè]ÑGîÚý‰î¼°-€£Œ2y_ÞoÈ*°]©åø·‘ʯ±¬}·QÖ,1‰¤OyÜ8³ˆ¹¾ô‡q Åz±!°;XVp4·¼’Š?Xƒo?]Ê=ÄËÇ|9_¦Ã†¯í¥ MA1@…¸½€£L\Ã-2pèÀ_4A‰ê@l%õ¡ t‚ê?N»'C]VþðŽbUGû ð0hL¡OÑïVõ•è*ýµBÙ±-ù%ÓŽ Ûw­iUg«í™…Uƒºk¿ÞÏxW ]¿rTu"\Äà¾ÆÖ=â$>gmñ{€Ô|³ í­ AŽa7ñ¹/ ÷;µ—(©l+AʲþD¡i]ŠÒÐq´û«Ž%aÒVòIüU@Î}ÎuÎdý/>=Mð+¨mgá²î:ü`ü°Õ1ìa½6b:»µj´ µ^†&˜KÓ¯erÿÊ"ÓŸafÈ ˜²–v½‡¬ÃÂü¶Záš™ø~t’Ñ¡9È„1^N\±¬˜î¶>¿S-}UBèŠÂãÃú·p×q¬Ñpg…±Þ Iëqí#6>ÝÀÂàsð<V¦¹†‡“̨œd€Ü…¨d.fB7âbeœyb°åë³$(·ƒ•.½ ëõ…Y¿N°jÜ&—Ï}OQzÀÁ¶k[û ´‚g¬È§ßîH_)úþv˜Š?»/»¬žg™ÔÙ×}¾QÎè"Î`=Ú ^(ôø.[–غ“‚7ܼ=ü»%DXð¼¦èûì[´¥Ž3Í#NÜ»ºõˆ©Ò¤Èm*�¢Ú™nô…íp”ÿWs·§¿ƒID7Øø<ÒŠâ³Ö­¡ÂΊD{b5WA4Ÿ<¬qs›î5 ôõJm1Çó37…m[ÊDãy4ljâR,W–QJ°myàâßûÞÕ­ä—ÓÒÍ!²§ÚÉ5kŽ»u:ÐjÆàê;\2?XªN$h79ý­áÓ“˜è¬‹”€&•¼»wyÃÈ—:¡`П#zäõÙëèàò ¥ˆqǽ¬4ªœ*˜zAßQn3hŽ„TE)!Gg&ݹÊŒ‚˜Ñ9Ý"¶á’û`òàë$†C´F· ü¶Ìhã®)Ôíº#0¿6]ü ¯wD8ÊÊ­£ÎI‚¶/Ø]5Ž9ôïÝ )*ŒþLFÚ²Õžýý„¹›ÈÍPˆÚY3{‰Ý,Œ)9Ìå€'8n89¡tr§ÃÂ;ÉÚþ¾X™QîèŒwsÐî‹ èÔy÷Ï>ò¥ãéžBcúpªåoïc–°ª2)Fòô5¬„M‡štâ`5£$k›Ü›E¾/» 8ßòO¿¡¥(ycxjÎU;y#çê½ùlî|Fèð‡AŸÙ})Ã’‘Ú[Ñ‹Ûs!6çm]ÙVÏ&qÑ–2“̺ÇÒ0¾½¾ƒ=Œ "alE ùVí´ãs«÷iµæ¯–mDɇ †A¨ÖŸ¬5¿ zÒ Ãׯ_™OE…ÓjØæ¤Uÿ£o\r cF`ÇN#lz.“›1¾j¯¦\A¹­Úo»oÙi°8Û_òm‹ØRc±"éЇn[×{€F+5r+jì÷á/™‰×È”BVkyT°0Õ†rhÚü $0Åçà„?çÝ2@®¯ty’ët~8¦ilÅ;ÊÙÎÚð¶Ñ`u¦w©Ùnz]wîÛiéò l9¥�isñœR�b&c{u¿ÓõŽæß”ä¡>`òI[»sŸ´ÅÓ]·t©ª5“¦›QrºÔ †ÛÔN½Rѧ¿æƒÎ ›Ã†í+»ÍnbykdK¦eX¸¶ Šø/ Ö{C§³rá¿Â¡0qê÷þ°×Äw–hä•‚¡q;×hÕ}w.i¤Up,h` R,}:8Ńz4òB/}¿ùô¢D;¬›Ýðs¬w=&3rg:…]ƒ0½ûýíé¥/ŸCôŸ"wëœm×Æ…$¶ù—ºY=øòQY-$])¾ÍyPôÞ°§¡Ú] 7_‹%:¾Ð>rW·Fªq´¸9 "ö´0ÓF¡Mß5†û`Î�ÌsŒ¥!ca  û®N_û²¤ð&ÞÒq8fXŽ¦2e…»Iq’‡ƒ8eŠÃ" "üj3¥}ùÈCg²© %\ñÑçBP¢´°wÒ›ï÷\ŠÊáÔ¸>ÞþÐÝ©oot? XÁD8ã@ŽÃ¾5þÍ7IRØôM÷äÒãQïÎàƒNè,V½¹©¾ *Ïb“…ô†Žòždû׶øSH;âèS¬”ÚüZ Uá•íøjpô2x„ÑÉÚåÎèëãŽý‡çíeü˜/ãúë=(„‘‘,‚¹…@åçÙc¦MÙª{f$*'€£9ïÿ‰þo>w]{ýñï#¹:9`8³u H%À™‰W‘iK(›Ä¿¾MÕ«b1<dåL©D4ý59îæpFÃÀŒÞ|ˆ}v¬ÀŽ_jîMÙfÿíÿʃ °OÁHÅn:ê|!Kë+m ¤¸~õvEr¸ý& ÒïÁÅUæ5ê$¡éÖÉ‘©Rœw\Qn’|éKg$ü Æ‹†OÐͱÅaÀOú0UEÚ^©Âí+^7UMÉ0ÀúÜï&“æ¾6¸sZ­…‘8ŽQ”[ÅÃd¹4b/v0ü¨gìzÇeìz@‘Ø£ }ékjÑÏ™ëð‰÷®®1‹‹©{΂TàsLžxíåÏa,iêYÁRöàúô¬À<Ã08é.¶®`œÐàY£šs¾Ó 2Ú&¶&¶æ³—…“Zoé‚ÓÚZ½#dbqKùÈšÞö8x¼yf²ú;wIÞk¥•Õ÷«˜é £ Þ+&„©ê9CšÄéÞÕý|?\ƒ�ÀKÁ·øQ¶$¤ë·õß®R›×+zËÉ8¸ü’Ä®ÅèšaÉWÃ_­Ÿ kÀnÛdwäM^ ,¬UrfTo("“/Ô^¾¨ždÖÊbÀó»¸çÊ4j"…´M3æÑz6# ø&ôÀc™Ût+iy›‘{JÀ]A÷›akErŒ€R={¾6ôÃB¯æE t¿ÓJ]†"î›[íxbÒ¡_x~Rh›SF´¾(¨+äÞQ}Z[‚¦A×®0Ôe»X9tcQñxïÌS*I.“VÇ<›Ãab„’…LÆi.o°3[5ä–ŸT°ovbaŸM k¢Ýp°UÓ òQ·x(YAÏ*\˜°7U™– ìnе­¡ø˜žSW³=És3îÈ*ÆF·g] n=*Ýæ|iG·mNGSh€‘ ÕÕ+›Í]‡¦vãúÛó{§ój=;ÛÖ_KÃ¥¾Æ¤»‚ýÆ‘5o†HÃn߉*éšjŽ2Ýé_(ö1[ØŸ¡…Ð|N ª¡.Þ°{g<þtŠöÏY÷ö›ÿ(8£ã˜Z ^²èØæ¦ ._oèIvš¾m\ žþ:ÿ±ƒIžÕZ>¡9(t·'@L;#‚ÖKh§™¡Ö baV™Íµ¯)¸¬Ç BÕG{ØÐ/úI 9œâÏ9:QZ¹»”ÉЂNÅQá/™ØƒÕ£˜Î©†ñ×ï]]߬Â5ÛX „B ¥Q]çÙ2â®Ýçßôb_ ¿"¬T¢”·¶Ó s?6ùµê›wU8#/‡†éÙ•œà˜C0'–]úsnëÕ×p7? ›ŸŠlÖ¹N‚üSáåÈ™è\^™„iÜý<&-yDQè£t L¹§„ŒôròL¬Y(íûéøX‚‡‰mˆ ÏÙ×é#’²2´†÷”- gœÏŠ‰Ìy.@Š¬è+Ÿ‹6¥ªƒÁŠ6<&žó o>½rÚÝVæßYhsËÀwO¡ þLï»sQÛðsÁþùœ5Šôãgf *Þ†ß~‚„.Óû7Ö†Ö=CL]c8\¡´_[§TqéFHšJ§…=³®þq®¡d¨€\G8¯GÓCDÃoßõž§è¶»pJ¥¯ÏòŠ([TôëÖƒ3v P"[=ö”µ‰žÖ¯g|q¸Û‡5ãž"×V„¯ô›4^AŽö j'V.¿£‹‘ç™] ƒÝ<¤ŸÉëJžÀ GÏ>PV•5 Ì«tˆ)wIö>…DÂÝt¸­Æ¶åát|=ú7:éqå¹Ïeh!B:QåX=§4* ëËòK#iGgu';=ÿ‘�kkê&øôBaš׿?»VÙhô"ÛI9ê”(œ†nÛ¥Zæ3Ñ̸\\PJl8½+‘GÀ mbù’@‘Ò™² vj8W”e[] Ørá|×Ö¦3Ô{Á†‰Öf­°qt“Ó2Ò9’ø+ÜXëåðÖ˜ßJ‰Ð?mžž¡@ƒ%óXtˆk& ˜L /MŸT Ñ“päK Ó¡ÎÛ'Ü(ô<ôÒnpö¿Ø;‘“ÚyéÓÛZw:,ïö4cgÃÃápdû]á ]¿^)«ؚ4NB$Ú1†˜gÍ™–u&O€ùã|&‘™õæìör‹.rÛIÎóX±±¯%°Ê3ˆ6—oÇ'Û[ïê|Ym!{û`¿AÀt¹a¤÷ÍêÙ,˜æÀ”WZw]Ôôð^ç´gæEzžµQ$¤ÕôGw ŠyÛõwœUQä—Q)N(é#Ö%ªày€2|8oŒvþÐ>»P~‹¶e(Øv½i߸ ¶±WÅ°ë×; §zI'& VçŒ%Ÿbûa=ç žf�/YWᙫmç®þ-q–Jˆ:kû Óp8Ó¢8ÚîÚk“5.gTiœP8É‚Ò’lcÑe§4qç”XF¨™\Ì$qñ¸Ü¡¼Uêt7]À«UH+E#7><¨Œ·~ÌïÊ€V™ï9XC ø¬=š |:Ï6hÚíeŸJòË•„y]ºf¹ŸGG ,Í‚t´Ö}±à¢Yç»Þ „껶q{ÅFL–TVªê¾tF·Ô½S䎇 {¹®àóUãZ¿ÊnÐþvÔÍ0ç2Ýòíü‡b>¶CÑ‹ó˜y¨Hˆ‡qsë‰Ò–•?,cåŒÒÔÎãañšàŽÌ/XuÜVšÕ?#Ê‹º£•ê`TÃ( ÕkŽôç¾* —’½Ð>i’ƒØxiëþW€çÌwòÒ÷0T˜;«u_¢hC=ïܲç£zõûÀ¾Þ#{è*¶Ö tvdŸê†b³Ê`½›ÿÖ½õNà™±®“åOw0¶©±Û‘ÖNÚj—iìZQ‚;ºtº"n èw"Æ©r–?!zêP17˜§ùLwë[Û䛺ojßæ σú´9MóÉŠ6qõ']:*':ï<éÈuæ˜ØŸ² OÍ… }e­8H©Ž½%Œ² ,óàŸ@­´îð-ýɤ¿xàá3…üùUVð”ã(ÿ£+xIÔ~õŸ`­dZèqhÜйH.*ê %¡sÿFr»ÍAô¶m‹'3¥8ôÑõš�¿==xD/ “™‚'z¶ŠD˜‡Ò­ÞÃâq⊩?ϼ_¼¬yF¨mËf‚ÎÏ8yàö5°ú‰Ðx3ÒÿM§c7þo_ÛZç±”­³gI™øí–nnñ˜¤Të“»h‰kìD¶l‡º\Kw4©kO _ %.ìÃÒwâ7‰Èç]?ñŽ.–>¢¨>“<(·.à-…ñ`QèH" m«¯Ï[ì¹—£óP°ï0½¯•†óRö:»ë±ÕtV¿øÀÉ»·øá"ò}îè.!FR:d Aô¿ÞÕ—G(Íèÿ>À÷B~Ö«%Ïp¡MlÀœÙ·oy$Ö¢ZóÿV<. }j, ó: Â^§¿Ç/T·‚è„I—t¹ÇŽ~­/žÜqXš~Ѧ§»nÔ—>a)n->i­M2z•WzćS{GDÏi4æÆ{)+žJ±Â¤dæLjõQ0¯ô+âx8Ãù{Lƒb>¹×f‡f¾7cŸ©îwreÝE½+_ÐE‹Ïi¤ÛÚÕ ™©Ó0\à'vqåþÌýËëN_æ\DÉ¥¡ÕœÝî0S¤îê0»úù=ù¥"qJj cØá\4(TH?SšÅbÄh;Äb;³¥LáxÛn6zзšªQžûÍJq{píT+„Èz\Õ-ÕR|J+K˜NŽp#7¿Yô¤}rYfá¦̻ϵ/äÖõ7 Ý'RñyåÃt²SyÓ¨ [‘ôôÀN?¿¦åfуì[“ztLºý+kyMŸÜh8Ø+^'{¡ª)ºÏr CFàE’~j@‡†Æ†>³ƒªÍŠ¤º‡n¨O ²¯~òÉÐìdAøkŽƒl­A63ò©tç™&i>ö]ñ—÷aò…ª*Ýú¶FþiùötûGFý[­?ˆ<Ýâê>2=‰r?˜³p‡O3òÕ*@¸”%[¦<É® æÎ…Ýv°zâ�0£}ëŒ~ãȵóËÌ#Ž|¢)ô}@À¶3èVv¬~&Ž4¡3½WZq¶€›Q»m¤c>ÊG—¤/fìVaÎ槼5Õ£dr2#DdßÿýPÙ‰\ ¨BÚTõ°Å£¥k6ŤP‘y»½ZýÖìÐÐÛ@ƒábw¯çÅ¿¼¿nš3<4ɼCŽ¥Õ8§íÚjæÑ1ÚZ® HÍïÊ· âôõÆå%µ‡¶ºb Ú»–'uø팗mãصÎ#FgõÐ\L¿×½‡g !œ‰6ô¸Íèg8C#Àüx›¹qš« òA•€2L¶ög÷PC~^’Р“ ‹­nŸ"RiÎÚäu”˜vô{"öž^©´üeQ½æ"ľëÍÉVMÿï©_øòxvsbk M(ÔžŒj48þëqÇ ÇUm°FKƤmVX&N½Ñ7+W0ŒZkÚ‹gÑ‚?û'8~$…Ï „0.Ú¿Uc}.1 òleíŸýÀÐh$-ÿÐçуqmì2h†¢"G3á¦ç7]öÍÎÉ÷ã»L=þЯlÉ n�›ç [±"võó×sU˜EÆ2± ƒ_tÏÌR‚ôÏ”GÖÚ§ÛïÄóL±j©HOªwPàSö*õ¬ø$Y 9>n=¤#¯%ßêêtÆ ÀÕͱÙB ËjKÆ›ƒq¦™Žšî±Ô¿ôpÞ¹6÷Ê|‹ ©ÈÐåt|ÕÐ8 t_˜ç€^®´ž#Á£ÿ$qæ{óÅ ß©‚´þ´Ì²ESÍ™PÚ§' žÐWS wßÑ-™ÔdD˜)þövx×ï,ß^qU/éÀá•RÁîÅÔ;Øg½Ž-øÌb¡qÆXÁ*¾Ì ጊBn/hf¾(õ% âÁ:¨–°Ûš¼ÃŽ©^裈FBÇÞn7¿‚ÔÒo0÷ÜÐr§:B~s2YlÃŒ‹½.Vª6›C{¹ÆòðQÂXÓÛVøö…a„»™‹NÑ<“ri÷›¥óæ-2JAXYk}PÅ*s]3Œ_qÔ“Ru,*£(Ø `ò·Ú‡È…g:{Ú"/µcENpÛžn÷¼¦ f[“LÝGÇ=m:ØWÊFLç‹O÷•câóö‡>â4™ME6ˆQÚ3"š´^³rrƒó¨Í’j°e£Û˜AQqk§‡^E8ïâyîüîºÔwXTÑâÈ©(©‚¸S&1¦õ^ä.cÒÕÐ.3âoWÃ;’éÒ,/awÜòSQCÄ£WÿÕÎk%þÂ×Îx V’T•ƒ¢Ã*4›èÇ«ð_¦P´aåþæ²€’1‘j2e€ËÆG€©»{žbo»#u* QÄW‘㫸ÿëÙP8ö:xøå�+s2�.:š¶^FÆ.˜tCÄ?õp˜——{"óY‘-éÿ €¦ÑÏ_¯w‹^ØNÓ |ïýk Xô½ÄX‡²›ðçèJ™…Ôº&þáŒ0É€\¶AC+ÀÚóV,j…$½¦ZxŽfO—ä-Q M‡Z#.Ð%”Õ²ý¼Üˆ%‹ú™ÚŽVdìHéKC%ü zN C ‡¶æ ÞÜšzµÒÁ†w¹½ -ÚXËóȳfcNdÂFí] ˜5]V0ͶˆËeÜ€áM·úºe¶•PPäw¸i­bõÈ÷¦k`âÁ³^‚œ¤M“QaA±ªüÙ&‹…b8¡ø†uô)´Ý6·Ã§ÿÚ«fÌÎ<Òa{´Ð…PD…I¦¿«ñÓ]<™ »¦"·¼"Œw(®|n­þ_V:¯1ªã]«3`ÕÛÒÚ£Ÿ#ÊÊÍq&j ðW‡2É°�*;S,]g›Ã$¥ÙÕëRv1¼ö=œ~¦„GúH×døt[¨Jœ¹Îýîw™:ÇQá·óŒø¨€hà�WJöýïGZ˜Ì*¾Rk='Î*—ÕšmŽC¿ž\7°ÆÚ·òøi±|±§|ê‹ ˆÂ½å9¯œËÚã2Ž‡cJvÿòºýçiÄ:—QØ^\“ñÜqW9îà<¼)уy‘cp‡.S£3ÖÂй¿ê·žp8èamj:<Šcu{ºñ·(¼ ˆOBZ!ÆkM# ,—c`}¸ëæ‰Ï;¢´jõ'¡ÑמTæ¶8é»ÚÈE¢^¼þñWyb6T:ñ¼Šº ßþ¨Øhºâ²gØQ©Îì•÷ÊçH…ÅLrÛÒ2Hj}_zÆÆCL¹†;%1èí sYÉ›Å^±ìpRf&F*ÂÀ".Œõå‰öKä©ñ™ÓlãÕvä\(Eª îè?ÖžñÀÇÓÈç5ÿ‰K^ÁÛóŒ“&?Y[ ™º¦¡s’u{ôh¯‡‹Þ¼šŽò ±.[X•Rt¤´! ªÉšþ ¥øã6«XƒIëìê§û@Oa˜cŒ ÍDw¼øôóvKÌVFàrñjˆ_VÙ2à�*‘ukϵg{8[™½Õ Ê4rÃ_ñ<’xáý$,½nWÖ›×)¦*NãÝÞ›.…è±v?0¸ÿ™]@0ꃂö>w`Rì²:£ÙÿÌ°òºÝÜœ>‚ÐV8KKQ5êä ¯žè?Eé«×Ã`†Å“Žµür-¨¬Þ—Û'¯Ü`„uû*ˆÚÞ“Ü:2fyr‘ö¹ÄDdü$ZXœ@Yá,Ä̤cöÿ${Ê=_«6E¬È¶ YÒ+š”V̬ˆIÛì‘â«žõmÄÌ=ö=ï¨âÌ{‹ÛÓ;öK¨­=:.x´èóŸËuÌÝ´¢æ–‡>"b¥Œ [Kæ£iþÉÒÂa™~Ìâ=ô-âmí9ÂC𮬅ú“</M2¯~Õ‹ _&m;áƒò°ÄêÎR¦ÚÖ'ßå1÷]á#DZ#æh⨕s¤Öt0‹Ú(|ÀŒÏz‚ PèÍå¼Nツ¸£¿½>¯#Jž>€Œ™²÷¿vóóÀ°?¬>óµgŸÕ½ŽD^%7 %ÖbœVÝJà¢V ÈŸ‰¿©UÇ u ŠYÓü�µá�Þʼn… 'göÕË3CO€«6Êu©¦×¡~îØúD›¸çÝ<heüD«V©¢Æ c 3òO2€ÈDõïaäÇøþ@4²”@±ŽŒdÚºÕæ FY]¿;hþþ;Çñ²€É `ÒÚkMÇ–2öøñ,6²`Zm)Ìš}ϧþ KhÕ•0;$v0·ÝÎVÝ |¿{Ñ2ï.§Vbù_Dã,õÆð©Ó@;¸U•ÓãÁ93@Øô}~0S‚ÀðE¡l÷ë5·²dtBËuŠ) }»*  úó{‡OçИ9†=”… …Ë}Xžþ{©H/t±P‚Šg±ø‘.èwÝIRûv×R&«/¯Ôœc«±­^Ä«‘vÈñè"»~j=ˆþ‡Kë$�ÍOúzËwÍ—òyEpÁX8êœÉ¶}ŒC8÷šU¤A„/ä'WwpuI庤ȭJúÊID¦¶ˆL⥮¿)Î9dÉÑ.צ–~uRßnˆ–üh±ŽxÀœS ·Çgn8'ß$‡G¤nÕ#5Mur³¡8ŸÁwï/¢ÀNSs8ä 6†Ò<óÑ´ÅОèGIQf€˜ðmLÊQ™�ÉÌv�BÂRÔX°î½ï ¦ÿ\è óyÂ…DÏ*Hm½}æÑø®Ö'ÿ_*]… BIFc¾ úFu È0ºT`[/åÑ‹¥¼SSù˜Ö‚î¡–…8›r[3Õb™é]Þsš¯¬¢cnPŒ3ijskV ˆ8?5cUi¦ Ý^¼€¥¥±ú G<BßwO³š=ð9ŸÆ½šL;†7Ä3Ù{ äK<&5L¡@Ô.¬j(³;J¸nÐ;ò.õäe!f)èÿ{»E’‹U_П°ù ,U•ï]‚?OA¡vOO|ŸÒDåvÄ÷)‘ñʺuîÃŒ•&€ÉiÞš«d )›Ì{zË­5 Y»iÃþ&Š 6:*9¸ë½³?•½+=\ ocðbÛ–IØ2gdýzUÒ:žÞô••/¯$ Õ•gKçgÑÖú<kÿÛ&}œ™çʘ@ê¿‚ùS¿£êÝÆ<bYž÷Enš4Yá÷¬îicd£¥;[¨òǪÆ"œØUóp¾z±Èƒ¨L]J”áñ4(†­×óúâ:\øº<Nb_¾“fª ·ëÇÁ‡úK Ǧ/@cÍh¾Åá÷fâuÏ}ƺҋ5cô=’ûþìåXˆZzp%ø@ÃS´‹áÍž‡á¬ÿ² ï¤+Q6 ²Y% ØÛµ¯ Çh½'Èu±Èðݨ%©õ™F~é²"ˆÕäžO”x›ø–¢Ÿ4é¡ÞC’ñ}ý²¸X�K¬éó^ãm茂Ã:¾ˆ.<.?ÕsFÏ d¯±»ˆn¯ß$Ï M·ÁÚ¨‡k¤é#ßy›ŠŒÀí[(ëic(n6XfKÏ…š~ÿ5½­ÉνK„Öعá3â»öP7K…ÁxÚæß’T¹k8±*Ýê@«0ÿ<™»cœ¦ðÿûQTrw¨�2}a¶)E cËësùã ¨Õ²éc#U×OeuŸž¡Öì(h‰`\ô]G;Íÿ÷–^yÂt\7í;ô³×Jà,Øaîü¥U›ñeea/™<;†+×gqž¶§ °µÖ8›‹èR™È,”3ûŠJǸÊ*ë*‰}q`“×ôOxÔ±ïníýe±8‘ÒRdÛŸoh/Xî”5}äSkz•¸/}W{ŽÉo‹eT…UŒ�»ˆ(™­¿•øǵrs šø¸Ueh@!ŠÞ½Ò»øæ0 ºŸ„ŽY±f)«�­ÚÃnºì¶3s@¸êèEIœyð�ZíMÁè©ÆÑr,6™Š«Ap©”ÒK¿Ê^\y¹—^3�•Ö^Zñºõ`=æçQsŒ=\ǵ›y1®½NØ#¥ç“•%ÊD9C÷ê,þÒ@;YX•G%7x“£Va²3xöô|ÞÔMÒå×΃ŽŽÌÄFì„5ƒFg¬®oÈ­Ò«Ÿº#\õoi («…¤¤fÏôå7Dˆu$u~o„g723ܘ'dÍš*3_Ü‘Ç’…“¿ä†È¡Ôsc›—;þ9 ?ш¦‘þæ–v:r -7lnå2CßgÆ7ïDV›R¯&S¹•y“NDlOPšlµ»‹vh=Ðåc±úšjQ¦�‹ÁÂŽ´è|qaùáðج¦ƒS_3&=÷՞ ˜÷yah:­ú¬þ¿|¿:ÖRpFª™·\XfjÓ£H›j“þd‚ä?"g£çg->º~ÃýËÛfŠæYVùw}I™V"»= ÃÁõQü>$Ûòôçùúá‘ãå1’å9ÃKãµSQkð¾6UßSèL£Ìo4‚×€c>ªn@’ƒ8ݱø4Ξ@ St,×ô\æ+‡f5ßS´JÒBL%–¯àþÑž"ÚT; ©Ê½ «e•ylß6bê 5ç�Ø.زkú#š¤ûר‰YÍ¿9yé÷ðoÄê¤7ýömŒ# g " »:4B®æ—®·nË–á[(qõ{µ‹Ë¹‰[$>`ú"waMl«-%=Ö–ìZÈrÞ²©6f”Ó-—ÍŽ÷yIR´;¹a!' Ï€{q€—¦ÍÎ$ó±_fš,Us³�¼¤rÐf†}kÕÑ 9,‰E»¯ô8DûŠDßÍwʽ¸Xx.‡ #T µç×à ;j¤…ãב²Ùnð®èA4b¸½]ÊÚ…:> ÆqêÕ*Êúk¨ÿ°»ïWû%Þ‘*K='+fÝ|ÍTêk¯ã¡KÄÀ^Á˜íÿò=f’„~Ë*œ3}—­¸�QlèýP—jþ^éäLÑR#>îó m&Oó‘n,ŸñNwhÏ‹U_ß×K£Ð_a,•B‡ôz£-;(›Œå–PÐ÷{ï$©ºF3³Sv'·Ç©aš‚²cMAÔûÌã j®Oƒÿ_|oéu‚$äW~´nSe&¾ {¿M•3Ú¼\ÕèÕ΄C¬‰‚OL´l‹ï¿ÞÖCÆ3ÞêÅý`ñâÈQe^S]Uó×ct¿ê%„€eoÜ'ÚÇY™-}VðŽÉǿαrc­ì¼ñ€:ð(܈`{5Æÿ{~C¹§ ’àù­Æ0H¿¿—\OyÆŽ|Œq †Æ¸ÎéLA¿´uvn«S}¹OoÝ‹éÓíR«®šC‡9…3äK1§ÝlFÛõïñÛ¤±0s)Çò­îP€–DÔÜgC§ôY=™³þ£ø; Mñg ËÕÐ7ÆgZKÒIu×nè&÷J‰œl$/TçãóPÁ7§¸88M×#êÝîÿ‰/nXeMäî?Yv[ÏÜL¤Ì Y`of´¿wÚŠó+¿Ê¡ƒÄÞè!æëqâÒM¦šN&Óo™Cä¡3s‚6Ú¬åçhÖiaM>;”cݶ»Éï«ëÂ¥rÞ°aÄÈ–2jlÞÛ…\¦™tˆ1Ÿ¢ä=ûé|àȾ&‹Ã­™;×­Œ^:Ïg^·…%øÛmµÙBQÍ|úvı܈ï~ŸÈ¿“h , J”G–t^n)2q ¡*}ï¡‘š¹(–lkŠ"Ö¶¯`gñÚø) áEê{}¹=½ŽCÊ”£–Ê™AÁûðÓh!©ïœ¸èÃCèÖpŽËþd… IYBàœñ¤z[[Äh°á±%=»›DÒ#úo}÷~7»ý#ÊþVk'§½Ç©¸ßPßwOåØG¦°Ó÷¾Wn<yC:…×=§ê +~m»Ã´–öîÄ’üth¨ÖFfÄ)e\û/ŠdE}ñS¡ðôÁdDï¾6Áˆl',3uÈžnXwž¾?‹:ˆ0æG4P>ãe‹œj?Pðy±áÑ»&­•ñÆjâÙ—Ùy”.Ìb¾¦2pìô¡_ýèÓ]#cŽÙýÀ)¹ÖjJÂmkƒa0;¢½m_¹Ÿ 'ˆ=GòÂ×,áÑO¹ [`V¢éãgtÇ“èÓÞï$'YæuËà©�m°Nq˜¬fFËÀ‰u\IÍ‚UÞ¥I†,=†¿)|ú¾|–<iê³ì…¯Žbœ½xlmjÍ ÓÏg†n2ù¨T,Y}ï_Ós“ØJˆ0c­‚lúôf¾XZ—cÎ﬉âÌãðÅìR»—¬Ý8šÒ5+×2²2V/²~¾:q¸¶ÚæÌIS1 š¾½í)-ù_89ªrn¬#VkúœG_¨^ ƒÖî­G{ŠHÓSÃ?¯Ê«î‰ÒÚ¤ÙzRr€úR­}%q•Rq<mÒýØ/2³«ˆ¼¡ô>™4\áÝ'6N2”‚4ä­¾¶'ÌN¸7î2¢`î0\‘Hs“'9å-AB£6;í_ùô‡ˆUžîG´w4$ËØç{`N\ÓÉ•lU¤Å3ŒùŠ*vÃwú<lg>£]<îAêüKµo]þì  kܺ¤âYMÊQ A¸éOÀeŽã³ãì=ýÊCß¡‘–®È°C¹dðfø‰Y‡qG'ñÓ ÈÉœø1»UØ[ïäõÏêþÏΚ>ë “l^Íö"+°)RQÐÐ3øVìxýŽÎuÚ¿˜•™\2ϲiôßÂF–ói(J%½eš±B努‚á�oLá$Èš[K£¥ü&Ý°g?ùãi†VGpÁɂºˆ°¥ÓXc£9¯AI}H�Íé_ýE;±*Íxp>3Ùe´3Š(¸‚¦xíÎŽ§+öõ±Ri;r+zÿxFpÁù=+\:ñFÀŒ%)>¡{`̼뭳>¼`$îQÉ‚›ë4Hú­× ³–.»i{8ÒYr‹8€uÒ1¯&Ã÷{Ÿ6®UÆÚ…{²±_m‹Ý0ÔûƒÓ¼xQºWž Ù´Å¡Îf+lñqx5Ó‘ÝŠ齟›yD™ƒZD&c£uç§`DÔõ�`ÑèY5ZÍjáYAC‹&îÕ÷±„ ñvxCb;Î|‚»VAõ¹væÐSûÑœvÜ®ôVŠ\1 ~eã¥ÎWB„Î1m´ÞfIœe¬º¶VràÒ.á¾5KR*ðLà }C`Fëž7ÅÈ/D¤V:ETí´îW{wÖù䢰´Vá•qÀn Š ³…~Īª¢W×ÞÎÏìö"¿Ë¡¤œ±š{ßÕðµQEnþ‘Ù^’™ç?�Ôù”•ePgææ0ObÄÛí0:±”7.ÔbON[D©9¦d£ŠZᨇ vvpÒ“w^ƒ_»=§ïF–ĹÂǧc²ä™Ÿ)‡+Õhsõ×ÌlæA~k7J ×m¼3jõhA­.Št>:Ãþúj:®»zI*Þ-Äé>y…/–Îæ¿�]:2ýŸ\DIù¢á·""5²ŸéÏdŸ?~àEùèªÉç°J%!sž6§¢¤r0UÒîJºÚ?«¶§¡çeîñ_’M°ø:÷Þ÷ƒužØKz=Ì4ÔßÆÝÆèÎ@tWêÆigl¸ 539c‰¾�ÖiÞë<+‚¼?án¨/:1ã#ãÛü·ÔXfìýüMñ¼Ú¨Ë$ZµÍáÌ4/Óà¢bþò1ƒˆtAèá¶i3¥\»Š€Ú2øŠyS€RäŸÊW€¶/{SŸõ[зú=µ‹»¸Ùy.G=Z©Åvã™Oé·é>|ÏZq.OYÏ“nB3{¢,Ç‹IÙ³ýé&äOr…'gz/iZzn{cáÍÀ*èÎuÕЋVәLJ‘y½ƒ”9;L65€Yß?¶}×p¶×öN—u„6"?“û”•‰RCôkûŒ1¬ž·,ªc«gùÅ�¶ŸŸš¹³Ü•QÀj_ÉÚÆ@ ÷t;Õ…»á-BÞ»Òà],<Ñ0±_§ @7^ªËó~PX? QZË”qˆ÷~…˜TÚâCNA5žÔºè´Z7.Q{ÏX.ú&¨tÙDÇa›% |‹ ks@z—KiN@߀G$AÚY5`²àœ³îQ<3dâÌícœÊ^ brÌÍY*¦ö´¨wDZ¸ô3N!ˆÐ9°îœ2sZúNqÿžùJqŒ’]mSˆ5 Ðd_c`¡­jðµk4Ñî†ãØ¡Ìð`^áq¶ n¶2­‰ßN¤Ÿ>dà9RŠñÔ(<öd/@, ZA¡Õ6.f»Ñãy¥ŠZUNÖ±Äm_5%K‰I©}ÞîfªÝØÞÀÓ]dG=»U—lIRF†S¡ º2­¥Á æ÷†–›‹¢šLWVb€}Ý×ò¨ý@cÆØÂ^ƒËÌcS™rì)r…Ÿ£Ó>âœ7¨$ÆÇ£S<£< ¸Ç2ÕnåÇ‚e]&ú§¼ŒJn_íœ8Ê¿™¥UžÆ9·ˆ?�$ ¶§f =›úˆ~:·žë†¶3¡ê`Ê“‚¸Ã )K} /öoJå´…èeea0z>»ò¨oë¨gËö<é²FS ”HpͶì/~¸ÍgÈüî ØâùVµùÀ™¨viÜœ†~´¹³}«ü¥y˜yêQ°‡¿Ñ÷Öƒ«ŒÚ§güþû‘$Þ¼(U!u°|™ Þ§¿ù@²r8)´v‚&O‚¸Ý:ü/mŸžº¥ç?Ñ!1<ÊèË^/Œ}Æ r6Q½qhåcw8öŒlÿðÒtjùPh€ÄÞø[Z =ZôÑÃÞsV=^ &NpÇHKüâ68Ç6)BÂà‹ÝP·æ@ºË ໬"¨e(ñšAµÎN¼9ÞÁù,RÕHPé%Ýü¦óÒím8ãö€Vv7Q^^_âdˆfIŠ{Ú‡y?[Åìš=¸Ó­r!¸ÿÀwQH˺ÿ¡±nÅÖáÝ@g!À”­i*”'MäÖ#Æwf‹ë1]”aT"7JBtšÛZåMàÕ“~ÆÁ¶Fqì2„½ rŒk¤æ†¯’™r|˜.²eßyWwì Jì #ÀªF³ XÛXÐ褌A‹?ò.vÚŠjAå,ƒ=íþøl‰–a¬Ò²Þh¶ì©á/ø磦ʻ׹tòË µ¤Ð‡:n}*E›¦Î,}àc(Ê:{”M·¿ñ@m¦L1{›‰5�@-Â2˜µçí¨º_oé§>,™Y}ì”ÜjæHu‡KçÄt ËpÆÀÒCïdÛ g<L’öOrÍsA¹Æ±Mz}tP)Õ?S P_G#¶Æ¯�|z¾½´b ¥ê$ÿ< õD‘qü¨œþ`} [zYŽè_ èÛÊ(7ãˆcס£ç<#v »˜ßvÝQ¸ÝŒ9N{‚>4–áBS« èd¤uQJÑMhPʼÉ+°®h,ÿa€$ePMƒk@³í«ÒQCiÛ/Ú~qä€])ó°Nô–ß“54M[ÿXˆ7ÿzg6ƒ®€ èåvfúŒ¥"¬@cÆ`(®´Þ!'™×ݯD³¶ òºÓ NÏñóôw‡Ç(}V^cÛmÞ³þ3£Sñ* -'GW¹Ì€Ñ”SÍŠÇ*[åæÄ» 5X«n=tÈ›†*"b¾1.´¢ë6i} “ GÛ÷@ZsÒ#c¹BÞƹhiq’ËÜ¡”* íØ€:D+V©CJÜ×KÊÉ3÷«ØÇ£0m¦) ?êì¸(üÉÝ‚Ž~Ø‹?í⧇ÅvúC�üœbÙç·çÛÑp^YUï ßE6J !¡`‹ùÔlRžìF#oeúY¿u•¯<^´².c5¨Ð8ÍÙ¥ŒO´_á˜3A–¿©¦O_â Èø^Ö#nÂs±›2/2G aóDŸ¢³±µ2À”Ån(QüÒ°¿F)JZðÉ}H~Ö˜E ‡"´2 ûk}w†Žµ§yU^öNNûÞô%ñŒå3�Œ÷_”‹|*ÃÃÖ0EHç(Øa%€ô/ÔþßLd•±m Rw,(ÂYñAVÍùøâtøTž1ã£z(,v½8OlÇþå/‘06y0õ@GY:ÛÉX¦Ü}E¾©?þŽ&yá2Ó³)ƒxÐ?\f¹@nïÎ Öüˆ Ï-ߪÏÞs½çÄ (ü® V_¬%lIÞÄN†¾H4-úí&ŠïÖƒë® 8ßË0~% oé¡Q=šàÉ”t½ §L—U»Ž5*Ö'N•–ÐÏêvœ�œ¨ô¨Nš!ŽJz‚ÞKûÑò¢Â˜Ø¶á¿gåÒ°È�cÄ¡éúð£¨ùè°†4wiU‰BD±–J?¶PÎ>/º ý'0wDïhÚ5.0l£Àç[õÜQ¹ðâ”å #pÙz–i MF³Tµå('‡¶=ûº´²e¤¸…C¥\_ÌÇXKŽ™}22wï¤7QY6žHí ÍôRŽBv^ô/: ©E…q>œ¿Ó §ê5´7þX˸¥›Ž´3­M• »@/#$'ÌKôŸ‹Óïô0"/ûÉ%§5}=îÃJ÷CŒš„oÿtJäX¹6yǸµ5;ôPª¯P¹fGÞ>À¥ÿ(ô%zÈ‘uG§Û÷§ÍÙs«-òÓ¸ÛЮšÏÓÿ.ÿ[ºöZtC÷ŒTI´G[hÏ”“U<ID4n×ÛÄŸœ6ÐßûÉšljCíפŠ­…h¡ÛGÉDò4ZÕ¤;a÷±kúRï*ÆÀ‡öüåâ™Ó™|iÆ˼B|¢Œ(hõðhz’ãÖ“èTc§U-ú·œ€.Oà×õLå9A±ñt¤z[{ªZ×94À¶^Ϧb’µcÔŒ­¨q• Óµ~ jîôéèÛÓ�¼{åºðúuéb.A T:<)?<j?�SËmŒÁ° Ç{2Àž8Û™Gîsj MÙJçÍï(ÃÜ…Îm‰ò¾RE±§±O'ÚnÇö§Ý°Úmú]§9žŽGé2ÈôW}ú0©ò…¸Ò‘B·ðñÿÁos¤»B1È!Réôï VÉÝ ŒJ˜wP›¾öÿq<Vilô§<ˆ¬ÂC¥Ñ.E“Ì4f</î߸“Źi禕 5ýx,M<Úç2’þþÁy‡je”Ȩ޶’øb›Ôý Y;kù»T†o…ò¹††ÚQ×Nξ؜9»Ã+ú(]öÊca=‡,Žjb9ŒŸZ içï† ÝÌz8¼Í®Ê+µ¨íÉ?”PÖ �nP{l–a€n16¢¼KI™7GÑÀ}7=X~UPÞú8‡qèWá¾çíÙað,Ô4µŸÞ#ŠÒ¹ƒ ™š5aüŽÙ…Î3pʺµúO ëœÍ.'´Nç5­Ól<:Æ&S~� æ“ WöšQ…Ê·Ñ`ñ­ b6žó¥‰û® ŠÏÑ7�:ô§}s2ìªkz 3—F–HJ²:QãhÆÉàsV”îÈD>Y”ÃèÁÿÅËsë> üñFí&Ï™—é\Ç‘nƬ±(¯TÌÒõæ5rk¤»~]; ãè ¼˜ú2ÈUäüli(hé³[j¨ùM\?_S‰¶(V¼ZŸ¡E™E¥òé·‡~ßÙæäÚ RΕµSâz#žº4# ý* €⑸Ù ÿýH –¼òű‚ö²€äõŽ§ƒ›žsmßwìâíFŸh*pÞÌq{b¿J+®�ËCƒÚؤ źZ6·Ý´,¼ U»cŒbK•~*ÀŒ¨¸²Ú6µ(`¢¨kAžIŸHÆ’n<éÄÄu¤ šŠ ÝNM«)ŽuÎ5â¿eúñ¿2·¢ î¿[Vö-4øaB™)�$Òjæk†Î…µš75žHa¡ÿ„IûÀÕ¦€»jmÙ“µQ‡us´°rq%ÃÞg%™ªSȤ k*ySN˜·eŠÐ'†Bº'¥TAâ¨^Õm½×gô;ÚS’æ¾s˜s"’X"`Ž»#+|ËðŸe!Q©ƒ×”ë©DúÂk_‹ÛÓÂÛ¾á¤zhÃw“G!Ý×#•Öó]ÚYÙÓUf Éc%†mí‚|&vWw~N°!GÃfµGËꬣ)Ô"Q`Í€*•q²Ä RôéèŸütòÕ®‡Á¸|›[°= ³IŒÝ¥Œ|ŒÏ°Aðg %673ò~7ÎÐòõ"8í©Íö =ÉÙ|Å´?Ež/z&˜º¦I7(G ÈþT+w«íxi…¼AÓUGµþn³;,.é—¡/–eØ E~=O˜æÄíÁù;óÅÞO \NüBhûÌu¤ÛÖ«ÌÀÊœø›InVM">~ýñ€ïÿšf»#¥½µÝ'  ìÄøQÞqwœ8W¿~u±8Š“¤ }äÉÈ“d=«Û¨xbKÇËAjèÞ[¿­Ôpæzÿ˜®†§1S±´stÔþ ˆÅÕi÷á×êÍIé›ksWõÚžÚƒ½]óÞýZìçÅ€§5L^UB¸?”KF¤ø| #}¹ø4;¦ ªG³•�mà݉5Ë_AcK‡áÒ’ ±#¥‰ñ÷Ú« ¾O@Ø:ùØÉ‹¹o\e>ÀŽ óHrþ«èn£»®x#Ç*+h¬ðJa¿-¿²Yi¹í‰òÝ©ñHZî¡\t­ðÉüïêšÒ%EÒJèkˆ*×¾Ûµñ÷™5%»­ƒèµâü³ðcp+ªoÅÆ%¢ûIbÊžõÀÆ—¡=á\ʸq ÓMM¯–ð,óš…LÖ8CCßÎÝy*I;Š³‰6WMòÌ3‚ÔáO¤º2Ä5ÜCZש64v}ÑOj•T£9OåŸ[WÕÓˆ Z§&lè–sÇÒ'¯~ôLYzª;”ð×=ÝÙþÓÅñý®ÿsšìQ«ÇRV‘“çbx5zkgö ²P´2D6Õs=zÃ3¼ðÐ1,ÌÑBnh½6½LxÎ}=š5Ö ¬ ‡úËK. sKH÷œ51Ѧ`xëéñ¶ Ïä´¸âSyó l“6gÇ*n$Ké)¶Y'a¶ŽÝÒñ“,zw”®8OÌ(Ýv{˜ÊtÆ‾;åÖ§ýÍósXÂÊ´a›)e �×íÚÁ»¢ÛbµÐßö«‹ãÔwâåVxDÖ'Ju–‘ÛL¹‡9åçÒ´ä�Åe¼àÛSn²rЉ¢VÜÉË“˜‚ot:ò(]{åšžx¡DÕË)ÊÅóÙc‘6õÔ v×ðTÿÿʹçz²x7û)tfGò‡Z¨²B·ÂÉœwš›<}|œÓ¹nùš;«aoÖ’;•–™ÇËJ"¶*Œ*¿bÚ:ºz³c³¼ÿÄ«Å1M CÛAôs m7a6þaÝ×ï íIRdž¸ ›Œò'_¥ï~Lq§=aÏ÷àÕåÍüÀ°¨Ê ½Ð¿ÿ:ä´OMÓöœýÚAGí^—?Áy^Q ·-õÐQð™sÐL”æ«×²TÜžÒõÖÔ37xþ7¨&üTe^öC]ÝÀÀÕvö`Û4ß궉‘î¡ç4[œ¶í¹ÇÂî/ðøÁT°¢t='ÍP k;A;: ÊOmóžÑà.±ò‘!S5L·¦…½èyWêÌíûŠÊòú‡¶Eƒðg·¢]¸«­âËl1öô@4ÎüR (ª\ ËVçf¤çǨp¿ ø±qüaä(ñ¥Aàôudî@¥ï,wW£Í¤ìa°fxÌþHòÞËÕåþCä% œá–9Æúï¼ãÒÍx¢ŠŒˆ6Ȩ¡»YP<mhðˆñœä \l1ÿ…‘i™ éüשÌMÇ‚½VÝÑWßGND“P¥þ@„ÅÚw w«fdø8÷šÍ•îÛ›_x´]Áx„ Óô­»¿Î,¢>]Wu›Sëü7lN[4WdÐð™GßhpÈÙkËÿ/´6‹$J3óž\TM%Ü6.1DwçØëÙ¯|M‡#N= (T‘Þ œ‘¿aBÙ2)kûíQ¬½”‘ݳ¶1ÌÛ•°u*|-æ£b[¥y�µ¬­j4ò-ª3¿&–øPäÚq<œ'³’&_Q’ùÍ>6“tþçÇÓˆïúÝßdîC·O ßjƒýRGŸ¾RÅ¡ï»*L]+üFBÀdU§o@¸-7µóÜÚ“òϵ;À¼K¼ïnkáN²Œ;hçØSÃÜñОw^‡ŽRµ?&»|ËXP¥°Cyì@q¬8þõ|aYw¶8îCÛš¿Àd1)$�_7Öª,Ê\ÿœ”™Ø·mOxó^HŠv=‚™¤¾×`RŒ~¶6þÒÓ=ý˜ ü‘ÁwKÒ¨JVËðÁž[×Î^v'ïŽϯürÕÞV=#6n˃´U‰A"”NûÃúrf¿#Ç[þøÐÊÍ‚VˆB6"Ìk•H¦{/3 ¥üµ aôŸÂL Bõ×\UÛ[Ön ¸'­Û‘ºïª‚îV»ªüÈ™²‘ÒK'qØ™ê]},ó^µåIÍ 3³¼í<¢,åÂóNëíβsþYrV¾Æ [¸¬±m€JN�ª´wÝ ©mX”(5­NÀ[n®eá· Án¢ä ʼn]AêD«²B8Ð5€"´OÍßÇ7£TíNXêÜÊCD8y«ŸŽTúM7p¿íE$°X µ@` ÃVAç8[LŒtùå/8 QújÈ@ô”Ÿ…ƒFŒQŸFùØ¥’?Ó¯^ÑÊTmñÜhYOÜTwN‚i Ä¶y^YwY”`íCãvYÀþl𫨇¯·æ·K\ ½»$fu5´PTÙ|›GûG =ŽÄ*bwƒ¾§ÕY…lÔŒT,Ôc½ñHâX§v8\#ü½Ù:Xý¡û’ŽÚÿ‹�-¸[5´Ûä½ýRŽŸ Üé@ïZ}­pÚaC9×a§p9ó YzNªèkDƒÂ?ªèþ` E[à‹Ñr¼wHQq_bÝSåf5NÌŠí¼>μÕú(ƒ!š¥ÂÁÖ/oè(ÁÉ­x¼tQ`³Fùm·-E±/þN¦jÕ©ç) ŠzöÎCŽû»ÁiÇbO’çþâ'Ô/eèà z,aPlGÏ ^}¯çØS”ÎsEà‘3­±ØB1T¥L¹wC„Ç1ã6xz¶dŠïAØ(·ò½ˆ&O¹4òΙ=@Ú÷%Ö÷<ûŠÜNÿ˜T%Cç²Ý¨·“ûûÚW@Ÿ ¨ÀMŸ'¬€ú#èdðE1¬Ž}Â.°NÅ‚„3nf£ÐW™Ç*‰¸ƒF¶|ñ ¹[¦æQÿ:–V¾å`R5Ú'ObS(ºåÜißÔÜzm³[šBjÌC·cEÛP§�éP3ê<¤•ó )ú¸Ô3?|Òó…{¥Ý¢sÚùë¬ðX8\< ›„ª§Á:¿T¶Á3”½ÁŒÀHƒ^M?YY1 _fG£~4Þ³å~)x¢§¯è˜µ0ø·—Þ‚»‡²hæUÛ²ÞøÚéç\#„.6PÍÖÓs§ªn%¤š÷§)Yì&™U1ºd½gkž±.×ñ´i.æß«SÉÚê àRJ2¶ª@@OMêP{$%ú;“sÔ½ óú@ƒÚ3OÌpX³Bo§ÚÜ)#~!­ã —ŸŠóEæ! 1ßRÈNzkâ™cˆÆ”Óc=ž¬w:Ðɶ¢¶%Klß=3J‚Ãù·*ôˆX¦  ³"1¿è­)^¶0¢pKr7‡Â•úЩl!ö{W·íš4ñ8¥©ïª šu¿ífš¢Àø®=·k‰5´à’ þÔⱌX.‹î°çŒ°e‹ '‚ïêÂ¥©o–¢ÓL¥Ý§Þ&¨¿²ƒ„ 5„²‘ Š“wyíÀgšo–vE§×XRìßzÒã 8,4∸vëY¬;ºðl/QÑîzYo<3OV+óà%Éøý½¢qšS02dq1_F @ ‡*î6œtŒ9Ó‹l®ÊÃpé@Æ–L£²+%«5¾IéaWòˆÅšÃþŠÂØiz×™)* –ת%€f)‚ô‘9wyÐ.ëRÿ ,¸’/±TYî¦o‰…šoYŸµXûœ”^[•¿™!DyäúÙ1ËŽ´:­^H5Þ¢×i¢ª»?–y·êijG¥M$õ§k“ãý¼ÖŒaEô°ôbk9wµÄé[çñ‰„~ßYõÝ‘vý×Áé‹jÄòåŽ5n™y“ç(giBèîDV£o„m˜¹íW÷BÑe†·�„m–!XŠ@²Pº'éý…®‘ŸúuÜ ±4\}–÷ ä.X$vÝîvDµ;·Ìë’v{�œë G:¡#q³1ú/�¬ê¾ÝQÎä.(iâÜQÞuù*0]Óò#d4bÛ]öµÌîò·ƒ$w~s˜Ä«Ù¼ú4N;úÑAÜyéº5'V{(»PL…ÃëçúËøàzW7kÜÂIcíÄ`ˆµµõãdº³u)gQoÎYÏ…J¨ÊØå bH›šs[£ñ`}Ÿþ&oš8¥R« ñþYar1­ucLÞ0Ýo�ƒÍu¤®ÚêVª{Ü1Zû½êÊruµ•"íƒBb;v¬ y™Ý;B€Ð^ ® Y㓆.ƒÜv®1<RvwìV³cÇS»=tWBä×?ªt'5(j#ª éþTßÖµ-ü~·öŒ:ØFªã@õòRçÃŽýG9Ì攲÷¡[øìk`¨Åög ½èUKÈe•_©)tv!Ç4«€;C´¾ÆŽ?éÄé�ZUkÀ¸A½Z)Ao{ZÆá.C´l+3‡‹ÞºS‡Œ,™¥iÇIÏ,H\ŠÌ4¬ìðEo–þ•:þ0ìhÌ2aÞÏ®ö5K¤jéýàcbï¤À¬Ö¬sÛ«¢l'‰ÑRÇ+)ÿÙº/=8«çÒ²ƒâb÷UšÑ}øé•cíù~iÞç9s}¼:#AûkÂ~Y™’¿·6Ñ=åynÄWÄæR÷‹Vî›e£†Dkªª¦z¡ý«Å1-êQ^h•áÓ놫O¶“‚­îé}_<™²-Ý&N´¹ia;=¯A€IâôðEn[gAtª|‘c"gxSpÜï®/¼§<{rÛþȶ?¾˜N¨“CÜüZ%\�Ð…g“²˜·É™€Íï|NiŸ¡š‹{Hâ,vO³ŽjÄó'XÁ¹cVã,;ei­/}{ÝtòîFŽ£uØðàÍN5(›éšnèþ:E@ü± QÎúø&ÖbÐÊMWT¹Ç:�kqó£8¡ O °cµÌ§m·6Ógwu3ãpF/"B;þQº÷9ÙV)J“E›"Ž1%úú>'ÂòîêFóÅ¥Q1œ1Ê ¬µÓ(UÇ÷‰Nºÿ~d^U’¥æ¿‰ì&–‡>asõÄ&CÓX6?àeJ¹v3­Æœ³Ø‹‘$ûqz÷ž¹´PÎÆ2XÍК¯-yNÂŽ+÷EIF_gºì%«½ôL†ùƒî9%žkOk¶:Ýl=Jg3š¦ïjZžhpdq¼XxÜýVPú­‘Œ?äá8q ‘ÊÜðÓ0^§Õ—¦}÷ÿIe„:FAï*ÑfÐÏÏeÒ¦þÖV™Øp,ª™ªKÕF¿AÅ¡S€Å®ÍhW”4Õ¶ÑÄÛö0 9:$¬p‘fC7vº¹jEdÑÂ&“#7'GΡЛ»!Ã컧«H[.ò´+X—;*Aá`ø WÖMÓ]|(Ð{kÏ3ºÆ-)–%AòãÉa5§Y>¤ŒR]×Ä»|–ž‡Ž^sZr¡Skz)†ŸT›°‚¦Sg�oE”¹í%ŸâÆ|nÁÎ<SùŒ‰��Ç“Ï3ÞL•É~'�^ä>"ëà/E ²#ñÇSõæz¯tÝc­Õ›k¸è–AI¶+‚èbÕ4¹¹\ïzPóô®<i]ùÉ“ÃÏkzªÅh¡Œ*¬Ž£V; ýÕ—ÇåÝ?b_µL:)âáld¬Ñ™aÓr‹"7iæ”Ñ(/2¯âÃêÀ®/¬¾N„scúºôŽÔ»ïú/iÐÞE%E¹g,Í©PGõ^¯úf9œª4æúœË¤ôÕH-ö0cÜ|ÛÙƒ×úBÅÒ8† '•T)B£Äþê~!î¸"9›‡oA¾±Mlt ™/Ï>)Ý@eKé½üÁ)™„ùœ„ù,-‘b«qªäF5k4rapÞµÝá(~á·Êa/ ,qSÌâ1½(ìˆð£Ü1´w'ø£øöÂô"°\\~TV«Œµ ÿÌö`±¹xokÚ.ŸŸ–•TßÊN·µüÛ =%ÓÒ?ÓñRù‹·0°¦à id?ènN=ÌÏT<áM]…(Ig@bTÁéî²{Oä„èûÖ_ÝCAðçâàIî”HE}ØÐÚNzÅ›àPl/_­®õg>ú×'‰}wâ¦:çÖ,cé‘Ž¾Ò]»&_¹` ÆË––ªo¨÷Ä[϶bñÅIàmB5•pÀö¢Çú;tÒLÝ+c“h±~@QéJFuÊúÁÉ K‡Çeÿýˆ3îã¬ÔÉ™t> J¾MìqyÇdØQ#¶´¥ÃŽ"!7²/Ì&‘ºz½Vß4Rg‚‹XÀ’ŽNí‹7´w&µV7®±y¤ »5f×båxïb90ÊS;ÁÀ>Ž9€üƈD(w¼²_C<+fß ÞÑÏß½C‹Ñ'úC«u‚6·èùÓ¦ÐÔYM}7[›ÔPþö§3 ®¨TÕ6ÅàbsÊ‚ð[í'™YŠî‡7Ǿ”öL‰*eÛ~Ê�Š\#*õ ýì·:$TÚx ¢'F;Ê"=ï^Zòzîm†àØãö8Á}Ì4Š ¥Þ¶ÑÄ pþãŒsðl$ʇªA‚yÌè ö½RãÌF*Wí_«9yª_¬?ÐÝìs[Û™´hÀ‘üôà‹¼$‚•W!ˆØgôé-Á‰ÞÄW²`­ÓvÐ’·!#Aº¢2%ýßÓ½„äó­¥¼=9*³¯W3LF[A§fšì!Æz?Ý©†%3¯Õ:)ƒèøm²ª‚~{Y¯Aë8âvÒ»Çð߈6Õ|9Ò£hßö÷Éœ·4ïy~÷¾…RPÈüö\ÈLSýå�ËJÈÜHŒEW‹÷Ǿiúf~i°maò3zTbÓ|³ßž „^Â#{*$ÃÉû¬”oÌù`SQZæÂý wkÝ SMZ4»#°cïs 9fRtã€Ùî¦é±öeì5¥¼e·Øí§&3)Ãì|“í÷ ˆ:h³NPgHoGŸ–ÓU£3GŒråŒöób$lFF»‹+É òfšt,¸½‚QAY+ÅlZ;+eÖáÀ$4{q‚¡É´p6ŒÓÔÉ€r²5nbQˆé{ýAøIùÈJÓ:?P04.(½2åž22ïZúÓl¸àw¼â8µh!qi‡·O\=~næ²þ³>boÐ{ŽPÅ¡Õ„ôLÄV"5ÍüfÈ+õ÷Ô'zBÊv·ÍÔj:&¨P š3Ao(î ®p¢0Êœ7 .š¾Êñp¾LªÍä _atCÆ2Î Ö Ì¶ÜíÎÆèiùr›¤WÊttr”tdwÎtü¸ûê$P)ê-ïf+GF/q»¡çdGz<št9âôiáû¦Þp/° ´Ìû¸ËÞó…¦#'ËÚ@x!P™Ç>ÿ#¬–bkyRrÜê(‚Εòw²G…®=«Z2 %c+¥bAZdjý€÷(Ó°sèÜ×£…h=à#¹¨"À qƒ)ûZõ5Kz†á°›É»»Z„‹ŸŠ¦/ˆnÜz^ò š•OMwɈµ‰#˜,ÈÕa쉤E6ûzX‚Ê”ÙÚãEãQ×cû·ÚÐ5Ó¾ý¬÷?RzoN!7'::3;ä. ›äÉ¡Ö£Þ½ïR2Rës¦sÒÌsDgô÷t íUŽ­G/ié÷Û-ÐEù8Ô_/»þîÀWÌND¿õzŒpˆn! ê¬gÞ ¯o(ùïîJx -2®$UŸ f:NÆèg¤ 2¿G¨J3ŸÍIëæ\ùiãeD,"Æd´ClâÔ¼¥KÅb "WýÄ­%5#v†C矺îqƒ>ëÕ¡ù6‚ù+oépE”½Hą̂Õu³Oì¦j`¯¶7buìñŠôJdíˆþEU¯yóŽQ<xÆh~~ì&Ž¼7?þ¡¸´œy–ÕÛ‚f}w~ö…1§T7Š>èÔëëÓBÁúVÛÛ“£¡Ñ·˜½Nছv“¼0JÍ\åÁʱ«mIhÑú¿[yœw–ü8Q†$4(žµÜKibw¼¢³[» -›Y‘jÐÝÔtZõÞˆ[ƒ¾P}ljµ{â.™?)Ð…QšÞ{†9ŸþþE{tÜ1±›rc§(ÓkmÃ(+Ò…`uH{ªŒÄ øÞK—ÏÄhX�zaeì™mKJ—Rêž«§vA,×ï]¯Ut²²½Ã‰ëq…`ÓSlÐqxÍ%L Wb°­É<P®;o=ŒŠéÆ[XÖx»²`>™Öê–ÞülªÉ2óµ8éX=OÕ‚WÚRúpµé»M'•‹dv×À�Àú‘€©‰¼ßIwo}© :°j¶š7{hB„‚뤦*¼d"f5=æIk0Éiº¦“äLZ›Ú0q=ï*«¯ñô?b„é;áÿad”¿âz0eo‘~à袇!°¹¨´á†òÿÐÖú‹r?ÿþ暇™» ‹Ýï¾Ø{´Ö¶dª 0Þ©ÏÞpœ çîb¶ö.¬Õ/eK6{é V¤}»ÊŸ½Ó>ê¡•zùó¬Ë¹Ìý9%‚Øñ´vËBÆ¿.¥ü_ÔÜÍ«xuZ¯~„�¯]l#LÐÇ=Í÷:]V5ÛÕêAæ¸Ì {è5’¾|?½-TkÊN ËŒ½7@añ#§å°hu›®e‡ÛîGû™ÒPhžfõÙÓüf¢æÞ&‰Ðx1¥ ûk#óÕ6‘óÌ@ÊÞTiÓx4ºÕˆbÕý3µÔ÷JùÉÉ4yÃÓºß×N’›*$3¿Ú¢zWÐ"JC_pŠŽ‚ìíóF™™hp-´Ð ìƒöðb=1¡±Sh¯Tµ BŽVÎ9ÌkÌëÝÈt:îfŒëha³É†œÏt’¿BVËl¤‰¯íÚ{r›ºíL�,ê•fÈ»"e’yä[DŸš‚Ïh'îIàk$Ÿwœ0�/Ä"¥ ©šÐGà…Ŭ‚¸×)'…qA_h÷P4dk^¶²äTó¶å‡~Iûµ™N®Ë·gÛ G¨‹·ÿ¥€z¤ó ºyâl«Ê;CÒ÷‚N¶Ç¥Õ#~W˜8ϯ°«‘âÊ0¨$.ìõŒiîȽcuN}Y™Ý-n.sù8Šô‚ölJéxë” @Cªûú²Ü²Ü¡ºË‹ãl)�;né€~|w$z;DZÄ–õ§{ÇßÔçéq1Èh‰¸ÕÀÇgÚƒ-�oâ'ÊŸ]p ˆ UGÀ¦-òíÁ¹ê=‰Gÿ)CǽÊÄ7ˆ µ‹§•²†*{Y‰íÈ÷ã©°Lœe~|¡ûÚÎôfÖ’ ót«t´‚m¬r†Ð*ìÆ™$ôà;¬»~< ¿¿]›n$=®Æð1Êdiã¦;a¢¸ôqí+•RbÒ*ñê'eû«d#’«` hoí¦­=/ÕítsýÈ´AŽ}¤ƒf‚ÀÚ)ÖÌÎé'N´żâbÕ’ ¡õžÿz#àÍi04>mX¼ãùºô­<^ ƒ.ÆXµÏÜ©ž¶œG8ÏÄ¥ÊÛ?Ð}K’…*X:DgmT7f¬øF|0v›Öê3þÂÞ!OÝŸã±ÕúByæqöŠìŽÂPVqfeÐ¥æõ½+“CyÔP”z”XöZ›E¨kÖãÒ¹"@k¢Ù£Ž¯ˆÅ¡ÉYEÚæçbn ØõvãfS§¿­fc}‹5ÉY­sð†”cG•?ú²ê¶#ãŽ?ÔÇ Üÿ-à%¡׾ν•+þtŽ;‘¡—Ê×®¿£¬öBåB>h¿[ƒ0fGïý…ÚaV˜$;3*ë<þÒ~c0ŒV w®íy‹ž²4}e© g^„‹Ô1èÍ$pŸY¯òSQžŠÁ‹¯¹$•"ªTFwQÔEk ­µ½tG¼ËîŽX‘1ä†?l÷7ÃÄDåub 6N„ó`}m^ƒ!Êp±CäÖl1.Û¾·Ûè×pK°bÿ)c¶á°uòÚ\û8?ówG¨qäñpαäªùëW‹ó¾\²mÆ(kJÑR³b¬˜;"#‘4™¯VPX²†½Òü‘Nj.̧Aé´oU^6—?tRùºûÞ{¯løC)2NqÛ€ì€>5ÖjÀUB´�ûîù9:0xnà @—fƒBËcAžwôY™„Îbh(ßÜS¥eÛ¿ ‡â/Ñ°ÐuÔ‘â|\ÅÄ@´[J‹~zÏÚ`¤Ùð^{™àsïcÚÐÏ>)okúˆ•¶é/«-§î,FlÇ´e0~´¥Çç‰a­,_î2_Ù õ/Ý­ã+ªŽ—ÃÎpÐd|Ïã¬hæ°Ùg)YX`1eöœfZu«]¯7Â}F#‚>¢ÑìpWwH©9»âÐ@EöRZw&¶y½ú4Õ'ýt0ò ¿ÙTežÈ®±¦©Ú×ÐéÚb:“¤¶‹“1‰bM‰UÕ´žz×îðõÆvŠØèUFtp±X¯o^=S÷ܶmîá!÷`ˆ6œqzÄi•»}×ÔÕwè®ÕBo#Ü,(-ê¼yb&Çy>½­¶Hn&ÂíT”¡op1-ùjpêW]sy[Šs1xfÛÞCŸù§•±L…´ØÁ Ý7•¢\¹,Ïÿ׳ß0N)LUªZXATÁy¤5i…–™¹ã¬œŽÊ¶ñê £S}î\9önê:3G¡ %›Ñ·Õ=Äⵌ°Ü™%Hôõi Ù6 NFfNOgJW¢Í`åÝ&«ÂŒ#» SœFÙ0•ƒ!Ñá¾¥44oOžé`CyÜÎð:,Ó…*;X§‡ÕëË7b&C–¼§´pê’ :5K9|^*…¶ìööÝy7ÝwYȼVP.€nJŸ›‹5Nç2@7_¸Ÿ³ÝKßçQ$ºî‡VËKJ£qr> ™F`xšÄ–ŠÍ£z´ñjºÅß6ûoõoô1ß;GÊ«Ô©¦Ê7¬@É'ÑD~v¾¨Þùê[ýÕ¶ž oýZT8qI8Ô`ÅEäûÇÉZ{^1Œ�œ<‘;&!FYÁ蛄>Ÿ ¦±M*”ò{Ð)ÞõŒ’2DŽ»D¶D}ñª`œq§†G 5¸¬qhbÙí0û…»Tv-õÐý$€Qû¬wVãØ U𹉛êUFd`ØäF“52¹o{hD.Ì*Ù†¿6)žÿ • cç6…\,ŠÆ¶}¶Ý ] 3²4°:Y¶0‚òSïsm5EIx¤©W…sÞ:nè&e½Þ¤Œ'JÐx2ï””gA5/&1^“t]ÓcF7˜f^œ"±Ðî>°¾‰y¹ŸxKr ø9ÖLi·iÕê& #áѬNƸTPéq�6ų±gx¯<N}@z ªAƒyî4¾ì*yŽß Xˆ_±ÜâdQ""Û„KvúñWl0Ï(š÷ÅÊ0ÓTG<—ÐÂ/±Cº4Ä4Gžwpü^Ž&˜Â*PqѪÖÊ­ºÏ%Ð Ùý5å=-34E%aSPÌÜ*á-cba=÷ƒ–’…F§!óЦ¾¹¸Ö5ô9…)žl³…H¦:£¦‰–XÍÍÅjÙ$´ó{™ÕäíÀ¸(¿˜]»8_µ3¨-‡ }¹¿ø«ÌS\n¶ ¿ŸŽ^ k3 ³úGã˜Ò$4‹¦‹Ÿ²"tÇC”[}˜UáI%x¸{�—˜é$ßÛ»ô:–‘&ÌÒˆ?µ“ƒ„RÈú)}‚†€£,#ãî/Q{,ÎR\ à|ñJpºwß'£mÒõJ�1Ë}Þ>´"p?T|vÎùòÕÙ Äý[ðèÆÄIåO’(ô¶ \‡V_±­Ç?»Õ2«7¾ñ¿UÍà™ŒVÄV“M ¡ìMË´¿X*Óì}–):¼©é“©J¼"P ´±ìlLïþ·¦U·³æÂ&01Œ‡§+wFV‘s—gÁ6òîzs¦@tÇ#öƒUvšîJîÕ3c 8)2?3Ë‚i‚æ@ãDâ-—‡¥ÕVõð‡–¾A¥î¤pd\Bš,<#A»¡ŠÕÚÕ# Ò Z`s8¹4ýwCŽ$Ž}A†¸b ·ÜšîéÌþ°UÇôß„}öÏb›ŸäîOÝ_W /dÜŠ"½BU59}©šIÂt¦•ÌÉ¢¥MuÈ$r}Þå­Žž'Ö¸AG¹ý6!]_|fK+º’æº/Ñ•þ°§É@+®,&‹c†g~5KLøV†/]·ðÀvõh¼Ràüô(ê3}–Ö5r˜VÁ½Üîc¨ÿÞýÕŒÆR][Iè”^y¹B}.9vžŽHCÛT;ù·ºsèÊÌ/ÇKüSÕZy‡À²öõB¸¢åŒ}þ€|\Dv˜‚C‚̼ ’YËñ’9'½:¶5T„ˆp˵µL.1ÕõTtÚ?€ž áe2”ÒŠJÐãSÈ“wýHtÔJFrÓ…¯¶Ë�"±Ømô)zZˆNsŠ§/pñš¨Î[L{¬Ú’e‹yÝ¿èÓ¦Æ)nûŸŽ<DÜñ•à_¦’\™ZÜÖôN?ZÂf\_ugx]6xW£‹}eÝ”;3¶8q  ù(­£2þ2y2÷ýat€­õ©=¢g6æYVX’(wèç5­†öÇ7O»ýAµ¥tÄ­úGÕÜGôsœÚ¥i÷Ú×æíëD‹·‡¡c@†9 n^!¯Zƒwãg$cbÓ|_<yùS©­”®_]umD°’`ÓC‚þìQ€ØÁÙ™\º^ÕËËÛÒB(õð¿ƒËcÿãR�–Íåõ Ö!zåŠsÜ­êËýá™Z¸TÆ®„¥âyr'(4ìÜh´Z¿ð…æ¿t"üà蹊ó�w,=Äø÷ê{íE&–TæÎŽ›èÿºg D_ÏF©¡t7;«Rõ\ÚäFwÖŒ3‘¶;*çÜÅÍ‘§R„]�ØMr»±£Lô:÷Žý vRƾ€½×¦ÏhÖ?Þ<÷‹6Gg+R8B+¡ëÜ9Û˹;u”;|ÕbÁC§;>m¨^™tÿ Œ|žŽ;ÜF>è…ò_oî_]·¬â0qs æ‚H•tJjj|ØÃèîõ{ԩأУ[QD¦ÍYžw4¬ îZYZå>‹ñA…Œ·Ò<¦þ©Båì Ú ´–íP‹•jHîñ¨}Û(ž oO”‚º\Æò3çhñï=€³…'V¥¿Š²¡³º+>$Zºó÷½ÎDô‰.ljH±-´HÂã_¯KMOÓ³f]‡ä“ÄjQ®_ï¢,œ*ÌV5Ä°:­œA1±ÉÈVp>Ê,Jºó°A“<ú(2VïËHº©,?RåÚzª†,Ž~ÆÉPÍ8ÉE/OŽÏÇj$Ej%„òx„±E<ë{g×3tß.Ó¯å-'I&Ip« œ6^?|õõiDÏ-hÇÃNÄÝÕù²Ú ìüfÚ‘Vi‘™£DLÃéÀÊ6éB,Nk“zIZtòž5ô¬uI$˜mX °Ç_ë’<Úm}æž eXýÂHjïŒ5"ÏŽ11j2ó@·¼´0=�¶;¸¬t†n þq`‹ýÀÓܶ:[RðÁÄߪÎÿá ¿ûïØ\…å,ÕVŸlšûzc•±Û²¥ø‚Ñט-´„qà®ÿ#S,ÃÑÆ0CÝ®~ºC¨²\§°2Óõ#­œêd7!’ÑËì.Ÿ £GJo¶3ŒÆC¶3q¸18Fý¼´f÷Úù´ ÔT¥Ü‹×É°MÛDó}Ws“Ú!ïDy‚³/ñ€i;j×÷R<·STò!c#2KcGB0žæ=lDe…wJ£çü5Axé}I³A½öø3ªG”eà=ïP7XBÑŽ:X°§AòmL¹²B ¬P‚Ìrv5+B7^ E†²}6Ns£óMU¾7ª}ØK ÅÔÆ8}åÜ“J )Ê-Sà+†úŽ,:{õ`”…¾‹1nô ¦Æcö”ÂG‘]oœ\ûþ )�Wžô0¹·Ø„ý›Ù>! YE½›“Š¼.¤ìmGçå/i©Dn,iÈõŸ=ÇúŸÌ—éÃs^XmwC'¹¿é:—ÕÐð¦–M8Ìê•Jž)¬[Gq‘%Øá¿WÙ½ûÂm™“™Ouö³×V™xQ_w¦/ý;’Ô[§L@ngÆ}{PWƒØ𣠂V!x”_ou&hÁ„Á^u䓺‰2E§ëûÅþÕ€8[ø¬²~äag'qÏ]çɾé]ñ¶;¿»¿I=îOl0“È>u&V¹ˆÙá+—ÚoÌ$ž)2ö€‡ªº‹±ö*õÚ³Ræ½Ô…‡ñ”᦭ü KÇ¿fr()€Jå-ûml:uy–‡é é.®Î¾‘' ô¶Gº=§o[ǃ÷·dÞ%îd O(=G\mטš;ÃM=ÏŠ•ñ?AÇyâgSè¢×”å[)V<Œƒ?N”AÀcwk%£ 3VªLï{ÕÒæì7æî3OR‡­Ú‡Žöjvl=•$¾óì9¬$%þ¿Úh»aiY5·˜ÝÙ1ÐíhñÄ&%1‰›|G>áõm·r™±¡•ÝßUõ÷¾ ˜wv²Nù×h'À3Mçõ´ø}k§ˆÀO›1Šï“Ã(b}¬w«iëMzùðc§±³cgf÷jMiNÚ]í >+'=²¹æñе—q»;s¶³½ŒvÚõ®ñ#z ©•ƒNPÄx÷t²Vé C•¶p¬Ï=”^AÞcº‹b#t·­éÀœ49?Î5ƒ–ÁÏøƒuÂáTbÊõñ„<ü¨¾¬wyZ¥gŽÌPýf `åQÛ�ðl˜.H×d¹ ‘éÿz$ÞÜ„ý)¡½4YäwÂmW¨íº#Æ¢o*vûº…9Ê@*5i¥7ÇgpQ‘WIïosh½ýø›²3*<¤i,þVUnlÜ̦ÔãäÔ¤š®3öÝïô„^xÉ�ËBïA…‛YpGºA ÀÁ»@Ù<¼z «%…*¤…§·ã+Î)“ï!£/ñLôx°ÒÓ­(¬ÞC?ö]al÷–¯OQ,TR£�Ýôøí‰i‚_ÙyªËoÃy#Ai-ånCï_N?f(O>MšOEùÇÿ>R#y§ÌIÝ/ðHÆ©áMÇ«Kjœº TfÓÅ"Hmõ>&¶·,4ãüÝ1‰ƒ¢<$èŒAzïZSPgþèÚýi`-1½P%GäÅ¢JÂ|²¾i­<è’Þz2£¬·4}-éˆe'Cö ¨‚º glVÏÃÑØ°ºzB€áÎ×›ª{¹³êx…EO C’Áù þnøªtÐG „ÀÂå=X¯–¹ÂM¤¯xÄgßÜnˆ÷O¸øQ˜ZãSÑ º2H¨ø—L!gÃ2n¶ÈdñwZYŽÊ`þ±§¿‘~þuzû=xXÍxì0©\ÓôÕ©“cŽ;®“'IæÞtc¡ ’ÕʚǬr+R•F!Ëoê>,Õãh1;/ÄÓ,EØ& Ù¤·í®AÏö£%RG&=L.}<M-ŒgÞk–»¶‹šÑ-X\¿òáÛÂiè–Ú0ùIP.*•5ë»!¤“¨ÅAéDŒcºïÐÉ@ÎÁK1ÜtZîi`aè{“âž!üž,s ^õyòæ‚¿qHŠd¼y`3Þkæ…ì…ÓlwÜ Šô»át/LÖqû+{qgC (­Ì==âÂêýÁ—º­-rBð\ ÒÕü­†¼AºÞ8à3¼ Û\²Ut x‚÷+Û?§s!mt‘#‘Uô§>–œ¦Ó ó¯Cý5yW¦ƒ\TWýÜn(ƒÒZ\ZÊÌn ©¢õÂ…[þÔ0É)×UgjÉb2ÉKéÖ‚o7iâDãÛÿípß¹¯ ˜U7vín³C”q—ÑDhAÚŒ ±a Ã¹´Æ;Œ»•]hª( RÍeñï=í¤TQ_¡©¼‡å¬XfÖ”*Ñ¡lÄ=!Íq˜hÇp”;Á#Ãb fÞÑ¡ÚY[f#QÓrA5 fĦèõ/˜jwx‘ÖÙanlƒL£’“Rç ÞMÝÞçFžÕškqññ@ù0qša +iOt3òþè¡Ù¯.®ìëæò†‡ÇST[u±eGU”j[ô|l[uø„bŽõ{ÝS©9o½«ÇºYºˆ¥aet”Zm¦á{u¬DãKÐþ½$**ƒ³`ØQ¾µ›�Ý"V9w s× ‡ ¤´¸’vœò ™­¡$Ú!ÜM„9—øÞ©ßžTrù"P�’‹–H:^u³ƒ$Tù {–cå ›JOMÆ’*öÑîôÙuœD¾æ1 »~ãòÁe*¡l<q¥‘ßæaîOŠcT\¡§ž£ßU×ê:xYhÅZ—,úX6:ýÈÂz™hrß 1Ê(ÕÝþâ �©N‹Cåøm@Ö´:)á'O•»€SäXà ¯*L-~x,;ÅR“v´C €j— üÞz‚{Bé•ï¦º<ׯ®dIÊ…ŽUL&˜Öpw‹µ„¹ˆÇ®§½ŽMÄ÷oöp˜Býæ¯AÕFVk¨aµÅЇÿâÙnxîÚe‰à›Ñêbñ@'t¹Þº¨>í8‘4 ž÷T¬ã´ò›‘Ïú¢õÓ¦zò ´N=üñlÒßT%:y•t¢SyV™ÒˆƒÜàÚu“á¯Ý—k^ PélÐ-{Õ¥£$”åêm„£|‘gÓ¬yö>ßd#èI¢;MG½1‘8äA»Í‚òÓ:°öW7¡ßãÔ‰G½‰¬ïaåQWöŽN^ç4€zmÞÞt®_5°£Â4á‡z ü½øQ›[Œg±?0£z.¼>Ú*ÖŒ*/®ñæÉH·˜:¦ÍÙ-ñóŽÆ>íÀþ¿Î œ@óšÓË÷ÍCœÅ­4 p5³ë.x+ u—_XÁx…¢(H¹4…vðp£þXõõ‘;v÷“nêúx*h£$ÛO·9é>L옣“n:Úñ¾y.^E^&Á$Ðy¤¢OåóPøÔô_zž’¸,$=|AÃÍ¡»?Gl¦­@Q{ºŸû¹qQffîT§ž3WÊZ @Ú/ ã÷=Š(ó»ÓàÜfA8÷žæ;Ä™ƒ…M•XwÖ‘×?Î[zp*·}Ã!õiž §ž€`OÕV೑2dt33)<Ó°÷«%KsÒ½cA_kíTJ¶‡£?ÅCFy™-Ø0Ròm!UQ+.wõõZp5tóo)ï§d¥^ßnuÀí•öFÖÜlY³Ù„<q÷¹ïý‘xšûž¾´é¦™ži¸Ö²x0«)o]¥$~|qÓ«0–Áüe‚¤ÓX‡ךŽLÖ¶À¬Œ¢ýHKÍoGÊä=ºUûÔØûDLm]˜è˜z6w¿h&¡ú2¨·#E%zÃÉ)·}u,ƒ,w z›<†qÇIî ว#òóì Cûúâ%k“¸~½ûymÆ b*†èÚ5:僼cm@]1oƒã â. ‹vê@«­àXœ¯¬lÖ/õXãÔ®X’‡-é7¹éÊi”nwÀºëË«¹}—¡7¨¤}:ƒ‚“~ON`ÀÈ&~ ¤8è%áNë+7N"Oü&2£‰a„+ç§5ÂÎ;üå…0‚FþºÞÍÛçª~å¢ÓÃn­™)ŽÙó…n!övýÅ ×–c²›©Yì»êDXàç–îJ¼µš_“l(©¹L¦Ïל¨Z¼è â8Û¨ÜÚ:ç®ïƒýÉÎw`Ñ}ÚÉSAv?Ðgä¯éþܹïM·žÇÿð ­Ø¹cS8yÇßÎÿc¯+ÎSN©Ç÷ïà+¶Ž5Tŧ-½-E3– rW·µtê™J‰Û@ËrÔGÛußž†þ2 O®túæ»É€¸¦sÝò6°ÀsnjPáè'ÈW?zÜÒ˜6P¢ ·“§QªÖ-£ Œwh[§Ï|*J­6}–Ð7Úz6*pcÒœ)¥ À»¼Íó+m¥<0KÙâ+”d˜ËmÚ-Ü‘ ¶1?å×>_&º6I°¥l ízÐÀüOÓäRó1ôÈ;·ú—?ùÙMb‰( …Oûà`뙿ÎëW”$N/²Î$ôt=FßÔ-l�04=<oUÈ8©ºÞ¬œ_%ÇàÔñômœÏ8²ðE4! ÎƶtdÜíóDj&/“-TŠÁÀ*;î»UrÓ,üÑ+¢íŠšÏ¡OƒÌèǼ ÷Ü‹×G¸„“=C•¹Û=‘'¨bW[}vt¦î/#e—vÌ;sy‘XÃ=¥ˆŠý+q$”ã“>JÄÊÕX7Ø ÿ†p\¹ƒV 1SÙX=|ˆŠÑ‘dðoû¨ä‹ÌyëœÒJ<y%9‰"zª%â¿’[N\CJâΪ¦˜–Ûºã»ußí—ç^.ö⣨œV/ÖUM/­ÛªìàºÎ'öJû'bª¡“Š…²g4 ¾sçMøn_lxkk*Î}aâæ„ óì·Èǯ›!ªßAOŒv}\Áê°ß³&û4Q 3=*]6!cª(8SÒùY[¼úÇÿ>Ð)Ü T¢ìŠÜßtn)~$4zÍ@ùa2†´šã4kÂöÛºš7bß!¨.™Ó‘4awï>f)˜tò¾òÄa(|šù=pO~BåžAÒwÖ•#òÁâEúž{Fšú:Ć'ZFÕZé¶8Ú-nH†a`Ýða&F& àmY]Â÷«®Ö/áýlžl¦0fËÂ|áýw4øcÕ7ŽCS¬öv•ˆ�Yn¬QÉ(ç^PÎx±Ñȃú B1§lUæAp[Óf ô6éhë¦o³û¬ì$òà6"¿¥uZW‘,P'™Ã>Ñ=sTRb¦p(ÁdȦP',Çóp£3t‡yz ‹óí~Ø„ (û­…^¼ Þ6£é‘²Äàæ}Ѿ2L³Ì1Li¯S dGc Oį]‘5mbö@S^ pÿÌÔ»¯Ý /(†ª…¶Z„]ׄ[3Öbã¨ó9«`/n_–;·Åœ+¸ ÎŽó_U‘ çGŸ3ÑŸÛžV_:ntçÔ ŠÜ]Ï81ËSîe:`@‡BçxPì?ímoÍÏ–?á<æŽìõ)ª…ºOŒ ‹þÂqò@x«ÓÌæ dñ„vûõ¾“ZW¤©ýü‚=šÐ4 ‹l0\sž+˜(»e¥J¼Ÿßm{àºf"㧮è*ö‡õ2ASL XÜô§î{wÑñ8áÁ‡ÐGFm#ÈjmÆšˆ‡,oÚÑÎùïGTÁ3ÛºìÉá :ƒ¿uN¯÷Ý"Î/TTDƒNA¢ÐÃDczjb¡wi2…âUìb>Ïâ g”­k~ÿ˜{%ã¥c!Z¹s¿œøF±{:âÉF!‰êÅaÔ¼$bâV¨P—öò÷Ðè Zf05×á¨pÇ;~œ[ê'7U‘öø±n[Û0=Ëpýæõj’`Hn’Ðj³ÙÖ‰ˆ�4wêûZd"4žšÞÄ®m£ÊýH5ù8²É^�”^qš1 ²NÑy° àÄ(åU²´ ~ðV¦¾SyíÇ(þT!u¡u!>ði!áa¾¢ a ¼ßZè”…ÏÆ<­¢8v]ט+q‘·¥sãt!’Pú•A¼¶¸=&k Dëpb{ÚlèèåöÆêP÷BýE£Ã—°c®“ã~DÛX(E{Á–ÿE‰èŽ}̽ÙÊBW•ÎÎa`ˆä×6á’O!/c}äfÃWÑ?ÎA®yƒºt¶¹HÍ3�îh)÷ŠiŠ¸Ù1@²ÞÕOu±R2îú¹ìm¤æÈÚGyÕv,'áÂ.Ã&=õØÈMK åãbœ#Må£ÿ‚i¿Gƒæ‘Ëijwöz¦›C{è[;&ïNè÷èŸö¾}‹P:{ú3É‚û…Q‹°ªõ-ÆýÚ=q¤öˆ‘~ÍHÁªî+åë2Ô“§*`vôã­r6Qb¤^ÑdINVX+ÕÊμÐf.½š5Až$Í“²"–ñ¿›ù¸™ÆØÄb@Jç ¿uBgŸžÄ<å8FL6ßv=¦tG †;'Ú÷Z½Ïç;²ÞÈá‡þrÔ5‘õyÿÆ°aH•ï ™û“¡�E¿*ÌK ÌÂÆ;GG®ÿBaãQ ±Ôz¿]°FÿÉÊÐwb”NJ«z6q1,ý2úßÆ<% p–î¬o+$M‘dÂCüÅ/Š¼•ÀÓÿî‡@ÕêpbÚíûÚ ÄõÇd0ÀÉ@{‡…ì;ôq'>˜bHèv tÊ'GS/K Ö¦ÏZäÖâZø*´–ÏE|«<o&®¼ï¿å…Ié A3ŠöÜBO{l€üÙØ®i,^bØËŸ='v¤>`›>fâ“ÔBàÛPôçAùü"’‚uû}BÍãM^V™§O”Ð!¥@ò­3‘ÜxöÉ7ê/ÆýÊ»z 5Sx}ñÌ׋ÏI§‰•±1Žf:îªyý<E±§QœyòÈaдePkÛ»Ká1š¤Ò†Ô×Óˆ$u „„EIkÚáV½¢ñÆ‚ý±n”󼜜îò Öj²I{œüž©MëY¯ºžRaÓ·‡i¾P.õí³Ç¯^UÂOÍî!& o‰fmHØh¨Ì�X¦h9ß…Û SÆYÁöÐ(± #ˆ½žô¦ÕgBAÌè;ÿ|lê3ÛÄÚ¥ìVVzˆhA^£c·û‰q>*T }Ènl­Ø¯ ü‡éÜu_h¨2“àr‹p­xyn¨Xs]Э];–6ÌaÚÕVNÑæïáÂÈ+²fæ©¥ aåÚÕ#´h›Ë½y67Ðpºs¶[¯QU£“°ƒå‘Yª… ì,íu›Ð-ßþ…f^fžŒ~7‹v¸Ê7æÿÕ1õ°X‘øvRËŽµõ£/ôëEgŽ³û—¶€YâV';²AÁ¦h=÷ºÚî-Ä_«Ô¤züe<›OÑîBV¥òè¨÷lN Æ* Žª”ïNÖ£ { QŽ—-ô50ÛÚ}la}Îí¬) lÈ™äC\  M†9õ0¤­Í¬Sú Œ¢÷ùïG‚ŽE–ŸJ2�²Š*,Ÿ‹¯põ•“:Jì[+Vt÷×¾�AlºcÓž>Aß{¦0ì¿1;WU#ñþHé=«ë *bm¾€V1Z,uäæÌÀÈÿÊ$¹ ½=G"1à(¸Y;¡†Õ¡i¬ý.XÙ¦šð.'b‘ùp©2˜rÊ{Žßfî€Ñk”Z•Uøgì«ð> òEÑ8@ Ó3·JåÔö‡³O~‰x«B_LºVHªÚÁCo¯XO‚súö¢²h/ ?øBVy" mäÄJ£Í³;BÛj£¾ÈGôÒfÓ;JCÀ*RjëÿYn«ýšŽ§³e3ËÞK±f¢t}øÖPiÓnßõÐ3PÉ kh‚þègßtC6uIE“•÷ƒãür8¡|‘oÁhIóïK¹=¾BÝMÍ–*³FFéä;iÅiT¹ª—ùÏïÅßÓhQ¯%LxÃàC{TcëÌ"S®¥¡þ 莾Á…[°ãY7yÜâÌÓï‰>Õ¦f¨µ©ii-ð¸Å½>µ½b_ùóqºMéecâcÅ»™"N§À¹_T÷¦_/9t,ª´Ò {lPM@‘up¿§›0r–NôŽøÿ’9Í™Çi¦·–Úºõ&úgT{*Òø‚fsŠÌØïô}J›¯_;ÔD3^ªÕvýî° 'Õtíè.6çËе­}õÐ\… �-ƒÐ¢‡AŠ¤ѸÙ†©Ä0°\!A“Rݹ˜Ê�ŠÚ6Ò­ú²nÕi.²>eóû:Y3‘Ü’Îõ¤h¤…u¸²•‘g\A}×Í^ÛCÛ¾×ÎvŪL` r^f³ñ„ El½‰Tv]–çy75ºþæõqË|l$m†…Ãì9œoë D 7ûwЊȗ¶æ‘ä¿ ^§?EÆ$M¦ÞßBž¸š—Ç$¢xÁ9g)ðÃm^œ£46Žøó–ÆÔkÝ)Ï©É2:†MÄF\†zA•H«^Íi׳F²Ãægaw=¢9ûLv¢$ófƒÐÚ@—çä!]©väÕh™+oéÎF‹¾LÎm5ÝÙV¥>loÃ,{9J»a0ŸÑ–‘7œáÌC�Gh�¶Û*(ÆÆ3™ç#Ø®ÂzÅ<ymA,fºÖSѹ4 H<5B1—ÚôK�ä­˜Êãü ‰˜È³3a>cÖÖ ÷¾»écÂjú M™Uï,#ú$°¢¨ð·`"û' ‡®¥åäJù÷j~.([X¥AaÛ'LÝvøcª$[#ùØ.0úOäKBrߪCÕž <F‚2^›†ñaà‡q?hkª'×ëYB-õ7Þ~EÐwðøÀ6ttŒ:nr#ž»W^iš1ØԔ嗽„Põ±†…ºehÛhI:†¥Ë ‡ ãÜ)Ž“°ÊŠÔÜ'ÎèÏ0³º8CB=RÏÿuÿÆÿfÿý`F©ln)je€tÕU~dfyHR±%®‚= ˆ݇‹×úòO´R¸=5“„¾£Ã9>õ^2\ïæ/#á#¥ÍÖ*HRxø¶ÝLæ"eRK•„Ö"=§Ø:TDòÁ¡qGŸn€³^¬Ç›š9 ¯ læ‰âi4(+5‰Ü37í‰_“Ñï°Ó3¯¯ÆT¸†²Ñ0{´¨ÏzõåÕ)ÁØ0”Á¿ÚÞ¦âï÷ ’ÛQ…„£æðl/¦AIæ ›ÐF¦sŽj¦Zýþ†å¾£NCê\aq’·¢=Ïä{œ» £›Ñ苇É9ƒ~²t¬‰àõ¸fI–¾ë( É¿7½\–Q«¬È6-<± ²oZC[ëO'È6süsÐ/çå_+AsËyïú¡¯IÍQâ:g’çvCDŸ'›çVâ4ÇMsEøfùr `Úñ"£Íñm„pg/vH¡·¢Ê<ZÈÊu‚Žb¸ë?›ÝFyiC¬ˆ ¬/hæÚÀÁ¥ê/>·l‹þ“Å•õÔiÿ’¾ ‘˜ÁE{‘éBñk:´3}Âî3î®c%$fí|Íc­†1ªtw{´W…;]Ga¿ëÍàguh8ƒ“—;RÇQ|¢à΃–Íu­’:½åîO=lמŽãaxÝ› Ñ‹ +áÜ•Z…Èg2Eñ|ië`ÕKŒî ÿËOüc¦s˜ïü|.§‡#à:JÆ«Ééó¥ _è)‰ê‹=Q,ÔƧjØÙ#èì­×W§uã@¹ ðPãŒî¸OU¢“~JÁÍ™=àRsŠc ’—Ñ‹쌹ã¯-Üc_˜-²2 »¥³Ê1Ó¬•VW¯:&¼Ü…{ºÐbYÆhj39/Õ¶âS׌Ñ+樚ÌÎîÕbŸ0­£\hÔVa©ÀššvïÆdÖ2$¢R]$³Î¸„Râ L±’îû8w½I®Y@á s&.çg«IöOí¼Hð ;ÐwÖIÄwNxå¢U 2ڞ͘ÉV˜joëX´óòŽLi¤¢d)º<£ ¦³dŒë6»fr<�lvó×Ò°·J±aæÏØK裠¬·®Û³¶UÃËK6õ¶.È ˆýÛJÜt“TŘ˱§Ô©õt¥oÛ R‡:dQŒák /]o�|d\Ö.¡S9ì©Ô·†?8«håù6 \`Îój1·¿ñžpžZMYïã6ÊÉ*’$@Õ‹`ËpE}yÞkL­ü#Bðt§stÊùìÉ?Š Ã?"0øóAFÀbLdƒ¢úPHzÜÓ ýE+¼9í(žÀ¶NIþÕ¨Äö$¢Ðœ5Tƒç^Ç­ÊK=ÏæQÁ¡ 7óµ·§"$0›ÕBöÅ'ÙmÐqqÙET›Ü½tPŽ:ed|‡„Vq£0qÜÎ æc@ú2x kE»333ƒ™ëP•ªJûES²?!™[}sq ¾œacÏ€9)¸qAºûKMG5àÂçàuú±öĈWLm˜gƒÍŠ+CŸœÉE !OT"­´žœËà s‡ ÑÔ^¸ŠK7(Å3n» rJºdá£]w,Ô ·tîÁéÇÄgâÆiäõ"ävô°q°šÀñ²ï˜—¾ÅQˆ9UDv}´õy:Ètg=ÿ÷#AÞÓµ=«,�p®Û—ĈÇ'fQùú%!æ<´NªáÇK9e=«7"ý+6/ÞåR yAÏÏ 7'.%7ÄCZztˆY2šLžaeå„ì™2 s4ÏæYÒîkašó€(1ðø¤äZœ‰aG+¯û”9=lN”Á¿ŽÖuwôòvP3væ!¾¸òÅzSÃý<@ƒèlÕ¼ëçía_Û鶾p¿Áx©ÞüxãOSø6jÜn˜ÐìÏ»­S�3ðZøQ3yPîÓ ÐÛß t˨Æp)çnSÐU¢Š¹0wXÎÞà­z˜™ørn©F¯ŽŠXG{¯é¾:•L|sï+S2äzµ†åBÓ{ztXPªæP×Ø<-š_ã–>_[¬.ÎÒz½¾÷+ä¥Âƒg—ïòûâÍY´ˆBÌðÅÛàµÏwåQ¹¸ëÙv± .Éø1Ã$Æ{Æ£x[·mÇ$y.ì¹ï'¿K�XÚ–ªæêÜz„Š-}¨N ƒnåÚ5&¸ÔŠ›-tVÏkŠ.½6�Ù½øZŒ"°þeU”¡çèGÉÈæ„RùÇ1EVÛ03€¢ZÔ&îàö®l2•-Ä:áÇV'ôàþúefSÿEÓÎã¨8ëik¸‰èg–Êõ,Ä@›£ •ØPo×>©²¡ÿcç®k×0Ø+ùz]WžÛfÉö®@e?'[E« Ó»Ñ4-·Ý~bb%:½*Š*¯óÎFUÝ=Ⱦuä醽‡ôÀ»o•WYdkáŠÐýuÜO±–J¥î¥ö¥®p¢}YPÛá4 D¼s('ÙB‡9‡FK”ÝäTºZé%g ¢Ø“úªC„2Ê $;ñŒ2,˜¾£|k:L ‹-U>B=úÚ52-¤#Ú°[íp`ëäÆnÚÑ=§²ÇCN÷Êê°±1F©Èáú;ouÍÃÐ$0Ì0 =* œ»¦ÑHË^ c8'Ýtïj„G kûÚ±§ÆO>¶tš¼)ƒ$׳ò”üÊ¿t8ðCrÚWtk>;'GVFQ}7¯Œ5¬ÔøýZjç»ÎL—Æ …¡£ÏOëF ` q5VÒiüV:)|'MFPR9^Š&¹oè®ñìæWO©ò|‹+!±¦AUÞZcÔ«´;ߧ±Æ¶ínqŸS©imÌÒ+èùÕ§ÉS¾°6î¿r|/2·¢¹£:•QP J™Åìš»¡_ü¬*1{ö[”iîN^óia=\ûì*îž™àÝZ<ÔƒK¢,Îm†‹ 'ËþŠ¡¯<H|2„ç[³Ì[ÛÌ$/\}ÌR±Ó†bRSë|$<Šù­EóÔú<¡«ã мÒcrt—ÐÜ”ù; JŠÄ Q`¶(p5ÔëœQ‹j*aU5õE_|•ÂÊ$ÊS£òw < ×+Îb¤Š¨âaÀjÂܨ}ƒK]¹¤CªO‚â¤É…$æ+ú_a~0ðÞËG½xêôæŽøÅ¢®ûŠ2ŒÆLe#ÁÏ/†âZÏŠ;£Ñ—Ž¥{HeœÅñèEÊÖUS³kßkýÇig^EÃ�lzßqãPS·: ¾ òG=‹õ¶¡ºMuì—˜ògvHÔ„/*ߌૂdP5’Lµ¤Ù×Ò´9“ÚŒ;ÓC{¨ ’øÅcS¦ LÖºvÙÃH÷áÄ!-¾G=QZ b¾™7º0º)SRxx½L‡3³<‚ š—ÿLç"JâÌãBÓŸ:·ÜÿÑ]C‘p!åÉÚÔ*ª®²f/j(›d ÏL›’uÈ#©Œ)vvÎEøX·;.¶Ÿ‘lJOf‰ÇlýDµ<]<»$ì}·?Ðê9éØý|6[x@  „#dÌòïÎSÿX Þ•G:kAUÉý†s'ªí«„8‹|sΰ¢G7%ê­®y›fXç’K2ô®–J¥§ôÂR©€¡'¶Ã–Åñ¿qVÿº³jMFØ|†nùª¡4­ø±°6ZØY£.Xr>n†7O ´¦5W9]z&Ý_«,üCgïeN»‘U—m“¤¡êD™xÅÿ§OD,­ð„HûE¢Ã—õJhLÒ$0šZÿL‡¯ŠìˆX š-}—Z•C»~2Sd&:ª~ãúôjT‘º‚ç€Ù�§³GOÀy>9AX£S芻Å÷лIæ{4°³tŽ-n“µŒY[�YŒ¨/sO=&Yª&ÓAQP±mµë0GuÅŠ|¼sn/îHåÿ¶d·æŸßª˜^²äâ9(Ja>gî4Ò²4Íã̵0â`}¥Wd]V—ãxšœ¯Ø>sC –(ëKß^ƒË’¥3%TWZ©¥¿Í¥)N¡D¬Ð«Œeå�¦ÏÍÌ[°¡óÌÏ:Xy LÛþÇ»1]¿û[ƒÿÄY1­ðÍa60švå]=l#툮õèMx¾ Ì™Å.¬â;—T ºZ˜ãF¬úœ`IÝÂë…SÎ-Œ¡/Œ‡Ùè›_¼Ôb<xF0N0)ŸæÀ[ŽG3¤ŸÔ莓NHGaç³fµÑk¼”½7úî ¹'ØáëXµr.´ÓóO•l­\ØŠW‚.½/¸`9½Ä %uýpc çŠÑIUç Ä9! 2îŽùÃÊß9±êºóŽ]/îò®‰fÅk™ŽÇd(VŸÿz�±ÎKž V§¹ï‚#i»~«¿¥¾&ç)ÂÒÿ¿ÿÇíÁ4ÑîýîÆZ\,½¥¨ éE\&µþ¿«ƒ´ÌשAÔû5‘-òŒ‡ÐV‹©ð¦¥\öÖ£-©9mh»Ý#{ïNví…L‰»VâÙÂØ…êÏT@`{ÊØzÇ‚th1µÞÔJ)üÖØ_"»0rýÕBôtè©œIhÍ”œÉ8†Jî\<xRr•G C‚DrÙ²Ô5„#ƒýª‹D†Š®³Y‘ÿR')õÔ] vßF ™U³3‘Æ3_mEÐV0uŸwy�’+7MµcWŠ0ÖkYW´ù´WT"sZLÃØŸ3Ï ,æbÊâ ²ž°œC<ØySiô{q{² oI8dKN ×qŽ}Z« ú²î/8¢ú//Y@[Î9á/êúòGOŒÖÀ53J)^+öƒaü‡¡Þ¨ ñ´ãÞ1øºú vóÚ”÷ML‘R&•úV‹™úXü·môl™L§…OxZŠÆöå~b£$SÄíŽ熧'S×+¹êʬÖ3»DÉ ìT¤£Ú2ÇF²k_÷3ëêYMéÃ@ ‚v7MÙñ‰¶å±Ý4ï>ÿÖ(Ê°k<{Ý¿zµÒÒö2´X¨Ë3»ò̆˜ÜÚ”³?}=oþ`Ö!çª,‡Â¹U¤Í³Ì÷ͬ „Jásk¸e#ÄÝÕèÍ­Æy'Ž“šà¼AMâ̇jQ…=bèʬ¸à µ å·“OY™ª÷»–4GÆ#`JªÐ¡|az¼§ wH©cŠÖÒLoùÃh$D¼ ~Ä�W{˜ÈdÿìVt<îj[T>Æð©,†ÑÊÃŽ­VU…QÝãöKNÔ¹ñΕ9EQ]•ýTÖ zbôwªæÛSI¢„ýcs E£TÚÆåźÍn êñ4\뾆Fu#cùT:Ãï¿fû|vµŠÚ˜Qâ|8`#™ÙÊ;í)g,˜X1dA¾¾h›©•,vs#hs~ø£Å(òl©˜ÜÑsfzúö6ÖP™Šñƒß+yÐ1‰²ÂM2#eY°d¨|þÕxZíÀáWKãØ“$íðdîŸ[w§âC—¹0*’áçšÎ–þ¯w¶óln¡é “>œ]oûþ¥7™ê=䲶Iÿ3Ý O´ãƒmfƒu‡ÿ<¨±µ$¶à#«2²­ó é?=úÀÍ-D~gÈK¹!§VÍ@UyjK³Ä¬Àyˆ‚lR&EÉÎĽ©}”õÏlb“| B²ñí뎊ú¥àn» ƒJÀ$@ÛCk:&Hù'E¾`ƒPŸ×UXý¦$tý^OŠ´Lׯ/†ÿêÿø\—2*¯å¬O -¨°×é]œ¤œËTÄ ö,¬Ì|?4*Z€@ÂOÕ*Ì+§'(ßFðëÓ¤cƒ÷Ôš—º9€ü« ·»E̽7ÞߥNÊ"óòiºß«}QÅÒYÛ]Ldz&™èp˜E@îÉ\*¾òäjª ëuˆrD¤…¦úcÛ¡Ë£ºÏ6 ø—7CÆØÑN°é8VPŠØ×Z-f¢"F®ÇôH´Ê|£ ¹Ã�öQ˜ùFòa!ÍÞ¤ÿ1§^Æ8C‘6žßhô:&#¿%ÏÝRJ ¯Í¢&ðÜÊå!î3v­Y‰7Ô»Ø*öÅf]4eƒ2 é½02Ñ™…Š‚ôËÀ\ÄVºTüA(|~Ø'‰ £˜#“ƒ4ÞY+¸P¹Ý9+”)hþØÌ6S;xåƒÍ-$/¯e9½--:+Eo”(P†w`!o Ñúî4\`ç6 Šöl18‘C”šw馲®§Oƒ{éR(µÆI?iËœQ*,Xä0Ÿ%™™iÏN0à–¥ K… ?Ø’µ9âcã±5V+p ¨·T8"/!„ó*¦ÿR÷šf˜©‰‰2&Ú÷ŸkN”hïÅþ Øî«€H+}{„²¶m€±ÐÃ׎¥iU7¨Ñ¥…)løèí‡;ˆÞÌKc9ãì{zëd˜<GbÖk¼(˜¼kDçÇl‰¥\”†46ÀKµX×ÈpCqnÃSm°:ïWpAQÐõ#=,ôJ…Ê T)|4­³ð6Dy³’ŸµÐ#í;E¬ æɞΨNϨԪM{Ê}ð?§ˆÇCTóbÑóv˜‚Ó¦§Ð0XÍd¼Õ|Z¯ñÁ`~x_¡°t¹M‰7F¨ƒM òÚCåiVvâz_a$-¼f/ü™× CM%a>[µ•ÚÀ£gtý—ܾ 3|‘ê5jëÑS6ž!HÜ“çEY8åÍ#UÏh§‘ÎΤ)ä@9ïíW„W³Ó�*ñ¬ùð€Meq@K îD{Ž»˜O™;:²MiE,å|ñžW?yŠ™â”«õMDv¤Â‘g8!ˆCF¤LÀIxü‘ ëh™ù�&rññ¯b�9›g;"x>{=žËBÇ%bõå¡£í_3™˜ûÛÃ<O£âûžµóí…¤Æ`¢rrCI-¼£,e“àŽÎš¸=™ÀÜ`°µ@õäeÝ{ñ­òóÌ'>zŽ0˜w{©8O¬v›�#¤pÝÖÉN诚´øýÉä×óÊC€Vb{‘¢züöÆ]»ÓŒ{Sïê.îŒ0e´2 c¥`Ž‚öî 󠹆‹Å9½¦¿ÄUèO])¶m,`½5XÂT}Íæ¨/t@r'õÎË|Ü“¶É<»’ª?ÁzQc*E¥ÚØ¡æåªpŸ˜eº©á¤%†Š_œKA¡ÂgîeòuÙ ¶Ì»ó`ºP¼hmûgt‡®FPqN€ P­G¹½°rT€i¸©ÊéàM¼=[v<̵ï¾ÍñªÜˆ^įö½[­w€ÈùÿTAÒôÆÀ ºØ›\_<ruhñö©tÀiݪ×uÁuý¯T4"o*IJ/{ʳ#熕;%Óäñ,Gdïø^ß7ãôl÷P–ÅH´h§oTè*fgR¼y/ˆÌ_¬å¥3c)SI7ö¼®2×lwÚ¥›37s‘¼£SOÛeÅgýö”12ty”Ãò¨†qá›ÖÊk{M4³¾nY³…×"@FŸìžkŲJà?qìó=yWÎ5 =õ2vïk‡$ ²q¸’X–â}·Ÿ÷êá‚îøèÜþÞ­õ(Õã|ÀåÛ[œ[«eÛŒ°I©M?Mo< s(g%ßn=¡qwDŠç*×7Íã-{A\Š亡¸•š6ï¹ÏýÅYÍÅ@QDü¤`¿’ßI3ß›$Ĩ 2K D–²ÆÁvÍ(ý½ÖĆ·ZðÛøë—F¨’qx:Žö”å·Îþ.«þ4¼MjºòÑ—¬·B`”ꯅ¶ö+å ÞGãµBûzw¤º2úœ­ª Ê}xÌH/ÅÈpZNÓØ2€#TåÒð*64ÒæÇdd”0L èŒì I¢¡OuPü+žD%uý%ZV™×­ˆ‘1îõÇtÊXSí„TÃlS~×”·è¿Tɶ»£/óG™ï&ÕµFSí"•wÐ^1¨–CÒÒà,DšÄ›•6”±º…óð?øjº‘qþä¾>kJÆüaˆ£ðBý7½}-³¸ä°ò5µ ‹õƒJÁÕ\ïÚ– 8M=_Z§UŒ!²$‚¯ Ú$Î<aÖ8ªFaˤ4p&ó¢ö±¿šËˆ·¬ŒgL x_sX³PÉöT餤?ëÓ“0»¾Aï„; ÿlᕵ|N‚|R8þ±ã1°•P5Epe2 ¾ƒÁ¦úhR®‡èìô0À¸3ðZ¸5"M£øP|; ‘TÍx »£²$žù¥'Ùr´Õ�xÜz“-ô5R`šñÖï¥%žõ!ÌŒo=ã³V09F>ì.®ÓWÐÆÜS¨`îój ƒâ§½ç6‚Én7eÈ@]¸ee^oo­åÍ wðØÁ$cð°`«ÞÂ÷ÅdÐTL¥²‚gÊ“yùKOšœU £ä¼Ñfæ‘Jrú„\æ}ì¦zƒs] Ýú2ÇsßÓJÙÝqMÒÄ}Æ[J·G[Yö€Díö2?b|c*©e°˜.T 1lÃ> ?ݳ¢!W‡Ú)ÝlÔÐk¶IPÕ:£âŒÖSø7?s85×´ýçzf¿ç¾|ñ)_„j›_Kú˜5Õ„S ™»ïppA^åb_›ÑêÔ.ž|.tmbЕ©Ä<^,cŽžý±ÖD­#J¾¼MX®¼e?écϽK$Œ2¡iHQ®£{Mž8^j{Ò6V”dõž }µÔl˜yá˜8_ºÅõ —êpQ!“ƒeôé µ]Û ÿˆ÷ëç3:å®*ë ‘;Ó¬âx€ZÿÔ{!i<q«BÓ¹á0Á.¢È0V瑾Oñ©²&8µ?jO@zƒÏÓ4ã‰ÿ¥Ã’=ü+|k0wª'†Iµ‚á’Br­`|äx þ;W7 ’GnºÂÄmÖÙ@”A̱œ®Æ›Î~ex%8Р㇙Rj‡t7™¬:• Ú{€å»‡î‹òÒYX*¤í+*"U}¿0°N-8(åu´ªÙ;þðÆ€îmáN 6JädùÙ:Byk-NíÊY6S®%X¹w”ã´t{G”Ó!¡:õÛW¯A1æ©›OT¤b4¿˜û<˜ÑÅq¾°Ë VGÑnÒåÄÚ/8çÚf—Sw¤Wþå[ß±K¨Ó¨óå_ß P§vo8òO­OlÀÍÅà.;ÊIèfƵ¬™Ð;ÒC,.–²ÂX?½/Æ_d¾Û‹0K éÔÿ‰)œ»~òÌ[ï~J)‰þS&™‡9§ºšó ÿT¥nP%(ã°¦t~T Nº«U=HÀ»8¯ÔèJÍmþ¦›\]ΣiuéþO…: 5=ë’|3Õ5 ⲜþØ#5ðÚ¼V;¹ºåÊ8úUPL=[CÁ#ÎXI÷cyÃìØIGÃÓ^¸Qað•?CUyÊ’�‘WU³Zý )é~,±â‰†C*êÿümþb+±±+gà„d•ÛÝ< áDA}¯æ1ÇZ+¥ëŠÉ÷Ó‚žylýZgrµ|ápø2*"=É¥ê-è!¬øÐÝU ö]Â�¢"ˆjÏçælÛ ,�îM,ÒÌ›w¥üÑEÀ­1ªœ¬¡¬úöõP÷œWã׫Ëtéû¹cg€Íá®/Udµ£"‘2¥G[øZv­jzo^8!k…”ØÑ'?R 6¾Ìy¶ü íþ*ó œоÿ:ő锦}ãpeš®¼ÈbÜ7R¾ý™*‘QÍkSƒAötcÅ2 îs'ÿ ¥ïzHÆ×ÊG„QY²­³ j·&ÙNU%)áõâ–æq‡ùŽ¾°ŽûùžHRêÎþRˆ Õºß^ƲéÆy<µÝÛÊ©Ï ¥)D•: ƒ-få¡T£¦Gb´IATIGÌ",…´Õ÷Œ€œd¹fÅÒg>Œjª÷ZÉ’…í¬|ý¯qðpäSýç`¦tŒP¶¿ÒáÁL‡ã׃hhg§~RNo‹›ãÇGT'Õ·~|[Ï;¡9 €FKŽ'JéÕú²Ò–­€G·—C´U'ó^Ok×ȶÅ<›*•mFåàÿŒ¦ÄÖ—ûýZ+œ#7„ƒ‰}Ý^XfŠÎ ´:kÊ;VRþÀ”löäßчŽþûÊ­<½ijÀë‡ÖþD¦dOw¸îzK–¹t‡?»^_䌰M=Ÿe+Ù#6­6~ÎÚßÎsf\çWvÏ–ªÂÇÐeA2_LR‚Ú«Ö8 Œåÿ¥mEá\W±hK6ª¬V䆢7N P*øWköýV*‘eÅfô?aÖ;Žb-@zè'ø/ñòö·KY]ZVl€Õp!.. éïÎýPW¤íÃfó›±î13ø—†Ä‘ê-ØŠÖ_BÀò²3>Ö€Uúo]TòÐoËðê«Êãçwʈj©š %|ÐI©ƒ1^ÇZÂËfêñ„˜ zAõ/»_!,pGOË[¤HtH›—iåD’î8Šxº‰èùM µz£<|–*öé–1éšól–ªÝ:“4¶ø;ÔçHn)Œ–ý‚HuÀä@Ãg'·xÛýo:ô¸Ï·¿Ù&î[/*,—ÄÝɦÂ@™fy&î¢XmžV¥ˆª`ÐY‚ªc_öŽeãöôÿ—ÛÁ³�Ýû`®_L«Ð 98ÿ¡7d÷Hž¡C‘®SL3ŸRÈ4Lízèe¨&õæò§k@RùØPŠÁû4 ŠYp�±©ˆèئ4h2SK xoL¾áÝ÷v[a?yú£ ùÛ €°´¯wc’"rZ¤<GnY%¢^+¬ºàaOëX[®kšiM f¶ML’kxíêøf ›:ªê¾ÏÆ:âÒæ²·îæðæ`Åqé?œä¥o?CË}{¤(°0Ájºù³Ó.Þ¶Ûwýý{q•ëŸ1ókuác—ÅÆ:‹‹À8ç¿ÚJØœ™ÌþóþvîtÄåq5Gh6¯˜Î÷#¾žÁmqÙÄð)H 3Æ äDZ]GžòR‚êúmÏä³÷tÓæÐ6&ô#Úóè¦óãÅžF©èöQzjšæ êÔ‡•ô>rú¨’Ô¾×€K³Ü'H–”Æ&š4OJ*¤¦é@Ÿ‡- Àg¶›£gFaοT)åÏ>Ù(3CÇa„í·N;«xÙ¦AQ,¾>Áù‚V›«ÉoùŒÒسä]â<È~,W¢õôÅCS³=`î¶ãý{/åÁƒÒà l.}@º6pm•( P´ãiCçšÿïUÑY_ëÒÜ1¿6ÿº– g6õ!À)±ö]‚mG~»0‡š6 Úu"þ¼ J4æ‘lX+åòÏ7Ÿ57á*¡Â™å£/V8Ϫ–h+ÝèÊ@q&ŸdØÑB‰˜Ø!fD“{{ÊÌ.N» XòïÝ“! }9Z`‚sHh ~gRN~ã0×#]yÓE5Ê|Ñt¥¾"X°Ïìos¸˜r ÝMi`.Ï1±qìFÂ\>5”u…V¶ J/ÄI‹ï¢óžQn2âbÍ4Æó"æµk"ŠŠÅò=þ)ˆ mS¿DóZ¿$91é°ìa¢Yô“w1ª]ürŸ'pyØódNo…NÛÍ ­™±$XUÙ, ŠÓu¿ç¶rm@®[]y"ôLTc„lbŠ×»ùï¾>»Uç“I#Ô^îS“‚w`²Qlï°ÄG‚ÇëúÖVÜ#:€äsøÐs=üDýÛêIÛ¦ —©Aä¬isÛf—ãdìËû8«8L=qCÑw¢w¶*æh‡/hŽé«¾>òJ»¯âäÄg“…)ž$:0²0œ‚%PøtÜ}ÙÉx˜ö@ÂT’|w?ÐyX&Oã­îqA7ÐàÆÐö00ÏÛ8´ø‰–ü‚žIo›ª‚ +m!=‰²OI“<"ž—^X.…%æ¦ÓÞÔt3B Ô¡Ü_¼Úì€ûÀK˜ŽQì°sÖ ðÈ ‚µÎl&z^õÚÜ^z‹v·w á¨o¸þ¡q*d¿°2^˜ ÃΕnÊçà±oN‡åÿ¥Mh¹p(B+ô§ ê°÷lÐ6Üár‚jÛ®ÁÌÞŽ>ÙºAu¤åžÙzô´à×½µ)ZÈÕëý³'u&ñè_Òf¥GlSJêw`â{ô$2õÐ ¬ 2lh-EÛ­gƒTciv~®gtÑ}LmºhœÝS¯-Uî—kÂô öàƒ´»ú”×ù˜ØÖ“¨WØ‹+ŒAêiÄ—ÈŒú Xs­(¬ŒÒ?Ü89Øõ>sÎhdå²8[mW`Îrd<ÁÇqûß4‰ëe@ûw«5Ë3okÀ71F;˶2"î÷°})72ÄêR8ÐöÑ>­ü„#ž¢ÓNß°ÙxDŽ¿ÙÙi¥$ÄÌ9î ÂEœçuAÇöæÊ8ÕêÕ—°ÆÞ¤#åK(•è3Ô‰­àrÅÆÝ}ÖûÜMà› Nܱ+ÞayûebAxî)Tg«µ½ñ(G)­@öÛ½BêII•Å™'C½år4T ¹ƒÛÖ]É#Êíｫ{öÒWB’æ€|²¿8ù­y<M>¶Y´¨¡Spßî3¦À~fF¥qæR º3l¦·)ÀZòÔPæ ÐÚß{)ÄÕ•Sû„ùoÕuZƒ¢oBk“I McœÄO^ÕT­ŸMd¯|-5[aÃœrºø´tª–:OÐþŸ™æD”[xrL´˜×1ý-§ðÅÚ¢X Q9ʃýéÛì‘Bäq¨°^³`}¡Ò¤n¼< Ý�¹[Ç7Ñ7…ìA'nÙ2ÌJJ’ò· ©æ®§,Ë.àK–vœÜ¡û~I^)ÂOuäE|@—suÆ@gÖíCÎi†ÑZ½~ 0öÌ93§wŽ{ÒÃl«Á¬„ž»›A×ãQ_^õĦš*äfv�‚¶ë·;w—'×Z§ÅÒ‡ôU9£Vh€Ê9‡uh}F?²oij¦*ˆ6úžàL ,NºAÇÓÈÆûZ„N6ˆbâ/áu"V .ØË]-O…ÙÓ 7sÀ¤ñ!j¼4Q‚EJöÚós^"òl7ð³›ÐúÇ#+‹Ý0!&C)$[maǪ» œêx#3ru$>©àªÌSå›$’Aá<ÛîÒ"ñGª Ð_ $f×7x4\Aó@ê‹Ü%í¿€¦¯å æ ð­v§Ií¤wÊFýÕ†Mâ… ¥ìS$$Пù¢{D‹I…�¸ä@jƒå¾øAaCûègî Ê cîíu™Ð×Râ8ýŸÐ*h¹vßm>.ë®=ó)3SÒ~ðÔ€8Î]‹õÔ¦™Ž˜¢V¾Õ|êwGáauÝ—ü³`uXHÝ­6Yâ9¦dÜk^Ó¹’u'g™rìh¿Í³ŠXÍÉ@¬Ê|Þ^FZºíz×_ÿ¨~8Vfö´t»,¸Ñ°þô¥¢Í÷]iŸÔZ@ab@$óuÚ·ç9Pg÷Ì¿­ÏÏœ|*z¤¿{³ ïF< ÷²¥7ÉšQË1•ˆ•1îšæzìUÄ 8¤ SÚΕ»dX3¥ÄR)£3JId[w®TJõæ¾ÁcnúÌÇއ †YÙglasÉO'Áq¯|ÉD�¶ W­àÁa½bíÐÜíZ¨”ô0E¯¬ùTd$÷ÙÓY'¸ ø¨‡ ×"l,ʽuypp8¸rJªÌW|L‚¦­‚|«ª_i %?DôÙ¡ííÅí×¢èØ8�æ\åéOãì¿÷õª>õ*ã ¶ó Т¨[<¶éIãÌohP!ÝÖT|ê^”Ö;ä7ì�Ïâ{9Ìî�¥³³½ø¢¿ÕY¾ï<A\ë\˜SUÚÝðMeºrÇGþ}ÖàN]ºÇ@Ð r§o™œEV¸æ•�‘‡ÏZ1e¦l{ö ŽåýÍâ$þ…éoPÌ,BŠ®EP]¶Z³‰¬x¿ƒ ¼Ä×çAõUÈ£ÊǤR<ïO´ûêÉæÜ©›ÐÛ%tCžâÔ¥<‘˜ÜmI ] Mp©áýÌ"Òï˜3D‚pà,”KóÉ!8§ºßM^2ižXW3 ýÞU¦¹ï¼,±ÑôˆIy4{ò¿ôߥ5Íáp­A9ÙÝÐá[s£XÕÎE4Ú†Âú6J¾Âqï1Ðä°¸ú.$ø"J'Ș“áLË®›­ÇX-;Ñ“­¸‚¼=àåø¸G&ä³SÖi#e“ùVí|¯¸ٽθS :¶$þëõäl¬×©ÓÎørÞ»RtîZÿ9[ОÌú^Söãk'…lkKµ6ÞQkH ßÃýy¤¡ÊØ ˜Ãƒ|#y˜„ž–K!ƒóÈx¯£’,T_€‹F\Fw7ìÖì(>BÀè–zE5U€¢…¡´Ê•±‘gA)ruY0O 9ü¬=ÅÔõç‹fºª<É}¼Úè¿ÿf£±E1aX\Ö*NŠÚu ƒ²Ít'¦/}Ùò ëôýÜ#D°SÂSSý§fRRc§ÛʧâNÿbòzó cßí·;®7Yå€â3&AbE  µ¬™…:›Ö׆­i¨Ø ôƒ¹§0uT]– ÚÍ©ë[“5ÐvûaiëÓ°?œƒò”i9e 5à3ô‰§[%lVkC©´c¥Qðë†Å•ÜeaYd¦»iÌéÏÿ\kÀԺذâÌŸ_áæ˜qQ:縥=’ü¨``àÞÖ(à…·Ã÷h<µæ"lM3M_¯ˆ6±Ó¦3(‹M”­ÕéåŽKÍ UìÕ®‡Ã’WýØ—.ƒo–õXIàHß =ÚÞKȘ}²y›bëîaì";NLƒëkNƒÂºã¢æ[ÑÒÞ‹àèFrGE*ý!“ÉÁí8# ÑÍ1¹>[öN"\*ø[K…¡‚ïÂkJ}'7}½?ŒHÚîÿçDœy¤) l i¥ar–ù’‡¹:ð£{Ã2V8­åV6œE(¾†Ç‘nk·ÒÇîã'ß ,ÐWtê|ÞÔë9Á¦\$ÄFLÉ’öL ;6;16K>¼1§¸Õ6 ³%'x>G´ájédÑI•qµ\³¸6þƒq™í¸ ¯÷L/N·¡aVévðtPΣW´Àéîûäïœñ]œ…žVäOAÕڶ슦`=ú-·÷R‹¸Š\Ññú+ˆwfÖû;âÄRÍX_ik†2•9¶ðãç@\åVFHŽ�Óu,Å°•¶¾é ªÂÔ žA. p%%¢E€­9çSH ðJ¹~AÞ¸ŸrF¢ÃgEèx?›ñ9ýÃÅä»�x&’žWp¡(óÌ"¸OÜwT‘|ëY$f;v4É® #½gÅ‹"–£!Jq«œR%,A¤`ð—šèI•yjt[ç5ä.žUOÓ Ÿì «ËgD7n†qêì,·¡Ô:Ö¢@¢² ÄY-áÕ5ïöÂj?Fæ]#á.Âü:˃p°§LhÜV­„‡t:ôé†J÷È€i—ª¾EzÕ|>OTÜX1¼ñtB#Û,+ÊÁfv¯7ipšy3z><+kf‡£®d-¶í\ì÷²¢´�l£Ú¥”'®gLJ󜭞¥ú=Ò©ŽQ¾¢ßǽ™Ê{ä °ƒÞC댾Æà‹6SnÞ»V†…GgKäÃ>˜‚Ê,ÆZ{ Pð¼*Q—EÙÃú1͇JL)-×R„µ? ‚Óa<š1¶»z˜a:ãkFТqik9Y9)L/(¿­-m‰Û‘욣NZß­Ó7Î_šj¸7Ji÷&œÑìJ ÍΆ£_~²¼/dZ£îj@|Ìxë,O½"»b‡Ÿ źãä}hzbþÅb´&§ÅµÁs>ëËÊÌóŽ£#pºÐù]4ªì]°Æ†è°RuTS˜2ŽbTämáGï]çËdþ…Uäfþ1ûÒÁöõ¨¼Ú,õ³¨©´ö½/³‘rùX4鎊eŽ�R2 ÞtÉ*_K$Èsˆ¤Ë2×Úì%uu“yÒ—´(å«òc¤´þÏjiÝüÂél‰ˆ¢Eºy`Å%jb¨BçYÑl´¦Útú¬úå¶[©ÿÑ›|¡<YxFR©ºþGlLϽ:øÿIZÀXÖÔÜÚië‚’Œoµ�Ž¬ÉÚ»Š¢&×÷t\œF?"i3zZ²ÓɃøRÖõkÒýƒÂþKoºÌQýdÒ{žͪÖÖžMokŶE™¼9§ìOLu¢Ä‘{bŽHúéxtº0T\4Kü}Ÿ+‹YŽ]¢G!îÑŸ ™#̾ڀŸPUg´=–§Á{JßôþŠ?yÌš²æÌm/QÌUІËÿ¼7Åþ˜J=·Øúü&‘�ÒSršX;³#¯¾è?Ö«B…ñ¸ß³'‰HÑáÏî 3¸y<¨6šwÉÁû>&-Ã…OtlzܳúìZÇêõ Ú§Ãð–öŒwyGZ;^!Ó6X_² ²¨¤Y-4ÎPˆ•¨5„ØQÄf:Žãîj!Ô) ‚î=ÙfðXµ,[<ÏÝE°`F‡‘s»ö ¶[Enù³ýÌ —ií{lÞX|‡¹î_NVúÒ‡ÙfîEF#9}ÈÆz›w›šrs_^9£Bd×iéøRà, =÷‡˜m ¹Èû-ahØ­UÁù¿E¦‡šKï®VxÛn´V«¯»Öá‹Ö)¢Aƒgf|aØtB¾\{¢- ¼™wõF”¶~y¹ÑJê² š´±i»@sh'Þ#³oy‚{·¸ æ´ÇÑú°´û’•'±·6ci¨#üo7üo}bó[¿qãNß]AÉSM!©Ö…›¦\-Ÿ5çû‚òå ¤ÈeØ:Xj€6±êvEÎzÁ^H2?Éù¢Tû}±ñr9Ž…·¦|Ì(=¥Šµ»×µÆø€G"¸‹ FSû%ÄÊwZ§ÖC‡{N¾Žõüè™Òb_;•C -EËDVÛµúž¶Ü?ò’~³•)Ü¢­ð¨SaTv‚™¢R=ÃoÜ.OàêëIl­»|ëOù»ó-ôLg<üЬoRZ7¶ÙÂ)L*±|¹¥ ÇæÄé~Àý›FO§ , åA°«üÄP6hžëÿ?mÿ¶<²´‰ÂÇú®ÂG«ÿŒY=´ßJH l!°$^L¾ÿëXñDdd¦0`üÎ^k}]È®Y¤ÌÈØ<›“V”7Q5÷ô"JîŽNaö“2R×v:Žó7™ÄÇr‰¾ûlÐǶNö¨ä Žê. ú&ÆÁuÎh½¾¸üC/ŸcœËå×NË{$§-£„µÇøÓIßüJ§üq½9£µwu›ú žFõB1ù‰ÄM´ÔÄÞÊÂMƳ~Ê쮉¿»;ÓÃ…uba Æ>dGã‹îŒ ùbÒUÓVíŠQ¸–]eëäpRÚDLè0[,¶Õ/ãg“äD%* ³ä7[Pl€H…É*¼J"¤ÇH+”ךûÛí·W£ÃoÖġ3tPzx'Q%67ÿXû 2‘<qhH¢—,H:-6Ñ'¦ h¢Áš®ýhDïQ¨¥6ÞŸâ T÷µ>Q$;ª[JÒDãKîºÅn_]É©gb¨ùs®(\^}Iq$˜àÆšwý¿áì”ò¸ú€[qöÕ{­ ƒ1Eæýã´¸qЃ”OÚwæá5m#T…”E6Ã)ñ¸êùÀÙ.•”%1XçC” Ra)‹ ÇÎ7C¿/Ãð£žîê™r ¨‰ŽÏã‹éò6×ÃYŠ{ŠÍcˆyÕî”÷ƒºhܦ·½ÌyP;˜æ| ÿÛ©iï¬JÌog‘ø¾¹aœ›‚Ê AAnÉ[)ºÓya5Â!ÃPcøÌ Ï¡Ï+“Ä̘(~~:ýPf?솚’HÌ|Q¹2»Een€ÀÎ&ë† Õ´« !I;þÃñrób›ßqሠ#"’VŸ ôg—ƒ¾†û»sáâx]7׿ƒ"8³;qP)ƒn­XH/I[ù¸§bÖA9�:=í6PÎï L·(ÊWF:%èóôN:ÍT. —èC’†5ôŒvø»z>áÓ—ÉÊ£­ Û˜y²ÆŒ¡;Ï6² ¯jו_üÄ!Ó8!tÑ•÷ѳj |‡˜O0¿ˆÆ™@Cq v÷jé,Ì<h=›öJïî\½©º°Gï®rÛó.æŒ}P9ƾõƒ(ÒΊÅÆ’÷q@r‘Ýy?ÈiwïÊ‹¦h‹ BƒÖ0ÈÞ½þ9ì=„ɳ«Wê '«UÍg7O`ÅØWG° ËÜ0 uì,} ãe.e½Ë;óÝ<ÌVÄ`úôSdÛņ¦îI~Øxtï,“WÏykÓƒÂÏ,ŸÇƪÈü�ôQŒŽÕâ•¡–ãkz%2(žp;äÇKßÿT¨Ô”%è uÃÍ]su*õv6%/ÕŒÁ¡U~Êi¥.õu8Úúª¿ÊÇËÜÇjAƒ Éƒø«óÔRåØ`¬ý¢lêÁØ$ܨ9Ž³UnC$#¡÷îÏŽS7uâú)ÒCõ¢I|ÿó¿æ·á:®0ûy¹£ZR¤«­r#%Þ*³. ì2`›7ºñW¯‡ò³mN”ù‚õì}ˆ&Ak†P‚¥%¶bŽ­õõû›G‰çÉL©Z‰œ*‚wj˜'¯Ö�÷Û‘w,ÅÆÿlþ¨‚ÄvhÐÞ€ÚÍ¡SI|ô¼·œ _öÃaƹú|°R8œˆÐ¹»/ $Þ¹J9âjÀþ“¥Ç"h˜nb÷Õq²ö­©až»� nï]Õç»ë’ÑA>árÛ+¶Î_¿bìøtn#<I­Ôl[Î(â4åjàoÌ #Ë¡TàEí7§ÿì©Àªw3nž©þ€Â>ùx®S×Òÿ¼ˆüªÁÝÿ¥ézX%í8¥„$¥³|4 i\š±žåÖ{úGjÛ¿ÉÔô í­òÜy’ž§n·³‡È¤ÀXw)åù÷­©G±Tk=èò vÖã¶A#Zèü/‘byš9¯»s Š¶›öThÁ~¡Éá5” ™ŽÍN‹ù¨á¸Á¶†¤½H‰Æ¦¦Õô98­Å`–nRß4JeqäÝ»p¤k†•¡£þ„¾ëNYx†6næߪ¹$¡PÓžBÍDd†A™ËiD;iä©šÚP=O,ÛÛú/1cq- ®/sLE`«p)˜TãEOÜWŸˆ%æ0©DT2‘möç¥aæÌ\ÊH¯´ïÚÑà]7õ8¢§b^ß8ü|+ÎÜ9^˜SV†éÝ£¿â @×U§£¿#QU±Ÿ) ZÑÖÈZ­ø“P\zeyšKüŒ|À…i0`dtýtˆZMHÊJ:ŠúÞºÅý…¿RUøfrtrŽÀ”Ÿôf‘w°«l-å‹N#Ô^®\Yå›àѪ^¦’bÊ—ÃÝácK4@kD—e¿y£@™àîÂHD}åQçDÊw‘È3¶C{æz¤„gƒ¨¼Ýož_üöšßâ®B<YämŒøAß”Ž{Ô´ÚúS]Ì·jvÛm'diÍÉ ÛhYΚj²ê3}×íÂOcçã¢Ò“ŒbW”¶Ë©XÜÞ¹öÍ,|êøœddÏOfò±× gUôã•'-F9Ù¢½cáß'?âÁÐíà!ÎÈô1,Ž@Lú3¯ÇЫ¤TºYð|9{tºYãž:‡ëÍz~ÛL:G¦W±´ø<;¤¿é× S~;t—±€Ë WÓ"Êi²ue½7u¸Ûœ<Vb‹ºHÔÅBÖÌ®qß rn¹óõ]ËŠø‰DG” ä¬Á®´Û㇎ݤ¯À@âpå÷ˆ‘Ö@'ÿ»îRébŽÚÞÒÒ¨7Ê©b9>ðGZ_êšFlûù׈䱋ä¬g iñ„ê“Äv¸)Å]ÐÉüIXÜ4” žšC iú¥d–óŸ·Â!w"Ä%Ä’š¿ „§šj&õ?‹ Ôh‰þÖ ºÝæ¹p4ŽGý½ëMž9´µˆ¡QBó(ÐòA=7#§5ãæòmú¿$.¦+º(-ų*;•è‡€>‡I—eÓÿ(\äÀ"1 ;Ñîëª,¬T/jÝ'(&±o~@áî ÎE6NÎ~�ÂjKŸÒê4>P4}®n§…§ÒBœ+ Ê^K"ôÊ8Zt°¬±#Ò¾¦åS=Uæ²j Z$>`d=k¶ àr¤âR-1+>ðû4BaTÌØ‚²Yl·žÃq¸NûZ¶Ô‰M±þݧ%®Ì€] 2 '˜¾Î&†6¦(دP"Pv¦rÎuB—úÌ6&æ•»‰EÉ “‘æË¥Ìt¹¬Hnì®l¦:<ñS™óŸ…3=‹LžiöçœÍ¡Lë§à™ÁÅ(±œ‡›âüM†ù(&am =o=SÑFp›XýZRèŽ8á wìø6få“ïG&tiC>7Ú¸]Í@5¯!©ÇŒýØ3”Ú’€_±;HWV]!„éÍ›N‹Z‰›²ÚÍ£ÿždÅQâ;ÝP€ÿX"xö«æ3%Ñ”: ñ ª%=Ù‹é<Ž×C×zÐXmиڧÜv´«<Ť2Ölzø#ÆJ’éîÞOþl½2ùá0Òšß}ºô¡·.+Öî ¥¬é·©Ùìsxiäó¤+ÓÑ£ùÙ{ãص{·ÈÊ%õÿ«–^ä«?ñ_¼‚ÖSíf+•ÎžN¾F#F_=‰ i8 fxO¶Ú­¢ýÀ`At¥ä‰´íÞH‰ÿŒ§P; £]™ÒI‚t»Ó¢àUÌÈ­ÂòAí/Ã7Ü1}(|oȉåÙJ·)ARBßàdIÕ)K¯Qtãëð¢Ù+ÏL1¸ùÑKU|•t:üX(íY>=Å;äL°H⪒ö&›¾F.«<‘àDÚ`TáÇMï¦}÷§>_–âên‘wùÒp®ðú%Ìü«)�eí¿߬š½¥Ì-ÿû~®Çy}©W·ëê’àáÐßAgq¨}6ýñ8ÈÓ0ðØ·f?³¾ë ÿÜŠv1[ØGy°;CÁaê=q^)½NP^è+„^‡’s¼qGK«²[$öeí _U^Š’ĵ,˜M×Â2+ÞégO@Øî`£äÙ›,‹é¼Ì+e/ûŽëú­Ö“§‹, 0œl•Ê˪—Zfÿ˜�¤pl±âŸtWš†¾DùÞùR“õ´w3ÑSÝîyÁžÙñľ®õãBʘN°ž•Ê\2z‚Î×àE¢ˆw¯ÃÔ%XïaP5;—§³áCPì oOu°?ÀÕ·?ß.øÄ:RW†>4wô1óFã3ÅfD…ù[*ÛŽÃö;nï‰Æp‘†ž@#¬VF*0[«N­•¡žU¡‘÷y§£ê|ðíÛ·Žü=IÈÂõ³ù!/ vUo™s8{VNˆÒââÞË”l¦åß°ÔØzÏ"üŽQã}ÇÆ¢Ìü F ª—AÖ(£ïyÚŸ:ÓÚçw7Ãr¬wïò¾3m^­îbª¢ CÛ{Äæ¹P¤yP¦f?±¶ÇÎ|ˆÕÇ°0òû¤�¦Ê vN7‘¥\YýùE:Ì·IffÞscý*¨lË +¥=¶-×Ôæ;ËJÙ ;²u]i([›†¶|ÿ¯Yè§óÄ4…Õ;´¿–Tñ™7ì÷j”V A ®§Ð0ŸI±§lë:Ÿ¡Ê(cYÞHÁ™ñ’@ll½¯trwÉ‚¨^<öµ¢É}þ`WZ?n~Æ A\kO¨žÌ´×*›˜ÛV³¡1¥†¦€CŸQ²°vóO“Š¸ˆ"Šµ†úõÉ‘2œ ºH¬"´ c…<Þ9qsëªV™‘ü-´ô¤Ûl¾n 2 CZ4›l¿}{ ϪÃEÑjžÞ=‰í™²ŸÙH¸é”CVÿÃMÇ—¡Dôj©"(ÚΣÕÐÛŽ­E*Цбž»úŽÒâA–õXÅ –bAö9xÅ鼜é8Òê¨^ä¾Ê+ä•E‚Ÿ EHÔõ¦€OÔ 3¦íÈP¦Ú œy9¹›}ñYÓüg‰²ÓÊÖWlŽYPŽšš%¦Õ&Hžá´¯ ]ñ돦-Ûj·§b__ª6·&Óî|H~ó¼ÀÅ›HàˆÍl3Uº,naîÄ ñ)(1Ï<à{a„j3:M•õ;ï‡ùèZÁ—ù?td—ÎG€MrÌÿ#k:ðº¨o(D;ÒîßD!Ú*T"é?í=‚V¡º­ÌÒ£¹2ƒâL„aƒÝ{+‰ˆ“Úïºô×¥£棣œž(Eî°ÆxCh°Ñ»–çG<ä†<ÇËwÑæó©›þ9Ô6 µ)ãÍf©;>(¦v'zÀEwr™=2urÚ´³[,'Xý xÓCÕèr‡Áüù©ö†ý”PÒ’£SßÓ`ÿ­~¹²¦w=tß/'ŸÆ=;[é®c‚ 扒wøØ͔լ4À@yIˆÓ—Q™ø)ݹ}—¦:ß“4ˆ-Ø7F4¼ÀÆ@V`ÍÍ'ù'§F®î·Å3>¯­ `È@hPßœ$*#rä¨ÞÀhÙ]<BǪž&‡O —á,Èmî˜"«9s5yÙS 7¿B£øìý©Ëúøùhu»’@é=8qeBÛs31pš°¼¨·¼'±V·4kôL£å§md•û¢Ò¤Hó$ßÞ'CRew,¬É6}!œã~«ã×Áà :œîÔ$R¢ÞŒó·hɳÝÎÒœŸŽ Oš…àœ£¾ÿ-^NØí"«o�AÁˆîÊ‹†‘§c«ý[õ‰(nŒÁ®Nð5¹ÿÂË°+V߆k9Ö6³k'ãwÙó4èE0_á?†Àr\¸+›ÅD>«¢>ý…¦öRù-˜&ƒtÇk¦“ªøœÕ‹{ Jêr½@ÑfÚ,«d{6\–ý³óÂS›óáÐ"im5öÄ,,J¢ØN9ÄçB1Q£,¥¾¾B FA}3þ§²Ýð/‚'´›µEÄ–uNïÙ·FàçýíÿyÛ½ýÿG€þÿoÃÒªn²‚Áõa"Ë6=³öö•23UƘèY šþÅQƒ×qq*³ƒo_¿k™«×²{RÆCEl$ÿŽ(ƒ§ˆ(aÖÍ$ZÉúzSW7-ñ BZiq1èðö”oz‡æ ÆóÈÈP{Á;€²¡*Ýàâ‹Ò-OÎýš‰ÂI5b¶ei+R+iñÉ¥§Wù]+Àe&{W(âÌ-êVÄ+u¡mx*f1\V‘t¢#o§£6�ŠaÐîëQôýŸP›DEÛJt\l¯ôÓ»×züØOxVÚ”¿Ç?÷™èTìúhaª®Xÿ-«»´˜€;› <€Q×ý�\ž9õ•”Ÿ[E¹QVHæÚ´7|n#àùXÉÓ ô&Cú'|ÿ×£× ÝñttéÖÏÚ?Uæ<hcô;*ÊÂkÌ£#Pf²iÀ»´ÃÙlóÞÕ÷qHY9…ÓHŒŒA¾={â$0zãtT‡Öç<e‹òÂ,€A wmbO=Ezx›u‡;\Eöf�u±CÿûÕP›y…EÆ(ç¥ÊO+ìɈ¸öíàÆÄðö „û‡{«ÿ@4÷ï*s˜à8𜾷NçÃ?g©\ú åœ*—'Í`™jëÒ*Þ§©q“^ñ©‘`£™Æý}§ym¶Wl³õNÍRk+€Šêskéž*Pövªw B|>ÂÏ=‚[Þà¸QagÝ…„æue§®…/ž¿`$7ß$Û\Ó&~ E (õÌZ¿p#gð­–^Ûä?2–×›ž’“jÕqa/<}ÓQ&fæ…nI73LžïãVåß( ~¥Ú¡3MCŸw¶Rs¬)ÓŸ£Å“p<õ5½zC‡ç­­áŽüà·Ê{‘p\qÔéŠ ;O‡®ï Ä†±ºxê™G‡FÉŠÚ¼íF–¿mF¦¡SŸÄ;ü)(ßÏ×£"̽’Öž²›BO†˜ÅߧŸ”‚Q›F©gøˆZAáöÕk�Š³}™Aœu®¬§º¡cÑÒ ±;ÖlýÍ .õÖ>;„C�>é”êGÇ¿ÑÁAd°U¯hÀGn梄šT,$YÉúdÃÞ œ8?yYÿ.ô´TXXxÞålì) ©€!äÀúÏ Sp)½Mó?Ð2gA…3Eð(oÀ'˜Sf=1º©¬f˜«&À6ÂŒqð–®ñÙ’tò:J`BÊÝÐ\ïÛGEgNÏ£  äbZ¯v8ÔÓiÐ.6»ÈÃ{Ñb™$æ?4Ìü]žbú•y«Ë·ŒÈ•ëýÌNð9—,,¨L~ÒЗTžÅ–g«È÷,�:÷$ž3¢ù“P¦ee¥Å“bbVïrã Ý¥q™®îâ6ý© _®:éP°,Ú‹I#�qj8O›{Þ¡t=Ž³AFý"0ÊóÌóLˆ@<‚@í©ö<oçA¸Ú>ŒÆ0¥mñý8.*ëÌÀñD"ýTÈgÓÕgP¤,·›ddÐûá8Jþ¦òi×?A[·Èœ§sJ+:­pYÅf:Î0µðhM0ÙäsBî ƾ\þßΫ‰&á”óçÛÚÔ†Q^KoÔÊ_a™‘e¤åT3nkz0úýORz² êkE)VkË´‚El¬üëzVtÁJ‘Zêû„×É'‹ª9‘¥ã @eôVé?o‘ ¯3ÃSwÑ’ög|Ž6‘»E<„'“ª? ×ÑŒÄL0†2àHk%U.luÿøfmŸY]¤He)¡‹Î–ôÃb ]ý1ŸèyÍ÷nØã�á¿7ÑQjTýYÕ·c.[jüXsÄUe¥›ëWbñNªõƒ­Œa2¿¹¡ùÿ­Å_”„YšØþ1D\ŽYÔg'nc?±=ñ~ñ]ì,¥2>_<È/­Êt•{žŒëã|8ÃOlWåR©žë¾ª ï:+˜ÖÞÌKÕûælÚa2$çðüýW÷W5qÔ* =”Øèc’y€)ìø¦äp|©)÷ŽCT£6dq62,’‡:!M´õÐøS·43‡ÑZF€2§ÑK!gÝY@"$±ҤϮ¢áf#•+}1X5%¸Ýì<”æóhD³è+BÁ`¿“–ý`0ήRåÎtªb—T…Æ·íáßf@²wä7~rð\—!÷ÆRÜ@„‰:Ýül¤²’„‚ÍõŸ¶ûg¨ÿù—N9Å-ÊXs]}+•¼®/·%™-4É”wÃNS/e!Øš¥ïLϬ?³<€VÔï¥-âŒ>›Î¸¾Û‹¿A$'¡@§à¶tc<žµò£ðç 9wÓg¤3EµR½Ë{¿ 3Ï 7Œà™Ä’r/€=ƒÍÝþÔ×<T¦7™™¯òTºYåÐá8ÖéØ€Á«šŒƒ ÃsgÕƒ`¤ðyU/Sž¸ƒ†Ý—Ì #£c~ÁÍIëÝ<ED ® %^ppqIã.Ÿ§¶qµvØŒ1ìÈ‚r«$å¯á™Þ3ð¦…ûô¹ü·@â}Z!ý }È]šÍí±æ^öâ!YÈ÷ŒdâBÓ� õyö„• èœ}Ü4Lsèö›>i•ùœ|¸Tön¿¼ÎX__¶¥¢nW:ãhgsÙÒÔ‚íDüà 讎h]sW¨’H#ÊœO^JNO «Þó°dŠòø‡{.só‚ÊÀ †=kœnbÏRo×éí¸£ öùú™;Xeâ·&MÁÉßžÁÔ!4\óÏèŠ|åƱ4[b¿R”0S”Þà~ÏU'⯵٢4ó¦‚FTŽJçÖ)’«ÂŽ"´æÆ7ì~¼‚#¡Ý¬è›C„–¹$ÉfÚŸf÷¨‚#¥“SÐ ÕÐtê¬JQ˜¸&?HnÁþDåË×ÖX§Ü­‘X÷ÑÍ;H€ß6æ)[­¹óyy©‡ôw=È놟ï®I‰ ´k[°T<ºÜ/‹°'U’gî”WˆEBþ®(Hò•®\4yå«ß2>\„ŒÄÖiÿgÏŸvµHpÓ›³Àâ·bÕ“#d„ »¿Æµ.F¦!‡Að[ÐÈLÿ˜D´bó�zTAõ©jÓU®’YÎPS="½2 Ö:7 Y… IòwMšE’‚˜ÿ¼•:[6(U�­¡= Z;kwühM’¯ÕýŠ RܵÞÀ‡Í´u¯¨»;ÿô¥ =W"Z“€ ÇýàÅ:nœÿÙk«^WÊ“®YZ8Š4þmjèî¾Û‰:NKJÅÒµ*Ûï]¾†1´¾•¦W�‘FMoáÖ1×în“TÐ{ÐȼA•}»Û®;ó ŠMöÓ_<_Ôöìü*JyªÒ ϲ<ïåOöÑÖóP©¤1Ò¨ÜXo"±{{ |e9ô¡±nÇHøÆ[t>BÖ^Ñ\¬pf{v¼ôï�ø¿ÿÞªF‰q)ßl :&?í(òs—ŽÊ6¡Æ±¾qšÞ¿šÆ…Ç›el{ÛÓž5‘;Ôª†Íb¨ÜT©ˤÚ3ó±7 ^ßîþøMz9)ý%®åßOœ+Ä ª_¯~ó*ó&ØP”Ê7¥ªXgf¡è\kÉŒ½ÿª!g=)C‘,/�•¦ï3œ¼*™[âûƒâµZÞù')ç€ñ¸ §ÛYmôŠCÇð"{òìÞ̈ߓ¥˜º ¥|ëS­XÀ6ePÖ Çn’èhØÞ>…g±9M ËY\¦¼‡ H8jÄ2ˆTÊ%¶¬uH5߸\OЭL@¨”èV=öní¤í¹Š»é6òÑÂ÷á²\S¥ ¡HUââ‚Ô&/42_—-(zïÿzùÐEWGÒ;/u  g}{ç<qK“zcEÝ(Á™žÇi¯I—I9 ½Ôåø¯ô×’ØwNòh¡„ÿÝsm^Î3•ŸjÒ ÿêGυǨjBêºà¿ü¹f3åQûÌëš#l <c-$­¥¬]qN)çëèçš¾²Ñ%$T€Qew±Z"ð¬¯xSËÛ·›óéqÙUz–L¹hz–0.îRÇ-ln­Ç6(2]³¼ÍNt’M+leLëÞXK0D¯<†ÄÖ„zúyiÞr Ï<œ÷™y¢(†cÜkÓ7§,qI>bKmpú+[s¢GfºTÎêÐH…ÿ¤"…+kûÆaAÔ¿› H”ahÔ€5Øåž'|äºc‘éòoè¦:Õ÷X _°B`Š>ŠƒNn½KìŒom¬©Ã>òh!NTÅí¾RZñÀˆ0¥ž!ËîuÏ}uFUÕ£ÈN9äuåÉÜ‹àÕŠöfr³zr(L‰Fµ(|ÈTõ ÏšÎÂáz0· `³§Wúñ 6 ð%ݤÂæŠh–ÉÒñ܆~Æ^楥Š…å¤NöŽZt ” }ÕG3lo–]f>XS¨./Ø79±ÅŽµ²DJ¾¢ÿœcc¬qçZð+#–‰Â\…µQæSDnkëŽ}MØ7 “ª,Í^b¬ûîLeíû»ÙJÙZ<ì9d òÌsúó!§ÜBáCyÆxIî§éçDçN›ƒîRæÊw&¯ž‚6+µQ±“òLZ²š÷¾m°=®uü2M|Ö1…®¶ªÍL;½ž,ìßL¡ãÄè^Ʀò9t쾡âòEgÇïL9\ùÁ�ù[0Hx ÖûzeéÌœæ˵OE%A£¦¡õïE‹ì+Ý£æ*-Ró›oí뤈3OY� ß8ÈZ=o‘ØPoò»Ç²xÅŠ£›pÔýë„ëq¿›ÚJhx£à§Saëol|aíNoùn×ñQ¯é|ÛëxŽÖ*€P†�â¡ò³’€2LñDµ9£Ö4û)­6Çžÿ*‚²¦•AËt„Ù]¿óO|Êú%„5qžd6è Á]/ÚJˆóºÖÿéN%©—thÁ‰–¦3´± 7e(¼È"Ls«Š"p†q„dÖl—QQÖœô;( –?û Éxå Ç¢?ÑöŠj Ž( 7”½‰™Ã$ýŒNrˆßÜh+Ì3Å…ÄÊÆ t;íÒ =DµJ0£¼L"bØj«¬àNÙÞÎ3Lø“åÀ…èÞ6=jI#b&´‚Wÿ7,ržùR}¥P/¢÷Ú�–T±ÊÑî·&h¼ •fá w“ŠŸduRB_S»<ÜØ,S²Ñ-WßUÒÌíî·úãìf¨»?ц+úÉCLûë¦[Dæ<è®"íëúºk‘¯6Nùœ¤ôfʽ*CÀ�¶Ò“´bMú‹âžâEúö¿ÀÕOaì]¯h{m·“µ ½Åb<:vmÐæž=ÆfÇ"ÈϽÖþØ#gZk}²›Ÿööhô3¾¸,3iF©Ø<Aü®ƒ{˜+Ï›éܘ²±yºå.Lq%ªýŽýé`Ó +ËœðÉ㫪ȋβŽãø4_gÁ‚gb²ø½õÀ£¦Ëü—‚iåO)œ:ÈBtzÜ"Ûë¹)2Ùñ´ª¶É˪n,0 � ¾hÓ&W­ƒ{©[fe©ÁË~&¢¾<¯ òòFˆûø…©e6ŠnË-{£÷T7ÆÓB{}Œp ­<Í·ïž`FlªL2núôÅ<jR°ù‡G8úõ8*ò53À~å[§®‚®ÕUlߌ²-g5f®(ØÖa(‰O–YäAb ƒ9f¸ýtZô8îiÔ£¡3“ËÛWÉN!#‘# ÇX^°ôÛ—A¯6ÀÔŸû5É©$̳•Jý!e–¬ÄýºQ'y±'ŒžUÁ~®ë Gпô„‰ L @;TôˆF¯QÂCKHªÑ¦1ºl]½TÃom¯`ªqe“÷(áÁ$ˆgõ€É&ÀŠÇ ‘Vw0v$\Q¿oÆ*¨f«Ðp}qFä<æ÷CGÿú&{‹ã•ü&ìL` öÚ?¦¯~n¹SaÚR6G\˜AN¬º)KÖ]YÍ>¿¼3Þþäš~‚4»@fÈÑ*Ÿ¼]–¬„ÐÂ8øXò ›ôÝÊR _X<O`kÜn÷‹”„S³¿mE[¬zîú!Òd‚R>9aÇfO™‹Œ9„—ô7줤ÌVZEhtÒ½®mý‰5A…ÚvéVý3 ÉÌò¹ë—ïøÇD½9@*'×pu$¶ò;þÒ¡µªŠ¢Xzþ™µ´F¿Œi·jÿõ‚ ¿íøçùWææO'+ɳïÓièÚ£ëÊÿŒ[¶#ÚØôã ZùÃØè…¼ù°ØwØŸlíãÌ/#èÎ,Ÿðn¿~ú¤°ó—=Î;žW›º¢nšãB·}¿Í­²Š4iVe9°dÕÆòËž+ÏìÙtþ y§ÅŠ¨^£w© Næ%{Ü ék:ß­èÍD•Éˆ92N Èú¶ÿ‚’W¸ºNÝCßÇ*¾eÊ€À}Z\Þç«Æß‹'yhž¬Aºçì?“7¶wQš®-”õxyÉjÆ!’7]ú*˜°SÝZf×Þo½rbÐ_éÆi«òÐW',)A£ $ž”Zº?+¢)tæ±Ã+„@ÇÅä9îòÁnJcÇgg²\ÛCsúËéóŒI ÚŸ’ Ó-2~e¸Yx|?ÆuÓú‡ ŒÒ <;³ˆ†¶§FU È~Œ¢‹ùÂŽðôÓjq ;W~Ú>xåaµ´ô‹|Àiù‹µqŽ8=‹þäi›½3“F!ŠrOM_×å4Î]ó%AUÂyrZ_l@ÛXåoUýEšl£2ºé<Ø1|ÓJsÄÐîaØwgÛ cØ‹X1³ãÃ8)\•TIêû½Ð¦YÄÏ–)óÃp S Y¼ÔûçŽHUå|C݈if&õnà—ÀÓi[Õ¯lûYû»ß;F^‡Û° ó øì *,­q«Å×’D{£Ýý#­&ò°V¬èA†6† Ø»ÇÛâSuòä˜Q…4?©•FÖ§;1MØfNK–а+ ›ÊíAÉEþ>Õ0/±EþB~}ÀCâÓ‘×¼§Iµp×î7¦EÙ]‡­¯+!”Ü/ÏhiôE¯Nñ Óq¾ŽÒ:ó w‚×úa–&±-ÍXƒ ^‡•Eă/¨æç¶ûï{¾ntXx›ÍÄ®Gn\¶~Ÿ·3m‰ƒÀAfçÓ•Ý®ï=ÌÔUM,Û=ãæÔ ‚áZ/~„FœðÆ¡ó.è7kÜFÙ*ô`¨L -XXæyÂú›+*z;رn˜Hi QØÍ} -^Y2wè`˜²u'5xÒ–¨ª÷®0o*W³>¸=Ò èNÞN8TeùNšr'cI,!YÐeTœznû”*C]¹tWs–ÜÉümí‡FN>Ñ FÖÙˆ³éj~æ¥8Hì�¥—ÑI©5ôÑq¸ŸÇv¥5ÿÈf$abœüú@˜vÁ&™àIvb‚sfÛŠ¨ÞozÊYâ®áS‘$A>iÎÓAàöx68ù6hlIÌ )9æ%¥>uõÇvã¾Ga°ÿÒÛ©OÎ7wcXß&×ÎÎ/Z<©–ËÆʼ jŽN„lPtgX(ç<uÇ:,UúP•Ÿ™’ØÎÂTh¶k¥&I¶ª2ëäçmù²‰Á·Ãõ¬,i{ÙÁ†7”§piÍ÷|’ôø‘Y\hÛ:²a'lÌë³·’€y¤ýHÏè½ÿ÷fOÓå)QÐ*¦ó¹×[ ,œñÐSæÇ‘)ñ’½èµ—{Ö?,@|©é‘›3xS3E[Ð(äÅJ©?¸ôlQ³¡�tb ‘öŒ˜¤ño7HQd5;ª£0«ßÿ¹®Êb|p7Ì}ßjD¸Í[è)µ:Žõ²wGàKGHœ¥Nn4FSu™h”êÀüðǬaisŒVŠù7>¯‰‹ÑrûÁv(?=©á壼ÊmpÉ®Øöñ@'iW«Š‰ÓŒ)¨i xÊ¢=\69üXãЗ·£g¹Œ•És#é•lŽ—–Ί9 £XÓïWÆSFÆí:^V“¹P=·¡)æeÜ{>‚€FVO/7*Ðó’ù§/«¹éëS7¬µJ$Q)”WEQÒÐS §ã÷tä©ö8‹TµjäË`wœE]мº\2úŸ¢¸ñž[æ¸ òwÁ€ŠÊtÕ=íxræîÙØ tÊÒ30ëƧ¹Ëòø<›P‰²“€¾9ZÊœxÅ45ƒ®ù©Ú_ÞQsHÝDŸçZíºÿ:y±¶þ³·mÙ`ÙËÀæo!ó¬$4_Á[87ÎUue×uœñt¸¿˜ûéè0Qyê:½ åž)ÅÍéiX—ºµ hfLÂÛXíJ/²?bŒ¤•QDËM®²a݇Fs ‡z“ÙA}y¿öp ÎäÄ ¹8Ï>|Ђžó^ëÑUÈ™>xuûÔ©SŠœ!¥@ÕÙJ  gù¨Qê¹ß«zfÍ«=1¹£'°¯íd%f±GŠà¼EéœÃéît÷¿ûh¤kõ/0tF¿"K˜3üèZ5I«‡ÖŒúõ4X…ÝÇìµÌ˜ÍhW…»OÓ'DÇú´f3ŒU½þDò=I2ÿ@¢9�;’^U�;EÉÑÕ0‘št8c�#K²wõwµq«xªNTG‡hÿÅŸ7ùvÎ4“~÷‹_qô?ga´»æÃÕ4ˆòÌ „p£…áW ??Ñ xß'æ^»‹Gzº­¥’èO("Þ¶Ðï‡ó¨nør¡sF5]ÿ­žaÐwåˆ7’Ž¤ô˨ôób0\öõ òc2Ÿþ± ,½¾ƒ÷óÕÁ¬ÙŽ}žF“Õjðªc7?ß‹óÕjùC,¡‹#ð ³Ï˵‘²Û€ÕÅ}h–¶Ïì¹ä¬Q¤9´.›x2šì~Pÿ9^u:U¡oÜLÿá Á wûŸ…¿¯Öwú©ƒdbvTRyku˜ –`¼ÕšEržHådžn h5pá¬OX£¿›=Ûr|V‹ˆg–\¤GÖ%̓¬ž¬]#w­F–¹<ϯ‘]zÏÜ)g!ÔŸtÈ2·î‘s´|¹'ÁQˆo–…ô÷l¤ÜBÄÕ¡Ÿð{ObÝô6}'{miýÐé*Ò7åyÔ§âxÔ5mŒÅao ›BÜ`j Úî´3œznP+}K±tÐÍœ³üO=;rПa':ÿDØp°åÖa7ŠÑ'4õ-ë® BÕWÈÃó™v·ŸÄXNÎxö†ãÅûèÇúCL›ÔÌR|9Çoqm¥ç÷ÅýZú´iŸÕŽ,abäDUíWmØ.Çöpd wõÌJ/ñI>:_TQ'ݻ˫†ý`13Ëãà¦`q#Ê­._cášaÈzd¾jÄ!e«¾>WkŽ<?aÝÀ)''Ïp«éèZ,}Ž7Ž9s"/d:õÒ6a êÊul(®ÿFz#ÎWš¸"›6ƒ|>{2\Û{böKÇ 9‰Pm-é߃̴?Ê¥wZŸNô®º9åEmoõÃ=˜A¸&µõD »ë½£ÖèΛYèÏ)ì­#JìÌ%F7ì¯çS§ëå󌔧žýwÿÒFÂ"¼ËÏ�®[o<1çî~þôŒÿÅvÈ$ kãŽRÀ„ŠoÙ=¸2¡Â©™ûnØšÊ0Ãöã?`é3áû¯ìÅwÒDgsFDÀ˜$ÄçÞS÷¥`óÆD)Ú0þå‰`ûžúŠéõäd:Ù‡‘çøw!@Îä*7ôXž'}ã¤G£_Í®£Gu=ùÍÔˆÌùßïS¶Ðyˆ%„…Q³5á ßÛ¥œ$<@]yìÑ3ÑþD)í×NÅŇî j_µ¤ƒoVe1ôþ•9ÿÎî>J ol˜Ÿœ-g*;æ³iø`Žl’N©::cÜØœÿý—}’9ÑX=ßÛ‡:ujÎ}…\:Õmú`(üü]vèvWbjÌÄ=ÙC‡Þ´BfÊ»3Ø·ŸZÈï¦ëv ßdGË.L1†ñˆðkB’ý&>ÙŒ=6Â`¬ܨ|K–P®Ø}A«d×yïû:ÁÅ ¾ÎY)}™ôÝ@†‡Ù§à=¡³ù˪`ïQºÉe§øâ2BMíŒG_´Ç¦}jÒ‰˜V óµÆÀ<s< õl9&svW?¯¤ð”¸;°éiktª$0<æßÁ€ˆõ;űU?7ÿÞ(¯ŒWîãÙ+mªýh*|ï Bâwè¡�•Ç|V>ZÊY/Îø[ÔOXm~Â3ˆtÀÈð:$¦ÓŽª´lÐrY}?X‚ûBü&,éðÑù×Ò”ëÄ΃,$¾ +S[x&Z­Z@®_è,Ô|w¦­iñ³ëÌÒ_§·åÚn÷Ã?zžî² @XE£®­-Ž¯q®ƒßEµGø^�Vës"Cs( r«Þ† ‡V2¡TÉj¶ ”MI€5ªÊ¯*#Ä£‚"±%yÙ“ÀÝp}…çýOì«yå@au_ôpËúj'ÇÁë6BtjÎçV+0´¥÷öºn%òЛk¤ø¤Ö´gkçm7쿾WG¯”Kyì \³Õ9©Vâ5¯´ƒ£^ ë¤U‡bZÜ?úÙSXñª0 ¹Î§á§ZªÒ%ô‰¾›öEÿc[\*_@ÏÁƒJ0”jq0ö-l2LBÔqÓI^x;é@÷N¬Ž³Â/üh9nUPŽ …àØ ð@ZÆX@ÍyÜÕ¶Èb4Ï[¬9ïØv9ŠAPÍq¼Øp¯„ñYcJ–›5ƒbLš)²^‡N¦Ò×npÆ K}²�5ÇÏ ¢5 °jœ{WÈÎ-7Ïúص§cƒˆ©ûâGróªHJ¥Qc /¿ÚuÅN•]J<ZÇo­üò•ŸnŒ{BK6ŸÎöð?Š®±D ¶Œ-Lhûã) µÐîï3­JS( µ @&³E«ÅL»€˜–5Ûjp¿ùˆÞr²uû³¹ý7dÿ¤ònW.Bþ¬;hýë8 ãQ½í$êû…Kº¼ÏÏÞ¶O‚´ž<Zèp5¹7*koÎiíáoþºìÉ®&ë5Ázkh¼)­Q ‹Õ†å#³a¬&8v’#“Ã=�ëÚÜý54kÒÐ3@@½”qgÛœ0Vö‡ùxÛf~›‹Ë#âêq¨‚p˜Ôê60æ»Ã‘¿Ë–÷L§ŒóaD»5 J‹ƒ¬œØ@Ùj¨ƒ ð+°h‘à]8C­5«ͨ¹¼±zŸó0ÈfÛÅHÑ»ø¸©“¯Š³²8êÕo! ™âá%˜“#t1äTV<yݳ|¦þà)ØÏM áï3ªÐa426Þ=Ðj: ÜÞ$ðFÞü¼x¤÷G$¼¸J|Œ${0°ø:4—5·5§×üEüfjiÚt'[KG¼ë¼MEGᧉ4Õù ".=KSƾZ¬U–ŒJÞŠ¡ö Ì} f••Ô¾G߯ŠÌÓª Á“£¼Å²Ix€8ª™ý÷²…eêtt2Û[Õk¨€$¦¨j§«•Y»§Å)ËØÞ¹€©´a ¨cÓõ‡x§ý9,´^CÞG©1*ÍrO”"6SD³öv!ç¨m?1(¡ú|˜ŸÊp'(ò,çQþÈ>àšð7,cº,¾«nîûÉ~,B)ï£Ì¨rS®RXxÒçNœôœº÷뜱<Î|V:÷`èmmX±  ¿Ò?ö“7bz0iJW¼Jž;V£''5tu¶¢~jÊDõ+{—‚]';¥§Ç¢¤ÿX°î¬Æ"¢”ñ pa%ï$ñ<ˆ‚õ ­š: aÑø‡®¨°p Gó¿ 2DÑJÎ…þÎîŒN~§G‰n— bqÛ)âÄW·"º <Zñ‡c§ÉÇ l*Њ ³¡xAZçžàz¹>¼Õ2`‘\ä¼_f¶þí\ÒR)C8S"k?«i2«1\Ù®ÍbW¥]³êÚøƒ‚ÈÙ÷'dÇ‹vÚ3I8éè‚P°pÞÃâä ®ÿßo]{8£¹ñ€{¾f'è¿Ñì­6ΊáˆV§‘Åãuñ¶‘qÞKç´•.ãóós¨ïV«9’Gg–ÎÉݧl|;îˆÔ~y iñ[8]*~NDÿ–ÏþØc`mGKfÁH2×€n€˜Ž.o0þÔ{$WM7¾™Ãå>73*D#®•%D¡ÍÔ¦M7ìXïSÇó ~§‡…™„™M ˆU[j¯€yµqVÒÏÏxXï©w¡mCA±Ödûuœá-ê0‹Co–�YÂÑøSKùAmYº™÷°©‹Ö ¤ô^œAe꼘O0ˆ©e­Šß¡1uý‘êlS·o÷Fåuf e$�-`ÒÙ·þ™N•ˆ‘M“e¯úLñCÐrë]·þèyJMû¼}½R¹Žòò&XˆåqÓzhh4]Gwmwü{ä8- ¸§4Äç¦Ðw;ªDÄ^=ØɨNäæײ0®9›-=Øž“À| Ó19Ø¿"éºæ{ÃÐæž/`µYó'Ù¥>; <…ßu³ïÅ ˜xCŠž¯Y·§XÌj@´fòó [ȹ‡3Šˆ!;Àß û—E®˜ˆpê ëmNÕ}™ÑbŽß: ™£Á" 4ÝPGìRa@J©wûÑKÌÍ÷‡@¥Áþaƒú´ú÷œÒ;22¤J—-ä Û‹óv¦ÏÙ $Ã�¯Q 2lÈ¿|Œs(Kߺ—¢ì€¬UÄ‚#ãì�?[öÆÙÊÛ9†± òéËY/ýñPÏo»}3Û¹>sÉ 6÷m'ÖÐ!{ú¸û¦æâé-ÃÓdó™[–jy•*믋Á(TzM‘­½TøSp:eñÃf•_õ{b¥Ý ÀÙis¾¥F!UžâjKõ¹ÞݳåY”­­´ië–A:ê9PÁ™cꂳ_~eVm—À¾È×’ÖÎîÙ¯x ¾£çÿüd‰ØyÀ‹Šf§x9nUÑG…K˜Éî@ÅÕIE_çS7¯Á›éyÄEtÁä„eŧ½Ï°*éÔyÉ#S>:Ö»`4»^Ýat¦•ÕR¥lvöÍ»­'Ê Mß:ûÞwøµ’ßF;B¼ÂIe­QÙ‚ÓÒUPáT`¹#fâDMÊÊ÷m‘Z>T*¿€†½ÃSTwÍü̹(AïèÆ™Oé†élAeçdËN�Í;hÙ%·ÔYiöâ[G3ÍmDÊ A~é ZG$¾j&9x (ìÇJ«Oµ°"ÛcÊ o�  é pßFÁªÏ/Ÿ†-NŒGŸª.(¹nà.2¦n)#¦dÉçÕÁÙ·µµm£ÊŸKŸ¾¦àà¼:Ø‹;«ÏÂuâÈÜ£MOI}ÜNkBàŸŽs'­ù/û‰*}Y5.í±2ð¢±Ë1¦\Ôœ|Àã°±À©·À’T^î“þø]ˆSýqíA)âLKç�cÍt=ŽE÷¢(“âÝ¢ÂèJ5Þ+yIÄr•ò$4Ù_”â…\v÷0@ܬé4•ÈX+`£–ÎAʽ:Ã/÷Û־ℵ>¾Æb£¡U‘6ƒ§)ÍÂ-L’SQ»H[âÌž+vh™g¾aE¡ô¦ âærYÑ™‘›|VÍð2bg¡¶€¡Ó‘¶ý½-[£U²“@–¾û»‚èDÖÛ$8Ó2‚8´QÞh]ƒ_Œ³$ôûs!¦çX7Í¿ž:²ùMX.WãFjì•ê}ê®|x¿µLš*9ìCeuÎú£“¦¼Ã›!ie¹8Ø¢ ò§ãÊß&E®äzJú¾9Eð= “U³, ]cöÓciŽ0»‰àˈ p ~êóôÜ Y˜¦ÎʱoŽõÇüiË“tù±†6RéÔJKŽºÜíøU%œÇE¶*èY ©lTo…6Ï{=CoÐœø÷¤¾‰"Yål£áÄ)1UEƒ={¸t¤c%Ú¥¿×jÑð8.VSR<½& ŠóÎk�Ù^­]îHu„†6¤ÒØßÛ]ަީɇzNMç5kÿÀ;±sUâ¾e™t:oæŠyèù¤‰W(Älë“—º/ c-n°ø¢÷ˆ©žSÖV»bçYÎ*ƒ<:Çä¡£:‡¾ýt¬jå€F1tì¨&8/ÊPÍ™´~•Fs°ýOï]Ý&×IX¸º€]’ÚåYsòfÜ›žª \i¿1|rÁ©æfðõ¡ÀmíÝ3O¹šnÉ\ÀbÔ»³ï•…¦´§„ñ\#NÓ*[iu~`H[Ãôˆ4¦iÑæãÁÿ'ß‹ŽY—ŽXÔ„öÂÙ±ózÒä/—*µ“ëRïÎîsÿLªÖðL(ÐâËOŸ^7“m–雞™ñ 4P‘`Á€Sèif:³óìuk¨`4 + ò¿sò(=„+àΕG¬<åq Š�62XóioÜÿ ”Á]Ü™Žf+{Zº»! "'B„=÷G:­ºã¹Õ—;nÀqlkFqmÙò n´˜Æ ¦þ{VÃâ etvüZ:p‡ÆÝô;IDV:c3f`:è±ëªÎQ�ïœ3ÞNTFxM¸ËCײ2¡¼xüVx‰K5Ž­¯T…õ´U—ÿvØÇ+rd\ZŠ«ƒ•<KÅkB‡L³Ð Ç1ÿ={&‹|ïÞ{‰r ÜWÛÑóHfBÐPÞÀ¥¥V=̵ŸûÞO€«ÎwHyÑ<xÕ[Œ v6Ûíë£ .*qÈÔÛƒ-#>»UW3zpºˆ‚Ó~XØÀâ¼ùP€Îwh>~ìÎÔ(¼Rt?Õë˜ÎÞÝñ:þõ”³ôœþœ<\4ZÿUCëÚ¯WŒežÐX‰´ëm¬8 ÃŽ·ªJZ† ¾gÇ4%êþ ÃGcš�ž3Ð{uÊ×…êªa})ÊÒïFÅà§K´OÝ4_Ú3§#e®ù»áEÆ lèjñ<xãÑ¢/ä!‰yz˜šßüÄãŒUw0�á›YŒðÀèƒÅƒ|Ðòãù*Ã%ñ<!D­©« ²b‹(i•ÏK· 嬙@ÖMÞÉ}#Âd-"„¹i”µò�¡½¥Â¦f–q8¨o©¾®-4=i)ÓÚ†"HOj!›2ù¸6xWú—’Õ¸Ðõð˜IþìšnDÓGpαG!߉®û` (Élï5j¢ 4-L^|R3€TɤÛáê Û§¤X±ò‘Òb–1›`á)1±XÆ€Vp:^,ßúnü°ÒIj-|šè�zßš–€CuÜ1e–¿ñæx:Ù „ÕÍìëê1%Ñê4Ƭõ£’±5ïj¤a©•jœƒXE"]æ¬Û]Ý]¸™WŠHZ;3ZY­VàH[Œ«†?míqpLЉLuºÜ ~¥RB¾·KQøóDZn—º ²E[Q¬ÒÙ/¢†š9cMqîÛ¥^­û?ùÊÖæP®´wvÈI"êêVðbö­›Ô¯Î4¢¬\iÏBÇŽA:lêè4À^–²ð?o•ŽœÜ¿1…¨©šVÏI;)ÓžØu+Y,J’’Ë=+©õrmt~ç°eQᑦڛ-8å:÷e9>;}Aï!­L›BäéÁCW+¯Vlp|UQ‹>,r*ŒŒÑÇÖÖ ‹˜·4úŸœ+ÒÄ—›E¹XSÝYvzíè öôíƒÍ…6¢éÓ·ÆÄvH‹öp”5cT4h=hÈÞõïyâä{¦—‚eÕ,§1‹f¤¤_Åë¨L¢Saëó“GçÖBb²-v°qùP¨'³oëÍfõêÓ.1ª¸ßŽú–¨(ØÝ])¥— ©£G·ÛÏ®÷nP$~‰{[ïúöUàæ—?¹w~ÂÙºæþ´*¨¬™¸Ï~ºé)VPô g0äAn‡Ï(¬a!ÁÙáé¿;\cLà&¥ÔU5ž™6“Öί>(ôÚ\<mIÛɤ¨ð|�áç´õŒNqÈP�³ýãŽEùáÔÓy¼ e™áº*bèЕT²* +b{¨a�ÌFÞñ~yæ]ªR¹ß«ŒDÙ("KÙK¸BÏ{#›md&_hr 7عï£w¯ Ph–ðã}È3o ŽµˆÙجY(ÞO"Ú¡D�«ž6ÁJ2Ò)©­ÇGç`ùÆd!hÅI÷jú7_hIÀ‘iòᛑJMõõÕd'\{sÝ䱌—îòaT Ÿ9Œ&Ôïiü˜R¡ <#HØúGeÖû×Çe¦­v¯“æÖhL4ˆ ¤§£M‹ü¹Œ Á¾ÆÕÄî›Z–ÕÕtzJ-ýé«ë$«˜Š =‹Øž¾.=Ó¶pæ^enÜAøR'A¾\=Ô5¶×Ì<xÙVóð™; £WÜHÓRÊØ4Æö:í~ú轩æwÏc8O^d7ê\ìéZEç<7ç‚9~íâìì ,� átP´ø®m! ¤”Cð*¦3»?±XÞúª@Ï„VNôÚ‘þ µí¾˜f|m½£jÖÂ`õ߸è¬òEâ©®º4H·šaöÞ àì–ø ùÁÓénä5ñ]I)Ê|û°‹žS:ê.Ì“q¤$õo~ʼ1ØQoóçÕuâô�Äf i² Ÿ-…ÍKq¶››Vo6º\½Ëþ:¶Œ‰[U@iêª)cìæ4 ²ñ_ŸP†4Óηc¨×–£È7 /DÑ%¦ºÄj—@}IOwÅÚ•û‹øî/¿‹CùBüç¨2¦¡?6¡(,¢0·e{äy˜¤…ÃíÑ…2Žz™ØP«åóÔtÛÌ<%‚h\æíа”�–Z’kVX+zÒòþß‚ØmÜÊýÎpÊyì ¦Y×yT-èB 3ŒRíü‘Ö 8¨ÅT[ÓF?½ÞÏa?hˆÖ‘|6{¡Ó´Âô“6RÇãE ;á±=¡?Vé�¥ž`Û<ãÿŽ_O})úºIP̳ãš”mæS·¡êŽv™'ð@V�7›ˆý2±OòÐÓrÇØ>Iƒì¬:V0#êÆz/¤ktyhCÛ×ñx‘ö•ŸädvÞAQA”˜¿:³7ÀÃYnWüöÏò½•è]æÈs¨-Ì4œ�‘ºtN)XPõfêT{ŽHØIÉ2¢©æYç‚”W!”síÉZ<p<°Ãi<'.÷1CÿíR|í£Ÿ}ŽeÁ3£4 ˆweÄ�¨çÙ…êÞ‚L¥4߆QHïCÕŠTÚ]¹a¿`;¸SQÓˆu~†sDzòœAÑ‚ž‡»úÉ~Àh¥¬U‹Žk¼hKX*úìW/ÿ°T‰¾ž»UKû³[‘Ü°€g†(F‚Í Œ‡ë—òV¼y;)-sß÷îÌõÿÃFÀOõ¼œ'oÎ ›½î'a[�ej®z¦§ýéÓíXþNlB$ËxhUÅvž+ýíùƒþ‘îf‡oç8ž{ï Ô%N}û@t+­Â•ÜQŒ'ª/³FuÎ0373NæLOóG¯~[86L©NLMõÀÜo@½\í@y=I'S«Ë|aE zÊC·ÜÃM+'‹›ulw7Ð[9 [´´D' éFP�ŒìþwëŸÐ7 îIdžÕ,ž!N¸&4Î QHí<K» ¾=Mí-y«Ññ$­Â¥C¤Ú(®}¹ï®ùðš}`lÔ )Çj%ÙDx#–35øO!Îߊ¹ðÜ”Äy€<Y9µèJ冀3.éBG9•Ë*žðâ©Ùi}¦%Ú–že¶X{“XÝÓß»I x2Ýr—Ohõ•‡ç�pÙ–AbÚ†{aÊYc>ý"cŸÙ/+ëé)ÜarrbFÃF*™q½ç~ýø§×Þ,qXe^2滢kízQ-Åvu¬¿Àôb³w)8-Za5*·UfkMŒþ+ªSgEXýÇF˜Û r,t Ö_öõ™v^éuðÁ0C,‰¾¨œ·XÊõ»fÐñ æêz/ ¥ã$AöÙxJ‹¤ÛÖVtÆÇ}îÊD¥›‘ælB 7†ÓèùЈÚÿÒö8Ë ¯c@xsÐä´óÅÅä ý6:\7FáùÅÍK<.•jn°[ú¹-4È:£«ÞjËd�^×y[ëÚ92ü|¸\é¯ñË[ƒlá8^ôŸ^'‘‡•bƒN¸×‰U„†åJµšòùÉ¿ç§TTf~'÷¥`ó¢VËÌŒ¯&c¤hþKc+õ…ó4wðB9fÇKVÓ÷TÿÙ¬½o­ˆÿ󖘾AAõõíýØSŠë9KüFÖiª² ¯,øÓ+E41šÂQD•Á0Ì Fæ‚Ë~ñÈÌÓ•ö]hƒ”¸¹Ô·ÝC¦³`[½€´ÐH›?yìzÛ ÍÃÜ;8}ÓЖݗ™zwAS%tÐ>ôÄ»îO' A˜ì]ÞŸ·Æ…“)–QPˆ 7‰pÆ7ÓµÝ×ã*1yS/×ø2ÀÄçÅÔÓ}euñùTé²86¤QD6¬Ýû=ëûª*ÎÀ,Ö‘úiѵñ¬ØL*g8F¡o�Wd.3=B–½ù‰GfØL‡kZz´Q¯‹²ÆÿØø»Émr,=‘Á²²O†7ð„èç© �‚ ‹ùtõHMâb r7ZNþ–¦9;šÔ˜ÜÎÀ䦓²…–îp:ÓšAî?o±™¼Vô•&6~¥/Œ\QüÿÖ-Â'ÚÞéÚ̘kªc÷ý0̼!±›ÿø‘Ñ¢³šÏ ùÜ$AºÕÀ…$¢fq¦ýÀhpét¢ùb Ø*kÊ,„žùgeÞá]ŠÄ:-ˆQÿJð©¾ú{†¶ëÆ2!”Ýþ3¬²0cߘUã’Š¸aPÕÿšç÷†ž¨SþÅ -®\æ—0Fv X;^=»újš Æ]{¥Óò‚gœï‚•š-g–ïW+œÅ¸DqTâ ¥Ù#°oóÞri>Òø. ?¬`À:ÒÓt– ¿·5s˜ß|xп¬&§«ëKÇ~_/IoúxÎt]Ž}Œø‹%z »Þ`ÞœIàƒ)±7-ŽVaŒ–(ëY§#Ì2[›š†n¦äõÅ•ÇgTR­D”èýóŒºöÌ‹ÔTu¾½U@™Oþx ÷н#}F#ÄA.ë•:±ÐÞ±¡3ˆºIÏÙÍ+×!+‡h.xˆƒWïž®”ò†[b²Ž¼jŽÍßçþÆa' Cä #,:µ¦£‡©âš¯¡Ô¯©Û£æ® ”DªI;y‰ÉáÇíµ ¢scÒÃ4p뮜%³ˆÄ¬ôö:´·ärÅ.¡×vEó护²²Éš,|~Z=‡ƒ½Q½+R—mD ×mjªdn&³´×™ÞÈÌVÐJ°ÿø[¬ØZÊ$Ù9(QȬFtÚâ8Šõ&KÔ2UXX( 8é¿™p¸fvªÙôiJ9´âRJy§ú¬®³TD§-Ü3–·¾Ã—Ë=M¼Œ”š7;+f¶U³K§C(>Y:3€–> ÎLnñC΃úƒ&þ Oõ¿&ë_àîá"k²V™vÅÐQDI.'Ï8¦¦h>ø]Ç;N# ¹5×'Î#Ò¤cE“,(ßÕ#;¨07ü Ï}9éÇC;ݓ㉊ tqÏE–+ hƒJ8¨¥»zÁ±'QË´Hã @o0lÔ ¯Êj£Z«ô_= ”üÔ‹NK+ÑÞ^#/Ó)$ Ý{ôtÖ´àæÙó+¦—†¾‚WNU{ aÓ‹‡ÚØÂ&e2(ôV:óϸÀƸ~_¦®`Oš¥¦;þÙšåáf*!.W:µÍ@ýÌœ`­¹o~d©¦Çû\å4cá]�»DÄJT1‰r/žÀætÛˆdÑ/ÐJYn÷øjÑ!A+ætòôAÙˆPŽ®ÍqÙaøº~³Ïä³b¤”£²: éÊÿ•Š¢/ï“›lì¯7Ë2ŸçѲ¡}_+™•…EEž»^™¡|ࣂéñÆÄΚÖÙ†z£"—ëts’Ø%š˜ §mç5sz±'çsä*ñ űõ¥Ì¨’¨^·ó 3í5£\õDñ:q;6°ÅÚò¤ÕÞr-¶!Xf×íéV?”K­F`hDVˆéîÓCˆ~žÑy€· §ñÒà &‘!T>¥Yúú®Ü„Øô¢ndÕ÷hMš´ê‘pïUó"'‰+-‚ÓDo5^¹Pdþñ2ý¯Î»’ÉÓRWd»àe)›5RiË55hïiWQRúîâ˜ÜFä2Sþö ùK‡kq\¸¿y‰DÖÚeüvý>Eiâr‚|÷xŒ×FÆ̇žR]u_2V°¯õ7Á9׆`5H|ò1ɨ­A—…79¿–Ú§§·ÁÝ{¤„UdIäð`€BpEÙª‚´ÿ†Öl;nµÚ×Çev#Þ;NYž†;ƒ5yk,ÿ4a¶L9ŸhSŠJÉÑé_+¾‡ãïËS#¤ª [Ô¼6ÒÀà×Ézžù¹:8èô¡c[òÑ¡ö¡Ã÷ 4à°ÖÍGÅü̶öĽ£Ì ú96“J.Å,«ËíF&;¸.Ïïcè<ñDM}cÈÅêyEÿÌ3ÁË’Èx«|¢añ›Ø/°üýì‘Îf\jÃìKJ+ óÆ;Ò5OˆµÉjgα£7Oª¦…y1,¨ït\Ôóñú£À©ý"cLw\dÏó²j]…ÿìyâ­y3[«iKe—Ö´Ur”¼ÍÞÃ>¼-ûÃIèŸô ¹ˆ]õ|LbE •,®ÇXüBSkÅÛÐ Ý\Q7~HNÒü4W/h5ÖÑŒŽ¾º»£6ªî†®±€ UÛ¿}½œˆlg<AÚ±¹TA1+«ŽEZ©büÏK¯ 1SÅÌá(¬r‘àÏ̱ÁöRùÈêèúþo"g-(ãs¢ý`MylT;­<6ªîö¡5®V¬ø85^ìªþOâ|:qu°ô‰çÁ2ôåW™ñ—mAÀ&F¢Âìä“Æhä óPVT³†zAx+HUۈتӽunÓÔPL*Ñ\€¡ž;GéöãyVmâWD"OŽÃ°<`^Ùn=’d߇7V—Ó�Nt5åv”'póèúá#_9)SõÛŸ Çeœ,YVMTs<+yu!™öAúÐ); ËÿÝKKgŸ0G²·–3§�/yîáßüø®œ‡¾y0½õ8¦A^[!´ZŠ«Î¡…DòsU4<¸¶uCú(™œE+2kUa¡µJw¬Ž±Ð+Šaᚇ)Nô‘þî—Ïž -i¬ƒž·ì‹ÄG—਺@?áËS3¤å†¬¯°jßuÂóøö¦Ud!›2Y8³ i;T§(‚:2É*hUXd¡ |dƒJñtŸÐPÆ+ý~õEPX[kv©¤H>®[ç�3ÎØ]}/Ælbcdsˆ<ÒJT “•#/‡7Öu”ûü7yn˜$•á3EÆ¢?©ï7üiÇ_gÚ4VñofLÚU e ›Àó>¡ç<zNc¼Øe­¼jto‰82 L‘Ø&«‘QpD8êŒÓõñ:¿D3œM“IvÒ`¦³#¯·n S-c<ö’}9¨7'–û}üê\{ÃJÅké1NÇ·Ý_•0γÃÉì…a±¿·Þb«¢{D¼\1ò-ˆóÙ^H}£ƒÏ�ííl Y¯öb­T§ûÝÙoî—ZÞ1Ó¦5\±œq‚Þ¢çn¦:l#žgú’l*•ç–>X²yèCêhs�…ò®YÛ«â‚ú²¡<ÑÁ¨3Ý螺âp%^AÆ> Ò{sÐõõp|3(‹ •EWYhü›œ}UVzž«õ¦e% =mÕ61C˜ý‰æõÉpZ�˜(¦òIP ³gḼÎE3%9 [îqo>K3_b(3¨þôxmx’´umy;ìî#¿êœ—‘4BÖj¤$zÐÜ6cCÔóè‰b²1Å={ gî›Sf:ЩÏöþÌ�óiõü|+’4ôYAa!ú^•µr‹EO€“mK<a‡€Ú^“ø*W*a/[Øk´C§=ð™G¯wÄúÝ»ún˜›yYbɸ Nj\1NÔëÒmu±cw£ÂÀ­%Àº#¾2 ׶ªJmc¹’ùÝø¡¬ÁzrN»‡ÿ¯"’p$+>í›pJ:&K›°"e¹Xj*²íÕÈïrçÎGç=ÀèUÉÔ|[Ó[;#´Ýw”ÉÚ‚ŽY!qÛ¹š¹ò8QìØ*V0«)œ¶Þc>Ô_Ε-V¶%AÃe¹ýñ�ÆiÕ?+U:/4nºt´WA¹ë̼ ¥&ž‡jÙƒÀ¨ì'(÷ŽwÛ#)ÇÌå³õ%à$¥žþà†š”ÙÁèï_®Ä ý—¹&c´]–™•û…«!0˜ŒåVÚ°R¦¾:€˜ñ¿Y÷§ò|¥ÞÊZŒ˜R÷Ú‡Qµ l²é€g˜‚àõNXvljóŸ^Ⱦ)1únyìVº;ƒÚ²U·B¬ú‘¡(ØlK«ò .›sÀTêmñoP•®f¦iЀˆí:=Zäjƒ•Û‚lÚ«ßÏÇ EM4èœ:é]’j—î†o>[¤ë2p†;¯õàwÄ£¤òa“ðg˜ lôã.†)§ULé… 8ÎrwoXN3òtPÖÅãî„Ñš9¸í/Íçý¿74C_INëËíÝ3V¦œHSÔï CQø!ˆ’ª¡Ž�z¶ j.GÊm(|Ê?XÄ‘Ù]Iz±L¡‚‘XÕ|`æ+® °ì'Z œó6÷¤‹÷ÚA'NIç„6é}'…B€¨ûþW=m®&Ýê„<Ô I­s$÷¡ÐkÐN­ub¼ïÙÖYš¿M9c¿ ŸŠÇ`Æ¢+ŽKtäþ½Å£Gº2ÿ¼/yT¨´©ˆÞÄœKÐSÝŽ:ÏÇ«=ìábÂzmµñ~7¹Ã÷eïÒE'ñ ¼ê•ºzS .J‹ãL•ZTzW ¤W£ó§ÙN)WÚ€ .Ú«–_UÎÖ@o+ëαæ‰çß#2kóGÎBéÎuˆ¢2†©Ì„ðôªPÊ4]’t#N�»×w•\rXW™™íÿ(Ð]ÉÚÁ‰èüŒ|7rɵ2Âò²a £ålݼòZó$©âЗ¬¨èéf”¯YXéEª†msrN¿”ý±äê84†Ž9Û«v:*#ˆ3šåi´K0ËÞËC£8έ Ü~>Wþmµ( îB>§ô—~s²ÜØxÃmŸ½US._x-ŒóC)ÿ†¾†ùÍ%8„ݼ?÷ظÖ%Çž©£‡ËnVxéç$3RA s»¡ž©Õ“OýVª9jãX÷³ˆ5·9''E Ž'Tn¢vñü;DQ^BM7ˆÞšÛ§óÂ'ˆ¾zX Ò°×7˜þ§.z8ÓJ‡$†9Æ÷ hôõ¡+ ¸MÌ,¨¯‹ ],çü9À¬åÖ8Q­z„Ÿ»`ƒ;óÕ4·}N©¶Ž_”©¥×Ϊ€œò[.6gåD º‰{?ë1yÂ’¿&³ü{—Énrù õbúïØïáW< +ù³KCÌU|v¼h¾nÐTìÌà‡êÆ–‡µòò­Ñ‘yšVI÷YòÔòú㇥–w_, e^ìˆÝ“î‰"ƒ/‚äkv”µî ÙÄPÛz²¯w±�ùŠ ©æzl¼AÉG}=Ôg}Hü„(&òôt:Q 5=Ðv4Q9´r‰îP±cÿÂxnmŽøê Š+x€ Ub,šk*±yË/H¸s1îÇhgçøBœ¢h·�ü¡g> :ö•ËîäÚtjByçè+˘h®”)ÀËn89Ý„v©²ÿø°|êÊÜb¹¢UAeÁ¢«=6ÙüQ89»ñÖºÔeÚÀÖ±“¶Jö-š˜æ¥—dÖ¼x!GÌÆ"rglhÍ vtªñÆ2±nÍrë(*Žãõ@‡€÷ oЗ`«R©CaÑRÞc›‚‰¢HiQ¤Õµ)´]Pk¡z:Y)ŠðáÑz;£Çg…t¯9ê:ÄÙ߯ï‘þ\“‡uÌú1羑‘»÷ —Æ_Mßã4ôG¿´à—ôÚK+¹¾!l-²¾‹¼î_bhÑPÛHß'·\…-ÅÆw­G7ÂM½#£;FôŒ+´ËÌéÂËÇ¥onš³RlšûÁs8¨‡CýßÚ3GÎâ]àTsMƨ†°+1Ï[º]°•¼| ÆÍ #,Á›WÏÕÎL#Ó¬ìayJ ð’‚°[×ê9G{ÎÖëº10AaùÖ‚f`µ¹¸·#Ϥ5ý§¾¤wt~MÇ'5îoÖ1ÑÿTêDUpuiˆCͽÓá>²™×²¨ñ'‹2 ºnyÈ»hñölí»Ku�F-ÿ×µ_{e,(Wªl?I´ÅÞØ™eMñ»ÆUWø_/1ó…߬¡Ÿ½zJù6Ï¥{ô[cÁ¬OšˆÁ~W¹uŒŽÅñTQñûÇøbÁYæ§ðïër²¤H>#ßd®µ¯WlXµz‹äï©f -iö«3¯7bCÞÍèÅ'&©iFO“›uw éMà oýá�+“›Ì§kó¨ýz¤…˜X+èˆ BH…ÁIÇ€5VŽãþPÏç†-ŒÖuEâ=h[YFñ{½õ&égÂ%ÍOu vhw<‹-=O6G,g_\ø ›Ó(ƒÚ…q†ÏÔ@ ïûÖ0ŒRF*ÏV~Ý‚|Ú‰ô‰Ø„À"ÈƇû=Ôtx^iÕ‡Út<Ò?é{@7èx¹ê?¡V²:à)¥ÉƒØ)?Æ|fÖ|E•Ÿ-åcW¨ˆ½ÇþD5PmÉÅìÌÒ ( ©ÈÖ­ÕÝwË»D)÷¡ßÝ ðø<©".=ŽËˆ¼;¶ë‡Ppõ¿(#®-,oŒg:KØ×ã±Á$7N^“N€ûF©Ÿvµ‹5xvööÑÍ<ÝCøý×LŒ-ɺ4¶)õ@çÌ|1<­ ZK!OPÏcS·bæ~êF1÷¸oÉy*i<Ù£ ”dVüHjÇå3U{7'ª„ðîßÓ2ô¥œ@d9fT\ì«„ÈÜYoÜ·†¾ÎyK˜s«ãÙ�Å•õ #M¬JÌ ‚èFÏŽ ¶½ŽÚ¨Ao‘bT0NÜ×RK :™Û\«�‡›Jëv¾#$1UµLÔà•ûÓÿº„—>PËrÕߦ(ÏÙÝÍë=l#„ÓsI(Só¦~ÃÓ¾·‡3gÀO2Ž2s0úŒé…S’Uo{¦UÀò‹Pï¡på7À( oF ÞZAE^!5ß<”AVÛ�}ÿíyb¶¢±£`“Üå [æhh&Qê(ÀÛþ˜&,à$ Úq˜ßarß=Ã)&eæ‹“Å´¼2¿Ž§ý¼FñØ(zhÝÑý¡ ÌÌ;¿úŽ†ÊÖIÜ" ùVø5«ÁÓQXÛüݵ4퉅ª ÂnÙ°óß¿žâÌå–¬~†¬>þ7†eíœ|¸|ÿÓ{øŠA>`½étÔ'V 7?>je¥Eì²Fæö¢9œø²,üÔk? ýú¥yº hÜTB· í€(cXÂ~÷vÞº£É˜;®`›+˜–eó;¤šUïËÌ¿BB(±æ1(uŒ§…i¸Ã/›-%Å:ßK‚á\᧊[«÷ž²‰è«nYœ ¡˜]ÙÏÿBúç™vjm£BõÁHÀf•ÀÃÑ¿‡Z—Q* ŒÒlVèÓ`}m=ч;yIæ“…§ÞBäm´q2…6F;Ô ÚyLPrÏ­D¢z:&AÖ]ÝY.å/Üå¡W`²$ª|960F(œû”!£â× @È”§í®¾‰Z*e!VÔê©£‚$»zc梑qÆ‘ÜGt•ƒù£Ûq{ä™±]H‘x#‹Ïé X­÷ ÍdþtÖ³àeÄêÖáýÇ•èÎxðs± o?ÊÊPššù@vŒÀJz€V)›òÉhƦ9žìkSSÅ´ õåGÒU4…oôuåÁd³Xhyž”è¥Ãñ|}4ŸÒðf}æJ€ßu6Bdž•y ]“Ä*gܳ�[‡+ ôûï‡^”+·¹4–ÅÜ¥LÏJ ıQC2Ô)ý`@›ep‘™Ž!®ùÿ¹â `ÅQGû€”QÍHªìë­x~~£ùÌÂÞIß:»óá:J½eú7ÚÞæUE*o¢’Â1˜þê²·*¢j” b@ »ôçù”í`ZÛÉy¦%“Ÿ¯/}/Ë×áÙ·)Z^T™C–SwüJƒ¤žMñ.½Z–¢ªÑ5<±¼V]dwƒkæÊÌåî‹SŠÖ~MÄùW,(ç|çõk.}GÙÈ$B’¯cœ•älEˆ¢"1äuTf«.Ûh<FóÂ\ˆ2…ñ…ùæì¦ ^T†_¦ÓÎsܸlÄɶ³ÔïšáV&šC‡)§gHL7¾Ñdx:@¨©QFŽ@1÷[u|‡W´¢<ò»gq$&Ɖ±´Ý¡›GOÄo™öË Ó`ù—þÆßüóÐsgmgö%kv¶‰Ãæ|³ïMÖSÌÖ¥öœw”dñŠŸ_Q~WÑîÓ,ì-è3(yML ,9g7‘Y5BÁ>à?#R÷jFf‰K-…¨Ñ­NÛs'}¨í€ÐŠ¿pa}µÑʽOoÖMzª:×j- !#þdÚ*áH=kûš´?Å`W©yDzn=sd^¤¶šk»?û;î<<Ñì¬[¼xT13.ƒqG5byéàˆÖ¼†lÌ\UPîkF[tzb’gÖ:$bkJÚ‘t'¾jÏûsº:´”Ý}7¯ŽâÇ…Ç¢ç6ÌqP|6¨`s¤OàèÔÏ‚5êù 3¦ƒGíÎËÉõtpR9¿f€GÅ_^b‰I ¨˜&tW˜úž:{¨Ó®ý¾4/Ý1Á5͉sñw«uÎ0‘C×)¼ËŠn)½å‚|?SÕÖ3÷ýÿü¯ùm@“EȲ�ÁgDÛÓYÌÂ`wµÀžžÆ¹ÄH:I¯[›ñ€8;–_å%Z²¸q&§Ð%w8X˜èÉÁ™¸KÓë9 GDUìR{¥‰;ñÇ(Ru u¾/Ò­kH܉¡3­J¼ üžWn*0 º_ "+ å>]É>Y"6Ý�¬4»×Á°g+¯{ÖaEúÚôôñóA•ò¶°ÌµÞÕÿyK ööݪMfÞð!×Ùo³ï4`€rŸ_¶y\­|AvCgŽ‰ùÜòÂo0-ßùMÞ8öLõ¸;rº÷Ê6Bù·Ð~9ÚD\OL©ë9²röüQQYÞxª! Æš”´/¶’ìé`ëüPsÃLî„8°º ]ì˜ÕØN7Z&21mþ³”á¬lúF%D=Òaˆù#üy¶#˜gÆ‹¶Cõj‡¬iÀ4gºÞ÷µû©ÖöÎ3&@{6g#†Á ·Ç$~÷›Fdóžþ ˜ýF¿è›úLºšv‰f;½ñ§ÊÏDv•_mû¨ò¼3²Â2×ñz¤”ãÓ2‰"Àºã÷§!q?ÍχG¥gÔ+ýª‰¾G>+òò˜PM;DõÙˆ€ Ê V“1³Üó*[³KqÐM-úk.ÿy‹WÝŠ_úèæ‘«q±ß"¤ÅŸ Ë”>\Oˆj˜ÛÑUu®q%zî£9C]éÄÒr«…ReëN<Õ‹œ…? vEeî÷èa.Ÿ±ç cÄxÜx“¾ØJôíŸ=m‰‰A‚Þkã^üþwe ÍLYM̾‹È˜ªÚÜ)ŠhT`¨^ý¥©Þ]—p¥{ƒ•¯¨ˆTøãTÓëÞ²ò¼ÂÞ»¼[öçÙªÜášSpŠÑÈÜ‚,m´Òöƒét¾f›:yáN^þ@ho«ûìÙ;}°Äª›þFâÓ†»Xý1e×Y_µ2: "^b`h}A+èUßÄ*ó CQ .” öï"¼ž65D„éXŒíÙŽÃ@R‰çø°ÌwçÑ,Õ‹TÏÏ­·›‡ú<ñ³3y™£œ‡½Yp>)¿‹êµiB›Ã^ ž®˜²ræbž¡}G ÆèÁúJsý½«öeññÄ©,‹óèŒ!ÀVñàÒò¦ŒÌ’Y1Æ…Š_ýˆ h÷…ða÷½[ò·«zÑ­Ts^Yöî<¶?¬`#…'Î!j·WÚÅg%t/Ý¿§ó8ßk~þZy~êƒ !ßœ4­G•CÖêÔ«zóò L»p9Dg¾EDa¿(î”–½”ÉAoüxç}û\™fQæX ´M÷hî”­%ü ío>�“¢€ûúËÐUÜ´õ>OÛ™y2û—¶¨@§—-ô@@ß+EÖ»�êï>IüâfìyÆC\LäÓ¡„)Ëúœ¤Lg <{õ}Ûç”—óìa®(G³âÁ�”ºQˆÊÓö_VX?B‘ýi»‚ò2+=Sˆ›´‡éÅ]f=N6´]~ï'ð6Ól•g´ŠÉ¶ö¬h(knDðÓl?³p|rW|™-qæã›\„†ÜÄ*Ñi²¢ù2[øÏ[Yž¸ W Øk µÄC¶fFó5 Šeð:g ‚÷^¹¼yAK+-=è˲tÃÛÞʽŠ>Ρ†æp·P€>ûïªûOˆI nGt´��9Ð3Nzég:í`«ÙÏýñ„¢Ð™çUqÙ¸UYñ “¤*º¼² nVÂO§{ÁS3Õè ™|s¤„ô •˜dPÆzO}ÛbYX¦¹I69ð^5^´A¯ËÀ%»—{´<‡-3•msëT÷ÂüZQËsJ8Ÿ_ÿÃîZ€›2tgŠÅ½_¢‘éÊP)£a˜ÍC”Ô¦£ËJ˜<"î¸/NTâlÕV¥ÌfÑl€áz„uŽaS¿ª¤gkP9Õ0HjMÜš®ë÷¼p¿¡trUÃXDWÚ¬YúoJߎëÎ3€à&AþÙ¸#¢¹NN讎TÈ`Öþ² H™û.ºu€*à¬(üú A;ýJ“8¨T{À±f¥~Þþª>…5ߊŒ¬P?Qp{œÛz|»¾5Óø¯Zp´7Å|hsÆi âcíÔFŒ÷^êq‡çë_ȧ:ž Ò±×^a±X[ÄURÄ£ªWÿFÀÉj%Æúí4Qºh­gÙ–öƒtÜÍW…4Æèþ¼õ“ÒƒJâÞQÈŒF;KxÒ¾§u|ÙõÝ6' Ï4 † i#%b¼F³ûqKÿ÷ c¼í…—²îÆàß~3ÓÈ6qrô°çcš1Å nÓ^:OãùàÂk®N=èèšácÞèöän7P‚~ ã09Ÿ”<ˆüqWÌnzbFæ¶Õ\ôû<ÆHˆFyp ÕZŒªg$â3Í–F!T `¯ý�2ßê~›Ø2TŽÅ:σr‡ÀÓ1ðRögbßåJ�O›MÞ~éM*nŒ‰`wŽèf¨sÇ8—5¹²¨Üþå• ÒÙ§Úi0NšÞÄbÑÐtÛÞ©‚”µzêëWÛ¹i¸ÚÊòÎM”ngÙÓL{K¸Ÿcò…áþ|0öèè,÷PšÙ|>M=@ˆHl½'ã21„ëœó³ba=†wSЛÈæà+üDeô‹”–ÊFV•|f©q§8²jr©Ë—ßm˜h;˜ì‡ët*~È—ÝѬÞsã˜ù¨ àÿ, üû¡¥ÿ‚Fݽ@í)ü‰à¸xh¨<a…|¶«‹~x Kb­ÏÕ‰ŽGHzVÛÚùÓ½G>f„Ê‘,“Úçy>ÖYLóD@õíó<HÏÖ‡•Žö-›a›B‡—Û›i›[Và'B‰ ´�AQ\èchX^- ¦„Š¥XO;ÉRôÊfT/#ÐKi{c›ÅÅÚ¤‘¹‘©ãb– ìÏC®<©åŸ‘¹:/ÒQTB›„g¯Lul2 ™õàár(;ÆJ72¥…IÒÔŸ‚@Á¿šjÏtá�G‡ @=$Õ׶²…¹FyಥG_½.«§¯Ìm,ÞÔ¸UÏüW2ŸnLusi]ߣD:' ú ·;]²Ît÷f¤Z|·µæGC7‚oNO–ÿcnÒ aˆ§Ïw4®â|]��w‚ù«U¾�caÓû|ñZN¢£Ÿ—=Ué÷¼3xeÓ'¢ g°bÇCÇ#3ŒWmîÝq–q’5¶3žáÐ/¾÷»[%cçîžÛÂJÅI]ì²5îOlIlvi2=9rÛvªŒfÎÖˆig¡ÞÆ«O¾d˜ûLlÕŸö0^f�ŽÎV2Ðq2æc’ƒˆš¢¾<e©TDþûÆÆÍEq?9'˜‡¹³hÓNĸÓ,¸:æÙEôq—úÂí…(m˜2šJ`èϾv]Ë'÷ÑWì!u¹2ÈÚû‹N-¬V&¥¹ÂÇåMÍ+/óoGѳɉêð8ÙG:h‹Fg…¬þjéwœç”s ~AÊb«;ç†y½¼�ð±ìxJZZÿ«ëoÝæ$óV!;{Aú1m'ÏÞŒËã'¥G[âF•iô·ÌâiôÙ–,°öÆÒw032ð…ge6—‰´}G+š½Æ*íZ`]è¾Ó¶{ÀÜ‹³æUƒ:×õJ}Òy*Šç%”³WµSlÁdð8(Û³*|Ø/.!½8üÏýKÌP<UõtIjOÖv" ÄRæY&ÜÚý“àQz½e¥7 ½¡ý´Ì,(4¨ábð”gù#û2b™é0¥$3 ’½eÌpø¹¹·3¸eÀôŵ"ßPçÌëÞ¤íËp)df•Ú–¢*äpLÀÌrƒ4 ý«'á*Ìn”7‡"H–«g~ŽñÒàþf2¤–»WVo<Z±¸)ñY.TX®”a¦ú*È$Õ»Us†Ç. –ËÎm|Q ¤3Þ2|à™ˆíêÙ òÖé÷(¨½Ë[t|œä® —âóv_”¨%½ðX1nW3o 0‘ ÷16(fÙjȹöÁˆ3_ÈÖ’t„Ÿ6ePxs„Žw££a›yÇç­ÞTa«…9¾Æ ÝsíeRܯ7à-ð5$ÁŽOïnóqƒpÜ~–~È~¡wZ<bÓJÔÙ“ð/õÖ–©ËÛc&Þ_`a5vVÿ¿áIº.·êUU±’5Ç9;(·ù ­!Aõ‡˜J94:×€ZŒÝ¡l›Y±§È}è*&‰( FqãÛz:àæv&û¥t‹ ×yÏçµÑé\ãnò°ò¸hÈÒúÍ·[O¡Dô)ÌZx1‹ÉØ'ÝZîr9 ŠíbÚt¡ƒk™o™’l+ðBG¹Ê|d=…Š®¬Ù<xÚü»ó8"õ`Äáå:JÜpÖµ¼u�‚òàÛ/p(晢´·-)óþRt)«^^˜@'í HR"íÏhašòéq’ß°¡àÂd!‰Èã…Ƨ(©èÄt}®JÜuîàç’l ÀóŽ’Ú°šÐ ùªí¼<§2Ÿñ¢7ÀËHW¯€GˆYûp˜k&Áe†¥ó—GØ°A2¿ó7Å2E¥;×àîõôŒŒnáp<š:Ó/>—ÒŠÊ]Ž”Þ•ZüÑC>ºa=e.âdkTâðí¾Ä¾¹`´Po­BK%MÖgêuU«,õýʨöäAiõ rhÖtƒhájÂož×²Ê %é.‚yʃêódÝ=áâ|.žÞ£þøË{—·Õž»Ë…ï™#}òÍ ¬pÛ3ð /²52ÏQŠÉŠ#þH´Óóƒ�:='Úöçd£1'„ó+®6¡*pBxºú—”Î%nç2ïvžá «’îihÐ5(øôÐ勤sx•ßþŒÓ¡t5F69…íÓ§kÔ ]QéÓñ0?wù}œ&>?>4³ºÈQÒà–“cçqß.„ër4‡çwÈ›ïU2Sz¡÷/ÞON‹Ôy¦›%†^ž‘"{¯WšI “vðž,fÒØÜ©góK‚³VySàÓ IÐÆ(fÜ0“>øÄIŒ„ £âïØÜÉ¿Ý!™ÓâE ’°ygÞ|yšñÏytÝ26PÉ=<óÒJÌDœªŒ;:J¢EsŠ´RÉ;j8â4W¹G|ò(ô§ÞLKÁ…ÎåEÉ»eÈßóh»bÇ5®Î«×yG73ZñÔSØwåAünT©ë7˜_Š²–xy9'hÑ–ê<zë€Ý鯃ãX8¸ç½+¿«¯óŽ>[­]ý8—uÙ8*=î7ËÖØ«Û,<ªVÞÛP¥x=Î^§6ëÊeÐ×DÂÃëòŸ¹ï¿y> ·ö]¸ß,¿yi“ ü]–~êTî‚Õ–:ÉR>èmL`xêÕcÙsà �¾:å· çOùã{}°aS÷Å킯ôž·‚Hì}™Žî”úuì”4ùÄýÒ×N•ÄdÓƒ²7\¼8ð׃'ø÷ÜǸŠ2OC&’wµ~åþÃñ2û“Úñp9A{¢3àœájxZ?ÙkxZBèJªè;Ëm‚'U'@ ί¶ËU `€Ý]È÷¸D‡¾ì²èñ±éÝúÅq`²È–€Üa¬‡4¨¾¬\CnPÝü¥x:èôd)Ë N }<"ê”cÅn§i=W@çš.mëý‘'O÷åŒ/H ç<ÊË ·Jw9Láüî9ËúXûI°Ó¯Ḧˆ2'º–ùaŽ¼ƒ®ü}ú”$ájЕ—$¨jõû(yFVⳄ¨¢c_ºã¸¬ËÃéo¸Òæg1š,H¦«ç‹À¬IÜ(cÛ…TùëÍF»výulùˆ] �ŠUG—v&”Q"ëÀ…~¾·k㽦òÐ:[Kg6=ý…âݪ°b:k ø/»Õ? Sßïíýñäxžrr0±ý„¿»$¾y\Áã÷ù8{¨VÏØ^Ë DÁ4a±oMY–Â#å ˆÍì¹ $Í]ÝA6XF~Ä[4¤ÿºÑ½%çÑ&:÷S}ÏÖ[lLI¹ÃG^·ØàO èÖh;U©ºÄ3”OpøÇÁΆï^Ú†cg‰šU;Ì)>µ~<Õm Æ,Ÿ‚róÈ•g ô†Úœ ‡‡dN^ø‰ãÇõÈ÷A 磾Èê¡Kƒ¬¹Øjg'ŽDgçr‡®ýg~1#S1±].dq|]½^­ óыŠi£;é]Þ;Ö|·RLŒÀ”ÊY *5¼_¸`Ey©LiŒFÍH—ü`bÝ5rô3¦Æ!GnÊÃÜUé: ¬›ÏŒ6‡ /ê8\=7º›õÅÓÚÃ=uy²¶Ô•Òßngátt^qjå…¡HÜ]aòX§¸ô7€dTdD_“£Ž`ãÀ»z?:ÓÅî±JJ¹¢ ”znFçrŒl;jú<¯õ3ÜÔcë0oz,ƒ°¶Fæ—vvm«Ã‚’�úõ]UÖ*­¼Æ;$]Zø£oUZ7©9t6üÀéÌ�½xæ¦åß :Z—‘|Ø*ú" 3fR[bi�‡4Õ¤±ÅúßYOé›±~ÞpÖX¨"«U€¨¡Ì‹µ÷ÌÁàÕëƒ)•ÎýªxEéf!¡øgÐ×k:ßÙèL_®¶Ö´ÌAÎ¥åod•ìlG6¶Căæ²ÒC˜Wréö¦ äû!3™EzÙœ/ôYx”†ÅYë!Å“Ýxöµ^ÿ–Äé#2³òÒÒý­pf$hþ}íH¹’iëë·R̳%`íД¹*‹I¶äX'@úýmð*=4.¼íÔ;^è·.JZx,eF÷0"©šO^;‚mÎ5ïxŽBÊ*'A¢é{tJ®ÈïÐQbmêeââã'›Þd%´žMRðøÞ:ô{6aRì|Í66ßqB3=åþ|¯?\ø+8lõePÎ*öËÂ}½]Œa6p?[¦ê®ñ0=ÉD~˜íH·9ßÕZ‘Ñç!?¶‡öv·ReùÙ×?¢LrïW2^[Eå;¿Â^ËW€ÆB:sñ§!>C1~¿;šçLß³á6Á/Ûr¥çGZâµ5hû½‰±E&|¯Óþät:ZeÅËĆ ±DÚ\Š µü$4&XÔ¦u7òdYAöâ¾ ¾£Ókÿá€Û’½ëmÉ)……Ö~ l”åE¯‡cGeIå3«Â(hû*(]û05Z¦@¹tÜ�K)¡;ËõÍГÖ?ÁÒ+ó¤üCæ*¶¥˜«cÓ ûùÃŽË ¦šX­þ[—Uÿ@YZÓ—¢¤tÂ)Œ¥\.¨Ò[[z%üÕt“›)9¾Ú^äô§HnyÒ'¢³téÏ]ß½bŒã!…ö´0~$šÁ þ/ㆢØ[y!“!,þi3Úâ2ÍÐ)Ïó>ðä %EøõÛ©£gT.^ÿK (f€Í×Vü¹º•NÉË¢%±årÃÊÔpQ{o=_zûæo^ÕÜ/"§Ã|%ÑÑŠŸ½"HÀ£¬€â><ã᳊_~þ«6+˜M&6§«i0`T#U–c� î_ød¸Ü*3 Ñùwj|×Ñ’ú<»öfýµý©áI 9ó'xg”1ù¢àf&0rÏ]]ˆ½9-`Ãè:FØœ¨Ät0‰$ï¤ÑÿR__ÇITX˜vƉCžq­c ðrZÔ&<Ð<r{ "0•ÚÊä^RË0òyLØ^.²Ÿ|² Ed‹¹y<³ˆ«²ôÍTSÔúT‹[ÌoÔïÃŒ×N¬ÃÏ¥2eQ¶h|àKá0d"‡lDúÒvk{Œ<&Ä\B$´›á#"yÎK*}^ƒ\JÃApØ’oX‰b×Q­úFmB¦?a^M·”.®E¨±¡Í¦®Þ~I|'„w,o)\µJùï¤ÔIÜìqŒÓ)Œp=¬…âîþÒûˆ�àï×ët%1 -ë_5[I±ðXÿôÀØÃQ‡…®Í–žuQªI…Á“aŵ“꬗ª<ËJåÑ)¶»ŠÓÓפDæ8ú8ÒJÚ4 [ç6 j+)kÄBoýãÔ)ÅüõÖ›w2÷Ž1\=ÛÐQq¿ÓHè(¼à:ZEå4¸™ÔŸ‹ Ù ž"dMAÏÔFýé´Æèõ”í§Æm\$f‚À•Ó~GUå4{•‘>ÂSMjóã“»ÇPS—dÜ€xµü8= œÌ�¡Œ*ÍW[¾æ+)”!ºM_Ÿ6=à.㸜€³-‚>AÈ»üN*œ÷ÀÚ™ž·÷¼\ï<ŒÏˆaMå»´˜¤rj^b.ߌ±ô<aE¨Âçá|sé5(ëÂbf�ÂFg]MïðdוÒ'lÊQÕå Ÿ—+ ³„hœ%iìðÝÜ ùLU¨ rŽ#:Xõm«èDX”'¾ß5EÝ~ʃr<ûØãúppÍŽ¡;*áTɲëØ­B`¶’qŽÃ·eT jZõÒ¥Ÿ\£ï8¡™–Jiœeíi”°Tl³…àÞÃl»&�ÇJÕzó£[ôIÞDÖOÓ»§0êØ$æùYúð·‹û÷(-]•éöT°v´Ñ¥®áfÃÆdŠýîj1Mç1=af±K˲dD« x·ÂK7ºKS‡·…nðÌ5ˆ»úÆ>±é˜+1ÊYf¸X|z K5 ¦£)©ÍëtÜô«†‡o’È>mMB Ü©Ñ¡0"}ÝRà6‡ÈoëßxO¼À â”Z!žŠ;èní Tµ”Ã�è;¡g¢"”™®P;ÕÚßµ }œëØáãÏÞ©–,Ýáj‘þµü +ºä©/¥žpËò’$H¬ù7#ÍšóŸÌV{iÆHIÊö1§·¬ÂÒ hzçÐj™œTvé`„køš;Zæå®Rjå18©ÛüAÂüétÖ‚´/ë€gj”¬6ì™Ë«çm¦z¼nîš2?¶g¶NÙBN£Ú…>z|²ˆ¾(k°ÔMþÁ™ÒÒQå_[7¡k¤ãaÒÒ¯±ù­{O%´ +Žn¾Ï¦fර~¼\¬zn¦ãŽ"BÕkq±8=ÕŒ³›³ãß—ª*c)ÄnÔ´d å8"àFýG¿Ò²ÀWöã;0×oñ­Àyè“ü ãÚói{ò„¯P©b `—*ÝÉë…ÕS wex‘®åEîÓç!/ŸÑq耠Ÿ#€¯Š/ªŽ)ÕZœ  ñ=D þ­ÎgOÏ¢Ñz¾nìúå¾ä[îr>¶úX(-hÕDÕ7YÉÛç©ÙË0Á\¼†‹Cr³N!ݤü]Pâ° ŒÄþòw&ËÎ+1ûâò‡ró^ 5øg[1:'ñ³¸•ãtWÏ͈0ËœýlÆ\ք΃ÏÚ½;Î>ÚºÛ‰ |Œ�Aa%/P…7âLtÙioU1×€rqßî5š‹³øÈ Ù´Š š`Õí¤óÃuŽùá%ó°âVSt„ûfþi R°3bäC—ÇüUÞ¡šUzK#°+Œû¾F7Ú`¯2ªM.ì±°í6=¤<üëU–¨²8A�AïL"sÖ ûÄm¥ þ„²ãsÇà:#_P[*ôe˜ ÛÕ¦;tõÈ]”§q‹=?-JC¦Ô»Ûœ¯v;ø†ÛæÃ}ø3¼x˜»‡ñZ›mRQ¯çVÁü¥ñ‚Ž’¦´BàmIq¹ž`hEñ”¶"U›+ìfÑ¥¹÷+§·Œv ‚·È%‹×|ctúÕC¾7,`Ç­‡ûÔAc 3¨`Ý­´S‡LAššj=*žï)ný¥ W™9åø‚õ5ú êƳ뮦×Æ‹s±8ó•âÀýoév¥õΛ‹Ù^¤$Î;>ÅѬ¥¬ðCÜ@^"dÈ]K‚ËXùYÓ¡¬ò<4à ”%ŸúëÔÒMÁakœXUd±/a0œ³ ;Ï:ðQàx<LÄêÉÚŸÃMáØB4èg¿…ÈCŽ ¨îðIlyÞ¸cldäÎ`6ßv£ð­nAœV‰N#ÿ|¤H >StÉ”å¯ÛÑ^çEz~Ç/ú¤£ZYÁš4`™¼àÐùþš r�XÚîL®2溑³ÿhº‘uîÔrúö$¢‚ÎKûs#Ò±à‘Ãä^`!>*ÀkÚvop­GKj`ÆûãñÒ›3vødAu²¤zh) ˆZÔ½ð&�¦æ÷N«g™OùÝ.hc ×E÷;²»/¢û“ž®óBL­èËZí|ÖæBçãhá{kÔc °íI zcJÏvøôõ‰JÃY)fLp`iS½ààîÊío(^—þtì§!3Ý—‡™DË©½‘®ÃF:·ãÑ»Âùq5ÿD²ùbP1ĹXÇ_ó©Z0L"€«¢¸']Çë¬ýù§M{— Š2EEå#ºÛVéxݶ{+'Öì9å™Î»æjþy#àû æ w|ó'Á®RB ,hY:¿Åí«;²,÷îb´ù“ëÉÂ{°’X¶öÐ]f¯ñêü©ì¿…ů.»{öľ„[) µ4(Åz07° z Fµ8…4ËI»ØwW't6ïuÙŠt…ا“˜ Ôx˜½ ‘ÒZº÷³ÈÔó©^Àr½ì¹¾g†ê´;™AËe¾@Ú´±#Í,°òÝo e(GÔ˜Û6¿è†+=uÖµ¢ûuk°R™xÏ° â íåáøvBÇ@ùÁ?:ÅZ³ÒLPÑ“‰kS—ØœK |æþÜ’Ic/¡^[tovƒ'u"U¬÷¬ØÔ+£6 íñ:^át£ (UìÊ˘n³¯ÌOžÛõ},y¾*!áÌTµÑ"Ä‚Ù™êW,µ2÷‰îÀ¶j(Ÿ �XN{µ ¥$q?ì·lG‡É�‡DÆàùҬÊïáÆ*b\¦dí¨è!„°ëL!Ê©M®(ŒnJ“ØŸ5”¨)Ê$¬o”èDó?4*øÓ2ëúÒÍÎâÒ¡wÄj=H;\9Óöz…â"ôŨ#nµÅÖß&.Å¿|קUü¹Ïå•ÛH ÷¨k:ü¬/•kØuÜŒò¤ôÍj“$ó…7èý¦Cä¶çX(½|Âéx´ž¢ö*ó¹i³Ž÷‘Åéz0K,Ûçð<ŽWx|k¦‡NÄÕ¾Þå:["@˜äò8ÂRE9G¸Ü°qíÞxˆPi¸üRa.)|YqàË/tè¾¼¸Kå_Rqê.ü“oÐX ñ<¨G¤Ô¡:ŒmŠ½q]¯ E“Z´"½çýSe|AN!ûï¨Âèì…JéP_e0¢s²ù»wõ½Í'‘ïx m<4³.»yÓƒ¨1œe´»' Æ’q+tLΫ¹ -÷lvÇ(bÊm;\>lR¥’••ycnGö6”Fîl¿±Í“=Ó*úŸQü�¥`OU52®ó‡•Ý|*¿•¹“îfëþÄ®>W‡òåÎJ0´F6¡˜^¸ Vù¾²»½Q&KŒ‚ ¾d®µ6>6ÇúãÖeæ¦LTnñ©ÃlÁúðFÞˆµf~;Þ8T½ŒüÊÊ0ÎÌ(Vlj TNìÊþH5¯§ˆ21MØ»p’cž *Þ1Þ¢KƒP6jÎë2=¦-J.P¸„UêŽy4WGævŒO‘ ’ŽÃòµ&uéÇ@:±)þõ£‡ä3â‡òÞPg’µÁȉ Î 0½ÑF «p C›™^ª<7LžOtA�ÙDÕ{=ñ'Ýñ(ñÒM¶ò:vÚêG™VûŽoh1(Ú5°vân±ßköF‰dŠ”­‡é_¬¶•zTi¢÷㥣º:€%§çŽ¶g²ÔÎÇ´í†?µµÀ{†Åy¬µÖ‚Ë3,\“qò*tzPT^^ñ,(2ßè ƒ-hñ¿«¸n%¦kÆ¿]y7??½ÈȾ[Wž<hÇ<() sÒ‹õe´ '°Wé »Ü»ºcƒ…>k‹ÁÔçAÑ鸇)HêrM锯`Ô§n/ž!€s«¥œµ¢s²ë‰ñ¡祩W¨E»åܧ·È/L"‹ÌVì%û%wvªJí\§<~09,­qÎy[¸’×[¬tTö#Ãý%UYšy›bf%›ï;Ïc¶97æÍáŽ@g ?]bˆ®üÎÙ¨龪 oU¬œ_ä:¢› êÔǬf6-3ßèL[Ìpâû¯î˜/œ›~æØe$kÃC¿PíƤ@9¯_åv¾¤³™×RSúB²‘R°í fNg«è§tz4­óºû¿Å’€\¯Yà,%Òôè£÷§·Ÿëzc18÷±ŒBP€c‚àRÓé]t£Lã8VŠB´;Ù¡±“ò5ê+ôAúˆ £(îòÖRø£@”˜xШþØ8»®Ûñ&Ç–ÿѽ—¾lG Ê/B+¦(žœûÏs¹`„"’Ð~Œ€ó›z›ßòB¾ÿŠÞ7`žÂ´Ã7°0€ù;ž¯HÃ|4ê)üá=O÷£–ŽÞ„«i‘æ¼»èB»ô²¦_~¿øn5Æ7í àáûYüàFùñÿ%€0Š\ëV؃¦§÷n Ijüµ3Å(ÛÚ»iç=mëY´ÏÁÑǪ©ܶžàPßQr¡%ø õá8MFÅõatÿÄHRM�ø¦Cï0„Ì(¸D€ø+dèÉsuŒ@> èÞ_¶eZ·ßˆe )MfvÃônKuÏò d'¥ïa»™*‰ÑJ Ój±ÛT´º)»þBHÑÊK˜2Ø‘¥ŽÍ 4›@á¤iSÙ¿k™—žZ[Å+è 8gkúKEîPWlî|f#¨oÿ8wÝZ†°´àù[4+´‹1ng‰?ý $Ü¿¼Ò„ñ‚êÖ(çs1Ïh l–±êpA·"k±&ôŸŸÝ \‡’[ÿaŽV†‹çB7_é˜Á {¥4Y¿8ÃÅ9îøïó”mõÃ&r‘º ŧÄñ &ïg¯])S(œÚ/#×1ò­ÐÇÈqx£ÊдtvÆCçYVŸ¨Ä8uH½ŸžÖïO?`шOù³ã…r@ÛԱπÓ@{y¥6ªØ7a¤4¨ú«§”/Z­!µœG oœ�þø³i›¤Uæ;8Ðã„ófÅÒÌHýP¾hÂÿã —o¦JïçM}u-/:RÄYé¾f„Öiòíºw@›Û@ ÜŒ­æŸ­ýËö:´·sáÄ:ôŒÛŽÛ¤SF¬`} *âÙðŠ«ƒƒ©hW“-ñª­š:µWtlÐÌ;b6Ü\;³Ù)וfÊ—¼Ì‚ŠyÂÇŠ‡²…âç™JøŽò|i¥ÿÒÇèÄIMXKœ‚²=ìRV=:tr÷»ù pç¦däîé˜vT†(ªˆ‚"”)@±Sé ­ß<ÌÓÔàùB¦£Öt¢F‹êþÀ×ûˆñ9ˆˆGvÝ9°.õæxº=Uûuñ‚ àB+°ž}5‰nòz(¿ôŽ\™Ps}(Yï¾\úeÈMê£q®²2tÑ=þ…)C݉&¶fUm‰f@knëf_[ ¯ÿ;¦f7Žcô·×<?'OÝ÷øõ¦¢¥ûUÁƒÐ†îÙ°0‡ºYšiêƒÏaú<Ñ®´[CÚ¤Ïö™<æˆØ±*w¬YF²Kh±4­öR©AqÞÓ‘,L—3V?=†ŸWhÅ™øÉŸw{¥Ç:Î^F{tÕ�¸'A´#JoÌœYP4ÊP@§ý,¦4œØAÈ H <k~£]�¢ï³Ÿ(Ò8½TÑÅ;|PÊ•ŽžÂ6žF%ÊÎë×ï:ü‰©É¡Ú”}¶nÀÔÐÎ`¾5gü¯‰6}_'ÖL¦Rà^5s ä€Ër<½Arµ­¥Ä‡Î6Ÿézñ½a”øóMÖ?À"º·ï Ê"b6ç¿&gß9Yâo¢<aå[´¡ó»Mhe [K%Š×JÕÔ†"‡õØÞ¹ˆŒõ‰`ždÞÓeL2v†ÆŒ³‰°E[aUümÿÝÀ’(S &C3‚e9eo¦¯_>ïÌë½)ˆ»ç¬e¨·ó ³mº( <›O¥‡ÖÙ# eËý¯Z]ßÓʉ“ó'¬‚~ª‚lùòÌQÑcuèÒaºdŽmôŸÖ/×î'~‘zˆ}!•Oì±×ê.(æ…ÀÜîˆàKt’­ ÂÎd¶2Ó]ñ5«ÐS™Á•´µ´(aÑ÷)kw¤ÔI_có…nÊ7)§\º ’³?ÛôPÓ€ÀlóŽÏrðÔº6 >¾Ç|(™TlFð“ÓÇYPz|Révž(ž¿ª‘zÎÐœy\�h,N[JÔ¨¡—t#n„`žjYÆIæOë VþçðåÓº1ǦÈš ¿^¦Ùº¨£[TÓ£z·»Vb‰†"ed¥T¥_ÎqŠý± Wy„±Ž¦BéEŸˆ%ˆœº î»á þñÚ)ËSÇüaD¨�dŸ K@°\(Q·ÜŸ™ÿñªÆY;;D«ß$ôK\xEM;qvFy­ŸœïÊ ŽÈ£½H»3cs¼¢;{*J[ÁT·‹çÔ±ëV÷’O^æÏé1,#íü°×c MA׿dÅ›ØIio=]gŠHHNhAY§¿1’Ì¡/ mŠŸ¡”‹Pº/ åÓ Á®û¶n"ÏȽTÔž¶Oä$ûÎAD¬;aiêhÊ(gÇV¿m ks8ZÃèýû6 ’Q3yhâ˜g'RÕ¡ Ÿ$¾ý¢íB7´‰&U<qCˆG$#Ò:œÛôÿú6WK½8á—2k/Qж+‚ìdÙs¥Q4ôMË÷FÏÖ]Ð1t¡·¼ñ—/ãÌdÂL@…éYb¬’—úð¶ˆì¨Ñï¹-üîIoHÝýWäÃV5×8÷åÍ·×ÄÚ#[ZGúú ÷GùÊã öKh~*^.“DÇ—žÜ« $n_W–Q‘‡Åc>ÿ|ȃ²·™;ýËàó -IÿÖ_œ[wùHü,NÔLQÔE°|&Tœ½Ô†2=øOõ~ÇQ}¡œ€6¸ya@qœ”ÖB‹¶ÊrI‚´WE¾2[÷oÆñ‚Žßüa9͹Ωڲ‚¸·,X`&™Áû±g9vhµ æáB¡Ž:±åÞ®b´Õ@šh)Ö¸jGouë¾ûLŒ¡Ð]“¼¬ä¢Î,ÈFY¯§¢‘g#†-nü—¬ü¸£Êí˜)Ï÷ìÕ‰é5G¦4K|ô¸2¨†­‡¤d^®�"j¶¡OàõßåÈò­¥/PP´ŒÐ¶JC¡ºØð¨R6½äÔ°—2±¿èL<þ(ŸE§Î ëOÝíñ<ÌžD†mhüª÷…©Û¿ÚiÿF[Å7³&4¦ÒÕã@›àŒ¯½†KùðPfW!ó*Ï™²ä\^}£é×#s$I3_P'¦YÑN'd9«ùdjIø±¥Ò­}]§©Ëxîã8ãgm%aÅkʪvJª°ÐÂA¹y“žq¶¶áOiJGÛÕµ©¦~y;t�•žY¸es9€Gè+ŪmݹW´IÓS’´9¨p§Îƒ)=$ígëõÇؤ{¥È‡¯²ZN·‰AÞigd;'çÜ=ÚÊpQ¨A'›n4ãçÏ3 6Òìg äß#xìµxî¸?%0ÂÓŒ;ˆRÏ© —N\”vÍẢ]{8Ü ÓK™É8[–ø¾H´ ›z#ƒ)H"lXä›w.Ö~Ta¶2aÍ‚ÝÙÈÅé;ÓùqEH÷¸›z7÷ÇžJx±2¢k”•.JãØ/˜®äç‹åŒœF©÷(|»qßÍfÜÿƒgR¬˜!§Î07µŸ½úÖìxd‘¨T„QâMYÆ.”ćfŒŒñ5¤O5?³¿U°‹“5º5 – ¸ý×C )«¢¿zArOõìŒsoBŒÓWø íW7È9IJ-sö8ÌÁ¥/bÊÑËT¬žó¾zÿ¸_‚zÌ+¶’ó )îì±ÿá*" ]Ö²ìM‹·—wÆ‹qXúý5Z #´b*+YÎÓ 0L8 È¸HÄ]ݵÍ `?y>0‘ù<` /ïn^ £X±¦_uMÝ<15SžVæƒÚ~µõYƒŒïWd¥u.é§sEüÊ 3ò¡T,8IÏ» ’¶Qÿ,(Vx¥)xÄ}}ùéy'žø,îZlº2Ÿ‹§ˆÿoI¥ј)­¬ºäÀcGgà§ÖÖ¬ÂIåX ̾'üò¸¥ž(x„lp)©Ì,�@Ó<a)ç¦ûÂÓQ(ÂÍw5CŠÂí8f1£L«ìQ†æÏ~ðÎÞK´8^éV#"EìÊiùúPù…ð_zÄgZ‡EvÛ+-œ´×Œi>ÆÀÔR8!†ú¶œŒ/½ÿÅǸ6*Q×ê†ÿ†/ŒsÇ­JüÐU´éº#hÉŽõ”-JVþbkR5OMù5ÜXmÓEŸ›µÑó"(·zka™yäöOMÝH»3JHÁ|DÙÿ!]Qþù|µäf^òú/û :b4‚S˜�Pjïr+XóÒWµÈJ̶%qEö³ôôûåÚn÷ÃíÑÿ( &ªÌâÙlvÕ3‹‡ñ€K¿96ª¯± …ÐxÞP©¼ßn¿½FÀìÑÿg û'êh }©pÏ©][VJ‚çC/Aæ™7O œ²Ã²>Û¤òPw` ÃÁª€´ºVžŒÍÆ EæY:�þ–ñ©sýƒ†ê@�v¾Y¿€Àå^ÁXðw˜+Šm–½ZÁ ø2À®×�@|ŒÔoSŠ¦ŒBÅýÌT2Zsx€Qb¶ß)ªÿУìV¨ç<ß9÷ãr#í-fh!"畸ìä¹€(¦jwÇ=çä÷¦FÃtYøIÈ®¨Å¨=Ð 0ú_¾a °’Þ_,O Q‹pUÐ[@…°…4JÎýòït4m(BÒ¿wùÝu6ËWV˜Tu”2F½õš�½ ÝÏSM‡¤Í³†+¤Ü?ßÄRþFQjå>+âyÐÌ”Ø~6žú†-L¬P‡NÕñÑÏ*⦰—wpÉš>½bB0V,—êÚ/¾×T­ŒÝq™ƒþ<â®·z†|S/ÈBuÅJ}3ðCÙà¤úB!ž(käUz¤}Q93Â*jnaÀg™ UÑó…ûvu sceo5”ãLÖ“8ubãZI8féðSÔBCt.)ºíø™3R¯à=Bæ-Ý?3ÅR tŽ3›ì¬ z…7Ȍا„Ê·xgí_3ãÀÃÆÞê$¦m/L¶`žqò("´%®q`ËzFsøƒ­§±,K­† {Á&ºû[©† ßLù;'t½9yÔ”¤k¨M )}ø󗇛#ç싳°œÓaÆôà¹ÆˆÓ?O8…-éQQÆ?êfâ ËKÍ¿ôÝ":á.m¡…Ò\ï¸hZ°Gjô(VukÞ= Vº¡rÉûïj´^9ëy&îS­úcI0—ôãlµèî˜É_ðŸOöU$³ª$îØnÄ™Ñ$b %X›-zó§‹)ƒÒ€ç©û“·ÄeúŠ 1ôM|Ã4è¾² aø›ªÒ`–®puúçf¸RÚÙy”í[ õð†-<f¤5Jr|ÓŽ³¿ZÄn¨ìÛT«A‘º—›'~=”0­rßJŠnθ£³ngûþqfÂ/W‰ª­Ä.ð¼.= ;úŸ}Iyï¤+ "Ý=%é§mô–¾Ýƒ-9¶Ø’•zö„È*+`(‡%«o»º…ü¿ëx.בÎ{üsGÿèÚÖ¾"ý÷lÑrŽÌ0D½x®´Be²­nÀ¼xÔ¹»Pyѹ¦C?ž'Û¶g9ˆšö:-ùñBæf?ìPkŽ²ôvtñ|ˆáúP’ç[Åwg§f§Ò3¯"Q¢]fþJ/ű«z×ùg^ʬÛsWÿÁ¤+¿u™ë,¨¬0 hæhÌ`xêšc÷”_z Ë^8ß½#¼àБguã_gRG™˜+ ¡sJôØ:ós¯ô¼)äÑîEO{€Í³R`¡8NŽ¢“/”ƒ|øÕ Rµ"NÊÃ�aº‚9Aêß²éiûî­qÀ~èñ_$ƒÆ©Ë×2ÔrGÐ[²±×a*É]½±peˆÖòÔôûÅëƒ0ôY @•B,¿Qœ�ÊT°rÓçy¯³.ùw²i ñô¦iŽ‹Ýï ²ÜÄÛÈÙ òV$ÆE‘R1©ànÏG×±.—Iàþ+)óÈâg¢ÂR2ÏéÕÚ;ñL¹4ã;ü‚‰þœôŸÎƒ{L„œ#‰ÈŸ$�NÓþ¯½zo»Ÿ Ymî6G=FÞP&£¹=vžµç`ê¨tÂÂzºLô—Í‚Y—â8\ÇÙIŽiûåÞ•6Ëx5èŒïRuj^–4TzŸ÷ìR+Äc‹qyíÅ~Q¢Ý˯ÏÅ3Ó\!%Žõ‹‰ÊËt^|l^ÙkÜtß C•ž‹8(Ç­Ù}É‚4{E½ùÛ/t ¬9¹ßÑΞ&ÇÐbÛªslz}O kqå3+d»ñ¨·x3ÔNF845 z6dRÉqbÑ÷ï€Ä ^bá¾Aºk=AªdŒ>׋t÷$®üvIÁ† ‰s²-mƒ6¯ÇÔi‘þÎ'ÔúHWnŽ­B+aû§e:N~¼ÎÀ�SƒŽ”é=ÞA`äz•‹ -E½hÐìõ–Dƒ–En—¦ÝP/ áÒØ$°NÀîœÑ7à.„Q[í†S_ïLê©ü“ÉU‰—$ëN®2(Ú/m÷×F¤ýÙJ^{¾.cæ>�5ðŒ”rga¶3}‡z?:fÌ¢8!Ëþ½—“¥Ì1šb>ÉÔy½+np [¿æ;ƒˆùáÐÁ9­Lžo¶eäõE}¡ÕQ—­, Õ˜ô»…¶^7îŽÚd´’¢¯þ%˜Âg+QJ?`=j•jàaa‘»"È À,Ÿãšy} êµÆ)‘¨oGšYEV¤E¬`s®“¡¢ò%¤¡³WSA²Ýzù ï„ñìFoPF0‹h¨?ÖÜ™è oè+%ZK;í_Áäw öÿ½xåÊ®¡ß¼œ¢\·ó¸{»³?1ü«&}šøó5Ìik`+>½ …'îJp8åµÇ:gþåŒ|>¤ºH2¯ §ÏÛÑñb¥2ÊPΙ¨²§ËorQ–8„„?9Û‡\µ¸ÊJCC”p;¿™ÇQé/@8BS:hÿõºV˜ÖXÿR~\¨X�ÒÀxÜ¥§íQøD3¤AaÔcæÿ¯åS¶œ"O¬Wû£`´Mc$ª`U'T˜»1¸ñÚbÉZéÕ¿ *¿í°¡:t6»GÃØå±™øÎ;Ú‹–Å•–¾%‹Ó__:º]Ñ]}•{Âñ"µ¹’ Ý~zYïç‘ËwYx÷º S}YºË‡1º#�Û(zÝã "ÏzȢ빡p>Ê¡§X°Å)æ^Ç+Õð¢Ã vÒw”ç!.n!mG[óÓJëA s¨Û«“8€SÔ ÀÖã\®¡«‘?™†Èl’ñà«y *’¾ç+³³ÒC/Í7*ŒˆÔLs¸k<Ӻ˕~œ2±±×l<>jó;m*9®‚vÌ‚r¶c¬ˆM_:GÕ½'1óLlƶÄGÅ£LôÆÞ!îʾ?Ï S×ÜtôŒ“A®Ÿ¹ÑÚF™iºƒü‘ky„ûÎ9‹Ü šŠ\‘› g¥ž…Þ¤*Î᤟štÉLD„GU$›·–JBÊù€21½×ÜðÂ)3BP˧�8Mû#4Ôös,ñÓÕ$�Ëq®Ã¼ÈÝG‹Í}ñ +(„Ñw¡ÛqšÌ—1uŠI‰ó Ñë5]–®mÍË»|Ñâ/UIŠÊ HtNGgeÓ%ÜÝöž)îvØóͳ½ßøé„<XÈÞ§U+ÚÒÁUÏò¶ÄzRkÙ`'ÓR(Ѫ¨ÏžhÃrÍáò‚P¾~îT°igÔŠ¯ΨP‹7†iÐãFSY.yÂú'ÊÎêqy6Ä´£äµÜŽ›s2}… 7·†áôýJ«•o¿0FæºÚx¢|èèTÏ'kĪ]»gà9[Ë …é¨<qqeàšï~Ý/To¥§GwnêÎÃZO¸Ie¾t@AÇ”x'ηcŽJØÒBl†³ÁámM‘Vî(m¯²ÖÞt¨) ‚µóš1Ýw¾ŸÖ§ÑÝúþ‹'ÖLÑ7eQ:!s+‘:AëªÅÔýBÀÇaæ³Ídæ/êo×BéZ…¾ßDË·QÈ‘ƒ¾îáôPÁ|ÿú±Ef”øú´°ÛA3¦:)âNp×â¯)¢…c‡Œig{Õ´±fïàoÓG-×ñµ: KœT„6Þ “š-v‰uiEXÝ=À½êqì¾Ð½Òz¦Íže§šö9#WÖ„gzw¡§ÇÁZ;3lkëËØ@©¯•ܬÁßê Z³>ãik6=›V Á“Éæx:ѱí¼Ô¿_|WËÍ|-ŒÐ¨‹çõ—§ç¾=~Lî«ìŸ8óñÊxØWº5eÛzW#wà<’Ê@J¸)÷ž©$Ùô×>Rýêz-X\„~Sœâîñ Ú…Ÿ×:}ÑD¶F#ßæ®~Ò‡©Öã©ÇlT­v�³ØÖ(f sŸ‘Ž‡ •6þ@+ÅÍ\ØÐÅïg-ǯ_Ýå¯îÊK`#'úi–!Åž+•z¾F'3Îf3>o È3*`»ÇC çö’·®œZùTÚÍŠŒ¸Ë6³T’µ9¶àþIªü³lGù~t°éó ÚÚ±n¡X 6ëõ¼—ßúë“· ŸÛ”õ�U¢¨úFó³•>|)7i;›$So†])‘ãÙmÒ²ö‚I2·C/—ðÝ—|À·÷}­z”ÄËñ2þ$ P…>ˆå2äò¬¯;O¿ó¢’½›Ñy0[°©bf‚÷U€iÁ…•|ñ³}á‡+IJ’ç$È­³Fš::¤åK=Q#yö’¤Ø¦xhÂtŸlBÆ'ƒ-ÒÈ LDúr’œ^ꖗ΢ßÍ;™×‡t ,•uƒlRÑ×Ńþâöž÷½­|¯ÿ„ˆÊ"ãƒîÕ»öÛ¡ùv\ŽÃ©ŸýAA¾úŠÜx ’.aæ>õ8&Aùe­-ƒà8ƒbîÚ_B“rÕ×O0ͤº4:ͤ{6Ó¾–ÿëQfî GqÛG<s X²>k^ÁÝrïçúwÿGõ<d…‰QÐcuÉÔtü¯ý# ¿{¿ÎWH.üóŸ6œ£%UΞ¬8<²ÀΉ#´#ýILá¾½®•‘…[éSZO»÷âëa}ÙIÓý‰SݦP@p„ípW ©öy™yˆ,ä8ïŶ2ÐÃ,±*¬‚eDJ÷®ßÕȱþ0tïúòa²Þ©eñ@Ò,‹WH ÚUìÙžw™sÓ—–´Dt<Á]›:_[±l§"z4ÍÞeä¤F­6â´ïª#f0ÀQryr H ¥*želý! 3|;ºõÐ'ª²U²ÃÞwÅÉJd°qÜŽ¾¤ƒ—ÅeŸ›à91qy®àjZ€®ÊJ‚&4#,ücË4X†˜yô´:’Vå×€CiÎûA)<ºðvŒ>A£ôt¦t$ZµnŠÕÈÓ¨°Z×ÆSÅ“boYTÑtÜ‘¿+@WÎV/eÃæ\;­\2¿Ý™ªˆIÒ%D“u ¬X^BhY{m©lz*ð¬üg¢<\SRÇžHöt›™Šqo5Þèd\©ÒáQ¼ŸUÛ*æue$¢Õkyq\zCñ’¡²3mõâSI�À&öÿþÛiMÿ½à¾™%ËÎŽBn~d:ÞM¤/Å_V‚ o»šÞ°îzX=÷W¥Fnƒwzuvš�~/Æ ã¯«Ý$}7Z?- Šã^ë*ŒA¬J7Åèý^#8KÃÕ% – ,D3e)߬÷s«í³n¡2ê”ñ[·tûŒ´ÞðºÔÈ#$€¨–ŒŽÓÆêDÔFB^*Ó»²¡òº½ÇœMOË%GÿÜPñ6Yn`'kÃïüe†º½´î¾oäkêf\œ�––~j‡,“ƒÃž—8y¸°_º±åùhguGm™#Ik÷ë—Õ±GÖÊ"–X'íy¤ªƒéÓà÷>ÒÏ‹U9IÛ’2ájT>lÂ’stÜÔ“*ôÇáFm?²@¾³B-֢،Ò;³6Z"qOßeïºÑ¯é6eÊ8Q•á™ÒÅôkp“‡Ë~tçÂL?1ëçæÕV©ŽKñG¶’·zŸë¦NßBæ{\±YlN‹u¼8r$HåÌÖqÓ£}"·À¿æ‘Ï›o4´°þ ‰g¶î쎧nR —¥SÖ“–˜GŠé ]YêF—æÖ¾2M m†’­Û³Šlþ4¹'Þ{žùܪµ>6.‹œÃ8êQ:µ\è†E€šÃQŒR3QÑ—¼í›óD€ÄšsGÆá}J胚k³‚²=sQ6}ÖIUÁ;=ÏË/¨öž'¦¬œ†žìtV*Bä<CtóX4ìÀÎç·?�¡?­dÔ²ì,L…]FÑúäá8N` ƒíuP…Ø„4 ¯u{¾…º=$ñª-‚ä49:ùö<ýÛ™÷\8cv"öÆÜwÙɲÒ> În—Ï8(»Áa¿·ûÉÛ ?Ö a²¢`àMƒ¨ÖÆ) /×›ýv¿‘ƒøñÝ*Yq–©l�î-þµò˜©)Í0Ù©ì{g7WÈûñ~dÁ\…uA:êç_àÀ/3O;.€‚î¤:À‚²(ÑÃ’å$ÂbœiéîG<!LôÝ…ŸŒó2£¨>9(4-¿!�¬5ýA’$2"?[|†+K2zØ쨔wµµÄ+ã%"€¿uL~�ýô»oÈwʨéÌï¶ÎU‰GU¬*lM*l"­Ïúù¯ÀZ,’0wgll:AÒÁ:»Ôk@(§{:"³,6ó4nXmßHnQª›ÌÐäc“ ʲ€úÒŸ=ˆKçƒÙz?àl¢(÷[´Š©æ§Ü`V\“µ@èS:AÌ,éwÅ0ñclhpZé§Ï»ìñwèð{–5DDǨ0¨&ÛS„Ê t^¶õ—5/Å—üæõ<'öðëØt:LeouXÅKS–ÎñéZüÏ%;ãb- š§²Q{—G$¾“-Ïv ’úÁtòžNG$¹™•C‚;*=æ±ñF ìúµš¿¨´ùÀ Ã’ÀñŒÞµº„ÃN3PaÍÇèoD¼K‡Ú’ÑÎ2¡ÖíLA»Š2;ZhpŸ©Prfê'zhX®ôú/eÝû¹Ê‰•.q4L'* ð‰M¼é Æ« 6vÇÉooý˜µ¥ÏJÅ]ÿ P”Z×çì¬5²*Ý5öŽ6-oúʱãÔÕ7­à,µ•RÈXŸ„µ¢OŘü±÷ã|†ñ†µ?åtMç»:>=sø íiýMVuŒîº$èÝ'!BÛ”›…¢ÀÌdïB57§²u>ñ=£,1Ó¼øTF:pƒ)Öl’à zË©OǾoÂIûÑt¶Lo .Ê 2û<»€´5ÝâÍž>oË@¼û¿<í¿kV ÕµUìùÁ“5 Wf¾¬O]!7Ë\b¹ÙQÈÏ‚½õó{ÙÜ/­Vñ˜y08¯Vñ>LDŠ·.9¢i9p¡¯‰­q¬nk*ן<nU6fãZ¸+—1*&‡î¯$ÜàI;mC—C>nòJvC”úÏÖ%×Úþç_Zýßüj¿4|”³ÖvyhÈq¾Ïh¶ËéõÛ³ÝúÓ*Iƒ‘uÓ——¡J^kòüœuùnÒœú6=œ‘3…D¸ä9” eFcŽn¶3ÀÒq3O)Pûè§p‘­›ÓÐ.L­Õ.=³‘ÊÓUÖ„¾ìé‘«­ý+Š…¶j* Das ¤+ŸtSULWœ£%9,@£ùMYèñ„ÍD'¥”¬÷tø²,›ÌÌX{7uT»‰+ÝE¾Ù„ÖÝÀdQ>å¿—aYá$óX5‰õíãap  #ìçÑ�³ôý ÿÍ´6ÊÂÜž|ïOhE½·ÞX{ÁSrÚ¤BrWú×^”YÔ0IðÅàBÛXß¾½"”Zvd³ zÏnQgË…–ƒ¾¯wÝžyþð ’)£‘G¨�ûåbü"Ç�°…üßÀÌV»þÝ—BGŸáU£¸ðéÖ«ÅO™VùÞòHú¾-ûWVýz”a¤u“�qéÔO™çY1–æ8û–¨ýóÀ/­ Æ7Q4Ÿ]ÌÖ¶(9T…¹¦ãÈ}Và.¶Éš¹Þüø­ ¹²ÁÊ8ÜžÁòX¶hFc<br¸‡ÆTvêgJÇ2hhC•§ÁîJfmI‡ìÑWðYêâ;5µ#=ÔOËO©¤ ™Xq¾„qvvf±Q^‹öÓ?3³÷åÒžx¡€M—-jêÖ¢*‘*ézºªð”Ø‹Ç"ÓQ¹ÖQ ƒZ„»OåkEøÁôàé¾~Æó•è.TžoÜ%àÙ¼[2L˜¹³âéê‘›prÏÁfœˆNjÄ'ÇSd‹zK檻n1‚LýÇ—¯«ëÃqä )ï¼þɳ]V½!VjKmo«#?–ÊOŒ›gÁW?‹µQÍ›y®‡ ëÓ2-ê³ë“Õ‹QûáôEôo4}þ ÒÁ={¥a€:„f*Т‚“žD}pä6v4^èžèë`ŸÝ¼ÂªªVœ0ÇJ'+8»CG»<jâw Lë­—1çš)EêˆÚ‰ÁcSå±L¾<å¸Û²5®Ò´7<|ÇL¥\qeÙÚº†%梯wÏnÀok†ÜZKîÊréZÁo†òßi6°h héj×Rr‘7£Ø­³Ê†*21©w#8›I<ý—+ŒÑ´œ`%Þì¬ÇK¬‰£ÿ¥é–âùP&æ®.ØDߪv¢BðÊо¡Sm÷îò9ìªä3¹Wœ©Öí_ôuòðFhh<ÑZögœtAl½U`¾ïí+zŽ.§‰’2&…—?Æ칎iÛìf¦èçå”ôgloèÎïzz( %XG‚t_¾Ã%¢F-ºÚˆÓñnü ׸ëuß„ÊŠÞ÷ŒûB_õ)¬Ð÷§Äuø2Áë퀎Æ{)†¸Ú$G­Äó³CoÝqKt°„ŸKtIoõ+‰f½:°î ´¿µ÷µ®f~ðé3ø[$åŒK¾»)n“»ñ8ìk_Kü/`cqæûŠÁ'cÂøj§¥.:­ ÐÖ²aûÉ^lÀQÙ|ø}8 {š]<CA'§…WÇõÛ?oqÜþÎñâÅ/%iâxå&KËî€Ö\Z+H¢tõ°Y“7J×E .9í2䧔Ž(Ïo\i6K„èóé)®.XO‹¦dPâh±ò·°Šq…qkjÀZµUÉe ôèí8ŽA<Д¥»�ÛÀ‚³èný75RÔŒhJ‡™ø›f—­GC뮄V l÷M{Ã0~ A\&Þˆ¢â€zA?|RÓ¿‚*ØŒ­êç©G»>rœ°Î-µ”ïõHøêlS‚œ‡çh.œêy^Òºý¿ÂSh©F“ÕÅË}ƒœÍqöUÇ©ey¶V†íÛœ…a”›ÏÙ±h`ªîÖ~'D wõŒ§lÏÈÂÛ›rxCãäü$n­6A6¿¼íÊÊÊW°¤%³Sã)þl n·ÕÉÔO¯ñ#óĶâ$>톌¢’•¯†OØfÊEï»a£wù½q§ët„ÖJPœkOô çüÀ•ä̘ Ýp03-wiÁ-žõMŠÂÉ]ÙI.Æü,‰ cÝÔÊŸ4š½«Ÿ~ÒJý .biï,ÈÏg¬eÉR*1ÏÂjt~³QÇ«ZyúŒÅ!•¹“' ÏY{.`0ã’·ôô}Jý¾{£Ô-ØæËsBó'ŒtÂèmÄ·© ‹A[Ót>|ƒiP–Ç©îB/DìÄ, ¤Õ³ù–Te1'LXÍ YÞ•ç ­*؃Ülq1ï\èѶúQÕ€ÊuiYçÔsCç[£4‹Üð=%‹ßB¼$ǃZø|G3<ϼL€ÇÓŽnyù©fƒpTšxDêô£%O«Ü‚téNj~¶RO¼Ú—sD*á(Ï]ÏOq@¤ÞnU6çJMÁÙ»zæ.•¥  S*09š¿‹$ê?‚+7‰”Èžl‡ãB»ÍZœÊÍû>‹(=ƒá¸@Fìýâ¬Éù1€EÛ\í™ÏÜCõ4nîüæ8Ï‘õwut•„kŒ_†€Høà]­ÍôLˆ½£$É3e‘WÒ£ ²þäûKQ´µ½Ž×°­Ö\[܈ »KïÚ)G+Y«ÂIQ}úö{‘ûx5Œ<J»ãõg¨Ú²°äÙž«s8¶ð¿‘AË"_O^[ÞXf®A·9BNt³W’ï«Íî(uL–Ùô•*ŸPå(:pø§}Ð]†#vô³a˜ÓÌé�_˜û]„­U6�ΘnNݲ£I”_Qߊ<rbd~a~Z²œ(™\/–J-p_ƒ±——úC@´wV­óñ@Ü8ÐfË›~eÉÓšúÎðw¥/IÏ ¨Æš=o¿ã€²øFZœ{)ñU!“襴▦¹ äÝJ‰£èF!ˆ»ö³Ês³¾­oùq=óëßÌ©¬ìµ„ ÔÈ=ïWgJöëTï[‡à}ðvÿyÛôØo†Û…4Y°ý¯üo²ä@·J»jQà3O¦õ‡Š Š…ǪÅéIð«žU¼’Ä'TCûÇÚ �ºEŠT¸¹æ«Õ€ÎÍöQ nó4HšÎ£Ô€òB%Õ<݇þ¾ÒK6¢È²£Sô8Aõþo•Ö †™^fX¨¾ÇaY§VépÀÚÓa&»ëÞÕ·&¾ªÆFUdw¦#'—U/ uµ%`µ¢#åŠ ú³Ÿv” 'u _„+ Ü"¸€ûºè¬ŠývkÙÀ uDǨpóÓ-SÕðeÂMÀÎÀ.kXÑ|n')´9¶3¿GDXa_µjÜ4eP4z,¤QÔç©;Nz_ŒÉ¼+�QøŠmQÆ7ç¶óL[87Fâ`…CÐü~¦“¡Z4ù=+>håýâHŠõÇÞ“urù£ÉHC®áÙ¦õ{’Y®w/Éy¨èï( ¢hœã³2Z‡ êHh%ËwxžÃjt‘ñ3-ÔSGc~U2oR°ÆÐA›fð35ý¯€(Q¨JO¹*~w9=%5Pœ\ N²š›‘M™Ž—åùÓпu aÔ0Ašk§ß+¶.Hü„oÓAø8¹ÓZJmü8óŒ§`7  çă¬X"÷LGn}ñ& º;¿Aê·"¡G2&Av½¨à9€K ]÷!ÿXí§75qš‡(×3Ÿ0hœU‘&êF(_øïÜ`Mì¥!vd…«\Cºs©U挕<Ð.®ÍÃüï;qùJŒFx¼´p{ý³ŒæD”×Ð_±yOH<Á aWÑ!¬TU´—[8™XŽmˆ>o–ù —ŠL¿‚«¡N·–=Ë F>Ë¥Y‹üÜÛž–Î$MEØ D” yTEH|nY…;eS€É[NZZÐÑñ125VxÉHà ¸÷ “7[¹;ÓŠj* †×‹.3ïë8vB¼0Ö­)JyÜÅ·4¤¬ Oö6dõJ‹ý°iÌ~’{ôz͇dheÃÜ3§}­Öa'U"- löFÁTIiá6}7¸äî'Êz\yîÙ©1¡Êã]'™jˆMW£®Ì¯XYð^¨HQ ÀÂ\Þz€Íw=è|(ŽÍË‹ëL³ï5ìþ¬6‹}Ÿ2X~quîùlš�Ê®›5SZ0êeâ–^€Ä±¦žY"9gÖ°ïÃ$`Vv2ëÛõ]Çr)NbÕœç¯á?ܸ!1¶ZÍœ {õÎú*“nÁ4oŠì?gu¶¶¾Q€Na|úŠÇò¬-Yɉ·¯ßý ñcæ5l&{ÁðÃH« ÎU 3‰Ði °?" L–GvïÕ•¡[•éùÑN ÕAŸ¢wÚ/Pøáœfš‡®½™Êv\™ÒYÍ4Rg°,Í¥íµ <F‡MLÖ­7ÎÅÏhøá�únHYô,>+{ÝŽ°à°ž>Ö©7®ŽøQ4ŠË'*;H;{””º‹×\sàËÅXðÿ£а'ãÈ R¶×2H¾jí’ÇÒzï니ë@6±ŸÜ$‚fàö:´7÷0-¼£¡Ii“(ñ©LÙí÷3uìxÌ•Ë Öàd6Wéðî ã™_ìÉË?µ·ŠŠÊ"�Yz‚½‰“éÝÓšÎÕ |)G‡‹k7¶OLŠ#-j¤¶ý‡ÞÎJþÜÎäpD˜eìá�ìîz%fYæµt0ù©չüÃШƒØ¦iß‘a¹«­äå \‹á“Ï×<(ÚO›+@³ÔÙÞo¬É=Ý‹Å+ÈèEI¼òa€çZdç«­Å ®ÔÌLñ%ÌÌËÅ nËÐîu ñï~ö/¹Á( ¤ûJ0k´jDwí!E¢Ÿ”!Ù-•‰t†´$œÖBÝUrwXǽbûäY»ø¼âË믑]×2 º]pÎjB<äé{¤ïµGØrB»Ç-æJÏÁ”Giõ@Y°£²@Æ°E]`*@TÌhu©W·#!E‘…b}›Pp¼ª±Ab9ÛÝþŒ†ÓlÔQüããb¥4ÿÀ…RÉYË,îöPô àtüãyѳlÏé¿o|µ(ŠmÒ›¢¨?ÑÒÙƒŒ}IÁm¿ J<Ø#wÊëJÃW©l@:‹éä2¾¶CŽ_A:cÕ‘ñè>rÜkpvÃB¤´µê?šÒRÖMÅ:æ4ªÎê]]èÙï–ÆeöˆFsøˆrái?Z8dbLJ=Ȣ঩ˆç(HšƒõÍ™3?eFFiØ#÷+è{5uT䦨�ô|AÅ;¨3RbjÓ†êÚrãñ7˜Š|•ú‡8é1Xp%O—Àã¡,ÑF4…Úþ³ÁêŒù[–=|ÛÁ,ƒý ý‹¯ÎIù\hK)(U-éÑüÖðûãÜÊD%š¢sGß`¶÷HnhõûÝ›Ì3”ت!óR+ñXì¶éSŠ­–nÈÆÝf?X›è¡žA°wN²Êü;•‰òHõù¯ç16íOlÉ+O@„FÊTž5"pú3䆯ÿñ4>¦>ÒÿÎ( } …=h&ŸžjÓ¦Fy¢•FhðÁ«jÕjÖAº=£P}µ&o v¥ûê†ìõ$^âŒT|’y¹IamÙ‹A““8«=úC›©[c+^ñ‚5{²v¢ÎMve`9áZÓþ:»ªÊ4S!kÑd¤Ô5t¾µàOcÊ�®‰'Çã®þ95ùÏp=|omÇaé \®l&ª©vÚö¤Otk„“x ËÞÓê?ìES|Ÿ"žŽQ~ÈLŸäóäzÒî�DçSd_$ûäÖÞHVÒ|¤³ œwn&ør’¿†òž UÌšvKÄaG‡\YèöªÚ6ØÏ@ÆèqYY.g»UfESQS+;&F—ûŒÒÁú€Xåߟtk“Ê!˜*¾-”®ä¢dŒ>“,š #B‘ýo³O<J"õ0dðÖ¼"á º…b(F¸ÛÄŒ°ä¼k~è°³h•g,{sî]K aeìíÜý$z“†¾à9tÄrÚZEtÜ™µe†#Dz ©Ûíçõw°Å‰~Ô 8ç‹~`º•ì&oŠö·Îüéw@sk‚Z˜îË8Ñ]Žßµ\oê;¶ iJžÿ¬œÆŸÀç-‘´0춧›ô©Ec™¾ Z`Jd`pÔõíîOžÆ…´Àè¸Bq‘Ÿ”ÞK“í—_“F³UaÈî?Tµ¼»Gk¸„úÍ­Î#ßÄ „ ”ÊZÅÒ”a„Bì¤Ì=–g>,iâY+s7¾EÙY-¸•‰Úõ?oUaRÙ˜î ïºÓº]ûÀS5úŸÒïK%†TÍ—AIV•<Ë·m=©ê«çöÚ =ѵi#`ó§ ’ºs*82×â)iSï’ééß×{²E>]iÍP®Äöôˆà¤Iù·¯nÐÌ‘Ö=ã¹Õ—;Äû"ôí‹*ÀGÆ49adøœvÜ#ãÞû·_×uêmÕº‚2$nD g­Yt’YµlÓŽì¨õþí<U:«¨w¦¿¶U`#T#艀Ug´‹Ûó¨ý¯_ø`X‡qJ ëWá8{feR[ªŸ„]ý½¾ßlA)*‚Ê4;±<«Œ05qÛ•…=æS½þAÿ@‹”þæ%¹é[U¾e¦\²S£„í%.rX3Øê7ÂÌq¶Ò£u. `ÛT¬J‘ ó䇎µ‹Æ:Œ?i­\j•iqÛQÚí‹#Ü:>®?Ë•ÿ”mNà߆½©ÇºÝ×€u¯ä¿_üÃT6SÜ)›ñQL¨¾ô‘/ǦÞlŽoª¶ÿyËè¤8¹°Kuù Ä÷sž;U42ÌrƒØdS<Gìþ€Ìa‚?… öä\½Ü7v¯¾iÙ]Ê ^F׈i h•ã<“ÙRD¦ÎpÎ,èT¨l æå‘uÀõ•®Š‰æºj…/^;ùÄq uxÐѯ¯ž®…D!!è*<!6TåJŒ’ņ)­°Ý\(‘ãà»hÞË·“2Mó?Ždd:ÿe3IW1†vÌIÞô]Û p«L->kÕƦ¸6 ¸ýæÇÇ®XåmÍ}=æ!ó¹åM]Ëó'x!™?E»š/n/F¹|ÃïXGÇ·ºª:ªùËMƒÙ‚×óݽÅóÞš¸c+Ñék¦Ûópó’…™Ÿ�>kžÂªaBçÊ&ëÜï±?‹µæˆÉRÎ×]œšÞ­{+˜Î­·ßôè<—9. ¿}ªÂÀáõc¶èA‚2›Y£‡†]ð+þÜYW‰îÕ¦I)Øè3Ú˜Fˆœd…ýYÌ$^Ã:Þ cY¸¥ë<±l)6OðÙº×Kû)OÂâ¦*¹ÔePLd—µBõ/û}ZóÒ³i¬¾xHšÌ¤M£Õ«|ôpêÖR>0ãÅ‚±Ê¿ºƒC­“˜ãŒTd槓ƒMõÙÊ6Î@¸pŠ*Š¿ör-+×ðÍÅêâ`–šŽWïç t&…ø+±E«Ëf»FSŸÓá«&$ÈT(ü/Ýàªçž½Q)¸ì™ÿŠ-€q‹ðr¬ÞVâgôч‚ÙVmñD2Œ˜ÿ~üg‹À:Ï/ýÆÜìwÊ.}— ýÅ^7ùû¹Ù%!§iL+“GÄ/‰/æié[£Æ›€¿ùt»Ü„!ÛöÒ°ô0<Ñw͵œ5<kØ'~ZHæ³nß•¹“b¹bD£!™zjV¹lñ[‡‚b0°í„؃àß»ºÝEé²CIƒ¢œKNLí¬;qÿ~q'Znf^±ÉðB (¬Ï 0¢,;º£åæ¾Ú"{é_BH!O'òÚU<:ÙzŠ8amE’™¸u<ÌR|v`hAÊ˼‚Ê×-OZFbP)C dšÜôò»S=σX¥“‚󯜸Zeδ–Šw¹s²‰™gS·Vз¿.}gþyscâÄÉ<HyÔÐÛ7Ë£à›~Ð/­q"G‚•¢/íœQ™S—² ZýrŽeíËp†B�;„'VU Zcâïà8…O<ÂÓÊŽÑÑõf‹&Œelm‚¼Xdæ`µVÏ#;àÚ ‘ÈÅp£nšYîz©q:Jƒ¤wÛýv^¯„Ò‹H¸U…}SnÇaâ›S\§ @åö©÷˜R Œ½2ߤ©>Np+Ï,‹}ïØ€"vÞa‰¼©'p¥Þ=("ÏßN†$}M{ÞR\‘�Š[¼SžŸÄúdºNÔ•;Tá ™²úr©½bÞ¹²ßq¤I€¯y<8OŸk¨/÷Œ'ʲ(,Ê‚ör…õÃæܽ«Ÿvß0EK}Ó¶ä ndhÜs[€ª”jÑË`_îÙ)@^0Í …ÃôS{’xG´}Á®Wz‘EæÃ×èÉ­·Ja2õ„¬öJ¹›AJ;dÆcŒFæ“E:ó §ùݨ¢Ê¸þX°D,{’þI+Ín^wýO•úžnÜø¡¨³¨ÒAŽ´p\¦ýáW³I—ðW®£Nkjt6 Ž´lŠfçÑµ<xÄZ¶rö©£ç‹Qµv`ƒM•€š«¹É§þúwpúÈËQ±#¥¥ rpzú&Öpœ´åû¸ìJBçÑ"9±‰Ä»+xQPx¨g4Fù­wÇ™Åln_ýÀœ%§—á9u1…Ÿ%V Wuei £Â´@@5Îîòxe•+¯»]å”GU² 9(r»50ÑyÚϳµ?pãçãBGåð½µÉ Îí&´Àxüß(t!Î MW!Eœ¹Óæ©ÅÊ¡…Ö'§•q£ª<62f>I)˵>-Ë"¤D£óh’ hï-šé7ŽÅFñ×Ê$2=ÈšL(\øÎé ü¤? -ÝÅ+edt®–g+ÓW5ì·ò! q º—e<K8ŠØÉ–ÇüäŽ)Ý“þËRÎY­ïÌž„SýÔB$LÁž‚tû°ÑXÕ¤ÕwV)–"Î÷z.ûY=œ¿·Y<︊-G ãHÅ›ðÖ´ñÈyŸïxAÏÑO Xi°™(ÞéD1ËUÃZF ûÄ»zXÔeÞØÁÇTès…àË”cKn˜KwÀp1˜7ô-(‰Ù ôzÉÐg6iìsù0RžpƒÆQÓ¥ŠyñGk-Á¦c ;ÚÚO*Y‘[Tk;(](>ÿ5…7 þ°:gùlC]££o˜AyYÍ°È\ß‹Ù"<iÎfë“é]FÙñ¬À*üzºlÑ ¡«µlÔ;í{2Å@Ì¿Y.±Q…܆ŠL¶û±Ïr­3¨¸9§”’SÎ5Lf<5Ÿi¥þ©Ç+Gý­‘ŒùÑIÕÙÀª_àÐÑíºÖ‰‚œÿˆÙzVÿçù•j#(Ö‹–֥̓¸ï=-):«”9Û t·¹›ë_#}šéÎ~&ž¢G,Íá|ÒÃW4kY›&јývûÖ‹dßíaç¬Ãê'1Ô«1‚ê·ž¶<#B4[¨?¨¶p›S_[õ縆'ºÑ­A ÀÈò&âÞãñé«"�£•5TqÇ(ñª)63¦ó™rOÝV?»y®-à*1 ‹†Ñë*BcŠÁÓÿµ ™/Þ³xg]°®h„núúÔ æ©¨¦ì̽8ÆÚ?ªÊøvèÜÙ§¯ šÅƒÎõáÜYd ~™¿ÿRÎy;1ºgÝýÑðÓúPæ.‡ŒË^ÛÒœ9,õÉ®Ä/°Ä¤Ìu ¡BQÑVUU)’¶ûúp´v«gŽY'àd·”L,Ïú\Qž¸s a1ª3}úÈrÐ.¢ÿF¨/ÇSo ”}MÙŽìL{èŒçQÀTÖÌórf0`½ÖžwŽLÂwÙ3ò’¶SÛˆ±´þ滺{šønîÐ)i˜'OŠñ¼èƒ¾àXdÁô=¼>_UŽe„+Ìå³ ²¡ö¬O0#£Ú‡oò,ÇÝ{óro†y4nã sŒî÷§g= N Ûzh)|fôrc s%tí‡ç}ýâVl>¤T¡|y%ü®¶Â›!gê˃¼;-WÒÜep@ßë­t~!(k!@í@gy‘5~ÏèÄ€DšÀ± dZuÆઇsñ¢kÎ<ë{`´á;ChÑSuy–@£â&ÓÑÕÚØØ XÎWä‚o{¦#ÿ‘ŽÙ›Z-uö,ìA ¦[le!†ñ#2šÉÛ?oSpðø/ßÒÒ­Á=ßö׊ßrªyò;n{™e÷sD(ᦃGÈÿ³§´t^Ñ»1L÷brÿWšiž®Ð\úVA|öÁ%œjï}GëÊ%…¿©}Ý>d%r¨¦Ï14óz„žp½WEè…²˜½ Üº½“\'xRæó­#¸Æ–øÁb¾ø;þò‹ G+A[âÓ‘6E´Uh厒&c댽Œã]ûÑÁ›ÖÛÅêÙ4 Ÿ_ ò‹WâOªÁBëg3…¿y6f‘ÞåŠÙX&.‹aùÉ˶ðôÅbd1´Íڌق\ÌJmc÷êÁ¯\Ué M;Cö:¥o,j*0‘zE<¢xºr¦à7ïhÅ|Öæí)é!èÁ 0?yf‹?âá¼f‰ídÓ‘ W…Å¢è3DÒ<ÏbNÞì NüƒîÙ&2]bî“âc Hâ?*%̾ŠÚŒ­s(³TÃD!Ñüåó×\ý—ñIéwÁB°U¡Š®0ÊŠNɽ'1/ôe¯>Kõ;a5K|ÉW¦ ”\;«å|èœì±é@ÈÒÉä+þïåJí8¹ 3AïI΢^ÓA„˜»Ô# ±ÝÅ£~?OW®ØíPRP»zkó]‘):æ%؇=ˆX|ïÍž‰COÊVÞáƒ'ÿuUaÃ*§Æ3S tÒËÎ4Œkðõ»ùéO<«â6xÌSÊöÎôxW£ÿí\›!'ØKUïò–Ú;×Q; Ï?Uƒ ŽÐÃ~¨7n° AÃãI"É=ÏægXîˆEö3+KKÏã�¡!Û«˜îf?GI²Üö¹ywŸå™ëÆ ïr™úZ''³ïM/Otk¤Ü@÷¬º e:OÇûsëñ.í´ à aÿ¯j„àýÖ<t1²6×ÃAþñH® Š3ÿÃÕ�æâÙd…nqºR\@³Äºíá@}p¬F¥ ƒ ´‘X=Õ‚­„é&0ÁÎLžÜé«Ú§QâqM™R9`Nw‹éÂôõ¶ßvGN¡9_7 oŒ÷;·#nõx¹šš|Ô±\¨švi¤pGYÍÞ,õÇš‡pÈB®É‘R<÷iï\aZdÎc’âÚ2Ór,?=𿼣Řã<ï_b|âŽÒ#!£Í #FC X±Ô½uä|ÔÄȽØX±¦ðW‚¡åcf"×x¡3I­B†46µø4m ŒfÚÚ´/V`r¨î&ˆ©5€é%‘0zR¢9dg‚?Ã_¡ß!$�VØ£°öËÿU5wÅ3“è2»±A”$ÆUÍN¦Fë4õ‹`™«$‚¨Q ÖY-ÚnFKãpüòGœãx„æ°Žšû]ÎœáȃŒ÷3ͪþY.SàÒ…–rGcГõ87Ð}5™iºßèÁz/ôÞûÝ7Õ‚$JãT# O»MLësÛªZ±2ŸaÌIj³?-c¡Ÿ†ÖN6‹3œˆñ:t—Ú«C ÌEk.z¡G½Ÿ ÉYŒÄàRú²ñQa¬œ TÎPy¶\¶Õ “Ä)D"'ýQæ( WBO±ˆ*–'[ôÔ¨ÿ±+>_QNŒcM<Bƒ,’Ùm={ ãT“bö~5§­ŠÐë³PÐmêÃÚflº®§»Bu´Uz¡]"ΒȵÍ?¿Û¸9Á x„©ˆ#|n½&g¡ªºŽxñš"‚ò"å9êb ¹\<t›B¬ZÞT_p…W ¢Í?ÍõúŠRzt-UÙ¼Ævöî/#z,Þ1Ëð¶Ç¾ÓÖ#¬@ùâhPVkæ¶,}8XäÔs¾Zâ‘t ûö ‚þ»¦¢ÈÂü:cp»©;T£Æ ‹²8`@iåVáCa‹ù®Œi#ÇÔbª=ºÄ‰{uŠ»@»c–Žño‚já9²ýó-u«9óºN]£ú \£í;ŽØ5¯oÌÐþ¶ ‹È—š‚ a²o¯¬ghW58SÁHOàZkæé¤Å†¥OY®5@Wrª1²ë®vðX¥Åb$Ç€÷;¢¨˜N&ÿ+CUÎÊo…ÓaýؤE‹Tœ2dQ†-sN?š3þNÆp“9”Î]DäN÷§”ŽAm&¦kÊý:›ÜOç¹Ç’{³�~úÏf™]>fSÇЮbÀ…‚s4Ú"œ¾.êë³r±š\Ù}èþ+öÉl÷H[‚=íDTðŒÛã½Ça¿¥Rò£¤`C™²Døø‡Œíg;vJD‘ŠVk ÎÁÊÝqèwT„•dïlÑ8¦Ô¼üž]y~§‰Ñé8Á¥*ívŽ¿F 7nºV„ÛšG…öu/=9,@JšÊ üÒˆ³òûˆ7cßcV‹93TX0ý2ç¦0ýeJüÛ¤ó\>l´lÁPkèÅcá¹·ƒøü¬ç­^‚úŒ;d‚#+Ñ ¤Ä–çKK÷»ÛÄ Ö´ ¥Üÿ2yÞ�¨v8€˜~f_KW†ÅŽQ‹*_)”¶i\Pf»9nà2#í�&´˜Âòú7®ÂqTX¶›œ`uEŸƒAp 8Z&‚wôÙ\?0»b-tBé~GÜÚ ßup]@+}º‚Ûä„ÇlgïÞÕ·™u컩Pí² ´0 ¦«ÏÐó{·ðÄ8X£¸>yéÚ)kßRA{Š”‰%hBÞŒcnÊjgõŽ‹Oú ëë‡.$ž¤³Ë–RîÆyÌækU`fH˜ÌÒ/x‹¯ P’æ,˜GpÕ½ôn8ìU:�£U‘ì¼yõ¼|Ccˆ; 5Tuƒ§ÊÀã ^¢YýæÙù<söÉ2ŸA ¡[(sFÛïm<SØÞ›ÌE«ÙªÚ"w:Éb0½(÷{OrËŒYûGô†t©¿ðpyÁÒ]>DÖúžcF™fV*†E±NðËlB[|SÅ‚°«Ü.ÿûmìŽT˜þ8{©ò°*,ë<8*„ê‹)Ø Sm ú€iiÅÉù¡0¢Ofè/XuDm†õ±Àš¢EYÍïžð ks3^Gk8‰{˜‚Ŭ0®PVHKÞ?y«i{ûD3ý¿’ò{z ™é.ÏsÄí§S—§‡s°ÀdÖúÔ©Æê¾[”Y<úÙsd’ÝGgÜ ’\RÏVþ‹ê‹úÐÁ·Ï‰iü¤™YÄdßH £E­ø à. =¯KÏ 9I~LϲŠERljþ;K8®#÷øõÅ�n6Úß~º£’®Æ×¢ï‚øú).E·E¢)v0™(†Æøô•ä-Ê jˆ©Ì;:d«ÑúFe n°‚‘èsÖ‚q£•»ÛQ‘u êoô bá&’5͘¢ZìÐ2³0Uµ”â  3×T2ÞŽq¢[ïüA+h°¢­UÀcëW„;Ç™Lècl´»º_iä^ù”ª™nXôuQ�‡Þ“9{tohr¼I´‡ XûÖ[lBhä1vç*rV92E‘WܳGQÍÊøóm&§;…׸è íÕÈØö8nŸoöJEç®ÒàÎÄüAÛ©èÔM01Fòl«¤’!PL Óíò ‡zC!È4C8WVû_wèqœO@Y,[O¾Ù4nÅ•³.*gv8nðˆ0þ‘h”­¤ BïJÙ4îŽÓ"H† ÓÁ¬±üYÊ;¥Ã#nù§  êqáHá}ö•(8·N6 -ô/=èr³‹=²ãÓáb¤v;QhÈ(ýTñöâægТluDÁ¸åÿ^-UíD¸[¥yš­5k¦z"ïÿê=ýÜÞ  ‰XÄOÆeÖTLIB§=¥Ôv|•³ïðÅTCÆê å{‚mºæBÛn4*·R8…'£Ê¶´>‚¤ý²0upSÐfsB¡‘ASç®ä…¿B ÈÖÓË'\€›ŽÉ3£¦°ˆ_’ºtv[‰?ÌÇ4¤ŠÎöòÐѧãôheÀ:ó¯ø†¦¹“6W’ŽÂÔh‰�EØÀ§€“ãI燩~xÛþ[€äë­W„¢wlAHþÊZÊÈ¿å‡ÇÖlwG„QYèØY�#Ø`a­XëcýSá¦z1DVÍ ^f‰¬ geâY1µmW»‘#æ +MgöÒÓtú%mļôYa)Õé¤XøOe¤Çü£;µKk*…Û}D0D~¾nàÔy'ÑÝØÊçÑÍOëž"—Þ㔤TÂœ¼¾ß¡«iû°¢9P;~ûú]â,ªÖÒ¢tíèmß{GI¾t-lé…Bêp?ÚW9AŸ =ÙÓ.fçX@ï0ü×3‹™ÔìfˆV¨YÅ9Ÿÿ `¼Ì7Ð ³�#âô½óýr¦}çA¯^”r°üaÓÍL( S¶ýô¸ Í™‘.|Êq¡(TY;÷§¶V].3˜îË6gyZçH°éˆ¶W?ð$ñ)ªˆ}O樈¹ 68˜)e ^&Žòöù-/}WLkRzß±õæ)Û=S_;ü5÷¨ý7ÅâýÉoÇ ÛËVèÖÏöuoú»ˆ’ÙJdŒîéi s´¨ÿ5Ÿ×JÌþç ªÈ2¢³o˜ëòi•¹“ÄãSpö¼�˜/ÿ:xÆi8³FŒ!†´çQl»áŠ2£eDtö®4©(×^b˜ÕÒ’.šw…,QŠ³,óN´ÿ¼ÅùÛ?o*—œæ+d X‡æ•ó¢–’¾ñ¾=STúJ€ã(3°&—€ùÒé? àqh*“a/ž‹hx‚vâtßÂ6á:XãF†p£ö“%D±á<iÏ»ªÇw’K”ùz)Ðìs:Dzg$àiÙ–‹ÃŸ<@¡Ät[2ƒRÆAXIuîÞM6Æèç“œÿuA–®œ‡h¹O=­Û¢9*f2w×Ñêíìa‹4òh_³¯7SâЙÕ’¦IqˆÀO‡–î€ocÈKœ­¯<ߣ¨ò5ŒéülZHugÏ|‰’ôÖ+™…ÃÒ@L¼u 5æçïX‹DO¾H©m_Q5 M0®Þ>®GÍqp)PüÖÏ9}½nÎî|‹mí|½úú2ÛÜÝë¡=o§UØŸ…ÿ/ ×Ê«TdH8¶ÖcéÞ•ë8äIÄR0Mci«]°†�Õt&¾´j ðód±ˆWe`¾ÏÓ’£¹¢tô�¡7Æ. ð÷<­~ç-ôN[+˜–À�¦ÖU½­~¤½hº¯ìÜ×÷¥c§cÑÓej%l‚x8ÔóA0T“ªÕè\çɈ§ð¨#|€m=Ù‚<0+à>ü°/¶SÒÂHOøåøîrÆÝTóØœo7jrä)1¸Ã|½×—¥—¬Ú²èóRØýXÊ jjMdþIæ]¦Êãp”pýÃp°ÕÊýQ\$Ó¨0™kPLÛÖh_!,ÐAgÒx æ€_ëð¾³ãõÏ,Ûè¨Ï'Á°>0˜´óað‚¡Þ3*lXáù{Þöv$G{Â|F‘—VµéùeáŒÊÉVÁ±/’†#5x¬q¢ô!µØnŠÈ½v/é™YoÛ e�—ã®c‡¥? Å·¨é¬mj—Ÿ€)®îš/ˆ‘¥¹šÅÕôP3ÿôt[ßë ±ÃÞ‚£^·UzÑz©,VŒÈœŽíœVMÁ0;GCú P­7×Úþç_ŠÕýof¬vå±Ê(Xcïj.w¾ÐgÄ0fŸíqØAò|GÖ;²Gš"¹!i_õŸŠgˆk‰.£Ãdi"þVà>ö¦ 2«(]9kaÊÐY ¹Í ð!‘¢ò&¥<B²Òîï_zù…iX…0šò׎QÔ`!³â²Y×îH·|¾åӃߒ›nÙf äßyp×MM§‰µ¼;Ž×H^ÞÕÔÓÞnë·Íu¤nÔ½_A ÍÀ•l»Ò ?·®;ÈŸÓ…õglw/í¹â4€$™;ªÞ7£°2Q3åõÓŽÌâÂ&{è9¥,Fí|"Œä&´öƒL ½Ë’ÔQå g0¬n¦»l.^”z ¼ý&øéÂyÎ]7½HEkrêét±†Yp@C²µ 昅®Ý쬭ö |ï…–by‰ÄËÞuÜ(Ë­‡ŒV¢B Ì4Z|%9/lO¦¯§cnžˆù¤…Z•Å¼BJºµTz¥§“{wàÑ;+âÞÕFC—ïßT†‰ÊxߘJk '«ÎŸ{d½ª N];ÖË¥u¶ê"ÑòkÀ{Ë—Ñë õEÜùîϺ>ã?óùDæP›Nòú7Híf½ùÑhN¬Ø®GºGýÖœ¤¥'NœŽ¡ÒÛΊÔeÖ¾ûòàÂ×mDÑ 4}ºÒ‘Y=ÒëHA°È®Œp_茬»Ñ¾bæIæe}9¤h£Ôd`gïnSj”€|HÊŠXI„þ$Èg„›2õñlFª/;阯‚‰ÕwÑ3ùV®ï¡(˜u—bJ‡3|£ëÆÓbi/óàeÅ"! 6çÝÄy‹ Æn<;¬y³á_'Aÿ•i§6Ae¢Aut¸`žöfñ7«ŸCËÔuô ƒGãáå|;øÿκ#ò†rÒ*‚>='+ÏHI†�08Cb4 ¢Ïæ½h4KCÈŽX¬ra1sG©-ücD‘Y¸\WÈäqw¨ðç+ vÀþD!(·åe„½¬®S¦#!ŽSÖpÊ4ÖZ]áXÌÊS‡éØ—ƒ¨E…uG;îfc²·i«öç_b(ç-Ý`~V}Ì¡ 0Ï®g[ƒÔ¾'øèó²„-tNY_Hu *üðÚ?gÖøöOñvtÄèr¯€žî^ô´¢íü/¥^£,ÉÖü É­›w'0´¡Šî8YÕZIˆý¢8NVcñDnA¯ÇSÊFâGTÖœ„w¿z–{ÙËW±J~Ôéijö8­Ì‘h÷χ3_Ó¼ÒòzjÔ¦J ’£ÒYhžµÚ£M5ã²m¤®Á°÷Ä.Òãy¢§„5˜¹¼Z±#n…w>îdEٶ苽Ò,)2çö@gö‚®¼hÛˆ Œö¸(ÉùG™Tßé'ûcžµºKç)ÂÓ±2öÝþ  MôŸãí”´ô#{É‚£Ô`úè§å–9À¡™^#iÍ4â'Ž%,ñM Ìã|]ƒ·™°Ó‘L•zó®zúh£¤^²ŽçZˆFúzŸ ®¿TLEPZÿèØ ›}‹‚'¤pºùñ¡›sœxMRî»_ª é'ëºÔˆÂóÄPa“6®; á`Lwžîü|•B3g- Š¥q  3‹óÇ l]ŒU¡JàYä½Ô@sÎ<€ßà+¯GÆ8ëë1¦„®µ3sŠ³ËñâÁWnò8“ÌÅÊÙ#›0õôõßO®]–£”[¦>…(� /u­ÔÏE»‹ÌÇ:D0`ƒrÉ»ê=¤LåBlÿ^ñû/£�|sl>ôiŒ=¯@QTêw”À[ÝLú"#%)o~M[ `p¨) ’à泇9ŽŒQÿ¾‰3oüÀ eU³²¦†ãηÿ¼QÈàØœÇz¤ˆÐVèü¿š4ìN/ö½Ù8Á�>¤ì¶ŒžÊš­>[íÒ‡æü×y@ꄃQé§"1l]ÃjK÷lRù˿Јˆ=3 ™a²8«^PaÖˆ_V@èiGÌyo ,ƒs5ÂÝÙ¢G õ¨•X 4£½66:ïÈñFQèœX™o:_錙-ÿÄY�E¤eíù~RŸÚ»—¼Qj±-\ó°¢pݶƒñB7ç|Ò‘²`S4X¯uU¯ü‹(hݧ*D ,”Y²H k+‚"¬=ws¥O·tŠ¬ü t.”˧§5L›üu šQÞ“¶¥xx b/T½žUKsËqRœTñ?ÔèÍüd„h)ó2³GîK7=­½~Â|mGç[ÇA°æŠ,#¼ÂºY'ŠÜ˜OrJÍpåi¡“LÙ�ßsJ›Y敯ÁÏ6&ôi³eëTöìhdt Sb²–óØ9zþ ÈØ]DÀöŽo}á«ÒЧ_.1·b¸í_tè©H¾¦©i“õèÝ9‰++°j(†øtäGVÉ ˜ª1Ô„ç[¢õâŸÉÓ}DÖ[T±š6q·ßn;å'ÿ¨&Vz”_®—À)çži¨¤?žNŒà9sœÇýòV« ×~Úœ‡zº1š¹Kþ'2?í*PÂa\éËF¼Ïtkz »Û¯´ G 3ª·£3g ‡¾î[ úH%º§šõkW÷ØWl&†‚fÞ*Ì ã<bÀQÙµßÂV,ê@d(îœ ´ä‡Ô¹»r}ÌTd¸ŠÊ—= ÿßÖ¾d»Q¥YwÌÿžÉþï¢o† Pc#•JµÎû?Ç/"#3‘%Y®}&ví-ËÍ×<üÁMƒ}¯`üMÇr5øô+ó(Œg Ïr–AÑ�>ÇdÍ7q€m®>©Ðe¼)Ú÷‘³®³ÃZEš¾Š8ÍâD‹k{…ù’U¬>Ë°C†ö e÷Ý躻 Vëã�¢¶ž-ðéÖù29/=ñ}©eÞ(÷[tCºu`Ê•Lð<ü¤Šž¹T™o( =ôó›^ÂÔ4rŠø „¾­d—öâ ]4NV®ÁU�ÒR¼SªÄË¡oJ Pø3åz 9|ªO.ŠIÓ Nên˜=‡âPàú2H>[DˆzI“®E6ŘÈĈç\` à•+›ö¬pƒ0ç�¢:É|*7%‰Sš,¤IA{bQ'¿Äœ?쌩—«÷C¶‡ÝÎbõ›Réhk‘ÊECÇ%—ivŒ"åœ_)z÷¥uºÉéì™x|À¼wgB);ëËôÄê- ãl¥à³`äVíµákôÔ¼8E?óCmß9!ÿr©©ÖvØí¾¦‚ÍVJcH´Ì€·r¾G9íjì%Ö[ëþÎÑÉ3¹/¡S}ä«+‡2¤O¾ë¥Wñ/’·Jû> 2+es]z†ÓÏÐW瀑Õ#KŒx$¨}¡¥Ú±“&=¤a7FÛD0zX/ÿŠ8öÝ!è©;Z¡MüòLä‘]t¢=(ÁÈÜìÅ@ÙþÇwÎ×8Ë|J4‹?Çàpÿ¶b˜mÖýqœTkî" _^¿`qÖ¾ÀßÒ¡dÛ%ëJ_ýöÀ†‚ôéèWÞfd„OOi^ô[»Äð†P°¹J&QšÊ²Q¶HøÆ ×q«2AÉ ¡b:6¿¨pÞMžS˼hÛÙ Ìêv+Í›Þ «Ð ¼ p{:–Aôn[a…Àéo±]Ìö8ºb\7G„ T\a[&.<다væP[û‚-pT(Å®2\šéÈJ6Z€¦BLáƒfb[Cåè`ùŠÀ/a|ýSò•Û(rð }‰ú“vÁ€»“˜'ÍMÕ¥t'Oø7&KØN‰ªF¼Ïâ`8Ñ—ÔòepÈu¸¶àÅ˵¹Ð¹F'RÛQ¦·î†úüòró¬Ï\Èùll‚âäyŸ)¦›y²â—üÂ6ˆâj%ê[Ñ„4ÑÞJ¡"1h™Øe ¨'ûZç¨i¼ŸN¿œYª µ’à4þv0oš•fv·ï®~ñúø9Ï¢"¯è}:› ¢'Èž1]¦‘§š¬½ )¬Fqk½Õ÷.ÂR'c7ƒ,Xvó(Ó=ı<¼ÝÑ¢pe ªQØÉ+DVFaÂÿø™[Xë$-4À\®×âNa¢)[åõô‹¶È“Íÿ¶JÓž¾ˆ еÀ<µœ·ªë‚*­—)íΉ¹µ¾>vÇó)X¢ltb<|Ú} Ø™q˜•¿Ù€WßÜéeºEž•JX`vö¤ç>œ´%’Oèr4§ñw”qiN5ËnàÅÏVÕÚX  ê2[* l yÞ¶ëïÉôfy¬ Ä0–U±Àƒ›!<Q© ³ŸhMÆ™WÆDP…®]£õ_éùC½à(Ľ·°.¬›ÛïG2=ïÀ®­z¬’èûž–Ou=›µ„ÙEÊ+…ö�aòmýÖ\‘ó8öþX·ãî¶.ó}dxÍÞe§Å«‘Ûzòîný|¿•Ö¨Ì(¸Ý'”¼ë!áÆ÷GÉyƒƒ‹mÅi±b!V„жÚÍú;øþsUlV*=kq~ºy½Ô}3> ÚÎåë“WxoFÖGd ¸]‹PMú6ÐùЋJ»r»ÌòF”Ì–Ñpò@ì²ÈÀÁó[ ¢ðVUw. Rª·¾HŒß“¹Ë—ñØë•Lš|GhoöhÛü1»t#®Ö¶qø¥ÅÔé,“JÝ?þë—Q«ê4SÊÞ­ŽJ3_{8¸ˆBÎs› h…§Œ«¥·Î&‘/TÆ,|ð©î\MO ê ûÃé¹w€ýð: ‚U¶{÷ºòÛú2Ø’y¯2 xèúäëE§¸ão(ÉMJ‚µMT¦^a…Kßr>–P¥ ï– =æΚ_ {K‡{à˜9ì¬å<Í_š\éÊÛ‘]á’ Ôh' kî¢ ðî„Iò‚uS­HŽa,½³¼«]ƒÉÓ!rŒÒ×ÈÚQè7#�ÉŠ·÷Xw€+ž›«ÍÓ~Ø\ŒWÓâžùP025²'äö°üÙuT¿µÖHŸÔ|]ë`>ü)äøç³Á¨¥‹€xÈ)ŒWWAÐÅ“äYÑ0UAú©L ôÙÓ±¶c¾a€ïÅ3Âaå;s<yXù4[iæ•Ì0&ÈÜ%ìù°÷ £÷%UaFv*åq¨euUŒ7:j^OêVÈèì)õc'IïR¯Ve¦Âð;ÀT fÏ‚Vëe�‰ßÊÃö5^wEáÖ3”ét~ªýM5¥ƒéŒßÕÌ^^Àž˜ƒ5ífN<…àG~ÓQ»µ”õ†aømõeRµ1ÀèÅ&©ß¡–™ç³É·åøÐÒ»¶2Y³Ww†@|8N0°éš`ÛKÓò½ùÞ#F•òÙÌV~t.14ßô½^µs©°€«¡³VÕIÓ��ØV’¢Æ¢‰qPº¦s®ëí×;à4Jv“ÐQ”ˆ3P}Á NÃ$÷Ý#¾µ’°2Ú±Ás-Àú³µÉËÉ7:lË & ž®IeÜ÷ömE1J{Løô‹¢rïèÈ̶†¶?–sõh—¬B8OYZô'«]ƒÑqôÑâ¯IÓG¹+UEDfcì½·SÓžF"Y $‘˜=˜ÒTŏ¶¨)4ðí—Ò»pJب:2#a>wVkBE¼8Iu¢åäË#e‰Ð}î±Ç ¢ÕÁ%8gf�h¿ñ1F.ªÈÐá°«‚|ï™) RÙNdhJRÊͲæ¶õ%n˜+Šµ8ˆãÎÎúBÖÅ¥ÿW§Ú‚r¯ô©’ÊGÑ…Ü~ [ÜÚ™%²¨}Ã_ðb…Ý #5æÖLÈMs[g'x"¸³xîܯÙt;®tj<YÚksã †Šáì‡iåÒõúåk b-ÿÅk 0ö*ÊN8Ãxi-ëì%8Ë=ä< ´(˜·êV�JË8Ú)ñ½”ânrÔHì۪·²c¤ï»o¡Š±8Óë´Ñ ¶ñ°WŠFÎ]Ÿ–»T‡pZûÖ«Øe¿›`¾5úa"1¶¶™ñH³6‰Â•§gœnèeÖfÚƒžþaæÞ* £ûÕNõ•åL&¿®†=j kѺJAçkö›d*„B -Û8(-°0Œ{c\l$'ÍŠ´/-Ø8ÌnAv'º‡q£û®ÿ�ç­¨q\{Ãоs…®Ä½ƒ=Rá%ÓD¨ä€Œ›³·+8à¨kÎONG•S—6Z˜R2UŤ;,ˆSÝzª„2J”µþf/¨»8V…gF™™¶÷}A¿Çeô€#L”²»ótØ w×m‡Ìu¸Šª‘)¡§öå¦#m æ°Á!ý¾Ó­HÄYd@¬Ýõ»aqœgÞ¤'§‚û{UŒ«ªZ·z°Nßì…¬Ñ@Í¿9«påCá®F嬈pPoꦛaYC@Ìð#2ºÕ³¨Œ»=Ë¹Í >ûþøźuÁ»è˜áûy´kêVƹuéK¶»êO.ÛF5^²÷ %‰È;ĺ4g.öGbT­†)9:EºÛôo™×‹¤0IÂ> ê¶d°Í×L¾¦ÑãX t´,{¿`»�ˆ<™5Ù–ÂΪG§½¬ |ÀÙ¢s¥þÜ~ÆRˆÝÀMd9Ô†ö „1ì¹¥¯`ÈŸˆÂêÆ»lÎsª>-D…Ý>Ɖ+‹q?O"+# 3{ìÕ×nWšùÒ.Ј؈FnU £…úük<L’Ëýófà´¸€ùðEw¾µÏHWT4 Vñ`ÒÝ`:-pd\³<ü" VæS·±ýu“9`Ö‘¿/º- 6ðKn¹<С?žºá>¹–÷.Eå&™·¬Q@Bä› ú…¯I�Zsè¤Rì¡¸Ç ½äVTi>fA|ÚZÌmֹ̱‹(Št›½m•;[Ïé5—qtB ÈôÇn¿Ø³Äñ:úóÛBI½th_#°&Q¸ÒjÉÄG²°¢§úÌ€ánØžö5/(ŽUæßþoÌ$ßÖŠîçÐ%YPõY�ÊP®±ƒ–¸='£°„ïpLÝ|/›éᲈlbÛQ:ÅYG&ë<ÚøÊY美ÌSI™4T!ëÔ`ò‡<È{ݾò ¹㓲¢Õ¿Ü‚´ë#¸Î_—dú€9£žgÒôÿñÉýa‘ãæ; îÕà“‹½Ó˜€¬ÖE.õu÷KQÈ›}Eùª È@·›ïü7W:ði‚yíàÓ;ŠÉ(ÝÐ_3gŠ5éu{íۯʨòüHY¾f^ò ûݺyÑ8ìd8k‰L·ôÓgß2[Q§„�%´H`ö¹SIá }Ò3âW¯¸NÖöáU8qÂÅŒvÇ—U¹ö%B`Å'Ä÷õEt°$>86¶Ý|B\\À@=—ël¾zf:F+¸DîMISÝ{G9»ü}ê퇂ÙW…óiò„Ðî¢wñüMvõ`¾Þï4„©¯ôˆš¡¥Ä S–ZÒ–çþ±�4×WÍ€";Þ(ÍsìÛ2ˆk½Ï Ç4Ól4^ÝaÇäÿ^;zÇ Je²Sça26l»Š‚’¡²7‰·NŒãò<ëᦘŽRWæ pÄè‹N²ßÊ@C…Ð÷T¯]®ý¶»òv˜é4÷-�vò÷{—þ)˜»ÝÖP;ÝzRŒóž»° P5æ ÓáI†m³_‘±‰YŽœ²ßYUHÚ lRè%ÙYƬlFßj”óâÄòÎép%ìдô«bëÍ¿Þ.f!k>lÆjß׊ÜË9ëÇ×9ëb™ÛÆCïÈܸàCú—3’ äƒ+h¦mÖEF¬r˜è´wâq‘ § ŒW 7³Âm¬¢´]îi…æ¥%'ËÄa³�ÿÑhgíxÅjt£Rq°PyËjoi1Þ*ÉùZarxž#Ï7•µ0YÈŽï¢ï ¥-5+V ðzÛ³ö¡ Õฬ›å ÉšÕîüÕže¾`Dñªâ^ 4“(ñ!ª6x úú$l•áÊÈ< –‰–¼ecjm 4žkZ,›=ºZ@½£a© V;Þ�Ø×*ßøÓÓÅÌXã±Îé>Ï;Ï-ÕôtžÈ°:Ü]9:¨»|˜Öåú;ö,w…›GÎ; ãÎðnª·ÛƒàÕ(B,àãs‡~èš—Ñ‚iè‘.xšÛÑŠ<YƒD°†M_¦ŸÉ¾–^£ÀÂÙ4´7ÏV½ÇiÔ|Î6sŸ_¹þq¶Â“P® �ê秵ON£`Î HÌ2Kç¥j2®œ&¹Ô‚JÔšÂd‡ Ä“SùH"ÿ‹ü»H,HÄw`T‘]µž‘*C6ÌÈ£bÙUž±ÍÈa`QÆîøÄ™ÁìêêlÇ9@Ú!}¥4ÉʹՙwÄeLRm“ üœ= ¼¹LéX˜«®+(öÇÒÙ¢¹ùuÄU™×D§¨8œ(±H­]':ÒWUZ p¥T7]Ó\LŠõWꬬRãMÛÌ€ÕÛ®FYiÏ©ÎVgæU¡¾7Í%‡¹¥_qB㪤U*+ô'P‰°§Ÿ…ñ`ES>ÎdŠü_sX‘)ïÌUWv3RF·½—<Š´™§Ýu< þgǘ~÷=@«¾ubÜEfˆ5Fzü0ïòm¬uE§Æ1Ý´9(Ü4ÃfßÓ´ÏóÌýD°ÇÉ÷Cø‚xÞ4µžÛT£/lºÉ DA¹¬_ŒµZI¤`ždŒ· _æÑ-ÙŸ·´ÄƒéŒéz�aYÚvjŒá}ã‰1”ÆÏ÷ò+ ÊîÓ}`$½E7�–%3ËØÿâ•ëE¾­éO·d¨(ŽBo‚ ¸Àœá»3)ê­•¿]§qùŠÜM‡³­@ØÝñÊc î_€.3ïß ‡óÁúÙw ÞeŒ\æipÒ¹ÛÌIÄŸVM<âô¯=2yE a:g‹®ÐOljú›&ÁýŸÂ¤wE&£p8P1aõÚ`ÚŽÝKùë‰O§aX»«¯=żÈ<† åvµÇ/žVýw“›³^€èå©`^c6¹›“±µÅAùFgÙn§f;fEíÅ ëiã&‰pûDâ{£ ŠIû6%¨8THMÎ1š‹¶šÞÈ»z¶S|­ÚˆÝ%–˜‚ìÖCcsýbÄ=ÐCøÒR¨R'€”=Ð8ÓG2!ëíl[¯ HGžš¤p7û,Hç³Ç:éPØ­à)›q꽕ӭ‘Çð°zLBßä ‘öBÉKéRG,¨vRy‡{ Þ§ ãÔóKä÷%¦¤ú·›lcÙ <ëŽ?5pMŒÈd×ÃX,»H�öU» ñºa&Î9Ï–!«uOoú©ü §n0ÑÃGÆUf4 «Æê:nŽÑ\?*ÇåJýŽ±‹->âÔÆ<—y0›>=SP¤wH'íÛ¿ Ðîh‰¹©—ög LX€_D**Å÷²YûoÌ)K7Þ4ÕL‰vø9™ccé\Þ–ýxÄÑ]SEÌ/®ß¤%{>I:Z¸œÍÞ¼FpÍóDQh7Ï=µ{}âp[DFw1´±kPÏT†›¯ŒqƒÈ²;_~�üÃJu>®‚þ ýiC&¬ÛÏ‹‚p2 à×ô?Ó·OR—™£6I‘Ji¥u-®Ü(˜÷®ÅÉåp: ×ãî¦QQ9…U^NGâ'+Å’ Xœƒ­eŽG�=fŽe>÷·§Ž|/³�îš�>Ö)ù¢XqóÐ6Vâ̸ʩÎZèÐ0fñÄ,A¤Ì¢.ý‚³\¬³8cqš2}¬¬O^Ôë¯& Êçｚgð˜>¶2YLYñwÝü©†=E†Dë8¦gŽj,+OÅR¤•Í|ÙRœ´ê*±ˆÂ4"6hPkUÞÆ^<nÓ:he®þÙGÀ|Þ}˜ŸwJR¤›Ç»kl½+[T‰íupÀGæžQoUù1à¥Õ…·5Ùºd(…b_9gÏû)§Ú@“Æʨ*ûŠÄ}7êùôÜe,ÏC_·"Ž„1côiÖ°`Žg§õíì×2ÅRcw%žQ'ä?q¢jŽ×{‡Çs§¨<6"͉ñmÆŠê1·P°Nº Ž W Üî„ÈkÜJ@åzÏj—y®`¤É´åû®gXø™}÷³‡‰/¬H%ý<Au²1*EêÝÌž²ÒñÌó*: ¾‡niDV·1ÌÍjLQ±mÍÁÈ“#'a r¿A=ÒúÓµñ÷jEY±b^B!Aslq, ÖÅ ‘­bfÇÇY¨JÓ!ûZÁÅníŒ_yªÜ”ZìÄxœ&¼ë·ã•Š##ÏÕwy¤Íâª_Eü\¹Øâ)­wõ¥øJcyaä˨À+‚¢U;•÷õ•sY˜WÈ¥ý]Ug=O+Ö—O¶ZГƒ~­ÖÖ:À™Žýøxê ·+àñ“ð@øRÍuÌSÉÝ3át¹i"P9vý[&àËŒ;¥ÊPÏÓ¼®ºÄŸ‘³¼åþ”ÕpÕ9œÌ€@ξ;v=սǓٺ7ß?²§.ü€É  ®èy§âyš·Wbï¥ßð¶§ÅJçæÅ×™á5°ƒr¨¤«›Á0gßí»[M`¸²KŠ„‰uþB®­gÝ^-”"‹`. s ˆo¼(q£ò¥¢=Žò•hÅXú¼ßy¶¦8å úb%þF~¤/éC£P…§]ÎĈȾ;sM˜KonS'GísÓ4ícx9~dÖð5*˜öÂ{É,!¤õüEK7®\ðäòóÝ?ѯ,ýN2TßÀ3Ç&s‚FvÉÇV"䃘S¾è&~d4›Z2IboP¼ï;_0šÙ+ÆÊs“årå âùMK ש“‰fžÚ-,Í3&Ì1Ä@öÃT3¦AµRýïfªU8œ°•¹/ é@8Ïì¦c�VM (™ ·ŽÎw]LÒ•(a Ì,nN­ ãª_‡Í2N‡Ú.WŽ=ÿ6Aí`¶0~/B ¤ßѹ«áÓ“ò5„=+Ü÷�${aÁ·Ãq¶|.Wr~î H†Òኹ ŸŸ<³NʹfaªøúšYº’ …õAé�Ä)åŒÐ&­wBä¡égÂñc½/ŒÀÝë?|‚.⃋Â\á®ÎÍãXS>Yãɇ֭ Ó ¥1Ïø¿0(/{ç–FuªGîw`™{W_Ð~‰ç Ë�šSø\«’ëcÑC;º¯áÍæ.ŒÜÞ©çÒÙ?ÉŒìˆZ­ü½|­n¿­FYÁgñ‹Ðþý¬§ò™pŽ*uÐ4Ø{ž¤ þVˆ‚îÝãý¬âI,y/7rzè{Ä‹·Äθ¤kZg7ŠÓaÞ³ð‘mºä@ª`*Š ®·^šuÛµ‡LKàºúú´Ý”0Š„Õ¶ñTŠa6xðtŠ_ª¶J¦œGôjo„AANõ8uÔ|ˆ×ôp?±ô£iÁ…‹ÖN§n˜h-Üã»2‚_Z 3¡Â³íX%áæÛ5§+‰KùXؘâLS9-€PV|kôM‚Ñ_ ôÕÛ™ÃäæÄìgˆºž ð—Ï ÆaI˜{’c¤ó¬ÏWzø¦±…U‰c ©`牂[º¼î>‡ž(= ŽAú%êÔFõ°YgÕI B‹ÌYß’'}“,ô×Ü·GJÜÏ;o²;æ-Îäa õ‹Y²uïÒœñʯç %;Í쉾Pñ5õ�MŠÌµi=?õûÈ‹p=Ýi»"ÈÚE{ÍÈJέ(úAUÚ‹Ž" 7,WíI9HØÑQ|Š·J6[Ò*¿xÉÕvE×JšU(WV Ö“±Î‹›0»oÚ¤vޯё¢ÒÎv1æ<÷5ä_•»³›Û¿{¼Š~°ÎÌ ŒÜËpÌI½\Yà ÐׯpÈâ—U7[ÊÝ’ýÕ[(6ñ‘~7ÀhÀ¾¢•ª²»Ô(”ïÿÔ¯í5 mŠ*(Γ‡ÄrÓt¾hY>µ,b¿Â§ q„Éäûìü¯NgH•ª3±œoë—GÏÌc†ÄQéûSã‰+"^YùX¡øWÏÅQó,ó=ecÔÁe ‹G§2­~gÂ><]X}ƒ©þo\¬haÀ‹/î‡T£ª‹>ã¶Çé »T™ñ!»Oà{ämh¼¡òL ‡ý™T›í3¡Dwm4}³¯4³~TÐ;¤À6Ñ[6'Ï•Þp´Z4Ocb¡€l@ònd½= žyÁ€/œµK‰+øHF¯æ<Ñ;BÆqœŽ3ö®<^ï×7?t>Œ²ê7ûœÞ´Öm–acù¬p|Áå0ÑY¬/+Bi—«ô+ º˜‹ óy##oP8h˜ÔWëë"¶ßYî$Ò‚W^‰˜É§öõ/¢Ï®\†2â‡kOÜä{™+‘ÁàRl3 ÚE²¿–is#¡¦_XÛŽ“×ýºÓ<å+§Ú¢‰àt„ªìƶ…™yk=¬.Wä"oLcg¥(ùÁË<Š"qÊ\)óÝê"òÎ*sqv¡ËC‹Ûm.…9Ò)ÉÛøÞw÷‘i²’ðÏY¾4lw¦]& ÿ%‹‹û“ t×ú¥OÕê˜+3Ô÷eà¨ò Ø ; Ñà^ä$.ügÂ1Ñ$H_ØÌ‘Çå“ç¿ÙBçóÓVn¡ßRJ}´û"J‡íöË«§°«ã\‚ãvkTÌYšªüød5•Ö‡MS€¯¶Áüq#Oì'2Ö"ó’ol·›@{µ‡ÿ:|ÞD¿IßØèr™+³€¤ƒJîß°‹¹Õ‹0*Ü]¢Íz}<¶‹³Ý8®²kdO9Xѽ{óóË ‹P®®;þž¬^zÛ±v`…Ê0è6,UÓï,T2滄ó^ï8Šàõ;¬ç_•Fåª$J±ó ù½õH ÷$æZ°ÊöÁ¨Ÿ^øs=?UâàܬϪ1q£eˆÈu9¹ãˆ<³÷oEdòxå­RóÅ íJ³l�¢Ô¢Aë͆¦œl*�&Úëïüµ£0úfséVË#VmQÿÈQû–+6.–jUØÂ_f¨¥@¦DJÁ­ b»X°ÿBWg'ot…šÀuÛMn0ð1„êâþ­—;?Q>¬…ËÑMšJVcr’TP3ܺr?rxá€F¹ô7c,ðäe’’³JvøëÖÌQ˜ zkcð¯<~O€R7pe¬–«‡³S&ZÜÚ2>Š>3ò…~”J#ëU<׿uaÅ“¾UQJ«ØªL%¨"yÚk)aÇö‘^F°õûhäãù8ÓBµý´ ‘ºu.ü�Ë“ ŽÂ¬µ™\Â}“eÏIŠ@ÿÚ7ö°RÒ„ð<\¼¶ºÚšuêįï]}¿ÎJs¶WFÊŠç‹ÑÎ΢S{ÊpÌc;8¦×ýÕˆ1ó]– 18,‚j»ø1Á¦4ÔÚÃ"§8Ïð‘6ç?j(-~+re©9fP«v‘’ç„)Âi»™¸üL°ÈÁ¶d¾wKGÆâ[Þ°Ã#”ö·öFYzÄJ-— pËíZpRÖÚÕx0£-Rc2Õ´@ÉE¬ø4ñP˜7fÉÝlª½>Ãǡס´MßDBájež'w™{êÒ2Ÿg<‡¶÷fjË„SiÏÖ}Ú_½i´FÎ¥;d¸÷U}ªqžs%k[O߈vä+=E j*Þß=º#[tYî­¬i�Nç·ñ‹§Vìñ‡ØïûÂÒ†¶³bÀíÍ›2auøoßý׸ÛÞùÉ!=ÊiK{ܧ¬ät|Ùôž(ól|F®£¦Þ=ôqL"Sa„Fpu΃¢Õe–³CBOe‹4†  î_)³ä‹ ÙD{'Ý*È?–óËDmXTÁ¯=¿†&´œD0ñ¾6bæϤa²§³ø}o-’êÛT°þÒž|åÚ7¸á©€ÞUPÔ[ªG•ó´uiNZ|q.2oiÛ܃vE³µ ú¾n[)ÀY.Q ;ç–ÿÔz¨†å€BFæõ,mñbs1Uy ‘3Œ‘B|mÑZ8“ì°Â¼9r¯_@ËOüµÒ•WnHÛ, ’Kçœð*‰Výš†åï/ ÏÇЛU²Ã{úþtñ’‰ºßQ=à¡ÔBÜ�ø¿äˆÔ4U´¤ÜWó¶õðõR[™Ý†½º7ï_‹»øãŒ,NåeÆÁ¦Ÿ³ ™z“®#yã*Ì®ŽËÔÀÊ–m"ýD&¦B.b²»I $eÏE…÷=Õ“3_úþã kW‡ÿð°vÖ8;gùE1¸ÞS÷Øs–¯æ¢‘Ð÷³e}„V,rrk»é§²8¶å+e†ª±œ>…ò1S‚,{Ôb“éfÉîZ0ƒÆ¹¿BÓ Äç2¹ žÏåf?f Õ¿ÖÌQ_õe ã.¸ƒ}¾C÷Ììx¦ÄFn÷eÖÊ–BmY&º"cŒA(‹_¾Ïú•ò\øØY™8K7 ÝÒÞïOûû׬k“µ3t."“ÉÉ;j˜¡¡�¨n˜ötÖabÿHf2ñi‚s&Ò ÞÕf—±Ó·-Š­(ïNrU¯ë[Y¢õ<\ú=ÓΓ&¥½%›Îb¶þ ǧäKW®‰+645’c9Hœõ4Y Ú×Ô¢T3(ÍÉÖ¤”´|.Þô™’®qð”Àuÿê¾Kì‰/GCG‡ñþÓõÛù´^oè»'™£C1Úeèbèî-9Üë!`³­«$$w*>óƒ#4pSòŸiáÿ9œyÍ:û:ŠWåÞYš–#ü ÔéìS¾·+³ãâM Rè ±ƒ ýà M3 S@¢<jŸÅþâ¬8Ô]ê¬Ëú•´RêÝCÅÆÇúqß\2jq›;S¥bZÓÿÑjÔ› ÏœÇJÏÂ*EàÄd¸\)@åçðð›ì¡žÿt$œG™—¬Ñý<~¤IP¼/¾j@‡a§7õ$¢QÆ9@R…gV}®IÎm¨ˆ_�´úA'~=P}­%lËؘS~x `•í‡1|oßm=Œ>¥PGÓ%y´ý'Ê‹SD¯#ìcz½ç9Òíûľm§±5»œŽGùEuŠâ(óR]ÐWQ–…æºè.²;„Ç9ð_©bopŸ·ú¹?ŒM’2¨~«Hšä_t4Oc¶Ö^Ôü³ý©“¼5T²åtC™ofy¸s}1ª:ªf"ük?€o8»¡=œèX5sdó½/ÊR®f—´4ú:¦4Û®k>çY Çþ6äwŠS1«…ËŽß8{)‹¤§³V…]+>}ÎÅë–ƒSmq ¥ÐÿCùC‡|^Ä%¸,h„õ0ÅçΨgË@Qô]U.ó¬å2™ó¢ù¾ÑïaV”ò=Ax‡eÎÈø›[3Úì+ß%’ÊP‹‚¢U‰®ÎŒêâÁâ->óå}èÁw¿;™ß½r×Ép^”¹~èÍÝíûQhp½a/d™ïÞ‚FÙ–r­UHUy�„é|ÄÙød.%ñ*(§6õOnca3ëUIùªlU”†kå^СòË¢£Vìe*)f3е Æ £ÿb‡÷<†¾³RÄA艷 ­=—Ó\þÈÉG›làÅ‚÷óêúç°Û¤ôóÊp ³_ZàŽè¯l·fPׄç²úÂm¬Ó#P©r”Æ@k–5eá#îkT¹Žø« ìÛöò3ìrª°­ñˆt¯Æž–ÉÝfý#SØ2µ +hàâU”/|:¬ã¬c®„¢‘Mã”mKÕ<”¤ UûN{£Ì• #Ä“RKdæÛJ¦J¾¦›”'™ûH,§ù®ÞŽ2“n8ºLïÍŸóàŽ›¦å»Ö 9û-¾‰$ *\¿ y+Sg:.u¤§Þãr3]ðä­ã É´—oœBÒr--’‰ZÍ´xóc1?^¸ˆ2„ŸHÕľlu(z§,ÝlÀéÓ ‡Ížâlx¥AÝ0þ ¾=Ѻp+ƒå3ÊN× L1öõéTÓGWB›EŒßEŽG‘RS“n6 %ÛÞ4¿˜m&¸T£úÕ=å‡>*ÎJ³0¼¤ Äà[+`Ÿñmú8ôíÝäóá°pÝrƉ&ºÓeLø¬FõAü;mFõ–@‰ÎäÙ–§ûÃìÊ~:*éÿB³„—м9Ö§e©¿†æÛ¨yÍžñ[‘mßÝP“p…Áå¶x°¾Œ§È¬2kŸ!þw«ÕGÇ~†ŸÇ¶Y˜ Ã+Ķ§HŸÄ1O1“mQ{»Ût(•€ö<%5˜ç±¸RÏ»,ez˜”–æ–°1Ô‡¤EøÌ{üПõÎä >áaÿïÿÌoýuL{;ö«ãv耊bfBUZ÷gSGf?––ŸÀ »£¸2 @± {ûèÐÏ}úÇ®À ¼³vïº÷ër_´(j¬$ežhËX~€ °rZ ÍÕãÁX5tÈ" Mí%½í(.oùæ¿*O‘* ®ÐbF)mcY Šâãðù*³Ûï-“j%´NgÉæåS¶8‹Àzt è¡ð½±ÞÃöbÝŠþãY+¢#*ú(­:§Âͯ[YقĹÜ_¿Üìx+n!¥Pl3k†mLO(VI÷5ÛCs×BÐ)_~[³_á8Ùi}:kͺþŽ¥" åáïԵ㶷(ç&õ\0ÀcqÉ›_¸¯¯´ÚÍ×g5Eö„F jò °Š¹”ÞTÿ|ÌÒÆG_Ób¨¨ó¦×\뙿ó˖ʺ^}~ŠÌ×,¹Hºä’»ƒŽÔË Ä·àci¬â²söœŒâ»½§Bo|”ŒÅ¾2ãÌæšÖ÷öjºÅõy§Üž…uŒ&ý T®”×öHpEÅÍ4ÈCßAn%p$…•Äè5±Óö7í-'º™™7…òk~5œòŒÃ0ÚRöµW;Éä¨,('‚iŸjt§Ln`›D÷ÎÁÆ,0|HÏP±tØ»‚6/I/b_™‰2.ëÏæ‹¡RÄr£»×±bÏS`ŸÛk$û‹5³¨:̵ÁäÔ¢ úë"hDù§»úݶ€æÍ‚þF9Q28Ÿ•ÍÔËLÌÌRÁãåæÅ Cø¸ç÷âÔÓR®ìIt<ü9Õû�æڤϻó0f´fîCâì2²i0îÖíÜL§žÚrΩ”ãÃLJ¶·åÅãTâAÑ=DþªùD[‚¢FÒ(åB$ ùwàÁn)Ö“’€Ç‹¸üëûjÒq¢üYUäøXÆ'oº¶¬ªÅ!doÜÉ%”ðÌDø¢w,œÝŽ/TeiDûšV£i?ÑZG?dö«ÑoœOn\P<ËÊXÂþ™ujÊ0;;έ“Û4£‘y~TåF5«0ž„ Õxe[;mp.礭öTÂ)ë@¿²wO+QC€½ˆþûªÜ×fɃxVæÁÃT;8»ˆ<–: =dॅZàâ% ?ÃÖQÖÀH§ŒC -�còÑWÓEL•Ï7­ú_U}ößôÿˆS‚â,køÅ¿sãN+_@2æ)2ÁçZÿ”ÊÎZ›Ò<žì+EN]ýqÖ-\Xå›8–}ª1¨|÷¨ -ð…è•$>c?„l?!{Ûk5f opKÐÇùר¸¸p\dŒ‡J\(³è|/Q*› ÞCifôÀ·_7×¼^Ÿyè*cÆSióî»i!Eß×Y+ψcïê~%ÎÓ*w¦YÐP¤Iú“žª0<äÓS£Ÿ°ÕPT•õ• Ûpšª ÜKKš#Âa‚·Œc{ʇvWÝ–Æ+ÈY¼2o¥Ï¼ëéûÔª½UÀ]þ« �ô ÀMLx\~åºÄ…ÛÉ`%P"Võ»I•Nû±¿ßö ù€ýçÍ÷L¢ƒ:Aór¬?ºéGô$Ç«ªLçIvÝiïIOœ`dzÿÍV³Ú¢ZžÓ uûwæãíÌÌDžþ0›/"'n‘1+ÆrTø‚U,G ZSo%™h Ò»(ÙN“¾­€b^ØÏíëWT"îK7#ïv7ZîÆ•––Sí‰.«ÝÛ7£ ëP%žÃ%;–Duíé”ØÜÿ ´!w'~ÈΠÞXV¶¿âéô² | ­á·Ã�Uç[0upçg_¡ù±± Ý×±' JëK�ÐY‘ºsÏÊé7/_[Üw—ÍF†)‰ƒÔz9±‘ú^Ãé»#¤šoF¥D!ÝÌÏ“ŒGz_Ÿ.¢•ôò¨$úOVÆþ4Ð¥beÞrÁâà`Ù?Cø8ŘˆktŒ‡Ú‹Ø—Ž{*Žfo/¾^|ÕÒ•“SªvÀÜiÙ{�Yºg§©³cÅ@ùúWS’ÜÁá8¸½âOútšeÒañ�¹ÜÆe¯ÐçW>ÎQá]C—b ³3’¯œ}MÀ)ík°^M…·0Å få „%J½r)ÿ/×µyZçcäŒã¼©é™8ðç %Ùpâ“í^’ƒèaEÁ1¯\0 þTã¼4úJ8¾ Ùe-à¸ÙC±Žþ+Ú&5pÖÑ£*2'ç�Ú—Azºz~òËØ/´,mýO«îùJ3e5b…ÿÜ<¤['‰J-êžÆ#„þþEf[æĄ̂°­~u_QQYùÓaEƒÎÊ“ÞæR]?ÍÓ›ÎhŸž6mR_×WÆ´£íšXg ÆÝþpªƒ ¥ÚóÛ#‚)áÎoyÌ*5Ò#šDƒS"«pÉ@é =†9pZûîÕv¹ Kü9î&O‚x?y&¼˜wPÔ“}dô£€îï Á1<² NŠ5hª¼KÄSgµŠF`l}�@V ­óüw8(O^ZʹF˼Öá`™ˆ-ê¾;÷ãŽáŠà븋 ÝD+tê¹þÞÓV3šyèÃb°ý¹8åó\8ëÁQÞͪo¬õl €·þÅ­¶U··¬ÜyÃx®ÈðÄj¬a‡} ˆ¯ºè3ý6Nî¡èžH ¥E¶2Ó[ }[¿{^ìMhõRŸ¹T½y5k×ï^¥åŠ9ÂÒ‚ðž>{¶\[ܔٚ#χã(f%Vap:4ÐÆ5Ó…µf@˜ù…GX}—q£=f†0¼dÁAú¿Õ”Ëñfï]…"ïÜgÁŠ'#ÀP|TÅhÑzœF3Å>œä¹¯„ZŸö¢Âá“°z„À¼ã nF,µßRžœC™5uóÝe› ÔEi*üÜ8 ‚—^Ì'S—¡@çM¢`—îÚ­Ыo¾¢ŸU…% Dîþ\U¯Øô°!˜3uûW\˜*wF>ëÛÜTº¨Ø¾ümlË"ÓC´x²;QªL £õG•~Bac•ä0T#íΰŠOU³Œø:p”-vÞœy•ÈHݼ8l}œûÎatCÌê¹®hÚQdÐÌNÙ/·¯¥¥XÛ–@}¤ç³ÉQ2Ú—"ü5 4eõrq®Å‡@¡¢ˆ”ÛÙ„õôýUCÄ–"`ÄäTJdgðŒÿÁŽŠ5¤ÖË[}¦÷÷“/PÙ1°‚€míâOoí“<¤œB;;Š^/V³¾ÿ¡‡Êð»MѶV»œ*ZÓ‰6uÇÀ d,ûëD±¶Ýúo¾çIJVe¾±|æt€üö¸~èÈòtPi@ë ‘Ê]Ýiê—eæë˜gAÒû ¢fG^WÒ¶IHüÔ%eZT@VBkµ_œÙŸ¸5A±{¼°¬Ð-_AqæáTèBÍ<Ÿ§ˆö=”âÔýqî5«×·’ÛÊo‰Ô6wÚCõ³Q5H:ЃzÚ•wðÜ8ÃácJ3îgÚe¶ï¸ï€]ÏtœbÿñqöÜðÀ©PÝc×S,ß+ßÿ­Àþy+ #Ss_kô‹,c<·úòµ{…Š‘‰øsŠról)d„B:Åv1kþåh”åþf¢3áp¢Ól¶5fbƶMyy8ͬzûê•àf+L0ÞUç}@+üÏ®-Ý÷\…Ä[Û%ƒŽjŒ¼k݈8¸(2¶_]«ì|Í»|˜9zµ:ª\áY•¼äœwcKG£Iq©Ðs‚0ÞõåÄA9Wa߈Â:瀔Ìsu±ðM#Ð}œ©ìÃ6ƒNü>ˆÎ/×ôhN «O§ ÉRq°àTK @½ ÷³/=VC«BdFKæcI‚¬Þ{ü�PÑéü6ê€VeZå]¾&Rš&^¡Ãöa‡ô´¶2Ì•£©hÛúÐåÈÖL°¾PR+O À¦v--üË´¡Klœ%ÂÃa áW£—M#ݲv÷ß=d%B #Ã[1äøx^¸ç ¯(Š¢—°r)Ï)‚¨þc>1xÜZ—KÉ¡÷5…A«+dÆ ó|TŒØ™t1|„ZÏ…¡C;ï¬z'7,5ÈRß«¶"ÎÂfèÂÅÛÉt»}Õˆ«¨¢ÅÐ…1Ë Ìyîî “Öæ¹ ŠÉr`j&Aö¶~ ïE_Ì…(—*L¨ð:°M}*ã06Ç0(Yß!Rñì -wg¾ƒŒ•jEº7P>ÁR÷ÔUãÈ3üäªÙÙµ³2hOÜÉm½ç;_”MVÔ[7…–·¦3FKì6cpHoLÒضX» o.z>®BËÕ¶.!%.N°â̼­­ÛÃ<T,» öÍyüÀÔJ¦<p«˜’ ~×}^ÑŽ|?›å  ÷­dµ÷jŽ¢Ü£„'" KŸ¶ÓÓܨîWGyŽ½Ôö¤xyq‡}aDUΩêÆ™92dà£ï³2ôÝ[ÀŒ»TAÕ(ú_2†Þp6}}r­¿ïÚ,™'»›1¯ 2ë–’Õ2Ž‹z#*Uçöõ>c×Þ‰Ø@ZÊa7X ¨?'PÂiä“($ËTJÈH›§‚S+LcvNcÕ¬K¹éÈÛX³º;Lµ<‚-íš½€w¼ËçFöž¼À‡ŽJò¢±”„L¶þɪúݥʿHœ/Õ{DN9)öÒ²x¥ÈØšv›PÓ y©' ’àáÏU6g¯cDÚàÊA¦¿äj@á—C„Â}M-&´;ñp̹ÌçßµoDGSš|ykó‹^ùøq\øBPlð@+ëla|aà­1#H㫽à±V$µèoÒ3sw–Ñ‹Ô4ñÂÌÉŸºº[ãÛX}:­›ObN·rñä6=Ô)¦Ñ¿zÖU«!ߺBùË"ú°Hµyâ«?œ†çYé±^¡õ‚š´î îfÈýÙ Ã7|yBI<A܉Hdܲó»)^°çó®ždÃ9õhÙÝ—r«2ŸJ ¯—ŠNÿwevÇŒ‡àï"5:… Š­w.¾€I³Ô÷øIúD7"ùl]w¡çoÖÇyh¯,g}@îNwž�ò^ëï¼Z4MÉq¢B)zW¢Z‰/7Žµ¡ˆ‘öÑ3«z8B‰s£Ú¦ñrìY¡O%Eª’ç¨ÓÕpLŒR·»¸òˆ¼=_ˆ9ÄáûÞ“q?vVpÞ,»Ÿ³¨Jñç)\v}I_­ÈÕ4b«Mïn1²£òJOa¾Œý½’:­V}T“53å¨å þL›Ý×SÏe˜(aï$1Rgêµ”¼ùyûJbnT¾$ÍEÇ{´€Ð¦R̈zÃxí=ÿ‘î-Lógw¦¿áýä=–Sݵt}®)¯\>èùž&4T5ËžÑNN©M3ÓÛ×›)@šùŠú©Èg~nM¬e  Í‡ Jx7aÈÙ¿¬Ÿ®`ñLü†ý›S\,Ý8ß± ù7–!Î)O%M‹}64å‡V£³k¤¤û£cŒ•›Ë?3ð±zµ Ü6±Ó‚Ú¸J!/¶tA{XSØU}tŠ[ý˜ÔĉcÑÐrÑ;LÖ|ÑÙú_¼ Êg+àĈ2ÍIP6JV>‚>=hfÓô Fµÿ¼ÅZÖ0ð@£H²iKÜ÷¯¾rIÊtR;dAõÞ»¿hæúö6®Þãù<cü”…Ï‚ƒ?›ÔØÊ9a8ý™‡Naÿ–Z扺òÈ´½R}´í×›Kµ xçýi:ä}0ëM•ù(+�†Hñv®BïÈý¿Q«NÒÄE'è‘MšÑtuÖ_‡M=Õ;ó 9G)rOå{êMîw±Q%”Kmr˜ 6˜çíÙ Ãà‚üÈNÃZ˜äFtaù„جÜJÌm¬kÒ¼VÄ{«põ¾¹çò–„~åA‡R?ÓïˆmΞ‰åØJV|ëéøm.f©qåêñ#B‡äÓ:*¢gÇ}þ`»~ß]·G´nsà“éŒë=Ç_¹¡ÒäÎÜvP§Ì ´È‰YM4$è-®iºŒ“60é†È°å®£a䕪L5<œ€súÔ¥Y¾cÛ5²¬!j#Ò»>·ëwgIè)ôÐ3k:ŠV;ÞVÅÀƒK@‡žÿZÓ‰Á’a á–ôn¿7Ô'H»î›R,5ª—I“$ª†}w8Ê]GhÞKîí¬NúÉÜŠù‚gweŒÓUך·u)ÝE,=Ô®ûú-LKõ©FHσÖd^/ŽÁjF±©Ùµä‹™iÜo¨ïºöSK]\ÆÍ>˜(úÒüÀðèóݱ¡‘ µOoÉ+§¦b¶ÂX™mL±ø¬½œñ¯ì_Ÿ™~ñA¨æu3á^Ý„™oËŒsGÙÞ:±"ÅèÝTÃÊ Wó ô™êNV¥UlOcZªì™¸Ý{GÎŒú<Qˆ4ª«ÛiÜG‘_ý¶ Ž„Ô«94è�NOŠJ‚û͉%Z.ºqµÙé]­ÊRëre jò`˜Š ü³sí‘÷ñºØ–”o¶ãðÜÎÎܱÃ#‹ ô‚EÛôâf×ßÉ°ô„+¡±EQŽŸ$ å-TšóÕÁ~T+CÜT q›“ãÈOã¥þ—†¸eè[ª�µßòJ¥R-})$6çV’ÁW8¾•j- :€åÛÚmú¬O*[®ÜÕízKã5!¬@d§H²Û»-`%J_èsÊÇâ’ðv8ËüŽ?$±we¶³¥îìf&dfÿE¹æ XK?XÛV?*=çhÜ”½K‚IJ€—šJÚo8Ô€?^i“/6r¢ªpÉIeBS\ßÍ"LDhLQù_ÞãÇèX‚r@3ðŸnùoÛ­é†\'«±Á©Õw_¡ñàŸ1”’æÞ¬F›¾xC%nf$>ôÐM‘Ú_pÕ’Þêëc5×(ÉWî,”)ð�Û+‘§°¶nLÍdBHy!±ßdB‘Ÿ¢s§uè’<ûÖ¤ÛÁˆ¨ 2yò®åw>QpõúÞ,]¼Y0¶{Ÿ<X @–Ê$À¾1ž_Þ%Õf'ÄbÅ gj º™ A †äká?"®ÔGWµ4ìBkºF‡¢VÈ#6re‡–ûÙð]olª7ÆVľ¶ÐÔÏv~ÖkÉÎó7ÎXK'˜å9þá+TD¬Ç’Œ¹í² Ylï¶\¯CÏžépº›PÓ^3àÂ5™vU¾åéÓšÂ$Ê•D.if#g(�[¿ú§deŒºß´aò“ì­¢5¸r#¦®=Ü—èò$FC0kªÒ¤§ªø*‘(w~! ñéx8®‹Áï;‰Y¸âNRBB±ð·2ÔËÌOX±´;)Ƀä$ ãÙ'§Œ*¡Ü²®s #`ÝV � #KX½2žp¿2eÛ®‡Vd­ª‰ª_Àõºœ÷/=\¢Ã˜IJ|:m‘lνš¢Æ6“öô¶æ·}ý *ðÛýb.>Cð.ß[–PIYÕ¦«óÌ;ßNlÊ[Ià”~ÍùÄzI3š~ þ ‡Î£{ƒÿÁ–ÿøƒGáúØ ±ñ)©·d,K‰ÉkÖ*·ó‰°[¶Rѵé”B¦EOš}}1æÛÜüôþÖíú =ÐÍ4v3¥¶‡þ0î‚ÍåØL𠤶îÜ+ZŽúŠu’s uo‹àÆ(¨ó˜l˜s|€à×Ôô÷Ð-ºÜiÝ­úÀ1{íµ°‰ïíýÀ°»¯ÊŒ–²? ÙP›»7Ñ�µ4ASø.BºÄI_×ð¡(húsqÁ¨‹Üf´+éQ}íÑS ªs¸À©³[Yâ=7°ó Ìþ¾ŽTò¤Ýâùã5TU–z:RÆz¸/ǨRO.q‘î‰æW­8L–ïcÕFõçy]îË"׌t5Å<ÈêNËѾ_t³¦ú°³ �f;mêKoh Cë.<)ij§€ïÒã˜÷Þ7ÛãjàKŸÈ^L{z¸mý¶¹²b=¥w÷~Dgë_àw‰®[f¹RfŽ²Îçù©’[D…Âͺgt¦þx¢ÛÎ*I ¯¾çãæCT‹6ÂÆ·¸ ¸ô[hŒo(Í°; ç¦^àCk4è#Ä(­Ò~Å¾æ ·6öS©jf0í˜dv^<Þv½œ—Î Oý,f¤=ÝÞtÒ‘#dwêËÇŒf‚"êVÆ÷üÓ¸ò=®á*�U¢d89ÝÌœÛÂáRß·rüFŸÈÆhQƒ£ ´ÐãÌìoˆ–kÚì üb%röúw8z]‹@v+dÉ’òQÉ [s^ q…'Ä9L°qš]‡E­PÐÚýú!Ú©LŠ4shÒˆý‘ÃN‡Ø>ï÷v¯ù#Gÿ‰UÀQô™i¡Ó h”O+ùhÙ:Vè´ŒEqö¼©€ŒÃÜ™¤…¬)Bõ6˜Ë{Ý+¶vÄñJ©­ØÒ@ Ë GÆÐ, ò€�ýëÐÎŽýû]F™éDQ<PQ½Ã)yPìQQ0XøÐ_¤'l˜}ãïÞBw~ ™øXÄÏ0Üks ˆ³FÖî¼6‚KˆÂ rV;° ðÍØP>/€ËÞ#b_Ð D·t,5•‡¯ªÄþ#‘;Ó¢šj¯šjÎôy¯FKZ‹Ì‹Pû¾¼~mOè›>d³/ƒrQ^6¸ãОµ|ûï[¤°V*-Ç“µÍŒ'‰â0½ú$7µý2圕']wÃIØ!o‘IÊWUe>€£àG$ùK ÝC‹q�ýãBÏaûÏ[¬Óã 3‘]7X •—žPâ©|‡ †:â×f­¦(Œ³‚ìˆiý9ÃÓ/Ö§©'É"�Ô6‚jdí~5š?‘ŽZõ(oaSuÎ$§”¶ÜQæÕœÃumÿ#­ÈÜs]ˆÕ˜9ücEqYöÚ´*‹Ëf¥"ž{3gI™9Ïg*=)íà“kèÞm\ÖiŒ;OÇùF®}™ŒxÆýPšW+°"&YZ•ˆá>³’–œ¶»áY¥k•ļ‰E Ë ¶ôl>À¸w³£ôo1Cº ëq8×— `¼/Îû4hèA—[5ÔÈbOr¥D›ØhÉž;¯¹väáºîK�­ƒbYØP'N(~~å}0F¼¦ed¦fttF½Nû˜ê*÷ÝÒ]ÿyK¿5¢Ñrh<oÅ¿P /ÒÐ3w« ?Sj·×2 Ù€9Ú ÛŸ ôå+²‹Ì@°J#m}ä›´L6ÀŽ xþší)„ʹÃi^«Ö*Ùbcâ– ¿†Î·~€©øɃèXÖ«ýÔ¯‘îâp5BB ½‰FK™ŠòïÚNæýÙh ü×Px~%Rk6$I-$+)¹<xþw8Î<Ú݃¶£(OŸÖB¢2i/œÊEÐüxµã¶£ÿÕiŸ:EH¡ , ©:ÝÇ7¸ÍPo¡H}¸Fwf¾'4kïØ>:é[e]ƒoÀ*.Öÿž—WŽáÉ *ž#&¿kÏüÂåUÄà÷�¾|Ë_Œní¥ù½S™Þ„ç¡p.·Ðš—:ß^\mõ†Îrç8Ùq¿À~V‰ÇkÆFUqãªÓÀ:ÚÕ¦m_Hï‘~‹šºiˆÜRëîpTÅÅuÃÂÕµߨúe�lâžéN”jÁ[ÖÑe=‡Û®ò”YX¼vž)ÐZ­ùÈ42~[’ ¼^ÔUø°Î2õö{³Ým¶Œ? a#óÉ3I5ÐW…FÖíï´‘IÐ×uÛ(/|ê sw‹ ÜÌ"‰+öÓ°KÄ܈7Dªé_ð¨Ó2ó•f«`f]§º¥Ø\0BsÙýêiy³Ý»úŠg°@^ ë,(»Î«¼ð<ÞjŠ#×á­=èMãüDÖ>m‘Då¥ Um ?b‹z¡`l9ÜåÍøväÖ@Ÿ¤Ø+B¥Òžšœ¸,“»@œS=Þå·4ºÑ¹m:½{ôr:Uô[Z×ÏÌüšVQŽGœ¦1„¡!©Êü·#åž5… ôík­úòÐtu°£ÞŸ=Y3mªß{û‡TL•PQŒ=>6$EÏZ“ÀzÆ�hVÂ`Y¨*-ý5 :‚Ç{¿ò›ªÄ8G"#@gÕ@ç`²Ø1mÂÉë2{Þtçi#PXž½+ñÈ3¯48~ŸÙg£óq( Âã°³ÊÍxa• ã¸~ñ½~„ôIõÞ”Éé];ä8ŸM<6 ŸÔ›ýÁHÒÒ¿õ³Üÿ÷¯ !çµÃ«<) l…Ø0íu€@õz#å‡WjnÇYéH8¦˜YñØ}ÉJ”¦ðœ‹4¨Z+Dð¤s©¿òQ÷ ²$*’$ËìÁBIý©Ï)Ù~7É6¤ ߸3}ôÎ-Xú¯RnÛ0ùðÑŽXІ±§ã¥Ö–T`JM dΊ?x¢æå>¼",|Y¯F`õVu©>¢çËŽ .³‡ä-R4yTçÇš»±E課_[A6Ywv<F­.*´Ðtè8IU®ï4%¿X¤"hó‹2 ¨Ÿ=Úþ¼\}#á®>yÓùT[¦›tØ".Ù9’Í }äÔJ,F©aÂoœPQ¹Þò—¯fÛV„ £Žw˜;/¹6øC–Ž‘«R<¬\£JéX"i­ë“ùšÃ•×Ñ`»Z¤IÎØÕV4o­hœÖQ˜WQCãåà¤ô…©jZ&t•›“…ªb€NB·u/KÚ^lÐb¥›íû©gÞL4(è>[+&€FWl+W¶ïýâJAÉJ|óݬ’±hXôÒ’2¨dúè.|Á°ÝµÙª™ã'ó|°Ï–’D ¨œXÛÆs¤V£É^̘S‡ê]ŸþœÙlýY.fĬÞ,÷=ò0ž[t»ÃLaŸ–T V·üyÏœ¥ši†FØ2Ñ2ÈN³Oé!Ù1Œ×ÓÀÎÔxÀèÆÜRÇ£jåKÉ2越}Cë‹>4m‰k¦šq#ºþjTµÖÝ–;î»áMónüQqhm aÂ*”J•¶N%ß^>Ò]U½7ç¬X&ëwžòHW=ë[y+HsûÊ#‡ûgHë\Ó­NÓŠeJ¹ßæmwÁö‚‚òGÞÂj¹òŸ•£”ç/×e™B`®!¦U63Z³ÆÒ“ÿÓȾ‹ÿí»ÿŠŒõ—ÜizݶÉ-}«ßcPûND©—³Ý» óÏÃWÓ_5þaã<U|Ì;ðÔarhëçŒÔ¤(2ÏÊ/Ã"§wÙ_•’ÊV'3Í@ý¦Êº[mYÏI™EÊ%N&] x¾;C-‚aúóz1…Üs½H%ÔtRÜB˜å9PÚl#³ÛðͪÙ;lã3Áí,t=!á»]Ë µq-ËX¡fkÕžð~çIù&È@©·ô &LEE•OUv1íUÞ ”óÿ–ØXµ´n qf¾|n4s§ï\FÈ©©ñrûÁúF4Wf«Ö²"¦nó¡ÖU¨þ•|‚q†üSÑÙDU«cÅÅpC#?÷Þf½+üxïg_�š‘'Õ(Q¿¥]Qõ½5dÑ­‹£x g'<ªï犕@ÍËjÃ} }xS"UiPRYf¯l+–e|xeßÛƒ…1˜¨­!Þzz;è5ôØ7†aÏÔ^9oMPíD.Ô‰ÒeK5ãé‘„§ ê£FíG«r«àf¥¯¢w×/æ¿xM ÃÙG±ŒF¸f¡Ó%�î:¹ïkž¬HTé½ï<Ždf,ÄÙÏ-nvHÅj%ý%¥š]‹3__¥`Ñø}Õm8´îðý‚¨ŽGcc¡Òý.éÏž€Åþ *3&Óï~KÖɉà ]+IWUo ?µ8ÈO‹‰¦²•›2åÀ£€U÷ž8=k.#¿ BcŸÌ—�;H{éÚß±õðð~l8çó5"-áè–8¥¦[}¡5ŸöàÈ8V;Ë/âÞ¤¦Ïòå¬Ê<ÑÊ3Y¶ðGR‚ú|YôåÙú®Ö vìêÙìÎ¥›=\2èPd—(ïôþ¶¸´ÄU#t@ TšéÜ«þƒèJ01Ûìº/|ÓùO79øØÏR»­ Ï™ë[°‹ð¼¤Aún»÷ûvØTÙƒ?×Ó8ó&a%ÆYõb¾© Tc°èÊ?ëU;­2óûwaJÑ» òw;.E:„.{ÊL.WUCdyò£}½hÿóÆ7Ô‚v#k‚„LËzƒ€ iŽ'MSæz»Ø`’û§gtèç5¨- }³Š8$(tFј.¶9Š©€§ ”ÂA=,^ðºkµò:€CÆÇáõªb]B¼ZŒ!& ®…~2;¶¢©¡‹?À"5̲¿‘q²¡1:øGN‹VÁ^Tuès_À Óä%ÍTö‚9ìb!)<½i¶Wì|úzºT‹ ´öÖ¸m¬¯¡6ÓÁ“àx;]¹¹GeÌ<«XÑFØÓ—Âò© üb­¸_ì¡11r 3½�˜,8bæÔÎ8µ¦àça¤ò•§ò¢C}Û¨‹‡PH¤Îk5ÌLãRHë’<¢’—çk "õ×yýzｚ¤‰ƒþ|+ub4š‚ÃW´@Rq£RN¸Y饑+¶Ný³¶Óát3áU,T–ç-#˜¡]TÃ3ÛSLçýÝwàik몥zÐÀYŒ^ãjVýÈ»HCO¥ Ÿ*¦rÍJ)A¡`}ªÌ<öÖ ¶·•Žð éBâ oší¢áÑ_ÿ<…|îá7¸«ò…(£§¿¤î}aå�|& €ÕèY9 ‰Ü‹Lª«?YøÑÎ Sëþ‰øÖ@ß¾u\<´ód,Þh]vµ0Ù­Ôƒâ£ü¤˜dŒ`µìm 3z«šÒ—‡N5f_èv—¥¯f m2 ²“ºÂ,™:8é¨îEÉ;Çã(Lw˜²GÊ7ÚÚV¢{¯­áÝùJö` x·Ý`D!oÂR˜œ1R¶iÃÃIY¸Œb[þŸT/:³û‘„ëÂeF1½¡ >ŸE–VÛ ‚ša¿`nž€bqaTuo~Qè-öJRÊ=‚Úkpþ×:ñŽ2k]( Ñï]ª~<÷–Oü ´ò…è®LÇœ¨²í™–K'ƒRS®ÚrËFôi<>WƒE8ˆ3OÖÁK„Ö!%¾S=9úA¢*¼ò\É#ßh5F˜nöçóaiQï¥äX-I€ð�ë�Ýïà¥\̲4–cï÷΃Qn)¬ò˜ÂÔY‡_×ÇÞ¢Ö­0²Þ¢yD‹rµàTLŸp6j²FîôUÓe¯¥,ýØÝ™‚7C†aîű¶"Ä@'±…gLϺPÜÛ:ÊI))›Ühü©¯”s3ð¥.~’ûîÀgŽB`Ÿi¦ÑÒÜõ9IÁ¹—ÊVÁctqßN_Ÿ«MÚÃ?Ê ¦’By¼ëõ@ý¸öh<ZXâlAñôë[Ç•‡Úq‘ùœç„“½ŠÒ׋ _ûúOßñygìÏ „B$yöôT&˜¨2QÉ}a’€qB,G?5^NcœÐýÖ®Ô3§©{Ev'K\ÿ4f‹a|êò¤$±^CÛóô§ûQQZx’5%¼{Zî“žÒ@ÙË8züßÿy[öôE$¨^k°(I¡‡ºD൞(¯9 S(¨MX솳O­}¸Œ®¸ë_¼«•¢=@¡P«fÝ `;|À‘Šíî1«—óz]ѯñÔòØç¡iù:›ÅpñéÚ £7ĤeóÌã›GIΗ, ¤sªxŠs¯CÀbâ# ‹v¦î²úʇé@3º}™–ÔÇ×P¼(wOj;~¾±‰046ð|÷Å2^7¦¹=GÐ|Nƒe W&-@D“("k¶îÒIr™ºÃ /‘òt¥,g1˜ñ7rïiëä  Ì:$,#Œq)¾YÁ¼»£²È?IRŒiv}ìIÃâiÒzG£WŸæç#ó¿È2ÎS'zÏ“ÍH§is˜!Æ]­_î ç…þá/¸+éÄ�îž&¡ÚÛÞŒÆ_Ý^¬ã|Y‚·:£Ì%IÙÄÒ¼5>ßöà·ëä;›¶Èª¸ýÃïÿÔ3ª.UÝ@ë~R1êsO•“"œÒÒùn{ˆ‘†¶~yÒÑ»?íó j5&ÇÆÚÕôƒD×¼<‡ µ/+;6OJ‘à·—MÂþZf͘žY÷2w©-"‹6€J„É’ar½cT©3Õ¨8Õ.TA”ø'òd¹g?…=™ÐÁ…„áÓrXYæç!4èeÝò{r:l½œäÇì\¯aŒ;@ʾµŒ`h±¨¦ôkìÇËðÆÇüHË9yo¼ªgKpŒ‡F<ÚÙ·ô˜0`úúÀä7½qþ›¼ ­Ùg ­‘àk3d¾\éÙñ½4!üY#[»ÅìÒap¤ØÔÞ”ˆ6Ö¯Ú©_9&]ŽÒ‚ô.­{™94§£MKÇeØkqµ¯/PÖ0ÉùŽOýùÐsXý�¤E4`ÍÐâ´ò§,°Ú=Ñqf-"AÅÇ.þC‘Ž}  d«îÆ'úΕMÿL"§¦<±û­¥9ÜÚ¤ð¶pxM›žŽ›3ܽô´”9I ™^•Òx÷†€ÓU ¶Üê/î †£¥›–bJ¨çP+´@!R£‚ 3KäpEî]~1Ç‹= ýJœšbÚâVš%Ž=äÔØêŠ^÷"fÓ™grÓq ý+ŽÁ²£ÖWÆQ‹ßš—ø ¹íåJùÞjJ>ðTƸúÖ¢…Ò¬¿Nð^ÓÈO ×&c8+<äªfð¼?†ñÒw·àhNcî;Èý�Lű/ÅEÏö41‰ªEJW´M·&¯ÓÝ¢nüknÈY:Á`K—ÓÉÑkÀžp“£ýØRäæ:È^Ñ ûm<÷¾Ì=¬E¤ª´@ìZÛª“4@èü¸­f .ìž»¦¡‹8<S‡¸n¤öàaA(€Øá…Lˆä…¸ÒŸî tdþÙb¬›²½îÕ43ù-„V^uoZ)—jÖ˜ô³*…V[ôˆëW¶lDIFhÿ¢Zs–­¨d°§³#ìX ·f®Ïþ“ô¹[_ú,`zÇÍ/:�󽦊˜nhïðÌI%ì×]­G]. ¬¤ãP*›å»×–CqeÛÏ{`ÁÞO6´¢i“°HŒIh+_úò81çí[AE­ëNÜ"bœ}ÝoyfõóºðÀ¬,µ;\(z…íÕÁQxîŽõä†Ð+ž{~íX²‚X‰:>©Gw “È5ÃlHoÄDüS§t-fí•ÞôS‰^%7´é³À…T¦ƒk]㈦¸ZQŽpàì ä,q@·…œ¦lv5+÷AOûúf°øëï¢ÿ^NÉÐæý9÷léX$lde^ýü 'MT+ªçŸp• .J+¶³2%!e:b’£¿®ûÝq¢-/ÚðKÃÊbnàu‚”\6XW#õ÷¢ ^F¦RÈ¿f˜g™?•è6m–*H¦ãÙõééX«ÂäÞŽÞxY'ÅŠò}‚FGcÍйV¨7Ýä È›q\PÈË=”!f)yfm°à6å©Q}ºR\¢ýkØ&†3Cõ;•¯—«gàÞLWP"õ}¿)̷ܳ ¢w¼l ~|±µÒý¨aX›æÂ-pQ¸EïÂd —×àN .¦=B5KYBéÙ–iïö;Ã5C|÷< ª`(ƒòd‹I¤ì4[BUÝú]Íû‡l]›Äj_U\÷težlÝ À–zkINñˆºê ÖBî„Vs†œ« úT/G0ñvô§w¿:Árh/à'ðD"Ëb$Í\ÑIá½±r7‘ä¶5p¨Ž¼ùó_g´‰!%]fJŒçÅ4ÝÀF{½ŸqŒy½]ÛyºrÇÙ ¬ÞÝ™èm˜ø€•+SÚæû}~+ûK×ȦL|Ž @ÛWúG:ï4"Õ×UJ'!~{g£"‘ºå ÓQ6Ã}EµÏƒñ(iª Tlš9çVAvÊ\¿wu—ÍžDŽÏ#Ío†$H®:TIÚ#tXµoÛÄh¬%ÀUWiHGp _#ü¢?YëJ" ç B&Õú¶žý±H*PÞ7`yµšȶ¹êËsÓÌ2ÏVdJè:£l¹¾€,®êpŒJûÀšÕéHïTÝÖ(ñºTlÕaŒòµ›e,s,äI=à’¶9ƒ!öwtCM†>°ö@¡Åíý›eòåJ"0æõQß8S ¥ë¤m •—öÖüDFÓ@Lö* [X£úÍPÉ*é‘qsŸÞiþ º½ëîE«ž <ù.´ÄìðEýT<‡·¢tØRúb$ƒžU|Þ[h|aÎ åïïž<ƒ°`™$cz߇NíŠB£%ŒþdbÕåÐc˜»†²ÎƒÌþ¦KE é`HZ-no8õžD˜ r!N]¶}bãé­¦˜$à‚'É%nIâ¬r¸7½½Ú¤s^´ ­5ŠI[·=}åbË]}å|ÄiæU¤”o¶ITVãsîÓt82˜Ùö`XÎïeɽ¼* dúø2ÐùÖª—»ç¡Ø6à õ´?Ól]FÑÂ<Ñ_StJ¶…Îü¡›À·5ÅÈrF ë{ßAࢣ\FbtûÕ#*]uŽiål¦0È—ßvi&xíAIEÎ(Õ o<öHWÖ pê(xŸ<¥Œ³kQõRÞíÌpê±mU2.Ä4à­Ü)´þŽ5PÜ™ÄYRC!´gRQÝèòßOpŸ±ß£üf†à{Åà<oÇA¤bR—ìÍ$YÇÉQ‘­éàí‚¡rQãÔ¸}(/þÒrî— >ÄTÖ£¡”áJn! Ž%«Ú%6âÐ"¡pI+H•î'x¤cùüΙxŒŒÁ›aÑ÷é›—wÀq‹mÆqWv°»è6Ä£ ¥cºaé$j©2£´’³kA£<Qy¬µ8|É~1 }sw@À *º7}æ’Õ†C»†{=ç8»æªYó'úôE­è˜þ'-™# #jL-Bhf©/õê›ÇfÕq艎”ìR¤H‘·@Z¶šœê_KPñ ]h@Û ¯¼P>;÷f/0ã4 4÷°´-OÈÖ_|n=ß �V¾}e"ÃD14k¬»vÌà,R,ž­û… ßçkUžú"Ç ÞýRÇA1|Ú C;…Ϊ·¹ë·®‹3Í«žÙó!Âjž¦®êƒ�NH-ý*ëýÙƒ¿5Òš5ת¦î]¿Ø¸ìR±Œh_utÎ''M‚Ó¥¤—¿Õh,Ocÿª<Rš;Zqc8¨ «ñÑÚ©cžáeê~sp¼yõq•jgAUnÄiä£h{Øt.ÔÇ«ã0@îÒÉzqÐ3”â ¼bÍCÕpUšU<iŽkÃS¬‡ÖÇ8ÜÄñ•‘rœ¸+ëËñ€aÐ&ŒõçùÐל©Ñ‡¢5°]Ö…ol+Ó¨°Õªä¸IóoÓæª9AÍAËù»}Ñ'ÒU®ÌÍÜ¡«‚Üʽ²ª5Ü™±gÁ,Îû±9v”–Î’U ‡ê"¨¬ŒKìÖýbM¦ÀMšYŸä‰Ú‘LU½dHè|P@h•–„“—^½{¿5ñ£•± m¢è›wÏ>e3rïocÊ©…«cžA{—VàRÈ‹{L‘ï4‘_e†U3HWíÞäPÑhÇÓ¬¾Òw#ï_zù‘ú×õ ‹§­Ç2 OÙZ“ë”Þ6>¶#­'“Šô‹<Dšå¬&A©cñj‘€ÉTRk¨§ß× •ö!UsG›+fíK„vÕÖ»œFî=}ÄŠlÅƦ…2íRúM­6@n¸Û,£jU›±Š£º­¯Œ£º B¨$è(Ø©Æ*p¾80T†Ð¨»®œZ¿…+ZI¬˜+¦‰°óì‡9u;`!ýŽClP£¥<OW:QùËs¦#îÉ©QNx´öI»'x_Z‘•í™§¿ñ<]÷<CZ<)®n.Íý~Îf%žmûo,U|`G®‰VïJâî)1Œœ†LÄóÌãûýoçÃ#5ç+/7š?:°c¥Ó¤Ww�n‰=ÐmMô 6®rñúsô1!?²V€Ác=dfD 5Ä¢ÍxB¶£ßRYs5Ú5”b(GLlå‹5N 9ˆª¡¯ºs·½ºÿ’VÞï\š���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/data/tenk.data����������������������������������������������������������0000664�0000000�0000000�00002436120�15100345067�0020346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������8800 0 0 0 0 0 0 800 800 3800 8800 0 1 MAAAAA AAAAAA AAAAxx 1891 1 1 3 1 11 91 891 1891 1891 1891 182 183 TUAAAA BAAAAA HHHHxx 3420 2 0 0 0 0 20 420 1420 3420 3420 40 41 OBAAAA CAAAAA OOOOxx 9850 3 0 2 0 10 50 850 1850 4850 9850 100 101 WOAAAA DAAAAA VVVVxx 7164 4 0 0 4 4 64 164 1164 2164 7164 128 129 OPAAAA EAAAAA AAAAxx 8009 5 1 1 9 9 9 9 9 3009 8009 18 19 BWAAAA FAAAAA HHHHxx 5057 6 1 1 7 17 57 57 1057 57 5057 114 115 NMAAAA GAAAAA OOOOxx 6701 7 1 1 1 1 1 701 701 1701 6701 2 3 TXAAAA HAAAAA VVVVxx 4321 8 1 1 1 1 21 321 321 4321 4321 42 43 FKAAAA IAAAAA AAAAxx 3043 9 1 3 3 3 43 43 1043 3043 3043 86 87 BNAAAA JAAAAA HHHHxx 1314 10 0 2 4 14 14 314 1314 1314 1314 28 29 OYAAAA KAAAAA OOOOxx 1504 11 0 0 4 4 4 504 1504 1504 1504 8 9 WFAAAA LAAAAA VVVVxx 5222 12 0 2 2 2 22 222 1222 222 5222 44 45 WSAAAA MAAAAA AAAAxx 6243 13 1 3 3 3 43 243 243 1243 6243 86 87 DGAAAA NAAAAA HHHHxx 5471 14 1 3 1 11 71 471 1471 471 5471 142 143 LCAAAA OAAAAA OOOOxx 5006 15 0 2 6 6 6 6 1006 6 5006 12 13 OKAAAA PAAAAA VVVVxx 5387 16 1 3 7 7 87 387 1387 387 5387 174 175 FZAAAA QAAAAA AAAAxx 5785 17 1 1 5 5 85 785 1785 785 5785 170 171 NOAAAA RAAAAA HHHHxx 6621 18 1 1 1 1 21 621 621 1621 6621 42 43 RUAAAA SAAAAA OOOOxx 6969 19 1 1 9 9 69 969 969 1969 6969 138 139 BIAAAA TAAAAA VVVVxx 9460 20 0 0 0 0 60 460 1460 4460 9460 120 121 WZAAAA UAAAAA AAAAxx 59 21 1 3 9 19 59 59 59 59 59 118 119 HCAAAA VAAAAA HHHHxx 8020 22 0 0 0 0 20 20 20 3020 8020 40 41 MWAAAA WAAAAA OOOOxx 7695 23 1 3 5 15 95 695 1695 2695 7695 190 191 ZJAAAA XAAAAA VVVVxx 3442 24 0 2 2 2 42 442 1442 3442 3442 84 85 KCAAAA YAAAAA AAAAxx 5119 25 1 3 9 19 19 119 1119 119 5119 38 39 XOAAAA ZAAAAA HHHHxx 646 26 0 2 6 6 46 646 646 646 646 92 93 WYAAAA ABAAAA OOOOxx 9605 27 1 1 5 5 5 605 1605 4605 9605 10 11 LFAAAA BBAAAA VVVVxx 263 28 1 3 3 3 63 263 263 263 263 126 127 DKAAAA CBAAAA AAAAxx 3269 29 1 1 9 9 69 269 1269 3269 3269 138 139 TVAAAA DBAAAA HHHHxx 1839 30 1 3 9 19 39 839 1839 1839 1839 78 79 TSAAAA EBAAAA OOOOxx 9144 31 0 0 4 4 44 144 1144 4144 9144 88 89 SNAAAA FBAAAA VVVVxx 2513 32 1 1 3 13 13 513 513 2513 2513 26 27 RSAAAA GBAAAA AAAAxx 8850 33 0 2 0 10 50 850 850 3850 8850 100 101 KCAAAA HBAAAA HHHHxx 236 34 0 0 6 16 36 236 236 236 236 72 73 CJAAAA IBAAAA OOOOxx 3162 35 0 2 2 2 62 162 1162 3162 3162 124 125 QRAAAA JBAAAA VVVVxx 4380 36 0 0 0 0 80 380 380 4380 4380 160 161 MMAAAA KBAAAA AAAAxx 8095 37 1 3 5 15 95 95 95 3095 8095 190 191 JZAAAA LBAAAA HHHHxx 209 38 1 1 9 9 9 209 209 209 209 18 19 BIAAAA MBAAAA OOOOxx 3055 39 1 3 5 15 55 55 1055 3055 3055 110 111 NNAAAA NBAAAA VVVVxx 6921 40 1 1 1 1 21 921 921 1921 6921 42 43 FGAAAA OBAAAA AAAAxx 7046 41 0 2 6 6 46 46 1046 2046 7046 92 93 ALAAAA PBAAAA HHHHxx 7912 42 0 0 2 12 12 912 1912 2912 7912 24 25 ISAAAA QBAAAA OOOOxx 7267 43 1 3 7 7 67 267 1267 2267 7267 134 135 NTAAAA RBAAAA VVVVxx 3599 44 1 3 9 19 99 599 1599 3599 3599 198 199 LIAAAA SBAAAA AAAAxx 923 45 1 3 3 3 23 923 923 923 923 46 47 NJAAAA TBAAAA HHHHxx 1437 46 1 1 7 17 37 437 1437 1437 1437 74 75 HDAAAA UBAAAA OOOOxx 6439 47 1 3 9 19 39 439 439 1439 6439 78 79 RNAAAA VBAAAA VVVVxx 6989 48 1 1 9 9 89 989 989 1989 6989 178 179 VIAAAA WBAAAA AAAAxx 8798 49 0 2 8 18 98 798 798 3798 8798 196 197 KAAAAA XBAAAA HHHHxx 5960 50 0 0 0 0 60 960 1960 960 5960 120 121 GVAAAA YBAAAA OOOOxx 5832 51 0 0 2 12 32 832 1832 832 5832 64 65 IQAAAA ZBAAAA VVVVxx 6066 52 0 2 6 6 66 66 66 1066 6066 132 133 IZAAAA ACAAAA AAAAxx 322 53 0 2 2 2 22 322 322 322 322 44 45 KMAAAA BCAAAA HHHHxx 8321 54 1 1 1 1 21 321 321 3321 8321 42 43 BIAAAA CCAAAA OOOOxx 734 55 0 2 4 14 34 734 734 734 734 68 69 GCAAAA DCAAAA VVVVxx 688 56 0 0 8 8 88 688 688 688 688 176 177 MAAAAA ECAAAA AAAAxx 4212 57 0 0 2 12 12 212 212 4212 4212 24 25 AGAAAA FCAAAA HHHHxx 9653 58 1 1 3 13 53 653 1653 4653 9653 106 107 HHAAAA GCAAAA OOOOxx 2677 59 1 1 7 17 77 677 677 2677 2677 154 155 ZYAAAA HCAAAA VVVVxx 5423 60 1 3 3 3 23 423 1423 423 5423 46 47 PAAAAA ICAAAA AAAAxx 2592 61 0 0 2 12 92 592 592 2592 2592 184 185 SVAAAA JCAAAA HHHHxx 3233 62 1 1 3 13 33 233 1233 3233 3233 66 67 JUAAAA KCAAAA OOOOxx 5032 63 0 0 2 12 32 32 1032 32 5032 64 65 OLAAAA LCAAAA VVVVxx 2525 64 1 1 5 5 25 525 525 2525 2525 50 51 DTAAAA MCAAAA AAAAxx 4450 65 0 2 0 10 50 450 450 4450 4450 100 101 EPAAAA NCAAAA HHHHxx 5778 66 0 2 8 18 78 778 1778 778 5778 156 157 GOAAAA OCAAAA OOOOxx 5852 67 0 0 2 12 52 852 1852 852 5852 104 105 CRAAAA PCAAAA VVVVxx 5404 68 0 0 4 4 4 404 1404 404 5404 8 9 WZAAAA QCAAAA AAAAxx 6223 69 1 3 3 3 23 223 223 1223 6223 46 47 JFAAAA RCAAAA HHHHxx 6133 70 1 1 3 13 33 133 133 1133 6133 66 67 XBAAAA SCAAAA OOOOxx 9112 71 0 0 2 12 12 112 1112 4112 9112 24 25 MMAAAA TCAAAA VVVVxx 7575 72 1 3 5 15 75 575 1575 2575 7575 150 151 JFAAAA UCAAAA AAAAxx 7414 73 0 2 4 14 14 414 1414 2414 7414 28 29 EZAAAA VCAAAA HHHHxx 9741 74 1 1 1 1 41 741 1741 4741 9741 82 83 RKAAAA WCAAAA OOOOxx 3767 75 1 3 7 7 67 767 1767 3767 3767 134 135 XOAAAA XCAAAA VVVVxx 9372 76 0 0 2 12 72 372 1372 4372 9372 144 145 MWAAAA YCAAAA AAAAxx 8976 77 0 0 6 16 76 976 976 3976 8976 152 153 GHAAAA ZCAAAA HHHHxx 4071 78 1 3 1 11 71 71 71 4071 4071 142 143 PAAAAA ADAAAA OOOOxx 1311 79 1 3 1 11 11 311 1311 1311 1311 22 23 LYAAAA BDAAAA VVVVxx 2604 80 0 0 4 4 4 604 604 2604 2604 8 9 EWAAAA CDAAAA AAAAxx 8840 81 0 0 0 0 40 840 840 3840 8840 80 81 ACAAAA DDAAAA HHHHxx 567 82 1 3 7 7 67 567 567 567 567 134 135 VVAAAA EDAAAA OOOOxx 5215 83 1 3 5 15 15 215 1215 215 5215 30 31 PSAAAA FDAAAA VVVVxx 5474 84 0 2 4 14 74 474 1474 474 5474 148 149 OCAAAA GDAAAA AAAAxx 3906 85 0 2 6 6 6 906 1906 3906 3906 12 13 GUAAAA HDAAAA HHHHxx 1769 86 1 1 9 9 69 769 1769 1769 1769 138 139 BQAAAA IDAAAA OOOOxx 1454 87 0 2 4 14 54 454 1454 1454 1454 108 109 YDAAAA JDAAAA VVVVxx 6877 88 1 1 7 17 77 877 877 1877 6877 154 155 NEAAAA KDAAAA AAAAxx 6501 89 1 1 1 1 1 501 501 1501 6501 2 3 BQAAAA LDAAAA HHHHxx 934 90 0 2 4 14 34 934 934 934 934 68 69 YJAAAA MDAAAA OOOOxx 4075 91 1 3 5 15 75 75 75 4075 4075 150 151 TAAAAA NDAAAA VVVVxx 3180 92 0 0 0 0 80 180 1180 3180 3180 160 161 ISAAAA ODAAAA AAAAxx 7787 93 1 3 7 7 87 787 1787 2787 7787 174 175 NNAAAA PDAAAA HHHHxx 6401 94 1 1 1 1 1 401 401 1401 6401 2 3 FMAAAA QDAAAA OOOOxx 4244 95 0 0 4 4 44 244 244 4244 4244 88 89 GHAAAA RDAAAA VVVVxx 4591 96 1 3 1 11 91 591 591 4591 4591 182 183 PUAAAA SDAAAA AAAAxx 4113 97 1 1 3 13 13 113 113 4113 4113 26 27 FCAAAA TDAAAA HHHHxx 5925 98 1 1 5 5 25 925 1925 925 5925 50 51 XTAAAA UDAAAA OOOOxx 1987 99 1 3 7 7 87 987 1987 1987 1987 174 175 LYAAAA VDAAAA VVVVxx 8248 100 0 0 8 8 48 248 248 3248 8248 96 97 GFAAAA WDAAAA AAAAxx 4151 101 1 3 1 11 51 151 151 4151 4151 102 103 RDAAAA XDAAAA HHHHxx 8670 102 0 2 0 10 70 670 670 3670 8670 140 141 MVAAAA YDAAAA OOOOxx 6194 103 0 2 4 14 94 194 194 1194 6194 188 189 GEAAAA ZDAAAA VVVVxx 88 104 0 0 8 8 88 88 88 88 88 176 177 KDAAAA AEAAAA AAAAxx 4058 105 0 2 8 18 58 58 58 4058 4058 116 117 CAAAAA BEAAAA HHHHxx 2742 106 0 2 2 2 42 742 742 2742 2742 84 85 MBAAAA CEAAAA OOOOxx 8275 107 1 3 5 15 75 275 275 3275 8275 150 151 HGAAAA DEAAAA VVVVxx 4258 108 0 2 8 18 58 258 258 4258 4258 116 117 UHAAAA EEAAAA AAAAxx 6129 109 1 1 9 9 29 129 129 1129 6129 58 59 TBAAAA FEAAAA HHHHxx 7243 110 1 3 3 3 43 243 1243 2243 7243 86 87 PSAAAA GEAAAA OOOOxx 2392 111 0 0 2 12 92 392 392 2392 2392 184 185 AOAAAA HEAAAA VVVVxx 9853 112 1 1 3 13 53 853 1853 4853 9853 106 107 ZOAAAA IEAAAA AAAAxx 6064 113 0 0 4 4 64 64 64 1064 6064 128 129 GZAAAA JEAAAA HHHHxx 4391 114 1 3 1 11 91 391 391 4391 4391 182 183 XMAAAA KEAAAA OOOOxx 726 115 0 2 6 6 26 726 726 726 726 52 53 YBAAAA LEAAAA VVVVxx 6957 116 1 1 7 17 57 957 957 1957 6957 114 115 PHAAAA MEAAAA AAAAxx 3853 117 1 1 3 13 53 853 1853 3853 3853 106 107 FSAAAA NEAAAA HHHHxx 4524 118 0 0 4 4 24 524 524 4524 4524 48 49 ASAAAA OEAAAA OOOOxx 5330 119 0 2 0 10 30 330 1330 330 5330 60 61 AXAAAA PEAAAA VVVVxx 6671 120 1 3 1 11 71 671 671 1671 6671 142 143 PWAAAA QEAAAA AAAAxx 5314 121 0 2 4 14 14 314 1314 314 5314 28 29 KWAAAA REAAAA HHHHxx 9202 122 0 2 2 2 2 202 1202 4202 9202 4 5 YPAAAA SEAAAA OOOOxx 4596 123 0 0 6 16 96 596 596 4596 4596 192 193 UUAAAA TEAAAA VVVVxx 8951 124 1 3 1 11 51 951 951 3951 8951 102 103 HGAAAA UEAAAA AAAAxx 9902 125 0 2 2 2 2 902 1902 4902 9902 4 5 WQAAAA VEAAAA HHHHxx 1440 126 0 0 0 0 40 440 1440 1440 1440 80 81 KDAAAA WEAAAA OOOOxx 5339 127 1 3 9 19 39 339 1339 339 5339 78 79 JXAAAA XEAAAA VVVVxx 3371 128 1 3 1 11 71 371 1371 3371 3371 142 143 RZAAAA YEAAAA AAAAxx 4467 129 1 3 7 7 67 467 467 4467 4467 134 135 VPAAAA ZEAAAA HHHHxx 6216 130 0 0 6 16 16 216 216 1216 6216 32 33 CFAAAA AFAAAA OOOOxx 5364 131 0 0 4 4 64 364 1364 364 5364 128 129 IYAAAA BFAAAA VVVVxx 7547 132 1 3 7 7 47 547 1547 2547 7547 94 95 HEAAAA CFAAAA AAAAxx 4338 133 0 2 8 18 38 338 338 4338 4338 76 77 WKAAAA DFAAAA HHHHxx 3481 134 1 1 1 1 81 481 1481 3481 3481 162 163 XDAAAA EFAAAA OOOOxx 826 135 0 2 6 6 26 826 826 826 826 52 53 UFAAAA FFAAAA VVVVxx 3647 136 1 3 7 7 47 647 1647 3647 3647 94 95 HKAAAA GFAAAA AAAAxx 3337 137 1 1 7 17 37 337 1337 3337 3337 74 75 JYAAAA HFAAAA HHHHxx 3591 138 1 3 1 11 91 591 1591 3591 3591 182 183 DIAAAA IFAAAA OOOOxx 7192 139 0 0 2 12 92 192 1192 2192 7192 184 185 QQAAAA JFAAAA VVVVxx 1078 140 0 2 8 18 78 78 1078 1078 1078 156 157 MPAAAA KFAAAA AAAAxx 1310 141 0 2 0 10 10 310 1310 1310 1310 20 21 KYAAAA LFAAAA HHHHxx 9642 142 0 2 2 2 42 642 1642 4642 9642 84 85 WGAAAA MFAAAA OOOOxx 39 143 1 3 9 19 39 39 39 39 39 78 79 NBAAAA NFAAAA VVVVxx 8682 144 0 2 2 2 82 682 682 3682 8682 164 165 YVAAAA OFAAAA AAAAxx 1794 145 0 2 4 14 94 794 1794 1794 1794 188 189 ARAAAA PFAAAA HHHHxx 5630 146 0 2 0 10 30 630 1630 630 5630 60 61 OIAAAA QFAAAA OOOOxx 6748 147 0 0 8 8 48 748 748 1748 6748 96 97 OZAAAA RFAAAA VVVVxx 3766 148 0 2 6 6 66 766 1766 3766 3766 132 133 WOAAAA SFAAAA AAAAxx 6403 149 1 3 3 3 3 403 403 1403 6403 6 7 HMAAAA TFAAAA HHHHxx 175 150 1 3 5 15 75 175 175 175 175 150 151 TGAAAA UFAAAA OOOOxx 2179 151 1 3 9 19 79 179 179 2179 2179 158 159 VFAAAA VFAAAA VVVVxx 7897 152 1 1 7 17 97 897 1897 2897 7897 194 195 TRAAAA WFAAAA AAAAxx 2760 153 0 0 0 0 60 760 760 2760 2760 120 121 ECAAAA XFAAAA HHHHxx 1675 154 1 3 5 15 75 675 1675 1675 1675 150 151 LMAAAA YFAAAA OOOOxx 2564 155 0 0 4 4 64 564 564 2564 2564 128 129 QUAAAA ZFAAAA VVVVxx 157 156 1 1 7 17 57 157 157 157 157 114 115 BGAAAA AGAAAA AAAAxx 8779 157 1 3 9 19 79 779 779 3779 8779 158 159 RZAAAA BGAAAA HHHHxx 9591 158 1 3 1 11 91 591 1591 4591 9591 182 183 XEAAAA CGAAAA OOOOxx 8732 159 0 0 2 12 32 732 732 3732 8732 64 65 WXAAAA DGAAAA VVVVxx 139 160 1 3 9 19 39 139 139 139 139 78 79 JFAAAA EGAAAA AAAAxx 5372 161 0 0 2 12 72 372 1372 372 5372 144 145 QYAAAA FGAAAA HHHHxx 1278 162 0 2 8 18 78 278 1278 1278 1278 156 157 EXAAAA GGAAAA OOOOxx 4697 163 1 1 7 17 97 697 697 4697 4697 194 195 RYAAAA HGAAAA VVVVxx 8610 164 0 2 0 10 10 610 610 3610 8610 20 21 ETAAAA IGAAAA AAAAxx 8180 165 0 0 0 0 80 180 180 3180 8180 160 161 QCAAAA JGAAAA HHHHxx 2399 166 1 3 9 19 99 399 399 2399 2399 198 199 HOAAAA KGAAAA OOOOxx 615 167 1 3 5 15 15 615 615 615 615 30 31 RXAAAA LGAAAA VVVVxx 7629 168 1 1 9 9 29 629 1629 2629 7629 58 59 LHAAAA MGAAAA AAAAxx 7628 169 0 0 8 8 28 628 1628 2628 7628 56 57 KHAAAA NGAAAA HHHHxx 4659 170 1 3 9 19 59 659 659 4659 4659 118 119 FXAAAA OGAAAA OOOOxx 5865 171 1 1 5 5 65 865 1865 865 5865 130 131 PRAAAA PGAAAA VVVVxx 3973 172 1 1 3 13 73 973 1973 3973 3973 146 147 VWAAAA QGAAAA AAAAxx 552 173 0 0 2 12 52 552 552 552 552 104 105 GVAAAA RGAAAA HHHHxx 708 174 0 0 8 8 8 708 708 708 708 16 17 GBAAAA SGAAAA OOOOxx 3550 175 0 2 0 10 50 550 1550 3550 3550 100 101 OGAAAA TGAAAA VVVVxx 5547 176 1 3 7 7 47 547 1547 547 5547 94 95 JFAAAA UGAAAA AAAAxx 489 177 1 1 9 9 89 489 489 489 489 178 179 VSAAAA VGAAAA HHHHxx 3794 178 0 2 4 14 94 794 1794 3794 3794 188 189 YPAAAA WGAAAA OOOOxx 9479 179 1 3 9 19 79 479 1479 4479 9479 158 159 PAAAAA XGAAAA VVVVxx 6435 180 1 3 5 15 35 435 435 1435 6435 70 71 NNAAAA YGAAAA AAAAxx 5120 181 0 0 0 0 20 120 1120 120 5120 40 41 YOAAAA ZGAAAA HHHHxx 3615 182 1 3 5 15 15 615 1615 3615 3615 30 31 BJAAAA AHAAAA OOOOxx 8399 183 1 3 9 19 99 399 399 3399 8399 198 199 BLAAAA BHAAAA VVVVxx 2155 184 1 3 5 15 55 155 155 2155 2155 110 111 XEAAAA CHAAAA AAAAxx 6690 185 0 2 0 10 90 690 690 1690 6690 180 181 IXAAAA DHAAAA HHHHxx 1683 186 1 3 3 3 83 683 1683 1683 1683 166 167 TMAAAA EHAAAA OOOOxx 6302 187 0 2 2 2 2 302 302 1302 6302 4 5 KIAAAA FHAAAA VVVVxx 516 188 0 0 6 16 16 516 516 516 516 32 33 WTAAAA GHAAAA AAAAxx 3901 189 1 1 1 1 1 901 1901 3901 3901 2 3 BUAAAA HHAAAA HHHHxx 6938 190 0 2 8 18 38 938 938 1938 6938 76 77 WGAAAA IHAAAA OOOOxx 7484 191 0 0 4 4 84 484 1484 2484 7484 168 169 WBAAAA JHAAAA VVVVxx 7424 192 0 0 4 4 24 424 1424 2424 7424 48 49 OZAAAA KHAAAA AAAAxx 9410 193 0 2 0 10 10 410 1410 4410 9410 20 21 YXAAAA LHAAAA HHHHxx 1714 194 0 2 4 14 14 714 1714 1714 1714 28 29 YNAAAA MHAAAA OOOOxx 8278 195 0 2 8 18 78 278 278 3278 8278 156 157 KGAAAA NHAAAA VVVVxx 3158 196 0 2 8 18 58 158 1158 3158 3158 116 117 MRAAAA OHAAAA AAAAxx 2511 197 1 3 1 11 11 511 511 2511 2511 22 23 PSAAAA PHAAAA HHHHxx 2912 198 0 0 2 12 12 912 912 2912 2912 24 25 AIAAAA QHAAAA OOOOxx 2648 199 0 0 8 8 48 648 648 2648 2648 96 97 WXAAAA RHAAAA VVVVxx 9385 200 1 1 5 5 85 385 1385 4385 9385 170 171 ZWAAAA SHAAAA AAAAxx 7545 201 1 1 5 5 45 545 1545 2545 7545 90 91 FEAAAA THAAAA HHHHxx 8407 202 1 3 7 7 7 407 407 3407 8407 14 15 JLAAAA UHAAAA OOOOxx 5893 203 1 1 3 13 93 893 1893 893 5893 186 187 RSAAAA VHAAAA VVVVxx 7049 204 1 1 9 9 49 49 1049 2049 7049 98 99 DLAAAA WHAAAA AAAAxx 6812 205 0 0 2 12 12 812 812 1812 6812 24 25 ACAAAA XHAAAA HHHHxx 3649 206 1 1 9 9 49 649 1649 3649 3649 98 99 JKAAAA YHAAAA OOOOxx 9275 207 1 3 5 15 75 275 1275 4275 9275 150 151 TSAAAA ZHAAAA VVVVxx 1179 208 1 3 9 19 79 179 1179 1179 1179 158 159 JTAAAA AIAAAA AAAAxx 969 209 1 1 9 9 69 969 969 969 969 138 139 HLAAAA BIAAAA HHHHxx 7920 210 0 0 0 0 20 920 1920 2920 7920 40 41 QSAAAA CIAAAA OOOOxx 998 211 0 2 8 18 98 998 998 998 998 196 197 KMAAAA DIAAAA VVVVxx 3958 212 0 2 8 18 58 958 1958 3958 3958 116 117 GWAAAA EIAAAA AAAAxx 6052 213 0 0 2 12 52 52 52 1052 6052 104 105 UYAAAA FIAAAA HHHHxx 8791 214 1 3 1 11 91 791 791 3791 8791 182 183 DAAAAA GIAAAA OOOOxx 5191 215 1 3 1 11 91 191 1191 191 5191 182 183 RRAAAA HIAAAA VVVVxx 4267 216 1 3 7 7 67 267 267 4267 4267 134 135 DIAAAA IIAAAA AAAAxx 2829 217 1 1 9 9 29 829 829 2829 2829 58 59 VEAAAA JIAAAA HHHHxx 6396 218 0 0 6 16 96 396 396 1396 6396 192 193 AMAAAA KIAAAA OOOOxx 9413 219 1 1 3 13 13 413 1413 4413 9413 26 27 BYAAAA LIAAAA VVVVxx 614 220 0 2 4 14 14 614 614 614 614 28 29 QXAAAA MIAAAA AAAAxx 4660 221 0 0 0 0 60 660 660 4660 4660 120 121 GXAAAA NIAAAA HHHHxx 8834 222 0 2 4 14 34 834 834 3834 8834 68 69 UBAAAA OIAAAA OOOOxx 2767 223 1 3 7 7 67 767 767 2767 2767 134 135 LCAAAA PIAAAA VVVVxx 2444 224 0 0 4 4 44 444 444 2444 2444 88 89 AQAAAA QIAAAA AAAAxx 4129 225 1 1 9 9 29 129 129 4129 4129 58 59 VCAAAA RIAAAA HHHHxx 3394 226 0 2 4 14 94 394 1394 3394 3394 188 189 OAAAAA SIAAAA OOOOxx 2705 227 1 1 5 5 5 705 705 2705 2705 10 11 BAAAAA TIAAAA VVVVxx 8499 228 1 3 9 19 99 499 499 3499 8499 198 199 XOAAAA UIAAAA AAAAxx 8852 229 0 0 2 12 52 852 852 3852 8852 104 105 MCAAAA VIAAAA HHHHxx 6174 230 0 2 4 14 74 174 174 1174 6174 148 149 MDAAAA WIAAAA OOOOxx 750 231 0 2 0 10 50 750 750 750 750 100 101 WCAAAA XIAAAA VVVVxx 8164 232 0 0 4 4 64 164 164 3164 8164 128 129 ACAAAA YIAAAA AAAAxx 4930 233 0 2 0 10 30 930 930 4930 4930 60 61 QHAAAA ZIAAAA HHHHxx 9904 234 0 0 4 4 4 904 1904 4904 9904 8 9 YQAAAA AJAAAA OOOOxx 7378 235 0 2 8 18 78 378 1378 2378 7378 156 157 UXAAAA BJAAAA VVVVxx 2927 236 1 3 7 7 27 927 927 2927 2927 54 55 PIAAAA CJAAAA AAAAxx 7155 237 1 3 5 15 55 155 1155 2155 7155 110 111 FPAAAA DJAAAA HHHHxx 1302 238 0 2 2 2 2 302 1302 1302 1302 4 5 CYAAAA EJAAAA OOOOxx 5904 239 0 0 4 4 4 904 1904 904 5904 8 9 CTAAAA FJAAAA VVVVxx 9687 240 1 3 7 7 87 687 1687 4687 9687 174 175 PIAAAA GJAAAA AAAAxx 3553 241 1 1 3 13 53 553 1553 3553 3553 106 107 RGAAAA HJAAAA HHHHxx 4447 242 1 3 7 7 47 447 447 4447 4447 94 95 BPAAAA IJAAAA OOOOxx 6878 243 0 2 8 18 78 878 878 1878 6878 156 157 OEAAAA JJAAAA VVVVxx 9470 244 0 2 0 10 70 470 1470 4470 9470 140 141 GAAAAA KJAAAA AAAAxx 9735 245 1 3 5 15 35 735 1735 4735 9735 70 71 LKAAAA LJAAAA HHHHxx 5967 246 1 3 7 7 67 967 1967 967 5967 134 135 NVAAAA MJAAAA OOOOxx 6601 247 1 1 1 1 1 601 601 1601 6601 2 3 XTAAAA NJAAAA VVVVxx 7631 248 1 3 1 11 31 631 1631 2631 7631 62 63 NHAAAA OJAAAA AAAAxx 3559 249 1 3 9 19 59 559 1559 3559 3559 118 119 XGAAAA PJAAAA HHHHxx 2247 250 1 3 7 7 47 247 247 2247 2247 94 95 LIAAAA QJAAAA OOOOxx 9649 251 1 1 9 9 49 649 1649 4649 9649 98 99 DHAAAA RJAAAA VVVVxx 808 252 0 0 8 8 8 808 808 808 808 16 17 CFAAAA SJAAAA AAAAxx 240 253 0 0 0 0 40 240 240 240 240 80 81 GJAAAA TJAAAA HHHHxx 5031 254 1 3 1 11 31 31 1031 31 5031 62 63 NLAAAA UJAAAA OOOOxx 9563 255 1 3 3 3 63 563 1563 4563 9563 126 127 VDAAAA VJAAAA VVVVxx 5656 256 0 0 6 16 56 656 1656 656 5656 112 113 OJAAAA WJAAAA AAAAxx 3886 257 0 2 6 6 86 886 1886 3886 3886 172 173 MTAAAA XJAAAA HHHHxx 2431 258 1 3 1 11 31 431 431 2431 2431 62 63 NPAAAA YJAAAA OOOOxx 5560 259 0 0 0 0 60 560 1560 560 5560 120 121 WFAAAA ZJAAAA VVVVxx 9065 260 1 1 5 5 65 65 1065 4065 9065 130 131 RKAAAA AKAAAA AAAAxx 8130 261 0 2 0 10 30 130 130 3130 8130 60 61 SAAAAA BKAAAA HHHHxx 4054 262 0 2 4 14 54 54 54 4054 4054 108 109 YZAAAA CKAAAA OOOOxx 873 263 1 1 3 13 73 873 873 873 873 146 147 PHAAAA DKAAAA VVVVxx 3092 264 0 0 2 12 92 92 1092 3092 3092 184 185 YOAAAA EKAAAA AAAAxx 6697 265 1 1 7 17 97 697 697 1697 6697 194 195 PXAAAA FKAAAA HHHHxx 2452 266 0 0 2 12 52 452 452 2452 2452 104 105 IQAAAA GKAAAA OOOOxx 7867 267 1 3 7 7 67 867 1867 2867 7867 134 135 PQAAAA HKAAAA VVVVxx 3753 268 1 1 3 13 53 753 1753 3753 3753 106 107 JOAAAA IKAAAA AAAAxx 7834 269 0 2 4 14 34 834 1834 2834 7834 68 69 IPAAAA JKAAAA HHHHxx 5846 270 0 2 6 6 46 846 1846 846 5846 92 93 WQAAAA KKAAAA OOOOxx 7604 271 0 0 4 4 4 604 1604 2604 7604 8 9 MGAAAA LKAAAA VVVVxx 3452 272 0 0 2 12 52 452 1452 3452 3452 104 105 UCAAAA MKAAAA AAAAxx 4788 273 0 0 8 8 88 788 788 4788 4788 176 177 ECAAAA NKAAAA HHHHxx 8600 274 0 0 0 0 0 600 600 3600 8600 0 1 USAAAA OKAAAA OOOOxx 8511 275 1 3 1 11 11 511 511 3511 8511 22 23 JPAAAA PKAAAA VVVVxx 4452 276 0 0 2 12 52 452 452 4452 4452 104 105 GPAAAA QKAAAA AAAAxx 1709 277 1 1 9 9 9 709 1709 1709 1709 18 19 TNAAAA RKAAAA HHHHxx 3440 278 0 0 0 0 40 440 1440 3440 3440 80 81 ICAAAA SKAAAA OOOOxx 9188 279 0 0 8 8 88 188 1188 4188 9188 176 177 KPAAAA TKAAAA VVVVxx 3058 280 0 2 8 18 58 58 1058 3058 3058 116 117 QNAAAA UKAAAA AAAAxx 5821 281 1 1 1 1 21 821 1821 821 5821 42 43 XPAAAA VKAAAA HHHHxx 3428 282 0 0 8 8 28 428 1428 3428 3428 56 57 WBAAAA WKAAAA OOOOxx 3581 283 1 1 1 1 81 581 1581 3581 3581 162 163 THAAAA XKAAAA VVVVxx 7523 284 1 3 3 3 23 523 1523 2523 7523 46 47 JDAAAA YKAAAA AAAAxx 3131 285 1 3 1 11 31 131 1131 3131 3131 62 63 LQAAAA ZKAAAA HHHHxx 2404 286 0 0 4 4 4 404 404 2404 2404 8 9 MOAAAA ALAAAA OOOOxx 5453 287 1 1 3 13 53 453 1453 453 5453 106 107 TBAAAA BLAAAA VVVVxx 1599 288 1 3 9 19 99 599 1599 1599 1599 198 199 NJAAAA CLAAAA AAAAxx 7081 289 1 1 1 1 81 81 1081 2081 7081 162 163 JMAAAA DLAAAA HHHHxx 1750 290 0 2 0 10 50 750 1750 1750 1750 100 101 IPAAAA ELAAAA OOOOxx 5085 291 1 1 5 5 85 85 1085 85 5085 170 171 PNAAAA FLAAAA VVVVxx 9777 292 1 1 7 17 77 777 1777 4777 9777 154 155 BMAAAA GLAAAA AAAAxx 574 293 0 2 4 14 74 574 574 574 574 148 149 CWAAAA HLAAAA HHHHxx 5984 294 0 0 4 4 84 984 1984 984 5984 168 169 EWAAAA ILAAAA OOOOxx 7039 295 1 3 9 19 39 39 1039 2039 7039 78 79 TKAAAA JLAAAA VVVVxx 7143 296 1 3 3 3 43 143 1143 2143 7143 86 87 TOAAAA KLAAAA AAAAxx 5702 297 0 2 2 2 2 702 1702 702 5702 4 5 ILAAAA LLAAAA HHHHxx 362 298 0 2 2 2 62 362 362 362 362 124 125 YNAAAA MLAAAA OOOOxx 6997 299 1 1 7 17 97 997 997 1997 6997 194 195 DJAAAA NLAAAA VVVVxx 2529 300 1 1 9 9 29 529 529 2529 2529 58 59 HTAAAA OLAAAA AAAAxx 6319 301 1 3 9 19 19 319 319 1319 6319 38 39 BJAAAA PLAAAA HHHHxx 954 302 0 2 4 14 54 954 954 954 954 108 109 SKAAAA QLAAAA OOOOxx 3413 303 1 1 3 13 13 413 1413 3413 3413 26 27 HBAAAA RLAAAA VVVVxx 9081 304 1 1 1 1 81 81 1081 4081 9081 162 163 HLAAAA SLAAAA AAAAxx 5599 305 1 3 9 19 99 599 1599 599 5599 198 199 JHAAAA TLAAAA HHHHxx 4772 306 0 0 2 12 72 772 772 4772 4772 144 145 OBAAAA ULAAAA OOOOxx 1124 307 0 0 4 4 24 124 1124 1124 1124 48 49 GRAAAA VLAAAA VVVVxx 7793 308 1 1 3 13 93 793 1793 2793 7793 186 187 TNAAAA WLAAAA AAAAxx 4201 309 1 1 1 1 1 201 201 4201 4201 2 3 PFAAAA XLAAAA HHHHxx 7015 310 1 3 5 15 15 15 1015 2015 7015 30 31 VJAAAA YLAAAA OOOOxx 5936 311 0 0 6 16 36 936 1936 936 5936 72 73 IUAAAA ZLAAAA VVVVxx 4625 312 1 1 5 5 25 625 625 4625 4625 50 51 XVAAAA AMAAAA AAAAxx 4989 313 1 1 9 9 89 989 989 4989 4989 178 179 XJAAAA BMAAAA HHHHxx 4949 314 1 1 9 9 49 949 949 4949 4949 98 99 JIAAAA CMAAAA OOOOxx 6273 315 1 1 3 13 73 273 273 1273 6273 146 147 HHAAAA DMAAAA VVVVxx 4478 316 0 2 8 18 78 478 478 4478 4478 156 157 GQAAAA EMAAAA AAAAxx 8854 317 0 2 4 14 54 854 854 3854 8854 108 109 OCAAAA FMAAAA HHHHxx 2105 318 1 1 5 5 5 105 105 2105 2105 10 11 ZCAAAA GMAAAA OOOOxx 8345 319 1 1 5 5 45 345 345 3345 8345 90 91 ZIAAAA HMAAAA VVVVxx 1941 320 1 1 1 1 41 941 1941 1941 1941 82 83 RWAAAA IMAAAA AAAAxx 1765 321 1 1 5 5 65 765 1765 1765 1765 130 131 XPAAAA JMAAAA HHHHxx 9592 322 0 0 2 12 92 592 1592 4592 9592 184 185 YEAAAA KMAAAA OOOOxx 1694 323 0 2 4 14 94 694 1694 1694 1694 188 189 ENAAAA LMAAAA VVVVxx 8940 324 0 0 0 0 40 940 940 3940 8940 80 81 WFAAAA MMAAAA AAAAxx 7264 325 0 0 4 4 64 264 1264 2264 7264 128 129 KTAAAA NMAAAA HHHHxx 4699 326 1 3 9 19 99 699 699 4699 4699 198 199 TYAAAA OMAAAA OOOOxx 4541 327 1 1 1 1 41 541 541 4541 4541 82 83 RSAAAA PMAAAA VVVVxx 5768 328 0 0 8 8 68 768 1768 768 5768 136 137 WNAAAA QMAAAA AAAAxx 6183 329 1 3 3 3 83 183 183 1183 6183 166 167 VDAAAA RMAAAA HHHHxx 7457 330 1 1 7 17 57 457 1457 2457 7457 114 115 VAAAAA SMAAAA OOOOxx 7317 331 1 1 7 17 17 317 1317 2317 7317 34 35 LVAAAA TMAAAA VVVVxx 1944 332 0 0 4 4 44 944 1944 1944 1944 88 89 UWAAAA UMAAAA AAAAxx 665 333 1 1 5 5 65 665 665 665 665 130 131 PZAAAA VMAAAA HHHHxx 5974 334 0 2 4 14 74 974 1974 974 5974 148 149 UVAAAA WMAAAA OOOOxx 7370 335 0 2 0 10 70 370 1370 2370 7370 140 141 MXAAAA XMAAAA VVVVxx 9196 336 0 0 6 16 96 196 1196 4196 9196 192 193 SPAAAA YMAAAA AAAAxx 6796 337 0 0 6 16 96 796 796 1796 6796 192 193 KBAAAA ZMAAAA HHHHxx 6180 338 0 0 0 0 80 180 180 1180 6180 160 161 SDAAAA ANAAAA OOOOxx 8557 339 1 1 7 17 57 557 557 3557 8557 114 115 DRAAAA BNAAAA VVVVxx 928 340 0 0 8 8 28 928 928 928 928 56 57 SJAAAA CNAAAA AAAAxx 6275 341 1 3 5 15 75 275 275 1275 6275 150 151 JHAAAA DNAAAA HHHHxx 409 342 1 1 9 9 9 409 409 409 409 18 19 TPAAAA ENAAAA OOOOxx 6442 343 0 2 2 2 42 442 442 1442 6442 84 85 UNAAAA FNAAAA VVVVxx 5889 344 1 1 9 9 89 889 1889 889 5889 178 179 NSAAAA GNAAAA AAAAxx 5180 345 0 0 0 0 80 180 1180 180 5180 160 161 GRAAAA HNAAAA HHHHxx 1629 346 1 1 9 9 29 629 1629 1629 1629 58 59 RKAAAA INAAAA OOOOxx 6088 347 0 0 8 8 88 88 88 1088 6088 176 177 EAAAAA JNAAAA VVVVxx 5598 348 0 2 8 18 98 598 1598 598 5598 196 197 IHAAAA KNAAAA AAAAxx 1803 349 1 3 3 3 3 803 1803 1803 1803 6 7 JRAAAA LNAAAA HHHHxx 2330 350 0 2 0 10 30 330 330 2330 2330 60 61 QLAAAA MNAAAA OOOOxx 5901 351 1 1 1 1 1 901 1901 901 5901 2 3 ZSAAAA NNAAAA VVVVxx 780 352 0 0 0 0 80 780 780 780 780 160 161 AEAAAA ONAAAA AAAAxx 7171 353 1 3 1 11 71 171 1171 2171 7171 142 143 VPAAAA PNAAAA HHHHxx 8778 354 0 2 8 18 78 778 778 3778 8778 156 157 QZAAAA QNAAAA OOOOxx 6622 355 0 2 2 2 22 622 622 1622 6622 44 45 SUAAAA RNAAAA VVVVxx 9938 356 0 2 8 18 38 938 1938 4938 9938 76 77 GSAAAA SNAAAA AAAAxx 8254 357 0 2 4 14 54 254 254 3254 8254 108 109 MFAAAA TNAAAA HHHHxx 1951 358 1 3 1 11 51 951 1951 1951 1951 102 103 BXAAAA UNAAAA OOOOxx 1434 359 0 2 4 14 34 434 1434 1434 1434 68 69 EDAAAA VNAAAA VVVVxx 7539 360 1 3 9 19 39 539 1539 2539 7539 78 79 ZDAAAA WNAAAA AAAAxx 600 361 0 0 0 0 0 600 600 600 600 0 1 CXAAAA XNAAAA HHHHxx 3122 362 0 2 2 2 22 122 1122 3122 3122 44 45 CQAAAA YNAAAA OOOOxx 5704 363 0 0 4 4 4 704 1704 704 5704 8 9 KLAAAA ZNAAAA VVVVxx 6300 364 0 0 0 0 0 300 300 1300 6300 0 1 IIAAAA AOAAAA AAAAxx 4585 365 1 1 5 5 85 585 585 4585 4585 170 171 JUAAAA BOAAAA HHHHxx 6313 366 1 1 3 13 13 313 313 1313 6313 26 27 VIAAAA COAAAA OOOOxx 3154 367 0 2 4 14 54 154 1154 3154 3154 108 109 IRAAAA DOAAAA VVVVxx 642 368 0 2 2 2 42 642 642 642 642 84 85 SYAAAA EOAAAA AAAAxx 7736 369 0 0 6 16 36 736 1736 2736 7736 72 73 OLAAAA FOAAAA HHHHxx 5087 370 1 3 7 7 87 87 1087 87 5087 174 175 RNAAAA GOAAAA OOOOxx 5708 371 0 0 8 8 8 708 1708 708 5708 16 17 OLAAAA HOAAAA VVVVxx 8169 372 1 1 9 9 69 169 169 3169 8169 138 139 FCAAAA IOAAAA AAAAxx 9768 373 0 0 8 8 68 768 1768 4768 9768 136 137 SLAAAA JOAAAA HHHHxx 3874 374 0 2 4 14 74 874 1874 3874 3874 148 149 ATAAAA KOAAAA OOOOxx 6831 375 1 3 1 11 31 831 831 1831 6831 62 63 TCAAAA LOAAAA VVVVxx 18 376 0 2 8 18 18 18 18 18 18 36 37 SAAAAA MOAAAA AAAAxx 6375 377 1 3 5 15 75 375 375 1375 6375 150 151 FLAAAA NOAAAA HHHHxx 7106 378 0 2 6 6 6 106 1106 2106 7106 12 13 INAAAA OOAAAA OOOOxx 5926 379 0 2 6 6 26 926 1926 926 5926 52 53 YTAAAA POAAAA VVVVxx 4956 380 0 0 6 16 56 956 956 4956 4956 112 113 QIAAAA QOAAAA AAAAxx 7042 381 0 2 2 2 42 42 1042 2042 7042 84 85 WKAAAA ROAAAA HHHHxx 6043 382 1 3 3 3 43 43 43 1043 6043 86 87 LYAAAA SOAAAA OOOOxx 2084 383 0 0 4 4 84 84 84 2084 2084 168 169 ECAAAA TOAAAA VVVVxx 6038 384 0 2 8 18 38 38 38 1038 6038 76 77 GYAAAA UOAAAA AAAAxx 7253 385 1 1 3 13 53 253 1253 2253 7253 106 107 ZSAAAA VOAAAA HHHHxx 2061 386 1 1 1 1 61 61 61 2061 2061 122 123 HBAAAA WOAAAA OOOOxx 7800 387 0 0 0 0 0 800 1800 2800 7800 0 1 AOAAAA XOAAAA VVVVxx 4970 388 0 2 0 10 70 970 970 4970 4970 140 141 EJAAAA YOAAAA AAAAxx 8580 389 0 0 0 0 80 580 580 3580 8580 160 161 ASAAAA ZOAAAA HHHHxx 9173 390 1 1 3 13 73 173 1173 4173 9173 146 147 VOAAAA APAAAA OOOOxx 8558 391 0 2 8 18 58 558 558 3558 8558 116 117 ERAAAA BPAAAA VVVVxx 3897 392 1 1 7 17 97 897 1897 3897 3897 194 195 XTAAAA CPAAAA AAAAxx 5069 393 1 1 9 9 69 69 1069 69 5069 138 139 ZMAAAA DPAAAA HHHHxx 2301 394 1 1 1 1 1 301 301 2301 2301 2 3 NKAAAA EPAAAA OOOOxx 9863 395 1 3 3 3 63 863 1863 4863 9863 126 127 JPAAAA FPAAAA VVVVxx 5733 396 1 1 3 13 33 733 1733 733 5733 66 67 NMAAAA GPAAAA AAAAxx 2338 397 0 2 8 18 38 338 338 2338 2338 76 77 YLAAAA HPAAAA HHHHxx 9639 398 1 3 9 19 39 639 1639 4639 9639 78 79 TGAAAA IPAAAA OOOOxx 1139 399 1 3 9 19 39 139 1139 1139 1139 78 79 VRAAAA JPAAAA VVVVxx 2293 400 1 1 3 13 93 293 293 2293 2293 186 187 FKAAAA KPAAAA AAAAxx 6125 401 1 1 5 5 25 125 125 1125 6125 50 51 PBAAAA LPAAAA HHHHxx 5374 402 0 2 4 14 74 374 1374 374 5374 148 149 SYAAAA MPAAAA OOOOxx 7216 403 0 0 6 16 16 216 1216 2216 7216 32 33 ORAAAA NPAAAA VVVVxx 2285 404 1 1 5 5 85 285 285 2285 2285 170 171 XJAAAA OPAAAA AAAAxx 2387 405 1 3 7 7 87 387 387 2387 2387 174 175 VNAAAA PPAAAA HHHHxx 5015 406 1 3 5 15 15 15 1015 15 5015 30 31 XKAAAA QPAAAA OOOOxx 2087 407 1 3 7 7 87 87 87 2087 2087 174 175 HCAAAA RPAAAA VVVVxx 4938 408 0 2 8 18 38 938 938 4938 4938 76 77 YHAAAA SPAAAA AAAAxx 3635 409 1 3 5 15 35 635 1635 3635 3635 70 71 VJAAAA TPAAAA HHHHxx 7737 410 1 1 7 17 37 737 1737 2737 7737 74 75 PLAAAA UPAAAA OOOOxx 8056 411 0 0 6 16 56 56 56 3056 8056 112 113 WXAAAA VPAAAA VVVVxx 4502 412 0 2 2 2 2 502 502 4502 4502 4 5 ERAAAA WPAAAA AAAAxx 54 413 0 2 4 14 54 54 54 54 54 108 109 CCAAAA XPAAAA HHHHxx 3182 414 0 2 2 2 82 182 1182 3182 3182 164 165 KSAAAA YPAAAA OOOOxx 3718 415 0 2 8 18 18 718 1718 3718 3718 36 37 ANAAAA ZPAAAA VVVVxx 3989 416 1 1 9 9 89 989 1989 3989 3989 178 179 LXAAAA AQAAAA AAAAxx 8028 417 0 0 8 8 28 28 28 3028 8028 56 57 UWAAAA BQAAAA HHHHxx 1426 418 0 2 6 6 26 426 1426 1426 1426 52 53 WCAAAA CQAAAA OOOOxx 3801 419 1 1 1 1 1 801 1801 3801 3801 2 3 FQAAAA DQAAAA VVVVxx 241 420 1 1 1 1 41 241 241 241 241 82 83 HJAAAA EQAAAA AAAAxx 8000 421 0 0 0 0 0 0 0 3000 8000 0 1 SVAAAA FQAAAA HHHHxx 8357 422 1 1 7 17 57 357 357 3357 8357 114 115 LJAAAA GQAAAA OOOOxx 7548 423 0 0 8 8 48 548 1548 2548 7548 96 97 IEAAAA HQAAAA VVVVxx 7307 424 1 3 7 7 7 307 1307 2307 7307 14 15 BVAAAA IQAAAA AAAAxx 2275 425 1 3 5 15 75 275 275 2275 2275 150 151 NJAAAA JQAAAA HHHHxx 2718 426 0 2 8 18 18 718 718 2718 2718 36 37 OAAAAA KQAAAA OOOOxx 7068 427 0 0 8 8 68 68 1068 2068 7068 136 137 WLAAAA LQAAAA VVVVxx 3181 428 1 1 1 1 81 181 1181 3181 3181 162 163 JSAAAA MQAAAA AAAAxx 749 429 1 1 9 9 49 749 749 749 749 98 99 VCAAAA NQAAAA HHHHxx 5195 430 1 3 5 15 95 195 1195 195 5195 190 191 VRAAAA OQAAAA OOOOxx 6136 431 0 0 6 16 36 136 136 1136 6136 72 73 ACAAAA PQAAAA VVVVxx 8012 432 0 0 2 12 12 12 12 3012 8012 24 25 EWAAAA QQAAAA AAAAxx 3957 433 1 1 7 17 57 957 1957 3957 3957 114 115 FWAAAA RQAAAA HHHHxx 3083 434 1 3 3 3 83 83 1083 3083 3083 166 167 POAAAA SQAAAA OOOOxx 9997 435 1 1 7 17 97 997 1997 4997 9997 194 195 NUAAAA TQAAAA VVVVxx 3299 436 1 3 9 19 99 299 1299 3299 3299 198 199 XWAAAA UQAAAA AAAAxx 846 437 0 2 6 6 46 846 846 846 846 92 93 OGAAAA VQAAAA HHHHxx 2985 438 1 1 5 5 85 985 985 2985 2985 170 171 VKAAAA WQAAAA OOOOxx 9238 439 0 2 8 18 38 238 1238 4238 9238 76 77 IRAAAA XQAAAA VVVVxx 1403 440 1 3 3 3 3 403 1403 1403 1403 6 7 ZBAAAA YQAAAA AAAAxx 5563 441 1 3 3 3 63 563 1563 563 5563 126 127 ZFAAAA ZQAAAA HHHHxx 7965 442 1 1 5 5 65 965 1965 2965 7965 130 131 JUAAAA ARAAAA OOOOxx 4512 443 0 0 2 12 12 512 512 4512 4512 24 25 ORAAAA BRAAAA VVVVxx 9730 444 0 2 0 10 30 730 1730 4730 9730 60 61 GKAAAA CRAAAA AAAAxx 1129 445 1 1 9 9 29 129 1129 1129 1129 58 59 LRAAAA DRAAAA HHHHxx 2624 446 0 0 4 4 24 624 624 2624 2624 48 49 YWAAAA ERAAAA OOOOxx 8178 447 0 2 8 18 78 178 178 3178 8178 156 157 OCAAAA FRAAAA VVVVxx 6468 448 0 0 8 8 68 468 468 1468 6468 136 137 UOAAAA GRAAAA AAAAxx 3027 449 1 3 7 7 27 27 1027 3027 3027 54 55 LMAAAA HRAAAA HHHHxx 3845 450 1 1 5 5 45 845 1845 3845 3845 90 91 XRAAAA IRAAAA OOOOxx 786 451 0 2 6 6 86 786 786 786 786 172 173 GEAAAA JRAAAA VVVVxx 4971 452 1 3 1 11 71 971 971 4971 4971 142 143 FJAAAA KRAAAA AAAAxx 1542 453 0 2 2 2 42 542 1542 1542 1542 84 85 IHAAAA LRAAAA HHHHxx 7967 454 1 3 7 7 67 967 1967 2967 7967 134 135 LUAAAA MRAAAA OOOOxx 443 455 1 3 3 3 43 443 443 443 443 86 87 BRAAAA NRAAAA VVVVxx 7318 456 0 2 8 18 18 318 1318 2318 7318 36 37 MVAAAA ORAAAA AAAAxx 4913 457 1 1 3 13 13 913 913 4913 4913 26 27 ZGAAAA PRAAAA HHHHxx 9466 458 0 2 6 6 66 466 1466 4466 9466 132 133 CAAAAA QRAAAA OOOOxx 7866 459 0 2 6 6 66 866 1866 2866 7866 132 133 OQAAAA RRAAAA VVVVxx 784 460 0 0 4 4 84 784 784 784 784 168 169 EEAAAA SRAAAA AAAAxx 9040 461 0 0 0 0 40 40 1040 4040 9040 80 81 SJAAAA TRAAAA HHHHxx 3954 462 0 2 4 14 54 954 1954 3954 3954 108 109 CWAAAA URAAAA OOOOxx 4183 463 1 3 3 3 83 183 183 4183 4183 166 167 XEAAAA VRAAAA VVVVxx 3608 464 0 0 8 8 8 608 1608 3608 3608 16 17 UIAAAA WRAAAA AAAAxx 7630 465 0 2 0 10 30 630 1630 2630 7630 60 61 MHAAAA XRAAAA HHHHxx 590 466 0 2 0 10 90 590 590 590 590 180 181 SWAAAA YRAAAA OOOOxx 3453 467 1 1 3 13 53 453 1453 3453 3453 106 107 VCAAAA ZRAAAA VVVVxx 7757 468 1 1 7 17 57 757 1757 2757 7757 114 115 JMAAAA ASAAAA AAAAxx 7394 469 0 2 4 14 94 394 1394 2394 7394 188 189 KYAAAA BSAAAA HHHHxx 396 470 0 0 6 16 96 396 396 396 396 192 193 GPAAAA CSAAAA OOOOxx 7873 471 1 1 3 13 73 873 1873 2873 7873 146 147 VQAAAA DSAAAA VVVVxx 1553 472 1 1 3 13 53 553 1553 1553 1553 106 107 THAAAA ESAAAA AAAAxx 598 473 0 2 8 18 98 598 598 598 598 196 197 AXAAAA FSAAAA HHHHxx 7191 474 1 3 1 11 91 191 1191 2191 7191 182 183 PQAAAA GSAAAA OOOOxx 8116 475 0 0 6 16 16 116 116 3116 8116 32 33 EAAAAA HSAAAA VVVVxx 2516 476 0 0 6 16 16 516 516 2516 2516 32 33 USAAAA ISAAAA AAAAxx 7750 477 0 2 0 10 50 750 1750 2750 7750 100 101 CMAAAA JSAAAA HHHHxx 6625 478 1 1 5 5 25 625 625 1625 6625 50 51 VUAAAA KSAAAA OOOOxx 8838 479 0 2 8 18 38 838 838 3838 8838 76 77 YBAAAA LSAAAA VVVVxx 4636 480 0 0 6 16 36 636 636 4636 4636 72 73 IWAAAA MSAAAA AAAAxx 7627 481 1 3 7 7 27 627 1627 2627 7627 54 55 JHAAAA NSAAAA HHHHxx 1690 482 0 2 0 10 90 690 1690 1690 1690 180 181 ANAAAA OSAAAA OOOOxx 7071 483 1 3 1 11 71 71 1071 2071 7071 142 143 ZLAAAA PSAAAA VVVVxx 2081 484 1 1 1 1 81 81 81 2081 2081 162 163 BCAAAA QSAAAA AAAAxx 7138 485 0 2 8 18 38 138 1138 2138 7138 76 77 OOAAAA RSAAAA HHHHxx 864 486 0 0 4 4 64 864 864 864 864 128 129 GHAAAA SSAAAA OOOOxx 6392 487 0 0 2 12 92 392 392 1392 6392 184 185 WLAAAA TSAAAA VVVVxx 7544 488 0 0 4 4 44 544 1544 2544 7544 88 89 EEAAAA USAAAA AAAAxx 5438 489 0 2 8 18 38 438 1438 438 5438 76 77 EBAAAA VSAAAA HHHHxx 7099 490 1 3 9 19 99 99 1099 2099 7099 198 199 BNAAAA WSAAAA OOOOxx 5157 491 1 1 7 17 57 157 1157 157 5157 114 115 JQAAAA XSAAAA VVVVxx 3391 492 1 3 1 11 91 391 1391 3391 3391 182 183 LAAAAA YSAAAA AAAAxx 3805 493 1 1 5 5 5 805 1805 3805 3805 10 11 JQAAAA ZSAAAA HHHHxx 2110 494 0 2 0 10 10 110 110 2110 2110 20 21 EDAAAA ATAAAA OOOOxx 3176 495 0 0 6 16 76 176 1176 3176 3176 152 153 ESAAAA BTAAAA VVVVxx 5918 496 0 2 8 18 18 918 1918 918 5918 36 37 QTAAAA CTAAAA AAAAxx 1218 497 0 2 8 18 18 218 1218 1218 1218 36 37 WUAAAA DTAAAA HHHHxx 6683 498 1 3 3 3 83 683 683 1683 6683 166 167 BXAAAA ETAAAA OOOOxx 914 499 0 2 4 14 14 914 914 914 914 28 29 EJAAAA FTAAAA VVVVxx 4737 500 1 1 7 17 37 737 737 4737 4737 74 75 FAAAAA GTAAAA AAAAxx 7286 501 0 2 6 6 86 286 1286 2286 7286 172 173 GUAAAA HTAAAA HHHHxx 9975 502 1 3 5 15 75 975 1975 4975 9975 150 151 RTAAAA ITAAAA OOOOxx 8030 503 0 2 0 10 30 30 30 3030 8030 60 61 WWAAAA JTAAAA VVVVxx 7364 504 0 0 4 4 64 364 1364 2364 7364 128 129 GXAAAA KTAAAA AAAAxx 1389 505 1 1 9 9 89 389 1389 1389 1389 178 179 LBAAAA LTAAAA HHHHxx 4025 506 1 1 5 5 25 25 25 4025 4025 50 51 VYAAAA MTAAAA OOOOxx 4835 507 1 3 5 15 35 835 835 4835 4835 70 71 ZDAAAA NTAAAA VVVVxx 8045 508 1 1 5 5 45 45 45 3045 8045 90 91 LXAAAA OTAAAA AAAAxx 1864 509 0 0 4 4 64 864 1864 1864 1864 128 129 STAAAA PTAAAA HHHHxx 3313 510 1 1 3 13 13 313 1313 3313 3313 26 27 LXAAAA QTAAAA OOOOxx 2384 511 0 0 4 4 84 384 384 2384 2384 168 169 SNAAAA RTAAAA VVVVxx 6115 512 1 3 5 15 15 115 115 1115 6115 30 31 FBAAAA STAAAA AAAAxx 5705 513 1 1 5 5 5 705 1705 705 5705 10 11 LLAAAA TTAAAA HHHHxx 9269 514 1 1 9 9 69 269 1269 4269 9269 138 139 NSAAAA UTAAAA OOOOxx 3379 515 1 3 9 19 79 379 1379 3379 3379 158 159 ZZAAAA VTAAAA VVVVxx 8205 516 1 1 5 5 5 205 205 3205 8205 10 11 PDAAAA WTAAAA AAAAxx 6575 517 1 3 5 15 75 575 575 1575 6575 150 151 XSAAAA XTAAAA HHHHxx 486 518 0 2 6 6 86 486 486 486 486 172 173 SSAAAA YTAAAA OOOOxx 4894 519 0 2 4 14 94 894 894 4894 4894 188 189 GGAAAA ZTAAAA VVVVxx 3090 520 0 2 0 10 90 90 1090 3090 3090 180 181 WOAAAA AUAAAA AAAAxx 759 521 1 3 9 19 59 759 759 759 759 118 119 FDAAAA BUAAAA HHHHxx 4864 522 0 0 4 4 64 864 864 4864 4864 128 129 CFAAAA CUAAAA OOOOxx 4083 523 1 3 3 3 83 83 83 4083 4083 166 167 BBAAAA DUAAAA VVVVxx 6918 524 0 2 8 18 18 918 918 1918 6918 36 37 CGAAAA EUAAAA AAAAxx 8146 525 0 2 6 6 46 146 146 3146 8146 92 93 IBAAAA FUAAAA HHHHxx 1523 526 1 3 3 3 23 523 1523 1523 1523 46 47 PGAAAA GUAAAA OOOOxx 1591 527 1 3 1 11 91 591 1591 1591 1591 182 183 FJAAAA HUAAAA VVVVxx 3343 528 1 3 3 3 43 343 1343 3343 3343 86 87 PYAAAA IUAAAA AAAAxx 1391 529 1 3 1 11 91 391 1391 1391 1391 182 183 NBAAAA JUAAAA HHHHxx 9963 530 1 3 3 3 63 963 1963 4963 9963 126 127 FTAAAA KUAAAA OOOOxx 2423 531 1 3 3 3 23 423 423 2423 2423 46 47 FPAAAA LUAAAA VVVVxx 1822 532 0 2 2 2 22 822 1822 1822 1822 44 45 CSAAAA MUAAAA AAAAxx 8706 533 0 2 6 6 6 706 706 3706 8706 12 13 WWAAAA NUAAAA HHHHxx 3001 534 1 1 1 1 1 1 1001 3001 3001 2 3 LLAAAA OUAAAA OOOOxx 6707 535 1 3 7 7 7 707 707 1707 6707 14 15 ZXAAAA PUAAAA VVVVxx 2121 536 1 1 1 1 21 121 121 2121 2121 42 43 PDAAAA QUAAAA AAAAxx 5814 537 0 2 4 14 14 814 1814 814 5814 28 29 QPAAAA RUAAAA HHHHxx 2659 538 1 3 9 19 59 659 659 2659 2659 118 119 HYAAAA SUAAAA OOOOxx 2016 539 0 0 6 16 16 16 16 2016 2016 32 33 OZAAAA TUAAAA VVVVxx 4286 540 0 2 6 6 86 286 286 4286 4286 172 173 WIAAAA UUAAAA AAAAxx 9205 541 1 1 5 5 5 205 1205 4205 9205 10 11 BQAAAA VUAAAA HHHHxx 3496 542 0 0 6 16 96 496 1496 3496 3496 192 193 MEAAAA WUAAAA OOOOxx 5333 543 1 1 3 13 33 333 1333 333 5333 66 67 DXAAAA XUAAAA VVVVxx 5571 544 1 3 1 11 71 571 1571 571 5571 142 143 HGAAAA YUAAAA AAAAxx 1696 545 0 0 6 16 96 696 1696 1696 1696 192 193 GNAAAA ZUAAAA HHHHxx 4871 546 1 3 1 11 71 871 871 4871 4871 142 143 JFAAAA AVAAAA OOOOxx 4852 547 0 0 2 12 52 852 852 4852 4852 104 105 QEAAAA BVAAAA VVVVxx 8483 548 1 3 3 3 83 483 483 3483 8483 166 167 HOAAAA CVAAAA AAAAxx 1376 549 0 0 6 16 76 376 1376 1376 1376 152 153 YAAAAA DVAAAA HHHHxx 5456 550 0 0 6 16 56 456 1456 456 5456 112 113 WBAAAA EVAAAA OOOOxx 499 551 1 3 9 19 99 499 499 499 499 198 199 FTAAAA FVAAAA VVVVxx 3463 552 1 3 3 3 63 463 1463 3463 3463 126 127 FDAAAA GVAAAA AAAAxx 7426 553 0 2 6 6 26 426 1426 2426 7426 52 53 QZAAAA HVAAAA HHHHxx 5341 554 1 1 1 1 41 341 1341 341 5341 82 83 LXAAAA IVAAAA OOOOxx 9309 555 1 1 9 9 9 309 1309 4309 9309 18 19 BUAAAA JVAAAA VVVVxx 2055 556 1 3 5 15 55 55 55 2055 2055 110 111 BBAAAA KVAAAA AAAAxx 2199 557 1 3 9 19 99 199 199 2199 2199 198 199 PGAAAA LVAAAA HHHHxx 7235 558 1 3 5 15 35 235 1235 2235 7235 70 71 HSAAAA MVAAAA OOOOxx 8661 559 1 1 1 1 61 661 661 3661 8661 122 123 DVAAAA NVAAAA VVVVxx 9494 560 0 2 4 14 94 494 1494 4494 9494 188 189 EBAAAA OVAAAA AAAAxx 935 561 1 3 5 15 35 935 935 935 935 70 71 ZJAAAA PVAAAA HHHHxx 7044 562 0 0 4 4 44 44 1044 2044 7044 88 89 YKAAAA QVAAAA OOOOxx 1974 563 0 2 4 14 74 974 1974 1974 1974 148 149 YXAAAA RVAAAA VVVVxx 9679 564 1 3 9 19 79 679 1679 4679 9679 158 159 HIAAAA SVAAAA AAAAxx 9822 565 0 2 2 2 22 822 1822 4822 9822 44 45 UNAAAA TVAAAA HHHHxx 4088 566 0 0 8 8 88 88 88 4088 4088 176 177 GBAAAA UVAAAA OOOOxx 1749 567 1 1 9 9 49 749 1749 1749 1749 98 99 HPAAAA VVAAAA VVVVxx 2116 568 0 0 6 16 16 116 116 2116 2116 32 33 KDAAAA WVAAAA AAAAxx 976 569 0 0 6 16 76 976 976 976 976 152 153 OLAAAA XVAAAA HHHHxx 8689 570 1 1 9 9 89 689 689 3689 8689 178 179 FWAAAA YVAAAA OOOOxx 2563 571 1 3 3 3 63 563 563 2563 2563 126 127 PUAAAA ZVAAAA VVVVxx 7195 572 1 3 5 15 95 195 1195 2195 7195 190 191 TQAAAA AWAAAA AAAAxx 9985 573 1 1 5 5 85 985 1985 4985 9985 170 171 BUAAAA BWAAAA HHHHxx 7699 574 1 3 9 19 99 699 1699 2699 7699 198 199 DKAAAA CWAAAA OOOOxx 5311 575 1 3 1 11 11 311 1311 311 5311 22 23 HWAAAA DWAAAA VVVVxx 295 576 1 3 5 15 95 295 295 295 295 190 191 JLAAAA EWAAAA AAAAxx 8214 577 0 2 4 14 14 214 214 3214 8214 28 29 YDAAAA FWAAAA HHHHxx 3275 578 1 3 5 15 75 275 1275 3275 3275 150 151 ZVAAAA GWAAAA OOOOxx 9646 579 0 2 6 6 46 646 1646 4646 9646 92 93 AHAAAA HWAAAA VVVVxx 1908 580 0 0 8 8 8 908 1908 1908 1908 16 17 KVAAAA IWAAAA AAAAxx 3858 581 0 2 8 18 58 858 1858 3858 3858 116 117 KSAAAA JWAAAA HHHHxx 9362 582 0 2 2 2 62 362 1362 4362 9362 124 125 CWAAAA KWAAAA OOOOxx 9307 583 1 3 7 7 7 307 1307 4307 9307 14 15 ZTAAAA LWAAAA VVVVxx 6124 584 0 0 4 4 24 124 124 1124 6124 48 49 OBAAAA MWAAAA AAAAxx 2405 585 1 1 5 5 5 405 405 2405 2405 10 11 NOAAAA NWAAAA HHHHxx 8422 586 0 2 2 2 22 422 422 3422 8422 44 45 YLAAAA OWAAAA OOOOxx 393 587 1 1 3 13 93 393 393 393 393 186 187 DPAAAA PWAAAA VVVVxx 8973 588 1 1 3 13 73 973 973 3973 8973 146 147 DHAAAA QWAAAA AAAAxx 5171 589 1 3 1 11 71 171 1171 171 5171 142 143 XQAAAA RWAAAA HHHHxx 4929 590 1 1 9 9 29 929 929 4929 4929 58 59 PHAAAA SWAAAA OOOOxx 6935 591 1 3 5 15 35 935 935 1935 6935 70 71 TGAAAA TWAAAA VVVVxx 8584 592 0 0 4 4 84 584 584 3584 8584 168 169 ESAAAA UWAAAA AAAAxx 1035 593 1 3 5 15 35 35 1035 1035 1035 70 71 VNAAAA VWAAAA HHHHxx 3734 594 0 2 4 14 34 734 1734 3734 3734 68 69 QNAAAA WWAAAA OOOOxx 1458 595 0 2 8 18 58 458 1458 1458 1458 116 117 CEAAAA XWAAAA VVVVxx 8746 596 0 2 6 6 46 746 746 3746 8746 92 93 KYAAAA YWAAAA AAAAxx 1677 597 1 1 7 17 77 677 1677 1677 1677 154 155 NMAAAA ZWAAAA HHHHxx 8502 598 0 2 2 2 2 502 502 3502 8502 4 5 APAAAA AXAAAA OOOOxx 7752 599 0 0 2 12 52 752 1752 2752 7752 104 105 EMAAAA BXAAAA VVVVxx 2556 600 0 0 6 16 56 556 556 2556 2556 112 113 IUAAAA CXAAAA AAAAxx 6426 601 0 2 6 6 26 426 426 1426 6426 52 53 ENAAAA DXAAAA HHHHxx 8420 602 0 0 0 0 20 420 420 3420 8420 40 41 WLAAAA EXAAAA OOOOxx 4462 603 0 2 2 2 62 462 462 4462 4462 124 125 QPAAAA FXAAAA VVVVxx 1378 604 0 2 8 18 78 378 1378 1378 1378 156 157 ABAAAA GXAAAA AAAAxx 1387 605 1 3 7 7 87 387 1387 1387 1387 174 175 JBAAAA HXAAAA HHHHxx 8094 606 0 2 4 14 94 94 94 3094 8094 188 189 IZAAAA IXAAAA OOOOxx 7247 607 1 3 7 7 47 247 1247 2247 7247 94 95 TSAAAA JXAAAA VVVVxx 4261 608 1 1 1 1 61 261 261 4261 4261 122 123 XHAAAA KXAAAA AAAAxx 5029 609 1 1 9 9 29 29 1029 29 5029 58 59 LLAAAA LXAAAA HHHHxx 3625 610 1 1 5 5 25 625 1625 3625 3625 50 51 LJAAAA MXAAAA OOOOxx 8068 611 0 0 8 8 68 68 68 3068 8068 136 137 IYAAAA NXAAAA VVVVxx 102 612 0 2 2 2 2 102 102 102 102 4 5 YDAAAA OXAAAA AAAAxx 5596 613 0 0 6 16 96 596 1596 596 5596 192 193 GHAAAA PXAAAA HHHHxx 5872 614 0 0 2 12 72 872 1872 872 5872 144 145 WRAAAA QXAAAA OOOOxx 4742 615 0 2 2 2 42 742 742 4742 4742 84 85 KAAAAA RXAAAA VVVVxx 2117 616 1 1 7 17 17 117 117 2117 2117 34 35 LDAAAA SXAAAA AAAAxx 3945 617 1 1 5 5 45 945 1945 3945 3945 90 91 TVAAAA TXAAAA HHHHxx 7483 618 1 3 3 3 83 483 1483 2483 7483 166 167 VBAAAA UXAAAA OOOOxx 4455 619 1 3 5 15 55 455 455 4455 4455 110 111 JPAAAA VXAAAA VVVVxx 609 620 1 1 9 9 9 609 609 609 609 18 19 LXAAAA WXAAAA AAAAxx 9829 621 1 1 9 9 29 829 1829 4829 9829 58 59 BOAAAA XXAAAA HHHHxx 4857 622 1 1 7 17 57 857 857 4857 4857 114 115 VEAAAA YXAAAA OOOOxx 3314 623 0 2 4 14 14 314 1314 3314 3314 28 29 MXAAAA ZXAAAA VVVVxx 5353 624 1 1 3 13 53 353 1353 353 5353 106 107 XXAAAA AYAAAA AAAAxx 4909 625 1 1 9 9 9 909 909 4909 4909 18 19 VGAAAA BYAAAA HHHHxx 7597 626 1 1 7 17 97 597 1597 2597 7597 194 195 FGAAAA CYAAAA OOOOxx 2683 627 1 3 3 3 83 683 683 2683 2683 166 167 FZAAAA DYAAAA VVVVxx 3223 628 1 3 3 3 23 223 1223 3223 3223 46 47 ZTAAAA EYAAAA AAAAxx 5363 629 1 3 3 3 63 363 1363 363 5363 126 127 HYAAAA FYAAAA HHHHxx 4578 630 0 2 8 18 78 578 578 4578 4578 156 157 CUAAAA GYAAAA OOOOxx 5544 631 0 0 4 4 44 544 1544 544 5544 88 89 GFAAAA HYAAAA VVVVxx 1589 632 1 1 9 9 89 589 1589 1589 1589 178 179 DJAAAA IYAAAA AAAAxx 7412 633 0 0 2 12 12 412 1412 2412 7412 24 25 CZAAAA JYAAAA HHHHxx 3803 634 1 3 3 3 3 803 1803 3803 3803 6 7 HQAAAA KYAAAA OOOOxx 6179 635 1 3 9 19 79 179 179 1179 6179 158 159 RDAAAA LYAAAA VVVVxx 5588 636 0 0 8 8 88 588 1588 588 5588 176 177 YGAAAA MYAAAA AAAAxx 2134 637 0 2 4 14 34 134 134 2134 2134 68 69 CEAAAA NYAAAA HHHHxx 4383 638 1 3 3 3 83 383 383 4383 4383 166 167 PMAAAA OYAAAA OOOOxx 6995 639 1 3 5 15 95 995 995 1995 6995 190 191 BJAAAA PYAAAA VVVVxx 6598 640 0 2 8 18 98 598 598 1598 6598 196 197 UTAAAA QYAAAA AAAAxx 8731 641 1 3 1 11 31 731 731 3731 8731 62 63 VXAAAA RYAAAA HHHHxx 7177 642 1 1 7 17 77 177 1177 2177 7177 154 155 BQAAAA SYAAAA OOOOxx 6578 643 0 2 8 18 78 578 578 1578 6578 156 157 ATAAAA TYAAAA VVVVxx 9393 644 1 1 3 13 93 393 1393 4393 9393 186 187 HXAAAA UYAAAA AAAAxx 1276 645 0 0 6 16 76 276 1276 1276 1276 152 153 CXAAAA VYAAAA HHHHxx 8766 646 0 2 6 6 66 766 766 3766 8766 132 133 EZAAAA WYAAAA OOOOxx 1015 647 1 3 5 15 15 15 1015 1015 1015 30 31 BNAAAA XYAAAA VVVVxx 4396 648 0 0 6 16 96 396 396 4396 4396 192 193 CNAAAA YYAAAA AAAAxx 5564 649 0 0 4 4 64 564 1564 564 5564 128 129 AGAAAA ZYAAAA HHHHxx 927 650 1 3 7 7 27 927 927 927 927 54 55 RJAAAA AZAAAA OOOOxx 3306 651 0 2 6 6 6 306 1306 3306 3306 12 13 EXAAAA BZAAAA VVVVxx 1615 652 1 3 5 15 15 615 1615 1615 1615 30 31 DKAAAA CZAAAA AAAAxx 4550 653 0 2 0 10 50 550 550 4550 4550 100 101 ATAAAA DZAAAA HHHHxx 2468 654 0 0 8 8 68 468 468 2468 2468 136 137 YQAAAA EZAAAA OOOOxx 5336 655 0 0 6 16 36 336 1336 336 5336 72 73 GXAAAA FZAAAA VVVVxx 4471 656 1 3 1 11 71 471 471 4471 4471 142 143 ZPAAAA GZAAAA AAAAxx 8085 657 1 1 5 5 85 85 85 3085 8085 170 171 ZYAAAA HZAAAA HHHHxx 540 658 0 0 0 0 40 540 540 540 540 80 81 UUAAAA IZAAAA OOOOxx 5108 659 0 0 8 8 8 108 1108 108 5108 16 17 MOAAAA JZAAAA VVVVxx 8015 660 1 3 5 15 15 15 15 3015 8015 30 31 HWAAAA KZAAAA AAAAxx 2857 661 1 1 7 17 57 857 857 2857 2857 114 115 XFAAAA LZAAAA HHHHxx 9472 662 0 0 2 12 72 472 1472 4472 9472 144 145 IAAAAA MZAAAA OOOOxx 5666 663 0 2 6 6 66 666 1666 666 5666 132 133 YJAAAA NZAAAA VVVVxx 3555 664 1 3 5 15 55 555 1555 3555 3555 110 111 TGAAAA OZAAAA AAAAxx 378 665 0 2 8 18 78 378 378 378 378 156 157 OOAAAA PZAAAA HHHHxx 4466 666 0 2 6 6 66 466 466 4466 4466 132 133 UPAAAA QZAAAA OOOOxx 3247 667 1 3 7 7 47 247 1247 3247 3247 94 95 XUAAAA RZAAAA VVVVxx 6570 668 0 2 0 10 70 570 570 1570 6570 140 141 SSAAAA SZAAAA AAAAxx 5655 669 1 3 5 15 55 655 1655 655 5655 110 111 NJAAAA TZAAAA HHHHxx 917 670 1 1 7 17 17 917 917 917 917 34 35 HJAAAA UZAAAA OOOOxx 3637 671 1 1 7 17 37 637 1637 3637 3637 74 75 XJAAAA VZAAAA VVVVxx 3668 672 0 0 8 8 68 668 1668 3668 3668 136 137 CLAAAA WZAAAA AAAAxx 5644 673 0 0 4 4 44 644 1644 644 5644 88 89 CJAAAA XZAAAA HHHHxx 8286 674 0 2 6 6 86 286 286 3286 8286 172 173 SGAAAA YZAAAA OOOOxx 6896 675 0 0 6 16 96 896 896 1896 6896 192 193 GFAAAA ZZAAAA VVVVxx 2870 676 0 2 0 10 70 870 870 2870 2870 140 141 KGAAAA AABAAA AAAAxx 8041 677 1 1 1 1 41 41 41 3041 8041 82 83 HXAAAA BABAAA HHHHxx 8137 678 1 1 7 17 37 137 137 3137 8137 74 75 ZAAAAA CABAAA OOOOxx 4823 679 1 3 3 3 23 823 823 4823 4823 46 47 NDAAAA DABAAA VVVVxx 2438 680 0 2 8 18 38 438 438 2438 2438 76 77 UPAAAA EABAAA AAAAxx 6329 681 1 1 9 9 29 329 329 1329 6329 58 59 LJAAAA FABAAA HHHHxx 623 682 1 3 3 3 23 623 623 623 623 46 47 ZXAAAA GABAAA OOOOxx 1360 683 0 0 0 0 60 360 1360 1360 1360 120 121 IAAAAA HABAAA VVVVxx 7987 684 1 3 7 7 87 987 1987 2987 7987 174 175 FVAAAA IABAAA AAAAxx 9788 685 0 0 8 8 88 788 1788 4788 9788 176 177 MMAAAA JABAAA HHHHxx 3212 686 0 0 2 12 12 212 1212 3212 3212 24 25 OTAAAA KABAAA OOOOxx 2725 687 1 1 5 5 25 725 725 2725 2725 50 51 VAAAAA LABAAA VVVVxx 7837 688 1 1 7 17 37 837 1837 2837 7837 74 75 LPAAAA MABAAA AAAAxx 4746 689 0 2 6 6 46 746 746 4746 4746 92 93 OAAAAA NABAAA HHHHxx 3986 690 0 2 6 6 86 986 1986 3986 3986 172 173 IXAAAA OABAAA OOOOxx 9128 691 0 0 8 8 28 128 1128 4128 9128 56 57 CNAAAA PABAAA VVVVxx 5044 692 0 0 4 4 44 44 1044 44 5044 88 89 AMAAAA QABAAA AAAAxx 8132 693 0 0 2 12 32 132 132 3132 8132 64 65 UAAAAA RABAAA HHHHxx 9992 694 0 0 2 12 92 992 1992 4992 9992 184 185 IUAAAA SABAAA OOOOxx 8468 695 0 0 8 8 68 468 468 3468 8468 136 137 SNAAAA TABAAA VVVVxx 6876 696 0 0 6 16 76 876 876 1876 6876 152 153 MEAAAA UABAAA AAAAxx 3532 697 0 0 2 12 32 532 1532 3532 3532 64 65 WFAAAA VABAAA HHHHxx 2140 698 0 0 0 0 40 140 140 2140 2140 80 81 IEAAAA WABAAA OOOOxx 2183 699 1 3 3 3 83 183 183 2183 2183 166 167 ZFAAAA XABAAA VVVVxx 9766 700 0 2 6 6 66 766 1766 4766 9766 132 133 QLAAAA YABAAA AAAAxx 7943 701 1 3 3 3 43 943 1943 2943 7943 86 87 NTAAAA ZABAAA HHHHxx 9243 702 1 3 3 3 43 243 1243 4243 9243 86 87 NRAAAA ABBAAA OOOOxx 6241 703 1 1 1 1 41 241 241 1241 6241 82 83 BGAAAA BBBAAA VVVVxx 9540 704 0 0 0 0 40 540 1540 4540 9540 80 81 YCAAAA CBBAAA AAAAxx 7418 705 0 2 8 18 18 418 1418 2418 7418 36 37 IZAAAA DBBAAA HHHHxx 1603 706 1 3 3 3 3 603 1603 1603 1603 6 7 RJAAAA EBBAAA OOOOxx 8950 707 0 2 0 10 50 950 950 3950 8950 100 101 GGAAAA FBBAAA VVVVxx 6933 708 1 1 3 13 33 933 933 1933 6933 66 67 RGAAAA GBBAAA AAAAxx 2646 709 0 2 6 6 46 646 646 2646 2646 92 93 UXAAAA HBBAAA HHHHxx 3447 710 1 3 7 7 47 447 1447 3447 3447 94 95 PCAAAA IBBAAA OOOOxx 9957 711 1 1 7 17 57 957 1957 4957 9957 114 115 ZSAAAA JBBAAA VVVVxx 4623 712 1 3 3 3 23 623 623 4623 4623 46 47 VVAAAA KBBAAA AAAAxx 9058 713 0 2 8 18 58 58 1058 4058 9058 116 117 KKAAAA LBBAAA HHHHxx 7361 714 1 1 1 1 61 361 1361 2361 7361 122 123 DXAAAA MBBAAA OOOOxx 2489 715 1 1 9 9 89 489 489 2489 2489 178 179 TRAAAA NBBAAA VVVVxx 7643 716 1 3 3 3 43 643 1643 2643 7643 86 87 ZHAAAA OBBAAA AAAAxx 9166 717 0 2 6 6 66 166 1166 4166 9166 132 133 OOAAAA PBBAAA HHHHxx 7789 718 1 1 9 9 89 789 1789 2789 7789 178 179 PNAAAA QBBAAA OOOOxx 2332 719 0 0 2 12 32 332 332 2332 2332 64 65 SLAAAA RBBAAA VVVVxx 1832 720 0 0 2 12 32 832 1832 1832 1832 64 65 MSAAAA SBBAAA AAAAxx 8375 721 1 3 5 15 75 375 375 3375 8375 150 151 DKAAAA TBBAAA HHHHxx 948 722 0 0 8 8 48 948 948 948 948 96 97 MKAAAA UBBAAA OOOOxx 5613 723 1 1 3 13 13 613 1613 613 5613 26 27 XHAAAA VBBAAA VVVVxx 6310 724 0 2 0 10 10 310 310 1310 6310 20 21 SIAAAA WBBAAA AAAAxx 4254 725 0 2 4 14 54 254 254 4254 4254 108 109 QHAAAA XBBAAA HHHHxx 4260 726 0 0 0 0 60 260 260 4260 4260 120 121 WHAAAA YBBAAA OOOOxx 2060 727 0 0 0 0 60 60 60 2060 2060 120 121 GBAAAA ZBBAAA VVVVxx 4831 728 1 3 1 11 31 831 831 4831 4831 62 63 VDAAAA ACBAAA AAAAxx 6176 729 0 0 6 16 76 176 176 1176 6176 152 153 ODAAAA BCBAAA HHHHxx 6688 730 0 0 8 8 88 688 688 1688 6688 176 177 GXAAAA CCBAAA OOOOxx 5752 731 0 0 2 12 52 752 1752 752 5752 104 105 GNAAAA DCBAAA VVVVxx 8714 732 0 2 4 14 14 714 714 3714 8714 28 29 EXAAAA ECBAAA AAAAxx 6739 733 1 3 9 19 39 739 739 1739 6739 78 79 FZAAAA FCBAAA HHHHxx 7066 734 0 2 6 6 66 66 1066 2066 7066 132 133 ULAAAA GCBAAA OOOOxx 7250 735 0 2 0 10 50 250 1250 2250 7250 100 101 WSAAAA HCBAAA VVVVxx 3161 736 1 1 1 1 61 161 1161 3161 3161 122 123 PRAAAA ICBAAA AAAAxx 1411 737 1 3 1 11 11 411 1411 1411 1411 22 23 HCAAAA JCBAAA HHHHxx 9301 738 1 1 1 1 1 301 1301 4301 9301 2 3 TTAAAA KCBAAA OOOOxx 8324 739 0 0 4 4 24 324 324 3324 8324 48 49 EIAAAA LCBAAA VVVVxx 9641 740 1 1 1 1 41 641 1641 4641 9641 82 83 VGAAAA MCBAAA AAAAxx 7077 741 1 1 7 17 77 77 1077 2077 7077 154 155 FMAAAA NCBAAA HHHHxx 9888 742 0 0 8 8 88 888 1888 4888 9888 176 177 IQAAAA OCBAAA OOOOxx 9909 743 1 1 9 9 9 909 1909 4909 9909 18 19 DRAAAA PCBAAA VVVVxx 2209 744 1 1 9 9 9 209 209 2209 2209 18 19 ZGAAAA QCBAAA AAAAxx 6904 745 0 0 4 4 4 904 904 1904 6904 8 9 OFAAAA RCBAAA HHHHxx 6608 746 0 0 8 8 8 608 608 1608 6608 16 17 EUAAAA SCBAAA OOOOxx 8400 747 0 0 0 0 0 400 400 3400 8400 0 1 CLAAAA TCBAAA VVVVxx 5124 748 0 0 4 4 24 124 1124 124 5124 48 49 CPAAAA UCBAAA AAAAxx 5484 749 0 0 4 4 84 484 1484 484 5484 168 169 YCAAAA VCBAAA HHHHxx 3575 750 1 3 5 15 75 575 1575 3575 3575 150 151 NHAAAA WCBAAA OOOOxx 9723 751 1 3 3 3 23 723 1723 4723 9723 46 47 ZJAAAA XCBAAA VVVVxx 360 752 0 0 0 0 60 360 360 360 360 120 121 WNAAAA YCBAAA AAAAxx 1059 753 1 3 9 19 59 59 1059 1059 1059 118 119 TOAAAA ZCBAAA HHHHxx 4941 754 1 1 1 1 41 941 941 4941 4941 82 83 BIAAAA ADBAAA OOOOxx 2535 755 1 3 5 15 35 535 535 2535 2535 70 71 NTAAAA BDBAAA VVVVxx 4119 756 1 3 9 19 19 119 119 4119 4119 38 39 LCAAAA CDBAAA AAAAxx 3725 757 1 1 5 5 25 725 1725 3725 3725 50 51 HNAAAA DDBAAA HHHHxx 4758 758 0 2 8 18 58 758 758 4758 4758 116 117 ABAAAA EDBAAA OOOOxx 9593 759 1 1 3 13 93 593 1593 4593 9593 186 187 ZEAAAA FDBAAA VVVVxx 4663 760 1 3 3 3 63 663 663 4663 4663 126 127 JXAAAA GDBAAA AAAAxx 7734 761 0 2 4 14 34 734 1734 2734 7734 68 69 MLAAAA HDBAAA HHHHxx 9156 762 0 0 6 16 56 156 1156 4156 9156 112 113 EOAAAA IDBAAA OOOOxx 8120 763 0 0 0 0 20 120 120 3120 8120 40 41 IAAAAA JDBAAA VVVVxx 4385 764 1 1 5 5 85 385 385 4385 4385 170 171 RMAAAA KDBAAA AAAAxx 2926 765 0 2 6 6 26 926 926 2926 2926 52 53 OIAAAA LDBAAA HHHHxx 4186 766 0 2 6 6 86 186 186 4186 4186 172 173 AFAAAA MDBAAA OOOOxx 2508 767 0 0 8 8 8 508 508 2508 2508 16 17 MSAAAA NDBAAA VVVVxx 4012 768 0 0 2 12 12 12 12 4012 4012 24 25 IYAAAA ODBAAA AAAAxx 6266 769 0 2 6 6 66 266 266 1266 6266 132 133 AHAAAA PDBAAA HHHHxx 3709 770 1 1 9 9 9 709 1709 3709 3709 18 19 RMAAAA QDBAAA OOOOxx 7289 771 1 1 9 9 89 289 1289 2289 7289 178 179 JUAAAA RDBAAA VVVVxx 8875 772 1 3 5 15 75 875 875 3875 8875 150 151 JDAAAA SDBAAA AAAAxx 4412 773 0 0 2 12 12 412 412 4412 4412 24 25 SNAAAA TDBAAA HHHHxx 3033 774 1 1 3 13 33 33 1033 3033 3033 66 67 RMAAAA UDBAAA OOOOxx 1645 775 1 1 5 5 45 645 1645 1645 1645 90 91 HLAAAA VDBAAA VVVVxx 3557 776 1 1 7 17 57 557 1557 3557 3557 114 115 VGAAAA WDBAAA AAAAxx 6316 777 0 0 6 16 16 316 316 1316 6316 32 33 YIAAAA XDBAAA HHHHxx 2054 778 0 2 4 14 54 54 54 2054 2054 108 109 ABAAAA YDBAAA OOOOxx 7031 779 1 3 1 11 31 31 1031 2031 7031 62 63 LKAAAA ZDBAAA VVVVxx 3405 780 1 1 5 5 5 405 1405 3405 3405 10 11 ZAAAAA AEBAAA AAAAxx 5343 781 1 3 3 3 43 343 1343 343 5343 86 87 NXAAAA BEBAAA HHHHxx 5240 782 0 0 0 0 40 240 1240 240 5240 80 81 OTAAAA CEBAAA OOOOxx 9650 783 0 2 0 10 50 650 1650 4650 9650 100 101 EHAAAA DEBAAA VVVVxx 3777 784 1 1 7 17 77 777 1777 3777 3777 154 155 HPAAAA EEBAAA AAAAxx 9041 785 1 1 1 1 41 41 1041 4041 9041 82 83 TJAAAA FEBAAA HHHHxx 6923 786 1 3 3 3 23 923 923 1923 6923 46 47 HGAAAA GEBAAA OOOOxx 2977 787 1 1 7 17 77 977 977 2977 2977 154 155 NKAAAA HEBAAA VVVVxx 5500 788 0 0 0 0 0 500 1500 500 5500 0 1 ODAAAA IEBAAA AAAAxx 1044 789 0 0 4 4 44 44 1044 1044 1044 88 89 EOAAAA JEBAAA HHHHxx 434 790 0 2 4 14 34 434 434 434 434 68 69 SQAAAA KEBAAA OOOOxx 611 791 1 3 1 11 11 611 611 611 611 22 23 NXAAAA LEBAAA VVVVxx 5760 792 0 0 0 0 60 760 1760 760 5760 120 121 ONAAAA MEBAAA AAAAxx 2445 793 1 1 5 5 45 445 445 2445 2445 90 91 BQAAAA NEBAAA HHHHxx 7098 794 0 2 8 18 98 98 1098 2098 7098 196 197 ANAAAA OEBAAA OOOOxx 2188 795 0 0 8 8 88 188 188 2188 2188 176 177 EGAAAA PEBAAA VVVVxx 4597 796 1 1 7 17 97 597 597 4597 4597 194 195 VUAAAA QEBAAA AAAAxx 1913 797 1 1 3 13 13 913 1913 1913 1913 26 27 PVAAAA REBAAA HHHHxx 8696 798 0 0 6 16 96 696 696 3696 8696 192 193 MWAAAA SEBAAA OOOOxx 3332 799 0 0 2 12 32 332 1332 3332 3332 64 65 EYAAAA TEBAAA VVVVxx 8760 800 0 0 0 0 60 760 760 3760 8760 120 121 YYAAAA UEBAAA AAAAxx 3215 801 1 3 5 15 15 215 1215 3215 3215 30 31 RTAAAA VEBAAA HHHHxx 1625 802 1 1 5 5 25 625 1625 1625 1625 50 51 NKAAAA WEBAAA OOOOxx 4219 803 1 3 9 19 19 219 219 4219 4219 38 39 HGAAAA XEBAAA VVVVxx 415 804 1 3 5 15 15 415 415 415 415 30 31 ZPAAAA YEBAAA AAAAxx 4242 805 0 2 2 2 42 242 242 4242 4242 84 85 EHAAAA ZEBAAA HHHHxx 8660 806 0 0 0 0 60 660 660 3660 8660 120 121 CVAAAA AFBAAA OOOOxx 6525 807 1 1 5 5 25 525 525 1525 6525 50 51 ZQAAAA BFBAAA VVVVxx 2141 808 1 1 1 1 41 141 141 2141 2141 82 83 JEAAAA CFBAAA AAAAxx 5152 809 0 0 2 12 52 152 1152 152 5152 104 105 EQAAAA DFBAAA HHHHxx 8560 810 0 0 0 0 60 560 560 3560 8560 120 121 GRAAAA EFBAAA OOOOxx 9835 811 1 3 5 15 35 835 1835 4835 9835 70 71 HOAAAA FFBAAA VVVVxx 2657 812 1 1 7 17 57 657 657 2657 2657 114 115 FYAAAA GFBAAA AAAAxx 6085 813 1 1 5 5 85 85 85 1085 6085 170 171 BAAAAA HFBAAA HHHHxx 6698 814 0 2 8 18 98 698 698 1698 6698 196 197 QXAAAA IFBAAA OOOOxx 5421 815 1 1 1 1 21 421 1421 421 5421 42 43 NAAAAA JFBAAA VVVVxx 6661 816 1 1 1 1 61 661 661 1661 6661 122 123 FWAAAA KFBAAA AAAAxx 5645 817 1 1 5 5 45 645 1645 645 5645 90 91 DJAAAA LFBAAA HHHHxx 1248 818 0 0 8 8 48 248 1248 1248 1248 96 97 AWAAAA MFBAAA OOOOxx 5690 819 0 2 0 10 90 690 1690 690 5690 180 181 WKAAAA NFBAAA VVVVxx 4762 820 0 2 2 2 62 762 762 4762 4762 124 125 EBAAAA OFBAAA AAAAxx 1455 821 1 3 5 15 55 455 1455 1455 1455 110 111 ZDAAAA PFBAAA HHHHxx 9846 822 0 2 6 6 46 846 1846 4846 9846 92 93 SOAAAA QFBAAA OOOOxx 5295 823 1 3 5 15 95 295 1295 295 5295 190 191 RVAAAA RFBAAA VVVVxx 2826 824 0 2 6 6 26 826 826 2826 2826 52 53 SEAAAA SFBAAA AAAAxx 7496 825 0 0 6 16 96 496 1496 2496 7496 192 193 ICAAAA TFBAAA HHHHxx 3024 826 0 0 4 4 24 24 1024 3024 3024 48 49 IMAAAA UFBAAA OOOOxx 4945 827 1 1 5 5 45 945 945 4945 4945 90 91 FIAAAA VFBAAA VVVVxx 4404 828 0 0 4 4 4 404 404 4404 4404 8 9 KNAAAA WFBAAA AAAAxx 9302 829 0 2 2 2 2 302 1302 4302 9302 4 5 UTAAAA XFBAAA HHHHxx 1286 830 0 2 6 6 86 286 1286 1286 1286 172 173 MXAAAA YFBAAA OOOOxx 8435 831 1 3 5 15 35 435 435 3435 8435 70 71 LMAAAA ZFBAAA VVVVxx 8969 832 1 1 9 9 69 969 969 3969 8969 138 139 ZGAAAA AGBAAA AAAAxx 3302 833 0 2 2 2 2 302 1302 3302 3302 4 5 AXAAAA BGBAAA HHHHxx 9753 834 1 1 3 13 53 753 1753 4753 9753 106 107 DLAAAA CGBAAA OOOOxx 9374 835 0 2 4 14 74 374 1374 4374 9374 148 149 OWAAAA DGBAAA VVVVxx 4907 836 1 3 7 7 7 907 907 4907 4907 14 15 TGAAAA EGBAAA AAAAxx 1659 837 1 3 9 19 59 659 1659 1659 1659 118 119 VLAAAA FGBAAA HHHHxx 5095 838 1 3 5 15 95 95 1095 95 5095 190 191 ZNAAAA GGBAAA OOOOxx 9446 839 0 2 6 6 46 446 1446 4446 9446 92 93 IZAAAA HGBAAA VVVVxx 8528 840 0 0 8 8 28 528 528 3528 8528 56 57 AQAAAA IGBAAA AAAAxx 4890 841 0 2 0 10 90 890 890 4890 4890 180 181 CGAAAA JGBAAA HHHHxx 1221 842 1 1 1 1 21 221 1221 1221 1221 42 43 ZUAAAA KGBAAA OOOOxx 5583 843 1 3 3 3 83 583 1583 583 5583 166 167 TGAAAA LGBAAA VVVVxx 7303 844 1 3 3 3 3 303 1303 2303 7303 6 7 XUAAAA MGBAAA AAAAxx 406 845 0 2 6 6 6 406 406 406 406 12 13 QPAAAA NGBAAA HHHHxx 7542 846 0 2 2 2 42 542 1542 2542 7542 84 85 CEAAAA OGBAAA OOOOxx 9507 847 1 3 7 7 7 507 1507 4507 9507 14 15 RBAAAA PGBAAA VVVVxx 9511 848 1 3 1 11 11 511 1511 4511 9511 22 23 VBAAAA QGBAAA AAAAxx 1373 849 1 1 3 13 73 373 1373 1373 1373 146 147 VAAAAA RGBAAA HHHHxx 6556 850 0 0 6 16 56 556 556 1556 6556 112 113 ESAAAA SGBAAA OOOOxx 4117 851 1 1 7 17 17 117 117 4117 4117 34 35 JCAAAA TGBAAA VVVVxx 7794 852 0 2 4 14 94 794 1794 2794 7794 188 189 UNAAAA UGBAAA AAAAxx 7170 853 0 2 0 10 70 170 1170 2170 7170 140 141 UPAAAA VGBAAA HHHHxx 5809 854 1 1 9 9 9 809 1809 809 5809 18 19 LPAAAA WGBAAA OOOOxx 7828 855 0 0 8 8 28 828 1828 2828 7828 56 57 CPAAAA XGBAAA VVVVxx 8046 856 0 2 6 6 46 46 46 3046 8046 92 93 MXAAAA YGBAAA AAAAxx 4833 857 1 1 3 13 33 833 833 4833 4833 66 67 XDAAAA ZGBAAA HHHHxx 2107 858 1 3 7 7 7 107 107 2107 2107 14 15 BDAAAA AHBAAA OOOOxx 4276 859 0 0 6 16 76 276 276 4276 4276 152 153 MIAAAA BHBAAA VVVVxx 9536 860 0 0 6 16 36 536 1536 4536 9536 72 73 UCAAAA CHBAAA AAAAxx 5549 861 1 1 9 9 49 549 1549 549 5549 98 99 LFAAAA DHBAAA HHHHxx 6427 862 1 3 7 7 27 427 427 1427 6427 54 55 FNAAAA EHBAAA OOOOxx 1382 863 0 2 2 2 82 382 1382 1382 1382 164 165 EBAAAA FHBAAA VVVVxx 3256 864 0 0 6 16 56 256 1256 3256 3256 112 113 GVAAAA GHBAAA AAAAxx 3270 865 0 2 0 10 70 270 1270 3270 3270 140 141 UVAAAA HHBAAA HHHHxx 4808 866 0 0 8 8 8 808 808 4808 4808 16 17 YCAAAA IHBAAA OOOOxx 7938 867 0 2 8 18 38 938 1938 2938 7938 76 77 ITAAAA JHBAAA VVVVxx 4405 868 1 1 5 5 5 405 405 4405 4405 10 11 LNAAAA KHBAAA AAAAxx 2264 869 0 0 4 4 64 264 264 2264 2264 128 129 CJAAAA LHBAAA HHHHxx 80 870 0 0 0 0 80 80 80 80 80 160 161 CDAAAA MHBAAA OOOOxx 320 871 0 0 0 0 20 320 320 320 320 40 41 IMAAAA NHBAAA VVVVxx 2383 872 1 3 3 3 83 383 383 2383 2383 166 167 RNAAAA OHBAAA AAAAxx 3146 873 0 2 6 6 46 146 1146 3146 3146 92 93 ARAAAA PHBAAA HHHHxx 6911 874 1 3 1 11 11 911 911 1911 6911 22 23 VFAAAA QHBAAA OOOOxx 7377 875 1 1 7 17 77 377 1377 2377 7377 154 155 TXAAAA RHBAAA VVVVxx 9965 876 1 1 5 5 65 965 1965 4965 9965 130 131 HTAAAA SHBAAA AAAAxx 8361 877 1 1 1 1 61 361 361 3361 8361 122 123 PJAAAA THBAAA HHHHxx 9417 878 1 1 7 17 17 417 1417 4417 9417 34 35 FYAAAA UHBAAA OOOOxx 2483 879 1 3 3 3 83 483 483 2483 2483 166 167 NRAAAA VHBAAA VVVVxx 9843 880 1 3 3 3 43 843 1843 4843 9843 86 87 POAAAA WHBAAA AAAAxx 6395 881 1 3 5 15 95 395 395 1395 6395 190 191 ZLAAAA XHBAAA HHHHxx 6444 882 0 0 4 4 44 444 444 1444 6444 88 89 WNAAAA YHBAAA OOOOxx 1820 883 0 0 0 0 20 820 1820 1820 1820 40 41 ASAAAA ZHBAAA VVVVxx 2768 884 0 0 8 8 68 768 768 2768 2768 136 137 MCAAAA AIBAAA AAAAxx 5413 885 1 1 3 13 13 413 1413 413 5413 26 27 FAAAAA BIBAAA HHHHxx 2923 886 1 3 3 3 23 923 923 2923 2923 46 47 LIAAAA CIBAAA OOOOxx 5286 887 0 2 6 6 86 286 1286 286 5286 172 173 IVAAAA DIBAAA VVVVxx 6126 888 0 2 6 6 26 126 126 1126 6126 52 53 QBAAAA EIBAAA AAAAxx 8343 889 1 3 3 3 43 343 343 3343 8343 86 87 XIAAAA FIBAAA HHHHxx 6010 890 0 2 0 10 10 10 10 1010 6010 20 21 EXAAAA GIBAAA OOOOxx 4177 891 1 1 7 17 77 177 177 4177 4177 154 155 REAAAA HIBAAA VVVVxx 5808 892 0 0 8 8 8 808 1808 808 5808 16 17 KPAAAA IIBAAA AAAAxx 4859 893 1 3 9 19 59 859 859 4859 4859 118 119 XEAAAA JIBAAA HHHHxx 9252 894 0 0 2 12 52 252 1252 4252 9252 104 105 WRAAAA KIBAAA OOOOxx 2941 895 1 1 1 1 41 941 941 2941 2941 82 83 DJAAAA LIBAAA VVVVxx 8693 896 1 1 3 13 93 693 693 3693 8693 186 187 JWAAAA MIBAAA AAAAxx 4432 897 0 0 2 12 32 432 432 4432 4432 64 65 MOAAAA NIBAAA HHHHxx 2371 898 1 3 1 11 71 371 371 2371 2371 142 143 FNAAAA OIBAAA OOOOxx 7546 899 0 2 6 6 46 546 1546 2546 7546 92 93 GEAAAA PIBAAA VVVVxx 1369 900 1 1 9 9 69 369 1369 1369 1369 138 139 RAAAAA QIBAAA AAAAxx 4687 901 1 3 7 7 87 687 687 4687 4687 174 175 HYAAAA RIBAAA HHHHxx 8941 902 1 1 1 1 41 941 941 3941 8941 82 83 XFAAAA SIBAAA OOOOxx 226 903 0 2 6 6 26 226 226 226 226 52 53 SIAAAA TIBAAA VVVVxx 3493 904 1 1 3 13 93 493 1493 3493 3493 186 187 JEAAAA UIBAAA AAAAxx 6433 905 1 1 3 13 33 433 433 1433 6433 66 67 LNAAAA VIBAAA HHHHxx 9189 906 1 1 9 9 89 189 1189 4189 9189 178 179 LPAAAA WIBAAA OOOOxx 6027 907 1 3 7 7 27 27 27 1027 6027 54 55 VXAAAA XIBAAA VVVVxx 4615 908 1 3 5 15 15 615 615 4615 4615 30 31 NVAAAA YIBAAA AAAAxx 5320 909 0 0 0 0 20 320 1320 320 5320 40 41 QWAAAA ZIBAAA HHHHxx 7002 910 0 2 2 2 2 2 1002 2002 7002 4 5 IJAAAA AJBAAA OOOOxx 7367 911 1 3 7 7 67 367 1367 2367 7367 134 135 JXAAAA BJBAAA VVVVxx 289 912 1 1 9 9 89 289 289 289 289 178 179 DLAAAA CJBAAA AAAAxx 407 913 1 3 7 7 7 407 407 407 407 14 15 RPAAAA DJBAAA HHHHxx 504 914 0 0 4 4 4 504 504 504 504 8 9 KTAAAA EJBAAA OOOOxx 8301 915 1 1 1 1 1 301 301 3301 8301 2 3 HHAAAA FJBAAA VVVVxx 1396 916 0 0 6 16 96 396 1396 1396 1396 192 193 SBAAAA GJBAAA AAAAxx 4794 917 0 2 4 14 94 794 794 4794 4794 188 189 KCAAAA HJBAAA HHHHxx 6400 918 0 0 0 0 0 400 400 1400 6400 0 1 EMAAAA IJBAAA OOOOxx 1275 919 1 3 5 15 75 275 1275 1275 1275 150 151 BXAAAA JJBAAA VVVVxx 5797 920 1 1 7 17 97 797 1797 797 5797 194 195 ZOAAAA KJBAAA AAAAxx 2221 921 1 1 1 1 21 221 221 2221 2221 42 43 LHAAAA LJBAAA HHHHxx 2504 922 0 0 4 4 4 504 504 2504 2504 8 9 ISAAAA MJBAAA OOOOxx 2143 923 1 3 3 3 43 143 143 2143 2143 86 87 LEAAAA NJBAAA VVVVxx 1083 924 1 3 3 3 83 83 1083 1083 1083 166 167 RPAAAA OJBAAA AAAAxx 6148 925 0 0 8 8 48 148 148 1148 6148 96 97 MCAAAA PJBAAA HHHHxx 3612 926 0 0 2 12 12 612 1612 3612 3612 24 25 YIAAAA QJBAAA OOOOxx 9499 927 1 3 9 19 99 499 1499 4499 9499 198 199 JBAAAA RJBAAA VVVVxx 5773 928 1 1 3 13 73 773 1773 773 5773 146 147 BOAAAA SJBAAA AAAAxx 1014 929 0 2 4 14 14 14 1014 1014 1014 28 29 ANAAAA TJBAAA HHHHxx 1427 930 1 3 7 7 27 427 1427 1427 1427 54 55 XCAAAA UJBAAA OOOOxx 6770 931 0 2 0 10 70 770 770 1770 6770 140 141 KAAAAA VJBAAA VVVVxx 9042 932 0 2 2 2 42 42 1042 4042 9042 84 85 UJAAAA WJBAAA AAAAxx 9892 933 0 0 2 12 92 892 1892 4892 9892 184 185 MQAAAA XJBAAA HHHHxx 1771 934 1 3 1 11 71 771 1771 1771 1771 142 143 DQAAAA YJBAAA OOOOxx 7392 935 0 0 2 12 92 392 1392 2392 7392 184 185 IYAAAA ZJBAAA VVVVxx 4465 936 1 1 5 5 65 465 465 4465 4465 130 131 TPAAAA AKBAAA AAAAxx 278 937 0 2 8 18 78 278 278 278 278 156 157 SKAAAA BKBAAA HHHHxx 7776 938 0 0 6 16 76 776 1776 2776 7776 152 153 CNAAAA CKBAAA OOOOxx 3763 939 1 3 3 3 63 763 1763 3763 3763 126 127 TOAAAA DKBAAA VVVVxx 7503 940 1 3 3 3 3 503 1503 2503 7503 6 7 PCAAAA EKBAAA AAAAxx 3793 941 1 1 3 13 93 793 1793 3793 3793 186 187 XPAAAA FKBAAA HHHHxx 6510 942 0 2 0 10 10 510 510 1510 6510 20 21 KQAAAA GKBAAA OOOOxx 7641 943 1 1 1 1 41 641 1641 2641 7641 82 83 XHAAAA HKBAAA VVVVxx 3228 944 0 0 8 8 28 228 1228 3228 3228 56 57 EUAAAA IKBAAA AAAAxx 194 945 0 2 4 14 94 194 194 194 194 188 189 MHAAAA JKBAAA HHHHxx 8555 946 1 3 5 15 55 555 555 3555 8555 110 111 BRAAAA KKBAAA OOOOxx 4997 947 1 1 7 17 97 997 997 4997 4997 194 195 FKAAAA LKBAAA VVVVxx 8687 948 1 3 7 7 87 687 687 3687 8687 174 175 DWAAAA MKBAAA AAAAxx 6632 949 0 0 2 12 32 632 632 1632 6632 64 65 CVAAAA NKBAAA HHHHxx 9607 950 1 3 7 7 7 607 1607 4607 9607 14 15 NFAAAA OKBAAA OOOOxx 6201 951 1 1 1 1 1 201 201 1201 6201 2 3 NEAAAA PKBAAA VVVVxx 857 952 1 1 7 17 57 857 857 857 857 114 115 ZGAAAA QKBAAA AAAAxx 5623 953 1 3 3 3 23 623 1623 623 5623 46 47 HIAAAA RKBAAA HHHHxx 5979 954 1 3 9 19 79 979 1979 979 5979 158 159 ZVAAAA SKBAAA OOOOxx 2201 955 1 1 1 1 1 201 201 2201 2201 2 3 RGAAAA TKBAAA VVVVxx 3166 956 0 2 6 6 66 166 1166 3166 3166 132 133 URAAAA UKBAAA AAAAxx 6249 957 1 1 9 9 49 249 249 1249 6249 98 99 JGAAAA VKBAAA HHHHxx 3271 958 1 3 1 11 71 271 1271 3271 3271 142 143 VVAAAA WKBAAA OOOOxx 7777 959 1 1 7 17 77 777 1777 2777 7777 154 155 DNAAAA XKBAAA VVVVxx 6732 960 0 0 2 12 32 732 732 1732 6732 64 65 YYAAAA YKBAAA AAAAxx 6297 961 1 1 7 17 97 297 297 1297 6297 194 195 FIAAAA ZKBAAA HHHHxx 5685 962 1 1 5 5 85 685 1685 685 5685 170 171 RKAAAA ALBAAA OOOOxx 9931 963 1 3 1 11 31 931 1931 4931 9931 62 63 ZRAAAA BLBAAA VVVVxx 7485 964 1 1 5 5 85 485 1485 2485 7485 170 171 XBAAAA CLBAAA AAAAxx 386 965 0 2 6 6 86 386 386 386 386 172 173 WOAAAA DLBAAA HHHHxx 8204 966 0 0 4 4 4 204 204 3204 8204 8 9 ODAAAA ELBAAA OOOOxx 3606 967 0 2 6 6 6 606 1606 3606 3606 12 13 SIAAAA FLBAAA VVVVxx 1692 968 0 0 2 12 92 692 1692 1692 1692 184 185 CNAAAA GLBAAA AAAAxx 3002 969 0 2 2 2 2 2 1002 3002 3002 4 5 MLAAAA HLBAAA HHHHxx 9676 970 0 0 6 16 76 676 1676 4676 9676 152 153 EIAAAA ILBAAA OOOOxx 915 971 1 3 5 15 15 915 915 915 915 30 31 FJAAAA JLBAAA VVVVxx 7706 972 0 2 6 6 6 706 1706 2706 7706 12 13 KKAAAA KLBAAA AAAAxx 6080 973 0 0 0 0 80 80 80 1080 6080 160 161 WZAAAA LLBAAA HHHHxx 1860 974 0 0 0 0 60 860 1860 1860 1860 120 121 OTAAAA MLBAAA OOOOxx 1444 975 0 0 4 4 44 444 1444 1444 1444 88 89 ODAAAA NLBAAA VVVVxx 7208 976 0 0 8 8 8 208 1208 2208 7208 16 17 GRAAAA OLBAAA AAAAxx 8554 977 0 2 4 14 54 554 554 3554 8554 108 109 ARAAAA PLBAAA HHHHxx 2028 978 0 0 8 8 28 28 28 2028 2028 56 57 AAAAAA QLBAAA OOOOxx 9893 979 1 1 3 13 93 893 1893 4893 9893 186 187 NQAAAA RLBAAA VVVVxx 4740 980 0 0 0 0 40 740 740 4740 4740 80 81 IAAAAA SLBAAA AAAAxx 6186 981 0 2 6 6 86 186 186 1186 6186 172 173 YDAAAA TLBAAA HHHHxx 6357 982 1 1 7 17 57 357 357 1357 6357 114 115 NKAAAA ULBAAA OOOOxx 3699 983 1 3 9 19 99 699 1699 3699 3699 198 199 HMAAAA VLBAAA VVVVxx 7620 984 0 0 0 0 20 620 1620 2620 7620 40 41 CHAAAA WLBAAA AAAAxx 921 985 1 1 1 1 21 921 921 921 921 42 43 LJAAAA XLBAAA HHHHxx 5506 986 0 2 6 6 6 506 1506 506 5506 12 13 UDAAAA YLBAAA OOOOxx 8851 987 1 3 1 11 51 851 851 3851 8851 102 103 LCAAAA ZLBAAA VVVVxx 3205 988 1 1 5 5 5 205 1205 3205 3205 10 11 HTAAAA AMBAAA AAAAxx 1956 989 0 0 6 16 56 956 1956 1956 1956 112 113 GXAAAA BMBAAA HHHHxx 6272 990 0 0 2 12 72 272 272 1272 6272 144 145 GHAAAA CMBAAA OOOOxx 1509 991 1 1 9 9 9 509 1509 1509 1509 18 19 BGAAAA DMBAAA VVVVxx 53 992 1 1 3 13 53 53 53 53 53 106 107 BCAAAA EMBAAA AAAAxx 213 993 1 1 3 13 13 213 213 213 213 26 27 FIAAAA FMBAAA HHHHxx 4924 994 0 0 4 4 24 924 924 4924 4924 48 49 KHAAAA GMBAAA OOOOxx 2097 995 1 1 7 17 97 97 97 2097 2097 194 195 RCAAAA HMBAAA VVVVxx 4607 996 1 3 7 7 7 607 607 4607 4607 14 15 FVAAAA IMBAAA AAAAxx 1582 997 0 2 2 2 82 582 1582 1582 1582 164 165 WIAAAA JMBAAA HHHHxx 6643 998 1 3 3 3 43 643 643 1643 6643 86 87 NVAAAA KMBAAA OOOOxx 2238 999 0 2 8 18 38 238 238 2238 2238 76 77 CIAAAA LMBAAA VVVVxx 2942 1000 0 2 2 2 42 942 942 2942 2942 84 85 EJAAAA MMBAAA AAAAxx 1655 1001 1 3 5 15 55 655 1655 1655 1655 110 111 RLAAAA NMBAAA HHHHxx 3226 1002 0 2 6 6 26 226 1226 3226 3226 52 53 CUAAAA OMBAAA OOOOxx 4263 1003 1 3 3 3 63 263 263 4263 4263 126 127 ZHAAAA PMBAAA VVVVxx 960 1004 0 0 0 0 60 960 960 960 960 120 121 YKAAAA QMBAAA AAAAxx 1213 1005 1 1 3 13 13 213 1213 1213 1213 26 27 RUAAAA RMBAAA HHHHxx 1845 1006 1 1 5 5 45 845 1845 1845 1845 90 91 ZSAAAA SMBAAA OOOOxx 6944 1007 0 0 4 4 44 944 944 1944 6944 88 89 CHAAAA TMBAAA VVVVxx 5284 1008 0 0 4 4 84 284 1284 284 5284 168 169 GVAAAA UMBAAA AAAAxx 188 1009 0 0 8 8 88 188 188 188 188 176 177 GHAAAA VMBAAA HHHHxx 748 1010 0 0 8 8 48 748 748 748 748 96 97 UCAAAA WMBAAA OOOOxx 2226 1011 0 2 6 6 26 226 226 2226 2226 52 53 QHAAAA XMBAAA VVVVxx 7342 1012 0 2 2 2 42 342 1342 2342 7342 84 85 KWAAAA YMBAAA AAAAxx 6120 1013 0 0 0 0 20 120 120 1120 6120 40 41 KBAAAA ZMBAAA HHHHxx 536 1014 0 0 6 16 36 536 536 536 536 72 73 QUAAAA ANBAAA OOOOxx 3239 1015 1 3 9 19 39 239 1239 3239 3239 78 79 PUAAAA BNBAAA VVVVxx 2832 1016 0 0 2 12 32 832 832 2832 2832 64 65 YEAAAA CNBAAA AAAAxx 5296 1017 0 0 6 16 96 296 1296 296 5296 192 193 SVAAAA DNBAAA HHHHxx 5795 1018 1 3 5 15 95 795 1795 795 5795 190 191 XOAAAA ENBAAA OOOOxx 6290 1019 0 2 0 10 90 290 290 1290 6290 180 181 YHAAAA FNBAAA VVVVxx 4916 1020 0 0 6 16 16 916 916 4916 4916 32 33 CHAAAA GNBAAA AAAAxx 8366 1021 0 2 6 6 66 366 366 3366 8366 132 133 UJAAAA HNBAAA HHHHxx 4248 1022 0 0 8 8 48 248 248 4248 4248 96 97 KHAAAA INBAAA OOOOxx 6460 1023 0 0 0 0 60 460 460 1460 6460 120 121 MOAAAA JNBAAA VVVVxx 9296 1024 0 0 6 16 96 296 1296 4296 9296 192 193 OTAAAA KNBAAA AAAAxx 3486 1025 0 2 6 6 86 486 1486 3486 3486 172 173 CEAAAA LNBAAA HHHHxx 5664 1026 0 0 4 4 64 664 1664 664 5664 128 129 WJAAAA MNBAAA OOOOxx 7624 1027 0 0 4 4 24 624 1624 2624 7624 48 49 GHAAAA NNBAAA VVVVxx 2790 1028 0 2 0 10 90 790 790 2790 2790 180 181 IDAAAA ONBAAA AAAAxx 682 1029 0 2 2 2 82 682 682 682 682 164 165 GAAAAA PNBAAA HHHHxx 6412 1030 0 0 2 12 12 412 412 1412 6412 24 25 QMAAAA QNBAAA OOOOxx 6882 1031 0 2 2 2 82 882 882 1882 6882 164 165 SEAAAA RNBAAA VVVVxx 1332 1032 0 0 2 12 32 332 1332 1332 1332 64 65 GZAAAA SNBAAA AAAAxx 4911 1033 1 3 1 11 11 911 911 4911 4911 22 23 XGAAAA TNBAAA HHHHxx 3528 1034 0 0 8 8 28 528 1528 3528 3528 56 57 SFAAAA UNBAAA OOOOxx 271 1035 1 3 1 11 71 271 271 271 271 142 143 LKAAAA VNBAAA VVVVxx 7007 1036 1 3 7 7 7 7 1007 2007 7007 14 15 NJAAAA WNBAAA AAAAxx 2198 1037 0 2 8 18 98 198 198 2198 2198 196 197 OGAAAA XNBAAA HHHHxx 4266 1038 0 2 6 6 66 266 266 4266 4266 132 133 CIAAAA YNBAAA OOOOxx 9867 1039 1 3 7 7 67 867 1867 4867 9867 134 135 NPAAAA ZNBAAA VVVVxx 7602 1040 0 2 2 2 2 602 1602 2602 7602 4 5 KGAAAA AOBAAA AAAAxx 7521 1041 1 1 1 1 21 521 1521 2521 7521 42 43 HDAAAA BOBAAA HHHHxx 7200 1042 0 0 0 0 0 200 1200 2200 7200 0 1 YQAAAA COBAAA OOOOxx 4816 1043 0 0 6 16 16 816 816 4816 4816 32 33 GDAAAA DOBAAA VVVVxx 1669 1044 1 1 9 9 69 669 1669 1669 1669 138 139 FMAAAA EOBAAA AAAAxx 4764 1045 0 0 4 4 64 764 764 4764 4764 128 129 GBAAAA FOBAAA HHHHxx 7393 1046 1 1 3 13 93 393 1393 2393 7393 186 187 JYAAAA GOBAAA OOOOxx 7434 1047 0 2 4 14 34 434 1434 2434 7434 68 69 YZAAAA HOBAAA VVVVxx 9079 1048 1 3 9 19 79 79 1079 4079 9079 158 159 FLAAAA IOBAAA AAAAxx 9668 1049 0 0 8 8 68 668 1668 4668 9668 136 137 WHAAAA JOBAAA HHHHxx 7184 1050 0 0 4 4 84 184 1184 2184 7184 168 169 IQAAAA KOBAAA OOOOxx 7347 1051 1 3 7 7 47 347 1347 2347 7347 94 95 PWAAAA LOBAAA VVVVxx 951 1052 1 3 1 11 51 951 951 951 951 102 103 PKAAAA MOBAAA AAAAxx 4513 1053 1 1 3 13 13 513 513 4513 4513 26 27 PRAAAA NOBAAA HHHHxx 2692 1054 0 0 2 12 92 692 692 2692 2692 184 185 OZAAAA OOBAAA OOOOxx 9930 1055 0 2 0 10 30 930 1930 4930 9930 60 61 YRAAAA POBAAA VVVVxx 4516 1056 0 0 6 16 16 516 516 4516 4516 32 33 SRAAAA QOBAAA AAAAxx 1592 1057 0 0 2 12 92 592 1592 1592 1592 184 185 GJAAAA ROBAAA HHHHxx 6312 1058 0 0 2 12 12 312 312 1312 6312 24 25 UIAAAA SOBAAA OOOOxx 185 1059 1 1 5 5 85 185 185 185 185 170 171 DHAAAA TOBAAA VVVVxx 1848 1060 0 0 8 8 48 848 1848 1848 1848 96 97 CTAAAA UOBAAA AAAAxx 5844 1061 0 0 4 4 44 844 1844 844 5844 88 89 UQAAAA VOBAAA HHHHxx 1666 1062 0 2 6 6 66 666 1666 1666 1666 132 133 CMAAAA WOBAAA OOOOxx 5864 1063 0 0 4 4 64 864 1864 864 5864 128 129 ORAAAA XOBAAA VVVVxx 1004 1064 0 0 4 4 4 4 1004 1004 1004 8 9 QMAAAA YOBAAA AAAAxx 1758 1065 0 2 8 18 58 758 1758 1758 1758 116 117 QPAAAA ZOBAAA HHHHxx 8823 1066 1 3 3 3 23 823 823 3823 8823 46 47 JBAAAA APBAAA OOOOxx 129 1067 1 1 9 9 29 129 129 129 129 58 59 ZEAAAA BPBAAA VVVVxx 5703 1068 1 3 3 3 3 703 1703 703 5703 6 7 JLAAAA CPBAAA AAAAxx 3331 1069 1 3 1 11 31 331 1331 3331 3331 62 63 DYAAAA DPBAAA HHHHxx 5791 1070 1 3 1 11 91 791 1791 791 5791 182 183 TOAAAA EPBAAA OOOOxx 4421 1071 1 1 1 1 21 421 421 4421 4421 42 43 BOAAAA FPBAAA VVVVxx 9740 1072 0 0 0 0 40 740 1740 4740 9740 80 81 QKAAAA GPBAAA AAAAxx 798 1073 0 2 8 18 98 798 798 798 798 196 197 SEAAAA HPBAAA HHHHxx 571 1074 1 3 1 11 71 571 571 571 571 142 143 ZVAAAA IPBAAA OOOOxx 7084 1075 0 0 4 4 84 84 1084 2084 7084 168 169 MMAAAA JPBAAA VVVVxx 650 1076 0 2 0 10 50 650 650 650 650 100 101 AZAAAA KPBAAA AAAAxx 1467 1077 1 3 7 7 67 467 1467 1467 1467 134 135 LEAAAA LPBAAA HHHHxx 5446 1078 0 2 6 6 46 446 1446 446 5446 92 93 MBAAAA MPBAAA OOOOxx 830 1079 0 2 0 10 30 830 830 830 830 60 61 YFAAAA NPBAAA VVVVxx 5516 1080 0 0 6 16 16 516 1516 516 5516 32 33 EEAAAA OPBAAA AAAAxx 8520 1081 0 0 0 0 20 520 520 3520 8520 40 41 SPAAAA PPBAAA HHHHxx 1152 1082 0 0 2 12 52 152 1152 1152 1152 104 105 ISAAAA QPBAAA OOOOxx 862 1083 0 2 2 2 62 862 862 862 862 124 125 EHAAAA RPBAAA VVVVxx 454 1084 0 2 4 14 54 454 454 454 454 108 109 MRAAAA SPBAAA AAAAxx 9956 1085 0 0 6 16 56 956 1956 4956 9956 112 113 YSAAAA TPBAAA HHHHxx 1654 1086 0 2 4 14 54 654 1654 1654 1654 108 109 QLAAAA UPBAAA OOOOxx 257 1087 1 1 7 17 57 257 257 257 257 114 115 XJAAAA VPBAAA VVVVxx 5469 1088 1 1 9 9 69 469 1469 469 5469 138 139 JCAAAA WPBAAA AAAAxx 9075 1089 1 3 5 15 75 75 1075 4075 9075 150 151 BLAAAA XPBAAA HHHHxx 7799 1090 1 3 9 19 99 799 1799 2799 7799 198 199 ZNAAAA YPBAAA OOOOxx 2001 1091 1 1 1 1 1 1 1 2001 2001 2 3 ZYAAAA ZPBAAA VVVVxx 9786 1092 0 2 6 6 86 786 1786 4786 9786 172 173 KMAAAA AQBAAA AAAAxx 7281 1093 1 1 1 1 81 281 1281 2281 7281 162 163 BUAAAA BQBAAA HHHHxx 5137 1094 1 1 7 17 37 137 1137 137 5137 74 75 PPAAAA CQBAAA OOOOxx 4053 1095 1 1 3 13 53 53 53 4053 4053 106 107 XZAAAA DQBAAA VVVVxx 7911 1096 1 3 1 11 11 911 1911 2911 7911 22 23 HSAAAA EQBAAA AAAAxx 4298 1097 0 2 8 18 98 298 298 4298 4298 196 197 IJAAAA FQBAAA HHHHxx 4805 1098 1 1 5 5 5 805 805 4805 4805 10 11 VCAAAA GQBAAA OOOOxx 9038 1099 0 2 8 18 38 38 1038 4038 9038 76 77 QJAAAA HQBAAA VVVVxx 8023 1100 1 3 3 3 23 23 23 3023 8023 46 47 PWAAAA IQBAAA AAAAxx 6595 1101 1 3 5 15 95 595 595 1595 6595 190 191 RTAAAA JQBAAA HHHHxx 9831 1102 1 3 1 11 31 831 1831 4831 9831 62 63 DOAAAA KQBAAA OOOOxx 788 1103 0 0 8 8 88 788 788 788 788 176 177 IEAAAA LQBAAA VVVVxx 902 1104 0 2 2 2 2 902 902 902 902 4 5 SIAAAA MQBAAA AAAAxx 9137 1105 1 1 7 17 37 137 1137 4137 9137 74 75 LNAAAA NQBAAA HHHHxx 1744 1106 0 0 4 4 44 744 1744 1744 1744 88 89 CPAAAA OQBAAA OOOOxx 7285 1107 1 1 5 5 85 285 1285 2285 7285 170 171 FUAAAA PQBAAA VVVVxx 7006 1108 0 2 6 6 6 6 1006 2006 7006 12 13 MJAAAA QQBAAA AAAAxx 9236 1109 0 0 6 16 36 236 1236 4236 9236 72 73 GRAAAA RQBAAA HHHHxx 5472 1110 0 0 2 12 72 472 1472 472 5472 144 145 MCAAAA SQBAAA OOOOxx 7975 1111 1 3 5 15 75 975 1975 2975 7975 150 151 TUAAAA TQBAAA VVVVxx 4181 1112 1 1 1 1 81 181 181 4181 4181 162 163 VEAAAA UQBAAA AAAAxx 7677 1113 1 1 7 17 77 677 1677 2677 7677 154 155 HJAAAA VQBAAA HHHHxx 35 1114 1 3 5 15 35 35 35 35 35 70 71 JBAAAA WQBAAA OOOOxx 6813 1115 1 1 3 13 13 813 813 1813 6813 26 27 BCAAAA XQBAAA VVVVxx 6618 1116 0 2 8 18 18 618 618 1618 6618 36 37 OUAAAA YQBAAA AAAAxx 8069 1117 1 1 9 9 69 69 69 3069 8069 138 139 JYAAAA ZQBAAA HHHHxx 3071 1118 1 3 1 11 71 71 1071 3071 3071 142 143 DOAAAA ARBAAA OOOOxx 4390 1119 0 2 0 10 90 390 390 4390 4390 180 181 WMAAAA BRBAAA VVVVxx 7764 1120 0 0 4 4 64 764 1764 2764 7764 128 129 QMAAAA CRBAAA AAAAxx 8163 1121 1 3 3 3 63 163 163 3163 8163 126 127 ZBAAAA DRBAAA HHHHxx 1961 1122 1 1 1 1 61 961 1961 1961 1961 122 123 LXAAAA ERBAAA OOOOxx 1103 1123 1 3 3 3 3 103 1103 1103 1103 6 7 LQAAAA FRBAAA VVVVxx 5486 1124 0 2 6 6 86 486 1486 486 5486 172 173 ADAAAA GRBAAA AAAAxx 9513 1125 1 1 3 13 13 513 1513 4513 9513 26 27 XBAAAA HRBAAA HHHHxx 7311 1126 1 3 1 11 11 311 1311 2311 7311 22 23 FVAAAA IRBAAA OOOOxx 4144 1127 0 0 4 4 44 144 144 4144 4144 88 89 KDAAAA JRBAAA VVVVxx 7901 1128 1 1 1 1 1 901 1901 2901 7901 2 3 XRAAAA KRBAAA AAAAxx 4629 1129 1 1 9 9 29 629 629 4629 4629 58 59 BWAAAA LRBAAA HHHHxx 6858 1130 0 2 8 18 58 858 858 1858 6858 116 117 UDAAAA MRBAAA OOOOxx 125 1131 1 1 5 5 25 125 125 125 125 50 51 VEAAAA NRBAAA VVVVxx 3834 1132 0 2 4 14 34 834 1834 3834 3834 68 69 MRAAAA ORBAAA AAAAxx 8155 1133 1 3 5 15 55 155 155 3155 8155 110 111 RBAAAA PRBAAA HHHHxx 8230 1134 0 2 0 10 30 230 230 3230 8230 60 61 OEAAAA QRBAAA OOOOxx 744 1135 0 0 4 4 44 744 744 744 744 88 89 QCAAAA RRBAAA VVVVxx 357 1136 1 1 7 17 57 357 357 357 357 114 115 TNAAAA SRBAAA AAAAxx 2159 1137 1 3 9 19 59 159 159 2159 2159 118 119 BFAAAA TRBAAA HHHHxx 8559 1138 1 3 9 19 59 559 559 3559 8559 118 119 FRAAAA URBAAA OOOOxx 6866 1139 0 2 6 6 66 866 866 1866 6866 132 133 CEAAAA VRBAAA VVVVxx 3863 1140 1 3 3 3 63 863 1863 3863 3863 126 127 PSAAAA WRBAAA AAAAxx 4193 1141 1 1 3 13 93 193 193 4193 4193 186 187 HFAAAA XRBAAA HHHHxx 3277 1142 1 1 7 17 77 277 1277 3277 3277 154 155 BWAAAA YRBAAA OOOOxx 5577 1143 1 1 7 17 77 577 1577 577 5577 154 155 NGAAAA ZRBAAA VVVVxx 9503 1144 1 3 3 3 3 503 1503 4503 9503 6 7 NBAAAA ASBAAA AAAAxx 7642 1145 0 2 2 2 42 642 1642 2642 7642 84 85 YHAAAA BSBAAA HHHHxx 6197 1146 1 1 7 17 97 197 197 1197 6197 194 195 JEAAAA CSBAAA OOOOxx 8995 1147 1 3 5 15 95 995 995 3995 8995 190 191 ZHAAAA DSBAAA VVVVxx 440 1148 0 0 0 0 40 440 440 440 440 80 81 YQAAAA ESBAAA AAAAxx 8418 1149 0 2 8 18 18 418 418 3418 8418 36 37 ULAAAA FSBAAA HHHHxx 8531 1150 1 3 1 11 31 531 531 3531 8531 62 63 DQAAAA GSBAAA OOOOxx 3790 1151 0 2 0 10 90 790 1790 3790 3790 180 181 UPAAAA HSBAAA VVVVxx 7610 1152 0 2 0 10 10 610 1610 2610 7610 20 21 SGAAAA ISBAAA AAAAxx 1252 1153 0 0 2 12 52 252 1252 1252 1252 104 105 EWAAAA JSBAAA HHHHxx 7559 1154 1 3 9 19 59 559 1559 2559 7559 118 119 TEAAAA KSBAAA OOOOxx 9945 1155 1 1 5 5 45 945 1945 4945 9945 90 91 NSAAAA LSBAAA VVVVxx 9023 1156 1 3 3 3 23 23 1023 4023 9023 46 47 BJAAAA MSBAAA AAAAxx 3516 1157 0 0 6 16 16 516 1516 3516 3516 32 33 GFAAAA NSBAAA HHHHxx 4671 1158 1 3 1 11 71 671 671 4671 4671 142 143 RXAAAA OSBAAA OOOOxx 1465 1159 1 1 5 5 65 465 1465 1465 1465 130 131 JEAAAA PSBAAA VVVVxx 9515 1160 1 3 5 15 15 515 1515 4515 9515 30 31 ZBAAAA QSBAAA AAAAxx 3242 1161 0 2 2 2 42 242 1242 3242 3242 84 85 SUAAAA RSBAAA HHHHxx 1732 1162 0 0 2 12 32 732 1732 1732 1732 64 65 QOAAAA SSBAAA OOOOxx 1678 1163 0 2 8 18 78 678 1678 1678 1678 156 157 OMAAAA TSBAAA VVVVxx 1464 1164 0 0 4 4 64 464 1464 1464 1464 128 129 IEAAAA USBAAA AAAAxx 6546 1165 0 2 6 6 46 546 546 1546 6546 92 93 URAAAA VSBAAA HHHHxx 4448 1166 0 0 8 8 48 448 448 4448 4448 96 97 CPAAAA WSBAAA OOOOxx 9847 1167 1 3 7 7 47 847 1847 4847 9847 94 95 TOAAAA XSBAAA VVVVxx 8264 1168 0 0 4 4 64 264 264 3264 8264 128 129 WFAAAA YSBAAA AAAAxx 1620 1169 0 0 0 0 20 620 1620 1620 1620 40 41 IKAAAA ZSBAAA HHHHxx 9388 1170 0 0 8 8 88 388 1388 4388 9388 176 177 CXAAAA ATBAAA OOOOxx 6445 1171 1 1 5 5 45 445 445 1445 6445 90 91 XNAAAA BTBAAA VVVVxx 4789 1172 1 1 9 9 89 789 789 4789 4789 178 179 FCAAAA CTBAAA AAAAxx 1562 1173 0 2 2 2 62 562 1562 1562 1562 124 125 CIAAAA DTBAAA HHHHxx 7305 1174 1 1 5 5 5 305 1305 2305 7305 10 11 ZUAAAA ETBAAA OOOOxx 6344 1175 0 0 4 4 44 344 344 1344 6344 88 89 AKAAAA FTBAAA VVVVxx 5130 1176 0 2 0 10 30 130 1130 130 5130 60 61 IPAAAA GTBAAA AAAAxx 3284 1177 0 0 4 4 84 284 1284 3284 3284 168 169 IWAAAA HTBAAA HHHHxx 6346 1178 0 2 6 6 46 346 346 1346 6346 92 93 CKAAAA ITBAAA OOOOxx 1061 1179 1 1 1 1 61 61 1061 1061 1061 122 123 VOAAAA JTBAAA VVVVxx 872 1180 0 0 2 12 72 872 872 872 872 144 145 OHAAAA KTBAAA AAAAxx 123 1181 1 3 3 3 23 123 123 123 123 46 47 TEAAAA LTBAAA HHHHxx 7903 1182 1 3 3 3 3 903 1903 2903 7903 6 7 ZRAAAA MTBAAA OOOOxx 560 1183 0 0 0 0 60 560 560 560 560 120 121 OVAAAA NTBAAA VVVVxx 4446 1184 0 2 6 6 46 446 446 4446 4446 92 93 APAAAA OTBAAA AAAAxx 3909 1185 1 1 9 9 9 909 1909 3909 3909 18 19 JUAAAA PTBAAA HHHHxx 669 1186 1 1 9 9 69 669 669 669 669 138 139 TZAAAA QTBAAA OOOOxx 7843 1187 1 3 3 3 43 843 1843 2843 7843 86 87 RPAAAA RTBAAA VVVVxx 2546 1188 0 2 6 6 46 546 546 2546 2546 92 93 YTAAAA STBAAA AAAAxx 6757 1189 1 1 7 17 57 757 757 1757 6757 114 115 XZAAAA TTBAAA HHHHxx 466 1190 0 2 6 6 66 466 466 466 466 132 133 YRAAAA UTBAAA OOOOxx 5556 1191 0 0 6 16 56 556 1556 556 5556 112 113 SFAAAA VTBAAA VVVVxx 7196 1192 0 0 6 16 96 196 1196 2196 7196 192 193 UQAAAA WTBAAA AAAAxx 2947 1193 1 3 7 7 47 947 947 2947 2947 94 95 JJAAAA XTBAAA HHHHxx 6493 1194 1 1 3 13 93 493 493 1493 6493 186 187 TPAAAA YTBAAA OOOOxx 7203 1195 1 3 3 3 3 203 1203 2203 7203 6 7 BRAAAA ZTBAAA VVVVxx 3716 1196 0 0 6 16 16 716 1716 3716 3716 32 33 YMAAAA AUBAAA AAAAxx 8058 1197 0 2 8 18 58 58 58 3058 8058 116 117 YXAAAA BUBAAA HHHHxx 433 1198 1 1 3 13 33 433 433 433 433 66 67 RQAAAA CUBAAA OOOOxx 7649 1199 1 1 9 9 49 649 1649 2649 7649 98 99 FIAAAA DUBAAA VVVVxx 6966 1200 0 2 6 6 66 966 966 1966 6966 132 133 YHAAAA EUBAAA AAAAxx 553 1201 1 1 3 13 53 553 553 553 553 106 107 HVAAAA FUBAAA HHHHxx 3677 1202 1 1 7 17 77 677 1677 3677 3677 154 155 LLAAAA GUBAAA OOOOxx 2344 1203 0 0 4 4 44 344 344 2344 2344 88 89 EMAAAA HUBAAA VVVVxx 7439 1204 1 3 9 19 39 439 1439 2439 7439 78 79 DAAAAA IUBAAA AAAAxx 3910 1205 0 2 0 10 10 910 1910 3910 3910 20 21 KUAAAA JUBAAA HHHHxx 3638 1206 0 2 8 18 38 638 1638 3638 3638 76 77 YJAAAA KUBAAA OOOOxx 6637 1207 1 1 7 17 37 637 637 1637 6637 74 75 HVAAAA LUBAAA VVVVxx 4438 1208 0 2 8 18 38 438 438 4438 4438 76 77 SOAAAA MUBAAA AAAAxx 171 1209 1 3 1 11 71 171 171 171 171 142 143 PGAAAA NUBAAA HHHHxx 310 1210 0 2 0 10 10 310 310 310 310 20 21 YLAAAA OUBAAA OOOOxx 2714 1211 0 2 4 14 14 714 714 2714 2714 28 29 KAAAAA PUBAAA VVVVxx 5199 1212 1 3 9 19 99 199 1199 199 5199 198 199 ZRAAAA QUBAAA AAAAxx 8005 1213 1 1 5 5 5 5 5 3005 8005 10 11 XVAAAA RUBAAA HHHHxx 3188 1214 0 0 8 8 88 188 1188 3188 3188 176 177 QSAAAA SUBAAA OOOOxx 1518 1215 0 2 8 18 18 518 1518 1518 1518 36 37 KGAAAA TUBAAA VVVVxx 6760 1216 0 0 0 0 60 760 760 1760 6760 120 121 AAAAAA UUBAAA AAAAxx 9373 1217 1 1 3 13 73 373 1373 4373 9373 146 147 NWAAAA VUBAAA HHHHxx 1938 1218 0 2 8 18 38 938 1938 1938 1938 76 77 OWAAAA WUBAAA OOOOxx 2865 1219 1 1 5 5 65 865 865 2865 2865 130 131 FGAAAA XUBAAA VVVVxx 3203 1220 1 3 3 3 3 203 1203 3203 3203 6 7 FTAAAA YUBAAA AAAAxx 6025 1221 1 1 5 5 25 25 25 1025 6025 50 51 TXAAAA ZUBAAA HHHHxx 8684 1222 0 0 4 4 84 684 684 3684 8684 168 169 AWAAAA AVBAAA OOOOxx 7732 1223 0 0 2 12 32 732 1732 2732 7732 64 65 KLAAAA BVBAAA VVVVxx 3218 1224 0 2 8 18 18 218 1218 3218 3218 36 37 UTAAAA CVBAAA AAAAxx 525 1225 1 1 5 5 25 525 525 525 525 50 51 FUAAAA DVBAAA HHHHxx 601 1226 1 1 1 1 1 601 601 601 601 2 3 DXAAAA EVBAAA OOOOxx 6091 1227 1 3 1 11 91 91 91 1091 6091 182 183 HAAAAA FVBAAA VVVVxx 4498 1228 0 2 8 18 98 498 498 4498 4498 196 197 ARAAAA GVBAAA AAAAxx 8192 1229 0 0 2 12 92 192 192 3192 8192 184 185 CDAAAA HVBAAA HHHHxx 8006 1230 0 2 6 6 6 6 6 3006 8006 12 13 YVAAAA IVBAAA OOOOxx 6157 1231 1 1 7 17 57 157 157 1157 6157 114 115 VCAAAA JVBAAA VVVVxx 312 1232 0 0 2 12 12 312 312 312 312 24 25 AMAAAA KVBAAA AAAAxx 8652 1233 0 0 2 12 52 652 652 3652 8652 104 105 UUAAAA LVBAAA HHHHxx 2787 1234 1 3 7 7 87 787 787 2787 2787 174 175 FDAAAA MVBAAA OOOOxx 1782 1235 0 2 2 2 82 782 1782 1782 1782 164 165 OQAAAA NVBAAA VVVVxx 23 1236 1 3 3 3 23 23 23 23 23 46 47 XAAAAA OVBAAA AAAAxx 1206 1237 0 2 6 6 6 206 1206 1206 1206 12 13 KUAAAA PVBAAA HHHHxx 1076 1238 0 0 6 16 76 76 1076 1076 1076 152 153 KPAAAA QVBAAA OOOOxx 5379 1239 1 3 9 19 79 379 1379 379 5379 158 159 XYAAAA RVBAAA VVVVxx 2047 1240 1 3 7 7 47 47 47 2047 2047 94 95 TAAAAA SVBAAA AAAAxx 6262 1241 0 2 2 2 62 262 262 1262 6262 124 125 WGAAAA TVBAAA HHHHxx 1840 1242 0 0 0 0 40 840 1840 1840 1840 80 81 USAAAA UVBAAA OOOOxx 2106 1243 0 2 6 6 6 106 106 2106 2106 12 13 ADAAAA VVBAAA VVVVxx 1307 1244 1 3 7 7 7 307 1307 1307 1307 14 15 HYAAAA WVBAAA AAAAxx 735 1245 1 3 5 15 35 735 735 735 735 70 71 HCAAAA XVBAAA HHHHxx 3657 1246 1 1 7 17 57 657 1657 3657 3657 114 115 RKAAAA YVBAAA OOOOxx 3006 1247 0 2 6 6 6 6 1006 3006 3006 12 13 QLAAAA ZVBAAA VVVVxx 1538 1248 0 2 8 18 38 538 1538 1538 1538 76 77 EHAAAA AWBAAA AAAAxx 6098 1249 0 2 8 18 98 98 98 1098 6098 196 197 OAAAAA BWBAAA HHHHxx 5267 1250 1 3 7 7 67 267 1267 267 5267 134 135 PUAAAA CWBAAA OOOOxx 9757 1251 1 1 7 17 57 757 1757 4757 9757 114 115 HLAAAA DWBAAA VVVVxx 1236 1252 0 0 6 16 36 236 1236 1236 1236 72 73 OVAAAA EWBAAA AAAAxx 83 1253 1 3 3 3 83 83 83 83 83 166 167 FDAAAA FWBAAA HHHHxx 9227 1254 1 3 7 7 27 227 1227 4227 9227 54 55 XQAAAA GWBAAA OOOOxx 8772 1255 0 0 2 12 72 772 772 3772 8772 144 145 KZAAAA HWBAAA VVVVxx 8822 1256 0 2 2 2 22 822 822 3822 8822 44 45 IBAAAA IWBAAA AAAAxx 7167 1257 1 3 7 7 67 167 1167 2167 7167 134 135 RPAAAA JWBAAA HHHHxx 6909 1258 1 1 9 9 9 909 909 1909 6909 18 19 TFAAAA KWBAAA OOOOxx 1439 1259 1 3 9 19 39 439 1439 1439 1439 78 79 JDAAAA LWBAAA VVVVxx 2370 1260 0 2 0 10 70 370 370 2370 2370 140 141 ENAAAA MWBAAA AAAAxx 4577 1261 1 1 7 17 77 577 577 4577 4577 154 155 BUAAAA NWBAAA HHHHxx 2575 1262 1 3 5 15 75 575 575 2575 2575 150 151 BVAAAA OWBAAA OOOOxx 2795 1263 1 3 5 15 95 795 795 2795 2795 190 191 NDAAAA PWBAAA VVVVxx 5520 1264 0 0 0 0 20 520 1520 520 5520 40 41 IEAAAA QWBAAA AAAAxx 382 1265 0 2 2 2 82 382 382 382 382 164 165 SOAAAA RWBAAA HHHHxx 6335 1266 1 3 5 15 35 335 335 1335 6335 70 71 RJAAAA SWBAAA OOOOxx 8430 1267 0 2 0 10 30 430 430 3430 8430 60 61 GMAAAA TWBAAA VVVVxx 4131 1268 1 3 1 11 31 131 131 4131 4131 62 63 XCAAAA UWBAAA AAAAxx 9332 1269 0 0 2 12 32 332 1332 4332 9332 64 65 YUAAAA VWBAAA HHHHxx 293 1270 1 1 3 13 93 293 293 293 293 186 187 HLAAAA WWBAAA OOOOxx 2276 1271 0 0 6 16 76 276 276 2276 2276 152 153 OJAAAA XWBAAA VVVVxx 5687 1272 1 3 7 7 87 687 1687 687 5687 174 175 TKAAAA YWBAAA AAAAxx 5862 1273 0 2 2 2 62 862 1862 862 5862 124 125 MRAAAA ZWBAAA HHHHxx 5073 1274 1 1 3 13 73 73 1073 73 5073 146 147 DNAAAA AXBAAA OOOOxx 4170 1275 0 2 0 10 70 170 170 4170 4170 140 141 KEAAAA BXBAAA VVVVxx 5039 1276 1 3 9 19 39 39 1039 39 5039 78 79 VLAAAA CXBAAA AAAAxx 3294 1277 0 2 4 14 94 294 1294 3294 3294 188 189 SWAAAA DXBAAA HHHHxx 6015 1278 1 3 5 15 15 15 15 1015 6015 30 31 JXAAAA EXBAAA OOOOxx 9015 1279 1 3 5 15 15 15 1015 4015 9015 30 31 TIAAAA FXBAAA VVVVxx 9785 1280 1 1 5 5 85 785 1785 4785 9785 170 171 JMAAAA GXBAAA AAAAxx 4312 1281 0 0 2 12 12 312 312 4312 4312 24 25 WJAAAA HXBAAA HHHHxx 6343 1282 1 3 3 3 43 343 343 1343 6343 86 87 ZJAAAA IXBAAA OOOOxx 2161 1283 1 1 1 1 61 161 161 2161 2161 122 123 DFAAAA JXBAAA VVVVxx 4490 1284 0 2 0 10 90 490 490 4490 4490 180 181 SQAAAA KXBAAA AAAAxx 4454 1285 0 2 4 14 54 454 454 4454 4454 108 109 IPAAAA LXBAAA HHHHxx 7647 1286 1 3 7 7 47 647 1647 2647 7647 94 95 DIAAAA MXBAAA OOOOxx 1028 1287 0 0 8 8 28 28 1028 1028 1028 56 57 ONAAAA NXBAAA VVVVxx 2965 1288 1 1 5 5 65 965 965 2965 2965 130 131 BKAAAA OXBAAA AAAAxx 9900 1289 0 0 0 0 0 900 1900 4900 9900 0 1 UQAAAA PXBAAA HHHHxx 5509 1290 1 1 9 9 9 509 1509 509 5509 18 19 XDAAAA QXBAAA OOOOxx 7751 1291 1 3 1 11 51 751 1751 2751 7751 102 103 DMAAAA RXBAAA VVVVxx 9594 1292 0 2 4 14 94 594 1594 4594 9594 188 189 AFAAAA SXBAAA AAAAxx 7632 1293 0 0 2 12 32 632 1632 2632 7632 64 65 OHAAAA TXBAAA HHHHxx 6528 1294 0 0 8 8 28 528 528 1528 6528 56 57 CRAAAA UXBAAA OOOOxx 1041 1295 1 1 1 1 41 41 1041 1041 1041 82 83 BOAAAA VXBAAA VVVVxx 1534 1296 0 2 4 14 34 534 1534 1534 1534 68 69 AHAAAA WXBAAA AAAAxx 4229 1297 1 1 9 9 29 229 229 4229 4229 58 59 RGAAAA XXBAAA HHHHxx 84 1298 0 0 4 4 84 84 84 84 84 168 169 GDAAAA YXBAAA OOOOxx 2189 1299 1 1 9 9 89 189 189 2189 2189 178 179 FGAAAA ZXBAAA VVVVxx 7566 1300 0 2 6 6 66 566 1566 2566 7566 132 133 AFAAAA AYBAAA AAAAxx 707 1301 1 3 7 7 7 707 707 707 707 14 15 FBAAAA BYBAAA HHHHxx 581 1302 1 1 1 1 81 581 581 581 581 162 163 JWAAAA CYBAAA OOOOxx 6753 1303 1 1 3 13 53 753 753 1753 6753 106 107 TZAAAA DYBAAA VVVVxx 8604 1304 0 0 4 4 4 604 604 3604 8604 8 9 YSAAAA EYBAAA AAAAxx 373 1305 1 1 3 13 73 373 373 373 373 146 147 JOAAAA FYBAAA HHHHxx 9635 1306 1 3 5 15 35 635 1635 4635 9635 70 71 PGAAAA GYBAAA OOOOxx 9277 1307 1 1 7 17 77 277 1277 4277 9277 154 155 VSAAAA HYBAAA VVVVxx 7117 1308 1 1 7 17 17 117 1117 2117 7117 34 35 TNAAAA IYBAAA AAAAxx 8564 1309 0 0 4 4 64 564 564 3564 8564 128 129 KRAAAA JYBAAA HHHHxx 1697 1310 1 1 7 17 97 697 1697 1697 1697 194 195 HNAAAA KYBAAA OOOOxx 7840 1311 0 0 0 0 40 840 1840 2840 7840 80 81 OPAAAA LYBAAA VVVVxx 3646 1312 0 2 6 6 46 646 1646 3646 3646 92 93 GKAAAA MYBAAA AAAAxx 368 1313 0 0 8 8 68 368 368 368 368 136 137 EOAAAA NYBAAA HHHHxx 4797 1314 1 1 7 17 97 797 797 4797 4797 194 195 NCAAAA OYBAAA OOOOxx 5300 1315 0 0 0 0 0 300 1300 300 5300 0 1 WVAAAA PYBAAA VVVVxx 7664 1316 0 0 4 4 64 664 1664 2664 7664 128 129 UIAAAA QYBAAA AAAAxx 1466 1317 0 2 6 6 66 466 1466 1466 1466 132 133 KEAAAA RYBAAA HHHHxx 2477 1318 1 1 7 17 77 477 477 2477 2477 154 155 HRAAAA SYBAAA OOOOxx 2036 1319 0 0 6 16 36 36 36 2036 2036 72 73 IAAAAA TYBAAA VVVVxx 3624 1320 0 0 4 4 24 624 1624 3624 3624 48 49 KJAAAA UYBAAA AAAAxx 5099 1321 1 3 9 19 99 99 1099 99 5099 198 199 DOAAAA VYBAAA HHHHxx 1308 1322 0 0 8 8 8 308 1308 1308 1308 16 17 IYAAAA WYBAAA OOOOxx 3704 1323 0 0 4 4 4 704 1704 3704 3704 8 9 MMAAAA XYBAAA VVVVxx 2451 1324 1 3 1 11 51 451 451 2451 2451 102 103 HQAAAA YYBAAA AAAAxx 4898 1325 0 2 8 18 98 898 898 4898 4898 196 197 KGAAAA ZYBAAA HHHHxx 4959 1326 1 3 9 19 59 959 959 4959 4959 118 119 TIAAAA AZBAAA OOOOxx 5942 1327 0 2 2 2 42 942 1942 942 5942 84 85 OUAAAA BZBAAA VVVVxx 2425 1328 1 1 5 5 25 425 425 2425 2425 50 51 HPAAAA CZBAAA AAAAxx 7760 1329 0 0 0 0 60 760 1760 2760 7760 120 121 MMAAAA DZBAAA HHHHxx 6294 1330 0 2 4 14 94 294 294 1294 6294 188 189 CIAAAA EZBAAA OOOOxx 6785 1331 1 1 5 5 85 785 785 1785 6785 170 171 ZAAAAA FZBAAA VVVVxx 3542 1332 0 2 2 2 42 542 1542 3542 3542 84 85 GGAAAA GZBAAA AAAAxx 1809 1333 1 1 9 9 9 809 1809 1809 1809 18 19 PRAAAA HZBAAA HHHHxx 130 1334 0 2 0 10 30 130 130 130 130 60 61 AFAAAA IZBAAA OOOOxx 8672 1335 0 0 2 12 72 672 672 3672 8672 144 145 OVAAAA JZBAAA VVVVxx 2125 1336 1 1 5 5 25 125 125 2125 2125 50 51 TDAAAA KZBAAA AAAAxx 7683 1337 1 3 3 3 83 683 1683 2683 7683 166 167 NJAAAA LZBAAA HHHHxx 7842 1338 0 2 2 2 42 842 1842 2842 7842 84 85 QPAAAA MZBAAA OOOOxx 9584 1339 0 0 4 4 84 584 1584 4584 9584 168 169 QEAAAA NZBAAA VVVVxx 7963 1340 1 3 3 3 63 963 1963 2963 7963 126 127 HUAAAA OZBAAA AAAAxx 8581 1341 1 1 1 1 81 581 581 3581 8581 162 163 BSAAAA PZBAAA HHHHxx 2135 1342 1 3 5 15 35 135 135 2135 2135 70 71 DEAAAA QZBAAA OOOOxx 7352 1343 0 0 2 12 52 352 1352 2352 7352 104 105 UWAAAA RZBAAA VVVVxx 5789 1344 1 1 9 9 89 789 1789 789 5789 178 179 ROAAAA SZBAAA AAAAxx 8490 1345 0 2 0 10 90 490 490 3490 8490 180 181 OOAAAA TZBAAA HHHHxx 2145 1346 1 1 5 5 45 145 145 2145 2145 90 91 NEAAAA UZBAAA OOOOxx 7021 1347 1 1 1 1 21 21 1021 2021 7021 42 43 BKAAAA VZBAAA VVVVxx 3736 1348 0 0 6 16 36 736 1736 3736 3736 72 73 SNAAAA WZBAAA AAAAxx 7396 1349 0 0 6 16 96 396 1396 2396 7396 192 193 MYAAAA XZBAAA HHHHxx 6334 1350 0 2 4 14 34 334 334 1334 6334 68 69 QJAAAA YZBAAA OOOOxx 5461 1351 1 1 1 1 61 461 1461 461 5461 122 123 BCAAAA ZZBAAA VVVVxx 5337 1352 1 1 7 17 37 337 1337 337 5337 74 75 HXAAAA AACAAA AAAAxx 7440 1353 0 0 0 0 40 440 1440 2440 7440 80 81 EAAAAA BACAAA HHHHxx 6879 1354 1 3 9 19 79 879 879 1879 6879 158 159 PEAAAA CACAAA OOOOxx 2432 1355 0 0 2 12 32 432 432 2432 2432 64 65 OPAAAA DACAAA VVVVxx 8529 1356 1 1 9 9 29 529 529 3529 8529 58 59 BQAAAA EACAAA AAAAxx 7859 1357 1 3 9 19 59 859 1859 2859 7859 118 119 HQAAAA FACAAA HHHHxx 15 1358 1 3 5 15 15 15 15 15 15 30 31 PAAAAA GACAAA OOOOxx 7475 1359 1 3 5 15 75 475 1475 2475 7475 150 151 NBAAAA HACAAA VVVVxx 717 1360 1 1 7 17 17 717 717 717 717 34 35 PBAAAA IACAAA AAAAxx 250 1361 0 2 0 10 50 250 250 250 250 100 101 QJAAAA JACAAA HHHHxx 4700 1362 0 0 0 0 0 700 700 4700 4700 0 1 UYAAAA KACAAA OOOOxx 7510 1363 0 2 0 10 10 510 1510 2510 7510 20 21 WCAAAA LACAAA VVVVxx 4562 1364 0 2 2 2 62 562 562 4562 4562 124 125 MTAAAA MACAAA AAAAxx 8075 1365 1 3 5 15 75 75 75 3075 8075 150 151 PYAAAA NACAAA HHHHxx 871 1366 1 3 1 11 71 871 871 871 871 142 143 NHAAAA OACAAA OOOOxx 7161 1367 1 1 1 1 61 161 1161 2161 7161 122 123 LPAAAA PACAAA VVVVxx 9109 1368 1 1 9 9 9 109 1109 4109 9109 18 19 JMAAAA QACAAA AAAAxx 8675 1369 1 3 5 15 75 675 675 3675 8675 150 151 RVAAAA RACAAA HHHHxx 1025 1370 1 1 5 5 25 25 1025 1025 1025 50 51 LNAAAA SACAAA OOOOxx 4065 1371 1 1 5 5 65 65 65 4065 4065 130 131 JAAAAA TACAAA VVVVxx 3511 1372 1 3 1 11 11 511 1511 3511 3511 22 23 BFAAAA UACAAA AAAAxx 9840 1373 0 0 0 0 40 840 1840 4840 9840 80 81 MOAAAA VACAAA HHHHxx 7495 1374 1 3 5 15 95 495 1495 2495 7495 190 191 HCAAAA WACAAA OOOOxx 55 1375 1 3 5 15 55 55 55 55 55 110 111 DCAAAA XACAAA VVVVxx 6151 1376 1 3 1 11 51 151 151 1151 6151 102 103 PCAAAA YACAAA AAAAxx 2512 1377 0 0 2 12 12 512 512 2512 2512 24 25 QSAAAA ZACAAA HHHHxx 5881 1378 1 1 1 1 81 881 1881 881 5881 162 163 FSAAAA ABCAAA OOOOxx 1442 1379 0 2 2 2 42 442 1442 1442 1442 84 85 MDAAAA BBCAAA VVVVxx 1270 1380 0 2 0 10 70 270 1270 1270 1270 140 141 WWAAAA CBCAAA AAAAxx 959 1381 1 3 9 19 59 959 959 959 959 118 119 XKAAAA DBCAAA HHHHxx 8251 1382 1 3 1 11 51 251 251 3251 8251 102 103 JFAAAA EBCAAA OOOOxx 3051 1383 1 3 1 11 51 51 1051 3051 3051 102 103 JNAAAA FBCAAA VVVVxx 5052 1384 0 0 2 12 52 52 1052 52 5052 104 105 IMAAAA GBCAAA AAAAxx 1863 1385 1 3 3 3 63 863 1863 1863 1863 126 127 RTAAAA HBCAAA HHHHxx 344 1386 0 0 4 4 44 344 344 344 344 88 89 GNAAAA IBCAAA OOOOxx 3590 1387 0 2 0 10 90 590 1590 3590 3590 180 181 CIAAAA JBCAAA VVVVxx 4223 1388 1 3 3 3 23 223 223 4223 4223 46 47 LGAAAA KBCAAA AAAAxx 2284 1389 0 0 4 4 84 284 284 2284 2284 168 169 WJAAAA LBCAAA HHHHxx 9425 1390 1 1 5 5 25 425 1425 4425 9425 50 51 NYAAAA MBCAAA OOOOxx 6221 1391 1 1 1 1 21 221 221 1221 6221 42 43 HFAAAA NBCAAA VVVVxx 195 1392 1 3 5 15 95 195 195 195 195 190 191 NHAAAA OBCAAA AAAAxx 1517 1393 1 1 7 17 17 517 1517 1517 1517 34 35 JGAAAA PBCAAA HHHHxx 3791 1394 1 3 1 11 91 791 1791 3791 3791 182 183 VPAAAA QBCAAA OOOOxx 572 1395 0 0 2 12 72 572 572 572 572 144 145 AWAAAA RBCAAA VVVVxx 46 1396 0 2 6 6 46 46 46 46 46 92 93 UBAAAA SBCAAA AAAAxx 9451 1397 1 3 1 11 51 451 1451 4451 9451 102 103 NZAAAA TBCAAA HHHHxx 3359 1398 1 3 9 19 59 359 1359 3359 3359 118 119 FZAAAA UBCAAA OOOOxx 8867 1399 1 3 7 7 67 867 867 3867 8867 134 135 BDAAAA VBCAAA VVVVxx 674 1400 0 2 4 14 74 674 674 674 674 148 149 YZAAAA WBCAAA AAAAxx 2674 1401 0 2 4 14 74 674 674 2674 2674 148 149 WYAAAA XBCAAA HHHHxx 6523 1402 1 3 3 3 23 523 523 1523 6523 46 47 XQAAAA YBCAAA OOOOxx 6210 1403 0 2 0 10 10 210 210 1210 6210 20 21 WEAAAA ZBCAAA VVVVxx 7564 1404 0 0 4 4 64 564 1564 2564 7564 128 129 YEAAAA ACCAAA AAAAxx 4776 1405 0 0 6 16 76 776 776 4776 4776 152 153 SBAAAA BCCAAA HHHHxx 2993 1406 1 1 3 13 93 993 993 2993 2993 186 187 DLAAAA CCCAAA OOOOxx 2969 1407 1 1 9 9 69 969 969 2969 2969 138 139 FKAAAA DCCAAA VVVVxx 1762 1408 0 2 2 2 62 762 1762 1762 1762 124 125 UPAAAA ECCAAA AAAAxx 685 1409 1 1 5 5 85 685 685 685 685 170 171 JAAAAA FCCAAA HHHHxx 5312 1410 0 0 2 12 12 312 1312 312 5312 24 25 IWAAAA GCCAAA OOOOxx 3264 1411 0 0 4 4 64 264 1264 3264 3264 128 129 OVAAAA HCCAAA VVVVxx 7008 1412 0 0 8 8 8 8 1008 2008 7008 16 17 OJAAAA ICCAAA AAAAxx 5167 1413 1 3 7 7 67 167 1167 167 5167 134 135 TQAAAA JCCAAA HHHHxx 3060 1414 0 0 0 0 60 60 1060 3060 3060 120 121 SNAAAA KCCAAA OOOOxx 1752 1415 0 0 2 12 52 752 1752 1752 1752 104 105 KPAAAA LCCAAA VVVVxx 1016 1416 0 0 6 16 16 16 1016 1016 1016 32 33 CNAAAA MCCAAA AAAAxx 7365 1417 1 1 5 5 65 365 1365 2365 7365 130 131 HXAAAA NCCAAA HHHHxx 4358 1418 0 2 8 18 58 358 358 4358 4358 116 117 QLAAAA OCCAAA OOOOxx 2819 1419 1 3 9 19 19 819 819 2819 2819 38 39 LEAAAA PCCAAA VVVVxx 6727 1420 1 3 7 7 27 727 727 1727 6727 54 55 TYAAAA QCCAAA AAAAxx 1459 1421 1 3 9 19 59 459 1459 1459 1459 118 119 DEAAAA RCCAAA HHHHxx 1708 1422 0 0 8 8 8 708 1708 1708 1708 16 17 SNAAAA SCCAAA OOOOxx 471 1423 1 3 1 11 71 471 471 471 471 142 143 DSAAAA TCCAAA VVVVxx 387 1424 1 3 7 7 87 387 387 387 387 174 175 XOAAAA UCCAAA AAAAxx 1166 1425 0 2 6 6 66 166 1166 1166 1166 132 133 WSAAAA VCCAAA HHHHxx 2400 1426 0 0 0 0 0 400 400 2400 2400 0 1 IOAAAA WCCAAA OOOOxx 3584 1427 0 0 4 4 84 584 1584 3584 3584 168 169 WHAAAA XCCAAA VVVVxx 6423 1428 1 3 3 3 23 423 423 1423 6423 46 47 BNAAAA YCCAAA AAAAxx 9520 1429 0 0 0 0 20 520 1520 4520 9520 40 41 ECAAAA ZCCAAA HHHHxx 8080 1430 0 0 0 0 80 80 80 3080 8080 160 161 UYAAAA ADCAAA OOOOxx 5709 1431 1 1 9 9 9 709 1709 709 5709 18 19 PLAAAA BDCAAA VVVVxx 1131 1432 1 3 1 11 31 131 1131 1131 1131 62 63 NRAAAA CDCAAA AAAAxx 8562 1433 0 2 2 2 62 562 562 3562 8562 124 125 IRAAAA DDCAAA HHHHxx 5766 1434 0 2 6 6 66 766 1766 766 5766 132 133 UNAAAA EDCAAA OOOOxx 245 1435 1 1 5 5 45 245 245 245 245 90 91 LJAAAA FDCAAA VVVVxx 9869 1436 1 1 9 9 69 869 1869 4869 9869 138 139 PPAAAA GDCAAA AAAAxx 3533 1437 1 1 3 13 33 533 1533 3533 3533 66 67 XFAAAA HDCAAA HHHHxx 5109 1438 1 1 9 9 9 109 1109 109 5109 18 19 NOAAAA IDCAAA OOOOxx 977 1439 1 1 7 17 77 977 977 977 977 154 155 PLAAAA JDCAAA VVVVxx 1651 1440 1 3 1 11 51 651 1651 1651 1651 102 103 NLAAAA KDCAAA AAAAxx 1357 1441 1 1 7 17 57 357 1357 1357 1357 114 115 FAAAAA LDCAAA HHHHxx 9087 1442 1 3 7 7 87 87 1087 4087 9087 174 175 NLAAAA MDCAAA OOOOxx 3399 1443 1 3 9 19 99 399 1399 3399 3399 198 199 TAAAAA NDCAAA VVVVxx 7543 1444 1 3 3 3 43 543 1543 2543 7543 86 87 DEAAAA ODCAAA AAAAxx 2469 1445 1 1 9 9 69 469 469 2469 2469 138 139 ZQAAAA PDCAAA HHHHxx 8305 1446 1 1 5 5 5 305 305 3305 8305 10 11 LHAAAA QDCAAA OOOOxx 3265 1447 1 1 5 5 65 265 1265 3265 3265 130 131 PVAAAA RDCAAA VVVVxx 9977 1448 1 1 7 17 77 977 1977 4977 9977 154 155 TTAAAA SDCAAA AAAAxx 3961 1449 1 1 1 1 61 961 1961 3961 3961 122 123 JWAAAA TDCAAA HHHHxx 4952 1450 0 0 2 12 52 952 952 4952 4952 104 105 MIAAAA UDCAAA OOOOxx 5173 1451 1 1 3 13 73 173 1173 173 5173 146 147 ZQAAAA VDCAAA VVVVxx 860 1452 0 0 0 0 60 860 860 860 860 120 121 CHAAAA WDCAAA AAAAxx 4523 1453 1 3 3 3 23 523 523 4523 4523 46 47 ZRAAAA XDCAAA HHHHxx 2361 1454 1 1 1 1 61 361 361 2361 2361 122 123 VMAAAA YDCAAA OOOOxx 7877 1455 1 1 7 17 77 877 1877 2877 7877 154 155 ZQAAAA ZDCAAA VVVVxx 3422 1456 0 2 2 2 22 422 1422 3422 3422 44 45 QBAAAA AECAAA AAAAxx 5781 1457 1 1 1 1 81 781 1781 781 5781 162 163 JOAAAA BECAAA HHHHxx 4752 1458 0 0 2 12 52 752 752 4752 4752 104 105 UAAAAA CECAAA OOOOxx 1786 1459 0 2 6 6 86 786 1786 1786 1786 172 173 SQAAAA DECAAA VVVVxx 1892 1460 0 0 2 12 92 892 1892 1892 1892 184 185 UUAAAA EECAAA AAAAxx 6389 1461 1 1 9 9 89 389 389 1389 6389 178 179 TLAAAA FECAAA HHHHxx 8644 1462 0 0 4 4 44 644 644 3644 8644 88 89 MUAAAA GECAAA OOOOxx 9056 1463 0 0 6 16 56 56 1056 4056 9056 112 113 IKAAAA HECAAA VVVVxx 1423 1464 1 3 3 3 23 423 1423 1423 1423 46 47 TCAAAA IECAAA AAAAxx 4901 1465 1 1 1 1 1 901 901 4901 4901 2 3 NGAAAA JECAAA HHHHxx 3859 1466 1 3 9 19 59 859 1859 3859 3859 118 119 LSAAAA KECAAA OOOOxx 2324 1467 0 0 4 4 24 324 324 2324 2324 48 49 KLAAAA LECAAA VVVVxx 8101 1468 1 1 1 1 1 101 101 3101 8101 2 3 PZAAAA MECAAA AAAAxx 8016 1469 0 0 6 16 16 16 16 3016 8016 32 33 IWAAAA NECAAA HHHHxx 5826 1470 0 2 6 6 26 826 1826 826 5826 52 53 CQAAAA OECAAA OOOOxx 8266 1471 0 2 6 6 66 266 266 3266 8266 132 133 YFAAAA PECAAA VVVVxx 7558 1472 0 2 8 18 58 558 1558 2558 7558 116 117 SEAAAA QECAAA AAAAxx 6976 1473 0 0 6 16 76 976 976 1976 6976 152 153 IIAAAA RECAAA HHHHxx 222 1474 0 2 2 2 22 222 222 222 222 44 45 OIAAAA SECAAA OOOOxx 1624 1475 0 0 4 4 24 624 1624 1624 1624 48 49 MKAAAA TECAAA VVVVxx 1250 1476 0 2 0 10 50 250 1250 1250 1250 100 101 CWAAAA UECAAA AAAAxx 1621 1477 1 1 1 1 21 621 1621 1621 1621 42 43 JKAAAA VECAAA HHHHxx 2350 1478 0 2 0 10 50 350 350 2350 2350 100 101 KMAAAA WECAAA OOOOxx 5239 1479 1 3 9 19 39 239 1239 239 5239 78 79 NTAAAA XECAAA VVVVxx 6681 1480 1 1 1 1 81 681 681 1681 6681 162 163 ZWAAAA YECAAA AAAAxx 4983 1481 1 3 3 3 83 983 983 4983 4983 166 167 RJAAAA ZECAAA HHHHxx 7149 1482 1 1 9 9 49 149 1149 2149 7149 98 99 ZOAAAA AFCAAA OOOOxx 3502 1483 0 2 2 2 2 502 1502 3502 3502 4 5 SEAAAA BFCAAA VVVVxx 3133 1484 1 1 3 13 33 133 1133 3133 3133 66 67 NQAAAA CFCAAA AAAAxx 8342 1485 0 2 2 2 42 342 342 3342 8342 84 85 WIAAAA DFCAAA HHHHxx 3041 1486 1 1 1 1 41 41 1041 3041 3041 82 83 ZMAAAA EFCAAA OOOOxx 5383 1487 1 3 3 3 83 383 1383 383 5383 166 167 BZAAAA FFCAAA VVVVxx 3916 1488 0 0 6 16 16 916 1916 3916 3916 32 33 QUAAAA GFCAAA AAAAxx 1438 1489 0 2 8 18 38 438 1438 1438 1438 76 77 IDAAAA HFCAAA HHHHxx 9408 1490 0 0 8 8 8 408 1408 4408 9408 16 17 WXAAAA IFCAAA OOOOxx 5783 1491 1 3 3 3 83 783 1783 783 5783 166 167 LOAAAA JFCAAA VVVVxx 683 1492 1 3 3 3 83 683 683 683 683 166 167 HAAAAA KFCAAA AAAAxx 9381 1493 1 1 1 1 81 381 1381 4381 9381 162 163 VWAAAA LFCAAA HHHHxx 5676 1494 0 0 6 16 76 676 1676 676 5676 152 153 IKAAAA MFCAAA OOOOxx 3224 1495 0 0 4 4 24 224 1224 3224 3224 48 49 AUAAAA NFCAAA VVVVxx 8332 1496 0 0 2 12 32 332 332 3332 8332 64 65 MIAAAA OFCAAA AAAAxx 3372 1497 0 0 2 12 72 372 1372 3372 3372 144 145 SZAAAA PFCAAA HHHHxx 7436 1498 0 0 6 16 36 436 1436 2436 7436 72 73 AAAAAA QFCAAA OOOOxx 5010 1499 0 2 0 10 10 10 1010 10 5010 20 21 SKAAAA RFCAAA VVVVxx 7256 1500 0 0 6 16 56 256 1256 2256 7256 112 113 CTAAAA SFCAAA AAAAxx 961 1501 1 1 1 1 61 961 961 961 961 122 123 ZKAAAA TFCAAA HHHHxx 4182 1502 0 2 2 2 82 182 182 4182 4182 164 165 WEAAAA UFCAAA OOOOxx 639 1503 1 3 9 19 39 639 639 639 639 78 79 PYAAAA VFCAAA VVVVxx 8836 1504 0 0 6 16 36 836 836 3836 8836 72 73 WBAAAA WFCAAA AAAAxx 8705 1505 1 1 5 5 5 705 705 3705 8705 10 11 VWAAAA XFCAAA HHHHxx 32 1506 0 0 2 12 32 32 32 32 32 64 65 GBAAAA YFCAAA OOOOxx 7913 1507 1 1 3 13 13 913 1913 2913 7913 26 27 JSAAAA ZFCAAA VVVVxx 229 1508 1 1 9 9 29 229 229 229 229 58 59 VIAAAA AGCAAA AAAAxx 2393 1509 1 1 3 13 93 393 393 2393 2393 186 187 BOAAAA BGCAAA HHHHxx 2815 1510 1 3 5 15 15 815 815 2815 2815 30 31 HEAAAA CGCAAA OOOOxx 4858 1511 0 2 8 18 58 858 858 4858 4858 116 117 WEAAAA DGCAAA VVVVxx 6283 1512 1 3 3 3 83 283 283 1283 6283 166 167 RHAAAA EGCAAA AAAAxx 4147 1513 1 3 7 7 47 147 147 4147 4147 94 95 NDAAAA FGCAAA HHHHxx 6801 1514 1 1 1 1 1 801 801 1801 6801 2 3 PBAAAA GGCAAA OOOOxx 1011 1515 1 3 1 11 11 11 1011 1011 1011 22 23 XMAAAA HGCAAA VVVVxx 2527 1516 1 3 7 7 27 527 527 2527 2527 54 55 FTAAAA IGCAAA AAAAxx 381 1517 1 1 1 1 81 381 381 381 381 162 163 ROAAAA JGCAAA HHHHxx 3366 1518 0 2 6 6 66 366 1366 3366 3366 132 133 MZAAAA KGCAAA OOOOxx 9636 1519 0 0 6 16 36 636 1636 4636 9636 72 73 QGAAAA LGCAAA VVVVxx 2239 1520 1 3 9 19 39 239 239 2239 2239 78 79 DIAAAA MGCAAA AAAAxx 5911 1521 1 3 1 11 11 911 1911 911 5911 22 23 JTAAAA NGCAAA HHHHxx 449 1522 1 1 9 9 49 449 449 449 449 98 99 HRAAAA OGCAAA OOOOxx 5118 1523 0 2 8 18 18 118 1118 118 5118 36 37 WOAAAA PGCAAA VVVVxx 7684 1524 0 0 4 4 84 684 1684 2684 7684 168 169 OJAAAA QGCAAA AAAAxx 804 1525 0 0 4 4 4 804 804 804 804 8 9 YEAAAA RGCAAA HHHHxx 8378 1526 0 2 8 18 78 378 378 3378 8378 156 157 GKAAAA SGCAAA OOOOxx 9855 1527 1 3 5 15 55 855 1855 4855 9855 110 111 BPAAAA TGCAAA VVVVxx 1995 1528 1 3 5 15 95 995 1995 1995 1995 190 191 TYAAAA UGCAAA AAAAxx 1979 1529 1 3 9 19 79 979 1979 1979 1979 158 159 DYAAAA VGCAAA HHHHxx 4510 1530 0 2 0 10 10 510 510 4510 4510 20 21 MRAAAA WGCAAA OOOOxx 3792 1531 0 0 2 12 92 792 1792 3792 3792 184 185 WPAAAA XGCAAA VVVVxx 3541 1532 1 1 1 1 41 541 1541 3541 3541 82 83 FGAAAA YGCAAA AAAAxx 8847 1533 1 3 7 7 47 847 847 3847 8847 94 95 HCAAAA ZGCAAA HHHHxx 1336 1534 0 0 6 16 36 336 1336 1336 1336 72 73 KZAAAA AHCAAA OOOOxx 6780 1535 0 0 0 0 80 780 780 1780 6780 160 161 UAAAAA BHCAAA VVVVxx 8711 1536 1 3 1 11 11 711 711 3711 8711 22 23 BXAAAA CHCAAA AAAAxx 7839 1537 1 3 9 19 39 839 1839 2839 7839 78 79 NPAAAA DHCAAA HHHHxx 677 1538 1 1 7 17 77 677 677 677 677 154 155 BAAAAA EHCAAA OOOOxx 1574 1539 0 2 4 14 74 574 1574 1574 1574 148 149 OIAAAA FHCAAA VVVVxx 2905 1540 1 1 5 5 5 905 905 2905 2905 10 11 THAAAA GHCAAA AAAAxx 1879 1541 1 3 9 19 79 879 1879 1879 1879 158 159 HUAAAA HHCAAA HHHHxx 7820 1542 0 0 0 0 20 820 1820 2820 7820 40 41 UOAAAA IHCAAA OOOOxx 4308 1543 0 0 8 8 8 308 308 4308 4308 16 17 SJAAAA JHCAAA VVVVxx 4474 1544 0 2 4 14 74 474 474 4474 4474 148 149 CQAAAA KHCAAA AAAAxx 6985 1545 1 1 5 5 85 985 985 1985 6985 170 171 RIAAAA LHCAAA HHHHxx 6929 1546 1 1 9 9 29 929 929 1929 6929 58 59 NGAAAA MHCAAA OOOOxx 777 1547 1 1 7 17 77 777 777 777 777 154 155 XDAAAA NHCAAA VVVVxx 8271 1548 1 3 1 11 71 271 271 3271 8271 142 143 DGAAAA OHCAAA AAAAxx 2389 1549 1 1 9 9 89 389 389 2389 2389 178 179 XNAAAA PHCAAA HHHHxx 946 1550 0 2 6 6 46 946 946 946 946 92 93 KKAAAA QHCAAA OOOOxx 9682 1551 0 2 2 2 82 682 1682 4682 9682 164 165 KIAAAA RHCAAA VVVVxx 8722 1552 0 2 2 2 22 722 722 3722 8722 44 45 MXAAAA SHCAAA AAAAxx 470 1553 0 2 0 10 70 470 470 470 470 140 141 CSAAAA THCAAA HHHHxx 7425 1554 1 1 5 5 25 425 1425 2425 7425 50 51 PZAAAA UHCAAA OOOOxx 2372 1555 0 0 2 12 72 372 372 2372 2372 144 145 GNAAAA VHCAAA VVVVxx 508 1556 0 0 8 8 8 508 508 508 508 16 17 OTAAAA WHCAAA AAAAxx 163 1557 1 3 3 3 63 163 163 163 163 126 127 HGAAAA XHCAAA HHHHxx 6579 1558 1 3 9 19 79 579 579 1579 6579 158 159 BTAAAA YHCAAA OOOOxx 2355 1559 1 3 5 15 55 355 355 2355 2355 110 111 PMAAAA ZHCAAA VVVVxx 70 1560 0 2 0 10 70 70 70 70 70 140 141 SCAAAA AICAAA AAAAxx 651 1561 1 3 1 11 51 651 651 651 651 102 103 BZAAAA BICAAA HHHHxx 4436 1562 0 0 6 16 36 436 436 4436 4436 72 73 QOAAAA CICAAA OOOOxx 4240 1563 0 0 0 0 40 240 240 4240 4240 80 81 CHAAAA DICAAA VVVVxx 2722 1564 0 2 2 2 22 722 722 2722 2722 44 45 SAAAAA EICAAA AAAAxx 8937 1565 1 1 7 17 37 937 937 3937 8937 74 75 TFAAAA FICAAA HHHHxx 8364 1566 0 0 4 4 64 364 364 3364 8364 128 129 SJAAAA GICAAA OOOOxx 8317 1567 1 1 7 17 17 317 317 3317 8317 34 35 XHAAAA HICAAA VVVVxx 8872 1568 0 0 2 12 72 872 872 3872 8872 144 145 GDAAAA IICAAA AAAAxx 5512 1569 0 0 2 12 12 512 1512 512 5512 24 25 AEAAAA JICAAA HHHHxx 6651 1570 1 3 1 11 51 651 651 1651 6651 102 103 VVAAAA KICAAA OOOOxx 5976 1571 0 0 6 16 76 976 1976 976 5976 152 153 WVAAAA LICAAA VVVVxx 3301 1572 1 1 1 1 1 301 1301 3301 3301 2 3 ZWAAAA MICAAA AAAAxx 6784 1573 0 0 4 4 84 784 784 1784 6784 168 169 YAAAAA NICAAA HHHHxx 573 1574 1 1 3 13 73 573 573 573 573 146 147 BWAAAA OICAAA OOOOxx 3015 1575 1 3 5 15 15 15 1015 3015 3015 30 31 ZLAAAA PICAAA VVVVxx 8245 1576 1 1 5 5 45 245 245 3245 8245 90 91 DFAAAA QICAAA AAAAxx 5251 1577 1 3 1 11 51 251 1251 251 5251 102 103 ZTAAAA RICAAA HHHHxx 2281 1578 1 1 1 1 81 281 281 2281 2281 162 163 TJAAAA SICAAA OOOOxx 518 1579 0 2 8 18 18 518 518 518 518 36 37 YTAAAA TICAAA VVVVxx 9839 1580 1 3 9 19 39 839 1839 4839 9839 78 79 LOAAAA UICAAA AAAAxx 4526 1581 0 2 6 6 26 526 526 4526 4526 52 53 CSAAAA VICAAA HHHHxx 1261 1582 1 1 1 1 61 261 1261 1261 1261 122 123 NWAAAA WICAAA OOOOxx 4259 1583 1 3 9 19 59 259 259 4259 4259 118 119 VHAAAA XICAAA VVVVxx 9098 1584 0 2 8 18 98 98 1098 4098 9098 196 197 YLAAAA YICAAA AAAAxx 6037 1585 1 1 7 17 37 37 37 1037 6037 74 75 FYAAAA ZICAAA HHHHxx 4284 1586 0 0 4 4 84 284 284 4284 4284 168 169 UIAAAA AJCAAA OOOOxx 3267 1587 1 3 7 7 67 267 1267 3267 3267 134 135 RVAAAA BJCAAA VVVVxx 5908 1588 0 0 8 8 8 908 1908 908 5908 16 17 GTAAAA CJCAAA AAAAxx 1549 1589 1 1 9 9 49 549 1549 1549 1549 98 99 PHAAAA DJCAAA HHHHxx 8736 1590 0 0 6 16 36 736 736 3736 8736 72 73 AYAAAA EJCAAA OOOOxx 2008 1591 0 0 8 8 8 8 8 2008 2008 16 17 GZAAAA FJCAAA VVVVxx 548 1592 0 0 8 8 48 548 548 548 548 96 97 CVAAAA GJCAAA AAAAxx 8846 1593 0 2 6 6 46 846 846 3846 8846 92 93 GCAAAA HJCAAA HHHHxx 8374 1594 0 2 4 14 74 374 374 3374 8374 148 149 CKAAAA IJCAAA OOOOxx 7986 1595 0 2 6 6 86 986 1986 2986 7986 172 173 EVAAAA JJCAAA VVVVxx 6819 1596 1 3 9 19 19 819 819 1819 6819 38 39 HCAAAA KJCAAA AAAAxx 4418 1597 0 2 8 18 18 418 418 4418 4418 36 37 YNAAAA LJCAAA HHHHxx 833 1598 1 1 3 13 33 833 833 833 833 66 67 BGAAAA MJCAAA OOOOxx 4416 1599 0 0 6 16 16 416 416 4416 4416 32 33 WNAAAA NJCAAA VVVVxx 4902 1600 0 2 2 2 2 902 902 4902 4902 4 5 OGAAAA OJCAAA AAAAxx 6828 1601 0 0 8 8 28 828 828 1828 6828 56 57 QCAAAA PJCAAA HHHHxx 1118 1602 0 2 8 18 18 118 1118 1118 1118 36 37 ARAAAA QJCAAA OOOOxx 9993 1603 1 1 3 13 93 993 1993 4993 9993 186 187 JUAAAA RJCAAA VVVVxx 1430 1604 0 2 0 10 30 430 1430 1430 1430 60 61 ADAAAA SJCAAA AAAAxx 5670 1605 0 2 0 10 70 670 1670 670 5670 140 141 CKAAAA TJCAAA HHHHxx 5424 1606 0 0 4 4 24 424 1424 424 5424 48 49 QAAAAA UJCAAA OOOOxx 5561 1607 1 1 1 1 61 561 1561 561 5561 122 123 XFAAAA VJCAAA VVVVxx 2027 1608 1 3 7 7 27 27 27 2027 2027 54 55 ZZAAAA WJCAAA AAAAxx 6924 1609 0 0 4 4 24 924 924 1924 6924 48 49 IGAAAA XJCAAA HHHHxx 5946 1610 0 2 6 6 46 946 1946 946 5946 92 93 SUAAAA YJCAAA OOOOxx 4294 1611 0 2 4 14 94 294 294 4294 4294 188 189 EJAAAA ZJCAAA VVVVxx 2936 1612 0 0 6 16 36 936 936 2936 2936 72 73 YIAAAA AKCAAA AAAAxx 3855 1613 1 3 5 15 55 855 1855 3855 3855 110 111 HSAAAA BKCAAA HHHHxx 455 1614 1 3 5 15 55 455 455 455 455 110 111 NRAAAA CKCAAA OOOOxx 2918 1615 0 2 8 18 18 918 918 2918 2918 36 37 GIAAAA DKCAAA VVVVxx 448 1616 0 0 8 8 48 448 448 448 448 96 97 GRAAAA EKCAAA AAAAxx 2149 1617 1 1 9 9 49 149 149 2149 2149 98 99 REAAAA FKCAAA HHHHxx 8890 1618 0 2 0 10 90 890 890 3890 8890 180 181 YDAAAA GKCAAA OOOOxx 8919 1619 1 3 9 19 19 919 919 3919 8919 38 39 BFAAAA HKCAAA VVVVxx 4957 1620 1 1 7 17 57 957 957 4957 4957 114 115 RIAAAA IKCAAA AAAAxx 4 1621 0 0 4 4 4 4 4 4 4 8 9 EAAAAA JKCAAA HHHHxx 4837 1622 1 1 7 17 37 837 837 4837 4837 74 75 BEAAAA KKCAAA OOOOxx 3976 1623 0 0 6 16 76 976 1976 3976 3976 152 153 YWAAAA LKCAAA VVVVxx 9459 1624 1 3 9 19 59 459 1459 4459 9459 118 119 VZAAAA MKCAAA AAAAxx 7097 1625 1 1 7 17 97 97 1097 2097 7097 194 195 ZMAAAA NKCAAA HHHHxx 9226 1626 0 2 6 6 26 226 1226 4226 9226 52 53 WQAAAA OKCAAA OOOOxx 5803 1627 1 3 3 3 3 803 1803 803 5803 6 7 FPAAAA PKCAAA VVVVxx 21 1628 1 1 1 1 21 21 21 21 21 42 43 VAAAAA QKCAAA AAAAxx 5275 1629 1 3 5 15 75 275 1275 275 5275 150 151 XUAAAA RKCAAA HHHHxx 3488 1630 0 0 8 8 88 488 1488 3488 3488 176 177 EEAAAA SKCAAA OOOOxx 1595 1631 1 3 5 15 95 595 1595 1595 1595 190 191 JJAAAA TKCAAA VVVVxx 5212 1632 0 0 2 12 12 212 1212 212 5212 24 25 MSAAAA UKCAAA AAAAxx 6574 1633 0 2 4 14 74 574 574 1574 6574 148 149 WSAAAA VKCAAA HHHHxx 7524 1634 0 0 4 4 24 524 1524 2524 7524 48 49 KDAAAA WKCAAA OOOOxx 6100 1635 0 0 0 0 0 100 100 1100 6100 0 1 QAAAAA XKCAAA VVVVxx 1198 1636 0 2 8 18 98 198 1198 1198 1198 196 197 CUAAAA YKCAAA AAAAxx 7345 1637 1 1 5 5 45 345 1345 2345 7345 90 91 NWAAAA ZKCAAA HHHHxx 5020 1638 0 0 0 0 20 20 1020 20 5020 40 41 CLAAAA ALCAAA OOOOxx 6925 1639 1 1 5 5 25 925 925 1925 6925 50 51 JGAAAA BLCAAA VVVVxx 8915 1640 1 3 5 15 15 915 915 3915 8915 30 31 XEAAAA CLCAAA AAAAxx 3088 1641 0 0 8 8 88 88 1088 3088 3088 176 177 UOAAAA DLCAAA HHHHxx 4828 1642 0 0 8 8 28 828 828 4828 4828 56 57 SDAAAA ELCAAA OOOOxx 7276 1643 0 0 6 16 76 276 1276 2276 7276 152 153 WTAAAA FLCAAA VVVVxx 299 1644 1 3 9 19 99 299 299 299 299 198 199 NLAAAA GLCAAA AAAAxx 76 1645 0 0 6 16 76 76 76 76 76 152 153 YCAAAA HLCAAA HHHHxx 8458 1646 0 2 8 18 58 458 458 3458 8458 116 117 INAAAA ILCAAA OOOOxx 7207 1647 1 3 7 7 7 207 1207 2207 7207 14 15 FRAAAA JLCAAA VVVVxx 5585 1648 1 1 5 5 85 585 1585 585 5585 170 171 VGAAAA KLCAAA AAAAxx 3234 1649 0 2 4 14 34 234 1234 3234 3234 68 69 KUAAAA LLCAAA HHHHxx 8001 1650 1 1 1 1 1 1 1 3001 8001 2 3 TVAAAA MLCAAA OOOOxx 1319 1651 1 3 9 19 19 319 1319 1319 1319 38 39 TYAAAA NLCAAA VVVVxx 6342 1652 0 2 2 2 42 342 342 1342 6342 84 85 YJAAAA OLCAAA AAAAxx 9199 1653 1 3 9 19 99 199 1199 4199 9199 198 199 VPAAAA PLCAAA HHHHxx 5696 1654 0 0 6 16 96 696 1696 696 5696 192 193 CLAAAA QLCAAA OOOOxx 2562 1655 0 2 2 2 62 562 562 2562 2562 124 125 OUAAAA RLCAAA VVVVxx 4226 1656 0 2 6 6 26 226 226 4226 4226 52 53 OGAAAA SLCAAA AAAAxx 1184 1657 0 0 4 4 84 184 1184 1184 1184 168 169 OTAAAA TLCAAA HHHHxx 5807 1658 1 3 7 7 7 807 1807 807 5807 14 15 JPAAAA ULCAAA OOOOxx 1890 1659 0 2 0 10 90 890 1890 1890 1890 180 181 SUAAAA VLCAAA VVVVxx 451 1660 1 3 1 11 51 451 451 451 451 102 103 JRAAAA WLCAAA AAAAxx 1049 1661 1 1 9 9 49 49 1049 1049 1049 98 99 JOAAAA XLCAAA HHHHxx 5272 1662 0 0 2 12 72 272 1272 272 5272 144 145 UUAAAA YLCAAA OOOOxx 4588 1663 0 0 8 8 88 588 588 4588 4588 176 177 MUAAAA ZLCAAA VVVVxx 5213 1664 1 1 3 13 13 213 1213 213 5213 26 27 NSAAAA AMCAAA AAAAxx 9543 1665 1 3 3 3 43 543 1543 4543 9543 86 87 BDAAAA BMCAAA HHHHxx 6318 1666 0 2 8 18 18 318 318 1318 6318 36 37 AJAAAA CMCAAA OOOOxx 7992 1667 0 0 2 12 92 992 1992 2992 7992 184 185 KVAAAA DMCAAA VVVVxx 4619 1668 1 3 9 19 19 619 619 4619 4619 38 39 RVAAAA EMCAAA AAAAxx 7189 1669 1 1 9 9 89 189 1189 2189 7189 178 179 NQAAAA FMCAAA HHHHxx 2178 1670 0 2 8 18 78 178 178 2178 2178 156 157 UFAAAA GMCAAA OOOOxx 4928 1671 0 0 8 8 28 928 928 4928 4928 56 57 OHAAAA HMCAAA VVVVxx 3966 1672 0 2 6 6 66 966 1966 3966 3966 132 133 OWAAAA IMCAAA AAAAxx 9790 1673 0 2 0 10 90 790 1790 4790 9790 180 181 OMAAAA JMCAAA HHHHxx 9150 1674 0 2 0 10 50 150 1150 4150 9150 100 101 YNAAAA KMCAAA OOOOxx 313 1675 1 1 3 13 13 313 313 313 313 26 27 BMAAAA LMCAAA VVVVxx 1614 1676 0 2 4 14 14 614 1614 1614 1614 28 29 CKAAAA MMCAAA AAAAxx 1581 1677 1 1 1 1 81 581 1581 1581 1581 162 163 VIAAAA NMCAAA HHHHxx 3674 1678 0 2 4 14 74 674 1674 3674 3674 148 149 ILAAAA OMCAAA OOOOxx 3444 1679 0 0 4 4 44 444 1444 3444 3444 88 89 MCAAAA PMCAAA VVVVxx 1050 1680 0 2 0 10 50 50 1050 1050 1050 100 101 KOAAAA QMCAAA AAAAxx 8241 1681 1 1 1 1 41 241 241 3241 8241 82 83 ZEAAAA RMCAAA HHHHxx 3382 1682 0 2 2 2 82 382 1382 3382 3382 164 165 CAAAAA SMCAAA OOOOxx 7105 1683 1 1 5 5 5 105 1105 2105 7105 10 11 HNAAAA TMCAAA VVVVxx 2957 1684 1 1 7 17 57 957 957 2957 2957 114 115 TJAAAA UMCAAA AAAAxx 6162 1685 0 2 2 2 62 162 162 1162 6162 124 125 ADAAAA VMCAAA HHHHxx 5150 1686 0 2 0 10 50 150 1150 150 5150 100 101 CQAAAA WMCAAA OOOOxx 2622 1687 0 2 2 2 22 622 622 2622 2622 44 45 WWAAAA XMCAAA VVVVxx 2240 1688 0 0 0 0 40 240 240 2240 2240 80 81 EIAAAA YMCAAA AAAAxx 8880 1689 0 0 0 0 80 880 880 3880 8880 160 161 ODAAAA ZMCAAA HHHHxx 9250 1690 0 2 0 10 50 250 1250 4250 9250 100 101 URAAAA ANCAAA OOOOxx 7010 1691 0 2 0 10 10 10 1010 2010 7010 20 21 QJAAAA BNCAAA VVVVxx 1098 1692 0 2 8 18 98 98 1098 1098 1098 196 197 GQAAAA CNCAAA AAAAxx 648 1693 0 0 8 8 48 648 648 648 648 96 97 YYAAAA DNCAAA HHHHxx 5536 1694 0 0 6 16 36 536 1536 536 5536 72 73 YEAAAA ENCAAA OOOOxx 7858 1695 0 2 8 18 58 858 1858 2858 7858 116 117 GQAAAA FNCAAA VVVVxx 7053 1696 1 1 3 13 53 53 1053 2053 7053 106 107 HLAAAA GNCAAA AAAAxx 8681 1697 1 1 1 1 81 681 681 3681 8681 162 163 XVAAAA HNCAAA HHHHxx 8832 1698 0 0 2 12 32 832 832 3832 8832 64 65 SBAAAA INCAAA OOOOxx 6836 1699 0 0 6 16 36 836 836 1836 6836 72 73 YCAAAA JNCAAA VVVVxx 4856 1700 0 0 6 16 56 856 856 4856 4856 112 113 UEAAAA KNCAAA AAAAxx 345 1701 1 1 5 5 45 345 345 345 345 90 91 HNAAAA LNCAAA HHHHxx 6559 1702 1 3 9 19 59 559 559 1559 6559 118 119 HSAAAA MNCAAA OOOOxx 3017 1703 1 1 7 17 17 17 1017 3017 3017 34 35 BMAAAA NNCAAA VVVVxx 4176 1704 0 0 6 16 76 176 176 4176 4176 152 153 QEAAAA ONCAAA AAAAxx 2839 1705 1 3 9 19 39 839 839 2839 2839 78 79 FFAAAA PNCAAA HHHHxx 6065 1706 1 1 5 5 65 65 65 1065 6065 130 131 HZAAAA QNCAAA OOOOxx 7360 1707 0 0 0 0 60 360 1360 2360 7360 120 121 CXAAAA RNCAAA VVVVxx 9527 1708 1 3 7 7 27 527 1527 4527 9527 54 55 LCAAAA SNCAAA AAAAxx 8849 1709 1 1 9 9 49 849 849 3849 8849 98 99 JCAAAA TNCAAA HHHHxx 7274 1710 0 2 4 14 74 274 1274 2274 7274 148 149 UTAAAA UNCAAA OOOOxx 4368 1711 0 0 8 8 68 368 368 4368 4368 136 137 AMAAAA VNCAAA VVVVxx 2488 1712 0 0 8 8 88 488 488 2488 2488 176 177 SRAAAA WNCAAA AAAAxx 4674 1713 0 2 4 14 74 674 674 4674 4674 148 149 UXAAAA XNCAAA HHHHxx 365 1714 1 1 5 5 65 365 365 365 365 130 131 BOAAAA YNCAAA OOOOxx 5897 1715 1 1 7 17 97 897 1897 897 5897 194 195 VSAAAA ZNCAAA VVVVxx 8918 1716 0 2 8 18 18 918 918 3918 8918 36 37 AFAAAA AOCAAA AAAAxx 1988 1717 0 0 8 8 88 988 1988 1988 1988 176 177 MYAAAA BOCAAA HHHHxx 1210 1718 0 2 0 10 10 210 1210 1210 1210 20 21 OUAAAA COCAAA OOOOxx 2945 1719 1 1 5 5 45 945 945 2945 2945 90 91 HJAAAA DOCAAA VVVVxx 555 1720 1 3 5 15 55 555 555 555 555 110 111 JVAAAA EOCAAA AAAAxx 9615 1721 1 3 5 15 15 615 1615 4615 9615 30 31 VFAAAA FOCAAA HHHHxx 9939 1722 1 3 9 19 39 939 1939 4939 9939 78 79 HSAAAA GOCAAA OOOOxx 1216 1723 0 0 6 16 16 216 1216 1216 1216 32 33 UUAAAA HOCAAA VVVVxx 745 1724 1 1 5 5 45 745 745 745 745 90 91 RCAAAA IOCAAA AAAAxx 3326 1725 0 2 6 6 26 326 1326 3326 3326 52 53 YXAAAA JOCAAA HHHHxx 953 1726 1 1 3 13 53 953 953 953 953 106 107 RKAAAA KOCAAA OOOOxx 444 1727 0 0 4 4 44 444 444 444 444 88 89 CRAAAA LOCAAA VVVVxx 280 1728 0 0 0 0 80 280 280 280 280 160 161 UKAAAA MOCAAA AAAAxx 3707 1729 1 3 7 7 7 707 1707 3707 3707 14 15 PMAAAA NOCAAA HHHHxx 1351 1730 1 3 1 11 51 351 1351 1351 1351 102 103 ZZAAAA OOCAAA OOOOxx 1280 1731 0 0 0 0 80 280 1280 1280 1280 160 161 GXAAAA POCAAA VVVVxx 628 1732 0 0 8 8 28 628 628 628 628 56 57 EYAAAA QOCAAA AAAAxx 6198 1733 0 2 8 18 98 198 198 1198 6198 196 197 KEAAAA ROCAAA HHHHxx 1957 1734 1 1 7 17 57 957 1957 1957 1957 114 115 HXAAAA SOCAAA OOOOxx 9241 1735 1 1 1 1 41 241 1241 4241 9241 82 83 LRAAAA TOCAAA VVVVxx 303 1736 1 3 3 3 3 303 303 303 303 6 7 RLAAAA UOCAAA AAAAxx 1945 1737 1 1 5 5 45 945 1945 1945 1945 90 91 VWAAAA VOCAAA HHHHxx 3634 1738 0 2 4 14 34 634 1634 3634 3634 68 69 UJAAAA WOCAAA OOOOxx 4768 1739 0 0 8 8 68 768 768 4768 4768 136 137 KBAAAA XOCAAA VVVVxx 9262 1740 0 2 2 2 62 262 1262 4262 9262 124 125 GSAAAA YOCAAA AAAAxx 2610 1741 0 2 0 10 10 610 610 2610 2610 20 21 KWAAAA ZOCAAA HHHHxx 6640 1742 0 0 0 0 40 640 640 1640 6640 80 81 KVAAAA APCAAA OOOOxx 3338 1743 0 2 8 18 38 338 1338 3338 3338 76 77 KYAAAA BPCAAA VVVVxx 6560 1744 0 0 0 0 60 560 560 1560 6560 120 121 ISAAAA CPCAAA AAAAxx 5986 1745 0 2 6 6 86 986 1986 986 5986 172 173 GWAAAA DPCAAA HHHHxx 2970 1746 0 2 0 10 70 970 970 2970 2970 140 141 GKAAAA EPCAAA OOOOxx 4731 1747 1 3 1 11 31 731 731 4731 4731 62 63 ZZAAAA FPCAAA VVVVxx 9486 1748 0 2 6 6 86 486 1486 4486 9486 172 173 WAAAAA GPCAAA AAAAxx 7204 1749 0 0 4 4 4 204 1204 2204 7204 8 9 CRAAAA HPCAAA HHHHxx 6685 1750 1 1 5 5 85 685 685 1685 6685 170 171 DXAAAA IPCAAA OOOOxx 6852 1751 0 0 2 12 52 852 852 1852 6852 104 105 ODAAAA JPCAAA VVVVxx 2325 1752 1 1 5 5 25 325 325 2325 2325 50 51 LLAAAA KPCAAA AAAAxx 1063 1753 1 3 3 3 63 63 1063 1063 1063 126 127 XOAAAA LPCAAA HHHHxx 6810 1754 0 2 0 10 10 810 810 1810 6810 20 21 YBAAAA MPCAAA OOOOxx 7718 1755 0 2 8 18 18 718 1718 2718 7718 36 37 WKAAAA NPCAAA VVVVxx 1680 1756 0 0 0 0 80 680 1680 1680 1680 160 161 QMAAAA OPCAAA AAAAxx 7402 1757 0 2 2 2 2 402 1402 2402 7402 4 5 SYAAAA PPCAAA HHHHxx 4134 1758 0 2 4 14 34 134 134 4134 4134 68 69 ADAAAA QPCAAA OOOOxx 8232 1759 0 0 2 12 32 232 232 3232 8232 64 65 QEAAAA RPCAAA VVVVxx 6682 1760 0 2 2 2 82 682 682 1682 6682 164 165 AXAAAA SPCAAA AAAAxx 7952 1761 0 0 2 12 52 952 1952 2952 7952 104 105 WTAAAA TPCAAA HHHHxx 5943 1762 1 3 3 3 43 943 1943 943 5943 86 87 PUAAAA UPCAAA OOOOxx 5394 1763 0 2 4 14 94 394 1394 394 5394 188 189 MZAAAA VPCAAA VVVVxx 6554 1764 0 2 4 14 54 554 554 1554 6554 108 109 CSAAAA WPCAAA AAAAxx 8186 1765 0 2 6 6 86 186 186 3186 8186 172 173 WCAAAA XPCAAA HHHHxx 199 1766 1 3 9 19 99 199 199 199 199 198 199 RHAAAA YPCAAA OOOOxx 3386 1767 0 2 6 6 86 386 1386 3386 3386 172 173 GAAAAA ZPCAAA VVVVxx 8974 1768 0 2 4 14 74 974 974 3974 8974 148 149 EHAAAA AQCAAA AAAAxx 8140 1769 0 0 0 0 40 140 140 3140 8140 80 81 CBAAAA BQCAAA HHHHxx 3723 1770 1 3 3 3 23 723 1723 3723 3723 46 47 FNAAAA CQCAAA OOOOxx 8827 1771 1 3 7 7 27 827 827 3827 8827 54 55 NBAAAA DQCAAA VVVVxx 1998 1772 0 2 8 18 98 998 1998 1998 1998 196 197 WYAAAA EQCAAA AAAAxx 879 1773 1 3 9 19 79 879 879 879 879 158 159 VHAAAA FQCAAA HHHHxx 892 1774 0 0 2 12 92 892 892 892 892 184 185 IIAAAA GQCAAA OOOOxx 9468 1775 0 0 8 8 68 468 1468 4468 9468 136 137 EAAAAA HQCAAA VVVVxx 3797 1776 1 1 7 17 97 797 1797 3797 3797 194 195 BQAAAA IQCAAA AAAAxx 8379 1777 1 3 9 19 79 379 379 3379 8379 158 159 HKAAAA JQCAAA HHHHxx 2817 1778 1 1 7 17 17 817 817 2817 2817 34 35 JEAAAA KQCAAA OOOOxx 789 1779 1 1 9 9 89 789 789 789 789 178 179 JEAAAA LQCAAA VVVVxx 3871 1780 1 3 1 11 71 871 1871 3871 3871 142 143 XSAAAA MQCAAA AAAAxx 7931 1781 1 3 1 11 31 931 1931 2931 7931 62 63 BTAAAA NQCAAA HHHHxx 3636 1782 0 0 6 16 36 636 1636 3636 3636 72 73 WJAAAA OQCAAA OOOOxx 699 1783 1 3 9 19 99 699 699 699 699 198 199 XAAAAA PQCAAA VVVVxx 6850 1784 0 2 0 10 50 850 850 1850 6850 100 101 MDAAAA QQCAAA AAAAxx 6394 1785 0 2 4 14 94 394 394 1394 6394 188 189 YLAAAA RQCAAA HHHHxx 3475 1786 1 3 5 15 75 475 1475 3475 3475 150 151 RDAAAA SQCAAA OOOOxx 3026 1787 0 2 6 6 26 26 1026 3026 3026 52 53 KMAAAA TQCAAA VVVVxx 876 1788 0 0 6 16 76 876 876 876 876 152 153 SHAAAA UQCAAA AAAAxx 1992 1789 0 0 2 12 92 992 1992 1992 1992 184 185 QYAAAA VQCAAA HHHHxx 3079 1790 1 3 9 19 79 79 1079 3079 3079 158 159 LOAAAA WQCAAA OOOOxx 8128 1791 0 0 8 8 28 128 128 3128 8128 56 57 QAAAAA XQCAAA VVVVxx 8123 1792 1 3 3 3 23 123 123 3123 8123 46 47 LAAAAA YQCAAA AAAAxx 3285 1793 1 1 5 5 85 285 1285 3285 3285 170 171 JWAAAA ZQCAAA HHHHxx 9315 1794 1 3 5 15 15 315 1315 4315 9315 30 31 HUAAAA ARCAAA OOOOxx 9862 1795 0 2 2 2 62 862 1862 4862 9862 124 125 IPAAAA BRCAAA VVVVxx 2764 1796 0 0 4 4 64 764 764 2764 2764 128 129 ICAAAA CRCAAA AAAAxx 3544 1797 0 0 4 4 44 544 1544 3544 3544 88 89 IGAAAA DRCAAA HHHHxx 7747 1798 1 3 7 7 47 747 1747 2747 7747 94 95 ZLAAAA ERCAAA OOOOxx 7725 1799 1 1 5 5 25 725 1725 2725 7725 50 51 DLAAAA FRCAAA VVVVxx 2449 1800 1 1 9 9 49 449 449 2449 2449 98 99 FQAAAA GRCAAA AAAAxx 8967 1801 1 3 7 7 67 967 967 3967 8967 134 135 XGAAAA HRCAAA HHHHxx 7371 1802 1 3 1 11 71 371 1371 2371 7371 142 143 NXAAAA IRCAAA OOOOxx 2158 1803 0 2 8 18 58 158 158 2158 2158 116 117 AFAAAA JRCAAA VVVVxx 5590 1804 0 2 0 10 90 590 1590 590 5590 180 181 AHAAAA KRCAAA AAAAxx 8072 1805 0 0 2 12 72 72 72 3072 8072 144 145 MYAAAA LRCAAA HHHHxx 1971 1806 1 3 1 11 71 971 1971 1971 1971 142 143 VXAAAA MRCAAA OOOOxx 772 1807 0 0 2 12 72 772 772 772 772 144 145 SDAAAA NRCAAA VVVVxx 3433 1808 1 1 3 13 33 433 1433 3433 3433 66 67 BCAAAA ORCAAA AAAAxx 8419 1809 1 3 9 19 19 419 419 3419 8419 38 39 VLAAAA PRCAAA HHHHxx 1493 1810 1 1 3 13 93 493 1493 1493 1493 186 187 LFAAAA QRCAAA OOOOxx 2584 1811 0 0 4 4 84 584 584 2584 2584 168 169 KVAAAA RRCAAA VVVVxx 9502 1812 0 2 2 2 2 502 1502 4502 9502 4 5 MBAAAA SRCAAA AAAAxx 4673 1813 1 1 3 13 73 673 673 4673 4673 146 147 TXAAAA TRCAAA HHHHxx 7403 1814 1 3 3 3 3 403 1403 2403 7403 6 7 TYAAAA URCAAA OOOOxx 7103 1815 1 3 3 3 3 103 1103 2103 7103 6 7 FNAAAA VRCAAA VVVVxx 7026 1816 0 2 6 6 26 26 1026 2026 7026 52 53 GKAAAA WRCAAA AAAAxx 8574 1817 0 2 4 14 74 574 574 3574 8574 148 149 URAAAA XRCAAA HHHHxx 1366 1818 0 2 6 6 66 366 1366 1366 1366 132 133 OAAAAA YRCAAA OOOOxx 5787 1819 1 3 7 7 87 787 1787 787 5787 174 175 POAAAA ZRCAAA VVVVxx 2552 1820 0 0 2 12 52 552 552 2552 2552 104 105 EUAAAA ASCAAA AAAAxx 4557 1821 1 1 7 17 57 557 557 4557 4557 114 115 HTAAAA BSCAAA HHHHxx 3237 1822 1 1 7 17 37 237 1237 3237 3237 74 75 NUAAAA CSCAAA OOOOxx 6901 1823 1 1 1 1 1 901 901 1901 6901 2 3 LFAAAA DSCAAA VVVVxx 7708 1824 0 0 8 8 8 708 1708 2708 7708 16 17 MKAAAA ESCAAA AAAAxx 2011 1825 1 3 1 11 11 11 11 2011 2011 22 23 JZAAAA FSCAAA HHHHxx 9455 1826 1 3 5 15 55 455 1455 4455 9455 110 111 RZAAAA GSCAAA OOOOxx 5228 1827 0 0 8 8 28 228 1228 228 5228 56 57 CTAAAA HSCAAA VVVVxx 4043 1828 1 3 3 3 43 43 43 4043 4043 86 87 NZAAAA ISCAAA AAAAxx 8242 1829 0 2 2 2 42 242 242 3242 8242 84 85 AFAAAA JSCAAA HHHHxx 6351 1830 1 3 1 11 51 351 351 1351 6351 102 103 HKAAAA KSCAAA OOOOxx 5899 1831 1 3 9 19 99 899 1899 899 5899 198 199 XSAAAA LSCAAA VVVVxx 4849 1832 1 1 9 9 49 849 849 4849 4849 98 99 NEAAAA MSCAAA AAAAxx 9583 1833 1 3 3 3 83 583 1583 4583 9583 166 167 PEAAAA NSCAAA HHHHxx 4994 1834 0 2 4 14 94 994 994 4994 4994 188 189 CKAAAA OSCAAA OOOOxx 9787 1835 1 3 7 7 87 787 1787 4787 9787 174 175 LMAAAA PSCAAA VVVVxx 243 1836 1 3 3 3 43 243 243 243 243 86 87 JJAAAA QSCAAA AAAAxx 3931 1837 1 3 1 11 31 931 1931 3931 3931 62 63 FVAAAA RSCAAA HHHHxx 5945 1838 1 1 5 5 45 945 1945 945 5945 90 91 RUAAAA SSCAAA OOOOxx 1325 1839 1 1 5 5 25 325 1325 1325 1325 50 51 ZYAAAA TSCAAA VVVVxx 4142 1840 0 2 2 2 42 142 142 4142 4142 84 85 IDAAAA USCAAA AAAAxx 1963 1841 1 3 3 3 63 963 1963 1963 1963 126 127 NXAAAA VSCAAA HHHHxx 7041 1842 1 1 1 1 41 41 1041 2041 7041 82 83 VKAAAA WSCAAA OOOOxx 3074 1843 0 2 4 14 74 74 1074 3074 3074 148 149 GOAAAA XSCAAA VVVVxx 3290 1844 0 2 0 10 90 290 1290 3290 3290 180 181 OWAAAA YSCAAA AAAAxx 4146 1845 0 2 6 6 46 146 146 4146 4146 92 93 MDAAAA ZSCAAA HHHHxx 3832 1846 0 0 2 12 32 832 1832 3832 3832 64 65 KRAAAA ATCAAA OOOOxx 2217 1847 1 1 7 17 17 217 217 2217 2217 34 35 HHAAAA BTCAAA VVVVxx 635 1848 1 3 5 15 35 635 635 635 635 70 71 LYAAAA CTCAAA AAAAxx 6967 1849 1 3 7 7 67 967 967 1967 6967 134 135 ZHAAAA DTCAAA HHHHxx 3522 1850 0 2 2 2 22 522 1522 3522 3522 44 45 MFAAAA ETCAAA OOOOxx 2471 1851 1 3 1 11 71 471 471 2471 2471 142 143 BRAAAA FTCAAA VVVVxx 4236 1852 0 0 6 16 36 236 236 4236 4236 72 73 YGAAAA GTCAAA AAAAxx 853 1853 1 1 3 13 53 853 853 853 853 106 107 VGAAAA HTCAAA HHHHxx 3754 1854 0 2 4 14 54 754 1754 3754 3754 108 109 KOAAAA ITCAAA OOOOxx 796 1855 0 0 6 16 96 796 796 796 796 192 193 QEAAAA JTCAAA VVVVxx 4640 1856 0 0 0 0 40 640 640 4640 4640 80 81 MWAAAA KTCAAA AAAAxx 9496 1857 0 0 6 16 96 496 1496 4496 9496 192 193 GBAAAA LTCAAA HHHHxx 6873 1858 1 1 3 13 73 873 873 1873 6873 146 147 JEAAAA MTCAAA OOOOxx 4632 1859 0 0 2 12 32 632 632 4632 4632 64 65 EWAAAA NTCAAA VVVVxx 5758 1860 0 2 8 18 58 758 1758 758 5758 116 117 MNAAAA OTCAAA AAAAxx 6514 1861 0 2 4 14 14 514 514 1514 6514 28 29 OQAAAA PTCAAA HHHHxx 9510 1862 0 2 0 10 10 510 1510 4510 9510 20 21 UBAAAA QTCAAA OOOOxx 8411 1863 1 3 1 11 11 411 411 3411 8411 22 23 NLAAAA RTCAAA VVVVxx 7762 1864 0 2 2 2 62 762 1762 2762 7762 124 125 OMAAAA STCAAA AAAAxx 2225 1865 1 1 5 5 25 225 225 2225 2225 50 51 PHAAAA TTCAAA HHHHxx 4373 1866 1 1 3 13 73 373 373 4373 4373 146 147 FMAAAA UTCAAA OOOOxx 7326 1867 0 2 6 6 26 326 1326 2326 7326 52 53 UVAAAA VTCAAA VVVVxx 8651 1868 1 3 1 11 51 651 651 3651 8651 102 103 TUAAAA WTCAAA AAAAxx 9825 1869 1 1 5 5 25 825 1825 4825 9825 50 51 XNAAAA XTCAAA HHHHxx 2988 1870 0 0 8 8 88 988 988 2988 2988 176 177 YKAAAA YTCAAA OOOOxx 8138 1871 0 2 8 18 38 138 138 3138 8138 76 77 ABAAAA ZTCAAA VVVVxx 7792 1872 0 0 2 12 92 792 1792 2792 7792 184 185 SNAAAA AUCAAA AAAAxx 1232 1873 0 0 2 12 32 232 1232 1232 1232 64 65 KVAAAA BUCAAA HHHHxx 8221 1874 1 1 1 1 21 221 221 3221 8221 42 43 FEAAAA CUCAAA OOOOxx 4044 1875 0 0 4 4 44 44 44 4044 4044 88 89 OZAAAA DUCAAA VVVVxx 1204 1876 0 0 4 4 4 204 1204 1204 1204 8 9 IUAAAA EUCAAA AAAAxx 5145 1877 1 1 5 5 45 145 1145 145 5145 90 91 XPAAAA FUCAAA HHHHxx 7791 1878 1 3 1 11 91 791 1791 2791 7791 182 183 RNAAAA GUCAAA OOOOxx 8270 1879 0 2 0 10 70 270 270 3270 8270 140 141 CGAAAA HUCAAA VVVVxx 9427 1880 1 3 7 7 27 427 1427 4427 9427 54 55 PYAAAA IUCAAA AAAAxx 2152 1881 0 0 2 12 52 152 152 2152 2152 104 105 UEAAAA JUCAAA HHHHxx 7790 1882 0 2 0 10 90 790 1790 2790 7790 180 181 QNAAAA KUCAAA OOOOxx 5301 1883 1 1 1 1 1 301 1301 301 5301 2 3 XVAAAA LUCAAA VVVVxx 626 1884 0 2 6 6 26 626 626 626 626 52 53 CYAAAA MUCAAA AAAAxx 260 1885 0 0 0 0 60 260 260 260 260 120 121 AKAAAA NUCAAA HHHHxx 4369 1886 1 1 9 9 69 369 369 4369 4369 138 139 BMAAAA OUCAAA OOOOxx 5457 1887 1 1 7 17 57 457 1457 457 5457 114 115 XBAAAA PUCAAA VVVVxx 3468 1888 0 0 8 8 68 468 1468 3468 3468 136 137 KDAAAA QUCAAA AAAAxx 2257 1889 1 1 7 17 57 257 257 2257 2257 114 115 VIAAAA RUCAAA HHHHxx 9318 1890 0 2 8 18 18 318 1318 4318 9318 36 37 KUAAAA SUCAAA OOOOxx 8762 1891 0 2 2 2 62 762 762 3762 8762 124 125 AZAAAA TUCAAA VVVVxx 9153 1892 1 1 3 13 53 153 1153 4153 9153 106 107 BOAAAA UUCAAA AAAAxx 9220 1893 0 0 0 0 20 220 1220 4220 9220 40 41 QQAAAA VUCAAA HHHHxx 8003 1894 1 3 3 3 3 3 3 3003 8003 6 7 VVAAAA WUCAAA OOOOxx 7257 1895 1 1 7 17 57 257 1257 2257 7257 114 115 DTAAAA XUCAAA VVVVxx 3930 1896 0 2 0 10 30 930 1930 3930 3930 60 61 EVAAAA YUCAAA AAAAxx 2976 1897 0 0 6 16 76 976 976 2976 2976 152 153 MKAAAA ZUCAAA HHHHxx 2531 1898 1 3 1 11 31 531 531 2531 2531 62 63 JTAAAA AVCAAA OOOOxx 2250 1899 0 2 0 10 50 250 250 2250 2250 100 101 OIAAAA BVCAAA VVVVxx 8549 1900 1 1 9 9 49 549 549 3549 8549 98 99 VQAAAA CVCAAA AAAAxx 7197 1901 1 1 7 17 97 197 1197 2197 7197 194 195 VQAAAA DVCAAA HHHHxx 5916 1902 0 0 6 16 16 916 1916 916 5916 32 33 OTAAAA EVCAAA OOOOxx 5287 1903 1 3 7 7 87 287 1287 287 5287 174 175 JVAAAA FVCAAA VVVVxx 9095 1904 1 3 5 15 95 95 1095 4095 9095 190 191 VLAAAA GVCAAA AAAAxx 7137 1905 1 1 7 17 37 137 1137 2137 7137 74 75 NOAAAA HVCAAA HHHHxx 7902 1906 0 2 2 2 2 902 1902 2902 7902 4 5 YRAAAA IVCAAA OOOOxx 7598 1907 0 2 8 18 98 598 1598 2598 7598 196 197 GGAAAA JVCAAA VVVVxx 5652 1908 0 0 2 12 52 652 1652 652 5652 104 105 KJAAAA KVCAAA AAAAxx 2017 1909 1 1 7 17 17 17 17 2017 2017 34 35 PZAAAA LVCAAA HHHHxx 7255 1910 1 3 5 15 55 255 1255 2255 7255 110 111 BTAAAA MVCAAA OOOOxx 7999 1911 1 3 9 19 99 999 1999 2999 7999 198 199 RVAAAA NVCAAA VVVVxx 5388 1912 0 0 8 8 88 388 1388 388 5388 176 177 GZAAAA OVCAAA AAAAxx 8754 1913 0 2 4 14 54 754 754 3754 8754 108 109 SYAAAA PVCAAA HHHHxx 5415 1914 1 3 5 15 15 415 1415 415 5415 30 31 HAAAAA QVCAAA OOOOxx 8861 1915 1 1 1 1 61 861 861 3861 8861 122 123 VCAAAA RVCAAA VVVVxx 2874 1916 0 2 4 14 74 874 874 2874 2874 148 149 OGAAAA SVCAAA AAAAxx 9910 1917 0 2 0 10 10 910 1910 4910 9910 20 21 ERAAAA TVCAAA HHHHxx 5178 1918 0 2 8 18 78 178 1178 178 5178 156 157 ERAAAA UVCAAA OOOOxx 5698 1919 0 2 8 18 98 698 1698 698 5698 196 197 ELAAAA VVCAAA VVVVxx 8500 1920 0 0 0 0 0 500 500 3500 8500 0 1 YOAAAA WVCAAA AAAAxx 1814 1921 0 2 4 14 14 814 1814 1814 1814 28 29 URAAAA XVCAAA HHHHxx 4968 1922 0 0 8 8 68 968 968 4968 4968 136 137 CJAAAA YVCAAA OOOOxx 2642 1923 0 2 2 2 42 642 642 2642 2642 84 85 QXAAAA ZVCAAA VVVVxx 1578 1924 0 2 8 18 78 578 1578 1578 1578 156 157 SIAAAA AWCAAA AAAAxx 4774 1925 0 2 4 14 74 774 774 4774 4774 148 149 QBAAAA BWCAAA HHHHxx 7062 1926 0 2 2 2 62 62 1062 2062 7062 124 125 QLAAAA CWCAAA OOOOxx 5381 1927 1 1 1 1 81 381 1381 381 5381 162 163 ZYAAAA DWCAAA VVVVxx 7985 1928 1 1 5 5 85 985 1985 2985 7985 170 171 DVAAAA EWCAAA AAAAxx 3850 1929 0 2 0 10 50 850 1850 3850 3850 100 101 CSAAAA FWCAAA HHHHxx 5624 1930 0 0 4 4 24 624 1624 624 5624 48 49 IIAAAA GWCAAA OOOOxx 8948 1931 0 0 8 8 48 948 948 3948 8948 96 97 EGAAAA HWCAAA VVVVxx 995 1932 1 3 5 15 95 995 995 995 995 190 191 HMAAAA IWCAAA AAAAxx 5058 1933 0 2 8 18 58 58 1058 58 5058 116 117 OMAAAA JWCAAA HHHHxx 9670 1934 0 2 0 10 70 670 1670 4670 9670 140 141 YHAAAA KWCAAA OOOOxx 3115 1935 1 3 5 15 15 115 1115 3115 3115 30 31 VPAAAA LWCAAA VVVVxx 4935 1936 1 3 5 15 35 935 935 4935 4935 70 71 VHAAAA MWCAAA AAAAxx 4735 1937 1 3 5 15 35 735 735 4735 4735 70 71 DAAAAA NWCAAA HHHHxx 1348 1938 0 0 8 8 48 348 1348 1348 1348 96 97 WZAAAA OWCAAA OOOOxx 2380 1939 0 0 0 0 80 380 380 2380 2380 160 161 ONAAAA PWCAAA VVVVxx 4246 1940 0 2 6 6 46 246 246 4246 4246 92 93 IHAAAA QWCAAA AAAAxx 522 1941 0 2 2 2 22 522 522 522 522 44 45 CUAAAA RWCAAA HHHHxx 1701 1942 1 1 1 1 1 701 1701 1701 1701 2 3 LNAAAA SWCAAA OOOOxx 9709 1943 1 1 9 9 9 709 1709 4709 9709 18 19 LJAAAA TWCAAA VVVVxx 8829 1944 1 1 9 9 29 829 829 3829 8829 58 59 PBAAAA UWCAAA AAAAxx 7936 1945 0 0 6 16 36 936 1936 2936 7936 72 73 GTAAAA VWCAAA HHHHxx 8474 1946 0 2 4 14 74 474 474 3474 8474 148 149 YNAAAA WWCAAA OOOOxx 4676 1947 0 0 6 16 76 676 676 4676 4676 152 153 WXAAAA XWCAAA VVVVxx 6303 1948 1 3 3 3 3 303 303 1303 6303 6 7 LIAAAA YWCAAA AAAAxx 3485 1949 1 1 5 5 85 485 1485 3485 3485 170 171 BEAAAA ZWCAAA HHHHxx 2695 1950 1 3 5 15 95 695 695 2695 2695 190 191 RZAAAA AXCAAA OOOOxx 8830 1951 0 2 0 10 30 830 830 3830 8830 60 61 QBAAAA BXCAAA VVVVxx 898 1952 0 2 8 18 98 898 898 898 898 196 197 OIAAAA CXCAAA AAAAxx 7268 1953 0 0 8 8 68 268 1268 2268 7268 136 137 OTAAAA DXCAAA HHHHxx 6568 1954 0 0 8 8 68 568 568 1568 6568 136 137 QSAAAA EXCAAA OOOOxx 9724 1955 0 0 4 4 24 724 1724 4724 9724 48 49 AKAAAA FXCAAA VVVVxx 3329 1956 1 1 9 9 29 329 1329 3329 3329 58 59 BYAAAA GXCAAA AAAAxx 9860 1957 0 0 0 0 60 860 1860 4860 9860 120 121 GPAAAA HXCAAA HHHHxx 6833 1958 1 1 3 13 33 833 833 1833 6833 66 67 VCAAAA IXCAAA OOOOxx 5956 1959 0 0 6 16 56 956 1956 956 5956 112 113 CVAAAA JXCAAA VVVVxx 3963 1960 1 3 3 3 63 963 1963 3963 3963 126 127 LWAAAA KXCAAA AAAAxx 883 1961 1 3 3 3 83 883 883 883 883 166 167 ZHAAAA LXCAAA HHHHxx 2761 1962 1 1 1 1 61 761 761 2761 2761 122 123 FCAAAA MXCAAA OOOOxx 4644 1963 0 0 4 4 44 644 644 4644 4644 88 89 QWAAAA NXCAAA VVVVxx 1358 1964 0 2 8 18 58 358 1358 1358 1358 116 117 GAAAAA OXCAAA AAAAxx 2049 1965 1 1 9 9 49 49 49 2049 2049 98 99 VAAAAA PXCAAA HHHHxx 2193 1966 1 1 3 13 93 193 193 2193 2193 186 187 JGAAAA QXCAAA OOOOxx 9435 1967 1 3 5 15 35 435 1435 4435 9435 70 71 XYAAAA RXCAAA VVVVxx 5890 1968 0 2 0 10 90 890 1890 890 5890 180 181 OSAAAA SXCAAA AAAAxx 8149 1969 1 1 9 9 49 149 149 3149 8149 98 99 LBAAAA TXCAAA HHHHxx 423 1970 1 3 3 3 23 423 423 423 423 46 47 HQAAAA UXCAAA OOOOxx 7980 1971 0 0 0 0 80 980 1980 2980 7980 160 161 YUAAAA VXCAAA VVVVxx 9019 1972 1 3 9 19 19 19 1019 4019 9019 38 39 XIAAAA WXCAAA AAAAxx 1647 1973 1 3 7 7 47 647 1647 1647 1647 94 95 JLAAAA XXCAAA HHHHxx 9495 1974 1 3 5 15 95 495 1495 4495 9495 190 191 FBAAAA YXCAAA OOOOxx 3904 1975 0 0 4 4 4 904 1904 3904 3904 8 9 EUAAAA ZXCAAA VVVVxx 5838 1976 0 2 8 18 38 838 1838 838 5838 76 77 OQAAAA AYCAAA AAAAxx 3866 1977 0 2 6 6 66 866 1866 3866 3866 132 133 SSAAAA BYCAAA HHHHxx 3093 1978 1 1 3 13 93 93 1093 3093 3093 186 187 ZOAAAA CYCAAA OOOOxx 9666 1979 0 2 6 6 66 666 1666 4666 9666 132 133 UHAAAA DYCAAA VVVVxx 1246 1980 0 2 6 6 46 246 1246 1246 1246 92 93 YVAAAA EYCAAA AAAAxx 9759 1981 1 3 9 19 59 759 1759 4759 9759 118 119 JLAAAA FYCAAA HHHHxx 7174 1982 0 2 4 14 74 174 1174 2174 7174 148 149 YPAAAA GYCAAA OOOOxx 7678 1983 0 2 8 18 78 678 1678 2678 7678 156 157 IJAAAA HYCAAA VVVVxx 3004 1984 0 0 4 4 4 4 1004 3004 3004 8 9 OLAAAA IYCAAA AAAAxx 5607 1985 1 3 7 7 7 607 1607 607 5607 14 15 RHAAAA JYCAAA HHHHxx 8510 1986 0 2 0 10 10 510 510 3510 8510 20 21 IPAAAA KYCAAA OOOOxx 1483 1987 1 3 3 3 83 483 1483 1483 1483 166 167 BFAAAA LYCAAA VVVVxx 2915 1988 1 3 5 15 15 915 915 2915 2915 30 31 DIAAAA MYCAAA AAAAxx 1548 1989 0 0 8 8 48 548 1548 1548 1548 96 97 OHAAAA NYCAAA HHHHxx 5767 1990 1 3 7 7 67 767 1767 767 5767 134 135 VNAAAA OYCAAA OOOOxx 3214 1991 0 2 4 14 14 214 1214 3214 3214 28 29 QTAAAA PYCAAA VVVVxx 8663 1992 1 3 3 3 63 663 663 3663 8663 126 127 FVAAAA QYCAAA AAAAxx 5425 1993 1 1 5 5 25 425 1425 425 5425 50 51 RAAAAA RYCAAA HHHHxx 8530 1994 0 2 0 10 30 530 530 3530 8530 60 61 CQAAAA SYCAAA OOOOxx 821 1995 1 1 1 1 21 821 821 821 821 42 43 PFAAAA TYCAAA VVVVxx 8816 1996 0 0 6 16 16 816 816 3816 8816 32 33 CBAAAA UYCAAA AAAAxx 9367 1997 1 3 7 7 67 367 1367 4367 9367 134 135 HWAAAA VYCAAA HHHHxx 4138 1998 0 2 8 18 38 138 138 4138 4138 76 77 EDAAAA WYCAAA OOOOxx 94 1999 0 2 4 14 94 94 94 94 94 188 189 QDAAAA XYCAAA VVVVxx 1858 2000 0 2 8 18 58 858 1858 1858 1858 116 117 MTAAAA YYCAAA AAAAxx 5513 2001 1 1 3 13 13 513 1513 513 5513 26 27 BEAAAA ZYCAAA HHHHxx 9620 2002 0 0 0 0 20 620 1620 4620 9620 40 41 AGAAAA AZCAAA OOOOxx 4770 2003 0 2 0 10 70 770 770 4770 4770 140 141 MBAAAA BZCAAA VVVVxx 5193 2004 1 1 3 13 93 193 1193 193 5193 186 187 TRAAAA CZCAAA AAAAxx 198 2005 0 2 8 18 98 198 198 198 198 196 197 QHAAAA DZCAAA HHHHxx 417 2006 1 1 7 17 17 417 417 417 417 34 35 BQAAAA EZCAAA OOOOxx 173 2007 1 1 3 13 73 173 173 173 173 146 147 RGAAAA FZCAAA VVVVxx 6248 2008 0 0 8 8 48 248 248 1248 6248 96 97 IGAAAA GZCAAA AAAAxx 302 2009 0 2 2 2 2 302 302 302 302 4 5 QLAAAA HZCAAA HHHHxx 8983 2010 1 3 3 3 83 983 983 3983 8983 166 167 NHAAAA IZCAAA OOOOxx 4840 2011 0 0 0 0 40 840 840 4840 4840 80 81 EEAAAA JZCAAA VVVVxx 2876 2012 0 0 6 16 76 876 876 2876 2876 152 153 QGAAAA KZCAAA AAAAxx 5841 2013 1 1 1 1 41 841 1841 841 5841 82 83 RQAAAA LZCAAA HHHHxx 2766 2014 0 2 6 6 66 766 766 2766 2766 132 133 KCAAAA MZCAAA OOOOxx 9482 2015 0 2 2 2 82 482 1482 4482 9482 164 165 SAAAAA NZCAAA VVVVxx 5335 2016 1 3 5 15 35 335 1335 335 5335 70 71 FXAAAA OZCAAA AAAAxx 1502 2017 0 2 2 2 2 502 1502 1502 1502 4 5 UFAAAA PZCAAA HHHHxx 9291 2018 1 3 1 11 91 291 1291 4291 9291 182 183 JTAAAA QZCAAA OOOOxx 8655 2019 1 3 5 15 55 655 655 3655 8655 110 111 XUAAAA RZCAAA VVVVxx 1687 2020 1 3 7 7 87 687 1687 1687 1687 174 175 XMAAAA SZCAAA AAAAxx 8171 2021 1 3 1 11 71 171 171 3171 8171 142 143 HCAAAA TZCAAA HHHHxx 5699 2022 1 3 9 19 99 699 1699 699 5699 198 199 FLAAAA UZCAAA OOOOxx 1462 2023 0 2 2 2 62 462 1462 1462 1462 124 125 GEAAAA VZCAAA VVVVxx 608 2024 0 0 8 8 8 608 608 608 608 16 17 KXAAAA WZCAAA AAAAxx 6860 2025 0 0 0 0 60 860 860 1860 6860 120 121 WDAAAA XZCAAA HHHHxx 6063 2026 1 3 3 3 63 63 63 1063 6063 126 127 FZAAAA YZCAAA OOOOxx 1422 2027 0 2 2 2 22 422 1422 1422 1422 44 45 SCAAAA ZZCAAA VVVVxx 1932 2028 0 0 2 12 32 932 1932 1932 1932 64 65 IWAAAA AADAAA AAAAxx 5065 2029 1 1 5 5 65 65 1065 65 5065 130 131 VMAAAA BADAAA HHHHxx 432 2030 0 0 2 12 32 432 432 432 432 64 65 QQAAAA CADAAA OOOOxx 4680 2031 0 0 0 0 80 680 680 4680 4680 160 161 AYAAAA DADAAA VVVVxx 8172 2032 0 0 2 12 72 172 172 3172 8172 144 145 ICAAAA EADAAA AAAAxx 8668 2033 0 0 8 8 68 668 668 3668 8668 136 137 KVAAAA FADAAA HHHHxx 256 2034 0 0 6 16 56 256 256 256 256 112 113 WJAAAA GADAAA OOOOxx 2500 2035 0 0 0 0 0 500 500 2500 2500 0 1 ESAAAA HADAAA VVVVxx 274 2036 0 2 4 14 74 274 274 274 274 148 149 OKAAAA IADAAA AAAAxx 5907 2037 1 3 7 7 7 907 1907 907 5907 14 15 FTAAAA JADAAA HHHHxx 8587 2038 1 3 7 7 87 587 587 3587 8587 174 175 HSAAAA KADAAA OOOOxx 9942 2039 0 2 2 2 42 942 1942 4942 9942 84 85 KSAAAA LADAAA VVVVxx 116 2040 0 0 6 16 16 116 116 116 116 32 33 MEAAAA MADAAA AAAAxx 7134 2041 0 2 4 14 34 134 1134 2134 7134 68 69 KOAAAA NADAAA HHHHxx 9002 2042 0 2 2 2 2 2 1002 4002 9002 4 5 GIAAAA OADAAA OOOOxx 1209 2043 1 1 9 9 9 209 1209 1209 1209 18 19 NUAAAA PADAAA VVVVxx 9983 2044 1 3 3 3 83 983 1983 4983 9983 166 167 ZTAAAA QADAAA AAAAxx 1761 2045 1 1 1 1 61 761 1761 1761 1761 122 123 TPAAAA RADAAA HHHHxx 7723 2046 1 3 3 3 23 723 1723 2723 7723 46 47 BLAAAA SADAAA OOOOxx 6518 2047 0 2 8 18 18 518 518 1518 6518 36 37 SQAAAA TADAAA VVVVxx 1372 2048 0 0 2 12 72 372 1372 1372 1372 144 145 UAAAAA UADAAA AAAAxx 3587 2049 1 3 7 7 87 587 1587 3587 3587 174 175 ZHAAAA VADAAA HHHHxx 5323 2050 1 3 3 3 23 323 1323 323 5323 46 47 TWAAAA WADAAA OOOOxx 5902 2051 0 2 2 2 2 902 1902 902 5902 4 5 ATAAAA XADAAA VVVVxx 3749 2052 1 1 9 9 49 749 1749 3749 3749 98 99 FOAAAA YADAAA AAAAxx 5965 2053 1 1 5 5 65 965 1965 965 5965 130 131 LVAAAA ZADAAA HHHHxx 663 2054 1 3 3 3 63 663 663 663 663 126 127 NZAAAA ABDAAA OOOOxx 36 2055 0 0 6 16 36 36 36 36 36 72 73 KBAAAA BBDAAA VVVVxx 9782 2056 0 2 2 2 82 782 1782 4782 9782 164 165 GMAAAA CBDAAA AAAAxx 5412 2057 0 0 2 12 12 412 1412 412 5412 24 25 EAAAAA DBDAAA HHHHxx 9961 2058 1 1 1 1 61 961 1961 4961 9961 122 123 DTAAAA EBDAAA OOOOxx 6492 2059 0 0 2 12 92 492 492 1492 6492 184 185 SPAAAA FBDAAA VVVVxx 4234 2060 0 2 4 14 34 234 234 4234 4234 68 69 WGAAAA GBDAAA AAAAxx 4922 2061 0 2 2 2 22 922 922 4922 4922 44 45 IHAAAA HBDAAA HHHHxx 6166 2062 0 2 6 6 66 166 166 1166 6166 132 133 EDAAAA IBDAAA OOOOxx 7019 2063 1 3 9 19 19 19 1019 2019 7019 38 39 ZJAAAA JBDAAA VVVVxx 7805 2064 1 1 5 5 5 805 1805 2805 7805 10 11 FOAAAA KBDAAA AAAAxx 9808 2065 0 0 8 8 8 808 1808 4808 9808 16 17 GNAAAA LBDAAA HHHHxx 2550 2066 0 2 0 10 50 550 550 2550 2550 100 101 CUAAAA MBDAAA OOOOxx 8626 2067 0 2 6 6 26 626 626 3626 8626 52 53 UTAAAA NBDAAA VVVVxx 5649 2068 1 1 9 9 49 649 1649 649 5649 98 99 HJAAAA OBDAAA AAAAxx 3117 2069 1 1 7 17 17 117 1117 3117 3117 34 35 XPAAAA PBDAAA HHHHxx 866 2070 0 2 6 6 66 866 866 866 866 132 133 IHAAAA QBDAAA OOOOxx 2323 2071 1 3 3 3 23 323 323 2323 2323 46 47 JLAAAA RBDAAA VVVVxx 5132 2072 0 0 2 12 32 132 1132 132 5132 64 65 KPAAAA SBDAAA AAAAxx 9222 2073 0 2 2 2 22 222 1222 4222 9222 44 45 SQAAAA TBDAAA HHHHxx 3934 2074 0 2 4 14 34 934 1934 3934 3934 68 69 IVAAAA UBDAAA OOOOxx 4845 2075 1 1 5 5 45 845 845 4845 4845 90 91 JEAAAA VBDAAA VVVVxx 7714 2076 0 2 4 14 14 714 1714 2714 7714 28 29 SKAAAA WBDAAA AAAAxx 9818 2077 0 2 8 18 18 818 1818 4818 9818 36 37 QNAAAA XBDAAA HHHHxx 2219 2078 1 3 9 19 19 219 219 2219 2219 38 39 JHAAAA YBDAAA OOOOxx 6573 2079 1 1 3 13 73 573 573 1573 6573 146 147 VSAAAA ZBDAAA VVVVxx 4555 2080 1 3 5 15 55 555 555 4555 4555 110 111 FTAAAA ACDAAA AAAAxx 7306 2081 0 2 6 6 6 306 1306 2306 7306 12 13 AVAAAA BCDAAA HHHHxx 9313 2082 1 1 3 13 13 313 1313 4313 9313 26 27 FUAAAA CCDAAA OOOOxx 3924 2083 0 0 4 4 24 924 1924 3924 3924 48 49 YUAAAA DCDAAA VVVVxx 5176 2084 0 0 6 16 76 176 1176 176 5176 152 153 CRAAAA ECDAAA AAAAxx 9767 2085 1 3 7 7 67 767 1767 4767 9767 134 135 RLAAAA FCDAAA HHHHxx 905 2086 1 1 5 5 5 905 905 905 905 10 11 VIAAAA GCDAAA OOOOxx 8037 2087 1 1 7 17 37 37 37 3037 8037 74 75 DXAAAA HCDAAA VVVVxx 8133 2088 1 1 3 13 33 133 133 3133 8133 66 67 VAAAAA ICDAAA AAAAxx 2954 2089 0 2 4 14 54 954 954 2954 2954 108 109 QJAAAA JCDAAA HHHHxx 7262 2090 0 2 2 2 62 262 1262 2262 7262 124 125 ITAAAA KCDAAA OOOOxx 8768 2091 0 0 8 8 68 768 768 3768 8768 136 137 GZAAAA LCDAAA VVVVxx 6953 2092 1 1 3 13 53 953 953 1953 6953 106 107 LHAAAA MCDAAA AAAAxx 1984 2093 0 0 4 4 84 984 1984 1984 1984 168 169 IYAAAA NCDAAA HHHHxx 9348 2094 0 0 8 8 48 348 1348 4348 9348 96 97 OVAAAA OCDAAA OOOOxx 7769 2095 1 1 9 9 69 769 1769 2769 7769 138 139 VMAAAA PCDAAA VVVVxx 2994 2096 0 2 4 14 94 994 994 2994 2994 188 189 ELAAAA QCDAAA AAAAxx 5938 2097 0 2 8 18 38 938 1938 938 5938 76 77 KUAAAA RCDAAA HHHHxx 556 2098 0 0 6 16 56 556 556 556 556 112 113 KVAAAA SCDAAA OOOOxx 2577 2099 1 1 7 17 77 577 577 2577 2577 154 155 DVAAAA TCDAAA VVVVxx 8733 2100 1 1 3 13 33 733 733 3733 8733 66 67 XXAAAA UCDAAA AAAAxx 3108 2101 0 0 8 8 8 108 1108 3108 3108 16 17 OPAAAA VCDAAA HHHHxx 4166 2102 0 2 6 6 66 166 166 4166 4166 132 133 GEAAAA WCDAAA OOOOxx 3170 2103 0 2 0 10 70 170 1170 3170 3170 140 141 YRAAAA XCDAAA VVVVxx 8118 2104 0 2 8 18 18 118 118 3118 8118 36 37 GAAAAA YCDAAA AAAAxx 8454 2105 0 2 4 14 54 454 454 3454 8454 108 109 ENAAAA ZCDAAA HHHHxx 5338 2106 0 2 8 18 38 338 1338 338 5338 76 77 IXAAAA ADDAAA OOOOxx 402 2107 0 2 2 2 2 402 402 402 402 4 5 MPAAAA BDDAAA VVVVxx 5673 2108 1 1 3 13 73 673 1673 673 5673 146 147 FKAAAA CDDAAA AAAAxx 4324 2109 0 0 4 4 24 324 324 4324 4324 48 49 IKAAAA DDDAAA HHHHxx 1943 2110 1 3 3 3 43 943 1943 1943 1943 86 87 TWAAAA EDDAAA OOOOxx 7703 2111 1 3 3 3 3 703 1703 2703 7703 6 7 HKAAAA FDDAAA VVVVxx 7180 2112 0 0 0 0 80 180 1180 2180 7180 160 161 EQAAAA GDDAAA AAAAxx 5478 2113 0 2 8 18 78 478 1478 478 5478 156 157 SCAAAA HDDAAA HHHHxx 5775 2114 1 3 5 15 75 775 1775 775 5775 150 151 DOAAAA IDDAAA OOOOxx 6952 2115 0 0 2 12 52 952 952 1952 6952 104 105 KHAAAA JDDAAA VVVVxx 9022 2116 0 2 2 2 22 22 1022 4022 9022 44 45 AJAAAA KDDAAA AAAAxx 547 2117 1 3 7 7 47 547 547 547 547 94 95 BVAAAA LDDAAA HHHHxx 5877 2118 1 1 7 17 77 877 1877 877 5877 154 155 BSAAAA MDDAAA OOOOxx 9580 2119 0 0 0 0 80 580 1580 4580 9580 160 161 MEAAAA NDDAAA VVVVxx 6094 2120 0 2 4 14 94 94 94 1094 6094 188 189 KAAAAA ODDAAA AAAAxx 3398 2121 0 2 8 18 98 398 1398 3398 3398 196 197 SAAAAA PDDAAA HHHHxx 4574 2122 0 2 4 14 74 574 574 4574 4574 148 149 YTAAAA QDDAAA OOOOxx 3675 2123 1 3 5 15 75 675 1675 3675 3675 150 151 JLAAAA RDDAAA VVVVxx 6413 2124 1 1 3 13 13 413 413 1413 6413 26 27 RMAAAA SDDAAA AAAAxx 9851 2125 1 3 1 11 51 851 1851 4851 9851 102 103 XOAAAA TDDAAA HHHHxx 126 2126 0 2 6 6 26 126 126 126 126 52 53 WEAAAA UDDAAA OOOOxx 6803 2127 1 3 3 3 3 803 803 1803 6803 6 7 RBAAAA VDDAAA VVVVxx 6949 2128 1 1 9 9 49 949 949 1949 6949 98 99 HHAAAA WDDAAA AAAAxx 115 2129 1 3 5 15 15 115 115 115 115 30 31 LEAAAA XDDAAA HHHHxx 4165 2130 1 1 5 5 65 165 165 4165 4165 130 131 FEAAAA YDDAAA OOOOxx 201 2131 1 1 1 1 1 201 201 201 201 2 3 THAAAA ZDDAAA VVVVxx 9324 2132 0 0 4 4 24 324 1324 4324 9324 48 49 QUAAAA AEDAAA AAAAxx 6562 2133 0 2 2 2 62 562 562 1562 6562 124 125 KSAAAA BEDAAA HHHHxx 1917 2134 1 1 7 17 17 917 1917 1917 1917 34 35 TVAAAA CEDAAA OOOOxx 558 2135 0 2 8 18 58 558 558 558 558 116 117 MVAAAA DEDAAA VVVVxx 8515 2136 1 3 5 15 15 515 515 3515 8515 30 31 NPAAAA EEDAAA AAAAxx 6321 2137 1 1 1 1 21 321 321 1321 6321 42 43 DJAAAA FEDAAA HHHHxx 6892 2138 0 0 2 12 92 892 892 1892 6892 184 185 CFAAAA GEDAAA OOOOxx 1001 2139 1 1 1 1 1 1 1001 1001 1001 2 3 NMAAAA HEDAAA VVVVxx 2858 2140 0 2 8 18 58 858 858 2858 2858 116 117 YFAAAA IEDAAA AAAAxx 2434 2141 0 2 4 14 34 434 434 2434 2434 68 69 QPAAAA JEDAAA HHHHxx 4460 2142 0 0 0 0 60 460 460 4460 4460 120 121 OPAAAA KEDAAA OOOOxx 5447 2143 1 3 7 7 47 447 1447 447 5447 94 95 NBAAAA LEDAAA VVVVxx 3799 2144 1 3 9 19 99 799 1799 3799 3799 198 199 DQAAAA MEDAAA AAAAxx 4310 2145 0 2 0 10 10 310 310 4310 4310 20 21 UJAAAA NEDAAA HHHHxx 405 2146 1 1 5 5 5 405 405 405 405 10 11 PPAAAA OEDAAA OOOOxx 4573 2147 1 1 3 13 73 573 573 4573 4573 146 147 XTAAAA PEDAAA VVVVxx 706 2148 0 2 6 6 6 706 706 706 706 12 13 EBAAAA QEDAAA AAAAxx 7619 2149 1 3 9 19 19 619 1619 2619 7619 38 39 BHAAAA REDAAA HHHHxx 7959 2150 1 3 9 19 59 959 1959 2959 7959 118 119 DUAAAA SEDAAA OOOOxx 6712 2151 0 0 2 12 12 712 712 1712 6712 24 25 EYAAAA TEDAAA VVVVxx 6959 2152 1 3 9 19 59 959 959 1959 6959 118 119 RHAAAA UEDAAA AAAAxx 9791 2153 1 3 1 11 91 791 1791 4791 9791 182 183 PMAAAA VEDAAA HHHHxx 2112 2154 0 0 2 12 12 112 112 2112 2112 24 25 GDAAAA WEDAAA OOOOxx 9114 2155 0 2 4 14 14 114 1114 4114 9114 28 29 OMAAAA XEDAAA VVVVxx 3506 2156 0 2 6 6 6 506 1506 3506 3506 12 13 WEAAAA YEDAAA AAAAxx 5002 2157 0 2 2 2 2 2 1002 2 5002 4 5 KKAAAA ZEDAAA HHHHxx 3518 2158 0 2 8 18 18 518 1518 3518 3518 36 37 IFAAAA AFDAAA OOOOxx 602 2159 0 2 2 2 2 602 602 602 602 4 5 EXAAAA BFDAAA VVVVxx 9060 2160 0 0 0 0 60 60 1060 4060 9060 120 121 MKAAAA CFDAAA AAAAxx 3292 2161 0 0 2 12 92 292 1292 3292 3292 184 185 QWAAAA DFDAAA HHHHxx 77 2162 1 1 7 17 77 77 77 77 77 154 155 ZCAAAA EFDAAA OOOOxx 1420 2163 0 0 0 0 20 420 1420 1420 1420 40 41 QCAAAA FFDAAA VVVVxx 6001 2164 1 1 1 1 1 1 1 1001 6001 2 3 VWAAAA GFDAAA AAAAxx 7477 2165 1 1 7 17 77 477 1477 2477 7477 154 155 PBAAAA HFDAAA HHHHxx 6655 2166 1 3 5 15 55 655 655 1655 6655 110 111 ZVAAAA IFDAAA OOOOxx 7845 2167 1 1 5 5 45 845 1845 2845 7845 90 91 TPAAAA JFDAAA VVVVxx 8484 2168 0 0 4 4 84 484 484 3484 8484 168 169 IOAAAA KFDAAA AAAAxx 4345 2169 1 1 5 5 45 345 345 4345 4345 90 91 DLAAAA LFDAAA HHHHxx 4250 2170 0 2 0 10 50 250 250 4250 4250 100 101 MHAAAA MFDAAA OOOOxx 2391 2171 1 3 1 11 91 391 391 2391 2391 182 183 ZNAAAA NFDAAA VVVVxx 6884 2172 0 0 4 4 84 884 884 1884 6884 168 169 UEAAAA OFDAAA AAAAxx 7270 2173 0 2 0 10 70 270 1270 2270 7270 140 141 QTAAAA PFDAAA HHHHxx 2499 2174 1 3 9 19 99 499 499 2499 2499 198 199 DSAAAA QFDAAA OOOOxx 7312 2175 0 0 2 12 12 312 1312 2312 7312 24 25 GVAAAA RFDAAA VVVVxx 7113 2176 1 1 3 13 13 113 1113 2113 7113 26 27 PNAAAA SFDAAA AAAAxx 6695 2177 1 3 5 15 95 695 695 1695 6695 190 191 NXAAAA TFDAAA HHHHxx 6521 2178 1 1 1 1 21 521 521 1521 6521 42 43 VQAAAA UFDAAA OOOOxx 272 2179 0 0 2 12 72 272 272 272 272 144 145 MKAAAA VFDAAA VVVVxx 9976 2180 0 0 6 16 76 976 1976 4976 9976 152 153 STAAAA WFDAAA AAAAxx 992 2181 0 0 2 12 92 992 992 992 992 184 185 EMAAAA XFDAAA HHHHxx 6158 2182 0 2 8 18 58 158 158 1158 6158 116 117 WCAAAA YFDAAA OOOOxx 3281 2183 1 1 1 1 81 281 1281 3281 3281 162 163 FWAAAA ZFDAAA VVVVxx 7446 2184 0 2 6 6 46 446 1446 2446 7446 92 93 KAAAAA AGDAAA AAAAxx 4679 2185 1 3 9 19 79 679 679 4679 4679 158 159 ZXAAAA BGDAAA HHHHxx 5203 2186 1 3 3 3 3 203 1203 203 5203 6 7 DSAAAA CGDAAA OOOOxx 9874 2187 0 2 4 14 74 874 1874 4874 9874 148 149 UPAAAA DGDAAA VVVVxx 8371 2188 1 3 1 11 71 371 371 3371 8371 142 143 ZJAAAA EGDAAA AAAAxx 9086 2189 0 2 6 6 86 86 1086 4086 9086 172 173 MLAAAA FGDAAA HHHHxx 430 2190 0 2 0 10 30 430 430 430 430 60 61 OQAAAA GGDAAA OOOOxx 8749 2191 1 1 9 9 49 749 749 3749 8749 98 99 NYAAAA HGDAAA VVVVxx 577 2192 1 1 7 17 77 577 577 577 577 154 155 FWAAAA IGDAAA AAAAxx 4884 2193 0 0 4 4 84 884 884 4884 4884 168 169 WFAAAA JGDAAA HHHHxx 3421 2194 1 1 1 1 21 421 1421 3421 3421 42 43 PBAAAA KGDAAA OOOOxx 2812 2195 0 0 2 12 12 812 812 2812 2812 24 25 EEAAAA LGDAAA VVVVxx 5958 2196 0 2 8 18 58 958 1958 958 5958 116 117 EVAAAA MGDAAA AAAAxx 9901 2197 1 1 1 1 1 901 1901 4901 9901 2 3 VQAAAA NGDAAA HHHHxx 8478 2198 0 2 8 18 78 478 478 3478 8478 156 157 COAAAA OGDAAA OOOOxx 6545 2199 1 1 5 5 45 545 545 1545 6545 90 91 TRAAAA PGDAAA VVVVxx 1479 2200 1 3 9 19 79 479 1479 1479 1479 158 159 XEAAAA QGDAAA AAAAxx 1046 2201 0 2 6 6 46 46 1046 1046 1046 92 93 GOAAAA RGDAAA HHHHxx 6372 2202 0 0 2 12 72 372 372 1372 6372 144 145 CLAAAA SGDAAA OOOOxx 8206 2203 0 2 6 6 6 206 206 3206 8206 12 13 QDAAAA TGDAAA VVVVxx 9544 2204 0 0 4 4 44 544 1544 4544 9544 88 89 CDAAAA UGDAAA AAAAxx 9287 2205 1 3 7 7 87 287 1287 4287 9287 174 175 FTAAAA VGDAAA HHHHxx 6786 2206 0 2 6 6 86 786 786 1786 6786 172 173 ABAAAA WGDAAA OOOOxx 6511 2207 1 3 1 11 11 511 511 1511 6511 22 23 LQAAAA XGDAAA VVVVxx 603 2208 1 3 3 3 3 603 603 603 603 6 7 FXAAAA YGDAAA AAAAxx 2022 2209 0 2 2 2 22 22 22 2022 2022 44 45 UZAAAA ZGDAAA HHHHxx 2086 2210 0 2 6 6 86 86 86 2086 2086 172 173 GCAAAA AHDAAA OOOOxx 1969 2211 1 1 9 9 69 969 1969 1969 1969 138 139 TXAAAA BHDAAA VVVVxx 4841 2212 1 1 1 1 41 841 841 4841 4841 82 83 FEAAAA CHDAAA AAAAxx 5845 2213 1 1 5 5 45 845 1845 845 5845 90 91 VQAAAA DHDAAA HHHHxx 4635 2214 1 3 5 15 35 635 635 4635 4635 70 71 HWAAAA EHDAAA OOOOxx 4658 2215 0 2 8 18 58 658 658 4658 4658 116 117 EXAAAA FHDAAA VVVVxx 2896 2216 0 0 6 16 96 896 896 2896 2896 192 193 KHAAAA GHDAAA AAAAxx 5179 2217 1 3 9 19 79 179 1179 179 5179 158 159 FRAAAA HHDAAA HHHHxx 8667 2218 1 3 7 7 67 667 667 3667 8667 134 135 JVAAAA IHDAAA OOOOxx 7294 2219 0 2 4 14 94 294 1294 2294 7294 188 189 OUAAAA JHDAAA VVVVxx 3706 2220 0 2 6 6 6 706 1706 3706 3706 12 13 OMAAAA KHDAAA AAAAxx 8389 2221 1 1 9 9 89 389 389 3389 8389 178 179 RKAAAA LHDAAA HHHHxx 2486 2222 0 2 6 6 86 486 486 2486 2486 172 173 QRAAAA MHDAAA OOOOxx 8743 2223 1 3 3 3 43 743 743 3743 8743 86 87 HYAAAA NHDAAA VVVVxx 2777 2224 1 1 7 17 77 777 777 2777 2777 154 155 VCAAAA OHDAAA AAAAxx 2113 2225 1 1 3 13 13 113 113 2113 2113 26 27 HDAAAA PHDAAA HHHHxx 2076 2226 0 0 6 16 76 76 76 2076 2076 152 153 WBAAAA QHDAAA OOOOxx 2300 2227 0 0 0 0 0 300 300 2300 2300 0 1 MKAAAA RHDAAA VVVVxx 6894 2228 0 2 4 14 94 894 894 1894 6894 188 189 EFAAAA SHDAAA AAAAxx 6939 2229 1 3 9 19 39 939 939 1939 6939 78 79 XGAAAA THDAAA HHHHxx 446 2230 0 2 6 6 46 446 446 446 446 92 93 ERAAAA UHDAAA OOOOxx 6218 2231 0 2 8 18 18 218 218 1218 6218 36 37 EFAAAA VHDAAA VVVVxx 1295 2232 1 3 5 15 95 295 1295 1295 1295 190 191 VXAAAA WHDAAA AAAAxx 5135 2233 1 3 5 15 35 135 1135 135 5135 70 71 NPAAAA XHDAAA HHHHxx 8122 2234 0 2 2 2 22 122 122 3122 8122 44 45 KAAAAA YHDAAA OOOOxx 316 2235 0 0 6 16 16 316 316 316 316 32 33 EMAAAA ZHDAAA VVVVxx 514 2236 0 2 4 14 14 514 514 514 514 28 29 UTAAAA AIDAAA AAAAxx 7970 2237 0 2 0 10 70 970 1970 2970 7970 140 141 OUAAAA BIDAAA HHHHxx 9350 2238 0 2 0 10 50 350 1350 4350 9350 100 101 QVAAAA CIDAAA OOOOxx 3700 2239 0 0 0 0 0 700 1700 3700 3700 0 1 IMAAAA DIDAAA VVVVxx 582 2240 0 2 2 2 82 582 582 582 582 164 165 KWAAAA EIDAAA AAAAxx 9722 2241 0 2 2 2 22 722 1722 4722 9722 44 45 YJAAAA FIDAAA HHHHxx 7398 2242 0 2 8 18 98 398 1398 2398 7398 196 197 OYAAAA GIDAAA OOOOxx 2265 2243 1 1 5 5 65 265 265 2265 2265 130 131 DJAAAA HIDAAA VVVVxx 3049 2244 1 1 9 9 49 49 1049 3049 3049 98 99 HNAAAA IIDAAA AAAAxx 9121 2245 1 1 1 1 21 121 1121 4121 9121 42 43 VMAAAA JIDAAA HHHHxx 4275 2246 1 3 5 15 75 275 275 4275 4275 150 151 LIAAAA KIDAAA OOOOxx 6567 2247 1 3 7 7 67 567 567 1567 6567 134 135 PSAAAA LIDAAA VVVVxx 6755 2248 1 3 5 15 55 755 755 1755 6755 110 111 VZAAAA MIDAAA AAAAxx 4535 2249 1 3 5 15 35 535 535 4535 4535 70 71 LSAAAA NIDAAA HHHHxx 7968 2250 0 0 8 8 68 968 1968 2968 7968 136 137 MUAAAA OIDAAA OOOOxx 3412 2251 0 0 2 12 12 412 1412 3412 3412 24 25 GBAAAA PIDAAA VVVVxx 6112 2252 0 0 2 12 12 112 112 1112 6112 24 25 CBAAAA QIDAAA AAAAxx 6805 2253 1 1 5 5 5 805 805 1805 6805 10 11 TBAAAA RIDAAA HHHHxx 2880 2254 0 0 0 0 80 880 880 2880 2880 160 161 UGAAAA SIDAAA OOOOxx 7710 2255 0 2 0 10 10 710 1710 2710 7710 20 21 OKAAAA TIDAAA VVVVxx 7949 2256 1 1 9 9 49 949 1949 2949 7949 98 99 TTAAAA UIDAAA AAAAxx 7043 2257 1 3 3 3 43 43 1043 2043 7043 86 87 XKAAAA VIDAAA HHHHxx 9012 2258 0 0 2 12 12 12 1012 4012 9012 24 25 QIAAAA WIDAAA OOOOxx 878 2259 0 2 8 18 78 878 878 878 878 156 157 UHAAAA XIDAAA VVVVxx 7930 2260 0 2 0 10 30 930 1930 2930 7930 60 61 ATAAAA YIDAAA AAAAxx 667 2261 1 3 7 7 67 667 667 667 667 134 135 RZAAAA ZIDAAA HHHHxx 1905 2262 1 1 5 5 5 905 1905 1905 1905 10 11 HVAAAA AJDAAA OOOOxx 4958 2263 0 2 8 18 58 958 958 4958 4958 116 117 SIAAAA BJDAAA VVVVxx 2973 2264 1 1 3 13 73 973 973 2973 2973 146 147 JKAAAA CJDAAA AAAAxx 3631 2265 1 3 1 11 31 631 1631 3631 3631 62 63 RJAAAA DJDAAA HHHHxx 5868 2266 0 0 8 8 68 868 1868 868 5868 136 137 SRAAAA EJDAAA OOOOxx 2873 2267 1 1 3 13 73 873 873 2873 2873 146 147 NGAAAA FJDAAA VVVVxx 6941 2268 1 1 1 1 41 941 941 1941 6941 82 83 ZGAAAA GJDAAA AAAAxx 6384 2269 0 0 4 4 84 384 384 1384 6384 168 169 OLAAAA HJDAAA HHHHxx 3806 2270 0 2 6 6 6 806 1806 3806 3806 12 13 KQAAAA IJDAAA OOOOxx 5079 2271 1 3 9 19 79 79 1079 79 5079 158 159 JNAAAA JJDAAA VVVVxx 1970 2272 0 2 0 10 70 970 1970 1970 1970 140 141 UXAAAA KJDAAA AAAAxx 7810 2273 0 2 0 10 10 810 1810 2810 7810 20 21 KOAAAA LJDAAA HHHHxx 4639 2274 1 3 9 19 39 639 639 4639 4639 78 79 LWAAAA MJDAAA OOOOxx 6527 2275 1 3 7 7 27 527 527 1527 6527 54 55 BRAAAA NJDAAA VVVVxx 8079 2276 1 3 9 19 79 79 79 3079 8079 158 159 TYAAAA OJDAAA AAAAxx 2740 2277 0 0 0 0 40 740 740 2740 2740 80 81 KBAAAA PJDAAA HHHHxx 2337 2278 1 1 7 17 37 337 337 2337 2337 74 75 XLAAAA QJDAAA OOOOxx 6670 2279 0 2 0 10 70 670 670 1670 6670 140 141 OWAAAA RJDAAA VVVVxx 2345 2280 1 1 5 5 45 345 345 2345 2345 90 91 FMAAAA SJDAAA AAAAxx 401 2281 1 1 1 1 1 401 401 401 401 2 3 LPAAAA TJDAAA HHHHxx 2704 2282 0 0 4 4 4 704 704 2704 2704 8 9 AAAAAA UJDAAA OOOOxx 5530 2283 0 2 0 10 30 530 1530 530 5530 60 61 SEAAAA VJDAAA VVVVxx 51 2284 1 3 1 11 51 51 51 51 51 102 103 ZBAAAA WJDAAA AAAAxx 4282 2285 0 2 2 2 82 282 282 4282 4282 164 165 SIAAAA XJDAAA HHHHxx 7336 2286 0 0 6 16 36 336 1336 2336 7336 72 73 EWAAAA YJDAAA OOOOxx 8320 2287 0 0 0 0 20 320 320 3320 8320 40 41 AIAAAA ZJDAAA VVVVxx 7772 2288 0 0 2 12 72 772 1772 2772 7772 144 145 YMAAAA AKDAAA AAAAxx 1894 2289 0 2 4 14 94 894 1894 1894 1894 188 189 WUAAAA BKDAAA HHHHxx 2320 2290 0 0 0 0 20 320 320 2320 2320 40 41 GLAAAA CKDAAA OOOOxx 6232 2291 0 0 2 12 32 232 232 1232 6232 64 65 SFAAAA DKDAAA VVVVxx 2833 2292 1 1 3 13 33 833 833 2833 2833 66 67 ZEAAAA EKDAAA AAAAxx 8265 2293 1 1 5 5 65 265 265 3265 8265 130 131 XFAAAA FKDAAA HHHHxx 4589 2294 1 1 9 9 89 589 589 4589 4589 178 179 NUAAAA GKDAAA OOOOxx 8182 2295 0 2 2 2 82 182 182 3182 8182 164 165 SCAAAA HKDAAA VVVVxx 8337 2296 1 1 7 17 37 337 337 3337 8337 74 75 RIAAAA IKDAAA AAAAxx 8210 2297 0 2 0 10 10 210 210 3210 8210 20 21 UDAAAA JKDAAA HHHHxx 1406 2298 0 2 6 6 6 406 1406 1406 1406 12 13 CCAAAA KKDAAA OOOOxx 4463 2299 1 3 3 3 63 463 463 4463 4463 126 127 RPAAAA LKDAAA VVVVxx 4347 2300 1 3 7 7 47 347 347 4347 4347 94 95 FLAAAA MKDAAA AAAAxx 181 2301 1 1 1 1 81 181 181 181 181 162 163 ZGAAAA NKDAAA HHHHxx 9986 2302 0 2 6 6 86 986 1986 4986 9986 172 173 CUAAAA OKDAAA OOOOxx 661 2303 1 1 1 1 61 661 661 661 661 122 123 LZAAAA PKDAAA VVVVxx 4105 2304 1 1 5 5 5 105 105 4105 4105 10 11 XBAAAA QKDAAA AAAAxx 2187 2305 1 3 7 7 87 187 187 2187 2187 174 175 DGAAAA RKDAAA HHHHxx 1628 2306 0 0 8 8 28 628 1628 1628 1628 56 57 QKAAAA SKDAAA OOOOxx 3119 2307 1 3 9 19 19 119 1119 3119 3119 38 39 ZPAAAA TKDAAA VVVVxx 6804 2308 0 0 4 4 4 804 804 1804 6804 8 9 SBAAAA UKDAAA AAAAxx 9918 2309 0 2 8 18 18 918 1918 4918 9918 36 37 MRAAAA VKDAAA HHHHxx 8916 2310 0 0 6 16 16 916 916 3916 8916 32 33 YEAAAA WKDAAA OOOOxx 6057 2311 1 1 7 17 57 57 57 1057 6057 114 115 ZYAAAA XKDAAA VVVVxx 3622 2312 0 2 2 2 22 622 1622 3622 3622 44 45 IJAAAA YKDAAA AAAAxx 9168 2313 0 0 8 8 68 168 1168 4168 9168 136 137 QOAAAA ZKDAAA HHHHxx 3720 2314 0 0 0 0 20 720 1720 3720 3720 40 41 CNAAAA ALDAAA OOOOxx 9927 2315 1 3 7 7 27 927 1927 4927 9927 54 55 VRAAAA BLDAAA VVVVxx 5616 2316 0 0 6 16 16 616 1616 616 5616 32 33 AIAAAA CLDAAA AAAAxx 5210 2317 0 2 0 10 10 210 1210 210 5210 20 21 KSAAAA DLDAAA HHHHxx 636 2318 0 0 6 16 36 636 636 636 636 72 73 MYAAAA ELDAAA OOOOxx 9936 2319 0 0 6 16 36 936 1936 4936 9936 72 73 ESAAAA FLDAAA VVVVxx 2316 2320 0 0 6 16 16 316 316 2316 2316 32 33 CLAAAA GLDAAA AAAAxx 4363 2321 1 3 3 3 63 363 363 4363 4363 126 127 VLAAAA HLDAAA HHHHxx 7657 2322 1 1 7 17 57 657 1657 2657 7657 114 115 NIAAAA ILDAAA OOOOxx 697 2323 1 1 7 17 97 697 697 697 697 194 195 VAAAAA JLDAAA VVVVxx 912 2324 0 0 2 12 12 912 912 912 912 24 25 CJAAAA KLDAAA AAAAxx 8806 2325 0 2 6 6 6 806 806 3806 8806 12 13 SAAAAA LLDAAA HHHHxx 9698 2326 0 2 8 18 98 698 1698 4698 9698 196 197 AJAAAA MLDAAA OOOOxx 6191 2327 1 3 1 11 91 191 191 1191 6191 182 183 DEAAAA NLDAAA VVVVxx 1188 2328 0 0 8 8 88 188 1188 1188 1188 176 177 STAAAA OLDAAA AAAAxx 7676 2329 0 0 6 16 76 676 1676 2676 7676 152 153 GJAAAA PLDAAA HHHHxx 7073 2330 1 1 3 13 73 73 1073 2073 7073 146 147 BMAAAA QLDAAA OOOOxx 8019 2331 1 3 9 19 19 19 19 3019 8019 38 39 LWAAAA RLDAAA VVVVxx 4726 2332 0 2 6 6 26 726 726 4726 4726 52 53 UZAAAA SLDAAA AAAAxx 4648 2333 0 0 8 8 48 648 648 4648 4648 96 97 UWAAAA TLDAAA HHHHxx 3227 2334 1 3 7 7 27 227 1227 3227 3227 54 55 DUAAAA ULDAAA OOOOxx 7232 2335 0 0 2 12 32 232 1232 2232 7232 64 65 ESAAAA VLDAAA VVVVxx 9761 2336 1 1 1 1 61 761 1761 4761 9761 122 123 LLAAAA WLDAAA AAAAxx 3105 2337 1 1 5 5 5 105 1105 3105 3105 10 11 LPAAAA XLDAAA HHHHxx 5266 2338 0 2 6 6 66 266 1266 266 5266 132 133 OUAAAA YLDAAA OOOOxx 6788 2339 0 0 8 8 88 788 788 1788 6788 176 177 CBAAAA ZLDAAA VVVVxx 2442 2340 0 2 2 2 42 442 442 2442 2442 84 85 YPAAAA AMDAAA AAAAxx 8198 2341 0 2 8 18 98 198 198 3198 8198 196 197 IDAAAA BMDAAA HHHHxx 5806 2342 0 2 6 6 6 806 1806 806 5806 12 13 IPAAAA CMDAAA OOOOxx 8928 2343 0 0 8 8 28 928 928 3928 8928 56 57 KFAAAA DMDAAA VVVVxx 1657 2344 1 1 7 17 57 657 1657 1657 1657 114 115 TLAAAA EMDAAA AAAAxx 9164 2345 0 0 4 4 64 164 1164 4164 9164 128 129 MOAAAA FMDAAA HHHHxx 1851 2346 1 3 1 11 51 851 1851 1851 1851 102 103 FTAAAA GMDAAA OOOOxx 4744 2347 0 0 4 4 44 744 744 4744 4744 88 89 MAAAAA HMDAAA VVVVxx 8055 2348 1 3 5 15 55 55 55 3055 8055 110 111 VXAAAA IMDAAA AAAAxx 1533 2349 1 1 3 13 33 533 1533 1533 1533 66 67 ZGAAAA JMDAAA HHHHxx 1260 2350 0 0 0 0 60 260 1260 1260 1260 120 121 MWAAAA KMDAAA OOOOxx 1290 2351 0 2 0 10 90 290 1290 1290 1290 180 181 QXAAAA LMDAAA VVVVxx 297 2352 1 1 7 17 97 297 297 297 297 194 195 LLAAAA MMDAAA AAAAxx 4145 2353 1 1 5 5 45 145 145 4145 4145 90 91 LDAAAA NMDAAA HHHHxx 863 2354 1 3 3 3 63 863 863 863 863 126 127 FHAAAA OMDAAA OOOOxx 3423 2355 1 3 3 3 23 423 1423 3423 3423 46 47 RBAAAA PMDAAA VVVVxx 8750 2356 0 2 0 10 50 750 750 3750 8750 100 101 OYAAAA QMDAAA AAAAxx 3546 2357 0 2 6 6 46 546 1546 3546 3546 92 93 KGAAAA RMDAAA HHHHxx 3678 2358 0 2 8 18 78 678 1678 3678 3678 156 157 MLAAAA SMDAAA OOOOxx 5313 2359 1 1 3 13 13 313 1313 313 5313 26 27 JWAAAA TMDAAA VVVVxx 6233 2360 1 1 3 13 33 233 233 1233 6233 66 67 TFAAAA UMDAAA AAAAxx 5802 2361 0 2 2 2 2 802 1802 802 5802 4 5 EPAAAA VMDAAA HHHHxx 7059 2362 1 3 9 19 59 59 1059 2059 7059 118 119 NLAAAA WMDAAA OOOOxx 6481 2363 1 1 1 1 81 481 481 1481 6481 162 163 HPAAAA XMDAAA VVVVxx 1596 2364 0 0 6 16 96 596 1596 1596 1596 192 193 KJAAAA YMDAAA AAAAxx 8181 2365 1 1 1 1 81 181 181 3181 8181 162 163 RCAAAA ZMDAAA HHHHxx 5368 2366 0 0 8 8 68 368 1368 368 5368 136 137 MYAAAA ANDAAA OOOOxx 9416 2367 0 0 6 16 16 416 1416 4416 9416 32 33 EYAAAA BNDAAA VVVVxx 9521 2368 1 1 1 1 21 521 1521 4521 9521 42 43 FCAAAA CNDAAA AAAAxx 1042 2369 0 2 2 2 42 42 1042 1042 1042 84 85 COAAAA DNDAAA HHHHxx 4503 2370 1 3 3 3 3 503 503 4503 4503 6 7 FRAAAA ENDAAA OOOOxx 3023 2371 1 3 3 3 23 23 1023 3023 3023 46 47 HMAAAA FNDAAA VVVVxx 1976 2372 0 0 6 16 76 976 1976 1976 1976 152 153 AYAAAA GNDAAA AAAAxx 5610 2373 0 2 0 10 10 610 1610 610 5610 20 21 UHAAAA HNDAAA HHHHxx 7410 2374 0 2 0 10 10 410 1410 2410 7410 20 21 AZAAAA INDAAA OOOOxx 7872 2375 0 0 2 12 72 872 1872 2872 7872 144 145 UQAAAA JNDAAA VVVVxx 8591 2376 1 3 1 11 91 591 591 3591 8591 182 183 LSAAAA KNDAAA AAAAxx 1804 2377 0 0 4 4 4 804 1804 1804 1804 8 9 KRAAAA LNDAAA HHHHxx 5299 2378 1 3 9 19 99 299 1299 299 5299 198 199 VVAAAA MNDAAA OOOOxx 4695 2379 1 3 5 15 95 695 695 4695 4695 190 191 PYAAAA NNDAAA VVVVxx 2672 2380 0 0 2 12 72 672 672 2672 2672 144 145 UYAAAA ONDAAA AAAAxx 585 2381 1 1 5 5 85 585 585 585 585 170 171 NWAAAA PNDAAA HHHHxx 8622 2382 0 2 2 2 22 622 622 3622 8622 44 45 QTAAAA QNDAAA OOOOxx 3780 2383 0 0 0 0 80 780 1780 3780 3780 160 161 KPAAAA RNDAAA VVVVxx 7941 2384 1 1 1 1 41 941 1941 2941 7941 82 83 LTAAAA SNDAAA AAAAxx 3305 2385 1 1 5 5 5 305 1305 3305 3305 10 11 DXAAAA TNDAAA HHHHxx 8653 2386 1 1 3 13 53 653 653 3653 8653 106 107 VUAAAA UNDAAA OOOOxx 5756 2387 0 0 6 16 56 756 1756 756 5756 112 113 KNAAAA VNDAAA VVVVxx 576 2388 0 0 6 16 76 576 576 576 576 152 153 EWAAAA WNDAAA AAAAxx 1915 2389 1 3 5 15 15 915 1915 1915 1915 30 31 RVAAAA XNDAAA HHHHxx 4627 2390 1 3 7 7 27 627 627 4627 4627 54 55 ZVAAAA YNDAAA OOOOxx 920 2391 0 0 0 0 20 920 920 920 920 40 41 KJAAAA ZNDAAA VVVVxx 2537 2392 1 1 7 17 37 537 537 2537 2537 74 75 PTAAAA AODAAA AAAAxx 50 2393 0 2 0 10 50 50 50 50 50 100 101 YBAAAA BODAAA HHHHxx 1313 2394 1 1 3 13 13 313 1313 1313 1313 26 27 NYAAAA CODAAA OOOOxx 8542 2395 0 2 2 2 42 542 542 3542 8542 84 85 OQAAAA DODAAA VVVVxx 6428 2396 0 0 8 8 28 428 428 1428 6428 56 57 GNAAAA EODAAA AAAAxx 4351 2397 1 3 1 11 51 351 351 4351 4351 102 103 JLAAAA FODAAA HHHHxx 2050 2398 0 2 0 10 50 50 50 2050 2050 100 101 WAAAAA GODAAA OOOOxx 5162 2399 0 2 2 2 62 162 1162 162 5162 124 125 OQAAAA HODAAA VVVVxx 8229 2400 1 1 9 9 29 229 229 3229 8229 58 59 NEAAAA IODAAA AAAAxx 7782 2401 0 2 2 2 82 782 1782 2782 7782 164 165 INAAAA JODAAA HHHHxx 1563 2402 1 3 3 3 63 563 1563 1563 1563 126 127 DIAAAA KODAAA OOOOxx 267 2403 1 3 7 7 67 267 267 267 267 134 135 HKAAAA LODAAA VVVVxx 5138 2404 0 2 8 18 38 138 1138 138 5138 76 77 QPAAAA MODAAA AAAAxx 7022 2405 0 2 2 2 22 22 1022 2022 7022 44 45 CKAAAA NODAAA HHHHxx 6705 2406 1 1 5 5 5 705 705 1705 6705 10 11 XXAAAA OODAAA OOOOxx 6190 2407 0 2 0 10 90 190 190 1190 6190 180 181 CEAAAA PODAAA VVVVxx 8226 2408 0 2 6 6 26 226 226 3226 8226 52 53 KEAAAA QODAAA AAAAxx 8882 2409 0 2 2 2 82 882 882 3882 8882 164 165 QDAAAA RODAAA HHHHxx 5181 2410 1 1 1 1 81 181 1181 181 5181 162 163 HRAAAA SODAAA OOOOxx 4598 2411 0 2 8 18 98 598 598 4598 4598 196 197 WUAAAA TODAAA VVVVxx 4882 2412 0 2 2 2 82 882 882 4882 4882 164 165 UFAAAA UODAAA AAAAxx 7490 2413 0 2 0 10 90 490 1490 2490 7490 180 181 CCAAAA VODAAA HHHHxx 5224 2414 0 0 4 4 24 224 1224 224 5224 48 49 YSAAAA WODAAA OOOOxx 2174 2415 0 2 4 14 74 174 174 2174 2174 148 149 QFAAAA XODAAA VVVVxx 3059 2416 1 3 9 19 59 59 1059 3059 3059 118 119 RNAAAA YODAAA AAAAxx 8790 2417 0 2 0 10 90 790 790 3790 8790 180 181 CAAAAA ZODAAA HHHHxx 2222 2418 0 2 2 2 22 222 222 2222 2222 44 45 MHAAAA APDAAA OOOOxx 5473 2419 1 1 3 13 73 473 1473 473 5473 146 147 NCAAAA BPDAAA VVVVxx 937 2420 1 1 7 17 37 937 937 937 937 74 75 BKAAAA CPDAAA AAAAxx 2975 2421 1 3 5 15 75 975 975 2975 2975 150 151 LKAAAA DPDAAA HHHHxx 9569 2422 1 1 9 9 69 569 1569 4569 9569 138 139 BEAAAA EPDAAA OOOOxx 3456 2423 0 0 6 16 56 456 1456 3456 3456 112 113 YCAAAA FPDAAA VVVVxx 6657 2424 1 1 7 17 57 657 657 1657 6657 114 115 BWAAAA GPDAAA AAAAxx 3776 2425 0 0 6 16 76 776 1776 3776 3776 152 153 GPAAAA HPDAAA HHHHxx 6072 2426 0 0 2 12 72 72 72 1072 6072 144 145 OZAAAA IPDAAA OOOOxx 8129 2427 1 1 9 9 29 129 129 3129 8129 58 59 RAAAAA JPDAAA VVVVxx 1085 2428 1 1 5 5 85 85 1085 1085 1085 170 171 TPAAAA KPDAAA AAAAxx 2079 2429 1 3 9 19 79 79 79 2079 2079 158 159 ZBAAAA LPDAAA HHHHxx 1200 2430 0 0 0 0 0 200 1200 1200 1200 0 1 EUAAAA MPDAAA OOOOxx 3276 2431 0 0 6 16 76 276 1276 3276 3276 152 153 AWAAAA NPDAAA VVVVxx 2608 2432 0 0 8 8 8 608 608 2608 2608 16 17 IWAAAA OPDAAA AAAAxx 702 2433 0 2 2 2 2 702 702 702 702 4 5 ABAAAA PPDAAA HHHHxx 5750 2434 0 2 0 10 50 750 1750 750 5750 100 101 ENAAAA QPDAAA OOOOxx 2776 2435 0 0 6 16 76 776 776 2776 2776 152 153 UCAAAA RPDAAA VVVVxx 9151 2436 1 3 1 11 51 151 1151 4151 9151 102 103 ZNAAAA SPDAAA AAAAxx 3282 2437 0 2 2 2 82 282 1282 3282 3282 164 165 GWAAAA TPDAAA HHHHxx 408 2438 0 0 8 8 8 408 408 408 408 16 17 SPAAAA UPDAAA OOOOxx 3473 2439 1 1 3 13 73 473 1473 3473 3473 146 147 PDAAAA VPDAAA VVVVxx 7095 2440 1 3 5 15 95 95 1095 2095 7095 190 191 XMAAAA WPDAAA AAAAxx 3288 2441 0 0 8 8 88 288 1288 3288 3288 176 177 MWAAAA XPDAAA HHHHxx 8215 2442 1 3 5 15 15 215 215 3215 8215 30 31 ZDAAAA YPDAAA OOOOxx 6244 2443 0 0 4 4 44 244 244 1244 6244 88 89 EGAAAA ZPDAAA VVVVxx 8440 2444 0 0 0 0 40 440 440 3440 8440 80 81 QMAAAA AQDAAA AAAAxx 3800 2445 0 0 0 0 0 800 1800 3800 3800 0 1 EQAAAA BQDAAA HHHHxx 7279 2446 1 3 9 19 79 279 1279 2279 7279 158 159 ZTAAAA CQDAAA OOOOxx 9206 2447 0 2 6 6 6 206 1206 4206 9206 12 13 CQAAAA DQDAAA VVVVxx 6465 2448 1 1 5 5 65 465 465 1465 6465 130 131 ROAAAA EQDAAA AAAAxx 4127 2449 1 3 7 7 27 127 127 4127 4127 54 55 TCAAAA FQDAAA HHHHxx 7463 2450 1 3 3 3 63 463 1463 2463 7463 126 127 BBAAAA GQDAAA OOOOxx 5117 2451 1 1 7 17 17 117 1117 117 5117 34 35 VOAAAA HQDAAA VVVVxx 4715 2452 1 3 5 15 15 715 715 4715 4715 30 31 JZAAAA IQDAAA AAAAxx 2010 2453 0 2 0 10 10 10 10 2010 2010 20 21 IZAAAA JQDAAA HHHHxx 6486 2454 0 2 6 6 86 486 486 1486 6486 172 173 MPAAAA KQDAAA OOOOxx 6434 2455 0 2 4 14 34 434 434 1434 6434 68 69 MNAAAA LQDAAA VVVVxx 2151 2456 1 3 1 11 51 151 151 2151 2151 102 103 TEAAAA MQDAAA AAAAxx 4821 2457 1 1 1 1 21 821 821 4821 4821 42 43 LDAAAA NQDAAA HHHHxx 6507 2458 1 3 7 7 7 507 507 1507 6507 14 15 HQAAAA OQDAAA OOOOxx 8741 2459 1 1 1 1 41 741 741 3741 8741 82 83 FYAAAA PQDAAA VVVVxx 6846 2460 0 2 6 6 46 846 846 1846 6846 92 93 IDAAAA QQDAAA AAAAxx 4525 2461 1 1 5 5 25 525 525 4525 4525 50 51 BSAAAA RQDAAA HHHHxx 8299 2462 1 3 9 19 99 299 299 3299 8299 198 199 FHAAAA SQDAAA OOOOxx 5465 2463 1 1 5 5 65 465 1465 465 5465 130 131 FCAAAA TQDAAA VVVVxx 7206 2464 0 2 6 6 6 206 1206 2206 7206 12 13 ERAAAA UQDAAA AAAAxx 2616 2465 0 0 6 16 16 616 616 2616 2616 32 33 QWAAAA VQDAAA HHHHxx 4440 2466 0 0 0 0 40 440 440 4440 4440 80 81 UOAAAA WQDAAA OOOOxx 6109 2467 1 1 9 9 9 109 109 1109 6109 18 19 ZAAAAA XQDAAA VVVVxx 7905 2468 1 1 5 5 5 905 1905 2905 7905 10 11 BSAAAA YQDAAA AAAAxx 6498 2469 0 2 8 18 98 498 498 1498 6498 196 197 YPAAAA ZQDAAA HHHHxx 2034 2470 0 2 4 14 34 34 34 2034 2034 68 69 GAAAAA ARDAAA OOOOxx 7693 2471 1 1 3 13 93 693 1693 2693 7693 186 187 XJAAAA BRDAAA VVVVxx 7511 2472 1 3 1 11 11 511 1511 2511 7511 22 23 XCAAAA CRDAAA AAAAxx 7531 2473 1 3 1 11 31 531 1531 2531 7531 62 63 RDAAAA DRDAAA HHHHxx 6869 2474 1 1 9 9 69 869 869 1869 6869 138 139 FEAAAA ERDAAA OOOOxx 2763 2475 1 3 3 3 63 763 763 2763 2763 126 127 HCAAAA FRDAAA VVVVxx 575 2476 1 3 5 15 75 575 575 575 575 150 151 DWAAAA GRDAAA AAAAxx 8953 2477 1 1 3 13 53 953 953 3953 8953 106 107 JGAAAA HRDAAA HHHHxx 5833 2478 1 1 3 13 33 833 1833 833 5833 66 67 JQAAAA IRDAAA OOOOxx 9035 2479 1 3 5 15 35 35 1035 4035 9035 70 71 NJAAAA JRDAAA VVVVxx 9123 2480 1 3 3 3 23 123 1123 4123 9123 46 47 XMAAAA KRDAAA AAAAxx 206 2481 0 2 6 6 6 206 206 206 206 12 13 YHAAAA LRDAAA HHHHxx 4155 2482 1 3 5 15 55 155 155 4155 4155 110 111 VDAAAA MRDAAA OOOOxx 532 2483 0 0 2 12 32 532 532 532 532 64 65 MUAAAA NRDAAA VVVVxx 1370 2484 0 2 0 10 70 370 1370 1370 1370 140 141 SAAAAA ORDAAA AAAAxx 7656 2485 0 0 6 16 56 656 1656 2656 7656 112 113 MIAAAA PRDAAA HHHHxx 7735 2486 1 3 5 15 35 735 1735 2735 7735 70 71 NLAAAA QRDAAA OOOOxx 2118 2487 0 2 8 18 18 118 118 2118 2118 36 37 MDAAAA RRDAAA VVVVxx 6914 2488 0 2 4 14 14 914 914 1914 6914 28 29 YFAAAA SRDAAA AAAAxx 6277 2489 1 1 7 17 77 277 277 1277 6277 154 155 LHAAAA TRDAAA HHHHxx 6347 2490 1 3 7 7 47 347 347 1347 6347 94 95 DKAAAA URDAAA OOOOxx 4030 2491 0 2 0 10 30 30 30 4030 4030 60 61 AZAAAA VRDAAA VVVVxx 9673 2492 1 1 3 13 73 673 1673 4673 9673 146 147 BIAAAA WRDAAA AAAAxx 2015 2493 1 3 5 15 15 15 15 2015 2015 30 31 NZAAAA XRDAAA HHHHxx 1317 2494 1 1 7 17 17 317 1317 1317 1317 34 35 RYAAAA YRDAAA OOOOxx 404 2495 0 0 4 4 4 404 404 404 404 8 9 OPAAAA ZRDAAA VVVVxx 1604 2496 0 0 4 4 4 604 1604 1604 1604 8 9 SJAAAA ASDAAA AAAAxx 1912 2497 0 0 2 12 12 912 1912 1912 1912 24 25 OVAAAA BSDAAA HHHHxx 5727 2498 1 3 7 7 27 727 1727 727 5727 54 55 HMAAAA CSDAAA OOOOxx 4538 2499 0 2 8 18 38 538 538 4538 4538 76 77 OSAAAA DSDAAA VVVVxx 6868 2500 0 0 8 8 68 868 868 1868 6868 136 137 EEAAAA ESDAAA AAAAxx 9801 2501 1 1 1 1 1 801 1801 4801 9801 2 3 ZMAAAA FSDAAA HHHHxx 1781 2502 1 1 1 1 81 781 1781 1781 1781 162 163 NQAAAA GSDAAA OOOOxx 7061 2503 1 1 1 1 61 61 1061 2061 7061 122 123 PLAAAA HSDAAA VVVVxx 2412 2504 0 0 2 12 12 412 412 2412 2412 24 25 UOAAAA ISDAAA AAAAxx 9191 2505 1 3 1 11 91 191 1191 4191 9191 182 183 NPAAAA JSDAAA HHHHxx 1958 2506 0 2 8 18 58 958 1958 1958 1958 116 117 IXAAAA KSDAAA OOOOxx 2203 2507 1 3 3 3 3 203 203 2203 2203 6 7 TGAAAA LSDAAA VVVVxx 9104 2508 0 0 4 4 4 104 1104 4104 9104 8 9 EMAAAA MSDAAA AAAAxx 3837 2509 1 1 7 17 37 837 1837 3837 3837 74 75 PRAAAA NSDAAA HHHHxx 7055 2510 1 3 5 15 55 55 1055 2055 7055 110 111 JLAAAA OSDAAA OOOOxx 4612 2511 0 0 2 12 12 612 612 4612 4612 24 25 KVAAAA PSDAAA VVVVxx 6420 2512 0 0 0 0 20 420 420 1420 6420 40 41 YMAAAA QSDAAA AAAAxx 613 2513 1 1 3 13 13 613 613 613 613 26 27 PXAAAA RSDAAA HHHHxx 1691 2514 1 3 1 11 91 691 1691 1691 1691 182 183 BNAAAA SSDAAA OOOOxx 33 2515 1 1 3 13 33 33 33 33 33 66 67 HBAAAA TSDAAA VVVVxx 875 2516 1 3 5 15 75 875 875 875 875 150 151 RHAAAA USDAAA AAAAxx 9030 2517 0 2 0 10 30 30 1030 4030 9030 60 61 IJAAAA VSDAAA HHHHxx 4285 2518 1 1 5 5 85 285 285 4285 4285 170 171 VIAAAA WSDAAA OOOOxx 6236 2519 0 0 6 16 36 236 236 1236 6236 72 73 WFAAAA XSDAAA VVVVxx 4702 2520 0 2 2 2 2 702 702 4702 4702 4 5 WYAAAA YSDAAA AAAAxx 3441 2521 1 1 1 1 41 441 1441 3441 3441 82 83 JCAAAA ZSDAAA HHHHxx 2150 2522 0 2 0 10 50 150 150 2150 2150 100 101 SEAAAA ATDAAA OOOOxx 1852 2523 0 0 2 12 52 852 1852 1852 1852 104 105 GTAAAA BTDAAA VVVVxx 7713 2524 1 1 3 13 13 713 1713 2713 7713 26 27 RKAAAA CTDAAA AAAAxx 6849 2525 1 1 9 9 49 849 849 1849 6849 98 99 LDAAAA DTDAAA HHHHxx 3425 2526 1 1 5 5 25 425 1425 3425 3425 50 51 TBAAAA ETDAAA OOOOxx 4681 2527 1 1 1 1 81 681 681 4681 4681 162 163 BYAAAA FTDAAA VVVVxx 1134 2528 0 2 4 14 34 134 1134 1134 1134 68 69 QRAAAA GTDAAA AAAAxx 7462 2529 0 2 2 2 62 462 1462 2462 7462 124 125 ABAAAA HTDAAA HHHHxx 2148 2530 0 0 8 8 48 148 148 2148 2148 96 97 QEAAAA ITDAAA OOOOxx 5921 2531 1 1 1 1 21 921 1921 921 5921 42 43 TTAAAA JTDAAA VVVVxx 118 2532 0 2 8 18 18 118 118 118 118 36 37 OEAAAA KTDAAA AAAAxx 3065 2533 1 1 5 5 65 65 1065 3065 3065 130 131 XNAAAA LTDAAA HHHHxx 6590 2534 0 2 0 10 90 590 590 1590 6590 180 181 MTAAAA MTDAAA OOOOxx 4993 2535 1 1 3 13 93 993 993 4993 4993 186 187 BKAAAA NTDAAA VVVVxx 6818 2536 0 2 8 18 18 818 818 1818 6818 36 37 GCAAAA OTDAAA AAAAxx 1449 2537 1 1 9 9 49 449 1449 1449 1449 98 99 TDAAAA PTDAAA HHHHxx 2039 2538 1 3 9 19 39 39 39 2039 2039 78 79 LAAAAA QTDAAA OOOOxx 2524 2539 0 0 4 4 24 524 524 2524 2524 48 49 CTAAAA RTDAAA VVVVxx 1481 2540 1 1 1 1 81 481 1481 1481 1481 162 163 ZEAAAA STDAAA AAAAxx 6984 2541 0 0 4 4 84 984 984 1984 6984 168 169 QIAAAA TTDAAA HHHHxx 3960 2542 0 0 0 0 60 960 1960 3960 3960 120 121 IWAAAA UTDAAA OOOOxx 1983 2543 1 3 3 3 83 983 1983 1983 1983 166 167 HYAAAA VTDAAA VVVVxx 6379 2544 1 3 9 19 79 379 379 1379 6379 158 159 JLAAAA WTDAAA AAAAxx 8975 2545 1 3 5 15 75 975 975 3975 8975 150 151 FHAAAA XTDAAA HHHHxx 1102 2546 0 2 2 2 2 102 1102 1102 1102 4 5 KQAAAA YTDAAA OOOOxx 2517 2547 1 1 7 17 17 517 517 2517 2517 34 35 VSAAAA ZTDAAA VVVVxx 712 2548 0 0 2 12 12 712 712 712 712 24 25 KBAAAA AUDAAA AAAAxx 5419 2549 1 3 9 19 19 419 1419 419 5419 38 39 LAAAAA BUDAAA HHHHxx 723 2550 1 3 3 3 23 723 723 723 723 46 47 VBAAAA CUDAAA OOOOxx 8057 2551 1 1 7 17 57 57 57 3057 8057 114 115 XXAAAA DUDAAA VVVVxx 7471 2552 1 3 1 11 71 471 1471 2471 7471 142 143 JBAAAA EUDAAA AAAAxx 8855 2553 1 3 5 15 55 855 855 3855 8855 110 111 PCAAAA FUDAAA HHHHxx 5074 2554 0 2 4 14 74 74 1074 74 5074 148 149 ENAAAA GUDAAA OOOOxx 7139 2555 1 3 9 19 39 139 1139 2139 7139 78 79 POAAAA HUDAAA VVVVxx 3833 2556 1 1 3 13 33 833 1833 3833 3833 66 67 LRAAAA IUDAAA AAAAxx 5186 2557 0 2 6 6 86 186 1186 186 5186 172 173 MRAAAA JUDAAA HHHHxx 9436 2558 0 0 6 16 36 436 1436 4436 9436 72 73 YYAAAA KUDAAA OOOOxx 8859 2559 1 3 9 19 59 859 859 3859 8859 118 119 TCAAAA LUDAAA VVVVxx 6943 2560 1 3 3 3 43 943 943 1943 6943 86 87 BHAAAA MUDAAA AAAAxx 2315 2561 1 3 5 15 15 315 315 2315 2315 30 31 BLAAAA NUDAAA HHHHxx 1394 2562 0 2 4 14 94 394 1394 1394 1394 188 189 QBAAAA OUDAAA OOOOxx 8863 2563 1 3 3 3 63 863 863 3863 8863 126 127 XCAAAA PUDAAA VVVVxx 8812 2564 0 0 2 12 12 812 812 3812 8812 24 25 YAAAAA QUDAAA AAAAxx 7498 2565 0 2 8 18 98 498 1498 2498 7498 196 197 KCAAAA RUDAAA HHHHxx 8962 2566 0 2 2 2 62 962 962 3962 8962 124 125 SGAAAA SUDAAA OOOOxx 2533 2567 1 1 3 13 33 533 533 2533 2533 66 67 LTAAAA TUDAAA VVVVxx 8188 2568 0 0 8 8 88 188 188 3188 8188 176 177 YCAAAA UUDAAA AAAAxx 6137 2569 1 1 7 17 37 137 137 1137 6137 74 75 BCAAAA VUDAAA HHHHxx 974 2570 0 2 4 14 74 974 974 974 974 148 149 MLAAAA WUDAAA OOOOxx 2751 2571 1 3 1 11 51 751 751 2751 2751 102 103 VBAAAA XUDAAA VVVVxx 4975 2572 1 3 5 15 75 975 975 4975 4975 150 151 JJAAAA YUDAAA AAAAxx 3411 2573 1 3 1 11 11 411 1411 3411 3411 22 23 FBAAAA ZUDAAA HHHHxx 3143 2574 1 3 3 3 43 143 1143 3143 3143 86 87 XQAAAA AVDAAA OOOOxx 8011 2575 1 3 1 11 11 11 11 3011 8011 22 23 DWAAAA BVDAAA VVVVxx 988 2576 0 0 8 8 88 988 988 988 988 176 177 AMAAAA CVDAAA AAAAxx 4289 2577 1 1 9 9 89 289 289 4289 4289 178 179 ZIAAAA DVDAAA HHHHxx 8105 2578 1 1 5 5 5 105 105 3105 8105 10 11 TZAAAA EVDAAA OOOOxx 9885 2579 1 1 5 5 85 885 1885 4885 9885 170 171 FQAAAA FVDAAA VVVVxx 1002 2580 0 2 2 2 2 2 1002 1002 1002 4 5 OMAAAA GVDAAA AAAAxx 5827 2581 1 3 7 7 27 827 1827 827 5827 54 55 DQAAAA HVDAAA HHHHxx 1228 2582 0 0 8 8 28 228 1228 1228 1228 56 57 GVAAAA IVDAAA OOOOxx 6352 2583 0 0 2 12 52 352 352 1352 6352 104 105 IKAAAA JVDAAA VVVVxx 8868 2584 0 0 8 8 68 868 868 3868 8868 136 137 CDAAAA KVDAAA AAAAxx 3643 2585 1 3 3 3 43 643 1643 3643 3643 86 87 DKAAAA LVDAAA HHHHxx 1468 2586 0 0 8 8 68 468 1468 1468 1468 136 137 MEAAAA MVDAAA OOOOxx 8415 2587 1 3 5 15 15 415 415 3415 8415 30 31 RLAAAA NVDAAA VVVVxx 9631 2588 1 3 1 11 31 631 1631 4631 9631 62 63 LGAAAA OVDAAA AAAAxx 7408 2589 0 0 8 8 8 408 1408 2408 7408 16 17 YYAAAA PVDAAA HHHHxx 1934 2590 0 2 4 14 34 934 1934 1934 1934 68 69 KWAAAA QVDAAA OOOOxx 996 2591 0 0 6 16 96 996 996 996 996 192 193 IMAAAA RVDAAA VVVVxx 8027 2592 1 3 7 7 27 27 27 3027 8027 54 55 TWAAAA SVDAAA AAAAxx 8464 2593 0 0 4 4 64 464 464 3464 8464 128 129 ONAAAA TVDAAA HHHHxx 5007 2594 1 3 7 7 7 7 1007 7 5007 14 15 PKAAAA UVDAAA OOOOxx 8356 2595 0 0 6 16 56 356 356 3356 8356 112 113 KJAAAA VVDAAA VVVVxx 4579 2596 1 3 9 19 79 579 579 4579 4579 158 159 DUAAAA WVDAAA AAAAxx 8513 2597 1 1 3 13 13 513 513 3513 8513 26 27 LPAAAA XVDAAA HHHHxx 383 2598 1 3 3 3 83 383 383 383 383 166 167 TOAAAA YVDAAA OOOOxx 9304 2599 0 0 4 4 4 304 1304 4304 9304 8 9 WTAAAA ZVDAAA VVVVxx 7224 2600 0 0 4 4 24 224 1224 2224 7224 48 49 WRAAAA AWDAAA AAAAxx 6023 2601 1 3 3 3 23 23 23 1023 6023 46 47 RXAAAA BWDAAA HHHHxx 2746 2602 0 2 6 6 46 746 746 2746 2746 92 93 QBAAAA CWDAAA OOOOxx 137 2603 1 1 7 17 37 137 137 137 137 74 75 HFAAAA DWDAAA VVVVxx 9441 2604 1 1 1 1 41 441 1441 4441 9441 82 83 DZAAAA EWDAAA AAAAxx 3690 2605 0 2 0 10 90 690 1690 3690 3690 180 181 YLAAAA FWDAAA HHHHxx 913 2606 1 1 3 13 13 913 913 913 913 26 27 DJAAAA GWDAAA OOOOxx 1768 2607 0 0 8 8 68 768 1768 1768 1768 136 137 AQAAAA HWDAAA VVVVxx 8492 2608 0 0 2 12 92 492 492 3492 8492 184 185 QOAAAA IWDAAA AAAAxx 8083 2609 1 3 3 3 83 83 83 3083 8083 166 167 XYAAAA JWDAAA HHHHxx 4609 2610 1 1 9 9 9 609 609 4609 4609 18 19 HVAAAA KWDAAA OOOOxx 7520 2611 0 0 0 0 20 520 1520 2520 7520 40 41 GDAAAA LWDAAA VVVVxx 4231 2612 1 3 1 11 31 231 231 4231 4231 62 63 TGAAAA MWDAAA AAAAxx 6022 2613 0 2 2 2 22 22 22 1022 6022 44 45 QXAAAA NWDAAA HHHHxx 9784 2614 0 0 4 4 84 784 1784 4784 9784 168 169 IMAAAA OWDAAA OOOOxx 1343 2615 1 3 3 3 43 343 1343 1343 1343 86 87 RZAAAA PWDAAA VVVVxx 7549 2616 1 1 9 9 49 549 1549 2549 7549 98 99 JEAAAA QWDAAA AAAAxx 269 2617 1 1 9 9 69 269 269 269 269 138 139 JKAAAA RWDAAA HHHHxx 1069 2618 1 1 9 9 69 69 1069 1069 1069 138 139 DPAAAA SWDAAA OOOOxx 4610 2619 0 2 0 10 10 610 610 4610 4610 20 21 IVAAAA TWDAAA VVVVxx 482 2620 0 2 2 2 82 482 482 482 482 164 165 OSAAAA UWDAAA AAAAxx 3025 2621 1 1 5 5 25 25 1025 3025 3025 50 51 JMAAAA VWDAAA HHHHxx 7914 2622 0 2 4 14 14 914 1914 2914 7914 28 29 KSAAAA WWDAAA OOOOxx 3198 2623 0 2 8 18 98 198 1198 3198 3198 196 197 ATAAAA XWDAAA VVVVxx 1187 2624 1 3 7 7 87 187 1187 1187 1187 174 175 RTAAAA YWDAAA AAAAxx 4707 2625 1 3 7 7 7 707 707 4707 4707 14 15 BZAAAA ZWDAAA HHHHxx 8279 2626 1 3 9 19 79 279 279 3279 8279 158 159 LGAAAA AXDAAA OOOOxx 6127 2627 1 3 7 7 27 127 127 1127 6127 54 55 RBAAAA BXDAAA VVVVxx 1305 2628 1 1 5 5 5 305 1305 1305 1305 10 11 FYAAAA CXDAAA AAAAxx 4804 2629 0 0 4 4 4 804 804 4804 4804 8 9 UCAAAA DXDAAA HHHHxx 6069 2630 1 1 9 9 69 69 69 1069 6069 138 139 LZAAAA EXDAAA OOOOxx 9229 2631 1 1 9 9 29 229 1229 4229 9229 58 59 ZQAAAA FXDAAA VVVVxx 4703 2632 1 3 3 3 3 703 703 4703 4703 6 7 XYAAAA GXDAAA AAAAxx 6410 2633 0 2 0 10 10 410 410 1410 6410 20 21 OMAAAA HXDAAA HHHHxx 944 2634 0 0 4 4 44 944 944 944 944 88 89 IKAAAA IXDAAA OOOOxx 3744 2635 0 0 4 4 44 744 1744 3744 3744 88 89 AOAAAA JXDAAA VVVVxx 1127 2636 1 3 7 7 27 127 1127 1127 1127 54 55 JRAAAA KXDAAA AAAAxx 6693 2637 1 1 3 13 93 693 693 1693 6693 186 187 LXAAAA LXDAAA HHHHxx 583 2638 1 3 3 3 83 583 583 583 583 166 167 LWAAAA MXDAAA OOOOxx 2684 2639 0 0 4 4 84 684 684 2684 2684 168 169 GZAAAA NXDAAA VVVVxx 6192 2640 0 0 2 12 92 192 192 1192 6192 184 185 EEAAAA OXDAAA AAAAxx 4157 2641 1 1 7 17 57 157 157 4157 4157 114 115 XDAAAA PXDAAA HHHHxx 6470 2642 0 2 0 10 70 470 470 1470 6470 140 141 WOAAAA QXDAAA OOOOxx 8965 2643 1 1 5 5 65 965 965 3965 8965 130 131 VGAAAA RXDAAA VVVVxx 1433 2644 1 1 3 13 33 433 1433 1433 1433 66 67 DDAAAA SXDAAA AAAAxx 4570 2645 0 2 0 10 70 570 570 4570 4570 140 141 UTAAAA TXDAAA HHHHxx 1806 2646 0 2 6 6 6 806 1806 1806 1806 12 13 MRAAAA UXDAAA OOOOxx 1230 2647 0 2 0 10 30 230 1230 1230 1230 60 61 IVAAAA VXDAAA VVVVxx 2283 2648 1 3 3 3 83 283 283 2283 2283 166 167 VJAAAA WXDAAA AAAAxx 6456 2649 0 0 6 16 56 456 456 1456 6456 112 113 IOAAAA XXDAAA HHHHxx 7427 2650 1 3 7 7 27 427 1427 2427 7427 54 55 RZAAAA YXDAAA OOOOxx 8310 2651 0 2 0 10 10 310 310 3310 8310 20 21 QHAAAA ZXDAAA VVVVxx 8103 2652 1 3 3 3 3 103 103 3103 8103 6 7 RZAAAA AYDAAA AAAAxx 3947 2653 1 3 7 7 47 947 1947 3947 3947 94 95 VVAAAA BYDAAA HHHHxx 3414 2654 0 2 4 14 14 414 1414 3414 3414 28 29 IBAAAA CYDAAA OOOOxx 2043 2655 1 3 3 3 43 43 43 2043 2043 86 87 PAAAAA DYDAAA VVVVxx 4393 2656 1 1 3 13 93 393 393 4393 4393 186 187 ZMAAAA EYDAAA AAAAxx 6664 2657 0 0 4 4 64 664 664 1664 6664 128 129 IWAAAA FYDAAA HHHHxx 4545 2658 1 1 5 5 45 545 545 4545 4545 90 91 VSAAAA GYDAAA OOOOxx 7637 2659 1 1 7 17 37 637 1637 2637 7637 74 75 THAAAA HYDAAA VVVVxx 1359 2660 1 3 9 19 59 359 1359 1359 1359 118 119 HAAAAA IYDAAA AAAAxx 5018 2661 0 2 8 18 18 18 1018 18 5018 36 37 ALAAAA JYDAAA HHHHxx 987 2662 1 3 7 7 87 987 987 987 987 174 175 ZLAAAA KYDAAA OOOOxx 1320 2663 0 0 0 0 20 320 1320 1320 1320 40 41 UYAAAA LYDAAA VVVVxx 9311 2664 1 3 1 11 11 311 1311 4311 9311 22 23 DUAAAA MYDAAA AAAAxx 7993 2665 1 1 3 13 93 993 1993 2993 7993 186 187 LVAAAA NYDAAA HHHHxx 7588 2666 0 0 8 8 88 588 1588 2588 7588 176 177 WFAAAA OYDAAA OOOOxx 5983 2667 1 3 3 3 83 983 1983 983 5983 166 167 DWAAAA PYDAAA VVVVxx 4070 2668 0 2 0 10 70 70 70 4070 4070 140 141 OAAAAA QYDAAA AAAAxx 8349 2669 1 1 9 9 49 349 349 3349 8349 98 99 DJAAAA RYDAAA HHHHxx 3810 2670 0 2 0 10 10 810 1810 3810 3810 20 21 OQAAAA SYDAAA OOOOxx 6948 2671 0 0 8 8 48 948 948 1948 6948 96 97 GHAAAA TYDAAA VVVVxx 7153 2672 1 1 3 13 53 153 1153 2153 7153 106 107 DPAAAA UYDAAA AAAAxx 5371 2673 1 3 1 11 71 371 1371 371 5371 142 143 PYAAAA VYDAAA HHHHxx 8316 2674 0 0 6 16 16 316 316 3316 8316 32 33 WHAAAA WYDAAA OOOOxx 5903 2675 1 3 3 3 3 903 1903 903 5903 6 7 BTAAAA XYDAAA VVVVxx 6718 2676 0 2 8 18 18 718 718 1718 6718 36 37 KYAAAA YYDAAA AAAAxx 4759 2677 1 3 9 19 59 759 759 4759 4759 118 119 BBAAAA ZYDAAA HHHHxx 2555 2678 1 3 5 15 55 555 555 2555 2555 110 111 HUAAAA AZDAAA OOOOxx 3457 2679 1 1 7 17 57 457 1457 3457 3457 114 115 ZCAAAA BZDAAA VVVVxx 9626 2680 0 2 6 6 26 626 1626 4626 9626 52 53 GGAAAA CZDAAA AAAAxx 2570 2681 0 2 0 10 70 570 570 2570 2570 140 141 WUAAAA DZDAAA HHHHxx 7964 2682 0 0 4 4 64 964 1964 2964 7964 128 129 IUAAAA EZDAAA OOOOxx 1543 2683 1 3 3 3 43 543 1543 1543 1543 86 87 JHAAAA FZDAAA VVVVxx 929 2684 1 1 9 9 29 929 929 929 929 58 59 TJAAAA GZDAAA AAAAxx 9244 2685 0 0 4 4 44 244 1244 4244 9244 88 89 ORAAAA HZDAAA HHHHxx 9210 2686 0 2 0 10 10 210 1210 4210 9210 20 21 GQAAAA IZDAAA OOOOxx 8334 2687 0 2 4 14 34 334 334 3334 8334 68 69 OIAAAA JZDAAA VVVVxx 9310 2688 0 2 0 10 10 310 1310 4310 9310 20 21 CUAAAA KZDAAA AAAAxx 5024 2689 0 0 4 4 24 24 1024 24 5024 48 49 GLAAAA LZDAAA HHHHxx 8794 2690 0 2 4 14 94 794 794 3794 8794 188 189 GAAAAA MZDAAA OOOOxx 4091 2691 1 3 1 11 91 91 91 4091 4091 182 183 JBAAAA NZDAAA VVVVxx 649 2692 1 1 9 9 49 649 649 649 649 98 99 ZYAAAA OZDAAA AAAAxx 8505 2693 1 1 5 5 5 505 505 3505 8505 10 11 DPAAAA PZDAAA HHHHxx 6652 2694 0 0 2 12 52 652 652 1652 6652 104 105 WVAAAA QZDAAA OOOOxx 8945 2695 1 1 5 5 45 945 945 3945 8945 90 91 BGAAAA RZDAAA VVVVxx 2095 2696 1 3 5 15 95 95 95 2095 2095 190 191 PCAAAA SZDAAA AAAAxx 8676 2697 0 0 6 16 76 676 676 3676 8676 152 153 SVAAAA TZDAAA HHHHxx 3994 2698 0 2 4 14 94 994 1994 3994 3994 188 189 QXAAAA UZDAAA OOOOxx 2859 2699 1 3 9 19 59 859 859 2859 2859 118 119 ZFAAAA VZDAAA VVVVxx 5403 2700 1 3 3 3 3 403 1403 403 5403 6 7 VZAAAA WZDAAA AAAAxx 3254 2701 0 2 4 14 54 254 1254 3254 3254 108 109 EVAAAA XZDAAA HHHHxx 7339 2702 1 3 9 19 39 339 1339 2339 7339 78 79 HWAAAA YZDAAA OOOOxx 7220 2703 0 0 0 0 20 220 1220 2220 7220 40 41 SRAAAA ZZDAAA VVVVxx 4154 2704 0 2 4 14 54 154 154 4154 4154 108 109 UDAAAA AAEAAA AAAAxx 7570 2705 0 2 0 10 70 570 1570 2570 7570 140 141 EFAAAA BAEAAA HHHHxx 2576 2706 0 0 6 16 76 576 576 2576 2576 152 153 CVAAAA CAEAAA OOOOxx 5764 2707 0 0 4 4 64 764 1764 764 5764 128 129 SNAAAA DAEAAA VVVVxx 4314 2708 0 2 4 14 14 314 314 4314 4314 28 29 YJAAAA EAEAAA AAAAxx 2274 2709 0 2 4 14 74 274 274 2274 2274 148 149 MJAAAA FAEAAA HHHHxx 9756 2710 0 0 6 16 56 756 1756 4756 9756 112 113 GLAAAA GAEAAA OOOOxx 8274 2711 0 2 4 14 74 274 274 3274 8274 148 149 GGAAAA HAEAAA VVVVxx 1289 2712 1 1 9 9 89 289 1289 1289 1289 178 179 PXAAAA IAEAAA AAAAxx 7335 2713 1 3 5 15 35 335 1335 2335 7335 70 71 DWAAAA JAEAAA HHHHxx 5351 2714 1 3 1 11 51 351 1351 351 5351 102 103 VXAAAA KAEAAA OOOOxx 8978 2715 0 2 8 18 78 978 978 3978 8978 156 157 IHAAAA LAEAAA VVVVxx 2 2716 0 2 2 2 2 2 2 2 2 4 5 CAAAAA MAEAAA AAAAxx 8906 2717 0 2 6 6 6 906 906 3906 8906 12 13 OEAAAA NAEAAA HHHHxx 6388 2718 0 0 8 8 88 388 388 1388 6388 176 177 SLAAAA OAEAAA OOOOxx 5675 2719 1 3 5 15 75 675 1675 675 5675 150 151 HKAAAA PAEAAA VVVVxx 255 2720 1 3 5 15 55 255 255 255 255 110 111 VJAAAA QAEAAA AAAAxx 9538 2721 0 2 8 18 38 538 1538 4538 9538 76 77 WCAAAA RAEAAA HHHHxx 1480 2722 0 0 0 0 80 480 1480 1480 1480 160 161 YEAAAA SAEAAA OOOOxx 4015 2723 1 3 5 15 15 15 15 4015 4015 30 31 LYAAAA TAEAAA VVVVxx 5166 2724 0 2 6 6 66 166 1166 166 5166 132 133 SQAAAA UAEAAA AAAAxx 91 2725 1 3 1 11 91 91 91 91 91 182 183 NDAAAA VAEAAA HHHHxx 2958 2726 0 2 8 18 58 958 958 2958 2958 116 117 UJAAAA WAEAAA OOOOxx 9131 2727 1 3 1 11 31 131 1131 4131 9131 62 63 FNAAAA XAEAAA VVVVxx 3944 2728 0 0 4 4 44 944 1944 3944 3944 88 89 SVAAAA YAEAAA AAAAxx 4514 2729 0 2 4 14 14 514 514 4514 4514 28 29 QRAAAA ZAEAAA HHHHxx 5661 2730 1 1 1 1 61 661 1661 661 5661 122 123 TJAAAA ABEAAA OOOOxx 8724 2731 0 0 4 4 24 724 724 3724 8724 48 49 OXAAAA BBEAAA VVVVxx 6408 2732 0 0 8 8 8 408 408 1408 6408 16 17 MMAAAA CBEAAA AAAAxx 5013 2733 1 1 3 13 13 13 1013 13 5013 26 27 VKAAAA DBEAAA HHHHxx 6156 2734 0 0 6 16 56 156 156 1156 6156 112 113 UCAAAA EBEAAA OOOOxx 7350 2735 0 2 0 10 50 350 1350 2350 7350 100 101 SWAAAA FBEAAA VVVVxx 9858 2736 0 2 8 18 58 858 1858 4858 9858 116 117 EPAAAA GBEAAA AAAAxx 895 2737 1 3 5 15 95 895 895 895 895 190 191 LIAAAA HBEAAA HHHHxx 8368 2738 0 0 8 8 68 368 368 3368 8368 136 137 WJAAAA IBEAAA OOOOxx 179 2739 1 3 9 19 79 179 179 179 179 158 159 XGAAAA JBEAAA VVVVxx 4048 2740 0 0 8 8 48 48 48 4048 4048 96 97 SZAAAA KBEAAA AAAAxx 3073 2741 1 1 3 13 73 73 1073 3073 3073 146 147 FOAAAA LBEAAA HHHHxx 321 2742 1 1 1 1 21 321 321 321 321 42 43 JMAAAA MBEAAA OOOOxx 5352 2743 0 0 2 12 52 352 1352 352 5352 104 105 WXAAAA NBEAAA VVVVxx 1940 2744 0 0 0 0 40 940 1940 1940 1940 80 81 QWAAAA OBEAAA AAAAxx 8803 2745 1 3 3 3 3 803 803 3803 8803 6 7 PAAAAA PBEAAA HHHHxx 791 2746 1 3 1 11 91 791 791 791 791 182 183 LEAAAA QBEAAA OOOOxx 9809 2747 1 1 9 9 9 809 1809 4809 9809 18 19 HNAAAA RBEAAA VVVVxx 5519 2748 1 3 9 19 19 519 1519 519 5519 38 39 HEAAAA SBEAAA AAAAxx 7420 2749 0 0 0 0 20 420 1420 2420 7420 40 41 KZAAAA TBEAAA HHHHxx 7541 2750 1 1 1 1 41 541 1541 2541 7541 82 83 BEAAAA UBEAAA OOOOxx 6538 2751 0 2 8 18 38 538 538 1538 6538 76 77 MRAAAA VBEAAA VVVVxx 710 2752 0 2 0 10 10 710 710 710 710 20 21 IBAAAA WBEAAA AAAAxx 9488 2753 0 0 8 8 88 488 1488 4488 9488 176 177 YAAAAA XBEAAA HHHHxx 3135 2754 1 3 5 15 35 135 1135 3135 3135 70 71 PQAAAA YBEAAA OOOOxx 4273 2755 1 1 3 13 73 273 273 4273 4273 146 147 JIAAAA ZBEAAA VVVVxx 629 2756 1 1 9 9 29 629 629 629 629 58 59 FYAAAA ACEAAA AAAAxx 9167 2757 1 3 7 7 67 167 1167 4167 9167 134 135 POAAAA BCEAAA HHHHxx 751 2758 1 3 1 11 51 751 751 751 751 102 103 XCAAAA CCEAAA OOOOxx 1126 2759 0 2 6 6 26 126 1126 1126 1126 52 53 IRAAAA DCEAAA VVVVxx 3724 2760 0 0 4 4 24 724 1724 3724 3724 48 49 GNAAAA ECEAAA AAAAxx 1789 2761 1 1 9 9 89 789 1789 1789 1789 178 179 VQAAAA FCEAAA HHHHxx 792 2762 0 0 2 12 92 792 792 792 792 184 185 MEAAAA GCEAAA OOOOxx 2771 2763 1 3 1 11 71 771 771 2771 2771 142 143 PCAAAA HCEAAA VVVVxx 4313 2764 1 1 3 13 13 313 313 4313 4313 26 27 XJAAAA ICEAAA AAAAxx 9312 2765 0 0 2 12 12 312 1312 4312 9312 24 25 EUAAAA JCEAAA HHHHxx 955 2766 1 3 5 15 55 955 955 955 955 110 111 TKAAAA KCEAAA OOOOxx 6382 2767 0 2 2 2 82 382 382 1382 6382 164 165 MLAAAA LCEAAA VVVVxx 7875 2768 1 3 5 15 75 875 1875 2875 7875 150 151 XQAAAA MCEAAA AAAAxx 7491 2769 1 3 1 11 91 491 1491 2491 7491 182 183 DCAAAA NCEAAA HHHHxx 8193 2770 1 1 3 13 93 193 193 3193 8193 186 187 DDAAAA OCEAAA OOOOxx 968 2771 0 0 8 8 68 968 968 968 968 136 137 GLAAAA PCEAAA VVVVxx 4951 2772 1 3 1 11 51 951 951 4951 4951 102 103 LIAAAA QCEAAA AAAAxx 2204 2773 0 0 4 4 4 204 204 2204 2204 8 9 UGAAAA RCEAAA HHHHxx 2066 2774 0 2 6 6 66 66 66 2066 2066 132 133 MBAAAA SCEAAA OOOOxx 2631 2775 1 3 1 11 31 631 631 2631 2631 62 63 FXAAAA TCEAAA VVVVxx 8947 2776 1 3 7 7 47 947 947 3947 8947 94 95 DGAAAA UCEAAA AAAAxx 8033 2777 1 1 3 13 33 33 33 3033 8033 66 67 ZWAAAA VCEAAA HHHHxx 6264 2778 0 0 4 4 64 264 264 1264 6264 128 129 YGAAAA WCEAAA OOOOxx 7778 2779 0 2 8 18 78 778 1778 2778 7778 156 157 ENAAAA XCEAAA VVVVxx 9701 2780 1 1 1 1 1 701 1701 4701 9701 2 3 DJAAAA YCEAAA AAAAxx 5091 2781 1 3 1 11 91 91 1091 91 5091 182 183 VNAAAA ZCEAAA HHHHxx 7577 2782 1 1 7 17 77 577 1577 2577 7577 154 155 LFAAAA ADEAAA OOOOxx 3345 2783 1 1 5 5 45 345 1345 3345 3345 90 91 RYAAAA BDEAAA VVVVxx 7329 2784 1 1 9 9 29 329 1329 2329 7329 58 59 XVAAAA CDEAAA AAAAxx 7551 2785 1 3 1 11 51 551 1551 2551 7551 102 103 LEAAAA DDEAAA HHHHxx 6207 2786 1 3 7 7 7 207 207 1207 6207 14 15 TEAAAA EDEAAA OOOOxx 8664 2787 0 0 4 4 64 664 664 3664 8664 128 129 GVAAAA FDEAAA VVVVxx 8394 2788 0 2 4 14 94 394 394 3394 8394 188 189 WKAAAA GDEAAA AAAAxx 7324 2789 0 0 4 4 24 324 1324 2324 7324 48 49 SVAAAA HDEAAA HHHHxx 2713 2790 1 1 3 13 13 713 713 2713 2713 26 27 JAAAAA IDEAAA OOOOxx 2230 2791 0 2 0 10 30 230 230 2230 2230 60 61 UHAAAA JDEAAA VVVVxx 9211 2792 1 3 1 11 11 211 1211 4211 9211 22 23 HQAAAA KDEAAA AAAAxx 1296 2793 0 0 6 16 96 296 1296 1296 1296 192 193 WXAAAA LDEAAA HHHHxx 8104 2794 0 0 4 4 4 104 104 3104 8104 8 9 SZAAAA MDEAAA OOOOxx 6916 2795 0 0 6 16 16 916 916 1916 6916 32 33 AGAAAA NDEAAA VVVVxx 2208 2796 0 0 8 8 8 208 208 2208 2208 16 17 YGAAAA ODEAAA AAAAxx 3935 2797 1 3 5 15 35 935 1935 3935 3935 70 71 JVAAAA PDEAAA HHHHxx 7814 2798 0 2 4 14 14 814 1814 2814 7814 28 29 OOAAAA QDEAAA OOOOxx 6508 2799 0 0 8 8 8 508 508 1508 6508 16 17 IQAAAA RDEAAA VVVVxx 1703 2800 1 3 3 3 3 703 1703 1703 1703 6 7 NNAAAA SDEAAA AAAAxx 5640 2801 0 0 0 0 40 640 1640 640 5640 80 81 YIAAAA TDEAAA HHHHxx 6417 2802 1 1 7 17 17 417 417 1417 6417 34 35 VMAAAA UDEAAA OOOOxx 1713 2803 1 1 3 13 13 713 1713 1713 1713 26 27 XNAAAA VDEAAA VVVVxx 5309 2804 1 1 9 9 9 309 1309 309 5309 18 19 FWAAAA WDEAAA AAAAxx 4364 2805 0 0 4 4 64 364 364 4364 4364 128 129 WLAAAA XDEAAA HHHHxx 619 2806 1 3 9 19 19 619 619 619 619 38 39 VXAAAA YDEAAA OOOOxx 9498 2807 0 2 8 18 98 498 1498 4498 9498 196 197 IBAAAA ZDEAAA VVVVxx 2804 2808 0 0 4 4 4 804 804 2804 2804 8 9 WDAAAA AEEAAA AAAAxx 2220 2809 0 0 0 0 20 220 220 2220 2220 40 41 KHAAAA BEEAAA HHHHxx 9542 2810 0 2 2 2 42 542 1542 4542 9542 84 85 ADAAAA CEEAAA OOOOxx 3349 2811 1 1 9 9 49 349 1349 3349 3349 98 99 VYAAAA DEEAAA VVVVxx 9198 2812 0 2 8 18 98 198 1198 4198 9198 196 197 UPAAAA EEEAAA AAAAxx 2727 2813 1 3 7 7 27 727 727 2727 2727 54 55 XAAAAA FEEAAA HHHHxx 3768 2814 0 0 8 8 68 768 1768 3768 3768 136 137 YOAAAA GEEAAA OOOOxx 2334 2815 0 2 4 14 34 334 334 2334 2334 68 69 ULAAAA HEEAAA VVVVxx 7770 2816 0 2 0 10 70 770 1770 2770 7770 140 141 WMAAAA IEEAAA AAAAxx 5963 2817 1 3 3 3 63 963 1963 963 5963 126 127 JVAAAA JEEAAA HHHHxx 4732 2818 0 0 2 12 32 732 732 4732 4732 64 65 AAAAAA KEEAAA OOOOxx 2448 2819 0 0 8 8 48 448 448 2448 2448 96 97 EQAAAA LEEAAA VVVVxx 5998 2820 0 2 8 18 98 998 1998 998 5998 196 197 SWAAAA MEEAAA AAAAxx 8577 2821 1 1 7 17 77 577 577 3577 8577 154 155 XRAAAA NEEAAA HHHHxx 266 2822 0 2 6 6 66 266 266 266 266 132 133 GKAAAA OEEAAA OOOOxx 2169 2823 1 1 9 9 69 169 169 2169 2169 138 139 LFAAAA PEEAAA VVVVxx 8228 2824 0 0 8 8 28 228 228 3228 8228 56 57 MEAAAA QEEAAA AAAAxx 4813 2825 1 1 3 13 13 813 813 4813 4813 26 27 DDAAAA REEAAA HHHHxx 2769 2826 1 1 9 9 69 769 769 2769 2769 138 139 NCAAAA SEEAAA OOOOxx 8382 2827 0 2 2 2 82 382 382 3382 8382 164 165 KKAAAA TEEAAA VVVVxx 1717 2828 1 1 7 17 17 717 1717 1717 1717 34 35 BOAAAA UEEAAA AAAAxx 7178 2829 0 2 8 18 78 178 1178 2178 7178 156 157 CQAAAA VEEAAA HHHHxx 9547 2830 1 3 7 7 47 547 1547 4547 9547 94 95 FDAAAA WEEAAA OOOOxx 8187 2831 1 3 7 7 87 187 187 3187 8187 174 175 XCAAAA XEEAAA VVVVxx 3168 2832 0 0 8 8 68 168 1168 3168 3168 136 137 WRAAAA YEEAAA AAAAxx 2180 2833 0 0 0 0 80 180 180 2180 2180 160 161 WFAAAA ZEEAAA HHHHxx 859 2834 1 3 9 19 59 859 859 859 859 118 119 BHAAAA AFEAAA OOOOxx 1554 2835 0 2 4 14 54 554 1554 1554 1554 108 109 UHAAAA BFEAAA VVVVxx 3567 2836 1 3 7 7 67 567 1567 3567 3567 134 135 FHAAAA CFEAAA AAAAxx 5985 2837 1 1 5 5 85 985 1985 985 5985 170 171 FWAAAA DFEAAA HHHHxx 1 2838 1 1 1 1 1 1 1 1 1 2 3 BAAAAA EFEAAA OOOOxx 5937 2839 1 1 7 17 37 937 1937 937 5937 74 75 JUAAAA FFEAAA VVVVxx 7594 2840 0 2 4 14 94 594 1594 2594 7594 188 189 CGAAAA GFEAAA AAAAxx 3783 2841 1 3 3 3 83 783 1783 3783 3783 166 167 NPAAAA HFEAAA HHHHxx 6841 2842 1 1 1 1 41 841 841 1841 6841 82 83 DDAAAA IFEAAA OOOOxx 9694 2843 0 2 4 14 94 694 1694 4694 9694 188 189 WIAAAA JFEAAA VVVVxx 4322 2844 0 2 2 2 22 322 322 4322 4322 44 45 GKAAAA KFEAAA AAAAxx 6012 2845 0 0 2 12 12 12 12 1012 6012 24 25 GXAAAA LFEAAA HHHHxx 108 2846 0 0 8 8 8 108 108 108 108 16 17 EEAAAA MFEAAA OOOOxx 3396 2847 0 0 6 16 96 396 1396 3396 3396 192 193 QAAAAA NFEAAA VVVVxx 8643 2848 1 3 3 3 43 643 643 3643 8643 86 87 LUAAAA OFEAAA AAAAxx 6087 2849 1 3 7 7 87 87 87 1087 6087 174 175 DAAAAA PFEAAA HHHHxx 2629 2850 1 1 9 9 29 629 629 2629 2629 58 59 DXAAAA QFEAAA OOOOxx 3009 2851 1 1 9 9 9 9 1009 3009 3009 18 19 TLAAAA RFEAAA VVVVxx 438 2852 0 2 8 18 38 438 438 438 438 76 77 WQAAAA SFEAAA AAAAxx 2480 2853 0 0 0 0 80 480 480 2480 2480 160 161 KRAAAA TFEAAA HHHHxx 936 2854 0 0 6 16 36 936 936 936 936 72 73 AKAAAA UFEAAA OOOOxx 6 2855 0 2 6 6 6 6 6 6 6 12 13 GAAAAA VFEAAA VVVVxx 768 2856 0 0 8 8 68 768 768 768 768 136 137 ODAAAA WFEAAA AAAAxx 1564 2857 0 0 4 4 64 564 1564 1564 1564 128 129 EIAAAA XFEAAA HHHHxx 3236 2858 0 0 6 16 36 236 1236 3236 3236 72 73 MUAAAA YFEAAA OOOOxx 3932 2859 0 0 2 12 32 932 1932 3932 3932 64 65 GVAAAA ZFEAAA VVVVxx 8914 2860 0 2 4 14 14 914 914 3914 8914 28 29 WEAAAA AGEAAA AAAAxx 119 2861 1 3 9 19 19 119 119 119 119 38 39 PEAAAA BGEAAA HHHHxx 6034 2862 0 2 4 14 34 34 34 1034 6034 68 69 CYAAAA CGEAAA OOOOxx 5384 2863 0 0 4 4 84 384 1384 384 5384 168 169 CZAAAA DGEAAA VVVVxx 6885 2864 1 1 5 5 85 885 885 1885 6885 170 171 VEAAAA EGEAAA AAAAxx 232 2865 0 0 2 12 32 232 232 232 232 64 65 YIAAAA FGEAAA HHHHxx 1293 2866 1 1 3 13 93 293 1293 1293 1293 186 187 TXAAAA GGEAAA OOOOxx 9204 2867 0 0 4 4 4 204 1204 4204 9204 8 9 AQAAAA HGEAAA VVVVxx 527 2868 1 3 7 7 27 527 527 527 527 54 55 HUAAAA IGEAAA AAAAxx 6539 2869 1 3 9 19 39 539 539 1539 6539 78 79 NRAAAA JGEAAA HHHHxx 3679 2870 1 3 9 19 79 679 1679 3679 3679 158 159 NLAAAA KGEAAA OOOOxx 8282 2871 0 2 2 2 82 282 282 3282 8282 164 165 OGAAAA LGEAAA VVVVxx 5027 2872 1 3 7 7 27 27 1027 27 5027 54 55 JLAAAA MGEAAA AAAAxx 7694 2873 0 2 4 14 94 694 1694 2694 7694 188 189 YJAAAA NGEAAA HHHHxx 473 2874 1 1 3 13 73 473 473 473 473 146 147 FSAAAA OGEAAA OOOOxx 6325 2875 1 1 5 5 25 325 325 1325 6325 50 51 HJAAAA PGEAAA VVVVxx 8761 2876 1 1 1 1 61 761 761 3761 8761 122 123 ZYAAAA QGEAAA AAAAxx 6184 2877 0 0 4 4 84 184 184 1184 6184 168 169 WDAAAA RGEAAA HHHHxx 419 2878 1 3 9 19 19 419 419 419 419 38 39 DQAAAA SGEAAA OOOOxx 6111 2879 1 3 1 11 11 111 111 1111 6111 22 23 BBAAAA TGEAAA VVVVxx 3836 2880 0 0 6 16 36 836 1836 3836 3836 72 73 ORAAAA UGEAAA AAAAxx 4086 2881 0 2 6 6 86 86 86 4086 4086 172 173 EBAAAA VGEAAA HHHHxx 5818 2882 0 2 8 18 18 818 1818 818 5818 36 37 UPAAAA WGEAAA OOOOxx 4528 2883 0 0 8 8 28 528 528 4528 4528 56 57 ESAAAA XGEAAA VVVVxx 7199 2884 1 3 9 19 99 199 1199 2199 7199 198 199 XQAAAA YGEAAA AAAAxx 1847 2885 1 3 7 7 47 847 1847 1847 1847 94 95 BTAAAA ZGEAAA HHHHxx 2875 2886 1 3 5 15 75 875 875 2875 2875 150 151 PGAAAA AHEAAA OOOOxx 2872 2887 0 0 2 12 72 872 872 2872 2872 144 145 MGAAAA BHEAAA VVVVxx 3972 2888 0 0 2 12 72 972 1972 3972 3972 144 145 UWAAAA CHEAAA AAAAxx 7590 2889 0 2 0 10 90 590 1590 2590 7590 180 181 YFAAAA DHEAAA HHHHxx 1914 2890 0 2 4 14 14 914 1914 1914 1914 28 29 QVAAAA EHEAAA OOOOxx 1658 2891 0 2 8 18 58 658 1658 1658 1658 116 117 ULAAAA FHEAAA VVVVxx 2126 2892 0 2 6 6 26 126 126 2126 2126 52 53 UDAAAA GHEAAA AAAAxx 645 2893 1 1 5 5 45 645 645 645 645 90 91 VYAAAA HHEAAA HHHHxx 6636 2894 0 0 6 16 36 636 636 1636 6636 72 73 GVAAAA IHEAAA OOOOxx 1469 2895 1 1 9 9 69 469 1469 1469 1469 138 139 NEAAAA JHEAAA VVVVxx 1377 2896 1 1 7 17 77 377 1377 1377 1377 154 155 ZAAAAA KHEAAA AAAAxx 8425 2897 1 1 5 5 25 425 425 3425 8425 50 51 BMAAAA LHEAAA HHHHxx 9300 2898 0 0 0 0 0 300 1300 4300 9300 0 1 STAAAA MHEAAA OOOOxx 5355 2899 1 3 5 15 55 355 1355 355 5355 110 111 ZXAAAA NHEAAA VVVVxx 840 2900 0 0 0 0 40 840 840 840 840 80 81 IGAAAA OHEAAA AAAAxx 5185 2901 1 1 5 5 85 185 1185 185 5185 170 171 LRAAAA PHEAAA HHHHxx 6467 2902 1 3 7 7 67 467 467 1467 6467 134 135 TOAAAA QHEAAA OOOOxx 58 2903 0 2 8 18 58 58 58 58 58 116 117 GCAAAA RHEAAA VVVVxx 5051 2904 1 3 1 11 51 51 1051 51 5051 102 103 HMAAAA SHEAAA AAAAxx 8901 2905 1 1 1 1 1 901 901 3901 8901 2 3 JEAAAA THEAAA HHHHxx 1550 2906 0 2 0 10 50 550 1550 1550 1550 100 101 QHAAAA UHEAAA OOOOxx 1698 2907 0 2 8 18 98 698 1698 1698 1698 196 197 INAAAA VHEAAA VVVVxx 802 2908 0 2 2 2 2 802 802 802 802 4 5 WEAAAA WHEAAA AAAAxx 2440 2909 0 0 0 0 40 440 440 2440 2440 80 81 WPAAAA XHEAAA HHHHxx 2260 2910 0 0 0 0 60 260 260 2260 2260 120 121 YIAAAA YHEAAA OOOOxx 8218 2911 0 2 8 18 18 218 218 3218 8218 36 37 CEAAAA ZHEAAA VVVVxx 5144 2912 0 0 4 4 44 144 1144 144 5144 88 89 WPAAAA AIEAAA AAAAxx 4822 2913 0 2 2 2 22 822 822 4822 4822 44 45 MDAAAA BIEAAA HHHHxx 9476 2914 0 0 6 16 76 476 1476 4476 9476 152 153 MAAAAA CIEAAA OOOOxx 7535 2915 1 3 5 15 35 535 1535 2535 7535 70 71 VDAAAA DIEAAA VVVVxx 8738 2916 0 2 8 18 38 738 738 3738 8738 76 77 CYAAAA EIEAAA AAAAxx 7946 2917 0 2 6 6 46 946 1946 2946 7946 92 93 QTAAAA FIEAAA HHHHxx 8143 2918 1 3 3 3 43 143 143 3143 8143 86 87 FBAAAA GIEAAA OOOOxx 2623 2919 1 3 3 3 23 623 623 2623 2623 46 47 XWAAAA HIEAAA VVVVxx 5209 2920 1 1 9 9 9 209 1209 209 5209 18 19 JSAAAA IIEAAA AAAAxx 7674 2921 0 2 4 14 74 674 1674 2674 7674 148 149 EJAAAA JIEAAA HHHHxx 1135 2922 1 3 5 15 35 135 1135 1135 1135 70 71 RRAAAA KIEAAA OOOOxx 424 2923 0 0 4 4 24 424 424 424 424 48 49 IQAAAA LIEAAA VVVVxx 942 2924 0 2 2 2 42 942 942 942 942 84 85 GKAAAA MIEAAA AAAAxx 7813 2925 1 1 3 13 13 813 1813 2813 7813 26 27 NOAAAA NIEAAA HHHHxx 3539 2926 1 3 9 19 39 539 1539 3539 3539 78 79 DGAAAA OIEAAA OOOOxx 2909 2927 1 1 9 9 9 909 909 2909 2909 18 19 XHAAAA PIEAAA VVVVxx 3748 2928 0 0 8 8 48 748 1748 3748 3748 96 97 EOAAAA QIEAAA AAAAxx 2996 2929 0 0 6 16 96 996 996 2996 2996 192 193 GLAAAA RIEAAA HHHHxx 1869 2930 1 1 9 9 69 869 1869 1869 1869 138 139 XTAAAA SIEAAA OOOOxx 8151 2931 1 3 1 11 51 151 151 3151 8151 102 103 NBAAAA TIEAAA VVVVxx 6361 2932 1 1 1 1 61 361 361 1361 6361 122 123 RKAAAA UIEAAA AAAAxx 5568 2933 0 0 8 8 68 568 1568 568 5568 136 137 EGAAAA VIEAAA HHHHxx 2796 2934 0 0 6 16 96 796 796 2796 2796 192 193 ODAAAA WIEAAA OOOOxx 8489 2935 1 1 9 9 89 489 489 3489 8489 178 179 NOAAAA XIEAAA VVVVxx 9183 2936 1 3 3 3 83 183 1183 4183 9183 166 167 FPAAAA YIEAAA AAAAxx 8227 2937 1 3 7 7 27 227 227 3227 8227 54 55 LEAAAA ZIEAAA HHHHxx 1844 2938 0 0 4 4 44 844 1844 1844 1844 88 89 YSAAAA AJEAAA OOOOxx 3975 2939 1 3 5 15 75 975 1975 3975 3975 150 151 XWAAAA BJEAAA VVVVxx 6490 2940 0 2 0 10 90 490 490 1490 6490 180 181 QPAAAA CJEAAA AAAAxx 8303 2941 1 3 3 3 3 303 303 3303 8303 6 7 JHAAAA DJEAAA HHHHxx 7334 2942 0 2 4 14 34 334 1334 2334 7334 68 69 CWAAAA EJEAAA OOOOxx 2382 2943 0 2 2 2 82 382 382 2382 2382 164 165 QNAAAA FJEAAA VVVVxx 177 2944 1 1 7 17 77 177 177 177 177 154 155 VGAAAA GJEAAA AAAAxx 8117 2945 1 1 7 17 17 117 117 3117 8117 34 35 FAAAAA HJEAAA HHHHxx 5485 2946 1 1 5 5 85 485 1485 485 5485 170 171 ZCAAAA IJEAAA OOOOxx 6544 2947 0 0 4 4 44 544 544 1544 6544 88 89 SRAAAA JJEAAA VVVVxx 8517 2948 1 1 7 17 17 517 517 3517 8517 34 35 PPAAAA KJEAAA AAAAxx 2252 2949 0 0 2 12 52 252 252 2252 2252 104 105 QIAAAA LJEAAA HHHHxx 4480 2950 0 0 0 0 80 480 480 4480 4480 160 161 IQAAAA MJEAAA OOOOxx 4785 2951 1 1 5 5 85 785 785 4785 4785 170 171 BCAAAA NJEAAA VVVVxx 9700 2952 0 0 0 0 0 700 1700 4700 9700 0 1 CJAAAA OJEAAA AAAAxx 2122 2953 0 2 2 2 22 122 122 2122 2122 44 45 QDAAAA PJEAAA HHHHxx 8783 2954 1 3 3 3 83 783 783 3783 8783 166 167 VZAAAA QJEAAA OOOOxx 1453 2955 1 1 3 13 53 453 1453 1453 1453 106 107 XDAAAA RJEAAA VVVVxx 3908 2956 0 0 8 8 8 908 1908 3908 3908 16 17 IUAAAA SJEAAA AAAAxx 7707 2957 1 3 7 7 7 707 1707 2707 7707 14 15 LKAAAA TJEAAA HHHHxx 9049 2958 1 1 9 9 49 49 1049 4049 9049 98 99 BKAAAA UJEAAA OOOOxx 654 2959 0 2 4 14 54 654 654 654 654 108 109 EZAAAA VJEAAA VVVVxx 3336 2960 0 0 6 16 36 336 1336 3336 3336 72 73 IYAAAA WJEAAA AAAAxx 622 2961 0 2 2 2 22 622 622 622 622 44 45 YXAAAA XJEAAA HHHHxx 8398 2962 0 2 8 18 98 398 398 3398 8398 196 197 ALAAAA YJEAAA OOOOxx 9193 2963 1 1 3 13 93 193 1193 4193 9193 186 187 PPAAAA ZJEAAA VVVVxx 7896 2964 0 0 6 16 96 896 1896 2896 7896 192 193 SRAAAA AKEAAA AAAAxx 9798 2965 0 2 8 18 98 798 1798 4798 9798 196 197 WMAAAA BKEAAA HHHHxx 2881 2966 1 1 1 1 81 881 881 2881 2881 162 163 VGAAAA CKEAAA OOOOxx 672 2967 0 0 2 12 72 672 672 672 672 144 145 WZAAAA DKEAAA VVVVxx 6743 2968 1 3 3 3 43 743 743 1743 6743 86 87 JZAAAA EKEAAA AAAAxx 8935 2969 1 3 5 15 35 935 935 3935 8935 70 71 RFAAAA FKEAAA HHHHxx 2426 2970 0 2 6 6 26 426 426 2426 2426 52 53 IPAAAA GKEAAA OOOOxx 722 2971 0 2 2 2 22 722 722 722 722 44 45 UBAAAA HKEAAA VVVVxx 5088 2972 0 0 8 8 88 88 1088 88 5088 176 177 SNAAAA IKEAAA AAAAxx 8677 2973 1 1 7 17 77 677 677 3677 8677 154 155 TVAAAA JKEAAA HHHHxx 6963 2974 1 3 3 3 63 963 963 1963 6963 126 127 VHAAAA KKEAAA OOOOxx 1653 2975 1 1 3 13 53 653 1653 1653 1653 106 107 PLAAAA LKEAAA VVVVxx 7295 2976 1 3 5 15 95 295 1295 2295 7295 190 191 PUAAAA MKEAAA AAAAxx 6675 2977 1 3 5 15 75 675 675 1675 6675 150 151 TWAAAA NKEAAA HHHHxx 7183 2978 1 3 3 3 83 183 1183 2183 7183 166 167 HQAAAA OKEAAA OOOOxx 4378 2979 0 2 8 18 78 378 378 4378 4378 156 157 KMAAAA PKEAAA VVVVxx 2157 2980 1 1 7 17 57 157 157 2157 2157 114 115 ZEAAAA QKEAAA AAAAxx 2621 2981 1 1 1 1 21 621 621 2621 2621 42 43 VWAAAA RKEAAA HHHHxx 9278 2982 0 2 8 18 78 278 1278 4278 9278 156 157 WSAAAA SKEAAA OOOOxx 79 2983 1 3 9 19 79 79 79 79 79 158 159 BDAAAA TKEAAA VVVVxx 7358 2984 0 2 8 18 58 358 1358 2358 7358 116 117 AXAAAA UKEAAA AAAAxx 3589 2985 1 1 9 9 89 589 1589 3589 3589 178 179 BIAAAA VKEAAA HHHHxx 1254 2986 0 2 4 14 54 254 1254 1254 1254 108 109 GWAAAA WKEAAA OOOOxx 3490 2987 0 2 0 10 90 490 1490 3490 3490 180 181 GEAAAA XKEAAA VVVVxx 7533 2988 1 1 3 13 33 533 1533 2533 7533 66 67 TDAAAA YKEAAA AAAAxx 2800 2989 0 0 0 0 0 800 800 2800 2800 0 1 SDAAAA ZKEAAA HHHHxx 351 2990 1 3 1 11 51 351 351 351 351 102 103 NNAAAA ALEAAA OOOOxx 4359 2991 1 3 9 19 59 359 359 4359 4359 118 119 RLAAAA BLEAAA VVVVxx 5788 2992 0 0 8 8 88 788 1788 788 5788 176 177 QOAAAA CLEAAA AAAAxx 5521 2993 1 1 1 1 21 521 1521 521 5521 42 43 JEAAAA DLEAAA HHHHxx 3351 2994 1 3 1 11 51 351 1351 3351 3351 102 103 XYAAAA ELEAAA OOOOxx 5129 2995 1 1 9 9 29 129 1129 129 5129 58 59 HPAAAA FLEAAA VVVVxx 315 2996 1 3 5 15 15 315 315 315 315 30 31 DMAAAA GLEAAA AAAAxx 7552 2997 0 0 2 12 52 552 1552 2552 7552 104 105 MEAAAA HLEAAA HHHHxx 9176 2998 0 0 6 16 76 176 1176 4176 9176 152 153 YOAAAA ILEAAA OOOOxx 7458 2999 0 2 8 18 58 458 1458 2458 7458 116 117 WAAAAA JLEAAA VVVVxx 279 3000 1 3 9 19 79 279 279 279 279 158 159 TKAAAA KLEAAA AAAAxx 738 3001 0 2 8 18 38 738 738 738 738 76 77 KCAAAA LLEAAA HHHHxx 2557 3002 1 1 7 17 57 557 557 2557 2557 114 115 JUAAAA MLEAAA OOOOxx 9395 3003 1 3 5 15 95 395 1395 4395 9395 190 191 JXAAAA NLEAAA VVVVxx 7214 3004 0 2 4 14 14 214 1214 2214 7214 28 29 MRAAAA OLEAAA AAAAxx 6354 3005 0 2 4 14 54 354 354 1354 6354 108 109 KKAAAA PLEAAA HHHHxx 4799 3006 1 3 9 19 99 799 799 4799 4799 198 199 PCAAAA QLEAAA OOOOxx 1231 3007 1 3 1 11 31 231 1231 1231 1231 62 63 JVAAAA RLEAAA VVVVxx 5252 3008 0 0 2 12 52 252 1252 252 5252 104 105 AUAAAA SLEAAA AAAAxx 5250 3009 0 2 0 10 50 250 1250 250 5250 100 101 YTAAAA TLEAAA HHHHxx 9319 3010 1 3 9 19 19 319 1319 4319 9319 38 39 LUAAAA ULEAAA OOOOxx 1724 3011 0 0 4 4 24 724 1724 1724 1724 48 49 IOAAAA VLEAAA VVVVxx 7947 3012 1 3 7 7 47 947 1947 2947 7947 94 95 RTAAAA WLEAAA AAAAxx 1105 3013 1 1 5 5 5 105 1105 1105 1105 10 11 NQAAAA XLEAAA HHHHxx 1417 3014 1 1 7 17 17 417 1417 1417 1417 34 35 NCAAAA YLEAAA OOOOxx 7101 3015 1 1 1 1 1 101 1101 2101 7101 2 3 DNAAAA ZLEAAA VVVVxx 1088 3016 0 0 8 8 88 88 1088 1088 1088 176 177 WPAAAA AMEAAA AAAAxx 979 3017 1 3 9 19 79 979 979 979 979 158 159 RLAAAA BMEAAA HHHHxx 7589 3018 1 1 9 9 89 589 1589 2589 7589 178 179 XFAAAA CMEAAA OOOOxx 8952 3019 0 0 2 12 52 952 952 3952 8952 104 105 IGAAAA DMEAAA VVVVxx 2864 3020 0 0 4 4 64 864 864 2864 2864 128 129 EGAAAA EMEAAA AAAAxx 234 3021 0 2 4 14 34 234 234 234 234 68 69 AJAAAA FMEAAA HHHHxx 7231 3022 1 3 1 11 31 231 1231 2231 7231 62 63 DSAAAA GMEAAA OOOOxx 6792 3023 0 0 2 12 92 792 792 1792 6792 184 185 GBAAAA HMEAAA VVVVxx 4311 3024 1 3 1 11 11 311 311 4311 4311 22 23 VJAAAA IMEAAA AAAAxx 3374 3025 0 2 4 14 74 374 1374 3374 3374 148 149 UZAAAA JMEAAA HHHHxx 3367 3026 1 3 7 7 67 367 1367 3367 3367 134 135 NZAAAA KMEAAA OOOOxx 2598 3027 0 2 8 18 98 598 598 2598 2598 196 197 YVAAAA LMEAAA VVVVxx 1033 3028 1 1 3 13 33 33 1033 1033 1033 66 67 TNAAAA MMEAAA AAAAxx 7803 3029 1 3 3 3 3 803 1803 2803 7803 6 7 DOAAAA NMEAAA HHHHxx 3870 3030 0 2 0 10 70 870 1870 3870 3870 140 141 WSAAAA OMEAAA OOOOxx 4962 3031 0 2 2 2 62 962 962 4962 4962 124 125 WIAAAA PMEAAA VVVVxx 4842 3032 0 2 2 2 42 842 842 4842 4842 84 85 GEAAAA QMEAAA AAAAxx 8814 3033 0 2 4 14 14 814 814 3814 8814 28 29 ABAAAA RMEAAA HHHHxx 3429 3034 1 1 9 9 29 429 1429 3429 3429 58 59 XBAAAA SMEAAA OOOOxx 6550 3035 0 2 0 10 50 550 550 1550 6550 100 101 YRAAAA TMEAAA VVVVxx 6317 3036 1 1 7 17 17 317 317 1317 6317 34 35 ZIAAAA UMEAAA AAAAxx 5023 3037 1 3 3 3 23 23 1023 23 5023 46 47 FLAAAA VMEAAA HHHHxx 5825 3038 1 1 5 5 25 825 1825 825 5825 50 51 BQAAAA WMEAAA OOOOxx 5297 3039 1 1 7 17 97 297 1297 297 5297 194 195 TVAAAA XMEAAA VVVVxx 8764 3040 0 0 4 4 64 764 764 3764 8764 128 129 CZAAAA YMEAAA AAAAxx 5084 3041 0 0 4 4 84 84 1084 84 5084 168 169 ONAAAA ZMEAAA HHHHxx 6808 3042 0 0 8 8 8 808 808 1808 6808 16 17 WBAAAA ANEAAA OOOOxx 1780 3043 0 0 0 0 80 780 1780 1780 1780 160 161 MQAAAA BNEAAA VVVVxx 4092 3044 0 0 2 12 92 92 92 4092 4092 184 185 KBAAAA CNEAAA AAAAxx 3618 3045 0 2 8 18 18 618 1618 3618 3618 36 37 EJAAAA DNEAAA HHHHxx 7299 3046 1 3 9 19 99 299 1299 2299 7299 198 199 TUAAAA ENEAAA OOOOxx 8544 3047 0 0 4 4 44 544 544 3544 8544 88 89 QQAAAA FNEAAA VVVVxx 2359 3048 1 3 9 19 59 359 359 2359 2359 118 119 TMAAAA GNEAAA AAAAxx 1939 3049 1 3 9 19 39 939 1939 1939 1939 78 79 PWAAAA HNEAAA HHHHxx 5834 3050 0 2 4 14 34 834 1834 834 5834 68 69 KQAAAA INEAAA OOOOxx 1997 3051 1 1 7 17 97 997 1997 1997 1997 194 195 VYAAAA JNEAAA VVVVxx 7917 3052 1 1 7 17 17 917 1917 2917 7917 34 35 NSAAAA KNEAAA AAAAxx 2098 3053 0 2 8 18 98 98 98 2098 2098 196 197 SCAAAA LNEAAA HHHHxx 7576 3054 0 0 6 16 76 576 1576 2576 7576 152 153 KFAAAA MNEAAA OOOOxx 376 3055 0 0 6 16 76 376 376 376 376 152 153 MOAAAA NNEAAA VVVVxx 8535 3056 1 3 5 15 35 535 535 3535 8535 70 71 HQAAAA ONEAAA AAAAxx 5659 3057 1 3 9 19 59 659 1659 659 5659 118 119 RJAAAA PNEAAA HHHHxx 2786 3058 0 2 6 6 86 786 786 2786 2786 172 173 EDAAAA QNEAAA OOOOxx 8820 3059 0 0 0 0 20 820 820 3820 8820 40 41 GBAAAA RNEAAA VVVVxx 1229 3060 1 1 9 9 29 229 1229 1229 1229 58 59 HVAAAA SNEAAA AAAAxx 9321 3061 1 1 1 1 21 321 1321 4321 9321 42 43 NUAAAA TNEAAA HHHHxx 7662 3062 0 2 2 2 62 662 1662 2662 7662 124 125 SIAAAA UNEAAA OOOOxx 5535 3063 1 3 5 15 35 535 1535 535 5535 70 71 XEAAAA VNEAAA VVVVxx 4889 3064 1 1 9 9 89 889 889 4889 4889 178 179 BGAAAA WNEAAA AAAAxx 8259 3065 1 3 9 19 59 259 259 3259 8259 118 119 RFAAAA XNEAAA HHHHxx 6789 3066 1 1 9 9 89 789 789 1789 6789 178 179 DBAAAA YNEAAA OOOOxx 5411 3067 1 3 1 11 11 411 1411 411 5411 22 23 DAAAAA ZNEAAA VVVVxx 6992 3068 0 0 2 12 92 992 992 1992 6992 184 185 YIAAAA AOEAAA AAAAxx 7698 3069 0 2 8 18 98 698 1698 2698 7698 196 197 CKAAAA BOEAAA HHHHxx 2342 3070 0 2 2 2 42 342 342 2342 2342 84 85 CMAAAA COEAAA OOOOxx 1501 3071 1 1 1 1 1 501 1501 1501 1501 2 3 TFAAAA DOEAAA VVVVxx 6322 3072 0 2 2 2 22 322 322 1322 6322 44 45 EJAAAA EOEAAA AAAAxx 9861 3073 1 1 1 1 61 861 1861 4861 9861 122 123 HPAAAA FOEAAA HHHHxx 9802 3074 0 2 2 2 2 802 1802 4802 9802 4 5 ANAAAA GOEAAA OOOOxx 4750 3075 0 2 0 10 50 750 750 4750 4750 100 101 SAAAAA HOEAAA VVVVxx 5855 3076 1 3 5 15 55 855 1855 855 5855 110 111 FRAAAA IOEAAA AAAAxx 4304 3077 0 0 4 4 4 304 304 4304 4304 8 9 OJAAAA JOEAAA HHHHxx 2605 3078 1 1 5 5 5 605 605 2605 2605 10 11 FWAAAA KOEAAA OOOOxx 1802 3079 0 2 2 2 2 802 1802 1802 1802 4 5 IRAAAA LOEAAA VVVVxx 9368 3080 0 0 8 8 68 368 1368 4368 9368 136 137 IWAAAA MOEAAA AAAAxx 7107 3081 1 3 7 7 7 107 1107 2107 7107 14 15 JNAAAA NOEAAA HHHHxx 8895 3082 1 3 5 15 95 895 895 3895 8895 190 191 DEAAAA OOEAAA OOOOxx 3750 3083 0 2 0 10 50 750 1750 3750 3750 100 101 GOAAAA POEAAA VVVVxx 8934 3084 0 2 4 14 34 934 934 3934 8934 68 69 QFAAAA QOEAAA AAAAxx 9464 3085 0 0 4 4 64 464 1464 4464 9464 128 129 AAAAAA ROEAAA HHHHxx 1928 3086 0 0 8 8 28 928 1928 1928 1928 56 57 EWAAAA SOEAAA OOOOxx 3196 3087 0 0 6 16 96 196 1196 3196 3196 192 193 YSAAAA TOEAAA VVVVxx 5256 3088 0 0 6 16 56 256 1256 256 5256 112 113 EUAAAA UOEAAA AAAAxx 7119 3089 1 3 9 19 19 119 1119 2119 7119 38 39 VNAAAA VOEAAA HHHHxx 4495 3090 1 3 5 15 95 495 495 4495 4495 190 191 XQAAAA WOEAAA OOOOxx 9292 3091 0 0 2 12 92 292 1292 4292 9292 184 185 KTAAAA XOEAAA VVVVxx 1617 3092 1 1 7 17 17 617 1617 1617 1617 34 35 FKAAAA YOEAAA AAAAxx 481 3093 1 1 1 1 81 481 481 481 481 162 163 NSAAAA ZOEAAA HHHHxx 56 3094 0 0 6 16 56 56 56 56 56 112 113 ECAAAA APEAAA OOOOxx 9120 3095 0 0 0 0 20 120 1120 4120 9120 40 41 UMAAAA BPEAAA VVVVxx 1306 3096 0 2 6 6 6 306 1306 1306 1306 12 13 GYAAAA CPEAAA AAAAxx 7773 3097 1 1 3 13 73 773 1773 2773 7773 146 147 ZMAAAA DPEAAA HHHHxx 4863 3098 1 3 3 3 63 863 863 4863 4863 126 127 BFAAAA EPEAAA OOOOxx 1114 3099 0 2 4 14 14 114 1114 1114 1114 28 29 WQAAAA FPEAAA VVVVxx 8124 3100 0 0 4 4 24 124 124 3124 8124 48 49 MAAAAA GPEAAA AAAAxx 6254 3101 0 2 4 14 54 254 254 1254 6254 108 109 OGAAAA HPEAAA HHHHxx 8109 3102 1 1 9 9 9 109 109 3109 8109 18 19 XZAAAA IPEAAA OOOOxx 1747 3103 1 3 7 7 47 747 1747 1747 1747 94 95 FPAAAA JPEAAA VVVVxx 6185 3104 1 1 5 5 85 185 185 1185 6185 170 171 XDAAAA KPEAAA AAAAxx 3388 3105 0 0 8 8 88 388 1388 3388 3388 176 177 IAAAAA LPEAAA HHHHxx 4905 3106 1 1 5 5 5 905 905 4905 4905 10 11 RGAAAA MPEAAA OOOOxx 5728 3107 0 0 8 8 28 728 1728 728 5728 56 57 IMAAAA NPEAAA VVVVxx 7507 3108 1 3 7 7 7 507 1507 2507 7507 14 15 TCAAAA OPEAAA AAAAxx 5662 3109 0 2 2 2 62 662 1662 662 5662 124 125 UJAAAA PPEAAA HHHHxx 1686 3110 0 2 6 6 86 686 1686 1686 1686 172 173 WMAAAA QPEAAA OOOOxx 5202 3111 0 2 2 2 2 202 1202 202 5202 4 5 CSAAAA RPEAAA VVVVxx 6905 3112 1 1 5 5 5 905 905 1905 6905 10 11 PFAAAA SPEAAA AAAAxx 9577 3113 1 1 7 17 77 577 1577 4577 9577 154 155 JEAAAA TPEAAA HHHHxx 7194 3114 0 2 4 14 94 194 1194 2194 7194 188 189 SQAAAA UPEAAA OOOOxx 7016 3115 0 0 6 16 16 16 1016 2016 7016 32 33 WJAAAA VPEAAA VVVVxx 8905 3116 1 1 5 5 5 905 905 3905 8905 10 11 NEAAAA WPEAAA AAAAxx 3419 3117 1 3 9 19 19 419 1419 3419 3419 38 39 NBAAAA XPEAAA HHHHxx 6881 3118 1 1 1 1 81 881 881 1881 6881 162 163 REAAAA YPEAAA OOOOxx 8370 3119 0 2 0 10 70 370 370 3370 8370 140 141 YJAAAA ZPEAAA VVVVxx 6117 3120 1 1 7 17 17 117 117 1117 6117 34 35 HBAAAA AQEAAA AAAAxx 1636 3121 0 0 6 16 36 636 1636 1636 1636 72 73 YKAAAA BQEAAA HHHHxx 6857 3122 1 1 7 17 57 857 857 1857 6857 114 115 TDAAAA CQEAAA OOOOxx 7163 3123 1 3 3 3 63 163 1163 2163 7163 126 127 NPAAAA DQEAAA VVVVxx 5040 3124 0 0 0 0 40 40 1040 40 5040 80 81 WLAAAA EQEAAA AAAAxx 6263 3125 1 3 3 3 63 263 263 1263 6263 126 127 XGAAAA FQEAAA HHHHxx 4809 3126 1 1 9 9 9 809 809 4809 4809 18 19 ZCAAAA GQEAAA OOOOxx 900 3127 0 0 0 0 0 900 900 900 900 0 1 QIAAAA HQEAAA VVVVxx 3199 3128 1 3 9 19 99 199 1199 3199 3199 198 199 BTAAAA IQEAAA AAAAxx 4156 3129 0 0 6 16 56 156 156 4156 4156 112 113 WDAAAA JQEAAA HHHHxx 3501 3130 1 1 1 1 1 501 1501 3501 3501 2 3 REAAAA KQEAAA OOOOxx 164 3131 0 0 4 4 64 164 164 164 164 128 129 IGAAAA LQEAAA VVVVxx 9548 3132 0 0 8 8 48 548 1548 4548 9548 96 97 GDAAAA MQEAAA AAAAxx 1149 3133 1 1 9 9 49 149 1149 1149 1149 98 99 FSAAAA NQEAAA HHHHxx 1962 3134 0 2 2 2 62 962 1962 1962 1962 124 125 MXAAAA OQEAAA OOOOxx 4072 3135 0 0 2 12 72 72 72 4072 4072 144 145 QAAAAA PQEAAA VVVVxx 4280 3136 0 0 0 0 80 280 280 4280 4280 160 161 QIAAAA QQEAAA AAAAxx 1398 3137 0 2 8 18 98 398 1398 1398 1398 196 197 UBAAAA RQEAAA HHHHxx 725 3138 1 1 5 5 25 725 725 725 725 50 51 XBAAAA SQEAAA OOOOxx 3988 3139 0 0 8 8 88 988 1988 3988 3988 176 177 KXAAAA TQEAAA VVVVxx 5059 3140 1 3 9 19 59 59 1059 59 5059 118 119 PMAAAA UQEAAA AAAAxx 2632 3141 0 0 2 12 32 632 632 2632 2632 64 65 GXAAAA VQEAAA HHHHxx 1909 3142 1 1 9 9 9 909 1909 1909 1909 18 19 LVAAAA WQEAAA OOOOxx 6827 3143 1 3 7 7 27 827 827 1827 6827 54 55 PCAAAA XQEAAA VVVVxx 8156 3144 0 0 6 16 56 156 156 3156 8156 112 113 SBAAAA YQEAAA AAAAxx 1192 3145 0 0 2 12 92 192 1192 1192 1192 184 185 WTAAAA ZQEAAA HHHHxx 9545 3146 1 1 5 5 45 545 1545 4545 9545 90 91 DDAAAA AREAAA OOOOxx 2249 3147 1 1 9 9 49 249 249 2249 2249 98 99 NIAAAA BREAAA VVVVxx 5580 3148 0 0 0 0 80 580 1580 580 5580 160 161 QGAAAA CREAAA AAAAxx 8403 3149 1 3 3 3 3 403 403 3403 8403 6 7 FLAAAA DREAAA HHHHxx 4024 3150 0 0 4 4 24 24 24 4024 4024 48 49 UYAAAA EREAAA OOOOxx 1866 3151 0 2 6 6 66 866 1866 1866 1866 132 133 UTAAAA FREAAA VVVVxx 9251 3152 1 3 1 11 51 251 1251 4251 9251 102 103 VRAAAA GREAAA AAAAxx 9979 3153 1 3 9 19 79 979 1979 4979 9979 158 159 VTAAAA HREAAA HHHHxx 9899 3154 1 3 9 19 99 899 1899 4899 9899 198 199 TQAAAA IREAAA OOOOxx 2540 3155 0 0 0 0 40 540 540 2540 2540 80 81 STAAAA JREAAA VVVVxx 8957 3156 1 1 7 17 57 957 957 3957 8957 114 115 NGAAAA KREAAA AAAAxx 7702 3157 0 2 2 2 2 702 1702 2702 7702 4 5 GKAAAA LREAAA HHHHxx 4211 3158 1 3 1 11 11 211 211 4211 4211 22 23 ZFAAAA MREAAA OOOOxx 6684 3159 0 0 4 4 84 684 684 1684 6684 168 169 CXAAAA NREAAA VVVVxx 3883 3160 1 3 3 3 83 883 1883 3883 3883 166 167 JTAAAA OREAAA AAAAxx 3531 3161 1 3 1 11 31 531 1531 3531 3531 62 63 VFAAAA PREAAA HHHHxx 9178 3162 0 2 8 18 78 178 1178 4178 9178 156 157 APAAAA QREAAA OOOOxx 3389 3163 1 1 9 9 89 389 1389 3389 3389 178 179 JAAAAA RREAAA VVVVxx 7874 3164 0 2 4 14 74 874 1874 2874 7874 148 149 WQAAAA SREAAA AAAAxx 4522 3165 0 2 2 2 22 522 522 4522 4522 44 45 YRAAAA TREAAA HHHHxx 9399 3166 1 3 9 19 99 399 1399 4399 9399 198 199 NXAAAA UREAAA OOOOxx 9083 3167 1 3 3 3 83 83 1083 4083 9083 166 167 JLAAAA VREAAA VVVVxx 1530 3168 0 2 0 10 30 530 1530 1530 1530 60 61 WGAAAA WREAAA AAAAxx 2360 3169 0 0 0 0 60 360 360 2360 2360 120 121 UMAAAA XREAAA HHHHxx 4908 3170 0 0 8 8 8 908 908 4908 4908 16 17 UGAAAA YREAAA OOOOxx 4628 3171 0 0 8 8 28 628 628 4628 4628 56 57 AWAAAA ZREAAA VVVVxx 3889 3172 1 1 9 9 89 889 1889 3889 3889 178 179 PTAAAA ASEAAA AAAAxx 1331 3173 1 3 1 11 31 331 1331 1331 1331 62 63 FZAAAA BSEAAA HHHHxx 1942 3174 0 2 2 2 42 942 1942 1942 1942 84 85 SWAAAA CSEAAA OOOOxx 4734 3175 0 2 4 14 34 734 734 4734 4734 68 69 CAAAAA DSEAAA VVVVxx 8386 3176 0 2 6 6 86 386 386 3386 8386 172 173 OKAAAA ESEAAA AAAAxx 3586 3177 0 2 6 6 86 586 1586 3586 3586 172 173 YHAAAA FSEAAA HHHHxx 2354 3178 0 2 4 14 54 354 354 2354 2354 108 109 OMAAAA GSEAAA OOOOxx 7108 3179 0 0 8 8 8 108 1108 2108 7108 16 17 KNAAAA HSEAAA VVVVxx 1857 3180 1 1 7 17 57 857 1857 1857 1857 114 115 LTAAAA ISEAAA AAAAxx 2544 3181 0 0 4 4 44 544 544 2544 2544 88 89 WTAAAA JSEAAA HHHHxx 819 3182 1 3 9 19 19 819 819 819 819 38 39 NFAAAA KSEAAA OOOOxx 2878 3183 0 2 8 18 78 878 878 2878 2878 156 157 SGAAAA LSEAAA VVVVxx 1772 3184 0 0 2 12 72 772 1772 1772 1772 144 145 EQAAAA MSEAAA AAAAxx 354 3185 0 2 4 14 54 354 354 354 354 108 109 QNAAAA NSEAAA HHHHxx 3259 3186 1 3 9 19 59 259 1259 3259 3259 118 119 JVAAAA OSEAAA OOOOxx 2170 3187 0 2 0 10 70 170 170 2170 2170 140 141 MFAAAA PSEAAA VVVVxx 1190 3188 0 2 0 10 90 190 1190 1190 1190 180 181 UTAAAA QSEAAA AAAAxx 3607 3189 1 3 7 7 7 607 1607 3607 3607 14 15 TIAAAA RSEAAA HHHHxx 4661 3190 1 1 1 1 61 661 661 4661 4661 122 123 HXAAAA SSEAAA OOOOxx 1796 3191 0 0 6 16 96 796 1796 1796 1796 192 193 CRAAAA TSEAAA VVVVxx 1561 3192 1 1 1 1 61 561 1561 1561 1561 122 123 BIAAAA USEAAA AAAAxx 4336 3193 0 0 6 16 36 336 336 4336 4336 72 73 UKAAAA VSEAAA HHHHxx 7550 3194 0 2 0 10 50 550 1550 2550 7550 100 101 KEAAAA WSEAAA OOOOxx 3238 3195 0 2 8 18 38 238 1238 3238 3238 76 77 OUAAAA XSEAAA VVVVxx 9870 3196 0 2 0 10 70 870 1870 4870 9870 140 141 QPAAAA YSEAAA AAAAxx 6502 3197 0 2 2 2 2 502 502 1502 6502 4 5 CQAAAA ZSEAAA HHHHxx 3903 3198 1 3 3 3 3 903 1903 3903 3903 6 7 DUAAAA ATEAAA OOOOxx 2869 3199 1 1 9 9 69 869 869 2869 2869 138 139 JGAAAA BTEAAA VVVVxx 5072 3200 0 0 2 12 72 72 1072 72 5072 144 145 CNAAAA CTEAAA AAAAxx 1201 3201 1 1 1 1 1 201 1201 1201 1201 2 3 FUAAAA DTEAAA HHHHxx 6245 3202 1 1 5 5 45 245 245 1245 6245 90 91 FGAAAA ETEAAA OOOOxx 1402 3203 0 2 2 2 2 402 1402 1402 1402 4 5 YBAAAA FTEAAA VVVVxx 2594 3204 0 2 4 14 94 594 594 2594 2594 188 189 UVAAAA GTEAAA AAAAxx 9171 3205 1 3 1 11 71 171 1171 4171 9171 142 143 TOAAAA HTEAAA HHHHxx 2620 3206 0 0 0 0 20 620 620 2620 2620 40 41 UWAAAA ITEAAA OOOOxx 6309 3207 1 1 9 9 9 309 309 1309 6309 18 19 RIAAAA JTEAAA VVVVxx 1285 3208 1 1 5 5 85 285 1285 1285 1285 170 171 LXAAAA KTEAAA AAAAxx 5466 3209 0 2 6 6 66 466 1466 466 5466 132 133 GCAAAA LTEAAA HHHHxx 168 3210 0 0 8 8 68 168 168 168 168 136 137 MGAAAA MTEAAA OOOOxx 1410 3211 0 2 0 10 10 410 1410 1410 1410 20 21 GCAAAA NTEAAA VVVVxx 6332 3212 0 0 2 12 32 332 332 1332 6332 64 65 OJAAAA OTEAAA AAAAxx 9530 3213 0 2 0 10 30 530 1530 4530 9530 60 61 OCAAAA PTEAAA HHHHxx 7749 3214 1 1 9 9 49 749 1749 2749 7749 98 99 BMAAAA QTEAAA OOOOxx 3656 3215 0 0 6 16 56 656 1656 3656 3656 112 113 QKAAAA RTEAAA VVVVxx 37 3216 1 1 7 17 37 37 37 37 37 74 75 LBAAAA STEAAA AAAAxx 2744 3217 0 0 4 4 44 744 744 2744 2744 88 89 OBAAAA TTEAAA HHHHxx 4206 3218 0 2 6 6 6 206 206 4206 4206 12 13 UFAAAA UTEAAA OOOOxx 1846 3219 0 2 6 6 46 846 1846 1846 1846 92 93 ATAAAA VTEAAA VVVVxx 9913 3220 1 1 3 13 13 913 1913 4913 9913 26 27 HRAAAA WTEAAA AAAAxx 4078 3221 0 2 8 18 78 78 78 4078 4078 156 157 WAAAAA XTEAAA HHHHxx 2080 3222 0 0 0 0 80 80 80 2080 2080 160 161 ACAAAA YTEAAA OOOOxx 4169 3223 1 1 9 9 69 169 169 4169 4169 138 139 JEAAAA ZTEAAA VVVVxx 2070 3224 0 2 0 10 70 70 70 2070 2070 140 141 QBAAAA AUEAAA AAAAxx 4500 3225 0 0 0 0 0 500 500 4500 4500 0 1 CRAAAA BUEAAA HHHHxx 4123 3226 1 3 3 3 23 123 123 4123 4123 46 47 PCAAAA CUEAAA OOOOxx 5594 3227 0 2 4 14 94 594 1594 594 5594 188 189 EHAAAA DUEAAA VVVVxx 9941 3228 1 1 1 1 41 941 1941 4941 9941 82 83 JSAAAA EUEAAA AAAAxx 7154 3229 0 2 4 14 54 154 1154 2154 7154 108 109 EPAAAA FUEAAA HHHHxx 8340 3230 0 0 0 0 40 340 340 3340 8340 80 81 UIAAAA GUEAAA OOOOxx 7110 3231 0 2 0 10 10 110 1110 2110 7110 20 21 MNAAAA HUEAAA VVVVxx 7795 3232 1 3 5 15 95 795 1795 2795 7795 190 191 VNAAAA IUEAAA AAAAxx 132 3233 0 0 2 12 32 132 132 132 132 64 65 CFAAAA JUEAAA HHHHxx 4603 3234 1 3 3 3 3 603 603 4603 4603 6 7 BVAAAA KUEAAA OOOOxx 9720 3235 0 0 0 0 20 720 1720 4720 9720 40 41 WJAAAA LUEAAA VVVVxx 1460 3236 0 0 0 0 60 460 1460 1460 1460 120 121 EEAAAA MUEAAA AAAAxx 4677 3237 1 1 7 17 77 677 677 4677 4677 154 155 XXAAAA NUEAAA HHHHxx 9272 3238 0 0 2 12 72 272 1272 4272 9272 144 145 QSAAAA OUEAAA OOOOxx 2279 3239 1 3 9 19 79 279 279 2279 2279 158 159 RJAAAA PUEAAA VVVVxx 4587 3240 1 3 7 7 87 587 587 4587 4587 174 175 LUAAAA QUEAAA AAAAxx 2244 3241 0 0 4 4 44 244 244 2244 2244 88 89 IIAAAA RUEAAA HHHHxx 742 3242 0 2 2 2 42 742 742 742 742 84 85 OCAAAA SUEAAA OOOOxx 4426 3243 0 2 6 6 26 426 426 4426 4426 52 53 GOAAAA TUEAAA VVVVxx 4571 3244 1 3 1 11 71 571 571 4571 4571 142 143 VTAAAA UUEAAA AAAAxx 4775 3245 1 3 5 15 75 775 775 4775 4775 150 151 RBAAAA VUEAAA HHHHxx 24 3246 0 0 4 4 24 24 24 24 24 48 49 YAAAAA WUEAAA OOOOxx 4175 3247 1 3 5 15 75 175 175 4175 4175 150 151 PEAAAA XUEAAA VVVVxx 9877 3248 1 1 7 17 77 877 1877 4877 9877 154 155 XPAAAA YUEAAA AAAAxx 7271 3249 1 3 1 11 71 271 1271 2271 7271 142 143 RTAAAA ZUEAAA HHHHxx 5468 3250 0 0 8 8 68 468 1468 468 5468 136 137 ICAAAA AVEAAA OOOOxx 6106 3251 0 2 6 6 6 106 106 1106 6106 12 13 WAAAAA BVEAAA VVVVxx 9005 3252 1 1 5 5 5 5 1005 4005 9005 10 11 JIAAAA CVEAAA AAAAxx 109 3253 1 1 9 9 9 109 109 109 109 18 19 FEAAAA DVEAAA HHHHxx 6365 3254 1 1 5 5 65 365 365 1365 6365 130 131 VKAAAA EVEAAA OOOOxx 7437 3255 1 1 7 17 37 437 1437 2437 7437 74 75 BAAAAA FVEAAA VVVVxx 7979 3256 1 3 9 19 79 979 1979 2979 7979 158 159 XUAAAA GVEAAA AAAAxx 6050 3257 0 2 0 10 50 50 50 1050 6050 100 101 SYAAAA HVEAAA HHHHxx 2853 3258 1 1 3 13 53 853 853 2853 2853 106 107 TFAAAA IVEAAA OOOOxx 7603 3259 1 3 3 3 3 603 1603 2603 7603 6 7 LGAAAA JVEAAA VVVVxx 483 3260 1 3 3 3 83 483 483 483 483 166 167 PSAAAA KVEAAA AAAAxx 5994 3261 0 2 4 14 94 994 1994 994 5994 188 189 OWAAAA LVEAAA HHHHxx 6708 3262 0 0 8 8 8 708 708 1708 6708 16 17 AYAAAA MVEAAA OOOOxx 5090 3263 0 2 0 10 90 90 1090 90 5090 180 181 UNAAAA NVEAAA VVVVxx 4608 3264 0 0 8 8 8 608 608 4608 4608 16 17 GVAAAA OVEAAA AAAAxx 4551 3265 1 3 1 11 51 551 551 4551 4551 102 103 BTAAAA PVEAAA HHHHxx 5437 3266 1 1 7 17 37 437 1437 437 5437 74 75 DBAAAA QVEAAA OOOOxx 4130 3267 0 2 0 10 30 130 130 4130 4130 60 61 WCAAAA RVEAAA VVVVxx 6363 3268 1 3 3 3 63 363 363 1363 6363 126 127 TKAAAA SVEAAA AAAAxx 1499 3269 1 3 9 19 99 499 1499 1499 1499 198 199 RFAAAA TVEAAA HHHHxx 384 3270 0 0 4 4 84 384 384 384 384 168 169 UOAAAA UVEAAA OOOOxx 2266 3271 0 2 6 6 66 266 266 2266 2266 132 133 EJAAAA VVEAAA VVVVxx 6018 3272 0 2 8 18 18 18 18 1018 6018 36 37 MXAAAA WVEAAA AAAAxx 7915 3273 1 3 5 15 15 915 1915 2915 7915 30 31 LSAAAA XVEAAA HHHHxx 6167 3274 1 3 7 7 67 167 167 1167 6167 134 135 FDAAAA YVEAAA OOOOxx 9988 3275 0 0 8 8 88 988 1988 4988 9988 176 177 EUAAAA ZVEAAA VVVVxx 6599 3276 1 3 9 19 99 599 599 1599 6599 198 199 VTAAAA AWEAAA AAAAxx 1693 3277 1 1 3 13 93 693 1693 1693 1693 186 187 DNAAAA BWEAAA HHHHxx 5971 3278 1 3 1 11 71 971 1971 971 5971 142 143 RVAAAA CWEAAA OOOOxx 8470 3279 0 2 0 10 70 470 470 3470 8470 140 141 UNAAAA DWEAAA VVVVxx 2807 3280 1 3 7 7 7 807 807 2807 2807 14 15 ZDAAAA EWEAAA AAAAxx 1120 3281 0 0 0 0 20 120 1120 1120 1120 40 41 CRAAAA FWEAAA HHHHxx 5924 3282 0 0 4 4 24 924 1924 924 5924 48 49 WTAAAA GWEAAA OOOOxx 9025 3283 1 1 5 5 25 25 1025 4025 9025 50 51 DJAAAA HWEAAA VVVVxx 9454 3284 0 2 4 14 54 454 1454 4454 9454 108 109 QZAAAA IWEAAA AAAAxx 2259 3285 1 3 9 19 59 259 259 2259 2259 118 119 XIAAAA JWEAAA HHHHxx 5249 3286 1 1 9 9 49 249 1249 249 5249 98 99 XTAAAA KWEAAA OOOOxx 6350 3287 0 2 0 10 50 350 350 1350 6350 100 101 GKAAAA LWEAAA VVVVxx 2930 3288 0 2 0 10 30 930 930 2930 2930 60 61 SIAAAA MWEAAA AAAAxx 6055 3289 1 3 5 15 55 55 55 1055 6055 110 111 XYAAAA NWEAAA HHHHxx 7691 3290 1 3 1 11 91 691 1691 2691 7691 182 183 VJAAAA OWEAAA OOOOxx 1573 3291 1 1 3 13 73 573 1573 1573 1573 146 147 NIAAAA PWEAAA VVVVxx 9943 3292 1 3 3 3 43 943 1943 4943 9943 86 87 LSAAAA QWEAAA AAAAxx 3085 3293 1 1 5 5 85 85 1085 3085 3085 170 171 ROAAAA RWEAAA HHHHxx 5928 3294 0 0 8 8 28 928 1928 928 5928 56 57 AUAAAA SWEAAA OOOOxx 887 3295 1 3 7 7 87 887 887 887 887 174 175 DIAAAA TWEAAA VVVVxx 4630 3296 0 2 0 10 30 630 630 4630 4630 60 61 CWAAAA UWEAAA AAAAxx 9827 3297 1 3 7 7 27 827 1827 4827 9827 54 55 ZNAAAA VWEAAA HHHHxx 8926 3298 0 2 6 6 26 926 926 3926 8926 52 53 IFAAAA WWEAAA OOOOxx 5726 3299 0 2 6 6 26 726 1726 726 5726 52 53 GMAAAA XWEAAA VVVVxx 1569 3300 1 1 9 9 69 569 1569 1569 1569 138 139 JIAAAA YWEAAA AAAAxx 8074 3301 0 2 4 14 74 74 74 3074 8074 148 149 OYAAAA ZWEAAA HHHHxx 7909 3302 1 1 9 9 9 909 1909 2909 7909 18 19 FSAAAA AXEAAA OOOOxx 8367 3303 1 3 7 7 67 367 367 3367 8367 134 135 VJAAAA BXEAAA VVVVxx 7217 3304 1 1 7 17 17 217 1217 2217 7217 34 35 PRAAAA CXEAAA AAAAxx 5254 3305 0 2 4 14 54 254 1254 254 5254 108 109 CUAAAA DXEAAA HHHHxx 1181 3306 1 1 1 1 81 181 1181 1181 1181 162 163 LTAAAA EXEAAA OOOOxx 6907 3307 1 3 7 7 7 907 907 1907 6907 14 15 RFAAAA FXEAAA VVVVxx 5508 3308 0 0 8 8 8 508 1508 508 5508 16 17 WDAAAA GXEAAA AAAAxx 4782 3309 0 2 2 2 82 782 782 4782 4782 164 165 YBAAAA HXEAAA HHHHxx 793 3310 1 1 3 13 93 793 793 793 793 186 187 NEAAAA IXEAAA OOOOxx 5740 3311 0 0 0 0 40 740 1740 740 5740 80 81 UMAAAA JXEAAA VVVVxx 3107 3312 1 3 7 7 7 107 1107 3107 3107 14 15 NPAAAA KXEAAA AAAAxx 1197 3313 1 1 7 17 97 197 1197 1197 1197 194 195 BUAAAA LXEAAA HHHHxx 4376 3314 0 0 6 16 76 376 376 4376 4376 152 153 IMAAAA MXEAAA OOOOxx 6226 3315 0 2 6 6 26 226 226 1226 6226 52 53 MFAAAA NXEAAA VVVVxx 5033 3316 1 1 3 13 33 33 1033 33 5033 66 67 PLAAAA OXEAAA AAAAxx 5494 3317 0 2 4 14 94 494 1494 494 5494 188 189 IDAAAA PXEAAA HHHHxx 3244 3318 0 0 4 4 44 244 1244 3244 3244 88 89 UUAAAA QXEAAA OOOOxx 7670 3319 0 2 0 10 70 670 1670 2670 7670 140 141 AJAAAA RXEAAA VVVVxx 9273 3320 1 1 3 13 73 273 1273 4273 9273 146 147 RSAAAA SXEAAA AAAAxx 5248 3321 0 0 8 8 48 248 1248 248 5248 96 97 WTAAAA TXEAAA HHHHxx 3381 3322 1 1 1 1 81 381 1381 3381 3381 162 163 BAAAAA UXEAAA OOOOxx 4136 3323 0 0 6 16 36 136 136 4136 4136 72 73 CDAAAA VXEAAA VVVVxx 4163 3324 1 3 3 3 63 163 163 4163 4163 126 127 DEAAAA WXEAAA AAAAxx 4270 3325 0 2 0 10 70 270 270 4270 4270 140 141 GIAAAA XXEAAA HHHHxx 1729 3326 1 1 9 9 29 729 1729 1729 1729 58 59 NOAAAA YXEAAA OOOOxx 2778 3327 0 2 8 18 78 778 778 2778 2778 156 157 WCAAAA ZXEAAA VVVVxx 5082 3328 0 2 2 2 82 82 1082 82 5082 164 165 MNAAAA AYEAAA AAAAxx 870 3329 0 2 0 10 70 870 870 870 870 140 141 MHAAAA BYEAAA HHHHxx 4192 3330 0 0 2 12 92 192 192 4192 4192 184 185 GFAAAA CYEAAA OOOOxx 308 3331 0 0 8 8 8 308 308 308 308 16 17 WLAAAA DYEAAA VVVVxx 6783 3332 1 3 3 3 83 783 783 1783 6783 166 167 XAAAAA EYEAAA AAAAxx 7611 3333 1 3 1 11 11 611 1611 2611 7611 22 23 TGAAAA FYEAAA HHHHxx 4221 3334 1 1 1 1 21 221 221 4221 4221 42 43 JGAAAA GYEAAA OOOOxx 6353 3335 1 1 3 13 53 353 353 1353 6353 106 107 JKAAAA HYEAAA VVVVxx 1830 3336 0 2 0 10 30 830 1830 1830 1830 60 61 KSAAAA IYEAAA AAAAxx 2437 3337 1 1 7 17 37 437 437 2437 2437 74 75 TPAAAA JYEAAA HHHHxx 3360 3338 0 0 0 0 60 360 1360 3360 3360 120 121 GZAAAA KYEAAA OOOOxx 1829 3339 1 1 9 9 29 829 1829 1829 1829 58 59 JSAAAA LYEAAA VVVVxx 9475 3340 1 3 5 15 75 475 1475 4475 9475 150 151 LAAAAA MYEAAA AAAAxx 4566 3341 0 2 6 6 66 566 566 4566 4566 132 133 QTAAAA NYEAAA HHHHxx 9944 3342 0 0 4 4 44 944 1944 4944 9944 88 89 MSAAAA OYEAAA OOOOxx 6054 3343 0 2 4 14 54 54 54 1054 6054 108 109 WYAAAA PYEAAA VVVVxx 4722 3344 0 2 2 2 22 722 722 4722 4722 44 45 QZAAAA QYEAAA AAAAxx 2779 3345 1 3 9 19 79 779 779 2779 2779 158 159 XCAAAA RYEAAA HHHHxx 8051 3346 1 3 1 11 51 51 51 3051 8051 102 103 RXAAAA SYEAAA OOOOxx 9671 3347 1 3 1 11 71 671 1671 4671 9671 142 143 ZHAAAA TYEAAA VVVVxx 6084 3348 0 0 4 4 84 84 84 1084 6084 168 169 AAAAAA UYEAAA AAAAxx 3729 3349 1 1 9 9 29 729 1729 3729 3729 58 59 LNAAAA VYEAAA HHHHxx 6627 3350 1 3 7 7 27 627 627 1627 6627 54 55 XUAAAA WYEAAA OOOOxx 4769 3351 1 1 9 9 69 769 769 4769 4769 138 139 LBAAAA XYEAAA VVVVxx 2224 3352 0 0 4 4 24 224 224 2224 2224 48 49 OHAAAA YYEAAA AAAAxx 1404 3353 0 0 4 4 4 404 1404 1404 1404 8 9 ACAAAA ZYEAAA HHHHxx 8532 3354 0 0 2 12 32 532 532 3532 8532 64 65 EQAAAA AZEAAA OOOOxx 6759 3355 1 3 9 19 59 759 759 1759 6759 118 119 ZZAAAA BZEAAA VVVVxx 6404 3356 0 0 4 4 4 404 404 1404 6404 8 9 IMAAAA CZEAAA AAAAxx 3144 3357 0 0 4 4 44 144 1144 3144 3144 88 89 YQAAAA DZEAAA HHHHxx 973 3358 1 1 3 13 73 973 973 973 973 146 147 LLAAAA EZEAAA OOOOxx 9789 3359 1 1 9 9 89 789 1789 4789 9789 178 179 NMAAAA FZEAAA VVVVxx 6181 3360 1 1 1 1 81 181 181 1181 6181 162 163 TDAAAA GZEAAA AAAAxx 1519 3361 1 3 9 19 19 519 1519 1519 1519 38 39 LGAAAA HZEAAA HHHHxx 9729 3362 1 1 9 9 29 729 1729 4729 9729 58 59 FKAAAA IZEAAA OOOOxx 8167 3363 1 3 7 7 67 167 167 3167 8167 134 135 DCAAAA JZEAAA VVVVxx 3830 3364 0 2 0 10 30 830 1830 3830 3830 60 61 IRAAAA KZEAAA AAAAxx 6286 3365 0 2 6 6 86 286 286 1286 6286 172 173 UHAAAA LZEAAA HHHHxx 3047 3366 1 3 7 7 47 47 1047 3047 3047 94 95 FNAAAA MZEAAA OOOOxx 3183 3367 1 3 3 3 83 183 1183 3183 3183 166 167 LSAAAA NZEAAA VVVVxx 6687 3368 1 3 7 7 87 687 687 1687 6687 174 175 FXAAAA OZEAAA AAAAxx 2783 3369 1 3 3 3 83 783 783 2783 2783 166 167 BDAAAA PZEAAA HHHHxx 9920 3370 0 0 0 0 20 920 1920 4920 9920 40 41 ORAAAA QZEAAA OOOOxx 4847 3371 1 3 7 7 47 847 847 4847 4847 94 95 LEAAAA RZEAAA VVVVxx 3645 3372 1 1 5 5 45 645 1645 3645 3645 90 91 FKAAAA SZEAAA AAAAxx 7406 3373 0 2 6 6 6 406 1406 2406 7406 12 13 WYAAAA TZEAAA HHHHxx 6003 3374 1 3 3 3 3 3 3 1003 6003 6 7 XWAAAA UZEAAA OOOOxx 3408 3375 0 0 8 8 8 408 1408 3408 3408 16 17 CBAAAA VZEAAA VVVVxx 4243 3376 1 3 3 3 43 243 243 4243 4243 86 87 FHAAAA WZEAAA AAAAxx 1622 3377 0 2 2 2 22 622 1622 1622 1622 44 45 KKAAAA XZEAAA HHHHxx 5319 3378 1 3 9 19 19 319 1319 319 5319 38 39 PWAAAA YZEAAA OOOOxx 4033 3379 1 1 3 13 33 33 33 4033 4033 66 67 DZAAAA ZZEAAA VVVVxx 8573 3380 1 1 3 13 73 573 573 3573 8573 146 147 TRAAAA AAFAAA AAAAxx 8404 3381 0 0 4 4 4 404 404 3404 8404 8 9 GLAAAA BAFAAA HHHHxx 6993 3382 1 1 3 13 93 993 993 1993 6993 186 187 ZIAAAA CAFAAA OOOOxx 660 3383 0 0 0 0 60 660 660 660 660 120 121 KZAAAA DAFAAA VVVVxx 1136 3384 0 0 6 16 36 136 1136 1136 1136 72 73 SRAAAA EAFAAA AAAAxx 3393 3385 1 1 3 13 93 393 1393 3393 3393 186 187 NAAAAA FAFAAA HHHHxx 9743 3386 1 3 3 3 43 743 1743 4743 9743 86 87 TKAAAA GAFAAA OOOOxx 9705 3387 1 1 5 5 5 705 1705 4705 9705 10 11 HJAAAA HAFAAA VVVVxx 6960 3388 0 0 0 0 60 960 960 1960 6960 120 121 SHAAAA IAFAAA AAAAxx 2753 3389 1 1 3 13 53 753 753 2753 2753 106 107 XBAAAA JAFAAA HHHHxx 906 3390 0 2 6 6 6 906 906 906 906 12 13 WIAAAA KAFAAA OOOOxx 999 3391 1 3 9 19 99 999 999 999 999 198 199 LMAAAA LAFAAA VVVVxx 6927 3392 1 3 7 7 27 927 927 1927 6927 54 55 LGAAAA MAFAAA AAAAxx 4846 3393 0 2 6 6 46 846 846 4846 4846 92 93 KEAAAA NAFAAA HHHHxx 676 3394 0 0 6 16 76 676 676 676 676 152 153 AAAAAA OAFAAA OOOOxx 8612 3395 0 0 2 12 12 612 612 3612 8612 24 25 GTAAAA PAFAAA VVVVxx 4111 3396 1 3 1 11 11 111 111 4111 4111 22 23 DCAAAA QAFAAA AAAAxx 9994 3397 0 2 4 14 94 994 1994 4994 9994 188 189 KUAAAA RAFAAA HHHHxx 4399 3398 1 3 9 19 99 399 399 4399 4399 198 199 FNAAAA SAFAAA OOOOxx 4464 3399 0 0 4 4 64 464 464 4464 4464 128 129 SPAAAA TAFAAA VVVVxx 7316 3400 0 0 6 16 16 316 1316 2316 7316 32 33 KVAAAA UAFAAA AAAAxx 8982 3401 0 2 2 2 82 982 982 3982 8982 164 165 MHAAAA VAFAAA HHHHxx 1871 3402 1 3 1 11 71 871 1871 1871 1871 142 143 ZTAAAA WAFAAA OOOOxx 4082 3403 0 2 2 2 82 82 82 4082 4082 164 165 ABAAAA XAFAAA VVVVxx 3949 3404 1 1 9 9 49 949 1949 3949 3949 98 99 XVAAAA YAFAAA AAAAxx 9352 3405 0 0 2 12 52 352 1352 4352 9352 104 105 SVAAAA ZAFAAA HHHHxx 9638 3406 0 2 8 18 38 638 1638 4638 9638 76 77 SGAAAA ABFAAA OOOOxx 8177 3407 1 1 7 17 77 177 177 3177 8177 154 155 NCAAAA BBFAAA VVVVxx 3499 3408 1 3 9 19 99 499 1499 3499 3499 198 199 PEAAAA CBFAAA AAAAxx 4233 3409 1 1 3 13 33 233 233 4233 4233 66 67 VGAAAA DBFAAA HHHHxx 1953 3410 1 1 3 13 53 953 1953 1953 1953 106 107 DXAAAA EBFAAA OOOOxx 7372 3411 0 0 2 12 72 372 1372 2372 7372 144 145 OXAAAA FBFAAA VVVVxx 5127 3412 1 3 7 7 27 127 1127 127 5127 54 55 FPAAAA GBFAAA AAAAxx 4384 3413 0 0 4 4 84 384 384 4384 4384 168 169 QMAAAA HBFAAA HHHHxx 9964 3414 0 0 4 4 64 964 1964 4964 9964 128 129 GTAAAA IBFAAA OOOOxx 5392 3415 0 0 2 12 92 392 1392 392 5392 184 185 KZAAAA JBFAAA VVVVxx 616 3416 0 0 6 16 16 616 616 616 616 32 33 SXAAAA KBFAAA AAAAxx 591 3417 1 3 1 11 91 591 591 591 591 182 183 TWAAAA LBFAAA HHHHxx 6422 3418 0 2 2 2 22 422 422 1422 6422 44 45 ANAAAA MBFAAA OOOOxx 6551 3419 1 3 1 11 51 551 551 1551 6551 102 103 ZRAAAA NBFAAA VVVVxx 9286 3420 0 2 6 6 86 286 1286 4286 9286 172 173 ETAAAA OBFAAA AAAAxx 3817 3421 1 1 7 17 17 817 1817 3817 3817 34 35 VQAAAA PBFAAA HHHHxx 7717 3422 1 1 7 17 17 717 1717 2717 7717 34 35 VKAAAA QBFAAA OOOOxx 8718 3423 0 2 8 18 18 718 718 3718 8718 36 37 IXAAAA RBFAAA VVVVxx 8608 3424 0 0 8 8 8 608 608 3608 8608 16 17 CTAAAA SBFAAA AAAAxx 2242 3425 0 2 2 2 42 242 242 2242 2242 84 85 GIAAAA TBFAAA HHHHxx 4811 3426 1 3 1 11 11 811 811 4811 4811 22 23 BDAAAA UBFAAA OOOOxx 6838 3427 0 2 8 18 38 838 838 1838 6838 76 77 ADAAAA VBFAAA VVVVxx 787 3428 1 3 7 7 87 787 787 787 787 174 175 HEAAAA WBFAAA AAAAxx 7940 3429 0 0 0 0 40 940 1940 2940 7940 80 81 KTAAAA XBFAAA HHHHxx 336 3430 0 0 6 16 36 336 336 336 336 72 73 YMAAAA YBFAAA OOOOxx 9859 3431 1 3 9 19 59 859 1859 4859 9859 118 119 FPAAAA ZBFAAA VVVVxx 3864 3432 0 0 4 4 64 864 1864 3864 3864 128 129 QSAAAA ACFAAA AAAAxx 7162 3433 0 2 2 2 62 162 1162 2162 7162 124 125 MPAAAA BCFAAA HHHHxx 2071 3434 1 3 1 11 71 71 71 2071 2071 142 143 RBAAAA CCFAAA OOOOxx 7469 3435 1 1 9 9 69 469 1469 2469 7469 138 139 HBAAAA DCFAAA VVVVxx 2917 3436 1 1 7 17 17 917 917 2917 2917 34 35 FIAAAA ECFAAA AAAAxx 7486 3437 0 2 6 6 86 486 1486 2486 7486 172 173 YBAAAA FCFAAA HHHHxx 3355 3438 1 3 5 15 55 355 1355 3355 3355 110 111 BZAAAA GCFAAA OOOOxx 6998 3439 0 2 8 18 98 998 998 1998 6998 196 197 EJAAAA HCFAAA VVVVxx 5498 3440 0 2 8 18 98 498 1498 498 5498 196 197 MDAAAA ICFAAA AAAAxx 5113 3441 1 1 3 13 13 113 1113 113 5113 26 27 ROAAAA JCFAAA HHHHxx 2846 3442 0 2 6 6 46 846 846 2846 2846 92 93 MFAAAA KCFAAA OOOOxx 6834 3443 0 2 4 14 34 834 834 1834 6834 68 69 WCAAAA LCFAAA VVVVxx 8925 3444 1 1 5 5 25 925 925 3925 8925 50 51 HFAAAA MCFAAA AAAAxx 2757 3445 1 1 7 17 57 757 757 2757 2757 114 115 BCAAAA NCFAAA HHHHxx 2775 3446 1 3 5 15 75 775 775 2775 2775 150 151 TCAAAA OCFAAA OOOOxx 6182 3447 0 2 2 2 82 182 182 1182 6182 164 165 UDAAAA PCFAAA VVVVxx 4488 3448 0 0 8 8 88 488 488 4488 4488 176 177 QQAAAA QCFAAA AAAAxx 8523 3449 1 3 3 3 23 523 523 3523 8523 46 47 VPAAAA RCFAAA HHHHxx 52 3450 0 0 2 12 52 52 52 52 52 104 105 ACAAAA SCFAAA OOOOxx 7251 3451 1 3 1 11 51 251 1251 2251 7251 102 103 XSAAAA TCFAAA VVVVxx 6130 3452 0 2 0 10 30 130 130 1130 6130 60 61 UBAAAA UCFAAA AAAAxx 205 3453 1 1 5 5 5 205 205 205 205 10 11 XHAAAA VCFAAA HHHHxx 1186 3454 0 2 6 6 86 186 1186 1186 1186 172 173 QTAAAA WCFAAA OOOOxx 1738 3455 0 2 8 18 38 738 1738 1738 1738 76 77 WOAAAA XCFAAA VVVVxx 9485 3456 1 1 5 5 85 485 1485 4485 9485 170 171 VAAAAA YCFAAA AAAAxx 4235 3457 1 3 5 15 35 235 235 4235 4235 70 71 XGAAAA ZCFAAA HHHHxx 7891 3458 1 3 1 11 91 891 1891 2891 7891 182 183 NRAAAA ADFAAA OOOOxx 4960 3459 0 0 0 0 60 960 960 4960 4960 120 121 UIAAAA BDFAAA VVVVxx 8911 3460 1 3 1 11 11 911 911 3911 8911 22 23 TEAAAA CDFAAA AAAAxx 1219 3461 1 3 9 19 19 219 1219 1219 1219 38 39 XUAAAA DDFAAA HHHHxx 9652 3462 0 0 2 12 52 652 1652 4652 9652 104 105 GHAAAA EDFAAA OOOOxx 9715 3463 1 3 5 15 15 715 1715 4715 9715 30 31 RJAAAA FDFAAA VVVVxx 6629 3464 1 1 9 9 29 629 629 1629 6629 58 59 ZUAAAA GDFAAA AAAAxx 700 3465 0 0 0 0 0 700 700 700 700 0 1 YAAAAA HDFAAA HHHHxx 9819 3466 1 3 9 19 19 819 1819 4819 9819 38 39 RNAAAA IDFAAA OOOOxx 5188 3467 0 0 8 8 88 188 1188 188 5188 176 177 ORAAAA JDFAAA VVVVxx 5367 3468 1 3 7 7 67 367 1367 367 5367 134 135 LYAAAA KDFAAA AAAAxx 6447 3469 1 3 7 7 47 447 447 1447 6447 94 95 ZNAAAA LDFAAA HHHHxx 720 3470 0 0 0 0 20 720 720 720 720 40 41 SBAAAA MDFAAA OOOOxx 9157 3471 1 1 7 17 57 157 1157 4157 9157 114 115 FOAAAA NDFAAA VVVVxx 1082 3472 0 2 2 2 82 82 1082 1082 1082 164 165 QPAAAA ODFAAA AAAAxx 3179 3473 1 3 9 19 79 179 1179 3179 3179 158 159 HSAAAA PDFAAA HHHHxx 4818 3474 0 2 8 18 18 818 818 4818 4818 36 37 IDAAAA QDFAAA OOOOxx 7607 3475 1 3 7 7 7 607 1607 2607 7607 14 15 PGAAAA RDFAAA VVVVxx 2352 3476 0 0 2 12 52 352 352 2352 2352 104 105 MMAAAA SDFAAA AAAAxx 1170 3477 0 2 0 10 70 170 1170 1170 1170 140 141 ATAAAA TDFAAA HHHHxx 4269 3478 1 1 9 9 69 269 269 4269 4269 138 139 FIAAAA UDFAAA OOOOxx 8767 3479 1 3 7 7 67 767 767 3767 8767 134 135 FZAAAA VDFAAA VVVVxx 3984 3480 0 0 4 4 84 984 1984 3984 3984 168 169 GXAAAA WDFAAA AAAAxx 3190 3481 0 2 0 10 90 190 1190 3190 3190 180 181 SSAAAA XDFAAA HHHHxx 7456 3482 0 0 6 16 56 456 1456 2456 7456 112 113 UAAAAA YDFAAA OOOOxx 4348 3483 0 0 8 8 48 348 348 4348 4348 96 97 GLAAAA ZDFAAA VVVVxx 3150 3484 0 2 0 10 50 150 1150 3150 3150 100 101 ERAAAA AEFAAA AAAAxx 8780 3485 0 0 0 0 80 780 780 3780 8780 160 161 SZAAAA BEFAAA HHHHxx 2553 3486 1 1 3 13 53 553 553 2553 2553 106 107 FUAAAA CEFAAA OOOOxx 7526 3487 0 2 6 6 26 526 1526 2526 7526 52 53 MDAAAA DEFAAA VVVVxx 2031 3488 1 3 1 11 31 31 31 2031 2031 62 63 DAAAAA EEFAAA AAAAxx 8793 3489 1 1 3 13 93 793 793 3793 8793 186 187 FAAAAA FEFAAA HHHHxx 1122 3490 0 2 2 2 22 122 1122 1122 1122 44 45 ERAAAA GEFAAA OOOOxx 1855 3491 1 3 5 15 55 855 1855 1855 1855 110 111 JTAAAA HEFAAA VVVVxx 6613 3492 1 1 3 13 13 613 613 1613 6613 26 27 JUAAAA IEFAAA AAAAxx 3231 3493 1 3 1 11 31 231 1231 3231 3231 62 63 HUAAAA JEFAAA HHHHxx 9101 3494 1 1 1 1 1 101 1101 4101 9101 2 3 BMAAAA KEFAAA OOOOxx 4937 3495 1 1 7 17 37 937 937 4937 4937 74 75 XHAAAA LEFAAA VVVVxx 666 3496 0 2 6 6 66 666 666 666 666 132 133 QZAAAA MEFAAA AAAAxx 8943 3497 1 3 3 3 43 943 943 3943 8943 86 87 ZFAAAA NEFAAA HHHHxx 6164 3498 0 0 4 4 64 164 164 1164 6164 128 129 CDAAAA OEFAAA OOOOxx 1081 3499 1 1 1 1 81 81 1081 1081 1081 162 163 PPAAAA PEFAAA VVVVxx 210 3500 0 2 0 10 10 210 210 210 210 20 21 CIAAAA QEFAAA AAAAxx 6024 3501 0 0 4 4 24 24 24 1024 6024 48 49 SXAAAA REFAAA HHHHxx 5715 3502 1 3 5 15 15 715 1715 715 5715 30 31 VLAAAA SEFAAA OOOOxx 8938 3503 0 2 8 18 38 938 938 3938 8938 76 77 UFAAAA TEFAAA VVVVxx 1326 3504 0 2 6 6 26 326 1326 1326 1326 52 53 AZAAAA UEFAAA AAAAxx 7111 3505 1 3 1 11 11 111 1111 2111 7111 22 23 NNAAAA VEFAAA HHHHxx 757 3506 1 1 7 17 57 757 757 757 757 114 115 DDAAAA WEFAAA OOOOxx 8933 3507 1 1 3 13 33 933 933 3933 8933 66 67 PFAAAA XEFAAA VVVVxx 6495 3508 1 3 5 15 95 495 495 1495 6495 190 191 VPAAAA YEFAAA AAAAxx 3134 3509 0 2 4 14 34 134 1134 3134 3134 68 69 OQAAAA ZEFAAA HHHHxx 1304 3510 0 0 4 4 4 304 1304 1304 1304 8 9 EYAAAA AFFAAA OOOOxx 1835 3511 1 3 5 15 35 835 1835 1835 1835 70 71 PSAAAA BFFAAA VVVVxx 7275 3512 1 3 5 15 75 275 1275 2275 7275 150 151 VTAAAA CFFAAA AAAAxx 7337 3513 1 1 7 17 37 337 1337 2337 7337 74 75 FWAAAA DFFAAA HHHHxx 1282 3514 0 2 2 2 82 282 1282 1282 1282 164 165 IXAAAA EFFAAA OOOOxx 6566 3515 0 2 6 6 66 566 566 1566 6566 132 133 OSAAAA FFFAAA VVVVxx 3786 3516 0 2 6 6 86 786 1786 3786 3786 172 173 QPAAAA GFFAAA AAAAxx 5741 3517 1 1 1 1 41 741 1741 741 5741 82 83 VMAAAA HFFAAA HHHHxx 6076 3518 0 0 6 16 76 76 76 1076 6076 152 153 SZAAAA IFFAAA OOOOxx 9998 3519 0 2 8 18 98 998 1998 4998 9998 196 197 OUAAAA JFFAAA VVVVxx 6268 3520 0 0 8 8 68 268 268 1268 6268 136 137 CHAAAA KFFAAA AAAAxx 9647 3521 1 3 7 7 47 647 1647 4647 9647 94 95 BHAAAA LFFAAA HHHHxx 4877 3522 1 1 7 17 77 877 877 4877 4877 154 155 PFAAAA MFFAAA OOOOxx 2652 3523 0 0 2 12 52 652 652 2652 2652 104 105 AYAAAA NFFAAA VVVVxx 1247 3524 1 3 7 7 47 247 1247 1247 1247 94 95 ZVAAAA OFFAAA AAAAxx 2721 3525 1 1 1 1 21 721 721 2721 2721 42 43 RAAAAA PFFAAA HHHHxx 5968 3526 0 0 8 8 68 968 1968 968 5968 136 137 OVAAAA QFFAAA OOOOxx 9570 3527 0 2 0 10 70 570 1570 4570 9570 140 141 CEAAAA RFFAAA VVVVxx 6425 3528 1 1 5 5 25 425 425 1425 6425 50 51 DNAAAA SFFAAA AAAAxx 5451 3529 1 3 1 11 51 451 1451 451 5451 102 103 RBAAAA TFFAAA HHHHxx 5668 3530 0 0 8 8 68 668 1668 668 5668 136 137 AKAAAA UFFAAA OOOOxx 9493 3531 1 1 3 13 93 493 1493 4493 9493 186 187 DBAAAA VFFAAA VVVVxx 7973 3532 1 1 3 13 73 973 1973 2973 7973 146 147 RUAAAA WFFAAA AAAAxx 8250 3533 0 2 0 10 50 250 250 3250 8250 100 101 IFAAAA XFFAAA HHHHxx 82 3534 0 2 2 2 82 82 82 82 82 164 165 EDAAAA YFFAAA OOOOxx 6258 3535 0 2 8 18 58 258 258 1258 6258 116 117 SGAAAA ZFFAAA VVVVxx 9978 3536 0 2 8 18 78 978 1978 4978 9978 156 157 UTAAAA AGFAAA AAAAxx 6930 3537 0 2 0 10 30 930 930 1930 6930 60 61 OGAAAA BGFAAA HHHHxx 3746 3538 0 2 6 6 46 746 1746 3746 3746 92 93 COAAAA CGFAAA OOOOxx 7065 3539 1 1 5 5 65 65 1065 2065 7065 130 131 TLAAAA DGFAAA VVVVxx 4281 3540 1 1 1 1 81 281 281 4281 4281 162 163 RIAAAA EGFAAA AAAAxx 4367 3541 1 3 7 7 67 367 367 4367 4367 134 135 ZLAAAA FGFAAA HHHHxx 9526 3542 0 2 6 6 26 526 1526 4526 9526 52 53 KCAAAA GGFAAA OOOOxx 5880 3543 0 0 0 0 80 880 1880 880 5880 160 161 ESAAAA HGFAAA VVVVxx 8480 3544 0 0 0 0 80 480 480 3480 8480 160 161 EOAAAA IGFAAA AAAAxx 2476 3545 0 0 6 16 76 476 476 2476 2476 152 153 GRAAAA JGFAAA HHHHxx 9074 3546 0 2 4 14 74 74 1074 4074 9074 148 149 ALAAAA KGFAAA OOOOxx 4830 3547 0 2 0 10 30 830 830 4830 4830 60 61 UDAAAA LGFAAA VVVVxx 3207 3548 1 3 7 7 7 207 1207 3207 3207 14 15 JTAAAA MGFAAA AAAAxx 7894 3549 0 2 4 14 94 894 1894 2894 7894 188 189 QRAAAA NGFAAA HHHHxx 3860 3550 0 0 0 0 60 860 1860 3860 3860 120 121 MSAAAA OGFAAA OOOOxx 5293 3551 1 1 3 13 93 293 1293 293 5293 186 187 PVAAAA PGFAAA VVVVxx 6895 3552 1 3 5 15 95 895 895 1895 6895 190 191 FFAAAA QGFAAA AAAAxx 9908 3553 0 0 8 8 8 908 1908 4908 9908 16 17 CRAAAA RGFAAA HHHHxx 9247 3554 1 3 7 7 47 247 1247 4247 9247 94 95 RRAAAA SGFAAA OOOOxx 8110 3555 0 2 0 10 10 110 110 3110 8110 20 21 YZAAAA TGFAAA VVVVxx 4716 3556 0 0 6 16 16 716 716 4716 4716 32 33 KZAAAA UGFAAA AAAAxx 4979 3557 1 3 9 19 79 979 979 4979 4979 158 159 NJAAAA VGFAAA HHHHxx 5280 3558 0 0 0 0 80 280 1280 280 5280 160 161 CVAAAA WGFAAA OOOOxx 8326 3559 0 2 6 6 26 326 326 3326 8326 52 53 GIAAAA XGFAAA VVVVxx 5572 3560 0 0 2 12 72 572 1572 572 5572 144 145 IGAAAA YGFAAA AAAAxx 4665 3561 1 1 5 5 65 665 665 4665 4665 130 131 LXAAAA ZGFAAA HHHHxx 3665 3562 1 1 5 5 65 665 1665 3665 3665 130 131 ZKAAAA AHFAAA OOOOxx 6744 3563 0 0 4 4 44 744 744 1744 6744 88 89 KZAAAA BHFAAA VVVVxx 1897 3564 1 1 7 17 97 897 1897 1897 1897 194 195 ZUAAAA CHFAAA AAAAxx 1220 3565 0 0 0 0 20 220 1220 1220 1220 40 41 YUAAAA DHFAAA HHHHxx 2614 3566 0 2 4 14 14 614 614 2614 2614 28 29 OWAAAA EHFAAA OOOOxx 8509 3567 1 1 9 9 9 509 509 3509 8509 18 19 HPAAAA FHFAAA VVVVxx 8521 3568 1 1 1 1 21 521 521 3521 8521 42 43 TPAAAA GHFAAA AAAAxx 4121 3569 1 1 1 1 21 121 121 4121 4121 42 43 NCAAAA HHFAAA HHHHxx 9663 3570 1 3 3 3 63 663 1663 4663 9663 126 127 RHAAAA IHFAAA OOOOxx 2346 3571 0 2 6 6 46 346 346 2346 2346 92 93 GMAAAA JHFAAA VVVVxx 3370 3572 0 2 0 10 70 370 1370 3370 3370 140 141 QZAAAA KHFAAA AAAAxx 1498 3573 0 2 8 18 98 498 1498 1498 1498 196 197 QFAAAA LHFAAA HHHHxx 7422 3574 0 2 2 2 22 422 1422 2422 7422 44 45 MZAAAA MHFAAA OOOOxx 3472 3575 0 0 2 12 72 472 1472 3472 3472 144 145 ODAAAA NHFAAA VVVVxx 4126 3576 0 2 6 6 26 126 126 4126 4126 52 53 SCAAAA OHFAAA AAAAxx 4494 3577 0 2 4 14 94 494 494 4494 4494 188 189 WQAAAA PHFAAA HHHHxx 6323 3578 1 3 3 3 23 323 323 1323 6323 46 47 FJAAAA QHFAAA OOOOxx 2823 3579 1 3 3 3 23 823 823 2823 2823 46 47 PEAAAA RHFAAA VVVVxx 8596 3580 0 0 6 16 96 596 596 3596 8596 192 193 QSAAAA SHFAAA AAAAxx 6642 3581 0 2 2 2 42 642 642 1642 6642 84 85 MVAAAA THFAAA HHHHxx 9276 3582 0 0 6 16 76 276 1276 4276 9276 152 153 USAAAA UHFAAA OOOOxx 4148 3583 0 0 8 8 48 148 148 4148 4148 96 97 ODAAAA VHFAAA VVVVxx 9770 3584 0 2 0 10 70 770 1770 4770 9770 140 141 ULAAAA WHFAAA AAAAxx 9812 3585 0 0 2 12 12 812 1812 4812 9812 24 25 KNAAAA XHFAAA HHHHxx 4419 3586 1 3 9 19 19 419 419 4419 4419 38 39 ZNAAAA YHFAAA OOOOxx 3802 3587 0 2 2 2 2 802 1802 3802 3802 4 5 GQAAAA ZHFAAA VVVVxx 3210 3588 0 2 0 10 10 210 1210 3210 3210 20 21 MTAAAA AIFAAA AAAAxx 6794 3589 0 2 4 14 94 794 794 1794 6794 188 189 IBAAAA BIFAAA HHHHxx 242 3590 0 2 2 2 42 242 242 242 242 84 85 IJAAAA CIFAAA OOOOxx 962 3591 0 2 2 2 62 962 962 962 962 124 125 ALAAAA DIFAAA VVVVxx 7151 3592 1 3 1 11 51 151 1151 2151 7151 102 103 BPAAAA EIFAAA AAAAxx 9440 3593 0 0 0 0 40 440 1440 4440 9440 80 81 CZAAAA FIFAAA HHHHxx 721 3594 1 1 1 1 21 721 721 721 721 42 43 TBAAAA GIFAAA OOOOxx 2119 3595 1 3 9 19 19 119 119 2119 2119 38 39 NDAAAA HIFAAA VVVVxx 9883 3596 1 3 3 3 83 883 1883 4883 9883 166 167 DQAAAA IIFAAA AAAAxx 5071 3597 1 3 1 11 71 71 1071 71 5071 142 143 BNAAAA JIFAAA HHHHxx 8239 3598 1 3 9 19 39 239 239 3239 8239 78 79 XEAAAA KIFAAA OOOOxx 7451 3599 1 3 1 11 51 451 1451 2451 7451 102 103 PAAAAA LIFAAA VVVVxx 9517 3600 1 1 7 17 17 517 1517 4517 9517 34 35 BCAAAA MIFAAA AAAAxx 9180 3601 0 0 0 0 80 180 1180 4180 9180 160 161 CPAAAA NIFAAA HHHHxx 9327 3602 1 3 7 7 27 327 1327 4327 9327 54 55 TUAAAA OIFAAA OOOOxx 5462 3603 0 2 2 2 62 462 1462 462 5462 124 125 CCAAAA PIFAAA VVVVxx 8306 3604 0 2 6 6 6 306 306 3306 8306 12 13 MHAAAA QIFAAA AAAAxx 6234 3605 0 2 4 14 34 234 234 1234 6234 68 69 UFAAAA RIFAAA HHHHxx 8771 3606 1 3 1 11 71 771 771 3771 8771 142 143 JZAAAA SIFAAA OOOOxx 5853 3607 1 1 3 13 53 853 1853 853 5853 106 107 DRAAAA TIFAAA VVVVxx 8373 3608 1 1 3 13 73 373 373 3373 8373 146 147 BKAAAA UIFAAA AAAAxx 5017 3609 1 1 7 17 17 17 1017 17 5017 34 35 ZKAAAA VIFAAA HHHHxx 8025 3610 1 1 5 5 25 25 25 3025 8025 50 51 RWAAAA WIFAAA OOOOxx 2526 3611 0 2 6 6 26 526 526 2526 2526 52 53 ETAAAA XIFAAA VVVVxx 7419 3612 1 3 9 19 19 419 1419 2419 7419 38 39 JZAAAA YIFAAA AAAAxx 4572 3613 0 0 2 12 72 572 572 4572 4572 144 145 WTAAAA ZIFAAA HHHHxx 7744 3614 0 0 4 4 44 744 1744 2744 7744 88 89 WLAAAA AJFAAA OOOOxx 8825 3615 1 1 5 5 25 825 825 3825 8825 50 51 LBAAAA BJFAAA VVVVxx 6067 3616 1 3 7 7 67 67 67 1067 6067 134 135 JZAAAA CJFAAA AAAAxx 3291 3617 1 3 1 11 91 291 1291 3291 3291 182 183 PWAAAA DJFAAA HHHHxx 7115 3618 1 3 5 15 15 115 1115 2115 7115 30 31 RNAAAA EJFAAA OOOOxx 2626 3619 0 2 6 6 26 626 626 2626 2626 52 53 AXAAAA FJFAAA VVVVxx 4109 3620 1 1 9 9 9 109 109 4109 4109 18 19 BCAAAA GJFAAA AAAAxx 4056 3621 0 0 6 16 56 56 56 4056 4056 112 113 AAAAAA HJFAAA HHHHxx 6811 3622 1 3 1 11 11 811 811 1811 6811 22 23 ZBAAAA IJFAAA OOOOxx 680 3623 0 0 0 0 80 680 680 680 680 160 161 EAAAAA JJFAAA VVVVxx 474 3624 0 2 4 14 74 474 474 474 474 148 149 GSAAAA KJFAAA AAAAxx 9294 3625 0 2 4 14 94 294 1294 4294 9294 188 189 MTAAAA LJFAAA HHHHxx 7555 3626 1 3 5 15 55 555 1555 2555 7555 110 111 PEAAAA MJFAAA OOOOxx 8076 3627 0 0 6 16 76 76 76 3076 8076 152 153 QYAAAA NJFAAA VVVVxx 3840 3628 0 0 0 0 40 840 1840 3840 3840 80 81 SRAAAA OJFAAA AAAAxx 5955 3629 1 3 5 15 55 955 1955 955 5955 110 111 BVAAAA PJFAAA HHHHxx 994 3630 0 2 4 14 94 994 994 994 994 188 189 GMAAAA QJFAAA OOOOxx 2089 3631 1 1 9 9 89 89 89 2089 2089 178 179 JCAAAA RJFAAA VVVVxx 869 3632 1 1 9 9 69 869 869 869 869 138 139 LHAAAA SJFAAA AAAAxx 1223 3633 1 3 3 3 23 223 1223 1223 1223 46 47 BVAAAA TJFAAA HHHHxx 1514 3634 0 2 4 14 14 514 1514 1514 1514 28 29 GGAAAA UJFAAA OOOOxx 4891 3635 1 3 1 11 91 891 891 4891 4891 182 183 DGAAAA VJFAAA VVVVxx 4190 3636 0 2 0 10 90 190 190 4190 4190 180 181 EFAAAA WJFAAA AAAAxx 4377 3637 1 1 7 17 77 377 377 4377 4377 154 155 JMAAAA XJFAAA HHHHxx 9195 3638 1 3 5 15 95 195 1195 4195 9195 190 191 RPAAAA YJFAAA OOOOxx 3827 3639 1 3 7 7 27 827 1827 3827 3827 54 55 FRAAAA ZJFAAA VVVVxx 7386 3640 0 2 6 6 86 386 1386 2386 7386 172 173 CYAAAA AKFAAA AAAAxx 6665 3641 1 1 5 5 65 665 665 1665 6665 130 131 JWAAAA BKFAAA HHHHxx 7514 3642 0 2 4 14 14 514 1514 2514 7514 28 29 ADAAAA CKFAAA OOOOxx 6431 3643 1 3 1 11 31 431 431 1431 6431 62 63 JNAAAA DKFAAA VVVVxx 3251 3644 1 3 1 11 51 251 1251 3251 3251 102 103 BVAAAA EKFAAA AAAAxx 8439 3645 1 3 9 19 39 439 439 3439 8439 78 79 PMAAAA FKFAAA HHHHxx 831 3646 1 3 1 11 31 831 831 831 831 62 63 ZFAAAA GKFAAA OOOOxx 8485 3647 1 1 5 5 85 485 485 3485 8485 170 171 JOAAAA HKFAAA VVVVxx 7314 3648 0 2 4 14 14 314 1314 2314 7314 28 29 IVAAAA IKFAAA AAAAxx 3044 3649 0 0 4 4 44 44 1044 3044 3044 88 89 CNAAAA JKFAAA HHHHxx 4283 3650 1 3 3 3 83 283 283 4283 4283 166 167 TIAAAA KKFAAA OOOOxx 298 3651 0 2 8 18 98 298 298 298 298 196 197 MLAAAA LKFAAA VVVVxx 7114 3652 0 2 4 14 14 114 1114 2114 7114 28 29 QNAAAA MKFAAA AAAAxx 9664 3653 0 0 4 4 64 664 1664 4664 9664 128 129 SHAAAA NKFAAA HHHHxx 5315 3654 1 3 5 15 15 315 1315 315 5315 30 31 LWAAAA OKFAAA OOOOxx 2164 3655 0 0 4 4 64 164 164 2164 2164 128 129 GFAAAA PKFAAA VVVVxx 3390 3656 0 2 0 10 90 390 1390 3390 3390 180 181 KAAAAA QKFAAA AAAAxx 836 3657 0 0 6 16 36 836 836 836 836 72 73 EGAAAA RKFAAA HHHHxx 3316 3658 0 0 6 16 16 316 1316 3316 3316 32 33 OXAAAA SKFAAA OOOOxx 1284 3659 0 0 4 4 84 284 1284 1284 1284 168 169 KXAAAA TKFAAA VVVVxx 2497 3660 1 1 7 17 97 497 497 2497 2497 194 195 BSAAAA UKFAAA AAAAxx 1374 3661 0 2 4 14 74 374 1374 1374 1374 148 149 WAAAAA VKFAAA HHHHxx 9525 3662 1 1 5 5 25 525 1525 4525 9525 50 51 JCAAAA WKFAAA OOOOxx 2911 3663 1 3 1 11 11 911 911 2911 2911 22 23 ZHAAAA XKFAAA VVVVxx 9686 3664 0 2 6 6 86 686 1686 4686 9686 172 173 OIAAAA YKFAAA AAAAxx 584 3665 0 0 4 4 84 584 584 584 584 168 169 MWAAAA ZKFAAA HHHHxx 5653 3666 1 1 3 13 53 653 1653 653 5653 106 107 LJAAAA ALFAAA OOOOxx 4986 3667 0 2 6 6 86 986 986 4986 4986 172 173 UJAAAA BLFAAA VVVVxx 6049 3668 1 1 9 9 49 49 49 1049 6049 98 99 RYAAAA CLFAAA AAAAxx 9891 3669 1 3 1 11 91 891 1891 4891 9891 182 183 LQAAAA DLFAAA HHHHxx 8809 3670 1 1 9 9 9 809 809 3809 8809 18 19 VAAAAA ELFAAA OOOOxx 8598 3671 0 2 8 18 98 598 598 3598 8598 196 197 SSAAAA FLFAAA VVVVxx 2573 3672 1 1 3 13 73 573 573 2573 2573 146 147 ZUAAAA GLFAAA AAAAxx 6864 3673 0 0 4 4 64 864 864 1864 6864 128 129 AEAAAA HLFAAA HHHHxx 7932 3674 0 0 2 12 32 932 1932 2932 7932 64 65 CTAAAA ILFAAA OOOOxx 6605 3675 1 1 5 5 5 605 605 1605 6605 10 11 BUAAAA JLFAAA VVVVxx 9500 3676 0 0 0 0 0 500 1500 4500 9500 0 1 KBAAAA KLFAAA AAAAxx 8742 3677 0 2 2 2 42 742 742 3742 8742 84 85 GYAAAA LLFAAA HHHHxx 9815 3678 1 3 5 15 15 815 1815 4815 9815 30 31 NNAAAA MLFAAA OOOOxx 3319 3679 1 3 9 19 19 319 1319 3319 3319 38 39 RXAAAA NLFAAA VVVVxx 184 3680 0 0 4 4 84 184 184 184 184 168 169 CHAAAA OLFAAA AAAAxx 8886 3681 0 2 6 6 86 886 886 3886 8886 172 173 UDAAAA PLFAAA HHHHxx 7050 3682 0 2 0 10 50 50 1050 2050 7050 100 101 ELAAAA QLFAAA OOOOxx 9781 3683 1 1 1 1 81 781 1781 4781 9781 162 163 FMAAAA RLFAAA VVVVxx 2443 3684 1 3 3 3 43 443 443 2443 2443 86 87 ZPAAAA SLFAAA AAAAxx 1160 3685 0 0 0 0 60 160 1160 1160 1160 120 121 QSAAAA TLFAAA HHHHxx 4600 3686 0 0 0 0 0 600 600 4600 4600 0 1 YUAAAA ULFAAA OOOOxx 813 3687 1 1 3 13 13 813 813 813 813 26 27 HFAAAA VLFAAA VVVVxx 5078 3688 0 2 8 18 78 78 1078 78 5078 156 157 INAAAA WLFAAA AAAAxx 9008 3689 0 0 8 8 8 8 1008 4008 9008 16 17 MIAAAA XLFAAA HHHHxx 9016 3690 0 0 6 16 16 16 1016 4016 9016 32 33 UIAAAA YLFAAA OOOOxx 2747 3691 1 3 7 7 47 747 747 2747 2747 94 95 RBAAAA ZLFAAA VVVVxx 3106 3692 0 2 6 6 6 106 1106 3106 3106 12 13 MPAAAA AMFAAA AAAAxx 8235 3693 1 3 5 15 35 235 235 3235 8235 70 71 TEAAAA BMFAAA HHHHxx 5582 3694 0 2 2 2 82 582 1582 582 5582 164 165 SGAAAA CMFAAA OOOOxx 4334 3695 0 2 4 14 34 334 334 4334 4334 68 69 SKAAAA DMFAAA VVVVxx 1612 3696 0 0 2 12 12 612 1612 1612 1612 24 25 AKAAAA EMFAAA AAAAxx 5650 3697 0 2 0 10 50 650 1650 650 5650 100 101 IJAAAA FMFAAA HHHHxx 6086 3698 0 2 6 6 86 86 86 1086 6086 172 173 CAAAAA GMFAAA OOOOxx 9667 3699 1 3 7 7 67 667 1667 4667 9667 134 135 VHAAAA HMFAAA VVVVxx 4215 3700 1 3 5 15 15 215 215 4215 4215 30 31 DGAAAA IMFAAA AAAAxx 8553 3701 1 1 3 13 53 553 553 3553 8553 106 107 ZQAAAA JMFAAA HHHHxx 9066 3702 0 2 6 6 66 66 1066 4066 9066 132 133 SKAAAA KMFAAA OOOOxx 1092 3703 0 0 2 12 92 92 1092 1092 1092 184 185 AQAAAA LMFAAA VVVVxx 2848 3704 0 0 8 8 48 848 848 2848 2848 96 97 OFAAAA MMFAAA AAAAxx 2765 3705 1 1 5 5 65 765 765 2765 2765 130 131 JCAAAA NMFAAA HHHHxx 6513 3706 1 1 3 13 13 513 513 1513 6513 26 27 NQAAAA OMFAAA OOOOxx 6541 3707 1 1 1 1 41 541 541 1541 6541 82 83 PRAAAA PMFAAA VVVVxx 9617 3708 1 1 7 17 17 617 1617 4617 9617 34 35 XFAAAA QMFAAA AAAAxx 5870 3709 0 2 0 10 70 870 1870 870 5870 140 141 URAAAA RMFAAA HHHHxx 8811 3710 1 3 1 11 11 811 811 3811 8811 22 23 XAAAAA SMFAAA OOOOxx 4529 3711 1 1 9 9 29 529 529 4529 4529 58 59 FSAAAA TMFAAA VVVVxx 161 3712 1 1 1 1 61 161 161 161 161 122 123 FGAAAA UMFAAA AAAAxx 641 3713 1 1 1 1 41 641 641 641 641 82 83 RYAAAA VMFAAA HHHHxx 4767 3714 1 3 7 7 67 767 767 4767 4767 134 135 JBAAAA WMFAAA OOOOxx 6293 3715 1 1 3 13 93 293 293 1293 6293 186 187 BIAAAA XMFAAA VVVVxx 3816 3716 0 0 6 16 16 816 1816 3816 3816 32 33 UQAAAA YMFAAA AAAAxx 4748 3717 0 0 8 8 48 748 748 4748 4748 96 97 QAAAAA ZMFAAA HHHHxx 9924 3718 0 0 4 4 24 924 1924 4924 9924 48 49 SRAAAA ANFAAA OOOOxx 6716 3719 0 0 6 16 16 716 716 1716 6716 32 33 IYAAAA BNFAAA VVVVxx 8828 3720 0 0 8 8 28 828 828 3828 8828 56 57 OBAAAA CNFAAA AAAAxx 4967 3721 1 3 7 7 67 967 967 4967 4967 134 135 BJAAAA DNFAAA HHHHxx 9680 3722 0 0 0 0 80 680 1680 4680 9680 160 161 IIAAAA ENFAAA OOOOxx 2784 3723 0 0 4 4 84 784 784 2784 2784 168 169 CDAAAA FNFAAA VVVVxx 2882 3724 0 2 2 2 82 882 882 2882 2882 164 165 WGAAAA GNFAAA AAAAxx 3641 3725 1 1 1 1 41 641 1641 3641 3641 82 83 BKAAAA HNFAAA HHHHxx 5537 3726 1 1 7 17 37 537 1537 537 5537 74 75 ZEAAAA INFAAA OOOOxx 820 3727 0 0 0 0 20 820 820 820 820 40 41 OFAAAA JNFAAA VVVVxx 5847 3728 1 3 7 7 47 847 1847 847 5847 94 95 XQAAAA KNFAAA AAAAxx 566 3729 0 2 6 6 66 566 566 566 566 132 133 UVAAAA LNFAAA HHHHxx 2246 3730 0 2 6 6 46 246 246 2246 2246 92 93 KIAAAA MNFAAA OOOOxx 6680 3731 0 0 0 0 80 680 680 1680 6680 160 161 YWAAAA NNFAAA VVVVxx 2014 3732 0 2 4 14 14 14 14 2014 2014 28 29 MZAAAA ONFAAA AAAAxx 8355 3733 1 3 5 15 55 355 355 3355 8355 110 111 JJAAAA PNFAAA HHHHxx 1610 3734 0 2 0 10 10 610 1610 1610 1610 20 21 YJAAAA QNFAAA OOOOxx 9719 3735 1 3 9 19 19 719 1719 4719 9719 38 39 VJAAAA RNFAAA VVVVxx 8498 3736 0 2 8 18 98 498 498 3498 8498 196 197 WOAAAA SNFAAA AAAAxx 5883 3737 1 3 3 3 83 883 1883 883 5883 166 167 HSAAAA TNFAAA HHHHxx 7380 3738 0 0 0 0 80 380 1380 2380 7380 160 161 WXAAAA UNFAAA OOOOxx 8865 3739 1 1 5 5 65 865 865 3865 8865 130 131 ZCAAAA VNFAAA VVVVxx 4743 3740 1 3 3 3 43 743 743 4743 4743 86 87 LAAAAA WNFAAA AAAAxx 5086 3741 0 2 6 6 86 86 1086 86 5086 172 173 QNAAAA XNFAAA HHHHxx 2739 3742 1 3 9 19 39 739 739 2739 2739 78 79 JBAAAA YNFAAA OOOOxx 9375 3743 1 3 5 15 75 375 1375 4375 9375 150 151 PWAAAA ZNFAAA VVVVxx 7876 3744 0 0 6 16 76 876 1876 2876 7876 152 153 YQAAAA AOFAAA AAAAxx 453 3745 1 1 3 13 53 453 453 453 453 106 107 LRAAAA BOFAAA HHHHxx 6987 3746 1 3 7 7 87 987 987 1987 6987 174 175 TIAAAA COFAAA OOOOxx 2860 3747 0 0 0 0 60 860 860 2860 2860 120 121 AGAAAA DOFAAA VVVVxx 8372 3748 0 0 2 12 72 372 372 3372 8372 144 145 AKAAAA EOFAAA AAAAxx 2048 3749 0 0 8 8 48 48 48 2048 2048 96 97 UAAAAA FOFAAA HHHHxx 9231 3750 1 3 1 11 31 231 1231 4231 9231 62 63 BRAAAA GOFAAA OOOOxx 634 3751 0 2 4 14 34 634 634 634 634 68 69 KYAAAA HOFAAA VVVVxx 3998 3752 0 2 8 18 98 998 1998 3998 3998 196 197 UXAAAA IOFAAA AAAAxx 4728 3753 0 0 8 8 28 728 728 4728 4728 56 57 WZAAAA JOFAAA HHHHxx 579 3754 1 3 9 19 79 579 579 579 579 158 159 HWAAAA KOFAAA OOOOxx 815 3755 1 3 5 15 15 815 815 815 815 30 31 JFAAAA LOFAAA VVVVxx 1009 3756 1 1 9 9 9 9 1009 1009 1009 18 19 VMAAAA MOFAAA AAAAxx 6596 3757 0 0 6 16 96 596 596 1596 6596 192 193 STAAAA NOFAAA HHHHxx 2793 3758 1 1 3 13 93 793 793 2793 2793 186 187 LDAAAA OOFAAA OOOOxx 9589 3759 1 1 9 9 89 589 1589 4589 9589 178 179 VEAAAA POFAAA VVVVxx 2794 3760 0 2 4 14 94 794 794 2794 2794 188 189 MDAAAA QOFAAA AAAAxx 2551 3761 1 3 1 11 51 551 551 2551 2551 102 103 DUAAAA ROFAAA HHHHxx 1588 3762 0 0 8 8 88 588 1588 1588 1588 176 177 CJAAAA SOFAAA OOOOxx 4443 3763 1 3 3 3 43 443 443 4443 4443 86 87 XOAAAA TOFAAA VVVVxx 5009 3764 1 1 9 9 9 9 1009 9 5009 18 19 RKAAAA UOFAAA AAAAxx 4287 3765 1 3 7 7 87 287 287 4287 4287 174 175 XIAAAA VOFAAA HHHHxx 2167 3766 1 3 7 7 67 167 167 2167 2167 134 135 JFAAAA WOFAAA OOOOxx 2290 3767 0 2 0 10 90 290 290 2290 2290 180 181 CKAAAA XOFAAA VVVVxx 7225 3768 1 1 5 5 25 225 1225 2225 7225 50 51 XRAAAA YOFAAA AAAAxx 8992 3769 0 0 2 12 92 992 992 3992 8992 184 185 WHAAAA ZOFAAA HHHHxx 1540 3770 0 0 0 0 40 540 1540 1540 1540 80 81 GHAAAA APFAAA OOOOxx 2029 3771 1 1 9 9 29 29 29 2029 2029 58 59 BAAAAA BPFAAA VVVVxx 2855 3772 1 3 5 15 55 855 855 2855 2855 110 111 VFAAAA CPFAAA AAAAxx 3534 3773 0 2 4 14 34 534 1534 3534 3534 68 69 YFAAAA DPFAAA HHHHxx 8078 3774 0 2 8 18 78 78 78 3078 8078 156 157 SYAAAA EPFAAA OOOOxx 9778 3775 0 2 8 18 78 778 1778 4778 9778 156 157 CMAAAA FPFAAA VVVVxx 3543 3776 1 3 3 3 43 543 1543 3543 3543 86 87 HGAAAA GPFAAA AAAAxx 4778 3777 0 2 8 18 78 778 778 4778 4778 156 157 UBAAAA HPFAAA HHHHxx 8931 3778 1 3 1 11 31 931 931 3931 8931 62 63 NFAAAA IPFAAA OOOOxx 557 3779 1 1 7 17 57 557 557 557 557 114 115 LVAAAA JPFAAA VVVVxx 5546 3780 0 2 6 6 46 546 1546 546 5546 92 93 IFAAAA KPFAAA AAAAxx 7527 3781 1 3 7 7 27 527 1527 2527 7527 54 55 NDAAAA LPFAAA HHHHxx 5000 3782 0 0 0 0 0 0 1000 0 5000 0 1 IKAAAA MPFAAA OOOOxx 7587 3783 1 3 7 7 87 587 1587 2587 7587 174 175 VFAAAA NPFAAA VVVVxx 3014 3784 0 2 4 14 14 14 1014 3014 3014 28 29 YLAAAA OPFAAA AAAAxx 5276 3785 0 0 6 16 76 276 1276 276 5276 152 153 YUAAAA PPFAAA HHHHxx 6457 3786 1 1 7 17 57 457 457 1457 6457 114 115 JOAAAA QPFAAA OOOOxx 389 3787 1 1 9 9 89 389 389 389 389 178 179 ZOAAAA RPFAAA VVVVxx 7104 3788 0 0 4 4 4 104 1104 2104 7104 8 9 GNAAAA SPFAAA AAAAxx 9995 3789 1 3 5 15 95 995 1995 4995 9995 190 191 LUAAAA TPFAAA HHHHxx 7368 3790 0 0 8 8 68 368 1368 2368 7368 136 137 KXAAAA UPFAAA OOOOxx 3258 3791 0 2 8 18 58 258 1258 3258 3258 116 117 IVAAAA VPFAAA VVVVxx 9208 3792 0 0 8 8 8 208 1208 4208 9208 16 17 EQAAAA WPFAAA AAAAxx 2396 3793 0 0 6 16 96 396 396 2396 2396 192 193 EOAAAA XPFAAA HHHHxx 1715 3794 1 3 5 15 15 715 1715 1715 1715 30 31 ZNAAAA YPFAAA OOOOxx 1240 3795 0 0 0 0 40 240 1240 1240 1240 80 81 SVAAAA ZPFAAA VVVVxx 1952 3796 0 0 2 12 52 952 1952 1952 1952 104 105 CXAAAA AQFAAA AAAAxx 4403 3797 1 3 3 3 3 403 403 4403 4403 6 7 JNAAAA BQFAAA HHHHxx 6333 3798 1 1 3 13 33 333 333 1333 6333 66 67 PJAAAA CQFAAA OOOOxx 2492 3799 0 0 2 12 92 492 492 2492 2492 184 185 WRAAAA DQFAAA VVVVxx 6543 3800 1 3 3 3 43 543 543 1543 6543 86 87 RRAAAA EQFAAA AAAAxx 5548 3801 0 0 8 8 48 548 1548 548 5548 96 97 KFAAAA FQFAAA HHHHxx 3458 3802 0 2 8 18 58 458 1458 3458 3458 116 117 ADAAAA GQFAAA OOOOxx 2588 3803 0 0 8 8 88 588 588 2588 2588 176 177 OVAAAA HQFAAA VVVVxx 1364 3804 0 0 4 4 64 364 1364 1364 1364 128 129 MAAAAA IQFAAA AAAAxx 9856 3805 0 0 6 16 56 856 1856 4856 9856 112 113 CPAAAA JQFAAA HHHHxx 4964 3806 0 0 4 4 64 964 964 4964 4964 128 129 YIAAAA KQFAAA OOOOxx 773 3807 1 1 3 13 73 773 773 773 773 146 147 TDAAAA LQFAAA VVVVxx 6402 3808 0 2 2 2 2 402 402 1402 6402 4 5 GMAAAA MQFAAA AAAAxx 7213 3809 1 1 3 13 13 213 1213 2213 7213 26 27 LRAAAA NQFAAA HHHHxx 3385 3810 1 1 5 5 85 385 1385 3385 3385 170 171 FAAAAA OQFAAA OOOOxx 6005 3811 1 1 5 5 5 5 5 1005 6005 10 11 ZWAAAA PQFAAA VVVVxx 9346 3812 0 2 6 6 46 346 1346 4346 9346 92 93 MVAAAA QQFAAA AAAAxx 1831 3813 1 3 1 11 31 831 1831 1831 1831 62 63 LSAAAA RQFAAA HHHHxx 5406 3814 0 2 6 6 6 406 1406 406 5406 12 13 YZAAAA SQFAAA OOOOxx 2154 3815 0 2 4 14 54 154 154 2154 2154 108 109 WEAAAA TQFAAA VVVVxx 3721 3816 1 1 1 1 21 721 1721 3721 3721 42 43 DNAAAA UQFAAA AAAAxx 2889 3817 1 1 9 9 89 889 889 2889 2889 178 179 DHAAAA VQFAAA HHHHxx 4410 3818 0 2 0 10 10 410 410 4410 4410 20 21 QNAAAA WQFAAA OOOOxx 7102 3819 0 2 2 2 2 102 1102 2102 7102 4 5 ENAAAA XQFAAA VVVVxx 4057 3820 1 1 7 17 57 57 57 4057 4057 114 115 BAAAAA YQFAAA AAAAxx 9780 3821 0 0 0 0 80 780 1780 4780 9780 160 161 EMAAAA ZQFAAA HHHHxx 9481 3822 1 1 1 1 81 481 1481 4481 9481 162 163 RAAAAA ARFAAA OOOOxx 2366 3823 0 2 6 6 66 366 366 2366 2366 132 133 ANAAAA BRFAAA VVVVxx 2708 3824 0 0 8 8 8 708 708 2708 2708 16 17 EAAAAA CRFAAA AAAAxx 7399 3825 1 3 9 19 99 399 1399 2399 7399 198 199 PYAAAA DRFAAA HHHHxx 5234 3826 0 2 4 14 34 234 1234 234 5234 68 69 ITAAAA ERFAAA OOOOxx 1843 3827 1 3 3 3 43 843 1843 1843 1843 86 87 XSAAAA FRFAAA VVVVxx 1006 3828 0 2 6 6 6 6 1006 1006 1006 12 13 SMAAAA GRFAAA AAAAxx 7696 3829 0 0 6 16 96 696 1696 2696 7696 192 193 AKAAAA HRFAAA HHHHxx 6411 3830 1 3 1 11 11 411 411 1411 6411 22 23 PMAAAA IRFAAA OOOOxx 3913 3831 1 1 3 13 13 913 1913 3913 3913 26 27 NUAAAA JRFAAA VVVVxx 2538 3832 0 2 8 18 38 538 538 2538 2538 76 77 QTAAAA KRFAAA AAAAxx 3019 3833 1 3 9 19 19 19 1019 3019 3019 38 39 DMAAAA LRFAAA HHHHxx 107 3834 1 3 7 7 7 107 107 107 107 14 15 DEAAAA MRFAAA OOOOxx 427 3835 1 3 7 7 27 427 427 427 427 54 55 LQAAAA NRFAAA VVVVxx 9849 3836 1 1 9 9 49 849 1849 4849 9849 98 99 VOAAAA ORFAAA AAAAxx 4195 3837 1 3 5 15 95 195 195 4195 4195 190 191 JFAAAA PRFAAA HHHHxx 9215 3838 1 3 5 15 15 215 1215 4215 9215 30 31 LQAAAA QRFAAA OOOOxx 3165 3839 1 1 5 5 65 165 1165 3165 3165 130 131 TRAAAA RRFAAA VVVVxx 3280 3840 0 0 0 0 80 280 1280 3280 3280 160 161 EWAAAA SRFAAA AAAAxx 4477 3841 1 1 7 17 77 477 477 4477 4477 154 155 FQAAAA TRFAAA HHHHxx 5885 3842 1 1 5 5 85 885 1885 885 5885 170 171 JSAAAA URFAAA OOOOxx 3311 3843 1 3 1 11 11 311 1311 3311 3311 22 23 JXAAAA VRFAAA VVVVxx 6453 3844 1 1 3 13 53 453 453 1453 6453 106 107 FOAAAA WRFAAA AAAAxx 8527 3845 1 3 7 7 27 527 527 3527 8527 54 55 ZPAAAA XRFAAA HHHHxx 1921 3846 1 1 1 1 21 921 1921 1921 1921 42 43 XVAAAA YRFAAA OOOOxx 2427 3847 1 3 7 7 27 427 427 2427 2427 54 55 JPAAAA ZRFAAA VVVVxx 3691 3848 1 3 1 11 91 691 1691 3691 3691 182 183 ZLAAAA ASFAAA AAAAxx 3882 3849 0 2 2 2 82 882 1882 3882 3882 164 165 ITAAAA BSFAAA HHHHxx 562 3850 0 2 2 2 62 562 562 562 562 124 125 QVAAAA CSFAAA OOOOxx 377 3851 1 1 7 17 77 377 377 377 377 154 155 NOAAAA DSFAAA VVVVxx 1497 3852 1 1 7 17 97 497 1497 1497 1497 194 195 PFAAAA ESFAAA AAAAxx 4453 3853 1 1 3 13 53 453 453 4453 4453 106 107 HPAAAA FSFAAA HHHHxx 4678 3854 0 2 8 18 78 678 678 4678 4678 156 157 YXAAAA GSFAAA OOOOxx 2234 3855 0 2 4 14 34 234 234 2234 2234 68 69 YHAAAA HSFAAA VVVVxx 1073 3856 1 1 3 13 73 73 1073 1073 1073 146 147 HPAAAA ISFAAA AAAAxx 6479 3857 1 3 9 19 79 479 479 1479 6479 158 159 FPAAAA JSFAAA HHHHxx 5665 3858 1 1 5 5 65 665 1665 665 5665 130 131 XJAAAA KSFAAA OOOOxx 586 3859 0 2 6 6 86 586 586 586 586 172 173 OWAAAA LSFAAA VVVVxx 1584 3860 0 0 4 4 84 584 1584 1584 1584 168 169 YIAAAA MSFAAA AAAAxx 2574 3861 0 2 4 14 74 574 574 2574 2574 148 149 AVAAAA NSFAAA HHHHxx 9833 3862 1 1 3 13 33 833 1833 4833 9833 66 67 FOAAAA OSFAAA OOOOxx 6726 3863 0 2 6 6 26 726 726 1726 6726 52 53 SYAAAA PSFAAA VVVVxx 8497 3864 1 1 7 17 97 497 497 3497 8497 194 195 VOAAAA QSFAAA AAAAxx 2914 3865 0 2 4 14 14 914 914 2914 2914 28 29 CIAAAA RSFAAA HHHHxx 8586 3866 0 2 6 6 86 586 586 3586 8586 172 173 GSAAAA SSFAAA OOOOxx 6973 3867 1 1 3 13 73 973 973 1973 6973 146 147 FIAAAA TSFAAA VVVVxx 1322 3868 0 2 2 2 22 322 1322 1322 1322 44 45 WYAAAA USFAAA AAAAxx 5242 3869 0 2 2 2 42 242 1242 242 5242 84 85 QTAAAA VSFAAA HHHHxx 5581 3870 1 1 1 1 81 581 1581 581 5581 162 163 RGAAAA WSFAAA OOOOxx 1365 3871 1 1 5 5 65 365 1365 1365 1365 130 131 NAAAAA XSFAAA VVVVxx 2818 3872 0 2 8 18 18 818 818 2818 2818 36 37 KEAAAA YSFAAA AAAAxx 3758 3873 0 2 8 18 58 758 1758 3758 3758 116 117 OOAAAA ZSFAAA HHHHxx 2665 3874 1 1 5 5 65 665 665 2665 2665 130 131 NYAAAA ATFAAA OOOOxx 9823 3875 1 3 3 3 23 823 1823 4823 9823 46 47 VNAAAA BTFAAA VVVVxx 7057 3876 1 1 7 17 57 57 1057 2057 7057 114 115 LLAAAA CTFAAA AAAAxx 543 3877 1 3 3 3 43 543 543 543 543 86 87 XUAAAA DTFAAA HHHHxx 4008 3878 0 0 8 8 8 8 8 4008 4008 16 17 EYAAAA ETFAAA OOOOxx 4397 3879 1 1 7 17 97 397 397 4397 4397 194 195 DNAAAA FTFAAA VVVVxx 8533 3880 1 1 3 13 33 533 533 3533 8533 66 67 FQAAAA GTFAAA AAAAxx 9728 3881 0 0 8 8 28 728 1728 4728 9728 56 57 EKAAAA HTFAAA HHHHxx 5198 3882 0 2 8 18 98 198 1198 198 5198 196 197 YRAAAA ITFAAA OOOOxx 5036 3883 0 0 6 16 36 36 1036 36 5036 72 73 SLAAAA JTFAAA VVVVxx 4394 3884 0 2 4 14 94 394 394 4394 4394 188 189 ANAAAA KTFAAA AAAAxx 9633 3885 1 1 3 13 33 633 1633 4633 9633 66 67 NGAAAA LTFAAA HHHHxx 3339 3886 1 3 9 19 39 339 1339 3339 3339 78 79 LYAAAA MTFAAA OOOOxx 9529 3887 1 1 9 9 29 529 1529 4529 9529 58 59 NCAAAA NTFAAA VVVVxx 4780 3888 0 0 0 0 80 780 780 4780 4780 160 161 WBAAAA OTFAAA AAAAxx 4862 3889 0 2 2 2 62 862 862 4862 4862 124 125 AFAAAA PTFAAA HHHHxx 8152 3890 0 0 2 12 52 152 152 3152 8152 104 105 OBAAAA QTFAAA OOOOxx 9330 3891 0 2 0 10 30 330 1330 4330 9330 60 61 WUAAAA RTFAAA VVVVxx 4362 3892 0 2 2 2 62 362 362 4362 4362 124 125 ULAAAA STFAAA AAAAxx 4688 3893 0 0 8 8 88 688 688 4688 4688 176 177 IYAAAA TTFAAA HHHHxx 1903 3894 1 3 3 3 3 903 1903 1903 1903 6 7 FVAAAA UTFAAA OOOOxx 9027 3895 1 3 7 7 27 27 1027 4027 9027 54 55 FJAAAA VTFAAA VVVVxx 5385 3896 1 1 5 5 85 385 1385 385 5385 170 171 DZAAAA WTFAAA AAAAxx 9854 3897 0 2 4 14 54 854 1854 4854 9854 108 109 APAAAA XTFAAA HHHHxx 9033 3898 1 1 3 13 33 33 1033 4033 9033 66 67 LJAAAA YTFAAA OOOOxx 3185 3899 1 1 5 5 85 185 1185 3185 3185 170 171 NSAAAA ZTFAAA VVVVxx 2618 3900 0 2 8 18 18 618 618 2618 2618 36 37 SWAAAA AUFAAA AAAAxx 371 3901 1 3 1 11 71 371 371 371 371 142 143 HOAAAA BUFAAA HHHHxx 3697 3902 1 1 7 17 97 697 1697 3697 3697 194 195 FMAAAA CUFAAA OOOOxx 1682 3903 0 2 2 2 82 682 1682 1682 1682 164 165 SMAAAA DUFAAA VVVVxx 3333 3904 1 1 3 13 33 333 1333 3333 3333 66 67 FYAAAA EUFAAA AAAAxx 1722 3905 0 2 2 2 22 722 1722 1722 1722 44 45 GOAAAA FUFAAA HHHHxx 2009 3906 1 1 9 9 9 9 9 2009 2009 18 19 HZAAAA GUFAAA OOOOxx 3517 3907 1 1 7 17 17 517 1517 3517 3517 34 35 HFAAAA HUFAAA VVVVxx 7640 3908 0 0 0 0 40 640 1640 2640 7640 80 81 WHAAAA IUFAAA AAAAxx 259 3909 1 3 9 19 59 259 259 259 259 118 119 ZJAAAA JUFAAA HHHHxx 1400 3910 0 0 0 0 0 400 1400 1400 1400 0 1 WBAAAA KUFAAA OOOOxx 6663 3911 1 3 3 3 63 663 663 1663 6663 126 127 HWAAAA LUFAAA VVVVxx 1576 3912 0 0 6 16 76 576 1576 1576 1576 152 153 QIAAAA MUFAAA AAAAxx 8843 3913 1 3 3 3 43 843 843 3843 8843 86 87 DCAAAA NUFAAA HHHHxx 9474 3914 0 2 4 14 74 474 1474 4474 9474 148 149 KAAAAA OUFAAA OOOOxx 1597 3915 1 1 7 17 97 597 1597 1597 1597 194 195 LJAAAA PUFAAA VVVVxx 1143 3916 1 3 3 3 43 143 1143 1143 1143 86 87 ZRAAAA QUFAAA AAAAxx 4162 3917 0 2 2 2 62 162 162 4162 4162 124 125 CEAAAA RUFAAA HHHHxx 1301 3918 1 1 1 1 1 301 1301 1301 1301 2 3 BYAAAA SUFAAA OOOOxx 2935 3919 1 3 5 15 35 935 935 2935 2935 70 71 XIAAAA TUFAAA VVVVxx 886 3920 0 2 6 6 86 886 886 886 886 172 173 CIAAAA UUFAAA AAAAxx 1661 3921 1 1 1 1 61 661 1661 1661 1661 122 123 XLAAAA VUFAAA HHHHxx 1026 3922 0 2 6 6 26 26 1026 1026 1026 52 53 MNAAAA WUFAAA OOOOxx 7034 3923 0 2 4 14 34 34 1034 2034 7034 68 69 OKAAAA XUFAAA VVVVxx 2305 3924 1 1 5 5 5 305 305 2305 2305 10 11 RKAAAA YUFAAA AAAAxx 1725 3925 1 1 5 5 25 725 1725 1725 1725 50 51 JOAAAA ZUFAAA HHHHxx 909 3926 1 1 9 9 9 909 909 909 909 18 19 ZIAAAA AVFAAA OOOOxx 9906 3927 0 2 6 6 6 906 1906 4906 9906 12 13 ARAAAA BVFAAA VVVVxx 3309 3928 1 1 9 9 9 309 1309 3309 3309 18 19 HXAAAA CVFAAA AAAAxx 515 3929 1 3 5 15 15 515 515 515 515 30 31 VTAAAA DVFAAA HHHHxx 932 3930 0 0 2 12 32 932 932 932 932 64 65 WJAAAA EVFAAA OOOOxx 8144 3931 0 0 4 4 44 144 144 3144 8144 88 89 GBAAAA FVFAAA VVVVxx 5592 3932 0 0 2 12 92 592 1592 592 5592 184 185 CHAAAA GVFAAA AAAAxx 4003 3933 1 3 3 3 3 3 3 4003 4003 6 7 ZXAAAA HVFAAA HHHHxx 9566 3934 0 2 6 6 66 566 1566 4566 9566 132 133 YDAAAA IVFAAA OOOOxx 4556 3935 0 0 6 16 56 556 556 4556 4556 112 113 GTAAAA JVFAAA VVVVxx 268 3936 0 0 8 8 68 268 268 268 268 136 137 IKAAAA KVFAAA AAAAxx 8107 3937 1 3 7 7 7 107 107 3107 8107 14 15 VZAAAA LVFAAA HHHHxx 5816 3938 0 0 6 16 16 816 1816 816 5816 32 33 SPAAAA MVFAAA OOOOxx 8597 3939 1 1 7 17 97 597 597 3597 8597 194 195 RSAAAA NVFAAA VVVVxx 9611 3940 1 3 1 11 11 611 1611 4611 9611 22 23 RFAAAA OVFAAA AAAAxx 8070 3941 0 2 0 10 70 70 70 3070 8070 140 141 KYAAAA PVFAAA HHHHxx 6040 3942 0 0 0 0 40 40 40 1040 6040 80 81 IYAAAA QVFAAA OOOOxx 3184 3943 0 0 4 4 84 184 1184 3184 3184 168 169 MSAAAA RVFAAA VVVVxx 9656 3944 0 0 6 16 56 656 1656 4656 9656 112 113 KHAAAA SVFAAA AAAAxx 1577 3945 1 1 7 17 77 577 1577 1577 1577 154 155 RIAAAA TVFAAA HHHHxx 1805 3946 1 1 5 5 5 805 1805 1805 1805 10 11 LRAAAA UVFAAA OOOOxx 8268 3947 0 0 8 8 68 268 268 3268 8268 136 137 AGAAAA VVFAAA VVVVxx 3489 3948 1 1 9 9 89 489 1489 3489 3489 178 179 FEAAAA WVFAAA AAAAxx 4564 3949 0 0 4 4 64 564 564 4564 4564 128 129 OTAAAA XVFAAA HHHHxx 4006 3950 0 2 6 6 6 6 6 4006 4006 12 13 CYAAAA YVFAAA OOOOxx 8466 3951 0 2 6 6 66 466 466 3466 8466 132 133 QNAAAA ZVFAAA VVVVxx 938 3952 0 2 8 18 38 938 938 938 938 76 77 CKAAAA AWFAAA AAAAxx 5944 3953 0 0 4 4 44 944 1944 944 5944 88 89 QUAAAA BWFAAA HHHHxx 8363 3954 1 3 3 3 63 363 363 3363 8363 126 127 RJAAAA CWFAAA OOOOxx 5348 3955 0 0 8 8 48 348 1348 348 5348 96 97 SXAAAA DWFAAA VVVVxx 71 3956 1 3 1 11 71 71 71 71 71 142 143 TCAAAA EWFAAA AAAAxx 3620 3957 0 0 0 0 20 620 1620 3620 3620 40 41 GJAAAA FWFAAA HHHHxx 3230 3958 0 2 0 10 30 230 1230 3230 3230 60 61 GUAAAA GWFAAA OOOOxx 6132 3959 0 0 2 12 32 132 132 1132 6132 64 65 WBAAAA HWFAAA VVVVxx 6143 3960 1 3 3 3 43 143 143 1143 6143 86 87 HCAAAA IWFAAA AAAAxx 8781 3961 1 1 1 1 81 781 781 3781 8781 162 163 TZAAAA JWFAAA HHHHxx 5522 3962 0 2 2 2 22 522 1522 522 5522 44 45 KEAAAA KWFAAA OOOOxx 6320 3963 0 0 0 0 20 320 320 1320 6320 40 41 CJAAAA LWFAAA VVVVxx 3923 3964 1 3 3 3 23 923 1923 3923 3923 46 47 XUAAAA MWFAAA AAAAxx 2207 3965 1 3 7 7 7 207 207 2207 2207 14 15 XGAAAA NWFAAA HHHHxx 966 3966 0 2 6 6 66 966 966 966 966 132 133 ELAAAA OWFAAA OOOOxx 9020 3967 0 0 0 0 20 20 1020 4020 9020 40 41 YIAAAA PWFAAA VVVVxx 4616 3968 0 0 6 16 16 616 616 4616 4616 32 33 OVAAAA QWFAAA AAAAxx 8289 3969 1 1 9 9 89 289 289 3289 8289 178 179 VGAAAA RWFAAA HHHHxx 5796 3970 0 0 6 16 96 796 1796 796 5796 192 193 YOAAAA SWFAAA OOOOxx 9259 3971 1 3 9 19 59 259 1259 4259 9259 118 119 DSAAAA TWFAAA VVVVxx 3710 3972 0 2 0 10 10 710 1710 3710 3710 20 21 SMAAAA UWFAAA AAAAxx 251 3973 1 3 1 11 51 251 251 251 251 102 103 RJAAAA VWFAAA HHHHxx 7669 3974 1 1 9 9 69 669 1669 2669 7669 138 139 ZIAAAA WWFAAA OOOOxx 6304 3975 0 0 4 4 4 304 304 1304 6304 8 9 MIAAAA XWFAAA VVVVxx 6454 3976 0 2 4 14 54 454 454 1454 6454 108 109 GOAAAA YWFAAA AAAAxx 1489 3977 1 1 9 9 89 489 1489 1489 1489 178 179 HFAAAA ZWFAAA HHHHxx 715 3978 1 3 5 15 15 715 715 715 715 30 31 NBAAAA AXFAAA OOOOxx 4319 3979 1 3 9 19 19 319 319 4319 4319 38 39 DKAAAA BXFAAA VVVVxx 7112 3980 0 0 2 12 12 112 1112 2112 7112 24 25 ONAAAA CXFAAA AAAAxx 3726 3981 0 2 6 6 26 726 1726 3726 3726 52 53 INAAAA DXFAAA HHHHxx 7727 3982 1 3 7 7 27 727 1727 2727 7727 54 55 FLAAAA EXFAAA OOOOxx 8387 3983 1 3 7 7 87 387 387 3387 8387 174 175 PKAAAA FXFAAA VVVVxx 6555 3984 1 3 5 15 55 555 555 1555 6555 110 111 DSAAAA GXFAAA AAAAxx 1148 3985 0 0 8 8 48 148 1148 1148 1148 96 97 ESAAAA HXFAAA HHHHxx 9000 3986 0 0 0 0 0 0 1000 4000 9000 0 1 EIAAAA IXFAAA OOOOxx 5278 3987 0 2 8 18 78 278 1278 278 5278 156 157 AVAAAA JXFAAA VVVVxx 2388 3988 0 0 8 8 88 388 388 2388 2388 176 177 WNAAAA KXFAAA AAAAxx 7984 3989 0 0 4 4 84 984 1984 2984 7984 168 169 CVAAAA LXFAAA HHHHxx 881 3990 1 1 1 1 81 881 881 881 881 162 163 XHAAAA MXFAAA OOOOxx 6830 3991 0 2 0 10 30 830 830 1830 6830 60 61 SCAAAA NXFAAA VVVVxx 7056 3992 0 0 6 16 56 56 1056 2056 7056 112 113 KLAAAA OXFAAA AAAAxx 7581 3993 1 1 1 1 81 581 1581 2581 7581 162 163 PFAAAA PXFAAA HHHHxx 5214 3994 0 2 4 14 14 214 1214 214 5214 28 29 OSAAAA QXFAAA OOOOxx 2505 3995 1 1 5 5 5 505 505 2505 2505 10 11 JSAAAA RXFAAA VVVVxx 5112 3996 0 0 2 12 12 112 1112 112 5112 24 25 QOAAAA SXFAAA AAAAxx 9884 3997 0 0 4 4 84 884 1884 4884 9884 168 169 EQAAAA TXFAAA HHHHxx 8040 3998 0 0 0 0 40 40 40 3040 8040 80 81 GXAAAA UXFAAA OOOOxx 7033 3999 1 1 3 13 33 33 1033 2033 7033 66 67 NKAAAA VXFAAA VVVVxx 9343 4000 1 3 3 3 43 343 1343 4343 9343 86 87 JVAAAA WXFAAA AAAAxx 2931 4001 1 3 1 11 31 931 931 2931 2931 62 63 TIAAAA XXFAAA HHHHxx 9024 4002 0 0 4 4 24 24 1024 4024 9024 48 49 CJAAAA YXFAAA OOOOxx 6485 4003 1 1 5 5 85 485 485 1485 6485 170 171 LPAAAA ZXFAAA VVVVxx 3465 4004 1 1 5 5 65 465 1465 3465 3465 130 131 HDAAAA AYFAAA AAAAxx 3357 4005 1 1 7 17 57 357 1357 3357 3357 114 115 DZAAAA BYFAAA HHHHxx 2929 4006 1 1 9 9 29 929 929 2929 2929 58 59 RIAAAA CYFAAA OOOOxx 3086 4007 0 2 6 6 86 86 1086 3086 3086 172 173 SOAAAA DYFAAA VVVVxx 8897 4008 1 1 7 17 97 897 897 3897 8897 194 195 FEAAAA EYFAAA AAAAxx 9688 4009 0 0 8 8 88 688 1688 4688 9688 176 177 QIAAAA FYFAAA HHHHxx 6522 4010 0 2 2 2 22 522 522 1522 6522 44 45 WQAAAA GYFAAA OOOOxx 3241 4011 1 1 1 1 41 241 1241 3241 3241 82 83 RUAAAA HYFAAA VVVVxx 8770 4012 0 2 0 10 70 770 770 3770 8770 140 141 IZAAAA IYFAAA AAAAxx 2884 4013 0 0 4 4 84 884 884 2884 2884 168 169 YGAAAA JYFAAA HHHHxx 9579 4014 1 3 9 19 79 579 1579 4579 9579 158 159 LEAAAA KYFAAA OOOOxx 3125 4015 1 1 5 5 25 125 1125 3125 3125 50 51 FQAAAA LYFAAA VVVVxx 4604 4016 0 0 4 4 4 604 604 4604 4604 8 9 CVAAAA MYFAAA AAAAxx 2682 4017 0 2 2 2 82 682 682 2682 2682 164 165 EZAAAA NYFAAA HHHHxx 254 4018 0 2 4 14 54 254 254 254 254 108 109 UJAAAA OYFAAA OOOOxx 6569 4019 1 1 9 9 69 569 569 1569 6569 138 139 RSAAAA PYFAAA VVVVxx 2686 4020 0 2 6 6 86 686 686 2686 2686 172 173 IZAAAA QYFAAA AAAAxx 2123 4021 1 3 3 3 23 123 123 2123 2123 46 47 RDAAAA RYFAAA HHHHxx 1745 4022 1 1 5 5 45 745 1745 1745 1745 90 91 DPAAAA SYFAAA OOOOxx 247 4023 1 3 7 7 47 247 247 247 247 94 95 NJAAAA TYFAAA VVVVxx 5800 4024 0 0 0 0 0 800 1800 800 5800 0 1 CPAAAA UYFAAA AAAAxx 1121 4025 1 1 1 1 21 121 1121 1121 1121 42 43 DRAAAA VYFAAA HHHHxx 8893 4026 1 1 3 13 93 893 893 3893 8893 186 187 BEAAAA WYFAAA OOOOxx 7819 4027 1 3 9 19 19 819 1819 2819 7819 38 39 TOAAAA XYFAAA VVVVxx 1339 4028 1 3 9 19 39 339 1339 1339 1339 78 79 NZAAAA YYFAAA AAAAxx 5680 4029 0 0 0 0 80 680 1680 680 5680 160 161 MKAAAA ZYFAAA HHHHxx 5093 4030 1 1 3 13 93 93 1093 93 5093 186 187 XNAAAA AZFAAA OOOOxx 3508 4031 0 0 8 8 8 508 1508 3508 3508 16 17 YEAAAA BZFAAA VVVVxx 933 4032 1 1 3 13 33 933 933 933 933 66 67 XJAAAA CZFAAA AAAAxx 1106 4033 0 2 6 6 6 106 1106 1106 1106 12 13 OQAAAA DZFAAA HHHHxx 4386 4034 0 2 6 6 86 386 386 4386 4386 172 173 SMAAAA EZFAAA OOOOxx 5895 4035 1 3 5 15 95 895 1895 895 5895 190 191 TSAAAA FZFAAA VVVVxx 2980 4036 0 0 0 0 80 980 980 2980 2980 160 161 QKAAAA GZFAAA AAAAxx 4400 4037 0 0 0 0 0 400 400 4400 4400 0 1 GNAAAA HZFAAA HHHHxx 7433 4038 1 1 3 13 33 433 1433 2433 7433 66 67 XZAAAA IZFAAA OOOOxx 6110 4039 0 2 0 10 10 110 110 1110 6110 20 21 ABAAAA JZFAAA VVVVxx 867 4040 1 3 7 7 67 867 867 867 867 134 135 JHAAAA KZFAAA AAAAxx 5292 4041 0 0 2 12 92 292 1292 292 5292 184 185 OVAAAA LZFAAA HHHHxx 3926 4042 0 2 6 6 26 926 1926 3926 3926 52 53 AVAAAA MZFAAA OOOOxx 1107 4043 1 3 7 7 7 107 1107 1107 1107 14 15 PQAAAA NZFAAA VVVVxx 7355 4044 1 3 5 15 55 355 1355 2355 7355 110 111 XWAAAA OZFAAA AAAAxx 4689 4045 1 1 9 9 89 689 689 4689 4689 178 179 JYAAAA PZFAAA HHHHxx 4872 4046 0 0 2 12 72 872 872 4872 4872 144 145 KFAAAA QZFAAA OOOOxx 7821 4047 1 1 1 1 21 821 1821 2821 7821 42 43 VOAAAA RZFAAA VVVVxx 7277 4048 1 1 7 17 77 277 1277 2277 7277 154 155 XTAAAA SZFAAA AAAAxx 3268 4049 0 0 8 8 68 268 1268 3268 3268 136 137 SVAAAA TZFAAA HHHHxx 8877 4050 1 1 7 17 77 877 877 3877 8877 154 155 LDAAAA UZFAAA OOOOxx 343 4051 1 3 3 3 43 343 343 343 343 86 87 FNAAAA VZFAAA VVVVxx 621 4052 1 1 1 1 21 621 621 621 621 42 43 XXAAAA WZFAAA AAAAxx 5429 4053 1 1 9 9 29 429 1429 429 5429 58 59 VAAAAA XZFAAA HHHHxx 392 4054 0 0 2 12 92 392 392 392 392 184 185 CPAAAA YZFAAA OOOOxx 6004 4055 0 0 4 4 4 4 4 1004 6004 8 9 YWAAAA ZZFAAA VVVVxx 6377 4056 1 1 7 17 77 377 377 1377 6377 154 155 HLAAAA AAGAAA AAAAxx 3037 4057 1 1 7 17 37 37 1037 3037 3037 74 75 VMAAAA BAGAAA HHHHxx 3514 4058 0 2 4 14 14 514 1514 3514 3514 28 29 EFAAAA CAGAAA OOOOxx 8740 4059 0 0 0 0 40 740 740 3740 8740 80 81 EYAAAA DAGAAA VVVVxx 3877 4060 1 1 7 17 77 877 1877 3877 3877 154 155 DTAAAA EAGAAA AAAAxx 5731 4061 1 3 1 11 31 731 1731 731 5731 62 63 LMAAAA FAGAAA HHHHxx 6407 4062 1 3 7 7 7 407 407 1407 6407 14 15 LMAAAA GAGAAA OOOOxx 2044 4063 0 0 4 4 44 44 44 2044 2044 88 89 QAAAAA HAGAAA VVVVxx 7362 4064 0 2 2 2 62 362 1362 2362 7362 124 125 EXAAAA IAGAAA AAAAxx 5458 4065 0 2 8 18 58 458 1458 458 5458 116 117 YBAAAA JAGAAA HHHHxx 6437 4066 1 1 7 17 37 437 437 1437 6437 74 75 PNAAAA KAGAAA OOOOxx 1051 4067 1 3 1 11 51 51 1051 1051 1051 102 103 LOAAAA LAGAAA VVVVxx 1203 4068 1 3 3 3 3 203 1203 1203 1203 6 7 HUAAAA MAGAAA AAAAxx 2176 4069 0 0 6 16 76 176 176 2176 2176 152 153 SFAAAA NAGAAA HHHHxx 8997 4070 1 1 7 17 97 997 997 3997 8997 194 195 BIAAAA OAGAAA OOOOxx 6378 4071 0 2 8 18 78 378 378 1378 6378 156 157 ILAAAA PAGAAA VVVVxx 6006 4072 0 2 6 6 6 6 6 1006 6006 12 13 AXAAAA QAGAAA AAAAxx 2308 4073 0 0 8 8 8 308 308 2308 2308 16 17 UKAAAA RAGAAA HHHHxx 625 4074 1 1 5 5 25 625 625 625 625 50 51 BYAAAA SAGAAA OOOOxx 7298 4075 0 2 8 18 98 298 1298 2298 7298 196 197 SUAAAA TAGAAA VVVVxx 5575 4076 1 3 5 15 75 575 1575 575 5575 150 151 LGAAAA UAGAAA AAAAxx 3565 4077 1 1 5 5 65 565 1565 3565 3565 130 131 DHAAAA VAGAAA HHHHxx 47 4078 1 3 7 7 47 47 47 47 47 94 95 VBAAAA WAGAAA OOOOxx 2413 4079 1 1 3 13 13 413 413 2413 2413 26 27 VOAAAA XAGAAA VVVVxx 2153 4080 1 1 3 13 53 153 153 2153 2153 106 107 VEAAAA YAGAAA AAAAxx 752 4081 0 0 2 12 52 752 752 752 752 104 105 YCAAAA ZAGAAA HHHHxx 4095 4082 1 3 5 15 95 95 95 4095 4095 190 191 NBAAAA ABGAAA OOOOxx 2518 4083 0 2 8 18 18 518 518 2518 2518 36 37 WSAAAA BBGAAA VVVVxx 3681 4084 1 1 1 1 81 681 1681 3681 3681 162 163 PLAAAA CBGAAA AAAAxx 4213 4085 1 1 3 13 13 213 213 4213 4213 26 27 BGAAAA DBGAAA HHHHxx 2615 4086 1 3 5 15 15 615 615 2615 2615 30 31 PWAAAA EBGAAA OOOOxx 1471 4087 1 3 1 11 71 471 1471 1471 1471 142 143 PEAAAA FBGAAA VVVVxx 7315 4088 1 3 5 15 15 315 1315 2315 7315 30 31 JVAAAA GBGAAA AAAAxx 6013 4089 1 1 3 13 13 13 13 1013 6013 26 27 HXAAAA HBGAAA HHHHxx 3077 4090 1 1 7 17 77 77 1077 3077 3077 154 155 JOAAAA IBGAAA OOOOxx 2190 4091 0 2 0 10 90 190 190 2190 2190 180 181 GGAAAA JBGAAA VVVVxx 528 4092 0 0 8 8 28 528 528 528 528 56 57 IUAAAA KBGAAA AAAAxx 9508 4093 0 0 8 8 8 508 1508 4508 9508 16 17 SBAAAA LBGAAA HHHHxx 2473 4094 1 1 3 13 73 473 473 2473 2473 146 147 DRAAAA MBGAAA OOOOxx 167 4095 1 3 7 7 67 167 167 167 167 134 135 LGAAAA NBGAAA VVVVxx 8448 4096 0 0 8 8 48 448 448 3448 8448 96 97 YMAAAA OBGAAA AAAAxx 7538 4097 0 2 8 18 38 538 1538 2538 7538 76 77 YDAAAA PBGAAA HHHHxx 7638 4098 0 2 8 18 38 638 1638 2638 7638 76 77 UHAAAA QBGAAA OOOOxx 4328 4099 0 0 8 8 28 328 328 4328 4328 56 57 MKAAAA RBGAAA VVVVxx 3812 4100 0 0 2 12 12 812 1812 3812 3812 24 25 QQAAAA SBGAAA AAAAxx 2879 4101 1 3 9 19 79 879 879 2879 2879 158 159 TGAAAA TBGAAA HHHHxx 4741 4102 1 1 1 1 41 741 741 4741 4741 82 83 JAAAAA UBGAAA OOOOxx 9155 4103 1 3 5 15 55 155 1155 4155 9155 110 111 DOAAAA VBGAAA VVVVxx 5151 4104 1 3 1 11 51 151 1151 151 5151 102 103 DQAAAA WBGAAA AAAAxx 5591 4105 1 3 1 11 91 591 1591 591 5591 182 183 BHAAAA XBGAAA HHHHxx 1034 4106 0 2 4 14 34 34 1034 1034 1034 68 69 UNAAAA YBGAAA OOOOxx 765 4107 1 1 5 5 65 765 765 765 765 130 131 LDAAAA ZBGAAA VVVVxx 2664 4108 0 0 4 4 64 664 664 2664 2664 128 129 MYAAAA ACGAAA AAAAxx 6854 4109 0 2 4 14 54 854 854 1854 6854 108 109 QDAAAA BCGAAA HHHHxx 8263 4110 1 3 3 3 63 263 263 3263 8263 126 127 VFAAAA CCGAAA OOOOxx 8658 4111 0 2 8 18 58 658 658 3658 8658 116 117 AVAAAA DCGAAA VVVVxx 587 4112 1 3 7 7 87 587 587 587 587 174 175 PWAAAA ECGAAA AAAAxx 4553 4113 1 1 3 13 53 553 553 4553 4553 106 107 DTAAAA FCGAAA HHHHxx 1368 4114 0 0 8 8 68 368 1368 1368 1368 136 137 QAAAAA GCGAAA OOOOxx 1718 4115 0 2 8 18 18 718 1718 1718 1718 36 37 COAAAA HCGAAA VVVVxx 140 4116 0 0 0 0 40 140 140 140 140 80 81 KFAAAA ICGAAA AAAAxx 8341 4117 1 1 1 1 41 341 341 3341 8341 82 83 VIAAAA JCGAAA HHHHxx 72 4118 0 0 2 12 72 72 72 72 72 144 145 UCAAAA KCGAAA OOOOxx 6589 4119 1 1 9 9 89 589 589 1589 6589 178 179 LTAAAA LCGAAA VVVVxx 2024 4120 0 0 4 4 24 24 24 2024 2024 48 49 WZAAAA MCGAAA AAAAxx 8024 4121 0 0 4 4 24 24 24 3024 8024 48 49 QWAAAA NCGAAA HHHHxx 9564 4122 0 0 4 4 64 564 1564 4564 9564 128 129 WDAAAA OCGAAA OOOOxx 8625 4123 1 1 5 5 25 625 625 3625 8625 50 51 TTAAAA PCGAAA VVVVxx 2680 4124 0 0 0 0 80 680 680 2680 2680 160 161 CZAAAA QCGAAA AAAAxx 4323 4125 1 3 3 3 23 323 323 4323 4323 46 47 HKAAAA RCGAAA HHHHxx 8981 4126 1 1 1 1 81 981 981 3981 8981 162 163 LHAAAA SCGAAA OOOOxx 8909 4127 1 1 9 9 9 909 909 3909 8909 18 19 REAAAA TCGAAA VVVVxx 5288 4128 0 0 8 8 88 288 1288 288 5288 176 177 KVAAAA UCGAAA AAAAxx 2057 4129 1 1 7 17 57 57 57 2057 2057 114 115 DBAAAA VCGAAA HHHHxx 5931 4130 1 3 1 11 31 931 1931 931 5931 62 63 DUAAAA WCGAAA OOOOxx 9794 4131 0 2 4 14 94 794 1794 4794 9794 188 189 SMAAAA XCGAAA VVVVxx 1012 4132 0 0 2 12 12 12 1012 1012 1012 24 25 YMAAAA YCGAAA AAAAxx 5496 4133 0 0 6 16 96 496 1496 496 5496 192 193 KDAAAA ZCGAAA HHHHxx 9182 4134 0 2 2 2 82 182 1182 4182 9182 164 165 EPAAAA ADGAAA OOOOxx 5258 4135 0 2 8 18 58 258 1258 258 5258 116 117 GUAAAA BDGAAA VVVVxx 3050 4136 0 2 0 10 50 50 1050 3050 3050 100 101 INAAAA CDGAAA AAAAxx 2083 4137 1 3 3 3 83 83 83 2083 2083 166 167 DCAAAA DDGAAA HHHHxx 3069 4138 1 1 9 9 69 69 1069 3069 3069 138 139 BOAAAA EDGAAA OOOOxx 8459 4139 1 3 9 19 59 459 459 3459 8459 118 119 JNAAAA FDGAAA VVVVxx 169 4140 1 1 9 9 69 169 169 169 169 138 139 NGAAAA GDGAAA AAAAxx 4379 4141 1 3 9 19 79 379 379 4379 4379 158 159 LMAAAA HDGAAA HHHHxx 5126 4142 0 2 6 6 26 126 1126 126 5126 52 53 EPAAAA IDGAAA OOOOxx 1415 4143 1 3 5 15 15 415 1415 1415 1415 30 31 LCAAAA JDGAAA VVVVxx 1163 4144 1 3 3 3 63 163 1163 1163 1163 126 127 TSAAAA KDGAAA AAAAxx 3500 4145 0 0 0 0 0 500 1500 3500 3500 0 1 QEAAAA LDGAAA HHHHxx 7202 4146 0 2 2 2 2 202 1202 2202 7202 4 5 ARAAAA MDGAAA OOOOxx 747 4147 1 3 7 7 47 747 747 747 747 94 95 TCAAAA NDGAAA VVVVxx 9264 4148 0 0 4 4 64 264 1264 4264 9264 128 129 ISAAAA ODGAAA AAAAxx 8548 4149 0 0 8 8 48 548 548 3548 8548 96 97 UQAAAA PDGAAA HHHHxx 4228 4150 0 0 8 8 28 228 228 4228 4228 56 57 QGAAAA QDGAAA OOOOxx 7122 4151 0 2 2 2 22 122 1122 2122 7122 44 45 YNAAAA RDGAAA VVVVxx 3395 4152 1 3 5 15 95 395 1395 3395 3395 190 191 PAAAAA SDGAAA AAAAxx 5674 4153 0 2 4 14 74 674 1674 674 5674 148 149 GKAAAA TDGAAA HHHHxx 7293 4154 1 1 3 13 93 293 1293 2293 7293 186 187 NUAAAA UDGAAA OOOOxx 737 4155 1 1 7 17 37 737 737 737 737 74 75 JCAAAA VDGAAA VVVVxx 9595 4156 1 3 5 15 95 595 1595 4595 9595 190 191 BFAAAA WDGAAA AAAAxx 594 4157 0 2 4 14 94 594 594 594 594 188 189 WWAAAA XDGAAA HHHHxx 5322 4158 0 2 2 2 22 322 1322 322 5322 44 45 SWAAAA YDGAAA OOOOxx 2933 4159 1 1 3 13 33 933 933 2933 2933 66 67 VIAAAA ZDGAAA VVVVxx 4955 4160 1 3 5 15 55 955 955 4955 4955 110 111 PIAAAA AEGAAA AAAAxx 4073 4161 1 1 3 13 73 73 73 4073 4073 146 147 RAAAAA BEGAAA HHHHxx 7249 4162 1 1 9 9 49 249 1249 2249 7249 98 99 VSAAAA CEGAAA OOOOxx 192 4163 0 0 2 12 92 192 192 192 192 184 185 KHAAAA DEGAAA VVVVxx 2617 4164 1 1 7 17 17 617 617 2617 2617 34 35 RWAAAA EEGAAA AAAAxx 7409 4165 1 1 9 9 9 409 1409 2409 7409 18 19 ZYAAAA FEGAAA HHHHxx 4903 4166 1 3 3 3 3 903 903 4903 4903 6 7 PGAAAA GEGAAA OOOOxx 9797 4167 1 1 7 17 97 797 1797 4797 9797 194 195 VMAAAA HEGAAA VVVVxx 9919 4168 1 3 9 19 19 919 1919 4919 9919 38 39 NRAAAA IEGAAA AAAAxx 1878 4169 0 2 8 18 78 878 1878 1878 1878 156 157 GUAAAA JEGAAA HHHHxx 4851 4170 1 3 1 11 51 851 851 4851 4851 102 103 PEAAAA KEGAAA OOOOxx 5514 4171 0 2 4 14 14 514 1514 514 5514 28 29 CEAAAA LEGAAA VVVVxx 2582 4172 0 2 2 2 82 582 582 2582 2582 164 165 IVAAAA MEGAAA AAAAxx 3564 4173 0 0 4 4 64 564 1564 3564 3564 128 129 CHAAAA NEGAAA HHHHxx 7085 4174 1 1 5 5 85 85 1085 2085 7085 170 171 NMAAAA OEGAAA OOOOxx 3619 4175 1 3 9 19 19 619 1619 3619 3619 38 39 FJAAAA PEGAAA VVVVxx 261 4176 1 1 1 1 61 261 261 261 261 122 123 BKAAAA QEGAAA AAAAxx 7338 4177 0 2 8 18 38 338 1338 2338 7338 76 77 GWAAAA REGAAA HHHHxx 4251 4178 1 3 1 11 51 251 251 4251 4251 102 103 NHAAAA SEGAAA OOOOxx 5360 4179 0 0 0 0 60 360 1360 360 5360 120 121 EYAAAA TEGAAA VVVVxx 5678 4180 0 2 8 18 78 678 1678 678 5678 156 157 KKAAAA UEGAAA AAAAxx 9162 4181 0 2 2 2 62 162 1162 4162 9162 124 125 KOAAAA VEGAAA HHHHxx 5920 4182 0 0 0 0 20 920 1920 920 5920 40 41 STAAAA WEGAAA OOOOxx 7156 4183 0 0 6 16 56 156 1156 2156 7156 112 113 GPAAAA XEGAAA VVVVxx 4271 4184 1 3 1 11 71 271 271 4271 4271 142 143 HIAAAA YEGAAA AAAAxx 4698 4185 0 2 8 18 98 698 698 4698 4698 196 197 SYAAAA ZEGAAA HHHHxx 1572 4186 0 0 2 12 72 572 1572 1572 1572 144 145 MIAAAA AFGAAA OOOOxx 6974 4187 0 2 4 14 74 974 974 1974 6974 148 149 GIAAAA BFGAAA VVVVxx 4291 4188 1 3 1 11 91 291 291 4291 4291 182 183 BJAAAA CFGAAA AAAAxx 4036 4189 0 0 6 16 36 36 36 4036 4036 72 73 GZAAAA DFGAAA HHHHxx 7473 4190 1 1 3 13 73 473 1473 2473 7473 146 147 LBAAAA EFGAAA OOOOxx 4786 4191 0 2 6 6 86 786 786 4786 4786 172 173 CCAAAA FFGAAA VVVVxx 2662 4192 0 2 2 2 62 662 662 2662 2662 124 125 KYAAAA GFGAAA AAAAxx 916 4193 0 0 6 16 16 916 916 916 916 32 33 GJAAAA HFGAAA HHHHxx 668 4194 0 0 8 8 68 668 668 668 668 136 137 SZAAAA IFGAAA OOOOxx 4874 4195 0 2 4 14 74 874 874 4874 4874 148 149 MFAAAA JFGAAA VVVVxx 3752 4196 0 0 2 12 52 752 1752 3752 3752 104 105 IOAAAA KFGAAA AAAAxx 4865 4197 1 1 5 5 65 865 865 4865 4865 130 131 DFAAAA LFGAAA HHHHxx 7052 4198 0 0 2 12 52 52 1052 2052 7052 104 105 GLAAAA MFGAAA OOOOxx 5712 4199 0 0 2 12 12 712 1712 712 5712 24 25 SLAAAA NFGAAA VVVVxx 31 4200 1 3 1 11 31 31 31 31 31 62 63 FBAAAA OFGAAA AAAAxx 4944 4201 0 0 4 4 44 944 944 4944 4944 88 89 EIAAAA PFGAAA HHHHxx 1435 4202 1 3 5 15 35 435 1435 1435 1435 70 71 FDAAAA QFGAAA OOOOxx 501 4203 1 1 1 1 1 501 501 501 501 2 3 HTAAAA RFGAAA VVVVxx 9401 4204 1 1 1 1 1 401 1401 4401 9401 2 3 PXAAAA SFGAAA AAAAxx 5014 4205 0 2 4 14 14 14 1014 14 5014 28 29 WKAAAA TFGAAA HHHHxx 9125 4206 1 1 5 5 25 125 1125 4125 9125 50 51 ZMAAAA UFGAAA OOOOxx 6144 4207 0 0 4 4 44 144 144 1144 6144 88 89 ICAAAA VFGAAA VVVVxx 1743 4208 1 3 3 3 43 743 1743 1743 1743 86 87 BPAAAA WFGAAA AAAAxx 4316 4209 0 0 6 16 16 316 316 4316 4316 32 33 AKAAAA XFGAAA HHHHxx 8212 4210 0 0 2 12 12 212 212 3212 8212 24 25 WDAAAA YFGAAA OOOOxx 7344 4211 0 0 4 4 44 344 1344 2344 7344 88 89 MWAAAA ZFGAAA VVVVxx 2051 4212 1 3 1 11 51 51 51 2051 2051 102 103 XAAAAA AGGAAA AAAAxx 8131 4213 1 3 1 11 31 131 131 3131 8131 62 63 TAAAAA BGGAAA HHHHxx 7023 4214 1 3 3 3 23 23 1023 2023 7023 46 47 DKAAAA CGGAAA OOOOxx 9674 4215 0 2 4 14 74 674 1674 4674 9674 148 149 CIAAAA DGGAAA VVVVxx 4984 4216 0 0 4 4 84 984 984 4984 4984 168 169 SJAAAA EGGAAA AAAAxx 111 4217 1 3 1 11 11 111 111 111 111 22 23 HEAAAA FGGAAA HHHHxx 2296 4218 0 0 6 16 96 296 296 2296 2296 192 193 IKAAAA GGGAAA OOOOxx 5025 4219 1 1 5 5 25 25 1025 25 5025 50 51 HLAAAA HGGAAA VVVVxx 1756 4220 0 0 6 16 56 756 1756 1756 1756 112 113 OPAAAA IGGAAA AAAAxx 2885 4221 1 1 5 5 85 885 885 2885 2885 170 171 ZGAAAA JGGAAA HHHHxx 2541 4222 1 1 1 1 41 541 541 2541 2541 82 83 TTAAAA KGGAAA OOOOxx 1919 4223 1 3 9 19 19 919 1919 1919 1919 38 39 VVAAAA LGGAAA VVVVxx 6496 4224 0 0 6 16 96 496 496 1496 6496 192 193 WPAAAA MGGAAA AAAAxx 6103 4225 1 3 3 3 3 103 103 1103 6103 6 7 TAAAAA NGGAAA HHHHxx 98 4226 0 2 8 18 98 98 98 98 98 196 197 UDAAAA OGGAAA OOOOxx 3727 4227 1 3 7 7 27 727 1727 3727 3727 54 55 JNAAAA PGGAAA VVVVxx 689 4228 1 1 9 9 89 689 689 689 689 178 179 NAAAAA QGGAAA AAAAxx 7181 4229 1 1 1 1 81 181 1181 2181 7181 162 163 FQAAAA RGGAAA HHHHxx 8447 4230 1 3 7 7 47 447 447 3447 8447 94 95 XMAAAA SGGAAA OOOOxx 4569 4231 1 1 9 9 69 569 569 4569 4569 138 139 TTAAAA TGGAAA VVVVxx 8844 4232 0 0 4 4 44 844 844 3844 8844 88 89 ECAAAA UGGAAA AAAAxx 2436 4233 0 0 6 16 36 436 436 2436 2436 72 73 SPAAAA VGGAAA HHHHxx 391 4234 1 3 1 11 91 391 391 391 391 182 183 BPAAAA WGGAAA OOOOxx 3035 4235 1 3 5 15 35 35 1035 3035 3035 70 71 TMAAAA XGGAAA VVVVxx 7583 4236 1 3 3 3 83 583 1583 2583 7583 166 167 RFAAAA YGGAAA AAAAxx 1145 4237 1 1 5 5 45 145 1145 1145 1145 90 91 BSAAAA ZGGAAA HHHHxx 93 4238 1 1 3 13 93 93 93 93 93 186 187 PDAAAA AHGAAA OOOOxx 8896 4239 0 0 6 16 96 896 896 3896 8896 192 193 EEAAAA BHGAAA VVVVxx 6719 4240 1 3 9 19 19 719 719 1719 6719 38 39 LYAAAA CHGAAA AAAAxx 7728 4241 0 0 8 8 28 728 1728 2728 7728 56 57 GLAAAA DHGAAA HHHHxx 1349 4242 1 1 9 9 49 349 1349 1349 1349 98 99 XZAAAA EHGAAA OOOOxx 5349 4243 1 1 9 9 49 349 1349 349 5349 98 99 TXAAAA FHGAAA VVVVxx 3040 4244 0 0 0 0 40 40 1040 3040 3040 80 81 YMAAAA GHGAAA AAAAxx 2414 4245 0 2 4 14 14 414 414 2414 2414 28 29 WOAAAA HHGAAA HHHHxx 5122 4246 0 2 2 2 22 122 1122 122 5122 44 45 APAAAA IHGAAA OOOOxx 9553 4247 1 1 3 13 53 553 1553 4553 9553 106 107 LDAAAA JHGAAA VVVVxx 5987 4248 1 3 7 7 87 987 1987 987 5987 174 175 HWAAAA KHGAAA AAAAxx 5939 4249 1 3 9 19 39 939 1939 939 5939 78 79 LUAAAA LHGAAA HHHHxx 3525 4250 1 1 5 5 25 525 1525 3525 3525 50 51 PFAAAA MHGAAA OOOOxx 1371 4251 1 3 1 11 71 371 1371 1371 1371 142 143 TAAAAA NHGAAA VVVVxx 618 4252 0 2 8 18 18 618 618 618 618 36 37 UXAAAA OHGAAA AAAAxx 6529 4253 1 1 9 9 29 529 529 1529 6529 58 59 DRAAAA PHGAAA HHHHxx 4010 4254 0 2 0 10 10 10 10 4010 4010 20 21 GYAAAA QHGAAA OOOOxx 328 4255 0 0 8 8 28 328 328 328 328 56 57 QMAAAA RHGAAA VVVVxx 6121 4256 1 1 1 1 21 121 121 1121 6121 42 43 LBAAAA SHGAAA AAAAxx 3505 4257 1 1 5 5 5 505 1505 3505 3505 10 11 VEAAAA THGAAA HHHHxx 2033 4258 1 1 3 13 33 33 33 2033 2033 66 67 FAAAAA UHGAAA OOOOxx 4724 4259 0 0 4 4 24 724 724 4724 4724 48 49 SZAAAA VHGAAA VVVVxx 8717 4260 1 1 7 17 17 717 717 3717 8717 34 35 HXAAAA WHGAAA AAAAxx 5639 4261 1 3 9 19 39 639 1639 639 5639 78 79 XIAAAA XHGAAA HHHHxx 3448 4262 0 0 8 8 48 448 1448 3448 3448 96 97 QCAAAA YHGAAA OOOOxx 2919 4263 1 3 9 19 19 919 919 2919 2919 38 39 HIAAAA ZHGAAA VVVVxx 3417 4264 1 1 7 17 17 417 1417 3417 3417 34 35 LBAAAA AIGAAA AAAAxx 943 4265 1 3 3 3 43 943 943 943 943 86 87 HKAAAA BIGAAA HHHHxx 775 4266 1 3 5 15 75 775 775 775 775 150 151 VDAAAA CIGAAA OOOOxx 2333 4267 1 1 3 13 33 333 333 2333 2333 66 67 TLAAAA DIGAAA VVVVxx 4801 4268 1 1 1 1 1 801 801 4801 4801 2 3 RCAAAA EIGAAA AAAAxx 7169 4269 1 1 9 9 69 169 1169 2169 7169 138 139 TPAAAA FIGAAA HHHHxx 2840 4270 0 0 0 0 40 840 840 2840 2840 80 81 GFAAAA GIGAAA OOOOxx 9034 4271 0 2 4 14 34 34 1034 4034 9034 68 69 MJAAAA HIGAAA VVVVxx 6154 4272 0 2 4 14 54 154 154 1154 6154 108 109 SCAAAA IIGAAA AAAAxx 1412 4273 0 0 2 12 12 412 1412 1412 1412 24 25 ICAAAA JIGAAA HHHHxx 2263 4274 1 3 3 3 63 263 263 2263 2263 126 127 BJAAAA KIGAAA OOOOxx 7118 4275 0 2 8 18 18 118 1118 2118 7118 36 37 UNAAAA LIGAAA VVVVxx 1526 4276 0 2 6 6 26 526 1526 1526 1526 52 53 SGAAAA MIGAAA AAAAxx 491 4277 1 3 1 11 91 491 491 491 491 182 183 XSAAAA NIGAAA HHHHxx 9732 4278 0 0 2 12 32 732 1732 4732 9732 64 65 IKAAAA OIGAAA OOOOxx 7067 4279 1 3 7 7 67 67 1067 2067 7067 134 135 VLAAAA PIGAAA VVVVxx 212 4280 0 0 2 12 12 212 212 212 212 24 25 EIAAAA QIGAAA AAAAxx 1955 4281 1 3 5 15 55 955 1955 1955 1955 110 111 FXAAAA RIGAAA HHHHxx 3303 4282 1 3 3 3 3 303 1303 3303 3303 6 7 BXAAAA SIGAAA OOOOxx 2715 4283 1 3 5 15 15 715 715 2715 2715 30 31 LAAAAA TIGAAA VVVVxx 8168 4284 0 0 8 8 68 168 168 3168 8168 136 137 ECAAAA UIGAAA AAAAxx 6799 4285 1 3 9 19 99 799 799 1799 6799 198 199 NBAAAA VIGAAA HHHHxx 5080 4286 0 0 0 0 80 80 1080 80 5080 160 161 KNAAAA WIGAAA OOOOxx 4939 4287 1 3 9 19 39 939 939 4939 4939 78 79 ZHAAAA XIGAAA VVVVxx 6604 4288 0 0 4 4 4 604 604 1604 6604 8 9 AUAAAA YIGAAA AAAAxx 6531 4289 1 3 1 11 31 531 531 1531 6531 62 63 FRAAAA ZIGAAA HHHHxx 9948 4290 0 0 8 8 48 948 1948 4948 9948 96 97 QSAAAA AJGAAA OOOOxx 7923 4291 1 3 3 3 23 923 1923 2923 7923 46 47 TSAAAA BJGAAA VVVVxx 9905 4292 1 1 5 5 5 905 1905 4905 9905 10 11 ZQAAAA CJGAAA AAAAxx 340 4293 0 0 0 0 40 340 340 340 340 80 81 CNAAAA DJGAAA HHHHxx 1721 4294 1 1 1 1 21 721 1721 1721 1721 42 43 FOAAAA EJGAAA OOOOxx 9047 4295 1 3 7 7 47 47 1047 4047 9047 94 95 ZJAAAA FJGAAA VVVVxx 4723 4296 1 3 3 3 23 723 723 4723 4723 46 47 RZAAAA GJGAAA AAAAxx 5748 4297 0 0 8 8 48 748 1748 748 5748 96 97 CNAAAA HJGAAA HHHHxx 6845 4298 1 1 5 5 45 845 845 1845 6845 90 91 HDAAAA IJGAAA OOOOxx 1556 4299 0 0 6 16 56 556 1556 1556 1556 112 113 WHAAAA JJGAAA VVVVxx 9505 4300 1 1 5 5 5 505 1505 4505 9505 10 11 PBAAAA KJGAAA AAAAxx 3573 4301 1 1 3 13 73 573 1573 3573 3573 146 147 LHAAAA LJGAAA HHHHxx 3785 4302 1 1 5 5 85 785 1785 3785 3785 170 171 PPAAAA MJGAAA OOOOxx 2772 4303 0 0 2 12 72 772 772 2772 2772 144 145 QCAAAA NJGAAA VVVVxx 7282 4304 0 2 2 2 82 282 1282 2282 7282 164 165 CUAAAA OJGAAA AAAAxx 8106 4305 0 2 6 6 6 106 106 3106 8106 12 13 UZAAAA PJGAAA HHHHxx 2847 4306 1 3 7 7 47 847 847 2847 2847 94 95 NFAAAA QJGAAA OOOOxx 9803 4307 1 3 3 3 3 803 1803 4803 9803 6 7 BNAAAA RJGAAA VVVVxx 7719 4308 1 3 9 19 19 719 1719 2719 7719 38 39 XKAAAA SJGAAA AAAAxx 4649 4309 1 1 9 9 49 649 649 4649 4649 98 99 VWAAAA TJGAAA HHHHxx 6196 4310 0 0 6 16 96 196 196 1196 6196 192 193 IEAAAA UJGAAA OOOOxx 6026 4311 0 2 6 6 26 26 26 1026 6026 52 53 UXAAAA VJGAAA VVVVxx 1646 4312 0 2 6 6 46 646 1646 1646 1646 92 93 ILAAAA WJGAAA AAAAxx 6526 4313 0 2 6 6 26 526 526 1526 6526 52 53 ARAAAA XJGAAA HHHHxx 5110 4314 0 2 0 10 10 110 1110 110 5110 20 21 OOAAAA YJGAAA OOOOxx 3946 4315 0 2 6 6 46 946 1946 3946 3946 92 93 UVAAAA ZJGAAA VVVVxx 445 4316 1 1 5 5 45 445 445 445 445 90 91 DRAAAA AKGAAA AAAAxx 3249 4317 1 1 9 9 49 249 1249 3249 3249 98 99 ZUAAAA BKGAAA HHHHxx 2501 4318 1 1 1 1 1 501 501 2501 2501 2 3 FSAAAA CKGAAA OOOOxx 3243 4319 1 3 3 3 43 243 1243 3243 3243 86 87 TUAAAA DKGAAA VVVVxx 4701 4320 1 1 1 1 1 701 701 4701 4701 2 3 VYAAAA EKGAAA AAAAxx 472 4321 0 0 2 12 72 472 472 472 472 144 145 ESAAAA FKGAAA HHHHxx 3356 4322 0 0 6 16 56 356 1356 3356 3356 112 113 CZAAAA GKGAAA OOOOxx 9967 4323 1 3 7 7 67 967 1967 4967 9967 134 135 JTAAAA HKGAAA VVVVxx 4292 4324 0 0 2 12 92 292 292 4292 4292 184 185 CJAAAA IKGAAA AAAAxx 7005 4325 1 1 5 5 5 5 1005 2005 7005 10 11 LJAAAA JKGAAA HHHHxx 6267 4326 1 3 7 7 67 267 267 1267 6267 134 135 BHAAAA KKGAAA OOOOxx 6678 4327 0 2 8 18 78 678 678 1678 6678 156 157 WWAAAA LKGAAA VVVVxx 6083 4328 1 3 3 3 83 83 83 1083 6083 166 167 ZZAAAA MKGAAA AAAAxx 760 4329 0 0 0 0 60 760 760 760 760 120 121 GDAAAA NKGAAA HHHHxx 7833 4330 1 1 3 13 33 833 1833 2833 7833 66 67 HPAAAA OKGAAA OOOOxx 2877 4331 1 1 7 17 77 877 877 2877 2877 154 155 RGAAAA PKGAAA VVVVxx 8810 4332 0 2 0 10 10 810 810 3810 8810 20 21 WAAAAA QKGAAA AAAAxx 1560 4333 0 0 0 0 60 560 1560 1560 1560 120 121 AIAAAA RKGAAA HHHHxx 1367 4334 1 3 7 7 67 367 1367 1367 1367 134 135 PAAAAA SKGAAA OOOOxx 8756 4335 0 0 6 16 56 756 756 3756 8756 112 113 UYAAAA TKGAAA VVVVxx 1346 4336 0 2 6 6 46 346 1346 1346 1346 92 93 UZAAAA UKGAAA AAAAxx 6449 4337 1 1 9 9 49 449 449 1449 6449 98 99 BOAAAA VKGAAA HHHHxx 6658 4338 0 2 8 18 58 658 658 1658 6658 116 117 CWAAAA WKGAAA OOOOxx 6745 4339 1 1 5 5 45 745 745 1745 6745 90 91 LZAAAA XKGAAA VVVVxx 4866 4340 0 2 6 6 66 866 866 4866 4866 132 133 EFAAAA YKGAAA AAAAxx 14 4341 0 2 4 14 14 14 14 14 14 28 29 OAAAAA ZKGAAA HHHHxx 4506 4342 0 2 6 6 6 506 506 4506 4506 12 13 IRAAAA ALGAAA OOOOxx 1923 4343 1 3 3 3 23 923 1923 1923 1923 46 47 ZVAAAA BLGAAA VVVVxx 8365 4344 1 1 5 5 65 365 365 3365 8365 130 131 TJAAAA CLGAAA AAAAxx 1279 4345 1 3 9 19 79 279 1279 1279 1279 158 159 FXAAAA DLGAAA HHHHxx 7666 4346 0 2 6 6 66 666 1666 2666 7666 132 133 WIAAAA ELGAAA OOOOxx 7404 4347 0 0 4 4 4 404 1404 2404 7404 8 9 UYAAAA FLGAAA VVVVxx 65 4348 1 1 5 5 65 65 65 65 65 130 131 NCAAAA GLGAAA AAAAxx 5820 4349 0 0 0 0 20 820 1820 820 5820 40 41 WPAAAA HLGAAA HHHHxx 459 4350 1 3 9 19 59 459 459 459 459 118 119 RRAAAA ILGAAA OOOOxx 4787 4351 1 3 7 7 87 787 787 4787 4787 174 175 DCAAAA JLGAAA VVVVxx 5631 4352 1 3 1 11 31 631 1631 631 5631 62 63 PIAAAA KLGAAA AAAAxx 9717 4353 1 1 7 17 17 717 1717 4717 9717 34 35 TJAAAA LLGAAA HHHHxx 2560 4354 0 0 0 0 60 560 560 2560 2560 120 121 MUAAAA MLGAAA OOOOxx 8295 4355 1 3 5 15 95 295 295 3295 8295 190 191 BHAAAA NLGAAA VVVVxx 3596 4356 0 0 6 16 96 596 1596 3596 3596 192 193 IIAAAA OLGAAA AAAAxx 2023 4357 1 3 3 3 23 23 23 2023 2023 46 47 VZAAAA PLGAAA HHHHxx 5055 4358 1 3 5 15 55 55 1055 55 5055 110 111 LMAAAA QLGAAA OOOOxx 763 4359 1 3 3 3 63 763 763 763 763 126 127 JDAAAA RLGAAA VVVVxx 6733 4360 1 1 3 13 33 733 733 1733 6733 66 67 ZYAAAA SLGAAA AAAAxx 9266 4361 0 2 6 6 66 266 1266 4266 9266 132 133 KSAAAA TLGAAA HHHHxx 4479 4362 1 3 9 19 79 479 479 4479 4479 158 159 HQAAAA ULGAAA OOOOxx 1816 4363 0 0 6 16 16 816 1816 1816 1816 32 33 WRAAAA VLGAAA VVVVxx 899 4364 1 3 9 19 99 899 899 899 899 198 199 PIAAAA WLGAAA AAAAxx 230 4365 0 2 0 10 30 230 230 230 230 60 61 WIAAAA XLGAAA HHHHxx 5362 4366 0 2 2 2 62 362 1362 362 5362 124 125 GYAAAA YLGAAA OOOOxx 1609 4367 1 1 9 9 9 609 1609 1609 1609 18 19 XJAAAA ZLGAAA VVVVxx 6750 4368 0 2 0 10 50 750 750 1750 6750 100 101 QZAAAA AMGAAA AAAAxx 9704 4369 0 0 4 4 4 704 1704 4704 9704 8 9 GJAAAA BMGAAA HHHHxx 3991 4370 1 3 1 11 91 991 1991 3991 3991 182 183 NXAAAA CMGAAA OOOOxx 3959 4371 1 3 9 19 59 959 1959 3959 3959 118 119 HWAAAA DMGAAA VVVVxx 9021 4372 1 1 1 1 21 21 1021 4021 9021 42 43 ZIAAAA EMGAAA AAAAxx 7585 4373 1 1 5 5 85 585 1585 2585 7585 170 171 TFAAAA FMGAAA HHHHxx 7083 4374 1 3 3 3 83 83 1083 2083 7083 166 167 LMAAAA GMGAAA OOOOxx 7688 4375 0 0 8 8 88 688 1688 2688 7688 176 177 SJAAAA HMGAAA VVVVxx 2673 4376 1 1 3 13 73 673 673 2673 2673 146 147 VYAAAA IMGAAA AAAAxx 3554 4377 0 2 4 14 54 554 1554 3554 3554 108 109 SGAAAA JMGAAA HHHHxx 7416 4378 0 0 6 16 16 416 1416 2416 7416 32 33 GZAAAA KMGAAA OOOOxx 5672 4379 0 0 2 12 72 672 1672 672 5672 144 145 EKAAAA LMGAAA VVVVxx 1355 4380 1 3 5 15 55 355 1355 1355 1355 110 111 DAAAAA MMGAAA AAAAxx 3149 4381 1 1 9 9 49 149 1149 3149 3149 98 99 DRAAAA NMGAAA HHHHxx 5811 4382 1 3 1 11 11 811 1811 811 5811 22 23 NPAAAA OMGAAA OOOOxx 3759 4383 1 3 9 19 59 759 1759 3759 3759 118 119 POAAAA PMGAAA VVVVxx 5634 4384 0 2 4 14 34 634 1634 634 5634 68 69 SIAAAA QMGAAA AAAAxx 8617 4385 1 1 7 17 17 617 617 3617 8617 34 35 LTAAAA RMGAAA HHHHxx 8949 4386 1 1 9 9 49 949 949 3949 8949 98 99 FGAAAA SMGAAA OOOOxx 3964 4387 0 0 4 4 64 964 1964 3964 3964 128 129 MWAAAA TMGAAA VVVVxx 3852 4388 0 0 2 12 52 852 1852 3852 3852 104 105 ESAAAA UMGAAA AAAAxx 1555 4389 1 3 5 15 55 555 1555 1555 1555 110 111 VHAAAA VMGAAA HHHHxx 6536 4390 0 0 6 16 36 536 536 1536 6536 72 73 KRAAAA WMGAAA OOOOxx 4779 4391 1 3 9 19 79 779 779 4779 4779 158 159 VBAAAA XMGAAA VVVVxx 1893 4392 1 1 3 13 93 893 1893 1893 1893 186 187 VUAAAA YMGAAA AAAAxx 9358 4393 0 2 8 18 58 358 1358 4358 9358 116 117 YVAAAA ZMGAAA HHHHxx 7438 4394 0 2 8 18 38 438 1438 2438 7438 76 77 CAAAAA ANGAAA OOOOxx 941 4395 1 1 1 1 41 941 941 941 941 82 83 FKAAAA BNGAAA VVVVxx 4844 4396 0 0 4 4 44 844 844 4844 4844 88 89 IEAAAA CNGAAA AAAAxx 4745 4397 1 1 5 5 45 745 745 4745 4745 90 91 NAAAAA DNGAAA HHHHxx 1017 4398 1 1 7 17 17 17 1017 1017 1017 34 35 DNAAAA ENGAAA OOOOxx 327 4399 1 3 7 7 27 327 327 327 327 54 55 PMAAAA FNGAAA VVVVxx 3152 4400 0 0 2 12 52 152 1152 3152 3152 104 105 GRAAAA GNGAAA AAAAxx 4711 4401 1 3 1 11 11 711 711 4711 4711 22 23 FZAAAA HNGAAA HHHHxx 141 4402 1 1 1 1 41 141 141 141 141 82 83 LFAAAA INGAAA OOOOxx 1303 4403 1 3 3 3 3 303 1303 1303 1303 6 7 DYAAAA JNGAAA VVVVxx 8873 4404 1 1 3 13 73 873 873 3873 8873 146 147 HDAAAA KNGAAA AAAAxx 8481 4405 1 1 1 1 81 481 481 3481 8481 162 163 FOAAAA LNGAAA HHHHxx 5445 4406 1 1 5 5 45 445 1445 445 5445 90 91 LBAAAA MNGAAA OOOOxx 7868 4407 0 0 8 8 68 868 1868 2868 7868 136 137 QQAAAA NNGAAA VVVVxx 6722 4408 0 2 2 2 22 722 722 1722 6722 44 45 OYAAAA ONGAAA AAAAxx 6628 4409 0 0 8 8 28 628 628 1628 6628 56 57 YUAAAA PNGAAA HHHHxx 7738 4410 0 2 8 18 38 738 1738 2738 7738 76 77 QLAAAA QNGAAA OOOOxx 1018 4411 0 2 8 18 18 18 1018 1018 1018 36 37 ENAAAA RNGAAA VVVVxx 3296 4412 0 0 6 16 96 296 1296 3296 3296 192 193 UWAAAA SNGAAA AAAAxx 1946 4413 0 2 6 6 46 946 1946 1946 1946 92 93 WWAAAA TNGAAA HHHHxx 6603 4414 1 3 3 3 3 603 603 1603 6603 6 7 ZTAAAA UNGAAA OOOOxx 3562 4415 0 2 2 2 62 562 1562 3562 3562 124 125 AHAAAA VNGAAA VVVVxx 1147 4416 1 3 7 7 47 147 1147 1147 1147 94 95 DSAAAA WNGAAA AAAAxx 6031 4417 1 3 1 11 31 31 31 1031 6031 62 63 ZXAAAA XNGAAA HHHHxx 6484 4418 0 0 4 4 84 484 484 1484 6484 168 169 KPAAAA YNGAAA OOOOxx 496 4419 0 0 6 16 96 496 496 496 496 192 193 CTAAAA ZNGAAA VVVVxx 4563 4420 1 3 3 3 63 563 563 4563 4563 126 127 NTAAAA AOGAAA AAAAxx 1037 4421 1 1 7 17 37 37 1037 1037 1037 74 75 XNAAAA BOGAAA HHHHxx 9672 4422 0 0 2 12 72 672 1672 4672 9672 144 145 AIAAAA COGAAA OOOOxx 9053 4423 1 1 3 13 53 53 1053 4053 9053 106 107 FKAAAA DOGAAA VVVVxx 2523 4424 1 3 3 3 23 523 523 2523 2523 46 47 BTAAAA EOGAAA AAAAxx 8519 4425 1 3 9 19 19 519 519 3519 8519 38 39 RPAAAA FOGAAA HHHHxx 8190 4426 0 2 0 10 90 190 190 3190 8190 180 181 ADAAAA GOGAAA OOOOxx 2068 4427 0 0 8 8 68 68 68 2068 2068 136 137 OBAAAA HOGAAA VVVVxx 8569 4428 1 1 9 9 69 569 569 3569 8569 138 139 PRAAAA IOGAAA AAAAxx 6535 4429 1 3 5 15 35 535 535 1535 6535 70 71 JRAAAA JOGAAA HHHHxx 1810 4430 0 2 0 10 10 810 1810 1810 1810 20 21 QRAAAA KOGAAA OOOOxx 3099 4431 1 3 9 19 99 99 1099 3099 3099 198 199 FPAAAA LOGAAA VVVVxx 7466 4432 0 2 6 6 66 466 1466 2466 7466 132 133 EBAAAA MOGAAA AAAAxx 4017 4433 1 1 7 17 17 17 17 4017 4017 34 35 NYAAAA NOGAAA HHHHxx 1097 4434 1 1 7 17 97 97 1097 1097 1097 194 195 FQAAAA OOGAAA OOOOxx 7686 4435 0 2 6 6 86 686 1686 2686 7686 172 173 QJAAAA POGAAA VVVVxx 6742 4436 0 2 2 2 42 742 742 1742 6742 84 85 IZAAAA QOGAAA AAAAxx 5966 4437 0 2 6 6 66 966 1966 966 5966 132 133 MVAAAA ROGAAA HHHHxx 3632 4438 0 0 2 12 32 632 1632 3632 3632 64 65 SJAAAA SOGAAA OOOOxx 8837 4439 1 1 7 17 37 837 837 3837 8837 74 75 XBAAAA TOGAAA VVVVxx 1667 4440 1 3 7 7 67 667 1667 1667 1667 134 135 DMAAAA UOGAAA AAAAxx 8833 4441 1 1 3 13 33 833 833 3833 8833 66 67 TBAAAA VOGAAA HHHHxx 9805 4442 1 1 5 5 5 805 1805 4805 9805 10 11 DNAAAA WOGAAA OOOOxx 3650 4443 0 2 0 10 50 650 1650 3650 3650 100 101 KKAAAA XOGAAA VVVVxx 2237 4444 1 1 7 17 37 237 237 2237 2237 74 75 BIAAAA YOGAAA AAAAxx 9980 4445 0 0 0 0 80 980 1980 4980 9980 160 161 WTAAAA ZOGAAA HHHHxx 2861 4446 1 1 1 1 61 861 861 2861 2861 122 123 BGAAAA APGAAA OOOOxx 1334 4447 0 2 4 14 34 334 1334 1334 1334 68 69 IZAAAA BPGAAA VVVVxx 842 4448 0 2 2 2 42 842 842 842 842 84 85 KGAAAA CPGAAA AAAAxx 1116 4449 0 0 6 16 16 116 1116 1116 1116 32 33 YQAAAA DPGAAA HHHHxx 4055 4450 1 3 5 15 55 55 55 4055 4055 110 111 ZZAAAA EPGAAA OOOOxx 3842 4451 0 2 2 2 42 842 1842 3842 3842 84 85 URAAAA FPGAAA VVVVxx 1886 4452 0 2 6 6 86 886 1886 1886 1886 172 173 OUAAAA GPGAAA AAAAxx 8589 4453 1 1 9 9 89 589 589 3589 8589 178 179 JSAAAA HPGAAA HHHHxx 5873 4454 1 1 3 13 73 873 1873 873 5873 146 147 XRAAAA IPGAAA OOOOxx 7711 4455 1 3 1 11 11 711 1711 2711 7711 22 23 PKAAAA JPGAAA VVVVxx 911 4456 1 3 1 11 11 911 911 911 911 22 23 BJAAAA KPGAAA AAAAxx 5837 4457 1 1 7 17 37 837 1837 837 5837 74 75 NQAAAA LPGAAA HHHHxx 897 4458 1 1 7 17 97 897 897 897 897 194 195 NIAAAA MPGAAA OOOOxx 4299 4459 1 3 9 19 99 299 299 4299 4299 198 199 JJAAAA NPGAAA VVVVxx 7774 4460 0 2 4 14 74 774 1774 2774 7774 148 149 ANAAAA OPGAAA AAAAxx 7832 4461 0 0 2 12 32 832 1832 2832 7832 64 65 GPAAAA PPGAAA HHHHxx 9915 4462 1 3 5 15 15 915 1915 4915 9915 30 31 JRAAAA QPGAAA OOOOxx 9 4463 1 1 9 9 9 9 9 9 9 18 19 JAAAAA RPGAAA VVVVxx 9675 4464 1 3 5 15 75 675 1675 4675 9675 150 151 DIAAAA SPGAAA AAAAxx 7953 4465 1 1 3 13 53 953 1953 2953 7953 106 107 XTAAAA TPGAAA HHHHxx 8912 4466 0 0 2 12 12 912 912 3912 8912 24 25 UEAAAA UPGAAA OOOOxx 4188 4467 0 0 8 8 88 188 188 4188 4188 176 177 CFAAAA VPGAAA VVVVxx 8446 4468 0 2 6 6 46 446 446 3446 8446 92 93 WMAAAA WPGAAA AAAAxx 1600 4469 0 0 0 0 0 600 1600 1600 1600 0 1 OJAAAA XPGAAA HHHHxx 43 4470 1 3 3 3 43 43 43 43 43 86 87 RBAAAA YPGAAA OOOOxx 544 4471 0 0 4 4 44 544 544 544 544 88 89 YUAAAA ZPGAAA VVVVxx 6977 4472 1 1 7 17 77 977 977 1977 6977 154 155 JIAAAA AQGAAA AAAAxx 3191 4473 1 3 1 11 91 191 1191 3191 3191 182 183 TSAAAA BQGAAA HHHHxx 418 4474 0 2 8 18 18 418 418 418 418 36 37 CQAAAA CQGAAA OOOOxx 3142 4475 0 2 2 2 42 142 1142 3142 3142 84 85 WQAAAA DQGAAA VVVVxx 5042 4476 0 2 2 2 42 42 1042 42 5042 84 85 YLAAAA EQGAAA AAAAxx 2194 4477 0 2 4 14 94 194 194 2194 2194 188 189 KGAAAA FQGAAA HHHHxx 2397 4478 1 1 7 17 97 397 397 2397 2397 194 195 FOAAAA GQGAAA OOOOxx 4684 4479 0 0 4 4 84 684 684 4684 4684 168 169 EYAAAA HQGAAA VVVVxx 34 4480 0 2 4 14 34 34 34 34 34 68 69 IBAAAA IQGAAA AAAAxx 3844 4481 0 0 4 4 44 844 1844 3844 3844 88 89 WRAAAA JQGAAA HHHHxx 7824 4482 0 0 4 4 24 824 1824 2824 7824 48 49 YOAAAA KQGAAA OOOOxx 6177 4483 1 1 7 17 77 177 177 1177 6177 154 155 PDAAAA LQGAAA VVVVxx 9657 4484 1 1 7 17 57 657 1657 4657 9657 114 115 LHAAAA MQGAAA AAAAxx 4546 4485 0 2 6 6 46 546 546 4546 4546 92 93 WSAAAA NQGAAA HHHHxx 599 4486 1 3 9 19 99 599 599 599 599 198 199 BXAAAA OQGAAA OOOOxx 153 4487 1 1 3 13 53 153 153 153 153 106 107 XFAAAA PQGAAA VVVVxx 6910 4488 0 2 0 10 10 910 910 1910 6910 20 21 UFAAAA QQGAAA AAAAxx 4408 4489 0 0 8 8 8 408 408 4408 4408 16 17 ONAAAA RQGAAA HHHHxx 1164 4490 0 0 4 4 64 164 1164 1164 1164 128 129 USAAAA SQGAAA OOOOxx 6469 4491 1 1 9 9 69 469 469 1469 6469 138 139 VOAAAA TQGAAA VVVVxx 5996 4492 0 0 6 16 96 996 1996 996 5996 192 193 QWAAAA UQGAAA AAAAxx 2639 4493 1 3 9 19 39 639 639 2639 2639 78 79 NXAAAA VQGAAA HHHHxx 2678 4494 0 2 8 18 78 678 678 2678 2678 156 157 AZAAAA WQGAAA OOOOxx 8392 4495 0 0 2 12 92 392 392 3392 8392 184 185 UKAAAA XQGAAA VVVVxx 1386 4496 0 2 6 6 86 386 1386 1386 1386 172 173 IBAAAA YQGAAA AAAAxx 5125 4497 1 1 5 5 25 125 1125 125 5125 50 51 DPAAAA ZQGAAA HHHHxx 8453 4498 1 1 3 13 53 453 453 3453 8453 106 107 DNAAAA ARGAAA OOOOxx 2369 4499 1 1 9 9 69 369 369 2369 2369 138 139 DNAAAA BRGAAA VVVVxx 1608 4500 0 0 8 8 8 608 1608 1608 1608 16 17 WJAAAA CRGAAA AAAAxx 3781 4501 1 1 1 1 81 781 1781 3781 3781 162 163 LPAAAA DRGAAA HHHHxx 903 4502 1 3 3 3 3 903 903 903 903 6 7 TIAAAA ERGAAA OOOOxx 2099 4503 1 3 9 19 99 99 99 2099 2099 198 199 TCAAAA FRGAAA VVVVxx 538 4504 0 2 8 18 38 538 538 538 538 76 77 SUAAAA GRGAAA AAAAxx 9177 4505 1 1 7 17 77 177 1177 4177 9177 154 155 ZOAAAA HRGAAA HHHHxx 420 4506 0 0 0 0 20 420 420 420 420 40 41 EQAAAA IRGAAA OOOOxx 9080 4507 0 0 0 0 80 80 1080 4080 9080 160 161 GLAAAA JRGAAA VVVVxx 2630 4508 0 2 0 10 30 630 630 2630 2630 60 61 EXAAAA KRGAAA AAAAxx 5978 4509 0 2 8 18 78 978 1978 978 5978 156 157 YVAAAA LRGAAA HHHHxx 9239 4510 1 3 9 19 39 239 1239 4239 9239 78 79 JRAAAA MRGAAA OOOOxx 4372 4511 0 0 2 12 72 372 372 4372 4372 144 145 EMAAAA NRGAAA VVVVxx 4357 4512 1 1 7 17 57 357 357 4357 4357 114 115 PLAAAA ORGAAA AAAAxx 9857 4513 1 1 7 17 57 857 1857 4857 9857 114 115 DPAAAA PRGAAA HHHHxx 7933 4514 1 1 3 13 33 933 1933 2933 7933 66 67 DTAAAA QRGAAA OOOOxx 9574 4515 0 2 4 14 74 574 1574 4574 9574 148 149 GEAAAA RRGAAA VVVVxx 8294 4516 0 2 4 14 94 294 294 3294 8294 188 189 AHAAAA SRGAAA AAAAxx 627 4517 1 3 7 7 27 627 627 627 627 54 55 DYAAAA TRGAAA HHHHxx 3229 4518 1 1 9 9 29 229 1229 3229 3229 58 59 FUAAAA URGAAA OOOOxx 3163 4519 1 3 3 3 63 163 1163 3163 3163 126 127 RRAAAA VRGAAA VVVVxx 7349 4520 1 1 9 9 49 349 1349 2349 7349 98 99 RWAAAA WRGAAA AAAAxx 6889 4521 1 1 9 9 89 889 889 1889 6889 178 179 ZEAAAA XRGAAA HHHHxx 2101 4522 1 1 1 1 1 101 101 2101 2101 2 3 VCAAAA YRGAAA OOOOxx 6476 4523 0 0 6 16 76 476 476 1476 6476 152 153 CPAAAA ZRGAAA VVVVxx 6765 4524 1 1 5 5 65 765 765 1765 6765 130 131 FAAAAA ASGAAA AAAAxx 4204 4525 0 0 4 4 4 204 204 4204 4204 8 9 SFAAAA BSGAAA HHHHxx 5915 4526 1 3 5 15 15 915 1915 915 5915 30 31 NTAAAA CSGAAA OOOOxx 2318 4527 0 2 8 18 18 318 318 2318 2318 36 37 ELAAAA DSGAAA VVVVxx 294 4528 0 2 4 14 94 294 294 294 294 188 189 ILAAAA ESGAAA AAAAxx 5245 4529 1 1 5 5 45 245 1245 245 5245 90 91 TTAAAA FSGAAA HHHHxx 4481 4530 1 1 1 1 81 481 481 4481 4481 162 163 JQAAAA GSGAAA OOOOxx 7754 4531 0 2 4 14 54 754 1754 2754 7754 108 109 GMAAAA HSGAAA VVVVxx 8494 4532 0 2 4 14 94 494 494 3494 8494 188 189 SOAAAA ISGAAA AAAAxx 4014 4533 0 2 4 14 14 14 14 4014 4014 28 29 KYAAAA JSGAAA HHHHxx 2197 4534 1 1 7 17 97 197 197 2197 2197 194 195 NGAAAA KSGAAA OOOOxx 1297 4535 1 1 7 17 97 297 1297 1297 1297 194 195 XXAAAA LSGAAA VVVVxx 1066 4536 0 2 6 6 66 66 1066 1066 1066 132 133 APAAAA MSGAAA AAAAxx 5710 4537 0 2 0 10 10 710 1710 710 5710 20 21 QLAAAA NSGAAA HHHHxx 4100 4538 0 0 0 0 0 100 100 4100 4100 0 1 SBAAAA OSGAAA OOOOxx 7356 4539 0 0 6 16 56 356 1356 2356 7356 112 113 YWAAAA PSGAAA VVVVxx 7658 4540 0 2 8 18 58 658 1658 2658 7658 116 117 OIAAAA QSGAAA AAAAxx 3666 4541 0 2 6 6 66 666 1666 3666 3666 132 133 ALAAAA RSGAAA HHHHxx 9713 4542 1 1 3 13 13 713 1713 4713 9713 26 27 PJAAAA SSGAAA OOOOxx 691 4543 1 3 1 11 91 691 691 691 691 182 183 PAAAAA TSGAAA VVVVxx 3112 4544 0 0 2 12 12 112 1112 3112 3112 24 25 SPAAAA USGAAA AAAAxx 6035 4545 1 3 5 15 35 35 35 1035 6035 70 71 DYAAAA VSGAAA HHHHxx 8353 4546 1 1 3 13 53 353 353 3353 8353 106 107 HJAAAA WSGAAA OOOOxx 5679 4547 1 3 9 19 79 679 1679 679 5679 158 159 LKAAAA XSGAAA VVVVxx 2124 4548 0 0 4 4 24 124 124 2124 2124 48 49 SDAAAA YSGAAA AAAAxx 4714 4549 0 2 4 14 14 714 714 4714 4714 28 29 IZAAAA ZSGAAA HHHHxx 9048 4550 0 0 8 8 48 48 1048 4048 9048 96 97 AKAAAA ATGAAA OOOOxx 7692 4551 0 0 2 12 92 692 1692 2692 7692 184 185 WJAAAA BTGAAA VVVVxx 4542 4552 0 2 2 2 42 542 542 4542 4542 84 85 SSAAAA CTGAAA AAAAxx 8737 4553 1 1 7 17 37 737 737 3737 8737 74 75 BYAAAA DTGAAA HHHHxx 4977 4554 1 1 7 17 77 977 977 4977 4977 154 155 LJAAAA ETGAAA OOOOxx 9349 4555 1 1 9 9 49 349 1349 4349 9349 98 99 PVAAAA FTGAAA VVVVxx 731 4556 1 3 1 11 31 731 731 731 731 62 63 DCAAAA GTGAAA AAAAxx 1788 4557 0 0 8 8 88 788 1788 1788 1788 176 177 UQAAAA HTGAAA HHHHxx 7830 4558 0 2 0 10 30 830 1830 2830 7830 60 61 EPAAAA ITGAAA OOOOxx 3977 4559 1 1 7 17 77 977 1977 3977 3977 154 155 ZWAAAA JTGAAA VVVVxx 2421 4560 1 1 1 1 21 421 421 2421 2421 42 43 DPAAAA KTGAAA AAAAxx 5891 4561 1 3 1 11 91 891 1891 891 5891 182 183 PSAAAA LTGAAA HHHHxx 1111 4562 1 3 1 11 11 111 1111 1111 1111 22 23 TQAAAA MTGAAA OOOOxx 9224 4563 0 0 4 4 24 224 1224 4224 9224 48 49 UQAAAA NTGAAA VVVVxx 9872 4564 0 0 2 12 72 872 1872 4872 9872 144 145 SPAAAA OTGAAA AAAAxx 2433 4565 1 1 3 13 33 433 433 2433 2433 66 67 PPAAAA PTGAAA HHHHxx 1491 4566 1 3 1 11 91 491 1491 1491 1491 182 183 JFAAAA QTGAAA OOOOxx 6653 4567 1 1 3 13 53 653 653 1653 6653 106 107 XVAAAA RTGAAA VVVVxx 1907 4568 1 3 7 7 7 907 1907 1907 1907 14 15 JVAAAA STGAAA AAAAxx 889 4569 1 1 9 9 89 889 889 889 889 178 179 FIAAAA TTGAAA HHHHxx 561 4570 1 1 1 1 61 561 561 561 561 122 123 PVAAAA UTGAAA OOOOxx 7415 4571 1 3 5 15 15 415 1415 2415 7415 30 31 FZAAAA VTGAAA VVVVxx 2703 4572 1 3 3 3 3 703 703 2703 2703 6 7 ZZAAAA WTGAAA AAAAxx 2561 4573 1 1 1 1 61 561 561 2561 2561 122 123 NUAAAA XTGAAA HHHHxx 1257 4574 1 1 7 17 57 257 1257 1257 1257 114 115 JWAAAA YTGAAA OOOOxx 2390 4575 0 2 0 10 90 390 390 2390 2390 180 181 YNAAAA ZTGAAA VVVVxx 3915 4576 1 3 5 15 15 915 1915 3915 3915 30 31 PUAAAA AUGAAA AAAAxx 8476 4577 0 0 6 16 76 476 476 3476 8476 152 153 AOAAAA BUGAAA HHHHxx 607 4578 1 3 7 7 7 607 607 607 607 14 15 JXAAAA CUGAAA OOOOxx 3891 4579 1 3 1 11 91 891 1891 3891 3891 182 183 RTAAAA DUGAAA VVVVxx 7269 4580 1 1 9 9 69 269 1269 2269 7269 138 139 PTAAAA EUGAAA AAAAxx 9537 4581 1 1 7 17 37 537 1537 4537 9537 74 75 VCAAAA FUGAAA HHHHxx 8518 4582 0 2 8 18 18 518 518 3518 8518 36 37 QPAAAA GUGAAA OOOOxx 5221 4583 1 1 1 1 21 221 1221 221 5221 42 43 VSAAAA HUGAAA VVVVxx 3274 4584 0 2 4 14 74 274 1274 3274 3274 148 149 YVAAAA IUGAAA AAAAxx 6677 4585 1 1 7 17 77 677 677 1677 6677 154 155 VWAAAA JUGAAA HHHHxx 3114 4586 0 2 4 14 14 114 1114 3114 3114 28 29 UPAAAA KUGAAA OOOOxx 1966 4587 0 2 6 6 66 966 1966 1966 1966 132 133 QXAAAA LUGAAA VVVVxx 5941 4588 1 1 1 1 41 941 1941 941 5941 82 83 NUAAAA MUGAAA AAAAxx 9463 4589 1 3 3 3 63 463 1463 4463 9463 126 127 ZZAAAA NUGAAA HHHHxx 8966 4590 0 2 6 6 66 966 966 3966 8966 132 133 WGAAAA OUGAAA OOOOxx 4402 4591 0 2 2 2 2 402 402 4402 4402 4 5 INAAAA PUGAAA VVVVxx 3364 4592 0 0 4 4 64 364 1364 3364 3364 128 129 KZAAAA QUGAAA AAAAxx 3698 4593 0 2 8 18 98 698 1698 3698 3698 196 197 GMAAAA RUGAAA HHHHxx 4651 4594 1 3 1 11 51 651 651 4651 4651 102 103 XWAAAA SUGAAA OOOOxx 2127 4595 1 3 7 7 27 127 127 2127 2127 54 55 VDAAAA TUGAAA VVVVxx 3614 4596 0 2 4 14 14 614 1614 3614 3614 28 29 AJAAAA UUGAAA AAAAxx 5430 4597 0 2 0 10 30 430 1430 430 5430 60 61 WAAAAA VUGAAA HHHHxx 3361 4598 1 1 1 1 61 361 1361 3361 3361 122 123 HZAAAA WUGAAA OOOOxx 4798 4599 0 2 8 18 98 798 798 4798 4798 196 197 OCAAAA XUGAAA VVVVxx 8269 4600 1 1 9 9 69 269 269 3269 8269 138 139 BGAAAA YUGAAA AAAAxx 6458 4601 0 2 8 18 58 458 458 1458 6458 116 117 KOAAAA ZUGAAA HHHHxx 3358 4602 0 2 8 18 58 358 1358 3358 3358 116 117 EZAAAA AVGAAA OOOOxx 5898 4603 0 2 8 18 98 898 1898 898 5898 196 197 WSAAAA BVGAAA VVVVxx 1880 4604 0 0 0 0 80 880 1880 1880 1880 160 161 IUAAAA CVGAAA AAAAxx 782 4605 0 2 2 2 82 782 782 782 782 164 165 CEAAAA DVGAAA HHHHxx 3102 4606 0 2 2 2 2 102 1102 3102 3102 4 5 IPAAAA EVGAAA OOOOxx 6366 4607 0 2 6 6 66 366 366 1366 6366 132 133 WKAAAA FVGAAA VVVVxx 399 4608 1 3 9 19 99 399 399 399 399 198 199 JPAAAA GVGAAA AAAAxx 6773 4609 1 1 3 13 73 773 773 1773 6773 146 147 NAAAAA HVGAAA HHHHxx 7942 4610 0 2 2 2 42 942 1942 2942 7942 84 85 MTAAAA IVGAAA OOOOxx 6274 4611 0 2 4 14 74 274 274 1274 6274 148 149 IHAAAA JVGAAA VVVVxx 7447 4612 1 3 7 7 47 447 1447 2447 7447 94 95 LAAAAA KVGAAA AAAAxx 7648 4613 0 0 8 8 48 648 1648 2648 7648 96 97 EIAAAA LVGAAA HHHHxx 3997 4614 1 1 7 17 97 997 1997 3997 3997 194 195 TXAAAA MVGAAA OOOOxx 1759 4615 1 3 9 19 59 759 1759 1759 1759 118 119 RPAAAA NVGAAA VVVVxx 1785 4616 1 1 5 5 85 785 1785 1785 1785 170 171 RQAAAA OVGAAA AAAAxx 8930 4617 0 2 0 10 30 930 930 3930 8930 60 61 MFAAAA PVGAAA HHHHxx 7595 4618 1 3 5 15 95 595 1595 2595 7595 190 191 DGAAAA QVGAAA OOOOxx 6752 4619 0 0 2 12 52 752 752 1752 6752 104 105 SZAAAA RVGAAA VVVVxx 5635 4620 1 3 5 15 35 635 1635 635 5635 70 71 TIAAAA SVGAAA AAAAxx 1579 4621 1 3 9 19 79 579 1579 1579 1579 158 159 TIAAAA TVGAAA HHHHxx 7743 4622 1 3 3 3 43 743 1743 2743 7743 86 87 VLAAAA UVGAAA OOOOxx 5856 4623 0 0 6 16 56 856 1856 856 5856 112 113 GRAAAA VVGAAA VVVVxx 7273 4624 1 1 3 13 73 273 1273 2273 7273 146 147 TTAAAA WVGAAA AAAAxx 1399 4625 1 3 9 19 99 399 1399 1399 1399 198 199 VBAAAA XVGAAA HHHHxx 3694 4626 0 2 4 14 94 694 1694 3694 3694 188 189 CMAAAA YVGAAA OOOOxx 2782 4627 0 2 2 2 82 782 782 2782 2782 164 165 ADAAAA ZVGAAA VVVVxx 6951 4628 1 3 1 11 51 951 951 1951 6951 102 103 JHAAAA AWGAAA AAAAxx 6053 4629 1 1 3 13 53 53 53 1053 6053 106 107 VYAAAA BWGAAA HHHHxx 1753 4630 1 1 3 13 53 753 1753 1753 1753 106 107 LPAAAA CWGAAA OOOOxx 3985 4631 1 1 5 5 85 985 1985 3985 3985 170 171 HXAAAA DWGAAA VVVVxx 6159 4632 1 3 9 19 59 159 159 1159 6159 118 119 XCAAAA EWGAAA AAAAxx 6250 4633 0 2 0 10 50 250 250 1250 6250 100 101 KGAAAA FWGAAA HHHHxx 6240 4634 0 0 0 0 40 240 240 1240 6240 80 81 AGAAAA GWGAAA OOOOxx 6571 4635 1 3 1 11 71 571 571 1571 6571 142 143 TSAAAA HWGAAA VVVVxx 8624 4636 0 0 4 4 24 624 624 3624 8624 48 49 STAAAA IWGAAA AAAAxx 9718 4637 0 2 8 18 18 718 1718 4718 9718 36 37 UJAAAA JWGAAA HHHHxx 5529 4638 1 1 9 9 29 529 1529 529 5529 58 59 REAAAA KWGAAA OOOOxx 7089 4639 1 1 9 9 89 89 1089 2089 7089 178 179 RMAAAA LWGAAA VVVVxx 5488 4640 0 0 8 8 88 488 1488 488 5488 176 177 CDAAAA MWGAAA AAAAxx 5444 4641 0 0 4 4 44 444 1444 444 5444 88 89 KBAAAA NWGAAA HHHHxx 4899 4642 1 3 9 19 99 899 899 4899 4899 198 199 LGAAAA OWGAAA OOOOxx 7928 4643 0 0 8 8 28 928 1928 2928 7928 56 57 YSAAAA PWGAAA VVVVxx 4736 4644 0 0 6 16 36 736 736 4736 4736 72 73 EAAAAA QWGAAA AAAAxx 4317 4645 1 1 7 17 17 317 317 4317 4317 34 35 BKAAAA RWGAAA HHHHxx 1174 4646 0 2 4 14 74 174 1174 1174 1174 148 149 ETAAAA SWGAAA OOOOxx 6138 4647 0 2 8 18 38 138 138 1138 6138 76 77 CCAAAA TWGAAA VVVVxx 3943 4648 1 3 3 3 43 943 1943 3943 3943 86 87 RVAAAA UWGAAA AAAAxx 1545 4649 1 1 5 5 45 545 1545 1545 1545 90 91 LHAAAA VWGAAA HHHHxx 6867 4650 1 3 7 7 67 867 867 1867 6867 134 135 DEAAAA WWGAAA OOOOxx 6832 4651 0 0 2 12 32 832 832 1832 6832 64 65 UCAAAA XWGAAA VVVVxx 2987 4652 1 3 7 7 87 987 987 2987 2987 174 175 XKAAAA YWGAAA AAAAxx 5169 4653 1 1 9 9 69 169 1169 169 5169 138 139 VQAAAA ZWGAAA HHHHxx 8998 4654 0 2 8 18 98 998 998 3998 8998 196 197 CIAAAA AXGAAA OOOOxx 9347 4655 1 3 7 7 47 347 1347 4347 9347 94 95 NVAAAA BXGAAA VVVVxx 4800 4656 0 0 0 0 0 800 800 4800 4800 0 1 QCAAAA CXGAAA AAAAxx 4200 4657 0 0 0 0 0 200 200 4200 4200 0 1 OFAAAA DXGAAA HHHHxx 4046 4658 0 2 6 6 46 46 46 4046 4046 92 93 QZAAAA EXGAAA OOOOxx 7142 4659 0 2 2 2 42 142 1142 2142 7142 84 85 SOAAAA FXGAAA VVVVxx 2733 4660 1 1 3 13 33 733 733 2733 2733 66 67 DBAAAA GXGAAA AAAAxx 1568 4661 0 0 8 8 68 568 1568 1568 1568 136 137 IIAAAA HXGAAA HHHHxx 5105 4662 1 1 5 5 5 105 1105 105 5105 10 11 JOAAAA IXGAAA OOOOxx 9115 4663 1 3 5 15 15 115 1115 4115 9115 30 31 PMAAAA JXGAAA VVVVxx 6475 4664 1 3 5 15 75 475 475 1475 6475 150 151 BPAAAA KXGAAA AAAAxx 3796 4665 0 0 6 16 96 796 1796 3796 3796 192 193 AQAAAA LXGAAA HHHHxx 5410 4666 0 2 0 10 10 410 1410 410 5410 20 21 CAAAAA MXGAAA OOOOxx 4023 4667 1 3 3 3 23 23 23 4023 4023 46 47 TYAAAA NXGAAA VVVVxx 8904 4668 0 0 4 4 4 904 904 3904 8904 8 9 MEAAAA OXGAAA AAAAxx 450 4669 0 2 0 10 50 450 450 450 450 100 101 IRAAAA PXGAAA HHHHxx 8087 4670 1 3 7 7 87 87 87 3087 8087 174 175 BZAAAA QXGAAA OOOOxx 6478 4671 0 2 8 18 78 478 478 1478 6478 156 157 EPAAAA RXGAAA VVVVxx 2696 4672 0 0 6 16 96 696 696 2696 2696 192 193 SZAAAA SXGAAA AAAAxx 1792 4673 0 0 2 12 92 792 1792 1792 1792 184 185 YQAAAA TXGAAA HHHHxx 9699 4674 1 3 9 19 99 699 1699 4699 9699 198 199 BJAAAA UXGAAA OOOOxx 9160 4675 0 0 0 0 60 160 1160 4160 9160 120 121 IOAAAA VXGAAA VVVVxx 9989 4676 1 1 9 9 89 989 1989 4989 9989 178 179 FUAAAA WXGAAA AAAAxx 9568 4677 0 0 8 8 68 568 1568 4568 9568 136 137 AEAAAA XXGAAA HHHHxx 487 4678 1 3 7 7 87 487 487 487 487 174 175 TSAAAA YXGAAA OOOOxx 7863 4679 1 3 3 3 63 863 1863 2863 7863 126 127 LQAAAA ZXGAAA VVVVxx 1884 4680 0 0 4 4 84 884 1884 1884 1884 168 169 MUAAAA AYGAAA AAAAxx 2651 4681 1 3 1 11 51 651 651 2651 2651 102 103 ZXAAAA BYGAAA HHHHxx 8285 4682 1 1 5 5 85 285 285 3285 8285 170 171 RGAAAA CYGAAA OOOOxx 3927 4683 1 3 7 7 27 927 1927 3927 3927 54 55 BVAAAA DYGAAA VVVVxx 4076 4684 0 0 6 16 76 76 76 4076 4076 152 153 UAAAAA EYGAAA AAAAxx 6149 4685 1 1 9 9 49 149 149 1149 6149 98 99 NCAAAA FYGAAA HHHHxx 6581 4686 1 1 1 1 81 581 581 1581 6581 162 163 DTAAAA GYGAAA OOOOxx 8293 4687 1 1 3 13 93 293 293 3293 8293 186 187 ZGAAAA HYGAAA VVVVxx 7665 4688 1 1 5 5 65 665 1665 2665 7665 130 131 VIAAAA IYGAAA AAAAxx 4435 4689 1 3 5 15 35 435 435 4435 4435 70 71 POAAAA JYGAAA HHHHxx 1271 4690 1 3 1 11 71 271 1271 1271 1271 142 143 XWAAAA KYGAAA OOOOxx 3928 4691 0 0 8 8 28 928 1928 3928 3928 56 57 CVAAAA LYGAAA VVVVxx 7045 4692 1 1 5 5 45 45 1045 2045 7045 90 91 ZKAAAA MYGAAA AAAAxx 4943 4693 1 3 3 3 43 943 943 4943 4943 86 87 DIAAAA NYGAAA HHHHxx 8473 4694 1 1 3 13 73 473 473 3473 8473 146 147 XNAAAA OYGAAA OOOOxx 1707 4695 1 3 7 7 7 707 1707 1707 1707 14 15 RNAAAA PYGAAA VVVVxx 7509 4696 1 1 9 9 9 509 1509 2509 7509 18 19 VCAAAA QYGAAA AAAAxx 1593 4697 1 1 3 13 93 593 1593 1593 1593 186 187 HJAAAA RYGAAA HHHHxx 9281 4698 1 1 1 1 81 281 1281 4281 9281 162 163 ZSAAAA SYGAAA OOOOxx 8986 4699 0 2 6 6 86 986 986 3986 8986 172 173 QHAAAA TYGAAA VVVVxx 3740 4700 0 0 0 0 40 740 1740 3740 3740 80 81 WNAAAA UYGAAA AAAAxx 9265 4701 1 1 5 5 65 265 1265 4265 9265 130 131 JSAAAA VYGAAA HHHHxx 1510 4702 0 2 0 10 10 510 1510 1510 1510 20 21 CGAAAA WYGAAA OOOOxx 3022 4703 0 2 2 2 22 22 1022 3022 3022 44 45 GMAAAA XYGAAA VVVVxx 9014 4704 0 2 4 14 14 14 1014 4014 9014 28 29 SIAAAA YYGAAA AAAAxx 6816 4705 0 0 6 16 16 816 816 1816 6816 32 33 ECAAAA ZYGAAA HHHHxx 5518 4706 0 2 8 18 18 518 1518 518 5518 36 37 GEAAAA AZGAAA OOOOxx 4451 4707 1 3 1 11 51 451 451 4451 4451 102 103 FPAAAA BZGAAA VVVVxx 8747 4708 1 3 7 7 47 747 747 3747 8747 94 95 LYAAAA CZGAAA AAAAxx 4646 4709 0 2 6 6 46 646 646 4646 4646 92 93 SWAAAA DZGAAA HHHHxx 7296 4710 0 0 6 16 96 296 1296 2296 7296 192 193 QUAAAA EZGAAA OOOOxx 9644 4711 0 0 4 4 44 644 1644 4644 9644 88 89 YGAAAA FZGAAA VVVVxx 5977 4712 1 1 7 17 77 977 1977 977 5977 154 155 XVAAAA GZGAAA AAAAxx 6270 4713 0 2 0 10 70 270 270 1270 6270 140 141 EHAAAA HZGAAA HHHHxx 5578 4714 0 2 8 18 78 578 1578 578 5578 156 157 OGAAAA IZGAAA OOOOxx 2465 4715 1 1 5 5 65 465 465 2465 2465 130 131 VQAAAA JZGAAA VVVVxx 6436 4716 0 0 6 16 36 436 436 1436 6436 72 73 ONAAAA KZGAAA AAAAxx 8089 4717 1 1 9 9 89 89 89 3089 8089 178 179 DZAAAA LZGAAA HHHHxx 2409 4718 1 1 9 9 9 409 409 2409 2409 18 19 ROAAAA MZGAAA OOOOxx 284 4719 0 0 4 4 84 284 284 284 284 168 169 YKAAAA NZGAAA VVVVxx 5576 4720 0 0 6 16 76 576 1576 576 5576 152 153 MGAAAA OZGAAA AAAAxx 6534 4721 0 2 4 14 34 534 534 1534 6534 68 69 IRAAAA PZGAAA HHHHxx 8848 4722 0 0 8 8 48 848 848 3848 8848 96 97 ICAAAA QZGAAA OOOOxx 4305 4723 1 1 5 5 5 305 305 4305 4305 10 11 PJAAAA RZGAAA VVVVxx 5574 4724 0 2 4 14 74 574 1574 574 5574 148 149 KGAAAA SZGAAA AAAAxx 596 4725 0 0 6 16 96 596 596 596 596 192 193 YWAAAA TZGAAA HHHHxx 1253 4726 1 1 3 13 53 253 1253 1253 1253 106 107 FWAAAA UZGAAA OOOOxx 521 4727 1 1 1 1 21 521 521 521 521 42 43 BUAAAA VZGAAA VVVVxx 8739 4728 1 3 9 19 39 739 739 3739 8739 78 79 DYAAAA WZGAAA AAAAxx 908 4729 0 0 8 8 8 908 908 908 908 16 17 YIAAAA XZGAAA HHHHxx 6937 4730 1 1 7 17 37 937 937 1937 6937 74 75 VGAAAA YZGAAA OOOOxx 4515 4731 1 3 5 15 15 515 515 4515 4515 30 31 RRAAAA ZZGAAA VVVVxx 8630 4732 0 2 0 10 30 630 630 3630 8630 60 61 YTAAAA AAHAAA AAAAxx 7518 4733 0 2 8 18 18 518 1518 2518 7518 36 37 EDAAAA BAHAAA HHHHxx 8300 4734 0 0 0 0 0 300 300 3300 8300 0 1 GHAAAA CAHAAA OOOOxx 8434 4735 0 2 4 14 34 434 434 3434 8434 68 69 KMAAAA DAHAAA VVVVxx 6000 4736 0 0 0 0 0 0 0 1000 6000 0 1 UWAAAA EAHAAA AAAAxx 4508 4737 0 0 8 8 8 508 508 4508 4508 16 17 KRAAAA FAHAAA HHHHxx 7861 4738 1 1 1 1 61 861 1861 2861 7861 122 123 JQAAAA GAHAAA OOOOxx 5953 4739 1 1 3 13 53 953 1953 953 5953 106 107 ZUAAAA HAHAAA VVVVxx 5063 4740 1 3 3 3 63 63 1063 63 5063 126 127 TMAAAA IAHAAA AAAAxx 4501 4741 1 1 1 1 1 501 501 4501 4501 2 3 DRAAAA JAHAAA HHHHxx 7092 4742 0 0 2 12 92 92 1092 2092 7092 184 185 UMAAAA KAHAAA OOOOxx 4388 4743 0 0 8 8 88 388 388 4388 4388 176 177 UMAAAA LAHAAA VVVVxx 1826 4744 0 2 6 6 26 826 1826 1826 1826 52 53 GSAAAA MAHAAA AAAAxx 568 4745 0 0 8 8 68 568 568 568 568 136 137 WVAAAA NAHAAA HHHHxx 8184 4746 0 0 4 4 84 184 184 3184 8184 168 169 UCAAAA OAHAAA OOOOxx 4268 4747 0 0 8 8 68 268 268 4268 4268 136 137 EIAAAA PAHAAA VVVVxx 5798 4748 0 2 8 18 98 798 1798 798 5798 196 197 APAAAA QAHAAA AAAAxx 5190 4749 0 2 0 10 90 190 1190 190 5190 180 181 QRAAAA RAHAAA HHHHxx 1298 4750 0 2 8 18 98 298 1298 1298 1298 196 197 YXAAAA SAHAAA OOOOxx 4035 4751 1 3 5 15 35 35 35 4035 4035 70 71 FZAAAA TAHAAA VVVVxx 4504 4752 0 0 4 4 4 504 504 4504 4504 8 9 GRAAAA UAHAAA AAAAxx 5992 4753 0 0 2 12 92 992 1992 992 5992 184 185 MWAAAA VAHAAA HHHHxx 770 4754 0 2 0 10 70 770 770 770 770 140 141 QDAAAA WAHAAA OOOOxx 7502 4755 0 2 2 2 2 502 1502 2502 7502 4 5 OCAAAA XAHAAA VVVVxx 824 4756 0 0 4 4 24 824 824 824 824 48 49 SFAAAA YAHAAA AAAAxx 7716 4757 0 0 6 16 16 716 1716 2716 7716 32 33 UKAAAA ZAHAAA HHHHxx 5749 4758 1 1 9 9 49 749 1749 749 5749 98 99 DNAAAA ABHAAA OOOOxx 9814 4759 0 2 4 14 14 814 1814 4814 9814 28 29 MNAAAA BBHAAA VVVVxx 350 4760 0 2 0 10 50 350 350 350 350 100 101 MNAAAA CBHAAA AAAAxx 1390 4761 0 2 0 10 90 390 1390 1390 1390 180 181 MBAAAA DBHAAA HHHHxx 6994 4762 0 2 4 14 94 994 994 1994 6994 188 189 AJAAAA EBHAAA OOOOxx 3629 4763 1 1 9 9 29 629 1629 3629 3629 58 59 PJAAAA FBHAAA VVVVxx 9937 4764 1 1 7 17 37 937 1937 4937 9937 74 75 FSAAAA GBHAAA AAAAxx 5285 4765 1 1 5 5 85 285 1285 285 5285 170 171 HVAAAA HBHAAA HHHHxx 3157 4766 1 1 7 17 57 157 1157 3157 3157 114 115 LRAAAA IBHAAA OOOOxx 9549 4767 1 1 9 9 49 549 1549 4549 9549 98 99 HDAAAA JBHAAA VVVVxx 4118 4768 0 2 8 18 18 118 118 4118 4118 36 37 KCAAAA KBHAAA AAAAxx 756 4769 0 0 6 16 56 756 756 756 756 112 113 CDAAAA LBHAAA HHHHxx 5964 4770 0 0 4 4 64 964 1964 964 5964 128 129 KVAAAA MBHAAA OOOOxx 7701 4771 1 1 1 1 1 701 1701 2701 7701 2 3 FKAAAA NBHAAA VVVVxx 1242 4772 0 2 2 2 42 242 1242 1242 1242 84 85 UVAAAA OBHAAA AAAAxx 7890 4773 0 2 0 10 90 890 1890 2890 7890 180 181 MRAAAA PBHAAA HHHHxx 1991 4774 1 3 1 11 91 991 1991 1991 1991 182 183 PYAAAA QBHAAA OOOOxx 110 4775 0 2 0 10 10 110 110 110 110 20 21 GEAAAA RBHAAA VVVVxx 9334 4776 0 2 4 14 34 334 1334 4334 9334 68 69 AVAAAA SBHAAA AAAAxx 6231 4777 1 3 1 11 31 231 231 1231 6231 62 63 RFAAAA TBHAAA HHHHxx 9871 4778 1 3 1 11 71 871 1871 4871 9871 142 143 RPAAAA UBHAAA OOOOxx 9471 4779 1 3 1 11 71 471 1471 4471 9471 142 143 HAAAAA VBHAAA VVVVxx 2697 4780 1 1 7 17 97 697 697 2697 2697 194 195 TZAAAA WBHAAA AAAAxx 4761 4781 1 1 1 1 61 761 761 4761 4761 122 123 DBAAAA XBHAAA HHHHxx 8493 4782 1 1 3 13 93 493 493 3493 8493 186 187 ROAAAA YBHAAA OOOOxx 1045 4783 1 1 5 5 45 45 1045 1045 1045 90 91 FOAAAA ZBHAAA VVVVxx 3403 4784 1 3 3 3 3 403 1403 3403 3403 6 7 XAAAAA ACHAAA AAAAxx 9412 4785 0 0 2 12 12 412 1412 4412 9412 24 25 AYAAAA BCHAAA HHHHxx 7652 4786 0 0 2 12 52 652 1652 2652 7652 104 105 IIAAAA CCHAAA OOOOxx 5866 4787 0 2 6 6 66 866 1866 866 5866 132 133 QRAAAA DCHAAA VVVVxx 6942 4788 0 2 2 2 42 942 942 1942 6942 84 85 AHAAAA ECHAAA AAAAxx 9353 4789 1 1 3 13 53 353 1353 4353 9353 106 107 TVAAAA FCHAAA HHHHxx 2600 4790 0 0 0 0 0 600 600 2600 2600 0 1 AWAAAA GCHAAA OOOOxx 6971 4791 1 3 1 11 71 971 971 1971 6971 142 143 DIAAAA HCHAAA VVVVxx 5391 4792 1 3 1 11 91 391 1391 391 5391 182 183 JZAAAA ICHAAA AAAAxx 7654 4793 0 2 4 14 54 654 1654 2654 7654 108 109 KIAAAA JCHAAA HHHHxx 1797 4794 1 1 7 17 97 797 1797 1797 1797 194 195 DRAAAA KCHAAA OOOOxx 4530 4795 0 2 0 10 30 530 530 4530 4530 60 61 GSAAAA LCHAAA VVVVxx 3130 4796 0 2 0 10 30 130 1130 3130 3130 60 61 KQAAAA MCHAAA AAAAxx 9442 4797 0 2 2 2 42 442 1442 4442 9442 84 85 EZAAAA NCHAAA HHHHxx 6659 4798 1 3 9 19 59 659 659 1659 6659 118 119 DWAAAA OCHAAA OOOOxx 9714 4799 0 2 4 14 14 714 1714 4714 9714 28 29 QJAAAA PCHAAA VVVVxx 3660 4800 0 0 0 0 60 660 1660 3660 3660 120 121 UKAAAA QCHAAA AAAAxx 1906 4801 0 2 6 6 6 906 1906 1906 1906 12 13 IVAAAA RCHAAA HHHHxx 7927 4802 1 3 7 7 27 927 1927 2927 7927 54 55 XSAAAA SCHAAA OOOOxx 1767 4803 1 3 7 7 67 767 1767 1767 1767 134 135 ZPAAAA TCHAAA VVVVxx 5523 4804 1 3 3 3 23 523 1523 523 5523 46 47 LEAAAA UCHAAA AAAAxx 9289 4805 1 1 9 9 89 289 1289 4289 9289 178 179 HTAAAA VCHAAA HHHHxx 2717 4806 1 1 7 17 17 717 717 2717 2717 34 35 NAAAAA WCHAAA OOOOxx 4099 4807 1 3 9 19 99 99 99 4099 4099 198 199 RBAAAA XCHAAA VVVVxx 4387 4808 1 3 7 7 87 387 387 4387 4387 174 175 TMAAAA YCHAAA AAAAxx 8864 4809 0 0 4 4 64 864 864 3864 8864 128 129 YCAAAA ZCHAAA HHHHxx 1774 4810 0 2 4 14 74 774 1774 1774 1774 148 149 GQAAAA ADHAAA OOOOxx 6292 4811 0 0 2 12 92 292 292 1292 6292 184 185 AIAAAA BDHAAA VVVVxx 847 4812 1 3 7 7 47 847 847 847 847 94 95 PGAAAA CDHAAA AAAAxx 5954 4813 0 2 4 14 54 954 1954 954 5954 108 109 AVAAAA DDHAAA HHHHxx 8032 4814 0 0 2 12 32 32 32 3032 8032 64 65 YWAAAA EDHAAA OOOOxx 3295 4815 1 3 5 15 95 295 1295 3295 3295 190 191 TWAAAA FDHAAA VVVVxx 8984 4816 0 0 4 4 84 984 984 3984 8984 168 169 OHAAAA GDHAAA AAAAxx 7809 4817 1 1 9 9 9 809 1809 2809 7809 18 19 JOAAAA HDHAAA HHHHxx 1670 4818 0 2 0 10 70 670 1670 1670 1670 140 141 GMAAAA IDHAAA OOOOxx 7733 4819 1 1 3 13 33 733 1733 2733 7733 66 67 LLAAAA JDHAAA VVVVxx 6187 4820 1 3 7 7 87 187 187 1187 6187 174 175 ZDAAAA KDHAAA AAAAxx 9326 4821 0 2 6 6 26 326 1326 4326 9326 52 53 SUAAAA LDHAAA HHHHxx 2493 4822 1 1 3 13 93 493 493 2493 2493 186 187 XRAAAA MDHAAA OOOOxx 9512 4823 0 0 2 12 12 512 1512 4512 9512 24 25 WBAAAA NDHAAA VVVVxx 4342 4824 0 2 2 2 42 342 342 4342 4342 84 85 ALAAAA ODHAAA AAAAxx 5350 4825 0 2 0 10 50 350 1350 350 5350 100 101 UXAAAA PDHAAA HHHHxx 6009 4826 1 1 9 9 9 9 9 1009 6009 18 19 DXAAAA QDHAAA OOOOxx 1208 4827 0 0 8 8 8 208 1208 1208 1208 16 17 MUAAAA RDHAAA VVVVxx 7014 4828 0 2 4 14 14 14 1014 2014 7014 28 29 UJAAAA SDHAAA AAAAxx 2967 4829 1 3 7 7 67 967 967 2967 2967 134 135 DKAAAA TDHAAA HHHHxx 5831 4830 1 3 1 11 31 831 1831 831 5831 62 63 HQAAAA UDHAAA OOOOxx 3097 4831 1 1 7 17 97 97 1097 3097 3097 194 195 DPAAAA VDHAAA VVVVxx 1528 4832 0 0 8 8 28 528 1528 1528 1528 56 57 UGAAAA WDHAAA AAAAxx 6429 4833 1 1 9 9 29 429 429 1429 6429 58 59 HNAAAA XDHAAA HHHHxx 7320 4834 0 0 0 0 20 320 1320 2320 7320 40 41 OVAAAA YDHAAA OOOOxx 844 4835 0 0 4 4 44 844 844 844 844 88 89 MGAAAA ZDHAAA VVVVxx 7054 4836 0 2 4 14 54 54 1054 2054 7054 108 109 ILAAAA AEHAAA AAAAxx 1643 4837 1 3 3 3 43 643 1643 1643 1643 86 87 FLAAAA BEHAAA HHHHxx 7626 4838 0 2 6 6 26 626 1626 2626 7626 52 53 IHAAAA CEHAAA OOOOxx 8728 4839 0 0 8 8 28 728 728 3728 8728 56 57 SXAAAA DEHAAA VVVVxx 8277 4840 1 1 7 17 77 277 277 3277 8277 154 155 JGAAAA EEHAAA AAAAxx 189 4841 1 1 9 9 89 189 189 189 189 178 179 HHAAAA FEHAAA HHHHxx 3717 4842 1 1 7 17 17 717 1717 3717 3717 34 35 ZMAAAA GEHAAA OOOOxx 1020 4843 0 0 0 0 20 20 1020 1020 1020 40 41 GNAAAA HEHAAA VVVVxx 9234 4844 0 2 4 14 34 234 1234 4234 9234 68 69 ERAAAA IEHAAA AAAAxx 9541 4845 1 1 1 1 41 541 1541 4541 9541 82 83 ZCAAAA JEHAAA HHHHxx 380 4846 0 0 0 0 80 380 380 380 380 160 161 QOAAAA KEHAAA OOOOxx 397 4847 1 1 7 17 97 397 397 397 397 194 195 HPAAAA LEHAAA VVVVxx 835 4848 1 3 5 15 35 835 835 835 835 70 71 DGAAAA MEHAAA AAAAxx 347 4849 1 3 7 7 47 347 347 347 347 94 95 JNAAAA NEHAAA HHHHxx 2490 4850 0 2 0 10 90 490 490 2490 2490 180 181 URAAAA OEHAAA OOOOxx 605 4851 1 1 5 5 5 605 605 605 605 10 11 HXAAAA PEHAAA VVVVxx 7960 4852 0 0 0 0 60 960 1960 2960 7960 120 121 EUAAAA QEHAAA AAAAxx 9681 4853 1 1 1 1 81 681 1681 4681 9681 162 163 JIAAAA REHAAA HHHHxx 5753 4854 1 1 3 13 53 753 1753 753 5753 106 107 HNAAAA SEHAAA OOOOxx 1676 4855 0 0 6 16 76 676 1676 1676 1676 152 153 MMAAAA TEHAAA VVVVxx 5533 4856 1 1 3 13 33 533 1533 533 5533 66 67 VEAAAA UEHAAA AAAAxx 8958 4857 0 2 8 18 58 958 958 3958 8958 116 117 OGAAAA VEHAAA HHHHxx 664 4858 0 0 4 4 64 664 664 664 664 128 129 OZAAAA WEHAAA OOOOxx 3005 4859 1 1 5 5 5 5 1005 3005 3005 10 11 PLAAAA XEHAAA VVVVxx 8576 4860 0 0 6 16 76 576 576 3576 8576 152 153 WRAAAA YEHAAA AAAAxx 7304 4861 0 0 4 4 4 304 1304 2304 7304 8 9 YUAAAA ZEHAAA HHHHxx 3375 4862 1 3 5 15 75 375 1375 3375 3375 150 151 VZAAAA AFHAAA OOOOxx 6336 4863 0 0 6 16 36 336 336 1336 6336 72 73 SJAAAA BFHAAA VVVVxx 1392 4864 0 0 2 12 92 392 1392 1392 1392 184 185 OBAAAA CFHAAA AAAAxx 2925 4865 1 1 5 5 25 925 925 2925 2925 50 51 NIAAAA DFHAAA HHHHxx 1217 4866 1 1 7 17 17 217 1217 1217 1217 34 35 VUAAAA EFHAAA OOOOxx 3714 4867 0 2 4 14 14 714 1714 3714 3714 28 29 WMAAAA FFHAAA VVVVxx 2120 4868 0 0 0 0 20 120 120 2120 2120 40 41 ODAAAA GFHAAA AAAAxx 2845 4869 1 1 5 5 45 845 845 2845 2845 90 91 LFAAAA HFHAAA HHHHxx 3865 4870 1 1 5 5 65 865 1865 3865 3865 130 131 RSAAAA IFHAAA OOOOxx 124 4871 0 0 4 4 24 124 124 124 124 48 49 UEAAAA JFHAAA VVVVxx 865 4872 1 1 5 5 65 865 865 865 865 130 131 HHAAAA KFHAAA AAAAxx 9361 4873 1 1 1 1 61 361 1361 4361 9361 122 123 BWAAAA LFHAAA HHHHxx 6338 4874 0 2 8 18 38 338 338 1338 6338 76 77 UJAAAA MFHAAA OOOOxx 7330 4875 0 2 0 10 30 330 1330 2330 7330 60 61 YVAAAA NFHAAA VVVVxx 513 4876 1 1 3 13 13 513 513 513 513 26 27 TTAAAA OFHAAA AAAAxx 5001 4877 1 1 1 1 1 1 1001 1 5001 2 3 JKAAAA PFHAAA HHHHxx 549 4878 1 1 9 9 49 549 549 549 549 98 99 DVAAAA QFHAAA OOOOxx 1808 4879 0 0 8 8 8 808 1808 1808 1808 16 17 ORAAAA RFHAAA VVVVxx 7168 4880 0 0 8 8 68 168 1168 2168 7168 136 137 SPAAAA SFHAAA AAAAxx 9878 4881 0 2 8 18 78 878 1878 4878 9878 156 157 YPAAAA TFHAAA HHHHxx 233 4882 1 1 3 13 33 233 233 233 233 66 67 ZIAAAA UFHAAA OOOOxx 4262 4883 0 2 2 2 62 262 262 4262 4262 124 125 YHAAAA VFHAAA VVVVxx 7998 4884 0 2 8 18 98 998 1998 2998 7998 196 197 QVAAAA WFHAAA AAAAxx 2419 4885 1 3 9 19 19 419 419 2419 2419 38 39 BPAAAA XFHAAA HHHHxx 9960 4886 0 0 0 0 60 960 1960 4960 9960 120 121 CTAAAA YFHAAA OOOOxx 3523 4887 1 3 3 3 23 523 1523 3523 3523 46 47 NFAAAA ZFHAAA VVVVxx 5440 4888 0 0 0 0 40 440 1440 440 5440 80 81 GBAAAA AGHAAA AAAAxx 3030 4889 0 2 0 10 30 30 1030 3030 3030 60 61 OMAAAA BGHAAA HHHHxx 2745 4890 1 1 5 5 45 745 745 2745 2745 90 91 PBAAAA CGHAAA OOOOxx 7175 4891 1 3 5 15 75 175 1175 2175 7175 150 151 ZPAAAA DGHAAA VVVVxx 640 4892 0 0 0 0 40 640 640 640 640 80 81 QYAAAA EGHAAA AAAAxx 1798 4893 0 2 8 18 98 798 1798 1798 1798 196 197 ERAAAA FGHAAA HHHHxx 7499 4894 1 3 9 19 99 499 1499 2499 7499 198 199 LCAAAA GGHAAA OOOOxx 1924 4895 0 0 4 4 24 924 1924 1924 1924 48 49 AWAAAA HGHAAA VVVVxx 1327 4896 1 3 7 7 27 327 1327 1327 1327 54 55 BZAAAA IGHAAA AAAAxx 73 4897 1 1 3 13 73 73 73 73 73 146 147 VCAAAA JGHAAA HHHHxx 9558 4898 0 2 8 18 58 558 1558 4558 9558 116 117 QDAAAA KGHAAA OOOOxx 818 4899 0 2 8 18 18 818 818 818 818 36 37 MFAAAA LGHAAA VVVVxx 9916 4900 0 0 6 16 16 916 1916 4916 9916 32 33 KRAAAA MGHAAA AAAAxx 2978 4901 0 2 8 18 78 978 978 2978 2978 156 157 OKAAAA NGHAAA HHHHxx 8469 4902 1 1 9 9 69 469 469 3469 8469 138 139 TNAAAA OGHAAA OOOOxx 9845 4903 1 1 5 5 45 845 1845 4845 9845 90 91 ROAAAA PGHAAA VVVVxx 2326 4904 0 2 6 6 26 326 326 2326 2326 52 53 MLAAAA QGHAAA AAAAxx 4032 4905 0 0 2 12 32 32 32 4032 4032 64 65 CZAAAA RGHAAA HHHHxx 5604 4906 0 0 4 4 4 604 1604 604 5604 8 9 OHAAAA SGHAAA OOOOxx 9610 4907 0 2 0 10 10 610 1610 4610 9610 20 21 QFAAAA TGHAAA VVVVxx 5101 4908 1 1 1 1 1 101 1101 101 5101 2 3 FOAAAA UGHAAA AAAAxx 7246 4909 0 2 6 6 46 246 1246 2246 7246 92 93 SSAAAA VGHAAA HHHHxx 1292 4910 0 0 2 12 92 292 1292 1292 1292 184 185 SXAAAA WGHAAA OOOOxx 6235 4911 1 3 5 15 35 235 235 1235 6235 70 71 VFAAAA XGHAAA VVVVxx 1733 4912 1 1 3 13 33 733 1733 1733 1733 66 67 ROAAAA YGHAAA AAAAxx 4647 4913 1 3 7 7 47 647 647 4647 4647 94 95 TWAAAA ZGHAAA HHHHxx 258 4914 0 2 8 18 58 258 258 258 258 116 117 YJAAAA AHHAAA OOOOxx 8438 4915 0 2 8 18 38 438 438 3438 8438 76 77 OMAAAA BHHAAA VVVVxx 7869 4916 1 1 9 9 69 869 1869 2869 7869 138 139 RQAAAA CHHAAA AAAAxx 9691 4917 1 3 1 11 91 691 1691 4691 9691 182 183 TIAAAA DHHAAA HHHHxx 5422 4918 0 2 2 2 22 422 1422 422 5422 44 45 OAAAAA EHHAAA OOOOxx 9630 4919 0 2 0 10 30 630 1630 4630 9630 60 61 KGAAAA FHHAAA VVVVxx 4439 4920 1 3 9 19 39 439 439 4439 4439 78 79 TOAAAA GHHAAA AAAAxx 3140 4921 0 0 0 0 40 140 1140 3140 3140 80 81 UQAAAA HHHAAA HHHHxx 9111 4922 1 3 1 11 11 111 1111 4111 9111 22 23 LMAAAA IHHAAA OOOOxx 4606 4923 0 2 6 6 6 606 606 4606 4606 12 13 EVAAAA JHHAAA VVVVxx 8620 4924 0 0 0 0 20 620 620 3620 8620 40 41 OTAAAA KHHAAA AAAAxx 7849 4925 1 1 9 9 49 849 1849 2849 7849 98 99 XPAAAA LHHAAA HHHHxx 346 4926 0 2 6 6 46 346 346 346 346 92 93 INAAAA MHHAAA OOOOxx 9528 4927 0 0 8 8 28 528 1528 4528 9528 56 57 MCAAAA NHHAAA VVVVxx 1811 4928 1 3 1 11 11 811 1811 1811 1811 22 23 RRAAAA OHHAAA AAAAxx 6068 4929 0 0 8 8 68 68 68 1068 6068 136 137 KZAAAA PHHAAA HHHHxx 6260 4930 0 0 0 0 60 260 260 1260 6260 120 121 UGAAAA QHHAAA OOOOxx 5909 4931 1 1 9 9 9 909 1909 909 5909 18 19 HTAAAA RHHAAA VVVVxx 4518 4932 0 2 8 18 18 518 518 4518 4518 36 37 URAAAA SHHAAA AAAAxx 7530 4933 0 2 0 10 30 530 1530 2530 7530 60 61 QDAAAA THHAAA HHHHxx 3900 4934 0 0 0 0 0 900 1900 3900 3900 0 1 AUAAAA UHHAAA OOOOxx 3969 4935 1 1 9 9 69 969 1969 3969 3969 138 139 RWAAAA VHHAAA VVVVxx 8690 4936 0 2 0 10 90 690 690 3690 8690 180 181 GWAAAA WHHAAA AAAAxx 5532 4937 0 0 2 12 32 532 1532 532 5532 64 65 UEAAAA XHHAAA HHHHxx 5989 4938 1 1 9 9 89 989 1989 989 5989 178 179 JWAAAA YHHAAA OOOOxx 1870 4939 0 2 0 10 70 870 1870 1870 1870 140 141 YTAAAA ZHHAAA VVVVxx 1113 4940 1 1 3 13 13 113 1113 1113 1113 26 27 VQAAAA AIHAAA AAAAxx 5155 4941 1 3 5 15 55 155 1155 155 5155 110 111 HQAAAA BIHAAA HHHHxx 7460 4942 0 0 0 0 60 460 1460 2460 7460 120 121 YAAAAA CIHAAA OOOOxx 6217 4943 1 1 7 17 17 217 217 1217 6217 34 35 DFAAAA DIHAAA VVVVxx 8333 4944 1 1 3 13 33 333 333 3333 8333 66 67 NIAAAA EIHAAA AAAAxx 6341 4945 1 1 1 1 41 341 341 1341 6341 82 83 XJAAAA FIHAAA HHHHxx 6230 4946 0 2 0 10 30 230 230 1230 6230 60 61 QFAAAA GIHAAA OOOOxx 6902 4947 0 2 2 2 2 902 902 1902 6902 4 5 MFAAAA HIHAAA VVVVxx 670 4948 0 2 0 10 70 670 670 670 670 140 141 UZAAAA IIHAAA AAAAxx 805 4949 1 1 5 5 5 805 805 805 805 10 11 ZEAAAA JIHAAA HHHHxx 1340 4950 0 0 0 0 40 340 1340 1340 1340 80 81 OZAAAA KIHAAA OOOOxx 8649 4951 1 1 9 9 49 649 649 3649 8649 98 99 RUAAAA LIHAAA VVVVxx 3887 4952 1 3 7 7 87 887 1887 3887 3887 174 175 NTAAAA MIHAAA AAAAxx 5400 4953 0 0 0 0 0 400 1400 400 5400 0 1 SZAAAA NIHAAA HHHHxx 4354 4954 0 2 4 14 54 354 354 4354 4354 108 109 MLAAAA OIHAAA OOOOxx 950 4955 0 2 0 10 50 950 950 950 950 100 101 OKAAAA PIHAAA VVVVxx 1544 4956 0 0 4 4 44 544 1544 1544 1544 88 89 KHAAAA QIHAAA AAAAxx 3898 4957 0 2 8 18 98 898 1898 3898 3898 196 197 YTAAAA RIHAAA HHHHxx 8038 4958 0 2 8 18 38 38 38 3038 8038 76 77 EXAAAA SIHAAA OOOOxx 1095 4959 1 3 5 15 95 95 1095 1095 1095 190 191 DQAAAA TIHAAA VVVVxx 1748 4960 0 0 8 8 48 748 1748 1748 1748 96 97 GPAAAA UIHAAA AAAAxx 9154 4961 0 2 4 14 54 154 1154 4154 9154 108 109 COAAAA VIHAAA HHHHxx 2182 4962 0 2 2 2 82 182 182 2182 2182 164 165 YFAAAA WIHAAA OOOOxx 6797 4963 1 1 7 17 97 797 797 1797 6797 194 195 LBAAAA XIHAAA VVVVxx 9149 4964 1 1 9 9 49 149 1149 4149 9149 98 99 XNAAAA YIHAAA AAAAxx 7351 4965 1 3 1 11 51 351 1351 2351 7351 102 103 TWAAAA ZIHAAA HHHHxx 2820 4966 0 0 0 0 20 820 820 2820 2820 40 41 MEAAAA AJHAAA OOOOxx 9696 4967 0 0 6 16 96 696 1696 4696 9696 192 193 YIAAAA BJHAAA VVVVxx 253 4968 1 1 3 13 53 253 253 253 253 106 107 TJAAAA CJHAAA AAAAxx 3600 4969 0 0 0 0 0 600 1600 3600 3600 0 1 MIAAAA DJHAAA HHHHxx 3892 4970 0 0 2 12 92 892 1892 3892 3892 184 185 STAAAA EJHAAA OOOOxx 231 4971 1 3 1 11 31 231 231 231 231 62 63 XIAAAA FJHAAA VVVVxx 8331 4972 1 3 1 11 31 331 331 3331 8331 62 63 LIAAAA GJHAAA AAAAxx 403 4973 1 3 3 3 3 403 403 403 403 6 7 NPAAAA HJHAAA HHHHxx 8642 4974 0 2 2 2 42 642 642 3642 8642 84 85 KUAAAA IJHAAA OOOOxx 3118 4975 0 2 8 18 18 118 1118 3118 3118 36 37 YPAAAA JJHAAA VVVVxx 3835 4976 1 3 5 15 35 835 1835 3835 3835 70 71 NRAAAA KJHAAA AAAAxx 1117 4977 1 1 7 17 17 117 1117 1117 1117 34 35 ZQAAAA LJHAAA HHHHxx 7024 4978 0 0 4 4 24 24 1024 2024 7024 48 49 EKAAAA MJHAAA OOOOxx 2636 4979 0 0 6 16 36 636 636 2636 2636 72 73 KXAAAA NJHAAA VVVVxx 3778 4980 0 2 8 18 78 778 1778 3778 3778 156 157 IPAAAA OJHAAA AAAAxx 2003 4981 1 3 3 3 3 3 3 2003 2003 6 7 BZAAAA PJHAAA HHHHxx 5717 4982 1 1 7 17 17 717 1717 717 5717 34 35 XLAAAA QJHAAA OOOOxx 4869 4983 1 1 9 9 69 869 869 4869 4869 138 139 HFAAAA RJHAAA VVVVxx 8921 4984 1 1 1 1 21 921 921 3921 8921 42 43 DFAAAA SJHAAA AAAAxx 888 4985 0 0 8 8 88 888 888 888 888 176 177 EIAAAA TJHAAA HHHHxx 7599 4986 1 3 9 19 99 599 1599 2599 7599 198 199 HGAAAA UJHAAA OOOOxx 8621 4987 1 1 1 1 21 621 621 3621 8621 42 43 PTAAAA VJHAAA VVVVxx 811 4988 1 3 1 11 11 811 811 811 811 22 23 FFAAAA WJHAAA AAAAxx 9147 4989 1 3 7 7 47 147 1147 4147 9147 94 95 VNAAAA XJHAAA HHHHxx 1413 4990 1 1 3 13 13 413 1413 1413 1413 26 27 JCAAAA YJHAAA OOOOxx 5232 4991 0 0 2 12 32 232 1232 232 5232 64 65 GTAAAA ZJHAAA VVVVxx 5912 4992 0 0 2 12 12 912 1912 912 5912 24 25 KTAAAA AKHAAA AAAAxx 3418 4993 0 2 8 18 18 418 1418 3418 3418 36 37 MBAAAA BKHAAA HHHHxx 3912 4994 0 0 2 12 12 912 1912 3912 3912 24 25 MUAAAA CKHAAA OOOOxx 9576 4995 0 0 6 16 76 576 1576 4576 9576 152 153 IEAAAA DKHAAA VVVVxx 4225 4996 1 1 5 5 25 225 225 4225 4225 50 51 NGAAAA EKHAAA AAAAxx 8222 4997 0 2 2 2 22 222 222 3222 8222 44 45 GEAAAA FKHAAA HHHHxx 7013 4998 1 1 3 13 13 13 1013 2013 7013 26 27 TJAAAA GKHAAA OOOOxx 7037 4999 1 1 7 17 37 37 1037 2037 7037 74 75 RKAAAA HKHAAA VVVVxx 1205 5000 1 1 5 5 5 205 1205 1205 1205 10 11 JUAAAA IKHAAA AAAAxx 8114 5001 0 2 4 14 14 114 114 3114 8114 28 29 CAAAAA JKHAAA HHHHxx 6585 5002 1 1 5 5 85 585 585 1585 6585 170 171 HTAAAA KKHAAA OOOOxx 155 5003 1 3 5 15 55 155 155 155 155 110 111 ZFAAAA LKHAAA VVVVxx 2841 5004 1 1 1 1 41 841 841 2841 2841 82 83 HFAAAA MKHAAA AAAAxx 1996 5005 0 0 6 16 96 996 1996 1996 1996 192 193 UYAAAA NKHAAA HHHHxx 4948 5006 0 0 8 8 48 948 948 4948 4948 96 97 IIAAAA OKHAAA OOOOxx 3304 5007 0 0 4 4 4 304 1304 3304 3304 8 9 CXAAAA PKHAAA VVVVxx 5684 5008 0 0 4 4 84 684 1684 684 5684 168 169 QKAAAA QKHAAA AAAAxx 6962 5009 0 2 2 2 62 962 962 1962 6962 124 125 UHAAAA RKHAAA HHHHxx 8691 5010 1 3 1 11 91 691 691 3691 8691 182 183 HWAAAA SKHAAA OOOOxx 8501 5011 1 1 1 1 1 501 501 3501 8501 2 3 ZOAAAA TKHAAA VVVVxx 4783 5012 1 3 3 3 83 783 783 4783 4783 166 167 ZBAAAA UKHAAA AAAAxx 3762 5013 0 2 2 2 62 762 1762 3762 3762 124 125 SOAAAA VKHAAA HHHHxx 4534 5014 0 2 4 14 34 534 534 4534 4534 68 69 KSAAAA WKHAAA OOOOxx 4999 5015 1 3 9 19 99 999 999 4999 4999 198 199 HKAAAA XKHAAA VVVVxx 4618 5016 0 2 8 18 18 618 618 4618 4618 36 37 QVAAAA YKHAAA AAAAxx 4220 5017 0 0 0 0 20 220 220 4220 4220 40 41 IGAAAA ZKHAAA HHHHxx 3384 5018 0 0 4 4 84 384 1384 3384 3384 168 169 EAAAAA ALHAAA OOOOxx 3036 5019 0 0 6 16 36 36 1036 3036 3036 72 73 UMAAAA BLHAAA VVVVxx 545 5020 1 1 5 5 45 545 545 545 545 90 91 ZUAAAA CLHAAA AAAAxx 9946 5021 0 2 6 6 46 946 1946 4946 9946 92 93 OSAAAA DLHAAA HHHHxx 1985 5022 1 1 5 5 85 985 1985 1985 1985 170 171 JYAAAA ELHAAA OOOOxx 2310 5023 0 2 0 10 10 310 310 2310 2310 20 21 WKAAAA FLHAAA VVVVxx 6563 5024 1 3 3 3 63 563 563 1563 6563 126 127 LSAAAA GLHAAA AAAAxx 4886 5025 0 2 6 6 86 886 886 4886 4886 172 173 YFAAAA HLHAAA HHHHxx 9359 5026 1 3 9 19 59 359 1359 4359 9359 118 119 ZVAAAA ILHAAA OOOOxx 400 5027 0 0 0 0 0 400 400 400 400 0 1 KPAAAA JLHAAA VVVVxx 9742 5028 0 2 2 2 42 742 1742 4742 9742 84 85 SKAAAA KLHAAA AAAAxx 6736 5029 0 0 6 16 36 736 736 1736 6736 72 73 CZAAAA LLHAAA HHHHxx 8166 5030 0 2 6 6 66 166 166 3166 8166 132 133 CCAAAA MLHAAA OOOOxx 861 5031 1 1 1 1 61 861 861 861 861 122 123 DHAAAA NLHAAA VVVVxx 7492 5032 0 0 2 12 92 492 1492 2492 7492 184 185 ECAAAA OLHAAA AAAAxx 1155 5033 1 3 5 15 55 155 1155 1155 1155 110 111 LSAAAA PLHAAA HHHHxx 9769 5034 1 1 9 9 69 769 1769 4769 9769 138 139 TLAAAA QLHAAA OOOOxx 6843 5035 1 3 3 3 43 843 843 1843 6843 86 87 FDAAAA RLHAAA VVVVxx 5625 5036 1 1 5 5 25 625 1625 625 5625 50 51 JIAAAA SLHAAA AAAAxx 1910 5037 0 2 0 10 10 910 1910 1910 1910 20 21 MVAAAA TLHAAA HHHHxx 9796 5038 0 0 6 16 96 796 1796 4796 9796 192 193 UMAAAA ULHAAA OOOOxx 6950 5039 0 2 0 10 50 950 950 1950 6950 100 101 IHAAAA VLHAAA VVVVxx 3084 5040 0 0 4 4 84 84 1084 3084 3084 168 169 QOAAAA WLHAAA AAAAxx 2959 5041 1 3 9 19 59 959 959 2959 2959 118 119 VJAAAA XLHAAA HHHHxx 2093 5042 1 1 3 13 93 93 93 2093 2093 186 187 NCAAAA YLHAAA OOOOxx 2738 5043 0 2 8 18 38 738 738 2738 2738 76 77 IBAAAA ZLHAAA VVVVxx 6406 5044 0 2 6 6 6 406 406 1406 6406 12 13 KMAAAA AMHAAA AAAAxx 9082 5045 0 2 2 2 82 82 1082 4082 9082 164 165 ILAAAA BMHAAA HHHHxx 8568 5046 0 0 8 8 68 568 568 3568 8568 136 137 ORAAAA CMHAAA OOOOxx 3566 5047 0 2 6 6 66 566 1566 3566 3566 132 133 EHAAAA DMHAAA VVVVxx 3016 5048 0 0 6 16 16 16 1016 3016 3016 32 33 AMAAAA EMHAAA AAAAxx 1207 5049 1 3 7 7 7 207 1207 1207 1207 14 15 LUAAAA FMHAAA HHHHxx 4045 5050 1 1 5 5 45 45 45 4045 4045 90 91 PZAAAA GMHAAA OOOOxx 4173 5051 1 1 3 13 73 173 173 4173 4173 146 147 NEAAAA HMHAAA VVVVxx 3939 5052 1 3 9 19 39 939 1939 3939 3939 78 79 NVAAAA IMHAAA AAAAxx 9683 5053 1 3 3 3 83 683 1683 4683 9683 166 167 LIAAAA JMHAAA HHHHxx 1684 5054 0 0 4 4 84 684 1684 1684 1684 168 169 UMAAAA KMHAAA OOOOxx 9271 5055 1 3 1 11 71 271 1271 4271 9271 142 143 PSAAAA LMHAAA VVVVxx 9317 5056 1 1 7 17 17 317 1317 4317 9317 34 35 JUAAAA MMHAAA AAAAxx 5793 5057 1 1 3 13 93 793 1793 793 5793 186 187 VOAAAA NMHAAA HHHHxx 352 5058 0 0 2 12 52 352 352 352 352 104 105 ONAAAA OMHAAA OOOOxx 7328 5059 0 0 8 8 28 328 1328 2328 7328 56 57 WVAAAA PMHAAA VVVVxx 4582 5060 0 2 2 2 82 582 582 4582 4582 164 165 GUAAAA QMHAAA AAAAxx 7413 5061 1 1 3 13 13 413 1413 2413 7413 26 27 DZAAAA RMHAAA HHHHxx 6772 5062 0 0 2 12 72 772 772 1772 6772 144 145 MAAAAA SMHAAA OOOOxx 4973 5063 1 1 3 13 73 973 973 4973 4973 146 147 HJAAAA TMHAAA VVVVxx 7480 5064 0 0 0 0 80 480 1480 2480 7480 160 161 SBAAAA UMHAAA AAAAxx 5555 5065 1 3 5 15 55 555 1555 555 5555 110 111 RFAAAA VMHAAA HHHHxx 4227 5066 1 3 7 7 27 227 227 4227 4227 54 55 PGAAAA WMHAAA OOOOxx 4153 5067 1 1 3 13 53 153 153 4153 4153 106 107 TDAAAA XMHAAA VVVVxx 4601 5068 1 1 1 1 1 601 601 4601 4601 2 3 ZUAAAA YMHAAA AAAAxx 3782 5069 0 2 2 2 82 782 1782 3782 3782 164 165 MPAAAA ZMHAAA HHHHxx 3872 5070 0 0 2 12 72 872 1872 3872 3872 144 145 YSAAAA ANHAAA OOOOxx 893 5071 1 1 3 13 93 893 893 893 893 186 187 JIAAAA BNHAAA VVVVxx 2430 5072 0 2 0 10 30 430 430 2430 2430 60 61 MPAAAA CNHAAA AAAAxx 2591 5073 1 3 1 11 91 591 591 2591 2591 182 183 RVAAAA DNHAAA HHHHxx 264 5074 0 0 4 4 64 264 264 264 264 128 129 EKAAAA ENHAAA OOOOxx 6238 5075 0 2 8 18 38 238 238 1238 6238 76 77 YFAAAA FNHAAA VVVVxx 633 5076 1 1 3 13 33 633 633 633 633 66 67 JYAAAA GNHAAA AAAAxx 1029 5077 1 1 9 9 29 29 1029 1029 1029 58 59 PNAAAA HNHAAA HHHHxx 5934 5078 0 2 4 14 34 934 1934 934 5934 68 69 GUAAAA INHAAA OOOOxx 8694 5079 0 2 4 14 94 694 694 3694 8694 188 189 KWAAAA JNHAAA VVVVxx 7401 5080 1 1 1 1 1 401 1401 2401 7401 2 3 RYAAAA KNHAAA AAAAxx 1165 5081 1 1 5 5 65 165 1165 1165 1165 130 131 VSAAAA LNHAAA HHHHxx 9438 5082 0 2 8 18 38 438 1438 4438 9438 76 77 AZAAAA MNHAAA OOOOxx 4790 5083 0 2 0 10 90 790 790 4790 4790 180 181 GCAAAA NNHAAA VVVVxx 4531 5084 1 3 1 11 31 531 531 4531 4531 62 63 HSAAAA ONHAAA AAAAxx 6099 5085 1 3 9 19 99 99 99 1099 6099 198 199 PAAAAA PNHAAA HHHHxx 8236 5086 0 0 6 16 36 236 236 3236 8236 72 73 UEAAAA QNHAAA OOOOxx 8551 5087 1 3 1 11 51 551 551 3551 8551 102 103 XQAAAA RNHAAA VVVVxx 3128 5088 0 0 8 8 28 128 1128 3128 3128 56 57 IQAAAA SNHAAA AAAAxx 3504 5089 0 0 4 4 4 504 1504 3504 3504 8 9 UEAAAA TNHAAA HHHHxx 9071 5090 1 3 1 11 71 71 1071 4071 9071 142 143 XKAAAA UNHAAA OOOOxx 5930 5091 0 2 0 10 30 930 1930 930 5930 60 61 CUAAAA VNHAAA VVVVxx 6825 5092 1 1 5 5 25 825 825 1825 6825 50 51 NCAAAA WNHAAA AAAAxx 2218 5093 0 2 8 18 18 218 218 2218 2218 36 37 IHAAAA XNHAAA HHHHxx 3604 5094 0 0 4 4 4 604 1604 3604 3604 8 9 QIAAAA YNHAAA OOOOxx 5761 5095 1 1 1 1 61 761 1761 761 5761 122 123 PNAAAA ZNHAAA VVVVxx 5414 5096 0 2 4 14 14 414 1414 414 5414 28 29 GAAAAA AOHAAA AAAAxx 5892 5097 0 0 2 12 92 892 1892 892 5892 184 185 QSAAAA BOHAAA HHHHxx 4080 5098 0 0 0 0 80 80 80 4080 4080 160 161 YAAAAA COHAAA OOOOxx 8018 5099 0 2 8 18 18 18 18 3018 8018 36 37 KWAAAA DOHAAA VVVVxx 1757 5100 1 1 7 17 57 757 1757 1757 1757 114 115 PPAAAA EOHAAA AAAAxx 5854 5101 0 2 4 14 54 854 1854 854 5854 108 109 ERAAAA FOHAAA HHHHxx 1335 5102 1 3 5 15 35 335 1335 1335 1335 70 71 JZAAAA GOHAAA OOOOxx 3811 5103 1 3 1 11 11 811 1811 3811 3811 22 23 PQAAAA HOHAAA VVVVxx 9917 5104 1 1 7 17 17 917 1917 4917 9917 34 35 LRAAAA IOHAAA AAAAxx 5947 5105 1 3 7 7 47 947 1947 947 5947 94 95 TUAAAA JOHAAA HHHHxx 7263 5106 1 3 3 3 63 263 1263 2263 7263 126 127 JTAAAA KOHAAA OOOOxx 1730 5107 0 2 0 10 30 730 1730 1730 1730 60 61 OOAAAA LOHAAA VVVVxx 5747 5108 1 3 7 7 47 747 1747 747 5747 94 95 BNAAAA MOHAAA AAAAxx 3876 5109 0 0 6 16 76 876 1876 3876 3876 152 153 CTAAAA NOHAAA HHHHxx 2762 5110 0 2 2 2 62 762 762 2762 2762 124 125 GCAAAA OOHAAA OOOOxx 7613 5111 1 1 3 13 13 613 1613 2613 7613 26 27 VGAAAA POHAAA VVVVxx 152 5112 0 0 2 12 52 152 152 152 152 104 105 WFAAAA QOHAAA AAAAxx 3941 5113 1 1 1 1 41 941 1941 3941 3941 82 83 PVAAAA ROHAAA HHHHxx 5614 5114 0 2 4 14 14 614 1614 614 5614 28 29 YHAAAA SOHAAA OOOOxx 9279 5115 1 3 9 19 79 279 1279 4279 9279 158 159 XSAAAA TOHAAA VVVVxx 3048 5116 0 0 8 8 48 48 1048 3048 3048 96 97 GNAAAA UOHAAA AAAAxx 6152 5117 0 0 2 12 52 152 152 1152 6152 104 105 QCAAAA VOHAAA HHHHxx 5481 5118 1 1 1 1 81 481 1481 481 5481 162 163 VCAAAA WOHAAA OOOOxx 4675 5119 1 3 5 15 75 675 675 4675 4675 150 151 VXAAAA XOHAAA VVVVxx 3334 5120 0 2 4 14 34 334 1334 3334 3334 68 69 GYAAAA YOHAAA AAAAxx 4691 5121 1 3 1 11 91 691 691 4691 4691 182 183 LYAAAA ZOHAAA HHHHxx 803 5122 1 3 3 3 3 803 803 803 803 6 7 XEAAAA APHAAA OOOOxx 5409 5123 1 1 9 9 9 409 1409 409 5409 18 19 BAAAAA BPHAAA VVVVxx 1054 5124 0 2 4 14 54 54 1054 1054 1054 108 109 OOAAAA CPHAAA AAAAxx 103 5125 1 3 3 3 3 103 103 103 103 6 7 ZDAAAA DPHAAA HHHHxx 8565 5126 1 1 5 5 65 565 565 3565 8565 130 131 LRAAAA EPHAAA OOOOxx 4666 5127 0 2 6 6 66 666 666 4666 4666 132 133 MXAAAA FPHAAA VVVVxx 6634 5128 0 2 4 14 34 634 634 1634 6634 68 69 EVAAAA GPHAAA AAAAxx 5538 5129 0 2 8 18 38 538 1538 538 5538 76 77 AFAAAA HPHAAA HHHHxx 3789 5130 1 1 9 9 89 789 1789 3789 3789 178 179 TPAAAA IPHAAA OOOOxx 4641 5131 1 1 1 1 41 641 641 4641 4641 82 83 NWAAAA JPHAAA VVVVxx 2458 5132 0 2 8 18 58 458 458 2458 2458 116 117 OQAAAA KPHAAA AAAAxx 5667 5133 1 3 7 7 67 667 1667 667 5667 134 135 ZJAAAA LPHAAA HHHHxx 6524 5134 0 0 4 4 24 524 524 1524 6524 48 49 YQAAAA MPHAAA OOOOxx 9179 5135 1 3 9 19 79 179 1179 4179 9179 158 159 BPAAAA NPHAAA VVVVxx 6358 5136 0 2 8 18 58 358 358 1358 6358 116 117 OKAAAA OPHAAA AAAAxx 6668 5137 0 0 8 8 68 668 668 1668 6668 136 137 MWAAAA PPHAAA HHHHxx 6414 5138 0 2 4 14 14 414 414 1414 6414 28 29 SMAAAA QPHAAA OOOOxx 2813 5139 1 1 3 13 13 813 813 2813 2813 26 27 FEAAAA RPHAAA VVVVxx 8927 5140 1 3 7 7 27 927 927 3927 8927 54 55 JFAAAA SPHAAA AAAAxx 8695 5141 1 3 5 15 95 695 695 3695 8695 190 191 LWAAAA TPHAAA HHHHxx 363 5142 1 3 3 3 63 363 363 363 363 126 127 ZNAAAA UPHAAA OOOOxx 9966 5143 0 2 6 6 66 966 1966 4966 9966 132 133 ITAAAA VPHAAA VVVVxx 1323 5144 1 3 3 3 23 323 1323 1323 1323 46 47 XYAAAA WPHAAA AAAAxx 8211 5145 1 3 1 11 11 211 211 3211 8211 22 23 VDAAAA XPHAAA HHHHxx 4375 5146 1 3 5 15 75 375 375 4375 4375 150 151 HMAAAA YPHAAA OOOOxx 3257 5147 1 1 7 17 57 257 1257 3257 3257 114 115 HVAAAA ZPHAAA VVVVxx 6239 5148 1 3 9 19 39 239 239 1239 6239 78 79 ZFAAAA AQHAAA AAAAxx 3602 5149 0 2 2 2 2 602 1602 3602 3602 4 5 OIAAAA BQHAAA HHHHxx 9830 5150 0 2 0 10 30 830 1830 4830 9830 60 61 COAAAA CQHAAA OOOOxx 7826 5151 0 2 6 6 26 826 1826 2826 7826 52 53 APAAAA DQHAAA VVVVxx 2108 5152 0 0 8 8 8 108 108 2108 2108 16 17 CDAAAA EQHAAA AAAAxx 7245 5153 1 1 5 5 45 245 1245 2245 7245 90 91 RSAAAA FQHAAA HHHHxx 8330 5154 0 2 0 10 30 330 330 3330 8330 60 61 KIAAAA GQHAAA OOOOxx 7441 5155 1 1 1 1 41 441 1441 2441 7441 82 83 FAAAAA HQHAAA VVVVxx 9848 5156 0 0 8 8 48 848 1848 4848 9848 96 97 UOAAAA IQHAAA AAAAxx 1226 5157 0 2 6 6 26 226 1226 1226 1226 52 53 EVAAAA JQHAAA HHHHxx 414 5158 0 2 4 14 14 414 414 414 414 28 29 YPAAAA KQHAAA OOOOxx 1273 5159 1 1 3 13 73 273 1273 1273 1273 146 147 ZWAAAA LQHAAA VVVVxx 9866 5160 0 2 6 6 66 866 1866 4866 9866 132 133 MPAAAA MQHAAA AAAAxx 4633 5161 1 1 3 13 33 633 633 4633 4633 66 67 FWAAAA NQHAAA HHHHxx 8727 5162 1 3 7 7 27 727 727 3727 8727 54 55 RXAAAA OQHAAA OOOOxx 5308 5163 0 0 8 8 8 308 1308 308 5308 16 17 EWAAAA PQHAAA VVVVxx 1395 5164 1 3 5 15 95 395 1395 1395 1395 190 191 RBAAAA QQHAAA AAAAxx 1825 5165 1 1 5 5 25 825 1825 1825 1825 50 51 FSAAAA RQHAAA HHHHxx 7606 5166 0 2 6 6 6 606 1606 2606 7606 12 13 OGAAAA SQHAAA OOOOxx 9390 5167 0 2 0 10 90 390 1390 4390 9390 180 181 EXAAAA TQHAAA VVVVxx 2376 5168 0 0 6 16 76 376 376 2376 2376 152 153 KNAAAA UQHAAA AAAAxx 2377 5169 1 1 7 17 77 377 377 2377 2377 154 155 LNAAAA VQHAAA HHHHxx 5346 5170 0 2 6 6 46 346 1346 346 5346 92 93 QXAAAA WQHAAA OOOOxx 4140 5171 0 0 0 0 40 140 140 4140 4140 80 81 GDAAAA XQHAAA VVVVxx 6032 5172 0 0 2 12 32 32 32 1032 6032 64 65 AYAAAA YQHAAA AAAAxx 9453 5173 1 1 3 13 53 453 1453 4453 9453 106 107 PZAAAA ZQHAAA HHHHxx 9297 5174 1 1 7 17 97 297 1297 4297 9297 194 195 PTAAAA ARHAAA OOOOxx 6455 5175 1 3 5 15 55 455 455 1455 6455 110 111 HOAAAA BRHAAA VVVVxx 4458 5176 0 2 8 18 58 458 458 4458 4458 116 117 MPAAAA CRHAAA AAAAxx 9516 5177 0 0 6 16 16 516 1516 4516 9516 32 33 ACAAAA DRHAAA HHHHxx 6211 5178 1 3 1 11 11 211 211 1211 6211 22 23 XEAAAA ERHAAA OOOOxx 526 5179 0 2 6 6 26 526 526 526 526 52 53 GUAAAA FRHAAA VVVVxx 3570 5180 0 2 0 10 70 570 1570 3570 3570 140 141 IHAAAA GRHAAA AAAAxx 4885 5181 1 1 5 5 85 885 885 4885 4885 170 171 XFAAAA HRHAAA HHHHxx 6390 5182 0 2 0 10 90 390 390 1390 6390 180 181 ULAAAA IRHAAA OOOOxx 1606 5183 0 2 6 6 6 606 1606 1606 1606 12 13 UJAAAA JRHAAA VVVVxx 7850 5184 0 2 0 10 50 850 1850 2850 7850 100 101 YPAAAA KRHAAA AAAAxx 3315 5185 1 3 5 15 15 315 1315 3315 3315 30 31 NXAAAA LRHAAA HHHHxx 8322 5186 0 2 2 2 22 322 322 3322 8322 44 45 CIAAAA MRHAAA OOOOxx 3703 5187 1 3 3 3 3 703 1703 3703 3703 6 7 LMAAAA NRHAAA VVVVxx 9489 5188 1 1 9 9 89 489 1489 4489 9489 178 179 ZAAAAA ORHAAA AAAAxx 6104 5189 0 0 4 4 4 104 104 1104 6104 8 9 UAAAAA PRHAAA HHHHxx 3067 5190 1 3 7 7 67 67 1067 3067 3067 134 135 ZNAAAA QRHAAA OOOOxx 2521 5191 1 1 1 1 21 521 521 2521 2521 42 43 ZSAAAA RRHAAA VVVVxx 2581 5192 1 1 1 1 81 581 581 2581 2581 162 163 HVAAAA SRHAAA AAAAxx 595 5193 1 3 5 15 95 595 595 595 595 190 191 XWAAAA TRHAAA HHHHxx 8291 5194 1 3 1 11 91 291 291 3291 8291 182 183 XGAAAA URHAAA OOOOxx 1727 5195 1 3 7 7 27 727 1727 1727 1727 54 55 LOAAAA VRHAAA VVVVxx 6847 5196 1 3 7 7 47 847 847 1847 6847 94 95 JDAAAA WRHAAA AAAAxx 7494 5197 0 2 4 14 94 494 1494 2494 7494 188 189 GCAAAA XRHAAA HHHHxx 7093 5198 1 1 3 13 93 93 1093 2093 7093 186 187 VMAAAA YRHAAA OOOOxx 7357 5199 1 1 7 17 57 357 1357 2357 7357 114 115 ZWAAAA ZRHAAA VVVVxx 620 5200 0 0 0 0 20 620 620 620 620 40 41 WXAAAA ASHAAA AAAAxx 2460 5201 0 0 0 0 60 460 460 2460 2460 120 121 QQAAAA BSHAAA HHHHxx 1598 5202 0 2 8 18 98 598 1598 1598 1598 196 197 MJAAAA CSHAAA OOOOxx 4112 5203 0 0 2 12 12 112 112 4112 4112 24 25 ECAAAA DSHAAA VVVVxx 2956 5204 0 0 6 16 56 956 956 2956 2956 112 113 SJAAAA ESHAAA AAAAxx 3193 5205 1 1 3 13 93 193 1193 3193 3193 186 187 VSAAAA FSHAAA HHHHxx 6356 5206 0 0 6 16 56 356 356 1356 6356 112 113 MKAAAA GSHAAA OOOOxx 730 5207 0 2 0 10 30 730 730 730 730 60 61 CCAAAA HSHAAA VVVVxx 8826 5208 0 2 6 6 26 826 826 3826 8826 52 53 MBAAAA ISHAAA AAAAxx 9036 5209 0 0 6 16 36 36 1036 4036 9036 72 73 OJAAAA JSHAAA HHHHxx 2085 5210 1 1 5 5 85 85 85 2085 2085 170 171 FCAAAA KSHAAA OOOOxx 9007 5211 1 3 7 7 7 7 1007 4007 9007 14 15 LIAAAA LSHAAA VVVVxx 6047 5212 1 3 7 7 47 47 47 1047 6047 94 95 PYAAAA MSHAAA AAAAxx 3953 5213 1 1 3 13 53 953 1953 3953 3953 106 107 BWAAAA NSHAAA HHHHxx 1214 5214 0 2 4 14 14 214 1214 1214 1214 28 29 SUAAAA OSHAAA OOOOxx 4814 5215 0 2 4 14 14 814 814 4814 4814 28 29 EDAAAA PSHAAA VVVVxx 5738 5216 0 2 8 18 38 738 1738 738 5738 76 77 SMAAAA QSHAAA AAAAxx 7176 5217 0 0 6 16 76 176 1176 2176 7176 152 153 AQAAAA RSHAAA HHHHxx 3609 5218 1 1 9 9 9 609 1609 3609 3609 18 19 VIAAAA SSHAAA OOOOxx 592 5219 0 0 2 12 92 592 592 592 592 184 185 UWAAAA TSHAAA VVVVxx 9391 5220 1 3 1 11 91 391 1391 4391 9391 182 183 FXAAAA USHAAA AAAAxx 5345 5221 1 1 5 5 45 345 1345 345 5345 90 91 PXAAAA VSHAAA HHHHxx 1171 5222 1 3 1 11 71 171 1171 1171 1171 142 143 BTAAAA WSHAAA OOOOxx 7238 5223 0 2 8 18 38 238 1238 2238 7238 76 77 KSAAAA XSHAAA VVVVxx 7561 5224 1 1 1 1 61 561 1561 2561 7561 122 123 VEAAAA YSHAAA AAAAxx 5876 5225 0 0 6 16 76 876 1876 876 5876 152 153 ASAAAA ZSHAAA HHHHxx 6611 5226 1 3 1 11 11 611 611 1611 6611 22 23 HUAAAA ATHAAA OOOOxx 7300 5227 0 0 0 0 0 300 1300 2300 7300 0 1 UUAAAA BTHAAA VVVVxx 1506 5228 0 2 6 6 6 506 1506 1506 1506 12 13 YFAAAA CTHAAA AAAAxx 1153 5229 1 1 3 13 53 153 1153 1153 1153 106 107 JSAAAA DTHAAA HHHHxx 3831 5230 1 3 1 11 31 831 1831 3831 3831 62 63 JRAAAA ETHAAA OOOOxx 9255 5231 1 3 5 15 55 255 1255 4255 9255 110 111 ZRAAAA FTHAAA VVVVxx 1841 5232 1 1 1 1 41 841 1841 1841 1841 82 83 VSAAAA GTHAAA AAAAxx 5075 5233 1 3 5 15 75 75 1075 75 5075 150 151 FNAAAA HTHAAA HHHHxx 101 5234 1 1 1 1 1 101 101 101 101 2 3 XDAAAA ITHAAA OOOOxx 2627 5235 1 3 7 7 27 627 627 2627 2627 54 55 BXAAAA JTHAAA VVVVxx 7078 5236 0 2 8 18 78 78 1078 2078 7078 156 157 GMAAAA KTHAAA AAAAxx 2850 5237 0 2 0 10 50 850 850 2850 2850 100 101 QFAAAA LTHAAA HHHHxx 8703 5238 1 3 3 3 3 703 703 3703 8703 6 7 TWAAAA MTHAAA OOOOxx 4101 5239 1 1 1 1 1 101 101 4101 4101 2 3 TBAAAA NTHAAA VVVVxx 318 5240 0 2 8 18 18 318 318 318 318 36 37 GMAAAA OTHAAA AAAAxx 6452 5241 0 0 2 12 52 452 452 1452 6452 104 105 EOAAAA PTHAAA HHHHxx 5558 5242 0 2 8 18 58 558 1558 558 5558 116 117 UFAAAA QTHAAA OOOOxx 3127 5243 1 3 7 7 27 127 1127 3127 3127 54 55 HQAAAA RTHAAA VVVVxx 535 5244 1 3 5 15 35 535 535 535 535 70 71 PUAAAA STHAAA AAAAxx 270 5245 0 2 0 10 70 270 270 270 270 140 141 KKAAAA TTHAAA HHHHxx 4038 5246 0 2 8 18 38 38 38 4038 4038 76 77 IZAAAA UTHAAA OOOOxx 3404 5247 0 0 4 4 4 404 1404 3404 3404 8 9 YAAAAA VTHAAA VVVVxx 2374 5248 0 2 4 14 74 374 374 2374 2374 148 149 INAAAA WTHAAA AAAAxx 6446 5249 0 2 6 6 46 446 446 1446 6446 92 93 YNAAAA XTHAAA HHHHxx 7758 5250 0 2 8 18 58 758 1758 2758 7758 116 117 KMAAAA YTHAAA OOOOxx 356 5251 0 0 6 16 56 356 356 356 356 112 113 SNAAAA ZTHAAA VVVVxx 9197 5252 1 1 7 17 97 197 1197 4197 9197 194 195 TPAAAA AUHAAA AAAAxx 9765 5253 1 1 5 5 65 765 1765 4765 9765 130 131 PLAAAA BUHAAA HHHHxx 4974 5254 0 2 4 14 74 974 974 4974 4974 148 149 IJAAAA CUHAAA OOOOxx 442 5255 0 2 2 2 42 442 442 442 442 84 85 ARAAAA DUHAAA VVVVxx 4349 5256 1 1 9 9 49 349 349 4349 4349 98 99 HLAAAA EUHAAA AAAAxx 6119 5257 1 3 9 19 19 119 119 1119 6119 38 39 JBAAAA FUHAAA HHHHxx 7574 5258 0 2 4 14 74 574 1574 2574 7574 148 149 IFAAAA GUHAAA OOOOxx 4445 5259 1 1 5 5 45 445 445 4445 4445 90 91 ZOAAAA HUHAAA VVVVxx 940 5260 0 0 0 0 40 940 940 940 940 80 81 EKAAAA IUHAAA AAAAxx 1875 5261 1 3 5 15 75 875 1875 1875 1875 150 151 DUAAAA JUHAAA HHHHxx 5951 5262 1 3 1 11 51 951 1951 951 5951 102 103 XUAAAA KUHAAA OOOOxx 9132 5263 0 0 2 12 32 132 1132 4132 9132 64 65 GNAAAA LUHAAA VVVVxx 6913 5264 1 1 3 13 13 913 913 1913 6913 26 27 XFAAAA MUHAAA AAAAxx 3308 5265 0 0 8 8 8 308 1308 3308 3308 16 17 GXAAAA NUHAAA HHHHxx 7553 5266 1 1 3 13 53 553 1553 2553 7553 106 107 NEAAAA OUHAAA OOOOxx 2138 5267 0 2 8 18 38 138 138 2138 2138 76 77 GEAAAA PUHAAA VVVVxx 6252 5268 0 0 2 12 52 252 252 1252 6252 104 105 MGAAAA QUHAAA AAAAxx 2171 5269 1 3 1 11 71 171 171 2171 2171 142 143 NFAAAA RUHAAA HHHHxx 4159 5270 1 3 9 19 59 159 159 4159 4159 118 119 ZDAAAA SUHAAA OOOOxx 2401 5271 1 1 1 1 1 401 401 2401 2401 2 3 JOAAAA TUHAAA VVVVxx 6553 5272 1 1 3 13 53 553 553 1553 6553 106 107 BSAAAA UUHAAA AAAAxx 5217 5273 1 1 7 17 17 217 1217 217 5217 34 35 RSAAAA VUHAAA HHHHxx 1405 5274 1 1 5 5 5 405 1405 1405 1405 10 11 BCAAAA WUHAAA OOOOxx 1494 5275 0 2 4 14 94 494 1494 1494 1494 188 189 MFAAAA XUHAAA VVVVxx 5553 5276 1 1 3 13 53 553 1553 553 5553 106 107 PFAAAA YUHAAA AAAAxx 8296 5277 0 0 6 16 96 296 296 3296 8296 192 193 CHAAAA ZUHAAA HHHHxx 6565 5278 1 1 5 5 65 565 565 1565 6565 130 131 NSAAAA AVHAAA OOOOxx 817 5279 1 1 7 17 17 817 817 817 817 34 35 LFAAAA BVHAAA VVVVxx 6947 5280 1 3 7 7 47 947 947 1947 6947 94 95 FHAAAA CVHAAA AAAAxx 4184 5281 0 0 4 4 84 184 184 4184 4184 168 169 YEAAAA DVHAAA HHHHxx 6577 5282 1 1 7 17 77 577 577 1577 6577 154 155 ZSAAAA EVHAAA OOOOxx 6424 5283 0 0 4 4 24 424 424 1424 6424 48 49 CNAAAA FVHAAA VVVVxx 2482 5284 0 2 2 2 82 482 482 2482 2482 164 165 MRAAAA GVHAAA AAAAxx 6874 5285 0 2 4 14 74 874 874 1874 6874 148 149 KEAAAA HVHAAA HHHHxx 7601 5286 1 1 1 1 1 601 1601 2601 7601 2 3 JGAAAA IVHAAA OOOOxx 4552 5287 0 0 2 12 52 552 552 4552 4552 104 105 CTAAAA JVHAAA VVVVxx 8406 5288 0 2 6 6 6 406 406 3406 8406 12 13 ILAAAA KVHAAA AAAAxx 2924 5289 0 0 4 4 24 924 924 2924 2924 48 49 MIAAAA LVHAAA HHHHxx 8255 5290 1 3 5 15 55 255 255 3255 8255 110 111 NFAAAA MVHAAA OOOOxx 4920 5291 0 0 0 0 20 920 920 4920 4920 40 41 GHAAAA NVHAAA VVVVxx 228 5292 0 0 8 8 28 228 228 228 228 56 57 UIAAAA OVHAAA AAAAxx 9431 5293 1 3 1 11 31 431 1431 4431 9431 62 63 TYAAAA PVHAAA HHHHxx 4021 5294 1 1 1 1 21 21 21 4021 4021 42 43 RYAAAA QVHAAA OOOOxx 2966 5295 0 2 6 6 66 966 966 2966 2966 132 133 CKAAAA RVHAAA VVVVxx 2862 5296 0 2 2 2 62 862 862 2862 2862 124 125 CGAAAA SVHAAA AAAAxx 4303 5297 1 3 3 3 3 303 303 4303 4303 6 7 NJAAAA TVHAAA HHHHxx 9643 5298 1 3 3 3 43 643 1643 4643 9643 86 87 XGAAAA UVHAAA OOOOxx 3008 5299 0 0 8 8 8 8 1008 3008 3008 16 17 SLAAAA VVHAAA VVVVxx 7476 5300 0 0 6 16 76 476 1476 2476 7476 152 153 OBAAAA WVHAAA AAAAxx 3686 5301 0 2 6 6 86 686 1686 3686 3686 172 173 ULAAAA XVHAAA HHHHxx 9051 5302 1 3 1 11 51 51 1051 4051 9051 102 103 DKAAAA YVHAAA OOOOxx 6592 5303 0 0 2 12 92 592 592 1592 6592 184 185 OTAAAA ZVHAAA VVVVxx 924 5304 0 0 4 4 24 924 924 924 924 48 49 OJAAAA AWHAAA AAAAxx 4406 5305 0 2 6 6 6 406 406 4406 4406 12 13 MNAAAA BWHAAA HHHHxx 5233 5306 1 1 3 13 33 233 1233 233 5233 66 67 HTAAAA CWHAAA OOOOxx 8881 5307 1 1 1 1 81 881 881 3881 8881 162 163 PDAAAA DWHAAA VVVVxx 2212 5308 0 0 2 12 12 212 212 2212 2212 24 25 CHAAAA EWHAAA AAAAxx 5804 5309 0 0 4 4 4 804 1804 804 5804 8 9 GPAAAA FWHAAA HHHHxx 2990 5310 0 2 0 10 90 990 990 2990 2990 180 181 ALAAAA GWHAAA OOOOxx 4069 5311 1 1 9 9 69 69 69 4069 4069 138 139 NAAAAA HWHAAA VVVVxx 5380 5312 0 0 0 0 80 380 1380 380 5380 160 161 YYAAAA IWHAAA AAAAxx 5016 5313 0 0 6 16 16 16 1016 16 5016 32 33 YKAAAA JWHAAA HHHHxx 5056 5314 0 0 6 16 56 56 1056 56 5056 112 113 MMAAAA KWHAAA OOOOxx 3732 5315 0 0 2 12 32 732 1732 3732 3732 64 65 ONAAAA LWHAAA VVVVxx 5527 5316 1 3 7 7 27 527 1527 527 5527 54 55 PEAAAA MWHAAA AAAAxx 1151 5317 1 3 1 11 51 151 1151 1151 1151 102 103 HSAAAA NWHAAA HHHHxx 7900 5318 0 0 0 0 0 900 1900 2900 7900 0 1 WRAAAA OWHAAA OOOOxx 1660 5319 0 0 0 0 60 660 1660 1660 1660 120 121 WLAAAA PWHAAA VVVVxx 8064 5320 0 0 4 4 64 64 64 3064 8064 128 129 EYAAAA QWHAAA AAAAxx 8240 5321 0 0 0 0 40 240 240 3240 8240 80 81 YEAAAA RWHAAA HHHHxx 413 5322 1 1 3 13 13 413 413 413 413 26 27 XPAAAA SWHAAA OOOOxx 8311 5323 1 3 1 11 11 311 311 3311 8311 22 23 RHAAAA TWHAAA VVVVxx 1065 5324 1 1 5 5 65 65 1065 1065 1065 130 131 ZOAAAA UWHAAA AAAAxx 2741 5325 1 1 1 1 41 741 741 2741 2741 82 83 LBAAAA VWHAAA HHHHxx 5306 5326 0 2 6 6 6 306 1306 306 5306 12 13 CWAAAA WWHAAA OOOOxx 5464 5327 0 0 4 4 64 464 1464 464 5464 128 129 ECAAAA XWHAAA VVVVxx 4237 5328 1 1 7 17 37 237 237 4237 4237 74 75 ZGAAAA YWHAAA AAAAxx 3822 5329 0 2 2 2 22 822 1822 3822 3822 44 45 ARAAAA ZWHAAA HHHHxx 2548 5330 0 0 8 8 48 548 548 2548 2548 96 97 AUAAAA AXHAAA OOOOxx 2688 5331 0 0 8 8 88 688 688 2688 2688 176 177 KZAAAA BXHAAA VVVVxx 8061 5332 1 1 1 1 61 61 61 3061 8061 122 123 BYAAAA CXHAAA AAAAxx 9340 5333 0 0 0 0 40 340 1340 4340 9340 80 81 GVAAAA DXHAAA HHHHxx 4031 5334 1 3 1 11 31 31 31 4031 4031 62 63 BZAAAA EXHAAA OOOOxx 2635 5335 1 3 5 15 35 635 635 2635 2635 70 71 JXAAAA FXHAAA VVVVxx 809 5336 1 1 9 9 9 809 809 809 809 18 19 DFAAAA GXHAAA AAAAxx 3209 5337 1 1 9 9 9 209 1209 3209 3209 18 19 LTAAAA HXHAAA HHHHxx 3825 5338 1 1 5 5 25 825 1825 3825 3825 50 51 DRAAAA IXHAAA OOOOxx 1448 5339 0 0 8 8 48 448 1448 1448 1448 96 97 SDAAAA JXHAAA VVVVxx 9077 5340 1 1 7 17 77 77 1077 4077 9077 154 155 DLAAAA KXHAAA AAAAxx 3730 5341 0 2 0 10 30 730 1730 3730 3730 60 61 MNAAAA LXHAAA HHHHxx 9596 5342 0 0 6 16 96 596 1596 4596 9596 192 193 CFAAAA MXHAAA OOOOxx 3563 5343 1 3 3 3 63 563 1563 3563 3563 126 127 BHAAAA NXHAAA VVVVxx 4116 5344 0 0 6 16 16 116 116 4116 4116 32 33 ICAAAA OXHAAA AAAAxx 4825 5345 1 1 5 5 25 825 825 4825 4825 50 51 PDAAAA PXHAAA HHHHxx 8376 5346 0 0 6 16 76 376 376 3376 8376 152 153 EKAAAA QXHAAA OOOOxx 3917 5347 1 1 7 17 17 917 1917 3917 3917 34 35 RUAAAA RXHAAA VVVVxx 4407 5348 1 3 7 7 7 407 407 4407 4407 14 15 NNAAAA SXHAAA AAAAxx 8202 5349 0 2 2 2 2 202 202 3202 8202 4 5 MDAAAA TXHAAA HHHHxx 7675 5350 1 3 5 15 75 675 1675 2675 7675 150 151 FJAAAA UXHAAA OOOOxx 4104 5351 0 0 4 4 4 104 104 4104 4104 8 9 WBAAAA VXHAAA VVVVxx 9225 5352 1 1 5 5 25 225 1225 4225 9225 50 51 VQAAAA WXHAAA AAAAxx 2834 5353 0 2 4 14 34 834 834 2834 2834 68 69 AFAAAA XXHAAA HHHHxx 1227 5354 1 3 7 7 27 227 1227 1227 1227 54 55 FVAAAA YXHAAA OOOOxx 3383 5355 1 3 3 3 83 383 1383 3383 3383 166 167 DAAAAA ZXHAAA VVVVxx 67 5356 1 3 7 7 67 67 67 67 67 134 135 PCAAAA AYHAAA AAAAxx 1751 5357 1 3 1 11 51 751 1751 1751 1751 102 103 JPAAAA BYHAAA HHHHxx 8054 5358 0 2 4 14 54 54 54 3054 8054 108 109 UXAAAA CYHAAA OOOOxx 8571 5359 1 3 1 11 71 571 571 3571 8571 142 143 RRAAAA DYHAAA VVVVxx 2466 5360 0 2 6 6 66 466 466 2466 2466 132 133 WQAAAA EYHAAA AAAAxx 9405 5361 1 1 5 5 5 405 1405 4405 9405 10 11 TXAAAA FYHAAA HHHHxx 6883 5362 1 3 3 3 83 883 883 1883 6883 166 167 TEAAAA GYHAAA OOOOxx 4301 5363 1 1 1 1 1 301 301 4301 4301 2 3 LJAAAA HYHAAA VVVVxx 3705 5364 1 1 5 5 5 705 1705 3705 3705 10 11 NMAAAA IYHAAA AAAAxx 5420 5365 0 0 0 0 20 420 1420 420 5420 40 41 MAAAAA JYHAAA HHHHxx 3692 5366 0 0 2 12 92 692 1692 3692 3692 184 185 AMAAAA KYHAAA OOOOxx 6851 5367 1 3 1 11 51 851 851 1851 6851 102 103 NDAAAA LYHAAA VVVVxx 9363 5368 1 3 3 3 63 363 1363 4363 9363 126 127 DWAAAA MYHAAA AAAAxx 2269 5369 1 1 9 9 69 269 269 2269 2269 138 139 HJAAAA NYHAAA HHHHxx 4918 5370 0 2 8 18 18 918 918 4918 4918 36 37 EHAAAA OYHAAA OOOOxx 4297 5371 1 1 7 17 97 297 297 4297 4297 194 195 HJAAAA PYHAAA VVVVxx 1836 5372 0 0 6 16 36 836 1836 1836 1836 72 73 QSAAAA QYHAAA AAAAxx 237 5373 1 1 7 17 37 237 237 237 237 74 75 DJAAAA RYHAAA HHHHxx 6131 5374 1 3 1 11 31 131 131 1131 6131 62 63 VBAAAA SYHAAA OOOOxx 3174 5375 0 2 4 14 74 174 1174 3174 3174 148 149 CSAAAA TYHAAA VVVVxx 9987 5376 1 3 7 7 87 987 1987 4987 9987 174 175 DUAAAA UYHAAA AAAAxx 3630 5377 0 2 0 10 30 630 1630 3630 3630 60 61 QJAAAA VYHAAA HHHHxx 2899 5378 1 3 9 19 99 899 899 2899 2899 198 199 NHAAAA WYHAAA OOOOxx 4079 5379 1 3 9 19 79 79 79 4079 4079 158 159 XAAAAA XYHAAA VVVVxx 5049 5380 1 1 9 9 49 49 1049 49 5049 98 99 FMAAAA YYHAAA AAAAxx 2963 5381 1 3 3 3 63 963 963 2963 2963 126 127 ZJAAAA ZYHAAA HHHHxx 3962 5382 0 2 2 2 62 962 1962 3962 3962 124 125 KWAAAA AZHAAA OOOOxx 7921 5383 1 1 1 1 21 921 1921 2921 7921 42 43 RSAAAA BZHAAA VVVVxx 3967 5384 1 3 7 7 67 967 1967 3967 3967 134 135 PWAAAA CZHAAA AAAAxx 2752 5385 0 0 2 12 52 752 752 2752 2752 104 105 WBAAAA DZHAAA HHHHxx 7944 5386 0 0 4 4 44 944 1944 2944 7944 88 89 OTAAAA EZHAAA OOOOxx 2205 5387 1 1 5 5 5 205 205 2205 2205 10 11 VGAAAA FZHAAA VVVVxx 5035 5388 1 3 5 15 35 35 1035 35 5035 70 71 RLAAAA GZHAAA AAAAxx 1425 5389 1 1 5 5 25 425 1425 1425 1425 50 51 VCAAAA HZHAAA HHHHxx 832 5390 0 0 2 12 32 832 832 832 832 64 65 AGAAAA IZHAAA OOOOxx 1447 5391 1 3 7 7 47 447 1447 1447 1447 94 95 RDAAAA JZHAAA VVVVxx 6108 5392 0 0 8 8 8 108 108 1108 6108 16 17 YAAAAA KZHAAA AAAAxx 4936 5393 0 0 6 16 36 936 936 4936 4936 72 73 WHAAAA LZHAAA HHHHxx 7704 5394 0 0 4 4 4 704 1704 2704 7704 8 9 IKAAAA MZHAAA OOOOxx 142 5395 0 2 2 2 42 142 142 142 142 84 85 MFAAAA NZHAAA VVVVxx 4272 5396 0 0 2 12 72 272 272 4272 4272 144 145 IIAAAA OZHAAA AAAAxx 7667 5397 1 3 7 7 67 667 1667 2667 7667 134 135 XIAAAA PZHAAA HHHHxx 366 5398 0 2 6 6 66 366 366 366 366 132 133 COAAAA QZHAAA OOOOxx 8866 5399 0 2 6 6 66 866 866 3866 8866 132 133 ADAAAA RZHAAA VVVVxx 7712 5400 0 0 2 12 12 712 1712 2712 7712 24 25 QKAAAA SZHAAA AAAAxx 3880 5401 0 0 0 0 80 880 1880 3880 3880 160 161 GTAAAA TZHAAA HHHHxx 4631 5402 1 3 1 11 31 631 631 4631 4631 62 63 DWAAAA UZHAAA OOOOxx 2789 5403 1 1 9 9 89 789 789 2789 2789 178 179 HDAAAA VZHAAA VVVVxx 7720 5404 0 0 0 0 20 720 1720 2720 7720 40 41 YKAAAA WZHAAA AAAAxx 7618 5405 0 2 8 18 18 618 1618 2618 7618 36 37 AHAAAA XZHAAA HHHHxx 4990 5406 0 2 0 10 90 990 990 4990 4990 180 181 YJAAAA YZHAAA OOOOxx 7918 5407 0 2 8 18 18 918 1918 2918 7918 36 37 OSAAAA ZZHAAA VVVVxx 5067 5408 1 3 7 7 67 67 1067 67 5067 134 135 XMAAAA AAIAAA AAAAxx 6370 5409 0 2 0 10 70 370 370 1370 6370 140 141 ALAAAA BAIAAA HHHHxx 2268 5410 0 0 8 8 68 268 268 2268 2268 136 137 GJAAAA CAIAAA OOOOxx 1949 5411 1 1 9 9 49 949 1949 1949 1949 98 99 ZWAAAA DAIAAA VVVVxx 5503 5412 1 3 3 3 3 503 1503 503 5503 6 7 RDAAAA EAIAAA AAAAxx 9951 5413 1 3 1 11 51 951 1951 4951 9951 102 103 TSAAAA FAIAAA HHHHxx 6823 5414 1 3 3 3 23 823 823 1823 6823 46 47 LCAAAA GAIAAA OOOOxx 6287 5415 1 3 7 7 87 287 287 1287 6287 174 175 VHAAAA HAIAAA VVVVxx 6016 5416 0 0 6 16 16 16 16 1016 6016 32 33 KXAAAA IAIAAA AAAAxx 1977 5417 1 1 7 17 77 977 1977 1977 1977 154 155 BYAAAA JAIAAA HHHHxx 8579 5418 1 3 9 19 79 579 579 3579 8579 158 159 ZRAAAA KAIAAA OOOOxx 6204 5419 0 0 4 4 4 204 204 1204 6204 8 9 QEAAAA LAIAAA VVVVxx 9764 5420 0 0 4 4 64 764 1764 4764 9764 128 129 OLAAAA MAIAAA AAAAxx 2005 5421 1 1 5 5 5 5 5 2005 2005 10 11 DZAAAA NAIAAA HHHHxx 1648 5422 0 0 8 8 48 648 1648 1648 1648 96 97 KLAAAA OAIAAA OOOOxx 2457 5423 1 1 7 17 57 457 457 2457 2457 114 115 NQAAAA PAIAAA VVVVxx 2698 5424 0 2 8 18 98 698 698 2698 2698 196 197 UZAAAA QAIAAA AAAAxx 7730 5425 0 2 0 10 30 730 1730 2730 7730 60 61 ILAAAA RAIAAA HHHHxx 7287 5426 1 3 7 7 87 287 1287 2287 7287 174 175 HUAAAA SAIAAA OOOOxx 2937 5427 1 1 7 17 37 937 937 2937 2937 74 75 ZIAAAA TAIAAA VVVVxx 6824 5428 0 0 4 4 24 824 824 1824 6824 48 49 MCAAAA UAIAAA AAAAxx 9256 5429 0 0 6 16 56 256 1256 4256 9256 112 113 ASAAAA VAIAAA HHHHxx 4810 5430 0 2 0 10 10 810 810 4810 4810 20 21 ADAAAA WAIAAA OOOOxx 3869 5431 1 1 9 9 69 869 1869 3869 3869 138 139 VSAAAA XAIAAA VVVVxx 1993 5432 1 1 3 13 93 993 1993 1993 1993 186 187 RYAAAA YAIAAA AAAAxx 6048 5433 0 0 8 8 48 48 48 1048 6048 96 97 QYAAAA ZAIAAA HHHHxx 6922 5434 0 2 2 2 22 922 922 1922 6922 44 45 GGAAAA ABIAAA OOOOxx 8 5435 0 0 8 8 8 8 8 8 8 16 17 IAAAAA BBIAAA VVVVxx 6706 5436 0 2 6 6 6 706 706 1706 6706 12 13 YXAAAA CBIAAA AAAAxx 9159 5437 1 3 9 19 59 159 1159 4159 9159 118 119 HOAAAA DBIAAA HHHHxx 7020 5438 0 0 0 0 20 20 1020 2020 7020 40 41 AKAAAA EBIAAA OOOOxx 767 5439 1 3 7 7 67 767 767 767 767 134 135 NDAAAA FBIAAA VVVVxx 8602 5440 0 2 2 2 2 602 602 3602 8602 4 5 WSAAAA GBIAAA AAAAxx 4442 5441 0 2 2 2 42 442 442 4442 4442 84 85 WOAAAA HBIAAA HHHHxx 2040 5442 0 0 0 0 40 40 40 2040 2040 80 81 MAAAAA IBIAAA OOOOxx 5493 5443 1 1 3 13 93 493 1493 493 5493 186 187 HDAAAA JBIAAA VVVVxx 275 5444 1 3 5 15 75 275 275 275 275 150 151 PKAAAA KBIAAA AAAAxx 8876 5445 0 0 6 16 76 876 876 3876 8876 152 153 KDAAAA LBIAAA HHHHxx 7381 5446 1 1 1 1 81 381 1381 2381 7381 162 163 XXAAAA MBIAAA OOOOxx 1827 5447 1 3 7 7 27 827 1827 1827 1827 54 55 HSAAAA NBIAAA VVVVxx 3537 5448 1 1 7 17 37 537 1537 3537 3537 74 75 BGAAAA OBIAAA AAAAxx 6978 5449 0 2 8 18 78 978 978 1978 6978 156 157 KIAAAA PBIAAA HHHHxx 6160 5450 0 0 0 0 60 160 160 1160 6160 120 121 YCAAAA QBIAAA OOOOxx 9219 5451 1 3 9 19 19 219 1219 4219 9219 38 39 PQAAAA RBIAAA VVVVxx 5034 5452 0 2 4 14 34 34 1034 34 5034 68 69 QLAAAA SBIAAA AAAAxx 8463 5453 1 3 3 3 63 463 463 3463 8463 126 127 NNAAAA TBIAAA HHHHxx 2038 5454 0 2 8 18 38 38 38 2038 2038 76 77 KAAAAA UBIAAA OOOOxx 9562 5455 0 2 2 2 62 562 1562 4562 9562 124 125 UDAAAA VBIAAA VVVVxx 2687 5456 1 3 7 7 87 687 687 2687 2687 174 175 JZAAAA WBIAAA AAAAxx 5092 5457 0 0 2 12 92 92 1092 92 5092 184 185 WNAAAA XBIAAA HHHHxx 539 5458 1 3 9 19 39 539 539 539 539 78 79 TUAAAA YBIAAA OOOOxx 2139 5459 1 3 9 19 39 139 139 2139 2139 78 79 HEAAAA ZBIAAA VVVVxx 9221 5460 1 1 1 1 21 221 1221 4221 9221 42 43 RQAAAA ACIAAA AAAAxx 965 5461 1 1 5 5 65 965 965 965 965 130 131 DLAAAA BCIAAA HHHHxx 6051 5462 1 3 1 11 51 51 51 1051 6051 102 103 TYAAAA CCIAAA OOOOxx 5822 5463 0 2 2 2 22 822 1822 822 5822 44 45 YPAAAA DCIAAA VVVVxx 6397 5464 1 1 7 17 97 397 397 1397 6397 194 195 BMAAAA ECIAAA AAAAxx 2375 5465 1 3 5 15 75 375 375 2375 2375 150 151 JNAAAA FCIAAA HHHHxx 9415 5466 1 3 5 15 15 415 1415 4415 9415 30 31 DYAAAA GCIAAA OOOOxx 6552 5467 0 0 2 12 52 552 552 1552 6552 104 105 ASAAAA HCIAAA VVVVxx 2248 5468 0 0 8 8 48 248 248 2248 2248 96 97 MIAAAA ICIAAA AAAAxx 2611 5469 1 3 1 11 11 611 611 2611 2611 22 23 LWAAAA JCIAAA HHHHxx 9609 5470 1 1 9 9 9 609 1609 4609 9609 18 19 PFAAAA KCIAAA OOOOxx 2132 5471 0 0 2 12 32 132 132 2132 2132 64 65 AEAAAA LCIAAA VVVVxx 8452 5472 0 0 2 12 52 452 452 3452 8452 104 105 CNAAAA MCIAAA AAAAxx 9407 5473 1 3 7 7 7 407 1407 4407 9407 14 15 VXAAAA NCIAAA HHHHxx 2814 5474 0 2 4 14 14 814 814 2814 2814 28 29 GEAAAA OCIAAA OOOOxx 1889 5475 1 1 9 9 89 889 1889 1889 1889 178 179 RUAAAA PCIAAA VVVVxx 7489 5476 1 1 9 9 89 489 1489 2489 7489 178 179 BCAAAA QCIAAA AAAAxx 2255 5477 1 3 5 15 55 255 255 2255 2255 110 111 TIAAAA RCIAAA HHHHxx 3380 5478 0 0 0 0 80 380 1380 3380 3380 160 161 AAAAAA SCIAAA OOOOxx 1167 5479 1 3 7 7 67 167 1167 1167 1167 134 135 XSAAAA TCIAAA VVVVxx 5369 5480 1 1 9 9 69 369 1369 369 5369 138 139 NYAAAA UCIAAA AAAAxx 2378 5481 0 2 8 18 78 378 378 2378 2378 156 157 MNAAAA VCIAAA HHHHxx 8315 5482 1 3 5 15 15 315 315 3315 8315 30 31 VHAAAA WCIAAA OOOOxx 2934 5483 0 2 4 14 34 934 934 2934 2934 68 69 WIAAAA XCIAAA VVVVxx 7924 5484 0 0 4 4 24 924 1924 2924 7924 48 49 USAAAA YCIAAA AAAAxx 2867 5485 1 3 7 7 67 867 867 2867 2867 134 135 HGAAAA ZCIAAA HHHHxx 9141 5486 1 1 1 1 41 141 1141 4141 9141 82 83 PNAAAA ADIAAA OOOOxx 3613 5487 1 1 3 13 13 613 1613 3613 3613 26 27 ZIAAAA BDIAAA VVVVxx 2461 5488 1 1 1 1 61 461 461 2461 2461 122 123 RQAAAA CDIAAA AAAAxx 4567 5489 1 3 7 7 67 567 567 4567 4567 134 135 RTAAAA DDIAAA HHHHxx 2906 5490 0 2 6 6 6 906 906 2906 2906 12 13 UHAAAA EDIAAA OOOOxx 4848 5491 0 0 8 8 48 848 848 4848 4848 96 97 MEAAAA FDIAAA VVVVxx 6614 5492 0 2 4 14 14 614 614 1614 6614 28 29 KUAAAA GDIAAA AAAAxx 6200 5493 0 0 0 0 0 200 200 1200 6200 0 1 MEAAAA HDIAAA HHHHxx 7895 5494 1 3 5 15 95 895 1895 2895 7895 190 191 RRAAAA IDIAAA OOOOxx 6829 5495 1 1 9 9 29 829 829 1829 6829 58 59 RCAAAA JDIAAA VVVVxx 4087 5496 1 3 7 7 87 87 87 4087 4087 174 175 FBAAAA KDIAAA AAAAxx 8787 5497 1 3 7 7 87 787 787 3787 8787 174 175 ZZAAAA LDIAAA HHHHxx 3322 5498 0 2 2 2 22 322 1322 3322 3322 44 45 UXAAAA MDIAAA OOOOxx 9091 5499 1 3 1 11 91 91 1091 4091 9091 182 183 RLAAAA NDIAAA VVVVxx 5268 5500 0 0 8 8 68 268 1268 268 5268 136 137 QUAAAA ODIAAA AAAAxx 2719 5501 1 3 9 19 19 719 719 2719 2719 38 39 PAAAAA PDIAAA HHHHxx 30 5502 0 2 0 10 30 30 30 30 30 60 61 EBAAAA QDIAAA OOOOxx 1975 5503 1 3 5 15 75 975 1975 1975 1975 150 151 ZXAAAA RDIAAA VVVVxx 2641 5504 1 1 1 1 41 641 641 2641 2641 82 83 PXAAAA SDIAAA AAAAxx 8616 5505 0 0 6 16 16 616 616 3616 8616 32 33 KTAAAA TDIAAA HHHHxx 5980 5506 0 0 0 0 80 980 1980 980 5980 160 161 AWAAAA UDIAAA OOOOxx 5170 5507 0 2 0 10 70 170 1170 170 5170 140 141 WQAAAA VDIAAA VVVVxx 1960 5508 0 0 0 0 60 960 1960 1960 1960 120 121 KXAAAA WDIAAA AAAAxx 8141 5509 1 1 1 1 41 141 141 3141 8141 82 83 DBAAAA XDIAAA HHHHxx 6692 5510 0 0 2 12 92 692 692 1692 6692 184 185 KXAAAA YDIAAA OOOOxx 7621 5511 1 1 1 1 21 621 1621 2621 7621 42 43 DHAAAA ZDIAAA VVVVxx 3890 5512 0 2 0 10 90 890 1890 3890 3890 180 181 QTAAAA AEIAAA AAAAxx 4300 5513 0 0 0 0 0 300 300 4300 4300 0 1 KJAAAA BEIAAA HHHHxx 736 5514 0 0 6 16 36 736 736 736 736 72 73 ICAAAA CEIAAA OOOOxx 6626 5515 0 2 6 6 26 626 626 1626 6626 52 53 WUAAAA DEIAAA VVVVxx 1800 5516 0 0 0 0 0 800 1800 1800 1800 0 1 GRAAAA EEIAAA AAAAxx 3430 5517 0 2 0 10 30 430 1430 3430 3430 60 61 YBAAAA FEIAAA HHHHxx 9519 5518 1 3 9 19 19 519 1519 4519 9519 38 39 DCAAAA GEIAAA OOOOxx 5111 5519 1 3 1 11 11 111 1111 111 5111 22 23 POAAAA HEIAAA VVVVxx 6915 5520 1 3 5 15 15 915 915 1915 6915 30 31 ZFAAAA IEIAAA AAAAxx 9246 5521 0 2 6 6 46 246 1246 4246 9246 92 93 QRAAAA JEIAAA HHHHxx 5141 5522 1 1 1 1 41 141 1141 141 5141 82 83 TPAAAA KEIAAA OOOOxx 5922 5523 0 2 2 2 22 922 1922 922 5922 44 45 UTAAAA LEIAAA VVVVxx 3087 5524 1 3 7 7 87 87 1087 3087 3087 174 175 TOAAAA MEIAAA AAAAxx 1859 5525 1 3 9 19 59 859 1859 1859 1859 118 119 NTAAAA NEIAAA HHHHxx 8482 5526 0 2 2 2 82 482 482 3482 8482 164 165 GOAAAA OEIAAA OOOOxx 8414 5527 0 2 4 14 14 414 414 3414 8414 28 29 QLAAAA PEIAAA VVVVxx 6662 5528 0 2 2 2 62 662 662 1662 6662 124 125 GWAAAA QEIAAA AAAAxx 8614 5529 0 2 4 14 14 614 614 3614 8614 28 29 ITAAAA REIAAA HHHHxx 42 5530 0 2 2 2 42 42 42 42 42 84 85 QBAAAA SEIAAA OOOOxx 7582 5531 0 2 2 2 82 582 1582 2582 7582 164 165 QFAAAA TEIAAA VVVVxx 8183 5532 1 3 3 3 83 183 183 3183 8183 166 167 TCAAAA UEIAAA AAAAxx 1299 5533 1 3 9 19 99 299 1299 1299 1299 198 199 ZXAAAA VEIAAA HHHHxx 7004 5534 0 0 4 4 4 4 1004 2004 7004 8 9 KJAAAA WEIAAA OOOOxx 3298 5535 0 2 8 18 98 298 1298 3298 3298 196 197 WWAAAA XEIAAA VVVVxx 7884 5536 0 0 4 4 84 884 1884 2884 7884 168 169 GRAAAA YEIAAA AAAAxx 4191 5537 1 3 1 11 91 191 191 4191 4191 182 183 FFAAAA ZEIAAA HHHHxx 7346 5538 0 2 6 6 46 346 1346 2346 7346 92 93 OWAAAA AFIAAA OOOOxx 7989 5539 1 1 9 9 89 989 1989 2989 7989 178 179 HVAAAA BFIAAA VVVVxx 5719 5540 1 3 9 19 19 719 1719 719 5719 38 39 ZLAAAA CFIAAA AAAAxx 800 5541 0 0 0 0 0 800 800 800 800 0 1 UEAAAA DFIAAA HHHHxx 6509 5542 1 1 9 9 9 509 509 1509 6509 18 19 JQAAAA EFIAAA OOOOxx 4672 5543 0 0 2 12 72 672 672 4672 4672 144 145 SXAAAA FFIAAA VVVVxx 4434 5544 0 2 4 14 34 434 434 4434 4434 68 69 OOAAAA GFIAAA AAAAxx 8309 5545 1 1 9 9 9 309 309 3309 8309 18 19 PHAAAA HFIAAA HHHHxx 5134 5546 0 2 4 14 34 134 1134 134 5134 68 69 MPAAAA IFIAAA OOOOxx 5153 5547 1 1 3 13 53 153 1153 153 5153 106 107 FQAAAA JFIAAA VVVVxx 1522 5548 0 2 2 2 22 522 1522 1522 1522 44 45 OGAAAA KFIAAA AAAAxx 8629 5549 1 1 9 9 29 629 629 3629 8629 58 59 XTAAAA LFIAAA HHHHxx 4549 5550 1 1 9 9 49 549 549 4549 4549 98 99 ZSAAAA MFIAAA OOOOxx 9506 5551 0 2 6 6 6 506 1506 4506 9506 12 13 QBAAAA NFIAAA VVVVxx 6542 5552 0 2 2 2 42 542 542 1542 6542 84 85 QRAAAA OFIAAA AAAAxx 2579 5553 1 3 9 19 79 579 579 2579 2579 158 159 FVAAAA PFIAAA HHHHxx 4664 5554 0 0 4 4 64 664 664 4664 4664 128 129 KXAAAA QFIAAA OOOOxx 696 5555 0 0 6 16 96 696 696 696 696 192 193 UAAAAA RFIAAA VVVVxx 7950 5556 0 2 0 10 50 950 1950 2950 7950 100 101 UTAAAA SFIAAA AAAAxx 5 5557 1 1 5 5 5 5 5 5 5 10 11 FAAAAA TFIAAA HHHHxx 7806 5558 0 2 6 6 6 806 1806 2806 7806 12 13 GOAAAA UFIAAA OOOOxx 2770 5559 0 2 0 10 70 770 770 2770 2770 140 141 OCAAAA VFIAAA VVVVxx 1344 5560 0 0 4 4 44 344 1344 1344 1344 88 89 SZAAAA WFIAAA AAAAxx 511 5561 1 3 1 11 11 511 511 511 511 22 23 RTAAAA XFIAAA HHHHxx 9070 5562 0 2 0 10 70 70 1070 4070 9070 140 141 WKAAAA YFIAAA OOOOxx 2961 5563 1 1 1 1 61 961 961 2961 2961 122 123 XJAAAA ZFIAAA VVVVxx 8031 5564 1 3 1 11 31 31 31 3031 8031 62 63 XWAAAA AGIAAA AAAAxx 326 5565 0 2 6 6 26 326 326 326 326 52 53 OMAAAA BGIAAA HHHHxx 183 5566 1 3 3 3 83 183 183 183 183 166 167 BHAAAA CGIAAA OOOOxx 5917 5567 1 1 7 17 17 917 1917 917 5917 34 35 PTAAAA DGIAAA VVVVxx 8256 5568 0 0 6 16 56 256 256 3256 8256 112 113 OFAAAA EGIAAA AAAAxx 7889 5569 1 1 9 9 89 889 1889 2889 7889 178 179 LRAAAA FGIAAA HHHHxx 9029 5570 1 1 9 9 29 29 1029 4029 9029 58 59 HJAAAA GGIAAA OOOOxx 1316 5571 0 0 6 16 16 316 1316 1316 1316 32 33 QYAAAA HGIAAA VVVVxx 7442 5572 0 2 2 2 42 442 1442 2442 7442 84 85 GAAAAA IGIAAA AAAAxx 2810 5573 0 2 0 10 10 810 810 2810 2810 20 21 CEAAAA JGIAAA HHHHxx 20 5574 0 0 0 0 20 20 20 20 20 40 41 UAAAAA KGIAAA OOOOxx 2306 5575 0 2 6 6 6 306 306 2306 2306 12 13 SKAAAA LGIAAA VVVVxx 4694 5576 0 2 4 14 94 694 694 4694 4694 188 189 OYAAAA MGIAAA AAAAxx 9710 5577 0 2 0 10 10 710 1710 4710 9710 20 21 MJAAAA NGIAAA HHHHxx 1791 5578 1 3 1 11 91 791 1791 1791 1791 182 183 XQAAAA OGIAAA OOOOxx 6730 5579 0 2 0 10 30 730 730 1730 6730 60 61 WYAAAA PGIAAA VVVVxx 359 5580 1 3 9 19 59 359 359 359 359 118 119 VNAAAA QGIAAA AAAAxx 8097 5581 1 1 7 17 97 97 97 3097 8097 194 195 LZAAAA RGIAAA HHHHxx 6147 5582 1 3 7 7 47 147 147 1147 6147 94 95 LCAAAA SGIAAA OOOOxx 643 5583 1 3 3 3 43 643 643 643 643 86 87 TYAAAA TGIAAA VVVVxx 698 5584 0 2 8 18 98 698 698 698 698 196 197 WAAAAA UGIAAA AAAAxx 3881 5585 1 1 1 1 81 881 1881 3881 3881 162 163 HTAAAA VGIAAA HHHHxx 7600 5586 0 0 0 0 0 600 1600 2600 7600 0 1 IGAAAA WGIAAA OOOOxx 1583 5587 1 3 3 3 83 583 1583 1583 1583 166 167 XIAAAA XGIAAA VVVVxx 9612 5588 0 0 2 12 12 612 1612 4612 9612 24 25 SFAAAA YGIAAA AAAAxx 1032 5589 0 0 2 12 32 32 1032 1032 1032 64 65 SNAAAA ZGIAAA HHHHxx 4834 5590 0 2 4 14 34 834 834 4834 4834 68 69 YDAAAA AHIAAA OOOOxx 5076 5591 0 0 6 16 76 76 1076 76 5076 152 153 GNAAAA BHIAAA VVVVxx 3070 5592 0 2 0 10 70 70 1070 3070 3070 140 141 COAAAA CHIAAA AAAAxx 1421 5593 1 1 1 1 21 421 1421 1421 1421 42 43 RCAAAA DHIAAA HHHHxx 8970 5594 0 2 0 10 70 970 970 3970 8970 140 141 AHAAAA EHIAAA OOOOxx 6271 5595 1 3 1 11 71 271 271 1271 6271 142 143 FHAAAA FHIAAA VVVVxx 8547 5596 1 3 7 7 47 547 547 3547 8547 94 95 TQAAAA GHIAAA AAAAxx 1259 5597 1 3 9 19 59 259 1259 1259 1259 118 119 LWAAAA HHIAAA HHHHxx 8328 5598 0 0 8 8 28 328 328 3328 8328 56 57 IIAAAA IHIAAA OOOOxx 1503 5599 1 3 3 3 3 503 1503 1503 1503 6 7 VFAAAA JHIAAA VVVVxx 2253 5600 1 1 3 13 53 253 253 2253 2253 106 107 RIAAAA KHIAAA AAAAxx 7449 5601 1 1 9 9 49 449 1449 2449 7449 98 99 NAAAAA LHIAAA HHHHxx 3579 5602 1 3 9 19 79 579 1579 3579 3579 158 159 RHAAAA MHIAAA OOOOxx 1585 5603 1 1 5 5 85 585 1585 1585 1585 170 171 ZIAAAA NHIAAA VVVVxx 5543 5604 1 3 3 3 43 543 1543 543 5543 86 87 FFAAAA OHIAAA AAAAxx 8627 5605 1 3 7 7 27 627 627 3627 8627 54 55 VTAAAA PHIAAA HHHHxx 8618 5606 0 2 8 18 18 618 618 3618 8618 36 37 MTAAAA QHIAAA OOOOxx 1911 5607 1 3 1 11 11 911 1911 1911 1911 22 23 NVAAAA RHIAAA VVVVxx 2758 5608 0 2 8 18 58 758 758 2758 2758 116 117 CCAAAA SHIAAA AAAAxx 5744 5609 0 0 4 4 44 744 1744 744 5744 88 89 YMAAAA THIAAA HHHHxx 4976 5610 0 0 6 16 76 976 976 4976 4976 152 153 KJAAAA UHIAAA OOOOxx 6380 5611 0 0 0 0 80 380 380 1380 6380 160 161 KLAAAA VHIAAA VVVVxx 1937 5612 1 1 7 17 37 937 1937 1937 1937 74 75 NWAAAA WHIAAA AAAAxx 9903 5613 1 3 3 3 3 903 1903 4903 9903 6 7 XQAAAA XHIAAA HHHHxx 4409 5614 1 1 9 9 9 409 409 4409 4409 18 19 PNAAAA YHIAAA OOOOxx 4133 5615 1 1 3 13 33 133 133 4133 4133 66 67 ZCAAAA ZHIAAA VVVVxx 5263 5616 1 3 3 3 63 263 1263 263 5263 126 127 LUAAAA AIIAAA AAAAxx 7888 5617 0 0 8 8 88 888 1888 2888 7888 176 177 KRAAAA BIIAAA HHHHxx 6060 5618 0 0 0 0 60 60 60 1060 6060 120 121 CZAAAA CIIAAA OOOOxx 2522 5619 0 2 2 2 22 522 522 2522 2522 44 45 ATAAAA DIIAAA VVVVxx 5550 5620 0 2 0 10 50 550 1550 550 5550 100 101 MFAAAA EIIAAA AAAAxx 9396 5621 0 0 6 16 96 396 1396 4396 9396 192 193 KXAAAA FIIAAA HHHHxx 176 5622 0 0 6 16 76 176 176 176 176 152 153 UGAAAA GIIAAA OOOOxx 5148 5623 0 0 8 8 48 148 1148 148 5148 96 97 AQAAAA HIIAAA VVVVxx 6691 5624 1 3 1 11 91 691 691 1691 6691 182 183 JXAAAA IIIAAA AAAAxx 4652 5625 0 0 2 12 52 652 652 4652 4652 104 105 YWAAAA JIIAAA HHHHxx 5096 5626 0 0 6 16 96 96 1096 96 5096 192 193 AOAAAA KIIAAA OOOOxx 2408 5627 0 0 8 8 8 408 408 2408 2408 16 17 QOAAAA LIIAAA VVVVxx 7322 5628 0 2 2 2 22 322 1322 2322 7322 44 45 QVAAAA MIIAAA AAAAxx 6782 5629 0 2 2 2 82 782 782 1782 6782 164 165 WAAAAA NIIAAA HHHHxx 4642 5630 0 2 2 2 42 642 642 4642 4642 84 85 OWAAAA OIIAAA OOOOxx 5427 5631 1 3 7 7 27 427 1427 427 5427 54 55 TAAAAA PIIAAA VVVVxx 4461 5632 1 1 1 1 61 461 461 4461 4461 122 123 PPAAAA QIIAAA AAAAxx 8416 5633 0 0 6 16 16 416 416 3416 8416 32 33 SLAAAA RIIAAA HHHHxx 2593 5634 1 1 3 13 93 593 593 2593 2593 186 187 TVAAAA SIIAAA OOOOxx 6202 5635 0 2 2 2 2 202 202 1202 6202 4 5 OEAAAA TIIAAA VVVVxx 3826 5636 0 2 6 6 26 826 1826 3826 3826 52 53 ERAAAA UIIAAA AAAAxx 4417 5637 1 1 7 17 17 417 417 4417 4417 34 35 XNAAAA VIIAAA HHHHxx 7871 5638 1 3 1 11 71 871 1871 2871 7871 142 143 TQAAAA WIIAAA OOOOxx 5622 5639 0 2 2 2 22 622 1622 622 5622 44 45 GIAAAA XIIAAA VVVVxx 3010 5640 0 2 0 10 10 10 1010 3010 3010 20 21 ULAAAA YIIAAA AAAAxx 3407 5641 1 3 7 7 7 407 1407 3407 3407 14 15 BBAAAA ZIIAAA HHHHxx 1274 5642 0 2 4 14 74 274 1274 1274 1274 148 149 AXAAAA AJIAAA OOOOxx 2828 5643 0 0 8 8 28 828 828 2828 2828 56 57 UEAAAA BJIAAA VVVVxx 3427 5644 1 3 7 7 27 427 1427 3427 3427 54 55 VBAAAA CJIAAA AAAAxx 612 5645 0 0 2 12 12 612 612 612 612 24 25 OXAAAA DJIAAA HHHHxx 8729 5646 1 1 9 9 29 729 729 3729 8729 58 59 TXAAAA EJIAAA OOOOxx 1239 5647 1 3 9 19 39 239 1239 1239 1239 78 79 RVAAAA FJIAAA VVVVxx 8990 5648 0 2 0 10 90 990 990 3990 8990 180 181 UHAAAA GJIAAA AAAAxx 5609 5649 1 1 9 9 9 609 1609 609 5609 18 19 THAAAA HJIAAA HHHHxx 4441 5650 1 1 1 1 41 441 441 4441 4441 82 83 VOAAAA IJIAAA OOOOxx 9078 5651 0 2 8 18 78 78 1078 4078 9078 156 157 ELAAAA JJIAAA VVVVxx 6699 5652 1 3 9 19 99 699 699 1699 6699 198 199 RXAAAA KJIAAA AAAAxx 8390 5653 0 2 0 10 90 390 390 3390 8390 180 181 SKAAAA LJIAAA HHHHxx 5455 5654 1 3 5 15 55 455 1455 455 5455 110 111 VBAAAA MJIAAA OOOOxx 7537 5655 1 1 7 17 37 537 1537 2537 7537 74 75 XDAAAA NJIAAA VVVVxx 4669 5656 1 1 9 9 69 669 669 4669 4669 138 139 PXAAAA OJIAAA AAAAxx 5534 5657 0 2 4 14 34 534 1534 534 5534 68 69 WEAAAA PJIAAA HHHHxx 1920 5658 0 0 0 0 20 920 1920 1920 1920 40 41 WVAAAA QJIAAA OOOOxx 9465 5659 1 1 5 5 65 465 1465 4465 9465 130 131 BAAAAA RJIAAA VVVVxx 4897 5660 1 1 7 17 97 897 897 4897 4897 194 195 JGAAAA SJIAAA AAAAxx 1990 5661 0 2 0 10 90 990 1990 1990 1990 180 181 OYAAAA TJIAAA HHHHxx 7148 5662 0 0 8 8 48 148 1148 2148 7148 96 97 YOAAAA UJIAAA OOOOxx 533 5663 1 1 3 13 33 533 533 533 533 66 67 NUAAAA VJIAAA VVVVxx 4339 5664 1 3 9 19 39 339 339 4339 4339 78 79 XKAAAA WJIAAA AAAAxx 6450 5665 0 2 0 10 50 450 450 1450 6450 100 101 COAAAA XJIAAA HHHHxx 9627 5666 1 3 7 7 27 627 1627 4627 9627 54 55 HGAAAA YJIAAA OOOOxx 5539 5667 1 3 9 19 39 539 1539 539 5539 78 79 BFAAAA ZJIAAA VVVVxx 6758 5668 0 2 8 18 58 758 758 1758 6758 116 117 YZAAAA AKIAAA AAAAxx 3435 5669 1 3 5 15 35 435 1435 3435 3435 70 71 DCAAAA BKIAAA HHHHxx 4350 5670 0 2 0 10 50 350 350 4350 4350 100 101 ILAAAA CKIAAA OOOOxx 9088 5671 0 0 8 8 88 88 1088 4088 9088 176 177 OLAAAA DKIAAA VVVVxx 6368 5672 0 0 8 8 68 368 368 1368 6368 136 137 YKAAAA EKIAAA AAAAxx 6337 5673 1 1 7 17 37 337 337 1337 6337 74 75 TJAAAA FKIAAA HHHHxx 4361 5674 1 1 1 1 61 361 361 4361 4361 122 123 TLAAAA GKIAAA OOOOxx 1719 5675 1 3 9 19 19 719 1719 1719 1719 38 39 DOAAAA HKIAAA VVVVxx 3109 5676 1 1 9 9 9 109 1109 3109 3109 18 19 PPAAAA IKIAAA AAAAxx 7135 5677 1 3 5 15 35 135 1135 2135 7135 70 71 LOAAAA JKIAAA HHHHxx 1964 5678 0 0 4 4 64 964 1964 1964 1964 128 129 OXAAAA KKIAAA OOOOxx 3 5679 1 3 3 3 3 3 3 3 3 6 7 DAAAAA LKIAAA VVVVxx 1868 5680 0 0 8 8 68 868 1868 1868 1868 136 137 WTAAAA MKIAAA AAAAxx 5182 5681 0 2 2 2 82 182 1182 182 5182 164 165 IRAAAA NKIAAA HHHHxx 7567 5682 1 3 7 7 67 567 1567 2567 7567 134 135 BFAAAA OKIAAA OOOOxx 3676 5683 0 0 6 16 76 676 1676 3676 3676 152 153 KLAAAA PKIAAA VVVVxx 9382 5684 0 2 2 2 82 382 1382 4382 9382 164 165 WWAAAA QKIAAA AAAAxx 8645 5685 1 1 5 5 45 645 645 3645 8645 90 91 NUAAAA RKIAAA HHHHxx 2018 5686 0 2 8 18 18 18 18 2018 2018 36 37 QZAAAA SKIAAA OOOOxx 217 5687 1 1 7 17 17 217 217 217 217 34 35 JIAAAA TKIAAA VVVVxx 6793 5688 1 1 3 13 93 793 793 1793 6793 186 187 HBAAAA UKIAAA AAAAxx 7280 5689 0 0 0 0 80 280 1280 2280 7280 160 161 AUAAAA VKIAAA HHHHxx 2168 5690 0 0 8 8 68 168 168 2168 2168 136 137 KFAAAA WKIAAA OOOOxx 5259 5691 1 3 9 19 59 259 1259 259 5259 118 119 HUAAAA XKIAAA VVVVxx 6019 5692 1 3 9 19 19 19 19 1019 6019 38 39 NXAAAA YKIAAA AAAAxx 877 5693 1 1 7 17 77 877 877 877 877 154 155 THAAAA ZKIAAA HHHHxx 4961 5694 1 1 1 1 61 961 961 4961 4961 122 123 VIAAAA ALIAAA OOOOxx 1873 5695 1 1 3 13 73 873 1873 1873 1873 146 147 BUAAAA BLIAAA VVVVxx 13 5696 1 1 3 13 13 13 13 13 13 26 27 NAAAAA CLIAAA AAAAxx 1537 5697 1 1 7 17 37 537 1537 1537 1537 74 75 DHAAAA DLIAAA HHHHxx 3129 5698 1 1 9 9 29 129 1129 3129 3129 58 59 JQAAAA ELIAAA OOOOxx 6473 5699 1 1 3 13 73 473 473 1473 6473 146 147 ZOAAAA FLIAAA VVVVxx 7865 5700 1 1 5 5 65 865 1865 2865 7865 130 131 NQAAAA GLIAAA AAAAxx 7822 5701 0 2 2 2 22 822 1822 2822 7822 44 45 WOAAAA HLIAAA HHHHxx 239 5702 1 3 9 19 39 239 239 239 239 78 79 FJAAAA ILIAAA OOOOxx 2062 5703 0 2 2 2 62 62 62 2062 2062 124 125 IBAAAA JLIAAA VVVVxx 762 5704 0 2 2 2 62 762 762 762 762 124 125 IDAAAA KLIAAA AAAAxx 3764 5705 0 0 4 4 64 764 1764 3764 3764 128 129 UOAAAA LLIAAA HHHHxx 465 5706 1 1 5 5 65 465 465 465 465 130 131 XRAAAA MLIAAA OOOOxx 2587 5707 1 3 7 7 87 587 587 2587 2587 174 175 NVAAAA NLIAAA VVVVxx 8402 5708 0 2 2 2 2 402 402 3402 8402 4 5 ELAAAA OLIAAA AAAAxx 1055 5709 1 3 5 15 55 55 1055 1055 1055 110 111 POAAAA PLIAAA HHHHxx 3072 5710 0 0 2 12 72 72 1072 3072 3072 144 145 EOAAAA QLIAAA OOOOxx 7359 5711 1 3 9 19 59 359 1359 2359 7359 118 119 BXAAAA RLIAAA VVVVxx 6558 5712 0 2 8 18 58 558 558 1558 6558 116 117 GSAAAA SLIAAA AAAAxx 48 5713 0 0 8 8 48 48 48 48 48 96 97 WBAAAA TLIAAA HHHHxx 5382 5714 0 2 2 2 82 382 1382 382 5382 164 165 AZAAAA ULIAAA OOOOxx 947 5715 1 3 7 7 47 947 947 947 947 94 95 LKAAAA VLIAAA VVVVxx 2644 5716 0 0 4 4 44 644 644 2644 2644 88 89 SXAAAA WLIAAA AAAAxx 7516 5717 0 0 6 16 16 516 1516 2516 7516 32 33 CDAAAA XLIAAA HHHHxx 2362 5718 0 2 2 2 62 362 362 2362 2362 124 125 WMAAAA YLIAAA OOOOxx 839 5719 1 3 9 19 39 839 839 839 839 78 79 HGAAAA ZLIAAA VVVVxx 2216 5720 0 0 6 16 16 216 216 2216 2216 32 33 GHAAAA AMIAAA AAAAxx 7673 5721 1 1 3 13 73 673 1673 2673 7673 146 147 DJAAAA BMIAAA HHHHxx 8173 5722 1 1 3 13 73 173 173 3173 8173 146 147 JCAAAA CMIAAA OOOOxx 1630 5723 0 2 0 10 30 630 1630 1630 1630 60 61 SKAAAA DMIAAA VVVVxx 9057 5724 1 1 7 17 57 57 1057 4057 9057 114 115 JKAAAA EMIAAA AAAAxx 4392 5725 0 0 2 12 92 392 392 4392 4392 184 185 YMAAAA FMIAAA HHHHxx 3695 5726 1 3 5 15 95 695 1695 3695 3695 190 191 DMAAAA GMIAAA OOOOxx 5751 5727 1 3 1 11 51 751 1751 751 5751 102 103 FNAAAA HMIAAA VVVVxx 5745 5728 1 1 5 5 45 745 1745 745 5745 90 91 ZMAAAA IMIAAA AAAAxx 7945 5729 1 1 5 5 45 945 1945 2945 7945 90 91 PTAAAA JMIAAA HHHHxx 5174 5730 0 2 4 14 74 174 1174 174 5174 148 149 ARAAAA KMIAAA OOOOxx 3829 5731 1 1 9 9 29 829 1829 3829 3829 58 59 HRAAAA LMIAAA VVVVxx 3317 5732 1 1 7 17 17 317 1317 3317 3317 34 35 PXAAAA MMIAAA AAAAxx 4253 5733 1 1 3 13 53 253 253 4253 4253 106 107 PHAAAA NMIAAA HHHHxx 1291 5734 1 3 1 11 91 291 1291 1291 1291 182 183 RXAAAA OMIAAA OOOOxx 3266 5735 0 2 6 6 66 266 1266 3266 3266 132 133 QVAAAA PMIAAA VVVVxx 2939 5736 1 3 9 19 39 939 939 2939 2939 78 79 BJAAAA QMIAAA AAAAxx 2755 5737 1 3 5 15 55 755 755 2755 2755 110 111 ZBAAAA RMIAAA HHHHxx 6844 5738 0 0 4 4 44 844 844 1844 6844 88 89 GDAAAA SMIAAA OOOOxx 8594 5739 0 2 4 14 94 594 594 3594 8594 188 189 OSAAAA TMIAAA VVVVxx 704 5740 0 0 4 4 4 704 704 704 704 8 9 CBAAAA UMIAAA AAAAxx 1681 5741 1 1 1 1 81 681 1681 1681 1681 162 163 RMAAAA VMIAAA HHHHxx 364 5742 0 0 4 4 64 364 364 364 364 128 129 AOAAAA WMIAAA OOOOxx 2928 5743 0 0 8 8 28 928 928 2928 2928 56 57 QIAAAA XMIAAA VVVVxx 117 5744 1 1 7 17 17 117 117 117 117 34 35 NEAAAA YMIAAA AAAAxx 96 5745 0 0 6 16 96 96 96 96 96 192 193 SDAAAA ZMIAAA HHHHxx 7796 5746 0 0 6 16 96 796 1796 2796 7796 192 193 WNAAAA ANIAAA OOOOxx 3101 5747 1 1 1 1 1 101 1101 3101 3101 2 3 HPAAAA BNIAAA VVVVxx 3397 5748 1 1 7 17 97 397 1397 3397 3397 194 195 RAAAAA CNIAAA AAAAxx 1605 5749 1 1 5 5 5 605 1605 1605 1605 10 11 TJAAAA DNIAAA HHHHxx 4881 5750 1 1 1 1 81 881 881 4881 4881 162 163 TFAAAA ENIAAA OOOOxx 4521 5751 1 1 1 1 21 521 521 4521 4521 42 43 XRAAAA FNIAAA VVVVxx 6430 5752 0 2 0 10 30 430 430 1430 6430 60 61 INAAAA GNIAAA AAAAxx 282 5753 0 2 2 2 82 282 282 282 282 164 165 WKAAAA HNIAAA HHHHxx 9645 5754 1 1 5 5 45 645 1645 4645 9645 90 91 ZGAAAA INIAAA OOOOxx 8946 5755 0 2 6 6 46 946 946 3946 8946 92 93 CGAAAA JNIAAA VVVVxx 5064 5756 0 0 4 4 64 64 1064 64 5064 128 129 UMAAAA KNIAAA AAAAxx 7470 5757 0 2 0 10 70 470 1470 2470 7470 140 141 IBAAAA LNIAAA HHHHxx 5886 5758 0 2 6 6 86 886 1886 886 5886 172 173 KSAAAA MNIAAA OOOOxx 6280 5759 0 0 0 0 80 280 280 1280 6280 160 161 OHAAAA NNIAAA VVVVxx 5247 5760 1 3 7 7 47 247 1247 247 5247 94 95 VTAAAA ONIAAA AAAAxx 412 5761 0 0 2 12 12 412 412 412 412 24 25 WPAAAA PNIAAA HHHHxx 5342 5762 0 2 2 2 42 342 1342 342 5342 84 85 MXAAAA QNIAAA OOOOxx 2271 5763 1 3 1 11 71 271 271 2271 2271 142 143 JJAAAA RNIAAA VVVVxx 849 5764 1 1 9 9 49 849 849 849 849 98 99 RGAAAA SNIAAA AAAAxx 1885 5765 1 1 5 5 85 885 1885 1885 1885 170 171 NUAAAA TNIAAA HHHHxx 5620 5766 0 0 0 0 20 620 1620 620 5620 40 41 EIAAAA UNIAAA OOOOxx 7079 5767 1 3 9 19 79 79 1079 2079 7079 158 159 HMAAAA VNIAAA VVVVxx 5819 5768 1 3 9 19 19 819 1819 819 5819 38 39 VPAAAA WNIAAA AAAAxx 7497 5769 1 1 7 17 97 497 1497 2497 7497 194 195 JCAAAA XNIAAA HHHHxx 5993 5770 1 1 3 13 93 993 1993 993 5993 186 187 NWAAAA YNIAAA OOOOxx 3739 5771 1 3 9 19 39 739 1739 3739 3739 78 79 VNAAAA ZNIAAA VVVVxx 6296 5772 0 0 6 16 96 296 296 1296 6296 192 193 EIAAAA AOIAAA AAAAxx 2716 5773 0 0 6 16 16 716 716 2716 2716 32 33 MAAAAA BOIAAA HHHHxx 1130 5774 0 2 0 10 30 130 1130 1130 1130 60 61 MRAAAA COIAAA OOOOxx 5593 5775 1 1 3 13 93 593 1593 593 5593 186 187 DHAAAA DOIAAA VVVVxx 6972 5776 0 0 2 12 72 972 972 1972 6972 144 145 EIAAAA EOIAAA AAAAxx 8360 5777 0 0 0 0 60 360 360 3360 8360 120 121 OJAAAA FOIAAA HHHHxx 6448 5778 0 0 8 8 48 448 448 1448 6448 96 97 AOAAAA GOIAAA OOOOxx 3689 5779 1 1 9 9 89 689 1689 3689 3689 178 179 XLAAAA HOIAAA VVVVxx 7951 5780 1 3 1 11 51 951 1951 2951 7951 102 103 VTAAAA IOIAAA AAAAxx 2974 5781 0 2 4 14 74 974 974 2974 2974 148 149 KKAAAA JOIAAA HHHHxx 6600 5782 0 0 0 0 0 600 600 1600 6600 0 1 WTAAAA KOIAAA OOOOxx 4662 5783 0 2 2 2 62 662 662 4662 4662 124 125 IXAAAA LOIAAA VVVVxx 4765 5784 1 1 5 5 65 765 765 4765 4765 130 131 HBAAAA MOIAAA AAAAxx 355 5785 1 3 5 15 55 355 355 355 355 110 111 RNAAAA NOIAAA HHHHxx 6228 5786 0 0 8 8 28 228 228 1228 6228 56 57 OFAAAA OOIAAA OOOOxx 964 5787 0 0 4 4 64 964 964 964 964 128 129 CLAAAA POIAAA VVVVxx 3082 5788 0 2 2 2 82 82 1082 3082 3082 164 165 OOAAAA QOIAAA AAAAxx 7028 5789 0 0 8 8 28 28 1028 2028 7028 56 57 IKAAAA ROIAAA HHHHxx 4505 5790 1 1 5 5 5 505 505 4505 4505 10 11 HRAAAA SOIAAA OOOOxx 8961 5791 1 1 1 1 61 961 961 3961 8961 122 123 RGAAAA TOIAAA VVVVxx 9571 5792 1 3 1 11 71 571 1571 4571 9571 142 143 DEAAAA UOIAAA AAAAxx 9394 5793 0 2 4 14 94 394 1394 4394 9394 188 189 IXAAAA VOIAAA HHHHxx 4245 5794 1 1 5 5 45 245 245 4245 4245 90 91 HHAAAA WOIAAA OOOOxx 7560 5795 0 0 0 0 60 560 1560 2560 7560 120 121 UEAAAA XOIAAA VVVVxx 2907 5796 1 3 7 7 7 907 907 2907 2907 14 15 VHAAAA YOIAAA AAAAxx 7817 5797 1 1 7 17 17 817 1817 2817 7817 34 35 ROAAAA ZOIAAA HHHHxx 5408 5798 0 0 8 8 8 408 1408 408 5408 16 17 AAAAAA APIAAA OOOOxx 8092 5799 0 0 2 12 92 92 92 3092 8092 184 185 GZAAAA BPIAAA VVVVxx 1309 5800 1 1 9 9 9 309 1309 1309 1309 18 19 JYAAAA CPIAAA AAAAxx 6673 5801 1 1 3 13 73 673 673 1673 6673 146 147 RWAAAA DPIAAA HHHHxx 1245 5802 1 1 5 5 45 245 1245 1245 1245 90 91 XVAAAA EPIAAA OOOOxx 6790 5803 0 2 0 10 90 790 790 1790 6790 180 181 EBAAAA FPIAAA VVVVxx 8380 5804 0 0 0 0 80 380 380 3380 8380 160 161 IKAAAA GPIAAA AAAAxx 5786 5805 0 2 6 6 86 786 1786 786 5786 172 173 OOAAAA HPIAAA HHHHxx 9590 5806 0 2 0 10 90 590 1590 4590 9590 180 181 WEAAAA IPIAAA OOOOxx 5763 5807 1 3 3 3 63 763 1763 763 5763 126 127 RNAAAA JPIAAA VVVVxx 1345 5808 1 1 5 5 45 345 1345 1345 1345 90 91 TZAAAA KPIAAA AAAAxx 3480 5809 0 0 0 0 80 480 1480 3480 3480 160 161 WDAAAA LPIAAA HHHHxx 7864 5810 0 0 4 4 64 864 1864 2864 7864 128 129 MQAAAA MPIAAA OOOOxx 4853 5811 1 1 3 13 53 853 853 4853 4853 106 107 REAAAA NPIAAA VVVVxx 1445 5812 1 1 5 5 45 445 1445 1445 1445 90 91 PDAAAA OPIAAA AAAAxx 170 5813 0 2 0 10 70 170 170 170 170 140 141 OGAAAA PPIAAA HHHHxx 7348 5814 0 0 8 8 48 348 1348 2348 7348 96 97 QWAAAA QPIAAA OOOOxx 3920 5815 0 0 0 0 20 920 1920 3920 3920 40 41 UUAAAA RPIAAA VVVVxx 3307 5816 1 3 7 7 7 307 1307 3307 3307 14 15 FXAAAA SPIAAA AAAAxx 4584 5817 0 0 4 4 84 584 584 4584 4584 168 169 IUAAAA TPIAAA HHHHxx 3344 5818 0 0 4 4 44 344 1344 3344 3344 88 89 QYAAAA UPIAAA OOOOxx 4360 5819 0 0 0 0 60 360 360 4360 4360 120 121 SLAAAA VPIAAA VVVVxx 8757 5820 1 1 7 17 57 757 757 3757 8757 114 115 VYAAAA WPIAAA AAAAxx 4315 5821 1 3 5 15 15 315 315 4315 4315 30 31 ZJAAAA XPIAAA HHHHxx 5243 5822 1 3 3 3 43 243 1243 243 5243 86 87 RTAAAA YPIAAA OOOOxx 8550 5823 0 2 0 10 50 550 550 3550 8550 100 101 WQAAAA ZPIAAA VVVVxx 159 5824 1 3 9 19 59 159 159 159 159 118 119 DGAAAA AQIAAA AAAAxx 4710 5825 0 2 0 10 10 710 710 4710 4710 20 21 EZAAAA BQIAAA HHHHxx 7179 5826 1 3 9 19 79 179 1179 2179 7179 158 159 DQAAAA CQIAAA OOOOxx 2509 5827 1 1 9 9 9 509 509 2509 2509 18 19 NSAAAA DQIAAA VVVVxx 6981 5828 1 1 1 1 81 981 981 1981 6981 162 163 NIAAAA EQIAAA AAAAxx 5060 5829 0 0 0 0 60 60 1060 60 5060 120 121 QMAAAA FQIAAA HHHHxx 5601 5830 1 1 1 1 1 601 1601 601 5601 2 3 LHAAAA GQIAAA OOOOxx 703 5831 1 3 3 3 3 703 703 703 703 6 7 BBAAAA HQIAAA VVVVxx 8719 5832 1 3 9 19 19 719 719 3719 8719 38 39 JXAAAA IQIAAA AAAAxx 1570 5833 0 2 0 10 70 570 1570 1570 1570 140 141 KIAAAA JQIAAA HHHHxx 1036 5834 0 0 6 16 36 36 1036 1036 1036 72 73 WNAAAA KQIAAA OOOOxx 6703 5835 1 3 3 3 3 703 703 1703 6703 6 7 VXAAAA LQIAAA VVVVxx 252 5836 0 0 2 12 52 252 252 252 252 104 105 SJAAAA MQIAAA AAAAxx 631 5837 1 3 1 11 31 631 631 631 631 62 63 HYAAAA NQIAAA HHHHxx 5098 5838 0 2 8 18 98 98 1098 98 5098 196 197 COAAAA OQIAAA OOOOxx 8346 5839 0 2 6 6 46 346 346 3346 8346 92 93 AJAAAA PQIAAA VVVVxx 4910 5840 0 2 0 10 10 910 910 4910 4910 20 21 WGAAAA QQIAAA AAAAxx 559 5841 1 3 9 19 59 559 559 559 559 118 119 NVAAAA RQIAAA HHHHxx 1477 5842 1 1 7 17 77 477 1477 1477 1477 154 155 VEAAAA SQIAAA OOOOxx 5115 5843 1 3 5 15 15 115 1115 115 5115 30 31 TOAAAA TQIAAA VVVVxx 8784 5844 0 0 4 4 84 784 784 3784 8784 168 169 WZAAAA UQIAAA AAAAxx 4422 5845 0 2 2 2 22 422 422 4422 4422 44 45 COAAAA VQIAAA HHHHxx 2702 5846 0 2 2 2 2 702 702 2702 2702 4 5 YZAAAA WQIAAA OOOOxx 9599 5847 1 3 9 19 99 599 1599 4599 9599 198 199 FFAAAA XQIAAA VVVVxx 2463 5848 1 3 3 3 63 463 463 2463 2463 126 127 TQAAAA YQIAAA AAAAxx 498 5849 0 2 8 18 98 498 498 498 498 196 197 ETAAAA ZQIAAA HHHHxx 494 5850 0 2 4 14 94 494 494 494 494 188 189 ATAAAA ARIAAA OOOOxx 8632 5851 0 0 2 12 32 632 632 3632 8632 64 65 AUAAAA BRIAAA VVVVxx 3449 5852 1 1 9 9 49 449 1449 3449 3449 98 99 RCAAAA CRIAAA AAAAxx 5888 5853 0 0 8 8 88 888 1888 888 5888 176 177 MSAAAA DRIAAA HHHHxx 2211 5854 1 3 1 11 11 211 211 2211 2211 22 23 BHAAAA ERIAAA OOOOxx 2835 5855 1 3 5 15 35 835 835 2835 2835 70 71 BFAAAA FRIAAA VVVVxx 4196 5856 0 0 6 16 96 196 196 4196 4196 192 193 KFAAAA GRIAAA AAAAxx 2177 5857 1 1 7 17 77 177 177 2177 2177 154 155 TFAAAA HRIAAA HHHHxx 1959 5858 1 3 9 19 59 959 1959 1959 1959 118 119 JXAAAA IRIAAA OOOOxx 5172 5859 0 0 2 12 72 172 1172 172 5172 144 145 YQAAAA JRIAAA VVVVxx 7898 5860 0 2 8 18 98 898 1898 2898 7898 196 197 URAAAA KRIAAA AAAAxx 5729 5861 1 1 9 9 29 729 1729 729 5729 58 59 JMAAAA LRIAAA HHHHxx 469 5862 1 1 9 9 69 469 469 469 469 138 139 BSAAAA MRIAAA OOOOxx 4456 5863 0 0 6 16 56 456 456 4456 4456 112 113 KPAAAA NRIAAA VVVVxx 3578 5864 0 2 8 18 78 578 1578 3578 3578 156 157 QHAAAA ORIAAA AAAAxx 8623 5865 1 3 3 3 23 623 623 3623 8623 46 47 RTAAAA PRIAAA HHHHxx 6749 5866 1 1 9 9 49 749 749 1749 6749 98 99 PZAAAA QRIAAA OOOOxx 6735 5867 1 3 5 15 35 735 735 1735 6735 70 71 BZAAAA RRIAAA VVVVxx 5197 5868 1 1 7 17 97 197 1197 197 5197 194 195 XRAAAA SRIAAA AAAAxx 2067 5869 1 3 7 7 67 67 67 2067 2067 134 135 NBAAAA TRIAAA HHHHxx 5600 5870 0 0 0 0 0 600 1600 600 5600 0 1 KHAAAA URIAAA OOOOxx 7741 5871 1 1 1 1 41 741 1741 2741 7741 82 83 TLAAAA VRIAAA VVVVxx 9925 5872 1 1 5 5 25 925 1925 4925 9925 50 51 TRAAAA WRIAAA AAAAxx 9685 5873 1 1 5 5 85 685 1685 4685 9685 170 171 NIAAAA XRIAAA HHHHxx 7622 5874 0 2 2 2 22 622 1622 2622 7622 44 45 EHAAAA YRIAAA OOOOxx 6859 5875 1 3 9 19 59 859 859 1859 6859 118 119 VDAAAA ZRIAAA VVVVxx 3094 5876 0 2 4 14 94 94 1094 3094 3094 188 189 APAAAA ASIAAA AAAAxx 2628 5877 0 0 8 8 28 628 628 2628 2628 56 57 CXAAAA BSIAAA HHHHxx 40 5878 0 0 0 0 40 40 40 40 40 80 81 OBAAAA CSIAAA OOOOxx 1644 5879 0 0 4 4 44 644 1644 1644 1644 88 89 GLAAAA DSIAAA VVVVxx 588 5880 0 0 8 8 88 588 588 588 588 176 177 QWAAAA ESIAAA AAAAxx 7522 5881 0 2 2 2 22 522 1522 2522 7522 44 45 IDAAAA FSIAAA HHHHxx 162 5882 0 2 2 2 62 162 162 162 162 124 125 GGAAAA GSIAAA OOOOxx 3610 5883 0 2 0 10 10 610 1610 3610 3610 20 21 WIAAAA HSIAAA VVVVxx 3561 5884 1 1 1 1 61 561 1561 3561 3561 122 123 ZGAAAA ISIAAA AAAAxx 8185 5885 1 1 5 5 85 185 185 3185 8185 170 171 VCAAAA JSIAAA HHHHxx 7237 5886 1 1 7 17 37 237 1237 2237 7237 74 75 JSAAAA KSIAAA OOOOxx 4592 5887 0 0 2 12 92 592 592 4592 4592 184 185 QUAAAA LSIAAA VVVVxx 7082 5888 0 2 2 2 82 82 1082 2082 7082 164 165 KMAAAA MSIAAA AAAAxx 4719 5889 1 3 9 19 19 719 719 4719 4719 38 39 NZAAAA NSIAAA HHHHxx 3879 5890 1 3 9 19 79 879 1879 3879 3879 158 159 FTAAAA OSIAAA OOOOxx 1662 5891 0 2 2 2 62 662 1662 1662 1662 124 125 YLAAAA PSIAAA VVVVxx 3995 5892 1 3 5 15 95 995 1995 3995 3995 190 191 RXAAAA QSIAAA AAAAxx 5828 5893 0 0 8 8 28 828 1828 828 5828 56 57 EQAAAA RSIAAA HHHHxx 4197 5894 1 1 7 17 97 197 197 4197 4197 194 195 LFAAAA SSIAAA OOOOxx 5146 5895 0 2 6 6 46 146 1146 146 5146 92 93 YPAAAA TSIAAA VVVVxx 753 5896 1 1 3 13 53 753 753 753 753 106 107 ZCAAAA USIAAA AAAAxx 7064 5897 0 0 4 4 64 64 1064 2064 7064 128 129 SLAAAA VSIAAA HHHHxx 1312 5898 0 0 2 12 12 312 1312 1312 1312 24 25 MYAAAA WSIAAA OOOOxx 5573 5899 1 1 3 13 73 573 1573 573 5573 146 147 JGAAAA XSIAAA VVVVxx 7634 5900 0 2 4 14 34 634 1634 2634 7634 68 69 QHAAAA YSIAAA AAAAxx 2459 5901 1 3 9 19 59 459 459 2459 2459 118 119 PQAAAA ZSIAAA HHHHxx 8636 5902 0 0 6 16 36 636 636 3636 8636 72 73 EUAAAA ATIAAA OOOOxx 5318 5903 0 2 8 18 18 318 1318 318 5318 36 37 OWAAAA BTIAAA VVVVxx 1064 5904 0 0 4 4 64 64 1064 1064 1064 128 129 YOAAAA CTIAAA AAAAxx 9779 5905 1 3 9 19 79 779 1779 4779 9779 158 159 DMAAAA DTIAAA HHHHxx 6512 5906 0 0 2 12 12 512 512 1512 6512 24 25 MQAAAA ETIAAA OOOOxx 3572 5907 0 0 2 12 72 572 1572 3572 3572 144 145 KHAAAA FTIAAA VVVVxx 816 5908 0 0 6 16 16 816 816 816 816 32 33 KFAAAA GTIAAA AAAAxx 3978 5909 0 2 8 18 78 978 1978 3978 3978 156 157 AXAAAA HTIAAA HHHHxx 5390 5910 0 2 0 10 90 390 1390 390 5390 180 181 IZAAAA ITIAAA OOOOxx 4685 5911 1 1 5 5 85 685 685 4685 4685 170 171 FYAAAA JTIAAA VVVVxx 3003 5912 1 3 3 3 3 3 1003 3003 3003 6 7 NLAAAA KTIAAA AAAAxx 2638 5913 0 2 8 18 38 638 638 2638 2638 76 77 MXAAAA LTIAAA HHHHxx 9716 5914 0 0 6 16 16 716 1716 4716 9716 32 33 SJAAAA MTIAAA OOOOxx 9598 5915 0 2 8 18 98 598 1598 4598 9598 196 197 EFAAAA NTIAAA VVVVxx 9501 5916 1 1 1 1 1 501 1501 4501 9501 2 3 LBAAAA OTIAAA AAAAxx 1704 5917 0 0 4 4 4 704 1704 1704 1704 8 9 ONAAAA PTIAAA HHHHxx 8609 5918 1 1 9 9 9 609 609 3609 8609 18 19 DTAAAA QTIAAA OOOOxx 5211 5919 1 3 1 11 11 211 1211 211 5211 22 23 LSAAAA RTIAAA VVVVxx 3605 5920 1 1 5 5 5 605 1605 3605 3605 10 11 RIAAAA STIAAA AAAAxx 8730 5921 0 2 0 10 30 730 730 3730 8730 60 61 UXAAAA TTIAAA HHHHxx 4208 5922 0 0 8 8 8 208 208 4208 4208 16 17 WFAAAA UTIAAA OOOOxx 7784 5923 0 0 4 4 84 784 1784 2784 7784 168 169 KNAAAA VTIAAA VVVVxx 7501 5924 1 1 1 1 1 501 1501 2501 7501 2 3 NCAAAA WTIAAA AAAAxx 7862 5925 0 2 2 2 62 862 1862 2862 7862 124 125 KQAAAA XTIAAA HHHHxx 8922 5926 0 2 2 2 22 922 922 3922 8922 44 45 EFAAAA YTIAAA OOOOxx 3857 5927 1 1 7 17 57 857 1857 3857 3857 114 115 JSAAAA ZTIAAA VVVVxx 6393 5928 1 1 3 13 93 393 393 1393 6393 186 187 XLAAAA AUIAAA AAAAxx 506 5929 0 2 6 6 6 506 506 506 506 12 13 MTAAAA BUIAAA HHHHxx 4232 5930 0 0 2 12 32 232 232 4232 4232 64 65 UGAAAA CUIAAA OOOOxx 8991 5931 1 3 1 11 91 991 991 3991 8991 182 183 VHAAAA DUIAAA VVVVxx 8578 5932 0 2 8 18 78 578 578 3578 8578 156 157 YRAAAA EUIAAA AAAAxx 3235 5933 1 3 5 15 35 235 1235 3235 3235 70 71 LUAAAA FUIAAA HHHHxx 963 5934 1 3 3 3 63 963 963 963 963 126 127 BLAAAA GUIAAA OOOOxx 113 5935 1 1 3 13 13 113 113 113 113 26 27 JEAAAA HUIAAA VVVVxx 8234 5936 0 2 4 14 34 234 234 3234 8234 68 69 SEAAAA IUIAAA AAAAxx 2613 5937 1 1 3 13 13 613 613 2613 2613 26 27 NWAAAA JUIAAA HHHHxx 5540 5938 0 0 0 0 40 540 1540 540 5540 80 81 CFAAAA KUIAAA OOOOxx 9727 5939 1 3 7 7 27 727 1727 4727 9727 54 55 DKAAAA LUIAAA VVVVxx 2229 5940 1 1 9 9 29 229 229 2229 2229 58 59 THAAAA MUIAAA AAAAxx 6242 5941 0 2 2 2 42 242 242 1242 6242 84 85 CGAAAA NUIAAA HHHHxx 2502 5942 0 2 2 2 2 502 502 2502 2502 4 5 GSAAAA OUIAAA OOOOxx 6212 5943 0 0 2 12 12 212 212 1212 6212 24 25 YEAAAA PUIAAA VVVVxx 3495 5944 1 3 5 15 95 495 1495 3495 3495 190 191 LEAAAA QUIAAA AAAAxx 2364 5945 0 0 4 4 64 364 364 2364 2364 128 129 YMAAAA RUIAAA HHHHxx 6777 5946 1 1 7 17 77 777 777 1777 6777 154 155 RAAAAA SUIAAA OOOOxx 9811 5947 1 3 1 11 11 811 1811 4811 9811 22 23 JNAAAA TUIAAA VVVVxx 1450 5948 0 2 0 10 50 450 1450 1450 1450 100 101 UDAAAA UUIAAA AAAAxx 5008 5949 0 0 8 8 8 8 1008 8 5008 16 17 QKAAAA VUIAAA HHHHxx 1318 5950 0 2 8 18 18 318 1318 1318 1318 36 37 SYAAAA WUIAAA OOOOxx 3373 5951 1 1 3 13 73 373 1373 3373 3373 146 147 TZAAAA XUIAAA VVVVxx 398 5952 0 2 8 18 98 398 398 398 398 196 197 IPAAAA YUIAAA AAAAxx 3804 5953 0 0 4 4 4 804 1804 3804 3804 8 9 IQAAAA ZUIAAA HHHHxx 9148 5954 0 0 8 8 48 148 1148 4148 9148 96 97 WNAAAA AVIAAA OOOOxx 4382 5955 0 2 2 2 82 382 382 4382 4382 164 165 OMAAAA BVIAAA VVVVxx 4026 5956 0 2 6 6 26 26 26 4026 4026 52 53 WYAAAA CVIAAA AAAAxx 7804 5957 0 0 4 4 4 804 1804 2804 7804 8 9 EOAAAA DVIAAA HHHHxx 6839 5958 1 3 9 19 39 839 839 1839 6839 78 79 BDAAAA EVIAAA OOOOxx 3756 5959 0 0 6 16 56 756 1756 3756 3756 112 113 MOAAAA FVIAAA VVVVxx 6734 5960 0 2 4 14 34 734 734 1734 6734 68 69 AZAAAA GVIAAA AAAAxx 2228 5961 0 0 8 8 28 228 228 2228 2228 56 57 SHAAAA HVIAAA HHHHxx 3273 5962 1 1 3 13 73 273 1273 3273 3273 146 147 XVAAAA IVIAAA OOOOxx 3708 5963 0 0 8 8 8 708 1708 3708 3708 16 17 QMAAAA JVIAAA VVVVxx 4320 5964 0 0 0 0 20 320 320 4320 4320 40 41 EKAAAA KVIAAA AAAAxx 74 5965 0 2 4 14 74 74 74 74 74 148 149 WCAAAA LVIAAA HHHHxx 2520 5966 0 0 0 0 20 520 520 2520 2520 40 41 YSAAAA MVIAAA OOOOxx 9619 5967 1 3 9 19 19 619 1619 4619 9619 38 39 ZFAAAA NVIAAA VVVVxx 1801 5968 1 1 1 1 1 801 1801 1801 1801 2 3 HRAAAA OVIAAA AAAAxx 6399 5969 1 3 9 19 99 399 399 1399 6399 198 199 DMAAAA PVIAAA HHHHxx 8313 5970 1 1 3 13 13 313 313 3313 8313 26 27 THAAAA QVIAAA OOOOxx 7003 5971 1 3 3 3 3 3 1003 2003 7003 6 7 JJAAAA RVIAAA VVVVxx 329 5972 1 1 9 9 29 329 329 329 329 58 59 RMAAAA SVIAAA AAAAxx 9090 5973 0 2 0 10 90 90 1090 4090 9090 180 181 QLAAAA TVIAAA HHHHxx 2299 5974 1 3 9 19 99 299 299 2299 2299 198 199 LKAAAA UVIAAA OOOOxx 3925 5975 1 1 5 5 25 925 1925 3925 3925 50 51 ZUAAAA VVIAAA VVVVxx 8145 5976 1 1 5 5 45 145 145 3145 8145 90 91 HBAAAA WVIAAA AAAAxx 8561 5977 1 1 1 1 61 561 561 3561 8561 122 123 HRAAAA XVIAAA HHHHxx 2797 5978 1 1 7 17 97 797 797 2797 2797 194 195 PDAAAA YVIAAA OOOOxx 1451 5979 1 3 1 11 51 451 1451 1451 1451 102 103 VDAAAA ZVIAAA VVVVxx 7977 5980 1 1 7 17 77 977 1977 2977 7977 154 155 VUAAAA AWIAAA AAAAxx 112 5981 0 0 2 12 12 112 112 112 112 24 25 IEAAAA BWIAAA HHHHxx 5265 5982 1 1 5 5 65 265 1265 265 5265 130 131 NUAAAA CWIAAA OOOOxx 3819 5983 1 3 9 19 19 819 1819 3819 3819 38 39 XQAAAA DWIAAA VVVVxx 3648 5984 0 0 8 8 48 648 1648 3648 3648 96 97 IKAAAA EWIAAA AAAAxx 6306 5985 0 2 6 6 6 306 306 1306 6306 12 13 OIAAAA FWIAAA HHHHxx 2385 5986 1 1 5 5 85 385 385 2385 2385 170 171 TNAAAA GWIAAA OOOOxx 9084 5987 0 0 4 4 84 84 1084 4084 9084 168 169 KLAAAA HWIAAA VVVVxx 4499 5988 1 3 9 19 99 499 499 4499 4499 198 199 BRAAAA IWIAAA AAAAxx 1154 5989 0 2 4 14 54 154 1154 1154 1154 108 109 KSAAAA JWIAAA HHHHxx 6800 5990 0 0 0 0 0 800 800 1800 6800 0 1 OBAAAA KWIAAA OOOOxx 8049 5991 1 1 9 9 49 49 49 3049 8049 98 99 PXAAAA LWIAAA VVVVxx 3733 5992 1 1 3 13 33 733 1733 3733 3733 66 67 PNAAAA MWIAAA AAAAxx 8496 5993 0 0 6 16 96 496 496 3496 8496 192 193 UOAAAA NWIAAA HHHHxx 9952 5994 0 0 2 12 52 952 1952 4952 9952 104 105 USAAAA OWIAAA OOOOxx 9792 5995 0 0 2 12 92 792 1792 4792 9792 184 185 QMAAAA PWIAAA VVVVxx 5081 5996 1 1 1 1 81 81 1081 81 5081 162 163 LNAAAA QWIAAA AAAAxx 7908 5997 0 0 8 8 8 908 1908 2908 7908 16 17 ESAAAA RWIAAA HHHHxx 5398 5998 0 2 8 18 98 398 1398 398 5398 196 197 QZAAAA SWIAAA OOOOxx 8423 5999 1 3 3 3 23 423 423 3423 8423 46 47 ZLAAAA TWIAAA VVVVxx 3362 6000 0 2 2 2 62 362 1362 3362 3362 124 125 IZAAAA UWIAAA AAAAxx 7767 6001 1 3 7 7 67 767 1767 2767 7767 134 135 TMAAAA VWIAAA HHHHxx 7063 6002 1 3 3 3 63 63 1063 2063 7063 126 127 RLAAAA WWIAAA OOOOxx 8350 6003 0 2 0 10 50 350 350 3350 8350 100 101 EJAAAA XWIAAA VVVVxx 6779 6004 1 3 9 19 79 779 779 1779 6779 158 159 TAAAAA YWIAAA AAAAxx 5742 6005 0 2 2 2 42 742 1742 742 5742 84 85 WMAAAA ZWIAAA HHHHxx 9045 6006 1 1 5 5 45 45 1045 4045 9045 90 91 XJAAAA AXIAAA OOOOxx 8792 6007 0 0 2 12 92 792 792 3792 8792 184 185 EAAAAA BXIAAA VVVVxx 8160 6008 0 0 0 0 60 160 160 3160 8160 120 121 WBAAAA CXIAAA AAAAxx 3061 6009 1 1 1 1 61 61 1061 3061 3061 122 123 TNAAAA DXIAAA HHHHxx 4721 6010 1 1 1 1 21 721 721 4721 4721 42 43 PZAAAA EXIAAA OOOOxx 9817 6011 1 1 7 17 17 817 1817 4817 9817 34 35 PNAAAA FXIAAA VVVVxx 9257 6012 1 1 7 17 57 257 1257 4257 9257 114 115 BSAAAA GXIAAA AAAAxx 7779 6013 1 3 9 19 79 779 1779 2779 7779 158 159 FNAAAA HXIAAA HHHHxx 2663 6014 1 3 3 3 63 663 663 2663 2663 126 127 LYAAAA IXIAAA OOOOxx 3885 6015 1 1 5 5 85 885 1885 3885 3885 170 171 LTAAAA JXIAAA VVVVxx 9469 6016 1 1 9 9 69 469 1469 4469 9469 138 139 FAAAAA KXIAAA AAAAxx 6766 6017 0 2 6 6 66 766 766 1766 6766 132 133 GAAAAA LXIAAA HHHHxx 7173 6018 1 1 3 13 73 173 1173 2173 7173 146 147 XPAAAA MXIAAA OOOOxx 4709 6019 1 1 9 9 9 709 709 4709 4709 18 19 DZAAAA NXIAAA VVVVxx 4210 6020 0 2 0 10 10 210 210 4210 4210 20 21 YFAAAA OXIAAA AAAAxx 3715 6021 1 3 5 15 15 715 1715 3715 3715 30 31 XMAAAA PXIAAA HHHHxx 5089 6022 1 1 9 9 89 89 1089 89 5089 178 179 TNAAAA QXIAAA OOOOxx 1639 6023 1 3 9 19 39 639 1639 1639 1639 78 79 BLAAAA RXIAAA VVVVxx 5757 6024 1 1 7 17 57 757 1757 757 5757 114 115 LNAAAA SXIAAA AAAAxx 3545 6025 1 1 5 5 45 545 1545 3545 3545 90 91 JGAAAA TXIAAA HHHHxx 709 6026 1 1 9 9 9 709 709 709 709 18 19 HBAAAA UXIAAA OOOOxx 6519 6027 1 3 9 19 19 519 519 1519 6519 38 39 TQAAAA VXIAAA VVVVxx 4341 6028 1 1 1 1 41 341 341 4341 4341 82 83 ZKAAAA WXIAAA AAAAxx 2381 6029 1 1 1 1 81 381 381 2381 2381 162 163 PNAAAA XXIAAA HHHHxx 7215 6030 1 3 5 15 15 215 1215 2215 7215 30 31 NRAAAA YXIAAA OOOOxx 9323 6031 1 3 3 3 23 323 1323 4323 9323 46 47 PUAAAA ZXIAAA VVVVxx 3593 6032 1 1 3 13 93 593 1593 3593 3593 186 187 FIAAAA AYIAAA AAAAxx 3123 6033 1 3 3 3 23 123 1123 3123 3123 46 47 DQAAAA BYIAAA HHHHxx 8673 6034 1 1 3 13 73 673 673 3673 8673 146 147 PVAAAA CYIAAA OOOOxx 5094 6035 0 2 4 14 94 94 1094 94 5094 188 189 YNAAAA DYIAAA VVVVxx 6477 6036 1 1 7 17 77 477 477 1477 6477 154 155 DPAAAA EYIAAA AAAAxx 9734 6037 0 2 4 14 34 734 1734 4734 9734 68 69 KKAAAA FYIAAA HHHHxx 2998 6038 0 2 8 18 98 998 998 2998 2998 196 197 ILAAAA GYIAAA OOOOxx 7807 6039 1 3 7 7 7 807 1807 2807 7807 14 15 HOAAAA HYIAAA VVVVxx 5739 6040 1 3 9 19 39 739 1739 739 5739 78 79 TMAAAA IYIAAA AAAAxx 138 6041 0 2 8 18 38 138 138 138 138 76 77 IFAAAA JYIAAA HHHHxx 2403 6042 1 3 3 3 3 403 403 2403 2403 6 7 LOAAAA KYIAAA OOOOxx 2484 6043 0 0 4 4 84 484 484 2484 2484 168 169 ORAAAA LYIAAA VVVVxx 2805 6044 1 1 5 5 5 805 805 2805 2805 10 11 XDAAAA MYIAAA AAAAxx 5189 6045 1 1 9 9 89 189 1189 189 5189 178 179 PRAAAA NYIAAA HHHHxx 8336 6046 0 0 6 16 36 336 336 3336 8336 72 73 QIAAAA OYIAAA OOOOxx 5241 6047 1 1 1 1 41 241 1241 241 5241 82 83 PTAAAA PYIAAA VVVVxx 2612 6048 0 0 2 12 12 612 612 2612 2612 24 25 MWAAAA QYIAAA AAAAxx 2571 6049 1 3 1 11 71 571 571 2571 2571 142 143 XUAAAA RYIAAA HHHHxx 926 6050 0 2 6 6 26 926 926 926 926 52 53 QJAAAA SYIAAA OOOOxx 337 6051 1 1 7 17 37 337 337 337 337 74 75 ZMAAAA TYIAAA VVVVxx 2821 6052 1 1 1 1 21 821 821 2821 2821 42 43 NEAAAA UYIAAA AAAAxx 2658 6053 0 2 8 18 58 658 658 2658 2658 116 117 GYAAAA VYIAAA HHHHxx 9054 6054 0 2 4 14 54 54 1054 4054 9054 108 109 GKAAAA WYIAAA OOOOxx 5492 6055 0 0 2 12 92 492 1492 492 5492 184 185 GDAAAA XYIAAA VVVVxx 7313 6056 1 1 3 13 13 313 1313 2313 7313 26 27 HVAAAA YYIAAA AAAAxx 75 6057 1 3 5 15 75 75 75 75 75 150 151 XCAAAA ZYIAAA HHHHxx 5489 6058 1 1 9 9 89 489 1489 489 5489 178 179 DDAAAA AZIAAA OOOOxx 8413 6059 1 1 3 13 13 413 413 3413 8413 26 27 PLAAAA BZIAAA VVVVxx 3693 6060 1 1 3 13 93 693 1693 3693 3693 186 187 BMAAAA CZIAAA AAAAxx 9820 6061 0 0 0 0 20 820 1820 4820 9820 40 41 SNAAAA DZIAAA HHHHxx 8157 6062 1 1 7 17 57 157 157 3157 8157 114 115 TBAAAA EZIAAA OOOOxx 4161 6063 1 1 1 1 61 161 161 4161 4161 122 123 BEAAAA FZIAAA VVVVxx 8339 6064 1 3 9 19 39 339 339 3339 8339 78 79 TIAAAA GZIAAA AAAAxx 4141 6065 1 1 1 1 41 141 141 4141 4141 82 83 HDAAAA HZIAAA HHHHxx 9001 6066 1 1 1 1 1 1 1001 4001 9001 2 3 FIAAAA IZIAAA OOOOxx 8247 6067 1 3 7 7 47 247 247 3247 8247 94 95 FFAAAA JZIAAA VVVVxx 1182 6068 0 2 2 2 82 182 1182 1182 1182 164 165 MTAAAA KZIAAA AAAAxx 9876 6069 0 0 6 16 76 876 1876 4876 9876 152 153 WPAAAA LZIAAA HHHHxx 4302 6070 0 2 2 2 2 302 302 4302 4302 4 5 MJAAAA MZIAAA OOOOxx 6674 6071 0 2 4 14 74 674 674 1674 6674 148 149 SWAAAA NZIAAA VVVVxx 4214 6072 0 2 4 14 14 214 214 4214 4214 28 29 CGAAAA OZIAAA AAAAxx 5584 6073 0 0 4 4 84 584 1584 584 5584 168 169 UGAAAA PZIAAA HHHHxx 265 6074 1 1 5 5 65 265 265 265 265 130 131 FKAAAA QZIAAA OOOOxx 9207 6075 1 3 7 7 7 207 1207 4207 9207 14 15 DQAAAA RZIAAA VVVVxx 9434 6076 0 2 4 14 34 434 1434 4434 9434 68 69 WYAAAA SZIAAA AAAAxx 2921 6077 1 1 1 1 21 921 921 2921 2921 42 43 JIAAAA TZIAAA HHHHxx 9355 6078 1 3 5 15 55 355 1355 4355 9355 110 111 VVAAAA UZIAAA OOOOxx 8538 6079 0 2 8 18 38 538 538 3538 8538 76 77 KQAAAA VZIAAA VVVVxx 4559 6080 1 3 9 19 59 559 559 4559 4559 118 119 JTAAAA WZIAAA AAAAxx 9175 6081 1 3 5 15 75 175 1175 4175 9175 150 151 XOAAAA XZIAAA HHHHxx 4489 6082 1 1 9 9 89 489 489 4489 4489 178 179 RQAAAA YZIAAA OOOOxx 1485 6083 1 1 5 5 85 485 1485 1485 1485 170 171 DFAAAA ZZIAAA VVVVxx 8853 6084 1 1 3 13 53 853 853 3853 8853 106 107 NCAAAA AAJAAA AAAAxx 9143 6085 1 3 3 3 43 143 1143 4143 9143 86 87 RNAAAA BAJAAA HHHHxx 9551 6086 1 3 1 11 51 551 1551 4551 9551 102 103 JDAAAA CAJAAA OOOOxx 49 6087 1 1 9 9 49 49 49 49 49 98 99 XBAAAA DAJAAA VVVVxx 8351 6088 1 3 1 11 51 351 351 3351 8351 102 103 FJAAAA EAJAAA AAAAxx 9748 6089 0 0 8 8 48 748 1748 4748 9748 96 97 YKAAAA FAJAAA HHHHxx 4536 6090 0 0 6 16 36 536 536 4536 4536 72 73 MSAAAA GAJAAA OOOOxx 930 6091 0 2 0 10 30 930 930 930 930 60 61 UJAAAA HAJAAA VVVVxx 2206 6092 0 2 6 6 6 206 206 2206 2206 12 13 WGAAAA IAJAAA AAAAxx 8004 6093 0 0 4 4 4 4 4 3004 8004 8 9 WVAAAA JAJAAA HHHHxx 219 6094 1 3 9 19 19 219 219 219 219 38 39 LIAAAA KAJAAA OOOOxx 2724 6095 0 0 4 4 24 724 724 2724 2724 48 49 UAAAAA LAJAAA VVVVxx 4868 6096 0 0 8 8 68 868 868 4868 4868 136 137 GFAAAA MAJAAA AAAAxx 5952 6097 0 0 2 12 52 952 1952 952 5952 104 105 YUAAAA NAJAAA HHHHxx 2094 6098 0 2 4 14 94 94 94 2094 2094 188 189 OCAAAA OAJAAA OOOOxx 5707 6099 1 3 7 7 7 707 1707 707 5707 14 15 NLAAAA PAJAAA VVVVxx 5200 6100 0 0 0 0 0 200 1200 200 5200 0 1 ASAAAA QAJAAA AAAAxx 967 6101 1 3 7 7 67 967 967 967 967 134 135 FLAAAA RAJAAA HHHHxx 1982 6102 0 2 2 2 82 982 1982 1982 1982 164 165 GYAAAA SAJAAA OOOOxx 3410 6103 0 2 0 10 10 410 1410 3410 3410 20 21 EBAAAA TAJAAA VVVVxx 174 6104 0 2 4 14 74 174 174 174 174 148 149 SGAAAA UAJAAA AAAAxx 9217 6105 1 1 7 17 17 217 1217 4217 9217 34 35 NQAAAA VAJAAA HHHHxx 9103 6106 1 3 3 3 3 103 1103 4103 9103 6 7 DMAAAA WAJAAA OOOOxx 868 6107 0 0 8 8 68 868 868 868 868 136 137 KHAAAA XAJAAA VVVVxx 8261 6108 1 1 1 1 61 261 261 3261 8261 122 123 TFAAAA YAJAAA AAAAxx 2720 6109 0 0 0 0 20 720 720 2720 2720 40 41 QAAAAA ZAJAAA HHHHxx 2999 6110 1 3 9 19 99 999 999 2999 2999 198 199 JLAAAA ABJAAA OOOOxx 769 6111 1 1 9 9 69 769 769 769 769 138 139 PDAAAA BBJAAA VVVVxx 4533 6112 1 1 3 13 33 533 533 4533 4533 66 67 JSAAAA CBJAAA AAAAxx 2030 6113 0 2 0 10 30 30 30 2030 2030 60 61 CAAAAA DBJAAA HHHHxx 5824 6114 0 0 4 4 24 824 1824 824 5824 48 49 AQAAAA EBJAAA OOOOxx 2328 6115 0 0 8 8 28 328 328 2328 2328 56 57 OLAAAA FBJAAA VVVVxx 9970 6116 0 2 0 10 70 970 1970 4970 9970 140 141 MTAAAA GBJAAA AAAAxx 3192 6117 0 0 2 12 92 192 1192 3192 3192 184 185 USAAAA HBJAAA HHHHxx 3387 6118 1 3 7 7 87 387 1387 3387 3387 174 175 HAAAAA IBJAAA OOOOxx 1936 6119 0 0 6 16 36 936 1936 1936 1936 72 73 MWAAAA JBJAAA VVVVxx 6934 6120 0 2 4 14 34 934 934 1934 6934 68 69 SGAAAA KBJAAA AAAAxx 5615 6121 1 3 5 15 15 615 1615 615 5615 30 31 ZHAAAA LBJAAA HHHHxx 2241 6122 1 1 1 1 41 241 241 2241 2241 82 83 FIAAAA MBJAAA OOOOxx 1842 6123 0 2 2 2 42 842 1842 1842 1842 84 85 WSAAAA NBJAAA VVVVxx 8044 6124 0 0 4 4 44 44 44 3044 8044 88 89 KXAAAA OBJAAA AAAAxx 8902 6125 0 2 2 2 2 902 902 3902 8902 4 5 KEAAAA PBJAAA HHHHxx 4519 6126 1 3 9 19 19 519 519 4519 4519 38 39 VRAAAA QBJAAA OOOOxx 492 6127 0 0 2 12 92 492 492 492 492 184 185 YSAAAA RBJAAA VVVVxx 2694 6128 0 2 4 14 94 694 694 2694 2694 188 189 QZAAAA SBJAAA AAAAxx 5861 6129 1 1 1 1 61 861 1861 861 5861 122 123 LRAAAA TBJAAA HHHHxx 2104 6130 0 0 4 4 4 104 104 2104 2104 8 9 YCAAAA UBJAAA OOOOxx 5376 6131 0 0 6 16 76 376 1376 376 5376 152 153 UYAAAA VBJAAA VVVVxx 3147 6132 1 3 7 7 47 147 1147 3147 3147 94 95 BRAAAA WBJAAA AAAAxx 9880 6133 0 0 0 0 80 880 1880 4880 9880 160 161 AQAAAA XBJAAA HHHHxx 6171 6134 1 3 1 11 71 171 171 1171 6171 142 143 JDAAAA YBJAAA OOOOxx 1850 6135 0 2 0 10 50 850 1850 1850 1850 100 101 ETAAAA ZBJAAA VVVVxx 1775 6136 1 3 5 15 75 775 1775 1775 1775 150 151 HQAAAA ACJAAA AAAAxx 9261 6137 1 1 1 1 61 261 1261 4261 9261 122 123 FSAAAA BCJAAA HHHHxx 9648 6138 0 0 8 8 48 648 1648 4648 9648 96 97 CHAAAA CCJAAA OOOOxx 7846 6139 0 2 6 6 46 846 1846 2846 7846 92 93 UPAAAA DCJAAA VVVVxx 1446 6140 0 2 6 6 46 446 1446 1446 1446 92 93 QDAAAA ECJAAA AAAAxx 3139 6141 1 3 9 19 39 139 1139 3139 3139 78 79 TQAAAA FCJAAA HHHHxx 6142 6142 0 2 2 2 42 142 142 1142 6142 84 85 GCAAAA GCJAAA OOOOxx 5812 6143 0 0 2 12 12 812 1812 812 5812 24 25 OPAAAA HCJAAA VVVVxx 6728 6144 0 0 8 8 28 728 728 1728 6728 56 57 UYAAAA ICJAAA AAAAxx 4428 6145 0 0 8 8 28 428 428 4428 4428 56 57 IOAAAA JCJAAA HHHHxx 502 6146 0 2 2 2 2 502 502 502 502 4 5 ITAAAA KCJAAA OOOOxx 2363 6147 1 3 3 3 63 363 363 2363 2363 126 127 XMAAAA LCJAAA VVVVxx 3808 6148 0 0 8 8 8 808 1808 3808 3808 16 17 MQAAAA MCJAAA AAAAxx 1010 6149 0 2 0 10 10 10 1010 1010 1010 20 21 WMAAAA NCJAAA HHHHxx 9565 6150 1 1 5 5 65 565 1565 4565 9565 130 131 XDAAAA OCJAAA OOOOxx 1587 6151 1 3 7 7 87 587 1587 1587 1587 174 175 BJAAAA PCJAAA VVVVxx 1474 6152 0 2 4 14 74 474 1474 1474 1474 148 149 SEAAAA QCJAAA AAAAxx 6215 6153 1 3 5 15 15 215 215 1215 6215 30 31 BFAAAA RCJAAA HHHHxx 2395 6154 1 3 5 15 95 395 395 2395 2395 190 191 DOAAAA SCJAAA OOOOxx 8753 6155 1 1 3 13 53 753 753 3753 8753 106 107 RYAAAA TCJAAA VVVVxx 2446 6156 0 2 6 6 46 446 446 2446 2446 92 93 CQAAAA UCJAAA AAAAxx 60 6157 0 0 0 0 60 60 60 60 60 120 121 ICAAAA VCJAAA HHHHxx 982 6158 0 2 2 2 82 982 982 982 982 164 165 ULAAAA WCJAAA OOOOxx 6489 6159 1 1 9 9 89 489 489 1489 6489 178 179 PPAAAA XCJAAA VVVVxx 5334 6160 0 2 4 14 34 334 1334 334 5334 68 69 EXAAAA YCJAAA AAAAxx 8540 6161 0 0 0 0 40 540 540 3540 8540 80 81 MQAAAA ZCJAAA HHHHxx 490 6162 0 2 0 10 90 490 490 490 490 180 181 WSAAAA ADJAAA OOOOxx 6763 6163 1 3 3 3 63 763 763 1763 6763 126 127 DAAAAA BDJAAA VVVVxx 8273 6164 1 1 3 13 73 273 273 3273 8273 146 147 FGAAAA CDJAAA AAAAxx 8327 6165 1 3 7 7 27 327 327 3327 8327 54 55 HIAAAA DDJAAA HHHHxx 8541 6166 1 1 1 1 41 541 541 3541 8541 82 83 NQAAAA EDJAAA OOOOxx 3459 6167 1 3 9 19 59 459 1459 3459 3459 118 119 BDAAAA FDJAAA VVVVxx 5557 6168 1 1 7 17 57 557 1557 557 5557 114 115 TFAAAA GDJAAA AAAAxx 158 6169 0 2 8 18 58 158 158 158 158 116 117 CGAAAA HDJAAA HHHHxx 1741 6170 1 1 1 1 41 741 1741 1741 1741 82 83 ZOAAAA IDJAAA OOOOxx 8385 6171 1 1 5 5 85 385 385 3385 8385 170 171 NKAAAA JDJAAA VVVVxx 617 6172 1 1 7 17 17 617 617 617 617 34 35 TXAAAA KDJAAA AAAAxx 3560 6173 0 0 0 0 60 560 1560 3560 3560 120 121 YGAAAA LDJAAA HHHHxx 5216 6174 0 0 6 16 16 216 1216 216 5216 32 33 QSAAAA MDJAAA OOOOxx 8443 6175 1 3 3 3 43 443 443 3443 8443 86 87 TMAAAA NDJAAA VVVVxx 2700 6176 0 0 0 0 0 700 700 2700 2700 0 1 WZAAAA ODJAAA AAAAxx 3661 6177 1 1 1 1 61 661 1661 3661 3661 122 123 VKAAAA PDJAAA HHHHxx 4875 6178 1 3 5 15 75 875 875 4875 4875 150 151 NFAAAA QDJAAA OOOOxx 6721 6179 1 1 1 1 21 721 721 1721 6721 42 43 NYAAAA RDJAAA VVVVxx 3659 6180 1 3 9 19 59 659 1659 3659 3659 118 119 TKAAAA SDJAAA AAAAxx 8944 6181 0 0 4 4 44 944 944 3944 8944 88 89 AGAAAA TDJAAA HHHHxx 9133 6182 1 1 3 13 33 133 1133 4133 9133 66 67 HNAAAA UDJAAA OOOOxx 9882 6183 0 2 2 2 82 882 1882 4882 9882 164 165 CQAAAA VDJAAA VVVVxx 2102 6184 0 2 2 2 2 102 102 2102 2102 4 5 WCAAAA WDJAAA AAAAxx 9445 6185 1 1 5 5 45 445 1445 4445 9445 90 91 HZAAAA XDJAAA HHHHxx 5559 6186 1 3 9 19 59 559 1559 559 5559 118 119 VFAAAA YDJAAA OOOOxx 6096 6187 0 0 6 16 96 96 96 1096 6096 192 193 MAAAAA ZDJAAA VVVVxx 9336 6188 0 0 6 16 36 336 1336 4336 9336 72 73 CVAAAA AEJAAA AAAAxx 2162 6189 0 2 2 2 62 162 162 2162 2162 124 125 EFAAAA BEJAAA HHHHxx 7459 6190 1 3 9 19 59 459 1459 2459 7459 118 119 XAAAAA CEJAAA OOOOxx 3248 6191 0 0 8 8 48 248 1248 3248 3248 96 97 YUAAAA DEJAAA VVVVxx 9539 6192 1 3 9 19 39 539 1539 4539 9539 78 79 XCAAAA EEJAAA AAAAxx 4449 6193 1 1 9 9 49 449 449 4449 4449 98 99 DPAAAA FEJAAA HHHHxx 2809 6194 1 1 9 9 9 809 809 2809 2809 18 19 BEAAAA GEJAAA OOOOxx 7058 6195 0 2 8 18 58 58 1058 2058 7058 116 117 MLAAAA HEJAAA VVVVxx 3512 6196 0 0 2 12 12 512 1512 3512 3512 24 25 CFAAAA IEJAAA AAAAxx 2802 6197 0 2 2 2 2 802 802 2802 2802 4 5 UDAAAA JEJAAA HHHHxx 6289 6198 1 1 9 9 89 289 289 1289 6289 178 179 XHAAAA KEJAAA OOOOxx 1947 6199 1 3 7 7 47 947 1947 1947 1947 94 95 XWAAAA LEJAAA VVVVxx 9572 6200 0 0 2 12 72 572 1572 4572 9572 144 145 EEAAAA MEJAAA AAAAxx 2356 6201 0 0 6 16 56 356 356 2356 2356 112 113 QMAAAA NEJAAA HHHHxx 3039 6202 1 3 9 19 39 39 1039 3039 3039 78 79 XMAAAA OEJAAA OOOOxx 9452 6203 0 0 2 12 52 452 1452 4452 9452 104 105 OZAAAA PEJAAA VVVVxx 6328 6204 0 0 8 8 28 328 328 1328 6328 56 57 KJAAAA QEJAAA AAAAxx 7661 6205 1 1 1 1 61 661 1661 2661 7661 122 123 RIAAAA REJAAA HHHHxx 2566 6206 0 2 6 6 66 566 566 2566 2566 132 133 SUAAAA SEJAAA OOOOxx 6095 6207 1 3 5 15 95 95 95 1095 6095 190 191 LAAAAA TEJAAA VVVVxx 6367 6208 1 3 7 7 67 367 367 1367 6367 134 135 XKAAAA UEJAAA AAAAxx 3368 6209 0 0 8 8 68 368 1368 3368 3368 136 137 OZAAAA VEJAAA HHHHxx 5567 6210 1 3 7 7 67 567 1567 567 5567 134 135 DGAAAA WEJAAA OOOOxx 9834 6211 0 2 4 14 34 834 1834 4834 9834 68 69 GOAAAA XEJAAA VVVVxx 9695 6212 1 3 5 15 95 695 1695 4695 9695 190 191 XIAAAA YEJAAA AAAAxx 7291 6213 1 3 1 11 91 291 1291 2291 7291 182 183 LUAAAA ZEJAAA HHHHxx 4806 6214 0 2 6 6 6 806 806 4806 4806 12 13 WCAAAA AFJAAA OOOOxx 2000 6215 0 0 0 0 0 0 0 2000 2000 0 1 YYAAAA BFJAAA VVVVxx 6817 6216 1 1 7 17 17 817 817 1817 6817 34 35 FCAAAA CFJAAA AAAAxx 8487 6217 1 3 7 7 87 487 487 3487 8487 174 175 LOAAAA DFJAAA HHHHxx 3245 6218 1 1 5 5 45 245 1245 3245 3245 90 91 VUAAAA EFJAAA OOOOxx 632 6219 0 0 2 12 32 632 632 632 632 64 65 IYAAAA FFJAAA VVVVxx 8067 6220 1 3 7 7 67 67 67 3067 8067 134 135 HYAAAA GFJAAA AAAAxx 7140 6221 0 0 0 0 40 140 1140 2140 7140 80 81 QOAAAA HFJAAA HHHHxx 6802 6222 0 2 2 2 2 802 802 1802 6802 4 5 QBAAAA IFJAAA OOOOxx 3980 6223 0 0 0 0 80 980 1980 3980 3980 160 161 CXAAAA JFJAAA VVVVxx 1321 6224 1 1 1 1 21 321 1321 1321 1321 42 43 VYAAAA KFJAAA AAAAxx 2273 6225 1 1 3 13 73 273 273 2273 2273 146 147 LJAAAA LFJAAA HHHHxx 6787 6226 1 3 7 7 87 787 787 1787 6787 174 175 BBAAAA MFJAAA OOOOxx 9480 6227 0 0 0 0 80 480 1480 4480 9480 160 161 QAAAAA NFJAAA VVVVxx 9404 6228 0 0 4 4 4 404 1404 4404 9404 8 9 SXAAAA OFJAAA AAAAxx 3914 6229 0 2 4 14 14 914 1914 3914 3914 28 29 OUAAAA PFJAAA HHHHxx 5507 6230 1 3 7 7 7 507 1507 507 5507 14 15 VDAAAA QFJAAA OOOOxx 1813 6231 1 1 3 13 13 813 1813 1813 1813 26 27 TRAAAA RFJAAA VVVVxx 1999 6232 1 3 9 19 99 999 1999 1999 1999 198 199 XYAAAA SFJAAA AAAAxx 3848 6233 0 0 8 8 48 848 1848 3848 3848 96 97 ASAAAA TFJAAA HHHHxx 9693 6234 1 1 3 13 93 693 1693 4693 9693 186 187 VIAAAA UFJAAA OOOOxx 1353 6235 1 1 3 13 53 353 1353 1353 1353 106 107 BAAAAA VFJAAA VVVVxx 7218 6236 0 2 8 18 18 218 1218 2218 7218 36 37 QRAAAA WFJAAA AAAAxx 8223 6237 1 3 3 3 23 223 223 3223 8223 46 47 HEAAAA XFJAAA HHHHxx 9982 6238 0 2 2 2 82 982 1982 4982 9982 164 165 YTAAAA YFJAAA OOOOxx 8799 6239 1 3 9 19 99 799 799 3799 8799 198 199 LAAAAA ZFJAAA VVVVxx 8929 6240 1 1 9 9 29 929 929 3929 8929 58 59 LFAAAA AGJAAA AAAAxx 4626 6241 0 2 6 6 26 626 626 4626 4626 52 53 YVAAAA BGJAAA HHHHxx 7958 6242 0 2 8 18 58 958 1958 2958 7958 116 117 CUAAAA CGJAAA OOOOxx 3743 6243 1 3 3 3 43 743 1743 3743 3743 86 87 ZNAAAA DGJAAA VVVVxx 8165 6244 1 1 5 5 65 165 165 3165 8165 130 131 BCAAAA EGJAAA AAAAxx 7899 6245 1 3 9 19 99 899 1899 2899 7899 198 199 VRAAAA FGJAAA HHHHxx 8698 6246 0 2 8 18 98 698 698 3698 8698 196 197 OWAAAA GGJAAA OOOOxx 9270 6247 0 2 0 10 70 270 1270 4270 9270 140 141 OSAAAA HGJAAA VVVVxx 6348 6248 0 0 8 8 48 348 348 1348 6348 96 97 EKAAAA IGJAAA AAAAxx 6999 6249 1 3 9 19 99 999 999 1999 6999 198 199 FJAAAA JGJAAA HHHHxx 8467 6250 1 3 7 7 67 467 467 3467 8467 134 135 RNAAAA KGJAAA OOOOxx 3907 6251 1 3 7 7 7 907 1907 3907 3907 14 15 HUAAAA LGJAAA VVVVxx 4738 6252 0 2 8 18 38 738 738 4738 4738 76 77 GAAAAA MGJAAA AAAAxx 248 6253 0 0 8 8 48 248 248 248 248 96 97 OJAAAA NGJAAA HHHHxx 8769 6254 1 1 9 9 69 769 769 3769 8769 138 139 HZAAAA OGJAAA OOOOxx 9922 6255 0 2 2 2 22 922 1922 4922 9922 44 45 QRAAAA PGJAAA VVVVxx 778 6256 0 2 8 18 78 778 778 778 778 156 157 YDAAAA QGJAAA AAAAxx 1233 6257 1 1 3 13 33 233 1233 1233 1233 66 67 LVAAAA RGJAAA HHHHxx 1183 6258 1 3 3 3 83 183 1183 1183 1183 166 167 NTAAAA SGJAAA OOOOxx 2838 6259 0 2 8 18 38 838 838 2838 2838 76 77 EFAAAA TGJAAA VVVVxx 3096 6260 0 0 6 16 96 96 1096 3096 3096 192 193 CPAAAA UGJAAA AAAAxx 8566 6261 0 2 6 6 66 566 566 3566 8566 132 133 MRAAAA VGJAAA HHHHxx 7635 6262 1 3 5 15 35 635 1635 2635 7635 70 71 RHAAAA WGJAAA OOOOxx 5428 6263 0 0 8 8 28 428 1428 428 5428 56 57 UAAAAA XGJAAA VVVVxx 7430 6264 0 2 0 10 30 430 1430 2430 7430 60 61 UZAAAA YGJAAA AAAAxx 7210 6265 0 2 0 10 10 210 1210 2210 7210 20 21 IRAAAA ZGJAAA HHHHxx 4485 6266 1 1 5 5 85 485 485 4485 4485 170 171 NQAAAA AHJAAA OOOOxx 9623 6267 1 3 3 3 23 623 1623 4623 9623 46 47 DGAAAA BHJAAA VVVVxx 3670 6268 0 2 0 10 70 670 1670 3670 3670 140 141 ELAAAA CHJAAA AAAAxx 1575 6269 1 3 5 15 75 575 1575 1575 1575 150 151 PIAAAA DHJAAA HHHHxx 5874 6270 0 2 4 14 74 874 1874 874 5874 148 149 YRAAAA EHJAAA OOOOxx 673 6271 1 1 3 13 73 673 673 673 673 146 147 XZAAAA FHJAAA VVVVxx 9712 6272 0 0 2 12 12 712 1712 4712 9712 24 25 OJAAAA GHJAAA AAAAxx 7729 6273 1 1 9 9 29 729 1729 2729 7729 58 59 HLAAAA HHJAAA HHHHxx 4318 6274 0 2 8 18 18 318 318 4318 4318 36 37 CKAAAA IHJAAA OOOOxx 4143 6275 1 3 3 3 43 143 143 4143 4143 86 87 JDAAAA JHJAAA VVVVxx 4932 6276 0 0 2 12 32 932 932 4932 4932 64 65 SHAAAA KHJAAA AAAAxx 5835 6277 1 3 5 15 35 835 1835 835 5835 70 71 LQAAAA LHJAAA HHHHxx 4966 6278 0 2 6 6 66 966 966 4966 4966 132 133 AJAAAA MHJAAA OOOOxx 6711 6279 1 3 1 11 11 711 711 1711 6711 22 23 DYAAAA NHJAAA VVVVxx 3990 6280 0 2 0 10 90 990 1990 3990 3990 180 181 MXAAAA OHJAAA AAAAxx 990 6281 0 2 0 10 90 990 990 990 990 180 181 CMAAAA PHJAAA HHHHxx 220 6282 0 0 0 0 20 220 220 220 220 40 41 MIAAAA QHJAAA OOOOxx 5693 6283 1 1 3 13 93 693 1693 693 5693 186 187 ZKAAAA RHJAAA VVVVxx 3662 6284 0 2 2 2 62 662 1662 3662 3662 124 125 WKAAAA SHJAAA AAAAxx 7844 6285 0 0 4 4 44 844 1844 2844 7844 88 89 SPAAAA THJAAA HHHHxx 5515 6286 1 3 5 15 15 515 1515 515 5515 30 31 DEAAAA UHJAAA OOOOxx 5551 6287 1 3 1 11 51 551 1551 551 5551 102 103 NFAAAA VHJAAA VVVVxx 2358 6288 0 2 8 18 58 358 358 2358 2358 116 117 SMAAAA WHJAAA AAAAxx 8977 6289 1 1 7 17 77 977 977 3977 8977 154 155 HHAAAA XHJAAA HHHHxx 7040 6290 0 0 0 0 40 40 1040 2040 7040 80 81 UKAAAA YHJAAA OOOOxx 105 6291 1 1 5 5 5 105 105 105 105 10 11 BEAAAA ZHJAAA VVVVxx 4496 6292 0 0 6 16 96 496 496 4496 4496 192 193 YQAAAA AIJAAA AAAAxx 2254 6293 0 2 4 14 54 254 254 2254 2254 108 109 SIAAAA BIJAAA HHHHxx 411 6294 1 3 1 11 11 411 411 411 411 22 23 VPAAAA CIJAAA OOOOxx 2373 6295 1 1 3 13 73 373 373 2373 2373 146 147 HNAAAA DIJAAA VVVVxx 3477 6296 1 1 7 17 77 477 1477 3477 3477 154 155 TDAAAA EIJAAA AAAAxx 8964 6297 0 0 4 4 64 964 964 3964 8964 128 129 UGAAAA FIJAAA HHHHxx 8471 6298 1 3 1 11 71 471 471 3471 8471 142 143 VNAAAA GIJAAA OOOOxx 5776 6299 0 0 6 16 76 776 1776 776 5776 152 153 EOAAAA HIJAAA VVVVxx 9921 6300 1 1 1 1 21 921 1921 4921 9921 42 43 PRAAAA IIJAAA AAAAxx 7816 6301 0 0 6 16 16 816 1816 2816 7816 32 33 QOAAAA JIJAAA HHHHxx 2439 6302 1 3 9 19 39 439 439 2439 2439 78 79 VPAAAA KIJAAA OOOOxx 9298 6303 0 2 8 18 98 298 1298 4298 9298 196 197 QTAAAA LIJAAA VVVVxx 9424 6304 0 0 4 4 24 424 1424 4424 9424 48 49 MYAAAA MIJAAA AAAAxx 3252 6305 0 0 2 12 52 252 1252 3252 3252 104 105 CVAAAA NIJAAA HHHHxx 1401 6306 1 1 1 1 1 401 1401 1401 1401 2 3 XBAAAA OIJAAA OOOOxx 9632 6307 0 0 2 12 32 632 1632 4632 9632 64 65 MGAAAA PIJAAA VVVVxx 370 6308 0 2 0 10 70 370 370 370 370 140 141 GOAAAA QIJAAA AAAAxx 728 6309 0 0 8 8 28 728 728 728 728 56 57 ACAAAA RIJAAA HHHHxx 2888 6310 0 0 8 8 88 888 888 2888 2888 176 177 CHAAAA SIJAAA OOOOxx 1441 6311 1 1 1 1 41 441 1441 1441 1441 82 83 LDAAAA TIJAAA VVVVxx 8308 6312 0 0 8 8 8 308 308 3308 8308 16 17 OHAAAA UIJAAA AAAAxx 2165 6313 1 1 5 5 65 165 165 2165 2165 130 131 HFAAAA VIJAAA HHHHxx 6359 6314 1 3 9 19 59 359 359 1359 6359 118 119 PKAAAA WIJAAA OOOOxx 9637 6315 1 1 7 17 37 637 1637 4637 9637 74 75 RGAAAA XIJAAA VVVVxx 5208 6316 0 0 8 8 8 208 1208 208 5208 16 17 ISAAAA YIJAAA AAAAxx 4705 6317 1 1 5 5 5 705 705 4705 4705 10 11 ZYAAAA ZIJAAA HHHHxx 2341 6318 1 1 1 1 41 341 341 2341 2341 82 83 BMAAAA AJJAAA OOOOxx 8539 6319 1 3 9 19 39 539 539 3539 8539 78 79 LQAAAA BJJAAA VVVVxx 7528 6320 0 0 8 8 28 528 1528 2528 7528 56 57 ODAAAA CJJAAA AAAAxx 7969 6321 1 1 9 9 69 969 1969 2969 7969 138 139 NUAAAA DJJAAA HHHHxx 6381 6322 1 1 1 1 81 381 381 1381 6381 162 163 LLAAAA EJJAAA OOOOxx 4906 6323 0 2 6 6 6 906 906 4906 4906 12 13 SGAAAA FJJAAA VVVVxx 8697 6324 1 1 7 17 97 697 697 3697 8697 194 195 NWAAAA GJJAAA AAAAxx 6301 6325 1 1 1 1 1 301 301 1301 6301 2 3 JIAAAA HJJAAA HHHHxx 7554 6326 0 2 4 14 54 554 1554 2554 7554 108 109 OEAAAA IJJAAA OOOOxx 5107 6327 1 3 7 7 7 107 1107 107 5107 14 15 LOAAAA JJJAAA VVVVxx 5046 6328 0 2 6 6 46 46 1046 46 5046 92 93 CMAAAA KJJAAA AAAAxx 4063 6329 1 3 3 3 63 63 63 4063 4063 126 127 HAAAAA LJJAAA HHHHxx 7580 6330 0 0 0 0 80 580 1580 2580 7580 160 161 OFAAAA MJJAAA OOOOxx 2245 6331 1 1 5 5 45 245 245 2245 2245 90 91 JIAAAA NJJAAA VVVVxx 3711 6332 1 3 1 11 11 711 1711 3711 3711 22 23 TMAAAA OJJAAA AAAAxx 3220 6333 0 0 0 0 20 220 1220 3220 3220 40 41 WTAAAA PJJAAA HHHHxx 6463 6334 1 3 3 3 63 463 463 1463 6463 126 127 POAAAA QJJAAA OOOOxx 8196 6335 0 0 6 16 96 196 196 3196 8196 192 193 GDAAAA RJJAAA VVVVxx 9875 6336 1 3 5 15 75 875 1875 4875 9875 150 151 VPAAAA SJJAAA AAAAxx 1333 6337 1 1 3 13 33 333 1333 1333 1333 66 67 HZAAAA TJJAAA HHHHxx 7880 6338 0 0 0 0 80 880 1880 2880 7880 160 161 CRAAAA UJJAAA OOOOxx 2322 6339 0 2 2 2 22 322 322 2322 2322 44 45 ILAAAA VJJAAA VVVVxx 2163 6340 1 3 3 3 63 163 163 2163 2163 126 127 FFAAAA WJJAAA AAAAxx 421 6341 1 1 1 1 21 421 421 421 421 42 43 FQAAAA XJJAAA HHHHxx 2042 6342 0 2 2 2 42 42 42 2042 2042 84 85 OAAAAA YJJAAA OOOOxx 1424 6343 0 0 4 4 24 424 1424 1424 1424 48 49 UCAAAA ZJJAAA VVVVxx 7870 6344 0 2 0 10 70 870 1870 2870 7870 140 141 SQAAAA AKJAAA AAAAxx 2653 6345 1 1 3 13 53 653 653 2653 2653 106 107 BYAAAA BKJAAA HHHHxx 4216 6346 0 0 6 16 16 216 216 4216 4216 32 33 EGAAAA CKJAAA OOOOxx 1515 6347 1 3 5 15 15 515 1515 1515 1515 30 31 HGAAAA DKJAAA VVVVxx 7860 6348 0 0 0 0 60 860 1860 2860 7860 120 121 IQAAAA EKJAAA AAAAxx 2984 6349 0 0 4 4 84 984 984 2984 2984 168 169 UKAAAA FKJAAA HHHHxx 6269 6350 1 1 9 9 69 269 269 1269 6269 138 139 DHAAAA GKJAAA OOOOxx 2609 6351 1 1 9 9 9 609 609 2609 2609 18 19 JWAAAA HKJAAA VVVVxx 3671 6352 1 3 1 11 71 671 1671 3671 3671 142 143 FLAAAA IKJAAA AAAAxx 4544 6353 0 0 4 4 44 544 544 4544 4544 88 89 USAAAA JKJAAA HHHHxx 4668 6354 0 0 8 8 68 668 668 4668 4668 136 137 OXAAAA KKJAAA OOOOxx 2565 6355 1 1 5 5 65 565 565 2565 2565 130 131 RUAAAA LKJAAA VVVVxx 3126 6356 0 2 6 6 26 126 1126 3126 3126 52 53 GQAAAA MKJAAA AAAAxx 7573 6357 1 1 3 13 73 573 1573 2573 7573 146 147 HFAAAA NKJAAA HHHHxx 1476 6358 0 0 6 16 76 476 1476 1476 1476 152 153 UEAAAA OKJAAA OOOOxx 2146 6359 0 2 6 6 46 146 146 2146 2146 92 93 OEAAAA PKJAAA VVVVxx 9990 6360 0 2 0 10 90 990 1990 4990 9990 180 181 GUAAAA QKJAAA AAAAxx 2530 6361 0 2 0 10 30 530 530 2530 2530 60 61 ITAAAA RKJAAA HHHHxx 9288 6362 0 0 8 8 88 288 1288 4288 9288 176 177 GTAAAA SKJAAA OOOOxx 9755 6363 1 3 5 15 55 755 1755 4755 9755 110 111 FLAAAA TKJAAA VVVVxx 5305 6364 1 1 5 5 5 305 1305 305 5305 10 11 BWAAAA UKJAAA AAAAxx 2495 6365 1 3 5 15 95 495 495 2495 2495 190 191 ZRAAAA VKJAAA HHHHxx 5443 6366 1 3 3 3 43 443 1443 443 5443 86 87 JBAAAA WKJAAA OOOOxx 1930 6367 0 2 0 10 30 930 1930 1930 1930 60 61 GWAAAA XKJAAA VVVVxx 9134 6368 0 2 4 14 34 134 1134 4134 9134 68 69 INAAAA YKJAAA AAAAxx 2844 6369 0 0 4 4 44 844 844 2844 2844 88 89 KFAAAA ZKJAAA HHHHxx 896 6370 0 0 6 16 96 896 896 896 896 192 193 MIAAAA ALJAAA OOOOxx 1330 6371 0 2 0 10 30 330 1330 1330 1330 60 61 EZAAAA BLJAAA VVVVxx 8980 6372 0 0 0 0 80 980 980 3980 8980 160 161 KHAAAA CLJAAA AAAAxx 5940 6373 0 0 0 0 40 940 1940 940 5940 80 81 MUAAAA DLJAAA HHHHxx 6494 6374 0 2 4 14 94 494 494 1494 6494 188 189 UPAAAA ELJAAA OOOOxx 165 6375 1 1 5 5 65 165 165 165 165 130 131 JGAAAA FLJAAA VVVVxx 2510 6376 0 2 0 10 10 510 510 2510 2510 20 21 OSAAAA GLJAAA AAAAxx 9950 6377 0 2 0 10 50 950 1950 4950 9950 100 101 SSAAAA HLJAAA HHHHxx 3854 6378 0 2 4 14 54 854 1854 3854 3854 108 109 GSAAAA ILJAAA OOOOxx 7493 6379 1 1 3 13 93 493 1493 2493 7493 186 187 FCAAAA JLJAAA VVVVxx 4124 6380 0 0 4 4 24 124 124 4124 4124 48 49 QCAAAA KLJAAA AAAAxx 8563 6381 1 3 3 3 63 563 563 3563 8563 126 127 JRAAAA LLJAAA HHHHxx 8735 6382 1 3 5 15 35 735 735 3735 8735 70 71 ZXAAAA MLJAAA OOOOxx 9046 6383 0 2 6 6 46 46 1046 4046 9046 92 93 YJAAAA NLJAAA VVVVxx 1754 6384 0 2 4 14 54 754 1754 1754 1754 108 109 MPAAAA OLJAAA AAAAxx 6954 6385 0 2 4 14 54 954 954 1954 6954 108 109 MHAAAA PLJAAA HHHHxx 4953 6386 1 1 3 13 53 953 953 4953 4953 106 107 NIAAAA QLJAAA OOOOxx 8142 6387 0 2 2 2 42 142 142 3142 8142 84 85 EBAAAA RLJAAA VVVVxx 9661 6388 1 1 1 1 61 661 1661 4661 9661 122 123 PHAAAA SLJAAA AAAAxx 6415 6389 1 3 5 15 15 415 415 1415 6415 30 31 TMAAAA TLJAAA HHHHxx 5782 6390 0 2 2 2 82 782 1782 782 5782 164 165 KOAAAA ULJAAA OOOOxx 7721 6391 1 1 1 1 21 721 1721 2721 7721 42 43 ZKAAAA VLJAAA VVVVxx 580 6392 0 0 0 0 80 580 580 580 580 160 161 IWAAAA WLJAAA AAAAxx 3784 6393 0 0 4 4 84 784 1784 3784 3784 168 169 OPAAAA XLJAAA HHHHxx 9810 6394 0 2 0 10 10 810 1810 4810 9810 20 21 INAAAA YLJAAA OOOOxx 8488 6395 0 0 8 8 88 488 488 3488 8488 176 177 MOAAAA ZLJAAA VVVVxx 6214 6396 0 2 4 14 14 214 214 1214 6214 28 29 AFAAAA AMJAAA AAAAxx 9433 6397 1 1 3 13 33 433 1433 4433 9433 66 67 VYAAAA BMJAAA HHHHxx 9959 6398 1 3 9 19 59 959 1959 4959 9959 118 119 BTAAAA CMJAAA OOOOxx 554 6399 0 2 4 14 54 554 554 554 554 108 109 IVAAAA DMJAAA VVVVxx 6646 6400 0 2 6 6 46 646 646 1646 6646 92 93 QVAAAA EMJAAA AAAAxx 1138 6401 0 2 8 18 38 138 1138 1138 1138 76 77 URAAAA FMJAAA HHHHxx 9331 6402 1 3 1 11 31 331 1331 4331 9331 62 63 XUAAAA GMJAAA OOOOxx 7331 6403 1 3 1 11 31 331 1331 2331 7331 62 63 ZVAAAA HMJAAA VVVVxx 3482 6404 0 2 2 2 82 482 1482 3482 3482 164 165 YDAAAA IMJAAA AAAAxx 3795 6405 1 3 5 15 95 795 1795 3795 3795 190 191 ZPAAAA JMJAAA HHHHxx 2441 6406 1 1 1 1 41 441 441 2441 2441 82 83 XPAAAA KMJAAA OOOOxx 5229 6407 1 1 9 9 29 229 1229 229 5229 58 59 DTAAAA LMJAAA VVVVxx 7012 6408 0 0 2 12 12 12 1012 2012 7012 24 25 SJAAAA MMJAAA AAAAxx 7036 6409 0 0 6 16 36 36 1036 2036 7036 72 73 QKAAAA NMJAAA HHHHxx 8243 6410 1 3 3 3 43 243 243 3243 8243 86 87 BFAAAA OMJAAA OOOOxx 9320 6411 0 0 0 0 20 320 1320 4320 9320 40 41 MUAAAA PMJAAA VVVVxx 4693 6412 1 1 3 13 93 693 693 4693 4693 186 187 NYAAAA QMJAAA AAAAxx 6741 6413 1 1 1 1 41 741 741 1741 6741 82 83 HZAAAA RMJAAA HHHHxx 2997 6414 1 1 7 17 97 997 997 2997 2997 194 195 HLAAAA SMJAAA OOOOxx 4838 6415 0 2 8 18 38 838 838 4838 4838 76 77 CEAAAA TMJAAA VVVVxx 6945 6416 1 1 5 5 45 945 945 1945 6945 90 91 DHAAAA UMJAAA AAAAxx 8253 6417 1 1 3 13 53 253 253 3253 8253 106 107 LFAAAA VMJAAA HHHHxx 8989 6418 1 1 9 9 89 989 989 3989 8989 178 179 THAAAA WMJAAA OOOOxx 2640 6419 0 0 0 0 40 640 640 2640 2640 80 81 OXAAAA XMJAAA VVVVxx 5647 6420 1 3 7 7 47 647 1647 647 5647 94 95 FJAAAA YMJAAA AAAAxx 7186 6421 0 2 6 6 86 186 1186 2186 7186 172 173 KQAAAA ZMJAAA HHHHxx 3278 6422 0 2 8 18 78 278 1278 3278 3278 156 157 CWAAAA ANJAAA OOOOxx 8546 6423 0 2 6 6 46 546 546 3546 8546 92 93 SQAAAA BNJAAA VVVVxx 8297 6424 1 1 7 17 97 297 297 3297 8297 194 195 DHAAAA CNJAAA AAAAxx 9534 6425 0 2 4 14 34 534 1534 4534 9534 68 69 SCAAAA DNJAAA HHHHxx 9618 6426 0 2 8 18 18 618 1618 4618 9618 36 37 YFAAAA ENJAAA OOOOxx 8839 6427 1 3 9 19 39 839 839 3839 8839 78 79 ZBAAAA FNJAAA VVVVxx 7605 6428 1 1 5 5 5 605 1605 2605 7605 10 11 NGAAAA GNJAAA AAAAxx 6421 6429 1 1 1 1 21 421 421 1421 6421 42 43 ZMAAAA HNJAAA HHHHxx 3582 6430 0 2 2 2 82 582 1582 3582 3582 164 165 UHAAAA INJAAA OOOOxx 485 6431 1 1 5 5 85 485 485 485 485 170 171 RSAAAA JNJAAA VVVVxx 1925 6432 1 1 5 5 25 925 1925 1925 1925 50 51 BWAAAA KNJAAA AAAAxx 4296 6433 0 0 6 16 96 296 296 4296 4296 192 193 GJAAAA LNJAAA HHHHxx 8874 6434 0 2 4 14 74 874 874 3874 8874 148 149 IDAAAA MNJAAA OOOOxx 1443 6435 1 3 3 3 43 443 1443 1443 1443 86 87 NDAAAA NNJAAA VVVVxx 4239 6436 1 3 9 19 39 239 239 4239 4239 78 79 BHAAAA ONJAAA AAAAxx 9760 6437 0 0 0 0 60 760 1760 4760 9760 120 121 KLAAAA PNJAAA HHHHxx 136 6438 0 0 6 16 36 136 136 136 136 72 73 GFAAAA QNJAAA OOOOxx 6472 6439 0 0 2 12 72 472 472 1472 6472 144 145 YOAAAA RNJAAA VVVVxx 4896 6440 0 0 6 16 96 896 896 4896 4896 192 193 IGAAAA SNJAAA AAAAxx 9028 6441 0 0 8 8 28 28 1028 4028 9028 56 57 GJAAAA TNJAAA HHHHxx 8354 6442 0 2 4 14 54 354 354 3354 8354 108 109 IJAAAA UNJAAA OOOOxx 8648 6443 0 0 8 8 48 648 648 3648 8648 96 97 QUAAAA VNJAAA VVVVxx 918 6444 0 2 8 18 18 918 918 918 918 36 37 IJAAAA WNJAAA AAAAxx 6606 6445 0 2 6 6 6 606 606 1606 6606 12 13 CUAAAA XNJAAA HHHHxx 2462 6446 0 2 2 2 62 462 462 2462 2462 124 125 SQAAAA YNJAAA OOOOxx 7536 6447 0 0 6 16 36 536 1536 2536 7536 72 73 WDAAAA ZNJAAA VVVVxx 1700 6448 0 0 0 0 0 700 1700 1700 1700 0 1 KNAAAA AOJAAA AAAAxx 6740 6449 0 0 0 0 40 740 740 1740 6740 80 81 GZAAAA BOJAAA HHHHxx 28 6450 0 0 8 8 28 28 28 28 28 56 57 CBAAAA COJAAA OOOOxx 6044 6451 0 0 4 4 44 44 44 1044 6044 88 89 MYAAAA DOJAAA VVVVxx 5053 6452 1 1 3 13 53 53 1053 53 5053 106 107 JMAAAA EOJAAA AAAAxx 4832 6453 0 0 2 12 32 832 832 4832 4832 64 65 WDAAAA FOJAAA HHHHxx 9145 6454 1 1 5 5 45 145 1145 4145 9145 90 91 TNAAAA GOJAAA OOOOxx 5482 6455 0 2 2 2 82 482 1482 482 5482 164 165 WCAAAA HOJAAA VVVVxx 7644 6456 0 0 4 4 44 644 1644 2644 7644 88 89 AIAAAA IOJAAA AAAAxx 2128 6457 0 0 8 8 28 128 128 2128 2128 56 57 WDAAAA JOJAAA HHHHxx 6583 6458 1 3 3 3 83 583 583 1583 6583 166 167 FTAAAA KOJAAA OOOOxx 4224 6459 0 0 4 4 24 224 224 4224 4224 48 49 MGAAAA LOJAAA VVVVxx 5253 6460 1 1 3 13 53 253 1253 253 5253 106 107 BUAAAA MOJAAA AAAAxx 8219 6461 1 3 9 19 19 219 219 3219 8219 38 39 DEAAAA NOJAAA HHHHxx 8113 6462 1 1 3 13 13 113 113 3113 8113 26 27 BAAAAA OOJAAA OOOOxx 3616 6463 0 0 6 16 16 616 1616 3616 3616 32 33 CJAAAA POJAAA VVVVxx 1361 6464 1 1 1 1 61 361 1361 1361 1361 122 123 JAAAAA QOJAAA AAAAxx 949 6465 1 1 9 9 49 949 949 949 949 98 99 NKAAAA ROJAAA HHHHxx 8582 6466 0 2 2 2 82 582 582 3582 8582 164 165 CSAAAA SOJAAA OOOOxx 5104 6467 0 0 4 4 4 104 1104 104 5104 8 9 IOAAAA TOJAAA VVVVxx 6146 6468 0 2 6 6 46 146 146 1146 6146 92 93 KCAAAA UOJAAA AAAAxx 7681 6469 1 1 1 1 81 681 1681 2681 7681 162 163 LJAAAA VOJAAA HHHHxx 1904 6470 0 0 4 4 4 904 1904 1904 1904 8 9 GVAAAA WOJAAA OOOOxx 1989 6471 1 1 9 9 89 989 1989 1989 1989 178 179 NYAAAA XOJAAA VVVVxx 4179 6472 1 3 9 19 79 179 179 4179 4179 158 159 TEAAAA YOJAAA AAAAxx 1739 6473 1 3 9 19 39 739 1739 1739 1739 78 79 XOAAAA ZOJAAA HHHHxx 2447 6474 1 3 7 7 47 447 447 2447 2447 94 95 DQAAAA APJAAA OOOOxx 3029 6475 1 1 9 9 29 29 1029 3029 3029 58 59 NMAAAA BPJAAA VVVVxx 9783 6476 1 3 3 3 83 783 1783 4783 9783 166 167 HMAAAA CPJAAA AAAAxx 8381 6477 1 1 1 1 81 381 381 3381 8381 162 163 JKAAAA DPJAAA HHHHxx 8755 6478 1 3 5 15 55 755 755 3755 8755 110 111 TYAAAA EPJAAA OOOOxx 8384 6479 0 0 4 4 84 384 384 3384 8384 168 169 MKAAAA FPJAAA VVVVxx 7655 6480 1 3 5 15 55 655 1655 2655 7655 110 111 LIAAAA GPJAAA AAAAxx 4766 6481 0 2 6 6 66 766 766 4766 4766 132 133 IBAAAA HPJAAA HHHHxx 3324 6482 0 0 4 4 24 324 1324 3324 3324 48 49 WXAAAA IPJAAA OOOOxx 5022 6483 0 2 2 2 22 22 1022 22 5022 44 45 ELAAAA JPJAAA VVVVxx 2856 6484 0 0 6 16 56 856 856 2856 2856 112 113 WFAAAA KPJAAA AAAAxx 6503 6485 1 3 3 3 3 503 503 1503 6503 6 7 DQAAAA LPJAAA HHHHxx 6872 6486 0 0 2 12 72 872 872 1872 6872 144 145 IEAAAA MPJAAA OOOOxx 1663 6487 1 3 3 3 63 663 1663 1663 1663 126 127 ZLAAAA NPJAAA VVVVxx 6964 6488 0 0 4 4 64 964 964 1964 6964 128 129 WHAAAA OPJAAA AAAAxx 4622 6489 0 2 2 2 22 622 622 4622 4622 44 45 UVAAAA PPJAAA HHHHxx 6089 6490 1 1 9 9 89 89 89 1089 6089 178 179 FAAAAA QPJAAA OOOOxx 8567 6491 1 3 7 7 67 567 567 3567 8567 134 135 NRAAAA RPJAAA VVVVxx 597 6492 1 1 7 17 97 597 597 597 597 194 195 ZWAAAA SPJAAA AAAAxx 4222 6493 0 2 2 2 22 222 222 4222 4222 44 45 KGAAAA TPJAAA HHHHxx 9322 6494 0 2 2 2 22 322 1322 4322 9322 44 45 OUAAAA UPJAAA OOOOxx 624 6495 0 0 4 4 24 624 624 624 624 48 49 AYAAAA VPJAAA VVVVxx 4329 6496 1 1 9 9 29 329 329 4329 4329 58 59 NKAAAA WPJAAA AAAAxx 6781 6497 1 1 1 1 81 781 781 1781 6781 162 163 VAAAAA XPJAAA HHHHxx 1673 6498 1 1 3 13 73 673 1673 1673 1673 146 147 JMAAAA YPJAAA OOOOxx 6633 6499 1 1 3 13 33 633 633 1633 6633 66 67 DVAAAA ZPJAAA VVVVxx 2569 6500 1 1 9 9 69 569 569 2569 2569 138 139 VUAAAA AQJAAA AAAAxx 4995 6501 1 3 5 15 95 995 995 4995 4995 190 191 DKAAAA BQJAAA HHHHxx 2749 6502 1 1 9 9 49 749 749 2749 2749 98 99 TBAAAA CQJAAA OOOOxx 9044 6503 0 0 4 4 44 44 1044 4044 9044 88 89 WJAAAA DQJAAA VVVVxx 5823 6504 1 3 3 3 23 823 1823 823 5823 46 47 ZPAAAA EQJAAA AAAAxx 9366 6505 0 2 6 6 66 366 1366 4366 9366 132 133 GWAAAA FQJAAA HHHHxx 1169 6506 1 1 9 9 69 169 1169 1169 1169 138 139 ZSAAAA GQJAAA OOOOxx 1300 6507 0 0 0 0 0 300 1300 1300 1300 0 1 AYAAAA HQJAAA VVVVxx 9973 6508 1 1 3 13 73 973 1973 4973 9973 146 147 PTAAAA IQJAAA AAAAxx 2092 6509 0 0 2 12 92 92 92 2092 2092 184 185 MCAAAA JQJAAA HHHHxx 9776 6510 0 0 6 16 76 776 1776 4776 9776 152 153 AMAAAA KQJAAA OOOOxx 7612 6511 0 0 2 12 12 612 1612 2612 7612 24 25 UGAAAA LQJAAA VVVVxx 7190 6512 0 2 0 10 90 190 1190 2190 7190 180 181 OQAAAA MQJAAA AAAAxx 5147 6513 1 3 7 7 47 147 1147 147 5147 94 95 ZPAAAA NQJAAA HHHHxx 3722 6514 0 2 2 2 22 722 1722 3722 3722 44 45 ENAAAA OQJAAA OOOOxx 5858 6515 0 2 8 18 58 858 1858 858 5858 116 117 IRAAAA PQJAAA VVVVxx 3204 6516 0 0 4 4 4 204 1204 3204 3204 8 9 GTAAAA QQJAAA AAAAxx 8994 6517 0 2 4 14 94 994 994 3994 8994 188 189 YHAAAA RQJAAA HHHHxx 7478 6518 0 2 8 18 78 478 1478 2478 7478 156 157 QBAAAA SQJAAA OOOOxx 9624 6519 0 0 4 4 24 624 1624 4624 9624 48 49 EGAAAA TQJAAA VVVVxx 6639 6520 1 3 9 19 39 639 639 1639 6639 78 79 JVAAAA UQJAAA AAAAxx 369 6521 1 1 9 9 69 369 369 369 369 138 139 FOAAAA VQJAAA HHHHxx 7766 6522 0 2 6 6 66 766 1766 2766 7766 132 133 SMAAAA WQJAAA OOOOxx 4094 6523 0 2 4 14 94 94 94 4094 4094 188 189 MBAAAA XQJAAA VVVVxx 9556 6524 0 0 6 16 56 556 1556 4556 9556 112 113 ODAAAA YQJAAA AAAAxx 4887 6525 1 3 7 7 87 887 887 4887 4887 174 175 ZFAAAA ZQJAAA HHHHxx 2321 6526 1 1 1 1 21 321 321 2321 2321 42 43 HLAAAA ARJAAA OOOOxx 9201 6527 1 1 1 1 1 201 1201 4201 9201 2 3 XPAAAA BRJAAA VVVVxx 1627 6528 1 3 7 7 27 627 1627 1627 1627 54 55 PKAAAA CRJAAA AAAAxx 150 6529 0 2 0 10 50 150 150 150 150 100 101 UFAAAA DRJAAA HHHHxx 8010 6530 0 2 0 10 10 10 10 3010 8010 20 21 CWAAAA ERJAAA OOOOxx 8026 6531 0 2 6 6 26 26 26 3026 8026 52 53 SWAAAA FRJAAA VVVVxx 5495 6532 1 3 5 15 95 495 1495 495 5495 190 191 JDAAAA GRJAAA AAAAxx 6213 6533 1 1 3 13 13 213 213 1213 6213 26 27 ZEAAAA HRJAAA HHHHxx 6464 6534 0 0 4 4 64 464 464 1464 6464 128 129 QOAAAA IRJAAA OOOOxx 1158 6535 0 2 8 18 58 158 1158 1158 1158 116 117 OSAAAA JRJAAA VVVVxx 8669 6536 1 1 9 9 69 669 669 3669 8669 138 139 LVAAAA KRJAAA AAAAxx 3225 6537 1 1 5 5 25 225 1225 3225 3225 50 51 BUAAAA LRJAAA HHHHxx 1294 6538 0 2 4 14 94 294 1294 1294 1294 188 189 UXAAAA MRJAAA OOOOxx 2166 6539 0 2 6 6 66 166 166 2166 2166 132 133 IFAAAA NRJAAA VVVVxx 9328 6540 0 0 8 8 28 328 1328 4328 9328 56 57 UUAAAA ORJAAA AAAAxx 8431 6541 1 3 1 11 31 431 431 3431 8431 62 63 HMAAAA PRJAAA HHHHxx 7100 6542 0 0 0 0 0 100 1100 2100 7100 0 1 CNAAAA QRJAAA OOOOxx 8126 6543 0 2 6 6 26 126 126 3126 8126 52 53 OAAAAA RRJAAA VVVVxx 2185 6544 1 1 5 5 85 185 185 2185 2185 170 171 BGAAAA SRJAAA AAAAxx 5697 6545 1 1 7 17 97 697 1697 697 5697 194 195 DLAAAA TRJAAA HHHHxx 5531 6546 1 3 1 11 31 531 1531 531 5531 62 63 TEAAAA URJAAA OOOOxx 3020 6547 0 0 0 0 20 20 1020 3020 3020 40 41 EMAAAA VRJAAA VVVVxx 3076 6548 0 0 6 16 76 76 1076 3076 3076 152 153 IOAAAA WRJAAA AAAAxx 9228 6549 0 0 8 8 28 228 1228 4228 9228 56 57 YQAAAA XRJAAA HHHHxx 1734 6550 0 2 4 14 34 734 1734 1734 1734 68 69 SOAAAA YRJAAA OOOOxx 7616 6551 0 0 6 16 16 616 1616 2616 7616 32 33 YGAAAA ZRJAAA VVVVxx 9059 6552 1 3 9 19 59 59 1059 4059 9059 118 119 LKAAAA ASJAAA AAAAxx 323 6553 1 3 3 3 23 323 323 323 323 46 47 LMAAAA BSJAAA HHHHxx 1283 6554 1 3 3 3 83 283 1283 1283 1283 166 167 JXAAAA CSJAAA OOOOxx 9535 6555 1 3 5 15 35 535 1535 4535 9535 70 71 TCAAAA DSJAAA VVVVxx 2580 6556 0 0 0 0 80 580 580 2580 2580 160 161 GVAAAA ESJAAA AAAAxx 7633 6557 1 1 3 13 33 633 1633 2633 7633 66 67 PHAAAA FSJAAA HHHHxx 9497 6558 1 1 7 17 97 497 1497 4497 9497 194 195 HBAAAA GSJAAA OOOOxx 9842 6559 0 2 2 2 42 842 1842 4842 9842 84 85 OOAAAA HSJAAA VVVVxx 3426 6560 0 2 6 6 26 426 1426 3426 3426 52 53 UBAAAA ISJAAA AAAAxx 7650 6561 0 2 0 10 50 650 1650 2650 7650 100 101 GIAAAA JSJAAA HHHHxx 9935 6562 1 3 5 15 35 935 1935 4935 9935 70 71 DSAAAA KSJAAA OOOOxx 9354 6563 0 2 4 14 54 354 1354 4354 9354 108 109 UVAAAA LSJAAA VVVVxx 5569 6564 1 1 9 9 69 569 1569 569 5569 138 139 FGAAAA MSJAAA AAAAxx 5765 6565 1 1 5 5 65 765 1765 765 5765 130 131 TNAAAA NSJAAA HHHHxx 7283 6566 1 3 3 3 83 283 1283 2283 7283 166 167 DUAAAA OSJAAA OOOOxx 1068 6567 0 0 8 8 68 68 1068 1068 1068 136 137 CPAAAA PSJAAA VVVVxx 1641 6568 1 1 1 1 41 641 1641 1641 1641 82 83 DLAAAA QSJAAA AAAAxx 1688 6569 0 0 8 8 88 688 1688 1688 1688 176 177 YMAAAA RSJAAA HHHHxx 1133 6570 1 1 3 13 33 133 1133 1133 1133 66 67 PRAAAA SSJAAA OOOOxx 4493 6571 1 1 3 13 93 493 493 4493 4493 186 187 VQAAAA TSJAAA VVVVxx 3354 6572 0 2 4 14 54 354 1354 3354 3354 108 109 AZAAAA USJAAA AAAAxx 4029 6573 1 1 9 9 29 29 29 4029 4029 58 59 ZYAAAA VSJAAA HHHHxx 6704 6574 0 0 4 4 4 704 704 1704 6704 8 9 WXAAAA WSJAAA OOOOxx 3221 6575 1 1 1 1 21 221 1221 3221 3221 42 43 XTAAAA XSJAAA VVVVxx 9432 6576 0 0 2 12 32 432 1432 4432 9432 64 65 UYAAAA YSJAAA AAAAxx 6990 6577 0 2 0 10 90 990 990 1990 6990 180 181 WIAAAA ZSJAAA HHHHxx 1760 6578 0 0 0 0 60 760 1760 1760 1760 120 121 SPAAAA ATJAAA OOOOxx 4754 6579 0 2 4 14 54 754 754 4754 4754 108 109 WAAAAA BTJAAA VVVVxx 7724 6580 0 0 4 4 24 724 1724 2724 7724 48 49 CLAAAA CTJAAA AAAAxx 9487 6581 1 3 7 7 87 487 1487 4487 9487 174 175 XAAAAA DTJAAA HHHHxx 166 6582 0 2 6 6 66 166 166 166 166 132 133 KGAAAA ETJAAA OOOOxx 5479 6583 1 3 9 19 79 479 1479 479 5479 158 159 TCAAAA FTJAAA VVVVxx 8744 6584 0 0 4 4 44 744 744 3744 8744 88 89 IYAAAA GTJAAA AAAAxx 5746 6585 0 2 6 6 46 746 1746 746 5746 92 93 ANAAAA HTJAAA HHHHxx 907 6586 1 3 7 7 7 907 907 907 907 14 15 XIAAAA ITJAAA OOOOxx 3968 6587 0 0 8 8 68 968 1968 3968 3968 136 137 QWAAAA JTJAAA VVVVxx 5721 6588 1 1 1 1 21 721 1721 721 5721 42 43 BMAAAA KTJAAA AAAAxx 6738 6589 0 2 8 18 38 738 738 1738 6738 76 77 EZAAAA LTJAAA HHHHxx 4097 6590 1 1 7 17 97 97 97 4097 4097 194 195 PBAAAA MTJAAA OOOOxx 8456 6591 0 0 6 16 56 456 456 3456 8456 112 113 GNAAAA NTJAAA VVVVxx 1269 6592 1 1 9 9 69 269 1269 1269 1269 138 139 VWAAAA OTJAAA AAAAxx 7997 6593 1 1 7 17 97 997 1997 2997 7997 194 195 PVAAAA PTJAAA HHHHxx 9457 6594 1 1 7 17 57 457 1457 4457 9457 114 115 TZAAAA QTJAAA OOOOxx 1159 6595 1 3 9 19 59 159 1159 1159 1159 118 119 PSAAAA RTJAAA VVVVxx 1631 6596 1 3 1 11 31 631 1631 1631 1631 62 63 TKAAAA STJAAA AAAAxx 2019 6597 1 3 9 19 19 19 19 2019 2019 38 39 RZAAAA TTJAAA HHHHxx 3186 6598 0 2 6 6 86 186 1186 3186 3186 172 173 OSAAAA UTJAAA OOOOxx 5587 6599 1 3 7 7 87 587 1587 587 5587 174 175 XGAAAA VTJAAA VVVVxx 9172 6600 0 0 2 12 72 172 1172 4172 9172 144 145 UOAAAA WTJAAA AAAAxx 5589 6601 1 1 9 9 89 589 1589 589 5589 178 179 ZGAAAA XTJAAA HHHHxx 5103 6602 1 3 3 3 3 103 1103 103 5103 6 7 HOAAAA YTJAAA OOOOxx 3177 6603 1 1 7 17 77 177 1177 3177 3177 154 155 FSAAAA ZTJAAA VVVVxx 8887 6604 1 3 7 7 87 887 887 3887 8887 174 175 VDAAAA AUJAAA AAAAxx 12 6605 0 0 2 12 12 12 12 12 12 24 25 MAAAAA BUJAAA HHHHxx 8575 6606 1 3 5 15 75 575 575 3575 8575 150 151 VRAAAA CUJAAA OOOOxx 4335 6607 1 3 5 15 35 335 335 4335 4335 70 71 TKAAAA DUJAAA VVVVxx 4581 6608 1 1 1 1 81 581 581 4581 4581 162 163 FUAAAA EUJAAA AAAAxx 4444 6609 0 0 4 4 44 444 444 4444 4444 88 89 YOAAAA FUJAAA HHHHxx 7978 6610 0 2 8 18 78 978 1978 2978 7978 156 157 WUAAAA GUJAAA OOOOxx 3081 6611 1 1 1 1 81 81 1081 3081 3081 162 163 NOAAAA HUJAAA VVVVxx 4059 6612 1 3 9 19 59 59 59 4059 4059 118 119 DAAAAA IUJAAA AAAAxx 5711 6613 1 3 1 11 11 711 1711 711 5711 22 23 RLAAAA JUJAAA HHHHxx 7069 6614 1 1 9 9 69 69 1069 2069 7069 138 139 XLAAAA KUJAAA OOOOxx 6150 6615 0 2 0 10 50 150 150 1150 6150 100 101 OCAAAA LUJAAA VVVVxx 9550 6616 0 2 0 10 50 550 1550 4550 9550 100 101 IDAAAA MUJAAA AAAAxx 7087 6617 1 3 7 7 87 87 1087 2087 7087 174 175 PMAAAA NUJAAA HHHHxx 9557 6618 1 1 7 17 57 557 1557 4557 9557 114 115 PDAAAA OUJAAA OOOOxx 7856 6619 0 0 6 16 56 856 1856 2856 7856 112 113 EQAAAA PUJAAA VVVVxx 1115 6620 1 3 5 15 15 115 1115 1115 1115 30 31 XQAAAA QUJAAA AAAAxx 1086 6621 0 2 6 6 86 86 1086 1086 1086 172 173 UPAAAA RUJAAA HHHHxx 5048 6622 0 0 8 8 48 48 1048 48 5048 96 97 EMAAAA SUJAAA OOOOxx 5168 6623 0 0 8 8 68 168 1168 168 5168 136 137 UQAAAA TUJAAA VVVVxx 6029 6624 1 1 9 9 29 29 29 1029 6029 58 59 XXAAAA UUJAAA AAAAxx 546 6625 0 2 6 6 46 546 546 546 546 92 93 AVAAAA VUJAAA HHHHxx 2908 6626 0 0 8 8 8 908 908 2908 2908 16 17 WHAAAA WUJAAA OOOOxx 779 6627 1 3 9 19 79 779 779 779 779 158 159 ZDAAAA XUJAAA VVVVxx 4202 6628 0 2 2 2 2 202 202 4202 4202 4 5 QFAAAA YUJAAA AAAAxx 9984 6629 0 0 4 4 84 984 1984 4984 9984 168 169 AUAAAA ZUJAAA HHHHxx 4730 6630 0 2 0 10 30 730 730 4730 4730 60 61 YZAAAA AVJAAA OOOOxx 6517 6631 1 1 7 17 17 517 517 1517 6517 34 35 RQAAAA BVJAAA VVVVxx 8410 6632 0 2 0 10 10 410 410 3410 8410 20 21 MLAAAA CVJAAA AAAAxx 4793 6633 1 1 3 13 93 793 793 4793 4793 186 187 JCAAAA DVJAAA HHHHxx 3431 6634 1 3 1 11 31 431 1431 3431 3431 62 63 ZBAAAA EVJAAA OOOOxx 2481 6635 1 1 1 1 81 481 481 2481 2481 162 163 LRAAAA FVJAAA VVVVxx 3905 6636 1 1 5 5 5 905 1905 3905 3905 10 11 FUAAAA GVJAAA AAAAxx 8807 6637 1 3 7 7 7 807 807 3807 8807 14 15 TAAAAA HVJAAA HHHHxx 2660 6638 0 0 0 0 60 660 660 2660 2660 120 121 IYAAAA IVJAAA OOOOxx 4985 6639 1 1 5 5 85 985 985 4985 4985 170 171 TJAAAA JVJAAA VVVVxx 3080 6640 0 0 0 0 80 80 1080 3080 3080 160 161 MOAAAA KVJAAA AAAAxx 1090 6641 0 2 0 10 90 90 1090 1090 1090 180 181 YPAAAA LVJAAA HHHHxx 6917 6642 1 1 7 17 17 917 917 1917 6917 34 35 BGAAAA MVJAAA OOOOxx 5177 6643 1 1 7 17 77 177 1177 177 5177 154 155 DRAAAA NVJAAA VVVVxx 2729 6644 1 1 9 9 29 729 729 2729 2729 58 59 ZAAAAA OVJAAA AAAAxx 9706 6645 0 2 6 6 6 706 1706 4706 9706 12 13 IJAAAA PVJAAA HHHHxx 9929 6646 1 1 9 9 29 929 1929 4929 9929 58 59 XRAAAA QVJAAA OOOOxx 1547 6647 1 3 7 7 47 547 1547 1547 1547 94 95 NHAAAA RVJAAA VVVVxx 2798 6648 0 2 8 18 98 798 798 2798 2798 196 197 QDAAAA SVJAAA AAAAxx 4420 6649 0 0 0 0 20 420 420 4420 4420 40 41 AOAAAA TVJAAA HHHHxx 6771 6650 1 3 1 11 71 771 771 1771 6771 142 143 LAAAAA UVJAAA OOOOxx 2004 6651 0 0 4 4 4 4 4 2004 2004 8 9 CZAAAA VVJAAA VVVVxx 8686 6652 0 2 6 6 86 686 686 3686 8686 172 173 CWAAAA WVJAAA AAAAxx 3663 6653 1 3 3 3 63 663 1663 3663 3663 126 127 XKAAAA XVJAAA HHHHxx 806 6654 0 2 6 6 6 806 806 806 806 12 13 AFAAAA YVJAAA OOOOxx 4309 6655 1 1 9 9 9 309 309 4309 4309 18 19 TJAAAA ZVJAAA VVVVxx 7443 6656 1 3 3 3 43 443 1443 2443 7443 86 87 HAAAAA AWJAAA AAAAxx 5779 6657 1 3 9 19 79 779 1779 779 5779 158 159 HOAAAA BWJAAA HHHHxx 8821 6658 1 1 1 1 21 821 821 3821 8821 42 43 HBAAAA CWJAAA OOOOxx 4198 6659 0 2 8 18 98 198 198 4198 4198 196 197 MFAAAA DWJAAA VVVVxx 8115 6660 1 3 5 15 15 115 115 3115 8115 30 31 DAAAAA EWJAAA AAAAxx 9554 6661 0 2 4 14 54 554 1554 4554 9554 108 109 MDAAAA FWJAAA HHHHxx 8956 6662 0 0 6 16 56 956 956 3956 8956 112 113 MGAAAA GWJAAA OOOOxx 4733 6663 1 1 3 13 33 733 733 4733 4733 66 67 BAAAAA HWJAAA VVVVxx 5417 6664 1 1 7 17 17 417 1417 417 5417 34 35 JAAAAA IWJAAA AAAAxx 4792 6665 0 0 2 12 92 792 792 4792 4792 184 185 ICAAAA JWJAAA HHHHxx 462 6666 0 2 2 2 62 462 462 462 462 124 125 URAAAA KWJAAA OOOOxx 3687 6667 1 3 7 7 87 687 1687 3687 3687 174 175 VLAAAA LWJAAA VVVVxx 2013 6668 1 1 3 13 13 13 13 2013 2013 26 27 LZAAAA MWJAAA AAAAxx 5386 6669 0 2 6 6 86 386 1386 386 5386 172 173 EZAAAA NWJAAA HHHHxx 2816 6670 0 0 6 16 16 816 816 2816 2816 32 33 IEAAAA OWJAAA OOOOxx 7827 6671 1 3 7 7 27 827 1827 2827 7827 54 55 BPAAAA PWJAAA VVVVxx 5077 6672 1 1 7 17 77 77 1077 77 5077 154 155 HNAAAA QWJAAA AAAAxx 6039 6673 1 3 9 19 39 39 39 1039 6039 78 79 HYAAAA RWJAAA HHHHxx 215 6674 1 3 5 15 15 215 215 215 215 30 31 HIAAAA SWJAAA OOOOxx 855 6675 1 3 5 15 55 855 855 855 855 110 111 XGAAAA TWJAAA VVVVxx 9692 6676 0 0 2 12 92 692 1692 4692 9692 184 185 UIAAAA UWJAAA AAAAxx 8391 6677 1 3 1 11 91 391 391 3391 8391 182 183 TKAAAA VWJAAA HHHHxx 8424 6678 0 0 4 4 24 424 424 3424 8424 48 49 AMAAAA WWJAAA OOOOxx 6331 6679 1 3 1 11 31 331 331 1331 6331 62 63 NJAAAA XWJAAA VVVVxx 6561 6680 1 1 1 1 61 561 561 1561 6561 122 123 JSAAAA YWJAAA AAAAxx 8955 6681 1 3 5 15 55 955 955 3955 8955 110 111 LGAAAA ZWJAAA HHHHxx 1764 6682 0 0 4 4 64 764 1764 1764 1764 128 129 WPAAAA AXJAAA OOOOxx 6623 6683 1 3 3 3 23 623 623 1623 6623 46 47 TUAAAA BXJAAA VVVVxx 2900 6684 0 0 0 0 0 900 900 2900 2900 0 1 OHAAAA CXJAAA AAAAxx 7048 6685 0 0 8 8 48 48 1048 2048 7048 96 97 CLAAAA DXJAAA HHHHxx 3843 6686 1 3 3 3 43 843 1843 3843 3843 86 87 VRAAAA EXJAAA OOOOxx 4855 6687 1 3 5 15 55 855 855 4855 4855 110 111 TEAAAA FXJAAA VVVVxx 7383 6688 1 3 3 3 83 383 1383 2383 7383 166 167 ZXAAAA GXJAAA AAAAxx 7765 6689 1 1 5 5 65 765 1765 2765 7765 130 131 RMAAAA HXJAAA HHHHxx 1125 6690 1 1 5 5 25 125 1125 1125 1125 50 51 HRAAAA IXJAAA OOOOxx 755 6691 1 3 5 15 55 755 755 755 755 110 111 BDAAAA JXJAAA VVVVxx 2995 6692 1 3 5 15 95 995 995 2995 2995 190 191 FLAAAA KXJAAA AAAAxx 8907 6693 1 3 7 7 7 907 907 3907 8907 14 15 PEAAAA LXJAAA HHHHxx 9357 6694 1 1 7 17 57 357 1357 4357 9357 114 115 XVAAAA MXJAAA OOOOxx 4469 6695 1 1 9 9 69 469 469 4469 4469 138 139 XPAAAA NXJAAA VVVVxx 2147 6696 1 3 7 7 47 147 147 2147 2147 94 95 PEAAAA OXJAAA AAAAxx 2952 6697 0 0 2 12 52 952 952 2952 2952 104 105 OJAAAA PXJAAA HHHHxx 1324 6698 0 0 4 4 24 324 1324 1324 1324 48 49 YYAAAA QXJAAA OOOOxx 1173 6699 1 1 3 13 73 173 1173 1173 1173 146 147 DTAAAA RXJAAA VVVVxx 3169 6700 1 1 9 9 69 169 1169 3169 3169 138 139 XRAAAA SXJAAA AAAAxx 5149 6701 1 1 9 9 49 149 1149 149 5149 98 99 BQAAAA TXJAAA HHHHxx 9660 6702 0 0 0 0 60 660 1660 4660 9660 120 121 OHAAAA UXJAAA OOOOxx 3446 6703 0 2 6 6 46 446 1446 3446 3446 92 93 OCAAAA VXJAAA VVVVxx 6988 6704 0 0 8 8 88 988 988 1988 6988 176 177 UIAAAA WXJAAA AAAAxx 5829 6705 1 1 9 9 29 829 1829 829 5829 58 59 FQAAAA XXJAAA HHHHxx 7166 6706 0 2 6 6 66 166 1166 2166 7166 132 133 QPAAAA YXJAAA OOOOxx 3940 6707 0 0 0 0 40 940 1940 3940 3940 80 81 OVAAAA ZXJAAA VVVVxx 2645 6708 1 1 5 5 45 645 645 2645 2645 90 91 TXAAAA AYJAAA AAAAxx 478 6709 0 2 8 18 78 478 478 478 478 156 157 KSAAAA BYJAAA HHHHxx 1156 6710 0 0 6 16 56 156 1156 1156 1156 112 113 MSAAAA CYJAAA OOOOxx 2731 6711 1 3 1 11 31 731 731 2731 2731 62 63 BBAAAA DYJAAA VVVVxx 5637 6712 1 1 7 17 37 637 1637 637 5637 74 75 VIAAAA EYJAAA AAAAxx 7517 6713 1 1 7 17 17 517 1517 2517 7517 34 35 DDAAAA FYJAAA HHHHxx 5331 6714 1 3 1 11 31 331 1331 331 5331 62 63 BXAAAA GYJAAA OOOOxx 9640 6715 0 0 0 0 40 640 1640 4640 9640 80 81 UGAAAA HYJAAA VVVVxx 4108 6716 0 0 8 8 8 108 108 4108 4108 16 17 ACAAAA IYJAAA AAAAxx 1087 6717 1 3 7 7 87 87 1087 1087 1087 174 175 VPAAAA JYJAAA HHHHxx 8017 6718 1 1 7 17 17 17 17 3017 8017 34 35 JWAAAA KYJAAA OOOOxx 8795 6719 1 3 5 15 95 795 795 3795 8795 190 191 HAAAAA LYJAAA VVVVxx 7060 6720 0 0 0 0 60 60 1060 2060 7060 120 121 OLAAAA MYJAAA AAAAxx 9450 6721 0 2 0 10 50 450 1450 4450 9450 100 101 MZAAAA NYJAAA HHHHxx 390 6722 0 2 0 10 90 390 390 390 390 180 181 APAAAA OYJAAA OOOOxx 66 6723 0 2 6 6 66 66 66 66 66 132 133 OCAAAA PYJAAA VVVVxx 8789 6724 1 1 9 9 89 789 789 3789 8789 178 179 BAAAAA QYJAAA AAAAxx 9260 6725 0 0 0 0 60 260 1260 4260 9260 120 121 ESAAAA RYJAAA HHHHxx 6679 6726 1 3 9 19 79 679 679 1679 6679 158 159 XWAAAA SYJAAA OOOOxx 9052 6727 0 0 2 12 52 52 1052 4052 9052 104 105 EKAAAA TYJAAA VVVVxx 9561 6728 1 1 1 1 61 561 1561 4561 9561 122 123 TDAAAA UYJAAA AAAAxx 9725 6729 1 1 5 5 25 725 1725 4725 9725 50 51 BKAAAA VYJAAA HHHHxx 6298 6730 0 2 8 18 98 298 298 1298 6298 196 197 GIAAAA WYJAAA OOOOxx 8654 6731 0 2 4 14 54 654 654 3654 8654 108 109 WUAAAA XYJAAA VVVVxx 8725 6732 1 1 5 5 25 725 725 3725 8725 50 51 PXAAAA YYJAAA AAAAxx 9377 6733 1 1 7 17 77 377 1377 4377 9377 154 155 RWAAAA ZYJAAA HHHHxx 3807 6734 1 3 7 7 7 807 1807 3807 3807 14 15 LQAAAA AZJAAA OOOOxx 8048 6735 0 0 8 8 48 48 48 3048 8048 96 97 OXAAAA BZJAAA VVVVxx 764 6736 0 0 4 4 64 764 764 764 764 128 129 KDAAAA CZJAAA AAAAxx 9702 6737 0 2 2 2 2 702 1702 4702 9702 4 5 EJAAAA DZJAAA HHHHxx 8060 6738 0 0 0 0 60 60 60 3060 8060 120 121 AYAAAA EZJAAA OOOOxx 6371 6739 1 3 1 11 71 371 371 1371 6371 142 143 BLAAAA FZJAAA VVVVxx 5237 6740 1 1 7 17 37 237 1237 237 5237 74 75 LTAAAA GZJAAA AAAAxx 743 6741 1 3 3 3 43 743 743 743 743 86 87 PCAAAA HZJAAA HHHHxx 7395 6742 1 3 5 15 95 395 1395 2395 7395 190 191 LYAAAA IZJAAA OOOOxx 3365 6743 1 1 5 5 65 365 1365 3365 3365 130 131 LZAAAA JZJAAA VVVVxx 6667 6744 1 3 7 7 67 667 667 1667 6667 134 135 LWAAAA KZJAAA AAAAxx 3445 6745 1 1 5 5 45 445 1445 3445 3445 90 91 NCAAAA LZJAAA HHHHxx 4019 6746 1 3 9 19 19 19 19 4019 4019 38 39 PYAAAA MZJAAA OOOOxx 7035 6747 1 3 5 15 35 35 1035 2035 7035 70 71 PKAAAA NZJAAA VVVVxx 5274 6748 0 2 4 14 74 274 1274 274 5274 148 149 WUAAAA OZJAAA AAAAxx 519 6749 1 3 9 19 19 519 519 519 519 38 39 ZTAAAA PZJAAA HHHHxx 2801 6750 1 1 1 1 1 801 801 2801 2801 2 3 TDAAAA QZJAAA OOOOxx 3320 6751 0 0 0 0 20 320 1320 3320 3320 40 41 SXAAAA RZJAAA VVVVxx 3153 6752 1 1 3 13 53 153 1153 3153 3153 106 107 HRAAAA SZJAAA AAAAxx 7680 6753 0 0 0 0 80 680 1680 2680 7680 160 161 KJAAAA TZJAAA HHHHxx 8942 6754 0 2 2 2 42 942 942 3942 8942 84 85 YFAAAA UZJAAA OOOOxx 3195 6755 1 3 5 15 95 195 1195 3195 3195 190 191 XSAAAA VZJAAA VVVVxx 2287 6756 1 3 7 7 87 287 287 2287 2287 174 175 ZJAAAA WZJAAA AAAAxx 8325 6757 1 1 5 5 25 325 325 3325 8325 50 51 FIAAAA XZJAAA HHHHxx 2603 6758 1 3 3 3 3 603 603 2603 2603 6 7 DWAAAA YZJAAA OOOOxx 5871 6759 1 3 1 11 71 871 1871 871 5871 142 143 VRAAAA ZZJAAA VVVVxx 1773 6760 1 1 3 13 73 773 1773 1773 1773 146 147 FQAAAA AAKAAA AAAAxx 3323 6761 1 3 3 3 23 323 1323 3323 3323 46 47 VXAAAA BAKAAA HHHHxx 2053 6762 1 1 3 13 53 53 53 2053 2053 106 107 ZAAAAA CAKAAA OOOOxx 4062 6763 0 2 2 2 62 62 62 4062 4062 124 125 GAAAAA DAKAAA VVVVxx 4611 6764 1 3 1 11 11 611 611 4611 4611 22 23 JVAAAA EAKAAA AAAAxx 3451 6765 1 3 1 11 51 451 1451 3451 3451 102 103 TCAAAA FAKAAA HHHHxx 1819 6766 1 3 9 19 19 819 1819 1819 1819 38 39 ZRAAAA GAKAAA OOOOxx 9806 6767 0 2 6 6 6 806 1806 4806 9806 12 13 ENAAAA HAKAAA VVVVxx 6619 6768 1 3 9 19 19 619 619 1619 6619 38 39 PUAAAA IAKAAA AAAAxx 1031 6769 1 3 1 11 31 31 1031 1031 1031 62 63 RNAAAA JAKAAA HHHHxx 1865 6770 1 1 5 5 65 865 1865 1865 1865 130 131 TTAAAA KAKAAA OOOOxx 6282 6771 0 2 2 2 82 282 282 1282 6282 164 165 QHAAAA LAKAAA VVVVxx 1178 6772 0 2 8 18 78 178 1178 1178 1178 156 157 ITAAAA MAKAAA AAAAxx 8007 6773 1 3 7 7 7 7 7 3007 8007 14 15 ZVAAAA NAKAAA HHHHxx 9126 6774 0 2 6 6 26 126 1126 4126 9126 52 53 ANAAAA OAKAAA OOOOxx 9113 6775 1 1 3 13 13 113 1113 4113 9113 26 27 NMAAAA PAKAAA VVVVxx 537 6776 1 1 7 17 37 537 537 537 537 74 75 RUAAAA QAKAAA AAAAxx 6208 6777 0 0 8 8 8 208 208 1208 6208 16 17 UEAAAA RAKAAA HHHHxx 1626 6778 0 2 6 6 26 626 1626 1626 1626 52 53 OKAAAA SAKAAA OOOOxx 7188 6779 0 0 8 8 88 188 1188 2188 7188 176 177 MQAAAA TAKAAA VVVVxx 9216 6780 0 0 6 16 16 216 1216 4216 9216 32 33 MQAAAA UAKAAA AAAAxx 6134 6781 0 2 4 14 34 134 134 1134 6134 68 69 YBAAAA VAKAAA HHHHxx 2074 6782 0 2 4 14 74 74 74 2074 2074 148 149 UBAAAA WAKAAA OOOOxx 6369 6783 1 1 9 9 69 369 369 1369 6369 138 139 ZKAAAA XAKAAA VVVVxx 9306 6784 0 2 6 6 6 306 1306 4306 9306 12 13 YTAAAA YAKAAA AAAAxx 3155 6785 1 3 5 15 55 155 1155 3155 3155 110 111 JRAAAA ZAKAAA HHHHxx 3611 6786 1 3 1 11 11 611 1611 3611 3611 22 23 XIAAAA ABKAAA OOOOxx 6530 6787 0 2 0 10 30 530 530 1530 6530 60 61 ERAAAA BBKAAA VVVVxx 6979 6788 1 3 9 19 79 979 979 1979 6979 158 159 LIAAAA CBKAAA AAAAxx 9129 6789 1 1 9 9 29 129 1129 4129 9129 58 59 DNAAAA DBKAAA HHHHxx 8013 6790 1 1 3 13 13 13 13 3013 8013 26 27 FWAAAA EBKAAA OOOOxx 6926 6791 0 2 6 6 26 926 926 1926 6926 52 53 KGAAAA FBKAAA VVVVxx 1877 6792 1 1 7 17 77 877 1877 1877 1877 154 155 FUAAAA GBKAAA AAAAxx 1882 6793 0 2 2 2 82 882 1882 1882 1882 164 165 KUAAAA HBKAAA HHHHxx 6720 6794 0 0 0 0 20 720 720 1720 6720 40 41 MYAAAA IBKAAA OOOOxx 690 6795 0 2 0 10 90 690 690 690 690 180 181 OAAAAA JBKAAA VVVVxx 143 6796 1 3 3 3 43 143 143 143 143 86 87 NFAAAA KBKAAA AAAAxx 7241 6797 1 1 1 1 41 241 1241 2241 7241 82 83 NSAAAA LBKAAA HHHHxx 6461 6798 1 1 1 1 61 461 461 1461 6461 122 123 NOAAAA MBKAAA OOOOxx 2258 6799 0 2 8 18 58 258 258 2258 2258 116 117 WIAAAA NBKAAA VVVVxx 2280 6800 0 0 0 0 80 280 280 2280 2280 160 161 SJAAAA OBKAAA AAAAxx 7556 6801 0 0 6 16 56 556 1556 2556 7556 112 113 QEAAAA PBKAAA HHHHxx 1038 6802 0 2 8 18 38 38 1038 1038 1038 76 77 YNAAAA QBKAAA OOOOxx 2634 6803 0 2 4 14 34 634 634 2634 2634 68 69 IXAAAA RBKAAA VVVVxx 7847 6804 1 3 7 7 47 847 1847 2847 7847 94 95 VPAAAA SBKAAA AAAAxx 4415 6805 1 3 5 15 15 415 415 4415 4415 30 31 VNAAAA TBKAAA HHHHxx 1933 6806 1 1 3 13 33 933 1933 1933 1933 66 67 JWAAAA UBKAAA OOOOxx 8034 6807 0 2 4 14 34 34 34 3034 8034 68 69 AXAAAA VBKAAA VVVVxx 9233 6808 1 1 3 13 33 233 1233 4233 9233 66 67 DRAAAA WBKAAA AAAAxx 6572 6809 0 0 2 12 72 572 572 1572 6572 144 145 USAAAA XBKAAA HHHHxx 1586 6810 0 2 6 6 86 586 1586 1586 1586 172 173 AJAAAA YBKAAA OOOOxx 8512 6811 0 0 2 12 12 512 512 3512 8512 24 25 KPAAAA ZBKAAA VVVVxx 7421 6812 1 1 1 1 21 421 1421 2421 7421 42 43 LZAAAA ACKAAA AAAAxx 503 6813 1 3 3 3 3 503 503 503 503 6 7 JTAAAA BCKAAA HHHHxx 5332 6814 0 0 2 12 32 332 1332 332 5332 64 65 CXAAAA CCKAAA OOOOxx 2602 6815 0 2 2 2 2 602 602 2602 2602 4 5 CWAAAA DCKAAA VVVVxx 2902 6816 0 2 2 2 2 902 902 2902 2902 4 5 QHAAAA ECKAAA AAAAxx 2979 6817 1 3 9 19 79 979 979 2979 2979 158 159 PKAAAA FCKAAA HHHHxx 1431 6818 1 3 1 11 31 431 1431 1431 1431 62 63 BDAAAA GCKAAA OOOOxx 8639 6819 1 3 9 19 39 639 639 3639 8639 78 79 HUAAAA HCKAAA VVVVxx 4218 6820 0 2 8 18 18 218 218 4218 4218 36 37 GGAAAA ICKAAA AAAAxx 7453 6821 1 1 3 13 53 453 1453 2453 7453 106 107 RAAAAA JCKAAA HHHHxx 5448 6822 0 0 8 8 48 448 1448 448 5448 96 97 OBAAAA KCKAAA OOOOxx 6768 6823 0 0 8 8 68 768 768 1768 6768 136 137 IAAAAA LCKAAA VVVVxx 3104 6824 0 0 4 4 4 104 1104 3104 3104 8 9 KPAAAA MCKAAA AAAAxx 2297 6825 1 1 7 17 97 297 297 2297 2297 194 195 JKAAAA NCKAAA HHHHxx 7994 6826 0 2 4 14 94 994 1994 2994 7994 188 189 MVAAAA OCKAAA OOOOxx 550 6827 0 2 0 10 50 550 550 550 550 100 101 EVAAAA PCKAAA VVVVxx 4777 6828 1 1 7 17 77 777 777 4777 4777 154 155 TBAAAA QCKAAA AAAAxx 5962 6829 0 2 2 2 62 962 1962 962 5962 124 125 IVAAAA RCKAAA HHHHxx 1763 6830 1 3 3 3 63 763 1763 1763 1763 126 127 VPAAAA SCKAAA OOOOxx 3654 6831 0 2 4 14 54 654 1654 3654 3654 108 109 OKAAAA TCKAAA VVVVxx 4106 6832 0 2 6 6 6 106 106 4106 4106 12 13 YBAAAA UCKAAA AAAAxx 5156 6833 0 0 6 16 56 156 1156 156 5156 112 113 IQAAAA VCKAAA HHHHxx 422 6834 0 2 2 2 22 422 422 422 422 44 45 GQAAAA WCKAAA OOOOxx 5011 6835 1 3 1 11 11 11 1011 11 5011 22 23 TKAAAA XCKAAA VVVVxx 218 6836 0 2 8 18 18 218 218 218 218 36 37 KIAAAA YCKAAA AAAAxx 9762 6837 0 2 2 2 62 762 1762 4762 9762 124 125 MLAAAA ZCKAAA HHHHxx 6074 6838 0 2 4 14 74 74 74 1074 6074 148 149 QZAAAA ADKAAA OOOOxx 4060 6839 0 0 0 0 60 60 60 4060 4060 120 121 EAAAAA BDKAAA VVVVxx 8680 6840 0 0 0 0 80 680 680 3680 8680 160 161 WVAAAA CDKAAA AAAAxx 5863 6841 1 3 3 3 63 863 1863 863 5863 126 127 NRAAAA DDKAAA HHHHxx 8042 6842 0 2 2 2 42 42 42 3042 8042 84 85 IXAAAA EDKAAA OOOOxx 2964 6843 0 0 4 4 64 964 964 2964 2964 128 129 AKAAAA FDKAAA VVVVxx 6931 6844 1 3 1 11 31 931 931 1931 6931 62 63 PGAAAA GDKAAA AAAAxx 6715 6845 1 3 5 15 15 715 715 1715 6715 30 31 HYAAAA HDKAAA HHHHxx 5859 6846 1 3 9 19 59 859 1859 859 5859 118 119 JRAAAA IDKAAA OOOOxx 6173 6847 1 1 3 13 73 173 173 1173 6173 146 147 LDAAAA JDKAAA VVVVxx 7788 6848 0 0 8 8 88 788 1788 2788 7788 176 177 ONAAAA KDKAAA AAAAxx 9370 6849 0 2 0 10 70 370 1370 4370 9370 140 141 KWAAAA LDKAAA HHHHxx 3038 6850 0 2 8 18 38 38 1038 3038 3038 76 77 WMAAAA MDKAAA OOOOxx 6483 6851 1 3 3 3 83 483 483 1483 6483 166 167 JPAAAA NDKAAA VVVVxx 7534 6852 0 2 4 14 34 534 1534 2534 7534 68 69 UDAAAA ODKAAA AAAAxx 5769 6853 1 1 9 9 69 769 1769 769 5769 138 139 XNAAAA PDKAAA HHHHxx 9152 6854 0 0 2 12 52 152 1152 4152 9152 104 105 AOAAAA QDKAAA OOOOxx 6251 6855 1 3 1 11 51 251 251 1251 6251 102 103 LGAAAA RDKAAA VVVVxx 9209 6856 1 1 9 9 9 209 1209 4209 9209 18 19 FQAAAA SDKAAA AAAAxx 5365 6857 1 1 5 5 65 365 1365 365 5365 130 131 JYAAAA TDKAAA HHHHxx 509 6858 1 1 9 9 9 509 509 509 509 18 19 PTAAAA UDKAAA OOOOxx 3132 6859 0 0 2 12 32 132 1132 3132 3132 64 65 MQAAAA VDKAAA VVVVxx 5373 6860 1 1 3 13 73 373 1373 373 5373 146 147 RYAAAA WDKAAA AAAAxx 4247 6861 1 3 7 7 47 247 247 4247 4247 94 95 JHAAAA XDKAAA HHHHxx 3491 6862 1 3 1 11 91 491 1491 3491 3491 182 183 HEAAAA YDKAAA OOOOxx 495 6863 1 3 5 15 95 495 495 495 495 190 191 BTAAAA ZDKAAA VVVVxx 1594 6864 0 2 4 14 94 594 1594 1594 1594 188 189 IJAAAA AEKAAA AAAAxx 2243 6865 1 3 3 3 43 243 243 2243 2243 86 87 HIAAAA BEKAAA HHHHxx 7780 6866 0 0 0 0 80 780 1780 2780 7780 160 161 GNAAAA CEKAAA OOOOxx 5632 6867 0 0 2 12 32 632 1632 632 5632 64 65 QIAAAA DEKAAA VVVVxx 2679 6868 1 3 9 19 79 679 679 2679 2679 158 159 BZAAAA EEKAAA AAAAxx 1354 6869 0 2 4 14 54 354 1354 1354 1354 108 109 CAAAAA FEKAAA HHHHxx 180 6870 0 0 0 0 80 180 180 180 180 160 161 YGAAAA GEKAAA OOOOxx 7017 6871 1 1 7 17 17 17 1017 2017 7017 34 35 XJAAAA HEKAAA VVVVxx 1867 6872 1 3 7 7 67 867 1867 1867 1867 134 135 VTAAAA IEKAAA AAAAxx 2213 6873 1 1 3 13 13 213 213 2213 2213 26 27 DHAAAA JEKAAA HHHHxx 8773 6874 1 1 3 13 73 773 773 3773 8773 146 147 LZAAAA KEKAAA OOOOxx 1784 6875 0 0 4 4 84 784 1784 1784 1784 168 169 QQAAAA LEKAAA VVVVxx 5961 6876 1 1 1 1 61 961 1961 961 5961 122 123 HVAAAA MEKAAA AAAAxx 8801 6877 1 1 1 1 1 801 801 3801 8801 2 3 NAAAAA NEKAAA HHHHxx 4860 6878 0 0 0 0 60 860 860 4860 4860 120 121 YEAAAA OEKAAA OOOOxx 2214 6879 0 2 4 14 14 214 214 2214 2214 28 29 EHAAAA PEKAAA VVVVxx 1735 6880 1 3 5 15 35 735 1735 1735 1735 70 71 TOAAAA QEKAAA AAAAxx 578 6881 0 2 8 18 78 578 578 578 578 156 157 GWAAAA REKAAA HHHHxx 7853 6882 1 1 3 13 53 853 1853 2853 7853 106 107 BQAAAA SEKAAA OOOOxx 2215 6883 1 3 5 15 15 215 215 2215 2215 30 31 FHAAAA TEKAAA VVVVxx 4704 6884 0 0 4 4 4 704 704 4704 4704 8 9 YYAAAA UEKAAA AAAAxx 9379 6885 1 3 9 19 79 379 1379 4379 9379 158 159 TWAAAA VEKAAA HHHHxx 9745 6886 1 1 5 5 45 745 1745 4745 9745 90 91 VKAAAA WEKAAA OOOOxx 5636 6887 0 0 6 16 36 636 1636 636 5636 72 73 UIAAAA XEKAAA VVVVxx 4548 6888 0 0 8 8 48 548 548 4548 4548 96 97 YSAAAA YEKAAA AAAAxx 6537 6889 1 1 7 17 37 537 537 1537 6537 74 75 LRAAAA ZEKAAA HHHHxx 7748 6890 0 0 8 8 48 748 1748 2748 7748 96 97 AMAAAA AFKAAA OOOOxx 687 6891 1 3 7 7 87 687 687 687 687 174 175 LAAAAA BFKAAA VVVVxx 1243 6892 1 3 3 3 43 243 1243 1243 1243 86 87 VVAAAA CFKAAA AAAAxx 852 6893 0 0 2 12 52 852 852 852 852 104 105 UGAAAA DFKAAA HHHHxx 785 6894 1 1 5 5 85 785 785 785 785 170 171 FEAAAA EFKAAA OOOOxx 2002 6895 0 2 2 2 2 2 2 2002 2002 4 5 AZAAAA FFKAAA VVVVxx 2748 6896 0 0 8 8 48 748 748 2748 2748 96 97 SBAAAA GFKAAA AAAAxx 6075 6897 1 3 5 15 75 75 75 1075 6075 150 151 RZAAAA HFKAAA HHHHxx 7029 6898 1 1 9 9 29 29 1029 2029 7029 58 59 JKAAAA IFKAAA OOOOxx 7474 6899 0 2 4 14 74 474 1474 2474 7474 148 149 MBAAAA JFKAAA VVVVxx 7755 6900 1 3 5 15 55 755 1755 2755 7755 110 111 HMAAAA KFKAAA AAAAxx 1456 6901 0 0 6 16 56 456 1456 1456 1456 112 113 AEAAAA LFKAAA HHHHxx 2808 6902 0 0 8 8 8 808 808 2808 2808 16 17 AEAAAA MFKAAA OOOOxx 4089 6903 1 1 9 9 89 89 89 4089 4089 178 179 HBAAAA NFKAAA VVVVxx 4718 6904 0 2 8 18 18 718 718 4718 4718 36 37 MZAAAA OFKAAA AAAAxx 910 6905 0 2 0 10 10 910 910 910 910 20 21 AJAAAA PFKAAA HHHHxx 2868 6906 0 0 8 8 68 868 868 2868 2868 136 137 IGAAAA QFKAAA OOOOxx 2103 6907 1 3 3 3 3 103 103 2103 2103 6 7 XCAAAA RFKAAA VVVVxx 2407 6908 1 3 7 7 7 407 407 2407 2407 14 15 POAAAA SFKAAA AAAAxx 4353 6909 1 1 3 13 53 353 353 4353 4353 106 107 LLAAAA TFKAAA HHHHxx 7988 6910 0 0 8 8 88 988 1988 2988 7988 176 177 GVAAAA UFKAAA OOOOxx 2750 6911 0 2 0 10 50 750 750 2750 2750 100 101 UBAAAA VFKAAA VVVVxx 2006 6912 0 2 6 6 6 6 6 2006 2006 12 13 EZAAAA WFKAAA AAAAxx 4617 6913 1 1 7 17 17 617 617 4617 4617 34 35 PVAAAA XFKAAA HHHHxx 1251 6914 1 3 1 11 51 251 1251 1251 1251 102 103 DWAAAA YFKAAA OOOOxx 4590 6915 0 2 0 10 90 590 590 4590 4590 180 181 OUAAAA ZFKAAA VVVVxx 1144 6916 0 0 4 4 44 144 1144 1144 1144 88 89 ASAAAA AGKAAA AAAAxx 7131 6917 1 3 1 11 31 131 1131 2131 7131 62 63 HOAAAA BGKAAA HHHHxx 95 6918 1 3 5 15 95 95 95 95 95 190 191 RDAAAA CGKAAA OOOOxx 4827 6919 1 3 7 7 27 827 827 4827 4827 54 55 RDAAAA DGKAAA VVVVxx 4307 6920 1 3 7 7 7 307 307 4307 4307 14 15 RJAAAA EGKAAA AAAAxx 1505 6921 1 1 5 5 5 505 1505 1505 1505 10 11 XFAAAA FGKAAA HHHHxx 8191 6922 1 3 1 11 91 191 191 3191 8191 182 183 BDAAAA GGKAAA OOOOxx 5037 6923 1 1 7 17 37 37 1037 37 5037 74 75 TLAAAA HGKAAA VVVVxx 7363 6924 1 3 3 3 63 363 1363 2363 7363 126 127 FXAAAA IGKAAA AAAAxx 8427 6925 1 3 7 7 27 427 427 3427 8427 54 55 DMAAAA JGKAAA HHHHxx 5231 6926 1 3 1 11 31 231 1231 231 5231 62 63 FTAAAA KGKAAA OOOOxx 2943 6927 1 3 3 3 43 943 943 2943 2943 86 87 FJAAAA LGKAAA VVVVxx 4624 6928 0 0 4 4 24 624 624 4624 4624 48 49 WVAAAA MGKAAA AAAAxx 2020 6929 0 0 0 0 20 20 20 2020 2020 40 41 SZAAAA NGKAAA HHHHxx 6155 6930 1 3 5 15 55 155 155 1155 6155 110 111 TCAAAA OGKAAA OOOOxx 4381 6931 1 1 1 1 81 381 381 4381 4381 162 163 NMAAAA PGKAAA VVVVxx 1057 6932 1 1 7 17 57 57 1057 1057 1057 114 115 ROAAAA QGKAAA AAAAxx 9010 6933 0 2 0 10 10 10 1010 4010 9010 20 21 OIAAAA RGKAAA HHHHxx 4947 6934 1 3 7 7 47 947 947 4947 4947 94 95 HIAAAA SGKAAA OOOOxx 335 6935 1 3 5 15 35 335 335 335 335 70 71 XMAAAA TGKAAA VVVVxx 6890 6936 0 2 0 10 90 890 890 1890 6890 180 181 AFAAAA UGKAAA AAAAxx 5070 6937 0 2 0 10 70 70 1070 70 5070 140 141 ANAAAA VGKAAA HHHHxx 5270 6938 0 2 0 10 70 270 1270 270 5270 140 141 SUAAAA WGKAAA OOOOxx 8657 6939 1 1 7 17 57 657 657 3657 8657 114 115 ZUAAAA XGKAAA VVVVxx 7625 6940 1 1 5 5 25 625 1625 2625 7625 50 51 HHAAAA YGKAAA AAAAxx 5759 6941 1 3 9 19 59 759 1759 759 5759 118 119 NNAAAA ZGKAAA HHHHxx 9483 6942 1 3 3 3 83 483 1483 4483 9483 166 167 TAAAAA AHKAAA OOOOxx 8304 6943 0 0 4 4 4 304 304 3304 8304 8 9 KHAAAA BHKAAA VVVVxx 296 6944 0 0 6 16 96 296 296 296 296 192 193 KLAAAA CHKAAA AAAAxx 1176 6945 0 0 6 16 76 176 1176 1176 1176 152 153 GTAAAA DHKAAA HHHHxx 2069 6946 1 1 9 9 69 69 69 2069 2069 138 139 PBAAAA EHKAAA OOOOxx 1531 6947 1 3 1 11 31 531 1531 1531 1531 62 63 XGAAAA FHKAAA VVVVxx 5329 6948 1 1 9 9 29 329 1329 329 5329 58 59 ZWAAAA GHKAAA AAAAxx 3702 6949 0 2 2 2 2 702 1702 3702 3702 4 5 KMAAAA HHKAAA HHHHxx 6520 6950 0 0 0 0 20 520 520 1520 6520 40 41 UQAAAA IHKAAA OOOOxx 7310 6951 0 2 0 10 10 310 1310 2310 7310 20 21 EVAAAA JHKAAA VVVVxx 1175 6952 1 3 5 15 75 175 1175 1175 1175 150 151 FTAAAA KHKAAA AAAAxx 9107 6953 1 3 7 7 7 107 1107 4107 9107 14 15 HMAAAA LHKAAA HHHHxx 2737 6954 1 1 7 17 37 737 737 2737 2737 74 75 HBAAAA MHKAAA OOOOxx 3437 6955 1 1 7 17 37 437 1437 3437 3437 74 75 FCAAAA NHKAAA VVVVxx 281 6956 1 1 1 1 81 281 281 281 281 162 163 VKAAAA OHKAAA AAAAxx 6676 6957 0 0 6 16 76 676 676 1676 6676 152 153 UWAAAA PHKAAA HHHHxx 145 6958 1 1 5 5 45 145 145 145 145 90 91 PFAAAA QHKAAA OOOOxx 3172 6959 0 0 2 12 72 172 1172 3172 3172 144 145 ASAAAA RHKAAA VVVVxx 4049 6960 1 1 9 9 49 49 49 4049 4049 98 99 TZAAAA SHKAAA AAAAxx 6042 6961 0 2 2 2 42 42 42 1042 6042 84 85 KYAAAA THKAAA HHHHxx 9122 6962 0 2 2 2 22 122 1122 4122 9122 44 45 WMAAAA UHKAAA OOOOxx 7244 6963 0 0 4 4 44 244 1244 2244 7244 88 89 QSAAAA VHKAAA VVVVxx 5361 6964 1 1 1 1 61 361 1361 361 5361 122 123 FYAAAA WHKAAA AAAAxx 8647 6965 1 3 7 7 47 647 647 3647 8647 94 95 PUAAAA XHKAAA HHHHxx 7956 6966 0 0 6 16 56 956 1956 2956 7956 112 113 AUAAAA YHKAAA OOOOxx 7812 6967 0 0 2 12 12 812 1812 2812 7812 24 25 MOAAAA ZHKAAA VVVVxx 570 6968 0 2 0 10 70 570 570 570 570 140 141 YVAAAA AIKAAA AAAAxx 4115 6969 1 3 5 15 15 115 115 4115 4115 30 31 HCAAAA BIKAAA HHHHxx 1856 6970 0 0 6 16 56 856 1856 1856 1856 112 113 KTAAAA CIKAAA OOOOxx 9582 6971 0 2 2 2 82 582 1582 4582 9582 164 165 OEAAAA DIKAAA VVVVxx 2025 6972 1 1 5 5 25 25 25 2025 2025 50 51 XZAAAA EIKAAA AAAAxx 986 6973 0 2 6 6 86 986 986 986 986 172 173 YLAAAA FIKAAA HHHHxx 8358 6974 0 2 8 18 58 358 358 3358 8358 116 117 MJAAAA GIKAAA OOOOxx 510 6975 0 2 0 10 10 510 510 510 510 20 21 QTAAAA HIKAAA VVVVxx 6101 6976 1 1 1 1 1 101 101 1101 6101 2 3 RAAAAA IIKAAA AAAAxx 4167 6977 1 3 7 7 67 167 167 4167 4167 134 135 HEAAAA JIKAAA HHHHxx 6139 6978 1 3 9 19 39 139 139 1139 6139 78 79 DCAAAA KIKAAA OOOOxx 6912 6979 0 0 2 12 12 912 912 1912 6912 24 25 WFAAAA LIKAAA VVVVxx 339 6980 1 3 9 19 39 339 339 339 339 78 79 BNAAAA MIKAAA AAAAxx 8759 6981 1 3 9 19 59 759 759 3759 8759 118 119 XYAAAA NIKAAA HHHHxx 246 6982 0 2 6 6 46 246 246 246 246 92 93 MJAAAA OIKAAA OOOOxx 2831 6983 1 3 1 11 31 831 831 2831 2831 62 63 XEAAAA PIKAAA VVVVxx 2327 6984 1 3 7 7 27 327 327 2327 2327 54 55 NLAAAA QIKAAA AAAAxx 7001 6985 1 1 1 1 1 1 1001 2001 7001 2 3 HJAAAA RIKAAA HHHHxx 4398 6986 0 2 8 18 98 398 398 4398 4398 196 197 ENAAAA SIKAAA OOOOxx 1495 6987 1 3 5 15 95 495 1495 1495 1495 190 191 NFAAAA TIKAAA VVVVxx 8522 6988 0 2 2 2 22 522 522 3522 8522 44 45 UPAAAA UIKAAA AAAAxx 7090 6989 0 2 0 10 90 90 1090 2090 7090 180 181 SMAAAA VIKAAA HHHHxx 8457 6990 1 1 7 17 57 457 457 3457 8457 114 115 HNAAAA WIKAAA OOOOxx 4238 6991 0 2 8 18 38 238 238 4238 4238 76 77 AHAAAA XIKAAA VVVVxx 6791 6992 1 3 1 11 91 791 791 1791 6791 182 183 FBAAAA YIKAAA AAAAxx 1342 6993 0 2 2 2 42 342 1342 1342 1342 84 85 QZAAAA ZIKAAA HHHHxx 4580 6994 0 0 0 0 80 580 580 4580 4580 160 161 EUAAAA AJKAAA OOOOxx 1475 6995 1 3 5 15 75 475 1475 1475 1475 150 151 TEAAAA BJKAAA VVVVxx 9184 6996 0 0 4 4 84 184 1184 4184 9184 168 169 GPAAAA CJKAAA AAAAxx 1189 6997 1 1 9 9 89 189 1189 1189 1189 178 179 TTAAAA DJKAAA HHHHxx 638 6998 0 2 8 18 38 638 638 638 638 76 77 OYAAAA EJKAAA OOOOxx 5867 6999 1 3 7 7 67 867 1867 867 5867 134 135 RRAAAA FJKAAA VVVVxx 9911 7000 1 3 1 11 11 911 1911 4911 9911 22 23 FRAAAA GJKAAA AAAAxx 8147 7001 1 3 7 7 47 147 147 3147 8147 94 95 JBAAAA HJKAAA HHHHxx 4492 7002 0 0 2 12 92 492 492 4492 4492 184 185 UQAAAA IJKAAA OOOOxx 385 7003 1 1 5 5 85 385 385 385 385 170 171 VOAAAA JJKAAA VVVVxx 5235 7004 1 3 5 15 35 235 1235 235 5235 70 71 JTAAAA KJKAAA AAAAxx 4812 7005 0 0 2 12 12 812 812 4812 4812 24 25 CDAAAA LJKAAA HHHHxx 9807 7006 1 3 7 7 7 807 1807 4807 9807 14 15 FNAAAA MJKAAA OOOOxx 9588 7007 0 0 8 8 88 588 1588 4588 9588 176 177 UEAAAA NJKAAA VVVVxx 9832 7008 0 0 2 12 32 832 1832 4832 9832 64 65 EOAAAA OJKAAA AAAAxx 3757 7009 1 1 7 17 57 757 1757 3757 3757 114 115 NOAAAA PJKAAA HHHHxx 9703 7010 1 3 3 3 3 703 1703 4703 9703 6 7 FJAAAA QJKAAA OOOOxx 1022 7011 0 2 2 2 22 22 1022 1022 1022 44 45 INAAAA RJKAAA VVVVxx 5165 7012 1 1 5 5 65 165 1165 165 5165 130 131 RQAAAA SJKAAA AAAAxx 7129 7013 1 1 9 9 29 129 1129 2129 7129 58 59 FOAAAA TJKAAA HHHHxx 4164 7014 0 0 4 4 64 164 164 4164 4164 128 129 EEAAAA UJKAAA OOOOxx 7239 7015 1 3 9 19 39 239 1239 2239 7239 78 79 LSAAAA VJKAAA VVVVxx 523 7016 1 3 3 3 23 523 523 523 523 46 47 DUAAAA WJKAAA AAAAxx 4670 7017 0 2 0 10 70 670 670 4670 4670 140 141 QXAAAA XJKAAA HHHHxx 8503 7018 1 3 3 3 3 503 503 3503 8503 6 7 BPAAAA YJKAAA OOOOxx 714 7019 0 2 4 14 14 714 714 714 714 28 29 MBAAAA ZJKAAA VVVVxx 1350 7020 0 2 0 10 50 350 1350 1350 1350 100 101 YZAAAA AKKAAA AAAAxx 8318 7021 0 2 8 18 18 318 318 3318 8318 36 37 YHAAAA BKKAAA HHHHxx 1834 7022 0 2 4 14 34 834 1834 1834 1834 68 69 OSAAAA CKKAAA OOOOxx 4306 7023 0 2 6 6 6 306 306 4306 4306 12 13 QJAAAA DKKAAA VVVVxx 8543 7024 1 3 3 3 43 543 543 3543 8543 86 87 PQAAAA EKKAAA AAAAxx 9397 7025 1 1 7 17 97 397 1397 4397 9397 194 195 LXAAAA FKKAAA HHHHxx 3145 7026 1 1 5 5 45 145 1145 3145 3145 90 91 ZQAAAA GKKAAA OOOOxx 3942 7027 0 2 2 2 42 942 1942 3942 3942 84 85 QVAAAA HKKAAA VVVVxx 8583 7028 1 3 3 3 83 583 583 3583 8583 166 167 DSAAAA IKKAAA AAAAxx 8073 7029 1 1 3 13 73 73 73 3073 8073 146 147 NYAAAA JKKAAA HHHHxx 4940 7030 0 0 0 0 40 940 940 4940 4940 80 81 AIAAAA KKKAAA OOOOxx 9573 7031 1 1 3 13 73 573 1573 4573 9573 146 147 FEAAAA LKKAAA VVVVxx 5325 7032 1 1 5 5 25 325 1325 325 5325 50 51 VWAAAA MKKAAA AAAAxx 1833 7033 1 1 3 13 33 833 1833 1833 1833 66 67 NSAAAA NKKAAA HHHHxx 1337 7034 1 1 7 17 37 337 1337 1337 1337 74 75 LZAAAA OKKAAA OOOOxx 9749 7035 1 1 9 9 49 749 1749 4749 9749 98 99 ZKAAAA PKKAAA VVVVxx 7505 7036 1 1 5 5 5 505 1505 2505 7505 10 11 RCAAAA QKKAAA AAAAxx 9731 7037 1 3 1 11 31 731 1731 4731 9731 62 63 HKAAAA RKKAAA HHHHxx 4098 7038 0 2 8 18 98 98 98 4098 4098 196 197 QBAAAA SKKAAA OOOOxx 1418 7039 0 2 8 18 18 418 1418 1418 1418 36 37 OCAAAA TKKAAA VVVVxx 63 7040 1 3 3 3 63 63 63 63 63 126 127 LCAAAA UKKAAA AAAAxx 9889 7041 1 1 9 9 89 889 1889 4889 9889 178 179 JQAAAA VKKAAA HHHHxx 2871 7042 1 3 1 11 71 871 871 2871 2871 142 143 LGAAAA WKKAAA OOOOxx 1003 7043 1 3 3 3 3 3 1003 1003 1003 6 7 PMAAAA XKKAAA VVVVxx 8796 7044 0 0 6 16 96 796 796 3796 8796 192 193 IAAAAA YKKAAA AAAAxx 22 7045 0 2 2 2 22 22 22 22 22 44 45 WAAAAA ZKKAAA HHHHxx 8244 7046 0 0 4 4 44 244 244 3244 8244 88 89 CFAAAA ALKAAA OOOOxx 2282 7047 0 2 2 2 82 282 282 2282 2282 164 165 UJAAAA BLKAAA VVVVxx 3487 7048 1 3 7 7 87 487 1487 3487 3487 174 175 DEAAAA CLKAAA AAAAxx 8633 7049 1 1 3 13 33 633 633 3633 8633 66 67 BUAAAA DLKAAA HHHHxx 6418 7050 0 2 8 18 18 418 418 1418 6418 36 37 WMAAAA ELKAAA OOOOxx 4682 7051 0 2 2 2 82 682 682 4682 4682 164 165 CYAAAA FLKAAA VVVVxx 4103 7052 1 3 3 3 3 103 103 4103 4103 6 7 VBAAAA GLKAAA AAAAxx 6256 7053 0 0 6 16 56 256 256 1256 6256 112 113 QGAAAA HLKAAA HHHHxx 4040 7054 0 0 0 0 40 40 40 4040 4040 80 81 KZAAAA ILKAAA OOOOxx 9342 7055 0 2 2 2 42 342 1342 4342 9342 84 85 IVAAAA JLKAAA VVVVxx 9969 7056 1 1 9 9 69 969 1969 4969 9969 138 139 LTAAAA KLKAAA AAAAxx 223 7057 1 3 3 3 23 223 223 223 223 46 47 PIAAAA LLKAAA HHHHxx 4593 7058 1 1 3 13 93 593 593 4593 4593 186 187 RUAAAA MLKAAA OOOOxx 44 7059 0 0 4 4 44 44 44 44 44 88 89 SBAAAA NLKAAA VVVVxx 3513 7060 1 1 3 13 13 513 1513 3513 3513 26 27 DFAAAA OLKAAA AAAAxx 5771 7061 1 3 1 11 71 771 1771 771 5771 142 143 ZNAAAA PLKAAA HHHHxx 5083 7062 1 3 3 3 83 83 1083 83 5083 166 167 NNAAAA QLKAAA OOOOxx 3839 7063 1 3 9 19 39 839 1839 3839 3839 78 79 RRAAAA RLKAAA VVVVxx 2986 7064 0 2 6 6 86 986 986 2986 2986 172 173 WKAAAA SLKAAA AAAAxx 2200 7065 0 0 0 0 0 200 200 2200 2200 0 1 QGAAAA TLKAAA HHHHxx 197 7066 1 1 7 17 97 197 197 197 197 194 195 PHAAAA ULKAAA OOOOxx 7455 7067 1 3 5 15 55 455 1455 2455 7455 110 111 TAAAAA VLKAAA VVVVxx 1379 7068 1 3 9 19 79 379 1379 1379 1379 158 159 BBAAAA WLKAAA AAAAxx 4356 7069 0 0 6 16 56 356 356 4356 4356 112 113 OLAAAA XLKAAA HHHHxx 6888 7070 0 0 8 8 88 888 888 1888 6888 176 177 YEAAAA YLKAAA OOOOxx 9139 7071 1 3 9 19 39 139 1139 4139 9139 78 79 NNAAAA ZLKAAA VVVVxx 7682 7072 0 2 2 2 82 682 1682 2682 7682 164 165 MJAAAA AMKAAA AAAAxx 4873 7073 1 1 3 13 73 873 873 4873 4873 146 147 LFAAAA BMKAAA HHHHxx 783 7074 1 3 3 3 83 783 783 783 783 166 167 DEAAAA CMKAAA OOOOxx 6071 7075 1 3 1 11 71 71 71 1071 6071 142 143 NZAAAA DMKAAA VVVVxx 5160 7076 0 0 0 0 60 160 1160 160 5160 120 121 MQAAAA EMKAAA AAAAxx 2291 7077 1 3 1 11 91 291 291 2291 2291 182 183 DKAAAA FMKAAA HHHHxx 187 7078 1 3 7 7 87 187 187 187 187 174 175 FHAAAA GMKAAA OOOOxx 7786 7079 0 2 6 6 86 786 1786 2786 7786 172 173 MNAAAA HMKAAA VVVVxx 3432 7080 0 0 2 12 32 432 1432 3432 3432 64 65 ACAAAA IMKAAA AAAAxx 5450 7081 0 2 0 10 50 450 1450 450 5450 100 101 QBAAAA JMKAAA HHHHxx 2699 7082 1 3 9 19 99 699 699 2699 2699 198 199 VZAAAA KMKAAA OOOOxx 692 7083 0 0 2 12 92 692 692 692 692 184 185 QAAAAA LMKAAA VVVVxx 6081 7084 1 1 1 1 81 81 81 1081 6081 162 163 XZAAAA MMKAAA AAAAxx 4829 7085 1 1 9 9 29 829 829 4829 4829 58 59 TDAAAA NMKAAA HHHHxx 238 7086 0 2 8 18 38 238 238 238 238 76 77 EJAAAA OMKAAA OOOOxx 9100 7087 0 0 0 0 0 100 1100 4100 9100 0 1 AMAAAA PMKAAA VVVVxx 1968 7088 0 0 8 8 68 968 1968 1968 1968 136 137 SXAAAA QMKAAA AAAAxx 1872 7089 0 0 2 12 72 872 1872 1872 1872 144 145 AUAAAA RMKAAA HHHHxx 7051 7090 1 3 1 11 51 51 1051 2051 7051 102 103 FLAAAA SMKAAA OOOOxx 2743 7091 1 3 3 3 43 743 743 2743 2743 86 87 NBAAAA TMKAAA VVVVxx 1237 7092 1 1 7 17 37 237 1237 1237 1237 74 75 PVAAAA UMKAAA AAAAxx 3052 7093 0 0 2 12 52 52 1052 3052 3052 104 105 KNAAAA VMKAAA HHHHxx 8021 7094 1 1 1 1 21 21 21 3021 8021 42 43 NWAAAA WMKAAA OOOOxx 657 7095 1 1 7 17 57 657 657 657 657 114 115 HZAAAA XMKAAA VVVVxx 2236 7096 0 0 6 16 36 236 236 2236 2236 72 73 AIAAAA YMKAAA AAAAxx 7011 7097 1 3 1 11 11 11 1011 2011 7011 22 23 RJAAAA ZMKAAA HHHHxx 4067 7098 1 3 7 7 67 67 67 4067 4067 134 135 LAAAAA ANKAAA OOOOxx 9449 7099 1 1 9 9 49 449 1449 4449 9449 98 99 LZAAAA BNKAAA VVVVxx 7428 7100 0 0 8 8 28 428 1428 2428 7428 56 57 SZAAAA CNKAAA AAAAxx 1272 7101 0 0 2 12 72 272 1272 1272 1272 144 145 YWAAAA DNKAAA HHHHxx 6897 7102 1 1 7 17 97 897 897 1897 6897 194 195 HFAAAA ENKAAA OOOOxx 5839 7103 1 3 9 19 39 839 1839 839 5839 78 79 PQAAAA FNKAAA VVVVxx 6835 7104 1 3 5 15 35 835 835 1835 6835 70 71 XCAAAA GNKAAA AAAAxx 1887 7105 1 3 7 7 87 887 1887 1887 1887 174 175 PUAAAA HNKAAA HHHHxx 1551 7106 1 3 1 11 51 551 1551 1551 1551 102 103 RHAAAA INKAAA OOOOxx 4667 7107 1 3 7 7 67 667 667 4667 4667 134 135 NXAAAA JNKAAA VVVVxx 9603 7108 1 3 3 3 3 603 1603 4603 9603 6 7 JFAAAA KNKAAA AAAAxx 4332 7109 0 0 2 12 32 332 332 4332 4332 64 65 QKAAAA LNKAAA HHHHxx 5681 7110 1 1 1 1 81 681 1681 681 5681 162 163 NKAAAA MNKAAA OOOOxx 8062 7111 0 2 2 2 62 62 62 3062 8062 124 125 CYAAAA NNKAAA VVVVxx 2302 7112 0 2 2 2 2 302 302 2302 2302 4 5 OKAAAA ONKAAA AAAAxx 2825 7113 1 1 5 5 25 825 825 2825 2825 50 51 REAAAA PNKAAA HHHHxx 4527 7114 1 3 7 7 27 527 527 4527 4527 54 55 DSAAAA QNKAAA OOOOxx 4230 7115 0 2 0 10 30 230 230 4230 4230 60 61 SGAAAA RNKAAA VVVVxx 3053 7116 1 1 3 13 53 53 1053 3053 3053 106 107 LNAAAA SNKAAA AAAAxx 983 7117 1 3 3 3 83 983 983 983 983 166 167 VLAAAA TNKAAA HHHHxx 9458 7118 0 2 8 18 58 458 1458 4458 9458 116 117 UZAAAA UNKAAA OOOOxx 4128 7119 0 0 8 8 28 128 128 4128 4128 56 57 UCAAAA VNKAAA VVVVxx 425 7120 1 1 5 5 25 425 425 425 425 50 51 JQAAAA WNKAAA AAAAxx 3911 7121 1 3 1 11 11 911 1911 3911 3911 22 23 LUAAAA XNKAAA HHHHxx 6607 7122 1 3 7 7 7 607 607 1607 6607 14 15 DUAAAA YNKAAA OOOOxx 5431 7123 1 3 1 11 31 431 1431 431 5431 62 63 XAAAAA ZNKAAA VVVVxx 6330 7124 0 2 0 10 30 330 330 1330 6330 60 61 MJAAAA AOKAAA AAAAxx 3592 7125 0 0 2 12 92 592 1592 3592 3592 184 185 EIAAAA BOKAAA HHHHxx 154 7126 0 2 4 14 54 154 154 154 154 108 109 YFAAAA COKAAA OOOOxx 9879 7127 1 3 9 19 79 879 1879 4879 9879 158 159 ZPAAAA DOKAAA VVVVxx 3202 7128 0 2 2 2 2 202 1202 3202 3202 4 5 ETAAAA EOKAAA AAAAxx 3056 7129 0 0 6 16 56 56 1056 3056 3056 112 113 ONAAAA FOKAAA HHHHxx 9890 7130 0 2 0 10 90 890 1890 4890 9890 180 181 KQAAAA GOKAAA OOOOxx 5840 7131 0 0 0 0 40 840 1840 840 5840 80 81 QQAAAA HOKAAA VVVVxx 9804 7132 0 0 4 4 4 804 1804 4804 9804 8 9 CNAAAA IOKAAA AAAAxx 681 7133 1 1 1 1 81 681 681 681 681 162 163 FAAAAA JOKAAA HHHHxx 3443 7134 1 3 3 3 43 443 1443 3443 3443 86 87 LCAAAA KOKAAA OOOOxx 8088 7135 0 0 8 8 88 88 88 3088 8088 176 177 CZAAAA LOKAAA VVVVxx 9447 7136 1 3 7 7 47 447 1447 4447 9447 94 95 JZAAAA MOKAAA AAAAxx 1490 7137 0 2 0 10 90 490 1490 1490 1490 180 181 IFAAAA NOKAAA HHHHxx 3684 7138 0 0 4 4 84 684 1684 3684 3684 168 169 SLAAAA OOKAAA OOOOxx 3113 7139 1 1 3 13 13 113 1113 3113 3113 26 27 TPAAAA POKAAA VVVVxx 9004 7140 0 0 4 4 4 4 1004 4004 9004 8 9 IIAAAA QOKAAA AAAAxx 7147 7141 1 3 7 7 47 147 1147 2147 7147 94 95 XOAAAA ROKAAA HHHHxx 7571 7142 1 3 1 11 71 571 1571 2571 7571 142 143 FFAAAA SOKAAA OOOOxx 5545 7143 1 1 5 5 45 545 1545 545 5545 90 91 HFAAAA TOKAAA VVVVxx 4558 7144 0 2 8 18 58 558 558 4558 4558 116 117 ITAAAA UOKAAA AAAAxx 6206 7145 0 2 6 6 6 206 206 1206 6206 12 13 SEAAAA VOKAAA HHHHxx 5695 7146 1 3 5 15 95 695 1695 695 5695 190 191 BLAAAA WOKAAA OOOOxx 9600 7147 0 0 0 0 0 600 1600 4600 9600 0 1 GFAAAA XOKAAA VVVVxx 5432 7148 0 0 2 12 32 432 1432 432 5432 64 65 YAAAAA YOKAAA AAAAxx 9299 7149 1 3 9 19 99 299 1299 4299 9299 198 199 RTAAAA ZOKAAA HHHHxx 2386 7150 0 2 6 6 86 386 386 2386 2386 172 173 UNAAAA APKAAA OOOOxx 2046 7151 0 2 6 6 46 46 46 2046 2046 92 93 SAAAAA BPKAAA VVVVxx 3293 7152 1 1 3 13 93 293 1293 3293 3293 186 187 RWAAAA CPKAAA AAAAxx 3046 7153 0 2 6 6 46 46 1046 3046 3046 92 93 ENAAAA DPKAAA HHHHxx 214 7154 0 2 4 14 14 214 214 214 214 28 29 GIAAAA EPKAAA OOOOxx 7893 7155 1 1 3 13 93 893 1893 2893 7893 186 187 PRAAAA FPKAAA VVVVxx 891 7156 1 3 1 11 91 891 891 891 891 182 183 HIAAAA GPKAAA AAAAxx 6499 7157 1 3 9 19 99 499 499 1499 6499 198 199 ZPAAAA HPKAAA HHHHxx 5003 7158 1 3 3 3 3 3 1003 3 5003 6 7 LKAAAA IPKAAA OOOOxx 6487 7159 1 3 7 7 87 487 487 1487 6487 174 175 NPAAAA JPKAAA VVVVxx 9403 7160 1 3 3 3 3 403 1403 4403 9403 6 7 RXAAAA KPKAAA AAAAxx 945 7161 1 1 5 5 45 945 945 945 945 90 91 JKAAAA LPKAAA HHHHxx 6713 7162 1 1 3 13 13 713 713 1713 6713 26 27 FYAAAA MPKAAA OOOOxx 9928 7163 0 0 8 8 28 928 1928 4928 9928 56 57 WRAAAA NPKAAA VVVVxx 8585 7164 1 1 5 5 85 585 585 3585 8585 170 171 FSAAAA OPKAAA AAAAxx 4004 7165 0 0 4 4 4 4 4 4004 4004 8 9 AYAAAA PPKAAA HHHHxx 2528 7166 0 0 8 8 28 528 528 2528 2528 56 57 GTAAAA QPKAAA OOOOxx 3350 7167 0 2 0 10 50 350 1350 3350 3350 100 101 WYAAAA RPKAAA VVVVxx 2160 7168 0 0 0 0 60 160 160 2160 2160 120 121 CFAAAA SPKAAA AAAAxx 1521 7169 1 1 1 1 21 521 1521 1521 1521 42 43 NGAAAA TPKAAA HHHHxx 5660 7170 0 0 0 0 60 660 1660 660 5660 120 121 SJAAAA UPKAAA OOOOxx 5755 7171 1 3 5 15 55 755 1755 755 5755 110 111 JNAAAA VPKAAA VVVVxx 7614 7172 0 2 4 14 14 614 1614 2614 7614 28 29 WGAAAA WPKAAA AAAAxx 3121 7173 1 1 1 1 21 121 1121 3121 3121 42 43 BQAAAA XPKAAA HHHHxx 2735 7174 1 3 5 15 35 735 735 2735 2735 70 71 FBAAAA YPKAAA OOOOxx 7506 7175 0 2 6 6 6 506 1506 2506 7506 12 13 SCAAAA ZPKAAA VVVVxx 2693 7176 1 1 3 13 93 693 693 2693 2693 186 187 PZAAAA AQKAAA AAAAxx 2892 7177 0 0 2 12 92 892 892 2892 2892 184 185 GHAAAA BQKAAA HHHHxx 3310 7178 0 2 0 10 10 310 1310 3310 3310 20 21 IXAAAA CQKAAA OOOOxx 3484 7179 0 0 4 4 84 484 1484 3484 3484 168 169 AEAAAA DQKAAA VVVVxx 9733 7180 1 1 3 13 33 733 1733 4733 9733 66 67 JKAAAA EQKAAA AAAAxx 29 7181 1 1 9 9 29 29 29 29 29 58 59 DBAAAA FQKAAA HHHHxx 9013 7182 1 1 3 13 13 13 1013 4013 9013 26 27 RIAAAA GQKAAA OOOOxx 3847 7183 1 3 7 7 47 847 1847 3847 3847 94 95 ZRAAAA HQKAAA VVVVxx 6724 7184 0 0 4 4 24 724 724 1724 6724 48 49 QYAAAA IQKAAA AAAAxx 2559 7185 1 3 9 19 59 559 559 2559 2559 118 119 LUAAAA JQKAAA HHHHxx 5326 7186 0 2 6 6 26 326 1326 326 5326 52 53 WWAAAA KQKAAA OOOOxx 4802 7187 0 2 2 2 2 802 802 4802 4802 4 5 SCAAAA LQKAAA VVVVxx 131 7188 1 3 1 11 31 131 131 131 131 62 63 BFAAAA MQKAAA AAAAxx 1634 7189 0 2 4 14 34 634 1634 1634 1634 68 69 WKAAAA NQKAAA HHHHxx 919 7190 1 3 9 19 19 919 919 919 919 38 39 JJAAAA OQKAAA OOOOxx 9575 7191 1 3 5 15 75 575 1575 4575 9575 150 151 HEAAAA PQKAAA VVVVxx 1256 7192 0 0 6 16 56 256 1256 1256 1256 112 113 IWAAAA QQKAAA AAAAxx 9428 7193 0 0 8 8 28 428 1428 4428 9428 56 57 QYAAAA RQKAAA HHHHxx 5121 7194 1 1 1 1 21 121 1121 121 5121 42 43 ZOAAAA SQKAAA OOOOxx 6584 7195 0 0 4 4 84 584 584 1584 6584 168 169 GTAAAA TQKAAA VVVVxx 7193 7196 1 1 3 13 93 193 1193 2193 7193 186 187 RQAAAA UQKAAA AAAAxx 4047 7197 1 3 7 7 47 47 47 4047 4047 94 95 RZAAAA VQKAAA HHHHxx 104 7198 0 0 4 4 4 104 104 104 104 8 9 AEAAAA WQKAAA OOOOxx 1527 7199 1 3 7 7 27 527 1527 1527 1527 54 55 TGAAAA XQKAAA VVVVxx 3460 7200 0 0 0 0 60 460 1460 3460 3460 120 121 CDAAAA YQKAAA AAAAxx 8526 7201 0 2 6 6 26 526 526 3526 8526 52 53 YPAAAA ZQKAAA HHHHxx 8959 7202 1 3 9 19 59 959 959 3959 8959 118 119 PGAAAA ARKAAA OOOOxx 3633 7203 1 1 3 13 33 633 1633 3633 3633 66 67 TJAAAA BRKAAA VVVVxx 1799 7204 1 3 9 19 99 799 1799 1799 1799 198 199 FRAAAA CRKAAA AAAAxx 461 7205 1 1 1 1 61 461 461 461 461 122 123 TRAAAA DRKAAA HHHHxx 718 7206 0 2 8 18 18 718 718 718 718 36 37 QBAAAA ERKAAA OOOOxx 3219 7207 1 3 9 19 19 219 1219 3219 3219 38 39 VTAAAA FRKAAA VVVVxx 3494 7208 0 2 4 14 94 494 1494 3494 3494 188 189 KEAAAA GRKAAA AAAAxx 9402 7209 0 2 2 2 2 402 1402 4402 9402 4 5 QXAAAA HRKAAA HHHHxx 7983 7210 1 3 3 3 83 983 1983 2983 7983 166 167 BVAAAA IRKAAA OOOOxx 7919 7211 1 3 9 19 19 919 1919 2919 7919 38 39 PSAAAA JRKAAA VVVVxx 8036 7212 0 0 6 16 36 36 36 3036 8036 72 73 CXAAAA KRKAAA AAAAxx 5164 7213 0 0 4 4 64 164 1164 164 5164 128 129 QQAAAA LRKAAA HHHHxx 4160 7214 0 0 0 0 60 160 160 4160 4160 120 121 AEAAAA MRKAAA OOOOxx 5370 7215 0 2 0 10 70 370 1370 370 5370 140 141 OYAAAA NRKAAA VVVVxx 5347 7216 1 3 7 7 47 347 1347 347 5347 94 95 RXAAAA ORKAAA AAAAxx 7109 7217 1 1 9 9 9 109 1109 2109 7109 18 19 LNAAAA PRKAAA HHHHxx 4826 7218 0 2 6 6 26 826 826 4826 4826 52 53 QDAAAA QRKAAA OOOOxx 1338 7219 0 2 8 18 38 338 1338 1338 1338 76 77 MZAAAA RRKAAA VVVVxx 2711 7220 1 3 1 11 11 711 711 2711 2711 22 23 HAAAAA SRKAAA AAAAxx 6299 7221 1 3 9 19 99 299 299 1299 6299 198 199 HIAAAA TRKAAA HHHHxx 1616 7222 0 0 6 16 16 616 1616 1616 1616 32 33 EKAAAA URKAAA OOOOxx 7519 7223 1 3 9 19 19 519 1519 2519 7519 38 39 FDAAAA VRKAAA VVVVxx 1262 7224 0 2 2 2 62 262 1262 1262 1262 124 125 OWAAAA WRKAAA AAAAxx 7228 7225 0 0 8 8 28 228 1228 2228 7228 56 57 ASAAAA XRKAAA HHHHxx 7892 7226 0 0 2 12 92 892 1892 2892 7892 184 185 ORAAAA YRKAAA OOOOxx 7929 7227 1 1 9 9 29 929 1929 2929 7929 58 59 ZSAAAA ZRKAAA VVVVxx 7705 7228 1 1 5 5 5 705 1705 2705 7705 10 11 JKAAAA ASKAAA AAAAxx 3111 7229 1 3 1 11 11 111 1111 3111 3111 22 23 RPAAAA BSKAAA HHHHxx 3066 7230 0 2 6 6 66 66 1066 3066 3066 132 133 YNAAAA CSKAAA OOOOxx 9559 7231 1 3 9 19 59 559 1559 4559 9559 118 119 RDAAAA DSKAAA VVVVxx 3787 7232 1 3 7 7 87 787 1787 3787 3787 174 175 RPAAAA ESKAAA AAAAxx 8710 7233 0 2 0 10 10 710 710 3710 8710 20 21 AXAAAA FSKAAA HHHHxx 4870 7234 0 2 0 10 70 870 870 4870 4870 140 141 IFAAAA GSKAAA OOOOxx 1883 7235 1 3 3 3 83 883 1883 1883 1883 166 167 LUAAAA HSKAAA VVVVxx 9689 7236 1 1 9 9 89 689 1689 4689 9689 178 179 RIAAAA ISKAAA AAAAxx 9491 7237 1 3 1 11 91 491 1491 4491 9491 182 183 BBAAAA JSKAAA HHHHxx 2035 7238 1 3 5 15 35 35 35 2035 2035 70 71 HAAAAA KSKAAA OOOOxx 655 7239 1 3 5 15 55 655 655 655 655 110 111 FZAAAA LSKAAA VVVVxx 6305 7240 1 1 5 5 5 305 305 1305 6305 10 11 NIAAAA MSKAAA AAAAxx 9423 7241 1 3 3 3 23 423 1423 4423 9423 46 47 LYAAAA NSKAAA HHHHxx 283 7242 1 3 3 3 83 283 283 283 283 166 167 XKAAAA OSKAAA OOOOxx 2607 7243 1 3 7 7 7 607 607 2607 2607 14 15 HWAAAA PSKAAA VVVVxx 7740 7244 0 0 0 0 40 740 1740 2740 7740 80 81 SLAAAA QSKAAA AAAAxx 6956 7245 0 0 6 16 56 956 956 1956 6956 112 113 OHAAAA RSKAAA HHHHxx 884 7246 0 0 4 4 84 884 884 884 884 168 169 AIAAAA SSKAAA OOOOxx 5730 7247 0 2 0 10 30 730 1730 730 5730 60 61 KMAAAA TSKAAA VVVVxx 3438 7248 0 2 8 18 38 438 1438 3438 3438 76 77 GCAAAA USKAAA AAAAxx 3250 7249 0 2 0 10 50 250 1250 3250 3250 100 101 AVAAAA VSKAAA HHHHxx 5470 7250 0 2 0 10 70 470 1470 470 5470 140 141 KCAAAA WSKAAA OOOOxx 2037 7251 1 1 7 17 37 37 37 2037 2037 74 75 JAAAAA XSKAAA VVVVxx 6593 7252 1 1 3 13 93 593 593 1593 6593 186 187 PTAAAA YSKAAA AAAAxx 3893 7253 1 1 3 13 93 893 1893 3893 3893 186 187 TTAAAA ZSKAAA HHHHxx 3200 7254 0 0 0 0 0 200 1200 3200 3200 0 1 CTAAAA ATKAAA OOOOxx 7125 7255 1 1 5 5 25 125 1125 2125 7125 50 51 BOAAAA BTKAAA VVVVxx 2295 7256 1 3 5 15 95 295 295 2295 2295 190 191 HKAAAA CTKAAA AAAAxx 2056 7257 0 0 6 16 56 56 56 2056 2056 112 113 CBAAAA DTKAAA HHHHxx 2962 7258 0 2 2 2 62 962 962 2962 2962 124 125 YJAAAA ETKAAA OOOOxx 993 7259 1 1 3 13 93 993 993 993 993 186 187 FMAAAA FTKAAA VVVVxx 9127 7260 1 3 7 7 27 127 1127 4127 9127 54 55 BNAAAA GTKAAA AAAAxx 2075 7261 1 3 5 15 75 75 75 2075 2075 150 151 VBAAAA HTKAAA HHHHxx 9338 7262 0 2 8 18 38 338 1338 4338 9338 76 77 EVAAAA ITKAAA OOOOxx 8100 7263 0 0 0 0 0 100 100 3100 8100 0 1 OZAAAA JTKAAA VVVVxx 5047 7264 1 3 7 7 47 47 1047 47 5047 94 95 DMAAAA KTKAAA AAAAxx 7032 7265 0 0 2 12 32 32 1032 2032 7032 64 65 MKAAAA LTKAAA HHHHxx 6374 7266 0 2 4 14 74 374 374 1374 6374 148 149 ELAAAA MTKAAA OOOOxx 4137 7267 1 1 7 17 37 137 137 4137 4137 74 75 DDAAAA NTKAAA VVVVxx 7132 7268 0 0 2 12 32 132 1132 2132 7132 64 65 IOAAAA OTKAAA AAAAxx 3064 7269 0 0 4 4 64 64 1064 3064 3064 128 129 WNAAAA PTKAAA HHHHxx 3621 7270 1 1 1 1 21 621 1621 3621 3621 42 43 HJAAAA QTKAAA OOOOxx 6199 7271 1 3 9 19 99 199 199 1199 6199 198 199 LEAAAA RTKAAA VVVVxx 4926 7272 0 2 6 6 26 926 926 4926 4926 52 53 MHAAAA STKAAA AAAAxx 8035 7273 1 3 5 15 35 35 35 3035 8035 70 71 BXAAAA TTKAAA HHHHxx 2195 7274 1 3 5 15 95 195 195 2195 2195 190 191 LGAAAA UTKAAA OOOOxx 5366 7275 0 2 6 6 66 366 1366 366 5366 132 133 KYAAAA VTKAAA VVVVxx 3478 7276 0 2 8 18 78 478 1478 3478 3478 156 157 UDAAAA WTKAAA AAAAxx 1926 7277 0 2 6 6 26 926 1926 1926 1926 52 53 CWAAAA XTKAAA HHHHxx 7265 7278 1 1 5 5 65 265 1265 2265 7265 130 131 LTAAAA YTKAAA OOOOxx 7668 7279 0 0 8 8 68 668 1668 2668 7668 136 137 YIAAAA ZTKAAA VVVVxx 3335 7280 1 3 5 15 35 335 1335 3335 3335 70 71 HYAAAA AUKAAA AAAAxx 7660 7281 0 0 0 0 60 660 1660 2660 7660 120 121 QIAAAA BUKAAA HHHHxx 9604 7282 0 0 4 4 4 604 1604 4604 9604 8 9 KFAAAA CUKAAA OOOOxx 7301 7283 1 1 1 1 1 301 1301 2301 7301 2 3 VUAAAA DUKAAA VVVVxx 4475 7284 1 3 5 15 75 475 475 4475 4475 150 151 DQAAAA EUKAAA AAAAxx 9954 7285 0 2 4 14 54 954 1954 4954 9954 108 109 WSAAAA FUKAAA HHHHxx 5723 7286 1 3 3 3 23 723 1723 723 5723 46 47 DMAAAA GUKAAA OOOOxx 2669 7287 1 1 9 9 69 669 669 2669 2669 138 139 RYAAAA HUKAAA VVVVxx 1685 7288 1 1 5 5 85 685 1685 1685 1685 170 171 VMAAAA IUKAAA AAAAxx 2233 7289 1 1 3 13 33 233 233 2233 2233 66 67 XHAAAA JUKAAA HHHHxx 8111 7290 1 3 1 11 11 111 111 3111 8111 22 23 ZZAAAA KUKAAA OOOOxx 7685 7291 1 1 5 5 85 685 1685 2685 7685 170 171 PJAAAA LUKAAA VVVVxx 3773 7292 1 1 3 13 73 773 1773 3773 3773 146 147 DPAAAA MUKAAA AAAAxx 7172 7293 0 0 2 12 72 172 1172 2172 7172 144 145 WPAAAA NUKAAA HHHHxx 1740 7294 0 0 0 0 40 740 1740 1740 1740 80 81 YOAAAA OUKAAA OOOOxx 5416 7295 0 0 6 16 16 416 1416 416 5416 32 33 IAAAAA PUKAAA VVVVxx 1823 7296 1 3 3 3 23 823 1823 1823 1823 46 47 DSAAAA QUKAAA AAAAxx 1668 7297 0 0 8 8 68 668 1668 1668 1668 136 137 EMAAAA RUKAAA HHHHxx 1795 7298 1 3 5 15 95 795 1795 1795 1795 190 191 BRAAAA SUKAAA OOOOxx 8599 7299 1 3 9 19 99 599 599 3599 8599 198 199 TSAAAA TUKAAA VVVVxx 5542 7300 0 2 2 2 42 542 1542 542 5542 84 85 EFAAAA UUKAAA AAAAxx 5658 7301 0 2 8 18 58 658 1658 658 5658 116 117 QJAAAA VUKAAA HHHHxx 9824 7302 0 0 4 4 24 824 1824 4824 9824 48 49 WNAAAA WUKAAA OOOOxx 19 7303 1 3 9 19 19 19 19 19 19 38 39 TAAAAA XUKAAA VVVVxx 9344 7304 0 0 4 4 44 344 1344 4344 9344 88 89 KVAAAA YUKAAA AAAAxx 5900 7305 0 0 0 0 0 900 1900 900 5900 0 1 YSAAAA ZUKAAA HHHHxx 7818 7306 0 2 8 18 18 818 1818 2818 7818 36 37 SOAAAA AVKAAA OOOOxx 8377 7307 1 1 7 17 77 377 377 3377 8377 154 155 FKAAAA BVKAAA VVVVxx 6886 7308 0 2 6 6 86 886 886 1886 6886 172 173 WEAAAA CVKAAA AAAAxx 3201 7309 1 1 1 1 1 201 1201 3201 3201 2 3 DTAAAA DVKAAA HHHHxx 87 7310 1 3 7 7 87 87 87 87 87 174 175 JDAAAA EVKAAA OOOOxx 1089 7311 1 1 9 9 89 89 1089 1089 1089 178 179 XPAAAA FVKAAA VVVVxx 3948 7312 0 0 8 8 48 948 1948 3948 3948 96 97 WVAAAA GVKAAA AAAAxx 6383 7313 1 3 3 3 83 383 383 1383 6383 166 167 NLAAAA HVKAAA HHHHxx 837 7314 1 1 7 17 37 837 837 837 837 74 75 FGAAAA IVKAAA OOOOxx 6285 7315 1 1 5 5 85 285 285 1285 6285 170 171 THAAAA JVKAAA VVVVxx 78 7316 0 2 8 18 78 78 78 78 78 156 157 ADAAAA KVKAAA AAAAxx 4389 7317 1 1 9 9 89 389 389 4389 4389 178 179 VMAAAA LVKAAA HHHHxx 4795 7318 1 3 5 15 95 795 795 4795 4795 190 191 LCAAAA MVKAAA OOOOxx 9369 7319 1 1 9 9 69 369 1369 4369 9369 138 139 JWAAAA NVKAAA VVVVxx 69 7320 1 1 9 9 69 69 69 69 69 138 139 RCAAAA OVKAAA AAAAxx 7689 7321 1 1 9 9 89 689 1689 2689 7689 178 179 TJAAAA PVKAAA HHHHxx 5642 7322 0 2 2 2 42 642 1642 642 5642 84 85 AJAAAA QVKAAA OOOOxx 2348 7323 0 0 8 8 48 348 348 2348 2348 96 97 IMAAAA RVKAAA VVVVxx 9308 7324 0 0 8 8 8 308 1308 4308 9308 16 17 AUAAAA SVKAAA AAAAxx 9093 7325 1 1 3 13 93 93 1093 4093 9093 186 187 TLAAAA TVKAAA HHHHxx 1199 7326 1 3 9 19 99 199 1199 1199 1199 198 199 DUAAAA UVKAAA OOOOxx 307 7327 1 3 7 7 7 307 307 307 307 14 15 VLAAAA VVKAAA VVVVxx 3814 7328 0 2 4 14 14 814 1814 3814 3814 28 29 SQAAAA WVKAAA AAAAxx 8817 7329 1 1 7 17 17 817 817 3817 8817 34 35 DBAAAA XVKAAA HHHHxx 2329 7330 1 1 9 9 29 329 329 2329 2329 58 59 PLAAAA YVKAAA OOOOxx 2932 7331 0 0 2 12 32 932 932 2932 2932 64 65 UIAAAA ZVKAAA VVVVxx 1986 7332 0 2 6 6 86 986 1986 1986 1986 172 173 KYAAAA AWKAAA AAAAxx 5279 7333 1 3 9 19 79 279 1279 279 5279 158 159 BVAAAA BWKAAA HHHHxx 5357 7334 1 1 7 17 57 357 1357 357 5357 114 115 BYAAAA CWKAAA OOOOxx 6778 7335 0 2 8 18 78 778 778 1778 6778 156 157 SAAAAA DWKAAA VVVVxx 2773 7336 1 1 3 13 73 773 773 2773 2773 146 147 RCAAAA EWKAAA AAAAxx 244 7337 0 0 4 4 44 244 244 244 244 88 89 KJAAAA FWKAAA HHHHxx 6900 7338 0 0 0 0 0 900 900 1900 6900 0 1 KFAAAA GWKAAA OOOOxx 4739 7339 1 3 9 19 39 739 739 4739 4739 78 79 HAAAAA HWKAAA VVVVxx 3217 7340 1 1 7 17 17 217 1217 3217 3217 34 35 TTAAAA IWKAAA AAAAxx 7563 7341 1 3 3 3 63 563 1563 2563 7563 126 127 XEAAAA JWKAAA HHHHxx 1807 7342 1 3 7 7 7 807 1807 1807 1807 14 15 NRAAAA KWKAAA OOOOxx 4199 7343 1 3 9 19 99 199 199 4199 4199 198 199 NFAAAA LWKAAA VVVVxx 1077 7344 1 1 7 17 77 77 1077 1077 1077 154 155 LPAAAA MWKAAA AAAAxx 8348 7345 0 0 8 8 48 348 348 3348 8348 96 97 CJAAAA NWKAAA HHHHxx 841 7346 1 1 1 1 41 841 841 841 841 82 83 JGAAAA OWKAAA OOOOxx 8154 7347 0 2 4 14 54 154 154 3154 8154 108 109 QBAAAA PWKAAA VVVVxx 5261 7348 1 1 1 1 61 261 1261 261 5261 122 123 JUAAAA QWKAAA AAAAxx 1950 7349 0 2 0 10 50 950 1950 1950 1950 100 101 AXAAAA RWKAAA HHHHxx 8472 7350 0 0 2 12 72 472 472 3472 8472 144 145 WNAAAA SWKAAA OOOOxx 8745 7351 1 1 5 5 45 745 745 3745 8745 90 91 JYAAAA TWKAAA VVVVxx 8715 7352 1 3 5 15 15 715 715 3715 8715 30 31 FXAAAA UWKAAA AAAAxx 9708 7353 0 0 8 8 8 708 1708 4708 9708 16 17 KJAAAA VWKAAA HHHHxx 5860 7354 0 0 0 0 60 860 1860 860 5860 120 121 KRAAAA WWKAAA OOOOxx 9142 7355 0 2 2 2 42 142 1142 4142 9142 84 85 QNAAAA XWKAAA VVVVxx 6582 7356 0 2 2 2 82 582 582 1582 6582 164 165 ETAAAA YWKAAA AAAAxx 1255 7357 1 3 5 15 55 255 1255 1255 1255 110 111 HWAAAA ZWKAAA HHHHxx 6459 7358 1 3 9 19 59 459 459 1459 6459 118 119 LOAAAA AXKAAA OOOOxx 6327 7359 1 3 7 7 27 327 327 1327 6327 54 55 JJAAAA BXKAAA VVVVxx 4692 7360 0 0 2 12 92 692 692 4692 4692 184 185 MYAAAA CXKAAA AAAAxx 3772 7361 0 0 2 12 72 772 1772 3772 3772 144 145 CPAAAA DXKAAA HHHHxx 4203 7362 1 3 3 3 3 203 203 4203 4203 6 7 RFAAAA EXKAAA OOOOxx 2946 7363 0 2 6 6 46 946 946 2946 2946 92 93 IJAAAA FXKAAA VVVVxx 3524 7364 0 0 4 4 24 524 1524 3524 3524 48 49 OFAAAA GXKAAA AAAAxx 8409 7365 1 1 9 9 9 409 409 3409 8409 18 19 LLAAAA HXKAAA HHHHxx 1824 7366 0 0 4 4 24 824 1824 1824 1824 48 49 ESAAAA IXKAAA OOOOxx 4637 7367 1 1 7 17 37 637 637 4637 4637 74 75 JWAAAA JXKAAA VVVVxx 589 7368 1 1 9 9 89 589 589 589 589 178 179 RWAAAA KXKAAA AAAAxx 484 7369 0 0 4 4 84 484 484 484 484 168 169 QSAAAA LXKAAA HHHHxx 8963 7370 1 3 3 3 63 963 963 3963 8963 126 127 TGAAAA MXKAAA OOOOxx 5502 7371 0 2 2 2 2 502 1502 502 5502 4 5 QDAAAA NXKAAA VVVVxx 6982 7372 0 2 2 2 82 982 982 1982 6982 164 165 OIAAAA OXKAAA AAAAxx 8029 7373 1 1 9 9 29 29 29 3029 8029 58 59 VWAAAA PXKAAA HHHHxx 4395 7374 1 3 5 15 95 395 395 4395 4395 190 191 BNAAAA QXKAAA OOOOxx 2595 7375 1 3 5 15 95 595 595 2595 2595 190 191 VVAAAA RXKAAA VVVVxx 2133 7376 1 1 3 13 33 133 133 2133 2133 66 67 BEAAAA SXKAAA AAAAxx 1414 7377 0 2 4 14 14 414 1414 1414 1414 28 29 KCAAAA TXKAAA HHHHxx 8201 7378 1 1 1 1 1 201 201 3201 8201 2 3 LDAAAA UXKAAA OOOOxx 4706 7379 0 2 6 6 6 706 706 4706 4706 12 13 AZAAAA VXKAAA VVVVxx 5310 7380 0 2 0 10 10 310 1310 310 5310 20 21 GWAAAA WXKAAA AAAAxx 7333 7381 1 1 3 13 33 333 1333 2333 7333 66 67 BWAAAA XXKAAA HHHHxx 9420 7382 0 0 0 0 20 420 1420 4420 9420 40 41 IYAAAA YXKAAA OOOOxx 1383 7383 1 3 3 3 83 383 1383 1383 1383 166 167 FBAAAA ZXKAAA VVVVxx 6225 7384 1 1 5 5 25 225 225 1225 6225 50 51 LFAAAA AYKAAA AAAAxx 2064 7385 0 0 4 4 64 64 64 2064 2064 128 129 KBAAAA BYKAAA HHHHxx 6700 7386 0 0 0 0 0 700 700 1700 6700 0 1 SXAAAA CYKAAA OOOOxx 1352 7387 0 0 2 12 52 352 1352 1352 1352 104 105 AAAAAA DYKAAA VVVVxx 4249 7388 1 1 9 9 49 249 249 4249 4249 98 99 LHAAAA EYKAAA AAAAxx 9429 7389 1 1 9 9 29 429 1429 4429 9429 58 59 RYAAAA FYKAAA HHHHxx 8090 7390 0 2 0 10 90 90 90 3090 8090 180 181 EZAAAA GYKAAA OOOOxx 5378 7391 0 2 8 18 78 378 1378 378 5378 156 157 WYAAAA HYKAAA VVVVxx 9085 7392 1 1 5 5 85 85 1085 4085 9085 170 171 LLAAAA IYKAAA AAAAxx 7468 7393 0 0 8 8 68 468 1468 2468 7468 136 137 GBAAAA JYKAAA HHHHxx 9955 7394 1 3 5 15 55 955 1955 4955 9955 110 111 XSAAAA KYKAAA OOOOxx 8692 7395 0 0 2 12 92 692 692 3692 8692 184 185 IWAAAA LYKAAA VVVVxx 1463 7396 1 3 3 3 63 463 1463 1463 1463 126 127 HEAAAA MYKAAA AAAAxx 3577 7397 1 1 7 17 77 577 1577 3577 3577 154 155 PHAAAA NYKAAA HHHHxx 5654 7398 0 2 4 14 54 654 1654 654 5654 108 109 MJAAAA OYKAAA OOOOxx 7955 7399 1 3 5 15 55 955 1955 2955 7955 110 111 ZTAAAA PYKAAA VVVVxx 4843 7400 1 3 3 3 43 843 843 4843 4843 86 87 HEAAAA QYKAAA AAAAxx 1776 7401 0 0 6 16 76 776 1776 1776 1776 152 153 IQAAAA RYKAAA HHHHxx 2223 7402 1 3 3 3 23 223 223 2223 2223 46 47 NHAAAA SYKAAA OOOOxx 8442 7403 0 2 2 2 42 442 442 3442 8442 84 85 SMAAAA TYKAAA VVVVxx 9738 7404 0 2 8 18 38 738 1738 4738 9738 76 77 OKAAAA UYKAAA AAAAxx 4867 7405 1 3 7 7 67 867 867 4867 4867 134 135 FFAAAA VYKAAA HHHHxx 2983 7406 1 3 3 3 83 983 983 2983 2983 166 167 TKAAAA WYKAAA OOOOxx 3300 7407 0 0 0 0 0 300 1300 3300 3300 0 1 YWAAAA XYKAAA VVVVxx 3815 7408 1 3 5 15 15 815 1815 3815 3815 30 31 TQAAAA YYKAAA AAAAxx 1779 7409 1 3 9 19 79 779 1779 1779 1779 158 159 LQAAAA ZYKAAA HHHHxx 1123 7410 1 3 3 3 23 123 1123 1123 1123 46 47 FRAAAA AZKAAA OOOOxx 4824 7411 0 0 4 4 24 824 824 4824 4824 48 49 ODAAAA BZKAAA VVVVxx 5407 7412 1 3 7 7 7 407 1407 407 5407 14 15 ZZAAAA CZKAAA AAAAxx 5123 7413 1 3 3 3 23 123 1123 123 5123 46 47 BPAAAA DZKAAA HHHHxx 2515 7414 1 3 5 15 15 515 515 2515 2515 30 31 TSAAAA EZKAAA OOOOxx 4781 7415 1 1 1 1 81 781 781 4781 4781 162 163 XBAAAA FZKAAA VVVVxx 7831 7416 1 3 1 11 31 831 1831 2831 7831 62 63 FPAAAA GZKAAA AAAAxx 6946 7417 0 2 6 6 46 946 946 1946 6946 92 93 EHAAAA HZKAAA HHHHxx 1215 7418 1 3 5 15 15 215 1215 1215 1215 30 31 TUAAAA IZKAAA OOOOxx 7783 7419 1 3 3 3 83 783 1783 2783 7783 166 167 JNAAAA JZKAAA VVVVxx 4532 7420 0 0 2 12 32 532 532 4532 4532 64 65 ISAAAA KZKAAA AAAAxx 9068 7421 0 0 8 8 68 68 1068 4068 9068 136 137 UKAAAA LZKAAA HHHHxx 7030 7422 0 2 0 10 30 30 1030 2030 7030 60 61 KKAAAA MZKAAA OOOOxx 436 7423 0 0 6 16 36 436 436 436 436 72 73 UQAAAA NZKAAA VVVVxx 6549 7424 1 1 9 9 49 549 549 1549 6549 98 99 XRAAAA OZKAAA AAAAxx 3348 7425 0 0 8 8 48 348 1348 3348 3348 96 97 UYAAAA PZKAAA HHHHxx 6229 7426 1 1 9 9 29 229 229 1229 6229 58 59 PFAAAA QZKAAA OOOOxx 3933 7427 1 1 3 13 33 933 1933 3933 3933 66 67 HVAAAA RZKAAA VVVVxx 1876 7428 0 0 6 16 76 876 1876 1876 1876 152 153 EUAAAA SZKAAA AAAAxx 8920 7429 0 0 0 0 20 920 920 3920 8920 40 41 CFAAAA TZKAAA HHHHxx 7926 7430 0 2 6 6 26 926 1926 2926 7926 52 53 WSAAAA UZKAAA OOOOxx 8805 7431 1 1 5 5 5 805 805 3805 8805 10 11 RAAAAA VZKAAA VVVVxx 6729 7432 1 1 9 9 29 729 729 1729 6729 58 59 VYAAAA WZKAAA AAAAxx 7397 7433 1 1 7 17 97 397 1397 2397 7397 194 195 NYAAAA XZKAAA HHHHxx 9303 7434 1 3 3 3 3 303 1303 4303 9303 6 7 VTAAAA YZKAAA OOOOxx 4255 7435 1 3 5 15 55 255 255 4255 4255 110 111 RHAAAA ZZKAAA VVVVxx 7229 7436 1 1 9 9 29 229 1229 2229 7229 58 59 BSAAAA AALAAA AAAAxx 854 7437 0 2 4 14 54 854 854 854 854 108 109 WGAAAA BALAAA HHHHxx 6723 7438 1 3 3 3 23 723 723 1723 6723 46 47 PYAAAA CALAAA OOOOxx 9597 7439 1 1 7 17 97 597 1597 4597 9597 194 195 DFAAAA DALAAA VVVVxx 6532 7440 0 0 2 12 32 532 532 1532 6532 64 65 GRAAAA EALAAA AAAAxx 2910 7441 0 2 0 10 10 910 910 2910 2910 20 21 YHAAAA FALAAA HHHHxx 6717 7442 1 1 7 17 17 717 717 1717 6717 34 35 JYAAAA GALAAA OOOOxx 1790 7443 0 2 0 10 90 790 1790 1790 1790 180 181 WQAAAA HALAAA VVVVxx 3761 7444 1 1 1 1 61 761 1761 3761 3761 122 123 ROAAAA IALAAA AAAAxx 1565 7445 1 1 5 5 65 565 1565 1565 1565 130 131 FIAAAA JALAAA HHHHxx 6205 7446 1 1 5 5 5 205 205 1205 6205 10 11 REAAAA KALAAA OOOOxx 2726 7447 0 2 6 6 26 726 726 2726 2726 52 53 WAAAAA LALAAA VVVVxx 799 7448 1 3 9 19 99 799 799 799 799 198 199 TEAAAA MALAAA AAAAxx 3540 7449 0 0 0 0 40 540 1540 3540 3540 80 81 EGAAAA NALAAA HHHHxx 5878 7450 0 2 8 18 78 878 1878 878 5878 156 157 CSAAAA OALAAA OOOOxx 2542 7451 0 2 2 2 42 542 542 2542 2542 84 85 UTAAAA PALAAA VVVVxx 4888 7452 0 0 8 8 88 888 888 4888 4888 176 177 AGAAAA QALAAA AAAAxx 5290 7453 0 2 0 10 90 290 1290 290 5290 180 181 MVAAAA RALAAA HHHHxx 7995 7454 1 3 5 15 95 995 1995 2995 7995 190 191 NVAAAA SALAAA OOOOxx 3519 7455 1 3 9 19 19 519 1519 3519 3519 38 39 JFAAAA TALAAA VVVVxx 3571 7456 1 3 1 11 71 571 1571 3571 3571 142 143 JHAAAA UALAAA AAAAxx 7854 7457 0 2 4 14 54 854 1854 2854 7854 108 109 CQAAAA VALAAA HHHHxx 5184 7458 0 0 4 4 84 184 1184 184 5184 168 169 KRAAAA WALAAA OOOOxx 3498 7459 0 2 8 18 98 498 1498 3498 3498 196 197 OEAAAA XALAAA VVVVxx 1264 7460 0 0 4 4 64 264 1264 1264 1264 128 129 QWAAAA YALAAA AAAAxx 3159 7461 1 3 9 19 59 159 1159 3159 3159 118 119 NRAAAA ZALAAA HHHHxx 5480 7462 0 0 0 0 80 480 1480 480 5480 160 161 UCAAAA ABLAAA OOOOxx 1706 7463 0 2 6 6 6 706 1706 1706 1706 12 13 QNAAAA BBLAAA VVVVxx 4540 7464 0 0 0 0 40 540 540 4540 4540 80 81 QSAAAA CBLAAA AAAAxx 2799 7465 1 3 9 19 99 799 799 2799 2799 198 199 RDAAAA DBLAAA HHHHxx 7389 7466 1 1 9 9 89 389 1389 2389 7389 178 179 FYAAAA EBLAAA OOOOxx 5565 7467 1 1 5 5 65 565 1565 565 5565 130 131 BGAAAA FBLAAA VVVVxx 3896 7468 0 0 6 16 96 896 1896 3896 3896 192 193 WTAAAA GBLAAA AAAAxx 2100 7469 0 0 0 0 0 100 100 2100 2100 0 1 UCAAAA HBLAAA HHHHxx 3507 7470 1 3 7 7 7 507 1507 3507 3507 14 15 XEAAAA IBLAAA OOOOxx 7971 7471 1 3 1 11 71 971 1971 2971 7971 142 143 PUAAAA JBLAAA VVVVxx 2312 7472 0 0 2 12 12 312 312 2312 2312 24 25 YKAAAA KBLAAA AAAAxx 2494 7473 0 2 4 14 94 494 494 2494 2494 188 189 YRAAAA LBLAAA HHHHxx 2474 7474 0 2 4 14 74 474 474 2474 2474 148 149 ERAAAA MBLAAA OOOOxx 3136 7475 0 0 6 16 36 136 1136 3136 3136 72 73 QQAAAA NBLAAA VVVVxx 7242 7476 0 2 2 2 42 242 1242 2242 7242 84 85 OSAAAA OBLAAA AAAAxx 9430 7477 0 2 0 10 30 430 1430 4430 9430 60 61 SYAAAA PBLAAA HHHHxx 1052 7478 0 0 2 12 52 52 1052 1052 1052 104 105 MOAAAA QBLAAA OOOOxx 4172 7479 0 0 2 12 72 172 172 4172 4172 144 145 MEAAAA RBLAAA VVVVxx 970 7480 0 2 0 10 70 970 970 970 970 140 141 ILAAAA SBLAAA AAAAxx 882 7481 0 2 2 2 82 882 882 882 882 164 165 YHAAAA TBLAAA HHHHxx 9799 7482 1 3 9 19 99 799 1799 4799 9799 198 199 XMAAAA UBLAAA OOOOxx 5850 7483 0 2 0 10 50 850 1850 850 5850 100 101 ARAAAA VBLAAA VVVVxx 9473 7484 1 1 3 13 73 473 1473 4473 9473 146 147 JAAAAA WBLAAA AAAAxx 8635 7485 1 3 5 15 35 635 635 3635 8635 70 71 DUAAAA XBLAAA HHHHxx 2349 7486 1 1 9 9 49 349 349 2349 2349 98 99 JMAAAA YBLAAA OOOOxx 2270 7487 0 2 0 10 70 270 270 2270 2270 140 141 IJAAAA ZBLAAA VVVVxx 7887 7488 1 3 7 7 87 887 1887 2887 7887 174 175 JRAAAA ACLAAA AAAAxx 3091 7489 1 3 1 11 91 91 1091 3091 3091 182 183 XOAAAA BCLAAA HHHHxx 3728 7490 0 0 8 8 28 728 1728 3728 3728 56 57 KNAAAA CCLAAA OOOOxx 3658 7491 0 2 8 18 58 658 1658 3658 3658 116 117 SKAAAA DCLAAA VVVVxx 5975 7492 1 3 5 15 75 975 1975 975 5975 150 151 VVAAAA ECLAAA AAAAxx 332 7493 0 0 2 12 32 332 332 332 332 64 65 UMAAAA FCLAAA HHHHxx 7990 7494 0 2 0 10 90 990 1990 2990 7990 180 181 IVAAAA GCLAAA OOOOxx 8688 7495 0 0 8 8 88 688 688 3688 8688 176 177 EWAAAA HCLAAA VVVVxx 9601 7496 1 1 1 1 1 601 1601 4601 9601 2 3 HFAAAA ICLAAA AAAAxx 8401 7497 1 1 1 1 1 401 401 3401 8401 2 3 DLAAAA JCLAAA HHHHxx 8093 7498 1 1 3 13 93 93 93 3093 8093 186 187 HZAAAA KCLAAA OOOOxx 4278 7499 0 2 8 18 78 278 278 4278 4278 156 157 OIAAAA LCLAAA VVVVxx 5467 7500 1 3 7 7 67 467 1467 467 5467 134 135 HCAAAA MCLAAA AAAAxx 3137 7501 1 1 7 17 37 137 1137 3137 3137 74 75 RQAAAA NCLAAA HHHHxx 204 7502 0 0 4 4 4 204 204 204 204 8 9 WHAAAA OCLAAA OOOOxx 8224 7503 0 0 4 4 24 224 224 3224 8224 48 49 IEAAAA PCLAAA VVVVxx 2944 7504 0 0 4 4 44 944 944 2944 2944 88 89 GJAAAA QCLAAA AAAAxx 7593 7505 1 1 3 13 93 593 1593 2593 7593 186 187 BGAAAA RCLAAA HHHHxx 814 7506 0 2 4 14 14 814 814 814 814 28 29 IFAAAA SCLAAA OOOOxx 8047 7507 1 3 7 7 47 47 47 3047 8047 94 95 NXAAAA TCLAAA VVVVxx 7802 7508 0 2 2 2 2 802 1802 2802 7802 4 5 COAAAA UCLAAA AAAAxx 901 7509 1 1 1 1 1 901 901 901 901 2 3 RIAAAA VCLAAA HHHHxx 6168 7510 0 0 8 8 68 168 168 1168 6168 136 137 GDAAAA WCLAAA OOOOxx 2950 7511 0 2 0 10 50 950 950 2950 2950 100 101 MJAAAA XCLAAA VVVVxx 5393 7512 1 1 3 13 93 393 1393 393 5393 186 187 LZAAAA YCLAAA AAAAxx 3585 7513 1 1 5 5 85 585 1585 3585 3585 170 171 XHAAAA ZCLAAA HHHHxx 9392 7514 0 0 2 12 92 392 1392 4392 9392 184 185 GXAAAA ADLAAA OOOOxx 8314 7515 0 2 4 14 14 314 314 3314 8314 28 29 UHAAAA BDLAAA VVVVxx 9972 7516 0 0 2 12 72 972 1972 4972 9972 144 145 OTAAAA CDLAAA AAAAxx 9130 7517 0 2 0 10 30 130 1130 4130 9130 60 61 ENAAAA DDLAAA HHHHxx 975 7518 1 3 5 15 75 975 975 975 975 150 151 NLAAAA EDLAAA OOOOxx 5720 7519 0 0 0 0 20 720 1720 720 5720 40 41 AMAAAA FDLAAA VVVVxx 3769 7520 1 1 9 9 69 769 1769 3769 3769 138 139 ZOAAAA GDLAAA AAAAxx 5303 7521 1 3 3 3 3 303 1303 303 5303 6 7 ZVAAAA HDLAAA HHHHxx 6564 7522 0 0 4 4 64 564 564 1564 6564 128 129 MSAAAA IDLAAA OOOOxx 7855 7523 1 3 5 15 55 855 1855 2855 7855 110 111 DQAAAA JDLAAA VVVVxx 8153 7524 1 1 3 13 53 153 153 3153 8153 106 107 PBAAAA KDLAAA AAAAxx 2292 7525 0 0 2 12 92 292 292 2292 2292 184 185 EKAAAA LDLAAA HHHHxx 3156 7526 0 0 6 16 56 156 1156 3156 3156 112 113 KRAAAA MDLAAA OOOOxx 6580 7527 0 0 0 0 80 580 580 1580 6580 160 161 CTAAAA NDLAAA VVVVxx 5324 7528 0 0 4 4 24 324 1324 324 5324 48 49 UWAAAA ODLAAA AAAAxx 8871 7529 1 3 1 11 71 871 871 3871 8871 142 143 FDAAAA PDLAAA HHHHxx 2543 7530 1 3 3 3 43 543 543 2543 2543 86 87 VTAAAA QDLAAA OOOOxx 7857 7531 1 1 7 17 57 857 1857 2857 7857 114 115 FQAAAA RDLAAA VVVVxx 4084 7532 0 0 4 4 84 84 84 4084 4084 168 169 CBAAAA SDLAAA AAAAxx 9887 7533 1 3 7 7 87 887 1887 4887 9887 174 175 HQAAAA TDLAAA HHHHxx 6940 7534 0 0 0 0 40 940 940 1940 6940 80 81 YGAAAA UDLAAA OOOOxx 3415 7535 1 3 5 15 15 415 1415 3415 3415 30 31 JBAAAA VDLAAA VVVVxx 5012 7536 0 0 2 12 12 12 1012 12 5012 24 25 UKAAAA WDLAAA AAAAxx 3187 7537 1 3 7 7 87 187 1187 3187 3187 174 175 PSAAAA XDLAAA HHHHxx 8556 7538 0 0 6 16 56 556 556 3556 8556 112 113 CRAAAA YDLAAA OOOOxx 7966 7539 0 2 6 6 66 966 1966 2966 7966 132 133 KUAAAA ZDLAAA VVVVxx 7481 7540 1 1 1 1 81 481 1481 2481 7481 162 163 TBAAAA AELAAA AAAAxx 8524 7541 0 0 4 4 24 524 524 3524 8524 48 49 WPAAAA BELAAA HHHHxx 3021 7542 1 1 1 1 21 21 1021 3021 3021 42 43 FMAAAA CELAAA OOOOxx 6045 7543 1 1 5 5 45 45 45 1045 6045 90 91 NYAAAA DELAAA VVVVxx 8022 7544 0 2 2 2 22 22 22 3022 8022 44 45 OWAAAA EELAAA AAAAxx 3626 7545 0 2 6 6 26 626 1626 3626 3626 52 53 MJAAAA FELAAA HHHHxx 1030 7546 0 2 0 10 30 30 1030 1030 1030 60 61 QNAAAA GELAAA OOOOxx 8903 7547 1 3 3 3 3 903 903 3903 8903 6 7 LEAAAA HELAAA VVVVxx 7488 7548 0 0 8 8 88 488 1488 2488 7488 176 177 ACAAAA IELAAA AAAAxx 9293 7549 1 1 3 13 93 293 1293 4293 9293 186 187 LTAAAA JELAAA HHHHxx 4586 7550 0 2 6 6 86 586 586 4586 4586 172 173 KUAAAA KELAAA OOOOxx 9282 7551 0 2 2 2 82 282 1282 4282 9282 164 165 ATAAAA LELAAA VVVVxx 1948 7552 0 0 8 8 48 948 1948 1948 1948 96 97 YWAAAA MELAAA AAAAxx 2534 7553 0 2 4 14 34 534 534 2534 2534 68 69 MTAAAA NELAAA HHHHxx 1150 7554 0 2 0 10 50 150 1150 1150 1150 100 101 GSAAAA OELAAA OOOOxx 4931 7555 1 3 1 11 31 931 931 4931 4931 62 63 RHAAAA PELAAA VVVVxx 2866 7556 0 2 6 6 66 866 866 2866 2866 132 133 GGAAAA QELAAA AAAAxx 6172 7557 0 0 2 12 72 172 172 1172 6172 144 145 KDAAAA RELAAA HHHHxx 4819 7558 1 3 9 19 19 819 819 4819 4819 38 39 JDAAAA SELAAA OOOOxx 569 7559 1 1 9 9 69 569 569 569 569 138 139 XVAAAA TELAAA VVVVxx 1146 7560 0 2 6 6 46 146 1146 1146 1146 92 93 CSAAAA UELAAA AAAAxx 3062 7561 0 2 2 2 62 62 1062 3062 3062 124 125 UNAAAA VELAAA HHHHxx 7690 7562 0 2 0 10 90 690 1690 2690 7690 180 181 UJAAAA WELAAA OOOOxx 8611 7563 1 3 1 11 11 611 611 3611 8611 22 23 FTAAAA XELAAA VVVVxx 1142 7564 0 2 2 2 42 142 1142 1142 1142 84 85 YRAAAA YELAAA AAAAxx 1193 7565 1 1 3 13 93 193 1193 1193 1193 186 187 XTAAAA ZELAAA HHHHxx 2507 7566 1 3 7 7 7 507 507 2507 2507 14 15 LSAAAA AFLAAA OOOOxx 1043 7567 1 3 3 3 43 43 1043 1043 1043 86 87 DOAAAA BFLAAA VVVVxx 7472 7568 0 0 2 12 72 472 1472 2472 7472 144 145 KBAAAA CFLAAA AAAAxx 1817 7569 1 1 7 17 17 817 1817 1817 1817 34 35 XRAAAA DFLAAA HHHHxx 3868 7570 0 0 8 8 68 868 1868 3868 3868 136 137 USAAAA EFLAAA OOOOxx 9031 7571 1 3 1 11 31 31 1031 4031 9031 62 63 JJAAAA FFLAAA VVVVxx 7254 7572 0 2 4 14 54 254 1254 2254 7254 108 109 ATAAAA GFLAAA AAAAxx 5030 7573 0 2 0 10 30 30 1030 30 5030 60 61 MLAAAA HFLAAA HHHHxx 6594 7574 0 2 4 14 94 594 594 1594 6594 188 189 QTAAAA IFLAAA OOOOxx 6862 7575 0 2 2 2 62 862 862 1862 6862 124 125 YDAAAA JFLAAA VVVVxx 1994 7576 0 2 4 14 94 994 1994 1994 1994 188 189 SYAAAA KFLAAA AAAAxx 9017 7577 1 1 7 17 17 17 1017 4017 9017 34 35 VIAAAA LFLAAA HHHHxx 5716 7578 0 0 6 16 16 716 1716 716 5716 32 33 WLAAAA MFLAAA OOOOxx 1900 7579 0 0 0 0 0 900 1900 1900 1900 0 1 CVAAAA NFLAAA VVVVxx 120 7580 0 0 0 0 20 120 120 120 120 40 41 QEAAAA OFLAAA AAAAxx 9003 7581 1 3 3 3 3 3 1003 4003 9003 6 7 HIAAAA PFLAAA HHHHxx 4178 7582 0 2 8 18 78 178 178 4178 4178 156 157 SEAAAA QFLAAA OOOOxx 8777 7583 1 1 7 17 77 777 777 3777 8777 154 155 PZAAAA RFLAAA VVVVxx 3653 7584 1 1 3 13 53 653 1653 3653 3653 106 107 NKAAAA SFLAAA AAAAxx 1137 7585 1 1 7 17 37 137 1137 1137 1137 74 75 TRAAAA TFLAAA HHHHxx 6362 7586 0 2 2 2 62 362 362 1362 6362 124 125 SKAAAA UFLAAA OOOOxx 8537 7587 1 1 7 17 37 537 537 3537 8537 74 75 JQAAAA VFLAAA VVVVxx 1590 7588 0 2 0 10 90 590 1590 1590 1590 180 181 EJAAAA WFLAAA AAAAxx 374 7589 0 2 4 14 74 374 374 374 374 148 149 KOAAAA XFLAAA HHHHxx 2597 7590 1 1 7 17 97 597 597 2597 2597 194 195 XVAAAA YFLAAA OOOOxx 8071 7591 1 3 1 11 71 71 71 3071 8071 142 143 LYAAAA ZFLAAA VVVVxx 9009 7592 1 1 9 9 9 9 1009 4009 9009 18 19 NIAAAA AGLAAA AAAAxx 1978 7593 0 2 8 18 78 978 1978 1978 1978 156 157 CYAAAA BGLAAA HHHHxx 1541 7594 1 1 1 1 41 541 1541 1541 1541 82 83 HHAAAA CGLAAA OOOOxx 4998 7595 0 2 8 18 98 998 998 4998 4998 196 197 GKAAAA DGLAAA VVVVxx 1649 7596 1 1 9 9 49 649 1649 1649 1649 98 99 LLAAAA EGLAAA AAAAxx 5426 7597 0 2 6 6 26 426 1426 426 5426 52 53 SAAAAA FGLAAA HHHHxx 1492 7598 0 0 2 12 92 492 1492 1492 1492 184 185 KFAAAA GGLAAA OOOOxx 9622 7599 0 2 2 2 22 622 1622 4622 9622 44 45 CGAAAA HGLAAA VVVVxx 701 7600 1 1 1 1 1 701 701 701 701 2 3 ZAAAAA IGLAAA AAAAxx 2781 7601 1 1 1 1 81 781 781 2781 2781 162 163 ZCAAAA JGLAAA HHHHxx 3982 7602 0 2 2 2 82 982 1982 3982 3982 164 165 EXAAAA KGLAAA OOOOxx 7259 7603 1 3 9 19 59 259 1259 2259 7259 118 119 FTAAAA LGLAAA VVVVxx 9868 7604 0 0 8 8 68 868 1868 4868 9868 136 137 OPAAAA MGLAAA AAAAxx 564 7605 0 0 4 4 64 564 564 564 564 128 129 SVAAAA NGLAAA HHHHxx 6315 7606 1 3 5 15 15 315 315 1315 6315 30 31 XIAAAA OGLAAA OOOOxx 9092 7607 0 0 2 12 92 92 1092 4092 9092 184 185 SLAAAA PGLAAA VVVVxx 8237 7608 1 1 7 17 37 237 237 3237 8237 74 75 VEAAAA QGLAAA AAAAxx 1513 7609 1 1 3 13 13 513 1513 1513 1513 26 27 FGAAAA RGLAAA HHHHxx 1922 7610 0 2 2 2 22 922 1922 1922 1922 44 45 YVAAAA SGLAAA OOOOxx 5396 7611 0 0 6 16 96 396 1396 396 5396 192 193 OZAAAA TGLAAA VVVVxx 2485 7612 1 1 5 5 85 485 485 2485 2485 170 171 PRAAAA UGLAAA AAAAxx 5774 7613 0 2 4 14 74 774 1774 774 5774 148 149 COAAAA VGLAAA HHHHxx 3983 7614 1 3 3 3 83 983 1983 3983 3983 166 167 FXAAAA WGLAAA OOOOxx 221 7615 1 1 1 1 21 221 221 221 221 42 43 NIAAAA XGLAAA VVVVxx 8662 7616 0 2 2 2 62 662 662 3662 8662 124 125 EVAAAA YGLAAA AAAAxx 2456 7617 0 0 6 16 56 456 456 2456 2456 112 113 MQAAAA ZGLAAA HHHHxx 9736 7618 0 0 6 16 36 736 1736 4736 9736 72 73 MKAAAA AHLAAA OOOOxx 8936 7619 0 0 6 16 36 936 936 3936 8936 72 73 SFAAAA BHLAAA VVVVxx 5395 7620 1 3 5 15 95 395 1395 395 5395 190 191 NZAAAA CHLAAA AAAAxx 9523 7621 1 3 3 3 23 523 1523 4523 9523 46 47 HCAAAA DHLAAA HHHHxx 6980 7622 0 0 0 0 80 980 980 1980 6980 160 161 MIAAAA EHLAAA OOOOxx 2091 7623 1 3 1 11 91 91 91 2091 2091 182 183 LCAAAA FHLAAA VVVVxx 6807 7624 1 3 7 7 7 807 807 1807 6807 14 15 VBAAAA GHLAAA AAAAxx 8818 7625 0 2 8 18 18 818 818 3818 8818 36 37 EBAAAA HHLAAA HHHHxx 5298 7626 0 2 8 18 98 298 1298 298 5298 196 197 UVAAAA IHLAAA OOOOxx 1726 7627 0 2 6 6 26 726 1726 1726 1726 52 53 KOAAAA JHLAAA VVVVxx 3878 7628 0 2 8 18 78 878 1878 3878 3878 156 157 ETAAAA KHLAAA AAAAxx 8700 7629 0 0 0 0 0 700 700 3700 8700 0 1 QWAAAA LHLAAA HHHHxx 5201 7630 1 1 1 1 1 201 1201 201 5201 2 3 BSAAAA MHLAAA OOOOxx 3936 7631 0 0 6 16 36 936 1936 3936 3936 72 73 KVAAAA NHLAAA VVVVxx 776 7632 0 0 6 16 76 776 776 776 776 152 153 WDAAAA OHLAAA AAAAxx 5302 7633 0 2 2 2 2 302 1302 302 5302 4 5 YVAAAA PHLAAA HHHHxx 3595 7634 1 3 5 15 95 595 1595 3595 3595 190 191 HIAAAA QHLAAA OOOOxx 9061 7635 1 1 1 1 61 61 1061 4061 9061 122 123 NKAAAA RHLAAA VVVVxx 6261 7636 1 1 1 1 61 261 261 1261 6261 122 123 VGAAAA SHLAAA AAAAxx 8878 7637 0 2 8 18 78 878 878 3878 8878 156 157 MDAAAA THLAAA HHHHxx 3312 7638 0 0 2 12 12 312 1312 3312 3312 24 25 KXAAAA UHLAAA OOOOxx 9422 7639 0 2 2 2 22 422 1422 4422 9422 44 45 KYAAAA VHLAAA VVVVxx 7321 7640 1 1 1 1 21 321 1321 2321 7321 42 43 PVAAAA WHLAAA AAAAxx 3813 7641 1 1 3 13 13 813 1813 3813 3813 26 27 RQAAAA XHLAAA HHHHxx 5848 7642 0 0 8 8 48 848 1848 848 5848 96 97 YQAAAA YHLAAA OOOOxx 3535 7643 1 3 5 15 35 535 1535 3535 3535 70 71 ZFAAAA ZHLAAA VVVVxx 1040 7644 0 0 0 0 40 40 1040 1040 1040 80 81 AOAAAA AILAAA AAAAxx 8572 7645 0 0 2 12 72 572 572 3572 8572 144 145 SRAAAA BILAAA HHHHxx 5435 7646 1 3 5 15 35 435 1435 435 5435 70 71 BBAAAA CILAAA OOOOxx 8199 7647 1 3 9 19 99 199 199 3199 8199 198 199 JDAAAA DILAAA VVVVxx 8775 7648 1 3 5 15 75 775 775 3775 8775 150 151 NZAAAA EILAAA AAAAxx 7722 7649 0 2 2 2 22 722 1722 2722 7722 44 45 ALAAAA FILAAA HHHHxx 3549 7650 1 1 9 9 49 549 1549 3549 3549 98 99 NGAAAA GILAAA OOOOxx 2578 7651 0 2 8 18 78 578 578 2578 2578 156 157 EVAAAA HILAAA VVVVxx 1695 7652 1 3 5 15 95 695 1695 1695 1695 190 191 FNAAAA IILAAA AAAAxx 1902 7653 0 2 2 2 2 902 1902 1902 1902 4 5 EVAAAA JILAAA HHHHxx 6058 7654 0 2 8 18 58 58 58 1058 6058 116 117 AZAAAA KILAAA OOOOxx 6591 7655 1 3 1 11 91 591 591 1591 6591 182 183 NTAAAA LILAAA VVVVxx 7962 7656 0 2 2 2 62 962 1962 2962 7962 124 125 GUAAAA MILAAA AAAAxx 5612 7657 0 0 2 12 12 612 1612 612 5612 24 25 WHAAAA NILAAA HHHHxx 3341 7658 1 1 1 1 41 341 1341 3341 3341 82 83 NYAAAA OILAAA OOOOxx 5460 7659 0 0 0 0 60 460 1460 460 5460 120 121 ACAAAA PILAAA VVVVxx 2368 7660 0 0 8 8 68 368 368 2368 2368 136 137 CNAAAA QILAAA AAAAxx 8646 7661 0 2 6 6 46 646 646 3646 8646 92 93 OUAAAA RILAAA HHHHxx 4987 7662 1 3 7 7 87 987 987 4987 4987 174 175 VJAAAA SILAAA OOOOxx 9018 7663 0 2 8 18 18 18 1018 4018 9018 36 37 WIAAAA TILAAA VVVVxx 8685 7664 1 1 5 5 85 685 685 3685 8685 170 171 BWAAAA UILAAA AAAAxx 694 7665 0 2 4 14 94 694 694 694 694 188 189 SAAAAA VILAAA HHHHxx 2012 7666 0 0 2 12 12 12 12 2012 2012 24 25 KZAAAA WILAAA OOOOxx 2417 7667 1 1 7 17 17 417 417 2417 2417 34 35 ZOAAAA XILAAA VVVVxx 4022 7668 0 2 2 2 22 22 22 4022 4022 44 45 SYAAAA YILAAA AAAAxx 5935 7669 1 3 5 15 35 935 1935 935 5935 70 71 HUAAAA ZILAAA HHHHxx 1656 7670 0 0 6 16 56 656 1656 1656 1656 112 113 SLAAAA AJLAAA OOOOxx 6195 7671 1 3 5 15 95 195 195 1195 6195 190 191 HEAAAA BJLAAA VVVVxx 3057 7672 1 1 7 17 57 57 1057 3057 3057 114 115 PNAAAA CJLAAA AAAAxx 2852 7673 0 0 2 12 52 852 852 2852 2852 104 105 SFAAAA DJLAAA HHHHxx 4634 7674 0 2 4 14 34 634 634 4634 4634 68 69 GWAAAA EJLAAA OOOOxx 1689 7675 1 1 9 9 89 689 1689 1689 1689 178 179 ZMAAAA FJLAAA VVVVxx 4102 7676 0 2 2 2 2 102 102 4102 4102 4 5 UBAAAA GJLAAA AAAAxx 3287 7677 1 3 7 7 87 287 1287 3287 3287 174 175 LWAAAA HJLAAA HHHHxx 5246 7678 0 2 6 6 46 246 1246 246 5246 92 93 UTAAAA IJLAAA OOOOxx 7450 7679 0 2 0 10 50 450 1450 2450 7450 100 101 OAAAAA JJLAAA VVVVxx 6548 7680 0 0 8 8 48 548 548 1548 6548 96 97 WRAAAA KJLAAA AAAAxx 379 7681 1 3 9 19 79 379 379 379 379 158 159 POAAAA LJLAAA HHHHxx 7435 7682 1 3 5 15 35 435 1435 2435 7435 70 71 ZZAAAA MJLAAA OOOOxx 2041 7683 1 1 1 1 41 41 41 2041 2041 82 83 NAAAAA NJLAAA VVVVxx 8462 7684 0 2 2 2 62 462 462 3462 8462 124 125 MNAAAA OJLAAA AAAAxx 9076 7685 0 0 6 16 76 76 1076 4076 9076 152 153 CLAAAA PJLAAA HHHHxx 761 7686 1 1 1 1 61 761 761 761 761 122 123 HDAAAA QJLAAA OOOOxx 795 7687 1 3 5 15 95 795 795 795 795 190 191 PEAAAA RJLAAA VVVVxx 1671 7688 1 3 1 11 71 671 1671 1671 1671 142 143 HMAAAA SJLAAA AAAAxx 695 7689 1 3 5 15 95 695 695 695 695 190 191 TAAAAA TJLAAA HHHHxx 4981 7690 1 1 1 1 81 981 981 4981 4981 162 163 PJAAAA UJLAAA OOOOxx 1211 7691 1 3 1 11 11 211 1211 1211 1211 22 23 PUAAAA VJLAAA VVVVxx 5914 7692 0 2 4 14 14 914 1914 914 5914 28 29 MTAAAA WJLAAA AAAAxx 9356 7693 0 0 6 16 56 356 1356 4356 9356 112 113 WVAAAA XJLAAA HHHHxx 1500 7694 0 0 0 0 0 500 1500 1500 1500 0 1 SFAAAA YJLAAA OOOOxx 3353 7695 1 1 3 13 53 353 1353 3353 3353 106 107 ZYAAAA ZJLAAA VVVVxx 1060 7696 0 0 0 0 60 60 1060 1060 1060 120 121 UOAAAA AKLAAA AAAAxx 7910 7697 0 2 0 10 10 910 1910 2910 7910 20 21 GSAAAA BKLAAA HHHHxx 1329 7698 1 1 9 9 29 329 1329 1329 1329 58 59 DZAAAA CKLAAA OOOOxx 6011 7699 1 3 1 11 11 11 11 1011 6011 22 23 FXAAAA DKLAAA VVVVxx 7146 7700 0 2 6 6 46 146 1146 2146 7146 92 93 WOAAAA EKLAAA AAAAxx 4602 7701 0 2 2 2 2 602 602 4602 4602 4 5 AVAAAA FKLAAA HHHHxx 6751 7702 1 3 1 11 51 751 751 1751 6751 102 103 RZAAAA GKLAAA OOOOxx 2666 7703 0 2 6 6 66 666 666 2666 2666 132 133 OYAAAA HKLAAA VVVVxx 2785 7704 1 1 5 5 85 785 785 2785 2785 170 171 DDAAAA IKLAAA AAAAxx 5851 7705 1 3 1 11 51 851 1851 851 5851 102 103 BRAAAA JKLAAA HHHHxx 2435 7706 1 3 5 15 35 435 435 2435 2435 70 71 RPAAAA KKLAAA OOOOxx 7429 7707 1 1 9 9 29 429 1429 2429 7429 58 59 TZAAAA LKLAAA VVVVxx 4241 7708 1 1 1 1 41 241 241 4241 4241 82 83 DHAAAA MKLAAA AAAAxx 5691 7709 1 3 1 11 91 691 1691 691 5691 182 183 XKAAAA NKLAAA HHHHxx 7731 7710 1 3 1 11 31 731 1731 2731 7731 62 63 JLAAAA OKLAAA OOOOxx 249 7711 1 1 9 9 49 249 249 249 249 98 99 PJAAAA PKLAAA VVVVxx 1731 7712 1 3 1 11 31 731 1731 1731 1731 62 63 POAAAA QKLAAA AAAAxx 8716 7713 0 0 6 16 16 716 716 3716 8716 32 33 GXAAAA RKLAAA HHHHxx 2670 7714 0 2 0 10 70 670 670 2670 2670 140 141 SYAAAA SKLAAA OOOOxx 4654 7715 0 2 4 14 54 654 654 4654 4654 108 109 AXAAAA TKLAAA VVVVxx 1027 7716 1 3 7 7 27 27 1027 1027 1027 54 55 NNAAAA UKLAAA AAAAxx 1099 7717 1 3 9 19 99 99 1099 1099 1099 198 199 HQAAAA VKLAAA HHHHxx 3617 7718 1 1 7 17 17 617 1617 3617 3617 34 35 DJAAAA WKLAAA OOOOxx 4330 7719 0 2 0 10 30 330 330 4330 4330 60 61 OKAAAA XKLAAA VVVVxx 9750 7720 0 2 0 10 50 750 1750 4750 9750 100 101 ALAAAA YKLAAA AAAAxx 467 7721 1 3 7 7 67 467 467 467 467 134 135 ZRAAAA ZKLAAA HHHHxx 8525 7722 1 1 5 5 25 525 525 3525 8525 50 51 XPAAAA ALLAAA OOOOxx 5990 7723 0 2 0 10 90 990 1990 990 5990 180 181 KWAAAA BLLAAA VVVVxx 4839 7724 1 3 9 19 39 839 839 4839 4839 78 79 DEAAAA CLLAAA AAAAxx 9914 7725 0 2 4 14 14 914 1914 4914 9914 28 29 IRAAAA DLLAAA HHHHxx 7047 7726 1 3 7 7 47 47 1047 2047 7047 94 95 BLAAAA ELLAAA OOOOxx 874 7727 0 2 4 14 74 874 874 874 874 148 149 QHAAAA FLLAAA VVVVxx 6061 7728 1 1 1 1 61 61 61 1061 6061 122 123 DZAAAA GLLAAA AAAAxx 5491 7729 1 3 1 11 91 491 1491 491 5491 182 183 FDAAAA HLLAAA HHHHxx 4344 7730 0 0 4 4 44 344 344 4344 4344 88 89 CLAAAA ILLAAA OOOOxx 1281 7731 1 1 1 1 81 281 1281 1281 1281 162 163 HXAAAA JLLAAA VVVVxx 3597 7732 1 1 7 17 97 597 1597 3597 3597 194 195 JIAAAA KLLAAA AAAAxx 4992 7733 0 0 2 12 92 992 992 4992 4992 184 185 AKAAAA LLLAAA HHHHxx 3849 7734 1 1 9 9 49 849 1849 3849 3849 98 99 BSAAAA MLLAAA OOOOxx 2655 7735 1 3 5 15 55 655 655 2655 2655 110 111 DYAAAA NLLAAA VVVVxx 147 7736 1 3 7 7 47 147 147 147 147 94 95 RFAAAA OLLAAA AAAAxx 9110 7737 0 2 0 10 10 110 1110 4110 9110 20 21 KMAAAA PLLAAA HHHHxx 1637 7738 1 1 7 17 37 637 1637 1637 1637 74 75 ZKAAAA QLLAAA OOOOxx 9826 7739 0 2 6 6 26 826 1826 4826 9826 52 53 YNAAAA RLLAAA VVVVxx 5957 7740 1 1 7 17 57 957 1957 957 5957 114 115 DVAAAA SLLAAA AAAAxx 6932 7741 0 0 2 12 32 932 932 1932 6932 64 65 QGAAAA TLLAAA HHHHxx 9684 7742 0 0 4 4 84 684 1684 4684 9684 168 169 MIAAAA ULLAAA OOOOxx 4653 7743 1 1 3 13 53 653 653 4653 4653 106 107 ZWAAAA VLLAAA VVVVxx 8065 7744 1 1 5 5 65 65 65 3065 8065 130 131 FYAAAA WLLAAA AAAAxx 1202 7745 0 2 2 2 2 202 1202 1202 1202 4 5 GUAAAA XLLAAA HHHHxx 9214 7746 0 2 4 14 14 214 1214 4214 9214 28 29 KQAAAA YLLAAA OOOOxx 196 7747 0 0 6 16 96 196 196 196 196 192 193 OHAAAA ZLLAAA VVVVxx 4486 7748 0 2 6 6 86 486 486 4486 4486 172 173 OQAAAA AMLAAA AAAAxx 2585 7749 1 1 5 5 85 585 585 2585 2585 170 171 LVAAAA BMLAAA HHHHxx 2464 7750 0 0 4 4 64 464 464 2464 2464 128 129 UQAAAA CMLAAA OOOOxx 3467 7751 1 3 7 7 67 467 1467 3467 3467 134 135 JDAAAA DMLAAA VVVVxx 9295 7752 1 3 5 15 95 295 1295 4295 9295 190 191 NTAAAA EMLAAA AAAAxx 517 7753 1 1 7 17 17 517 517 517 517 34 35 XTAAAA FMLAAA HHHHxx 6870 7754 0 2 0 10 70 870 870 1870 6870 140 141 GEAAAA GMLAAA OOOOxx 5732 7755 0 0 2 12 32 732 1732 732 5732 64 65 MMAAAA HMLAAA VVVVxx 9376 7756 0 0 6 16 76 376 1376 4376 9376 152 153 QWAAAA IMLAAA AAAAxx 838 7757 0 2 8 18 38 838 838 838 838 76 77 GGAAAA JMLAAA HHHHxx 9254 7758 0 2 4 14 54 254 1254 4254 9254 108 109 YRAAAA KMLAAA OOOOxx 8879 7759 1 3 9 19 79 879 879 3879 8879 158 159 NDAAAA LMLAAA VVVVxx 6281 7760 1 1 1 1 81 281 281 1281 6281 162 163 PHAAAA MMLAAA AAAAxx 8216 7761 0 0 6 16 16 216 216 3216 8216 32 33 AEAAAA NMLAAA HHHHxx 9213 7762 1 1 3 13 13 213 1213 4213 9213 26 27 JQAAAA OMLAAA OOOOxx 7234 7763 0 2 4 14 34 234 1234 2234 7234 68 69 GSAAAA PMLAAA VVVVxx 5692 7764 0 0 2 12 92 692 1692 692 5692 184 185 YKAAAA QMLAAA AAAAxx 693 7765 1 1 3 13 93 693 693 693 693 186 187 RAAAAA RMLAAA HHHHxx 9050 7766 0 2 0 10 50 50 1050 4050 9050 100 101 CKAAAA SMLAAA OOOOxx 3623 7767 1 3 3 3 23 623 1623 3623 3623 46 47 JJAAAA TMLAAA VVVVxx 2130 7768 0 2 0 10 30 130 130 2130 2130 60 61 YDAAAA UMLAAA AAAAxx 2514 7769 0 2 4 14 14 514 514 2514 2514 28 29 SSAAAA VMLAAA HHHHxx 1812 7770 0 0 2 12 12 812 1812 1812 1812 24 25 SRAAAA WMLAAA OOOOxx 9037 7771 1 1 7 17 37 37 1037 4037 9037 74 75 PJAAAA XMLAAA VVVVxx 5054 7772 0 2 4 14 54 54 1054 54 5054 108 109 KMAAAA YMLAAA AAAAxx 7801 7773 1 1 1 1 1 801 1801 2801 7801 2 3 BOAAAA ZMLAAA HHHHxx 7939 7774 1 3 9 19 39 939 1939 2939 7939 78 79 JTAAAA ANLAAA OOOOxx 7374 7775 0 2 4 14 74 374 1374 2374 7374 148 149 QXAAAA BNLAAA VVVVxx 1058 7776 0 2 8 18 58 58 1058 1058 1058 116 117 SOAAAA CNLAAA AAAAxx 1972 7777 0 0 2 12 72 972 1972 1972 1972 144 145 WXAAAA DNLAAA HHHHxx 3741 7778 1 1 1 1 41 741 1741 3741 3741 82 83 XNAAAA ENLAAA OOOOxx 2227 7779 1 3 7 7 27 227 227 2227 2227 54 55 RHAAAA FNLAAA VVVVxx 304 7780 0 0 4 4 4 304 304 304 304 8 9 SLAAAA GNLAAA AAAAxx 4914 7781 0 2 4 14 14 914 914 4914 4914 28 29 AHAAAA HNLAAA HHHHxx 2428 7782 0 0 8 8 28 428 428 2428 2428 56 57 KPAAAA INLAAA OOOOxx 6660 7783 0 0 0 0 60 660 660 1660 6660 120 121 EWAAAA JNLAAA VVVVxx 2676 7784 0 0 6 16 76 676 676 2676 2676 152 153 YYAAAA KNLAAA AAAAxx 2454 7785 0 2 4 14 54 454 454 2454 2454 108 109 KQAAAA LNLAAA HHHHxx 3798 7786 0 2 8 18 98 798 1798 3798 3798 196 197 CQAAAA MNLAAA OOOOxx 1341 7787 1 1 1 1 41 341 1341 1341 1341 82 83 PZAAAA NNLAAA VVVVxx 1611 7788 1 3 1 11 11 611 1611 1611 1611 22 23 ZJAAAA ONLAAA AAAAxx 2681 7789 1 1 1 1 81 681 681 2681 2681 162 163 DZAAAA PNLAAA HHHHxx 7292 7790 0 0 2 12 92 292 1292 2292 7292 184 185 MUAAAA QNLAAA OOOOxx 7775 7791 1 3 5 15 75 775 1775 2775 7775 150 151 BNAAAA RNLAAA VVVVxx 794 7792 0 2 4 14 94 794 794 794 794 188 189 OEAAAA SNLAAA AAAAxx 8709 7793 1 1 9 9 9 709 709 3709 8709 18 19 ZWAAAA TNLAAA HHHHxx 1901 7794 1 1 1 1 1 901 1901 1901 1901 2 3 DVAAAA UNLAAA OOOOxx 3089 7795 1 1 9 9 89 89 1089 3089 3089 178 179 VOAAAA VNLAAA VVVVxx 7797 7796 1 1 7 17 97 797 1797 2797 7797 194 195 XNAAAA WNLAAA AAAAxx 6070 7797 0 2 0 10 70 70 70 1070 6070 140 141 MZAAAA XNLAAA HHHHxx 2191 7798 1 3 1 11 91 191 191 2191 2191 182 183 HGAAAA YNLAAA OOOOxx 3497 7799 1 1 7 17 97 497 1497 3497 3497 194 195 NEAAAA ZNLAAA VVVVxx 8302 7800 0 2 2 2 2 302 302 3302 8302 4 5 IHAAAA AOLAAA AAAAxx 4365 7801 1 1 5 5 65 365 365 4365 4365 130 131 XLAAAA BOLAAA HHHHxx 3588 7802 0 0 8 8 88 588 1588 3588 3588 176 177 AIAAAA COLAAA OOOOxx 8292 7803 0 0 2 12 92 292 292 3292 8292 184 185 YGAAAA DOLAAA VVVVxx 4696 7804 0 0 6 16 96 696 696 4696 4696 192 193 QYAAAA EOLAAA AAAAxx 5641 7805 1 1 1 1 41 641 1641 641 5641 82 83 ZIAAAA FOLAAA HHHHxx 9386 7806 0 2 6 6 86 386 1386 4386 9386 172 173 AXAAAA GOLAAA OOOOxx 507 7807 1 3 7 7 7 507 507 507 507 14 15 NTAAAA HOLAAA VVVVxx 7201 7808 1 1 1 1 1 201 1201 2201 7201 2 3 ZQAAAA IOLAAA AAAAxx 7785 7809 1 1 5 5 85 785 1785 2785 7785 170 171 LNAAAA JOLAAA HHHHxx 463 7810 1 3 3 3 63 463 463 463 463 126 127 VRAAAA KOLAAA OOOOxx 6656 7811 0 0 6 16 56 656 656 1656 6656 112 113 AWAAAA LOLAAA VVVVxx 807 7812 1 3 7 7 7 807 807 807 807 14 15 BFAAAA MOLAAA AAAAxx 7278 7813 0 2 8 18 78 278 1278 2278 7278 156 157 YTAAAA NOLAAA HHHHxx 6237 7814 1 1 7 17 37 237 237 1237 6237 74 75 XFAAAA OOLAAA OOOOxx 7671 7815 1 3 1 11 71 671 1671 2671 7671 142 143 BJAAAA POLAAA VVVVxx 2235 7816 1 3 5 15 35 235 235 2235 2235 70 71 ZHAAAA QOLAAA AAAAxx 4042 7817 0 2 2 2 42 42 42 4042 4042 84 85 MZAAAA ROLAAA HHHHxx 5273 7818 1 1 3 13 73 273 1273 273 5273 146 147 VUAAAA SOLAAA OOOOxx 7557 7819 1 1 7 17 57 557 1557 2557 7557 114 115 REAAAA TOLAAA VVVVxx 4007 7820 1 3 7 7 7 7 7 4007 4007 14 15 DYAAAA UOLAAA AAAAxx 1428 7821 0 0 8 8 28 428 1428 1428 1428 56 57 YCAAAA VOLAAA HHHHxx 9739 7822 1 3 9 19 39 739 1739 4739 9739 78 79 PKAAAA WOLAAA OOOOxx 7836 7823 0 0 6 16 36 836 1836 2836 7836 72 73 KPAAAA XOLAAA VVVVxx 1777 7824 1 1 7 17 77 777 1777 1777 1777 154 155 JQAAAA YOLAAA AAAAxx 5192 7825 0 0 2 12 92 192 1192 192 5192 184 185 SRAAAA ZOLAAA HHHHxx 7236 7826 0 0 6 16 36 236 1236 2236 7236 72 73 ISAAAA APLAAA OOOOxx 1623 7827 1 3 3 3 23 623 1623 1623 1623 46 47 LKAAAA BPLAAA VVVVxx 8288 7828 0 0 8 8 88 288 288 3288 8288 176 177 UGAAAA CPLAAA AAAAxx 2827 7829 1 3 7 7 27 827 827 2827 2827 54 55 TEAAAA DPLAAA HHHHxx 458 7830 0 2 8 18 58 458 458 458 458 116 117 QRAAAA EPLAAA OOOOxx 1818 7831 0 2 8 18 18 818 1818 1818 1818 36 37 YRAAAA FPLAAA VVVVxx 6837 7832 1 1 7 17 37 837 837 1837 6837 74 75 ZCAAAA GPLAAA AAAAxx 7825 7833 1 1 5 5 25 825 1825 2825 7825 50 51 ZOAAAA HPLAAA HHHHxx 9146 7834 0 2 6 6 46 146 1146 4146 9146 92 93 UNAAAA IPLAAA OOOOxx 8451 7835 1 3 1 11 51 451 451 3451 8451 102 103 BNAAAA JPLAAA VVVVxx 6438 7836 0 2 8 18 38 438 438 1438 6438 76 77 QNAAAA KPLAAA AAAAxx 4020 7837 0 0 0 0 20 20 20 4020 4020 40 41 QYAAAA LPLAAA HHHHxx 4068 7838 0 0 8 8 68 68 68 4068 4068 136 137 MAAAAA MPLAAA OOOOxx 2411 7839 1 3 1 11 11 411 411 2411 2411 22 23 TOAAAA NPLAAA VVVVxx 6222 7840 0 2 2 2 22 222 222 1222 6222 44 45 IFAAAA OPLAAA AAAAxx 3164 7841 0 0 4 4 64 164 1164 3164 3164 128 129 SRAAAA PPLAAA HHHHxx 311 7842 1 3 1 11 11 311 311 311 311 22 23 ZLAAAA QPLAAA OOOOxx 5683 7843 1 3 3 3 83 683 1683 683 5683 166 167 PKAAAA RPLAAA VVVVxx 3993 7844 1 1 3 13 93 993 1993 3993 3993 186 187 PXAAAA SPLAAA AAAAxx 9897 7845 1 1 7 17 97 897 1897 4897 9897 194 195 RQAAAA TPLAAA HHHHxx 6609 7846 1 1 9 9 9 609 609 1609 6609 18 19 FUAAAA UPLAAA OOOOxx 1362 7847 0 2 2 2 62 362 1362 1362 1362 124 125 KAAAAA VPLAAA VVVVxx 3918 7848 0 2 8 18 18 918 1918 3918 3918 36 37 SUAAAA WPLAAA AAAAxx 7376 7849 0 0 6 16 76 376 1376 2376 7376 152 153 SXAAAA XPLAAA HHHHxx 6996 7850 0 0 6 16 96 996 996 1996 6996 192 193 CJAAAA YPLAAA OOOOxx 9567 7851 1 3 7 7 67 567 1567 4567 9567 134 135 ZDAAAA ZPLAAA VVVVxx 7525 7852 1 1 5 5 25 525 1525 2525 7525 50 51 LDAAAA AQLAAA AAAAxx 9069 7853 1 1 9 9 69 69 1069 4069 9069 138 139 VKAAAA BQLAAA HHHHxx 9999 7854 1 3 9 19 99 999 1999 4999 9999 198 199 PUAAAA CQLAAA OOOOxx 9237 7855 1 1 7 17 37 237 1237 4237 9237 74 75 HRAAAA DQLAAA VVVVxx 8441 7856 1 1 1 1 41 441 441 3441 8441 82 83 RMAAAA EQLAAA AAAAxx 6769 7857 1 1 9 9 69 769 769 1769 6769 138 139 JAAAAA FQLAAA HHHHxx 6073 7858 1 1 3 13 73 73 73 1073 6073 146 147 PZAAAA GQLAAA OOOOxx 1091 7859 1 3 1 11 91 91 1091 1091 1091 182 183 ZPAAAA HQLAAA VVVVxx 9886 7860 0 2 6 6 86 886 1886 4886 9886 172 173 GQAAAA IQLAAA AAAAxx 3971 7861 1 3 1 11 71 971 1971 3971 3971 142 143 TWAAAA JQLAAA HHHHxx 4621 7862 1 1 1 1 21 621 621 4621 4621 42 43 TVAAAA KQLAAA OOOOxx 3120 7863 0 0 0 0 20 120 1120 3120 3120 40 41 AQAAAA LQLAAA VVVVxx 9773 7864 1 1 3 13 73 773 1773 4773 9773 146 147 XLAAAA MQLAAA AAAAxx 8712 7865 0 0 2 12 12 712 712 3712 8712 24 25 CXAAAA NQLAAA HHHHxx 801 7866 1 1 1 1 1 801 801 801 801 2 3 VEAAAA OQLAAA OOOOxx 9478 7867 0 2 8 18 78 478 1478 4478 9478 156 157 OAAAAA PQLAAA VVVVxx 3466 7868 0 2 6 6 66 466 1466 3466 3466 132 133 IDAAAA QQLAAA AAAAxx 6326 7869 0 2 6 6 26 326 326 1326 6326 52 53 IJAAAA RQLAAA HHHHxx 1723 7870 1 3 3 3 23 723 1723 1723 1723 46 47 HOAAAA SQLAAA OOOOxx 4978 7871 0 2 8 18 78 978 978 4978 4978 156 157 MJAAAA TQLAAA VVVVxx 2311 7872 1 3 1 11 11 311 311 2311 2311 22 23 XKAAAA UQLAAA AAAAxx 9532 7873 0 0 2 12 32 532 1532 4532 9532 64 65 QCAAAA VQLAAA HHHHxx 3680 7874 0 0 0 0 80 680 1680 3680 3680 160 161 OLAAAA WQLAAA OOOOxx 1244 7875 0 0 4 4 44 244 1244 1244 1244 88 89 WVAAAA XQLAAA VVVVxx 3821 7876 1 1 1 1 21 821 1821 3821 3821 42 43 ZQAAAA YQLAAA AAAAxx 9586 7877 0 2 6 6 86 586 1586 4586 9586 172 173 SEAAAA ZQLAAA HHHHxx 3894 7878 0 2 4 14 94 894 1894 3894 3894 188 189 UTAAAA ARLAAA OOOOxx 6169 7879 1 1 9 9 69 169 169 1169 6169 138 139 HDAAAA BRLAAA VVVVxx 5919 7880 1 3 9 19 19 919 1919 919 5919 38 39 RTAAAA CRLAAA AAAAxx 4187 7881 1 3 7 7 87 187 187 4187 4187 174 175 BFAAAA DRLAAA HHHHxx 5477 7882 1 1 7 17 77 477 1477 477 5477 154 155 RCAAAA ERLAAA OOOOxx 2806 7883 0 2 6 6 6 806 806 2806 2806 12 13 YDAAAA FRLAAA VVVVxx 8158 7884 0 2 8 18 58 158 158 3158 8158 116 117 UBAAAA GRLAAA AAAAxx 7130 7885 0 2 0 10 30 130 1130 2130 7130 60 61 GOAAAA HRLAAA HHHHxx 7133 7886 1 1 3 13 33 133 1133 2133 7133 66 67 JOAAAA IRLAAA OOOOxx 6033 7887 1 1 3 13 33 33 33 1033 6033 66 67 BYAAAA JRLAAA VVVVxx 2415 7888 1 3 5 15 15 415 415 2415 2415 30 31 XOAAAA KRLAAA AAAAxx 8091 7889 1 3 1 11 91 91 91 3091 8091 182 183 FZAAAA LRLAAA HHHHxx 8347 7890 1 3 7 7 47 347 347 3347 8347 94 95 BJAAAA MRLAAA OOOOxx 7879 7891 1 3 9 19 79 879 1879 2879 7879 158 159 BRAAAA NRLAAA VVVVxx 9360 7892 0 0 0 0 60 360 1360 4360 9360 120 121 AWAAAA ORLAAA AAAAxx 3369 7893 1 1 9 9 69 369 1369 3369 3369 138 139 PZAAAA PRLAAA HHHHxx 8536 7894 0 0 6 16 36 536 536 3536 8536 72 73 IQAAAA QRLAAA OOOOxx 8628 7895 0 0 8 8 28 628 628 3628 8628 56 57 WTAAAA RRLAAA VVVVxx 1580 7896 0 0 0 0 80 580 1580 1580 1580 160 161 UIAAAA SRLAAA AAAAxx 705 7897 1 1 5 5 5 705 705 705 705 10 11 DBAAAA TRLAAA HHHHxx 4650 7898 0 2 0 10 50 650 650 4650 4650 100 101 WWAAAA URLAAA OOOOxx 9165 7899 1 1 5 5 65 165 1165 4165 9165 130 131 NOAAAA VRLAAA VVVVxx 4820 7900 0 0 0 0 20 820 820 4820 4820 40 41 KDAAAA WRLAAA AAAAxx 3538 7901 0 2 8 18 38 538 1538 3538 3538 76 77 CGAAAA XRLAAA HHHHxx 9947 7902 1 3 7 7 47 947 1947 4947 9947 94 95 PSAAAA YRLAAA OOOOxx 4954 7903 0 2 4 14 54 954 954 4954 4954 108 109 OIAAAA ZRLAAA VVVVxx 1104 7904 0 0 4 4 4 104 1104 1104 1104 8 9 MQAAAA ASLAAA AAAAxx 8455 7905 1 3 5 15 55 455 455 3455 8455 110 111 FNAAAA BSLAAA HHHHxx 8307 7906 1 3 7 7 7 307 307 3307 8307 14 15 NHAAAA CSLAAA OOOOxx 9203 7907 1 3 3 3 3 203 1203 4203 9203 6 7 ZPAAAA DSLAAA VVVVxx 7565 7908 1 1 5 5 65 565 1565 2565 7565 130 131 ZEAAAA ESLAAA AAAAxx 7745 7909 1 1 5 5 45 745 1745 2745 7745 90 91 XLAAAA FSLAAA HHHHxx 1787 7910 1 3 7 7 87 787 1787 1787 1787 174 175 TQAAAA GSLAAA OOOOxx 4861 7911 1 1 1 1 61 861 861 4861 4861 122 123 ZEAAAA HSLAAA VVVVxx 5183 7912 1 3 3 3 83 183 1183 183 5183 166 167 JRAAAA ISLAAA AAAAxx 529 7913 1 1 9 9 29 529 529 529 529 58 59 JUAAAA JSLAAA HHHHxx 2470 7914 0 2 0 10 70 470 470 2470 2470 140 141 ARAAAA KSLAAA OOOOxx 1267 7915 1 3 7 7 67 267 1267 1267 1267 134 135 TWAAAA LSLAAA VVVVxx 2059 7916 1 3 9 19 59 59 59 2059 2059 118 119 FBAAAA MSLAAA AAAAxx 1862 7917 0 2 2 2 62 862 1862 1862 1862 124 125 QTAAAA NSLAAA HHHHxx 7382 7918 0 2 2 2 82 382 1382 2382 7382 164 165 YXAAAA OSLAAA OOOOxx 4796 7919 0 0 6 16 96 796 796 4796 4796 192 193 MCAAAA PSLAAA VVVVxx 2331 7920 1 3 1 11 31 331 331 2331 2331 62 63 RLAAAA QSLAAA AAAAxx 8870 7921 0 2 0 10 70 870 870 3870 8870 140 141 EDAAAA RSLAAA HHHHxx 9581 7922 1 1 1 1 81 581 1581 4581 9581 162 163 NEAAAA SSLAAA OOOOxx 9063 7923 1 3 3 3 63 63 1063 4063 9063 126 127 PKAAAA TSLAAA VVVVxx 2192 7924 0 0 2 12 92 192 192 2192 2192 184 185 IGAAAA USLAAA AAAAxx 6466 7925 0 2 6 6 66 466 466 1466 6466 132 133 SOAAAA VSLAAA HHHHxx 7096 7926 0 0 6 16 96 96 1096 2096 7096 192 193 YMAAAA WSLAAA OOOOxx 6257 7927 1 1 7 17 57 257 257 1257 6257 114 115 RGAAAA XSLAAA VVVVxx 7009 7928 1 1 9 9 9 9 1009 2009 7009 18 19 PJAAAA YSLAAA AAAAxx 8136 7929 0 0 6 16 36 136 136 3136 8136 72 73 YAAAAA ZSLAAA HHHHxx 1854 7930 0 2 4 14 54 854 1854 1854 1854 108 109 ITAAAA ATLAAA OOOOxx 3644 7931 0 0 4 4 44 644 1644 3644 3644 88 89 EKAAAA BTLAAA VVVVxx 4437 7932 1 1 7 17 37 437 437 4437 4437 74 75 ROAAAA CTLAAA AAAAxx 7209 7933 1 1 9 9 9 209 1209 2209 7209 18 19 HRAAAA DTLAAA HHHHxx 1516 7934 0 0 6 16 16 516 1516 1516 1516 32 33 IGAAAA ETLAAA OOOOxx 822 7935 0 2 2 2 22 822 822 822 822 44 45 QFAAAA FTLAAA VVVVxx 1778 7936 0 2 8 18 78 778 1778 1778 1778 156 157 KQAAAA GTLAAA AAAAxx 8161 7937 1 1 1 1 61 161 161 3161 8161 122 123 XBAAAA HTLAAA HHHHxx 6030 7938 0 2 0 10 30 30 30 1030 6030 60 61 YXAAAA ITLAAA OOOOxx 3515 7939 1 3 5 15 15 515 1515 3515 3515 30 31 FFAAAA JTLAAA VVVVxx 1702 7940 0 2 2 2 2 702 1702 1702 1702 4 5 MNAAAA KTLAAA AAAAxx 2671 7941 1 3 1 11 71 671 671 2671 2671 142 143 TYAAAA LTLAAA HHHHxx 7623 7942 1 3 3 3 23 623 1623 2623 7623 46 47 FHAAAA MTLAAA OOOOxx 9828 7943 0 0 8 8 28 828 1828 4828 9828 56 57 AOAAAA NTLAAA VVVVxx 1888 7944 0 0 8 8 88 888 1888 1888 1888 176 177 QUAAAA OTLAAA AAAAxx 4520 7945 0 0 0 0 20 520 520 4520 4520 40 41 WRAAAA PTLAAA HHHHxx 3461 7946 1 1 1 1 61 461 1461 3461 3461 122 123 DDAAAA QTLAAA OOOOxx 1488 7947 0 0 8 8 88 488 1488 1488 1488 176 177 GFAAAA RTLAAA VVVVxx 7753 7948 1 1 3 13 53 753 1753 2753 7753 106 107 FMAAAA STLAAA AAAAxx 5525 7949 1 1 5 5 25 525 1525 525 5525 50 51 NEAAAA TTLAAA HHHHxx 5220 7950 0 0 0 0 20 220 1220 220 5220 40 41 USAAAA UTLAAA OOOOxx 305 7951 1 1 5 5 5 305 305 305 305 10 11 TLAAAA VTLAAA VVVVxx 7883 7952 1 3 3 3 83 883 1883 2883 7883 166 167 FRAAAA WTLAAA AAAAxx 1222 7953 0 2 2 2 22 222 1222 1222 1222 44 45 AVAAAA XTLAAA HHHHxx 8552 7954 0 0 2 12 52 552 552 3552 8552 104 105 YQAAAA YTLAAA OOOOxx 6097 7955 1 1 7 17 97 97 97 1097 6097 194 195 NAAAAA ZTLAAA VVVVxx 2298 7956 0 2 8 18 98 298 298 2298 2298 196 197 KKAAAA AULAAA AAAAxx 956 7957 0 0 6 16 56 956 956 956 956 112 113 UKAAAA BULAAA HHHHxx 9351 7958 1 3 1 11 51 351 1351 4351 9351 102 103 RVAAAA CULAAA OOOOxx 6669 7959 1 1 9 9 69 669 669 1669 6669 138 139 NWAAAA DULAAA VVVVxx 9383 7960 1 3 3 3 83 383 1383 4383 9383 166 167 XWAAAA EULAAA AAAAxx 1607 7961 1 3 7 7 7 607 1607 1607 1607 14 15 VJAAAA FULAAA HHHHxx 812 7962 0 0 2 12 12 812 812 812 812 24 25 GFAAAA GULAAA OOOOxx 2109 7963 1 1 9 9 9 109 109 2109 2109 18 19 DDAAAA HULAAA VVVVxx 207 7964 1 3 7 7 7 207 207 207 207 14 15 ZHAAAA IULAAA AAAAxx 7124 7965 0 0 4 4 24 124 1124 2124 7124 48 49 AOAAAA JULAAA HHHHxx 9333 7966 1 1 3 13 33 333 1333 4333 9333 66 67 ZUAAAA KULAAA OOOOxx 3262 7967 0 2 2 2 62 262 1262 3262 3262 124 125 MVAAAA LULAAA VVVVxx 1070 7968 0 2 0 10 70 70 1070 1070 1070 140 141 EPAAAA MULAAA AAAAxx 7579 7969 1 3 9 19 79 579 1579 2579 7579 158 159 NFAAAA NULAAA HHHHxx 9283 7970 1 3 3 3 83 283 1283 4283 9283 166 167 BTAAAA OULAAA OOOOxx 4917 7971 1 1 7 17 17 917 917 4917 4917 34 35 DHAAAA PULAAA VVVVxx 1328 7972 0 0 8 8 28 328 1328 1328 1328 56 57 CZAAAA QULAAA AAAAxx 3042 7973 0 2 2 2 42 42 1042 3042 3042 84 85 ANAAAA RULAAA HHHHxx 8352 7974 0 0 2 12 52 352 352 3352 8352 104 105 GJAAAA SULAAA OOOOxx 2710 7975 0 2 0 10 10 710 710 2710 2710 20 21 GAAAAA TULAAA VVVVxx 3330 7976 0 2 0 10 30 330 1330 3330 3330 60 61 CYAAAA UULAAA AAAAxx 2822 7977 0 2 2 2 22 822 822 2822 2822 44 45 OEAAAA VULAAA HHHHxx 5627 7978 1 3 7 7 27 627 1627 627 5627 54 55 LIAAAA WULAAA OOOOxx 7848 7979 0 0 8 8 48 848 1848 2848 7848 96 97 WPAAAA XULAAA VVVVxx 7384 7980 0 0 4 4 84 384 1384 2384 7384 168 169 AYAAAA YULAAA AAAAxx 727 7981 1 3 7 7 27 727 727 727 727 54 55 ZBAAAA ZULAAA HHHHxx 9926 7982 0 2 6 6 26 926 1926 4926 9926 52 53 URAAAA AVLAAA OOOOxx 2647 7983 1 3 7 7 47 647 647 2647 2647 94 95 VXAAAA BVLAAA VVVVxx 6416 7984 0 0 6 16 16 416 416 1416 6416 32 33 UMAAAA CVLAAA AAAAxx 8751 7985 1 3 1 11 51 751 751 3751 8751 102 103 PYAAAA DVLAAA HHHHxx 6515 7986 1 3 5 15 15 515 515 1515 6515 30 31 PQAAAA EVLAAA OOOOxx 2472 7987 0 0 2 12 72 472 472 2472 2472 144 145 CRAAAA FVLAAA VVVVxx 7205 7988 1 1 5 5 5 205 1205 2205 7205 10 11 DRAAAA GVLAAA AAAAxx 9654 7989 0 2 4 14 54 654 1654 4654 9654 108 109 IHAAAA HVLAAA HHHHxx 5646 7990 0 2 6 6 46 646 1646 646 5646 92 93 EJAAAA IVLAAA OOOOxx 4217 7991 1 1 7 17 17 217 217 4217 4217 34 35 FGAAAA JVLAAA VVVVxx 4484 7992 0 0 4 4 84 484 484 4484 4484 168 169 MQAAAA KVLAAA AAAAxx 6654 7993 0 2 4 14 54 654 654 1654 6654 108 109 YVAAAA LVLAAA HHHHxx 4876 7994 0 0 6 16 76 876 876 4876 4876 152 153 OFAAAA MVLAAA OOOOxx 9690 7995 0 2 0 10 90 690 1690 4690 9690 180 181 SIAAAA NVLAAA VVVVxx 2453 7996 1 1 3 13 53 453 453 2453 2453 106 107 JQAAAA OVLAAA AAAAxx 829 7997 1 1 9 9 29 829 829 829 829 58 59 XFAAAA PVLAAA HHHHxx 2547 7998 1 3 7 7 47 547 547 2547 2547 94 95 ZTAAAA QVLAAA OOOOxx 9726 7999 0 2 6 6 26 726 1726 4726 9726 52 53 CKAAAA RVLAAA VVVVxx 9267 8000 1 3 7 7 67 267 1267 4267 9267 134 135 LSAAAA SVLAAA AAAAxx 7448 8001 0 0 8 8 48 448 1448 2448 7448 96 97 MAAAAA TVLAAA HHHHxx 610 8002 0 2 0 10 10 610 610 610 610 20 21 MXAAAA UVLAAA OOOOxx 2791 8003 1 3 1 11 91 791 791 2791 2791 182 183 JDAAAA VVLAAA VVVVxx 3651 8004 1 3 1 11 51 651 1651 3651 3651 102 103 LKAAAA WVLAAA AAAAxx 5206 8005 0 2 6 6 6 206 1206 206 5206 12 13 GSAAAA XVLAAA HHHHxx 8774 8006 0 2 4 14 74 774 774 3774 8774 148 149 MZAAAA YVLAAA OOOOxx 4753 8007 1 1 3 13 53 753 753 4753 4753 106 107 VAAAAA ZVLAAA VVVVxx 4755 8008 1 3 5 15 55 755 755 4755 4755 110 111 XAAAAA AWLAAA AAAAxx 686 8009 0 2 6 6 86 686 686 686 686 172 173 KAAAAA BWLAAA HHHHxx 8281 8010 1 1 1 1 81 281 281 3281 8281 162 163 NGAAAA CWLAAA OOOOxx 2058 8011 0 2 8 18 58 58 58 2058 2058 116 117 EBAAAA DWLAAA VVVVxx 8900 8012 0 0 0 0 0 900 900 3900 8900 0 1 IEAAAA EWLAAA AAAAxx 8588 8013 0 0 8 8 88 588 588 3588 8588 176 177 ISAAAA FWLAAA HHHHxx 2904 8014 0 0 4 4 4 904 904 2904 2904 8 9 SHAAAA GWLAAA OOOOxx 8917 8015 1 1 7 17 17 917 917 3917 8917 34 35 ZEAAAA HWLAAA VVVVxx 9026 8016 0 2 6 6 26 26 1026 4026 9026 52 53 EJAAAA IWLAAA AAAAxx 2416 8017 0 0 6 16 16 416 416 2416 2416 32 33 YOAAAA JWLAAA HHHHxx 1053 8018 1 1 3 13 53 53 1053 1053 1053 106 107 NOAAAA KWLAAA OOOOxx 7141 8019 1 1 1 1 41 141 1141 2141 7141 82 83 ROAAAA LWLAAA VVVVxx 9771 8020 1 3 1 11 71 771 1771 4771 9771 142 143 VLAAAA MWLAAA AAAAxx 2774 8021 0 2 4 14 74 774 774 2774 2774 148 149 SCAAAA NWLAAA HHHHxx 3213 8022 1 1 3 13 13 213 1213 3213 3213 26 27 PTAAAA OWLAAA OOOOxx 5694 8023 0 2 4 14 94 694 1694 694 5694 188 189 ALAAAA PWLAAA VVVVxx 6631 8024 1 3 1 11 31 631 631 1631 6631 62 63 BVAAAA QWLAAA AAAAxx 6638 8025 0 2 8 18 38 638 638 1638 6638 76 77 IVAAAA RWLAAA HHHHxx 7407 8026 1 3 7 7 7 407 1407 2407 7407 14 15 XYAAAA SWLAAA OOOOxx 8972 8027 0 0 2 12 72 972 972 3972 8972 144 145 CHAAAA TWLAAA VVVVxx 2202 8028 0 2 2 2 2 202 202 2202 2202 4 5 SGAAAA UWLAAA AAAAxx 6135 8029 1 3 5 15 35 135 135 1135 6135 70 71 ZBAAAA VWLAAA HHHHxx 5043 8030 1 3 3 3 43 43 1043 43 5043 86 87 ZLAAAA WWLAAA OOOOxx 5163 8031 1 3 3 3 63 163 1163 163 5163 126 127 PQAAAA XWLAAA VVVVxx 1191 8032 1 3 1 11 91 191 1191 1191 1191 182 183 VTAAAA YWLAAA AAAAxx 6576 8033 0 0 6 16 76 576 576 1576 6576 152 153 YSAAAA ZWLAAA HHHHxx 3455 8034 1 3 5 15 55 455 1455 3455 3455 110 111 XCAAAA AXLAAA OOOOxx 3688 8035 0 0 8 8 88 688 1688 3688 3688 176 177 WLAAAA BXLAAA VVVVxx 4982 8036 0 2 2 2 82 982 982 4982 4982 164 165 QJAAAA CXLAAA AAAAxx 4180 8037 0 0 0 0 80 180 180 4180 4180 160 161 UEAAAA DXLAAA HHHHxx 4708 8038 0 0 8 8 8 708 708 4708 4708 16 17 CZAAAA EXLAAA OOOOxx 1241 8039 1 1 1 1 41 241 1241 1241 1241 82 83 TVAAAA FXLAAA VVVVxx 4921 8040 1 1 1 1 21 921 921 4921 4921 42 43 HHAAAA GXLAAA AAAAxx 3197 8041 1 1 7 17 97 197 1197 3197 3197 194 195 ZSAAAA HXLAAA HHHHxx 8225 8042 1 1 5 5 25 225 225 3225 8225 50 51 JEAAAA IXLAAA OOOOxx 5913 8043 1 1 3 13 13 913 1913 913 5913 26 27 LTAAAA JXLAAA VVVVxx 6387 8044 1 3 7 7 87 387 387 1387 6387 174 175 RLAAAA KXLAAA AAAAxx 2706 8045 0 2 6 6 6 706 706 2706 2706 12 13 CAAAAA LXLAAA HHHHxx 1461 8046 1 1 1 1 61 461 1461 1461 1461 122 123 FEAAAA MXLAAA OOOOxx 7646 8047 0 2 6 6 46 646 1646 2646 7646 92 93 CIAAAA NXLAAA VVVVxx 8066 8048 0 2 6 6 66 66 66 3066 8066 132 133 GYAAAA OXLAAA AAAAxx 4171 8049 1 3 1 11 71 171 171 4171 4171 142 143 LEAAAA PXLAAA HHHHxx 8008 8050 0 0 8 8 8 8 8 3008 8008 16 17 AWAAAA QXLAAA OOOOxx 2088 8051 0 0 8 8 88 88 88 2088 2088 176 177 ICAAAA RXLAAA VVVVxx 7907 8052 1 3 7 7 7 907 1907 2907 7907 14 15 DSAAAA SXLAAA AAAAxx 2429 8053 1 1 9 9 29 429 429 2429 2429 58 59 LPAAAA TXLAAA HHHHxx 9629 8054 1 1 9 9 29 629 1629 4629 9629 58 59 JGAAAA UXLAAA OOOOxx 1470 8055 0 2 0 10 70 470 1470 1470 1470 140 141 OEAAAA VXLAAA VVVVxx 4346 8056 0 2 6 6 46 346 346 4346 4346 92 93 ELAAAA WXLAAA AAAAxx 7219 8057 1 3 9 19 19 219 1219 2219 7219 38 39 RRAAAA XXLAAA HHHHxx 1185 8058 1 1 5 5 85 185 1185 1185 1185 170 171 PTAAAA YXLAAA OOOOxx 8776 8059 0 0 6 16 76 776 776 3776 8776 152 153 OZAAAA ZXLAAA VVVVxx 684 8060 0 0 4 4 84 684 684 684 684 168 169 IAAAAA AYLAAA AAAAxx 2343 8061 1 3 3 3 43 343 343 2343 2343 86 87 DMAAAA BYLAAA HHHHxx 4470 8062 0 2 0 10 70 470 470 4470 4470 140 141 YPAAAA CYLAAA OOOOxx 5116 8063 0 0 6 16 16 116 1116 116 5116 32 33 UOAAAA DYLAAA VVVVxx 1746 8064 0 2 6 6 46 746 1746 1746 1746 92 93 EPAAAA EYLAAA AAAAxx 3216 8065 0 0 6 16 16 216 1216 3216 3216 32 33 STAAAA FYLAAA HHHHxx 4594 8066 0 2 4 14 94 594 594 4594 4594 188 189 SUAAAA GYLAAA OOOOxx 3013 8067 1 1 3 13 13 13 1013 3013 3013 26 27 XLAAAA HYLAAA VVVVxx 2307 8068 1 3 7 7 7 307 307 2307 2307 14 15 TKAAAA IYLAAA AAAAxx 7663 8069 1 3 3 3 63 663 1663 2663 7663 126 127 TIAAAA JYLAAA HHHHxx 8504 8070 0 0 4 4 4 504 504 3504 8504 8 9 CPAAAA KYLAAA OOOOxx 3683 8071 1 3 3 3 83 683 1683 3683 3683 166 167 RLAAAA LYLAAA VVVVxx 144 8072 0 0 4 4 44 144 144 144 144 88 89 OFAAAA MYLAAA AAAAxx 203 8073 1 3 3 3 3 203 203 203 203 6 7 VHAAAA NYLAAA HHHHxx 5255 8074 1 3 5 15 55 255 1255 255 5255 110 111 DUAAAA OYLAAA OOOOxx 4150 8075 0 2 0 10 50 150 150 4150 4150 100 101 QDAAAA PYLAAA VVVVxx 5701 8076 1 1 1 1 1 701 1701 701 5701 2 3 HLAAAA QYLAAA AAAAxx 7400 8077 0 0 0 0 0 400 1400 2400 7400 0 1 QYAAAA RYLAAA HHHHxx 8203 8078 1 3 3 3 3 203 203 3203 8203 6 7 NDAAAA SYLAAA OOOOxx 637 8079 1 1 7 17 37 637 637 637 637 74 75 NYAAAA TYLAAA VVVVxx 2898 8080 0 2 8 18 98 898 898 2898 2898 196 197 MHAAAA UYLAAA AAAAxx 1110 8081 0 2 0 10 10 110 1110 1110 1110 20 21 SQAAAA VYLAAA HHHHxx 6255 8082 1 3 5 15 55 255 255 1255 6255 110 111 PGAAAA WYLAAA OOOOxx 1071 8083 1 3 1 11 71 71 1071 1071 1071 142 143 FPAAAA XYLAAA VVVVxx 541 8084 1 1 1 1 41 541 541 541 541 82 83 VUAAAA YYLAAA AAAAxx 8077 8085 1 1 7 17 77 77 77 3077 8077 154 155 RYAAAA ZYLAAA HHHHxx 6809 8086 1 1 9 9 9 809 809 1809 6809 18 19 XBAAAA AZLAAA OOOOxx 4749 8087 1 1 9 9 49 749 749 4749 4749 98 99 RAAAAA BZLAAA VVVVxx 2886 8088 0 2 6 6 86 886 886 2886 2886 172 173 AHAAAA CZLAAA AAAAxx 5510 8089 0 2 0 10 10 510 1510 510 5510 20 21 YDAAAA DZLAAA HHHHxx 713 8090 1 1 3 13 13 713 713 713 713 26 27 LBAAAA EZLAAA OOOOxx 8388 8091 0 0 8 8 88 388 388 3388 8388 176 177 QKAAAA FZLAAA VVVVxx 9524 8092 0 0 4 4 24 524 1524 4524 9524 48 49 ICAAAA GZLAAA AAAAxx 9949 8093 1 1 9 9 49 949 1949 4949 9949 98 99 RSAAAA HZLAAA HHHHxx 885 8094 1 1 5 5 85 885 885 885 885 170 171 BIAAAA IZLAAA OOOOxx 8699 8095 1 3 9 19 99 699 699 3699 8699 198 199 PWAAAA JZLAAA VVVVxx 2232 8096 0 0 2 12 32 232 232 2232 2232 64 65 WHAAAA KZLAAA AAAAxx 5142 8097 0 2 2 2 42 142 1142 142 5142 84 85 UPAAAA LZLAAA HHHHxx 8891 8098 1 3 1 11 91 891 891 3891 8891 182 183 ZDAAAA MZLAAA OOOOxx 1881 8099 1 1 1 1 81 881 1881 1881 1881 162 163 JUAAAA NZLAAA VVVVxx 3751 8100 1 3 1 11 51 751 1751 3751 3751 102 103 HOAAAA OZLAAA AAAAxx 1896 8101 0 0 6 16 96 896 1896 1896 1896 192 193 YUAAAA PZLAAA HHHHxx 8258 8102 0 2 8 18 58 258 258 3258 8258 116 117 QFAAAA QZLAAA OOOOxx 3820 8103 0 0 0 0 20 820 1820 3820 3820 40 41 YQAAAA RZLAAA VVVVxx 6617 8104 1 1 7 17 17 617 617 1617 6617 34 35 NUAAAA SZLAAA AAAAxx 5100 8105 0 0 0 0 0 100 1100 100 5100 0 1 EOAAAA TZLAAA HHHHxx 4277 8106 1 1 7 17 77 277 277 4277 4277 154 155 NIAAAA UZLAAA OOOOxx 2498 8107 0 2 8 18 98 498 498 2498 2498 196 197 CSAAAA VZLAAA VVVVxx 4343 8108 1 3 3 3 43 343 343 4343 4343 86 87 BLAAAA WZLAAA AAAAxx 8319 8109 1 3 9 19 19 319 319 3319 8319 38 39 ZHAAAA XZLAAA HHHHxx 4803 8110 1 3 3 3 3 803 803 4803 4803 6 7 TCAAAA YZLAAA OOOOxx 3100 8111 0 0 0 0 0 100 1100 3100 3100 0 1 GPAAAA ZZLAAA VVVVxx 428 8112 0 0 8 8 28 428 428 428 428 56 57 MQAAAA AAMAAA AAAAxx 2811 8113 1 3 1 11 11 811 811 2811 2811 22 23 DEAAAA BAMAAA HHHHxx 2989 8114 1 1 9 9 89 989 989 2989 2989 178 179 ZKAAAA CAMAAA OOOOxx 1100 8115 0 0 0 0 0 100 1100 1100 1100 0 1 IQAAAA DAMAAA VVVVxx 6586 8116 0 2 6 6 86 586 586 1586 6586 172 173 ITAAAA EAMAAA AAAAxx 3124 8117 0 0 4 4 24 124 1124 3124 3124 48 49 EQAAAA FAMAAA HHHHxx 1635 8118 1 3 5 15 35 635 1635 1635 1635 70 71 XKAAAA GAMAAA OOOOxx 3888 8119 0 0 8 8 88 888 1888 3888 3888 176 177 OTAAAA HAMAAA VVVVxx 8369 8120 1 1 9 9 69 369 369 3369 8369 138 139 XJAAAA IAMAAA AAAAxx 3148 8121 0 0 8 8 48 148 1148 3148 3148 96 97 CRAAAA JAMAAA HHHHxx 2842 8122 0 2 2 2 42 842 842 2842 2842 84 85 IFAAAA KAMAAA OOOOxx 4965 8123 1 1 5 5 65 965 965 4965 4965 130 131 ZIAAAA LAMAAA VVVVxx 3742 8124 0 2 2 2 42 742 1742 3742 3742 84 85 YNAAAA MAMAAA AAAAxx 5196 8125 0 0 6 16 96 196 1196 196 5196 192 193 WRAAAA NAMAAA HHHHxx 9105 8126 1 1 5 5 5 105 1105 4105 9105 10 11 FMAAAA OAMAAA OOOOxx 6806 8127 0 2 6 6 6 806 806 1806 6806 12 13 UBAAAA PAMAAA VVVVxx 5849 8128 1 1 9 9 49 849 1849 849 5849 98 99 ZQAAAA QAMAAA AAAAxx 6504 8129 0 0 4 4 4 504 504 1504 6504 8 9 EQAAAA RAMAAA HHHHxx 9841 8130 1 1 1 1 41 841 1841 4841 9841 82 83 NOAAAA SAMAAA OOOOxx 457 8131 1 1 7 17 57 457 457 457 457 114 115 PRAAAA TAMAAA VVVVxx 8856 8132 0 0 6 16 56 856 856 3856 8856 112 113 QCAAAA UAMAAA AAAAxx 8043 8133 1 3 3 3 43 43 43 3043 8043 86 87 JXAAAA VAMAAA HHHHxx 5933 8134 1 1 3 13 33 933 1933 933 5933 66 67 FUAAAA WAMAAA OOOOxx 5725 8135 1 1 5 5 25 725 1725 725 5725 50 51 FMAAAA XAMAAA VVVVxx 8607 8136 1 3 7 7 7 607 607 3607 8607 14 15 BTAAAA YAMAAA AAAAxx 9280 8137 0 0 0 0 80 280 1280 4280 9280 160 161 YSAAAA ZAMAAA HHHHxx 6017 8138 1 1 7 17 17 17 17 1017 6017 34 35 LXAAAA ABMAAA OOOOxx 4946 8139 0 2 6 6 46 946 946 4946 4946 92 93 GIAAAA BBMAAA VVVVxx 7373 8140 1 1 3 13 73 373 1373 2373 7373 146 147 PXAAAA CBMAAA AAAAxx 8096 8141 0 0 6 16 96 96 96 3096 8096 192 193 KZAAAA DBMAAA HHHHxx 3178 8142 0 2 8 18 78 178 1178 3178 3178 156 157 GSAAAA EBMAAA OOOOxx 1849 8143 1 1 9 9 49 849 1849 1849 1849 98 99 DTAAAA FBMAAA VVVVxx 8813 8144 1 1 3 13 13 813 813 3813 8813 26 27 ZAAAAA GBMAAA AAAAxx 460 8145 0 0 0 0 60 460 460 460 460 120 121 SRAAAA HBMAAA HHHHxx 7756 8146 0 0 6 16 56 756 1756 2756 7756 112 113 IMAAAA IBMAAA OOOOxx 4425 8147 1 1 5 5 25 425 425 4425 4425 50 51 FOAAAA JBMAAA VVVVxx 1602 8148 0 2 2 2 2 602 1602 1602 1602 4 5 QJAAAA KBMAAA AAAAxx 5981 8149 1 1 1 1 81 981 1981 981 5981 162 163 BWAAAA LBMAAA HHHHxx 8139 8150 1 3 9 19 39 139 139 3139 8139 78 79 BBAAAA MBMAAA OOOOxx 754 8151 0 2 4 14 54 754 754 754 754 108 109 ADAAAA NBMAAA VVVVxx 26 8152 0 2 6 6 26 26 26 26 26 52 53 ABAAAA OBMAAA AAAAxx 106 8153 0 2 6 6 6 106 106 106 106 12 13 CEAAAA PBMAAA HHHHxx 7465 8154 1 1 5 5 65 465 1465 2465 7465 130 131 DBAAAA QBMAAA OOOOxx 1048 8155 0 0 8 8 48 48 1048 1048 1048 96 97 IOAAAA RBMAAA VVVVxx 2303 8156 1 3 3 3 3 303 303 2303 2303 6 7 PKAAAA SBMAAA AAAAxx 5794 8157 0 2 4 14 94 794 1794 794 5794 188 189 WOAAAA TBMAAA HHHHxx 3321 8158 1 1 1 1 21 321 1321 3321 3321 42 43 TXAAAA UBMAAA OOOOxx 6122 8159 0 2 2 2 22 122 122 1122 6122 44 45 MBAAAA VBMAAA VVVVxx 6474 8160 0 2 4 14 74 474 474 1474 6474 148 149 APAAAA WBMAAA AAAAxx 827 8161 1 3 7 7 27 827 827 827 827 54 55 VFAAAA XBMAAA HHHHxx 6616 8162 0 0 6 16 16 616 616 1616 6616 32 33 MUAAAA YBMAAA OOOOxx 2131 8163 1 3 1 11 31 131 131 2131 2131 62 63 ZDAAAA ZBMAAA VVVVxx 5483 8164 1 3 3 3 83 483 1483 483 5483 166 167 XCAAAA ACMAAA AAAAxx 606 8165 0 2 6 6 6 606 606 606 606 12 13 IXAAAA BCMAAA HHHHxx 922 8166 0 2 2 2 22 922 922 922 922 44 45 MJAAAA CCMAAA OOOOxx 8475 8167 1 3 5 15 75 475 475 3475 8475 150 151 ZNAAAA DCMAAA VVVVxx 7645 8168 1 1 5 5 45 645 1645 2645 7645 90 91 BIAAAA ECMAAA AAAAxx 5097 8169 1 1 7 17 97 97 1097 97 5097 194 195 BOAAAA FCMAAA HHHHxx 5377 8170 1 1 7 17 77 377 1377 377 5377 154 155 VYAAAA GCMAAA OOOOxx 6116 8171 0 0 6 16 16 116 116 1116 6116 32 33 GBAAAA HCMAAA VVVVxx 8674 8172 0 2 4 14 74 674 674 3674 8674 148 149 QVAAAA ICMAAA AAAAxx 8063 8173 1 3 3 3 63 63 63 3063 8063 126 127 DYAAAA JCMAAA HHHHxx 5271 8174 1 3 1 11 71 271 1271 271 5271 142 143 TUAAAA KCMAAA OOOOxx 1619 8175 1 3 9 19 19 619 1619 1619 1619 38 39 HKAAAA LCMAAA VVVVxx 6419 8176 1 3 9 19 19 419 419 1419 6419 38 39 XMAAAA MCMAAA AAAAxx 7651 8177 1 3 1 11 51 651 1651 2651 7651 102 103 HIAAAA NCMAAA HHHHxx 2897 8178 1 1 7 17 97 897 897 2897 2897 194 195 LHAAAA OCMAAA OOOOxx 8148 8179 0 0 8 8 48 148 148 3148 8148 96 97 KBAAAA PCMAAA VVVVxx 7461 8180 1 1 1 1 61 461 1461 2461 7461 122 123 ZAAAAA QCMAAA AAAAxx 9186 8181 0 2 6 6 86 186 1186 4186 9186 172 173 IPAAAA RCMAAA HHHHxx 7127 8182 1 3 7 7 27 127 1127 2127 7127 54 55 DOAAAA SCMAAA OOOOxx 8233 8183 1 1 3 13 33 233 233 3233 8233 66 67 REAAAA TCMAAA VVVVxx 9651 8184 1 3 1 11 51 651 1651 4651 9651 102 103 FHAAAA UCMAAA AAAAxx 6746 8185 0 2 6 6 46 746 746 1746 6746 92 93 MZAAAA VCMAAA HHHHxx 7835 8186 1 3 5 15 35 835 1835 2835 7835 70 71 JPAAAA WCMAAA OOOOxx 8815 8187 1 3 5 15 15 815 815 3815 8815 30 31 BBAAAA XCMAAA VVVVxx 6398 8188 0 2 8 18 98 398 398 1398 6398 196 197 CMAAAA YCMAAA AAAAxx 5344 8189 0 0 4 4 44 344 1344 344 5344 88 89 OXAAAA ZCMAAA HHHHxx 8209 8190 1 1 9 9 9 209 209 3209 8209 18 19 TDAAAA ADMAAA OOOOxx 8444 8191 0 0 4 4 44 444 444 3444 8444 88 89 UMAAAA BDMAAA VVVVxx 5669 8192 1 1 9 9 69 669 1669 669 5669 138 139 BKAAAA CDMAAA AAAAxx 2455 8193 1 3 5 15 55 455 455 2455 2455 110 111 LQAAAA DDMAAA HHHHxx 6767 8194 1 3 7 7 67 767 767 1767 6767 134 135 HAAAAA EDMAAA OOOOxx 135 8195 1 3 5 15 35 135 135 135 135 70 71 FFAAAA FDMAAA VVVVxx 3503 8196 1 3 3 3 3 503 1503 3503 3503 6 7 TEAAAA GDMAAA AAAAxx 6102 8197 0 2 2 2 2 102 102 1102 6102 4 5 SAAAAA HDMAAA HHHHxx 7136 8198 0 0 6 16 36 136 1136 2136 7136 72 73 MOAAAA IDMAAA OOOOxx 4933 8199 1 1 3 13 33 933 933 4933 4933 66 67 THAAAA JDMAAA VVVVxx 8804 8200 0 0 4 4 4 804 804 3804 8804 8 9 QAAAAA KDMAAA AAAAxx 3760 8201 0 0 0 0 60 760 1760 3760 3760 120 121 QOAAAA LDMAAA HHHHxx 8603 8202 1 3 3 3 3 603 603 3603 8603 6 7 XSAAAA MDMAAA OOOOxx 7411 8203 1 3 1 11 11 411 1411 2411 7411 22 23 BZAAAA NDMAAA VVVVxx 834 8204 0 2 4 14 34 834 834 834 834 68 69 CGAAAA ODMAAA AAAAxx 7385 8205 1 1 5 5 85 385 1385 2385 7385 170 171 BYAAAA PDMAAA HHHHxx 3696 8206 0 0 6 16 96 696 1696 3696 3696 192 193 EMAAAA QDMAAA OOOOxx 8720 8207 0 0 0 0 20 720 720 3720 8720 40 41 KXAAAA RDMAAA VVVVxx 4539 8208 1 3 9 19 39 539 539 4539 4539 78 79 PSAAAA SDMAAA AAAAxx 9837 8209 1 1 7 17 37 837 1837 4837 9837 74 75 JOAAAA TDMAAA HHHHxx 8595 8210 1 3 5 15 95 595 595 3595 8595 190 191 PSAAAA UDMAAA OOOOxx 3673 8211 1 1 3 13 73 673 1673 3673 3673 146 147 HLAAAA VDMAAA VVVVxx 475 8212 1 3 5 15 75 475 475 475 475 150 151 HSAAAA WDMAAA AAAAxx 2256 8213 0 0 6 16 56 256 256 2256 2256 112 113 UIAAAA XDMAAA HHHHxx 6349 8214 1 1 9 9 49 349 349 1349 6349 98 99 FKAAAA YDMAAA OOOOxx 9968 8215 0 0 8 8 68 968 1968 4968 9968 136 137 KTAAAA ZDMAAA VVVVxx 7261 8216 1 1 1 1 61 261 1261 2261 7261 122 123 HTAAAA AEMAAA AAAAxx 5799 8217 1 3 9 19 99 799 1799 799 5799 198 199 BPAAAA BEMAAA HHHHxx 8159 8218 1 3 9 19 59 159 159 3159 8159 118 119 VBAAAA CEMAAA OOOOxx 92 8219 0 0 2 12 92 92 92 92 92 184 185 ODAAAA DEMAAA VVVVxx 5927 8220 1 3 7 7 27 927 1927 927 5927 54 55 ZTAAAA EEMAAA AAAAxx 7925 8221 1 1 5 5 25 925 1925 2925 7925 50 51 VSAAAA FEMAAA HHHHxx 5836 8222 0 0 6 16 36 836 1836 836 5836 72 73 MQAAAA GEMAAA OOOOxx 7935 8223 1 3 5 15 35 935 1935 2935 7935 70 71 FTAAAA HEMAAA VVVVxx 5505 8224 1 1 5 5 5 505 1505 505 5505 10 11 TDAAAA IEMAAA AAAAxx 5882 8225 0 2 2 2 82 882 1882 882 5882 164 165 GSAAAA JEMAAA HHHHxx 4411 8226 1 3 1 11 11 411 411 4411 4411 22 23 RNAAAA KEMAAA OOOOxx 64 8227 0 0 4 4 64 64 64 64 64 128 129 MCAAAA LEMAAA VVVVxx 2851 8228 1 3 1 11 51 851 851 2851 2851 102 103 RFAAAA MEMAAA AAAAxx 1665 8229 1 1 5 5 65 665 1665 1665 1665 130 131 BMAAAA NEMAAA HHHHxx 2895 8230 1 3 5 15 95 895 895 2895 2895 190 191 JHAAAA OEMAAA OOOOxx 2210 8231 0 2 0 10 10 210 210 2210 2210 20 21 AHAAAA PEMAAA VVVVxx 9873 8232 1 1 3 13 73 873 1873 4873 9873 146 147 TPAAAA QEMAAA AAAAxx 5402 8233 0 2 2 2 2 402 1402 402 5402 4 5 UZAAAA REMAAA HHHHxx 285 8234 1 1 5 5 85 285 285 285 285 170 171 ZKAAAA SEMAAA OOOOxx 8545 8235 1 1 5 5 45 545 545 3545 8545 90 91 RQAAAA TEMAAA VVVVxx 5328 8236 0 0 8 8 28 328 1328 328 5328 56 57 YWAAAA UEMAAA AAAAxx 733 8237 1 1 3 13 33 733 733 733 733 66 67 FCAAAA VEMAAA HHHHxx 7726 8238 0 2 6 6 26 726 1726 2726 7726 52 53 ELAAAA WEMAAA OOOOxx 5418 8239 0 2 8 18 18 418 1418 418 5418 36 37 KAAAAA XEMAAA VVVVxx 7761 8240 1 1 1 1 61 761 1761 2761 7761 122 123 NMAAAA YEMAAA AAAAxx 9263 8241 1 3 3 3 63 263 1263 4263 9263 126 127 HSAAAA ZEMAAA HHHHxx 5579 8242 1 3 9 19 79 579 1579 579 5579 158 159 PGAAAA AFMAAA OOOOxx 5434 8243 0 2 4 14 34 434 1434 434 5434 68 69 ABAAAA BFMAAA VVVVxx 5230 8244 0 2 0 10 30 230 1230 230 5230 60 61 ETAAAA CFMAAA AAAAxx 9981 8245 1 1 1 1 81 981 1981 4981 9981 162 163 XTAAAA DFMAAA HHHHxx 5830 8246 0 2 0 10 30 830 1830 830 5830 60 61 GQAAAA EFMAAA OOOOxx 128 8247 0 0 8 8 28 128 128 128 128 56 57 YEAAAA FFMAAA VVVVxx 2734 8248 0 2 4 14 34 734 734 2734 2734 68 69 EBAAAA GFMAAA AAAAxx 4537 8249 1 1 7 17 37 537 537 4537 4537 74 75 NSAAAA HFMAAA HHHHxx 3899 8250 1 3 9 19 99 899 1899 3899 3899 198 199 ZTAAAA IFMAAA OOOOxx 1000 8251 0 0 0 0 0 0 1000 1000 1000 0 1 MMAAAA JFMAAA VVVVxx 9896 8252 0 0 6 16 96 896 1896 4896 9896 192 193 QQAAAA KFMAAA AAAAxx 3640 8253 0 0 0 0 40 640 1640 3640 3640 80 81 AKAAAA LFMAAA HHHHxx 2568 8254 0 0 8 8 68 568 568 2568 2568 136 137 UUAAAA MFMAAA OOOOxx 2026 8255 0 2 6 6 26 26 26 2026 2026 52 53 YZAAAA NFMAAA VVVVxx 3955 8256 1 3 5 15 55 955 1955 3955 3955 110 111 DWAAAA OFMAAA AAAAxx 7152 8257 0 0 2 12 52 152 1152 2152 7152 104 105 CPAAAA PFMAAA HHHHxx 2402 8258 0 2 2 2 2 402 402 2402 2402 4 5 KOAAAA QFMAAA OOOOxx 9522 8259 0 2 2 2 22 522 1522 4522 9522 44 45 GCAAAA RFMAAA VVVVxx 4011 8260 1 3 1 11 11 11 11 4011 4011 22 23 HYAAAA SFMAAA AAAAxx 3297 8261 1 1 7 17 97 297 1297 3297 3297 194 195 VWAAAA TFMAAA HHHHxx 4915 8262 1 3 5 15 15 915 915 4915 4915 30 31 BHAAAA UFMAAA OOOOxx 5397 8263 1 1 7 17 97 397 1397 397 5397 194 195 PZAAAA VFMAAA VVVVxx 5454 8264 0 2 4 14 54 454 1454 454 5454 108 109 UBAAAA WFMAAA AAAAxx 4568 8265 0 0 8 8 68 568 568 4568 4568 136 137 STAAAA XFMAAA HHHHxx 5875 8266 1 3 5 15 75 875 1875 875 5875 150 151 ZRAAAA YFMAAA OOOOxx 3642 8267 0 2 2 2 42 642 1642 3642 3642 84 85 CKAAAA ZFMAAA VVVVxx 8506 8268 0 2 6 6 6 506 506 3506 8506 12 13 EPAAAA AGMAAA AAAAxx 9621 8269 1 1 1 1 21 621 1621 4621 9621 42 43 BGAAAA BGMAAA HHHHxx 7739 8270 1 3 9 19 39 739 1739 2739 7739 78 79 RLAAAA CGMAAA OOOOxx 3987 8271 1 3 7 7 87 987 1987 3987 3987 174 175 JXAAAA DGMAAA VVVVxx 2090 8272 0 2 0 10 90 90 90 2090 2090 180 181 KCAAAA EGMAAA AAAAxx 3838 8273 0 2 8 18 38 838 1838 3838 3838 76 77 QRAAAA FGMAAA HHHHxx 17 8274 1 1 7 17 17 17 17 17 17 34 35 RAAAAA GGMAAA OOOOxx 3406 8275 0 2 6 6 6 406 1406 3406 3406 12 13 ABAAAA HGMAAA VVVVxx 8312 8276 0 0 2 12 12 312 312 3312 8312 24 25 SHAAAA IGMAAA AAAAxx 4034 8277 0 2 4 14 34 34 34 4034 4034 68 69 EZAAAA JGMAAA HHHHxx 1535 8278 1 3 5 15 35 535 1535 1535 1535 70 71 BHAAAA KGMAAA OOOOxx 7198 8279 0 2 8 18 98 198 1198 2198 7198 196 197 WQAAAA LGMAAA VVVVxx 8885 8280 1 1 5 5 85 885 885 3885 8885 170 171 TDAAAA MGMAAA AAAAxx 4081 8281 1 1 1 1 81 81 81 4081 4081 162 163 ZAAAAA NGMAAA HHHHxx 980 8282 0 0 0 0 80 980 980 980 980 160 161 SLAAAA OGMAAA OOOOxx 551 8283 1 3 1 11 51 551 551 551 551 102 103 FVAAAA PGMAAA VVVVxx 7746 8284 0 2 6 6 46 746 1746 2746 7746 92 93 YLAAAA QGMAAA AAAAxx 4756 8285 0 0 6 16 56 756 756 4756 4756 112 113 YAAAAA RGMAAA HHHHxx 3655 8286 1 3 5 15 55 655 1655 3655 3655 110 111 PKAAAA SGMAAA OOOOxx 7075 8287 1 3 5 15 75 75 1075 2075 7075 150 151 DMAAAA TGMAAA VVVVxx 3950 8288 0 2 0 10 50 950 1950 3950 3950 100 101 YVAAAA UGMAAA AAAAxx 2314 8289 0 2 4 14 14 314 314 2314 2314 28 29 ALAAAA VGMAAA HHHHxx 8432 8290 0 0 2 12 32 432 432 3432 8432 64 65 IMAAAA WGMAAA OOOOxx 62 8291 0 2 2 2 62 62 62 62 62 124 125 KCAAAA XGMAAA VVVVxx 6920 8292 0 0 0 0 20 920 920 1920 6920 40 41 EGAAAA YGMAAA AAAAxx 4077 8293 1 1 7 17 77 77 77 4077 4077 154 155 VAAAAA ZGMAAA HHHHxx 9118 8294 0 2 8 18 18 118 1118 4118 9118 36 37 SMAAAA AHMAAA OOOOxx 5375 8295 1 3 5 15 75 375 1375 375 5375 150 151 TYAAAA BHMAAA VVVVxx 178 8296 0 2 8 18 78 178 178 178 178 156 157 WGAAAA CHMAAA AAAAxx 1079 8297 1 3 9 19 79 79 1079 1079 1079 158 159 NPAAAA DHMAAA HHHHxx 4279 8298 1 3 9 19 79 279 279 4279 4279 158 159 PIAAAA EHMAAA OOOOxx 8436 8299 0 0 6 16 36 436 436 3436 8436 72 73 MMAAAA FHMAAA VVVVxx 1931 8300 1 3 1 11 31 931 1931 1931 1931 62 63 HWAAAA GHMAAA AAAAxx 2096 8301 0 0 6 16 96 96 96 2096 2096 192 193 QCAAAA HHMAAA HHHHxx 1638 8302 0 2 8 18 38 638 1638 1638 1638 76 77 ALAAAA IHMAAA OOOOxx 2788 8303 0 0 8 8 88 788 788 2788 2788 176 177 GDAAAA JHMAAA VVVVxx 4751 8304 1 3 1 11 51 751 751 4751 4751 102 103 TAAAAA KHMAAA AAAAxx 8824 8305 0 0 4 4 24 824 824 3824 8824 48 49 KBAAAA LHMAAA HHHHxx 3098 8306 0 2 8 18 98 98 1098 3098 3098 196 197 EPAAAA MHMAAA OOOOxx 4497 8307 1 1 7 17 97 497 497 4497 4497 194 195 ZQAAAA NHMAAA VVVVxx 5223 8308 1 3 3 3 23 223 1223 223 5223 46 47 XSAAAA OHMAAA AAAAxx 9212 8309 0 0 2 12 12 212 1212 4212 9212 24 25 IQAAAA PHMAAA HHHHxx 4265 8310 1 1 5 5 65 265 265 4265 4265 130 131 BIAAAA QHMAAA OOOOxx 6898 8311 0 2 8 18 98 898 898 1898 6898 196 197 IFAAAA RHMAAA VVVVxx 8808 8312 0 0 8 8 8 808 808 3808 8808 16 17 UAAAAA SHMAAA AAAAxx 5629 8313 1 1 9 9 29 629 1629 629 5629 58 59 NIAAAA THMAAA HHHHxx 3779 8314 1 3 9 19 79 779 1779 3779 3779 158 159 JPAAAA UHMAAA OOOOxx 4972 8315 0 0 2 12 72 972 972 4972 4972 144 145 GJAAAA VHMAAA VVVVxx 4511 8316 1 3 1 11 11 511 511 4511 4511 22 23 NRAAAA WHMAAA AAAAxx 6761 8317 1 1 1 1 61 761 761 1761 6761 122 123 BAAAAA XHMAAA HHHHxx 2335 8318 1 3 5 15 35 335 335 2335 2335 70 71 VLAAAA YHMAAA OOOOxx 732 8319 0 0 2 12 32 732 732 732 732 64 65 ECAAAA ZHMAAA VVVVxx 4757 8320 1 1 7 17 57 757 757 4757 4757 114 115 ZAAAAA AIMAAA AAAAxx 6624 8321 0 0 4 4 24 624 624 1624 6624 48 49 UUAAAA BIMAAA HHHHxx 5869 8322 1 1 9 9 69 869 1869 869 5869 138 139 TRAAAA CIMAAA OOOOxx 5842 8323 0 2 2 2 42 842 1842 842 5842 84 85 SQAAAA DIMAAA VVVVxx 5735 8324 1 3 5 15 35 735 1735 735 5735 70 71 PMAAAA EIMAAA AAAAxx 8276 8325 0 0 6 16 76 276 276 3276 8276 152 153 IGAAAA FIMAAA HHHHxx 7227 8326 1 3 7 7 27 227 1227 2227 7227 54 55 ZRAAAA GIMAAA OOOOxx 4923 8327 1 3 3 3 23 923 923 4923 4923 46 47 JHAAAA HIMAAA VVVVxx 9135 8328 1 3 5 15 35 135 1135 4135 9135 70 71 JNAAAA IIMAAA AAAAxx 5813 8329 1 1 3 13 13 813 1813 813 5813 26 27 PPAAAA JIMAAA HHHHxx 9697 8330 1 1 7 17 97 697 1697 4697 9697 194 195 ZIAAAA KIMAAA OOOOxx 3222 8331 0 2 2 2 22 222 1222 3222 3222 44 45 YTAAAA LIMAAA VVVVxx 2394 8332 0 2 4 14 94 394 394 2394 2394 188 189 COAAAA MIMAAA AAAAxx 5784 8333 0 0 4 4 84 784 1784 784 5784 168 169 MOAAAA NIMAAA HHHHxx 3652 8334 0 0 2 12 52 652 1652 3652 3652 104 105 MKAAAA OIMAAA OOOOxx 8175 8335 1 3 5 15 75 175 175 3175 8175 150 151 LCAAAA PIMAAA VVVVxx 7568 8336 0 0 8 8 68 568 1568 2568 7568 136 137 CFAAAA QIMAAA AAAAxx 6645 8337 1 1 5 5 45 645 645 1645 6645 90 91 PVAAAA RIMAAA HHHHxx 8176 8338 0 0 6 16 76 176 176 3176 8176 152 153 MCAAAA SIMAAA OOOOxx 530 8339 0 2 0 10 30 530 530 530 530 60 61 KUAAAA TIMAAA VVVVxx 5439 8340 1 3 9 19 39 439 1439 439 5439 78 79 FBAAAA UIMAAA AAAAxx 61 8341 1 1 1 1 61 61 61 61 61 122 123 JCAAAA VIMAAA HHHHxx 3951 8342 1 3 1 11 51 951 1951 3951 3951 102 103 ZVAAAA WIMAAA OOOOxx 5283 8343 1 3 3 3 83 283 1283 283 5283 166 167 FVAAAA XIMAAA VVVVxx 7226 8344 0 2 6 6 26 226 1226 2226 7226 52 53 YRAAAA YIMAAA AAAAxx 1954 8345 0 2 4 14 54 954 1954 1954 1954 108 109 EXAAAA ZIMAAA HHHHxx 334 8346 0 2 4 14 34 334 334 334 334 68 69 WMAAAA AJMAAA OOOOxx 3921 8347 1 1 1 1 21 921 1921 3921 3921 42 43 VUAAAA BJMAAA VVVVxx 6276 8348 0 0 6 16 76 276 276 1276 6276 152 153 KHAAAA CJMAAA AAAAxx 3378 8349 0 2 8 18 78 378 1378 3378 3378 156 157 YZAAAA DJMAAA HHHHxx 5236 8350 0 0 6 16 36 236 1236 236 5236 72 73 KTAAAA EJMAAA OOOOxx 7781 8351 1 1 1 1 81 781 1781 2781 7781 162 163 HNAAAA FJMAAA VVVVxx 8601 8352 1 1 1 1 1 601 601 3601 8601 2 3 VSAAAA GJMAAA AAAAxx 1473 8353 1 1 3 13 73 473 1473 1473 1473 146 147 REAAAA HJMAAA HHHHxx 3246 8354 0 2 6 6 46 246 1246 3246 3246 92 93 WUAAAA IJMAAA OOOOxx 3601 8355 1 1 1 1 1 601 1601 3601 3601 2 3 NIAAAA JJMAAA VVVVxx 6861 8356 1 1 1 1 61 861 861 1861 6861 122 123 XDAAAA KJMAAA AAAAxx 9032 8357 0 0 2 12 32 32 1032 4032 9032 64 65 KJAAAA LJMAAA HHHHxx 216 8358 0 0 6 16 16 216 216 216 216 32 33 IIAAAA MJMAAA OOOOxx 3824 8359 0 0 4 4 24 824 1824 3824 3824 48 49 CRAAAA NJMAAA VVVVxx 8486 8360 0 2 6 6 86 486 486 3486 8486 172 173 KOAAAA OJMAAA AAAAxx 276 8361 0 0 6 16 76 276 276 276 276 152 153 QKAAAA PJMAAA HHHHxx 1838 8362 0 2 8 18 38 838 1838 1838 1838 76 77 SSAAAA QJMAAA OOOOxx 6175 8363 1 3 5 15 75 175 175 1175 6175 150 151 NDAAAA RJMAAA VVVVxx 3719 8364 1 3 9 19 19 719 1719 3719 3719 38 39 BNAAAA SJMAAA AAAAxx 6958 8365 0 2 8 18 58 958 958 1958 6958 116 117 QHAAAA TJMAAA HHHHxx 6822 8366 0 2 2 2 22 822 822 1822 6822 44 45 KCAAAA UJMAAA OOOOxx 3318 8367 0 2 8 18 18 318 1318 3318 3318 36 37 QXAAAA VJMAAA VVVVxx 7222 8368 0 2 2 2 22 222 1222 2222 7222 44 45 URAAAA WJMAAA AAAAxx 85 8369 1 1 5 5 85 85 85 85 85 170 171 HDAAAA XJMAAA HHHHxx 5158 8370 0 2 8 18 58 158 1158 158 5158 116 117 KQAAAA YJMAAA OOOOxx 6360 8371 0 0 0 0 60 360 360 1360 6360 120 121 QKAAAA ZJMAAA VVVVxx 2599 8372 1 3 9 19 99 599 599 2599 2599 198 199 ZVAAAA AKMAAA AAAAxx 4002 8373 0 2 2 2 2 2 2 4002 4002 4 5 YXAAAA BKMAAA HHHHxx 6597 8374 1 1 7 17 97 597 597 1597 6597 194 195 TTAAAA CKMAAA OOOOxx 5762 8375 0 2 2 2 62 762 1762 762 5762 124 125 QNAAAA DKMAAA VVVVxx 8383 8376 1 3 3 3 83 383 383 3383 8383 166 167 LKAAAA EKMAAA AAAAxx 4686 8377 0 2 6 6 86 686 686 4686 4686 172 173 GYAAAA FKMAAA HHHHxx 5972 8378 0 0 2 12 72 972 1972 972 5972 144 145 SVAAAA GKMAAA OOOOxx 1432 8379 0 0 2 12 32 432 1432 1432 1432 64 65 CDAAAA HKMAAA VVVVxx 1601 8380 1 1 1 1 1 601 1601 1601 1601 2 3 PJAAAA IKMAAA AAAAxx 3012 8381 0 0 2 12 12 12 1012 3012 3012 24 25 WLAAAA JKMAAA HHHHxx 9345 8382 1 1 5 5 45 345 1345 4345 9345 90 91 LVAAAA KKMAAA OOOOxx 8869 8383 1 1 9 9 69 869 869 3869 8869 138 139 DDAAAA LKMAAA VVVVxx 6612 8384 0 0 2 12 12 612 612 1612 6612 24 25 IUAAAA MKMAAA AAAAxx 262 8385 0 2 2 2 62 262 262 262 262 124 125 CKAAAA NKMAAA HHHHxx 300 8386 0 0 0 0 0 300 300 300 300 0 1 OLAAAA OKMAAA OOOOxx 3045 8387 1 1 5 5 45 45 1045 3045 3045 90 91 DNAAAA PKMAAA VVVVxx 7252 8388 0 0 2 12 52 252 1252 2252 7252 104 105 YSAAAA QKMAAA AAAAxx 9099 8389 1 3 9 19 99 99 1099 4099 9099 198 199 ZLAAAA RKMAAA HHHHxx 9006 8390 0 2 6 6 6 6 1006 4006 9006 12 13 KIAAAA SKMAAA OOOOxx 3078 8391 0 2 8 18 78 78 1078 3078 3078 156 157 KOAAAA TKMAAA VVVVxx 5159 8392 1 3 9 19 59 159 1159 159 5159 118 119 LQAAAA UKMAAA AAAAxx 9329 8393 1 1 9 9 29 329 1329 4329 9329 58 59 VUAAAA VKMAAA HHHHxx 1393 8394 1 1 3 13 93 393 1393 1393 1393 186 187 PBAAAA WKMAAA OOOOxx 5894 8395 0 2 4 14 94 894 1894 894 5894 188 189 SSAAAA XKMAAA VVVVxx 11 8396 1 3 1 11 11 11 11 11 11 22 23 LAAAAA YKMAAA AAAAxx 5606 8397 0 2 6 6 6 606 1606 606 5606 12 13 QHAAAA ZKMAAA HHHHxx 5541 8398 1 1 1 1 41 541 1541 541 5541 82 83 DFAAAA ALMAAA OOOOxx 2689 8399 1 1 9 9 89 689 689 2689 2689 178 179 LZAAAA BLMAAA VVVVxx 1023 8400 1 3 3 3 23 23 1023 1023 1023 46 47 JNAAAA CLMAAA AAAAxx 8134 8401 0 2 4 14 34 134 134 3134 8134 68 69 WAAAAA DLMAAA HHHHxx 5923 8402 1 3 3 3 23 923 1923 923 5923 46 47 VTAAAA ELMAAA OOOOxx 6056 8403 0 0 6 16 56 56 56 1056 6056 112 113 YYAAAA FLMAAA VVVVxx 653 8404 1 1 3 13 53 653 653 653 653 106 107 DZAAAA GLMAAA AAAAxx 367 8405 1 3 7 7 67 367 367 367 367 134 135 DOAAAA HLMAAA HHHHxx 1828 8406 0 0 8 8 28 828 1828 1828 1828 56 57 ISAAAA ILMAAA OOOOxx 6506 8407 0 2 6 6 6 506 506 1506 6506 12 13 GQAAAA JLMAAA VVVVxx 5772 8408 0 0 2 12 72 772 1772 772 5772 144 145 AOAAAA KLMAAA AAAAxx 8052 8409 0 0 2 12 52 52 52 3052 8052 104 105 SXAAAA LLMAAA HHHHxx 2633 8410 1 1 3 13 33 633 633 2633 2633 66 67 HXAAAA MLMAAA OOOOxx 4878 8411 0 2 8 18 78 878 878 4878 4878 156 157 QFAAAA NLMAAA VVVVxx 5621 8412 1 1 1 1 21 621 1621 621 5621 42 43 FIAAAA OLMAAA AAAAxx 41 8413 1 1 1 1 41 41 41 41 41 82 83 PBAAAA PLMAAA HHHHxx 4613 8414 1 1 3 13 13 613 613 4613 4613 26 27 LVAAAA QLMAAA OOOOxx 9389 8415 1 1 9 9 89 389 1389 4389 9389 178 179 DXAAAA RLMAAA VVVVxx 9414 8416 0 2 4 14 14 414 1414 4414 9414 28 29 CYAAAA SLMAAA AAAAxx 3583 8417 1 3 3 3 83 583 1583 3583 3583 166 167 VHAAAA TLMAAA HHHHxx 3454 8418 0 2 4 14 54 454 1454 3454 3454 108 109 WCAAAA ULMAAA OOOOxx 719 8419 1 3 9 19 19 719 719 719 719 38 39 RBAAAA VLMAAA VVVVxx 6188 8420 0 0 8 8 88 188 188 1188 6188 176 177 AEAAAA WLMAAA AAAAxx 2288 8421 0 0 8 8 88 288 288 2288 2288 176 177 AKAAAA XLMAAA HHHHxx 1287 8422 1 3 7 7 87 287 1287 1287 1287 174 175 NXAAAA YLMAAA OOOOxx 1397 8423 1 1 7 17 97 397 1397 1397 1397 194 195 TBAAAA ZLMAAA VVVVxx 7763 8424 1 3 3 3 63 763 1763 2763 7763 126 127 PMAAAA AMMAAA AAAAxx 5194 8425 0 2 4 14 94 194 1194 194 5194 188 189 URAAAA BMMAAA HHHHxx 3167 8426 1 3 7 7 67 167 1167 3167 3167 134 135 VRAAAA CMMAAA OOOOxx 9218 8427 0 2 8 18 18 218 1218 4218 9218 36 37 OQAAAA DMMAAA VVVVxx 2065 8428 1 1 5 5 65 65 65 2065 2065 130 131 LBAAAA EMMAAA AAAAxx 9669 8429 1 1 9 9 69 669 1669 4669 9669 138 139 XHAAAA FMMAAA HHHHxx 146 8430 0 2 6 6 46 146 146 146 146 92 93 QFAAAA GMMAAA OOOOxx 6141 8431 1 1 1 1 41 141 141 1141 6141 82 83 FCAAAA HMMAAA VVVVxx 2843 8432 1 3 3 3 43 843 843 2843 2843 86 87 JFAAAA IMMAAA AAAAxx 7934 8433 0 2 4 14 34 934 1934 2934 7934 68 69 ETAAAA JMMAAA HHHHxx 2536 8434 0 0 6 16 36 536 536 2536 2536 72 73 OTAAAA KMMAAA OOOOxx 7088 8435 0 0 8 8 88 88 1088 2088 7088 176 177 QMAAAA LMMAAA VVVVxx 2519 8436 1 3 9 19 19 519 519 2519 2519 38 39 XSAAAA MMMAAA AAAAxx 6650 8437 0 2 0 10 50 650 650 1650 6650 100 101 UVAAAA NMMAAA HHHHxx 3007 8438 1 3 7 7 7 7 1007 3007 3007 14 15 RLAAAA OMMAAA OOOOxx 4507 8439 1 3 7 7 7 507 507 4507 4507 14 15 JRAAAA PMMAAA VVVVxx 4892 8440 0 0 2 12 92 892 892 4892 4892 184 185 EGAAAA QMMAAA AAAAxx 7159 8441 1 3 9 19 59 159 1159 2159 7159 118 119 JPAAAA RMMAAA HHHHxx 3171 8442 1 3 1 11 71 171 1171 3171 3171 142 143 ZRAAAA SMMAAA OOOOxx 1080 8443 0 0 0 0 80 80 1080 1080 1080 160 161 OPAAAA TMMAAA VVVVxx 7248 8444 0 0 8 8 48 248 1248 2248 7248 96 97 USAAAA UMMAAA AAAAxx 7230 8445 0 2 0 10 30 230 1230 2230 7230 60 61 CSAAAA VMMAAA HHHHxx 3823 8446 1 3 3 3 23 823 1823 3823 3823 46 47 BRAAAA WMMAAA OOOOxx 5517 8447 1 1 7 17 17 517 1517 517 5517 34 35 FEAAAA XMMAAA VVVVxx 1482 8448 0 2 2 2 82 482 1482 1482 1482 164 165 AFAAAA YMMAAA AAAAxx 9953 8449 1 1 3 13 53 953 1953 4953 9953 106 107 VSAAAA ZMMAAA HHHHxx 2754 8450 0 2 4 14 54 754 754 2754 2754 108 109 YBAAAA ANMAAA OOOOxx 3875 8451 1 3 5 15 75 875 1875 3875 3875 150 151 BTAAAA BNMAAA VVVVxx 9800 8452 0 0 0 0 0 800 1800 4800 9800 0 1 YMAAAA CNMAAA AAAAxx 8819 8453 1 3 9 19 19 819 819 3819 8819 38 39 FBAAAA DNMAAA HHHHxx 8267 8454 1 3 7 7 67 267 267 3267 8267 134 135 ZFAAAA ENMAAA OOOOxx 520 8455 0 0 0 0 20 520 520 520 520 40 41 AUAAAA FNMAAA VVVVxx 5770 8456 0 2 0 10 70 770 1770 770 5770 140 141 YNAAAA GNMAAA AAAAxx 2114 8457 0 2 4 14 14 114 114 2114 2114 28 29 IDAAAA HNMAAA HHHHxx 5045 8458 1 1 5 5 45 45 1045 45 5045 90 91 BMAAAA INMAAA OOOOxx 1094 8459 0 2 4 14 94 94 1094 1094 1094 188 189 CQAAAA JNMAAA VVVVxx 8786 8460 0 2 6 6 86 786 786 3786 8786 172 173 YZAAAA KNMAAA AAAAxx 353 8461 1 1 3 13 53 353 353 353 353 106 107 PNAAAA LNMAAA HHHHxx 290 8462 0 2 0 10 90 290 290 290 290 180 181 ELAAAA MNMAAA OOOOxx 3376 8463 0 0 6 16 76 376 1376 3376 3376 152 153 WZAAAA NNMAAA VVVVxx 9305 8464 1 1 5 5 5 305 1305 4305 9305 10 11 XTAAAA ONMAAA AAAAxx 186 8465 0 2 6 6 86 186 186 186 186 172 173 EHAAAA PNMAAA HHHHxx 4817 8466 1 1 7 17 17 817 817 4817 4817 34 35 HDAAAA QNMAAA OOOOxx 4638 8467 0 2 8 18 38 638 638 4638 4638 76 77 KWAAAA RNMAAA VVVVxx 3558 8468 0 2 8 18 58 558 1558 3558 3558 116 117 WGAAAA SNMAAA AAAAxx 9285 8469 1 1 5 5 85 285 1285 4285 9285 170 171 DTAAAA TNMAAA HHHHxx 848 8470 0 0 8 8 48 848 848 848 848 96 97 QGAAAA UNMAAA OOOOxx 8923 8471 1 3 3 3 23 923 923 3923 8923 46 47 FFAAAA VNMAAA VVVVxx 6826 8472 0 2 6 6 26 826 826 1826 6826 52 53 OCAAAA WNMAAA AAAAxx 5187 8473 1 3 7 7 87 187 1187 187 5187 174 175 NRAAAA XNMAAA HHHHxx 2398 8474 0 2 8 18 98 398 398 2398 2398 196 197 GOAAAA YNMAAA OOOOxx 7653 8475 1 1 3 13 53 653 1653 2653 7653 106 107 JIAAAA ZNMAAA VVVVxx 8835 8476 1 3 5 15 35 835 835 3835 8835 70 71 VBAAAA AOMAAA AAAAxx 5736 8477 0 0 6 16 36 736 1736 736 5736 72 73 QMAAAA BOMAAA HHHHxx 1238 8478 0 2 8 18 38 238 1238 1238 1238 76 77 QVAAAA COMAAA OOOOxx 6021 8479 1 1 1 1 21 21 21 1021 6021 42 43 PXAAAA DOMAAA VVVVxx 6815 8480 1 3 5 15 15 815 815 1815 6815 30 31 DCAAAA EOMAAA AAAAxx 2549 8481 1 1 9 9 49 549 549 2549 2549 98 99 BUAAAA FOMAAA HHHHxx 5657 8482 1 1 7 17 57 657 1657 657 5657 114 115 PJAAAA GOMAAA OOOOxx 6855 8483 1 3 5 15 55 855 855 1855 6855 110 111 RDAAAA HOMAAA VVVVxx 1225 8484 1 1 5 5 25 225 1225 1225 1225 50 51 DVAAAA IOMAAA AAAAxx 7452 8485 0 0 2 12 52 452 1452 2452 7452 104 105 QAAAAA JOMAAA HHHHxx 2479 8486 1 3 9 19 79 479 479 2479 2479 158 159 JRAAAA KOMAAA OOOOxx 7974 8487 0 2 4 14 74 974 1974 2974 7974 148 149 SUAAAA LOMAAA VVVVxx 1212 8488 0 0 2 12 12 212 1212 1212 1212 24 25 QUAAAA MOMAAA AAAAxx 8883 8489 1 3 3 3 83 883 883 3883 8883 166 167 RDAAAA NOMAAA HHHHxx 8150 8490 0 2 0 10 50 150 150 3150 8150 100 101 MBAAAA OOMAAA OOOOxx 3392 8491 0 0 2 12 92 392 1392 3392 3392 184 185 MAAAAA POMAAA VVVVxx 6774 8492 0 2 4 14 74 774 774 1774 6774 148 149 OAAAAA QOMAAA AAAAxx 904 8493 0 0 4 4 4 904 904 904 904 8 9 UIAAAA ROMAAA HHHHxx 5068 8494 0 0 8 8 68 68 1068 68 5068 136 137 YMAAAA SOMAAA OOOOxx 9339 8495 1 3 9 19 39 339 1339 4339 9339 78 79 FVAAAA TOMAAA VVVVxx 1062 8496 0 2 2 2 62 62 1062 1062 1062 124 125 WOAAAA UOMAAA AAAAxx 3841 8497 1 1 1 1 41 841 1841 3841 3841 82 83 TRAAAA VOMAAA HHHHxx 8924 8498 0 0 4 4 24 924 924 3924 8924 48 49 GFAAAA WOMAAA OOOOxx 9795 8499 1 3 5 15 95 795 1795 4795 9795 190 191 TMAAAA XOMAAA VVVVxx 3981 8500 1 1 1 1 81 981 1981 3981 3981 162 163 DXAAAA YOMAAA AAAAxx 4290 8501 0 2 0 10 90 290 290 4290 4290 180 181 AJAAAA ZOMAAA HHHHxx 1067 8502 1 3 7 7 67 67 1067 1067 1067 134 135 BPAAAA APMAAA OOOOxx 8679 8503 1 3 9 19 79 679 679 3679 8679 158 159 VVAAAA BPMAAA VVVVxx 2894 8504 0 2 4 14 94 894 894 2894 2894 188 189 IHAAAA CPMAAA AAAAxx 9248 8505 0 0 8 8 48 248 1248 4248 9248 96 97 SRAAAA DPMAAA HHHHxx 1072 8506 0 0 2 12 72 72 1072 1072 1072 144 145 GPAAAA EPMAAA OOOOxx 3510 8507 0 2 0 10 10 510 1510 3510 3510 20 21 AFAAAA FPMAAA VVVVxx 6871 8508 1 3 1 11 71 871 871 1871 6871 142 143 HEAAAA GPMAAA AAAAxx 8701 8509 1 1 1 1 1 701 701 3701 8701 2 3 RWAAAA HPMAAA HHHHxx 8170 8510 0 2 0 10 70 170 170 3170 8170 140 141 GCAAAA IPMAAA OOOOxx 2730 8511 0 2 0 10 30 730 730 2730 2730 60 61 ABAAAA JPMAAA VVVVxx 2668 8512 0 0 8 8 68 668 668 2668 2668 136 137 QYAAAA KPMAAA AAAAxx 8723 8513 1 3 3 3 23 723 723 3723 8723 46 47 NXAAAA LPMAAA HHHHxx 3439 8514 1 3 9 19 39 439 1439 3439 3439 78 79 HCAAAA MPMAAA OOOOxx 6219 8515 1 3 9 19 19 219 219 1219 6219 38 39 FFAAAA NPMAAA VVVVxx 4264 8516 0 0 4 4 64 264 264 4264 4264 128 129 AIAAAA OPMAAA AAAAxx 3929 8517 1 1 9 9 29 929 1929 3929 3929 58 59 DVAAAA PPMAAA HHHHxx 7 8518 1 3 7 7 7 7 7 7 7 14 15 HAAAAA QPMAAA OOOOxx 3737 8519 1 1 7 17 37 737 1737 3737 3737 74 75 TNAAAA RPMAAA VVVVxx 358 8520 0 2 8 18 58 358 358 358 358 116 117 UNAAAA SPMAAA AAAAxx 5128 8521 0 0 8 8 28 128 1128 128 5128 56 57 GPAAAA TPMAAA HHHHxx 7353 8522 1 1 3 13 53 353 1353 2353 7353 106 107 VWAAAA UPMAAA OOOOxx 8758 8523 0 2 8 18 58 758 758 3758 8758 116 117 WYAAAA VPMAAA VVVVxx 7284 8524 0 0 4 4 84 284 1284 2284 7284 168 169 EUAAAA WPMAAA AAAAxx 4037 8525 1 1 7 17 37 37 37 4037 4037 74 75 HZAAAA XPMAAA HHHHxx 435 8526 1 3 5 15 35 435 435 435 435 70 71 TQAAAA YPMAAA OOOOxx 3580 8527 0 0 0 0 80 580 1580 3580 3580 160 161 SHAAAA ZPMAAA VVVVxx 4554 8528 0 2 4 14 54 554 554 4554 4554 108 109 ETAAAA AQMAAA AAAAxx 4337 8529 1 1 7 17 37 337 337 4337 4337 74 75 VKAAAA BQMAAA HHHHxx 512 8530 0 0 2 12 12 512 512 512 512 24 25 STAAAA CQMAAA OOOOxx 2032 8531 0 0 2 12 32 32 32 2032 2032 64 65 EAAAAA DQMAAA VVVVxx 1755 8532 1 3 5 15 55 755 1755 1755 1755 110 111 NPAAAA EQMAAA AAAAxx 9923 8533 1 3 3 3 23 923 1923 4923 9923 46 47 RRAAAA FQMAAA HHHHxx 3747 8534 1 3 7 7 47 747 1747 3747 3747 94 95 DOAAAA GQMAAA OOOOxx 27 8535 1 3 7 7 27 27 27 27 27 54 55 BBAAAA HQMAAA VVVVxx 3075 8536 1 3 5 15 75 75 1075 3075 3075 150 151 HOAAAA IQMAAA AAAAxx 6259 8537 1 3 9 19 59 259 259 1259 6259 118 119 TGAAAA JQMAAA HHHHxx 2940 8538 0 0 0 0 40 940 940 2940 2940 80 81 CJAAAA KQMAAA OOOOxx 5724 8539 0 0 4 4 24 724 1724 724 5724 48 49 EMAAAA LQMAAA VVVVxx 5638 8540 0 2 8 18 38 638 1638 638 5638 76 77 WIAAAA MQMAAA AAAAxx 479 8541 1 3 9 19 79 479 479 479 479 158 159 LSAAAA NQMAAA HHHHxx 4125 8542 1 1 5 5 25 125 125 4125 4125 50 51 RCAAAA OQMAAA OOOOxx 1525 8543 1 1 5 5 25 525 1525 1525 1525 50 51 RGAAAA PQMAAA VVVVxx 7529 8544 1 1 9 9 29 529 1529 2529 7529 58 59 PDAAAA QQMAAA AAAAxx 931 8545 1 3 1 11 31 931 931 931 931 62 63 VJAAAA RQMAAA HHHHxx 5175 8546 1 3 5 15 75 175 1175 175 5175 150 151 BRAAAA SQMAAA OOOOxx 6798 8547 0 2 8 18 98 798 798 1798 6798 196 197 MBAAAA TQMAAA VVVVxx 2111 8548 1 3 1 11 11 111 111 2111 2111 22 23 FDAAAA UQMAAA AAAAxx 6145 8549 1 1 5 5 45 145 145 1145 6145 90 91 JCAAAA VQMAAA HHHHxx 4712 8550 0 0 2 12 12 712 712 4712 4712 24 25 GZAAAA WQMAAA OOOOxx 3110 8551 0 2 0 10 10 110 1110 3110 3110 20 21 QPAAAA XQMAAA VVVVxx 97 8552 1 1 7 17 97 97 97 97 97 194 195 TDAAAA YQMAAA AAAAxx 758 8553 0 2 8 18 58 758 758 758 758 116 117 EDAAAA ZQMAAA HHHHxx 1895 8554 1 3 5 15 95 895 1895 1895 1895 190 191 XUAAAA ARMAAA OOOOxx 5289 8555 1 1 9 9 89 289 1289 289 5289 178 179 LVAAAA BRMAAA VVVVxx 5026 8556 0 2 6 6 26 26 1026 26 5026 52 53 ILAAAA CRMAAA AAAAxx 4725 8557 1 1 5 5 25 725 725 4725 4725 50 51 TZAAAA DRMAAA HHHHxx 1679 8558 1 3 9 19 79 679 1679 1679 1679 158 159 PMAAAA ERMAAA OOOOxx 4433 8559 1 1 3 13 33 433 433 4433 4433 66 67 NOAAAA FRMAAA VVVVxx 5340 8560 0 0 0 0 40 340 1340 340 5340 80 81 KXAAAA GRMAAA AAAAxx 6340 8561 0 0 0 0 40 340 340 1340 6340 80 81 WJAAAA HRMAAA HHHHxx 3261 8562 1 1 1 1 61 261 1261 3261 3261 122 123 LVAAAA IRMAAA OOOOxx 8108 8563 0 0 8 8 8 108 108 3108 8108 16 17 WZAAAA JRMAAA VVVVxx 8785 8564 1 1 5 5 85 785 785 3785 8785 170 171 XZAAAA KRMAAA AAAAxx 7391 8565 1 3 1 11 91 391 1391 2391 7391 182 183 HYAAAA LRMAAA HHHHxx 1496 8566 0 0 6 16 96 496 1496 1496 1496 192 193 OFAAAA MRMAAA OOOOxx 1484 8567 0 0 4 4 84 484 1484 1484 1484 168 169 CFAAAA NRMAAA VVVVxx 5884 8568 0 0 4 4 84 884 1884 884 5884 168 169 ISAAAA ORMAAA AAAAxx 342 8569 0 2 2 2 42 342 342 342 342 84 85 ENAAAA PRMAAA HHHHxx 7659 8570 1 3 9 19 59 659 1659 2659 7659 118 119 PIAAAA QRMAAA OOOOxx 6635 8571 1 3 5 15 35 635 635 1635 6635 70 71 FVAAAA RRMAAA VVVVxx 8507 8572 1 3 7 7 7 507 507 3507 8507 14 15 FPAAAA SRMAAA AAAAxx 2583 8573 1 3 3 3 83 583 583 2583 2583 166 167 JVAAAA TRMAAA HHHHxx 6533 8574 1 1 3 13 33 533 533 1533 6533 66 67 HRAAAA URMAAA OOOOxx 5879 8575 1 3 9 19 79 879 1879 879 5879 158 159 DSAAAA VRMAAA VVVVxx 5511 8576 1 3 1 11 11 511 1511 511 5511 22 23 ZDAAAA WRMAAA AAAAxx 3682 8577 0 2 2 2 82 682 1682 3682 3682 164 165 QLAAAA XRMAAA HHHHxx 7182 8578 0 2 2 2 82 182 1182 2182 7182 164 165 GQAAAA YRMAAA OOOOxx 1409 8579 1 1 9 9 9 409 1409 1409 1409 18 19 FCAAAA ZRMAAA VVVVxx 3363 8580 1 3 3 3 63 363 1363 3363 3363 126 127 JZAAAA ASMAAA AAAAxx 729 8581 1 1 9 9 29 729 729 729 729 58 59 BCAAAA BSMAAA HHHHxx 5857 8582 1 1 7 17 57 857 1857 857 5857 114 115 HRAAAA CSMAAA OOOOxx 235 8583 1 3 5 15 35 235 235 235 235 70 71 BJAAAA DSMAAA VVVVxx 193 8584 1 1 3 13 93 193 193 193 193 186 187 LHAAAA ESMAAA AAAAxx 5586 8585 0 2 6 6 86 586 1586 586 5586 172 173 WGAAAA FSMAAA HHHHxx 6203 8586 1 3 3 3 3 203 203 1203 6203 6 7 PEAAAA GSMAAA OOOOxx 6795 8587 1 3 5 15 95 795 795 1795 6795 190 191 JBAAAA HSMAAA VVVVxx 3211 8588 1 3 1 11 11 211 1211 3211 3211 22 23 NTAAAA ISMAAA AAAAxx 9763 8589 1 3 3 3 63 763 1763 4763 9763 126 127 NLAAAA JSMAAA HHHHxx 9043 8590 1 3 3 3 43 43 1043 4043 9043 86 87 VJAAAA KSMAAA OOOOxx 2854 8591 0 2 4 14 54 854 854 2854 2854 108 109 UFAAAA LSMAAA VVVVxx 565 8592 1 1 5 5 65 565 565 565 565 130 131 TVAAAA MSMAAA AAAAxx 9284 8593 0 0 4 4 84 284 1284 4284 9284 168 169 CTAAAA NSMAAA HHHHxx 7886 8594 0 2 6 6 86 886 1886 2886 7886 172 173 IRAAAA OSMAAA OOOOxx 122 8595 0 2 2 2 22 122 122 122 122 44 45 SEAAAA PSMAAA VVVVxx 4934 8596 0 2 4 14 34 934 934 4934 4934 68 69 UHAAAA QSMAAA AAAAxx 1766 8597 0 2 6 6 66 766 1766 1766 1766 132 133 YPAAAA RSMAAA HHHHxx 2554 8598 0 2 4 14 54 554 554 2554 2554 108 109 GUAAAA SSMAAA OOOOxx 488 8599 0 0 8 8 88 488 488 488 488 176 177 USAAAA TSMAAA VVVVxx 825 8600 1 1 5 5 25 825 825 825 825 50 51 TFAAAA USMAAA AAAAxx 678 8601 0 2 8 18 78 678 678 678 678 156 157 CAAAAA VSMAAA HHHHxx 4543 8602 1 3 3 3 43 543 543 4543 4543 86 87 TSAAAA WSMAAA OOOOxx 1699 8603 1 3 9 19 99 699 1699 1699 1699 198 199 JNAAAA XSMAAA VVVVxx 3771 8604 1 3 1 11 71 771 1771 3771 3771 142 143 BPAAAA YSMAAA AAAAxx 1234 8605 0 2 4 14 34 234 1234 1234 1234 68 69 MVAAAA ZSMAAA HHHHxx 4152 8606 0 0 2 12 52 152 152 4152 4152 104 105 SDAAAA ATMAAA OOOOxx 1632 8607 0 0 2 12 32 632 1632 1632 1632 64 65 UKAAAA BTMAAA VVVVxx 4988 8608 0 0 8 8 88 988 988 4988 4988 176 177 WJAAAA CTMAAA AAAAxx 1980 8609 0 0 0 0 80 980 1980 1980 1980 160 161 EYAAAA DTMAAA HHHHxx 7479 8610 1 3 9 19 79 479 1479 2479 7479 158 159 RBAAAA ETMAAA OOOOxx 2586 8611 0 2 6 6 86 586 586 2586 2586 172 173 MVAAAA FTMAAA VVVVxx 5433 8612 1 1 3 13 33 433 1433 433 5433 66 67 ZAAAAA GTMAAA AAAAxx 2261 8613 1 1 1 1 61 261 261 2261 2261 122 123 ZIAAAA HTMAAA HHHHxx 1180 8614 0 0 0 0 80 180 1180 1180 1180 160 161 KTAAAA ITMAAA OOOOxx 3938 8615 0 2 8 18 38 938 1938 3938 3938 76 77 MVAAAA JTMAAA VVVVxx 6714 8616 0 2 4 14 14 714 714 1714 6714 28 29 GYAAAA KTMAAA AAAAxx 2890 8617 0 2 0 10 90 890 890 2890 2890 180 181 EHAAAA LTMAAA HHHHxx 7379 8618 1 3 9 19 79 379 1379 2379 7379 158 159 VXAAAA MTMAAA OOOOxx 5896 8619 0 0 6 16 96 896 1896 896 5896 192 193 USAAAA NTMAAA VVVVxx 5949 8620 1 1 9 9 49 949 1949 949 5949 98 99 VUAAAA OTMAAA AAAAxx 3194 8621 0 2 4 14 94 194 1194 3194 3194 188 189 WSAAAA PTMAAA HHHHxx 9325 8622 1 1 5 5 25 325 1325 4325 9325 50 51 RUAAAA QTMAAA OOOOxx 9531 8623 1 3 1 11 31 531 1531 4531 9531 62 63 PCAAAA RTMAAA VVVVxx 711 8624 1 3 1 11 11 711 711 711 711 22 23 JBAAAA STMAAA AAAAxx 2450 8625 0 2 0 10 50 450 450 2450 2450 100 101 GQAAAA TTMAAA HHHHxx 1929 8626 1 1 9 9 29 929 1929 1929 1929 58 59 FWAAAA UTMAAA OOOOxx 6165 8627 1 1 5 5 65 165 165 1165 6165 130 131 DDAAAA VTMAAA VVVVxx 4050 8628 0 2 0 10 50 50 50 4050 4050 100 101 UZAAAA WTMAAA AAAAxx 9011 8629 1 3 1 11 11 11 1011 4011 9011 22 23 PIAAAA XTMAAA HHHHxx 7916 8630 0 0 6 16 16 916 1916 2916 7916 32 33 MSAAAA YTMAAA OOOOxx 9136 8631 0 0 6 16 36 136 1136 4136 9136 72 73 KNAAAA ZTMAAA VVVVxx 8782 8632 0 2 2 2 82 782 782 3782 8782 164 165 UZAAAA AUMAAA AAAAxx 8491 8633 1 3 1 11 91 491 491 3491 8491 182 183 POAAAA BUMAAA HHHHxx 5114 8634 0 2 4 14 14 114 1114 114 5114 28 29 SOAAAA CUMAAA OOOOxx 5815 8635 1 3 5 15 15 815 1815 815 5815 30 31 RPAAAA DUMAAA VVVVxx 5628 8636 0 0 8 8 28 628 1628 628 5628 56 57 MIAAAA EUMAAA AAAAxx 810 8637 0 2 0 10 10 810 810 810 810 20 21 EFAAAA FUMAAA HHHHxx 6178 8638 0 2 8 18 78 178 178 1178 6178 156 157 QDAAAA GUMAAA OOOOxx 2619 8639 1 3 9 19 19 619 619 2619 2619 38 39 TWAAAA HUMAAA VVVVxx 3340 8640 0 0 0 0 40 340 1340 3340 3340 80 81 MYAAAA IUMAAA AAAAxx 2491 8641 1 3 1 11 91 491 491 2491 2491 182 183 VRAAAA JUMAAA HHHHxx 3574 8642 0 2 4 14 74 574 1574 3574 3574 148 149 MHAAAA KUMAAA OOOOxx 6754 8643 0 2 4 14 54 754 754 1754 6754 108 109 UZAAAA LUMAAA VVVVxx 1566 8644 0 2 6 6 66 566 1566 1566 1566 132 133 GIAAAA MUMAAA AAAAxx 9174 8645 0 2 4 14 74 174 1174 4174 9174 148 149 WOAAAA NUMAAA HHHHxx 1520 8646 0 0 0 0 20 520 1520 1520 1520 40 41 MGAAAA OUMAAA OOOOxx 2691 8647 1 3 1 11 91 691 691 2691 2691 182 183 NZAAAA PUMAAA VVVVxx 6961 8648 1 1 1 1 61 961 961 1961 6961 122 123 THAAAA QUMAAA AAAAxx 5722 8649 0 2 2 2 22 722 1722 722 5722 44 45 CMAAAA RUMAAA HHHHxx 9707 8650 1 3 7 7 7 707 1707 4707 9707 14 15 JJAAAA SUMAAA OOOOxx 2891 8651 1 3 1 11 91 891 891 2891 2891 182 183 FHAAAA TUMAAA VVVVxx 341 8652 1 1 1 1 41 341 341 341 341 82 83 DNAAAA UUMAAA AAAAxx 4690 8653 0 2 0 10 90 690 690 4690 4690 180 181 KYAAAA VUMAAA HHHHxx 7841 8654 1 1 1 1 41 841 1841 2841 7841 82 83 PPAAAA WUMAAA OOOOxx 6615 8655 1 3 5 15 15 615 615 1615 6615 30 31 LUAAAA XUMAAA VVVVxx 9169 8656 1 1 9 9 69 169 1169 4169 9169 138 139 ROAAAA YUMAAA AAAAxx 6689 8657 1 1 9 9 89 689 689 1689 6689 178 179 HXAAAA ZUMAAA HHHHxx 8721 8658 1 1 1 1 21 721 721 3721 8721 42 43 LXAAAA AVMAAA OOOOxx 7508 8659 0 0 8 8 8 508 1508 2508 7508 16 17 UCAAAA BVMAAA VVVVxx 8631 8660 1 3 1 11 31 631 631 3631 8631 62 63 ZTAAAA CVMAAA AAAAxx 480 8661 0 0 0 0 80 480 480 480 480 160 161 MSAAAA DVMAAA HHHHxx 7094 8662 0 2 4 14 94 94 1094 2094 7094 188 189 WMAAAA EVMAAA OOOOxx 319 8663 1 3 9 19 19 319 319 319 319 38 39 HMAAAA FVMAAA VVVVxx 9421 8664 1 1 1 1 21 421 1421 4421 9421 42 43 JYAAAA GVMAAA AAAAxx 4352 8665 0 0 2 12 52 352 352 4352 4352 104 105 KLAAAA HVMAAA HHHHxx 5019 8666 1 3 9 19 19 19 1019 19 5019 38 39 BLAAAA IVMAAA OOOOxx 3956 8667 0 0 6 16 56 956 1956 3956 3956 112 113 EWAAAA JVMAAA VVVVxx 114 8668 0 2 4 14 14 114 114 114 114 28 29 KEAAAA KVMAAA AAAAxx 1196 8669 0 0 6 16 96 196 1196 1196 1196 192 193 AUAAAA LVMAAA HHHHxx 1407 8670 1 3 7 7 7 407 1407 1407 1407 14 15 DCAAAA MVMAAA OOOOxx 7432 8671 0 0 2 12 32 432 1432 2432 7432 64 65 WZAAAA NVMAAA VVVVxx 3141 8672 1 1 1 1 41 141 1141 3141 3141 82 83 VQAAAA OVMAAA AAAAxx 2073 8673 1 1 3 13 73 73 73 2073 2073 146 147 TBAAAA PVMAAA HHHHxx 3400 8674 0 0 0 0 0 400 1400 3400 3400 0 1 UAAAAA QVMAAA OOOOxx 505 8675 1 1 5 5 5 505 505 505 505 10 11 LTAAAA RVMAAA VVVVxx 1263 8676 1 3 3 3 63 263 1263 1263 1263 126 127 PWAAAA SVMAAA AAAAxx 190 8677 0 2 0 10 90 190 190 190 190 180 181 IHAAAA TVMAAA HHHHxx 6686 8678 0 2 6 6 86 686 686 1686 6686 172 173 EXAAAA UVMAAA OOOOxx 9821 8679 1 1 1 1 21 821 1821 4821 9821 42 43 TNAAAA VVMAAA VVVVxx 1119 8680 1 3 9 19 19 119 1119 1119 1119 38 39 BRAAAA WVMAAA AAAAxx 2955 8681 1 3 5 15 55 955 955 2955 2955 110 111 RJAAAA XVMAAA HHHHxx 224 8682 0 0 4 4 24 224 224 224 224 48 49 QIAAAA YVMAAA OOOOxx 7562 8683 0 2 2 2 62 562 1562 2562 7562 124 125 WEAAAA ZVMAAA VVVVxx 8845 8684 1 1 5 5 45 845 845 3845 8845 90 91 FCAAAA AWMAAA AAAAxx 5405 8685 1 1 5 5 5 405 1405 405 5405 10 11 XZAAAA BWMAAA HHHHxx 9192 8686 0 0 2 12 92 192 1192 4192 9192 184 185 OPAAAA CWMAAA OOOOxx 4927 8687 1 3 7 7 27 927 927 4927 4927 54 55 NHAAAA DWMAAA VVVVxx 997 8688 1 1 7 17 97 997 997 997 997 194 195 JMAAAA EWMAAA AAAAxx 989 8689 1 1 9 9 89 989 989 989 989 178 179 BMAAAA FWMAAA HHHHxx 7258 8690 0 2 8 18 58 258 1258 2258 7258 116 117 ETAAAA GWMAAA OOOOxx 6899 8691 1 3 9 19 99 899 899 1899 6899 198 199 JFAAAA HWMAAA VVVVxx 1770 8692 0 2 0 10 70 770 1770 1770 1770 140 141 CQAAAA IWMAAA AAAAxx 4423 8693 1 3 3 3 23 423 423 4423 4423 46 47 DOAAAA JWMAAA HHHHxx 5671 8694 1 3 1 11 71 671 1671 671 5671 142 143 DKAAAA KWMAAA OOOOxx 8393 8695 1 1 3 13 93 393 393 3393 8393 186 187 VKAAAA LWMAAA VVVVxx 4355 8696 1 3 5 15 55 355 355 4355 4355 110 111 NLAAAA MWMAAA AAAAxx 3919 8697 1 3 9 19 19 919 1919 3919 3919 38 39 TUAAAA NWMAAA HHHHxx 338 8698 0 2 8 18 38 338 338 338 338 76 77 ANAAAA OWMAAA OOOOxx 5790 8699 0 2 0 10 90 790 1790 790 5790 180 181 SOAAAA PWMAAA VVVVxx 1452 8700 0 0 2 12 52 452 1452 1452 1452 104 105 WDAAAA QWMAAA AAAAxx 939 8701 1 3 9 19 39 939 939 939 939 78 79 DKAAAA RWMAAA HHHHxx 8913 8702 1 1 3 13 13 913 913 3913 8913 26 27 VEAAAA SWMAAA OOOOxx 7157 8703 1 1 7 17 57 157 1157 2157 7157 114 115 HPAAAA TWMAAA VVVVxx 7240 8704 0 0 0 0 40 240 1240 2240 7240 80 81 MSAAAA UWMAAA AAAAxx 3492 8705 0 0 2 12 92 492 1492 3492 3492 184 185 IEAAAA VWMAAA HHHHxx 3464 8706 0 0 4 4 64 464 1464 3464 3464 128 129 GDAAAA WWMAAA OOOOxx 388 8707 0 0 8 8 88 388 388 388 388 176 177 YOAAAA XWMAAA VVVVxx 4135 8708 1 3 5 15 35 135 135 4135 4135 70 71 BDAAAA YWMAAA AAAAxx 1194 8709 0 2 4 14 94 194 1194 1194 1194 188 189 YTAAAA ZWMAAA HHHHxx 5476 8710 0 0 6 16 76 476 1476 476 5476 152 153 QCAAAA AXMAAA OOOOxx 9844 8711 0 0 4 4 44 844 1844 4844 9844 88 89 QOAAAA BXMAAA VVVVxx 9364 8712 0 0 4 4 64 364 1364 4364 9364 128 129 EWAAAA CXMAAA AAAAxx 5238 8713 0 2 8 18 38 238 1238 238 5238 76 77 MTAAAA DXMAAA HHHHxx 3712 8714 0 0 2 12 12 712 1712 3712 3712 24 25 UMAAAA EXMAAA OOOOxx 6189 8715 1 1 9 9 89 189 189 1189 6189 178 179 BEAAAA FXMAAA VVVVxx 5257 8716 1 1 7 17 57 257 1257 257 5257 114 115 FUAAAA GXMAAA AAAAxx 81 8717 1 1 1 1 81 81 81 81 81 162 163 DDAAAA HXMAAA HHHHxx 3289 8718 1 1 9 9 89 289 1289 3289 3289 178 179 NWAAAA IXMAAA OOOOxx 1177 8719 1 1 7 17 77 177 1177 1177 1177 154 155 HTAAAA JXMAAA VVVVxx 5038 8720 0 2 8 18 38 38 1038 38 5038 76 77 ULAAAA KXMAAA AAAAxx 325 8721 1 1 5 5 25 325 325 325 325 50 51 NMAAAA LXMAAA HHHHxx 7221 8722 1 1 1 1 21 221 1221 2221 7221 42 43 TRAAAA MXMAAA OOOOxx 7123 8723 1 3 3 3 23 123 1123 2123 7123 46 47 ZNAAAA NXMAAA VVVVxx 6364 8724 0 0 4 4 64 364 364 1364 6364 128 129 UKAAAA OXMAAA AAAAxx 4468 8725 0 0 8 8 68 468 468 4468 4468 136 137 WPAAAA PXMAAA HHHHxx 9185 8726 1 1 5 5 85 185 1185 4185 9185 170 171 HPAAAA QXMAAA OOOOxx 4158 8727 0 2 8 18 58 158 158 4158 4158 116 117 YDAAAA RXMAAA VVVVxx 9439 8728 1 3 9 19 39 439 1439 4439 9439 78 79 BZAAAA SXMAAA AAAAxx 7759 8729 1 3 9 19 59 759 1759 2759 7759 118 119 LMAAAA TXMAAA HHHHxx 3325 8730 1 1 5 5 25 325 1325 3325 3325 50 51 XXAAAA UXMAAA OOOOxx 7991 8731 1 3 1 11 91 991 1991 2991 7991 182 183 JVAAAA VXMAAA VVVVxx 1650 8732 0 2 0 10 50 650 1650 1650 1650 100 101 MLAAAA WXMAAA AAAAxx 8395 8733 1 3 5 15 95 395 395 3395 8395 190 191 XKAAAA XXMAAA HHHHxx 286 8734 0 2 6 6 86 286 286 286 286 172 173 ALAAAA YXMAAA OOOOxx 1507 8735 1 3 7 7 7 507 1507 1507 1507 14 15 ZFAAAA ZXMAAA VVVVxx 4122 8736 0 2 2 2 22 122 122 4122 4122 44 45 OCAAAA AYMAAA AAAAxx 2625 8737 1 1 5 5 25 625 625 2625 2625 50 51 ZWAAAA BYMAAA HHHHxx 1140 8738 0 0 0 0 40 140 1140 1140 1140 80 81 WRAAAA CYMAAA OOOOxx 5262 8739 0 2 2 2 62 262 1262 262 5262 124 125 KUAAAA DYMAAA VVVVxx 4919 8740 1 3 9 19 19 919 919 4919 4919 38 39 FHAAAA EYMAAA AAAAxx 7266 8741 0 2 6 6 66 266 1266 2266 7266 132 133 MTAAAA FYMAAA HHHHxx 630 8742 0 2 0 10 30 630 630 630 630 60 61 GYAAAA GYMAAA OOOOxx 2129 8743 1 1 9 9 29 129 129 2129 2129 58 59 XDAAAA HYMAAA VVVVxx 9552 8744 0 0 2 12 52 552 1552 4552 9552 104 105 KDAAAA IYMAAA AAAAxx 3018 8745 0 2 8 18 18 18 1018 3018 3018 36 37 CMAAAA JYMAAA HHHHxx 7145 8746 1 1 5 5 45 145 1145 2145 7145 90 91 VOAAAA KYMAAA OOOOxx 1633 8747 1 1 3 13 33 633 1633 1633 1633 66 67 VKAAAA LYMAAA VVVVxx 7957 8748 1 1 7 17 57 957 1957 2957 7957 114 115 BUAAAA MYMAAA AAAAxx 774 8749 0 2 4 14 74 774 774 774 774 148 149 UDAAAA NYMAAA HHHHxx 9371 8750 1 3 1 11 71 371 1371 4371 9371 142 143 LWAAAA OYMAAA OOOOxx 6007 8751 1 3 7 7 7 7 7 1007 6007 14 15 BXAAAA PYMAAA VVVVxx 5277 8752 1 1 7 17 77 277 1277 277 5277 154 155 ZUAAAA QYMAAA AAAAxx 9426 8753 0 2 6 6 26 426 1426 4426 9426 52 53 OYAAAA RYMAAA HHHHxx 9190 8754 0 2 0 10 90 190 1190 4190 9190 180 181 MPAAAA SYMAAA OOOOxx 8996 8755 0 0 6 16 96 996 996 3996 8996 192 193 AIAAAA TYMAAA VVVVxx 3409 8756 1 1 9 9 9 409 1409 3409 3409 18 19 DBAAAA UYMAAA AAAAxx 7212 8757 0 0 2 12 12 212 1212 2212 7212 24 25 KRAAAA VYMAAA HHHHxx 416 8758 0 0 6 16 16 416 416 416 416 32 33 AQAAAA WYMAAA OOOOxx 7211 8759 1 3 1 11 11 211 1211 2211 7211 22 23 JRAAAA XYMAAA VVVVxx 7454 8760 0 2 4 14 54 454 1454 2454 7454 108 109 SAAAAA YYMAAA AAAAxx 8417 8761 1 1 7 17 17 417 417 3417 8417 34 35 TLAAAA ZYMAAA HHHHxx 5562 8762 0 2 2 2 62 562 1562 562 5562 124 125 YFAAAA AZMAAA OOOOxx 4996 8763 0 0 6 16 96 996 996 4996 4996 192 193 EKAAAA BZMAAA VVVVxx 5718 8764 0 2 8 18 18 718 1718 718 5718 36 37 YLAAAA CZMAAA AAAAxx 7838 8765 0 2 8 18 38 838 1838 2838 7838 76 77 MPAAAA DZMAAA HHHHxx 7715 8766 1 3 5 15 15 715 1715 2715 7715 30 31 TKAAAA EZMAAA OOOOxx 2780 8767 0 0 0 0 80 780 780 2780 2780 160 161 YCAAAA FZMAAA VVVVxx 1013 8768 1 1 3 13 13 13 1013 1013 1013 26 27 ZMAAAA GZMAAA AAAAxx 8465 8769 1 1 5 5 65 465 465 3465 8465 130 131 PNAAAA HZMAAA HHHHxx 7976 8770 0 0 6 16 76 976 1976 2976 7976 152 153 UUAAAA IZMAAA OOOOxx 7150 8771 0 2 0 10 50 150 1150 2150 7150 100 101 APAAAA JZMAAA VVVVxx 6471 8772 1 3 1 11 71 471 471 1471 6471 142 143 XOAAAA KZMAAA AAAAxx 1927 8773 1 3 7 7 27 927 1927 1927 1927 54 55 DWAAAA LZMAAA HHHHxx 227 8774 1 3 7 7 27 227 227 227 227 54 55 TIAAAA MZMAAA OOOOxx 6462 8775 0 2 2 2 62 462 462 1462 6462 124 125 OOAAAA NZMAAA VVVVxx 5227 8776 1 3 7 7 27 227 1227 227 5227 54 55 BTAAAA OZMAAA AAAAxx 1074 8777 0 2 4 14 74 74 1074 1074 1074 148 149 IPAAAA PZMAAA HHHHxx 9448 8778 0 0 8 8 48 448 1448 4448 9448 96 97 KZAAAA QZMAAA OOOOxx 4459 8779 1 3 9 19 59 459 459 4459 4459 118 119 NPAAAA RZMAAA VVVVxx 2478 8780 0 2 8 18 78 478 478 2478 2478 156 157 IRAAAA SZMAAA AAAAxx 5005 8781 1 1 5 5 5 5 1005 5 5005 10 11 NKAAAA TZMAAA HHHHxx 2418 8782 0 2 8 18 18 418 418 2418 2418 36 37 APAAAA UZMAAA OOOOxx 6991 8783 1 3 1 11 91 991 991 1991 6991 182 183 XIAAAA VZMAAA VVVVxx 4729 8784 1 1 9 9 29 729 729 4729 4729 58 59 XZAAAA WZMAAA AAAAxx 3548 8785 0 0 8 8 48 548 1548 3548 3548 96 97 MGAAAA XZMAAA HHHHxx 9616 8786 0 0 6 16 16 616 1616 4616 9616 32 33 WFAAAA YZMAAA OOOOxx 2901 8787 1 1 1 1 1 901 901 2901 2901 2 3 PHAAAA ZZMAAA VVVVxx 10 8788 0 2 0 10 10 10 10 10 10 20 21 KAAAAA AANAAA AAAAxx 2637 8789 1 1 7 17 37 637 637 2637 2637 74 75 LXAAAA BANAAA HHHHxx 6747 8790 1 3 7 7 47 747 747 1747 6747 94 95 NZAAAA CANAAA OOOOxx 797 8791 1 1 7 17 97 797 797 797 797 194 195 REAAAA DANAAA VVVVxx 7609 8792 1 1 9 9 9 609 1609 2609 7609 18 19 RGAAAA EANAAA AAAAxx 8290 8793 0 2 0 10 90 290 290 3290 8290 180 181 WGAAAA FANAAA HHHHxx 8765 8794 1 1 5 5 65 765 765 3765 8765 130 131 DZAAAA GANAAA OOOOxx 8053 8795 1 1 3 13 53 53 53 3053 8053 106 107 TXAAAA HANAAA VVVVxx 5602 8796 0 2 2 2 2 602 1602 602 5602 4 5 MHAAAA IANAAA AAAAxx 3672 8797 0 0 2 12 72 672 1672 3672 3672 144 145 GLAAAA JANAAA HHHHxx 7513 8798 1 1 3 13 13 513 1513 2513 7513 26 27 ZCAAAA KANAAA OOOOxx 3462 8799 0 2 2 2 62 462 1462 3462 3462 124 125 EDAAAA LANAAA VVVVxx 4457 8800 1 1 7 17 57 457 457 4457 4457 114 115 LPAAAA MANAAA AAAAxx 6547 8801 1 3 7 7 47 547 547 1547 6547 94 95 VRAAAA NANAAA HHHHxx 7417 8802 1 1 7 17 17 417 1417 2417 7417 34 35 HZAAAA OANAAA OOOOxx 8641 8803 1 1 1 1 41 641 641 3641 8641 82 83 JUAAAA PANAAA VVVVxx 149 8804 1 1 9 9 49 149 149 149 149 98 99 TFAAAA QANAAA AAAAxx 5041 8805 1 1 1 1 41 41 1041 41 5041 82 83 XLAAAA RANAAA HHHHxx 9232 8806 0 0 2 12 32 232 1232 4232 9232 64 65 CRAAAA SANAAA OOOOxx 3603 8807 1 3 3 3 3 603 1603 3603 3603 6 7 PIAAAA TANAAA VVVVxx 2792 8808 0 0 2 12 92 792 792 2792 2792 184 185 KDAAAA UANAAA AAAAxx 6620 8809 0 0 0 0 20 620 620 1620 6620 40 41 QUAAAA VANAAA HHHHxx 4000 8810 0 0 0 0 0 0 0 4000 4000 0 1 WXAAAA WANAAA OOOOxx 659 8811 1 3 9 19 59 659 659 659 659 118 119 JZAAAA XANAAA VVVVxx 8174 8812 0 2 4 14 74 174 174 3174 8174 148 149 KCAAAA YANAAA AAAAxx 4599 8813 1 3 9 19 99 599 599 4599 4599 198 199 XUAAAA ZANAAA HHHHxx 7851 8814 1 3 1 11 51 851 1851 2851 7851 102 103 ZPAAAA ABNAAA OOOOxx 6284 8815 0 0 4 4 84 284 284 1284 6284 168 169 SHAAAA BBNAAA VVVVxx 7116 8816 0 0 6 16 16 116 1116 2116 7116 32 33 SNAAAA CBNAAA AAAAxx 5595 8817 1 3 5 15 95 595 1595 595 5595 190 191 FHAAAA DBNAAA HHHHxx 2903 8818 1 3 3 3 3 903 903 2903 2903 6 7 RHAAAA EBNAAA OOOOxx 5948 8819 0 0 8 8 48 948 1948 948 5948 96 97 UUAAAA FBNAAA VVVVxx 225 8820 1 1 5 5 25 225 225 225 225 50 51 RIAAAA GBNAAA AAAAxx 524 8821 0 0 4 4 24 524 524 524 524 48 49 EUAAAA HBNAAA HHHHxx 7639 8822 1 3 9 19 39 639 1639 2639 7639 78 79 VHAAAA IBNAAA OOOOxx 7297 8823 1 1 7 17 97 297 1297 2297 7297 194 195 RUAAAA JBNAAA VVVVxx 2606 8824 0 2 6 6 6 606 606 2606 2606 12 13 GWAAAA KBNAAA AAAAxx 4771 8825 1 3 1 11 71 771 771 4771 4771 142 143 NBAAAA LBNAAA HHHHxx 8162 8826 0 2 2 2 62 162 162 3162 8162 124 125 YBAAAA MBNAAA OOOOxx 8999 8827 1 3 9 19 99 999 999 3999 8999 198 199 DIAAAA NBNAAA VVVVxx 2309 8828 1 1 9 9 9 309 309 2309 2309 18 19 VKAAAA OBNAAA AAAAxx 3594 8829 0 2 4 14 94 594 1594 3594 3594 188 189 GIAAAA PBNAAA HHHHxx 6092 8830 0 0 2 12 92 92 92 1092 6092 184 185 IAAAAA QBNAAA OOOOxx 7467 8831 1 3 7 7 67 467 1467 2467 7467 134 135 FBAAAA RBNAAA VVVVxx 6986 8832 0 2 6 6 86 986 986 1986 6986 172 173 SIAAAA SBNAAA AAAAxx 9898 8833 0 2 8 18 98 898 1898 4898 9898 196 197 SQAAAA TBNAAA HHHHxx 9578 8834 0 2 8 18 78 578 1578 4578 9578 156 157 KEAAAA UBNAAA OOOOxx 156 8835 0 0 6 16 56 156 156 156 156 112 113 AGAAAA VBNAAA VVVVxx 5810 8836 0 2 0 10 10 810 1810 810 5810 20 21 MPAAAA WBNAAA AAAAxx 790 8837 0 2 0 10 90 790 790 790 790 180 181 KEAAAA XBNAAA HHHHxx 6840 8838 0 0 0 0 40 840 840 1840 6840 80 81 CDAAAA YBNAAA OOOOxx 6725 8839 1 1 5 5 25 725 725 1725 6725 50 51 RYAAAA ZBNAAA VVVVxx 5528 8840 0 0 8 8 28 528 1528 528 5528 56 57 QEAAAA ACNAAA AAAAxx 4120 8841 0 0 0 0 20 120 120 4120 4120 40 41 MCAAAA BCNAAA HHHHxx 6694 8842 0 2 4 14 94 694 694 1694 6694 188 189 MXAAAA CCNAAA OOOOxx 3552 8843 0 0 2 12 52 552 1552 3552 3552 104 105 QGAAAA DCNAAA VVVVxx 1478 8844 0 2 8 18 78 478 1478 1478 1478 156 157 WEAAAA ECNAAA AAAAxx 8084 8845 0 0 4 4 84 84 84 3084 8084 168 169 YYAAAA FCNAAA HHHHxx 7578 8846 0 2 8 18 78 578 1578 2578 7578 156 157 MFAAAA GCNAAA OOOOxx 6314 8847 0 2 4 14 14 314 314 1314 6314 28 29 WIAAAA HCNAAA VVVVxx 6123 8848 1 3 3 3 23 123 123 1123 6123 46 47 NBAAAA ICNAAA AAAAxx 9443 8849 1 3 3 3 43 443 1443 4443 9443 86 87 FZAAAA JCNAAA HHHHxx 9628 8850 0 0 8 8 28 628 1628 4628 9628 56 57 IGAAAA KCNAAA OOOOxx 8508 8851 0 0 8 8 8 508 508 3508 8508 16 17 GPAAAA LCNAAA VVVVxx 5552 8852 0 0 2 12 52 552 1552 552 5552 104 105 OFAAAA MCNAAA AAAAxx 5327 8853 1 3 7 7 27 327 1327 327 5327 54 55 XWAAAA NCNAAA HHHHxx 7771 8854 1 3 1 11 71 771 1771 2771 7771 142 143 XMAAAA OCNAAA OOOOxx 8932 8855 0 0 2 12 32 932 932 3932 8932 64 65 OFAAAA PCNAAA VVVVxx 3526 8856 0 2 6 6 26 526 1526 3526 3526 52 53 QFAAAA QCNAAA AAAAxx 4340 8857 0 0 0 0 40 340 340 4340 4340 80 81 YKAAAA RCNAAA HHHHxx 9419 8858 1 3 9 19 19 419 1419 4419 9419 38 39 HYAAAA SCNAAA OOOOxx 8421 8859 1 1 1 1 21 421 421 3421 8421 42 43 XLAAAA TCNAAA VVVVxx 7431 8860 1 3 1 11 31 431 1431 2431 7431 62 63 VZAAAA UCNAAA AAAAxx 172 8861 0 0 2 12 72 172 172 172 172 144 145 QGAAAA VCNAAA HHHHxx 3279 8862 1 3 9 19 79 279 1279 3279 3279 158 159 DWAAAA WCNAAA OOOOxx 1508 8863 0 0 8 8 8 508 1508 1508 1508 16 17 AGAAAA XCNAAA VVVVxx 7091 8864 1 3 1 11 91 91 1091 2091 7091 182 183 TMAAAA YCNAAA AAAAxx 1419 8865 1 3 9 19 19 419 1419 1419 1419 38 39 PCAAAA ZCNAAA HHHHxx 3032 8866 0 0 2 12 32 32 1032 3032 3032 64 65 QMAAAA ADNAAA OOOOxx 8683 8867 1 3 3 3 83 683 683 3683 8683 166 167 ZVAAAA BDNAAA VVVVxx 4763 8868 1 3 3 3 63 763 763 4763 4763 126 127 FBAAAA CDNAAA AAAAxx 4424 8869 0 0 4 4 24 424 424 4424 4424 48 49 EOAAAA DDNAAA HHHHxx 8640 8870 0 0 0 0 40 640 640 3640 8640 80 81 IUAAAA EDNAAA OOOOxx 7187 8871 1 3 7 7 87 187 1187 2187 7187 174 175 LQAAAA FDNAAA VVVVxx 6247 8872 1 3 7 7 47 247 247 1247 6247 94 95 HGAAAA GDNAAA AAAAxx 7340 8873 0 0 0 0 40 340 1340 2340 7340 80 81 IWAAAA HDNAAA HHHHxx 182 8874 0 2 2 2 82 182 182 182 182 164 165 AHAAAA IDNAAA OOOOxx 2948 8875 0 0 8 8 48 948 948 2948 2948 96 97 KJAAAA JDNAAA VVVVxx 9462 8876 0 2 2 2 62 462 1462 4462 9462 124 125 YZAAAA KDNAAA AAAAxx 5997 8877 1 1 7 17 97 997 1997 997 5997 194 195 RWAAAA LDNAAA HHHHxx 5608 8878 0 0 8 8 8 608 1608 608 5608 16 17 SHAAAA MDNAAA OOOOxx 1472 8879 0 0 2 12 72 472 1472 1472 1472 144 145 QEAAAA NDNAAA VVVVxx 277 8880 1 1 7 17 77 277 277 277 277 154 155 RKAAAA ODNAAA AAAAxx 4807 8881 1 3 7 7 7 807 807 4807 4807 14 15 XCAAAA PDNAAA HHHHxx 4969 8882 1 1 9 9 69 969 969 4969 4969 138 139 DJAAAA QDNAAA OOOOxx 5611 8883 1 3 1 11 11 611 1611 611 5611 22 23 VHAAAA RDNAAA VVVVxx 372 8884 0 0 2 12 72 372 372 372 372 144 145 IOAAAA SDNAAA AAAAxx 6666 8885 0 2 6 6 66 666 666 1666 6666 132 133 KWAAAA TDNAAA HHHHxx 476 8886 0 0 6 16 76 476 476 476 476 152 153 ISAAAA UDNAAA OOOOxx 5225 8887 1 1 5 5 25 225 1225 225 5225 50 51 ZSAAAA VDNAAA VVVVxx 5143 8888 1 3 3 3 43 143 1143 143 5143 86 87 VPAAAA WDNAAA AAAAxx 1853 8889 1 1 3 13 53 853 1853 1853 1853 106 107 HTAAAA XDNAAA HHHHxx 675 8890 1 3 5 15 75 675 675 675 675 150 151 ZZAAAA YDNAAA OOOOxx 5643 8891 1 3 3 3 43 643 1643 643 5643 86 87 BJAAAA ZDNAAA VVVVxx 5317 8892 1 1 7 17 17 317 1317 317 5317 34 35 NWAAAA AENAAA AAAAxx 8102 8893 0 2 2 2 2 102 102 3102 8102 4 5 QZAAAA BENAAA HHHHxx 978 8894 0 2 8 18 78 978 978 978 978 156 157 QLAAAA CENAAA OOOOxx 4620 8895 0 0 0 0 20 620 620 4620 4620 40 41 SVAAAA DENAAA VVVVxx 151 8896 1 3 1 11 51 151 151 151 151 102 103 VFAAAA EENAAA AAAAxx 972 8897 0 0 2 12 72 972 972 972 972 144 145 KLAAAA FENAAA HHHHxx 6820 8898 0 0 0 0 20 820 820 1820 6820 40 41 ICAAAA GENAAA OOOOxx 7387 8899 1 3 7 7 87 387 1387 2387 7387 174 175 DYAAAA HENAAA VVVVxx 9634 8900 0 2 4 14 34 634 1634 4634 9634 68 69 OGAAAA IENAAA AAAAxx 6308 8901 0 0 8 8 8 308 308 1308 6308 16 17 QIAAAA JENAAA HHHHxx 8323 8902 1 3 3 3 23 323 323 3323 8323 46 47 DIAAAA KENAAA OOOOxx 6672 8903 0 0 2 12 72 672 672 1672 6672 144 145 QWAAAA LENAAA VVVVxx 8283 8904 1 3 3 3 83 283 283 3283 8283 166 167 PGAAAA MENAAA AAAAxx 7996 8905 0 0 6 16 96 996 1996 2996 7996 192 193 OVAAAA NENAAA HHHHxx 6488 8906 0 0 8 8 88 488 488 1488 6488 176 177 OPAAAA OENAAA OOOOxx 2365 8907 1 1 5 5 65 365 365 2365 2365 130 131 ZMAAAA PENAAA VVVVxx 9746 8908 0 2 6 6 46 746 1746 4746 9746 92 93 WKAAAA QENAAA AAAAxx 8605 8909 1 1 5 5 5 605 605 3605 8605 10 11 ZSAAAA RENAAA HHHHxx 3342 8910 0 2 2 2 42 342 1342 3342 3342 84 85 OYAAAA SENAAA OOOOxx 8429 8911 1 1 9 9 29 429 429 3429 8429 58 59 FMAAAA TENAAA VVVVxx 1162 8912 0 2 2 2 62 162 1162 1162 1162 124 125 SSAAAA UENAAA AAAAxx 531 8913 1 3 1 11 31 531 531 531 531 62 63 LUAAAA VENAAA HHHHxx 8408 8914 0 0 8 8 8 408 408 3408 8408 16 17 KLAAAA WENAAA OOOOxx 8862 8915 0 2 2 2 62 862 862 3862 8862 124 125 WCAAAA XENAAA VVVVxx 5843 8916 1 3 3 3 43 843 1843 843 5843 86 87 TQAAAA YENAAA AAAAxx 8704 8917 0 0 4 4 4 704 704 3704 8704 8 9 UWAAAA ZENAAA HHHHxx 7070 8918 0 2 0 10 70 70 1070 2070 7070 140 141 YLAAAA AFNAAA OOOOxx 9119 8919 1 3 9 19 19 119 1119 4119 9119 38 39 TMAAAA BFNAAA VVVVxx 8344 8920 0 0 4 4 44 344 344 3344 8344 88 89 YIAAAA CFNAAA AAAAxx 8979 8921 1 3 9 19 79 979 979 3979 8979 158 159 JHAAAA DFNAAA HHHHxx 2971 8922 1 3 1 11 71 971 971 2971 2971 142 143 HKAAAA EFNAAA OOOOxx 7700 8923 0 0 0 0 0 700 1700 2700 7700 0 1 EKAAAA FFNAAA VVVVxx 8280 8924 0 0 0 0 80 280 280 3280 8280 160 161 MGAAAA GFNAAA AAAAxx 9096 8925 0 0 6 16 96 96 1096 4096 9096 192 193 WLAAAA HFNAAA HHHHxx 99 8926 1 3 9 19 99 99 99 99 99 198 199 VDAAAA IFNAAA OOOOxx 6696 8927 0 0 6 16 96 696 696 1696 6696 192 193 OXAAAA JFNAAA VVVVxx 9490 8928 0 2 0 10 90 490 1490 4490 9490 180 181 ABAAAA KFNAAA AAAAxx 9073 8929 1 1 3 13 73 73 1073 4073 9073 146 147 ZKAAAA LFNAAA HHHHxx 1861 8930 1 1 1 1 61 861 1861 1861 1861 122 123 PTAAAA MFNAAA OOOOxx 4413 8931 1 1 3 13 13 413 413 4413 4413 26 27 TNAAAA NFNAAA VVVVxx 6002 8932 0 2 2 2 2 2 2 1002 6002 4 5 WWAAAA OFNAAA AAAAxx 439 8933 1 3 9 19 39 439 439 439 439 78 79 XQAAAA PFNAAA HHHHxx 5449 8934 1 1 9 9 49 449 1449 449 5449 98 99 PBAAAA QFNAAA OOOOxx 9737 8935 1 1 7 17 37 737 1737 4737 9737 74 75 NKAAAA RFNAAA VVVVxx 1898 8936 0 2 8 18 98 898 1898 1898 1898 196 197 AVAAAA SFNAAA AAAAxx 4189 8937 1 1 9 9 89 189 189 4189 4189 178 179 DFAAAA TFNAAA HHHHxx 1408 8938 0 0 8 8 8 408 1408 1408 1408 16 17 ECAAAA UFNAAA OOOOxx 394 8939 0 2 4 14 94 394 394 394 394 188 189 EPAAAA VFNAAA VVVVxx 1935 8940 1 3 5 15 35 935 1935 1935 1935 70 71 LWAAAA WFNAAA AAAAxx 3965 8941 1 1 5 5 65 965 1965 3965 3965 130 131 NWAAAA XFNAAA HHHHxx 6821 8942 1 1 1 1 21 821 821 1821 6821 42 43 JCAAAA YFNAAA OOOOxx 349 8943 1 1 9 9 49 349 349 349 349 98 99 LNAAAA ZFNAAA VVVVxx 8428 8944 0 0 8 8 28 428 428 3428 8428 56 57 EMAAAA AGNAAA AAAAxx 8200 8945 0 0 0 0 0 200 200 3200 8200 0 1 KDAAAA BGNAAA HHHHxx 1737 8946 1 1 7 17 37 737 1737 1737 1737 74 75 VOAAAA CGNAAA OOOOxx 6516 8947 0 0 6 16 16 516 516 1516 6516 32 33 QQAAAA DGNAAA VVVVxx 5441 8948 1 1 1 1 41 441 1441 441 5441 82 83 HBAAAA EGNAAA AAAAxx 5999 8949 1 3 9 19 99 999 1999 999 5999 198 199 TWAAAA FGNAAA HHHHxx 1539 8950 1 3 9 19 39 539 1539 1539 1539 78 79 FHAAAA GGNAAA OOOOxx 9067 8951 1 3 7 7 67 67 1067 4067 9067 134 135 TKAAAA HGNAAA VVVVxx 4061 8952 1 1 1 1 61 61 61 4061 4061 122 123 FAAAAA IGNAAA AAAAxx 1642 8953 0 2 2 2 42 642 1642 1642 1642 84 85 ELAAAA JGNAAA HHHHxx 4657 8954 1 1 7 17 57 657 657 4657 4657 114 115 DXAAAA KGNAAA OOOOxx 9934 8955 0 2 4 14 34 934 1934 4934 9934 68 69 CSAAAA LGNAAA VVVVxx 6385 8956 1 1 5 5 85 385 385 1385 6385 170 171 PLAAAA MGNAAA AAAAxx 6775 8957 1 3 5 15 75 775 775 1775 6775 150 151 PAAAAA NGNAAA HHHHxx 3873 8958 1 1 3 13 73 873 1873 3873 3873 146 147 ZSAAAA OGNAAA OOOOxx 3862 8959 0 2 2 2 62 862 1862 3862 3862 124 125 OSAAAA PGNAAA VVVVxx 1224 8960 0 0 4 4 24 224 1224 1224 1224 48 49 CVAAAA QGNAAA AAAAxx 4483 8961 1 3 3 3 83 483 483 4483 4483 166 167 LQAAAA RGNAAA HHHHxx 3685 8962 1 1 5 5 85 685 1685 3685 3685 170 171 TLAAAA SGNAAA OOOOxx 6082 8963 0 2 2 2 82 82 82 1082 6082 164 165 YZAAAA TGNAAA VVVVxx 7798 8964 0 2 8 18 98 798 1798 2798 7798 196 197 YNAAAA UGNAAA AAAAxx 9039 8965 1 3 9 19 39 39 1039 4039 9039 78 79 RJAAAA VGNAAA HHHHxx 985 8966 1 1 5 5 85 985 985 985 985 170 171 XLAAAA WGNAAA OOOOxx 5389 8967 1 1 9 9 89 389 1389 389 5389 178 179 HZAAAA XGNAAA VVVVxx 1716 8968 0 0 6 16 16 716 1716 1716 1716 32 33 AOAAAA YGNAAA AAAAxx 4209 8969 1 1 9 9 9 209 209 4209 4209 18 19 XFAAAA ZGNAAA HHHHxx 746 8970 0 2 6 6 46 746 746 746 746 92 93 SCAAAA AHNAAA OOOOxx 6295 8971 1 3 5 15 95 295 295 1295 6295 190 191 DIAAAA BHNAAA VVVVxx 9754 8972 0 2 4 14 54 754 1754 4754 9754 108 109 ELAAAA CHNAAA AAAAxx 2336 8973 0 0 6 16 36 336 336 2336 2336 72 73 WLAAAA DHNAAA HHHHxx 3701 8974 1 1 1 1 1 701 1701 3701 3701 2 3 JMAAAA EHNAAA OOOOxx 3551 8975 1 3 1 11 51 551 1551 3551 3551 102 103 PGAAAA FHNAAA VVVVxx 8516 8976 0 0 6 16 16 516 516 3516 8516 32 33 OPAAAA GHNAAA AAAAxx 9290 8977 0 2 0 10 90 290 1290 4290 9290 180 181 ITAAAA HHNAAA HHHHxx 5686 8978 0 2 6 6 86 686 1686 686 5686 172 173 SKAAAA IHNAAA OOOOxx 2893 8979 1 1 3 13 93 893 893 2893 2893 186 187 HHAAAA JHNAAA VVVVxx 6279 8980 1 3 9 19 79 279 279 1279 6279 158 159 NHAAAA KHNAAA AAAAxx 2278 8981 0 2 8 18 78 278 278 2278 2278 156 157 QJAAAA LHNAAA HHHHxx 1618 8982 0 2 8 18 18 618 1618 1618 1618 36 37 GKAAAA MHNAAA OOOOxx 3450 8983 0 2 0 10 50 450 1450 3450 3450 100 101 SCAAAA NHNAAA VVVVxx 8857 8984 1 1 7 17 57 857 857 3857 8857 114 115 RCAAAA OHNAAA AAAAxx 1005 8985 1 1 5 5 5 5 1005 1005 1005 10 11 RMAAAA PHNAAA HHHHxx 4727 8986 1 3 7 7 27 727 727 4727 4727 54 55 VZAAAA QHNAAA OOOOxx 7617 8987 1 1 7 17 17 617 1617 2617 7617 34 35 ZGAAAA RHNAAA VVVVxx 2021 8988 1 1 1 1 21 21 21 2021 2021 42 43 TZAAAA SHNAAA AAAAxx 9124 8989 0 0 4 4 24 124 1124 4124 9124 48 49 YMAAAA THNAAA HHHHxx 3175 8990 1 3 5 15 75 175 1175 3175 3175 150 151 DSAAAA UHNAAA OOOOxx 2949 8991 1 1 9 9 49 949 949 2949 2949 98 99 LJAAAA VHNAAA VVVVxx 2424 8992 0 0 4 4 24 424 424 2424 2424 48 49 GPAAAA WHNAAA AAAAxx 4791 8993 1 3 1 11 91 791 791 4791 4791 182 183 HCAAAA XHNAAA HHHHxx 7500 8994 0 0 0 0 0 500 1500 2500 7500 0 1 MCAAAA YHNAAA OOOOxx 4893 8995 1 1 3 13 93 893 893 4893 4893 186 187 FGAAAA ZHNAAA VVVVxx 121 8996 1 1 1 1 21 121 121 121 121 42 43 REAAAA AINAAA AAAAxx 1965 8997 1 1 5 5 65 965 1965 1965 1965 130 131 PXAAAA BINAAA HHHHxx 2972 8998 0 0 2 12 72 972 972 2972 2972 144 145 IKAAAA CINAAA OOOOxx 662 8999 0 2 2 2 62 662 662 662 662 124 125 MZAAAA DINAAA VVVVxx 7074 9000 0 2 4 14 74 74 1074 2074 7074 148 149 CMAAAA EINAAA AAAAxx 981 9001 1 1 1 1 81 981 981 981 981 162 163 TLAAAA FINAAA HHHHxx 3520 9002 0 0 0 0 20 520 1520 3520 3520 40 41 KFAAAA GINAAA OOOOxx 6540 9003 0 0 0 0 40 540 540 1540 6540 80 81 ORAAAA HINAAA VVVVxx 6648 9004 0 0 8 8 48 648 648 1648 6648 96 97 SVAAAA IINAAA AAAAxx 7076 9005 0 0 6 16 76 76 1076 2076 7076 152 153 EMAAAA JINAAA HHHHxx 6919 9006 1 3 9 19 19 919 919 1919 6919 38 39 DGAAAA KINAAA OOOOxx 1108 9007 0 0 8 8 8 108 1108 1108 1108 16 17 QQAAAA LINAAA VVVVxx 317 9008 1 1 7 17 17 317 317 317 317 34 35 FMAAAA MINAAA AAAAxx 3483 9009 1 3 3 3 83 483 1483 3483 3483 166 167 ZDAAAA NINAAA HHHHxx 6764 9010 0 0 4 4 64 764 764 1764 6764 128 129 EAAAAA OINAAA OOOOxx 1235 9011 1 3 5 15 35 235 1235 1235 1235 70 71 NVAAAA PINAAA VVVVxx 7121 9012 1 1 1 1 21 121 1121 2121 7121 42 43 XNAAAA QINAAA AAAAxx 426 9013 0 2 6 6 26 426 426 426 426 52 53 KQAAAA RINAAA HHHHxx 6880 9014 0 0 0 0 80 880 880 1880 6880 160 161 QEAAAA SINAAA OOOOxx 5401 9015 1 1 1 1 1 401 1401 401 5401 2 3 TZAAAA TINAAA VVVVxx 7323 9016 1 3 3 3 23 323 1323 2323 7323 46 47 RVAAAA UINAAA AAAAxx 9751 9017 1 3 1 11 51 751 1751 4751 9751 102 103 BLAAAA VINAAA HHHHxx 3436 9018 0 0 6 16 36 436 1436 3436 3436 72 73 ECAAAA WINAAA OOOOxx 7319 9019 1 3 9 19 19 319 1319 2319 7319 38 39 NVAAAA XINAAA VVVVxx 7882 9020 0 2 2 2 82 882 1882 2882 7882 164 165 ERAAAA YINAAA AAAAxx 8260 9021 0 0 0 0 60 260 260 3260 8260 120 121 SFAAAA ZINAAA HHHHxx 9758 9022 0 2 8 18 58 758 1758 4758 9758 116 117 ILAAAA AJNAAA OOOOxx 4205 9023 1 1 5 5 5 205 205 4205 4205 10 11 TFAAAA BJNAAA VVVVxx 8884 9024 0 0 4 4 84 884 884 3884 8884 168 169 SDAAAA CJNAAA AAAAxx 1112 9025 0 0 2 12 12 112 1112 1112 1112 24 25 UQAAAA DJNAAA HHHHxx 2186 9026 0 2 6 6 86 186 186 2186 2186 172 173 CGAAAA EJNAAA OOOOxx 8666 9027 0 2 6 6 66 666 666 3666 8666 132 133 IVAAAA FJNAAA VVVVxx 4325 9028 1 1 5 5 25 325 325 4325 4325 50 51 JKAAAA GJNAAA AAAAxx 4912 9029 0 0 2 12 12 912 912 4912 4912 24 25 YGAAAA HJNAAA HHHHxx 6497 9030 1 1 7 17 97 497 497 1497 6497 194 195 XPAAAA IJNAAA OOOOxx 9072 9031 0 0 2 12 72 72 1072 4072 9072 144 145 YKAAAA JJNAAA VVVVxx 8899 9032 1 3 9 19 99 899 899 3899 8899 198 199 HEAAAA KJNAAA AAAAxx 5619 9033 1 3 9 19 19 619 1619 619 5619 38 39 DIAAAA LJNAAA HHHHxx 4110 9034 0 2 0 10 10 110 110 4110 4110 20 21 CCAAAA MJNAAA OOOOxx 7025 9035 1 1 5 5 25 25 1025 2025 7025 50 51 FKAAAA NJNAAA VVVVxx 5605 9036 1 1 5 5 5 605 1605 605 5605 10 11 PHAAAA OJNAAA AAAAxx 2572 9037 0 0 2 12 72 572 572 2572 2572 144 145 YUAAAA PJNAAA HHHHxx 3895 9038 1 3 5 15 95 895 1895 3895 3895 190 191 VTAAAA QJNAAA OOOOxx 9138 9039 0 2 8 18 38 138 1138 4138 9138 76 77 MNAAAA RJNAAA VVVVxx 4713 9040 1 1 3 13 13 713 713 4713 4713 26 27 HZAAAA SJNAAA AAAAxx 6079 9041 1 3 9 19 79 79 79 1079 6079 158 159 VZAAAA TJNAAA HHHHxx 8898 9042 0 2 8 18 98 898 898 3898 8898 196 197 GEAAAA UJNAAA OOOOxx 2650 9043 0 2 0 10 50 650 650 2650 2650 100 101 YXAAAA VJNAAA VVVVxx 5316 9044 0 0 6 16 16 316 1316 316 5316 32 33 MWAAAA WJNAAA AAAAxx 5133 9045 1 1 3 13 33 133 1133 133 5133 66 67 LPAAAA XJNAAA HHHHxx 2184 9046 0 0 4 4 84 184 184 2184 2184 168 169 AGAAAA YJNAAA OOOOxx 2728 9047 0 0 8 8 28 728 728 2728 2728 56 57 YAAAAA ZJNAAA VVVVxx 6737 9048 1 1 7 17 37 737 737 1737 6737 74 75 DZAAAA AKNAAA AAAAxx 1128 9049 0 0 8 8 28 128 1128 1128 1128 56 57 KRAAAA BKNAAA HHHHxx 9662 9050 0 2 2 2 62 662 1662 4662 9662 124 125 QHAAAA CKNAAA OOOOxx 9384 9051 0 0 4 4 84 384 1384 4384 9384 168 169 YWAAAA DKNAAA VVVVxx 4576 9052 0 0 6 16 76 576 576 4576 4576 152 153 AUAAAA EKNAAA AAAAxx 9613 9053 1 1 3 13 13 613 1613 4613 9613 26 27 TFAAAA FKNAAA HHHHxx 4001 9054 1 1 1 1 1 1 1 4001 4001 2 3 XXAAAA GKNAAA OOOOxx 3628 9055 0 0 8 8 28 628 1628 3628 3628 56 57 OJAAAA HKNAAA VVVVxx 6968 9056 0 0 8 8 68 968 968 1968 6968 136 137 AIAAAA IKNAAA AAAAxx 6491 9057 1 3 1 11 91 491 491 1491 6491 182 183 RPAAAA JKNAAA HHHHxx 1265 9058 1 1 5 5 65 265 1265 1265 1265 130 131 RWAAAA KKNAAA OOOOxx 6128 9059 0 0 8 8 28 128 128 1128 6128 56 57 SBAAAA LKNAAA VVVVxx 4274 9060 0 2 4 14 74 274 274 4274 4274 148 149 KIAAAA MKNAAA AAAAxx 3598 9061 0 2 8 18 98 598 1598 3598 3598 196 197 KIAAAA NKNAAA HHHHxx 7961 9062 1 1 1 1 61 961 1961 2961 7961 122 123 FUAAAA OKNAAA OOOOxx 2643 9063 1 3 3 3 43 643 643 2643 2643 86 87 RXAAAA PKNAAA VVVVxx 4547 9064 1 3 7 7 47 547 547 4547 4547 94 95 XSAAAA QKNAAA AAAAxx 3568 9065 0 0 8 8 68 568 1568 3568 3568 136 137 GHAAAA RKNAAA HHHHxx 8954 9066 0 2 4 14 54 954 954 3954 8954 108 109 KGAAAA SKNAAA OOOOxx 8802 9067 0 2 2 2 2 802 802 3802 8802 4 5 OAAAAA TKNAAA VVVVxx 7829 9068 1 1 9 9 29 829 1829 2829 7829 58 59 DPAAAA UKNAAA AAAAxx 1008 9069 0 0 8 8 8 8 1008 1008 1008 16 17 UMAAAA VKNAAA HHHHxx 3627 9070 1 3 7 7 27 627 1627 3627 3627 54 55 NJAAAA WKNAAA OOOOxx 3999 9071 1 3 9 19 99 999 1999 3999 3999 198 199 VXAAAA XKNAAA VVVVxx 7697 9072 1 1 7 17 97 697 1697 2697 7697 194 195 BKAAAA YKNAAA AAAAxx 9380 9073 0 0 0 0 80 380 1380 4380 9380 160 161 UWAAAA ZKNAAA HHHHxx 2707 9074 1 3 7 7 7 707 707 2707 2707 14 15 DAAAAA ALNAAA OOOOxx 4430 9075 0 2 0 10 30 430 430 4430 4430 60 61 KOAAAA BLNAAA VVVVxx 6440 9076 0 0 0 0 40 440 440 1440 6440 80 81 SNAAAA CLNAAA AAAAxx 9958 9077 0 2 8 18 58 958 1958 4958 9958 116 117 ATAAAA DLNAAA HHHHxx 7592 9078 0 0 2 12 92 592 1592 2592 7592 184 185 AGAAAA ELNAAA OOOOxx 7852 9079 0 0 2 12 52 852 1852 2852 7852 104 105 AQAAAA FLNAAA VVVVxx 9253 9080 1 1 3 13 53 253 1253 4253 9253 106 107 XRAAAA GLNAAA AAAAxx 5910 9081 0 2 0 10 10 910 1910 910 5910 20 21 ITAAAA HLNAAA HHHHxx 7487 9082 1 3 7 7 87 487 1487 2487 7487 174 175 ZBAAAA ILNAAA OOOOxx 6324 9083 0 0 4 4 24 324 324 1324 6324 48 49 GJAAAA JLNAAA VVVVxx 5792 9084 0 0 2 12 92 792 1792 792 5792 184 185 UOAAAA KLNAAA AAAAxx 7390 9085 0 2 0 10 90 390 1390 2390 7390 180 181 GYAAAA LLNAAA HHHHxx 8534 9086 0 2 4 14 34 534 534 3534 8534 68 69 GQAAAA MLNAAA OOOOxx 2690 9087 0 2 0 10 90 690 690 2690 2690 180 181 MZAAAA NLNAAA VVVVxx 3992 9088 0 0 2 12 92 992 1992 3992 3992 184 185 OXAAAA OLNAAA AAAAxx 6928 9089 0 0 8 8 28 928 928 1928 6928 56 57 MGAAAA PLNAAA HHHHxx 7815 9090 1 3 5 15 15 815 1815 2815 7815 30 31 POAAAA QLNAAA OOOOxx 9477 9091 1 1 7 17 77 477 1477 4477 9477 154 155 NAAAAA RLNAAA VVVVxx 497 9092 1 1 7 17 97 497 497 497 497 194 195 DTAAAA SLNAAA AAAAxx 7532 9093 0 0 2 12 32 532 1532 2532 7532 64 65 SDAAAA TLNAAA HHHHxx 9838 9094 0 2 8 18 38 838 1838 4838 9838 76 77 KOAAAA ULNAAA OOOOxx 1557 9095 1 1 7 17 57 557 1557 1557 1557 114 115 XHAAAA VLNAAA VVVVxx 2467 9096 1 3 7 7 67 467 467 2467 2467 134 135 XQAAAA WLNAAA AAAAxx 2367 9097 1 3 7 7 67 367 367 2367 2367 134 135 BNAAAA XLNAAA HHHHxx 5677 9098 1 1 7 17 77 677 1677 677 5677 154 155 JKAAAA YLNAAA OOOOxx 6193 9099 1 1 3 13 93 193 193 1193 6193 186 187 FEAAAA ZLNAAA VVVVxx 7126 9100 0 2 6 6 26 126 1126 2126 7126 52 53 COAAAA AMNAAA AAAAxx 5264 9101 0 0 4 4 64 264 1264 264 5264 128 129 MUAAAA BMNAAA HHHHxx 850 9102 0 2 0 10 50 850 850 850 850 100 101 SGAAAA CMNAAA OOOOxx 4854 9103 0 2 4 14 54 854 854 4854 4854 108 109 SEAAAA DMNAAA VVVVxx 4414 9104 0 2 4 14 14 414 414 4414 4414 28 29 UNAAAA EMNAAA AAAAxx 8971 9105 1 3 1 11 71 971 971 3971 8971 142 143 BHAAAA FMNAAA HHHHxx 9240 9106 0 0 0 0 40 240 1240 4240 9240 80 81 KRAAAA GMNAAA OOOOxx 7341 9107 1 1 1 1 41 341 1341 2341 7341 82 83 JWAAAA HMNAAA VVVVxx 3151 9108 1 3 1 11 51 151 1151 3151 3151 102 103 FRAAAA IMNAAA AAAAxx 1742 9109 0 2 2 2 42 742 1742 1742 1742 84 85 APAAAA JMNAAA HHHHxx 1347 9110 1 3 7 7 47 347 1347 1347 1347 94 95 VZAAAA KMNAAA OOOOxx 9418 9111 0 2 8 18 18 418 1418 4418 9418 36 37 GYAAAA LMNAAA VVVVxx 5452 9112 0 0 2 12 52 452 1452 452 5452 104 105 SBAAAA MMNAAA AAAAxx 8637 9113 1 1 7 17 37 637 637 3637 8637 74 75 FUAAAA NMNAAA HHHHxx 8287 9114 1 3 7 7 87 287 287 3287 8287 174 175 TGAAAA OMNAAA OOOOxx 9865 9115 1 1 5 5 65 865 1865 4865 9865 130 131 LPAAAA PMNAAA VVVVxx 1664 9116 0 0 4 4 64 664 1664 1664 1664 128 129 AMAAAA QMNAAA AAAAxx 9933 9117 1 1 3 13 33 933 1933 4933 9933 66 67 BSAAAA RMNAAA HHHHxx 3416 9118 0 0 6 16 16 416 1416 3416 3416 32 33 KBAAAA SMNAAA OOOOxx 7981 9119 1 1 1 1 81 981 1981 2981 7981 162 163 ZUAAAA TMNAAA VVVVxx 1981 9120 1 1 1 1 81 981 1981 1981 1981 162 163 FYAAAA UMNAAA AAAAxx 441 9121 1 1 1 1 41 441 441 441 441 82 83 ZQAAAA VMNAAA HHHHxx 1380 9122 0 0 0 0 80 380 1380 1380 1380 160 161 CBAAAA WMNAAA OOOOxx 7325 9123 1 1 5 5 25 325 1325 2325 7325 50 51 TVAAAA XMNAAA VVVVxx 5682 9124 0 2 2 2 82 682 1682 682 5682 164 165 OKAAAA YMNAAA AAAAxx 1024 9125 0 0 4 4 24 24 1024 1024 1024 48 49 KNAAAA ZMNAAA HHHHxx 1096 9126 0 0 6 16 96 96 1096 1096 1096 192 193 EQAAAA ANNAAA OOOOxx 4717 9127 1 1 7 17 17 717 717 4717 4717 34 35 LZAAAA BNNAAA VVVVxx 7948 9128 0 0 8 8 48 948 1948 2948 7948 96 97 STAAAA CNNAAA AAAAxx 4074 9129 0 2 4 14 74 74 74 4074 4074 148 149 SAAAAA DNNAAA HHHHxx 211 9130 1 3 1 11 11 211 211 211 211 22 23 DIAAAA ENNAAA OOOOxx 8993 9131 1 1 3 13 93 993 993 3993 8993 186 187 XHAAAA FNNAAA VVVVxx 4509 9132 1 1 9 9 9 509 509 4509 4509 18 19 LRAAAA GNNAAA AAAAxx 823 9133 1 3 3 3 23 823 823 823 823 46 47 RFAAAA HNNAAA HHHHxx 4747 9134 1 3 7 7 47 747 747 4747 4747 94 95 PAAAAA INNAAA OOOOxx 6955 9135 1 3 5 15 55 955 955 1955 6955 110 111 NHAAAA JNNAAA VVVVxx 7922 9136 0 2 2 2 22 922 1922 2922 7922 44 45 SSAAAA KNNAAA AAAAxx 6936 9137 0 0 6 16 36 936 936 1936 6936 72 73 UGAAAA LNNAAA HHHHxx 1546 9138 0 2 6 6 46 546 1546 1546 1546 92 93 MHAAAA MNNAAA OOOOxx 9836 9139 0 0 6 16 36 836 1836 4836 9836 72 73 IOAAAA NNNAAA VVVVxx 5626 9140 0 2 6 6 26 626 1626 626 5626 52 53 KIAAAA ONNAAA AAAAxx 4879 9141 1 3 9 19 79 879 879 4879 4879 158 159 RFAAAA PNNAAA HHHHxx 8590 9142 0 2 0 10 90 590 590 3590 8590 180 181 KSAAAA QNNAAA OOOOxx 8842 9143 0 2 2 2 42 842 842 3842 8842 84 85 CCAAAA RNNAAA VVVVxx 6505 9144 1 1 5 5 5 505 505 1505 6505 10 11 FQAAAA SNNAAA AAAAxx 2803 9145 1 3 3 3 3 803 803 2803 2803 6 7 VDAAAA TNNAAA HHHHxx 9258 9146 0 2 8 18 58 258 1258 4258 9258 116 117 CSAAAA UNNAAA OOOOxx 741 9147 1 1 1 1 41 741 741 741 741 82 83 NCAAAA VNNAAA VVVVxx 1457 9148 1 1 7 17 57 457 1457 1457 1457 114 115 BEAAAA WNNAAA AAAAxx 5777 9149 1 1 7 17 77 777 1777 777 5777 154 155 FOAAAA XNNAAA HHHHxx 2883 9150 1 3 3 3 83 883 883 2883 2883 166 167 XGAAAA YNNAAA OOOOxx 6610 9151 0 2 0 10 10 610 610 1610 6610 20 21 GUAAAA ZNNAAA VVVVxx 4331 9152 1 3 1 11 31 331 331 4331 4331 62 63 PKAAAA AONAAA AAAAxx 2712 9153 0 0 2 12 12 712 712 2712 2712 24 25 IAAAAA BONAAA HHHHxx 9268 9154 0 0 8 8 68 268 1268 4268 9268 136 137 MSAAAA CONAAA OOOOxx 410 9155 0 2 0 10 10 410 410 410 410 20 21 UPAAAA DONAAA VVVVxx 9411 9156 1 3 1 11 11 411 1411 4411 9411 22 23 ZXAAAA EONAAA AAAAxx 4683 9157 1 3 3 3 83 683 683 4683 4683 166 167 DYAAAA FONAAA HHHHxx 7072 9158 0 0 2 12 72 72 1072 2072 7072 144 145 AMAAAA GONAAA OOOOxx 5050 9159 0 2 0 10 50 50 1050 50 5050 100 101 GMAAAA HONAAA VVVVxx 5932 9160 0 0 2 12 32 932 1932 932 5932 64 65 EUAAAA IONAAA AAAAxx 2756 9161 0 0 6 16 56 756 756 2756 2756 112 113 ACAAAA JONAAA HHHHxx 9813 9162 1 1 3 13 13 813 1813 4813 9813 26 27 LNAAAA KONAAA OOOOxx 7388 9163 0 0 8 8 88 388 1388 2388 7388 176 177 EYAAAA LONAAA VVVVxx 2596 9164 0 0 6 16 96 596 596 2596 2596 192 193 WVAAAA MONAAA AAAAxx 5102 9165 0 2 2 2 2 102 1102 102 5102 4 5 GOAAAA NONAAA HHHHxx 208 9166 0 0 8 8 8 208 208 208 208 16 17 AIAAAA OONAAA OOOOxx 86 9167 0 2 6 6 86 86 86 86 86 172 173 IDAAAA PONAAA VVVVxx 8127 9168 1 3 7 7 27 127 127 3127 8127 54 55 PAAAAA QONAAA AAAAxx 5154 9169 0 2 4 14 54 154 1154 154 5154 108 109 GQAAAA RONAAA HHHHxx 4491 9170 1 3 1 11 91 491 491 4491 4491 182 183 TQAAAA SONAAA OOOOxx 7423 9171 1 3 3 3 23 423 1423 2423 7423 46 47 NZAAAA TONAAA VVVVxx 6441 9172 1 1 1 1 41 441 441 1441 6441 82 83 TNAAAA UONAAA AAAAxx 2920 9173 0 0 0 0 20 920 920 2920 2920 40 41 IIAAAA VONAAA HHHHxx 6386 9174 0 2 6 6 86 386 386 1386 6386 172 173 QLAAAA WONAAA OOOOxx 9744 9175 0 0 4 4 44 744 1744 4744 9744 88 89 UKAAAA XONAAA VVVVxx 2667 9176 1 3 7 7 67 667 667 2667 2667 134 135 PYAAAA YONAAA AAAAxx 5754 9177 0 2 4 14 54 754 1754 754 5754 108 109 INAAAA ZONAAA HHHHxx 4645 9178 1 1 5 5 45 645 645 4645 4645 90 91 RWAAAA APNAAA OOOOxx 4327 9179 1 3 7 7 27 327 327 4327 4327 54 55 LKAAAA BPNAAA VVVVxx 843 9180 1 3 3 3 43 843 843 843 843 86 87 LGAAAA CPNAAA AAAAxx 4085 9181 1 1 5 5 85 85 85 4085 4085 170 171 DBAAAA DPNAAA HHHHxx 2849 9182 1 1 9 9 49 849 849 2849 2849 98 99 PFAAAA EPNAAA OOOOxx 5734 9183 0 2 4 14 34 734 1734 734 5734 68 69 OMAAAA FPNAAA VVVVxx 5307 9184 1 3 7 7 7 307 1307 307 5307 14 15 DWAAAA GPNAAA AAAAxx 8433 9185 1 1 3 13 33 433 433 3433 8433 66 67 JMAAAA HPNAAA HHHHxx 3031 9186 1 3 1 11 31 31 1031 3031 3031 62 63 PMAAAA IPNAAA OOOOxx 5714 9187 0 2 4 14 14 714 1714 714 5714 28 29 ULAAAA JPNAAA VVVVxx 5969 9188 1 1 9 9 69 969 1969 969 5969 138 139 PVAAAA KPNAAA AAAAxx 2532 9189 0 0 2 12 32 532 532 2532 2532 64 65 KTAAAA LPNAAA HHHHxx 5219 9190 1 3 9 19 19 219 1219 219 5219 38 39 TSAAAA MPNAAA OOOOxx 7343 9191 1 3 3 3 43 343 1343 2343 7343 86 87 LWAAAA NPNAAA VVVVxx 9089 9192 1 1 9 9 89 89 1089 4089 9089 178 179 PLAAAA OPNAAA AAAAxx 9337 9193 1 1 7 17 37 337 1337 4337 9337 74 75 DVAAAA PPNAAA HHHHxx 5131 9194 1 3 1 11 31 131 1131 131 5131 62 63 JPAAAA QPNAAA OOOOxx 6253 9195 1 1 3 13 53 253 253 1253 6253 106 107 NGAAAA RPNAAA VVVVxx 5140 9196 0 0 0 0 40 140 1140 140 5140 80 81 SPAAAA SPNAAA AAAAxx 2953 9197 1 1 3 13 53 953 953 2953 2953 106 107 PJAAAA TPNAAA HHHHxx 4293 9198 1 1 3 13 93 293 293 4293 4293 186 187 DJAAAA UPNAAA OOOOxx 9974 9199 0 2 4 14 74 974 1974 4974 9974 148 149 QTAAAA VPNAAA VVVVxx 5061 9200 1 1 1 1 61 61 1061 61 5061 122 123 RMAAAA WPNAAA AAAAxx 8570 9201 0 2 0 10 70 570 570 3570 8570 140 141 QRAAAA XPNAAA HHHHxx 9504 9202 0 0 4 4 4 504 1504 4504 9504 8 9 OBAAAA YPNAAA OOOOxx 604 9203 0 0 4 4 4 604 604 604 604 8 9 GXAAAA ZPNAAA VVVVxx 4991 9204 1 3 1 11 91 991 991 4991 4991 182 183 ZJAAAA AQNAAA AAAAxx 880 9205 0 0 0 0 80 880 880 880 880 160 161 WHAAAA BQNAAA HHHHxx 3861 9206 1 1 1 1 61 861 1861 3861 3861 122 123 NSAAAA CQNAAA OOOOxx 8262 9207 0 2 2 2 62 262 262 3262 8262 124 125 UFAAAA DQNAAA VVVVxx 5689 9208 1 1 9 9 89 689 1689 689 5689 178 179 VKAAAA EQNAAA AAAAxx 1793 9209 1 1 3 13 93 793 1793 1793 1793 186 187 ZQAAAA FQNAAA HHHHxx 2661 9210 1 1 1 1 61 661 661 2661 2661 122 123 JYAAAA GQNAAA OOOOxx 7954 9211 0 2 4 14 54 954 1954 2954 7954 108 109 YTAAAA HQNAAA VVVVxx 1874 9212 0 2 4 14 74 874 1874 1874 1874 148 149 CUAAAA IQNAAA AAAAxx 2982 9213 0 2 2 2 82 982 982 2982 2982 164 165 SKAAAA JQNAAA HHHHxx 331 9214 1 3 1 11 31 331 331 331 331 62 63 TMAAAA KQNAAA OOOOxx 5021 9215 1 1 1 1 21 21 1021 21 5021 42 43 DLAAAA LQNAAA VVVVxx 9894 9216 0 2 4 14 94 894 1894 4894 9894 188 189 OQAAAA MQNAAA AAAAxx 7709 9217 1 1 9 9 9 709 1709 2709 7709 18 19 NKAAAA NQNAAA HHHHxx 4980 9218 0 0 0 0 80 980 980 4980 4980 160 161 OJAAAA OQNAAA OOOOxx 8249 9219 1 1 9 9 49 249 249 3249 8249 98 99 HFAAAA PQNAAA VVVVxx 7120 9220 0 0 0 0 20 120 1120 2120 7120 40 41 WNAAAA QQNAAA AAAAxx 7464 9221 0 0 4 4 64 464 1464 2464 7464 128 129 CBAAAA RQNAAA HHHHxx 8086 9222 0 2 6 6 86 86 86 3086 8086 172 173 AZAAAA SQNAAA OOOOxx 3509 9223 1 1 9 9 9 509 1509 3509 3509 18 19 ZEAAAA TQNAAA VVVVxx 3902 9224 0 2 2 2 2 902 1902 3902 3902 4 5 CUAAAA UQNAAA AAAAxx 9907 9225 1 3 7 7 7 907 1907 4907 9907 14 15 BRAAAA VQNAAA HHHHxx 6278 9226 0 2 8 18 78 278 278 1278 6278 156 157 MHAAAA WQNAAA OOOOxx 9316 9227 0 0 6 16 16 316 1316 4316 9316 32 33 IUAAAA XQNAAA VVVVxx 2824 9228 0 0 4 4 24 824 824 2824 2824 48 49 QEAAAA YQNAAA AAAAxx 1558 9229 0 2 8 18 58 558 1558 1558 1558 116 117 YHAAAA ZQNAAA HHHHxx 5436 9230 0 0 6 16 36 436 1436 436 5436 72 73 CBAAAA ARNAAA OOOOxx 1161 9231 1 1 1 1 61 161 1161 1161 1161 122 123 RSAAAA BRNAAA VVVVxx 7569 9232 1 1 9 9 69 569 1569 2569 7569 138 139 DFAAAA CRNAAA AAAAxx 9614 9233 0 2 4 14 14 614 1614 4614 9614 28 29 UFAAAA DRNAAA HHHHxx 6970 9234 0 2 0 10 70 970 970 1970 6970 140 141 CIAAAA ERNAAA OOOOxx 2422 9235 0 2 2 2 22 422 422 2422 2422 44 45 EPAAAA FRNAAA VVVVxx 8860 9236 0 0 0 0 60 860 860 3860 8860 120 121 UCAAAA GRNAAA AAAAxx 9912 9237 0 0 2 12 12 912 1912 4912 9912 24 25 GRAAAA HRNAAA HHHHxx 1109 9238 1 1 9 9 9 109 1109 1109 1109 18 19 RQAAAA IRNAAA OOOOxx 3286 9239 0 2 6 6 86 286 1286 3286 3286 172 173 KWAAAA JRNAAA VVVVxx 2277 9240 1 1 7 17 77 277 277 2277 2277 154 155 PJAAAA KRNAAA AAAAxx 8656 9241 0 0 6 16 56 656 656 3656 8656 112 113 YUAAAA LRNAAA HHHHxx 4656 9242 0 0 6 16 56 656 656 4656 4656 112 113 CXAAAA MRNAAA OOOOxx 6965 9243 1 1 5 5 65 965 965 1965 6965 130 131 XHAAAA NRNAAA VVVVxx 7591 9244 1 3 1 11 91 591 1591 2591 7591 182 183 ZFAAAA ORNAAA AAAAxx 4883 9245 1 3 3 3 83 883 883 4883 4883 166 167 VFAAAA PRNAAA HHHHxx 452 9246 0 0 2 12 52 452 452 452 452 104 105 KRAAAA QRNAAA OOOOxx 4018 9247 0 2 8 18 18 18 18 4018 4018 36 37 OYAAAA RRNAAA VVVVxx 4066 9248 0 2 6 6 66 66 66 4066 4066 132 133 KAAAAA SRNAAA AAAAxx 6480 9249 0 0 0 0 80 480 480 1480 6480 160 161 GPAAAA TRNAAA HHHHxx 8634 9250 0 2 4 14 34 634 634 3634 8634 68 69 CUAAAA URNAAA OOOOxx 9387 9251 1 3 7 7 87 387 1387 4387 9387 174 175 BXAAAA VRNAAA VVVVxx 3476 9252 0 0 6 16 76 476 1476 3476 3476 152 153 SDAAAA WRNAAA AAAAxx 5995 9253 1 3 5 15 95 995 1995 995 5995 190 191 PWAAAA XRNAAA HHHHxx 9677 9254 1 1 7 17 77 677 1677 4677 9677 154 155 FIAAAA YRNAAA OOOOxx 3884 9255 0 0 4 4 84 884 1884 3884 3884 168 169 KTAAAA ZRNAAA VVVVxx 6500 9256 0 0 0 0 0 500 500 1500 6500 0 1 AQAAAA ASNAAA AAAAxx 7972 9257 0 0 2 12 72 972 1972 2972 7972 144 145 QUAAAA BSNAAA HHHHxx 5281 9258 1 1 1 1 81 281 1281 281 5281 162 163 DVAAAA CSNAAA OOOOxx 1288 9259 0 0 8 8 88 288 1288 1288 1288 176 177 OXAAAA DSNAAA VVVVxx 4366 9260 0 2 6 6 66 366 366 4366 4366 132 133 YLAAAA ESNAAA AAAAxx 6557 9261 1 1 7 17 57 557 557 1557 6557 114 115 FSAAAA FSNAAA HHHHxx 7086 9262 0 2 6 6 86 86 1086 2086 7086 172 173 OMAAAA GSNAAA OOOOxx 6588 9263 0 0 8 8 88 588 588 1588 6588 176 177 KTAAAA HSNAAA VVVVxx 9062 9264 0 2 2 2 62 62 1062 4062 9062 124 125 OKAAAA ISNAAA AAAAxx 9230 9265 0 2 0 10 30 230 1230 4230 9230 60 61 ARAAAA JSNAAA HHHHxx 7672 9266 0 0 2 12 72 672 1672 2672 7672 144 145 CJAAAA KSNAAA OOOOxx 5204 9267 0 0 4 4 4 204 1204 204 5204 8 9 ESAAAA LSNAAA VVVVxx 2836 9268 0 0 6 16 36 836 836 2836 2836 72 73 CFAAAA MSNAAA AAAAxx 7165 9269 1 1 5 5 65 165 1165 2165 7165 130 131 PPAAAA NSNAAA HHHHxx 971 9270 1 3 1 11 71 971 971 971 971 142 143 JLAAAA OSNAAA OOOOxx 3851 9271 1 3 1 11 51 851 1851 3851 3851 102 103 DSAAAA PSNAAA VVVVxx 8593 9272 1 1 3 13 93 593 593 3593 8593 186 187 NSAAAA QSNAAA AAAAxx 7742 9273 0 2 2 2 42 742 1742 2742 7742 84 85 ULAAAA RSNAAA HHHHxx 2887 9274 1 3 7 7 87 887 887 2887 2887 174 175 BHAAAA SSNAAA OOOOxx 8479 9275 1 3 9 19 79 479 479 3479 8479 158 159 DOAAAA TSNAAA VVVVxx 9514 9276 0 2 4 14 14 514 1514 4514 9514 28 29 YBAAAA USNAAA AAAAxx 273 9277 1 1 3 13 73 273 273 273 273 146 147 NKAAAA VSNAAA HHHHxx 2938 9278 0 2 8 18 38 938 938 2938 2938 76 77 AJAAAA WSNAAA OOOOxx 9793 9279 1 1 3 13 93 793 1793 4793 9793 186 187 RMAAAA XSNAAA VVVVxx 8050 9280 0 2 0 10 50 50 50 3050 8050 100 101 QXAAAA YSNAAA AAAAxx 6702 9281 0 2 2 2 2 702 702 1702 6702 4 5 UXAAAA ZSNAAA HHHHxx 7290 9282 0 2 0 10 90 290 1290 2290 7290 180 181 KUAAAA ATNAAA OOOOxx 1837 9283 1 1 7 17 37 837 1837 1837 1837 74 75 RSAAAA BTNAAA VVVVxx 3206 9284 0 2 6 6 6 206 1206 3206 3206 12 13 ITAAAA CTNAAA AAAAxx 4925 9285 1 1 5 5 25 925 925 4925 4925 50 51 LHAAAA DTNAAA HHHHxx 5066 9286 0 2 6 6 66 66 1066 66 5066 132 133 WMAAAA ETNAAA OOOOxx 3401 9287 1 1 1 1 1 401 1401 3401 3401 2 3 VAAAAA FTNAAA VVVVxx 3474 9288 0 2 4 14 74 474 1474 3474 3474 148 149 QDAAAA GTNAAA AAAAxx 57 9289 1 1 7 17 57 57 57 57 57 114 115 FCAAAA HTNAAA HHHHxx 2082 9290 0 2 2 2 82 82 82 2082 2082 164 165 CCAAAA ITNAAA OOOOxx 100 9291 0 0 0 0 0 100 100 100 100 0 1 WDAAAA JTNAAA VVVVxx 9665 9292 1 1 5 5 65 665 1665 4665 9665 130 131 THAAAA KTNAAA AAAAxx 8284 9293 0 0 4 4 84 284 284 3284 8284 168 169 QGAAAA LTNAAA HHHHxx 958 9294 0 2 8 18 58 958 958 958 958 116 117 WKAAAA MTNAAA OOOOxx 5282 9295 0 2 2 2 82 282 1282 282 5282 164 165 EVAAAA NTNAAA VVVVxx 4257 9296 1 1 7 17 57 257 257 4257 4257 114 115 THAAAA OTNAAA AAAAxx 3160 9297 0 0 0 0 60 160 1160 3160 3160 120 121 ORAAAA PTNAAA HHHHxx 8449 9298 1 1 9 9 49 449 449 3449 8449 98 99 ZMAAAA QTNAAA OOOOxx 500 9299 0 0 0 0 0 500 500 500 500 0 1 GTAAAA RTNAAA VVVVxx 6432 9300 0 0 2 12 32 432 432 1432 6432 64 65 KNAAAA STNAAA AAAAxx 6220 9301 0 0 0 0 20 220 220 1220 6220 40 41 GFAAAA TTNAAA HHHHxx 7233 9302 1 1 3 13 33 233 1233 2233 7233 66 67 FSAAAA UTNAAA OOOOxx 2723 9303 1 3 3 3 23 723 723 2723 2723 46 47 TAAAAA VTNAAA VVVVxx 1899 9304 1 3 9 19 99 899 1899 1899 1899 198 199 BVAAAA WTNAAA AAAAxx 7158 9305 0 2 8 18 58 158 1158 2158 7158 116 117 IPAAAA XTNAAA HHHHxx 202 9306 0 2 2 2 2 202 202 202 202 4 5 UHAAAA YTNAAA OOOOxx 2286 9307 0 2 6 6 86 286 286 2286 2286 172 173 YJAAAA ZTNAAA VVVVxx 5356 9308 0 0 6 16 56 356 1356 356 5356 112 113 AYAAAA AUNAAA AAAAxx 3809 9309 1 1 9 9 9 809 1809 3809 3809 18 19 NQAAAA BUNAAA HHHHxx 3979 9310 1 3 9 19 79 979 1979 3979 3979 158 159 BXAAAA CUNAAA OOOOxx 8359 9311 1 3 9 19 59 359 359 3359 8359 118 119 NJAAAA DUNAAA VVVVxx 3479 9312 1 3 9 19 79 479 1479 3479 3479 158 159 VDAAAA EUNAAA AAAAxx 4895 9313 1 3 5 15 95 895 895 4895 4895 190 191 HGAAAA FUNAAA HHHHxx 6059 9314 1 3 9 19 59 59 59 1059 6059 118 119 BZAAAA GUNAAA OOOOxx 9560 9315 0 0 0 0 60 560 1560 4560 9560 120 121 SDAAAA HUNAAA VVVVxx 6756 9316 0 0 6 16 56 756 756 1756 6756 112 113 WZAAAA IUNAAA AAAAxx 7504 9317 0 0 4 4 4 504 1504 2504 7504 8 9 QCAAAA JUNAAA HHHHxx 6762 9318 0 2 2 2 62 762 762 1762 6762 124 125 CAAAAA KUNAAA OOOOxx 5304 9319 0 0 4 4 4 304 1304 304 5304 8 9 AWAAAA LUNAAA VVVVxx 9533 9320 1 1 3 13 33 533 1533 4533 9533 66 67 RCAAAA MUNAAA AAAAxx 6649 9321 1 1 9 9 49 649 649 1649 6649 98 99 TVAAAA NUNAAA HHHHxx 38 9322 0 2 8 18 38 38 38 38 38 76 77 MBAAAA OUNAAA OOOOxx 5713 9323 1 1 3 13 13 713 1713 713 5713 26 27 TLAAAA PUNAAA VVVVxx 3000 9324 0 0 0 0 0 0 1000 3000 3000 0 1 KLAAAA QUNAAA AAAAxx 3738 9325 0 2 8 18 38 738 1738 3738 3738 76 77 UNAAAA RUNAAA HHHHxx 3327 9326 1 3 7 7 27 327 1327 3327 3327 54 55 ZXAAAA SUNAAA OOOOxx 3922 9327 0 2 2 2 22 922 1922 3922 3922 44 45 WUAAAA TUNAAA VVVVxx 9245 9328 1 1 5 5 45 245 1245 4245 9245 90 91 PRAAAA UUNAAA AAAAxx 2172 9329 0 0 2 12 72 172 172 2172 2172 144 145 OFAAAA VUNAAA HHHHxx 7128 9330 0 0 8 8 28 128 1128 2128 7128 56 57 EOAAAA WUNAAA OOOOxx 1195 9331 1 3 5 15 95 195 1195 1195 1195 190 191 ZTAAAA XUNAAA VVVVxx 8445 9332 1 1 5 5 45 445 445 3445 8445 90 91 VMAAAA YUNAAA AAAAxx 8638 9333 0 2 8 18 38 638 638 3638 8638 76 77 GUAAAA ZUNAAA HHHHxx 1249 9334 1 1 9 9 49 249 1249 1249 1249 98 99 BWAAAA AVNAAA OOOOxx 8659 9335 1 3 9 19 59 659 659 3659 8659 118 119 BVAAAA BVNAAA VVVVxx 3556 9336 0 0 6 16 56 556 1556 3556 3556 112 113 UGAAAA CVNAAA AAAAxx 3347 9337 1 3 7 7 47 347 1347 3347 3347 94 95 TYAAAA DVNAAA HHHHxx 3260 9338 0 0 0 0 60 260 1260 3260 3260 120 121 KVAAAA EVNAAA OOOOxx 5139 9339 1 3 9 19 39 139 1139 139 5139 78 79 RPAAAA FVNAAA VVVVxx 9991 9340 1 3 1 11 91 991 1991 4991 9991 182 183 HUAAAA GVNAAA AAAAxx 5499 9341 1 3 9 19 99 499 1499 499 5499 198 199 NDAAAA HVNAAA HHHHxx 8082 9342 0 2 2 2 82 82 82 3082 8082 164 165 WYAAAA IVNAAA OOOOxx 1640 9343 0 0 0 0 40 640 1640 1640 1640 80 81 CLAAAA JVNAAA VVVVxx 8726 9344 0 2 6 6 26 726 726 3726 8726 52 53 QXAAAA KVNAAA AAAAxx 2339 9345 1 3 9 19 39 339 339 2339 2339 78 79 ZLAAAA LVNAAA HHHHxx 2601 9346 1 1 1 1 1 601 601 2601 2601 2 3 BWAAAA MVNAAA OOOOxx 9940 9347 0 0 0 0 40 940 1940 4940 9940 80 81 ISAAAA NVNAAA VVVVxx 4185 9348 1 1 5 5 85 185 185 4185 4185 170 171 ZEAAAA OVNAAA AAAAxx 9546 9349 0 2 6 6 46 546 1546 4546 9546 92 93 EDAAAA PVNAAA HHHHxx 5218 9350 0 2 8 18 18 218 1218 218 5218 36 37 SSAAAA QVNAAA OOOOxx 4374 9351 0 2 4 14 74 374 374 4374 4374 148 149 GMAAAA RVNAAA VVVVxx 288 9352 0 0 8 8 88 288 288 288 288 176 177 CLAAAA SVNAAA AAAAxx 7445 9353 1 1 5 5 45 445 1445 2445 7445 90 91 JAAAAA TVNAAA HHHHxx 1710 9354 0 2 0 10 10 710 1710 1710 1710 20 21 UNAAAA UVNAAA OOOOxx 6409 9355 1 1 9 9 9 409 409 1409 6409 18 19 NMAAAA VVNAAA VVVVxx 7982 9356 0 2 2 2 82 982 1982 2982 7982 164 165 AVAAAA WVNAAA AAAAxx 4950 9357 0 2 0 10 50 950 950 4950 4950 100 101 KIAAAA XVNAAA HHHHxx 9242 9358 0 2 2 2 42 242 1242 4242 9242 84 85 MRAAAA YVNAAA OOOOxx 3272 9359 0 0 2 12 72 272 1272 3272 3272 144 145 WVAAAA ZVNAAA VVVVxx 739 9360 1 3 9 19 39 739 739 739 739 78 79 LCAAAA AWNAAA AAAAxx 5526 9361 0 2 6 6 26 526 1526 526 5526 52 53 OEAAAA BWNAAA HHHHxx 8189 9362 1 1 9 9 89 189 189 3189 8189 178 179 ZCAAAA CWNAAA OOOOxx 9106 9363 0 2 6 6 6 106 1106 4106 9106 12 13 GMAAAA DWNAAA VVVVxx 9775 9364 1 3 5 15 75 775 1775 4775 9775 150 151 ZLAAAA EWNAAA AAAAxx 4643 9365 1 3 3 3 43 643 643 4643 4643 86 87 PWAAAA FWNAAA HHHHxx 8396 9366 0 0 6 16 96 396 396 3396 8396 192 193 YKAAAA GWNAAA OOOOxx 3255 9367 1 3 5 15 55 255 1255 3255 3255 110 111 FVAAAA HWNAAA VVVVxx 301 9368 1 1 1 1 1 301 301 301 301 2 3 PLAAAA IWNAAA AAAAxx 6014 9369 0 2 4 14 14 14 14 1014 6014 28 29 IXAAAA JWNAAA HHHHxx 6046 9370 0 2 6 6 46 46 46 1046 6046 92 93 OYAAAA KWNAAA OOOOxx 984 9371 0 0 4 4 84 984 984 984 984 168 169 WLAAAA LWNAAA VVVVxx 2420 9372 0 0 0 0 20 420 420 2420 2420 40 41 CPAAAA MWNAAA AAAAxx 2922 9373 0 2 2 2 22 922 922 2922 2922 44 45 KIAAAA NWNAAA HHHHxx 2317 9374 1 1 7 17 17 317 317 2317 2317 34 35 DLAAAA OWNAAA OOOOxx 7332 9375 0 0 2 12 32 332 1332 2332 7332 64 65 AWAAAA PWNAAA VVVVxx 6451 9376 1 3 1 11 51 451 451 1451 6451 102 103 DOAAAA QWNAAA AAAAxx 2589 9377 1 1 9 9 89 589 589 2589 2589 178 179 PVAAAA RWNAAA HHHHxx 4333 9378 1 1 3 13 33 333 333 4333 4333 66 67 RKAAAA SWNAAA OOOOxx 8650 9379 0 2 0 10 50 650 650 3650 8650 100 101 SUAAAA TWNAAA VVVVxx 6856 9380 0 0 6 16 56 856 856 1856 6856 112 113 SDAAAA UWNAAA AAAAxx 4194 9381 0 2 4 14 94 194 194 4194 4194 188 189 IFAAAA VWNAAA HHHHxx 6246 9382 0 2 6 6 46 246 246 1246 6246 92 93 GGAAAA WWNAAA OOOOxx 4371 9383 1 3 1 11 71 371 371 4371 4371 142 143 DMAAAA XWNAAA VVVVxx 1388 9384 0 0 8 8 88 388 1388 1388 1388 176 177 KBAAAA YWNAAA AAAAxx 1056 9385 0 0 6 16 56 56 1056 1056 1056 112 113 QOAAAA ZWNAAA HHHHxx 6041 9386 1 1 1 1 41 41 41 1041 6041 82 83 JYAAAA AXNAAA OOOOxx 6153 9387 1 1 3 13 53 153 153 1153 6153 106 107 RCAAAA BXNAAA VVVVxx 8450 9388 0 2 0 10 50 450 450 3450 8450 100 101 ANAAAA CXNAAA AAAAxx 3469 9389 1 1 9 9 69 469 1469 3469 3469 138 139 LDAAAA DXNAAA HHHHxx 5226 9390 0 2 6 6 26 226 1226 226 5226 52 53 ATAAAA EXNAAA OOOOxx 8112 9391 0 0 2 12 12 112 112 3112 8112 24 25 AAAAAA FXNAAA VVVVxx 647 9392 1 3 7 7 47 647 647 647 647 94 95 XYAAAA GXNAAA AAAAxx 2567 9393 1 3 7 7 67 567 567 2567 2567 134 135 TUAAAA HXNAAA HHHHxx 9064 9394 0 0 4 4 64 64 1064 4064 9064 128 129 QKAAAA IXNAAA OOOOxx 5161 9395 1 1 1 1 61 161 1161 161 5161 122 123 NQAAAA JXNAAA VVVVxx 5260 9396 0 0 0 0 60 260 1260 260 5260 120 121 IUAAAA KXNAAA AAAAxx 8988 9397 0 0 8 8 88 988 988 3988 8988 176 177 SHAAAA LXNAAA HHHHxx 9678 9398 0 2 8 18 78 678 1678 4678 9678 156 157 GIAAAA MXNAAA OOOOxx 6853 9399 1 1 3 13 53 853 853 1853 6853 106 107 PDAAAA NXNAAA VVVVxx 5294 9400 0 2 4 14 94 294 1294 294 5294 188 189 QVAAAA OXNAAA AAAAxx 9864 9401 0 0 4 4 64 864 1864 4864 9864 128 129 KPAAAA PXNAAA HHHHxx 8702 9402 0 2 2 2 2 702 702 3702 8702 4 5 SWAAAA QXNAAA OOOOxx 1132 9403 0 0 2 12 32 132 1132 1132 1132 64 65 ORAAAA RXNAAA VVVVxx 1524 9404 0 0 4 4 24 524 1524 1524 1524 48 49 QGAAAA SXNAAA AAAAxx 4560 9405 0 0 0 0 60 560 560 4560 4560 120 121 KTAAAA TXNAAA HHHHxx 2137 9406 1 1 7 17 37 137 137 2137 2137 74 75 FEAAAA UXNAAA OOOOxx 3283 9407 1 3 3 3 83 283 1283 3283 3283 166 167 HWAAAA VXNAAA VVVVxx 3377 9408 1 1 7 17 77 377 1377 3377 3377 154 155 XZAAAA WXNAAA AAAAxx 2267 9409 1 3 7 7 67 267 267 2267 2267 134 135 FJAAAA XXNAAA HHHHxx 8987 9410 1 3 7 7 87 987 987 3987 8987 174 175 RHAAAA YXNAAA OOOOxx 6709 9411 1 1 9 9 9 709 709 1709 6709 18 19 BYAAAA ZXNAAA VVVVxx 8059 9412 1 3 9 19 59 59 59 3059 8059 118 119 ZXAAAA AYNAAA AAAAxx 3402 9413 0 2 2 2 2 402 1402 3402 3402 4 5 WAAAAA BYNAAA HHHHxx 6443 9414 1 3 3 3 43 443 443 1443 6443 86 87 VNAAAA CYNAAA OOOOxx 8858 9415 0 2 8 18 58 858 858 3858 8858 116 117 SCAAAA DYNAAA VVVVxx 3974 9416 0 2 4 14 74 974 1974 3974 3974 148 149 WWAAAA EYNAAA AAAAxx 3521 9417 1 1 1 1 21 521 1521 3521 3521 42 43 LFAAAA FYNAAA HHHHxx 9509 9418 1 1 9 9 9 509 1509 4509 9509 18 19 TBAAAA GYNAAA OOOOxx 5442 9419 0 2 2 2 42 442 1442 442 5442 84 85 IBAAAA HYNAAA VVVVxx 8968 9420 0 0 8 8 68 968 968 3968 8968 136 137 YGAAAA IYNAAA AAAAxx 333 9421 1 1 3 13 33 333 333 333 333 66 67 VMAAAA JYNAAA HHHHxx 952 9422 0 0 2 12 52 952 952 952 952 104 105 QKAAAA KYNAAA OOOOxx 7482 9423 0 2 2 2 82 482 1482 2482 7482 164 165 UBAAAA LYNAAA VVVVxx 1486 9424 0 2 6 6 86 486 1486 1486 1486 172 173 EFAAAA MYNAAA AAAAxx 1815 9425 1 3 5 15 15 815 1815 1815 1815 30 31 VRAAAA NYNAAA HHHHxx 7937 9426 1 1 7 17 37 937 1937 2937 7937 74 75 HTAAAA OYNAAA OOOOxx 1436 9427 0 0 6 16 36 436 1436 1436 1436 72 73 GDAAAA PYNAAA VVVVxx 3470 9428 0 2 0 10 70 470 1470 3470 3470 140 141 MDAAAA QYNAAA AAAAxx 8195 9429 1 3 5 15 95 195 195 3195 8195 190 191 FDAAAA RYNAAA HHHHxx 6906 9430 0 2 6 6 6 906 906 1906 6906 12 13 QFAAAA SYNAAA OOOOxx 2539 9431 1 3 9 19 39 539 539 2539 2539 78 79 RTAAAA TYNAAA VVVVxx 5988 9432 0 0 8 8 88 988 1988 988 5988 176 177 IWAAAA UYNAAA AAAAxx 8908 9433 0 0 8 8 8 908 908 3908 8908 16 17 QEAAAA VYNAAA HHHHxx 2319 9434 1 3 9 19 19 319 319 2319 2319 38 39 FLAAAA WYNAAA OOOOxx 3263 9435 1 3 3 3 63 263 1263 3263 3263 126 127 NVAAAA XYNAAA VVVVxx 4039 9436 1 3 9 19 39 39 39 4039 4039 78 79 JZAAAA YYNAAA AAAAxx 6373 9437 1 1 3 13 73 373 373 1373 6373 146 147 DLAAAA ZYNAAA HHHHxx 1168 9438 0 0 8 8 68 168 1168 1168 1168 136 137 YSAAAA AZNAAA OOOOxx 8338 9439 0 2 8 18 38 338 338 3338 8338 76 77 SIAAAA BZNAAA VVVVxx 1172 9440 0 0 2 12 72 172 1172 1172 1172 144 145 CTAAAA CZNAAA AAAAxx 200 9441 0 0 0 0 0 200 200 200 200 0 1 SHAAAA DZNAAA HHHHxx 6355 9442 1 3 5 15 55 355 355 1355 6355 110 111 LKAAAA EZNAAA OOOOxx 7768 9443 0 0 8 8 68 768 1768 2768 7768 136 137 UMAAAA FZNAAA VVVVxx 25 9444 1 1 5 5 25 25 25 25 25 50 51 ZAAAAA GZNAAA AAAAxx 7144 9445 0 0 4 4 44 144 1144 2144 7144 88 89 UOAAAA HZNAAA HHHHxx 8671 9446 1 3 1 11 71 671 671 3671 8671 142 143 NVAAAA IZNAAA OOOOxx 9163 9447 1 3 3 3 63 163 1163 4163 9163 126 127 LOAAAA JZNAAA VVVVxx 8889 9448 1 1 9 9 89 889 889 3889 8889 178 179 XDAAAA KZNAAA AAAAxx 5950 9449 0 2 0 10 50 950 1950 950 5950 100 101 WUAAAA LZNAAA HHHHxx 6163 9450 1 3 3 3 63 163 163 1163 6163 126 127 BDAAAA MZNAAA OOOOxx 8119 9451 1 3 9 19 19 119 119 3119 8119 38 39 HAAAAA NZNAAA VVVVxx 1416 9452 0 0 6 16 16 416 1416 1416 1416 32 33 MCAAAA OZNAAA AAAAxx 4132 9453 0 0 2 12 32 132 132 4132 4132 64 65 YCAAAA PZNAAA HHHHxx 2294 9454 0 2 4 14 94 294 294 2294 2294 188 189 GKAAAA QZNAAA OOOOxx 9094 9455 0 2 4 14 94 94 1094 4094 9094 188 189 ULAAAA RZNAAA VVVVxx 4168 9456 0 0 8 8 68 168 168 4168 4168 136 137 IEAAAA SZNAAA AAAAxx 9108 9457 0 0 8 8 8 108 1108 4108 9108 16 17 IMAAAA TZNAAA HHHHxx 5706 9458 0 2 6 6 6 706 1706 706 5706 12 13 MLAAAA UZNAAA OOOOxx 2231 9459 1 3 1 11 31 231 231 2231 2231 62 63 VHAAAA VZNAAA VVVVxx 2173 9460 1 1 3 13 73 173 173 2173 2173 146 147 PFAAAA WZNAAA AAAAxx 90 9461 0 2 0 10 90 90 90 90 90 180 181 MDAAAA XZNAAA HHHHxx 9996 9462 0 0 6 16 96 996 1996 4996 9996 192 193 MUAAAA YZNAAA OOOOxx 330 9463 0 2 0 10 30 330 330 330 330 60 61 SMAAAA ZZNAAA VVVVxx 2052 9464 0 0 2 12 52 52 52 2052 2052 104 105 YAAAAA AAOAAA AAAAxx 1093 9465 1 1 3 13 93 93 1093 1093 1093 186 187 BQAAAA BAOAAA HHHHxx 5817 9466 1 1 7 17 17 817 1817 817 5817 34 35 TPAAAA CAOAAA OOOOxx 1559 9467 1 3 9 19 59 559 1559 1559 1559 118 119 ZHAAAA DAOAAA VVVVxx 8405 9468 1 1 5 5 5 405 405 3405 8405 10 11 HLAAAA EAOAAA AAAAxx 9962 9469 0 2 2 2 62 962 1962 4962 9962 124 125 ETAAAA FAOAAA HHHHxx 9461 9470 1 1 1 1 61 461 1461 4461 9461 122 123 XZAAAA GAOAAA OOOOxx 3028 9471 0 0 8 8 28 28 1028 3028 3028 56 57 MMAAAA HAOAAA VVVVxx 6814 9472 0 2 4 14 14 814 814 1814 6814 28 29 CCAAAA IAOAAA AAAAxx 9587 9473 1 3 7 7 87 587 1587 4587 9587 174 175 TEAAAA JAOAAA HHHHxx 6863 9474 1 3 3 3 63 863 863 1863 6863 126 127 ZDAAAA KAOAAA OOOOxx 4963 9475 1 3 3 3 63 963 963 4963 4963 126 127 XIAAAA LAOAAA VVVVxx 7811 9476 1 3 1 11 11 811 1811 2811 7811 22 23 LOAAAA MAOAAA AAAAxx 7608 9477 0 0 8 8 8 608 1608 2608 7608 16 17 QGAAAA NAOAAA HHHHxx 5321 9478 1 1 1 1 21 321 1321 321 5321 42 43 RWAAAA OAOAAA OOOOxx 9971 9479 1 3 1 11 71 971 1971 4971 9971 142 143 NTAAAA PAOAAA VVVVxx 6161 9480 1 1 1 1 61 161 161 1161 6161 122 123 ZCAAAA QAOAAA AAAAxx 2181 9481 1 1 1 1 81 181 181 2181 2181 162 163 XFAAAA RAOAAA HHHHxx 3828 9482 0 0 8 8 28 828 1828 3828 3828 56 57 GRAAAA SAOAAA OOOOxx 348 9483 0 0 8 8 48 348 348 348 348 96 97 KNAAAA TAOAAA VVVVxx 5459 9484 1 3 9 19 59 459 1459 459 5459 118 119 ZBAAAA UAOAAA AAAAxx 9406 9485 0 2 6 6 6 406 1406 4406 9406 12 13 UXAAAA VAOAAA HHHHxx 9852 9486 0 0 2 12 52 852 1852 4852 9852 104 105 YOAAAA WAOAAA OOOOxx 3095 9487 1 3 5 15 95 95 1095 3095 3095 190 191 BPAAAA XAOAAA VVVVxx 5597 9488 1 1 7 17 97 597 1597 597 5597 194 195 HHAAAA YAOAAA AAAAxx 8841 9489 1 1 1 1 41 841 841 3841 8841 82 83 BCAAAA ZAOAAA HHHHxx 3536 9490 0 0 6 16 36 536 1536 3536 3536 72 73 AGAAAA ABOAAA OOOOxx 4009 9491 1 1 9 9 9 9 9 4009 4009 18 19 FYAAAA BBOAAA VVVVxx 7366 9492 0 2 6 6 66 366 1366 2366 7366 132 133 IXAAAA CBOAAA AAAAxx 7327 9493 1 3 7 7 27 327 1327 2327 7327 54 55 VVAAAA DBOAAA HHHHxx 1613 9494 1 1 3 13 13 613 1613 1613 1613 26 27 BKAAAA EBOAAA OOOOxx 8619 9495 1 3 9 19 19 619 619 3619 8619 38 39 NTAAAA FBOAAA VVVVxx 4880 9496 0 0 0 0 80 880 880 4880 4880 160 161 SFAAAA GBOAAA AAAAxx 1552 9497 0 0 2 12 52 552 1552 1552 1552 104 105 SHAAAA HBOAAA HHHHxx 7636 9498 0 0 6 16 36 636 1636 2636 7636 72 73 SHAAAA IBOAAA OOOOxx 8397 9499 1 1 7 17 97 397 397 3397 8397 194 195 ZKAAAA JBOAAA VVVVxx 6224 9500 0 0 4 4 24 224 224 1224 6224 48 49 KFAAAA KBOAAA AAAAxx 9102 9501 0 2 2 2 2 102 1102 4102 9102 4 5 CMAAAA LBOAAA HHHHxx 7906 9502 0 2 6 6 6 906 1906 2906 7906 12 13 CSAAAA MBOAAA OOOOxx 9467 9503 1 3 7 7 67 467 1467 4467 9467 134 135 DAAAAA NBOAAA VVVVxx 828 9504 0 0 8 8 28 828 828 828 828 56 57 WFAAAA OBOAAA AAAAxx 9585 9505 1 1 5 5 85 585 1585 4585 9585 170 171 REAAAA PBOAAA HHHHxx 925 9506 1 1 5 5 25 925 925 925 925 50 51 PJAAAA QBOAAA OOOOxx 7375 9507 1 3 5 15 75 375 1375 2375 7375 150 151 RXAAAA RBOAAA VVVVxx 4027 9508 1 3 7 7 27 27 27 4027 4027 54 55 XYAAAA SBOAAA AAAAxx 766 9509 0 2 6 6 66 766 766 766 766 132 133 MDAAAA TBOAAA HHHHxx 5633 9510 1 1 3 13 33 633 1633 633 5633 66 67 RIAAAA UBOAAA OOOOxx 5648 9511 0 0 8 8 48 648 1648 648 5648 96 97 GJAAAA VBOAAA VVVVxx 148 9512 0 0 8 8 48 148 148 148 148 96 97 SFAAAA WBOAAA AAAAxx 2072 9513 0 0 2 12 72 72 72 2072 2072 144 145 SBAAAA XBOAAA HHHHxx 431 9514 1 3 1 11 31 431 431 431 431 62 63 PQAAAA YBOAAA OOOOxx 1711 9515 1 3 1 11 11 711 1711 1711 1711 22 23 VNAAAA ZBOAAA VVVVxx 9378 9516 0 2 8 18 78 378 1378 4378 9378 156 157 SWAAAA ACOAAA AAAAxx 6776 9517 0 0 6 16 76 776 776 1776 6776 152 153 QAAAAA BCOAAA HHHHxx 6842 9518 0 2 2 2 42 842 842 1842 6842 84 85 EDAAAA CCOAAA OOOOxx 2656 9519 0 0 6 16 56 656 656 2656 2656 112 113 EYAAAA DCOAAA VVVVxx 3116 9520 0 0 6 16 16 116 1116 3116 3116 32 33 WPAAAA ECOAAA AAAAxx 7904 9521 0 0 4 4 4 904 1904 2904 7904 8 9 ASAAAA FCOAAA HHHHxx 3529 9522 1 1 9 9 29 529 1529 3529 3529 58 59 TFAAAA GCOAAA OOOOxx 3240 9523 0 0 0 0 40 240 1240 3240 3240 80 81 QUAAAA HCOAAA VVVVxx 5801 9524 1 1 1 1 1 801 1801 801 5801 2 3 DPAAAA ICOAAA AAAAxx 4090 9525 0 2 0 10 90 90 90 4090 4090 180 181 IBAAAA JCOAAA HHHHxx 7687 9526 1 3 7 7 87 687 1687 2687 7687 174 175 RJAAAA KCOAAA OOOOxx 9711 9527 1 3 1 11 11 711 1711 4711 9711 22 23 NJAAAA LCOAAA VVVVxx 4760 9528 0 0 0 0 60 760 760 4760 4760 120 121 CBAAAA MCOAAA AAAAxx 5524 9529 0 0 4 4 24 524 1524 524 5524 48 49 MEAAAA NCOAAA HHHHxx 2251 9530 1 3 1 11 51 251 251 2251 2251 102 103 PIAAAA OCOAAA OOOOxx 1511 9531 1 3 1 11 11 511 1511 1511 1511 22 23 DGAAAA PCOAAA VVVVxx 5991 9532 1 3 1 11 91 991 1991 991 5991 182 183 LWAAAA QCOAAA AAAAxx 7808 9533 0 0 8 8 8 808 1808 2808 7808 16 17 IOAAAA RCOAAA HHHHxx 8708 9534 0 0 8 8 8 708 708 3708 8708 16 17 YWAAAA SCOAAA OOOOxx 8939 9535 1 3 9 19 39 939 939 3939 8939 78 79 VFAAAA TCOAAA VVVVxx 4295 9536 1 3 5 15 95 295 295 4295 4295 190 191 FJAAAA UCOAAA AAAAxx 5905 9537 1 1 5 5 5 905 1905 905 5905 10 11 DTAAAA VCOAAA HHHHxx 2649 9538 1 1 9 9 49 649 649 2649 2649 98 99 XXAAAA WCOAAA OOOOxx 2347 9539 1 3 7 7 47 347 347 2347 2347 94 95 HMAAAA XCOAAA VVVVxx 6339 9540 1 3 9 19 39 339 339 1339 6339 78 79 VJAAAA YCOAAA AAAAxx 292 9541 0 0 2 12 92 292 292 292 292 184 185 GLAAAA ZCOAAA HHHHxx 9314 9542 0 2 4 14 14 314 1314 4314 9314 28 29 GUAAAA ADOAAA OOOOxx 6893 9543 1 1 3 13 93 893 893 1893 6893 186 187 DFAAAA BDOAAA VVVVxx 3970 9544 0 2 0 10 70 970 1970 3970 3970 140 141 SWAAAA CDOAAA AAAAxx 1652 9545 0 0 2 12 52 652 1652 1652 1652 104 105 OLAAAA DDOAAA HHHHxx 4326 9546 0 2 6 6 26 326 326 4326 4326 52 53 KKAAAA EDOAAA OOOOxx 7881 9547 1 1 1 1 81 881 1881 2881 7881 162 163 DRAAAA FDOAAA VVVVxx 5291 9548 1 3 1 11 91 291 1291 291 5291 182 183 NVAAAA GDOAAA AAAAxx 957 9549 1 1 7 17 57 957 957 957 957 114 115 VKAAAA HDOAAA HHHHxx 2313 9550 1 1 3 13 13 313 313 2313 2313 26 27 ZKAAAA IDOAAA OOOOxx 5463 9551 1 3 3 3 63 463 1463 463 5463 126 127 DCAAAA JDOAAA VVVVxx 1268 9552 0 0 8 8 68 268 1268 1268 1268 136 137 UWAAAA KDOAAA AAAAxx 5028 9553 0 0 8 8 28 28 1028 28 5028 56 57 KLAAAA LDOAAA HHHHxx 656 9554 0 0 6 16 56 656 656 656 656 112 113 GZAAAA MDOAAA OOOOxx 9274 9555 0 2 4 14 74 274 1274 4274 9274 148 149 SSAAAA NDOAAA VVVVxx 8217 9556 1 1 7 17 17 217 217 3217 8217 34 35 BEAAAA ODOAAA AAAAxx 2175 9557 1 3 5 15 75 175 175 2175 2175 150 151 RFAAAA PDOAAA HHHHxx 6028 9558 0 0 8 8 28 28 28 1028 6028 56 57 WXAAAA QDOAAA OOOOxx 7584 9559 0 0 4 4 84 584 1584 2584 7584 168 169 SFAAAA RDOAAA VVVVxx 4114 9560 0 2 4 14 14 114 114 4114 4114 28 29 GCAAAA SDOAAA AAAAxx 8894 9561 0 2 4 14 94 894 894 3894 8894 188 189 CEAAAA TDOAAA HHHHxx 781 9562 1 1 1 1 81 781 781 781 781 162 163 BEAAAA UDOAAA OOOOxx 133 9563 1 1 3 13 33 133 133 133 133 66 67 DFAAAA VDOAAA VVVVxx 7572 9564 0 0 2 12 72 572 1572 2572 7572 144 145 GFAAAA WDOAAA AAAAxx 8514 9565 0 2 4 14 14 514 514 3514 8514 28 29 MPAAAA XDOAAA HHHHxx 3352 9566 0 0 2 12 52 352 1352 3352 3352 104 105 YYAAAA YDOAAA OOOOxx 8098 9567 0 2 8 18 98 98 98 3098 8098 196 197 MZAAAA ZDOAAA VVVVxx 9116 9568 0 0 6 16 16 116 1116 4116 9116 32 33 QMAAAA AEOAAA AAAAxx 9444 9569 0 0 4 4 44 444 1444 4444 9444 88 89 GZAAAA BEOAAA HHHHxx 2590 9570 0 2 0 10 90 590 590 2590 2590 180 181 QVAAAA CEOAAA OOOOxx 7302 9571 0 2 2 2 2 302 1302 2302 7302 4 5 WUAAAA DEOAAA VVVVxx 7444 9572 0 0 4 4 44 444 1444 2444 7444 88 89 IAAAAA EEOAAA AAAAxx 8748 9573 0 0 8 8 48 748 748 3748 8748 96 97 MYAAAA FEOAAA HHHHxx 7615 9574 1 3 5 15 15 615 1615 2615 7615 30 31 XGAAAA GEOAAA OOOOxx 6090 9575 0 2 0 10 90 90 90 1090 6090 180 181 GAAAAA HEOAAA VVVVxx 1529 9576 1 1 9 9 29 529 1529 1529 1529 58 59 VGAAAA IEOAAA AAAAxx 9398 9577 0 2 8 18 98 398 1398 4398 9398 196 197 MXAAAA JEOAAA HHHHxx 6114 9578 0 2 4 14 14 114 114 1114 6114 28 29 EBAAAA KEOAAA OOOOxx 2736 9579 0 0 6 16 36 736 736 2736 2736 72 73 GBAAAA LEOAAA VVVVxx 468 9580 0 0 8 8 68 468 468 468 468 136 137 ASAAAA MEOAAA AAAAxx 1487 9581 1 3 7 7 87 487 1487 1487 1487 174 175 FFAAAA NEOAAA HHHHxx 4784 9582 0 0 4 4 84 784 784 4784 4784 168 169 ACAAAA OEOAAA OOOOxx 6731 9583 1 3 1 11 31 731 731 1731 6731 62 63 XYAAAA PEOAAA VVVVxx 3328 9584 0 0 8 8 28 328 1328 3328 3328 56 57 AYAAAA QEOAAA AAAAxx 6891 9585 1 3 1 11 91 891 891 1891 6891 182 183 BFAAAA REOAAA HHHHxx 8039 9586 1 3 9 19 39 39 39 3039 8039 78 79 FXAAAA SEOAAA OOOOxx 4064 9587 0 0 4 4 64 64 64 4064 4064 128 129 IAAAAA TEOAAA VVVVxx 542 9588 0 2 2 2 42 542 542 542 542 84 85 WUAAAA UEOAAA AAAAxx 1039 9589 1 3 9 19 39 39 1039 1039 1039 78 79 ZNAAAA VEOAAA HHHHxx 5603 9590 1 3 3 3 3 603 1603 603 5603 6 7 NHAAAA WEOAAA OOOOxx 6641 9591 1 1 1 1 41 641 641 1641 6641 82 83 LVAAAA XEOAAA VVVVxx 6307 9592 1 3 7 7 7 307 307 1307 6307 14 15 PIAAAA YEOAAA AAAAxx 5354 9593 0 2 4 14 54 354 1354 354 5354 108 109 YXAAAA ZEOAAA HHHHxx 7878 9594 0 2 8 18 78 878 1878 2878 7878 156 157 ARAAAA AFOAAA OOOOxx 6391 9595 1 3 1 11 91 391 391 1391 6391 182 183 VLAAAA BFOAAA VVVVxx 4575 9596 1 3 5 15 75 575 575 4575 4575 150 151 ZTAAAA CFOAAA AAAAxx 6644 9597 0 0 4 4 44 644 644 1644 6644 88 89 OVAAAA DFOAAA HHHHxx 5207 9598 1 3 7 7 7 207 1207 207 5207 14 15 HSAAAA EFOAAA OOOOxx 1736 9599 0 0 6 16 36 736 1736 1736 1736 72 73 UOAAAA FFOAAA VVVVxx 3547 9600 1 3 7 7 47 547 1547 3547 3547 94 95 LGAAAA GFOAAA AAAAxx 6647 9601 1 3 7 7 47 647 647 1647 6647 94 95 RVAAAA HFOAAA HHHHxx 4107 9602 1 3 7 7 7 107 107 4107 4107 14 15 ZBAAAA IFOAAA OOOOxx 8125 9603 1 1 5 5 25 125 125 3125 8125 50 51 NAAAAA JFOAAA VVVVxx 9223 9604 1 3 3 3 23 223 1223 4223 9223 46 47 TQAAAA KFOAAA AAAAxx 6903 9605 1 3 3 3 3 903 903 1903 6903 6 7 NFAAAA LFOAAA HHHHxx 3639 9606 1 3 9 19 39 639 1639 3639 3639 78 79 ZJAAAA MFOAAA OOOOxx 9606 9607 0 2 6 6 6 606 1606 4606 9606 12 13 MFAAAA NFOAAA VVVVxx 3232 9608 0 0 2 12 32 232 1232 3232 3232 64 65 IUAAAA OFOAAA AAAAxx 2063 9609 1 3 3 3 63 63 63 2063 2063 126 127 JBAAAA PFOAAA HHHHxx 3731 9610 1 3 1 11 31 731 1731 3731 3731 62 63 NNAAAA QFOAAA OOOOxx 2558 9611 0 2 8 18 58 558 558 2558 2558 116 117 KUAAAA RFOAAA VVVVxx 2357 9612 1 1 7 17 57 357 357 2357 2357 114 115 RMAAAA SFOAAA AAAAxx 6008 9613 0 0 8 8 8 8 8 1008 6008 16 17 CXAAAA TFOAAA HHHHxx 8246 9614 0 2 6 6 46 246 246 3246 8246 92 93 EFAAAA UFOAAA OOOOxx 8220 9615 0 0 0 0 20 220 220 3220 8220 40 41 EEAAAA VFOAAA VVVVxx 1075 9616 1 3 5 15 75 75 1075 1075 1075 150 151 JPAAAA WFOAAA AAAAxx 2410 9617 0 2 0 10 10 410 410 2410 2410 20 21 SOAAAA XFOAAA HHHHxx 3253 9618 1 1 3 13 53 253 1253 3253 3253 106 107 DVAAAA YFOAAA OOOOxx 4370 9619 0 2 0 10 70 370 370 4370 4370 140 141 CMAAAA ZFOAAA VVVVxx 8426 9620 0 2 6 6 26 426 426 3426 8426 52 53 CMAAAA AGOAAA AAAAxx 2262 9621 0 2 2 2 62 262 262 2262 2262 124 125 AJAAAA BGOAAA HHHHxx 4149 9622 1 1 9 9 49 149 149 4149 4149 98 99 PDAAAA CGOAAA OOOOxx 2732 9623 0 0 2 12 32 732 732 2732 2732 64 65 CBAAAA DGOAAA VVVVxx 8606 9624 0 2 6 6 6 606 606 3606 8606 12 13 ATAAAA EGOAAA AAAAxx 6311 9625 1 3 1 11 11 311 311 1311 6311 22 23 TIAAAA FGOAAA HHHHxx 7223 9626 1 3 3 3 23 223 1223 2223 7223 46 47 VRAAAA GGOAAA OOOOxx 3054 9627 0 2 4 14 54 54 1054 3054 3054 108 109 MNAAAA HGOAAA VVVVxx 3952 9628 0 0 2 12 52 952 1952 3952 3952 104 105 AWAAAA IGOAAA AAAAxx 8252 9629 0 0 2 12 52 252 252 3252 8252 104 105 KFAAAA JGOAAA HHHHxx 6020 9630 0 0 0 0 20 20 20 1020 6020 40 41 OXAAAA KGOAAA OOOOxx 3846 9631 0 2 6 6 46 846 1846 3846 3846 92 93 YRAAAA LGOAAA VVVVxx 3755 9632 1 3 5 15 55 755 1755 3755 3755 110 111 LOAAAA MGOAAA AAAAxx 3765 9633 1 1 5 5 65 765 1765 3765 3765 130 131 VOAAAA NGOAAA HHHHxx 3434 9634 0 2 4 14 34 434 1434 3434 3434 68 69 CCAAAA OGOAAA OOOOxx 1381 9635 1 1 1 1 81 381 1381 1381 1381 162 163 DBAAAA PGOAAA VVVVxx 287 9636 1 3 7 7 87 287 287 287 287 174 175 BLAAAA QGOAAA AAAAxx 4476 9637 0 0 6 16 76 476 476 4476 4476 152 153 EQAAAA RGOAAA HHHHxx 2916 9638 0 0 6 16 16 916 916 2916 2916 32 33 EIAAAA SGOAAA OOOOxx 4517 9639 1 1 7 17 17 517 517 4517 4517 34 35 TRAAAA TGOAAA VVVVxx 4561 9640 1 1 1 1 61 561 561 4561 4561 122 123 LTAAAA UGOAAA AAAAxx 5106 9641 0 2 6 6 6 106 1106 106 5106 12 13 KOAAAA VGOAAA HHHHxx 2077 9642 1 1 7 17 77 77 77 2077 2077 154 155 XBAAAA WGOAAA OOOOxx 5269 9643 1 1 9 9 69 269 1269 269 5269 138 139 RUAAAA XGOAAA VVVVxx 5688 9644 0 0 8 8 88 688 1688 688 5688 176 177 UKAAAA YGOAAA AAAAxx 8831 9645 1 3 1 11 31 831 831 3831 8831 62 63 RBAAAA ZGOAAA HHHHxx 3867 9646 1 3 7 7 67 867 1867 3867 3867 134 135 TSAAAA AHOAAA OOOOxx 6062 9647 0 2 2 2 62 62 62 1062 6062 124 125 EZAAAA BHOAAA VVVVxx 8460 9648 0 0 0 0 60 460 460 3460 8460 120 121 KNAAAA CHOAAA AAAAxx 3138 9649 0 2 8 18 38 138 1138 3138 3138 76 77 SQAAAA DHOAAA HHHHxx 3173 9650 1 1 3 13 73 173 1173 3173 3173 146 147 BSAAAA EHOAAA OOOOxx 7018 9651 0 2 8 18 18 18 1018 2018 7018 36 37 YJAAAA FHOAAA VVVVxx 4836 9652 0 0 6 16 36 836 836 4836 4836 72 73 AEAAAA GHOAAA AAAAxx 1007 9653 1 3 7 7 7 7 1007 1007 1007 14 15 TMAAAA HHOAAA HHHHxx 658 9654 0 2 8 18 58 658 658 658 658 116 117 IZAAAA IHOAAA OOOOxx 5205 9655 1 1 5 5 5 205 1205 205 5205 10 11 FSAAAA JHOAAA VVVVxx 5805 9656 1 1 5 5 5 805 1805 805 5805 10 11 HPAAAA KHOAAA AAAAxx 5959 9657 1 3 9 19 59 959 1959 959 5959 118 119 FVAAAA LHOAAA HHHHxx 2863 9658 1 3 3 3 63 863 863 2863 2863 126 127 DGAAAA MHOAAA OOOOxx 7272 9659 0 0 2 12 72 272 1272 2272 7272 144 145 STAAAA NHOAAA VVVVxx 8437 9660 1 1 7 17 37 437 437 3437 8437 74 75 NMAAAA OHOAAA AAAAxx 4900 9661 0 0 0 0 0 900 900 4900 4900 0 1 MGAAAA PHOAAA HHHHxx 890 9662 0 2 0 10 90 890 890 890 890 180 181 GIAAAA QHOAAA OOOOxx 3530 9663 0 2 0 10 30 530 1530 3530 3530 60 61 UFAAAA RHOAAA VVVVxx 6209 9664 1 1 9 9 9 209 209 1209 6209 18 19 VEAAAA SHOAAA AAAAxx 4595 9665 1 3 5 15 95 595 595 4595 4595 190 191 TUAAAA THOAAA HHHHxx 5982 9666 0 2 2 2 82 982 1982 982 5982 164 165 CWAAAA UHOAAA OOOOxx 1101 9667 1 1 1 1 1 101 1101 1101 1101 2 3 JQAAAA VHOAAA VVVVxx 9555 9668 1 3 5 15 55 555 1555 4555 9555 110 111 NDAAAA WHOAAA AAAAxx 1918 9669 0 2 8 18 18 918 1918 1918 1918 36 37 UVAAAA XHOAAA HHHHxx 3527 9670 1 3 7 7 27 527 1527 3527 3527 54 55 RFAAAA YHOAAA OOOOxx 7309 9671 1 1 9 9 9 309 1309 2309 7309 18 19 DVAAAA ZHOAAA VVVVxx 8213 9672 1 1 3 13 13 213 213 3213 8213 26 27 XDAAAA AIOAAA AAAAxx 306 9673 0 2 6 6 6 306 306 306 306 12 13 ULAAAA BIOAAA HHHHxx 845 9674 1 1 5 5 45 845 845 845 845 90 91 NGAAAA CIOAAA OOOOxx 16 9675 0 0 6 16 16 16 16 16 16 32 33 QAAAAA DIOAAA VVVVxx 437 9676 1 1 7 17 37 437 437 437 437 74 75 VQAAAA EIOAAA AAAAxx 9518 9677 0 2 8 18 18 518 1518 4518 9518 36 37 CCAAAA FIOAAA HHHHxx 2142 9678 0 2 2 2 42 142 142 2142 2142 84 85 KEAAAA GIOAAA OOOOxx 8121 9679 1 1 1 1 21 121 121 3121 8121 42 43 JAAAAA HIOAAA VVVVxx 7354 9680 0 2 4 14 54 354 1354 2354 7354 108 109 WWAAAA IIOAAA AAAAxx 1720 9681 0 0 0 0 20 720 1720 1720 1720 40 41 EOAAAA JIOAAA HHHHxx 6078 9682 0 2 8 18 78 78 78 1078 6078 156 157 UZAAAA KIOAAA OOOOxx 5929 9683 1 1 9 9 29 929 1929 929 5929 58 59 BUAAAA LIOAAA VVVVxx 3856 9684 0 0 6 16 56 856 1856 3856 3856 112 113 ISAAAA MIOAAA AAAAxx 3424 9685 0 0 4 4 24 424 1424 3424 3424 48 49 SBAAAA NIOAAA HHHHxx 1712 9686 0 0 2 12 12 712 1712 1712 1712 24 25 WNAAAA OIOAAA OOOOxx 2340 9687 0 0 0 0 40 340 340 2340 2340 80 81 AMAAAA PIOAAA VVVVxx 5570 9688 0 2 0 10 70 570 1570 570 5570 140 141 GGAAAA QIOAAA AAAAxx 8734 9689 0 2 4 14 34 734 734 3734 8734 68 69 YXAAAA RIOAAA HHHHxx 6077 9690 1 1 7 17 77 77 77 1077 6077 154 155 TZAAAA SIOAAA OOOOxx 2960 9691 0 0 0 0 60 960 960 2960 2960 120 121 WJAAAA TIOAAA VVVVxx 5062 9692 0 2 2 2 62 62 1062 62 5062 124 125 SMAAAA UIOAAA AAAAxx 1532 9693 0 0 2 12 32 532 1532 1532 1532 64 65 YGAAAA VIOAAA HHHHxx 8298 9694 0 2 8 18 98 298 298 3298 8298 196 197 EHAAAA WIOAAA OOOOxx 2496 9695 0 0 6 16 96 496 496 2496 2496 192 193 ASAAAA XIOAAA VVVVxx 8412 9696 0 0 2 12 12 412 412 3412 8412 24 25 OLAAAA YIOAAA AAAAxx 724 9697 0 0 4 4 24 724 724 724 724 48 49 WBAAAA ZIOAAA HHHHxx 1019 9698 1 3 9 19 19 19 1019 1019 1019 38 39 FNAAAA AJOAAA OOOOxx 6265 9699 1 1 5 5 65 265 265 1265 6265 130 131 ZGAAAA BJOAAA VVVVxx 740 9700 0 0 0 0 40 740 740 740 740 80 81 MCAAAA CJOAAA AAAAxx 8495 9701 1 3 5 15 95 495 495 3495 8495 190 191 TOAAAA DJOAAA HHHHxx 6983 9702 1 3 3 3 83 983 983 1983 6983 166 167 PIAAAA EJOAAA OOOOxx 991 9703 1 3 1 11 91 991 991 991 991 182 183 DMAAAA FJOAAA VVVVxx 3189 9704 1 1 9 9 89 189 1189 3189 3189 178 179 RSAAAA GJOAAA AAAAxx 4487 9705 1 3 7 7 87 487 487 4487 4487 174 175 PQAAAA HJOAAA HHHHxx 5554 9706 0 2 4 14 54 554 1554 554 5554 108 109 QFAAAA IJOAAA OOOOxx 1258 9707 0 2 8 18 58 258 1258 1258 1258 116 117 KWAAAA JJOAAA VVVVxx 5359 9708 1 3 9 19 59 359 1359 359 5359 118 119 DYAAAA KJOAAA AAAAxx 2709 9709 1 1 9 9 9 709 709 2709 2709 18 19 FAAAAA LJOAAA HHHHxx 361 9710 1 1 1 1 61 361 361 361 361 122 123 XNAAAA MJOAAA OOOOxx 4028 9711 0 0 8 8 28 28 28 4028 4028 56 57 YYAAAA NJOAAA VVVVxx 3735 9712 1 3 5 15 35 735 1735 3735 3735 70 71 RNAAAA OJOAAA AAAAxx 4427 9713 1 3 7 7 27 427 427 4427 4427 54 55 HOAAAA PJOAAA HHHHxx 7540 9714 0 0 0 0 40 540 1540 2540 7540 80 81 AEAAAA QJOAAA OOOOxx 3569 9715 1 1 9 9 69 569 1569 3569 3569 138 139 HHAAAA RJOAAA VVVVxx 1916 9716 0 0 6 16 16 916 1916 1916 1916 32 33 SVAAAA SJOAAA AAAAxx 7596 9717 0 0 6 16 96 596 1596 2596 7596 192 193 EGAAAA TJOAAA HHHHxx 9721 9718 1 1 1 1 21 721 1721 4721 9721 42 43 XJAAAA UJOAAA OOOOxx 4429 9719 1 1 9 9 29 429 429 4429 4429 58 59 JOAAAA VJOAAA VVVVxx 3471 9720 1 3 1 11 71 471 1471 3471 3471 142 143 NDAAAA WJOAAA AAAAxx 1157 9721 1 1 7 17 57 157 1157 1157 1157 114 115 NSAAAA XJOAAA HHHHxx 5700 9722 0 0 0 0 0 700 1700 700 5700 0 1 GLAAAA YJOAAA OOOOxx 4431 9723 1 3 1 11 31 431 431 4431 4431 62 63 LOAAAA ZJOAAA VVVVxx 9409 9724 1 1 9 9 9 409 1409 4409 9409 18 19 XXAAAA AKOAAA AAAAxx 8752 9725 0 0 2 12 52 752 752 3752 8752 104 105 QYAAAA BKOAAA HHHHxx 9484 9726 0 0 4 4 84 484 1484 4484 9484 168 169 UAAAAA CKOAAA OOOOxx 1266 9727 0 2 6 6 66 266 1266 1266 1266 132 133 SWAAAA DKOAAA VVVVxx 9097 9728 1 1 7 17 97 97 1097 4097 9097 194 195 XLAAAA EKOAAA AAAAxx 3068 9729 0 0 8 8 68 68 1068 3068 3068 136 137 AOAAAA FKOAAA HHHHxx 5490 9730 0 2 0 10 90 490 1490 490 5490 180 181 EDAAAA GKOAAA OOOOxx 1375 9731 1 3 5 15 75 375 1375 1375 1375 150 151 XAAAAA HKOAAA VVVVxx 2487 9732 1 3 7 7 87 487 487 2487 2487 174 175 RRAAAA IKOAAA AAAAxx 1705 9733 1 1 5 5 5 705 1705 1705 1705 10 11 PNAAAA JKOAAA HHHHxx 1571 9734 1 3 1 11 71 571 1571 1571 1571 142 143 LIAAAA KKOAAA OOOOxx 4005 9735 1 1 5 5 5 5 5 4005 4005 10 11 BYAAAA LKOAAA VVVVxx 5497 9736 1 1 7 17 97 497 1497 497 5497 194 195 LDAAAA MKOAAA AAAAxx 2144 9737 0 0 4 4 44 144 144 2144 2144 88 89 MEAAAA NKOAAA HHHHxx 4052 9738 0 0 2 12 52 52 52 4052 4052 104 105 WZAAAA OKOAAA OOOOxx 4942 9739 0 2 2 2 42 942 942 4942 4942 84 85 CIAAAA PKOAAA VVVVxx 5504 9740 0 0 4 4 4 504 1504 504 5504 8 9 SDAAAA QKOAAA AAAAxx 2913 9741 1 1 3 13 13 913 913 2913 2913 26 27 BIAAAA RKOAAA HHHHxx 5617 9742 1 1 7 17 17 617 1617 617 5617 34 35 BIAAAA SKOAAA OOOOxx 8179 9743 1 3 9 19 79 179 179 3179 8179 158 159 PCAAAA TKOAAA VVVVxx 9437 9744 1 1 7 17 37 437 1437 4437 9437 74 75 ZYAAAA UKOAAA AAAAxx 1821 9745 1 1 1 1 21 821 1821 1821 1821 42 43 BSAAAA VKOAAA HHHHxx 5737 9746 1 1 7 17 37 737 1737 737 5737 74 75 RMAAAA WKOAAA OOOOxx 4207 9747 1 3 7 7 7 207 207 4207 4207 14 15 VFAAAA XKOAAA VVVVxx 4815 9748 1 3 5 15 15 815 815 4815 4815 30 31 FDAAAA YKOAAA AAAAxx 8707 9749 1 3 7 7 7 707 707 3707 8707 14 15 XWAAAA ZKOAAA HHHHxx 5970 9750 0 2 0 10 70 970 1970 970 5970 140 141 QVAAAA ALOAAA OOOOxx 5501 9751 1 1 1 1 1 501 1501 501 5501 2 3 PDAAAA BLOAAA VVVVxx 4013 9752 1 1 3 13 13 13 13 4013 4013 26 27 JYAAAA CLOAAA AAAAxx 9235 9753 1 3 5 15 35 235 1235 4235 9235 70 71 FRAAAA DLOAAA HHHHxx 2503 9754 1 3 3 3 3 503 503 2503 2503 6 7 HSAAAA ELOAAA OOOOxx 9181 9755 1 1 1 1 81 181 1181 4181 9181 162 163 DPAAAA FLOAAA VVVVxx 2289 9756 1 1 9 9 89 289 289 2289 2289 178 179 BKAAAA GLOAAA AAAAxx 4256 9757 0 0 6 16 56 256 256 4256 4256 112 113 SHAAAA HLOAAA HHHHxx 191 9758 1 3 1 11 91 191 191 191 191 182 183 JHAAAA ILOAAA OOOOxx 9655 9759 1 3 5 15 55 655 1655 4655 9655 110 111 JHAAAA JLOAAA VVVVxx 8615 9760 1 3 5 15 15 615 615 3615 8615 30 31 JTAAAA KLOAAA AAAAxx 3011 9761 1 3 1 11 11 11 1011 3011 3011 22 23 VLAAAA LLOAAA HHHHxx 6376 9762 0 0 6 16 76 376 376 1376 6376 152 153 GLAAAA MLOAAA OOOOxx 68 9763 0 0 8 8 68 68 68 68 68 136 137 QCAAAA NLOAAA VVVVxx 4720 9764 0 0 0 0 20 720 720 4720 4720 40 41 OZAAAA OLOAAA AAAAxx 6848 9765 0 0 8 8 48 848 848 1848 6848 96 97 KDAAAA PLOAAA HHHHxx 456 9766 0 0 6 16 56 456 456 456 456 112 113 ORAAAA QLOAAA OOOOxx 5887 9767 1 3 7 7 87 887 1887 887 5887 174 175 LSAAAA RLOAAA VVVVxx 9249 9768 1 1 9 9 49 249 1249 4249 9249 98 99 TRAAAA SLOAAA AAAAxx 4041 9769 1 1 1 1 41 41 41 4041 4041 82 83 LZAAAA TLOAAA HHHHxx 2304 9770 0 0 4 4 4 304 304 2304 2304 8 9 QKAAAA ULOAAA OOOOxx 8763 9771 1 3 3 3 63 763 763 3763 8763 126 127 BZAAAA VLOAAA VVVVxx 2115 9772 1 3 5 15 15 115 115 2115 2115 30 31 JDAAAA WLOAAA AAAAxx 8014 9773 0 2 4 14 14 14 14 3014 8014 28 29 GWAAAA XLOAAA HHHHxx 9895 9774 1 3 5 15 95 895 1895 4895 9895 190 191 PQAAAA YLOAAA OOOOxx 671 9775 1 3 1 11 71 671 671 671 671 142 143 VZAAAA ZLOAAA VVVVxx 3774 9776 0 2 4 14 74 774 1774 3774 3774 148 149 EPAAAA AMOAAA AAAAxx 134 9777 0 2 4 14 34 134 134 134 134 68 69 EFAAAA BMOAAA HHHHxx 534 9778 0 2 4 14 34 534 534 534 534 68 69 OUAAAA CMOAAA OOOOxx 7308 9779 0 0 8 8 8 308 1308 2308 7308 16 17 CVAAAA DMOAAA VVVVxx 5244 9780 0 0 4 4 44 244 1244 244 5244 88 89 STAAAA EMOAAA AAAAxx 1512 9781 0 0 2 12 12 512 1512 1512 1512 24 25 EGAAAA FMOAAA HHHHxx 8960 9782 0 0 0 0 60 960 960 3960 8960 120 121 QGAAAA GMOAAA OOOOxx 6602 9783 0 2 2 2 2 602 602 1602 6602 4 5 YTAAAA HMOAAA VVVVxx 593 9784 1 1 3 13 93 593 593 593 593 186 187 VWAAAA IMOAAA AAAAxx 2353 9785 1 1 3 13 53 353 353 2353 2353 106 107 NMAAAA JMOAAA HHHHxx 4139 9786 1 3 9 19 39 139 139 4139 4139 78 79 FDAAAA KMOAAA OOOOxx 3063 9787 1 3 3 3 63 63 1063 3063 3063 126 127 VNAAAA LMOAAA VVVVxx 652 9788 0 0 2 12 52 652 652 652 652 104 105 CZAAAA MMOAAA AAAAxx 7405 9789 1 1 5 5 5 405 1405 2405 7405 10 11 VYAAAA NMOAAA HHHHxx 3034 9790 0 2 4 14 34 34 1034 3034 3034 68 69 SMAAAA OMOAAA OOOOxx 4614 9791 0 2 4 14 14 614 614 4614 4614 28 29 MVAAAA PMOAAA VVVVxx 2351 9792 1 3 1 11 51 351 351 2351 2351 102 103 LMAAAA QMOAAA AAAAxx 8208 9793 0 0 8 8 8 208 208 3208 8208 16 17 SDAAAA RMOAAA HHHHxx 5475 9794 1 3 5 15 75 475 1475 475 5475 150 151 PCAAAA SMOAAA OOOOxx 6875 9795 1 3 5 15 75 875 875 1875 6875 150 151 LEAAAA TMOAAA VVVVxx 563 9796 1 3 3 3 63 563 563 563 563 126 127 RVAAAA UMOAAA AAAAxx 3346 9797 0 2 6 6 46 346 1346 3346 3346 92 93 SYAAAA VMOAAA HHHHxx 291 9798 1 3 1 11 91 291 291 291 291 182 183 FLAAAA WMOAAA OOOOxx 6345 9799 1 1 5 5 45 345 345 1345 6345 90 91 BKAAAA XMOAAA VVVVxx 8099 9800 1 3 9 19 99 99 99 3099 8099 198 199 NZAAAA YMOAAA AAAAxx 2078 9801 0 2 8 18 78 78 78 2078 2078 156 157 YBAAAA ZMOAAA HHHHxx 8238 9802 0 2 8 18 38 238 238 3238 8238 76 77 WEAAAA ANOAAA OOOOxx 4482 9803 0 2 2 2 82 482 482 4482 4482 164 165 KQAAAA BNOAAA VVVVxx 716 9804 0 0 6 16 16 716 716 716 716 32 33 OBAAAA CNOAAA AAAAxx 7288 9805 0 0 8 8 88 288 1288 2288 7288 176 177 IUAAAA DNOAAA HHHHxx 5906 9806 0 2 6 6 6 906 1906 906 5906 12 13 ETAAAA ENOAAA OOOOxx 5618 9807 0 2 8 18 18 618 1618 618 5618 36 37 CIAAAA FNOAAA VVVVxx 1141 9808 1 1 1 1 41 141 1141 1141 1141 82 83 XRAAAA GNOAAA AAAAxx 8231 9809 1 3 1 11 31 231 231 3231 8231 62 63 PEAAAA HNOAAA HHHHxx 3713 9810 1 1 3 13 13 713 1713 3713 3713 26 27 VMAAAA INOAAA OOOOxx 9158 9811 0 2 8 18 58 158 1158 4158 9158 116 117 GOAAAA JNOAAA VVVVxx 4051 9812 1 3 1 11 51 51 51 4051 4051 102 103 VZAAAA KNOAAA AAAAxx 1973 9813 1 1 3 13 73 973 1973 1973 1973 146 147 XXAAAA LNOAAA HHHHxx 6710 9814 0 2 0 10 10 710 710 1710 6710 20 21 CYAAAA MNOAAA OOOOxx 1021 9815 1 1 1 1 21 21 1021 1021 1021 42 43 HNAAAA NNOAAA VVVVxx 2196 9816 0 0 6 16 96 196 196 2196 2196 192 193 MGAAAA ONOAAA AAAAxx 8335 9817 1 3 5 15 35 335 335 3335 8335 70 71 PIAAAA PNOAAA HHHHxx 2272 9818 0 0 2 12 72 272 272 2272 2272 144 145 KJAAAA QNOAAA OOOOxx 3818 9819 0 2 8 18 18 818 1818 3818 3818 36 37 WQAAAA RNOAAA VVVVxx 679 9820 1 3 9 19 79 679 679 679 679 158 159 DAAAAA SNOAAA AAAAxx 7512 9821 0 0 2 12 12 512 1512 2512 7512 24 25 YCAAAA TNOAAA HHHHxx 493 9822 1 1 3 13 93 493 493 493 493 186 187 ZSAAAA UNOAAA OOOOxx 5663 9823 1 3 3 3 63 663 1663 663 5663 126 127 VJAAAA VNOAAA VVVVxx 4655 9824 1 3 5 15 55 655 655 4655 4655 110 111 BXAAAA WNOAAA AAAAxx 3996 9825 0 0 6 16 96 996 1996 3996 3996 192 193 SXAAAA XNOAAA HHHHxx 8797 9826 1 1 7 17 97 797 797 3797 8797 194 195 JAAAAA YNOAAA OOOOxx 2991 9827 1 3 1 11 91 991 991 2991 2991 182 183 BLAAAA ZNOAAA VVVVxx 7038 9828 0 2 8 18 38 38 1038 2038 7038 76 77 SKAAAA AOOAAA AAAAxx 4174 9829 0 2 4 14 74 174 174 4174 4174 148 149 OEAAAA BOOAAA HHHHxx 6908 9830 0 0 8 8 8 908 908 1908 6908 16 17 SFAAAA COOAAA OOOOxx 8477 9831 1 1 7 17 77 477 477 3477 8477 154 155 BOAAAA DOOAAA VVVVxx 3576 9832 0 0 6 16 76 576 1576 3576 3576 152 153 OHAAAA EOOAAA AAAAxx 2685 9833 1 1 5 5 85 685 685 2685 2685 170 171 HZAAAA FOOAAA HHHHxx 9161 9834 1 1 1 1 61 161 1161 4161 9161 122 123 JOAAAA GOOAAA OOOOxx 2951 9835 1 3 1 11 51 951 951 2951 2951 102 103 NJAAAA HOOAAA VVVVxx 8362 9836 0 2 2 2 62 362 362 3362 8362 124 125 QJAAAA IOOAAA AAAAxx 2379 9837 1 3 9 19 79 379 379 2379 2379 158 159 NNAAAA JOOAAA HHHHxx 1277 9838 1 1 7 17 77 277 1277 1277 1277 154 155 DXAAAA KOOAAA OOOOxx 1728 9839 0 0 8 8 28 728 1728 1728 1728 56 57 MOAAAA LOOAAA VVVVxx 9816 9840 0 0 6 16 16 816 1816 4816 9816 32 33 ONAAAA MOOAAA AAAAxx 6288 9841 0 0 8 8 88 288 288 1288 6288 176 177 WHAAAA NOOAAA HHHHxx 8985 9842 1 1 5 5 85 985 985 3985 8985 170 171 PHAAAA OOOAAA OOOOxx 771 9843 1 3 1 11 71 771 771 771 771 142 143 RDAAAA POOAAA VVVVxx 464 9844 0 0 4 4 64 464 464 464 464 128 129 WRAAAA QOOAAA AAAAxx 9625 9845 1 1 5 5 25 625 1625 4625 9625 50 51 FGAAAA ROOAAA HHHHxx 9608 9846 0 0 8 8 8 608 1608 4608 9608 16 17 OFAAAA SOOAAA OOOOxx 9170 9847 0 2 0 10 70 170 1170 4170 9170 140 141 SOAAAA TOOAAA VVVVxx 9658 9848 0 2 8 18 58 658 1658 4658 9658 116 117 MHAAAA UOOAAA AAAAxx 7515 9849 1 3 5 15 15 515 1515 2515 7515 30 31 BDAAAA VOOAAA HHHHxx 9400 9850 0 0 0 0 0 400 1400 4400 9400 0 1 OXAAAA WOOAAA OOOOxx 2045 9851 1 1 5 5 45 45 45 2045 2045 90 91 RAAAAA XOOAAA VVVVxx 324 9852 0 0 4 4 24 324 324 324 324 48 49 MMAAAA YOOAAA AAAAxx 4252 9853 0 0 2 12 52 252 252 4252 4252 104 105 OHAAAA ZOOAAA HHHHxx 8329 9854 1 1 9 9 29 329 329 3329 8329 58 59 JIAAAA APOAAA OOOOxx 4472 9855 0 0 2 12 72 472 472 4472 4472 144 145 AQAAAA BPOAAA VVVVxx 1047 9856 1 3 7 7 47 47 1047 1047 1047 94 95 HOAAAA CPOAAA AAAAxx 9341 9857 1 1 1 1 41 341 1341 4341 9341 82 83 HVAAAA DPOAAA HHHHxx 7000 9858 0 0 0 0 0 0 1000 2000 7000 0 1 GJAAAA EPOAAA OOOOxx 1429 9859 1 1 9 9 29 429 1429 1429 1429 58 59 ZCAAAA FPOAAA VVVVxx 2701 9860 1 1 1 1 1 701 701 2701 2701 2 3 XZAAAA GPOAAA AAAAxx 6630 9861 0 2 0 10 30 630 630 1630 6630 60 61 AVAAAA HPOAAA HHHHxx 3669 9862 1 1 9 9 69 669 1669 3669 3669 138 139 DLAAAA IPOAAA OOOOxx 8613 9863 1 1 3 13 13 613 613 3613 8613 26 27 HTAAAA JPOAAA VVVVxx 7080 9864 0 0 0 0 80 80 1080 2080 7080 160 161 IMAAAA KPOAAA AAAAxx 8788 9865 0 0 8 8 88 788 788 3788 8788 176 177 AAAAAA LPOAAA HHHHxx 6291 9866 1 3 1 11 91 291 291 1291 6291 182 183 ZHAAAA MPOAAA OOOOxx 7885 9867 1 1 5 5 85 885 1885 2885 7885 170 171 HRAAAA NPOAAA VVVVxx 7160 9868 0 0 0 0 60 160 1160 2160 7160 120 121 KPAAAA OPOAAA AAAAxx 6140 9869 0 0 0 0 40 140 140 1140 6140 80 81 ECAAAA PPOAAA HHHHxx 9881 9870 1 1 1 1 81 881 1881 4881 9881 162 163 BQAAAA QPOAAA OOOOxx 9140 9871 0 0 0 0 40 140 1140 4140 9140 80 81 ONAAAA RPOAAA VVVVxx 644 9872 0 0 4 4 44 644 644 644 644 88 89 UYAAAA SPOAAA AAAAxx 3667 9873 1 3 7 7 67 667 1667 3667 3667 134 135 BLAAAA TPOAAA HHHHxx 2675 9874 1 3 5 15 75 675 675 2675 2675 150 151 XYAAAA UPOAAA OOOOxx 9492 9875 0 0 2 12 92 492 1492 4492 9492 184 185 CBAAAA VPOAAA VVVVxx 5004 9876 0 0 4 4 4 4 1004 4 5004 8 9 MKAAAA WPOAAA AAAAxx 9456 9877 0 0 6 16 56 456 1456 4456 9456 112 113 SZAAAA XPOAAA HHHHxx 8197 9878 1 1 7 17 97 197 197 3197 8197 194 195 HDAAAA YPOAAA OOOOxx 2837 9879 1 1 7 17 37 837 837 2837 2837 74 75 DFAAAA ZPOAAA VVVVxx 127 9880 1 3 7 7 27 127 127 127 127 54 55 XEAAAA AQOAAA AAAAxx 9772 9881 0 0 2 12 72 772 1772 4772 9772 144 145 WLAAAA BQOAAA HHHHxx 5743 9882 1 3 3 3 43 743 1743 743 5743 86 87 XMAAAA CQOAAA OOOOxx 2007 9883 1 3 7 7 7 7 7 2007 2007 14 15 FZAAAA DQOAAA VVVVxx 7586 9884 0 2 6 6 86 586 1586 2586 7586 172 173 UFAAAA EQOAAA AAAAxx 45 9885 1 1 5 5 45 45 45 45 45 90 91 TBAAAA FQOAAA HHHHxx 6482 9886 0 2 2 2 82 482 482 1482 6482 164 165 IPAAAA GQOAAA OOOOxx 4565 9887 1 1 5 5 65 565 565 4565 4565 130 131 PTAAAA HQOAAA VVVVxx 6975 9888 1 3 5 15 75 975 975 1975 6975 150 151 HIAAAA IQOAAA AAAAxx 7260 9889 0 0 0 0 60 260 1260 2260 7260 120 121 GTAAAA JQOAAA HHHHxx 2830 9890 0 2 0 10 30 830 830 2830 2830 60 61 WEAAAA KQOAAA OOOOxx 9365 9891 1 1 5 5 65 365 1365 4365 9365 130 131 FWAAAA LQOAAA VVVVxx 8207 9892 1 3 7 7 7 207 207 3207 8207 14 15 RDAAAA MQOAAA AAAAxx 2506 9893 0 2 6 6 6 506 506 2506 2506 12 13 KSAAAA NQOAAA HHHHxx 8081 9894 1 1 1 1 81 81 81 3081 8081 162 163 VYAAAA OQOAAA OOOOxx 8678 9895 0 2 8 18 78 678 678 3678 8678 156 157 UVAAAA PQOAAA VVVVxx 9932 9896 0 0 2 12 32 932 1932 4932 9932 64 65 ASAAAA QQOAAA AAAAxx 447 9897 1 3 7 7 47 447 447 447 447 94 95 FRAAAA RQOAAA HHHHxx 9187 9898 1 3 7 7 87 187 1187 4187 9187 174 175 JPAAAA SQOAAA OOOOxx 89 9899 1 1 9 9 89 89 89 89 89 178 179 LDAAAA TQOAAA VVVVxx 7027 9900 1 3 7 7 27 27 1027 2027 7027 54 55 HKAAAA UQOAAA AAAAxx 1536 9901 0 0 6 16 36 536 1536 1536 1536 72 73 CHAAAA VQOAAA HHHHxx 160 9902 0 0 0 0 60 160 160 160 160 120 121 EGAAAA WQOAAA OOOOxx 7679 9903 1 3 9 19 79 679 1679 2679 7679 158 159 JJAAAA XQOAAA VVVVxx 5973 9904 1 1 3 13 73 973 1973 973 5973 146 147 TVAAAA YQOAAA AAAAxx 4401 9905 1 1 1 1 1 401 401 4401 4401 2 3 HNAAAA ZQOAAA HHHHxx 395 9906 1 3 5 15 95 395 395 395 395 190 191 FPAAAA AROAAA OOOOxx 4904 9907 0 0 4 4 4 904 904 4904 4904 8 9 QGAAAA BROAAA VVVVxx 2759 9908 1 3 9 19 59 759 759 2759 2759 118 119 DCAAAA CROAAA AAAAxx 8713 9909 1 1 3 13 13 713 713 3713 8713 26 27 DXAAAA DROAAA HHHHxx 3770 9910 0 2 0 10 70 770 1770 3770 3770 140 141 APAAAA EROAAA OOOOxx 8272 9911 0 0 2 12 72 272 272 3272 8272 144 145 EGAAAA FROAAA VVVVxx 5358 9912 0 2 8 18 58 358 1358 358 5358 116 117 CYAAAA GROAAA AAAAxx 9747 9913 1 3 7 7 47 747 1747 4747 9747 94 95 XKAAAA HROAAA HHHHxx 1567 9914 1 3 7 7 67 567 1567 1567 1567 134 135 HIAAAA IROAAA OOOOxx 2136 9915 0 0 6 16 36 136 136 2136 2136 72 73 EEAAAA JROAAA VVVVxx 314 9916 0 2 4 14 14 314 314 314 314 28 29 CMAAAA KROAAA AAAAxx 4583 9917 1 3 3 3 83 583 583 4583 4583 166 167 HUAAAA LROAAA HHHHxx 375 9918 1 3 5 15 75 375 375 375 375 150 151 LOAAAA MROAAA OOOOxx 5566 9919 0 2 6 6 66 566 1566 566 5566 132 133 CGAAAA NROAAA VVVVxx 6865 9920 1 1 5 5 65 865 865 1865 6865 130 131 BEAAAA OROAAA AAAAxx 894 9921 0 2 4 14 94 894 894 894 894 188 189 KIAAAA PROAAA HHHHxx 5399 9922 1 3 9 19 99 399 1399 399 5399 198 199 RZAAAA QROAAA OOOOxx 1385 9923 1 1 5 5 85 385 1385 1385 1385 170 171 HBAAAA RROAAA VVVVxx 2156 9924 0 0 6 16 56 156 156 2156 2156 112 113 YEAAAA SROAAA AAAAxx 9659 9925 1 3 9 19 59 659 1659 4659 9659 118 119 NHAAAA TROAAA HHHHxx 477 9926 1 1 7 17 77 477 477 477 477 154 155 JSAAAA UROAAA OOOOxx 8194 9927 0 2 4 14 94 194 194 3194 8194 188 189 EDAAAA VROAAA VVVVxx 3937 9928 1 1 7 17 37 937 1937 3937 3937 74 75 LVAAAA WROAAA AAAAxx 3745 9929 1 1 5 5 45 745 1745 3745 3745 90 91 BOAAAA XROAAA HHHHxx 4096 9930 0 0 6 16 96 96 96 4096 4096 192 193 OBAAAA YROAAA OOOOxx 5487 9931 1 3 7 7 87 487 1487 487 5487 174 175 BDAAAA ZROAAA VVVVxx 2475 9932 1 3 5 15 75 475 475 2475 2475 150 151 FRAAAA ASOAAA AAAAxx 6105 9933 1 1 5 5 5 105 105 1105 6105 10 11 VAAAAA BSOAAA HHHHxx 6036 9934 0 0 6 16 36 36 36 1036 6036 72 73 EYAAAA CSOAAA OOOOxx 1315 9935 1 3 5 15 15 315 1315 1315 1315 30 31 PYAAAA DSOAAA VVVVxx 4473 9936 1 1 3 13 73 473 473 4473 4473 146 147 BQAAAA ESOAAA AAAAxx 4016 9937 0 0 6 16 16 16 16 4016 4016 32 33 MYAAAA FSOAAA HHHHxx 8135 9938 1 3 5 15 35 135 135 3135 8135 70 71 XAAAAA GSOAAA OOOOxx 8892 9939 0 0 2 12 92 892 892 3892 8892 184 185 AEAAAA HSOAAA VVVVxx 4850 9940 0 2 0 10 50 850 850 4850 4850 100 101 OEAAAA ISOAAA AAAAxx 2545 9941 1 1 5 5 45 545 545 2545 2545 90 91 XTAAAA JSOAAA HHHHxx 3788 9942 0 0 8 8 88 788 1788 3788 3788 176 177 SPAAAA KSOAAA OOOOxx 1672 9943 0 0 2 12 72 672 1672 1672 1672 144 145 IMAAAA LSOAAA VVVVxx 3664 9944 0 0 4 4 64 664 1664 3664 3664 128 129 YKAAAA MSOAAA AAAAxx 3775 9945 1 3 5 15 75 775 1775 3775 3775 150 151 FPAAAA NSOAAA HHHHxx 3103 9946 1 3 3 3 3 103 1103 3103 3103 6 7 JPAAAA OSOAAA OOOOxx 9335 9947 1 3 5 15 35 335 1335 4335 9335 70 71 BVAAAA PSOAAA VVVVxx 9200 9948 0 0 0 0 0 200 1200 4200 9200 0 1 WPAAAA QSOAAA AAAAxx 8665 9949 1 1 5 5 65 665 665 3665 8665 130 131 HVAAAA RSOAAA HHHHxx 1356 9950 0 0 6 16 56 356 1356 1356 1356 112 113 EAAAAA SSOAAA OOOOxx 6118 9951 0 2 8 18 18 118 118 1118 6118 36 37 IBAAAA TSOAAA VVVVxx 4605 9952 1 1 5 5 5 605 605 4605 4605 10 11 DVAAAA USOAAA AAAAxx 5651 9953 1 3 1 11 51 651 1651 651 5651 102 103 JJAAAA VSOAAA HHHHxx 9055 9954 1 3 5 15 55 55 1055 4055 9055 110 111 HKAAAA WSOAAA OOOOxx 8461 9955 1 1 1 1 61 461 461 3461 8461 122 123 LNAAAA XSOAAA VVVVxx 6107 9956 1 3 7 7 7 107 107 1107 6107 14 15 XAAAAA YSOAAA AAAAxx 1967 9957 1 3 7 7 67 967 1967 1967 1967 134 135 RXAAAA ZSOAAA HHHHxx 8910 9958 0 2 0 10 10 910 910 3910 8910 20 21 SEAAAA ATOAAA OOOOxx 8257 9959 1 1 7 17 57 257 257 3257 8257 114 115 PFAAAA BTOAAA VVVVxx 851 9960 1 3 1 11 51 851 851 851 851 102 103 TGAAAA CTOAAA AAAAxx 7823 9961 1 3 3 3 23 823 1823 2823 7823 46 47 XOAAAA DTOAAA HHHHxx 3208 9962 0 0 8 8 8 208 1208 3208 3208 16 17 KTAAAA ETOAAA OOOOxx 856 9963 0 0 6 16 56 856 856 856 856 112 113 YGAAAA FTOAAA VVVVxx 2654 9964 0 2 4 14 54 654 654 2654 2654 108 109 CYAAAA GTOAAA AAAAxx 7185 9965 1 1 5 5 85 185 1185 2185 7185 170 171 JQAAAA HTOAAA HHHHxx 309 9966 1 1 9 9 9 309 309 309 309 18 19 XLAAAA ITOAAA OOOOxx 9752 9967 0 0 2 12 52 752 1752 4752 9752 104 105 CLAAAA JTOAAA VVVVxx 6405 9968 1 1 5 5 5 405 405 1405 6405 10 11 JMAAAA KTOAAA AAAAxx 6113 9969 1 1 3 13 13 113 113 1113 6113 26 27 DBAAAA LTOAAA HHHHxx 9774 9970 0 2 4 14 74 774 1774 4774 9774 148 149 YLAAAA MTOAAA OOOOxx 1674 9971 0 2 4 14 74 674 1674 1674 1674 148 149 KMAAAA NTOAAA VVVVxx 9602 9972 0 2 2 2 2 602 1602 4602 9602 4 5 IFAAAA OTOAAA AAAAxx 1363 9973 1 3 3 3 63 363 1363 1363 1363 126 127 LAAAAA PTOAAA HHHHxx 6887 9974 1 3 7 7 87 887 887 1887 6887 174 175 XEAAAA QTOAAA OOOOxx 6170 9975 0 2 0 10 70 170 170 1170 6170 140 141 IDAAAA RTOAAA VVVVxx 8888 9976 0 0 8 8 88 888 888 3888 8888 176 177 WDAAAA STOAAA AAAAxx 2981 9977 1 1 1 1 81 981 981 2981 2981 162 163 RKAAAA TTOAAA HHHHxx 7369 9978 1 1 9 9 69 369 1369 2369 7369 138 139 LXAAAA UTOAAA OOOOxx 6227 9979 1 3 7 7 27 227 227 1227 6227 54 55 NFAAAA VTOAAA VVVVxx 8002 9980 0 2 2 2 2 2 2 3002 8002 4 5 UVAAAA WTOAAA AAAAxx 4288 9981 0 0 8 8 88 288 288 4288 4288 176 177 YIAAAA XTOAAA HHHHxx 5136 9982 0 0 6 16 36 136 1136 136 5136 72 73 OPAAAA YTOAAA OOOOxx 1084 9983 0 0 4 4 84 84 1084 1084 1084 168 169 SPAAAA ZTOAAA VVVVxx 9117 9984 1 1 7 17 17 117 1117 4117 9117 34 35 RMAAAA AUOAAA AAAAxx 2406 9985 0 2 6 6 6 406 406 2406 2406 12 13 OOAAAA BUOAAA HHHHxx 1384 9986 0 0 4 4 84 384 1384 1384 1384 168 169 GBAAAA CUOAAA OOOOxx 9194 9987 0 2 4 14 94 194 1194 4194 9194 188 189 QPAAAA DUOAAA VVVVxx 858 9988 0 2 8 18 58 858 858 858 858 116 117 AHAAAA EUOAAA AAAAxx 8592 9989 0 0 2 12 92 592 592 3592 8592 184 185 MSAAAA FUOAAA HHHHxx 4773 9990 1 1 3 13 73 773 773 4773 4773 146 147 PBAAAA GUOAAA OOOOxx 4093 9991 1 1 3 13 93 93 93 4093 4093 186 187 LBAAAA HUOAAA VVVVxx 6587 9992 1 3 7 7 87 587 587 1587 6587 174 175 JTAAAA IUOAAA AAAAxx 6093 9993 1 1 3 13 93 93 93 1093 6093 186 187 JAAAAA JUOAAA HHHHxx 429 9994 1 1 9 9 29 429 429 429 429 58 59 NQAAAA KUOAAA OOOOxx 5780 9995 0 0 0 0 80 780 1780 780 5780 160 161 IOAAAA LUOAAA VVVVxx 1783 9996 1 3 3 3 83 783 1783 1783 1783 166 167 PQAAAA MUOAAA AAAAxx 2992 9997 0 0 2 12 92 992 992 2992 2992 184 185 CLAAAA NUOAAA HHHHxx 0 9998 0 0 0 0 0 0 0 0 0 0 1 AAAAAA OUOAAA OOOOxx 2968 9999 0 0 8 8 68 968 968 2968 2968 136 137 EKAAAA PUOAAA VVVVxx ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/ddl.sql�����������������������������������������������������������������0000664�0000000�0000000�00000014117�15100345067�0017121�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS "customSchema" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \ir include/ddl_ops_1.sql SELECT * FROM PUBLIC."Hypertable_1"; SELECT * FROM ONLY PUBLIC."Hypertable_1"; EXPLAIN (buffers off, costs off) SELECT * FROM ONLY PUBLIC."Hypertable_1"; SELECT * FROM test.show_columns('PUBLIC."Hypertable_1"'); SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); \ir include/ddl_ops_2.sql SELECT * FROM test.show_columns('PUBLIC."Hypertable_1"'); SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM PUBLIC."Hypertable_1"; -- alter column tests CREATE TABLE alter_test(time timestamptz, temp float, color varchar(10)); -- create hypertable with two chunks SELECT create_hypertable('alter_test', 'time', 'color', 2, chunk_time_interval => 2628000000000); INSERT INTO alter_test VALUES ('2017-01-20T09:00:01', 17.5, 'blue'), ('2017-01-21T09:00:01', 19.1, 'yellow'), ('2017-04-20T09:00:01', 89.5, 'green'), ('2017-04-21T09:00:01', 17.1, 'black'); SELECT * FROM test.show_columns('alter_test'); SELECT * FROM test.show_columnsp('_timescaledb_internal._hyper_9_%chunk'); -- show the column name and type of the partitioning dimension in the -- metadata table SELECT * FROM _timescaledb_catalog.dimension WHERE hypertable_id = 9; EXPLAIN (buffers off, costs off) SELECT * FROM alter_test WHERE time > '2017-05-20T10:00:01'; -- rename column and change its type ALTER TABLE alter_test RENAME COLUMN time TO time_us; --converting timestamptz->timestamp should happen under UTC SET timezone = 'UTC'; ALTER TABLE alter_test ALTER COLUMN time_us TYPE timestamp; RESET timezone; ALTER TABLE alter_test RENAME COLUMN color TO colorname; \set ON_ERROR_STOP 0 -- Changing types on hash-partitioned columns is not safe for some -- types and is therefore blocked. ALTER TABLE alter_test ALTER COLUMN colorname TYPE text; \set ON_ERROR_STOP 1 SELECT * FROM test.show_columns('alter_test'); SELECT * FROM test.show_columnsp('_timescaledb_internal._hyper_9_%chunk'); -- show that the metadata has been updated SELECT * FROM _timescaledb_catalog.dimension WHERE hypertable_id = 9; -- constraint exclusion should still work with updated column EXPLAIN (buffers off, costs off) SELECT * FROM alter_test WHERE time_us > '2017-05-20T10:00:01'; \set ON_ERROR_STOP 0 -- verify that we cannot change the column type to something incompatible ALTER TABLE alter_test ALTER COLUMN colorname TYPE varchar(3); -- conversion that messes up partitioning fails ALTER TABLE alter_test ALTER COLUMN time_us TYPE timestamptz USING time_us::timestamptz+INTERVAL '1 year'; -- dropping column that messes up partiitoning fails ALTER TABLE alter_test DROP COLUMN colorname; --ONLY blocked ALTER TABLE ONLY alter_test RENAME COLUMN colorname TO colorname2; ALTER TABLE ONLY alter_test ALTER COLUMN colorname TYPE varchar(10); \set ON_ERROR_STOP 1 CREATE TABLE alter_test_bigint(time bigint, temp float); SELECT create_hypertable('alter_test_bigint', 'time', chunk_time_interval => 2628000000000); \set ON_ERROR_STOP 0 -- Changing type of time dimension to a non-supported type -- shall not be allowed ALTER TABLE alter_test_bigint ALTER COLUMN time TYPE TEXT; -- dropping open time dimension shall not be allowed. ALTER TABLE alter_test_bigint DROP COLUMN time; \set ON_ERROR_STOP 1 -- test expression index creation where physical layout of chunks differs from hypertable CREATE TABLE i2504(time timestamp NOT NULL, a int, b int, c int, d int); select create_hypertable('i2504', 'time'); INSERT INTO i2504 VALUES (now(), 1, 2, 3, 4); ALTER TABLE i2504 DROP COLUMN b; INSERT INTO i2504(time, a, c, d) VALUES (now() - interval '1 year', 1, 2, 3), (now() - interval '2 years', 1, 2, 3); CREATE INDEX idx2 ON i2504(a,d) WHERE c IS NOT NULL; DROP INDEX idx2; CREATE INDEX idx2 ON i2504(a,d) WITH (timescaledb.transaction_per_chunk) WHERE c IS NOT NULL; -- Make sure custom composite types are supported as dimensions CREATE TYPE TUPLE as (val1 int4, val2 int4); CREATE TABLE part_custom_dim (time TIMESTAMPTZ, combo TUPLE, device TEXT); \set ON_ERROR_STOP 0 -- should fail on PG < 14 because no partitioning function supplied and the given custom type -- has no default hash function -- on PG14 custom types are hashable SELECT create_hypertable('part_custom_dim', 'time', 'combo', 4); \set ON_ERROR_STOP 1 -- immutable functions with sub-transaction (issue #4489) CREATE FUNCTION i4489(value TEXT DEFAULT '') RETURNS INTEGER AS $$ BEGIN RETURN value::INTEGER; EXCEPTION WHEN invalid_text_representation THEN RETURN 0; END; $$ LANGUAGE PLPGSQL IMMUTABLE; -- should return 1 (one) in both cases SELECT i4489('1'), i4489('1'); -- should return 0 (zero) in all cases handled by the exception SELECT i4489(), i4489(); SELECT i4489('a'), i4489('a'); -- test ALTER TABLE ONLY for hypertables CREATE TABLE at_test(time timestamptz) WITH (tsdb.hypertable); -- adding column only on the parent table should be blocked \set ON_ERROR_STOP 0 ALTER TABLE ONLY at_test ADD COLUMN value INT; \set ON_ERROR_STOP 1 ALTER TABLE ONLY at_test SET (autovacuum_enabled = false); ALTER TABLE ONLY at_test RESET (autovacuum_enabled); -- test again after creating some chunks INSERT INTO at_test VALUES ('2025-01-01'); INSERT INTO at_test VALUES ('2025-02-01'); ALTER TABLE ONLY at_test SET (autovacuum_enabled = false); ALTER TABLE ONLY at_test RESET (autovacuum_enabled); -- test DDL inside function CREATE OR REPLACE FUNCTION ddl_function() RETURNS VOID LANGUAGE PLPGSQL AS $$ BEGIN DROP TABLE IF EXISTS func_table; CREATE TABLE func_table(time timestamptz) WITH (tsdb.hypertable); END $$; SELECT ddl_function(); SELECT hypertable_name from timescaledb_information.hypertables WHERE hypertable_name='func_table'; SELECT ddl_function(); SELECT hypertable_name from timescaledb_information.hypertables WHERE hypertable_name='func_table'; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/ddl_errors.sql����������������������������������������������������������0000664�0000000�0000000�00000011212�15100345067�0020506�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); CREATE INDEX ON PUBLIC."Hypertable_1" (time, "Device_id"); -- Default integer interval is supported as part of -- hypertable generalization, verify additional secnarios \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable(NULL, NULL); SELECT * FROM create_hypertable('"public"."Hypertable_1"', NULL); -- space dimensions require explicit number of partitions SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM create_hypertable('"public"."Hypertable_1_mispelled"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time_mispelled', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'Device_id', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id_mispelled', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); INSERT INTO PUBLIC."Hypertable_1" VALUES(1,'dev_1', 3); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); DELETE FROM PUBLIC."Hypertable_1" ; \set ON_ERROR_STOP 1 SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 INSERT INTO "Hypertable_1" VALUES (0, 1, 0); \set ON_ERROR_STOP 0 ALTER TABLE _timescaledb_internal._hyper_1_1_chunk ALTER COLUMN temp_c DROP NOT NULL; \set ON_ERROR_STOP 1 CREATE TABLE PUBLIC."Parent" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); \set ON_ERROR_STOP 0 ALTER TABLE "Hypertable_1" INHERIT "Parent"; ALTER TABLE _timescaledb_internal._hyper_1_1_chunk INHERIT "Parent"; ALTER TABLE _timescaledb_internal._hyper_1_1_chunk NO INHERIT "Parent"; \set ON_ERROR_STOP 1 CREATE TABLE PUBLIC."Child" () INHERITS ("Parent"); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Parent"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM create_hypertable('"public"."Child"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 CREATE TEMPORARY TABLE temp_table (time timestamptz) WITH (tsdb.hypertable); \set ON_ERROR_STOP 1 CREATE TEMP TABLE "Hypertable_temp" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"Hypertable_temp"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ALTER TABLE "Hypertable_1" SET UNLOGGED; \set ON_ERROR_STOP 1 ALTER TABLE "Hypertable_1" SET LOGGED; CREATE TABLE PUBLIC."Hypertable_1_rule" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1 ); CREATE RULE notify_me AS ON UPDATE TO "Hypertable_1_rule" DO ALSO NOTIFY "Hypertable_1_rule"; \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Hypertable_1_rule"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 ALTER TABLE "Hypertable_1_rule" DISABLE RULE notify_me; \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('"public"."Hypertable_1_rule"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 1 DROP RULE notify_me ON "Hypertable_1_rule"; SELECT * FROM create_hypertable('"public"."Hypertable_1_rule"', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set ON_ERROR_STOP 0 CREATE RULE notify_me AS ON UPDATE TO "Hypertable_1_rule" DO ALSO NOTIFY "Hypertable_1_rule"; \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 SELECT add_dimension(NULL,NULL); \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 SELECT attach_tablespace(NULL,NULL); \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 select set_number_partitions(NULL,NULL); \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/ddl_extra.sql�����������������������������������������������������������0000664�0000000�0000000�00000003774�15100345067�0020333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION show_columns_ext(rel regclass) RETURNS TABLE("Column" name, "Type" text, "NotNull" boolean, "Compression" text) LANGUAGE SQL STABLE AS $BODY$ SELECT a.attname, format_type(t.oid, t.typtypmod), a.attnotnull, (CASE WHEN a.attcompression = 'l' THEN 'lz4' WHEN a.attcompression = 'p' THEN 'pglz' ELSE '' END) FROM pg_attribute a, pg_type t WHERE a.attrelid = rel AND a.atttypid = t.oid AND a.attnum >= 0 ORDER BY a.attnum; $BODY$; CREATE TABLE conditions ( time TIMESTAMP NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time', chunk_time_interval := '1 day'::interval); INSERT INTO conditions SELECT generate_series('2021-10-10 00:00'::timestamp, '2021-10-11 00:00'::timestamp, '1 day'), 'POR', 55, 75; CREATE VIEW t AS SELECT 'conditions'::regclass AS r UNION ALL SELECT * FROM show_chunks('conditions'); SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; ALTER TABLE conditions ALTER COLUMN location SET COMPRESSION pglz; SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; INSERT INTO conditions VALUES ('2021-10-12 00:00'::timestamp, 'BRA', 66, 77); SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; ALTER TABLE conditions ALTER COLUMN location SET COMPRESSION default; SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'location' ORDER BY 1, 2; \set ON_ERROR_STOP 0 -- failing test because compression is not allowed in "non-TOASTable" datatypes ALTER TABLE conditions ALTER COLUMN temperature SET COMPRESSION pglz; SELECT * FROM t, LATERAL show_columns_ext(r) WHERE "Column" = 'temperature' ORDER BY 1, 2; ����timescaledb-2.23.0/test/sql/debug_utils.sql���������������������������������������������������������0000664�0000000�0000000�00000001346�15100345067�0020664�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT _timescaledb_debug.extension_state(); RESET ROLE; DO $$ DECLARE module text; BEGIN SELECT probin INTO module FROM pg_proc WHERE proname = 'extension_state' AND pronamespace = '_timescaledb_debug'::regnamespace; EXECUTE format('CREATE FUNCTION extension_state() RETURNS TEXT AS ''%s'', ''ts_extension_get_state'' LANGUAGE C', module); END $$; DROP EXTENSION timescaledb; SELECT * FROM extension_state(); \c CREATE EXTENSION timescaledb; SELECT * FROM extension_state(); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/delete.sql��������������������������������������������������������������0000664�0000000�0000000�00000004325�15100345067�0017620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql \o SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; DELETE FROM "two_Partitions" WHERE series_0 = 1.5; DELETE FROM "two_Partitions" WHERE series_0 = 100; SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; -- Make sure DELETE isn't optimized if it includes Append plans -- Need to turn of nestloop to make append appear the same on PG96 and PG10 set enable_nestloop = 'off'; CREATE OR REPLACE FUNCTION series_val() RETURNS integer LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN 5; END; $BODY$; -- ConstraintAwareAppend applied for SELECT EXPLAIN (buffers off, costs off) SELECT FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()); -- ConstraintAwareAppend NOT applied for DELETE EXPLAIN (buffers off, costs off) DELETE FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()); SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; BEGIN; DELETE FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()); SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; ROLLBACK; BEGIN; DELETE FROM "two_Partitions" WHERE series_1 IN (SELECT series_1 FROM "two_Partitions" WHERE series_1 > series_val()) RETURNING "timeCustom"; SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; ROLLBACK; -- test update on chunks directly CREATE TABLE direct_delete(time timestamptz) WITH (tsdb.hypertable); INSERT INTO direct_delete VALUES ('2020-01-01'); SELECT show_chunks('direct_delete') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) DELETE FROM :CHUNK; EXPLAIN (costs off, timing off, summary off) DELETE FROM ONLY :CHUNK; -- DELETE should succeed BEGIN; DELETE FROM :CHUNK RETURNING *; ROLLBACK; BEGIN; DELETE FROM ONLY :CHUNK RETURNING *; ROLLBACK; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/drop_extension.sql������������������������������������������������������0000664�0000000�0000000�00000003673�15100345067�0021423�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE drop_test(time timestamp, temp float8, device text); SELECT create_hypertable('drop_test', 'time', 'device', 2); SELECT * FROM _timescaledb_catalog.hypertable; INSERT INTO drop_test VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); SELECT * FROM drop_test; \c :TEST_DBNAME :ROLE_SUPERUSER DROP EXTENSION timescaledb CASCADE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Querying the original table should not return any rows since all of -- them actually existed in chunks that are now gone SELECT * FROM drop_test; \c :TEST_DBNAME :ROLE_SUPERUSER -- Recreate the extension SET client_min_messages=error; CREATE EXTENSION timescaledb; RESET client_min_messages; -- Test that calling twice generates proper error \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb; \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- CREATE twice with IF NOT EXISTS should be OK CREATE EXTENSION IF NOT EXISTS timescaledb; -- Make the table a hypertable again SELECT create_hypertable('drop_test', 'time', 'device', 2); SELECT * FROM _timescaledb_catalog.hypertable; INSERT INTO drop_test VALUES('Mon Mar 20 09:18:19.100462 2017', 22.1, 'dev1'); SELECT * FROM drop_test; --test drops thru cascades of other objects \c :TEST_DBNAME :ROLE_SUPERUSER -- Stop background workers to prevent them from interfering with the drop public schema SELECT _timescaledb_functions.stop_background_workers(); SET client_min_messages TO ERROR; REVOKE CONNECT ON DATABASE :TEST_DBNAME FROM public; SELECT count(pg_terminate_backend(pg_stat_activity.pid)) AS TERMINATED FROM pg_stat_activity WHERE pg_stat_activity.datname = :'TEST_DBNAME' AND pg_stat_activity.pid <> pg_backend_pid() \gset RESET client_min_messages; -- drop the public schema and all its objects DROP SCHEMA public CASCADE; \dn ���������������������������������������������������������������������timescaledb-2.23.0/test/sql/drop_hypertable.sql�����������������������������������������������������0000664�0000000�0000000�00000004262�15100345067�0021541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT * from _timescaledb_catalog.hypertable; SELECT * from _timescaledb_catalog.dimension; CREATE TABLE should_drop (time timestamp, temp float8); SELECT create_hypertable('should_drop', 'time'); CREATE TABLE hyper_with_dependencies (time timestamp, temp float8); SELECT create_hypertable('hyper_with_dependencies', 'time'); CREATE VIEW dependent_view AS SELECT * FROM hyper_with_dependencies; INSERT INTO hyper_with_dependencies VALUES (now(), 1.0); \set ON_ERROR_STOP 0 DROP TABLE hyper_with_dependencies; \set ON_ERROR_STOP 1 DROP TABLE hyper_with_dependencies CASCADE; -- check that the view is dropped SELECT oid FROM pg_class WHERE relname = 'dependent_view'; CREATE TABLE chunk_with_dependencies (time timestamp, temp float8); SELECT create_hypertable('chunk_with_dependencies', 'time'); INSERT INTO chunk_with_dependencies VALUES (now(), 1.0); CREATE VIEW dependent_view_chunk AS SELECT * FROM _timescaledb_internal._hyper_3_2_chunk; \set ON_ERROR_STOP 0 DROP TABLE chunk_with_dependencies; \set ON_ERROR_STOP 1 DROP TABLE chunk_with_dependencies CASCADE; -- check that the view is dropped SELECT oid FROM pg_class WHERE relname = 'dependent_view_chunk'; -- Calling create hypertable again will increment hypertable ID -- although no new hypertable is created. Make sure we can handle this. SELECT create_hypertable('should_drop', 'time', if_not_exists => true); SELECT * from _timescaledb_catalog.hypertable; SELECT * from _timescaledb_catalog.dimension; DROP TABLE should_drop; CREATE TABLE should_drop (time timestamp, temp float8); SELECT create_hypertable('should_drop', 'time'); INSERT INTO should_drop VALUES (now(), 1.0); SELECT * from _timescaledb_catalog.hypertable; SELECT * from _timescaledb_catalog.dimension; -- test dropping multiple objects at once CREATE TABLE t1 (time timestamptz) WITH (tsdb.hypertable); INSERT INTO t1 VALUES ('2025-01-01'); CREATE TABLE t2 (time timestamptz) WITH (tsdb.hypertable); INSERT INTO t2 VALUES ('2025-01-01'); CREATE TABLE t3 (time timestamptz); DROP TABLE t1, t2, t3; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/drop_owned.sql.in�������������������������������������������������������0000664�0000000�0000000�00000006046�15100345067�0021125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA hypertable_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.default_perm_user (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.default_perm_user', 'time', 'location', 2); INSERT INTO hypertable_schema.default_perm_user VALUES ('2001-01-01 01:01:01', 23.3, 1); RESET ROLE; CREATE TABLE hypertable_schema.superuser (time timestamptz, temp float, location int); SELECT create_hypertable('hypertable_schema.superuser', 'time', 'location', 2); INSERT INTO hypertable_schema.superuser VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; DROP OWNED BY :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; DROP TABLE hypertable_schema.superuser; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; SELECT * FROM _timescaledb_catalog.dimension; SELECT * FROM _timescaledb_catalog.dimension_slice; SELECT * FROM _timescaledb_catalog.chunk_constraint; -- test drop owned in database without extension installed \c :TEST_DBNAME :ROLE_SUPERUSER CREATE database test_drop_owned; \c test_drop_owned DROP OWNED BY :ROLE_SUPERUSER; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test_drop_owned WITH (FORCE); -- Test that dependencies on roles are added to chunks when creating -- new chunks. If that is not done, DROP OWNED BY will not revoke the -- privilege on the chunk. CREATE TABLE sensor_data(time timestamptz not null, cpu double precision null); SELECT * FROM create_hypertable('sensor_data','time'); INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-01'::timestamptz, '2020-01-24'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp sensor_data \dp _timescaledb_internal._hyper_3* GRANT SELECT ON sensor_data TO :ROLE_DEFAULT_PERM_USER; \dp sensor_data \dp _timescaledb_internal._hyper_3* -- Insert more chunks after adding the user to the hypertable. These -- will now get the privileges of the hypertable. INSERT INTO sensor_data SELECT time, random() AS cpu FROM generate_series('2020-01-20'::timestamptz, '2020-02-05'::timestamptz, INTERVAL '10 minute') AS g1(time); \dp _timescaledb_internal._hyper_3* -- This should revoke the privileges on both the hypertable and the chunks. DROP OWNED BY :ROLE_DEFAULT_PERM_USER; \dp sensor_data \dp _timescaledb_internal._hyper_3* ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/drop_rename_hypertable.sql����������������������������������������������0000664�0000000�0000000�00000002234�15100345067�0023065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql \o SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); -- Test that renaming hypertable works SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); ALTER TABLE "two_Partitions" RENAME TO "newname"; SELECT * FROM "newname"; SELECT * FROM _timescaledb_catalog.hypertable; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "newschema" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ALTER TABLE "newname" SET SCHEMA "newschema"; SELECT * FROM "newschema"."newname"; SELECT * FROM _timescaledb_catalog.hypertable; DROP TABLE "newschema"."newname"; SELECT * FROM _timescaledb_catalog.hypertable; SELECT schema, name FROM test.relation WHERE schema IN ('public', '_timescaledb_catalog', '_timescaledb_internal'); -- Test that renaming ordinary table works CREATE TABLE renametable (foo int); ALTER TABLE "renametable" RENAME TO "newname_none_ht"; SELECT * FROM "newname_none_ht"; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/drop_schema.sql���������������������������������������������������������0000664�0000000�0000000�00000005351�15100345067�0020642�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA chunk_schema1; CREATE SCHEMA chunk_schema2; CREATE SCHEMA hypertable_schema; CREATE SCHEMA extra_schema; GRANT ALL ON SCHEMA hypertable_schema TO :ROLE_DEFAULT_PERM_USER; GRANT ALL ON SCHEMA chunk_schema1 TO :ROLE_DEFAULT_PERM_USER; GRANT ALL ON SCHEMA chunk_schema2 TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE hypertable_schema.test1 (time timestamptz, temp float, location int); CREATE TABLE hypertable_schema.test2 (time timestamptz, temp float, location int); --create two identical tables with their own chunk schemas SELECT create_hypertable('hypertable_schema.test1', 'time', 'location', 2, associated_schema_name => 'chunk_schema1'); SELECT create_hypertable('hypertable_schema.test2', 'time', 'location', 2, associated_schema_name => 'chunk_schema2'); INSERT INTO hypertable_schema.test1 VALUES ('2001-01-01 01:01:01', 23.3, 1); INSERT INTO hypertable_schema.test2 VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; RESET ROLE; --drop the associated schema. We drop the extra schema to show we can --handle multi-schema drops DROP SCHEMA chunk_schema1, extra_schema CASCADE; SET ROLE :ROLE_DEFAULT_PERM_USER; --show that the metadata for the table using the dropped schema is --changed. The other table is not affected. SELECT * FROM _timescaledb_catalog.hypertable ORDER BY id; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; --new chunk should be created in the internal associated schema INSERT INTO hypertable_schema.test1 VALUES ('2001-01-01 01:01:01', 23.3, 1); SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; RESET ROLE; --dropping the internal schema should not work \set ON_ERROR_STOP 0 DROP SCHEMA _timescaledb_internal CASCADE; \set ON_ERROR_STOP 1 --dropping the hypertable schema should delete everything DROP SCHEMA hypertable_schema CASCADE; SET ROLE :ROLE_DEFAULT_PERM_USER; --everything should be cleaned up SELECT * FROM _timescaledb_catalog.hypertable GROUP BY id; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; SELECT * FROM _timescaledb_catalog.dimension; SELECT * FROM _timescaledb_catalog.dimension_slice; SELECT * FROM _timescaledb_catalog.chunk_constraint; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/dump_meta.sql�����������������������������������������������������������0000664�0000000�0000000�00000000403�15100345067�0020322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_two_partitions.sql \ir ../../scripts/dump_meta_data.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/extension_scripts.sql���������������������������������������������������0000664�0000000�0000000�00000004161�15100345067�0022137�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER DROP EXTENSION timescaledb; -- test that installation script errors when any of our internal schemas already exists \set ON_ERROR_STOP 0 CREATE SCHEMA _timescaledb_catalog; CREATE EXTENSION timescaledb; DROP SCHEMA _timescaledb_catalog; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA _timescaledb_internal; CREATE EXTENSION timescaledb; DROP SCHEMA _timescaledb_internal; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA _timescaledb_cache; CREATE EXTENSION timescaledb; DROP SCHEMA _timescaledb_cache; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA _timescaledb_config; CREATE EXTENSION timescaledb; DROP SCHEMA _timescaledb_config; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA timescaledb_experimental; CREATE EXTENSION timescaledb; DROP SCHEMA timescaledb_experimental; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA timescaledb_information; CREATE EXTENSION timescaledb; DROP SCHEMA timescaledb_information; -- test that installation script errors when any of the function in public schema already exists -- we don't test every public function but just a few common ones \c :TEST_DBNAME :ROLE_SUPERUSER CREATE FUNCTION time_bucket(int,int) RETURNS int LANGUAGE SQL AS $$ SELECT 1::int; $$; CREATE EXTENSION timescaledb; DROP FUNCTION time_bucket; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION show_chunks(relation regclass, older_than "any" DEFAULT NULL, newer_than "any" DEFAULT NULL, created_before "any" DEFAULT NULL, created_after "any" DEFAULT NULL) RETURNS SETOF regclass language internal as 'pg_partition_ancestors'; CREATE EXTENSION timescaledb; DROP FUNCTION show_chunks; -- Create a user that is not all-lowercase CREATE USER "FooBar" WITH SUPERUSER; \c :TEST_DBNAME "FooBar" SET client_min_messages TO error; CREATE EXTENSION timescaledb; DROP EXTENSION timescaledb; RESET client_min_messages; \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER "FooBar"; SET client_min_messages TO ERROR; CREATE EXTENSION timescaledb; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/generated_as_identity.sql�����������������������������������������������0000664�0000000�0000000�00000002137�15100345067�0022707�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE table test_gen ( id int generated by default AS IDENTITY primary key, payload text ); SELECT create_hypertable('test_gen', 'id', chunk_time_interval=>10); insert into test_gen (payload) select generate_series(1,15) returning *; select * from test_gen; \set ON_ERROR_STOP 0 insert into test_gen values('1', 'a'); \set ON_ERROR_STOP 1 ALTER TABLE test_gen ALTER COLUMN id DROP IDENTITY; \set ON_ERROR_STOP 0 insert into test_gen (payload) select generate_series(15,20) returning *; \set ON_ERROR_STOP 1 ALTER TABLE test_gen ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY; \set ON_ERROR_STOP 0 insert into test_gen (payload) select generate_series(15,20) returning *; \set ON_ERROR_STOP 1 ALTER TABLE test_gen ALTER COLUMN id SET GENERATED BY DEFAULT RESTART 100; insert into test_gen (payload) select generate_series(15,20) returning *; select * from test_gen; SELECT * FROM test.show_subtables('test_gen'); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/grant_hypertable.sql.in�������������������������������������������������0000664�0000000�0000000�00000010616�15100345067�0022315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable and show that it does not have any privileges SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '5 days'::interval); INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; \z conditions \z _timescaledb_internal.*chunk -- Add privileges and show that they propagate to the chunks GRANT SELECT, INSERT ON conditions TO PUBLIC; \z conditions \z _timescaledb_internal.*chunk -- Create some more chunks and show that they also get the privileges. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-10 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1h') AS time; \z conditions \z _timescaledb_internal.*chunk -- Revoke one of the privileges and show that it propagate to the -- chunks. REVOKE INSERT ON conditions FROM PUBLIC; \z conditions \z _timescaledb_internal.*chunk -- Add some more chunks and show that it inherits the grants from the -- hypertable. INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-20 00:00'::timestamp, '2018-12-30 00:00'::timestamp, '1h') AS time; \z conditions \z _timescaledb_internal.*chunk -- Change grants of one chunk explicitly and check that it is possible \z _timescaledb_internal._hyper_1_1_chunk GRANT UPDATE ON _timescaledb_internal._hyper_1_1_chunk TO PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk REVOKE SELECT ON _timescaledb_internal._hyper_1_1_chunk FROM PUBLIC; \z _timescaledb_internal._hyper_1_1_chunk -- Check that revoking a permission first on the chunk and then on the -- hypertable that was added through the hypertable (INSERT and -- SELECT, in this case) still do not copy permissions from the -- hypertable (so there should not be a select permission to public on -- the chunk but there should be one on the hypertable). GRANT INSERT ON conditions TO PUBLIC; \z conditions \z _timescaledb_internal._hyper_1_2_chunk REVOKE SELECT ON _timescaledb_internal._hyper_1_2_chunk FROM PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions \z _timescaledb_internal._hyper_1_2_chunk -- Check that granting permissions through hypertable does not remove -- separate grants on chunk. GRANT UPDATE ON _timescaledb_internal._hyper_1_3_chunk TO PUBLIC; \z conditions \z _timescaledb_internal._hyper_1_3_chunk GRANT INSERT ON conditions TO PUBLIC; REVOKE INSERT ON conditions FROM PUBLIC; \z conditions \z _timescaledb_internal._hyper_1_3_chunk -- Check that GRANT ALL IN SCHEMA adds privileges to the parent -- and also goes to chunks in another schema GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z conditions \z _timescaledb_internal.*chunk -- Check that REVOKE ALL IN SCHEMA removes privileges of the parent -- and also goes to chunks in another schema REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z conditions \z _timescaledb_internal.*chunk -- Create chunks in the same schema as the hypertable and check that -- they also get the same privileges as the hypertable CREATE TABLE measurements( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); -- Create a hypertable with chunks in the same schema SELECT * FROM create_hypertable('public.measurements', 'time', chunk_time_interval => '5 days'::interval, associated_schema_name => 'public'); INSERT INTO measurements SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-10 00:00'::timestamp, '1h') AS time; -- GRANT ALL and check privileges GRANT ALL ON ALL TABLES IN SCHEMA public TO :ROLE_DEFAULT_PERM_USER_2; \z measurements \z conditions \z public.*chunk -- REVOKE ALL and check privileges REVOKE ALL ON ALL TABLES IN SCHEMA public FROM :ROLE_DEFAULT_PERM_USER_2; \z measurements \z conditions \z public.*chunk -- GRANT/REVOKE in an empty schema (Issue #4581) CREATE SCHEMA test_grant; GRANT ALL ON ALL TABLES IN SCHEMA test_grant TO :ROLE_DEFAULT_PERM_USER_2; REVOKE ALL ON ALL TABLES IN SCHEMA test_grant FROM :ROLE_DEFAULT_PERM_USER_2; ������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/hash.sql����������������������������������������������������������������0000664�0000000�0000000�00000011373�15100345067�0017302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test hashing Const values. We should expect the same hash value for -- all integer types when values are compatible SELECT _timescaledb_functions.get_partition_hash(1::int); SELECT _timescaledb_functions.get_partition_hash(1::bigint); SELECT _timescaledb_functions.get_partition_hash(1::smallint); SELECT _timescaledb_functions.get_partition_hash(true); -- Floating point types should also hash the same for compatible values SELECT _timescaledb_functions.get_partition_hash(1.0::real); SELECT _timescaledb_functions.get_partition_hash(1.0::double precision); -- Float aliases SELECT _timescaledb_functions.get_partition_hash(1.0::float); SELECT _timescaledb_functions.get_partition_hash(1.0::float4); SELECT _timescaledb_functions.get_partition_hash(1.0::float8); SELECT _timescaledb_functions.get_partition_hash(1.0::numeric); -- 'name' and '"char"' are internal PostgreSQL types, which are not -- intended for use by the general user. They are included here only -- for completeness -- https://www.postgresql.org/docs/10/static/datatype-character.html#datatype-character-special-table SELECT _timescaledb_functions.get_partition_hash('c'::name); SELECT _timescaledb_functions.get_partition_hash('c'::"char"); -- String and character hashes should also have the same output for -- compatible values SELECT _timescaledb_functions.get_partition_hash('c'::char); SELECT _timescaledb_functions.get_partition_hash('c'::varchar(2)); SELECT _timescaledb_functions.get_partition_hash('c'::text); -- 'c' is 0x63 in ASCII SELECT _timescaledb_functions.get_partition_hash(E'\\x63'::bytea); -- Time and date types SELECT _timescaledb_functions.get_partition_hash(interval '1 day'); SELECT _timescaledb_functions.get_partition_hash('2017-03-22T09:18:23'::timestamp); SELECT _timescaledb_functions.get_partition_hash('2017-03-22T09:18:23'::timestamptz); SELECT _timescaledb_functions.get_partition_hash('2017-03-22'::date); SELECT _timescaledb_functions.get_partition_hash('10:00:00'::time); SELECT _timescaledb_functions.get_partition_hash('10:00:00-1'::timetz); -- Other types SELECT _timescaledb_functions.get_partition_hash(ARRAY[1,2,3]); SELECT _timescaledb_functions.get_partition_hash('08002b:010203'::macaddr); SELECT _timescaledb_functions.get_partition_hash('192.168.100.128/25'::cidr); SELECT _timescaledb_functions.get_partition_hash('192.168.100.128'::inet); SELECT _timescaledb_functions.get_partition_hash('2001:4f8:3:ba:2e0:81ff:fe22:d1f1'::inet); SELECT _timescaledb_functions.get_partition_hash('2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'::cidr); SELECT _timescaledb_functions.get_partition_hash('{ "foo": "bar" }'::jsonb); SELECT _timescaledb_functions.get_partition_hash('4b6a5eec-b344-11e7-abc4-cec278b6b50a'::uuid); SELECT _timescaledb_functions.get_partition_hash(1::regclass); SELECT _timescaledb_functions.get_partition_hash(int4range(10, 20)); SELECT _timescaledb_functions.get_partition_hash(int8range(10, 20)); SELECT _timescaledb_functions.get_partition_hash(numrange(10, 20)); SELECT _timescaledb_functions.get_partition_hash(tsrange('2017-03-22T09:18:23', '2017-03-23T09:18:23')); SELECT _timescaledb_functions.get_partition_hash(tstzrange('2017-03-22T09:18:23+01', '2017-03-23T09:18:23+00')); -- Test hashing Var values CREATE TABLE hash_test(id int, value text); INSERT INTO hash_test VALUES (1, 'test'); -- Test Vars SELECT _timescaledb_functions.get_partition_hash(id) FROM hash_test; SELECT _timescaledb_functions.get_partition_hash(value) FROM hash_test; -- Test coerced value SELECT _timescaledb_functions.get_partition_hash(id::text) FROM hash_test; -- Test legacy function that converts values to text first SELECT _timescaledb_functions.get_partition_for_key('4b6a5eec-b344-11e7-abc4-cec278b6b50a'::text); SELECT _timescaledb_functions.get_partition_for_key('4b6a5eec-b344-11e7-abc4-cec278b6b50a'::varchar); SELECT _timescaledb_functions.get_partition_for_key(187); SELECT _timescaledb_functions.get_partition_for_key(187::bigint); SELECT _timescaledb_functions.get_partition_for_key(187::numeric); SELECT _timescaledb_functions.get_partition_for_key(187::double precision); SELECT _timescaledb_functions.get_partition_for_key(int4range(10, 20)); SELECT _timescaledb_functions.get_partition_hash('08002b:010203'::macaddr); -- Test inside IMMUTABLE function (Issue #4575) CREATE FUNCTION my_get_partition_hash(INTEGER) RETURNS INTEGER AS 'SELECT _timescaledb_functions.get_partition_hash($1);' LANGUAGE SQL IMMUTABLE; CREATE FUNCTION my_get_partition_for_key(INTEGER) RETURNS INTEGER AS 'SELECT _timescaledb_functions.get_partition_for_key($1);' LANGUAGE SQL IMMUTABLE; SELECT my_get_partition_hash(1); SELECT my_get_partition_for_key(1); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/histogram_test.sql.in���������������������������������������������������0000664�0000000�0000000�00000005537�15100345067�0022025�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- table 1 CREATE TABLE "hitest1"(key real, val varchar(40)); -- insertions INSERT INTO "hitest1" VALUES(0, 'hi'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(3, 'yo'); INSERT INTO "hitest1" VALUES(4, 'howdy'); INSERT INTO "hitest1" VALUES(5, 'hola'); INSERT INTO "hitest1" VALUES(6, 'ya'); INSERT INTO "hitest1" VALUES(1, 'sup'); INSERT INTO "hitest1" VALUES(2, 'hello'); INSERT INTO "hitest1" VALUES(1, 'sup'); -- table 2 CREATE TABLE "hitest2"(name varchar(30), score integer, qualify boolean); -- insertions INSERT INTO "hitest2" VALUES('Tom', 6, TRUE); INSERT INTO "hitest2" VALUES('Mary', 4, FALSE); INSERT INTO "hitest2" VALUES('Jaq', 3, FALSE); INSERT INTO "hitest2" VALUES('Jane', 10, TRUE); -- standard 2 bucket SELECT histogram(key, 0, 9, 2) FROM hitest1; -- standard multi-bucket SELECT histogram(key, 0, 9, 5) FROM hitest1; -- standard 3 bucket SELECT val, histogram(key, 0, 7, 3) FROM hitest1 GROUP BY val ORDER BY val; -- standard element beneath lb SELECT histogram(key, 1, 7, 3) FROM hitest1; -- standard element above ub SELECT histogram(key, 0, 3, 3) FROM hitest1; -- standard element beneath and above lb and ub, respectively SELECT histogram(key, 1, 3, 2) FROM hitest1; -- standard 1 bucket SELECT histogram(key, 1, 3, 1) FROM hitest1; -- standard 2 bucket SELECT qualify, histogram(score, 0, 10, 2) FROM hitest2 GROUP BY qualify ORDER BY qualify; -- standard multi-bucket SELECT qualify, histogram(score, 0, 10, 5) FROM hitest2 GROUP BY qualify ORDER BY qualify; -- check number of buckets is constant \set ON_ERROR_STOP 0 select histogram(i,10,90,case when i=1 then 1 else 1000000 end) FROM generate_series(1,100) i; \set ON_ERROR_STOP 1 CREATE TABLE weather ( time TIMESTAMPTZ NOT NULL, city TEXT, temperature FLOAT, PRIMARY KEY(time, city) ); -- There is a bug in width_bucket() causing a NaN as a result, so we -- check that it is not causing a crash in histogram(). SELECT * FROM create_hypertable('weather', 'time', 'city', 3); INSERT INTO weather VALUES ('2023-02-10 09:16:51.133584+00','city1',10.4), ('2023-02-10 11:16:51.611618+00','city1',10.3), ('2023-02-10 06:58:59.999999+00','city1',10.3), ('2023-02-10 01:58:59.999999+00','city1',10.3), ('2023-02-09 01:58:59.999999+00','city1',10.3), ('2023-02-10 08:58:59.999999+00','city1',10.3), ('2023-03-23 06:12:02.73765+00 ','city1', 9.7), ('2023-03-23 06:12:06.990998+00','city1',11.7); -- This will currently generate an error on PG15 and prior versions \set ON_ERROR_STOP 0 SELECT histogram(temperature, -1.79769e+308, 1.79769e+308,10) FROM weather GROUP BY city; \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017254�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/agg_bookends_load.sql�������������������������������������������0000664�0000000�0000000�00000002054�15100345067�0023417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE btest(time timestamp NOT NULL, time_alt timestamp, gp INTEGER, temp float, strid TEXT DEFAULT 'testing'); SELECT schema_name, table_name, created FROM create_hypertable('btest', 'time'); INSERT INTO btest VALUES('2017-01-20T09:00:01', '2017-01-20T10:00:00', 1, 22.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:59', 1, 21.2); INSERT INTO btest VALUES('2017-01-20T09:00:47', '2017-01-20T09:00:58', 1, 25.1); INSERT INTO btest VALUES('2017-01-20T09:00:02', '2017-01-20T09:00:57', 2, 35.5); INSERT INTO btest VALUES('2017-01-20T09:00:21', '2017-01-20T09:00:56', 2, 30.2); --TOASTED; INSERT INTO btest VALUES('2017-01-20T09:00:43', '2017-01-20T09:01:55', 2, 20.1, repeat('xyz', 1000000) ); CREATE TABLE btest_numeric (time timestamp NOT NULL, quantity numeric); SELECT schema_name, table_name, created FROM create_hypertable('btest_numeric', 'time'); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/agg_bookends_query.sql������������������������������������������0000664�0000000�0000000�00000014132�15100345067�0023645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be only output of results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); :PREFIX SELECT time, gp, temp FROM btest ORDER BY time; :PREFIX SELECT last(temp, time) FROM btest; :PREFIX SELECT first(temp, time) FROM btest; :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; :PREFIX SELECT gp, last(temp, time) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, first(temp, time) FROM btest GROUP BY gp ORDER BY gp; --check whole row :PREFIX SELECT gp, first(btest, time) FROM btest GROUP BY gp ORDER BY gp; --check toasted col :PREFIX SELECT gp, left(last(strid, time), 10) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(temp, strid) FROM btest GROUP BY gp ORDER BY gp; :PREFIX SELECT gp, last(strid, temp) FROM btest GROUP BY gp ORDER BY gp; BEGIN; --check null value as last element INSERT INTO btest VALUES('2018-01-20T09:00:43', '2017-01-20T09:00:55', 2, NULL); :PREFIX SELECT last(temp, time) FROM btest; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest VALUES('2019-01-20T09:00:43', '2018-01-20T09:00:55', 2, 30.5); :PREFIX SELECT last(temp, time) FROM btest; --check null cmp element is skipped INSERT INTO btest VALUES('2018-01-20T09:00:43', NULL, 2, 32.3); :PREFIX SELECT last(temp, time_alt) FROM btest; -- fist returns NULL value :PREFIX SELECT first(temp, time_alt) FROM btest; -- test first return non NULL value INSERT INTO btest VALUES('2016-01-20T09:00:00', '2016-01-20T09:00:00', 2, 36.5); :PREFIX SELECT first(temp, time_alt) FROM btest; --check non null cmp element insert after null cmp INSERT INTO btest VALUES('2020-01-20T09:00:43', '2020-01-20T09:00:43', 2, 35.3); :PREFIX SELECT last(temp, time_alt) FROM btest; :PREFIX SELECT first(temp, time_alt) FROM btest; --cmp nulls should be ignored and not present in groups :PREFIX SELECT gp, last(temp, time_alt) FROM btest GROUP BY gp ORDER BY gp; --Previously, some bugs were found with NULLS and numeric types, so test that INSERT INTO btest_numeric VALUES ('2019-01-20T09:00:43', NULL); :PREFIX SELECT last(quantity, time) FROM btest_numeric; --check non-null element "overrides" NULL because it comes after. INSERT INTO btest_numeric VALUES('2020-01-20T09:00:43', 30.5); :PREFIX SELECT last(quantity, time) FROM btest_numeric; -- do index scan for last :PREFIX SELECT last(temp, time) FROM btest; -- do index scan for first :PREFIX SELECT first(temp, time) FROM btest; -- can't do index scan when ordering on non-index column :PREFIX SELECT first(temp, time_alt) FROM btest; -- do index scan for subquery :PREFIX SELECT * FROM (SELECT last(temp, time) FROM btest) last; -- can't do index scan when using group by :PREFIX SELECT last(temp, time) FROM btest GROUP BY gp ORDER BY gp; -- do index scan when agg function is used in CTE subquery :PREFIX WITH last_temp AS (SELECT last(temp, time) FROM btest) SELECT * from last_temp; -- do index scan when using both FIRST and LAST aggregate functions :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- verify results when using both FIRST and LAST :PREFIX SELECT first(temp, time), last(temp, time) FROM btest; -- do index scan when using WHERE :PREFIX SELECT last(temp, time) FROM btest WHERE time <= '2017-01-20T09:00:02'; -- can't do index scan for MAX and LAST combined (MinMax optimization fails when having different aggregate functions) :PREFIX SELECT max(time), last(temp, time) FROM btest; -- can't do index scan when using FIRST/LAST in ORDER BY :PREFIX SELECT last(temp, time) FROM btest ORDER BY last(temp, time); -- do index scan :PREFIX SELECT last(temp, time) FROM btest WHERE temp < 30; -- SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- do index scan :PREFIX SELECT first(temp, time) FROM btest WHERE time >= '2017-01-20 09:00:47'; -- can't do index scan when using WINDOW function :PREFIX SELECT gp, last(temp, time) OVER (PARTITION BY gp) AS last FROM btest; -- test constants :PREFIX SELECT first(100, 100) FROM btest; -- create an index so we can test optimization CREATE INDEX btest_time_alt_idx ON btest(time_alt); :PREFIX SELECT last(temp, time_alt) FROM btest; --test nested FIRST/LAST - should optimize :PREFIX SELECT abs(last(temp, time)) FROM btest; -- test nested FIRST/LAST in ORDER BY - no optimization possible :PREFIX SELECT abs(last(temp, time)) FROM btest ORDER BY abs(last(temp,time)); ROLLBACK; -- Test with NULL numeric values BEGIN; TRUNCATE btest_numeric; -- Empty table :PREFIX SELECT first(btest_numeric, time) FROM btest_numeric; :PREFIX SELECT last(btest_numeric, time) FROM btest_numeric; -- Only NULL values INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; -- NULL values followed by non-NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; TRUNCATE btest_numeric; -- non-NULL values followed by NULL values INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 1); INSERT INTO btest_numeric VALUES('2019-01-20T09:00:43', 2); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); INSERT INTO btest_numeric VALUES('2018-01-20T09:00:43', NULL); :PREFIX SELECT first(quantity, time) FROM btest_numeric; :PREFIX SELECT last(quantity, time) FROM btest_numeric; :PREFIX SELECT first(time, quantity) FROM btest_numeric; :PREFIX SELECT last(time, quantity) FROM btest_numeric; ROLLBACK; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/append_load.sql�������������������������������������������������0000664�0000000�0000000�00000011607�15100345067�0022250�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE PARALLEL SAFE AS $BODY$ BEGIN RAISE NOTICE 'Stable function now_s() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_i() RETURNS timestamptz LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'Immutable function now_i() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE FUNCTION now_v() RETURNS timestamptz LANGUAGE PLPGSQL VOLATILE AS $BODY$ BEGIN RAISE NOTICE 'Volatile function now_v() called!'; RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE OR REPLACE PROCEDURE force_parallel(on_or_off bool) LANGUAGE PLPGSQL AS $$ BEGIN IF current_setting('server_version_num')::int < 160000 THEN IF on_or_off THEN set force_parallel_mode = 'on'; ELSE set force_parallel_mode = 'off'; END IF; ELSE IF on_or_off THEN set debug_parallel_query = 'on'; ELSE set debug_parallel_query = 'off'; END IF; END IF; END; $$; CREATE TABLE append_test(time timestamptz, temp float, colorid integer, attr jsonb); SELECT create_hypertable('append_test', 'time', chunk_time_interval => 2628000000000); -- create three chunks INSERT INTO append_test VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); VACUUM (ANALYZE) append_test; -- Create another hypertable to join with CREATE TABLE join_test(time timestamptz, temp float, colorid integer); SELECT create_hypertable('join_test', 'time', chunk_time_interval => 2628000000000); INSERT INTO join_test VALUES ('2017-01-22T09:18:22', 15.2, 1), ('2017-02-22T09:18:22', 24.5, 2), ('2017-08-22T09:18:22', 23.1, 3); VACUUM (ANALYZE) join_test; -- Create another table to join with which is not a hypertable. CREATE TABLE join_test_plain(time timestamptz, temp float, colorid integer, attr jsonb); INSERT INTO join_test_plain VALUES ('2017-01-22T09:18:22', 15.2, 1, '{"a": 1}'), ('2017-02-22T09:18:22', 24.5, 2, '{"b": 2}'), ('2017-08-22T09:18:22', 23.1, 3, '{"c": 3}'); VACUUM (ANALYZE) join_test_plain; -- create hypertable with DATE time dimension CREATE TABLE metrics_date(time DATE NOT NULL); SELECT create_hypertable('metrics_date','time'); INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_date; -- create hypertable with TIMESTAMP time dimension CREATE TABLE metrics_timestamp(time TIMESTAMP NOT NULL); SELECT create_hypertable('metrics_timestamp','time'); INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); VACUUM (ANALYZE) metrics_timestamp; -- create hypertable with TIMESTAMPTZ time dimension CREATE TABLE metrics_timestamptz(time TIMESTAMPTZ NOT NULL, device_id INT NOT NULL); CREATE INDEX ON metrics_timestamptz(device_id,time); SELECT create_hypertable('metrics_timestamptz','time'); INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval), 3; VACUUM (ANALYZE) metrics_timestamptz; -- create space partitioned hypertable CREATE TABLE metrics_space(time timestamptz NOT NULL, device_id int NOT NULL, v1 float, v2 float, v3 text); SELECT create_hypertable('metrics_space','time','device_id',3); INSERT INTO metrics_space SELECT time, device_id, device_id + 0.25, device_id + 0.75, device_id FROM generate_series('2000-01-01'::timestamptz, '2000-01-14'::timestamptz, '5m'::interval) g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) metrics_space; -- test ChunkAppend projection #2661 CREATE TABLE i2661 ( machine_id int4 NOT NULL, "name" varchar(255) NOT NULL, "timestamp" timestamptz NOT NULL, "first" float4 NULL ); SELECT create_hypertable('i2661', 'timestamp'); INSERT INTO i2661 SELECT 1, 'speed', generate_series('2019-12-31 00:00:00', '2020-01-10 00:00:00', '2m'::interval), 0; VACUUM (ANALYZE) i2661; �������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/append_query.sql������������������������������������������������0000664�0000000�0000000�00000045102�15100345067�0022473�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- canary for results diff -- this should be the only output of the results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations'),('timescaledb.enable_chunk_append')) v(setting); -- query should exclude all chunks with optimization on :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC; --query should exclude all chunks and be a MergeAppend :PREFIX SELECT * FROM append_test WHERE time > now_s() + '1 month' ORDER BY time DESC limit 1; -- when optimized, the plan should be a constraint-aware append and -- cover only one chunk. It should be a backward index scan due to -- descending index on time. Should also skip the main table, since it -- cannot hold tuples :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months'; -- adding ORDER BY and LIMIT should turn the plan into an optimized -- ordered append plan :PREFIX SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time LIMIT 3; -- no optimized plan for queries with restrictions that can be -- constified at planning time. Regular planning-time constraint -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_i() - interval '2 months' ORDER BY time; -- currently, we cannot distinguish between stable and volatile -- functions as far as applying our modified plan. However, volatile -- function should not be pre-evaluated to constants, so no chunk -- exclusion should occur. :PREFIX SELECT * FROM append_test WHERE time > now_v() - interval '2 months' ORDER BY time; -- prepared statement output should be the same regardless of -- optimizations PREPARE query_opt AS SELECT * FROM append_test WHERE time > now_s() - interval '2 months' ORDER BY time; :PREFIX EXECUTE query_opt; DEALLOCATE query_opt; -- aggregates should produce same output :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time > now_s() - interval '4 months' GROUP BY t ORDER BY t DESC; -- querying outside the time range should return nothing. This tests -- that ConstraintAwareAppend can handle the case when an Append node -- is turned into a Result node due to no children :PREFIX SELECT date_trunc('year', time) t, avg(temp) FROM append_test WHERE time < '2016-03-22' AND date_part('dow', time) between 1 and 5 GROUP BY t ORDER BY t DESC; -- a parameterized query can safely constify params, so won't be -- optimized by constraint-aware append since regular constraint -- exclusion works just fine PREPARE query_param AS SELECT * FROM append_test WHERE time > $1 ORDER BY time; :PREFIX EXECUTE query_param(now_s() - interval '2 months'); DEALLOCATE query_param; --test with cte :PREFIX WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; WITH data AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime, AVG(temp) AS VALUE FROM append_test WHERE TIME > now_s() - INTERVAL '400 day' AND colorid > 0 GROUP BY btime ), period AS ( SELECT time_bucket(INTERVAL '30 day', TIME) AS btime FROM GENERATE_SERIES('2017-03-22T01:01:01', '2017-08-23T01:01:01', INTERVAL '30 day') TIME ) SELECT period.btime, VALUE FROM period LEFT JOIN DATA USING (btime) ORDER BY period.btime; -- force nested loop join with no materialization. This tests that the -- inner ConstraintAwareScan supports resetting its scan for every -- iteration of the outer relation loop set enable_hashjoin = 'off'; set enable_mergejoin = 'off'; set enable_material = 'off'; :PREFIX SELECT * FROM append_test a INNER JOIN join_test j ON (a.colorid = j.colorid) WHERE a.time > now_s() - interval '3 hours' AND j.time > now_s() - interval '3 hours'; reset enable_hashjoin; reset enable_mergejoin; reset enable_material; -- test constraint_exclusion with date time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz ORDER BY time; -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::date < time ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamp < time ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE '2000-01-15'::timestamptz < time ORDER BY time; -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; -- test constraint_exclusion with timestamp time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz ORDER BY time; -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::date < time ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamp < time ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE '2000-01-15'::timestamptz < time ORDER BY time; -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; -- test constraint_exclusion with timestamptz time dimension and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz ORDER BY time; -- test Const OP Var -- the queries should all have 3 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::date < time ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamp < time ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE '2000-01-15'::timestamptz < time ORDER BY time; -- test 2 constraints -- the queries should all have 2 chunks :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::date AND time < '2000-01-21'::date ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamp AND time < '2000-01-21'::timestamp ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > '2000-01-15'::timestamptz AND time < '2000-01-21'::timestamptz ORDER BY time; -- test constraint_exclusion with space partitioning and DATE/TIMESTAMP/TIMESTAMPTZ constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz ORDER BY time; -- test Const OP Var -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::date < time ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamp < time ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE '2000-01-10'::timestamptz < time ORDER BY time; -- test 2 constraints -- exclusion for constraints with non-matching datatypes not working for space partitioning atm :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::date AND time < '2000-01-15'::date ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamp AND time < '2000-01-15'::timestamp ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND time < '2000-01-15'::timestamptz ORDER BY time; -- test filtering on space partition :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id = 1 ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (1,2) ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND device_id IN (VALUES(1)) ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > '2000-01-10'::timestamptz AND v3 IN (VALUES('1')) ORDER BY time; :PREFIX SELECT * FROM metrics_space WHERE time = (VALUES ('2019-12-24' at time zone 'UTC')) AND v3 NOT IN (VALUES ('1')); -- test CURRENT_DATE -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_DATE ORDER BY time; :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_DATE ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_DATE ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_DATE ORDER BY time; -- test CURRENT_TIMESTAMP -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > CURRENT_TIMESTAMP ORDER BY time; :PREFIX SELECT time FROM metrics_timestamp WHERE time > CURRENT_TIMESTAMP ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > CURRENT_TIMESTAMP ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > CURRENT_TIMESTAMP ORDER BY time; -- test now() -- should be 0 chunks :PREFIX SELECT time FROM metrics_date WHERE time > now() ORDER BY time; :PREFIX SELECT time FROM metrics_timestamp WHERE time > now() ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time > now() ORDER BY time; :PREFIX SELECT time FROM metrics_space WHERE time > now() ORDER BY time; -- query with tablesample and planner exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15' ORDER BY time DESC; -- query with tablesample and startup exclusion :PREFIX SELECT * FROM metrics_date TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-15'::text::date ORDER BY time DESC; -- query with tablesample, space partitioning and planner exclusion :PREFIX SELECT * FROM metrics_space TABLESAMPLE BERNOULLI(5) REPEATABLE(0) WHERE time > '2000-01-10'::timestamptz ORDER BY time DESC, device_id; -- test runtime exclusion -- test runtime exclusion with LATERAL and 2 hypertables :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; -- test runtime exclusion and startup exclusions :PREFIX SELECT m1.time, m2.time FROM metrics_timestamptz m1 LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m2 WHERE m1.time = m2.time AND m2.time < '2000-01-10'::text::timestamptz LIMIT 1) m2 ON true ORDER BY m1.time; -- test runtime exclusion does not activate for constraints on non-partitioning columns -- should not use runtime exclusion :PREFIX SELECT * FROM append_test a LEFT JOIN LATERAL(SELECT * FROM join_test j WHERE a.colorid = j.colorid ORDER BY time DESC LIMIT 1) j ON true ORDER BY a.time LIMIT 1; -- test runtime exclusion with LATERAL and generate_series :PREFIX SELECT g.time FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g(time) LEFT JOIN LATERAL(SELECT time FROM metrics_timestamptz m WHERE m.time=g.time LIMIT 1) m ON true; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time) m ON true; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time=g.time ORDER BY time) m ON true; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval) AS g(time) INNER JOIN LATERAL (SELECT time FROM metrics_timestamptz m WHERE time>g.time + '1 day' ORDER BY time LIMIT 1) m ON true; -- test runtime exclusion with subquery :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE m1.time=(SELECT max(time) FROM metrics_timestamptz); -- test runtime exclusion with correlated subquery :PREFIX SELECT m1.time, (SELECT m2.time FROM metrics_timestamptz m2 WHERE m2.time < m1.time ORDER BY m2.time DESC LIMIT 1) FROM metrics_timestamptz m1 WHERE m1.time < '2000-01-10' ORDER BY m1.time; -- test EXISTS :PREFIX SELECT m1.time FROM metrics_timestamptz m1 WHERE EXISTS(SELECT 1 FROM metrics_timestamptz m2 WHERE m1.time < m2.time) ORDER BY m1.time DESC limit 1000; -- test constraint exclusion for subqueries with append -- should include 2 chunks :PREFIX SELECT time FROM (SELECT time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY time) m; -- test constraint exclusion for subqueries with mergeappend -- should include 2 chunks :PREFIX SELECT device_id, time FROM (SELECT device_id, time FROM metrics_timestamptz WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time) m; -- test LIMIT pushdown -- no aggregates/window functions/SRF should pushdown limit :PREFIX SELECT FROM metrics_timestamptz ORDER BY time LIMIT 1; -- aggregates should prevent pushdown :PREFIX SELECT count(*) FROM metrics_timestamptz LIMIT 1; :PREFIX SELECT count(*) FROM metrics_space LIMIT 1; -- HAVING should prevent pushdown :PREFIX SELECT 1 FROM metrics_timestamptz HAVING count(*) > 1 LIMIT 1; :PREFIX SELECT 1 FROM metrics_space HAVING count(*) > 1 LIMIT 1; -- DISTINCT should prevent pushdown SET enable_hashagg TO false; :PREFIX SELECT DISTINCT device_id FROM metrics_timestamptz ORDER BY device_id LIMIT 3; :PREFIX SELECT DISTINCT device_id FROM metrics_space ORDER BY device_id LIMIT 3; RESET enable_hashagg; -- JOINs should prevent pushdown -- when LIMIT gets pushed to a Sort node it will switch to top-N heapsort -- if more tuples then LIMIT are requested this will trigger an error -- to trigger this we need a Sort node that is below ChunkAppend CREATE TABLE join_limit (time timestamptz, device_id int); SELECT table_name FROM create_hypertable('join_limit','time',create_default_indexes:=false); CREATE INDEX ON join_limit(time,device_id); INSERT INTO join_limit SELECT time, device_id FROM generate_series('2000-01-01'::timestamptz,'2000-01-21','30m') g1(time), generate_series(1,10,1) g2(device_id) ORDER BY time, device_id; VACUUM (ANALYZE) join_limit; -- get 2nd chunk oid SELECT tableoid AS "CHUNK_OID" FROM join_limit WHERE time > '2000-01-07' ORDER BY time LIMIT 1 \gset --get index name for 2nd chunk SELECT indexrelid::regclass AS "INDEX_NAME" FROM pg_index WHERE indrelid = :CHUNK_OID \gset DROP INDEX :INDEX_NAME; :PREFIX SELECT * FROM metrics_timestamptz m1 INNER JOIN join_limit m2 ON m1.time = m2.time AND m1.device_id=m2.device_id WHERE m1.time > '2000-01-07' ORDER BY m1.time, m1.device_id LIMIT 3; DROP TABLE join_limit; -- test ChunkAppend projection #2661 :PREFIX SELECT ts.timestamp, ht.timestamp FROM ( SELECT generate_series( to_timestamp(FLOOR(EXTRACT (EPOCH FROM '2020-01-01T00:01:00Z'::timestamp) / 300) * 300) AT TIME ZONE 'UTC', '2020-01-01T01:00:00Z', '5 minutes'::interval ) AS timestamp ) ts LEFT JOIN i2661 ht ON (FLOOR(EXTRACT (EPOCH FROM ht."timestamp") / 300) * 300 = EXTRACT (EPOCH FROM ts.timestamp)) AND ht.timestamp > '2019-12-30T00:00:00Z'::timestamp ORDER BY ts.timestamp, ht.timestamp; -- #3030 test chunkappend keeps pathkeys when subpath is append -- on PG11 this will not use ChunkAppend but MergeAppend SET enable_seqscan TO FALSE; CREATE TABLE i3030(time timestamptz NOT NULL, a int, b int); SELECT table_name FROM create_hypertable('i3030', 'time', create_default_indexes=>false); CREATE INDEX ON i3030(a,time); INSERT INTO i3030 (time,a) SELECT time, a FROM generate_series('2000-01-01'::timestamptz,'2000-01-01 3:00:00'::timestamptz,'1min'::interval) time, generate_series(1,30) a; VACUUM (ANALYZE) i3030; :PREFIX SELECT * FROM i3030 where time BETWEEN '2000-01-01'::text::timestamptz AND '2000-01-03'::text::timestamptz ORDER BY a,time LIMIT 1; DROP TABLE i3030; RESET enable_seqscan; --parent runtime exclusion tests: --optimization works with ANY (array) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > 100)::jsonb[]); --optimization does not work for ANY subquery (does not force an initplan) :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT attr FROM join_test_plain WHERE temp > 100)); --works on any strict operator without ANY :PREFIX SELECT * FROM append_test a WHERE a.attr @> (SELECT attr FROM join_test_plain WHERE temp > 100 limit 1); --optimization works with function calls CREATE OR REPLACE FUNCTION select_tag(_min_temp int) RETURNS jsonb[] LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT coalesce(array_agg(attr), array[]::jsonb[]) FROM join_test_plain WHERE temp > _min_temp $function$; :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT select_tag(100))::jsonb[]); --optimization does not work when result is null :PREFIX SELECT * FROM append_test a WHERE a.attr @> ANY((SELECT array_agg(attr) FROM join_test_plain WHERE temp > 100)::jsonb[]); -- Test that ConstraintAwareAppend properly locks relations in -- parallel query mode set timescaledb.enable_chunk_append=false; call force_parallel(true); :PREFIX select time, avg(temp), colorid from append_test where time > now_s() - interval '3 months 20 days' group by time, colorid; reset timescaledb.enable_chunk_append; reset max_parallel_workers_per_gather; call force_parallel(false); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/bgw_launcher_utils.sql������������������������������������������0000664�0000000�0000000�00000005403�15100345067�0023657�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Note on testing: need a couple wrappers that pg_sleep in a loop to wait for changes -- to appear in pg_stat_activity. -- Further Note: PG 9.6 changed what appeared in pg_stat_activity, so the launcher doesn't actually show up. -- we can still test its interactions with its children, but can't test some of the things specific to the launcher. -- So we've added some bits about the version number as needed. CREATE VIEW worker_counts as SELECT count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Launcher') as launcher, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME') as single_scheduler, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = :'TEST_DBNAME_2') as single_2_scheduler, count(*) filter (WHERE backend_type = 'TimescaleDB Background Worker Scheduler' AND datname = 'template1') as template1_scheduler FROM pg_stat_activity; CREATE FUNCTION wait_worker_counts(launcher_ct INTEGER, scheduler1_ct INTEGER, scheduler2_ct INTEGER, template1_ct INTEGER) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1..10 LOOP SELECT COUNT(*) from worker_counts where launcher = launcher_ct AND single_scheduler = scheduler1_ct AND single_2_scheduler = scheduler2_ct and template1_scheduler = template1_ct into r; if(r < 1) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE --We have the correct counts! RETURN TRUE; END IF; END LOOP; RETURN FALSE; END $BODY$; CREATE FUNCTION wait_for_bgw_scheduler(_datname NAME, _count INT DEFAULT 1, _ticks INT DEFAULT 10) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1.._ticks LOOP SELECT count(*) FROM pg_stat_activity WHERE application_name = 'TimescaleDB Background Worker Scheduler' AND datname = _datname INTO r; IF(r <> _count) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN 'BGW Scheduler found.'; END IF; END LOOP; RETURN 'BGW Scheduler NOT found.'; END $BODY$; CREATE PROCEDURE kill_database_backends(_datname NAME) LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN FOR i in 1..100 LOOP SELECT count(pg_terminate_backend(pg_stat_activity.pid)) FROM pg_stat_activity WHERE datname = _datname AND pg_stat_activity.pid <> pg_backend_pid() INTO r; IF(r = 0) THEN RETURN; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RAISE 'Failed to terminate backends'; END $BODY$; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/bgw_launcher_utils_cleanup.sql����������������������������������0000664�0000000�0000000�00000000570�15100345067�0025366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP FUNCTION wait_worker_counts(integer, integer, integer, integer); DROP VIEW worker_counts; DROP FUNCTION wait_for_bgw_scheduler(name,int,int); DROP PROCEDURE kill_database_backends(name); ����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/ddl_ops_1.sql���������������������������������������������������0000664�0000000�0000000�00000014477�15100345067�0021656�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1, humidity numeric NULL DEFAULT 0, sensor_1 NUMERIC NULL DEFAULT 1, sensor_2 NUMERIC NOT NULL DEFAULT 1, sensor_3 NUMERIC NOT NULL DEFAULT 1, sensor_4 NUMERIC NOT NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1" (time, "Device_id"); CREATE TABLE "customSchema"."Hypertable_1" ( time BIGINT NOT NULL, "Device_id" TEXT NOT NULL, temp_c int NOT NULL DEFAULT -1, humidity numeric NULL DEFAULT 0, sensor_1 NUMERIC NULL DEFAULT 1, sensor_2 NUMERIC NOT NULL DEFAULT 1, sensor_3 NUMERIC NOT NULL DEFAULT 1, sensor_4 NUMERIC NOT NULL DEFAULT 1 ); CREATE INDEX ON "customSchema"."Hypertable_1" (time, "Device_id"); SELECT * FROM create_hypertable('"public"."Hypertable_1"', 'time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM create_hypertable('"customSchema"."Hypertable_1"', 'time', NULL, 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM _timescaledb_catalog.hypertable; CREATE INDEX ON PUBLIC."Hypertable_1" (time, "temp_c"); CREATE INDEX "ind_humidity" ON PUBLIC."Hypertable_1" (time, "humidity"); CREATE INDEX "ind_sensor_1" ON PUBLIC."Hypertable_1" (time, "sensor_1"); INSERT INTO PUBLIC."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 30, 70, 1, 2, 3, 100); CREATE UNIQUE INDEX "Unique1" ON PUBLIC."Hypertable_1" (time, "Device_id"); CREATE UNIQUE INDEX "Unique1" ON "customSchema"."Hypertable_1" (time); INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 30, 70, 1, 2, 3, 100); INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000001, 'dev1', 30, 70, 1, 2, 3, 100); SELECT * FROM test.show_indexesp('%.%'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper_%'); --expect error cases \set ON_ERROR_STOP 0 INSERT INTO "customSchema"."Hypertable_1"(time, "Device_id", temp_c, humidity, sensor_1, sensor_2, sensor_3, sensor_4) VALUES(1257894000000000000, 'dev1', 31, 71, 72, 4, 1, 102); CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" ("Device_id"); CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" (time); CREATE UNIQUE INDEX "Unique2" ON PUBLIC."Hypertable_1" (sensor_1); UPDATE ONLY PUBLIC."Hypertable_1" SET time = 0 WHERE TRUE; DELETE FROM ONLY PUBLIC."Hypertable_1" WHERE "Device_id" = 'dev1'; \set ON_ERROR_STOP 1 CREATE TABLE my_ht (time BIGINT, val integer); SELECT * FROM create_hypertable('my_ht', 'time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); ALTER TABLE my_ht ADD COLUMN val2 integer; SELECT * FROM test.show_columns('my_ht'); -- Should error when adding again \set ON_ERROR_STOP 0 ALTER TABLE my_ht ADD COLUMN val2 integer; \set ON_ERROR_STOP 1 -- Should create ALTER TABLE my_ht ADD COLUMN IF NOT EXISTS val3 integer; SELECT * FROM test.show_columns('my_ht'); -- Should skip and not error ALTER TABLE my_ht ADD COLUMN IF NOT EXISTS val3 integer; SELECT * FROM test.show_columns('my_ht'); -- Should drop ALTER TABLE my_ht DROP COLUMN IF EXISTS val3; SELECT * FROM test.show_columns('my_ht'); -- Should skip and not error ALTER TABLE my_ht DROP COLUMN IF EXISTS val3; SELECT * FROM test.show_columns('my_ht'); --Test default index creation on create_hypertable(). --Make sure that we do not duplicate indexes that already exists -- --No existing indexes: both time and space-time indexes created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); ROLLBACK; --Space index exists: only time index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1_with_default_index_enabled" ("Device_id", "Time" DESC); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); ROLLBACK; --Time index exists, only partition index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE INDEX ON PUBLIC."Hypertable_1_with_default_index_enabled" ("Time" DESC); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); ROLLBACK; --No space partitioning, only time index created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); ROLLBACK; --Disable index creation: no default indexes created BEGIN; CREATE TABLE PUBLIC."Hypertable_1_with_default_index_enabled" ( "Time" BIGINT NOT NULL, "Device_id" TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); SELECT * FROM create_hypertable('"public"."Hypertable_1_with_default_index_enabled"', 'Time', 'Device_id', 1, create_default_indexes=>FALSE, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); SELECT * FROM test.show_indexes('"Hypertable_1_with_default_index_enabled"'); ROLLBACK; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/ddl_ops_2.sql���������������������������������������������������0000664�0000000�0000000�00000003300�15100345067�0021636�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN temp_f INTEGER NOT NULL DEFAULT 31; ALTER TABLE PUBLIC."Hypertable_1" DROP COLUMN temp_c; ALTER TABLE PUBLIC."Hypertable_1" DROP COLUMN sensor_4; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN humidity SET DEFAULT 100; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_1 DROP DEFAULT; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2 SET DEFAULT NULL; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_1 SET NOT NULL; ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2 DROP NOT NULL; ALTER TABLE PUBLIC."Hypertable_1" RENAME COLUMN sensor_2 TO sensor_2_renamed; ALTER TABLE PUBLIC."Hypertable_1" RENAME COLUMN sensor_3 TO sensor_3_renamed; DROP INDEX "ind_sensor_1"; CREATE OR REPLACE FUNCTION empty_trigger_func() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN END $BODY$; CREATE TRIGGER test_trigger BEFORE UPDATE OR DELETE ON PUBLIC."Hypertable_1" FOR EACH STATEMENT EXECUTE FUNCTION empty_trigger_func(); ALTER TABLE PUBLIC."Hypertable_1" ALTER COLUMN sensor_2_renamed SET DATA TYPE int; ALTER INDEX "ind_humidity" RENAME TO "ind_humdity2"; -- Change should be reflected here SELECT * FROM test.show_indexesp('%.%'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); --create column with same name as previously renamed one ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN sensor_3 BIGINT NOT NULL DEFAULT 131; --create column with same name as previously dropped one ALTER TABLE PUBLIC."Hypertable_1" ADD COLUMN sensor_4 BIGINT NOT NULL DEFAULT 131; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/insert_single.sql�����������������������������������������������0000664�0000000�0000000�00000003351�15100345067�0022644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."one_Partition" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."one_Partition" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."one_Partition" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; \c :DBNAME :ROLE_SUPERUSER CREATE SCHEMA "one_Partition" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :DBNAME :ROLE_DEFAULT_PERM_USER; SELECT * FROM create_hypertable('"public"."one_Partition"', 'timeCustom', associated_schema_name=>'one_Partition', chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); --output command tags \set QUIET off BEGIN; \COPY "one_Partition" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "one_Partition"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/insert_two_partitions.sql���������������������������������������0000664�0000000�0000000�00000003403�15100345067�0024446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); \set QUIET off BEGIN; \COPY public."two_Partitions" FROM 'data/ds1_dev1_1.tsv' NULL AS ''; COMMIT; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257894000000000000, 'dev2', 1.5, 2); \set QUIET on �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/join_load.sql���������������������������������������������������0000664�0000000�0000000�00000010552�15100345067�0021736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- these table definitions have been adjusted from -- table defintions of the postgres test suite CREATE TABLE INT2_TBL(f1 int2, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('int2_tbl','ts'); INSERT INTO INT2_TBL(f1) VALUES ('0 '); INSERT INTO INT2_TBL(f1) VALUES (' 1234 '); INSERT INTO INT2_TBL(f1) VALUES (' -1234'); -- largest and smallest values INSERT INTO INT2_TBL(f1) VALUES ('32767'); INSERT INTO INT2_TBL(f1) VALUES ('-32767'); CREATE TABLE INT4_TBL(f1 int4, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('int4_tbl','ts'); INSERT INTO INT4_TBL(f1) VALUES (' 0 '); INSERT INTO INT4_TBL(f1) VALUES ('123456 '); INSERT INTO INT4_TBL(f1) VALUES (' -123456'); -- largest and smallest values INSERT INTO INT4_TBL(f1) VALUES ('2147483647'); INSERT INTO INT4_TBL(f1) VALUES ('-2147483647'); CREATE TABLE INT8_TBL(q1 int8, q2 int8, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('int8_tbl','ts'); INSERT INTO INT8_TBL VALUES(' 123 ',' 456'); INSERT INTO INT8_TBL VALUES('123 ','4567890123456789'); INSERT INTO INT8_TBL VALUES('4567890123456789','123'); INSERT INTO INT8_TBL VALUES(+4567890123456789,'4567890123456789'); INSERT INTO INT8_TBL VALUES('+4567890123456789','-4567890123456789'); CREATE TABLE FLOAT8_TBL(f1 float8, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('float8_tbl','ts'); INSERT INTO FLOAT8_TBL(f1) VALUES (' 0.0 '); INSERT INTO FLOAT8_TBL(f1) VALUES ('1004.30 '); INSERT INTO FLOAT8_TBL(f1) VALUES (' -34.84'); INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e+200'); INSERT INTO FLOAT8_TBL(f1) VALUES ('1.2345678901234e-200'); CREATE TABLE TEXT_TBL (f1 text, ts timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('text_tbl','ts'); INSERT INTO TEXT_TBL VALUES ('doh!'); INSERT INTO TEXT_TBL VALUES ('hi de ho neighbor'); CREATE TABLE a (aa TEXT); CREATE TABLE b (bb TEXT) INHERITS (a); CREATE TABLE c (cc TEXT) INHERITS (a); CREATE TABLE d (dd TEXT) INHERITS (b,c,a); INSERT INTO a(aa) VALUES('aaa'); INSERT INTO a(aa) VALUES('aaaa'); INSERT INTO a(aa) VALUES('aaaaa'); INSERT INTO a(aa) VALUES('aaaaaa'); INSERT INTO a(aa) VALUES('aaaaaaa'); INSERT INTO a(aa) VALUES('aaaaaaaa'); INSERT INTO b(aa) VALUES('bbb'); INSERT INTO b(aa) VALUES('bbbb'); INSERT INTO b(aa) VALUES('bbbbb'); INSERT INTO b(aa) VALUES('bbbbbb'); INSERT INTO b(aa) VALUES('bbbbbbb'); INSERT INTO b(aa) VALUES('bbbbbbbb'); INSERT INTO c(aa) VALUES('ccc'); INSERT INTO c(aa) VALUES('cccc'); INSERT INTO c(aa) VALUES('ccccc'); INSERT INTO c(aa) VALUES('cccccc'); INSERT INTO c(aa) VALUES('ccccccc'); INSERT INTO c(aa) VALUES('cccccccc'); INSERT INTO d(aa) VALUES('ddd'); INSERT INTO d(aa) VALUES('dddd'); INSERT INTO d(aa) VALUES('ddddd'); INSERT INTO d(aa) VALUES('dddddd'); INSERT INTO d(aa) VALUES('ddddddd'); INSERT INTO d(aa) VALUES('dddddddd'); CREATE TABLE onek ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 name, stringu2 name, string4 name ); SELECT table_name FROM create_hypertable('onek','unique2',chunk_time_interval:=1000); \copy onek FROM 'data/onek.data' CREATE TABLE tenk1 ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 name, stringu2 name, string4 name ); SELECT table_name FROM create_hypertable('tenk1','unique2',chunk_time_interval:=1000); \copy tenk1 FROM 'data/tenk.data' CREATE TABLE tenk2 ( unique1 int4, unique2 int4, two int4, four int4, ten int4, twenty int4, hundred int4, thousand int4, twothousand int4, fivethous int4, tenthous int4, odd int4, even int4, stringu1 name, stringu2 name, string4 name ); SELECT table_name FROM create_hypertable('tenk2','unique2',chunk_time_interval:=1000); INSERT INTO tenk2 SELECT * FROM tenk1; ������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/join_query.sql��������������������������������������������������0000664�0000000�0000000�00000213661�15100345067�0022172�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- these queries are based on the postgres JOIN tests -- and have been adjusted to run on hypertables -- canary for results diff -- this should be the only output of the results diff SELECT setting, current_setting(setting) AS value from (VALUES ('timescaledb.enable_optimizations')) v(setting); -- -- JOIN -- Test JOIN clauses -- CREATE TABLE J1_TBL ( i integer, j integer, t text, ts_j1 timestamptz NOT NULL DEFAULT '2000-01-01' ); CREATE TABLE J2_TBL ( i integer, k integer, ts_j2 timestamptz NOT NULL DEFAULT '2000-01-02' ); SELECT (SELECT table_name FROM create_hypertable(tbl||'_tbl', 'ts_' || tbl)) FROM (VALUES ('j1'),('j2')) v(tbl); INSERT INTO J1_TBL VALUES (1, 4, 'one'); INSERT INTO J1_TBL VALUES (2, 3, 'two'); INSERT INTO J1_TBL VALUES (3, 2, 'three'); INSERT INTO J1_TBL VALUES (4, 1, 'four'); INSERT INTO J1_TBL VALUES (5, 0, 'five'); INSERT INTO J1_TBL VALUES (6, 6, 'six'); INSERT INTO J1_TBL VALUES (7, 7, 'seven'); INSERT INTO J1_TBL VALUES (8, 8, 'eight'); INSERT INTO J1_TBL VALUES (0, NULL, 'zero'); INSERT INTO J1_TBL VALUES (NULL, NULL, 'null'); INSERT INTO J1_TBL VALUES (NULL, 0, 'zero'); INSERT INTO J2_TBL VALUES (1, -1); INSERT INTO J2_TBL VALUES (2, 2); INSERT INTO J2_TBL VALUES (3, -3); INSERT INTO J2_TBL VALUES (2, 4); INSERT INTO J2_TBL VALUES (5, -5); INSERT INTO J2_TBL VALUES (5, -5); INSERT INTO J2_TBL VALUES (0, NULL); INSERT INTO J2_TBL VALUES (NULL, NULL); INSERT INTO J2_TBL VALUES (NULL, 0); -- -- CORRELATION NAMES -- Make sure that table/column aliases are supported -- before diving into more complex join syntax. -- SELECT '' AS "xxx", * FROM J1_TBL AS tx; SELECT '' AS "xxx", * FROM J1_TBL tx; SELECT '' AS "xxx", * FROM J1_TBL AS t1 (a, b, c); SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b, c); SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e); SELECT '' AS "xxx", t1.a, t2.e FROM J1_TBL t1 (a, b, c), J2_TBL t2 (d, e) WHERE t1.a = t2.d; -- -- CROSS JOIN -- Qualifications are not allowed on cross joins, -- which degenerate into a standard unqualified inner join. -- SELECT '' AS "xxx", * FROM J1_TBL CROSS JOIN J2_TBL; -- ambiguous column -- SELECT '' AS "xxx", i, k, t -- FROM J1_TBL CROSS JOIN J2_TBL; -- resolve previous ambiguity by specifying the table name SELECT '' AS "xxx", t1.i, k, t FROM J1_TBL t1 CROSS JOIN J2_TBL t2; SELECT '' AS "xxx", ii, tt, kk FROM (J1_TBL CROSS JOIN J2_TBL) AS tx (ii, jj, tt, ii2, kk); SELECT '' AS "xxx", tx.ii, tx.jj, tx.kk FROM (J1_TBL t1 (a, b, c) CROSS JOIN J2_TBL t2 (d, e)) AS tx (ii, jj, tt, ii2, kk); SELECT '' AS "xxx", * FROM J1_TBL CROSS JOIN J2_TBL a CROSS JOIN J2_TBL b; -- -- -- Inner joins (equi-joins) -- -- -- -- Inner joins (equi-joins) with USING clause -- The USING syntax changes the shape of the resulting table -- by including a column in the USING clause only once in the result. -- -- Inner equi-join on specified column SELECT '' AS "xxx", * FROM J1_TBL INNER JOIN J2_TBL USING (i); -- Same as above, slightly different syntax SELECT '' AS "xxx", * FROM J1_TBL JOIN J2_TBL USING (i); SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, d) USING (a) ORDER BY a, d; SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b, c) JOIN J2_TBL t2 (a, b) USING (b) ORDER BY b, t1.a; -- -- NATURAL JOIN -- Inner equi-join on all columns with the same name -- SELECT '' AS "xxx", * FROM J1_TBL NATURAL JOIN J2_TBL; SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (a, d); SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b, c) NATURAL JOIN J2_TBL t2 (d, a); -- mismatch number of columns -- currently, Postgres will fill in with underlying names SELECT '' AS "xxx", * FROM J1_TBL t1 (a, b) NATURAL JOIN J2_TBL t2 (a); -- -- Inner joins (equi-joins) -- SELECT '' AS "xxx", * FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.i); SELECT '' AS "xxx", * FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i = J2_TBL.k); -- -- Non-equi-joins -- SELECT '' AS "xxx", * FROM J1_TBL JOIN J2_TBL ON (J1_TBL.i <= J2_TBL.k); -- -- Outer joins -- Note that OUTER is a noise word -- SELECT '' AS "xxx", * FROM J1_TBL LEFT OUTER JOIN J2_TBL USING (i) ORDER BY i, k, t; SELECT '' AS "xxx", * FROM J1_TBL LEFT JOIN J2_TBL USING (i) ORDER BY i, k, t; SELECT '' AS "xxx", * FROM J1_TBL RIGHT OUTER JOIN J2_TBL USING (i); SELECT '' AS "xxx", * FROM J1_TBL RIGHT JOIN J2_TBL USING (i); SELECT '' AS "xxx", * FROM J1_TBL FULL OUTER JOIN J2_TBL USING (i) ORDER BY i, k, t; SELECT '' AS "xxx", * FROM J1_TBL FULL JOIN J2_TBL USING (i) ORDER BY i, k, t; SELECT '' AS "xxx", * FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (k = 1); SELECT '' AS "xxx", * FROM J1_TBL LEFT JOIN J2_TBL USING (i) WHERE (i = 1); -- -- semijoin selectivity for <> -- :PREFIX select * from int4_tbl i4, tenk1 a where exists(select * from tenk1 b where a.twothousand = b.twothousand and a.fivethous <> b.fivethous) and i4.f1 = a.tenthous; -- -- More complicated constructs -- -- -- Multiway full join -- CREATE TABLE t1 (name TEXT, n INTEGER, ts_t1 timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE t2 (name TEXT, n INTEGER, ts_t2 timestamptz NOT NULL DEFAULT '2000-01-02'); CREATE TABLE t3 (name TEXT, n INTEGER, ts_t3 timestamptz NOT NULL DEFAULT '2000-01-03'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'ts_' || tbl)) FROM (VALUES ('t1'),('t2'),('t3')) v(tbl); INSERT INTO t1 VALUES ( 'bb', 11 ); INSERT INTO t2 VALUES ( 'bb', 12 ); INSERT INTO t2 VALUES ( 'cc', 22 ); INSERT INTO t2 VALUES ( 'ee', 42 ); INSERT INTO t3 VALUES ( 'bb', 13 ); INSERT INTO t3 VALUES ( 'cc', 23 ); INSERT INTO t3 VALUES ( 'dd', 33 ); SELECT * FROM t1 FULL JOIN t2 USING (name) FULL JOIN t3 USING (name); -- -- Test interactions of join syntax and subqueries -- -- Basic cases (we expect planner to pull up the subquery here) SELECT * FROM (SELECT * FROM t2) as s2 INNER JOIN (SELECT * FROM t3) s3 USING (name); SELECT * FROM (SELECT * FROM t2) as s2 LEFT JOIN (SELECT * FROM t3) s3 USING (name); SELECT * FROM (SELECT * FROM t2) as s2 FULL JOIN (SELECT * FROM t3) s3 USING (name); -- Cases with non-nullable expressions in subquery results; -- make sure these go to null as expected SELECT * FROM (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 NATURAL INNER JOIN (SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3; SELECT * FROM (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 NATURAL LEFT JOIN (SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3; SELECT * FROM (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 NATURAL FULL JOIN (SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3; SELECT * FROM (SELECT name, n as s1_n, 1 as s1_1 FROM t1) as s1 NATURAL INNER JOIN (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 NATURAL INNER JOIN (SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3; SELECT * FROM (SELECT name, n as s1_n, 1 as s1_1 FROM t1) as s1 NATURAL FULL JOIN (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 NATURAL FULL JOIN (SELECT name, n as s3_n, 3 as s3_2 FROM t3) s3; SELECT * FROM (SELECT name, n as s1_n FROM t1) as s1 NATURAL FULL JOIN (SELECT * FROM (SELECT name, n as s2_n FROM t2) as s2 NATURAL FULL JOIN (SELECT name, n as s3_n FROM t3) as s3 ) ss2; SELECT * FROM (SELECT name, n as s1_n FROM t1) as s1 NATURAL FULL JOIN (SELECT * FROM (SELECT name, n as s2_n, 2 as s2_2 FROM t2) as s2 NATURAL FULL JOIN (SELECT name, n as s3_n FROM t3) as s3 ) ss2; -- Test for propagation of nullability constraints into sub-joins create table x (x1 int, x2 int, ts_x timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT table_name FROM create_hypertable('x','ts_x'); insert into x values (1,11); insert into x values (2,22); insert into x values (3,null); insert into x values (4,44); insert into x values (5,null); create table y (y1 int, y2 int, ts_y timestamptz NOT NULL DEFAULT '2000-01-02'); SELECT table_name FROM create_hypertable('y','ts_y'); insert into y values (1,111); insert into y values (2,222); insert into y values (3,333); insert into y values (4,null); select * from x; select * from y; select * from x left join y on (x1 = y1 and x2 is not null); select * from x left join y on (x1 = y1 and y2 is not null); select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1); select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1 and x2 is not null); select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1 and y2 is not null); select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1 and xx2 is not null); -- these should NOT give the same answers as above select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1) where (x2 is not null); select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1) where (y2 is not null); select * from (x left join y on (x1 = y1)) left join x xx(xx1,xx2) on (x1 = xx1) where (xx2 is not null); -- -- regression test: check for bug with propagation of implied equality -- to outside an IN -- select count(*) from tenk1 a where unique1 in (select unique1 from tenk1 b join tenk1 c using (unique1) where b.unique2 = 42); -- -- regression test: check for failure to generate a plan with multiple -- degenerate IN clauses -- select count(*) from tenk1 x where x.unique1 in (select a.f1 from int4_tbl a,float8_tbl b where a.f1=b.f1) and x.unique1 = 0 and x.unique1 in (select aa.f1 from int4_tbl aa,float8_tbl bb where aa.f1=bb.f1); -- try that with GEQO too begin; set geqo = on; set geqo_threshold = 2; select count(*) from tenk1 x where x.unique1 in (select a.f1 from int4_tbl a,float8_tbl b where a.f1=b.f1) and x.unique1 = 0 and x.unique1 in (select aa.f1 from int4_tbl aa,float8_tbl bb where aa.f1=bb.f1); rollback; -- -- regression test: be sure we cope with proven-dummy append rels -- :PREFIX select aa, bb, unique1, unique1 from tenk1 right join b on aa::int = unique1 where bb < bb and bb is null; -- -- regression test: check handling of empty-FROM subquery underneath outer join -- :PREFIX select * from int8_tbl i1 left join (int8_tbl i2 join (select 123 as x) ss on i2.q1 = x) on i1.q2 = i2.q2 order by 1, 2; -- -- regression test: check a case where join_clause_is_movable_into() gives -- an imprecise result, causing an assertion failure -- select count(*) from (select t3.tenthous as x1, coalesce(t1.stringu1, t2.stringu1) as x2 from tenk1 t1 left join tenk1 t2 on t1.unique1 = t2.unique1 join tenk1 t3 on t1.unique2 = t3.unique2) ss, tenk1 t4, tenk1 t5 where t4.thousand = t5.unique1 and ss.x1 = t4.tenthous and ss.x2 = t5.stringu1; -- -- regression test: check a case where we formerly missed including an EC -- enforcement clause because it was expected to be handled at scan level -- :PREFIX select a.f1, b.f1, t.thousand, t.tenthous from tenk1 t, (select sum(f1)+1 as f1 from int4_tbl i4a) a, (select sum(f1) as f1 from int4_tbl i4b) b where b.f1 = t.thousand and a.f1 = b.f1 and (a.f1+b.f1+999) = t.tenthous; -- -- check a case where we formerly got confused by conflicting sort orders -- in redundant merge join path keys -- :PREFIX select * from j1_tbl full join (select * from j2_tbl order by j2_tbl.i desc, j2_tbl.k asc) j2_tbl on j1_tbl.i = j2_tbl.i and j1_tbl.i = j2_tbl.k; -- -- a different check for handling of redundant sort keys in merge joins -- :PREFIX select count(*) from (select * from tenk1 x order by x.thousand, x.twothousand, x.fivethous) x left join (select * from tenk1 y order by y.unique2) y on x.thousand = y.unique2 and x.twothousand = y.hundred and x.fivethous = y.unique2; -- -- Clean up -- DROP TABLE t1; DROP TABLE t2; DROP TABLE t3; DROP TABLE J1_TBL; DROP TABLE J2_TBL; DROP TABLE x; DROP TABLE y; -- Both DELETE and UPDATE allow the specification of additional tables -- to "join" against to determine which rows should be modified. CREATE TABLE t1 (a int, b int, ts_t1 timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE t2 (a int, b int, ts_t2 timestamptz NOT NULL DEFAULT '2000-01-02'); CREATE TABLE t3 (x int, y int, ts_t3 timestamptz NOT NULL DEFAULT '2000-01-03'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'ts_' || tbl)) FROM (VALUES ('t1'),('t2'),('t3')) v(tbl); INSERT INTO t1 VALUES (5, 10); INSERT INTO t1 VALUES (15, 20); INSERT INTO t1 VALUES (100, 100); INSERT INTO t1 VALUES (200, 1000); INSERT INTO t2 VALUES (200, 2000); INSERT INTO t3 VALUES (5, 20); INSERT INTO t3 VALUES (6, 7); INSERT INTO t3 VALUES (7, 8); INSERT INTO t3 VALUES (500, 100); DELETE FROM t3 USING t1 table1 WHERE t3.x = table1.a; SELECT * FROM t3; DELETE FROM t3 USING t1 JOIN t2 USING (a) WHERE t3.x > t1.a; SELECT * FROM t3; DELETE FROM t3 USING t3 t3_other WHERE t3.x = t3_other.x AND t3.y = t3_other.y; SELECT * FROM t3; -- Test matching of column name with wrong alias -- select t1.x from t1 join t3 on (t1.a = t3.x); DROP TABLE t1; DROP TABLE t2; DROP TABLE t3; -- -- regression test for 8.1 merge right join bug -- CREATE TABLE tt1 ( tt1_id int4, joincol int4, ts_tt1 timestamptz NOT NULL DEFAULT '2000-01-01' ); SELECT table_name FROM create_hypertable('tt1','ts_tt1'); INSERT INTO tt1 VALUES (1, 11); INSERT INTO tt1 VALUES (2, NULL); CREATE TABLE tt2 ( tt2_id int4, joincol int4, ts_tt2 timestamptz NOT NULL DEFAULT '2000-01-02' ); SELECT table_name FROM create_hypertable('tt2','ts_tt2'); INSERT INTO tt2 VALUES (21, 11); INSERT INTO tt2 VALUES (22, 11); set enable_hashjoin to off; set enable_nestloop to off; -- these should give the same results select tt1.*, tt2.* from tt1 left join tt2 on tt1.joincol = tt2.joincol; select tt1.*, tt2.* from tt2 right join tt1 on tt1.joincol = tt2.joincol; reset enable_hashjoin; reset enable_nestloop; DROP TABLE tt1; DROP TABLE tt2; -- -- regression test for bug #13908 (hash join with skew tuples & nbatch increase) -- set work_mem to '64kB'; set enable_mergejoin to off; :PREFIX select count(*) from tenk1 a, tenk1 b where a.hundred = b.thousand and (b.fivethous % 10) < 10; reset work_mem; reset enable_mergejoin; -- -- regression test for 8.2 bug with improper re-ordering of left joins -- create table tt3(f1 int, f2 text); SELECT table_name FROM create_hypertable('tt3','f1',chunk_time_interval:=2000); insert into tt3 select x, repeat('xyzzy', 100) from generate_series(1,10000) x; create index tt3i on tt3(f1); analyze tt3; create table tt4(f1 int); SELECT table_name FROM create_hypertable('tt4','f1',chunk_time_interval:=2000); insert into tt4 values (0),(1),(9999); analyze tt4; SELECT a.f1 FROM tt4 a LEFT JOIN ( SELECT b.f1 FROM tt3 b LEFT JOIN tt3 c ON (b.f1 = c.f1) WHERE c.f1 IS NULL ) AS d ON (a.f1 = d.f1) WHERE d.f1 IS NULL; DROP TABLE tt3; DROP TABLE tt4; -- -- regression test for proper handling of outer joins within antijoins -- create table tt4x(c1 int, c2 int, c3 int); SELECT table_name FROM create_hypertable('tt4x','c1',chunk_time_interval:=2000); :PREFIX select * from tt4x t1 where not exists ( select 1 from tt4x t2 left join tt4x t3 on t2.c3 = t3.c1 left join ( select t5.c1 as c1 from tt4x t4 left join tt4x t5 on t4.c2 = t5.c1 ) a1 on t3.c2 = a1.c1 where t1.c1 = t2.c2 ); DROP TABLE tt4x; -- -- regression test for problems of the sort depicted in bug #3494 -- create table tt5(f1 int, f2 int); create table tt6(f1 int, f2 int); SELECT table_name FROM create_hypertable('tt5','f1',chunk_time_interval:=2000); SELECT table_name FROM create_hypertable('tt6','f1',chunk_time_interval:=2000); insert into tt5 values(1, 10); insert into tt5 values(1, 11); insert into tt6 values(1, 9); insert into tt6 values(1, 2); insert into tt6 values(2, 9); select * from tt5,tt6 where tt5.f1 = tt6.f1 and tt5.f1 = tt5.f2 - tt6.f2; DROP TABLE tt5; DROP TABLE tt6; -- -- regression test for problems of the sort depicted in bug #3588 -- create table xx (pkxx int); create table yy (pkyy int, pkxx int); select table_name FROM create_hypertable('xx','pkxx',chunk_time_interval:=2000); select table_name FROM create_hypertable('yy','pkyy',chunk_time_interval:=2000); insert into xx values (1); insert into xx values (2); insert into xx values (3); insert into yy values (101, 1); insert into yy values (201, 2); insert into yy values (301, NULL); select yy.pkyy as yy_pkyy, yy.pkxx as yy_pkxx, yya.pkyy as yya_pkyy, xxa.pkxx as xxa_pkxx, xxb.pkxx as xxb_pkxx from yy left join (SELECT * FROM yy where pkyy = 101) as yya ON yy.pkyy = yya.pkyy left join xx xxa on yya.pkxx = xxa.pkxx left join xx xxb on coalesce (xxa.pkxx, 1) = xxb.pkxx; DROP TABLE xx; DROP TABLE yy; -- -- regression test for improper pushing of constants across outer-join clauses -- (as seen in early 8.2.x releases) -- create table zt1 (f1 int primary key); create table zt2 (f2 int primary key); create table zt3 (f3 int primary key); select table_name FROM create_hypertable('zt1','f1',chunk_time_interval:=2000); select table_name FROM create_hypertable('zt2','f2',chunk_time_interval:=2000); select table_name FROM create_hypertable('zt3','f3',chunk_time_interval:=2000); insert into zt1 values(53); insert into zt2 values(53); select * from zt2 left join zt3 on (f2 = f3) left join zt1 on (f3 = f1) where f2 = 53; create temp view zv1 as select *,'dummy'::text AS junk from zt1; select * from zt2 left join zt3 on (f2 = f3) left join zv1 on (f3 = f1) where f2 = 53; drop table zt1 cascade; drop table zt2; drop table zt3; -- -- regression test for improper extraction of OR indexqual conditions -- (as seen in early 8.3.x releases) -- select a.unique2, a.ten, b.tenthous, b.unique2, b.hundred from tenk1 a left join tenk1 b on a.unique2 = b.tenthous where a.unique1 = 42 and ((b.unique2 is null and a.ten = 2) or b.hundred = 3); -- -- test proper positioning of one-time quals in EXISTS (8.4devel bug) -- prepare foo(bool) as select count(*) from tenk1 a left join tenk1 b on (a.unique2 = b.unique1 and exists (select 1 from tenk1 c where c.thousand = b.unique2 and $1)); execute foo(true); execute foo(false); deallocate foo; -- -- test for sane behavior with noncanonical merge clauses, per bug #4926 -- begin; set enable_mergejoin = 1; set enable_hashjoin = 0; set enable_nestloop = 0; create temp table a (i integer); create temp table b (x integer, y integer); select * from a left join b on i = x and i = y and x = i; rollback; -- -- test handling of merge clauses using record_ops -- begin; create type mycomptype as (id int, v bigint); create temp table tidv (idv mycomptype); create index on tidv (idv); :PREFIX select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; set enable_mergejoin = 0; :PREFIX select a.idv, b.idv from tidv a, tidv b where a.idv = b.idv; rollback; -- -- test NULL behavior of whole-row Vars, per bug #5025 -- select t1.q2, count(t2.*) from int8_tbl t1 left join int8_tbl t2 on (t1.q2 = t2.q1) group by t1.q2 order by 1; select t1.q2, count(t2.*) from int8_tbl t1 left join (select * from int8_tbl) t2 on (t1.q2 = t2.q1) group by t1.q2 order by 1; select t1.q2, count(t2.*) from int8_tbl t1 left join (select * from int8_tbl offset 0) t2 on (t1.q2 = t2.q1) group by t1.q2 order by 1; select t1.q2, count(t2.*) from int8_tbl t1 left join (select q1, case when q2=1 then 1 else q2 end as q2 from int8_tbl) t2 on (t1.q2 = t2.q1) group by t1.q2 order by 1; -- -- test incorrect failure to NULL pulled-up subexpressions -- begin; create temp table a ( code char not null, constraint a_pk primary key (code) ); create temp table b ( a char not null, num integer not null, constraint b_pk primary key (a, num) ); create temp table c ( name char not null, a char, constraint c_pk primary key (name) ); insert into a (code) values ('p'); insert into a (code) values ('q'); insert into b (a, num) values ('p', 1); insert into b (a, num) values ('p', 2); insert into c (name, a) values ('A', 'p'); insert into c (name, a) values ('B', 'q'); insert into c (name, a) values ('C', null); select c.name, ss.code, ss.b_cnt, ss.const from c left join (select a.code, coalesce(b_grp.cnt, 0) as b_cnt, -1 as const from a left join (select count(1) as cnt, b.a from b group by b.a) as b_grp on a.code = b_grp.a ) as ss on (c.a = ss.code) order by c.name; rollback; -- -- test incorrect handling of placeholders that only appear in targetlists, -- per bug #6154 -- SELECT * FROM ( SELECT 1 as key1 ) sub1 LEFT JOIN ( SELECT sub3.key3, sub4.value2, COALESCE(sub4.value2, 66) as value3 FROM ( SELECT 1 as key3 ) sub3 LEFT JOIN ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM ( SELECT 1 as key5 ) sub5 LEFT JOIN ( SELECT 2 as key6, 42 as value1 ) sub6 ON sub5.key5 = sub6.key6 ) sub4 ON sub4.key5 = sub3.key3 ) sub2 ON sub1.key1 = sub2.key3; -- test the path using join aliases, too SELECT * FROM ( SELECT 1 as key1 ) sub1 LEFT JOIN ( SELECT sub3.key3, value2, COALESCE(value2, 66) as value3 FROM ( SELECT 1 as key3 ) sub3 LEFT JOIN ( SELECT sub5.key5, COALESCE(sub6.value1, 1) as value2 FROM ( SELECT 1 as key5 ) sub5 LEFT JOIN ( SELECT 2 as key6, 42 as value1 ) sub6 ON sub5.key5 = sub6.key6 ) sub4 ON sub4.key5 = sub3.key3 ) sub2 ON sub1.key1 = sub2.key3; -- -- test case where a PlaceHolderVar is used as a nestloop parameter -- :PREFIX SELECT qq, unique1 FROM ( SELECT COALESCE(q1, 0) AS qq FROM int8_tbl a ) AS ss1 FULL OUTER JOIN ( SELECT COALESCE(q2, -1) AS qq FROM int8_tbl b ) AS ss2 USING (qq) INNER JOIN tenk1 c ON qq = unique2; -- -- nested nestloops can require nested PlaceHolderVars -- create table nt1 ( id int primary key, a1 boolean, a2 boolean ); create table nt2 ( id int primary key, nt1_id int, b1 boolean, b2 boolean -- foreign key (nt1_id) references nt1(id) ); create table nt3 ( id int primary key, nt2_id int, c1 boolean -- foreign key (nt2_id) references nt2(id) ); select (select table_name from create_hypertable(tbl,'id',chunk_time_interval:=1000)) from (VALUES ('nt1'),('nt2'),('nt3')) v(tbl); insert into nt1 values (1,true,true); insert into nt1 values (2,true,false); insert into nt1 values (3,false,false); insert into nt2 values (1,1,true,true); insert into nt2 values (2,2,true,false); insert into nt2 values (3,3,false,false); insert into nt3 values (1,1,true); insert into nt3 values (2,2,false); insert into nt3 values (3,3,true); :PREFIX select nt3.id from nt3 as nt3 left join (select nt2.*, (nt2.b1 and ss1.a3) AS b3 from nt2 as nt2 left join (select nt1.*, (nt1.id is not null) as a3 from nt1) as ss1 on ss1.id = nt2.nt1_id ) as ss2 on ss2.id = nt3.nt2_id where nt3.id = 1 and ss2.b3; drop table nt1; drop table nt2; drop table nt3; -- -- test case where a PlaceHolderVar is propagated into a subquery -- :PREFIX select * from int8_tbl t1 left join (select q1 as x, 42 as y from int8_tbl t2) ss on t1.q2 = ss.x where 1 = (select 1 from int8_tbl t3 where ss.y is not null limit 1) order by 1,2; -- -- test the corner cases FULL JOIN ON TRUE and FULL JOIN ON FALSE -- select * from int4_tbl a full join int4_tbl b on true; select * from int4_tbl a full join int4_tbl b on false; -- -- test for ability to use a cartesian join when necessary -- :PREFIX select * from tenk1 join int4_tbl on f1 = twothousand, int4(sin(1)) q1, int4(sin(0)) q2 where q1 = thousand or q2 = thousand; :PREFIX select * from tenk1 join int4_tbl on f1 = twothousand, int4(sin(1)) q1, int4(sin(0)) q2 where thousand = (q1 + q2); -- -- test ability to generate a suitable plan for a star-schema query -- :PREFIX select * from tenk1, int8_tbl a, int8_tbl b where thousand = a.q1 and tenthous = b.q1 and a.q2 = 1 and b.q2 = 2; -- -- test a corner case in which we shouldn't apply the star-schema optimization -- :PREFIX select t1.unique2, t1.stringu1, t2.unique1, t2.stringu2 from tenk1 t1 inner join int4_tbl i1 left join (select v1.x2, v2.y1, 11 AS d1 from (values(1,0)) v1(x1,x2) left join (values(3,1)) v2(y1,y2) on v1.x1 = v2.y2) subq1 on (i1.f1 = subq1.x2) on (t1.unique2 = subq1.d1) left join tenk1 t2 on (subq1.y1 = t2.unique1) where t1.unique2 < 42 and t1.stringu1 > t2.stringu2; -- variant that isn't quite a star-schema case :PREFIX select ss1.d1 from tenk1 as t1 inner join tenk1 as t2 on t1.tenthous = t2.ten inner join int8_tbl as i8 left join int4_tbl as i4 inner join (select 64::information_schema.cardinal_number as d1 from tenk1 t3, lateral (select abs(t3.unique1) + random()) ss0(x) where t3.fivethous < 0) as ss1 on i4.f1 = ss1.d1 on i8.q1 = i4.f1 on t1.tenthous = ss1.d1 where t1.unique1 < i4.f1; -- -- test extraction of restriction OR clauses from join OR clause -- (we used to only do this for indexable clauses) -- :PREFIX select * from tenk1 a join tenk1 b on (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.hundred = 4) ORDER BY a.unique2,b.unique2; :PREFIX select * from tenk1 a join tenk1 b on (a.unique1 = 1 and b.unique1 = 2) or (a.unique2 = 3 and b.ten = 4) ORDER BY a.unique2,b.unique2; :PREFIX select * from tenk1 a join tenk1 b on (a.unique1 = 1 and b.unique1 = 2) or ((a.unique2 = 3 or a.unique2 = 7) and b.hundred = 4) ORDER BY a.unique2,b.unique2; -- -- test placement of movable quals in a parameterized join tree -- :PREFIX select * from tenk1 t1 left join (tenk1 t2 join tenk1 t3 on t2.thousand = t3.unique2) on t1.hundred = t2.hundred and t1.ten = t3.ten where t1.unique1 = 1 ORDER BY t1,t2,t3; :PREFIX select * from tenk1 t1 left join (tenk1 t2 join tenk1 t3 on t2.thousand = t3.unique2) on t1.hundred = t2.hundred and t1.ten + t2.ten = t3.ten where t1.unique1 = 1; :PREFIX select count(*) from tenk1 a join tenk1 b on a.unique1 = b.unique2 left join tenk1 c on a.unique2 = b.unique1 and c.thousand = a.thousand join int4_tbl on b.thousand = f1; :PREFIX select b.unique1 from tenk1 a join tenk1 b on a.unique1 = b.unique2 left join tenk1 c on b.unique1 = 42 and c.thousand = a.thousand join int4_tbl i1 on b.thousand = f1 right join int4_tbl i2 on i2.f1 = b.tenthous order by 1; :PREFIX select * from ( select unique1, q1, coalesce(unique1, -1) + q1 as fault from int8_tbl left join tenk1 on (q2 = unique2) ) ss where fault = 122 order by fault; :PREFIX select * from (values (1, array[10,20]), (2, array[20,30])) as v1(v1x,v1ys) left join (values (1, 10), (2, 20)) as v2(v2x,v2y) on v2x = v1x left join unnest(v1ys) as u1(u1y) on u1y = v2y; -- -- test handling of potential equivalence clauses above outer joins -- :PREFIX select q1, unique2, thousand, hundred from int8_tbl a left join tenk1 b on q1 = unique2 where coalesce(thousand,123) = q1 and q1 = coalesce(hundred,123); :PREFIX select f1, unique2, case when unique2 is null then f1 else 0 end from int4_tbl a left join tenk1 b on f1 = unique2 where (case when unique2 is null then f1 else 0 end) = 0; -- -- another case with equivalence clauses above outer joins (bug #8591) -- :PREFIX select a.unique1, b.unique1, c.unique1, coalesce(b.twothousand, a.twothousand) from tenk1 a left join tenk1 b on b.thousand = a.unique1 left join tenk1 c on c.unique2 = coalesce(b.twothousand, a.twothousand) where a.unique2 < 10 and coalesce(b.twothousand, a.twothousand) = 44; -- -- check handling of join aliases when flattening multiple levels of subquery -- :PREFIX select foo1.join_key as foo1_id, foo3.join_key AS foo3_id, bug_field from (values (0),(1)) foo1(join_key) left join (select join_key, bug_field from (select ss1.join_key, ss1.bug_field from (select f1 as join_key, 666 as bug_field from int4_tbl i1) ss1 ) foo2 left join (select unique2 as join_key from tenk1 i2) ss2 using (join_key) ) foo3 using (join_key); -- -- test successful handling of nested outer joins with degenerate join quals -- :PREFIX select t1.* from text_tbl t1 left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 left join int8_tbl i8 left join (select *, null::int as d2 from int8_tbl i8b2) b2 on (i8.q1 = b2.q1) on (b2.d2 = b1.q2) on (t1.f1 = b1.d1) left join int4_tbl i4 on (i8.q2 = i4.f1); :PREFIX select t1.* from text_tbl t1 left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 left join int8_tbl i8 left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2) b2 on (i8.q1 = b2.q1) on (b2.d2 = b1.q2) on (t1.f1 = b1.d1) left join int4_tbl i4 on (i8.q2 = i4.f1); :PREFIX select t1.* from text_tbl t1 left join (select *, '***'::text as d1 from int8_tbl i8b1) b1 left join int8_tbl i8 left join (select *, null::int as d2 from int8_tbl i8b2, int4_tbl i4b2 where q1 = f1) b2 on (i8.q1 = b2.q1) on (b2.d2 = b1.q2) on (t1.f1 = b1.d1) left join int4_tbl i4 on (i8.q2 = i4.f1); :PREFIX select * from text_tbl t1 inner join int8_tbl i8 on i8.q2 = 456 right join text_tbl t2 on t1.f1 = 'doh!' left join int4_tbl i4 on i8.q1 = i4.f1; -- -- test for appropriate join order in the presence of lateral references -- :PREFIX select * from text_tbl t1 left join int8_tbl i8 on i8.q2 = 123, lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss where t1.f1 = ss.f1; :PREFIX select * from text_tbl t1 left join int8_tbl i8 on i8.q2 = 123, lateral (select i8.q1, t2.f1 from text_tbl t2 limit 1) as ss1, lateral (select ss1.* from text_tbl t3 limit 1) as ss2 where t1.f1 = ss2.f1; :PREFIX select 1 from text_tbl as tt1 inner join text_tbl as tt2 on (tt1.f1 = 'foo') left join text_tbl as tt3 on (tt3.f1 = 'foo') left join text_tbl as tt4 on (tt3.f1 = tt4.f1), lateral (select tt4.f1 as c0 from text_tbl as tt5 limit 1) as ss1 where tt1.f1 = ss1.c0; -- -- check a case in which a PlaceHolderVar forces join order -- :PREFIX select ss2.* from int4_tbl i41 left join int8_tbl i8 join (select i42.f1 as c1, i43.f1 as c2, 42 as c3 from int4_tbl i42, int4_tbl i43) ss1 on i8.q1 = ss1.c2 on i41.f1 = ss1.c1, lateral (select i41.*, i8.*, ss1.* from text_tbl limit 1) ss2 where ss1.c2 = 0; -- -- test successful handling of full join underneath left join (bug #14105) -- :PREFIX select * from (select 1 as id) as xx left join (tenk1 as a1 full join (select 1 as id) as yy on (a1.unique1 = yy.id)) on (xx.id = coalesce(yy.id)); -- -- test ability to push constants through outer join clauses -- :PREFIX select * from int4_tbl a left join tenk1 b on f1 = unique2 where f1 = 0; :PREFIX select * from tenk1 a full join tenk1 b using(unique2) where unique2 = 42; -- -- test that quals attached to an outer join have correct semantics, -- specifically that they don't re-use expressions computed below the join; -- we force a mergejoin so that coalesce(b.q1, 1) appears as a join input -- set enable_hashjoin to off; set enable_nestloop to off; :PREFIX select a.q2, b.q1 from int8_tbl a left join int8_tbl b on a.q2 = coalesce(b.q1, 1) where coalesce(b.q1, 1) > 0; reset enable_hashjoin; reset enable_nestloop; -- -- test join removal -- begin; CREATE TEMP TABLE a (id int PRIMARY KEY, b_id int); CREATE TEMP TABLE b (id int PRIMARY KEY, c_id int); CREATE TEMP TABLE c (id int PRIMARY KEY); CREATE TEMP TABLE d (a int, b int); INSERT INTO a VALUES (0, 0), (1, NULL); INSERT INTO b VALUES (0, 0), (1, NULL); INSERT INTO c VALUES (0), (1); INSERT INTO d VALUES (1,3), (2,2), (3,1); -- all three cases should be optimizable into a simple seqscan :PREFIX SELECT a.* FROM a LEFT JOIN b ON a.b_id = b.id; :PREFIX SELECT b.* FROM b LEFT JOIN c ON b.c_id = c.id; :PREFIX SELECT a.* FROM a LEFT JOIN (b left join c on b.c_id = c.id) ON (a.b_id = b.id); -- check optimization of outer join within another special join :PREFIX select id from a where id in ( select b.id from b left join c on b.id = c.id ); -- check that join removal works for a left join when joining a subquery -- that is guaranteed to be unique by its GROUP BY clause :PREFIX select d.* from d left join (select * from b group by b.id, b.c_id) s on d.a = s.id and d.b = s.c_id; -- similarly, but keying off a DISTINCT clause :PREFIX select d.* from d left join (select distinct * from b) s on d.a = s.id and d.b = s.c_id; -- join removal is not possible when the GROUP BY contains a column that is -- not in the join condition. (Note: as of 9.6, we notice that b.id is a -- primary key and so drop b.c_id from the GROUP BY of the resulting plan; -- but this happens too late for join removal in the outer plan level.) :PREFIX select d.* from d left join (select * from b group by b.id, b.c_id) s on d.a = s.id; -- similarly, but keying off a DISTINCT clause :PREFIX select d.* from d left join (select distinct * from b) s on d.a = s.id; -- check join removal works when uniqueness of the join condition is enforced -- by a UNION :PREFIX select d.* from d left join (select id from a union select id from b) s on d.a = s.id; -- check join removal with a cross-type comparison operator :PREFIX select i8.* from int8_tbl i8 left join (select f1 from int4_tbl group by f1) i4 on i8.q1 = i4.f1; -- check join removal with lateral references :PREFIX select 1 from (select a.id FROM a left join b on a.b_id = b.id) q, lateral generate_series(1, q.id) gs(i) where q.id = gs.i; rollback; create table parent (k int primary key, pd int); create table child (k int unique, cd int); select table_name from create_hypertable('parent','k',chunk_time_interval:=1000); select table_name from create_hypertable('child','k',chunk_time_interval:=1000); insert into parent values (1, 10), (2, 20), (3, 30); insert into child values (1, 100), (4, 400); -- this case is optimizable select p.* from parent p left join child c on (p.k = c.k); :PREFIX select p.* from parent p left join child c on (p.k = c.k); -- this case is not select p.*, linked from parent p left join (select c.*, true as linked from child c) as ss on (p.k = ss.k); :PREFIX select p.*, linked from parent p left join (select c.*, true as linked from child c) as ss on (p.k = ss.k); -- check for a 9.0rc1 bug: join removal breaks pseudoconstant qual handling select p.* from parent p left join child c on (p.k = c.k) where p.k = 1 and p.k = 2; :PREFIX select p.* from parent p left join child c on (p.k = c.k) where p.k = 1 and p.k = 2; select p.* from (parent p left join child c on (p.k = c.k)) join parent x on p.k = x.k where p.k = 1 and p.k = 2; :PREFIX select p.* from (parent p left join child c on (p.k = c.k)) join parent x on p.k = x.k where p.k = 1 and p.k = 2; drop table parent; drop table child; -- bug 5255: this is not optimizable by join removal begin; CREATE TEMP TABLE a (id int PRIMARY KEY); CREATE TEMP TABLE b (id int PRIMARY KEY, a_id int); INSERT INTO a VALUES (0), (1); INSERT INTO b VALUES (0, 0), (1, NULL); SELECT * FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); SELECT b.* FROM b LEFT JOIN a ON (b.a_id = a.id) WHERE (a.id IS NULL OR a.id > 0); rollback; -- another join removal bug: this is not optimizable, either begin; create temp table innertab (id int8 primary key, dat1 int8); insert into innertab values(123, 42); SELECT * FROM (SELECT 1 AS x) ss1 LEFT JOIN (SELECT q1, q2, COALESCE(dat1, q1) AS y FROM int8_tbl LEFT JOIN innertab ON q2 = id) ss2 ON true; rollback; -- another join removal bug: we must clean up correctly when removing a PHV begin; create temp table uniquetbl (f1 text unique); :PREFIX select t1.* from uniquetbl as t1 left join (select *, '***'::text as d1 from uniquetbl) t2 on t1.f1 = t2.f1 left join uniquetbl t3 on t2.d1 = t3.f1; :PREFIX select t0.* from text_tbl t0 left join (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, t1.stringu2 from tenk1 t1 join int4_tbl i4 ON i4.f1 = t1.unique2 left join uniquetbl u1 ON u1.f1 = t1.string4) ss on t0.f1 = ss.case1 where ss.stringu2 !~* ss.case1; select t0.* from text_tbl t0 left join (select case t1.ten when 0 then 'doh!'::text else null::text end as case1, t1.stringu2 from tenk1 t1 join int4_tbl i4 ON i4.f1 = t1.unique2 left join uniquetbl u1 ON u1.f1 = t1.string4) ss on t0.f1 = ss.case1 where ss.stringu2 !~* ss.case1; rollback; -- bug #8444: we've historically allowed duplicate aliases within aliased JOINs -- select * from -- int8_tbl x join (int4_tbl x cross join int4_tbl y) j on q1 = f1; -- error -- select * from -- int8_tbl x join (int4_tbl x cross join int4_tbl y) j on q1 = y.f1; -- error select * from int8_tbl x join (int4_tbl x cross join int4_tbl y(ff)) j on q1 = f1; -- ok -- -- Test hints given on incorrect column references are useful -- -- select t1.uunique1 from -- tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, prefer "t1" suggestion -- select t2.uunique1 from -- tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, prefer "t2" suggestion -- select uunique1 from -- tenk1 t1 join tenk2 t2 on t1.two = t2.two; -- error, suggest both at once -- -- Take care to reference the correct RTE -- -- select atts.relid::regclass, s.* from pg_stats s join -- pg_attribute a on s.attname = a.attname and s.tablename = -- a.attrelid::regclass::text join (select unnest(indkey) attnum, -- indexrelid from pg_index i) atts on atts.attnum = a.attnum where -- schemaname != 'pg_catalog'; -- -- Test LATERAL -- select unique2, x.* from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; :PREFIX select unique2, x.* from tenk1 a, lateral (select * from int4_tbl b where f1 = a.unique1) x; select unique2, x.* from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss; :PREFIX select unique2, x.* from int4_tbl x, lateral (select unique2 from tenk1 where f1 = unique1) ss; :PREFIX select unique2, x.* from int4_tbl x cross join lateral (select unique2 from tenk1 where f1 = unique1) ss; select unique2, x.* from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; :PREFIX select unique2, x.* from int4_tbl x left join lateral (select unique1, unique2 from tenk1 where f1 = unique1) ss on true; -- check scoping of lateral versus parent references -- the first of these should return int8_tbl.q2, the second int8_tbl.q1 select *, (select r from (select q1 as q2) x, (select q2 as r) y) from int8_tbl; select *, (select r from (select q1 as q2) x, lateral (select q2 as r) y) from int8_tbl; -- lateral with function in FROM select count(*) from tenk1 a, lateral generate_series(1,two) g; :PREFIX select count(*) from tenk1 a, lateral generate_series(1,two) g; :PREFIX select count(*) from tenk1 a cross join lateral generate_series(1,two) g; -- don't need the explicit LATERAL keyword for functions :PREFIX select count(*) from tenk1 a, generate_series(1,two) g; -- lateral with UNION ALL subselect :PREFIX select * from generate_series(100,200) g, lateral (select * from int8_tbl a where g = q1 union all select * from int8_tbl b where g = q2) ss; select * from generate_series(100,200) g, lateral (select * from int8_tbl a where g = q1 union all select * from int8_tbl b where g = q2) ss; -- lateral with VALUES :PREFIX select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; -- lateral with VALUES, no flattening possible :PREFIX select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; select count(*) from tenk1 a, tenk1 b join lateral (values(a.unique1),(-1)) ss(x) on b.unique2 = ss.x; -- lateral injecting a strange outer join condition :PREFIX select * from int8_tbl a, int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) on x.q2 = ss.z order by a.q1, a.q2, x.q1, x.q2, ss.z; select * from int8_tbl a, int8_tbl x left join lateral (select a.q1 from int4_tbl y) ss(z) on x.q2 = ss.z order by a.q1, a.q2, x.q1, x.q2, ss.z; -- lateral reference to a join alias variable select * from (select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, lateral (select x) ss2(y); select * from (select f1 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1, lateral (values(x)) ss2(y); select * from ((select f1/2 as x from int4_tbl) ss1 join int4_tbl i4 on x = f1) j, lateral (select x) ss2(y); -- lateral references requiring pullup select * from (values(1)) x(lb), lateral generate_series(lb,4) x4; select * from (select f1/1000000000 from int4_tbl) x(lb), lateral generate_series(lb,4) x4; select * from (values(1)) x(lb), lateral (values(lb)) y(lbcopy); select * from (values(1)) x(lb), lateral (select lb from int4_tbl) y(lbcopy); select * from int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, lateral (values(x.q1,y.q1,y.q2)) v(xq1,yq1,yq2); select * from int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); select x.* from int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1, lateral (select x.q1,y.q1,y.q2) v(xq1,yq1,yq2); select v.* from (int8_tbl x left join (select q1,coalesce(q2,0) q2 from int8_tbl) y on x.q2 = y.q1) left join int4_tbl z on z.f1 = x.q2, lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); select v.* from (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) left join int4_tbl z on z.f1 = x.q2, lateral (select x.q1,y.q1 union all select x.q2,y.q2) v(vx,vy); create temp table dual(); insert into dual default values; analyze dual; select v.* from (int8_tbl x left join (select q1,(select coalesce(q2,0)) q2 from int8_tbl) y on x.q2 = y.q1) left join int4_tbl z on z.f1 = x.q2, lateral (select x.q1,y.q1 from dual union all select x.q2,y.q2 from dual) v(vx,vy); drop table dual; :PREFIX select * from int8_tbl a left join lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; select * from int8_tbl a left join lateral (select *, a.q2 as x from int8_tbl b) ss on a.q2 = ss.q1; :PREFIX select * from int8_tbl a left join lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; select * from int8_tbl a left join lateral (select *, coalesce(a.q2, 42) as x from int8_tbl b) ss on a.q2 = ss.q1; -- lateral can result in join conditions appearing below their -- real semantic level :PREFIX select * from int4_tbl i left join lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; select * from int4_tbl i left join lateral (select * from int2_tbl j where i.f1 = j.f1) k on true; :PREFIX select * from int4_tbl i left join lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; select * from int4_tbl i left join lateral (select coalesce(i) from int2_tbl j where i.f1 = j.f1) k on true; :PREFIX select * from int4_tbl a, lateral ( select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) ) ss; select * from int4_tbl a, lateral ( select * from int4_tbl b left join int8_tbl c on (b.f1 = q1 and a.f1 = q2) ) ss; -- lateral reference in a PlaceHolderVar evaluated at join level :PREFIX select * from int8_tbl a left join lateral (select b.q1 as bq1, c.q1 as cq1, least(a.q1,b.q1,c.q1) from int8_tbl b cross join int8_tbl c) ss on a.q2 = ss.bq1; select * from int8_tbl a left join lateral (select b.q1 as bq1, c.q1 as cq1, least(a.q1,b.q1,c.q1) from int8_tbl b cross join int8_tbl c) ss on a.q2 = ss.bq1; -- case requiring nested PlaceHolderVars :PREFIX select * from int8_tbl c left join ( int8_tbl a left join (select q1, coalesce(q2,42) as x from int8_tbl b) ss1 on a.q2 = ss1.q1 cross join lateral (select q1, coalesce(ss1.x,q2) as y from int8_tbl d) ss2 ) on c.q2 = ss2.q1, lateral (select ss2.y offset 0) ss3; -- case that breaks the old ph_may_need optimization :PREFIX select c.*,a.*,ss1.q1,ss2.q1,ss3.* from int8_tbl c left join ( int8_tbl a left join (select q1, coalesce(q2,f1) as x from int8_tbl b, int4_tbl b2 where q1 < f1) ss1 on a.q2 = ss1.q1 cross join lateral (select q1, coalesce(ss1.x,q2) as y from int8_tbl d) ss2 ) on c.q2 = ss2.q1, lateral (select * from int4_tbl i where ss2.y > f1) ss3; -- check processing of postponed quals (bug #9041) :PREFIX select * from (select 1 as x offset 0) x cross join (select 2 as y offset 0) y left join lateral ( select * from (select 3 as z offset 0) z where z.z = x.x ) zz on zz.z = y.y; -- check dummy rels with lateral references (bug #15694) :PREFIX select * from int8_tbl i8 left join lateral (select *, i8.q2 from int4_tbl where false) ss on true; :PREFIX select * from int8_tbl i8 left join lateral (select *, i8.q2 from int4_tbl i1, int4_tbl i2 where false) ss on true; -- check handling of nested appendrels inside LATERAL select * from ((select 2 as v) union all (select 3 as v)) as q1 cross join lateral ((select * from ((select 4 as v) union all (select 5 as v)) as q3) union all (select q1.v) ) as q2; -- check we don't try to do a unique-ified semijoin with LATERAL :PREFIX select * from (values (0,9998), (1,1000)) v(id,x), lateral (select f1 from int4_tbl where f1 = any (select unique1 from tenk1 where unique2 = v.x offset 0)) ss; select * from (values (0,9998), (1,1000)) v(id,x), lateral (select f1 from int4_tbl where f1 = any (select unique1 from tenk1 where unique2 = v.x offset 0)) ss; -- check proper extParam/allParam handling (this isn't exactly a LATERAL issue, -- but we can make the test case much more compact with LATERAL) :PREFIX select * from (values (0), (1)) v(id), lateral (select * from int8_tbl t1, lateral (select * from (select * from int8_tbl t2 where q1 = any (select q2 from int8_tbl t3 where q2 = (select greatest(t1.q1,t2.q2)) and (select v.id=0)) offset 0) ss2) ss where t1.q1 = ss.q2) ss0; select * from (values (0), (1)) v(id), lateral (select * from int8_tbl t1, lateral (select * from (select * from int8_tbl t2 where q1 = any (select q2 from int8_tbl t3 where q2 = (select greatest(t1.q1,t2.q2)) and (select v.id=0)) offset 0) ss2) ss where t1.q1 = ss.q2) ss0; -- test some error cases where LATERAL should have been used but wasn't -- select f1,g from int4_tbl a, (select f1 as g) ss; -- select f1,g from int4_tbl a, (select a.f1 as g) ss; -- select f1,g from int4_tbl a cross join (select f1 as g) ss; -- select f1,g from int4_tbl a cross join (select a.f1 as g) ss; -- SQL:2008 says the left table is in scope but illegal to access here -- select f1,g from int4_tbl a right join lateral generate_series(0, a.f1) g on true; -- select f1,g from int4_tbl a full join lateral generate_series(0, a.f1) g on true; -- check we complain about ambiguous table references -- select * from -- int8_tbl x cross join (int4_tbl x cross join lateral (select x.f1) ss); -- LATERAL can be used to put an aggregate into the FROM clause of its query -- select 1 from tenk1 a, lateral (select max(a.unique1) from int4_tbl b) ss; -- check behavior of LATERAL in UPDATE/DELETE -- create temp table xx1 as select f1 as x1, -f1 as x2 from int4_tbl; -- error, can't do this: -- update xx1 set x2 = f1 from (select * from int4_tbl where f1 = x1) ss; -- update xx1 set x2 = f1 from (select * from int4_tbl where f1 = xx1.x1) ss; -- can't do it even with LATERAL: -- update xx1 set x2 = f1 from lateral (select * from int4_tbl where f1 = x1) ss; -- we might in future allow something like this, but for now it's an error: -- update xx1 set x2 = f1 from xx1, lateral (select * from int4_tbl where f1 = x1) ss; -- also errors: -- delete from xx1 using (select * from int4_tbl where f1 = x1) ss; -- delete from xx1 using (select * from int4_tbl where f1 = xx1.x1) ss; -- delete from xx1 using lateral (select * from int4_tbl where f1 = x1) ss; -- -- test LATERAL reference propagation down a multi-level inheritance hierarchy -- produced for a multi-level partitioned table hierarchy. -- create table join_pt1 (a int, b int, c varchar) partition by range(a); create table join_pt1p1 partition of join_pt1 for values from (0) to (100) partition by range(b); create table join_pt1p2 partition of join_pt1 for values from (100) to (200); create table join_pt1p1p1 partition of join_pt1p1 for values from (0) to (100); insert into join_pt1 values (1, 1, 'x'), (101, 101, 'y'); create table join_ut1 (a int, b int, c varchar); insert into join_ut1 values (101, 101, 'y'), (2, 2, 'z'); :PREFIX select t1.b, ss.phv from join_ut1 t1 left join lateral (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss on t1.a = ss.t2a order by t1.a; select t1.b, ss.phv from join_ut1 t1 left join lateral (select t2.a as t2a, t3.a t3a, least(t1.a, t2.a, t3.a) phv from join_pt1 t2 join join_ut1 t3 on t2.a = t3.b) ss on t1.a = ss.t2a order by t1.a; drop table join_pt1; drop table join_ut1; -- -- test that foreign key join estimation performs sanely for outer joins -- begin; create table fkest (a int, b int, c int unique, primary key(a,b)); create table fkest1 (a int, b int, primary key(a,b)); insert into fkest select x/10, x%10, x from generate_series(1,1000) x; insert into fkest1 select x/10, x%10 from generate_series(1,1000) x; alter table fkest1 add constraint fkest1_a_b_fkey foreign key (a,b) references fkest; analyze fkest; analyze fkest1; :PREFIX select * from fkest f left join fkest1 f1 on f.a = f1.a and f.b = f1.b left join fkest1 f2 on f.a = f2.a and f.b = f2.b left join fkest1 f3 on f.a = f3.a and f.b = f3.b where f.c = 1; rollback; -- -- test planner's ability to mark joins as unique -- create table j1 (id int primary key); create table j2 (id int primary key); create table j3 (id int); SELECT (SELECT table_name FROM create_hypertable(tbl,'id',chunk_time_interval:=1000)) FROM (VALUES ('j1'),('j2'),('j3')) v(tbl); insert into j1 values(1),(2),(3); insert into j2 values(1),(2),(3); insert into j3 values(1),(1); analyze j1; analyze j2; analyze j3; -- ensure join is properly marked as unique :PREFIX select * from j1 inner join j2 on j1.id = j2.id; -- ensure join is not unique when not an equi-join :PREFIX select * from j1 inner join j2 on j1.id > j2.id; -- ensure non-unique rel is not chosen as inner :PREFIX select * from j1 inner join j3 on j1.id = j3.id; -- ensure left join is marked as unique :PREFIX select * from j1 left join j2 on j1.id = j2.id; -- ensure right join is marked as unique :PREFIX select * from j1 right join j2 on j1.id = j2.id; -- ensure full join is marked as unique :PREFIX select * from j1 full join j2 on j1.id = j2.id; -- a clauseless (cross) join can't be unique :PREFIX select * from j1 cross join j2; -- ensure a natural join is marked as unique :PREFIX select * from j1 natural join j2; -- ensure a distinct clause allows the inner to become unique :PREFIX select * from j1 inner join (select distinct id from j3) j3 on j1.id = j3.id; -- ensure group by clause allows the inner to become unique :PREFIX select * from j1 inner join (select id from j3 group by id) j3 on j1.id = j3.id; drop table j1; drop table j2; drop table j3; -- test more complex permutations of unique joins create table j1 (id1 int, id2 int, primary key(id1,id2)); create table j2 (id1 int, id2 int, primary key(id1,id2)); create table j3 (id1 int, id2 int, primary key(id1,id2)); SELECT (SELECT table_name FROM create_hypertable(tbl,'id1',chunk_time_interval:=1000,create_default_indexes:=false)) FROM (VALUES ('j1'),('j2'),('j3')) v(tbl); insert into j1 values(1,1),(1,2); insert into j2 values(1,1); insert into j3 values(1,1); analyze j1; analyze j2; analyze j3; -- ensure there's no unique join when not all columns which are part of the -- unique index are seen in the join clause :PREFIX select * from j1 inner join j2 on j1.id1 = j2.id1; -- ensure proper unique detection with multiple join quals :PREFIX select * from j1 inner join j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2; -- ensure we don't detect the join to be unique when quals are not part of the -- join condition :PREFIX select * from j1 inner join j2 on j1.id1 = j2.id1 where j1.id2 = 1; -- as above, but for left joins. :PREFIX select * from j1 left join j2 on j1.id1 = j2.id1 where j1.id2 = 1; -- validate logic in merge joins which skips mark and restore. -- it should only do this if all quals which were used to detect the unique -- are present as join quals, and not plain quals. set enable_nestloop to 0; set enable_hashjoin to 0; set enable_sort to 0; -- create an index that will be preferred over the PK to perform the join create index j1_id1_idx on j1 (id1) where id1 % 1000 = 1; :PREFIX select * from j1 j1 inner join j1 j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; select * from j1 j1 inner join j1 j2 on j1.id1 = j2.id1 and j1.id2 = j2.id2 where j1.id1 % 1000 = 1 and j2.id1 % 1000 = 1; reset enable_nestloop; reset enable_hashjoin; reset enable_sort; drop table j1; drop table j2; drop table j3; -- check that semijoin inner is not seen as unique for a portion of the outerrel :PREFIX select t1.unique1, t2.hundred from onek t1, tenk1 t2 where exists (select 1 from tenk1 t3 where t3.thousand = t1.unique1 and t3.tenthous = t2.hundred) and t1.unique1 < 1; -- ... unless it actually is unique create table j3 as select unique1, tenthous from onek LIMIT 0; select table_name FROM create_hypertable('j3','unique1',chunk_time_interval:=10000); insert into j3 SELECT unique1, tenthous from onek; vacuum analyze j3; create unique index on j3(unique1, tenthous); :PREFIX select t1.unique1, t2.hundred from onek t1, tenk1 t2 where exists (select 1 from j3 where j3.unique1 = t1.unique1 and j3.tenthous = t2.hundred) and t1.unique1 < 1; drop table j3; -- -- exercises for the hash join code -- begin; set local min_parallel_table_scan_size = 0; set local parallel_setup_cost = 0; set local enable_hashjoin = on; -- Extract bucket and batch counts from an explain analyze plan. In -- general we can't make assertions about how many batches (or -- buckets) will be required because it can vary, but we can in some -- special cases and we can check for growth. create or replace function find_hash(node json) returns json language plpgsql as $$ declare x json; child json; begin if node->>'Node Type' = 'Hash' then return node; else for child in select json_array_elements(node->'Plans') loop x := find_hash(child); if x is not null then return x; end if; end loop; return null; end if; end; $$; create or replace function hash_join_batches(query text) returns table (original int, final int) language plpgsql as $$ declare whole_plan json; hash_node json; begin for whole_plan in execute 'explain (analyze, format ''json'') ' || query loop hash_node := find_hash(json_extract_path(whole_plan, '0', 'Plan')); original := hash_node->>'Original Hash Batches'; final := hash_node->>'Hash Batches'; return next; end loop; end; $$; -- Make a simple relation with well distributed keys and correctly -- estimated size. create table simple(id int, t text); select table_name from create_hypertable('simple','id',chunk_time_interval:=5000); insert into simple select generate_series(1, 20000) AS id, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'; alter table simple set (parallel_workers = 2); analyze simple; -- Make a relation whose size we will under-estimate. We want stats -- to say 1000 rows, but actually there are 20,000 rows. create table bigger_than_it_looks(id int, t text); select table_name from create_hypertable('bigger_than_it_looks','id',chunk_time_interval:=5000); insert into bigger_than_it_looks select generate_series(1, 20000) as id, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'; alter table bigger_than_it_looks set (autovacuum_enabled = 'false'); alter table bigger_than_it_looks set (parallel_workers = 2); analyze bigger_than_it_looks; update pg_class set reltuples = 1000 where relname = 'bigger_than_it_looks'; -- Make a relation whose size we underestimate and that also has a -- kind of skew that breaks our batching scheme. We want stats to say -- 2 rows, but actually there are 20,000 rows with the same key. create table extremely_skewed (id int, t text); select table_name from create_hypertable('extremely_skewed','id',chunk_time_interval:=5000); alter table extremely_skewed set (autovacuum_enabled = 'false'); alter table extremely_skewed set (parallel_workers = 2); analyze extremely_skewed; insert into extremely_skewed select 42 as id, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' from generate_series(1, 20000); update pg_class set reltuples = 2, relpages = pg_relation_size('extremely_skewed') / 8192 where relname = 'extremely_skewed'; -- Make a relation with a couple of enormous tuples. create table wide(id int, t text); select table_name from create_hypertable('wide','id',chunk_time_interval:=5000); insert into wide select generate_series(1, 10) as id, rpad('', 320000, 'x') as t; alter table wide set (parallel_workers = 2); -- update statistics analyze wide; -- The "optimal" case: the hash table fits in memory; we plan for 1 -- batch, we stick to that number, and peak memory usage stays within -- our work_mem budget -- non-parallel savepoint settings; set local max_parallel_workers_per_gather = 0; set local work_mem = '4MB'; :PREFIX select count(*) from simple r join simple s using (id); select count(*) from simple r join simple s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- parallel with parallel-oblivious hash join savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '4MB'; set local enable_parallel_hash = off; :PREFIX select count(*) from simple r join simple s using (id); select count(*) from simple r join simple s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- parallel with parallel-aware hash join savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '4MB'; set local enable_parallel_hash = on; :PREFIX select count(*) from simple r join simple s using (id); select count(*) from simple r join simple s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- The "good" case: batches required, but we plan the right number; we -- plan for some number of batches, and we stick to that number, and -- peak memory usage says within our work_mem budget -- non-parallel savepoint settings; set local max_parallel_workers_per_gather = 0; set local work_mem = '128kB'; :PREFIX select count(*) from simple r join simple s using (id); select count(*) from simple r join simple s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- parallel with parallel-oblivious hash join savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '128kB'; set local enable_parallel_hash = off; :PREFIX select count(*) from simple r join simple s using (id); select count(*) from simple r join simple s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- parallel with parallel-aware hash join savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '192kB'; set local enable_parallel_hash = on; :PREFIX select count(*) from simple r join simple s using (id); select count(*) from simple r join simple s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- The "bad" case: during execution we need to increase number of -- batches; in this case we plan for 1 batch, and increase at least a -- couple of times, and peak memory usage stays within our work_mem -- budget -- non-parallel savepoint settings; set local max_parallel_workers_per_gather = 0; set local work_mem = '128kB'; :PREFIX select count(*) FROM simple r JOIN bigger_than_it_looks s USING (id); select count(*) FROM simple r JOIN bigger_than_it_looks s USING (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) FROM simple r JOIN bigger_than_it_looks s USING (id); $$); rollback to settings; -- parallel with parallel-oblivious hash join savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '128kB'; set local enable_parallel_hash = off; :PREFIX select count(*) from simple r join bigger_than_it_looks s using (id); select count(*) from simple r join bigger_than_it_looks s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join bigger_than_it_looks s using (id); $$); rollback to settings; -- parallel with parallel-aware hash join savepoint settings; set local max_parallel_workers_per_gather = 1; set local work_mem = '192kB'; set local enable_parallel_hash = on; :PREFIX select count(*) from simple r join bigger_than_it_looks s using (id); select count(*) from simple r join bigger_than_it_looks s using (id); select original > 1 as initially_multibatch, final > original as increased_batches from hash_join_batches( $$ select count(*) from simple r join bigger_than_it_looks s using (id); $$); rollback to settings; -- The "ugly" case: increasing the number of batches during execution -- doesn't help, so stop trying to fit in work_mem and hope for the -- best; in this case we plan for 1 batch, increases just once and -- then stop increasing because that didn't help at all, so we blow -- right through the work_mem budget and hope for the best... -- non-parallel savepoint settings; set local max_parallel_workers_per_gather = 0; set local work_mem = '128kB'; set local enable_mergejoin to false; :PREFIX select count(*) from simple r join extremely_skewed s using (id); select count(*) from simple r join extremely_skewed s using (id); select * from hash_join_batches( $$ select count(*) from simple r join extremely_skewed s using (id); $$); rollback to settings; -- parallel with parallel-oblivious hash join savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '128kB'; set local enable_parallel_hash = off; :PREFIX select count(*) from simple r join extremely_skewed s using (id); select count(*) from simple r join extremely_skewed s using (id); select * from hash_join_batches( $$ select count(*) from simple r join extremely_skewed s using (id); $$); rollback to settings; -- parallel with parallel-aware hash join savepoint settings; set local max_parallel_workers_per_gather = 1; set local work_mem = '128kB'; set local enable_parallel_hash = on; :PREFIX select count(*) from simple r join extremely_skewed s using (id); select count(*) from simple r join extremely_skewed s using (id); select * from hash_join_batches( $$ select count(*) from simple r join extremely_skewed s using (id); $$); rollback to settings; -- A couple of other hash join tests unrelated to work_mem management. -- Check that EXPLAIN ANALYZE has data even if the leader doesn't participate savepoint settings; set local max_parallel_workers_per_gather = 2; set local work_mem = '4MB'; set local parallel_leader_participation = off; select * from hash_join_batches( $$ select count(*) from simple r join simple s using (id); $$); rollback to settings; -- Exercise rescans. We'll turn off parallel_leader_participation so -- that we can check that instrumentation comes back correctly. create table join_foo as select generate_series(1, 3) as id, 'xxxxx'::text as t; alter table join_foo set (parallel_workers = 0); create table join_bar as select generate_series(1, 10000) as id, 'xxxxx'::text as t; alter table join_bar set (parallel_workers = 2); -- update statistics analyze join_foo; analyze join_bar; -- multi-batch with rescan, parallel-oblivious savepoint settings; set enable_parallel_hash = off; set parallel_leader_participation = off; set min_parallel_table_scan_size = 0; set parallel_setup_cost = 0; set parallel_tuple_cost = 0; set max_parallel_workers_per_gather = 2; set enable_material = off; set enable_mergejoin = off; set work_mem = '64kB'; :PREFIX select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select final > 1 as multibatch from hash_join_batches( $$ select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; $$); rollback to settings; -- single-batch with rescan, parallel-oblivious savepoint settings; set enable_parallel_hash = off; set parallel_leader_participation = off; set min_parallel_table_scan_size = 0; set parallel_setup_cost = 0; set parallel_tuple_cost = 0; set max_parallel_workers_per_gather = 2; set enable_material = off; set enable_mergejoin = off; set work_mem = '4MB'; :PREFIX select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select final > 1 as multibatch from hash_join_batches( $$ select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; $$); rollback to settings; -- multi-batch with rescan, parallel-aware savepoint settings; set enable_parallel_hash = on; set parallel_leader_participation = off; set min_parallel_table_scan_size = 0; set parallel_setup_cost = 0; set parallel_tuple_cost = 0; set max_parallel_workers_per_gather = 2; set enable_material = off; set enable_mergejoin = off; set work_mem = '64kB'; :PREFIX select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select final > 1 as multibatch from hash_join_batches( $$ select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; $$); rollback to settings; -- single-batch with rescan, parallel-aware savepoint settings; set enable_parallel_hash = on; set parallel_leader_participation = off; set min_parallel_table_scan_size = 0; set parallel_setup_cost = 0; set parallel_tuple_cost = 0; set max_parallel_workers_per_gather = 2; set enable_material = off; set enable_mergejoin = off; set work_mem = '4MB'; :PREFIX select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; select final > 1 as multibatch from hash_join_batches( $$ select count(*) from join_foo left join (select b1.id, b1.t from join_bar b1 join join_bar b2 using (id)) ss on join_foo.id < ss.id + 1 and join_foo.id > ss.id - 1; $$); rollback to settings; -- A full outer join where every record is matched. -- non-parallel savepoint settings; set local max_parallel_workers_per_gather = 0; :PREFIX select count(*) from simple r full outer join simple s using (id); rollback to settings; -- parallelism not possible with parallel-oblivious outer hash join savepoint settings; set local max_parallel_workers_per_gather = 2; :PREFIX select count(*) from simple r full outer join simple s using (id); select count(*) from simple r full outer join simple s using (id); rollback to settings; -- An full outer join where every record is not matched. -- non-parallel savepoint settings; set local max_parallel_workers_per_gather = 0; :PREFIX select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); rollback to settings; -- parallelism not possible with parallel-oblivious outer hash join savepoint settings; set local max_parallel_workers_per_gather = 2; :PREFIX select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); select count(*) from simple r full outer join simple s on (r.id = 0 - s.id); rollback to settings; -- exercise special code paths for huge tuples (note use of non-strict -- expression and left join required to get the detoasted tuple into -- the hash table) -- parallel with parallel-aware hash join (hits ExecParallelHashLoadTuple and -- sts_puttuple oversized tuple cases because it's multi-batch) savepoint settings; set max_parallel_workers_per_gather = 2; set enable_parallel_hash = on; set work_mem = '128kB'; :PREFIX select length(max(s.t)) from wide left join (select id, coalesce(t, '') || '' as t from wide) s using (id); select length(max(s.t)) from wide left join (select id, coalesce(t, '') || '' as t from wide) s using (id); select final > 1 as multibatch from hash_join_batches( $$ select length(max(s.t)) from wide left join (select id, coalesce(t, '') || '' as t from wide) s using (id); $$); rollback to settings; rollback; �������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/plan_expand_hypertable_load.sql���������������������������������0000664�0000000�0000000�00000007420�15100345067�0025507�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --single time dimension CREATE TABLE hyper ("time_broken" bigint NOT NULL, "value" integer); ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper', 'time', chunk_time_interval => 10); INSERT INTO hyper SELECT g, g FROM generate_series(0,1000) g; --insert a point with INT_MAX_64 INSERT INTO hyper (time, value) SELECT 9223372036854775807::bigint, 0; --time and space CREATE TABLE hyper_w_space ("time_broken" bigint NOT NULL, "device_id" text, "value" integer); ALTER TABLE hyper_w_space DROP COLUMN time_broken, ADD COLUMN time BIGINT; SELECT create_hypertable('hyper_w_space', 'time', 'device_id', 4, chunk_time_interval => 10); INSERT INTO hyper_w_space (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE VIEW hyper_w_space_view AS (SELECT * FROM hyper_w_space); --with timestamp and space CREATE TABLE tag (id serial PRIMARY KEY, name text); CREATE TABLE hyper_ts ("time_broken" timestamptz NOT NULL, "device_id" text, tag_id INT REFERENCES tag(id), "value" integer); ALTER TABLE hyper_ts DROP COLUMN time_broken, ADD COLUMN time TIMESTAMPTZ; SELECT create_hypertable('hyper_ts', 'time', 'device_id', 2, chunk_time_interval => '10 seconds'::interval); INSERT INTO tag(name) SELECT 'tag'||g FROM generate_series(0,10) g; INSERT INTO hyper_ts (time, device_id, tag_id, value) SELECT to_timestamp(g), 'dev' || g, (random() /10)+1, g FROM generate_series(0,30) g; --one in the future INSERT INTO hyper_ts (time, device_id, tag_id, value) VALUES ('2100-01-01 02:03:04 PST', 'dev101', 1, 0); --time partitioning function CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc ("time" float8 NOT NULL, "device_id" text, "value" integer); SELECT create_hypertable('hyper_timefunc', 'time', 'device_id', 4, chunk_time_interval => 10, time_partitioning_func => 'unix_to_timestamp'); INSERT INTO hyper_timefunc (time, device_id, value) SELECT g, 'dev' || g, g FROM generate_series(0,30) g; CREATE TABLE metrics_timestamp(time timestamp); SELECT create_hypertable('metrics_timestamp','time'); INSERT INTO metrics_timestamp SELECT generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'1d'::interval); CREATE TABLE metrics_timestamptz(time timestamptz, device_id int); SELECT create_hypertable('metrics_timestamptz','time'); INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 1; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 2; INSERT INTO metrics_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval), 3; --create a second table to test joins with CREATE TABLE metrics_timestamptz_2 (LIKE metrics_timestamptz); SELECT create_hypertable('metrics_timestamptz_2','time'); INSERT INTO metrics_timestamptz_2 SELECT * FROM metrics_timestamptz; INSERT INTO metrics_timestamptz_2 VALUES ('2000-12-01'::timestamptz, 3); CREATE TABLE metrics_date(time date); SELECT create_hypertable('metrics_date','time'); INSERT INTO metrics_date SELECT generate_series('2000-01-01'::date,'2000-02-01'::date,'1d'::interval); ANALYZE hyper; ANALYZE hyper_w_space; ANALYZE tag; ANALYZE hyper_ts; ANALYZE hyper_timefunc; -- create normal table for JOIN tests CREATE TABLE regular_timestamptz(time timestamptz); INSERT INTO regular_timestamptz SELECT generate_series('2000-01-01'::timestamptz,'2000-02-01'::timestamptz,'1d'::interval); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/plan_expand_hypertable_query.sql��������������������������������0000664�0000000�0000000�00000066456�15100345067�0025753�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --we want to see how our logic excludes chunks --and not how much work constraint_exclusion does SET constraint_exclusion = 'off'; \qecho test upper bounds :PREFIX SELECT * FROM hyper WHERE time < 10 ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time < 11 ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time = 10 ORDER BY value; :PREFIX SELECT * FROM hyper WHERE 10 >= time ORDER BY value; \qecho test lower bounds :PREFIX SELECT * FROM hyper WHERE time >= 10 and time < 20 ORDER BY value; :PREFIX SELECT * FROM hyper WHERE 10 < time and 20 >= time ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time >= 9 and time < 20 ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time > 9 and time < 20 ORDER BY value; \qecho test empty result :PREFIX SELECT * FROM hyper WHERE time < 0; \qecho test expression evaluation :PREFIX SELECT * FROM hyper WHERE time < (5*2)::smallint; \qecho test logic at INT64_MAX :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775807::bigint ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time = 9223372036854775806::bigint ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time >= 9223372036854775807::bigint ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775807::bigint ORDER BY value; :PREFIX SELECT * FROM hyper WHERE time > 9223372036854775806::bigint ORDER BY value; \qecho cte :PREFIX WITH cte AS( SELECT * FROM hyper WHERE time < 10 ) SELECT * FROM cte ORDER BY value; \qecho subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper WHERE time < 10); \qecho no space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 ORDER BY value; \qecho valid space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ORDER BY value; :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev5' = device_id ORDER BY value; :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and 'dev'||(2+3) = device_id ORDER BY value; \qecho only space constraint :PREFIX SELECT * FROM hyper_w_space WHERE 'dev5' = device_id ORDER BY value; \qecho unhandled space constraint :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 and device_id > 'dev5' ORDER BY value; \qecho use of OR - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND (device_id = 'dev5' or device_id = 'dev6') ORDER BY value; \qecho cte :PREFIX WITH cte AS( SELECT * FROM hyper_w_space WHERE time < 10 and device_id = 'dev5' ) SELECT * FROM cte ORDER BY value; \qecho subquery :PREFIX SELECT 0 = ANY (SELECT value FROM hyper_w_space WHERE time < 10 and device_id = 'dev5'); \qecho view :PREFIX SELECT * FROM hyper_w_space_view WHERE time < 10 and device_id = 'dev5' ORDER BY value; \qecho IN statement - simple :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5') ORDER BY value; \qecho IN statement - two chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev5','dev6') ORDER BY value; \qecho IN statement - one chunk :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN ('dev4','dev5') ORDER BY value; \qecho NOT IN - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id NOT IN ('dev5','dev6') ORDER BY value; \qecho IN statement with subquery - does not filter chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id IN (SELECT 'dev5'::text) ORDER BY value; \qecho ANY :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) ORDER BY value; \qecho ANY with intersection :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev6','dev7']) ORDER BY value; \qecho ANY without intersection shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND device_id = ANY(ARRAY['dev5','dev6']) AND device_id = ANY(ARRAY['dev8','dev9']) ORDER BY value; \qecho ANY/IN/ALL only works for equals operator :PREFIX SELECT * FROM hyper_w_space WHERE device_id < ANY(ARRAY['dev5','dev6']) ORDER BY value; \qecho ALL with equals and different values shouldnt scan any chunks :PREFIX SELECT * FROM hyper_w_space WHERE device_id = ALL(ARRAY['dev5','dev6']) ORDER BY value; \qecho Multi AND :PREFIX SELECT * FROM hyper_w_space WHERE time < 10 AND time < 100 ORDER BY value; \qecho Time dimension doesnt filter chunks when using IN/ANY with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1,2]) ORDER BY value; \qecho Time dimension chunk filtering works for ANY with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ANY(ARRAY[1]) ORDER BY value; \qecho Time dimension chunk filtering works for ALL with single argument :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1]) ORDER BY value; \qecho Time dimension chunk filtering works for ALL with multiple arguments :PREFIX SELECT * FROM hyper_w_space WHERE time < ALL(ARRAY[1,10,20,30]) ORDER BY value; \qecho AND intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev1' ORDER BY value; \qecho AND with no intersection using IN and EQUALS :PREFIX SELECT * FROM hyper_w_space WHERE device_id IN ('dev1','dev2') AND device_id = 'dev3' ORDER BY value; \qecho timestamps \qecho these should work since they are immutable functions :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969 PST'::timestamptz ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp AT TIME ZONE 'PST' ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; \qecho these should not work since uses stable functions; :PREFIX SELECT * FROM hyper_ts WHERE time < 'Wed Dec 31 16:00:10 1969'::timestamp ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE time < ('Wed Dec 31 16:00:10 1969'::timestamp::timestamptz) ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE NOW() < time ORDER BY value; \qecho joins :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.id=1) or (time < to_timestamp(10) and device_id = 'dev1') ORDER BY value; :PREFIX SELECT * FROM hyper_ts WHERE tag_id IN (SELECT id FROM tag WHERE tag.name='tag1') and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; :PREFIX SELECT * FROM hyper_ts JOIN tag on (hyper_ts.tag_id = tag.id ) WHERE tag.name = 'tag1' and time < to_timestamp(10) and device_id = 'dev1' ORDER BY value; \qecho test constraint exclusion for constraints in ON clause of JOINs \qecho should exclude chunks on m1 and propagate qual to m2 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; \qecho should exclude chunks on m2 and propagate qual to m1 because of INNER JOIN :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho must not exclude on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; \qecho should exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho should exclude chunks on m1 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; \qecho must not exclude chunks on m2 :PREFIX SELECT m1.time,m2.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time < '2000-01-10' ORDER BY m1.time, m2.time; \qecho time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 10::bigint ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) < 11::bigint ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) <= 10::bigint ORDER BY time; :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time) ORDER BY time; :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time) ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 10::bigint ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) < 11::bigint ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time, 5) <= 10::bigint ORDER BY time; :PREFIX SELECT * FROM hyper WHERE 10::bigint > time_bucket(10, time, 5) ORDER BY time; :PREFIX SELECT * FROM hyper WHERE 11::bigint > time_bucket(10, time, 5) ORDER BY time; \qecho timestamp time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamp; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time) >= '2000-01-15' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('7d',time,'2000-01-10'::timestamp) >= '2000-01-25' ORDER BY time; \qecho timestamptz time_bucket exclusion SELECT count(DISTINCT tableoid) FROM metrics_timestamptz; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time) >= '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'3d'::interval) >= '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'2000-01-10'::timestamptz) >= '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') < '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') <= '2000-01-05' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') > '2000-01-25' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamptz WHERE time_bucket('7d',time,'Europe/Berlin') >= '2000-01-25' ORDER BY time; \qecho test overflow behaviour of time_bucket exclusion :PREFIX SELECT * FROM hyper WHERE time > 950 AND time_bucket(10, time) < '9223372036854775807'::bigint ORDER BY time; \qecho test timestamp upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '294276-01-01'::timestamp ORDER BY time; \qecho transformation would be out of range :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1000d',time) < '294276-01-01'::timestamp ORDER BY time; \qecho test timestamptz upper boundary \qecho there should be no transformation if we are out of the supported (TimescaleDB-specific) range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '294276-01-01'::timestamptz ORDER BY time; \qecho transformation would be out of range :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1000d',time) < '294276-01-01'::timestamptz ORDER BY time; \qecho time_bucket exclusion with run-time constants -- These queries have a stable time_bucket expression, because the text::interval conversion is stable. PREPARE P1(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P2(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P3(text , text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P4(text , text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; -- These queries have an immutable time_bucket expression, because the parameter is passed as interval, and no conversion is involved. PREPARE P5(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P6(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamptz ORDER BY time; PREPARE P7(interval, text) AS SELECT * FROM metrics_timestamptz WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; PREPARE P8(interval, text) AS SELECT * FROM metrics_timestamp WHERE time_bucket($1::interval, time) > $2::timestamp ORDER BY time; SET plan_cache_mode TO 'force_custom_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); SET plan_cache_mode TO 'force_generic_plan'; :PREFIX EXECUTE P1('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P2('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P3('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P4('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P5('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P6('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P7('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P8('60 mins', '2024-01-01 UTC'); :PREFIX EXECUTE P1('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P2('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P3('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P4('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P5('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P6('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P7('60 mins', '2000-01-01 UTC'); :PREFIX EXECUTE P8('60 mins', '2000-01-01 UTC'); RESET plan_cache_mode; DEALLOCATE P1; DEALLOCATE P2; DEALLOCATE P3; DEALLOCATE P4; DEALLOCATE P5; DEALLOCATE P6; DEALLOCATE P7; DEALLOCATE P8; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 100 ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(10, time) > 10 AND time_bucket(10, time) < 20 ORDER BY time; :PREFIX SELECT * FROM hyper WHERE time_bucket(1, time) > 11 AND time_bucket(1, time) < 19 ORDER BY time; :PREFIX SELECT * FROM hyper WHERE 10 < time_bucket(10, time) AND 20 > time_bucket(10,time) ORDER BY time; \qecho time_bucket exclusion with date :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; :PREFIX SELECT * FROM metrics_date WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; \qecho time_bucket exclusion with timestamp :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; :PREFIX SELECT * FROM metrics_timestamp WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; \qecho time_bucket exclusion with timestamptz :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) < '2000-01-03' ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('6h',time) >= '2000-01-03' AND time_bucket('6h',time) <= '2000-01-10' ORDER BY time; \qecho time_bucket exclusion with timestamptz and day interval :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) < '2000-01-03' ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('1d',time) <= '2000-01-10' ORDER BY time; :PREFIX SELECT time FROM metrics_timestamptz WHERE time_bucket('1d',time) >= '2000-01-03' AND time_bucket('7d',time) <= '2000-01-10' ORDER BY time; \qecho no transformation :PREFIX SELECT * FROM hyper WHERE time_bucket(10 + floor(random())::int, time) > 10 AND time_bucket(10 + floor(random())::int, time) < 100 AND time < 150 ORDER BY time; \qecho exclude chunks based on time column with partitioning function. This \qecho transparently applies the time partitioning function on the time \qecho value to be able to exclude chunks (similar to a closed dimension). :PREFIX SELECT * FROM hyper_timefunc WHERE time < 4 ORDER BY value; \qecho excluding based on time expression is currently unoptimized :PREFIX SELECT * FROM hyper_timefunc WHERE unix_to_timestamp(time) < 'Wed Dec 31 16:00:04 1969 PST' ORDER BY value; \qecho test qual propagation for joins RESET constraint_exclusion; \qecho nothing to propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time ORDER BY m1.time; \qecho OR constraints should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' OR m1.time > '2001-01-01' ORDER BY m1.time; \qecho test single constraint \qecho constraint should be on both scans \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; \qecho test 2 constraints on single relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; \qecho test 2 constraints with 1 constraint on each relation \qecho these will propagate even for LEFT/RIGHT JOIN because the constraints are not in the ON clause and therefore imply a NOT NULL condition on the JOIN column :PREFIX SELECT m1.time FROM metrics_timestamptz m1, metrics_timestamptz_2 m2 WHERE m1.time = m2.time AND m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho test constraints in ON clause of INNER JOIN :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho test constraints in ON clause of LEFT JOIN \qecho must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 LEFT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho test constraints in ON clause of RIGHT JOIN \qecho must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 RIGHT JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time AND m2.time > '2000-01-01' AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho test equality condition not in ON clause :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' ORDER BY m1.time; \qecho test constraints not joined on \qecho device_id constraint must not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; \qecho test multiple join conditions \qecho device_id constraint should propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON true WHERE m2.time = m1.time AND m1.device_id = m2.device_id AND m2.time < '2000-01-10' AND m1.device_id = 1 ORDER BY m1.time; \qecho test join with 3 tables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time INNER JOIN metrics_timestamptz m3 ON m2.time=m3.time WHERE m1.time > '2000-01-01' AND m1.time < '2000-01-10' ORDER BY m1.time; \qecho test non-Const constraints :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10'::text::timestamptz ORDER BY m1.time; \qecho test now() :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < now() ORDER BY m1.time; \qecho test volatile function \qecho should not propagate :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m1.time < clock_timestamp() ORDER BY m1.time; :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN metrics_timestamptz_2 m2 ON m1.time = m2.time WHERE m2.time < clock_timestamp() ORDER BY m1.time; \qecho test JOINs with normal table \qecho will not propagate because constraints are only added to hypertables :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m1.time < '2000-01-10' ORDER BY m1.time; \qecho test JOINs with normal table :PREFIX SELECT m1.time FROM metrics_timestamptz m1 INNER JOIN regular_timestamptz m2 ON m1.time = m2.time WHERE m2.time < '2000-01-10' ORDER BY m1.time; \qecho test quals are not pushed into OUTER JOIN CREATE TABLE outer_join_1 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); CREATE TABLE outer_join_2 (id int, name text,time timestamptz NOT NULL DEFAULT '2000-01-01'); SELECT (SELECT table_name FROM create_hypertable(tbl, 'time')) FROM (VALUES ('outer_join_1'),('outer_join_2')) v(tbl); INSERT INTO outer_join_1 VALUES(1,'a'), (2,'b'); INSERT INTO outer_join_2 VALUES(1,'a'); :PREFIX SELECT one.id, two.name FROM outer_join_1 one LEFT OUTER JOIN outer_join_2 two ON one.id=two.id WHERE one.id=2; :PREFIX SELECT one.id, two.name FROM outer_join_2 two RIGHT OUTER JOIN outer_join_1 one ON one.id=two.id WHERE one.id=2; DROP TABLE outer_join_1; DROP TABLE outer_join_2; -- test UNION between regular table and hypertable SELECT time FROM regular_timestamptz UNION SELECT time FROM metrics_timestamptz ORDER BY 1; -- test UNION ALL between regular table and hypertable SELECT time FROM regular_timestamptz UNION ALL SELECT time FROM metrics_timestamptz ORDER BY 1; -- test nested join qual propagation :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON true WHERE o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id AND o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON true WHERE o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id AND o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; :PREFIX SELECT * FROM ( SELECT o1_m1.time FROM metrics_timestamptz o1_m1 INNER JOIN metrics_timestamptz_2 o1_m2 ON o1_m2.time = o1_m1.time AND o1_m1.device_id = o1_m2.device_id WHERE o1_m2.time < '2000-01-10' AND o1_m1.device_id = 1 ) o1 FULL OUTER JOIN ( SELECT o2_m1.time FROM metrics_timestamptz o2_m1 FULL OUTER JOIN metrics_timestamptz_2 o2_m2 ON o2_m2.time = o2_m1.time AND o2_m1.device_id = o2_m2.device_id WHERE o2_m2.time > '2000-01-20' AND o2_m1.device_id = 2 ) o2 ON o1.time = o2.time ORDER BY 1,2; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/plan_hashagg_load.sql�������������������������������������������0000664�0000000�0000000�00000004411�15100345067�0023410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE metric (id SERIAL PRIMARY KEY, value INT); CREATE TABLE hyper(time TIMESTAMP NOT NULL, time_int BIGINT, time_broken DATE, metricid int, value double precision); CREATE TABLE regular(time TIMESTAMP NOT NULL, time_int BIGINT, time_date DATE, metricid int, value double precision); SELECT create_hypertable('hyper', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE); ALTER TABLE hyper DROP COLUMN time_broken, ADD COLUMN time_date DATE; INSERT INTO metric(value) SELECT random()*100 FROM generate_series(0,10); INSERT INTO hyper SELECT t, EXTRACT(EPOCH FROM t), (EXTRACT(EPOCH FROM t)::int % 10)+1, 1.0, t::date FROM generate_series('2001-01-01', '2001-01-10', INTERVAL '1 second') t; INSERT INTO regular(time, time_int, time_date, metricid, value) SELECT t, EXTRACT(EPOCH FROM t), t::date, (EXTRACT(EPOCH FROM t)::int % 10) + 1, 1.0 FROM generate_series('2001-01-01', '2001-01-02', INTERVAL '1 second') t; --test some queries before analyze; EXPLAIN (buffers off, costs off) SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; EXPLAIN (buffers off, costs off) SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE TABLE hyper_timefunc(time float8 NOT NULL, metricid int, VALUE double precision, time_date DATE); SELECT create_hypertable('hyper_timefunc', 'time', chunk_time_interval => interval '20 day', create_default_indexes=>FALSE, time_partitioning_func => 'unix_to_timestamp'); INSERT INTO hyper_timefunc SELECT time_int, metricid, VALUE, time_date FROM hyper; ANALYZE metric; ANALYZE hyper; ANALYZE regular; ANALYZE hyper_timefunc; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/plan_hashagg_query.sql������������������������������������������0000664�0000000�0000000�00000007053�15100345067�0023643�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. :PREFIX SELECT time_bucket('1 minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; :PREFIX SELECT time_bucket('1 hour', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; --should be too many groups will not hashaggregate :PREFIX SELECT time_bucket('1 second', time) AS MetricMinuteTs, metricid, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metricid ORDER BY MetricMinuteTs DESC, metricid; :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; :PREFIX SELECT time_bucket(60, time_int) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; :PREFIX SELECT time_bucket(60, time_int, 10) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; :PREFIX SELECT time_bucket('1 day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; :PREFIX SELECT date_trunc('minute', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; \set ON_ERROR_STOP 0 --can't optimize invalid time unit :PREFIX SELECT date_trunc('invalid', time) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; \set ON_ERROR_STOP 1 :PREFIX SELECT date_trunc('day', time_date) AS MetricMinuteTs, AVG(value) as avg FROM hyper WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; --joins --with hypertable, optimize :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(hyper.value) as avg FROM hyper JOIN metric ON (hyper.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; --no hypertable involved, no optimization :PREFIX SELECT time_bucket(3600, time_int, 10) AS MetricMinuteTs, metric.value, AVG(regular.value) as avg FROM regular JOIN metric ON (regular.metricid = metric.id) WHERE time >= '2001-01-04T00:00:00' AND time <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs, metric.id ORDER BY MetricMinuteTs DESC, metric.id; -- Try with time partitioning function. Currently not optimized for hash aggregates :PREFIX SELECT time_bucket('1 minute', unix_to_timestamp(time)) AS MetricMinuteTs, AVG(value) as avg FROM hyper_timefunc WHERE unix_to_timestamp(time) >= '2001-01-04T00:00:00' AND unix_to_timestamp(time) <= '2001-01-05T01:00:00' GROUP BY MetricMinuteTs ORDER BY MetricMinuteTs DESC; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/plan_ordered_append_load.sql������������������������������������0000664�0000000�0000000�00000016530�15100345067�0024766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- create a now() function for repeatable testing that always returns -- the same timestamp. It needs to be marked STABLE CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2000-01-08T0:00:00+0'::timestamptz; END; $BODY$; CREATE TABLE devices(device_id INT PRIMARY KEY, name TEXT); INSERT INTO devices VALUES (1,'Device 1'), (2,'Device 2'), (3,'Device 3'); -- create a second table where we create chunks in reverse order CREATE TABLE ordered_append_reverse(time timestamptz NOT NULL, device_id INT, value float); SELECT create_hypertable('ordered_append_reverse','time'); INSERT INTO ordered_append_reverse SELECT generate_series('2000-01-18'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 0.5; -- table where dimension column is last column CREATE TABLE IF NOT EXISTS dimension_last( id INT8 NOT NULL, device_id INT NOT NULL, name TEXT NOT NULL, time timestamptz NOT NULL ); SELECT create_hypertable('dimension_last', 'time', chunk_time_interval => interval '1day', if_not_exists => True); -- table with only dimension column CREATE TABLE IF NOT EXISTS dimension_only( time timestamptz NOT NULL ); SELECT create_hypertable('dimension_only', 'time', chunk_time_interval => interval '1day', if_not_exists => True); INSERT INTO dimension_last SELECT 1,1,'Device 1',generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-04 23:59:00+0'::timestamptz,'1m'::interval); INSERT INTO dimension_only VALUES ('2000-01-01'), ('2000-01-03'), ('2000-01-05'), ('2000-01-07'); ANALYZE devices; ANALYZE ordered_append_reverse; ANALYZE dimension_last; ANALYZE dimension_only; -- create hypertable with indexes not on all chunks CREATE TABLE ht_missing_indexes(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_missing_indexes','time'); INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 1, 0.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 2, 1.5; INSERT INTO ht_missing_indexes SELECT generate_series('2000-01-01'::timestamptz,'2000-01-18'::timestamptz,'1m'::interval), 3, 2.5; -- drop index from 2nd chunk of ht_missing_indexes SELECT format('%I.%I',i.schemaname,i.indexname) AS "INDEX_NAME" FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable ht ON c.hypertable_id = ht.id INNER JOIN pg_indexes i ON i.schemaname = c.schema_name AND i.tablename=c.table_name WHERE ht.table_name = 'ht_missing_indexes' ORDER BY c.id LIMIT 1 OFFSET 1 \gset DROP INDEX :INDEX_NAME; ANALYZE ht_missing_indexes; -- create hypertable with with dropped columns CREATE TABLE ht_dropped_columns(c1 int, c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('ht_dropped_columns','time'); ALTER TABLE ht_dropped_columns DROP COLUMN c1; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-01'::timestamptz,'2000-01-02'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c2; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-08'::timestamptz,'2000-01-09'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c3; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-15'::timestamptz,'2000-01-16'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c4; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-22'::timestamptz,'2000-01-23'::timestamptz,'1m'::interval), 1, 0.5; ALTER TABLE ht_dropped_columns DROP COLUMN c5; INSERT INTO ht_dropped_columns(time,device_id,value) SELECT generate_series('2000-01-29'::timestamptz,'2000-01-30'::timestamptz,'1m'::interval), 1, 0.5; ANALYZE ht_dropped_columns; CREATE TABLE space2(time timestamptz NOT NULL, device_id int NOT NULL, tag_id int NOT NULL, value float); SELECT create_hypertable('space2','time','device_id',number_partitions:=3); SELECT add_dimension('space2','tag_id',number_partitions:=3); INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 1, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 2, 3.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 3, 1.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 3, 2.5; INSERT INTO space2 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 3, 3, 3.5; ANALYZE space2; CREATE TABLE space3(time timestamptz NOT NULL, x int NOT NULL, y int NOT NULL, z int NOT NULL, value float); SELECT create_hypertable('space3','time','x',number_partitions:=2); SELECT add_dimension('space3','y',number_partitions:=2); SELECT add_dimension('space3','z',number_partitions:=2); INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 1, 2, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 1, 2, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 1, 1.5; INSERT INTO space3 SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 2, 2, 2, 1.5; ANALYZE space3; CREATE TABLE sortopt_test(time timestamptz NOT NULL, device TEXT); SELECT create_hypertable('sortopt_test','time',create_default_indexes:=false); -- since alpine does not support locales we cant test collations in our ci -- CREATE COLLATION IF NOT EXISTS en_US(LOCALE='en_US.utf8'); -- CREATE INDEX time_device_utf8 ON sortopt_test(time, device COLLATE "en_US"); CREATE INDEX time_device_nullsfirst ON sortopt_test(time, device NULLS FIRST); CREATE INDEX time_device_nullslast ON sortopt_test(time, device DESC NULLS LAST); INSERT INTO sortopt_test SELECT generate_series('2000-01-10'::timestamptz,'2000-01-01'::timestamptz,'-1m'::interval), 'Device 1'; ANALYZE sortopt_test; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/plan_ordered_append_query.sql�����������������������������������0000664�0000000�0000000�00000006511�15100345067�0025212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- print chunks ordered by time to ensure ordering we want SELECT ht.table_name AS hypertable, c.table_name AS chunk, ds.range_start FROM _timescaledb_catalog.chunk c INNER JOIN LATERAL(SELECT * FROM _timescaledb_catalog.chunk_constraint cc WHERE c.id = cc.chunk_id ORDER BY cc.dimension_slice_id LIMIT 1) cc ON true INNER JOIN _timescaledb_catalog.dimension_slice ds ON ds.id=cc.dimension_slice_id INNER JOIN _timescaledb_catalog.dimension d ON ds.dimension_id = d.id INNER JOIN _timescaledb_catalog.hypertable ht ON d.hypertable_id = ht.id ORDER BY ht.table_name, range_start, chunk; -- test ASC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time ASC LIMIT 1; -- test DESC for reverse ordered chunks :PREFIX SELECT time, device_id, value FROM ordered_append_reverse ORDER BY time DESC LIMIT 1; -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d',time), device_id, name FROM dimension_last ORDER BY time_bucket('1d',time), device_id LIMIT 1; -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day',time), device_id, name FROM dimension_last ORDER BY 1,2 LIMIT 1; -- test with table with only dimension column :PREFIX SELECT * FROM dimension_only ORDER BY time DESC LIMIT 1; -- test LEFT JOIN against hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last LEFT JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; -- test INNER JOIN against non-hypertable :PREFIX_NO_ANALYZE SELECT * FROM dimension_last INNER JOIN dimension_only USING (time) ORDER BY dimension_last.time DESC LIMIT 2; -- test join against non-hypertable :PREFIX SELECT * FROM dimension_last INNER JOIN devices USING(device_id) ORDER BY dimension_last.time DESC LIMIT 2; -- test hypertable with index missing on one chunk :PREFIX SELECT time, device_id, value FROM ht_missing_indexes ORDER BY time ASC LIMIT 1; -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE device_id = 2 ORDER BY time DESC LIMIT 1; -- test hypertable with index missing on one chunk -- and no data :PREFIX SELECT time, device_id, value FROM ht_missing_indexes WHERE time > '2000-01-07' ORDER BY time LIMIT 10; -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns ORDER BY time ASC LIMIT 1; -- test hypertable with dropped columns :PREFIX SELECT time, device_id, value FROM ht_dropped_columns WHERE device_id = 1 ORDER BY time DESC; -- test hypertable with 2 space dimensions :PREFIX SELECT time, device_id, value FROM space2 ORDER BY time DESC; -- test hypertable with 3 space dimensions :PREFIX SELECT time FROM space3 ORDER BY time DESC; -- test COLLATION -- cant be tested in our ci because alpine doesnt support locales -- :PREFIX SELECT * FROM sortopt_test ORDER BY time, device COLLATE "en_US.utf8"; -- test NULLS FIRST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device NULLS FIRST; -- test NULLS LAST :PREFIX SELECT * FROM sortopt_test ORDER BY time, device DESC NULLS LAST; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/query_load.sql��������������������������������������������������0000664�0000000�0000000�00000010460�15100345067�0022142�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC.hyper_1 ( time TIMESTAMP NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain" ON PUBLIC.hyper_1 (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1"'::regclass, 'time'::name, number_partitions => 1, create_default_indexes=>false); INSERT INTO hyper_1 SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1 SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.hyper_1_tz ( time TIMESTAMPTZ NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_tz" ON PUBLIC.hyper_1_tz (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1_tz"'::regclass, 'time'::name, number_partitions => 1, create_default_indexes=>false); INSERT INTO hyper_1_tz SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1_tz SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.hyper_1_int ( time int NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_int" ON PUBLIC.hyper_1_int (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1_int"'::regclass, 'time'::name, number_partitions => 1, chunk_time_interval=>10000, create_default_indexes=>FALSE); INSERT INTO hyper_1_int SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1_int SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.hyper_1_date ( time date NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_date" ON PUBLIC.hyper_1_date (time DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_1_date"'::regclass, 'time'::name, number_partitions => 1, chunk_time_interval=>86400000000, create_default_indexes=>FALSE); INSERT INTO hyper_1_date SELECT to_timestamp(ser)::date, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_1_date SELECT to_timestamp(ser)::date, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; --below needed to create enough unique dates to trigger an index scan INSERT INTO hyper_1_date SELECT to_timestamp(ser*100)::date, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; CREATE TABLE PUBLIC.plain_table ( time TIMESTAMPTZ NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE INDEX "time_plain_plain_table" ON PUBLIC.plain_table (time DESC, series_0); INSERT INTO plain_table SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO plain_table SELECT to_timestamp(ser), ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; -- Table with a time partitioning function CREATE TABLE PUBLIC.hyper_timefunc ( time float8 NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL ); CREATE OR REPLACE FUNCTION unix_to_timestamp(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE INDEX "time_plain_timefunc" ON PUBLIC.hyper_timefunc (to_timestamp(time) DESC, series_0); SELECT * FROM create_hypertable('"public"."hyper_timefunc"'::regclass, 'time'::name, number_partitions => 1, create_default_indexes=>false, time_partitioning_func => 'unix_to_timestamp'); INSERT INTO hyper_timefunc SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(0,10000) ser; INSERT INTO hyper_timefunc SELECT ser, ser, ser+10000, sqrt(ser::numeric) FROM generate_series(10001,20000) ser; ANALYZE plain_table; ANALYZE hyper_timefunc; ANALYZE hyper_1; ANALYZE hyper_1_tz; ANALYZE hyper_1_int; ANALYZE hyper_1_date; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/query_query.sql�������������������������������������������������0000664�0000000�0000000�00000007565�15100345067�0022404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SHOW timescaledb.enable_optimizations; --non-aggregates use MergeAppend in both optimized and non-optimized :PREFIX SELECT * FROM hyper_1 ORDER BY "time" DESC limit 2; :PREFIX SELECT * FROM hyper_timefunc ORDER BY unix_to_timestamp("time") DESC limit 2; --Aggregates use MergeAppend only in optimized :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_date GROUP BY t ORDER BY t DESC limit 2; --the minute and second results should be diff :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT date_trunc('second', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --test that when index on time used by constraint, still works correctly :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 WHERE time < to_timestamp(900) GROUP BY t ORDER BY t DESC LIMIT 2; --test on table with time partitioning function. Currently not --optimized to use index for ordering since the index is an expression --on time (e.g., timefunc(time)), and we currently don't handle that --case. :PREFIX SELECT date_trunc('minute', to_timestamp(time)) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_timefunc WHERE to_timestamp(time) < to_timestamp(900) GROUP BY t ORDER BY t DESC LIMIT 2; BEGIN; --test that still works with an expression index on data_trunc. DROP INDEX "time_plain"; CREATE INDEX "time_trunc" ON PUBLIC.hyper_1 (date_trunc('minute', time)); ANALYZE hyper_1; :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; --test that works with both indexes CREATE INDEX "time_plain" ON PUBLIC.hyper_1 (time DESC, series_0); ANALYZE hyper_1; :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket('1 minute', time) t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric, 5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket('1 minute', time, INTERVAL '30 seconds') t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric,5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket('1 minute', time - INTERVAL '30 seconds') t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric,5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket('1 minute', time - INTERVAL '30 seconds') + INTERVAL '30 seconds' t, avg(series_0), min(series_1), trunc(avg(series_2)::numeric,5) FROM hyper_1 GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket('1 minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_tz GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket('1 minute', time::timestamp) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_tz GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket(10, time) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_int GROUP BY t ORDER BY t DESC limit 2; :PREFIX SELECT time_bucket(10, time, 2) t, avg(series_0), min(series_1), avg(series_2) FROM hyper_1_int GROUP BY t ORDER BY t DESC limit 2; ROLLBACK; -- sort order optimization should not be applied to non-hypertables :PREFIX SELECT date_trunc('minute', time) t, avg(series_0), min(series_1), avg(series_2) FROM plain_table WHERE time < to_timestamp(900) GROUP BY t ORDER BY t DESC LIMIT 2; �������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/query_result_test_equal.sql�������������������������������������0000664�0000000�0000000�00000001616�15100345067�0024772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --expects QUERY1 and QUERY2 to be set, expects data can be compared set enable_hashjoin = off; set enable_mergejoin = on; with query1 AS ( SELECT row_number() OVER(ORDER BY q.*) row_number, * FROM (:QUERY1) as q ), query2 AS ( SELECT row_number() OVER (ORDER BY v.*) row_number, * FROM (:QUERY2) as v ) SELECT count(*) FILTER (WHERE query1.row_number IS DISTINCT FROM query2.row_number OR query1.show_chunks IS DISTINCT FROM query2.drop_chunks) AS "Different Rows", coalesce(max(query1.row_number), 0) AS "Total Rows from Query 1", coalesce(max(query2.row_number), 0) AS "Total Rows from Query 2" FROM query1 FULL OUTER JOIN query2 ON (query1.row_number = query2.row_number); reset enable_hashjoin; reset enable_mergejoin; ������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/test_utils.sql��������������������������������������������������0000664�0000000�0000000�00000001172�15100345067�0022175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION assert_true( val boolean ) RETURNS VOID LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN IF val IS NOT TRUE THEN RAISE 'Assert failed'; END IF; END $BODY$; CREATE OR REPLACE FUNCTION assert_equal( val1 anyelement, val2 anyelement ) RETURNS VOID LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN IF (val1 = val2) IS NOT TRUE THEN RAISE 'Assert failed: % = %',val1,val2; END IF; END $BODY$; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/ts_merge_load.sql�����������������������������������������������0000664�0000000�0000000�00000005006�15100345067�0022602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/include/ts_merge_load_ht.sql��������������������������������������������0000664�0000000�0000000�00000005731�15100345067�0023302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE USER regress_merge_privs; CREATE USER regress_merge_no_privs; DROP TABLE IF EXISTS target; DROP TABLE IF EXISTS source; CREATE TABLE target (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target', 'tid', chunk_time_interval => 3); CREATE TABLE source (sid integer, delta integer) -- no index WITH (autovacuum_enabled=off); INSERT INTO target VALUES (1, 10); INSERT INTO target VALUES (2, 20); INSERT INTO target VALUES (3, 30); SELECT t.ctid is not null as matched, t.*, s.* FROM source s FULL OUTER JOIN target t ON s.sid = t.tid ORDER BY t.tid, s.sid; ALTER TABLE target OWNER TO regress_merge_privs; ALTER TABLE source OWNER TO regress_merge_privs; CREATE TABLE target2 (tid integer, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('target2', 'tid', chunk_time_interval => 3); CREATE TABLE source2 (sid integer, delta integer) WITH (autovacuum_enabled=off); ALTER TABLE target2 OWNER TO regress_merge_no_privs; ALTER TABLE source2 OWNER TO regress_merge_no_privs; GRANT INSERT ON target TO regress_merge_no_privs; GRANT CREATE ON SCHEMA public TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; CREATE TABLE sq_target (tid integer NOT NULL, balance integer) WITH (autovacuum_enabled=off); SELECT create_hypertable('sq_target', 'tid', chunk_time_interval => 3); CREATE TABLE sq_source (delta integer, sid integer, balance integer DEFAULT 0) WITH (autovacuum_enabled=off); INSERT INTO sq_target(tid, balance) VALUES (1,100), (2,200), (3,300); INSERT INTO sq_source(sid, delta) VALUES (1,10), (2,20), (4,40); -- conditional WHEN clause CREATE TABLE wq_target (tid integer not null, balance integer DEFAULT -1) WITH (autovacuum_enabled=off); SELECT create_hypertable('wq_target', 'tid', chunk_time_interval => 3); CREATE TABLE wq_source (balance integer, sid integer) WITH (autovacuum_enabled=off); INSERT INTO wq_source (sid, balance) VALUES (1, 100); -- some complex joins on the source side CREATE TABLE cj_target (tid integer, balance float, val text) WITH (autovacuum_enabled=off); SELECT create_hypertable('cj_target', 'tid', chunk_time_interval => 3); CREATE TABLE cj_source1 (sid1 integer, scat integer, delta integer) WITH (autovacuum_enabled=off); CREATE TABLE cj_source2 (sid2 integer, sval text) WITH (autovacuum_enabled=off); INSERT INTO cj_source1 VALUES (1, 10, 100); INSERT INTO cj_source1 VALUES (1, 20, 200); INSERT INTO cj_source1 VALUES (2, 20, 300); INSERT INTO cj_source1 VALUES (3, 10, 400); INSERT INTO cj_source2 VALUES (1, 'initial source2'); INSERT INTO cj_source2 VALUES (2, 'initial source2'); INSERT INTO cj_source2 VALUES (3, 'initial source2'); CREATE TABLE fs_target (a int, b int, c text) WITH (autovacuum_enabled=off); SELECT create_hypertable('fs_target', 'a', chunk_time_interval => 3);���������������������������������������timescaledb-2.23.0/test/sql/include/ts_merge_query.sql����������������������������������������������0000664�0000000�0000000�00000105067�15100345067�0023040�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Errors -- MERGE INTO target t RANDOMWORD USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; -- MATCHED/INSERT error MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN INSERT DEFAULT VALUES; -- incorrectly specifying INTO target MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT INTO target DEFAULT VALUES; -- Multiple VALUES clause MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (1,1), (2,2); -- SELECT query for INSERT MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT SELECT (1, 1); -- NOT MATCHED/UPDATE MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN UPDATE SET balance = 0; -- UPDATE tablename MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE target SET balance = 0; -- source and target names the same MERGE INTO target USING target ON tid = tid WHEN MATCHED THEN DO NOTHING; -- used in a CTE WITH foo AS ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) SELECT * FROM foo; -- used in COPY COPY ( MERGE INTO target USING source ON (true) WHEN MATCHED THEN DELETE ) TO stdout; -- unsupported relation types -- view CREATE VIEW tv AS SELECT * FROM target; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; DROP VIEW tv; -- materialized view CREATE MATERIALIZED VIEW mv AS SELECT * FROM target; MERGE INTO mv t USING source s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; DROP MATERIALIZED VIEW mv; -- permissions MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; GRANT INSERT ON target TO regress_merge_no_privs; SET SESSION AUTHORIZATION regress_merge_no_privs; MERGE INTO target USING source2 ON target.tid = source2.sid WHEN MATCHED THEN UPDATE SET balance = 0; GRANT UPDATE ON target2 TO regress_merge_privs; SET SESSION AUTHORIZATION regress_merge_privs; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN MATCHED THEN DELETE; MERGE INTO target2 USING source ON target2.tid = source.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; -- check if the target can be accessed from source relation subquery; we should -- not be able to do so MERGE INTO target t USING (SELECT * FROM source WHERE t.tid > sid) s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; -- -- initial tests -- -- zero rows in source has no effect MERGE INTO target USING source ON target.tid = source.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT DEFAULT VALUES; ROLLBACK; -- insert some non-matching source rows to work from INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN DO NOTHING; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (5, 50); SELECT * FROM target ORDER BY tid; ROLLBACK; -- index plans INSERT INTO target SELECT generate_series(1000,2500), 0; ALTER TABLE target ADD PRIMARY KEY (tid); ANALYZE target; DELETE FROM target WHERE tid > 100; ANALYZE target; -- insert some matching source rows to work from INSERT INTO source VALUES (2, 5); INSERT INTO source VALUES (3, 20); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- equivalent of a DELETE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DO NOTHING; SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- duplicate source row causes multiple target row update ERROR INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0; ROLLBACK; BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN DELETE; ROLLBACK; -- remove duplicate MATCHED data from source data DELETE FROM source WHERE sid = 2; INSERT INTO source VALUES (2, 5); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- duplicate source row on INSERT should fail because of target_pkey INSERT INTO source VALUES (4, 40); BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, NULL); SELECT * FROM target ORDER BY tid; ROLLBACK; -- remove duplicate NOT MATCHED data from source data DELETE FROM source WHERE sid = 4; INSERT INTO source VALUES (4, 40); SELECT * FROM source ORDER BY sid; SELECT * FROM target ORDER BY tid; -- remove constraints alter table target drop CONSTRAINT target_pkey; alter table target alter column tid drop not null; -- multiple actions BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (4, 4) WHEN MATCHED THEN UPDATE SET balance = 0; SELECT * FROM target ORDER BY tid; ROLLBACK; -- should be equivalent BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = 0 WHEN NOT MATCHED THEN INSERT VALUES (4, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- column references -- do a simple equivalent of an UPDATE join BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta; SELECT * FROM target ORDER BY tid; ROLLBACK; -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with duplicate source rows INSERT INTO source VALUES (5, 50); INSERT INTO source VALUES (5, 50); -- do a simple equivalent of an INSERT SELECT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- removing duplicate source rows DELETE FROM source WHERE sid = 5; -- and again with explicitly identified column list BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- and again with a subtle error: referring to non-existent target row for NOT MATCHED MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); -- and again with a constant ON clause BEGIN; MERGE INTO target t USING source AS s ON (SELECT true) WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (t.tid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- now the classic UPSERT BEGIN; MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance + s.delta WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- this time with a FALSE condition MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND FALSE THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- this time with an actual condition which returns false MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance <> 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; BEGIN; -- and now with a condition which returns true MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; -- conditions in the NOT MATCHED clause can only refer to source columns BEGIN; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND t.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; ROLLBACK; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN NOT MATCHED AND s.balance = 100 THEN INSERT (tid) VALUES (s.sid); SELECT * FROM wq_target; -- conditions in MATCHED clause can refer to both source and target SELECT * FROM wq_source; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if AND works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 AND s.balance = 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check if OR works MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 99 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance = 199 OR s.balance > 100 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; -- check source-side whole-row references BEGIN; MERGE INTO wq_target t USING wq_source s ON (t.tid = s.sid) WHEN matched and t = s or t.tid = s.sid THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; ROLLBACK; -- check if subqueries work in the conditions? MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.balance > (SELECT max(balance) FROM target) THEN UPDATE SET balance = t.balance + s.balance; -- check if we can access system columns in the conditions MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.xmin = t.xmax THEN UPDATE SET balance = t.balance + s.balance; MERGE INTO wq_target t USING wq_source s ON t.tid = s.sid WHEN MATCHED AND t.tableoid >= 0 THEN UPDATE SET balance = t.balance + s.balance; SELECT * FROM wq_target; DROP TABLE wq_target CASCADE; DROP TABLE wq_source; -- test triggers create or replace function merge_trigfunc () returns trigger language plpgsql as $$ DECLARE line text; BEGIN SELECT INTO line format('%s %s %s trigger%s', TG_WHEN, TG_OP, TG_LEVEL, CASE WHEN TG_OP = 'INSERT' AND TG_LEVEL = 'ROW' THEN format(' row: %s', NEW) WHEN TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW' THEN format(' row: %s -> %s', OLD, NEW) WHEN TG_OP = 'DELETE' AND TG_LEVEL = 'ROW' THEN format(' row: %s', OLD) END); RAISE NOTICE '%', line; IF (TG_WHEN = 'BEFORE' AND TG_LEVEL = 'ROW') THEN IF (TG_OP = 'DELETE') THEN RETURN OLD; ELSE RETURN NEW; END IF; ELSE RETURN NULL; END IF; END; $$; CREATE TRIGGER merge_bsi BEFORE INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsu BEFORE UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bsd BEFORE DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asi AFTER INSERT ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asu AFTER UPDATE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_asd AFTER DELETE ON target FOR EACH STATEMENT EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bri BEFORE INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_bru BEFORE UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_brd BEFORE DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ari AFTER INSERT ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_aru AFTER UPDATE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); CREATE TRIGGER merge_ard AFTER DELETE ON target FOR EACH ROW EXECUTE PROCEDURE merge_trigfunc (); -- now the classic UPSERT, with a DELETE BEGIN; UPDATE target SET balance = 0 WHERE tid = 3; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- Test behavior of triggers that turn UPDATE/DELETE into no-ops create or replace function skip_merge_op() returns trigger language plpgsql as $$ BEGIN RETURN NULL; END; $$; SELECT * FROM target full outer join source on (sid = tid); create trigger merge_skip BEFORE INSERT OR UPDATE or DELETE ON target FOR EACH ROW EXECUTE FUNCTION skip_merge_op(); DO $$ DECLARE result integer; BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND s.sid = 3 THEN UPDATE SET balance = t.balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES (sid, delta); IF FOUND THEN RAISE NOTICE 'Found'; ELSE RAISE NOTICE 'Not found'; END IF; GET DIAGNOSTICS result := ROW_COUNT; RAISE NOTICE 'ROW_COUNT = %', result; END; $$; SELECT * FROM target FULL OUTER JOIN source ON (sid = tid); DROP TRIGGER merge_skip ON target; DROP FUNCTION skip_merge_op(); -- test from PL/pgSQL -- make sure MERGE INTO isn't interpreted to mean returning variables like SELECT INTO BEGIN; DO LANGUAGE plpgsql $$ BEGIN MERGE INTO target t USING source AS s ON t.tid = s.sid WHEN MATCHED AND t.balance > s.delta THEN UPDATE SET balance = t.balance - s.delta; END; $$; ROLLBACK; --source constants BEGIN; MERGE INTO target t USING (SELECT 9 AS sid, 57 AS delta) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; --source query BEGIN; MERGE INTO target t USING (SELECT sid, delta FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, delta as newname FROM source WHERE delta > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.newname); SELECT * FROM target ORDER BY tid; ROLLBACK; --self-merge BEGIN; MERGE INTO target t1 USING target t2 ON t1.tid = t2.tid WHEN MATCHED THEN UPDATE SET balance = t1.balance + t2.balance WHEN NOT MATCHED THEN INSERT VALUES (t2.tid, t2.balance); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT tid as sid, balance as delta FROM target WHERE balance > 0) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; BEGIN; MERGE INTO target t USING (SELECT sid, max(delta) AS delta FROM source GROUP BY sid HAVING count(*) = 1 ORDER BY sid ASC) AS s ON t.tid = s.sid WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (s.sid, s.delta); SELECT * FROM target ORDER BY tid; ROLLBACK; -- plpgsql parameters and results BEGIN; CREATE FUNCTION merge_func (p_id integer, p_bal integer) RETURNS INTEGER LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO target t USING (SELECT p_id AS sid) AS s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = t.balance - p_bal; IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(3, 4); SELECT * FROM target ORDER BY tid; ROLLBACK; -- PREPARE BEGIN; prepare foom as merge into target t using (select 1 as sid) s on (t.tid = s.sid) when matched then update set balance = 1; execute foom; ROLLBACK; BEGIN; PREPARE foom2 (integer, integer) AS MERGE INTO target t USING (SELECT 1) s ON t.tid = $1 WHEN MATCHED THEN UPDATE SET balance = $2; --EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) execute foom2 (1, 1); ROLLBACK; -- subqueries in source relation BEGIN; MERGE INTO sq_target t USING (SELECT * FROM sq_source) s ON tid = sid WHEN MATCHED AND t.balance > delta THEN UPDATE SET balance = t.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- try a view CREATE VIEW v AS SELECT * FROM sq_source WHERE sid < 2; BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = v.balance + delta; SELECT * FROM sq_target ORDER BY tid; ROLLBACK; -- ambiguous reference to a column BEGIN; MERGE INTO sq_target USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; SELECT * FROM sq_target; ROLLBACK; -- CTEs BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); WITH targq AS ( SELECT * FROM v ) MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE; ROLLBACK; -- RETURNING BEGIN; INSERT INTO sq_source (sid, balance, delta) VALUES (-1, -1, -10); MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND tid > 2 THEN UPDATE SET balance = t.balance + delta WHEN NOT MATCHED THEN INSERT (balance, tid) VALUES (balance + delta, sid) WHEN MATCHED AND tid < 2 THEN DELETE RETURNING *; ROLLBACK; -- PG17-specific tests for views, returning and merge_action. These throw syntax errors for previous versions of Postgres. -- However, since the error is the same for both hypertables and regular tables, this test should still pass for previous versions. -- RETURNING INSERT INTO source(sid, delta) VALUES(1, 40), (5, 50); BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from target; ROLLBACK; BEGIN; MERGE INTO target t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 1 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; -- Views CREATE VIEW tv AS SELECT * FROM target; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta); SELECT * from tv; SELECT * from target; -- should also update the underlying table ROLLBACK; BEGIN; MERGE INTO tv t USING source s ON t.tid = s.sid WHEN MATCHED AND tid > 2 THEN UPDATE set balance = balance + s.delta WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (tid, balance) VALUES (sid, delta) RETURNING merge_action(), t.*; ROLLBACK; DROP VIEW tv; DELETE FROM source where sid in (1, 5); -- EXPLAIN CREATE TABLE ex_mtarget (a int, b int) WITH (autovacuum_enabled=off); CREATE TABLE ex_msource (a int, b int) WITH (autovacuum_enabled=off); INSERT INTO ex_mtarget SELECT i, i*10 FROM generate_series(1,100,2) i; INSERT INTO ex_msource SELECT i, i*10 FROM generate_series(1,100,1) i; CREATE FUNCTION explain_merge(query text) RETURNS SETOF text LANGUAGE plpgsql AS $$ DECLARE ln text; BEGIN FOR ln IN EXECUTE 'explain (analyze, timing off, summary off, buffers off, costs off) ' || query LOOP ln := regexp_replace(ln, '(Memory( Usage)?|Buckets|Batches): \S*', '\1: xxx', 'g'); RETURN NEXT ln; END LOOP; END; $$; -- only updates SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED THEN UPDATE SET b = t.b + 1'); -- only updates to selected tuples SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1'); -- updates + deletes SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 10 AND t.a <= 20 THEN DELETE'); -- only inserts SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN NOT MATCHED AND s.a < 10 THEN INSERT VALUES (a, b)'); -- all three SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a WHEN MATCHED AND t.a < 10 THEN UPDATE SET b = t.b + 1 WHEN MATCHED AND t.a >= 30 AND t.a <= 40 THEN DELETE WHEN NOT MATCHED AND s.a < 20 THEN INSERT VALUES (a, b)'); -- nothing SELECT explain_merge(' MERGE INTO ex_mtarget t USING ex_msource s ON t.a = s.a AND t.a < -1000 WHEN MATCHED AND t.a < 10 THEN DO NOTHING'); DROP TABLE ex_msource, ex_mtarget; DROP FUNCTION explain_merge(text); -- Subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED THEN UPDATE SET balance = (SELECT count(*) FROM sq_target); SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid WHEN MATCHED AND (SELECT count(*) > 0 FROM sq_target) THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; -- Test RETURNING with subqueries BEGIN; MERGE INTO sq_target t USING v ON tid = sid AND (SELECT count(*) > 0 FROM sq_target) WHEN MATCHED THEN UPDATE SET balance = 42 RETURNING *; SELECT * FROM sq_target WHERE tid = 1; ROLLBACK; DROP TABLE sq_target CASCADE; DROP TABLE sq_source CASCADE; CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 PARTITION OF pa_target FOR VALUES IN (1,4) WITH (autovacuum_enabled=off); CREATE TABLE part2 PARTITION OF pa_target FOR VALUES IN (2,5,6) WITH (autovacuum_enabled=off); CREATE TABLE part3 PARTITION OF pa_target FOR VALUES IN (3,8,9) WITH (autovacuum_enabled=off); CREATE TABLE part4 PARTITION OF pa_target DEFAULT WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid = 1 WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; CREATE FUNCTION merge_func() RETURNS integer LANGUAGE plpgsql AS $$ DECLARE result integer; BEGIN MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); IF FOUND THEN GET DIAGNOSTICS result := ROW_COUNT; END IF; RETURN result; END; $$; SELECT merge_func(); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_target CASCADE; -- The target table is partitioned in the same way, but this time by attaching -- partitions which have columns in different order, dropped columns etc. CREATE TABLE pa_target (tid integer, balance float, val text) PARTITION BY LIST (tid); CREATE TABLE part1 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part2 (balance float, tid integer, val text) WITH (autovacuum_enabled=off); CREATE TABLE part3 (tid integer, balance float, val text) WITH (autovacuum_enabled=off); CREATE TABLE part4 (extraid text, tid integer, balance float, val text) WITH (autovacuum_enabled=off); ALTER TABLE part4 DROP COLUMN extraid; ALTER TABLE pa_target ATTACH PARTITION part1 FOR VALUES IN (1,4); ALTER TABLE pa_target ATTACH PARTITION part2 FOR VALUES IN (2,5,6); ALTER TABLE pa_target ATTACH PARTITION part3 FOR VALUES IN (3,8,9); ALTER TABLE pa_target ATTACH PARTITION part4 DEFAULT; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT id, id * 100, 'initial' FROM generate_series(1,14,2) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- same with a constant qual BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid AND tid IN (1, 5) WHEN MATCHED AND tid % 5 = 0 THEN DELETE WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; -- try updating the partition key column BEGIN; MERGE INTO pa_target t USING pa_source s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET tid = tid + 1, balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- Sub-partitioning CREATE TABLE pa_target (logts timestamp, tid integer, balance float, val text) PARTITION BY RANGE (logts); CREATE TABLE part_m01 PARTITION OF pa_target FOR VALUES FROM ('2017-01-01') TO ('2017-02-01') PARTITION BY LIST (tid); CREATE TABLE part_m01_odd PARTITION OF part_m01 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m01_even PARTITION OF part_m01 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE part_m02 PARTITION OF pa_target FOR VALUES FROM ('2017-02-01') TO ('2017-03-01') PARTITION BY LIST (tid); CREATE TABLE part_m02_odd PARTITION OF part_m02 FOR VALUES IN (1,3,5,7,9) WITH (autovacuum_enabled=off); CREATE TABLE part_m02_even PARTITION OF part_m02 FOR VALUES IN (2,4,6,8) WITH (autovacuum_enabled=off); CREATE TABLE pa_source (sid integer, delta float) WITH (autovacuum_enabled=off); -- insert many rows to the source table INSERT INTO pa_source SELECT id, id * 10 FROM generate_series(1,14) AS id; -- insert a few rows in the target table (odd numbered tid) INSERT INTO pa_target SELECT '2017-01-31', id, id * 100, 'initial' FROM generate_series(1,9,3) AS id; INSERT INTO pa_target SELECT '2017-02-28', id, id * 100, 'initial' FROM generate_series(2,9,3) AS id; -- try simple MERGE BEGIN; MERGE INTO pa_target t USING (SELECT '2017-01-15' AS slogts, * FROM pa_source WHERE sid < 10) s ON t.tid = s.sid WHEN MATCHED THEN UPDATE SET balance = balance + delta, val = val || ' updated by merge' WHEN NOT MATCHED THEN INSERT VALUES (slogts::timestamp, sid, delta, 'inserted by merge'); SELECT * FROM pa_target ORDER BY tid; ROLLBACK; DROP TABLE pa_source; DROP TABLE pa_target CASCADE; -- some complex joins on the source side -- source relation is an unaliased join MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid1, delta, sval); -- try accessing columns from either side of the source join MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta, sval) WHEN MATCHED THEN DELETE; -- some simple expressions in INSERT targetlist MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 ON t.tid = sid1 WHEN NOT MATCHED THEN INSERT VALUES (sid2, delta + scat, sval) WHEN MATCHED THEN UPDATE SET val = val || ' updated by merge'; MERGE INTO cj_target t USING cj_source2 s2 INNER JOIN cj_source1 s1 ON sid1 = sid2 AND scat = 20 ON t.tid = sid1 WHEN MATCHED THEN UPDATE SET val = val || ' ' || delta::text; SELECT * FROM cj_target ORDER BY tid; ALTER TABLE cj_source1 RENAME COLUMN sid1 TO sid; ALTER TABLE cj_source2 RENAME COLUMN sid2 TO sid; TRUNCATE cj_target; MERGE INTO cj_target t USING cj_source1 s1 INNER JOIN cj_source2 s2 ON s1.sid = s2.sid ON t.tid = s1.sid WHEN NOT MATCHED THEN INSERT VALUES (s2.sid, delta, sval); DROP TABLE cj_source2, cj_source1; DROP TABLE cj_target CASCADE; -- Function scans MERGE INTO fs_target t USING generate_series(1,100,1) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id WHEN NOT MATCHED THEN INSERT VALUES (id, -1); MERGE INTO fs_target t USING generate_series(1,100,2) AS id ON t.a = id WHEN MATCHED THEN UPDATE SET b = b + id, c = 'updated '|| id.*::text WHEN NOT MATCHED THEN INSERT VALUES (id, -1, 'inserted ' || id.*::text); SELECT count(*) FROM fs_target; DROP TABLE fs_target CASCADE; -- SERIALIZABLE test -- handled in isolation tests -- Inheritance-based partitioning CREATE TABLE measurement ( city_id int not null, logdate date not null, peaktemp int, unitsales int ) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m02 ( CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2006m03 ( CHECK ( logdate >= DATE '2006-03-01' AND logdate < DATE '2006-04-01' ) ) INHERITS (measurement) WITH (autovacuum_enabled=off); CREATE TABLE measurement_y2007m01 ( filler text, peaktemp int, logdate date not null, city_id int not null, unitsales int CHECK ( logdate >= DATE '2007-01-01' AND logdate < DATE '2007-02-01') ) WITH (autovacuum_enabled=off); ALTER TABLE measurement_y2007m01 DROP COLUMN filler; ALTER TABLE measurement_y2007m01 INHERIT measurement; INSERT INTO measurement VALUES (0, '2005-07-21', 5, 15); CREATE OR REPLACE FUNCTION measurement_insert_trigger() RETURNS TRIGGER AS $$ BEGIN IF ( NEW.logdate >= DATE '2006-02-01' AND NEW.logdate < DATE '2006-03-01' ) THEN INSERT INTO measurement_y2006m02 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2006-03-01' AND NEW.logdate < DATE '2006-04-01' ) THEN INSERT INTO measurement_y2006m03 VALUES (NEW.*); ELSIF ( NEW.logdate >= DATE '2007-01-01' AND NEW.logdate < DATE '2007-02-01' ) THEN INSERT INTO measurement_y2007m01 (city_id, logdate, peaktemp, unitsales) VALUES (NEW.*); ELSE RAISE EXCEPTION 'Date out of range. Fix the measurement_insert_trigger() function!'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql ; CREATE TRIGGER insert_measurement_trigger BEFORE INSERT ON measurement FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); INSERT INTO measurement VALUES (1, '2006-02-10', 35, 10); INSERT INTO measurement VALUES (1, '2006-02-16', 45, 20); INSERT INTO measurement VALUES (1, '2006-03-17', 25, 10); INSERT INTO measurement VALUES (1, '2006-03-27', 15, 40); INSERT INTO measurement VALUES (1, '2007-01-15', 10, 10); INSERT INTO measurement VALUES (1, '2007-01-17', 10, 10); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; CREATE TABLE new_measurement (LIKE measurement) WITH (autovacuum_enabled=off); INSERT INTO new_measurement VALUES (0, '2005-07-21', 25, 20); INSERT INTO new_measurement VALUES (1, '2006-03-01', 20, 10); INSERT INTO new_measurement VALUES (1, '2006-02-16', 50, 10); INSERT INTO new_measurement VALUES (2, '2006-02-10', 20, 20); INSERT INTO new_measurement VALUES (1, '2006-03-27', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-17', NULL, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-15', 5, NULL); INSERT INTO new_measurement VALUES (1, '2007-01-16', 10, 10); BEGIN; MERGE INTO ONLY measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate, peaktemp; ROLLBACK; MERGE into measurement m USING new_measurement nm ON (m.city_id = nm.city_id and m.logdate=nm.logdate) WHEN MATCHED AND nm.peaktemp IS NULL THEN DELETE WHEN MATCHED THEN UPDATE SET peaktemp = greatest(m.peaktemp, nm.peaktemp), unitsales = m.unitsales + coalesce(nm.unitsales, 0) WHEN NOT MATCHED THEN INSERT (city_id, logdate, peaktemp, unitsales) VALUES (city_id, logdate, peaktemp, unitsales); SELECT tableoid::regclass, * FROM measurement ORDER BY city_id, logdate; BEGIN; MERGE INTO new_measurement nm USING ONLY measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; ROLLBACK; MERGE INTO new_measurement nm USING measurement m ON (nm.city_id = m.city_id and nm.logdate=m.logdate) WHEN MATCHED THEN DELETE; SELECT * FROM new_measurement ORDER BY city_id, logdate; DROP TABLE measurement, new_measurement CASCADE; DROP FUNCTION measurement_insert_trigger(); RESET SESSION AUTHORIZATION; DROP TABLE target CASCADE; DROP TABLE target2 CASCADE; DROP TABLE source, source2; DROP FUNCTION merge_trigfunc(); REVOKE CREATE ON SCHEMA public FROM regress_merge_privs; DROP USER regress_merge_privs; DROP USER regress_merge_no_privs; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/index.sql���������������������������������������������������������������0000664�0000000�0000000�00000033507�15100345067�0017471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE index_test(time timestamptz, temp float); SELECT create_hypertable('index_test', 'time'); -- Default indexes created SELECT * FROM test.show_indexes('index_test'); DROP TABLE index_test; CREATE TABLE index_test(time timestamptz, device integer, temp float); -- Create index before create_hypertable() CREATE UNIQUE INDEX index_test_time_idx ON index_test (time); \set ON_ERROR_STOP 0 -- Creating a hypertable from a table with an index that doesn't cover -- all partitioning columns should fail SELECT create_hypertable('index_test', 'time', 'device', 2); \set ON_ERROR_STOP 1 -- Partitioning on only time should work SELECT create_hypertable('index_test', 'time'); INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 1, 17.5); -- Check that index is also created on chunk SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Create another chunk INSERT INTO index_test VALUES ('2017-05-20T09:00:01', 3, 17.5); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Delete the index on only one chunk DROP INDEX _timescaledb_internal._hyper_3_1_chunk_index_test_time_idx; SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Recreate table with new partitioning DROP TABLE index_test; CREATE TABLE index_test(id serial, time timestamptz, device integer, temp float); SELECT * FROM test.show_columns('index_test'); -- Test that we can handle difference in attnos across hypertable and -- chunks by dropping the ID column ALTER TABLE index_test DROP COLUMN id; SELECT * FROM test.show_columns('index_test'); -- No pre-existing UNIQUE index, so partitioning on two columns should work SELECT create_hypertable('index_test', 'time', 'device', 2); INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 1, 17.5); \set ON_ERROR_STOP 0 -- Create unique index without all partitioning columns should fail CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time); \set ON_ERROR_STOP 1 CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time, device); -- Regular index need not cover all partitioning columns CREATE INDEX ON index_test (time, temp); -- Create another chunk INSERT INTO index_test VALUES ('2017-04-20T09:00:01', 1, 17.5); -- New index should have been recursed to chunks SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); ALTER INDEX index_test_time_idx RENAME TO index_test_time_idx2; -- Metadata and index should have changed name SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); DROP INDEX index_test_time_idx2; DROP INDEX index_test_time_device_idx; -- Index should have been dropped SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Create index with long name to see how this is handled on chunks CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates ON index_test (time DESC, temp); CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2 ON index_test (time DESC, temp DESC); SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates; DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2; \set ON_ERROR_STOP 0 -- Create index CONCURRENTLY CREATE UNIQUE INDEX CONCURRENTLY index_test_time_device_idx ON index_test (time, device); \set ON_ERROR_STOP 1 -- Test tablespaces. Chunk indexes should end up in same tablespace as -- main index. \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; SET client_min_messages = NOTICE; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE INDEX index_test_time_idx ON index_test (time) TABLESPACE tablespace1; SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ALTER INDEX index_test_time_idx SET TABLESPACE tablespace2; SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Add constraint index ALTER TABLE index_test ADD UNIQUE (time, device); SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Constraints are added to chunk_constraint table. SELECT * FROM _timescaledb_catalog.chunk_constraint; DROP TABLE index_test; -- Create table in a tablespace CREATE TABLE index_test(time timestamptz, temp float, device int) TABLESPACE tablespace1; -- Default indexes should be in the table's tablespace SELECT create_hypertable('index_test', 'time'); -- Explicitly defining an index tablespace should work and propagate -- to chunks CREATE INDEX ON index_test (time, device) TABLESPACE tablespace2; -- New indexes without explicit tablespaces should use the default -- tablespace CREATE INDEX ON index_test (device); -- Create chunk INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 17.5); -- Check that the tablespaces of chunk indexes match the tablespace of -- the main index SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Creating a new index should propagate to existing chunks, including -- the given tablespace CREATE INDEX ON index_test (time, temp) TABLESPACE tablespace2; SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Cleanup DROP TABLE index_test CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Test expression indexes CREATE TABLE index_expr_test(id serial, time timestamptz, temp float, meta jsonb); -- Screw up the attribute numbers ALTER TABLE index_expr_test DROP COLUMN id; CREATE INDEX ON index_expr_test ((meta ->> 'field')) ; INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, '{"field": "value1"}'); INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, '{"field": "value2"}'); EXPLAIN (verbose, buffers off, costs off) SELECT * FROM index_expr_test WHERE meta ->> 'field' = 'value1'; SELECT * FROM index_expr_test WHERE meta ->> 'field' = 'value1'; -- Test INDEX DROP error for multiple objects CREATE TABLE index_test(time timestamptz, temp float); CREATE UNIQUE INDEX index_test_idx ON index_test (time, temp); SELECT create_hypertable('index_test', 'time'); CREATE TABLE index_test_2(time timestamptz, temp float); CREATE UNIQUE INDEX index_test_2_idx ON index_test_2 (time, temp); \set ON_ERROR_STOP 0 DROP INDEX index_test_idx, index_test_2_idx; \set ON_ERROR_STOP 1 -- test expression index with dropped columns CREATE TABLE idx_expr_test(filler int, time timestamptz, meta text); SELECT table_name FROM create_hypertable('idx_expr_test', 'time'); ALTER TABLE idx_expr_test DROP COLUMN filler; CREATE INDEX tag_idx ON idx_expr_test(('foo'||meta)); INSERT INTO idx_expr_test(time, meta) VALUES ('2000-01-01', 'bar'); DROP TABLE idx_expr_test CASCADE; -- test multicolumn expression index with dropped columns CREATE TABLE idx_expr_test(filler int, time timestamptz, t1 text, t2 text, t3 text); SELECT table_name FROM create_hypertable('idx_expr_test', 'time'); ALTER TABLE idx_expr_test DROP COLUMN filler; CREATE INDEX tag_idx ON idx_expr_test((t1||t2||t3)); INSERT INTO idx_expr_test(time, t1, t2, t3) VALUES ('2000-01-01', 'foo', 'bar', 'baz'); DROP TABLE idx_expr_test CASCADE; -- test index with predicate and dropped columns CREATE TABLE idx_predicate_test(filler int, time timestamptz); SELECT table_name FROM create_hypertable('idx_predicate_test', 'time'); ALTER TABLE idx_predicate_test DROP COLUMN filler; ALTER TABLE idx_predicate_test ADD COLUMN b1 bool; CREATE INDEX idx_predicate_test_b1 ON idx_predicate_test(b1) WHERE b1=true; INSERT INTO idx_predicate_test VALUES ('2000-01-01',true); DROP TABLE idx_predicate_test; -- test index with table references CREATE TABLE idx_tableref_test(time timestamptz); SELECT table_name FROM create_hypertable('idx_tableref_test', 'time'); -- we use security definer to prevent function inlining CREATE OR REPLACE FUNCTION tableref_func(t idx_tableref_test) RETURNS timestamptz LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $f$ SELECT t.time; $f$; -- try creating index with no existing chunks CREATE INDEX tableref_idx ON idx_tableref_test(tableref_func(idx_tableref_test)); -- insert data to trigger chunk creation INSERT INTO idx_tableref_test SELECT '2000-01-01'; DROP INDEX tableref_idx; -- try creating index on hypertable with existing chunks CREATE INDEX tableref_idx ON idx_tableref_test(tableref_func(idx_tableref_test)); -- test index creation with if not exists CREATE TABLE idx_exists(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('idx_exists', 'time'); -- should be skipped since this index was already created by create_hypertable CREATE INDEX IF NOT EXISTS idx_exists_time_idx ON idx_exists(time DESC); -- should create index CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); -- should be skipped since it was created in previous command CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); DROP INDEX idx_exists_time_asc_idx; INSERT INTO idx_exists VALUES ('2000-01-01'),('2001-01-01'); -- should create index CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); -- should be skipped since it was created in previous command CREATE INDEX IF NOT EXISTS idx_exists_time_asc_idx ON idx_exists(time ASC); -- test reindex CREATE TABLE reindex_test(time timestamp, temp float, PRIMARY KEY(time, temp)); CREATE UNIQUE INDEX reindex_test_time_unique_idx ON reindex_test(time); -- create hypertable with three chunks SELECT create_hypertable('reindex_test', 'time', chunk_time_interval => 2628000000000); INSERT INTO reindex_test VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); SELECT * FROM test.show_columns('reindex_test'); SELECT * FROM test.show_subtables('reindex_test'); -- show reindexing REINDEX (VERBOSE) TABLE reindex_test; \set ON_ERROR_STOP 0 -- REINDEX TABLE CONCURRENTLY on hypertables is not supported REINDEX TABLE CONCURRENTLY reindex_test; -- this one currently doesn't recurse to chunks and instead gives an -- error REINDEX (VERBOSE) INDEX reindex_test_time_unique_idx; \set ON_ERROR_STOP 1 -- show reindexing on a normal table CREATE TABLE reindex_norm(time timestamp, temp float); CREATE UNIQUE INDEX reindex_norm_time_unique_idx ON reindex_norm(time); INSERT INTO reindex_norm VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); REINDEX (VERBOSE) TABLE reindex_norm; REINDEX (VERBOSE) INDEX reindex_norm_time_unique_idx; SELECT * FROM test.show_constraintsp('_timescaledb_internal._hyper_12%'); SELECT * FROM reindex_norm; CREATE TABLE ht_dropped(time timestamptz, d0 int, d1 int, c0 int, c1 int, c2 int); SELECT create_hypertable('ht_dropped','time'); INSERT INTO ht_dropped(time,c0,c1,c2) SELECT '2000-01-01',1,2,3; ALTER TABLE ht_dropped DROP COLUMN d0; INSERT INTO ht_dropped(time,c0,c1,c2) SELECT '2001-01-01',1,2,3; ALTER TABLE ht_dropped DROP COLUMN d1; INSERT INTO ht_dropped(time,c0,c1,c2) SELECT '2002-01-01',1,2,3; CREATE INDEX ON ht_dropped(c0,c1,c2) WHERE c1 IS NOT NULL; CREATE INDEX ON ht_dropped(c0,c1,c2) WITH(timescaledb.transaction_per_chunk) WHERE c2 IS NOT NULL; SELECT oid::TEXT AS "Chunk", i.* FROM (SELECT tableoid::REGCLASS FROM ht_dropped GROUP BY tableoid) ch (oid) LEFT JOIN LATERAL ( SELECT * FROM test.show_indexes (ch.oid)) i ON TRUE ORDER BY 1, 2; -- #3056 check chunk index column name mapping CREATE TABLE i3056(c int, order_number int NOT NULL, date_created timestamptz NOT NULL); CREATE INDEX ON i3056(order_number) INCLUDE(order_number); CREATE INDEX ON i3056(date_created, (order_number % 5)) INCLUDE(order_number); SELECT table_name FROM create_hypertable('i3056', 'date_created'); ALTER TABLE i3056 DROP COLUMN c; INSERT INTO i3056(order_number,date_created) VALUES (1, '2000-01-01'); -- #5908 test CREATE INDEX ON ONLY main table CREATE TABLE test(time timestamptz, temp float); SELECT create_hypertable('test', 'time'); INSERT INTO test (time,temp) VALUES (generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::float); SELECT * FROM show_chunks('test'); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_15_21_chunk'); -- create index per chunk CREATE INDEX _hyper_15_21_chunk_test_temp_idx ON _timescaledb_internal._hyper_15_21_chunk(temp); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_15_21_chunk'); SELECT * FROM test.show_indexes('test'); -- create index only on main table CREATE INDEX test_temp_idx ON ONLY test (time); SELECT * FROM test.show_indexes('test'); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_15_21_chunk'); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/information_views.sql���������������������������������������������������0000664�0000000�0000000�00000006543�15100345067�0022124�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT * FROM timescaledb_information.hypertables; -- create simple hypertable with 1 chunk CREATE TABLE ht1(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('ht1','time'); INSERT INTO ht1 SELECT '2000-01-01'::TIMESTAMPTZ; -- create simple hypertable with 1 chunk and toasted data CREATE TABLE ht2(time TIMESTAMPTZ NOT NULL, data TEXT); SELECT create_hypertable('ht2','time'); INSERT INTO ht2 SELECT '2000-01-01'::TIMESTAMPTZ, repeat('8k',4096); SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; \c :TEST_DBNAME :ROLE_SUPERUSER -- create schema open and hypertable with 3 chunks CREATE SCHEMA open; GRANT USAGE ON SCHEMA open TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE open.open_ht(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('open.open_ht','time'); INSERT INTO open.open_ht SELECT '2000-01-01'::TIMESTAMPTZ; INSERT INTO open.open_ht SELECT '2001-01-01'::TIMESTAMPTZ; INSERT INTO open.open_ht SELECT '2002-01-01'::TIMESTAMPTZ; -- create schema closed and hypertable CREATE SCHEMA closed; CREATE TABLE closed.closed_ht(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('closed.closed_ht','time'); INSERT INTO closed.closed_ht SELECT '2000-01-01'::TIMESTAMPTZ; SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 0 \x SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; -- filter by schema SELECT * FROM timescaledb_information.hypertables WHERE hypertable_schema = 'closed' ORDER BY hypertable_schema, hypertable_name; -- filter by table name SELECT * FROM timescaledb_information.hypertables WHERE hypertable_name = 'ht1' ORDER BY hypertable_schema, hypertable_name; -- filter by owner SELECT * FROM timescaledb_information.hypertables WHERE owner = 'super_user' ORDER BY hypertable_schema, hypertable_name; \x ---Add integer table -- CREATE TABLE test_table_int(time bigint, junk int); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 10); CREATE OR REPLACE function table_int_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; SELECT set_integer_now_func('test_table_int', 'table_int_now'); INSERT into test_table_int SELECT generate_series( 1, 20), 100; \d timescaledb_information.chunks SELECT hypertable_schema, hypertable_name, chunk_schema, chunk_name, primary_dimension, primary_dimension_type, range_start, range_end, range_start_integer, range_end_integer, is_compressed, chunk_tablespace, data_nodes FROM timescaledb_information.chunks WHERE hypertable_name = 'ht1' ORDER BY chunk_name; SELECT hypertable_schema, hypertable_name, chunk_schema, chunk_name, primary_dimension, primary_dimension_type, range_start, range_end, range_start_integer, range_end_integer, is_compressed, chunk_tablespace, data_nodes FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int' ORDER BY chunk_name; \x SELECT * FROM timescaledb_information.dimensions ORDER BY hypertable_name, dimension_number; \x �������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/insert.sql.in�����������������������������������������������������������0000664�0000000�0000000�00000024506�15100345067�0020272�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET enable_seqscan TO off; \ir include/insert_two_partitions.sql SELECT * FROM test.show_columnsp('_timescaledb_internal.%_hyper%'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%'); SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; SELECT * FROM "two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; SELECT * FROM ONLY "two_Partitions"; CREATE TABLE error_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('error_test', 'time', 'device', 2); \set QUIET off INSERT INTO error_test VALUES ('Mon Mar 20 09:18:20.1 2017', 21.3, 'dev1'); \set ON_ERROR_STOP 0 -- generate insert error INSERT INTO error_test VALUES ('Mon Mar 20 09:18:22.3 2017', 21.1, NULL); \set ON_ERROR_STOP 1 INSERT INTO error_test VALUES ('Mon Mar 20 09:18:25.7 2017', 22.4, 'dev2'); \set QUIET on SELECT * FROM error_test; --test character(9) partition keys since there were issues with padding causing partitioning errors CREATE TABLE tick_character ( symbol character(9) NOT NULL, mid REAL NOT NULL, spread REAL NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('tick_character', 'time', 'symbol', 2); INSERT INTO tick_character ( symbol, mid, spread, time ) VALUES ( 'GBPJPY', 142.639000, 5.80, 'Mon Mar 20 09:18:22.3 2017') RETURNING time, symbol, mid; SELECT * FROM tick_character; CREATE TABLE date_col_test(time date, temp float8, device text NOT NULL); SELECT create_hypertable('date_col_test', 'time', 'device', 1000, chunk_time_interval => INTERVAL '1 Day'); INSERT INTO date_col_test VALUES ('2001-02-01', 98, 'dev1'), ('2001-03-02', 98, 'dev1'); SELECT * FROM date_col_test WHERE time > '2001-01-01'; -- Out-of-order insertion regression test. -- this used to trip an assert in subspace_store.c checking that -- max_open_chunks_per_insert was obeyed set timescaledb.max_open_chunks_per_insert=1; CREATE TABLE chunk_assert_fail(i bigint, j bigint); SELECT create_hypertable('chunk_assert_fail', 'i', 'j', 1000, chunk_time_interval=>1); insert into chunk_assert_fail values (1, 1), (1, 2), (2,1); select * from chunk_assert_fail; CREATE TABLE one_space_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('one_space_test', 'time', 'device', 1); INSERT INTO one_space_test VALUES ('2001-01-01 01:01:01', 1.0, 'device'), ('2002-01-01 01:02:01', 1.0, 'device'); SELECT * FROM one_space_test; --CTE & EXPLAIN ANALYZE TESTS WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:02:01', 1.0, 'device') RETURNING *) SELECT * FROM insert_cte; EXPLAIN (analyze, buffers off, costs off, timing off) --can't turn summary off in 9.6 so instead grep it away at end. WITH insert_cte as ( INSERT INTO one_space_test VALUES ('2001-01-01 01:03:01', 1.0, 'device') ) SELECT 1 \g | grep -v "Planning" | grep -v "Execution" -- INSERTs can exclude chunks based on constraints EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail; EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i < 1; EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i = 1; EXPLAIN (buffers off, costs off) INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; INSERT INTO chunk_assert_fail SELECT i, j FROM chunk_assert_fail WHERE i > 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time < 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time >= 'infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time <= '-infinity' LIMIT 1; INSERT INTO one_space_test SELECT * FROM one_space_test WHERE time > '-infinity' LIMIT 1; CREATE TABLE timestamp_inf(time TIMESTAMP); SELECT create_hypertable('timestamp_inf', 'time'); INSERT INTO timestamp_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time < 'infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time >= 'infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time <= '-infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO timestamp_inf SELECT * FROM timestamp_inf WHERE time > '-infinity' LIMIT 1; CREATE TABLE date_inf(time DATE); SELECT create_hypertable('date_inf', 'time'); INSERT INTO date_inf VALUES ('2018/01/02'), ('2019/01/02'); EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time < 'infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time >= 'infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time <= '-infinity' LIMIT 1; EXPLAIN (buffers off, costs off) INSERT INTO date_inf SELECT * FROM date_inf WHERE time > '-infinity' LIMIT 1; -- test INSERT with cached plans / plpgsql functions -- https://github.com/timescale/timescaledb/issues/1809 CREATE TABLE status_table(a int, b int, last_ts timestamptz, UNIQUE(a,b)); CREATE TABLE metrics(time timestamptz NOT NULL, value float); CREATE TABLE metrics2(time timestamptz NOT NULL, value float); SELECT (create_hypertable(t,'time')).table_name FROM (VALUES ('metrics'),('metrics2')) v(t); INSERT INTO metrics VALUES ('2000-01-01',random()), ('2000-02-01',random()), ('2000-03-01',random()); CREATE OR REPLACE FUNCTION insert_test() RETURNS VOID LANGUAGE plpgsql AS $$ DECLARE r RECORD; BEGIN FOR r IN SELECT * FROM metrics LOOP WITH foo AS ( INSERT INTO metrics2 SELECT * FROM metrics RETURNING * ) INSERT INTO status_table (a,b, last_ts) VALUES (1,1, now()) ON CONFLICT (a,b) DO UPDATE SET last_ts=(SELECT max(time) FROM metrics); END LOOP; END; $$; SELECT insert_test(), insert_test(), insert_test(); -- test Postgres crashes on INSERT ... SELECT ... WHERE NOT EXISTS with empty table -- https://github.com/timescale/timescaledb/issues/1883 CREATE TABLE readings ( toe TIMESTAMPTZ NOT NULL, sensor_id INT NOT NULL, value INT NOT NULL ); SELECT create_hypertable( 'readings', 'toe', chunk_time_interval => interval '1 day', if_not_exists => TRUE, migrate_data => TRUE ); EXPLAIN (buffers off, costs off) INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); INSERT INTO readings SELECT '2020-05-09 10:34:35.296288+00', 1, 0 WHERE NOT EXISTS ( SELECT 1 FROM readings WHERE sensor_id = 1 AND toe = '2020-05-09 10:34:35.296288+00' ); DROP TABLE readings; CREATE TABLE sample_table ( sequence INTEGER NOT NULL, time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value NUMERIC NOT NULL, UNIQUE (sequence, time) ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '1 day'); INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-08-01', TIMESTAMP '2019-08-10', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); \set ON_ERROR_STOP 0 INSERT INTO sample_table (sequence,time,value) VALUES (7, generate_series(TIMESTAMP '2019-07-21', TIMESTAMP '2019-08-01', INTERVAL '10 minutes'), ROUND(RANDOM()*10)::int); \set ON_ERROR_STOP 1 INSERT INTO sample_table (sequence,time,value) VALUES (7,generate_series(TIMESTAMP '2019-01-01', TIMESTAMP '2019-07-01', '10 minutes'), ROUND(RANDOM()*10)::int); DROP TABLE sample_table; -- test on conflict clause on columns with default value -- issue #3037 CREATE TABLE i3037(time timestamptz PRIMARY KEY); SELECT create_hypertable('i3037','time'); ALTER TABLE i3037 ADD COLUMN value float DEFAULT 0; INSERT INTO i3037 VALUES ('2000-01-01'); INSERT INTO i3037 VALUES ('2000-01-01') ON CONFLICT(time) DO UPDATE SET value = EXCLUDED.value; -- test inserting into chunks directly CREATE TABLE direct_insert(time timestamptz, meta text) WITH (tsdb.hypertable); INSERT INTO direct_insert VALUES ('2020-01-01'); SELECT show_chunks('direct_insert') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) INSERT INTO :CHUNK VALUES ('2020-01-01'); -- correct time range should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; -- incorrect time range should fail \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2020-01-01'), ('2021-01-01') RETURNING *; INSERT INTO :CHUNK VALUES ('2025-01-01') RETURNING *; \set ON_ERROR_STOP 1 -- test that triggers on chunks work CREATE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'trigger called'; NEW.meta = 'triggered'; RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER test_trigger BEFORE INSERT ON direct_insert FOR EACH ROW EXECUTE PROCEDURE test_trigger(); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; -- test upsert DELETE FROM direct_insert; ALTER TABLE direct_insert ADD CONSTRAINT direct_insert_pkey PRIMARY KEY (time); INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; -- DO NOTHING should succeed INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT DO NOTHING RETURNING *; INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET meta = 'update' RETURNING *; \set ON_ERROR_STOP 0 -- conflict should fail INSERT INTO :CHUNK VALUES ('2020-01-01') RETURNING *; INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = '2000-01-01' RETURNING *; INSERT INTO :CHUNK VALUES ('2020-01-01') ON CONFLICT (time) DO UPDATE SET time = EXCLUDED.time + '1 year' RETURNING *; \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/insert_many.sql���������������������������������������������������������0000664�0000000�0000000�00000002742�15100345067�0020707�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE many_partitions_test(time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('many_partitions_test', 'time', 'device', 1000); --NOTE: how much slower the first two queries are -- they are creating chunks INSERT INTO many_partitions_test SELECT to_timestamp(ser), ser, ser::text FROM generate_series(1,100) ser; INSERT INTO many_partitions_test SELECT to_timestamp(ser), ser, ser::text FROM generate_series(101,200) ser; INSERT INTO many_partitions_test SELECT to_timestamp(ser), ser, (ser-201)::text FROM generate_series(201,300) ser; SELECT * FROM many_partitions_test ORDER BY time DESC LIMIT 2; SELECT count(*) FROM many_partitions_test; CREATE TABLE many_partitions_test_1m (time timestamp, temp float8, device text NOT NULL); SELECT create_hypertable('many_partitions_test_1m', 'time', 'device', 1000); EXPLAIN (verbose on, buffers off, costs off) INSERT INTO many_partitions_test_1m(time, temp, device) SELECT time_bucket('1 minute', time) AS period, avg(temp), device FROM many_partitions_test GROUP BY period, device; INSERT INTO many_partitions_test_1m(time, temp, device) SELECT time_bucket('1 minute', time) AS period, avg(temp), device FROM many_partitions_test GROUP BY period, device; SELECT * FROM many_partitions_test_1m ORDER BY time, device LIMIT 10; ������������������������������timescaledb-2.23.0/test/sql/insert_returning.sql����������������������������������������������������0000664�0000000�0000000�00000002412�15100345067�0021752�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE standard_table ( standard_id integer PRIMARY KEY, name text not null ); CREATE TABLE hypertable ( time timestamptz not null, name text not null, standard_id integer not null ); select * from create_hypertable('hypertable', 'time'); INSERT INTO standard_table (standard_id, name) VALUES (1, 'standard_1'); INSERT INTO hypertable (time, name, standard_id) VALUES ('2021-01-01 01:01:01+00', 'hypertable_1', 1); INSERT INTO hypertable (time, name, standard_id) VALUES ('2022-02-02 02:02:02+00', 'hypertable_2', 1) RETURNING *, EXISTS ( SELECT * FROM standard_table WHERE standard_table.standard_id = hypertable.standard_id ); INSERT INTO hypertable (time, name, standard_id) VALUES ('2023-03-03 03:03:03+00', 'hypertable_3', 1) RETURNING *, EXISTS ( SELECT * FROM standard_table WHERE standard_table.standard_id = hypertable.standard_id ); INSERT INTO hypertable (time, name, standard_id) VALUES ('2024-04-04 04:04:04+00', 'hypertable_4', 2) RETURNING *, EXISTS ( SELECT * FROM standard_table WHERE standard_table.standard_id = hypertable.standard_id );������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/insert_single.sql�������������������������������������������������������0000664�0000000�0000000�00000020214�15100345067�0021216�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_single.sql SELECT * FROM test.show_columnsp('"one_Partition".%'); SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; --test that we can insert data into a 1-dimensional table (only time partitioning) CREATE TABLE "1dim"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim"', 'time'); INSERT INTO "1dim" VALUES('2017-01-20T09:00:01', 22.5) RETURNING *; INSERT INTO "1dim" VALUES('2017-01-20T09:00:21', 21.2); INSERT INTO "1dim" VALUES('2017-01-20T09:00:47', 25.1); SELECT * FROM "1dim"; CREATE TABLE regular_table (time timestamp, temp float); INSERT INTO regular_table SELECT * FROM "1dim"; SELECT * FROM regular_table; TRUNCATE TABLE regular_table; INSERT INTO regular_table VALUES('2017-01-20T09:00:59', 29.2); INSERT INTO "1dim" SELECT * FROM regular_table; SELECT * FROM "1dim"; SELECT "1dim" FROM "1dim"; --test that we can insert pre-1970 dates CREATE TABLE "1dim_pre1970"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim_pre1970"', 'time', chunk_time_interval=> INTERVAL '1 Month'); INSERT INTO "1dim_pre1970" VALUES('1969-12-01T19:00:00', 21.2); INSERT INTO "1dim_pre1970" VALUES('1969-12-20T09:00:00', 25.1); INSERT INTO "1dim_pre1970" VALUES('1970-01-20T09:00:00', 26.6); INSERT INTO "1dim_pre1970" VALUES('1969-02-20T09:00:00', 29.9); --should show warning BEGIN; CREATE TABLE "1dim_usec_interval"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim_usec_interval"', 'time', chunk_time_interval=> 10); INSERT INTO "1dim_usec_interval" VALUES('1969-12-01T19:00:00', 21.2); ROLLBACK; CREATE TABLE "1dim_usec_interval"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"1dim_usec_interval"', 'time', chunk_time_interval=> 1000000); INSERT INTO "1dim_usec_interval" VALUES('1969-12-01T19:00:00', 21.2); CREATE TABLE "1dim_neg"(time INTEGER, temp float); SELECT create_hypertable('"1dim_neg"', 'time', chunk_time_interval=>10); INSERT INTO "1dim_neg" VALUES (-20, 21.2); INSERT INTO "1dim_neg" VALUES (-19, 21.2); INSERT INTO "1dim_neg" VALUES (-1, 21.2); INSERT INTO "1dim_neg" VALUES (0, 21.2); INSERT INTO "1dim_neg" VALUES (1, 21.2); INSERT INTO "1dim_neg" VALUES (19, 21.2); INSERT INTO "1dim_neg" VALUES (20, 21.2); SELECT * FROM "1dim_pre1970"; SELECT * FROM "1dim_neg"; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; SELECT * FROM _timescaledb_catalog.dimension_slice; -- Create a three-dimensional table CREATE TABLE "3dim" (time timestamp, temp float, device text, location text); SELECT create_hypertable('"3dim"', 'time', 'device', 2); SELECT add_dimension('"3dim"', 'location', 2); INSERT INTO "3dim" VALUES('2017-01-20T09:00:01', 22.5, 'blue', 'nyc'); INSERT INTO "3dim" VALUES('2017-01-20T09:00:21', 21.2, 'brown', 'sthlm'); INSERT INTO "3dim" VALUES('2017-01-20T09:00:47', 25.1, 'yellow', 'la'); --show the constraints on the three-dimensional chunk SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_7_16_chunk'); --queries should work in three dimensions SELECT * FROM "3dim"; -- test that explain works EXPLAIN (BUFFERS FALSE, COSTS FALSE) INSERT INTO "3dim" VALUES('2017-01-21T09:00:01', 32.9, 'green', 'nyc'), ('2017-01-21T09:00:47', 27.3, 'purple', 'la') RETURNING *; EXPLAIN (BUFFERS FALSE, COSTS FALSE) WITH "3dim_insert" AS ( INSERT INTO "3dim" VALUES('2017-01-21T09:01:44', 19.3, 'black', 'la') RETURNING time, temp ), regular_insert AS ( INSERT INTO regular_table VALUES('2017-01-21T10:00:51', 14.3) RETURNING time, temp ) INSERT INTO "1dim" (SELECT time, temp FROM "3dim_insert" UNION SELECT time, temp FROM regular_insert); -- test prepared statement INSERT PREPARE "1dim_plan" (timestamp, float) AS INSERT INTO "1dim" VALUES($1, $2) ON CONFLICT (time) DO NOTHING; EXECUTE "1dim_plan" ('2017-04-17 23:35', 31.4); EXECUTE "1dim_plan" ('2017-04-17 23:35', 32.6); -- test prepared statement with generic plan (forced when no parameters) PREPARE "1dim_plan_generic" AS INSERT INTO "1dim" VALUES('2017-05-18 17:24', 18.3); EXECUTE "1dim_plan_generic"; SELECT * FROM "1dim" ORDER BY time; SELECT * FROM "3dim" ORDER BY (time, device); -- Test large intervals as default interval for integer is -- supported as part of hypertable generalization \set ON_ERROR_STOP 0 CREATE TABLE "inttime_err"(time INTEGER PRIMARY KEY, temp float); SELECT create_hypertable('"inttime_err"', 'time', chunk_time_interval=>2147483648); \set ON_ERROR_STOP 1 SELECT create_hypertable('"inttime_err"', 'time', chunk_time_interval=>2147483647); -- Test large intervals as default interval is supported -- for integer types as part of hypertable generalization. \set ON_ERROR_STOP 0 CREATE TABLE "smallinttime_err"(time SMALLINT PRIMARY KEY, temp float); SELECT create_hypertable('"smallinttime_err"', 'time', chunk_time_interval=>32768); \set ON_ERROR_STOP 1 SELECT create_hypertable('"smallinttime_err"', 'time', chunk_time_interval=>32767); --make sure date inserts work even when the timezone changes the CREATE TABLE hyper_date(time date, temp float); SELECT create_hypertable('"hyper_date"', 'time'); SET timezone=+1; INSERT INTO "hyper_date" VALUES('2011-01-26', 22.5); RESET timezone; --make sure timestamp inserts work even when the timezone changes the SET timezone = 'UTC'; CREATE TABLE "test_tz"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"test_tz"', 'time', chunk_time_interval=> INTERVAL '1 day'); INSERT INTO "test_tz" VALUES('2017-09-22 10:00:00', 21.2); INSERT INTO "test_tz" VALUES('2017-09-21 19:00:00', 21.2); SET timezone = 'US/central'; INSERT INTO "test_tz" VALUES('2017-09-21 19:01:00', 21.2); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_10_20_chunk'); SELECT * FROM test_tz; -- test various memory settings -- SET timescaledb.max_open_chunks_per_insert = 10; SET timescaledb.max_cached_chunks_per_hypertable = 10; CREATE TABLE "nondefault_mem_settings"(time timestamp PRIMARY KEY, temp float); SELECT create_hypertable('"nondefault_mem_settings"', 'time', chunk_time_interval=> INTERVAL '1 Month'); INSERT INTO "nondefault_mem_settings" VALUES('2000-12-01T19:00:00', 21.2); INSERT INTO "nondefault_mem_settings" VALUES('2001-12-20T09:00:00', 25.1); --lowest possible SET timescaledb.max_open_chunks_per_insert = 1; SET timescaledb.max_cached_chunks_per_hypertable = 1; INSERT INTO "nondefault_mem_settings" VALUES ('2001-01-20T09:00:00', 26.6), ('2002-02-20T09:00:00', 27.9), ('2003-02-20T09:00:00', 28.9); INSERT INTO "nondefault_mem_settings" VALUES ('2001-03-20T09:00:00', 30.6), ('2002-03-20T09:00:00', 31.9), ('2003-03-20T09:00:00', 32.9); --warning about mismatched cache sizes SET timescaledb.max_open_chunks_per_insert = 100; SET timescaledb.max_cached_chunks_per_hypertable = 10; INSERT INTO "nondefault_mem_settings" VALUES ('2001-05-20T09:00:00', 36.6), ('2002-05-20T09:00:00', 37.9), ('2003-05-20T09:00:00', 38.9); --unlimited SET timescaledb.max_open_chunks_per_insert = 0; SET timescaledb.max_cached_chunks_per_hypertable = 0; INSERT INTO "nondefault_mem_settings" VALUES ('2001-04-20T09:00:00', 33.6), ('2002-04-20T09:00:00', 34.9), ('2003-04-20T09:00:00', 35.9); SELECT * FROM "nondefault_mem_settings"; --test rollback BEGIN; \set QUIET off CREATE TABLE "data_records" ("time" bigint NOT NULL, "value" integer CHECK (VALUE >= 0)); SELECT create_hypertable('data_records', 'time', chunk_time_interval => 2592000000); INSERT INTO "data_records" ("time", "value") VALUES (0, 1); SAVEPOINT savepoint_1; INSERT INTO "data_records" ("time", "value") VALUES (1, 0); ROLLBACK TO SAVEPOINT savepoint_1; INSERT INTO "data_records" ("time", "value") VALUES (2, 1); SAVEPOINT savepoint_2; \set ON_ERROR_STOP 0 INSERT INTO "data_records" ("time", "value") VALUES (3, -1); \set ON_ERROR_STOP 1 ROLLBACK TO SAVEPOINT savepoint_2; INSERT INTO "data_records" ("time", "value") VALUES (4, 1); SAVEPOINT savepoint_3; INSERT INTO "data_records" ("time", "value") VALUES (5, 0); ROLLBACK TO SAVEPOINT savepoint_3; SELECT * FROM data_records; \set QUIET on ROLLBACK; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/lateral.sql�������������������������������������������������������������0000664�0000000�0000000�00000007514�15100345067�0020005�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE regular_table(name text, junk text); CREATE TABLE ht(time timestamptz NOT NULL, location text); SELECT create_hypertable('ht', 'time'); INSERT INTO ht(time) select timestamp 'epoch' + (i * interval '1 second') from generate_series(1, 100) as T(i); INSERT INTO regular_table values('name', 'junk'); SELECT * FROM regular_table ik LEFT JOIN LATERAL (select max(time::timestamptz) from ht s where ik.name='name' and s.time < now()) s on true; select * from regular_table ik LEFT JOIN LATERAL (select max(time::timestamptz) from ht s where ik.name='name' and s.time > now()) s on true; DROP TABLE regular_table; DROP TABLE ht; CREATE TABLE orders(id int, user_id int, time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('orders', 'time'); INSERT INTO orders values(1,1,timestamp 'epoch' + '1 second'); INSERT INTO orders values(2,1,timestamp 'epoch' + '2 second'); INSERT INTO orders values(3,1,timestamp 'epoch' + '3 second'); INSERT INTO orders values(4,2,timestamp 'epoch' + '4 second'); INSERT INTO orders values(5,1,timestamp 'epoch' + '5 second'); INSERT INTO orders values(6,3,timestamp 'epoch' + '6 second'); INSERT INTO orders values(7,1,timestamp 'epoch' + '7 second'); INSERT INTO orders values(8,4,timestamp 'epoch' + '8 second'); INSERT INTO orders values(9,2,timestamp 'epoch' + '9 second'); -- Need a LATERAL query with a reference to the upper-level table and -- with a restriction on time -- Upper-level table constraint should be a constant in order to trigger -- creation of a one-time filter in the planner SELECT user_id, first_order_time, max_time FROM (SELECT user_id, min(time) AS first_order_time FROM orders GROUP BY user_id) o1 LEFT JOIN LATERAL (SELECT max(time) AS max_time FROM orders WHERE o1.user_id = '2' AND time > now()) o2 ON true ORDER BY user_id, first_order_time, max_time; SELECT user_id, first_order_time, max_time FROM (SELECT user_id, min(time) AS first_order_time FROM orders GROUP BY user_id) o1 LEFT JOIN LATERAL (SELECT max(time) AS max_time FROM orders WHERE o1.user_id = '2' AND time < now()) o2 ON true ORDER BY user_id, first_order_time, max_time; -- Nested LATERALs SELECT user_id, first_order_time, time1, min_time FROM (SELECT user_id, min(time) AS first_order_time FROM orders GROUP BY user_id) o1 LEFT JOIN LATERAL (SELECT user_id as o2user_id, time AS time1 FROM orders WHERE o1.user_id = '2' AND time < now()) o2 ON true LEFT JOIN LATERAL (SELECT min(time) as min_time FROM orders WHERE o2.o2user_id = '1' AND time < now()) o3 ON true ORDER BY user_id, first_order_time, time1, min_time; -- Cleanup DROP TABLE orders; ---- OUTER JOIN tests --- --github issue 2500 CREATE TABLE t1_timescale (a int, b int); CREATE TABLE t2 (a int, b int); SELECT create_hypertable('t1_timescale', 'a', chunk_time_interval=>1000); INSERT into t2 values (3, 3), (15 , 15); INSERT into t1_timescale select generate_series(5, 25, 1), 77; UPDATE t1_timescale SET b = 15 WHERE a = 15; SELECT * FROM t1_timescale FULL OUTER JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 ORDER BY 1, 2, 3, 4; SELECT * FROM t1_timescale LEFT OUTER JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 WHERE t1_timescale.a=5 ORDER BY 1, 2, 3, 4; SELECT * FROM t1_timescale RIGHT JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 ORDER BY 1, 2, 3, 4; SELECT * FROM t1_timescale RIGHT JOIN t2 on t1_timescale.b=t2.b and t2.b between 10 and 20 WHERE t1_timescale.a=5 ORDER BY 1, 2, 3, 4; SELECT * FROM t1_timescale LEFT OUTER JOIN t2 on t1_timescale.a=t2.a and t2.b between 10 and 20 WHERE t1_timescale.a IN ( 10, 15, 20, 25) ORDER BY 1, 2, 3, 4; SELECT * FROM t1_timescale RIGHT OUTER JOIN t2 on t1_timescale.a=t2.a and t2.b between 10 and 20 ORDER BY 1, 2, 3, 4; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/license.sql�������������������������������������������������������������0000664�0000000�0000000�00000003271�15100345067�0017777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ECHO queries \set VERBOSITY default SHOW timescaledb.license; SELECT _timescaledb_functions.tsl_loaded(); -- User shouldn't be able to change the license in the session \set ON_ERROR_STOP 0 SET timescaledb.license='apache'; SET timescaledb.license='timescale'; SET timescaledb.license='something_else'; \set ON_ERROR_STOP 1 -- make sure apache license blocks tsl features \set ON_ERROR_STOP 0 SELECT locf(1); SELECT interpolate(1); SELECT time_bucket_gapfill(1,1,1,1); CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS VOID AS $$ DECLARE BEGIN END; $$ LANGUAGE plpgsql; SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb); DROP FUNCTION custom_func; CREATE TABLE metrics(time timestamptz NOT NULL, value float); SELECT create_hypertable('metrics', 'time'); ALTER TABLE metrics SET (timescaledb.compress); INSERT INTO metrics VALUES ('2022-01-01 00:00:00', 1), ('2022-01-01 01:00:00', 2), ('2022-01-01 02:00:00', 3); CREATE MATERIALIZED VIEW metrics_hourly WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, AVG(value), MAX(value), MIN(value) FROM metrics GROUP BY bucket WITH NO DATA; CREATE MATERIALIZED VIEW metrics_hourly AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, AVG(value), MAX(value), MIN(value) FROM metrics GROUP BY bucket; CALL refresh_continuous_aggregate('metrics_hourly', NULL, NULL); DROP MATERIALIZED VIEW metrics_hourly; DROP TABLE metrics; \set ON_ERROR_STOP 1 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader.sql.in�����������������������������������������������������������0000664�0000000�0000000�00000013543�15100345067�0020233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_2 :TEST_DBNAME _2 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE :"TEST_DBNAME_2"; DROP EXTENSION timescaledb; --no extension SELECT * FROM test.extension; SELECT 1; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-1'; SELECT 1; SELECT * FROM test.extension; CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-1'; CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-2'; DROP EXTENSION timescaledb; \set ON_ERROR_STOP 0 --test that we cannot accidentally load another library version CREATE EXTENSION IF NOT EXISTS timescaledb VERSION 'mock-2'; \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER --no extension SELECT * FROM test.extension; SELECT 1; CREATE EXTENSION timescaledb VERSION 'mock-1'; --same backend as create extension; SELECT 1; SELECT * FROM test.extension; --start new backend; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT 1; SELECT 1; --test fn call after load SELECT mock_function(); SELECT * FROM test.extension; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --test fn call as first command SELECT mock_function(); --use guc to prevent loading \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.disable_load = 'on'; SELECT 1; SELECT 1; SET timescaledb.disable_load = 'off'; SELECT 1; \set ON_ERROR_STOP 0 SET timescaledb.disable_load = 'not bool'; \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER RESET ALL; SELECT 1; \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.disable_load TO DEFAULT; SELECT 1; \c :TEST_DBNAME :ROLE_SUPERUSER RESET timescaledb.disable_load; SELECT 1; \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.other = 'on'; SELECT 1; \set ON_ERROR_STOP 0 --cannot update extension after .so of previous version already loaded ALTER EXTENSION timescaledb UPDATE TO 'mock-2'; \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT * FROM test.extension; CREATE EXTENSION timescaledb VERSION 'mock-1'; SELECT * FROM test.extension; --start a new backend to update \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER EXTENSION timescaledb UPDATE TO 'mock-2'; SELECT 1; SELECT * FROM test.extension; --drop extension DROP EXTENSION timescaledb; SELECT 1; SELECT * FROM test.extension; \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-2'; SELECT 1; SELECT * FROM test.extension; -- test db 1 still has old version \c :TEST_DBNAME :ROLE_SUPERUSER SELECT 1; SELECT * FROM test.extension; --try a broken upgrade \c :TEST_DBNAME_2 :ROLE_SUPERUSER SELECT * FROM test.extension; \set ON_ERROR_STOP 0 ALTER EXTENSION timescaledb UPDATE TO 'mock-3'; \set ON_ERROR_STOP 1 --should still be on mock-2 SELECT 1; SELECT * FROM test.extension; --drop extension DROP EXTENSION timescaledb; SELECT 1; SELECT * FROM test.extension; --create extension anew, only upgrade was broken \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-3'; SELECT 1; SELECT * FROM test.extension; DROP EXTENSION timescaledb; SELECT 1; --mismatched version errors \c :TEST_DBNAME_2 :ROLE_SUPERUSER --mock-4 has mismatched versions, so the .so load should be fatal SELECT format($$\! utils/test_fatal_command.sh %1$s "CREATE EXTENSION timescaledb VERSION 'mock-4'"$$, :'TEST_DBNAME_2') as command_to_run \gset :command_to_run --mock-4 not installed. SELECT * FROM test.extension; \c :TEST_DBNAME_2 :ROLE_SUPERUSER --broken version and drop CREATE EXTENSION timescaledb VERSION 'mock-broken'; \set ON_ERROR_STOP 0 --intentional broken version SELECT * FROM test.extension; SELECT 1; SELECT 1; --cannot drop extension; already loaded broken version DROP EXTENSION timescaledb; \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER --can drop extension now. Since drop first command. DROP EXTENSION timescaledb; SELECT * FROM test.extension; --broken version and update to fixed \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-broken'; \set ON_ERROR_STOP 0 --intentional broken version SELECT 1; --cannot update extension; already loaded bad version ALTER EXTENSION timescaledb UPDATE TO 'mock-5'; \set ON_ERROR_STOP 1 \c :TEST_DBNAME_2 :ROLE_SUPERUSER --can update extension now. ALTER EXTENSION timescaledb UPDATE TO 'mock-5'; SELECT 1; SELECT mock_function(); \c :TEST_DBNAME_2 :ROLE_SUPERUSER ALTER EXTENSION timescaledb UPDATE TO 'mock-6'; --The mock-5->mock_6 upgrade is intentionally broken. --The mock_function was never changed to point to mock-6 in the update script. --Thus mock_function is defined incorrectly to point to the mock-5.so --This will now be a FATAL error. SELECT format($$\! utils/test_fatal_command.sh %1$s "SELECT mock_function()"$$, :'TEST_DBNAME_2') as command_to_run \gset :command_to_run SELECT * FROM test.extension; --TEST: create extension when old .so already loaded \c :TEST_DBNAME :ROLE_SUPERUSER SELECT * FROM test.extension; DROP EXTENSION timescaledb; SELECT * FROM test.extension; \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb VERSION 'mock-2'; \set ON_ERROR_STOP 1 SELECT * FROM test.extension; --can create in a new session. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE EXTENSION timescaledb VERSION 'mock-2'; SELECT * FROM test.extension; --make sure parallel workers started after a 'DISCARD ALL' work CREATE TABLE test (i int, j double precision); INSERT INTO test SELECT x, x+0.1 FROM generate_series(1,100) AS x; DISCARD ALL; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); SET max_parallel_workers_per_gather = 1; SELECT count(*) FROM test; CREATE EXTENSION timescaledb_osm VERSION 'mock-1'; -- Test that OSM process utility hook works: it should see this DROP TABLE. DROP TABLE test; -- clean up additional database \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE :"TEST_DBNAME_2" WITH (FORCE); �������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017077�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/CMakeLists.txt���������������������������������������������������0000664�0000000�0000000�00000001263�15100345067�0021641�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������if(CMAKE_BUILD_TYPE MATCHES Debug) install( FILES timescaledb--mock-1.sql timescaledb--mock-2.sql timescaledb--mock-3.sql timescaledb--mock-4.sql timescaledb--mock-5.sql timescaledb--mock-6.sql timescaledb--mock-broken.sql timescaledb--mock-1--mock-2.sql timescaledb--mock-2--mock-3.sql timescaledb--mock-3--mock-4.sql timescaledb--mock-5--mock-6.sql timescaledb--mock-broken--mock-5.sql timescaledb--0.0.0.sql timescaledb_osm.control timescaledb_osm--mock-1.sql DESTINATION "${PG_SHAREDIR}/extension") endif(CMAKE_BUILD_TYPE MATCHES Debug) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--0.0.0.sql�������������������������������������������0000664�0000000�0000000�00000000266�15100345067�0022606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-1--mock-2.sql����������������������������������0000664�0000000�0000000�00000000663�15100345067�0024406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --test that the extension is deactivated during upgrade SELECT 1; SELECT 1; SELECT 1; SELECT 1; CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-2', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; �����������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-1.sql������������������������������������������0000664�0000000�0000000�00000000712�15100345067�0023236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-1', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-2--mock-3.sql����������������������������������0000664�0000000�0000000�00000000536�15100345067�0024407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. broken sql; CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-3', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-2.sql������������������������������������������0000664�0000000�0000000�00000000760�15100345067�0023242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --create function before proxy table CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-2', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); ����������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-3--mock-4.sql����������������������������������0000664�0000000�0000000�00000000662�15100345067�0024411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --test that the extension is deactivated during upgrade SELECT 1; SELECT 1; SELECT 1; SELECT 1; CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-4', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-3.sql������������������������������������������0000664�0000000�0000000�00000000712�15100345067�0023240�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-3', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-4.sql������������������������������������������0000664�0000000�0000000�00000000712�15100345067�0023241�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-4', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-5--mock-6.sql����������������������������������0000664�0000000�0000000�00000000733�15100345067�0024414�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --test that the extension is deactivated during upgrade SELECT 1; SELECT 1; SELECT 1; SELECT 1; --intentionally forget to updat func --CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID -- AS '$libdir/timescaledb-mock-6', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; �������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-5.sql������������������������������������������0000664�0000000�0000000�00000000712�15100345067�0023242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-5', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-6.sql������������������������������������������0000664�0000000�0000000�00000000712�15100345067�0023243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-6', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; ������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-broken--mock-5.sql�����������������������������0000664�0000000�0000000�00000000661�15100345067�0025527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --test that the extension is deactivated during upgrade SELECT 1; SELECT 1; SELECT 1; SELECT 1; CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-5', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; �������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb--mock-broken.sql�������������������������������������0000664�0000000�0000000�00000000717�15100345067�0024363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS _timescaledb_cache; CREATE TABLE IF NOT EXISTS _timescaledb_cache.cache_inval_extension(); CREATE OR REPLACE FUNCTION mock_function() RETURNS VOID AS '$libdir/timescaledb-mock-broken', 'ts_mock_function' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; �������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb_osm--mock-1.sql��������������������������������������0000664�0000000�0000000�00000000617�15100345067�0024120�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA _osm_catalog; CREATE TABLE _osm_catalog.metadata(); CREATE OR REPLACE FUNCTION mock_osm() RETURNS VOID AS '$libdir/timescaledb_osm-mock-1', 'ts_mock_osm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/loader/timescaledb_osm.control������������������������������������������0000664�0000000�0000000�00000000252�15100345067�0023632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������comment = 'Manages object storage on S3' default_version = '0' module_pathname = '$libdir/timescaledb_osm-0' relocatable = false superuser = false requires = timescaledb ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/merge.sql���������������������������������������������������������������0000664�0000000�0000000�00000070566�15100345067�0017467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Create target table with location and temperature CREATE TABLE target ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL, to_be_dropped text ); SELECT create_hypertable( 'target', 'time', chunk_time_interval => INTERVAL '5 seconds'); INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- This makes sure we have one column with attisdropped and one column -- with atthasmissing set to true. These two cases can cause problems -- with chunk dispatch execution when merging using a when-clause with -- inserts. Unfortunately they are hard to trigger, so this is not a -- definitive test. ALTER TABLE target DROP COLUMN to_be_dropped; ALTER TABLE target ADD COLUMN val text default 'string -'; -- Create source table with location and temperature CREATE TABLE source ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable( 'source', 'time', chunk_time_interval => INTERVAL '5 seconds'); -- Generate data that overlaps with target table INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- Print table/rows/num of chunks select * from target order by time, location asc; select * from source order by time, location asc; -- CREATE normal PostgreSQL tables CREATE TABLE target_pg AS SELECT * FROM target; CREATE TABLE source_pg AS SELECT * FROM source; -- Merge UPDATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- Merge UPDATE matched rows for hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- Merge DELETE matched rows for hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- clean up tables DELETE FROM target_pg; DELETE FROM target; DELETE FROM source_pg; DELETE FROM source; INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO target_pg SELECT * FROM target; INSERT INTO source_pg SELECT * FROM source; -- Merge UPDATE matched rows and INSERT new row for unmatched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE' WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- Merge UPDATE matched rows and INSERT new row for unmatched rows for hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE' WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge INSERT with constant literals for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- Merge INSERT with constant literals for hypertables MERGE INTO target t USING source s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge with INSERT/DELETE/UPDATE on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.location = 560076 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.location = 560083 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- Merge with INSERT/DELETE/UPDATE on hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.location = 560076 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.location = 560083 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge with Subqueries on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location > (SELECT count(*) FROM source_pg) WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (SELECT count(*) FROM target_pg) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'SUBQUERY string - INSERTED BY MERGE'); -- Merge with Subqueries on hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.location > (SELECT count(*) FROM source) WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (SELECT count(*) FROM target) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'SUBQUERY string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- clean up tables DELETE FROM target_pg; DELETE FROM target; DELETE FROM source_pg; DELETE FROM source; -- TEST with target as hypertable and source as normal PG table INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; INSERT INTO target_pg SELECT * FROM target; INSERT INTO source_pg SELECT * FROM source; -- Merge UPDATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- Merge UPDATE with target as hypertables and source as normal PG tables MERGE INTO target t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = (t.temperature + s.temperature)/2, val = val || ' UPDATED BY MERGE'; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- Merge DELETE with target as hypertables and source as normal PG tables MERGE INTO target t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DELETE; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge INSERT with constant literals for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- Merge INSERT with constant literals for target as hypertables and source as normal PG tables MERGE INTO target t USING source s ON t.location = 1234 WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge with INSERT/DELETE/UPDATE on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- Merge with INSERT/DELETE/UPDATE on target as hypertables and source as normal PG tables MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED AND t.temperature = 23 THEN UPDATE SET temperature = (t.temperature + s.temperature) * 2, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.temperature = 47 THEN DELETE WHEN NOT MATCHED THEN INSERT (time, location, temperature, val) VALUES (s.time, s.location, s.temperature, 'string - INSERTED BY MERGE'); -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; DROP TABLE target_pg CASCADE; DROP TABLE target CASCADE; DROP TABLE source_pg CASCADE; DROP TABLE source CASCADE; -- test MERGE with source being a PARTITION table CREATE TABLE source_pg( id INT NOT NULL, dev INT NOT NULL, value INT, CONSTRAINT cstr_source_pky PRIMARY KEY (id) ) PARTITION BY LIST (id); CREATE TABLE source_1_2_3_4 PARTITION OF source_pg FOR VALUES IN (1,2,3,4); CREATE TABLE source_5_6_7_8 PARTITION OF source_pg FOR VALUES IN (5,6,7,8); INSERT INTO source_pg SELECT generate_series(1,8), 44,55; CREATE TABLE target ( ts TIMESTAMP WITH TIME ZONE NOT NULL, id INT NOT NULL, dev INT NOT NULL, FOREIGN KEY (id) REFERENCES source_pg(id) ON DELETE CASCADE ); SELECT create_hypertable( relation => 'target', time_column_name => 'ts' ); insert into target values ('2023-01-12 00:00:05'::timestamp with time zone, 1,2); insert into target values ('2023-01-12 00:00:10'::timestamp with time zone, 2,2); insert into target values ('2023-01-12 00:00:15'::timestamp with time zone, 3,2); insert into target values ('2023-01-12 00:00:20'::timestamp with time zone, 4,2); insert into target values ('2023-01-14 00:00:25'::timestamp with time zone, 5,2); insert into target values ('2023-01-14 00:00:30'::timestamp with time zone, 6,2); insert into target values ('2023-01-14 00:00:35'::timestamp with time zone, 7,2); insert into target values ('2023-01-14 00:00:40'::timestamp with time zone, 8,2); CREATE TABLE target_pg AS SELECT * FROM target; -- Merge UPDATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.id = s.id WHEN MATCHED THEN UPDATE SET dev = (t.dev + s.dev)/2; -- Merge UPDATE matched rows for hypertables MERGE INTO target t USING source_pg s ON t.id = s.id WHEN MATCHED THEN UPDATE SET dev = (t.dev + s.dev)/2; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.id = s.id WHEN MATCHED THEN DELETE; -- Merge DELETE matched rows for hypertables MERGE INTO target t USING source_pg s ON t.id = s.id WHEN MATCHED THEN DELETE; -- ensure TARGET PG table and hypertable are same SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- clean up tables DROP TABLE target_pg CASCADE; DROP TABLE target CASCADE; DROP TABLE source_pg CASCADE; -- test MERGE with hypertables with time and space partitions CREATE TABLE target ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('target', 'time', 'device_id', 5); SELECT add_dimension('target', 'device_id_peer', 5); SELECT add_dimension('target', 'v2', 5); INSERT INTO target (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); CREATE TABLE source ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int ); SELECT create_hypertable ('source', 'time', 'device_id', 3); INSERT INTO source (time, device_id, filler_2, filler_3, filler_1) SELECT time, device_id, device_id + 134, device_id + 209, device_id + 0.50127 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); -- create PG tables to compare PG target and hypertable target tables CREATE table target_pg as SELECT * FROM target; CREATE table source_pg as SELECT * FROM source; -- Merge UDPATE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET filler_2 = s.filler_1 + 100; -- Merge UDPATE matched rows for space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET filler_2 = s.filler_1 + 100; SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge DELETE matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- Merge DELETE matched rows for space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge INSERT matched rows for normal PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); -- Merge INSERT matched rows for space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- Merge with INSERT/DELETE/UPDATE on PG tables MERGE INTO target_pg t USING source_pg s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED AND t.device_id_peer = 2 THEN UPDATE SET filler_2 = s.filler_1 + s.filler_2 + s.filler_3 + 100 WHEN MATCHED AND t.device_id_peer = 7 THEN DELETE WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); -- Merge with INSERT/DELETE/UPDATE on space partitioned hypertables MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED AND t.device_id_peer = 2 THEN UPDATE SET filler_2 = s.filler_1 + s.filler_2 + s.filler_3 + 100 WHEN MATCHED AND t.device_id_peer = 7 THEN DELETE WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; -- clean up tables DROP TABLE target_pg CASCADE; DROP TABLE target CASCADE; DROP TABLE source_pg CASCADE; DROP TABLE source CASCADE; -- TEST with parition column place after similar data type column CREATE TABLE target ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float, partition_column TIMESTAMPTZ NOT NULL ); SELECT create_hypertable ('target', 'partition_column'); INSERT INTO target (time, device_id, device_id_peer, v0, v1, v2, v3, partition_column) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL, time + interval '10m' FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); CREATE TABLE source ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int ); SELECT create_hypertable ('source', 'time', 'device_id', 3); INSERT INTO source (time, device_id, filler_2, filler_3, filler_1) SELECT time, device_id, device_id + 134, device_id + 209, device_id + 0.50127 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); -- create PG tables to compare PG target and hypertable target tables CREATE table target_pg as SELECT * FROM target; MERGE INTO target_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, device_id_peer, v0, v1, v2, v3, partition_column) VALUES ('2010-01-06 05:30:00+05:30', 23, 2, 11, 22, 33, 44, '2023-01-06 05:33:00+05:30'); MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, device_id_peer, v0, v1, v2, v3, partition_column) VALUES ('2010-01-06 05:30:00+05:30', 23, 2, 11, 22, 33, 44, '2023-01-06 05:33:00+05:30'); SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; MERGE INTO target_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; SELECT CASE WHEN EXISTS (TABLE target EXCEPT TABLE target_pg) OR EXISTS (TABLE target_pg EXCEPT TABLE target) THEN 'different' ELSE 'same' END AS result; MERGE INTO target_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); -- time dimension column is NULL, this will report an null constraint violation error \set ON_ERROR_STOP 0 MERGE INTO target t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (filler_1, filler_2, filler_3, time, device_id, device_id_peer, v0, v1, v2, v3) VALUES (s.filler_1, s.filler_2, s.filler_3, s.time, s.device_id, s.device_id + 10, 1,2,3,4); \set ON_ERROR_STOP 1 DROP TABLE target CASCADE; DROP TABLE target_pg CASCADE; DROP TABLE source CASCADE; -- TEST with target table have CHECK constraints CREATE TABLE target ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL CHECK (temperature > 10), val text default 'string -' ); SELECT create_hypertable( 'target', 'time', chunk_time_interval => INTERVAL '5 seconds'); INSERT INTO target SELECT time, location, 14 as temperature FROM generate_series( '2021-01-01 00:00:00', '2021-01-01 00:00:09', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- Create source table with location and temperature CREATE TABLE source ( time TIMESTAMPTZ NOT NULL, location SMALLINT NOT NULL, temperature DOUBLE PRECISION NULL ); -- Generate data that overlaps with target table INSERT INTO source SELECT time, location, 80 as temperature FROM generate_series( '2021-01-01 00:00:05', '2021-01-01 00:00:14', INTERVAL '5 seconds' ) as time, generate_series(1,4) as location; -- CREATE normal PostgreSQL tables CREATE TABLE target_pg AS SELECT * FROM target; -- Merge UPDATE/DELETE with DO NOTHING on pg tables MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN DO NOTHING; -- Merge UPDATE/DELETE with DO NOTHING on hypertable MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN DO NOTHING WHEN NOT MATCHED THEN DO NOTHING; -- Error cases for Merge \set ON_ERROR_STOP 0 -- Merge UPDATE should fail with check constraint violation MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE'; -- Merge UPDATE should fail with check constraint violation MERGE INTO target t USING source s ON t.time = s.time AND t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE'; -- Merge error with unreachable WHEN clause on pg tables MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.time < now() THEN DELETE WHEN NOT MATCHED THEN DO NOTHING; -- Merge error with unreachable WHEN clause on hypertable MERGE INTO target t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN UPDATE SET temperature = 8, val = val || ' UPDATED BY MERGE' WHEN MATCHED AND t.time < now() THEN DELETE WHEN NOT MATCHED THEN DO NOTHING; -- Merge error with unknown action in MERGE WHEN MATCHED clause on pg tables MERGE INTO target_pg t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN SELECT 1; -- Merge error with unknown action in MERGE WHEN MATCHED clause on hypertable MERGE INTO target t USING source s ON t.time = s.time AND t.location != s.location WHEN MATCHED THEN SELECT 1; -- Merge error cannot affect row a second time on pg tables MERGE INTO target_pg t USING source s ON t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 28, val = val || ' UPDATED BY MERGE'; -- Merge error cannot affect row a second time on hypertable MERGE INTO target t USING source s ON t.location = s.location WHEN MATCHED THEN UPDATE SET temperature = 28, val = val || ' UPDATED BY MERGE'; \set ON_ERROR_STOP 1 DROP TABLE target CASCADE; DROP TABLE target_pg CASCADE; DROP TABLE source CASCADE; -- TEST for PERMISSIONS CREATE USER priv_user; CREATE USER non_priv_user; CREATE TABLE target ( value DOUBLE PRECISION NOT NULL, time TIMESTAMPTZ NOT NULL ); SELECT table_name FROM create_hypertable( 'target'::regclass, 'time'::name, chunk_time_interval=>interval '8 hours', create_default_indexes=> false); SELECT '2022-10-10 14:33:44.1234+05:30' as start_date \gset INSERT INTO target (value, time) SELECT 1,t from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '5m') t cross join generate_series(1,3) s; CREATE TABLE source ( time TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL, value DOUBLE PRECISION NOT NULL ); SELECT table_name FROM create_hypertable( 'source'::regclass, 'time'::name, chunk_time_interval=>interval '6 hours', create_default_indexes=> false); ALTER TABLE target OWNER TO priv_user; ALTER TABLE source OWNER TO priv_user; GRANT SELECT ON source TO non_priv_user; SET SESSION AUTHORIZATION non_priv_user; \set ON_ERROR_STOP 0 -- non_priv_user does not have UPDATE privilege on target table MERGE INTO target USING source ON target.time = source.time WHEN MATCHED THEN UPDATE SET value = 0; -- non_priv_user does not have DELETE privilege on target table MERGE INTO target USING source ON target.time = source.time WHEN MATCHED THEN DELETE; -- non_priv_user does not have INSERT privilege on target table MERGE INTO target USING source ON target.time = source.time WHEN NOT MATCHED THEN INSERT VALUES (10, '2023-01-15 00:00:10'::timestamp with time zone); \set ON_ERROR_STOP 1 RESET SESSION AUTHORIZATION; DROP TABLE target; DROP TABLE source; DROP USER priv_user; DROP USER non_priv_user; ������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/metadata.sql������������������������������������������������������������0000664�0000000�0000000�00000007570�15100345067�0020143�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_uuid() RETURNS UUID AS :MODULE_PATHNAME, 'ts_test_uuid' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_exported_uuid() RETURNS UUID AS :MODULE_PATHNAME, 'ts_test_exported_uuid' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_install_timestamp() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_test_install_timestamp' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; INSERT INTO _timescaledb_catalog.metadata (key, value, include_in_telemetry) SELECT 'metadata_test', 'FOO', TRUE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- uuid and install_timestamp should already be in the table before we generate SELECT COUNT(*) from _timescaledb_catalog.metadata; SELECT _timescaledb_internal.test_uuid() as uuid_1 \gset SELECT _timescaledb_internal.test_exported_uuid() as uuid_ex_1 \gset SELECT _timescaledb_internal.test_install_timestamp() as timestamp_1 \gset -- Check that there is exactly 1 UUID row SELECT COUNT(*) from _timescaledb_catalog.metadata where key='uuid'; -- Check that exported_uuid and timestamp are also generated SELECT COUNT(*) from _timescaledb_catalog.metadata where key='exported_uuid'; SELECT COUNT(*) from _timescaledb_catalog.metadata where key='install_timestamp'; -- Make sure that the UUID is idempotent SELECT _timescaledb_internal.test_uuid() = :'uuid_1' as uuids_equal; SELECT _timescaledb_internal.test_uuid() = :'uuid_1' as uuids_equal; -- Also make sure install_time and exported_uuid are idempotent SELECT _timescaledb_internal.test_exported_uuid() = :'uuid_ex_1' as exported_uuids_equal; SELECT _timescaledb_internal.test_exported_uuid() = :'uuid_ex_1' as exported_uuids_equal; SELECT _timescaledb_internal.test_install_timestamp() = :'timestamp_1' as timestamps_equal; SELECT _timescaledb_internal.test_install_timestamp() = :'timestamp_1' as timestamps_equal; -- Now make sure that only the exported_uuid is exported on pg_dump \c postgres :ROLE_SUPERUSER \setenv PGOPTIONS '--client-min-messages=warning' \! utils/pg_dump_aux_dump.sh dump/instmeta.sql ALTER DATABASE :TEST_DBNAME SET timescaledb.restoring='on'; -- Redirect to /dev/null to suppress NOTICE \! utils/pg_dump_aux_restore.sh dump/instmeta.sql ALTER DATABASE :TEST_DBNAME SET timescaledb.restoring='off'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Should have all 3 row, because pg_dump includes the insertion of uuid and timestamp. SELECT COUNT(*) FROM _timescaledb_catalog.metadata; -- Verify that this is the old exported_uuid SELECT _timescaledb_internal.test_exported_uuid() = :'uuid_ex_1' as exported_uuids_equal; -- Verify that the uuid is new SELECT _timescaledb_internal.test_uuid() = :'uuid_1' as exported_uuids_diff; -- Verify that the install_timestamp got restored SELECT _timescaledb_internal.test_install_timestamp() = :'timestamp_1' as timestamps_equal; SELECT * FROM _timescaledb_catalog.metadata WHERE key = 'metadata_test'; -- check metadata version matches expected value SELECT x.extversion = m.value AS "version match" FROM pg_extension x JOIN _timescaledb_catalog.metadata m ON m.key='timescaledb_version' WHERE x.extname='timescaledb'; -- test version check in post_restore \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.metadata SET value = '1.2.3' WHERE key = 'timescaledb_version'; \set ON_ERROR_STOP 0 -- set verbosity to sqlstate to suppress version dependant error message \set VERBOSITY sqlstate SELECT timescaledb_post_restore(); \set ON_ERROR_STOP 1 UPDATE _timescaledb_catalog.metadata m SET value = x.extversion FROM pg_extension x WHERE m.key = 'timescaledb_version' AND x.extname='timescaledb'; SELECT timescaledb_post_restore(); ����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/multi_transaction_index.sql���������������������������������������������0000664�0000000�0000000�00000013303�15100345067�0023300�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE index_test(id serial, time timestamptz, device integer, temp float); SELECT * FROM test.show_columns('index_test'); -- Test that we can handle difference in attnos across hypertable and -- chunks by dropping the ID column ALTER TABLE index_test DROP COLUMN id; SELECT * FROM test.show_columns('index_test'); -- No pre-existing UNIQUE index, so partitioning on two columns should work SELECT create_hypertable('index_test', 'time', 'device', 2); INSERT INTO index_test VALUES ('2017-01-20T09:00:01', 1, 17.5); \set ON_ERROR_STOP 0 -- cannot create a UNIQUE index with transaction_per_chunk CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time) WITH (timescaledb.transaction_per_chunk); CREATE UNIQUE INDEX index_test_time_device_idx ON index_test (time, device) WITH(timescaledb.transaction_per_chunk); \set ON_ERROR_STOP 1 CREATE INDEX index_test_time_device_idx ON index_test (time, device) WITH (timescaledb.transaction_per_chunk); -- Regular index need not cover all partitioning columns CREATE INDEX ON index_test (time, temp) WITH (timescaledb.transaction_per_chunk); -- Create another chunk INSERT INTO index_test VALUES ('2017-04-20T09:00:01', 1, 17.5); -- New index should have been recursed to chunks SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk') ORDER BY 1,2; ALTER INDEX index_test_time_idx RENAME TO index_test_time_idx2; -- Metadata and index should have changed name SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk') ORDER BY 1,2; DROP INDEX index_test_time_idx2; DROP INDEX index_test_time_device_idx; -- Index should have been dropped SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Create index with long name to see how this is handled on chunks CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates ON index_test (time ASC, temp DESC) WITH (timescaledb.transaction_per_chunk); CREATE INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2 ON index_test (time DESC, temp ASC) WITH (timescaledb.transaction_per_chunk); SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates; DROP INDEX a_hypertable_index_with_a_very_very_long_name_that_truncates_2; SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Add constraint index ALTER TABLE index_test ADD UNIQUE (time, device); SELECT * FROM test.show_indexes('index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- Constraints are added to chunk_constraint table. SELECT * FROM _timescaledb_catalog.chunk_constraint; DROP TABLE index_test; -- Test that indexes are planned correctly CREATE TABLE index_expr_test(id serial, time timestamptz, temp float, meta int); select create_hypertable('index_expr_test', 'time'); -- Screw up the attribute numbers ALTER TABLE index_expr_test DROP COLUMN id; CREATE INDEX ON index_expr_test (meta) WITH (timescaledb.transaction_per_chunk); INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, 1); INSERT INTO index_expr_test VALUES ('2017-01-20T09:00:01', 17.5, 2); SET enable_seqscan TO false; SET enable_bitmapscan TO false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM index_expr_test WHERE meta = 1; SELECT * FROM index_expr_test WHERE meta = 1; SET enable_seqscan TO default; SET enable_bitmapscan TO default; \set ON_ERROR_STOP 0 -- cannot create a transaction_per_chunk index within a transaction block BEGIN; CREATE INDEX ON index_expr_test (temp) WITH (timescaledb.transaction_per_chunk); ROLLBACK; \set ON_ERROR_STOP 1 DROP TABLE index_expr_test CASCADE; CREATE TABLE partial_index_test(time INTEGER); SELECT create_hypertable('partial_index_test', 'time', chunk_time_interval => 1, create_default_indexes => false); -- create 3 chunks INSERT INTO partial_index_test(time) SELECT generate_series(0, 2); select * from partial_index_test order by 1; -- create indexes on only 1 of the chunks CREATE INDEX ON partial_index_test (time) WITH (timescaledb.transaction_per_chunk, timescaledb.max_chunks='1'); SELECT * FROM test.show_indexes('partial_index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- regerssion test for bug fixed by PR #1008. -- this caused an assertion failure when a MergeAppend node contained unsorted children SET enable_bitmapscan TO false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; -- we can drop the partially created index DROP INDEX partial_index_test_time_idx; SELECT * FROM test.show_indexes('partial_index_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); EXPLAIN (verbose, buffers off, costs off) SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; SELECT * FROM partial_index_test WHERE time < 2 ORDER BY time LIMIT 2; SET enable_seqscan TO true; SET enable_bitmapscan TO true; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CREATE INDEX ON partial_index_test (time) WITH (timescaledb.transaction_per_chunk, timescaledb.max_chunks='1'); \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/net.sql�����������������������������������������������������������������0000664�0000000�0000000�00000002215�15100345067�0017140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_http_parsing(int) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_http_parsing' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_http_parsing_full() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_http_parsing_full' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_http_request_build() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_http_request_build' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_conn() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_conn' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT _timescaledb_internal.test_http_parsing(10000); SELECT _timescaledb_internal.test_http_parsing_full(); SELECT _timescaledb_internal.test_http_request_build(); SELECT _timescaledb_internal.test_conn(); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/null_exclusion.sql.in���������������������������������������������������0000664�0000000�0000000�00000002175�15100345067�0022027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. create table metrics(ts timestamp, id int, value float); select create_hypertable('metrics', 'ts'); insert into metrics values ('2022-02-02 02:02:02', 2, 2.), ('2023-03-03 03:03:03', 3, 3.); analyze metrics; -- non-const condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics); -- two non-const conditions explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics) and id = 1; -- condition that becomes const null after evaluating the param explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1); -- const null condition and some other condition explain (analyze, buffers off, costs off, summary off, timing off) select * from metrics where ts >= (select max(ts) from metrics where id = -1) and id = 1; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/parallel.sql.in���������������������������������������������������������0000664�0000000�0000000�00000020700�15100345067�0020552�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --parallel queries require big-ish tables so collect them all here --so that we need to generate queries only once. -- output with analyze is not stable because it depends on worker assignment \set PREFIX 'EXPLAIN (buffers off, costs off)' \set CHUNK1 _timescaledb_internal._hyper_1_1_chunk \set CHUNK2 _timescaledb_internal._hyper_1_2_chunk CREATE TABLE test (i int, j double precision, ts timestamp); SELECT create_hypertable('test','i',chunk_time_interval:=500000); INSERT INTO test SELECT x, x+0.1, _timescaledb_functions.to_timestamp(x*1000) FROM generate_series(0,1000000-1,10) AS x; ANALYZE test; ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=2); SET work_mem TO '50MB'; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost TO 0; EXPLAIN (buffers off, costs off) SELECT first(i, j) FROM "test"; SELECT first(i, j) FROM "test"; EXPLAIN (buffers off, costs off) SELECT last(i, j) FROM "test"; SELECT last(i, j) FROM "test"; EXPLAIN (buffers off, costs off) SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; -- test single copy parallel plan with parallel chunk append :PREFIX SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" WHERE length(version()) > 0 GROUP BY sec ORDER BY sec LIMIT 5; SELECT time_bucket('1 second', ts) sec, last(i, j) FROM "test" GROUP BY sec ORDER BY sec LIMIT 5; --test variants of histogram EXPLAIN (buffers off, costs off) SELECT histogram(i, 1, 1000000, 2) FROM "test"; SELECT histogram(i, 1, 1000000, 2) FROM "test"; EXPLAIN (buffers off, costs off) SELECT histogram(i, 1,1000001,10) FROM "test"; SELECT histogram(i, 1, 1000001, 10) FROM "test"; EXPLAIN (buffers off, costs off) SELECT histogram(i, 0,100000,5) FROM "test"; SELECT histogram(i, 0, 100000, 5) FROM "test"; EXPLAIN (buffers off, costs off) SELECT histogram(i, 10,100000,5) FROM "test"; SELECT histogram(i, 10, 100000, 5) FROM "test"; EXPLAIN (buffers off, costs off) SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); SELECT histogram(NULL, 10,100000,5) FROM "test" WHERE i = coalesce(-1,j); -- test parallel ChunkAppend :PREFIX SELECT i FROM "test" WHERE length(version()) > 0; :PREFIX SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; -- test parallel ChunkAppend with only work done in the parallel workers SET parallel_leader_participation = off; SELECT count(*) FROM "test" WHERE i > 1 AND length(version()) > 0; RESET parallel_leader_participation; -- Test parallel chunk append is used (index scan is disabled to trigger a parallel chunk append) SET parallel_tuple_cost = 0; SET enable_indexscan = OFF; :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; SELECT * FROM (SELECT * FROM "test" WHERE length(version()) > 0 ORDER BY I LIMIT 10) AS t1 LEFT JOIN (SELECT * FROM "test" WHERE i < 500000 ORDER BY I LIMIT 10) AS t2 ON (t1.i = t2.i) ORDER BY t1.i, t2.i; SET enable_indexscan = ON; -- Test normal chunk append can be used in a parallel worker :PREFIX SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; SELECT * FROM (SELECT * FROM "test" WHERE i >= 999000 ORDER BY i) AS t1 JOIN (SELECT * FROM "test" WHERE i >= 400000 ORDER BY i) AS t2 ON (TRUE) ORDER BY t1.i, t2.i LIMIT 10; -- Test parallel ChunkAppend reinit SET enable_material = off; SET min_parallel_table_scan_size = 0; SET min_parallel_index_scan_size = 0; SET enable_hashjoin = 'off'; SET enable_nestloop = 'off'; CREATE TABLE sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL); SELECT FROM create_hypertable(relation=>'sensor_data', time_column_name=> 'time'); -- Sensors 1 and 2 INSERT INTO sensor_data SELECT time, sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '3 months') AS g1(time), generate_series(1, 2, 1) AS g2(sensor_id) ORDER BY time; -- Sensor 100 INSERT INTO sensor_data SELECT time, 100 as sensor_id FROM generate_series('2000-01-01 00:00:30', '2022-01-01 00:00:30', INTERVAL '1 year') AS g1(time) ORDER BY time; :PREFIX SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; -- Check query result SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; -- Ensure the same result is produced if only the parallel workers have to produce them (i.e., the pstate is reinitialized properly) SET parallel_leader_participation = off; SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; RESET parallel_leader_participation; -- Ensure the same query result is produced by a sequencial query SET max_parallel_workers_per_gather TO 0; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); SELECT * FROM sensor_data AS s1 JOIN sensor_data AS s2 ON (TRUE) WHERE s1.time > '2020-01-01 00:00:30'::text::timestamptz AND s2.time > '2020-01-01 00:00:30' AND s2.time < '2021-01-01 00:00:30' AND s1.sensor_id > 50 ORDER BY s2.time, s1.time, s1.sensor_id, s2.sensor_id; RESET enable_material; RESET min_parallel_table_scan_size; RESET min_parallel_index_scan_size; RESET enable_hashjoin; RESET enable_nestloop; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); -- test worker assignment -- first chunk should have 1 worker and second chunk should have 2 SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; SELECT count(*) FROM "test" WHERE i >= 400000 AND length(version()) > 0; -- test worker assignment -- first chunk should have 2 worker and second chunk should have 1 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; -- test ChunkAppend with # workers < # childs SET max_parallel_workers_per_gather TO 1; :PREFIX SELECT count(*) FROM "test" WHERE length(version()) > 0; SELECT count(*) FROM "test" WHERE length(version()) > 0; -- test ChunkAppend with # workers > # childs SET max_parallel_workers_per_gather TO 2; :PREFIX SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; SELECT count(*) FROM "test" WHERE i >= 500000 AND length(version()) > 0; RESET max_parallel_workers_per_gather; -- test partial and non-partial plans -- these will not be parallel on PG < 11 ALTER TABLE :CHUNK1 SET (parallel_workers=0); ALTER TABLE :CHUNK2 SET (parallel_workers=2); :PREFIX SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0; ALTER TABLE :CHUNK1 SET (parallel_workers=2); ALTER TABLE :CHUNK2 SET (parallel_workers=0); :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0; ALTER TABLE :CHUNK1 RESET (parallel_workers); ALTER TABLE :CHUNK2 RESET (parallel_workers); -- now() is not marked parallel safe in PostgreSQL < 12 so using now() -- in a query will prevent parallelism but CURRENT_TIMESTAMP and -- transaction_timestamp() are marked parallel safe :PREFIX SELECT i FROM "test" WHERE ts < CURRENT_TIMESTAMP; :PREFIX SELECT i FROM "test" WHERE ts < transaction_timestamp(); -- this won't be parallel query because now() is parallel restricted in PG < 12 :PREFIX SELECT i FROM "test" WHERE ts < now(); ����������������������������������������������������������������timescaledb-2.23.0/test/sql/partition.sql�����������������������������������������������������������0000664�0000000�0000000�00000025545�15100345067�0020376�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE part_legacy(time timestamptz, temp float, device int); SELECT create_hypertable('part_legacy', 'time', 'device', 2, partitioning_func => '_timescaledb_functions.get_partition_for_key'); -- Show legacy partitioning function is used SELECT * FROM _timescaledb_catalog.dimension; INSERT INTO part_legacy VALUES ('2017-03-22T09:18:23', 23.4, 1); INSERT INTO part_legacy VALUES ('2017-03-22T09:18:23', 23.4, 76); VACUUM part_legacy; -- Show two chunks and CHECK constraint with cast SELECT * FROM test.show_constraintsp('_timescaledb_internal._hyper_1_%_chunk'); -- Make sure constraint exclusion works on device column BEGIN; -- For plan stability between versions SET LOCAL enable_bitmapscan = false; SET LOCAL enable_indexscan = false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_legacy WHERE device = 1; COMMIT; CREATE TABLE part_new(time timestamptz, temp float, device int); SELECT create_hypertable('part_new', 'time', 'device', 2); SELECT * FROM _timescaledb_catalog.dimension; INSERT INTO part_new VALUES ('2017-03-22T09:18:23', 23.4, 1); INSERT INTO part_new VALUES ('2017-03-22T09:18:23', 23.4, 2); VACUUM part_new; -- Show two chunks and CHECK constraint without cast SELECT * FROM test.show_constraintsp('_timescaledb_internal._hyper_2_%_chunk'); -- Make sure constraint exclusion works on device column BEGIN; -- For plan stability between versions SET LOCAL enable_bitmapscan = false; SET LOCAL enable_indexscan = false; EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_new WHERE device = 1; COMMIT; CREATE TABLE part_new_convert1(time timestamptz, temp float8, device int); SELECT create_hypertable('part_new_convert1', 'time', 'temp', 2); INSERT INTO part_new_convert1 VALUES ('2017-03-22T09:18:23', 1.0, 2); \set ON_ERROR_STOP 0 -- Changing the type of a hash-partitioned column should not be supported ALTER TABLE part_new_convert1 ALTER COLUMN temp TYPE numeric; \set ON_ERROR_STOP 1 -- Should be able to change if not hash partitioned though ALTER TABLE part_new_convert1 ALTER COLUMN time TYPE timestamp; SELECT * FROM test.show_columnsp('_timescaledb_internal._hyper_3_%_chunk'); CREATE TABLE part_add_dim(time timestamptz, temp float8, device int, location int); SELECT create_hypertable('part_add_dim', 'time', 'temp', 2); \set ON_ERROR_STOP 0 SELECT add_dimension('part_add_dim', 'location', 2, partitioning_func => 'bad_func'); \set ON_ERROR_STOP 1 SELECT add_dimension('part_add_dim', 'location', 2, partitioning_func => '_timescaledb_functions.get_partition_for_key'); SELECT * FROM _timescaledb_catalog.dimension; -- Test that we support custom SQL-based partitioning functions and -- that our native partitioning function handles function expressions -- as argument CREATE OR REPLACE FUNCTION custom_partfunc(source anyelement) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval INTEGER; BEGIN retval = _timescaledb_functions.get_partition_hash(substring(source::text FROM '[A-za-z0-9 ]+')); RAISE NOTICE 'hash value for % is %', source, retval; RETURN retval; END $BODY$; CREATE TABLE part_custom_func(time timestamptz, temp float8, device text); SELECT create_hypertable('part_custom_func', 'time', 'device', 2, partitioning_func => 'custom_partfunc'); SELECT _timescaledb_functions.get_partition_hash(substring('dev1' FROM '[A-za-z0-9 ]+')); SELECT _timescaledb_functions.get_partition_hash('dev1'::text); SELECT _timescaledb_functions.get_partition_hash('dev7'::text); INSERT INTO part_custom_func VALUES ('2017-03-22T09:18:23', 23.4, 'dev1'), ('2017-03-22T09:18:23', 23.4, 'dev7'); SELECT * FROM test.show_subtables('part_custom_func'); -- This first test is slightly trivial, but segfaulted in old versions CREATE TYPE simpl AS (val1 int4); CREATE OR REPLACE FUNCTION simpl_type_hash(ANYELEMENT) RETURNS int4 AS $$ SELECT $1.val1; $$ LANGUAGE SQL IMMUTABLE; CREATE TABLE simpl_partition ("timestamp" TIMESTAMPTZ, object simpl); SELECT create_hypertable( 'simpl_partition', 'timestamp', 'object', 1000, chunk_time_interval => interval '1 day', partitioning_func=>'simpl_type_hash'); INSERT INTO simpl_partition VALUES ('2017-03-22T09:18:23', ROW(1)::simpl); SELECT * from simpl_partition; -- Also test that the fix works when we have more chunks than allowed at once SET timescaledb.max_open_chunks_per_insert=1; INSERT INTO simpl_partition VALUES ('2017-03-22T10:18:23', ROW(0)::simpl), ('2017-03-22T10:18:23', ROW(1)::simpl), ('2017-03-22T10:18:23', ROW(2)::simpl), ('2017-03-22T10:18:23', ROW(3)::simpl), ('2017-03-22T10:18:23', ROW(4)::simpl), ('2017-03-22T10:18:23', ROW(5)::simpl); SET timescaledb.max_open_chunks_per_insert=default; SELECT * from simpl_partition; -- Test that index creation is handled correctly. CREATE TABLE hyper_with_index(time timestamptz, temp float, device int); CREATE UNIQUE INDEX temp_index ON hyper_with_index(temp); \set ON_ERROR_STOP 0 SELECT create_hypertable('hyper_with_index', 'time'); SELECT create_hypertable('hyper_with_index', 'time', 'device', 2); SELECT create_hypertable('hyper_with_index', 'time', 'temp', 2); \set ON_ERROR_STOP 1 DROP INDEX temp_index; CREATE UNIQUE INDEX time_index ON hyper_with_index(time); \set ON_ERROR_STOP 0 -- should error because device not in index SELECT create_hypertable('hyper_with_index', 'time', 'device', 4); \set ON_ERROR_STOP 1 SELECT create_hypertable('hyper_with_index', 'time'); -- make sure user created index is used. -- not using \d or \d+ because output syntax differs -- between postgres 9 and postgres 10. SELECT indexname FROM pg_indexes WHERE tablename = 'hyper_with_index'; \set ON_ERROR_STOP 0 SELECT add_dimension('hyper_with_index', 'device', 4); \set ON_ERROR_STOP 1 DROP INDEX time_index; CREATE UNIQUE INDEX time_space_index ON hyper_with_index(time, device); SELECT add_dimension('hyper_with_index', 'device', 4); CREATE TABLE hyper_with_primary(time TIMESTAMPTZ PRIMARY KEY, temp float, device int); \set ON_ERROR_STOP 0 SELECT create_hypertable('hyper_with_primary', 'time', 'device', 4); \set ON_ERROR_STOP 1 SELECT create_hypertable('hyper_with_primary', 'time'); \set ON_ERROR_STOP 0 SELECT add_dimension('hyper_with_primary', 'device', 4); \set ON_ERROR_STOP 1 -- NON-unique indexes can still be created CREATE INDEX temp_index ON hyper_with_index(temp); -- Make sure custom composite types are supported as dimensions CREATE TYPE TUPLE as (val1 int4, val2 int4); CREATE FUNCTION tuple_hash(value ANYELEMENT) RETURNS INT4 LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'custom hash value is: %', value.val1+value.val2; RETURN value.val1+value.val2; END $BODY$; CREATE TABLE part_custom_dim (time TIMESTAMPTZ, combo TUPLE, device TEXT); SELECT create_hypertable('part_custom_dim', 'time', 'combo', 4, partitioning_func=>'tuple_hash'); INSERT INTO part_custom_dim(time, combo) VALUES (now(), (1,2)); DROP TABLE part_custom_dim; -- Now make sure that renaming partitioning_func_schema will get updated properly \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_partitioning_schema; CREATE FUNCTION my_partitioning_schema.tuple_hash(value ANYELEMENT) RETURNS INT4 LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RAISE NOTICE 'custom hash value is: %', value.val1+value.val2; RETURN value.val1+value.val2; END $BODY$; CREATE TABLE part_custom_dim (time TIMESTAMPTZ, combo TUPLE, device TEXT); SELECT create_hypertable('part_custom_dim', 'time', 'combo', 4, partitioning_func=>'my_partitioning_schema.tuple_hash'); INSERT INTO part_custom_dim(time, combo) VALUES (now(), (1,2)); ALTER SCHEMA my_partitioning_schema RENAME TO new_partitioning_schema; -- Inserts should work even after we rename the schema INSERT INTO part_custom_dim(time, combo) VALUES (now(), (3,4)); -- Test partitioning function on an open (time) dimension CREATE OR REPLACE FUNCTION time_partfunc(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RAISE NOTICE 'time value for % is %', unixtime, timezone('UTC', retval); RETURN retval; END $BODY$; CREATE OR REPLACE FUNCTION time_partfunc_bad_parameters(unixtime float8, extra text) RETURNS TIMESTAMPTZ LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT to_timestamp(unixtime); $BODY$; CREATE OR REPLACE FUNCTION time_partfunc_bad_return_type(unixtime float8) RETURNS FLOAT8 LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT unixtime; $BODY$; CREATE TABLE part_time_func(time float8, temp float8, device text); \set ON_ERROR_STOP 0 -- Should fail due to invalid time column SELECT create_hypertable('part_time_func', 'time'); -- Should fail due to bad signature of time partitioning function SELECT create_hypertable('part_time_func', 'time', time_partitioning_func => 'time_partfunc_bad_parameters'); SELECT create_hypertable('part_time_func', 'time', time_partitioning_func => 'time_partfunc_bad_return_type'); \set ON_ERROR_STOP 1 -- Should work with time partitioning function that returns a valid time type SELECT create_hypertable('part_time_func', 'time', time_partitioning_func => 'time_partfunc'); INSERT INTO part_time_func VALUES (1530214157.134, 23.4, 'dev1'), (1533214157.8734, 22.3, 'dev7'); SELECT time, temp, device FROM part_time_func; SELECT time_partfunc(time) at time zone 'UTC', temp, device FROM part_time_func; SELECT * FROM test.show_subtables('part_time_func'); SELECT (test.show_constraints("Child")).* FROM test.show_subtables('part_time_func'); SELECT (test.show_indexes("Child")).* FROM test.show_subtables('part_time_func'); -- Check that constraint exclusion works with time partitioning -- function (scan only one chunk) -- No exclusion EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_time_func; -- Exclude using the function on time EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_time_func WHERE time_partfunc(time) < '2018-07-01'; -- Exclude using the same date but as a UNIX timestamp. Won't do an -- index scan since the index is on the time function expression EXPLAIN (verbose, buffers off, costs off) SELECT * FROM part_time_func WHERE time < 1530403200.0; -- Check that inserts will fail if we use a time partitioning function -- that returns NULL CREATE OR REPLACE FUNCTION time_partfunc_null_ret(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN RETURN NULL; END $BODY$; CREATE TABLE part_time_func_null_ret(time float8, temp float8, device text); SELECT create_hypertable('part_time_func_null_ret', 'time', time_partitioning_func => 'time_partfunc_null_ret'); \set ON_ERROR_STOP 0 INSERT INTO part_time_func_null_ret VALUES (1530214157.134, 23.4, 'dev1'), (1533214157.8734, 22.3, 'dev7'); \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/partitioning.sql��������������������������������������������������������0000664�0000000�0000000�00000002453�15100345067�0021065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Should expect an error when creating a hypertable from a partition \set ON_ERROR_STOP 0 CREATE TABLE partitioned_ht_create(time timestamptz, temp float, device int) PARTITION BY RANGE (time); SELECT create_hypertable('partitioned_ht_create', 'time'); \set ON_ERROR_STOP 1 -- Should expect an error when attaching a hypertable to a partition \set ON_ERROR_STOP 0 CREATE TABLE partitioned_attachment_vanilla(time timestamptz, temp float, device int) PARTITION BY RANGE (time); CREATE TABLE attachment_hypertable(time timestamptz, temp float, device int); SELECT create_hypertable('attachment_hypertable', 'time'); ALTER TABLE partitioned_attachment_vanilla ATTACH PARTITION attachment_hypertable FOR VALUES FROM ('2016-07-01') TO ('2016-08-01'); \set ON_ERROR_STOP 1 -- Should not expect an error when attaching a normal table to a partition CREATE TABLE partitioned_vanilla(time timestamptz, temp float, device int) PARTITION BY RANGE (time); CREATE TABLE attachment_vanilla(time timestamptz, temp float, device int); ALTER TABLE partitioned_vanilla ATTACH PARTITION attachment_vanilla FOR VALUES FROM ('2016-07-01') TO ('2016-08-01'); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/partitionwise.sql.in����������������������������������������������������0000664�0000000�0000000�00000017303�15100345067�0021664�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- Create a two dimensional hypertable CREATE TABLE hyper (time timestamptz, device int, temp float); SELECT * FROM create_hypertable('hyper', 'time', 'device', 2); -- Create a similar PostgreSQL partitioned table CREATE TABLE pg2dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg2dim_h1 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 0) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h2 PARTITION OF pg2dim FOR VALUES WITH (MODULUS 2, REMAINDER 1) PARTITION BY RANGE(time); CREATE TABLE pg2dim_h1_t1 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h1_t2 PARTITION OF pg2dim_h1 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); CREATE TABLE pg2dim_h2_t1 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-01-01 00:00') TO ('2018-09-01 00:00'); CREATE TABLE pg2dim_h2_t2 PARTITION OF pg2dim_h2 FOR VALUES FROM ('2018-09-01 00:00') TO ('2018-12-01 00:00'); -- Create a 1-dimensional partitioned table for comparison CREATE TABLE pg1dim (time timestamptz, device int, temp float) PARTITION BY HASH (device); CREATE TABLE pg1dim_h1 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE pg1dim_h2 PARTITION OF pg1dim FOR VALUES WITH (MODULUS 2, REMAINDER 1); INSERT INTO hyper VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg2dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); INSERT INTO pg1dim VALUES ('2018-02-19 13:01', 1, 2.3), ('2018-02-19 13:02', 3, 3.1), ('2018-10-19 13:01', 1, 7.6), ('2018-10-19 13:02', 3, 9.0); SELECT * FROM test.show_subtables('hyper'); SELECT * FROM pg2dim_h1_t1; SELECT * FROM pg2dim_h1_t2; SELECT * FROM pg2dim_h2_t1; SELECT * FROM pg2dim_h2_t2; -- Compare partitionwise aggreate enabled/disabled. First run queries -- on PG partitioned tables for reference. -- All partition keys covered by GROUP BY SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg1dim GROUP BY 1 ORDER BY 1; -- All partition keys not covered by GROUP BY (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT device, avg(temp) FROM pg2dim GROUP BY 1 ORDER BY 1; -- All partition keys covered by GROUP BY (full partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT time, device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; -- All partition keys not covered by GROUP BY because of date_trunc -- expression on time (partial partitionwise) SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM pg2dim GROUP BY 1, 2 ORDER BY 1, 2; -- Now run on hypertable -- All partition keys not covered by GROUP BY (partial partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT device, avg(temp) FROM hyper GROUP BY 1 ORDER BY 1; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; -- Partial aggregation since date_trunc(time) is not a partition key SET enable_partitionwise_aggregate = 'off'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. SET enable_partitionwise_aggregate = 'on'; :PREFIX SELECT date_trunc('month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; -- Also test time_bucket SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time_bucket('1 month', time), device, avg(temp) FROM hyper GROUP BY 1, 2 ORDER BY 1, 2; -- Test partitionwise joins, mostly to see that we do not break -- anything CREATE TABLE hyper_meta (time timestamptz, device int, info text); SELECT * FROM create_hypertable('hyper_meta', 'time', 'device', 2); INSERT INTO hyper_meta VALUES ('2018-02-19 13:01', 1, 'device_1'), ('2018-02-19 13:02', 3, 'device_3'); SET enable_partitionwise_join = 'off'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; SET enable_partitionwise_join = 'on'; :PREFIX SELECT h.time, h.device, h.temp, hm.info FROM hyper h, hyper_meta hm WHERE h.device = hm.device; :PREFIX SELECT pg2.time, pg2.device, pg2.temp, pg1.temp FROM pg2dim pg2, pg1dim pg1 WHERE pg2.device = pg1.device; -- Test hypertable with time partitioning function CREATE OR REPLACE FUNCTION time_func(unixtime float8) RETURNS TIMESTAMPTZ LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval TIMESTAMPTZ; BEGIN retval := to_timestamp(unixtime); RETURN retval; END $BODY$; CREATE TABLE hyper_timepart (time float8, device int, temp float); SELECT * FROM create_hypertable('hyper_timepart', 'time', 'device', 2, time_partitioning_func => 'time_func'); -- Planner won't pick push-down aggs on table with time function -- unless a certain amount of data SELECT setseed(1); INSERT INTO hyper_timepart SELECT x, ceil(random() * 8), random() * 20 FROM generate_series(0,5000-1) AS x; -- All partition keys covered (full partitionwise) SET timescaledb.enable_chunkwise_aggregation = 'off'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; -- Grouping on original time column should be pushed-down SET timescaledb.enable_chunkwise_aggregation = 'on'; :PREFIX SELECT time, device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; -- Applying the time partitioning function should also allow push-down -- on open dimensions :PREFIX SELECT time_func(time), device, avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; -- Partial aggregation pushdown is currently not supported for this query by -- the TSDB pushdown code since a projection is used in the path. :PREFIX SELECT time_func(time), _timescaledb_functions.get_partition_hash(device), avg(temp) FROM hyper_timepart GROUP BY 1, 2 ORDER BY 1, 2 LIMIT 10; -- Test removal of redundant group key optimization in PG16 -- All lower versions include the redundant key on device column :PREFIX SELECT device, avg(temp) FROM hyper_timepart WHERE device = 1 GROUP BY 1 LIMIT 10; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/pg_dump.sql�������������������������������������������������������������0000664�0000000�0000000�00000022711�15100345067�0020010�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_DBNAME_EXTRA :TEST_DBNAME _extra \o /dev/null \ir include/insert_two_partitions.sql \o \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION bgw_wait(database TEXT, timeout INT, raise_error BOOLEAN DEFAULT TRUE) RETURNS VOID AS :MODULE_PATHNAME, 'ts_bgw_wait' LANGUAGE C VOLATILE; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME ALTER TABLE PUBLIC."two_Partitions" SET SCHEMA "test_schema"; -- Test that we can restore constraints ALTER TABLE "test_schema"."two_Partitions" ADD CONSTRAINT timeCustom_device_id_series_2_key UNIQUE ("timeCustom", device_id, series_2); -- Test that we can restore triggers CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN RETURN NEW; END $BODY$; -- Test that a custom chunk sizing function is restored CREATE OR REPLACE FUNCTION custom_calculate_chunk_interval( dimension_id INTEGER, dimension_coord BIGINT, chunk_target_size BIGINT ) RETURNS BIGINT LANGUAGE PLPGSQL AS $BODY$ DECLARE BEGIN RETURN -1; END $BODY$; SELECT * FROM set_adaptive_chunking('"test_schema"."two_Partitions"', '1 MB', 'custom_calculate_chunk_interval'); -- Chunk sizing func set SELECT * FROM _timescaledb_catalog.hypertable; SELECT proname, pronamespace, pronargs FROM pg_proc WHERE proname = 'custom_calculate_chunk_interval'; CREATE TRIGGER restore_trigger BEFORE INSERT ON "test_schema"."two_Partitions" FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- Save the number of dependent objects so we can make sure we have the same number later SELECT count(*) as num_dependent_objects FROM pg_depend WHERE refclassid = 'pg_extension'::regclass AND refobjid = (SELECT oid FROM pg_extension WHERE extname = 'timescaledb') \gset SELECT * FROM test.show_columns('"test_schema"."two_Partitions"'); SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_indexes('"test_schema"."two_Partitions"'); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_constraints('"test_schema"."two_Partitions"'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_triggers('"test_schema"."two_Partitions"'); SELECT * FROM test.show_triggers('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM "test_schema"."two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; SELECT * FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY "timeCustom", device_id, series_0, series_1; SELECT * FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY "timeCustom", device_id, series_0, series_1; -- Show all constraints SELECT * FROM _timescaledb_catalog.chunk_constraint; INSERT INTO _timescaledb_catalog.metadata VALUES ('exported_uuid', 'original_uuid', true); INSERT INTO _timescaledb_catalog.metadata VALUES ('metadata_test', 'FOO', false); \c postgres :ROLE_SUPERUSER -- We shell out to a script in order to grab the correct hostname from the -- environmental variables that originally called this psql command. Sadly -- vars passed to psql do not work in \! commands so we can't do it that way. \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; --create a exported uuid before restoring (mocks telemetry running before restore) INSERT INTO _timescaledb_catalog.metadata VALUES ('exported_uuid', 'new_db_uuid', true); -- disable background jobs UPDATE _timescaledb_config.bgw_job SET scheduled = false; RESET client_min_messages; SELECT timescaledb_pre_restore(); SHOW timescaledb.restoring; -- reconnect and check GUC value in new session \c SHOW timescaledb.restoring; \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql -- Now run our post-restore function. SELECT timescaledb_post_restore(); SHOW timescaledb.restoring; -- timescaledb_post_restore restarts background worker so we have to stop them -- to make sure they dont interfere with this database being used as template below SELECT _timescaledb_functions.stop_background_workers(); --should be same as count above SELECT count(*) = :num_dependent_objects as dependent_objects_match FROM pg_depend WHERE refclassid = 'pg_extension'::regclass AND refobjid = (SELECT oid FROM pg_extension WHERE extname = 'timescaledb'); --we should have the original uuid from the backed up db set as the exported_uuid SELECT value = 'original_uuid' FROM _timescaledb_catalog.metadata WHERE key='exported_uuid'; SELECT count(*) = 1 FROM _timescaledb_catalog.metadata WHERE key LIKE 'exported%'; --we should have the original value of metadata_test SELECT * FROM _timescaledb_catalog.metadata WHERE key='metadata_test'; --main table and chunk schemas should be the same SELECT * FROM test.show_columns('"test_schema"."two_Partitions"'); SELECT * FROM test.show_columns('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_indexes('"test_schema"."two_Partitions"'); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_constraints('"test_schema"."two_Partitions"'); SELECT * FROM test.show_constraints('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_triggers('"test_schema"."two_Partitions"'); SELECT * FROM test.show_triggers('_timescaledb_internal._hyper_1_1_chunk'); --data should be the same SELECT * FROM "test_schema"."two_Partitions" ORDER BY "timeCustom", device_id, series_0, series_1; SELECT * FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY "timeCustom", device_id, series_0, series_1; SELECT * FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY "timeCustom", device_id, series_0, series_1; SELECT * FROM _timescaledb_catalog.chunk_constraint; --Chunk sizing function should have been restored SELECT * FROM _timescaledb_catalog.hypertable; SELECT proname, pronamespace, pronargs FROM pg_proc WHERE proname = 'custom_calculate_chunk_interval'; --check simple ddl still works ALTER TABLE "test_schema"."two_Partitions" ADD COLUMN series_3 integer; INSERT INTO "test_schema"."two_Partitions"("timeCustom", device_id, series_0, series_1, series_3) VALUES (1357894000000000000, 'dev5', 1.5, 2, 4); SELECT * FROM ONLY "test_schema"."two_Partitions"; --query for the extension tables/sequences that will not be dumped by pg_dump (should --be empty except for views and explicitly excluded tables) SELECT objid::regclass FROM pg_catalog.pg_depend WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass AND refobjid = (select oid from pg_extension where extname='timescaledb') AND deptype = 'e' AND classid='pg_catalog.pg_class'::pg_catalog.regclass AND objid NOT IN (select unnest(extconfig) from pg_extension where extname='timescaledb') ORDER BY objid::regclass::text COLLATE "C"; -- Make sure we can't run our restoring functions as a normal perm user as that would disable functionality for the whole db \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Hides error messages in cases where error messages differ between Postgres versions create or replace function get_sqlstate(in_text TEXT) RETURNS TEXT AS $$ BEGIN BEGIN EXECUTE in_text; EXCEPTION WHEN others THEN GET STACKED DIAGNOSTICS in_text = RETURNED_SQLSTATE; END; RETURN in_text; END; $$ LANGUAGE PLPGSQL; SELECT get_sqlstate('SELECT timescaledb_pre_restore()'); SELECT get_sqlstate('SELECT timescaledb_post_restore()'); drop function get_sqlstate(TEXT); -- Check that the extension can be copied from an existing database -- without explicitly installing it. Stop background workers since we -- cannot have any backends connected to the database when cloning it. \c :TEST_DBNAME :ROLE_SUPERUSER SELECT timescaledb_pre_restore(); SELECT bgw_wait(:'TEST_DBNAME', 60, FALSE); -- Force other sessions connected to the TEST_DBNAME to be finished \c postgres :ROLE_SUPERUSER REVOKE CONNECT ON DATABASE :TEST_DBNAME FROM public; ALTER DATABASE :TEST_DBNAME allow_connections = off; SET client_min_messages TO ERROR; SELECT COUNT(pg_catalog.pg_terminate_backend(pid))>=0 FROM pg_stat_activity WHERE datname = ':TEST_DBNAME'; RESET client_min_messages; CREATE DATABASE :TEST_DBNAME_EXTRA WITH TEMPLATE :TEST_DBNAME; ALTER DATABASE :TEST_DBNAME allow_connections = on; GRANT CONNECT ON DATABASE :TEST_DBNAME TO public; -- Connect to the database and do some basic stuff to check that the -- extension works. \c :TEST_DBNAME_EXTRA :ROLE_DEFAULT_PERM_USER CREATE TABLE test_tz(time timestamptz not null, temp float8, device text); SELECT create_hypertable('test_tz', 'time', 'device', 2); SELECT id, schema_name, table_name FROM _timescaledb_catalog.hypertable; INSERT INTO test_tz VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_tz VALUES('Mon Mar 20 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_tz ORDER BY time; \c :TEST_DBNAME :ROLE_SUPERUSER -- make sure nobody is using it SET client_min_messages TO ERROR; REVOKE CONNECT ON DATABASE :TEST_DBNAME_EXTRA FROM public; SELECT count(pg_terminate_backend(pg_stat_activity.pid)) AS TERMINATED FROM pg_stat_activity WHERE pg_stat_activity.datname = :'TEST_DBNAME_EXTRA' AND pg_stat_activity.pid <> pg_backend_pid() \gset RESET client_min_messages; DROP DATABASE :TEST_DBNAME_EXTRA WITH (FORCE); �������������������������������������������������������timescaledb-2.23.0/test/sql/pg_dump_unprivileged.sql������������������������������������������������0000664�0000000�0000000�00000001674�15100345067�0022572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c template1 :ROLE_SUPERUSER SET client_min_messages TO ERROR; CREATE EXTENSION IF NOT EXISTS timescaledb; RESET client_min_messages; CREATE USER dump_unprivileged CREATEDB; \c template1 dump_unprivileged CREATE database dump_unprivileged; \! utils/pg_dump_unprivileged.sh \c dump_unprivileged :ROLE_SUPERUSER DROP EXTENSION timescaledb; GRANT ALL ON DATABASE dump_unprivileged TO dump_unprivileged; \c dump_unprivileged dump_unprivileged -- Create the timescale extension and table as underprivileged user CREATE EXTENSION timescaledb; CREATE TABLE t1 (a int); -- pg_dump currently fails when dumped \! utils/pg_dump_unprivileged.sh \c template1 :ROLE_SUPERUSER DROP EXTENSION timescaledb; DROP DATABASE dump_unprivileged WITH (FORCE); DROP USER dump_unprivileged; ��������������������������������������������������������������������timescaledb-2.23.0/test/sql/pg_join.sql�������������������������������������������������������������0000664�0000000�0000000�00000003161�15100345067�0020000�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- this test suite is based on the postgres join tests -- -- the tests have been adjusted to work with hypertables -- statements that would generate an error have been commented out -- because errors don't play nicely with psql output redirection -- plan output has been disabled, because we are not interested in -- the actual plans produced but in the correctness of the results -- we need superuser because some of the tests modify statistics \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME join SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset set client_min_messages to warning; \ir :TEST_LOAD_NAME \set PREFIX '' \set ECHO errors -- get results with optimizations disabled \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME \o -- get query results with all optimizations \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME \o :DIFF_CMD ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/plain.sql���������������������������������������������������������������0000664�0000000�0000000�00000002203�15100345067�0017452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Tests for plain PostgreSQL commands to ensure that they work while -- the TimescaleDB extension is loaded. This is a mix of statements -- added mostly as regression checks when bugs are discovered and -- fixed. CREATE TABLE regular_table(time timestamp, temp float8, tag text, color integer); -- Renaming indexes should work CREATE INDEX time_color_idx ON regular_table(time, color); ALTER INDEX time_color_idx RENAME TO time_color_idx2; ALTER TABLE regular_table ALTER COLUMN color TYPE bigint; SELECT * FROM test.show_columns('regular_table'); SELECT * FROM test.show_indexes('regular_table'); -- Renaming types should work CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple'); ALTER TYPE rainbow RENAME TO colors; \dT+ REINDEX TABLE regular_table; \c :TEST_DBNAME :ROLE_SUPERUSER REINDEX SCHEMA public; -- Not only simple statements should work CREATE TABLE a (aa TEXT); CREATE TABLE z (b TEXT, PRIMARY KEY(aa, b)) inherits (a); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/plan_expand_hypertable.sql.in�������������������������������������������0000664�0000000�0000000�00000007105�15100345067�0023472�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_expand_hypertable_load.sql \ir include/plan_expand_hypertable_query.sql \set ECHO errors \set TEST_BASE_NAME plan_expand_hypertable SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset -- run queries with optimization on and off and diff results \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME \o :DIFF_CMD \set ECHO queries \set PREFIX 'EXPLAIN (buffers off, costs off)' RESET timescaledb.enable_optimizations; -- test enable_qual_propagation GUC CREATE TABLE t(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('t','time'); INSERT INTO t VALUES ('2000-01-01'), ('2010-01-01'), ('2020-01-01'); -- time constraint should be in both scans :PREFIX SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; SET timescaledb.enable_qual_propagation TO false; -- time constraint should only be in t1 scan :PREFIX SELECT * FROM t t1 INNER JOIN t t2 ON t1.time = t2.time WHERE t1.time < timestamptz '2010-01-01'; RESET timescaledb.enable_qual_propagation; -- test hypertable classification when hypertable is not in cache -- https://github.com/timescale/timescaledb/issues/1832 CREATE TABLE test (a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('public.test', 'time'); INSERT INTO test SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; CREATE OR REPLACE FUNCTION test_f(_ts timestamptz) RETURNS SETOF test LANGUAGE SQL STABLE PARALLEL SAFE AS $f$ SELECT DISTINCT ON (a) * FROM test WHERE time >= _ts ORDER BY a, time DESC $f$; :PREFIX SELECT * FROM test_f(now()); -- create new session \c -- plan output should be identical to previous session :PREFIX SELECT * FROM test_f(now()); -- test hypertable expansion in nested function calls CREATE TABLE t1 (a int, b int NOT NULL); SELECT create_hypertable('t1', 'b', chunk_time_interval=>10); CREATE TABLE t2 (a int, b int NOT NULL); SELECT create_hypertable('t2', 'b', chunk_time_interval=>10); CREATE OR REPLACE FUNCTION f_t1(_a int, _b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (a) * FROM t1 WHERE a = _a and b = _b ORDER BY a, b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t2(_a int, _b int) RETURNS SETOF t2 LANGUAGE sql STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) j.* FROM f_t1(_a, _b) sc, t2 j WHERE j.b = _b AND j.a = _a ORDER BY j.a, j.b DESC $function$ ; CREATE OR REPLACE FUNCTION f_t1_2(_b int) RETURNS SETOF t1 LANGUAGE SQL STABLE PARALLEL SAFE AS $function$ SELECT DISTINCT ON (j.a) jt.* FROM t1 j, f_t1(j.a, _b) jt $function$; :PREFIX SELECT * FROM f_t1_2(10); :PREFIX SELECT * FROM f_t1_2(10) sc, f_t2(sc.a, 10); \qecho '--TEST END--' �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/plan_hashagg.sql.in�����������������������������������������������������0000664�0000000�0000000�00000002371�15100345067�0021376�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SET max_parallel_workers_per_gather TO 0; \set PREFIX 'EXPLAIN (buffers off, costs off) ' \ir include/plan_hashagg_load.sql \ir include/plan_hashagg_query.sql \set ECHO none \set TEST_BASE_NAME plan_hashagg SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset SET client_min_messages TO error; --generate the results into two different files \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME \o :DIFF_CMD �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/plan_hypertable_inline.sql����������������������������������������������0000664�0000000�0000000�00000004215�15100345067�0023063�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- test hypertable classification when query is in an inlineable function \set PREFIX 'EXPLAIN (buffers off, costs off)' CREATE TABLE test (a int, b bigint NOT NULL); SELECT create_hypertable('public.test', 'b', chunk_time_interval=>10); INSERT INTO test SELECT i, i FROM generate_series(1, 20) i; CREATE OR REPLACE FUNCTION test_f(_ts bigint) RETURNS SETOF test LANGUAGE SQL STABLE as $f$ SELECT DISTINCT ON (a) * FROM test WHERE b >= _ts AND b <= _ts + 2 $f$; -- plans must be the same in both cases -- specifically, the first plan should not contain the parent hypertable -- as that is a sign the pruning was not done successfully :PREFIX SELECT * FROM test_f(5); :PREFIX SELECT DISTINCT ON (a) * FROM test WHERE b >= 5 AND b <= 5 + 2; -- test with FOR UPDATE CREATE OR REPLACE FUNCTION test_f(_ts bigint) RETURNS SETOF test LANGUAGE SQL STABLE as $f$ SELECT * FROM test WHERE b >= _ts AND b <= _ts + 2 FOR UPDATE $f$; -- pruning should not be done by TimescaleDb in this case -- specifically, the parent hypertable must exist in the output plan :PREFIX SELECT * FROM test_f(5); :PREFIX SELECT * FROM test WHERE b >= 5 AND b <= 5 + 2 FOR UPDATE; -- test with CTE -- these cases are just to make sure we're everything is alright with -- the way we identify hypertables to prune chunks - we abuse ctename -- for this purpose. So double-check if we're not breaking plans -- with CTEs here. CREATE OR REPLACE FUNCTION test_f(_ts bigint) RETURNS SETOF test LANGUAGE SQL STABLE as $f$ WITH ct AS MATERIALIZED ( SELECT DISTINCT ON (a) * FROM test WHERE b >= _ts AND b <= _ts + 2 ) SELECT * FROM ct $f$; :PREFIX SELECT * FROM test_f(5); :PREFIX WITH ct AS MATERIALIZED ( SELECT DISTINCT ON (a) * FROM test WHERE b >= 5 AND b <= 5 + 2 ) SELECT * FROM ct; -- CTE within CTE :PREFIX WITH ct AS MATERIALIZED ( SELECT * FROM test_f(5) ) SELECT * FROM ct; -- CTE within NO MATERIALIZED CTE :PREFIX WITH ct AS NOT MATERIALIZED ( SELECT * FROM test_f(5) ) SELECT * FROM ct; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/plan_ordered_append.sql.in����������������������������������������������0000664�0000000�0000000�00000003245�15100345067�0022750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- we run these with analyze to confirm that nodes that are not -- needed to fulfill the limit are not executed -- unfortunately this doesn't work on PostgreSQL 9.6 which lacks -- the ability to turn off analyze timing summary so we run -- them without ANALYZE on PostgreSQL 9.6, but since LATERAL plans -- are different across versions we need version specific output -- here anyway. \set TEST_BASE_NAME plan_ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_NO_ANALYZE 'EXPLAIN (buffers off, costs off)' \ir :TEST_LOAD_NAME \ir :TEST_QUERY_NAME --generate the results into two different files \set ECHO errors --make output contain query results \set PREFIX '' \set PREFIX_NO_ANALYZE '' \o :TEST_RESULTS_OPTIMIZED SET timescaledb.ordered_append = 'on'; \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.ordered_append = 'off'; \ir :TEST_QUERY_NAME \o :DIFF_CMD �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/query.sql���������������������������������������������������������������0000664�0000000�0000000�00000002335�15100345067�0017522�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set TEST_BASE_NAME query SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized result" --label "Optimized result" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset \set PREFIX 'EXPLAIN (buffers OFF, costs OFF)' \ir :TEST_LOAD_NAME \ir :TEST_QUERY_NAME --generate the results into two different files \set ECHO errors SET client_min_messages TO error; --make output contain query results \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED SET timescaledb.enable_optimizations TO true; \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_UNOPTIMIZED SET timescaledb.enable_optimizations TO false; \ir :TEST_QUERY_NAME \o :DIFF_CMD SELECT 'Done' ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/relocate_extension.sql��������������������������������������������������0000664�0000000�0000000�00000010040�15100345067�0022237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH 'include/query_result_test_equal.sql' \c postgres :ROLE_SUPERUSER DROP DATABASE :TEST_DBNAME WITH (FORCE); CREATE DATABASE :TEST_DBNAME; \c :TEST_DBNAME CREATE SCHEMA "testSchema0"; SET client_min_messages=error; CREATE EXTENSION IF NOT EXISTS timescaledb SCHEMA "testSchema0"; RESET client_min_messages; CREATE TABLE test_ts(time timestamp, temp float8, device text); CREATE TABLE test_tz(time timestamptz, temp float8, device text); CREATE TABLE test_dt(time date, temp float8, device text); SELECT "testSchema0".create_hypertable('test_ts', 'time', 'device', 2); SELECT "testSchema0".create_hypertable('test_tz', 'time', 'device', 2); SELECT "testSchema0".create_hypertable('test_dt', 'time', 'device', 2); SELECT * FROM _timescaledb_catalog.hypertable; INSERT INTO test_ts VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_ts VALUES('Mon Mar 20 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_ts VALUES('Mon Mar 20 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_ts VALUES('Mon Mar 20 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_ts ORDER BY time; INSERT INTO test_tz VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_tz VALUES('Mon Mar 20 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_tz VALUES('Mon Mar 20 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_tz ORDER BY time; INSERT INTO test_dt VALUES('Mon Mar 20 09:17:00.936242 2017', 23.4, 'dev1'); INSERT INTO test_dt VALUES('Mon Mar 21 09:27:00.936242 2017', 22, 'dev2'); INSERT INTO test_dt VALUES('Mon Mar 22 09:28:00.936242 2017', 21.2, 'dev1'); INSERT INTO test_dt VALUES('Mon Mar 23 09:37:00.936242 2017', 30, 'dev3'); SELECT * FROM test_dt ORDER BY time; -- testing time_bucket START SELECT AVG(temp) AS avg_tmp, "testSchema0".time_bucket('5 minutes', time, INTERVAL '1 minutes') AS ten_min FROM test_ts GROUP BY ten_min ORDER BY avg_tmp; SELECT AVG(temp) AS avg_tmp, "testSchema0".time_bucket('5 minutes', time, INTERVAL '1 minutes') AS ten_min FROM test_tz GROUP BY ten_min ORDER BY avg_tmp; SELECT AVG(temp) AS avg_tmp, "testSchema0".time_bucket('1 day', time, INTERVAL '-0.5 day') AS ten_min FROM test_dt GROUP BY ten_min ORDER BY avg_tmp; -- testing time_bucket END -- testing drop_chunks START -- show_chunks and drop_chunks output should be the same \set QUERY1 'SELECT "testSchema0".show_chunks(older_than => \'2017-03-01\'::timestamp, relation => \'test_ts\')::REGCLASS::TEXT' \set QUERY2 'SELECT "testSchema0".drop_chunks(\'test_ts\', \'2017-03-01\'::timestamp)::TEXT' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test_ts ORDER BY time; \set QUERY1 'SELECT "testSchema0".show_chunks(older_than => interval \'1 minutes\', relation => \'test_tz\')::REGCLASS::TEXT' \set QUERY2 'SELECT "testSchema0".drop_chunks(\'test_tz\', interval \'1 minutes\')::TEXT' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test_tz ORDER BY time; \set QUERY1 'SELECT "testSchema0".show_chunks(older_than => interval \'1 minutes\', relation => \'test_dt\')::REGCLASS::TEXT' \set QUERY2 'SELECT "testSchema0".drop_chunks(\'test_dt\', interval \'1 minutes\')::TEXT' \set ECHO errors \ir :QUERY_RESULT_TEST_EQUAL_RELPATH \set ECHO all SELECT * FROM test_dt ORDER BY time; -- testing drop_chunks END -- testing hypertable_detailed_size START SELECT * FROM "testSchema0".hypertable_detailed_size('test_ts'); -- testing hypertable_detailed_size END SELECT * FROM "testSchema0".hypertable_index_size('test_ts_time_idx'); SELECT * FROM "testSchema0".hypertable_index_size('test_ts_device_time_idx'); CREATE SCHEMA "testSchema"; \set ON_ERROR_STOP 0 ALTER EXTENSION timescaledb SET SCHEMA "testSchema"; \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/reloptions.sql����������������������������������������������������������0000664�0000000�0000000�00000002446�15100345067�0020556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE reloptions_test(time integer, temp float8, color integer) WITH (fillfactor=75, autovacuum_vacuum_threshold=100); SELECT create_hypertable('reloptions_test', 'time', chunk_time_interval => 3); INSERT INTO reloptions_test VALUES (4, 24.3, 1), (9, 13.3, 2); -- Show that reloptions are inherited by chunks SELECT relname, reloptions FROM pg_class WHERE relname ~ '^_hyper.*' AND relkind = 'r'; -- Alter reloptions. We support multiple options for the ALTER TABLE ALTER TABLE reloptions_test SET (fillfactor=80, parallel_workers=8); ALTER TABLE reloptions_test SET (fillfactor=80), SET (parallel_workers=8); SELECT relname, reloptions FROM pg_class WHERE relname ~ '^_hyper.*' AND relkind = 'r'; ALTER TABLE reloptions_test RESET (fillfactor); SELECT relname, reloptions FROM pg_class WHERE relname ~ '^_hyper.*' AND relkind = 'r'; -- Test reloptions on a regular table CREATE TABLE reloptions_test2(time integer, temp float8, color integer); ALTER TABLE reloptions_test2 SET (fillfactor=80, parallel_workers=8); ALTER TABLE reloptions_test2 SET (fillfactor=80), SET (parallel_workers=8); DROP TABLE reloptions_test2; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/repair.sql��������������������������������������������������������������0000664�0000000�0000000�00000003754�15100345067�0017645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- We are testing different repair functions here to make sure that -- they work as expected. \c :TEST_DBNAME :ROLE_SUPERUSER \set TMP_USER :TEST_DBNAME _wizard CREATE USER :TMP_USER; CREATE USER "Random L User"; CREATE TABLE test_table_1(time timestamptz not null, temp float); SELECT create_hypertable('test_table_1', by_range('time', '1 day'::interval)); INSERT INTO test_table_1(time,temp) SELECT time, 100 * random() FROM generate_series( '2000-01-01'::timestamptz, '2000-01-05'::timestamptz, '1min'::interval ) time; CREATE TABLE test_table_2(time timestamptz not null, temp float); SELECT create_hypertable('test_table_2', by_range('time', '1 day'::interval)); INSERT INTO test_table_2(time,temp) SELECT time, 100 * random() FROM generate_series( '2000-01-01'::timestamptz, '2000-01-05'::timestamptz, '1min'::interval ) time; GRANT ALL ON test_table_1 TO :TMP_USER; GRANT ALL ON test_table_2 TO :TMP_USER; GRANT SELECT, INSERT ON test_table_1 TO "Random L User"; GRANT INSERT ON test_table_2 TO "Random L User"; -- Break the relacl of the table by deleting users DELETE FROM pg_authid WHERE rolname IN (:'TMP_USER', 'Random L User'); CREATE TABLE saved (LIKE pg_class); INSERT INTO saved SELECT * FROM pg_class; CALL _timescaledb_functions.repair_relation_acls(); -- The only thing we should see here are the relations we broke and -- the privileges we added for that user. No other relations should be -- touched. WITH lhs AS (SELECT oid, aclexplode(relacl) FROM pg_class), rhs AS (SELECT oid, aclexplode(relacl) FROM saved) SELECT rhs.oid::regclass FROM lhs FULL OUTER JOIN rhs ON row(lhs) = row(rhs) WHERE lhs.oid IS NULL AND rhs.oid IS NOT NULL GROUP BY rhs.oid; DROP TABLE saved; DROP TABLE test_table_1; DROP TABLE test_table_2; ��������������������timescaledb-2.23.0/test/sql/rowsecurity.sql.in������������������������������������������������������0000664�0000000�0000000�00000202203�15100345067�0021355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- Test of Row-level security feature -- -- Clean up in case a prior regression run failed \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET timescaledb.enable_constraint_exclusion TO off; -- Suppress NOTICE messages when users/groups don't exist SET client_min_messages TO 'warning'; DROP USER IF EXISTS regress_rls_alice; DROP USER IF EXISTS regress_rls_bob; DROP USER IF EXISTS regress_rls_carol; DROP USER IF EXISTS regress_rls_dave; DROP USER IF EXISTS regress_rls_exempt_user; DROP ROLE IF EXISTS regress_rls_group1; DROP ROLE IF EXISTS regress_rls_group2; DROP SCHEMA IF EXISTS regress_rls_schema CASCADE; RESET client_min_messages; -- initial setup CREATE USER regress_rls_alice NOLOGIN; CREATE USER regress_rls_bob NOLOGIN; CREATE USER regress_rls_carol NOLOGIN; CREATE USER regress_rls_dave NOLOGIN; CREATE USER regress_rls_exempt_user BYPASSRLS NOLOGIN; CREATE ROLE regress_rls_group1 NOLOGIN; CREATE ROLE regress_rls_group2 NOLOGIN; GRANT regress_rls_group1 TO regress_rls_bob; GRANT regress_rls_group2 TO regress_rls_carol; CREATE SCHEMA regress_rls_schema; GRANT ALL ON SCHEMA regress_rls_schema to public; SET search_path = regress_rls_schema; -- setup of malicious function CREATE OR REPLACE FUNCTION f_leak(text) RETURNS bool COST 0.0000001 LANGUAGE plpgsql AS 'BEGIN RAISE NOTICE ''f_leak => %'', $1; RETURN true; END'; GRANT EXECUTE ON FUNCTION f_leak(text) TO public; -- BASIC Row-Level Security Scenario SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE uaccount ( pguser name primary key, seclv int ); GRANT SELECT ON uaccount TO public; INSERT INTO uaccount VALUES ('regress_rls_alice', 99), ('regress_rls_bob', 1), ('regress_rls_carol', 2), ('regress_rls_dave', 3); CREATE TABLE category ( cid int primary key, cname text ); GRANT ALL ON category TO public; INSERT INTO category VALUES (11, 'novel'), (22, 'science fiction'), (33, 'technology'), (44, 'manga'); CREATE TABLE document ( did int primary key, cid int references category(cid), dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON document TO public; SELECT public.create_hypertable('document', 'did', chunk_time_interval=>2); INSERT INTO document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 22, 2, 'regress_rls_bob', 'my science fiction'), ( 4, 44, 1, 'regress_rls_bob', 'my first manga'), ( 5, 44, 2, 'regress_rls_bob', 'my second manga'), ( 6, 22, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 33, 2, 'regress_rls_carol', 'great technology book'), ( 8, 44, 1, 'regress_rls_carol', 'great manga'), ( 9, 22, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 33, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE document ENABLE ROW LEVEL SECURITY; -- user's security level must be higher than or equal to document's CREATE POLICY p1 ON document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- try to create a policy of bogus type CREATE POLICY p1 ON document AS UGLY USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- but Dave isn't allowed to anything at cid 50 or above -- this is to make sure that we sort the policies by name first -- when applying WITH CHECK, a later INSERT by Dave should fail due -- to p1r first CREATE POLICY p2r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44 AND cid < 50); -- and Dave isn't allowed to see manga documents CREATE POLICY p1r ON document AS RESTRICTIVE TO regress_rls_dave USING (cid <> 44); \dp \d document SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename = 'document' ORDER BY policyname; -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; -- try a sampled version SELECT * FROM document TABLESAMPLE BERNOULLI(50) REPEATABLE(0) WHERE f_leak(dtitle) ORDER BY did; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER BY did; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); -- 44 would technically fail for both p2r and p1r, but we should get an error -- back from p1r for this because it sorts first INSERT INTO document VALUES (100, 44, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail -- Just to see a p2r error INSERT INTO document VALUES (100, 55, 1, 'regress_rls_dave', 'testing sorting of policies'); -- fail -- only owner can change policies ALTER POLICY p1 ON document USING (true); --fail DROP POLICY p1 ON document; --fail SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document WHERE f_leak(dtitle) ORDER BY did; SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle) ORDER by did; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document WHERE f_leak(dtitle); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM document NATURAL JOIN category WHERE f_leak(dtitle); -- interaction of FK/PK constraints SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY p2 ON category USING (CASE WHEN current_user = 'regress_rls_bob' THEN cid IN (11, 33) WHEN current_user = 'regress_rls_carol' THEN cid IN (22, 44) ELSE false END); ALTER TABLE category ENABLE ROW LEVEL SECURITY; -- cannot delete PK referenced by invisible FK SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; \set VERBOSITY sqlstate DELETE FROM category WHERE cid = 33; -- fails with FK violation \set VERBOSITY default -- can insert FK referencing invisible PK SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM document d FULL OUTER JOIN category c on d.cid = c.cid ORDER BY d.did, c.cid; INSERT INTO document VALUES (11, 33, 1, current_user, 'hoge'); -- UNIQUE or PRIMARY KEY constraint violation DOES reveal presence of row SET SESSION AUTHORIZATION regress_rls_bob; INSERT INTO document VALUES (8, 44, 1, 'regress_rls_bob', 'my third manga'); -- Must fail with unique violation, revealing presence of did we can't see SELECT * FROM document WHERE did = 8; -- and confirm we can't see it -- RLS policies are checked before constraints INSERT INTO document VALUES (8, 44, 1, 'regress_rls_carol', 'my third manga'); -- Should fail with RLS check violation, not duplicate key violation UPDATE document SET did = 8, dauthor = 'regress_rls_carol' WHERE did = 5; -- Should fail with RLS check violation, not duplicate key violation -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM document; SELECT * FROM category; -- database superuser does bypass RLS policy when disabled RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM document; SELECT * FROM category; -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM document; SELECT * FROM category; -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM document; SELECT * FROM category; -- RLS policy does not apply to table owner when RLS disabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO OFF; SELECT * FROM document; SELECT * FROM category; -- -- Table inheritance and RLS policy -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE t1 (a int, junk1 text, b text); ALTER TABLE t1 DROP COLUMN junk1; -- just a disturbing factor GRANT ALL ON t1 TO public; COPY t1 FROM stdin; 1 aba 2 bbb 3 ccc 4 dad \. CREATE TABLE t2 (c float) INHERITS (t1); GRANT ALL ON t2 TO public; COPY t2 FROM stdin; 1 abc 1.1 2 bcd 2.2 3 cde 3.3 4 def 4.4 \. CREATE TABLE t3 (c text, b text, a int); ALTER TABLE t3 INHERIT t1; GRANT ALL ON t3 TO public; COPY t3(a,b,c) FROM stdin; 1 xxx X 2 yyy Y 3 zzz Z \. CREATE POLICY p1 ON t1 FOR ALL TO PUBLIC USING (a % 2 = 0); -- be even number CREATE POLICY p2 ON t2 FOR ALL TO PUBLIC USING (a % 2 = 1); -- be odd number ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; ALTER TABLE t2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; SELECT * FROM t1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); -- reference to system column SELECT ctid, * FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; -- reference to whole-row reference SELECT *, t1 FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT *, t1 FROM t1; -- for share/update lock SELECT * FROM t1 FOR SHARE; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 FOR SHARE; SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b) FOR SHARE; -- union all query SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT a, b, ctid FROM t2 UNION ALL SELECT a, b, ctid FROM t3; -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); -- non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); -- -- Hyper Tables -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE hyper_document ( did int, cid int, dlevel int not null, dauthor name, dtitle text ); GRANT ALL ON hyper_document TO public; SELECT public.create_hypertable('hyper_document', 'did', chunk_time_interval=>2); INSERT INTO hyper_document VALUES ( 1, 11, 1, 'regress_rls_bob', 'my first novel'), ( 2, 11, 2, 'regress_rls_bob', 'my second novel'), ( 3, 99, 2, 'regress_rls_bob', 'my science textbook'), ( 4, 55, 1, 'regress_rls_bob', 'my first satire'), ( 5, 99, 2, 'regress_rls_bob', 'my history book'), ( 6, 11, 1, 'regress_rls_carol', 'great science fiction'), ( 7, 99, 2, 'regress_rls_carol', 'great technology book'), ( 8, 55, 2, 'regress_rls_carol', 'great satire'), ( 9, 11, 1, 'regress_rls_dave', 'awesome science fiction'), (10, 99, 2, 'regress_rls_dave', 'awesome technology book'); ALTER TABLE hyper_document ENABLE ROW LEVEL SECURITY; GRANT ALL ON _timescaledb_internal._hyper_2_9_chunk TO public; -- Create policy on parent -- user's security level must be higher than or equal to document's CREATE POLICY pp1 ON hyper_document AS PERMISSIVE USING (dlevel <= (SELECT seclv FROM uaccount WHERE pguser = current_user)); -- Dave is only allowed to see cid < 55 CREATE POLICY pp1r ON hyper_document AS RESTRICTIVE TO regress_rls_dave USING (cid < 55); \d+ hyper_document SELECT * FROM pg_policies WHERE schemaname = 'regress_rls_schema' AND tablename like '%hyper_document%' ORDER BY policyname; -- viewpoint from regress_rls_bob SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); -- viewpoint from regress_rls_dave SET SESSION AUTHORIZATION regress_rls_dave; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); -- pp1 ERROR INSERT INTO hyper_document VALUES (1, 11, 5, 'regress_rls_dave', 'testing pp1'); -- fail -- pp1r ERROR INSERT INTO hyper_document VALUES (1, 99, 1, 'regress_rls_dave', 'testing pp1r'); -- fail -- Show that RLS policy does not apply for direct inserts to children -- This should fail with RLS POLICY pp1r violation. INSERT INTO hyper_document VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- fail -- But this should succeed. INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables'); -- success -- We still cannot see the row using the parent SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; -- But we can if we look directly SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; -- Turn on RLS and create policy on child to show RLS is checked before constraints SET SESSION AUTHORIZATION regress_rls_alice; ALTER TABLE _timescaledb_internal._hyper_2_9_chunk ENABLE ROW LEVEL SECURITY; CREATE POLICY pp3 ON _timescaledb_internal._hyper_2_9_chunk AS RESTRICTIVE USING (cid < 55); -- This should fail with RLS violation now. SET SESSION AUTHORIZATION regress_rls_dave; INSERT INTO _timescaledb_internal._hyper_2_9_chunk VALUES (1, 55, 1, 'regress_rls_dave', 'testing RLS with hypertables - round 2'); -- fail -- And now we cannot see directly into the partition either, due to RLS SELECT * FROM _timescaledb_internal._hyper_2_9_chunk WHERE f_leak(dtitle) ORDER BY did, cid; -- The parent looks same as before -- viewpoint from regress_rls_dave SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); -- viewpoint from regress_rls_carol SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); -- only owner can change policies ALTER POLICY pp1 ON hyper_document USING (true); --fail DROP POLICY pp1 ON hyper_document; --fail SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY pp1 ON hyper_document USING (dauthor = current_user); -- viewpoint from regress_rls_bob again SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; -- viewpoint from rls_regres_carol again SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM hyper_document WHERE f_leak(dtitle) ORDER BY did, cid; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper_document WHERE f_leak(dtitle); -- database superuser does bypass RLS policy when enabled RESET SESSION AUTHORIZATION; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; -- database non-superuser with bypass privilege can bypass RLS policy when disabled SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; -- RLS policy does not apply to table owner when RLS enabled. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; SELECT * FROM hyper_document ORDER BY did, cid; SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; -- When RLS disabled, other users get ERROR. SET SESSION AUTHORIZATION regress_rls_dave; SET row_security TO OFF; SELECT * FROM hyper_document ORDER BY did, cid; SELECT * FROM _timescaledb_internal._hyper_2_9_chunk ORDER BY did, cid; -- Check behavior with a policy that uses a SubPlan not an InitPlan. SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE POLICY pp3 ON hyper_document AS RESTRICTIVE USING ((SELECT dlevel <= seclv FROM uaccount WHERE pguser = current_user)); SET SESSION AUTHORIZATION regress_rls_carol; INSERT INTO hyper_document VALUES (100, 11, 5, 'regress_rls_carol', 'testing pp3'); -- fail ----- Dependencies ----- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security TO ON; CREATE TABLE dependee (x integer, y integer); SELECT public.create_hypertable('dependee', 'x', chunk_time_interval=>2); CREATE TABLE dependent (x integer, y integer); SELECT public.create_hypertable('dependent', 'x', chunk_time_interval=>2); CREATE POLICY d1 ON dependent FOR ALL TO PUBLIC USING (x = (SELECT d.x FROM dependee d WHERE d.y = y)); DROP TABLE dependee; -- Should fail without CASCADE due to dependency on row security qual? DROP TABLE dependee CASCADE; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM dependent; -- After drop, should be unqualified ----- RECURSION ---- -- -- Simple recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec1 (x integer, y integer); SELECT public.create_hypertable('rec1', 'x', chunk_time_interval=>2); CREATE POLICY r1 ON rec1 USING (x = (SELECT r.x FROM rec1 r WHERE y = r.y)); ALTER TABLE rec1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, direct recursion -- -- Mutual recursion -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE rec2 (a integer, b integer); SELECT public.create_hypertable('rec2', 'x', chunk_time_interval=>2); ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2 WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1 WHERE y = b)); ALTER TABLE rec2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion -- -- Mutual recursion via views -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rec1v AS SELECT * FROM rec1; CREATE VIEW rec2v AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); ALTER POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via views -- -- Mutual recursion via .s.b views -- SET SESSION AUTHORIZATION regress_rls_bob; \set VERBOSITY terse \\ -- suppress cascade details DROP VIEW rec1v, rec2v CASCADE; \set VERBOSITY default CREATE VIEW rec1v WITH (security_barrier) AS SELECT * FROM rec1; CREATE VIEW rec2v WITH (security_barrier) AS SELECT * FROM rec2; SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY r1 ON rec1 USING (x = (SELECT a FROM rec2v WHERE b = y)); CREATE POLICY r2 ON rec2 USING (a = (SELECT x FROM rec1v WHERE y = b)); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rec1; -- fail, mutual recursion via s.b. views -- -- recursive RLS and VIEWs in policy -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE s1 (a int, b text); SELECT public.create_hypertable('s1', 'a', chunk_time_interval=>2); INSERT INTO s1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE TABLE s2 (x int, y text); SELECT public.create_hypertable('s2', 'x', chunk_time_interval=>2); INSERT INTO s2 (SELECT x, md5(x::text) FROM generate_series(-6,6) x); GRANT SELECT ON s1, s2 TO regress_rls_bob; CREATE POLICY p1 ON s1 USING (a in (select x from s2 where y like '%2f%')); CREATE POLICY p2 ON s2 USING (x in (select a from s1 where b like '%22%')); CREATE POLICY p3 ON s1 FOR INSERT WITH CHECK (a = (SELECT a FROM s1)); ALTER TABLE s1 ENABLE ROW LEVEL SECURITY; ALTER TABLE s2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW v2 AS SELECT * FROM s2 WHERE y like '%af%'; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion) INSERT INTO s1 VALUES (1, 'foo'); -- fail (infinite recursion) SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3 on s1; ALTER POLICY p2 ON s2 USING (x % 2 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM only s1 WHERE f_leak(b); SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p1 ON s1 USING (a in (select x from v2)); -- using VIEW in RLS policy SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- OK EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM s1 WHERE f_leak(b); SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT (SELECT x FROM s1 LIMIT 1) xx, * FROM s2 WHERE y like '%28%'; SET SESSION AUTHORIZATION regress_rls_alice; ALTER POLICY p2 ON s2 USING (x in (select a from s1 where b like '%d2%')); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM s1 WHERE f_leak(b); -- fail (infinite recursion via view) -- prepared statement with regress_rls_alice privilege PREPARE p1(int) AS SELECT * FROM t1 WHERE a <= $1; EXECUTE p1(2); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); -- superuser is allowed to bypass RLS checks RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1 WHERE f_leak(b); -- plan cache should be invalidated EXECUTE p1(2); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1(2); PREPARE p2(int) AS SELECT * FROM t1 WHERE a = $1; EXECUTE p2(2); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); -- also, case when privilege switch from superuser SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXECUTE p2(2); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p2(2); -- -- UPDATE / DELETE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_bob; EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b = b || b WHERE f_leak(b); UPDATE t1 SET b = b || b WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); UPDATE only t1 SET b = b || '_updt' WHERE f_leak(b); -- returning clause with system column UPDATE only t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; UPDATE t1 SET b = b WHERE f_leak(b) RETURNING *; UPDATE t1 SET b = b WHERE f_leak(b) RETURNING ctid, *, t1; -- updates with from clause EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); UPDATE t2 SET b=t2.b FROM t3 WHERE t2.a = 3 and t3.a = 2 AND f_leak(t2.b) AND f_leak(t3.b); EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); UPDATE t1 SET b=t1.b FROM t2 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); UPDATE t2 SET b=t2.b FROM t1 WHERE t1.a = 3 and t2.a = 3 AND f_leak(t1.b) AND f_leak(t2.b); -- updates with from clause self join EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; UPDATE t2 t2_1 SET b = t2_2.b FROM t2 t2_2 WHERE t2_1.a = 3 AND t2_2.a = t2_1.a AND t2_2.b = t2_1.b AND f_leak(t2_1.b) AND f_leak(t2_2.b) RETURNING *, t2_1, t2_2; EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; UPDATE t1 t1_1 SET b = t1_2.b FROM t1 t1_2 WHERE t1_1.a = 4 AND t1_2.a = t1_1.a AND t1_2.b = t1_1.b AND f_leak(t1_1.b) AND f_leak(t1_2.b) RETURNING *, t1_1, t1_2; RESET SESSION AUTHORIZATION; SET row_security TO OFF; SELECT * FROM t1 ORDER BY a,b; SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM only t1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM t1 WHERE f_leak(b); DELETE FROM only t1 WHERE f_leak(b) RETURNING ctid, *, t1; DELETE FROM t1 WHERE f_leak(b) RETURNING ctid, *, t1; -- -- S.b. view on top of Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE b1 (a int, b text); SELECT public.create_hypertable('b1', 'a', chunk_time_interval=>2); INSERT INTO b1 (SELECT x, md5(x::text) FROM generate_series(-10,10) x); CREATE POLICY p1 ON b1 USING (a % 2 = 0); ALTER TABLE b1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON b1 TO regress_rls_bob; SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW bv1 WITH (security_barrier) AS SELECT * FROM b1 WHERE a > 0 WITH CHECK OPTION; GRANT ALL ON bv1 TO regress_rls_carol; SET SESSION AUTHORIZATION regress_rls_carol; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM bv1 WHERE f_leak(b); SELECT * FROM bv1 WHERE f_leak(b); INSERT INTO bv1 VALUES (-1, 'xxx'); -- should fail view WCO INSERT INTO bv1 VALUES (11, 'xxx'); -- should fail RLS check INSERT INTO bv1 VALUES (12, 'xxx'); -- ok EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); UPDATE bv1 SET b = 'yyy' WHERE a = 4 AND f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) DELETE FROM bv1 WHERE a = 6 AND f_leak(b); DELETE FROM bv1 WHERE a = 6 AND f_leak(b); SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM b1; -- -- INSERT ... ON CONFLICT DO UPDATE and Row-level security -- SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p1r ON document; CREATE POLICY p1 ON document FOR SELECT USING (true); CREATE POLICY p2 ON document FOR INSERT WITH CHECK (dauthor = current_user); CREATE POLICY p3 ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Exists... SELECT * FROM document WHERE did = 2; -- ...so violates actual WITH CHECK OPTION within UPDATE (not INSERT, since -- alternative UPDATE path happens to be taken): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, dauthor = EXCLUDED.dauthor; -- Violates USING qual for UPDATE policy p3. -- -- UPDATE path is taken, but UPDATE fails purely because *existing* row to be -- updated is not a "novel"/cid 11 (row is not leaked, even though we have -- SELECT privileges sufficient to see the row in this instance): INSERT INTO document VALUES (33, 22, 1, 'regress_rls_bob', 'okay science fiction'); -- preparation for next statement INSERT INTO document VALUES (33, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'Some novel, replaces sci-fi') -- takes UPDATE path ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; -- Fine (we UPDATE, since INSERT WCOs and UPDATE security barrier quals + WCOs -- not violated): INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; -- Fine (we INSERT, so "cid = 33" ("technology") isn't evaluated): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; -- Fine (same query, but we UPDATE, so "cid = 33", ("technology") is not the -- case in respect of *existing* tuple): INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; -- Same query a third time, but now fails due to existing tuple finally not -- passing quals: INSERT INTO document VALUES (78, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'some technology novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33 RETURNING *; -- Don't fail just because INSERT doesn't satisfy WITH CHECK option that -- originated as a barrier/USING() qual from the UPDATE. Note that the UPDATE -- path *isn't* taken, and so UPDATE-related policy does not apply: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; -- But this time, the same statement fails, because the UPDATE path is taken, -- and updating the row just inserted falls afoul of security barrier qual -- (enforced as WCO) -- what we might have updated target tuple to is -- irrelevant, in fact. INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; -- Test default USING qual enforced as WCO SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p1 ON document; DROP POLICY p2 ON document; DROP POLICY p3 ON document; CREATE POLICY p3_with_default ON document FOR UPDATE USING (cid = (SELECT cid from category WHERE cname = 'novel')); SET SESSION AUTHORIZATION regress_rls_bob; -- Just because WCO-style enforcement of USING quals occurs with -- existing/target tuple does not mean that the implementation can be allowed -- to fail to also enforce this qual against the final tuple appended to -- relation (since in the absence of an explicit WCO, this is also interpreted -- as an UPDATE/ALL WCO in general). -- -- UPDATE path is taken here (fails due to existing tuple). Note that this is -- not reported as a "USING expression", because it's an RLS UPDATE check that originated as -- a USING qual for the purposes of RLS in general, as opposed to an explicit -- USING qual that is ordinarily a security barrier. We leave it up to the -- UPDATE to make this fail: INSERT INTO document VALUES (79, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'technology book, can only insert') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle RETURNING *; -- UPDATE path is taken here. Existing tuple passes, since it's cid -- corresponds to "novel", but default USING qual is enforced against -- post-UPDATE tuple too (as always when updating with a policy that lacks an -- explicit WCO), and so this fails: INSERT INTO document VALUES (2, (SELECT cid from category WHERE cname = 'technology'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET cid = EXCLUDED.cid, dtitle = EXCLUDED.dtitle RETURNING *; SET SESSION AUTHORIZATION regress_rls_alice; DROP POLICY p3_with_default ON document; -- -- Test ALL policies with ON CONFLICT DO UPDATE (much the same as existing UPDATE -- tests) -- CREATE POLICY p3_with_all ON document FOR ALL USING (cid = (SELECT cid from category WHERE cname = 'novel')) WITH CHECK (dauthor = current_user); SET SESSION AUTHORIZATION regress_rls_bob; -- Fails, since ALL WCO is enforced in insert path: INSERT INTO document VALUES (80, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_carol', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle, cid = 33; -- Fails, since ALL policy USING qual is enforced (existing, target tuple is in -- violation, since it has the "manga" cid): INSERT INTO document VALUES (4, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dtitle = EXCLUDED.dtitle; -- Fails, since ALL WCO are enforced: INSERT INTO document VALUES (1, (SELECT cid from category WHERE cname = 'novel'), 1, 'regress_rls_bob', 'my first novel') ON CONFLICT (did) DO UPDATE SET dauthor = 'regress_rls_carol'; -- -- ROLE/GROUP -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE z1 (a int, b text); SELECT public.create_hypertable('z1', 'a', chunk_time_interval=>2); CREATE TABLE z2 (a int, b text); SELECT public.create_hypertable('z2', 'a', chunk_time_interval=>2); GRANT SELECT ON z1,z2 TO regress_rls_group1, regress_rls_group2, regress_rls_bob, regress_rls_carol; INSERT INTO z1 VALUES (1, 'aba'), (2, 'bbb'), (3, 'ccc'), (4, 'dad'); CREATE POLICY p1 ON z1 TO regress_rls_group1 USING (a % 2 = 0); CREATE POLICY p2 ON z1 TO regress_rls_group2 USING (a % 2 = 1); ALTER TABLE z1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); PREPARE plancache_test AS SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; PREPARE plancache_test2 AS WITH q AS MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; PREPARE plancache_test4 AS WITH q AS (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; PREPARE plancache_test6 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z1 WHERE f_leak(b)) SELECT * FROM q,z2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test6; PREPARE plancache_test3 AS WITH q AS MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; PREPARE plancache_test5 AS WITH q AS (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; PREPARE plancache_test7 AS WITH q AS NOT MATERIALIZED (SELECT * FROM z2) SELECT * FROM q,z1 WHERE f_leak(z1.b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test7; SET ROLE regress_rls_group1; SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; SET ROLE regress_rls_group2; SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM z1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test2; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test4; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test3; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE plancache_test5; -- -- Views should follow policy for view owner. -- -- View and Table owner are the same. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_bob; -- Query as role that is not owner of view or table. Should return all records. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; -- Query as view/table owner. Should return all records. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; DROP VIEW rls_view; -- View and Table owners are different. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_view AS SELECT * FROM z1 WHERE f_leak(b); GRANT SELECT ON rls_view TO regress_rls_alice; -- Query as role that is not owner of view but is owner of table. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM rls_view; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; -- Query as role that is not owner of table but is owner of view. -- Should return records based on view owner policies. SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM rls_view; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; -- Query as role that is not the owner of the table or view without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM rls_view; --fail - permission denied. EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; --fail - permission denied. -- Query as role that is not the owner of the table or view with permissions. SET SESSION AUTHORIZATION regress_rls_bob; GRANT SELECT ON rls_view TO regress_rls_carol; SELECT * FROM rls_view; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_view; SET SESSION AUTHORIZATION regress_rls_bob; DROP VIEW rls_view; -- -- Command specific -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE x1 (a int, b text, c text); SELECT public.create_hypertable('x1', 'a', chunk_time_interval=>2); GRANT ALL ON x1 TO PUBLIC; INSERT INTO x1 VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_carol'), (4, 'def', 'regress_rls_carol'), (5, 'efg', 'regress_rls_bob'), (6, 'fgh', 'regress_rls_bob'), (7, 'fgh', 'regress_rls_carol'), (8, 'fgh', 'regress_rls_carol'); CREATE POLICY p0 ON x1 FOR ALL USING (c = current_user); CREATE POLICY p1 ON x1 FOR SELECT USING (a % 2 = 0); CREATE POLICY p2 ON x1 FOR INSERT WITH CHECK (a % 2 = 1); CREATE POLICY p3 ON x1 FOR UPDATE USING (a % 2 = 0); CREATE POLICY p4 ON x1 FOR DELETE USING (a < 8); ALTER TABLE x1 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; SET SESSION AUTHORIZATION regress_rls_carol; SELECT * FROM x1 WHERE f_leak(b) ORDER BY a ASC; UPDATE x1 SET b = b || '_updt' WHERE f_leak(b) RETURNING *; DELETE FROM x1 WHERE f_leak(b) RETURNING *; -- -- Duplicate Policy Names -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE y1 (a int, b text); SELECT public.create_hypertable('y1', 'a', chunk_time_interval=>2); INSERT INTO y1 VALUES(1,2); CREATE TABLE y2 (a int, b text); SELECT public.create_hypertable('y2', 'a', chunk_time_interval=>2); GRANT ALL ON y1, y2 TO regress_rls_bob; CREATE POLICY p1 ON y1 FOR ALL USING (a % 2 = 0); CREATE POLICY p2 ON y1 FOR SELECT USING (a > 2); CREATE POLICY p1 ON y1 FOR SELECT USING (a % 2 = 1); --fail CREATE POLICY p1 ON y2 FOR ALL USING (a % 2 = 0); --OK ALTER TABLE y1 ENABLE ROW LEVEL SECURITY; ALTER TABLE y2 ENABLE ROW LEVEL SECURITY; -- -- Expression structure with SBV -- -- Create view as table owner. RLS should NOT be applied. SET SESSION AUTHORIZATION regress_rls_alice; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); DROP VIEW rls_sbv; -- Create view as role that does not own table. RLS should be applied. SET SESSION AUTHORIZATION regress_rls_bob; CREATE VIEW rls_sbv WITH (security_barrier) AS SELECT * FROM y1 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM rls_sbv WHERE (a = 1); DROP VIEW rls_sbv; -- -- Expression structure -- SET SESSION AUTHORIZATION regress_rls_alice; INSERT INTO y2 (SELECT x, md5(x::text) FROM generate_series(0,20) x); CREATE POLICY p2 ON y2 USING (a % 3 = 0); CREATE POLICY p3 ON y2 USING (a % 4 = 0); SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM y2 WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak(b); -- -- Qual push-down of leaky functions, when not referring to table -- SELECT * FROM y2 WHERE f_leak('abc'); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 WHERE f_leak('abc'); CREATE TABLE test_qual_pushdown ( abc text ); INSERT INTO test_qual_pushdown VALUES ('abc'),('def'); SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(abc); SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM y2 JOIN test_qual_pushdown ON (b = abc) WHERE f_leak(b); DROP TABLE test_qual_pushdown; -- -- Plancache invalidate on user change. -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP TABLE t1 CASCADE; \set VERBOSITY default CREATE TABLE t1 (a integer); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); GRANT SELECT ON t1 TO regress_rls_bob, regress_rls_carol; CREATE POLICY p1 ON t1 TO regress_rls_bob USING ((a % 2) = 0); CREATE POLICY p2 ON t1 TO regress_rls_carol USING ((a % 4) = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; -- Prepare as regress_rls_bob SET ROLE regress_rls_bob; PREPARE role_inval AS SELECT * FROM t1; -- Check plan EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; -- Change to regress_rls_carol SET ROLE regress_rls_carol; -- Check plan- should be different EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; -- Change back to regress_rls_bob SET ROLE regress_rls_bob; -- Check plan- should be back to original EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE role_inval; -- -- CTE and RLS -- RESET SESSION AUTHORIZATION; DROP TABLE t1 CASCADE; CREATE TABLE t1 (a integer, b text); SELECT public.create_hypertable('t1', 'a', chunk_time_interval=>2); CREATE POLICY p1 ON t1 USING (a % 2 = 0); ALTER TABLE t1 ENABLE ROW LEVEL SECURITY; GRANT ALL ON t1 TO regress_rls_bob; INSERT INTO t1 (SELECT x, md5(x::text) FROM generate_series(0,20) x); SET SESSION AUTHORIZATION regress_rls_bob; WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; EXPLAIN (BUFFERS OFF, COSTS OFF) WITH cte1 AS (SELECT * FROM t1 WHERE f_leak(b)) SELECT * FROM cte1; WITH cte1 AS (UPDATE t1 SET a = a + 1 RETURNING *) SELECT * FROM cte1; --fail WITH cte1 AS (UPDATE t1 SET a = a RETURNING *) SELECT * FROM cte1; --ok WITH cte1 AS (INSERT INTO t1 VALUES (21, 'Fail') RETURNING *) SELECT * FROM cte1; --fail WITH cte1 AS (INSERT INTO t1 VALUES (20, 'Success') RETURNING *) SELECT * FROM cte1; --ok -- -- Rename Policy -- RESET SESSION AUTHORIZATION; ALTER POLICY p1 ON t1 RENAME TO p1; --fail SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; ALTER POLICY p1 ON t1 RENAME TO p2; --ok SELECT polname, relname FROM pg_policy pol JOIN pg_class pc ON (pc.oid = pol.polrelid) WHERE relname = 't1'; -- -- Check INSERT SELECT -- SET SESSION AUTHORIZATION regress_rls_bob; CREATE TABLE t2 (a integer, b text); SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); INSERT INTO t2 (SELECT * FROM t1); EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO t2 (SELECT * FROM t1); SELECT * FROM t2; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t2; CREATE TABLE t3 AS SELECT * FROM t1; SELECT public.create_hypertable('t2', 'a', chunk_time_interval=>2); SELECT * FROM t3; SELECT * INTO t4 FROM t1; SELECT * FROM t4; -- -- RLS with JOIN -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE blog (id integer, author text, post text); SELECT public.create_hypertable('blog', 'id', chunk_time_interval=>2); CREATE TABLE comment (blog_id integer, message text); SELECT public.create_hypertable('comment', 'blog_id', chunk_time_interval=>2); GRANT ALL ON blog, comment TO regress_rls_bob; CREATE POLICY blog_1 ON blog USING (id % 2 = 0); ALTER TABLE blog ENABLE ROW LEVEL SECURITY; INSERT INTO blog VALUES (1, 'alice', 'blog #1'), (2, 'bob', 'blog #1'), (3, 'alice', 'blog #2'), (4, 'alice', 'blog #3'), (5, 'john', 'blog #1'); INSERT INTO comment VALUES (1, 'cool blog'), (1, 'fun blog'), (3, 'crazy blog'), (5, 'what?'), (4, 'insane!'), (2, 'who did it?'); SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN with Non-RLS. SELECT id, author, message FROM blog JOIN comment ON id = blog_id; -- Check Non-RLS JOIN with RLS. SELECT id, author, message FROM comment JOIN blog ON id = blog_id; SET SESSION AUTHORIZATION regress_rls_alice; CREATE POLICY comment_1 ON comment USING (blog_id < 4); ALTER TABLE comment ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Check RLS JOIN RLS SELECT id, author, message FROM blog JOIN comment ON id = blog_id; SELECT id, author, message FROM comment JOIN blog ON id = blog_id; SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE blog; DROP TABLE comment; -- -- Default Deny Policy -- RESET SESSION AUTHORIZATION; DROP POLICY p2 ON t1; ALTER TABLE t1 OWNER TO regress_rls_alice; -- Check that default deny does not apply to superuser. RESET SESSION AUTHORIZATION; SELECT * FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; -- Check that default deny does not apply to table owner. SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; -- Check that default deny applies to non-owner/non-superuser when RLS on. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO ON; SELECT * FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM t1; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM t1; -- -- COPY TO/FROM -- RESET SESSION AUTHORIZATION; DROP TABLE copy_t CASCADE; CREATE TABLE copy_t (a integer, b text); SELECT public.create_hypertable('copy_t', 'a', chunk_time_interval=>2); CREATE POLICY p1 ON copy_t USING (a % 2 = 0); ALTER TABLE copy_t ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_t TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_t (SELECT x, md5(x::text) FROM generate_series(0,10) x); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS SET row_security TO ON; COPY (SELECT * FROM copy_t ORDER BY a ASC) TO STDOUT WITH DELIMITER ','; --fail - permission denied -- Check COPY relation TO; keep it just one row to avoid reordering issues RESET SESSION AUTHORIZATION; SET row_security TO ON; CREATE TABLE copy_rel_to (a integer, b text); SELECT public.create_hypertable('copy_rel_to', 'a', chunk_time_interval=>2); CREATE POLICY p1 ON copy_rel_to USING (a % 2 = 0); ALTER TABLE copy_rel_to ENABLE ROW LEVEL SECURITY; GRANT ALL ON copy_rel_to TO regress_rls_bob, regress_rls_exempt_user; INSERT INTO copy_rel_to VALUES (1, md5('1')); -- Check COPY TO as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; -- Check COPY TO as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - would be affected by RLS SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --ok -- Check COPY TO as user without permissions. SET row_security TO OFF; SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied SET row_security TO ON; COPY (SELECT * FROM copy_rel_to) TO STDOUT WITH DELIMITER ','; --fail - permission denied -- Check COPY FROM as Superuser/owner. RESET SESSION AUTHORIZATION; SET row_security TO OFF; COPY copy_t FROM STDIN; --ok 1 abc 2 bcd 3 cde 4 def \. SET row_security TO ON; COPY copy_t FROM STDIN; --ok 1 abc 2 bcd 3 cde 4 def \. -- Check COPY FROM as user with permissions. SET SESSION AUTHORIZATION regress_rls_bob; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - would be affected by RLS. SET row_security TO ON; COPY copy_t FROM STDIN; --fail - COPY FROM not supported by RLS. -- Check COPY FROM as user with permissions and BYPASSRLS SET SESSION AUTHORIZATION regress_rls_exempt_user; SET row_security TO ON; COPY copy_t FROM STDIN; --ok 1 abc 2 bcd 3 cde 4 def \. -- Check COPY FROM as user without permissions. SET SESSION AUTHORIZATION regress_rls_carol; SET row_security TO OFF; COPY copy_t FROM STDIN; --fail - permission denied. SET row_security TO ON; COPY copy_t FROM STDIN; --fail - permission denied. RESET SESSION AUTHORIZATION; DROP TABLE copy_t; DROP TABLE copy_rel_to CASCADE; -- Check WHERE CURRENT OF SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE current_check (currentid int, payload text, rlsuser text); SELECT public.create_hypertable('current_check', 'currentid', chunk_time_interval=>10); GRANT ALL ON current_check TO PUBLIC; INSERT INTO current_check VALUES (1, 'abc', 'regress_rls_bob'), (2, 'bcd', 'regress_rls_bob'), (3, 'cde', 'regress_rls_bob'), (4, 'def', 'regress_rls_bob'); CREATE POLICY p1 ON current_check FOR SELECT USING (currentid % 2 = 0); CREATE POLICY p2 ON current_check FOR DELETE USING (currentid = 4 AND rlsuser = current_user); CREATE POLICY p3 ON current_check FOR UPDATE USING (currentid = 4) WITH CHECK (rlsuser = current_user); ALTER TABLE current_check ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; -- Can SELECT even rows SELECT * FROM current_check; -- Cannot UPDATE row 2 UPDATE current_check SET payload = payload || '_new' WHERE currentid = 2 RETURNING *; BEGIN; -- WHERE CURRENT OF does not work with custom scan nodes -- so we have to disable chunk append here SET timescaledb.enable_chunk_append TO false; DECLARE current_check_cursor SCROLL CURSOR FOR SELECT * FROM current_check; -- Returns rows that can be seen according to SELECT policy, like plain SELECT -- above (even rows) FETCH ABSOLUTE 1 FROM current_check_cursor; -- Still cannot UPDATE row 2 through cursor UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; -- Can update row 4 through cursor, which is the next visible row FETCH RELATIVE 1 FROM current_check_cursor; UPDATE current_check SET payload = payload || '_new' WHERE CURRENT OF current_check_cursor RETURNING *; SELECT * FROM current_check; -- Plan should be a subquery TID scan EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE current_check SET payload = payload WHERE CURRENT OF current_check_cursor; -- Similarly can only delete row 4 FETCH ABSOLUTE 1 FROM current_check_cursor; DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; FETCH RELATIVE 1 FROM current_check_cursor; DELETE FROM current_check WHERE CURRENT OF current_check_cursor RETURNING *; SELECT * FROM current_check; RESET timescaledb.enable_chunk_append; COMMIT; -- -- check pg_stats view filtering -- SET row_security TO ON; SET SESSION AUTHORIZATION regress_rls_alice; ANALYZE current_check; -- Stats visible SELECT row_security_active('current_check'); SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; SET SESSION AUTHORIZATION regress_rls_bob; -- Stats not visible SELECT row_security_active('current_check'); SELECT attname, most_common_vals FROM pg_stats WHERE tablename = 'current_check' ORDER BY 1; -- -- Collation support -- BEGIN; CREATE TABLE coll_t (c) AS VALUES ('bar'::text); CREATE POLICY coll_p ON coll_t USING (c < ('foo'::text COLLATE "C")); ALTER TABLE coll_t ENABLE ROW LEVEL SECURITY; GRANT SELECT ON coll_t TO regress_rls_alice; SELECT (string_to_array(polqual, ':'))[7] AS inputcollid FROM pg_policy WHERE polrelid = 'coll_t'::regclass; SET SESSION AUTHORIZATION regress_rls_alice; SELECT * FROM coll_t; ROLLBACK; -- -- Shared Object Dependencies -- RESET SESSION AUTHORIZATION; BEGIN; CREATE ROLE regress_rls_eve; CREATE ROLE regress_rls_frank; CREATE TABLE tbl1 (c) AS VALUES ('bar'::text); GRANT SELECT ON TABLE tbl1 TO regress_rls_eve; CREATE POLICY P ON tbl1 TO regress_rls_eve, regress_rls_frank USING (true); SELECT refclassid::regclass, deptype FROM pg_depend WHERE classid = 'pg_policy'::regclass AND refobjid = 'tbl1'::regclass; SELECT refclassid::regclass, deptype FROM pg_shdepend WHERE classid = 'pg_policy'::regclass AND refobjid IN ('regress_rls_eve'::regrole, 'regress_rls_frank'::regrole); SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on POLICY p ROLLBACK TO q; ALTER POLICY p ON tbl1 TO regress_rls_frank USING (true); SAVEPOINT q; DROP ROLE regress_rls_eve; --fails due to dependency on GRANT SELECT ROLLBACK TO q; REVOKE ALL ON TABLE tbl1 FROM regress_rls_eve; SAVEPOINT q; DROP ROLE regress_rls_eve; --succeeds ROLLBACK TO q; SAVEPOINT q; DROP ROLE regress_rls_frank; --fails due to dependency on POLICY p ROLLBACK TO q; DROP POLICY p ON tbl1; SAVEPOINT q; DROP ROLE regress_rls_frank; -- succeeds ROLLBACK TO q; ROLLBACK; -- cleanup -- -- Converting table to view -- BEGIN; CREATE TABLE t (c int); SELECT public.create_hypertable('t', 'c', chunk_time_interval=>2); CREATE POLICY p ON t USING (c % 2 = 1); ALTER TABLE t ENABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to row level security enabled ROLLBACK TO q; ALTER TABLE t DISABLE ROW LEVEL SECURITY; SAVEPOINT q; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- fails due to policy p on t ROLLBACK TO q; DROP POLICY p ON t; CREATE RULE "_RETURN" AS ON SELECT TO t DO INSTEAD SELECT * FROM generate_series(1,5) t0(c); -- succeeds ROLLBACK; -- -- Policy expression handling -- BEGIN; CREATE TABLE t (c) AS VALUES ('bar'::text); CREATE POLICY p ON t USING (max(c)); -- fails: aggregate functions are not allowed in policy expressions ROLLBACK; -- -- Non-target relations are only subject to SELECT policies -- SET SESSION AUTHORIZATION regress_rls_alice; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); CREATE TABLE r2 (a int); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); GRANT ALL ON r1, r2 TO regress_rls_bob; CREATE POLICY p1 ON r1 USING (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON r2 FOR SELECT USING (true); CREATE POLICY p2 ON r2 FOR INSERT WITH CHECK (false); CREATE POLICY p3 ON r2 FOR UPDATE USING (false); CREATE POLICY p4 ON r2 FOR DELETE USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; SET SESSION AUTHORIZATION regress_rls_bob; SELECT * FROM r1; SELECT * FROM r2; -- r2 is read-only INSERT INTO r2 VALUES (2); -- Not allowed \pset tuples_only 1 UPDATE r2 SET a = 2 RETURNING *; -- Updates nothing DELETE FROM r2 RETURNING *; -- Deletes nothing \pset tuples_only 0 -- r2 can be used as a non-target relation in DML INSERT INTO r1 SELECT a + 1 FROM r2 RETURNING *; -- OK UPDATE r1 SET a = r2.a + 2 FROM r2 WHERE r1.a = r2.a RETURNING *; -- OK DELETE FROM r1 USING r2 WHERE r1.a = r2.a + 2 RETURNING *; -- OK SELECT * FROM r1; SELECT * FROM r2; SET SESSION AUTHORIZATION regress_rls_alice; DROP TABLE r1; DROP TABLE r2; -- -- FORCE ROW LEVEL SECURITY applies RLS to owners too -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); INSERT INTO r1 VALUES (10), (20); CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No error, but no rows TABLE r1; -- RLS error INSERT INTO r1 VALUES (1); -- No error (unable to see any rows to update) UPDATE r1 SET a = 1; TABLE r1; -- No error (unable to see any rows to delete) DELETE FROM r1; TABLE r1; SET row_security = off; -- these all fail, would be affected by RLS TABLE r1; UPDATE r1 SET a = 1; DELETE FROM r1; DROP TABLE r1; -- -- FORCE ROW LEVEL SECURITY does not break RI -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Errors due to rows in r2 DELETE FROM r1; -- Reset r2 to no-RLS DROP POLICY p1 ON r2; ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; ALTER TABLE r2 DISABLE ROW LEVEL SECURITY; -- clean out r2 for INSERT test below DELETE FROM r2; -- Change r1 to not allow rows to be seen CREATE POLICY p1 ON r1 USING (false); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- No rows seen TABLE r1; -- No error, RI still sees that row exists in r1 INSERT INTO r2 VALUES (10); DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded DELETE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON DELETE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Deletes all records from both DELETE FROM r1; -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify no rows in r2 now TABLE r2; DROP TABLE r2; DROP TABLE r1; -- Ensure cascaded UPDATE works CREATE TABLE r1 (a int PRIMARY KEY); -- r1 is not a hypertable since r1.a is referenced by r2 CREATE TABLE r2 (a int REFERENCES r1 ON UPDATE CASCADE); SELECT public.create_hypertable('r2', 'a', chunk_time_interval=>2); INSERT INTO r1 VALUES (10), (20); INSERT INTO r2 VALUES (10), (20); -- Create policies on r2 which prevent the -- owner from seeing any rows, but RI should -- still see them. CREATE POLICY p1 ON r2 USING (false); ALTER TABLE r2 ENABLE ROW LEVEL SECURITY; ALTER TABLE r2 FORCE ROW LEVEL SECURITY; -- Updates records in both (terse output to not print CONTEXT, which can be different). \set VERBOSITY terse UPDATE r1 SET a = a+5; \set VERBOSITY default -- Remove FORCE from r2 ALTER TABLE r2 NO FORCE ROW LEVEL SECURITY; -- As owner, we now bypass RLS -- verify records in r2 updated TABLE r2; DROP TABLE r2; DROP TABLE r1; -- -- Test INSERT+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>2); CREATE POLICY p1 ON r1 FOR SELECT USING (false); CREATE POLICY p2 ON r1 FOR INSERT WITH CHECK (true); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine INSERT INTO r1 VALUES (10), (20); -- No error, but no rows TABLE r1; SET row_security = off; -- fail, would be affected by RLS TABLE r1; SET row_security = on; -- Error INSERT INTO r1 VALUES (10), (20) RETURNING *; DROP TABLE r1; -- -- Test UPDATE+RETURNING applies SELECT policies as -- WithCheckOptions (meaning an error is thrown) -- SET SESSION AUTHORIZATION regress_rls_alice; SET row_security = on; CREATE TABLE r1 (a int PRIMARY KEY); SELECT public.create_hypertable('r1', 'a', chunk_time_interval=>100); CREATE POLICY p1 ON r1 FOR SELECT USING (a < 20); CREATE POLICY p2 ON r1 FOR UPDATE USING (a < 20) WITH CHECK (true); CREATE POLICY p3 ON r1 FOR INSERT WITH CHECK (true); INSERT INTO r1 VALUES (10); ALTER TABLE r1 ENABLE ROW LEVEL SECURITY; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Works fine UPDATE r1 SET a = 30; -- Show updated rows ALTER TABLE r1 NO FORCE ROW LEVEL SECURITY; TABLE r1; -- reset value in r1 for test with RETURNING UPDATE r1 SET a = 10; -- Verify row reset TABLE r1; ALTER TABLE r1 FORCE ROW LEVEL SECURITY; -- Error UPDATE r1 SET a = 30 RETURNING *; -- UPDATE path of INSERT ... ON CONFLICT DO UPDATE should also error out INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30 RETURNING *; -- Should still error out without RETURNING (use of arbiter always requires -- SELECT permissions) INSERT INTO r1 VALUES (10) ON CONFLICT (a) DO UPDATE SET a = 30; -- ON CONFLICT ON CONSTRAINT INSERT INTO r1 VALUES (10) ON CONFLICT ON CONSTRAINT r1_pkey DO UPDATE SET a = 30; DROP TABLE r1; -- Check dependency handling RESET SESSION AUTHORIZATION; CREATE TABLE dep1 (c1 int); SELECT public.create_hypertable('dep1', 'c1', chunk_time_interval=>2); CREATE TABLE dep2 (c1 int); SELECT public.create_hypertable('dep2', 'c1', chunk_time_interval=>2); CREATE POLICY dep_p1 ON dep1 TO regress_rls_bob USING (c1 > (select max(dep2.c1) from dep2)); ALTER POLICY dep_p1 ON dep1 TO regress_rls_bob,regress_rls_carol; -- Should return one SELECT count(*) = 1 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); ALTER POLICY dep_p1 ON dep1 USING (true); -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_bob'); -- Should return one SELECT count(*) = 1 FROM pg_shdepend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_authid WHERE rolname = 'regress_rls_carol'); -- Should return zero SELECT count(*) = 0 FROM pg_depend WHERE objid = (SELECT oid FROM pg_policy WHERE polname = 'dep_p1') AND refobjid = (SELECT oid FROM pg_class WHERE relname = 'dep2'); -- DROP OWNED BY testing RESET SESSION AUTHORIZATION; CREATE ROLE regress_rls_dob_role1; CREATE ROLE regress_rls_dob_role2; CREATE TABLE dob_t1 (c1 int); SELECT public.create_hypertable('dob_t1', 'c1', chunk_time_interval=>2); CREATE TABLE dob_t2 (c1 int) PARTITION BY RANGE (c1); CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should fail, already gone CREATE POLICY p1 ON dob_t1 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t1; -- should succeed CREATE POLICY p1 ON dob_t2 TO regress_rls_dob_role1,regress_rls_dob_role2 USING (true); DROP OWNED BY regress_rls_dob_role1; DROP POLICY p1 ON dob_t2; -- should succeed DROP USER regress_rls_dob_role1; DROP USER regress_rls_dob_role2; -- -- Clean up objects -- RESET SESSION AUTHORIZATION; \set VERBOSITY terse \\ -- suppress cascade details DROP SCHEMA regress_rls_schema CASCADE; \set VERBOSITY default DROP USER regress_rls_alice; DROP USER regress_rls_bob; DROP USER regress_rls_carol; DROP USER regress_rls_dave; DROP USER regress_rls_exempt_user; DROP ROLE regress_rls_group1; DROP ROLE regress_rls_group2; -- Arrange to have a few policies left over, for testing -- pg_dump/pg_restore CREATE SCHEMA regress_rls_schema; CREATE TABLE rls_tbl (c1 int); SELECT public.create_hypertable('rls_tbl', 'c1', chunk_time_interval=>2); ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl USING (c1 > 5); CREATE POLICY p2 ON rls_tbl FOR SELECT USING (c1 <= 3); CREATE POLICY p3 ON rls_tbl FOR UPDATE USING (c1 <= 3) WITH CHECK (c1 > 5); CREATE POLICY p4 ON rls_tbl FOR DELETE USING (c1 <= 3); CREATE TABLE rls_tbl_force (c1 int); SELECT public.create_hypertable('rls_tbl_force', 'c1', chunk_time_interval=>2); ALTER TABLE rls_tbl_force ENABLE ROW LEVEL SECURITY; ALTER TABLE rls_tbl_force FORCE ROW LEVEL SECURITY; CREATE POLICY p1 ON rls_tbl_force USING (c1 = 5) WITH CHECK (c1 < 5); CREATE POLICY p2 ON rls_tbl_force FOR SELECT USING (c1 = 8); CREATE POLICY p3 ON rls_tbl_force FOR UPDATE USING (c1 = 8) WITH CHECK (c1 >= 5); CREATE POLICY p4 ON rls_tbl_force FOR DELETE USING (c1 = 8); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/size_utils.sql����������������������������������������������������������0000664�0000000�0000000�00000044670�15100345067�0020557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir include/insert_two_partitions.sql SELECT * FROM hypertable_detailed_size('"public"."two_Partitions"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_device_id_timeCustom_idx"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_device_id_idx"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_idx"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_0_idx"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_1_idx"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_2_idx"'); SELECT * FROM hypertable_index_size('"public"."two_Partitions_timeCustom_series_bool_idx"'); SELECT * FROM chunks_detailed_size('"public"."two_Partitions"') order by chunk_name; CREATE TABLE timestamp_partitioned(time TIMESTAMP, value TEXT); SELECT * FROM create_hypertable('timestamp_partitioned', 'time', 'value', 2); INSERT INTO timestamp_partitioned VALUES('2004-10-19 10:23:54', '10'); INSERT INTO timestamp_partitioned VALUES('2004-12-19 10:23:54', '30'); SELECT * FROM chunks_detailed_size('timestamp_partitioned') order by chunk_name; CREATE TABLE timestamp_partitioned_2(time TIMESTAMP, value CHAR(9)); SELECT * FROM create_hypertable('timestamp_partitioned_2', 'time', 'value', 2); INSERT INTO timestamp_partitioned_2 VALUES('2004-10-19 10:23:54', '10'); INSERT INTO timestamp_partitioned_2 VALUES('2004-12-19 10:23:54', '30'); SELECT * FROM chunks_detailed_size('timestamp_partitioned_2') order by chunk_name; CREATE TABLE toast_test(time TIMESTAMP, value TEXT); -- Set storage type to EXTERNAL to prevent PostgreSQL from compressing my -- easily compressable string and instead store it with TOAST ALTER TABLE toast_test ALTER COLUMN value SET STORAGE EXTERNAL; SELECT * FROM create_hypertable('toast_test', 'time'); INSERT INTO toast_test VALUES('2004-10-19 10:23:54', $$ this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. this must be over 2k. $$); SELECT * FROM chunks_detailed_size('toast_test'); -- -- Tests for approximate_row_count() -- -- Regular table -- CREATE TABLE approx_count(time TIMESTAMP, value int); INSERT INTO approx_count VALUES('2004-01-01 10:00:01', 1); INSERT INTO approx_count VALUES('2004-01-01 10:00:02', 2); INSERT INTO approx_count VALUES('2004-01-01 10:00:03', 3); INSERT INTO approx_count VALUES('2004-01-01 10:00:04', 4); INSERT INTO approx_count VALUES('2004-01-01 10:00:05', 5); INSERT INTO approx_count VALUES('2004-01-01 10:00:06', 6); INSERT INTO approx_count VALUES('2004-01-01 10:00:07', 7); SELECT * FROM approximate_row_count('approx_count'); ANALYZE approx_count; SELECT count(*) FROM approx_count; SELECT * FROM approximate_row_count('approx_count'); DROP TABLE approx_count; -- Regular table with basic inheritance -- CREATE TABLE approx_count(id int); INSERT INTO approx_count VALUES(1); SELECT count(*) FROM approx_count; SELECT * FROM approximate_row_count('approx_count'); ANALYZE approx_count; SELECT * FROM approximate_row_count('approx_count'); CREATE TABLE approx_count_child(id2 int) INHERITS (approx_count); INSERT INTO approx_count_child VALUES(0); SELECT count(*) FROM approx_count; SELECT * FROM approximate_row_count('approx_count'); ANALYZE approx_count_child; SELECT * FROM approximate_row_count('approx_count'); DROP TABLE approx_count CASCADE; -- Regular table with nested inheritance -- CREATE TABLE approx_count(id int); CREATE TABLE approx_count_a(id2 int) INHERITS (approx_count); CREATE TABLE approx_count_b(id3 int) INHERITS (approx_count_a); CREATE TABLE approx_count_c(id4 int) INHERITS (approx_count_b); INSERT INTO approx_count_a VALUES(0); INSERT INTO approx_count_b VALUES(1); INSERT INTO approx_count_c VALUES(2); INSERT INTO approx_count VALUES(3); SELECT * FROM approximate_row_count('approx_count'); ANALYZE approx_count_a; ANALYZE approx_count_b; ANALYZE approx_count_c; ANALYZE approx_count; SELECT count(*) FROM approx_count; SELECT * FROM approximate_row_count('approx_count'); SELECT count(*) FROM approx_count_a; SELECT * FROM approximate_row_count('approx_count_a'); SELECT count(*) FROM approx_count_b; SELECT * FROM approximate_row_count('approx_count_b'); SELECT count(*) FROM approx_count_c; SELECT * FROM approximate_row_count('approx_count_c'); DROP TABLE approx_count CASCADE; -- table with declarative partitioning -- CREATE TABLE approx_count_dp(time TIMESTAMP, value int) PARTITION BY RANGE(time); CREATE TABLE approx_count_dp0 PARTITION OF approx_count_dp FOR VALUES FROM ('2004-01-01 00:00:00') TO ('2005-01-01 00:00:00'); CREATE TABLE approx_count_dp1 PARTITION OF approx_count_dp FOR VALUES FROM ('2005-01-01 00:00:00') TO ('2006-01-01 00:00:00'); CREATE TABLE approx_count_dp2 PARTITION OF approx_count_dp FOR VALUES FROM ('2006-01-01 00:00:00') TO ('2007-01-01 00:00:00'); INSERT INTO approx_count_dp VALUES('2004-01-01 10:00:00', 1); INSERT INTO approx_count_dp VALUES('2004-01-01 11:00:00', 1); INSERT INTO approx_count_dp VALUES('2004-01-01 12:00:01', 1); INSERT INTO approx_count_dp VALUES('2005-01-01 10:00:00', 1); INSERT INTO approx_count_dp VALUES('2005-01-01 11:00:00', 1); INSERT INTO approx_count_dp VALUES('2005-01-01 12:00:01', 1); INSERT INTO approx_count_dp VALUES('2006-01-01 10:00:00', 1); INSERT INTO approx_count_dp VALUES('2006-01-01 11:00:00', 1); INSERT INTO approx_count_dp VALUES('2006-01-01 12:00:01', 1); SELECT count(*) FROM approx_count_dp; SELECT count(*) FROM approx_count_dp0; SELECT count(*) FROM approx_count_dp1; SELECT count(*) FROM approx_count_dp2; SELECT * FROM approximate_row_count('approx_count_dp'); ANALYZE approx_count_dp; SELECT * FROM approximate_row_count('approx_count_dp'); SELECT * FROM approximate_row_count('approx_count_dp0'); SELECT * FROM approximate_row_count('approx_count_dp1'); SELECT * FROM approximate_row_count('approx_count_dp2'); CREATE TABLE approx_count_dp_nested(time TIMESTAMP, device_id int, value int) PARTITION BY RANGE(time); CREATE TABLE approx_count_dp_nested_0 PARTITION OF approx_count_dp_nested FOR VALUES FROM ('2004-01-01 00:00:00') TO ('2005-01-01 00:00:00') PARTITION BY RANGE (device_id); CREATE TABLE approx_count_dp_nested_0_0 PARTITION OF approx_count_dp_nested_0 FOR VALUES FROM (0) TO (10); CREATE TABLE approx_count_dp_nested_0_1 PARTITION OF approx_count_dp_nested_0 FOR VALUES FROM (10) TO (20); CREATE TABLE approx_count_dp_nested_1 PARTITION OF approx_count_dp_nested FOR VALUES FROM ('2005-01-01 00:00:00') TO ('2006-01-01 00:00:00') PARTITION BY RANGE (device_id); CREATE TABLE approx_count_dp_nested_1_0 PARTITION OF approx_count_dp_nested_1 FOR VALUES FROM (0) TO (10); CREATE TABLE approx_count_dp_nested_1_1 PARTITION OF approx_count_dp_nested_1 FOR VALUES FROM (10) TO (20); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 1, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 2, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 3, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 11, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 12, 1); INSERT INTO approx_count_dp_nested VALUES('2004-01-01 10:00:00', 13, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 1, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 2, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 3, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 11, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 12, 1); INSERT INTO approx_count_dp_nested VALUES('2005-01-01 10:00:00', 13, 1); SELECT * FROM approximate_row_count('approx_count_dp_nested'); ANALYZE approx_count_dp_nested; SELECT (SELECT count(*) FROM approx_count_dp_nested) AS dp_nested, (SELECT count(*) FROM approx_count_dp_nested_0) AS dp_nested_0, (SELECT count(*) FROM approx_count_dp_nested_0_0) AS dp_nested_0_0, (SELECT count(*) FROM approx_count_dp_nested_0_1) AS dp_nested_0_1, (SELECT count(*) FROM approx_count_dp_nested_1) AS dp_nested_1, (SELECT count(*) FROM approx_count_dp_nested_1_0) AS dp_nested_1_0, (SELECT count(*) FROM approx_count_dp_nested_1_1) AS dp_nested_1_1 UNION ALL SELECT approximate_row_count('approx_count_dp_nested'), approximate_row_count('approx_count_dp_nested_0'), approximate_row_count('approx_count_dp_nested_0_0'), approximate_row_count('approx_count_dp_nested_0_1'), approximate_row_count('approx_count_dp_nested_1'), approximate_row_count('approx_count_dp_nested_1_0'), approximate_row_count('approx_count_dp_nested_1_1'); -- Hypertable -- CREATE TABLE approx_count(time TIMESTAMP, value int); SELECT * FROM create_hypertable('approx_count', 'time'); INSERT INTO approx_count VALUES('2004-01-01 10:00:01', 1); INSERT INTO approx_count VALUES('2004-01-01 10:00:02', 2); INSERT INTO approx_count VALUES('2004-01-01 10:00:03', 3); INSERT INTO approx_count VALUES('2004-01-01 10:00:04', 4); INSERT INTO approx_count VALUES('2004-01-01 10:00:05', 5); INSERT INTO approx_count VALUES('2004-01-01 10:00:06', 6); INSERT INTO approx_count VALUES('2004-01-01 10:00:07', 7); INSERT INTO approx_count VALUES('2004-01-01 10:00:08', 8); INSERT INTO approx_count VALUES('2004-01-01 10:00:09', 9); INSERT INTO approx_count VALUES('2004-01-01 10:00:10', 10); SELECT count(*) FROM approx_count; SELECT * FROM approximate_row_count('approx_count'); ANALYZE approx_count; SELECT * FROM approximate_row_count('approx_count'); \set ON_ERROR_STOP 0 SELECT * FROM approximate_row_count('unexisting'); SELECT * FROM approximate_row_count(); SELECT * FROM approximate_row_count(NULL); \set ON_ERROR_STOP 1 -- Test size functions with invalid or non-existing OID SELECT * FROM hypertable_size(0); SELECT * FROM hypertable_detailed_size(0) ORDER BY node_name; SELECT * FROM chunks_detailed_size(0) ORDER BY node_name; SELECT * FROM hypertable_compression_stats(0) ORDER BY node_name; SELECT * FROM chunk_compression_stats(0) ORDER BY node_name; SELECT * FROM hypertable_index_size(0); SELECT * FROM _timescaledb_functions.relation_size(0); SELECT * FROM hypertable_size(1); SELECT * FROM hypertable_detailed_size(1) ORDER BY node_name; SELECT * FROM chunks_detailed_size(1) ORDER BY node_name; SELECT * FROM hypertable_compression_stats(1) ORDER BY node_name; SELECT * FROM chunk_compression_stats(1) ORDER BY node_name; SELECT * FROM hypertable_index_size(1); SELECT * FROM _timescaledb_functions.relation_size(1); -- Test size functions with NULL input SELECT * FROM hypertable_size(NULL); SELECT * FROM hypertable_detailed_size(NULL) ORDER BY node_name; SELECT * FROM chunks_detailed_size(NULL) ORDER BY node_name; SELECT * FROM hypertable_compression_stats(NULL) ORDER BY node_name; SELECT * FROM chunk_compression_stats(NULL) ORDER BY node_name; SELECT * FROM hypertable_index_size(NULL); SELECT * FROM _timescaledb_functions.relation_size(NULL); -- Test approximate size functions with invalid input SELECT * FROM hypertable_approximate_size(0); SELECT * FROM hypertable_approximate_detailed_size(0); SELECT * FROM _timescaledb_functions.relation_approximate_size(0); SELECT * FROM hypertable_approximate_size(NULL); SELECT * FROM hypertable_approximate_detailed_size(NULL); SELECT * FROM _timescaledb_functions.relation_approximate_size(NULL); -- Test size on view, sequence and composite type CREATE VIEW view1 as SELECT 1; SELECT * FROM _timescaledb_functions.relation_approximate_size('view1'); SELECT * FROM _timescaledb_functions.relation_size('view1'); CREATE SEQUENCE test_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; SELECT * FROM _timescaledb_functions.relation_approximate_size('test_id_seq'); SELECT * FROM _timescaledb_functions.relation_size('test_id_seq'); CREATE TYPE test_type AS (time timestamp, temp float); SELECT * FROM _timescaledb_functions.relation_approximate_size('test_type'); SELECT * FROM _timescaledb_functions.relation_size('test_type'); -- Test size functions on regular table CREATE TABLE hypersize(time timestamptz, device int); CREATE INDEX hypersize_time_idx ON hypersize (time); \set ON_ERROR_STOP 0 \set VERBOSITY default \set SHOW_CONTEXT never SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx'); SELECT * FROM _timescaledb_functions.relation_size('hypersize'); SELECT * FROM hypertable_size('hypersize'); SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name; SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name; SELECT * FROM hypertable_compression_stats('hypersize') ORDER BY node_name; SELECT * FROM chunk_compression_stats('hypersize') ORDER BY node_name; SELECT * FROM hypertable_index_size('hypersize_time_idx'); SELECT * FROM _timescaledb_functions.relation_approximate_size('hypersize'); SELECT * FROM hypertable_approximate_size('hypersize'); SELECT * FROM hypertable_approximate_detailed_size('hypersize'); \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Test size functions on empty hypertable SELECT * FROM create_hypertable('hypersize', 'time'); SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx'); SELECT * FROM _timescaledb_functions.relation_size('hypersize'); SELECT * FROM hypertable_size('hypersize'); SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name; SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name; SELECT * FROM hypertable_compression_stats('hypersize') ORDER BY node_name; SELECT * FROM chunk_compression_stats('hypersize') ORDER BY node_name; SELECT * FROM hypertable_index_size('hypersize_time_idx'); SELECT * FROM _timescaledb_functions.relation_approximate_size('hypersize'); SELECT * FROM hypertable_approximate_size('hypersize'); SELECT * FROM hypertable_approximate_detailed_size('hypersize'); -- Test size functions on non-empty hypertable INSERT INTO hypersize VALUES('2021-02-25', 1); SELECT pg_relation_size('hypersize'), pg_table_size('hypersize'), pg_indexes_size('hypersize'), pg_total_relation_size('hypersize'), pg_relation_size('hypersize_time_idx'); SELECT pg_relation_size(ch), pg_table_size(ch), pg_indexes_size(ch), pg_total_relation_size(ch) FROM show_chunks('hypersize') ch ORDER BY ch; SELECT * FROM show_chunks('hypersize') ch JOIN LATERAL _timescaledb_functions.relation_size(ch) ON true; SELECT * FROM hypertable_size('hypersize'); SELECT * FROM hypertable_detailed_size('hypersize') ORDER BY node_name; SELECT * FROM chunks_detailed_size('hypersize') ORDER BY node_name; SELECT * FROM hypertable_compression_stats('hypersize') ORDER BY node_name; SELECT * FROM chunk_compression_stats('hypersize') ORDER BY node_name; SELECT * FROM hypertable_index_size('hypersize_time_idx'); SELECT * FROM _timescaledb_functions.relation_approximate_size('hypersize'); SELECT * FROM hypertable_approximate_size('hypersize'); SELECT * FROM hypertable_approximate_detailed_size('hypersize'); -- Test approx size functions with toast entries SELECT * FROM _timescaledb_functions.relation_approximate_size('toast_test'); SELECT * FROM hypertable_approximate_size('toast_test'); SELECT * FROM hypertable_approximate_detailed_size('toast_test'); -- Test approx size function against a regular table \set ON_ERROR_STOP 0 CREATE TABLE regular(time TIMESTAMP, value TEXT); SELECT * FROM hypertable_approximate_size('regular'); \set ON_ERROR_STOP 1 -- Test approx size functions with dropped chunks CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; SELECT * FROM hypertable_approximate_size('drop_chunks_table'); SELECT drop_chunks('drop_chunks_table', older_than => 19); SELECT * FROM hypertable_approximate_size('drop_chunks_table'); -- github issue #4857 -- below procedure should not crash SET client_min_messages = ERROR; do $$ DECLARE o INT; BEGIN FOR c IN 1..20 LOOP ANALYZE; END LOOP; END; $$; RESET client_min_messages; ������������������������������������������������������������������������timescaledb-2.23.0/test/sql/sort_optimization.sql���������������������������������������������������0000664�0000000�0000000�00000006462�15100345067�0022157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF) ' CREATE TABLE order_test(time int NOT NULL, device_id int, value float); CREATE INDEX ON order_test(time,device_id); CREATE INDEX ON order_test(device_id,time); SELECT create_hypertable('order_test','time',chunk_time_interval:=1000); INSERT INTO order_test SELECT 0,10,0.5; INSERT INTO order_test SELECT 1,9,0.5; INSERT INTO order_test SELECT 2,8,0.5; -- we want to see here that index scans are possible for the chosen expressions -- so we disable seqscan so we dont need to worry about other factors which would -- make PostgreSQL prefer seqscan over index scan SET enable_seqscan TO off; -- test sort optimization with single member order by SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1; -- should use index scan :PREFIX SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1; -- test sort optimization with ordering by multiple columns and time_bucket not last SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1,2; SET enable_seqscan TO default; -- must not use index scan :PREFIX SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 1,2; SET enable_seqscan TO off; -- test sort optimization with ordering by multiple columns and time_bucket as last member SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 2,1; -- should use index scan :PREFIX SELECT time_bucket(10,time),device_id,value FROM order_test ORDER BY 2,1; -- test sort optimization with interval calculation with non-fixed interval -- #7097 CREATE TABLE i7097_1(time timestamptz NOT NULL, quantity float, "isText" boolean); CREATE TABLE i7097_2(time timestamptz NOT NULL, quantity float, "isText" boolean); CREATE INDEX ON i7097_1(time) WHERE "isText" IS NULL; CREATE INDEX ON i7097_2(time) WHERE "isText" IS NULL; SELECT table_name FROM create_hypertable('i7097_1', 'time', create_default_indexes => false); SELECT table_name FROM create_hypertable('i7097_2', 'time', create_default_indexes => false); INSERT INTO i7097_1(time, quantity) SELECT time, round((random() * (100-3) + 3)::NUMERIC) AS quantity FROM generate_series('2023-01-01T00:00:00+01:00', '2023-05-01T00:00:00+01:00', interval 'PT10M') AS t(time); INSERT INTO i7097_2(time, quantity) SELECT time, round((random() * (100-3) + 3)::NUMERIC) AS quantity FROM generate_series('2023-01-01T00:00:00+01:00', '2023-05-01T00:00:00+01:00', interval 'PT10M') AS t(time); VACUUM ANALYZE i7097_1, i7097_2; SET TIME ZONE 'Europe/Paris'; WITH "cte1" AS (SELECT time + interval 'P1Y' AS time, avg(quantity) AS quantity FROM i7097_1 WHERE time >= '2024-03-31T00:00:00+01:00'::timestamptz - interval 'P1Y' AND time < '2024-03-31T23:59:59+02:00'::timestamptz + (- interval 'P1Y') AND "isText" IS NULL GROUP BY 1 ORDER BY 1 ASC), "cte2" AS (SELECT time + interval 'P1Y' AS time, avg(quantity) AS quantity FROM i7097_2 WHERE time >= '2024-03-31T00:00:00+01:00'::timestamptz - interval 'P1Y' AND time < '2024-03-31T23:59:59+02:00'::timestamptz + (- interval 'P1Y') AND "isText" IS NULL GROUP BY 1 ORDER BY 1 ASC) SELECT count(*) FROM (SELECT time, cte1.quantity + cte2.quantity FROM cte1 FULL OUTER JOIN cte2 USING (time)) j; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/sql_query.sql�����������������������������������������������������������0000664�0000000�0000000�00000006057�15100345067�0020406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql \o SELECT * FROM PUBLIC."two_Partitions"; EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions"; \echo "The following queries should NOT scan two_Partitions._hyper_1_1_chunk" EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions" WHERE device_id = 'dev2'; EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions" WHERE device_id = 'dev'||'2'; EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM PUBLIC."two_Partitions" WHERE 'dev'||'2' = device_id; --test integer partition key CREATE TABLE "int_part"(time timestamp, object_id int, temp float); SELECT create_hypertable('"int_part"', 'time', 'object_id', 2); INSERT INTO "int_part" VALUES('2017-01-20T09:00:01', 1, 22.5); INSERT INTO "int_part" VALUES('2017-01-20T09:00:01', 2, 22.5); --check that there are two chunks SELECT * FROM test.show_subtables('int_part'); SELECT * FROM "int_part" WHERE object_id = 1; --check that queries with IN/ANY/= work for the "time" column SELECT * FROM "int_part" WHERE time IN (NULL); SELECT * FROM "int_part" WHERE time = ANY (NULL); SELECT * FROM "int_part" WHERE time = NULL; --make sure this touches only one partititon EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM "int_part" WHERE object_id = 1; --Need to verify space partitions are currently pruned in this query --EXPLAIN (verbose ON, buffers off, costs off) SELECT * FROM "two_Partitions" WHERE device_id IN ('dev2', 'dev21'); \echo "The following shows non-aggregated queries with time desc using merge append" EXPLAIN (verbose ON, buffers off, costs off)SELECT * FROM PUBLIC."two_Partitions" ORDER BY "timeCustom" DESC NULLS LAST limit 2; --shows that more specific indexes are used if the WHERE clauses "match", uses the series_1 index here. EXPLAIN (verbose ON, buffers off, costs off)SELECT * FROM PUBLIC."two_Partitions" WHERE series_1 IS NOT NULL ORDER BY "timeCustom" DESC NULLS LAST limit 2; --here the "match" is implication series_1 > 1 => series_1 IS NOT NULL EXPLAIN (verbose ON, buffers off, costs off)SELECT * FROM PUBLIC."two_Partitions" WHERE series_1 > 1 ORDER BY "timeCustom" DESC NULLS LAST limit 2; --note that without time transform things work too EXPLAIN (verbose ON, buffers off, costs off)SELECT "timeCustom" t, min(series_0) FROM PUBLIC."two_Partitions" GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --The query should still use the index on timeCustom, even though the GROUP BY/ORDER BY is on the transformed time 't'. --However, current query plans show that it does not. EXPLAIN (verbose ON, buffers off, costs off)SELECT "timeCustom"/10 t, min(series_0) FROM PUBLIC."two_Partitions" GROUP BY t ORDER BY t DESC NULLS LAST limit 2; EXPLAIN (verbose ON, buffers off, costs off)SELECT "timeCustom"%10 t, min(series_0) FROM PUBLIC."two_Partitions" GROUP BY t ORDER BY t DESC NULLS LAST limit 2; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/symbol_conflict.sql�����������������������������������������������������0000664�0000000�0000000�00000001574�15100345067�0021547�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Test for symbol conflicts between the loader module and the -- versioned extension module. -- This test fails on, e.g. Linux, unless compiled with -fvisibility=hidden CREATE OR REPLACE FUNCTION hello_loader() RETURNS TEXT AS 'timescaledb', 'loader_hello' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; SELECT hello_loader(); CREATE OR REPLACE FUNCTION hello_timescaledb() RETURNS TEXT AS :MODULE_PATHNAME, 'timescaledb_hello' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; -- This calls an internal function with a conflicting name in the loader SELECT hello_loader(); -- This calls the identically named internal function in the versioned extension SELECT hello_timescaledb(); ������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/tableam.sql�������������������������������������������������������������0000664�0000000�0000000�00000002053�15100345067�0017757�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test support for setting table access method on hypertables \c :TEST_DBNAME :ROLE_SUPERUSER -- create a new access method that reuses the heap handler CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE testam (time timestamptz, device int, temp float) USING testam; SELECT create_hypertable('testam', 'time', 'device', 2); -- show that the hypertable is using the 'testam' table access method SELECT amname AS hypertable_amname FROM pg_class cl, pg_am am WHERE cl.oid = 'testam'::regclass AND cl.relam = am.oid; -- insert data to create a chunk INSERT INTO testam VALUES('2020-01-22:11:30', 1, 29.3); -- make sure the table access method for a chunk is the same as the -- hypertable root SELECT amname AS chunk_amname FROM pg_class cl, pg_am am, show_chunks('testam') ch WHERE cl.oid = ch AND cl.relam = am.oid; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/tableam_alter.sql�������������������������������������������������������0000664�0000000�0000000�00000003435�15100345067�0021153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test support for setting table access method on hypertables using -- ALTER TABLE. It should propagate to the chunks. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE VIEW chunk_info AS SELECT hypertable_name AS hypertable, chunk_name AS chunk, amname FROM timescaledb_information.chunks ch JOIN pg_class cl ON (format('%I.%I', ch.chunk_schema, ch.chunk_name)::regclass = cl.oid) JOIN pg_am am ON (am.oid = cl.relam); CREATE TABLE test_table (time timestamptz not null, device int, temp float); SELECT create_hypertable('test_table', by_range('time')); INSERT INTO test_table SELECT ts, 10 * random(), 100 * random() FROM generate_series('2001-01-01'::timestamp, '2001-02-01', '1d'::interval) as x(ts); SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; SELECT * FROM chunk_info WHERE hypertable = 'test_table'; -- Test setting the access method together with other options. This -- should not generate an error. ALTER TABLE test_table SET ACCESS METHOD testam, SET (autovacuum_vacuum_threshold = 100); -- Create more chunks. These will use the new access method, but the -- old chunks will use the old access method. INSERT INTO test_table SELECT ts, 10 * random(), 100 * random() FROM generate_series('2001-02-01'::timestamp, '2001-03-01', '1d'::interval) as x(ts); SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; SELECT * FROM chunk_info WHERE hypertable = 'test_table'; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/tableam_alter_defaults.sql����������������������������������������������0000664�0000000�0000000�00000005112�15100345067�0023034�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test support for setting table access method on hypertables using -- ALTER TABLE for version 17 and later. This is in addition to the -- tests in tableam_alter.sql. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE VIEW chunk_info AS SELECT hypertable_name AS hypertable, chunk_name AS chunk, amname FROM timescaledb_information.chunks ch JOIN pg_class cl ON (format('%I.%I', ch.chunk_schema, ch.chunk_name)::regclass = cl.oid) JOIN pg_am am ON (am.oid = cl.relam); CREATE TABLE test_table (time timestamptz not null, device int, temp float); SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; -- Check that setting default access method of a normal table works. ALTER TABLE test_table SET ACCESS METHOD DEFAULT; -- Check that changing the access method and then changing it back -- works. ALTER TABLE test_table SET ACCESS METHOD testam; ALTER TABLE test_table SET ACCESS METHOD DEFAULT; -- Check that setting default access method of a hypertable works. SELECT create_hypertable('test_table', by_range('time')); ALTER TABLE test_table SET ACCESS METHOD DEFAULT; SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; -- Test setting the access method together with other options. This -- should not generate an error. ALTER TABLE test_table SET ACCESS METHOD testam, SET (autovacuum_vacuum_threshold = 100); -- Add some rows to generate a chunk. This should get the access -- method of the hypertable. INSERT INTO test_table SELECT ts, 10 * random(), 100 * random() FROM generate_series('2001-01-01'::timestamp, '2001-01-14', '1d'::interval) as x(ts); SELECT * FROM chunk_info WHERE hypertable = 'test_table'; -- Setting it to the default method after we have set it to a test -- access method should work fine also on a hypertable. SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; ALTER TABLE test_table SET ACCESS METHOD DEFAULT; SELECT cl.relname, amname FROM pg_class cl JOIN pg_am am ON cl.relam = am.oid WHERE cl.relname = 'test_table'; SELECT chunk FROM show_chunks('test_table') t(chunk) limit 1 \gset ALTER TABLE :chunk SET ACCESS METHOD DEFAULT; SELECT * FROM chunk_info WHERE hypertable = 'test_table'; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/tablespace.sql����������������������������������������������������������0000664�0000000�0000000�00000023617�15100345067�0020466�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set ON_ERROR_STOP 0 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW hypertable_tablespaces AS SELECT cls.relname AS hypertable, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM _timescaledb_catalog.hypertable, LATERAL (SELECT * FROM pg_class WHERE oid = format('%I.%I', schema_name, table_name)::regclass) AS cls ORDER BY hypertable, tablespace; GRANT SELECT ON hypertable_tablespaces TO PUBLIC; --Test hypertable with tablespace. Tablespaces are cluster-wide, so we --attach the test name as prefix to allow tests to be executed in --parallel. CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --assigning a tablespace via the main table should work CREATE TABLE tspace_2dim(time timestamp, temp float, device text) TABLESPACE tablespace1; SELECT create_hypertable('tspace_2dim', 'time', 'device', 2); INSERT INTO tspace_2dim VALUES ('2017-01-20T09:00:01', 24.3, 'blue'); -- Tablespace for tspace_2dim should be set SELECT * FROM hypertable_tablespaces WHERE hypertable = 'tspace_2dim'; SELECT show_tablespaces('tspace_2dim'); --verify that the table chunk has the correct tablespace SELECT relname, spcname FROM pg_class c INNER JOIN pg_tablespace t ON (c.reltablespace = t.oid) INNER JOIN _timescaledb_catalog.chunk ch ON (ch.table_name = c.relname); --check some error conditions SELECT attach_tablespace(NULL,NULL); SELECT attach_tablespace('tablespace2', NULL); SELECT attach_tablespace(NULL, 'tspace_2dim'); SELECT attach_tablespace('none_existing_tablespace', 'tspace_2dim'); SELECT attach_tablespace('tablespace2', 'none_existing_table'); SELECT detach_tablespace(NULL); SELECT detach_tablespaces(NULL); SELECT show_tablespaces(NULL); --attach another tablespace without first creating it --> should generate error SELECT attach_tablespace('tablespace2', 'tspace_2dim'); --attach the same tablespace twice to same table should also generate error SELECT attach_tablespace('tablespace1', 'tspace_2dim'); --no error if if_not_attached is given SELECT attach_tablespace('tablespace1', 'tspace_2dim', if_not_attached => true); \c :TEST_DBNAME :ROLE_SUPERUSER --Tablespaces are cluster-wide, so we attach the test name as prefix --to allow tests to be executed in parallel. CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER_2 LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --attach without permissions on the table should fail SELECT attach_tablespace('tablespace2', 'tspace_2dim'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --attach without permissions on the tablespace should also fail SELECT attach_tablespace('tablespace2', 'tspace_2dim'); \c :TEST_DBNAME :ROLE_SUPERUSER GRANT :ROLE_DEFAULT_PERM_USER_2 TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --should work with permissions on both the table and the tablespace SELECT attach_tablespace('tablespace2', 'tspace_2dim'); SELECT * FROM _timescaledb_catalog.tablespace; SELECT * FROM show_tablespaces('tspace_2dim'); --insert into another chunk INSERT INTO tspace_2dim VALUES ('2017-01-20T09:00:01', 24.3, 'brown'); SELECT * FROM test.show_subtables('tspace_2dim'); --indexes should inherit the tablespace of their chunk SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); \x SELECT * FROM timescaledb_information.hypertables ORDER BY hypertable_schema, hypertable_name; SELECT hypertable_schema, hypertable_name, chunk_schema, chunk_name, chunk_tablespace FROM timescaledb_information.chunks ORDER BY chunk_name; \x -- SET ROLE :ROLE_DEFAULT_PERM_USER_2; CREATE TABLE tspace_1dim(time timestamp, temp float, device text); SELECT create_hypertable('tspace_1dim', 'time'); --user doesn't have permission on tablespace1 --> error SELECT attach_tablespace('tablespace1', 'tspace_1dim'); --grant permission to tablespace1 SET ROLE :ROLE_DEFAULT_PERM_USER; GRANT CREATE ON TABLESPACE tablespace1 TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; --should work fine now. Test SELECT INTO utility statements to ensure --internal alter table function call works with event triggers. SELECT true INTO attached FROM attach_tablespace('tablespace1', 'tspace_1dim'); SELECT attach_tablespace('tablespace2', 'tspace_1dim'); -- Tablespace for tspace_1dim should be set and attached SELECT * FROM hypertable_tablespaces WHERE hypertable = 'tspace_1dim'; SELECT show_tablespaces('tspace_1dim'); --trying to revoke permissions while attached should fail SET ROLE :ROLE_DEFAULT_PERM_USER; REVOKE CREATE ON TABLESPACE tablespace1 FROM :ROLE_DEFAULT_PERM_USER_2; REVOKE ALL ON TABLESPACE tablespace1 FROM :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM _timescaledb_catalog.tablespace; INSERT INTO tspace_1dim VALUES ('2017-01-20T09:00:01', 24.3, 'blue'); INSERT INTO tspace_1dim VALUES ('2017-03-20T09:00:01', 24.3, 'brown'); SELECT * FROM test.show_subtablesp('tspace_%'); --indexes should inherit the tablespace of their chunk, unless the --parent index has a tablespace set, in which case the chunks' --corresponding indexes are pinned to the parent index's --tablespace. The parent index can have a tablespace set in two cases: --(1) if explicitly set in CREATE INDEX, or (2) if the main table was --created with a tablespace, because then default indexes will be --created in that tablespace too. SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); --detach tablespace1 from tspace_2dim should fail due to lack of permissions SELECT detach_tablespace('tablespace1', 'tspace_2dim'); --detach tablespace1 from all tables. Should only detach from --'tspace_1dim' (1 tablespace) due to lack of permissions SELECT * FROM hypertable_tablespaces; SELECT * INTO detached FROM detach_tablespace('tablespace1'); SELECT * FROM detached; SELECT * FROM _timescaledb_catalog.tablespace; SELECT * FROM show_tablespaces('tspace_1dim'); SELECT * FROM show_tablespaces('tspace_2dim'); SELECT * FROM hypertable_tablespaces; --it should now be possible to revoke permissions on tablespace1 SET ROLE :ROLE_DEFAULT_PERM_USER; REVOKE CREATE ON TABLESPACE tablespace1 FROM :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; --detach the other tablespace SELECT detach_tablespace('tablespace2', 'tspace_1dim'); SELECT * FROM _timescaledb_catalog.tablespace; SELECT * FROM show_tablespaces('tspace_1dim'); SELECT * FROM show_tablespaces('tspace_2dim'); SELECT * FROM hypertable_tablespaces; --detaching tablespace2 from a table without permissions should fail SELECT detach_tablespace('tablespace2', 'tspace_2dim'); SELECT detach_tablespaces('tspace_2dim'); \c :TEST_DBNAME :ROLE_SUPERUSER -- PERM_USER_2 owns tablespace2, and PERM_USER owns the table -- 'tspace_2dim', which has tablespace2 attached. Revoking PERM_USER_2 -- FROM PERM_USER should therefore fail REVOKE :ROLE_DEFAULT_PERM_USER_2 FROM :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER_2; --set other user should make detach work SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * INTO detached_all FROM detach_tablespaces('tspace_2dim'); SELECT * FROM detached_all; SELECT * FROM _timescaledb_catalog.tablespace; SELECT * FROM show_tablespaces('tspace_1dim'); SELECT * FROM show_tablespaces('tspace_2dim'); \c :TEST_DBNAME :ROLE_SUPERUSER -- It should now be possible to revoke PERM_USER_2 from PERM_USER -- since tablespace2 is no longer attched to tspace_2dim REVOKE :ROLE_DEFAULT_PERM_USER_2 FROM :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; --detaching twice should fail SELECT detach_tablespace('tablespace2', 'tspace_2dim'); --adding if_attached should only generate notice SELECT detach_tablespace('tablespace2', 'tspace_2dim', if_attached => true); --attach tablespaces again to verify that tablespaces are cleaned up --when tables are dropped \c :TEST_DBNAME :ROLE_SUPERUSER SELECT attach_tablespace('tablespace2', 'tspace_1dim'); SELECT attach_tablespace('tablespace1', 'tspace_2dim'); SELECT * FROM _timescaledb_catalog.tablespace; DROP TABLE tspace_1dim; SELECT * FROM _timescaledb_catalog.tablespace; DROP TABLE tspace_2dim; SELECT * FROM _timescaledb_catalog.tablespace; -- Create two tables and attach multiple tablespaces to them. Verify -- that dropping a tablespace from multiple tables work as expected. CREATE TABLE tbl_1(time timestamp, temp float, device text); SELECT create_hypertable('tbl_1', 'time'); CREATE TABLE tbl_2(time timestamp, temp float, device text); SELECT create_hypertable('tbl_2', 'time'); CREATE TABLE tbl_3(time timestamp, temp float, device text); SELECT create_hypertable('tbl_3', 'time'); SELECT * FROM hypertable_tablespaces; SELECT * FROM show_tablespaces('tbl_1'); SELECT * FROM show_tablespaces('tbl_2'); SELECT * FROM show_tablespaces('tbl_3'); SELECT attach_tablespace('tablespace1', 'tbl_1'); SELECT attach_tablespace('tablespace2', 'tbl_1'); SELECT attach_tablespace('tablespace2', 'tbl_2'); SELECT attach_tablespace('tablespace2', 'tbl_3'); SELECT * FROM hypertable_tablespaces; SELECT * FROM show_tablespaces('tbl_1'); SELECT * FROM show_tablespaces('tbl_2'); SELECT * FROM show_tablespaces('tbl_3'); SELECT detach_tablespace('tablespace2'); SELECT * FROM hypertable_tablespaces; SELECT * FROM show_tablespaces('tbl_1'); SELECT * FROM show_tablespaces('tbl_2'); SELECT * FROM show_tablespaces('tbl_3'); DROP TABLE tbl_1; DROP TABLE tbl_2; DROP TABLE tbl_3; -- verify that one cannot DROP a tablespace while it is attached to a -- hypertable CREATE TABLE tbl_1(time timestamp, temp float, device text); SELECT create_hypertable('tbl_1', 'time'); SELECT attach_tablespace('tablespace1', 'tbl_1'); SELECT * FROM show_tablespaces('tbl_1'); DROP TABLESPACE tablespace1; --after detaching we should now be able to drop the tablespace SELECT detach_tablespace('tablespace1', 'tbl_1'); DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/telemetry.sql�����������������������������������������������������������0000664�0000000�0000000�00000031377�15100345067�0020377�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_status(int) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_status' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_status_ssl(int) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_status_ssl' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_status_mock(text) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_status_mock' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_validate_server_version(response text) RETURNS TEXT AS :MODULE_PATHNAME, 'ts_test_validate_server_version' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_telemetry_main_conn(text, text) RETURNS BOOLEAN AS :MODULE_PATHNAME, 'ts_test_telemetry_main_conn' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_telemetry(host text = NULL, servname text = NULL, port int = NULL) RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_telemetry' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.test_privacy() RETURNS BOOLEAN AS :MODULE_PATHNAME, 'ts_test_privacy' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test_check_version_response(response text) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_check_version_response' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; INSERT INTO _timescaledb_catalog.metadata VALUES ('foo','bar',TRUE); INSERT INTO _timescaledb_catalog.metadata VALUES ('bar','baz',FALSE); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT _timescaledb_internal.test_status_ssl(200); SELECT _timescaledb_internal.test_status_ssl(201); \set ON_ERROR_STOP 0 SELECT _timescaledb_internal.test_status_ssl(304); SELECT _timescaledb_internal.test_status_ssl(400); SELECT _timescaledb_internal.test_status_ssl(401); SELECT _timescaledb_internal.test_status_ssl(404); SELECT _timescaledb_internal.test_status_ssl(500); SELECT _timescaledb_internal.test_status_ssl(503); \set ON_ERROR_STOP 1 -- This function runs the test 5 times, because each time the internal C function is choosing a random length to send from the server on each socket read. We hit many cases this way. CREATE OR REPLACE FUNCTION mocker(TEXT) RETURNS SETOF TEXT AS $BODY$ DECLARE r TEXT; BEGIN FOR i in 1..5 LOOP SELECT _timescaledb_internal.test_status_mock($1) INTO r; RETURN NEXT r; END LOOP; RETURN; END $BODY$ LANGUAGE 'plpgsql'; select * from mocker( E'HTTP/1.1 200 OK\r\n' 'Content-Type: application/json; charset=utf-8\r\n' 'Date: Thu, 12 Jul 2018 18:33:04 GMT\r\n' 'ETag: W/\"e-upYEWCL+q6R/++2nWHz5b76hBgo\"\r\n' 'Server: nginx\r\n' 'Vary: Accept-Encoding\r\n' 'Content-Length: 14\r\n' 'Connection: Close\r\n\r\n' '{\"status\":200}'); select * from mocker( E'HTTP/1.1 201 OK\r\n' 'Content-Type: application/json; charset=utf-8\r\n' 'Vary: Accept-Encoding\r\n' 'Content-Length: 14\r\n' 'Connection: Close\r\n\r\n' '{\"status\":201}'); \set ON_ERROR_STOP 0 \set test_string 'HTTP/1.1 404 Not Found\r\nContent-Length: 14\r\nConnection: Close\r\n\r\n{\"status\":404}'; SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); \set test_string 'Content-Length: 14\r\nConnection: Close\r\n\r\n{\"status\":404}'; SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); \set test_string 'HTTP/1.1 404 Not Found\r\nContent-Length: 14\r\nConnection: Close\r\n{\"status\":404}'; SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); SELECT _timescaledb_internal.test_status_mock(:'test_string'); \set ON_ERROR_STOP 1 -- Test parsing version response SELECT * FROM _timescaledb_internal.test_validate_server_version('{"status": "200", "current_timescaledb_version": "10.1.0"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "9.2.0"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "9.1.2"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-rc1"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-rc2"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-rc1"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-alpha"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "123456789"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "!@#$%"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": ""}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": " 10 "}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "a"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "a.b.c"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1.1a"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1.1+rc1"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "10.1.1.1"}'); SELECT * FROM _timescaledb_internal.test_validate_server_version('{"current_timescaledb_version": "1.0.0-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"}'); ---------------------------------------------------------------- -- Test well-formed response and valid versions SELECT test_check_version_response('{"current_timescaledb_version": "1.6.1", "is_up_to_date": true}'); SELECT test_check_version_response('{"current_timescaledb_version": "1.6.1", "is_up_to_date": false}'); SELECT test_check_version_response('{"current_timescaledb_version": "10.1", "is_up_to_date": false}'); SELECT test_check_version_response('{"current_timescaledb_version": "10.1.1-rc1", "is_up_to_date": false}'); ---------------------------------------------------------------- -- Test well-formed response but invalid versions SELECT test_check_version_response('{"current_timescaledb_version": "1.0.0-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "is_up_to_date": false}'); SELECT test_check_version_response('{"current_timescaledb_version": "10.1.1+rc1", "is_up_to_date": false}'); SELECT test_check_version_response('{"current_timescaledb_version": "@10.1.1", "is_up_to_date": false}'); SELECT test_check_version_response('{"current_timescaledb_version": "10.1.1@", "is_up_to_date": false}'); ---------------------------------------------------------------- -- Test malformed responses \set ON_ERROR_STOP 0 -- Empty response SELECT test_check_version_response('{}'); -- Field "is_up_to_date" missing SELECT test_check_version_response('{"current_timescaledb_version": "1.6.1"}'); -- Field "current_timescaledb_version" is missing SELECT test_check_version_response('{"is_up_to_date": false}'); \set ON_ERROR_STOP 1 SET timescaledb.telemetry_level=basic; -- Connect to a bogus host and path to test error handling in telemetry_main() SELECT _timescaledb_internal.test_telemetry_main_conn('noservice.timescale.com', 'path'); -- Test telemetry report contents SET timescaledb.telemetry_level=basic; SELECT * FROM jsonb_object_keys(get_telemetry_report()) AS key WHERE key != 'os_name_pretty'; CREATE MATERIALIZED VIEW telemetry_report AS SELECT t FROM get_telemetry_report() t; -- check telemetry picks up flagged content from metadata SELECT t -> 'db_metadata' FROM telemetry_report; -- check timescaledb_telemetry.cloud SELECT t -> 'instance_metadata' FROM telemetry_report; -- Check access methods SELECT t->'access_methods' ? 'btree', t->'access_methods' ? 'heap', CAST(t->'access_methods'->'btree'->'pages' AS int) > 0, CAST(t->'access_methods'->'btree'->'instances' AS int) > 0 FROM telemetry_report; WITH t AS ( SELECT t -> 'relations' AS rels FROM telemetry_report ) SELECT rels -> 'hypertables' -> 'num_relations' AS num_hypertables, rels -> 'continuous_aggregates' -> 'num_relations' AS num_caggs FROM t; CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); REFRESH MATERIALIZED VIEW telemetry_report; WITH t AS ( SELECT t -> 'relations' AS rels FROM telemetry_report ) SELECT rels -> 'hypertables' -> 'num_relations' AS num_hypertables, rels -> 'continuous_aggregates' -> 'num_relations' AS num_caggs FROM t; set datestyle to iso; -- check that installed_time formatting in telemetry report does not depend on local date settings SELECT t -> 'installed_time' AS installed_time FROM telemetry_report \gset set datestyle to sql; SELECT t-> 'installed_time' AS installed_time2 FROM telemetry_report \gset SELECT :'installed_time' = :'installed_time2' AS equal, length(:'installed_time'), length(:'installed_time2'); RESET datestyle; -- test function call telemetry CREATE FUNCTION not_visible_in_telemetry() RETURNS INT AS $$ SELECT 1; $$ LANGUAGE SQL; -- drain old function call telemetry so we have fixed out put; SELECT FROM get_telemetry_report(); -- call some arbirary functions SELECT 1 + 1, not_visible_in_telemetry(), 1 + 1, abs(-1), not_visible_in_telemetry() WHERE 1 + 1 = 2; -- call some aggregates SELECT min(not_visible_in_telemetry()), sum(not_visible_in_telemetry()); -- check that we can record from a prepared statement PREPARE record_from_prepared AS SELECT 1 - 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; EXECUTE record_from_prepared; DEALLOCATE record_from_prepared; SELECT get_telemetry_report()->'functions_used'; -- check the report again to see if resetting works SELECT get_telemetry_report()->'functions_used'; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.metadata; SET timescaledb.telemetry_level=off; -- returns false which means telemetry got canceled SELECT * FROM _timescaledb_internal.test_privacy(); RESET timescaledb.telemetry_level; -- returns false which means telemetry got canceled SELECT * FROM _timescaledb_internal.test_privacy(); -- To make sure nothing was sent, we check the UUID table to make sure no exported UUID row was created SELECT key from _timescaledb_catalog.metadata; \set ON_ERROR_STOP 0 -- test that the telemetry gathering code doesn't break nonexistent statements EXECUTE noexistent_statement; \c :TEST_DBNAME :ROLE_SUPERUSER -- Insert some data into the telemetry event table INSERT INTO _timescaledb_catalog.telemetry_event(tag, body) VALUES ('ummagumma', '{"title": "Careful with that Axe Eugene!"}'), ('kaboom', '{"title": "Where is that kaboom?"}'); -- Check that it is present in the telemetry report SELECT * FROM jsonb_to_recordset(get_telemetry_report()->'db_telemetry_events') AS x(tag name, body text); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/test_tss_callbacks.sql��������������������������������������������������0000664�0000000�0000000�00000002457�15100345067�0022231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.setup_tss_hook_v0() RETURNS VOID AS :MODULE_PATHNAME, 'ts_setup_tss_hook_v0' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.setup_tss_hook_v1() RETURNS VOID AS :MODULE_PATHNAME, 'ts_setup_tss_hook_v1' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.teardown_tss_hook_v1() RETURNS VOID AS :MODULE_PATHNAME, 'ts_teardown_tss_hook_v1' LANGUAGE C VOLATILE; SELECT test.setup_tss_hook_v1(); CREATE TABLE copy_test ( "time" timestamptz NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('copy_test', 'time'); -- We should se a mock message COPY copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. SELECT test.teardown_tss_hook_v1(); -- Without the hook registered we cannot see the mock message COPY copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. -- Test for mismatch version SELECT test.setup_tss_hook_v0(); -- Warning because the mismatch versions COPY copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/test_utils.sql����������������������������������������������������������0000664�0000000�0000000�00000005065�15100345067�0020557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.condition() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_condition' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test.int64_eq() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_int64_eq' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test.ptr_eq() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_ptr_eq' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; CREATE OR REPLACE FUNCTION test.double_eq() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_utils_double_eq' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; SET ROLE :ROLE_DEFAULT_PERM_USER; -- We're testing that the test utils work and generate errors on -- failing conditions \set ON_ERROR_STOP 0 SELECT test.condition(); SELECT test.int64_eq(); SELECT test.ptr_eq(); SELECT test.double_eq(); \set ON_ERROR_STOP 1 -- Test debug points -- \set ECHO all \c :TEST_DBNAME :ROLE_SUPERUSER -- debug point already enabled SELECT debug_waitpoint_enable('test_debug_point'); \set ON_ERROR_STOP 0 SELECT debug_waitpoint_enable('test_debug_point'); \set ON_ERROR_STOP 1 SELECT debug_waitpoint_release('test_debug_point'); -- debug point not enabled \set ON_ERROR_STOP 0 SELECT debug_waitpoint_release('test_debug_point'); \set ON_ERROR_STOP 1 -- error injections -- CREATE OR REPLACE FUNCTION test_error_injection(TEXT) RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_error_injection' LANGUAGE C VOLATILE STRICT; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT test_error_injection('test_error'); SELECT debug_waitpoint_enable('test_error'); \set ON_ERROR_STOP 0 SELECT test_error_injection('test_error'); \set ON_ERROR_STOP 1 SELECT debug_waitpoint_release('test_error'); SELECT test_error_injection('test_error'); -- Test Scanner RESET ROLE; CREATE OR REPLACE FUNCTION test.scanner() RETURNS VOID AS :MODULE_PATHNAME, 'ts_test_scanner' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; SET ROLE :ROLE_DEFAULT_PERM_USER; -- Create two chunks to scan in the test CREATE TABLE hyper (time timestamptz, temp float); SELECT create_hypertable('hyper', 'time'); INSERT INTO hyper VALUES ('2021-01-01', 1.0), ('2022-01-01', 2.0); SELECT test.scanner(); -- Test errdata_to_jsonb RESET ROLE; CREATE OR REPLACE FUNCTION test.errdata_to_jsonb() RETURNS JSONB AS :MODULE_PATHNAME, 'ts_test_errdata_to_jsonb' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; SELECT test.errdata_to_jsonb(); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/timestamp.sql.in��������������������������������������������������������0000664�0000000�0000000�00000121405�15100345067�0020765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Utility function for grouping/slotting time with a given interval. CREATE OR REPLACE FUNCTION date_group( field timestamp, group_interval interval ) RETURNS timestamp LANGUAGE SQL STABLE AS $BODY$ SELECT to_timestamp((EXTRACT(EPOCH from $1)::int / EXTRACT(EPOCH from group_interval)::int) * EXTRACT(EPOCH from group_interval)::int)::timestamp; $BODY$; CREATE TABLE PUBLIC."testNs" ( "timeCustom" TIMESTAMP NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON PUBLIC."testNs" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA "testNs" AUTHORIZATION :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM create_hypertable('"public"."testNs"', 'timeCustom', 'device_id', 2, associated_schema_name=>'testNs' ); \c :TEST_DBNAME INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 1), ('2009-11-12T01:00:00+00:00', 'dev1', 1.5, 2), ('2009-11-10T23:00:02+00:00', 'dev1', 2.5, 3); INSERT INTO PUBLIC."testNs"("timeCustom", device_id, series_0, series_1) VALUES ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 1), ('2009-11-10T23:00:00+00:00', 'dev2', 1.5, 2); SELECT * FROM PUBLIC."testNs"; SET client_min_messages = WARNING; \echo 'The next 2 queries will differ in output between UTC and EST since the mod is on the 100th hour UTC' SET timezone = 'UTC'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; SET timezone = 'EST'; SELECT date_group("timeCustom", '100 days') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; \echo 'The rest of the queries will be the same in output between UTC and EST' SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC; SET timezone = 'UTC'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; SET timezone = 'EST'; SELECT * FROM PUBLIC."testNs" WHERE "timeCustom" >= TIMESTAMP '2009-11-10T23:00:00' AND "timeCustom" < TIMESTAMP '2009-11-12T01:00:00' ORDER BY "timeCustom" DESC, device_id, series_1; SET timezone = 'UTC'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; SET timezone = 'EST'; SELECT date_group("timeCustom", '1 day') AS time, sum(series_0) FROM PUBLIC."testNs" GROUP BY time ORDER BY time ASC LIMIT 2; ------------------------------------ -- Test time conversion functions -- ------------------------------------ \set ON_ERROR_STOP 0 SET timezone = 'UTC'; -- Conversion to timestamp using Postgres built-in function taking -- double. Gives inaccurate result on Postgres <= 9.6.2. Accurate on -- Postgres >= 9.6.3. SELECT to_timestamp(1486480176.236538); -- extension-specific version taking microsecond UNIX timestamp SELECT _timescaledb_functions.to_timestamp(1486480176236538); -- Should be the inverse of the statement above. SELECT _timescaledb_functions.to_unix_microseconds('2017-02-07 15:09:36.236538+00'); -- For timestamps, BIGINT MAX represents +Infinity and BIGINT MIN -- -Infinity. We keep this notion for UNIX epoch time: SELECT _timescaledb_functions.to_unix_microseconds('+infinity'); SELECT _timescaledb_functions.to_timestamp(9223372036854775807); SELECT _timescaledb_functions.to_unix_microseconds('-infinity'); SELECT _timescaledb_functions.to_timestamp(-9223372036854775808); -- In UNIX microseconds, the largest bigint value below infinity -- (BIGINT MAX) is smaller than internal date upper bound and should -- therefore be OK. Further, converting to the internal postgres epoch -- cannot overflow a 64-bit INTEGER since the postgres epoch is at a -- later date compared to the UNIX epoch, and is therefore represented -- by a smaller number SELECT _timescaledb_functions.to_timestamp(9223372036854775806); -- Julian day zero is -210866803200000000 microseconds from UNIX epoch SELECT _timescaledb_functions.to_timestamp(-210866803200000000); \set VERBOSITY default -- Going beyond Julian day zero should give out-of-range error SELECT _timescaledb_functions.to_timestamp(-210866803200000001); -- Lower bound on date (should return the Julian day zero UNIX timestamp above) SELECT _timescaledb_functions.to_unix_microseconds('4714-11-24 00:00:00+00 BC'); -- Going beyond lower bound on date should return out-of-range SELECT _timescaledb_functions.to_unix_microseconds('4714-11-23 23:59:59.999999+00 BC'); -- The upper bound for Postgres TIMESTAMPTZ SELECT timestamp '294276-12-31 23:59:59.999999+00'; -- Going beyond the upper bound, should fail SELECT timestamp '294276-12-31 23:59:59.999999+00' + interval '1 us'; -- Cannot represent the upper bound timestamp with a UNIX microsecond timestamp -- since the Postgres epoch is at a later date than the UNIX epoch. SELECT _timescaledb_functions.to_unix_microseconds('294276-12-31 23:59:59.999999+00'); -- Subtracting the difference between the two epochs (10957 days) should bring -- us within range. SELECT timestamp '294276-12-31 23:59:59.999999+00' - interval '10957 days'; SELECT _timescaledb_functions.to_unix_microseconds('294247-01-01 23:59:59.999999'); -- Adding one microsecond should take us out-of-range again SELECT timestamp '294247-01-01 23:59:59.999999' + interval '1 us'; SELECT _timescaledb_functions.to_unix_microseconds(timestamp '294247-01-01 23:59:59.999999' + interval '1 us'); --no time_bucketing of dates not by integer # of days SELECT time_bucket('1 hour', DATE '2012-01-01'); SELECT time_bucket('25 hour', DATE '2012-01-01'); \set ON_ERROR_STOP 1 SELECT time_bucket(INTERVAL '1 day', TIMESTAMP '2011-01-02 01:01:01'); SELECT time, time_bucket(INTERVAL '2 day ', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-01 01:01:01', TIMESTAMP '2011-01-02 01:01:01', TIMESTAMP '2011-01-03 01:01:01', TIMESTAMP '2011-01-04 01:01:01' ]) AS time; SELECT int_def, time_bucket(int_def,TIMESTAMP '2011-01-02 01:01:01.111') FROM unnest(ARRAY[ INTERVAL '1 millisecond', INTERVAL '1 second', INTERVAL '1 minute', INTERVAL '1 hour', INTERVAL '1 day', INTERVAL '2 millisecond', INTERVAL '2 second', INTERVAL '2 minute', INTERVAL '2 hour', INTERVAL '2 day' ]) AS int_def; \set ON_ERROR_STOP 0 SELECT time_bucket(INTERVAL '1 year 1d',TIMESTAMP '2011-01-02 01:01:01.111'); SELECT time_bucket(INTERVAL '1 month 1 minute',TIMESTAMP '2011-01-02 01:01:01.111'); \set ON_ERROR_STOP 1 SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '1970-01-01 00:59:59.999999', TIMESTAMP '1970-01-01 01:01:00', TIMESTAMP '1970-01-01 01:04:59.999999', TIMESTAMP '1970-01-01 01:05:00' ]) AS time; SELECT time, time_bucket(INTERVAL '5 minute', time) FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:04:59.999999', TIMESTAMP '2011-01-02 01:05:00', TIMESTAMP '2011-01-02 01:09:59.999999', TIMESTAMP '2011-01-02 01:10:00' ]) AS time; --offset with interval SELECT time, time_bucket(INTERVAL '5 minute', time , INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2 minutes') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:02:59.999999', TIMESTAMP '2011-01-02 01:03:00', TIMESTAMP '2011-01-02 01:07:59.999999', TIMESTAMP '2011-01-02 01:08:00' ]) AS time; --offset with infinity -- timestamp SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp '-Infinity', timestamp 'Infinity' ]) AS time; -- timestamptz SELECT time, time_bucket(INTERVAL '1 week', time, INTERVAL '1 day') FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; -- Date SELECT date, time_bucket(INTERVAL '1 week', date, INTERVAL '1 day') FROM unnest(ARRAY[ date '-Infinity', date 'Infinity' ]) AS date; --example to align with an origin SELECT time, time_bucket(INTERVAL '5 minute', time - (TIMESTAMP '2011-01-02 00:02:00' - TIMESTAMP 'epoch')) + (TIMESTAMP '2011-01-02 00:02:00'-TIMESTAMP 'epoch') FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:01:59.999999', TIMESTAMP '2011-01-02 01:02:00', TIMESTAMP '2011-01-02 01:06:59.999999', TIMESTAMP '2011-01-02 01:07:00' ]) AS time; --rounding version SELECT time, time_bucket(INTERVAL '5 minute', time , - INTERVAL '2.5 minutes') + INTERVAL '2 minutes 30 seconds' FROM unnest(ARRAY[ TIMESTAMP '2011-01-02 01:05:01', TIMESTAMP '2011-01-02 01:07:29', TIMESTAMP '2011-01-02 01:02:30', TIMESTAMP '2011-01-02 01:07:30', TIMESTAMP '2011-01-02 01:02:29' ]) AS time; --time_bucket with timezone should mimick date_trunc SET timezone TO 'UTC'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; --what happens with a local tz SET timezone TO 'America/New_York'; SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01+02' ]) AS time; --Note the timestamp tz input is aligned with UTC day /not/ local day. different than date_trunc. SELECT time, time_bucket(INTERVAL '1 day', time), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; --can force local bucketing with simple cast. SELECT time, time_bucket(INTERVAL '1 day', time::timestamp), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; --can also use interval to correct SELECT time, time_bucket(INTERVAL '1 day', time, -INTERVAL '19 hours'), date_trunc('day', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2011-01-02 01:01:01', TIMESTAMP WITH TIME ZONE '2011-01-03 01:01:01+01', TIMESTAMP WITH TIME ZONE '2011-01-04 01:01:01+02' ]) AS time; --dst: same local hour bucketed as two different hours. SELECT time, time_bucket(INTERVAL '1 hour', time), date_trunc('hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07' ]) AS time; --local alignment changes when bucketing by UTC across dst boundary SELECT time, time_bucket(INTERVAL '2 hour', time) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; --local alignment is preserved when bucketing by local time across DST boundary. SELECT time, time_bucket(INTERVAL '2 hour', time::timestamp) FROM unnest(ARRAY[ TIMESTAMP WITH TIME ZONE '2017-11-05 10:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 12:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 13:05:00+07', TIMESTAMP WITH TIME ZONE '2017-11-05 15:05:00+07' ]) AS time; SELECT time, time_bucket(10::smallint, time) AS time_bucket_smallint, time_bucket(10::int, time) AS time_bucket_int, time_bucket(10::bigint, time) AS time_bucket_bigint FROM unnest(ARRAY[ '-11', '-10', '-9', '-1', '0', '1', '99', '100', '109', '110' ]::smallint[]) AS time; SELECT time, time_bucket(10::smallint, time, 2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, 2::int) AS time_bucket_int, time_bucket(10::bigint, time, 2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-9', '-8', '-7', '1', '2', '3', '101', '102', '111', '112' ]::smallint[]) AS time; SELECT time, time_bucket(10::smallint, time, -2::smallint) AS time_bucket_smallint, time_bucket(10::int, time, -2::int) AS time_bucket_int, time_bucket(10::bigint, time, -2::bigint) AS time_bucket_bigint FROM unnest(ARRAY[ '-13', '-12', '-11', '-3', '-2', '-1', '97', '98', '107', '108' ]::smallint[]) AS time; \set ON_ERROR_STOP 0 SELECT time_bucket(10::smallint, '-32768'::smallint); SELECT time_bucket(10::smallint, '-32761'::smallint); select time_bucket(10::smallint, '-32768'::smallint, 1000::smallint); select time_bucket(10::smallint, '-32768'::smallint, '32767'::smallint); select time_bucket(10::smallint, '32767'::smallint, '-32768'::smallint); \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::smallint, time) FROM unnest(ARRAY[ '-32760', '-32759', '32767' ]::smallint[]) AS time; \set ON_ERROR_STOP 0 SELECT time_bucket(10::int, '-2147483648'::int); SELECT time_bucket(10::int, '-2147483641'::int); SELECT time_bucket(1000::int, '-2147483000'::int, 1::int); SELECT time_bucket(1000::int, '-2147483648'::int, '2147483647'::int); SELECT time_bucket(1000::int, '2147483647'::int, '-2147483648'::int); \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::int, time) FROM unnest(ARRAY[ '-2147483640', '-2147483639', '2147483647' ]::int[]) AS time; \set ON_ERROR_STOP 0 SELECT time_bucket(10::bigint, '-9223372036854775808'::bigint); SELECT time_bucket(10::bigint, '-9223372036854775801'::bigint); SELECT time_bucket(1000::bigint, '-9223372036854775000'::bigint, 1::bigint); SELECT time_bucket(1000::bigint, '-9223372036854775808'::bigint, '9223372036854775807'::bigint); SELECT time_bucket(1000::bigint, '9223372036854775807'::bigint, '-9223372036854775808'::bigint); \set ON_ERROR_STOP 1 SELECT time, time_bucket(10::bigint, time) FROM unnest(ARRAY[ '-9223372036854775800', '-9223372036854775799', '9223372036854775807' ]::bigint[]) AS time; SELECT time, time_bucket(INTERVAL '1 day', time::date) FROM unnest(ARRAY[ date '2017-11-05', date '2017-11-06' ]) AS time; SELECT time, time_bucket(INTERVAL '4 day', time::date) FROM unnest(ARRAY[ date '2017-11-04', date '2017-11-05', date '2017-11-08', date '2017-11-09' ]) AS time; SELECT time, time_bucket(INTERVAL '4 day', time::date, INTERVAL '2 day') FROM unnest(ARRAY[ date '2017-11-06', date '2017-11-07', date '2017-11-10', date '2017-11-11' ]) AS time; -- 2019-09-24 is a Monday, and we want to ensure that time_bucket returns the week starting with a Monday as date_trunc does, -- Rather than a Saturday which is the date of the PostgreSQL epoch SELECT time, time_bucket(INTERVAL '1 week', time::date) FROM unnest(ARRAY[ date '2018-09-16', date '2018-09-17', date '2018-09-23', date '2018-09-24' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '2018-09-16', timestamp without time zone '2018-09-17', timestamp without time zone '2018-09-23', timestamp without time zone '2018-09-24' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '2018-09-16', timestamp with time zone '2018-09-17', timestamp with time zone '2018-09-23', timestamp with time zone '2018-09-24' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp with time zone '-Infinity', timestamp with time zone 'Infinity' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '-Infinity', timestamp without time zone 'Infinity' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '4714-11-24 01:01:01.0 BC', timestamp without time zone '294276-12-31 23:59:59.9999' ]) AS time; --1000 years later weeks still align. SELECT time, time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time) FROM unnest(ARRAY[ timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-20', timestamp without time zone '3018-09-21', timestamp without time zone '3018-09-22' ]) AS time; --weeks align for timestamptz as well if cast to local time, (but not if done at UTC). SELECT time, date_trunc('week', time) = time_bucket(INTERVAL '1 week', time), date_trunc('week', time) = time_bucket(INTERVAL '1 week', time::timestamp) FROM unnest(ARRAY[ timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-20', timestamp with time zone '3018-09-21', timestamp with time zone '3018-09-22' ]) AS time; --check functions with origin --note that the default origin is at 0 UTC, using origin parameter it is easy to provide a EDT origin point \x SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time::timestamp) no_epoch_local, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-03 00:00:00+0') always_true, time_bucket(INTERVAL '1 week', time, timestamptz '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamptz 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamptz '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp with time zone '2000-01-01 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-01 00:00:00+0', timestamp with time zone '2000-01-03 00:00:00+0'- interval '1 second', timestamp with time zone '2000-01-03 00:00:00+0', timestamp with time zone '2000-01-01', timestamp with time zone '2000-01-02', timestamp with time zone '2000-01-03', timestamp with time zone '3018-09-12', timestamp with time zone '3018-09-13', timestamp with time zone '3018-09-14', timestamp with time zone '3018-09-15' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, timestamp '2000-01-03 00:00:00') always_true, time_bucket(INTERVAL '1 week', time, timestamp '2000-01-01 00:00:00+0') pg_epoch, time_bucket(INTERVAL '1 week', time, timestamp 'epoch') unix_epoch, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, timestamp '3018-09-14') custom_2 FROM unnest(ARRAY[ timestamp without time zone '2000-01-01 00:00:00'- interval '1 second', timestamp without time zone '2000-01-01 00:00:00', timestamp without time zone '2000-01-03 00:00:00'- interval '1 second', timestamp without time zone '2000-01-03 00:00:00', timestamp without time zone '2000-01-01', timestamp without time zone '2000-01-02', timestamp without time zone '2000-01-03', timestamp without time zone '3018-09-12', timestamp without time zone '3018-09-13', timestamp without time zone '3018-09-14', timestamp without time zone '3018-09-15' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time) no_epoch, time_bucket(INTERVAL '1 week', time) = time_bucket(INTERVAL '1 week', time, date '2000-01-03') always_true, time_bucket(INTERVAL '1 week', time, date '2000-01-01') pg_epoch, time_bucket(INTERVAL '1 week', time, (timestamp 'epoch')::date) unix_epoch, time_bucket(INTERVAL '1 week', time, date '3018-09-13') custom_1, time_bucket(INTERVAL '1 week', time, date '3018-09-14') custom_2 FROM unnest(ARRAY[ date '1999-12-31', date '2000-01-01', date '2000-01-02', date '2000-01-03', date '3018-09-12', date '3018-09-13', date '3018-09-14', date '3018-09-15' ]) AS time; \x --really old origin works if date around that time SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC', timestamp without time zone '4710-11-25 01:01:01.0 BC', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; SELECT time, time_bucket(INTERVAL '1 week', time, timestamp without time zone '294270-12-30 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '294270-12-29 23:59:59.9999', timestamp without time zone '294270-12-30 23:59:59.9999', timestamp without time zone '294270-12-31 23:59:59.9999', timestamp without time zone '2001-01-01', timestamp without time zone '3001-01-01' ]) AS time; \set ON_ERROR_STOP 0 --really old origin + very new data + long period errors SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp without time zone '4710-11-24 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp without time zone '294270-12-31 23:59:59.9999' ]) AS time; SELECT time, time_bucket(INTERVAL '100000 day', time, timestamp with time zone '4710-11-25 01:01:01.0 BC') FROM unnest(ARRAY[ timestamp with time zone '294270-12-30 23:59:59.9999' ]) AS time; --really high origin + old data + long period errors out SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp without time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp without time zone '4710-11-24 01:01:01.0 BC' ]) AS time; SELECT time, time_bucket(INTERVAL '10000000 day', time, timestamp with time zone '294270-12-31 23:59:59.9999') FROM unnest(ARRAY[ timestamp with time zone '4710-11-24 01:01:01.0 BC' ]) AS time; \set ON_ERROR_STOP 1 ------------------------------------------- --- Test time_bucket with month periods --- ------------------------------------------- SET datestyle TO ISO; SELECT time::date, time_bucket('1 month', time::date) AS "1m", time_bucket('2 month', time::date) AS "2m", time_bucket('3 month', time::date) AS "3m", time_bucket('1 month', time::date, '2000-02-01'::date) AS "1m origin", time_bucket('2 month', time::date, '2000-02-01'::date) AS "2m origin", time_bucket('3 month', time::date, '2000-02-01'::date) AS "3m origin" FROM generate_series('1990-01-03'::date,'1990-06-03'::date,'1month'::interval) time; SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamp) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamp) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamp) AS "3m origin" FROM generate_series('1990-01-03'::timestamp,'1990-06-03'::timestamp,'1month'::interval) time; SELECT time, time_bucket('1 month', time) AS "1m", time_bucket('2 month', time) AS "2m", time_bucket('3 month', time) AS "3m", time_bucket('1 month', time, '2000-02-01'::timestamptz) AS "1m origin", time_bucket('2 month', time, '2000-02-01'::timestamptz) AS "2m origin", time_bucket('3 month', time, '2000-02-01'::timestamptz) AS "3m origin" FROM generate_series('1990-01-03'::timestamptz,'1990-06-03'::timestamptz,'1month'::interval) time; --------------------------------------- --- Test time_bucket with timezones --- --------------------------------------- -- test NULL args SELECT time_bucket(NULL::interval,now(),'Europe/Berlin'), time_bucket('1day',NULL::timestamptz,'Europe/Berlin'), time_bucket('1day',now(),NULL::text), time_bucket('1day','2020-02-03','Europe/Berlin',NULL), time_bucket('1day','2020-02-03','Europe/Berlin','2020-04-01',NULL), time_bucket('1day','2020-02-03','Europe/Berlin',NULL,NULL), time_bucket('1day','2020-02-03','Europe/Berlin',"offset":=NULL::interval), time_bucket('1day','2020-02-03','Europe/Berlin',origin:=NULL::timestamptz); SET datestyle TO ISO; SELECT time_bucket('1day', ts) AS "UTC", time_bucket('1day', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1day', ts, 'Europe/London') AS "London", time_bucket('1day', ts, 'America/New_York') AS "New York", time_bucket('1day', ts, 'PST') AS "PST", time_bucket('1day', ts, current_setting('timezone')) AS "current" FROM generate_series('1999-12-31 17:00'::timestamptz,'2000-01-02 3:00'::timestamptz, '1hour'::interval) ts; SELECT time_bucket('1month', ts) AS "UTC", time_bucket('1month', ts, 'Europe/Berlin') AS "Berlin", time_bucket('1month', ts, 'America/New_York') AS "New York", time_bucket('1month', ts, current_setting('timezone')) AS "current", time_bucket('2month', ts, current_setting('timezone')) AS "2m", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp) AS "2m origin", time_bucket('2month', ts, current_setting('timezone'), "offset":='14 day'::interval) AS "2m offset", time_bucket('2month', ts, current_setting('timezone'), '2000-02-01'::timestamp, '7 day'::interval) AS "2m offset + origin" FROM generate_series('1999-12-01'::timestamptz,'2000-09-01'::timestamptz, '9 day'::interval) ts; RESET datestyle; ------------------------------------------------------------ --- Test timescaledb_experimental.time_bucket_ng function -- ------------------------------------------------------------ -- not supported functionality \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 hour', '2001-02-03' :: date) AS result; SELECT timescaledb_experimental.time_bucket_ng('0 days', '2001-02-03' :: date) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 month', '2001-02-03' :: date, origin => '2000-01-02') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 month', '2000-01-02' :: date, origin => '2001-01-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 day', '2000-01-02' :: date, origin => '2001-01-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 month 3 hours', '2021-11-22' :: timestamp) AS result; -- timestamp is less than the default 'origin' value SELECT timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, timezone => 'MSK'); -- 'origin' in Europe/Moscow timezone is not the first day of the month at given time zone (UTC in this case) select timescaledb_experimental.time_bucket_ng('1 month', '2021-07-12 12:34:56 Europe/Moscow' :: timestamptz, origin => '2021-06-01 00:00:00 Europe/Moscow' :: timestamptz, timezone => 'UTC'); \set ON_ERROR_STOP 1 -- wrappers SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamp, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-11-22' :: timestamptz, origin => '2021-06-01') AS result; -- null argument SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, timezone => 'Europe/Moscow') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: date, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamp, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', null :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; -- null interval SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date) AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz) AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, 'Europe/Moscow') AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12' :: date, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamp, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng(null, '2021-07-12 12:34:56' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; -- null origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => null) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => null) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => null, timezone => 'Europe/Moscow') AS result; -- infinity argument SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz) AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, timezone => 'Europe/Moscow') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: date, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamp, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', 'infinity' :: timestamptz, origin => '2021-06-01', timezone => 'Europe/Moscow') AS result; -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng('12 hours', 'infinity' :: timestamp, origin => '2021-06-01') AS result; -- infinite origin SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12' :: date, origin => 'infinity') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity') AS result; SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, origin => 'infinity', timezone => 'Europe/Moscow') AS result; -- test for specific code path: hours/minutes/seconds interval and timestamp argument SELECT timescaledb_experimental.time_bucket_ng('12 hours', '2021-07-12 12:34:56' :: timestamp, origin => 'infinity') AS result; -- test for invalid timezone argument SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => null) AS result; \set ON_ERROR_STOP 0 SELECT timescaledb_experimental.time_bucket_ng('1 year', '2021-07-12 12:34:56' :: timestamptz, timezone => 'Europe/Ololondon') AS result; \set ON_ERROR_STOP 1 -- Make sure time_bucket_ng() supports seconds, minutes, and hours. -- We happen to know that the internal implementation is the same -- as for time_bucket(), thus there is no reason to execute all the tests -- we already have for time_bucket(). These two functions will most likely -- be merged eventually anyway. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp) AS result; SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp) AS result; -- Same as above, but with provided 'origin' argument. SELECT timescaledb_experimental.time_bucket_ng('30 seconds', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; SELECT timescaledb_experimental.time_bucket_ng('15 minutes', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; SELECT timescaledb_experimental.time_bucket_ng('6 hours', '2021-07-12 12:34:56' :: timestamp, origin => '2021-07-12 12:10:00') AS result; -- N days / weeks buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; -- N days / weeks buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 day', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d1, to_char(timescaledb_experimental.time_bucket_ng('2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d2, to_char(timescaledb_experimental.time_bucket_ng('3 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS d3, to_char(timescaledb_experimental.time_bucket_ng('1 week', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1, to_char(timescaledb_experimental.time_bucket_ng('1 week 2 days', d, origin => '2020-01-01'), 'YYYY-MM-DD') AS w1d2 FROM generate_series('2020-01-01' :: date, '2020-01-12', '1 day') AS ts, unnest(array[ts :: date]) AS d; -- N month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; -- N month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m1, to_char(timescaledb_experimental.time_bucket_ng('2 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m2, to_char(timescaledb_experimental.time_bucket_ng('3 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m3, to_char(timescaledb_experimental.time_bucket_ng('4 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m4, to_char(timescaledb_experimental.time_bucket_ng('5 month', d, origin => '2019-05-01'), 'YYYY-MM-DD') AS m5 FROM generate_series('2020-01-01' :: date, '2020-12-01', '1 month') AS ts, unnest(array[ts :: date]) AS d; -- N years / N years, M month buckets SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; -- N years / N years, M month buckets with given 'origin' SELECT to_char(d, 'YYYY-MM-DD') AS d, to_char(timescaledb_experimental.time_bucket_ng('1 year', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1, to_char(timescaledb_experimental.time_bucket_ng('1 year 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y1m6, to_char(timescaledb_experimental.time_bucket_ng('2 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2, to_char(timescaledb_experimental.time_bucket_ng('2 years 6 month', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y2m6, to_char(timescaledb_experimental.time_bucket_ng('3 years', d, origin => '2000-06-01'), 'YYYY-MM-DD') AS y3 FROM generate_series('2015-01-01' :: date, '2020-12-01', '6 month') AS ts, unnest(array[ts :: date]) AS d; -- Test timezones support with different bucket sizes BEGIN; -- Timestamptz type is displayed in the session timezone. -- To get consistent results during the test we temporary set the session -- timezone to the known one. SET TIME ZONE '+00'; -- Moscow is UTC+3 in the year 2021. Let's say you are dealing with '1 day' bucket. -- In order to calculate the beginning of the bucket you have to take LOCAL -- Moscow time and throw away the time. You will get the midnight. The new day -- starts 3 hours EARLIER in Moscow than in UTC+0 time zone, thus resulting -- timestamp will be 3 hours LESS than for UTC+0. SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow', 'UTC']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; -- Same as above, but with 'origin' SELECT bs, tz, to_char(ts_out, 'YYYY-MM-DD HH24:MI:SS TZ') as res FROM unnest(array['Europe/Moscow']) as tz, unnest(array['12 hours', '1 day', '1 month', '4 months', '1 year']) as bs, unnest(array['2021-07-12 12:34:56 Europe/Moscow' :: timestamptz]) as ts_in, unnest(array['2021-06-01 00:00:00 Europe/Moscow' :: timestamptz]) as origin_in, unnest(array[timescaledb_experimental.time_bucket_ng(bs :: interval, ts_in, origin => origin_in, timezone => tz)]) as ts_out ORDER BY tz, bs :: interval; -- Overwritten origin allows to work with dates earlier than the default origin SELECT to_char(timescaledb_experimental.time_bucket_ng('1 day', '1999-01-01 12:34:56 MSK' :: timestamptz, origin => '1900-01-01 00:00:00 MSK', timezone => 'MSK'), 'YYYY-MM-DD HH24:MI:SS TZ'); -- Restore previously used time zone. ROLLBACK; ------------------------------------- --- Test time input functions -- ------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.interval_to_internal(coltype REGTYPE, value ANYELEMENT = NULL::BIGINT) RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_dimension_interval_to_internal_test' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT test.interval_to_internal('TIMESTAMP'::regtype, INTERVAL '1 day'); SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400000000); ---should give warning SELECT test.interval_to_internal('TIMESTAMP'::regtype, 86400); SELECT test.interval_to_internal('TIMESTAMP'::regtype); SELECT test.interval_to_internal('BIGINT'::regtype, 2147483649::bigint); -- Default interval for integer is supported as part of -- hypertable generalization SELECT test.interval_to_internal('INT'::regtype); SELECT test.interval_to_internal('SMALLINT'::regtype); SELECT test.interval_to_internal('BIGINT'::regtype); SELECT test.interval_to_internal('TIMESTAMPTZ'::regtype); SELECT test.interval_to_internal('TIMESTAMP'::regtype); SELECT test.interval_to_internal('DATE'::regtype); \set VERBOSITY terse \set ON_ERROR_STOP 0 SELECT test.interval_to_internal('INT'::regtype, 2147483649::bigint); SELECT test.interval_to_internal('SMALLINT'::regtype, 32768::bigint); SELECT test.interval_to_internal('TEXT'::regtype, 32768::bigint); SELECT test.interval_to_internal('INT'::regtype, INTERVAL '1 day'); \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/triggers.sql������������������������������������������������������������0000664�0000000�0000000�00000026714�15100345067�0020212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE hyper ( time BIGINT NOT NULL, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 ); CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ DECLARE cnt INTEGER; BEGIN SELECT count(*) INTO cnt FROM hyper; RAISE WARNING 'FIRING trigger when: % level: % op: % cnt: % trigger_name %', tg_when, tg_level, tg_op, cnt, tg_name; IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- row triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert BEFORE INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update BEFORE UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete BEFORE delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all BEFORE INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- row triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_after AFTER INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_insert_after_when_dev1 AFTER INSERT ON hyper FOR EACH ROW WHEN (NEW.device_id = 'dev1') EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_after AFTER UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_after AFTER delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all_after AFTER INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- statement triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert_s_before BEFORE INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_before BEFORE UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_before BEFORE DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); -- statement triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_s_after AFTER INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_after AFTER UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_after AFTER DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); -- CONSTRAINT TRIGGER CREATE CONSTRAINT TRIGGER _0_test_trigger_constraint_insert AFTER INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE CONSTRAINT TRIGGER _0_test_trigger_constraint_update AFTER UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE CONSTRAINT TRIGGER _0_test_trigger_constraint_delete AFTER DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); --test triggers before create_hypertable INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987600000000000, 'dev1', 1); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 1), (1257987800000000000, 'dev2', 1); UPDATE hyper SET sensor_1 = 2; DELETE FROM hyper; --test drop trigger DROP TRIGGER _0_test_trigger_insert ON hyper; DROP TRIGGER _0_test_trigger_insert_s_before ON hyper; DROP TRIGGER _0_test_trigger_insert_after ON hyper; DROP TRIGGER _0_test_trigger_insert_s_after ON hyper; INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987600000000000, 'dev1', 1); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 1), (1257987800000000000, 'dev2', 1); DROP TRIGGER _0_test_trigger_update ON hyper; DROP TRIGGER _0_test_trigger_update_s_before ON hyper; DROP TRIGGER _0_test_trigger_update_after ON hyper; DROP TRIGGER _0_test_trigger_update_s_after ON hyper; UPDATE hyper SET sensor_1 = 2; DROP TRIGGER _0_test_trigger_delete ON hyper; DROP TRIGGER _0_test_trigger_delete_s_before ON hyper; DROP TRIGGER _0_test_trigger_delete_after ON hyper; DROP TRIGGER _0_test_trigger_delete_s_after ON hyper; DELETE FROM hyper; DROP TRIGGER z_test_trigger_all ON hyper; DROP TRIGGER z_test_trigger_all_after ON hyper; --test create trigger on hypertable -- row triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert BEFORE INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update BEFORE UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete BEFORE delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all BEFORE INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- row triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_after AFTER INSERT ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_after AFTER UPDATE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_after AFTER delete ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER z_test_trigger_all_after AFTER INSERT OR UPDATE OR DELETE ON hyper FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- statement triggers: BEFORE CREATE TRIGGER _0_test_trigger_insert_s_before BEFORE INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_before BEFORE UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_before BEFORE DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); -- statement triggers: AFTER CREATE TRIGGER _0_test_trigger_insert_s_after AFTER INSERT ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_update_s_after AFTER UPDATE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _0_test_trigger_delete_s_after AFTER DELETE ON hyper FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987600000000000, 'dev1', 1); INSERT INTO hyper(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 1), (1257987800000000000, 'dev2', 1); UPDATE hyper SET sensor_1 = 2; DELETE FROM hyper; CREATE TABLE vehicles ( vehicle_id INTEGER PRIMARY KEY, vin_number CHAR(17), last_checkup TIMESTAMP ); CREATE TABLE color ( color_id INTEGER PRIMARY KEY, notes text ); CREATE TABLE location ( time TIMESTAMP NOT NULL, vehicle_id INTEGER REFERENCES vehicles (vehicle_id), color_id INTEGER, --no reference since gonna populate a hypertable latitude FLOAT, longitude FLOAT ); CREATE OR REPLACE FUNCTION create_vehicle_trigger_fn() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN INSERT INTO vehicles VALUES(NEW.vehicle_id, NULL, NULL) ON CONFLICT DO NOTHING; RETURN NEW; END $BODY$; CREATE OR REPLACE FUNCTION create_color_trigger_fn() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN --test subtxns within triggers BEGIN INSERT INTO color VALUES(NEW.color_id, 'n/a'); EXCEPTION WHEN unique_violation THEN -- Nothing to do, just continue END; RETURN NEW; END $BODY$; CREATE TRIGGER create_color_trigger BEFORE INSERT OR UPDATE ON location FOR EACH ROW EXECUTE FUNCTION create_color_trigger_fn(); SELECT create_hypertable('location', 'time'); --make color also a hypertable SELECT create_hypertable('color', 'color_id', chunk_time_interval=>10); -- Test that we can create and use triggers with another user GRANT TRIGGER, INSERT, SELECT, UPDATE ON location TO :ROLE_DEFAULT_PERM_USER_2; GRANT SELECT, INSERT, UPDATE ON color TO :ROLE_DEFAULT_PERM_USER_2; GRANT SELECT, INSERT, UPDATE ON vehicles TO :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2; CREATE TRIGGER create_vehicle_trigger BEFORE INSERT OR UPDATE ON location FOR EACH ROW EXECUTE FUNCTION create_vehicle_trigger_fn(); INSERT INTO location VALUES('2017-01-01 01:02:03', 1, 1, 40.7493226,-73.9771259); INSERT INTO location VALUES('2017-01-01 01:02:04', 1, 20, 24.7493226,-73.9771259); INSERT INTO location VALUES('2017-01-01 01:02:03', 23, 1, 40.7493226,-73.9771269); INSERT INTO location VALUES('2017-01-01 01:02:03', 53, 20, 40.7493226,-73.9771269); UPDATE location SET vehicle_id = 52 WHERE vehicle_id = 53; SELECT * FROM location; SELECT * FROM vehicles; SELECT * FROM color; -- switch back to default user to run some dropping tests \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- test that disable trigger is disallowed ALTER TABLE location DISABLE TRIGGER create_vehicle_trigger; \set ON_ERROR_STOP 1 -- test that drop trigger works DROP TRIGGER create_color_trigger ON location; DROP TRIGGER create_vehicle_trigger ON location; -- test that drop trigger doesn't cause leftovers that mean that dropping chunks or hypertables no longer works SELECT count(1) FROM pg_depend d WHERE d.classid = 'pg_trigger'::regclass AND NOT EXISTS (SELECT 1 FROM pg_trigger WHERE oid = d.objid); DROP TABLE location; -- test triggers with transition tables -- test creating hypertable from table with triggers with transition tables CREATE TABLE transition_test(time timestamptz NOT NULL); CREATE TRIGGER t1_stmt AFTER INSERT ON transition_test REFERENCING NEW TABLE AS new_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t1_row AFTER INSERT ON transition_test REFERENCING NEW TABLE AS new_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); -- We do not support ROW triggers with transition tables, so we need -- to remove it to be able to create the hypertable. \set ON_ERROR_STOP 0 SELECT create_hypertable('transition_test','time'); \set ON_ERROR_STOP 1 DROP TRIGGER t1_row ON transition_test; SELECT create_hypertable('transition_test','time'); -- Insert some rows to create a chunk INSERT INTO transition_test values ('2020-01-10'); SELECT chunk FROM show_chunks('transition_test') tbl(chunk) limit 1 \gset -- test creating trigger with transition tables on existing hypertable CREATE TRIGGER t3 AFTER UPDATE ON transition_test REFERENCING NEW TABLE AS new_trans OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t4 AFTER DELETE ON transition_test REFERENCING OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); INSERT INTO transition_test values ('2020-01-11'); COPY transition_test FROM STDIN; 2020-01-09 \. UPDATE transition_test SET time = '2020-01-12' WHERE time = '2020-01-11'; DELETE FROM transition_test WHERE time = '2020-01-12'; \set ON_ERROR_STOP 0 CREATE TRIGGER t3 AFTER UPDATE ON :chunk REFERENCING NEW TABLE AS new_trans OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t4 AFTER DELETE ON :chunk REFERENCING OLD TABLE AS old_trans FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t5 AFTER INSERT ON transition_test REFERENCING NEW TABLE AS new_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t6 AFTER UPDATE ON transition_test REFERENCING NEW TABLE AS new_trans OLD TABLE AS old_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); CREATE TRIGGER t7 AFTER DELETE ON transition_test REFERENCING OLD TABLE AS old_trans FOR EACH ROW EXECUTE FUNCTION test_trigger(); \set ON_ERROR_STOP 1 ����������������������������������������������������timescaledb-2.23.0/test/sql/truncate.sql������������������������������������������������������������0000664�0000000�0000000�00000010762�15100345067�0020205�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_two_partitions.sql \o SELECT * FROM _timescaledb_catalog.hypertable; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; SELECT * FROM test.show_subtables('"two_Partitions"'); SELECT * FROM "two_Partitions"; SET client_min_messages = WARNING; TRUNCATE "two_Partitions"; SELECT * FROM _timescaledb_catalog.hypertable; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; -- should be empty SELECT * FROM test.show_subtables('"two_Partitions"'); SELECT * FROM "two_Partitions"; INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; CREATE VIEW dependent_view AS SELECT * FROM _timescaledb_internal._hyper_1_5_chunk; CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ DECLARE cnt INTEGER; BEGIN RAISE WARNING 'FIRING trigger when: % level: % op: % cnt: % trigger_name %', tg_when, tg_level, tg_op, cnt, tg_name; IF TG_OP = 'DELETE' THEN RETURN OLD; END IF; RETURN NEW; END $BODY$; -- test truncate on a chunk CREATE TRIGGER _test_truncate_before BEFORE TRUNCATE ON _timescaledb_internal._hyper_1_5_chunk FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); CREATE TRIGGER _test_truncate_after AFTER TRUNCATE ON _timescaledb_internal._hyper_1_5_chunk FOR EACH STATEMENT EXECUTE FUNCTION test_trigger(); \set ON_ERROR_STOP 0 TRUNCATE "two_Partitions"; -- cannot TRUNCATE ONLY a hypertable TRUNCATE ONLY "two_Partitions" CASCADE; \set ON_ERROR_STOP 1 -- create a regular table to make sure we can truncate it in the same call CREATE TABLE truncate_normal (color int); INSERT INTO truncate_normal VALUES (1); SELECT * FROM truncate_normal; -- fix for bug #3580 \set ON_ERROR_STOP 0 TRUNCATE nonexistentrelation; \set ON_ERROR_STOP 1 CREATE TABLE truncate_nested (color int); INSERT INTO truncate_nested VALUES (2); SELECT * FROM truncate_normal, truncate_nested; CREATE FUNCTION fn_truncate_nested() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN TRUNCATE truncate_nested; RETURN NEW; END; $$; CREATE TRIGGER tg_truncate_nested BEFORE TRUNCATE ON truncate_normal FOR EACH STATEMENT EXECUTE FUNCTION fn_truncate_nested(); TRUNCATE truncate_normal; SELECT * FROM truncate_normal, truncate_nested; INSERT INTO truncate_normal VALUES (3); INSERT INTO truncate_nested VALUES (4); SELECT * FROM truncate_normal, truncate_nested; TRUNCATE truncate_normal; SELECT * FROM truncate_normal, truncate_nested; INSERT INTO truncate_normal VALUES (5); INSERT INTO truncate_nested VALUES (6); SELECT * FROM truncate_normal, truncate_nested; SELECT * FROM test.show_subtables('"two_Partitions"'); TRUNCATE "two_Partitions", truncate_normal CASCADE; -- should be empty SELECT * FROM test.show_subtables('"two_Partitions"'); SELECT * FROM "two_Partitions"; SELECT * FROM truncate_normal, truncate_nested; -- test TRUNCATE can be performed by a user -- with TRUNCATE privilege who is not table owner \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE owner WITH LOGIN; CREATE ROLE truncator WITH LOGIN; CREATE DATABASE test_trunc_ht OWNER owner; \c test_trunc_ht :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb; RESET client_min_messages; \c test_trunc_ht owner CREATE TABLE test_hypertable (time TIMESTAMP WITHOUT TIME ZONE NOT NULL, value DOUBLE PRECISION); SELECT create_hypertable('test_hypertable', 'time'); -- fail since we don't have TRUNCATE privileges yet \set ON_ERROR_STOP 0 \c test_trunc_ht truncator TRUNCATE TABLE test_hypertable; \set ON_ERROR_STOP 1 \c test_trunc_ht owner GRANT TRUNCATE ON test_hypertable TO truncator; -- now succeed after privilege was granted \c test_trunc_ht truncator; TRUNCATE TABLE test_hypertable; \c :TEST_DBNAME :ROLE_SUPERUSER -- set client_min_messages to ERROR to suppress warnings about orphaned files SET client_min_messages TO ERROR; DROP DATABASE test_trunc_ht WITH (FORCE); DROP ROLE owner; DROP ROLE truncator; ��������������timescaledb-2.23.0/test/sql/trusted_extension.sql���������������������������������������������������0000664�0000000�0000000�00000001775�15100345067�0022152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE trusted_test; GRANT CREATE ON DATABASE trusted_test TO :ROLE_1; \c trusted_test :ROLE_READ_ONLY \set ON_ERROR_STOP 0 CREATE EXTENSION timescaledb; \set ON_ERROR_STOP 1 \c trusted_test :ROLE_1 -- user shouldn't have superuser privilege SELECT rolsuper FROM pg_roles WHERE rolname=user; SET client_min_messages TO ERROR; CREATE EXTENSION timescaledb; RESET client_min_messages; CREATE TABLE t(time timestamptz); SELECT create_hypertable('t','time'); INSERT INTO t VALUES ('2000-01-01'), ('2001-01-01'); SELECT * FROM t ORDER BY 1; SELECT * FROM timescaledb_information.hypertables; SELECT * FROM test.relation WHERE schema = '_timescaledb_internal' AND name LIKE '\_hyper%'; DROP EXTENSION timescaledb CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE trusted_test WITH (FORCE); ���timescaledb-2.23.0/test/sql/ts_merge.sql.in���������������������������������������������������������0000664�0000000�0000000�00000002273�15100345067�0020570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 \set VERBOSITY default SET client_min_messages TO error; \set TEST_BASE_NAME ts_merge SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_load_ht.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_HT_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_ht_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_HYPERTABLE", format('%s/results/%s_results.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_WITH_NO_HYPERTABLE" \gset SELECT format('\! diff -u --label "Base pg table results" --label "Hypertable results" %s %s', :'TEST_RESULTS_WITH_HYPERTABLE', :'TEST_RESULTS_WITH_NO_HYPERTABLE') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- run tests on normal table \o :TEST_RESULTS_WITH_NO_HYPERTABLE \ir :TEST_QUERY_NAME \o \ir :TEST_LOAD_HT_NAME -- run tests on hypertable \o :TEST_RESULTS_WITH_HYPERTABLE \ir :TEST_QUERY_NAME \o :DIFF_CMD �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/update.sql��������������������������������������������������������������0000664�0000000�0000000�00000004324�15100345067�0017637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \o /dev/null \ir include/insert_single.sql \o -- Make sure UPDATE isn't optimized if it includes Append plans -- Need to turn of nestloop to make append appear the same on PG96 and PG10 set enable_nestloop = 'off'; CREATE OR REPLACE FUNCTION series_val() RETURNS integer LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN 5; END; $BODY$; -- ConstraintAwareAppend applied for SELECT EXPLAIN (buffers off, costs off) SELECT FROM "one_Partition" WHERE series_1 IN (SELECT series_1 FROM "one_Partition" WHERE series_1 > series_val()); -- ConstraintAwareAppend NOT applied for UPDATE EXPLAIN (buffers off, costs off) UPDATE "one_Partition" SET series_1 = 8 WHERE series_1 IN (SELECT series_1 FROM "one_Partition" WHERE series_1 > series_val()); SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; UPDATE "one_Partition" SET series_1 = 8 WHERE series_1 IN (SELECT series_1 FROM "one_Partition" WHERE series_1 > series_val()); SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; UPDATE "one_Partition" SET series_1 = 47; UPDATE "one_Partition" SET series_bool = true; SELECT * FROM "one_Partition" ORDER BY "timeCustom", device_id, series_0, series_1, series_2; -- test update on chunks directly CREATE TABLE direct_update(time timestamptz) WITH (tsdb.hypertable); INSERT INTO direct_update VALUES ('2020-01-01'); SELECT show_chunks('direct_update') AS "CHUNK" \gset --should have ModifyHyperable node EXPLAIN (costs off, timing off, summary off) UPDATE :CHUNK SET time = time + INTERVAL '1 minute'; EXPLAIN (costs off, timing off, summary off) UPDATE ONLY :CHUNK SET time = time + INTERVAL '1 minute'; -- correct time range should succeed UPDATE :CHUNK SET time = time + INTERVAL '1 minute' RETURNING *; UPDATE ONLY :CHUNK SET time = time + INTERVAL '1 minute' RETURNING *; -- crossing chunk boundary should fail \set ON_ERROR_STOP 0 UPDATE :CHUNK SET time = time + INTERVAL '1 month' RETURNING *; UPDATE ONLY :CHUNK SET time = time + INTERVAL '1 month' RETURNING *; \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017276�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/catalog_missing_columns.sql�������������������������������������0000664�0000000�0000000�00000002515�15100345067�0024725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --PG11 added an optimization where columns that were added by --an ALTER TABLE that had a DEFAULT value did not cause a table re-write. --Instead, those columns are filled with the default value on read. --But, this mechanism does not apply to catalog tables and does --not work with our catalog scanning code. --Thus make sure all catalog tables do not have this enabled (a.atthasmissing == false) CREATE OR REPLACE FUNCTION timescaledb_catalog_has_no_missing_columns() RETURNS VOID LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE cnt INTEGER; rel_names TEXT; BEGIN SELECT count(*), string_agg(c.relname,' ;') FROM pg_namespace n INNER JOIN pg_class c ON (c.relnamespace = n.oid) INNER JOIN pg_attribute a ON attrelid=c.oid WHERE a.attnum >= 0 AND (n.nspname='_timescaledb_catalog' OR n.nspname = '_timescaledb_config' OR n.nspname='_timescaledb_internal') AND a.atthasmissing INTO STRICT cnt, rel_names; IF cnt != 0 THEN RAISE EXCEPTION 'Some catalog tables were altered without a table re-write: %', rel_names; END IF; END; $BODY$; SELECT timescaledb_catalog_has_no_missing_columns(); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.bigint.sql����������������������������������������������0000664�0000000�0000000�00000000343�15100345067�0022721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP TABLE PUBLIC."two_Partitions" CASCADE; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.chunk_skipping.sql��������������������������������������0000664�0000000�0000000�00000000327�15100345067�0024463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP TABLE IF EXISTS chunkskip; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.compression.sql�����������������������������������������0000664�0000000�0000000�00000000363�15100345067�0024010�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP TABLE compress; DROP TYPE custom_type_for_compression; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.constraints.sql�����������������������������������������0000664�0000000�0000000�00000000460�15100345067�0024014�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. ALTER TABLE "two_Partitions" DROP CONSTRAINT IF EXISTS two_Partitions_device_id_2_fkey; DROP TABLE IF EXISTS devices; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.continuous_aggs.v2.sql����������������������������������0000664�0000000�0000000�00000003702�15100345067�0025204�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Collect information about different features so that we can pick -- the right usage. Some of these are changed in the same version, but -- we keep them separate anyway so that we can do additional checking -- if necessary. SELECT extversion < '2.0.0' AS has_refresh_mat_view, extversion < '2.0.0' AS has_drop_chunks_old_interface, extversion < '2.0.0' AS has_ignore_invalidations_older_than, extversion < '2.0.0' AS has_max_interval_per_job, extversion >= '2.0.0' AS has_create_mat_view, extversion >= '2.0.0' AS has_continuous_aggs_policy FROM pg_extension WHERE extname = 'timescaledb' \gset \if :has_continuous_aggs_policy SELECT remove_continuous_aggregate_policy('mat_drop'); \endif \if :has_create_mat_view DROP MATERIALIZED VIEW mat_drop; \else DROP VIEW mat_drop; \endif DROP TABLE drop_test; \if :has_create_mat_view DROP MATERIALIZED VIEW mat_conflict; \else DROP VIEW mat_conflict; \endif DROP TABLE conflict_test; \if :has_create_mat_view DROP MATERIALIZED VIEW mat_inttime; DROP MATERIALIZED VIEW mat_inttime2; \else DROP VIEW mat_inttime; DROP VIEW mat_inttime2; \endif DROP FUNCTION integer_now_test; DROP TABLE IF EXISTS int_time_test; \if :has_create_mat_view DROP MATERIALIZED VIEW mat_inval; \else DROP VIEW mat_inval; \endif DROP TABLE inval_test; \if :has_create_mat_view DROP MATERIALIZED VIEW mat_ignoreinval; \else DROP VIEW mat_ignoreinval; \endif \if :has_create_mat_view DROP MATERIALIZED VIEW cagg.realtime_mat; \else DROP VIEW cagg.realtime_mat; \endif DROP SCHEMA cagg; \if :has_create_mat_view DROP MATERIALIZED VIEW mat_before; \else DROP VIEW mat_before; \endif \if :has_create_mat_view DROP MATERIALIZED VIEW rename_cols; \else DROP VIEW rename_cols; \endif DROP TABLE conditions_before; DROP TYPE custom_type; ��������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.policies.sql��������������������������������������������0000664�0000000�0000000�00000000551�15100345067�0023255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT remove_reorder_policy('policy_test_timestamptz'); SELECT remove_retention_policy('policy_test_timestamptz'); SELECT remove_compression_policy('policy_test_timestamptz'); �������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.sparse_index.sql����������������������������������������0000664�0000000�0000000�00000000323�15100345067�0024127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP TABLE IF EXISTS bloom; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.timestamp.sql�������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0023451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. DROP TABLE IF EXISTS PUBLIC.hyper_timestamp; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.v10.sql�������������������������������������������������0000664�0000000�0000000�00000000347�15100345067�0022057�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir cleanup.v9.sql \ir cleanup.sparse_index.sql �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.v7.sql��������������������������������������������������0000664�0000000�0000000�00000000534�15100345067�0022003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir cleanup.bigint.sql \ir cleanup.constraints.sql \ir cleanup.timestamp.sql \ir cleanup.continuous_aggs.v2.sql \ir cleanup.compression.sql \ir cleanup.policies.sql ��������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.v8.sql��������������������������������������������������0000664�0000000�0000000�00000000313�15100345067�0021777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir cleanup.v7.sql ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/cleanup.v9.sql��������������������������������������������������0000664�0000000�0000000�00000000351�15100345067�0022002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir cleanup.v8.sql \ir cleanup.chunk_skipping.sql ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.catalog.sql������������������������������������������������0000664�0000000�0000000�00000013367�15100345067�0022427�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT NOT (extversion >= '2.19.0' AND extversion <= '2.20.3') AS has_fixed_compression_algorithms FROM pg_extension WHERE extname = 'timescaledb' \gset \d+ _timescaledb_catalog.hypertable \d+ _timescaledb_catalog.chunk \d+ _timescaledb_catalog.dimension \d+ _timescaledb_catalog.dimension_slice \d+ _timescaledb_catalog.chunk_constraint \d+ _timescaledb_catalog.tablespace -- since we forgot to add bool and null compression with 2.19.0 to the preinstall -- script fresh installations of 2.19+ won't have these compression algorithms \if :has_fixed_compression_algorithms SELECT * from _timescaledb_catalog.compression_algorithm algo ORDER BY algo; \endif SELECT nspname AS Schema, relname AS Name, -- PG17 introduced MAINTAIN acl (m) so removed it to keep output backward compatible replace(unnest(relacl)::text, 'm', '') as ACL FROM pg_class JOIN pg_namespace ns ON relnamespace = ns.oid WHERE nspname IN ('_timescaledb_catalog', '_timescaledb_config') ORDER BY Schema, Name, ACL; SELECT nspname AS schema, relname AS name, -- PG17 introduced MAINTAIN acl (m) so removed it to keep output backward compatible replace(unnest(initprivs)::text, 'm', '') AS initpriv FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace LEFT JOIN pg_init_privs ON objoid = cl.oid AND objsubid = 0 WHERE classoid = 'pg_class'::regclass AND nspname IN ('_timescaledb_catalog', '_timescaledb_config') ORDER BY schema, name, initpriv; \di _timescaledb_catalog.* \ds+ _timescaledb_catalog.* -- Functions in schemas: -- * _timescaledb_internal -- * _timescaledb_functions -- * public SELECT n.nspname as "Schema", p.proname as "Name", pg_catalog.pg_get_function_result(p.oid) as "Result data type", pg_catalog.pg_get_function_arguments(p.oid) as "Argument data types", CASE p.prokind WHEN 'a' THEN 'agg' WHEN 'w' THEN 'window' WHEN 'p' THEN 'proc' ELSE 'func' END as "Type", CASE WHEN p.provolatile = 'i' THEN 'immutable' WHEN p.provolatile = 's' THEN 'stable' WHEN p.provolatile = 'v' THEN 'volatile' END as "Volatility", CASE WHEN p.proparallel = 'r' THEN 'restricted' WHEN p.proparallel = 's' THEN 'safe' WHEN p.proparallel = 'u' THEN 'unsafe' END as "Parallel", pg_catalog.pg_get_userbyid(p.proowner) as "Owner", CASE WHEN prosecdef THEN 'definer' ELSE 'invoker' END AS "Security", CASE WHEN pg_catalog.array_length(p.proacl, 1) = 0 THEN '(none)' ELSE pg_catalog.array_to_string(p.proacl, E'\n') END AS "Access privileges", l.lanname as "Language", p.prosrc as "Source code", CASE WHEN l.lanname IN ('internal', 'c') THEN p.prosrc END as "Internal name", pg_catalog.obj_description(p.oid, 'pg_proc') as "Description" FROM pg_catalog.pg_proc p LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace LEFT JOIN pg_catalog.pg_language l ON l.oid = p.prolang WHERE n.nspname OPERATOR(pg_catalog.~) '^(_timescaledb_internal|_timescaledb_functions|public)$' COLLATE pg_catalog.default ORDER BY 1, 2, 4; \dy \d public.* -- Keep the output backward compatible \if :PG_UPGRADE_TEST SELECT oid AS extoid FROM pg_catalog.pg_extension WHERE extname = 'timescaledb' \gset WITH ext AS ( SELECT pg_catalog.pg_describe_object(classid, objid, 0) AS objdesc FROM pg_catalog.pg_depend WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass AND refobjid = :'extoid' AND deptype = 'e' ORDER BY 1 ) SELECT objdesc AS "Object description" FROM ext WHERE objdesc !~ '^type' OR objdesc ~ '^type _timescaledb_internal.(compressed_data|dimension_info)$' ORDER BY 1; WITH ext AS ( SELECT pg_catalog.pg_describe_object(classid, objid, 0) AS objdesc FROM pg_catalog.pg_depend WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass AND refobjid = :'extoid' AND deptype = 'e' ORDER BY 1 ) SELECT count(*) FROM ext WHERE objdesc !~ '^type' OR objdesc ~ '^type _timescaledb_internal.(compressed_data|dimension_info)$'; \else \dx+ timescaledb SELECT count(*) FROM pg_depend WHERE refclassid = 'pg_extension'::regclass AND refobjid = (SELECT oid FROM pg_extension WHERE extname = 'timescaledb'); \endif -- The list of tables configured to be dumped. SELECT unnest(extconfig)::regclass::text, unnest(extcondition) FROM pg_extension WHERE extname = 'timescaledb' ORDER BY 1; -- Show chunks that are not dropped and include owner in the output SELECT c.id, c.hypertable_id, c.schema_name, c.table_name, c.dropped, cl.relowner::regrole FROM _timescaledb_catalog.chunk c INNER JOIN pg_class cl ON (cl.oid=format('%I.%I', schema_name, table_name)::regclass) WHERE NOT c.dropped ORDER BY c.id, c.hypertable_id; SELECT chunk_constraint.* FROM _timescaledb_catalog.chunk_constraint JOIN _timescaledb_catalog.chunk ON chunk.id = chunk_constraint.chunk_id WHERE NOT chunk.dropped ORDER BY chunk_constraint.chunk_id, chunk_constraint.dimension_slice_id, chunk_constraint.constraint_name; -- Show attnum of all regclass objects belonging to our extension -- if those are not the same between fresh install/update our update scripts are broken SELECT att.attrelid::regclass, att.attnum, att.attname FROM pg_depend dep INNER JOIN pg_extension ext ON (dep.refobjid=ext.oid AND ext.extname = 'timescaledb') INNER JOIN pg_attribute att ON (att.attrelid=dep.objid AND att.attnum > 0) WHERE classid='pg_class'::regclass ORDER BY attrelid::regclass::text,att.attnum; -- Show constraints SELECT conrelid::regclass::text, conname, pg_get_constraintdef(oid) FROM pg_constraint WHERE conrelid::regclass::text ~ '^_timescaledb_' ORDER BY 1, 2, 3; SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY relid::regclass; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.chunk_skipping.sql�����������������������������������������0000664�0000000�0000000�00000001134�15100345067�0024016�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Show chunk column stats after updating the extension. We need to -- exclude the rows with chunk_id = 0 because we cannot keep those on -- downgrade due to FK constraint. Showing them would mean a diff in -- the output. We can still test that 0 chunk_ids are converted to -- NULL values during upgrades, however. SELECT * FROM _timescaledb_catalog.chunk_column_stats WHERE chunk_id IS NULL OR chunk_id > 0 ORDER BY id; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.compression.sql��������������������������������������������0000664�0000000�0000000�00000005235�15100345067�0023351�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT * FROM compress ORDER BY time DESC, small_cardinality, large_cardinality, some_double, some_int, some_custom, some_bool; -- This recompression is necessary only for downgrades from 2.17 to 2.16.1 -- due to downgrade migration requiring to add sequence number metadata -- column and causing compressed chunks to be unordered. -- Recompressing the chunks fully fixes the difference. SELECT count(decompress_chunk(ch, true)) FROM show_chunks('compress') ch; SELECT count(compress_chunk(ch, true)) FROM show_chunks('compress') ch; -- Running this query again to confirm data is consistent even after above recompression SELECT * FROM compress ORDER BY time DESC, small_cardinality, large_cardinality, some_double, some_int, some_custom, some_bool; INSERT INTO compress(time, small_cardinality, large_cardinality, some_double, some_int, some_custom, some_bool) SELECT g, 'QW', g::text, 2, 0, (100,4)::custom_type_for_compression, false FROM generate_series('2019-11-01 00:00'::timestamp, '2019-12-15 00:00'::timestamp, '1 day') g; SELECT count(compress_chunk(ch, true)) FROM show_chunks('compress') ch; SELECT * FROM compress ORDER BY time DESC, small_cardinality, large_cardinality, some_double, some_int, some_custom, some_bool; \x on WITH hypertables AS ( SELECT ht.id hypertable_id, ht.schema_name, ht.table_name, ht.compressed_hypertable_id FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace JOIN _timescaledb_catalog.hypertable ht ON relname = ht.table_name AND nspname = ht.schema_name ), table_summary AS ( SELECT format('%I.%I', ht1.schema_name, ht1.table_name) AS hypertable_name, format('%I.%I', ht2.schema_name, ht2.table_name) AS compressed_hypertable_name, format('%I.%I', ch2.schema_name, ch2.table_name) AS compressed_chunk_name FROM hypertables ht1 JOIN hypertables ht2 ON ht1.compressed_hypertable_id = ht2.hypertable_id JOIN _timescaledb_catalog.chunk ch2 ON ch2.hypertable_id = ht2.hypertable_id ) SELECT hypertable_name, (SELECT relacl FROM pg_class WHERE oid = hypertable_name::regclass) AS hypertable_acl, compressed_hypertable_name, (SELECT relacl FROM pg_class WHERE oid = compressed_hypertable_name::regclass) AS compressed_hypertable_acl, compressed_chunk_name, (SELECT relacl FROM pg_class WHERE oid = compressed_chunk_name::regclass) AS compressed_chunk_acl FROM table_summary ORDER BY hypertable_name, compressed_hypertable_name, compressed_chunk_name; \x off �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.continuous_aggs.sql����������������������������������������0000664�0000000�0000000�00000007713�15100345067�0024222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT extversion < '2.0.0' AS has_refresh_mat_view FROM pg_extension WHERE extname = 'timescaledb' \gset \if :has_refresh_mat_view REFRESH MATERIALIZED VIEW mat_before; \else CALL refresh_continuous_aggregate('mat_before',NULL,NULL); \endif \x on SELECT * FROM mat_before ORDER BY bucket, location; \x off --cause invalidations in the time range that is already --materialized. However, shift time by one second so that each --(timestamp, location) pair is unique. Otherwise last(temperature, --timec) won't be deterministic. INSERT INTO conditions_before SELECT generate_series('2018-12-01 00:01'::timestamp, '2018-12-31 00:01'::timestamp, '1 day'), 'POR', 165, 75, 40, 70, NULL, (1,2)::custom_type, 2, true; --cause invalidations way in the past INSERT INTO conditions_before SELECT generate_series('2017-12-01 00:01'::timestamp, '2017-12-31 00:01'::timestamp, '1 day'), 'POR', 1065, 75, 40, 70, NULL, (1,2)::custom_type, 2, true; \x on SELECT * FROM mat_before ORDER BY bucket, location; \x off CALL refresh_continuous_aggregate('mat_before',NULL,NULL); --the max of the temp for the POR should now be 165 \x on SELECT * FROM mat_before ORDER BY bucket, location; \x off -- Output the ACLs for each internal cagg object SELECT cl.oid::regclass::text AS reloid, unnest(relacl)::text AS relacl FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (ca.mat_hypertable_id = h.id) JOIN pg_class cl ON (cl.oid IN (format('%I.%I', h.schema_name, h.table_name)::regclass, format('%I.%I', direct_view_schema, direct_view_name)::regclass, format('%I.%I', partial_view_schema, partial_view_name)::regclass)) ORDER BY reloid, relacl; -- Output ACLs for chunks on materialized hypertables SELECT inhparent::regclass::text AS parent, cl.oid::regclass::text AS chunk, unnest(relacl)::text AS acl FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (ca.mat_hypertable_id = h.id) JOIN pg_inherits inh ON (inh.inhparent = format('%I.%I', h.schema_name, h.table_name)::regclass) JOIN pg_class cl ON (cl.oid = inh.inhrelid) ORDER BY parent, chunk, acl; -- Verify privileges on internal cagg objects. The privileges on the -- materialized hypertable, partial view, and direct view should match -- the user-facing user view. DO $$ DECLARE user_view_rel regclass; user_view_acl aclitem[]; rel regclass; acl aclitem[]; acl_matches boolean; BEGIN FOR user_view_rel, user_view_acl IN SELECT cl.oid, cl.relacl FROM pg_class cl JOIN _timescaledb_catalog.continuous_agg ca ON (format('%I.%I', ca.user_view_schema, ca.user_view_name)::regclass = cl.oid) LOOP FOR rel, acl, acl_matches IN SELECT cl.oid, cl.relacl, COALESCE(cl.relacl, ARRAY[]::aclitem[]) @> COALESCE(user_view_acl, ARRAY[]::aclitem[]) FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (ca.mat_hypertable_id = h.id) JOIN pg_class cl ON (cl.oid IN (format('%I.%I', h.schema_name, h.table_name)::regclass, format('%I.%I', direct_view_schema, direct_view_name)::regclass, format('%I.%I', partial_view_schema, partial_view_name)::regclass)) WHERE format('%I.%I', ca.user_view_schema, ca.user_view_name)::regclass = user_view_rel LOOP IF NOT acl_matches THEN RAISE EXCEPTION 'privileges mismatch for continuous aggregate "%"', user_view_rel USING DETAIL = format('Privileges for internal object "%s" are [%s], expected [%s].', rel, acl, user_view_acl); END IF; END LOOP; END LOOP; END $$ LANGUAGE PLPGSQL; �����������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.continuous_aggs.v2.sql�������������������������������������0000664�0000000�0000000�00000002027�15100345067�0024541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir post.continuous_aggs.sql \d cagg.* \x on SELECT * FROM cagg.realtime_mat ORDER BY bucket, location; \x off CALL refresh_continuous_aggregate('cagg.realtime_mat',NULL,NULL); \x on SELECT * FROM cagg.realtime_mat ORDER BY bucket, location; \x off SELECT view_name, materialized_only, materialization_hypertable_name FROM timescaledb_information.continuous_aggregates ORDER BY view_name::text; SELECT schedule_interval FROM timescaledb_information.jobs ORDER BY job_id; SELECT maxtemp FROM mat_ignoreinval ORDER BY 1; SELECT materialization_id FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log WHERE lowest_modified_value = -9223372036854775808 ORDER BY 1; SELECT count(*) FROM mat_inval; CALL refresh_continuous_aggregate('mat_inval',NULL,NULL); SELECT pg_sleep(0.1); -- ensure refresh completes SELECT count(*) FROM mat_inval; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.continuous_aggs.v3.sql�������������������������������������0000664�0000000�0000000�00000001334�15100345067�0024542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir post.continuous_aggs.v2.sql -- Ensure CAgg is refreshed SELECT extversion < '2.0.0' AS has_refresh_mat_view FROM pg_extension WHERE extname = 'timescaledb' \gset \if :has_refresh_mat_view REFRESH MATERIALIZED VIEW rename_cols; \else CALL refresh_continuous_aggregate('rename_cols',NULL,NULL); \endif SELECT "time", count(*) from rename_cols GROUP BY 1 ORDER BY 1; --verify compression can be enabled ALTER MATERIALIZED VIEW rename_cols SET ( timescaledb.compress='true'); SELECT "time", count(*) from rename_cols GROUP BY 1 ORDER BY 1; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.functions.sql����������������������������������������������0000664�0000000�0000000�00000000546�15100345067�0023020�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- check all functions point to the correct library SELECT oid::REGPROCEDURE, probin FROM pg_proc WHERE probin LIKE '%timescale%' ORDER BY oid::REGPROCEDURE::TEXT; ����������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.insert.sql�������������������������������������������������0000664�0000000�0000000�00000000702�15100345067�0022306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- INSERT data to create a new chunk after update or restore. INSERT INTO devices(id,floor) VALUES ('dev5', 5); INSERT INTO "two_Partitions"("timeCustom", device_id, device_id_2, series_0, series_1, series_2) VALUES (1258894000000000000, 'dev5', 'dev1', 2.2, 1, 2); ��������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.integrity_test.sql�����������������������������������������0000664�0000000�0000000�00000004303�15100345067�0024060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- We do not dump the size of the tables here since that might differ -- between an updated node and a restored node. For examples, stats -- tables can have different sizes, and this is not relevant for an -- update test. \dt _timescaledb_internal.* CREATE OR REPLACE FUNCTION timescaledb_integrity_test() RETURNS VOID LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE dimension_slice RECORD; constraint_row RECORD; index_row RECORD; chunk_count INTEGER; chunk_constraint_count INTEGER; BEGIN -- Check integrity of chunk_constraints FOR constraint_row IN SELECT c.conname, h.id AS hypertable_id FROM _timescaledb_catalog.hypertable h INNER JOIN pg_constraint c ON (c.conrelid = format('%I.%I', h.schema_name, h.table_name)::regclass) WHERE c.contype != 'c' LOOP SELECT count(*) FROM _timescaledb_catalog.chunk c WHERE c.hypertable_id = constraint_row.hypertable_id INTO STRICT chunk_count; SELECT count(cc.*) FROM _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.chunk c WHERE hypertable_constraint_name = constraint_row.conname AND c.id = cc.chunk_id AND c.hypertable_id = constraint_row.hypertable_id INTO STRICT chunk_constraint_count; IF chunk_constraint_count != chunk_count THEN RAISE EXCEPTION 'Missing chunk constraints for %. Expected %, but found %', constraint_row.conname, chunk_count, chunk_constraint_count; END IF; END LOOP; FOR dimension_slice IN SELECT chunk_id, dimension_slice_id FROM _timescaledb_catalog.chunk_constraint WHERE dimension_slice_id NOT IN (SELECT id FROM _timescaledb_catalog.dimension_slice) LOOP RAISE EXCEPTION 'Missing dimension slice with id % for chunk %.', dimension_slice.dimension_slice_id, dimension_slice.chunk_id; END LOOP; END; $BODY$; SELECT timescaledb_integrity_test(); -- Verify that the default jobs are the same in bgw_job SELECT id, application_name FROM _timescaledb_config.bgw_job ORDER BY id; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.pg_upgrade.sql���������������������������������������������0000664�0000000�0000000�00000000634�15100345067�0023123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \pset format aligned \pset tuples_only off \set PG_UPGRADE_TEST true \ir post.catalog.sql \unset PG_UPGRADE_TEST \ir post.policies.sql \ir post.functions.sql SELECT * FROM cagg_join.measurement_daily ORDER BY 1, 2, 3, 4, 5, 6; ����������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.policies.sql�����������������������������������������������0000664�0000000�0000000�00000000724�15100345067�0022615�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- SELECT * FROM _timescaledb_config.bgw_job WHERE id <> 1 ORDER BY id; SELECT id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, hypertable_id, config FROM _timescaledb_config.bgw_job WHERE id <> 1 ORDER BY id; ��������������������������������������������timescaledb-2.23.0/test/sql/updates/post.repair.cagg_joins.sql��������������������������������������0000664�0000000�0000000�00000001235�15100345067�0024370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \d+ cagg_joins_upgrade_test_with_realtime SELECT * FROM cagg_joins_upgrade_test_with_realtime ORDER BY bucket; \d+ cagg_joins_upgrade_test SELECT * FROM cagg_joins_upgrade_test ORDER BY bucket; \d+ cagg_joins_where SELECT * FROM cagg_joins_where ORDER BY bucket; \d+ cagg_joins_upgrade_test_with_realtime_using SELECT * FROM cagg_joins_upgrade_test_with_realtime_using ORDER BY bucket; \d+ cagg_joins_upgrade_test_using SELECT * FROM cagg_joins_upgrade_test_using ORDER BY bucket; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.repair.hierarchical_cagg.sql�������������������������������0000664�0000000�0000000�00000000337�15100345067�0025666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT count(*) FROM agg_test_monthly; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.repair.sql�������������������������������������������������0000664�0000000�0000000�00000000540�15100345067�0022264�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. --Check if the repaired cagg with joins work alright now \ir post.repair.cagg_joins.sql \ir post.repair.hierarchical_cagg.sql \z repair_test_int \z repair_test_extra ����������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.sequences.sql����������������������������������������������0000664�0000000�0000000�00000000560�15100345067�0022777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- check sequences did not get reset SELECT seqrelid::regclass, nextval(seqrelid), seqstart, seqincrement, seqmax, seqmin FROM pg_sequence ORDER BY seqrelid::regclass::text; ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.sparse_index.sql�������������������������������������������0000664�0000000�0000000�00000002127�15100345067�0023471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Show chunk column stats after updating the extension. We need to -- exclude the rows with chunk_id = 0 because we cannot keep those on -- downgrade due to FK constraint. Showing them would mean a diff in -- the output. We can still test that 0 chunk_ids are converted to -- NULL values during upgrades, however. SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY relid::regclass::text; SELECT schema_name || '.' || table_name AS chunk FROM _timescaledb_catalog.chunk WHERE id = ( SELECT compressed_chunk_id FROM _timescaledb_catalog.chunk WHERE hypertable_id = ( SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'bloom' ) LIMIT 1 ) \gset -- Note: we can't use \d+ here because it prevents changing the TOAST storage flag -- if we do, like in the UUID compression changes from external to extended, then -- the upgrade tests fail \d :chunk �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.v10.sql����������������������������������������������������0000664�0000000�0000000�00000000341�15100345067�0021407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir post.v9.sql \ir post.sparse_index.sql �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.v7.sql�����������������������������������������������������0000664�0000000�0000000�00000000746�15100345067�0021346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PG_UPGRADE_TEST false \ir post.catalog.sql \unset PG_UPGRADE_TEST \ir post.insert.sql \ir post.integrity_test.sql \ir catalog_missing_columns.sql \ir post.compression.sql \ir post.continuous_aggs.v2.sql \ir post.policies.sql \if :WITH_SUPERUSER \ir post.sequences.sql \endif \ir post.functions.sql ��������������������������timescaledb-2.23.0/test/sql/updates/post.v8.sql�����������������������������������������������������0000664�0000000�0000000�00000000713�15100345067�0021341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set PG_UPGRADE_TEST false \ir post.catalog.sql \unset PG_UPGRADE_TEST \ir post.insert.sql \ir post.integrity_test.sql \ir catalog_missing_columns.sql \ir post.compression.sql \ir post.continuous_aggs.v3.sql \ir post.policies.sql \ir post.sequences.sql \ir post.functions.sql �����������������������������������������������������timescaledb-2.23.0/test/sql/updates/post.v9.sql�����������������������������������������������������0000664�0000000�0000000�00000000343�15100345067�0021341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir post.v8.sql \ir post.chunk_skipping.sql ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/pre.cleanup.sql�������������������������������������������������0000664�0000000�0000000�00000003644�15100345067�0022242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Clean up objects that are created by the setup files. Ideally, we -- should clean them up in each post.*.sql file after generating the -- output, but now we do it here. SET client_min_messages TO WARNING; DROP MATERIALIZED VIEW IF EXISTS mat_inval CASCADE; DROP MATERIALIZED VIEW IF EXISTS mat_drop CASCADE; DROP MATERIALIZED VIEW IF EXISTS mat_before CASCADE; DROP MATERIALIZED VIEW IF EXISTS mat_conflict CASCADE; DROP MATERIALIZED VIEW IF EXISTS mat_inttime CASCADE; DROP MATERIALIZED VIEW IF EXISTS mat_inttime2 CASCADE; DROP MATERIALIZED VIEW IF EXISTS mat_ignoreinval CASCADE; DROP MATERIALIZED VIEW IF EXISTS cagg.realtime_mat CASCADE; DROP TABLE IF EXISTS public.hyper_timestamp; DROP TABLE IF EXISTS public."two_Partitions"; DROP TABLE IF EXISTS conditions_before; DROP TABLE IF EXISTS inval_test; DROP TABLE IF EXISTS int_time_test; DROP TABLE IF EXISTS conflict_test; DROP TABLE IF EXISTS drop_test; DROP TABLE IF EXISTS repair_test_timestamptz; DROP TABLE IF EXISTS repair_test_int; DROP TABLE IF EXISTS repair_test_extra; DROP TABLE IF EXISTS repair_test_timestamp; DROP TABLE IF EXISTS repair_test_date; DROP TABLE IF EXISTS compress; DROP TABLE IF EXISTS skip; DROP TABLE IF EXISTS devices; DROP TABLE IF EXISTS disthyper; DROP TABLE IF EXISTS policy_test_timestamptz; DROP TYPE IF EXISTS custom_type; DROP TYPE IF EXISTS custom_type_for_compression; DROP PROCEDURE IF EXISTS _timescaledb_testing.restart_dimension_slice_id; DROP PROCEDURE IF EXISTS _timescaledb_testing.stop_workers; DROP FUNCTION IF EXISTS timescaledb_integrity_test; DROP FUNCTION IF EXISTS timescaledb_catalog_has_no_missing_columns; DROP FUNCTION IF EXISTS integer_now_test; DROP SCHEMA IF EXISTS cagg; DROP SCHEMA IF EXISTS _timescaledb_testing; RESET client_min_messages; ��������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/pre.smoke.sql���������������������������������������������������0000664�0000000�0000000�00000001005�15100345067�0021716�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- These functions are used when running smoke tests. For smoke tests -- we assume that we do not have SUPER privileges. CREATE SCHEMA IF NOT EXISTS _timescaledb_testing; CREATE PROCEDURE _timescaledb_testing.restart_dimension_slice_id() LANGUAGE SQL AS ''; CREATE PROCEDURE _timescaledb_testing.stop_workers() LANGUAGE SQL AS ''; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/pre.testing.sql�������������������������������������������������0000664�0000000�0000000�00000001525�15100345067�0022264�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- These functions are used when running normal update tests. CREATE SCHEMA IF NOT EXISTS _timescaledb_testing; CREATE OR REPLACE PROCEDURE _timescaledb_testing.restart_dimension_slice_id() LANGUAGE SQL AS $$ ALTER SEQUENCE _timescaledb_catalog.dimension_slice_id_seq RESTART WITH 100; $$; CREATE OR REPLACE PROCEDURE _timescaledb_testing.stop_workers() LANGUAGE PLPGSQL AS $$ BEGIN IF EXISTS (SELECT FROM pg_proc WHERE proname='stop_background_workers' AND pronamespace='_timescaledb_internal'::regnamespace) THEN PERFORM _timescaledb_internal.stop_background_workers(); ELSE PERFORM _timescaledb_functions.stop_background_workers(); END IF; END $$; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.bigint.sql������������������������������������������������0000664�0000000�0000000�00000003376�15100345067�0022443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE PUBLIC."two_Partitions" ( "timeCustom" BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL, UNIQUE("timeCustom", device_id, series_2) ); CREATE INDEX ON PUBLIC."two_Partitions" (device_id, "timeCustom" DESC NULLS LAST) WHERE device_id IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_0) WHERE series_0 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_1) WHERE series_1 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_2) WHERE series_2 IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, series_bool) WHERE series_bool IS NOT NULL; CREATE INDEX ON PUBLIC."two_Partitions" ("timeCustom" DESC NULLS LAST, device_id); DO $$ BEGIN IF (EXISTS (SELECT FROM pg_proc WHERE proname = 'interval_to_usec' AND pronamespace='_timescaledb_internal'::regnamespace)) THEN PERFORM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_internal.interval_to_usec('1 month')); ELSE PERFORM create_hypertable('"public"."two_Partitions"'::regclass, 'timeCustom'::name, 'device_id'::name, associated_schema_name=>'_timescaledb_internal'::text, number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); END IF; END; $$; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.catalog.sql�����������������������������������������������0000664�0000000�0000000�00000002501�15100345067�0022566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Catalog tables are occasionally rewritten as part of updates, so -- this is to test that privileges are maintained over updates of the -- extension. We could verify that other properties (e.g., comments) -- are maintained here as well, but this is not something we use right -- now. -- -- We do not alter the privileges on _timescaledb_internal since this -- affects both internal objects and two tables that are metadata -- placed in the _timescaledb_internal schema. GRANT SELECT ON ALL TABLES IN SCHEMA _timescaledb_catalog TO tsdbadmin; GRANT SELECT ON ALL TABLES IN SCHEMA _timescaledb_config TO tsdbadmin; GRANT SELECT ON ALL SEQUENCES IN SCHEMA _timescaledb_catalog TO tsdbadmin; GRANT SELECT ON ALL SEQUENCES IN SCHEMA _timescaledb_config TO tsdbadmin; ALTER DEFAULT PRIVILEGES IN SCHEMA _timescaledb_catalog GRANT SELECT ON TABLES TO tsdbadmin; ALTER DEFAULT PRIVILEGES IN SCHEMA _timescaledb_config GRANT SELECT ON TABLES TO tsdbadmin; ALTER DEFAULT PRIVILEGES IN SCHEMA _timescaledb_catalog GRANT SELECT ON SEQUENCES TO tsdbadmin; ALTER DEFAULT PRIVILEGES IN SCHEMA _timescaledb_config GRANT SELECT ON SEQUENCES TO tsdbadmin; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.check.sql�������������������������������������������������0000664�0000000�0000000�00000001674�15100345067�0022243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \echo **** Missing dimension slices **** SELECT hypertable_id, ( SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.hypertable ht WHERE ht.id = ch.hypertable_id ) AS hypertable, chunk_id, dimension_slice_id, constraint_name, attname AS column_name, pg_get_expr(conbin, conrelid) AS constraint_expr FROM _timescaledb_catalog.chunk_constraint cc JOIN _timescaledb_catalog.chunk ch ON cc.chunk_id = ch.id JOIN pg_constraint ON conname = constraint_name JOIN pg_namespace ns ON connamespace = ns.oid AND ns.nspname = ch.schema_name JOIN pg_attribute ON attnum = conkey[1] AND attrelid = conrelid WHERE dimension_slice_id NOT IN (SELECT id FROM _timescaledb_catalog.dimension_slice); ��������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.chunk_skipping.sql����������������������������������������0000664�0000000�0000000�00000002607�15100345067�0024177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE chunkskip ( time TIMESTAMPTZ NOT NULL, updated_at TIMESTAMPTZ NOT NULL, location INT, temp FLOAT ); SELECT setseed(0.1); SELECT table_name FROM create_hypertable( 'chunkskip', 'time'); INSERT INTO chunkskip SELECT g, g+interval '1 hour', ceil(random()*20), random()*30 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day') g; ALTER TABLE chunkskip SET (timescaledb.compress, timescaledb.compress_segmentby='location', timescaledb.compress_orderby='"time" desc'); SELECT count(compress_chunk(ch, true)) FROM show_chunks('chunkskip') ch; DO $$ DECLARE version text[] := (SELECT regexp_split_to_array(extversion,'(\.|-)') FROM pg_extension WHERE extname = 'timescaledb'); BEGIN -- Enable chunk skipping. Doing this after compression to have a -- "special" chunk_id entry of 0. We check that this is changed to -- NULL during upgrade. IF version[1]::int >= 2 AND version[2]::int >= 17 AND (version[2]::int > 17 OR version[3]::int > 0) THEN SET timescaledb.enable_chunk_skipping = true; END IF; END $$; SELECT enable_chunk_skipping('chunkskip', 'updated_at'); �������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.compression.sql�������������������������������������������0000664�0000000�0000000�00000004100�15100345067�0023512�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TYPE custom_type_for_compression AS (high int, low int); CREATE TABLE compress ( time TIMESTAMPTZ NOT NULL, small_cardinality TEXT NULL, large_cardinality TEXT NULL, dropped TEXT NULL, some_double DOUBLE PRECISION NULL, some_int integer NULL, some_custom custom_type_for_compression NULL, some_bool boolean NULL ); SELECT table_name FROM create_hypertable( 'compress', 'time'); INSERT INTO compress SELECT g, 'POR', g::text, 'lint', 75.0, 40, (1,2)::custom_type_for_compression, true FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day') g; INSERT INTO compress SELECT g, 'POR', NULL, 'lint', NULL, NULL, NULL, NULL FROM generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day') g; INSERT INTO compress SELECT g, 'POR', g::text, 'lint', 94.0, 45, (3,4)::custom_type_for_compression, true FROM generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day') g; DO $$ DECLARE ts_minor int := (SELECT (string_to_array(extversion,'.'))[2]::int FROM pg_extension WHERE extname = 'timescaledb'); BEGIN -- support for dropping columns on compressed hypertables was added in 2.10.0 -- so we drop before compressing if the version is before 2.10.0 IF ts_minor < 10 THEN ALTER TABLE compress DROP COLUMN dropped; END IF; ALTER TABLE compress SET (timescaledb.compress, timescaledb.compress_segmentby='small_cardinality', timescaledb.compress_orderby='"time" desc'); PERFORM count(compress_chunk(ch, true)) FROM show_chunks('compress') ch; IF ts_minor >= 10 THEN ALTER TABLE compress DROP COLUMN dropped; END IF; END $$; \if :WITH_ROLES GRANT SELECT ON compress TO tsdbadmin; \endif ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.constraints.sql�������������������������������������������0000664�0000000�0000000�00000001212�15100345067�0023521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Secondary devices table to test foreign keys in "two_Partitions" CREATE TABLE devices ( id TEXT PRIMARY KEY, floor INTEGER ); INSERT INTO devices(id,floor) VALUES ('dev1', 1), ('dev2', 2), ('dev3', 3); -- Setup "two_Partitions" to use foreign key constraints ALTER TABLE "two_Partitions" ADD COLUMN device_id_2 TEXT NOT NULL; ALTER TABLE "two_Partitions" ADD CONSTRAINT two_Partitions_device_id_2_fkey FOREIGN KEY (device_id_2) REFERENCES devices(id); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.continuous_aggs.sql���������������������������������������0000664�0000000�0000000�00000027503�15100345067�0024374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Collect information about different features so that we can pick -- the right usage. Some of these are changed in the same version, but -- we keep them separate anyway so that we can do additional checking -- if necessary. -- disable background workers to prevent deadlocks between background processes -- on timescaledb 1.7.x CALL _timescaledb_testing.stop_workers(); -- disable chunkwise aggregation and hash aggregation, because it might lead to -- different order of chunk creation in the cagg table, based on the underlying -- aggregation plan. SET timescaledb.enable_chunkwise_aggregation TO OFF; SET enable_hashagg TO OFF; CREATE TYPE custom_type AS (high int, low int); CREATE TABLE conditions_before ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null, highlow custom_type null, bit_int smallint, good_life boolean ); SELECT table_name FROM create_hypertable( 'conditions_before', 'timec'); INSERT INTO conditions_before SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO conditions_before SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO conditions_before SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL, NULL, 8, true; -- rename_cols cagg view is also used for another test: if we can enable -- compression on a cagg after an upgrade -- This view has 3 cols which is fewer than the number of cols on the table -- we had a bug related to that and need to verify if compression can be -- enabled on such a view CREATE MATERIALIZED VIEW rename_cols WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 week', timec) AS bucket, location, round(avg(humidity)) AS humidity FROM conditions_before GROUP BY bucket, location WITH NO DATA; CREATE MATERIALIZED VIEW IF NOT EXISTS mat_before WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1week', timec) as bucket, location, round(min(allnull)) as min_allnull, round(max(temperature)) as max_temp, round(sum(temperature)+sum(humidity)) as agg_sum_expr, round(avg(humidity)) AS avg_humidity, round(stddev(humidity)) as stddev, bit_and(bit_int), bit_or(bit_int), bool_and(good_life), every(temperature > 0), bool_or(good_life), count(*) as count_rows, count(temperature) as count_temp, count(allnull) as count_zero, round(corr(temperature, humidity)) as corr, round(covar_pop(temperature, humidity)) as covar_pop, round(covar_samp(temperature, humidity)) as covar_samp, round(regr_avgx(temperature, humidity)) as regr_avgx, round(regr_avgy(temperature, humidity)) as regr_avgy, round(regr_count(temperature, humidity)) as regr_count, round(regr_intercept(temperature, humidity)) as regr_intercept, round(regr_r2(temperature, humidity)) as regr_r2, round(regr_slope(temperature, humidity)) as regr_slope, round(regr_sxx(temperature, humidity)) as regr_sxx, round(regr_sxy(temperature, humidity)) as regr_sxy, round(regr_syy(temperature, humidity)) as regr_syy, round(stddev(temperature)) as stddev_temp, round(stddev_pop(temperature)) as stddev_pop, round(stddev_samp(temperature)) as stddev_samp, round(variance(temperature)) as variance, round(var_pop(temperature)) as var_pop, round(var_samp(temperature)) as var_samp, last(temperature, timec) as last_temp, last(highlow, timec) as last_hl, first(highlow, timec) as first_hl, histogram(temperature, 0, 100, 5) FROM conditions_before GROUP BY bucket, location HAVING min(location) >= 'NYC' and avg(temperature) > 2 WITH NO DATA; ALTER MATERIALIZED VIEW rename_cols RENAME COLUMN bucket TO "time"; \if :WITH_SUPERUSER GRANT SELECT ON mat_before TO cagg_user WITH GRANT OPTION; \endif CALL refresh_continuous_aggregate('rename_cols',NULL,NULL); CALL refresh_continuous_aggregate('mat_before',NULL,NULL); -- we create separate schema for realtime agg since we dump all view definitions in public schema -- but realtime agg view definition is not stable across versions CREATE SCHEMA cagg; CREATE MATERIALIZED VIEW IF NOT EXISTS cagg.realtime_mat WITH ( timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec) as bucket, location, round(min(allnull)) as min_allnull, round(max(temperature)) as max_temp, round(sum(temperature)+sum(humidity)) as agg_sum_expr, round(avg(humidity)) AS avg_humidity, round(stddev(humidity)) as stddev_humidity, bit_and(bit_int), bit_or(bit_int), bool_and(good_life), every(temperature > 0), bool_or(good_life), count(*) as count_rows, count(temperature) as count_temp, count(allnull) as count_zero, round(corr(temperature, humidity)) as corr, round(covar_pop(temperature, humidity)) as covar_pop, round(covar_samp(temperature, humidity)) as covar_samp, round(regr_avgx(temperature, humidity)) as regr_avgx, round(regr_avgy(temperature, humidity)) as regr_avgy, round(regr_count(temperature, humidity)) as regr_count, round(regr_intercept(temperature, humidity)) as regr_intercept, round(regr_r2(temperature, humidity)) as regr_r2, round(regr_slope(temperature, humidity)) as regr_slope, round(regr_sxx(temperature, humidity)) as regr_sxx, round(regr_sxy(temperature, humidity)) as regr_sxy, round(regr_syy(temperature, humidity)) as regr_syy, round(stddev(temperature)) as stddev_temp, round(stddev_pop(temperature)) as stddev_pop, round(stddev_samp(temperature)) as stddev_samp, round(variance(temperature)) as variance, round(var_pop(temperature)) as var_pop, round(var_samp(temperature)) as var_samp, last(temperature, timec) as last_temp, last(highlow, timec) as last_hl, first(highlow, timec) as first_hl, histogram(temperature, 0, 100, 5) FROM conditions_before GROUP BY bucket, location HAVING min(location) >= 'NYC' and avg(temperature) > 2 WITH NO DATA; \if :WITH_SUPERUSER GRANT SELECT ON cagg.realtime_mat TO cagg_user; \endif CALL refresh_continuous_aggregate('cagg.realtime_mat',NULL,NULL); -- test ignore_invalidation_older_than migration -- CREATE MATERIALIZED VIEW IF NOT EXISTS mat_ignoreinval WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 week', timec) as bucket, max(temperature) as maxtemp FROM conditions_before GROUP BY bucket WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_ignoreinval', '30 days'::interval, '-30 days'::interval, '336 h'); CALL refresh_continuous_aggregate('mat_ignoreinval',NULL,NULL); -- test new data beyond the invalidation threshold is properly handled -- CREATE TABLE inval_test (time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION); SELECT create_hypertable('inval_test', 'time', chunk_time_interval => INTERVAL '1 week'); INSERT INTO inval_test SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1 day'), 'POR', generate_series(40.5, 50.0, 0.5); INSERT INTO inval_test SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-20 00:00'::timestamp, '1 day'), 'NYC', generate_series(31.0, 50.0, 1.0); CREATE MATERIALIZED VIEW mat_inval WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('10 minute', time) as bucket, location, min(temperature) as min_temp, max(temperature) as max_temp, round(avg(temperature)) as avg_temp FROM inval_test GROUP BY bucket, location WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_inval', NULL, '-20 days'::interval, '12 hours'); CALL refresh_continuous_aggregate('mat_inval',NULL,NULL); INSERT INTO inval_test SELECT generate_series('2118-12-01 00:00'::timestamp, '2118-12-20 00:00'::timestamp, '1 day'), 'POR', generate_series(135.25, 140.0, 0.25); INSERT INTO inval_test SELECT generate_series('2118-12-01 00:00'::timestamp, '2118-12-20 00:00'::timestamp, '1 day'), 'NYC', generate_series(131.0, 150.0, 1.0); -- Add an integer base table to ensure we handle it correctly CREATE TABLE int_time_test(timeval integer not null, col1 integer, col2 integer); select create_hypertable('int_time_test', 'timeval', chunk_time_interval=> 2); CREATE OR REPLACE FUNCTION integer_now_test() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timeval), 0) FROM public.int_time_test $$; SELECT set_integer_now_func('int_time_test', 'integer_now_test'); INSERT INTO int_time_test VALUES (10, - 4, 1), (11, - 3, 5), (12, - 3, 7), (13, - 3, 9), (14,-4, 11), (15, -4, 22), (16, -4, 23); CREATE MATERIALIZED VIEW mat_inttime WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket( 2, timeval), COUNT(col1) FROM int_time_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW mat_inttime2 WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket( 2, timeval), COUNT(col1) FROM int_time_test GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_inttime', 6, 2, '12 hours'); SELECT add_continuous_aggregate_policy('mat_inttime2', NULL, 2, '12 hours'); CALL refresh_continuous_aggregate('mat_inttime',NULL,NULL); CALL refresh_continuous_aggregate('mat_inttime2',NULL,NULL); -- Test that retention policies that conflict with continuous aggs are disabled -- CREATE TABLE conflict_test (time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION); SELECT create_hypertable('conflict_test', 'time', chunk_time_interval => INTERVAL '1 week'); CREATE MATERIALIZED VIEW mat_conflict WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('10 minute', time) as bucket, location, min(temperature) as min_temp, max(temperature) as max_temp, round(avg(temperature)) as avg_temp FROM conflict_test GROUP BY bucket, location WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_conflict', '28 days', '1 day', '12 hours'); SELECT add_retention_policy('conflict_test', '14 days'::interval) AS retention_jobid \gset SELECT alter_job(:retention_jobid, scheduled=>false); \if :WITH_SUPERUSER GRANT SELECT, TRIGGER, UPDATE ON mat_conflict TO cagg_user WITH GRANT OPTION; \endif -- Test that calling drop chunks on the hypertable does not break the -- update process when chunks are marked as dropped rather than -- removed. This happens when a continuous aggregate is defined on the -- hypertable, so we create a hypertable and a continuous aggregate -- here and then drop chunks from the hypertable and make sure that -- the update from 1.7 to 2.0 works as expected. CREATE TABLE drop_test ( time timestamptz not null, location INT, temperature double PRECISION ); SELECT create_hypertable ('drop_test', 'time', chunk_time_interval => interval '1 week'); INSERT INTO drop_test SELECT time, (random() * 3 + 1)::int, random() * 100.0 FROM generate_series(now() - interval '28 days', now(), '1 hour') AS time; CREATE MATERIALIZED VIEW mat_drop WITH ( timescaledb.materialized_only = TRUE, timescaledb.continuous ) AS SELECT time_bucket ('10 minute',time) AS bucket, LOCATION, min(temperature) AS min_temp, max(temperature) AS max_temp, round(avg(temperature)) AS avg_temp FROM drop_test GROUP BY bucket, LOCATION; SELECT add_continuous_aggregate_policy('mat_drop', '7 days', '-30 days'::interval, '20 min'); CALL refresh_continuous_aggregate('mat_drop',NULL,NULL); SELECT drop_chunks('drop_test', NOW() - INTERVAL '7 days'); RESET timescaledb.enable_chunkwise_aggregation; RESET enable_hashagg; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.databases.sql���������������������������������������������0000664�0000000�0000000�00000000407�15100345067�0023106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE DATABASE single; \c single CREATE EXTENSION IF NOT EXISTS timescaledb; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.drop_meta.sql���������������������������������������������0000664�0000000�0000000�00000000541�15100345067�0023130�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- DROP some chunks to test metadata cleanup \if :WITH_CHUNK DROP TABLE _timescaledb_internal._hyper_1_2_chunk; DROP TABLE _timescaledb_internal._hyper_1_3_chunk; \endif ���������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.fix_sparse_index_migration.sql����������������������������0000664�0000000�0000000�00000002071�15100345067�0026561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Fix wrong migration by removing all sparse index configurations -- which only contain auto sparse indexing definitions on hypertable DO $$ DECLARE rec RECORD; num_config INT; BEGIN IF NOT EXISTS ( SELECT column_name FROM information_schema.columns WHERE table_schema = '_timescaledb_catalog' AND table_name = 'compression_settings' AND column_name = 'index') THEN RETURN; END IF; FOR rec IN SELECT relid, compress_relid, index FROM _timescaledb_catalog.compression_settings WHERE compress_relid IS NULL LOOP num_config:=0; SELECT count(*) INTO num_config FROM jsonb_array_elements(rec.index) AS idx WHERE idx::jsonb @> '{"storage":"config"}'::jsonb; IF num_config = 0 THEN UPDATE _timescaledb_catalog.compression_settings SET index = NULL WHERE relid = rec.relid; END IF; END LOOP; END $$; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.insert_bigint.v1.sql��������������������������������������0000664�0000000�0000000�00000001107�15100345067�0024342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. INSERT INTO public."two_Partitions"("timeCustom", device_id, series_0, series_1, series_2) VALUES (1257987600000000000, 'dev1', 1.5, 1, 1), (1257987600000000000, 'dev1', 1.5, 2, 2), (1257894000000000000, 'dev2', 1.5, 1, 3), (1257894002000000000, 'dev1', 2.5, 3, 4); INSERT INTO "two_Partitions"("timeCustom", device_id, series_0, series_1, series_2) VALUES (1257894000000000000, 'dev2', 1.5, 2, 6); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.insert_bigint.v2.sql��������������������������������������0000664�0000000�0000000�00000001211�15100345067�0024337�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. INSERT INTO public."two_Partitions"("timeCustom", device_id, device_id_2, series_0, series_1, series_2) VALUES (1257987600000000000, 'dev1', 'dev2', 1.5, 2, 2), (1257894000000000000, 'dev2', 'dev2', 1.5, 1, 3), (1257987600000000000, 'dev3', 'dev2', 1.5, 1, 1), (1257894002000000000, 'dev1', 'dev2', 2.5, 3, 4); INSERT INTO "two_Partitions"("timeCustom", device_id, device_id_2, series_0, series_1, series_2) VALUES (1257894100000000000, 'dev2', 'dev2', 1.5, 2, 6); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.insert_timestamp.sql��������������������������������������0000664�0000000�0000000�00000000506�15100345067�0024546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. INSERT INTO hyper_timestamp VALUES ('2017-01-20T09:00:01', 'dev1', 1), ('2017-01-20T08:00:01', 'dev2', 2), ('2016-01-20T09:00:01', 'dev1', 3); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.pg_upgrade.sql��������������������������������������������0000664�0000000�0000000�00000001540�15100345067�0023273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA cagg_join; CREATE TABLE cagg_join.sensor( id SERIAL PRIMARY KEY, name TEXT, enabled BOOLEAN ); CREATE TABLE cagg_join.measurement( sensor_id INTEGER REFERENCES cagg_join.sensor(id), observed TIMESTAMPTZ, value FLOAT ); SELECT create_hypertable('cagg_join.measurement', 'observed'); CREATE MATERIALIZED VIEW cagg_join.measurement_daily WITH (timescaledb.continuous) AS -- Column s.name is functionally dependent on s.id (primary key) SELECT s.id, s.name, time_bucket(interval '1 day', observed) as bucket, avg(value), min(value), max(value) FROM cagg_join.sensor s JOIN cagg_join.measurement m on (s.id = m.sensor_id) GROUP BY s.id, bucket; ����������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.policies.sql����������������������������������������������0000664�0000000�0000000�00000004271�15100345067�0022771�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE policy_test_timestamptz(time timestamptz not null, device_id int, value float); SELECT table_name FROM create_hypertable('policy_test_timestamptz','time'); ALTER TABLE policy_test_timestamptz SET (timescaledb.compress, timescaledb.compress_orderby = '"time" desc'); INSERT INTO policy_test_timestamptz(time, device_id, value) VALUES ('3020-01-01 00:00:00', 1, 1.0); SELECT compress_chunk(show_chunks('policy_test_timestamptz')); DO LANGUAGE PLPGSQL $$ DECLARE ts_major INT; ts_minor INT; BEGIN WITH timescale_version AS ( SELECT string_to_array(extversion,'.') AS v FROM pg_extension WHERE extname = 'timescaledb' ) SELECT v[1], v[2] INTO ts_major, ts_minor FROM timescale_version; PERFORM add_reorder_policy('policy_test_timestamptz','policy_test_timestamptz_time_idx'); PERFORM add_retention_policy('policy_test_timestamptz','60d'::interval); -- some policy API functions got renamed for 2.0 so we need to make -- sure to use the right name for the version. The schedule_interval -- parameter of add_compression_policy was introduced in 2.8.0 IF ts_major = 2 AND ts_minor < 8 THEN PERFORM add_compression_policy('policy_test_timestamptz','10d'::interval); ELSE PERFORM add_compression_policy('policy_test_timestamptz','10d'::interval, schedule_interval => '3 days 12:00:00'::interval); END IF; END $$; \if :WITH_ROLES -- For PostgreSQL 15 and later GRANT ALL ON SCHEMA PUBLIC TO "dotted.name"; GRANT ALL ON SCHEMA PUBLIC TO "Kim Possible"; SET ROLE "dotted.name"; CREATE TABLE policy_test_user_1(time timestamptz not null, device_id int, value float); SELECT table_name FROM create_hypertable('policy_test_user_1','time'); SELECT add_retention_policy('policy_test_user_1', '14 days'::interval); SET ROLE "Kim Possible"; CREATE TABLE policy_test_user_2(time timestamptz not null, device_id int, value float); SELECT table_name FROM create_hypertable('policy_test_user_2','time'); SELECT add_retention_policy('policy_test_user_2', '14 days'::interval); RESET ROLE; \endif ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.post-downgrade.sql����������������������������������������0000664�0000000�0000000�00000002154�15100345067�0024115�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- When running a downgrade tests, the extension is first updated to -- the later version and then downgraded to the previous version. This -- means that in some cases, changes done by the update is not -- reversed by the downgrade. If these changes are harmless, we can -- apply changes to the clean rerun to incorporate these changes -- directly and prevent a diff between the clean-rerun version and the -- upgrade-downgrade version of the database. SELECT split_part(extversion, '.', 1)::int * 100000 + split_part(extversion, '.', 2)::int * 100 AS extversion_num FROM pg_extension WHERE extname = 'timescaledb' \gset SELECT :extversion_num >= 200000 AS has_create_mat_view \gset -- Rebuild the user views based on the renamed views \if :has_create_mat_view ALTER MATERIALIZED VIEW rename_cols SET (timescaledb.materialized_only = FALSE); \else ALTER VIEW rename_cols SET (timescaledb.materialized_only = FALSE); \endif ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.repair.cagg.sql�������������������������������������������0000664�0000000�0000000�00000003706�15100345067�0023346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- We want to check for inconsistent view generation for code coverage but we do not want to check -- for differences between clean and upgraded installation because we only issue warnings instead -- of actually repairing. As a result, if we run update tests instead of repair tests there would -- be differences and the update tests would fail. DO $$ DECLARE ts_version INTEGER; BEGIN SELECT split_part(extversion, '.', 1)::int * 100000 + split_part(extversion, '.', 2)::int * 100 INTO ts_version FROM pg_extension WHERE extname = 'timescaledb'; IF ts_version >= 200000 AND ts_version < 200700 THEN CREATE TABLE conditions_v3 ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); PERFORM create_hypertable('conditions_v3', 'timec'); INSERT INTO conditions_v3 SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 55, 75; INSERT INTO conditions_v3 SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 35, 45; INSERT INTO conditions_v3 SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 73, 55; -- Targets that contain Aggref nodes and Var nodes don't generate correct views before version 2.7.0 CREATE MATERIALIZED VIEW inconsistent_target WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 week', timec) AS bucket, temperature, CASE WHEN temperature < 0 THEN (avg(humidity) + 10) ELSE avg(humidity) END AS problematic_target FROM conditions_v3 GROUP BY bucket, temperature WITH NO DATA; END IF; END $$; ����������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.repair.cagg_joins.sql�������������������������������������0000664�0000000�0000000�00000007405�15100345067�0024550�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT current_setting('server_version_num')::int >= 130000 AS has_cagg_join_using \gset CREATE TABLE ht_cagg_joins( day TIMESTAMPTZ NOT NULL, city text NOT NULL, temperature INT NOT NULL, device_id int NOT NULL); SELECT create_hypertable( 'ht_cagg_joins', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO ht_cagg_joins (day, city, temperature, device_id) VALUES ('2021-06-14 00:00:00-00'::timestamptz, 'Moscow', 26,1), ('2021-06-15 00:00:00-00'::timestamptz, 'Moscow', 22,2), ('2021-06-16 00:00:00-00'::timestamptz, 'Berlin', 24,3), ('2021-06-17 00:00:00-00'::timestamptz, 'London', 24,4), ('2021-06-18 00:00:00-00'::timestamptz, 'Stockholm', 27,4), ('2021-06-19 00:00:00-00'::timestamptz, 'Moscow', 28,4), ('2021-06-20 00:00:00-00'::timestamptz, 'Stockholm', 30,1), ('2021-06-21 00:00:00-00'::timestamptz, 'London', 31,1), ('2021-06-22 00:00:00-00'::timestamptz, 'Stockholm', 34,1), ('2021-06-23 00:00:00-00'::timestamptz, 'Moscow', 34,2), ('2021-06-24 00:00:00-00'::timestamptz, 'London', 34,2), ('2021-06-25 00:00:00-00'::timestamptz, 'Stockholm', 32,3), ('2021-06-26 00:00:00-00'::timestamptz, 'Berlin', 32,3), ('2021-06-27 00:00:00-00'::timestamptz, 'Stockholm', 31,3); CREATE TABLE nt_cagg_joins ( device_id int not null, name text, location text); INSERT INTO nt_cagg_joins values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); --Create a cagg with join between a hypertable and a normal table -- with equality condition on inner join type and realtime aggregation enabled CREATE MATERIALIZED VIEW cagg_joins_upgrade_test_with_realtime WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ht_cagg_joins JOIN nt_cagg_joins ON ht_cagg_joins.device_id = nt_cagg_joins.device_id GROUP BY 1,3; --Create a cagg with join between a hypertable and a normal table -- with equality condition on inner join type and realtime aggregation disabled CREATE MATERIALIZED VIEW cagg_joins_upgrade_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ht_cagg_joins JOIN nt_cagg_joins ON ht_cagg_joins.device_id = nt_cagg_joins.device_id GROUP BY 1,3; --Create a Cagg with JOIN and additional WHERE conditions CREATE MATERIALIZED VIEW cagg_joins_where WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ht_cagg_joins JOIN nt_cagg_joins ON ht_cagg_joins.device_id = nt_cagg_joins.device_id WHERE ht_cagg_joins.city = nt_cagg_joins.location GROUP BY 1,3; -- Only test joins with using clause for postgresql versions above 12 \if :has_cagg_join_using --Create a cagg with join with using clause and realtime aggregation enabled CREATE MATERIALIZED VIEW cagg_joins_upgrade_test_with_realtime_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ht_cagg_joins JOIN nt_cagg_joins USING (device_id) GROUP BY 1,3; --Create a cagg with join with using and realtime aggregation disabled CREATE MATERIALIZED VIEW cagg_joins_upgrade_test_using WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ht_cagg_joins JOIN nt_cagg_joins USING (device_id) GROUP BY 1,3; \endif �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.repair.hierarchical_cagg.sql������������������������������0000664�0000000�0000000�00000002567�15100345067�0026050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE test ( timestamp TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, value INT NOT NULL, CONSTRAINT uk_test_timestamp_device_id UNIQUE (timestamp, device_id) ); SELECT create_hypertable('test', 'timestamp'); INSERT INTO test (timestamp, device_id, value) VALUES ('2023-05-01 00:00:00+00', 'sensor0', 1), ('2023-05-15 00:00:00+00', 'sensor0', 2), ('2023-05-31 00:00:00+00', 'sensor0', 10); CREATE MATERIALIZED VIEW agg_test_hourly WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour'::interval, timestamp) AS hour_timestamp, device_id, SUM(value) FROM test GROUP BY hour_timestamp, device_id WITH DATA; CREATE MATERIALIZED VIEW agg_test_daily WITH (timescaledb.continuous) AS SELECT time_bucket('1 day'::interval, hour_timestamp) AS day_timestamp, device_id, SUM(sum) FROM agg_test_hourly GROUP BY day_timestamp, device_id WITH DATA; CREATE MATERIALIZED VIEW agg_test_monthly WITH (timescaledb.continuous) AS SELECT time_bucket('1 month'::interval, day_timestamp) AS month_timestamp, device_id, SUM(sum) FROM agg_test_daily GROUP BY month_timestamp, device_id WITH DATA; �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.repair.sql������������������������������������������������0000664�0000000�0000000�00000006525�15100345067�0022450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test file to check that the repair script works. It will create a -- bunch of tables and "break" them by removing dimension slices from -- the dimension slice table. The repair script should then repair all -- of them and there should be no dimension slices missing. CREATE USER wizard; CREATE USER "Random L User"; CREATE TABLE repair_test_int(time integer not null, temp float8, tag integer, color integer); CREATE TABLE repair_test_timestamptz(time timestamptz not null, temp float8, tag integer, color integer); CREATE TABLE repair_test_extra(time timestamptz not null, temp float8, tag integer, color integer); CREATE TABLE repair_test_timestamp(time timestamp not null, temp float8, tag integer, color integer); CREATE TABLE repair_test_date(time date not null, temp float8, tag integer, color integer); -- We only break the dimension slice table if there is repair that is -- going to be done, but we create the tables regardless so that we -- can compare the databases. SELECT create_hypertable('repair_test_int', 'time', 'tag', 2, chunk_time_interval => '3'::bigint); SELECT create_hypertable('repair_test_timestamptz', 'time', 'tag', 2, chunk_time_interval => '1 day'::interval); SELECT create_hypertable('repair_test_extra', 'time', 'tag', 2, chunk_time_interval => '1 day'::interval); SELECT create_hypertable('repair_test_timestamp', 'time', 'tag', 2, chunk_time_interval => '1 day'::interval); SELECT create_hypertable('repair_test_date', 'time', 'tag', 2, chunk_time_interval => '1 day'::interval); -- These rows will create four constraints for each table. INSERT INTO repair_test_int VALUES (4, 24.3, 1, 1), (4, 24.3, 2, 1), (10, 24.3, 2, 1); INSERT INTO repair_test_timestamptz VALUES ('2020-01-01 10:11:12', 24.3, 1, 1), ('2020-01-01 10:11:13', 24.3, 2, 1), ('2020-01-02 10:11:14', 24.3, 2, 1); INSERT INTO repair_test_extra VALUES ('2020-01-01 10:11:12', 24.3, 1, 1), ('2020-01-01 10:11:13', 24.3, 2, 1), ('2020-01-02 10:11:14', 24.3, 2, 1); INSERT INTO repair_test_timestamp VALUES ('2020-01-01 10:11:12', 24.3, 1, 1), ('2020-01-01 10:11:13', 24.3, 2, 1), ('2020-01-02 10:11:14', 24.3, 2, 1); INSERT INTO repair_test_date VALUES ('2020-01-01 10:11:12', 24.3, 1, 1), ('2020-01-01 10:11:13', 24.3, 2, 1), ('2020-01-02 10:11:14', 24.3, 2, 1); -- We always drop the constraint and restore it in the -- post.repair.sql. -- -- This way if there are constraint violations remaining that wasn't -- repaired properly, we will notice them when restoring the -- constraint. ALTER TABLE _timescaledb_catalog.chunk_constraint DROP CONSTRAINT chunk_constraint_dimension_slice_id_fkey; -- Grant privileges to some tables above. All should be repaired. GRANT ALL ON repair_test_int TO wizard; GRANT ALL ON repair_test_extra TO wizard; GRANT SELECT, INSERT ON repair_test_int TO "Random L User"; GRANT INSERT ON repair_test_extra TO "Random L User"; -- Break the relacl of the table by deleting users directly from -- pg_authid table. DELETE FROM pg_authid WHERE rolname IN ('wizard', 'Random L User'); \ir setup.repair.cagg.sql \ir setup.repair.hierarchical_cagg.sql \ir setup.repair.cagg_joins.sql ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.roles.sql�������������������������������������������������0000664�0000000�0000000�00000000627�15100345067�0022307�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE ROLE cagg_user; CREATE USER tsdbadmin; -- These are used to test job creation and updating job owners. CREATE USER "dotted.name"; --non-identifier character in name CREATE USER "Kim Possible"; --case-sensitive names ���������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.sparse_index.sql������������������������������������������0000664�0000000�0000000�00000002607�15100345067�0023647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test a table with auto sparse indexes CREATE TABLE bloom ( x INT, v1 TEXT, u UUID, ts TIMESTAMP ); SELECT create_hypertable('bloom', 'x'); INSERT INTO bloom SELECT x, md5(x::text), CASE WHEN x = 7134 THEN '90ec9e8e-4501-4232-9d03-6d7cf6132815' ELSE '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid END, '2021-01-01'::timestamp + (INTERVAL '1 hour') * x FROM generate_series(1, 10000) x; CREATE INDEX ON bloom USING brin(v1 text_bloom_ops); CREATE INDEX ON bloom USING brin(u uuid_bloom_ops); CREATE INDEX ON bloom USING brin(ts timestamp_minmax_ops); ALTER TABLE bloom SET ( timescaledb.compress, timescaledb.compress_segmentby = 'v1', timescaledb.compress_orderby = 'x' ); SELECT COUNT(compress_chunk(x)) FROM show_chunks('bloom') x; VACUUM FULL ANALYZE bloom; SELECT * FROM _timescaledb_catalog.compression_settings; SELECT schema_name || '.' || table_name AS chunk FROM _timescaledb_catalog.chunk WHERE id = ( SELECT compressed_chunk_id FROM _timescaledb_catalog.chunk WHERE hypertable_id = ( SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'bloom' ) LIMIT 1 ) \gset \d+ :chunk�������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.timestamp.sql���������������������������������������������0000664�0000000�0000000�00000002000�15100345067�0023151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test a hypertable using timestamps CREATE TABLE PUBLIC.hyper_timestamp ( time timestamp NOT NULL, device_id TEXT NOT NULL, value int NOT NULL ); DO $$ BEGIN IF (EXISTS (SELECT FROM pg_proc WHERE proname = 'interval_to_usec' AND pronamespace='_timescaledb_internal'::regnamespace)) THEN PERFORM create_hypertable('hyper_timestamp'::regclass, 'time'::name, 'device_id'::name, number_partitions => 2, chunk_time_interval=> _timescaledb_internal.interval_to_usec('1 minute')); ELSE PERFORM create_hypertable('hyper_timestamp'::regclass, 'time'::name, 'device_id'::name, number_partitions => 2, chunk_time_interval=> _timescaledb_functions.interval_to_usec('1 minute')); END IF; END; $$; --some old versions use more slice_ids than newer ones. Make this uniform CALL _timescaledb_testing.restart_dimension_slice_id(); timescaledb-2.23.0/test/sql/updates/setup.v10.sql���������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0021563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir setup.v9.sql \ir setup.sparse_index.sql \ir setup.fix_sparse_index_migration.sql ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.v7.sql����������������������������������������������������0000664�0000000�0000000�00000001125�15100345067�0021511�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir setup.catalog.sql \ir setup.bigint.sql \ir setup.constraints.sql \ir setup.insert_bigint.v2.sql \ir setup.timestamp.sql ALTER TABLE PUBLIC.hyper_timestamp ADD CONSTRAINT exclude_const EXCLUDE USING btree ( "time" WITH =, device_id WITH = ) WHERE (value > 0); \ir setup.insert_timestamp.sql \ir setup.drop_meta.sql \ir setup.continuous_aggs.sql \ir setup.compression.sql \ir setup.policies.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.v8.sql����������������������������������������������������0000664�0000000�0000000�00000000310�15100345067�0021505�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir setup.v7.sql ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/updates/setup.v9.sql����������������������������������������������������0000664�0000000�0000000�00000000345�15100345067�0021516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \ir setup.v8.sql \ir setup.chunk_skipping.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/upsert.sql��������������������������������������������������������������0000664�0000000�0000000�00000040410�15100345067�0017673�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE upsert_test(time timestamp PRIMARY KEY, temp float, color text); SELECT create_hypertable('upsert_test', 'time'); INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 22.5, 'yellow') RETURNING *; INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 23.8, 'yellow') ON CONFLICT (time) DO UPDATE SET temp = 23.8 RETURNING *; INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 78.4, 'yellow') ON CONFLICT DO NOTHING; SELECT * FROM upsert_test; -- Test 'Tuples Inserted' and 'Conflicting Tuples' values in EXPLAIN ANALYZE EXPLAIN (VERBOSE, ANALYZE, BUFFERS FALSE, COSTS FALSE, TIMING FALSE, SUMMARY FALSE) INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 28.5, 'blue'), ('2017-01-20T09:00:01', 21.9, 'red'), ('2017-01-20T10:00:01', 2.4, 'pink') ON CONFLICT DO NOTHING; -- Test ON CONFLICT ON CONSTRAINT INSERT INTO upsert_test VALUES ('2017-01-20T09:00:01', 12.3, 'yellow') ON CONFLICT ON CONSTRAINT upsert_test_pkey DO UPDATE SET temp = 12.3 RETURNING time, temp, color; -- Test that update generates error on conflicts \set ON_ERROR_STOP 0 INSERT INTO upsert_test VALUES ('2017-01-21T09:00:01', 22.5, 'yellow') RETURNING *; UPDATE upsert_test SET time = '2017-01-20T09:00:01'; \set ON_ERROR_STOP 1 -- Test with UNIQUE index on multiple columns instead of PRIMARY KEY constraint CREATE TABLE upsert_test_unique(time timestamp, temp float, color text); SELECT create_hypertable('upsert_test_unique', 'time'); CREATE UNIQUE INDEX time_color_idx ON upsert_test_unique (time, color); INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 22.5, 'yellow') RETURNING *; INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 21.2, 'brown'); SELECT * FROM upsert_test_unique ORDER BY time, color DESC; INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 31.8, 'yellow') ON CONFLICT (time, color) DO UPDATE SET temp = 31.8; INSERT INTO upsert_test_unique VALUES ('2017-01-20T09:00:01', 54.3, 'yellow') ON CONFLICT DO NOTHING; SELECT * FROM upsert_test_unique ORDER BY time, color DESC; -- Test with multiple UNIQUE indexes CREATE TABLE upsert_test_multi_unique(time timestamp, temp float, color text); SELECT create_hypertable('upsert_test_multi_unique', 'time'); ALTER TABLE upsert_test_multi_unique ADD CONSTRAINT multi_time_temp UNIQUE (time, temp); CREATE UNIQUE INDEX multi_time_color_idx ON upsert_test_multi_unique (time, color); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'yellow'); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-21T09:00:01', 25.9, 'yellow'); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 23.5, 'brown'); INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT DO NOTHING; SELECT * FROM upsert_test_multi_unique ORDER BY time, color DESC; INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'blue') ON CONFLICT (time, temp) DO UPDATE SET color = 'blue'; INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 23.5, 'orange') ON CONFLICT ON CONSTRAINT multi_time_temp DO UPDATE SET color = excluded.color; SELECT * FROM upsert_test_multi_unique ORDER BY time, color DESC; INSERT INTO upsert_test_multi_unique VALUES ('2017-01-21T09:00:01', 45.7, 'yellow') ON CONFLICT (time, color) DO UPDATE SET temp = 45.7; SELECT * FROM upsert_test_multi_unique ORDER BY time, color DESC; \set ON_ERROR_STOP 0 -- Here the constraint in the ON CONFLICT clause is not the one that is -- actually violated by the INSERT, so it should still fail. INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 23.5, 'purple') ON CONFLICT (time, color) DO UPDATE set temp = 23.5; INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 22.5, 'orange') ON CONFLICT ON CONSTRAINT multi_time_temp DO UPDATE set color = 'orange'; \set ON_ERROR_STOP 1 CREATE TABLE upsert_test_space(time timestamp, device_id_1 char(20), to_drop int, temp float, color text); --drop two columns; create one. ALTER TABLE upsert_test_space DROP to_drop; ALTER TABLE upsert_test_space DROP device_id_1, ADD device_id char(20); ALTER TABLE upsert_test_space ADD CONSTRAINT time_space_constraint UNIQUE (time, device_id); SELECT create_hypertable('upsert_test_space', 'time', 'device_id', 2, partitioning_func=>'_timescaledb_functions.get_partition_for_key'::regproc); INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 25.9, 'yellow') RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 25.9, 'yellow'); INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 23.5, 'green') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 23.5, 'orange') ON CONFLICT ON CONSTRAINT time_space_constraint DO UPDATE SET color = excluded.color; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 23.5, 'orange3') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color||' (originally '|| upsert_test_space.color ||')' RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev3', 23.5, 'orange3.1') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color||' (originally '|| upsert_test_space.color ||')' RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 23.5, 'orange4') ON CONFLICT (time, device_id) DO NOTHING RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev4', 23.5, 'orange5') ON CONFLICT (time, device_id) DO NOTHING RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange5') ON CONFLICT (time, device_id) DO NOTHING RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange6') ON CONFLICT ON CONSTRAINT time_space_constraint DO NOTHING RETURNING *; --restore a column with the same name as a previously deleted one; ALTER TABLE upsert_test_space ADD device_id_1 char(20); INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_1) VALUES ('2017-01-20T09:00:01', 'dev4', 23.5, 'orange5.1', 'dev-id-1') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color||' (originally '|| upsert_test_space.color ||')' RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange6') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color WHERE upsert_test_space.temp < 20 RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 23.5, 'orange7') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color WHERE excluded.temp < 20 RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 3.5, 'orange7') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color, temp=excluded.temp WHERE excluded.temp < 20 RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8') ON CONFLICT (time, device_id) DO UPDATE SET color = excluded.color WHERE upsert_test_space.temp < 20 RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_1) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-1-new') ON CONFLICT (time, device_id) DO UPDATE SET device_id_1 = excluded.device_id_1 RETURNING *; INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_1) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-1-new') ON CONFLICT (time, device_id) DO UPDATE SET device_id_1 = 'device-id-1-new-2', color = 'orange9' RETURNING *; SELECT * FROM upsert_test_space; ALTER TABLE upsert_test_space DROP device_id_1, ADD device_id_2 char(20); INSERT INTO upsert_test_space (time, device_id, temp, color, device_id_2) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-2') ON CONFLICT (time, device_id) DO UPDATE SET device_id_2 = 'device-id-2-new', color = 'orange10' RETURNING *; --test inserting to to a chunk already in the chunk dispatch cache again. INSERT INTO upsert_test_space as current (time, device_id, temp, color, device_id_2) VALUES ('2017-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-2'), ('2018-01-20T09:00:01', 'dev5', 43.5, 'orange8', 'device-id-2'), ('2017-01-20T09:00:01', 'dev3', 43.5, 'orange7', 'device-id-2'), ('2018-01-21T09:00:01', 'dev5', 43.5, 'orange9', 'device-id-2') ON CONFLICT (time, device_id) DO UPDATE SET device_id_2 = coalesce(excluded.device_id_2,current.device_id_2), color = coalesce(excluded.color,current.color) RETURNING *; WITH CTE AS ( INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT DO NOTHING RETURNING * ) SELECT 1; WITH CTE AS ( INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple'), ('2017-01-20T09:00:01', 29.9, 'purple1') ON CONFLICT DO NOTHING RETURNING * ) SELECT * FROM CTE; WITH CTE AS ( INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'blue') ON CONFLICT (time, temp) DO UPDATE SET color = 'blue' RETURNING * ) SELECT * FROM CTE; --test error conditions when an index is dropped on a chunk DROP INDEX _timescaledb_internal._hyper_3_3_chunk_multi_time_color_idx; --everything is ok if not used as an arbiter index INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT DO NOTHING RETURNING *; --errors out if used as an arbiter index \set ON_ERROR_STOP 0 INSERT INTO upsert_test_multi_unique VALUES ('2017-01-20T09:00:01', 25.9, 'purple') ON CONFLICT (time, color) DO NOTHING RETURNING *; \set ON_ERROR_STOP 1 --create table with one chunk that has a tup_conv_map and one that does not --to ensure this, create a chunk before altering the table this chunk will not have a tup_conv_map CREATE TABLE upsert_test_diffchunk(time timestamp, device_id char(20), to_drop int, temp float, color text); SELECT create_hypertable('upsert_test_diffchunk', 'time', chunk_time_interval=> interval '1 month'); CREATE UNIQUE INDEX time_device_idx ON upsert_test_diffchunk (time, device_id); --this is the chunk with no tup_conv_map INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev1', 25.9, 'yellow') RETURNING *; INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2017-01-20T09:00:01', 'dev2', 25.9, 'yellow') RETURNING *; --alter the table ALTER TABLE upsert_test_diffchunk DROP to_drop; ALTER TABLE upsert_test_diffchunk ADD device_id_2 char(20); --new chunk that does have a tup conv map INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2019-01-20T09:00:01', 'dev1', 23.5, 'orange') ; INSERT INTO upsert_test_diffchunk (time, device_id, temp, color) VALUES ('2019-01-20T09:00:01', 'dev2', 23.5, 'orange') ; select * from upsert_test_diffchunk order by time, device_id; --make sure current works INSERT INTO upsert_test_diffchunk as current (time, device_id, temp, color, device_id_2) VALUES ('2019-01-20T09:00:01', 'dev1', 43.5, 'orange2', 'device-id-2'), ('2017-01-20T09:00:01', 'dev1', 43.5, 'yellow2', 'device-id-2'), ('2019-01-20T09:00:01', 'dev2', 43.5, 'orange2', 'device-id-2') ON CONFLICT (time, device_id) DO UPDATE SET device_id_2 = coalesce(excluded.device_id_2,current.device_id_2), temp = coalesce(excluded.temp,current.temp) , color = coalesce(excluded.color,current.color); select * from upsert_test_diffchunk order by time, device_id; --arbiter index tests CREATE TABLE upsert_test_arbiter(time timestamp, to_drop int); SELECT create_hypertable('upsert_test_arbiter', 'time', chunk_time_interval=> interval '1 month'); --this is the chunk with no tup_conv_map INSERT INTO upsert_test_arbiter (time, to_drop) VALUES ('2017-01-20T09:00:01', 1) RETURNING *; INSERT INTO upsert_test_arbiter (time, to_drop) VALUES ('2017-01-21T09:00:01', 2) RETURNING *; INSERT INTO upsert_test_arbiter (time, to_drop) VALUES ('2017-03-20T09:00:01', 3) RETURNING *; --alter the table ALTER TABLE upsert_test_arbiter DROP to_drop; ALTER TABLE upsert_test_arbiter ADD device_id char(20) DEFAULT 'dev1'; CREATE UNIQUE INDEX arbiter_time_device_idx ON upsert_test_arbiter (time, device_id); INSERT INTO upsert_test_arbiter as current (time, device_id) VALUES ('2018-01-21T09:00:01', 'dev1'), ('2017-01-20T09:00:01', 'dev1'), ('2017-01-21T09:00:01', 'dev2'), ('2018-01-21T09:00:01', 'dev2') ON CONFLICT (time, device_id) DO UPDATE SET device_id = coalesce(excluded.device_id,current.device_id) RETURNING *; with cte as ( INSERT INTO upsert_test_arbiter (time, device_id) VALUES ('2017-01-21T09:00:01', 'dev2'), ('2018-01-21T09:00:01', 'dev2') ON CONFLICT (time, device_id) DO UPDATE SET device_id = 'dev3' RETURNING *) select * from cte; -- test ON CONFLICT with prepared statements CREATE TABLE prepared_test(time timestamptz PRIMARY KEY, value float CHECK(value > 0)); SELECT create_hypertable('prepared_test','time'); CREATE TABLE source_data(time timestamptz PRIMARY KEY, value float); INSERT INTO source_data VALUES('2000-01-01',0.5), ('2001-01-01',0.5); -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the prepared statement 10 times -- check that an error in the prepared statement does not lead to the plan becoming unusable PREPARE prep_insert_select AS INSERT INTO prepared_test select * from source_data ON CONFLICT (time) DO UPDATE SET value = EXCLUDED.value; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; EXECUTE prep_insert_select; --this insert will create an invalid tuple in source_data --so that future calls to prep_insert_select will fail INSERT INTO source_data VALUES('2000-01-02',-0.5); \set ON_ERROR_STOP 0 EXECUTE prep_insert_select; EXECUTE prep_insert_select; \set ON_ERROR_STOP 1 DELETE FROM source_data WHERE value <= 0; EXECUTE prep_insert_select; PREPARE prep_insert AS INSERT INTO prepared_test VALUES('2000-01-01',0.5) ON CONFLICT (time) DO UPDATE SET value = EXCLUDED.value; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the prepared statement 10 times EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; EXECUTE prep_insert; SELECT * FROM prepared_test; DELETE FROM prepared_test; -- test ON CONFLICT with functions CREATE OR REPLACE FUNCTION test_upsert(t timestamptz, v float) RETURNS VOID AS $sql$ BEGIN INSERT INTO prepared_test VALUES(t,v) ON CONFLICT (time) DO UPDATE SET value = EXCLUDED.value; END; $sql$ LANGUAGE PLPGSQL; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the function 10 times SELECT counter,test_upsert('2000-01-01',0.5) FROM generate_series(1,10) AS g(counter); SELECT * FROM prepared_test; DELETE FROM prepared_test; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the function 10 times SELECT counter,test_upsert('2000-01-01',0.5) FROM generate_series(1,10) AS g(counter); SELECT * FROM prepared_test; DELETE FROM prepared_test; -- run it again to ensure INSERT path is still working as well SELECT counter,test_upsert('2000-01-01',0.5) FROM generate_series(1,10) AS g(counter); SELECT * FROM prepared_test; DELETE FROM prepared_test; -- test ON CONFLICT with functions CREATE OR REPLACE FUNCTION test_upsert2(t timestamptz, v float) RETURNS VOID AS $sql$ BEGIN INSERT INTO prepared_test VALUES(t,v) ON CONFLICT (time) DO UPDATE SET value = prepared_test.value + 1.0; END; $sql$ LANGUAGE PLPGSQL; -- at some point PostgreSQL will turn the plan into a generic plan -- so we execute the function 10 times SELECT counter,test_upsert2('2000-01-01',1.0) FROM generate_series(1,10) AS g(counter); SELECT * FROM prepared_test; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/util.sql����������������������������������������������������������������0000664�0000000�0000000�00000007612�15100345067�0017335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. \set ECHO errors \set VERBOSITY default \c :TEST_DBNAME :ROLE_SUPERUSER \set TMP_USER :TEST_DBNAME _wizard DO $$ BEGIN ASSERT( _timescaledb_functions.get_partition_for_key(''::text) = 669664877 ); ASSERT( _timescaledb_functions.get_partition_for_key('dev1'::text) = 1129986420 ); ASSERT( _timescaledb_functions.get_partition_for_key('longlonglonglongpartitionkey'::text) = 1169179734); END$$; \pset null '[NULL]' CREATE USER :TMP_USER; SELECT * FROM ( VALUES (_timescaledb_functions.makeaclitem(:'TMP_USER', :'TMP_USER', 'insert', false)), (_timescaledb_functions.makeaclitem(:'TMP_USER', :'TMP_USER', 'insert,select', false)), (_timescaledb_functions.makeaclitem(:'TMP_USER', :'TMP_USER', 'insert', true)), (_timescaledb_functions.makeaclitem(:'TMP_USER', :'TMP_USER', 'insert,select', true)), (_timescaledb_functions.makeaclitem(NULL, :'TMP_USER', 'insert,select', true)), (_timescaledb_functions.makeaclitem(:'TMP_USER', NULL, 'insert,select', true)), (_timescaledb_functions.makeaclitem(:'TMP_USER', :'TMP_USER', NULL, true)), (_timescaledb_functions.makeaclitem(:'TMP_USER', :'TMP_USER', 'insert,select', NULL)), (_timescaledb_functions.makeaclitem(0, :'TMP_USER', 'insert,select', true)), (_timescaledb_functions.makeaclitem(:'TMP_USER', 0, 'insert,select', true)) ) AS t(item); DROP USER :TMP_USER; CREATE TABLE data (vid serial, rng text); INSERT INTO data(rng) VALUES ('["2025-04-25 11:10:00+02","2025-04-25 11:14:00+02"]'), ('["2025-04-25 11:10:00+02","2025-04-25 11:17:00+02"]'), ('["2025-04-25 11:10:00+02","2025-04-25 11:20:00+02")'); \set ECHO all SELECT _timescaledb_functions.align_to_bucket('5 minutes'::interval, rng::tstzrange) FROM data; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.align_to_bucket(null, null); SELECT _timescaledb_functions.align_to_bucket(null::interval, null::tstzrange); SELECT _timescaledb_functions.align_to_bucket( null::interval, '["2025-04-25 11:10:00+02","2025-04-25 11:14:00+02"]'::tstzrange ); \set ON_ERROR_STOP 1 SELECT typ, _timescaledb_functions.get_internal_time_min(typ), _timescaledb_functions.get_internal_time_max(typ) FROM (VALUES ('bigint'::regtype), ('int'::regtype), ('smallint'::regtype), ('timestamp'::regtype), ('timestamptz'::regtype), ('date'::regtype), (null::regtype) ) t(typ); \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.get_internal_time_min(0); SELECT _timescaledb_functions.get_internal_time_max(0); \set ON_ERROR_STOP 1 WITH tstzranges AS ( SELECT vid, rng::tstzrange, lower(rng::tstzrange) AS lower_ts, upper(rng::tstzrange) AS upper_ts FROM data ), usecranges AS ( SELECT vid, _timescaledb_functions.to_unix_microseconds(lower_ts) AS lower_usec, _timescaledb_functions.to_unix_microseconds(upper_ts) AS upper_usec FROM tstzranges ) SELECT _timescaledb_functions.make_multirange_from_internal_time(rng, lower_usec, upper_usec), _timescaledb_functions.make_range_from_internal_time(rng, lower_ts, upper_ts) FROM tstzranges join usecranges using (vid); WITH tsranges AS ( SELECT vid, rng::tsrange, lower(rng::tsrange) AS lower_ts, upper(rng::tsrange) AS upper_ts FROM data ), usecranges AS ( SELECT vid, _timescaledb_functions.to_unix_microseconds(lower_ts) AS lower_usec, _timescaledb_functions.to_unix_microseconds(upper_ts) AS upper_usec FROM tsranges ) SELECT _timescaledb_functions.make_multirange_from_internal_time(rng, lower_usec, upper_usec), _timescaledb_functions.make_range_from_internal_time(rng, lower_ts, upper_ts) FROM tsranges join usecranges using (vid); ����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016771�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/pg_dump_aux_dump.sh�����������������������������������������������0000775�0000000�0000000�00000000704�15100345067�0022666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DUMPFILE=${DUMPFILE:-$1} EXTRA_PGOPTIONS=${EXTRA_PGOPTIONS:-$2} # Override PGOPTIONS to remove verbose output PGOPTIONS="--client-min-messages=warning $EXTRA_PGOPTIONS" export PGOPTIONS ${PG_BINDIR}/pg_dump -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} -Fc ${TEST_DBNAME} > /dev/null 2>&1 -f ${DUMPFILE} ${PG_BINDIR}/dropdb -f -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} ${TEST_DBNAME} ${PG_BINDIR}/createdb -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} ${TEST_DBNAME} ������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/pg_dump_aux_plain_dump.sh�����������������������������������������0000775�0000000�0000000�00000001250�15100345067�0024046�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DUMPFILE=${DUMPFILE:-$1} EXTRA_PGOPTIONS=${EXTRA_PGOPTIONS:-$2} DUMP_OPTIONS=${DUMP_OPTIONS:-$3} # Override PGOPTIONS to remove verbose output PGOPTIONS="--client-min-messages=warning $EXTRA_PGOPTIONS" export PGOPTIONS echo ${DUMP_OPTIONS} echo $DUMP_OPTIONS echo $(echo $DUMP_OPTIONS) ${PG_BINDIR}/pg_dump -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} ${DUMP_OPTIONS} -Fp ${TEST_DBNAME} -f ${DUMPFILE} # ${PG_BINDIR}/pg_dump -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} ${DUMP_OPTIONS} -Fp ${TEST_DBNAME} > /dev/null 2>&1 -f ${DUMPFILE} ${PG_BINDIR}/dropdb -f -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} ${TEST_DBNAME} ${PG_BINDIR}/createdb -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} ${TEST_DBNAME} ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/pg_dump_aux_restore.sh��������������������������������������������0000775�0000000�0000000�00000000444�15100345067�0023405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DUMPFILE=${DUMPFILE:-$1} # Override PGOPTIONS to remove verbose output PGOPTIONS='--client-min-messages=warning' export PGOPTIONS # Redirect output to /dev/null to suppress NOTICE ${PG_BINDIR}/pg_restore -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} -d ${TEST_DBNAME} ${DUMPFILE} > /dev/null 2>&1 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/pg_dump_unprivileged.sh�������������������������������������������0000775�0000000�0000000�00000000326�15100345067�0023541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������export PGOPTIONS PGOPTIONS='--client-min-messages=warning' ${PG_BINDIR}/pg_dump -h ${PGHOST} -U dump_unprivileged dump_unprivileged > /dev/null 2>&1 if [ $? -eq 0 ]; then echo "Database dumped successfully" fi ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/test_fatal_command.sh���������������������������������������������0000775�0000000�0000000�00000000246�15100345067�0023156�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������DB=$1 COMMAND=$2 ${PG_BINDIR}/psql -X -h ${PGHOST} -U ${TEST_ROLE_SUPERUSER} -d ${DB} --command="${COMMAND}" 2>&1 | grep -v CONTEXT | grep -v "extension script file" ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/testsupport.sql���������������������������������������������������0000664�0000000�0000000�00000031454�15100345067�0022135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE SCHEMA IF NOT EXISTS test; GRANT USAGE ON SCHEMA test TO PUBLIC; -- Utility functions to show relation information in tests. These -- functions generate output which is the same across PostgreSQL -- versions. Their usage is preferred over psql's '\d <relation>', -- since that output typically changes across PostgreSQL versions. -- this function is duplicated in test/isolation/specs/multi_transaction_indexing.spec -- if it changes, that copy may need to change as well CREATE OR REPLACE FUNCTION test.show_columns(rel regclass) RETURNS TABLE("Column" name, "Type" text, "NotNull" boolean) LANGUAGE SQL STABLE AS $BODY$ SELECT a.attname, format_type(t.oid, t.typtypmod), a.attnotnull FROM pg_attribute a, pg_type t WHERE a.attrelid = rel AND a.atttypid = t.oid AND a.attnum >= 0 ORDER BY a.attnum; $BODY$; CREATE OR REPLACE FUNCTION test.show_columnsp(pattern text) RETURNS TABLE("Relation" regclass, "Kind" "char", "Column" name, "Column type" text, "NotNull" boolean) LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE schema_name name = split_part(pattern, '.', 1); table_name name = split_part(pattern, '.', 2); BEGIN IF schema_name = '' OR table_name = '' THEN schema_name := current_schema(); table_name := pattern; END IF; RETURN QUERY SELECT c.oid::regclass, c.relkind, a.attname, format_type(t.oid, t.typtypmod), a.attnotnull FROM pg_class c, pg_attribute a, pg_type t WHERE format('%I.%I', c.relnamespace::regnamespace::name, c.relname) LIKE format('%I.%s', schema_name, table_name) AND a.attrelid = c.oid AND a.atttypid = t.oid AND a.attnum >= 0 ORDER BY c.relname, a.attnum; END $BODY$; CREATE OR REPLACE FUNCTION test.show_indexes(rel regclass) RETURNS TABLE("Index" regclass, "Columns" name[], "Expr" text, "Unique" boolean, "Primary" boolean, "Exclusion" boolean, "Tablespace" name) LANGUAGE SQL STABLE AS $BODY$ SELECT c.oid::regclass, array(SELECT "Column" FROM test.show_columns(i.indexrelid)), pg_get_expr(i.indexprs, c.oid, true), i.indisunique, i.indisprimary, i.indisexclusion, (SELECT t.spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) FROM pg_class c, pg_index i WHERE c.oid = i.indexrelid AND i.indrelid = rel ORDER BY c.relname; $BODY$; CREATE OR REPLACE FUNCTION test.show_indexespred(rel regclass) RETURNS TABLE("Index" regclass, "Columns" name[], "Expr" text, "Pred" text, "Unique" boolean, "Primary" boolean, "Exclusion" boolean, "Tablespace" name) LANGUAGE SQL STABLE AS $BODY$ SELECT c.oid::regclass, array(SELECT "Column" FROM test.show_columns(i.indexrelid)), pg_get_expr(i.indexprs, i.indrelid, true), pg_get_expr(i.indpred, i.indrelid, true), i.indisunique, i.indisprimary, i.indisexclusion, (SELECT t.spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) FROM pg_class c, pg_index i WHERE c.oid = i.indexrelid AND i.indrelid = rel ORDER BY c.relname; $BODY$; -- this function is duplicated in test/isolation/specs/multi_transaction_indexing.spec -- if it changes, that copy may need to change as well CREATE OR REPLACE FUNCTION test.show_indexesp(pattern text) RETURNS TABLE("Table" regclass, "Index" regclass, "Columns" name[], "Expr" text, "Unique" boolean, "Primary" boolean, "Exclusion" boolean, "Tablespace" name) LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE schema_name name = split_part(pattern, '.', 1); table_name name = split_part(pattern, '.', 2); BEGIN IF schema_name = '' OR table_name = '' THEN schema_name := current_schema(); table_name := pattern; END IF; RETURN QUERY SELECT c.oid::regclass, i.indexrelid::regclass, array(SELECT "Column" FROM test.show_columns(i.indexrelid)), pg_get_expr(i.indexprs, c.oid, true), i.indisunique, i.indisprimary, i.indisexclusion, (SELECT t.spcname FROM pg_class cc, pg_tablespace t WHERE cc.oid = i.indexrelid AND t.oid = cc.reltablespace) FROM pg_class c, pg_index i WHERE format('%I.%I', c.relnamespace::regnamespace::name, c.relname) LIKE format('%I.%s', schema_name, table_name) AND c.oid = i.indrelid ORDER BY c.oid, i.indexrelid; END $BODY$; CREATE OR REPLACE FUNCTION test.show_constraints(rel regclass) RETURNS TABLE("Constraint" name, "Type" "char", "Columns" name[], "Index" regclass, "Expr" text, "Deferrable" bool, "Deferred" bool, "Validated" bool) LANGUAGE SQL STABLE AS $BODY$ SELECT c.conname, c.contype, array(SELECT attname FROM pg_attribute a, unnest(conkey) k WHERE a.attrelid = rel AND k = a.attnum), c.conindid::regclass, pg_get_expr(c.conbin, c.conrelid), c.condeferrable, c.condeferred, c.convalidated FROM pg_constraint c WHERE c.conrelid = rel -- to avoid showing not null constraints which are new to PG18 -- https://github.com/postgres/postgres/commit/14e87ffa AND c.conname NOT LIKE '%not_null%' ORDER BY c.conname; $BODY$; CREATE OR REPLACE FUNCTION test.show_constraintsp(pattern text) RETURNS TABLE("Table" regclass, "Constraint" name, "Type" "char", "Columns" name[], "Index" regclass, "Expr" text, "Deferrable" bool, "Deferred" bool, "Validated" bool) LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE schema_name name = split_part(pattern, '.', 1); table_name name = split_part(pattern, '.', 2); BEGIN IF schema_name = '' OR table_name = '' THEN schema_name := current_schema(); table_name := pattern; END IF; RETURN QUERY SELECT cl.oid::regclass, c.conname, c.contype, array(SELECT attname FROM pg_attribute a, unnest(conkey) k WHERE a.attrelid = cl.oid AND k = a.attnum), c.conindid::regclass, pg_get_expr(c.conbin, c.conrelid), c.condeferrable, c.condeferred, c.convalidated FROM pg_class cl, pg_constraint c WHERE format('%I.%I', cl.relnamespace::regnamespace::name, cl.relname) LIKE format('%I.%s', schema_name, table_name) -- to avoid showing not null constraints which are new to PG18 -- https://github.com/postgres/postgres/commit/14e87ffa AND c.conname NOT LIKE '%not_null%' AND c.conrelid = cl.oid ORDER BY cl.relname, c.conname; END $BODY$; CREATE OR REPLACE FUNCTION test.show_triggers(rel regclass, show_internal boolean = false) RETURNS TABLE("Trigger" name, "Type" smallint, "Function" regproc) LANGUAGE SQL STABLE AS $BODY$ SELECT t.tgname, t.tgtype, t.tgfoid::regproc FROM pg_trigger t WHERE t.tgrelid = rel AND t.tgisinternal = show_internal ORDER BY t.tgname; $BODY$; CREATE OR REPLACE FUNCTION test.show_triggersp(pattern text, show_internal boolean = false) RETURNS TABLE("Table" regclass, "Trigger" name, "Type" smallint, "Function" regproc) LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE schema_name name = split_part(pattern, '.', 1); table_name name = split_part(pattern, '.', 2); BEGIN IF schema_name = '' OR table_name = '' THEN schema_name := current_schema(); table_name := pattern; END IF; RETURN QUERY SELECT t.tgrelid::regclass, t.tgname, t.tgtype, t.tgfoid::regproc FROM pg_class cl, pg_trigger t WHERE format('%I.%I', cl.relnamespace::regnamespace::name, cl.relname) LIKE format('%I.%s', schema_name, table_name) AND t.tgrelid = cl.oid AND t.tgisinternal = show_internal ORDER BY t.tgrelid, t.tgname; END $BODY$; CREATE OR REPLACE FUNCTION test.show_subtables(rel regclass) RETURNS TABLE("Child" regclass, "Tablespace" name) LANGUAGE SQL STABLE AS $BODY$ SELECT objid::regclass, (SELECT t.spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) FROM pg_depend d, pg_class c WHERE d.refobjid = rel AND d.deptype = 'n' AND d.classid = 'pg_class'::regclass AND d.objid = c.oid ORDER BY d.refobjid, d.objid; $BODY$; CREATE OR REPLACE FUNCTION test.show_subtablesp(pattern text) RETURNS TABLE("Parent" regclass, "Child" regclass, "Tablespace" name) LANGUAGE PLPGSQL STABLE AS $BODY$ DECLARE schema_name name = split_part(pattern, '.', 1); table_name name = split_part(pattern, '.', 2); BEGIN IF schema_name = '' OR table_name = '' THEN schema_name := current_schema(); table_name := pattern; END IF; RETURN QUERY SELECT refobjid::regclass, objid::regclass, (SELECT t.spcname FROM pg_class cc, pg_tablespace t WHERE cc.oid = d.objid AND t.oid = cc.reltablespace) FROM pg_class c, pg_depend d WHERE format('%I.%I', c.relnamespace::regnamespace::name, c.relname) LIKE format('%I.%s', schema_name, table_name) AND d.refobjid = c.oid AND d.deptype = 'n' AND d.classid = 'pg_class'::regclass ORDER BY d.refobjid, d.objid; END $BODY$; CREATE OR REPLACE FUNCTION test.execute_sql(cmd TEXT) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ BEGIN EXECUTE cmd; RETURN cmd; END $BODY$; -- Used to set a deterministic memory setting during tests CREATE OR REPLACE FUNCTION test.set_memory_cache_size(memory_amount text) RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_set_memory_cache_size' LANGUAGE C VOLATILE STRICT; CREATE OR REPLACE FUNCTION test.make_tablespace_path(prefix TEXT, test_name TEXT) RETURNS TEXT LANGUAGE plpgsql AS $BODY$ DECLARE mkdirFlag TEXT := CASE WHEN sysname = 'Windows' THEN '' ELSE '-p ' END FROM _timescaledb_functions.get_os_info(); dirPath TEXT := format('%s%s', prefix, test_name); createDir TEXT := format('mkdir %s%s', mkdirFlag, dirPath); BEGIN EXECUTE format('COPY (SELECT 1) TO PROGRAM %s', quote_literal(createDir)); RETURN dirPath; END; $BODY$; -- Wait for job to execute with success or failure CREATE OR REPLACE FUNCTION test.wait_for_job_to_run(job_param_id INTEGER, expected_runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r RECORD; BEGIN FOR i in 1..spins LOOP SELECT total_successes, total_failures FROM _timescaledb_internal.bgw_job_stat WHERE job_id=job_param_id INTO r; IF (r.total_failures > 0) THEN RAISE INFO 'wait_for_job_to_run: job execution failed'; RETURN false; ELSEIF (r.total_successes = expected_runs) THEN RETURN true; ELSEIF (r.total_successes > expected_runs) THEN RAISE 'num_runs > expected'; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RAISE INFO 'wait_for_job_to_run: timeout after % tries', spins; RETURN false; END $BODY$; -- Wait for job to run or fail CREATE OR REPLACE FUNCTION test.wait_for_job_to_run_or_fail(job_param_id INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE r RECORD; BEGIN FOR i in 1..spins LOOP SELECT total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=job_param_id INTO r; IF (r.total_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RAISE INFO 'wait_for_job_to_run_or_fail: timeout after % tries', spins; RETURN false; END $BODY$; CREATE OR REPLACE VIEW test.extension AS SELECT e.extname AS "Name", e.extversion AS "Version", n.nspname AS "Schema", c.description AS "Description" FROM pg_extension e LEFT JOIN pg_namespace n ON n.oid = e.extnamespace LEFT JOIN pg_description c ON c.objoid = e.oid AND c.classoid = 'pg_extension'::regclass ORDER BY 1; GRANT SELECT ON test.extension TO PUBLIC; -- View to replace \dt commands in tests for consistent output across PostgreSQL versions CREATE OR REPLACE VIEW test.relation AS SELECT n.nspname AS schema, c.relname AS name, CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' WHEN 'f' THEN 'foreign table' WHEN 'p' THEN 'partitioned table' ELSE c.relkind::text END AS type, pg_catalog.pg_get_userbyid(c.relowner) AS owner FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relkind IN ('r','p','v','m','f','') AND n.nspname <> 'information_schema' AND n.nspname <> 'pg_catalog' AND n.nspname !~ '^pg_toast' ORDER BY 1, 2; GRANT SELECT ON test.relation TO PUBLIC; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/utils/testsupport_init.sql����������������������������������������������0000664�0000000�0000000�00000000675�15100345067�0023161�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. SELECT _timescaledb_functions.stop_background_workers(); -- Cleanup any system job stats that can lead to flaky test DELETE FROM _timescaledb_internal.bgw_job_stat_history WHERE job_id < 1000; DELETE FROM _timescaledb_internal.bgw_job_stat WHERE job_id < 1000; �������������������������������������������������������������������timescaledb-2.23.0/test/sql/uuid.sql����������������������������������������������������������������0000664�0000000�0000000�00000022031�15100345067�0017316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- -- -- Test "time" partitioning on UUIDv7 -- -- CREATE TABLE uuid_events(id uuid primary key, device int, temp float); \set ON_ERROR_STOP 0 -- Test invalid interval type SELECT create_hypertable('uuid_events', 'id', chunk_time_interval => true); \set ON_ERROR_STOP 1 SELECT create_hypertable('uuid_events', 'id', chunk_time_interval => interval '1 day'); -- -- Test that inserting boundary values generates the right constraints -- on chunks. -- -- First value with min time: 00000000-0000-7000-8000-000000000000 BEGIN; INSERT INTO uuid_events VALUES ('00000000-0000-7000-8000-000000000000', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; SELECT uuid_timestamp(id), device, temp FROM uuid_events ORDER BY id; -- Update v7 UUID to a v4 UUID that doesn't violate the chunk's range -- constraint. Currently we don't prevent this "loophole". UPDATE uuid_events SET id = '00000000-0001-4000-8000-000000000000' WHERE id = '00000000-0000-7000-8000-000000000000'; SELECT uuid_timestamp(id), device, temp FROM uuid_events ORDER BY id; -- Update v7 UUID to a v4 that violates the chunk constraint: \set ON_ERROR_STOP 0 UPDATE uuid_events SET id = 'ffff0000-0000-4000-8000-000000000000' WHERE id = '00000000-0001-4000-8000-000000000000'; \set ON_ERROR_STOP 1 ROLLBACK; -- Last value with min time: 00000000-0000-7fff-bfff-ffffffffffff BEGIN; INSERT INTO uuid_events VALUES ('00000000-0000-7fff-bfff-ffffffffffff', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; ROLLBACK; -- First value with max time: ffffffff-ffff-7000-8000-000000000000 BEGIN; INSERT INTO uuid_events VALUES ('ffffffff-ffff-7000-8000-000000000000', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; ROLLBACK; -- (Max time with min value) + 1 BEGIN; INSERT INTO uuid_events VALUES ('ffffffff-ffff-7000-8000-000000000001', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; ROLLBACK; -- Last value with max time: ffffffff-ffff-7fff-bfff-ffffffffffff BEGIN; INSERT INTO uuid_events VALUES ('ffffffff-ffff-7fff-bfff-ffffffffffff', 1, 1.0); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; ROLLBACK; -- -- It is possible to generate UUIDs like follows, but the random -- generator used doesn't respect setseed() so used constant UUIDs for -- determinism. -- -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-01 01:00 PST'), 1, 1.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-01 02:00 PST'), 2, 2.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-02 01:00 PST'), 3, 3.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-02 02:00 PST'), 4, 4.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-03 03:00 PST'), 5, 5.0), -- (_timescaledb_functions.uuid_v7_from_timestamptz('2025-01-03 10:00 PST'), 6, 6.0); -- INSERT INTO uuid_events VALUES ('0194214e-cd00-7000-a9a7-63f1416dab45', 2, 2.0), ('01942117-de80-7000-8121-f12b2b69dd96', 1, 1.0), ('0194263e-3a80-7000-8f40-82c987b1bc1f', 3, 3.0), ('01942675-2900-7000-8db1-a98694b18785', 4, 4.0), ('01942bd2-7380-7000-9bc4-5f97443907b8', 5, 5.0), ('01942d52-f900-7000-866e-07d6404d53c1', 6, 6.0); SELECT * FROM show_chunks('uuid_events'); SELECT (test.show_constraints(ch)).* from show_chunks('uuid_events') ch; SELECT id, device, temp FROM uuid_events; SELECT uuid_timestamp(id), device, temp FROM uuid_events; SELECT uuid_timestamp(id), device, temp FROM uuid_events ORDER BY id; SELECT _timescaledb_functions.to_timestamp(range_start) AS range_start, _timescaledb_functions.to_timestamp(range_end) AS range_end FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.dimension d ON (ds.dimension_id = d.id) JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.table_name = 'uuid_events'; SELECT _timescaledb_functions.to_timestamp(range_start) AS chunk_range_start, _timescaledb_functions.to_timestamp(range_end) AS chunk_range_end FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.dimension d ON (ds.dimension_id = d.id) JOIN _timescaledb_catalog.hypertable h ON (d.hypertable_id = h.id) WHERE h.table_name = 'uuid_events' LIMIT 1 OFFSET 1 \gset -- Test that chunk exclusion on uuidv7 column works SELECT :'chunk_range_start', to_uuidv7_boundary(:'chunk_range_start'); -- Exclude all but one chunk EXPLAIN (verbose, buffers off, costs off, timing off) SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_start'); SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_start'); -- Exclude only one chunk. Add ordering (DESC) EXPLAIN (verbose, buffers off, costs off, timing off) SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_end') ORDER BY id DESC; SELECT uuid_timestamp(id), device, temp FROM uuid_events WHERE id < to_uuidv7_boundary(:'chunk_range_end') ORDER BY id DESC; CREATE VIEW chunk_ranges AS SELECT chunk_name, _timescaledb_functions.to_timestamp(range_start_integer) AS range_start, _timescaledb_functions.to_timestamp(range_end_integer) AS range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'uuid_events'; SELECT * FROM chunk_ranges; SELECT show_chunks('uuid_events', older_than => INTERVAL '1 day'); SELECT show_chunks('uuid_events', older_than => '2025-01-02'); SELECT show_chunks('uuid_events', newer_than => '2025-01-02'); SELECT drop_chunks('uuid_events', older_than => '2025-01-02'); SELECT show_chunks('uuid_events'); -- Insert non-v7 UUIDs \set ON_ERROR_STOP 0 INSERT INTO uuid_events SELECT 'a8961135-cd89-4c4b-aa05-79df642407dd', 5, 5.0; \set ON_ERROR_STOP 1 -- Insert as v7 UUID and later change to non-v7 to show effect on show_chunks() -- and drop_chunks() INSERT INTO uuid_events SELECT 'a8961135-cd89-7000-aa05-79df642407dd', 5, 5.0; SELECT * FROM chunk_ranges; UPDATE uuid_events SET id = 'a8961135-cd89-4c4b-aa05-79df642407dd' WHERE id = 'a8961135-cd89-7000-aa05-79df642407dd'; SELECT show_chunks('uuid_events', newer_than => '2025-01-02'); SELECT drop_chunks('uuid_events', newer_than => '2025-01-02'); SELECT * FROM chunk_ranges; INSERT INTO uuid_events SELECT to_uuidv7(now()), 6, 6.0; SELECT show_chunks('uuid_events', newer_than => INTERVAL '2 months'); SELECT drop_chunks('uuid_events', newer_than => INTERVAL '2 months'); SELECT show_chunks('uuid_events', newer_than => INTERVAL '2 months'); DROP TABLE uuid_events; BEGIN; -- Test UUID partition when using CREATE TABLE ... WITH CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ) WITH ( tsdb.hypertable, tsdb.partition_column='event_id', tsdb.chunk_interval='2 hours' ); -- Verify that the chunk time interval is two hours SELECT ((interval_length/1000000)/60)/60 AS hours FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; ROLLBACK; -- Test a different interval BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ) WITH ( tsdb.hypertable, tsdb.partition_column='event_id', tsdb.chunk_interval='2 months' ); -- Verify that the chunk time interval is two hours SELECT (((interval_length/1000000)/60)/60)/24 AS days FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; ROLLBACK; -- Verify same behavior without CREATE TABLE WITH: BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ); SELECT create_hypertable('events', 'event_id', chunk_time_interval => interval '2 hours'); -- Verify that the chunk time interval is two hours SELECT ((interval_length/1000000)/60)/60 AS hours FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ); SELECT create_hypertable('events', 'event_id', chunk_time_interval => interval '2 months'); -- Verify that the chunk time interval is two hours SELECT (((interval_length/1000000)/60)/60)/24 AS days FROM _timescaledb_catalog.dimension d JOIN _timescaledb_catalog.hypertable h ON (h.id = d.hypertable_id) WHERE h.table_name='events'; ROLLBACK; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/vacuum.sql��������������������������������������������������������������0000664�0000000�0000000�00000014567�15100345067�0017667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE TABLE vacuum_test(time timestamp, temp float); -- create hypertable with three chunks SELECT create_hypertable('vacuum_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); INSERT INTO vacuum_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); -- no stats SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'vacuum_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); VACUUM ANALYZE vacuum_test; -- stats should exist for all three chunks SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); -- stats should exist on parent hypertable SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'vacuum_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); DROP TABLE vacuum_test; --test plain analyze (no_vacuum) CREATE TABLE analyze_test(time timestamp, temp float); SELECT create_hypertable('analyze_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); INSERT INTO analyze_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); -- no stats SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'analyze_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); ANALYZE analyze_test; -- stats should exist for all three chunks SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); -- stats should exist on parent hypertable SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' AND tablename LIKE 'analyze_test' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); DROP TABLE analyze_test; -- Run vacuum on a normal (non-hypertable) table CREATE TABLE vacuum_norm(time timestamp, temp float); INSERT INTO vacuum_norm VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); VACUUM ANALYZE vacuum_norm; DROP TABLE vacuum_norm; --Similar to normal vacuum tests, but PG11 introduced ability to vacuum multiple tables at once, we make sure that works for hypertables as well. CREATE TABLE vacuum_test(time timestamp, temp float); -- create hypertable with three chunks SELECT create_hypertable('vacuum_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); INSERT INTO vacuum_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); CREATE TABLE analyze_test(time timestamp, temp float); SELECT create_hypertable('analyze_test', 'time', chunk_time_interval => 2628000000000, create_default_indexes => false); INSERT INTO analyze_test VALUES ('2017-01-20T16:00:01', 17.5), ('2017-01-21T16:00:01', 19.1), ('2017-04-20T16:00:01', 89.5), ('2017-04-21T16:00:01', 17.1), ('2017-06-20T16:00:01', 18.5), ('2017-06-21T16:00:01', 11.0); CREATE TABLE vacuum_norm(time timestamp, temp float); INSERT INTO vacuum_norm VALUES ('2017-01-20T09:00:01', 17.5), ('2017-01-21T09:00:01', 19.1), ('2017-04-20T09:00:01', 89.5), ('2017-04-21T09:00:01', 17.1), ('2017-06-20T09:00:01', 18.5), ('2017-06-21T09:00:01', 11.0); -- no stats SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); VACUUM ANALYZE vacuum_norm, vacuum_test, analyze_test; -- stats should exist for all 6 chunks SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = '_timescaledb_internal' AND tablename LIKE '_hyper_%_chunk' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); -- stats should exist on parent hypertable and normal table SELECT tablename, attname, histogram_bounds, n_distinct FROM pg_stats WHERE schemaname = 'public' ORDER BY tablename, attname, array_to_string(histogram_bounds, ','); �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/vacuum_parallel.sql�����������������������������������������������������0000664�0000000�0000000�00000003457�15100345067�0021537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- PG13 introduced parallel VACUUM functionality. It gets invoked when a table -- has two or more indexes on it. Read up more at -- https://www.postgresql.org/docs/13/sql-vacuum.html#PARALLEL CREATE TABLE vacuum_test(time timestamp NOT NULL, temp1 float, temp2 int); -- create hypertable -- we create chunks in public schema cause otherwise we would need -- elevated privileges to create indexes directly SELECT create_hypertable('vacuum_test', 'time', create_default_indexes => false, associated_schema_name => 'public'); -- parallel vacuum needs the index size to be larger than min_parallel_index_scan_size to kick in SET min_parallel_index_scan_size TO 0; INSERT INTO vacuum_test SELECT TIMESTAMP 'epoch' + (i * INTERVAL '4h'), i, i+1 FROM generate_series(1, 100) as T(i); -- create indexes on the temp columns -- we create indexes manually because otherwise vacuum verbose output -- would be different between 13.2 and 13.3+ -- 13.2 would try to vacuum the parent table index too while 13.3+ wouldn't CREATE INDEX ON _hyper_1_1_chunk(time); CREATE INDEX ON _hyper_1_1_chunk(temp1); CREATE INDEX ON _hyper_1_1_chunk(temp2); CREATE INDEX ON _hyper_1_2_chunk(time); CREATE INDEX ON _hyper_1_2_chunk(temp1); CREATE INDEX ON _hyper_1_2_chunk(temp2); CREATE INDEX ON _hyper_1_3_chunk(time); CREATE INDEX ON _hyper_1_3_chunk(temp1); CREATE INDEX ON _hyper_1_3_chunk(temp2); -- INSERT only will not trigger vacuum on indexes for PG13.3+ UPDATE vacuum_test SET time = time + '1s'::interval, temp1 = random(), temp2 = random(); -- we should see two parallel workers for each chunk VACUUM (PARALLEL 3) vacuum_test; DROP TABLE vacuum_test; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/sql/version.sql�������������������������������������������������������������0000664�0000000�0000000�00000000574�15100345067�0020045�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. -- Test that get_os_info returns 3 x text select pg_typeof(sysname) AS sysname_type,pg_typeof(version) AS version_type,pg_typeof(release) AS release_type from _timescaledb_functions.get_os_info(); ������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015621�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/CMakeLists.txt����������������������������������������������������������0000664�0000000�0000000�00000001672�15100345067�0020367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES adt_tests.c metadata.c symbol_conflict.c test_scanner.c test_time_to_internal.c test_time_utils.c test_tss_callbacks.c test_utils.c test_with_clause_parser.c) include(${PROJECT_SOURCE_DIR}/src/build-defs.cmake) add_library(${TESTS_LIB_NAME} OBJECT ${SOURCES}) # Since the test library will be linked into the loadable extension module, it # needs to be compiled as position-independent code (e.g., the -fPIC compiler # flag for GCC) set_target_properties(${TESTS_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON) # Set the MODULE_NAME for the symbol conflict test (see symbol_conflict.c) target_compile_definitions(${TESTS_LIB_NAME} PUBLIC MODULE_NAME=timescaledb) target_include_directories(${TESTS_LIB_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) add_subdirectory(bgw) add_subdirectory(net) if(USE_TELEMETRY) add_subdirectory(telemetry) endif() add_subdirectory(loader) ����������������������������������������������������������������������timescaledb-2.23.0/test/src/adt_tests.c�������������������������������������������������������������0000664�0000000�0000000�00000007760�15100345067�0017771�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include "export.h" #include "test_utils.h" TS_FUNCTION_INFO_V1(ts_test_adts); #define VEC_PREFIX int32 #define VEC_ELEMENT_TYPE int32 #define VEC_DECLARE 1 #define VEC_DEFINE 1 #define VEC_SCOPE static inline #include <adts/vec.h> /* We have to stub this for the unit tests. */ #ifndef CheckCompressedData #define CheckCompressedData(X) Assert(X) #define GLOBAL_MAX_ROWS_PER_COMPRESSION 1015 #endif #include <adts/bit_array.h> static void i32_vec_test(void) { int32_vec *vec = int32_vec_create(CurrentMemoryContext, 0); int i; uint32 old_capacity; for (i = 0; i < 100; i++) int32_vec_append(vec, i); TestAssertInt64Eq(vec->num_elements, 100); if (vec->max_elements < 100) elog(ERROR, "vec capacity %d, should be at least 100", vec->max_elements); for (i = 0; i < 100; i++) TestAssertInt64Eq(*int32_vec_at(vec, i), i); TestAssertPtrEq(int32_vec_last(vec), int32_vec_at(vec, vec->num_elements - 1)); old_capacity = vec->max_elements; int32_vec_delete_range(vec, 30, 19); TestAssertInt64Eq(vec->num_elements, 81); TestAssertInt64Eq(vec->max_elements, old_capacity); for (i = 0; i < 30; i++) TestAssertInt64Eq(*int32_vec_at(vec, i), i); for (; i < 51; i++) TestAssertInt64Eq(*int32_vec_at(vec, i), i + 19); TestAssertPtrEq(int32_vec_last(vec), int32_vec_at(vec, vec->num_elements - 1)); int32_vec_clear(vec); TestAssertInt64Eq(vec->num_elements, 0); TestAssertInt64Eq(vec->max_elements, old_capacity); int32_vec_free_data(vec); TestAssertInt64Eq(vec->num_elements, 0); TestAssertInt64Eq(vec->max_elements, 0); TestAssertPtrEq(vec->data, NULL); /* free_data is idempotent */ int32_vec_free_data(vec); TestAssertInt64Eq(vec->num_elements, 0); TestAssertInt64Eq(vec->max_elements, 0); TestAssertPtrEq(vec->data, NULL); int32_vec_free(vec); } /* including BitArray should give us uint64_vec */ static void uint64_vec_test(void) { uint64_vec vec; int i; uint64_vec_init(&vec, CurrentMemoryContext, 100); for (i = 0; i < 30; i++) uint64_vec_append(&vec, i + 3); TestAssertInt64Eq(vec.num_elements, 30); TestAssertInt64Eq(vec.max_elements, 100); for (i = 0; i < 30; i++) TestAssertInt64Eq(*uint64_vec_at(&vec, i), i + 3); uint64_vec_free_data(&vec); TestAssertInt64Eq(vec.num_elements, 0); TestAssertInt64Eq(vec.max_elements, 0); TestAssertPtrEq(vec.data, NULL); } static void bit_array_test(void) { BitArray bits; BitArrayIterator iter; int i; bit_array_init(&bits, 0); for (i = 0; i < 65; i++) bit_array_append(&bits, i, i); bit_array_append(&bits, 0, 0); bit_array_append(&bits, 0, 0); bit_array_append(&bits, 64, 0x9069060909009090); bit_array_append(&bits, 1, 0); bit_array_append(&bits, 64, ~0x9069060909009090); bit_array_append(&bits, 1, 1); bit_array_iterator_init(&iter, &bits); for (i = 0; i < 65; i++) TestAssertInt64Eq(bit_array_iter_next(&iter, i), i); TestAssertInt64Eq(bit_array_iter_next(&iter, 0), 0); TestAssertInt64Eq(bit_array_iter_next(&iter, 0), 0); TestAssertInt64Eq(bit_array_iter_next(&iter, 64), 0x9069060909009090); TestAssertInt64Eq(bit_array_iter_next(&iter, 1), 0); TestAssertInt64Eq(bit_array_iter_next(&iter, 64), ~0x9069060909009090); TestAssertInt64Eq(bit_array_iter_next(&iter, 1), 1); bit_array_iterator_init_rev(&iter, &bits); TestAssertInt64Eq(bit_array_iter_next_rev(&iter, 1), 1); TestAssertInt64Eq(bit_array_iter_next_rev(&iter, 64), ~0x9069060909009090); TestAssertInt64Eq(bit_array_iter_next_rev(&iter, 1), 0); TestAssertInt64Eq(bit_array_iter_next_rev(&iter, 64), 0x9069060909009090); TestAssertInt64Eq(bit_array_iter_next_rev(&iter, 0), 0); TestAssertInt64Eq(bit_array_iter_next_rev(&iter, 0), 0); for (i = 64; i >= 0; i--) TestAssertInt64Eq(bit_array_iter_next_rev(&iter, i), i); } Datum ts_test_adts(PG_FUNCTION_ARGS) { i32_vec_test(); uint64_vec_test(); bit_array_test(); PG_RETURN_VOID(); } ����������������timescaledb-2.23.0/test/src/bgw/��������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016400�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/CMakeLists.txt������������������������������������������������������0000664�0000000�0000000�00000000524�15100345067�0021141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/log.c ${CMAKE_CURRENT_SOURCE_DIR}/timer_mock.c ${CMAKE_CURRENT_SOURCE_DIR}/scheduler_mock.c ${CMAKE_CURRENT_SOURCE_DIR}/params.c ${CMAKE_CURRENT_SOURCE_DIR}/test_job_refresh.c ${CMAKE_CURRENT_SOURCE_DIR}/test_job_utils.c) target_sources(${TESTS_LIB_NAME} PRIVATE ${SOURCES}) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/README.md�����������������������������������������������������������0000664�0000000�0000000�00000003677�15100345067�0017674�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Background Worker Test Infrastructure This directory contains mocks and hooks to enable testing of timescale background workers. There are three main components: a counter-based timer used to test the scheduler in a deterministic manner; a scheduler that inserts test shims to the background worker and understands the tests we will run; and shims to dynamically set time and intercept background worker output. ## Output Background workers started by the test scheduler contain a hook storing all `elog` and `ereport` output in the table ```SQL public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT, ) ``` which must be created in order for tests to check background worker output. `msg_no` contains which message this was in the total-order of all background worker messages sent since the table was created; `mock_time` is the virtualized timestamp ([see that section](## Timer)) at which the message was written; `application_name` the name of the application that wrote the message; `msg` is the messgage string itself. See [`log.c`](log.c) for more detail. (We want to print more data from `ErrorData` at a later date) ## Timer We virtualize the timer to allow deterministic execution by tests. Our timer store a virtual microsecond counter in shared memory, backround processes can read this counter to determine the current time. The scheduler can "wait" on this timer which optionally waits for a process to finish and updates the counter to the waited time. The timer can be reset manually (for instance, to allow multiple tests in one file) with `ts_bgw_params_reset_time`). See [`timer_mock.c`](timer_mock.c) for more detail. ## Configuration Settings and the timer for background worker tests are stored in shared memory. This memory segment must be created with `ts_bgw_params_create` before use. see [params.c](params.c) and [params.h](params.h) for more detail. �����������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/log.c���������������������������������������������������������������0000664�0000000�0000000�00000006607�15100345067�0017336�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/namespace.h> #include <postmaster/bgworker.h> #include <storage/proc.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/snapmgr.h> #include "log.h" #include "params.h" #include "scanner.h" #include "ts_catalog/catalog.h" #include "utils.h" #include "compat/compat.h" static char *bgw_application_name = "unset"; void ts_bgw_log_set_application_name(char *name) { bgw_application_name = name; } static bool bgw_log_insert_relation(Relation rel, char *msg) { TupleDesc desc = RelationGetDescr(rel); static int32 msg_no = 0; Datum values[4]; bool nulls[4] = { false, false, false }; values[0] = Int32GetDatum(msg_no++); values[1] = Int64GetDatum((int64) ts_params_get()->current_time); values[2] = CStringGetTextDatum(bgw_application_name); values[3] = CStringGetTextDatum(msg); ts_catalog_insert_values(rel, desc, values, nulls); return true; } /* Insert a new entry into public.bgw_log * This table is used for testing as a way for mock background jobs * to insert messages into a log that could then be output into the golden file */ static void bgw_log_insert(char *msg) { Relation rel; PushActiveSnapshot(GetTransactionSnapshot()); Oid log_oid = ts_get_relation_relid("public", "bgw_log", false); rel = table_open(log_oid, RowExclusiveLock); bgw_log_insert_relation(rel, msg); table_close(rel, RowExclusiveLock); PopActiveSnapshot(); } static emit_log_hook_type prev_emit_log_hook = NULL; /* * NOTE: using transactions in emit_log_hook functions is not recommended. * However we rely on this current functionality for our test verifications, * so have to live with it for now. */ static void emit_log_hook_callback(ErrorData *edata) { /* * once proc_exit has started we may no longer be able to start transactions */ if (MyProc == NULL) return; /* * Block signals so we don't lose messages generated during signal * processing if they occur while we are saving this log message (since * emit_log_hook is modified and restored below) */ BackgroundWorkerBlockSignals(); PG_TRY(); { /* * If we do encounter some error writing to our log hook, remove the * hook to prevent potentially infinite recursion where this callback * keeps encountering an error, and it is its own logging callback. We * reinstall the hook when we're successfully done with this function. */ emit_log_hook = NULL; bool started_txn = false; if (!IsTransactionState()) { StartTransactionCommand(); started_txn = true; } bgw_log_insert(edata->message); if (started_txn) CommitTransactionCommand(); if (prev_emit_log_hook != NULL) prev_emit_log_hook(edata); /* Reinstall the hook if log was successful. */ emit_log_hook = emit_log_hook_callback; } PG_CATCH(); { /* If there was an error, rollback what was done before the error */ if (IsTransactionState()) AbortCurrentTransaction(); /* * Reinstall the hook because we are out of the main body of the * function. */ emit_log_hook = emit_log_hook_callback; } PG_END_TRY(); BackgroundWorkerUnblockSignals(); } void ts_register_emit_log_hook() { prev_emit_log_hook = emit_log_hook; emit_log_hook = emit_log_hook_callback; } �������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/log.h���������������������������������������������������������������0000664�0000000�0000000�00000000461�15100345067�0017333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once extern void ts_bgw_log_set_application_name(char *name); extern void ts_register_emit_log_hook(void); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/params.c������������������������������������������������������������0000664�0000000�0000000�00000014063�15100345067�0020033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/relscan.h> #include <access/xact.h> #include <catalog/namespace.h> #include <storage/bufmgr.h> #include <storage/dsm.h> #include <storage/lmgr.h> #include <storage/spin.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include "log.h" #include "params.h" #include "scanner.h" #include "test_utils.h" #include "timer_mock.h" #include "ts_catalog/catalog.h" #include "utils.h" typedef struct FormData_bgw_dsm_handle { /* handle is actually a uint32 */ int64 handle; } FormData_bgw_dsm_handle; typedef struct TestParamsWrapper { TestParams params; slock_t mutex; } TestParamsWrapper; static Oid get_dsm_handle_table_oid() { return ts_get_relation_relid("public", "bgw_dsm_handle_store", false); } static void params_register_dsm_handle(dsm_handle handle) { Relation rel; TableScanDesc scan; HeapTuple tuple; FormData_bgw_dsm_handle *fd; rel = table_open(get_dsm_handle_table_oid(), RowExclusiveLock); scan = table_beginscan(rel, SnapshotSelf, 0, NULL); tuple = heap_copytuple(heap_getnext(scan, ForwardScanDirection)); fd = (FormData_bgw_dsm_handle *) GETSTRUCT(tuple); fd->handle = handle; ts_catalog_update(rel, tuple); heap_freetuple(tuple); table_endscan(scan); table_close(rel, RowExclusiveLock); } static dsm_handle params_load_dsm_handle() { Relation rel; TableScanDesc scan; HeapTuple tuple; FormData_bgw_dsm_handle *fd; dsm_handle handle; rel = table_open(get_dsm_handle_table_oid(), RowExclusiveLock); scan = table_beginscan(rel, SnapshotSelf, 0, NULL); tuple = heap_getnext(scan, ForwardScanDirection); TestAssertTrue(tuple != NULL); tuple = heap_copytuple(tuple); fd = (FormData_bgw_dsm_handle *) GETSTRUCT(tuple); handle = fd->handle; heap_freetuple(tuple); table_endscan(scan); table_close(rel, RowExclusiveLock); return handle; } static dsm_handle params_get_dsm_handle() { static dsm_handle handle = 0; if (handle == 0) handle = params_load_dsm_handle(); return handle; } static TestParamsWrapper * params_open_wrapper(bool *do_close) { dsm_segment *seg; dsm_handle handle = params_get_dsm_handle(); TestParamsWrapper *wrapper; /* * If segment is returned via the mapping then there's no need to call * dsm_detach on it in params_close_wrapper */ seg = dsm_find_mapping(handle); if (seg == NULL) { seg = dsm_attach(handle); if (seg == NULL) elog(ERROR, "got NULL segment in params_open_wrapper"); *do_close = true; } else *do_close = false; TestAssertTrue(seg != NULL); wrapper = dsm_segment_address(seg); TestAssertTrue(wrapper != NULL); return wrapper; }; static void params_close_wrapper(TestParamsWrapper *wrapper) { dsm_segment *seg = dsm_find_mapping(params_get_dsm_handle()); TestAssertTrue(seg != NULL); dsm_detach(seg); } TestParams * ts_params_get() { bool do_close; TestParamsWrapper *wrapper = params_open_wrapper(&do_close); TestParams *res; TestAssertTrue(wrapper != NULL); res = palloc(sizeof(TestParams)); SpinLockAcquire(&wrapper->mutex); memcpy(res, &wrapper->params, sizeof(TestParams)); SpinLockRelease(&wrapper->mutex); if (do_close) params_close_wrapper(wrapper); return res; }; void ts_params_set_time(int64 new_val, bool set_latch) { bool do_close; TestParamsWrapper *wrapper = params_open_wrapper(&do_close); TestAssertTrue(wrapper != NULL); SpinLockAcquire(&wrapper->mutex); wrapper->params.current_time = new_val; SpinLockRelease(&wrapper->mutex); if (set_latch) SetLatch(&wrapper->params.timer_latch); if (do_close) params_close_wrapper(wrapper); } void ts_initialize_timer_latch() { bool do_close; TestParamsWrapper *wrapper = params_open_wrapper(&do_close); TestAssertTrue(wrapper != NULL); SpinLockAcquire(&wrapper->mutex); InitLatch(&wrapper->params.timer_latch); SpinLockRelease(&wrapper->mutex); if (do_close) params_close_wrapper(wrapper); } void ts_reset_and_wait_timer_latch() { bool do_close; TestParamsWrapper *wrapper = params_open_wrapper(&do_close); TestAssertTrue(wrapper != NULL); ResetLatch(&wrapper->params.timer_latch); WaitLatch(&wrapper->params.timer_latch, WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, 10000, PG_WAIT_EXTENSION); if (do_close) params_close_wrapper(wrapper); } static void params_set_mock_wait_type(MockWaitType new_val) { bool do_close; TestParamsWrapper *wrapper = params_open_wrapper(&do_close); TestAssertTrue(wrapper != NULL); SpinLockAcquire(&wrapper->mutex); wrapper->params.mock_wait_type = new_val; SpinLockRelease(&wrapper->mutex); if (do_close) params_close_wrapper(wrapper); } TS_FUNCTION_INFO_V1(ts_bgw_params_reset_time); Datum ts_bgw_params_reset_time(PG_FUNCTION_ARGS) { ts_params_set_time(PG_GETARG_INT64(0), PG_GETARG_BOOL(1)); PG_RETURN_VOID(); } TS_FUNCTION_INFO_V1(ts_bgw_params_mock_wait_returns_immediately); Datum ts_bgw_params_mock_wait_returns_immediately(PG_FUNCTION_ARGS) { params_set_mock_wait_type(PG_GETARG_INT32(0)); PG_RETURN_VOID(); } TS_FUNCTION_INFO_V1(ts_bgw_params_create); Datum ts_bgw_params_create(PG_FUNCTION_ARGS) { dsm_segment *seg = dsm_create(sizeof(TestParamsWrapper), 0); TestParamsWrapper *params; TestAssertTrue(seg != NULL); params = dsm_segment_address(seg); *params = (TestParamsWrapper) { .params = { .current_time = 0, }, }; SpinLockInit(¶ms->mutex); params_register_dsm_handle(dsm_segment_handle(seg)); dsm_pin_mapping(seg); dsm_pin_segment(seg); PG_RETURN_VOID(); } TS_FUNCTION_INFO_V1(ts_bgw_params_destroy); Datum ts_bgw_params_destroy(PG_FUNCTION_ARGS) { /* * Removing shared memory segment unpin for now because: * 1) This can fail in EXEC_BACKEND cases. * 2) There's no way to unpin in PG9.6. * 3) The EXEC_BACKEND compile-time flag is not correctly passed down. * 4) This should only affect tests, not actual DB functionality. * #if PG10 && !defined(EXEC_BACKEND) * dsm_unpin_segment(params_get_dsm_handle()); * #endif */ PG_RETURN_VOID(); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/params.h������������������������������������������������������������0000664�0000000�0000000�00000001332�15100345067�0020033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <storage/latch.h> typedef enum MockWaitType { WAIT_ON_JOB = 0, IMMEDIATELY_SET_UNTIL, WAIT_FOR_OTHER_TO_ADVANCE, WAIT_FOR_STANDARD_WAITLATCH, _MAX_MOCK_WAIT_TYPE } MockWaitType; typedef struct TestParams { Latch timer_latch; int64 current_time; MockWaitType mock_wait_type; } TestParams; extern TestParams *ts_params_get(void); extern void ts_params_set_time(int64 new_val, bool set_latch); extern void ts_initialize_timer_latch(void); extern void ts_reset_and_wait_timer_latch(void); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/scheduler_mock.c����������������������������������������������������0000664�0000000�0000000�00000027071�15100345067�0021542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <miscadmin.h> #include <pgstat.h> #include <postmaster/bgworker.h> #include <signal.h> #include <storage/ipc.h> #include <storage/latch.h> #include <storage/lmgr.h> #include <storage/lwlock.h> #include <storage/proc.h> #include <storage/shmem.h> #include <utils/builtins.h> #include <utils/errcodes.h> #include <utils/guc.h> #include <utils/jsonb.h> #include <utils/memutils.h> #include <utils/snapmgr.h> #include <utils/timestamp.h> #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/scheduler.h" #include "cross_module_fn.h" #include "extension.h" #include "log.h" #include "params.h" #include "test_utils.h" #include "time_bucket.h" #include "timer_mock.h" TS_FUNCTION_INFO_V1(ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish); TS_FUNCTION_INFO_V1(ts_bgw_db_scheduler_test_run); TS_FUNCTION_INFO_V1(ts_bgw_db_scheduler_test_wait_for_scheduler_finish); TS_FUNCTION_INFO_V1(ts_bgw_db_scheduler_test_main); TS_FUNCTION_INFO_V1(ts_bgw_job_execute_test); /* function for testing the correctness of the next_scheduled_slot calculation */ TS_FUNCTION_INFO_V1(ts_test_next_scheduled_execution_slot); typedef enum TestJobType { TEST_JOB_TYPE_JOB_1 = 0, TEST_JOB_TYPE_JOB_2_ERROR, TEST_JOB_TYPE_JOB_3_LONG, TEST_JOB_TYPE_JOB_4, _MAX_TEST_JOB_TYPE } TestJobType; static const char *test_job_type_names[_MAX_TEST_JOB_TYPE] = { [TEST_JOB_TYPE_JOB_1] = "bgw_test_job_1", [TEST_JOB_TYPE_JOB_2_ERROR] = "bgw_test_job_2_error", [TEST_JOB_TYPE_JOB_3_LONG] = "bgw_test_job_3_long", [TEST_JOB_TYPE_JOB_4] = "bgw_test_job_4", }; /* this is copied from the job_stat/ts_get_next_scheduled_execution_slot */ extern Datum ts_test_next_scheduled_execution_slot(PG_FUNCTION_ARGS) { Interval *schedule_interval = PG_GETARG_INTERVAL_P(0); TimestampTz finish_time = PG_GETARG_TIMESTAMPTZ(1); TimestampTz initial_start = PG_GETARG_TIMESTAMPTZ(2); text *timezone = PG_ARGISNULL(3) ? NULL : PG_GETARG_TEXT_PP(3); Datum timebucket_fini, timebucket_init, result; Datum schedint_datum = IntervalPGetDatum(schedule_interval); Interval one_month = { .day = 0, .time = 0, .month = 1, }; if (schedule_interval->month > 0) { if (timezone == NULL) { timebucket_init = DirectFunctionCall2(ts_timestamptz_bucket, schedint_datum, TimestampTzGetDatum(initial_start)); timebucket_fini = DirectFunctionCall2(ts_timestamptz_bucket, schedint_datum, TimestampTzGetDatum(finish_time)); } else { char *tz = text_to_cstring(timezone); timebucket_fini = DirectFunctionCall3(ts_timestamptz_timezone_bucket, schedint_datum, TimestampTzGetDatum(finish_time), CStringGetTextDatum(tz)); timebucket_init = DirectFunctionCall3(ts_timestamptz_timezone_bucket, schedint_datum, TimestampTzGetDatum(initial_start), CStringGetTextDatum(tz)); } /* always the next bucket */ timebucket_fini = DirectFunctionCall2(timestamptz_pl_interval, timebucket_fini, schedint_datum); /* get the number of months between them */ Datum year_init = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("year"), timebucket_init); Datum year_fini = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("year"), timebucket_fini); Datum month_init = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("month"), timebucket_init); Datum month_fini = DirectFunctionCall2(timestamptz_part, CStringGetTextDatum("month"), timebucket_fini); /* convert everything to months */ float8 month_diff = (DatumGetFloat8(year_fini) * 12) + DatumGetFloat8(month_fini) - ((DatumGetFloat8(year_init) * 12) + DatumGetFloat8(month_init)); Datum months_to_add = DirectFunctionCall2(interval_mul, IntervalPGetDatum(&one_month), Float8GetDatum(month_diff)); result = DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(initial_start), months_to_add); } else { if (timezone == NULL) { /* it is safe to use the origin in time_bucket calculation */ timebucket_fini = DirectFunctionCall3(ts_timestamptz_bucket, schedint_datum, TimestampTzGetDatum(finish_time), TimestampTzGetDatum(initial_start)); result = timebucket_fini; } else { char *tz = text_to_cstring(timezone); timebucket_fini = DirectFunctionCall4(ts_timestamptz_timezone_bucket, schedint_datum, TimestampTzGetDatum(finish_time), CStringGetTextDatum(tz), TimestampTzGetDatum(initial_start)); result = timebucket_fini; } } while (DatumGetTimestampTz(result) <= finish_time) { result = DirectFunctionCall2(timestamptz_pl_interval, result, schedint_datum); } return result; } extern Datum ts_bgw_db_scheduler_test_main(PG_FUNCTION_ARGS) { Oid db_oid = DatumGetObjectId(MyBgworkerEntry->bgw_main_arg); BgwParams bgw_params; BackgroundWorkerBlockSignals(); /* Setup any signal handlers here */ ts_bgw_scheduler_register_signal_handlers(); BackgroundWorkerUnblockSignals(); ts_bgw_scheduler_setup_callbacks(); memcpy(&bgw_params, MyBgworkerEntry->bgw_extra, sizeof(bgw_params)); elog(NOTICE, "scheduler user id %u", bgw_params.user_oid); elog(NOTICE, "running a test in the background: db=%u ttl=%d", db_oid, bgw_params.ttl); BackgroundWorkerInitializeConnectionByOid(db_oid, bgw_params.user_oid, 0); StartTransactionCommand(); ts_params_get(); ts_initialize_timer_latch(); CommitTransactionCommand(); ts_bgw_log_set_application_name("DB Scheduler"); ts_register_emit_log_hook(); ts_timer_set(&ts_mock_timer); ts_bgw_job_set_job_entrypoint_function_name("ts_bgw_job_execute_test"); pgstat_report_appname("DB Scheduler Test"); ts_bgw_scheduler_setup_mctx(); ts_bgw_scheduler_process(bgw_params.ttl, ts_timer_mock_register_bgw_handle); PG_RETURN_VOID(); } static BackgroundWorkerHandle * start_test_scheduler(int32 ttl, Oid user_oid) { const BgwParams bgw_params = { .bgw_main = "ts_bgw_db_scheduler_test_main", .ttl = ttl, .user_oid = user_oid, }; /* * This is where we would increment the number of bgw used, if we * decide to do so */ ts_bgw_scheduler_setup_mctx(); return ts_bgw_start_worker("ts_bgw_db_scheduler_test_main", &bgw_params); } /* this function will start up a bgw for the scheduler and set the ttl to the given value * (microseconds) */ extern Datum ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(PG_FUNCTION_ARGS) { BackgroundWorkerHandle *worker_handle; pid_t pid; worker_handle = start_test_scheduler(PG_GETARG_INT32(0), GetUserId()); TestAssertTrue(worker_handle != NULL); /* * If RegisterDynamicbackgroundworker fails, worker_handle will be * NULL. Since messages have already been printed in, just exit. */ if (!worker_handle) PG_RETURN_VOID(); BgwHandleStatus status = WaitForBackgroundWorkerStartup(worker_handle, &pid); TestAssertTrue(BGWH_STARTED == status); if (status != BGWH_STARTED) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("bgw not started"))); status = WaitForBackgroundWorkerShutdown(worker_handle); TestAssertTrue(BGWH_STOPPED == status); if (status != BGWH_STOPPED) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("bgw not stopped"))); PG_RETURN_VOID(); } static BackgroundWorkerHandle *current_handle = NULL; extern Datum ts_bgw_db_scheduler_test_run(PG_FUNCTION_ARGS) { pid_t pid; MemoryContext old_ctx; BgwHandleStatus status; old_ctx = MemoryContextSwitchTo(TopMemoryContext); current_handle = start_test_scheduler(PG_GETARG_INT32(0), GetUserId()); MemoryContextSwitchTo(old_ctx); /* * If RegisterDynamicbackgroundworker fails, current_handle will be * NULL. Since messages have already been printed in, just exit. */ if (!current_handle) PG_RETURN_VOID(); status = WaitForBackgroundWorkerStartup(current_handle, &pid); TestAssertTrue(BGWH_STARTED == status); if (status != BGWH_STARTED) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("bgw not started"))); PG_RETURN_VOID(); } extern Datum ts_bgw_db_scheduler_test_wait_for_scheduler_finish(PG_FUNCTION_ARGS) { if (current_handle != NULL) { BgwHandleStatus status = WaitForBackgroundWorkerShutdown(current_handle); TestAssertTrue(BGWH_STOPPED == status); if (status != BGWH_STOPPED) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("bgw not stopped"))); } PG_RETURN_VOID(); } static bool test_job_1() { StartTransactionCommand(); elog(WARNING, "Execute job 1"); CommitTransactionCommand(); return true; } static bool test_job_2_error() { StartTransactionCommand(); elog(WARNING, "Before error job 2"); ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), errmsg("Error job 2"))); elog(WARNING, "After error job 2"); CommitTransactionCommand(); return true; } static void log_terminate_signal(SIGNAL_ARGS) { write_stderr("job got term signal\n"); die(postgres_signal_arg); } TS_FUNCTION_INFO_V1(ts_bgw_test_job_sleep); /* * This function is used for testing removing jobs with * a currently running background job. */ Datum ts_bgw_test_job_sleep(PG_FUNCTION_ARGS) { BackgroundWorkerBlockSignals(); pqsignal(SIGTERM, log_terminate_signal); /* Setup any signal handlers here */ BackgroundWorkerUnblockSignals(); elog(WARNING, "Before sleep"); PopActiveSnapshot(); /* * we commit here so the effect of the elog which is written * to a table with a emit_log_hook is seen by other transactions * to verify the background job started */ CommitTransactionCommand(); StartTransactionCommand(); DirectFunctionCall1(pg_sleep, Float8GetDatum(10)); elog(WARNING, "After sleep"); PG_RETURN_VOID(); } static bool test_job_3_long() { BackgroundWorkerBlockSignals(); pqsignal(SIGTERM, log_terminate_signal); /* Setup any signal handlers here */ BackgroundWorkerUnblockSignals(); elog(WARNING, "Before sleep job 3"); DirectFunctionCall1(pg_sleep, Float8GetDatum(0.5L)); elog(WARNING, "After sleep job 3"); return true; } /* Exactly like job 1, except a wrapper will change its next_start. */ static bool test_job_4(void) { elog(WARNING, "Execute job 4"); return true; } static TestJobType get_test_job_type_from_name(Name job_type_name) { int i; for (i = 0; i < _MAX_TEST_JOB_TYPE; i++) { if (namestrcmp(job_type_name, test_job_type_names[i]) == 0) return i; } return _MAX_TEST_JOB_TYPE; } static bool test_job_dispatcher(BgwJob *job) { ts_register_emit_log_hook(); ts_bgw_log_set_application_name(strdup(NameStr(job->fd.application_name))); StartTransactionCommand(); ts_params_get(); CommitTransactionCommand(); switch (get_test_job_type_from_name(&job->fd.proc_name)) { case TEST_JOB_TYPE_JOB_1: return test_job_1(); case TEST_JOB_TYPE_JOB_2_ERROR: return test_job_2_error(); case TEST_JOB_TYPE_JOB_3_LONG: return test_job_3_long(); case TEST_JOB_TYPE_JOB_4: { /* Set next_start to 200ms */ Interval new_interval = { .time = .2 * USECS_PER_SEC }; return ts_bgw_job_run_and_set_next_start(job, test_job_4, 3, &new_interval, /* atomic */ true, /* mark */ false); } default: return ts_cm_functions->job_execute(job); } return false; } Datum ts_bgw_job_execute_test(PG_FUNCTION_ARGS) { ts_timer_set(&ts_mock_timer); ts_bgw_job_set_scheduler_test_hook(test_job_dispatcher); return ts_bgw_job_entrypoint(fcinfo); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/test_job_refresh.c��������������������������������������������������0000664�0000000�0000000�00000004161�15100345067�0022075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <string.h> #include <postgres.h> #include <access/htup_details.h> #include <fmgr.h> #include <funcapi.h> #include <stdlib.h> #include <time.h> #include <utils/memutils.h> #include "compat/compat.h" #include "bgw/scheduler.h" #include "export.h" TS_FUNCTION_INFO_V1(ts_test_job_refresh); static List *cur_scheduled_jobs = NIL; /* Test update_scheduled_jobs_list will correctly update with jobs in bgw_job table. * Call this function after loading up bgw_job table */ Datum ts_test_job_refresh(PG_FUNCTION_ARGS) { FuncCallContext *funcctx; ListCell *lc; if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; TupleDesc tupdesc; /* Use top-level memory context to preserve the global static list */ cur_scheduled_jobs = ts_update_scheduled_jobs_list(cur_scheduled_jobs, TopMemoryContext); funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); funcctx->user_fctx = list_head(cur_scheduled_jobs); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); } funcctx->tuple_desc = BlessTupleDesc(tupdesc); MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); lc = (ListCell *) funcctx->user_fctx; if (lc == NULL) SRF_RETURN_DONE(funcctx); else { /* Return the current list_cell and advance ptr */ HeapTuple tuple; Datum *values = palloc(sizeof(*values) * funcctx->tuple_desc->natts); bool *nulls = palloc(sizeof(*nulls) * funcctx->tuple_desc->natts); ts_populate_scheduled_job_tuple(lfirst(lc), values); memset(nulls, 0, sizeof(*nulls) * funcctx->tuple_desc->natts); tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls); funcctx->user_fctx = lnext(cur_scheduled_jobs, lc); SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple)); } PG_RETURN_NULL(); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/test_job_utils.c����������������������������������������������������0000664�0000000�0000000�00000001055�15100345067�0021576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <funcapi.h> #include "bgw/job.h" #include "test_utils.h" TS_TEST_FN(ts_test_bgw_job_function_call_string) { int32 job_id = PG_GETARG_INT32(0); BgwJob *job = ts_bgw_job_find(job_id, CurrentMemoryContext, true); const char *stmt = ts_bgw_job_function_call_string(job); PG_RETURN_TEXT_P(cstring_to_text(stmt)); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/timer_mock.c��������������������������������������������������������0000664�0000000�0000000�00000004144�15100345067�0020700�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/relscan.h> #include <access/xact.h> #include <catalog/namespace.h> #include <storage/bufmgr.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include "annotations.h" #include "bgw/launcher_interface.h" #include "log.h" #include "params.h" #include "scanner.h" #include "timer_mock.h" #include "ts_catalog/catalog.h" static List *bgw_handles = NIL; static bool mock_wait(TimestampTz until); static TimestampTz mock_current_time(void); const Timer ts_mock_timer = { .get_current_timestamp = mock_current_time, .wait = mock_wait, }; void ts_timer_mock_register_bgw_handle(BackgroundWorkerHandle *handle, MemoryContext scheduler_mctx) { elog(WARNING, "[TESTING] Registered new background worker"); MemoryContext old_context = MemoryContextSwitchTo(scheduler_mctx); bgw_handles = lappend(bgw_handles, handle); MemoryContextSwitchTo(old_context); } /* WARNING: mock_wait must _only_ be called from the bgw_scheduler, calling it from a worker will * clobber the timer state */ static bool mock_wait(TimestampTz until) { elog(WARNING, "[TESTING] Wait until " INT64_FORMAT ", started at " INT64_FORMAT, until, ts_params_get()->current_time); ListCell *lc; switch (ts_params_get()->mock_wait_type) { case WAIT_ON_JOB: foreach (lc, bgw_handles) { BackgroundWorkerHandle *bgw_handle = lfirst(lc); WaitForBackgroundWorkerShutdown(bgw_handle); } bgw_handles = NIL; TS_FALLTHROUGH; case IMMEDIATELY_SET_UNTIL: ts_params_set_time(until, false); return true; case WAIT_FOR_OTHER_TO_ADVANCE: { /* Wait for another process to set "next time" */ ts_reset_and_wait_timer_latch(); return true; } case WAIT_FOR_STANDARD_WAITLATCH: ts_get_standard_timer()->wait(until); return true; default: return false; } } static TimestampTz mock_current_time() { return ts_params_get()->current_time; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/bgw/timer_mock.h��������������������������������������������������������0000664�0000000�0000000�00000000670�15100345067�0020705�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <postmaster/bgworker.h> #include "bgw/timer.h" extern void ts_timer_mock_register_bgw_handle(BackgroundWorkerHandle *handle, MemoryContext scheduler_mctx); extern const Timer ts_mock_timer; ������������������������������������������������������������������������timescaledb-2.23.0/test/src/loader/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017067�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/loader/CMakeLists.txt���������������������������������������������������0000664�0000000�0000000�00000004710�15100345067�0021631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES init.c ${PROJECT_SOURCE_DIR}/src/extension.c ${PROJECT_SOURCE_DIR}/src/guc.c) include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/src) add_library(${PROJECT_NAME}-mock-1 MODULE ${SOURCES} config.h) add_library(${PROJECT_NAME}-mock-2 MODULE ${SOURCES} config.h) add_library(${PROJECT_NAME}-mock-3 MODULE ${SOURCES} config.h) # mock-4 will be broken mismatched .so add_library(${PROJECT_NAME}-mock-4 MODULE ${SOURCES} config.h) add_library(${PROJECT_NAME}-mock-5 MODULE ${SOURCES} config.h) add_library(${PROJECT_NAME}-mock-broken MODULE ${SOURCES} config.h) add_library(${PROJECT_NAME}-mock-6 MODULE ${SOURCES} config.h) target_compile_definitions(${PROJECT_NAME}-mock-1 PRIVATE TIMESCALEDB_VERSION_MOD="mock-1" BROKEN=0) target_compile_definitions(${PROJECT_NAME}-mock-2 PRIVATE TIMESCALEDB_VERSION_MOD="mock-2" BROKEN=0) target_compile_definitions(${PROJECT_NAME}-mock-3 PRIVATE TIMESCALEDB_VERSION_MOD="mock-3" BROKEN=0) # mock 4 is intentionally incorrect version mod target_compile_definitions( ${PROJECT_NAME}-mock-4 PRIVATE TIMESCALEDB_VERSION_MOD="mock-4-mismatch" BROKEN=0) target_compile_definitions(${PROJECT_NAME}-mock-5 PRIVATE TIMESCALEDB_VERSION_MOD="mock-5" BROKEN=0) target_compile_definitions( ${PROJECT_NAME}-mock-broken PRIVATE TIMESCALEDB_VERSION_MOD="mock-broken" BROKEN=1) target_compile_definitions(${PROJECT_NAME}-mock-6 PRIVATE TIMESCALEDB_VERSION_MOD="mock-6" BROKEN=0) foreach( MOCK_VERSION mock-1 mock-2 mock-3 mock-4 mock-broken mock-5 mock-6) set_target_properties( ${PROJECT_NAME}-${MOCK_VERSION} PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-${MOCK_VERSION} PREFIX "") install( TARGETS ${PROJECT_NAME}-${MOCK_VERSION} DESTINATION ${PG_PKGLIBDIR} OPTIONAL) endforeach(MOCK_VERSION) add_library(${PROJECT_NAME}_osm-mock-1 MODULE osm_init.c) target_compile_definitions(${PROJECT_NAME}_osm-mock-1 PRIVATE OSM_VERSION_MOD="mock-1") foreach(MOCK_VERSION mock-1) set_target_properties( ${PROJECT_NAME}_osm-${MOCK_VERSION} PROPERTIES OUTPUT_NAME ${PROJECT_NAME}_osm-${MOCK_VERSION} PREFIX "") install( TARGETS ${PROJECT_NAME}_osm-${MOCK_VERSION} DESTINATION ${PG_PKGLIBDIR} OPTIONAL) endforeach(MOCK_VERSION) ��������������������������������������������������������timescaledb-2.23.0/test/src/loader/config.h���������������������������������������������������������0000664�0000000�0000000�00000000457�15100345067�0020513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ /* Overwrite main config.h so we could inject our own version #s here. */ #define TELEMETRY_DEFAULT TELEMETRY_OFF �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/loader/init.c�����������������������������������������������������������0000664�0000000�0000000�00000006050�15100345067�0020177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <config.h> #ifndef WIN32 #include <access/parallel.h> #endif #include "compat/compat.h" #include "export.h" #include "extension.h" #include <commands/extension.h> #include <miscadmin.h> #include <parser/analyze.h> #include <utils/guc.h> #include <utils/inval.h> #define STR_EXPAND(x) #x #define STR(x) STR_EXPAND(x) #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif #if PG16_LT extern void PGDLLEXPORT _PG_init(void); #endif static post_parse_analyze_hook_type prev_post_parse_analyze_hook; bool ts_license_guc_check_hook(char **newval, void **extra, GucSource source); void ts_license_guc_assign_hook(const char *newval, void *extra); TS_FUNCTION_INFO_V1(ts_post_load_init); static void cache_invalidate_callback(Datum arg, Oid relid) { if (ts_extension_is_proxy_table_relid(relid)) ts_extension_invalidate(); } static void post_analyze_hook(ParseState *pstate, Query *query, JumbleState *jstate) { if (ts_extension_is_loaded_and_not_upgrading()) elog(WARNING, "mock post_analyze_hook " STR(TIMESCALEDB_VERSION_MOD)); /* * a symbol needed by IsParallelWorker is not exported on windows so we do * not perform this check */ #ifndef WIN32 if (prev_post_parse_analyze_hook != NULL && !IsParallelWorker()) elog(ERROR, "the extension called with a loader should always have a NULL prev hook"); #endif if (BROKEN && !creating_extension) ereport(ERROR, (errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION), errmsg("mock broken " STR(TIMESCALEDB_VERSION_MOD)))); } void _PG_init(void) { /* * Check extension_is loaded to catch certain errors such as calls to * functions defined on the wrong extension version */ ts_extension_check_version(TIMESCALEDB_VERSION_MOD); elog(WARNING, "mock init " STR(TIMESCALEDB_VERSION_MOD)); prev_post_parse_analyze_hook = post_parse_analyze_hook; /* * a symbol needed by IsParallelWorker is not exported on windows so we do * not perform this check */ #ifndef WIN32 if (prev_post_parse_analyze_hook != NULL && !IsParallelWorker()) elog(ERROR, "the extension called with a loader should always have a NULL prev hook"); #endif post_parse_analyze_hook = post_analyze_hook; CacheRegisterRelcacheCallback(cache_invalidate_callback, PointerGetDatum(NULL)); } /* mock for extension.c */ void ts_catalog_reset(void); void ts_catalog_reset() { } /* mock for guc.c */ void ts_hypertable_cache_invalidate_callback(void); void ts_hypertable_cache_invalidate_callback(void) { } TS_FUNCTION_INFO_V1(ts_mock_function); Datum ts_mock_function(PG_FUNCTION_ARGS) { elog(WARNING, "mock function call " STR(TIMESCALEDB_VERSION_MOD)); PG_RETURN_VOID(); } TSDLLEXPORT Datum ts_post_load_init(PG_FUNCTION_ARGS) { PG_RETURN_CHAR(0); } bool ts_license_guc_check_hook(char **newval, void **extra, GucSource source) { return true; } void ts_license_guc_assign_hook(const char *newval, void *extra) { } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/loader/osm_init.c�������������������������������������������������������0000664�0000000�0000000�00000004264�15100345067�0021062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/namespace.h> #include <tcop/utility.h> #include "compat/compat.h" #include "export.h" #include "loader/lwlocks.h" #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif static ProcessUtility_hook_type prev_ProcessUtility_hook; static void osm_process_utility_hook(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc); #if PG16_LT extern void PGDLLEXPORT _PG_init(void); #endif void _PG_init(void) { elog(WARNING, "OSM-%s _PG_init", OSM_VERSION_MOD); void **osm_lock_pointer = find_rendezvous_variable(RENDEZVOUS_OSM_PARALLEL_LWLOCK); if (osm_lock_pointer != NULL) { elog(WARNING, "got lwlock osm lock"); } else { elog(WARNING, "NO lwlock osm lock"); } prev_ProcessUtility_hook = ProcessUtility_hook; ProcessUtility_hook = osm_process_utility_hook; } TS_FUNCTION_INFO_V1(ts_mock_osm); Datum ts_mock_osm(PG_FUNCTION_ARGS) { elog(WARNING, "OSM-%s mock function call", OSM_VERSION_MOD); PG_RETURN_VOID(); } static void osm_process_utility_hook(PlannedStmt *pstmt, const char *queryString, bool readOnlyTree, ProcessUtilityContext context, ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest, QueryCompletion *qc) { if (nodeTag(pstmt->utilityStmt) == T_DropStmt) { DropStmt *stmt = (DropStmt *) pstmt->utilityStmt; if (stmt->removeType == OBJECT_TABLE) { ListCell *lc; foreach (lc, stmt->objects) { RangeVar *relation = makeRangeVarFromNameList(lfirst(lc)); if (relation != NULL) { Oid relid = RangeVarGetRelid(relation, NoLock, true); elog(NOTICE, "OSM-%s got DROP TABLE '%s'", OSM_VERSION_MOD, get_rel_name(relid)); } } } } if (prev_ProcessUtility_hook) prev_ProcessUtility_hook(pstmt, queryString, readOnlyTree, context, params, queryEnv, dest, qc); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/metadata.c��������������������������������������������������������������0000664�0000000�0000000�00000001407�15100345067�0017547�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <string.h> #include <unistd.h> #include <postgres.h> #include <fmgr.h> #include <utils/builtins.h> #include "export.h" #include "ts_catalog/metadata.h" TS_FUNCTION_INFO_V1(ts_test_uuid); TS_FUNCTION_INFO_V1(ts_test_exported_uuid); TS_FUNCTION_INFO_V1(ts_test_install_timestamp); Datum ts_test_uuid(PG_FUNCTION_ARGS) { PG_RETURN_DATUM(ts_metadata_get_uuid()); } Datum ts_test_exported_uuid(PG_FUNCTION_ARGS) { PG_RETURN_DATUM(ts_metadata_get_exported_uuid()); } Datum ts_test_install_timestamp(PG_FUNCTION_ARGS) { PG_RETURN_DATUM(ts_metadata_get_install_timestamp()); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/net/��������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016407�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/net/CMakeLists.txt������������������������������������������������������0000664�0000000�0000000�00000000466�15100345067�0021155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/test_conn.c ${CMAKE_CURRENT_SOURCE_DIR}/test_http.c ${CMAKE_CURRENT_SOURCE_DIR}/conn_mock.c) target_sources(${TESTS_LIB_NAME} PRIVATE ${SOURCES}) target_include_directories(${TESTS_LIB_NAME} PRIVATE ${PROJECT_SOURCE_DIR}/src/net) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/net/conn_mock.c���������������������������������������������������������0000664�0000000�0000000�00000004111�15100345067�0020516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <unistd.h> #include <postgres.h> #include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <time.h> #include "conn_internal.h" #include "conn_mock.h" #define MOCK_MAX_BUF_SIZE 1024 typedef struct MockConnection { Connection conn; char recv_buf[MOCK_MAX_BUF_SIZE]; size_t recv_buf_offset; size_t recv_buf_len; } MockConnection; static int mock_connect(Connection *conn, const char *host, const char *servname, int port) { return 0; } static void mock_close(Connection *conn) { } static ssize_t mock_write(Connection *conn, const char *buf, size_t writelen) { return writelen; } static ssize_t mock_read(Connection *conn, char *buf, size_t readlen) { size_t bytes_to_read = 0; size_t max = readlen; MockConnection *mock = (MockConnection *) conn; if (mock->recv_buf_offset >= mock->recv_buf_len) return 0; if (max >= mock->recv_buf_len - mock->recv_buf_offset) max = mock->recv_buf_len - mock->recv_buf_offset; /* Now read a random amount */ while (bytes_to_read == 0) { bytes_to_read = rand() % (max + 1); } memcpy(buf, mock->recv_buf + mock->recv_buf_offset, bytes_to_read); mock->recv_buf_offset += bytes_to_read; return bytes_to_read; } static int mock_init(Connection *conn) { srand(time(0)); return 0; } static ConnOps mock_ops = { .size = sizeof(MockConnection), .init = mock_init, .connect = mock_connect, .close = mock_close, .write = mock_write, .read = mock_read, }; ssize_t ts_connection_mock_set_recv_buf(Connection *conn, char *buf, size_t buf_len) { MockConnection *mock = (MockConnection *) conn; if (buf_len > MOCK_MAX_BUF_SIZE) return -1; memcpy(mock->recv_buf, buf, buf_len); mock->recv_buf_len = buf_len; return mock->recv_buf_len; } extern void _conn_mock_init(void); extern void _conn_mock_fini(void); void _conn_mock_init(void) { ts_connection_register(CONNECTION_MOCK, &mock_ops); } void _conn_mock_fini(void) { } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/net/conn_mock.h���������������������������������������������������������0000664�0000000�0000000�00000000550�15100345067�0020526�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <sys/socket.h> typedef struct Connection Connection; extern ssize_t ts_connection_mock_set_recv_buf(Connection *conn, char *buf, size_t buf_len); ��������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/net/test_conn.c���������������������������������������������������������0000664�0000000�0000000�00000003464�15100345067�0020556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <string.h> #include <unistd.h> #include <postgres.h> #include <fmgr.h> #include "compat/compat.h" #include "config.h" #include "net/conn.h" #define MAX_RESULT_SIZE 2048 TS_FUNCTION_INFO_V1(ts_test_conn); Datum ts_test_conn(PG_FUNCTION_ARGS) { char response[MAX_RESULT_SIZE]; Connection *conn; int ret; int port = 80; #ifdef TS_USE_OPENSSL int ssl_port = 443; #endif char *host = "httpbin.org"; /* Test connection_init/destroy */ conn = ts_connection_create(CONNECTION_PLAIN); ts_connection_destroy(conn); /* Check pass NULL won't crash */ ts_connection_destroy(NULL); /* Check that delays on the socket are properly handled */ conn = ts_connection_create(CONNECTION_PLAIN); ts_connection_set_timeout_millis(conn, 200); /* This is a brittle assert function because we might not necessarily have */ /* connectivity on the server running this test? */ ret = ts_connection_connect(conn, host, NULL, port); if (ret < 0) elog(ERROR, "%s", ts_connection_get_and_clear_error(conn)); /* should timeout */ ret = ts_connection_read(conn, response, 1); if (ret == 0) elog(ERROR, "Expected timeout"); ts_connection_close(conn); ts_connection_destroy(conn); #ifdef TS_USE_OPENSSL /* Now test ssl_ops */ conn = ts_connection_create(CONNECTION_SSL); ts_connection_set_timeout_millis(conn, 200); ret = ts_connection_connect(conn, host, NULL, ssl_port); if (ret < 0) elog(ERROR, "%s", ts_connection_get_and_clear_error(conn)); ret = ts_connection_read(conn, response, 1); if (ret == 0) elog(ERROR, "Expected timeout"); ts_connection_close(conn); ts_connection_destroy(conn); #endif PG_RETURN_NULL(); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/net/test_http.c���������������������������������������������������������0000664�0000000�0000000�00000016316�15100345067�0020600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <string.h> #include <postgres.h> #include <fmgr.h> #include <stdlib.h> #include <time.h> #include "export.h" #include "net/http.h" #include "test_utils.h" #define MAX_REQUEST_SIZE 4096 /* Tests for auxiliary HttpResponseState functions in http_parsing.h */ static const char *TEST_RESPONSES[] = { "HTTP/1.1 200 OK\r\n" "Content-Type: application/json; charset=utf-8\r\n" "Date: Thu, 12 Jul 2018 18:33:04 GMT\r\n" "ETag: W/\"e-upYEWCL+q6R/++2nWHz5b76hBgo\"\r\n" "Server: nginx " "Vary: Accept-Encoding\r\n" "Content-Length: 14\r\n" "Connection: Close\r\n\r\n" "{\"status\":200}", "HTTP/1.1 200 OK\r\n" "Content-Length: 14\r\n" "Content-Type: application/json; charset=utf-8\r\n" "Date: Thu, 12 Jul 2018 18:33:04 GMT\r\n" "ETag: W/\"e-upYEWCL+q6R/++2nWHz5b76hBgo\"\r\n" "Vary: Accept-Encoding\r\n\r\n" "{\"status\":200}", "HTTP/1.1 200 OK\r\n" "Content-Length: 14\r\n" "Connection: Close\r\n\r\n" "{\"status\":200}", "HTTP/1.1 201 OK\r\n" "Date: Thu, 12 Jul 2018 18:33:04 GMT\r\n" "Content-Length: 14\r\n" "ETag: W/\"e-upYEWCL+q6R/++2nWHz5b76hBgo\"\r\n" "Connection: Close\r\n\r\n" "{\"status\":201}", }; static const char *const BAD_RESPONSES[] = { "HTTP/1.1 200 OK\r\n" "Content-Type: application/json; charset=utf-8\r\n" "Date: Thu, 12 Jul 2018 18:33:04 GMT\r\n" "ETag: W/\"e-upYEWCL+q6R/++2nWHz5b76hBgo\"\r\n" "Connection: Close\r\n" "{\"status\":200}", "Content-Length: 14\r\n" "{\"status\":200}", "Content-Length: 14\r\n" "HTTP/1.1 404 Not Found\r\n" "Connection: Close\r\n\r\n" "{\"status\":404}", NULL }; static size_t TEST_LENGTHS[] = { 14, 14, 14, 14 }; static const char *MESSAGE_BODY[] = { "{\"status\":200}", "{\"status\":200}", "{\"status\":200}", "{\"status\":201}" }; TS_FUNCTION_INFO_V1(ts_test_http_parsing); TS_FUNCTION_INFO_V1(ts_test_http_parsing_full); TS_FUNCTION_INFO_V1(ts_test_http_request_build); static int num_test_strings() { return sizeof(TEST_LENGTHS) / sizeof(TEST_LENGTHS[0]); } /* Check we can successfully parse partial by well-formed HTTP responses */ Datum ts_test_http_parsing(PG_FUNCTION_ARGS) { int num_iterations = PG_GETARG_INT32(0); int i, j; size_t bytes; srand(time(0)); for (j = 0; j < num_iterations; j++) { for (i = 0; i < num_test_strings(); i++) { HttpResponseState *state = ts_http_response_state_create(); bool success; ssize_t bufsize = 0; char *buf; bytes = rand() % (strlen(TEST_RESPONSES[i]) + 1); buf = ts_http_response_state_next_buffer(state, &bufsize); TestAssertTrue(bufsize >= (ssize_t) bytes); /* Copy part of the message into the parsing state */ memcpy(buf, TEST_RESPONSES[i], bytes); /* Now do the parse */ success = ts_http_response_state_parse(state, bytes); TestAssertTrue(success); if (!success) elog(ERROR, "could not parse http state"); success = ts_http_response_state_is_done(state); TestAssertTrue(bytes < strlen(TEST_RESPONSES[i]) ? !success : success); ts_http_response_state_destroy(state); } } PG_RETURN_NULL(); } /* Check we can successfully parse full, well-formed HTTP response AND * successfully find error with full, poorly-formed HTTP responses */ Datum ts_test_http_parsing_full(PG_FUNCTION_ARGS) { int i; size_t bytes; srand(time(0)); for (i = 0; i < num_test_strings(); i++) { HttpResponseState *state = ts_http_response_state_create(); ssize_t bufsize = 0; char *buf; int cmp; buf = ts_http_response_state_next_buffer(state, &bufsize); bytes = strlen(TEST_RESPONSES[i]); TestAssertTrue(bufsize >= (ssize_t) bytes); /* Copy all of the message into the parsing state */ memcpy(buf, TEST_RESPONSES[i], bytes); /* Now do the parse */ TestAssertTrue(ts_http_response_state_parse(state, bytes)); TestAssertTrue(ts_http_response_state_is_done(state)); TestAssertTrue(ts_http_response_state_content_length(state) == TEST_LENGTHS[i]); /* Make sure we read the right message body */ cmp = !strncmp(MESSAGE_BODY[i], ts_http_response_state_body_start(state), ts_http_response_state_content_length(state)); TestAssertTrue(cmp); if (!cmp) elog(ERROR, "bad message"); ts_http_response_state_destroy(state); } /* Now do the bad responses */ for (i = 0; i < 3; i++) { HttpResponseState *state = ts_http_response_state_create(); ssize_t bufsize = 0; char *buf; buf = ts_http_response_state_next_buffer(state, &bufsize); bytes = strlen(BAD_RESPONSES[i]); TestAssertTrue(bufsize >= (ssize_t) bytes); memcpy(buf, BAD_RESPONSES[i], bytes); TestAssertTrue(!ts_http_response_state_parse(state, bytes) || !ts_http_response_state_valid_status(state)); ts_http_response_state_destroy(state); } PG_RETURN_NULL(); } Datum ts_test_http_request_build(PG_FUNCTION_ARGS) { const char *serialized; size_t request_len; const char *expected_response = "GET /v1/alerts HTTP/1.1\r\n" "Host: herp.com\r\nContent-Length: 0\r\n\r\n"; char *host = "herp.com"; HttpRequest *req = ts_http_request_create(HTTP_GET); int cmp_res; ts_http_request_set_uri(req, "/v1/alerts"); ts_http_request_set_version(req, HTTP_VERSION_11); ts_http_request_set_header(req, HTTP_CONTENT_LENGTH, "0"); ts_http_request_set_header(req, HTTP_HOST, host); serialized = ts_http_request_build(req, &request_len); cmp_res = !strncmp(expected_response, serialized, request_len); TestAssertTrue(cmp_res); if (!cmp_res) elog(ERROR, "bad response"); ts_http_request_destroy(req); expected_response = "GET /tmp/path/to/uri HTTP/1.0\r\n" "Content-Length: 0\r\nHost: herp.com\r\nContent-Type: application/json\r\n\r\n"; req = ts_http_request_create(HTTP_GET); ts_http_request_set_uri(req, "/tmp/path/to/uri"); ts_http_request_set_version(req, HTTP_VERSION_10); ts_http_request_set_header(req, HTTP_CONTENT_TYPE, "application/json"); ts_http_request_set_header(req, HTTP_HOST, host); ts_http_request_set_header(req, HTTP_CONTENT_LENGTH, "0"); serialized = ts_http_request_build(req, &request_len); TestAssertTrue(!strncmp(expected_response, serialized, request_len)); ts_http_request_destroy(req); expected_response = "POST /tmp/status/1234 HTTP/1.1\r\n" "Content-Length: 0\r\nHost: herp.com\r\n\r\n"; req = ts_http_request_create(HTTP_POST); ts_http_request_set_uri(req, "/tmp/status/1234"); ts_http_request_set_version(req, HTTP_VERSION_11); ts_http_request_set_header(req, HTTP_HOST, host); ts_http_request_set_header(req, HTTP_CONTENT_LENGTH, "0"); serialized = ts_http_request_build(req, &request_len); TestAssertTrue(!strncmp(expected_response, serialized, request_len)); ts_http_request_destroy(req); /* Check that content-length checking works */ req = ts_http_request_create(HTTP_POST); ts_http_request_set_uri(req, "/tmp/status/1234"); ts_http_request_set_version(req, HTTP_VERSION_11); ts_http_request_set_header(req, HTTP_HOST, host); ts_http_request_set_header(req, HTTP_CONTENT_LENGTH, "9"); TestAssertTrue(!ts_http_request_build(req, &request_len)); ts_http_request_destroy(req); PG_RETURN_NULL(); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/symbol_conflict.c�������������������������������������������������������0000664�0000000�0000000�00000001443�15100345067�0021155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <utils/builtins.h> #include "export.h" #define STR_EXPAND(x) #x #define STR(x) STR_EXPAND(x) #define FUNC_EXPAND(prefix, name) prefix##_##name #define FUNC(prefix, name) FUNC_EXPAND(prefix, name) /* Function with conflicting name when included in multiple modules */ extern const char *test_symbol_conflict(void); const char * test_symbol_conflict(void) { return "hello from " STR(MODULE_NAME); } TS_FUNCTION_INFO_V1(FUNC(MODULE_NAME, hello)); Datum FUNC(MODULE_NAME, hello)(PG_FUNCTION_ARGS) { PG_RETURN_TEXT_P(cstring_to_text(test_symbol_conflict())); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/telemetry/��������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017633�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/telemetry/CMakeLists.txt������������������������������������������������0000664�0000000�0000000�00000000247�15100345067�0022376�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/test_privacy.c ${CMAKE_CURRENT_SOURCE_DIR}/test_telemetry.c) target_sources(${TESTS_LIB_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/telemetry/test_privacy.c������������������������������������������������0000664�0000000�0000000�00000001075�15100345067�0022516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <string.h> #include <unistd.h> #include <postgres.h> #include <fmgr.h> #include <miscadmin.h> #include "compat/compat.h" #include "telemetry/telemetry.h" #include "uuid.h" TS_FUNCTION_INFO_V1(ts_test_privacy); Datum ts_test_privacy(PG_FUNCTION_ARGS) { /* This test should only run when timescaledb.telemetry_level=off */ PG_RETURN_BOOL(ts_telemetry_main("", "", "")); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/telemetry/test_telemetry.c����������������������������������������������0000664�0000000�0000000�00000016631�15100345067�0023057�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <fmgr.h> #include <funcapi.h> #include <utils/builtins.h> #include <utils/jsonb.h> #include "compat/compat.h" #include "config.h" #include "export.h" #include "net/http.h" #include "telemetry/telemetry.h" #ifdef TS_DEBUG #include "net/conn_mock.h" #endif #define HTTPS_PORT 443 #define TEST_ENDPOINT "postman-echo.com" /* Since we rely on an external service to test request statuses, we should retry * a few times if we are not getting the correct response. This should reduce * test flakiness. */ #define INVALID_RESPONSE_RETRIES 5 TS_FUNCTION_INFO_V1(ts_test_status); TS_FUNCTION_INFO_V1(ts_test_status_ssl); TS_FUNCTION_INFO_V1(ts_test_status_mock); TS_FUNCTION_INFO_V1(ts_test_telemetry_main_conn); TS_FUNCTION_INFO_V1(ts_test_telemetry); TS_FUNCTION_INFO_V1(ts_test_check_version_response); #ifdef TS_DEBUG static char *test_string; #endif static HttpRequest * build_request(int status) { HttpRequest *req = ts_http_request_create(HTTP_GET); char uri[20]; snprintf(uri, 20, "/status/%d", status); ts_http_request_set_uri(req, uri); ts_http_request_set_version(req, HTTP_VERSION_10); ts_http_request_set_header(req, HTTP_HOST, TEST_ENDPOINT); ts_http_request_set_header(req, HTTP_CONTENT_LENGTH, "0"); return req; } static Datum test_factory(ConnectionType type, int status, char *host, int port) { Connection *conn; HttpRequest *req; HttpResponseState *rsp = NULL; HttpError err; Datum json; conn = ts_connection_create(type); if (conn == NULL) return CStringGetTextDatum("could not initialize a connection"); if (ts_connection_connect(conn, host, NULL, port) < 0) { const char *err_msg = ts_connection_get_and_clear_error(conn); ts_connection_destroy(conn); elog(ERROR, "connection error: %s", err_msg); } #ifdef TS_DEBUG if (type == CONNECTION_MOCK) ts_connection_mock_set_recv_buf(conn, test_string, strlen(test_string)); #endif for (int retries = 0; retries < INVALID_RESPONSE_RETRIES; retries++) { req = build_request(status); rsp = ts_http_response_state_create(); err = ts_http_send_and_recv(conn, req, rsp); ts_http_request_destroy(req); /* We are mocking the connection, no need to retry */ if (type == CONNECTION_MOCK) break; /* Could be a transient HTTP error, lets try again */ if (err != HTTP_ERROR_NONE) continue; /* Got what we want, no need to retry */ if (ts_http_response_state_valid_status(rsp) || ts_http_response_state_status_code(rsp) == status) break; } if (err != HTTP_ERROR_NONE) { ereport(ERROR, (errcode(ERRCODE_IO_ERROR), errmsg("%s", ts_http_strerror(err)))); } ts_connection_destroy(conn); if (!ts_http_response_state_valid_status(rsp)) ereport(ERROR, (errcode(ERRCODE_IO_ERROR), errmsg("endpoint sent back unexpected HTTP status: %d", ts_http_response_state_status_code(rsp)))); json = DirectFunctionCall1(jsonb_in, CStringGetDatum(ts_http_response_state_body_start(rsp))); ts_http_response_state_destroy(rsp); return json; } /* Test ssl_ops */ Datum ts_test_status_ssl(PG_FUNCTION_ARGS) { int status = PG_GETARG_INT32(0); #ifdef TS_USE_OPENSSL return test_factory(CONNECTION_SSL, status, TEST_ENDPOINT, HTTPS_PORT); #else char buf[128] = { '\0' }; if (status / 100 != 2) ereport(ERROR, (errcode(ERRCODE_IO_ERROR), errmsg("endpoint sent back unexpected HTTP status: %d", status))); snprintf(buf, sizeof(buf) - 1, "{\"status\":%d}", status); PG_RETURN_JSONB_P(DatumGetJsonbP(DirectFunctionCall1(jsonb_in, CStringGetDatum(buf)))); #endif } /* Test default_ops */ Datum ts_test_status(PG_FUNCTION_ARGS) { int port = 80; int status = PG_GETARG_INT32(0); PG_RETURN_DATUM(test_factory(CONNECTION_PLAIN, status, TEST_ENDPOINT, port)); } #ifdef TS_DEBUG /* Test mock_ops */ Datum ts_test_status_mock(PG_FUNCTION_ARGS) { int port = 80; text *arg1 = PG_GETARG_TEXT_P(0); test_string = text_to_cstring(arg1); PG_RETURN_DATUM(test_factory(CONNECTION_MOCK, 123, TEST_ENDPOINT, port)); } #endif TS_FUNCTION_INFO_V1(ts_test_validate_server_version); Datum ts_test_validate_server_version(PG_FUNCTION_ARGS) { text *response = PG_GETARG_TEXT_P(0); VersionResult result; if (ts_validate_server_version(text_to_cstring(response), &result)) PG_RETURN_TEXT_P(cstring_to_text(result.versionstr)); PG_RETURN_NULL(); } Datum ts_test_check_version_response(PG_FUNCTION_ARGS) { text *response = PG_GETARG_TEXT_P(0); const char *volatile json = text_to_cstring(response); PG_TRY(); { ts_check_version_response(json); } PG_CATCH(); { /* If the response is malformed, ts_check_version_response() will * throw an error, so we capture the error here. The error message * contains the function pointer, which will vary between test runs, * so we do not re-throw the error here and instead print our own. */ ereport(ERROR, (errmsg("malformed telemetry response body"))); } PG_END_TRY(); PG_RETURN_VOID(); } /* Try to get the telemetry function to handle errors. Never connect to the * actual endpoint. Only test cases that will result in connection errors. */ Datum ts_test_telemetry_main_conn(PG_FUNCTION_ARGS) { text *host = PG_GETARG_TEXT_P(0); text *path = PG_GETARG_TEXT_P(1); const char *scheme; #ifdef TS_USE_OPENSSL scheme = "https"; #else scheme = "http"; #endif PG_RETURN_BOOL(ts_telemetry_main(text_to_cstring(host), text_to_cstring(path), scheme)); } Datum ts_test_telemetry(PG_FUNCTION_ARGS) { Connection *conn; ConnectionType conntype; HttpRequest *req; HttpResponseState *rsp; HttpError err; Datum json_body; const char *host = PG_ARGISNULL(0) ? TELEMETRY_HOST : text_to_cstring(PG_GETARG_TEXT_P(0)); const char *servname = PG_ARGISNULL(1) ? "https" : text_to_cstring(PG_GETARG_TEXT_P(1)); int port = PG_ARGISNULL(2) ? 0 : PG_GETARG_INT32(2); int ret; if (PG_NARGS() > 3) elog(ERROR, "invalid number of arguments"); if (strcmp("http", servname) == 0) conntype = CONNECTION_PLAIN; else if (strcmp("https", servname) == 0) conntype = CONNECTION_SSL; else elog(ERROR, "invalid service type '%s'", servname); conn = ts_connection_create(conntype); if (conn == NULL) elog(ERROR, "could not create telemetry connection"); ret = ts_connection_connect(conn, host, servname, port); if (ret < 0) { const char *errstr = ts_connection_get_and_clear_error(conn); ts_connection_destroy(conn); ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not make a connection to %s://%s", servname, host), errdetail("%s", errstr))); } req = ts_build_version_request(host, TELEMETRY_PATH); rsp = ts_http_response_state_create(); err = ts_http_send_and_recv(conn, req, rsp); ts_http_request_destroy(req); ts_connection_destroy(conn); if (err != HTTP_ERROR_NONE) { ts_http_response_state_destroy(rsp); ereport(ERROR, (errcode(ERRCODE_IO_ERROR), errmsg("telemetry error: %s", ts_http_strerror(err)))); } if (!ts_http_response_state_valid_status(rsp)) { ts_http_response_state_destroy(rsp); ereport(ERROR, (errcode(ERRCODE_IO_ERROR), errmsg("telemetry got unexpected HTTP response status: %d", ts_http_response_state_status_code(rsp)))); } json_body = DirectFunctionCall1(jsonb_in, CStringGetDatum(ts_http_response_state_body_start(rsp))); ts_http_response_state_destroy(rsp); PG_RETURN_DATUM(json_body); } �������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/test_scanner.c����������������������������������������������������������0000664�0000000�0000000�00000004745�15100345067�0020467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include "chunk.h" #include "scan_iterator.h" #include "scanner.h" #include "test_utils.h" TS_TEST_FN(ts_test_scanner) { ScanIterator it; Relation chunkrel; int32 chunk_id[2] = { -1, -1 }; size_t i = 0; /* Test pre-open relation */ it = ts_chunk_scan_iterator_create(CurrentMemoryContext); chunkrel = table_open(it.ctx.table, AccessShareLock); it.ctx.tablerel = chunkrel; /* Explicit start scan to test that we can call it twice without * issue. The loop will also call it */ ts_scan_iterator_start_scan(&it); ts_scanner_foreach(&it) { TupleInfo *ti = ts_scan_iterator_tuple_info(&it); FormData_chunk fd; ts_chunk_formdata_fill(&fd, ti); elog(NOTICE, "1. Scan: \"%s.%s\"", NameStr(fd.schema_name), NameStr(fd.table_name)); if (i < lengthof(chunk_id) && chunk_id[i] == -1) { chunk_id[i] = fd.id; i++; } } ts_scan_iterator_end(&it); /* Add a chunk filter and scan again */ ts_scan_iterator_scan_key_init(&it, Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id[0])); ts_scanner_foreach(&it) { TupleInfo *ti = ts_scan_iterator_tuple_info(&it); FormData_chunk fd; ts_chunk_formdata_fill(&fd, ti); elog(NOTICE, "2. Scan with filter: \"%s.%s\"", NameStr(fd.schema_name), NameStr(fd.table_name)); } /* Rescan */ ts_scan_iterator_scan_key_reset(&it); ts_scan_iterator_scan_key_init(&it, Anum_chunk_idx_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id[1])); ts_scan_iterator_rescan(&it); ts_scanner_foreach(&it) { TupleInfo *ti = ts_scan_iterator_tuple_info(&it); FormData_chunk fd; ts_chunk_formdata_fill(&fd, ti); elog(NOTICE, "3. ReScan: \"%s.%s\"", NameStr(fd.schema_name), NameStr(fd.table_name)); } ts_scan_iterator_end(&it); table_close(chunkrel, AccessShareLock); /* Do another scan, but an index scan this time */ it.ctx.tablerel = NULL; it.ctx.index = catalog_get_index(ts_catalog_get(), CHUNK, CHUNK_ID_INDEX); ts_scanner_foreach(&it) { TupleInfo *ti = ts_scan_iterator_tuple_info(&it); FormData_chunk fd; ts_chunk_formdata_fill(&fd, ti); elog(NOTICE, "4. IndexScan: \"%s.%s\"", NameStr(fd.schema_name), NameStr(fd.table_name)); } ts_scan_iterator_close(&it); PG_RETURN_VOID(); } ���������������������������timescaledb-2.23.0/test/src/test_time_to_internal.c�������������������������������������������������0000664�0000000�0000000�00000024416�15100345067�0022367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <utils/date.h> #include "export.h" #include "time_utils.h" #include "utils.h" #include "test_utils.h" TS_FUNCTION_INFO_V1(ts_test_time_to_internal_conversion); TS_FUNCTION_INFO_V1(ts_test_interval_to_internal_conversion); Datum ts_test_time_to_internal_conversion(PG_FUNCTION_ARGS) { int16 i16; int32 i32; int64 i64; /* test integer values */ /* int16 */ for (i16 = -100; i16 < 100; i16++) { TestAssertInt64Eq(i16, ts_time_value_to_internal(Int16GetDatum(i16), INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_internal_to_time_value(i16, INT2OID)), i16); } TestAssertInt64Eq(PG_INT16_MAX, ts_time_value_to_internal(Int16GetDatum(PG_INT16_MAX), INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_internal_to_time_value(PG_INT16_MAX, INT2OID)), PG_INT16_MAX); TestAssertInt64Eq(PG_INT16_MIN, ts_time_value_to_internal(Int16GetDatum(PG_INT16_MIN), INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_internal_to_time_value(PG_INT16_MIN, INT2OID)), PG_INT16_MIN); /* int32 */ for (i32 = -100; i32 < 100; i32++) { TestAssertInt64Eq(i32, ts_time_value_to_internal(Int32GetDatum(i32), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_time_value(i32, INT4OID)), i32); } TestAssertInt64Eq(PG_INT16_MAX, ts_time_value_to_internal(Int32GetDatum(PG_INT16_MAX), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_time_value(PG_INT16_MAX, INT4OID)), PG_INT16_MAX); TestAssertInt64Eq(PG_INT32_MAX, ts_time_value_to_internal(Int32GetDatum(PG_INT32_MAX), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_time_value(PG_INT32_MAX, INT4OID)), PG_INT32_MAX); TestAssertInt64Eq(PG_INT32_MIN, ts_time_value_to_internal(Int32GetDatum(PG_INT32_MIN), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_time_value(PG_INT32_MIN, INT4OID)), PG_INT32_MIN); /* int64 */ for (i64 = -100; i64 < 100; i64++) { TestAssertInt64Eq(i64, ts_time_value_to_internal(Int64GetDatum(i64), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_time_value(i64, INT8OID)), i64); } TestAssertInt64Eq(PG_INT16_MIN, ts_time_value_to_internal(Int64GetDatum(PG_INT16_MIN), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_time_value(PG_INT16_MIN, INT8OID)), PG_INT16_MIN); TestAssertInt64Eq(PG_INT32_MAX, ts_time_value_to_internal(Int64GetDatum(PG_INT32_MAX), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_time_value(PG_INT32_MAX, INT8OID)), PG_INT32_MAX); TestAssertInt64Eq(PG_INT64_MAX, ts_time_value_to_internal(Int64GetDatum(PG_INT64_MAX), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_time_value(PG_INT64_MAX, INT8OID)), PG_INT64_MAX); TestAssertInt64Eq(PG_INT64_MIN, ts_time_value_to_internal(Int64GetDatum(PG_INT64_MIN), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_time_value(PG_INT64_MIN, INT8OID)), PG_INT64_MIN); /* test time values round trip */ /* TIMESTAMP */ for (i64 = -100; i64 < 100; i64++) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, TIMESTAMPOID), TIMESTAMPOID)); for (i64 = -10000000; i64 < 100000000; i64 += 1000000) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, TIMESTAMPOID), TIMESTAMPOID)); for (i64 = -1000000000; i64 < 10000000000; i64 += 100000000) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, TIMESTAMPOID), TIMESTAMPOID)); TestAssertInt64Eq(TS_TIME_NOBEGIN, ts_time_value_to_internal(TimestampGetDatum(DT_NOBEGIN), TIMESTAMPOID)); TestAssertInt64Eq(TS_TIME_NOEND, ts_time_value_to_internal(TimestampGetDatum(DT_NOEND), TIMESTAMPOID)); TestAssertInt64Eq(DT_NOBEGIN, DatumGetTimestamp(ts_internal_to_time_value(PG_INT64_MIN, TIMESTAMPOID))); TestEnsureError(ts_internal_to_time_value(TS_TIMESTAMP_INTERNAL_MIN - 1, TIMESTAMPOID)); TestAssertInt64Eq(TS_TIMESTAMP_INTERNAL_MIN, ts_time_value_to_internal(ts_internal_to_time_value(TS_TIMESTAMP_INTERNAL_MIN, TIMESTAMPOID), TIMESTAMPOID)); TestAssertInt64Eq(DT_NOEND, (ts_time_value_to_internal(ts_internal_to_time_value(PG_INT64_MAX, TIMESTAMPOID), TIMESTAMPOID))); /* TIMESTAMPTZ */ for (i64 = -100; i64 < 100; i64++) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, TIMESTAMPTZOID), TIMESTAMPTZOID)); for (i64 = -10000000; i64 < 100000000; i64 += 1000000) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, TIMESTAMPTZOID), TIMESTAMPTZOID)); for (i64 = -1000000000; i64 < 10000000000; i64 += 100000000) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, TIMESTAMPTZOID), TIMESTAMPTZOID)); TestAssertInt64Eq(TS_TIME_NOBEGIN, ts_time_value_to_internal(TimestampTzGetDatum(DT_NOBEGIN), TIMESTAMPTZOID)); TestAssertInt64Eq(TS_TIME_NOEND, ts_time_value_to_internal(TimestampTzGetDatum(DT_NOEND), TIMESTAMPTZOID)); TestAssertInt64Eq(DT_NOBEGIN, DatumGetTimestampTz(ts_internal_to_time_value(PG_INT64_MIN, TIMESTAMPTZOID))); TestEnsureError(ts_internal_to_time_value(TS_TIMESTAMP_INTERNAL_MIN - 1, TIMESTAMPTZOID)); TestAssertInt64Eq(TS_TIMESTAMP_INTERNAL_MIN, ts_time_value_to_internal(ts_internal_to_time_value(TS_TIMESTAMP_INTERNAL_MIN, TIMESTAMPTZOID), TIMESTAMPTZOID)); TestAssertInt64Eq(DT_NOEND, ts_time_value_to_internal(ts_internal_to_time_value(PG_INT64_MAX, TIMESTAMPTZOID), TIMESTAMPTZOID)); /* DATE */ for (i64 = -100 * USECS_PER_DAY; i64 < 100 * USECS_PER_DAY; i64 += USECS_PER_DAY) TestAssertInt64Eq(i64, ts_time_value_to_internal(ts_internal_to_time_value(i64, DATEOID), DATEOID)); TestAssertInt64Eq(DATEVAL_NOBEGIN, DatumGetDateADT(ts_internal_to_time_value(PG_INT64_MIN, DATEOID))); TestAssertInt64Eq(DATEVAL_NOEND, DatumGetDateADT(ts_internal_to_time_value(PG_INT64_MAX, DATEOID))); TestEnsureError(ts_time_value_to_internal(DateADTGetDatum(DATEVAL_NOBEGIN + 1), DATEOID)); TestEnsureError(ts_time_value_to_internal(DateADTGetDatum(DATEVAL_NOEND - 1), DATEOID)); PG_RETURN_VOID(); }; Datum ts_test_interval_to_internal_conversion(PG_FUNCTION_ARGS) { int16 i16; int32 i32; int64 i64; /* test integer values */ /* int16 */ for (i16 = -100; i16 < 100; i16++) { TestAssertInt64Eq(i16, ts_interval_value_to_internal(Int16GetDatum(i16), INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_internal_to_interval_value(i16, INT2OID)), i16); } TestAssertInt64Eq(PG_INT16_MAX, ts_interval_value_to_internal(Int16GetDatum(PG_INT16_MAX), INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_internal_to_interval_value(PG_INT16_MAX, INT2OID)), PG_INT16_MAX); TestAssertInt64Eq(PG_INT16_MIN, ts_interval_value_to_internal(Int16GetDatum(PG_INT16_MIN), INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_internal_to_interval_value(PG_INT16_MIN, INT2OID)), PG_INT16_MIN); /* int32 */ for (i32 = -100; i32 < 100; i32++) { TestAssertInt64Eq(i32, ts_interval_value_to_internal(Int32GetDatum(i32), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_interval_value(i32, INT4OID)), i32); } TestAssertInt64Eq(PG_INT16_MAX, ts_interval_value_to_internal(Int32GetDatum(PG_INT16_MAX), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_interval_value(PG_INT16_MAX, INT4OID)), PG_INT16_MAX); TestAssertInt64Eq(PG_INT32_MAX, ts_interval_value_to_internal(Int32GetDatum(PG_INT32_MAX), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_interval_value(PG_INT32_MAX, INT4OID)), PG_INT32_MAX); TestAssertInt64Eq(PG_INT32_MIN, ts_interval_value_to_internal(Int32GetDatum(PG_INT32_MIN), INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_internal_to_interval_value(PG_INT32_MIN, INT4OID)), PG_INT32_MIN); /* int64 */ for (i64 = -100; i64 < 100; i64++) { TestAssertInt64Eq(i64, ts_interval_value_to_internal(Int64GetDatum(i64), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_interval_value(i64, INT8OID)), i64); } TestAssertInt64Eq(PG_INT16_MIN, ts_interval_value_to_internal(Int64GetDatum(PG_INT16_MIN), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_interval_value(PG_INT16_MIN, INT8OID)), PG_INT16_MIN); TestAssertInt64Eq(PG_INT32_MAX, ts_interval_value_to_internal(Int64GetDatum(PG_INT32_MAX), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_interval_value(PG_INT32_MAX, INT8OID)), PG_INT32_MAX); TestAssertInt64Eq(PG_INT64_MAX, ts_interval_value_to_internal(Int64GetDatum(PG_INT64_MAX), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_interval_value(PG_INT64_MAX, INT8OID)), PG_INT64_MAX); TestAssertInt64Eq(PG_INT64_MIN, ts_interval_value_to_internal(Int64GetDatum(PG_INT64_MIN), INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_internal_to_interval_value(PG_INT64_MIN, INT8OID)), PG_INT64_MIN); /* INTERVAL */ for (i64 = -100; i64 < 100; i64++) TestAssertInt64Eq(i64, ts_interval_value_to_internal(ts_internal_to_interval_value(i64, INTERVALOID), INTERVALOID)); for (i64 = -10000000; i64 < 100000000; i64 += 1000000) TestAssertInt64Eq(i64, ts_interval_value_to_internal(ts_internal_to_interval_value(i64, INTERVALOID), INTERVALOID)); for (i64 = -1000000000; i64 < 10000000000; i64 += 100000000) TestAssertInt64Eq(i64, ts_interval_value_to_internal(ts_internal_to_interval_value(i64, INTERVALOID), INTERVALOID)); TestAssertInt64Eq(PG_INT64_MIN, ts_interval_value_to_internal(ts_internal_to_interval_value(PG_INT64_MIN, INTERVALOID), INTERVALOID)); TestAssertInt64Eq(PG_INT64_MAX, ts_interval_value_to_internal(ts_internal_to_interval_value(PG_INT64_MAX, INTERVALOID), INTERVALOID)); PG_RETURN_VOID(); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/test_time_utils.c�������������������������������������������������������0000664�0000000�0000000�00000033033�15100345067�0021204�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <funcapi.h> #include <utils/date.h> #include <time_utils.h> #include <utils.h> #include "test_utils.h" /* * Functions to show TimescaleDB-specific limits of timestamps and dates: */ /* * TIMESTAMP WITH TIME ZONE */ TS_FUNCTION_INFO_V1(ts_timestamptz_pg_min); Datum ts_timestamptz_pg_min(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMPTZ(MIN_TIMESTAMP); } TS_FUNCTION_INFO_V1(ts_timestamptz_pg_end); Datum ts_timestamptz_pg_end(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMPTZ(END_TIMESTAMP); } TS_FUNCTION_INFO_V1(ts_timestamptz_min); Datum ts_timestamptz_min(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMPTZ(TS_TIMESTAMP_MIN); } TS_FUNCTION_INFO_V1(ts_timestamptz_end); Datum ts_timestamptz_end(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMPTZ(TS_TIMESTAMP_END); } TS_FUNCTION_INFO_V1(ts_timestamptz_internal_min); Datum ts_timestamptz_internal_min(PG_FUNCTION_ARGS) { PG_RETURN_INT64(TS_TIMESTAMP_INTERNAL_MIN); } TS_FUNCTION_INFO_V1(ts_timestamptz_internal_end); Datum ts_timestamptz_internal_end(PG_FUNCTION_ARGS) { PG_RETURN_INT64(TS_TIMESTAMP_INTERNAL_END); } /* * TIMESTAMP */ TS_FUNCTION_INFO_V1(ts_timestamp_pg_min); Datum ts_timestamp_pg_min(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMP(MIN_TIMESTAMP); } TS_FUNCTION_INFO_V1(ts_timestamp_pg_end); Datum ts_timestamp_pg_end(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMP(END_TIMESTAMP); } TS_FUNCTION_INFO_V1(ts_timestamp_min); Datum ts_timestamp_min(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMP(TS_TIMESTAMP_MIN); } TS_FUNCTION_INFO_V1(ts_timestamp_end); Datum ts_timestamp_end(PG_FUNCTION_ARGS) { PG_RETURN_TIMESTAMP(TS_TIMESTAMP_END); } TS_FUNCTION_INFO_V1(ts_timestamp_internal_min); Datum ts_timestamp_internal_min(PG_FUNCTION_ARGS) { PG_RETURN_INT64(TS_TIMESTAMP_INTERNAL_MIN); } TS_FUNCTION_INFO_V1(ts_timestamp_internal_end); Datum ts_timestamp_internal_end(PG_FUNCTION_ARGS) { PG_RETURN_INT64(TS_TIMESTAMP_INTERNAL_END); } /* * DATE */ TS_FUNCTION_INFO_V1(ts_date_pg_min); Datum ts_date_pg_min(PG_FUNCTION_ARGS) { PG_RETURN_DATEADT(DATETIME_MIN_JULIAN - POSTGRES_EPOCH_JDATE); } TS_FUNCTION_INFO_V1(ts_date_pg_end); Datum ts_date_pg_end(PG_FUNCTION_ARGS) { PG_RETURN_DATEADT(DATE_END_JULIAN - POSTGRES_EPOCH_JDATE); } TS_FUNCTION_INFO_V1(ts_date_min); Datum ts_date_min(PG_FUNCTION_ARGS) { PG_RETURN_DATEADT(TS_DATE_MIN); } TS_FUNCTION_INFO_V1(ts_date_end); Datum ts_date_end(PG_FUNCTION_ARGS) { PG_RETURN_DATEADT(TS_DATE_END); } TS_FUNCTION_INFO_V1(ts_date_internal_min); Datum ts_date_internal_min(PG_FUNCTION_ARGS) { PG_RETURN_INT64(TS_DATE_INTERNAL_MIN); } TS_FUNCTION_INFO_V1(ts_date_internal_end); Datum ts_date_internal_end(PG_FUNCTION_ARGS) { PG_RETURN_INT64(TS_DATE_INTERNAL_END); } TS_FUNCTION_INFO_V1(ts_test_time_utils); Datum ts_test_time_utils(PG_FUNCTION_ARGS) { TestAssertInt64Eq(ts_time_get_min(INT8OID), PG_INT64_MIN); TestAssertInt64Eq(ts_time_get_max(INT8OID), PG_INT64_MAX); TestAssertInt64Eq(ts_time_get_end_or_max(INT8OID), PG_INT64_MAX); TestEnsureError(ts_time_get_end(INT8OID)); TestEnsureError(ts_time_get_nobegin(INT8OID)); TestEnsureError(ts_time_get_noend(INT8OID)); TestAssertInt64Eq(DatumGetInt64(ts_time_datum_get_nobegin_or_min(INT8OID)), PG_INT64_MIN); TestAssertInt64Eq(DatumGetInt64(ts_time_datum_get_min(INT8OID)), PG_INT64_MIN); TestAssertInt64Eq(DatumGetInt64(ts_time_datum_get_max(INT8OID)), PG_INT64_MAX); TestEnsureError(ts_time_datum_get_end(INT8OID)); TestEnsureError(ts_time_datum_get_nobegin(INT8OID)); TestEnsureError(ts_time_datum_get_noend(INT8OID)); TestAssertInt64Eq(ts_time_get_min(INT4OID), PG_INT32_MIN); TestAssertInt64Eq(ts_time_get_max(INT4OID), PG_INT32_MAX); TestAssertInt64Eq(ts_time_get_end_or_max(INT4OID), PG_INT32_MAX); TestEnsureError(ts_time_get_end(INT4OID)); TestEnsureError(ts_time_get_nobegin(INT4OID)); TestEnsureError(ts_time_get_noend(INT4OID)); TestAssertInt64Eq(DatumGetInt32(ts_time_datum_get_nobegin_or_min(INT4OID)), PG_INT32_MIN); TestAssertInt64Eq(DatumGetInt32(ts_time_datum_get_min(INT4OID)), PG_INT32_MIN); TestAssertInt64Eq(DatumGetInt32(ts_time_datum_get_max(INT4OID)), PG_INT32_MAX); TestEnsureError(ts_time_datum_get_end(INT4OID)); TestEnsureError(ts_time_datum_get_nobegin(INT4OID)); TestEnsureError(ts_time_datum_get_noend(INT4OID)); TestAssertInt64Eq(ts_time_get_min(INT2OID), PG_INT16_MIN); TestAssertInt64Eq(ts_time_get_max(INT2OID), PG_INT16_MAX); TestAssertInt64Eq(ts_time_get_end_or_max(INT2OID), PG_INT16_MAX); TestEnsureError(ts_time_get_end(INT2OID)); TestEnsureError(ts_time_get_nobegin(INT2OID)); TestEnsureError(ts_time_get_noend(INT2OID)); TestAssertInt64Eq(DatumGetInt16(ts_time_datum_get_nobegin_or_min(INT2OID)), PG_INT16_MIN); TestAssertInt64Eq(DatumGetInt16(ts_time_datum_get_min(INT2OID)), PG_INT16_MIN); TestAssertInt64Eq(DatumGetInt16(ts_time_datum_get_max(INT2OID)), PG_INT16_MAX); TestEnsureError(ts_time_datum_get_end(INT2OID)); TestEnsureError(ts_time_datum_get_nobegin(INT2OID)); TestEnsureError(ts_time_datum_get_noend(INT2OID)); TestAssertInt64Eq(ts_time_get_min(TIMESTAMPOID), TS_TIMESTAMP_INTERNAL_MIN); TestAssertInt64Eq(ts_time_get_max(TIMESTAMPOID), TS_TIMESTAMP_INTERNAL_MAX); TestAssertInt64Eq(ts_time_get_end(TIMESTAMPOID), TS_TIMESTAMP_INTERNAL_END); TestAssertInt64Eq(ts_time_get_end_or_max(TIMESTAMPOID), TS_TIMESTAMP_INTERNAL_END); TestAssertInt64Eq(ts_time_get_nobegin(TIMESTAMPOID), TS_TIME_NOBEGIN); TestAssertInt64Eq(ts_time_get_noend(TIMESTAMPOID), TS_TIME_NOEND); TestAssertInt64Eq(DatumGetTimestamp(ts_time_datum_get_nobegin_or_min(TIMESTAMPOID)), DT_NOBEGIN); TestAssertInt64Eq(DatumGetTimestamp(ts_time_datum_get_min(TIMESTAMPOID)), TS_TIMESTAMP_MIN); TestAssertInt64Eq(DatumGetTimestamp(ts_time_datum_get_max(TIMESTAMPOID)), TS_TIMESTAMP_MAX); TestAssertInt64Eq(DatumGetTimestamp(ts_time_datum_get_end(TIMESTAMPOID)), TS_TIMESTAMP_END); TestAssertInt64Eq(DatumGetTimestamp(ts_time_datum_get_nobegin(TIMESTAMPOID)), DT_NOBEGIN); TestAssertInt64Eq(DatumGetTimestamp(ts_time_datum_get_noend(TIMESTAMPOID)), DT_NOEND); TestAssertInt64Eq(ts_time_get_min(TIMESTAMPTZOID), TS_TIMESTAMP_INTERNAL_MIN); TestAssertInt64Eq(ts_time_get_max(TIMESTAMPTZOID), TS_TIMESTAMP_INTERNAL_MAX); TestAssertInt64Eq(ts_time_get_end(TIMESTAMPTZOID), TS_TIMESTAMP_INTERNAL_END); TestAssertInt64Eq(ts_time_get_end_or_max(TIMESTAMPTZOID), TS_TIMESTAMP_INTERNAL_END); TestAssertInt64Eq(ts_time_get_nobegin(TIMESTAMPTZOID), TS_TIME_NOBEGIN); TestAssertInt64Eq(ts_time_get_noend(TIMESTAMPTZOID), TS_TIME_NOEND); TestAssertInt64Eq(DatumGetTimestampTz(ts_time_datum_get_nobegin_or_min(TIMESTAMPTZOID)), DT_NOBEGIN); TestAssertInt64Eq(DatumGetTimestampTz(ts_time_datum_get_min(TIMESTAMPTZOID)), TS_TIMESTAMP_MIN); TestAssertInt64Eq(DatumGetTimestampTz(ts_time_datum_get_max(TIMESTAMPTZOID)), TS_TIMESTAMP_MAX); TestAssertInt64Eq(DatumGetTimestampTz(ts_time_datum_get_end(TIMESTAMPTZOID)), TS_TIMESTAMP_END); TestAssertInt64Eq(DatumGetTimestampTz(ts_time_datum_get_nobegin(TIMESTAMPTZOID)), DT_NOBEGIN); TestAssertInt64Eq(DatumGetTimestampTz(ts_time_datum_get_noend(TIMESTAMPTZOID)), DT_NOEND); TestAssertInt64Eq(ts_time_get_min(DATEOID), TS_DATE_INTERNAL_MIN); TestAssertInt64Eq(ts_time_get_max(DATEOID), TS_DATE_INTERNAL_MAX); TestAssertInt64Eq(ts_time_get_end(DATEOID), TS_DATE_INTERNAL_END); TestAssertInt64Eq(ts_time_get_end_or_max(DATEOID), TS_DATE_INTERNAL_END); TestAssertInt64Eq(ts_time_get_nobegin(DATEOID), TS_TIME_NOBEGIN); TestAssertInt64Eq(ts_time_get_noend(DATEOID), TS_TIME_NOEND); TestAssertInt64Eq(DatumGetDateADT(ts_time_datum_get_nobegin_or_min(DATEOID)), DATEVAL_NOBEGIN); TestAssertInt64Eq(DatumGetDateADT(ts_time_datum_get_min(DATEOID)), TS_DATE_MIN); TestAssertInt64Eq(DatumGetDateADT(ts_time_datum_get_max(DATEOID)), TS_DATE_MAX); TestAssertInt64Eq(DatumGetDateADT(ts_time_datum_get_end(DATEOID)), TS_DATE_END); TestAssertInt64Eq(DatumGetDateADT(ts_time_datum_get_nobegin(DATEOID)), DATEVAL_NOBEGIN); TestAssertInt64Eq(DatumGetDateADT(ts_time_datum_get_noend(DATEOID)), DATEVAL_NOEND); /* Test boundary routines with unsupported time type */ TestEnsureError(ts_time_get_min(NUMERICOID)); TestEnsureError(ts_time_get_max(NUMERICOID)); TestEnsureError(ts_time_get_end(NUMERICOID)); TestEnsureError(ts_time_get_nobegin(NUMERICOID)); TestEnsureError(ts_time_get_noend(NUMERICOID)); TestEnsureError(ts_time_datum_get_nobegin_or_min(NUMERICOID)); TestEnsureError(ts_time_datum_get_min(NUMERICOID)); TestEnsureError(ts_time_datum_get_max(NUMERICOID)); TestEnsureError(ts_time_datum_get_end(NUMERICOID)); TestEnsureError(ts_time_datum_get_nobegin(NUMERICOID)); TestEnsureError(ts_time_datum_get_noend(NUMERICOID)); /* Test conversion of min, end, nobegin, and noend between native and * internal (Unix) time */ TestAssertInt64Eq(ts_time_value_to_internal(ts_time_datum_get_min(INT2OID), INT2OID), ts_time_get_min(INT2OID)); TestAssertInt64Eq(ts_time_value_to_internal(ts_time_datum_get_min(INT4OID), INT4OID), ts_time_get_min(INT4OID)); TestAssertInt64Eq(ts_time_value_to_internal(ts_time_datum_get_min(INT8OID), INT8OID), ts_time_get_min(INT8OID)); TestAssertInt64Eq(ts_time_value_to_internal(ts_time_datum_get_min(DATEOID), DATEOID), ts_time_get_min(DATEOID)); TestAssertInt64Eq(ts_time_value_to_internal(ts_time_datum_get_min(TIMESTAMPOID), TIMESTAMPOID), ts_time_get_min(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_value_to_internal(ts_time_datum_get_min(TIMESTAMPTZOID), TIMESTAMPTZOID), ts_time_get_min(TIMESTAMPTZOID)); /* Test saturating addition */ TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(INT2OID), 1, INT2OID), ts_time_get_max(INT2OID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(INT4OID), 1, INT4OID), ts_time_get_max(INT4OID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(INT8OID), 1, INT8OID), ts_time_get_max(INT8OID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(DATEOID), 1, DATEOID), ts_time_get_noend(DATEOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(DATEOID), 1, DATEOID), ts_time_get_noend(DATEOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(TIMESTAMPOID), 1, TIMESTAMPOID), ts_time_get_noend(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_max(TIMESTAMPTZOID), 1, TIMESTAMPOID), ts_time_get_noend(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_end(DATEOID) - 2, 1, DATEOID), ts_time_get_max(DATEOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_end(TIMESTAMPOID) - 2, 1, TIMESTAMPOID), ts_time_get_max(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_end(TIMESTAMPTZOID) - 2, 1, TIMESTAMPOID), ts_time_get_max(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(INT2OID), -1, INT2OID), ts_time_get_min(INT2OID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(INT4OID), -1, INT4OID), ts_time_get_min(INT4OID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(INT8OID), -1, INT8OID), ts_time_get_min(INT8OID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(DATEOID), -1, DATEOID), ts_time_get_nobegin(DATEOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(DATEOID), -1, DATEOID), ts_time_get_nobegin(DATEOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(TIMESTAMPOID), -1, TIMESTAMPOID), ts_time_get_nobegin(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_add(ts_time_get_min(TIMESTAMPTZOID), -1, TIMESTAMPOID), ts_time_get_nobegin(TIMESTAMPOID)); /* Test saturating subtraction */ TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(INT2OID), 1, INT2OID), ts_time_get_min(INT2OID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(INT4OID), 1, INT4OID), ts_time_get_min(INT4OID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(INT8OID), 1, INT8OID), ts_time_get_min(INT8OID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(DATEOID), 1, DATEOID), ts_time_get_nobegin(DATEOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(TIMESTAMPOID), 1, TIMESTAMPOID), ts_time_get_nobegin(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(TIMESTAMPTZOID), 1, TIMESTAMPTZOID), ts_time_get_nobegin(TIMESTAMPTZOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(DATEOID) + 1, 1, DATEOID), ts_time_get_min(DATEOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(TIMESTAMPOID) + 1, 1, TIMESTAMPOID), ts_time_get_min(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_min(TIMESTAMPTZOID) + 1, 1, TIMESTAMPTZOID), ts_time_get_min(TIMESTAMPTZOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_max(INT2OID), -1, INT2OID), ts_time_get_max(INT2OID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_max(INT4OID), -1, INT4OID), ts_time_get_max(INT4OID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_max(INT8OID), -1, INT8OID), ts_time_get_max(INT8OID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_max(DATEOID), -1, DATEOID), ts_time_get_noend(DATEOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_max(TIMESTAMPOID), -1, TIMESTAMPOID), ts_time_get_noend(TIMESTAMPOID)); TestAssertInt64Eq(ts_time_saturating_sub(ts_time_get_max(TIMESTAMPTZOID), -1, TIMESTAMPTZOID), ts_time_get_noend(TIMESTAMPTZOID)); PG_RETURN_VOID(); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/test_tss_callbacks.c����������������������������������������������������0000664�0000000�0000000�00000003357�15100345067�0021644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <funcapi.h> #include "export.h" #include "tss_callbacks.h" static void test_tss_store_hook(const char *query, int query_location, int query_len, uint64 query_id, uint64 total_time, uint64 rows, const BufferUsage *bufusage, const WalUsage *walusage) { elog(NOTICE, "test_tss_callbacks (mock): query=%s, len=%d, id=" INT64_FORMAT ", rows=" INT64_FORMAT, query, query_len, query_id, rows); } static bool test_tss_enabled_hook(int level) { return true; } TSSCallbacks test_tss_callbacks_v1 = { .version_num = 1, .tss_store_hook = test_tss_store_hook, .tss_enabled_hook_type = test_tss_enabled_hook, }; TS_FUNCTION_INFO_V1(ts_setup_tss_hook_v1); Datum ts_setup_tss_hook_v1(PG_FUNCTION_ARGS) { TSSCallbacks **ptr = (TSSCallbacks **) find_rendezvous_variable(TSS_CALLBACKS_VAR_NAME); *ptr = &test_tss_callbacks_v1; PG_RETURN_NULL(); } TS_FUNCTION_INFO_V1(ts_teardown_tss_hook_v1); Datum ts_teardown_tss_hook_v1(PG_FUNCTION_ARGS) { TSSCallbacks **ptr = (TSSCallbacks **) find_rendezvous_variable(TSS_CALLBACKS_VAR_NAME); *ptr = NULL; PG_RETURN_NULL(); } /* This version will mismatch with the current supported */ TSSCallbacks test_tss_callbacks_v0 = { .version_num = 0, .tss_store_hook = test_tss_store_hook, .tss_enabled_hook_type = test_tss_enabled_hook, }; TS_FUNCTION_INFO_V1(ts_setup_tss_hook_v0); Datum ts_setup_tss_hook_v0(PG_FUNCTION_ARGS) { TSSCallbacks **ptr = (TSSCallbacks **) find_rendezvous_variable(TSS_CALLBACKS_VAR_NAME); *ptr = &test_tss_callbacks_v0; PG_RETURN_NULL(); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/test_utils.c������������������������������������������������������������0000664�0000000�0000000�00000021475�15100345067�0020175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include "test_utils.h" #include <postgres.h> #include <compat/compat.h> #include <commands/dbcommands.h> #include <fmgr.h> #include <miscadmin.h> #include <storage/latch.h> #include <storage/proc.h> #include <storage/procarray.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/guc.h> #include <utils/memutils.h> #include "debug_point.h" #include "extension_constants.h" #include "utils.h" TS_FUNCTION_INFO_V1(ts_test_error_injection); TS_FUNCTION_INFO_V1(ts_debug_shippable_error_after_n_rows); TS_FUNCTION_INFO_V1(ts_debug_shippable_fatal_after_n_rows); /* * Test assertion macros. * * Errors are expected since we want to test that the macros work. For each * macro, test one failing and one non-failing condition. The non-failing must * come first since the failing one will abort the function. */ TS_TEST_FN(ts_test_utils_condition) { bool true_value = true; bool false_value = false; TestAssertTrue(true_value == true_value); TestAssertTrue(true_value == false_value); PG_RETURN_VOID(); } TS_TEST_FN(ts_test_utils_int64_eq) { int64 big = 32532978; int64 small = 3242234; TestAssertInt64Eq(big, small); TestAssertInt64Eq(big, big); PG_RETURN_VOID(); } TS_TEST_FN(ts_test_utils_ptr_eq) { bool true_value = true; bool false_value = false; bool *true_ptr = &true_value; bool *false_ptr = &false_value; TestAssertPtrEq(true_ptr, true_ptr); TestAssertPtrEq(true_ptr, false_ptr); PG_RETURN_VOID(); } TS_TEST_FN(ts_test_utils_double_eq) { double big_double = 923423478.3242; double small_double = 324.3; TestAssertDoubleEq(big_double, big_double); TestAssertDoubleEq(big_double, small_double); PG_RETURN_VOID(); } Datum ts_test_error_injection(PG_FUNCTION_ARGS) { text *name = PG_GETARG_TEXT_PP(0); DEBUG_ERROR_INJECTION(text_to_cstring(name)); PG_RETURN_VOID(); } static int transaction_row_counter(void) { static LocalTransactionId last_lxid = 0; static int rows_seen = 0; #if PG17_GE if (last_lxid != MyProc->vxid.lxid) { /* Reset it for each new transaction for predictable results. */ rows_seen = 0; last_lxid = MyProc->vxid.lxid; } #else if (last_lxid != MyProc->lxid) { rows_seen = 0; last_lxid = MyProc->lxid; } #endif return rows_seen++; } static int throw_after_n_rows(int max_rows, int severity) { int rows_seen = transaction_row_counter(); if (max_rows <= rows_seen) { ereport(severity, (errmsg("debug point: requested to error out after %d rows, %d rows seen", max_rows, rows_seen))); } return rows_seen; } Datum ts_debug_shippable_error_after_n_rows(PG_FUNCTION_ARGS) { PG_RETURN_INT32(throw_after_n_rows(PG_GETARG_INT32(0), ERROR)); } Datum ts_debug_shippable_fatal_after_n_rows(PG_FUNCTION_ARGS) { PG_RETURN_INT32(throw_after_n_rows(PG_GETARG_INT32(0), FATAL)); } /* * After how many rows should we error out according to the user-set option. */ static int get_error_after_rows() { int error_after = 7103; /* default is an arbitrary prime */ const char *error_after_option = GetConfigOption(MAKE_EXTOPTION("debug_broken_sendrecv_error_after"), true, false); if (error_after_option) { error_after = pg_strtoint32(error_after_option); } return error_after; } /* * Broken send/receive functions for int4 that throw after an (arbitrarily * chosen prime or configured) number of rows. */ static void broken_sendrecv_throw() { /* * Use ERROR, not FATAL, because PG versions < 14 are unable to report a * FATAL error to the access node before closing the connection, so the test * results would be different. */ (void) throw_after_n_rows(get_error_after_rows(), ERROR); } TS_FUNCTION_INFO_V1(ts_debug_broken_int4recv); Datum ts_debug_broken_int4recv(PG_FUNCTION_ARGS) { broken_sendrecv_throw(); return int4recv(fcinfo); } TS_FUNCTION_INFO_V1(ts_debug_broken_int4send); Datum ts_debug_broken_int4send(PG_FUNCTION_ARGS) { broken_sendrecv_throw(); return int4send(fcinfo); } /* An incorrect int4out that sometimes returns not a number. */ TS_FUNCTION_INFO_V1(ts_debug_incorrect_int4out); Datum ts_debug_incorrect_int4out(PG_FUNCTION_ARGS) { int rows_seen = transaction_row_counter(); if (rows_seen >= get_error_after_rows()) { PG_RETURN_CSTRING("surprise"); } return int4out(fcinfo); } /* Sleeps after a certain number of calls. */ static void ts_debug_sleepy_function() { static LocalTransactionId last_lxid = 0; static int rows_seen = 0; #if PG17_GE if (last_lxid != MyProc->vxid.lxid) { /* Reset it for each new transaction for predictable results. */ rows_seen = 0; last_lxid = MyProc->vxid.lxid; } #else if (last_lxid != MyProc->lxid) { rows_seen = 0; last_lxid = MyProc->lxid; } #endif rows_seen++; if (rows_seen >= 997) { (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, 1000, /* wait_event_info = */ 0); ResetLatch(MyLatch); rows_seen = 0; } } TS_FUNCTION_INFO_V1(ts_debug_sleepy_int4recv); Datum ts_debug_sleepy_int4recv(PG_FUNCTION_ARGS) { ts_debug_sleepy_function(); return int4recv(fcinfo); } TS_FUNCTION_INFO_V1(ts_debug_sleepy_int4send); Datum ts_debug_sleepy_int4send(PG_FUNCTION_ARGS) { ts_debug_sleepy_function(); return int4send(fcinfo); } TS_FUNCTION_INFO_V1(ts_bgw_wait); Datum ts_bgw_wait(PG_FUNCTION_ARGS) { text *datname = PG_GETARG_TEXT_PP(0); /* The timeout is given in seconds, so we compute the number of iterations * necessary to get a coverage of that time */ uint32 iterations = PG_ARGISNULL(1) ? 5 : (PG_GETARG_UINT32(1) + 4) / 5; bool raise_error = PG_ARGISNULL(2) ? true : PG_GETARG_BOOL(2); Oid dboid = get_database_oid(text_to_cstring(datname), false); /* This function contains a timeout of 5 seconds, so we iterate a few * times to make sure that it really has terminated. */ int notherbackends = 0; int npreparedxacts = 0; while (iterations-- > 0) { if (!CountOtherDBBackends(dboid, ¬herbackends, &npreparedxacts)) PG_RETURN_NULL(); ereport(NOTICE, (errmsg("source database \"%s\" is being accessed by other users", text_to_cstring(datname)), errdetail("There are %d other session(s) and %d prepared transaction(s) using the " "database.", notherbackends, npreparedxacts))); } if (raise_error) { ereport(ERROR, (errcode(ERRCODE_OBJECT_IN_USE), errmsg("source database \"%s\" is being accessed by other users", text_to_cstring(datname)), errdetail("There are %d other session(s) and %d prepared transaction(s) using the " "database.", notherbackends, npreparedxacts))); } pg_unreachable(); } /* * Return the number of bytes allocated in a given memory context and its * children. */ TS_FUNCTION_INFO_V1(ts_debug_allocated_bytes); Datum ts_debug_allocated_bytes(PG_FUNCTION_ARGS) { MemoryContext context = NULL; char *context_name = text_to_cstring(PG_GETARG_TEXT_PP(0)); if (strcmp(context_name, "PortalContext") == 0) { context = PortalContext; } else if (strcmp(context_name, "CacheMemoryContext") == 0) { context = CacheMemoryContext; } else if (strcmp(context_name, "TopMemoryContext") == 0) { context = TopMemoryContext; } else { ereport(ERROR, (errmsg("unknown memory context '%s' (search for arbitrary contexts by name is not" "implemented)", context_name))); PG_RETURN_NULL(); } PG_RETURN_UINT64(MemoryContextMemAllocated(context, /* recurse = */ true)); } TS_TEST_FN(ts_test_errdata_to_jsonb) { ErrorData *edata = (ErrorData *) palloc(sizeof(ErrorData)); edata->elevel = ERROR; edata->output_to_server = true; edata->output_to_client = true; edata->hide_stmt = false; edata->hide_ctx = false; edata->filename = "test error filename"; edata->lineno = 123; edata->funcname = "test error function"; edata->domain = "test error domain"; edata->context_domain = "test error context domain"; edata->sqlerrcode = ERRCODE_INVALID_PARAMETER_VALUE; edata->message = "test error message"; edata->detail = "test error detail"; edata->detail_log = "test error detail log"; edata->hint = "test error hint"; edata->context = "test error context"; edata->backtrace = "test error backtrace"; edata->message_id = "test error message id"; edata->schema_name = "test error schema"; edata->table_name = "test error table"; edata->column_name = "test error column"; edata->datatype_name = "test error datatype"; edata->constraint_name = "test error constraint"; edata->cursorpos = 42; edata->internalpos = 42; edata->internalquery = "test error internal query"; edata->saved_errno = 42; NameData proc_schema = { .data = { 0 } }; NameData proc_name = { .data = { 0 } }; namestrcpy(&proc_schema, "proc_schema"); namestrcpy(&proc_name, "proc_name"); Jsonb *out = ts_errdata_to_jsonb(edata, &proc_schema, &proc_name); PG_RETURN_JSONB_P(out); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/test_utils.h������������������������������������������������������������0000664�0000000�0000000�00000013424�15100345067�0020175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/xact.h> #include <fmgr.h> #include "export.h" static inline const char * strip_path(const char *filename) { int i = 0, slash = 0; while (filename[i] != '\0') { if (filename[i] == '/' || filename[i] == '\\') slash = i; i++; } return &filename[slash + 1]; } #define TestFailure(fmt, ...) \ do \ { \ elog(ERROR, "TestFailure | " fmt "", ##__VA_ARGS__); \ pg_unreachable(); \ } while (0) #define TestAssertInt64Eq(a, b) \ do \ { \ int64 a_i = (a); \ int64 b_i = (b); \ if (a_i != b_i) \ TestFailure("(%s == %s) [" INT64_FORMAT " == " INT64_FORMAT "]", #a, #b, a_i, b_i); \ } while (0) #define TestAssertPtrEq(a, b) \ do \ { \ void *a_i = (a); \ void *b_i = (b); \ if (a_i != b_i) \ TestFailure("(%s == %s)", #a, #b); \ } while (0) #define TestAssertDoubleEq(a, b) \ do \ { \ double a_i = (a); \ double b_i = (b); \ if (a_i != b_i) \ TestFailure("(%s == %s) [%f == %f]", #a, #b, a_i, b_i); \ } while (0) #define TestEnsureError(a) \ do \ { \ volatile bool this_has_panicked = false; \ MemoryContext oldctx = CurrentMemoryContext; \ BeginInternalSubTransaction("error expected"); \ PG_TRY(); \ { \ (a); \ } \ PG_CATCH(); \ { \ this_has_panicked = true; \ RollbackAndReleaseCurrentSubTransaction(); \ FlushErrorState(); \ } \ PG_END_TRY(); \ MemoryContextSwitchTo(oldctx); \ if (!this_has_panicked) \ { \ elog(ERROR, "failed to panic"); \ } \ } while (0) #define TestAssertTrue(cond) \ do \ { \ if (!(cond)) \ TestFailure("(%s)", #cond); \ } while (0) #define TS_TEST_FN(name) \ TS_FUNCTION_INFO_V1(name); \ Datum name(PG_FUNCTION_ARGS) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/src/test_with_clause_parser.c�����������������������������������������������0000664�0000000�0000000�00000021474�15100345067�0022717�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Apache License 2.0. * Please see the included NOTICE for copyright information and * LICENSE-APACHE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <commands/defrem.h> #include <fmgr.h> #include <funcapi.h> #include <postgres_ext.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/regproc.h> #include "annotations.h" #include "export.h" #include "test_utils.h" #include "with_clause/with_clause_parser.h" TS_FUNCTION_INFO_V1(ts_sqlstate_raise_in); TS_FUNCTION_INFO_V1(ts_sqlstate_raise_out); /* * Input function that will raise the error code give. This means that you can * trigger an error when reading and converting a string to this type. */ Datum ts_sqlstate_raise_in(PG_FUNCTION_ARGS) { char *code = PG_GETARG_CSTRING(0); if (strlen(code) != 5) ereport(ERROR, errcode(ERRCODE_SYNTAX_ERROR), errmsg("error code \"%s\" was not of length 5", code)); int sqlstate = MAKE_SQLSTATE(code[0], code[1], code[2], code[3], code[4]); ereport(ERROR, errcode(sqlstate), errmsg("raised requested error code \"%s\"", code)); return 0; } /* * Dummy function, we do not store values of this type anywhere. */ Datum ts_sqlstate_raise_out(PG_FUNCTION_ARGS) { PG_RETURN_CSTRING("uninteresting"); } static DefElem * def_elem_from_texts(Datum *texts, int nelems) { DefElem *elem = palloc0(sizeof(*elem)); switch (nelems) { case 1: elem->defname = text_to_cstring(DatumGetTextP(texts[0])); break; case 3: elem->arg = (Node *) makeString(text_to_cstring(DatumGetTextP(texts[2]))); TS_FALLTHROUGH; case 2: elem->defname = text_to_cstring(DatumGetTextP(texts[1])); elem->defnamespace = text_to_cstring(DatumGetTextP(texts[0])); break; default: elog(ERROR, "%d elements invalid for defelem", nelems); } return elem; } static List * def_elems_from_array(ArrayType *with_clause_array) { ArrayMetaState with_clause_meta = { .element_type = TEXTOID }; ArrayIterator with_clause_iter; Datum with_clause_datum; bool with_clause_null; List *def_elems = NIL; get_typlenbyvalalign(with_clause_meta.element_type, &with_clause_meta.typlen, &with_clause_meta.typbyval, &with_clause_meta.typalign); with_clause_iter = array_create_iterator(with_clause_array, 1, &with_clause_meta); while (array_iterate(with_clause_iter, &with_clause_datum, &with_clause_null)) { Datum *with_clause_fields; int with_clause_elems; ArrayType *with_clause = DatumGetArrayTypeP(with_clause_datum); TestAssertTrue(!with_clause_null); deconstruct_array(with_clause, TEXTOID, with_clause_meta.typlen, with_clause_meta.typbyval, with_clause_meta.typalign, &with_clause_fields, NULL, &with_clause_elems); def_elems = lappend(def_elems, def_elem_from_texts(with_clause_fields, with_clause_elems)); } return def_elems; } typedef struct FilteredWithClauses { List *within; List *without; } FilteredWithClauses; static HeapTuple create_filter_tuple(TupleDesc tuple_desc, DefElem *d, bool within) { Datum *values = palloc0(sizeof(*values) * tuple_desc->natts); bool *nulls = palloc0(sizeof(*nulls) * tuple_desc->natts); TestAssertTrue(tuple_desc->natts >= 4); if (d->defnamespace != NULL) values[0] = CStringGetTextDatum(d->defnamespace); else nulls[0] = true; if (d->defname != NULL) values[1] = CStringGetTextDatum(d->defname); else nulls[1] = true; if (d->arg != NULL) values[2] = CStringGetTextDatum(defGetString(d)); else nulls[2] = true; values[3] = BoolGetDatum(within); return heap_form_tuple(tuple_desc, values, nulls); } TS_TEST_FN(ts_test_with_clause_filter) { FuncCallContext *funcctx; FilteredWithClauses *filtered; MemoryContext oldcontext; if (SRF_IS_FIRSTCALL()) { ArrayType *with_clause_array; TupleDesc tupdesc; List *def_elems; funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); with_clause_array = DatumGetArrayTypeP(PG_GETARG_DATUM(0)); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); funcctx->tuple_desc = BlessTupleDesc(tupdesc); def_elems = def_elems_from_array(with_clause_array); filtered = palloc(sizeof(*filtered)); filtered->within = NIL; filtered->without = NIL; ts_with_clause_filter(def_elems, &filtered->within, &filtered->without); funcctx->user_fctx = filtered; MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); filtered = funcctx->user_fctx; if (filtered->within != NIL) { HeapTuple tuple; DefElem *d = linitial(filtered->within); tuple = create_filter_tuple(funcctx->tuple_desc, d, true); filtered->within = list_delete_first(filtered->within); SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple)); } else if (filtered->without != NIL) { HeapTuple tuple; DefElem *d = linitial(filtered->without); tuple = create_filter_tuple(funcctx->tuple_desc, d, false); filtered->without = list_delete_first(filtered->without); SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple)); } else SRF_RETURN_DONE(funcctx); } typedef enum TestArgs { TestArgUnimpl = 0, TestArgBool, TestArgInt32, TestArgDefault, TestArgName, TestArgRegclass, TestArgRaise, } TestArgs; static WithClauseDefinition test_args[] = { [TestArgUnimpl] = { .arg_names = {"unimplemented", NULL}, .type_id = InvalidOid, }, [TestArgBool] = { .arg_names = {"bool", NULL}, .type_id = BOOLOID, }, [TestArgInt32] = { .arg_names = {"int32", NULL}, .type_id = INT4OID, }, [TestArgDefault] = { .arg_names = {"default", NULL}, .type_id = INT4OID, .default_val = (Datum)-100 }, [TestArgName] = { .arg_names = {"name", NULL}, .type_id = NAMEOID, }, [TestArgRegclass] = { .arg_names = {"regclass", NULL}, .type_id = REGCLASSOID, }, [TestArgRaise] = { .arg_names = {"sqlstate_raise", NULL}, .type_id = InvalidOid, }, }; typedef struct WithClauseValue { WithClauseResult *parsed; int i; } WithClauseValue; TS_TEST_FN(ts_test_with_clause_parse) { FuncCallContext *funcctx; MemoryContext oldcontext; Datum *values; bool *nulls; HeapTuple tuple; WithClauseValue *result; /* * Look up any missing type ids before using it below to allow * user-defined types. * * Note that this will not look up types we have found in previous calls * of this function. * * We use the slightly more complicated way of calling to_regtype since * that exists on all versions of PostgreSQL. We cannot use regtypein * since that can generate errors and we do not want to deal with that. */ for (unsigned int i = 0; i < TS_ARRAY_LEN(test_args); ++i) { LOCAL_FCINFO(fcinfo_in, 1); Datum result; if (!OidIsValid(test_args[i].type_id)) { InitFunctionCallInfoData(*fcinfo_in, NULL, 1, InvalidOid, NULL, NULL); fcinfo_in->args[0].value = CStringGetTextDatum(test_args[i].arg_names[0]); fcinfo_in->args[0].isnull = false; result = to_regtype(fcinfo_in); if (!fcinfo_in->isnull) test_args[i].type_id = DatumGetObjectId(result); } } if (SRF_IS_FIRSTCALL()) { ArrayType *with_clause_array; List *def_elems; TupleDesc tupdesc; WithClauseResult *parsed; funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); funcctx->tuple_desc = BlessTupleDesc(tupdesc); with_clause_array = DatumGetArrayTypeP(PG_GETARG_DATUM(0)); def_elems = def_elems_from_array(with_clause_array); parsed = ts_with_clauses_parse(def_elems, test_args, TS_ARRAY_LEN(test_args)); result = palloc(sizeof(*result)); result->parsed = parsed; result->i = 0; funcctx->user_fctx = result; MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); result = funcctx->user_fctx; if (result == NULL || (size_t) result->i >= TS_ARRAY_LEN(test_args)) SRF_RETURN_DONE(funcctx); values = palloc0(sizeof(*values) * funcctx->tuple_desc->natts); nulls = palloc(sizeof(*nulls) * funcctx->tuple_desc->natts); memset(nulls, true, sizeof(*nulls) * funcctx->tuple_desc->natts); values[0] = CStringGetTextDatum(test_args[result->i].arg_names[0]); nulls[0] = false; if (!result->parsed[result->i].is_default || result->i == TestArgDefault) { values[result->i + 1] = result->parsed[result->i].parsed; nulls[result->i + 1] = false; } tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls); result->i += 1; SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple)); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/t/��������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015275�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/t/001_replication_telemetry.pl����������������������������������������������0000664�0000000�0000000�00000003644�15100345067�0022624�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. use strict; use warnings; use TimescaleNode; use Data::Dumper; use Test::More tests => 4; # This test checks that the extension state is handled correctly # across multiple sessions. Specifically, if the extension state # changes in one session (e.g., the extension is created or dropped), # this should be reflected in other concurrent sessions. # # To test this, we start one background psql session that stays open # for the duration of the tests and then change the extension state # from other sessions. my $node_primary = TimescaleNode->create( 'primary', allows_streaming => 1, auth_extra => [ '--create-role', 'repl_role' ]); my $backup_name = 'my_backup'; # Take backup $node_primary->backup($backup_name); # Create streaming standby linking to primary my $node_standby = PostgreSQL::Test::Cluster->new('standby_1'); $node_standby->init_from_backup($node_primary, $backup_name, has_streaming => 1); $node_standby->start; # Wait for standby to catch up $node_primary->wait_for_catchup($node_standby, 'replay', $node_primary->lsn('insert')); my $result = $node_primary->safe_psql('postgres', "SELECT get_telemetry_report()->'replication'->>'num_wal_senders'"); is($result, qq(1), 'number of wal senders on primary'); $result = $node_primary->safe_psql('postgres', "SELECT get_telemetry_report()->'replication'->>'is_wal_receiver'"); is($result, qq(false), 'primary is wal receiver'); $result = $node_standby->safe_psql('postgres', "SELECT get_telemetry_report()->'replication'->>'num_wal_senders'"); is($result, qq(0), 'number of wal senders on standby'); $result = $node_standby->safe_psql('postgres', "SELECT get_telemetry_report()->'replication'->>'is_wal_receiver'"); is($result, qq(true), 'standby is wal receiver'); done_testing(); 1; ��������������������������������������������������������������������������������������������timescaledb-2.23.0/test/t/CMakeLists.txt������������������������������������������������������������0000664�0000000�0000000�00000000411�15100345067�0020031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������if(CMAKE_BUILD_TYPE MATCHES Debug) list(APPEND PROVE_TEST_FILES 001_replication_telemetry.pl) endif(CMAKE_BUILD_TYPE MATCHES Debug) foreach(P_FILE ${PROVE_TEST_FILES}) configure_file(${P_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${P_FILE} COPYONLY) endforeach(P_FILE) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/test/test-defs.cmake�������������������������������������������������������������0000664�0000000�0000000�00000014173�15100345067�0017740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(TEST_ROLE_SUPERUSER super_user) set(TEST_ROLE_CLUSTER_SUPERUSER cluster_super_user) set(TEST_ROLE_DEFAULT_PERM_USER default_perm_user) set(TEST_ROLE_DEFAULT_PERM_USER_2 default_perm_user_2) set(TEST_ROLE_1 test_role_1) set(TEST_ROLE_2 test_role_2) set(TEST_ROLE_3 test_role_3) set(TEST_ROLE_4 test_role_4) set(TEST_ROLE_READ_ONLY test_role_read_only) # TEST_ROLE_2 has password in passfile set(TEST_ROLE_2_PASS pass) # TEST_ROLE_3 does not have password in passfile set(TEST_ROLE_3_PASS pass) # TEST_ROLE_4 does not have password in passfile set(TEST_ROLE_4_PASS pass) set(TEST_INPUT_DIR ${CMAKE_CURRENT_SOURCE_DIR}) set(TEST_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}) set(TEST_CLUSTER ${TEST_OUTPUT_DIR}/testcluster) # Basic connection info for test instance set(TEST_PGPORT_LOCAL 5432 CACHE STRING "The port of a running PostgreSQL instance") set(TEST_PGHOST localhost CACHE STRING "The hostname of a running PostgreSQL instance") set(TEST_PGUSER ${TEST_ROLE_DEFAULT_PERM_USER} CACHE STRING "The PostgreSQL test user") set(TEST_DBNAME single CACHE STRING "The database name to use for tests") set(TEST_PGPORT_TEMP_INSTANCE 55432 CACHE STRING "The port to run a temporary test PostgreSQL instance on") set(TEST_SCHEDULE ${CMAKE_CURRENT_BINARY_DIR}/test_schedule) set(TEST_SCHEDULE_SHARED ${CMAKE_CURRENT_BINARY_DIR}/shared/test_schedule_shared) set(ISOLATION_TEST_SCHEDULE ${CMAKE_CURRENT_BINARY_DIR}/isolation_test_schedule) set(TEST_PASSFILE ${TEST_OUTPUT_DIR}/pgpass.conf) # Windows does not support local connections (unix domain sockets) if(WIN32) set(TEST_HBA_LOCAL "#local") else() set(TEST_HBA_LOCAL "local") endif() configure_file(${PRIMARY_TEST_DIR}/pg_hba.conf.in pg_hba.conf) set(TEST_PG_HBA_FILE ${TEST_OUTPUT_DIR}/pg_hba.conf) # This variable is set differently in CI. We use it to save the logs outside the # tmp instance, because it is deleted by pg_regress on successful test # completion, and we want to run some additional checks on the logs in any case. set(TEST_PG_LOG_DIRECTORY "log" CACHE STRING "Log directory for regression tests") if(USE_TELEMETRY) set(TELEMETRY_DEFAULT_SETTING "timescaledb.telemetry_level=off") else() set(TELEMETRY_DEFAULT_SETTING) endif() configure_file(postgresql.conf.in postgresql.conf) configure_file(${PRIMARY_TEST_DIR}/pgtest.conf.in pgtest.conf) # pgpass file requires chmod 0600 configure_file(${PRIMARY_TEST_DIR}/pgpass.conf.in ${TEST_OUTPUT_DIR}${CMAKE_FILES_DIRECTORY}/pgpass.conf) file( COPY ${TEST_OUTPUT_DIR}${CMAKE_FILES_DIRECTORY}/pgpass.conf DESTINATION ${TEST_OUTPUT_DIR} NO_SOURCE_PERMISSIONS FILE_PERMISSIONS OWNER_READ OWNER_WRITE) set(PG_REGRESS_OPTS_BASE --host=${TEST_PGHOST} --dlpath=${PROJECT_BINARY_DIR}/src) set(PG_REGRESS_OPTS_EXTRA --create-role=${TEST_ROLE_SUPERUSER},${TEST_ROLE_DEFAULT_PERM_USER},${TEST_ROLE_DEFAULT_PERM_USER_2},${TEST_ROLE_CLUSTER_SUPERUSER},${TEST_ROLE_1},${TEST_ROLE_2},${TEST_ROLE_3},${TEST_ROLE_4},${TEST_ROLE_READ_ONLY} --dbname=${TEST_DBNAME} --launcher=${PRIMARY_TEST_DIR}/runner.sh) set(PG_REGRESS_SHARED_OPTS_EXTRA --create-role=${TEST_ROLE_SUPERUSER},${TEST_ROLE_DEFAULT_PERM_USER},${TEST_ROLE_DEFAULT_PERM_USER_2} --dbname=${TEST_DBNAME} --launcher=${PRIMARY_TEST_DIR}/runner_shared.sh) set(PG_ISOLATION_REGRESS_OPTS_EXTRA --create-role=${TEST_ROLE_SUPERUSER},${TEST_ROLE_DEFAULT_PERM_USER},${TEST_ROLE_DEFAULT_PERM_USER_2},${TEST_ROLE_CLUSTER_SUPERUSER},${TEST_ROLE_1},${TEST_ROLE_2},${TEST_ROLE_3},${TEST_ROLE_READ_ONLY} --dbname=${TEST_DBNAME} --launcher=${PRIMARY_TEST_DIR}/runner_isolation.sh) set(PG_REGRESS_OPTS_INOUT --inputdir=${TEST_INPUT_DIR} --outputdir=${TEST_OUTPUT_DIR}) set(PG_REGRESS_SHARED_OPTS_INOUT --inputdir=${TEST_INPUT_DIR}/shared --outputdir=${TEST_OUTPUT_DIR}/shared --load-extension=timescaledb) set(PG_ISOLATION_REGRESS_OPTS_INOUT --inputdir=${TEST_INPUT_DIR}/isolation --outputdir=${TEST_OUTPUT_DIR}/isolation --load-extension=timescaledb) set(PG_REGRESS_OPTS_TEMP_INSTANCE --port=${TEST_PGPORT_TEMP_INSTANCE} --temp-instance=${TEST_CLUSTER} --temp-config=${TEST_OUTPUT_DIR}/postgresql.conf) set(PG_REGRESS_OPTS_TEMP_INSTANCE_PGTEST --port=${TEST_PGPORT_TEMP_INSTANCE} --temp-instance=${TEST_CLUSTER} --temp-config=${TEST_OUTPUT_DIR}/pgtest.conf) set(PG_REGRESS_OPTS_LOCAL_INSTANCE --port=${TEST_PGPORT_LOCAL}) if(PG_REGRESS) set(PG_REGRESS_ENV PG_BINDIR=${PG_BINDIR} PG_REGRESS=${PG_REGRESS} PG_REGRESS_USE_FAKETIME=1 TEST_DBNAME=${TEST_DBNAME} TEST_INPUT_DIR=${TEST_INPUT_DIR} TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR} TEST_PGHOST=${TEST_PGHOST} TEST_PGUSER=${TEST_PGUSER} TEST_ROLE_1=${TEST_ROLE_1} TEST_ROLE_2=${TEST_ROLE_2} TEST_ROLE_2_PASS=${TEST_ROLE_2_PASS} TEST_ROLE_3=${TEST_ROLE_3} TEST_ROLE_3_PASS=${TEST_ROLE_3_PASS} TEST_ROLE_4_PASS=${TEST_ROLE_4_PASS} TEST_ROLE_CLUSTER_SUPERUSER=${TEST_ROLE_CLUSTER_SUPERUSER} TEST_ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER} TEST_ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2} TEST_ROLE_READ_ONLY=${TEST_ROLE_READ_ONLY} TEST_ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER} TEST_SCHEDULE=${TEST_SCHEDULE}) endif() if(PG_ISOLATION_REGRESS) set(PG_ISOLATION_REGRESS_ENV TEST_PGUSER=${TEST_PGUSER} TEST_ROLE_SUPERUSER=${TEST_ROLE_SUPERUSER} TEST_ROLE_DEFAULT_PERM_USER=${TEST_ROLE_DEFAULT_PERM_USER} TEST_ROLE_DEFAULT_PERM_USER_2=${TEST_ROLE_DEFAULT_PERM_USER_2} TEST_ROLE_CLUSTER_SUPERUSER=${TEST_ROLE_CLUSTER_SUPERUSER} TEST_ROLE_1=${TEST_ROLE_1} TEST_ROLE_2=${TEST_ROLE_2} TEST_ROLE_3=${TEST_ROLE_3} TEST_ROLE_2_PASS=${TEST_2_PASS} TEST_ROLE_3_PASS=${TEST_3_PASS} TEST_ROLE_READ_ONLY=${TEST_ROLE_READ_ONLY} TEST_DBNAME=${TEST_DBNAME} TEST_INPUT_DIR=${TEST_INPUT_DIR} TEST_OUTPUT_DIR=${TEST_OUTPUT_DIR} TEST_SCHEDULE=${ISOLATION_TEST_SCHEDULE} PG_REGRESS=${PG_ISOLATION_REGRESS}) endif() set(TEST_VERSION_SUFFIX ${PG_VERSION_MAJOR}) if(APACHE_ONLY) set(TEST_LICENSE_SUFFIX "oss") else() set(TEST_LICENSE_SUFFIX "tsl") endif() �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/timescaledb.control.in�����������������������������������������������������������0000664�0000000�0000000�00000000634�15100345067�0020341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# timescaledb extension comment = 'Enables scalable inserts and complex queries for time-series data' default_version = '@PROJECT_VERSION_MOD@' module_pathname = '$libdir/timescaledb-@PROJECT_VERSION_MOD@' #extension cannot be relocatable once installed because it uses multiple schemas and that is forbidden by PG. #(though this extension is relocatable during installation). relocatable = false trusted = true ����������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/�����������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0014655�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/CMakeLists.txt���������������������������������������������������������������0000664�0000000�0000000�00000000345�15100345067�0017417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������option(CODECOVERAGE "Enable fuzzing of compression using Libfuzzer" OFF) if(COMPRESSION_FUZZING) add_compile_definitions(TS_COMPRESSION_FUZZING=1) endif() # Add the subdirectories add_subdirectory(test) add_subdirectory(src) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/LICENSE-TIMESCALE������������������������������������������������������������0000664�0000000�0000000�00000042772�15100345067�0017202�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������TIMESCALE LICENSE AGREEMENT Posted Date: September 24, 2020 PLEASE READ CAREFULLY THIS TIMESCALE LICENSE AGREEMENT ("TSL Agreement"), WHICH CONSTITUTES A LEGALLY BINDING AGREEMENT AND GOVERNS USE OF THE TIMESCALE TIME-SERIES DATABASE SOFTWARE AND RELATED SOFTWARE THAT IS PROVIDED SUBJECT TO THIS TSL AGREEMENT. BY INSTALLING OR USING SUCH SOFTWARE, YOU AGREE THAT YOU HAVE READ AND AGREE TO BE BOUND BY THE TERMS AND CONDITIONS OF THIS TSL AGREEMENT. IF YOU DO NOT AGREE WITH SUCH TERMS AND CONDITIONS, YOU MAY NOT INSTALL OR USE SUCH SOFTWARE. IF YOU ARE INSTALLING OR USING SUCH SOFTWARE ON BEHALF OF A LEGAL ENTITY, YOU REPRESENT AND WARRANT THAT YOU HAVE THE AUTHORITY TO AGREE TO THE TERMS AND CONDITIONS OF THIS TSL AGREEMENT ON BEHALF OF THAT LEGAL ENTITY AND THE RIGHT TO BIND THAT LEGAL ENTITY TO THIS TSL AGREEMENT. This TSL Agreement is entered into by and between Timescale, Inc. ("Timescale") and you or the legal entity on whose behalf you are accepting this TSL Agreement ("You"). 0. BACKGROUND The Timescale time-series database software and related software is offered as "open code" or "source-available" code. This means that all source code of the software is available for inspection and download at https://github.com/timescale. The Timescale software is composed of two major pieces. The first piece (referred to herein as the Timescale Open Source Software, as defined below) is open source software that is licensed under the Apache Version 2.0 license. The second piece (referred to herein as the TSL Licensed Software, as defined below) is all of the Timescale Software other than the Timescale Open Source Software. The TSL Licensed Software may be used under this TSL Agreement without charge. 1. GOVERNING LICENSES 1.1 Source Code. The source code for all Timescale Software is made publicly available by Timescale at https://github.com/timescale. However, different license agreements govern the use of different parts of the Timescale Software source code. The use of Timescale Open Source Software, in both source and executable forms, is governed by the terms of the Apache License Version 2.0, a copy of which is available at https://opensource.org/licenses/Apache-2.0. The use of all other Timescale Software, in both source and executable forms, is governed by this TSL Agreement. 1.2 License Rights to Your Customers. As set forth in Section 2.1 below, the use by Your customers of the Timescale Software as part of any Value Added Products or Services that You distribute will be subject to the most current version of this TSL Agreement. 2. GRANT OF LICENSES 2.1 Grant. Conditioned upon compliance with all of the terms and conditions of this TSL Agreement, Timescale grants to You at no charge the following limited, non-exclusive, non-transferable, fully paid up, worldwide licenses, without the right to grant or authorize sublicenses (except as set forth in Section 2.3): (a) Internal Use. A license to copy, compile, install, and use the Timescale Software and Derivative Works solely for Your own internal business purposes in a manner that does not expose or give access to, directly or indirectly (e.g., via a wrapper), the Timescale Data Definition Interfaces or the Timescale Data Manipulation Interfaces to any person or entity other than You or Your employees and Contractors working on Your behalf. (b) Value Added Products or Services. A license (i) to copy, compile, install, and use the Timescale Software, Derivative Works, or parts thereof to develop and maintain Your Value Added Products or Services, (ii) to utilize (in the case of services) copies of the Timescale Software, Derivative Works, or parts thereof solely as incorporated into or utilized with Your Value Added Products or Services, and (iii) to distribute (in the case of products that are distributed to Your customers) copies of the Timescale Software binaries or of Derivative Works solely in binary form, and both solely as incorporated into or utilized with Your Value Added Products or Services; provided that (1) You notify Your customers that use of such Timescale Software or Derivative Works is subject to this TSL Agreement and You provide to each such customer a copy of the most current version of this TSL Agreement or a URL from which the most current version of this TSL Agreement may be obtained, and (2) the customer is prohibited, either contractually or technically, from defining, redefining, or modifying the database schema or other structural aspects of database objects, such as through use of the Timescale Data Definition Interfaces, in a Timescale Database utilized by such Value Added Products or Services. (c) Distribution of Source Code or Binaries in Standalone Form. Subject to the prohibitions in Section 2.2 below, a license to copy and distribute the Timescale Software source code and binaries solely in unmodified standalone form and subject to the terms and conditions of the most current version of this TSL Agreement. (d) Derivative Works. A license (i) to prepare, compile, and test Derivative Works of the TSL Licensed Software; (ii) to use Derivative Works for Internal Use solely as expressly permitted in Section 2.1(a); (iii) to utilize Derivative Works with Your Value Added Products or Services solely as expressly permitted in Section 2.1(b); (iv) to distribute Derivative Works in binary form with Your Value Added Products or Services solely as expressly permitted in Section 2.1(b); and (v) to distribute Derivative Works back to Timescale under Timescale's Contributor Agreement for potential incorporation into Timescale's maintained code base at its sole discretion. 2.2 Prohibitions. Notwithstanding any other provision in this TSL Agreement, You are prohibited from (i) using any TSL Licensed Software to provide time-sharing services or database-as-a-service services, or to provide any form of software-as-a-service or service offering in which the TSL Licensed Software is offered or made available to third parties to provide time-series database functions or operations, other than as part of Your Value Added Products or Services, or (ii) copying or distributing any TSL Licensed Software for use in any of the foregoing ways. In addition, You agree not to, except as expressly permitted in Section 2.1(d), prepare Derivative Works of any TSL Licensed Software or, except as expressly permitted herein, transfer, sell, rent, lease, sublicense, loan, or otherwise transfer or make available any TSL Licensed Software, whether in source code or binary executable form. 2.3 Affiliates and Contractors. You may permit Your Contractors and Affiliates to exercise the licenses set forth in Section 2.1, provided that such exercise by Contractors must be solely for your benefit and/or the benefit of Your Affiliates, and You shall be responsible for all acts and omissions of such Contractors and Affiliates in connection with such exercise of the licenses, including but not limited to breach of any terms of this TSL Agreement. 2.4 Reservation of Rights. Except as expressly set forth in Section 2.1, no other license or rights to the Timescale Software are granted to You under this TSL Agreement, whether by implication, estoppel, or otherwise. 3. DEFINITIONS In addition to other terms defined elsewhere in this TSL Agreement, the terms below have the following meanings: 3.1 "Affiliate" means, if You are a legal entity, any legal entity that controls, is controlled by, or which is under common control with, You, where "control" means ownership of at least fifty percent (50%) of the outstanding voting shares of the legal entity, or the contractual right to establish policy for, and manage the operations of, the legal entity. 3.2 "Contractor" means a person or entity engaged as a consultant or contractor to perform work on Your behalf, but only to the extent such person or entity is performing such work on Your behalf. 3.3 "Derivative Work" means any modification or enhancement made by You to the TSL Licensed Software, whether in source code, binary executable, intermediate, or other form. 3.4 "Timescale Database" means a time-series database that is created and/or used by the Timescale Software. 3.5 "Timescale Data Definition Interfaces" means SQL commands and other interfaces of the Timescale Software that can be used to define or modify the database schema and other structural aspects of database objects in a Timescale Database, including Data Definition Language (DDL) commands such as CREATE, DROP, ALTER, TRUNCATE, COMMENT, and RENAME. 3.6 "Timescale Data Manipulation Interfaces" means SQL commands and analytical function, procedural, and other types of application programming interfaces or commands, that allow the use, manipulation, and control of data present in a Timescale Database, including Data Manipulation Language (DML) commands such as SELECT, INSERT, UPDATE, and DELETE, Data Control Language (DCL) commands such as GRANT and REVOKE, and Transaction Control Language (TCL) commands such as COMMIT, ROLLBACK, SAVEPOINT, and SET TRANSACTION. 3.7 "Timescale Open Source Software" means those portions of the Timescale Software that Timescale makes publicly available for distribution from time to time as open source software under the terms of the Apache License Version 2.0 or, in some limited instances, under other open source licenses (such as the PostgreSQL license) as identified in the applicable source code files and/or accompanying notices. 3.8 "Timescale Software" means, collectively, all time-series database software and related software made publicly available by Timescale for distribution from time to time, in both source code and binary executable form, which includes the Timescale Open Source Software and the TSL Licensed Software. 3.9 "TSL Licensed Software" means those parts of the Timescale Software other than the Timescale Open Source Software. 3.10 "Value Added Products or Services" means products or services developed by or for You that utilize (for example, as a back-end function or part of a software stack) all or parts of the Timescale Software to provide time-series database storage and operations in support of larger value-added products or services (for example, an IoT platform or vertical-specific application) with respect to which all of the following are true: (i) such value-added products or services are not primarily database storage or operations products or services; (ii) such value-added products or services add substantial value of a different nature to the time-series database storage and operations afforded by the Timescale Software and are the key functions upon which such products or services are offered and marketed; and (iii) users of such Value Added Products or Services are prohibited, either contractually or technically, from defining, redefining, or modifying the database schema or other structural aspects of database objects, such as through use of the Timescale Data Definition Interfaces, in a Timescale Database utilized by such Value Added Products or Services. 4. TERMINATION This TSL Agreement will automatically terminate, whether or not You receive notice of such termination from Timescale, in the event You breach any of its terms or conditions. In accordance with Section 6 below, Timescale shall have no liability for any damage, loss, or expense of any kind, whether consequential, indirect, or direct, suffered or incurred by You arising from or incident to the termination of this TSL Agreement, whether or not Timescale has been advised or is aware of any such potential damage, loss, or expense. 5. DISCLAIMER OF WARRANTIES TO THE MAXIMUM EXTENT PERMITTED UNDER APPLICABLE LAW, ALL TIMESCALE SOFTWARE PROVIDED UNDER THIS TSL AGREEMENT, INCLUDING ALL PORTIONS OF THE TIMESCALE SOFTWARE SUPPLIED ON A TRIAL BASIS, ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND AND TIMESCALE DISCLAIMS ALL SUCH WARRANTIES, WHETHER EXPRESS, STATUTORY, OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, TITLE, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, AND ANY IMPLIED WARRANTIES ARISING FROM USAGE OF TRADE, COURSE OF DEALING, OR COURSE OF PERFORMANCE. WITHOUT LIMITING THE FOREGOING, TIMESCALE MAKES NO WARRANTY OR REPRESENTATION AS TO THE RELIABILITY, TIMELINESS, QUALITY, SUITABILITY, PROFITABILITY, SUPPORT, PERFORMANCE, LOSS OF USE OR LOSS OF DATA, AVAILABILITY, OR ACCURACY OF THE TIMESCALE SOFTWARE. YOU ACKNOWLEDGE THAT CHANGES MADE BY TIMESCALE TO THE TIMESCALE SOFTWARE MAY DISRUPT INTEROPERATION WITH YOUR VALUE ADDED PRODUCTS OR SERVICES. TIMESCALE AND ITS LICENSORS DO NOT WARRANT THAT THE TIMESCALE SOFTWARE, OR ANY PORTION THEREOF, IS ERROR FREE OR WILL OPERATE WITHOUT INTERRUPTION, OR THAT ANY VALUE ADDED PRODUCT OR SERVICE INTEROPERATING WITH THE TIMESCALE SOFTWARE WILL NOT EXPERIENCE LOSS OF USE OR LOSS OF DATA. YOU ACKNOWLEDGE THAT IN ENTERING INTO THIS TSL AGREEMENT, YOU HAVE NOT RELIED ON ANY PROMISE, WARRANTY, OR REPRESENTATION NOT EXPRESSLY SET FORTH IN THIS AGREEMENT. 6. LIMITATION OF LIABILITY TO THE MAXIMUM EXTENT PERMITTED UNDER APPLICABLE LAW, IN NO EVENT SHALL TIMESCALE OR ITS LICENSORS BE LIABLE TO YOU OR ANY THIRD PARTY FOR ANY DIRECT OR INDIRECT DAMAGES, INCLUDING BUT NOT LIMITED TO ANY LOSS OF PROFITS OR REVENUE, LOSS OF USE, BUSINESS INTERRUPTION, LOSS OF DATA, COST OF COVER OR SUBSTITUTE GOODS OR SERVICES, OR FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE, OR EXEMPLARY DAMAGES OF ANY KIND, HOWEVER CAUSED, RELATED TO, OR ARISING OUT OF THIS TSL AGREEMENT, ITS TERMINATION OR THE PERFORMANCE OR FAILURE TO PERFORM THIS TSL AGREEMENT, OR THE USE OR INABILITY TO USE THE TIMESCALE SOFTWARE, WHETHER ALLEGED AS A BREACH OF CONTRACT, BREACH OF WARRANTY, TORTIOUS CONDUCT, INCLUDING NEGLIGENCE, OR ANY OTHER LEGAL THEORY, EVEN IF TIMESCALE HAS BEEN ADVISED OR IS AWARE OF THE POSSIBILITY OF SUCH DAMAGES. 7. GENERAL 7.1 Complete Agreement. This TSL Agreement completely and exclusively states the entire agreement of the parties regarding the subject matter hereof and supersedes all prior proposals, agreements, or other communications between the parties, oral or written, regarding such subject matter. 7.2 Modification. This TSL Agreement may be modified by Timescale from time to time, and any such modifications will be effective upon the "Posted Date" set forth at the top of the modified agreement. The modified agreement shall govern any new version of the TSL Licensed Software (and all its constituent source code and binaries) that is officially released as a complete version release by Timescale on or after such Posted Date. Except as set forth in this Section 7.2, this TSL Agreement may not be amended except by a writing executed by both parties. 7.3 Governing Law. This TSL Agreement shall be governed by and construed solely under the laws of the State of New York, without application of any choice of law rules or principles that would lead to the applicability of the law of any other jurisdiction. None of the provisions of either the United Nations Convention on Contracts for the International Sale of Goods or the Uniform Computer Information Transactions Act shall apply. 7.4 Unenforceability. If any provision of this TSL Agreement is held unenforceable, the remaining provisions of this TSL Agreement shall remain in effect and the unenforceable provision shall be replaced by an enforceable provision that best reflects the original intent of the parties. 7.5 Injunctive Relief. You acknowledge that a breach or threatened breach of any provision of this TSL Agreement will cause irreparable harm to Timescale for which damages at law will not provide adequate relief, and Timescale shall therefore be entitled to injunctive relief against such breach or threatened breach without being required to post a bond. 7.6 Assignment. You may not assign this TSL Agreement, including by operation of law in connection with a merger or acquisition or otherwise, in whole or in part, without the prior written consent of Timescale, which Timescale may grant or withhold in its sole and absolute discretion. Any assignment in violation of the preceding sentence is void. 7.7 Independent Contractors. The parties to this TSL Agreement are independent contractors and this TSL Agreement does not establish any relationship of partnership, joint venture, employment, franchise, or agency between the parties. 7.8 U.S. Government Rights. The Timescale Software and related documentation are "Commercial Items", as that term is defined at 48 C.F.R. §2.101, consisting of "Commercial Computer Software" and "Commercial Computer Software Documentation," as such terms are used in 48 C.F.R. §12.212 or 48 C.F.R. §227.7202, as applicable, and are being licensed to U.S. Government end users (a) only as Commercial Items and (b) with only those rights as are granted to all other end users pursuant to the terms and conditions of this TSL Agreement. ������timescaledb-2.23.0/tsl/README.md��������������������������������������������������������������������0000664�0000000�0000000�00000000435�15100345067�0016136�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������## TimescaleDB TSL Library ## The TimescaleDB TSL library is licensed under the [Timescale License](LICENSE-TIMESCALE). - [Continuous Aggregates](src/continuous_aggs/README.md) - [Compression](src/compression/README.md) - [Query optimization for time series](src/nodes/README.md) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/�������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015444�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/CMakeLists.txt�����������������������������������������������������������0000664�0000000�0000000�00000006613�15100345067�0020212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES chunk_api.c chunk.c chunk_merge.c chunk_split.c chunkwise_agg.c init.c partialize_finalize.c planner.c process_utility.c reorder.c) # Add test source code in Debug builds if(CMAKE_BUILD_TYPE MATCHES Debug) set(TS_DEBUG 1) set(DEBUG 1) endif(CMAKE_BUILD_TYPE MATCHES Debug) set(TSL_LIBRARY_NAME ${PROJECT_NAME}-tsl) include(build-defs.cmake) if(CMAKE_BUILD_TYPE MATCHES Debug OR COMPRESSION_FUZZING) add_library(${TSL_LIBRARY_NAME} MODULE ${SOURCES} $<TARGET_OBJECTS:${TSL_TESTS_LIB_NAME}>) else() add_library(${TSL_LIBRARY_NAME} MODULE ${SOURCES}) endif() set_target_properties( ${TSL_LIBRARY_NAME} PROPERTIES OUTPUT_NAME ${TSL_LIBRARY_NAME}-${PROJECT_VERSION_MOD} PREFIX "") target_include_directories(${TSL_LIBRARY_NAME} PRIVATE ${PG_INCLUDEDIR}) target_compile_definitions(${TSL_LIBRARY_NAME} PUBLIC TS_TSL) target_compile_definitions(${TSL_LIBRARY_NAME} PUBLIC TS_SUBMODULE) if(WIN32) target_link_libraries(${TSL_LIBRARY_NAME} ${PG_LIBDIR}/libpq.lib) else() target_link_libraries(${TSL_LIBRARY_NAME} pq) endif() install(TARGETS ${TSL_LIBRARY_NAME} DESTINATION ${PG_PKGLIBDIR}) # if (WIN32) target_link_libraries(${PROJECT_NAME} # ${PROJECT_NAME}-${PROJECT_VERSION_MOD}.lib) endif(WIN32) # We use the UMASH library for hashing in vectorized grouping. If it was not # explicitly disabled already, detect if we can compile it on this platform. if((NOT DEFINED USE_UMASH) OR USE_UMASH) # Check whether we can enable the pclmul instruction required for the UMASH # hashing on amd64. Shouldn't be done if the user has manually specified the # target architecture, no idea how to detect this, but at least we shouldn't # do this when cross-compiling. if(NOT CMAKE_CROSSCOMPILING) check_c_compiler_flag(-mpclmul CC_PCLMUL) if(CC_PCLMUL) add_compile_options(-mpclmul) endif() endif() # The C compiler flags that we add using add_compile_options() are not # automatically used by check_c_source_compiles() because it works in a # separate project, so we have to add them manually. get_directory_property(DIR_COMPILE_OPTIONS_LIST COMPILE_OPTIONS) list(JOIN DIR_COMPILE_OPTIONS_LIST " " DIR_COMPILE_OPTIONS) set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${CMAKE_C_FLAGS} ${DIR_COMPILE_OPTIONS} -Werror=implicit-function-declaration" ) check_c_source_compiles( " #if defined(__PCLMUL__) #include <stdint.h> #include <immintrin.h> /* * For some reason, this doesn't compile on our i386 CI, but I also can't detect * it using the standard condition of defined(__x86_64__) && !defined(__ILP32__), * as described at https://wiki.debian.org/X32Port . */ int main() { (void) _mm_cvtsi64_si128((uint64_t) 0); return 0; } #elif defined(__ARM_FEATURE_CRYPTO) /* OK */ int main() { return 0; } #else #error Unsupported platform for UMASH #endif " UMASH_SUPPORTED) unset(CMAKE_REQUIRED_FLAGS) else() set(UMASH_SUPPORTED OFF) endif() option(USE_UMASH "Use the UMASH hash for string and multi-column vectorized grouping" ${UMASH_SUPPORTED}) if(USE_UMASH) if(NOT UMASH_SUPPORTED) message( FATAL_ERROR "UMASH use is requested, but it is not supported in the current configuration" ) endif() add_compile_definitions(TS_USE_UMASH) endif() add_subdirectory(bgw_policy) add_subdirectory(compression) add_subdirectory(continuous_aggs) add_subdirectory(import) add_subdirectory(nodes) ���������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/README.module.md���������������������������������������������������������0000664�0000000�0000000�00000003557�15100345067�0020221�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Submodule Licensing and Initialization # ## Loading and Activation ## We link module loading and activation to the license GUC itself. We have a single GUC, the license, and load submodules based on what capabilities the license enables, i.e., an `apache` license-key does not load this module, while `timescale` key does. This ensures that the loader "does the right thing" with respect to the license, and a user cannot accidentally activate features they aren't licensed to use. The actual loading and activation is done through `check` and `assign` hooks on the license GUC. On `check` we validate the license type and on `assign` we set the capabilities-struct in this module, if needed. The `check` and `assign` functions can be found in [`license_guc.c/h`](/src/license_guc.c) in the Apache-Licensed src. ### Cross License Functions ### To enable binaries which only contain Apache-Licensed code, we dynamically link in Timescale-Licensed code on license activation, and handle all function calls into the module via function pointers. The registry in `ts_cm_functions` of type `CrossModuleFunctions` (declared in [`cross_module_fn.h`](/src/cross_module_fn.h) and defined in [`cross_module_fn.c`](/src/cross_module_fn.c)) stores all of the cross-module functions. To add a new cross-module function you must: - Add a struct member `CrossModuleFunctions.<function name>`. - Add default function to `ts_cm_functions_default` that will be called from the Apache version, usually this function should just call `error_no_default_fn`. **NOTE** Due to function-pointer casting rules, the default function must have the exact same signature as the function pointer; you may _not_ cast another function pointer of another type. - Add the overriding function to `tsl_cm_functions`in `init.c` in this module. To call a cross-module functions use `ts_cm_functions-><function name>(args)`. �������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/��������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017602�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/CMakeLists.txt������������������������������������������������0000664�0000000�0000000�00000001162�15100345067�0022342�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/compression_api.c ${CMAKE_CURRENT_SOURCE_DIR}/continuous_aggregate_api.c ${CMAKE_CURRENT_SOURCE_DIR}/process_hyper_inval_api.c ${CMAKE_CURRENT_SOURCE_DIR}/job.c ${CMAKE_CURRENT_SOURCE_DIR}/job_api.c ${CMAKE_CURRENT_SOURCE_DIR}/reorder_api.c ${CMAKE_CURRENT_SOURCE_DIR}/policy_config.c ${CMAKE_CURRENT_SOURCE_DIR}/retention_api.c ${CMAKE_CURRENT_SOURCE_DIR}/policy_utils.c ${CMAKE_CURRENT_SOURCE_DIR}/policies_v2.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) target_include_directories(${TSL_LIBRARY_NAME} PRIVATE ${CMAKE_SOURCE_DIR}) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/compression_api.c���������������������������������������������0000664�0000000�0000000�00000042347�15100345067�0023152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <fmgr.h> #include <miscadmin.h> #include <utils/builtins.h> #include "compression_api.h" #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/timer.h" #include "bgw_policy/continuous_aggregate_api.h" #include "bgw_policy/job.h" #include "bgw_policy/job_api.h" #include "bgw_policy/policies_v2.h" #include "bgw_policy/policy_config.h" #include "errors.h" #include "guc.h" #include "hypertable.h" #include "hypertable_cache.h" #include "jsonb_utils.h" #include "policy_utils.h" #include "utils.h" #include <utils/elog.h> /* Default max runtime is unlimited for compress chunks */ #define DEFAULT_MAX_RUNTIME \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("0"), InvalidOid, -1)) /* Default retry period for reorder_jobs is currently 1 hour */ #define DEFAULT_RETRY_PERIOD \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("1 hour"), InvalidOid, -1)) /* Default max schedule period for the compression policy is 12 hours. The actual schedule period * will be chunk_interval/2 if the chunk_interval is < 12 hours. */ #define DEFAULT_MAX_SCHEDULE_PERIOD (int64)(12 * 3600 * 1000 * (int64) 1000) static Hypertable *validate_compress_chunks_hypertable(Cache *hcache, Oid user_htoid, bool *is_cagg); int32 policy_compression_get_maxchunks_per_job(const Jsonb *config) { bool found; int32 maxchunks = ts_jsonb_get_int32_field(config, POL_COMPRESSION_CONF_KEY_MAXCHUNKS_TO_COMPRESS, &found); return (found && maxchunks > 0) ? maxchunks : 0; } int64 policy_recompression_get_recompress_after_int(const Jsonb *config) { bool found; int64 compress_after = ts_jsonb_get_int64_field(config, POL_RECOMPRESSION_CONF_KEY_RECOMPRESS_AFTER, &found); if (!found) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for job", POL_RECOMPRESSION_CONF_KEY_RECOMPRESS_AFTER))); return compress_after; } Interval * policy_recompression_get_recompress_after_interval(const Jsonb *config) { Interval *interval = ts_jsonb_get_interval_field(config, POL_RECOMPRESSION_CONF_KEY_RECOMPRESS_AFTER); if (interval == NULL) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for job", POL_RECOMPRESSION_CONF_KEY_RECOMPRESS_AFTER))); return interval; } Datum policy_recompression_proc(PG_FUNCTION_ARGS) { if (PG_NARGS() != 2 || PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_VOID(); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); policy_recompression_execute(PG_GETARG_INT32(0), PG_GETARG_JSONB_P(1)); PG_RETURN_VOID(); } static void validate_compress_after_type(const Dimension *dim, Oid partitioning_type, Oid compress_after_type) { Oid expected_type = InvalidOid; if (IS_INTEGER_TYPE(partitioning_type)) { Oid now_func = ts_get_integer_now_func(dim, false); if (!IS_INTEGER_TYPE(compress_after_type) && OidIsValid(now_func)) expected_type = partitioning_type; } else if (compress_after_type != INTERVALOID) { expected_type = INTERVALOID; } if (OidIsValid(expected_type)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported compress_after argument type, expected type : %s", format_type_be(expected_type)))); } } Datum policy_compression_check(PG_FUNCTION_ARGS) { PolicyCompressionData policy_data; if (PG_ARGISNULL(0)) { ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("config must not be NULL"))); } policy_compression_read_and_validate_config(PG_GETARG_JSONB_P(0), &policy_data); ts_cache_release(&policy_data.hcache); PG_RETURN_VOID(); } /* compression policies are added to hypertables or continuous aggregates */ Datum policy_compression_add_internal(Oid user_rel_oid, Datum compress_after_datum, Oid compress_after_type, Interval *created_before, Interval *default_schedule_interval, bool user_defined_schedule_interval, bool if_not_exists, bool fixed_schedule, TimestampTz initial_start, const char *timezone) { NameData application_name; NameData proc_name, proc_schema, check_schema, check_name, owner; int32 job_id; Hypertable *hypertable; Cache *hcache; const Dimension *dim; Oid owner_id; bool is_cagg = false; hcache = ts_hypertable_cache_pin(); hypertable = validate_compress_chunks_hypertable(hcache, user_rel_oid, &is_cagg); /* creation time usage not supported with caggs yet */ if (is_cagg && created_before != NULL) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot use \"compress_created_before\" with continuous aggregate \"%s\" ", get_rel_name(user_rel_oid)))); owner_id = ts_hypertable_permissions_check(user_rel_oid, GetUserId()); ts_bgw_job_validate_job_owner(owner_id); /* Make sure that an existing policy doesn't exist on this hypertable */ List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_COMPRESSION_PROC_NAME, FUNCTIONS_SCHEMA_NAME, hypertable->fd.id); dim = hyperspace_get_open_dimension(hypertable->space, 0); Oid partitioning_type = ts_dimension_get_partition_type(dim); if (jobs != NIL) { bool is_equal = false; if (!if_not_exists) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("columnstore policy already exists for hypertable or continuous " "aggregate \"%s\"", get_rel_name(user_rel_oid)), errhint("Set option \"if_not_exists\" to true to avoid error."))); } Assert(list_length(jobs) == 1); BgwJob *existing = linitial(jobs); if (OidIsValid(compress_after_type)) is_equal = policy_config_check_hypertable_lag_equality(existing->fd.config, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, partitioning_type, compress_after_type, compress_after_datum, false /* isnull */); else { Assert(created_before != NULL); is_equal = policy_config_check_hypertable_lag_equality( existing->fd.config, POL_COMPRESSION_CONF_KEY_COMPRESS_CREATED_BEFORE, partitioning_type, INTERVALOID, IntervalPGetDatum(created_before), false /* isnull */); } if (is_equal) { /* If all arguments are the same, do nothing */ ts_cache_release(&hcache); ereport(NOTICE, (errmsg("columnstore policy already exists for hypertable \"%s\", skipping", get_rel_name(user_rel_oid)))); PG_RETURN_INT32(-1); } else { ts_cache_release(&hcache); ereport(WARNING, (errmsg("columnstore policy already exists for hypertable \"%s\"", get_rel_name(user_rel_oid)), errdetail("A policy already exists with different arguments."), errhint("Remove the existing policy before adding a new one."))); PG_RETURN_INT32(-1); } } if (created_before) { Assert(!OidIsValid(compress_after_type)); compress_after_type = INTERVALOID; } if (!is_cagg && IS_INTEGER_TYPE(partitioning_type) && !IS_INTEGER_TYPE(compress_after_type) && created_before == NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid value for parameter %s", POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER), errhint("Integer duration in \"compress_after\" or interval time duration" " in \"compress_created_before\" is required for hypertables with integer " "time dimension."))); if (dim && IS_TIMESTAMP_TYPE(ts_dimension_get_partition_type(dim)) && !user_defined_schedule_interval) { int64 hypertable_schedule_interval = dim->fd.interval_length / 2; /* On hypertables with a small chunk_time_interval, schedule the compression job more often * than DEFAULT_MAX_SCHEDULE_PERIOD */ if (DEFAULT_MAX_SCHEDULE_PERIOD > hypertable_schedule_interval) { default_schedule_interval = DatumGetIntervalP( ts_internal_to_interval_value(hypertable_schedule_interval, INTERVALOID)); } else { default_schedule_interval = DatumGetIntervalP( ts_internal_to_interval_value(DEFAULT_MAX_SCHEDULE_PERIOD, INTERVALOID)); } } /* insert a new job into jobs table */ namestrcpy(&application_name, "Columnstore Policy"); namestrcpy(&proc_name, POLICY_COMPRESSION_PROC_NAME); namestrcpy(&proc_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&check_name, POLICY_COMPRESSION_CHECK_NAME); namestrcpy(&check_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&owner, GetUserNameFromId(owner_id, false)); JsonbParseState *parse_state = NULL; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int32(parse_state, POLICY_CONFIG_KEY_HYPERTABLE_ID, hypertable->fd.id); validate_compress_after_type(dim, partitioning_type, compress_after_type); switch (compress_after_type) { case INTERVALOID: if (created_before) ts_jsonb_add_interval(parse_state, POL_COMPRESSION_CONF_KEY_COMPRESS_CREATED_BEFORE, created_before); else ts_jsonb_add_interval(parse_state, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, DatumGetIntervalP(compress_after_datum)); break; case INT2OID: ts_jsonb_add_int64(parse_state, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, DatumGetInt16(compress_after_datum)); break; case INT4OID: ts_jsonb_add_int64(parse_state, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, DatumGetInt32(compress_after_datum)); break; case INT8OID: ts_jsonb_add_int64(parse_state, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, DatumGetInt64(compress_after_datum)); break; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported datatype for %s: %s", POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, format_type_be(compress_after_type)))); } JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); Jsonb *config = JsonbValueToJsonb(result); job_id = ts_bgw_job_insert_relation(&application_name, default_schedule_interval, DEFAULT_MAX_RUNTIME, JOB_RETRY_UNLIMITED, DEFAULT_RETRY_PERIOD, &proc_schema, &proc_name, &check_schema, &check_name, owner_id, true, fixed_schedule, hypertable->fd.id, config, initial_start, timezone); if (!TIMESTAMP_NOT_FINITE(initial_start)) { ts_bgw_job_stat_upsert_next_start(job_id, initial_start); } ts_cache_release(&hcache); PG_RETURN_INT32(job_id); } /* compression policies are added to hypertables or continuous aggregates */ Datum policy_compression_add(PG_FUNCTION_ARGS) { /* * The function is not STRICT but we can't allow required args to be NULL * so we need to act like a strict function in those cases */ if (PG_ARGISNULL(0) || PG_ARGISNULL(2)) { ts_feature_flag_check(FEATURE_POLICY); PG_RETURN_NULL(); } Oid user_rel_oid = PG_GETARG_OID(0); Datum compress_after_datum = PG_GETARG_DATUM(1); Oid compress_after_type = PG_ARGISNULL(1) ? InvalidOid : get_fn_expr_argtype(fcinfo->flinfo, 1); bool if_not_exists = PG_GETARG_BOOL(2); bool user_defined_schedule_interval = !(PG_ARGISNULL(3)); Interval *default_schedule_interval = PG_ARGISNULL(3) ? DEFAULT_COMPRESSION_SCHEDULE_INTERVAL : PG_GETARG_INTERVAL_P(3); TimestampTz initial_start = PG_ARGISNULL(4) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(4); // if not providing initial_start, then we still get the old behavior bool fixed_schedule = !PG_ARGISNULL(4); text *timezone = PG_ARGISNULL(5) ? NULL : PG_GETARG_TEXT_PP(5); char *valid_timezone = NULL; Interval *created_before = PG_GETARG_INTERVAL_P(6); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); /* compress_after and created_before cannot be specified [or omitted] together */ if ((PG_ARGISNULL(1) && PG_ARGISNULL(6)) || (!PG_ARGISNULL(1) && !PG_ARGISNULL(6))) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg( "need to specify one of \"compress_after\" or \"compress_created_before\""))); /* if users pass in -infinity for initial_start, then use the current_timestamp instead */ if (fixed_schedule) { ts_bgw_job_validate_schedule_interval(default_schedule_interval); if (TIMESTAMP_NOT_FINITE(initial_start)) initial_start = ts_timer_get_current_timestamp(); } if (timezone != NULL) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(5)); Datum retval; retval = policy_compression_add_internal(user_rel_oid, compress_after_datum, compress_after_type, created_before, default_schedule_interval, user_defined_schedule_interval, if_not_exists, fixed_schedule, initial_start, valid_timezone); return retval; } bool policy_compression_remove_internal(Oid user_rel_oid, bool if_exists) { Hypertable *ht; Cache *hcache; ht = ts_hypertable_cache_get_cache_and_entry(user_rel_oid, CACHE_FLAG_MISSING_OK, &hcache); if (!ht) { const char *view_name = get_rel_name(user_rel_oid); if (!view_name) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("relation is not a hypertable or continuous aggregate"))); else { ContinuousAgg *ca = ts_continuous_agg_find_by_relid(user_rel_oid); if (!ca) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("relation \"%s\" is not a hypertable or continuous aggregate", view_name))); ht = ts_hypertable_get_by_id(ca->data.mat_hypertable_id); } } List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_COMPRESSION_PROC_NAME, FUNCTIONS_SCHEMA_NAME, ht->fd.id); ts_cache_release(&hcache); if (jobs == NIL) { if (!if_exists) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("columnstore policy not found for hypertable \"%s\"", get_rel_name(user_rel_oid)))); else { ereport(NOTICE, (errmsg("columnstore policy not found for hypertable \"%s\", skipping", get_rel_name(user_rel_oid)))); PG_RETURN_BOOL(false); } } ts_hypertable_permissions_check(user_rel_oid, GetUserId()); Assert(list_length(jobs) == 1); BgwJob *job = linitial(jobs); ts_bgw_job_delete_by_id(job->fd.id); PG_RETURN_BOOL(true); } /* remove compression policy from ht or cagg */ Datum policy_compression_remove(PG_FUNCTION_ARGS) { Oid user_rel_oid = PG_GETARG_OID(0); bool if_exists = PG_GETARG_BOOL(1); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); return policy_compression_remove_internal(user_rel_oid, if_exists); } /* compare cagg job config with compression job config. If there is an overlap, then * throw an error. We do this since we cannot refresh compressed * regions. We do not want cont. aggregate jobs to fail */ /* If this is a cagg, then mark it as a cagg */ static Hypertable * validate_compress_chunks_hypertable(Cache *hcache, Oid user_htoid, bool *is_cagg) { ContinuousAggHypertableStatus status; Hypertable *ht = ts_hypertable_cache_get_entry(hcache, user_htoid, true /* missing_ok */); *is_cagg = false; if (ht != NULL) { if (!TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("columnstore not enabled on hypertable \"%s\"", get_rel_name(user_htoid)), errhint("Enable columnstore before adding a columnstore policy."))); } status = ts_continuous_agg_hypertable_status(ht->fd.id); if ((status == HypertableIsMaterialization || status == HypertableIsMaterializationAndRaw)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add compression policy to materialized hypertable \"%s\" ", get_rel_name(user_htoid)), errhint("Please add the policy to the corresponding continuous aggregate " "instead."))); } } else { /*check if this is a cont aggregate view */ int32 mat_id; bool found; ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(user_htoid); if (cagg == NULL) { ts_cache_release(&hcache); const char *relname = get_rel_name(user_htoid); if (relname) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("\"%s\" is not a hypertable or a continuous aggregate", relname))); else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("object with id \"%u\" not found", user_htoid))); } *is_cagg = true; mat_id = cagg->data.mat_hypertable_id; ht = ts_hypertable_get_by_id(mat_id); found = policy_refresh_cagg_exists(mat_id); if (!found) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("continuous aggregate policy does not exist for \"%s\"", get_rel_name(user_htoid)), errmsg("setup a refresh policy for \"%s\" before setting up a columnstore " "policy", get_rel_name(user_htoid)))); } if (!TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("columnstore not enabled on continuous aggregate \"%s\"", get_rel_name(user_htoid)), errhint("Enable columnstore before adding a columnstore policy."))); } } Assert(ht != NULL); return ht; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/compression_api.h���������������������������������������������0000664�0000000�0000000�00000002362�15100345067�0023150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/jsonb.h> #include <utils/timestamp.h> /* User-facing API functions */ extern Datum policy_compression_add(PG_FUNCTION_ARGS); extern Datum policy_compression_remove(PG_FUNCTION_ARGS); extern Datum policy_recompression_proc(PG_FUNCTION_ARGS); extern Datum policy_compression_check(PG_FUNCTION_ARGS); int32 policy_compression_get_hypertable_id(const Jsonb *config); int32 policy_compression_get_maxchunks_per_job(const Jsonb *config); int64 policy_recompression_get_recompress_after_int(const Jsonb *config); Interval *policy_recompression_get_recompress_after_interval(const Jsonb *config); Datum policy_compression_add_internal(Oid user_rel_oid, Datum compress_after_datum, Oid compress_after_type, Interval *created_before, Interval *default_schedule_interval, bool user_defined_schedule_interval, bool if_not_exists, bool fixed_schedule, TimestampTz initial_start, const char *timezone); bool policy_compression_remove_internal(Oid user_rel_oid, bool if_exists); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/continuous_aggregate_api.c������������������������������������0000664�0000000�0000000�00000065430�15100345067�0025023�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <common/int128.h> #include <miscadmin.h> #include <parser/parse_coerce.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/rangetypes.h> #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/timer.h" #include "bgw_policy/continuous_aggregate_api.h" #include "bgw_policy/job.h" #include "bgw_policy/job_api.h" #include "bgw_policy/policies_v2.h" #include "bgw_policy/policy_utils.h" #include "dimension.h" #include "guc.h" #include "jsonb_utils.h" #include "policy_config.h" #include "policy_utils.h" #include "time_utils.h" #include "ts_catalog/continuous_agg.h" /* Default max runtime for a continuous aggregate jobs is unlimited for now */ #define DEFAULT_MAX_RUNTIME \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("0"), InvalidOid, -1)) /* Default buckets per batch is 1, which means that the job will refresh 1 bucket at a time */ #define DEFAULT_BUCKETS_PER_BATCH 1 /* Default max batches per execution is 0, which means no limit */ #define DEFAULT_MAX_BATCHES_PER_EXECUTION 0 /* Default refresh newest first is true, which means from newest data to the oldest */ #define DEFAULT_REFRESH_NEWEST_FIRST true int32 policy_continuous_aggregate_get_mat_hypertable_id(const Jsonb *config) { bool found; int32 mat_hypertable_id = ts_jsonb_get_int32_field(config, POL_REFRESH_CONF_KEY_MAT_HYPERTABLE_ID, &found); if (!found) ereport(ERROR, (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), errmsg("could not find \"%s\" in config for job", POL_REFRESH_CONF_KEY_MAT_HYPERTABLE_ID))); return mat_hypertable_id; } static int64 get_time_from_interval(const Dimension *dim, Datum interval, Oid type) { Oid partitioning_type = ts_dimension_get_partition_type(dim); if (IS_INTEGER_TYPE(type)) { Oid now_func = ts_get_integer_now_func(dim, true); int64 value = ts_interval_value_to_internal(interval, type); Assert(now_func); return ts_subtract_integer_from_now_saturating(now_func, value, partitioning_type); } else if (type == INTERVALOID) { Datum res = subtract_interval_from_now(DatumGetIntervalP(interval), partitioning_type); return ts_time_value_to_internal(res, partitioning_type); } else elog(ERROR, "unsupported offset type for continuous aggregate policy"); pg_unreachable(); return 0; } static int64 get_time_from_config(const Dimension *dim, const Jsonb *config, const char *json_label, bool *isnull) { Oid partitioning_type = ts_dimension_get_partition_type(dim); *isnull = false; if (IS_INTEGER_TYPE(partitioning_type)) { bool found; int64 interval_val = ts_jsonb_get_int64_field(config, json_label, &found); if (!found) { *isnull = true; return 0; } return get_time_from_interval(dim, Int64GetDatum(interval_val), INT8OID); } else { Interval *interval_val = ts_jsonb_get_interval_field(config, json_label); if (!interval_val) { *isnull = true; return 0; } return get_time_from_interval(dim, IntervalPGetDatum(interval_val), INTERVALOID); } } int64 policy_refresh_cagg_get_refresh_start(const ContinuousAgg *cagg, const Dimension *dim, const Jsonb *config, bool *start_isnull) { int64 res = get_time_from_config(dim, config, POL_REFRESH_CONF_KEY_START_OFFSET, start_isnull); /* interpret NULL as min value for that type */ if (*start_isnull) { Assert(cagg->partition_type == ts_dimension_get_partition_type(dim)); return cagg_get_time_min(cagg); } return res; } int64 policy_refresh_cagg_get_refresh_end(const Dimension *dim, const Jsonb *config, bool *end_isnull) { int64 res = get_time_from_config(dim, config, POL_REFRESH_CONF_KEY_END_OFFSET, end_isnull); if (*end_isnull) return ts_time_get_noend_or_max(ts_dimension_get_partition_type(dim)); return res; } bool policy_refresh_cagg_get_include_tiered_data(const Jsonb *config, bool *isnull) { bool found; bool res = ts_jsonb_get_bool_field(config, POL_REFRESH_CONF_KEY_INCLUDE_TIERED_DATA, &found); *isnull = !found; return res; } int32 policy_refresh_cagg_get_buckets_per_batch(const Jsonb *config) { bool found; int32 res = ts_jsonb_get_int32_field(config, POL_REFRESH_CONF_KEY_BUCKETS_PER_BATCH, &found); if (!found) res = DEFAULT_BUCKETS_PER_BATCH; /* default value */ return res; } int32 policy_refresh_cagg_get_max_batches_per_execution(const Jsonb *config) { bool found; int32 res = ts_jsonb_get_int32_field(config, POL_REFRESH_CONF_KEY_MAX_BATCHES_PER_EXECUTION, &found); if (!found) res = DEFAULT_MAX_BATCHES_PER_EXECUTION; /* default value */ return res; } bool policy_refresh_cagg_get_refresh_newest_first(const Jsonb *config) { bool found; bool res = ts_jsonb_get_bool_field(config, POL_REFRESH_CONF_KEY_REFRESH_NEWEST_FIRST, &found); if (!found) res = DEFAULT_REFRESH_NEWEST_FIRST; /* default value */ return res; } /* returns false if a policy could not be found */ bool policy_refresh_cagg_exists(int32 materialization_id) { Hypertable *mat_ht = ts_hypertable_get_by_id(materialization_id); if (!mat_ht) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("configuration materialization hypertable id %d not found", materialization_id))); List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_REFRESH_CAGG_PROC_NAME, FUNCTIONS_SCHEMA_NAME, materialization_id); if (jobs == NIL) return false; return true; } Datum policy_refresh_cagg_proc(PG_FUNCTION_ARGS) { if (PG_NARGS() != 2 || PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_VOID(); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); policy_refresh_cagg_execute(PG_GETARG_INT32(0), PG_GETARG_JSONB_P(1)); PG_RETURN_VOID(); } Datum policy_refresh_cagg_check(PG_FUNCTION_ARGS) { if (PG_ARGISNULL(0)) { ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("config must not be NULL"))); } policy_refresh_cagg_read_and_validate_config(PG_GETARG_JSONB_P(0), NULL); PG_RETURN_VOID(); } static void json_add_dim_interval_value(JsonbParseState *parse_state, const char *json_label, Oid dim_type, Datum value) { switch (dim_type) { case INTERVALOID: ts_jsonb_add_interval(parse_state, json_label, DatumGetIntervalP(value)); break; case INT2OID: ts_jsonb_add_int64(parse_state, json_label, DatumGetInt16(value)); break; case INT4OID: ts_jsonb_add_int64(parse_state, json_label, DatumGetInt32(value)); break; case INT8OID: ts_jsonb_add_int64(parse_state, json_label, DatumGetInt64(value)); break; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported interval argument type, expected type : %s", format_type_be(dim_type)))); } } static Datum convert_interval_arg(Oid dim_type, Datum interval, Oid *interval_type, const char *str_msg) { Oid convert_to = dim_type; Datum converted; if (IS_TIMESTAMP_TYPE(dim_type)) convert_to = INTERVALOID; if (*interval_type != convert_to) { if (!can_coerce_type(1, interval_type, &convert_to, COERCION_IMPLICIT)) { if (IS_INTEGER_TYPE(dim_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid parameter value for %s", str_msg), errhint("Use time interval of type %s with the continuous aggregate.", format_type_be(dim_type)))); else if (IS_TIMESTAMP_TYPE(dim_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid parameter value for %s", str_msg), errhint("Use time interval with a continuous aggregate using " "timestamp-based time " "bucket."))); } } converted = ts_time_datum_convert_arg(interval, interval_type, convert_to); /* For integer types, first convert all types to int64 to get on a common * type. Then check valid time ranges against the partition/dimension * type */ switch (*interval_type) { case INT2OID: converted = Int64GetDatum((int64) DatumGetInt16(converted)); break; case INT4OID: converted = Int64GetDatum((int64) DatumGetInt32(converted)); break; case INT8OID: break; case INTERVALOID: /* For timestamp types, we only support Interval, so nothing further * to do. */ return converted; default: pg_unreachable(); break; } /* Cap at min and max */ if (DatumGetInt64(converted) < ts_time_get_min(dim_type)) converted = ts_time_get_min(dim_type); else if (DatumGetInt64(converted) > ts_time_get_max(dim_type)) converted = ts_time_get_max(dim_type); /* Convert to the desired integer type */ switch (dim_type) { case INT2OID: converted = Int16GetDatum((int16) DatumGetInt64(converted)); break; case INT4OID: converted = Int32GetDatum((int32) DatumGetInt64(converted)); break; case INT8OID: /* Already int64, so nothing to do. */ break; default: pg_unreachable(); break; } *interval_type = dim_type; return converted; } /* * Convert an interval to a 128 integer value. * * Based on PostgreSQL's interval_cmp_value(). */ static inline INT128 interval_to_int128(const Interval *interval) { INT128 span; int64 dayfraction; int64 days; /* * Separate time field into days and dayfraction, then add the month and * day fields to the days part. We cannot overflow int64 days here. */ dayfraction = interval->time % USECS_PER_DAY; days = interval->time / USECS_PER_DAY; days += interval->month * INT64CONST(30); days += interval->day; /* Widen dayfraction to 128 bits */ span = int64_to_int128(dayfraction); /* Scale up days to microseconds, forming a 128-bit product */ int128_add_int64_mul_int64(&span, days, USECS_PER_DAY); return span; } int64 interval_to_int64(Datum interval, Oid type) { switch (type) { case INT2OID: return DatumGetInt16(interval); case INT4OID: return DatumGetInt32(interval); case INT8OID: return DatumGetInt64(interval); case INTERVALOID: { const int64 max = ts_time_get_max(TIMESTAMPTZOID); const int64 min = ts_time_get_min(TIMESTAMPTZOID); INT128 bigres = interval_to_int128(DatumGetIntervalP(interval)); if (int128_compare(bigres, int64_to_int128(max)) >= 0) return max; else if (int128_compare(bigres, int64_to_int128(min)) <= 0) return min; else return int128_to_int64(bigres); } default: break; } pg_unreachable(); return 0; } /* * Enforce that a policy has a refresh window of at least two buckets to * ensure we materialize at least one bucket each run. * * Why two buckets? Note that the policy probably won't execute at at time * that exactly aligns with a bucket boundary, so a window of one bucket * might not cover a full bucket that we want to materialize: * * Refresh window: [-----) * Materialized buckets: |-----|-----|-----| */ static void validate_window_size(const ContinuousAgg *cagg, const CaggPolicyConfig *config) { int64 start_offset; int64 end_offset; int64 bucket_width; if (config->offset_start.isnull) start_offset = ts_time_get_max(cagg->partition_type); else start_offset = interval_to_int64(config->offset_start.value, config->offset_start.type); if (config->offset_end.isnull) end_offset = ts_time_get_min(cagg->partition_type); else end_offset = interval_to_int64(config->offset_end.value, config->offset_end.type); bucket_width = ts_continuous_agg_bucket_width(cagg->bucket_function); Assert(bucket_width > 0); if (ts_time_saturating_add(end_offset, bucket_width * 2, INT8OID) > start_offset) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("policy refresh window too small"), errdetail("The start and end offsets must cover at least" " two buckets in the valid time range of type \"%s\".", format_type_be(cagg->partition_type)))); } static void parse_offset_arg(const ContinuousAgg *cagg, Oid offset_type, NullableDatum arg, ContinuousAggPolicyOffset *offset) { offset->isnull = arg.isnull; if (!offset->isnull) { offset->value = convert_interval_arg(cagg->partition_type, arg.value, &offset_type, offset->name); offset->type = offset_type; } } static void parse_cagg_policy_config(const ContinuousAgg *cagg, Oid start_offset_type, NullableDatum start_offset, Oid end_offset_type, NullableDatum end_offset, CaggPolicyConfig *config) { MemSet(config, 0, sizeof(CaggPolicyConfig)); config->partition_type = cagg->partition_type; /* This might seem backwards, but since we are dealing with offsets, start * actually translates to max and end to min for maximum window. */ config->offset_start.value = ts_time_datum_get_max(config->partition_type); config->offset_end.value = ts_time_datum_get_min(config->partition_type); config->offset_start.type = config->offset_end.type = IS_TIMESTAMP_TYPE(cagg->partition_type) ? INTERVALOID : cagg->partition_type; config->offset_start.name = POL_REFRESH_CONF_KEY_START_OFFSET; config->offset_end.name = POL_REFRESH_CONF_KEY_END_OFFSET; parse_offset_arg(cagg, start_offset_type, start_offset, &config->offset_start); parse_offset_arg(cagg, end_offset_type, end_offset, &config->offset_end); Assert(config->offset_start.type == config->offset_end.type); validate_window_size(cagg, config); } bool policy_refresh_cagg_check_if_last_policy(PolicyContinuousAggData *policy_data) { ContinuousAgg *cagg = policy_data->cagg; int64 end_offset = policy_data->refresh_window.end; bool end_isnull = policy_data->refresh_window.end_isnull; if (end_isnull) return true; Hypertable *mat_ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); const Dimension *dim = get_open_dimension_for_hypertable(mat_ht, true); List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_REFRESH_CAGG_PROC_NAME, FUNCTIONS_SCHEMA_NAME, cagg->data.mat_hypertable_id); ListCell *lc; /* We need to go through all jobs in order to determine if there is a job which starts after * this one */ foreach (lc, jobs) { BgwJob *job = (BgwJob *) lfirst(lc); bool end_offset_job_isnull; int64 end_offset_job = policy_refresh_cagg_get_refresh_end(dim, job->fd.config, &end_offset_job_isnull); if (end_offset_job_isnull || end_offset < end_offset_job) { return false; } } return true; } /* Ensures the refresh range of the new policy doesn't overlap with an existing one*/ PolicyRefreshOffsetOverlapResult policy_refresh_cagg_check_for_overlaps(ContinuousAgg *cagg, Jsonb *policy_config, int32 existing_job_id) { List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_REFRESH_CAGG_PROC_NAME, FUNCTIONS_SCHEMA_NAME, cagg->data.mat_hypertable_id); PolicyRefreshOffsetOverlapResult overlap_result = POLICY_REFRESH_OFFSET_OVERLAP_NONE; if (jobs == NIL) return overlap_result; if (ContinuousAggIsHierarchical(cagg)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("multiple refresh policies are not supported for hierarchical " "continuous aggregates"))); Hypertable *mat_ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); const Dimension *dim = get_open_dimension_for_hypertable(mat_ht, true); bool start_offset_isnull, end_offset_isnull; int64 start_offset = policy_refresh_cagg_get_refresh_start(cagg, dim, policy_config, &start_offset_isnull); int64 end_offset = policy_refresh_cagg_get_refresh_end(dim, policy_config, &end_offset_isnull); RangeBound lower = { .val = Int64GetDatum(start_offset), .infinite = start_offset_isnull, .inclusive = true, .lower = true, }; RangeBound upper = { .val = Int64GetDatum(end_offset), .infinite = end_offset_isnull, .inclusive = false, .lower = false, }; TypeCacheEntry *typcache = lookup_type_cache(INT8RANGEOID, TYPECACHE_RANGE_INFO); if (typcache == NULL || typcache->rngelemtype == NULL) elog(ERROR, "cache lookup failed"); RangeType *range = make_range_compat(typcache, &lower, &upper, false, NULL); ListCell *lc; elog(DEBUG1, "start_offset: " INT64_FORMAT ", end_offset: " INT64_FORMAT, start_offset, end_offset); /* We need to go through all jobs in order to determine if there is an existing job with the * exact same offsets */ foreach (lc, jobs) { BgwJob *job = (BgwJob *) lfirst(lc); if (existing_job_id == job->fd.id) { continue; } bool start_offset_job_isnull, end_offset_job_isnull; int64 start_offset_job = policy_refresh_cagg_get_refresh_start(cagg, dim, job->fd.config, &start_offset_job_isnull); int64 end_offset_job = policy_refresh_cagg_get_refresh_end(dim, job->fd.config, &end_offset_job_isnull); RangeBound lower_job = { .val = Int64GetDatum(start_offset_job), .infinite = start_offset_job_isnull, .inclusive = true, .lower = true, }; RangeBound upper_job = { .val = Int64GetDatum(end_offset_job), .infinite = end_offset_job_isnull, .inclusive = false, .lower = false, }; RangeType *range_job = make_range_compat(typcache, &lower_job, &upper_job, false, NULL); elog(DEBUG1, "start_offset_job: " INT64_FORMAT ", end_offset_job: " INT64_FORMAT, start_offset_job, end_offset_job); /* Check if exact same job exists, in which case throw an error or notice depending on * `if_not_exists` */ if (start_offset == start_offset_job && end_offset == end_offset_job) { /* If all arguments are the same, do nothing */ return POLICY_REFRESH_OFFSET_OVERLAP_EQUAL; } /* We need to first check all other jobs to see if there is an exact match, since we prefer * returning an exact match over an overlap, and the list of jobs isn't guaranteed to be * sorted by start/end offset. */ else if (range_overlaps_internal(typcache, range_job, range)) { overlap_result = POLICY_REFRESH_OFFSET_OVERLAP; } } return overlap_result; } Datum policy_refresh_cagg_add_internal(Oid cagg_oid, Oid start_offset_type, NullableDatum start_offset, Oid end_offset_type, NullableDatum end_offset, Interval refresh_interval, bool if_not_exists, bool fixed_schedule, TimestampTz initial_start, const char *timezone, NullableDatum include_tiered_data, NullableDatum buckets_per_batch, NullableDatum max_batches_per_execution, NullableDatum refresh_newest_first) { NameData application_name; NameData proc_name, proc_schema, check_name, check_schema, owner; ContinuousAgg *cagg; CaggPolicyConfig policyconf; int32 job_id; Oid owner_id; JsonbParseState *parse_state = NULL; /* Verify that the owner can create a background worker */ owner_id = ts_cagg_permissions_check(cagg_oid, GetUserId()); ts_bgw_job_validate_job_owner(owner_id); cagg = ts_continuous_agg_find_by_relid(cagg_oid); if (!cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("\"%s\" is not a continuous aggregate", get_rel_name(cagg_oid)))); if (!start_offset.isnull) start_offset.isnull = ts_if_offset_is_infinity(start_offset.value, start_offset_type, true /* is_start */); if (!end_offset.isnull) end_offset.isnull = ts_if_offset_is_infinity(end_offset.value, end_offset_type, false /* is_start */); parse_cagg_policy_config(cagg, start_offset_type, start_offset, end_offset_type, end_offset, &policyconf); /* Insert a new job into jobs table */ namestrcpy(&application_name, "Refresh Continuous Aggregate Policy"); namestrcpy(&proc_name, POLICY_REFRESH_CAGG_PROC_NAME); namestrcpy(&proc_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&check_name, POLICY_REFRESH_CAGG_CHECK_NAME); namestrcpy(&check_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&owner, GetUserNameFromId(owner_id, false)); pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int32(parse_state, POL_REFRESH_CONF_KEY_MAT_HYPERTABLE_ID, cagg->data.mat_hypertable_id); if (!policyconf.offset_start.isnull) json_add_dim_interval_value(parse_state, POL_REFRESH_CONF_KEY_START_OFFSET, policyconf.offset_start.type, policyconf.offset_start.value); else ts_jsonb_add_null(parse_state, POL_REFRESH_CONF_KEY_START_OFFSET); if (!policyconf.offset_end.isnull) json_add_dim_interval_value(parse_state, POL_REFRESH_CONF_KEY_END_OFFSET, policyconf.offset_end.type, policyconf.offset_end.value); else ts_jsonb_add_null(parse_state, POL_REFRESH_CONF_KEY_END_OFFSET); if (!include_tiered_data.isnull) ts_jsonb_add_bool(parse_state, POL_REFRESH_CONF_KEY_INCLUDE_TIERED_DATA, include_tiered_data.value); if (!buckets_per_batch.isnull) ts_jsonb_add_int32(parse_state, POL_REFRESH_CONF_KEY_BUCKETS_PER_BATCH, buckets_per_batch.value); if (!max_batches_per_execution.isnull) ts_jsonb_add_int32(parse_state, POL_REFRESH_CONF_KEY_MAX_BATCHES_PER_EXECUTION, max_batches_per_execution.value); if (!refresh_newest_first.isnull) ts_jsonb_add_bool(parse_state, POL_REFRESH_CONF_KEY_REFRESH_NEWEST_FIRST, refresh_newest_first.value); JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); Jsonb *config = JsonbValueToJsonb(result); PolicyRefreshOffsetOverlapResult res = policy_refresh_cagg_check_for_overlaps(cagg, config, 0); switch (res) { case POLICY_REFRESH_OFFSET_OVERLAP_NONE: break; case POLICY_REFRESH_OFFSET_OVERLAP_EQUAL: if (if_not_exists) { ereport(NOTICE, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("continuous aggregate refresh policy already exists for " "\"%s\", skipping", get_rel_name(cagg->relid)), errdetail("A refresh policy with the same start and end offset already " "exists for continuous aggregate \"%s\".", get_rel_name(cagg->relid)))); PG_RETURN_INT32(-1); } ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("continuous aggregate refresh policy already exists for " "\"%s\"", get_rel_name(cagg->relid)), errdetail("A refresh policy with the same start and end offset already exists " "for " "continuous aggregate \"%s\".", get_rel_name(cagg->relid)))); break; case POLICY_REFRESH_OFFSET_OVERLAP: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("refresh interval overlaps with an existing continuous aggregate " "policy on \"%s\"", get_rel_name(cagg->relid)))); break; } job_id = ts_bgw_job_insert_relation(&application_name, &refresh_interval, DEFAULT_MAX_RUNTIME, JOB_RETRY_UNLIMITED, &refresh_interval, &proc_schema, &proc_name, &check_schema, &check_name, owner_id, true, fixed_schedule, cagg->data.mat_hypertable_id, config, initial_start, timezone); PG_RETURN_INT32(job_id); } Datum policy_refresh_cagg_add(PG_FUNCTION_ARGS) { Oid cagg_oid, start_offset_type, end_offset_type; Interval refresh_interval; bool if_not_exists; NullableDatum start_offset, end_offset; NullableDatum include_tiered_data; NullableDatum buckets_per_batch; NullableDatum max_batches_per_execution; NullableDatum refresh_newest_first; ts_feature_flag_check(FEATURE_POLICY); cagg_oid = PG_GETARG_OID(0); if (PG_ARGISNULL(3)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot use NULL refresh_schedule_interval"))); start_offset_type = get_fn_expr_argtype(fcinfo->flinfo, 1); start_offset.value = PG_GETARG_DATUM(1); start_offset.isnull = PG_ARGISNULL(1); end_offset_type = get_fn_expr_argtype(fcinfo->flinfo, 2); end_offset.value = PG_GETARG_DATUM(2); end_offset.isnull = PG_ARGISNULL(2); refresh_interval = *PG_GETARG_INTERVAL_P(3); if_not_exists = PG_GETARG_BOOL(4); TimestampTz initial_start = PG_ARGISNULL(5) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(5); bool fixed_schedule = !PG_ARGISNULL(5); text *timezone = PG_ARGISNULL(6) ? NULL : PG_GETARG_TEXT_PP(6); char *valid_timezone = NULL; include_tiered_data.value = PG_GETARG_DATUM(7); include_tiered_data.isnull = PG_ARGISNULL(7); buckets_per_batch.value = PG_GETARG_DATUM(8); buckets_per_batch.isnull = PG_ARGISNULL(8); max_batches_per_execution.value = PG_GETARG_DATUM(9); max_batches_per_execution.isnull = PG_ARGISNULL(9); refresh_newest_first.value = PG_GETARG_DATUM(10); refresh_newest_first.isnull = PG_ARGISNULL(10); Datum retval; /* if users pass in -infinity for initial_start, then use the current_timestamp instead */ if (fixed_schedule) { ts_bgw_job_validate_schedule_interval(&refresh_interval); if (TIMESTAMP_NOT_FINITE(initial_start)) initial_start = ts_timer_get_current_timestamp(); } if (timezone != NULL) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(6)); retval = policy_refresh_cagg_add_internal(cagg_oid, start_offset_type, start_offset, end_offset_type, end_offset, refresh_interval, if_not_exists, fixed_schedule, initial_start, valid_timezone, include_tiered_data, buckets_per_batch, max_batches_per_execution, refresh_newest_first); if (!TIMESTAMP_NOT_FINITE(initial_start)) { int32 job_id = DatumGetInt32(retval); ts_bgw_job_stat_upsert_next_start(job_id, initial_start); } return retval; } Datum policy_refresh_cagg_remove_internal(Oid cagg_oid, bool if_exists) { int32 mat_htid; ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(cagg_oid); if (!cagg) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("\"%s\" is not a continuous aggregate", get_rel_name(cagg_oid)))); ts_cagg_permissions_check(cagg_oid, GetUserId()); mat_htid = cagg->data.mat_hypertable_id; List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_REFRESH_CAGG_PROC_NAME, FUNCTIONS_SCHEMA_NAME, mat_htid); if (jobs == NIL) { if (!if_exists) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), (errmsg("continuous aggregate policy not found for \"%s\"", get_rel_name(cagg_oid))))); else { ereport(NOTICE, (errmsg("continuous aggregate policy not found for \"%s\", skipping", get_rel_name(cagg_oid)))); PG_RETURN_BOOL(false); } } // Delete all bgw jobs associated with this CAgg ListCell *lc; foreach (lc, jobs) { BgwJob *job = (BgwJob *) lfirst(lc); ts_bgw_job_delete_by_id(job->fd.id); } PG_RETURN_BOOL(true); } Datum policy_refresh_cagg_remove(PG_FUNCTION_ARGS) { Oid cagg_oid = PG_GETARG_OID(0); bool if_not_exists = PG_GETARG_BOOL(1); /* Deprecating this argument */ bool if_exists; /* For backward compatibility, we use IF_NOT_EXISTS when IF_EXISTS is not given */ if_exists = PG_ARGISNULL(2) ? if_not_exists : PG_GETARG_BOOL(2); ts_feature_flag_check(FEATURE_POLICY); (void) policy_refresh_cagg_remove_internal(cagg_oid, if_exists); PG_RETURN_VOID(); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/continuous_aggregate_api.h������������������������������������0000664�0000000�0000000�00000004366�15100345067�0025031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "bgw_policy/job.h" #include "dimension.h" #include <continuous_aggs/materialize.h> #include <utils/jsonb.h> typedef enum PolicyRefreshOffsetOverlapResult { POLICY_REFRESH_OFFSET_OVERLAP, /* overlap but not exact */ POLICY_REFRESH_OFFSET_OVERLAP_EQUAL, /* exact match */ POLICY_REFRESH_OFFSET_OVERLAP_NONE, /* no overlap */ } PolicyRefreshOffsetOverlapResult; extern Datum policy_refresh_cagg_add(PG_FUNCTION_ARGS); extern Datum policy_refresh_cagg_proc(PG_FUNCTION_ARGS); extern Datum policy_refresh_cagg_check(PG_FUNCTION_ARGS); extern Datum policy_refresh_cagg_remove(PG_FUNCTION_ARGS); int32 policy_continuous_aggregate_get_mat_hypertable_id(const Jsonb *config); int64 policy_refresh_cagg_get_refresh_start(const ContinuousAgg *cagg, const Dimension *dim, const Jsonb *config, bool *start_isnull); int64 policy_refresh_cagg_get_refresh_end(const Dimension *dim, const Jsonb *config, bool *end_isnull); bool policy_refresh_cagg_get_include_tiered_data(const Jsonb *config, bool *isnull); int32 policy_refresh_cagg_get_buckets_per_batch(const Jsonb *config); int32 policy_refresh_cagg_get_max_batches_per_execution(const Jsonb *config); bool policy_refresh_cagg_get_refresh_newest_first(const Jsonb *config); bool policy_refresh_cagg_exists(int32 materialization_id); Datum policy_refresh_cagg_add_internal( Oid cagg_oid, Oid start_offset_type, NullableDatum start_offset, Oid end_offset_type, NullableDatum end_offset, Interval refresh_interval, bool if_not_exists, bool fixed_schedule, TimestampTz initial_start, const char *timezone, NullableDatum include_tiered_data, NullableDatum buckets_per_batch, NullableDatum max_batches_per_execution, NullableDatum refresh_newest_first); Datum policy_refresh_cagg_remove_internal(Oid cagg_oid, bool if_exists); PolicyRefreshOffsetOverlapResult policy_refresh_cagg_check_for_overlaps(ContinuousAgg *cagg, Jsonb *policy_config, int32 existing_job_id); bool policy_refresh_cagg_check_if_last_policy(PolicyContinuousAggData *policy_data); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/job.c���������������������������������������������������������0000664�0000000�0000000�00000062044�15100345067�0020526�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "bgw_policy/policies_v2.h" #include "cache.h" #include <access/xact.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <commands/defrem.h> #include <extension.h> #include <funcapi.h> #include <hypertable_cache.h> #include <nodes/makefuncs.h> #include <nodes/pg_list.h> #include <nodes/primnodes.h> #include <parser/parse_func.h> #include <parser/parser.h> #include <tcop/pquery.h> #include <utils/builtins.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include <utils/portal.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/timer.h" #include "bgw_policy/chunk_stats.h" #include "bgw_policy/compression_api.h" #include "bgw_policy/continuous_aggregate_api.h" #include "bgw_policy/policy_config.h" #include "bgw_policy/policy_utils.h" #include "bgw_policy/process_hyper_inval_api.h" #include "bgw_policy/reorder_api.h" #include "bgw_policy/retention_api.h" #include "compression/api.h" #include "continuous_aggs/invalidation_threshold.h" #include "continuous_aggs/materialize.h" #include "continuous_aggs/refresh.h" #include "ts_catalog/continuous_agg.h" #ifdef USE_TELEMETRY #include "telemetry/telemetry.h" #endif #include "tsl/src/chunk.h" #include "chunk.h" #include "config.h" #include "dimension.h" #include "dimension_slice.h" #include "guc.h" #include "job.h" #include "jsonb_utils.h" #include "reorder.h" #include "utils.h" #define REORDER_SKIP_RECENT_DIM_SLICES_N 3 static void log_retention_boundary(int elevel, PolicyRetentionData *policy_data, const char *message) { if (OidIsValid(policy_data->boundary_type)) elog(elevel, "%s \"%s\": dropping data %s %s", message, get_rel_name(policy_data->object_relid), policy_data->use_creation_time ? "created before" : "older than", ts_datum_to_string(policy_data->boundary, policy_data->boundary_type)); } static void enable_fast_restart(int32 job_id, const char *job_name) { BgwJobStat *job_stat = ts_bgw_job_stat_find(job_id); if (job_stat != NULL) { /* job might not have a valid last_start if it was not * run by the bgw framework. */ ts_bgw_job_stat_set_next_start(job_id, job_stat->fd.last_start != DT_NOBEGIN ? job_stat->fd.last_start : GetCurrentTransactionStartTimestamp()); } else ts_bgw_job_stat_upsert_next_start(job_id, GetCurrentTransactionStartTimestamp()); elog(DEBUG1, "the %s job is scheduled to run again immediately", job_name); } /* * Returns the ID of a chunk to reorder. Eligible chunks must be at least the * 3rd newest chunk in the hypertable (not entirely exact because we use the number * of dimension slices as a proxy for the number of chunks), * not compressed, not dropped and hasn't been reordered recently. * For this version of automatic reordering, "not reordered * recently" means the chunk has not been reordered at all. This information * is available in the bgw_policy_chunk_stats metadata table. */ static int get_chunk_id_to_reorder(int32 job_id, Hypertable *ht) { const Dimension *time_dimension = hyperspace_get_open_dimension(ht->space, 0); const DimensionSlice *nth_dimension = ts_dimension_slice_nth_latest_slice(time_dimension->fd.id, REORDER_SKIP_RECENT_DIM_SLICES_N); if (!nth_dimension) return -1; Assert(time_dimension != NULL); return ts_dimension_slice_oldest_valid_chunk_for_reorder(job_id, time_dimension->fd.id, BTLessEqualStrategyNumber, nth_dimension->fd.range_start, InvalidStrategy, -1); } /* * returns now() - window as partitioning type datum */ static Datum get_window_boundary(const Dimension *dim, const Jsonb *config, int64 (*int_getter)(const Jsonb *), Interval *(*interval_getter)(const Jsonb *) ) { Oid partitioning_type = ts_dimension_get_partition_type(dim); if (IS_INTEGER_TYPE(partitioning_type)) { Oid now_func = ts_get_integer_now_func(dim, false); /* If "now_func" is provided then we use that for calculating the window. */ if (OidIsValid(now_func)) { int64 res, lag = int_getter(config); res = ts_sub_integer_from_now(lag, partitioning_type, now_func); return Int64GetDatum(res); } else { /* * Otherwise, the interval value can be returned without subtracting it * from now(). */ Interval *lag = interval_getter(config); return IntervalPGetDatum(lag); } } else { Interval *lag = interval_getter(config); return subtract_interval_from_now(lag, partitioning_type); } } static List * get_chunk_to_recompress(const Dimension *dim, const Jsonb *config) { Oid partitioning_type = ts_dimension_get_partition_type(dim); StrategyNumber end_strategy = BTLessStrategyNumber; int32 numchunks = policy_compression_get_maxchunks_per_job(config); Datum boundary = get_window_boundary(dim, config, policy_recompression_get_recompress_after_int, policy_recompression_get_recompress_after_interval); return ts_dimension_slice_get_chunkids_to_compress(dim->fd.id, InvalidStrategy, /*start_strategy*/ -1, /*start_value*/ end_strategy, ts_time_value_to_internal(boundary, partitioning_type), false, true, numchunks); } static void check_valid_index(Hypertable *ht, const char *index_name) { Oid index_oid; HeapTuple idxtuple; Form_pg_index index_form; index_oid = ts_get_relation_relid(NameStr(ht->fd.schema_name), (char *) index_name, true); idxtuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid)); if (!HeapTupleIsValid(idxtuple)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("reorder index not found"), errdetail("The index \"%s\" could not be found", index_name))); index_form = (Form_pg_index) GETSTRUCT(idxtuple); if (index_form->indrelid != ht->main_table_relid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid reorder index"), errhint("The reorder index must by an index on hypertable \"%s\".", NameStr(ht->fd.table_name)))); ReleaseSysCache(idxtuple); } bool policy_reorder_execute(int32 job_id, Jsonb *config) { int chunk_id; Chunk *chunk; PolicyReorderData policy; policy_reorder_read_and_validate_config(config, &policy); /* Find a chunk to reorder in the selected hypertable */ chunk_id = get_chunk_id_to_reorder(job_id, policy.hypertable); if (chunk_id == -1) { elog(NOTICE, "no chunks need reordering for hypertable %s.%s", NameStr(policy.hypertable->fd.schema_name), NameStr(policy.hypertable->fd.table_name)); return true; } /* * NOTE: We pass the Oid of the hypertable's index, and the true reorder * function should translate this to the Oid of the index on the specific * chunk. */ chunk = ts_chunk_get_by_id(chunk_id, false); elog(DEBUG1, "reordering chunk %s.%s", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); reorder_chunk(chunk->table_id, policy.index_relid, false, InvalidOid, InvalidOid, InvalidOid); elog(DEBUG1, "completed reordering chunk %s.%s", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); /* Now update chunk_stats table */ ts_bgw_policy_chunk_stats_record_job_run(job_id, chunk_id, ts_timer_get_current_timestamp()); if (get_chunk_id_to_reorder(job_id, policy.hypertable) != -1) enable_fast_restart(job_id, "reorder"); return true; } void policy_reorder_read_and_validate_config(Jsonb *config, PolicyReorderData *policy) { int32 htid = policy_config_get_hypertable_id(config); Hypertable *ht = ts_hypertable_get_by_id(htid); if (!ht) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("configuration hypertable id %d not found", htid))); const char *index_name = policy_reorder_get_index_name(config); check_valid_index(ht, index_name); if (policy) { policy->hypertable = ht; policy->index_relid = ts_get_relation_relid(NameStr(ht->fd.schema_name), (char *) index_name, false); } } bool policy_retention_execute(int32 job_id, Jsonb *config) { PolicyRetentionData policy_data; bool verbose_log; policy_retention_read_and_validate_config(config, &policy_data); verbose_log = policy_get_verbose_log(config); if (verbose_log) log_retention_boundary(LOG, &policy_data, "applying retention policy to hypertable"); chunk_invoke_drop_chunks(policy_data.object_relid, policy_data.boundary, policy_data.boundary_type, policy_data.use_creation_time); return true; } void policy_retention_read_and_validate_config(Jsonb *config, PolicyRetentionData *policy_data) { Oid object_relid; Hypertable *hypertable; Cache *hcache; const Dimension *open_dim; Datum boundary; Oid boundary_type; ContinuousAgg *cagg; Interval *(*interval_getter)(const Jsonb *); interval_getter = policy_retention_get_drop_after_interval; bool use_creation_time = false; object_relid = ts_hypertable_id_to_relid(policy_config_get_hypertable_id(config), false); hypertable = ts_hypertable_cache_get_cache_and_entry(object_relid, CACHE_FLAG_NONE, &hcache); open_dim = get_open_dimension_for_hypertable(hypertable, false); /* if dim is NULL, then it should be an INTEGER partition with no int_now function */ if (open_dim == NULL) { Oid partition_type; open_dim = hyperspace_get_open_dimension(hypertable->space, 0); partition_type = ts_dimension_get_partition_type(open_dim); if (!IS_INTEGER_TYPE(partition_type)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("incorrect partition type %d. Expected integer", partition_type))); /* if there's no int_now function the boundary is considered as an INTERVAL */ boundary_type = INTERVALOID; interval_getter = policy_retention_get_drop_created_before_interval; use_creation_time = true; } else boundary_type = ts_dimension_get_partition_type(open_dim); boundary = get_window_boundary(open_dim, config, policy_retention_get_drop_after_int, interval_getter); /* We need to do a reverse lookup here since the given hypertable might be a materialized hypertable, and thus need to call drop_chunks on the continuous aggregate instead. */ cagg = ts_continuous_agg_find_by_mat_hypertable_id(hypertable->fd.id, true); if (cagg) { object_relid = ts_get_relation_relid(NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name), false); } ts_cache_release(&hcache); if (policy_data) { policy_data->object_relid = object_relid; policy_data->boundary = boundary; policy_data->boundary_type = boundary_type; policy_data->use_creation_time = use_creation_time; } } bool policy_refresh_cagg_execute(int32 job_id, Jsonb *config) { PolicyContinuousAggData policy_data; StringInfo str = makeStringInfo(); JsonbToCStringIndent(str, &config->root, VARSIZE(config)); policy_refresh_cagg_read_and_validate_config(config, &policy_data); bool extend_last_bucket = !policy_refresh_cagg_check_if_last_policy(&policy_data); bool enable_osm_reads_old = ts_guc_enable_osm_reads; if (!policy_data.include_tiered_data_isnull) { SetConfigOption("timescaledb.enable_tiered_reads", policy_data.include_tiered_data ? "on" : "off", PGC_USERSET, PGC_S_SESSION); } ContinuousAggRefreshContext context = { .callctx = CAGG_REFRESH_POLICY }; /* Try to split window range into a list of ranges */ List *refresh_window_list = continuous_agg_split_refresh_window(policy_data.cagg, &policy_data.refresh_window, policy_data.buckets_per_batch, policy_data.refresh_newest_first); if (refresh_window_list == NIL) refresh_window_list = lappend(refresh_window_list, &policy_data.refresh_window); else context.callctx = CAGG_REFRESH_POLICY_BATCHED; context.number_of_batches = list_length(refresh_window_list); ListCell *lc; int32 processing_batch = 0; foreach (lc, refresh_window_list) { InternalTimeRange *refresh_window = (InternalTimeRange *) lfirst(lc); elog(DEBUG1, "refreshing continuous aggregate \"%s\" from %s to %s", NameStr(policy_data.cagg->data.user_view_name), ts_internal_to_time_string(refresh_window->start, refresh_window->type), ts_internal_to_time_string(refresh_window->end, refresh_window->type)); context.processing_batch = ++processing_batch; continuous_agg_refresh_internal(policy_data.cagg, refresh_window, context, refresh_window->start_isnull, refresh_window->end_isnull, (context.callctx != CAGG_REFRESH_POLICY_BATCHED), false, /* force */ policy_data.process_hypertable_invalidations, extend_last_bucket); if (processing_batch >= policy_data.max_batches_per_execution && processing_batch < context.number_of_batches && policy_data.max_batches_per_execution > 0) { elog(LOG, "reached maximum number of batches per execution (%d), batches not processed (%d)", policy_data.max_batches_per_execution, context.number_of_batches - processing_batch); break; } } if (!policy_data.include_tiered_data_isnull) { SetConfigOption("timescaledb.enable_tiered_reads", enable_osm_reads_old ? "on" : "off", PGC_USERSET, PGC_S_SESSION); } return true; } void policy_refresh_cagg_read_and_validate_config(Jsonb *config, PolicyContinuousAggData *policy_data) { int32 materialization_id; Hypertable *mat_ht; const Dimension *open_dim; Oid dim_type; int64 refresh_start, refresh_end; int32 buckets_per_batch, max_batches_per_execution; bool start_isnull, end_isnull; bool include_tiered_data, include_tiered_data_isnull; bool refresh_newest_first; materialization_id = policy_continuous_aggregate_get_mat_hypertable_id(config); mat_ht = ts_hypertable_get_by_id(materialization_id); if (!mat_ht) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("configuration materialization hypertable id %d not found", materialization_id))); ContinuousAgg *cagg = ts_continuous_agg_find_by_mat_hypertable_id(materialization_id, false); open_dim = get_open_dimension_for_hypertable(mat_ht, true); dim_type = ts_dimension_get_partition_type(open_dim); refresh_start = policy_refresh_cagg_get_refresh_start(cagg, open_dim, config, &start_isnull); refresh_end = policy_refresh_cagg_get_refresh_end(open_dim, config, &end_isnull); if (refresh_start >= refresh_end) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid refresh window"), errdetail("start_offset: %s, end_offset: %s", ts_internal_to_time_string(refresh_start, dim_type), ts_internal_to_time_string(refresh_end, dim_type)), errhint("The start of the window must be before the end."))); include_tiered_data = policy_refresh_cagg_get_include_tiered_data(config, &include_tiered_data_isnull); buckets_per_batch = policy_refresh_cagg_get_buckets_per_batch(config); if (buckets_per_batch < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid buckets per batch"), errdetail("buckets_per_batch: %d", buckets_per_batch), errhint("The buckets per batch should be greater than or equal to zero."))); max_batches_per_execution = policy_refresh_cagg_get_max_batches_per_execution(config); if (max_batches_per_execution < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid max batches per execution"), errdetail("max_batches_per_execution: %d", max_batches_per_execution), errhint( "The max batches per execution should be greater than or equal to zero."))); refresh_newest_first = policy_refresh_cagg_get_refresh_newest_first(config); bool process_hypertable_invalidations_found; bool process_hypertable_invalidations = ts_jsonb_get_bool_field(config, POL_REFRESH_CONF_KEY_PROCESS_HYPERTABLE_INVALIDATIONS, &process_hypertable_invalidations_found); if (policy_data) { policy_data->refresh_window.type = dim_type; policy_data->refresh_window.start = refresh_start; policy_data->refresh_window.start_isnull = start_isnull; policy_data->refresh_window.end = refresh_end; policy_data->refresh_window.end_isnull = end_isnull; policy_data->cagg = cagg; policy_data->include_tiered_data = include_tiered_data; policy_data->include_tiered_data_isnull = include_tiered_data_isnull; policy_data->buckets_per_batch = buckets_per_batch; policy_data->max_batches_per_execution = max_batches_per_execution; policy_data->refresh_newest_first = refresh_newest_first; policy_data->process_hypertable_invalidations = !process_hypertable_invalidations_found || process_hypertable_invalidations; } } /* Read configuration for compression job from config object. */ void policy_compression_read_and_validate_config(Jsonb *config, PolicyCompressionData *policy_data) { Oid table_relid = ts_hypertable_id_to_relid(policy_config_get_hypertable_id(config), false); Cache *hcache; Hypertable *hypertable = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); if (policy_data) { policy_data->hypertable = hypertable; policy_data->hcache = hcache; } } void policy_recompression_read_and_validate_config(Jsonb *config, PolicyCompressionData *policy_data) { Oid table_relid = ts_hypertable_id_to_relid(policy_config_get_hypertable_id(config), false); Cache *hcache; Hypertable *hypertable = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); if (policy_data) { policy_data->hypertable = hypertable; policy_data->hcache = hcache; } } bool policy_recompression_execute(int32 job_id, Jsonb *config) { List *chunkid_lst; ListCell *lc; const Dimension *dim; PolicyCompressionData policy_data; bool used_portalcxt = false; MemoryContext saved_cxt, multitxn_cxt; policy_recompression_read_and_validate_config(config, &policy_data); dim = hyperspace_get_open_dimension(policy_data.hypertable->space, 0); /* we want the chunk id list to survive across transactions. So alloc in * a different context */ if (PortalContext) { /*if we have a portal context use that - it will get freed automatically*/ multitxn_cxt = PortalContext; used_portalcxt = true; } else { /* background worker job does not go via usual CALL path, so we do * not have a PortalContext */ multitxn_cxt = AllocSetContextCreate(TopMemoryContext, "CompressionJobCxt", ALLOCSET_DEFAULT_SIZES); } saved_cxt = MemoryContextSwitchTo(multitxn_cxt); chunkid_lst = get_chunk_to_recompress(dim, config); MemoryContextSwitchTo(saved_cxt); if (!chunkid_lst) { elog(NOTICE, "no chunks for hypertable \"%s.%s\" that satisfy recompress chunk policy", NameStr(policy_data.hypertable->fd.schema_name), NameStr(policy_data.hypertable->fd.table_name)); ts_cache_release(&policy_data.hcache); if (!used_portalcxt) MemoryContextDelete(multitxn_cxt); return true; } ts_cache_release(&policy_data.hcache); if (ActiveSnapshotSet()) PopActiveSnapshot(); /* process each chunk in a new transaction */ foreach (lc, chunkid_lst) { CommitTransactionCommand(); StartTransactionCommand(); int32 chunkid = lfirst_int(lc); Chunk *chunk = ts_chunk_get_by_id(chunkid, true); Assert(chunk); if (!ts_chunk_needs_recompression(chunk)) continue; tsl_compress_chunk_wrapper(chunk, true, false); elog(LOG, "completed recompressing chunk \"%s.%s\"", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); } elog(DEBUG1, "job %d completed recompressing chunk", job_id); return true; } void policy_process_hyper_inval_read_and_validate_config(Jsonb *config, PolicyMoveHyperInvalData *policy_data) { int32 hypertable_id = policy_config_get_hypertable_id(config); Oid table_relid = ts_hypertable_id_to_relid(hypertable_id, true); if (!OidIsValid(table_relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("configuration hypertable id %d not found", hypertable_id))); Cache *hcache; Hypertable *hypertable = ts_hypertable_cache_get_cache_and_entry(table_relid, CACHE_FLAG_NONE, &hcache); if (policy_data) { policy_data->hypertable = hypertable; policy_data->hcache = hcache; } else { ts_cache_release(&hcache); } } bool policy_process_hyper_inval_execute(int32 job_id, Jsonb *config) { PolicyMoveHyperInvalData policy_data; policy_process_hyper_inval_read_and_validate_config(config, &policy_data); const Dimension *dim = hyperspace_get_open_dimension(policy_data.hypertable->space, 0); Oid dimtype = ts_dimension_get_partition_type(dim); int32 hypertable_id = policy_data.hypertable->fd.id; /* We serialized on the invalidation threshold, so we get and lock it. */ invalidation_threshold_get(hypertable_id, dimtype); invalidation_process_hypertable_log(hypertable_id, dimtype); ts_cache_release(&policy_data.hcache); return true; } static void job_execute_function(FuncExpr *funcexpr) { bool isnull; EState *estate = CreateExecutorState(); ExprContext *econtext = CreateExprContext(estate); ExprState *es = ExecPrepareExpr((Expr *) funcexpr, estate); ExecEvalExpr(es, econtext, &isnull); FreeExprContext(econtext, true); FreeExecutorState(estate); } static void job_execute_procedure(FuncExpr *funcexpr) { CallStmt *call = makeNode(CallStmt); call->funcexpr = funcexpr; DestReceiver *dest = CreateDestReceiver(DestNone); /* we don't need to create proper param list cause we pass in all arguments as Const */ ParamListInfo params = makeParamList(0); ExecuteCallStmt(call, params, false, dest); } /* * Execute the job. * * This function can be called both from a portal and from a background * worker. */ bool job_execute(BgwJob *job) { Const *arg1, *arg2; bool portal_created = false; char prokind; Oid proc; FuncExpr *funcexpr; MemoryContext parent_ctx = CurrentMemoryContext; StringInfo query; Portal portal = ActivePortal; if (job->fd.config) elog(DEBUG1, "Executing %s with parameters %s", NameStr(job->fd.proc_name), DatumGetCString(DirectFunctionCall1(jsonb_out, JsonbPGetDatum(job->fd.config)))); else elog(DEBUG1, "Executing %s with no parameters", NameStr(job->fd.proc_name)); /* Create a portal if there's no active */ if (!PortalIsValid(portal)) { portal_created = true; portal = CreatePortal("", true, true); portal->visible = false; portal->resowner = CurrentResourceOwner; ActivePortal = portal; PortalContext = portal->portalContext; StartTransactionCommand(); EnsurePortalSnapshotExists(); } #ifdef USE_TELEMETRY /* The telemetry job has a separate code path and since we can reach this * code also when using run_job(), we have a special case here. This will * not be triggered when executed from ts_bgw_job_execute(). */ if (ts_is_telemetry_job(job)) { /* * In the first 12 hours, we want telemetry to ping every * hour. After that initial period, we default to the * schedule_interval listed in the job table. */ Interval one_hour = { .time = 1 * USECS_PER_HOUR }; return ts_bgw_job_run_and_set_next_start(job, ts_telemetry_main_wrapper, TELEMETRY_INITIAL_NUM_RUNS, &one_hour, /* atomic */ false, /* mark */ true); } #endif proc = ts_bgw_job_get_funcid(job); prokind = get_func_prokind(proc); /* * We need to switch back to parent MemoryContext as StartTransactionCommand * switched to CurTransactionContext and this context will be destroyed * on CommitTransactionCommand which may be too short-lived if a policy * has its own transaction handling. */ MemoryContextSwitchTo(parent_ctx); arg1 = makeConst(INT4OID, -1, InvalidOid, 4, Int32GetDatum(job->fd.id), false, true); if (job->fd.config == NULL) arg2 = makeNullConst(JSONBOID, -1, InvalidOid); else arg2 = makeConst(JSONBOID, -1, InvalidOid, -1, JsonbPGetDatum(job->fd.config), false, false); funcexpr = makeFuncExpr(proc, VOIDOID, list_make2(arg1, arg2), InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL); /* Here we create a query string from the function/procedure name that we * are calling. We do not update the status after the execution has * finished since this is wrapped inside the code that starts and stops * any job, not just custom jobs. We just provide more detailed * information here that we are actually calling a specific custom * function. */ query = makeStringInfo(); appendStringInfo(query, "CALL %s.%s()", quote_identifier(NameStr(job->fd.proc_schema)), quote_identifier(NameStr(job->fd.proc_name))); pgstat_report_activity(STATE_RUNNING, query->data); switch (prokind) { case PROKIND_FUNCTION: job_execute_function(funcexpr); break; case PROKIND_PROCEDURE: job_execute_procedure(funcexpr); break; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported function type"))); break; } /* Drop portal if it was created */ if (portal_created) { if (ActiveSnapshotSet()) PopActiveSnapshot(); CommitTransactionCommand(); PortalDrop(portal, false); ActivePortal = NULL; PortalContext = NULL; } return true; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/job.h���������������������������������������������������������0000664�0000000�0000000�00000005130�15100345067�0020524�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/jsonb.h> #include <bgw/job.h> #include <hypertable.h> #include "bgw_policy/chunk_stats.h" #include "cache.h" #include "continuous_aggs/materialize.h" /* Add config keys common across job types here */ #define CONFIG_KEY_VERBOSE_LOG "verbose_log" /*used only by retention now*/ typedef struct PolicyMoveHyperInvalData { Hypertable *hypertable; Cache *hcache; } PolicyMoveHyperInvalData; typedef struct PolicyReorderData { Hypertable *hypertable; Oid index_relid; } PolicyReorderData; typedef struct PolicyRetentionData { Oid object_relid; Datum boundary; Oid boundary_type; bool use_creation_time; } PolicyRetentionData; typedef struct PolicyContinuousAggData { InternalTimeRange refresh_window; ContinuousAgg *cagg; bool include_tiered_data; bool include_tiered_data_isnull; int32 buckets_per_batch; int32 max_batches_per_execution; bool refresh_newest_first; bool process_hypertable_invalidations; } PolicyContinuousAggData; typedef struct PolicyCompressionData { Hypertable *hypertable; Cache *hcache; } PolicyCompressionData; /* Reorder function type. Necessary for testing */ typedef void (*reorder_func)(Oid tableOid, Oid indexOid, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace); /* Functions exposed only for testing */ extern bool policy_reorder_execute(int32 job_id, Jsonb *config); extern bool policy_retention_execute(int32 job_id, Jsonb *config); extern bool policy_refresh_cagg_execute(int32 job_id, Jsonb *config); extern bool policy_process_hyper_inval_execute(int32 job_id, Jsonb *config); extern bool policy_recompression_execute(int32 job_id, Jsonb *config); extern void policy_reorder_read_and_validate_config(Jsonb *config, PolicyReorderData *policy_data); extern void policy_retention_read_and_validate_config(Jsonb *config, PolicyRetentionData *policy_data); extern void policy_refresh_cagg_read_and_validate_config(Jsonb *config, PolicyContinuousAggData *policy_data); extern void policy_process_hyper_inval_read_and_validate_config(Jsonb *config, PolicyMoveHyperInvalData *policy_data); extern void policy_compression_read_and_validate_config(Jsonb *config, PolicyCompressionData *policy_data); extern void policy_recompression_read_and_validate_config(Jsonb *config, PolicyCompressionData *policy_data); extern bool job_execute(BgwJob *job); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/job_api.c�����������������������������������������������������0000664�0000000�0000000�00000047400�15100345067�0021356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <funcapi.h> #include <miscadmin.h> #include <utils/acl.h> #include <utils/builtins.h> #include <parser/parse_func.h> #include <parser/parser.h> #include <bgw/job.h> #include <bgw/job_stat.h> #include "bgw/timer.h" #include "debug_assert.h" #include "hypertable_cache.h" #include "job.h" #include "job_api.h" #include "policies_v2.h" /* Default max runtime for a custom job is unlimited for now */ #define DEFAULT_MAX_RUNTIME 0 /* Default retry period for reorder_jobs is currently 5 minutes */ #define DEFAULT_RETRY_PERIOD (5 * USECS_PER_MINUTE) #define ALTER_JOB_NUM_COLS 13 /* * This function ensures that the check function has the required signature * @param check A valid Oid */ static inline void validate_check_signature(Oid check) { Oid proc = InvalidOid; ObjectWithArgs *object; NameData check_name = { .data = { 0 } }; NameData check_schema = { .data = { 0 } }; namestrcpy(&check_schema, get_namespace_name(get_func_namespace(check))); namestrcpy(&check_name, get_func_name(check)); object = makeNode(ObjectWithArgs); object->objname = list_make2(makeString(NameStr(check_schema)), makeString(NameStr(check_name))); object->objargs = list_make1(SystemTypeName("jsonb")); proc = LookupFuncWithArgs(OBJECT_ROUTINE, object, true); if (!OidIsValid(proc)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("function or procedure %s.%s(config jsonb) not found", NameStr(check_schema), NameStr(check_name)), errhint("The check function's signature must be (config jsonb)."))); } /* * CREATE FUNCTION add_job( * 0 proc REGPROC, * 1 schedule_interval INTERVAL, * 2 config JSONB DEFAULT NULL, * 3 initial_start TIMESTAMPTZ DEFAULT NULL, * 4 scheduled BOOL DEFAULT true * 5 check_config REGPROC DEFAULT NULL * 6 fixed_schedule BOOL DEFAULT TRUE * 7 timezone TEXT DEFAULT NULL * 8 job_name TEXT DEFAULT NULL * ) RETURNS INTEGER */ Datum job_add(PG_FUNCTION_ARGS) { NameData application_name; NameData proc_name; NameData proc_schema; NameData check_name = { .data = { 0 } }; NameData check_schema = { .data = { 0 } }; Interval max_runtime = { .time = DEFAULT_MAX_RUNTIME }; Interval retry_period = { .time = DEFAULT_RETRY_PERIOD }; int32 job_id; char *func_name = NULL; char *check_name_str = NULL; char *valid_timezone = NULL; TimestampTz initial_start = PG_ARGISNULL(3) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(3); Oid owner = GetUserId(); Oid proc = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Interval *schedule_interval = PG_ARGISNULL(1) ? NULL : PG_GETARG_INTERVAL_P(1); Jsonb *config = PG_ARGISNULL(2) ? NULL : PG_GETARG_JSONB_P(2); bool scheduled = PG_ARGISNULL(4) ? true : PG_GETARG_BOOL(4); Oid check = PG_ARGISNULL(5) ? InvalidOid : PG_GETARG_OID(5); bool fixed_schedule = PG_ARGISNULL(6) ? true : PG_GETARG_BOOL(6); text *timezone = PG_ARGISNULL(7) ? NULL : PG_GETARG_TEXT_PP(7); /* verify it's a valid timezone */ if (timezone != NULL) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(7)); char *job_name_str = PG_ARGISNULL(8) ? NULL : text_to_cstring(PG_GETARG_TEXT_PP(8)); TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("function or procedure cannot be NULL"))); if (NULL == schedule_interval) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("schedule interval cannot be NULL"))); /* for fixed schedules, we use time_bucket in the calculation of next_start Therefore, we cannot allow schedule intervals containing both month and day components */ if (fixed_schedule) ts_bgw_job_validate_schedule_interval(schedule_interval); func_name = get_func_name(proc); if (func_name == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("function or procedure with OID %u does not exist", proc))); if (object_aclcheck(ProcedureRelationId, proc, owner, ACL_EXECUTE) != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for function \"%s\"", func_name), errhint("Job owner must have EXECUTE privilege on the function."))); if (OidIsValid(check)) { check_name_str = get_func_name(check); if (check_name_str == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("function with OID %d does not exist", check))); if (object_aclcheck(ProcedureRelationId, check, owner, ACL_EXECUTE) != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for function \"%s\"", check_name_str), errhint("Job owner must have EXECUTE privilege on the function."))); namestrcpy(&check_schema, get_namespace_name(get_func_namespace(check))); namestrcpy(&check_name, check_name_str); } /* if no initial_start was provided for a fixed schedule, use the current time */ if (fixed_schedule && TIMESTAMP_NOT_FINITE(initial_start)) { initial_start = ts_timer_get_current_timestamp(); elog(DEBUG1, "Using current time [%s] as initial start", DatumGetCString( DirectFunctionCall1(timestamptz_out, TimestampTzGetDatum(initial_start)))); } /* Verify that the owner can create a background worker */ ts_bgw_job_validate_job_owner(owner); /* Next, insert a new job into jobs table */ if (job_name_str) namestrcpy(&application_name, job_name_str); else namestrcpy(&application_name, "User-Defined Action"); namestrcpy(&proc_schema, get_namespace_name(get_func_namespace(proc))); namestrcpy(&proc_name, func_name); /* The check exists but may not have the expected signature: (config jsonb) */ if (OidIsValid(check)) validate_check_signature(check); ts_bgw_job_run_config_check(check, 0, config); job_id = ts_bgw_job_insert_relation(&application_name, schedule_interval, &max_runtime, JOB_RETRY_UNLIMITED, &retry_period, &proc_schema, &proc_name, &check_schema, &check_name, owner, scheduled, fixed_schedule, INVALID_HYPERTABLE_ID, config, initial_start, valid_timezone); if (!TIMESTAMP_NOT_FINITE(initial_start)) ts_bgw_job_stat_upsert_next_start(job_id, initial_start); PG_RETURN_INT32(job_id); } static BgwJob * find_job(int32 job_id, bool null_job_id, bool missing_ok) { BgwJob *job; bool got_lock; LOCKTAG tag; if (null_job_id && !missing_ok) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("job ID cannot be NULL"))); /* The job table manipulation functions in job.c use an advisory lock * rather than a row lock to prevent the job from being modified while * running. Since we use this function to find a job for either running * manually or for altering it, we need to grab that advisory lock here as * well. */ got_lock = ts_lock_job_id(job_id, RowShareLock, /* session_lock */ false, &tag, /* block */ true); Ensure(got_lock, "could not get lock on job id %d", job_id); job = ts_bgw_job_find(job_id, CurrentMemoryContext, !missing_ok); if (NULL == job) { Assert(missing_ok); ereport(NOTICE, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("job %d not found, skipping", job_id))); } return job; } /* * CREATE OR REPLACE FUNCTION delete_job(job_id INTEGER) RETURNS VOID */ Datum job_delete(PG_FUNCTION_ARGS) { int32 job_id = PG_GETARG_INT32(0); BgwJob *job; TS_PREVENT_FUNC_IF_READ_ONLY(); job = find_job(job_id, PG_ARGISNULL(0), false); if (!has_privs_of_role(GetUserId(), job->fd.owner)) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("insufficient permissions to delete job owned by \"%s\"", GetUserNameFromId(job->fd.owner, false)))); ts_bgw_job_delete_by_id(job_id); PG_RETURN_VOID(); } /* * CREATE OR REPLACE PROCEDURE run_job(job_id INTEGER) */ Datum job_run(PG_FUNCTION_ARGS) { int32 job_id = PG_GETARG_INT32(0); BgwJob *job = find_job(job_id, PG_ARGISNULL(0), false); ts_bgw_job_permission_check(job, "run"); job_execute(job); PG_RETURN_VOID(); } /* * CREATE OR REPLACE FUNCTION alter_job( * 0 job_id INTEGER, * 1 schedule_interval INTERVAL = NULL, * 2 max_runtime INTERVAL = NULL, * 3 max_retries INTEGER = NULL, * 4 retry_period INTERVAL = NULL, * 5 scheduled BOOL = NULL, * 6 config JSONB = NULL, * 7 next_start TIMESTAMPTZ = NULL * 8 if_exists BOOL = FALSE, * 9 check_config REGPROC = NULL * 10 fixed_schedule BOOL = NULL, * 11 initial_start TIMESTAMPTZ = NULL * 12 timezone TEXT = NULL * 13 job_name TEXT = NULL * ) RETURNS TABLE ( * job_id INTEGER, * schedule_interval INTERVAL, * max_runtime INTERVAL, * max_retries INTEGER, * retry_period INTERVAL, * scheduled BOOL, * config JSONB, * next_start TIMESTAMPTZ * check_config TEXT * fixed_schedule BOOL * initial_start TIMESTAMPTZ * timezone TEXT * job_name TEXT * ) */ Datum job_alter(PG_FUNCTION_ARGS) { BgwJobStat *stat; TupleDesc tupdesc; Datum values[ALTER_JOB_NUM_COLS] = { 0 }; bool nulls[ALTER_JOB_NUM_COLS] = { false }; HeapTuple tuple; TimestampTz next_start; int job_id = PG_GETARG_INT32(0); bool if_exists = PG_GETARG_BOOL(8); BgwJob *job; NameData check_name = { .data = { 0 } }; NameData check_schema = { .data = { 0 } }; Oid check = PG_ARGISNULL(9) ? InvalidOid : PG_GETARG_OID(9); char *check_name_str = NULL; /* Added space for period and NULL */ char schema_qualified_check_name[(2 * NAMEDATALEN) + 2] = { 0 }; bool unregister_check = (!PG_ARGISNULL(9) && !OidIsValid(check)); TimestampTz initial_start = PG_ARGISNULL(11) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(11); text *timezone = PG_ARGISNULL(12) ? NULL : PG_GETARG_TEXT_PP(12); char *valid_timezone = NULL; /* verify it's a valid timezone */ if (timezone != NULL) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(12)); TS_PREVENT_FUNC_IF_READ_ONLY(); /* check that caller accepts tuple and abort early if that is not the * case */ if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); job = find_job(job_id, PG_ARGISNULL(0), if_exists); if (job == NULL) PG_RETURN_NULL(); ts_bgw_job_permission_check(job, "alter"); if (!PG_ARGISNULL(1)) job->fd.schedule_interval = *PG_GETARG_INTERVAL_P(1); if (!PG_ARGISNULL(2)) job->fd.max_runtime = *PG_GETARG_INTERVAL_P(2); if (!PG_ARGISNULL(3)) job->fd.max_retries = PG_GETARG_INT32(3); if (!PG_ARGISNULL(4)) job->fd.retry_period = *PG_GETARG_INTERVAL_P(4); if (!PG_ARGISNULL(5)) job->fd.scheduled = PG_GETARG_BOOL(5); if (!PG_ARGISNULL(6)) job->fd.config = PG_GETARG_JSONB_P(6); if (!PG_ARGISNULL(9)) { if (OidIsValid(check)) { check_name_str = get_func_name(check); if (check_name_str == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("function with OID %d does not exist", check))); if (object_aclcheck(ProcedureRelationId, check, GetUserId(), ACL_EXECUTE) != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for function \"%s\"", check_name_str), errhint("Job owner must have EXECUTE privilege on the function."))); namestrcpy(&check_schema, get_namespace_name(get_func_namespace(check))); namestrcpy(&check_name, check_name_str); /* The check exists but may not have the expected signature: (config jsonb) */ validate_check_signature(check); namestrcpy(&job->fd.check_schema, NameStr(check_schema)); namestrcpy(&job->fd.check_name, NameStr(check_name)); snprintf(schema_qualified_check_name, sizeof(schema_qualified_check_name) / sizeof(schema_qualified_check_name[0]), "%s.%s", NameStr(check_schema), check_name_str); } } else snprintf(schema_qualified_check_name, sizeof(schema_qualified_check_name) / sizeof(schema_qualified_check_name[0]), "%s.%s", NameStr(job->fd.check_schema), NameStr(job->fd.check_name)); /* * If the CAgg refresh policy job is being altered, then always check for overlap. * There is probably a better place to do this, but we choose to do this here since we need * access to the job_id, which we don't have inside the `policy_check` function called above. */ if (namestrcmp(&job->fd.proc_name, POLICY_REFRESH_CAGG_PROC_NAME) == 0) { int32 materialization_id = policy_continuous_aggregate_get_mat_hypertable_id(job->fd.config); ContinuousAgg *cagg = ts_continuous_agg_find_by_mat_hypertable_id(materialization_id, false); PolicyRefreshOffsetOverlapResult res = policy_refresh_cagg_check_for_overlaps(cagg, job->fd.config, job->fd.id); switch (res) { case POLICY_REFRESH_OFFSET_OVERLAP_NONE: break; case POLICY_REFRESH_OFFSET_OVERLAP_EQUAL: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("continuous aggregate refresh policy already exists for " "\"%s\"", get_rel_name(cagg->relid)), errdetail("A refresh policy with the same start and end offset already " "exists for " "continuous aggregate \"%s\".", get_rel_name(cagg->relid)))); break; case POLICY_REFRESH_OFFSET_OVERLAP: ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("refresh interval overlaps with an existing continuous aggregate " "policy on \"%s\"", get_rel_name(cagg->relid)))); break; } } if (unregister_check) { NameData empty_namedata = { .data = { 0 } }; namestrcpy(&job->fd.check_schema, NameStr(empty_namedata)); namestrcpy(&job->fd.check_name, NameStr(empty_namedata)); } if (!PG_ARGISNULL(10)) { bool fixed_schedule = PG_GETARG_BOOL(10); /* * initial_start is a required argument for fixed schedules * so we use the current timestamp if it's not provided */ if (fixed_schedule) { if (TIMESTAMP_NOT_FINITE(initial_start)) { initial_start = ts_timer_get_current_timestamp(); elog(NOTICE, "Using current time [%s] as initial start for job %d", DatumGetCString( DirectFunctionCall1(timestamptz_out, TimestampTzGetDatum(initial_start))), job->fd.id); job->fd.initial_start = initial_start; } } job->fd.fixed_schedule = fixed_schedule; } if (!PG_ARGISNULL(11)) { /* user provided +- infinity as initial_start, this is not acceptable */ if (TIMESTAMP_NOT_FINITE(initial_start)) { initial_start = ts_timer_get_current_timestamp(); elog(NOTICE, "Using current time [%s] as initial start for job %d", DatumGetCString( DirectFunctionCall1(timestamptz_out, TimestampTzGetDatum(initial_start))), job->fd.id); } job->fd.initial_start = initial_start; } if (!PG_ARGISNULL(13)) { char app_name[NAMEDATALEN]; int name_len; name_len = snprintf(app_name, NAMEDATALEN, "%s [%d]", text_to_cstring(PG_GETARG_TEXT_PP(13)), job_id); if (name_len >= NAMEDATALEN) ereport(ERROR, (errcode(ERRCODE_NAME_TOO_LONG), errmsg("application name too long."))); namestrcpy(&job->fd.application_name, app_name); } if (valid_timezone != NULL) job->fd.timezone = cstring_to_text(valid_timezone); else job->fd.timezone = NULL; /* it's also possible to alter the fields initial_start and timezone without * specifying fixed_schedule. In that case, update them and also update the * next_start accordingly. * If the job is not on a fixed schedule, then this has no effect on the next_start, * so maybe print a message to the user * that these changes are not really doing anything */ /* this function will also update the next_start if the schedule interval is changed, but I'm not going to rely on this to change stuff */ ts_bgw_job_update_by_id(job_id, job); /* one of the fields below changing necessitates a next_start update */ if (!PG_ARGISNULL(10) || !TIMESTAMP_NOT_FINITE(initial_start) || (valid_timezone != NULL)) { TimestampTz next_start_calculated; if (job->fd.fixed_schedule) { next_start_calculated = ts_get_next_scheduled_execution_slot(job, ts_timer_get_current_timestamp()); ts_bgw_job_stat_update_next_start(job->fd.id, next_start_calculated, false); } else { /* last finish time plus schedule interval */ BgwJobStat *stat = ts_bgw_job_stat_find(job->fd.id); if (stat != NULL) { next_start_calculated = DatumGetTimestampTz( DirectFunctionCall2(timestamptz_pl_interval, TimestampTzGetDatum(stat->fd.last_finish), IntervalPGetDatum(&job->fd.schedule_interval))); /* allow DT_NOBEGIN for next_start here through allow_unset=true in the case that * last_finish is DT_NOBEGIN, * This means the value is counted as unset which is what we want */ ts_bgw_job_stat_update_next_start(job->fd.id, next_start_calculated, true); } } } if (!PG_ARGISNULL(7)) ts_bgw_job_stat_upsert_next_start(job_id, PG_GETARG_TIMESTAMPTZ(7)); stat = ts_bgw_job_stat_find(job_id); if (stat != NULL) next_start = stat->fd.next_start; else next_start = DT_NOBEGIN; tupdesc = BlessTupleDesc(tupdesc); values[0] = Int32GetDatum(job->fd.id); values[1] = IntervalPGetDatum(&job->fd.schedule_interval); values[2] = IntervalPGetDatum(&job->fd.max_runtime); values[3] = Int32GetDatum(job->fd.max_retries); values[4] = IntervalPGetDatum(&job->fd.retry_period); values[5] = BoolGetDatum(job->fd.scheduled); if (job->fd.config == NULL) nulls[6] = true; else values[6] = JsonbPGetDatum(job->fd.config); values[7] = TimestampTzGetDatum(next_start); if (unregister_check) nulls[8] = true; else if (strlen(NameStr(job->fd.check_schema)) > 0) values[8] = CStringGetTextDatum(schema_qualified_check_name); else nulls[8] = true; /* values/nulls[9]: fixed_schedule */ values[9] = job->fd.fixed_schedule; /* values/nulls[10]: initial_start */ if (TIMESTAMP_NOT_FINITE(job->fd.initial_start)) { nulls[10] = true; } else values[10] = TimestampTzGetDatum(job->fd.initial_start); /* values/nulls[11]: timezone */ if (valid_timezone) values[11] = CStringGetTextDatum(valid_timezone); else nulls[11] = true; values[12] = NameGetDatum(&job->fd.application_name); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } static Hypertable * get_hypertable_from_oid(Cache **hcache, Oid table_oid) { Hypertable *hypertable = NULL; hypertable = ts_hypertable_cache_get_cache_and_entry(table_oid, CACHE_FLAG_MISSING_OK, hcache); if (!hypertable) { const char *view_name = get_rel_name(table_oid); if (!view_name) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("relation is not a hypertable or continuous aggregate"))); else { ContinuousAgg *ca = ts_continuous_agg_find_by_relid(table_oid); if (!ca) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("relation \"%s\" is not a hypertable or continuous aggregate", view_name))); hypertable = ts_hypertable_get_by_id(ca->data.mat_hypertable_id); } } Assert(hypertable != NULL); return hypertable; } Datum job_alter_set_hypertable_id(PG_FUNCTION_ARGS) { int32 job_id = PG_GETARG_INT32(0); Oid table_oid = PG_GETARG_OID(1); Cache *hcache = NULL; Hypertable *ht = NULL; TS_PREVENT_FUNC_IF_READ_ONLY(); BgwJob *job = find_job(job_id, PG_ARGISNULL(0), false /* missing_ok */); if (job == NULL) PG_RETURN_NULL(); ts_bgw_job_permission_check(job, "alter"); if (!PG_ARGISNULL(1)) { ht = get_hypertable_from_oid(&hcache, table_oid); ts_hypertable_permissions_check(ht->main_table_relid, GetUserId()); } job->fd.hypertable_id = (ht != NULL ? ht->fd.id : 0); ts_bgw_job_update_by_id(job_id, job); if (hcache) ts_cache_release(&hcache); PG_RETURN_INT32(job_id); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/job_api.h�����������������������������������������������������0000664�0000000�0000000�00000001077�15100345067�0021363�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> /* Special values for the number of retries of a failed job */ #define JOB_RETRY_UNLIMITED (-1) #define JOB_RETRY_NONE 0 extern Datum job_add(PG_FUNCTION_ARGS); extern Datum job_alter(PG_FUNCTION_ARGS); extern Datum job_delete(PG_FUNCTION_ARGS); extern Datum job_run(PG_FUNCTION_ARGS); extern Datum job_alter_set_hypertable_id(PG_FUNCTION_ARGS); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/policies_v2.c�������������������������������������������������0000664�0000000�0000000�00000060233�15100345067�0022170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <fmgr.h> #include <miscadmin.h> #include <parser/parse_coerce.h> #include <utils/builtins.h> #include <utils/float.h> #include "compat/compat.h" #include "bgw/job.h" #include "bgw_policy/continuous_aggregate_api.h" #include "bgw_policy/job.h" #include "bgw_policy/policies_v2.h" #include "compression_api.h" #include "errors.h" #include "funcapi.h" #include "guc.h" #include "hypertable.h" #include "hypertable_cache.h" #include "jsonb_utils.h" #include "policy_utils.h" #include "utils.h" #if PG16_GE #include "nodes/miscnodes.h" #endif /* Check if the provided argument is infinity */ bool ts_if_offset_is_infinity(Datum arg, Oid argtype, bool is_start) { if (OidIsValid(argtype) && argtype != UNKNOWNOID && argtype != FLOAT8OID) return false; if (argtype != FLOAT8OID) { double val; char *num = DatumGetCString(arg); #if PG16_LT bool have_error = false; val = float8in_internal_opt_error(num, NULL, "double precision", num, &have_error); if (have_error) return false; #else ErrorSaveContext escontext = { .type = T_ErrorSaveContext }; val = float8in_internal(num, NULL, "double precision", num, (Node *) &escontext); if (escontext.error_occurred) return false; #endif arg = Float8GetDatum(val); } float8 result = DatumGetFloat8(arg); return ((result == -get_float8_infinity() && is_start) || (result == get_float8_infinity() && !is_start)); } static void emit_error(const char *err) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("%s", err))); } static int64 offset_to_int64(NullableDatum arg, Oid argtype, Oid partition_type, bool is_start) { if (arg.isnull || ts_if_offset_is_infinity(arg.value, argtype, is_start)) { if (is_start) return ts_time_get_max(partition_type); else return ts_time_get_min(partition_type); } else return interval_to_int64(arg.value, argtype); } /* * Check different conditions if the requested policy parameters * are compatible with each other and then create/update the * provided policies. */ bool validate_and_create_policies(policies_info all_policies, bool if_exists) { int refresh_job_id = 0, compression_job_id = 0, retention_job_id = 0; int64 refresh_interval = 0, compress_after = 0, drop_after = 0, drop_after_HT = 0; int64 start_offset = 0, end_offset = 0, refresh_total_interval = 0; List *jobs = NIL; BgwJob *orig_ht_reten_job = NULL; char *err_gap_refresh = "there are gaps in refresh policy"; char *err_refresh_compress_overlap = "refresh and columnstore policies overlap"; char *err_refresh_reten_overlap = "refresh and retention policies overlap"; char *err_refresh_reten_ht_overlap = "refresh policy of continuous aggregate and retention " "policy of underlying hypertable overlap"; char *err_compress_reten_overlap = "columnstore and retention policies overlap"; jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_RETENTION_PROC_NAME, FUNCTIONS_SCHEMA_NAME, all_policies.original_HT); if (jobs != NIL) { Assert(list_length(jobs) == 1); orig_ht_reten_job = linitial(jobs); } if (all_policies.refresh) { start_offset = offset_to_int64(all_policies.refresh->start_offset, all_policies.refresh->start_offset_type, all_policies.partition_type, true); end_offset = offset_to_int64(all_policies.refresh->end_offset, all_policies.refresh->end_offset_type, all_policies.partition_type, false); refresh_interval = interval_to_int64(IntervalPGetDatum(&all_policies.refresh->schedule_interval), INTERVALOID); refresh_total_interval = start_offset; if (!IS_INTEGER_TYPE(all_policies.partition_type) && refresh_total_interval != ts_time_get_max(all_policies.partition_type)) refresh_total_interval += refresh_interval; } if (all_policies.compress) compress_after = interval_to_int64(all_policies.compress->compress_after, all_policies.compress->compress_after_type); if (all_policies.retention) drop_after = interval_to_int64(all_policies.retention->drop_after, all_policies.retention->drop_after_type); if (orig_ht_reten_job) { if (IS_INTEGER_TYPE(all_policies.partition_type)) { bool found_drop_after = false; drop_after_HT = ts_jsonb_get_int64_field(orig_ht_reten_job->fd.config, POL_RETENTION_CONF_KEY_DROP_AFTER, &found_drop_after); } else { drop_after_HT = interval_to_int64( IntervalPGetDatum(ts_jsonb_get_interval_field(orig_ht_reten_job->fd.config, POL_RETENTION_CONF_KEY_DROP_AFTER)), INTERVALOID); } } /* Per policy checks */ if (all_policies.refresh && !IS_INTEGER_TYPE(all_policies.partition_type)) { /* * Check if there are any gaps in the refresh policy. The below code is * a little suspect. But since we are planning to do away with the * add_policies/remove_policies APIs there's no need to spend a lot * of time on fixing it below. */ int64 refresh_window_size; if (start_offset == ts_time_get_max(all_policies.partition_type) || end_offset == ts_time_get_min(all_policies.partition_type) || end_offset > start_offset || pg_sub_s64_overflow(start_offset, end_offset, &refresh_window_size)) refresh_window_size = start_offset; /* if refresh_interval is greater than half of refresh_window_size, then there are gaps */ if (refresh_interval > (refresh_window_size / 2)) emit_error(err_gap_refresh); /* Disallow refreshed data to be deleted */ if (orig_ht_reten_job) { if (refresh_total_interval > drop_after_HT) emit_error(err_refresh_reten_ht_overlap); } } /* Cross policy checks */ if (all_policies.refresh && all_policies.compress) { /* Check if refresh policy does not overlap with compression */ if (refresh_total_interval > compress_after) emit_error(err_refresh_compress_overlap); } if (all_policies.refresh && all_policies.retention) { /* Check if refresh policy does not overlap with retention */ if (refresh_total_interval > drop_after) emit_error(err_refresh_reten_overlap); } if (all_policies.retention && all_policies.compress) { /* Check if compression and retention policy overlap */ if (compress_after == drop_after) emit_error(err_compress_reten_overlap); } /* Create policies as required, delete the old ones if coming from alter */ if (all_policies.refresh && all_policies.refresh->create_policy) { NullableDatum include_tiered_data = { .isnull = true }; NullableDatum nbuckets_per_refresh = { .isnull = true }; NullableDatum max_batches_per_execution = { .isnull = true }; NullableDatum refresh_newest_first = { .isnull = true }; if (all_policies.is_alter_policy) policy_refresh_cagg_remove_internal(all_policies.rel_oid, if_exists); refresh_job_id = policy_refresh_cagg_add_internal(all_policies.rel_oid, all_policies.refresh->start_offset_type, all_policies.refresh->start_offset, all_policies.refresh->end_offset_type, all_policies.refresh->end_offset, all_policies.refresh->schedule_interval, false, false, DT_NOBEGIN, NULL, include_tiered_data, nbuckets_per_refresh, max_batches_per_execution, refresh_newest_first); } if (all_policies.compress && all_policies.compress->create_policy) { if (all_policies.is_alter_policy) policy_compression_remove_internal(all_policies.rel_oid, if_exists); compression_job_id = policy_compression_add_internal(all_policies.rel_oid, all_policies.compress->compress_after, all_policies.compress->compress_after_type, NULL, DEFAULT_COMPRESSION_SCHEDULE_INTERVAL, false, if_exists, false, DT_NOBEGIN, NULL); } if (all_policies.retention && all_policies.retention->create_policy) { if (all_policies.is_alter_policy) policy_retention_remove_internal(all_policies.rel_oid, if_exists); retention_job_id = policy_retention_add_internal(all_policies.rel_oid, all_policies.retention->drop_after_type, all_policies.retention->drop_after, NULL, (Interval) DEFAULT_RETENTION_SCHEDULE_INTERVAL, false, false, DT_NOBEGIN, NULL); } return (refresh_job_id || compression_job_id || retention_job_id); } Datum policies_add(PG_FUNCTION_ARGS) { Oid rel_oid; bool if_not_exists; ContinuousAgg *cagg; policies_info all_policies = { .refresh = NULL, .compress = NULL, .retention = NULL }; refresh_policy ref; compression_policy comp; retention_policy ret; ts_feature_flag_check(FEATURE_POLICY); rel_oid = PG_GETARG_OID(0); if_not_exists = PG_GETARG_BOOL(1); cagg = ts_continuous_agg_find_by_relid(rel_oid); if (!cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("\"%s\" is not a continuous aggregate", get_rel_name(rel_oid)))); all_policies.rel_oid = rel_oid; all_policies.is_alter_policy = false; all_policies.original_HT = cagg->data.raw_hypertable_id; all_policies.partition_type = cagg->partition_type; if (!PG_ARGISNULL(2) || !PG_ARGISNULL(3)) { NullableDatum start_offset, end_offset; Oid start_offset_type, end_offset_type; start_offset.isnull = PG_ARGISNULL(2); end_offset.isnull = PG_ARGISNULL(3); start_offset.value = PG_GETARG_DATUM(2); end_offset.value = PG_GETARG_DATUM(3); start_offset_type = get_fn_expr_argtype(fcinfo->flinfo, 2); end_offset_type = get_fn_expr_argtype(fcinfo->flinfo, 3); refresh_policy tmp = { .create_policy = true, .start_offset = start_offset, .end_offset = end_offset, .schedule_interval = *DEFAULT_REFRESH_SCHEDULE_INTERVAL, .start_offset_type = start_offset_type, .end_offset_type = end_offset_type, }; ref = tmp; all_policies.refresh = &ref; } if (!PG_ARGISNULL(4)) { compression_policy tmp = { .create_policy = true, .compress_after = PG_GETARG_DATUM(4), .compress_after_type = get_fn_expr_argtype(fcinfo->flinfo, 4), }; comp = tmp; all_policies.compress = ∁ } if (!PG_ARGISNULL(5)) { retention_policy tmp = { .create_policy = true, .drop_after = PG_GETARG_DATUM(5), .drop_after_type = get_fn_expr_argtype(fcinfo->flinfo, 5) }; ret = tmp; all_policies.retention = &ret; } PG_RETURN_BOOL(validate_and_create_policies(all_policies, if_not_exists)); } Datum policies_remove(PG_FUNCTION_ARGS) { Oid cagg_oid = PG_GETARG_OID(0); ArrayType *policy_array = PG_ARGISNULL(2) ? NULL : PG_GETARG_ARRAYTYPE_P(2); bool if_exists = PG_GETARG_BOOL(1); Datum *policy; int npolicies, failures = 0; int i; bool success = false; ts_feature_flag_check(FEATURE_POLICY); if (policy_array == NULL) PG_RETURN_BOOL(false); deconstruct_array(policy_array, TEXTOID, -1, false, TYPALIGN_INT, &policy, NULL, &npolicies); for (i = 0; i < npolicies; i++) { char *curr_policy = VARDATA(policy[i]); if (pg_strcasecmp(curr_policy, POLICY_REFRESH_CAGG_PROC_NAME) == 0) success = policy_refresh_cagg_remove_internal(cagg_oid, if_exists); else if (pg_strcasecmp(curr_policy, POLICY_COMPRESSION_PROC_NAME) == 0) success = policy_compression_remove_internal(cagg_oid, if_exists); else if (pg_strncasecmp(curr_policy, POLICY_RETENTION_PROC_NAME, strlen(POLICY_RETENTION_PROC_NAME)) == 0) success = policy_retention_remove_internal(cagg_oid, if_exists); else ereport(NOTICE, (errmsg("No relevant policy found"))); if (!success) ++failures; } PG_RETURN_BOOL(success && (0 == failures)); } Datum policies_remove_all(PG_FUNCTION_ARGS) { if (PG_ARGISNULL(0)) PG_RETURN_BOOL(false); Oid cagg_oid = PG_GETARG_OID(0); bool if_exists = PG_GETARG_BOOL(1); List *jobs; ListCell *lc; bool success = if_exists; int failures = 0; ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(cagg_oid); ts_feature_flag_check(FEATURE_POLICY); if (!cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("\"%s\" is not a continuous aggregate", get_rel_name(cagg_oid)))); jobs = ts_bgw_job_find_by_hypertable_id(cagg->data.mat_hypertable_id); foreach (lc, jobs) { BgwJob *job = lfirst(lc); if (namestrcmp(&(job->fd.proc_name), POLICY_REFRESH_CAGG_PROC_NAME) == 0) success = policy_refresh_cagg_remove_internal(cagg_oid, if_exists); else if (namestrcmp(&(job->fd.proc_name), POLICY_COMPRESSION_PROC_NAME) == 0) success = policy_compression_remove_internal(cagg_oid, if_exists); else if (namestrcmp(&(job->fd.proc_name), POLICY_RETENTION_PROC_NAME) == 0) success = policy_retention_remove_internal(cagg_oid, if_exists); else ereport(NOTICE, (errmsg("Ignoring custom job"))); if (!success) ++failures; } PG_RETURN_BOOL(success && (0 == failures)); } Datum policies_alter(PG_FUNCTION_ARGS) { Oid rel_oid = PG_GETARG_OID(0); ContinuousAgg *cagg; List *jobs; ListCell *lc; bool if_exists = false, found, start_found, end_found; policies_info all_policies = { .refresh = NULL, .compress = NULL, .retention = NULL }; refresh_policy ref; compression_policy comp; retention_policy ret; ts_feature_flag_check(FEATURE_POLICY); cagg = ts_continuous_agg_find_by_relid(rel_oid); if (!cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("\"%s\" is not a continuous aggregate", get_rel_name(rel_oid)))); all_policies.is_alter_policy = true; all_policies.rel_oid = rel_oid; all_policies.original_HT = cagg->data.raw_hypertable_id; all_policies.partition_type = cagg->partition_type; jobs = ts_bgw_job_find_by_hypertable_id(cagg->data.mat_hypertable_id); if ((NIL == jobs)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no jobs found"))); foreach (lc, jobs) { BgwJob *job = lfirst(lc); if (namestrcmp(&(job->fd.proc_name), POLICY_REFRESH_CAGG_PROC_NAME) == 0) { refresh_policy tmp = { .create_policy = false, .end_offset = { 0 }, .end_offset_type = InvalidOid, .start_offset = { 0 }, .start_offset_type = InvalidOid, .schedule_interval = job->fd.schedule_interval }; ref = tmp; all_policies.refresh = &ref; if (IS_INTEGER_TYPE(cagg->partition_type)) { int64 start_value = ts_jsonb_get_int64_field(job->fd.config, POL_REFRESH_CONF_KEY_START_OFFSET, &start_found); int64 end_value = ts_jsonb_get_int64_field(job->fd.config, POL_REFRESH_CONF_KEY_END_OFFSET, &end_found); /* * If there is job then start_offset has to be there because policy is * not created without it. However if found it to be NULL, then we * want to keep it to NULL in this alter command also. */ all_policies.refresh->start_offset.isnull = !start_found; all_policies.refresh->start_offset_type = cagg->partition_type; all_policies.refresh->end_offset.isnull = !end_found; all_policies.refresh->end_offset_type = cagg->partition_type; switch (all_policies.refresh->start_offset_type) { case INT2OID: all_policies.refresh->start_offset.value = Int16GetDatum((int16) start_value); all_policies.refresh->end_offset.value = Int16GetDatum((int16) end_value); break; case INT4OID: all_policies.refresh->start_offset.value = Int32GetDatum((int32) start_value); all_policies.refresh->end_offset.value = Int32GetDatum((int32) end_value); break; case INT8OID: all_policies.refresh->start_offset.value = Int64GetDatum(start_value); all_policies.refresh->end_offset.value = Int64GetDatum(end_value); break; default: Assert(0); } } else { all_policies.refresh->start_offset.value = IntervalPGetDatum( ts_jsonb_get_interval_field(job->fd.config, POL_REFRESH_CONF_KEY_START_OFFSET)); all_policies.refresh->start_offset.isnull = (DatumGetIntervalP(all_policies.refresh->start_offset.value) == NULL); all_policies.refresh->start_offset_type = INTERVALOID; all_policies.refresh->end_offset.value = IntervalPGetDatum( ts_jsonb_get_interval_field(job->fd.config, POL_REFRESH_CONF_KEY_END_OFFSET)); all_policies.refresh->end_offset.isnull = (DatumGetIntervalP(all_policies.refresh->end_offset.value) == NULL); all_policies.refresh->end_offset_type = INTERVALOID; } } else if (namestrcmp(&(job->fd.proc_name), POLICY_COMPRESSION_PROC_NAME) == 0) { compression_policy tmp = { .compress_after = 0, .compress_after_type = InvalidOid, .create_policy = false }; comp = tmp; all_policies.compress = ∁ if (IS_INTEGER_TYPE(cagg->partition_type)) { int64 compress_value = ts_jsonb_get_int64_field(job->fd.config, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, &found); all_policies.compress->compress_after_type = cagg->partition_type; switch (all_policies.compress->compress_after_type) { case INT2OID: all_policies.compress->compress_after = Int16GetDatum((int16) compress_value); break; case INT4OID: all_policies.compress->compress_after = Int32GetDatum((int32) compress_value); break; case INT8OID: all_policies.compress->compress_after = Int64GetDatum(compress_value); break; default: Assert(0); } } else { all_policies.compress->compress_after = IntervalPGetDatum( ts_jsonb_get_interval_field(job->fd.config, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER)); all_policies.compress->compress_after_type = INTERVALOID; } } else if (namestrcmp(&(job->fd.proc_name), POLICY_RETENTION_PROC_NAME) == 0) { retention_policy tmp = { .create_policy = false, .drop_after = 0, .drop_after_type = InvalidOid }; ret = tmp; all_policies.retention = &ret; if (IS_INTEGER_TYPE(cagg->partition_type)) { int64 drop_value = ts_jsonb_get_int64_field(job->fd.config, POL_RETENTION_CONF_KEY_DROP_AFTER, &found); all_policies.retention->drop_after_type = cagg->partition_type; switch (all_policies.retention->drop_after_type) { case INT2OID: all_policies.retention->drop_after = Int16GetDatum((int16) drop_value); break; case INT4OID: all_policies.retention->drop_after = Int32GetDatum((int32) drop_value); break; case INT8OID: all_policies.retention->drop_after = Int64GetDatum(drop_value); break; default: Assert(0); } } else { all_policies.retention->drop_after = IntervalPGetDatum( ts_jsonb_get_interval_field(job->fd.config, POL_RETENTION_CONF_KEY_DROP_AFTER)); all_policies.retention->drop_after_type = INTERVALOID; } } } if (!PG_ARGISNULL(2)) { if (!all_policies.refresh) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no refresh job found"))); all_policies.refresh->start_offset.value = PG_GETARG_DATUM(2); all_policies.refresh->start_offset_type = get_fn_expr_argtype(fcinfo->flinfo, 2); all_policies.refresh->start_offset.isnull = false; all_policies.refresh->create_policy = true; } if (!PG_ARGISNULL(3)) { if (!all_policies.refresh) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no refresh job found"))); all_policies.refresh->end_offset.value = PG_GETARG_DATUM(3); all_policies.refresh->end_offset_type = get_fn_expr_argtype(fcinfo->flinfo, 3); all_policies.refresh->end_offset.isnull = false; all_policies.refresh->create_policy = true; } if (!PG_ARGISNULL(4)) { if (!all_policies.compress) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no compress job found"))); all_policies.compress->compress_after = PG_GETARG_DATUM(4); all_policies.compress->compress_after_type = get_fn_expr_argtype(fcinfo->flinfo, 4); all_policies.compress->create_policy = true; } if (!PG_ARGISNULL(5)) { if (!all_policies.retention) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no retention job found"))); all_policies.retention->drop_after = PG_GETARG_DATUM(5); all_policies.retention->drop_after_type = get_fn_expr_argtype(fcinfo->flinfo, 5); all_policies.retention->create_policy = true; } PG_RETURN_BOOL(validate_and_create_policies(all_policies, if_exists)); } static void push_to_json(Oid type, JsonbParseState *parse_state, BgwJob *job, char *json_label, char *show_config) { if (IS_INTEGER_TYPE(type)) { bool found; int64 value = ts_jsonb_get_int64_field(job->fd.config, json_label, &found); if (!found) ts_jsonb_add_null(parse_state, show_config); else ts_jsonb_add_int64(parse_state, show_config, value); } else { Interval *value = ts_jsonb_get_interval_field(job->fd.config, json_label); if (value == NULL) ts_jsonb_add_null(parse_state, show_config); else ts_jsonb_add_interval(parse_state, show_config, value); } } Datum policies_show(PG_FUNCTION_ARGS) { Oid rel_oid = PG_GETARG_OID(0); Oid type; ContinuousAgg *cagg; ListCell *lc; FuncCallContext *funcctx; static List *jobs; JsonbParseState *parse_state = NULL; ts_feature_flag_check(FEATURE_POLICY); cagg = ts_continuous_agg_find_by_relid(rel_oid); if (!cagg) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("\"%s\" is not a continuous aggregate", get_rel_name(rel_oid)))); type = IS_TIMESTAMP_TYPE(cagg->partition_type) ? INTERVALOID : cagg->partition_type; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); /* Use top-level memory context to preserve the global static list */ jobs = ts_bgw_job_find_by_hypertable_id(cagg->data.mat_hypertable_id); funcctx->user_fctx = list_head(jobs); MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); lc = (ListCell *) funcctx->user_fctx; /* * clang doesn't understand that jobs won't be NIL due to the above FIRSTCALL. However * it's also possible that the ts_bgw_job_find_by_hypertable_id function above doesn't * find a job for this hypertable */ if (lc == NULL || jobs == NULL) SRF_RETURN_DONE(funcctx); else { BgwJob *job = lfirst(lc); if (!namestrcmp(&(job->fd.proc_name), POLICY_REFRESH_CAGG_PROC_NAME)) { ts_jsonb_add_str(parse_state, SHOW_POLICY_KEY_POLICY_NAME, POLICY_REFRESH_CAGG_PROC_NAME); push_to_json(type, parse_state, job, POL_REFRESH_CONF_KEY_START_OFFSET, SHOW_POLICY_KEY_REFRESH_START_OFFSET); push_to_json(type, parse_state, job, POL_REFRESH_CONF_KEY_END_OFFSET, SHOW_POLICY_KEY_REFRESH_END_OFFSET); ts_jsonb_add_interval(parse_state, SHOW_POLICY_KEY_REFRESH_INTERVAL, &(job->fd.schedule_interval)); } else if (!namestrcmp(&(job->fd.proc_name), POLICY_COMPRESSION_PROC_NAME)) { ts_jsonb_add_str(parse_state, SHOW_POLICY_KEY_POLICY_NAME, POLICY_COMPRESSION_PROC_NAME); push_to_json(type, parse_state, job, POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER, SHOW_POLICY_KEY_COMPRESS_AFTER); /* POL_COMPRESSION_CONF_KEY_COMPRESS_CREATED_BEFORE not supported with caggs */ ts_jsonb_add_interval(parse_state, SHOW_POLICY_KEY_COMPRESS_INTERVAL, &(job->fd.schedule_interval)); } else if (!namestrcmp(&(job->fd.proc_name), POLICY_RETENTION_PROC_NAME)) { ts_jsonb_add_str(parse_state, SHOW_POLICY_KEY_POLICY_NAME, POLICY_RETENTION_PROC_NAME); push_to_json(type, parse_state, job, POL_RETENTION_CONF_KEY_DROP_AFTER, SHOW_POLICY_KEY_DROP_AFTER); /* POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE not supported with caggs */ ts_jsonb_add_interval(parse_state, SHOW_POLICY_KEY_RETENTION_INTERVAL, &(job->fd.schedule_interval)); } else ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("\"%s\" unsupported proc", NameStr(job->fd.proc_name)))); JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); funcctx->user_fctx = lnext(jobs, (ListCell *) funcctx->user_fctx); SRF_RETURN_NEXT(funcctx, PointerGetDatum(JsonbValueToJsonb(result))); } PG_RETURN_NULL(); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/policies_v2.h�������������������������������������������������0000664�0000000�0000000�00000011161�15100345067�0022171�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "compression/api.h" #include "dimension.h" #include <bgw_policy/compression_api.h> #include <bgw_policy/continuous_aggregate_api.h> #include <bgw_policy/retention_api.h> #include <continuous_aggs/materialize.h> #include <utils/jsonb.h> #define POLICY_REFRESH_CAGG_PROC_NAME "policy_refresh_continuous_aggregate" #define POLICY_REFRESH_CAGG_CHECK_NAME "policy_refresh_continuous_aggregate_check" #define POL_REFRESH_CONF_KEY_MAT_HYPERTABLE_ID "mat_hypertable_id" #define POL_REFRESH_CONF_KEY_START_OFFSET "start_offset" #define POL_REFRESH_CONF_KEY_END_OFFSET "end_offset" #define POL_REFRESH_CONF_KEY_INCLUDE_TIERED_DATA "include_tiered_data" #define POL_REFRESH_CONF_KEY_BUCKETS_PER_BATCH "buckets_per_batch" #define POL_REFRESH_CONF_KEY_MAX_BATCHES_PER_EXECUTION "max_batches_per_execution" #define POL_REFRESH_CONF_KEY_REFRESH_NEWEST_FIRST "refresh_newest_first" #define POL_REFRESH_CONF_KEY_PROCESS_HYPERTABLE_INVALIDATIONS "process_hypertable_invalidations" #define POLICY_COMPRESSION_PROC_NAME "policy_compression" #define POLICY_COMPRESSION_CHECK_NAME "policy_compression_check" #define POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER "compress_after" #define POL_COMPRESSION_CONF_KEY_MAXCHUNKS_TO_COMPRESS "maxchunks_to_compress" #define POL_COMPRESSION_CONF_KEY_COMPRESS_CREATED_BEFORE "compress_created_before" #define POLICY_RECOMPRESSION_PROC_NAME "policy_recompression" #define POL_RECOMPRESSION_CONF_KEY_RECOMPRESS_AFTER "recompress_after" #define POLICY_RETENTION_PROC_NAME "policy_retention" #define POLICY_RETENTION_CHECK_NAME "policy_retention_check" #define POL_RETENTION_CONF_KEY_DROP_AFTER "drop_after" #define POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE "drop_created_before" #define SHOW_POLICY_KEY_POLICY_NAME "policy_name" #define SHOW_POLICY_KEY_REFRESH_INTERVAL "refresh_interval" #define SHOW_POLICY_KEY_REFRESH_START_OFFSET "refresh_start_offset" #define SHOW_POLICY_KEY_REFRESH_END_OFFSET "refresh_end_offset" #define SHOW_POLICY_KEY_COMPRESS_AFTER POL_COMPRESSION_CONF_KEY_COMPRESS_AFTER #define SHOW_POLICY_KEY_COMPRESS_CREATED_BEFORE POL_COMPRESSION_CONF_KEY_COMPRESS_CREATED_BEFORE #define SHOW_POLICY_KEY_COMPRESS_INTERVAL "compress_interval" #define SHOW_POLICY_KEY_DROP_AFTER POL_RETENTION_CONF_KEY_DROP_AFTER #define SHOW_POLICY_KEY_DROP_CREATED_BEFORE POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE #define SHOW_POLICY_KEY_RETENTION_INTERVAL "retention_interval" #define DEFAULT_RETENTION_SCHEDULE_INTERVAL \ { \ .day = 1 \ } /* * Default scheduled interval for compress jobs = default chunk length. * If this is non-timestamp based hypertable, then default is 1 day */ #define DEFAULT_COMPRESSION_SCHEDULE_INTERVAL \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("1 day"), InvalidOid, -1)) #define DEFAULT_REFRESH_SCHEDULE_INTERVAL \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("1 hour"), InvalidOid, -1)) extern Datum policies_add(PG_FUNCTION_ARGS); extern Datum policies_remove(PG_FUNCTION_ARGS); extern Datum policies_remove_all(PG_FUNCTION_ARGS); extern Datum policies_alter(PG_FUNCTION_ARGS); extern Datum policies_show(PG_FUNCTION_ARGS); typedef struct CaggPolicyConfig { Oid partition_type; ContinuousAggPolicyOffset offset_start; ContinuousAggPolicyOffset offset_end; } CaggPolicyConfig; typedef struct refresh_policy { Interval schedule_interval; NullableDatum start_offset; NullableDatum end_offset; Oid start_offset_type, end_offset_type; bool create_policy; } refresh_policy; typedef struct compression_policy { Datum compress_after; Oid compress_after_type; bool create_policy; } compression_policy; typedef struct retention_policy { Datum drop_after; Oid drop_after_type; bool create_policy; } retention_policy; typedef struct policies_info { Oid rel_oid; Oid original_HT; Oid partition_type; refresh_policy *refresh; compression_policy *compress; retention_policy *retention; bool is_alter_policy; } policies_info; bool ts_if_offset_is_infinity(Datum arg, Oid argtype, bool is_start); bool validate_and_create_policies(policies_info all_policies, bool if_exists); int64 interval_to_int64(Datum interval, Oid type); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/policy_config.c�����������������������������������������������0000664�0000000�0000000�00000005672�15100345067�0022604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Module with common functions, variables, and constants for working with * policy configurations. */ #include <postgres.h> #include "jsonb_utils.h" #include "policies_v2.h" #include "policy_config.h" int32 policy_config_get_hypertable_id(const Jsonb *config) { bool found; int32 hypertable_id = ts_jsonb_get_int32_field(config, POLICY_CONFIG_KEY_HYPERTABLE_ID, &found); if (!found) ereport(ERROR, (errcode(ERRCODE_SQL_JSON_MEMBER_NOT_FOUND), errmsg("could not find hypertable_id in config for job"))); return hypertable_id; } /* Helper function to compare jsonb label value in the config * with passed in value. * This function is used for labels defined on the hypertable's dimension * Parameters: * config - jsonb config value * label - label we are looking for inside the config * partitioning_type - Oid for hypertable's dimension column * lag_value - value we will compare against the config's * value for the label * lag_type - Oid for lag_value * Returns: * True, if config value is equal to lag_value */ bool policy_config_check_hypertable_lag_equality(Jsonb *config, const char *json_label, Oid partitioning_type, Oid lag_type, Datum lag_datum, bool isnull) { /* * start_offset and end_offset for CAgg policies are allowed to have NULL values * In that case, config_value will be NULL but this is not an error */ bool null_ok = (strcmp(json_label, POL_REFRESH_CONF_KEY_END_OFFSET) == 0 || strcmp(json_label, POL_REFRESH_CONF_KEY_START_OFFSET) == 0); if (IS_INTEGER_TYPE(partitioning_type) && lag_type != INTERVALOID) { bool found; int64 config_value = ts_jsonb_get_int64_field(config, json_label, &found); if (!found && !null_ok) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for existing job", json_label))); if (!found && isnull) return true; if ((!found && !isnull) || (found && isnull)) return false; switch (lag_type) { case INT2OID: return config_value == DatumGetInt16(lag_datum); case INT4OID: return config_value == DatumGetInt32(lag_datum); case INT8OID: return config_value == DatumGetInt64(lag_datum); default: return false; } } else { if (lag_type != INTERVALOID) return false; Interval *config_value = ts_jsonb_get_interval_field(config, json_label); if (config_value == NULL && !null_ok) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for job", json_label))); if (config_value == NULL && isnull) return true; if ((config_value == NULL && !isnull) || (config_value != NULL && isnull)) return false; return DatumGetBool( DirectFunctionCall2(interval_eq, IntervalPGetDatum(config_value), lag_datum)); } } ����������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/policy_config.h�����������������������������������������������0000664�0000000�0000000�00000001231�15100345067�0022574�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * Common functions, variables, and constants for working with policy * configurations. */ #include <postgres.h> #include <utils/jsonb.h> #define POLICY_CONFIG_KEY_HYPERTABLE_ID "hypertable_id" extern int32 policy_config_get_hypertable_id(const Jsonb *config); extern bool policy_config_check_hypertable_lag_equality(Jsonb *config, const char *json_label, Oid partitioning_type, Oid lag_type, Datum lag_datum, bool isnull); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/policy_utils.c������������������������������������������������0000664�0000000�0000000�00000005045�15100345067�0022471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "policy_utils.h" #include "dimension.h" #include "errors.h" #include "guc.h" #include "hypertable.h" #include "jsonb_utils.h" #include "policies_v2.h" #include "time_utils.h" #include "ts_catalog/continuous_agg.h" #include <utils/builtins.h> Datum subtract_interval_from_now(Interval *lag, Oid time_dim_type) { #ifdef TS_DEBUG Datum res = ts_get_mock_time_or_current_time(); #else Datum res = TimestampTzGetDatum(GetCurrentTransactionStartTimestamp()); #endif switch (time_dim_type) { case TIMESTAMPOID: res = DirectFunctionCall1(timestamptz_timestamp, res); res = DirectFunctionCall2(timestamp_mi_interval, res, IntervalPGetDatum(lag)); return res; case TIMESTAMPTZOID: res = DirectFunctionCall2(timestamptz_mi_interval, res, IntervalPGetDatum(lag)); return res; case DATEOID: res = DirectFunctionCall1(timestamptz_timestamp, res); res = DirectFunctionCall2(timestamp_mi_interval, res, IntervalPGetDatum(lag)); res = DirectFunctionCall1(timestamp_date, res); return res; default: /* this should never happen as otherwise hypertable has unsupported time type */ ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unsupported time type %s", format_type_be(time_dim_type)))); pg_unreachable(); } } const Dimension * get_open_dimension_for_hypertable(const Hypertable *ht, bool fail_if_not_found) { int32 mat_id = ht->fd.id; if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) elog(ERROR, "invalid operation on compressed hypertable"); const Dimension *open_dim = hyperspace_get_open_dimension(ht->space, 0); Oid partitioning_type = ts_dimension_get_partition_type(open_dim); if (IS_INTEGER_TYPE(partitioning_type)) { /* if this a materialization hypertable related to cont agg * then need to get the right dimension which has * integer_now function */ open_dim = ts_continuous_agg_find_integer_now_func_by_materialization_id(mat_id); if (open_dim == NULL && fail_if_not_found) { ereport(ERROR, (errcode(ERRCODE_TS_UNEXPECTED), errmsg("missing integer_now function for hypertable \"%s\" ", get_rel_name(ht->main_table_relid)))); } } return open_dim; } bool policy_get_verbose_log(const Jsonb *config) { bool found; bool verbose_log = ts_jsonb_get_bool_field(config, CONFIG_KEY_VERBOSE_LOG, &found); return found ? verbose_log : false; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/policy_utils.h������������������������������������������������0000664�0000000�0000000�00000001103�15100345067�0022465�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "job.h" int64 subtract_integer_from_now_internal(int64 interval, Oid time_dim_type, Oid now_func, bool *overflow); Datum subtract_interval_from_now(Interval *lag, Oid time_dim_type); const Dimension *get_open_dimension_for_hypertable(const Hypertable *ht, bool fail_if_not_found); bool policy_get_verbose_log(const Jsonb *config); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/process_hyper_inval_api.c�������������������������������������0000664�0000000�0000000�00000014370�15100345067�0024662�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "process_hyper_inval_api.h" #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/timer.h" #include "bgw_policy/job.h" #include "bgw_policy/job_api.h" #include "guc.h" #include "hypertable.h" #include "jsonb_utils.h" #include "policy_config.h" #include <utils/elog.h> #define DEFAULT_MAX_RUNTIME \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("0"), InvalidOid, -1)) Datum policy_process_hyper_inval_proc(PG_FUNCTION_ARGS) { if (PG_NARGS() != 2 || PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_VOID(); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); policy_process_hyper_inval_execute(PG_GETARG_INT32(0), PG_GETARG_JSONB_P(1)); PG_RETURN_VOID(); } Datum policy_process_hyper_inval_check(PG_FUNCTION_ARGS) { if (PG_ARGISNULL(0)) { ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("config must not be NULL"))); } policy_process_hyper_inval_read_and_validate_config(PG_GETARG_JSONB_P(0), NULL); PG_RETURN_VOID(); } static int32 policy_process_hyper_inval_add_internal(Hypertable *ht, bool if_not_exists, Interval *schedule_interval, Oid owner_id, TimestampTz initial_start, const bool fixed_schedule, char *timezone) { NameData application_name, proc_name, proc_schema, check_schema, check_name, owner; List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_PROCESS_HYPER_INVAL_PROC_NAME, FUNCTIONS_SCHEMA_NAME, ht->fd.id); if (jobs != NIL) { Assert(list_length(jobs) == 1); if (!if_not_exists) ereport(ERROR, errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("move hypertable invalidations policy already exists for \"%s\"", get_rel_name(ht->main_table_relid))); else ereport(NOTICE, errmsg("move hypertable invalidations policy already exists for \"%s\", " "skipping", get_rel_name(ht->main_table_relid))); return -1; } namestrcpy(&application_name, "Move Hypertables Invalidation Policy"); namestrcpy(&proc_name, POLICY_PROCESS_HYPER_INVAL_PROC_NAME); namestrcpy(&proc_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&check_name, POLICY_PROCESS_HYPER_INVAL_CHECK_NAME); namestrcpy(&check_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&owner, GetUserNameFromId(owner_id, false)); JsonbParseState *parse_state = NULL; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int32(parse_state, POLICY_CONFIG_KEY_HYPERTABLE_ID, ht->fd.id); JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); Jsonb *config = JsonbValueToJsonb(result); return ts_bgw_job_insert_relation(&application_name, schedule_interval, DEFAULT_MAX_RUNTIME, JOB_RETRY_UNLIMITED, schedule_interval, &proc_schema, &proc_name, &check_schema, &check_name, owner_id, true, fixed_schedule, ht->fd.id, config, initial_start, timezone); } Datum policy_process_hyper_inval_add(PG_FUNCTION_ARGS) { Oid ht_oid = PG_GETARG_OID(0); Interval *schedule_interval = PG_GETARG_INTERVAL_P(1); const bool if_not_exists = PG_GETARG_BOOL(2); TimestampTz initial_start = PG_ARGISNULL(3) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(3); const bool fixed_schedule = !PG_ARGISNULL(3); char *valid_timezone = NULL; ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); if (fixed_schedule) { ts_bgw_job_validate_schedule_interval(schedule_interval); if (TIMESTAMP_NOT_FINITE(initial_start)) initial_start = ts_timer_get_current_timestamp(); } if (!PG_ARGISNULL(4)) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(4)); Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(ht_oid, CACHE_FLAG_NONE, &hcache); /* Check that we have a continuous aggregate attached */ List *caggs = ts_continuous_aggs_find_by_raw_table_id(ht->fd.id); if (list_length(caggs) == 0) ereport(ERROR, errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("\"%s\" does not have an associated continuous aggregate", get_rel_name(ht_oid))); Oid owner_id = ts_hypertable_permissions_check(ht_oid, GetUserId()); ts_bgw_job_validate_job_owner(owner_id); int32 job_id = policy_process_hyper_inval_add_internal(ht, if_not_exists, schedule_interval, owner_id, initial_start, fixed_schedule, valid_timezone); ts_cache_release(&hcache); if (!TIMESTAMP_NOT_FINITE(initial_start)) ts_bgw_job_stat_upsert_next_start(job_id, initial_start); PG_RETURN_INT32(job_id); } static void policy_process_hyper_inval_remove_internal(Oid ht_oid, bool if_exists) { Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(ht_oid, CACHE_FLAG_NONE, &hcache); if (!ht) ereport(ERROR, errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("\"%s\" is not a hypertable", get_rel_name(ht_oid))); /* Check permissions */ Oid owner_id = ts_hypertable_permissions_check(ht_oid, GetUserId()); ts_bgw_job_validate_job_owner(owner_id); /* Find jobs */ List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_PROCESS_HYPER_INVAL_PROC_NAME, FUNCTIONS_SCHEMA_NAME, ht->fd.id); if (!jobs && !if_exists) ereport(ERROR, errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("move invalidations policy for \"%s\" not found", get_rel_name(ht_oid))); if (!jobs && if_exists) { ereport(NOTICE, errmsg("move invalidations policy for \"%s\" not found, skipping", get_rel_name(ht_oid))); ts_cache_release(&hcache); return; } Assert(list_length(jobs) == 1); BgwJob *job = linitial(jobs); /* Delete all jobs, not just the first one? */ ts_bgw_job_delete_by_id(job->fd.id); ts_cache_release(&hcache); } Datum policy_process_hyper_inval_remove(PG_FUNCTION_ARGS) { ts_feature_flag_check(FEATURE_POLICY); policy_process_hyper_inval_remove_internal(PG_GETARG_OID(0), PG_GETARG_BOOL(1)); PG_RETURN_VOID(); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/process_hyper_inval_api.h�������������������������������������0000664�0000000�0000000�00000001256�15100345067�0024666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #define POLICY_PROCESS_HYPER_INVAL_PROC_NAME "policy_process_hypertable_invalidations" #define POLICY_PROCESS_HYPER_INVAL_CHECK_NAME "policy_process_hypertable_invalidations_check" extern Datum policy_process_hyper_inval_add(PG_FUNCTION_ARGS); extern Datum policy_process_hyper_inval_proc(PG_FUNCTION_ARGS); extern Datum policy_process_hyper_inval_check(PG_FUNCTION_ARGS); extern Datum policy_process_hyper_inval_remove(PG_FUNCTION_ARGS); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/reorder_api.c�������������������������������������������������0000664�0000000�0000000�00000023276�15100345067�0022253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <catalog/namespace.h> #include <catalog/pg_collation.h> #include <catalog/pg_type.h> #include <miscadmin.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include <compat/compat.h> #include <dimension.h> #include <hypertable_cache.h> #include <jsonb_utils.h> #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/timer.h" #include "bgw_policy/job.h" #include "bgw_policy/job_api.h" #include "bgw_policy/policy_config.h" #include "bgw_policy/reorder_api.h" #include "guc.h" #include "hypertable.h" #include "utils.h" /* * Default scheduled interval for reorder jobs should be 1/2 of the default chunk length. * If no such length is specified for the hypertable, then * the default is 4 days, which is approximately 1/2 of the default chunk size, 7 days. */ #define DEFAULT_SCHEDULE_INTERVAL \ { \ .day = 4 \ } /* Default max runtime for a reorder job is unlimited for now */ #define DEFAULT_MAX_RUNTIME \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("0"), InvalidOid, -1)) /* Default retry period for reorder_jobs is currently 5 minutes */ #define DEFAULT_RETRY_PERIOD \ DatumGetIntervalP(DirectFunctionCall3(interval_in, CStringGetDatum("5 min"), InvalidOid, -1)) #define CONFIG_KEY_INDEX_NAME "index_name" #define POLICY_REORDER_PROC_NAME "policy_reorder" #define POLICY_REORDER_CHECK_NAME "policy_reorder_check" char * policy_reorder_get_index_name(const Jsonb *config) { char *index_name = NULL; if (config != NULL) index_name = ts_jsonb_get_str_field(config, CONFIG_KEY_INDEX_NAME); if (index_name == NULL) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find index_name in config for job"))); return index_name; } static void check_valid_index(Hypertable *ht, Name index_name) { Oid index_oid; HeapTuple idxtuple; Form_pg_index indexForm; index_oid = ts_get_relation_relid(NameStr(ht->fd.schema_name), NameStr(*index_name), true); idxtuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid)); if (!HeapTupleIsValid(idxtuple)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid reorder index"))); indexForm = (Form_pg_index) GETSTRUCT(idxtuple); if (indexForm->indrelid != ht->main_table_relid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid reorder index"), errhint("The reorder index must by an index on hypertable \"%s\".", NameStr(ht->fd.table_name)))); ReleaseSysCache(idxtuple); } Datum policy_reorder_check(PG_FUNCTION_ARGS) { TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_ARGISNULL(0)) { ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("config must not be NULL"))); } policy_reorder_read_and_validate_config(PG_GETARG_JSONB_P(0), NULL); PG_RETURN_VOID(); } Datum policy_reorder_proc(PG_FUNCTION_ARGS) { if (PG_NARGS() != 2 || PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_VOID(); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); policy_reorder_execute(PG_GETARG_INT32(0), PG_GETARG_JSONB_P(1)); PG_RETURN_VOID(); } Datum policy_reorder_add(PG_FUNCTION_ARGS) { /* behave like a strict function */ if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); NameData application_name; NameData proc_name, proc_schema, check_name, check_schema, owner; int32 job_id; const Dimension *dim; Interval schedule_interval = DEFAULT_SCHEDULE_INTERVAL; Oid ht_oid = PG_GETARG_OID(0); Name index_name = PG_GETARG_NAME(1); bool if_not_exists = PG_GETARG_BOOL(2); Cache *hcache; Hypertable *ht; int32 hypertable_id; Oid partitioning_type; Oid owner_id; List *jobs; TimestampTz initial_start = PG_ARGISNULL(3) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(3); bool fixed_schedule = !PG_ARGISNULL(3); text *timezone = PG_ARGISNULL(4) ? NULL : PG_GETARG_TEXT_PP(4); char *valid_timezone = NULL; ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); if (timezone != NULL) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(4)); ht = ts_hypertable_cache_get_cache_and_entry(ht_oid, CACHE_FLAG_NONE, &hcache); Assert(ht != NULL); hypertable_id = ht->fd.id; /* First verify that the hypertable corresponds to a valid table */ owner_id = ts_hypertable_permissions_check(ht_oid, GetUserId()); if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add reorder policy to compressed hypertable \"%s\"", get_rel_name(ht_oid)), errhint("Please add the policy to the corresponding uncompressed hypertable " "instead."))); /* Now verify that the index is an actual index on that hypertable */ check_valid_index(ht, index_name); /* Verify that the hypertable owner can create a background worker */ ts_bgw_job_validate_job_owner(owner_id); /* Make sure that an existing reorder policy doesn't exist on this hypertable */ jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_REORDER_PROC_NAME, FUNCTIONS_SCHEMA_NAME, ht->fd.id); /* * Try to see if the hypertable has a specified chunk length for the * default schedule interval */ dim = hyperspace_get_open_dimension(ht->space, 0); Assert(dim); partitioning_type = ts_dimension_get_partition_type(dim); if (IS_TIMESTAMP_TYPE(partitioning_type)) { schedule_interval.time = dim->fd.interval_length / 2; schedule_interval.day = 0; schedule_interval.month = 0; } ts_cache_release(&hcache); if (jobs != NIL) { BgwJob *existing = linitial(jobs); Assert(list_length(jobs) == 1); if (!if_not_exists) ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("reorder policy already exists for hypertable \"%s\"", get_rel_name(ht_oid)))); if (!DatumGetBool(DirectFunctionCall2Coll(nameeq, C_COLLATION_OID, CStringGetDatum(policy_reorder_get_index_name( existing->fd.config)), NameGetDatum(index_name)))) { ereport(WARNING, (errmsg("reorder policy already exists for hypertable \"%s\"", get_rel_name(ht_oid)), errdetail("A policy already exists with different arguments."), errhint("Remove the existing policy before adding a new one."))); PG_RETURN_INT32(-1); } /* If all arguments are the same, do nothing */ ereport(NOTICE, (errmsg("reorder policy already exists on hypertable \"%s\", skipping", get_rel_name(ht_oid)))); PG_RETURN_INT32(-1); } /* if users pass in -infinity for initial_start, then use the current_timestamp instead */ if (fixed_schedule) { ts_bgw_job_validate_schedule_interval(&schedule_interval); if (TIMESTAMP_NOT_FINITE(initial_start)) initial_start = ts_timer_get_current_timestamp(); } /* Next, insert a new job into jobs table */ namestrcpy(&application_name, "Reorder Policy"); namestrcpy(&proc_name, POLICY_REORDER_PROC_NAME); namestrcpy(&proc_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&check_name, POLICY_REORDER_CHECK_NAME); namestrcpy(&check_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&owner, GetUserNameFromId(owner_id, false)); JsonbParseState *parse_state = NULL; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int32(parse_state, POLICY_CONFIG_KEY_HYPERTABLE_ID, hypertable_id); ts_jsonb_add_str(parse_state, CONFIG_KEY_INDEX_NAME, NameStr(*index_name)); JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); Jsonb *config = JsonbValueToJsonb(result); /* for the reorder policy, we choose a drifting schedule since the user does not control the schedule interval either */ job_id = ts_bgw_job_insert_relation(&application_name, &schedule_interval, DEFAULT_MAX_RUNTIME, JOB_RETRY_UNLIMITED, DEFAULT_RETRY_PERIOD, &proc_schema, &proc_name, &check_schema, &check_name, owner_id, true, fixed_schedule, hypertable_id, config, initial_start, valid_timezone); if (!TIMESTAMP_NOT_FINITE(initial_start)) ts_bgw_job_stat_upsert_next_start(job_id, initial_start); PG_RETURN_INT32(job_id); } Datum policy_reorder_remove(PG_FUNCTION_ARGS) { Oid hypertable_oid = PG_GETARG_OID(0); bool if_exists = PG_GETARG_BOOL(1); Hypertable *ht; Cache *hcache; ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); ht = ts_hypertable_cache_get_cache_and_entry(hypertable_oid, CACHE_FLAG_NONE, &hcache); List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_REORDER_PROC_NAME, FUNCTIONS_SCHEMA_NAME, ht->fd.id); ts_cache_release(&hcache); if (jobs == NIL) { if (!if_exists) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("reorder policy not found for hypertable \"%s\"", get_rel_name(hypertable_oid)))); else { ereport(NOTICE, (errmsg("reorder policy not found for hypertable \"%s\", skipping", get_rel_name(hypertable_oid)))); PG_RETURN_NULL(); } } Assert(list_length(jobs) == 1); BgwJob *job = linitial(jobs); ts_hypertable_permissions_check(hypertable_oid, GetUserId()); ts_bgw_job_delete_by_id(job->fd.id); PG_RETURN_NULL(); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/reorder_api.h�������������������������������������������������0000664�0000000�0000000�00000001030�15100345067�0022240�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> /* User-facing API functions */ extern Datum policy_reorder_add(PG_FUNCTION_ARGS); extern Datum policy_reorder_remove(PG_FUNCTION_ARGS); extern Datum policy_reorder_proc(PG_FUNCTION_ARGS); extern Datum policy_reorder_check(PG_FUNCTION_ARGS); extern char *policy_reorder_get_index_name(const Jsonb *config); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/retention_api.c�����������������������������������������������0000664�0000000�0000000�00000033470�15100345067�0022615�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/pg_type.h> #include <miscadmin.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include <hypertable_cache.h> #include "bgw/job.h" #include "bgw/job_stat.h" #include "bgw/timer.h" #include "bgw_policy/job.h" #include "bgw_policy/policies_v2.h" #include "bgw_policy/policy_config.h" #include "chunk.h" #include "dimension.h" #include "errors.h" #include "guc.h" #include "hypertable.h" #include "jsonb_utils.h" #include "policy_utils.h" #include "retention_api.h" #include "ts_catalog/continuous_agg.h" #include "utils.h" Datum policy_retention_proc(PG_FUNCTION_ARGS) { if (PG_NARGS() != 2 || PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_VOID(); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); policy_retention_execute(PG_GETARG_INT32(0), PG_GETARG_JSONB_P(1)); PG_RETURN_VOID(); } Datum policy_retention_check(PG_FUNCTION_ARGS) { TS_PREVENT_FUNC_IF_READ_ONLY(); if (PG_ARGISNULL(0)) { ereport(ERROR, (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), errmsg("config must not be NULL"))); } policy_retention_read_and_validate_config(PG_GETARG_JSONB_P(0), NULL); PG_RETURN_VOID(); } int64 policy_retention_get_drop_after_int(const Jsonb *config) { bool found; int64 drop_after = ts_jsonb_get_int64_field(config, POL_RETENTION_CONF_KEY_DROP_AFTER, &found); if (!found) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for job", POL_RETENTION_CONF_KEY_DROP_AFTER))); return drop_after; } Interval * policy_retention_get_drop_after_interval(const Jsonb *config) { Interval *interval = ts_jsonb_get_interval_field(config, POL_RETENTION_CONF_KEY_DROP_AFTER); if (interval == NULL) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for job", POL_RETENTION_CONF_KEY_DROP_AFTER))); return interval; } Interval * policy_retention_get_drop_created_before_interval(const Jsonb *config) { Interval *interval = ts_jsonb_get_interval_field(config, POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE); if (interval == NULL) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not find %s in config for job", POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE))); return interval; } static Hypertable * validate_drop_chunks_hypertable(Cache *hcache, Oid user_htoid) { ContinuousAggHypertableStatus status; Hypertable *ht = ts_hypertable_cache_get_entry(hcache, user_htoid, true /* missing_ok */); if (ht != NULL) { if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add retention policy to compressed hypertable \"%s\"", get_rel_name(user_htoid)), errhint("Please add the policy to the corresponding uncompressed hypertable " "instead."))); } status = ts_continuous_agg_hypertable_status(ht->fd.id); if ((status == HypertableIsMaterialization || status == HypertableIsMaterializationAndRaw)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot add retention policy to materialized hypertable \"%s\" ", get_rel_name(user_htoid)), errhint("Please add the policy to the corresponding continuous aggregate " "instead."))); } } else { /*check if this is a cont aggregate view */ int32 mat_id; ContinuousAgg *ca; ca = ts_continuous_agg_find_by_relid(user_htoid); if (ca == NULL) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("\"%s\" is not a hypertable or a continuous aggregate", get_rel_name(user_htoid)))); mat_id = ca->data.mat_hypertable_id; ht = ts_hypertable_get_by_id(mat_id); } Assert(ht != NULL); return ht; } Datum policy_retention_add_internal(Oid ht_oid, Oid window_type, Datum window_datum, Interval *created_before, Interval default_schedule_interval, bool if_not_exists, bool fixed_schedule, TimestampTz initial_start, const char *timezone) { NameData application_name; int32 job_id; Hypertable *hypertable; Cache *hcache; Oid owner_id = ts_hypertable_permissions_check(ht_oid, GetUserId()); Oid partitioning_type; const Dimension *dim; /* Default scheduled interval for drop_chunks jobs is currently 1 day (24 hours) */ /* Default max runtime should not be very long. Right now set to 5 minutes */ Interval default_max_runtime = { .time = 5 * USECS_PER_MINUTE }; /* Default retry period is currently 5 minutes */ Interval default_retry_period = { .time = 5 * USECS_PER_MINUTE }; /* Right now, there is an infinite number of retries for drop_chunks jobs */ int default_max_retries = -1; /* Verify that the hypertable owner can create a background worker */ ts_bgw_job_validate_job_owner(owner_id); /* Make sure that an existing policy doesn't exist on this hypertable */ hcache = ts_hypertable_cache_pin(); hypertable = validate_drop_chunks_hypertable(hcache, ht_oid); dim = hyperspace_get_open_dimension(hypertable->space, 0); partitioning_type = ts_dimension_get_partition_type(dim); List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_RETENTION_PROC_NAME, FUNCTIONS_SCHEMA_NAME, hypertable->fd.id); if (jobs != NIL) { bool is_equal = false; if (!if_not_exists) ereport(ERROR, (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("retention policy already exists for hypertable \"%s\"", get_rel_name(ht_oid)))); Assert(list_length(jobs) == 1); BgwJob *existing = linitial(jobs); if (OidIsValid(window_type)) is_equal = policy_config_check_hypertable_lag_equality(existing->fd.config, POL_RETENTION_CONF_KEY_DROP_AFTER, partitioning_type, window_type, window_datum, false /* isnull */); else { Assert(created_before != NULL); is_equal = policy_config_check_hypertable_lag_equality( existing->fd.config, POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE, partitioning_type, INTERVALOID, IntervalPGetDatum(created_before), false /* isnull */); } if (is_equal) { /* If all arguments are the same, do nothing */ ts_cache_release(&hcache); ereport(NOTICE, (errmsg("retention policy already exists for hypertable \"%s\", skipping", get_rel_name(ht_oid)))); PG_RETURN_INT32(-1); } else { ts_cache_release(&hcache); ereport(WARNING, (errmsg("retention policy already exists for hypertable \"%s\"", get_rel_name(ht_oid)), errdetail("A policy already exists with different arguments."), errhint("Remove the existing policy before adding a new one."))); PG_RETURN_INT32(-1); } } if (created_before) { Assert(!OidIsValid(window_type)); window_type = INTERVALOID; } if (IS_INTEGER_TYPE(partitioning_type)) { ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(ht_oid); if ((IS_INTEGER_TYPE(window_type) && cagg == NULL && !OidIsValid(ts_get_integer_now_func(dim, false))) || (!IS_INTEGER_TYPE(window_type) && created_before == NULL)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid value for parameter %s", POL_RETENTION_CONF_KEY_DROP_AFTER), errhint( "Integer duration in \"drop_after\" with valid \"integer_now\" function" " or interval time duration" " in \"drop_created_before\" is required for hypertables with integer " "time dimension."))); } if (IS_TIMESTAMP_TYPE(partitioning_type) && window_type != INTERVALOID) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid value for parameter %s", POL_RETENTION_CONF_KEY_DROP_AFTER), errhint("Interval time duration is required for hypertable" " with timestamp-based time dimension."))); JsonbParseState *parse_state = NULL; pushJsonbValue(&parse_state, WJB_BEGIN_OBJECT, NULL); ts_jsonb_add_int32(parse_state, POLICY_CONFIG_KEY_HYPERTABLE_ID, hypertable->fd.id); switch (window_type) { case INTERVALOID: if (created_before) ts_jsonb_add_interval(parse_state, POL_RETENTION_CONF_KEY_DROP_CREATED_BEFORE, created_before); else ts_jsonb_add_interval(parse_state, POL_RETENTION_CONF_KEY_DROP_AFTER, DatumGetIntervalP(window_datum)); break; case INT2OID: ts_jsonb_add_int64(parse_state, POL_RETENTION_CONF_KEY_DROP_AFTER, DatumGetInt16(window_datum)); break; case INT4OID: ts_jsonb_add_int64(parse_state, POL_RETENTION_CONF_KEY_DROP_AFTER, DatumGetInt32(window_datum)); break; case INT8OID: ts_jsonb_add_int64(parse_state, POL_RETENTION_CONF_KEY_DROP_AFTER, DatumGetInt64(window_datum)); break; default: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported datatype for %s: %s", POL_RETENTION_CONF_KEY_DROP_AFTER, format_type_be(window_type)))); } JsonbValue *result = pushJsonbValue(&parse_state, WJB_END_OBJECT, NULL); Jsonb *config = JsonbValueToJsonb(result); /* Next, insert a new job into jobs table */ namestrcpy(&application_name, "Retention Policy"); NameData proc_name, proc_schema, check_schema, check_name; namestrcpy(&proc_name, POLICY_RETENTION_PROC_NAME); namestrcpy(&proc_schema, FUNCTIONS_SCHEMA_NAME); namestrcpy(&check_name, POLICY_RETENTION_CHECK_NAME); namestrcpy(&check_schema, FUNCTIONS_SCHEMA_NAME); job_id = ts_bgw_job_insert_relation(&application_name, &default_schedule_interval, &default_max_runtime, default_max_retries, &default_retry_period, &proc_schema, &proc_name, &check_schema, &check_name, owner_id, true, fixed_schedule, hypertable->fd.id, config, initial_start, timezone); ts_cache_release(&hcache); PG_RETURN_INT32(job_id); } Datum policy_retention_add(PG_FUNCTION_ARGS) { /* behave like a strict function */ if (PG_ARGISNULL(0) || PG_ARGISNULL(2)) PG_RETURN_NULL(); Oid ht_oid = PG_GETARG_OID(0); Datum window_datum = PG_GETARG_DATUM(1); bool if_not_exists = PG_GETARG_BOOL(2); Oid window_type = PG_ARGISNULL(1) ? InvalidOid : get_fn_expr_argtype(fcinfo->flinfo, 1); Interval default_schedule_interval = PG_ARGISNULL(3) ? (Interval) DEFAULT_RETENTION_SCHEDULE_INTERVAL : *PG_GETARG_INTERVAL_P(3); TimestampTz initial_start = PG_ARGISNULL(4) ? DT_NOBEGIN : PG_GETARG_TIMESTAMPTZ(4); bool fixed_schedule = !PG_ARGISNULL(4); text *timezone = PG_ARGISNULL(5) ? NULL : PG_GETARG_TEXT_PP(5); char *valid_timezone = NULL; // Interval *created_before = PG_ARGISNULL(6) ? NULL: PG_GETARG_INTERVAL_P(6); Interval *created_before = PG_GETARG_INTERVAL_P(6); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); Datum retval; /* drop_after and created_before cannot be specified [or omitted] together */ if ((PG_ARGISNULL(1) && PG_ARGISNULL(6)) || (!PG_ARGISNULL(1) && !PG_ARGISNULL(6))) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("need to specify one of \"drop_after\" or \"drop_created_before\""))); /* if users pass in -infinity for initial_start, then use the current_timestamp instead */ if (fixed_schedule) { ts_bgw_job_validate_schedule_interval(&default_schedule_interval); if (TIMESTAMP_NOT_FINITE(initial_start)) initial_start = ts_timer_get_current_timestamp(); } if (timezone != NULL) valid_timezone = ts_bgw_job_validate_timezone(PG_GETARG_DATUM(5)); retval = policy_retention_add_internal(ht_oid, window_type, window_datum, created_before, default_schedule_interval, if_not_exists, fixed_schedule, initial_start, valid_timezone); if (!TIMESTAMP_NOT_FINITE(initial_start)) { int32 job_id = DatumGetInt32(retval); ts_bgw_job_stat_upsert_next_start(job_id, initial_start); } return retval; } Datum policy_retention_remove_internal(Oid table_oid, bool if_exists) { Cache *hcache; Hypertable *hypertable; hypertable = ts_hypertable_cache_get_cache_and_entry(table_oid, CACHE_FLAG_MISSING_OK, &hcache); if (!hypertable) { const char *view_name = get_rel_name(table_oid); if (!view_name) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("relation is not a hypertable or continuous aggregate"))); else { ContinuousAgg *ca = ts_continuous_agg_find_by_relid(table_oid); if (!ca) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("relation \"%s\" is not a hypertable or continuous aggregate", view_name))); hypertable = ts_hypertable_get_by_id(ca->data.mat_hypertable_id); } } Assert(hypertable != NULL); int32 ht_id = hypertable->fd.id; ts_cache_release(&hcache); ts_hypertable_permissions_check(table_oid, GetUserId()); List *jobs = ts_bgw_job_find_by_proc_and_hypertable_id(POLICY_RETENTION_PROC_NAME, FUNCTIONS_SCHEMA_NAME, ht_id); if (jobs == NIL) { if (!if_exists) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("retention policy not found for hypertable \"%s\"", get_rel_name(table_oid)))); else { ereport(NOTICE, (errmsg("retention policy not found for hypertable \"%s\", skipping", get_rel_name(table_oid)))); PG_RETURN_BOOL(false); } } Assert(list_length(jobs) == 1); BgwJob *job = linitial(jobs); ts_bgw_job_delete_by_id(job->fd.id); PG_RETURN_BOOL(true); } Datum policy_retention_remove(PG_FUNCTION_ARGS) { Oid table_oid = PG_GETARG_OID(0); bool if_exists = PG_GETARG_BOOL(1); ts_feature_flag_check(FEATURE_POLICY); TS_PREVENT_FUNC_IF_READ_ONLY(); return policy_retention_remove_internal(table_oid, if_exists); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/bgw_policy/retention_api.h�����������������������������������������������0000664�0000000�0000000�00000002013�15100345067�0022607�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> /* User-facing API functions */ extern Datum policy_retention_add(PG_FUNCTION_ARGS); extern Datum policy_retention_proc(PG_FUNCTION_ARGS); extern Datum policy_retention_check(PG_FUNCTION_ARGS); extern Datum policy_retention_remove(PG_FUNCTION_ARGS); int64 policy_retention_get_drop_after_int(const Jsonb *config); Interval *policy_retention_get_drop_after_interval(const Jsonb *config); Interval *policy_retention_get_drop_created_before_interval(const Jsonb *config); Datum policy_retention_add_internal(Oid ht_oid, Oid window_type, Datum window_datum, Interval *created_before, Interval default_schedule_interval, bool if_not_exists, bool fixed_schedule, TimestampTz initial_start, const char *timezone); Datum policy_retention_remove_internal(Oid table_oid, bool if_exists); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/build-defs.cmake���������������������������������������������������������0000664�0000000�0000000�00000004334�15100345067�0020470�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Hide symbols by default in shared libraries set(CMAKE_C_VISIBILITY_PRESET "hidden") if(UNIX) set(CMAKE_C_STANDARD 11) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -L${PG_LIBDIR}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -L${PG_LIBDIR}") set(CMAKE_C_FLAGS "${PG_CFLAGS} ${PG_CPPFLAGS} ${CMAKE_C_FLAGS}") set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g") endif() if(APPLE) if((${PG_VERSION_MAJOR} GREATER_EQUAL "16")) set(CMAKE_SHARED_MODULE_SUFFIX ".dylib") endif() set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -multiply_defined suppress") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -multiply_defined suppress -Wl,-undefined,dynamic_lookup -bundle_loader ${PG_BINDIR}/postgres" ) elseif(WIN32) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO") endif() # PG_LDFLAGS can have strange values if not found, so we just add the flags if # they are defined. if(PG_LDFLAGS) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${PG_LDFLAGS}") set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${PG_LDFLAGS}") endif() include_directories(${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/tsl/src ${PROJECT_BINARY_DIR}/src ${PROJECT_BINARY_DIR}/tsl/src) include_directories(SYSTEM ${PG_INCLUDEDIR_SERVER}) # Only Windows and FreeBSD need the base include/ dir instead of # include/server/, and including both causes problems on Ubuntu where they # frequently get out of sync if(WIN32 OR (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")) include_directories(SYSTEM ${PG_INCLUDEDIR}) endif() if(WIN32) link_directories(${PROJECT_BINARY_DIR}/src) set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${PG_LIBDIR}/postgres.lib ws2_32.lib Version.lib ${PROJECT_NAME}-${PROJECT_VERSION_MOD}.lib" ) set(CMAKE_C_FLAGS "-D_CRT_SECURE_NO_WARNINGS") include_directories(SYSTEM ${PG_INCLUDEDIR_SERVER}/port/win32) if(MSVC) include_directories(SYSTEM ${PG_INCLUDEDIR_SERVER}/port/win32_msvc) endif(MSVC) endif(WIN32) # Name of library with test-specific code set(TSL_TESTS_LIB_NAME ${PROJECT_NAME}-tsl-tests) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunk.c������������������������������������������������������������������0000664�0000000�0000000�00000012555�15100345067�0016730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/attnum.h> #include <access/table.h> #include <catalog/catalog.h> #include <catalog/heap.h> #include <catalog/namespace.h> #include <catalog/pg_class.h> #include <catalog/pg_foreign_server.h> #include <catalog/pg_foreign_table.h> #include <fmgr.h> #include <foreign/foreign.h> #include <funcapi.h> #include <miscadmin.h> #include <nodes/lockoptions.h> #include <nodes/makefuncs.h> #include <nodes/nodes.h> #include <nodes/value.h> #include <parser/parse_coerce.h> #include <parser/parse_func.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/palloc.h> #include <utils/rel.h> #include <utils/syscache.h> #include "chunk.h" #include "compression/compression.h" #include "debug_point.h" #include "extension.h" #include "hypertable.h" #include "utils.h" /* Data in a frozen chunk cannot be modified. So any operation * that rewrites data for a frozen chunk will be blocked. * Note that a frozen chunk can still be dropped. */ Datum chunk_freeze_chunk(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); TS_PREVENT_FUNC_IF_READ_ONLY(); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); Assert(chunk != NULL); if (chunk->relkind == RELKIND_FOREIGN_TABLE) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on tiered chunk \"%s\"", get_rel_name(chunk_relid)))); } if (ts_chunk_is_frozen(chunk)) PG_RETURN_BOOL(true); /* get Share lock. will wait for other concurrent transactions that are * modifying the chunk. Does not block SELECTs on the chunk. * Does not block other DDL on the chunk table. */ DEBUG_WAITPOINT("freeze_chunk_before_lock"); LockRelationOid(chunk_relid, ShareLock); bool ret = ts_chunk_set_frozen(chunk); PG_RETURN_BOOL(ret); } Datum chunk_unfreeze_chunk(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); TS_PREVENT_FUNC_IF_READ_ONLY(); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); Assert(chunk != NULL); if (chunk->relkind == RELKIND_FOREIGN_TABLE) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on foreign table \"%s\"", get_rel_name(chunk_relid)))); } if (!ts_chunk_is_frozen(chunk)) PG_RETURN_BOOL(true); /* This is a previously frozen chunk. Only selects are permitted on this chunk. * This changes the status in the catalog to allow previously blocked operations. */ bool ret = ts_chunk_unset_frozen(chunk); PG_RETURN_BOOL(ret); } /* * Invoke drop_chunks via fmgr so that the call can be deparsed and sent to * remote data nodes. * * Given that drop_chunks is an SRF, and has pseudo parameter types, we need * to provide a FuncExpr with type information for the deparser. * * Returns the number of dropped chunks. */ int chunk_invoke_drop_chunks(Oid relid, Datum older_than, Datum older_than_type, bool use_creation_time) { EState *estate; ExprContext *econtext; FuncExpr *fexpr; List *args = NIL; int num_results = 0; SetExprState *state; Oid restype; Oid func_oid; Const *TypeNullCons = makeNullConst(older_than_type, -1, InvalidOid); Const *IntervalVal = makeConst(older_than_type, -1, InvalidOid, get_typlen(older_than_type), older_than, false, get_typbyval(older_than_type)); Const *argarr[DROP_CHUNKS_NARGS] = { makeConst(REGCLASSOID, -1, InvalidOid, sizeof(relid), ObjectIdGetDatum(relid), false, false), TypeNullCons, TypeNullCons, castNode(Const, makeBoolConst(false, true)), TypeNullCons, TypeNullCons }; Oid type_id[DROP_CHUNKS_NARGS] = { REGCLASSOID, ANYOID, ANYOID, BOOLOID, ANYOID, ANYOID }; char *const schema_name = ts_extension_schema_name(); List *const fqn = list_make2(makeString(schema_name), makeString(DROP_CHUNKS_FUNCNAME)); StaticAssertStmt(lengthof(type_id) == lengthof(argarr), "argarr and type_id should have matching lengths"); func_oid = LookupFuncName(fqn, lengthof(type_id), type_id, false); Assert(func_oid); /* LookupFuncName should not return an invalid OID */ /* decide whether to use "older_than" or "drop_created_before" */ if (use_creation_time) argarr[4] = IntervalVal; else argarr[1] = IntervalVal; /* Prepare the function expr with argument list */ get_func_result_type(func_oid, &restype, NULL); for (size_t i = 0; i < lengthof(argarr); i++) args = lappend(args, argarr[i]); fexpr = makeFuncExpr(func_oid, restype, args, InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL); fexpr->funcretset = true; /* Execute the SRF */ estate = CreateExecutorState(); econtext = CreateExprContext(estate); state = ExecInitFunctionResultSet(&fexpr->xpr, econtext, NULL); while (true) { ExprDoneCond isdone; bool isnull; ExecMakeFunctionResultSet(state, econtext, estate->es_query_cxt, &isnull, &isdone); if (isdone == ExprEndResult) break; if (!isnull) num_results++; } /* Cleanup */ FreeExprContext(econtext, false); FreeExecutorState(estate); return num_results; } ���������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunk.h������������������������������������������������������������������0000664�0000000�0000000�00000001506�15100345067�0016727�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <chunk.h> #include <fmgr.h> extern Datum chunk_freeze_chunk(PG_FUNCTION_ARGS); extern Datum chunk_unfreeze_chunk(PG_FUNCTION_ARGS); extern int chunk_invoke_drop_chunks(Oid relid, Datum older_than, Datum older_than_type, bool use_creation_time); extern Datum chunk_merge_chunks(PG_FUNCTION_ARGS); extern Datum chunk_split_chunk(PG_FUNCTION_ARGS); extern void update_relstats(Relation catrel, Relation rel, double ntuples); extern void compute_rel_vacuum_cutoffs(Relation rel, struct VacuumCutoffs *cutoffs); extern void chunk_update_constraints(const Chunk *chunk, const Hypercube *new_cube); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunk_api.c��������������������������������������������������������������0000664�0000000�0000000�00000036473�15100345067�0017566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup.h> #include <access/htup_details.h> #include <access/multixact.h> #include <access/visibilitymap.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/pg_class.h> #include <catalog/pg_inherits.h> #include <catalog/pg_namespace.h> #include <catalog/pg_operator.h> #include <catalog/pg_type.h> #include <commands/vacuum.h> #include <fmgr.h> #include <funcapi.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/jsonb.h> #include <utils/lsyscache.h> #include <utils/palloc.h> #include <utils/syscache.h> #include "compat/compat.h" #include "chunk.h" #include "chunk_api.h" #include "debug_point.h" #include "error_utils.h" #include "errors.h" #include "hypercube.h" #include "hypertable_cache.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "utils.h" /* * Convert a hypercube to a JSONB value. * * For instance, a two-dimensional hypercube, with dimensions "time" and * "device", might look as follows: * * {"time": [1514419200000000, 1515024000000000], * "device": [-9223372036854775808, 1073741823]} */ static JsonbValue * hypercube_to_jsonb_value(Hypercube *hc, Hyperspace *hs, JsonbParseState **ps) { int i; Assert(hs->num_dimensions == hc->num_slices); pushJsonbValue(ps, WJB_BEGIN_OBJECT, NULL); for (i = 0; i < hc->num_slices; i++) { JsonbValue k, v; char *dim_name = NameStr(hs->dimensions[i].fd.column_name); Datum range_start = DirectFunctionCall1(int8_numeric, Int64GetDatum(hc->slices[i]->fd.range_start)); Datum range_end = DirectFunctionCall1(int8_numeric, Int64GetDatum(hc->slices[i]->fd.range_end)); Assert(hs->dimensions[i].fd.id == hc->slices[i]->fd.dimension_id); k.type = jbvString; k.val.string.len = strlen(dim_name); k.val.string.val = dim_name; pushJsonbValue(ps, WJB_KEY, &k); pushJsonbValue(ps, WJB_BEGIN_ARRAY, NULL); v.type = jbvNumeric; v.val.numeric = DatumGetNumeric(range_start); pushJsonbValue(ps, WJB_ELEM, &v); v.val.numeric = DatumGetNumeric(range_end); pushJsonbValue(ps, WJB_ELEM, &v); pushJsonbValue(ps, WJB_END_ARRAY, NULL); } return pushJsonbValue(ps, WJB_END_OBJECT, NULL); } /* * Create a hypercube from a JSONB object. * * Takes a JSONB object with a hypercube's dimensional constraints and outputs * a Hypercube. The JSONB is the same format as output by * hypercube_to_jsonb_value() above, i.e.: * * {"time": [1514419200000000, 1515024000000000], * "device": [-9223372036854775808, 1073741823]} */ static Hypercube * hypercube_from_jsonb(Jsonb *json, const Hyperspace *hs, const char **parse_error) { JsonbIterator *it; JsonbIteratorToken type; JsonbValue v; Hypercube *hc = NULL; const char *err = NULL; it = JsonbIteratorInit(&json->root); type = JsonbIteratorNext(&it, &v, false); if (type != WJB_BEGIN_OBJECT) { err = "invalid JSON format"; goto out_err; } if (v.val.object.nPairs != hs->num_dimensions) { err = "invalid number of hypercube dimensions"; goto out_err; } hc = ts_hypercube_alloc(hs->num_dimensions); while ((type = JsonbIteratorNext(&it, &v, false))) { int i; const Dimension *dim; int64 range[2]; const char *name; if (type == WJB_END_OBJECT) break; if (type != WJB_KEY) { err = "invalid JSON format"; goto out_err; } name = pnstrdup(v.val.string.val, v.val.string.len); dim = ts_hyperspace_get_dimension_by_name(hs, DIMENSION_TYPE_ANY, name); if (NULL == dim) { err = psprintf("dimension \"%s\" does not exist in hypertable", name); goto out_err; } type = JsonbIteratorNext(&it, &v, false); if (type != WJB_BEGIN_ARRAY) { err = "invalid JSON format"; goto out_err; } if (v.val.array.nElems != 2) { err = psprintf("unexpected number of dimensional bounds for dimension \"%s\"", name); goto out_err; } for (i = 0; i < 2; i++) { type = JsonbIteratorNext(&it, &v, false); if (type != WJB_ELEM) { err = "invalid JSON format"; goto out_err; } if (v.type == jbvString) { if (!IS_TIMESTAMP_TYPE(dim->fd.column_type)) { err = psprintf("constraint for dimension \"%s\" can be string only for date time", name); goto out_err; } char *v_str = (char *) palloc(v.val.string.len + 1); memcpy(v_str, v.val.string.val, v.val.string.len); v_str[v.val.string.len] = '\0'; range[i] = ts_time_value_from_arg(CStringGetDatum(v_str), InvalidOid, dim->fd.column_type, true); } else if (v.type == jbvNumeric) { range[i] = DatumGetInt64( DirectFunctionCall1(numeric_int8, NumericGetDatum(v.val.numeric))); } else { err = psprintf("constraint for dimension \"%s\" should be either numeric or string", name); goto out_err; } } type = JsonbIteratorNext(&it, &v, false); if (type != WJB_END_ARRAY) { err = "invalid JSON format"; goto out_err; } ts_hypercube_add_slice_from_range(hc, dim->fd.id, range[0], range[1]); } out_err: if (NULL != parse_error) *parse_error = err; if (NULL != err) return NULL; return hc; } enum Anum_create_chunk { Anum_create_chunk_id = 1, Anum_create_chunk_hypertable_id, Anum_create_chunk_schema_name, Anum_create_chunk_table_name, Anum_create_chunk_relkind, Anum_create_chunk_slices, Anum_create_chunk_created, _Anum_create_chunk_max, }; #define Natts_create_chunk (_Anum_create_chunk_max - 1) static HeapTuple chunk_form_tuple(Chunk *chunk, Hypertable *ht, TupleDesc tupdesc, bool created) { Datum values[Natts_create_chunk]; bool nulls[Natts_create_chunk] = { false }; JsonbParseState *ps = NULL; JsonbValue *jv = hypercube_to_jsonb_value(chunk->cube, ht->space, &ps); if (NULL == jv) return NULL; values[AttrNumberGetAttrOffset(Anum_create_chunk_id)] = Int32GetDatum(chunk->fd.id); values[AttrNumberGetAttrOffset(Anum_create_chunk_hypertable_id)] = Int32GetDatum(chunk->fd.hypertable_id); values[AttrNumberGetAttrOffset(Anum_create_chunk_schema_name)] = NameGetDatum(&chunk->fd.schema_name); values[AttrNumberGetAttrOffset(Anum_create_chunk_table_name)] = NameGetDatum(&chunk->fd.table_name); values[AttrNumberGetAttrOffset(Anum_create_chunk_relkind)] = CharGetDatum(chunk->relkind); values[AttrNumberGetAttrOffset(Anum_create_chunk_slices)] = JsonbPGetDatum(JsonbValueToJsonb(jv)); values[AttrNumberGetAttrOffset(Anum_create_chunk_created)] = BoolGetDatum(created); return heap_form_tuple(tupdesc, values, nulls); } Datum chunk_show(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Chunk *chunk = ts_chunk_get_by_relid(chunk_relid, true); Cache *hcache = ts_hypertable_cache_pin(); Hypertable *ht = ts_hypertable_cache_get_entry(hcache, chunk->hypertable_relid, CACHE_FLAG_NONE); TupleDesc tupdesc; HeapTuple tuple; Assert(NULL != chunk); Assert(NULL != ht); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); /* * We use the create_chunk tuple for show_chunk, because they only differ * in the created column at the end. That column will not be included here * since it is not part of the tuple descriptor. */ tuple = chunk_form_tuple(chunk, ht, tupdesc, false); ts_cache_release(&hcache); if (NULL == tuple) ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("could not create tuple from chunk"))); PG_RETURN_DATUM(HeapTupleGetDatum(tuple)); } static void check_privileges_for_creating_chunk(Oid hyper_relid) { AclResult acl_result; acl_result = pg_class_aclcheck(hyper_relid, GetUserId(), ACL_INSERT); if (acl_result != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for table \"%s\"", get_rel_name(hyper_relid)), errdetail("Insert privileges required on \"%s\" to create chunks.", get_rel_name(hyper_relid)))); } static Hypercube * get_hypercube_from_slices(Jsonb *slices, const Hypertable *ht) { Hypercube *hc; const char *parse_err; hc = hypercube_from_jsonb(slices, ht->space, &parse_err); if (hc == NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid hypercube for hypertable \"%s\"", get_rel_name(ht->main_table_relid)), errdetail("%s", parse_err))); return hc; } /* * Create a chunk and its metadata. * * This function will create a chunk, either from an existing table or by * creating a new table. If chunk_table_relid is InvalidOid, the chunk table * will be created, otherwise the table referenced by the relid will be * used. The chunk will be associated with the hypertable given by * hypertable_relid. */ Datum chunk_create(PG_FUNCTION_ARGS) { Oid hypertable_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Jsonb *slices = PG_ARGISNULL(1) ? NULL : PG_GETARG_JSONB_P(1); const char *schema_name = PG_ARGISNULL(2) ? NULL : PG_GETARG_CSTRING(2); const char *table_name = PG_ARGISNULL(3) ? NULL : PG_GETARG_CSTRING(3); Oid chunk_table_relid = PG_ARGISNULL(4) ? InvalidOid : PG_GETARG_OID(4); Cache *hcache = ts_hypertable_cache_pin(); Hypertable *ht = ts_hypertable_cache_get_entry(hcache, hypertable_relid, CACHE_FLAG_NONE); Hypercube *hc; Chunk *chunk; TupleDesc tupdesc; HeapTuple tuple; bool created; Assert(NULL != ht); Assert(OidIsValid(ht->main_table_relid)); check_privileges_for_creating_chunk(hypertable_relid); if (NULL == slices) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid slices"))); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); hc = get_hypercube_from_slices(slices, ht); Assert(NULL != hc); chunk = ts_chunk_find_or_create_without_cuts(ht, hc, schema_name, table_name, chunk_table_relid, &created); Assert(NULL != chunk); tuple = chunk_form_tuple(chunk, ht, tupdesc, created); ts_cache_release(&hcache); if (NULL == tuple) ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("could not create tuple from chunk"))); PG_RETURN_DATUM(HeapTupleGetDatum(tuple)); } /* * Detach a chunk from a hypertable. */ Datum chunk_detach(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Cache *hcache; Hypertable *ht; Chunk *chunk; Oid ht_rel; TS_PREVENT_FUNC_IF_READ_ONLY(); if (!OidIsValid(chunk_relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid chunk relation OID"))); DEBUG_WAITPOINT("chunk_detach_before_lock"); ht_rel = ts_hypertable_id_to_relid(ts_chunk_get_hypertable_id_by_reloid(chunk_relid), true); if (!OidIsValid(ht_rel)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("hypertable not found for the chunk"))); /* Take the same locks taken by PostgreSQL partitioning to be consistent */ LockRelationOid(ht_rel, ShareUpdateExclusiveLock); LockRelationOid(chunk_relid, AccessExclusiveLock); chunk = ts_chunk_get_by_relid(chunk_relid, true); Assert(chunk != NULL); ht = ts_hypertable_cache_get_cache_and_entry(chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); Assert(ht != NULL); if (!object_ownercheck(RelationRelationId, ht->main_table_relid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(ht->main_table_relid)), get_rel_name(ht->main_table_relid)); if (ts_chunk_is_compressed(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot detach compressed chunk \"%s\"", get_rel_name(chunk_relid)), errhint("Decompress the chunk first."))); if (chunk->fd.osm_chunk) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot detach OSM chunk \"%s\"", get_rel_name(chunk_relid)))); AlterTableCmd cmd = { .type = T_AlterTableCmd, .subtype = AT_DropInherit, .def = (Node *) makeRangeVar(NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), 0), }; AlterTableStmt stmt = { .type = T_AlterTableStmt, .cmds = list_make1(&cmd), .relation = makeRangeVar(NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), 0), }; ts_alter_table_with_event_trigger(chunk->table_id, (Node *) &stmt, list_make1(&cmd), false); ts_chunk_detach_by_relid(chunk_relid); ts_cache_release(&hcache); PG_RETURN_VOID(); } /* * Attach an existing relation to a hypertable as a chunk. */ Datum chunk_attach(PG_FUNCTION_ARGS) { Oid ht_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Oid chunk_relid = PG_ARGISNULL(1) ? InvalidOid : PG_GETARG_OID(1); Jsonb *slices = PG_ARGISNULL(2) ? NULL : PG_GETARG_JSONB_P(2); Cache *hcache; Hypertable *ht; Hypercube *hc; Chunk PG_USED_FOR_ASSERTS_ONLY *chunk; bool created; TS_PREVENT_FUNC_IF_READ_ONLY(); if (!OidIsValid(chunk_relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid chunk relation OID"))); if (!OidIsValid(ht_relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid hypertable relation OID"))); if (chunk_relid == ht_relid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("chunk relation cannot be the same as hypertable relation"))); if (NULL == slices) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid dimension slices argument"), errhint("Provide a json-formatted definition of dimensional constraints for the " "chunk partition."))); DEBUG_WAITPOINT("chunk_attach_before_lock"); /* Take the same locks taken by PostgreSQL partitioning to be consistent */ LockRelationOid(ht_relid, ShareUpdateExclusiveLock); LockRelationOid(chunk_relid, AccessExclusiveLock); /* Only owner is allowed */ if (!object_ownercheck(RelationRelationId, chunk_relid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(chunk_relid)), get_rel_name(chunk_relid)); if (is_inheritance_child(chunk_relid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot attach chunk that is already a child of another table"))); if (ts_is_hypertable(chunk_relid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot attach hypertable as a chunk"))); /* Check if the table still exists after taking the lock */ if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(chunk_relid))) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("relation with OID %u does not exist", chunk_relid))); check_privileges_for_creating_chunk(ht_relid); ht = ts_hypertable_cache_get_cache_and_entry(ht_relid, CACHE_FLAG_NONE, &hcache); Assert(ht != NULL); hc = get_hypercube_from_slices(slices, ht); Assert(hc != NULL); chunk = ts_chunk_find_or_create_without_cuts(ht, hc, get_namespace_name(get_rel_namespace(chunk_relid)), get_rel_name(chunk_relid), chunk_relid, &created); Assert(chunk != NULL); ts_cache_release(&hcache); PG_RETURN_VOID(); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunk_api.h��������������������������������������������������������������0000664�0000000�0000000�00000000727�15100345067�0017564�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <chunk.h> extern Datum chunk_status(PG_FUNCTION_ARGS); extern Datum chunk_show(PG_FUNCTION_ARGS); extern Datum chunk_create(PG_FUNCTION_ARGS); extern Datum chunk_detach(PG_FUNCTION_ARGS); extern Datum chunk_attach(PG_FUNCTION_ARGS); �����������������������������������������timescaledb-2.23.0/tsl/src/chunk_merge.c������������������������������������������������������������0000664�0000000�0000000�00000102007�15100345067�0020077�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/multixact.h> #include <access/relation.h> #include <catalog/catalog.h> #include <catalog/dependency.h> #include <catalog/heap.h> #include <catalog/pg_am.h> #include <catalog/pg_constraint.h> #include <commands/tablecmds.h> #include <storage/bufmgr.h> #include <storage/lockdefs.h> #include <utils/acl.h> #include <utils/relcache.h> #include <utils/syscache.h> #include "chunk.h" #include "debug_point.h" #include "hypercube.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_chunk_size.h" typedef struct RelationMergeInfo { Oid relid; struct VacuumCutoffs cutoffs; FormData_compression_chunk_size ccs; Chunk *chunk; Relation rel; char relpersistence; bool isresult; bool iscompressed_rel; } RelationMergeInfo; typedef enum MergeLockUpgrade { MERGE_LOCK_UPGRADE, MERGE_LOCK_CONDITIONAL_UPGRADE, MERGE_LOCK_ACCESS_EXCLUSIVE, } MergeLockUpgrade; void compute_rel_vacuum_cutoffs(Relation rel, struct VacuumCutoffs *cutoffs) { VacuumParams params; memset(¶ms, 0, sizeof(VacuumParams)); vacuum_get_cutoffs(rel, ¶ms, cutoffs); /* Frozen Id should not go backwards */ TransactionId relfrozenxid = rel->rd_rel->relfrozenxid; if (TransactionIdIsValid(relfrozenxid) && TransactionIdPrecedes(cutoffs->FreezeLimit, relfrozenxid)) cutoffs->FreezeLimit = relfrozenxid; MultiXactId relminmxid = rel->rd_rel->relminmxid; if (MultiXactIdIsValid(relminmxid) && MultiXactIdPrecedes(cutoffs->MultiXactCutoff, relminmxid)) cutoffs->MultiXactCutoff = relminmxid; } static void merge_chunks_finish(Oid new_relid, RelationMergeInfo *relinfos, int nrelids, MergeLockUpgrade lock_upgrade) { RelationMergeInfo *result_minfo = NULL; /* * The relations being merged are currently locked in ExclusiveLock, which * means other readers can have locks. To delete the relations, we first * need to upgrade to an exclusive lock. However, this might lead to * deadlocks so we need to bail out if we cannot get the lock immediately. */ for (int i = 0; i < nrelids; i++) { Oid relid = relinfos[i].relid; if (relinfos[i].isresult) result_minfo = &relinfos[i]; /* If merging internal compressed relations, not all chunks have one */ if (!OidIsValid(relid)) continue; switch (lock_upgrade) { case MERGE_LOCK_CONDITIONAL_UPGRADE: if (!ConditionalLockRelationOid(relid, AccessExclusiveLock)) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("could not lock relation \"%s\" for merge", get_rel_name(relid)))); break; case MERGE_LOCK_UPGRADE: LockRelationOid(relid, AccessExclusiveLock); break; case MERGE_LOCK_ACCESS_EXCLUSIVE: /* We should already hold AccessExclusivelock. Could preventively * take it or assert the lock is taken, but it would require * opening the relation again. */ break; } } Ensure(result_minfo != NULL, "no chunk to merge into found"); struct VacuumCutoffs *cutoffs = &result_minfo->cutoffs; finish_heap_swap(result_minfo->relid, new_relid, false, /* system catalog */ false /* swap toast by content */, false, /* check constraints */ true, /* internal? */ cutoffs->FreezeLimit, cutoffs->MultiXactCutoff, result_minfo->relpersistence); /* Don't need to drop objects for internal compressed relations, they are * dropped when the main chunk is dropped. */ if (result_minfo->iscompressed_rel) return; if (ts_chunk_is_compressed(result_minfo->chunk)) ts_chunk_set_partial(result_minfo->chunk); /* * Delete all the merged relations except the result one, since we are * keeping it for the heap swap. */ ObjectAddresses *objects = new_object_addresses(); for (int i = 0; i < nrelids; i++) { Oid relid = relinfos[i].relid; ObjectAddress object = { .classId = RelationRelationId, .objectId = relid, }; if (!OidIsValid(relid) || relinfos[i].isresult) continue; /* Cannot drop if relation is still open */ Assert(relinfos[i].rel == NULL); if (relinfos[i].chunk) { const Oid namespaceid = get_rel_namespace(relid); const char *schemaname = get_namespace_name(namespaceid); const char *tablename = get_rel_name(relid); ts_chunk_delete_by_name(schemaname, tablename, DROP_RESTRICT); } add_exact_object_address(&object, objects); } performMultipleDeletions(objects, DROP_RESTRICT, PERFORM_DELETION_INTERNAL); free_object_addresses(objects); } static int cmp_relations(const void *left, const void *right) { const RelationMergeInfo *linfo = ((RelationMergeInfo *) left); const RelationMergeInfo *rinfo = ((RelationMergeInfo *) right); if (linfo->chunk && rinfo->chunk) { const Hypercube *lcube = linfo->chunk->cube; const Hypercube *rcube = rinfo->chunk->cube; Assert(lcube->num_slices == rcube->num_slices); for (int i = 0; i < lcube->num_slices; i++) { const DimensionSlice *lslice = lcube->slices[i]; const DimensionSlice *rslice = rcube->slices[i]; Assert(lslice->fd.dimension_id == rslice->fd.dimension_id); /* Compare start of range for the dimension */ if (lslice->fd.range_start < rslice->fd.range_start) return -1; if (lslice->fd.range_start > rslice->fd.range_start) return 1; /* If start of range is equal, compare by end of range */ if (lslice->fd.range_end < rslice->fd.range_end) return -1; if (lslice->fd.range_end > rslice->fd.range_end) return 1; } /* Should only reach here if partitioning is equal across all * dimensions. Fall back to comparing relids. */ } return pg_cmp_u32(linfo->relid, rinfo->relid); } /* * Check that the partition boundaries of two chunks align so that a new valid * hypercube can be formed if the chunks are merged. This check assumes that * the hypercubes are sorted so that cube2 "follows" cube1. * * The algorithm is simple and only allows merging along a single dimension in * the same merge. For example, these two cases are mergeable: * * ' ____ * ' |__| * ' |__| * * ' _______ * ' |__|__| * * while these cases are not mergeable: * ' ____ * ' __|__| * ' |__| * * ' ______ * ' |____| * ' |__| * * * The validation can handle merges of many chunks at once if they are * "naively" aligned and this function is called on chunk hypercubes in * "partition order": * * ' _____________ * ' |__|__|__|__| * * However, the validation currently won't accept merges of multiple * dimensions at once: * * ' _____________ * ' |__|__|__|__| * ' |__|__|__|__| * * It also cannot handle complicated merges of multi-dimensional partitioning * schemes like the one below. * * ' _________ * ' |__a____| * ' |_b_|_c_| * * Merging a,b,c, should be possible but the validation currently cannot * handle such cases. Instead, it is necessary to first merge b,c. Then merge * a with the result (b,c) in a separate merge. Note that it is not possible * to merge only a,b or a,c. * * A future, more advanced, validation needs to handle corner-cases like the * one below that has gaps: * * ' _____________ * ' |__|__|__|__| * ' |____| |___| * ' */ static void validate_merge_possible(const Hypercube *cube1, const Hypercube *cube2) { int follow_edges = 0; int equal_edges = 0; Assert(cube1->num_slices == cube2->num_slices); for (int i = 0; i < cube1->num_slices; i++) { const DimensionSlice *slice1 = cube1->slices[i]; const DimensionSlice *slice2 = cube2->slices[i]; if (ts_dimension_slices_equal(slice1, slice2)) equal_edges++; if (slice1->fd.range_end == slice2->fd.range_start) follow_edges++; } if (follow_edges != 1 || (cube1->num_slices - equal_edges) != 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot create new chunk partition boundaries"), errhint("Try merging chunks that have adjacent partitions."))); } static const ChunkConstraint * get_chunk_constraint_by_slice_id(const ChunkConstraints *ccs, int32 slice_id) { for (int i = 0; i < ccs->num_constraints; i++) { const ChunkConstraint *cc = &ccs->constraints[i]; if (cc->fd.dimension_slice_id == slice_id) return cc; } return NULL; } void chunk_update_constraints(const Chunk *chunk, const Hypercube *new_cube) { Cache *hcache; const Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); List *new_constraints = NIL; for (int i = 0; i < new_cube->num_slices; i++) { const DimensionSlice *old_slice = chunk->cube->slices[i]; DimensionSlice *new_slice = new_cube->slices[i]; const ChunkConstraint *cc; ScanTupLock tuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleShare, }; /* If nothing changed in this dimension, move on to the next */ if (ts_dimension_slices_equal(old_slice, new_slice)) continue; cc = get_chunk_constraint_by_slice_id(chunk->constraints, old_slice->fd.id); if (cc) { ObjectAddress constrobj = { .classId = ConstraintRelationId, .objectId = get_relation_constraint_oid(chunk->table_id, NameStr(cc->fd.constraint_name), false), }; performDeletion(&constrobj, DROP_RESTRICT, 0); /* Create the new check constraint */ const Dimension *dim = ts_hyperspace_get_dimension_by_id(ht->space, old_slice->fd.dimension_id); Constraint *constr = ts_chunk_constraint_dimensional_create(dim, new_slice, NameStr(cc->fd.constraint_name)); /* Constraint could be NULL, e.g., if the merged chunk covers the * entire range in a space dimension it needs no constraint. */ if (constr != NULL) new_constraints = lappend(new_constraints, constr); } /* Check if there's already a slice with the new range. If so, avoid * inserting a new slice. */ if (!ts_dimension_slice_scan_for_existing(new_slice, &tuplock)) { new_slice->fd.id = -1; ts_dimension_slice_insert(new_slice); /* A new Id should be assigned */ Assert(new_slice->fd.id > 0); } /* Update the chunk constraint to point to the new slice ID */ ts_chunk_constraint_update_slice_id(chunk->fd.id, old_slice->fd.id, new_slice->fd.id); /* Delete the old slice if it is orphaned now */ if (ts_chunk_constraint_scan_by_dimension_slice_id(old_slice->fd.id, NULL, CurrentMemoryContext) == 0) { ts_dimension_slice_delete_by_id(old_slice->fd.id, false); } } /* Add new check constraints, if any */ if (new_constraints != NIL) { /* Adding a constraint should require AccessExclusivelock. It should * already be taken at this point, but specify it to be sure. */ Relation rel = table_open(chunk->table_id, AccessExclusiveLock); AddRelationNewConstraints(rel, NIL /* List *newColDefaults */, new_constraints, false /* allow_merge */, true /* is_local */, false /* is_internal */, NULL /* query string */); table_close(rel, NoLock); } ts_cache_release(&hcache); } static void merge_cubes(Hypercube *merged_cube, const Hypercube *cube) { /* Merge dimension slices */ for (int i = 0; i < cube->num_slices; i++) { const DimensionSlice *slice = cube->slices[i]; DimensionSlice *merged_slice = merged_cube->slices[i]; Assert(slice->fd.dimension_id == merged_slice->fd.dimension_id); if (slice->fd.range_start < merged_slice->fd.range_start) merged_slice->fd.range_start = slice->fd.range_start; if (slice->fd.range_end > merged_slice->fd.range_end) merged_slice->fd.range_end = slice->fd.range_end; } } /* * Get the locking mode for merge chunks. * * By default, a merge happens with access exclusive locks taken on chunks in * order to avoid deadlocks. It is possible to use a weaker exclusive lock by * setting a session variable, thus allowing reads during merges. However, * that can easily lead to deadlocks as shown in isolation tests. Therefore, * use the stricter locking settings by default. */ static MergeLockUpgrade merge_chunks_lock_upgrade_mode(void) { const char *lockupgrade = GetConfigOption("timescaledb.merge_chunks_lock_upgrade_mode", true, false); if (lockupgrade == NULL) return MERGE_LOCK_ACCESS_EXCLUSIVE; if (strcmp("upgrade", lockupgrade) == 0) return MERGE_LOCK_UPGRADE; if (strcmp("conditional", lockupgrade) == 0) return MERGE_LOCK_CONDITIONAL_UPGRADE; return MERGE_LOCK_ACCESS_EXCLUSIVE; } /* * Use anonymous settings value to disable multidim merges due to a bug in the * routing cache with non-aligned partitions/chunks. */ static bool merge_chunks_multidim_allowed(void) { const char *multidim_merge_enabled = GetConfigOption(MAKE_EXTOPTION("enable_merge_multidim_chunks"), true, false); if (multidim_merge_enabled == NULL) return false; return (pg_strcasecmp("on", multidim_merge_enabled) == 0 || pg_strcasecmp("1", multidim_merge_enabled) == 0 || pg_strcasecmp("true", multidim_merge_enabled) == 0); } #if (PG_VERSION_NUM >= 170000 && PG_VERSION_NUM <= 170002) /* * Workaround for changed behavior in the relation rewrite code that appeared * in PostgreSQL 17.0, but was fixed in 17.3. * * Merge chunks uses the relation rewrite functionality from CLUSTER and * VACUUM FULL. This works for merge because, when writing into a non-empty * relation, new pages are appended while the existing pages remain the * same. In PG17.0, however, that changed so that existing pages in the * relation were zeroed out. The changed behavior was introduced as part of * this commit: * * https://github.com/postgres/postgres/commit/8af256524893987a3e534c6578dd60edfb782a77 * * Fortunately, this was fixed in a follow up commit: * * https://github.com/postgres/postgres/commit/9695835538c2c8e9cd0048028b8c85e1bbf5c79c * * The fix is part of PG 17.3. Howevever, this still leaves PG 17.0 - 17.2 * with different behavior. * * To make the merge chunks code work for the "broken" versions we make PG * believe the first rewrite operation is the size of the fully merged * relation so that we reserve the full space needed and then "append" * backwards into the zeroed space (see illustration below). By doing this, we * ensure that no valid data is zeroed out. The downside of this approach is * that there will be a lot of unnecessary writing of zero pages. Below is an * example of what the rewrite would look like for merging three relations * with one page each. When writing the first relation, PG believes the merged * relation already contains two pages when starting the rewrite. These two * existing pages will be zeroed. When writing the next relation we tell PG * that there is only one existing page in the merged relation, and so forth. * * _____________ * |_0_|_0_|_x_| * _________ * |_0_|_x_| * _____ * |_x_| * * Result: * _____________ * |_x_|_x_|_x_| * */ static BlockNumber merge_rel_nblocks = 0; static BlockNumber *blockoff = NULL; static const TableAmRoutine *old_routine = NULL; static TableAmRoutine routine = {}; /* * TAM relation size function to make PG believe that the merged relation * contains as specific amount of existing data. */ static uint64 pq17_workaround_merge_relation_size(Relation rel, ForkNumber forkNumber) { uint64 nblocks = merge_rel_nblocks; if (forkNumber == MAIN_FORKNUM) return nblocks * BLCKSZ; return old_routine->relation_size(rel, forkNumber); } static inline void pg17_workaround_init(Relation rel, RelationMergeInfo *relinfos, int nrelids) { routine = *rel->rd_tableam; routine.relation_size = pq17_workaround_merge_relation_size; old_routine = rel->rd_tableam; rel->rd_tableam = &routine; blockoff = palloc(sizeof(BlockNumber) * nrelids); uint64 totalblocks = 0; for (int i = 0; i < nrelids; i++) { blockoff[i] = (BlockNumber) totalblocks; if (relinfos[i].rel) { totalblocks += smgrnblocks(RelationGetSmgr(relinfos[i].rel), MAIN_FORKNUM); /* Ensure the offsets don't overflow. For the merge itself, it is * assumed that the write will fail when writing too many blocks */ Ensure(totalblocks <= MaxBlockNumber, "max number of blocks exceeded for merge"); } } } static inline void pg17_workaround_cleanup(Relation rel) { pfree(blockoff); rel->rd_tableam = old_routine; } static inline RelationMergeInfo * get_relmergeinfo(RelationMergeInfo *relinfos, int nrelids, int i) { RelationMergeInfo *relinfo = &relinfos[nrelids - i - 1]; merge_rel_nblocks = blockoff[nrelids - i - 1]; return relinfo; } #else #define pg17_workaround_init(rel, relinfos, nrelids) #define pg17_workaround_cleanup(rel) #define get_relmergeinfo(relinfos, nrelids, i) &(relinfos)[i] #endif /* Update table stats */ void update_relstats(Relation catrel, Relation rel, double ntuples) { HeapTuple reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(RelationGetRelid(rel))); if (!HeapTupleIsValid(reltup)) elog(ERROR, "cache lookup failed for relation %u", RelationGetRelid(rel)); Form_pg_class relform = (Form_pg_class) GETSTRUCT(reltup); BlockNumber num_pages = RelationGetNumberOfBlocks(rel); relform->relpages = num_pages; relform->reltuples = ntuples; CatalogTupleUpdate(catrel, &reltup->t_self, reltup); heap_freetuple(reltup); } static double copy_table_data(Relation fromrel, Relation torel, struct VacuumCutoffs *cutoffs, struct VacuumCutoffs *merged_cutoffs) { double num_tuples = 0.0; double tups_vacuumed = 0.0; double tups_recently_dead = 0.0; table_relation_copy_for_cluster(fromrel, torel, NULL, false, cutoffs->OldestXmin, &cutoffs->FreezeLimit, &cutoffs->MultiXactCutoff, &num_tuples, &tups_vacuumed, &tups_recently_dead); elog(LOG, "merged rows from \"%s\" into \"%s\": tuples %lf vacuumed %lf recently dead %lf", RelationGetRelationName(fromrel), RelationGetRelationName(torel), num_tuples, tups_vacuumed, tups_recently_dead); if (TransactionIdPrecedes(merged_cutoffs->FreezeLimit, cutoffs->FreezeLimit)) merged_cutoffs->FreezeLimit = cutoffs->FreezeLimit; if (MultiXactIdPrecedes(merged_cutoffs->MultiXactCutoff, cutoffs->MultiXactCutoff)) merged_cutoffs->MultiXactCutoff = cutoffs->MultiXactCutoff; /* Close the relations before the heap swap, but keep the locks until * end of transaction. */ table_close(fromrel, NoLock); return num_tuples; } static Oid merge_relinfos(RelationMergeInfo *relinfos, int nrelids, int mergeindex) { RelationMergeInfo *result_minfo = &relinfos[mergeindex]; Relation result_rel = result_minfo->rel; if (result_rel == NULL) return InvalidOid; Oid tablespace = result_rel->rd_rel->reltablespace; struct VacuumCutoffs *merged_cutoffs = &result_minfo->cutoffs; /* Create the transient heap that will receive the re-ordered data */ Oid new_relid = make_new_heap(RelationGetRelid(result_rel), tablespace, result_rel->rd_rel->relam, result_minfo->relpersistence, ExclusiveLock); Relation new_rel = table_open(new_relid, AccessExclusiveLock); double total_num_tuples = 0.0; FormData_compression_chunk_size merged_ccs; memset(&merged_ccs, 0, sizeof(FormData_compression_chunk_size)); pg17_workaround_init(new_rel, relinfos, nrelids); /* Step 3: write the data from all the rels into a new merged heap */ for (int i = 0; i < nrelids; i++) { RelationMergeInfo *relinfo = get_relmergeinfo(relinfos, nrelids, i); struct VacuumCutoffs *cutoffs_i = &relinfo->cutoffs; double num_tuples = 0.0; if (relinfo->rel) { num_tuples = copy_table_data(relinfo->rel, new_rel, cutoffs_i, merged_cutoffs); total_num_tuples += num_tuples; relinfo->rel = NULL; } /* * Merge compression chunk size stats. * * Simply sum up the stats for all compressed relations that are * merged. Note that we don't add anything for non-compressed * relations that are merged because they don't have stats. This is a * bit weird because the data from uncompressed relations will not be * reflected in the stats of the merged chunk although the data is * part of the chunk. */ merged_ccs.compressed_heap_size += relinfo->ccs.compressed_heap_size; merged_ccs.compressed_toast_size += relinfo->ccs.compressed_toast_size; merged_ccs.compressed_index_size += relinfo->ccs.compressed_index_size; merged_ccs.uncompressed_heap_size += relinfo->ccs.uncompressed_heap_size; merged_ccs.uncompressed_toast_size += relinfo->ccs.uncompressed_toast_size; merged_ccs.uncompressed_index_size += relinfo->ccs.uncompressed_index_size; merged_ccs.numrows_post_compression += relinfo->ccs.numrows_post_compression; merged_ccs.numrows_pre_compression += relinfo->ccs.numrows_pre_compression; merged_ccs.numrows_frozen_immediately += relinfo->ccs.numrows_frozen_immediately; } pg17_workaround_cleanup(new_rel); /* Update table stats */ Relation relRelation = table_open(RelationRelationId, RowExclusiveLock); update_relstats(relRelation, new_rel, total_num_tuples); table_close(new_rel, NoLock); table_close(relRelation, RowExclusiveLock); /* * Update compression chunk size stats, but only if at least one of the * merged chunks was compressed. In that case the merged metadata should * be non-zero. */ if (merged_ccs.compressed_heap_size > 0) { /* * The result relation should always be compressed because we pick the * first compressed one, if one exists. */ Assert(result_minfo->ccs.compressed_heap_size > 0); ts_compression_chunk_size_update(result_minfo->chunk->fd.id, &merged_ccs); } return new_relid; } /* * Merge N chunk relations into one chunk based on Oids. * * The input chunk relations are ordered according to partition ranges and the * "first" relation in that ordered list will be "kept" to hold the merged * data. The merged chunk will have its partition ranges updated to cover the * ranges of all the merged chunks. * * The merge happens via a heap rewrite, followed by a heap swap, essentially * the same approach implemented by CLUSTER and VACUUM FULL, but applied on * several relations in the same operation (many to one). * * * The heap swap approach handles visibility across all PG isolation levels, * as implemented by the cluster code. * * In the first step, all data from each chunk is written to a temporary heap * (accounting for vacuum, half-dead/visible, and frozen tuples). In the * second step, a heap swap is performed on one of the chunks and all metadata * is rewritten to handle, e.g., new partition ranges. Finally, the old chunks * are dropped, except for the chunk that received the heap swap. * * To be able to merge, the function checks that: * * - all relations are tables (not, e.g,, views) * - all relations use same (or compatible) storage on disk * - all relations are chunks (and not, e.g., foreign/OSM chunks) * * Compressed chunks can be merged, and in that case the non-compressed chunk * and the (internal) compressed chunk are merged in separate * steps. Currently, the merge does not move and recompress data across the * two relations so whatever data was compressed or not compressed prior to * the merge will remain in the same state after the merge. */ Datum chunk_merge_chunks(PG_FUNCTION_ARGS) { ArrayType *chunks_array = PG_ARGISNULL(0) ? NULL : PG_GETARG_ARRAYTYPE_P(0); Datum *relids; bool *nulls; int nrelids; RelationMergeInfo *relinfos; RelationMergeInfo *crelinfos; /* For compressed relations */ int32 hypertable_id = INVALID_HYPERTABLE_ID; Hypercube *merged_cube = NULL; const Hypercube *prev_cube = NULL; const MergeLockUpgrade lock_upgrade = merge_chunks_lock_upgrade_mode(); int mergeindex = -1; PreventCommandIfReadOnly("merge_chunks"); if (chunks_array == NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no chunks to merge specified"))); deconstruct_array(chunks_array, REGCLASSOID, sizeof(Oid), true, TYPALIGN_INT, &relids, &nulls, &nrelids); if (nrelids < 2) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("must specify at least two chunks to merge"))); relinfos = palloc0(sizeof(struct RelationMergeInfo) * nrelids); crelinfos = palloc0(sizeof(struct RelationMergeInfo) * nrelids); /* Sort relids array in order to find duplicates and lock relations in * consistent order to avoid deadlocks. It doesn't matter that we don't * order the nulls array the same since we only care about all relids * being non-null. */ qsort(relids, nrelids, sizeof(Datum), oid_cmp); /* Step 1: Do sanity checks and then prepare to sort rels in consistent order. */ for (int i = 0; i < nrelids; i++) { Oid relid = DatumGetObjectId(relids[i]); RelationMergeInfo *relinfo = &relinfos[i]; Chunk *chunk; Relation rel; if (nulls[i] || !OidIsValid(relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid relation"))); if (i > 0 && DatumGetObjectId(relids[i]) == DatumGetObjectId(relids[i - 1])) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("duplicate relation \"%s\" in merge", get_rel_name(DatumGetObjectId(relids[i]))))); /* Lock the relation before doing other checks that can lock dependent * objects (this can otherwise lead to deadlocks with concurrent * operations). Note that if we take ExclusiveLock here to allow * readers while we are rewriting/merging the relations, the lock * needs to be upgraded to an AccessExclusiveLock later. This can also * lead to deadlocks. * * Ideally, we should probably take locks on all dependent objects as * well, at least on chunk-related objects that will be * dropped. Otherwise, that might also cause deadlocks later. For * example, if doing a concurrent DROP TABLE on one of the chunks will * lead to deadlock because it grabs locks on all dependencies before * dropping. * * However, for now we won't do that because that requires scanning * pg_depends and concurrent operations will probably fail anyway if * we remove the objects. We might as well fail with a deadlock. */ LOCKMODE lockmode = (lock_upgrade == MERGE_LOCK_ACCESS_EXCLUSIVE) ? AccessExclusiveLock : ExclusiveLock; chunk = ts_chunk_get_by_relid_locked(relid, lockmode, false); if (chunk == NULL) { /* * The relation is not a chunk, or it was deleted. Use * try_relation_open() to figure out which case. It will * automatically check that the relation still exists after the * lock is acquired. We only need AccessShareLock here since we * know the relation isn't a chunk and we only want to generate an * informative error. */ rel = try_relation_open(relid, AccessShareLock); if (rel) { bool is_table = (rel->rd_rel->relkind == RELKIND_RELATION); relation_close(rel, AccessShareLock); if (is_table) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("can only merge hypertable chunks"))); else ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot merge non-table relations"))); } else { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), errmsg("chunk does not exist"), errdetail("The relation with OID %u might have been removed " "by a concurrent merge or other operation.", relid))); } } /* Chunk already locked so we can get the relation directly from the cache */ rel = table_open(relid, NoLock); /* Only owner is allowed to merge */ if (!object_ownercheck(RelationRelationId, relid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(rel->rd_rel->relkind), get_rel_name(relid)); /* Lock toast table to prevent it from being concurrently vacuumed */ if (rel->rd_rel->reltoastrelid) LockRelationOid(rel->rd_rel->reltoastrelid, lockmode); /* * Check for active uses of the relation in the current transaction, * including open scans and pending AFTER trigger events. */ CheckTableNotInUse(rel, "merge_chunks"); if (!merge_chunks_multidim_allowed()) { Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); Ensure(ht, "missing hypertable for chunk"); if (ht->fd.num_dimensions > 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot merge chunk in multi-dimensional hypertable"))); ts_cache_release(&hcache); } if (chunk->fd.osm_chunk) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot merge OSM chunks"))); /* * Lock also internal compressed relation, if it exists. * * Don't fill in its MergeRelInfo until we sort relations in partition * order below, because the compressed relations need to be in the * same order. */ if (chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID) { Oid crelid = ts_chunk_get_relid(chunk->fd.compressed_chunk_id, false); LockRelationOid(crelid, AccessExclusiveLock); if (mergeindex == -1) mergeindex = i; /* Read compression chunk size stats */ bool found = ts_compression_chunk_size_get(chunk->fd.id, &relinfo->ccs); if (!found) elog(WARNING, "missing compression chunk size stats for compressed chunk \"%s\"", NameStr(chunk->fd.table_name)); } if (ts_chunk_is_frozen(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot merge frozen chunk \"%s.%s\" scheduled for tiering", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)), errhint("Untier the chunk before merging."))); if (hypertable_id == INVALID_HYPERTABLE_ID) hypertable_id = chunk->fd.hypertable_id; else if (hypertable_id != chunk->fd.hypertable_id) { Assert(i > 0); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot merge chunks across different hypertables"), errdetail("Chunk \"%s\" is part of hypertable \"%s\" while chunk \"%s\" is " "part of hypertable \"%s\"", get_rel_name(chunk->table_id), get_rel_name(chunk->hypertable_relid), get_rel_name(relinfos[i - 1].chunk->table_id), get_rel_name(relinfos[i - 1].chunk->hypertable_relid)))); } /* * It might not be possible to merge two chunks with different * storage, so better safe than sorry for now. */ Oid amoid = rel->rd_rel->relam; if (amoid != HEAP_TABLE_AM_OID) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("access method \"%s\" is not supported for merge", get_am_name(amoid)))); relinfo->relid = relid; relinfo->rel = rel; relinfo->chunk = chunk; relinfo->relpersistence = rel->rd_rel->relpersistence; } /* No compressed chunk found, so use index 0 for resulting merged chunk */ if (mergeindex == -1) mergeindex = 0; relinfos[mergeindex].isresult = true; /* Sort rels in partition order (in case of chunks). This is necessary to * validate that a merge is possible. */ qsort(relinfos, nrelids, sizeof(RelationMergeInfo), cmp_relations); /* Step 2: Check alignment/mergeability and create the merged hypercube * (partition ranges). */ for (int i = 0; i < nrelids; i++) { const Chunk *chunk = relinfos[i].chunk; Assert(chunk != NULL); if (merged_cube == NULL) { merged_cube = ts_hypercube_copy(chunk->cube); Assert(prev_cube == NULL); } else { Assert(chunk->cube->num_slices == merged_cube->num_slices); Assert(prev_cube != NULL); validate_merge_possible(prev_cube, chunk->cube); merge_cubes(merged_cube, chunk->cube); } prev_cube = chunk->cube; compute_rel_vacuum_cutoffs(relinfos[i].rel, &relinfos[i].cutoffs); /* * Fill in the compressed mergerelinfo array here after final sort of * rels so that the two arrays have the same order. */ if (chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID) { RelationMergeInfo *crelinfo = &crelinfos[i]; crelinfo->chunk = ts_chunk_get_by_id(chunk->fd.compressed_chunk_id, true); crelinfo->relid = crelinfo->chunk->table_id; crelinfo->rel = table_open(crelinfo->relid, AccessExclusiveLock); crelinfo->isresult = relinfos[i].isresult; crelinfo->iscompressed_rel = true; crelinfo->relpersistence = crelinfo->rel->rd_rel->relpersistence; compute_rel_vacuum_cutoffs(crelinfos[i].rel, &crelinfos[i].cutoffs); } /* Need to update the index of the result (merged) relation after * resort */ if (relinfos[i].isresult) mergeindex = i; } /* * Now merge all the data into a new temporary heap relation. Do it * separately for the non-compressed and compressed relations. */ Oid new_relid = merge_relinfos(relinfos, nrelids, mergeindex); Oid new_crelid = merge_relinfos(crelinfos, nrelids, mergeindex); /* Make new table stats visible */ CommandCounterIncrement(); DEBUG_WAITPOINT("merge_chunks_before_heap_swap"); merge_chunks_finish(new_relid, relinfos, nrelids, lock_upgrade); if (OidIsValid(new_crelid)) merge_chunks_finish(new_crelid, crelinfos, nrelids, lock_upgrade); /* Step 5: Update the dimensional metadata and constraints for the chunk * we are keeping. */ if (merged_cube) { RelationMergeInfo *result_minfo = &relinfos[mergeindex]; Assert(result_minfo->chunk); chunk_update_constraints(result_minfo->chunk, merged_cube); ts_hypercube_free(merged_cube); } pfree(relids); pfree(nulls); pfree(relinfos); pfree(crelinfos); PG_RETURN_VOID(); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunk_split.c������������������������������������������������������������0000664�0000000�0000000�00000110265�15100345067�0020140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/multixact.h> #include <access/rewriteheap.h> #include <catalog/dependency.h> #include <catalog/heap.h> #include <catalog/pg_am.h> #include <catalog/pg_collation.h> #include <catalog/pg_constraint.h> #include <commands/tablecmds.h> #include <storage/bufmgr.h> #include <storage/lockdefs.h> #include <utils/acl.h> #include <utils/snapshot.h> #include <utils/syscache.h> #include <math.h> #include "chunk.h" #include "compression/api.h" #include "compression/compression.h" #include "compression/create.h" #include "debug_point.h" #include "hypercube.h" #include "partitioning.h" #include "trigger.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_chunk_size.h" /* * The split_chunk() procedure currently only supports two-way split. */ #define SPLIT_FACTOR 2 typedef struct SplitContext SplitContext; /* * SplitPointInfo * * Information about point where split happens, including column/dimension and * type we split along. Needed to route tuples to correct result relation. */ typedef struct SplitPoint { const Dimension *dim; int64 point; /* Point at which we split */ /* * Function to route a tuple to a result relation during the split. The * function's implementation is different depending on whether compressed * or non-compressed relations are split. */ HeapTuple (*route_next_tuple)(TupleTableSlot *slot, SplitContext *scontext, int *routing_index); } SplitPoint; /* * CompressedSplitPoint * * Version of SplitPoint for a compressed relation. * * Since tuples are compressed, routing happens on min/max-metadata so column * references are different. */ typedef struct CompressedSplitPoint { SplitPoint base; AttrNumber attnum_min; AttrNumber attnum_max; AttrNumber attnum_count; TupleDesc noncompressed_tupdesc; } CompressedSplitPoint; typedef struct RewriteStats { int64 tuples_written; int64 tuples_alive; int64 tuples_recently_dead; int64 tuples_in_segments; } RewriteStats; /* * RelationWriteState * * State used to rewrite the resulting relations when splitting. Holds * information about attribute mappings in case the relations have different * tuple descriptors (e.g., due to dropped or added columns). */ typedef struct RelationWriteState { BulkInsertState bistate; TupleTableSlot *dstslot; RewriteState rwstate; Relation targetrel; Datum *values; bool *isnull; /* * Tuple mapping is needed in case the old relation has dropped * columns. New relations (as result of split) are "clean" without dropped * columns. The tuple map converts tuples between the source and * destination chunks. */ TupleConversionMap *tupmap; RowCompressor compressor; RewriteStats stats; } RelationWriteState; /* * SplitContext * * Main state for doing a split. */ typedef struct SplitContext { Relation rel; /* Relation/chunk being split */ SplitPoint *sp; struct VacuumCutoffs cutoffs; int split_factor; /* Number of relations to split into */ /* Array of rewrite states used to write the new relations. Size of * split_factor. */ RelationWriteState *rws; int rws_index; /* Index into rsi array indicating currently routed * relation. Set to -1 if no currently routed relation. */ } SplitContext; /* * SplitRelationInfo * * Information about the result relations in a split. Also, information about * the number of tuples written to the relation is returned in the struct. */ typedef struct SplitRelationInfo { Oid relid; /* The relid of the result relation */ int32 chunk_id; /* The corresponding chunk's ID */ bool heap_swap; /* The original relation getting split will receive a heap * swap. New chunks won't get a heap swap since they are * new and not visible to anyone else. */ RewriteStats stats; } SplitRelationInfo; static void relation_split_info_init(RelationWriteState *rws, Relation srcrel, Oid target_relid, struct VacuumCutoffs *cutoffs) { rws->targetrel = table_open(target_relid, AccessExclusiveLock); rws->bistate = GetBulkInsertState(); rws->rwstate = begin_heap_rewrite(srcrel, rws->targetrel, cutoffs->OldestXmin, cutoffs->FreezeLimit, cutoffs->MultiXactCutoff); rws->tupmap = convert_tuples_by_name(RelationGetDescr(srcrel), RelationGetDescr(rws->targetrel)); /* Create tuple slot for new partition. */ rws->dstslot = table_slot_create(rws->targetrel, NULL); ExecStoreAllNullTuple(rws->dstslot); rws->values = (Datum *) palloc0(RelationGetDescr(srcrel)->natts * sizeof(Datum)); rws->isnull = (bool *) palloc0(RelationGetDescr(srcrel)->natts * sizeof(bool)); } static void relation_split_info_cleanup(RelationWriteState *rws, int ti_options) { ExecDropSingleTupleTableSlot(rws->dstslot); FreeBulkInsertState(rws->bistate); table_finish_bulk_insert(rws->targetrel, ti_options); end_heap_rewrite(rws->rwstate); table_close(rws->targetrel, NoLock); pfree(rws->values); pfree(rws->isnull); if (rws->tupmap) free_conversion_map(rws->tupmap); rws->targetrel = NULL; rws->bistate = NULL; rws->dstslot = NULL; rws->tupmap = NULL; rws->values = NULL; rws->isnull = NULL; } /* * Reconstruct and rewrite the given tuple. * * Mostly taken from heapam module. * * When splitting a relation in two, the old relation is retained for one of * the result relations while the other is created new. This might lead to a * situation where the two result relations have different attribute mappings * because the old one could have dropped columns while the new one is "clean" * without dropped columns. Therefore, the rewrite function needs to account * for this when the tuple is rewritten. */ static void reform_and_rewrite_tuple(HeapTuple tuple, Relation srcrel, RelationWriteState *rws) { TupleDesc oldTupDesc = RelationGetDescr(srcrel); TupleDesc newTupDesc = RelationGetDescr(rws->targetrel); HeapTuple tupcopy; if (rws->tupmap) { /* * If this is the "new" relation, the tuple map might be different * from the "source" relation. */ tupcopy = execute_attr_map_tuple(tuple, rws->tupmap); } else { int i; heap_deform_tuple(tuple, oldTupDesc, rws->values, rws->isnull); /* Be sure to null out any dropped columns if this is the "old" * relation. A relation created new doesn't have dropped columns. */ for (i = 0; i < newTupDesc->natts; i++) { if (TupleDescAttr(newTupDesc, i)->attisdropped) rws->isnull[i] = true; } tupcopy = heap_form_tuple(newTupDesc, rws->values, rws->isnull); } /* The heap rewrite module does the rest */ rewrite_heap_tuple(rws->rwstate, tuple, tupcopy); heap_freetuple(tupcopy); } static Datum slot_get_partition_value(TupleTableSlot *slot, AttrNumber attnum, const SplitPoint *sp) { bool isnull = false; Datum value = slot_getattr(slot, attnum, &isnull); /* * Space-partition columns can have NULL values, but we only support * splits on time dimensions at the moment. */ Ensure(!isnull, "unexpected NULL value in partitioning column"); /* * Both time and space dimensions can have partitioning functions, so it * is necessary to always check for a function. */ if (NULL != sp->dim->partitioning) { Oid collation; collation = TupleDescAttr(slot->tts_tupleDescriptor, AttrNumberGetAttrOffset(attnum))->attcollation; value = ts_partitioning_func_apply(sp->dim->partitioning, collation, value); } return value; } /* * Compute the partition/routing index for a tuple. * * Returns 0 or 1 for first or second partition, respectively. */ static int route_tuple(TupleTableSlot *slot, const SplitPoint *sp) { Oid dimtype = ts_dimension_get_partition_type(sp->dim); Datum value = slot_get_partition_value(slot, sp->dim->column_attno, sp); int64 point = ts_time_value_to_internal(value, dimtype); /* * Route to partition based on new boundaries. Only 2-way split is * supported now, so routing is easy. An N-way split requires, e.g., * binary search. */ return (point < sp->point) ? 0 : 1; } /* * Compute the partition/routing index for a compressed tuple. * * Returns 0 or 1 for first or second partition, and -1 if the split point * falls within the given compressed tuple. */ static int route_compressed_tuple(TupleTableSlot *slot, const SplitPoint *sp) { const CompressedSplitPoint *csp = (const CompressedSplitPoint *) sp; Oid dimtype = ts_dimension_get_partition_type(sp->dim); Datum min_value = slot_get_partition_value(slot, csp->attnum_min, sp); Datum max_value = slot_get_partition_value(slot, csp->attnum_max, sp); int64 min_point = ts_time_value_to_internal(min_value, dimtype); int64 max_point = ts_time_value_to_internal(max_value, dimtype); if (max_point < sp->point) return 0; if (min_point >= sp->point) return 1; Assert(min_point < sp->point && max_point >= sp->point); return -1; } /* * Route a tuple to its partition. * * Only a 2-way split is supported at this time. * * For every non-NULL tuple returned, the routing_index will be set to 0 for * the first partition, and 1 for then second. */ static HeapTuple route_next_non_compressed_tuple(TupleTableSlot *slot, SplitContext *scontext, int *routing_index) { if (scontext->rws_index != -1) { scontext->rws_index = -1; return NULL; } scontext->rws_index = route_tuple(slot, scontext->sp); *routing_index = scontext->rws_index; return ExecFetchSlotHeapTuple(slot, false, NULL); } /* * Route a compressed tuple (segment) to its corresponding result partition * for the split. * * If the split point is found to be within the segment, it needs to be split * and sub-segments returned instead. Therefore, this function should be * called in a loop until returning NULL (no sub-segments left). If the * segment is not split, only the original segment is returned. * * For every non-NULL tuple returned, the routing_index will be set to 0 for * the first partition, and 1 for the second. */ static HeapTuple route_next_compressed_tuple(TupleTableSlot *slot, SplitContext *scontext, int *routing_index) { CompressedSplitPoint *csp = (CompressedSplitPoint *) scontext->sp; Assert(scontext->rws_index >= -1 && scontext->rws_index <= scontext->split_factor); if (scontext->rws_index == scontext->split_factor) { /* Nothing more to route for this tuple, so return NULL */ scontext->rws_index = -1; *routing_index = -1; return NULL; } else if (scontext->rws_index >= 0) { /* Segment is being split and recompressed into a sub-segment per * partition. Return the sub-segments until done. */ Assert(scontext->rws_index < scontext->split_factor); RelationWriteState *rws = &scontext->rws[scontext->rws_index]; HeapTuple new_tuple = row_compressor_build_tuple(&rws->compressor); HeapTuple old_tuple = ExecFetchSlotHeapTuple(slot, false, NULL); /* Copy over visibility information from the original segment * tuple. First copy the HeapTupleFields holding the xmin and * xmax. Then copy the infomask which has, among other things, the * frozen flag bits. */ memcpy(&new_tuple->t_data->t_choice.t_heap, &old_tuple->t_data->t_choice.t_heap, sizeof(HeapTupleFields)); new_tuple->t_data->t_infomask &= ~HEAP_XACT_MASK; new_tuple->t_data->t_infomask2 &= ~HEAP2_XACT_MASK; new_tuple->t_data->t_infomask |= old_tuple->t_data->t_infomask & HEAP_XACT_MASK; new_tuple->t_tableOid = RelationGetRelid(rws->targetrel); row_compressor_clear_batch(&rws->compressor, false); rws->stats.tuples_in_segments += rws->compressor.rowcnt_pre_compression; *routing_index = scontext->rws_index; scontext->rws_index++; row_compressor_close(&rws->compressor); return new_tuple; } *routing_index = route_compressed_tuple(slot, scontext->sp); if (*routing_index == -1) { /* * The split point is within the current compressed segment. It needs * to be split across the partitions by decompressing and * recompressing into sub-segments. */ HeapTuple tuple; CompressionSettings *csettings = ts_compression_settings_get_by_compress_relid(RelationGetRelid(scontext->rel)); tuple = ExecFetchSlotHeapTuple(slot, false, NULL); RowDecompressor decompressor = build_decompressor(slot->tts_tupleDescriptor, csp->noncompressed_tupdesc); heap_deform_tuple(tuple, decompressor.in_desc, decompressor.compressed_datums, decompressor.compressed_is_nulls); int nrows = decompress_batch(&decompressor); /* * Initialize a compressor for each new partition. */ for (int i = 0; i < scontext->split_factor; i++) { RelationWriteState *rws = &scontext->rws[i]; row_compressor_init(&rws->compressor, csettings, csp->noncompressed_tupdesc, RelationGetDescr(scontext->rws[i].targetrel)); } /* * Route each decompressed tuple to its corresponding partition's * compressor. */ for (int i = 0; i < nrows; i++) { int routing_index = route_tuple(decompressor.decompressed_slots[i], scontext->sp); Assert(routing_index == 0 || routing_index == 1); RelationWriteState *rws = &scontext->rws[routing_index]; /* * Since we're splitting a segment, the new segments will be * ordered like the original segment. Also, there is no risk of * the segments getting too big since we are only making segments * smaller. */ row_compressor_append_ordered_slot(&rws->compressor, decompressor.decompressed_slots[i]); } row_decompressor_close(&decompressor); scontext->rws_index = 0; /* * Call this function again to return the sub-segments. */ return route_next_compressed_tuple(slot, scontext, routing_index); } /* Update tuple count stats for compressed data */ bool isnull; Datum count = slot_getattr(slot, csp->attnum_count, &isnull); scontext->rws[*routing_index].stats.tuples_in_segments += DatumGetInt32(count); /* * The compressed tuple (segment) can be routed without splitting it. */ Assert(*routing_index >= 0 && *routing_index < scontext->split_factor); scontext->rws_index = scontext->split_factor; return ExecFetchSlotHeapTuple(slot, false, NULL); } static double copy_tuples_for_split(SplitContext *scontext) { Relation srcrel = scontext->rel; TupleTableSlot *srcslot; MemoryContext oldcxt; EState *estate; ExprContext *econtext; TableScanDesc scan; SplitPoint *sp = scontext->sp; estate = CreateExecutorState(); /* Create the tuple slot */ srcslot = table_slot_create(srcrel, NULL); /* * Scan through the rows using SnapshotAny to see everything so that we * can transfer tuples that are deleted or updated but still visible to * concurrent transactions. */ scan = table_beginscan(srcrel, SnapshotAny, 0, NULL); /* * Switch to per-tuple memory context and reset it for each tuple * produced, so we don't leak memory. */ econtext = GetPerTupleExprContext(estate); oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate)); /* * Read all the data from the split relation and route the tuples to the * new partitions. Do some vacuuming and cleanup at the same * time. Transfer all visibility information to the new relations. * * Main loop inspired by heapam_relation_copy_for_cluster() used to run * CLUSTER and VACUUM FULL on a table. */ double num_tuples = 0.0; double tups_vacuumed = 0.0; double tups_recently_dead = 0.0; BufferHeapTupleTableSlot *hslot; int routingindex = -1; while (table_scan_getnextslot(scan, ForwardScanDirection, srcslot)) { RelationWriteState *rws = NULL; HeapTuple tuple; Buffer buf; bool isdead; bool isalive = false; CHECK_FOR_INTERRUPTS(); ResetExprContext(econtext); tuple = ExecFetchSlotHeapTuple(srcslot, false, NULL); hslot = (BufferHeapTupleTableSlot *) srcslot; buf = hslot->buffer; LockBuffer(buf, BUFFER_LOCK_SHARE); switch (HeapTupleSatisfiesVacuum(tuple, scontext->cutoffs.OldestXmin, buf)) { case HEAPTUPLE_DEAD: /* Definitely dead */ isdead = true; break; case HEAPTUPLE_RECENTLY_DEAD: tups_recently_dead += 1; isdead = false; break; case HEAPTUPLE_LIVE: /* Live or recently dead, must copy it */ isdead = false; isalive = true; break; case HEAPTUPLE_INSERT_IN_PROGRESS: /* * Since we hold exclusive lock on the relation, normally the * only way to see this is if it was inserted earlier in our * own transaction. Give a warning if this case does not * apply; in any case we better copy it. */ if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple->t_data))) elog(WARNING, "concurrent insert in progress within table \"%s\"", RelationGetRelationName(srcrel)); /* treat as live */ isdead = false; isalive = true; break; case HEAPTUPLE_DELETE_IN_PROGRESS: /* * Similar situation to INSERT_IN_PROGRESS case. */ if (!TransactionIdIsCurrentTransactionId( HeapTupleHeaderGetUpdateXid(tuple->t_data))) elog(WARNING, "concurrent delete in progress within table \"%s\"", RelationGetRelationName(srcrel)); /* treat as recently dead */ tups_recently_dead += 1; isalive = true; isdead = false; break; default: elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result"); isdead = false; /* keep compiler quiet */ break; } LockBuffer(buf, BUFFER_LOCK_UNLOCK); HeapTuple tuple2; /* * Route the tuple to the matching (new) partition. The routing is * done in a loop because compressed tuple segments might be split * into multiple sub-segment tuples if the split is in the middle of * that segment. */ while ((tuple2 = sp->route_next_tuple(srcslot, scontext, &routingindex))) { Assert(routingindex >= 0 && routingindex < scontext->split_factor); rws = &scontext->rws[routingindex]; if (isdead) { tups_vacuumed += 1; /* heap rewrite module still needs to see it... */ if (rewrite_heap_dead_tuple(rws->rwstate, tuple2)) { /* A previous recently-dead tuple is now known dead */ tups_vacuumed += 1; tups_recently_dead -= 1; } } else { num_tuples++; rws->stats.tuples_written++; if (isalive) rws->stats.tuples_alive++; reform_and_rewrite_tuple(tuple2, srcrel, rws); } } } MemoryContextSwitchTo(oldcxt); const char *nspname = get_namespace_name(RelationGetNamespace(srcrel)); ereport(DEBUG1, (errmsg("\"%s.%s\": found %.0f removable, %.0f nonremovable row versions", nspname, RelationGetRelationName(srcrel), tups_vacuumed, num_tuples), errdetail("%.0f dead row versions cannot be removed yet.", tups_recently_dead))); table_endscan(scan); ExecDropSingleTupleTableSlot(srcslot); FreeExecutorState(estate); return num_tuples; } /* * Split a relation into "split_factor" pieces. */ static void split_relation(Relation rel, SplitPoint *sp, unsigned int split_factor, SplitRelationInfo *split_relations) { char relpersistence = rel->rd_rel->relpersistence; SplitContext scontext = { .rel = rel, .split_factor = split_factor, .rws = palloc0(sizeof(RelationWriteState) * split_factor), .sp = sp, .rws_index = -1, }; compute_rel_vacuum_cutoffs(scontext.rel, &scontext.cutoffs); for (unsigned int i = 0; i < split_factor; i++) { SplitRelationInfo *sri = &split_relations[i]; Oid write_relid = sri->relid; if (sri->heap_swap) { write_relid = make_new_heap(RelationGetRelid(rel), rel->rd_rel->reltablespace, rel->rd_rel->relam, relpersistence, AccessExclusiveLock); } relation_split_info_init(&scontext.rws[i], rel, write_relid, &scontext.cutoffs); } DEBUG_WAITPOINT("split_chunk_before_tuple_routing"); copy_tuples_for_split(&scontext); table_close(rel, NoLock); for (unsigned int i = 0; i < split_factor; i++) { RelationWriteState *rws = &scontext.rws[i]; SplitRelationInfo *sri = &split_relations[i]; ReindexParams reindex_params = { 0 }; int reindex_flags = REINDEX_REL_SUPPRESS_INDEX_USE; Oid write_relid = RelationGetRelid(rws->targetrel); Ensure(relpersistence == RELPERSISTENCE_PERMANENT, "only permanent chunks can be split"); reindex_flags |= REINDEX_REL_FORCE_INDEXES_PERMANENT; /* Save stats before cleaning up rewrite state */ memcpy(&sri->stats, &rws->stats, sizeof(sri->stats)); relation_split_info_cleanup(rws, TABLE_INSERT_SKIP_FSM); /* * Only reindex new chunks. Existing chunk will be reindexed during * the heap swap. */ if (sri->heap_swap) { /* Finally, swap the heap of the chunk that we split so that it only * contains the tuples for its new partition boundaries. AccessExclusive * lock is held during the swap. */ finish_heap_swap(sri->relid, write_relid, false, /* system catalog */ false /* swap toast by content */, true, /* check constraints */ true, /* internal? */ scontext.cutoffs.FreezeLimit, scontext.cutoffs.MultiXactCutoff, relpersistence); } else { reindex_relation_compat(NULL, sri->relid, reindex_flags, &reindex_params); } } pfree(scontext.rws); } static void compute_compression_size_stats_fraction(Form_compression_chunk_size ccs, double fraction) { ccs->compressed_heap_size = (int64) rint((double) ccs->compressed_heap_size * fraction); ccs->uncompressed_heap_size = (int64) rint((double) ccs->uncompressed_heap_size * fraction); ccs->uncompressed_index_size = (int64) rint((double) ccs->uncompressed_index_size * fraction); ccs->compressed_index_size = (int64) rint((double) ccs->compressed_index_size * fraction); ccs->uncompressed_toast_size = (int64) rint((double) ccs->uncompressed_toast_size * fraction); ccs->compressed_toast_size = (int64) rint((double) ccs->compressed_toast_size * fraction); ccs->numrows_frozen_immediately = (int64) rint((double) ccs->numrows_frozen_immediately * fraction); ccs->numrows_pre_compression = (int64) rint((double) ccs->numrows_pre_compression * fraction); ccs->numrows_post_compression = (int64) rint((double) ccs->numrows_post_compression * fraction); } static void update_compression_stats_for_split(const SplitRelationInfo *split_relations, const SplitRelationInfo *compressed_split_relations, int split_factor) { double total_tuples = 0; Assert(split_factor > 1); /* * Set the new chunk status and calculate the total amount of tuples * (compressed and non-compressed), which is used to calculated the * fraction of data each new partition received. */ for (int i = 0; i < split_factor; i++) { const SplitRelationInfo *sri = &split_relations[i]; const SplitRelationInfo *csri = &compressed_split_relations[i]; Chunk *chunk = ts_chunk_get_by_relid(sri->relid, true); if (sri->stats.tuples_written > 0) ts_chunk_set_partial(chunk); else ts_chunk_clear_status(chunk, CHUNK_STATUS_COMPRESSED_PARTIAL); total_tuples += sri->stats.tuples_alive + csri->stats.tuples_in_segments; } /* * Get the existing stats for the original chunk. The stats will be split * across the resulting new chunks. */ FormData_compression_chunk_size ccs; ts_compression_chunk_size_get(split_relations[0].chunk_id, &ccs); for (int i = 0; i < split_factor; i++) { const SplitRelationInfo *sri = &split_relations[i]; const SplitRelationInfo *csri = &compressed_split_relations[i]; FormData_compression_chunk_size new_ccs; /* Calculate the fraction of compressed and non-compressed data received * by the first partition (chunk) */ double fraction = 0.0; if (total_tuples > 0) fraction = (sri->stats.tuples_alive + csri->stats.tuples_in_segments) / total_tuples; memcpy(&new_ccs, &ccs, sizeof(ccs)); compute_compression_size_stats_fraction(&new_ccs, fraction); if (sri->heap_swap) { ts_compression_chunk_size_update(sri->chunk_id, &new_ccs); } else { /* The new partition (chunk) doesn't have stats so create new. */ RelationSize relsize = { .heap_size = new_ccs.uncompressed_heap_size, .index_size = new_ccs.uncompressed_index_size, .toast_size = new_ccs.uncompressed_toast_size, }; RelationSize compressed_relsize = { .heap_size = new_ccs.compressed_heap_size, .index_size = new_ccs.compressed_index_size, .toast_size = new_ccs.compressed_toast_size, }; compression_chunk_size_catalog_insert(sri->chunk_id, &relsize, csri->chunk_id, &compressed_relsize, new_ccs.numrows_pre_compression, new_ccs.numrows_post_compression, new_ccs.numrows_frozen_immediately); } } } /* * Update the chunk stats for the split. Also set the chunk state (partial or * non-partial) and reltuples in pg_class. * * To calculate new compression chunk size stats, the existing stats are * simply split across the result partitions based on the fraction of data * they received. New stats are not calculated since the pre-compression sizes * for the split relations are not known (it would require decompression and * then measuring the disk usage). The advantage of splitting the stats is * that the total size stats is the the same after the split as they were * before the split. */ static void update_chunk_stats_for_split(const SplitRelationInfo *split_relations, const SplitRelationInfo *compressed_split_relations, int split_factor) { if (compressed_split_relations) update_compression_stats_for_split(split_relations, compressed_split_relations, split_factor); /* * Update reltuples in pg_class. The reltuples are normally updated on * reindex, so this update only matters in case of no indexes. */ Relation relRelation = table_open(RelationRelationId, RowExclusiveLock); for (int i = 0; i < split_factor; i++) { const SplitRelationInfo *sri = &split_relations[i]; Relation rel; double ntuples = sri->stats.tuples_alive; rel = table_open(sri->relid, AccessShareLock); update_relstats(relRelation, rel, ntuples); table_close(rel, NoLock); } table_close(relRelation, RowExclusiveLock); } /* * Split a chunk along a given dimension and split point. * * The column/dimension and "split at" point are optional. If these arguments * are not specified, the chunk is split in two equal ranges based on the * primary partitioning column. * * The split is done using the table rewrite approach used by the PostgreSQL * CLUSTER code (also used for VACUUM FULL). It uses the rewrite module to * retain the visibility information of tuples, and also transferring (old) * deleted or updated tuples that are still visible to concurrent transactions * reading an older snapshot. Completely dead tuples are garbage collected. * * The advantage of the rewrite approach is that it is fully MVCC compliant * and ensures the result relations have minimal garbage after the split. Note * that locks don't fully protect against visibility issues since a concurrent * transaction can be pinned to an older snapshot while not (yet) holding any * locks on relations (chunks and hypertables) being split. */ Datum chunk_split_chunk(PG_FUNCTION_ARGS) { Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); const Chunk *chunk; Relation srcrel; chunk = ts_chunk_get_by_relid_locked(relid, AccessExclusiveLock, true); /* Chunk already locked, so use NoLock */ srcrel = table_open(relid, NoLock); if (srcrel->rd_rel->relkind != RELKIND_RELATION) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot split non-table relations"))); Oid amoid = srcrel->rd_rel->relam; if (amoid != HEAP_TABLE_AM_OID) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("access method \"%s\" is not supported for split", get_am_name(amoid)))); /* Only owner is allowed to split */ if (!object_ownercheck(RelationRelationId, relid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(srcrel->rd_rel->relkind), get_rel_name(relid)); /* Lock toast table to prevent it from being concurrently vacuumed */ if (srcrel->rd_rel->reltoastrelid) LockRelationOid(srcrel->rd_rel->reltoastrelid, AccessExclusiveLock); /* * Check for active uses of the relation in the current transaction, * including open scans and pending AFTER trigger events. */ CheckTableNotInUse(srcrel, "split_chunk"); if (chunk->fd.osm_chunk) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot split OSM chunks"))); if (ts_chunk_is_frozen(chunk)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot split frozen chunk \"%s.%s\" scheduled for tiering", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)), errhint("Untier the chunk before splitting it."))); Cache *hcache; const Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); const Dimension *dim = hyperspace_get_open_dimension(ht->space, 0); Ensure(dim, "no primary dimension for chunk"); if (ht->fd.num_dimensions > 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot split chunk in multi-dimensional hypertable"))); NameData splitdim_name; namestrcpy(&splitdim_name, NameStr(dim->fd.column_name)); Oid splitdim_type = ts_dimension_get_partition_type(dim); Oid splitcolumn_type = dim->fd.column_type; Datum split_at_datum; bool have_split_at = false; /* Check split_at argument */ if (!PG_ARGISNULL(1)) { Oid argtype = get_fn_expr_argtype(fcinfo->flinfo, 1); Datum arg = PG_GETARG_DATUM(1); if (argtype == UNKNOWNOID) { Oid infuncid = InvalidOid; Oid typioparam; getTypeInputInfo(splitdim_type, &infuncid, &typioparam); switch (get_func_nargs(infuncid)) { case 1: /* Functions that take one input argument, e.g., the Date function */ split_at_datum = OidFunctionCall1(infuncid, arg); break; case 3: /* Timestamp functions take three input arguments */ split_at_datum = OidFunctionCall3(infuncid, arg, ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1)); break; default: /* Shouldn't be any time types with other number of args */ Ensure(false, "invalid type for split_at"); pg_unreachable(); } argtype = splitdim_type; } else split_at_datum = arg; if (argtype != splitcolumn_type) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid type '%s' for split_at argument", format_type_be(argtype)), errdetail("The argument type must match the dimension \"%s\"", NameStr(dim->fd.column_name)))); have_split_at = true; } /* Serialize chunk creation around the root hypertable. NOTE: also taken * in ts_chunk_find_or_create_without_cuts() below. */ LockRelationOid(ht->main_table_relid, ShareUpdateExclusiveLock); /* * Find the existing partition slice for the chunk being split. */ DimensionSlice *slice = NULL; Hypercube *new_cube = ts_hypercube_copy(chunk->cube); for (int i = 0; i < new_cube->num_slices; i++) { DimensionSlice *curr_slice = new_cube->slices[i]; if (curr_slice->fd.dimension_id == dim->fd.id) { slice = curr_slice; break; } } Ensure(slice, "no chunk slice for dimension %s", NameStr(dim->fd.column_name)); /* * Pick split point and calculate new ranges. If no split point is given * by the user, then split in the middle. */ int64 interval_range = slice->fd.range_end - slice->fd.range_start; int64 split_at = 0; if (have_split_at) { Datum dim_datum; if (NULL != dim->partitioning) dim_datum = ts_partitioning_func_apply(dim->partitioning, C_COLLATION_OID, split_at_datum); else dim_datum = split_at_datum; split_at = ts_time_value_to_internal(dim_datum, splitdim_type); /* * Check that the split_at value actually produces a valid split. Note * that range_start is inclusive while range_end is non-inclusive. The * split_at value needs to produce partition ranges of at least length * 1. */ if (split_at < (slice->fd.range_start + 1) || split_at > (slice->fd.range_end - 2)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("cannot split chunk at %s", ts_datum_to_string(dim_datum, splitdim_type)))); } } else split_at = slice->fd.range_start + (interval_range / 2); elog(DEBUG1, "splitting chunk %s at %s", get_rel_name(relid), ts_internal_to_time_string(split_at, splitdim_type)); const CompressionSettings *compress_settings = ts_compression_settings_get(relid); int64 old_end = slice->fd.range_end; /* Update the slice range for the existing chunk */ slice->fd.range_end = split_at; chunk_update_constraints(chunk, new_cube); /* Update the slice for the new chunk */ slice->fd.range_start = split_at; slice->fd.range_end = old_end; slice->fd.id = 0; /* Must set to 0 to mark as new for it to be created */ /* Make updated constraints visible */ CommandCounterIncrement(); /* Reread hypertable after constraints changed */ ts_cache_release(&hcache); ht = ts_hypertable_cache_get_cache_and_entry(chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); bool created = false; Chunk *new_chunk = ts_chunk_find_or_create_without_cuts(ht, new_cube, NameStr(chunk->fd.schema_name), NULL, InvalidOid, &created); Ensure(created, "could not create chunk for split"); Assert(new_chunk); Chunk *new_compressed_chunk = NULL; if (compress_settings != NULL) { Hypertable *ht_compressed = ts_hypertable_get_by_id(ht->fd.compressed_hypertable_id); new_compressed_chunk = create_compress_chunk(ht_compressed, new_chunk, InvalidOid); ts_trigger_create_all_on_chunk(new_compressed_chunk); ts_chunk_set_compressed_chunk(new_chunk, new_compressed_chunk->fd.id); } CommandCounterIncrement(); DEBUG_WAITPOINT("split_chunk_before_tuple_routing"); SplitPoint sp = { .point = split_at, .dim = hyperspace_get_open_dimension(ht->space, 0), .route_next_tuple = route_next_non_compressed_tuple, }; /* * Array of the heap Oids of the resulting relations. Those relations that * will get a heap swap (i.e., the original chunk) has heap_swap set to * true. */ SplitRelationInfo split_relations[SPLIT_FACTOR] = { [0] = { .relid = relid, .chunk_id = chunk->fd.id, .heap_swap = true }, [1] = { .relid = new_chunk->table_id, .chunk_id = new_chunk->fd.id, .heap_swap = false } }; SplitRelationInfo csplit_relations[SPLIT_FACTOR] = {}; SplitRelationInfo *compressed_split_relations = NULL; /* Split and rewrite the compressed relation first, if one exists. */ if (new_compressed_chunk) { int orderby_pos = ts_array_position(compress_settings->fd.orderby, NameStr(splitdim_name)); Ensure(orderby_pos > 0, "primary dimension \"%s\" is not in compression settings", NameStr(splitdim_name)); /* * Get the attribute numbers for the primary dimension's min and max * values in the compressed relation. We'll use these to get the time * range of compressed segments in order to route segments to the * right result chunk. */ const char *min_attname = column_segment_min_name(orderby_pos); const char *max_attname = column_segment_max_name(orderby_pos); CompressedSplitPoint csp = { .base = { .point = split_at, .dim = hyperspace_get_open_dimension(ht->space, 0), .route_next_tuple = route_next_compressed_tuple, }, .attnum_min = get_attnum(compress_settings->fd.compress_relid, min_attname), .attnum_max = get_attnum(compress_settings->fd.compress_relid, max_attname), .attnum_count = get_attnum(compress_settings->fd.compress_relid, COMPRESSION_COLUMN_METADATA_COUNT_NAME), .noncompressed_tupdesc = CreateTupleDescCopy(RelationGetDescr(srcrel)), }; csplit_relations[0] = (SplitRelationInfo){ .relid = compress_settings->fd.compress_relid, .chunk_id = chunk->fd.compressed_chunk_id, .heap_swap = true }; csplit_relations[1] = (SplitRelationInfo){ .relid = new_compressed_chunk->table_id, .chunk_id = new_chunk->fd.compressed_chunk_id, .heap_swap = false }; Relation compressed_rel = table_open(compress_settings->fd.compress_relid, AccessExclusiveLock); compressed_split_relations = csplit_relations; split_relation(compressed_rel, &csp.base, SPLIT_FACTOR, compressed_split_relations); } /* Now split the non-compressed relation */ split_relation(srcrel, &sp, SPLIT_FACTOR, split_relations); ts_cache_release(&hcache); /* Update stats after split is done */ update_chunk_stats_for_split(split_relations, compressed_split_relations, SPLIT_FACTOR); DEBUG_WAITPOINT("split_chunk_at_end"); PG_RETURN_VOID(); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunkwise_agg.c����������������������������������������������������������0000664�0000000�0000000�00000054366�15100345067�0020444�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <optimizer/appendinfo.h> #include <optimizer/cost.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/prep.h> #include <optimizer/tlist.h> #include "chunkwise_agg.h" #include "gapfill.h" #include "guc.h" #include "import/planner.h" #include "nodes/chunk_append/chunk_append.h" #include "nodes/columnar_scan/columnar_scan.h" #include "planner.h" /* Helper function to find the first node of the provided type in the pathlist of the relation */ static Node * find_node(const RelOptInfo *relation, NodeTag type) { ListCell *lc; foreach (lc, relation->pathlist) { Node *node = lfirst(lc); if (nodeTag(node) == type) return node; } return NULL; } /* Check if the relation already has a min/max path */ static bool has_min_max_agg_path(const RelOptInfo *relation) { return find_node(relation, T_MinMaxAggPath) != NULL; } /* * Get an an existing aggregation path for the given relation or NULL if no aggregation path exists. */ static AggPath * get_existing_agg_path(const RelOptInfo *relation) { Node *node = find_node(relation, T_AggPath); return node ? castNode(AggPath, node) : NULL; } /* * Get all subpaths from a Append, MergeAppend, or ChunkAppend path */ static void get_subpaths_from_append_path(Path *path, List **subpaths, Path **append, Path **gather) { if (IsA(path, AppendPath)) { AppendPath *append_path = castNode(AppendPath, path); *subpaths = append_path->subpaths; *append = path; return; } if (IsA(path, MergeAppendPath)) { MergeAppendPath *merge_append_path = castNode(MergeAppendPath, path); *subpaths = merge_append_path->subpaths; *append = path; return; } if (ts_is_chunk_append_path(path)) { CustomPath *custom_path = castNode(CustomPath, path); *subpaths = custom_path->custom_paths; *append = path; return; } if (IsA(path, GatherPath)) { *gather = path; get_subpaths_from_append_path(castNode(GatherPath, path)->subpath, subpaths, append, /* gather = */ NULL); return; } if (IsA(path, GatherMergePath)) { *gather = path; get_subpaths_from_append_path(castNode(GatherMergePath, path)->subpath, subpaths, append, /* gather = */ NULL); return; } if (IsA(path, SortPath)) { /* Can see GatherMerge -> Sort -> Partial HashAggregate in parallel plans. */ get_subpaths_from_append_path(castNode(SortPath, path)->subpath, subpaths, append, gather); return; } if (IsA(path, AggPath)) { /* Can see GatherMerge -> Sort -> Partial HashAggregate in parallel plans. */ get_subpaths_from_append_path(castNode(AggPath, path)->subpath, subpaths, append, gather); return; } if (IsA(path, ProjectionPath)) { ProjectionPath *projection = castNode(ProjectionPath, path); get_subpaths_from_append_path(projection->subpath, subpaths, append, gather); return; } /* Aggregation push-down is not supported for other path types so far */ } /* * Copy an AppendPath and set new subpaths. */ static AppendPath * copy_append_path(AppendPath *path, List *subpaths, PathTarget *pathtarget) { AppendPath *newPath = makeNode(AppendPath); memcpy(newPath, path, sizeof(AppendPath)); newPath->subpaths = subpaths; newPath->path.pathtarget = copy_pathtarget(pathtarget); cost_append(newPath); return newPath; } /* * Copy a MergeAppendPath and set new subpaths. */ static MergeAppendPath * copy_merge_append_path(PlannerInfo *root, MergeAppendPath *path, List *subpaths, PathTarget *pathtarget) { MergeAppendPath *newPath = create_merge_append_path(root, path->path.parent, subpaths, path->path.pathkeys, NULL); newPath->path.param_info = path->path.param_info; newPath->path.pathtarget = copy_pathtarget(pathtarget); return newPath; } /* * Copy an append-like path and set new subpaths */ static Path * copy_append_like_path(PlannerInfo *root, Path *path, List *new_subpaths, PathTarget *pathtarget) { if (IsA(path, AppendPath)) { AppendPath *append_path = castNode(AppendPath, path); AppendPath *new_append_path = copy_append_path(append_path, new_subpaths, pathtarget); return &new_append_path->path; } else if (IsA(path, MergeAppendPath)) { MergeAppendPath *merge_append_path = castNode(MergeAppendPath, path); MergeAppendPath *new_merge_append_path = copy_merge_append_path(root, merge_append_path, new_subpaths, pathtarget); return &new_merge_append_path->path; } else if (ts_is_chunk_append_path(path)) { CustomPath *custom_path = castNode(CustomPath, path); ChunkAppendPath *chunk_append_path = (ChunkAppendPath *) custom_path; ChunkAppendPath *new_chunk_append_path = ts_chunk_append_path_copy(chunk_append_path, new_subpaths, pathtarget); return &new_chunk_append_path->cpath.path; } else if (IsA(path, ProjectionPath)) { /* * Projection goes under partial aggregation, so here we can just ignore * it. */ return copy_append_like_path(root, castNode(ProjectionPath, path)->subpath, new_subpaths, pathtarget); } /* Should never happen, already checked by caller */ Ensure(false, "unknown path type"); pg_unreachable(); } /* * Generate a partially sorted aggregated agg path on top of a path */ static AggPath * create_sorted_partial_agg_path(PlannerInfo *root, Path *path, PathTarget *target, double d_num_groups, GroupPathExtraData *extra_data) { Query *parse = root->parse; /* Determine costs for aggregations */ AggClauseCosts *agg_partial_costs = &extra_data->agg_partial_costs; bool is_sorted = pathkeys_contained_in(root->group_pathkeys, path->pathkeys); if (!is_sorted) { path = (Path *) create_sort_path(root, path->parent, path, root->group_pathkeys, -1.0); } AggPath *sorted_agg_path = create_agg_path(root, path->parent, path, target, parse->groupClause ? AGG_SORTED : AGG_PLAIN, AGGSPLIT_INITIAL_SERIAL, #if PG16_LT parse->groupClause, #else root->processed_groupClause, #endif NIL, agg_partial_costs, d_num_groups); return sorted_agg_path; } /* * Generate a partially hashed aggregated add path on top of a path */ static AggPath * create_hashed_partial_agg_path(PlannerInfo *root, Path *path, PathTarget *target, double d_num_groups, GroupPathExtraData *extra_data) { /* Determine costs for aggregations */ AggClauseCosts *agg_partial_costs = &extra_data->agg_partial_costs; AggPath *hash_path = create_agg_path(root, path->parent, path, target, AGG_HASHED, AGGSPLIT_INITIAL_SERIAL, #if PG16_LT root->parse->groupClause, #else root->processed_groupClause, #endif NIL, agg_partial_costs, d_num_groups); return hash_path; } /* * Add partially aggregated subpath */ static void add_partially_aggregated_subpaths(PlannerInfo *root, PathTarget *input_target, PathTarget *partial_grouping_target, double d_num_groups, GroupPathExtraData *extra_data, Path *subpath, List **sorted_paths, List **hashed_paths) { /* Translate targetlist for partition */ AppendRelInfo *appinfo = ts_get_appendrelinfo(root, subpath->parent->relid, false); PathTarget *chunk_grouped_target = copy_pathtarget(partial_grouping_target); chunk_grouped_target->exprs = castNode(List, adjust_appendrel_attrs(root, (Node *) chunk_grouped_target->exprs, /* nappinfos = */ 1, &appinfo)); /* * We might have to project before aggregation. In declarative partitioning * planning, the projection is applied by apply_scanjoin_target_to_path(). */ PathTarget *chunk_target_before_grouping = copy_pathtarget(input_target); chunk_target_before_grouping->exprs = castNode(List, adjust_appendrel_attrs(root, (Node *) chunk_target_before_grouping->exprs, /* nappinfos = */ 1, &appinfo)); /* * Note that we cannot use apply_projection_to_path() here, because it might * modify the targetlist of the projection-capable paths in place, which * would cause a mismatch when these paths are used in another context. * * In case of ColumnarScan path, we can make a copy of it and push the * projection down to it. * * In general, the projection here arises because the pathtarget of the * table scans is determined early based on the reltarget which lists all * used columns in attno order, and the pathtarget before grouping is * computed later and has the grouping columns in front. */ if (ts_is_columnar_scan_path(subpath)) { subpath = (Path *) copy_columnar_scan_path((ColumnarScanPath *) subpath); subpath->pathtarget = chunk_target_before_grouping; } else { subpath = (Path *) create_projection_path(root, subpath->parent, subpath, chunk_target_before_grouping); } if (extra_data->flags & GROUPING_CAN_USE_SORT) { AggPath *agg_path = create_sorted_partial_agg_path(root, subpath, chunk_grouped_target, d_num_groups, extra_data); *sorted_paths = lappend(*sorted_paths, (Path *) agg_path); } if (extra_data->flags & GROUPING_CAN_USE_HASH) { AggPath *agg_path = create_hashed_partial_agg_path(root, subpath, chunk_grouped_target, d_num_groups, extra_data); *hashed_paths = lappend(*hashed_paths, (Path *) agg_path); } } /* * Generate a total aggregation path for partial aggregations. * * The generated paths contain partial aggregations (created by using AGGSPLIT_INITIAL_SERIAL). * These aggregations need to be finished by the caller by adding a node that performs the * AGGSPLIT_FINAL_DESERIAL step. * * The original path can be either parallel or non-parallel aggregation, and the * resulting path will be parallel accordingly. */ static void generate_agg_pushdown_path(PlannerInfo *root, Path *cheapest_total_path, RelOptInfo *input_rel, RelOptInfo *output_rel, RelOptInfo *partially_grouped_rel, PathTarget *grouping_target, PathTarget *partial_grouping_target, double d_num_groups, GroupPathExtraData *extra_data) { /* Get subpaths */ List *subpaths = NIL; Path *top_gather = NULL; Path *top_append = NULL; get_subpaths_from_append_path(cheapest_total_path, &subpaths, &top_append, &top_gather); /* No subpaths available or unsupported append node */ if (subpaths == NIL) { return; } Assert(top_append != NULL); if (list_length(subpaths) < 2) { /* * Doesn't make sense to add per-chunk aggregation paths if there's * only one chunk. */ return; } /* Generate agg paths on top of the append children */ List *sorted_subpaths = NIL; List *hashed_subpaths = NIL; ListCell *lc; foreach (lc, subpaths) { Path *subpath = lfirst(lc); /* Check if we have an append path under an append path (e.g., a partially compressed * chunk. The first append path merges the chunk results. The second append path merges the * uncompressed and the compressed part of the chunk). * * In this case, the partial aggregation needs to be pushed down below the lower * append path. */ List *partially_compressed_paths = NIL; Path *partially_compressed_append = NULL; Path *partially_compressed_gather = NULL; get_subpaths_from_append_path(subpath, &partially_compressed_paths, &partially_compressed_append, &partially_compressed_gather); Assert(partially_compressed_gather == NULL); if (partially_compressed_append != NULL) { List *partially_compressed_sorted = NIL; List *partially_compressed_hashed = NIL; ListCell *lc2; foreach (lc2, partially_compressed_paths) { Path *partially_compressed_path = lfirst(lc2); add_partially_aggregated_subpaths(root, input_rel->reltarget, partial_grouping_target, d_num_groups, extra_data, partially_compressed_path, &partially_compressed_sorted /* Result path */, &partially_compressed_hashed /* Result path */); } if (extra_data->flags & GROUPING_CAN_USE_SORT) { sorted_subpaths = lappend(sorted_subpaths, copy_append_like_path(root, partially_compressed_append, partially_compressed_sorted, partial_grouping_target)); } if (extra_data->flags & GROUPING_CAN_USE_HASH) { hashed_subpaths = lappend(hashed_subpaths, copy_append_like_path(root, partially_compressed_append, partially_compressed_hashed, partial_grouping_target)); } } else { add_partially_aggregated_subpaths(root, input_rel->reltarget, partial_grouping_target, d_num_groups, extra_data, subpath, &sorted_subpaths /* Result paths */, &hashed_subpaths /* Result paths */); } } /* Create new append paths */ if (top_gather == NULL) { /* * The original aggregation plan was non-parallel, so we're creating a * non-parallel plan as well. */ if (sorted_subpaths != NIL) { add_path(partially_grouped_rel, copy_append_like_path(root, top_append, sorted_subpaths, partial_grouping_target)); } if (hashed_subpaths != NIL) { add_path(partially_grouped_rel, copy_append_like_path(root, top_append, hashed_subpaths, partial_grouping_target)); } } else { /* * The cheapest aggregation plan was parallel, so we're creating a * parallel plan as well. */ if (sorted_subpaths != NIL) { add_partial_path(partially_grouped_rel, copy_append_like_path(root, top_append, sorted_subpaths, partial_grouping_target)); } if (hashed_subpaths != NIL) { add_partial_path(partially_grouped_rel, copy_append_like_path(root, top_append, hashed_subpaths, partial_grouping_target)); } } } /* Is the provided path a agg path that uses a sorted or plain agg strategy? */ static bool pg_nodiscard is_path_sorted_or_plain_agg_path(Path *path) { AggPath *agg_path = castNode(AggPath, path); Assert(agg_path->aggstrategy == AGG_SORTED || agg_path->aggstrategy == AGG_PLAIN || agg_path->aggstrategy == AGG_HASHED); return agg_path->aggstrategy == AGG_SORTED || agg_path->aggstrategy == AGG_PLAIN; } /* * Check if this path belongs to a plain or sorted aggregation */ static bool contains_path_plain_or_sorted_agg(Path *path) { List *subpaths = NIL; Path *append = NULL; Path *gather = NULL; get_subpaths_from_append_path(path, &subpaths, &append, &gather); Ensure(subpaths != NIL, "Unable to determine aggregation type"); ListCell *lc; foreach (lc, subpaths) { Path *subpath = lfirst(lc); if (IsA(subpath, AggPath)) return is_path_sorted_or_plain_agg_path(subpath); } /* * No dedicated aggregation nodes found directly underneath the append node. This could be * due to two reasons. * * (1) Only vectorized aggregation is used and we don't have dedicated Aggregation nods. * (2) The query plan uses multi-level appends to keep a certain sorting * - ChunkAppend * - Merge Append * - Agg Chunk 1 * - Agg Chunk 2 * - Merge Append * - Agg Chunk 3 * - Agg Chunk 4 * * in both cases, we use a sorted aggregation node to finalize the partial aggregation and * produce a proper sorting. */ return true; } /* * Replan the aggregation and create a partial aggregation at chunk level and finalize the * aggregation on top of an append node. * * The functionality is inspired by PostgreSQL's create_partitionwise_grouping_paths() function * * Generated aggregation paths: * * Finalize Aggregate * -> Append * -> Partial Aggregation * - Chunk 1 * ... * -> Append of partially compressed chunk 2 * -> Partial Aggregation * -> Scan on uncompressed part of chunk 2 * -> Partial Aggregation * -> Scan on compressed part of chunk 2 * ... * -> Partial Aggregation N * - Chunk N */ void tsl_pushdown_partial_agg(PlannerInfo *root, Hypertable *ht, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra) { Query *parse = root->parse; /* We are only interested in hypertables */ if (!ht) return; /* Perform partial aggregation planning only if there is an aggregation is requested */ if (!parse->hasAggs) return; /* Grouping sets are not supported by the partial aggregation pushdown */ if (parse->groupingSets) return; /* Don't replan aggregation if we already have a MinMaxAggPath (e.g., created by * ts_preprocess_first_last_aggregates) */ if (has_min_max_agg_path(output_rel)) return; Assert(extra != NULL); GroupPathExtraData *extra_data = (GroupPathExtraData *) extra; /* Determine the number of groups from the already planned aggregation */ AggPath *existing_agg_path = get_existing_agg_path(output_rel); if (existing_agg_path == NULL) { return; } /* Skip partial aggregations already created by _timescaledb_functions.partialize_agg */ if (existing_agg_path->aggsplit == AGGSPLIT_INITIAL_SERIAL) return; /* Don't replan aggregation if it contains already partials or non-serializable aggregates */ if (root->hasNonPartialAggs || root->hasNonSerialAggs) return; double d_num_groups = existing_agg_path->numGroups; Assert(d_num_groups > 0); /* Construct partial group agg upper relation */ RelOptInfo *partially_grouped_rel = fetch_upper_rel(root, UPPERREL_PARTIAL_GROUP_AGG, input_rel->relids); partially_grouped_rel->consider_parallel = input_rel->consider_parallel; partially_grouped_rel->consider_startup = input_rel->consider_startup; partially_grouped_rel->reloptkind = input_rel->reloptkind; partially_grouped_rel->serverid = input_rel->serverid; partially_grouped_rel->userid = input_rel->userid; partially_grouped_rel->useridiscurrent = input_rel->useridiscurrent; partially_grouped_rel->fdwroutine = input_rel->fdwroutine; /* Build target list for partial aggregate paths */ PathTarget *grouping_target = output_rel->reltarget; PathTarget *partial_grouping_target = ts_make_partial_grouping_target(root, grouping_target); partially_grouped_rel->reltarget = partial_grouping_target; /* Calculate aggregation costs */ if (!extra_data->partial_costs_set) { /* Init costs */ MemSet(&extra_data->agg_partial_costs, 0, sizeof(AggClauseCosts)); MemSet(&extra_data->agg_final_costs, 0, sizeof(AggClauseCosts)); /* partial phase */ get_agg_clause_costs(root, AGGSPLIT_INITIAL_SERIAL, &extra_data->agg_partial_costs); /* final phase */ get_agg_clause_costs(root, AGGSPLIT_FINAL_DESERIAL, &extra_data->agg_final_costs); extra_data->partial_costs_set = true; } /* * For queries with LIMIT, the aggregated relation can have a path with low * total cost, and a path with low startup cost. We must partialize both, so * loop through the entire pathlist. */ ListCell *lc; foreach (lc, output_rel->pathlist) { Node *path = lfirst(lc); if (!IsA(path, AggPath)) { /* * Shouldn't happen, but here we work with arbitrary paths we don't * control, so it's not an assertion. */ continue; } /* Generate the aggregation pushdown path */ generate_agg_pushdown_path(root, (Path *) path, input_rel, output_rel, partially_grouped_rel, grouping_target, partial_grouping_target, d_num_groups, extra_data); } /* Replan aggregation if we were able to generate partially grouped rel paths */ List *partially_grouped_paths = list_concat(partially_grouped_rel->pathlist, partially_grouped_rel->partial_pathlist); if (partially_grouped_paths == NIL) return; /* Prefer our paths */ output_rel->pathlist = NIL; output_rel->partial_pathlist = NIL; /* * Finalize the created partially aggregated paths by adding a * 'Finalize Aggregate' node on top of them, and adding Sort and Gather * nodes as required. */ AggClauseCosts *agg_final_costs = &extra_data->agg_final_costs; foreach (lc, partially_grouped_paths) { Path *partially_aggregated_path = lfirst(lc); AggStrategy final_strategy; if (contains_path_plain_or_sorted_agg(partially_aggregated_path)) { const bool is_sorted = pathkeys_contained_in(root->group_pathkeys, partially_aggregated_path->pathkeys); if (!is_sorted) { partially_aggregated_path = (Path *) create_sort_path(root, output_rel, partially_aggregated_path, root->group_pathkeys, -1.0); } final_strategy = parse->groupClause ? AGG_SORTED : AGG_PLAIN; } else { final_strategy = AGG_HASHED; } /* * We have to add a Gather or Gather Merge on top of parallel plans. It * goes above the Sort we might have added just before, so that the Sort * is parallelized as well. */ if (partially_aggregated_path->parallel_workers > 0) { double total_groups = partially_aggregated_path->rows * partially_aggregated_path->parallel_workers; if (partially_aggregated_path->pathkeys == NIL) { partially_aggregated_path = (Path *) create_gather_path(root, partially_grouped_rel, partially_aggregated_path, partially_grouped_rel->reltarget, /* required_outer = */ NULL, &total_groups); } else { partially_aggregated_path = (Path *) create_gather_merge_path(root, partially_grouped_rel, partially_aggregated_path, partially_grouped_rel->reltarget, partially_aggregated_path->pathkeys, /* required_outer = */ NULL, &total_groups); } } add_path(output_rel, (Path *) create_agg_path(root, output_rel, partially_aggregated_path, grouping_target, final_strategy, AGGSPLIT_FINAL_DESERIAL, #if PG16_LT parse->groupClause, #else root->processed_groupClause, #endif (List *) parse->havingQual, agg_final_costs, d_num_groups)); } } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/chunkwise_agg.h����������������������������������������������������������0000664�0000000�0000000�00000000666�15100345067�0020443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pathnodes.h> #include "export.h" #include "hypertable.h" void tsl_pushdown_partial_agg(PlannerInfo *root, Hypertable *ht, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra); ��������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/�������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020005�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/CMakeLists.txt�����������������������������������������������0000664�0000000�0000000�00000001052�15100345067�0022543�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/api.c ${CMAKE_CURRENT_SOURCE_DIR}/batch_metadata_builder_bloom1.c ${CMAKE_CURRENT_SOURCE_DIR}/batch_metadata_builder_minmax.c ${CMAKE_CURRENT_SOURCE_DIR}/compression.c ${CMAKE_CURRENT_SOURCE_DIR}/compression_dml.c ${CMAKE_CURRENT_SOURCE_DIR}/compression_scankey.c ${CMAKE_CURRENT_SOURCE_DIR}/compression_storage.c ${CMAKE_CURRENT_SOURCE_DIR}/create.c ${CMAKE_CURRENT_SOURCE_DIR}/recompress.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) add_subdirectory(algorithms) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/README.md����������������������������������������������������0000664�0000000�0000000�00000021275�15100345067�0021273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Compression Algorithms This is a collection of compression algorithms that are used to compress data of different types. The algorithms are optimized for time-series use-cases; many of them assume that adjacent rows will have "similar" values. ## API Each compression algorithm the API is divided into two parts: a _compressor_ and a _decompression iterator_. The compressor is used to compress new data. - `<algorithm name>_compressor_alloc` - creates the compressor - `<algorithm_name>_compressor_append_null` - appends a null - `<algorithm_name>_compressor_append_value` - appends a non-null value - `<agorithm_name>_compressor_finish` - finalizes the compression and returns the compressed data Data can be read back out using the decompression iterator. An iterator can operate backwards or forwards. There is no random access. The api is - `<algorithm_name>_decompression_iterator_from_datum_<forward|reverse>` - create a new DatumIterator in the forward or reverse direction. - a DatumIterator has a function pointer called `try_next` that returns the next `DecompressResult`. A `DecompressResult` can either be a decompressed value datum, null, or a done marker to indicate that the iterator is done. Each decompression algorithm also contains send and recv function to get the external binary representations. `CompressionAlgorithmDefinition` is a structure that defines function pointers to get forward and reverse iterators as well as send and recv functions. The `definitions` array in `compression.c` contains a `CompressionAlgorithmDefinition` for each compression algorithm. ## Base algorithms The `simple8b rle` algorithm is a building block for many of the compression algorithms. It compresses a series of `uint64` values. It compresses the data by packing the values into the least amount of bits necessary for the magnitude of the int values, using run-length-encoding for large numbers of repeated values, A complete description is in the header file. Note that this is a header-only implementation as performance is paramount here as it is used as a primitive in all the other compression algorithms. ## Compression Algorithms ### DeltaDelta for each integer, it takes the delta-of-deltas with the pervious integer, zigzag encodes this deltadelta, then finally simple8b_rle encodes this zigzagged result. This algorithm performs very well when the magnitude of the delta between adjacent values tends not to vary much, and is optimal for fixed rate-of-change. ### Gorilla `gorilla` encodes floats using the Facebook gorilla algorithm. It stores the compressed xors of adjacent values. It is one of the few simple algorithms that compresses floating point numbers reasonably well. ### Dictionary The dictionary mechanism stores data in two parts: a "dictionary" storing each unique value in the dataset (stored as an array, see below) and simple8b_rle compressed list of indexes into the dictionary, ordered by row. This scheme can store any type of data, but will only be a space improvement if the data set is of relatively low cardinality. ### Array The array "compression" method simply stores the data in an array-like structure and does not actually compress it (though TOAST-based compression can be applied on top). It is the compression mechanism used when no other compression mechanism works. It can store any type of data. ### Bool Compressor The bool compressor is a simple compression algorithm that stores boolean values using the simple8b_rle algorithm only, without any additional processing. During decompression it decompresses the data and stores it in memory as a bitmap. The row based iterators then walk through the bitmap. The bool compressor differs from the other compressors in that it stores the last non-value as a place holder for the null values. This is done to make vectorization easier. ### UUID Compressor The uuid compressor is a compression algorithm that aims at storing UUID v7 values compressed as much as possible by taking advantage of the timestamp values being present in the UUID. The first part of the UUID where the timestamp resides is stored using the delta-delta algorithm. The second part of the UUID is stored without compression, as a sequence of uint64 values. The algorithm checks the cardinality of the values in the compressed batch and based on the cardinality it decides wether it is worth to recompress the batch using the dictionary compression algorithm. In that case it recompresses and stores the UUIDs as a dictionary. # Merging chunks while compressing # ## Setup ## Chunks will be merged during compression if we specify the `compress_chunk_time_interval` parameter. This value will be used to merge chunks adjacent on the time dimension if possible. This allows usage of smaller chunk intervals which are rolled into bigger compressed chunks. ## Operation ## Compression itself is altered by changing the destination compressed chunk from a newly created one to an already existing chunk which satisfies the necessary requirements (is adjacent to the compressed chunk and chunk interval can be increased not to go over compress chunk time interval). After compression completes, catalog is updated by dropping the compressed chunk and increasing the chunk interval of the adjacent chunk to include its time dimension slice. Chunk constraints are updated as necessary. ## Compression setup where time dimension is not the first column on order by ## When merging such chunks, due to the nature of sequence number ordering, we will inherently be left with chunks where the sequence numbers are not correctly ordered. In order to mitigate this issue, chunks are recompressed immediately. This has obvious performance implications which might make merging chunks not optimal for certain setups. # Picking default for `segment_by` and `order_by`. We have two functions to determine the columns for `timescaledb.compress_segmentby` and `timescaledb.compress_orderby` . These functions can be called by the UI to give good defaults. They can also be called internally when a hypertable has compression enabled but no values are provided to specify these options. ## `_timescaledb_functions.get_segmentby_defaults` This function determines a segment-by column to use. It returns a JSONB with the following top-level keys: - columns: an array of column names that should be used for segment by. Right now it always returns a single column. - confidence: a number between 0 and 10 (most confident) indicating how sure we are. - message: a message that should be shown to the user to evaluate the result. The intuition is as follows: we use 3 criterias: - We want to pick an "important" column for querying. We measure "importance", in terms of how early the column comes in an index (i.e. leading columns are very important, others less so). If there are no indexes, all columns will be considered if statistics are populated - The column has many rows for the same column value so that the segments will have many rows. We establish that a column will have many values if (i) it is not a dimension and (ii) either statistics tell us so (via `stadistinct` > 1) or, if statistics aren't populated, we check whether the column is a generated identity or serial column. - When we have multiple qualifying rows, we select the column where rows are spread most evenly across the distinct values. Naturally, statistics give us more confidence that the column has enough rows per segment. In this case we break ties by preferring columns from unique indexes. Otherwise, we prefer columns from non-unique indexes (we are less likely to run into a unique column there). Thus, our preference is based on the whether the column is from a unique or regular index as well as the position of the column in the index. Given these preferences, we think ties happened rarely but will be resolved arbitrarily. One final point: a number of tables don't have any indexed columns that aren't dimensions or serial columns. In this case, we have medium confidence that an empty segment by is correct. ## `_timescaledb_functions.get_orderby_defaults` This function determines which order by columns to use. It returns a JSONB with the following top-level keys: - clauses: an array of column names and sort order key words that shold be used for order by. - confidence: a number between 0 and 10 (most confident) indicating how sure we are. - message: a message that should be shown to the user to evaluate the result. The order by is built in three steps: 1) Use the column order in a unique index (removing the segment_by columns). 2) Add any dimension columns 3) Add the first attribute of any other index (to establish min-max filters on those columns). All non-dimension columns are returned without a sort specifier (thus using `ASC` as default). The dimension columns use `DESC`.�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/��������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0022156�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/CMakeLists.txt������������������������������������0000664�0000000�0000000�00000000651�15100345067�0024720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/array.c ${CMAKE_CURRENT_SOURCE_DIR}/datum_serialize.c ${CMAKE_CURRENT_SOURCE_DIR}/deltadelta.c ${CMAKE_CURRENT_SOURCE_DIR}/dictionary.c ${CMAKE_CURRENT_SOURCE_DIR}/gorilla.c ${CMAKE_CURRENT_SOURCE_DIR}/bool_compress.c ${CMAKE_CURRENT_SOURCE_DIR}/null.c ${CMAKE_CURRENT_SOURCE_DIR}/uuid_compress.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/array.c�������������������������������������������0000664�0000000�0000000�00000103177�15100345067�0023451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/tupmacs.h> #include <adts/char_vec.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <common/base64.h> #include <funcapi.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include "array.h" #include "compression/compression.h" #include "datum_serialize.h" #include "simple8b_rle.h" #include "simple8b_rle_bitarray.h" #include "simple8b_rle_bitmap.h" #include "compression/arrow_c_data_interface.h" /* A "compressed" array * uint8 has_nulls: 1 iff this has a nulls bitmap stored before the data * Oid element_type: the element stored by this array * simple8b_rle nulls: optional bitmap of nulls within the array * simple8b_rle sizes: the sizes of each data element * char data[]: the elements of the array */ typedef struct ArrayCompressed { CompressedDataHeaderFields; uint8 has_nulls; uint8 padding[6]; Oid element_type; /* 8-byte alignment sentinel for the following fields */ uint64 alignment_sentinel[FLEXIBLE_ARRAY_MEMBER]; } ArrayCompressed; bool array_compressed_has_nulls(const CompressedDataHeader *header) { const ArrayCompressed *ac = (const ArrayCompressed *) header; return ac->has_nulls; } static void pg_attribute_unused() assertions(void) { ArrayCompressed test_val = { .vl_len_ = { 0 } }; Simple8bRleSerialized test_simple8b = { 0 }; /* make sure no padding bytes make it to disk */ StaticAssertStmt(sizeof(ArrayCompressed) == sizeof(test_val.vl_len_) + sizeof(test_val.compression_algorithm) + sizeof(test_val.has_nulls) + sizeof(test_val.padding) + sizeof(test_val.element_type), "ArrayCompressed wrong size"); StaticAssertStmt(sizeof(ArrayCompressed) == 16, "ArrayCompressed wrong size"); /* Note about alignment: the data[] field stores arbitrary Postgres types using store_att_byval * and fetch_att. For this to work the data must be aligned according to the types alignment * parameter (in CREATE TYPE; valid values are 1,2,4,8 bytes). In order to ease implementation, * we simply align the start of data[] on a MAXALIGN (8-byte) boundary. Individual items in the * array are then aligned as specified by the array element type. See top of array.h header in * Postgres source code since it uses the same trick. Thus, we make sure that all fields * before the alignment sentinel are 8-byte aligned, and also that the two Simple8bRleSerialized * elements before the data element are themselves 8-byte aligned as well. */ StaticAssertStmt(offsetof(ArrayCompressed, alignment_sentinel) % MAXIMUM_ALIGNOF == 0, "variable sized data must be 8-byte aligned"); StaticAssertStmt(sizeof(Simple8bRleSerialized) % MAXIMUM_ALIGNOF == 0, "Simple8bRle data must be 8-byte aligned"); StaticAssertStmt(sizeof(test_simple8b.slots[0]) % MAXIMUM_ALIGNOF == 0, "Simple8bRle variable-length slots must be 8-byte aligned"); } typedef struct ArrayCompressedData { Oid element_type; Simple8bRleSerialized *nulls; /* NULL if no nulls */ Simple8bRleSerialized *sizes; const char *data; Size data_len; } ArrayCompressedData; typedef struct ArrayCompressor { Simple8bRleCompressor nulls; Simple8bRleCompressor sizes; char_vec data; Oid type; DatumSerializer *serializer; bool has_nulls; } ArrayCompressor; typedef struct ExtendedCompressor { Compressor base; ArrayCompressor *internal; Oid element_type; } ExtendedCompressor; typedef struct ArrayDecompressionIterator { DecompressionIterator base; Simple8bRleDecompressionIterator nulls; Simple8bRleDecompressionIterator sizes; const char *data; uint32 num_data_bytes; uint32 data_offset; DatumDeserializer *deserializer; bool has_nulls; } ArrayDecompressionIterator; /****************** *** Compressor *** ******************/ static void array_compressor_append_datum(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = array_compressor_alloc(extended->element_type); array_compressor_append(extended->internal, val); } static void array_compressor_append_null_value(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = array_compressor_alloc(extended->element_type); array_compressor_append_null(extended->internal); } static bool array_compressor_is_full(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = array_compressor_alloc(extended->element_type); Size datum_size_and_align; ArrayCompressor *array_comp = (ArrayCompressor *) extended->internal; if (datum_serializer_value_may_be_toasted(array_comp->serializer)) val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(val)); datum_size_and_align = datum_get_bytes_size(array_comp->serializer, array_comp->data.num_elements, val) - array_comp->data.num_elements; /* If we can't fit new datum in the max size, we are full */ return (datum_size_and_align + array_comp->data.num_elements) > MAX_ARRAY_COMPRESSOR_SIZE_BYTES; } static void * array_compressor_finish_and_reset(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; void *compressed = array_compressor_finish(extended->internal); pfree(extended->internal); extended->internal = NULL; return compressed; } const Compressor array_compressor = { .append_val = array_compressor_append_datum, .append_null = array_compressor_append_null_value, .is_full = array_compressor_is_full, .finish = array_compressor_finish_and_reset, }; Compressor * array_compressor_for_type(Oid element_type) { ExtendedCompressor *compressor = palloc(sizeof(*compressor)); *compressor = (ExtendedCompressor){ .base = array_compressor, .element_type = element_type, }; return &compressor->base; } ArrayCompressor * array_compressor_alloc(Oid type_to_compress) { ArrayCompressor *compressor = palloc(sizeof(*compressor)); compressor->has_nulls = false; simple8brle_compressor_init(&compressor->nulls); simple8brle_compressor_init(&compressor->sizes); char_vec_init(&compressor->data, CurrentMemoryContext, 0); compressor->type = type_to_compress; compressor->serializer = create_datum_serializer(type_to_compress); return compressor; } void array_compressor_append_null(ArrayCompressor *compressor) { compressor->has_nulls = true; simple8brle_compressor_append(&compressor->nulls, 1); } void array_compressor_append(ArrayCompressor *compressor, Datum val) { Size datum_size_and_align; char *start_ptr; simple8brle_compressor_append(&compressor->nulls, 0); if (datum_serializer_value_may_be_toasted(compressor->serializer)) val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(val)); datum_size_and_align = datum_get_bytes_size(compressor->serializer, compressor->data.num_elements, val) - compressor->data.num_elements; simple8brle_compressor_append(&compressor->sizes, datum_size_and_align); /* datum_to_bytes_and_advance will zero any padding bytes, so we need not do so here */ char_vec_reserve(&compressor->data, datum_size_and_align); start_ptr = compressor->data.data + compressor->data.num_elements; compressor->data.num_elements += datum_size_and_align; datum_to_bytes_and_advance(compressor->serializer, start_ptr, &datum_size_and_align, val); Assert(datum_size_and_align == 0); } typedef struct ArrayCompressorSerializationInfo { Simple8bRleSerialized *sizes; Simple8bRleSerialized *nulls; char_vec data; Size total; } ArrayCompressorSerializationInfo; ArrayCompressorSerializationInfo * array_compressor_get_serialization_info(ArrayCompressor *compressor) { ArrayCompressorSerializationInfo *info = palloc(sizeof(*info)); *info = (ArrayCompressorSerializationInfo){ .sizes = simple8brle_compressor_finish(&compressor->sizes), .nulls = compressor->has_nulls ? simple8brle_compressor_finish(&compressor->nulls) : NULL, .data = compressor->data, .total = 0, }; if (info->nulls != NULL) info->total += simple8brle_serialized_total_size(info->nulls); if (info->sizes != NULL) info->total += simple8brle_serialized_total_size(info->sizes); info->total += compressor->data.num_elements; return info; } Size array_compression_serialization_size(ArrayCompressorSerializationInfo *info) { return info->total; } uint32 array_compression_serialization_num_elements(ArrayCompressorSerializationInfo *info) { CheckCompressedData(info->sizes != NULL); return info->sizes->num_elements; } char * bytes_serialize_array_compressor_and_advance(char *dst, PG_USED_FOR_ASSERTS_ONLY Size dst_size, ArrayCompressorSerializationInfo *info) { uint32 sizes_bytes = simple8brle_serialized_total_size(info->sizes); Assert(dst_size == info->total); if (info->nulls != NULL) { uint32 nulls_bytes = simple8brle_serialized_total_size(info->nulls); Assert(dst_size >= nulls_bytes); dst = bytes_serialize_simple8b_and_advance(dst, nulls_bytes, info->nulls); dst_size -= nulls_bytes; } Assert(dst_size >= sizes_bytes); dst = bytes_serialize_simple8b_and_advance(dst, sizes_bytes, info->sizes); dst_size -= sizes_bytes; Assert(dst_size == info->data.num_elements); memcpy(dst, info->data.data, info->data.num_elements); return dst + info->data.num_elements; } static ArrayCompressed * array_compressed_from_serialization_info(ArrayCompressorSerializationInfo *info, Oid element_type) { char *compressed_data; ArrayCompressed *compressed_array; Size compressed_size = sizeof(ArrayCompressed) + info->total; if (!AllocSizeIsValid(compressed_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); compressed_data = palloc0(compressed_size); compressed_array = (ArrayCompressed *) compressed_data; *compressed_array = (ArrayCompressed){ .compression_algorithm = COMPRESSION_ALGORITHM_ARRAY, .has_nulls = info->nulls != NULL, .element_type = element_type, }; SET_VARSIZE(compressed_array->vl_len_, compressed_size); compressed_data += sizeof(ArrayCompressed); compressed_size -= sizeof(ArrayCompressed); bytes_serialize_array_compressor_and_advance(compressed_data, compressed_size, info); return compressed_array; } void * array_compressor_finish(ArrayCompressor *compressor) { ArrayCompressorSerializationInfo *info = array_compressor_get_serialization_info(compressor); if (info->sizes == NULL) return NULL; return array_compressed_from_serialization_info(info, compressor->type); } /****************** *** Decompress *** ******************/ static ArrayCompressedData array_compressed_data_from_bytes(StringInfo serialized_data, Oid element_type, bool has_nulls) { ArrayCompressedData data = { .element_type = element_type }; if (has_nulls) { data.nulls = bytes_deserialize_simple8b_and_advance(serialized_data); } data.sizes = bytes_deserialize_simple8b_and_advance(serialized_data); data.data = serialized_data->data + serialized_data->cursor; data.data_len = serialized_data->len - serialized_data->cursor; return data; } DecompressionIterator * array_decompression_iterator_alloc_forward(StringInfo serialized_data, Oid element_type, bool has_nulls) { ArrayCompressedData data = array_compressed_data_from_bytes(serialized_data, element_type, has_nulls); ArrayDecompressionIterator *iterator = palloc(sizeof(*iterator)); iterator->base.compression_algorithm = COMPRESSION_ALGORITHM_ARRAY; iterator->base.forward = true; iterator->base.element_type = element_type; iterator->base.try_next = array_decompression_iterator_try_next_forward; iterator->has_nulls = data.nulls != NULL; if (iterator->has_nulls) simple8brle_decompression_iterator_init_forward(&iterator->nulls, data.nulls); simple8brle_decompression_iterator_init_forward(&iterator->sizes, data.sizes); iterator->data = data.data; iterator->num_data_bytes = data.data_len; iterator->data_offset = 0; iterator->deserializer = create_datum_deserializer(iterator->base.element_type); return &iterator->base; } DecompressionIterator * tsl_array_decompression_iterator_from_datum_forward(Datum compressed_array, Oid element_type) { void *compressed_data = (void *) PG_DETOAST_DATUM(compressed_array); StringInfoData si = { .data = compressed_data, .len = VARSIZE(compressed_data) }; ArrayCompressed *compressed_array_header = consumeCompressedData(&si, sizeof(ArrayCompressed)); Assert(compressed_array_header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); CheckCompressedData(element_type == compressed_array_header->element_type); return array_decompression_iterator_alloc_forward(&si, compressed_array_header->element_type, compressed_array_header->has_nulls == 1); } extern DecompressResult array_decompression_iterator_try_next_forward(DecompressionIterator *general_iter) { Simple8bRleDecompressResult datum_size; ArrayDecompressionIterator *iter; Datum val; const char *start_pointer; Assert(general_iter->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY && general_iter->forward); iter = (ArrayDecompressionIterator *) general_iter; if (iter->has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_forward(&iter->nulls); if (null.is_done) return (DecompressResult){ .is_done = true, }; if (null.val != 0) return (DecompressResult){ .is_null = true, }; } datum_size = simple8brle_decompression_iterator_try_next_forward(&iter->sizes); if (datum_size.is_done) return (DecompressResult){ .is_done = true, }; CheckCompressedData(iter->data_offset + datum_size.val <= iter->num_data_bytes); start_pointer = iter->data + iter->data_offset; val = bytes_to_datum_and_advance(iter->deserializer, &start_pointer); iter->data_offset += datum_size.val; CheckCompressedData(iter->data + iter->data_offset == start_pointer); return (DecompressResult){ .val = val, }; } /************************** *** Decompress Reverse *** **************************/ DecompressionIterator * tsl_array_decompression_iterator_from_datum_reverse(Datum compressed_array, Oid element_type) { ArrayCompressed *compressed_array_header; ArrayCompressedData array_compressed_data; ArrayDecompressionIterator *iterator = palloc(sizeof(*iterator)); iterator->base.compression_algorithm = COMPRESSION_ALGORITHM_ARRAY; iterator->base.forward = false; iterator->base.element_type = element_type; iterator->base.try_next = array_decompression_iterator_try_next_reverse; void *compressed_data = PG_DETOAST_DATUM(compressed_array); StringInfoData si = { .data = compressed_data, .len = VARSIZE(compressed_data) }; compressed_array_header = consumeCompressedData(&si, sizeof(ArrayCompressed)); Assert(compressed_array_header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); if (element_type != compressed_array_header->element_type) elog(ERROR, "trying to decompress the wrong type"); array_compressed_data = array_compressed_data_from_bytes(&si, compressed_array_header->element_type, compressed_array_header->has_nulls); iterator->has_nulls = array_compressed_data.nulls != NULL; if (iterator->has_nulls) simple8brle_decompression_iterator_init_reverse(&iterator->nulls, array_compressed_data.nulls); simple8brle_decompression_iterator_init_reverse(&iterator->sizes, array_compressed_data.sizes); iterator->data = array_compressed_data.data; iterator->num_data_bytes = array_compressed_data.data_len; iterator->data_offset = iterator->num_data_bytes; iterator->deserializer = create_datum_deserializer(iterator->base.element_type); return &iterator->base; } static ArrowArray *tsl_bool_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx); static ArrowArray *tsl_text_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx); static ArrowArray *tsl_uuid_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx); /* Pass through to the specialized functions below for BOOL and TEXT */ ArrowArray * tsl_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx) { switch (element_type) { case BOOLOID: return tsl_bool_array_decompress_all(compressed_array, element_type, dest_mctx); case TEXTOID: return tsl_text_array_decompress_all(compressed_array, element_type, dest_mctx); case UUIDOID: return tsl_uuid_array_decompress_all(compressed_array, element_type, dest_mctx); default: elog(ERROR, "unsupported array type %u for bulk decompression", element_type); break; } return NULL; } static ArrowArray * tsl_bool_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == BOOLOID); void *compressed_data = PG_DETOAST_DATUM(compressed_array); StringInfoData si = { .data = compressed_data, .len = VARSIZE(compressed_data) }; ArrayCompressed *header = consumeCompressedData(&si, sizeof(ArrayCompressed)); Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); CheckCompressedData(header->element_type == BOOLOID); Simple8bRleSerialized *nulls_serialized = NULL; if (header->has_nulls) { nulls_serialized = bytes_deserialize_simple8b_and_advance(&si); } Simple8bRleSerialized *sizes_serialized = bytes_deserialize_simple8b_and_advance(&si); const uint32 n_notnull = sizes_serialized->num_elements; const uint32 n_total = header->has_nulls ? nulls_serialized->num_elements : n_notnull; const uint32 n_padded_bits = n_total + 63; const uint32 n_padded_bytes = n_padded_bits / 8; uint64 *validity_bitmap = NULL; uint64 *values = MemoryContextAllocZero(dest_mctx, n_padded_bytes); MemoryContext old_context = MemoryContextSwitchTo(dest_mctx); /* Decompress the nulls */ Simple8bRleBitArray validity_bits = simple8brle_bitarray_decompress(nulls_serialized, /* inverted*/ true); validity_bitmap = validity_bits.data; MemoryContextSwitchTo(old_context); /* Decompress the values using the iterator based decompressor */ { int position = 0; DecompressionIterator *iter = tsl_array_decompression_iterator_from_datum_forward(PointerGetDatum(compressed_data), BOOLOID); for (DecompressResult r = array_decompression_iterator_try_next_forward(iter); !r.is_done; r = array_decompression_iterator_try_next_forward(iter)) { if (!r.is_null) { bool data = DatumGetBool(r.val) == true; if (data) { arrow_set_row_validity(values, position, true); } } ++position; } } ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + (sizeof(void *) * 2)); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = values; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } static ArrowArray * tsl_uuid_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == UUIDOID); void *compressed_data = PG_DETOAST_DATUM(compressed_array); StringInfoData si = { .data = compressed_data, .len = VARSIZE_ANY(compressed_data) }; ArrayCompressed *header = consumeCompressedData(&si, sizeof(ArrayCompressed)); Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); CheckCompressedData(header->element_type == UUIDOID); Simple8bRleSerialized *nulls_serialized = NULL; if (header->has_nulls) { nulls_serialized = bytes_deserialize_simple8b_and_advance(&si); } Simple8bRleSerialized *sizes_serialized = bytes_deserialize_simple8b_and_advance(&si); const uint32 n_notnull = sizes_serialized->num_elements; /* the nulls_serialized test shouldn't be necessary, but clang needs this to pass without * warnings */ const uint32 n_total = (header->has_nulls && nulls_serialized != NULL) ? nulls_serialized->num_elements : n_notnull; const uint32 n_bytes = n_total * 16; const uint64 *restrict compressed_non_null_values = (const uint64 *) (si.data + si.cursor); CheckCompressedData(n_notnull * 16 <= (uint32) (si.len - si.cursor)); uint64 *restrict validity_bitmap = NULL; uint64 *restrict values = MemoryContextAlloc(dest_mctx, n_bytes); MemoryContext old_context = MemoryContextSwitchTo(dest_mctx); /* Decompress the nulls */ Simple8bRleBitArray validity_bits = simple8brle_bitarray_decompress(nulls_serialized, /* inverted*/ true); validity_bitmap = validity_bits.data; MemoryContextSwitchTo(old_context); /* Check the alignment of compressed_non_null_values */ if (((uintptr_t) compressed_non_null_values % 8) == 0) { int position = 0; for (uint32 i = 0; i < n_total; i++) { if (arrow_row_is_valid(validity_bitmap, i)) { /* Copy the 16 bytes of the UUID with simple assignment, because we know it is * aligned */ values[i * 2] = compressed_non_null_values[position * 2]; values[i * 2 + 1] = compressed_non_null_values[position * 2 + 1]; position++; } } } else { int position = 0; for (uint32 i = 0; i < n_total; i++) { if (arrow_row_is_valid(validity_bitmap, i)) { /* Copy the 16 bytes of the UUID with memcpy */ memcpy(&values[i * 2], &compressed_non_null_values[position * 2], 16); position++; } } } ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + (sizeof(void *) * 2)); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = values; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } #define ELEMENT_TYPE uint32 #include "simple8b_rle_decompress_all.h" #undef ELEMENT_TYPE static ArrowArray * tsl_text_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == TEXTOID); void *compressed_data = PG_DETOAST_DATUM(compressed_array); StringInfoData si = { .data = compressed_data, .len = VARSIZE(compressed_data) }; ArrayCompressed *header = consumeCompressedData(&si, sizeof(ArrayCompressed)); Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); CheckCompressedData(header->element_type == TEXTOID); return text_array_decompress_all_serialized_no_header(&si, header->has_nulls, dest_mctx); } ArrowArray * text_array_decompress_all_serialized_no_header(StringInfo si, bool has_nulls, MemoryContext dest_mctx) { Simple8bRleSerialized *nulls_serialized = NULL; if (has_nulls) { nulls_serialized = bytes_deserialize_simple8b_and_advance(si); } Simple8bRleSerialized *sizes_serialized = bytes_deserialize_simple8b_and_advance(si); uint32 n_notnull; const uint32 *sizes = simple8brle_decompress_all_uint32(sizes_serialized, &n_notnull); const uint32 n_total = has_nulls ? nulls_serialized->num_elements : n_notnull; CheckCompressedData(n_total >= n_notnull); uint32 *offsets = (uint32 *) MemoryContextAlloc(dest_mctx, pad_to_multiple(64, sizeof(*offsets) * (n_total + 1))); uint8 *arrow_bodies = (uint8 *) MemoryContextAlloc(dest_mctx, pad_to_multiple(64, si->len - si->cursor)); uint32 offset = 0; for (uint32 i = 0; i < n_notnull; i++) { const void *unaligned = consumeCompressedData(si, sizes[i]); /* * We start reading from the end of previous datum, but this pointer * might be not aligned as required for varlena-4b struct. We have to * align it here. Note that sizes[i] includes the alignment as well in * addition to the varlena size. * * See the corresponding row-by-row code in bytes_to_datum_and_advance(). */ const void *vardata = DatumGetPointer(att_align_pointer(unaligned, TYPALIGN_INT, -1, unaligned)); /* * Check for potentially corrupt varlena headers since we're reading them * directly from compressed data. */ if (VARATT_IS_4B_U(vardata)) { /* * Full varsize must be larger or equal than the header size so that * the calculation of size without header doesn't overflow. */ CheckCompressedData(VARSIZE_4B(vardata) >= VARHDRSZ); } else if (VARATT_IS_1B(vardata)) { /* Can't have a TOAST pointer here. */ CheckCompressedData(!VARATT_IS_1B_E(vardata)); /* * Full varsize must be larger or equal than the header size so that * the calculation of size without header doesn't overflow. */ CheckCompressedData(VARSIZE_1B(vardata) >= VARHDRSZ_SHORT); } else { /* * Can only have an uncompressed datum with 1-byte or 4-byte header * here, no TOAST or compressed data. */ CheckCompressedData(false); } /* * Size of varlena plus alignment must match the size stored in the * sizes array for this element. */ const Datum alignment_bytes = PointerGetDatum(vardata) - PointerGetDatum(unaligned); CheckCompressedData(VARSIZE_ANY(vardata) + alignment_bytes == sizes[i]); const uint32 textlen = VARSIZE_ANY_EXHDR(vardata); memcpy(&arrow_bodies[offset], VARDATA_ANY(vardata), textlen); offsets[i] = offset; CheckCompressedData(offset <= offset + textlen); /* Check for overflow. */ offset += textlen; } offsets[n_notnull] = offset; uint64 *restrict validity_bitmap = NULL; if (has_nulls) { const int validity_bitmap_bytes = sizeof(uint64) * (pad_to_multiple(64, n_total) / 64); validity_bitmap = MemoryContextAlloc(dest_mctx, validity_bitmap_bytes); /* * First, mark all data as valid, we will fill the nulls later if needed. * Note that the validity bitmap size is a multiple of 64 bits. We have to * fill the tail bits with zeros, because the corresponding elements are not * valid. * */ memset(validity_bitmap, 0xFF, validity_bitmap_bytes); if (n_total % 64) { const uint64 tail_mask = ~0ULL >> (64 - n_total % 64); validity_bitmap[n_total / 64] &= tail_mask; } /* * We have decompressed the data with nulls skipped, reshuffle it * according to the nulls bitmap. */ const Simple8bRleBitmap nulls = simple8brle_bitmap_decompress(nulls_serialized); CheckCompressedData(n_notnull + simple8brle_bitmap_num_ones(&nulls) == n_total); int current_notnull_element = n_notnull - 1; for (int i = n_total - 1; i >= 0; i--) { Assert(i >= current_notnull_element); /* * The index of the corresponding offset is higher by one than * the index of the element. The offset[0] is never affected by * this shuffling and is always 0. * Note that unlike the usual null reshuffling in other algorithms, * for offsets, even if all elements are null, the starting offset * is well-defined and we can do this assignment. This case is only * accessible through fuzzing. Through SQL, all-null batches result * in a null compressed value. */ Assert(current_notnull_element + 1 >= 0); offsets[i + 1] = offsets[current_notnull_element + 1]; if (simple8brle_bitmap_get_at(&nulls, i)) { arrow_set_row_validity(validity_bitmap, i, false); } else { Assert(current_notnull_element >= 0); current_notnull_element--; } } Assert(current_notnull_element == -1); } ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + (sizeof(void *) * 3)); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = offsets; buffers[2] = arrow_bodies; result->n_buffers = 3; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } DecompressResult array_decompression_iterator_try_next_reverse(DecompressionIterator *base_iter) { Simple8bRleDecompressResult datum_size; ArrayDecompressionIterator *iter; Datum val; const char *start_pointer; Assert(base_iter->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY && !base_iter->forward); iter = (ArrayDecompressionIterator *) base_iter; if (iter->has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_reverse(&iter->nulls); if (null.is_done) return (DecompressResult){ .is_done = true, }; if (null.val != 0) return (DecompressResult){ .is_null = true, }; } datum_size = simple8brle_decompression_iterator_try_next_reverse(&iter->sizes); if (datum_size.is_done) return (DecompressResult){ .is_done = true, }; Assert((int64) iter->data_offset - (int64) datum_size.val >= 0); iter->data_offset -= datum_size.val; start_pointer = iter->data + iter->data_offset; val = bytes_to_datum_and_advance(iter->deserializer, &start_pointer); return (DecompressResult){ .val = val, }; } /********************* *** send / recv *** *********************/ ArrayCompressorSerializationInfo * array_compressed_data_recv(StringInfo buffer, Oid element_type) { ArrayCompressor *compressor = array_compressor_alloc(element_type); Simple8bRleDecompressionIterator nulls; uint8 has_nulls; DatumDeserializer *deser = create_datum_deserializer(element_type); bool use_binary_recv; uint32 num_elements; uint32 i; has_nulls = pq_getmsgbyte(buffer) != 0; if (has_nulls) simple8brle_decompression_iterator_init_forward(&nulls, simple8brle_serialized_recv(buffer)); use_binary_recv = pq_getmsgbyte(buffer) != 0; /* This is actually the number of not-null elements */ num_elements = pq_getmsgint32(buffer); /* if there are nulls, use that count instead */ if (has_nulls) num_elements = nulls.num_elements; for (i = 0; i < num_elements; i++) { Datum val; if (has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_forward(&nulls); Assert(!null.is_done); if (null.val) { array_compressor_append_null(compressor); continue; } } val = binary_string_to_datum(deser, use_binary_recv ? BINARY_ENCODING : TEXT_ENCODING, buffer); array_compressor_append(compressor, val); } return array_compressor_get_serialization_info(compressor); } void array_compressed_data_send(StringInfo buffer, const char *_serialized_data, Size _data_size, Oid element_type, bool has_nulls) { DecompressResult datum; DatumSerializer *serializer = create_datum_serializer(element_type); BinaryStringEncoding encoding = datum_serializer_binary_string_encoding(serializer); StringInfoData si = { .data = (char *) _serialized_data, .len = _data_size }; ArrayCompressedData array_compressed_data = array_compressed_data_from_bytes(&si, element_type, has_nulls); si.cursor = 0; DecompressionIterator *data_iter = array_decompression_iterator_alloc_forward(&si, element_type, has_nulls); pq_sendbyte(buffer, array_compressed_data.nulls != NULL); if (array_compressed_data.nulls != NULL) simple8brle_serialized_send(buffer, array_compressed_data.nulls); pq_sendbyte(buffer, encoding == BINARY_ENCODING); /* * we do not send data.sizes because the sizes need not be the same once * deserialized, and we will need to recalculate them on recv. We do need * to send the number of elements, which is always the same as the number * of sizes. */ pq_sendint32(buffer, array_compressed_data.sizes->num_elements); for (datum = array_decompression_iterator_try_next_forward(data_iter); !datum.is_done; datum = array_decompression_iterator_try_next_forward(data_iter)) { if (datum.is_null) continue; datum_append_to_binary_string(serializer, encoding, buffer, datum.val); } } /******************** *** SQL Bindings *** ********************/ Datum array_compressed_recv(StringInfo buffer) { uint8 has_nulls; Oid element_type; has_nulls = pq_getmsgbyte(buffer); CheckCompressedData(has_nulls == 0 || has_nulls == 1); element_type = binary_string_get_type(buffer); ArrayCompressorSerializationInfo *info = array_compressed_data_recv(buffer, element_type); CheckCompressedData(info->sizes != NULL); CheckCompressedData(has_nulls == (info->nulls != NULL)); PG_RETURN_POINTER(array_compressed_from_serialization_info(info, element_type)); } void array_compressed_send(CompressedDataHeader *header, StringInfo buffer) { const char *compressed_data = (char *) header; uint32 data_size; ArrayCompressed *compressed_array_header; Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); compressed_array_header = (ArrayCompressed *) header; compressed_data += sizeof(*compressed_array_header); data_size = VARSIZE(compressed_array_header); data_size -= sizeof(*compressed_array_header); pq_sendbyte(buffer, compressed_array_header->has_nulls == true); type_append_to_binary_string(compressed_array_header->element_type, buffer); array_compressed_data_send(buffer, compressed_data, data_size, compressed_array_header->element_type, compressed_array_header->has_nulls); } extern Datum tsl_array_compressor_append(PG_FUNCTION_ARGS) { ArrayCompressor *compressor = (ArrayCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); MemoryContext agg_context; MemoryContext old_context; if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "tsl_array_compressor_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (compressor == NULL) { Oid type_to_compress = get_fn_expr_argtype(fcinfo->flinfo, 1); compressor = array_compressor_alloc(type_to_compress); } if (PG_ARGISNULL(1)) array_compressor_append_null(compressor); else array_compressor_append(compressor, PG_GETARG_DATUM(1)); MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(compressor); } extern Datum tsl_array_compressor_finish(PG_FUNCTION_ARGS) { ArrayCompressor *compressor = (ArrayCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); void *compressed; if (compressor == NULL) PG_RETURN_NULL(); compressed = array_compressor_finish(compressor); if (compressed == NULL) PG_RETURN_NULL(); PG_RETURN_POINTER(compressed); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/array.h�������������������������������������������0000664�0000000�0000000�00000010416�15100345067�0023447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * The `array` compression method can store any type of data. It simply puts it into an * array-like structure and does not compress it. TOAST-based compression should be applied on top. * * Array compression is are also used as a building block for dictionary compression. */ #include <postgres.h> #include <fmgr.h> #include <utils/memutils.h> #include "compression/compression.h" #define MAX_ARRAY_COMPRESSOR_SIZE_BYTES MaxAllocSize typedef struct StringInfoData StringInfoData; typedef StringInfoData *StringInfo; typedef struct ArrayCompressor ArrayCompressor; typedef struct ArrayCompressed ArrayCompressed; typedef struct ArrayDecompressionIterator ArrayDecompressionIterator; extern const Compressor array_compressor; extern bool array_compressed_has_nulls(const CompressedDataHeader *header); extern Compressor *array_compressor_for_type(Oid element_type); extern ArrayCompressor *array_compressor_alloc(Oid type_to_compress); extern void array_compressor_append_null(ArrayCompressor *compressor); extern void array_compressor_append(ArrayCompressor *compressor, Datum val); extern void *array_compressor_finish(ArrayCompressor *compressor); extern ArrayDecompressionIterator *array_decompression_iterator_alloc(void); extern DecompressionIterator * tsl_array_decompression_iterator_from_datum_forward(Datum compressed_array, Oid element_type); extern DecompressResult array_decompression_iterator_try_next_forward(DecompressionIterator *iter); extern DecompressionIterator * tsl_array_decompression_iterator_from_datum_reverse(Datum compressed_array, Oid element_type); extern DecompressResult array_decompression_iterator_try_next_reverse(DecompressionIterator *iter); /* API for using this as an embedded data structure */ typedef struct ArrayCompressorSerializationInfo ArrayCompressorSerializationInfo; extern ArrayCompressorSerializationInfo * array_compressor_get_serialization_info(ArrayCompressor *compressor); Size array_compression_serialization_size(ArrayCompressorSerializationInfo *info); uint32 array_compression_serialization_num_elements(ArrayCompressorSerializationInfo *info); extern char *bytes_serialize_array_compressor_and_advance(char *dst, Size dst_size, ArrayCompressorSerializationInfo *info); extern DecompressionIterator *array_decompression_iterator_alloc_forward(StringInfo serialized_data, Oid element_type, bool has_nulls); extern ArrayCompressorSerializationInfo *array_compressed_data_recv(StringInfo buffer, Oid element_type); extern void array_compressed_data_send(StringInfo buffer, const char *serialized_data, Size data_size, Oid element_type, bool has_nulls); extern Datum array_compressed_recv(StringInfo buffer); extern void array_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern Datum tsl_array_compressor_append(PG_FUNCTION_ARGS); extern Datum tsl_array_compressor_finish(PG_FUNCTION_ARGS); /* Pass through to the specialized functions below for BOOL and TEXT */ ArrowArray *tsl_array_decompress_all(Datum compressed_array, Oid element_type, MemoryContext dest_mctx); ArrowArray *text_array_decompress_all_serialized_no_header(StringInfo si, bool has_nulls, MemoryContext dest_mctx); #define ARRAY_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = tsl_array_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = tsl_array_decompression_iterator_from_datum_reverse, \ .compressed_data_send = array_compressed_send, \ .compressed_data_recv = array_compressed_recv, \ .compressor_for_type = array_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTENDED, \ .decompress_all = tsl_array_decompress_all, \ } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/bool_compress.c�����������������������������������0000664�0000000�0000000�00000034715�15100345067�0025202�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "bool_compress.h" #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "simple8b_rle.h" #include "simple8b_rle_bitarray.h" #include "simple8b_rle_bitmap.h" typedef struct BoolCompressed { CompressedDataHeaderFields; uint8 has_nulls; /* 1 if this has a NULLs bitmap after the values, 0 otherwise */ uint8 padding[2]; /* padding added because of Simple8bRleSerialized format */ char values[FLEXIBLE_ARRAY_MEMBER]; } BoolCompressed; typedef struct BoolDecompressionIterator { DecompressionIterator base; Simple8bRleBitmap values; Simple8bRleBitmap validity_bitmap; int32 position; } BoolDecompressionIterator; typedef struct BoolCompressor { Simple8bRleCompressor values; Simple8bRleCompressor validity_bitmap; bool has_nulls; bool last_value; uint32 num_nulls; } BoolCompressor; typedef struct ExtendedCompressor { Compressor base; BoolCompressor *internal; } ExtendedCompressor; /* * Local helpers */ static void bool_compressor_append_bool(Compressor *compressor, Datum val); static void bool_compressor_append_null_value(Compressor *compressor); static void *bool_compressor_finish_and_reset(Compressor *compressor); const Compressor bool_compressor_initializer = { .append_val = bool_compressor_append_bool, .append_null = bool_compressor_append_null_value, .is_full = NULL, .finish = bool_compressor_finish_and_reset, }; static BoolCompressed *bool_compressed_from_parts(Simple8bRleSerialized *values, Simple8bRleSerialized *validity_bitmap); static void decompression_iterator_init(BoolDecompressionIterator *iter, void *compressed, Oid element_type, bool forward); /* * Compressor framework functions and definitions for the bool_compress algorithm. */ extern BoolCompressor * bool_compressor_alloc(void) { BoolCompressor *compressor = palloc0(sizeof(*compressor)); simple8brle_compressor_init(&compressor->values); simple8brle_compressor_init(&compressor->validity_bitmap); return compressor; } extern void bool_compressor_append_null(BoolCompressor *compressor) { /* * We use parallel bitmaps of same size for validity and values, to support * zero-copy decompression into ArrowArray. When an element is null, * the particular value that goes into the values bitmap doesn't matter, so * we add the last seen value, not to break the RLE sequences. */ compressor->has_nulls = true; simple8brle_compressor_append(&compressor->values, compressor->last_value); simple8brle_compressor_append(&compressor->validity_bitmap, 0); compressor->num_nulls++; } extern void bool_compressor_append_value(BoolCompressor *compressor, bool next_val) { compressor->last_value = next_val; simple8brle_compressor_append(&compressor->values, next_val); simple8brle_compressor_append(&compressor->validity_bitmap, 1); } extern void * bool_compressor_finish(BoolCompressor *compressor) { if (compressor == NULL) return NULL; Simple8bRleSerialized *values = simple8brle_compressor_finish(&compressor->values); if (values == NULL) return NULL; if (compressor->num_nulls == compressor->values.num_elements) return NULL; Simple8bRleSerialized *validity_bitmap = simple8brle_compressor_finish(&compressor->validity_bitmap); BoolCompressed *compressed; compressed = bool_compressed_from_parts(values, compressor->has_nulls ? validity_bitmap : NULL); /* When only nulls are present, we can return NULL */ Assert(compressed == NULL || compressed->compression_algorithm == COMPRESSION_ALGORITHM_BOOL); return compressed; } extern bool bool_compressed_has_nulls(const CompressedDataHeader *header) { const BoolCompressed *ddc = (const BoolCompressed *) header; return ddc->has_nulls; } extern DecompressResult bool_decompression_iterator_try_next_forward(DecompressionIterator *iter) { Assert(iter->compression_algorithm == COMPRESSION_ALGORITHM_BOOL && iter->forward); Assert(iter->element_type == BOOLOID); BoolDecompressionIterator *bool_iter = (BoolDecompressionIterator *) iter; if (bool_iter->position >= bool_iter->values.num_elements) return (DecompressResult){ .is_done = true, }; /* check nulls */ if (bool_iter->validity_bitmap.num_elements > 0) { bool is_null = !simple8brle_bitmap_get_at(&bool_iter->validity_bitmap, bool_iter->position); if (is_null) { bool_iter->position++; return (DecompressResult){ .is_null = true, }; } } bool val = simple8brle_bitmap_get_at(&bool_iter->values, bool_iter->position); bool_iter->position++; return (DecompressResult){ .val = BoolGetDatum(val), }; } extern DecompressionIterator * bool_decompression_iterator_from_datum_forward(Datum bool_compressed, Oid element_type) { BoolDecompressionIterator *iterator = palloc(sizeof(*iterator)); CheckCompressedData(DatumGetPointer(bool_compressed) != NULL); decompression_iterator_init(iterator, (void *) PG_DETOAST_DATUM(bool_compressed), element_type, true); return &iterator->base; } extern DecompressResult bool_decompression_iterator_try_next_reverse(DecompressionIterator *iter) { Assert(iter->compression_algorithm == COMPRESSION_ALGORITHM_BOOL && !iter->forward); Assert(iter->element_type == BOOLOID); BoolDecompressionIterator *bool_iter = (BoolDecompressionIterator *) iter; if (bool_iter->position < 0) return (DecompressResult){ .is_done = true, }; /* check nulls */ if (bool_iter->validity_bitmap.num_elements > 0) { bool is_null = !simple8brle_bitmap_get_at(&bool_iter->validity_bitmap, bool_iter->position); if (is_null) { bool_iter->position--; return (DecompressResult){ .is_null = true, }; } } bool val = simple8brle_bitmap_get_at(&bool_iter->values, bool_iter->position); bool_iter->position--; return (DecompressResult){ .val = BoolGetDatum(val), }; } extern DecompressionIterator * bool_decompression_iterator_from_datum_reverse(Datum bool_compressed, Oid element_type) { BoolDecompressionIterator *iterator = palloc(sizeof(*iterator)); CheckCompressedData(DatumGetPointer(bool_compressed) != NULL); decompression_iterator_init(iterator, (void *) PG_DETOAST_DATUM(bool_compressed), element_type, false); return &iterator->base; } extern void bool_compressed_send(CompressedDataHeader *header, StringInfo buffer) { const BoolCompressed *data = (BoolCompressed *) header; Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_BOOL); pq_sendbyte(buffer, data->has_nulls); simple8brle_serialized_send(buffer, (Simple8bRleSerialized *) data->values); if (data->has_nulls) { Simple8bRleSerialized *validity_bitmap = (Simple8bRleSerialized *) (((char *) data->values) + simple8brle_serialized_total_size( (Simple8bRleSerialized *) data->values)); simple8brle_serialized_send(buffer, validity_bitmap); } } extern Datum bool_compressed_recv(StringInfo buffer) { uint8 has_nulls; Simple8bRleSerialized *values; Simple8bRleSerialized *validity_bitmap = NULL; BoolCompressed *compressed; has_nulls = pq_getmsgbyte(buffer); CheckCompressedData(has_nulls == 0 || has_nulls == 1); values = simple8brle_serialized_recv(buffer); if (has_nulls) validity_bitmap = simple8brle_serialized_recv(buffer); compressed = bool_compressed_from_parts(values, validity_bitmap); PG_RETURN_POINTER(compressed); } extern Compressor * bool_compressor_for_type(Oid element_type) { ExtendedCompressor *compressor = palloc(sizeof(*compressor)); switch (element_type) { case BOOLOID: *compressor = (ExtendedCompressor){ .base = bool_compressor_initializer }; return &compressor->base; default: elog(ERROR, "invalid type for bool compressor \"%s\"", format_type_be(element_type)); } pg_unreachable(); } /* * Cross-module functions for the bool_compress algorithm. */ extern Datum tsl_bool_compressor_append(PG_FUNCTION_ARGS) { MemoryContext old_context; MemoryContext agg_context; BoolCompressor *compressor = (BoolCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "tsl_bool_compressor_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (compressor == NULL) { compressor = bool_compressor_alloc(); if (PG_NARGS() > 2) elog(ERROR, "append expects two arguments"); } if (PG_ARGISNULL(1)) bool_compressor_append_null(compressor); else { bool next_val = PG_GETARG_BOOL(1); bool_compressor_append_value(compressor, next_val); } MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(compressor); } extern Datum tsl_bool_compressor_finish(PG_FUNCTION_ARGS) { BoolCompressor *compressor = PG_ARGISNULL(0) ? NULL : (BoolCompressor *) PG_GETARG_POINTER(0); void *compressed; if (compressor == NULL) PG_RETURN_NULL(); compressed = bool_compressor_finish(compressor); if (compressed == NULL) PG_RETURN_NULL(); PG_RETURN_POINTER(compressed); } extern ArrowArray * bool_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx) { MemoryContext old_context; Simple8bRleBitArray value_bits; Simple8bRleBitArray validity_bits; Simple8bRleSerialized *serialized_values = NULL; Simple8bRleSerialized *serialized_validity_bitmap = NULL; ArrowArray *result = NULL; uint64 *validity_bitmap = NULL; uint64 *decompressed_values = NULL; CheckCompressedData(DatumGetPointer(compressed) != NULL); void *detoasted = PG_DETOAST_DATUM(compressed); StringInfoData si = { .data = detoasted, .len = VARSIZE(compressed) }; BoolCompressed *header = consumeCompressedData(&si, sizeof(BoolCompressed)); Assert(header->has_nulls == 0 || header->has_nulls == 1); Assert(element_type == BOOLOID); serialized_values = bytes_deserialize_simple8b_and_advance(&si); const bool has_nulls = header->has_nulls == 1; if (has_nulls) { serialized_validity_bitmap = bytes_deserialize_simple8b_and_advance(&si); } /* Decompress the values directly to bit arrays */ old_context = MemoryContextSwitchTo(dest_mctx); value_bits = simple8brle_bitarray_decompress(serialized_values, /* inverted*/ false); decompressed_values = value_bits.data; validity_bits = simple8brle_bitarray_decompress(serialized_validity_bitmap, /* inverted*/ false); validity_bitmap = validity_bits.data; MemoryContextSwitchTo(old_context); result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + sizeof(void *) * 2); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = decompressed_values; result->n_buffers = 2; result->buffers = buffers; result->length = value_bits.num_elements; result->null_count = has_nulls ? (result->length - validity_bits.num_ones) : 0; return result; } /* * Local helpers */ static void bool_compressor_append_bool(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = bool_compressor_alloc(); bool_compressor_append_value(extended->internal, DatumGetBool(val) ? true : false); } static void bool_compressor_append_null_value(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = bool_compressor_alloc(); bool_compressor_append_null(extended->internal); } static void * bool_compressor_finish_and_reset(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; void *compressed = NULL; if (extended != NULL && extended->internal != NULL) { compressed = bool_compressor_finish(extended->internal); pfree(extended->internal); extended->internal = NULL; } return compressed; } static BoolCompressed * bool_compressed_from_parts(Simple8bRleSerialized *values, Simple8bRleSerialized *validity_bitmap) { uint32 validity_bitmap_size = 0; Size compressed_size; char *compressed_data; BoolCompressed *compressed; uint32 num_values = values != NULL ? values->num_elements : 0; uint32 values_size = values != NULL ? simple8brle_serialized_total_size(values) : 0; if (num_values == 0) return NULL; if (validity_bitmap != NULL) validity_bitmap_size = simple8brle_serialized_total_size(validity_bitmap); compressed_size = sizeof(BoolCompressed) + values_size + validity_bitmap_size; if (!AllocSizeIsValid(compressed_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); compressed_data = palloc(compressed_size); compressed = (BoolCompressed *) compressed_data; SET_VARSIZE(&compressed->vl_len_, compressed_size); compressed->compression_algorithm = COMPRESSION_ALGORITHM_BOOL; compressed->has_nulls = validity_bitmap_size != 0 ? 1 : 0; compressed_data += sizeof(*compressed); compressed_data = bytes_serialize_simple8b_and_advance(compressed_data, values_size, values); if (compressed->has_nulls == 1 && validity_bitmap != NULL) { CheckCompressedData(validity_bitmap->num_elements == num_values); bytes_serialize_simple8b_and_advance(compressed_data, validity_bitmap_size, validity_bitmap); } return compressed; } static void decompression_iterator_init(BoolDecompressionIterator *iter, void *compressed, Oid element_type, bool forward) { StringInfoData si = { .data = compressed, .len = VARSIZE(compressed) }; BoolCompressed *header = consumeCompressedData(&si, sizeof(BoolCompressed)); Simple8bRleSerialized *values = bytes_deserialize_simple8b_and_advance(&si); Assert(header->has_nulls == 0 || header->has_nulls == 1); Assert(element_type == BOOLOID); const bool has_nulls = header->has_nulls == 1; CheckCompressedData(has_nulls == 0 || has_nulls == 1); *iter = (BoolDecompressionIterator){ .base = { .compression_algorithm = COMPRESSION_ALGORITHM_BOOL, .forward = forward, .element_type = element_type, .try_next = (forward ? bool_decompression_iterator_try_next_forward : bool_decompression_iterator_try_next_reverse) }, .values = { 0 }, .validity_bitmap = { 0 }, .position = 0, }; iter->values = simple8brle_bitmap_decompress(values); if (has_nulls) { Simple8bRleSerialized *validity_bitmap = bytes_deserialize_simple8b_and_advance(&si); iter->validity_bitmap = simple8brle_bitmap_decompress(validity_bitmap); CheckCompressedData(iter->validity_bitmap.num_elements == iter->values.num_elements); } if (!forward) { iter->position = iter->values.num_elements - 1; } } ���������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/bool_compress.h�����������������������������������0000664�0000000�0000000�00000006564�15100345067�0025210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * bool_compress is used to encode boolean values using the simple8b_rle algorithm. * * The bool compressor differs from the other compressors in that it does store a value * even for nulls, which is the last value seen befere the null. With this the bool * compressor always creates a compressed block even for nulls only. * * The boolean compressor represents the boolean values in a batch with two parallel * bitmaps, value bitmap and validity bitmap, like in the Arrow representation. * These bitmaps are compressed with our common bit-packing algorithm. * * The validity bitmap stores a 0 for a null value and a 1 for a non-null value as * required by the Arrow specification. This is the opposite of what the other compression * algorithms do in their nulls bitmaps. */ #include <postgres.h> #include <fmgr.h> #include <lib/stringinfo.h> #include "compression/compression.h" typedef struct BoolCompressor BoolCompressor; typedef struct BoolCompressed BoolCompressed; typedef struct BoolDecompressionIterator BoolDecompressionIterator; /* * Compressor framework functions and definitions for the bool_compress algorithm. */ extern BoolCompressor *bool_compressor_alloc(void); extern void bool_compressor_append_null(BoolCompressor *compressor); extern void bool_compressor_append_value(BoolCompressor *compressor, bool next_val); extern void *bool_compressor_finish(BoolCompressor *compressor); extern bool bool_compressed_has_nulls(const CompressedDataHeader *header); extern DecompressResult bool_decompression_iterator_try_next_forward(DecompressionIterator *iter); extern DecompressionIterator *bool_decompression_iterator_from_datum_forward(Datum bool_compressed, Oid element_type); extern DecompressResult bool_decompression_iterator_try_next_reverse(DecompressionIterator *iter); extern DecompressionIterator *bool_decompression_iterator_from_datum_reverse(Datum bool_compressed, Oid element_type); extern ArrowArray *bool_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx); extern void bool_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern Datum bool_compressed_recv(StringInfo buf); extern Compressor *bool_compressor_for_type(Oid element_type); #define BOOL_COMPRESS_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = bool_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = bool_decompression_iterator_from_datum_reverse, \ .decompress_all = bool_decompress_all, .compressed_data_send = bool_compressed_send, \ .compressed_data_recv = bool_compressed_recv, \ .compressor_for_type = bool_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTERNAL, \ } /* * Cross-module functions for the bool_compress algorithm. */ extern Datum tsl_bool_compressor_append(PG_FUNCTION_ARGS); extern Datum tsl_bool_compressor_finish(PG_FUNCTION_ARGS); ��������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/datum_serialize.c���������������������������������0000664�0000000�0000000�00000027671�15100345067�0025520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ /* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/tupmacs.h> #include <catalog/namespace.h> #include <catalog/pg_type.h> #include <libpq/pqformat.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/lsyscache.h> #include <utils/sortsupport.h> #include <utils/syscache.h> #include <utils/typcache.h> #include <compat/compat.h> #include "datum_serialize.h" #include "src/utils.h" #include <compression/compression.h> typedef struct DatumSerializer { Oid type_oid; bool type_by_val; int16 type_len; char type_align; char type_storage; Oid type_send; Oid type_out; /* lazy load */ bool send_info_set; FmgrInfo send_flinfo; bool use_binary_send; } DatumSerializer; DatumSerializer * create_datum_serializer(Oid type_oid) { DatumSerializer *res = palloc(sizeof(*res)); /* we use the syscache and not the type cache here b/c we need the * send/recv in/out functions that aren't in type cache */ Form_pg_type type; HeapTuple tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid)); if (!HeapTupleIsValid(tup)) elog(ERROR, "cache lookup failed for type %u", type_oid); type = (Form_pg_type) GETSTRUCT(tup); *res = (DatumSerializer){ .type_oid = type_oid, .type_by_val = type->typbyval, .type_len = type->typlen, .type_align = type->typalign, .type_storage = type->typstorage, .type_send = type->typsend, .type_out = type->typoutput, .use_binary_send = OidIsValid(type->typsend), }; ReleaseSysCache(tup); return res; } bool datum_serializer_value_may_be_toasted(DatumSerializer *serializer) { return serializer->type_len == -1; } static inline void load_send_fn(DatumSerializer *serializer) { if (serializer->send_info_set) return; serializer->send_info_set = true; if (serializer->use_binary_send) fmgr_info(serializer->type_send, &serializer->send_flinfo); else fmgr_info(serializer->type_out, &serializer->send_flinfo); } #define TYPE_IS_PACKABLE(typlen, typstorage) ((typlen) == -1 && (typstorage) != 'p') /* Inspired by datum_compute_size in rangetypes.c */ Size datum_get_bytes_size(DatumSerializer *serializer, Size start_offset, Datum val) { Size data_length = start_offset; if (serializer->type_len == -1) { /* varlena */ Pointer ptr = DatumGetPointer(val); if (VARATT_IS_EXTERNAL(ptr)) { /* * Throw error, because we should never get a toasted datum. * Caller should have detoasted it. */ elog(ERROR, "datum should be detoasted before passed to datum_get_bytes_size"); } } if (TYPE_IS_PACKABLE(serializer->type_len, serializer->type_storage) && VARATT_CAN_MAKE_SHORT(DatumGetPointer(val))) { /* * we're anticipating converting to a short varlena header, so adjust * length and don't count any alignment (the case where the Datum is already * in short format is handled by att_align_datum) */ data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val)); } else { data_length = att_align_datum(data_length, serializer->type_align, serializer->type_len, val); data_length = att_addlength_datum(data_length, serializer->type_len, val); } return data_length; } BinaryStringEncoding datum_serializer_binary_string_encoding(DatumSerializer *serializer) { return (serializer->use_binary_send ? BINARY_ENCODING : TEXT_ENCODING); } static void check_allowed_data_len(Size data_length, Size max_size) { if (max_size < data_length) elog(ERROR, "trying to serialize more data than was allocated"); } static inline char * align_and_zero(char *ptr, char type_align, Size *max_size) { char *new_pos = (char *) att_align_nominal(ptr, type_align); if (new_pos != ptr) { Size padding = new_pos - ptr; check_allowed_data_len(padding, *max_size); memset(ptr, 0, padding); *max_size = *max_size - padding; } return new_pos; } /* Inspired by datum_write in rangetypes.c. This reduces the max_size by the data length before * exiting */ char * datum_to_bytes_and_advance(DatumSerializer *serializer, char *start, Size *max_size, Datum datum) { Size data_length; if (serializer->type_by_val) { /* pass-by-value */ start = align_and_zero(start, serializer->type_align, max_size); data_length = serializer->type_len; check_allowed_data_len(data_length, *max_size); /* Data length should be set to something sensible, otherwise an error * will be raised inside store_att_byval, so we assert here to get a * stack. */ Assert(data_length > 0 && data_length <= 8); store_att_byval(start, datum, data_length); } else if (serializer->type_len == -1) { /* varlena */ Pointer val = DatumGetPointer(datum); if (VARATT_IS_EXTERNAL(val)) { /* * Throw error, because we should never get a toast datum. * Caller should have detoasted it. */ elog(ERROR, "datum should be detoasted before passed to datum_to_bytes_and_advance"); data_length = 0; /* keep compiler quiet */ } else if (VARATT_IS_SHORT(val)) { /* no alignment for short varlenas */ data_length = VARSIZE_SHORT(val); check_allowed_data_len(data_length, *max_size); memcpy(start, val, data_length); } else if (TYPE_IS_PACKABLE(serializer->type_len, serializer->type_storage) && VARATT_CAN_MAKE_SHORT(val)) { /* convert to short varlena -- no alignment */ data_length = VARATT_CONVERTED_SHORT_SIZE(val); check_allowed_data_len(data_length, *max_size); SET_VARSIZE_SHORT(start, data_length); memcpy(start + 1, VARDATA(val), data_length - 1); } else { /* full 4-byte header varlena */ start = align_and_zero(start, serializer->type_align, max_size); data_length = VARSIZE(val); check_allowed_data_len(data_length, *max_size); memcpy(start, val, data_length); } } else if (serializer->type_len == -2) { /* cstring ... never needs alignment */ Assert(serializer->type_align == 'c'); data_length = strlen(DatumGetCString(datum)) + 1; check_allowed_data_len(data_length, *max_size); memcpy(start, DatumGetPointer(datum), data_length); } else { /* fixed-length pass-by-reference */ start = align_and_zero(start, serializer->type_align, max_size); Assert(serializer->type_len > 0); data_length = serializer->type_len; check_allowed_data_len(data_length, *max_size); memcpy(start, DatumGetPointer(datum), data_length); } start += data_length; *max_size = *max_size - data_length; return start; } typedef struct DatumDeserializer { bool type_by_val; int16 type_len; char type_align; char type_storage; Oid type_recv; Oid type_in; Oid type_io_param; int32 type_mod; /* lazy load */ bool recv_info_set; FmgrInfo recv_flinfo; bool use_binary_recv; } DatumDeserializer; DatumDeserializer * create_datum_deserializer(Oid type_oid) { DatumDeserializer *res = palloc(sizeof(*res)); /* we use the syscache and not the type cache here b/c we need the * send/recv in/out functions that aren't in type cache */ Form_pg_type type; HeapTuple tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid)); if (!HeapTupleIsValid(tup)) elog(ERROR, "cache lookup failed for type %u", type_oid); type = (Form_pg_type) GETSTRUCT(tup); *res = (DatumDeserializer){ .type_by_val = type->typbyval, .type_len = type->typlen, .type_align = type->typalign, .type_storage = type->typstorage, .type_recv = type->typreceive, .type_in = type->typinput, .type_io_param = getTypeIOParam(tup), .type_mod = type->typtypmod, }; ReleaseSysCache(tup); return res; } static inline void load_recv_fn(DatumDeserializer *des, bool use_binary) { if (des->recv_info_set && des->use_binary_recv == use_binary) return; des->recv_info_set = true; des->use_binary_recv = use_binary; if (des->use_binary_recv) fmgr_info(des->type_recv, &des->recv_flinfo); else fmgr_info(des->type_in, &des->recv_flinfo); } /* Loosely based on `range_deserialize` in rangetypes.c */ Datum bytes_to_datum_and_advance(DatumDeserializer *deserializer, const char **ptr) { Datum res; /* att_align_pointer can handle the case where an unaligned short-varlen follows any other * varlen by detecting padding. padding bytes _must always_ be set to 0, while the first byte of * a varlen header is _never_ 0. This means that if the next byte is non-zero, it must be the * start of a short-varlen, otherwise we need to align the pointer. */ *ptr = (Pointer) att_align_pointer(*ptr, deserializer->type_align, deserializer->type_len, *ptr); if (deserializer->type_len == -1) { /* * Check for potentially corrupt varlena headers since we're reading them * directly from compressed data. We can only have a plain datum * with 1-byte or 4-byte header here, no TOAST or compressed data. */ CheckCompressedData(VARATT_IS_4B_U(*ptr) || (VARATT_IS_1B(*ptr) && !VARATT_IS_1B_E(*ptr))); /* * Full varsize must be larger or equal than the header size so that the * calculation of size without header doesn't overflow. */ CheckCompressedData((VARATT_IS_1B(*ptr) && VARSIZE_1B(*ptr) >= VARHDRSZ_SHORT) || (VARSIZE_4B(*ptr) > VARHDRSZ)); } res = ts_fetch_att(*ptr, deserializer->type_by_val, deserializer->type_len); *ptr = att_addlength_pointer(*ptr, deserializer->type_len, *ptr); return res; } void type_append_to_binary_string(Oid type_oid, StringInfo buffer) { Form_pg_type type_tuple; HeapTuple tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid)); char *namespace_name; if (!HeapTupleIsValid(tup)) elog(ERROR, "cache lookup failed for type %u", type_oid); type_tuple = (Form_pg_type) GETSTRUCT(tup); namespace_name = get_namespace_name(type_tuple->typnamespace); pq_sendstring(buffer, namespace_name); pq_sendstring(buffer, NameStr(type_tuple->typname)); ReleaseSysCache(tup); } Oid binary_string_get_type(StringInfo buffer) { const char *element_type_namespace = pq_getmsgstring(buffer); const char *element_type_name = pq_getmsgstring(buffer); Oid namespace_oid; Oid type_oid; namespace_oid = LookupExplicitNamespace(element_type_namespace, false); type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid, PointerGetDatum(element_type_name), ObjectIdGetDatum(namespace_oid)); CheckCompressedData(OidIsValid(type_oid)); return type_oid; } void datum_append_to_binary_string(DatumSerializer *serializer, BinaryStringEncoding encoding, StringInfo buffer, Datum datum) { load_send_fn(serializer); if (encoding == MESSAGE_SPECIFIES_ENCODING) pq_sendbyte(buffer, serializer->use_binary_send); else if (encoding != datum_serializer_binary_string_encoding(serializer)) elog(ERROR, "incorrect encoding chosen in datum_append_to_binary_string"); if (serializer->use_binary_send) { bytea *output = SendFunctionCall(&serializer->send_flinfo, datum); pq_sendint32(buffer, VARSIZE_ANY_EXHDR(output)); pq_sendbytes(buffer, VARDATA(output), VARSIZE_ANY_EXHDR(output)); } else { char *output = OutputFunctionCall(&serializer->send_flinfo, datum); pq_sendstring(buffer, output); } } Datum binary_string_to_datum(DatumDeserializer *deserializer, BinaryStringEncoding encoding, StringInfo buffer) { Datum res; bool use_binary_recv = false; switch (encoding) { case BINARY_ENCODING: use_binary_recv = true; break; case TEXT_ENCODING: use_binary_recv = false; break; case MESSAGE_SPECIFIES_ENCODING: use_binary_recv = pq_getmsgbyte(buffer) != 0; break; } load_recv_fn(deserializer, use_binary_recv); if (use_binary_recv) { uint32 data_size = pq_getmsgint32(buffer); const char *bytes = pq_getmsgbytes(buffer, data_size); StringInfoData d = { .data = (char *) bytes, .len = data_size, .maxlen = data_size, }; res = ReceiveFunctionCall(&deserializer->recv_flinfo, &d, deserializer->type_io_param, deserializer->type_mod); } else { const char *string = pq_getmsgstring(buffer); res = InputFunctionCall(&deserializer->recv_flinfo, (char *) string, deserializer->type_io_param, deserializer->type_mod); } return res; } �����������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/datum_serialize.h���������������������������������0000664�0000000�0000000�00000003307�15100345067�0025513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <lib/stringinfo.h> /* SERIALIZATION */ typedef struct DatumSerializer DatumSerializer; DatumSerializer *create_datum_serializer(Oid type); bool datum_serializer_value_may_be_toasted(DatumSerializer *serializer); typedef enum { BINARY_ENCODING = 0, TEXT_ENCODING, MESSAGE_SPECIFIES_ENCODING, } BinaryStringEncoding; /* Get the encoding type used by the serializer: either BINARY_ENCODING or TEXT_ENCODING */ BinaryStringEncoding datum_serializer_binary_string_encoding(DatumSerializer *serializer); /* serialize to bytes in memory. */ Size datum_get_bytes_size(DatumSerializer *serializer, Size start_offset, Datum val); char *datum_to_bytes_and_advance(DatumSerializer *serializer, char *start, Size *max_size, Datum datum); /* serialize to a binary string (for send functions) */ void type_append_to_binary_string(Oid type_oid, StringInfo buffer); void datum_append_to_binary_string(DatumSerializer *serializer, BinaryStringEncoding encoding, StringInfo buffer, Datum datum); /* DESERIALIZATION */ typedef struct DatumDeserializer DatumDeserializer; DatumDeserializer *create_datum_deserializer(Oid type); /* deserialization from bytes in memory */ Datum bytes_to_datum_and_advance(DatumDeserializer *deserializer, const char **ptr); /* deserialization from binary strings (for recv functions) */ Datum binary_string_to_datum(DatumDeserializer *deserializer, BinaryStringEncoding encoding, StringInfo buffer); Oid binary_string_get_type(StringInfo buffer); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/deltadelta.c��������������������������������������0000664�0000000�0000000�00000060773�15100345067�0024442�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "deltadelta.h" #include <access/htup_details.h> #include <catalog/pg_aggregate.h> #include <catalog/pg_type.h> #include <common/base64.h> #include <funcapi.h> #include <lib/stringinfo.h> #include <stdbool.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include <utils.h> #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "simple8b_rle.h" #include "simple8b_rle_bitmap.h" static uint64 zig_zag_encode(uint64 value); static uint64 zig_zag_decode(uint64 value); typedef struct DeltaDeltaCompressed { CompressedDataHeaderFields; uint8 has_nulls; /* 1 if this has a NULLs bitmap after deltas, 0 otherwise */ uint8 padding[2]; uint64 last_value; uint64 last_delta; char delta_deltas[FLEXIBLE_ARRAY_MEMBER]; } DeltaDeltaCompressed; static void pg_attribute_unused() assertions(void) { DeltaDeltaCompressed test_val = { .vl_len_ = { 0 } }; /* make sure no padding bytes make it to disk */ StaticAssertStmt(sizeof(DeltaDeltaCompressed) == sizeof(test_val.vl_len_) + sizeof(test_val.compression_algorithm) + sizeof(test_val.has_nulls) + sizeof(test_val.padding) + sizeof(test_val.last_value) + sizeof(test_val.last_delta), "DeltaDeltaCompressed wrong size"); StaticAssertStmt(sizeof(DeltaDeltaCompressed) == 24, "DeltaDeltaCompressed wrong size"); } typedef struct DeltaDeltaDecompressionIterator { DecompressionIterator base; uint64 prev_val; uint64 prev_delta; Simple8bRleDecompressionIterator delta_deltas; Simple8bRleDecompressionIterator nulls; bool has_nulls; } DeltaDeltaDecompressionIterator; typedef struct DeltaDeltaCompressor { uint64 prev_val; uint64 prev_delta; Simple8bRleCompressor delta_delta; Simple8bRleCompressor nulls; bool has_nulls; } DeltaDeltaCompressor; typedef struct ExtendedCompressor { Compressor base; DeltaDeltaCompressor *internal; } ExtendedCompressor; bool deltadelta_compressed_has_nulls(const CompressedDataHeader *header) { const DeltaDeltaCompressed *ddc = (const DeltaDeltaCompressed *) header; return ddc->has_nulls; } static void deltadelta_compressor_append_bool(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetBool(val) ? 1 : 0); } static void deltadelta_compressor_append_int16(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetInt16(val)); } static void deltadelta_compressor_append_int32(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetInt32(val)); } static void deltadelta_compressor_append_int64(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetInt64(val)); } static void deltadelta_compressor_append_date(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetDateADT(val)); } static void deltadelta_compressor_append_timestamp(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetTimestamp(val)); } static void deltadelta_compressor_append_timestamptz(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_value(extended->internal, DatumGetTimestampTz(val)); } static void deltadelta_compressor_append_null_value(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = delta_delta_compressor_alloc(); delta_delta_compressor_append_null(extended->internal); } static void * deltadelta_compressor_finish_and_reset(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; void *compressed = delta_delta_compressor_finish(extended->internal); pfree(extended->internal); extended->internal = NULL; return compressed; } const Compressor deltadelta_bool_compressor = { .append_val = deltadelta_compressor_append_bool, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; const Compressor deltadelta_uint16_compressor = { .append_val = deltadelta_compressor_append_int16, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; const Compressor deltadelta_uint32_compressor = { .append_val = deltadelta_compressor_append_int32, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; const Compressor deltadelta_uint64_compressor = { .append_val = deltadelta_compressor_append_int64, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; const Compressor deltadelta_date_compressor = { .append_val = deltadelta_compressor_append_date, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; const Compressor deltadelta_timestamp_compressor = { .append_val = deltadelta_compressor_append_timestamp, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; const Compressor deltadelta_timestamptz_compressor = { .append_val = deltadelta_compressor_append_timestamptz, .append_null = deltadelta_compressor_append_null_value, .is_full = NULL, .finish = deltadelta_compressor_finish_and_reset, }; Compressor * delta_delta_compressor_for_type(Oid element_type) { ExtendedCompressor *compressor = palloc(sizeof(*compressor)); switch (element_type) { case BOOLOID: *compressor = (ExtendedCompressor){ .base = deltadelta_bool_compressor }; return &compressor->base; case INT2OID: *compressor = (ExtendedCompressor){ .base = deltadelta_uint16_compressor }; return &compressor->base; case INT4OID: *compressor = (ExtendedCompressor){ .base = deltadelta_uint32_compressor }; return &compressor->base; case INT8OID: *compressor = (ExtendedCompressor){ .base = deltadelta_uint64_compressor }; return &compressor->base; case DATEOID: *compressor = (ExtendedCompressor){ .base = deltadelta_date_compressor }; return &compressor->base; case TIMESTAMPOID: *compressor = (ExtendedCompressor){ .base = deltadelta_timestamp_compressor }; return &compressor->base; case TIMESTAMPTZOID: *compressor = (ExtendedCompressor){ .base = deltadelta_timestamptz_compressor }; return &compressor->base; default: elog(ERROR, "invalid type for delta-delta compressor \"%s\"", format_type_be(element_type)); } pg_unreachable(); } Datum tsl_deltadelta_compressor_append(PG_FUNCTION_ARGS) { MemoryContext old_context; MemoryContext agg_context; DeltaDeltaCompressor *compressor = (DeltaDeltaCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "tsl_deltadelta_compressor_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (compressor == NULL) { compressor = delta_delta_compressor_alloc(); if (PG_NARGS() > 2) elog(ERROR, "append expects two arguments"); } if (PG_ARGISNULL(1)) delta_delta_compressor_append_null(compressor); else { int64 next_val = PG_GETARG_INT64(1); delta_delta_compressor_append_value(compressor, next_val); } MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(compressor); } DeltaDeltaCompressor * delta_delta_compressor_alloc(void) { DeltaDeltaCompressor *compressor = palloc0(sizeof(*compressor)); simple8brle_compressor_init(&compressor->delta_delta); simple8brle_compressor_init(&compressor->nulls); return compressor; } static void * delta_delta_set_header_and_advance(uint64 last_value, uint64 last_delta, bool has_nulls, size_t compressed_size, void *dest) { DeltaDeltaCompressed *compressed = (DeltaDeltaCompressed *) dest; SET_VARSIZE(&compressed->vl_len_, compressed_size); compressed->compression_algorithm = COMPRESSION_ALGORITHM_DELTADELTA; compressed->last_value = last_value; compressed->last_delta = last_delta; compressed->has_nulls = has_nulls ? 1 : 0; compressed->padding[0] = 0; compressed->padding[1] = 0; return (char *) compressed + sizeof(*compressed); } size_t delta_delta_compressor_compressed_size(DeltaDeltaCompressor *compressor, size_t *nulls_size_out) { size_t compressed_size = sizeof(DeltaDeltaCompressed); size_t nulls_size_actual; /* If there are no elements, the compressed size is 0 even if there are nulls */ if (compressor->delta_delta.num_elements == 0) { if (nulls_size_out != NULL) *nulls_size_out = 0; return 0; } compressed_size += simple8brle_compressor_compressed_const_size(&compressor->delta_delta); if (compressor->has_nulls) { nulls_size_actual = simple8brle_compressor_compressed_const_size(&compressor->nulls); compressed_size += nulls_size_actual; if (nulls_size_out != NULL) *nulls_size_out = nulls_size_actual; } else if (nulls_size_out != NULL) *nulls_size_out = 0; return compressed_size; } void * delta_delta_compressor_finish(DeltaDeltaCompressor *compressor) { size_t total_size = delta_delta_compressor_compressed_size(compressor, NULL); char *compressed = NULL; if (total_size == 0) return NULL; compressed = palloc(total_size); delta_delta_compressor_finish_into(compressor, compressed); return compressed; } void * delta_delta_compressor_finish_into(DeltaDeltaCompressor *compressor, void *dest) { size_t data_size; size_t nulls_size; size_t compressed_size; char *result = (char *) dest; /* The compressed size includes the header and the nulls */ compressed_size = delta_delta_compressor_compressed_size(compressor, &nulls_size); if (compressed_size == 0) return dest; /* Check if the data size is valid */ data_size = compressed_size - sizeof(DeltaDeltaCompressed) - nulls_size; Assert(compressed_size > (sizeof(DeltaDeltaCompressed) + nulls_size)); result = delta_delta_set_header_and_advance(compressor->prev_val, compressor->prev_delta, compressor->has_nulls, compressed_size, dest); result = simple8brle_compressor_finish_into(&compressor->delta_delta, result, data_size); if (compressor->has_nulls) { Assert(nulls_size > 0); result = simple8brle_compressor_finish_into(&compressor->nulls, result, nulls_size); } return result; } Datum tsl_deltadelta_compressor_finish(PG_FUNCTION_ARGS) { DeltaDeltaCompressor *compressor = PG_ARGISNULL(0) ? NULL : (DeltaDeltaCompressor *) PG_GETARG_POINTER(0); void *compressed; if (compressor == NULL) PG_RETURN_NULL(); compressed = delta_delta_compressor_finish(compressor); if (compressed == NULL) PG_RETURN_NULL(); PG_RETURN_POINTER(compressed); } void delta_delta_compressor_append_null(DeltaDeltaCompressor *compressor) { compressor->has_nulls = true; simple8brle_compressor_append(&compressor->nulls, 1); } void delta_delta_compressor_append_value(DeltaDeltaCompressor *compressor, int64 next_val) { uint64 delta; uint64 delta_delta; uint64 encoded; /* * We perform all arithmetic using unsigned values due to C's overflow rules: * signed integer overflow is undefined behavior, so if we have a very large delta, * this code is without meaning, while unsigned overflow is 2's complement, so even * very large delta work the same as any other */ /* step 1: delta of deltas */ delta = ((uint64) next_val) - compressor->prev_val; delta_delta = delta - compressor->prev_delta; compressor->prev_val = next_val; compressor->prev_delta = delta; /* step 2: ZigZag encode */ encoded = zig_zag_encode(delta_delta); /* step 3: simple8b/RTE */ simple8brle_compressor_append(&compressor->delta_delta, encoded); simple8brle_compressor_append(&compressor->nulls, 0); } /**********************************************************************************/ /**********************************************************************************/ static void int64_decompression_iterator_init_forward(DeltaDeltaDecompressionIterator *iter, void *compressed, Oid element_type) { StringInfoData si = { .data = compressed, .len = VARSIZE(compressed) }; CheckCompressedData(VARSIZE(compressed) >= sizeof(DeltaDeltaCompressed)); CheckCompressedData(((DeltaDeltaCompressed *) compressed)->compression_algorithm == COMPRESSION_ALGORITHM_DELTADELTA); DeltaDeltaCompressed *header = consumeCompressedData(&si, sizeof(DeltaDeltaCompressed)); Simple8bRleSerialized *deltas = bytes_deserialize_simple8b_and_advance(&si); const bool has_nulls = header->has_nulls == 1; CheckCompressedData(has_nulls == 0 || has_nulls == 1); *iter = (DeltaDeltaDecompressionIterator){ .base = { .compression_algorithm = COMPRESSION_ALGORITHM_DELTADELTA, .forward = true, .element_type = element_type, .try_next = delta_delta_decompression_iterator_try_next_forward, }, .prev_val = 0, .prev_delta = 0, .has_nulls = has_nulls, }; simple8brle_decompression_iterator_init_forward(&iter->delta_deltas, deltas); if (has_nulls) { Simple8bRleSerialized *nulls = bytes_deserialize_simple8b_and_advance(&si); simple8brle_decompression_iterator_init_forward(&iter->nulls, nulls); } } static void int64_decompression_iterator_init_reverse(DeltaDeltaDecompressionIterator *iter, void *compressed, Oid element_type) { StringInfoData si = { .data = compressed, .len = VARSIZE(compressed) }; CheckCompressedData(VARSIZE(compressed) >= sizeof(DeltaDeltaCompressed)); CheckCompressedData(((DeltaDeltaCompressed *) compressed)->compression_algorithm == COMPRESSION_ALGORITHM_DELTADELTA); DeltaDeltaCompressed *header = consumeCompressedData(&si, sizeof(DeltaDeltaCompressed)); Simple8bRleSerialized *deltas = bytes_deserialize_simple8b_and_advance(&si); Assert(header->has_nulls == 0 || header->has_nulls == 1); *iter = (DeltaDeltaDecompressionIterator){ .base = { .compression_algorithm = COMPRESSION_ALGORITHM_DELTADELTA, .forward = false, .element_type = element_type, .try_next = delta_delta_decompression_iterator_try_next_reverse, }, .prev_val = header->last_value, .prev_delta = header->last_delta, .has_nulls = header->has_nulls, }; simple8brle_decompression_iterator_init_reverse(&iter->delta_deltas, deltas); if (header->has_nulls) { Simple8bRleSerialized *nulls = bytes_deserialize_simple8b_and_advance(&si); simple8brle_decompression_iterator_init_reverse(&iter->nulls, nulls); } } static inline DecompressResult convert_from_internal(DecompressResultInternal res_internal, Oid element_type) { if (res_internal.is_done || res_internal.is_null) { return (DecompressResult){ .is_done = res_internal.is_done, .is_null = res_internal.is_null, }; } switch (element_type) { case BOOLOID: return (DecompressResult){ .val = BoolGetDatum(res_internal.val), }; case INT8OID: return (DecompressResult){ .val = Int64GetDatum(res_internal.val), }; case INT4OID: return (DecompressResult){ .val = Int32GetDatum(res_internal.val), }; case INT2OID: return (DecompressResult){ .val = Int16GetDatum(res_internal.val), }; case DATEOID: return (DecompressResult){ .val = DateADTGetDatum(res_internal.val), }; case TIMESTAMPTZOID: return (DecompressResult){ .val = TimestampTzGetDatum(res_internal.val), }; case TIMESTAMPOID: return (DecompressResult){ .val = TimestampGetDatum(res_internal.val), }; default: elog(ERROR, "invalid type requested from deltadelta decompression \"%s\"", format_type_be(element_type)); } pg_unreachable(); } static DecompressResultInternal delta_delta_decompression_iterator_try_next_forward_internal(DeltaDeltaDecompressionIterator *iter) { Simple8bRleDecompressResult result; uint64 delta_delta; /* check for a null value */ if (iter->has_nulls) { Simple8bRleDecompressResult result = simple8brle_decompression_iterator_try_next_forward(&iter->nulls); if (result.is_done) return (DecompressResultInternal){ .is_done = true, }; if (result.val != 0) { CheckCompressedData(result.val == 1); return (DecompressResultInternal){ .is_null = true, }; } } result = simple8brle_decompression_iterator_try_next_forward(&iter->delta_deltas); if (result.is_done) return (DecompressResultInternal){ .is_done = true, }; delta_delta = zig_zag_decode(result.val); iter->prev_delta += delta_delta; iter->prev_val += iter->prev_delta; return (DecompressResultInternal){ .val = iter->prev_val, .is_null = false, .is_done = false, }; } DecompressResult delta_delta_decompression_iterator_try_next_forward(DecompressionIterator *iter) { Assert(iter->compression_algorithm == COMPRESSION_ALGORITHM_DELTADELTA && iter->forward); return convert_from_internal(delta_delta_decompression_iterator_try_next_forward_internal( (DeltaDeltaDecompressionIterator *) iter), iter->element_type); } #define ELEMENT_TYPE uint64 #include "simple8b_rle_decompress_all.h" #undef ELEMENT_TYPE /* Functions for bulk decompression. */ #define ELEMENT_TYPE uint16 #include "deltadelta_impl.c" #undef ELEMENT_TYPE #define ELEMENT_TYPE uint32 #include "deltadelta_impl.c" #undef ELEMENT_TYPE #define ELEMENT_TYPE uint64 #include "deltadelta_impl.c" #undef ELEMENT_TYPE ArrowArray * delta_delta_decompress_all(Datum compressed_data, Oid element_type, MemoryContext dest_mctx) { switch (element_type) { case INT8OID: case TIMESTAMPOID: case TIMESTAMPTZOID: return delta_delta_decompress_all_uint64(compressed_data, dest_mctx); case INT4OID: case DATEOID: return delta_delta_decompress_all_uint32(compressed_data, dest_mctx); case INT2OID: return delta_delta_decompress_all_uint16(compressed_data, dest_mctx); default: elog(ERROR, "type '%s' is not supported for deltadelta decompression", format_type_be(element_type)); pg_unreachable(); } } /* Functions for reverse iterator. */ static DecompressResultInternal delta_delta_decompression_iterator_try_next_reverse_internal(DeltaDeltaDecompressionIterator *iter) { Simple8bRleDecompressResult result; uint64 val; uint64 delta_delta; /* check for a null value */ if (iter->has_nulls) { Simple8bRleDecompressResult result = simple8brle_decompression_iterator_try_next_reverse(&iter->nulls); if (result.is_done) return (DecompressResultInternal){ .is_done = true, }; if (result.val != 0) { Assert(result.val == 1); return (DecompressResultInternal){ .is_null = true, }; } } result = simple8brle_decompression_iterator_try_next_reverse(&iter->delta_deltas); if (result.is_done) return (DecompressResultInternal){ .is_done = true, }; val = iter->prev_val; delta_delta = zig_zag_decode(result.val); iter->prev_val -= iter->prev_delta; iter->prev_delta -= delta_delta; return (DecompressResultInternal){ .val = val, }; } DecompressResult delta_delta_decompression_iterator_try_next_reverse(DecompressionIterator *iter) { Assert(iter->compression_algorithm == COMPRESSION_ALGORITHM_DELTADELTA && !iter->forward); return convert_from_internal(delta_delta_decompression_iterator_try_next_reverse_internal( (DeltaDeltaDecompressionIterator *) iter), iter->element_type); } DecompressionIterator * delta_delta_decompression_iterator_from_datum_forward(Datum deltadelta_compressed, Oid element_type) { DeltaDeltaDecompressionIterator *iterator = palloc(sizeof(*iterator)); int64_decompression_iterator_init_forward(iterator, (void *) PG_DETOAST_DATUM(deltadelta_compressed), element_type); return &iterator->base; } DecompressionIterator * delta_delta_decompression_iterator_from_datum_reverse(Datum deltadelta_compressed, Oid element_type) { DeltaDeltaDecompressionIterator *iterator = palloc(sizeof(*iterator)); int64_decompression_iterator_init_reverse(iterator, (void *) PG_DETOAST_DATUM(deltadelta_compressed), element_type); return &iterator->base; } /**********************************************************************************/ /**********************************************************************************/ void deltadelta_compressed_send(CompressedDataHeader *header, StringInfo buffer) { const DeltaDeltaCompressed *data = (DeltaDeltaCompressed *) header; Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_DELTADELTA); pq_sendbyte(buffer, data->has_nulls); pq_sendint64(buffer, data->last_value); pq_sendint64(buffer, data->last_delta); simple8brle_serialized_send(buffer, (Simple8bRleSerialized *) data->delta_deltas); if (data->has_nulls) { Simple8bRleSerialized *nulls = (Simple8bRleSerialized *) (((char *) data->delta_deltas) + simple8brle_serialized_total_size( (Simple8bRleSerialized *) data->delta_deltas)); simple8brle_serialized_send(buffer, nulls); } } Datum deltadelta_compressed_recv(StringInfo buffer) { uint8 has_nulls; uint64 last_value; uint64 last_delta; Simple8bRleSerialized *delta_delta_values; Simple8bRleSerialized *nulls = NULL; DeltaDeltaCompressed *compressed; void *buf_ptr = NULL; int delta_size = 0; int nulls_size = 0; size_t compressed_size = 0; size_t allocated_size = 2 * sizeof(Simple8bRleSerialized) + sizeof(DeltaDeltaCompressed) + (buffer->len - buffer->cursor); compressed = palloc(allocated_size); has_nulls = pq_getmsgbyte(buffer); CheckCompressedData(has_nulls == 0 || has_nulls == 1); last_value = pq_getmsgint64(buffer); last_delta = pq_getmsgint64(buffer); /* Leave space for the header, but we don't yet know the size of the compressed data */ buf_ptr = (char *) compressed + sizeof(DeltaDeltaCompressed); /* Calculate the size of the delta delta values based on the number of bytes read */ delta_size = buffer->cursor; buf_ptr = simple8brle_serialized_recv_into(buffer, buf_ptr, &delta_delta_values); delta_size = buffer->cursor - delta_size; if (has_nulls) { /* Calculate the size of the nulls based on the number of bytes read */ nulls_size = buffer->cursor; buf_ptr = simple8brle_serialized_recv_into(buffer, buf_ptr, &nulls); nulls_size = buffer->cursor - nulls_size; CheckCompressedData(delta_delta_values->num_elements < nulls->num_elements); } compressed_size = sizeof(DeltaDeltaCompressed) + delta_size + nulls_size; if (!AllocSizeIsValid(compressed_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); /* Set header but don't change the buffer pointer */ delta_delta_set_header_and_advance(last_value, last_delta, has_nulls, compressed_size, compressed); PG_RETURN_POINTER(compressed); } /**********************************************************************************/ /**********************************************************************************/ static pg_attribute_always_inline uint64 zig_zag_encode(uint64 value) { // (((uint64)value) << 1) ^ (uint64)(value >> 63); /* since shift is underspecified, we use (value < 0 ? 0xFFFFFFFFFFFFFFFFull : 0) * which compiles to the correct asm, and is well defined */ return (value << 1) ^ (((int64) value) < 0 ? 0xFFFFFFFFFFFFFFFFULL : 0); } static pg_attribute_always_inline uint64 zig_zag_decode(uint64 value) { /* ZigZag turns negative numbers into odd ones, and positive numbers into even ones*/ return (value >> 1) ^ (uint64) - (int64) (value & 1); } �����timescaledb-2.23.0/tsl/src/compression/algorithms/deltadelta.h��������������������������������������0000664�0000000�0000000�00000006761�15100345067�0024444�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * Deltadelta is used to encode integers or integer-like objects (e.g. timestamps). It's input is a * series of integers. first convert that series to a series of delta-of-deltas between * consecutive integers, while storing the first value as well. Given the first value * and the series of delta-of-delta values, it is easy to reconstruct the original series of * integers (assume first delta is 0). * * We now describe how to compress the delta-of-deltas: * First we zigzag encodes the delta-of-deltas * Second, we simple8b_rle encode the zig-zag encoding */ #include <postgres.h> #include <fmgr.h> #include <lib/stringinfo.h> #include "compression/compression.h" typedef struct DeltaDeltaCompressor DeltaDeltaCompressor; typedef struct DeltaDeltaCompressed DeltaDeltaCompressed; typedef struct DeltaDeltaDecompressionIterator DeltaDeltaDecompressionIterator; extern bool deltadelta_compressed_has_nulls(const CompressedDataHeader *header); extern Compressor *delta_delta_compressor_for_type(Oid element_type); extern DeltaDeltaCompressor *delta_delta_compressor_alloc(void); extern void delta_delta_compressor_append_null(DeltaDeltaCompressor *compressor); extern void delta_delta_compressor_append_value(DeltaDeltaCompressor *compressor, int64 next_val); extern void *delta_delta_compressor_finish(DeltaDeltaCompressor *compressor); extern size_t delta_delta_compressor_compressed_size(DeltaDeltaCompressor *compressor, size_t *nulls_size /* out */); extern void *delta_delta_compressor_finish_into(DeltaDeltaCompressor *compressor, void *dest); extern DecompressionIterator * delta_delta_decompression_iterator_from_datum_forward(Datum deltadelta_compressed, Oid element_type); extern DecompressionIterator * delta_delta_decompression_iterator_from_datum_reverse(Datum deltadelta_compressed, Oid element_type); extern DecompressResult delta_delta_decompression_iterator_try_next_forward(DecompressionIterator *iter); extern ArrowArray *delta_delta_decompress_all(Datum compressed_data, Oid element_type, MemoryContext dest_mctx); extern DecompressResult delta_delta_decompression_iterator_try_next_reverse(DecompressionIterator *iter); extern void deltadelta_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern Datum deltadelta_compressed_recv(StringInfo buf); extern Datum tsl_deltadelta_compressor_append(PG_FUNCTION_ARGS); extern Datum tsl_deltadelta_compressor_finish(PG_FUNCTION_ARGS); #define DELTA_DELTA_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = delta_delta_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = delta_delta_decompression_iterator_from_datum_reverse, \ .decompress_all = delta_delta_decompress_all, \ .compressed_data_send = deltadelta_compressed_send, \ .compressed_data_recv = deltadelta_compressed_recv, \ .compressor_for_type = delta_delta_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTERNAL, \ } ���������������timescaledb-2.23.0/tsl/src/compression/algorithms/deltadelta_impl.c���������������������������������0000664�0000000�0000000�00000012161�15100345067�0025447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Decompress the entire batch of deltadelta-compressed rows into an Arrow array. * Specialized for each supported data type. */ #define FUNCTION_NAME_HELPER(X, Y) X##_##Y #define FUNCTION_NAME(X, Y) FUNCTION_NAME_HELPER(X, Y) static ArrowArray * FUNCTION_NAME(delta_delta_decompress_all, ELEMENT_TYPE)(Datum compressed, MemoryContext dest_mctx) { StringInfoData si = { .data = DatumGetPointer(compressed), .len = VARSIZE(compressed) }; DeltaDeltaCompressed *header = consumeCompressedData(&si, sizeof(DeltaDeltaCompressed)); Simple8bRleSerialized *deltas_compressed = bytes_deserialize_simple8b_and_advance(&si); const bool has_nulls = header->has_nulls == 1; Assert(header->has_nulls == 0 || header->has_nulls == 1); /* * Can't use element type here because of zig-zag encoding. The deltas are * computed in uint64, so we can get a delta that is actually larger than * the element type. We can't just truncate the delta either, because it * will lead to broken decompression results. The test case is in * test_delta4(). */ uint32 num_deltas; const uint64 *deltas_zigzag = simple8brle_decompress_all_uint64(deltas_compressed, &num_deltas); Simple8bRleBitmap nulls = { 0 }; if (has_nulls) { Simple8bRleSerialized *nulls_compressed = bytes_deserialize_simple8b_and_advance(&si); nulls = simple8brle_bitmap_decompress(nulls_compressed); } /* * Pad the number of elements to multiple of 64 bytes if needed, so that we * can work in 64-byte blocks. */ #define INNER_LOOP_SIZE_LOG2 3 #define INNER_LOOP_SIZE (1 << INNER_LOOP_SIZE_LOG2) const uint32 n_total = has_nulls ? nulls.num_elements : num_deltas; const uint32 n_total_padded = pad_to_multiple(INNER_LOOP_SIZE, n_total); const uint32 n_notnull = num_deltas; const uint32 n_notnull_padded = pad_to_multiple(INNER_LOOP_SIZE, n_notnull); Assert(n_total_padded >= n_total); Assert(n_notnull_padded >= n_notnull); Assert(n_total >= n_notnull); Assert(n_total <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * We need additional padding at the end of buffer, because the code that * converts the elements to postgres Datum always reads in 8 bytes. */ const int buffer_bytes = n_total_padded * sizeof(ELEMENT_TYPE) + 8; ELEMENT_TYPE *restrict decompressed_values = MemoryContextAlloc(dest_mctx, buffer_bytes); /* Now fill the data w/o nulls. */ ELEMENT_TYPE current_delta = 0; ELEMENT_TYPE current_element = 0; /* * Manual unrolling speeds up this loop by about 10%. clang vectorizes * the zig_zag_decode part, but not the double-prefix-sum part. * * Also tried using SIMD prefix sum from here twice: * https://en.algorithmica.org/hpc/algorithms/prefix/, it's slower. * * Also tried zig-zag decoding in a separate loop, seems to be slightly * slower, around the noise threshold. */ Assert(n_notnull_padded % INNER_LOOP_SIZE == 0); for (uint32 outer = 0; outer < n_notnull_padded; outer += INNER_LOOP_SIZE) { for (uint32 inner = 0; inner < INNER_LOOP_SIZE; inner++) { current_delta += zig_zag_decode(deltas_zigzag[outer + inner]); current_element += current_delta; decompressed_values[outer + inner] = current_element; } } #undef INNER_LOOP_SIZE_LOG2 #undef INNER_LOOP_SIZE uint64 *restrict validity_bitmap = NULL; if (has_nulls) { /* Now move the data to account for nulls, and fill the validity bitmap. */ const int validity_bitmap_bytes = sizeof(uint64) * ((n_total + 64 - 1) / 64); validity_bitmap = MemoryContextAlloc(dest_mctx, validity_bitmap_bytes); /* * First, mark all data as valid, we will fill the nulls later if needed. * Note that the validity bitmap size is a multiple of 64 bits. We have to * fill the tail bits with zeros, because the corresponding elements are not * valid. * */ memset(validity_bitmap, 0xFF, validity_bitmap_bytes); if (n_total % 64) { const uint64 tail_mask = ~0ULL >> (64 - n_total % 64); validity_bitmap[n_total / 64] &= tail_mask; } /* * The number of not-null elements we have must be consistent with the * nulls bitmap. */ CheckCompressedData(n_notnull + simple8brle_bitmap_num_ones(&nulls) == n_total); int current_notnull_element = n_notnull - 1; for (int i = n_total - 1; i >= 0; i--) { Assert(i >= current_notnull_element); if (simple8brle_bitmap_get_at(&nulls, i)) { arrow_set_row_validity(validity_bitmap, i, false); } else { Assert(current_notnull_element >= 0); decompressed_values[i] = decompressed_values[current_notnull_element]; current_notnull_element--; } } Assert(current_notnull_element == -1); } /* Return the result. */ ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + sizeof(void *) * 2); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = decompressed_values; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } #undef FUNCTION_NAME #undef FUNCTION_NAME_HELPER ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/dictionary.c��������������������������������������0000664�0000000�0000000�00000077234�15100345067�0024504�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ /* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <access/tupmacs.h> #include <catalog/namespace.h> #include <catalog/pg_aggregate.h> #include <catalog/pg_type.h> #include <common/base64.h> #include <funcapi.h> #include <lib/stringinfo.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include <utils/typcache.h> #include <utils/uuid.h> #include "array.h" #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "datum_serialize.h" #include "dictionary.h" #include "dictionary_hash.h" #include "simple8b_rle.h" #include "simple8b_rle_bitarray.h" #include "simple8b_rle_bitmap.h" /* * A compression bitmap is stored as * bool has_nulls * padding * Oid element_type: the element stored by this compressed dictionary * uint32 num_distinct: the number of distinct values * simple8b_rle dictionary indexes: array of mappings from row to index into dictionary items * ArrayCompressed simple8b_rle nulls (optional) ArrayCompressed dictionary items */ typedef struct DictionaryCompressed { CompressedDataHeaderFields; uint8 has_nulls; uint8 padding[2]; Oid element_type; uint32 num_distinct; /* 8-byte alignment sentinel for the following fields */ uint64 alignment_sentinel[FLEXIBLE_ARRAY_MEMBER]; } DictionaryCompressed; bool dictionary_compressed_has_nulls(const CompressedDataHeader *header) { const DictionaryCompressed *dc = (const DictionaryCompressed *) header; return dc->has_nulls; } static void pg_attribute_unused() assertions(void) { DictionaryCompressed test_val; /* make sure no padding bytes make it to disk */ StaticAssertStmt(sizeof(DictionaryCompressed) == sizeof(test_val.vl_len_) + sizeof(test_val.compression_algorithm) + sizeof(test_val.has_nulls) + sizeof(test_val.padding) + sizeof(test_val.element_type) + sizeof(test_val.num_distinct), "CompressedDictionary wrong size"); StaticAssertStmt(sizeof(DictionaryCompressed) == 16, "CompressedDictionary wrong size"); } struct DictionaryDecompressionIterator { DecompressionIterator base; const DictionaryCompressed *compressed; Datum *values; Simple8bRleDecompressionIterator bitmap; Simple8bRleDecompressionIterator nulls; bool has_nulls; }; ////////////////// /// Compressor /// ////////////////// typedef struct DictionaryCompressor { dictionary_hash *dictionary_items; uint32 next_index; uint32 dict_val_size; Oid type; int16 typlen; bool typbyval; char typalign; bool has_nulls; DatumSerializer *serializer; Simple8bRleCompressor dictionary_indexes; Simple8bRleCompressor nulls; } DictionaryCompressor; typedef struct ExtendedCompressor { Compressor base; DictionaryCompressor *internal; Oid element_type; } ExtendedCompressor; static void dictionary_compressor_append_datum(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = dictionary_compressor_alloc(extended->element_type); dictionary_compressor_append(extended->internal, val); } static void dictionary_compressor_append_null_value(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = dictionary_compressor_alloc(extended->element_type); dictionary_compressor_append_null(extended->internal); } static bool dictionary_compressor_is_full(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = dictionary_compressor_alloc(extended->element_type); Size datum_size_and_align; DictionaryCompressor *dict_comp = (DictionaryCompressor *) extended->internal; if (datum_serializer_value_may_be_toasted(dict_comp->serializer)) val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(val)); datum_size_and_align = datum_get_bytes_size(dict_comp->serializer, dict_comp->dict_val_size, val) - dict_comp->dict_val_size; /* If we can't fit new datum in the max size, we are full */ return (datum_size_and_align + dict_comp->dict_val_size) > MAX_ARRAY_COMPRESSOR_SIZE_BYTES; } static void * dictionary_compressor_finish_and_reset(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; void *compressed = dictionary_compressor_finish(extended->internal); pfree(extended->internal); extended->internal = NULL; return compressed; } const Compressor dictionary_compressor = { .append_val = dictionary_compressor_append_datum, .append_null = dictionary_compressor_append_null_value, .is_full = dictionary_compressor_is_full, .finish = dictionary_compressor_finish_and_reset, }; Compressor * dictionary_compressor_for_type(Oid element_type) { ExtendedCompressor *compressor = palloc(sizeof(*compressor)); *compressor = (ExtendedCompressor){ .base = dictionary_compressor, .element_type = element_type, }; return &compressor->base; } DictionaryCompressor * dictionary_compressor_alloc(Oid type) { DictionaryCompressor *compressor = palloc(sizeof(*compressor)); TypeCacheEntry *tentry = lookup_type_cache(type, TYPECACHE_EQ_OPR_FINFO | TYPECACHE_HASH_PROC_FINFO); compressor->next_index = 0; compressor->dict_val_size = 0; compressor->has_nulls = false; compressor->type = type; compressor->typlen = tentry->typlen; compressor->typbyval = tentry->typbyval; compressor->typalign = tentry->typalign; compressor->dictionary_items = dictionary_hash_alloc(tentry); compressor->serializer = create_datum_serializer(type); simple8brle_compressor_init(&compressor->dictionary_indexes); simple8brle_compressor_init(&compressor->nulls); return compressor; } void dictionary_compressor_append_null(DictionaryCompressor *compressor) { compressor->has_nulls = true; simple8brle_compressor_append(&compressor->nulls, 1); } void dictionary_compressor_append(DictionaryCompressor *compressor, Datum val) { bool found; DictionaryHashItem *dict_item; Assert(compressor != NULL); if (datum_serializer_value_may_be_toasted(compressor->serializer)) val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(val)); dict_item = dictionary_insert(compressor->dictionary_items, val, &found); if (!found) { // per_val->bitmap = roaring_dictionary_create(); dict_item->index = compressor->next_index; dict_item->key = datumCopy(val, compressor->typbyval, compressor->typlen); Assert(compressor->next_index <= INT16_MAX - 1); compressor->next_index += 1; } Size datum_size_and_align = datum_get_bytes_size(compressor->serializer, compressor->dict_val_size, val) - compressor->dict_val_size; compressor->dict_val_size += datum_size_and_align; simple8brle_compressor_append(&compressor->dictionary_indexes, dict_item->index); simple8brle_compressor_append(&compressor->nulls, 0); } typedef struct DictionaryCompressorSerializationInfo { Size bitmaps_size; Size nulls_size; Size dictionary_size; Size total_size; uint32 num_distinct; Simple8bRleSerialized *dictionary_compressed_indexes; Simple8bRleSerialized *compressed_nulls; Datum *value_array; /* same as dictionary_serialization_info just as a regular array */ ArrayCompressorSerializationInfo *dictionary_serialization_info; bool is_all_null; } DictionaryCompressorSerializationInfo; static DictionaryCompressorSerializationInfo compressor_get_serialization_info(DictionaryCompressor *compressor) { Simple8bRleSerialized *dict_indexes = simple8brle_compressor_finish(&compressor->dictionary_indexes); Simple8bRleSerialized *nulls = simple8brle_compressor_finish(&compressor->nulls); dictionary_iterator dictionary_item_iterator; ArrayCompressor *array_comp = array_compressor_alloc(compressor->type); /* the total size is header size + bitmaps size + nulls? + data sizesize */ DictionaryCompressorSerializationInfo sizes = { .dictionary_compressed_indexes = dict_indexes, .compressed_nulls = nulls, .value_array = palloc(compressor->next_index * sizeof(Datum)) }; Size header_size = sizeof(DictionaryCompressed); if (sizes.dictionary_compressed_indexes == NULL) return (DictionaryCompressorSerializationInfo){ .is_all_null = true }; sizes.bitmaps_size = simple8brle_serialized_total_size(dict_indexes); sizes.total_size = MAXALIGN(header_size) + sizes.bitmaps_size; if (compressor->has_nulls) sizes.nulls_size = simple8brle_serialized_total_size(nulls); sizes.total_size += sizes.nulls_size; dictionary_start_iterate(compressor->dictionary_items, &dictionary_item_iterator); sizes.num_distinct = 0; for (DictionaryHashItem *dict_item = dictionary_iterate(compressor->dictionary_items, &dictionary_item_iterator); dict_item != NULL; dict_item = dictionary_iterate(compressor->dictionary_items, &dictionary_item_iterator)) { sizes.value_array[dict_item->index] = dict_item->key; sizes.num_distinct += 1; } for (uint32 i = 0; i < sizes.num_distinct; i++) { array_compressor_append(array_comp, sizes.value_array[i]); } sizes.dictionary_serialization_info = array_compressor_get_serialization_info(array_comp); sizes.dictionary_size = array_compression_serialization_size(sizes.dictionary_serialization_info); sizes.total_size += sizes.dictionary_size; if (!AllocSizeIsValid(sizes.total_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); return sizes; } static DictionaryCompressed * dictionary_compressed_from_serialization_info(DictionaryCompressorSerializationInfo sizes, Oid element_type) { char *data = palloc0(sizes.total_size); DictionaryCompressed *bitmap = (DictionaryCompressed *) data; SET_VARSIZE(bitmap->vl_len_, sizes.total_size); bitmap->compression_algorithm = COMPRESSION_ALGORITHM_DICTIONARY; bitmap->element_type = element_type; bitmap->has_nulls = sizes.nulls_size > 0 ? 1 : 0; bitmap->num_distinct = sizes.num_distinct; data = data + sizeof(DictionaryCompressed); data = bytes_serialize_simple8b_and_advance(data, sizes.bitmaps_size, sizes.dictionary_compressed_indexes); if (bitmap->has_nulls) data = bytes_serialize_simple8b_and_advance(data, sizes.nulls_size, sizes.compressed_nulls); data = bytes_serialize_array_compressor_and_advance(data, sizes.dictionary_size, sizes.dictionary_serialization_info); Assert((Size) (data - (char *) bitmap) == sizes.total_size); return bitmap; } static void dictionary_decompression_iterator_init(DictionaryDecompressionIterator *iter, const char *data, bool scan_forward, Oid element_type); /* there are more efficient ways to do this that use * DictionaryCompressorSerializationInfo, but they are not worth implementing * yet */ static ArrayCompressed * dictionary_compressed_to_array_compressed(DictionaryCompressed *compressed) { ArrayCompressor *compressor = array_compressor_alloc(compressed->element_type); DictionaryDecompressionIterator iterator; dictionary_decompression_iterator_init(&iterator, (void *) compressed, true, compressed->element_type); for (DecompressResult res = dictionary_decompression_iterator_try_next_forward(&iterator.base); !res.is_done; res = dictionary_decompression_iterator_try_next_forward(&iterator.base)) { if (res.is_null) array_compressor_append_null(compressor); else array_compressor_append(compressor, res.val); } return array_compressor_finish(compressor); } void * dictionary_compressor_finish(DictionaryCompressor *compressor) { uint64 average_element_size; uint64 expected_array_size; DictionaryCompressed *compressed; DictionaryCompressorSerializationInfo sizes = compressor_get_serialization_info(compressor); if (sizes.is_all_null) return NULL; Assert(0 != sizes.num_distinct); /* calculate what the expected size would have be if we recompressed this as * an array, if this is smaller than the current size, recompress as an array. */ average_element_size = sizes.dictionary_size / sizes.num_distinct; expected_array_size = average_element_size * sizes.dictionary_compressed_indexes->num_elements; compressed = dictionary_compressed_from_serialization_info(sizes, compressor->type); if (expected_array_size < sizes.total_size) return dictionary_compressed_to_array_compressed(compressed); return compressed; } //////////////////// /// Decompressor /// //////////////////// static void dictionary_decompression_iterator_init(DictionaryDecompressionIterator *iter, const char *_data, bool scan_forward, Oid element_type) { StringInfoData si = { .data = (char *) _data, .len = VARSIZE(_data) }; const DictionaryCompressed *bitmap = consumeCompressedData(&si, sizeof(DictionaryCompressed)); Simple8bRleSerialized *s8_bitmap; DecompressionIterator *dictionary_iterator; *iter = (DictionaryDecompressionIterator){ .base = { .compression_algorithm = COMPRESSION_ALGORITHM_DICTIONARY, .forward = scan_forward, .element_type = element_type, .try_next = (scan_forward ? dictionary_decompression_iterator_try_next_forward : dictionary_decompression_iterator_try_next_reverse), }, .compressed = bitmap, .values = palloc(sizeof(Datum) * bitmap->num_distinct), .has_nulls = bitmap->has_nulls == 1, }; s8_bitmap = bytes_deserialize_simple8b_and_advance(&si); if (scan_forward) simple8brle_decompression_iterator_init_forward(&iter->bitmap, s8_bitmap); else simple8brle_decompression_iterator_init_reverse(&iter->bitmap, s8_bitmap); if (iter->has_nulls) { Simple8bRleSerialized *s8_null = bytes_deserialize_simple8b_and_advance(&si); if (scan_forward) simple8brle_decompression_iterator_init_forward(&iter->nulls, s8_null); else simple8brle_decompression_iterator_init_reverse(&iter->nulls, s8_null); } dictionary_iterator = array_decompression_iterator_alloc_forward(&si, bitmap->element_type, /* has_nulls */ false); for (uint32 i = 0; i < bitmap->num_distinct; i++) { DecompressResult res = array_decompression_iterator_try_next_forward(dictionary_iterator); Assert(!res.is_null); Assert(!res.is_done); iter->values[i] = res.val; } Assert(array_decompression_iterator_try_next_forward(dictionary_iterator).is_done); } static ArrowArray *tsl_bool_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx); static ArrowArray *tsl_text_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx); static ArrowArray *tsl_uuid_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx); /* Pass through to the specialized functions below for BOOL, TEXT and UUID */ ArrowArray * tsl_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx) { switch (element_type) { case BOOLOID: return tsl_bool_dictionary_decompress_all(compressed, element_type, dest_mctx); case TEXTOID: return tsl_text_dictionary_decompress_all(compressed, element_type, dest_mctx); case UUIDOID: return tsl_uuid_dictionary_decompress_all(compressed, element_type, dest_mctx); default: elog(ERROR, "unsupported dictionary type %u for bulk decompression", element_type); break; } return NULL; } static ArrowArray * tsl_bool_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == BOOLOID); compressed = PointerGetDatum(PG_DETOAST_DATUM(compressed)); StringInfoData si = { .data = DatumGetPointer(compressed), .len = VARSIZE(compressed) }; const DictionaryCompressed *header = consumeCompressedData(&si, sizeof(DictionaryCompressed)); Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY); CheckCompressedData(header->element_type == BOOLOID); Simple8bRleSerialized *indices_serialized = bytes_deserialize_simple8b_and_advance(&si); Simple8bRleSerialized *nulls_serialized = NULL; if (header->has_nulls) { nulls_serialized = bytes_deserialize_simple8b_and_advance(&si); } const uint32 n_notnull = indices_serialized->num_elements; const uint32 n_total = header->has_nulls ? nulls_serialized->num_elements : n_notnull; const uint32 n_padded_bits = n_total + 63; const uint32 n_padded_bytes = n_padded_bits / 8; uint64 *validity_bitmap = NULL; uint64 *values = MemoryContextAllocZero(dest_mctx, n_padded_bytes); MemoryContext old_context = MemoryContextSwitchTo(dest_mctx); /* Decompress the nulls */ Simple8bRleBitArray validity_bits = simple8brle_bitarray_decompress(nulls_serialized, /* inverted*/ true); validity_bitmap = validity_bits.data; MemoryContextSwitchTo(old_context); if (header->has_nulls) { CheckCompressedData(validity_bits.num_ones == n_notnull); CheckCompressedData(validity_bits.num_elements == n_total); } /* Decompress the values using the iterator based decompressor */ { int position = 0; DecompressionIterator *iter = tsl_dictionary_decompression_iterator_from_datum_forward(compressed, BOOLOID); for (DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); !r.is_done; r = dictionary_decompression_iterator_try_next_forward(iter)) { if (!r.is_null) { bool data = DatumGetBool(r.val) == true; if (data) { arrow_set_row_validity(values, position, true); } } ++position; } } ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + (sizeof(void *) * 2)); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = values; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } #define ELEMENT_TYPE int16 #include "simple8b_rle_decompress_all.h" #undef ELEMENT_TYPE static ArrowArray * tsl_uuid_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == UUIDOID); compressed = PointerGetDatum(PG_DETOAST_DATUM(compressed)); StringInfoData si = { .data = DatumGetPointer(compressed), .len = VARSIZE_ANY(compressed) }; const DictionaryCompressed *header = consumeCompressedData(&si, sizeof(DictionaryCompressed)); Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY); CheckCompressedData(header->element_type == UUIDOID); Simple8bRleSerialized *indices_serialized = bytes_deserialize_simple8b_and_advance(&si); Simple8bRleSerialized *nulls_serialized = NULL; if (header->has_nulls) { nulls_serialized = bytes_deserialize_simple8b_and_advance(&si); } const uint32 n_notnull = indices_serialized->num_elements; const uint32 n_total = header->has_nulls ? nulls_serialized->num_elements : n_notnull; const uint32 n_bytes = n_total * 16; uint64 *restrict validity_bitmap = NULL; uint64 *restrict values = MemoryContextAllocZero(dest_mctx, n_bytes); MemoryContext old_context = MemoryContextSwitchTo(dest_mctx); /* Decompress the nulls */ Simple8bRleBitArray validity_bits = simple8brle_bitarray_decompress(nulls_serialized, /* inverted*/ true); validity_bitmap = validity_bits.data; MemoryContextSwitchTo(old_context); if (header->has_nulls) { CheckCompressedData(validity_bits.num_ones == n_notnull); CheckCompressedData(validity_bits.num_elements == n_total); } /* create a context so I can throw away all temp data in one step */ MemoryContext temp_context = AllocSetContextCreate(CurrentMemoryContext, "tsl_uuid_dictionary_decompress_all", ALLOCSET_DEFAULT_SIZES); /* This is the padding requirement of simple8brle_decompress_all. */ const uint32 n_padded = n_total + 63; int16 *restrict indices = MemoryContextAlloc(temp_context, sizeof(int16) * n_padded); const uint32 n_decompressed = simple8brle_decompress_all_buf_int16(indices_serialized, indices, n_padded); CheckCompressedData(n_decompressed == n_notnull); /* Don't care about the sizes stored in the Array, just skip over them. */ Simple8bRleSerialized *sizes_serialized = bytes_deserialize_simple8b_and_advance(&si); CheckCompressedData(sizes_serialized->num_elements == header->num_distinct); /* Verify that the remaining size has enough space for the values */ CheckCompressedData((uint32) ((si.len - si.cursor) / 16) >= header->num_distinct); uint64 *restrict dict_values = (uint64 *) (si.data + si.cursor); { int position = 0; for (uint32 i = 0; i < n_total; ++i) { if (arrow_row_is_valid(validity_bitmap, i)) { int16 idx = indices[position]; /* Check that the dictionary indices that we've just read are not out of bounds. */ CheckCompressedData(idx >= 0 && idx < (int16) header->num_distinct); /* Use assignment as both sides are coming from palloc, so it is guaranteed to be * aligned */ values[i * 2] = dict_values[idx * 2]; values[i * 2 + 1] = dict_values[idx * 2 + 1]; position++; } } } MemoryContextDelete(temp_context); ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + (sizeof(void *) * 2)); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = values; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } static ArrowArray * tsl_text_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == TEXTOID); compressed = PointerGetDatum(PG_DETOAST_DATUM(compressed)); StringInfoData si = { .data = DatumGetPointer(compressed), .len = VARSIZE(compressed) }; const DictionaryCompressed *header = consumeCompressedData(&si, sizeof(DictionaryCompressed)); Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY); CheckCompressedData(header->element_type == TEXTOID); Simple8bRleSerialized *indices_serialized = bytes_deserialize_simple8b_and_advance(&si); Simple8bRleSerialized *nulls_serialized = NULL; if (header->has_nulls) { nulls_serialized = bytes_deserialize_simple8b_and_advance(&si); } const uint32 n_notnull = indices_serialized->num_elements; const uint32 n_total = header->has_nulls ? nulls_serialized->num_elements : n_notnull; CheckCompressedData(n_total >= n_notnull); const uint32 n_padded = n_total + 63; /* This is the padding requirement of simple8brle_decompress_all. */ int16 *restrict indices = MemoryContextAlloc(dest_mctx, sizeof(int16) * n_padded); const uint32 n_decompressed = simple8brle_decompress_all_buf_int16(indices_serialized, indices, n_padded); CheckCompressedData(n_decompressed == n_notnull); /* Check that the dictionary indices that we've just read are not out of bounds. */ CheckCompressedData(header->num_distinct <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* We use signed indexes as recommended by the Arrow spec. */ CheckCompressedData(header->num_distinct <= INT16_MAX); bool have_incorrect_index = false; for (uint32 i = 0; i < n_notnull; i++) { have_incorrect_index = have_incorrect_index || indices[i] >= (int16) header->num_distinct; } CheckCompressedData(!have_incorrect_index); /* Decompress the actual values in the dictionary. */ ArrowArray *dict = text_array_decompress_all_serialized_no_header(&si, /* has_nulls = */ false, dest_mctx); CheckCompressedData(header->num_distinct == dict->length); uint64 *restrict validity_bitmap = NULL; if (header->has_nulls) { /* Fill validity and indices of the array elements, reshuffling for nulls if needed. */ const int validity_bitmap_bytes = sizeof(uint64) * pad_to_multiple(64, n_total) / 64; validity_bitmap = MemoryContextAlloc(dest_mctx, validity_bitmap_bytes); /* * First, mark all data as valid, we will fill the nulls later if needed. * Note that the validity bitmap size is a multiple of 64 bits. We have to * fill the tail bits with zeros, because the corresponding elements are not * valid. * */ memset(validity_bitmap, 0xFF, validity_bitmap_bytes); if (n_total % 64) { const uint64 tail_mask = ~0ULL >> (64 - n_total % 64); validity_bitmap[n_total / 64] &= tail_mask; } /* * We have decompressed the data with nulls skipped, reshuffle it * according to the nulls bitmap. */ Simple8bRleBitmap nulls = simple8brle_bitmap_decompress(nulls_serialized); CheckCompressedData(n_notnull + simple8brle_bitmap_num_ones(&nulls) == n_total); /* current_notnull_element needs to go below 0, so use signed type */ int64 current_notnull_element = n_notnull - 1; for (int64 i = n_total - 1; i >= 0; i--) { Assert(i >= current_notnull_element); if (simple8brle_bitmap_get_at(&nulls, i)) { arrow_set_row_validity(validity_bitmap, i, false); indices[i] = 0; } else { Assert(current_notnull_element >= 0); indices[i] = indices[current_notnull_element]; current_notnull_element--; } } Assert(current_notnull_element == -1); } ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + (sizeof(void *) * 2)); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = indices; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; result->dictionary = dict; return result; } DecompressionIterator * tsl_dictionary_decompression_iterator_from_datum_forward(Datum dictionary_compressed, Oid element_type) { DictionaryDecompressionIterator *iterator = palloc(sizeof(*iterator)); dictionary_decompression_iterator_init(iterator, (void *) PG_DETOAST_DATUM(dictionary_compressed), true, element_type); return &iterator->base; } DecompressionIterator * tsl_dictionary_decompression_iterator_from_datum_reverse(Datum dictionary_compressed, Oid element_type) { DictionaryDecompressionIterator *iterator = palloc(sizeof(*iterator)); dictionary_decompression_iterator_init(iterator, (void *) PG_DETOAST_DATUM(dictionary_compressed), false, element_type); return &iterator->base; } DecompressResult dictionary_decompression_iterator_try_next_forward(DecompressionIterator *iter_base) { DictionaryDecompressionIterator *iter; Simple8bRleDecompressResult result; Assert(iter_base->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY && iter_base->forward); iter = (DictionaryDecompressionIterator *) iter_base; if (iter->has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_forward(&iter->nulls); if (null.is_done) return (DecompressResult){ .is_done = true, }; if (null.val != 0) return (DecompressResult){ .is_null = true, }; } result = simple8brle_decompression_iterator_try_next_forward(&iter->bitmap); if (result.is_done) return (DecompressResult){ .is_done = true, }; CheckCompressedData(result.val < iter->compressed->num_distinct); return (DecompressResult){ .val = iter->values[result.val], .is_null = false, .is_done = false, }; } DecompressResult dictionary_decompression_iterator_try_next_reverse(DecompressionIterator *iter_base) { DictionaryDecompressionIterator *iter; Simple8bRleDecompressResult result; Assert(iter_base->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY && !iter_base->forward); iter = (DictionaryDecompressionIterator *) iter_base; if (iter->has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_reverse(&iter->nulls); if (null.is_done) return (DecompressResult){ .is_done = true, }; if (null.val != 0) return (DecompressResult){ .is_null = true, }; } result = simple8brle_decompression_iterator_try_next_reverse(&iter->bitmap); if (result.is_done) return (DecompressResult){ .is_done = true, }; Assert(result.val < iter->compressed->num_distinct); return (DecompressResult){ .val = iter->values[result.val], .is_null = false, .is_done = false, }; } ///////////////////// /// SQL Functions /// ///////////////////// Datum tsl_dictionary_compressor_append(PG_FUNCTION_ARGS) { DictionaryCompressor *compressor = (DictionaryCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); MemoryContext agg_context; MemoryContext old_context; if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "tsl_dictionary_compressor_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (compressor == NULL) { Oid type_to_compress = get_fn_expr_argtype(fcinfo->flinfo, 1); compressor = dictionary_compressor_alloc(type_to_compress); } if (PG_ARGISNULL(1)) dictionary_compressor_append_null(compressor); else dictionary_compressor_append(compressor, PG_GETARG_DATUM(1)); MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(compressor); } Datum tsl_dictionary_compressor_finish(PG_FUNCTION_ARGS) { DictionaryCompressor *compressor = (DictionaryCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); void *compressed; if (compressor == NULL) PG_RETURN_NULL(); compressed = dictionary_compressor_finish(compressor); if (compressed == NULL) PG_RETURN_NULL(); PG_RETURN_POINTER(compressed); } ///////////////////// /// I/O Functions /// ///////////////////// void dictionary_compressed_send(CompressedDataHeader *header, StringInfo buffer) { uint32 data_size; uint32 size; const DictionaryCompressed *compressed_header; const char *compressed_data; Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY); compressed_header = (DictionaryCompressed *) header; compressed_data = (char *) compressed_header; compressed_data += sizeof(*compressed_header); data_size = VARSIZE(compressed_header); data_size -= sizeof(*compressed_header); pq_sendbyte(buffer, compressed_header->has_nulls == true); type_append_to_binary_string(compressed_header->element_type, buffer); size = simple8brle_serialized_total_size((void *) compressed_data); simple8brle_serialized_send(buffer, (void *) compressed_data); compressed_data += size; data_size -= size; if (compressed_header->has_nulls) { uint32 size = simple8brle_serialized_total_size((void *) compressed_data); simple8brle_serialized_send(buffer, (void *) compressed_data); compressed_data += size; data_size -= size; } array_compressed_data_send(buffer, compressed_data, data_size, compressed_header->element_type, false); } Datum dictionary_compressed_recv(StringInfo buffer) { DictionaryCompressorSerializationInfo info = { 0 }; uint8 has_nulls; Oid element_type; has_nulls = pq_getmsgbyte(buffer); CheckCompressedData(has_nulls == 0 || has_nulls == 1); element_type = binary_string_get_type(buffer); info.dictionary_compressed_indexes = simple8brle_serialized_recv(buffer); info.bitmaps_size = simple8brle_serialized_total_size(info.dictionary_compressed_indexes); info.total_size = MAXALIGN(sizeof(DictionaryCompressed)) + info.bitmaps_size; if (has_nulls) { info.compressed_nulls = simple8brle_serialized_recv(buffer); info.nulls_size = simple8brle_serialized_total_size(info.compressed_nulls); info.total_size += info.nulls_size; } info.dictionary_serialization_info = array_compressed_data_recv(buffer, element_type); CheckCompressedData(info.dictionary_serialization_info != NULL); info.dictionary_size = array_compression_serialization_size(info.dictionary_serialization_info); info.total_size += info.dictionary_size; info.num_distinct = array_compression_serialization_num_elements(info.dictionary_serialization_info); if (!AllocSizeIsValid(info.total_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); return PointerGetDatum(dictionary_compressed_from_serialization_info(info, element_type)); } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/dictionary.h��������������������������������������0000664�0000000�0000000�00000006240�15100345067�0024476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * The Dictionary compressions scheme can store any type of data but is optimized for * low-cardinality data sets. The dictionary of distinct items is stored as an `array` compressed * object. The row->dictionary item mapping is stored as a series of integer-based indexes into the * dictionary array ordered by row number (called dictionary_indexes; compressed using * `simple8b_rle`). */ #include <postgres.h> #include "compression/compression.h" #include <lib/stringinfo.h> #include <fmgr.h> typedef struct DictionaryCompressor DictionaryCompressor; typedef struct DictionaryCompressed DictionaryCompressed; typedef struct DictionaryDecompressionIterator DictionaryDecompressionIterator; extern bool dictionary_compressed_has_nulls(const CompressedDataHeader *header); extern Compressor *dictionary_compressor_for_type(Oid element_type); extern DictionaryCompressor *dictionary_compressor_alloc(Oid type_to_compress); extern void dictionary_compressor_append_null(DictionaryCompressor *compressor); extern void dictionary_compressor_append(DictionaryCompressor *compressor, Datum val); extern void *dictionary_compressor_finish(DictionaryCompressor *compressor); extern DecompressionIterator * tsl_dictionary_decompression_iterator_from_datum_forward(Datum dictionary_compressed, Oid element_type); extern DecompressResult dictionary_decompression_iterator_try_next_forward(DecompressionIterator *iter); extern DecompressionIterator * tsl_dictionary_decompression_iterator_from_datum_reverse(Datum dictionary_compressed, Oid element_type); extern DecompressResult dictionary_decompression_iterator_try_next_reverse(DecompressionIterator *iter); extern void dictionary_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern Datum dictionary_compressed_recv(StringInfo buf); extern Datum tsl_dictionary_compressor_append(PG_FUNCTION_ARGS); extern Datum tsl_dictionary_compressor_finish(PG_FUNCTION_ARGS); /* Pass through to the specialized functions below for BOOL and TEXT */ ArrowArray *tsl_dictionary_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx); #define DICTIONARY_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = tsl_dictionary_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = tsl_dictionary_decompression_iterator_from_datum_reverse, \ .compressed_data_send = dictionary_compressed_send, \ .compressed_data_recv = dictionary_compressed_recv, \ .compressor_for_type = dictionary_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTENDED, \ .decompress_all = tsl_dictionary_decompress_all, \ } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/dictionary_hash.h���������������������������������0000664�0000000�0000000�00000006120�15100345067�0025476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * The Dictionary compressions scheme can store any type of data but is optimized for * low-cardinality data sets. The dictionary of distinct items is stored as an `array` compressed * object. The row->dictionary item mapping is stored as a series of integer-based indexes into the * dictionary array ordered by row number (called dictionary_indexes; compressed using * `simple8b_rle`). */ #include <postgres.h> #include <funcapi.h> #include <utils/typcache.h> #include "compat/compat.h" typedef struct HashMeta { FunctionCallInfo hash_info; FunctionCallInfo eq_info; } HashMeta; typedef struct DictionaryHashItem { Datum key; /* hash entry status */ uint32 hash; uint16 status; uint16 index; } DictionaryHashItem; typedef struct dictionary_hash dictionary_hash; static uint32 datum_hash(dictionary_hash *tb, Datum key); static bool datum_eq(dictionary_hash *tb, Datum a, Datum b); #define SH_PREFIX dictionary #define SH_ELEMENT_TYPE DictionaryHashItem #define SH_KEY_TYPE Datum #define SH_KEY key #define SH_HASH_KEY(tb, key) datum_hash(tb, key) #define SH_EQUAL(tb, a, b) datum_eq(tb, a, b) #define SH_STORE_HASH #define SH_GET_HASH(tb, entry) entry->hash #define SH_SCOPE static inline #define SH_DEFINE #define SH_DECLARE #include "lib/simplehash.h" static uint32 datum_hash(dictionary_hash *tb, Datum key) { HashMeta *meta = (HashMeta *) tb->private_data; FunctionCallInfo fcinfo = meta->hash_info; Datum value; FC_SET_ARG(fcinfo, 0, key); fcinfo->isnull = false; value = FunctionCallInvoke(fcinfo); Assert(!fcinfo->isnull); return DatumGetUInt32(value); } static bool datum_eq(dictionary_hash *tb, Datum a, Datum b) { HashMeta *meta = (HashMeta *) tb->private_data; FunctionCallInfo fcinfo = meta->eq_info; Datum value; FC_SET_ARG(fcinfo, 0, a); FC_SET_ARG(fcinfo, 1, b); fcinfo->isnull = false; value = FunctionCallInvoke(fcinfo); Assert(!fcinfo->isnull); return DatumGetBool(value); } static dictionary_hash * dictionary_hash_alloc(TypeCacheEntry *tentry) { HashMeta *meta = palloc(sizeof(*meta)); Oid collation = InvalidOid; collation = tentry->typcollation; if (tentry->hash_proc_finfo.fn_addr == NULL || tentry->eq_opr_finfo.fn_addr == NULL) elog(ERROR, "invalid type for dictionary compression, type must have both a hash function and " "equality function"); /* May be more correct to get collation defined on the column, which may be different than the * collation defined on the type (what we're currently using). We need to think about * backwards compatibility, and different collations. Should only affect compression ratios * anyway. */ meta->eq_info = HEAP_FCINFO(2); InitFunctionCallInfoData(*meta->eq_info, &tentry->eq_opr_finfo, 2, collation, NULL, NULL); meta->hash_info = HEAP_FCINFO(2); InitFunctionCallInfoData(*meta->hash_info, &tentry->hash_proc_finfo, 1, collation, NULL, NULL); return dictionary_create(CurrentMemoryContext, 10, meta); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/float_utils.h�������������������������������������0000664�0000000�0000000�00000002652�15100345067�0024661�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> static inline uint32 float_get_bits(float in) { uint32 out; StaticAssertStmt(sizeof(float) == sizeof(uint32), "float is not IEEE double wide float"); /* yes, this is the correct way to extract the bits of a floating point number in C */ memcpy(&out, &in, sizeof(uint32)); return out; } static pg_attribute_always_inline float bits_get_float(uint32 bits) { float out; StaticAssertStmt(sizeof(float) == sizeof(uint32), "float is not IEEE double wide float"); /* yes, this is the correct way to extract the bits of a floating point number in C */ memcpy(&out, &bits, sizeof(uint32)); return out; } static inline uint64 double_get_bits(double in) { uint64 out; StaticAssertStmt(sizeof(uint64) == sizeof(double), "double is not IEEE double wide float"); /* yes, this is the correct way to extract the bits of a floating point number in C */ memcpy(&out, &in, sizeof(uint64)); return out; } static pg_attribute_always_inline double bits_get_double(uint64 bits) { double out; StaticAssertStmt(sizeof(uint64) == sizeof(double), "double is not IEEE double wide float"); /* yes, this is the correct way to extract the bits of a floating point number in C */ memcpy(&out, &bits, sizeof(double)); return out; } ��������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/gorilla.c�����������������������������������������0000664�0000000�0000000�00000077576�15100345067�0024001�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <common/base64.h> #include <funcapi.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include <port/pg_bitutils.h> #include <utils/builtins.h> #include <utils/memutils.h> #include "gorilla.h" #include "adts/bit_array.h" #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "float_utils.h" #include "simple8b_rle.h" #include "simple8b_rle_bitmap.h" /* * Gorilla compressed data is stored as * uint16 compression_algorithm: id number for the compression scheme * uint8 has_nulls: 1 if we store a NULLs bitmap after the data, otherwise 0 * uint8 bits_used_in_last_xor_bucket: number of bits used in the last bucket * uint64 last_val: the last double stored, as bits * simple8b_rle tag0: array of first tag bits (as in gorilla), also stores nelems * simple8b_rle tag1: array of second tag bits (as in gorilla) * BitArray leading_zeros: array of leading zeroes before the xor (as in gorilla) * simple8b_rle num_bits_used: number of bits used for each xor (as in gorilla) * BitArray xors: array xor values (as in gorilla) * simple8b_rle nulls: 1 if the value is NULL, else 0 */ typedef struct GorillaCompressed { CompressedDataHeaderFields; uint8 has_nulls; /* we only use one bit for has_nulls, the rest can be reused */ uint8 bits_used_in_last_xor_bucket; uint8 bits_used_in_last_leading_zeros_bucket; uint32 num_leading_zeroes_buckets; uint32 num_xor_buckets; uint64 last_value; } GorillaCompressed; #define BITS_PER_LEADING_ZEROS 6 /* expanded version of the compressed data */ typedef struct CompressedGorillaData { const GorillaCompressed *header; Simple8bRleSerialized *tag0s; Simple8bRleSerialized *tag1s; BitArray leading_zeros; Simple8bRleSerialized *num_bits_used_per_xor; BitArray xors; Simple8bRleSerialized *nulls; /* NULL if no nulls */ } CompressedGorillaData; bool gorilla_compressed_has_nulls(const CompressedDataHeader *header) { const GorillaCompressed *gc = (const GorillaCompressed *) header; return gc->has_nulls; } static void pg_attribute_unused() assertions(void) { GorillaCompressed test_val = { .vl_len_ = { 0 } }; /* make sure no padding bytes make it to disk */ StaticAssertStmt(sizeof(GorillaCompressed) == sizeof(test_val.vl_len_) + sizeof(test_val.compression_algorithm) + sizeof(test_val.has_nulls) + sizeof(test_val.bits_used_in_last_xor_bucket) + sizeof(test_val.bits_used_in_last_leading_zeros_bucket) + sizeof(test_val.num_leading_zeroes_buckets) + sizeof(test_val.num_xor_buckets) + sizeof(test_val.last_value), "Gorilla wrong size"); StaticAssertStmt(sizeof(GorillaCompressed) == 24, "Gorilla wrong size"); } typedef struct GorillaCompressor { // NOTE it is a small win to replace these next two with specialized RLE bitmaps Simple8bRleCompressor tag0s; Simple8bRleCompressor tag1s; BitArray leading_zeros; Simple8bRleCompressor bits_used_per_xor; BitArray xors; Simple8bRleCompressor nulls; uint64 prev_val; uint8 prev_leading_zeroes; uint8 prev_trailing_zeros; bool has_nulls; } GorillaCompressor; typedef struct ExtendedCompressor { Compressor base; GorillaCompressor *internal; } ExtendedCompressor; typedef struct GorillaDecompressionIterator { DecompressionIterator base; CompressedGorillaData gorilla_data; Simple8bRleDecompressionIterator tag0s; Simple8bRleDecompressionIterator tag1s; BitArrayIterator leading_zeros; Simple8bRleDecompressionIterator num_bits_used; BitArrayIterator xors; Simple8bRleDecompressionIterator nulls; uint64 prev_val; uint8 prev_leading_zeroes; uint8 prev_xor_bits_used; bool has_nulls; } GorillaDecompressionIterator; /******************** *** Compressor *** ********************/ static void gorilla_compressor_append_float(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; uint64 value = float_get_bits(DatumGetFloat4(val)); if (extended->internal == NULL) extended->internal = gorilla_compressor_alloc(); gorilla_compressor_append_value(extended->internal, value); } static void gorilla_compressor_append_double(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; uint64 value = double_get_bits(DatumGetFloat8(val)); if (extended->internal == NULL) extended->internal = gorilla_compressor_alloc(); gorilla_compressor_append_value(extended->internal, value); } static void gorilla_compressor_append_int16(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = gorilla_compressor_alloc(); gorilla_compressor_append_value(extended->internal, (uint16) DatumGetInt16(val)); } static void gorilla_compressor_append_int32(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = gorilla_compressor_alloc(); gorilla_compressor_append_value(extended->internal, (uint32) DatumGetInt32(val)); } static void gorilla_compressor_append_int64(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = gorilla_compressor_alloc(); gorilla_compressor_append_value(extended->internal, DatumGetInt64(val)); } static void gorilla_compressor_append_null_value(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = gorilla_compressor_alloc(); gorilla_compressor_append_null(extended->internal); } static void * gorilla_compressor_finish_and_reset(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; void *compressed = gorilla_compressor_finish(extended->internal); pfree(extended->internal); extended->internal = NULL; return compressed; } const Compressor gorilla_float_compressor = { .append_val = gorilla_compressor_append_float, .append_null = gorilla_compressor_append_null_value, .is_full = NULL, .finish = gorilla_compressor_finish_and_reset, }; const Compressor gorilla_double_compressor = { .append_val = gorilla_compressor_append_double, .append_null = gorilla_compressor_append_null_value, .is_full = NULL, .finish = gorilla_compressor_finish_and_reset, }; const Compressor gorilla_uint16_compressor = { .append_val = gorilla_compressor_append_int16, .append_null = gorilla_compressor_append_null_value, .is_full = NULL, .finish = gorilla_compressor_finish_and_reset, }; const Compressor gorilla_uint32_compressor = { .append_val = gorilla_compressor_append_int32, .append_null = gorilla_compressor_append_null_value, .is_full = NULL, .finish = gorilla_compressor_finish_and_reset, }; const Compressor gorilla_uint64_compressor = { .append_val = gorilla_compressor_append_int64, .append_null = gorilla_compressor_append_null_value, .is_full = NULL, .finish = gorilla_compressor_finish_and_reset, }; Compressor * gorilla_compressor_for_type(Oid element_type) { ExtendedCompressor *compressor = palloc(sizeof(*compressor)); switch (element_type) { case FLOAT4OID: *compressor = (ExtendedCompressor){ .base = gorilla_float_compressor }; return &compressor->base; case FLOAT8OID: *compressor = (ExtendedCompressor){ .base = gorilla_double_compressor }; return &compressor->base; case INT2OID: *compressor = (ExtendedCompressor){ .base = gorilla_uint16_compressor }; return &compressor->base; case INT4OID: *compressor = (ExtendedCompressor){ .base = gorilla_uint32_compressor }; return &compressor->base; case INT8OID: *compressor = (ExtendedCompressor){ .base = gorilla_uint64_compressor }; return &compressor->base; default: elog(ERROR, "invalid type for Gorilla compression \"%s\"", format_type_be(element_type)); } pg_unreachable(); } GorillaCompressor * gorilla_compressor_alloc(void) { GorillaCompressor *compressor = palloc(sizeof(*compressor)); simple8brle_compressor_init(&compressor->tag0s); simple8brle_compressor_init(&compressor->tag1s); /* * The number of leading zeros takes about 5 bits to encode, and changes * maybe every 100 rows, so use this as a conservative estimate. */ bit_array_init(&compressor->leading_zeros, /* expected_bits = */ (GLOBAL_MAX_ROWS_PER_COMPRESSION * 5) / 100); simple8brle_compressor_init(&compressor->bits_used_per_xor); /* * We typically see about 12 bits or 4 decimal digits per row for the "xors" * part in gorilla compression. */ bit_array_init(&compressor->xors, /* expected_bits = */ GLOBAL_MAX_ROWS_PER_COMPRESSION * 12); simple8brle_compressor_init(&compressor->nulls); compressor->has_nulls = false; compressor->prev_leading_zeroes = 0; compressor->prev_trailing_zeros = 0; compressor->prev_val = 0; return compressor; } /* This function is used for testing only. */ Datum tsl_gorilla_compressor_append(PG_FUNCTION_ARGS) { MemoryContext old_context; MemoryContext agg_context; Compressor *compressor = (Compressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "tsl_gorilla_compressor_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (compressor == NULL) { compressor = gorilla_compressor_for_type(get_fn_expr_argtype(fcinfo->flinfo, 1)); } if (PG_ARGISNULL(1)) compressor->append_null(compressor); else { compressor->append_val(compressor, PG_GETARG_DATUM(1)); } MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(compressor); } /* This function is used for testing only. */ Datum tsl_gorilla_compressor_finish(PG_FUNCTION_ARGS) { Compressor *compressor = (Compressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (compressor == NULL) PG_RETURN_NULL(); void *compressed = compressor->finish(compressor); if (compressed == NULL) PG_RETURN_NULL(); PG_RETURN_POINTER(compressed); } void gorilla_compressor_append_null(GorillaCompressor *compressor) { simple8brle_compressor_append(&compressor->nulls, 1); compressor->has_nulls = true; } void gorilla_compressor_append_value(GorillaCompressor *compressor, uint64 val) { bool has_values; uint64 xor = compressor->prev_val ^ val; simple8brle_compressor_append(&compressor->nulls, 0); /* for the first value we store the bitsize even if the xor is all zeroes, * this ensures that the bits-per-xor isn't empty, and that we can calculate * the remaining offsets correctly. */ has_values = !simple8brle_compressor_is_empty(&compressor->bits_used_per_xor); if (has_values && xor == 0) simple8brle_compressor_append(&compressor->tag0s, 0); else { /* leftmost/rightmost 1 is not well-defined when all the bits in the number * are 0; the C implementations of these functions will ERROR, while the * assembly versions may return any value. We special-case 0 to to use * values for leading and trailing-zeroes that we know will work. */ int leading_zeros = xor != 0 ? 63 - pg_leftmost_one_pos64(xor) : 63; int trailing_zeros = xor != 0 ? pg_rightmost_one_pos64(xor) : 1; /* This can easily get stuck with a bad value for trailing_zeroes, leading to a bad * compressed size. We use a new trailing_zeroes if the delta is too large, but the * threshold (12) was picked in a completely unprincipled manner. * Needs benchmarking to determine an ideal threshold. */ bool reuse_bitsizes = has_values && leading_zeros >= compressor->prev_leading_zeroes && trailing_zeros >= compressor->prev_trailing_zeros && ((leading_zeros - compressor->prev_leading_zeroes) + (trailing_zeros - compressor->prev_trailing_zeros) <= 12); uint8 num_bits_used; simple8brle_compressor_append(&compressor->tag0s, 1); simple8brle_compressor_append(&compressor->tag1s, reuse_bitsizes ? 0 : 1); if (!reuse_bitsizes) { compressor->prev_leading_zeroes = leading_zeros; compressor->prev_trailing_zeros = trailing_zeros; num_bits_used = 64 - (leading_zeros + trailing_zeros); bit_array_append(&compressor->leading_zeros, BITS_PER_LEADING_ZEROS, leading_zeros); simple8brle_compressor_append(&compressor->bits_used_per_xor, num_bits_used); } num_bits_used = 64 - (compressor->prev_leading_zeroes + compressor->prev_trailing_zeros); bit_array_append(&compressor->xors, num_bits_used, xor >> compressor->prev_trailing_zeros); } compressor->prev_val = val; } static GorillaCompressed * compressed_gorilla_data_serialize(CompressedGorillaData *input) { Size tags0s_size = simple8brle_serialized_total_size(input->tag0s); Size tags1s_size = simple8brle_serialized_total_size(input->tag1s); Size leading_zeros_size = bit_array_data_bytes_used(&input->leading_zeros); Size bits_used_per_xor_size = simple8brle_serialized_total_size(input->num_bits_used_per_xor); Size xors_size = bit_array_data_bytes_used(&input->xors); Size nulls_size = 0; Size compressed_size; char *data; GorillaCompressed *compressed; if (input->header->has_nulls) nulls_size = simple8brle_serialized_total_size(input->nulls); compressed_size = sizeof(GorillaCompressed) + tags0s_size + tags1s_size + leading_zeros_size + bits_used_per_xor_size + xors_size; if (input->header->has_nulls) compressed_size += nulls_size; if (!AllocSizeIsValid(compressed_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); data = palloc0(compressed_size); compressed = (GorillaCompressed *) data; SET_VARSIZE(&compressed->vl_len_, compressed_size); Assert(compressed_size % 4 == 0); compressed->last_value = input->header->last_value; compressed->compression_algorithm = COMPRESSION_ALGORITHM_GORILLA; compressed->has_nulls = input->header->has_nulls; data += sizeof(GorillaCompressed); data = bytes_serialize_simple8b_and_advance(data, tags0s_size, input->tag0s); data = bytes_serialize_simple8b_and_advance(data, tags1s_size, input->tag1s); data = bytes_store_bit_array_and_advance(data, leading_zeros_size, &input->leading_zeros, &compressed->num_leading_zeroes_buckets, &compressed->bits_used_in_last_leading_zeros_bucket); data = bytes_serialize_simple8b_and_advance(data, bits_used_per_xor_size, input->num_bits_used_per_xor); data = bytes_store_bit_array_and_advance(data, xors_size, &input->xors, &compressed->num_xor_buckets, &compressed->bits_used_in_last_xor_bucket); if (input->header->has_nulls) data = bytes_serialize_simple8b_and_advance(data, nulls_size, input->nulls); return compressed; } void * gorilla_compressor_finish(GorillaCompressor *compressor) { GorillaCompressed header = { .compression_algorithm = COMPRESSION_ALGORITHM_GORILLA, .has_nulls = compressor->has_nulls ? 1 : 0, .last_value = compressor->prev_val, }; CompressedGorillaData data = { .header = &header }; data.tag0s = simple8brle_compressor_finish(&compressor->tag0s); if (data.tag0s == NULL) return NULL; data.tag1s = simple8brle_compressor_finish(&compressor->tag1s); Assert(data.tag1s != NULL); data.leading_zeros = compressor->leading_zeros; /* if all elements in the compressed are the same, there will be no xors, * and thus bits_used_per_xor will be empty. Since we need to store the header * to get the sizing right, we force at least one bits_used_per_xor to be created * in append, above */ data.num_bits_used_per_xor = simple8brle_compressor_finish(&compressor->bits_used_per_xor); Assert(data.num_bits_used_per_xor != NULL); data.xors = compressor->xors; data.nulls = simple8brle_compressor_finish(&compressor->nulls); Assert(compressor->has_nulls || data.nulls != NULL); return compressed_gorilla_data_serialize(&data); } /******************************* *** DecompressionIterator *** *******************************/ inline static void bytes_attach_bit_array_and_advance(BitArray *dst, StringInfo si, uint32 num_buckets, uint8 bits_in_last_bucket) { bit_array_wrap_internal(dst, num_buckets, bits_in_last_bucket, (uint64 *) (si->data + si->cursor)); consumeCompressedData(si, bit_array_data_bytes_used(dst)); } static void compressed_gorilla_data_init_from_stringinfo(CompressedGorillaData *expanded, StringInfo si) { expanded->header = (GorillaCompressed *) consumeCompressedData(si, sizeof(GorillaCompressed)); if (expanded->header->compression_algorithm != COMPRESSION_ALGORITHM_GORILLA) elog(ERROR, "unknown compression algorithm"); bool has_nulls = expanded->header->has_nulls == 1; expanded->tag0s = bytes_deserialize_simple8b_and_advance(si); expanded->tag1s = bytes_deserialize_simple8b_and_advance(si); bytes_attach_bit_array_and_advance(&expanded->leading_zeros, si, expanded->header->num_leading_zeroes_buckets, expanded->header->bits_used_in_last_leading_zeros_bucket); expanded->num_bits_used_per_xor = bytes_deserialize_simple8b_and_advance(si); bytes_attach_bit_array_and_advance(&expanded->xors, si, expanded->header->num_xor_buckets, expanded->header->bits_used_in_last_xor_bucket); if (has_nulls) expanded->nulls = bytes_deserialize_simple8b_and_advance(si); else expanded->nulls = NULL; } static void compressed_gorilla_data_init_from_pointer(CompressedGorillaData *expanded, const GorillaCompressed *compressed) { StringInfoData si = { .data = (char *) compressed, .len = VARSIZE(compressed) }; compressed_gorilla_data_init_from_stringinfo(expanded, &si); } static void compressed_gorilla_data_init_from_datum(CompressedGorillaData *data, Datum gorilla_compressed) { compressed_gorilla_data_init_from_pointer(data, (GorillaCompressed *) PG_DETOAST_DATUM( gorilla_compressed)); } static void gorilla_iterator_init_from_expanded_forward(GorillaDecompressionIterator *iterator, Oid element_type) { iterator->base.compression_algorithm = COMPRESSION_ALGORITHM_GORILLA; iterator->base.forward = true; iterator->base.element_type = element_type; iterator->base.try_next = gorilla_decompression_iterator_try_next_forward; iterator->prev_val = 0; iterator->prev_leading_zeroes = 0; iterator->prev_xor_bits_used = 0; simple8brle_decompression_iterator_init_forward(&iterator->tag0s, iterator->gorilla_data.tag0s); simple8brle_decompression_iterator_init_forward(&iterator->tag1s, iterator->gorilla_data.tag1s); bit_array_iterator_init(&iterator->leading_zeros, &iterator->gorilla_data.leading_zeros); simple8brle_decompression_iterator_init_forward(&iterator->num_bits_used, iterator->gorilla_data.num_bits_used_per_xor); bit_array_iterator_init(&iterator->xors, &iterator->gorilla_data.xors); iterator->has_nulls = iterator->gorilla_data.nulls != NULL; if (iterator->has_nulls) simple8brle_decompression_iterator_init_forward(&iterator->nulls, iterator->gorilla_data.nulls); } DecompressionIterator * gorilla_decompression_iterator_from_datum_forward(Datum gorilla_compressed, Oid element_type) { GorillaDecompressionIterator *iterator = palloc(sizeof(*iterator)); compressed_gorilla_data_init_from_datum(&iterator->gorilla_data, gorilla_compressed); gorilla_iterator_init_from_expanded_forward(iterator, element_type); return &iterator->base; } static inline DecompressResult convert_from_internal(DecompressResultInternal res_internal, Oid element_type) { if (res_internal.is_done || res_internal.is_null) { return (DecompressResult){ .is_done = res_internal.is_done, .is_null = res_internal.is_null, }; } switch (element_type) { case FLOAT8OID: return (DecompressResult){ .val = Float8GetDatum(bits_get_double(res_internal.val)), }; case FLOAT4OID: return (DecompressResult){ .val = Float4GetDatum(bits_get_float(res_internal.val)), }; case INT8OID: return (DecompressResult){ .val = Int64GetDatum(res_internal.val), }; case INT4OID: return (DecompressResult){ .val = Int32GetDatum(res_internal.val), }; case INT2OID: return (DecompressResult){ .val = Int16GetDatum(res_internal.val), }; default: elog(ERROR, "invalid type requested from gorilla decompression"); } pg_unreachable(); } static DecompressResultInternal gorilla_decompression_iterator_try_next_forward_internal(GorillaDecompressionIterator *iter) { Simple8bRleDecompressResult tag0; Simple8bRleDecompressResult tag1; uint64 xor ; if (iter->has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_forward(&iter->nulls); /* Could slightly improve performance here by not returning a tail of non-null bits */ if (null.is_done) { return (DecompressResultInternal){ .is_done = true, }; } if (null.val != 0) { CheckCompressedData(null.val == 1); return (DecompressResultInternal){ .is_null = true, }; } } tag0 = simple8brle_decompression_iterator_try_next_forward(&iter->tag0s); /* if we don't have a null bitset, this will determine when we're done */ if (tag0.is_done) { CheckCompressedData(!iter->has_nulls); return (DecompressResultInternal){ .is_done = true, }; } if (tag0.val == 0) { return (DecompressResultInternal){ .val = iter->prev_val, }; } tag1 = simple8brle_decompression_iterator_try_next_forward(&iter->tag1s); CheckCompressedData(!tag1.is_done); if (tag1.val != 0) { Simple8bRleDecompressResult num_xor_bits; /* get new xor sizes */ iter->prev_leading_zeroes = bit_array_iter_next(&iter->leading_zeros, BITS_PER_LEADING_ZEROS); CheckCompressedData(iter->prev_leading_zeroes <= 64); num_xor_bits = simple8brle_decompression_iterator_try_next_forward(&iter->num_bits_used); CheckCompressedData(!num_xor_bits.is_done); iter->prev_xor_bits_used = num_xor_bits.val; CheckCompressedData(iter->prev_xor_bits_used <= 64); /* * More than 64 significant bits don't make sense. Exactly 64 we get for * the first encoded number. */ CheckCompressedData(iter->prev_xor_bits_used + iter->prev_leading_zeroes <= 64); } /* * Zero significant bits would mean that the previous number is repeated, * but this should have been encoded with tag0 = 0. * This also might fail if we haven't seen the tag1 = 1 for the first number * and didn't initialize the bit widths. */ CheckCompressedData(iter->prev_xor_bits_used + iter->prev_leading_zeroes > 0); xor = bit_array_iter_next(&iter->xors, iter->prev_xor_bits_used); xor <<= 64 - (iter->prev_leading_zeroes + iter->prev_xor_bits_used); iter->prev_val ^= xor; return (DecompressResultInternal){ .val = iter->prev_val, }; } DecompressResult gorilla_decompression_iterator_try_next_forward(DecompressionIterator *iter_base) { Assert(iter_base->compression_algorithm == COMPRESSION_ALGORITHM_GORILLA && iter_base->forward); return convert_from_internal(gorilla_decompression_iterator_try_next_forward_internal( (GorillaDecompressionIterator *) iter_base), iter_base->element_type); } /**************************************** *** reversed DecompressionIterator *** ****************************************/ /* * conceptually, the bits from the gorilla algorithm can be thought of like * tag0: 1 1 1 1 1 1 1 1 1 1 1 * tag1: 1 0 0 0 0 1 0 0 0 0 1 * nbits: 0 4 5 3 * xor: 1 2 3 4 5 a b c d e Q * that is, tag1 represents the transition between one value in the number of * leading/used bits arrays, and thus can be transversed in any order, whenever * we see a `1`, we switch from using are current numbers to the "next" in * whichever iteration order we're following. When transversing in reverse order * there is a little subtlety in that we run out of lengths before we run out of * tag1 bits (there's an implicit leading `0`), but at that point we've run out * of values anyway, so it does not matter. */ DecompressionIterator * gorilla_decompression_iterator_from_datum_reverse(Datum gorilla_compressed, Oid element_type) { GorillaDecompressionIterator *iter = palloc(sizeof(*iter)); Simple8bRleDecompressResult num_xor_bits; iter->base.compression_algorithm = COMPRESSION_ALGORITHM_GORILLA; iter->base.forward = false; iter->base.element_type = element_type; iter->base.try_next = gorilla_decompression_iterator_try_next_reverse; compressed_gorilla_data_init_from_datum(&iter->gorilla_data, gorilla_compressed); simple8brle_decompression_iterator_init_reverse(&iter->tag0s, iter->gorilla_data.tag0s); simple8brle_decompression_iterator_init_reverse(&iter->tag1s, iter->gorilla_data.tag1s); bit_array_iterator_init_rev(&iter->leading_zeros, &iter->gorilla_data.leading_zeros); simple8brle_decompression_iterator_init_reverse(&iter->num_bits_used, iter->gorilla_data.num_bits_used_per_xor); bit_array_iterator_init_rev(&iter->xors, &iter->gorilla_data.xors); iter->has_nulls = iter->gorilla_data.nulls != NULL; if (iter->has_nulls) simple8brle_decompression_iterator_init_reverse(&iter->nulls, iter->gorilla_data.nulls); /* we need to know how many bits are used, even if the last value didn't store them */ iter->prev_leading_zeroes = bit_array_iter_next_rev(&iter->leading_zeros, BITS_PER_LEADING_ZEROS); num_xor_bits = simple8brle_decompression_iterator_try_next_reverse(&iter->num_bits_used); Assert(!num_xor_bits.is_done); iter->prev_xor_bits_used = num_xor_bits.val; iter->prev_val = iter->gorilla_data.header->last_value; return &iter->base; } static DecompressResultInternal gorilla_decompression_iterator_try_next_reverse_internal(GorillaDecompressionIterator *iter) { Simple8bRleDecompressResult tag0; Simple8bRleDecompressResult tag1; uint64 val; uint64 xor ; if (iter->has_nulls) { Simple8bRleDecompressResult null = simple8brle_decompression_iterator_try_next_reverse(&iter->nulls); if (null.is_done) return (DecompressResultInternal){ .is_done = true, }; if (null.val != 0) { Assert(null.val == 1); return (DecompressResultInternal){ .is_null = true, }; } } val = iter->prev_val; tag0 = simple8brle_decompression_iterator_try_next_reverse(&iter->tag0s); /* if we don't have a null bitset, this will determine when we're done */ if (tag0.is_done) return (DecompressResultInternal){ .is_done = true, }; if (tag0.val == 0) return (DecompressResultInternal){ .val = val, }; xor = bit_array_iter_next_rev(&iter->xors, iter->prev_xor_bits_used); if (iter->prev_leading_zeroes + iter->prev_xor_bits_used < 64) xor <<= 64 - (iter->prev_leading_zeroes + iter->prev_xor_bits_used); iter->prev_val ^= xor; tag1 = simple8brle_decompression_iterator_try_next_reverse(&iter->tag1s); if (tag1.val != 0) { /* get new xor sizes */ Simple8bRleDecompressResult num_xor_bits = simple8brle_decompression_iterator_try_next_reverse(&iter->num_bits_used); /* there're an implicit leading 0 to num_xor_bits and prev_leading_zeroes, */ if (num_xor_bits.is_done) { iter->prev_xor_bits_used = 0; iter->prev_leading_zeroes = 0; } else { iter->prev_xor_bits_used = num_xor_bits.val; iter->prev_leading_zeroes = bit_array_iter_next_rev(&iter->leading_zeros, BITS_PER_LEADING_ZEROS); } } return (DecompressResultInternal){ .val = val, }; } DecompressResult gorilla_decompression_iterator_try_next_reverse(DecompressionIterator *iter_base) { Assert(iter_base->compression_algorithm == COMPRESSION_ALGORITHM_GORILLA && !iter_base->forward); return convert_from_internal(gorilla_decompression_iterator_try_next_reverse_internal( (GorillaDecompressionIterator *) iter_base), iter_base->element_type); } #define MAX_NUM_LEADING_ZEROS_PADDED_N64 (((GLOBAL_MAX_ROWS_PER_COMPRESSION + 63) / 64) * 64) /* * Decompress packed 6bit values in lanes that contain a round number of both * packed and unpacked bytes -- 4 6-bit values are packed into 3 8-bit values. */ static uint8 * unpack_leading_zeros_array(BitArray *bitarray, uint32 *_n) { #define LANE_INPUTS 3 #define LANE_OUTPUTS 4 StaticAssertExpr(BITS_PER_LEADING_ZEROS * LANE_OUTPUTS == 8 * LANE_INPUTS, "the numbers of input and output lanes do not add up"); /* * We have four bytes of padding after leading zeros, so we don't care if * the reads of final bytes run into them and we unpack some nonsense. This * means we can always work in full lanes. * * We do have to check that the result fits into the maximum number of rows, * because we get the length from user input. */ const uint32 n_bytes_packed = bitarray->buckets.num_elements * sizeof(uint64); const uint32 n_lanes = (n_bytes_packed + LANE_INPUTS - 1) / LANE_INPUTS; const uint32 n_outputs = n_lanes * LANE_OUTPUTS; CheckCompressedData(n_outputs <= MAX_NUM_LEADING_ZEROS_PADDED_N64); uint8 *restrict dest = palloc(n_outputs); for (uint32 lane = 0; lane < n_lanes; lane++) { uint8 *restrict lane_dest = &dest[lane * LANE_OUTPUTS]; const uint8 *lane_src = &((uint8 *) bitarray->buckets.data)[lane * LANE_INPUTS]; for (uint32 output_in_lane = 0; output_in_lane < LANE_OUTPUTS; output_in_lane++) { const int startbit_abs = output_in_lane * BITS_PER_LEADING_ZEROS; const int startbit_rel = startbit_abs % 8; const int offs = 8 - startbit_rel; const uint8 this_input = lane_src[startbit_abs / 8]; const uint8 next_input = lane_src[(startbit_abs + BITS_PER_LEADING_ZEROS - 1) / 8]; uint8 output = this_input >> startbit_rel; output |= ((uint64) next_input) << offs; output &= (1ULL << BITS_PER_LEADING_ZEROS) - 1ULL; lane_dest[output_in_lane] = output; } } #undef LANE_INPUTS #undef LANE_OUTPUTS *_n = n_outputs; return dest; } /* Bulk gorilla decompression, specialized for supported data types. */ #define ELEMENT_TYPE uint8 #include "simple8b_rle_decompress_all.h" #undef ELEMENT_TYPE #define ELEMENT_TYPE uint32 #include "gorilla_impl.c" #undef ELEMENT_TYPE #define ELEMENT_TYPE uint64 #include "gorilla_impl.c" #undef ELEMENT_TYPE ArrowArray * gorilla_decompress_all(Datum datum, Oid element_type, MemoryContext dest_mctx) { CompressedGorillaData gorilla_data; compressed_gorilla_data_init_from_datum(&gorilla_data, datum); switch (element_type) { case FLOAT8OID: return gorilla_decompress_all_uint64(&gorilla_data, dest_mctx); case FLOAT4OID: return gorilla_decompress_all_uint32(&gorilla_data, dest_mctx); default: elog(ERROR, "type '%s' is not supported for gorilla decompression", format_type_be(element_type)); pg_unreachable(); } } /************* *** I/O *** **************/ void gorilla_compressed_send(CompressedDataHeader *header, StringInfo buf) { CompressedGorillaData data; const GorillaCompressed *compressed = (GorillaCompressed *) header; Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_GORILLA); compressed_gorilla_data_init_from_pointer(&data, compressed); pq_sendbyte(buf, data.header->has_nulls); pq_sendint64(buf, data.header->last_value); simple8brle_serialized_send(buf, data.tag0s); simple8brle_serialized_send(buf, data.tag1s); bit_array_send(buf, &data.leading_zeros); simple8brle_serialized_send(buf, data.num_bits_used_per_xor); bit_array_send(buf, &data.xors); if (data.header->has_nulls) simple8brle_serialized_send(buf, data.nulls); } Datum gorilla_compressed_recv(StringInfo buf) { GorillaCompressed header = { .vl_len_ = { 0 } }; CompressedGorillaData data = { .header = &header, }; header.has_nulls = pq_getmsgbyte(buf); CheckCompressedData(header.has_nulls == 0 || header.has_nulls == 1); header.last_value = pq_getmsgint64(buf); data.tag0s = simple8brle_serialized_recv(buf); data.tag1s = simple8brle_serialized_recv(buf); data.leading_zeros = bit_array_recv(buf); data.num_bits_used_per_xor = simple8brle_serialized_recv(buf); data.xors = bit_array_recv(buf); if (header.has_nulls) data.nulls = simple8brle_serialized_recv(buf); PG_RETURN_POINTER(compressed_gorilla_data_serialize(&data)); } ����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/gorilla.h�����������������������������������������0000664�0000000�0000000�00000012535�15100345067�0023766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * The Gorilla algorithm compresses floats and is modeled after the Facebook Gorilla paper: * "Gorilla: A Fast, Scalable, In-Memory Time Series Database" by Tuomas Pelkonen et. al. * * How it works: Given a series of floats, first convert that series to a series of xors between * consecutive floats (as uint64), while storing the first value as well. Given the first value * and the series of xor values, getting the floats back is trivial. So, our goal becomes to * compress the series of xors. * * The logic for compressing xors is as follows: * * The compression depends on the observation that a lot of xors will be mostly 0s, and that the * section of the xor that is non-zero will be similar in consecutive xors. So the algorithm tries * to record only the section of the xors that are non-zero. And records state about which section * of the xor its storing rarely (reusing this information from the previous xor if possible). The * state of which section of the xor is recorded is kept in two variables: leading-zeroes and * number_of_bits_used. Thus we record only number_of_bits_used bits of the xor (shifted * appropriately). * * The algorithm keeps state for the number of leading-zeroes and number_of_bits_used from xor to * xor. A boolean array called tag1 is used to indicate that these state variables need to change * for the next xor. A boolean array called Tag0 is used to indicate that the xor is 0. * * The state is as follows: * * two separate series of boolean bit values called tag0, tag1. (simple8brle compressed) * * a series of 6-bit bit-array values called leading-zeroes (not-compressed) * * a series of 64-bit ints of num_bits_used (simple8brle compressed) * * a series of variable-bit-length bits stored in an bit array called xors (not-compressed) * * Pseudocode: * if the xor == 0: * append a 0 to tag0. * You are done. * else: (xor != 0) * append a 1 to tag0. * Figure out the number of leading-zeroes and number_of_bits_used necessary to store the next * xor. Then, Make a decision whether to reuse the leading-zero and number of bits from the * current state. (the decision is based on whether it's possible to fit the next xor in as well * as a heuristic for whether it's cheaper to switch to use less number_of_bits_used) * * if (reusing previous state) * append 0 to tag1. * append number_of_bits_used bits to the xors bit array. These bits consist * of the next xor shifted by the appropriate amount. * You are done. * else: (you are changing state) * append 1 to tag1 * append the new number of leading-zeroes to the leading-zeroes array * append the new number for number_of_bits_used to the num_bits used array * append new number_of_bits_used bits to the xors bit array. * These bits consist of the next xor shifted by the appropriate amount. * you are done. * */ #include <postgres.h> #include <c.h> #include <fmgr.h> #include <lib/stringinfo.h> #include "compression/compression.h" typedef struct GorillaCompressor GorillaCompressor; typedef struct GorillaCompressed GorillaCompressed; typedef struct GorillaDecompressionIterator GorillaDecompressionIterator; extern bool gorilla_compressed_has_nulls(const CompressedDataHeader *header); extern Compressor *gorilla_compressor_for_type(Oid element_type); extern GorillaCompressor *gorilla_compressor_alloc(void); extern void gorilla_compressor_append_null(GorillaCompressor *compressor); extern void gorilla_compressor_append_value(GorillaCompressor *compressor, uint64 val); extern void *gorilla_compressor_finish(GorillaCompressor *compressor); extern DecompressionIterator * gorilla_decompression_iterator_from_datum_forward(Datum gorilla_compressed, Oid element_type); extern DecompressResult gorilla_decompression_iterator_try_next_forward(DecompressionIterator *iter); extern DecompressionIterator * gorilla_decompression_iterator_from_datum_reverse(Datum gorilla_compressed, Oid element_type); extern DecompressResult gorilla_decompression_iterator_try_next_reverse(DecompressionIterator *iter); extern ArrowArray *gorilla_decompress_all(Datum datum, Oid element_type, MemoryContext dest_mctx); extern void gorilla_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern Datum gorilla_compressed_recv(StringInfo buf); extern Datum tsl_gorilla_compressor_append(PG_FUNCTION_ARGS); extern Datum tsl_gorilla_compressor_finish(PG_FUNCTION_ARGS); #define GORILLA_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = gorilla_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = gorilla_decompression_iterator_from_datum_reverse, \ .decompress_all = gorilla_decompress_all, .compressed_data_send = gorilla_compressed_send, \ .compressed_data_recv = gorilla_compressed_recv, \ .compressor_for_type = gorilla_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTERNAL, \ } �������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/gorilla_impl.c������������������������������������0000664�0000000�0000000�00000014560�15100345067�0025002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Decompress the entire batch of gorilla-compressed rows into an Arrow array. * Specialized for each supported data type. */ #define FUNCTION_NAME_HELPER(X, Y) X##_##Y #define FUNCTION_NAME(X, Y) FUNCTION_NAME_HELPER(X, Y) static ArrowArray * FUNCTION_NAME(gorilla_decompress_all, ELEMENT_TYPE)(CompressedGorillaData *gorilla_data, MemoryContext dest_mctx) { const bool has_nulls = gorilla_data->nulls != NULL; const uint32 n_total = has_nulls ? gorilla_data->nulls->num_elements : gorilla_data->tag0s->num_elements; CheckCompressedData(n_total <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * Pad the number of elements to multiple of 64 bytes if needed, so that we * can work in 64-byte blocks. */ const uint32 n_total_padded = ((n_total * sizeof(ELEMENT_TYPE) + 63) / 64) * 64 / sizeof(ELEMENT_TYPE); Assert(n_total_padded >= n_total); /* * We need additional padding at the end of buffer, because the code that * converts the elements to postres Datum always reads in 8 bytes. */ const int buffer_bytes = n_total_padded * sizeof(ELEMENT_TYPE) + 8; ELEMENT_TYPE *restrict decompressed_values = MemoryContextAlloc(dest_mctx, buffer_bytes); const uint32 n_notnull = gorilla_data->tag0s->num_elements; CheckCompressedData(n_total >= n_notnull); /* Unpack the basic compressed data parts. */ const Simple8bRleBitmap tag0s = simple8brle_bitmap_prefixsums(gorilla_data->tag0s); const Simple8bRleBitmap tag1s = simple8brle_bitmap_prefixsums(gorilla_data->tag1s); BitArray leading_zeros_bitarray = gorilla_data->leading_zeros; BitArrayIterator leading_zeros_iterator; bit_array_iterator_init(&leading_zeros_iterator, &leading_zeros_bitarray); uint32 num_leading_zeros_padded; const uint8 *all_leading_zeros = unpack_leading_zeros_array(&gorilla_data->leading_zeros, &num_leading_zeros_padded); uint32 num_bit_widths; const uint8 *bit_widths = simple8brle_decompress_all_uint8(gorilla_data->num_bits_used_per_xor, &num_bit_widths); BitArray xors_bitarray = gorilla_data->xors; BitArrayIterator xors_iterator; bit_array_iterator_init(&xors_iterator, &xors_bitarray); /* * Now decompress the non-null data. * * 1) unpack only the different elements (tag0 = 1) based on the tag1 array. * * 1a) Sanity check: the number of bit widths we have matches the * number of 1s in the tag1s array. */ CheckCompressedData(simple8brle_bitmap_num_ones(&tag1s) == num_bit_widths); CheckCompressedData(simple8brle_bitmap_num_ones(&tag1s) <= num_leading_zeros_padded); /* * 1b) Sanity check: the first tag1 must be 1, so that we initialize the bit * widths. */ CheckCompressedData(simple8brle_bitmap_prefix_sum(&tag1s, 0) == 1); /* * 1c) Sanity check: can't have more different elements than notnull elements. */ const uint16 n_different = tag1s.num_elements; CheckCompressedData(n_different <= n_notnull); /* * 1d) Unpack. * * Note that the bit widths change often, so there's no sense in * having a fast path for stretches of tag1 == 0. */ ELEMENT_TYPE prev = 0; for (uint16 i = 0; i < n_different; i++) { const uint8 current_xor_bits = bit_widths[simple8brle_bitmap_prefix_sum(&tag1s, i) - 1]; const uint8 current_leading_zeros = all_leading_zeros[simple8brle_bitmap_prefix_sum(&tag1s, i) - 1]; /* * Truncate the shift here not to cause UB on the corrupt data. */ const uint8 shift = (64 - (current_xor_bits + current_leading_zeros)) & 63; const uint64 current_xor = bit_array_iter_next(&xors_iterator, current_xor_bits); prev ^= current_xor << shift; decompressed_values[i] = prev; } /* * 2) Fill out the stretches of repeated elements, encoded with tag0 = 0. * * 2a) Sanity check: number of different elements according to tag0s must be * the same as number of different elements according to tag1s, so that the * current_element doesn't underrun. */ CheckCompressedData(simple8brle_bitmap_num_ones(&tag0s) == n_different); /* * 2b) Sanity check: tag0s[0] == 1 -- the first element of the sequence is * always "different from the previous one". */ CheckCompressedData(simple8brle_bitmap_prefix_sum(&tag0s, 0) == 1); /* * 2b) Fill the repeated elements. */ for (int i = n_notnull - 1; i >= 0; i--) { decompressed_values[i] = decompressed_values[simple8brle_bitmap_prefix_sum(&tag0s, i) - 1]; } uint64 *restrict validity_bitmap = NULL; if (has_nulls) { /* * We have unpacked the non-null data. Now reshuffle it to account for nulls, * and fill the validity bitmap. */ const int validity_bitmap_bytes = sizeof(uint64) * ((n_total + 64 - 1) / 64); validity_bitmap = MemoryContextAlloc(dest_mctx, validity_bitmap_bytes); /* * First, mark all data as valid, we will fill the nulls later if needed. * Note that the validity bitmap size is a multiple of 64 bits. We have to * fill the tail bits with zeros, because the corresponding elements are not * valid. * */ memset(validity_bitmap, 0xFF, validity_bitmap_bytes); if (n_total % 64) { const uint64 tail_mask = ~0ULL >> (64 - n_total % 64); validity_bitmap[n_total / 64] &= tail_mask; } /* * We have decompressed the data with nulls skipped, reshuffle it * according to the nulls bitmap. */ const Simple8bRleBitmap nulls = simple8brle_bitmap_decompress(gorilla_data->nulls); CheckCompressedData(n_notnull + simple8brle_bitmap_num_ones(&nulls) == n_total); int current_notnull_element = n_notnull - 1; for (int i = n_total - 1; i >= 0; i--) { Assert(i >= current_notnull_element); if (simple8brle_bitmap_get_at(&nulls, i)) { arrow_set_row_validity(validity_bitmap, i, false); } else { Assert(current_notnull_element >= 0); decompressed_values[i] = decompressed_values[current_notnull_element]; current_notnull_element--; } } Assert(current_notnull_element == -1); } /* Return the result. */ ArrowArray *result = MemoryContextAllocZero(dest_mctx, sizeof(ArrowArray) + sizeof(void *) * 2); const void **buffers = (const void **) &result[1]; buffers[0] = validity_bitmap; buffers[1] = decompressed_values; result->n_buffers = 2; result->buffers = buffers; result->length = n_total; result->null_count = n_total - n_notnull; return result; } #undef FUNCTION_NAME #undef FUNCTION_NAME_HELPER ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/null.c��������������������������������������������0000664�0000000�0000000�00000003301�15100345067�0023271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "null.h" #include "fmgr.h" typedef struct NullCompressed { CompressedDataHeaderFields; } NullCompressed; extern DecompressionIterator * null_decompression_iterator_from_datum_forward(Datum bool_compressed, Oid element_type) { elog(ERROR, "null decompression iterator not implemented"); return NULL; } extern DecompressionIterator * null_decompression_iterator_from_datum_reverse(Datum bool_compressed, Oid element_type) { elog(ERROR, "null decompression iterator not implemented"); return NULL; } extern void null_compressed_send(CompressedDataHeader *header, StringInfo buffer) { elog(ERROR, "null compression doesn't implement send"); } extern Datum null_compressed_recv(StringInfo buffer) { /* Sanity checks for invalid buffer */ if (buffer->len == 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("compressed data is invalid to be a null compressed block"))); if (buffer->data == NULL) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("compressed data is NULL"))); PG_RETURN_POINTER(null_compressor_get_dummy_block()); } extern Compressor * null_compressor_for_type(Oid element_type) { elog(ERROR, "null compressor not implemented"); return NULL; } extern void * null_compressor_get_dummy_block(void) { NullCompressed *compressed = palloc(sizeof(NullCompressed)); Size compressed_size = sizeof(NullCompressed); compressed->compression_algorithm = COMPRESSION_ALGORITHM_NULL; SET_VARSIZE(&compressed->vl_len_, compressed_size); return compressed; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/null.h��������������������������������������������0000664�0000000�0000000�00000003771�15100345067�0023311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * The NULL compression algorithm is a no-op compression algorithm that is only * used to signal that all values in a compressed block are NULLs. The compression * interface functions are only defined to comply with the framework, but they * are not implemented and return an ERROR. Calling these function is a software * bug. */ #include <postgres.h> #include <fmgr.h> #include <lib/stringinfo.h> #include "compression/compression.h" /* * Compressor framework functions and definitions for the null algorithm. */ extern DecompressionIterator *null_decompression_iterator_from_datum_forward(Datum bool_compressed, Oid element_type); extern DecompressionIterator *null_decompression_iterator_from_datum_reverse(Datum bool_compressed, Oid element_type); extern void null_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern Datum null_compressed_recv(StringInfo buffer); extern Compressor *null_compressor_for_type(Oid element_type); extern void *null_compressor_get_dummy_block(void); #define NULL_COMPRESS_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = null_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = null_decompression_iterator_from_datum_reverse, \ .decompress_all = NULL, .compressed_data_send = null_compressed_send, \ .compressed_data_recv = null_compressed_recv, \ .compressor_for_type = null_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTERNAL, \ } �������timescaledb-2.23.0/tsl/src/compression/algorithms/simple8b_rle.h������������������������������������0000664�0000000�0000000�00000115140�15100345067�0024716�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <c.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include <adts/bit_array.h> #include "compat/compat.h" #include <adts/uint64_vec.h> /* This is defined as a header file as it is expected to be used as a primitive * for "real" compression algorithms, not used directly on SQL data. Also, due to inlining. * * * From Vo Ngoc Anh, Alistair Moffat: Index compression using 64-bit words. Softw., Pract. Exper. * 40(2): 131-147 (2010) * * Simple 8b RLE is a block based encoding/compression scheme for integers. Each block is made up of * one selector and one 64-bit data value. The interpretation of the data value is based on the * selector values. Selectors 1-14 indicate that the data value is a bit packing of integers, where * each integer takes up a constant number of bits. The value of the constant-number-of-bits is set * according to the table below. Selector 15 indicates that the block encodes a single "run" of RLE, * where the data element is a bit packing of the run count and run value. * * * Selector value: 0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | 15 (RLE) * Integers coded: 0 | 64 32 21 16 12 10 9 8 6 5 4 3 2 1 | up to 2^28 * Bits/integer: 0 | 1 2 3 4 5 6 7 8 10 12 16 21 32 64 | 36 bits * Wasted bits: 0 | 0 0 1 0 4 4 1 0 4 4 0 1 0 0 | N/A * * a 0 selector is currently unused */ /************** Constants *****************/ #define SIMPLE8B_BITSIZE 64 #define SIMPLE8B_MAXCODE 15 #define SIMPLE8B_MINCODE 1 #define SIMPLE8B_RLE_SELECTOR SIMPLE8B_MAXCODE #define SIMPLE8B_RLE_MAX_VALUE_BITS 36 #define SIMPLE8B_RLE_MAX_COUNT_BITS (SIMPLE8B_BITSIZE - SIMPLE8B_RLE_MAX_VALUE_BITS) #define SIMPLE8B_RLE_MAX_VALUE_MASK ((1ULL << SIMPLE8B_RLE_MAX_VALUE_BITS) - 1) #define SIMPLE8B_RLE_MAX_COUNT_MASK ((1ULL << SIMPLE8B_RLE_MAX_COUNT_BITS) - 1) #define SIMPLE8B_BITS_PER_SELECTOR 4 #define SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT 16 #define SIMPLE8B_MAX_BUFFERED 256 /* clang-format off */ /* selector value: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, RLE */ #define SIMPLE8B_NUM_ELEMENTS ((uint8[]){ 0, 64, 32, 21, 16, 12, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }) #define SIMPLE8B_BIT_LENGTH ((uint8[]){ 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 16, 21, 32, 64, 36 }) /* Map bit lengths directly to selector values */ #define SIMPLE8B_SELECTOR_FOR_BIT_WIDTH ((uint8[]){ \ /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, */ \ 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 10, 11, 11, 11, \ /* 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, */ \ 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, \ /* 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, */ \ 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, \ /* 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64 */ \ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14 \ }) /* clang-format on */ /* The full block selector is used when a value occupies the full 64bit block, see above. */ #define SIMPLE8B_FULL_BLOCK_SELECTOR 14 /******************** *** Public API *** ********************/ typedef struct Simple8bRleSerialized { /* the slots are padded with 0 to fill out the last slot, so there may be up * to 59 extra values stored, to counteract this, we store how many values * there should be on output. * We currently disallow more than 2^32 values per compression, since we're * going to limit the amount of rows stored per-compressed-row anyway. */ uint32 num_elements; /* we store nslots as a uint32 since we'll need to fit this in a varlen, and * we cannot store more than 2^32 bytes anyway */ uint32 num_blocks; uint64 slots[FLEXIBLE_ARRAY_MEMBER]; } Simple8bRleSerialized; static void pg_attribute_unused() simple8brle_size_assertions(void) { Simple8bRleSerialized test_val = { 0 }; /* ensure no padding bits make it to disk */ StaticAssertStmt(sizeof(Simple8bRleSerialized) == sizeof(test_val.num_elements) + sizeof(test_val.num_blocks), "simple8b_rle_oob wrong size"); StaticAssertStmt(sizeof(Simple8bRleSerialized) == 8, "simple8b_rle_oob wrong size"); } typedef struct Simple8bRleBlock { uint64 data; uint32 num_elements_compressed; uint8 selector; } Simple8bRleBlock; typedef struct Simple8bRleBuffer { uint64 data; uint32 repcount; /* The saved_repcount is placed here to help cache locality when we * need to do a partial flush and need to restore the repcount. */ uint32 saved_repcount; } Simple8bRleBuffer; typedef struct Simple8bRleCompressor { /* The total number of elements that have been compressed. */ uint32 num_elements; /* The number of elements that have been buffered in the uncompressed_buffer. */ uint32 num_buffered_elements; /* The last value that has been compressed. */ uint64 last_value; /* The buffer of uncompressed elements. */ Simple8bRleBuffer uncompressed_buffer[SIMPLE8B_MAX_BUFFERED]; BitArray selectors; uint64_vec compressed_data; } Simple8bRleCompressor; typedef struct Simple8bRleDecompressionIterator { BitArray selector_data; BitArrayIterator selectors; Simple8bRleBlock current_block; const uint64 *compressed_data; int32 num_blocks; int32 current_compressed_pos; int32 current_in_compressed_pos; uint32 num_elements; uint32 num_elements_returned; } Simple8bRleDecompressionIterator; typedef struct Simple8bRleDecompressResult { uint64 val; bool is_done; } Simple8bRleDecompressResult; static inline void simple8brle_compressor_init(Simple8bRleCompressor *compressor); static inline Simple8bRleSerialized * simple8brle_compressor_finish(Simple8bRleCompressor *compressor); static inline char *simple8brle_compressor_finish_into(Simple8bRleCompressor *compressor, char *dest, size_t expected_size); static inline void simple8brle_compressor_append(Simple8bRleCompressor *compressor, uint64 val); static inline bool simple8brle_compressor_is_empty(Simple8bRleCompressor *compressor); static inline void simple8brle_decompression_iterator_init_forward(Simple8bRleDecompressionIterator *iter, Simple8bRleSerialized *compressed); static inline void simple8brle_decompression_iterator_init_reverse(Simple8bRleDecompressionIterator *iter, Simple8bRleSerialized *compressed); static pg_attribute_always_inline Simple8bRleDecompressResult simple8brle_decompression_iterator_try_next_forward(Simple8bRleDecompressionIterator *iter); static pg_attribute_always_inline Simple8bRleDecompressResult simple8brle_decompression_iterator_try_next_reverse(Simple8bRleDecompressionIterator *iter); static inline void simple8brle_serialized_send(StringInfo buffer, const Simple8bRleSerialized *data); static inline char *bytes_serialize_simple8b_and_advance(char *dest, size_t expected_size, const Simple8bRleSerialized *data); static inline Simple8bRleSerialized *bytes_deserialize_simple8b_and_advance(StringInfo si); static inline size_t simple8brle_serialized_slot_size(const Simple8bRleSerialized *data); static inline size_t simple8brle_serialized_total_size(const Simple8bRleSerialized *data); /* * Calculate the size of the compressed data with the assumption that all uncompressed * data is flushed and pushed already. */ static inline size_t simple8brle_compressor_compressed_size(const Simple8bRleCompressor *compressor); /* * Calculate the size of the compressed data without modifying the compressor and without * making assumptions about the compressor state. */ static inline size_t simple8brle_compressor_compressed_const_size(const Simple8bRleCompressor *compressor); /********************* *** Private API *** *********************/ typedef struct Simple8bRlePartiallyCompressedData { Simple8bRleBlock block; const uint64 *data; uint32 data_size; } Simple8bRlePartiallyCompressedData; /* compressor */ static inline void simple8brle_compressor_partial_flush(Simple8bRleCompressor *compressor); static inline void simple8brle_compressor_full_flush(Simple8bRleCompressor *compressor); /* block */ static inline Simple8bRleBlock simple8brle_block_create(uint8 selector, uint64 data); static inline uint64 simple8brle_block_get_element(Simple8bRleBlock block, uint32 position_in_value); /* utils */ static inline bool simple8brle_selector_is_rle(uint8 selector); static inline uint64 simple8brle_selector_get_bitmask(uint8 selector); static inline uint32 simple8brle_bits_for_value(uint64 v); static inline uint32 simple8brle_rledata_repeatcount(uint64 rledata); static inline uint64 simple8brle_rledata_value(uint64 rledata); static uint32 simple8brle_num_selector_slots_for_num_blocks(uint32 num_blocks); /******************************* *** Simple8bRleSerialized *** *******************************/ static inline Simple8bRleSerialized * simple8brle_serialized_recv(StringInfo buffer) { uint32 i; uint32 num_elements = pq_getmsgint32(buffer); CheckCompressedData(num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); uint32 num_blocks = pq_getmsgint32(buffer); CheckCompressedData(num_blocks <= GLOBAL_MAX_ROWS_PER_COMPRESSION); uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(num_blocks); Simple8bRleSerialized *data; Size compressed_size = sizeof(Simple8bRleSerialized) + (num_blocks + num_selector_slots) * sizeof(uint64); if (!AllocSizeIsValid(compressed_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); data = palloc(compressed_size); data->num_elements = num_elements; data->num_blocks = num_blocks; for (i = 0; i < num_blocks + num_selector_slots; i++) data->slots[i] = pq_getmsgint64(buffer); return data; } static inline void * simple8brle_serialized_recv_into(StringInfo buffer, void *dest, Simple8bRleSerialized **data_out) { uint32 i; uint32 num_elements = pq_getmsgint32(buffer); CheckCompressedData(num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); uint32 num_blocks = pq_getmsgint32(buffer); CheckCompressedData(num_blocks <= GLOBAL_MAX_ROWS_PER_COMPRESSION); uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(num_blocks); Size compressed_size = sizeof(Simple8bRleSerialized) + (num_blocks + num_selector_slots) * sizeof(uint64); if (!AllocSizeIsValid(compressed_size)) ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("compressed size exceeds the maximum allowed (%d)", (int) MaxAllocSize))); *data_out = (Simple8bRleSerialized *) dest; (*data_out)->num_elements = num_elements; (*data_out)->num_blocks = num_blocks; for (i = 0; i < num_blocks + num_selector_slots; i++) (*data_out)->slots[i] = pq_getmsgint64(buffer); return (char *) *data_out + compressed_size; } static void simple8brle_serialized_send(StringInfo buffer, const Simple8bRleSerialized *data) { Assert(NULL != data); uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(data->num_blocks); uint32 i; pq_sendint32(buffer, data->num_elements); pq_sendint32(buffer, data->num_blocks); for (i = 0; i < data->num_blocks + num_selector_slots; i++) pq_sendint64(buffer, data->slots[i]); } static char * bytes_serialize_simple8b_and_advance(char *dest, size_t expected_size, const Simple8bRleSerialized *data) { size_t size = simple8brle_serialized_total_size(data); if (expected_size != size) elog(ERROR, "the size to serialize does not match simple8brle"); memcpy(dest, data, size); return dest + size; } static Simple8bRleSerialized * bytes_deserialize_simple8b_and_advance(StringInfo si) { Simple8bRleSerialized *serialized = consumeCompressedData(si, sizeof(Simple8bRleSerialized)); consumeCompressedData(si, simple8brle_serialized_slot_size(serialized)); CheckCompressedData(serialized->num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); CheckCompressedData(serialized->num_elements > 0); CheckCompressedData(serialized->num_blocks > 0); CheckCompressedData(serialized->num_elements >= serialized->num_blocks); return serialized; } static size_t simple8brle_serialized_slot_size(const Simple8bRleSerialized *data) { if (data == NULL) return 0; int total_slots = data->num_blocks + simple8brle_num_selector_slots_for_num_blocks(data->num_blocks); CheckCompressedData(total_slots > 0); CheckCompressedData((uint32) total_slots < PG_INT32_MAX / sizeof(uint64)); return total_slots * sizeof(uint64); } static size_t simple8brle_serialized_total_size(const Simple8bRleSerialized *data) { Assert(data != NULL); return sizeof(*data) + simple8brle_serialized_slot_size(data); } /******************************* *** Simple8bRleCompressor *** *******************************/ static void simple8brle_compressor_init(Simple8bRleCompressor *compressor) { *compressor = (Simple8bRleCompressor){ .num_elements = 0, .num_buffered_elements = 0, .last_value = 0, }; /* Allocate the size according to the batch target */ uint64_vec_init(&compressor->compressed_data, CurrentMemoryContext, TARGET_COMPRESSED_BATCH_SIZE); bit_array_init(&compressor->selectors, /* expected_bits = */ (TARGET_COMPRESSED_BATCH_SIZE * SIMPLE8B_BITS_PER_SELECTOR)); } static inline void simple8brle_compressor_partial_flush(Simple8bRleCompressor *compressor) { Assert(compressor->num_buffered_elements > 0); uint8 bit_width = 0; uint64 mask = 0; int16 max_pack = 0; uint8 selector = 0; int32 num_buffered_elements = compressor->num_buffered_elements; int32 i; for (i = 0; i < num_buffered_elements; i++) { Simple8bRleBuffer *restrict buffer_base = &compressor->uncompressed_buffer[i]; Assert(buffer_base[0].repcount > 0); uint8 first_bit_width = simple8brle_bits_for_value(buffer_base[0].data); selector = SIMPLE8B_SELECTOR_FOR_BIT_WIDTH[first_bit_width]; bit_width = SIMPLE8B_BIT_LENGTH[selector]; /* The current element times the bit width is large enough to flush. */ if (bit_width * buffer_base[0].repcount >= SIMPLE8B_BITSIZE) { uint64 val = buffer_base[0].data; uint64 repcount = buffer_base[0].repcount; /* We can only RLE elements if they are small enough to fit in the * data part of the RLE block. */ if (val <= SIMPLE8B_RLE_MAX_VALUE_MASK) { /* Flush the value as RLE */ uint64 rle_block = (repcount << SIMPLE8B_RLE_MAX_VALUE_BITS) | val; bit_array_append(&compressor->selectors, SIMPLE8B_BITS_PER_SELECTOR, SIMPLE8B_RLE_SELECTOR); uint64_vec_append(&compressor->compressed_data, rle_block); continue; } /* Otherwise we need to flush each element as a full 64 bit block */ else { /* Each repeated element needs to be flushed as separate blocks */ for (uint32 k = 0; k < repcount; k++) { bit_array_append(&compressor->selectors, SIMPLE8B_BITS_PER_SELECTOR, SIMPLE8B_FULL_BLOCK_SELECTOR); uint64_vec_append(&compressor->compressed_data, val); } continue; } } int32 num_packed = buffer_base[0].repcount; max_pack = SIMPLE8B_NUM_ELEMENTS[selector]; mask = simple8brle_selector_get_bitmask(selector); for (int32 j = 1; (i + j) < num_buffered_elements && num_packed < max_pack; ++j) { Assert(buffer_base[j].repcount > 0); uint64 val = buffer_base[j].data; while (val > mask) { /* We bumped into a value that doesn't fit, need to expand selector, * but we need to make sure we don't leave gaps in the packed data. */ ++selector; mask = simple8brle_selector_get_bitmask(selector); if (num_packed >= SIMPLE8B_NUM_ELEMENTS[selector]) break; } max_pack = SIMPLE8B_NUM_ELEMENTS[selector]; num_packed += buffer_base[j].repcount; } /* Final calculations after selector is determined */ bit_width = SIMPLE8B_BIT_LENGTH[selector]; int32 num_buffer_taken = 0; uint64 packed_value = 0; num_packed = 0; /* * We need to be smart with the repcounts. The case when the repeated values * can fit an entire block is already handled above. Here we move the values * from the current buffer entry to the packed value, thus we decrease the * repcounts one by one. */ while (num_packed < max_pack && (i + num_buffer_taken) < num_buffered_elements) { Simple8bRleBuffer *restrict current_entry = &buffer_base[num_buffer_taken]; current_entry->saved_repcount = current_entry->repcount; uint64 val = current_entry->data; uint32 entry_repcount = current_entry->repcount; while (entry_repcount > 0 && num_packed < max_pack) { packed_value |= (val & mask) << (num_packed * bit_width); ++num_packed; --entry_repcount; } /* Write back the updated repcount. */ current_entry->repcount = entry_repcount; if (entry_repcount > 0) break; ++num_buffer_taken; } if (num_packed == max_pack) { /* Flush the packed value. */ bit_array_append(&compressor->selectors, SIMPLE8B_BITS_PER_SELECTOR, selector); uint64_vec_append(&compressor->compressed_data, packed_value); } else { /* * If we flushed some values from the uncompressed buffer, but there are * some that didn't fit, we need to move them to the beginning of the buffer. * We need to restore the repcounts to their original values first. */ for (int32 j = 0; j < num_buffer_taken; j++) { buffer_base[j].repcount = buffer_base[j].saved_repcount; } uint32 remaining = num_buffered_elements - i; if (remaining > 0) { memcpy(compressor->uncompressed_buffer, &compressor->uncompressed_buffer[i], remaining * sizeof(Simple8bRleBuffer)); } else { /* If no elements are remaining, we can reset the buffer */ compressor->num_buffered_elements = 0; } /* Update the number of buffered elements */ compressor->num_buffered_elements = remaining; break; } i += (num_buffer_taken - 1); } /* If all elements were processed, reset buffer. */ if (i == num_buffered_elements) { compressor->num_buffered_elements = 0; } } static inline void simple8brle_compressor_full_flush(Simple8bRleCompressor *compressor) { Assert(compressor->num_buffered_elements > 0); uint8 bit_width = 0; uint64 mask = 0; int16 max_pack = 0; uint8 selector = 0; int32 num_buffered_elements = compressor->num_buffered_elements; for (int32 i = 0; i < num_buffered_elements; i++) { Simple8bRleBuffer *restrict buffer_base = &compressor->uncompressed_buffer[i]; Assert(buffer_base[0].repcount > 0); uint8 first_bit_width = simple8brle_bits_for_value(buffer_base[0].data); selector = SIMPLE8B_SELECTOR_FOR_BIT_WIDTH[first_bit_width]; bit_width = SIMPLE8B_BIT_LENGTH[selector]; /* The current element times the bit width is large enough to flush. */ if (bit_width * buffer_base[0].repcount >= SIMPLE8B_BITSIZE) { uint64 val = buffer_base[0].data; uint64 repcount = buffer_base[0].repcount; /* We can only RLE elements if they are small enough to fit in the * data part of the RLE block. */ if (val <= SIMPLE8B_RLE_MAX_VALUE_MASK) { /* Flush the value as RLE */ uint64 rle_block = (repcount << SIMPLE8B_RLE_MAX_VALUE_BITS) | val; bit_array_append(&compressor->selectors, SIMPLE8B_BITS_PER_SELECTOR, SIMPLE8B_RLE_SELECTOR); uint64_vec_append(&compressor->compressed_data, rle_block); continue; } /* Otherwise we need to flush each element as a full 64 bit block */ else { /* Each repeated element needs to be flushed as separate blocks */ for (uint32 k = 0; k < repcount; k++) { bit_array_append(&compressor->selectors, SIMPLE8B_BITS_PER_SELECTOR, SIMPLE8B_FULL_BLOCK_SELECTOR); uint64_vec_append(&compressor->compressed_data, val); } continue; } } int32 num_packed = buffer_base[0].repcount; max_pack = SIMPLE8B_NUM_ELEMENTS[selector]; mask = simple8brle_selector_get_bitmask(selector); for (int32 j = 1; (i + j) < num_buffered_elements && num_packed < max_pack; ++j) { Assert(buffer_base[j].repcount > 0); uint64 val = buffer_base[j].data; while (val > mask) { /* We bumped into a value that doesn't fit, need to expand selector, * but we need to make sure we don't leave gaps in the packed data. */ ++selector; mask = simple8brle_selector_get_bitmask(selector); if (num_packed >= SIMPLE8B_NUM_ELEMENTS[selector]) break; } max_pack = SIMPLE8B_NUM_ELEMENTS[selector]; num_packed += buffer_base[j].repcount; } /* Final calculations after selector is determined */ bit_width = SIMPLE8B_BIT_LENGTH[selector]; int32 num_buffer_taken = 0; uint64 packed_value = 0; num_packed = 0; /* * This is the main difference between the partial and full flush. * Here we don't need to be smart with the repcounts, because we are * flushing a full block no matter what. No elements can remain in the * uncompressed buffer. * */ while (num_packed < max_pack && (i + num_buffer_taken) < num_buffered_elements) { uint64 val = buffer_base[num_buffer_taken].data; while (buffer_base[num_buffer_taken].repcount > 0 && num_packed < max_pack) { packed_value |= (val & mask) << (num_packed * bit_width); ++num_packed; buffer_base[num_buffer_taken].repcount--; } if (buffer_base[num_buffer_taken].repcount > 0) break; ++num_buffer_taken; } /* Flush the packed value */ bit_array_append(&compressor->selectors, SIMPLE8B_BITS_PER_SELECTOR, selector); uint64_vec_append(&compressor->compressed_data, packed_value); i += (num_buffer_taken - 1); } compressor->num_buffered_elements = 0; } static void simple8brle_compressor_append(Simple8bRleCompressor *compressor, uint64 val) { Assert(compressor != NULL); if (unlikely(compressor->num_buffered_elements >= SIMPLE8B_MAX_BUFFERED)) { simple8brle_compressor_partial_flush(compressor); } uint32 num_buffered = compressor->num_buffered_elements; /* Check for RLE against last element. This saves a few cycles instead of looking * at the last buffered entry. */ if (likely(num_buffered > 0)) { if (likely(compressor->last_value == val)) { Simple8bRleBuffer *restrict last_entry = &compressor->uncompressed_buffer[num_buffered - 1]; if (likely(val == last_entry->data)) { /* Increment count, no new buffer entry needed */ last_entry->repcount++; compressor->num_elements++; return; } } } /* New unique value - buffer it. */ Simple8bRleBuffer *restrict new_entry = &compressor->uncompressed_buffer[num_buffered]; new_entry->data = val; new_entry->repcount = 1; compressor->num_buffered_elements = num_buffered + 1; compressor->num_elements++; compressor->last_value = val; } static bool simple8brle_compressor_is_empty(Simple8bRleCompressor *compressor) { return compressor->num_elements == 0; } static size_t simple8brle_compressor_compressed_size(const Simple8bRleCompressor *compressor) { /* we store 16 selectors per selector_slot, and one selector_slot per compressed_data_slot. * use num_compressed_data_slots / 16 + 1 to ensure that rounding doesn't truncate our slots * and that we always have a 0 slot at the end. */ return sizeof(Simple8bRleSerialized) + compressor->compressed_data.num_elements * sizeof(*compressor->compressed_data.data) + bit_array_data_bytes_used(&compressor->selectors); } static size_t simple8brle_compressor_compressed_const_size(const Simple8bRleCompressor *compressor) { /* Allocate temp space where the temp_compressor will put the data. Prefer static * allocation to avoid palloc overhead, since this is only used for size calculation. */ #define TEMP_DATA_SIZE TARGET_COMPRESSED_BATCH_SIZE #define TEMP_SELECTORS_SIZE (TEMP_DATA_SIZE / SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT) uint64 temp_data_static[TEMP_DATA_SIZE]; uint64 temp_selectors_static[TEMP_SELECTORS_SIZE]; uint64 temp_data_count = TEMP_DATA_SIZE; uint64 temp_selectors_count = TEMP_SELECTORS_SIZE; uint64 *temp_data = temp_data_static; uint64 *temp_selectors = temp_selectors_static; bool use_static = true; Simple8bRleCompressor temp_compressor = *compressor; /* Replace the data and selectors with the temp space.*/ temp_compressor.compressed_data.data = temp_data; temp_compressor.compressed_data.num_elements = 0; temp_compressor.compressed_data.max_elements = TEMP_DATA_SIZE; temp_compressor.selectors.buckets.data = temp_selectors; temp_compressor.selectors.buckets.num_elements = 0; temp_compressor.selectors.buckets.max_elements = TEMP_SELECTORS_SIZE; temp_compressor.selectors.bits_used_in_last_bucket = 0; /* If the compressor is empty, we can return 0, similar to finish. */ if (temp_compressor.num_elements == 0) return 0; /* * If the compressor has no uncompressed data, we can use the original size calculation. * Note that after every append, it is guaranteed that we have at least one uncompressed * element. Not having uncompressed elements can only happen if the compressor is empty * or finish was called, so we can use the original size calculation. */ if (compressor->num_buffered_elements == 0) return simple8brle_compressor_compressed_size(compressor); /* Because the buffering allows RLE entries to be stored, the worst case scenario for * the buffer size is determined by the repcounts in the buffered elements. */ uint32 actual_buffered = 0; for (uint32 i = 0; i < compressor->num_buffered_elements; i++) { actual_buffered += compressor->uncompressed_buffer[i].repcount; } if (actual_buffered > temp_data_count) { /* We need to increase the temp buffer and allocate it dynamically. * This can only happen if the TARGET_COMPRESSED_BATCH_SIZE is smaller * than the actual buffered elements, which is unlikely. */ temp_data_count = actual_buffered; temp_data = palloc(temp_data_count * sizeof(uint64)); /* Similarly the selectors */ temp_selectors_count = (actual_buffered + 15) / 16; temp_selectors = palloc(temp_selectors_count * sizeof(uint64)); use_static = false; } /* Flush the compressor to ensure all uncompressed data is compressed into the temp_compressor. */ simple8brle_compressor_full_flush(&temp_compressor); size_t num_data_blocks = compressor->compressed_data.num_elements + temp_compressor.compressed_data.num_elements; /* Add up the size of the compressed data blocks and the header. */ size_t result = sizeof(Simple8bRleSerialized) + num_data_blocks * sizeof(*temp_compressor.compressed_data.data); /* Add up the selector bits. */ size_t selector_bits = num_data_blocks * SIMPLE8B_BITS_PER_SELECTOR; result += ((selector_bits + 63) / 64) * sizeof(uint64); #undef TEMP_DATA_SIZE #undef TEMP_SELECTORS_SIZE if (!use_static) { /* If we allocated dynamically, we need to free the memory. */ pfree(temp_data); pfree(temp_selectors); } return result; } static inline uint32 simple8brle_compressor_num_selectors(Simple8bRleCompressor *compressor) { Assert(bit_array_num_bits(&compressor->selectors) % SIMPLE8B_BITS_PER_SELECTOR == 0); return bit_array_num_bits(&compressor->selectors) / SIMPLE8B_BITS_PER_SELECTOR; } static Simple8bRleSerialized * simple8brle_compressor_finish(Simple8bRleCompressor *compressor) { size_t size_left; size_t selector_size; size_t compressed_size; Simple8bRleSerialized *compressed; uint64 bits; if (compressor->num_elements == 0) return NULL; /* Flush any remaining state */ if (compressor->num_buffered_elements > 0) { simple8brle_compressor_full_flush(compressor); } Assert(compressor->num_buffered_elements == 0); compressed_size = simple8brle_compressor_compressed_size(compressor); /* we use palloc0 despite initializing the entire structure, * to ensure padding bits are zeroed, and that there's a 0 selector at the end. * It would be more efficient to ensure there are no padding bits in the struct, * and initialize everything ourselves */ compressed = palloc0(compressed_size); Assert(bit_array_num_buckets(&compressor->selectors) > 0); Assert(compressor->compressed_data.num_elements > 0); Assert(compressor->compressed_data.num_elements == simple8brle_compressor_num_selectors(compressor)); *compressed = (Simple8bRleSerialized){ .num_elements = compressor->num_elements, .num_blocks = compressor->compressed_data.num_elements, }; size_left = compressed_size - sizeof(*compressed); Assert(size_left >= bit_array_data_bytes_used(&compressor->selectors)); selector_size = bit_array_output(&compressor->selectors, compressed->slots, size_left, &bits); size_left -= selector_size; Assert(size_left == (compressor->compressed_data.num_elements * sizeof(*compressor->compressed_data.data))); Assert(compressor->selectors.buckets.num_elements == simple8brle_num_selector_slots_for_num_blocks(compressor->compressed_data.num_elements)); memcpy(compressed->slots + compressor->selectors.buckets.num_elements, compressor->compressed_data.data, size_left); return compressed; } static char * simple8brle_compressor_finish_into(Simple8bRleCompressor *compressor, char *dest, size_t expected_size) { size_t size_left; size_t selector_size; size_t compressed_size; char *end_ptr; Simple8bRleSerialized *compressed; uint64 bits; if (compressor->num_elements == 0) return NULL; Ensure(dest != NULL, "dest is NULL"); /* Flush any remaining state */ if (compressor->num_buffered_elements > 0) { simple8brle_compressor_full_flush(compressor); } Assert(compressor->num_buffered_elements == 0); compressed_size = simple8brle_compressor_compressed_size(compressor); Ensure(expected_size == compressed_size, "expected_size: %zu, compressed_size: %zu", expected_size, compressed_size); compressed = (Simple8bRleSerialized *) dest; Assert(bit_array_num_buckets(&compressor->selectors) > 0); Assert(compressor->compressed_data.num_elements > 0); Assert(compressor->compressed_data.num_elements == simple8brle_compressor_num_selectors(compressor)); *compressed = (Simple8bRleSerialized){ .num_elements = compressor->num_elements, .num_blocks = compressor->compressed_data.num_elements, }; size_left = compressed_size - sizeof(*compressed); Assert(size_left >= bit_array_data_bytes_used(&compressor->selectors)); selector_size = bit_array_output(&compressor->selectors, compressed->slots, size_left, &bits); size_left -= selector_size; Assert(size_left == (compressor->compressed_data.num_elements * sizeof(*compressor->compressed_data.data))); Assert(compressor->selectors.buckets.num_elements == simple8brle_num_selector_slots_for_num_blocks(compressor->compressed_data.num_elements)); memcpy(compressed->slots + compressor->selectors.buckets.num_elements, compressor->compressed_data.data, size_left); end_ptr = (char *) (compressed->slots + compressor->selectors.buckets.num_elements) + size_left; Assert(end_ptr == dest + expected_size); return end_ptr; } /****************************************** *** Simple8bRleDecompressionIterator *** ******************************************/ static void simple8brle_decompression_iterator_init_common(Simple8bRleDecompressionIterator *iter, Simple8bRleSerialized *compressed) { uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(compressed->num_blocks); *iter = (Simple8bRleDecompressionIterator){ .compressed_data = compressed->slots + num_selector_slots, .num_blocks = compressed->num_blocks, .current_compressed_pos = 0, .current_in_compressed_pos = 0, .num_elements = compressed->num_elements, .num_elements_returned = 0, }; bit_array_wrap(&iter->selector_data, compressed->slots, compressed->num_blocks * SIMPLE8B_BITS_PER_SELECTOR); } static void simple8brle_decompression_iterator_init_forward(Simple8bRleDecompressionIterator *iter, Simple8bRleSerialized *compressed) { simple8brle_decompression_iterator_init_common(iter, compressed); bit_array_iterator_init(&iter->selectors, &iter->selector_data); } static uint32 simple8brle_decompression_iterator_max_elements(Simple8bRleDecompressionIterator *iter, const Simple8bRleSerialized *compressed) { BitArrayIterator selectors; uint32 max_stored = 0; uint32 i; Assert(compressed->num_blocks > 0); bit_array_iterator_init(&selectors, iter->selectors.array); for (i = 0; i < compressed->num_blocks; i++) { uint8 selector = bit_array_iter_next(&selectors, SIMPLE8B_BITS_PER_SELECTOR); if (selector == 0) elog(ERROR, "invalid selector 0"); if (simple8brle_selector_is_rle(selector) && iter->compressed_data) { Assert(simple8brle_rledata_repeatcount(iter->compressed_data[i]) > 0); max_stored += simple8brle_rledata_repeatcount(iter->compressed_data[i]); } else { Assert(selector < SIMPLE8B_MAXCODE); max_stored += SIMPLE8B_NUM_ELEMENTS[selector]; } } return max_stored; } static void simple8brle_decompression_iterator_init_reverse(Simple8bRleDecompressionIterator *iter, Simple8bRleSerialized *compressed) { int32 skipped_in_last; simple8brle_decompression_iterator_init_common(iter, compressed); bit_array_iterator_init_rev(&iter->selectors, &iter->selector_data); skipped_in_last = simple8brle_decompression_iterator_max_elements(iter, compressed) - compressed->num_elements; Assert(NULL != iter->compressed_data); iter->current_block = simple8brle_block_create(bit_array_iter_next_rev(&iter->selectors, SIMPLE8B_BITS_PER_SELECTOR), iter->compressed_data[compressed->num_blocks - 1]); iter->current_in_compressed_pos = iter->current_block.num_elements_compressed - 1 - skipped_in_last; iter->current_compressed_pos = compressed->num_blocks - 2; return; } /* returning a struct produces noticeably better assembly on x86_64 than returning * is_done and is_null via pointers; it uses two registers instead of any memory reads. * Since it is also easier to read, we prefer it here. */ static Simple8bRleDecompressResult simple8brle_decompression_iterator_try_next_forward(Simple8bRleDecompressionIterator *iter) { uint64 uncompressed; if (iter->num_elements_returned >= iter->num_elements) return (Simple8bRleDecompressResult){ .is_done = true, }; if ((uint32) iter->current_in_compressed_pos >= iter->current_block.num_elements_compressed) { CheckCompressedData(iter->current_compressed_pos < iter->num_blocks); iter->current_block = simple8brle_block_create(bit_array_iter_next(&iter->selectors, SIMPLE8B_BITS_PER_SELECTOR), iter->compressed_data[iter->current_compressed_pos]); CheckCompressedData(iter->current_block.selector != 0); CheckCompressedData(iter->current_block.num_elements_compressed <= GLOBAL_MAX_ROWS_PER_COMPRESSION); iter->current_compressed_pos += 1; iter->current_in_compressed_pos = 0; } uncompressed = simple8brle_block_get_element(iter->current_block, iter->current_in_compressed_pos); iter->num_elements_returned += 1; iter->current_in_compressed_pos += 1; return (Simple8bRleDecompressResult){ .val = uncompressed, }; } static Simple8bRleDecompressResult simple8brle_decompression_iterator_try_next_reverse(Simple8bRleDecompressionIterator *iter) { uint64 uncompressed; if (iter->num_elements_returned >= iter->num_elements) return (Simple8bRleDecompressResult){ .is_done = true, }; if (iter->current_in_compressed_pos < 0) { iter->current_block = simple8brle_block_create(bit_array_iter_next_rev(&iter->selectors, SIMPLE8B_BITS_PER_SELECTOR), iter->compressed_data[iter->current_compressed_pos]); iter->current_in_compressed_pos = iter->current_block.num_elements_compressed - 1; iter->current_compressed_pos -= 1; } uncompressed = simple8brle_block_get_element(iter->current_block, iter->current_in_compressed_pos); iter->num_elements_returned += 1; iter->current_in_compressed_pos -= 1; return (Simple8bRleDecompressResult){ .val = uncompressed, }; } /************************** *** Simple8bRleBlock *** **************************/ static pg_attribute_always_inline Simple8bRleBlock simple8brle_block_create(uint8 selector, uint64 data) { Simple8bRleBlock block = (Simple8bRleBlock){ .selector = selector, .data = data, }; if (simple8brle_selector_is_rle(block.selector)) { block.num_elements_compressed = simple8brle_rledata_repeatcount(block.data); } else { block.num_elements_compressed = SIMPLE8B_NUM_ELEMENTS[block.selector]; } return block; } static inline uint64 simple8brle_block_get_element(Simple8bRleBlock block, uint32 position_in_value) { /* we're using 0 for end-of-stream, but haven't decided what to use it for */ if (block.selector == 0) { elog(ERROR, "end of compressed integer stream"); } else if (simple8brle_selector_is_rle(block.selector)) { /* decode rle-encoded integers */ uint64 repeated_value = simple8brle_rledata_value(block.data); CheckCompressedData(simple8brle_rledata_repeatcount(block.data) > 0); Assert(simple8brle_rledata_repeatcount(block.data) > position_in_value); return repeated_value; } else { uint64 compressed_value = block.data; uint32 bits_per_val = SIMPLE8B_BIT_LENGTH[block.selector]; /* decode bit-packed integers*/ Assert(position_in_value < SIMPLE8B_NUM_ELEMENTS[block.selector]); compressed_value >>= bits_per_val * position_in_value; compressed_value &= simple8brle_selector_get_bitmask(block.selector); return compressed_value; } pg_unreachable(); } /*************************** *** Utility Functions *** ***************************/ static pg_attribute_always_inline bool simple8brle_selector_is_rle(uint8 selector) { return selector == SIMPLE8B_RLE_SELECTOR; } static pg_attribute_always_inline uint32 simple8brle_rledata_repeatcount(uint64 rledata) { return (uint32) ((rledata >> SIMPLE8B_RLE_MAX_VALUE_BITS) & SIMPLE8B_RLE_MAX_COUNT_MASK); } static pg_attribute_always_inline uint64 simple8brle_rledata_value(uint64 rledata) { return rledata & SIMPLE8B_RLE_MAX_VALUE_MASK; } static pg_attribute_always_inline uint64 simple8brle_selector_get_bitmask(uint8 selector) { uint8 bitLen = SIMPLE8B_BIT_LENGTH[selector]; Assert(bitLen != 0); uint64 result = ((~0ULL) >> (64 - bitLen)); return result; } static pg_attribute_always_inline uint32 simple8brle_num_selector_slots_for_num_blocks(uint32 num_blocks) { return (num_blocks / SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT) + (num_blocks % SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT != 0 ? 1 : 0); } #ifdef HAVE_BUILTIN_CLZLL static inline uint32 simple8brle_bits_for_value(uint64 v) { if (v == 0) return 0; return 64 - __builtin_clzll(v); } #else static inline uint32 simple8brle_bits_for_value(uint64 v) { uint32 r = 0; if (v >= (1U << 31)) { v >>= 32; r += 32; } if (v >= (1U << 15)) { v >>= 16; r += 16; } if (v >= (1U << 7)) { v >>= 8; r += 8; } if (v >= (1U << 3)) { v >>= 4; r += 4; } if (v >= (1U << 1)) { v >>= 2; r += 2; } if (v >= (1U << 0)) { v >>= 1; r += 1; } return r; } #endif ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/simple8b_rle_bitarray.h���������������������������0000664�0000000�0000000�00000016313�15100345067�0026615�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "simple8b_rle.h" /* * This is a specialization of Simple8bRLE decoder for encoded 1 bit values * as they are used to store NULL flags in the compression methods as well as * the values for bool compression. * * Note that in the bool compression we store a validity map instead of a NULL * map, which is the same except the bits are inverted. * * The goal of this decoder is to support the following use cases: * * 1. Decompress the validity map of the bool compression method. * 2. Decompress the values of the bool compression method. * 3. Decompress the NULL map of the other compression methods into a validity * map in the ArrowArray. In this case the bits will be inverted. * * The reason we don't use the Simple8bRleBitmap is that the end result is an * array of bits and not bools. * * The complication comes from the RLE encoding of Simple8b while in the Arrow * validity bitmaps we have a straight array of bits. */ typedef struct Simple8bRleBitArray { uint64 *data; uint32 num_elements; uint32 num_blocks; uint16 num_ones; } Simple8bRleBitArray; static Simple8bRleBitArray simple8brle_bitarray_decompress(Simple8bRleSerialized *compressed, bool inverted) { Simple8bRleBitArray result = { 0 }; if (!compressed) { return result; } CheckCompressedData(compressed->num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); CheckCompressedData(compressed->num_blocks <= GLOBAL_MAX_ROWS_PER_COMPRESSION); const uint32 num_elements = compressed->num_elements; const uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(compressed->num_blocks); const uint64 *compressed_data = compressed->slots + num_selector_slots; const uint32 num_elements_padded = ((num_elements + 63) / 64 + 1) * 64; const uint32 num_blocks = compressed->num_blocks; result.data = palloc0(num_elements_padded / 64 * sizeof(uint64)); result.num_elements = num_elements; result.num_blocks = num_blocks; uint64 *restrict current_output_ptr = result.data; uint32 decompressed_index = 0; uint32 bit_position = 0; for (uint32 block_index = 0; block_index < num_blocks; block_index++) { const uint32 selector_slot = block_index / SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint32 selector_pos_in_slot = block_index % SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint64 slot_value = compressed->slots[selector_slot]; const uint8 selector_shift = selector_pos_in_slot * SIMPLE8B_BITS_PER_SELECTOR; const uint64 selector_mask = 0xFULL << selector_shift; const uint8 selector_value = (slot_value & selector_mask) >> selector_shift; Assert(selector_value < 16); uint64 block_data = compressed_data[block_index]; if (simple8brle_selector_is_rle(selector_value)) { /* * RLE block. */ uint32 repeat_count = simple8brle_rledata_repeatcount(block_data); CheckCompressedData(repeat_count <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * We might get an incorrect value from the corrupt data. Explicitly * truncate it to 0/1 in case the bool is not a standard bool type * which would have done it for us. */ const bool repeated_value = simple8brle_rledata_value(block_data) & 1; const bool bit_value = repeated_value ^ inverted; CheckCompressedData(decompressed_index + repeat_count <= num_elements); if (bit_value) { result.num_ones += repeat_count; /* Repeated 'ones' repeat_count times */ if ((repeat_count + bit_position) >= 64) { /* Head: Fill the remaining bits in the current word if not aligned */ if (bit_position > 0) { uint64_t head_bits = 64 - bit_position; uint64_t head_mask = (1ULL << head_bits) - 1; *current_output_ptr |= (head_mask << bit_position); repeat_count -= head_bits; decompressed_index += head_bits; current_output_ptr++; bit_position = 0; } /* Middle: Fill complete words */ uint64_t full_words = repeat_count / 64; for (uint64_t j = 0; j < full_words; j++) { *current_output_ptr = 0xFFFFFFFFFFFFFFFF; current_output_ptr++; } decompressed_index += full_words * 64; repeat_count -= full_words * 64; } /* Tail: Handle remaining bits (less than 64) */ if (repeat_count > 0) { Assert(repeat_count < 64); uint64_t tail_mask = (1ULL << (repeat_count & 63)) - 1; *current_output_ptr |= (tail_mask << bit_position); decompressed_index += repeat_count; bit_position = (bit_position + repeat_count) % 64; if (bit_position == 0) { current_output_ptr++; } else { current_output_ptr = result.data + (decompressed_index / 64); } } } else { decompressed_index += repeat_count; bit_position = decompressed_index % 64; current_output_ptr = result.data + (decompressed_index / 64); } Assert(decompressed_index <= num_elements); } else { /* * Bit-packed block. Since this is a bitmap, this block has 64 bits * packed. The last block might contain less than maximal possible * number of elements, but we have 64 bytes of padding on the right * so we don't care. */ CheckCompressedData(selector_value == 1); Assert(SIMPLE8B_BIT_LENGTH[selector_value] == 1); Assert(SIMPLE8B_NUM_ELEMENTS[selector_value] == 64); /* * We should require at least one element from the block. Previous * blocks might have had incorrect lengths, so this is not an * assertion. */ CheckCompressedData(decompressed_index < num_elements); CheckCompressedData(decompressed_index + 64 < num_elements_padded); /* Have to zero out the unused bits, so that the popcnt works properly. */ const int elements_this_block = Min(64, num_elements - decompressed_index); Assert(elements_this_block <= 64); Assert(elements_this_block > 0); block_data = block_data ^ -(uint64_t) inverted; block_data &= (~0ULL) >> (64 - elements_this_block); if (bit_position == 0) { /* The decoding is on exact 64bit boundaries */ *current_output_ptr = block_data; } else { /* We need to split the word */ uint64_t bits_remaining_in_word = 64 - bit_position; /* First part goes at the end of the current word */ *current_output_ptr |= (block_data << bit_position); /* Second part goes at the beginning of the next word */ *(current_output_ptr + 1) |= block_data >> bits_remaining_in_word; } #ifdef HAVE__BUILTIN_POPCOUNT result.num_ones += __builtin_popcountll(block_data); #else for (uint16 i = 0; i < 64; i++) result.num_ones += ((block_data >> i) & 1); #endif decompressed_index += 64; bit_position = decompressed_index % 64; current_output_ptr = result.data + (decompressed_index / 64); } } /* * We might have unpacked more because we work in full blocks, but at least * we shouldn't have unpacked less. */ CheckCompressedData(decompressed_index >= num_elements); Assert(decompressed_index <= num_elements_padded); /* * Might happen if we have stray ones in the higher unused bits of the last * block. */ CheckCompressedData(result.num_ones <= num_elements); return result; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/simple8b_rle_bitmap.h�����������������������������0000664�0000000�0000000�00000026062�15100345067�0026256�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * This is a specialization of Simple8bRLE decoder for bitmaps, i.e. where the * elements are only 0 and 1. It also counts the number of ones. */ #include "simple8b_rle.h" typedef struct Simple8bRleBitmap { /* Either the bools or prefix sums, depending on the decompression method. */ const void *data; uint16 num_elements; uint16 num_ones; } Simple8bRleBitmap; pg_attribute_always_inline static bool simple8brle_bitmap_get_at(const Simple8bRleBitmap *bitmap, uint16 i) { /* We have some padding on the right but we shouldn't overrun it. */ Assert(i < ((bitmap->num_elements + 63) / 64 + 1) * 64); return ((const bool *) bitmap->data)[i]; } pg_attribute_always_inline static uint16 simple8brle_bitmap_prefix_sum(const Simple8bRleBitmap *bitmap, uint16 i) { Assert(i < ((bitmap->num_elements + 63) / 64 + 1) * 64); return ((const uint16 *) bitmap->data)[i]; } pg_attribute_always_inline static uint16 simple8brle_bitmap_num_ones(const Simple8bRleBitmap *bitmap) { return bitmap->num_ones; } /* * Calculate prefix sum of bits instead of bitmap itself, because it's more * useful for gorilla decompression. Can be unused by other users of this * header. */ static Simple8bRleBitmap simple8brle_bitmap_prefixsums(Simple8bRleSerialized *compressed) pg_attribute_unused(); static Simple8bRleBitmap simple8brle_bitmap_prefixsums(Simple8bRleSerialized *compressed) { CheckCompressedData(compressed->num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); CheckCompressedData(compressed->num_blocks <= GLOBAL_MAX_ROWS_PER_COMPRESSION); const uint32 num_elements = compressed->num_elements; const uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(compressed->num_blocks); const uint64 *compressed_data = compressed->slots + num_selector_slots; /* * Pad to next multiple of 64 bytes on the right, so that we can simplify the * decompression loop and the get() function. Note that for get() we need at * least one byte of padding, hence the next multiple. */ const uint32 num_elements_padded = ((num_elements + 63) / 64 + 1) * 64; const uint32 num_blocks = compressed->num_blocks; uint16 *restrict prefix_sums = palloc(sizeof(uint16) * num_elements_padded); uint32 num_ones = 0; uint32 decompressed_index = 0; for (uint32 block_index = 0; block_index < num_blocks; block_index++) { const uint32 selector_slot = block_index / SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint32 selector_pos_in_slot = block_index % SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint64 slot_value = compressed->slots[selector_slot]; const uint8 selector_shift = selector_pos_in_slot * SIMPLE8B_BITS_PER_SELECTOR; const uint64 selector_mask = 0xFULL << selector_shift; const uint8 selector_value = (slot_value & selector_mask) >> selector_shift; Assert(selector_value < 16); uint64 block_data = compressed_data[block_index]; if (simple8brle_selector_is_rle(selector_value)) { /* * RLE block. */ const uint32 n_block_values = simple8brle_rledata_repeatcount(block_data); CheckCompressedData(n_block_values <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * We might get an incorrect value from the corrupt data. Explicitly * truncate it to 0/1 in case the bool is not a standard bool type * which would have done it for us. */ const bool repeated_value = simple8brle_rledata_value(block_data) & 1; CheckCompressedData(decompressed_index + n_block_values <= num_elements); if (repeated_value) { for (uint32 i = 0; i < n_block_values; i++) { prefix_sums[decompressed_index + i] = num_ones + i + 1; } num_ones += n_block_values; } else { for (uint32 i = 0; i < n_block_values; i++) { prefix_sums[decompressed_index + i] = num_ones; } } decompressed_index += n_block_values; Assert(decompressed_index <= num_elements); } else { /* * Bit-packed block. Since this is a bitmap, this block has 64 bits * packed. The last block might contain less than maximal possible * number of elements, but we have 64 bytes of padding on the right * so we don't care. */ CheckCompressedData(selector_value == 1); Assert(SIMPLE8B_BIT_LENGTH[selector_value] == 1); Assert(SIMPLE8B_NUM_ELEMENTS[selector_value] == 64); /* * We should require at least one element from the block. Previous * blocks might have had incorrect lengths, so this is not an * assertion. */ CheckCompressedData(decompressed_index < num_elements); /* Have to zero out the unused bits, so that the popcnt works properly. */ const int elements_this_block = Min(64, num_elements - decompressed_index); Assert(elements_this_block <= 64); Assert(elements_this_block > 0); block_data &= (~0ULL) >> (64 - elements_this_block); /* * The number of block elements should fit within padding. Previous * blocks might have had incorrect lengths, so this is not an * assertion. */ CheckCompressedData(decompressed_index + 64 < num_elements_padded); #ifdef HAVE__BUILTIN_POPCOUNT for (uint16 i = 0; i < 64; i++) { const uint16 word_prefix_sum = __builtin_popcountll(block_data & ((~0ULL) >> (63 - i))); prefix_sums[decompressed_index + i] = num_ones + word_prefix_sum; } num_ones += __builtin_popcountll(block_data); #else /* * Unfortunately, we have to have this fallback for Windows. */ for (uint16 i = 0; i < 64; i++) { const bool this_bit = (block_data >> i) & 1; num_ones += this_bit; prefix_sums[decompressed_index + i] = num_ones; } #endif decompressed_index += 64; } } /* * We might have unpacked more because we work in full blocks, but at least * we shouldn't have unpacked less. */ CheckCompressedData(decompressed_index >= num_elements); Assert(decompressed_index <= num_elements_padded); /* * Might happen if we have stray ones in the higher unused bits of the last * block. */ CheckCompressedData(num_ones <= num_elements); /* * Check that the number of ones actually fits into the uint16 counters * we're using. */ CheckCompressedData(((uint16) num_ones) == num_ones); Simple8bRleBitmap result = { .data = prefix_sums, .num_elements = num_elements, .num_ones = num_ones, }; return result; } static Simple8bRleBitmap simple8brle_bitmap_decompress(Simple8bRleSerialized *compressed) { CheckCompressedData(compressed->num_elements <= GLOBAL_MAX_ROWS_PER_COMPRESSION); CheckCompressedData(compressed->num_blocks <= GLOBAL_MAX_ROWS_PER_COMPRESSION); const uint32 num_elements = compressed->num_elements; const uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(compressed->num_blocks); const uint64 *compressed_data = compressed->slots + num_selector_slots; /* * Pad to next multiple of 64 bytes on the right, so that we can simplify the * decompression loop and the get() function. Note that for get() we need at * least one byte of padding, hence the next multiple. */ const uint32 num_elements_padded = ((num_elements + 63) / 64 + 1) * 64; const uint32 num_blocks = compressed->num_blocks; bool *restrict bitmap_bools_ = palloc(sizeof(bool) * num_elements_padded); uint32 num_ones = 0; uint32 decompressed_index = 0; for (uint32 block_index = 0; block_index < num_blocks; block_index++) { const uint32 selector_slot = block_index / SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint32 selector_pos_in_slot = block_index % SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint64 slot_value = compressed->slots[selector_slot]; const uint8 selector_shift = selector_pos_in_slot * SIMPLE8B_BITS_PER_SELECTOR; const uint64 selector_mask = 0xFULL << selector_shift; const uint8 selector_value = (slot_value & selector_mask) >> selector_shift; Assert(selector_value < 16); uint64 block_data = compressed_data[block_index]; if (simple8brle_selector_is_rle(selector_value)) { /* * RLE block. */ const uint32 n_block_values = simple8brle_rledata_repeatcount(block_data); CheckCompressedData(n_block_values <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * We might get an incorrect value from the corrupt data. Explicitly * truncate it to 0/1 in case the bool is not a standard bool type * which would have done it for us. */ const bool repeated_value = simple8brle_rledata_value(block_data) & 1; CheckCompressedData(decompressed_index + n_block_values <= num_elements); if (repeated_value) { for (uint32 i = 0; i < n_block_values; i++) { bitmap_bools_[decompressed_index + i] = true; } num_ones += n_block_values; } else { for (uint32 i = 0; i < n_block_values; i++) { bitmap_bools_[decompressed_index + i] = false; } } decompressed_index += n_block_values; Assert(decompressed_index <= num_elements); } else { /* * Bit-packed block. Since this is a bitmap, this block has 64 bits * packed. The last block might contain less than maximal possible * number of elements, but we have 64 bytes of padding on the right * so we don't care. */ CheckCompressedData(selector_value == 1); Assert(SIMPLE8B_BIT_LENGTH[selector_value] == 1); Assert(SIMPLE8B_NUM_ELEMENTS[selector_value] == 64); /* * We should require at least one element from the block. Previous * blocks might have had incorrect lengths, so this is not an * assertion. */ CheckCompressedData(decompressed_index < num_elements); /* Have to zero out the unused bits, so that the popcnt works properly. */ const int elements_this_block = Min(64, num_elements - decompressed_index); Assert(elements_this_block <= 64); Assert(elements_this_block > 0); block_data &= (~0ULL) >> (64 - elements_this_block); /* * The number of block elements should fit within padding. Previous * blocks might have had incorrect lengths, so this is not an * assertion. */ CheckCompressedData(decompressed_index + 64 < num_elements_padded); #ifdef HAVE__BUILTIN_POPCOUNT num_ones += __builtin_popcountll(block_data); #endif for (uint16 i = 0; i < 64; i++) { const bool this_bit = (block_data >> i) & 1; bitmap_bools_[decompressed_index + i] = this_bit; #ifndef HAVE__BUILTIN_POPCOUNT num_ones += this_bit; #endif } decompressed_index += 64; } } /* * We might have unpacked more because we work in full blocks, but at least * we shouldn't have unpacked less. */ CheckCompressedData(decompressed_index >= num_elements); Assert(decompressed_index <= num_elements_padded); /* * Might happen if we have stray ones in the higher unused bits of the last * block. */ CheckCompressedData(num_ones <= num_elements); Simple8bRleBitmap result = { .data = bitmap_bools_, .num_elements = num_elements, .num_ones = num_ones, }; /* Sanity check. */ #ifdef USE_ASSERT_CHECKING uint32 num_ones_2 = 0; for (uint32 i = 0; i < num_elements; i++) { num_ones_2 += simple8brle_bitmap_get_at(&result, i); } Assert(num_ones_2 == num_ones); #endif return result; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/simple8b_rle_decompress_all.h���������������������0000664�0000000�0000000�00000017650�15100345067�0030001�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #define FUNCTION_NAME_HELPER(X, Y) X##_##Y #define FUNCTION_NAME(X, Y) FUNCTION_NAME_HELPER(X, Y) /* * Specialization of bulk simple8brle decompression for a data type specified by * ELEMENT_TYPE macro. * * The buffer must have a padding of 63 elements after the last one, because * decompression is performed always in full blocks. */ static uint32 FUNCTION_NAME(simple8brle_decompress_all_buf, ELEMENT_TYPE)(Simple8bRleSerialized *compressed, ELEMENT_TYPE *restrict decompressed_values, uint32 n_buffer_elements) { const uint32 n_total_values = compressed->num_elements; /* * Caller must have allocated a properly sized buffer, see the comment above. */ Assert(n_buffer_elements >= n_total_values + 63); const uint32 num_selector_slots = simple8brle_num_selector_slots_for_num_blocks(compressed->num_blocks); const uint32 num_blocks = compressed->num_blocks; /* * Unpack the selector slots to get the selector values. Best done separately, * so that this loop can be vectorized. */ Assert(num_blocks <= GLOBAL_MAX_ROWS_PER_COMPRESSION); uint8 selector_values[GLOBAL_MAX_ROWS_PER_COMPRESSION]; const uint64 *slots = compressed->slots; for (uint32 block_index = 0; block_index < num_blocks; block_index++) { const uint32 selector_slot = block_index / SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint32 selector_pos_in_slot = block_index % SIMPLE8B_SELECTORS_PER_SELECTOR_SLOT; const uint64 slot_value = slots[selector_slot]; const uint8 selector_shift = selector_pos_in_slot * SIMPLE8B_BITS_PER_SELECTOR; const uint64 selector_mask = 0xFULL << selector_shift; const uint8 selector_value = (slot_value & selector_mask) >> selector_shift; selector_values[block_index] = selector_value; } /* * Now decompress the individual blocks. */ uint32 decompressed_index = 0; const uint64 *blocks = compressed->slots + num_selector_slots; for (uint32 block_index = 0; block_index < num_blocks; block_index++) { const uint8 selector_value = selector_values[block_index]; const uint64 block_data = blocks[block_index]; /* We don't see RLE blocks so often in the real data, <1% of blocks. */ if (unlikely(simple8brle_selector_is_rle(selector_value))) { const uint16 n_block_values = simple8brle_rledata_repeatcount(block_data); CheckCompressedData(n_block_values <= n_buffer_elements); CheckCompressedData(decompressed_index <= n_buffer_elements - n_block_values); const uint64 repeated_value_raw = simple8brle_rledata_value(block_data); const ELEMENT_TYPE repeated_value_converted = repeated_value_raw; CheckCompressedData(repeated_value_raw == (uint64) repeated_value_converted); for (uint16 i = 0; i < n_block_values; i++) { decompressed_values[decompressed_index + i] = repeated_value_converted; } decompressed_index += n_block_values; } else { /* Bit-packed blocks. Generate separate code for each block type. */ #define UNPACK_BLOCK(X) \ case (X): \ { \ /* \ * Error out it if the bit width is higher than that of the destination \ * type. We could just skip it, but this way the result of e.g. gorilla \ * decompression will be closer to what the row-by-row decompression \ * produces, which is easier for testing. \ */ \ const uint8 bits_per_value = SIMPLE8B_BIT_LENGTH[X]; \ CheckCompressedData(bits_per_value <= sizeof(ELEMENT_TYPE) * 8); \ \ /* \ * The last block might have less values than normal, but we have \ * padding at the end so we can unpack them all always for simpler \ * code. We still have to check if they fit, because the incoming data \ * might be incorrect. \ */ \ const uint16 n_block_values = SIMPLE8B_NUM_ELEMENTS[X]; \ CheckCompressedData(n_block_values <= n_buffer_elements); \ CheckCompressedData(decompressed_index <= n_buffer_elements - n_block_values); \ \ const uint64 bitmask = simple8brle_selector_get_bitmask(X); \ \ for (uint16 i = 0; i < n_block_values; i++) \ { \ const ELEMENT_TYPE value = (block_data >> (bits_per_value * i)) & bitmask; \ decompressed_values[decompressed_index + i] = value; \ } \ decompressed_index += n_block_values; \ break; \ } switch (selector_value) { UNPACK_BLOCK(1); UNPACK_BLOCK(2); UNPACK_BLOCK(3); UNPACK_BLOCK(4); UNPACK_BLOCK(5); UNPACK_BLOCK(6); UNPACK_BLOCK(7); UNPACK_BLOCK(8); UNPACK_BLOCK(9); UNPACK_BLOCK(10); UNPACK_BLOCK(11); UNPACK_BLOCK(12); UNPACK_BLOCK(13); UNPACK_BLOCK(14); default: /* * Can only get 0 here in case the data is corrupt. Doesn't * harm to report it right away, because this loop can't be * vectorized. */ CheckCompressedData(false); } #undef UNPACK_BLOCK } } /* * We can decompress more than expected because we work in full blocks, * but if we decompressed less, this means broken data. Better to report it * not to have an uninitialized tail. */ CheckCompressedData(decompressed_index >= n_total_values); Assert(decompressed_index <= n_buffer_elements); return n_total_values; } /* * The same function as above, but does palloc instead of taking the buffer as * an input. We mark it as possibly unused because it is used not for every * element type we have. */ static ELEMENT_TYPE *FUNCTION_NAME(simple8brle_decompress_all, ELEMENT_TYPE)(Simple8bRleSerialized *compressed, uint32 *n_) pg_attribute_unused(); static ELEMENT_TYPE * FUNCTION_NAME(simple8brle_decompress_all, ELEMENT_TYPE)(Simple8bRleSerialized *compressed, uint32 *n_) { const uint32 n_total_values = compressed->num_elements; Assert(n_total_values <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * We need a quite significant padding of 63 elements, not bytes, after the * last element, because we work in Simple8B blocks which can contain up to * 64 elements. */ const uint32 n_buffer_elements = n_total_values + 63; ELEMENT_TYPE *restrict decompressed_values = palloc(sizeof(ELEMENT_TYPE) * n_buffer_elements); *n_ = FUNCTION_NAME(simple8brle_decompress_all_buf, ELEMENT_TYPE)(compressed, decompressed_values, n_buffer_elements); return decompressed_values; } ����������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/uuid_compress.c�����������������������������������0000664�0000000�0000000�00000056561�15100345067�0025220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "uuid_compress.h" #include "adts/uint64_vec.h" #include "common/hashfn.h" #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "deltadelta.h" #include "dictionary.h" #include "lib/hyperloglog.h" #include "null.h" #include "simple8b_rle.h" #include "utils/palloc.h" #ifdef TS_USE_UMASH #include "import/umash.h" #endif typedef union UuidType { uint64 components[2]; pg_uuid_t uuid; } UuidType; typedef enum { UUID_COMPRESS_SUBTYPE_DELTADELTA = 0, UUID_COMPRESS_SUBTYPE_COUNT = 1, /* Must be last */ } UuidCompressSubtype; typedef struct UuidCompressed { CompressedDataHeaderFields; /* this uses 5 bytes */ uint8 subtype; uint16 num_nulls; uint32 timestamp_size; uint32 rand_b_and_variant_size; /* 8-byte alignment sentinel for the following fields */ uint64 alignment_sentinel[FLEXIBLE_ARRAY_MEMBER]; } UuidCompressed; static void pg_attribute_unused() assertions(void) { StaticAssertStmt(sizeof(UuidCompressed) == 16, "UuidCompressed wrong size"); StaticAssertStmt(offsetof(UuidCompressed, alignment_sentinel) % MAXIMUM_ALIGNOF == 0, "variable sized data must be 8-byte aligned"); } typedef struct UuidDecompressionIterator { DecompressionIterator base; int32 position; /* position within the total */ int32 total_elements; /* total number of entries plus nulls */ ArrowArray *uuid_buffer; /* init does a decompress_all to get this */ } UuidDecompressionIterator; /* * HyperLogLog parameters. * * The bit width is set such that the error rate is acceptable and also allocate * little memory. 8 uses 256 bytes and the error rate is 6.5% */ #define HLL_BIT_WIDTH 8 #define HLL_ERROR_RATE 0.065 #define HLL_MIN_CARDINALITY 20 /* * The UUID compressor is using delta delta compression for the first 8 * bytes of the UUID and stores the rest as a uint64_vec. At the same time * it keeps track of the cardinality of values. if the cardinality * indicates that we are better off with the dictionary compressor, we will * recompress it at the end. */ typedef struct UuidCompressor { /* Delta-delta encoding for timestamp, version and rand_a. */ DeltaDeltaCompressor *timestamp; /* We store the rand_b and variant parts together as a uint64_vec * to avoid having to store two separate bitmaps. */ uint64_vec rand_b_and_variant; /* HLL state to estimate the cardinality. This is used to check if * we are better off with recompressing the data as a dictionary. */ hyperLogLogState cardinality; /* Number of nulls in the data. */ uint16 num_nulls; /* Number of elements in the timestamp part. */ uint16 num_values; } UuidCompressor; typedef struct ExtendedCompressor { Compressor base; UuidCompressor *internal; } ExtendedCompressor; /* * Local helpers */ static void uuid_compressor_append_uuid(Compressor *compressor, Datum val); static void uuid_compressor_append_null_value(Compressor *compressor); static void *uuid_compressor_finish_and_reset(Compressor *compressor); static void decompression_iterator_init(UuidDecompressionIterator *iter, void *compressed, Oid element_type, bool forward); const Compressor uuid_compressor_initializer = { .append_val = uuid_compressor_append_uuid, .append_null = uuid_compressor_append_null_value, .is_full = NULL, .finish = uuid_compressor_finish_and_reset, }; /* * Compressor framework functions and definitions for the uuid_compress algorithm. */ extern UuidCompressor * uuid_compressor_alloc(void) { UuidCompressor *compressor = palloc0(sizeof(*compressor)); compressor->timestamp = delta_delta_compressor_alloc(); uint64_vec_init(&compressor->rand_b_and_variant, CurrentMemoryContext, TARGET_COMPRESSED_BATCH_SIZE); initHyperLogLog(&compressor->cardinality, HLL_BIT_WIDTH); return compressor; } extern void uuid_compressor_append_null(UuidCompressor *compressor) { delta_delta_compressor_append_null(compressor->timestamp); compressor->num_nulls++; } #ifdef TS_USE_UMASH static inline uint32 uuid_compress_hash(pg_uuid_t *uuid) { static struct umash_params params = { 0 }; if (params.poly[0][0] == 0) { umash_params_derive(¶ms, 0x12345abcdef67890ULL, NULL); Assert(params.poly[0][0] != 0); } uint64 h = umash_full(¶ms, /* seed = */ ~0ULL, /* which = */ 0, uuid->data, 16); return (uint32) (h ^ (h >> 32)); } #else static inline uint32 uuid_compress_hash(pg_uuid_t *uuid) { return hash_bytes((unsigned char *) uuid->data, sizeof(*uuid)); } #endif extern void uuid_compressor_append_value(UuidCompressor *compressor, pg_uuid_t next_val) { uint64_t components[2]; memcpy(components, next_val.data, sizeof(components)); /* The first component is the timestamp, version and rand_a. */ uint64_t timestamp = pg_ntoh64(components[0]); /* The second part is the rand_b and variant. */ uint64_t rand_b_and_variant = components[1]; delta_delta_compressor_append_value(compressor->timestamp, timestamp); uint64_vec_append(&compressor->rand_b_and_variant, rand_b_and_variant); uint32 h = uuid_compress_hash(&next_val); addHyperLogLog(&compressor->cardinality, h); compressor->num_values++; } static size_t uuid_compressor_estimate_dictionary_storage(UuidCompressor *compressor, size_t nulls_compressed_size) { double cardinality = (double) compressor->rand_b_and_variant.num_elements; double cardinality_and_error = cardinality; /* Don't use HLL if there are too few elements to estimate the cardinality. */ if (cardinality > HLL_MIN_CARDINALITY) { cardinality = estimateHyperLogLog(&compressor->cardinality); cardinality_and_error = cardinality * (1.0 - HLL_ERROR_RATE); } int array_index_bytes = ((int) cardinality_and_error * 5 + 63) / 64 * 8; double estimated_dictionary_storage = /* 16 bytes per values in dictionary/array/values */ cardinality_and_error * 16 + /* a single RLE block for the sizes in dictionary/array/sizes */ 16 + /* no nulls in dictionary/array/nulls */ 0 + /* 5 bits on average for the indexes in dictionary/array/indexes */ array_index_bytes + /* storing nulls is the same as in the delta-delta compressor */ nulls_compressed_size; return estimated_dictionary_storage; } extern void * uuid_compressor_finish(UuidCompressor *compressor) { if (compressor == NULL) return NULL; if (compressor->num_values == 0) return NULL; size_t nulls_compressed_size = 0; size_t timestamp_compressed_size = delta_delta_compressor_compressed_size(compressor->timestamp, &nulls_compressed_size); size_t estimated_dictionary_storage = uuid_compressor_estimate_dictionary_storage(compressor, nulls_compressed_size); size_t rand_b_and_variant_compressed_size = compressor->rand_b_and_variant.num_elements * sizeof(uint64_t); Assert(compressor->rand_b_and_variant.num_elements == compressor->num_values); size_t total_compressed_size = sizeof(UuidCompressed) + timestamp_compressed_size + rand_b_and_variant_compressed_size; /* TODO: this is temporary: to iterate over the delta-delta compressed data * we need to finalize the compression, so even if we knew that the dictionary * compression is better we still need to allocate, finish and memcpy the * entries. This is clearly a waste. To solve this we will need an interface * to iterate over compressed data without finalizing it. */ char *compressed_data = palloc(total_compressed_size); UuidCompressed *compressed = (UuidCompressed *) compressed_data; SET_VARSIZE(&compressed->vl_len_, total_compressed_size); compressed->compression_algorithm = COMPRESSION_ALGORITHM_UUID; compressed->num_nulls = compressor->num_nulls; Ensure(compressed->num_nulls == compressor->num_nulls, "unexpected number of nulls, it doesn't fit into the header"); compressed->subtype = UUID_COMPRESS_SUBTYPE_DELTADELTA; compressed->timestamp_size = timestamp_compressed_size; compressed->rand_b_and_variant_size = rand_b_and_variant_compressed_size; compressed_data += sizeof(*compressed); char *timestamp_compressed_data = compressed_data; compressed_data = delta_delta_compressor_finish_into(compressor->timestamp, timestamp_compressed_data); /* Make sure delta-delta took exactly the size it said it will */ Assert(compressed_data - timestamp_compressed_data == (long) timestamp_compressed_size); memcpy(compressed_data, compressor->rand_b_and_variant.data, rand_b_and_variant_compressed_size); if (total_compressed_size > estimated_dictionary_storage) { /* Recompress as dictionary */ DictionaryCompressor *dict_compressor = dictionary_compressor_alloc(UUIDOID); DecompressionIterator *iter = delta_delta_decompression_iterator_from_datum_forward(PointerGetDatum( timestamp_compressed_data), INT8OID); uint32 value_position = 0; for (DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); !r.is_done; r = delta_delta_decompression_iterator_try_next_forward(iter)) { if (r.is_null) { dictionary_compressor_append_null(dict_compressor); } else { UuidType uuid_type; uuid_type.components[0] = pg_hton64(DatumGetInt64(r.val)); uuid_type.components[1] = compressor->rand_b_and_variant.data[value_position]; dictionary_compressor_append(dict_compressor, UUIDPGetDatum(&uuid_type.uuid)); ++value_position; } } void *dict_compressed = dictionary_compressor_finish(dict_compressor); if (VARSIZE(dict_compressed) < total_compressed_size) { /* We are better off with the dictionary compression, inline with the estimated size */ pfree(compressed); compressed = dict_compressed; } else { /* We are better off with the original compression, contrary to the estimated size. * This is OK, as the estimate is probabilistic. */ pfree(dict_compressed); } pfree(dict_compressor); pfree(iter); } return compressed; } extern bool uuid_compressed_has_nulls(const CompressedDataHeader *header) { const UuidCompressed *uc = (const UuidCompressed *) header; return uc->num_nulls > 0; } extern DecompressResult uuid_decompression_iterator_try_next_forward(DecompressionIterator *iter) { Assert(iter->compression_algorithm == COMPRESSION_ALGORITHM_UUID && iter->forward); Assert(iter->element_type == UUIDOID); UuidDecompressionIterator *uuid_iter = (UuidDecompressionIterator *) iter; Assert(uuid_iter->uuid_buffer != NULL); Assert(uuid_iter->uuid_buffer->buffers != NULL); Assert(uuid_iter->uuid_buffer->buffers[1] != NULL); const uint64 *validity_bitmap = uuid_iter->uuid_buffer->buffers[0]; UuidType *uuid_values = (UuidType *) uuid_iter->uuid_buffer->buffers[1]; if (uuid_iter->position >= uuid_iter->total_elements) return (DecompressResult){ .is_done = true, }; /* check nulls */ if (validity_bitmap != NULL) { if (!arrow_row_is_valid(validity_bitmap, uuid_iter->position)) { uuid_iter->position++; return (DecompressResult){ .is_null = true, }; } } UuidType *current_uuid = &uuid_values[uuid_iter->position]; uuid_iter->position++; return (DecompressResult){ .val = PointerGetDatum(current_uuid), }; } extern DecompressionIterator * uuid_decompression_iterator_from_datum_forward(Datum uuid_compressed, Oid element_type) { UuidDecompressionIterator *iterator = palloc0(sizeof(*iterator)); CheckCompressedData(DatumGetPointer(uuid_compressed) != NULL); decompression_iterator_init(iterator, (void *) PG_DETOAST_DATUM(uuid_compressed), element_type, true); return &iterator->base; } extern DecompressResult uuid_decompression_iterator_try_next_reverse(DecompressionIterator *iter) { Assert(iter->compression_algorithm == COMPRESSION_ALGORITHM_UUID && !iter->forward); Assert(iter->element_type == UUIDOID); UuidDecompressionIterator *uuid_iter = (UuidDecompressionIterator *) iter; Assert(uuid_iter->uuid_buffer != NULL); Assert(uuid_iter->uuid_buffer->buffers != NULL); Assert(uuid_iter->uuid_buffer->buffers[1] != NULL); const uint64 *validity_bitmap = uuid_iter->uuid_buffer->buffers[0]; UuidType *uuid_values = (UuidType *) uuid_iter->uuid_buffer->buffers[1]; if (uuid_iter->position < 0) return (DecompressResult){ .is_done = true, }; /* check nulls */ if (validity_bitmap != NULL) { if (!arrow_row_is_valid(validity_bitmap, uuid_iter->position)) { uuid_iter->position--; return (DecompressResult){ .is_null = true, }; } } Assert(uuid_iter->position >= 0); UuidType *current_uuid = &uuid_values[uuid_iter->position]; uuid_iter->position--; return (DecompressResult){ .val = PointerGetDatum(current_uuid), }; } extern DecompressionIterator * uuid_decompression_iterator_from_datum_reverse(Datum uuid_compressed, Oid element_type) { UuidDecompressionIterator *iterator = palloc(sizeof(*iterator)); CheckCompressedData(DatumGetPointer(uuid_compressed) != NULL); decompression_iterator_init(iterator, (void *) PG_DETOAST_DATUM(uuid_compressed), element_type, false); return &iterator->base; } extern void uuid_compressed_send(CompressedDataHeader *header, StringInfo buffer) { const UuidCompressed *data = (UuidCompressed *) header; Assert(header->compression_algorithm == COMPRESSION_ALGORITHM_UUID); pq_sendbyte(buffer, data->subtype); pq_sendint16(buffer, data->num_nulls); pq_sendint32(buffer, data->timestamp_size); pq_sendint32(buffer, data->rand_b_and_variant_size); char *ptr = (char *) data->alignment_sentinel; deltadelta_compressed_send((CompressedDataHeader *) ptr, buffer); ptr += data->timestamp_size; uint64 *rand_b_and_variant = (uint64 *) ptr; uint32 num_elements = data->rand_b_and_variant_size / sizeof(uint64); for (uint32 i = 0; i < num_elements; i++) pq_sendint64(buffer, rand_b_and_variant[i]); } extern Datum uuid_compressed_recv(StringInfo buffer) { size_t total_compressed_sized = 0; uint8 subtype = pq_getmsgbyte(buffer); CheckCompressedData(subtype < UUID_COMPRESS_SUBTYPE_COUNT); uint16 num_nulls = pq_getmsgint(buffer, 2); uint32 timestamp_size = pq_getmsgint32(buffer); uint32 rand_b_and_variant_size = pq_getmsgint32(buffer); /* The timestamp_size must accommodate the delta-delta header (24 bytes) */ CheckCompressedData(timestamp_size > 24); CheckCompressedData(rand_b_and_variant_size > 0); CheckCompressedData(rand_b_and_variant_size % sizeof(uint64) == 0); CheckCompressedData(timestamp_size % sizeof(uint64) == 0); CheckCompressedData(rand_b_and_variant_size / sizeof(uint64) < GLOBAL_MAX_ROWS_PER_COMPRESSION); /* A good enough to catch totally bogus timestamp_size values, the actual limit is slightly * tighter */ CheckCompressedData(timestamp_size < (GLOBAL_MAX_ROWS_PER_COMPRESSION * (sizeof(uint64) + 1))); uint32 total_values = num_nulls + rand_b_and_variant_size / sizeof(uint64); CheckCompressedData(total_values < GLOBAL_MAX_ROWS_PER_COMPRESSION); total_compressed_sized = sizeof(UuidCompressed) + timestamp_size + rand_b_and_variant_size; CheckCompressedData(total_compressed_sized <= MaxAllocSize); char *result = palloc(total_compressed_sized); UuidCompressed *compressed = (UuidCompressed *) result; compressed->subtype = subtype; compressed->num_nulls = num_nulls; compressed->timestamp_size = timestamp_size; compressed->rand_b_and_variant_size = rand_b_and_variant_size; SET_VARSIZE(&compressed->vl_len_, total_compressed_sized); compressed->compression_algorithm = COMPRESSION_ALGORITHM_UUID; Datum delta_delta_compressed = deltadelta_compressed_recv(buffer); size_t delta_delta_compressed_size = VARSIZE(delta_delta_compressed); CheckCompressedData(delta_delta_compressed_size == timestamp_size); memcpy(result + sizeof(UuidCompressed), DatumGetPointer(delta_delta_compressed), delta_delta_compressed_size); uint64 *rand_b_and_variant = (uint64 *) (result + sizeof(UuidCompressed) + delta_delta_compressed_size); uint32 num_elements = rand_b_and_variant_size / sizeof(uint64); for (uint32 i = 0; i < num_elements; i++) rand_b_and_variant[i] = pq_getmsgint64(buffer); PG_RETURN_POINTER(result); } extern Compressor * uuid_compressor_for_type(Oid element_type) { ExtendedCompressor *compressor = palloc(sizeof(*compressor)); switch (element_type) { case UUIDOID: *compressor = (ExtendedCompressor){ .base = uuid_compressor_initializer }; return &compressor->base; default: elog(ERROR, "invalid type for uuid compressor \"%s\"", format_type_be(element_type)); } pg_unreachable(); } /* * Cross-module functions for the uuid_compress algorithm. */ extern Datum tsl_uuid_compressor_append(PG_FUNCTION_ARGS) { MemoryContext old_context; MemoryContext agg_context; UuidCompressor *compressor = (UuidCompressor *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "tsl_uuid_compressor_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (compressor == NULL) { compressor = uuid_compressor_alloc(); if (PG_NARGS() > 2) elog(ERROR, "append expects two arguments"); } if (PG_ARGISNULL(1)) uuid_compressor_append_null(compressor); else { pg_uuid_t *uuid = DatumGetUUIDP(PG_GETARG_DATUM(1)); Ensure(uuid != NULL, "invalid UUID"); uuid_compressor_append_value(compressor, *uuid); } MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(compressor); } extern Datum tsl_uuid_compressor_finish(PG_FUNCTION_ARGS) { UuidCompressor *compressor = PG_ARGISNULL(0) ? NULL : (UuidCompressor *) PG_GETARG_POINTER(0); void *compressed; if (compressor == NULL) PG_RETURN_NULL(); compressed = uuid_compressor_finish(compressor); if (compressed == NULL) PG_RETURN_NULL(); PG_RETURN_POINTER(compressed); } extern ArrowArray * uuid_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx) { Assert(element_type == UUIDOID); MemoryContext old_context; ArrowArray *timestamp_array = NULL; CheckCompressedData(DatumGetPointer(compressed) != NULL); void *detoasted = PG_DETOAST_DATUM(compressed); StringInfoData si = { .data = detoasted, .len = VARSIZE_ANY(compressed) }; UuidCompressed *header = consumeCompressedData(&si, sizeof(UuidCompressed)); char *timestamp_compressed_data = NULL; char *rand_b_and_variant_compressed_data; CheckCompressedData(header->compression_algorithm == COMPRESSION_ALGORITHM_UUID); CheckCompressedData(header->subtype == UUID_COMPRESS_SUBTYPE_DELTADELTA); /* The timestamp_size must accommodate the delta-delta header (24 bytes) */ CheckCompressedData(header->timestamp_size > 24); CheckCompressedData(header->rand_b_and_variant_size > 0); CheckCompressedData(header->rand_b_and_variant_size % sizeof(uint64) == 0); CheckCompressedData(header->timestamp_size % sizeof(uint64) == 0); /* A good enough to catch totally bogus timestamp_size values, the actual limit is slightly * tighter */ CheckCompressedData(header->timestamp_size < (GLOBAL_MAX_ROWS_PER_COMPRESSION * (sizeof(uint64) + 1))); timestamp_compressed_data = consumeCompressedData(&si, header->timestamp_size); rand_b_and_variant_compressed_data = consumeCompressedData(&si, header->rand_b_and_variant_size); int32 num_values = (int32) (header->rand_b_and_variant_size / sizeof(uint64)); int32 total_elements = (int32) header->num_nulls + num_values; CheckCompressedData(num_values > 0); CheckCompressedData(num_values < GLOBAL_MAX_ROWS_PER_COMPRESSION); old_context = MemoryContextSwitchTo(dest_mctx); /* Make sure we use a 128bit aligned buffer */ char *unaligned = (char *) palloc((total_elements * sizeof(UuidType)) + 15); UuidType *uuid_buffer = (UuidType *) TYPEALIGN(16, unaligned); /* * Note : the validity bits from the delta delta compression is directly usable * in the result array, but the decompressed ingegers will be replaced * with the UUIDs */ timestamp_array = delta_delta_decompress_all(PointerGetDatum(timestamp_compressed_data), INT8OID, CurrentMemoryContext); CheckCompressedData(timestamp_array->length == total_elements); CheckCompressedData(timestamp_array->null_count == header->num_nulls); uint64 *rand_b_and_variant = (uint64 *) palloc(header->rand_b_and_variant_size); memcpy(rand_b_and_variant, rand_b_and_variant_compressed_data, header->rand_b_and_variant_size); uint64 *validity_bitmap = NULL; uint64 *timestamp_values = (uint64 *) timestamp_array->buffers[1]; if (header->num_nulls > 0) { Assert(timestamp_array->buffers[0] != NULL); validity_bitmap = (uint64 *) timestamp_array->buffers[0]; int value_position = 0; for (int i = 0; i < total_elements; i++) { if (arrow_row_is_valid(validity_bitmap, i)) { Assert(value_position < num_values); uuid_buffer[i].components[0] = pg_ntoh64(timestamp_values[i]); uuid_buffer[i].components[1] = rand_b_and_variant[value_position]; ++value_position; } } } else { for (int i = 0; i < total_elements; i++) { uuid_buffer[i].components[0] = pg_ntoh64(timestamp_values[i]); uuid_buffer[i].components[1] = rand_b_and_variant[i]; } } /* * At this point I combined the uncompressed data in the rand_b_and_variant array * and the freshly decompressed data from the delta delta bulk decompressison. * I now free the temp data. Note that `timestamp_values` is the same pointer * as timestamp_array->buffers[1] , the second buffer in the ArrowArray. * This will be replaced with the uuid array. * */ pfree(rand_b_and_variant); pfree(timestamp_values); MemoryContextSwitchTo(old_context); /* * This is the only fixup needed for the ArrowArray. Everything else * is valid data as generated by delta_delta_decompress_all() */ timestamp_array->buffers[1] = (uint8 *) uuid_buffer; return timestamp_array; } /* * Local helpers */ static void uuid_compressor_append_uuid(Compressor *compressor, Datum val) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = uuid_compressor_alloc(); pg_uuid_t *uuid = DatumGetUUIDP(val); Ensure(uuid != NULL, "invalid UUID"); uuid_compressor_append_value(extended->internal, *uuid); } static void uuid_compressor_append_null_value(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; if (extended->internal == NULL) extended->internal = uuid_compressor_alloc(); uuid_compressor_append_null(extended->internal); } static void * uuid_compressor_finish_and_reset(Compressor *compressor) { ExtendedCompressor *extended = (ExtendedCompressor *) compressor; void *compressed = NULL; if (extended != NULL && extended->internal != NULL) { compressed = uuid_compressor_finish(extended->internal); pfree(extended->internal); extended->internal = NULL; } return compressed; } static void decompression_iterator_init(UuidDecompressionIterator *iter, void *compressed, Oid element_type, bool forward) { Assert(element_type == UUIDOID); ArrowArray *arrow_array = uuid_decompress_all(PointerGetDatum(compressed), element_type, CurrentMemoryContext); int32 total_elements = arrow_array->length; *iter = (UuidDecompressionIterator){ .base = { .compression_algorithm = COMPRESSION_ALGORITHM_UUID, .forward = forward, .element_type = element_type, .try_next = (forward ? uuid_decompression_iterator_try_next_forward : uuid_decompression_iterator_try_next_reverse) }, .position = (forward ? 0 : total_elements - 1), .total_elements = total_elements, .uuid_buffer = arrow_array, }; } static void pg_attribute_unused() silence_unused_warning(void) { simple8brle_serialized_recv(NULL); } �����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/algorithms/uuid_compress.h�����������������������������������0000664�0000000�0000000�00000006024�15100345067�0025212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * uuid_compress is used to encode UUID values where there are 4 distinct parts * that are encoded separately. The UUID being encoded is optimised for the v7 * UUID format. The four parts are: * * - timestamp : (delta-delta encoding) * - the version number and variant number concatenated : (simple8b_rle) * - rand_a : is encoded as an array of bits * - rand_b : is encoded as an array of bits */ #include <postgres.h> #include "compression/compression.h" #include <fmgr.h> #include <lib/stringinfo.h> #include <utils/uuid.h> typedef struct UuidCompressor UuidCompressor; typedef struct UuidCompressed UuidCompressed; typedef struct UuidDecompressionIterator UuidDecompressionIterator; /* * Compressor framework functions and definitions for the uuid_compress algorithm. */ extern UuidCompressor *uuid_compressor_alloc(void); extern void uuid_compressor_append_null(UuidCompressor *compressor); extern void uuid_compressor_append_value(UuidCompressor *compressor, pg_uuid_t next_val); extern void *uuid_compressor_finish(UuidCompressor *compressor); extern bool uuid_compressed_has_nulls(const CompressedDataHeader *header); extern DecompressResult uuid_decompression_iterator_try_next_forward(DecompressionIterator *iter); extern DecompressionIterator *uuid_decompression_iterator_from_datum_forward(Datum uuid_compressed, Oid element_type); extern DecompressResult uuid_decompression_iterator_try_next_reverse(DecompressionIterator *iter); extern DecompressionIterator *uuid_decompression_iterator_from_datum_reverse(Datum uuid_compressed, Oid element_type); extern void uuid_compressed_send(CompressedDataHeader *header, StringInfo buffer); extern ArrowArray *uuid_decompress_all(Datum compressed, Oid element_type, MemoryContext dest_mctx); extern Datum uuid_compressed_recv(StringInfo buf); extern Compressor *uuid_compressor_for_type(Oid element_type); #define UUID_COMPRESS_ALGORITHM_DEFINITION \ { \ .iterator_init_forward = uuid_decompression_iterator_from_datum_forward, \ .iterator_init_reverse = uuid_decompression_iterator_from_datum_reverse, \ .decompress_all = uuid_decompress_all, .compressed_data_send = uuid_compressed_send, \ .compressed_data_recv = uuid_compressed_recv, \ .compressor_for_type = uuid_compressor_for_type, \ .compressed_data_storage = TOAST_STORAGE_EXTERNAL, \ } /* * Cross-module functions for the uuid_compress algorithm. */ extern Datum tsl_uuid_compressor_append(PG_FUNCTION_ARGS); extern Datum tsl_uuid_compressor_finish(PG_FUNCTION_ARGS); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/api.c��������������������������������������������������������0000664�0000000�0000000�00000104247�15100345067�0020732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* This file contains the implementation for SQL utility functions that * compress and decompress chunks */ #include <postgres.h> #include <access/tableam.h> #include <access/xact.h> #include <catalog/dependency.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/pg_am.h> #include <commands/event_trigger.h> #include <commands/tablecmds.h> #include <commands/trigger.h> #include <libpq-fe.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/parsenodes.h> #include <nodes/pg_list.h> #include <parser/parse_func.h> #include <postgres_ext.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <tcop/utility.h> #include <trigger.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/fmgrprotos.h> #include <utils/inval.h> #include "compat/compat.h" #include "annotations.h" #include "api.h" #include "cache.h" #include "chunk.h" #include "compression.h" #include "compression_storage.h" #include "create.h" #include "debug_point.h" #include "error_utils.h" #include "errors.h" #include "hypercube.h" #include "hypertable.h" #include "hypertable_cache.h" #include "recompress.h" #include "scan_iterator.h" #include "scanner.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/chunk_column_stats.h" #include "ts_catalog/compression_chunk_size.h" #include "ts_catalog/compression_settings.h" #include "ts_catalog/continuous_agg.h" #include "utils.h" #include "wal_utils.h" typedef struct CompressChunkCxt { Hypertable *srcht; Chunk *srcht_chunk; /* chunk from srcht */ Hypertable *compress_ht; /*compressed table for srcht */ } CompressChunkCxt; static Oid get_compressed_chunk_index_for_recompression(Chunk *uncompressed_chunk); static Node * create_dummy_query() { RawStmt *query = NULL; query = makeNode(RawStmt); query->stmt = (Node *) makeNode(SelectStmt); return (Node *) query; } void compression_chunk_size_catalog_insert(int32 src_chunk_id, const RelationSize *src_size, int32 compress_chunk_id, const RelationSize *compress_size, int64 rowcnt_pre_compression, int64 rowcnt_post_compression, int64 rowcnt_frozen) { Catalog *catalog = ts_catalog_get(); Relation rel; TupleDesc desc; CatalogSecurityContext sec_ctx; Datum values[Natts_compression_chunk_size]; bool nulls[Natts_compression_chunk_size] = { false }; rel = table_open(catalog_get_table_id(catalog, COMPRESSION_CHUNK_SIZE), RowExclusiveLock); desc = RelationGetDescr(rel); memset(values, 0, sizeof(values)); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_chunk_id)] = Int32GetDatum(src_chunk_id); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_chunk_id)] = Int32GetDatum(compress_chunk_id); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_heap_size)] = Int64GetDatum(src_size->heap_size); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_toast_size)] = Int64GetDatum(src_size->toast_size); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_index_size)] = Int64GetDatum(src_size->index_size); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_heap_size)] = Int64GetDatum(compress_size->heap_size); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_toast_size)] = Int64GetDatum(compress_size->toast_size); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_index_size)] = Int64GetDatum(compress_size->index_size); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_pre_compression)] = Int64GetDatum(rowcnt_pre_compression); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_post_compression)] = Int64GetDatum(rowcnt_post_compression); values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_frozen_immediately)] = Int64GetDatum(rowcnt_frozen); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); table_close(rel, RowExclusiveLock); } static int compression_chunk_size_catalog_update_merged(int32 chunk_id, const RelationSize *size, int32 merge_chunk_id, const RelationSize *merge_size, int64 merge_rowcnt_pre_compression, int64 merge_rowcnt_post_compression) { ScanIterator iterator = ts_scan_iterator_create(COMPRESSION_CHUNK_SIZE, RowExclusiveLock, CurrentMemoryContext); bool updated = false; iterator.ctx.index = catalog_get_index(ts_catalog_get(), COMPRESSION_CHUNK_SIZE, COMPRESSION_CHUNK_SIZE_PKEY); ts_scan_iterator_scan_key_init(&iterator, Anum_compression_chunk_size_pkey_chunk_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(chunk_id)); ts_scanner_foreach(&iterator) { Datum values[Natts_compression_chunk_size]; bool replIsnull[Natts_compression_chunk_size] = { false }; bool repl[Natts_compression_chunk_size] = { false }; bool should_free; TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; heap_deform_tuple(tuple, ts_scanner_get_tupledesc(ti), values, replIsnull); /* Increment existing sizes with sizes from uncompressed chunk. */ values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_heap_size)] = Int64GetDatum(size->heap_size + DatumGetInt64(values[AttrNumberGetAttrOffset( Anum_compression_chunk_size_uncompressed_heap_size)])); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_heap_size)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_toast_size)] = Int64GetDatum(size->toast_size + DatumGetInt64(values[AttrNumberGetAttrOffset( Anum_compression_chunk_size_uncompressed_toast_size)])); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_toast_size)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_index_size)] = Int64GetDatum(size->index_size + DatumGetInt64(values[AttrNumberGetAttrOffset( Anum_compression_chunk_size_uncompressed_index_size)])); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_uncompressed_index_size)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_heap_size)] = Int64GetDatum(merge_size->heap_size); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_heap_size)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_toast_size)] = Int64GetDatum(merge_size->toast_size); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_toast_size)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_index_size)] = Int64GetDatum(merge_size->index_size); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_compressed_index_size)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_pre_compression)] = Int64GetDatum(merge_rowcnt_pre_compression + DatumGetInt64(values[AttrNumberGetAttrOffset( Anum_compression_chunk_size_numrows_pre_compression)])); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_pre_compression)] = true; values[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_post_compression)] = Int64GetDatum(merge_rowcnt_post_compression + DatumGetInt64(values[AttrNumberGetAttrOffset( Anum_compression_chunk_size_numrows_post_compression)])); repl[AttrNumberGetAttrOffset(Anum_compression_chunk_size_numrows_post_compression)] = true; new_tuple = heap_modify_tuple(tuple, ts_scanner_get_tupledesc(ti), values, replIsnull, repl); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); updated = true; break; } ts_scan_iterator_end(&iterator); ts_scan_iterator_close(&iterator); return updated; } static void get_hypertable_or_cagg_name(Hypertable *ht, Name objname) { ContinuousAggHypertableStatus status = ts_continuous_agg_hypertable_status(ht->fd.id); if (status == HypertableIsNotContinuousAgg || status == HypertableIsRawTable) namestrcpy(objname, NameStr(ht->fd.table_name)); else if (status == HypertableIsMaterialization) { ContinuousAgg *cagg = ts_continuous_agg_find_by_mat_hypertable_id(ht->fd.id, false); namestrcpy(objname, NameStr(cagg->data.user_view_name)); } else { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("unexpected hypertable status for %s %d", NameStr(ht->fd.table_name), status))); } } static void compresschunkcxt_init(CompressChunkCxt *cxt, Cache *hcache, Oid hypertable_relid, Oid chunk_relid) { Hypertable *srcht = ts_hypertable_cache_get_entry(hcache, hypertable_relid, CACHE_FLAG_NONE); Hypertable *compress_ht; Chunk *srcchunk; ts_hypertable_permissions_check(srcht->main_table_relid, GetUserId()); if (!TS_HYPERTABLE_HAS_COMPRESSION_TABLE(srcht)) { NameData cagg_ht_name; get_hypertable_or_cagg_name(srcht, &cagg_ht_name); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("columnstore not enabled on \"%s\"", NameStr(cagg_ht_name)), errdetail("It is not possible to convert chunks to columnstore on a hypertable or" " continuous aggregate that does not have columnstore enabled."), errhint("Enable columnstore using ALTER TABLE/MATERIALIZED VIEW with" " the timescaledb.enable_columnstore option."))); } compress_ht = ts_hypertable_get_by_id(srcht->fd.compressed_hypertable_id); if (compress_ht == NULL) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("missing columnstore-enabled hypertable"))); /* user has to be the owner of the compression table too */ ts_hypertable_permissions_check(compress_ht->main_table_relid, GetUserId()); if (!srcht->space) /* something is wrong */ ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("missing hyperspace for hypertable"))); /* refetch the srcchunk with all attributes filled in */ srcchunk = ts_chunk_get_by_relid(chunk_relid, true); ts_chunk_validate_chunk_status_for_operation(srcchunk, CHUNK_COMPRESS, true); cxt->srcht = srcht; cxt->compress_ht = compress_ht; cxt->srcht_chunk = srcchunk; } static Chunk * find_chunk_to_merge_into(Hypertable *ht, Chunk *current_chunk) { int64 max_chunk_interval, current_chunk_interval = 0, compressed_chunk_interval = 0; Chunk *previous_chunk; Point *p; const Dimension *time_dim = hyperspace_get_open_dimension(ht->space, 0); if (!time_dim || time_dim->fd.compress_interval_length == 0) return NULL; Assert(current_chunk->cube->num_slices > 0); Assert(current_chunk->cube->slices[0]->fd.dimension_id == time_dim->fd.id); max_chunk_interval = time_dim->fd.compress_interval_length; p = ts_point_create(current_chunk->cube->num_slices); /* First coordinate is the time coordinates and we want it to fall into previous chunk * hence we reduce it by 1 */ p->coordinates[p->num_coords++] = current_chunk->cube->slices[0]->fd.range_start - 1; current_chunk_interval = current_chunk->cube->slices[0]->fd.range_end - current_chunk->cube->slices[0]->fd.range_start; for (int i = p->num_coords; i < current_chunk->cube->num_slices; i++) { p->coordinates[p->num_coords++] = current_chunk->cube->slices[i]->fd.range_start; } previous_chunk = ts_hypertable_find_chunk_for_point(ht, p, ExclusiveLock); /* If there is no previous adjacent chunk along the time dimension or * if it hasn't been compressed yet, we can't merge. */ if (!previous_chunk || !OidIsValid(previous_chunk->fd.compressed_chunk_id)) return NULL; Assert(previous_chunk->cube->num_slices > 0); Assert(previous_chunk->cube->slices[0]->fd.dimension_id == time_dim->fd.id); compressed_chunk_interval = previous_chunk->cube->slices[0]->fd.range_end - previous_chunk->cube->slices[0]->fd.range_start; /* If the slices do not match (except on time dimension), we cannot merge the chunks. */ if (previous_chunk->cube->num_slices != current_chunk->cube->num_slices) return NULL; for (int i = 1; i < previous_chunk->cube->num_slices; i++) { if (previous_chunk->cube->slices[i]->fd.id != current_chunk->cube->slices[i]->fd.id) { return NULL; } } /* If the compressed chunk is full, we can't merge any more. */ if (compressed_chunk_interval == 0 || compressed_chunk_interval + current_chunk_interval > max_chunk_interval) return NULL; /* Get reloid of the previous compressed chunk via settings */ CompressionSettings *prev_comp_settings = ts_compression_settings_get(previous_chunk->table_id); CompressionSettings *ht_comp_settings = ts_compression_settings_get(ht->main_table_relid); if (!ts_compression_settings_equal_with_defaults(ht_comp_settings, prev_comp_settings)) return NULL; /* We don't support merging chunks with sequence numbers */ if (get_attnum(prev_comp_settings->fd.compress_relid, COMPRESSION_COLUMN_METADATA_SEQUENCE_NUM_NAME) != InvalidAttrNumber) return NULL; return previous_chunk; } /* Check if compression order is violated by merging in a new chunk * Because data merged in uses higher sequence numbers than any data already in the chunk, * the only way the order is guaranteed can be if we know the data we are merging in would come * after the existing data according to the compression order. This is true if the data being merged * in has timestamps greater than the existing data and the first column in the order by is time * ASC. * * The CompressChunkCxt references the chunk we are merging and mergable_chunk is the chunk we * are merging into. */ static bool check_is_chunk_order_violated_by_merge(CompressChunkCxt *cxt, const Dimension *time_dim, Chunk *mergable_chunk) { const DimensionSlice *mergable_slice = ts_hypercube_get_slice_by_dimension_id(mergable_chunk->cube, time_dim->fd.id); if (!mergable_slice) elog(ERROR, "mergeable chunk has no time dimension slice"); const DimensionSlice *compressed_slice = ts_hypercube_get_slice_by_dimension_id(cxt->srcht_chunk->cube, time_dim->fd.id); if (!compressed_slice) elog(ERROR, "columnstore chunk has no time dimension slice"); /* * Ensure the compressed chunk is AFTER the chunk that * it is being merged into. This is already guaranteed by previous checks. */ Ensure(mergable_slice->fd.range_end == compressed_slice->fd.range_start, "chunk being merged is not after the chunk that is being merged into"); CompressionSettings *ht_settings = ts_compression_settings_get(mergable_chunk->hypertable_relid); char *attname = get_attname(cxt->srcht->main_table_relid, time_dim->column_attno, false); int index = ts_array_position(ht_settings->fd.orderby, attname); /* Primary dimension column should be first compress_orderby column. */ if (index != 1) return true; return false; } static Oid compress_chunk_impl(Oid hypertable_relid, Oid chunk_relid) { Oid result_chunk_id = chunk_relid; CompressChunkCxt cxt = { 0 }; Chunk *compress_ht_chunk, *mergable_chunk; Cache *hcache; RelationSize before_size, after_size; CompressionStats cstat; bool new_compressed_chunk = false; hcache = ts_hypertable_cache_pin(); compresschunkcxt_init(&cxt, hcache, hypertable_relid, chunk_relid); /* acquire locks on src and compress hypertable and src chunk */ ereport(DEBUG1, (errmsg("acquiring locks for converting to columnstore \"%s.%s\"", get_namespace_name(get_rel_namespace(chunk_relid)), get_rel_name(chunk_relid)))); LockRelationOid(cxt.srcht->main_table_relid, AccessShareLock); LockRelationOid(cxt.compress_ht->main_table_relid, AccessShareLock); LockRelationOid(cxt.srcht_chunk->table_id, ExclusiveLock); /* acquire locks on catalog tables to keep till end of txn */ LockRelationOid(catalog_get_table_id(ts_catalog_get(), CHUNK), RowExclusiveLock); ereport(DEBUG1, (errmsg("locks acquired for converting to columnstore \"%s.%s\"", get_namespace_name(get_rel_namespace(chunk_relid)), get_rel_name(chunk_relid)))); DEBUG_WAITPOINT("compress_chunk_impl_start"); /* * Re-read the state of the chunk after all locks have been acquired and ensure * it is still uncompressed. Another process running in parallel might have * already performed the compression while we were waiting for the locks to be * acquired. */ Chunk *chunk_state_after_lock = ts_chunk_get_by_relid(chunk_relid, true); /* Throw error if chunk has invalid status for operation */ ts_chunk_validate_chunk_status_for_operation(chunk_state_after_lock, CHUNK_COMPRESS, true); /* get compression properties for hypertable */ mergable_chunk = find_chunk_to_merge_into(cxt.srcht, cxt.srcht_chunk); if (!mergable_chunk) { /* * Set up a dummy parsetree since we're calling AlterTableInternal * inside create_compress_chunk(). We can use anything here because we * are not calling EventTriggerDDLCommandEnd but we use a parse tree * type that CreateCommandTag can handle to avoid spurious printouts * in the event that EventTriggerDDLCommandEnd is called. */ EventTriggerAlterTableStart(create_dummy_query()); /* create compressed chunk and a new table */ compress_ht_chunk = create_compress_chunk(cxt.compress_ht, cxt.srcht_chunk, InvalidOid); /* Associate compressed chunk with main chunk. */ ts_chunk_set_compressed_chunk(cxt.srcht_chunk, compress_ht_chunk->fd.id); new_compressed_chunk = true; ereport(DEBUG1, (errmsg("new columnstore chunk \"%s.%s\" created", NameStr(compress_ht_chunk->fd.schema_name), NameStr(compress_ht_chunk->fd.table_name)))); EventTriggerAlterTableEnd(); } else { /* use an existing compressed chunk to compress into */ compress_ht_chunk = ts_chunk_get_by_id(mergable_chunk->fd.compressed_chunk_id, true); result_chunk_id = mergable_chunk->table_id; ereport(DEBUG1, (errmsg("merge into existing columnstore chunk \"%s.%s\"", NameStr(compress_ht_chunk->fd.schema_name), NameStr(compress_ht_chunk->fd.table_name)))); } /* Since the compressed relation is created in the same transaction as the tuples that will be * written by the compressor, we can insert the tuple directly in frozen state. This is the same * logic as performed in COPY INSERT FROZEN. * * Note: Tuples inserted with HEAP_INSERT_FROZEN become immediately visible to all transactions * (they violate the MVCC pattern). So, this flag can only be used when creating the compressed * chunk in the same transaction as the compressed tuples are inserted. * * If this isn't the case, then tuples can be seen multiple times by parallel readers - once in * the uncompressed part of the hypertable (since they are not deleted in the transaction) and * once in the compressed part of the hypertable since the MVCC semantic is violated due to the * flag. * * In contrast, when the compressed chunk part is created in the same transaction as the tuples * are written, the compressed chunk (i.e., the catalog entry) becomes visible to other * transactions only after the transaction that performs the compression is committed and * the uncompressed chunk is truncated. */ int insert_options = new_compressed_chunk ? HEAP_INSERT_FROZEN : 0; before_size = ts_relation_size_impl(cxt.srcht_chunk->table_id); cstat = compress_chunk(cxt.srcht_chunk->table_id, compress_ht_chunk->table_id, insert_options); after_size = ts_relation_size_impl(compress_ht_chunk->table_id); if (cxt.srcht->range_space) ts_chunk_column_stats_calculate(cxt.srcht, cxt.srcht_chunk); if (new_compressed_chunk) { compression_chunk_size_catalog_insert(cxt.srcht_chunk->fd.id, &before_size, compress_ht_chunk->fd.id, &after_size, cstat.rowcnt_pre_compression, cstat.rowcnt_post_compression, cstat.rowcnt_frozen); /* Detect and emit warning if poor compression ratio is found */ float compression_ratio = ((float) before_size.total_size / after_size.total_size); float POOR_COMPRESSION_THRESHOLD = 1.0; if (ts_guc_enable_compression_ratio_warnings && compression_ratio < POOR_COMPRESSION_THRESHOLD) ereport(WARNING, errcode(ERRCODE_WARNING), errmsg("poor compression rate detected for chunk \"%s\"'", get_rel_name(chunk_relid)), errdetail("Chunk \"%s\" has a poor compression ratio: %.2f. Size before " "compression: " INT64_FORMAT " bytes. Size after compression: " INT64_FORMAT " bytes", get_rel_name(chunk_relid), compression_ratio, before_size.total_size, after_size.total_size), errhint("Changing compression settings for \"%s\" can improve compression rate", get_rel_name(hypertable_relid))); } else { compression_chunk_size_catalog_update_merged(mergable_chunk->fd.id, &before_size, compress_ht_chunk->fd.id, &after_size, cstat.rowcnt_pre_compression, cstat.rowcnt_post_compression); const Dimension *time_dim = hyperspace_get_open_dimension(cxt.srcht->space, 0); Assert(time_dim != NULL); bool chunk_unordered = check_is_chunk_order_violated_by_merge(&cxt, time_dim, mergable_chunk); ts_chunk_merge_on_dimension(cxt.srcht, mergable_chunk, cxt.srcht_chunk, time_dim->fd.id); if (chunk_unordered) { ts_chunk_set_unordered(mergable_chunk); tsl_compress_chunk_wrapper(mergable_chunk, true, false); } } ts_cache_release(&hcache); return result_chunk_id; } static void decompress_chunk_impl(Chunk *uncompressed_chunk, bool if_compressed) { Cache *hcache; Hypertable *uncompressed_hypertable = ts_hypertable_cache_get_cache_and_entry(uncompressed_chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); Hypertable *compressed_hypertable; Chunk *compressed_chunk; ts_hypertable_permissions_check(uncompressed_hypertable->main_table_relid, GetUserId()); if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(uncompressed_hypertable)) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg( "convert_to_rowstore must not be called on the internal columnstore chunk"))); compressed_hypertable = ts_hypertable_get_by_id(uncompressed_hypertable->fd.compressed_hypertable_id); if (compressed_hypertable == NULL) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("missing columnstore-enabled hypertable"))); if (uncompressed_chunk->fd.hypertable_id != uncompressed_hypertable->fd.id) elog(ERROR, "hypertable and chunk do not match"); if (uncompressed_chunk->fd.compressed_chunk_id == INVALID_CHUNK_ID) { ts_cache_release(&hcache); ereport((if_compressed ? NOTICE : ERROR), (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("chunk \"%s\" is not converted to columnstore", get_rel_name(uncompressed_chunk->table_id)))); return; } write_logical_replication_msg_decompression_start(); ts_chunk_validate_chunk_status_for_operation(uncompressed_chunk, CHUNK_DECOMPRESS, true); compressed_chunk = ts_chunk_get_by_id(uncompressed_chunk->fd.compressed_chunk_id, true); ereport(DEBUG1, (errmsg("acquiring locks for converting to rowstore \"%s.%s\"", NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)))); /* acquire locks on src and compress hypertable and src chunk */ LockRelationOid(uncompressed_hypertable->main_table_relid, AccessShareLock); LockRelationOid(compressed_hypertable->main_table_relid, AccessShareLock); /* * Acquire an ExclusiveLock on the uncompressed and the compressed * chunk (the chunks can still be accessed by reads). * * The lock on the compressed chunk is needed because it gets deleted * after decompression. The lock on the uncompressed chunk is needed * to avoid deadlocks (e.g., caused by later lock upgrades or parallel * started chunk compressions). * * Note: Also the function decompress_chunk() will request an * ExclusiveLock on the compressed and on the uncompressed * chunk. See the comments in function about the concurrency of * operations. */ LockRelationOid(uncompressed_chunk->table_id, ExclusiveLock); LockRelationOid(compressed_chunk->table_id, ExclusiveLock); /* acquire locks on catalog tables to keep till end of txn */ LockRelationOid(catalog_get_table_id(ts_catalog_get(), CHUNK), RowExclusiveLock); ereport(DEBUG1, (errmsg("locks acquired for converting to rowstore \"%s.%s\"", NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)))); DEBUG_WAITPOINT("decompress_chunk_impl_start"); /* * Re-read the state of the chunk after all locks have been acquired and ensure * it is still compressed. Another process running in parallel might have * already performed the decompression while we were waiting for the locks to be * acquired. */ Chunk *chunk_state_after_lock = ts_chunk_get_by_id(uncompressed_chunk->fd.id, true); /* Throw error if chunk has invalid status for operation */ ts_chunk_validate_chunk_status_for_operation(chunk_state_after_lock, CHUNK_DECOMPRESS, true); decompress_chunk(compressed_chunk->table_id, uncompressed_chunk->table_id); /* Delete the compressed chunk */ ts_compression_chunk_size_delete(uncompressed_chunk->fd.id); ts_chunk_clear_compressed_chunk(uncompressed_chunk); ts_compression_settings_delete(uncompressed_chunk->table_id); /* * Lock the compressed chunk that is going to be deleted. At this point, * the reference to the compressed chunk is already removed from the * catalog but we need to block readers from accessing this chunk * until the catalog changes are visible to them. * * Note: Calling performMultipleDeletions in chunk_index_tuple_delete * also requests an AccessExclusiveLock on the compressed_chunk. However, * this call makes the lock on the chunk explicit. */ LockRelationOid(uncompressed_chunk->table_id, AccessExclusiveLock); LockRelationOid(compressed_chunk->table_id, AccessExclusiveLock); ts_chunk_drop(compressed_chunk, DROP_RESTRICT, -1); ts_cache_release(&hcache); write_logical_replication_msg_decompression_end(); } /* * Create a new compressed chunk using existing table with compressed data. * * chunk_relid - non-compressed chunk relid * chunk_table - table containing compressed data */ Datum tsl_create_compressed_chunk(PG_FUNCTION_ARGS) { Oid chunk_relid = PG_GETARG_OID(0); Oid chunk_table = PG_GETARG_OID(1); RelationSize uncompressed_size = { .heap_size = PG_GETARG_INT64(2), .toast_size = PG_GETARG_INT64(3), .index_size = PG_GETARG_INT64(4) }; RelationSize compressed_size = { .heap_size = PG_GETARG_INT64(5), .toast_size = PG_GETARG_INT64(6), .index_size = PG_GETARG_INT64(7) }; int64 numrows_pre_compression = PG_GETARG_INT64(8); int64 numrows_post_compression = PG_GETARG_INT64(9); Chunk *chunk; Chunk *compress_ht_chunk; Cache *hcache; CompressChunkCxt cxt; bool chunk_was_compressed; Assert(!PG_ARGISNULL(0)); Assert(!PG_ARGISNULL(1)); ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); TS_PREVENT_FUNC_IF_READ_ONLY(); chunk = ts_chunk_get_by_relid(chunk_relid, true); hcache = ts_hypertable_cache_pin(); compresschunkcxt_init(&cxt, hcache, chunk->hypertable_relid, chunk_relid); /* Acquire locks on src and compress hypertable and src chunk */ LockRelationOid(cxt.srcht->main_table_relid, AccessShareLock); LockRelationOid(cxt.compress_ht->main_table_relid, AccessShareLock); LockRelationOid(cxt.srcht_chunk->table_id, ShareLock); /* Acquire locks on catalog tables to keep till end of txn */ LockRelationOid(catalog_get_table_id(ts_catalog_get(), CHUNK), RowExclusiveLock); /* * Set up a dummy parsetree since we're calling AlterTableInternal inside * create_compress_chunk(). We can use anything here because we are not * calling EventTriggerDDLCommandEnd but we use a parse tree type that * CreateCommandTag can handle to avoid spurious printouts. */ EventTriggerAlterTableStart(create_dummy_query()); /* Create compressed chunk using existing table */ compress_ht_chunk = create_compress_chunk(cxt.compress_ht, cxt.srcht_chunk, chunk_table); EventTriggerAlterTableEnd(); /* Insert empty stats to compression_chunk_size */ compression_chunk_size_catalog_insert(cxt.srcht_chunk->fd.id, &uncompressed_size, compress_ht_chunk->fd.id, &compressed_size, numrows_pre_compression, numrows_post_compression, 0); chunk_was_compressed = ts_chunk_is_compressed(cxt.srcht_chunk); ts_chunk_set_compressed_chunk(cxt.srcht_chunk, compress_ht_chunk->fd.id); if (!chunk_was_compressed && ts_table_has_tuples(cxt.srcht_chunk->table_id, AccessShareLock)) { /* The chunk was not compressed before it had the compressed chunk * attached to it, and it contains rows, so we set it to be partial. */ ts_chunk_set_partial(cxt.srcht_chunk); } ts_cache_release(&hcache); PG_RETURN_OID(chunk_relid); } Datum tsl_compress_chunk(PG_FUNCTION_ARGS) { Oid uncompressed_chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); bool if_not_compressed = PG_ARGISNULL(1) ? true : PG_GETARG_BOOL(1); bool recompress = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); TS_PREVENT_FUNC_IF_READ_ONLY(); Chunk *chunk = ts_chunk_get_by_relid(uncompressed_chunk_id, true); uncompressed_chunk_id = tsl_compress_chunk_wrapper(chunk, if_not_compressed, recompress); PG_RETURN_OID(uncompressed_chunk_id); } Oid tsl_compress_chunk_wrapper(Chunk *chunk, bool if_not_compressed, bool recompress) { Oid uncompressed_chunk_id = chunk->table_id; write_logical_replication_msg_compression_start(); if (ts_chunk_is_compressed(chunk)) { CompressionSettings *chunk_settings = ts_compression_settings_get(chunk->table_id); bool valid_orderby_settings = chunk_settings && chunk_settings->fd.orderby; if (recompress) { CompressionSettings *ht_settings = ts_compression_settings_get(chunk->hypertable_relid); if (!valid_orderby_settings || !ts_compression_settings_equal_with_defaults(ht_settings, chunk_settings)) { decompress_chunk_impl(chunk, false); compress_chunk_impl(chunk->hypertable_relid, chunk->table_id); write_logical_replication_msg_compression_end(); return uncompressed_chunk_id; } } if (!ts_chunk_needs_recompression(chunk)) { write_logical_replication_msg_compression_end(); ereport((if_not_compressed ? NOTICE : ERROR), (errcode(ERRCODE_DUPLICATE_OBJECT), errmsg("chunk \"%s\" is already converted to columnstore", get_rel_name(chunk->table_id)))); return uncompressed_chunk_id; } if (ts_guc_enable_segmentwise_recompression && valid_orderby_settings && ts_chunk_is_partial(chunk) && get_compressed_chunk_index_for_recompression(chunk)) { uncompressed_chunk_id = recompress_chunk_segmentwise_impl(chunk); } else { if (!ts_guc_enable_segmentwise_recompression || !valid_orderby_settings) elog(NOTICE, "segmentwise recompression is disabled%s, performing full " "recompression on " "chunk \"%s.%s\"", (ts_guc_enable_segmentwise_recompression && !valid_orderby_settings ? " due to no order by" : ""), NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)); decompress_chunk_impl(chunk, false); compress_chunk_impl(chunk->hypertable_relid, chunk->table_id); } } else { uncompressed_chunk_id = compress_chunk_impl(chunk->hypertable_relid, chunk->table_id); } write_logical_replication_msg_compression_end(); return uncompressed_chunk_id; } Datum tsl_decompress_chunk(PG_FUNCTION_ARGS) { Oid uncompressed_chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); bool if_compressed = PG_ARGISNULL(1) ? true : PG_GETARG_BOOL(1); int32 chunk_id; ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); TS_PREVENT_FUNC_IF_READ_ONLY(); Chunk *uncompressed_chunk = ts_chunk_get_by_relid(uncompressed_chunk_id, true); chunk_id = uncompressed_chunk->fd.id; Hypertable *ht = ts_hypertable_get_by_id(uncompressed_chunk->fd.hypertable_id); ts_hypertable_permissions_check(ht->main_table_relid, GetUserId()); if (!ht->fd.compressed_hypertable_id) ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("missing columnstore-enabled hypertable"))); if (!ts_chunk_is_compressed(uncompressed_chunk)) { ereport((if_compressed ? NOTICE : ERROR), (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("chunk \"%s\" is not converted to columnstore", get_rel_name(uncompressed_chunk_id)))); PG_RETURN_NULL(); } else decompress_chunk_impl(uncompressed_chunk, if_compressed); /* * Post decompression regular DML can happen into this chunk. So, we update * chunk_column_stats entries for this chunk to min/max entries now. */ ts_chunk_column_stats_reset_by_chunk_id(chunk_id); PG_RETURN_OID(uncompressed_chunk_id); } /* * This is hacky but it doesn't matter. We just want to check for the existence of such an index * on the compressed chunk. */ extern Datum tsl_get_compressed_chunk_index_for_recompression(PG_FUNCTION_ARGS) { ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); Oid uncompressed_chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Chunk *uncompressed_chunk = ts_chunk_get_by_relid(uncompressed_chunk_id, true); Oid index_oid = get_compressed_chunk_index_for_recompression(uncompressed_chunk); if (OidIsValid(index_oid)) { PG_RETURN_OID(index_oid); } else PG_RETURN_NULL(); } static Oid get_compressed_chunk_index_for_recompression(Chunk *uncompressed_chunk) { Chunk *compressed_chunk = ts_chunk_get_by_id(uncompressed_chunk->fd.compressed_chunk_id, true); Relation uncompressed_chunk_rel = table_open(uncompressed_chunk->table_id, AccessShareLock); Relation compressed_chunk_rel = table_open(compressed_chunk->table_id, AccessShareLock); CompressionSettings *settings = ts_compression_settings_get(uncompressed_chunk->table_id); CatalogIndexState indstate = CatalogOpenIndexes(compressed_chunk_rel); Oid index_oid = get_compressed_chunk_index(indstate, settings); CatalogCloseIndexes(indstate); table_close(compressed_chunk_rel, NoLock); table_close(uncompressed_chunk_rel, NoLock); return index_oid; } Chunk * tsl_compression_chunk_create(Hypertable *compressed_ht, Chunk *src_chunk) { /* Create a new compressed chunk */ return create_compress_chunk(compressed_ht, src_chunk, InvalidOid); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/api.h��������������������������������������������������������0000664�0000000�0000000�00000002052�15100345067�0020726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <utils.h> #include "chunk.h" extern Datum tsl_create_compressed_chunk(PG_FUNCTION_ARGS); extern Datum tsl_compress_chunk(PG_FUNCTION_ARGS); extern Datum tsl_decompress_chunk(PG_FUNCTION_ARGS); extern Oid tsl_compress_chunk_wrapper(Chunk *chunk, bool if_not_compressed, bool recompress); extern Chunk *tsl_compression_chunk_create(Hypertable *compressed_ht, Chunk *src_chunk); extern Datum tsl_get_compressed_chunk_index_for_recompression( PG_FUNCTION_ARGS); // arg is oid of uncompressed chunk extern void compression_chunk_size_catalog_insert(int32 src_chunk_id, const RelationSize *src_size, int32 compress_chunk_id, const RelationSize *compress_size, int64 rowcnt_pre_compression, int64 rowcnt_post_compression, int64 rowcnt_frozen); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/arrow_c_data_interface.h�������������������������������������0000664�0000000�0000000�00000017070�15100345067�0024630�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * This header describes the Arrow C data interface which is a well-known * standard for in-memory interchange of columnar data. * * https://arrow.apache.org/docs/format/CDataInterface.html * * Citing from the above link: * * Arrow C data interface defines a very small, stable set of C definitions that * can be easily copied in any project’s source code and used for columnar data * interchange in the Arrow format. For non-C/C++ languages and runtimes, it * should be almost as easy to translate the C definitions into the * corresponding C FFI declarations. * * Applications and libraries can therefore work with Arrow memory without * necessarily using Arrow libraries or reinventing the wheel. */ #ifndef ARROW_C_DATA_INTERFACE #define ARROW_C_DATA_INTERFACE #define ARROW_FLAG_DICTIONARY_ORDERED 1 #define ARROW_FLAG_NULLABLE 2 #define ARROW_FLAG_MAP_KEYS_SORTED 4 typedef struct ArrowArray { /* * Mandatory. The logical length of the array (i.e. its number of items). */ int64 length; /* * Mandatory. The number of null items in the array. MAY be -1 if not yet * computed. */ int64 null_count; /* * Mandatory. The logical offset inside the array (i.e. the number of * items from the physical start of the buffers). MUST be 0 or positive. * * Producers MAY specify that they will only produce 0-offset arrays to * ease implementation of consumer code. Consumers MAY decide not to * support non-0-offset arrays, but they should document this limitation. */ int64 offset; /* * Mandatory. The number of physical buffers backing this array. The * number of buffers is a function of the data type, as described in the * Columnar format specification. * * Buffers of children arrays are not included. */ int64 n_buffers; /* * Mandatory. The number of children this type has. */ int64 n_children; /* * Mandatory. A C array of pointers to the start of each physical buffer * backing this array. Each void* pointer is the physical start of a * contiguous buffer. There must be ArrowArray.n_buffers pointers. * * The producer MUST ensure that each contiguous buffer is large enough to * represent length + offset values encoded according to the Columnar * format specification. * * It is recommended, but not required, that the memory addresses of the * buffers be aligned at least according to the type of primitive data * that they contain. Consumers MAY decide not to support unaligned * memory. * * The buffer pointers MAY be null only in two situations: * * - for the null bitmap buffer, if ArrowArray.null_count is 0; * * - for any buffer, if the size in bytes of the corresponding buffer would * be 0. * * Buffers of children arrays are not included. */ const void **buffers; struct ArrowArray **children; struct ArrowArray *dictionary; /* * Mandatory. A pointer to a producer-provided release callback. * * See below for memory management and release callback semantics. */ void (*release)(struct ArrowArray *); /* Opaque producer-specific data */ void *private_data; } ArrowArray; /* * We don't use the schema but have to define it for completeness because we're * defining the ARROW_C_DATA_INTERFACE macro. */ struct ArrowSchema { const char *format; const char *name; const char *metadata; int64 flags; int64 n_children; struct ArrowSchema **children; struct ArrowSchema *dictionary; void (*release)(struct ArrowSchema *); void *private_data; }; /* * The include guard ARROW_C_DATA_INTERFACE is required by the Arrow docs to * avoid redefinition of the Arrow structs in the third-party headers, but the * following functions are not part of Arrow C Data Interface, so they are not * under the guard. We still need some kind of guard for them, so we also have * pragma once above. */ #endif static pg_attribute_always_inline bool arrow_row_is_valid(const uint64 *bitmap, size_t row_number) { if (likely(bitmap == NULL)) { return true; } const size_t qword_index = row_number / 64; const size_t bit_index = row_number % 64; const uint64 mask = 1ull << bit_index; return bitmap[qword_index] & mask; } /* * Same as above but for two bitmaps, this is a typical situation when we have * validity bitmap + filter result. */ static pg_attribute_always_inline bool arrow_row_both_valid(const uint64 *bitmap1, const uint64 *bitmap2, size_t row_number) { if (likely(bitmap1 == NULL)) { return arrow_row_is_valid(bitmap2, row_number); } if (likely(bitmap2 == NULL)) { return arrow_row_is_valid(bitmap1, row_number); } const size_t qword_index = row_number / 64; const size_t bit_index = row_number % 64; const uint64 mask = 1ull << bit_index; return (bitmap1[qword_index] & bitmap2[qword_index]) & mask; } static pg_attribute_always_inline void arrow_set_row_validity(uint64 *bitmap, size_t row_number, bool value) { const size_t qword_index = row_number / 64; const size_t bit_index = row_number % 64; const uint64 mask = 1ull << bit_index; const uint64 new_bit = (value ? 1ull : 0ull) << bit_index; bitmap[qword_index] = (bitmap[qword_index] & ~mask) | new_bit; Assert(arrow_row_is_valid(bitmap, row_number) == value); } /* * Combine the validity bitmaps into the given storage. */ static inline const uint64 * arrow_combine_validity(size_t num_words, uint64 *restrict storage, const uint64 *filter1, const uint64 *filter2, const uint64 *filter3) { /* * Any and all of the filters can be null. For simplicity, move the non-null * filters to the leading positions. */ const uint64 *tmp; #define SWAP(X, Y) \ tmp = (X); \ (X) = (Y); \ (Y) = tmp; if (filter1 == NULL) { /* * We have at least one NULL that goes to the last position. */ SWAP(filter1, filter3); if (filter1 == NULL) { /* * We have another NULL that goes to the second position. */ SWAP(filter1, filter2); } } else { if (filter2 == NULL) { /* * We have at least one NULL that goes to the last position. */ SWAP(filter2, filter3); } } #undef SWAP Assert(filter2 == NULL || filter1 != NULL); Assert(filter3 == NULL || filter2 != NULL); if (filter2 == NULL) { /* Either have one non-null filter, or all of them are null. */ return filter1; } if (filter3 == NULL) { /* Have two non-null filters. */ for (size_t i = 0; i < num_words; i++) { storage[i] = filter1[i] & filter2[i]; } } else { /* Have three non-null filters. */ for (size_t i = 0; i < num_words; i++) { storage[i] = filter1[i] & filter2[i] & filter3[i]; } } return storage; } /* * Increase the `source_value` to be an even multiple of `pad_to`. */ static inline uint64 pad_to_multiple(uint64 pad_to, uint64 source_value) { return ((source_value + pad_to - 1) / pad_to) * pad_to; } static inline int arrow_num_valid(const uint64 *bitmap, size_t total_rows) { if (bitmap == NULL) { return total_rows; } uint64 num_valid = 0; #ifdef HAVE__BUILTIN_POPCOUNT const uint64 words = pad_to_multiple(64, total_rows) / 64; for (uint64 i = 0; i < words; i++) { num_valid += __builtin_popcountll(bitmap[i]); } #else for (size_t i = 0; i < total_rows; i++) { num_valid += arrow_row_is_valid(bitmap, i); } #endif return num_valid; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/batch_metadata_builder.h�������������������������������������0000664�0000000�0000000�00000001425�15100345067�0024607�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once typedef struct RowCompressor RowCompressor; typedef struct BatchMetadataBuilder { void (*update_val)(void *builder, Datum val); void (*update_null)(void *builder); void (*insert_to_compressed_row)(void *builder, RowCompressor *compressor); void (*reset)(void *builder, RowCompressor *compressor); } BatchMetadataBuilder; BatchMetadataBuilder *batch_metadata_builder_minmax_create(Oid type, Oid collation, int min_attr_offset, int max_attr_offset); BatchMetadataBuilder *batch_metadata_builder_bloom1_create(Oid type, int bloom_attr_offset); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/batch_metadata_builder_bloom1.c������������������������������0000664�0000000�0000000�00000046303�15100345067�0026057�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "postgres.h" #include <access/detoast.h> #include <catalog/pg_collation_d.h> #include <common/hashfn.h> #include <funcapi.h> #include <utils/builtins.h> #include <utils/typcache.h> #include <math.h> #include "compression.h" #include "batch_metadata_builder.h" #include "arrow_c_data_interface.h" #include "sparse_index_bloom1.h" #ifdef TS_USE_UMASH #include "import/umash.h" #endif /* * There is a tradeoff between making the bloom filters selective enough but * not too big. Testing on some real words datasets, the optimal value seems to * be about 2% false positives. We also want to be able to reduce the filter to * up to 64 bits, so that it fits in the main table. Hence the optimal number of * hashes. This number actually gives a slightly different false positive rate, * so this is what we ultimately use. * Calculator: https://hur.st/bloomfilter/?p=0.02&m=64 */ #define BLOOM1_FALSE_POSITIVES 0.022 #define BLOOM1_HASHES 6 /* * Limit the bits belonging to the particular elements to a small contiguous * region. This improves memory locality when building the bloom filter. */ #define BLOOM1_BLOCK_BITS 256 typedef struct Bloom1MetadataBuilder { BatchMetadataBuilder functions; int16 bloom_attr_offset; int allocated_varlena_bytes; struct varlena *bloom_varlena; PGFunction hash_function; FmgrInfo *hash_function_finfo; } Bloom1MetadataBuilder; /* * Low-bias invertible hash function from this article: * http://web.archive.org/web/20250406022607/https://nullprogram.com/blog/2018/07/31/ */ static inline uint64 bloom1_hash64(uint64 x) { x ^= x >> 32; x *= 0xd6e8feb86659fd93U; x ^= x >> 32; x *= 0xd6e8feb86659fd93U; x ^= x >> 32; return x; } static Datum bloom1_hash_8(PG_FUNCTION_ARGS) { PG_RETURN_UINT64(bloom1_hash64(PG_GETARG_INT64(0))); } static Datum bloom1_hash_4(PG_FUNCTION_ARGS) { PG_RETURN_UINT64(bloom1_hash64(PG_GETARG_INT32(0))); } #ifdef TS_USE_UMASH static struct umash_params * hashing_params() { static struct umash_params params = { 0 }; if (params.poly[0][0] == 0) { umash_params_derive(¶ms, 0x12345abcdef67890ULL, NULL); Assert(params.poly[0][0] != 0); } return ¶ms; } static Datum bloom1_hash_varlena(PG_FUNCTION_ARGS) { struct varlena *needle = PG_DETOAST_DATUM_PACKED(PG_GETARG_DATUM(0)); const int length = VARSIZE_ANY_EXHDR(needle); const char *data = VARDATA_ANY(needle); PG_RETURN_UINT64(umash_full(hashing_params(), /* seed = */ ~0ULL, /* which = */ 0, data, length)); } static Datum bloom1_hash_16(PG_FUNCTION_ARGS) { Datum datum = PG_GETARG_DATUM(0); PG_RETURN_UINT64(umash_full(hashing_params(), /* seed = */ ~0ULL, /* which = */ 0, DatumGetPointer(datum), 16)); } #endif /* * Get the hash function we use for building a bloom filter for a particular * type. Returns NULL if not supported. * The signature of the returned function matches the Postgres extended hashing * functions like hashtextextended(). * It's possible, though impractical, for a hash function to be implemented in a * procedural language, not in C. In this case, we need the proper FmgrInfo to * call it. We fetch it from the type cache. For our custom functions, it is NULL. */ PGFunction bloom1_get_hash_function(Oid type, FmgrInfo **finfo) { *finfo = NULL; /* * By default, we use the Postgres extended hashing functions, so that we * can use bloom filters for any types. * We request also the opfamily info and the equality operator, because * otherwise the Postgres type cache code fails obtusely on types with * improper opclasses. It picks up the btree opclass from a binary compatible * type (see GetDefaultOpClass), then an equality operator from this opclass, * and then refuses to return the hash functions because the hash opclass has * a different equality operator. The problem is that this happens over two * consecutive calls to lookup_type_cache(), so the first invocation of our * function says that we have a hash, and the second says that we don't. */ TypeCacheEntry *entry = lookup_type_cache(type, TYPECACHE_EQ_OPR | TYPECACHE_BTREE_OPFAMILY | TYPECACHE_HASH_EXTENDED_PROC_FINFO); /* * For some types we use our custom hash functions. We only do it for the * builtin Postgres types to be on the safe side, and also simplify the * testing by creating bad hash functions from SQL tests. If you change this, * you might have to change the bad hash testing in compress_bloom_sparse.sql. */ switch (entry->hash_extended_proc) { #ifdef TS_USE_UMASH case F_HASHTEXTEXTENDED: return bloom1_hash_varlena; case F_UUID_HASH_EXTENDED: return bloom1_hash_16; #endif case F_HASHINT8EXTENDED: return bloom1_hash_8; case F_HASHINT4EXTENDED: #if PG18_GE /* * PG18 added a custom hashing function for date type. * For backwards compatibility, we need to continue using * our own custom function which was used for < PG18. * * https://github.com/postgres/postgres/commit/23d0b484 */ case F_HASHDATEEXTENDED: #endif return bloom1_hash_4; } /* * For the Postgres hash function, finfo might be required, for example for * functions defined in procedural languages. */ *finfo = &entry->hash_extended_proc_finfo; return entry->hash_extended_proc_finfo.fn_addr; } static void bloom1_update_null(void *builder_) { /* * A null value cannot match an equality condition that we're optimizing * with bloom filters, so we don't need to consider them here. */ } static void bloom1_reset(void *builder_, RowCompressor *compressor) { Bloom1MetadataBuilder *builder = (Bloom1MetadataBuilder *) builder_; struct varlena *bloom = builder->bloom_varlena; memset(bloom, 0, builder->allocated_varlena_bytes); SET_VARSIZE(bloom, builder->allocated_varlena_bytes); compressor->compressed_is_null[builder->bloom_attr_offset] = true; compressor->compressed_values[builder->bloom_attr_offset] = 0; } static char * bloom1_words_buf(struct varlena *bloom) { return VARDATA_ANY(bloom); } static int bloom1_num_bits(const struct varlena *bloom) { return 8 * VARSIZE_ANY_EXHDR(bloom); } static void bloom1_insert_to_compressed_row(void *builder_, RowCompressor *compressor) { Bloom1MetadataBuilder *builder = (Bloom1MetadataBuilder *) builder_; struct varlena *bloom = builder->bloom_varlena; char *restrict words_buf = bloom1_words_buf(bloom); const int orig_num_bits = bloom1_num_bits(bloom); Assert(orig_num_bits % 8 == 0); Assert(orig_num_bits % 64 == 0); const int orig_bits_set = pg_popcount(words_buf, orig_num_bits / 8); if (unlikely(orig_bits_set == 0 || orig_bits_set == orig_num_bits)) { /* * 1) All elements turned out to be null, don't save the empty filter in * that case. The compressed batch will be compressed using the NULL * compression algorithm, so actually checking the rows will be efficient * enough. * * 2) All bits are set, this filter is useless. Shouldn't really happen, * but technically possible, and the following calculations will * segfault in this case. */ compressor->compressed_is_null[builder->bloom_attr_offset] = true; compressor->compressed_values[builder->bloom_attr_offset] = PointerGetDatum(NULL); return; } /* * Our filters are sized for the maximum expected number of the unique * elements, so in practice they can be very sparse if the actual number of * the unique elements is less. The TOAST compression doesn't handle even * the sparse filters very well. Apply a simple compression technique: split * the filter in half and bitwise OR the halves. Repeat this until we reach * the filter bit length that gives the desired false positive ratio. * The desired filter bit length is given by m1, we will now estimate it * based on the estimated current number of elements in the bloom filter (1) * and the ideal number of elements for a bloom filter of given size (2). * (1) n = log(1 - t/m0) / (k * log(1 - 1/m0)), * (2) n = -m1 * log(1 - p ^ (1/k)) / k. */ const double m0 = orig_num_bits; const double k = BLOOM1_HASHES; const double p = BLOOM1_FALSE_POSITIVES; const double t = orig_bits_set; const double m1 = -log(1 - t / m0) / (log(1 - 1 / m0) * log(1 - pow(p, 1 / k))); /* * Compute powers of two corresponding to the current and desired filter * bit length. */ const int starting_pow2 = ceil(log2(m0)); Assert(pow(2, starting_pow2) == m0); /* We don't want to go under 64 bytes. */ const int final_pow2 = MAX(6, ceil(log2(m1))); Assert(final_pow2 >= 6); /* * Fold filter in half, applying bitwise OR, until we reach the desired * filter bit length. */ for (int current_pow2 = starting_pow2; current_pow2 > final_pow2; current_pow2--) { const int half_words = 1 << (current_pow2 - 3 /* 8-bit byte */ - 1 /* half */); Assert(half_words > 0); const char *words_tail = &words_buf[half_words]; for (int i = 0; i < half_words; i++) { words_buf[i] |= words_tail[i]; } } /* * If we have resized the filter, update the nominal size of the varlena * object. */ if (final_pow2 < starting_pow2) { SET_VARSIZE(bloom, (char *) bloom1_words_buf(bloom) + (1 << (final_pow2 - 3 /* 8-bit byte */)) - (char *) bloom); } Assert(bloom1_num_bits(bloom) % (sizeof(*words_buf) * 8) == 0); Assert(bloom1_num_bits(bloom) % 64 == 0); compressor->compressed_is_null[builder->bloom_attr_offset] = false; compressor->compressed_values[builder->bloom_attr_offset] = PointerGetDatum(bloom); } /* * Call a hash function that uses a postgres "extended hash" signature. */ static inline uint64 calculate_hash(PGFunction hash_function, FmgrInfo *finfo, Datum needle) { LOCAL_FCINFO(hashfcinfo, 2); *hashfcinfo = (FunctionCallInfoBaseData){ 0 }; /* * Our hashing is not collation-sensitive, but the Postgres hashing functions * might refuse to work if the collation is not deterministic, so make them * happy. */ hashfcinfo->fncollation = C_COLLATION_OID; hashfcinfo->nargs = 2; hashfcinfo->args[0].value = needle; hashfcinfo->args[0].isnull = false; /* * Seed. Note that on 32-bit systems it is by-reference. */ const int64 seed = 0; hashfcinfo->args[1].value = Int64GetDatumFast(seed); hashfcinfo->args[1].isnull = false; /* * Needed for hash functions defined in procedural languages, not C. While * unlikely, we shouldn't segfault. The finfo is cached in the type cache. */ hashfcinfo->flinfo = finfo; return DatumGetUInt64(hash_function(hashfcinfo)); } /* * The offset of nth bit we're going to set. */ static inline uint32 bloom1_get_one_offset(uint64 value_hash, uint32 index) { const uint32 low = value_hash & ~(uint32) 0; const uint32 high = (value_hash >> 32) & ~(uint32) 0; /* * Add a quadratic component to lessen degradation in the unlikely case when * 'high' is a multiple of block bits. */ return low + (index * high + index * index) % BLOOM1_BLOCK_BITS; } static void bloom1_update_val(void *builder_, Datum needle) { Bloom1MetadataBuilder *builder = (Bloom1MetadataBuilder *) builder_; char *restrict words_buf = bloom1_words_buf(builder->bloom_varlena); const uint32 num_bits = bloom1_num_bits(builder->bloom_varlena); /* * These calculations are a little inconvenient, but I had to switch to * another buffer word size already, so for now I'm keeping the code generic * relative to this size. */ const uint32 num_word_bits = sizeof(*words_buf) * 8; Assert(num_bits % num_word_bits == 0); const uint32 log2_word_bits = pg_leftmost_one_pos32(num_word_bits); Assert(num_word_bits == (1ULL << log2_word_bits)); const uint32 word_mask = num_word_bits - 1; Assert((word_mask >> num_word_bits) == 0); const uint64 datum_hash_1 = calculate_hash(builder->hash_function, builder->hash_function_finfo, needle); const uint32 absolute_mask = num_bits - 1; for (int i = 0; i < BLOOM1_HASHES; i++) { const uint32 absolute_bit_index = bloom1_get_one_offset(datum_hash_1, i) & absolute_mask; const uint32 word_index = absolute_bit_index >> log2_word_bits; const uint32 word_bit_index = absolute_bit_index & word_mask; words_buf[word_index] |= 1ULL << word_bit_index; } } /* * Checks whether the given element can be present in the given bloom filter. * This is what we use in predicate pushdown. The SQL signature is: * _timescaledb_functions.bloom1_contains(bloom1, anyelement) */ Datum bloom1_contains(PG_FUNCTION_ARGS) { /* * This function is not strict, because if we don't have a bloom filter, this * means the condition can potentially be true. */ if (PG_ARGISNULL(0)) { PG_RETURN_BOOL(true); } /* * A null value cannot match the equality condition, although this probably * should be optimized away by the planner. */ if (PG_ARGISNULL(1)) { PG_RETURN_BOOL(false); } Oid type_oid = get_fn_expr_argtype(fcinfo->flinfo, 1); FmgrInfo *finfo = NULL; PGFunction fn = bloom1_get_hash_function(type_oid, &finfo); /* * Technically this function is callable by user with arbitrary argument * that might not have an extended hash function, so report this error * gracefully. */ if (fn == NULL) { ereport(ERROR, (errcode(ERRCODE_DATA_EXCEPTION), errmsg("the argument type %s lacks an extended hash function", format_type_be(type_oid)))); } struct varlena *bloom = PG_GETARG_VARLENA_P(0); const char *words_buf = bloom1_words_buf(bloom); const uint32 num_bits = bloom1_num_bits(bloom); /* Must be a power of two. */ CheckCompressedData(num_bits == (1ULL << pg_leftmost_one_pos32(num_bits))); /* Must be >= 64 bits. */ CheckCompressedData(num_bits >= 64); const uint32 num_word_bits = sizeof(*words_buf) * 8; Assert(num_bits % num_word_bits == 0); const uint32 log2_word_bits = pg_leftmost_one_pos32(num_word_bits); Assert(num_word_bits == (1ULL << log2_word_bits)); const uint32 word_mask = num_word_bits - 1; Assert((word_mask >> num_word_bits) == 0); Datum needle = PG_GETARG_DATUM(1); const uint64 datum_hash_1 = calculate_hash(fn, finfo, needle); const uint32 absolute_mask = num_bits - 1; for (int i = 0; i < BLOOM1_HASHES; i++) { const uint32 absolute_bit_index = bloom1_get_one_offset(datum_hash_1, i) & absolute_mask; const uint32 word_index = absolute_bit_index >> log2_word_bits; const uint32 word_bit_index = absolute_bit_index & word_mask; if ((words_buf[word_index] & (1ULL << word_bit_index)) == 0) { PG_RETURN_BOOL(false); } } PG_RETURN_BOOL(true); } static int bloom1_varlena_alloc_size(int num_bits) { /* * We are not supposed to go below 64 bits because we work in 64-bit words. */ Assert(num_bits % 64 == 0); return VARHDRSZ + num_bits / 8; } BatchMetadataBuilder * batch_metadata_builder_bloom1_create(Oid type_oid, int bloom_attr_offset) { /* * Better make the bloom filter size a power of two, because we compress the * sparse filters using division in half. The formula for the lowest * enclosing power of two is pow(2, floor(log2(x * 2 - 1))). */ const int expected_elements = TARGET_COMPRESSED_BATCH_SIZE * 16; const int lowest_power = pg_leftmost_one_pos32(expected_elements * 2 - 1); Assert(lowest_power <= 16); const int desired_bits = 1ULL << lowest_power; const int varlena_bytes = bloom1_varlena_alloc_size(desired_bits); Bloom1MetadataBuilder *builder = palloc(sizeof(*builder)); *builder = (Bloom1MetadataBuilder){ .functions = (BatchMetadataBuilder){ .update_val = bloom1_update_val, .update_null = bloom1_update_null, .insert_to_compressed_row = bloom1_insert_to_compressed_row, .reset = bloom1_reset, }, .bloom_attr_offset = bloom_attr_offset, .allocated_varlena_bytes = varlena_bytes, }; builder->hash_function = bloom1_get_hash_function(type_oid, &builder->hash_function_finfo); if (builder->hash_function == NULL) { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the argument type %s lacks an extended hash function", format_type_be(type_oid)))); } /* * Initialize the bloom filter. */ builder->bloom_varlena = palloc0(varlena_bytes); SET_VARSIZE(builder->bloom_varlena, varlena_bytes); return &builder->functions; } #ifndef NDEBUG static int bloom1_estimate_ndistinct(struct varlena *bloom) { const double m = bloom1_num_bits(bloom); const double t = pg_popcount(bloom1_words_buf(bloom), m / 8); const double k = BLOOM1_HASHES; return log(1 - t / m) / (k * log(1 - 1 / m)); } /* * We're slightly modifying this Postgres macro to avoid a warning about signed * vs unsigned comparison. */ #define TS_VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) \ ((int) VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer) < \ (int) ((toast_pointer).va_rawsize - VARHDRSZ)) TS_FUNCTION_INFO_V1(ts_bloom1_debug_info); /* * A function to output various debugging info about a bloom filter. * * Usage hints in the tests. */ Datum ts_bloom1_debug_info(PG_FUNCTION_ARGS) { /* Build a tuple descriptor for our result type */ TupleDesc tuple_desc; if (get_call_result_type(fcinfo, NULL, &tuple_desc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); /* Output columns of this function. */ enum { out_toast_header = 0, out_toasted_bytes, out_compressed_bytes, out_detoasted_bytes, out_bits_total, out_bits_set, out_estimated_elements, _out_columns }; Datum values[_out_columns] = { 0 }; bool nulls[_out_columns] = { 0 }; Datum toasted = PG_GETARG_DATUM(0); values[out_toast_header] = Int32GetDatum(((varattrib_1b *) toasted)->va_header); values[out_toasted_bytes] = Int32GetDatum(VARSIZE_ANY_EXHDR(toasted)); struct varlena *detoasted = PG_DETOAST_DATUM(toasted); values[out_detoasted_bytes] = Int32GetDatum(VARSIZE_ANY_EXHDR(detoasted)); const int bits_total = bloom1_num_bits(detoasted); values[out_bits_total] = Int32GetDatum(bits_total); const char *words = bloom1_words_buf(detoasted); values[out_bits_set] = Int32GetDatum(pg_popcount(words, bits_total / 8)); values[out_estimated_elements] = Int32GetDatum(bloom1_estimate_ndistinct(detoasted)); if (VARATT_IS_EXTERNAL_ONDISK(toasted)) { struct varatt_external toast_pointer; VARATT_EXTERNAL_GET_POINTER(toast_pointer, toasted); if (TS_VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer)) { values[out_compressed_bytes] = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer); } else { nulls[out_compressed_bytes] = true; } } else if (VARATT_IS_COMPRESSED(toasted)) { values[out_compressed_bytes] = VARDATA_COMPRESSED_GET_EXTSIZE(toasted); } else { nulls[out_compressed_bytes] = true; } PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tuple_desc, values, nulls))); } TS_FUNCTION_INFO_V1(ts_bloom1_debug_hash); /* * A debug function to inspect the actual hash value used for the bloom filter, * e.g. to find the very even hashes with many low bits equal to zero. */ Datum ts_bloom1_debug_hash(PG_FUNCTION_ARGS) { Oid type_oid = get_fn_expr_argtype(fcinfo->flinfo, 0); FmgrInfo *finfo = NULL; PGFunction fn = bloom1_get_hash_function(type_oid, &finfo); Ensure(fn != NULL, "cannot find our hash function"); Assert(!PG_ARGISNULL(0)); Datum needle = PG_GETARG_DATUM(0); PG_RETURN_UINT64(calculate_hash(fn, finfo, needle)); } #endif // #ifndef NDEBUG �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/batch_metadata_builder_minmax.c������������������������������0000664�0000000�0000000�00000012600�15100345067�0026150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <libpq/pqformat.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/sortsupport.h> #include <utils/typcache.h> #include "batch_metadata_builder_minmax.h" #include "compression.h" static void minmax_update_val(void *builder_, Datum val); static void minmax_update_null(void *builder_); static void minmax_insert_to_compressed_row(void *builder_, RowCompressor *compressor); static void minmax_reset(void *builder_, RowCompressor *compressor); BatchMetadataBuilder * batch_metadata_builder_minmax_create(Oid type_oid, Oid collation, int min_attr_offset, int max_attr_offset) { BatchMetadataBuilderMinMax *builder = palloc(sizeof(*builder)); TypeCacheEntry *type = lookup_type_cache(type_oid, TYPECACHE_LT_OPR); if (!OidIsValid(type->lt_opr)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("could not identify an less-than operator for type %s", format_type_be(type_oid)))); *builder = (BatchMetadataBuilderMinMax){ .functions = (BatchMetadataBuilder){ .update_val = minmax_update_val, .update_null = minmax_update_null, .insert_to_compressed_row = minmax_insert_to_compressed_row, .reset = minmax_reset, }, .type_oid = type_oid, .empty = true, .has_null = false, .type_by_val = type->typbyval, .type_len = type->typlen, .min_metadata_attr_offset = min_attr_offset, .max_metadata_attr_offset = max_attr_offset, }; builder->ssup.ssup_cxt = CurrentMemoryContext; builder->ssup.ssup_collation = collation; builder->ssup.ssup_nulls_first = false; PrepareSortSupportFromOrderingOp(type->lt_opr, &builder->ssup); return &builder->functions; } void minmax_update_val(void *builder_, Datum val) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; int cmp; if (builder->empty) { builder->min = datumCopy(val, builder->type_by_val, builder->type_len); builder->max = datumCopy(val, builder->type_by_val, builder->type_len); builder->empty = false; return; } cmp = ApplySortComparator(builder->min, false, val, false, &builder->ssup); if (cmp > 0) { if (!builder->type_by_val) pfree(DatumGetPointer(builder->min)); builder->min = datumCopy(val, builder->type_by_val, builder->type_len); } cmp = ApplySortComparator(builder->max, false, val, false, &builder->ssup); if (cmp < 0) { if (!builder->type_by_val) pfree(DatumGetPointer(builder->max)); builder->max = datumCopy(val, builder->type_by_val, builder->type_len); } } void minmax_update_null(void *builder_) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; builder->has_null = true; } static void minmax_reset(void *builder_, RowCompressor *compressor) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; if (!builder->empty) { if (!builder->type_by_val) { pfree(DatumGetPointer(builder->min)); pfree(DatumGetPointer(builder->max)); } builder->min = 0; builder->max = 0; } builder->empty = true; builder->has_null = false; compressor->compressed_is_null[builder->max_metadata_attr_offset] = true; compressor->compressed_is_null[builder->min_metadata_attr_offset] = true; compressor->compressed_values[builder->min_metadata_attr_offset] = 0; compressor->compressed_values[builder->max_metadata_attr_offset] = 0; } Datum batch_metadata_builder_minmax_min(void *builder_) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; if (builder->empty) elog(ERROR, "trying to get min from an empty builder"); if (builder->type_len == -1) { Datum unpacked = PointerGetDatum(PG_DETOAST_DATUM_PACKED(builder->min)); if (builder->min != unpacked) pfree(DatumGetPointer(builder->min)); builder->min = unpacked; } return builder->min; } Datum batch_metadata_builder_minmax_max(void *builder_) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; if (builder->empty) elog(ERROR, "trying to get max from an empty builder"); if (builder->type_len == -1) { Datum unpacked = PointerGetDatum(PG_DETOAST_DATUM_PACKED(builder->max)); if (builder->max != unpacked) pfree(DatumGetPointer(builder->max)); builder->max = unpacked; } return builder->max; } bool batch_metadata_builder_minmax_empty(void *builder_) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; return builder->empty; } static void minmax_insert_to_compressed_row(void *builder_, RowCompressor *compressor) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) builder_; Assert(builder->min_metadata_attr_offset >= 0); Assert(builder->max_metadata_attr_offset >= 0); if (!batch_metadata_builder_minmax_empty(builder)) { compressor->compressed_is_null[builder->min_metadata_attr_offset] = false; compressor->compressed_is_null[builder->max_metadata_attr_offset] = false; compressor->compressed_values[builder->min_metadata_attr_offset] = batch_metadata_builder_minmax_min(builder); compressor->compressed_values[builder->max_metadata_attr_offset] = batch_metadata_builder_minmax_max(builder); } else { compressor->compressed_is_null[builder->min_metadata_attr_offset] = true; compressor->compressed_is_null[builder->max_metadata_attr_offset] = true; } } ��������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/batch_metadata_builder_minmax.h������������������������������0000664�0000000�0000000�00000002160�15100345067�0026155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <utils/sortsupport.h> #include "batch_metadata_builder.h" typedef struct BatchMetadataBuilderMinMax { BatchMetadataBuilder functions; Oid type_oid; bool empty; bool has_null; SortSupportData ssup; bool type_by_val; int16 type_len; Datum min; Datum max; int16 min_metadata_attr_offset; int16 max_metadata_attr_offset; } BatchMetadataBuilderMinMax; typedef struct BatchMetadataBuilderMinMax BatchMetadataBuilderMinMax; typedef struct RowCompressor RowCompressor; /* * This is exposed only for the old unit tests. Ideally they should be replaced * with functional tests inspecting the compressed chunk table, and this * test-only interface should be removed. */ Datum batch_metadata_builder_minmax_min(void *builder_); Datum batch_metadata_builder_minmax_max(void *builder_); bool batch_metadata_builder_minmax_empty(void *builder_); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/compression.c������������������������������������������������0000664�0000000�0000000�00000224262�15100345067�0022522�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/attmap.h> #include <access/attnum.h> #include <access/skey.h> #include <access/tupdesc.h> #include <catalog/heap.h> #include <catalog/indexing.h> #include <catalog/pg_am.h> #include <common/base64.h> #include <funcapi.h> #include <libpq/pqformat.h> #include <storage/predicate.h> #include <utils/datum.h> #include <utils/elog.h> #include <utils/palloc.h> #include <utils/rel.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "compat/compat.h" #include "algorithms/array.h" #include "algorithms/bool_compress.h" #include "algorithms/deltadelta.h" #include "algorithms/dictionary.h" #include "algorithms/gorilla.h" #include "algorithms/null.h" #include "algorithms/uuid_compress.h" #include "batch_metadata_builder.h" #include "chunk_insert_state.h" #include "compression.h" #include "create.h" #include "custom_type_cache.h" #include "debug_assert.h" #include "debug_point.h" #include "guc.h" #include "nodes/modify_hypertable.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_settings.h" #include <nodes/columnar_scan/vector_quals.h> /* * Timing parameters for truncate locking heuristics. * These are the same as used by Postgres for truncate locking during lazy vacuum. * https://github.com/postgres/postgres/blob/4a0650d359c5981270039eeb634c3b7427aa0af5/src/backend/access/heap/vacuumlazy.c#L82 */ #define COMPRESS_TRUNCATE_LOCK_WAIT_INTERVAL 50 /* ms */ #define COMPRESS_TRUNCATE_LOCK_TIMEOUT 5000 /* ms */ StaticAssertDecl(GLOBAL_MAX_ROWS_PER_COMPRESSION >= TARGET_COMPRESSED_BATCH_SIZE, "max row numbers must be harmonized"); StaticAssertDecl(GLOBAL_MAX_ROWS_PER_COMPRESSION <= INT16_MAX, "dictionary compression uses signed int16 indexes"); static const CompressionAlgorithmDefinition definitions[_END_COMPRESSION_ALGORITHMS] = { [COMPRESSION_ALGORITHM_ARRAY] = ARRAY_ALGORITHM_DEFINITION, [COMPRESSION_ALGORITHM_DICTIONARY] = DICTIONARY_ALGORITHM_DEFINITION, [COMPRESSION_ALGORITHM_GORILLA] = GORILLA_ALGORITHM_DEFINITION, [COMPRESSION_ALGORITHM_DELTADELTA] = DELTA_DELTA_ALGORITHM_DEFINITION, [COMPRESSION_ALGORITHM_BOOL] = BOOL_COMPRESS_ALGORITHM_DEFINITION, [COMPRESSION_ALGORITHM_NULL] = NULL_COMPRESS_ALGORITHM_DEFINITION, [COMPRESSION_ALGORITHM_UUID] = UUID_COMPRESS_ALGORITHM_DEFINITION, }; static NameData compression_algorithm_name[] = { [_INVALID_COMPRESSION_ALGORITHM] = { "INVALID" }, [COMPRESSION_ALGORITHM_ARRAY] = { "ARRAY" }, [COMPRESSION_ALGORITHM_DICTIONARY] = { "DICTIONARY" }, [COMPRESSION_ALGORITHM_GORILLA] = { "GORILLA" }, [COMPRESSION_ALGORITHM_DELTADELTA] = { "DELTADELTA" }, [COMPRESSION_ALGORITHM_BOOL] = { "BOOL" }, [COMPRESSION_ALGORITHM_NULL] = { "NULL" }, [COMPRESSION_ALGORITHM_UUID] = { "UUID" }, }; Name compression_get_algorithm_name(CompressionAlgorithm alg) { return &compression_algorithm_name[alg]; } static Compressor * compressor_for_type(Oid type) { CompressionAlgorithm algorithm = compression_get_default_algorithm(type); if (algorithm >= _END_COMPRESSION_ALGORITHMS) elog(ERROR, "invalid compression algorithm %d", algorithm); return definitions[algorithm].compressor_for_type(type); } DecompressionInitializer tsl_get_decompression_iterator_init(CompressionAlgorithm algorithm, bool reverse) { if (algorithm >= _END_COMPRESSION_ALGORITHMS) elog(ERROR, "invalid compression algorithm %d", algorithm); if (reverse) return definitions[algorithm].iterator_init_reverse; else return definitions[algorithm].iterator_init_forward; } DecompressAllFunction tsl_get_decompress_all_function(CompressionAlgorithm algorithm, Oid type) { if (algorithm >= _END_COMPRESSION_ALGORITHMS) elog(ERROR, "invalid compression algorithm %d", algorithm); if (type != TEXTOID && type != BOOLOID && type != UUIDOID && (algorithm == COMPRESSION_ALGORITHM_DICTIONARY || algorithm == COMPRESSION_ALGORITHM_ARRAY)) { /* Bulk decompression of array and dictionary is only supported for * text, bool and uuid */ return NULL; } return definitions[algorithm].decompress_all; } static Tuplesortstate *compress_chunk_sort_relation(CompressionSettings *settings, Relation in_rel); static void row_compressor_process_ordered_slot(RowCompressor *row_compressor, TupleTableSlot *slot, BulkWriter *writer); static void row_compressor_update_group(RowCompressor *row_compressor, TupleTableSlot *row); static bool row_compressor_new_row_is_in_new_group(RowCompressor *row_compressor, TupleTableSlot *row); static void create_per_compressed_column(RowDecompressor *decompressor); static void row_compressor_append_row(RowCompressor *row_compressor, TupleTableSlot *row); static void row_compressor_flush(RowCompressor *row_compressor, BulkWriter *writer, bool changed_groups); /******************** ** compress_chunk ** ********************/ static CompressedDataHeader * get_compressed_data_header(Datum data) { CompressedDataHeader *header = (CompressedDataHeader *) PG_DETOAST_DATUM(data); if (header->compression_algorithm >= _END_COMPRESSION_ALGORITHMS) elog(ERROR, "invalid compression algorithm %d", header->compression_algorithm); return header; } /* Truncate the relation WITHOUT applying triggers. This is the * main difference with ExecuteTruncate. Triggers aren't applied * because the data remains, just in compressed form. Also don't * restart sequences. Use the transactional branch through ExecuteTruncate. */ static void truncate_relation(Oid table_oid) { List *fks = heap_truncate_find_FKs(list_make1_oid(table_oid)); /* Take an access exclusive lock now. Note that this may very well * be a lock upgrade. */ Relation rel = table_open(table_oid, AccessExclusiveLock); Oid toast_relid; /* Chunks should never have fks into them, but double check */ if (fks != NIL) elog(ERROR, "found a FK into a chunk while truncating"); CheckTableForSerializableConflictIn(rel); #if PG16_LT RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence); #else RelationSetNewRelfilenumber(rel, rel->rd_rel->relpersistence); #endif toast_relid = rel->rd_rel->reltoastrelid; table_close(rel, NoLock); if (OidIsValid(toast_relid)) { rel = table_open(toast_relid, AccessExclusiveLock); #if PG16_LT RelationSetNewRelfilenode(rel, rel->rd_rel->relpersistence); #else RelationSetNewRelfilenumber(rel, rel->rd_rel->relpersistence); #endif table_close(rel, NoLock); } ReindexParams params = { 0 }; ReindexParams *options = ¶ms; reindex_relation_compat(NULL, table_oid, REINDEX_REL_PROCESS_TOAST, options); rel = table_open(table_oid, AccessExclusiveLock); CommandCounterIncrement(); table_close(rel, NoLock); } /* Handle the all rows deletion of a given relation */ static void RelationDeleteAllRows(Relation rel, Snapshot snap) { TupleTableSlot *slot = table_slot_create(rel, NULL); TableScanDesc scan = table_beginscan(rel, snap, 0, NULL); while (table_scan_getnextslot(scan, ForwardScanDirection, slot)) { simple_table_tuple_delete(rel, &(slot->tts_tid), snap); } table_endscan(scan); ExecDropSingleTupleTableSlot(slot); } /* * Delete the relation WITHOUT applying triggers. This will be used when * `enable_delete_after_compression = true` instead of truncating the relation. * Also don't restart sequences. */ static void delete_relation_rows(Oid table_oid) { Relation rel = table_open(table_oid, RowExclusiveLock); Snapshot snap = RegisterSnapshot(GetLatestSnapshot()); /* Delete the rows in the table */ RelationDeleteAllRows(rel, snap); /* Delete the rows in the toast table */ if (OidIsValid(rel->rd_rel->reltoastrelid)) { Relation toast_rel = table_open(rel->rd_rel->reltoastrelid, RowExclusiveLock); RelationDeleteAllRows(toast_rel, snap); table_close(toast_rel, NoLock); } table_close(rel, NoLock); UnregisterSnapshot(snap); } /* * Use reltuples as an estimate for the number of rows that will get compressed. This value * might be way off the mark in case analyze hasn't happened in quite a while on this input * chunk. But that's the best guesstimate to start off with. * * We will report progress for every 10% of reltuples compressed. If rel or reltuples is not valid * or it's just too low then we just assume reporting every 100K tuples for now. */ #define RELTUPLES_REPORT_DEFAULT 100000 static int64 calculate_reltuples_to_report(float4 reltuples) { int64 report_reltuples = RELTUPLES_REPORT_DEFAULT; if (reltuples > 0) { report_reltuples = (int64) (0.1 * reltuples); /* either analyze has not been done or table doesn't have a lot of rows */ if (report_reltuples < RELTUPLES_REPORT_DEFAULT) report_reltuples = RELTUPLES_REPORT_DEFAULT; } return report_reltuples; } CompressionStats compress_chunk(Oid in_table, Oid out_table, int insert_options) { int n_keys; ListCell *lc; ScanDirection indexscan_direction = NoMovementScanDirection; Relation matched_index_rel = NULL; TupleTableSlot *slot; IndexScanDesc index_scan; HeapTuple in_table_tp = NULL, index_tp = NULL; Form_pg_attribute in_table_attr_tp, index_attr_tp; CompressionStats cstat; CompressionSettings *settings = ts_compression_settings_get_by_compress_relid(out_table); int64 report_reltuples; /* We want to prevent other compressors from compressing this table, * and we want to prevent INSERTs or UPDATEs which could mess up our compression. * We may as well allow readers to keep reading the uncompressed data while * we are compressing, so we only take an ExclusiveLock instead of AccessExclusive. */ Relation in_rel = table_open(in_table, ExclusiveLock); /* We are _just_ INSERTing into the out_table so in principle we could take * a RowExclusive lock, and let other operations read and write this table * as we work. However, we currently compress each table as a oneshot, so * we're taking the stricter lock to prevent accidents. * * Putting RowExclusiveMode behind a GUC so we can try this out with * rollups during compression. */ int out_rel_lockmode = ExclusiveLock; if (ts_guc_enable_rowlevel_compression_locking) { out_rel_lockmode = RowExclusiveLock; } Relation out_rel = relation_open(out_table, out_rel_lockmode); BulkWriter writer = bulk_writer_build(out_rel, insert_options); /* Sanity check we are dealing with relations */ Ensure(in_rel->rd_rel->relkind == RELKIND_RELATION, "compress_chunk called on non-relation"); Ensure(out_rel->rd_rel->relkind == RELKIND_RELATION, "compress_chunk called on non-relation"); PushActiveSnapshot(GetTransactionSnapshot()); /* Before calling row compressor relation should be segmented and sorted as configured * by compress_segmentby and compress_orderby. * Cost of sorting can be mitigated if we find an existing BTREE index defined for * uncompressed chunk otherwise expensive tuplesort will come into play. * * The following code is trying to find an existing index that * matches the configuration so that we can skip sequential scan and * tuplesort. * */ if (ts_guc_enable_compression_indexscan) { List *in_rel_index_oids = RelationGetIndexList(in_rel); foreach (lc, in_rel_index_oids) { Oid index_oid = lfirst_oid(lc); Relation index_rel = index_open(index_oid, AccessShareLock); IndexInfo *index_info = BuildIndexInfo(index_rel); if (index_info->ii_Predicate != 0) { /* * Can't use partial indexes for compression because they refer * only to a subset of all rows. */ index_close(index_rel, AccessShareLock); continue; } int previous_direction = NoMovementScanDirection; int current_direction = NoMovementScanDirection; n_keys = ts_array_length(settings->fd.segmentby) + ts_array_length(settings->fd.orderby); if (n_keys <= index_info->ii_NumIndexKeyAttrs && index_info->ii_Am == BTREE_AM_OID) { int i; for (i = 0; i < n_keys; i++) { const char *attname; int16 position; bool is_orderby_asc = true; bool is_null_first = false; if (i < ts_array_length(settings->fd.segmentby)) { position = i + 1; attname = ts_array_get_element_text(settings->fd.segmentby, position); } else { position = i - ts_array_length(settings->fd.segmentby) + 1; attname = ts_array_get_element_text(settings->fd.orderby, position); is_orderby_asc = !ts_array_get_element_bool(settings->fd.orderby_desc, position); is_null_first = ts_array_get_element_bool(settings->fd.orderby_nullsfirst, position); } int16 att_num = get_attnum(in_table, attname); int16 option = index_rel->rd_indoption[i]; bool index_orderby_asc = ((option & INDOPTION_DESC) == 0); bool index_null_first = ((option & INDOPTION_NULLS_FIRST) != 0); if (att_num == 0 || index_info->ii_IndexAttrNumbers[i] != att_num) { break; } in_table_tp = SearchSysCacheAttNum(in_table, att_num); if (!HeapTupleIsValid(in_table_tp)) elog(ERROR, "table \"%s\" does not have column \"%s\"", get_rel_name(in_table), attname); index_tp = SearchSysCacheAttNum(index_oid, i + 1); if (!HeapTupleIsValid(index_tp)) elog(ERROR, "index \"%s\" does not have column \"%s\"", get_rel_name(index_oid), attname); in_table_attr_tp = (Form_pg_attribute) GETSTRUCT(in_table_tp); index_attr_tp = (Form_pg_attribute) GETSTRUCT(index_tp); if (index_orderby_asc == is_orderby_asc && index_null_first == is_null_first && in_table_attr_tp->attcollation == index_attr_tp->attcollation) { current_direction = ForwardScanDirection; } else if (index_orderby_asc != is_orderby_asc && index_null_first != is_null_first && in_table_attr_tp->attcollation == index_attr_tp->attcollation) { current_direction = BackwardScanDirection; } else { current_direction = NoMovementScanDirection; break; } ReleaseSysCache(in_table_tp); in_table_tp = NULL; ReleaseSysCache(index_tp); index_tp = NULL; if (previous_direction == NoMovementScanDirection) { previous_direction = current_direction; } else if (previous_direction != current_direction) { break; } } if (n_keys == i && (previous_direction == current_direction && current_direction != NoMovementScanDirection)) { matched_index_rel = index_rel; indexscan_direction = current_direction; break; } else { if (HeapTupleIsValid(in_table_tp)) { ReleaseSysCache(in_table_tp); in_table_tp = NULL; } if (HeapTupleIsValid(index_tp)) { ReleaseSysCache(index_tp); index_tp = NULL; } index_close(index_rel, AccessShareLock); } } else { index_close(index_rel, AccessShareLock); } } } RowCompressor row_compressor; Assert(settings->fd.compress_relid == RelationGetRelid(out_rel)); row_compressor_init(&row_compressor, settings, RelationGetDescr(in_rel), RelationGetDescr(out_rel)); if (matched_index_rel != NULL) { int64 nrows_processed = 0; elog(ts_guc_debug_compression_path_info ? INFO : DEBUG1, "using index \"%s\" to scan rows for converting to columnstore", get_rel_name(matched_index_rel->rd_id)); index_scan = index_beginscan_compat(in_rel, matched_index_rel, GetActiveSnapshot(), NULL, 0, 0); slot = table_slot_create(in_rel, NULL); index_rescan(index_scan, NULL, 0, NULL, 0); report_reltuples = calculate_reltuples_to_report(in_rel->rd_rel->reltuples); while (index_getnext_slot(index_scan, indexscan_direction, slot)) { row_compressor_process_ordered_slot(&row_compressor, slot, &writer); if ((++nrows_processed % report_reltuples) == 0) elog(DEBUG2, "converted " INT64_FORMAT " rows to columnstore from \"%s\"", nrows_processed, RelationGetRelationName(in_rel)); } if (row_compressor.rows_compressed_into_current_value > 0) row_compressor_flush(&row_compressor, &writer, true); elog(DEBUG1, "finished converting " INT64_FORMAT " rows to columnstore from \"%s\"", nrows_processed, RelationGetRelationName(in_rel)); ExecDropSingleTupleTableSlot(slot); index_endscan(index_scan); index_close(matched_index_rel, AccessShareLock); } else { elog(ts_guc_debug_compression_path_info ? INFO : DEBUG1, "using tuplesort to scan rows from \"%s\" for converting to columnstore", RelationGetRelationName(in_rel)); Tuplesortstate *sorted_rel = compress_chunk_sort_relation(settings, in_rel); row_compressor_append_sorted_rows(&row_compressor, sorted_rel, in_rel, &writer); tuplesort_end(sorted_rel); } row_compressor_close(&row_compressor); bulk_writer_close(&writer); if (ts_guc_enable_delete_after_compression) { ereport(NOTICE, (errcode(ERRCODE_WARNING_DEPRECATED_FEATURE), errmsg("timescaledb.enable_delete_after_compression is deprecated and will be " "removed in a future version. Please use " "timescaledb.compress_truncate_behaviour instead."))); delete_relation_rows(in_table); DEBUG_WAITPOINT("compression_done_after_delete_uncompressed"); } else { int lock_retry = 0; switch (ts_guc_compress_truncate_behaviour) { case COMPRESS_TRUNCATE_ONLY: DEBUG_WAITPOINT("compression_done_before_truncate_uncompressed"); truncate_relation(in_table); DEBUG_WAITPOINT("compression_done_after_truncate_uncompressed"); break; case COMPRESS_TRUNCATE_OR_DELETE: DEBUG_WAITPOINT("compression_done_before_truncate_or_delete_uncompressed"); while (true) { if (ConditionalLockRelation(in_rel, AccessExclusiveLock)) { truncate_relation(in_table); break; } /* * Check for interrupts while trying to (re-)acquire the exclusive * lock. */ CHECK_FOR_INTERRUPTS(); if (++lock_retry > (COMPRESS_TRUNCATE_LOCK_TIMEOUT / COMPRESS_TRUNCATE_LOCK_WAIT_INTERVAL)) { /* * We failed to establish the lock in the specified number of * retries. This means we give up truncating and fallback to delete */ delete_relation_rows(in_table); break; } (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, COMPRESS_TRUNCATE_LOCK_WAIT_INTERVAL, WAIT_EVENT_VACUUM_TRUNCATE); ResetLatch(MyLatch); } DEBUG_WAITPOINT("compression_done_after_truncate_or_delete_uncompressed"); break; case COMPRESS_TRUNCATE_DISABLED: delete_relation_rows(in_table); DEBUG_WAITPOINT("compression_done_after_delete_uncompressed"); break; } } table_close(out_rel, NoLock); table_close(in_rel, NoLock); PopActiveSnapshot(); cstat.rowcnt_pre_compression = row_compressor.rowcnt_pre_compression; cstat.rowcnt_post_compression = row_compressor.num_compressed_rows; if ((insert_options & HEAP_INSERT_FROZEN) == HEAP_INSERT_FROZEN) cstat.rowcnt_frozen = row_compressor.num_compressed_rows; else cstat.rowcnt_frozen = 0; return cstat; } Tuplesortstate * compression_create_tuplesort_state(CompressionSettings *settings, Relation rel) { TupleDesc tupdesc = RelationGetDescr(rel); int num_segmentby = ts_array_length(settings->fd.segmentby); int num_orderby = ts_array_length(settings->fd.orderby); int n_keys = num_segmentby + num_orderby; AttrNumber *sort_keys = palloc(sizeof(*sort_keys) * n_keys); Oid *sort_operators = palloc(sizeof(*sort_operators) * n_keys); Oid *sort_collations = palloc(sizeof(*sort_collations) * n_keys); bool *nulls_first = palloc(sizeof(*nulls_first) * n_keys); int n; for (n = 0; n < n_keys; n++) { const char *attname; int position; if (n < num_segmentby) { position = n + 1; attname = ts_array_get_element_text(settings->fd.segmentby, position); } else { position = n - num_segmentby + 1; attname = ts_array_get_element_text(settings->fd.orderby, position); } compress_chunk_populate_sort_info_for_column(settings, RelationGetRelid(rel), attname, &sort_keys[n], &sort_operators[n], &sort_collations[n], &nulls_first[n]); } /* Make a copy of the tuple descriptor so that it is allocated on the same * memory context as the tuple sort instead of pointing into the relcache * entry that could be blown away. */ return tuplesort_begin_heap(CreateTupleDescCopy(tupdesc), n_keys, sort_keys, sort_operators, sort_collations, nulls_first, maintenance_work_mem, NULL, false /*=randomAccess*/); } static Tuplesortstate * compress_chunk_sort_relation(CompressionSettings *settings, Relation in_rel) { PushActiveSnapshot(GetLatestSnapshot()); Tuplesortstate *tuplesortstate; TableScanDesc scan; TupleTableSlot *slot; tuplesortstate = compression_create_tuplesort_state(settings, in_rel); scan = table_beginscan(in_rel, GetActiveSnapshot(), 0, NULL); slot = table_slot_create(in_rel, NULL); while (table_scan_getnextslot(scan, ForwardScanDirection, slot)) { if (!TTS_EMPTY(slot)) { /* This may not be the most efficient way to do things. * Since we use begin_heap() the tuplestore expects tupleslots, * so ISTM that the options are this or maybe putdatum(). */ tuplesort_puttupleslot(tuplesortstate, slot); } } table_endscan(scan); ExecDropSingleTupleTableSlot(slot); tuplesort_performsort(tuplesortstate); PopActiveSnapshot(); return tuplesortstate; } void compress_chunk_populate_sort_info_for_column(const CompressionSettings *settings, Oid table, const char *attname, AttrNumber *att_nums, Oid *sort_operator, Oid *collation, bool *nulls_first) { HeapTuple tp; Form_pg_attribute att_tup; TypeCacheEntry *tentry; tp = SearchSysCacheAttName(table, attname); if (!HeapTupleIsValid(tp)) elog(ERROR, "table \"%s\" does not have column \"%s\"", get_rel_name(table), attname); att_tup = (Form_pg_attribute) GETSTRUCT(tp); /* Other validation checks beyond just existence of a valid comparison operator could be useful */ *att_nums = att_tup->attnum; *collation = att_tup->attcollation; tentry = lookup_type_cache(att_tup->atttypid, TYPECACHE_LT_OPR | TYPECACHE_GT_OPR); if (ts_array_is_member(settings->fd.segmentby, attname)) { *nulls_first = false; *sort_operator = tentry->lt_opr; } else { Assert(ts_array_is_member(settings->fd.orderby, attname)); int position = ts_array_position(settings->fd.orderby, attname); *nulls_first = ts_array_get_element_bool(settings->fd.orderby_nullsfirst, position); if (ts_array_get_element_bool(settings->fd.orderby_desc, position)) *sort_operator = tentry->gt_opr; else *sort_operator = tentry->lt_opr; } if (!OidIsValid(*sort_operator)) elog(ERROR, "no valid sort operator for column \"%s\" of type \"%s\"", attname, format_type_be(att_tup->atttypid)); ReleaseSysCache(tp); } /* * Find segment by index on compressed chunk needed when doing index scans * over compressed data */ Oid get_compressed_chunk_index(ResultRelInfo *resultRelInfo, const CompressionSettings *settings) { int num_segmentby_columns = ts_array_length(settings->fd.segmentby); int num_orderby_columns = ts_array_length(settings->fd.orderby); for (int i = 0; i < resultRelInfo->ri_NumIndices; i++) { bool matches = true; Relation index_relation = resultRelInfo->ri_IndexRelationDescs[i]; IndexInfo *index_info = resultRelInfo->ri_IndexRelationInfo[i]; /* The index must include all segment by columns and at least two metadata columns. * Default index we build includes all segmentby columns and metadata columns (min and max, * in that order) for all orderby columns.*/ if (index_info->ii_NumIndexKeyAttrs != num_segmentby_columns + (num_orderby_columns * 2)) continue; for (int j = 0; j < num_segmentby_columns - 1; j++) { AttrNumber attno = index_relation->rd_index->indkey.values[j]; const char *attname = get_attname(index_relation->rd_index->indrelid, attno, false); if (!ts_array_is_member(settings->fd.segmentby, attname)) { matches = false; break; } } if (!matches) continue; return RelationGetRelid(index_relation); } return InvalidOid; } static void build_column_map(const CompressionSettings *settings, const TupleDesc in_desc, const TupleDesc out_desc, PerColumn **pcolumns, int16 **pmap) { Oid compressed_data_type_oid = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; PerColumn *columns = palloc0(sizeof(PerColumn) * in_desc->natts); int16 *map = palloc0(sizeof(int16) * in_desc->natts); for (int i = 0; i < in_desc->natts; i++) { Form_pg_attribute attr = TupleDescAttr(in_desc, i); if (attr->attisdropped) continue; PerColumn *column = &columns[AttrNumberGetAttrOffset(attr->attnum)]; AttrNumber compressed_colnum = get_attnum(settings->fd.compress_relid, NameStr(attr->attname)); Form_pg_attribute compressed_column_attr = TupleDescAttr(out_desc, AttrNumberGetAttrOffset(compressed_colnum)); map[AttrNumberGetAttrOffset(attr->attnum)] = AttrNumberGetAttrOffset(compressed_colnum); bool is_segmentby = ts_array_is_member(settings->fd.segmentby, NameStr(attr->attname)); bool is_orderby = ts_array_is_member(settings->fd.orderby, NameStr(attr->attname)); if (!is_segmentby) { if (compressed_column_attr->atttypid != compressed_data_type_oid) elog(ERROR, "expected column '%s' to be a compressed data type", NameStr(attr->attname)); AttrNumber segment_min_attr_number = compressed_column_metadata_attno(settings, settings->fd.relid, attr->attnum, settings->fd.compress_relid, "min"); AttrNumber segment_max_attr_number = compressed_column_metadata_attno(settings, settings->fd.relid, attr->attnum, settings->fd.compress_relid, "max"); int16 segment_min_attr_offset = segment_min_attr_number - 1; int16 segment_max_attr_offset = segment_max_attr_number - 1; BatchMetadataBuilder *batch_minmax_builder = NULL; if (segment_min_attr_number != InvalidAttrNumber || segment_max_attr_number != InvalidAttrNumber) { Ensure(segment_min_attr_number != InvalidAttrNumber, "could not find the min metadata column"); Ensure(segment_max_attr_number != InvalidAttrNumber, "could not find the min metadata column"); batch_minmax_builder = batch_metadata_builder_minmax_create(attr->atttypid, attr->attcollation, segment_min_attr_offset, segment_max_attr_offset); } Ensure(!is_orderby || batch_minmax_builder != NULL, "orderby columns must have minmax metadata"); const AttrNumber bloom_attr_number = compressed_column_metadata_attno(settings, settings->fd.relid, attr->attnum, settings->fd.compress_relid, "bloom1"); if (AttributeNumberIsValid(bloom_attr_number)) { const int bloom_attr_offset = AttrNumberGetAttrOffset(bloom_attr_number); batch_minmax_builder = batch_metadata_builder_bloom1_create(attr->atttypid, bloom_attr_offset); } *column = (PerColumn){ .compressor = compressor_for_type(attr->atttypid), .metadata_builder = batch_minmax_builder, .segmentby_column_index = -1, }; } else { if (attr->atttypid != compressed_column_attr->atttypid) elog(ERROR, "expected segment by column \"%s\" to be same type as uncompressed column", NameStr(attr->attname)); int16 index = ts_array_position(settings->fd.segmentby, NameStr(attr->attname)); *column = (PerColumn){ .segment_info = segment_info_new(attr), .segmentby_column_index = index, }; } } *pcolumns = columns; *pmap = map; } /* Check if we contain any compressors which need allocation limit checking */ static bool check_for_limited_size_compressors(PerColumn *pcolumns, int16 natts) { for (int i = 0; i < natts; i++) { if (pcolumns[i].compressor && pcolumns[i].compressor->is_full) return true; } return false; } void tsl_compressor_add_slot(RowCompressor *compressor, BulkWriter *bulk_writer, TupleTableSlot *slot) { if (compressor->sort_state) { tuplesort_puttupleslot(compressor->sort_state, slot); compressor->tuples_to_sort++; } else { row_compressor_process_ordered_slot(compressor, slot, bulk_writer); } } void tsl_compressor_flush(RowCompressor *compressor, BulkWriter *bulk_writer) { if (compressor->sort_state) { if (compressor->tuples_to_sort) { tuplesort_performsort(compressor->sort_state); TupleTableSlot *slot = MakeTupleTableSlot(compressor->in_desc, &TTSOpsMinimalTuple); while (tuplesort_gettupleslot(compressor->sort_state, true /*=forward*/, false /*=copy*/, slot, NULL /*=abbrev*/)) row_compressor_process_ordered_slot(compressor, slot, bulk_writer); if (compressor->rows_compressed_into_current_value > 0) row_compressor_flush(compressor, bulk_writer, true); ExecDropSingleTupleTableSlot(slot); tuplesort_reset(compressor->sort_state); compressor->tuples_to_sort = 0; } } else { if (compressor->rows_compressed_into_current_value > 0) row_compressor_flush(compressor, bulk_writer, false); } } void tsl_compressor_free(RowCompressor *compressor, BulkWriter *bulk_writer) { if (compressor->sort_state) tuplesort_end(compressor->sort_state); tsl_compressor_flush(compressor, bulk_writer); row_compressor_close(compressor); bulk_writer_close(bulk_writer); table_close(bulk_writer->out_rel, NoLock); } /* * Initialize a RowCompressor for compressing tuples * * When `sort` is true, the compressor will buffer all the tuples in a * Tuplesortstate and sort them before flushing to the output relation. */ RowCompressor * tsl_compressor_init(Relation in_rel, BulkWriter **bulk_writer, bool sort) { RowCompressor *compressor = palloc0(sizeof(RowCompressor)); CompressionSettings *settings = ts_compression_settings_get(in_rel->rd_id); Relation out_rel = table_open(settings->fd.compress_relid, RowExclusiveLock); *bulk_writer = bulk_writer_alloc(out_rel, 0); row_compressor_init(compressor, settings, RelationGetDescr(in_rel), RelationGetDescr(out_rel)); if (sort) compressor->sort_state = compression_create_tuplesort_state(settings, in_rel); return compressor; } /******************** ** row_compressor ** ********************/ void row_compressor_init(RowCompressor *row_compressor, const CompressionSettings *settings, const TupleDesc noncompressed_tupdesc, const TupleDesc compressed_tupdesc) { Name count_metadata_name = DatumGetName( DirectFunctionCall1(namein, CStringGetDatum(COMPRESSION_COLUMN_METADATA_COUNT_NAME))); AttrNumber count_metadata_column_num = get_attnum(settings->fd.compress_relid, NameStr(*count_metadata_name)); if (count_metadata_column_num == InvalidAttrNumber) elog(ERROR, "missing metadata column '%s' in columnstore table", COMPRESSION_COLUMN_METADATA_COUNT_NAME); *row_compressor = (RowCompressor){ .per_row_ctx = AllocSetContextCreate(CurrentMemoryContext, "compress chunk per-row", ALLOCSET_DEFAULT_SIZES), .in_desc = CreateTupleDescCopyConstr(noncompressed_tupdesc), .out_desc = CreateTupleDescCopyConstr(compressed_tupdesc), .n_input_columns = noncompressed_tupdesc->natts, .count_metadata_column_offset = AttrNumberGetAttrOffset(count_metadata_column_num), .compressed_values = palloc(sizeof(Datum) * compressed_tupdesc->natts), .compressed_is_null = palloc(sizeof(bool) * compressed_tupdesc->natts), .rows_compressed_into_current_value = 0, .rowcnt_pre_compression = 0, .num_compressed_rows = 0, .first_iteration = true, .sort_state = NULL, }; memset(row_compressor->compressed_is_null, 1, sizeof(bool) * compressed_tupdesc->natts); build_column_map(settings, noncompressed_tupdesc, compressed_tupdesc, &row_compressor->per_column, &row_compressor->uncompressed_col_to_compressed_col); /* If we have dictionary or array compressors, we have to check compressor size so we don't end * up going over allocation limit */ row_compressor->needs_fullness_check = check_for_limited_size_compressors(row_compressor->per_column, row_compressor->n_input_columns); } void row_compressor_append_sorted_rows(RowCompressor *row_compressor, Tuplesortstate *sorted_rel, Relation in_rel, BulkWriter *writer) { TupleTableSlot *slot = MakeTupleTableSlot(row_compressor->in_desc, &TTSOpsMinimalTuple); int64 nrows_processed = 0; int64 report_reltuples; report_reltuples = calculate_reltuples_to_report(in_rel->rd_rel->reltuples); while (tuplesort_gettupleslot(sorted_rel, true /*=forward*/, false /*=copy*/, slot, NULL /*=abbrev*/)) { row_compressor_process_ordered_slot(row_compressor, slot, writer); if ((++nrows_processed % report_reltuples) == 0) elog(DEBUG2, "compressed " INT64_FORMAT " rows from \"%s\"", nrows_processed, RelationGetRelationName(in_rel)); } if (row_compressor->rows_compressed_into_current_value > 0) row_compressor_flush(row_compressor, writer, true); elog(DEBUG1, "finished compressing " INT64_FORMAT " rows from \"%s\"", nrows_processed, RelationGetRelationName(in_rel)); ExecDropSingleTupleTableSlot(slot); } static bool row_compressor_is_full(RowCompressor *row_compressor, TupleTableSlot *row) { if (row_compressor->rows_compressed_into_current_value >= (uint32) ts_guc_compression_batch_size_limit) return true; if (!ts_guc_compression_enable_compressor_batch_limit) return false; if (!row_compressor->needs_fullness_check) return false; /* Check with every column compressor if they can add the next value to current batch */ int col; for (col = 0; col < row_compressor->n_input_columns; col++) { Compressor *compressor = row_compressor->per_column[col].compressor; bool is_null; Datum val; /* No compressor or the compressor has no check, just skip */ if (compressor == NULL || compressor->is_full == NULL) continue; val = slot_getattr(row, AttrOffsetGetAttrNumber(col), &is_null); if (!is_null) { if (compressor->is_full(compressor, val)) return true; } } return false; } void row_compressor_append_ordered_slot(RowCompressor *row_compressor, TupleTableSlot *slot) { MemoryContext old_ctx; slot_getallattrs(slot); old_ctx = MemoryContextSwitchTo(row_compressor->per_row_ctx); if (row_compressor->first_iteration) { row_compressor_update_group(row_compressor, slot); row_compressor->first_iteration = false; } bool changed_groups = row_compressor_new_row_is_in_new_group(row_compressor, slot); bool compressed_row_is_full = row_compressor_is_full(row_compressor, slot); Ensure(!changed_groups, "row is in different group"); Ensure(!compressed_row_is_full, "batch is full"); row_compressor_append_row(row_compressor, slot); MemoryContextSwitchTo(old_ctx); ExecClearTuple(slot); } static void row_compressor_process_ordered_slot(RowCompressor *row_compressor, TupleTableSlot *slot, BulkWriter *writer) { MemoryContext old_ctx; slot_getallattrs(slot); old_ctx = MemoryContextSwitchTo(row_compressor->per_row_ctx); if (row_compressor->first_iteration) { row_compressor_update_group(row_compressor, slot); row_compressor->first_iteration = false; } bool changed_groups = row_compressor_new_row_is_in_new_group(row_compressor, slot); bool compressed_row_is_full = row_compressor_is_full(row_compressor, slot); if (compressed_row_is_full || changed_groups) { if (row_compressor->rows_compressed_into_current_value > 0) row_compressor_flush(row_compressor, writer, changed_groups); if (changed_groups) row_compressor_update_group(row_compressor, slot); } row_compressor_append_row(row_compressor, slot); MemoryContextSwitchTo(old_ctx); ExecClearTuple(slot); } static void row_compressor_update_group(RowCompressor *row_compressor, TupleTableSlot *row) { int col; /* save original memory context */ const MemoryContext oldcontext = CurrentMemoryContext; Assert(row_compressor->rows_compressed_into_current_value == 0); Assert(row_compressor->n_input_columns <= row->tts_nvalid); MemoryContextSwitchTo(row_compressor->per_row_ctx->parent); for (col = 0; col < row_compressor->n_input_columns; col++) { PerColumn *column = &row_compressor->per_column[col]; Datum val; bool is_null; if (column->segment_info == NULL) continue; Assert(column->compressor == NULL); /* Performance Improvement: We should just use array access here; everything is guaranteed to be fetched */ val = slot_getattr(row, AttrOffsetGetAttrNumber(col), &is_null); segment_info_update(column->segment_info, val, is_null); } /* switch to original memory context */ MemoryContextSwitchTo(oldcontext); } static bool row_compressor_new_row_is_in_new_group(RowCompressor *row_compressor, TupleTableSlot *row) { int col; for (col = 0; col < row_compressor->n_input_columns; col++) { PerColumn *column = &row_compressor->per_column[col]; Datum datum = CharGetDatum(0); bool is_null; if (column->segment_info == NULL) continue; Assert(column->compressor == NULL); datum = slot_getattr(row, AttrOffsetGetAttrNumber(col), &is_null); if (!segment_info_datum_is_in_group(column->segment_info, datum, is_null)) return true; } return false; } void row_compressor_append_row(RowCompressor *row_compressor, TupleTableSlot *row) { int col; for (col = 0; col < row_compressor->n_input_columns; col++) { Compressor *compressor = row_compressor->per_column[col].compressor; bool is_null; Datum val; /* if there is no compressor, this must be a segmenter, so just skip */ if (compressor == NULL) continue; /* Performance Improvement: Since we call getallatts at the beginning, slot_getattr is * useless overhead here, and we should just access the array directly. */ BatchMetadataBuilder *builder = row_compressor->per_column[col].metadata_builder; val = slot_getattr(row, AttrOffsetGetAttrNumber(col), &is_null); if (is_null) { compressor->append_null(compressor); if (builder != NULL) { builder->update_null(builder); } } else { compressor->append_val(compressor, val); if (builder != NULL) { builder->update_val(builder, val); } } } row_compressor->rows_compressed_into_current_value += 1; } HeapTuple row_compressor_build_tuple(RowCompressor *row_compressor) { MemoryContext old_cxt = MemoryContextSwitchTo(row_compressor->per_row_ctx); for (int col = 0; col < row_compressor->n_input_columns; col++) { PerColumn *column = &row_compressor->per_column[col]; Compressor *compressor; int16 compressed_col; if (column->compressor == NULL && column->segment_info == NULL) continue; compressor = column->compressor; compressed_col = row_compressor->uncompressed_col_to_compressed_col[col]; Assert(compressed_col >= 0); if (compressor != NULL) { void *compressed_data; Assert(column->segment_info == NULL); compressed_data = compressor->finish(compressor); if (compressed_data == NULL) { if (ts_guc_enable_null_compression && row_compressor->rows_compressed_into_current_value > 0) compressed_data = null_compressor_get_dummy_block(); } row_compressor->compressed_is_null[compressed_col] = compressed_data == NULL; if (compressed_data != NULL) row_compressor->compressed_values[compressed_col] = PointerGetDatum(compressed_data); if (column->metadata_builder != NULL) { column->metadata_builder->insert_to_compressed_row(column->metadata_builder, row_compressor); } } else if (column->segment_info != NULL) { row_compressor->compressed_values[compressed_col] = column->segment_info->val; row_compressor->compressed_is_null[compressed_col] = column->segment_info->is_null; } } row_compressor->compressed_values[row_compressor->count_metadata_column_offset] = Int32GetDatum(row_compressor->rows_compressed_into_current_value); row_compressor->compressed_is_null[row_compressor->count_metadata_column_offset] = false; MemoryContextSwitchTo(old_cxt); /* Build the tuple on the callers memory context */ return heap_form_tuple(row_compressor->out_desc, row_compressor->compressed_values, row_compressor->compressed_is_null); } void row_compressor_clear_batch(RowCompressor *row_compressor, bool changed_groups) { MemoryContext old_cxt = MemoryContextSwitchTo(row_compressor->per_row_ctx); /* free the compressed values now that we're done with them (the old compressor is freed in * finish()) */ for (int col = 0; col < row_compressor->n_input_columns; col++) { PerColumn *column = &row_compressor->per_column[col]; int16 compressed_col; if (column->compressor == NULL && column->segment_info == NULL) continue; compressed_col = row_compressor->uncompressed_col_to_compressed_col[col]; Assert(compressed_col >= 0); if (row_compressor->compressed_is_null[compressed_col]) continue; /* don't free the segment-bys if we've overflowed the row, we still need them */ if (column->segment_info != NULL && !changed_groups) continue; if (column->compressor != NULL || !column->segment_info->typ_by_val) pfree(DatumGetPointer(row_compressor->compressed_values[compressed_col])); if (column->metadata_builder != NULL) { column->metadata_builder->reset(column->metadata_builder, row_compressor); } row_compressor->compressed_values[compressed_col] = 0; row_compressor->compressed_is_null[compressed_col] = true; } row_compressor->rowcnt_pre_compression += row_compressor->rows_compressed_into_current_value; row_compressor->num_compressed_rows++; row_compressor->rows_compressed_into_current_value = 0; MemoryContextSwitchTo(old_cxt); MemoryContextReset(row_compressor->per_row_ctx); } static void row_compressor_flush(RowCompressor *row_compressor, BulkWriter *writer, bool changed_groups) { HeapTuple compressed_tuple = row_compressor_build_tuple(row_compressor); MemoryContext old_cxt = MemoryContextSwitchTo(row_compressor->per_row_ctx); Assert(writer->bistate != NULL); heap_insert(writer->out_rel, compressed_tuple, writer->mycid, writer->insert_options /*=options*/, writer->bistate); if (writer->indexstate->ri_NumIndices > 0) { ts_catalog_index_insert(writer->indexstate, compressed_tuple); } heap_freetuple(compressed_tuple); if (row_compressor->on_flush) row_compressor->on_flush(row_compressor, row_compressor->rows_compressed_into_current_value); MemoryContextSwitchTo(old_cxt); row_compressor_clear_batch(row_compressor, changed_groups); } void row_compressor_reset(RowCompressor *row_compressor) { row_compressor->first_iteration = true; } void row_compressor_close(RowCompressor *row_compressor) { pfree(row_compressor->compressed_is_null); pfree(row_compressor->compressed_values); pfree(row_compressor->per_column); pfree(row_compressor->uncompressed_col_to_compressed_col); FreeTupleDesc(row_compressor->out_desc); } /****************** ** segment_info ** ******************/ SegmentInfo * segment_info_new(Form_pg_attribute column_attr) { TypeCacheEntry *tce = lookup_type_cache(column_attr->atttypid, TYPECACHE_EQ_OPR_FINFO); if (!OidIsValid(tce->eq_opr_finfo.fn_oid)) elog(ERROR, "no equality function for column \"%s\"", NameStr(column_attr->attname)); SegmentInfo *segment_info = palloc(sizeof(*segment_info)); *segment_info = (SegmentInfo){ .typlen = column_attr->attlen, .typ_by_val = column_attr->attbyval, }; fmgr_info_cxt(tce->eq_opr_finfo.fn_oid, &segment_info->eq_fn, CurrentMemoryContext); segment_info->eq_fcinfo = HEAP_FCINFO(2); segment_info->collation = column_attr->attcollation; InitFunctionCallInfoData(*segment_info->eq_fcinfo, &segment_info->eq_fn /*=Flinfo*/, 2 /*=Nargs*/, column_attr->attcollation /*=Collation*/, NULL, /*=Context*/ NULL /*=ResultInfo*/ ); return segment_info; } void segment_info_update(SegmentInfo *segment_info, Datum val, bool is_null) { segment_info->is_null = is_null; if (is_null) segment_info->val = 0; else segment_info->val = datumCopy(val, segment_info->typ_by_val, segment_info->typlen); } bool segment_info_datum_is_in_group(SegmentInfo *segment_info, Datum datum, bool is_null) { Datum data_is_eq; FunctionCallInfo eq_fcinfo; /* if one of the datums is null and the other isn't, we must be in a new group */ if (segment_info->is_null != is_null) return false; /* they're both null */ if (segment_info->is_null) return true; /* neither is null, call the eq function */ eq_fcinfo = segment_info->eq_fcinfo; FC_SET_ARG(eq_fcinfo, 0, segment_info->val); FC_SET_ARG(eq_fcinfo, 1, datum); data_is_eq = FunctionCallInvoke(eq_fcinfo); if (eq_fcinfo->isnull) return false; return DatumGetBool(data_is_eq); } /* * Build a map from compressed attribute numbers to non-compressed attribute * numbers. */ static AttrMap * build_decompress_attrmap(const TupleDesc noncompressed_desc, const TupleDesc compressed_desc, AttrNumber *count_meta_attnum) { AttrMap *attrMap; int outnatts; int innatts; int i; int nextindesc = -1; outnatts = compressed_desc->natts; innatts = noncompressed_desc->natts; attrMap = make_attrmap(outnatts); for (i = 0; i < outnatts; i++) { Form_pg_attribute outatt = TupleDescAttr(compressed_desc, i); char *attname; int j; if (outatt->attisdropped) continue; attname = NameStr(outatt->attname); if (strcmp(attname, COMPRESSION_COLUMN_METADATA_COUNT_NAME) == 0) { *count_meta_attnum = outatt->attnum; /* No point in mapping this attribute since meta columns are not * present in the non-compressed relation and will not be found * below anyway. */ continue; } else if (strncmp(attname, COMPRESSION_COLUMN_METADATA_PREFIX, strlen(COMPRESSION_COLUMN_METADATA_PREFIX)) == 0) { /* We can skip other meta attributes as well */ continue; } for (j = 0; j < innatts; j++) { Form_pg_attribute inatt; nextindesc++; if (nextindesc >= innatts) nextindesc = 0; inatt = TupleDescAttr(noncompressed_desc, nextindesc); if (inatt->attisdropped) continue; if (strcmp(attname, NameStr(inatt->attname)) == 0) { attrMap->attnums[i] = inatt->attnum; break; } } } return attrMap; } BulkWriter bulk_writer_build(Relation out_rel, int insert_options) { BulkWriter writer = { .out_rel = out_rel, .indexstate = CatalogOpenIndexes(out_rel), .mycid = GetCurrentCommandId(true), .bistate = GetBulkInsertState(), .estate = CreateExecutorState(), .insert_options = insert_options, }; return writer; } BulkWriter * bulk_writer_alloc(Relation out_rel, int insert_options) { BulkWriter *writer = palloc(sizeof(BulkWriter)); writer->out_rel = out_rel; writer->indexstate = CatalogOpenIndexes(out_rel); writer->mycid = GetCurrentCommandId(true); writer->bistate = GetBulkInsertState(); writer->estate = CreateExecutorState(); writer->insert_options = insert_options; return writer; } void bulk_writer_close(BulkWriter *writer) { FreeBulkInsertState(writer->bistate); if (writer->indexstate) CatalogCloseIndexes(writer->indexstate); FreeExecutorState(writer->estate); } /********************** ** decompress_chunk ** **********************/ RowDecompressor build_decompressor(const TupleDesc in_desc, const TupleDesc out_desc) { AttrNumber count_meta_attnum = InvalidAttrNumber; AttrMap *attrmap = build_decompress_attrmap(out_desc, in_desc, &count_meta_attnum); Assert(AttributeNumberIsValid(count_meta_attnum)); RowDecompressor decompressor = { .count_compressed_attindex = AttrNumberGetAttrOffset(count_meta_attnum), .in_desc = CreateTupleDescCopyConstr(in_desc), .out_desc = CreateTupleDescCopyConstr(out_desc), .compressed_datums = palloc(sizeof(Datum) * in_desc->natts), .compressed_is_nulls = palloc(sizeof(bool) * in_desc->natts), /* cache memory used to store the decompressed datums/is_null for form_tuple */ .decompressed_datums = palloc(sizeof(Datum) * out_desc->natts), .decompressed_is_nulls = palloc(sizeof(bool) * out_desc->natts), .per_compressed_row_ctx = AllocSetContextCreate(CurrentMemoryContext, "decompress chunk per-compressed row", ALLOCSET_DEFAULT_SIZES), .decompressed_slots = (TupleTableSlot **) palloc0(sizeof(void *) * TARGET_COMPRESSED_BATCH_SIZE), .attrmap = attrmap, }; create_per_compressed_column(&decompressor); /* * We need to make sure decompressed_is_nulls is in a defined state. While this * will get written for normal columns it will not get written for dropped columns * since dropped columns don't exist in the compressed chunk so we initialize * with true here. */ memset(decompressor.decompressed_is_nulls, true, out_desc->natts); detoaster_init(&decompressor.detoaster, CurrentMemoryContext); return decompressor; } void row_decompressor_reset(RowDecompressor *decompressor) { MemoryContextReset(decompressor->per_compressed_row_ctx); decompressor->unprocessed_tuples = 0; decompressor->batches_decompressed = 0; decompressor->tuples_decompressed = 0; } void row_decompressor_close(RowDecompressor *decompressor) { MemoryContextDelete(decompressor->per_compressed_row_ctx); detoaster_close(&decompressor->detoaster); free_attrmap(decompressor->attrmap); FreeTupleDesc(decompressor->in_desc); FreeTupleDesc(decompressor->out_desc); pfree(decompressor->compressed_datums); pfree(decompressor->compressed_is_nulls); pfree(decompressor->decompressed_datums); pfree(decompressor->decompressed_is_nulls); pfree(decompressor->decompressed_slots); pfree(decompressor->per_compressed_cols); } void decompress_chunk(Oid in_table, Oid out_table) { /* * Locks are taken in the order uncompressed table then compressed table * for consistency with compress_chunk. * We are _just_ INSERTing into the out_table so in principle we could take * a RowExclusive lock, and let other operations read and write this table * as we work. However, we currently compress each table as a oneshot, so * we're taking the stricter lock to prevent accidents. * We want to prevent other decompressors from decompressing this table, * and we want to prevent INSERTs or UPDATEs which could mess up our decompression. * We may as well allow readers to keep reading the compressed data while * we are decompressing, so we only take an ExclusiveLock instead of AccessExclusive. */ Relation out_rel = table_open(out_table, ExclusiveLock); Relation in_rel = table_open(in_table, ExclusiveLock); int64 nrows_processed = 0; PushActiveSnapshot(GetLatestSnapshot()); BulkWriter writer = bulk_writer_build(out_rel, 0); RowDecompressor decompressor = build_decompressor(RelationGetDescr(in_rel), RelationGetDescr(out_rel)); TupleTableSlot *slot = table_slot_create(in_rel, NULL); TableScanDesc scan = table_beginscan(in_rel, GetActiveSnapshot(), 0, (ScanKey) NULL); int64 report_reltuples = calculate_reltuples_to_report(in_rel->rd_rel->reltuples); while (table_scan_getnextslot(scan, ForwardScanDirection, slot)) { bool should_free; HeapTuple tuple = ExecFetchSlotHeapTuple(slot, false, &should_free); heap_deform_tuple(tuple, decompressor.in_desc, decompressor.compressed_datums, decompressor.compressed_is_nulls); if (should_free) heap_freetuple(tuple); row_decompressor_decompress_row_to_table(&decompressor, &writer); if ((++nrows_processed % report_reltuples) == 0) elog(DEBUG2, "decompressed " INT64_FORMAT " rows from \"%s\"", nrows_processed, RelationGetRelationName(in_rel)); } elog(DEBUG1, "finished decompressing " INT64_FORMAT " rows from \"%s\"", nrows_processed, RelationGetRelationName(in_rel)); table_endscan(scan); ExecDropSingleTupleTableSlot(slot); row_decompressor_close(&decompressor); bulk_writer_close(&writer); table_close(out_rel, NoLock); table_close(in_rel, NoLock); PopActiveSnapshot(); } static void create_per_compressed_column(RowDecompressor *decompressor) { Oid compressed_data_type_oid = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; Assert(OidIsValid(compressed_data_type_oid)); decompressor->per_compressed_cols = palloc(sizeof(*decompressor->per_compressed_cols) * decompressor->in_desc->natts); Assert(OidIsValid(compressed_data_type_oid)); for (int col = 0; col < decompressor->in_desc->natts; col++) { Oid decompressed_type; bool is_compressed; int16 decompressed_column_offset; PerCompressedColumn *per_compressed_col = &decompressor->per_compressed_cols[col]; Form_pg_attribute compressed_attr = TupleDescAttr(decompressor->in_desc, col); char *col_name = NameStr(compressed_attr->attname); /* find the mapping from compressed column to uncompressed column, setting * the index of columns that don't have an uncompressed version * (such as metadata) to -1 * Assumption: column names are the same on compressed and * uncompressed chunk. */ AttrNumber decompressed_colnum = decompressor->attrmap->attnums[col]; if (!AttributeNumberIsValid(decompressed_colnum)) { *per_compressed_col = (PerCompressedColumn){ .decompressed_column_offset = -1, }; continue; } decompressed_column_offset = AttrNumberGetAttrOffset(decompressed_colnum); decompressed_type = TupleDescAttr(decompressor->out_desc, decompressed_column_offset)->atttypid; /* determine if the data is compressed or not */ is_compressed = compressed_attr->atttypid == compressed_data_type_oid; if (!is_compressed && compressed_attr->atttypid != decompressed_type) elog(ERROR, "compressed table type '%s' does not match decompressed table type '%s' for " "segment-by column \"%s\"", format_type_be(compressed_attr->atttypid), format_type_be(decompressed_type), col_name); *per_compressed_col = (PerCompressedColumn){ .decompressed_column_offset = decompressed_column_offset, .is_compressed = is_compressed, .decompressed_type = decompressed_type, }; } } static void init_iterator(RowDecompressor *decompressor, CompressedDataHeader *header, int input_column) { Assert(decompressor->in_desc->natts > input_column); PerCompressedColumn *column_info = &decompressor->per_compressed_cols[input_column]; /* Special compression block with the NULL compression algorithm, * tells that all values in the compressed block are NULLs. */ if (header->compression_algorithm == COMPRESSION_ALGORITHM_NULL) { column_info->iterator = NULL; decompressor->compressed_is_nulls[input_column] = true; decompressor->decompressed_is_nulls[column_info->decompressed_column_offset] = true; return; } column_info->iterator = definitions[header->compression_algorithm] .iterator_init_forward(PointerGetDatum(header), column_info->decompressed_type); } static void init_batch(RowDecompressor *decompressor, AttrNumber *attnos, int num_attnos) { /* * Set segmentbys and compressed columns with default value. */ for (int input_column = 0; input_column < decompressor->in_desc->natts; input_column++) { PerCompressedColumn *column_info = &decompressor->per_compressed_cols[input_column]; const int output_index = column_info->decompressed_column_offset; /* Metadata column. */ if (output_index < 0) { continue; } /* Segmentby column. */ if (!column_info->is_compressed) { decompressor->decompressed_datums[output_index] = decompressor->compressed_datums[input_column]; decompressor->decompressed_is_nulls[output_index] = decompressor->compressed_is_nulls[input_column]; continue; } /* Compressed column with default value. */ if (decompressor->compressed_is_nulls[input_column]) { column_info->iterator = NULL; decompressor->decompressed_datums[output_index] = getmissingattr(decompressor->out_desc, output_index + 1, &decompressor->decompressed_is_nulls[output_index]); continue; } /* Only initialize required columns if specified. */ bool found = num_attnos == 0; for (int i = 0; i < num_attnos; i++) { if (output_index == AttrNumberGetAttrOffset(attnos[i])) { found = true; break; } } if (!found) { column_info->iterator = NULL; continue; } /* Normal compressed column. */ Datum compressed_datum = PointerGetDatum( detoaster_detoast_attr_copy((struct varlena *) DatumGetPointer( decompressor->compressed_datums[input_column]), &decompressor->detoaster, CurrentMemoryContext)); CompressedDataHeader *header = get_compressed_data_header(compressed_datum); init_iterator(decompressor, header, input_column); } } /* * Decompresses the current compressed batch into decompressed_slots, and returns * the number of rows in batch. */ int decompress_batch(RowDecompressor *decompressor) { if (decompressor->unprocessed_tuples) return decompressor->unprocessed_tuples; MemoryContext old_ctx = MemoryContextSwitchTo(decompressor->per_compressed_row_ctx); init_batch(decompressor, NULL, 0); /* * Set the number of batch rows from count metadata column. */ const int n_batch_rows = DatumGetInt32(decompressor->compressed_datums[decompressor->count_compressed_attindex]); CheckCompressedData(n_batch_rows > 0); CheckCompressedData(n_batch_rows <= GLOBAL_MAX_ROWS_PER_COMPRESSION); /* * Decompress all compressed columns for each row of the batch. */ for (int current_row = 0; current_row < n_batch_rows; current_row++) { for (int col = 0; col < decompressor->in_desc->natts; col++) { PerCompressedColumn *column_info = &decompressor->per_compressed_cols[col]; if (column_info->iterator == NULL) { continue; } Assert(column_info->is_compressed); const int output_index = column_info->decompressed_column_offset; const DecompressResult value = column_info->iterator->try_next(column_info->iterator); CheckCompressedData(!value.is_done); decompressor->decompressed_datums[output_index] = value.val; decompressor->decompressed_is_nulls[output_index] = value.is_null; } /* * Form the heap tuple for this decompressed rows and save it for later * processing. */ if (decompressor->decompressed_slots[current_row] == NULL) { MemoryContextSwitchTo(old_ctx); decompressor->decompressed_slots[current_row] = MakeSingleTupleTableSlot(decompressor->out_desc, &TTSOpsHeapTuple); MemoryContextSwitchTo(decompressor->per_compressed_row_ctx); } else { ExecClearTuple(decompressor->decompressed_slots[current_row]); } TupleTableSlot *decompressed_slot = decompressor->decompressed_slots[current_row]; HeapTuple decompressed_tuple = heap_form_tuple(decompressor->out_desc, decompressor->decompressed_datums, decompressor->decompressed_is_nulls); ExecStoreHeapTuple(decompressed_tuple, decompressed_slot, /* should_free = */ false); } /* * Verify that all other columns have ended, i.e. their length is consistent * with the count metadata column. */ for (int col = 0; col < decompressor->in_desc->natts; col++) { PerCompressedColumn *column_info = &decompressor->per_compressed_cols[col]; if (column_info->iterator == NULL) { continue; } Assert(column_info->is_compressed); const DecompressResult value = column_info->iterator->try_next(column_info->iterator); CheckCompressedData(value.is_done); } MemoryContextSwitchTo(old_ctx); decompressor->batches_decompressed++; decompressor->tuples_decompressed += n_batch_rows; decompressor->unprocessed_tuples = n_batch_rows; return n_batch_rows; } /* * Decompresses a single row from current compressed batch * into decompressed_values and decompressed_is_nulls based on the * attnos provided. * * Returns true if the row was decompressed or false if it finished the batch. */ bool decompress_batch_next_row(RowDecompressor *decompressor, AttrNumber *attnos, int num_attnos) { MemoryContext old_ctx = MemoryContextSwitchTo(decompressor->per_compressed_row_ctx); if (decompressor->unprocessed_tuples > 0) { decompressor->unprocessed_tuples--; if (decompressor->unprocessed_tuples == 0) { MemoryContextSwitchTo(old_ctx); return false; } } else { decompressor->batches_decompressed++; init_batch(decompressor, attnos, num_attnos); /* * Set the number of batch rows from count metadata column. */ decompressor->unprocessed_tuples = DatumGetInt32(decompressor->compressed_datums[decompressor->count_compressed_attindex]); CheckCompressedData(decompressor->unprocessed_tuples > 0); CheckCompressedData(decompressor->unprocessed_tuples <= GLOBAL_MAX_ROWS_PER_COMPRESSION); } for (int col = 0; col < decompressor->in_desc->natts; col++) { PerCompressedColumn *column_info = &decompressor->per_compressed_cols[col]; if (column_info->iterator == NULL) { continue; } Assert(column_info->is_compressed); const int output_index = column_info->decompressed_column_offset; const DecompressResult value = column_info->iterator->try_next(column_info->iterator); Assert(!value.is_done); decompressor->decompressed_datums[output_index] = value.val; decompressor->decompressed_is_nulls[output_index] = value.is_null; } decompressor->tuples_decompressed++; MemoryContextSwitchTo(old_ctx); return true; } /* Decompress single column using vectorized decompression */ ArrowArray * decompress_single_column(RowDecompressor *decompressor, AttrNumber attno, bool *single_value) { int16 target_col = -1; PerCompressedColumn *column_info = NULL; for (int col = 0; col < decompressor->in_desc->natts; col++) { column_info = &decompressor->per_compressed_cols[col]; if (!column_info->is_compressed) continue; if (column_info->decompressed_column_offset == AttrNumberGetAttrOffset(attno)) { target_col = col; break; } } Assert(column_info && target_col > -1); if (decompressor->compressed_is_nulls[target_col]) { /* Compressed column has a default value, handle it by generating * a single-value ArrowArray based on the default value. This will have to * be handled specially because of the assumption that the whole row has * this default value. */ *single_value = true; bool isnull; Datum default_datum = getmissingattr(decompressor->out_desc, attno, &isnull); return make_single_value_arrow(column_info->decompressed_type, default_datum, isnull); } *single_value = false; Datum compressed_datum = PointerGetDatum( detoaster_detoast_attr_copy((struct varlena *) DatumGetPointer( decompressor->compressed_datums[target_col]), &decompressor->detoaster, CurrentMemoryContext)); CompressedDataHeader *header = get_compressed_data_header(compressed_datum); /* Handle NULL compression algorithm */ if (header->compression_algorithm == COMPRESSION_ALGORITHM_NULL) { *single_value = true; return make_single_value_arrow(column_info->decompressed_type, (Datum) NULL, true); } DecompressAllFunction decompress_all = tsl_get_decompress_all_function(header->compression_algorithm, column_info->decompressed_type); Assert(decompress_all); return decompress_all(compressed_datum, column_info->decompressed_type, decompressor->per_compressed_row_ctx); } int row_decompressor_decompress_row_to_table(RowDecompressor *decompressor, BulkWriter *writer) { const int n_batch_rows = decompress_batch(decompressor); MemoryContext old_ctx = MemoryContextSwitchTo(decompressor->per_compressed_row_ctx); /* Insert all decompressed rows into table using the bulk insert API. */ table_multi_insert(writer->out_rel, decompressor->decompressed_slots, n_batch_rows, writer->mycid, /* options = */ 0, writer->bistate); /* * Now, update the indexes. If we have several indexes, we want to first * insert the entire batch into one index, then into another, and so on. * Working with one index at a time gives better data access locality, * which reduces the load on shared buffers cache. * The normal Postgres code inserts each row into all indexes, so to do it * the other way around, we create a temporary ResultRelInfo that only * references one index. Then we loop over indexes, and for each index we * set it to this temporary ResultRelInfo, and insert all rows into this * single index. */ if (writer->indexstate->ri_NumIndices > 0) { ResultRelInfo indexstate_copy = *writer->indexstate; Relation single_index_relation; IndexInfo *single_index_info; indexstate_copy.ri_NumIndices = 1; indexstate_copy.ri_IndexRelationDescs = &single_index_relation; indexstate_copy.ri_IndexRelationInfo = &single_index_info; for (int i = 0; i < writer->indexstate->ri_NumIndices; i++) { single_index_relation = writer->indexstate->ri_IndexRelationDescs[i]; single_index_info = writer->indexstate->ri_IndexRelationInfo[i]; for (int row = 0; row < n_batch_rows; row++) { TupleTableSlot *decompressed_slot = decompressor->decompressed_slots[row]; EState *estate = writer->estate; ExprContext *econtext = GetPerTupleExprContext(estate); /* Arrange for econtext's scan tuple to be the tuple under test */ econtext->ecxt_scantuple = decompressed_slot; ExecInsertIndexTuplesCompat(&indexstate_copy, decompressed_slot, estate, false, false, NULL, NIL, false); } } } MemoryContextSwitchTo(old_ctx); row_decompressor_reset(decompressor); return n_batch_rows; } void row_decompressor_decompress_row_to_tuplesort(RowDecompressor *decompressor, Tuplesortstate *tuplesortstate) { const int n_batch_rows = decompress_batch(decompressor); MemoryContext old_ctx = MemoryContextSwitchTo(decompressor->per_compressed_row_ctx); for (int i = 0; i < n_batch_rows; i++) { tuplesort_puttupleslot(tuplesortstate, decompressor->decompressed_slots[i]); } MemoryContextSwitchTo(old_ctx); row_decompressor_reset(decompressor); } /********************/ /*** SQL Bindings ***/ /********************/ Datum tsl_compressed_data_decompress_forward(PG_FUNCTION_ARGS) { CompressedDataHeader *header; FuncCallContext *funcctx; MemoryContext oldcontext; DecompressionIterator *iter; DecompressResult res; if (PG_ARGISNULL(0)) PG_RETURN_NULL(); if (SRF_IS_FIRSTCALL()) { funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); header = get_compressed_data_header(PG_GETARG_DATUM(0)); iter = definitions[header->compression_algorithm] .iterator_init_forward(PointerGetDatum(header), get_fn_expr_argtype(fcinfo->flinfo, 1)); funcctx->user_fctx = iter; MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); iter = funcctx->user_fctx; res = iter->try_next(iter); if (res.is_done) SRF_RETURN_DONE(funcctx); if (res.is_null) SRF_RETURN_NEXT_NULL(funcctx); SRF_RETURN_NEXT(funcctx, res.val); } Datum tsl_compressed_data_decompress_reverse(PG_FUNCTION_ARGS) { CompressedDataHeader *header; FuncCallContext *funcctx; MemoryContext oldcontext; DecompressionIterator *iter; DecompressResult res; if (PG_ARGISNULL(0)) PG_RETURN_NULL(); if (SRF_IS_FIRSTCALL()) { funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); header = get_compressed_data_header(PG_GETARG_DATUM(0)); iter = definitions[header->compression_algorithm] .iterator_init_reverse(PointerGetDatum(header), get_fn_expr_argtype(fcinfo->flinfo, 1)); funcctx->user_fctx = iter; MemoryContextSwitchTo(oldcontext); } funcctx = SRF_PERCALL_SETUP(); iter = funcctx->user_fctx; res = iter->try_next(iter); if (res.is_done) SRF_RETURN_DONE(funcctx); if (res.is_null) SRF_RETURN_NEXT_NULL(funcctx); SRF_RETURN_NEXT(funcctx, res.val); ; } Datum tsl_compressed_data_send(PG_FUNCTION_ARGS) { CompressedDataHeader *header = get_compressed_data_header(PG_GETARG_DATUM(0)); StringInfoData buf; pq_begintypsend(&buf); pq_sendbyte(&buf, header->compression_algorithm); if (header->compression_algorithm != COMPRESSION_ALGORITHM_NULL) { definitions[header->compression_algorithm].compressed_data_send(header, &buf); } PG_RETURN_BYTEA_P(pq_endtypsend(&buf)); } Datum tsl_compressed_data_recv(PG_FUNCTION_ARGS) { StringInfo buf = (StringInfo) PG_GETARG_POINTER(0); CompressedDataHeader header = { .vl_len_ = { 0 } }; header.compression_algorithm = pq_getmsgbyte(buf); if (header.compression_algorithm >= _END_COMPRESSION_ALGORITHMS) elog(ERROR, "invalid compression algorithm %d", header.compression_algorithm); return definitions[header.compression_algorithm].compressed_data_recv(buf); } extern Datum tsl_compressed_data_in(PG_FUNCTION_ARGS) { const char *input = PG_GETARG_CSTRING(0); size_t input_len = strlen(input); int decoded_len; #if PG18_GE /* With version 18 pointer type changed to uint8 * for better readability. * * https://github.com/postgres/postgres/commit/b28c59a6 */ uint8 *decoded; #else char *decoded; #endif StringInfoData data; Datum result; if (input_len > PG_INT32_MAX) elog(ERROR, "input too long"); decoded_len = pg_b64_dec_len(input_len); decoded = palloc(decoded_len + 1); decoded_len = pg_b64_decode(input, input_len, decoded, decoded_len); if (decoded_len < 0) elog(ERROR, "could not decode base64-encoded compressed data"); decoded[decoded_len] = '\0'; data = (StringInfoData){ .data = (char *) decoded, .len = decoded_len, .maxlen = decoded_len, }; result = DirectFunctionCall1(tsl_compressed_data_recv, PointerGetDatum(&data)); PG_RETURN_DATUM(result); } extern Datum tsl_compressed_data_out(PG_FUNCTION_ARGS) { Datum bytes_data = DirectFunctionCall1(tsl_compressed_data_send, PG_GETARG_DATUM(0)); bytea *bytes = DatumGetByteaP(bytes_data); int raw_len = VARSIZE_ANY_EXHDR(bytes); #if PG18_GE /* With version 18 pointer type changed to uint8 * for better readability. * * https://github.com/postgres/postgres/commit/b28c59a6 */ const uint8 *raw_data = (uint8 *) VARDATA(bytes); #else const char *raw_data = VARDATA(bytes); #endif int encoded_len = pg_b64_enc_len(raw_len); char *encoded = palloc(encoded_len + 1); encoded_len = pg_b64_encode(raw_data, raw_len, encoded, encoded_len); if (encoded_len < 0) elog(ERROR, "could not base64-encode compressed data"); encoded[encoded_len] = '\0'; PG_RETURN_CSTRING(encoded); } /* create_hypertable record attribute numbers */ enum Anum_compressed_info { Anum_compressed_info_algorithm = 1, Anum_compressed_info_has_nulls, _Anum_compressed_info_max, }; #define Natts_compressed_info (_Anum_compressed_info_max - 1) extern Datum tsl_compressed_data_info(PG_FUNCTION_ARGS) { const CompressedDataHeader *header = get_compressed_data_header(PG_GETARG_DATUM(0)); TupleDesc tupdesc; HeapTuple tuple; bool has_nulls = false; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in " "context that cannot accept type record"))); switch (header->compression_algorithm) { case COMPRESSION_ALGORITHM_GORILLA: has_nulls = gorilla_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_DICTIONARY: has_nulls = dictionary_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_DELTADELTA: has_nulls = deltadelta_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_ARRAY: has_nulls = array_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_BOOL: has_nulls = bool_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_NULL: has_nulls = true; break; case COMPRESSION_ALGORITHM_UUID: has_nulls = uuid_compressed_has_nulls(header); break; default: elog(ERROR, "unknown compression algorithm %d", header->compression_algorithm); break; } tupdesc = BlessTupleDesc(tupdesc); Datum values[Natts_compressed_info]; bool nulls[Natts_compressed_info] = { false }; values[AttrNumberGetAttrOffset(Anum_compressed_info_algorithm)] = NameGetDatum(compression_get_algorithm_name(header->compression_algorithm)); values[AttrNumberGetAttrOffset(Anum_compressed_info_has_nulls)] = BoolGetDatum(has_nulls); tuple = heap_form_tuple(tupdesc, values, nulls); return HeapTupleGetDatum(tuple); } extern Datum tsl_compressed_data_has_nulls(PG_FUNCTION_ARGS) { const CompressedDataHeader *header = get_compressed_data_header(PG_GETARG_DATUM(0)); bool has_nulls = false; switch (header->compression_algorithm) { case COMPRESSION_ALGORITHM_GORILLA: has_nulls = gorilla_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_DICTIONARY: has_nulls = dictionary_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_DELTADELTA: has_nulls = deltadelta_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_ARRAY: has_nulls = array_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_BOOL: has_nulls = bool_compressed_has_nulls(header); break; case COMPRESSION_ALGORITHM_NULL: has_nulls = true; break; case COMPRESSION_ALGORITHM_UUID: has_nulls = uuid_compressed_has_nulls(header); break; default: elog(ERROR, "unknown compression algorithm %d", header->compression_algorithm); break; } return BoolGetDatum(has_nulls); } extern CompressionStorage compression_get_toast_storage(CompressionAlgorithm algorithm) { if (algorithm == _INVALID_COMPRESSION_ALGORITHM || algorithm >= _END_COMPRESSION_ALGORITHMS) elog(ERROR, "invalid compression algorithm %d", algorithm); return definitions[algorithm].compressed_data_storage; } /* * Return a default compression algorithm suitable * for the type. The actual algorithm used for a * type might be different though since the compressor * can deviate from the default. The actual algorithm * used for a specific batch can only be determined * by reading the batch header. */ extern CompressionAlgorithm compression_get_default_algorithm(Oid typeoid) { switch (typeoid) { case INT4OID: case INT2OID: case INT8OID: case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: return COMPRESSION_ALGORITHM_DELTADELTA; case FLOAT4OID: case FLOAT8OID: return COMPRESSION_ALGORITHM_GORILLA; case NUMERICOID: return COMPRESSION_ALGORITHM_ARRAY; case BOOLOID: if (ts_guc_enable_bool_compression) return COMPRESSION_ALGORITHM_BOOL; else return COMPRESSION_ALGORITHM_ARRAY; case UUIDOID: if (ts_guc_enable_uuid_compression) return COMPRESSION_ALGORITHM_UUID; else return COMPRESSION_ALGORITHM_DICTIONARY; default: { /* use dictionary if possible, otherwise use array */ TypeCacheEntry *tentry = lookup_type_cache(typeoid, TYPECACHE_EQ_OPR_FINFO | TYPECACHE_HASH_PROC_FINFO); if (tentry->hash_proc_finfo.fn_addr == NULL || tentry->eq_opr_finfo.fn_addr == NULL) return COMPRESSION_ALGORITHM_ARRAY; return COMPRESSION_ALGORITHM_DICTIONARY; } } } const CompressionAlgorithmDefinition * algorithm_definition(CompressionAlgorithm algo) { Assert(algo > 0 && algo < _END_COMPRESSION_ALGORITHMS); return &definitions[algo]; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/compression.h������������������������������������������������0000664�0000000�0000000�00000037717�15100345067�0022536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/attnum.h> #include <catalog/indexing.h> #include <executor/tuptable.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <nodes/execnodes.h> #include <utils/relcache.h> typedef struct BulkInsertStateData *BulkInsertState; #include "batch_metadata_builder_minmax.h" #include "hypertable.h" #include "nodes/columnar_scan/detoaster.h" #include "ts_catalog/compression_settings.h" /* * Compressed data starts with a specialized varlen type starting with the usual * varlen header, and followed by a version specifying which compression * algorithm was used. This allows us to share the same code across different * SQL datatypes. Currently we only allow 127 versions, as we may want to use * variable-width integer type in the event we have more than a non-trivial * number of compression algorithms. */ #define CompressedDataHeaderFields \ char vl_len_[4]; \ uint8 compression_algorithm #define TARGET_COMPRESSED_BATCH_SIZE 1000 typedef struct CompressedDataHeader { CompressedDataHeaderFields; } CompressedDataHeader; /* On 32-bit architectures, 64-bit values are boxed when returned as datums. To avoid this overhead we have this type and corresponding iterators for efficiency. The iterators are private to the compression algorithms for now. */ typedef uint64 DecompressDataInternal; typedef struct DecompressResultInternal { DecompressDataInternal val; bool is_null; bool is_done; } DecompressResultInternal; /* This type returns datums and is used as our main interface */ typedef struct DecompressResult { Datum val; bool is_null; bool is_done; } DecompressResult; typedef struct FormData_hypertable ChunkCompressionSettings; typedef struct Compressor Compressor; struct Compressor { void (*append_null)(Compressor *compressord); void (*append_val)(Compressor *compressor, Datum val); bool (*is_full)(Compressor *compressor, Datum val); void *(*finish)(Compressor *data); }; typedef struct ArrowArray ArrowArray; typedef struct DecompressionIterator { uint8 compression_algorithm; bool forward; Oid element_type; DecompressResult (*try_next)(struct DecompressionIterator *); } DecompressionIterator; typedef struct SegmentInfo { Datum val; FmgrInfo eq_fn; FunctionCallInfo eq_fcinfo; int16 typlen; bool is_null; bool typ_by_val; Oid collation; } SegmentInfo; /* this struct holds information about a segmentby column, * and additionally stores the mapping for this column in * the uncompressed chunk. */ typedef struct CompressedSegmentInfo { SegmentInfo *segment_info; int16 decompressed_chunk_offset; } CompressedSegmentInfo; typedef struct PerCompressedColumn { Oid decompressed_type; /* the compressor to use for compressed columns, always NULL for segmenters * only use if is_compressed */ DecompressionIterator *iterator; /* is this a compressed column or a segment-by column */ bool is_compressed; /* * the index in the decompressed table of the data -1, * if the data is metadata not found in the decompressed table */ int16 decompressed_column_offset; } PerCompressedColumn; typedef struct BulkWriter { Relation out_rel; CatalogIndexState indexstate; EState *estate; CommandId mycid; BulkInsertState bistate; int insert_options; /* heap insert options */ } BulkWriter; typedef struct RowDecompressor { PerCompressedColumn *per_compressed_cols; int16 count_compressed_attindex; TupleDesc in_desc; TupleDesc out_desc; Datum *compressed_datums; bool *compressed_is_nulls; Datum *decompressed_datums; bool *decompressed_is_nulls; MemoryContext per_compressed_row_ctx; int64 batches_decompressed; int64 tuples_decompressed; TupleTableSlot **decompressed_slots; int unprocessed_tuples; AttrMap *attrmap; Detoaster detoaster; } RowDecompressor; /* * TOAST_STORAGE_EXTENDED for out of line storage. * TOAST_STORAGE_EXTERNAL for out of line storage + native PG toast compression * used when you want to enable postgres native toast * compression on the output of the compression algorithm. */ typedef enum { TOAST_STORAGE_EXTERNAL, TOAST_STORAGE_EXTENDED } CompressionStorage; typedef DecompressionIterator *(*DecompressionInitializer)(Datum, Oid); typedef ArrowArray *(*DecompressAllFunction)(Datum compressed, Oid element_type, MemoryContext dest_mctx); typedef struct CompressionAlgorithmDefinition { DecompressionInitializer iterator_init_forward; DecompressionInitializer iterator_init_reverse; DecompressAllFunction decompress_all; void (*compressed_data_send)(CompressedDataHeader *, StringInfo); Datum (*compressed_data_recv)(StringInfo); Compressor *(*compressor_for_type)(Oid element_type); CompressionStorage compressed_data_storage; } CompressionAlgorithmDefinition; typedef enum CompressionAlgorithm { /* Not a real algorithm, if this does get used, it's a bug in the code */ _INVALID_COMPRESSION_ALGORITHM = 0, COMPRESSION_ALGORITHM_ARRAY, COMPRESSION_ALGORITHM_DICTIONARY, COMPRESSION_ALGORITHM_GORILLA, COMPRESSION_ALGORITHM_DELTADELTA, COMPRESSION_ALGORITHM_BOOL, COMPRESSION_ALGORITHM_NULL, COMPRESSION_ALGORITHM_UUID, /* When adding an algorithm also add a static assert statement below */ /* end of real values */ _END_COMPRESSION_ALGORITHMS, _MAX_NUM_COMPRESSION_ALGORITHMS = 128, } CompressionAlgorithm; typedef struct CompressionStats { int64 rowcnt_pre_compression; int64 rowcnt_post_compression; int64 rowcnt_frozen; } CompressionStats; typedef struct PerColumn { /* the compressor to use for regular columns, NULL for segmenters */ Compressor *compressor; /* * Information on the metadata we'll store for this column (currently only min/max). * Only used for order-by columns right now, will be {-1, NULL} for others. */ BatchMetadataBuilder *metadata_builder; /* segment info; only used if compressor is NULL */ SegmentInfo *segment_info; int16 segmentby_column_index; } PerColumn; typedef struct RowCompressor { /* memory context reset per-row is stored */ MemoryContext per_row_ctx; /* The descriptor of the uncompressed tuple we're processing */ TupleDesc in_desc; /* The descriptor of the compressed tuple we're generating */ TupleDesc out_desc; /* in theory we could have more input columns than outputted ones, so we store the number of inputs/compressors separately */ int n_input_columns; /* info about each column */ struct PerColumn *per_column; /* do we have to check if compressors can accept more data */ bool needs_fullness_check; /* the order of columns in the compressed data need not match the order in the * uncompressed. This array maps each attribute offset in the uncompressed * data to the corresponding one in the compressed */ int16 *uncompressed_col_to_compressed_col; int16 count_metadata_column_offset; int16 sequence_num_metadata_column_offset; /* the number of uncompressed rows compressed into the current compressed row */ uint32 rows_compressed_into_current_value; /* a unique monotonically increasing (according to order by) id for each compressed row */ int32 sequence_num; /* cached arrays used to build the HeapTuple */ Datum *compressed_values; bool *compressed_is_null; int64 rowcnt_pre_compression; int64 num_compressed_rows; /* flag for checking if we are working on the first tuple */ bool first_iteration; /* Callback called on every flush. The ntuples argument is the number of * tuples flushed. Typically used for progress reporting. */ void (*on_flush)(struct RowCompressor *rowcompress, uint64 ntuples); Tuplesortstate *sort_state; int64 tuples_to_sort; /* number of tuples to sort with tuplesort */ } RowCompressor; /* * BatchFilter is used for filtering batches before decompressing. * The columns will either be segmentby columns or the corresponding * metadata columns of orderby columns. */ typedef struct BatchFilter { /* Column which we use for filtering */ NameData column_name; /* Filter operation used */ StrategyNumber strategy; /* Collation to be used by the operator */ Oid collation; /* Operator code used */ RegProcedure opcode; /* Value to compare with */ Const *value; /* IS NULL or IS NOT NULL */ bool is_null_check; bool is_null; bool is_array_op; } BatchFilter; extern Datum tsl_compressed_data_decompress_forward(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_decompress_reverse(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_send(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_recv(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_in(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_out(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_info(PG_FUNCTION_ARGS); extern Datum tsl_compressed_data_has_nulls(PG_FUNCTION_ARGS); static void pg_attribute_unused() assert_num_compression_algorithms_sane(void) { /* make sure not too many compression algorithms */ StaticAssertStmt(_END_COMPRESSION_ALGORITHMS <= _MAX_NUM_COMPRESSION_ALGORITHMS, "Too many compression algorithms, make sure a decision on variable-length " "version field has been made."); /* existing indexes that MUST NEVER CHANGE */ StaticAssertStmt(COMPRESSION_ALGORITHM_ARRAY == 1, "algorithm index has changed"); StaticAssertStmt(COMPRESSION_ALGORITHM_DICTIONARY == 2, "algorithm index has changed"); StaticAssertStmt(COMPRESSION_ALGORITHM_GORILLA == 3, "algorithm index has changed"); StaticAssertStmt(COMPRESSION_ALGORITHM_DELTADELTA == 4, "algorithm index has changed"); StaticAssertStmt(COMPRESSION_ALGORITHM_BOOL == 5, "algorithm index has changed"); StaticAssertStmt(COMPRESSION_ALGORITHM_NULL == 6, "algorithm index has changed"); StaticAssertStmt(COMPRESSION_ALGORITHM_UUID == 7, "algorithm index has changed"); /* * This should change when adding a new algorithm after adding the new * algorithm to the assert list above. This statement prevents adding a * new algorithm without updating the asserts above */ StaticAssertStmt(_END_COMPRESSION_ALGORITHMS == 8, "number of algorithms have changed, the asserts should be updated"); } extern Name compression_get_algorithm_name(CompressionAlgorithm alg); extern CompressionStorage compression_get_toast_storage(CompressionAlgorithm algo); extern CompressionAlgorithm compression_get_default_algorithm(Oid typeoid); extern CompressionStats compress_chunk(Oid in_table, Oid out_table, int insert_options); extern void decompress_chunk(Oid in_table, Oid out_table); extern DecompressionIterator *(*tsl_get_decompression_iterator_init( CompressionAlgorithm algorithm, bool reverse))(Datum, Oid element_type); extern DecompressAllFunction tsl_get_decompress_all_function(CompressionAlgorithm algorithm, Oid type); typedef struct Chunk Chunk; typedef struct ChunkInsertState ChunkInsertState; extern void decompress_batches_for_insert(ChunkInsertState *cis, TupleTableSlot *slot); extern void init_decompress_state_for_insert(ChunkInsertState *cis, TupleTableSlot *slot); typedef struct ModifyHypertableState ModifyHypertableState; extern bool decompress_target_segments(ModifyHypertableState *ht_state); /* CompressSingleRowState methods */ struct CompressSingleRowState; typedef struct CompressSingleRowState CompressSingleRowState; extern CompressSingleRowState *compress_row_init(int srcht_id, Relation in_rel, Relation out_rel); extern SegmentInfo *segment_info_new(Form_pg_attribute column_attr); extern bool segment_info_datum_is_in_group(SegmentInfo *segment_info, Datum datum, bool is_null); extern TupleTableSlot *compress_row_exec(CompressSingleRowState *cr, TupleTableSlot *slot); extern void compress_row_end(CompressSingleRowState *cr); extern void compress_row_destroy(CompressSingleRowState *cr); extern int row_decompressor_decompress_row_to_table(RowDecompressor *row_decompressor, BulkWriter *writer); extern void row_decompressor_decompress_row_to_tuplesort(RowDecompressor *row_decompressor, Tuplesortstate *tuplesortstate); extern void compress_chunk_populate_sort_info_for_column(const CompressionSettings *settings, Oid table, const char *attname, AttrNumber *att_nums, Oid *sort_operator, Oid *collation, bool *nulls_first); extern Tuplesortstate *compression_create_tuplesort_state(CompressionSettings *settings, Relation rel); extern void row_compressor_init(RowCompressor *row_compressor, const CompressionSettings *settings, const TupleDesc noncompressed_tupdesc, const TupleDesc compressed_tupdesc); RowCompressor *row_compressor_alloc(void); extern RowCompressor *tsl_compressor_init(Relation in_rel, BulkWriter **bulk_writer, bool sort); extern void tsl_compressor_add_slot(RowCompressor *compressor, BulkWriter *bulk_writer, TupleTableSlot *slot); extern void tsl_compressor_flush(RowCompressor *compressor, BulkWriter *bulk_writer); extern void tsl_compressor_free(RowCompressor *compressor, BulkWriter *bulk_writer); extern void row_compressor_reset(RowCompressor *row_compressor); extern void row_compressor_close(RowCompressor *row_compressor); extern HeapTuple row_compressor_build_tuple(RowCompressor *row_compressor); extern void row_compressor_clear_batch(RowCompressor *row_compressor, bool changed_groups); extern void row_compressor_append_ordered_slot(RowCompressor *row_compressor, TupleTableSlot *slot); extern void row_compressor_append_sorted_rows(RowCompressor *row_compressor, Tuplesortstate *sorted_rel, Relation in_rel, BulkWriter *writer); extern Oid get_compressed_chunk_index(ResultRelInfo *resultRelInfo, const CompressionSettings *settings); extern void segment_info_update(SegmentInfo *segment_info, Datum val, bool is_null); extern BulkWriter bulk_writer_build(Relation out_rel, int insert_options); extern BulkWriter *bulk_writer_alloc(Relation out_rel, int insert_options); extern void bulk_writer_close(BulkWriter *writer); extern RowDecompressor build_decompressor(const TupleDesc in_desc, const TupleDesc out_desc); extern void row_decompressor_reset(RowDecompressor *decompressor); extern void row_decompressor_close(RowDecompressor *decompressor); extern enum CompressionAlgorithms compress_get_default_algorithm(Oid typeoid); extern int decompress_batch(RowDecompressor *decompressor); extern bool decompress_batch_next_row(RowDecompressor *decompressor, AttrNumber *attnos, int num_attnos); extern ArrowArray *decompress_single_column(RowDecompressor *decompressor, AttrNumber attno, bool *single_value); /* * A convenience macro to throw an error about the corrupted compressed data, if * the argument is false. When fuzzing is enabled, we don't show the message not * to pollute the logs. */ #ifndef TS_COMPRESSION_FUZZING #define CORRUPT_DATA_MESSAGE(X) \ (errmsg("the compressed data is corrupt"), errdetail("%s", X), errcode(ERRCODE_DATA_CORRUPTED)) #else #define CORRUPT_DATA_MESSAGE(X) (errcode(ERRCODE_DATA_CORRUPTED)) #endif #define CheckCompressedData(X) \ if (unlikely(!(X))) \ ereport(ERROR, CORRUPT_DATA_MESSAGE(#X)) inline static void * consumeCompressedData(StringInfo si, int bytes) { CheckCompressedData(bytes >= 0); CheckCompressedData(si->cursor + bytes >= si->cursor); /* Check for overflow. */ CheckCompressedData(si->cursor + bytes <= si->len); void *result = si->data + si->cursor; si->cursor += bytes; return result; } /* * We use this limit for sanity checks in case the compressed data is corrupt. */ #define GLOBAL_MAX_ROWS_PER_COMPRESSION INT16_MAX const CompressionAlgorithmDefinition *algorithm_definition(CompressionAlgorithm algo); struct decompress_batches_stats { int64 batches_deleted; int64 batches_filtered; int64 batches_decompressed; int64 tuples_decompressed; int64 tuples_deleted; }; �������������������������������������������������timescaledb-2.23.0/tsl/src/compression/compression_dml.c��������������������������������������������0000664�0000000�0000000�00000151511�15100345067�0023352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/genam.h> #include <access/sdir.h> #include <access/tableam.h> #include <access/valid.h> #include <catalog/pg_am.h> #include <nodes/nodeFuncs.h> #include <optimizer/optimizer.h> #include <parser/parse_coerce.h> #include <parser/parse_relation.h> #include <parser/parsetree.h> #include <utils/lsyscache.h> #include <utils/relcache.h> #include <utils/snapmgr.h> #include <utils/typcache.h> #include <compat/compat.h> #include <chunk_insert_state.h> #include <compression/arrow_c_data_interface.h> #include <compression/compression.h> #include <compression/compression_dml.h> #include <compression/create.h> #include <compression/wal_utils.h> #include <expression_utils.h> #include <indexing.h> #include <nodes/columnar_scan/vector_dict.h> #include <nodes/columnar_scan/vector_predicates.h> #include <nodes/modify_hypertable.h> #include <ts_catalog/array_utils.h> typedef BatchQualSummary(BatchMatcher)(RowDecompressor *decompressor, ScanKeyData *scankeys, int num_scankeys, tuple_filtering_constraints *constraints, bool check_full_match, bool *skip_current_tuple); static struct decompress_batches_stats decompress_batches_scan(Relation in_rel, Relation out_rel, Relation index_rel, Snapshot snapshot, ScanKeyData *index_scankeys, int num_index_scankeys, ScanKeyData *heap_scankeys, int num_heap_scankeys, ScanKeyData *mem_scankeys, int num_mem_scankeys, tuple_filtering_constraints *constraints, bool *skip_current_tuple, bool delete_only, Bitmapset *null_columns, List *is_nulls); static BatchQualSummary batch_matches(RowDecompressor *decompressor, ScanKeyData *scankeys, int num_scankeys, tuple_filtering_constraints *constraints, bool check_full_match, bool *skip_current_tuple); static BatchQualSummary batch_matches_vectorized(RowDecompressor *decompressor, ScanKeyData *scankeys, int num_scankeys, tuple_filtering_constraints *constraints, bool check_full_match, bool *skip_current_tuple); static void process_predicates(Chunk *ch, CompressionSettings *settings, List *predicates, ScanKeyData **mem_scankeys, int *num_mem_scankeys, List **heap_filters, List **index_filters, List **is_null); static Relation find_matching_index(Relation comp_chunk_rel, List **index_filters, List **heap_filters); static tuple_filtering_constraints *get_batch_keys_for_unique_constraints(Relation relation); static BatchFilter *make_batchfilter(char *column_name, StrategyNumber strategy, Oid collation, RegProcedure opcode, Const *value, bool is_null_check, bool is_null, bool is_array_op); static void report_error(TM_Result result); static bool key_column_is_null(tuple_filtering_constraints *constraints, Relation chunk_rel, Oid ht_relid, TupleTableSlot *slot); static bool can_delete_without_decompression(ModifyHypertableState *ht_state, CompressionSettings *settings, Chunk *chunk, List *predicates); static bool can_vectorize_constraint_checks(tuple_filtering_constraints *constraints, CompressionSettings *settings, Relation chunk_rel, Oid ht_relid, ScanKeyWithAttnos *mem_scankeys); static ScanKeyData *get_updated_scankeys(const ScanKeyWithAttnos *scankeys, TupleTableSlot *slot, int null_flags); static AttrNumber TupleDescGetAttrNumber(TupleDesc desc, const char *name) { for (int i = 0; i < desc->natts; i++) { if (strcmp(name, NameStr(TupleDescAttr(desc, i)->attname)) == 0) return TupleDescAttr(desc, i)->attnum; } return InvalidAttrNumber; } void init_decompress_state_for_insert(ChunkInsertState *cis, TupleTableSlot *slot) { if (!cis->chunk_compressed || cis->cached_decompression_state != NULL) { /* * If the chunk is not compressed or the decompression state has * already been initialized, there is nothing to do here. */ return; } CachedDecompressionState *cdst = NULL; MemoryContext old_context = MemoryContextSwitchTo(cis->mctx); cdst = palloc0(sizeof(CachedDecompressionState)); cdst->has_primary_or_unique_index = ts_indexing_relation_has_primary_or_unique_index(cis->rel); if (cdst->has_primary_or_unique_index) { tuple_filtering_constraints *constraints = get_batch_keys_for_unique_constraints(cis->rel); if (constraints->covered) constraints->on_conflict = cis->onConflictAction; cdst->constraints = constraints; CompressionSettings *compression_settings = ts_compression_settings_get(RelationGetRelid(cis->rel)); Assert(compression_settings && OidIsValid(compression_settings->fd.compress_relid)); cdst->compression_settings = compression_settings; Relation in_rel = relation_open(compression_settings->fd.compress_relid, RowExclusiveLock); Bitmapset *columns_with_null_check = NULL; Bitmapset *key_columns = constraints->key_columns; Bitmapset *index_columns = NULL; Relation index_rel = NULL; if (ts_guc_enable_dml_decompression_tuple_filtering) { cdst->mem_scankeys.scankeys = build_mem_scankeys_from_slot(cis->hypertable_relid, compression_settings, cis->rel, constraints, slot, &cdst->mem_scankeys.num_scankeys, &cdst->mem_scankeys.attnos); cdst->constraints->vectorized_filtering = can_vectorize_constraint_checks(constraints, compression_settings, cis->rel, cis->hypertable_relid, &cdst->mem_scankeys); cdst->index_scankeys.scankeys = build_index_scankeys_using_slot(cis->hypertable_relid, in_rel, cis->rel, constraints->key_columns, slot, &index_rel, &index_columns, &cdst->index_scankeys.num_scankeys, &cdst->index_scankeys.attnos); } if (index_rel) { /* * Prepare the heap scan keys for all * key columns not found in the index */ key_columns = bms_difference(constraints->key_columns, index_columns); } cdst->heap_scankeys.scankeys = build_heap_scankeys(cis->hypertable_relid, in_rel, cis->rel, compression_settings, key_columns, &columns_with_null_check, slot, &cdst->heap_scankeys.num_scankeys, &cdst->heap_scankeys.attnos); if (index_rel) { cdst->index_relid = RelationGetRelid(index_rel); columns_with_null_check = NULL; index_close(index_rel, AccessShareLock); } cdst->columns_with_null_check = columns_with_null_check; table_close(in_rel, NoLock); } cis->cached_decompression_state = cdst; MemoryContextSwitchTo(old_context); } static ScanKeyData * get_updated_scankeys(const ScanKeyWithAttnos *scankeys, TupleTableSlot *slot, int null_flags) { if (scankeys->num_scankeys == 0) { return NULL; } ScanKeyData *updated_scankeys = palloc0(sizeof(ScanKeyData) * scankeys->num_scankeys); for (int i = 0; i < scankeys->num_scankeys; i++) { updated_scankeys[i] = scankeys->scankeys[i]; bool isnull = false; Datum value = slot_getattr(slot, scankeys->attnos[i], &isnull); if (isnull) { updated_scankeys[i].sk_flags = null_flags; updated_scankeys[i].sk_argument = (Datum) 0; } else { updated_scankeys[i].sk_flags = 0; updated_scankeys[i].sk_argument = value; } } return updated_scankeys; } void decompress_batches_for_insert(ChunkInsertState *cis, TupleTableSlot *slot) { /* * This is supposed to be called with the actual tuple that is being * inserted, so it cannot be empty. */ Assert(!TTS_EMPTY(slot)); Relation out_rel = cis->rel; CachedDecompressionState *cdst = cis->cached_decompression_state; Assert(cdst != NULL); if (!cdst->has_primary_or_unique_index) { /* * If there are no unique constraints there is nothing to do here. */ return; } if (!ts_guc_enable_dml_decompression) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("inserting into compressed chunk with unique constraints disabled"), errhint("Set timescaledb.enable_dml_decompression to TRUE."))); if (key_column_is_null(cdst->constraints, cis->rel, cis->hypertable_relid, slot)) { /* When any key column is NULL and NULLs are distinct there is no * decompression to be done as the tuple will not conflict with any * existing tuples. */ return; } Assert(cdst->compression_settings->fd.relid == RelationGetRelid(out_rel)); Relation in_rel = relation_open(cdst->compression_settings->fd.compress_relid, RowExclusiveLock); /* the scan keys used for in memory tests of the decompressed tuples */ bool skip_current_tuple = false; struct decompress_batches_stats stats; Relation index_rel = NULL; if (OidIsValid(cdst->index_relid)) { index_rel = index_open(cdst->index_relid, AccessShareLock); } ScanKeyData *index_scankeys = get_updated_scankeys(&cdst->index_scankeys, slot, SK_ISNULL | SK_SEARCHNULL); ScanKeyData *heap_scankeys = get_updated_scankeys(&cdst->heap_scankeys, slot, SK_ISNULL | SK_SEARCHNULL); ScanKeyData *mem_scankeys = get_updated_scankeys(&cdst->mem_scankeys, slot, SK_ISNULL); if (ts_guc_debug_compression_path_info) { elog(INFO, "Using %s scan with scan keys: index %d, heap %d, memory %d. ", OidIsValid(cdst->index_relid) ? "index" : "table", cdst->index_scankeys.num_scankeys, cdst->heap_scankeys.num_scankeys, cdst->mem_scankeys.num_scankeys); } /* * Using latest snapshot to scan the heap since we are doing this to build * the index on the uncompressed chunks in order to do speculative insertion * which is always built from all tuples (even in higher levels of isolation). */ PushActiveSnapshot(GetLatestSnapshot()); stats = decompress_batches_scan(in_rel, out_rel, index_rel, GetActiveSnapshot(), index_scankeys, cdst->index_scankeys.num_scankeys, heap_scankeys, cdst->heap_scankeys.num_scankeys, mem_scankeys, cdst->mem_scankeys.num_scankeys, cdst->constraints, &skip_current_tuple, false, cdst->columns_with_null_check, /* no null column check for non-segmentby columns */ NIL); if (index_rel) index_close(index_rel, AccessShareLock); PopActiveSnapshot(); if (skip_current_tuple) { cis->skip_current_tuple = true; } cis->counters->batches_deleted += stats.batches_deleted; cis->counters->batches_filtered += stats.batches_filtered; cis->counters->batches_decompressed += stats.batches_decompressed; cis->counters->tuples_decompressed += stats.tuples_decompressed; if (index_scankeys) pfree(index_scankeys); if (heap_scankeys) pfree(heap_scankeys); if (mem_scankeys) pfree(mem_scankeys); CommandCounterIncrement(); table_close(in_rel, NoLock); } /* * This method will: * 1. Evaluate WHERE clauses and check if SEGMENT BY columns * are specified or not. * 2. Build scan keys for SEGMENT BY columns. * 3. Move scanned rows to staging area. * 4. Update catalog table to change status of moved chunk. * * Returns true if it decompresses any data. */ static bool decompress_batches_for_update_delete(ModifyHypertableState *ht_state, Chunk *chunk, List *predicates, EState *estate, bool has_joins) { /* process each chunk with its corresponding predicates */ List *heap_filters = NIL; List *index_filters = NIL; List *is_null = NIL; ListCell *lc = NULL; Relation chunk_rel; Relation comp_chunk_rel; Relation matching_index_rel = NULL; BatchFilter *filter; ScanKeyData *scankeys = NULL; Bitmapset *null_columns = NULL; int num_scankeys = 0; ScanKeyData *index_scankeys = NULL; int num_index_scankeys = 0; struct decompress_batches_stats stats; int num_mem_scankeys = 0; ScanKeyData *mem_scankeys = NULL; CompressionSettings *settings = ts_compression_settings_get(chunk->table_id); bool delete_only = ht_state->mt->operation == CMD_DELETE && !has_joins && can_delete_without_decompression(ht_state, settings, chunk, predicates); process_predicates(chunk, settings, predicates, &mem_scankeys, &num_mem_scankeys, &heap_filters, &index_filters, &is_null); chunk_rel = table_open(chunk->table_id, RowExclusiveLock); comp_chunk_rel = table_open(settings->fd.compress_relid, RowExclusiveLock); if (index_filters) { matching_index_rel = find_matching_index(comp_chunk_rel, &index_filters, &heap_filters); } if (heap_filters) { scankeys = build_update_delete_scankeys(comp_chunk_rel, heap_filters, &num_scankeys, &null_columns, &delete_only); } if (matching_index_rel) { index_scankeys = build_index_scankeys(matching_index_rel, index_filters, &num_index_scankeys); } PushActiveSnapshot(GetTransactionSnapshot()); stats = decompress_batches_scan(comp_chunk_rel, chunk_rel, matching_index_rel, GetActiveSnapshot(), index_scankeys, num_index_scankeys, scankeys, num_scankeys, mem_scankeys, num_mem_scankeys, NULL, NULL, delete_only, null_columns, is_null); /* close the selected index */ if (matching_index_rel) index_close(matching_index_rel, AccessShareLock); PopActiveSnapshot(); /* * tuples from compressed chunk has been decompressed and moved * to staging area, thus mark this chunk as partially compressed */ if (stats.batches_decompressed > 0) ts_chunk_set_partial(chunk); table_close(chunk_rel, NoLock); table_close(comp_chunk_rel, NoLock); foreach (lc, heap_filters) { filter = lfirst(lc); pfree(filter); } foreach (lc, index_filters) { filter = lfirst(lc); pfree(filter); } ht_state->batches_deleted += stats.batches_deleted; ht_state->batches_filtered += stats.batches_filtered; ht_state->batches_decompressed += stats.batches_decompressed; ht_state->tuples_decompressed += stats.tuples_decompressed; ht_state->tuples_deleted += stats.tuples_deleted; return stats.batches_decompressed > 0; } typedef struct DecompressBatchScanData { TableScanDesc scan; IndexScanDesc index_scan; } DecompressBatchScanData; typedef struct DecompressBatchScanData *DecompressBatchScanDesc; static DecompressBatchScanDesc decompress_batch_beginscan(Relation in_rel, Relation index_rel, Snapshot snapshot, int num_scankeys, ScanKeyData *scankeys) { DecompressBatchScanDesc scan; scan = (DecompressBatchScanDesc) palloc(sizeof(DecompressBatchScanData)); if (index_rel) { scan->index_scan = index_beginscan_compat(in_rel, index_rel, snapshot, NULL, num_scankeys, 0); index_rescan(scan->index_scan, scankeys, num_scankeys, NULL, 0); scan->scan = NULL; } else { scan->scan = table_beginscan(in_rel, snapshot, num_scankeys, scankeys); scan->index_scan = NULL; } return scan; } static bool decompress_batch_scan_getnext_slot(DecompressBatchScanDesc scan, ScanDirection direction, struct TupleTableSlot *slot) { if (scan->index_scan) { return index_getnext_slot(scan->index_scan, direction, slot); } else { return table_scan_getnextslot(scan->scan, direction, slot); } } static void decompress_batch_endscan(DecompressBatchScanDesc scan) { if (scan->index_scan) { index_endscan(scan->index_scan); } else { table_endscan(scan->scan); } pfree(scan); } /* * This method will: * 1.Scan the index created with SEGMENT BY columns or the entire compressed chunk * 2.Fetch matching rows and decompress the row * 3.Delete this row from compressed chunk * 4.Insert decompressed rows to uncompressed chunk * * Returns whether we decompressed anything. * */ static struct decompress_batches_stats decompress_batches_scan(Relation in_rel, Relation out_rel, Relation index_rel, Snapshot snapshot, ScanKeyData *index_scankeys, int num_index_scankeys, ScanKeyData *heap_scankeys, int num_heap_scankeys, ScanKeyData *mem_scankeys, int num_mem_scankeys, tuple_filtering_constraints *constraints, bool *skip_current_tuple, bool delete_only, Bitmapset *null_columns, List *is_nulls) { HeapTuple compressed_tuple; BulkWriter writer; RowDecompressor decompressor; bool decompressor_initialized = false; bool valid = false; int num_scanned_rows = 0; int num_filtered_rows = 0; TM_Result result; DecompressBatchScanDesc scan = NULL; BatchMatcher *batch_matcher = constraints && constraints->vectorized_filtering ? batch_matches_vectorized : batch_matches; AttrNumber meta_count_attno = InvalidAttrNumber; struct decompress_batches_stats stats = { 0 }; /* TODO: Optimization by reusing the index scan while working on a single chunk */ if (index_rel) { scan = decompress_batch_beginscan(in_rel, index_rel, snapshot, num_index_scankeys, index_scankeys); } else { scan = decompress_batch_beginscan(in_rel, NULL, snapshot, num_heap_scankeys, heap_scankeys); } TupleTableSlot *slot = table_slot_create(in_rel, NULL); while (decompress_batch_scan_getnext_slot(scan, ForwardScanDirection, slot)) { num_scanned_rows++; /* Deconstruct the tuple */ Assert(slot->tts_ops->get_heap_tuple); compressed_tuple = slot->tts_ops->get_heap_tuple(slot); if (index_rel && num_heap_scankeys) { /* filter tuple based on compress_orderby columns */ valid = false; #if PG16_LT HeapKeyTest(compressed_tuple, RelationGetDescr(in_rel), num_heap_scankeys, heap_scankeys, valid); #else valid = HeapKeyTest(compressed_tuple, RelationGetDescr(in_rel), num_heap_scankeys, heap_scankeys); #endif if (!valid) { num_filtered_rows++; continue; } } int attrno = bms_next_member(null_columns, -1); int pos = 0; bool is_null_condition = 0; bool seg_col_is_null = false; valid = true; /* * Since the heap scan API does not support SK_SEARCHNULL we have to check * for NULL values manually when those are part of the constraints. */ for (; attrno >= 0; attrno = bms_next_member(null_columns, attrno)) { is_null_condition = is_nulls && list_nth_int(is_nulls, pos); seg_col_is_null = slot_attisnull(slot, attrno); if ((seg_col_is_null && !is_null_condition) || (!seg_col_is_null && is_null_condition)) { /* * if segment by column in the scanned tuple has non null value * and IS NULL is specified, OR segment by column has null value * and IS NOT NULL is specified then skip this tuple */ valid = false; break; } pos++; } if (!valid) { num_filtered_rows++; continue; } if (!decompressor_initialized) { decompressor = build_decompressor(RelationGetDescr(in_rel), RelationGetDescr(out_rel)); decompressor_initialized = true; writer = bulk_writer_build(out_rel, 0); meta_count_attno = TupleDescGetAttrNumber(decompressor.in_desc, COMPRESSION_COLUMN_METADATA_COUNT_NAME); Assert(meta_count_attno != InvalidAttrNumber); } heap_deform_tuple(compressed_tuple, decompressor.in_desc, decompressor.compressed_datums, decompressor.compressed_is_nulls); /* If there are no in-memory quals, all rows pass */ BatchQualSummary summary = AllRowsPass; if (num_mem_scankeys) { summary = batch_matcher(&decompressor, mem_scankeys, num_mem_scankeys, constraints, delete_only, /* need to check full batch for direct DELETEs */ skip_current_tuple); /* If no rows pass, complete batch gets filtered */ if (summary == NoRowsPass) { row_decompressor_reset(&decompressor); stats.batches_filtered++; continue; } } row_decompressor_reset(&decompressor); if (skip_current_tuple && *skip_current_tuple) { row_decompressor_close(&decompressor); bulk_writer_close(&writer); decompress_batch_endscan(scan); ExecDropSingleTupleTableSlot(slot); return stats; } write_logical_replication_msg_decompression_start(); TM_FailureData tmfd; result = table_tuple_delete(in_rel, &compressed_tuple->t_self, GetCurrentCommandId(true), snapshot, InvalidSnapshot, true, &tmfd, false); /* skip reporting error if isolation level is < Repeatable Read * since somebody decompressed the data concurrently, we need to take * that data into account as well when in Read Committed level */ if (result == TM_Deleted && !IsolationUsesXactSnapshot()) { write_logical_replication_msg_decompression_end(); stats.batches_decompressed++; continue; } if (result != TM_Ok) { write_logical_replication_msg_decompression_end(); row_decompressor_close(&decompressor); bulk_writer_close(&writer); decompress_batch_endscan(scan); report_error(result); return stats; } /* If all rows pass, complete batch can be deleted */ if (delete_only && summary == AllRowsPass) { stats.batches_deleted++; stats.tuples_deleted += DatumGetInt32( decompressor.compressed_datums[AttrNumberGetAttrOffset(meta_count_attno)]); } else { stats.tuples_decompressed += row_decompressor_decompress_row_to_table(&decompressor, &writer); stats.batches_decompressed++; } write_logical_replication_msg_decompression_end(); } ExecDropSingleTupleTableSlot(slot); decompress_batch_endscan(scan); if (decompressor_initialized) { row_decompressor_close(&decompressor); bulk_writer_close(&writer); } if (ts_guc_debug_compression_path_info) { elog(INFO, "Number of compressed rows fetched from %s: %d. " "Number of compressed rows filtered%s: %d.", index_rel ? "index" : "table scan", num_scanned_rows, index_rel ? " by heap filters" : "", num_filtered_rows); } return stats; } static BatchQualSummary batch_matches(RowDecompressor *decompressor, ScanKeyData *scankeys, int num_scankeys, tuple_filtering_constraints *constraints, bool check_full_match, bool *skip_current_tuple) { AttrNumber *attnos = palloc0(sizeof(AttrNumber) * num_scankeys); for (int i = 0; i < num_scankeys; i++) { attnos[i] = scankeys[i].sk_attno; } bool next_tuple = decompress_batch_next_row(decompressor, attnos, num_scankeys); ScanKey key; bool match; /* Default values are set like this because of binary operations * used to calculate these flags. */ bool match_any = false; bool match_all = true; while (next_tuple) { match = true; for (int i = 0; i < num_scankeys; i++) { key = &scankeys[i]; if (key->sk_flags & SK_ISNULL) { if (!decompressor->decompressed_is_nulls[AttrNumberGetAttrOffset(key->sk_attno)]) { match = false; break; } continue; } else if (decompressor->decompressed_is_nulls[AttrNumberGetAttrOffset(key->sk_attno)]) { match = false; break; } if (!DatumGetBool( FunctionCall2Coll(&key->sk_func, key->sk_collation, decompressor->decompressed_datums[AttrNumberGetAttrOffset( key->sk_attno)], key->sk_argument))) { match = false; break; } } match_any |= match; match_all &= match; if (match) { match_any = true; if (constraints) { if (constraints->on_conflict == ONCONFLICT_NONE) { ereport(ERROR, (errcode(ERRCODE_UNIQUE_VIOLATION), errmsg("duplicate key value violates unique constraint \"%s\"", get_rel_name(constraints->index_relid)) )); } if (constraints->on_conflict == ONCONFLICT_NOTHING && skip_current_tuple) { *skip_current_tuple = true; } } if (!check_full_match) return SomeRowsPass; } next_tuple = decompress_batch_next_row(decompressor, attnos, num_scankeys); } if (match_all) return AllRowsPass; if (match_any) return SomeRowsPass; return NoRowsPass; } static void apply_validity_bitmap(const ArrowArray *arrow, uint64 *restrict result) { const uint64 *validity = (const uint64 *) arrow->buffers[0]; if (validity) { const size_t n_vector_result_words = (arrow->length + 63) / 64; for (size_t i = 0; i < n_vector_result_words; i++) { result[i] &= validity[i]; } } else { Assert(arrow->null_count == 0); } } /* Look for default value match by checking the first result. * Default value arrow arrays contain a single member so that the only result that matters. * If we fail this check, it means the whole batch passed so we can bail immediately. */ static inline bool check_single_value_match(const uint64 *result) { return result[0] & 1; } static BatchQualSummary batch_matches_vectorized(RowDecompressor *decompressor, ScanKeyData *scankeys, int num_scankeys, tuple_filtering_constraints *constraints, bool check_full_match, bool *skip_current_tuple) { const int n_rows = DatumGetInt32(decompressor->compressed_datums[decompressor->count_compressed_attindex]); const int bitmap_bytes = sizeof(uint64) * ((n_rows + 63) / 64); uint64 *restrict result = MemoryContextAlloc(decompressor->per_compressed_row_ctx, bitmap_bytes); uint64 dict_result[(GLOBAL_MAX_ROWS_PER_COMPRESSION + 63) / 64]; memset(result, 0xFF, bitmap_bytes); bool single_value = false; bool batch_failed = false; for (int sk = 0; sk < num_scankeys; sk++) { ArrowArray *arrow = decompress_single_column(decompressor, scankeys[sk].sk_attno, &single_value); /* Handle null check */ if (scankeys[sk].sk_flags & SK_ISNULL) { vector_nulltest(arrow, IS_NULL, result); if (single_value && !check_single_value_match(result)) { batch_failed = true; break; } continue; } VectorPredicate *predicate = get_vector_const_predicate(scankeys[sk].sk_func.fn_oid); /* Handle non-dictionary compressed data */ if (!arrow->dictionary) { predicate(arrow, scankeys[sk].sk_argument, result); } else { /* Handle dictionary compressed data by decompressing the dictionary * first and then translating the results to actual results */ const size_t dict_rows = arrow->dictionary->length; const size_t dict_result_words = (dict_rows + 63) / 64; memset(dict_result, 0xFF, dict_result_words * 8); predicate(arrow->dictionary, scankeys[sk].sk_argument, dict_result); translate_bitmap_from_dictionary(arrow, dict_result, result); } apply_validity_bitmap(arrow, result); if (single_value && !check_single_value_match(result)) { batch_failed = true; break; } } if (batch_failed) { return NoRowsPass; } BatchQualSummary summary = get_vector_qual_summary(result, n_rows); if (summary != NoRowsPass) { if (constraints) { if (constraints->on_conflict == ONCONFLICT_NONE) { ereport(ERROR, (errcode(ERRCODE_UNIQUE_VIOLATION), errmsg("duplicate key value violates unique constraint \"%s\"", get_rel_name(constraints->index_relid)) )); } if (constraints->on_conflict == ONCONFLICT_NOTHING && skip_current_tuple) { *skip_current_tuple = true; } } return summary; } return summary; } /* * Traverse the plan tree to look for Scan nodes on uncompressed chunks. * Once Scan node is found check if chunk is compressed, if so then * decompress those segments which match the filter conditions if present. */ struct decompress_chunk_context { List *relids; ModifyHypertableState *ht_state; /* indicates decompression actually occurred */ bool batches_decompressed; bool has_joins; }; static bool decompress_chunk_walker(PlanState *ps, struct decompress_chunk_context *ctx); bool decompress_target_segments(ModifyHypertableState *ht_state) { ModifyTableState *ps = linitial_node(ModifyTableState, castNode(CustomScanState, ht_state)->custom_ps); struct decompress_chunk_context ctx = { .ht_state = ht_state, .relids = castNode(ModifyTable, ps->ps.plan)->resultRelations, }; Assert(ctx.relids); decompress_chunk_walker(&ps->ps, &ctx); return ctx.batches_decompressed; } static bool decompress_chunk_walker(PlanState *ps, struct decompress_chunk_context *ctx) { RangeTblEntry *rte = NULL; bool needs_decompression = false; bool should_rescan = false; bool batches_decompressed = false; List *predicates = NIL; Chunk *current_chunk; if (ps == NULL) return false; switch (nodeTag(ps)) { /* Note: IndexOnlyScans will never be selected for target * tables because system columns are necessary in order to modify the * data and those columns cannot be a part of the index */ case T_IndexScanState: { /* Get the index quals on the original table and also include * any filters that are used for filtering heap tuples */ predicates = list_union(((IndexScan *) ps->plan)->indexqualorig, ps->plan->qual); needs_decompression = true; break; } case T_BitmapHeapScanState: predicates = list_union(((BitmapHeapScan *) ps->plan)->bitmapqualorig, ps->plan->qual); needs_decompression = true; should_rescan = true; break; case T_SeqScanState: case T_SampleScanState: case T_TidScanState: case T_TidRangeScanState: { predicates = list_copy(ps->plan->qual); needs_decompression = true; break; } case T_NestLoopState: case T_MergeJoinState: case T_HashJoinState: { ctx->has_joins = true; break; } default: break; } if (needs_decompression) { /* * We are only interested in chunk scans of chunks that are the * target of the DML statement not chunk scan on joined hypertables * even when it is a self join */ int scanrelid = ((Scan *) ps->plan)->scanrelid; if (list_member_int(ctx->relids, scanrelid)) { rte = rt_fetch(scanrelid, ps->state->es_range_table); current_chunk = ts_chunk_get_by_relid(rte->relid, false); if (current_chunk && ts_chunk_is_compressed(current_chunk)) { if (!ts_guc_enable_dml_decompression) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("UPDATE/DELETE is disabled on compressed chunks"), errhint("Set timescaledb.enable_dml_decompression to TRUE."))); batches_decompressed = decompress_batches_for_update_delete(ctx->ht_state, current_chunk, predicates, ps->state, ctx->has_joins); ctx->batches_decompressed |= batches_decompressed; /* This is a workaround specifically for bitmap heap scans: * during node initialization, initialize the scan state with the active snapshot * but since we are inserting data to be modified during the same query, they end up * missing that data by using a snapshot which doesn't account for this decompressed * data. To circumvent this issue, we change the internal scan state to use the * transaction snapshot and execute a rescan so the scan state is set correctly and * includes the new data. * * From PG17 this has changed since the scan state is not initialized with * the node. */ if (should_rescan) { ScanState *ss = ((ScanState *) ps); if (ss && ss->ss_currentScanDesc) { ss->ss_currentScanDesc->rs_snapshot = GetActiveSnapshot(); table_rescan(ss->ss_currentScanDesc, NULL); } } } } } if (predicates) pfree(predicates); return planstate_tree_walker(ps, decompress_chunk_walker, ctx); } /* * For insert into compressed chunks with unique index determine the * columns which can be used for INSERT batch filtering. * The passed in relation is the uncompressed chunk. * * In case of multiple unique indexes we have to return the shared columns. * For expression indexes we ignore the columns with expressions, for partial * indexes we ignore predicate. * */ static tuple_filtering_constraints * get_batch_keys_for_unique_constraints(Relation relation) { tuple_filtering_constraints *constraints = palloc0(sizeof(tuple_filtering_constraints)); constraints->on_conflict = ONCONFLICT_UPDATE; constraints->nullsnotdistinct = false; ListCell *lc; /* Fast path if definitely no indexes */ if (!RelationGetForm(relation)->relhasindex) return constraints; List *indexoidlist = RelationGetIndexList(relation); /* Fall out if no indexes (but relhasindex was set) */ if (indexoidlist == NIL) return constraints; foreach (lc, indexoidlist) { Oid indexOid = lfirst_oid(lc); Relation indexDesc = index_open(indexOid, AccessShareLock); /* * We are only interested in unique indexes. PRIMARY KEY indexes also have * indisunique set to true so we do not need to check for them separately. */ if (!indexDesc->rd_index->indislive || !indexDesc->rd_index->indisvalid || !indexDesc->rd_index->indisunique) { index_close(indexDesc, AccessShareLock); continue; } Bitmapset *idx_attrs = NULL; /* * Collect attributes of current index. * For covering indexes we need to ignore the included columns. */ for (int i = 0; i < indexDesc->rd_index->indnkeyatts; i++) { AttrNumber attno = indexDesc->rd_index->indkey.values[i]; /* We are not interested in expression columns which will have attno = 0 */ if (!attno) continue; Assert(AttrNumberIsForUserDefinedAttr(attno)); idx_attrs = bms_add_member(idx_attrs, attno); } index_close(indexDesc, AccessShareLock); if (!constraints->key_columns) { /* First iteration */ constraints->key_columns = bms_copy(idx_attrs); /* * We only optimize unique constraint checks for non-partial and * non-expression indexes. For partial and expression indexes we * can still do batch filtering, just not make decisions about * constraint violations. */ constraints->covered = indexDesc->rd_indexprs == NIL && indexDesc->rd_indpred == NIL; constraints->index_relid = indexDesc->rd_id; } else { /* more than one unique constraint */ constraints->key_columns = bms_intersect(idx_attrs, constraints->key_columns); constraints->covered = false; } /* If any of the unique indexes have NULLS NOT DISTINCT set, we proceed * with checking the constraints with decompression */ constraints->nullsnotdistinct |= indexDesc->rd_index->indnullsnotdistinct; /* When multiple unique indexes are present, in theory there could be no shared * columns even though that is very unlikely as they will probably at least share * the partitioning columns. But since we are looking at chunk indexes here that * is not guaranteed. */ if (!constraints->key_columns) return constraints; } return constraints; } /* * This method will evaluate the predicates, extract * left and right operands, check if any of the operands * can be used for batch filtering and if so, it will * create a BatchFilter object and add it to the corresponding * list. * Any segmentby filter is put into index_filters list other * filters are put into heap_filters list. */ static void process_predicates(Chunk *ch, CompressionSettings *settings, List *predicates, ScanKeyData **mem_scankeys, int *num_mem_scankeys, List **heap_filters, List **index_filters, List **is_null) { ListCell *lc; if (ts_guc_enable_dml_decompression_tuple_filtering) { *mem_scankeys = palloc0(sizeof(ScanKeyData) * list_length(predicates)); } *num_mem_scankeys = 0; /* * We dont want to forward boundParams from the execution state here * as we dont want to constify join params in the predicates. * Constifying JOIN params would not be safe as we don't redo * this part in rescan. */ PlannerGlobal glob = { .boundParams = NULL }; PlannerInfo root = { .glob = &glob }; foreach (lc, predicates) { Node *node = copyObject(lfirst(lc)); Var *var; Expr *expr; Oid collation, opno; RegProcedure opcode; char *column_name; switch (nodeTag(node)) { case T_OpExpr: { OpExpr *opexpr = castNode(OpExpr, node); collation = opexpr->inputcollid; Const *arg_value; if (!ts_extract_expr_args(&opexpr->xpr, &var, &expr, &opno, &opcode)) continue; if (!IsA(expr, Const)) { expr = (Expr *) estimate_expression_value(&root, (Node *) expr); if (!IsA(expr, Const)) continue; } arg_value = castNode(Const, expr); column_name = get_attname(ch->table_id, var->varattno, false); TypeCacheEntry *tce = lookup_type_cache(var->vartype, TYPECACHE_BTREE_OPFAMILY); int op_strategy = get_op_opfamily_strategy(opno, tce->btree_opf); if (ts_array_is_member(settings->fd.segmentby, column_name)) { switch (op_strategy) { case BTEqualStrategyNumber: case BTLessStrategyNumber: case BTLessEqualStrategyNumber: case BTGreaterStrategyNumber: case BTGreaterEqualStrategyNumber: { /* save segment by column name and its corresponding value specified in * WHERE */ *index_filters = lappend(*index_filters, make_batchfilter(column_name, op_strategy, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ false /* is_array_op */ )); break; } default: *heap_filters = lappend(*heap_filters, make_batchfilter(column_name, op_strategy, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ false /* is_array_op */ )); break; } continue; } /* * Segmentby columns are checked as part of batch scan so no need to redo the check. */ if (ts_guc_enable_dml_decompression_tuple_filtering) { ScanKeyEntryInitialize(&(*mem_scankeys)[(*num_mem_scankeys)++], arg_value->constisnull ? SK_ISNULL : 0, var->varattno, op_strategy, arg_value->consttype, arg_value->constcollid, opcode, arg_value->constisnull ? 0 : arg_value->constvalue); } int min_attno = compressed_column_metadata_attno(settings, settings->fd.relid, var->varattno, settings->fd.compress_relid, "min"); if (min_attno == InvalidAttrNumber) continue; int max_attno = compressed_column_metadata_attno(settings, ch->table_id, var->varattno, settings->fd.compress_relid, "max"); if (max_attno == InvalidAttrNumber) continue; /* Need both min and max metadata attributes to build heap filters */ switch (op_strategy) { case BTEqualStrategyNumber: { /* orderby col = value implies min <= value and max >= value */ *heap_filters = lappend(*heap_filters, make_batchfilter(get_attname(settings->fd.compress_relid, min_attno, false), BTLessEqualStrategyNumber, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ false /* is_array_op */ )); *heap_filters = lappend(*heap_filters, make_batchfilter(get_attname(settings->fd.compress_relid, max_attno, false), BTGreaterEqualStrategyNumber, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ false /* is_array_op */ )); } break; case BTLessStrategyNumber: case BTLessEqualStrategyNumber: { /* orderby col <[=] value implies min <[=] value */ *heap_filters = lappend(*heap_filters, make_batchfilter(get_attname(settings->fd.compress_relid, min_attno, false), op_strategy, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ false /* is_array_op */ )); } break; case BTGreaterStrategyNumber: case BTGreaterEqualStrategyNumber: { /* orderby col >[=] value implies max >[=] value */ *heap_filters = lappend(*heap_filters, make_batchfilter(get_attname(settings->fd.compress_relid, max_attno, false), op_strategy, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ false /* is_array_op */ )); } break; default: /* Do nothing for unknown operator strategies. */ break; } } break; case T_ScalarArrayOpExpr: { ScalarArrayOpExpr *sa_expr = castNode(ScalarArrayOpExpr, node); if (!ts_extract_expr_args(&sa_expr->xpr, &var, &expr, &opno, &opcode)) continue; if (!IsA(expr, Const)) { expr = (Expr *) estimate_expression_value(&root, (Node *) expr); if (!IsA(expr, Const)) continue; } Const *arg_value = castNode(Const, expr); collation = sa_expr->inputcollid; column_name = get_attname(ch->table_id, var->varattno, false); TypeCacheEntry *tce = lookup_type_cache(var->vartype, TYPECACHE_BTREE_OPFAMILY); int op_strategy = get_op_opfamily_strategy(opno, tce->btree_opf); if (ts_array_is_member(settings->fd.segmentby, column_name)) { switch (op_strategy) { case BTEqualStrategyNumber: case BTLessStrategyNumber: case BTLessEqualStrategyNumber: case BTGreaterStrategyNumber: case BTGreaterEqualStrategyNumber: { /* save segment by column name and its corresponding value specified in * WHERE */ *index_filters = lappend(*index_filters, make_batchfilter(column_name, op_strategy, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ true /* is_array_op */ )); break; } default: *heap_filters = lappend(*heap_filters, make_batchfilter(column_name, op_strategy, collation, opcode, arg_value, false, /* is_null_check */ false, /* is_null */ true /* is_array_op */ )); break; } continue; } break; } case T_NullTest: { NullTest *ntest = (NullTest *) node; if (IsA(ntest->arg, Var)) { var = (Var *) ntest->arg; /* ignore system-defined attributes */ if (var->varattno <= 0) continue; column_name = get_attname(ch->table_id, var->varattno, false); if (ts_array_is_member(settings->fd.segmentby, column_name)) { *index_filters = lappend(*index_filters, make_batchfilter(column_name, InvalidStrategy, InvalidOid, InvalidOid, NULL, true, /* is_null_check */ ntest->nulltesttype == IS_NULL, /* is_null */ false /* is_array_op */ )); if (ntest->nulltesttype == IS_NULL) *is_null = lappend_int(*is_null, 1); else *is_null = lappend_int(*is_null, 0); } /* We cannot optimize filtering decompression using ORDERBY * metadata and null check qualifiers. We could possibly do that by checking the * compressed data in combination with the ORDERBY nulls first setting and * verifying that the first or last tuple of a segment contains a NULL value. * This is left for future optimization */ } } break; default: break; } } } static BatchFilter * make_batchfilter(char *column_name, StrategyNumber strategy, Oid collation, RegProcedure opcode, Const *value, bool is_null_check, bool is_null, bool is_array_op) { BatchFilter *segment_filter = palloc0(sizeof(*segment_filter)); *segment_filter = (BatchFilter){ .strategy = strategy, .collation = collation, .opcode = opcode, .value = value, .is_null_check = is_null_check, .is_null = is_null, .is_array_op = is_array_op, }; namestrcpy(&segment_filter->column_name, column_name); return segment_filter; } /* * A compressed chunk can have multiple indexes. For a given list * of columns in index_filters, find the matching index which has * the most columns based on index_filters and adjust the filters * if necessary. * Return matching index if found else return NULL. * * Note: This method will find the best matching index based on * number of filters it matches. If an index matches all the filters, * it will be chosen. Otherwise, it will try to select the index * which has most matches. If there are multiple indexes have * the same number of matches, it will pick the first one it finds. * For example * for a given condition like "WHERE X = 10 AND Y = 8" * if there are multiple indexes like * 1. index (a,b,c,x) * 2. index (a,x,y) * 3. index (x) * In this case 2nd index is returned. If that one didn't exist, * it would return the 1st index. */ static Relation find_matching_index(Relation comp_chunk_rel, List **index_filters, List **heap_filters) { List *index_oids; ListCell *lc; int total_filters = list_length(*index_filters); int max_match_count = 0; Relation result_rel = NULL; /* get list of indexes defined on compressed chunk */ index_oids = RelationGetIndexList(comp_chunk_rel); foreach (lc, index_oids) { int match_count = 0; Relation index_rel = index_open(lfirst_oid(lc), AccessShareLock); IndexInfo *index_info = BuildIndexInfo(index_rel); /* Can't use partial or expression indexes */ if (index_info->ii_Predicate != NIL || index_info->ii_Expressions != NIL) { index_close(index_rel, AccessShareLock); continue; } /* Can only use Btree indexes */ if (index_info->ii_Am != BTREE_AM_OID) { index_close(index_rel, AccessShareLock); continue; } ListCell *li; foreach (li, *index_filters) { for (int i = 0; i < index_rel->rd_index->indnatts; i++) { AttrNumber attnum = index_rel->rd_index->indkey.values[i]; char *attname = get_attname(RelationGetRelid(comp_chunk_rel), attnum, false); BatchFilter *sf = lfirst(li); /* ensure column exists in index relation */ if (!strcmp(attname, NameStr(sf->column_name))) { match_count++; break; } } } if (match_count == total_filters) { /* found index which has all columns specified in WHERE */ if (result_rel) index_close(result_rel, AccessShareLock); if (ts_guc_debug_compression_path_info) elog(INFO, "Index \"%s\" is used for scan. ", RelationGetRelationName(index_rel)); return index_rel; } if (match_count > max_match_count) { max_match_count = match_count; result_rel = index_rel; continue; } index_close(index_rel, AccessShareLock); } /* No matching index whatsoever */ if (!result_rel) { *heap_filters = list_concat(*heap_filters, *index_filters); *index_filters = list_truncate(*index_filters, 0); return NULL; } /* We found an index which matches partially. * It can be used but we need to transfer the unmatched * filters from index_filters to heap filters. */ for (int i = 0; i < list_length(*index_filters); i++) { BatchFilter *sf = list_nth(*index_filters, i); bool match = false; for (int j = 0; j < result_rel->rd_index->indnatts; j++) { AttrNumber attnum = result_rel->rd_index->indkey.values[j]; char *attname = get_attname(RelationGetRelid(comp_chunk_rel), attnum, false); /* ensure column exists in index relation */ if (!strcmp(attname, NameStr(sf->column_name))) { match = true; break; } } if (!match) { *heap_filters = lappend(*heap_filters, sf); *index_filters = list_delete_nth_cell(*index_filters, i); } } if (ts_guc_debug_compression_path_info) elog(INFO, "Index \"%s\" is used for scan. ", RelationGetRelationName(result_rel)); return result_rel; } static void report_error(TM_Result result) { switch (result) { case TM_Deleted: { if (IsolationUsesXactSnapshot()) { /* For Repeatable Read isolation level report error */ ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("could not serialize access due to concurrent update"))); } } break; /* * If another transaction is updating the compressed data, * we have to abort the transaction to keep consistency. */ case TM_Updated: { elog(ERROR, "tuple concurrently updated"); } break; case TM_Invisible: { elog(ERROR, "attempted to lock invisible tuple"); } break; case TM_Ok: break; default: { elog(ERROR, "unexpected tuple operation result: %d", result); } break; } } /* * If key_columns are including all unique constraint columns and NULLS * are not DISTINCT any NULL value in the key columns allows us to skip * finding matching batches as it will not create a constraint violation. */ static bool key_column_is_null(tuple_filtering_constraints *constraints, Relation chunk_rel, Oid ht_relid, TupleTableSlot *slot) { if (!constraints->covered || constraints->nullsnotdistinct) return false; AttrNumber chunk_attno = -1; while ((chunk_attno = bms_next_member(constraints->key_columns, chunk_attno)) > 0) { /* * slot has the physical layout of the hypertable, so we need to * get the attribute number of the hypertable for the column. */ const NameData *attname = attnumAttName(chunk_rel, chunk_attno); AttrNumber ht_attno = get_attnum(ht_relid, NameStr(*attname)); if (slot_attisnull(slot, ht_attno)) return true; } return false; } static bool can_delete_without_decompression(ModifyHypertableState *ht_state, CompressionSettings *settings, Chunk *chunk, List *predicates) { ListCell *lc; if (!ts_guc_enable_compressed_direct_batch_delete) return false; /* * If there is a RETURNING clause we skip the optimization to delete compressed batches directly */ if (ht_state->mt->returningLists) return false; if (ts_hypertable_has_continuous_aggregates(ht_state->ht->fd.id)) return false; /* * If there are any DELETE row triggers on the hypertable we skip the optimization * to delete compressed batches directly. */ ModifyTableState *ps = linitial_node(ModifyTableState, castNode(CustomScanState, ht_state)->custom_ps); if (ps->rootResultRelInfo->ri_TrigDesc) { TriggerDesc *trigdesc = ps->rootResultRelInfo->ri_TrigDesc; if (trigdesc->trig_delete_before_row || trigdesc->trig_delete_after_row || trigdesc->trig_delete_instead_row) { return false; } } foreach (lc, predicates) { Node *node = lfirst(lc); Var *var; Expr *arg_value; Oid opno; if (ts_extract_expr_args((Expr *) node, &var, &arg_value, &opno, NULL)) { if (!IsA(arg_value, Const)) { return false; } char *column_name = get_attname(chunk->table_id, var->varattno, false); /* Can do direct DELETE if we are dealing with segmentby columns */ if (ts_array_is_member(settings->fd.segmentby, column_name)) continue; /* Can do direct DELETE if we are using in-memory filtering but * only if we can actually create scankeys for filtering */ if (ts_guc_enable_dml_decompression_tuple_filtering) { switch (nodeTag(node)) { case T_ScalarArrayOpExpr: case T_NullTest: return false; default: continue; } } } return false; } return true; } static bool can_vectorize_constraint_checks(tuple_filtering_constraints *constraints, CompressionSettings *settings, Relation chunk_rel, Oid ht_relid, ScanKeyWithAttnos *mem_scankeys) { AttrNumber chunk_attno = -1; Oid typoid, collid; int32 typmod; if (mem_scankeys == NULL || mem_scankeys->num_scankeys == 0) return false; /* We can only vectorize if a vectorized check is available for all scankeys */ for (int sk = 0; sk < mem_scankeys->num_scankeys; sk++) { /* * Here we cannot check for NULL flags even if that is * handled separately, because this code is called from * the `init_decompress_state_for_insert` which sets the * flag based on the first record to be inserted and the * value may change for the subsequent records. * * The `fn_oid` doesn't get updated so it is valid to check * it here. */ ScanKeyData *scankey = &mem_scankeys->scankeys[sk]; if (get_vector_const_predicate(scankey->sk_func.fn_oid) == NULL) return false; } while ((chunk_attno = bms_next_member(constraints->key_columns, chunk_attno)) > 0) { /* * slot has the physical layout of the hypertable, so we need to * get the attribute number of the hypertable for the column. */ char *attname = get_attname(chunk_rel->rd_id, chunk_attno, false); /* Ignore segmentby columns, they aren't compressed */ if (ts_array_is_member(settings->fd.segmentby, attname)) continue; get_atttypetypmodcoll(chunk_rel->rd_id, chunk_attno, &typoid, &typmod, &collid); /* No bulk decompression function, no vectorized filtering */ if (tsl_get_decompress_all_function(compression_get_default_algorithm(typoid), typoid) == NULL) return false; /* For text types, check for non-deterministic collation which * prevents vectorized filtering */ if (typoid == TEXTOID && OidIsValid(collid) && !get_collation_isdeterministic(collid)) return false; } return true; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/compression_dml.h��������������������������������������������0000664�0000000�0000000�00000004075�15100345067�0023361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/skey.h> #include <nodes/nodes.h> #include "ts_catalog/compression_settings.h" typedef struct tuple_filtering_constraints { /* * All key column heap attribute numbers on uncompressed chunk. * We shouldn't be dealing with system columns so no need to * add/subtract FirstLowInvalidHeapAttributeNumber from these. */ Bitmapset *key_columns; /* * The covered flag is set to true if we have a single constraint that is covered * by all the columns present in the Bitmapset. */ bool covered; /* further fields only valid when covered is true */ OnConflictAction on_conflict; Oid index_relid; /* used for better error messages */ bool nullsnotdistinct; bool vectorized_filtering; } tuple_filtering_constraints; bool slot_key_test(TupleTableSlot *slot, ScanKey skey); ScanKeyData *build_mem_scankeys_from_slot(Oid ht_relid, CompressionSettings *settings, Relation out_rel, tuple_filtering_constraints *constraints, TupleTableSlot *slot, int *num_scankeys, AttrNumber **slot_attnos); ScanKeyData *build_index_scankeys(Relation index_rel, List *index_filters, int *num_scankeys); ScanKeyData *build_index_scankeys_using_slot(Oid hypertable_relid, Relation in_rel, Relation out_rel, Bitmapset *key_columns, TupleTableSlot *slot, Relation *result_index_rel, Bitmapset **index_columns, int *num_scan_keys, AttrNumber **slot_attnos); ScanKeyData *build_heap_scankeys(Oid hypertable_relid, Relation in_rel, Relation out_rel, CompressionSettings *settings, Bitmapset *key_columns, Bitmapset **null_columns, TupleTableSlot *slot, int *num_scankeys, AttrNumber **slot_attnos); ScanKeyData *build_update_delete_scankeys(Relation in_rel, List *heap_filters, int *num_scankeys, Bitmapset **null_columns, bool *delete_only); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/compression_scankey.c����������������������������������������0000664�0000000�0000000�00000043743�15100345067�0024242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_am.h> #include <parser/parse_coerce.h> #include <parser/parse_relation.h> #include <utils/typcache.h> #include "compression.h" #include "compression_dml.h" #include "create.h" #include "ts_catalog/array_utils.h" static Oid deduce_filter_subtype(BatchFilter *filter, Oid att_typoid); static bool create_segment_filter_scankey(Relation in_rel, char *segment_filter_col_name, StrategyNumber strategy, Oid subtype, Oid opcode, ScanKeyData *scankeys, int *num_scankeys, Bitmapset **null_columns, Datum value, bool is_null_check, bool is_array_op); /* * Test ScanKey against a slot. * * Unlike HeapKeyTest, this function takes into account SK_ISNULL * and works correctly when looking for null values. */ bool slot_key_test(TupleTableSlot *compressed_slot, ScanKey key) { /* No need to get the datum if we are only checking for NULLs */ if (key->sk_flags & SK_ISNULL) { return slot_attisnull(compressed_slot, key->sk_attno); } Datum val; bool is_null; val = slot_getattr(compressed_slot, key->sk_attno, &is_null); if (is_null) return false; return DatumGetBool(FunctionCall2Coll(&key->sk_func, key->sk_collation, val, key->sk_argument)); } /* * Build scankeys for decompressed tuple to check if it is part of the batch. * * The key_columns are the columns of the uncompressed chunk. */ ScanKeyData * build_mem_scankeys_from_slot(Oid ht_relid, CompressionSettings *settings, Relation out_rel, tuple_filtering_constraints *constraints, TupleTableSlot *slot, int *num_scankeys, AttrNumber **slot_attnos) { ScanKeyData *scankeys = NULL; int key_index = 0; TupleDesc out_desc = RelationGetDescr(out_rel); if (bms_is_empty(constraints->key_columns)) { *num_scankeys = key_index; return scankeys; } int max_key_columns = bms_num_members(constraints->key_columns); scankeys = palloc(sizeof(ScanKeyData) * max_key_columns); *slot_attnos = palloc0(sizeof(AttrNumber) * max_key_columns); AttrNumber attno = -1; while ((attno = bms_next_member(constraints->key_columns, attno)) > 0) { bool isnull; /* * slot has the physical layout of the hypertable, so we need to * get the attribute number of the hypertable for the column. */ char *attname = get_attname(out_rel->rd_id, attno, false); /* * We can skip any segmentby columns here since they have already been * checked during batch filtering. */ if (ts_array_is_member(settings->fd.segmentby, attname)) { continue; } AttrNumber ht_attno = get_attnum(ht_relid, attname); Datum value = slot_getattr(slot, ht_attno, &isnull); (*slot_attnos)[key_index] = ht_attno; Oid atttypid = TupleDescAttr(out_desc, AttrNumberGetAttrOffset(attno))->atttypid; TypeCacheEntry *tce = lookup_type_cache(atttypid, TYPECACHE_BTREE_OPFAMILY); /* * Should never happen since the column is part of unique constraint * and should therefore have the required opfamily */ if (!OidIsValid(tce->btree_opf)) elog(ERROR, "no btree opfamily for type \"%s\"", format_type_be(atttypid)); Oid opr = get_opfamily_member(tce->btree_opf, atttypid, atttypid, BTEqualStrategyNumber); /* * Fall back to btree operator input type when it is binary compatible with * the column type and no operator for column type could be found. */ if (!OidIsValid(opr) && IsBinaryCoercible(atttypid, tce->btree_opintype)) { opr = get_opfamily_member(tce->btree_opf, tce->btree_opintype, tce->btree_opintype, BTEqualStrategyNumber); } if (!OidIsValid(opr)) elog(ERROR, "no operator found for type \"%s\"", format_type_be(atttypid)); ScanKeyEntryInitialize(&scankeys[key_index++], isnull ? SK_ISNULL : 0, attno, BTEqualStrategyNumber, atttypid, TupleDescAttr(out_desc, AttrNumberGetAttrOffset(attno)) ->attcollation, get_opcode(opr), isnull ? 0 : value); } *num_scankeys = key_index; return scankeys; } /* * Build scankeys for decompression of specific batches. key_columns references the * columns of the uncompressed chunk. */ ScanKeyData * build_heap_scankeys(Oid hypertable_relid, Relation in_rel, Relation out_rel, CompressionSettings *settings, Bitmapset *key_columns, Bitmapset **null_columns, TupleTableSlot *slot, int *num_scankeys, AttrNumber **slot_attnos) { int key_index = 0; ScanKeyData *scankeys = NULL; if (!bms_is_empty(key_columns)) { int max_key_columns = bms_num_members(key_columns) * 2; scankeys = palloc0(max_key_columns * sizeof(ScanKeyData)); *slot_attnos = palloc0(max_key_columns * sizeof(AttrNumber)); AttrNumber attno = -1; while ((attno = bms_next_member(key_columns, attno)) > 0) { char *attname = get_attname(out_rel->rd_id, attno, false); bool isnull; AttrNumber ht_attno = get_attnum(hypertable_relid, attname); /* * This is a not very precise but easy assertion to detect attno * mismatch at least in some cases. The mismatch might happen if the * hypertable and chunk layout are different because of dropped * columns, and we're using a wrong slot type here. */ PG_USED_FOR_ASSERTS_ONLY Oid ht_atttype = get_atttype(hypertable_relid, ht_attno); PG_USED_FOR_ASSERTS_ONLY Oid slot_atttype = TupleDescAttr(slot->tts_tupleDescriptor, AttrNumberGetAttrOffset(ht_attno)) ->atttypid; Assert(ht_atttype == slot_atttype); Datum value = slot_getattr(slot, ht_attno, &isnull); /* * There are 3 possible scenarios we have to consider * when dealing with columns which are part of unique * constraints. * * 1. Column is segmentby-Column * In this case we can add a single ScanKey with an * equality check for the value. * 2. Column is orderby-Column * In this we can add 2 ScanKeys with range constraints * utilizing batch metadata. * 3. Column is neither segmentby nor orderby * In this case we cannot utilize this column for * batch filtering as the values are compressed and * we have no metadata. */ if (ts_array_is_member(settings->fd.segmentby, attname)) { if (create_segment_filter_scankey(in_rel, attname, BTEqualStrategyNumber, InvalidOid, InvalidOid, scankeys, &key_index, null_columns, value, isnull, false)) { (*slot_attnos)[key_index - 1] = ht_attno; } } if (ts_array_is_member(settings->fd.orderby, attname)) { /* Cannot optimize orderby columns with NULL values since those * are not visible in metadata */ if (isnull) continue; int16 index = ts_array_position(settings->fd.orderby, attname); if (create_segment_filter_scankey(in_rel, column_segment_min_name(index), BTLessEqualStrategyNumber, InvalidOid, InvalidOid, scankeys, &key_index, null_columns, value, false, false /* is_null_check */ )) { (*slot_attnos)[key_index - 1] = ht_attno; } if (create_segment_filter_scankey(in_rel, column_segment_max_name(index), BTGreaterEqualStrategyNumber, InvalidOid, InvalidOid, scankeys, &key_index, null_columns, value, false, false /* is_null_check */ )) { (*slot_attnos)[key_index - 1] = ht_attno; } } } } *num_scankeys = key_index; return scankeys; } /* * This method will build scan keys required to do index * scans on compressed chunks. */ ScanKeyData * build_index_scankeys(Relation index_rel, List *index_filters, int *num_scankeys) { ListCell *lc; BatchFilter *filter = NULL; *num_scankeys = list_length(index_filters); ScanKeyData *scankey = palloc0(sizeof(ScanKeyData) * (*num_scankeys)); int idx = 0; int flags; /* Order scankeys based on index attribute order */ for (int idx_attno = 1; idx_attno <= index_rel->rd_index->indnkeyatts && idx < *num_scankeys; idx_attno++) { AttrNumber attno = index_rel->rd_index->indkey.values[AttrNumberGetAttrOffset(idx_attno)]; char *attname = get_attname(index_rel->rd_index->indrelid, attno, false); Oid typoid = attnumTypeId(index_rel, idx_attno); foreach (lc, index_filters) { filter = lfirst(lc); if (!strcmp(attname, NameStr(filter->column_name))) { flags = 0; if (filter->is_null_check) { flags = SK_ISNULL | (filter->is_null ? SK_SEARCHNULL : SK_SEARCHNOTNULL); } if (filter->is_array_op) { flags |= SK_SEARCHARRAY; } ScanKeyEntryInitialize(&scankey[idx++], flags, idx_attno, filter->strategy, deduce_filter_subtype(filter, typoid), /* subtype */ filter->collation, filter->opcode, filter->value ? filter->value->constvalue : 0); break; } } } Assert(idx == *num_scankeys); return scankey; } /* This method is used to find matching index on compressed chunk * and build scan keys from the slot data */ ScanKeyData * build_index_scankeys_using_slot(Oid hypertable_relid, Relation in_rel, Relation out_rel, Bitmapset *key_columns, TupleTableSlot *slot, Relation *result_index_rel, Bitmapset **index_columns, int *num_scan_keys, AttrNumber **slot_attnos) { List *index_oids; ListCell *lc; ScanKeyData *scankeys = NULL; /* get list of indexes defined on compressed chunk */ index_oids = RelationGetIndexList(in_rel); *num_scan_keys = 0; foreach (lc, index_oids) { Relation index_rel = index_open(lfirst_oid(lc), AccessShareLock); IndexInfo *index_info = BuildIndexInfo(index_rel); /* Can't use partial or expression indexes */ if (index_info->ii_Predicate != NIL || index_info->ii_Expressions != NIL) { index_close(index_rel, AccessShareLock); continue; } /* Can only use Btree indexes */ if (index_info->ii_Am != BTREE_AM_OID) { index_close(index_rel, AccessShareLock); continue; } /* * Must have at least two attributes, index we are looking for contains * at least one segmentby column and a sequence number. */ if (index_rel->rd_index->indnatts < 2) { index_close(index_rel, AccessShareLock); continue; } scankeys = palloc0((index_rel->rd_index->indnatts) * sizeof(ScanKeyData)); *slot_attnos = palloc0((index_rel->rd_index->indnatts) * sizeof(AttrNumber)); /* * Using only key attributes to exclude covering columns * only interested in filtering here */ for (int i = 0; i < index_rel->rd_index->indnkeyatts; i++) { AttrNumber idx_attnum = AttrOffsetGetAttrNumber(i); AttrNumber in_attnum = index_rel->rd_index->indkey.values[i]; const NameData *attname = attnumAttName(in_rel, in_attnum); AttrNumber column_attno = get_attnum(out_rel->rd_id, NameStr(*attname)); /* Make sure we find columns in key columns in order to select the right index */ if (!bms_is_member(column_attno, key_columns)) { break; } bool isnull; AttrNumber ht_attno = get_attnum(hypertable_relid, NameStr(*attname)); Datum value = slot_getattr(slot, ht_attno, &isnull); (*slot_attnos)[*num_scan_keys] = ht_attno; Oid atttypid = attnumTypeId(index_rel, idx_attnum); TypeCacheEntry *tce = lookup_type_cache(atttypid, TYPECACHE_BTREE_OPFAMILY); if (!OidIsValid(tce->btree_opf)) elog(ERROR, "no btree opfamily for type \"%s\"", format_type_be(atttypid)); Oid opr = get_opfamily_member(tce->btree_opf, atttypid, atttypid, BTEqualStrategyNumber); /* * Fall back to btree operator input type when it is binary compatible with * the column type and no operator for column type could be found. */ if (!OidIsValid(opr) && IsBinaryCoercible(atttypid, tce->btree_opintype)) { opr = get_opfamily_member(tce->btree_opf, tce->btree_opintype, tce->btree_opintype, BTEqualStrategyNumber); } /* No operator could be found so we can't create the scankey. */ if (!OidIsValid(opr)) continue; Oid opcode = get_opcode(opr); Ensure(OidIsValid(opcode), "no opcode found for column operator of a hypertable column"); *index_columns = bms_add_member(*index_columns, column_attno); ScanKeyEntryInitialize(&scankeys[(*num_scan_keys)++], isnull ? SK_ISNULL | SK_SEARCHNULL : 0, /* flags */ idx_attnum, BTEqualStrategyNumber, InvalidOid, /* No strategy subtype. */ attnumCollationId(index_rel, idx_attnum), opcode, isnull ? 0 : value); } if (*num_scan_keys > 0) { *result_index_rel = index_rel; break; } else { index_close(index_rel, AccessShareLock); pfree(scankeys); scankeys = NULL; } } return scankeys; } /* * This method will build scan keys for predicates including * SEGMENT BY column with attribute number from compressed chunk * if condition is like <segmentbycol> = <const value>, else * OUT param null_columns is saved with column attribute number. */ ScanKeyData * build_update_delete_scankeys(Relation in_rel, List *heap_filters, int *num_scankeys, Bitmapset **null_columns, bool *delete_only) { ListCell *lc; BatchFilter *filter; int key_index = 0; ScanKeyData *scankeys = palloc0(heap_filters->length * sizeof(ScanKeyData)); foreach (lc, heap_filters) { filter = lfirst(lc); AttrNumber attno = get_attnum(in_rel->rd_id, NameStr(filter->column_name)); Oid typoid = get_atttype(in_rel->rd_id, attno); if (attno == InvalidAttrNumber) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" of relation \"%s\" does not exist", NameStr(filter->column_name), RelationGetRelationName(in_rel)))); bool added = create_segment_filter_scankey(in_rel, NameStr(filter->column_name), filter->strategy, deduce_filter_subtype(filter, typoid), filter->opcode, scankeys, &key_index, null_columns, filter->value ? filter->value->constvalue : 0, filter->is_null_check, filter->is_array_op); /* * When we plan to DELETE directly on compressed chunks we * need to ensure all query constraints could be applied * to the compressed scan and disable direct DELETE when * we are skipping filters. */ if (*delete_only && !added) *delete_only = false; } *num_scankeys = key_index; return scankeys; } static bool create_segment_filter_scankey(Relation in_rel, char *segment_filter_col_name, StrategyNumber strategy, Oid subtype, Oid opcode, ScanKeyData *scankeys, int *num_scankeys, Bitmapset **null_columns, Datum value, bool is_null_check, bool is_array_op) { AttrNumber cmp_attno = get_attnum(in_rel->rd_id, segment_filter_col_name); Assert(cmp_attno != InvalidAttrNumber); /* This should never happen but if it does happen, we can't generate a scan key for * the filter column so just skip it */ if (cmp_attno == InvalidAttrNumber) return false; int flags = is_array_op ? SK_SEARCHARRAY : 0; /* * In PG versions <= 14 NULL values are always considered distinct * from other NULL values and therefore NULLABLE multi-columnn * unique constraints might expose unexpected behaviour in the * presence of NULL values. * Since SK_SEARCHNULL is not supported by heap scans we cannot * build a ScanKey for NOT NULL and instead have to do those * checks manually. */ if (is_null_check) { *null_columns = bms_add_member(*null_columns, cmp_attno); return false; } Oid opr; /* * All btree operators will have a valid strategy here. For * non-btree operators e.g. <> we directly take the opcode * here. We could do the same for btree in certain cases * but some filters get transformed to min/max filters and * won't keep the initial opcode so we would need to disambiguate * between them. */ if (strategy == InvalidStrategy) { opr = opcode; } else { Oid atttypid = TupleDescAttr(in_rel->rd_att, AttrNumberGetAttrOffset(cmp_attno))->atttypid; TypeCacheEntry *tce = lookup_type_cache(atttypid, TYPECACHE_BTREE_OPFAMILY); if (!OidIsValid(tce->btree_opf)) elog(ERROR, "no btree opfamily for type \"%s\"", format_type_be(atttypid)); opr = get_opfamily_member(tce->btree_opf, atttypid, atttypid, strategy); /* * Fall back to btree operator input type when it is binary compatible with * the column type and no operator for column type could be found. */ if (!OidIsValid(opr) && IsBinaryCoercible(atttypid, tce->btree_opintype)) { opr = get_opfamily_member(tce->btree_opf, tce->btree_opintype, tce->btree_opintype, strategy); } /* No operator could be found so we can't create the scankey. */ if (!OidIsValid(opr)) return false; opr = get_opcode(opr); } /* We should never end up here but: no opcode, no optimization */ if (!OidIsValid(opr)) return false; ScanKeyEntryInitialize(&scankeys[(*num_scankeys)++], flags, cmp_attno, strategy, subtype, TupleDescAttr(in_rel->rd_att, AttrNumberGetAttrOffset(cmp_attno)) ->attcollation, opr, value); return true; } /* * Get the subtype for an indexscan from the provided filter. We also * need to handle array constants appropriately. */ static Oid deduce_filter_subtype(BatchFilter *filter, Oid att_typoid) { Oid subtype = InvalidOid; if (!filter->value) return InvalidOid; /* * Check if the filter type is different from the att type. If yes, the * subtype needs to be set appropriately. */ if (att_typoid != filter->value->consttype) { /* For an array type get its element type */ if (filter->is_array_op) subtype = get_element_type(filter->value->consttype); else subtype = filter->value->consttype; } return subtype; } �����������������������������timescaledb-2.23.0/tsl/src/compression/compression_storage.c����������������������������������������0000664�0000000�0000000�00000032675�15100345067�0024253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains functions for manipulating compression related * internal storage objects like creating the underlying tables and * setting storage options. */ #include <postgres.h> #include <access/reloptions.h> #include <access/xact.h> #include <catalog/indexing.h> #include <catalog/objectaccess.h> #include <catalog/objectaddress.h> #include <catalog/pg_class.h> #include <catalog/pg_constraint.h> #include <catalog/toasting.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <nodes/makefuncs.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/syscache.h> #include "compression.h" #include "compression_storage.h" #include "create.h" #include "custom_type_cache.h" #include "extension_constants.h" #include "guc.h" #include "hypertable.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_settings.h" #include "utils.h" #define PRINT_COMPRESSION_TABLE_NAME(buf, prefix, hypertable_id) \ do \ { \ int ret = snprintf(buf, NAMEDATALEN, prefix, hypertable_id); \ if (ret < 0 || ret > NAMEDATALEN) \ { \ ereport(ERROR, \ (errcode(ERRCODE_INTERNAL_ERROR), \ errmsg("bad compression hypertable internal name"))); \ } \ } while (0); static void set_toast_tuple_target_on_chunk(Oid compressed_table_id); static void set_statistics_on_compressed_chunk(Oid compressed_table_id); int32 compression_hypertable_create(Hypertable *ht, Oid owner, Oid tablespace_oid) { ObjectAddress tbladdress; char relnamebuf[NAMEDATALEN]; CatalogSecurityContext sec_ctx; Oid compress_relid; CreateStmt *create; RangeVar *compress_rel; int32 compress_hypertable_id; Assert(!TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)); create = makeNode(CreateStmt); create->tableElts = NIL; create->inhRelations = NIL; create->ofTypename = NULL; create->constraints = NIL; create->options = NULL; create->oncommit = ONCOMMIT_NOOP; create->tablespacename = get_tablespace_name(tablespace_oid); create->if_not_exists = false; /* Invalid tablespace_oid <=> NULL tablespace name */ Assert(!OidIsValid(tablespace_oid) == (create->tablespacename == NULL)); /* create the compression table */ /* NewRelationCreateToastTable calls CommandCounterIncrement */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); compress_hypertable_id = ts_catalog_table_next_seq_id(ts_catalog_get(), HYPERTABLE); PRINT_COMPRESSION_TABLE_NAME(relnamebuf, "_compressed_hypertable_%d", compress_hypertable_id); compress_rel = makeRangeVar(pstrdup(INTERNAL_SCHEMA_NAME), pstrdup(relnamebuf), -1); create->relation = compress_rel; tbladdress = DefineRelation(create, RELKIND_RELATION, owner, NULL, NULL); CommandCounterIncrement(); compress_relid = tbladdress.objectId; ts_copy_relation_acl(ht->main_table_relid, compress_relid, owner); ts_catalog_restore_user(&sec_ctx); ts_hypertable_create_compressed(compress_relid, compress_hypertable_id); return compress_hypertable_id; } Oid compression_chunk_create(Chunk *src_chunk, Chunk *chunk, List *column_defs, Oid tablespace_oid, CompressionSettings *settings) { ObjectAddress tbladdress; CatalogSecurityContext sec_ctx; Datum toast_options; #if PG18_LT char *validnsps[] = HEAP_RELOPT_NAMESPACES; #else const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; #endif Oid owner = ts_rel_get_owner(chunk->hypertable_relid); CreateStmt *create; RangeVar *compress_rel; create = makeNode(CreateStmt); create->tableElts = column_defs; create->inhRelations = NIL; create->ofTypename = NULL; create->constraints = NIL; create->options = NULL; create->oncommit = ONCOMMIT_NOOP; create->tablespacename = get_tablespace_name(tablespace_oid); create->if_not_exists = false; /* Invalid tablespace_oid <=> NULL tablespace name */ Assert(!OidIsValid(tablespace_oid) == (create->tablespacename == NULL)); /* create the compression table */ /* NewRelationCreateToastTable calls CommandCounterIncrement */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); compress_rel = makeRangeVar(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), -1); create->relation = compress_rel; /* Inherit the persistence (LOGGED or UNLOGGED) from the uncompressed chunk */ create->relation->relpersistence = get_rel_persistence(src_chunk->table_id); tbladdress = DefineRelation(create, RELKIND_RELATION, owner, NULL, NULL); CommandCounterIncrement(); chunk->table_id = tbladdress.objectId; ts_copy_relation_acl(chunk->hypertable_relid, chunk->table_id, owner); toast_options = transformRelOptions((Datum) 0, create->options, "toast", validnsps, true, false); (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); NewRelationCreateToastTable(chunk->table_id, toast_options); modify_compressed_toast_table_storage(settings, column_defs, chunk->table_id); set_statistics_on_compressed_chunk(chunk->table_id); set_toast_tuple_target_on_chunk(chunk->table_id); ts_catalog_restore_user(&sec_ctx); create_compressed_chunk_indexes(chunk, settings); return chunk->table_id; } static void set_toast_tuple_target_on_chunk(Oid compressed_table_id) { DefElem def_elem = { .type = T_DefElem, .defname = "toast_tuple_target", .arg = (Node *) makeInteger(ts_guc_debug_toast_tuple_target), .defaction = DEFELEM_SET, .location = -1, }; AlterTableCmd cmd = { .type = T_AlterTableCmd, .subtype = AT_SetRelOptions, .def = (Node *) list_make1(&def_elem), }; AlterTableInternal(compressed_table_id, list_make1(&cmd), true); } static void set_statistics_on_compressed_chunk(Oid compressed_table_id) { Relation table_rel = table_open(compressed_table_id, ShareUpdateExclusiveLock); Relation attrelation = table_open(AttributeRelationId, RowExclusiveLock); TupleDesc table_desc = RelationGetDescr(table_rel); Oid compressed_data_type = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; for (int i = 0; i < table_desc->natts; i++) { Form_pg_attribute attrtuple; HeapTuple tuple; Form_pg_attribute col_attr = TupleDescAttr(table_desc, i); Datum repl_val[Natts_pg_attribute] = { 0 }; bool repl_null[Natts_pg_attribute] = { false }; bool repl_repl[Natts_pg_attribute] = { false }; /* skip system columns */ if (col_attr->attnum <= 0) continue; tuple = SearchSysCacheCopyAttName(RelationGetRelid(table_rel), NameStr(col_attr->attname)); if (!HeapTupleIsValid(tuple)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" of compressed table \"%s\" does not exist", NameStr(col_attr->attname), RelationGetRelationName(table_rel)))); attrtuple = (Form_pg_attribute) GETSTRUCT(tuple); /* The planner should never look at compressed column statistics because * it will not understand them. Statistics on the other columns, * segmentbys and metadata, are very important, so we increase their * target. */ if (col_attr->atttypid == compressed_data_type) repl_val[AttrNumberGetAttrOffset(Anum_pg_attribute_attstattarget)] = Int16GetDatum(0); else repl_val[AttrNumberGetAttrOffset(Anum_pg_attribute_attstattarget)] = Int16GetDatum(1000); repl_repl[AttrNumberGetAttrOffset(Anum_pg_attribute_attstattarget)] = true; tuple = heap_modify_tuple(tuple, RelationGetDescr(attrelation), repl_val, repl_null, repl_repl); CatalogTupleUpdate(attrelation, &tuple->t_self, tuple); InvokeObjectPostAlterHook(RelationRelationId, RelationGetRelid(table_rel), attrtuple->attnum); heap_freetuple(tuple); } table_close(attrelation, NoLock); table_close(table_rel, NoLock); } /* modify storage attributes for toast table columns attached to the * compression table */ void modify_compressed_toast_table_storage(CompressionSettings *settings, List *coldefs, Oid compress_relid) { ListCell *lc; List *cmds = NIL; Oid compresseddata_oid = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; foreach (lc, coldefs) { ColumnDef *cd = lfirst_node(ColumnDef, lc); AttrNumber attno = get_attnum(compress_relid, cd->colname); if (attno != InvalidAttrNumber && get_atttype(compress_relid, attno) == compresseddata_oid) { /* * All columns that pass the datatype check are columns * that are also present in the uncompressed hypertable. * Metadata columns are missing from the uncompressed * hypertable but they do not have compresseddata datatype * and therefore would be skipped. */ attno = get_attnum(settings->fd.relid, cd->colname); Assert(attno != InvalidAttrNumber); Oid typid = get_atttype(settings->fd.relid, attno); CompressionStorage stor = compression_get_toast_storage(compression_get_default_algorithm(typid)); if (stor != TOAST_STORAGE_EXTERNAL) /* external is default storage for toast columns */ { AlterTableCmd *cmd = makeNode(AlterTableCmd); cmd->subtype = AT_SetStorage; cmd->name = pstrdup(cd->colname); Assert(stor == TOAST_STORAGE_EXTENDED); cmd->def = (Node *) makeString("extended"); cmds = lappend(cmds, cmd); } } } if (cmds != NIL) { AlterTableInternal(compress_relid, cmds, false); } } void create_compressed_chunk_indexes(Chunk *chunk, CompressionSettings *settings) { IndexStmt stmt = { .type = T_IndexStmt, .accessMethod = DEFAULT_INDEX_TYPE, .idxname = NULL, .relation = makeRangeVar(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), 0), .tableSpace = get_tablespace_name(get_rel_tablespace(chunk->table_id)), }; NameData index_name; ObjectAddress index_addr; HeapTuple index_tuple; List *indexcols = NIL; StringInfo buf = makeStringInfo(); if (settings->fd.segmentby) { Datum datum; bool isnull; ArrayIterator it = array_create_iterator(settings->fd.segmentby, 0, NULL); while (array_iterate(it, &datum, &isnull)) { IndexElem *segment_elem = makeNode(IndexElem); segment_elem->name = TextDatumGetCString(datum); appendStringInfoString(buf, segment_elem->name); appendStringInfoString(buf, ", "); indexcols = lappend(indexcols, segment_elem); } } SortByDir ordering; SortByNulls nulls_ordering; StringInfo orderby_buf = makeStringInfo(); for (int i = 1; i <= ts_array_length(settings->fd.orderby); i++) { resetStringInfo(orderby_buf); /* Add min metadata column */ IndexElem *orderby_min_elem = makeNode(IndexElem); orderby_min_elem->name = column_segment_min_name(i); if (ts_array_get_element_bool(settings->fd.orderby_desc, i)) { appendStringInfoString(orderby_buf, " DESC"); ordering = SORTBY_DESC; } else { appendStringInfoString(orderby_buf, " ASC"); ordering = SORTBY_ASC; } orderby_min_elem->ordering = ordering; if (ts_array_get_element_bool(settings->fd.orderby_nullsfirst, i)) { if (orderby_min_elem->ordering != SORTBY_DESC) { appendStringInfoString(orderby_buf, " NULLS FIRST"); nulls_ordering = SORTBY_NULLS_FIRST; } else { nulls_ordering = SORTBY_NULLS_DEFAULT; } } else { if (orderby_min_elem->ordering != SORTBY_DESC) { nulls_ordering = SORTBY_NULLS_DEFAULT; } else { appendStringInfoString(orderby_buf, " NULLS LAST"); nulls_ordering = SORTBY_NULLS_LAST; } } orderby_min_elem->nulls_ordering = nulls_ordering; appendStringInfoString(buf, orderby_min_elem->name); appendStringInfoString(buf, orderby_buf->data); appendStringInfoString(buf, ", "); indexcols = lappend(indexcols, orderby_min_elem); /* Add max metadata column */ IndexElem *orderby_max_elem = makeNode(IndexElem); orderby_max_elem->name = column_segment_max_name(i); orderby_max_elem->ordering = orderby_min_elem->ordering; orderby_max_elem->nulls_ordering = orderby_min_elem->nulls_ordering; appendStringInfoString(buf, orderby_max_elem->name); appendStringInfoString(buf, orderby_buf->data); appendStringInfoString(buf, ", "); indexcols = lappend(indexcols, orderby_max_elem); } stmt.indexParams = indexcols; index_addr = DefineIndexCompat(chunk->table_id, &stmt, InvalidOid, /* IndexRelationId */ InvalidOid, /* parentIndexId */ InvalidOid, /* parentConstraintId */ -1, /* total_parts */ false, /* is_alter_table */ false, /* check_rights */ false, /* check_not_in_use */ false, /* skip_build */ false); /* quiet */ index_tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(index_addr.objectId)); if (!HeapTupleIsValid(index_tuple)) elog(ERROR, "cache lookup failed for index relid %u", index_addr.objectId); index_name = ((Form_pg_class) GETSTRUCT(index_tuple))->relname; elog(DEBUG1, "adding index %s ON %s.%s USING BTREE(%s)", NameStr(index_name), NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), buf->data); ReleaseSysCache(index_tuple); } �������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/compression_storage.h����������������������������������������0000664�0000000�0000000�00000001536�15100345067�0024250�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains functions for manipulating compression related * internal storage objects like creating the underlying tables and * setting storage options. */ #include <postgres.h> #include "chunk.h" #include "hypertable.h" int32 compression_hypertable_create(Hypertable *ht, Oid owner, Oid tablespace_oid); Oid compression_chunk_create(Chunk *src_chunk, Chunk *chunk, List *column_defs, Oid tablespace_oid, CompressionSettings *settings); void modify_compressed_toast_table_storage(CompressionSettings *settings, List *coldefs, Oid compress_relid); void create_compressed_chunk_indexes(Chunk *chunk, CompressionSettings *settings); ������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/create.c�����������������������������������������������������0000664�0000000�0000000�00000155540�15100345067�0021426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/reloptions.h> #include <access/tupdesc.h> #include <access/xact.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/objectaccess.h> #include <catalog/pg_am_d.h> #include <catalog/pg_constraint.h> #include <catalog/pg_constraint_d.h> #include <catalog/pg_type.h> #include <catalog/toasting.h> #include <commands/alter.h> #include <commands/defrem.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <common/md5.h> #include <executor/spi.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <parser/parse_type.h> #include <storage/lmgr.h> #include <tcop/utility.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/guc.h> #include <utils/rel.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "compat/compat.h" #include "bgw_policy/policies_v2.h" #include "chunk.h" #include "chunk_index.h" #include "compression.h" #include "compression/compression_storage.h" #include "compression/sparse_index_bloom1.h" #include "create.h" #include "custom_type_cache.h" #include "dimension.h" #include "guc.h" #include "hypertable_cache.h" #include "jsonb_utils.h" #include "trigger.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/compression_settings.h" #include "ts_catalog/continuous_agg.h" #include "utils.h" #include "with_clause/alter_table_with_clause.h" #include "with_clause/create_table_with_clause.h" #include "bgw_policy/compression_api.h" static const char *sparse_index_types[] = { "min", "max", "bloom1" }; #ifdef USE_ASSERT_CHECKING static bool is_sparse_index_type(const char *type) { for (size_t i = 0; i < sizeof(sparse_index_types) / sizeof(sparse_index_types[0]); i++) { if (strcmp(sparse_index_types[i], type) == 0) { return true; } } return false; } #endif static void validate_hypertable_for_compression(Hypertable *ht); static List *build_columndefs(CompressionSettings *settings, Oid src_reloid); static ColumnDef *build_columndef_singlecolumn(const char *colname, Oid typid); static void compression_settings_set_manually_for_create(Hypertable *ht, CompressionSettings *settings, WithClauseResult *with_clause_options); static void compression_settings_set_manually_for_alter(Hypertable *ht, CompressionSettings *settings, WithClauseResult *with_clause_options); static void compression_settings_set_defaults(Hypertable *ht, CompressionSettings *settings, WithClauseResult *with_clause_options); static char * compression_column_segment_metadata_name(const char *type, int16 column_index) { Assert(is_sparse_index_type(type)); char *buf = palloc(sizeof(char) * NAMEDATALEN); Assert(column_index > 0); int ret = snprintf(buf, NAMEDATALEN, COMPRESSION_COLUMN_METADATA_PATTERN_V1, type, column_index); if (ret < 0 || ret > NAMEDATALEN) { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("bad segment metadata column name"))); } return buf; } char * column_segment_min_name(int16 column_index) { return compression_column_segment_metadata_name("min", column_index); } char * column_segment_max_name(int16 column_index) { return compression_column_segment_metadata_name("max", column_index); } /* * Get metadata name for a given column name and metadata type, format version 2. * We can't reference the attribute numbers, because they can change after * drop/restore if we had any dropped columns. * We might have to truncate the column names to fit into the NAMEDATALEN here, * in this case we disambiguate them with their md5 hash. */ char * compressed_column_metadata_name_v2(const char *metadata_type, const char *column_name) { Assert(is_sparse_index_type(metadata_type)); Assert(strlen(metadata_type) <= 6); const int len = strlen(column_name); Assert(len < NAMEDATALEN); /* * We have to fit the name into NAMEDATALEN - 1 which is 63 bytes: * 12 (_ts_meta_v2_) + 6 (metadata_type) + 1 (_) + x (column_name) + 1 (_) + 4 (hash) = 63; * x = 63 - 24 = 39. */ char *result; if (len > 39) { const char *errstr = NULL; char hash[33]; Ensure(pg_md5_hash(column_name, len, hash, &errstr), "md5 computation failure"); result = psprintf("_ts_meta_v2_%.6s_%.4s_%.39s", metadata_type, hash, column_name); } else { result = psprintf("_ts_meta_v2_%.6s_%.39s", metadata_type, column_name); } Assert(strlen(result) < NAMEDATALEN); return result; } int compressed_column_metadata_attno(const CompressionSettings *settings, Oid chunk_reloid, AttrNumber chunk_attno, Oid compressed_reloid, char *metadata_type) { Assert(is_sparse_index_type(metadata_type)); char *attname = get_attname(chunk_reloid, chunk_attno, /* missing_ok = */ false); int16 orderby_pos = ts_array_position(settings->fd.orderby, attname); if (orderby_pos != 0 && (strcmp(metadata_type, "min") == 0 || strcmp(metadata_type, "max") == 0)) { char *metadata_name = compression_column_segment_metadata_name(metadata_type, orderby_pos); return get_attnum(compressed_reloid, metadata_name); } char *metadata_name = compressed_column_metadata_name_v2(metadata_type, attname); return get_attnum(compressed_reloid, metadata_name); } /* * The heuristic for whether we should use the bloom filter sparse index. */ static bool should_create_bloom_sparse_index(Oid atttypid, TypeCacheEntry *type, Oid src_reloid) { /* * The index must be enabled by the GUC. */ if (!ts_guc_enable_sparse_index_bloom) { return false; } /* * The type must be hashable. For some types we use our own hash functions * which have better characteristics. */ FmgrInfo *finfo = NULL; if (bloom1_get_hash_function(atttypid, &finfo) == NULL) { return false; } /* * For time types, we expect: * 1) range queries, not equality, * 2) correlation with the orderby columns, e.g. creation time correlates * with the update time that is used as orderby. * This makes minmax indexes more suitable than bloom filters. */ if (atttypid == TIMESTAMPTZOID || atttypid == TIMESTAMPOID || atttypid == TIMEOID || atttypid == TIMETZOID || atttypid == DATEOID) { return false; } /* * For fractional arithmetic types, equality queries are unlikely. */ if (atttypid == FLOAT4OID || atttypid == FLOAT8OID || atttypid == NUMERICOID) { return false; } /* * Bloom filters for 1k elements with 2% false positive rate require about * one byte per element, so there's no point in using them for smaller data * types that typically compress to less than that. */ if (type->typlen > 0 && type->typlen < 4) { return false; } return true; } static ColumnDef * create_sparse_index_column_def(Form_pg_attribute attr, const char *metadata_type) { Assert(is_sparse_index_type(metadata_type)); Assert(strlen(metadata_type) <= 6); ColumnDef *column_def = NULL; const bool is_bloom = strcmp(metadata_type, "bloom1") == 0; if (is_bloom) { /* * The type must be hashable. For some types we use our own hash functions * which have better characteristics. */ FmgrInfo *finfo = NULL; if (bloom1_get_hash_function(attr->atttypid, &finfo) == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid bloom filter column type %s", format_type_be(attr->atttypid)), errdetail("Could not identify a hashing function for the type."))); column_def = makeColumnDef(compressed_column_metadata_name_v2(metadata_type, NameStr(attr->attname)), ts_custom_type_cache_get(CUSTOM_TYPE_BLOOM1)->type_oid, /* typmod = */ -1, /* collation = */ 0); /* * We have our custom compression for bloom filters, and the * result is almost incompressible with lz4 (~2%), so disable it. */ column_def->storage = TYPSTORAGE_EXTERNAL; } else /* either min or max */ { TypeCacheEntry *type = lookup_type_cache(attr->atttypid, TYPECACHE_LT_OPR); /* * a comparison operator if required for min max operations */ if (!OidIsValid(type->lt_opr)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid minmax column type %s", format_type_be(attr->atttypid)), errdetail("Could not identify a less-than operator for the type."))); column_def = makeColumnDef(compressed_column_metadata_name_v2(metadata_type, NameStr(attr->attname)), attr->atttypid, attr->atttypmod, attr->attcollation); if (attr->attstorage != TYPSTORAGE_PLAIN) { column_def->storage = TYPSTORAGE_MAIN; } } return column_def; } /* * return the columndef list for compressed hypertable. * we do this by getting the source hypertable's attrs, * 1. validate the segmentby cols and orderby cols exists in this list and * 2. create the columndefs for the new compressed hypertable * segmentby_cols have same datatype as the original table * all other cols have COMPRESSEDDATA_TYPE type */ static List * build_columndefs(CompressionSettings *settings, Oid src_reloid) { Oid compresseddata_oid = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; ArrayType *segmentby = settings->fd.segmentby; List *compressed_column_defs = NIL; List *segmentby_column_defs = NIL; Relation rel = table_open(src_reloid, AccessShareLock); TupleDesc tupdesc = rel->rd_att; for (int attoffset = 0; attoffset < tupdesc->natts; attoffset++) { Form_pg_attribute attr = TupleDescAttr(tupdesc, attoffset); if (attr->attisdropped) continue; if (strncmp(NameStr(attr->attname), COMPRESSION_COLUMN_METADATA_PREFIX, strlen(COMPRESSION_COLUMN_METADATA_PREFIX)) == 0) ereport(ERROR, (errcode(ERRCODE_RESERVED_NAME), errmsg("cannot convert tables with reserved column prefix '%s'", COMPRESSION_COLUMN_METADATA_PREFIX))); bool is_segmentby = ts_array_is_member(segmentby, NameStr(attr->attname)); if (is_segmentby) { segmentby_column_defs = lappend(segmentby_column_defs, makeColumnDef(NameStr(attr->attname), attr->atttypid, attr->atttypmod, attr->attcollation)); continue; } /* * This is either an orderby or a normal compressed column. We want to * have metadata for some of them. Put the metadata columns before the * respective compressed column, because they are accessed before * decompression. */ const bool is_orderby = ts_array_is_member(settings->fd.orderby, NameStr(attr->attname)); if (is_orderby) { int index = ts_array_position(settings->fd.orderby, NameStr(attr->attname)); TypeCacheEntry *type = lookup_type_cache(attr->atttypid, TYPECACHE_LT_OPR); /* * We must be able to create the metadata for the orderby columns, * because it is required for sorting. */ if (!OidIsValid(type->lt_opr)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("invalid ordering column type %s", format_type_be(attr->atttypid)), errdetail("Could not identify a less-than operator for the type."))); /* segment_meta min and max columns */ ColumnDef *def = makeColumnDef(column_segment_min_name(index), attr->atttypid, attr->atttypmod, attr->attcollation); def->storage = TYPSTORAGE_PLAIN; compressed_column_defs = lappend(compressed_column_defs, def); def = makeColumnDef(column_segment_max_name(index), attr->atttypid, attr->atttypmod, attr->attcollation); def->storage = TYPSTORAGE_PLAIN; compressed_column_defs = lappend(compressed_column_defs, def); } else if (settings->fd.index) { /* check sparse index columndefs is applicable */ bool is_bloom = ts_contains_sparse_index_config(settings, NameStr(attr->attname), ts_sparse_index_type_names [_SparseIndexTypeEnumBloom]); bool is_minmax = ts_contains_sparse_index_config(settings, NameStr(attr->attname), ts_sparse_index_type_names [_SparseIndexTypeEnumMinmax]); /* * We allow only one sparse index per column. Columns used in the ORDER BY * clause implicitly have a minmax index and adding a bloom filter on them is not * allowed. * * The parser is expected to enforce this constraint earlier, but we check again * here as a safeguard. */ Ensure((!is_bloom || !is_minmax), "Should not create bloom filter for minmax column \"%s\"", NameStr(attr->attname)); /* build sparse index columndefs if applicable */ if (is_bloom) { if (!ts_guc_enable_sparse_index_bloom) { ereport(WARNING, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("Creating bloom sparse index is disabled"), errhint("Either set \"enable_sparse_index_bloom\" to true or remove " "the bloom filter indexes from \"sparse_index\" configuration " "of the hypertable."))); } /* * Add bloom filter sparse index for this column. */ ColumnDef *bloom_column_def = create_sparse_index_column_def(attr, "bloom1"); compressed_column_defs = lappend(compressed_column_defs, bloom_column_def); } else if (is_minmax) { /* * Add minmax sparse index for this column. */ ColumnDef *def = create_sparse_index_column_def(attr, "min"); compressed_column_defs = lappend(compressed_column_defs, def); def = create_sparse_index_column_def(attr, "max"); compressed_column_defs = lappend(compressed_column_defs, def); } } compressed_column_defs = lappend(compressed_column_defs, makeColumnDef(NameStr(attr->attname), compresseddata_oid, /* typmod = */ -1, /* collOid = */ InvalidOid)); } /* * Add the metadata columns. Count is always accessed, so put it first. */ List *all_column_defs = list_make1(makeColumnDef(COMPRESSION_COLUMN_METADATA_COUNT_NAME, INT4OID, -1 /* typemod */, 0 /*collation*/)); /* * Then, put all segmentby columns. They are likely to be used in filters * before decompression. */ all_column_defs = list_concat(all_column_defs, segmentby_column_defs); /* * Then, put all the compressed columns. */ all_column_defs = list_concat(all_column_defs, compressed_column_defs); table_close(rel, AccessShareLock); return all_column_defs; } /* use this api for the case when you add a single column to a table that already has * compression setup * such as ALTER TABLE xyz ADD COLUMN ..... */ static ColumnDef * build_columndef_singlecolumn(const char *colname, Oid typid) { Oid compresseddata_oid = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; if (strncmp(colname, COMPRESSION_COLUMN_METADATA_PREFIX, strlen(COMPRESSION_COLUMN_METADATA_PREFIX)) == 0) ereport(ERROR, (errcode(ERRCODE_RESERVED_NAME), errmsg("cannot convert tables with reserved column prefix '%s'", COMPRESSION_COLUMN_METADATA_PREFIX))); return makeColumnDef(colname, compresseddata_oid, -1 /*typmod*/, 0 /*collation*/); } /* * Create compress chunk for specific table. * * If table_id is InvalidOid, create a new table. * */ Chunk * create_compress_chunk(Hypertable *compress_ht, Chunk *src_chunk, Oid table_id) { Catalog *catalog = ts_catalog_get(); CatalogSecurityContext sec_ctx; Chunk *compress_chunk; int namelen; Oid tablespace_oid; Assert(compress_ht->space->num_dimensions == 0); /* Create a new catalog entry for chunk based on uncompressed chunk */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); compress_chunk = ts_chunk_create_base(ts_catalog_table_next_seq_id(catalog, CHUNK), 0, RELKIND_RELATION); ts_catalog_restore_user(&sec_ctx); compress_chunk->fd.hypertable_id = compress_ht->fd.id; compress_chunk->hypertable_relid = compress_ht->main_table_relid; namestrcpy(&compress_chunk->fd.schema_name, INTERNAL_SCHEMA_NAME); if (OidIsValid(table_id)) { Relation table_rel = table_open(table_id, AccessShareLock); strncpy(NameStr(compress_chunk->fd.table_name), RelationGetRelationName(table_rel), NAMEDATALEN); table_close(table_rel, AccessShareLock); } else { /* Fail if we overflow the name limit */ namelen = snprintf(NameStr(compress_chunk->fd.table_name), NAMEDATALEN, "compress%s_%d_chunk", NameStr(compress_ht->fd.associated_table_prefix), compress_chunk->fd.id); if (namelen >= NAMEDATALEN) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("invalid name \"%s\" for compressed chunk", NameStr(compress_chunk->fd.table_name)), errdetail("The associated table prefix is too long."))); } /* Insert chunk */ ts_chunk_insert_lock(compress_chunk, RowExclusiveLock); /* Create the actual table relation for the chunk * Note that we have to pick the tablespace here as the compressed ht doesn't have dimensions * on which to base this decision. We simply pick the same tablespace as the uncompressed chunk * for now. */ tablespace_oid = get_rel_tablespace(src_chunk->table_id); CompressionSettings *settings = ts_compression_settings_get(src_chunk->hypertable_relid); /* * On hypertables created with CREATE TABLE ... WITH we enable compression * by default but do not create CompressionSettings immediately assuming * that we have more information available when the first compression * is actually triggered allowing us to generate better compression * settings. */ if (!settings) { settings = ts_compression_settings_create(src_chunk->hypertable_relid, InvalidOid, NULL, NULL, NULL, NULL, NULL); } Hypertable *ht = ts_hypertable_get_by_id(src_chunk->fd.hypertable_id); compression_settings_set_defaults(ht, settings, ts_alter_table_with_clause_parse(NIL)); if (OidIsValid(table_id)) compress_chunk->table_id = table_id; else { List *column_defs = build_columndefs(settings, src_chunk->table_id); compress_chunk->table_id = compression_chunk_create(src_chunk, compress_chunk, column_defs, tablespace_oid, settings); } if (!OidIsValid(compress_chunk->table_id)) elog(ERROR, "could not create columnstore chunk table"); /* Materialize current compression settings for this chunk */ ts_compression_settings_materialize(settings, src_chunk->table_id, compress_chunk->table_id); /* if the src chunk is not in the default tablespace, the compressed indexes * should also be in a non-default tablespace. IN the usual case, this is inferred * from the hypertable's and chunk's tablespace info. We do not propagate * attach_tablespace settings to the compressed hypertable. So we have to explicitly * pass the tablespace information here */ ts_chunk_index_create_all(compress_chunk->fd.hypertable_id, compress_chunk->hypertable_relid, compress_chunk->fd.id, compress_chunk->table_id, tablespace_oid); return compress_chunk; } /* Add the hypertable time column to the end of the orderby list if * it's not already in the orderby or segmentby. */ static OrderBySettings add_time_to_order_by_if_not_included(OrderBySettings obs, ArrayType *segmentby, Hypertable *ht) { const Dimension *time_dim; const char *time_col_name; bool found = false; time_dim = hyperspace_get_open_dimension(ht->space, 0); if (!time_dim) return obs; time_col_name = get_attname(ht->main_table_relid, time_dim->column_attno, false); if (ts_array_is_member(obs.orderby, time_col_name)) found = true; if (ts_array_is_member(segmentby, time_col_name)) found = true; if (!found) { /* Add time DESC NULLS FIRST to order by settings */ obs.orderby = ts_array_add_element_text(obs.orderby, pstrdup(time_col_name)); obs.orderby_desc = ts_array_add_element_bool(obs.orderby_desc, true); obs.orderby_nullsfirst = ts_array_add_element_bool(obs.orderby_nullsfirst, true); } return obs; } /* returns list of constraints that need to be cloned on the compressed hypertable * This is limited to foreign key constraints now */ static void validate_existing_constraints(Hypertable *ht, CompressionSettings *settings) { Relation pg_constr; SysScanDesc scan; ScanKeyData scankey; HeapTuple tuple; ArrayType *arr; Assert(ht->main_table_relid == settings->fd.relid); pg_constr = table_open(ConstraintRelationId, AccessShareLock); ScanKeyInit(&scankey, Anum_pg_constraint_conrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(settings->fd.relid)); scan = systable_beginscan(pg_constr, ConstraintRelidTypidNameIndexId, true, NULL, 1, &scankey); while (HeapTupleIsValid(tuple = systable_getnext(scan))) { Form_pg_constraint form = (Form_pg_constraint) GETSTRUCT(tuple); /* * We check primary, unique, and exclusion constraints. */ if (form->contype == CONSTRAINT_CHECK || form->contype == CONSTRAINT_TRIGGER #if PG17_GE || form->contype == CONSTRAINT_NOTNULL /* CONSTRAINT_NOTNULL introduced in PG17, see b0e96f311985 */ #endif ) { continue; } else if (form->contype == CONSTRAINT_EXCLUSION) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("constraint %s is not supported for converting to columnstore", NameStr(form->conname)), errhint("Exclusion constraints are not supported on hypertables that are " "converted to columnstore."))); } else { int j, numkeys; int16 *attnums; bool is_null; /* Extract the conkey array, ie, attnums of PK's columns */ Datum adatum = heap_getattr(tuple, Anum_pg_constraint_conkey, RelationGetDescr(pg_constr), &is_null); if (is_null) { Oid oid = heap_getattr(tuple, Anum_pg_constraint_oid, RelationGetDescr(pg_constr), &is_null); elog(ERROR, "null conkey for constraint %u", oid); } arr = DatumGetArrayTypeP(adatum); /* ensure not toasted */ numkeys = ts_array_length(arr); attnums = (int16 *) ARR_DATA_PTR(arr); for (j = 0; j < numkeys; j++) { const char *attname = get_attname(settings->fd.relid, attnums[j], false); /* is colno a segment-by or order_by column */ if (!form->conindid && (settings->fd.segmentby && settings->fd.orderby) && !ts_array_is_member(settings->fd.segmentby, attname) && !ts_array_is_member(settings->fd.orderby, attname)) ereport(WARNING, (errmsg("column \"%s\" should be used for segmenting or ordering", attname))); } } } systable_endscan(scan); table_close(pg_constr, AccessShareLock); } /* * Validate existing indexes on the hypertable. Note that there can be indexes * that do not have a corresponding constraint. * * We pass in a list of indexes that we should ignore since these are checked * by the constraint checking above. */ static void validate_existing_indexes(Hypertable *ht, CompressionSettings *settings) { Relation pg_index; HeapTuple htup; ScanKeyData skey; SysScanDesc indscan; ScanKeyInit(&skey, Anum_pg_index_indrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(ht->main_table_relid)); pg_index = table_open(IndexRelationId, AccessShareLock); indscan = systable_beginscan(pg_index, IndexIndrelidIndexId, true, NULL, 1, &skey); while (HeapTupleIsValid(htup = systable_getnext(indscan))) { Form_pg_index index = (Form_pg_index) GETSTRUCT(htup); /* We can ignore indexes that are being dropped, invalid indexes, * exclusion indexes, and any indexes checked by the constraint * checking. We can also skip checks below if the index is not a * unique index. */ if (!index->indislive || !index->indisvalid || index->indisexclusion || !index->indisunique) continue; /* Now we check that all columns of the unique index are part of the * segmentby columns. */ for (int i = 0; i < index->indnkeyatts; i++) { int attno = index->indkey.values[i]; if (attno == 0) continue; /* skip check for expression column */ const char *attname = get_attname(ht->main_table_relid, attno, false); if ((settings->fd.segmentby && settings->fd.orderby) && !ts_array_is_member(settings->fd.segmentby, attname) && !ts_array_is_member(settings->fd.orderby, attname)) ereport(WARNING, (errmsg("column \"%s\" should be used for segmenting or ordering", attname))); } } systable_endscan(indscan); table_close(pg_index, AccessShareLock); } static void drop_existing_compression_table(Hypertable *ht) { if (ts_chunk_exists_with_compression(ht->fd.id)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot drop columnstore-enabled hypertable with columnstore chunks"))); Hypertable *compressed = ts_hypertable_get_by_id(ht->fd.compressed_hypertable_id); if (compressed == NULL) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("columnstore-enabled hypertable not found"), errdetail("columnstore was enabled on \"%s\", but its internal" " columnstore hypertable could not be found.", NameStr(ht->fd.table_name)))); /* need to drop the old compressed hypertable in case the segment by columns changed (and * thus the column types of compressed hypertable need to change) */ ts_hypertable_drop(compressed, DROP_RESTRICT); ts_hypertable_unset_compressed(ht); } static bool disable_compression(Hypertable *ht, WithClauseResult *with_clause_options) { if (!TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) /* compression is not enabled, so just return */ return false; if (ts_chunk_exists_with_compression(ht->fd.id)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot disable columnstore on hypertable with columnstore chunks"))); if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) drop_existing_compression_table(ht); else { ts_hypertable_unset_compressed(ht); } ts_compression_settings_delete(ht->main_table_relid); return true; } /* Add column to internal compression table */ static void add_column_to_compression_table(Oid relid, CompressionSettings *settings, ColumnDef *coldef) { AlterTableCmd *addcol_cmd; /* create altertable stmt to add column to the compressed hypertable */ // Assert(TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(compress_ht)); addcol_cmd = makeNode(AlterTableCmd); addcol_cmd->subtype = AT_AddColumn; addcol_cmd->def = (Node *) coldef; addcol_cmd->missing_ok = false; /* alter the table and add column */ ts_alter_table_with_event_trigger(relid, NULL, list_make1(addcol_cmd), true); modify_compressed_toast_table_storage(settings, list_make1(coldef), relid); } /* Drop column from internal compression table */ static void drop_column_from_compression_table(Oid relid, char *name) { AlterTableCmd *cmd; /* create altertable stmt to drop column from the compressed hypertable */ cmd = makeNode(AlterTableCmd); cmd->subtype = AT_DropColumn; cmd->name = name; cmd->missing_ok = true; /* alter the table and drop column */ ts_alter_table_with_event_trigger(relid, NULL, list_make1(cmd), true); } static bool update_compress_chunk_time_interval(Hypertable *ht, WithClauseResult *with_clause_options) { const Dimension *time_dim = hyperspace_get_open_dimension(ht->space, 0); if (!time_dim) return false; Interval *compress_interval = ts_compress_hypertable_parse_chunk_time_interval(with_clause_options, ht); if (!compress_interval) { return false; } int64 compress_interval_usec = ts_interval_value_to_internal(IntervalPGetDatum(compress_interval), INTERVALOID); if (compress_interval_usec % time_dim->fd.interval_length > 0) elog(WARNING, "compress chunk interval is not a multiple of chunk interval, you should use a " "factor of chunk interval to merge as much as possible"); return ts_hypertable_set_compress_interval(ht, compress_interval_usec); } /* * enables compression for the passed in table by * creating a compression hypertable with special properties * Note: caller should check security permissions * * Return true if compression was enabled, false otherwise. * * Steps: * 1. Check existing constraints on the table -> can we support them with compression? * 2. Create internal compression table + mark hypertable as compression enabled * 3. Add catalog entries to hypertable_compression to record compression settings. * 4. Copy constraints to internal compression table */ bool tsl_process_compress_table(Hypertable *ht, WithClauseResult *with_clause_options) { int32 compress_htid; bool compress_disable = !with_clause_options[AlterTableFlagColumnstore].is_default && !DatumGetBool(with_clause_options[AlterTableFlagColumnstore].parsed); CompressionSettings *settings; ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); validate_hypertable_for_compression(ht); /* Lock the uncompressed ht in exclusive mode and keep till end of txn */ LockRelationOid(ht->main_table_relid, AccessExclusiveLock); /* reload info after lock */ ht = ts_hypertable_get_by_id(ht->fd.id); if (compress_disable) { return disable_compression(ht, with_clause_options); } if (!with_clause_options[AlterTableFlagCompressChunkTimeInterval].is_default) { update_compress_chunk_time_interval(ht, with_clause_options); } settings = ts_compression_settings_get(ht->main_table_relid); if (!settings) { settings = ts_compression_settings_create(ht->main_table_relid, InvalidOid, NULL, NULL, NULL, NULL, NULL); } compression_settings_set_manually_for_alter(ht, settings, with_clause_options); if (!TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { /* take explicit locks on catalog tables and keep them till end of txn */ LockRelationOid(catalog_get_table_id(ts_catalog_get(), HYPERTABLE), RowExclusiveLock); /* Check if we can create a compressed hypertable with existing * constraints and indexes. */ validate_existing_constraints(ht, settings); validate_existing_indexes(ht, settings); Oid ownerid = ts_rel_get_owner(ht->main_table_relid); Oid tablespace_oid = get_rel_tablespace(ht->main_table_relid); compress_htid = compression_hypertable_create(ht, ownerid, tablespace_oid); ts_hypertable_set_compressed(ht, compress_htid); } /* * Check for suboptimal compressed chunk merging configuration * * When compress_chunk_time_interval is configured to merge chunks during compression the * primary dimension should be the first compress_orderby column otherwise chunk merging will * require decompression. */ Dimension *dim = ts_hyperspace_get_mutable_dimension(ht->space, DIMENSION_TYPE_OPEN, 0); if (dim && dim->fd.compress_interval_length && ts_array_position(settings->fd.orderby, NameStr(dim->fd.column_name)) != 1) { ereport(WARNING, (errcode(ERRCODE_WARNING), errmsg("compress_chunk_time_interval configured and primary dimension not " "first column in compress_orderby"), errhint("consider setting \"%s\" as first compress_orderby column", NameStr(dim->fd.column_name)))); } /* do not release any locks, will get released by xact end */ return true; } /* * Verify uncompressed hypertable is compatible with conpression */ static void validate_hypertable_for_compression(Hypertable *ht) { if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot compress internal columnstore hypertable"))); } /*check row security settings for the table */ if (ts_has_row_security(ht->main_table_relid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("columnstore cannot be used on table with row security"))); Relation rel = table_open(ht->main_table_relid, AccessShareLock); TupleDesc tupdesc = RelationGetDescr(rel); /* * This is only a rough estimate and the actual row size might be different. * We use this only to show a warning when the row size is close to the * maximum row size. */ Size row_size = MAXALIGN(SizeofHeapTupleHeader); row_size += 8; /* sequence_num */ row_size += 4; /* count */ row_size += 16; /* min/max */ for (int attno = 0; attno < tupdesc->natts; attno++) { Form_pg_attribute attr = TupleDescAttr(tupdesc, attno); if (attr->attisdropped) continue; row_size += 18; /* assume 18 bytes for each compressed column (varlena) */ if (strncmp(NameStr(attr->attname), COMPRESSION_COLUMN_METADATA_PREFIX, strlen(COMPRESSION_COLUMN_METADATA_PREFIX)) == 0) ereport(ERROR, (errcode(ERRCODE_RESERVED_NAME), errmsg("cannot convert tables with reserved column prefix '%s' to columnstore", COMPRESSION_COLUMN_METADATA_PREFIX))); } if (row_size > MaxHeapTupleSize) { ereport(WARNING, (errmsg("compressed row size might exceed maximum row size"), errdetail("Estimated row size of columnstore-enabled hypertable is %zu. This " "exceeds the " "maximum size of %zu and can cause conversion of chunks to columnstore " "to fail.", row_size, MaxHeapTupleSize))); } /* * Check that all triggers are ok for compressed tables. */ Relation pg_trigger = table_open(TriggerRelationId, AccessShareLock); HeapTuple tuple; ScanKeyData key; ScanKeyInit(&key, Anum_pg_trigger_tgrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(ht->main_table_relid)); SysScanDesc scan = systable_beginscan(pg_trigger, TriggerRelidNameIndexId, true, NULL, 1, &key); while (HeapTupleIsValid(tuple = systable_getnext(scan))) { bool oldtable_isnull; Form_pg_trigger trigrec = (Form_pg_trigger) GETSTRUCT(tuple); /* * We currently don't support transition tables for DELETE triggers * on compressed tables because deleting a complete segment will not build a * transition table for the delete. */ fastgetattr(tuple, Anum_pg_trigger_tgoldtable, pg_trigger->rd_att, &oldtable_isnull); if (!oldtable_isnull && !TRIGGER_FOR_ROW(trigrec->tgtype) && TRIGGER_FOR_DELETE(trigrec->tgtype)) ereport(ERROR, errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("DELETE triggers with transition tables not supported")); } systable_endscan(scan); table_close(pg_trigger, AccessShareLock); table_close(rel, AccessShareLock); } /* * Get the default segment by value for a hypertable */ static ArrayType * compression_setting_segmentby_get_default(const Hypertable *ht) { StringInfoData command; StringInfoData result; int res; ArrayType *column_res = NULL; Datum datum; text *message; bool isnull; MemoryContext upper = CurrentMemoryContext; MemoryContext old; int32 confidence = -1; Oid default_segmentby_fn = ts_guc_default_segmentby_fn_oid(); if (!OidIsValid(default_segmentby_fn)) { elog(LOG_SERVER_ONLY, "segment_by default: hypertable=\"%s\" columns=\"\" function: \"\" confidence=-1", get_rel_name(ht->main_table_relid)); return NULL; } /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); initStringInfo(&command); appendStringInfo(&command, "SELECT " " (SELECT array_agg(x) " " FROM jsonb_array_elements_text(seg_by->'columns') t(x))::text[], " " seg_by->>'message', " " (seg_by->>'confidence')::int " "FROM %s.%s(%d) seg_by", quote_identifier(get_namespace_name(get_func_namespace(default_segmentby_fn))), quote_identifier(get_func_name(default_segmentby_fn)), ht->main_table_relid); if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); res = SPI_execute(command.data, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not get the default segment by for a hypertable \"%s\"", get_rel_name(ht->main_table_relid))))); old = MemoryContextSwitchTo(upper); datum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); if (!isnull) column_res = DatumGetArrayTypePCopy(datum); MemoryContextSwitchTo(old); datum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull); if (!isnull) { message = DatumGetTextPP(datum); elog(LOG_SERVER_ONLY, "there was some uncertainty picking the default segment by for the hypertable: %s", text_to_cstring(message)); } datum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull); if (!isnull) { confidence = DatumGetInt32(datum); } pfree(command.data); /* Reset search path since this can be executed as part of a larger transaction */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); initStringInfo(&result); ts_array_append_stringinfo(column_res, &result); elog(LOG_SERVER_ONLY, "segment_by default: hypertable=\"%s\" columns=\"%s\" function: \"%s.%s\" confidence=%d", get_rel_name(ht->main_table_relid), result.data, get_namespace_name(get_func_namespace(default_segmentby_fn)), get_func_name(default_segmentby_fn), confidence); pfree(result.data); return column_res; } /* * Get the default segment by value for a hypertable */ static OrderBySettings compression_setting_orderby_get_default(Hypertable *ht, ArrayType *segmentby) { StringInfoData command; int res; text *column_res = NULL; Datum datum; text *message; bool isnull; MemoryContext upper = CurrentMemoryContext; MemoryContext old; char *orderby; int32 confidence = -1; Oid types[] = { TEXTARRAYOID }; Datum values[] = { PointerGetDatum(segmentby) }; char nulls[] = { segmentby == NULL ? 'n' : 'v' }; Oid orderby_fn = ts_guc_default_orderby_fn_oid(); if (!OidIsValid(orderby_fn)) { /* fallback to original logic */ OrderBySettings obs = (OrderBySettings){ 0 }; obs = add_time_to_order_by_if_not_included(obs, segmentby, ht); elog(LOG_SERVER_ONLY, "order_by default: hypertable=\"%s\" function=\"\" confidence=-1", get_rel_name(ht->main_table_relid)); return obs; } /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); initStringInfo(&command); appendStringInfo(&command, "SELECT " " (SELECT string_agg(x, ', ') FROM " "jsonb_array_elements_text(seg_by->'clauses') " "t(x))::text, " " seg_by->>'message', " " (seg_by->>'confidence')::int " "FROM %s.%s(%d, coalesce($1, array[]::text[])) seg_by", quote_identifier(get_namespace_name(get_func_namespace(orderby_fn))), quote_identifier(get_func_name(orderby_fn)), ht->main_table_relid); if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); res = SPI_execute_with_args(command.data, 1, types, values, nulls, true /* read_only */, 0 /*count*/); if (res < 0) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), (errmsg("could not get the default order by for a hypertable \"%s\"", get_rel_name(ht->main_table_relid))))); old = MemoryContextSwitchTo(upper); datum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); if (!isnull) column_res = DatumGetTextPCopy(datum); MemoryContextSwitchTo(old); datum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull); if (!isnull) { message = DatumGetTextPP(datum); elog(LOG_SERVER_ONLY, "there was some uncertainty picking the default order by for the hypertable: %s", text_to_cstring(message)); } datum = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull); if (!isnull) { confidence = DatumGetInt32(datum); } /* Reset search path since this can be executed as part of a larger transaction */ AtEOXact_GUC(false, save_nestlevel); pfree(command.data); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); if (column_res != NULL) orderby = TextDatumGetCString(PointerGetDatum(column_res)); else orderby = ""; elog(LOG_SERVER_ONLY, "order_by default: hypertable=\"%s\" clauses=\"%s\" function=\"%s.%s\" confidence=%d", get_rel_name(ht->main_table_relid), orderby, get_namespace_name(get_func_namespace(orderby_fn)), get_func_name(orderby_fn), confidence); if (*orderby == '\0') { return (OrderBySettings){ 0 }; } return ts_compress_parse_order_collist(orderby, ht); } /* sparse indexes will only be set by default if there was no configuration */ static bool can_set_default_sparse_index(CompressionSettings *settings) { return (settings->fd.index == NULL) || !ts_jsonb_has_key_value_str_field(settings->fd.index, ts_sparse_index_common_keys[SparseIndexKeySource], ts_sparse_index_source_names [_SparseIndexSourceEnumConfig]); } static Jsonb * compression_setting_sparse_index_get_default(Hypertable *ht, CompressionSettings *settings) { bool has_object = false; Bitmapset *sparse_index_columns = NULL; JsonbParseState *parse_state = NULL; /* * Sparse indexes are only created automatically if they are not set in compression settings */ if (!ts_guc_auto_sparse_indexes || !can_set_default_sparse_index(settings)) return NULL; /* * Check which columns have btree indexes. We will create sparse minmax * indexes for them in compressed chunk. */ Relation rel = table_open(ht->main_table_relid, AccessShareLock); ListCell *lc; List *index_oids = RelationGetIndexList(rel); pushJsonbValue(&parse_state, WJB_BEGIN_ARRAY, NULL); foreach (lc, index_oids) { Oid index_oid = lfirst_oid(lc); Relation index_rel = index_open(index_oid, AccessShareLock); IndexInfo *index_info = BuildIndexInfo(index_rel); index_close(index_rel, NoLock); /* * We want to create the sparse minmax index, if it can satisfy the same * kinds of queries as the uncompressed index. The simplest case is btree * which can satisfy equality and comparison tests, same as sparse minmax. * * If an uncompressed column has an index, we want to create a * sparse index for it as well. A sparse index can't satisfy ordering * queries, but at least we can use a bloom index to satisfy equality * queries. Create it when we have uncompressed index types that can * also satisfy equality. */ if (index_info->ii_Am != BTREE_AM_OID && index_info->ii_Am != HASH_AM_OID && index_info->ii_Am != BRIN_AM_OID) { continue; } for (int i = 0; i < index_info->ii_NumIndexKeyAttrs; i++) { char *attname; Oid atttypid; SparseIndexConfig config; TypeCacheEntry *type; const AttrNumber attno = index_info->ii_IndexAttrNumbers[i]; if (attno == InvalidAttrNumber) { continue; } attname = get_attname(ht->main_table_relid, attno, false); /* do not create sparse index for orderby columns */ if (ts_array_is_member(settings->fd.orderby, attname) || ts_array_is_member(settings->fd.segmentby, attname) || bms_is_member(attno, sparse_index_columns)) continue; atttypid = get_atttype(ht->main_table_relid, attno); type = lookup_type_cache(atttypid, TYPECACHE_LT_OPR | TYPECACHE_HASH_EXTENDED_PROC); /* construct sparse index config */ if (ts_guc_enable_sparse_index_bloom && should_create_bloom_sparse_index(atttypid, type, ht->main_table_relid)) config.base.type = _SparseIndexTypeEnumBloom; else if (OidIsValid(type->lt_opr)) config.base.type = _SparseIndexTypeEnumMinmax; else continue; config.base.col = attname; config.base.source = _SparseIndexSourceEnumDefault; /* convert to json object */ ts_convert_sparse_index_config_to_jsonb(parse_state, &config); sparse_index_columns = bms_add_member(sparse_index_columns, attno); has_object = true; } } table_close(rel, AccessShareLock); return has_object ? JsonbValueToJsonb(pushJsonbValue(&parse_state, WJB_END_ARRAY, NULL)) : NULL; } static void compression_settings_set_defaults(Hypertable *ht, CompressionSettings *settings, WithClauseResult *with_clause_options) { /* orderby arrays should always be in sync either all NULL or none */ Assert( (settings->fd.orderby && settings->fd.orderby_desc && settings->fd.orderby_nullsfirst) || (!settings->fd.orderby && !settings->fd.orderby_desc && !settings->fd.orderby_nullsfirst)); bool add_orderby_sparse_index = false; /* get default settings which will be stored at chunk level */ if (!(settings->fd.orderby) && with_clause_options[AlterTableFlagOrderBy].is_default) { if (!settings->fd.segmentby && with_clause_options[AlterTableFlagSegmentBy].is_default) { settings->fd.segmentby = compression_setting_segmentby_get_default(ht); } settings->fd.index = ts_remove_orderby_sparse_index(settings); OrderBySettings obs = compression_setting_orderby_get_default(ht, settings->fd.segmentby); settings->fd.orderby = obs.orderby; settings->fd.orderby_desc = obs.orderby_desc; settings->fd.orderby_nullsfirst = obs.orderby_nullsfirst; add_orderby_sparse_index = settings->fd.index != NULL; } if (ts_guc_auto_sparse_indexes && can_set_default_sparse_index(settings)) { settings->fd.index = compression_setting_sparse_index_get_default(ht, settings); settings->fd.index = ts_add_orderby_sparse_index(settings); } else if (add_orderby_sparse_index) { settings->fd.index = ts_add_orderby_sparse_index(settings); } } static void compression_settings_set_manually_for_alter(Hypertable *ht, CompressionSettings *settings, WithClauseResult *with_clause_options) { /* orderby arrays should always be in sync either all NULL or none */ Assert( (settings->fd.orderby && settings->fd.orderby_desc && settings->fd.orderby_nullsfirst) || (!settings->fd.orderby && !settings->fd.orderby_desc && !settings->fd.orderby_nullsfirst)); if (with_clause_options[AlterTableFlagSegmentBy].is_default && with_clause_options[AlterTableFlagOrderBy].is_default && with_clause_options[AlterTableFlagIndex].is_default) return; bool add_orderby_sparse_index = false; if (!with_clause_options[AlterTableFlagSegmentBy].is_default) { settings->fd.segmentby = ts_compress_hypertable_parse_segment_by(with_clause_options[AlterTableFlagSegmentBy], ht); } if (!with_clause_options[AlterTableFlagOrderBy].is_default) { settings->fd.index = ts_remove_orderby_sparse_index(settings); OrderBySettings obs = ts_compress_hypertable_parse_order_by(with_clause_options[AlterTableFlagOrderBy], ht); obs = add_time_to_order_by_if_not_included(obs, settings->fd.segmentby, ht); settings->fd.orderby = obs.orderby; settings->fd.orderby_desc = obs.orderby_desc; settings->fd.orderby_nullsfirst = obs.orderby_nullsfirst; add_orderby_sparse_index = settings->fd.index != NULL; } if (!with_clause_options[AlterTableFlagIndex].is_default) { if (!settings->fd.orderby) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot set sparse index option without orderby option"), errdetail("Either set both options or remove both options to trigger default " "values"))); } settings->fd.index = ts_compress_hypertable_parse_index(with_clause_options[AlterTableFlagIndex], ht); settings->fd.index = ts_add_orderby_sparse_index(settings); } else if (add_orderby_sparse_index) { settings->fd.index = ts_add_orderby_sparse_index(settings); } /* update manual settings */ ts_compression_settings_update(settings); } static void compression_settings_set_manually_for_create(Hypertable *ht, CompressionSettings *settings, WithClauseResult *with_clause_options) { if (with_clause_options[CreateTableFlagSegmentBy].is_default && with_clause_options[CreateTableFlagOrderBy].is_default && with_clause_options[CreateTableFlagIndex].is_default) return; bool add_orderby_sparse_index = false; if (!with_clause_options[CreateTableFlagSegmentBy].is_default) { settings->fd.segmentby = ts_compress_hypertable_parse_segment_by(with_clause_options[CreateTableFlagSegmentBy], ht); } if (!with_clause_options[CreateTableFlagOrderBy].is_default) { settings->fd.index = ts_remove_orderby_sparse_index(settings); OrderBySettings obs = ts_compress_hypertable_parse_order_by(with_clause_options[CreateTableFlagOrderBy], ht); obs = add_time_to_order_by_if_not_included(obs, settings->fd.segmentby, ht); settings->fd.orderby = obs.orderby; settings->fd.orderby_desc = obs.orderby_desc; settings->fd.orderby_nullsfirst = obs.orderby_nullsfirst; add_orderby_sparse_index = settings->fd.index != NULL; } if (!with_clause_options[CreateTableFlagIndex].is_default) { if (!settings->fd.orderby) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot set sparse index option without orderby option"), errdetail("Either set both options or remove both options to trigger default " "values"))); } settings->fd.index = ts_compress_hypertable_parse_index(with_clause_options[CreateTableFlagIndex], ht); settings->fd.index = ts_add_orderby_sparse_index(settings); } else if (add_orderby_sparse_index) { settings->fd.index = ts_add_orderby_sparse_index(settings); } /* update manual settings */ ts_compression_settings_update(settings); } /* Add a column to a table that has compression enabled * This function specifically adds the column to the internal compression table. */ void tsl_process_compress_table_add_column(Hypertable *ht, ColumnDef *orig_def) { ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); if (!TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { return; } List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); ListCell *lc; Oid coloid = LookupTypeNameOid(NULL, orig_def->typeName, false); foreach (lc, chunks) { Chunk *chunk = lfirst(lc); /* don't add column if it already exists */ if (get_attnum(chunk->table_id, orig_def->colname) != InvalidAttrNumber) { return; } ColumnDef *coldef = build_columndef_singlecolumn(orig_def->colname, coloid); CompressionSettings *settings = ts_compression_settings_get_by_compress_relid(chunk->table_id); add_column_to_compression_table(chunk->table_id, settings, coldef); } } /* Drop a column from a table that has compression enabled * This function specifically removes it from the internal compression table * and removes it from metadata. * Removing orderby or segmentby columns is not supported. */ void tsl_process_compress_table_drop_column(Hypertable *ht, char *name) { Assert(TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht) || TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)); ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); CompressionSettings *settings = ts_compression_settings_get(ht->main_table_relid); if (settings && (ts_array_is_member(settings->fd.segmentby, name) || ts_array_is_member(settings->fd.orderby, name))) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot drop orderby or segmentby column from a hypertable with " "columnstore enabled"))); List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); CompressionSettings *settings = ts_compression_settings_get_by_compress_relid(chunk->table_id); if (ts_array_is_member(settings->fd.segmentby, name) || ts_array_is_member(settings->fd.orderby, name)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot drop orderby or segmentby column from a chunk with " "columnstore enabled"))); } if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { foreach (lc, chunks) { Chunk *chunk = lfirst(lc); drop_column_from_compression_table(chunk->table_id, name); } } } /* Rename a column on a hypertable that has compression enabled. * * This function renames the existing column in the internal compression table. * We assume that there is a 1-1 mapping between the original chunk and * compressed chunk column names and that the names are identical. * Also update any metadata associated with the column. */ void tsl_process_compress_table_rename_column(Hypertable *ht, const RenameStmt *stmt) { Assert(stmt->relationType == OBJECT_TABLE && stmt->renameType == OBJECT_COLUMN); Assert(TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)); if (strncmp(stmt->newname, COMPRESSION_COLUMN_METADATA_PREFIX, strlen(COMPRESSION_COLUMN_METADATA_PREFIX)) == 0) ereport(ERROR, (errcode(ERRCODE_RESERVED_NAME), errmsg("cannot convert tables with reserved column prefix '%s' to columnstore", COMPRESSION_COLUMN_METADATA_PREFIX))); if (!TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { return; } RenameStmt *compressed_col_stmt = (RenameStmt *) copyObject(stmt); RenameStmt *compressed_index_stmt = (RenameStmt *) copyObject(stmt); List *chunks = ts_chunk_get_by_hypertable_id(ht->fd.compressed_hypertable_id); ListCell *lc; foreach (lc, chunks) { Chunk *chunk = lfirst(lc); compressed_col_stmt->relation = makeRangeVar(NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name), -1); ExecRenameStmt(compressed_col_stmt); compressed_index_stmt->relation = compressed_col_stmt->relation; for (size_t i = 0; i < sizeof(sparse_index_types) / sizeof(sparse_index_types[0]); i++) { char *old_index_name = compressed_column_metadata_name_v2(sparse_index_types[i], stmt->subname); if (get_attnum(chunk->table_id, old_index_name) == InvalidAttrNumber) { continue; } char *new_index_name = compressed_column_metadata_name_v2(sparse_index_types[i], stmt->newname); compressed_index_stmt->subname = old_index_name; compressed_index_stmt->newname = new_index_name; ExecRenameStmt(compressed_index_stmt); } } } /* * Enables compression for a hypertable without creating initial configuration * * This is used when creating a hypertable with CREATE TABLE ... WITH (timescaledb.hypertable) */ void tsl_columnstore_setup(Hypertable *ht, WithClauseResult *with_clause_options) { LockRelationOid(catalog_get_table_id(ts_catalog_get(), HYPERTABLE), RowExclusiveLock); Oid ownerid = ts_rel_get_owner(ht->main_table_relid); Oid tablespace_oid = get_rel_tablespace(ht->main_table_relid); CompressionSettings *settings = ts_compression_settings_create(ht->main_table_relid, InvalidOid, NULL, NULL, NULL, NULL, NULL); compression_settings_set_manually_for_create(ht, settings, with_clause_options); int compress_htid = compression_hypertable_create(ht, ownerid, tablespace_oid); ts_hypertable_set_compressed(ht, compress_htid); /* Add default compression policy when compression is enabled via CREATE TABLE WITH */ /* Use the chunk interval as the compression interval */ const Dimension *time_dim = hyperspace_get_open_dimension(ht->space, 0); if (time_dim != NULL) { Oid compress_after_type = ts_dimension_get_partition_type(time_dim); Datum compress_after_datum; if (IS_TIMESTAMP_TYPE(compress_after_type) || IS_UUID_TYPE(compress_after_type)) compress_after_type = INTERVALOID; compress_after_datum = ts_internal_to_interval_value(time_dim->fd.interval_length, compress_after_type); policy_compression_add_internal( ht->main_table_relid, compress_after_datum, compress_after_type, NULL, /* created_before */ DEFAULT_COMPRESSION_SCHEDULE_INTERVAL, /* default_schedule_interval */ true, /* user_defined_schedule_interval */ true, /* if_not_exists */ false, /* fixed_schedule */ GetCurrentTimestamp() + USECS_PER_DAY, /* initial_start */ NULL /* timezone */); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/create.h�����������������������������������������������������0000664�0000000�0000000�00000003131�15100345067�0021417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/parsenodes.h> #include "hypertable.h" #include "with_clause/with_clause_parser.h" #define COMPRESSION_COLUMN_METADATA_PREFIX "_ts_meta_" #define COMPRESSION_COLUMN_METADATA_COUNT_NAME COMPRESSION_COLUMN_METADATA_PREFIX "count" #define COMPRESSION_COLUMN_METADATA_SEQUENCE_NUM_NAME \ COMPRESSION_COLUMN_METADATA_PREFIX "sequence_num" #define COMPRESSION_COLUMN_METADATA_PATTERN_V1 "_ts_meta_%s_%d" bool tsl_process_compress_table(Hypertable *ht, WithClauseResult *with_clause_options); void tsl_process_compress_table_add_column(Hypertable *ht, ColumnDef *orig_def); void tsl_process_compress_table_drop_column(Hypertable *ht, char *name); void tsl_process_compress_table_rename_column(Hypertable *ht, const RenameStmt *stmt); Chunk *create_compress_chunk(Hypertable *compress_ht, Chunk *src_chunk, Oid table_id); char *column_segment_min_name(int16 column_index); char *column_segment_max_name(int16 column_index); char *compressed_column_metadata_name_v2(const char *metadata_type, const char *column_name); typedef struct CompressionSettings CompressionSettings; int compressed_column_metadata_attno(const CompressionSettings *settings, Oid chunk_reloid, AttrNumber chunk_attno, Oid compressed_reloid, char *metadata_type); void tsl_columnstore_setup(Hypertable *ht, WithClauseResult *with_clause_options); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/recompress.c�������������������������������������������������0000664�0000000�0000000�00000073262�15100345067�0022345�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "debug_point.h" #include <parser/parse_coerce.h> #include <parser/parse_relation.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/relcache.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "compression.h" #include "compression_dml.h" #include "create.h" #include "debug_assert.h" #include "guc.h" #include "indexing.h" #include "recompress.h" #include "ts_catalog/array_utils.h" #include "ts_catalog/chunk_column_stats.h" #include "ts_catalog/compression_settings.h" /* * Timing parameters for spin locking heuristics. * These are the same as used by Postgres for truncate locking during lazy vacuum. * https://github.com/postgres/postgres/blob/4a0650d359c5981270039eeb634c3b7427aa0af5/src/backend/access/heap/vacuumlazy.c#L82 */ #define RECOMPRESS_EXCLUSIVE_LOCK_WAIT_INTERVAL 50 /* ms */ #define RECOMPRESS_EXCLUSIVE_LOCK_TIMEOUT 5000 /* ms */ static bool fetch_uncompressed_chunk_into_tuplesort(Tuplesortstate *tuplesortstate, Relation uncompressed_chunk_rel, Snapshot snapshot); static bool delete_tuple_for_recompression(Relation rel, ItemPointer tid, Snapshot snapshot); static void update_current_segment(CompressedSegmentInfo *current_segment, TupleTableSlot *slot, int nsegmentby_cols); static void create_segmentby_scankeys(CompressionSettings *settings, Relation index_rel, Relation compressed_chunk_rel, ScanKeyData *index_scankeys); static void create_orderby_scankeys(CompressionSettings *settings, Relation index_rel, Relation compressed_chunk_rel, ScanKeyData *orderby_scankeys); static void update_segmentby_scankeys(TupleTableSlot *uncompressed_slot, CompressedSegmentInfo *current_segment, int num_segmentby, ScanKey index_scankeys); static void update_orderby_scankeys(TupleTableSlot *uncompressed_slot, CompressedSegmentInfo *current_segment, int num_segmentby, int num_orderby, ScanKey orderby_scankeys); static enum Batch_match_result match_tuple_batch(TupleTableSlot *compressed_slot, int num_orderby, ScanKey orderby_scankeys, bool *nulls_first); static bool check_changed_group(CompressedSegmentInfo *current_segment, TupleTableSlot *slot, int nsegmentby_cols); static void recompress_segment(Tuplesortstate *tuplesortstate, Relation compressed_chunk_rel, RowCompressor *row_compressor, BulkWriter *writer); static void try_updating_chunk_status(Chunk *uncompressed_chunk, Relation uncompressed_chunk_rel); /* * Recompress an existing chunk by decompressing the batches * that are affected by the addition of newer data. The existing * compressed chunk will not be recreated but modified in place. * * 0 uncompressed_chunk_id REGCLASS * 1 if_not_compressed BOOL = false */ Datum tsl_recompress_chunk_segmentwise(PG_FUNCTION_ARGS) { Oid uncompressed_chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); bool if_not_compressed = PG_ARGISNULL(1) ? true : PG_GETARG_BOOL(1); ts_feature_flag_check(FEATURE_HYPERTABLE_COMPRESSION); TS_PREVENT_FUNC_IF_READ_ONLY(); Chunk *chunk = ts_chunk_get_by_relid(uncompressed_chunk_id, true); if (!ts_chunk_is_partial(chunk)) { int elevel = if_not_compressed ? NOTICE : ERROR; ereport(elevel, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("nothing to recompress in chunk %s.%s", NameStr(chunk->fd.schema_name), NameStr(chunk->fd.table_name)))); } else { if (!ts_guc_enable_segmentwise_recompression) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("segmentwise recompression functionality disabled, " "enable it by first setting " "timescaledb.enable_segmentwise_recompression to on"))); } CompressionSettings *settings = ts_compression_settings_get(uncompressed_chunk_id); if (!settings->fd.orderby) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("segmentwise recompression cannot be applied for " "compression with no " "order by"))); } uncompressed_chunk_id = recompress_chunk_segmentwise_impl(chunk); } PG_RETURN_OID(uncompressed_chunk_id); } Oid recompress_chunk_segmentwise_impl(Chunk *uncompressed_chunk) { Oid uncompressed_chunk_id = uncompressed_chunk->table_id; /* * only proceed if status in (3, 9, 11) * 1: compressed * 2: compressed_unordered * 4: frozen * 8: compressed_partial */ if (!ts_chunk_is_compressed(uncompressed_chunk) && ts_chunk_is_partial(uncompressed_chunk)) elog(ERROR, "unexpected chunk status %d in chunk %s.%s", uncompressed_chunk->fd.status, NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)); /* need it to find the segby cols from the catalog */ Chunk *compressed_chunk = ts_chunk_get_by_id(uncompressed_chunk->fd.compressed_chunk_id, true); CompressionSettings *settings = ts_compression_settings_get(uncompressed_chunk->table_id); /* We should not do segment-wise recompression with empty orderby, see #7748 */ Ensure(settings->fd.orderby, "empty order by, cannot recompress segmentwise"); ereport(DEBUG1, (errmsg("acquiring locks for recompression: \"%s.%s\"", NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)))); LOCKMODE recompression_lockmode = ts_guc_enable_exclusive_locking_recompression ? ExclusiveLock : ShareUpdateExclusiveLock; /* lock both chunks, compressed and uncompressed */ Relation uncompressed_chunk_rel = table_open(uncompressed_chunk->table_id, recompression_lockmode); Relation compressed_chunk_rel = table_open(compressed_chunk->table_id, recompression_lockmode); bool has_unique_constraints = ts_indexing_relation_has_primary_or_unique_index(uncompressed_chunk_rel); int count; LOCKTAG locktag; SET_LOCKTAG_RELATION(locktag, MyDatabaseId, uncompressed_chunk_id); /* * Recompression does not block inserts but it can interfere with * constraint checking since it moves uncompressed tuples from * uncompressed chunk to compressed chunk but the INSERTs check * tuples in the opposite order. * * If there are unique constraints and multiple INSERTs happening at start * we want to just bail out so not to cause wasted work and bloat. */ if (has_unique_constraints) { GetLockConflicts(&locktag, ExclusiveLock, &count); if (count > 1) { elog(WARNING, "skipping recompression of chunk %s.%s due to unique constraints and concurrent " "DML", NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)); table_close(uncompressed_chunk_rel, NoLock); table_close(compressed_chunk_rel, NoLock); PG_RETURN_OID(uncompressed_chunk_id); } } Hypertable *ht = ts_hypertable_get_by_id(uncompressed_chunk->fd.hypertable_id); if (ht->range_space) ts_chunk_column_stats_calculate(ht, uncompressed_chunk); TupleDesc compressed_rel_tupdesc = RelationGetDescr(compressed_chunk_rel); TupleDesc uncompressed_rel_tupdesc = RelationGetDescr(uncompressed_chunk_rel); int num_segmentby = ts_array_length(settings->fd.segmentby); int num_orderby = ts_array_length(settings->fd.orderby); int n_keys = num_segmentby + num_orderby; AttrNumber *sort_keys = palloc(sizeof(*sort_keys) * n_keys); Oid *sort_operators = palloc(sizeof(*sort_operators) * n_keys); Oid *sort_collations = palloc(sizeof(*sort_collations) * n_keys); bool *nulls_first = palloc(sizeof(*nulls_first) * n_keys); CompressedSegmentInfo *current_segment = palloc0(sizeof(CompressedSegmentInfo) * n_keys); for (int n = 0; n < n_keys; n++) { const char *attname; int position; if (n < num_segmentby) { position = n + 1; attname = ts_array_get_element_text(settings->fd.segmentby, position); } else { position = n - num_segmentby + 1; attname = ts_array_get_element_text(settings->fd.orderby, position); } AttrNumber col_attno = get_attnum(uncompressed_chunk_rel->rd_id, attname); current_segment[n].decompressed_chunk_offset = AttrNumberGetAttrOffset(col_attno); current_segment[n].segment_info = segment_info_new( TupleDescAttr(uncompressed_rel_tupdesc, current_segment[n].decompressed_chunk_offset)); compress_chunk_populate_sort_info_for_column(settings, RelationGetRelid(uncompressed_chunk_rel), attname, &sort_keys[n], &sort_operators[n], &sort_collations[n], &nulls_first[n]); } /******************** row decompressor **************/ RowDecompressor decompressor = build_decompressor(RelationGetDescr(compressed_chunk_rel), RelationGetDescr(uncompressed_chunk_rel)); /********** row compressor *******************/ RowCompressor row_compressor; Assert(settings->fd.compress_relid == RelationGetRelid(compressed_chunk_rel)); row_compressor_init(&row_compressor, settings, RelationGetDescr(uncompressed_chunk_rel), RelationGetDescr(compressed_chunk_rel)); BulkWriter writer = bulk_writer_build(compressed_chunk_rel, 0); Oid index_oid = get_compressed_chunk_index(writer.indexstate, settings); /* For chunks with no segmentby settings, we can still do segmentwise recompression * The entire chunk is treated as a single segment */ elog(ts_guc_debug_compression_path_info ? INFO : DEBUG1, "Using index \"%s\" for recompression", get_rel_name(index_oid)); LOCKMODE index_lockmode = ts_guc_enable_exclusive_locking_recompression ? ExclusiveLock : RowExclusiveLock; Relation index_rel = index_open(index_oid, index_lockmode); ereport(DEBUG1, (errmsg("locks acquired for recompression: \"%s.%s\"", NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)))); /* Setting up scankeys */ ScanKeyData *index_scankeys = palloc(sizeof(ScanKeyData) * num_segmentby); ScanKeyData *orderby_scankeys = palloc(sizeof(ScanKeyData) * num_orderby * 2); create_segmentby_scankeys(settings, index_rel, compressed_chunk_rel, index_scankeys); create_orderby_scankeys(settings, index_rel, compressed_chunk_rel, orderby_scankeys); /* Used for sorting and iterating over all the uncompressed tuples that have * to be recompressed. These tuples are sorted based on the segmentby and * orderby settings. */ Tuplesortstate *input_tuplesortstate = tuplesort_begin_heap(uncompressed_rel_tupdesc, n_keys, sort_keys, sort_operators, sort_collations, nulls_first, maintenance_work_mem, NULL, false); /* Used for gathering and resorting the tuples that should be recompressed together. * Since we are working on a per-segment level here, we only need to sort them * based on the orderby settings. */ Tuplesortstate *recompress_tuplesortstate = tuplesort_begin_heap(uncompressed_rel_tupdesc, num_orderby, &sort_keys[num_segmentby], &sort_operators[num_segmentby], &sort_collations[num_segmentby], &nulls_first[num_segmentby], maintenance_work_mem, NULL, false); /************** snapshot ****************************/ Snapshot snapshot = RegisterSnapshot(GetTransactionSnapshot()); TupleTableSlot *uncompressed_slot = MakeTupleTableSlot(uncompressed_rel_tupdesc, &TTSOpsMinimalTuple); TupleTableSlot *compressed_slot = table_slot_create(compressed_chunk_rel, NULL); HeapTuple compressed_tuple; IndexScanDesc index_scan = index_beginscan_compat(compressed_chunk_rel, index_rel, snapshot, NULL, num_segmentby, 0); bool found_tuple = fetch_uncompressed_chunk_into_tuplesort(input_tuplesortstate, uncompressed_chunk_rel, snapshot); if (!found_tuple) goto finish; tuplesort_performsort(input_tuplesortstate); for (found_tuple = tuplesort_gettupleslot(input_tuplesortstate, true /*=forward*/, false /*=copy*/, uncompressed_slot, NULL /*=abbrev*/); found_tuple;) { CHECK_FOR_INTERRUPTS(); update_current_segment(current_segment, uncompressed_slot, num_segmentby); /* Build scankeys based on uncompressed tuple values */ update_segmentby_scankeys(uncompressed_slot, current_segment, num_segmentby, index_scankeys); update_orderby_scankeys(uncompressed_slot, current_segment, num_segmentby, num_orderby, orderby_scankeys); index_rescan(index_scan, index_scankeys, num_segmentby, NULL, 0); bool done_with_segment = false; bool tuples_for_recompression = false; enum Batch_match_result result; while (index_getnext_slot(index_scan, ForwardScanDirection, compressed_slot)) { /* Check if the uncompressed tuple is before, inside, or after the compressed batch */ result = match_tuple_batch(compressed_slot, num_orderby, orderby_scankeys, &nulls_first[num_segmentby]); /* If the tuple is before the batch, add it for recompression * also keep adding uncompressed tuples while they are: * - any left * - before the current batch * - in the same segment group */ while (result == Tuple_before) { tuples_for_recompression = true; tuplesort_puttupleslot(recompress_tuplesortstate, uncompressed_slot); found_tuple = tuplesort_gettupleslot(input_tuplesortstate, true /*=forward*/, false /*=copy*/, uncompressed_slot, NULL /*=abbrev*/); /* If we happen to hit the end of uncompressed tuples or tuple changed segment group * we are done with the segment group */ if (!found_tuple || check_changed_group(current_segment, uncompressed_slot, num_segmentby)) { done_with_segment = true; break; } slot_getallattrs(uncompressed_slot); update_orderby_scankeys(uncompressed_slot, current_segment, num_segmentby, num_orderby, orderby_scankeys); result = match_tuple_batch(compressed_slot, num_orderby, orderby_scankeys, &nulls_first[num_segmentby]); } /* If we are done with segment, recompress everything we have so far * and break out of this segment index scan */ if (done_with_segment) { tuples_for_recompression = false; recompress_segment(recompress_tuplesortstate, uncompressed_chunk_rel, &row_compressor, &writer); break; } /* If the tuple matches the batch, add the batch for recompression */ /* Potential optimization: merge uncompressed tuples and decompressed tuples * into the tuplesortstate since they are both already sorted */ if (result == Tuple_match) { tuples_for_recompression = true; bool should_free; compressed_tuple = ExecFetchSlotHeapTuple(compressed_slot, false, &should_free); heap_deform_tuple(compressed_tuple, compressed_rel_tupdesc, decompressor.compressed_datums, decompressor.compressed_is_nulls); row_decompressor_decompress_row_to_tuplesort(&decompressor, recompress_tuplesortstate); if (!delete_tuple_for_recompression(compressed_chunk_rel, &(compressed_slot->tts_tid), snapshot)) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("aborting recompression due to concurrent updates on " "compressed data, retrying with next policy run"))); CommandCounterIncrement(); if (should_free) heap_freetuple(compressed_tuple); continue; } /* At this point, tuple is after the batch * If there are tuples added for recompression, do it * and continue to the next batch */ if (tuples_for_recompression) { tuples_for_recompression = false; recompress_segment(recompress_tuplesortstate, uncompressed_chunk_rel, &row_compressor, &writer); } } /* End if we are finished with all uncompressed tuples */ if (!found_tuple) { break; } /* Reset index scan if we are done with with this segment */ if (done_with_segment) { continue; } /* We are done with existing batches for this segment group * Everything after this point goes into new batches * until we hit a new segment group or exhaust the uncompressed tuples */ while (!check_changed_group(current_segment, uncompressed_slot, num_segmentby)) { tuples_for_recompression = true; tuplesort_puttupleslot(recompress_tuplesortstate, uncompressed_slot); found_tuple = tuplesort_gettupleslot(input_tuplesortstate, true /*=forward*/, false /*=copy*/, uncompressed_slot, NULL /*=abbrev*/); if (!found_tuple) { tuples_for_recompression = false; recompress_segment(recompress_tuplesortstate, uncompressed_chunk_rel, &row_compressor, &writer); break; } slot_getallattrs(uncompressed_slot); } if (tuples_for_recompression) { recompress_segment(recompress_tuplesortstate, uncompressed_chunk_rel, &row_compressor, &writer); } } finish: row_compressor_close(&row_compressor); bulk_writer_close(&writer); ExecDropSingleTupleTableSlot(uncompressed_slot); ExecDropSingleTupleTableSlot(compressed_slot); index_endscan(index_scan); UnregisterSnapshot(snapshot); index_close(index_rel, NoLock); row_decompressor_close(&decompressor); tuplesort_end(input_tuplesortstate); tuplesort_end(recompress_tuplesortstate); pfree(current_segment); pfree(index_scankeys); pfree(orderby_scankeys); /* If we can quickly upgrade the lock, lets try updating the chunk status to fully * compressed. But we need to check if there are any uncompressed tuples in the * relation since somebody might have inserted new tuples while we were recompressing. */ if (ConditionalLockRelation(uncompressed_chunk_rel, ExclusiveLock)) { try_updating_chunk_status(uncompressed_chunk, uncompressed_chunk_rel); } else if (has_unique_constraints) { /* * This can be problematic since we cannot acquire ExclusiveLock meaning its * possible there are inserts going which need to check unique constraints. * Due to the reverse direction of tuple movement, concurrent recompression * and speculative insertion could potentially cause false negatives during * constraint checking. For now, our best option here is to bail. * * We use a spin lock to wait for the ExclusiveLock or bail out if we can't get it in time. */ int lock_retry = 0; while (true) { if (ConditionalLockRelation(uncompressed_chunk_rel, ExclusiveLock)) { try_updating_chunk_status(uncompressed_chunk, uncompressed_chunk_rel); break; } /* * Check for interrupts while trying to (re-)acquire the exclusive * lock. */ CHECK_FOR_INTERRUPTS(); if (++lock_retry > (RECOMPRESS_EXCLUSIVE_LOCK_TIMEOUT / RECOMPRESS_EXCLUSIVE_LOCK_WAIT_INTERVAL)) { /* * We failed to establish the lock in the specified number of * retries. This means we give up trying to get the exclusive lock are abort the * recompression operation */ ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("aborting recompression due to concurrent DML on uncompressed " "data, retrying with next policy run"))); break; } (void) WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH, RECOMPRESS_EXCLUSIVE_LOCK_WAIT_INTERVAL, WAIT_EVENT_VACUUM_TRUNCATE); ResetLatch(MyLatch); DEBUG_WAITPOINT("chunk_recompress_after_latch"); } } table_close(uncompressed_chunk_rel, NoLock); table_close(compressed_chunk_rel, NoLock); PG_RETURN_OID(uncompressed_chunk_id); } static void update_segmentby_scankeys(TupleTableSlot *uncompressed_slot, CompressedSegmentInfo *current_segment, int num_segmentby, ScanKey index_scankeys) { Datum val; bool is_null; for (int i = 0; i < num_segmentby; i++) { AttrNumber in_attnum = AttrOffsetGetAttrNumber(current_segment[i].decompressed_chunk_offset); val = slot_getattr(uncompressed_slot, in_attnum, &is_null); index_scankeys[i].sk_flags = is_null ? SK_ISNULL | SK_SEARCHNULL : 0; index_scankeys[i].sk_argument = val; } } static void update_orderby_scankeys(TupleTableSlot *uncompressed_slot, CompressedSegmentInfo *current_segment, int num_segmentby, int num_orderby, ScanKey orderby_scankeys) { int min_index, max_index; Datum val; bool is_null; for (int i = 0; i < num_orderby; i++) { AttrNumber in_attnum = AttrOffsetGetAttrNumber(current_segment[num_segmentby + i].decompressed_chunk_offset); val = slot_getattr(uncompressed_slot, in_attnum, &is_null); min_index = i * 2; max_index = min_index + 1; orderby_scankeys[min_index].sk_flags = is_null ? SK_ISNULL : 0; orderby_scankeys[min_index].sk_argument = val; orderby_scankeys[max_index].sk_flags = is_null ? SK_ISNULL : 0; orderby_scankeys[max_index].sk_argument = val; } } static enum Batch_match_result handle_null_scan(int key_flags, bool nulls_first, enum Batch_match_result result) { if (key_flags & SK_ISNULL) return nulls_first ? Tuple_before : Tuple_after; return result; } static enum Batch_match_result match_tuple_batch(TupleTableSlot *compressed_slot, int num_orderby, ScanKey orderby_scankeys, bool *nulls_first) { ScanKey key; for (int i = 0; i < num_orderby; i++) { key = &orderby_scankeys[i * 2]; if (!slot_key_test(compressed_slot, key)) return handle_null_scan(key->sk_flags, nulls_first[i], Tuple_before); key = &orderby_scankeys[i * 2 + 1]; if (!slot_key_test(compressed_slot, key)) return handle_null_scan(key->sk_flags, nulls_first[i], Tuple_after); } return Tuple_match; } static bool fetch_uncompressed_chunk_into_tuplesort(Tuplesortstate *tuplesortstate, Relation uncompressed_chunk_rel, Snapshot snapshot) { bool matching_exist = false; TableScanDesc scan = table_beginscan(uncompressed_chunk_rel, snapshot, 0, 0); TupleTableSlot *slot = table_slot_create(uncompressed_chunk_rel, NULL); while (table_scan_getnextslot(scan, ForwardScanDirection, slot)) { matching_exist = true; slot_getallattrs(slot); tuplesort_puttupleslot(tuplesortstate, slot); if (!delete_tuple_for_recompression(uncompressed_chunk_rel, &slot->tts_tid, snapshot)) ereport(ERROR, (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE), errmsg("aborting recompression due to concurrent updates on " "uncompressed data, retrying with next policy run"))); } ExecDropSingleTupleTableSlot(slot); table_endscan(scan); return matching_exist; } /* Sort the tuples and recompress them */ static void recompress_segment(Tuplesortstate *tuplesortstate, Relation compressed_chunk_rel, RowCompressor *row_compressor, BulkWriter *writer) { tuplesort_performsort(tuplesortstate); row_compressor_reset(row_compressor); row_compressor_append_sorted_rows(row_compressor, tuplesortstate, compressed_chunk_rel, writer); tuplesort_reset(tuplesortstate); CommandCounterIncrement(); } static void update_current_segment(CompressedSegmentInfo *current_segment, TupleTableSlot *slot, int nsegmentby_cols) { Datum val; bool is_null; CompressedSegmentInfo curr; for (int i = 0; i < nsegmentby_cols; i++) { curr = current_segment[i]; val = slot_getattr(slot, AttrOffsetGetAttrNumber(curr.decompressed_chunk_offset), &is_null); /* new segment, need to do per-segment processing */ segment_info_update(curr.segment_info, val, is_null); } } static bool check_changed_group(CompressedSegmentInfo *current_segment, TupleTableSlot *slot, int nsegmentby_cols) { Datum val; bool is_null; bool changed_segment = false; CompressedSegmentInfo curr; for (int i = 0; i < nsegmentby_cols; i++) { curr = current_segment[i]; val = slot_getattr(slot, AttrOffsetGetAttrNumber(curr.decompressed_chunk_offset), &is_null); if (!segment_info_datum_is_in_group(curr.segment_info, val, is_null)) { changed_segment = true; break; } } return changed_segment; } static void init_scankey(ScanKey sk, AttrNumber attnum, Oid atttypid, Oid attcollid, StrategyNumber strategy) { TypeCacheEntry *tce = lookup_type_cache(atttypid, TYPECACHE_BTREE_OPFAMILY); if (!OidIsValid(tce->btree_opf)) elog(ERROR, "no btree opfamily for type \"%s\"", format_type_be(atttypid)); Oid opr = get_opfamily_member(tce->btree_opf, atttypid, atttypid, strategy); /* * Fall back to btree operator input type when it is binary compatible with * the column type and no operator for column type could be found. */ if (!OidIsValid(opr) && IsBinaryCoercible(atttypid, tce->btree_opintype)) { opr = get_opfamily_member(tce->btree_opf, tce->btree_opintype, tce->btree_opintype, strategy); } if (!OidIsValid(opr)) elog(ERROR, "no operator for type \"%s\"", format_type_be(atttypid)); opr = get_opcode(opr); if (!OidIsValid(opr)) elog(ERROR, "no opcode for type \"%s\"", format_type_be(atttypid)); ScanKeyEntryInitialize(sk, 0, /* flags */ attnum, strategy, InvalidOid, /* No strategy subtype. */ attcollid, opr, (Datum) 0); } static void create_segmentby_scankeys(CompressionSettings *settings, Relation index_rel, Relation compressed_chunk_rel, ScanKeyData *index_scankeys) { int num_segmentby = ts_array_length(settings->fd.segmentby); for (int i = 0; i < num_segmentby; i++) { AttrNumber idx_attnum = AttrOffsetGetAttrNumber(i); AttrNumber in_attnum = index_rel->rd_index->indkey.values[i]; const NameData PG_USED_FOR_ASSERTS_ONLY *attname = attnumAttName(compressed_chunk_rel, in_attnum); Assert(strcmp(NameStr(*attname), ts_array_get_element_text(settings->fd.segmentby, i + 1)) == 0); init_scankey(&index_scankeys[i], idx_attnum, attnumTypeId(index_rel, idx_attnum), attnumCollationId(index_rel, idx_attnum), BTEqualStrategyNumber); } } static void create_orderby_scankeys(CompressionSettings *settings, Relation index_rel, Relation compressed_chunk_rel, ScanKeyData *orderby_scankeys) { int position; int num_orderby = ts_array_length(settings->fd.orderby); /* Create two scankeys per orderby column, for min and max metadata columns respectively */ for (int i = 0; i < num_orderby * 2; i = i + 2) { position = (i / 2) + 1; AttrNumber first_attno = get_attnum(compressed_chunk_rel->rd_id, column_segment_min_name(position)); StrategyNumber first_strategy = BTLessEqualStrategyNumber; AttrNumber second_attno = get_attnum(compressed_chunk_rel->rd_id, column_segment_max_name(position)); StrategyNumber second_strategy = BTGreaterEqualStrategyNumber; Assert(first_attno != InvalidAttrNumber); Assert(second_attno != InvalidAttrNumber); bool is_desc = ts_array_get_element_bool(settings->fd.orderby_desc, position); /* If we are using DESC order, swap the order of metadata scankeys * since we rely on the order to determine whether a tuple is before or after * the compressed batch and the index is also ordered in that way. */ if (is_desc) { AttrNumber temp_attno = first_attno; StrategyNumber temp_strategy = first_strategy; first_attno = second_attno; first_strategy = second_strategy; second_attno = temp_attno; second_strategy = temp_strategy; } init_scankey(&orderby_scankeys[i], first_attno, attnumTypeId(compressed_chunk_rel, first_attno), attnumCollationId(compressed_chunk_rel, first_attno), first_strategy); init_scankey(&orderby_scankeys[i + 1], second_attno, attnumTypeId(compressed_chunk_rel, second_attno), attnumCollationId(compressed_chunk_rel, second_attno), second_strategy); } } /* Deleting a tuple for recompression if we can. * If there is an unexpected result, we should just abort the operation completely. * There are potential optimizations that can be done here in certain scenarios. */ static bool delete_tuple_for_recompression(Relation rel, ItemPointer tid, Snapshot snapshot) { TM_Result result; TM_FailureData tmfd; result = table_tuple_delete(rel, tid, GetCurrentCommandId(true), snapshot, InvalidSnapshot, true /* for now, just wait for commit/abort, that might let us proceed */ , &tmfd, true /* changingPart */); return result == TM_Ok; } /* Check if we can update the chunk status to fully compressed after segmentwise recompression * We can only do this if there were no concurrent DML operations, so we check to see if there are * any uncompressed tuples in the chunk after compression. * If there aren't, we can update the chunk status * * Note: Caller is expected to have an ExclusiveLock on the uncompressed_chunk */ static void try_updating_chunk_status(Chunk *uncompressed_chunk, Relation uncompressed_chunk_rel) { PushActiveSnapshot(GetLatestSnapshot()); TableScanDesc scan = table_beginscan(uncompressed_chunk_rel, GetActiveSnapshot(), 0, 0); ScanDirection scan_dir = BackwardScanDirection; TupleTableSlot *slot = table_slot_create(uncompressed_chunk_rel, NULL); /* Doing a backwards scan with assumption that newly inserted tuples * are most likely at the end of the heap. */ bool has_tuples = false; if (table_scan_getnextslot(scan, scan_dir, slot)) { has_tuples = true; } ExecDropSingleTupleTableSlot(slot); table_endscan(scan); PopActiveSnapshot(); if (!has_tuples) { if (ts_chunk_clear_status(uncompressed_chunk, CHUNK_STATUS_COMPRESSED_UNORDERED | CHUNK_STATUS_COMPRESSED_PARTIAL)) ereport(DEBUG1, (errmsg("cleared chunk status for recompression: \"%s.%s\"", NameStr(uncompressed_chunk->fd.schema_name), NameStr(uncompressed_chunk->fd.table_name)))); /* changed chunk status, so invalidate any plans involving this chunk */ CacheInvalidateRelcacheByRelid(uncompressed_chunk->table_id); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/recompress.h�������������������������������������������������0000664�0000000�0000000�00000001105�15100345067�0022335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include <utils.h> #include "chunk.h" extern Datum tsl_recompress_chunk_segmentwise(PG_FUNCTION_ARGS); Oid recompress_chunk_segmentwise_impl(Chunk *chunk); /* Result of matching an uncompressed tuple against a compressed batch */ enum Batch_match_result { Tuple_before = 1, Tuple_match, Tuple_after, _Batch_match_result_max, }; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/sparse_index_bloom1.h����������������������������������������0000664�0000000�0000000�00000000517�15100345067�0024116�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "postgres.h" Datum bloom1_contains(PG_FUNCTION_ARGS); PGFunction bloom1_get_hash_function(Oid type, FmgrInfo **finfo); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/compression/wal_utils.h��������������������������������������������������0000664�0000000�0000000�00000003374�15100345067�0022170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <replication/message.h> #include "guc.h" /* * Utils to insert markers into the WAL log which demarcate compression * and decompression operations. * The primary purpose is to be able to discern between user-driven DML * operations (caused by statements which INSERT/UPDATE/DELETE data), and * compression-driven DML (moving data to/from compressed chunks). */ #define COMPRESSION_MARKER_START "::timescaledb-compression-start" #define COMPRESSION_MARKER_END "::timescaledb-compression-end" #define DECOMPRESSION_MARKER_START "::timescaledb-decompression-start" #define DECOMPRESSION_MARKER_END "::timescaledb-decompression-end" static inline bool is_compression_wal_markers_enabled() { return ts_guc_enable_compression_wal_markers && XLogLogicalInfoActive(); } static inline void write_logical_replication_msg_compression_start() { if (is_compression_wal_markers_enabled()) { LogLogicalMessageCompat(COMPRESSION_MARKER_START, "", 0, true, true); } } static inline void write_logical_replication_msg_compression_end() { if (is_compression_wal_markers_enabled()) { LogLogicalMessageCompat(COMPRESSION_MARKER_END, "", 0, true, true); } } static inline void write_logical_replication_msg_decompression_start() { if (is_compression_wal_markers_enabled()) { LogLogicalMessageCompat(DECOMPRESSION_MARKER_START, "", 0, true, true); } } static inline void write_logical_replication_msg_decompression_end() { if (is_compression_wal_markers_enabled()) { LogLogicalMessageCompat(DECOMPRESSION_MARKER_END, "", 0, true, true); } } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/���������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020653�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/CMakeLists.txt�������������������������������������������0000664�0000000�0000000�00000002617�15100345067�0023421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/common.c ${CMAKE_CURRENT_SOURCE_DIR}/create.c ${CMAKE_CURRENT_SOURCE_DIR}/finalize.c ${CMAKE_CURRENT_SOURCE_DIR}/insert.c ${CMAKE_CURRENT_SOURCE_DIR}/invalidation_record.c ${CMAKE_CURRENT_SOURCE_DIR}/invalidation_threshold.c ${CMAKE_CURRENT_SOURCE_DIR}/invalidation.c ${CMAKE_CURRENT_SOURCE_DIR}/invalidation_multi.c ${CMAKE_CURRENT_SOURCE_DIR}/materialize.c ${CMAKE_CURRENT_SOURCE_DIR}/options.c ${CMAKE_CURRENT_SOURCE_DIR}/planner.c ${CMAKE_CURRENT_SOURCE_DIR}/refresh.c ${CMAKE_CURRENT_SOURCE_DIR}/repair.c ${CMAKE_CURRENT_SOURCE_DIR}/utils.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) add_library( ${TSL_CAGG_INVALIDATION_PLUGIN_NAME} MODULE invalidation_plugin.c invalidation_plugin_cache.c invalidation_record.c) # VERSION and SOVERSION are not used since they do not make sense for modules, # and actually breaks the build on MacOS. # # See https://gitlab.kitware.com/cmake/cmake/-/issues/20782. set_target_properties( ${TSL_CAGG_INVALIDATION_PLUGIN_NAME} PROPERTIES OUTPUT_NAME ${TSL_CAGG_INVALIDATION_PLUGIN_NAME} PREFIX "" POSITION_INDEPENDENT_CODE ON) target_include_directories(${TSL_CAGG_INVALIDATION_PLUGIN_NAME} PRIVATE ${PG_INCLUDEDIR}) install(TARGETS ${TSL_CAGG_INVALIDATION_PLUGIN_NAME} LIBRARY DESTINATION ${PG_PKGLIBDIR}) �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/README.md������������������������������������������������0000664�0000000�0000000�00000022315�15100345067�0022135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Continuous Aggregates # A continuous aggregate is a special kind of materialized view for aggregates that can be partially and continuously refreshed, either manually or automated by a policy that runs in the background. Unlike a regular materialized view, a continuous aggregate doesn't require complete re-materialization on every refresh. Instead, it is possible to refresh a subset of the continuous aggregate at relatively low cost, thus enabling continuous aggregation as new data is written or old data is updated and/or backfilled. To enable continuous aggregation, a continuous aggregate stores partial aggregations for every time bucket in an internal hypertable. The advantage of this configuration is that each time bucket can be recomputed individually, without requiring updates to other buckets, and buckets can be combined to form more granular aggregates (e.g., hourly buckets can be combined to form daily buckets). Finalization of the partial buckets happens automatically at query time. Although such finalization gives slightly higher querying times, it is offset by more efficient refreshes that only recompute the buckets that have been "invalidated" by changes in the raw data. A continuous aggregate policy automates the refreshing, allowing the aggregate to stay up-to-date without manual intervention. A policy can be configured to only refresh the most recent data (e.g., just the last hour's worth of data) or ensure that the continuous aggregate is always up-to-date with the underlying source data. Policies that focus on recent data allow older parts of the continuous aggregate to stay the same or be governed by manual refreshes. ## Bookkeeping and Internal State ## TimescaleDB does bookkeeping for each continuous aggregate to know which buckets of the aggregates require refreshing. Whenever a modification happens to the source data, an invalidation for the modified region is written to an invalidation log. However, invalidations are not written after the *invalidation threshold*, which tracks the latest bucket materialized thus far. This threshold allows write amplification to be kept to a minimum by not writing invalidations for "hot" time buckets that are assumed to still have data being written to them. Thus, to store, maintain, and query aggregations, continuous aggregates consist of the following objects: 1. A user view, which queries and finalizes the aggregations and is also the object that users interact with. 2. A partial view, which is used to materialize new data. 3. A direct view, which holds the original query that users specified. 4. An internal materialization hypertable, containing the materialized data as partial aggregates for each time bucket. 5. An invalidation threshold, which is a timestamp that tracks the latest materialization. Invalidations that occur before this timestamp will be logged, while invalidations after it will not be logged. 6. A trigger on the source hypertable that writes invalidations to the hypertable invalidation log at transaction end, based on INSERT, UPDATE, and DELETE statements that mutate the data. 7. A hypertable invalidation log that tracks invalidated regions of data for each hypertable. Entries in this log contain time ranges that need to be re-materialized across all the hypertable's continuous aggregates. 8. A materialization invalidation log. Once a refresh runs on a given continuous aggregate, this log tracks how invalidations from the hypertable invalidation log are processed against the refresh window for the refreshed continuous aggregate. Thus, a single invalidation in the hypertable invalidation log becomes one entry per continuous aggregate in the materialization invalidation log. ## The materialized hypertable ## The materialized hypertable does not store the aggregate's output, but rather the partial aggregate state. For instance, in case of an average, each bucket stores the sum and count in an internal binary form. The partial aggregates are what gives continuous aggregates flexibility; buckets can be individually updated and multiple partial aggregates can be combined to form new partials. Future enhancements may allow aggregating at different time resolutions using the the same underlying continuous aggregate. ## The Invalidation Log and Threshold ## There are two mechanisms for collecting hypertable invalidations: 1. A trigger on the hypertable, which writes to a dedicated *hypertable invalidation log* table. 2. A logical decoding plugin, which scans the WAL to produce invalidation entries. ### Invalidation Log Table Mutating transactions must record their mutations in the invalidation log, so that a refresh knows to re-materialize the invalidated range. When using the trigger approach, this happens by installing a trigger on the source hypertable when the first continuous aggregate on that hypertable is created. The trigger writes entries to the hypertable invalidation log. To reduce the extra writes by the trigger, only one invalidation range (lowest and highest modified value) is written at the end of a mutating transaction. As a result, a refresh might materialize more data than necessary, but the insert incurs a smaller overhead instead. Write amplification is further reduced by never writing invalidations after the invalidation threshold, which can be configured to lag behind the time bucket that sees the most writes. Whenever a refresh occurs across a time range that is newer than the current invalidation threshold, the threshold must first be moved to the end of the refreshed region so that new invalidations are recorded in the region after the refresh. However, mutations in the refreshed region can also happen concurrently with the refresh, so, in order to not lose any invalidations, the invalidation threshold must be moved in its own transaction before the new region is materialized. Thus, every refresh may happen across two transactions; first one that moves the invalidation threshold (if necessary) and a second one that does the actual materialization of new data. The second transaction of the refresh will only materialize regions that are recorded as invalid in the invalidation log. Thus, the initial state of a continuous aggregate is to have an entry in the invalidation log that invalidates the entire range of the aggregate. During the refresh, the log is processed and invalidations are cut against the given refresh window, leaving only invalidation entries that are outside the refresh window. Subsequently, if the refresh window does not match any invalidations, there is nothing to refresh either. ### Invalidations Plugin The invalidation plugin is available in `invalidation_plugin.c` and is used to generate "invalidations" for continuous aggregates. An invalidation is a time range that has been modified in the original hypertable that is the source of data for refreshing a continuous aggregate. To avoid dependencies on the TimescaleDB extension, the invalidation plugin is made as simple as possible and does not use the metadata tables of the TimescaleDB extension and instead is configured to read specific relids and attribute names when fetching data. While processing the WAL, the timestamps are collected into ranges and (similarly to when using the trigger to record changes) only one invalidation range (lowest and highest modified value in microseconds since UNIX Epoch) is produced for each modified hypertable in each mutating transaction. For the same reasons as above, this means that a refresh might materialize more data than necessary. The modifications are represented as tuples consisting of the relid for the change and the start and end timestamp as int64, which is the internal representation of timestamp values. It is up to the receiver to use the relid and timestamps correctly. To be able to collect a unique key for each changed row when doing a `DELETE` or an `UPDATE`, it is required that the hypertable has a replica identity set. This can either be the primary key of the hypertable, or a unique index, or the full row if neither is suitable. ## Distribution of functions across files Each source file has an associated header file that should be included to use functions from the corresponding file. <dl> <dt>`common.c`</dt> <dd>This file contains the functions common in all scenarios of creating a continuous aggregates.</dd> <dt>`create.c`</dt> <dd>This file contains the functions that are directly responsible for the creation of the continuous aggregates, like creating hypertable, catalog_entry, view, etc.</dd> <dt>`finalize.c`</dt> <dd>This file contains the specific functions for the case when continous aggregates are created in old format.</dd> <dt>`materialize.c`</dt> <dd>This file contains the functions directly dealing with the materialization of the continuous aggregates.</dd> <dt>`repair.c`</dt> <dd>The repair and rebuilding related functions are put together in this file.</dd> </dl> <dt>`invalidation.c`</dt> <dd>Functions related to invalidation processing for continuous aggregates.</dd> </dl> <dt>`invalidation_plugin.c`</dt> <dd>The invalidation plugin.</dd> <dt>`invalidation_plugin_cache.c`</dt> <dd>The invalidation cache for the invalidation plugin.</dd> <dt>`invalidation_record.c`</dt> <dd>Functions to work with invalidation records.</dd> </dl> �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/common.c�������������������������������������������������0000664�0000000�0000000�00000145315�15100345067�0022320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "common.h" #include <utils/acl.h> #include <utils/date.h> #include <utils/timestamp.h> #include "guc.h" static Const *check_time_bucket_argument(Node *arg, char *position, bool process_checks); static void caggtimebucketinfo_init(ContinuousAggTimeBucketInfo *src, int32 hypertable_id, Oid hypertable_oid, AttrNumber hypertable_partition_colno, Oid hypertable_partition_coltype, int64 hypertable_partition_col_interval, int32 parent_mat_hypertable_id); static void process_additional_timebucket_parameter(ContinuousAggBucketFunction *bf, Const *arg, bool *custom_origin); static void process_timebucket_parameters(FuncExpr *fe, ContinuousAggBucketFunction *bf, bool process_checks, bool is_cagg_create, AttrNumber htpartcolno); static void caggtimebucket_validate(ContinuousAggTimeBucketInfo *tbinfo, List *groupClause, List *targetList, List *rtable, bool is_cagg_create); static bool cagg_query_supported(const Query *query, StringInfo hint, StringInfo detail, const bool finalized); static Datum get_bucket_width_datum(ContinuousAggTimeBucketInfo bucket_info); static int64 get_bucket_width(ContinuousAggTimeBucketInfo bucket_info); static FuncExpr *build_conversion_call(Oid type, FuncExpr *boundary); static FuncExpr *build_boundary_call(int32 ht_id, Oid type); static Const *cagg_boundary_make_lower_bound(Oid type); static Node *build_union_query_quals(int32 ht_id, Oid partcoltype, Oid opno, int varno, AttrNumber attno); static RangeTblEntry *makeRangeTblEntry(Query *subquery, const char *aliasname); static bool time_bucket_info_has_fixed_width(const ContinuousAggBucketFunction *bf); #define INTERNAL_TO_DATE_FUNCTION "to_date" #define INTERNAL_TO_TSTZ_FUNCTION "to_timestamp" #define INTERNAL_TO_TS_FUNCTION "to_timestamp_without_timezone" #define BOUNDARY_FUNCTION "cagg_watermark" static Const * check_time_bucket_argument(Node *arg, char *position, bool process_checks) { if (IsA(arg, NamedArgExpr)) arg = (Node *) castNode(NamedArgExpr, arg)->arg; Node *expr = eval_const_expressions(NULL, arg); if (process_checks && !IsA(expr, Const)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("only immutable expressions allowed in time bucket function"), errhint("Use an immutable expression as %s argument to the time bucket function.", position))); return castNode(Const, expr); } /* * Initialize caggtimebucket. */ static void caggtimebucketinfo_init(ContinuousAggTimeBucketInfo *src, int32 hypertable_id, Oid hypertable_oid, AttrNumber hypertable_partition_colno, Oid hypertable_partition_coltype, int64 hypertable_partition_col_interval, int32 parent_mat_hypertable_id) { src->htid = hypertable_id; src->parent_mat_hypertable_id = parent_mat_hypertable_id; src->htoid = hypertable_oid; src->htoidparent = InvalidOid; src->htpartcolno = hypertable_partition_colno; src->htpartcoltype = hypertable_partition_coltype; src->htpartcol_interval_len = hypertable_partition_col_interval; /* Initialize bucket function data structure */ src->bf = palloc0(sizeof(ContinuousAggBucketFunction)); src->bf->bucket_function = InvalidOid; src->bf->bucket_width_type = InvalidOid; /* Time based buckets */ src->bf->bucket_time_width = NULL; /* not specified by default */ src->bf->bucket_time_timezone = NULL; /* not specified by default */ src->bf->bucket_time_offset = NULL; /* not specified by default */ TIMESTAMP_NOBEGIN(src->bf->bucket_time_origin); /* origin is not specified by default */ /* Integer based buckets */ src->bf->bucket_integer_width = 0; /* invalid value */ src->bf->bucket_integer_offset = 0; /* invalid value */ } /* * Initialize MaterializationHypertableColumnInfo. */ void mattablecolumninfo_init(MaterializationHypertableColumnInfo *matcolinfo, List *grouplist) { matcolinfo->matcollist = NIL; matcolinfo->partial_seltlist = NIL; matcolinfo->partial_grouplist = grouplist; matcolinfo->mat_groupcolname_list = NIL; matcolinfo->matpartcolno = -1; matcolinfo->matpartcolname = NULL; } /* * Check if the supplied OID belongs to a valid bucket function * for continuous aggregates. */ bool function_allowed_in_cagg_definition(Oid funcid) { FuncInfo *finfo = ts_func_cache_get_bucketing_func(funcid); if (finfo == NULL) return false; if (finfo->allowed_in_cagg_definition) return true; /* Allow creation of CAggs with deprecated bucket function in debug builds for testing purposes */ if (ts_guc_debug_allow_cagg_with_deprecated_funcs && IS_DEPRECATED_TIME_BUCKET_NG_FUNC(finfo)) return true; return false; } /* * When a view is created (StoreViewQuery), 2 dummy rtable entries corresponding to "old" and * "new" are prepended to the rtable list. We remove these and adjust the varnos to recreate * the user or direct view query. */ void RemoveRangeTableEntries(Query *query) { #if PG16_LT List *rtable = query->rtable; Assert(list_length(rtable) >= 3); rtable = list_delete_first(rtable); query->rtable = list_delete_first(rtable); OffsetVarNodes((Node *) query, -2, 0); Assert(list_length(query->rtable) >= 1); #endif } /* * Extract the final view from the UNION ALL query. * * q1 is the query on the materialization hypertable with the finalize call * q2 is the query on the raw hypertable which was supplied in the initial CREATE VIEW statement * returns q1 from: * SELECT * from ( SELECT * from q1 where <coale_qual> * UNION ALL * SELECT * from q2 where existing_qual and <coale_qual> * where coale_qual is: time < ----> (or >= ) * COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark( <htid>)), * '-infinity'::timestamp with time zone) * The WHERE clause of the final view is removed. */ Query * destroy_union_query(Query *q) { Assert(q->commandType == CMD_SELECT && ((SetOperationStmt *) q->setOperations)->op == SETOP_UNION && ((SetOperationStmt *) q->setOperations)->all == true); /* Get RTE of the left-hand side of UNION ALL. */ RangeTblEntry *rte = linitial(q->rtable); Assert(rte->rtekind == RTE_SUBQUERY); Query *query = copyObject(rte->subquery); /* Delete the WHERE clause from the final view. */ query->jointree->quals = NULL; return query; } /* * Handle additional parameter of the timebucket function such as timezone, offset, or origin */ static void process_additional_timebucket_parameter(ContinuousAggBucketFunction *bf, Const *arg, bool *custom_origin) { char *tz_name; switch (exprType((Node *) arg)) { /* Timezone as text */ case TEXTOID: tz_name = TextDatumGetCString(arg->constvalue); if (!ts_is_valid_timezone_name(tz_name)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid timezone name \"%s\"", tz_name))); } bf->bucket_time_timezone = tz_name; break; case INTERVALOID: /* Bucket offset as interval */ bf->bucket_time_offset = DatumGetIntervalP(arg->constvalue); break; case DATEOID: /* Bucket origin as Date */ if (!arg->constisnull) bf->bucket_time_origin = date2timestamptz_opt_overflow(DatumGetDateADT(arg->constvalue), NULL); *custom_origin = true; break; case TIMESTAMPOID: /* Bucket origin as Timestamp */ bf->bucket_time_origin = DatumGetTimestamp(arg->constvalue); *custom_origin = true; break; case TIMESTAMPTZOID: /* Bucket origin as TimestampTZ */ bf->bucket_time_origin = DatumGetTimestampTz(arg->constvalue); *custom_origin = true; break; case INT2OID: /* Bucket offset as smallint */ bf->bucket_integer_offset = DatumGetInt16(arg->constvalue); break; case INT4OID: /* Bucket offset as int */ bf->bucket_integer_offset = DatumGetInt32(arg->constvalue); break; case INT8OID: /* Bucket offset as bigint */ bf->bucket_integer_offset = DatumGetInt64(arg->constvalue); break; default: ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("unable to handle time_bucket parameter of type: %s", format_type_be(exprType((Node *) arg))))); pg_unreachable(); } } /* * Process the FuncExpr node to fill the bucket function data structure. The other * parameters are used when `process_check` is true that means we need to raise errors * when invalid parameters are passed to the time bucket function when creating a cagg. */ static void process_timebucket_parameters(FuncExpr *fe, ContinuousAggBucketFunction *bf, bool process_checks, bool is_cagg_create, AttrNumber htpartcolno) { Node *width_arg; Node *col_arg; bool custom_origin = false; TIMESTAMP_NOBEGIN(bf->bucket_time_origin); int nargs; /* Only column allowed : time_bucket('1day', <column> ) */ col_arg = lsecond(fe->args); /* Could be a named argument */ if (IsA(col_arg, NamedArgExpr)) col_arg = (Node *) castNode(NamedArgExpr, col_arg)->arg; if (process_checks && htpartcolno != InvalidAttrNumber && (!(IsA(col_arg, Var)) || castNode(Var, col_arg)->varattno != htpartcolno)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("time bucket function must reference the primary hypertable " "dimension column"))); nargs = list_length(fe->args); Assert(nargs >= 2 && nargs <= 5); /* * Process the third argument of the time bucket function. This could be `timezone`, `offset`, * or `origin`. * * Time bucket function variations with 3 and 5 arguments: * - time_bucket(width SMALLINT, ts SMALLINT, offset SMALLINT) * - time_bucket(width INTEGER, ts INTEGER, offset INTEGER) * - time_bucket(width BIGINT, ts BIGINT, offset BIGINT) * - time_bucket(width INTERVAL, ts DATE, offset INTERVAL) * - time_bucket(width INTERVAL, ts DATE, origin DATE) * - time_bucket(width INTERVAL, ts TIMESTAMPTZ, offset INTERVAL) * - time_bucket(width INTERVAL, ts TIMESTAMPTZ, origin TIMESTAMPTZ) * - time_bucket(width INTERVAL, ts TIMESTAMPTZ, timezone TEXT, origin TIMESTAMPTZ, * offset INTERVAL) * - time_bucket(width INTERVAL, ts TIMESTAMP, offset INTERVAL) * - time_bucket(width INTERVAL, ts TIMESTAMP, origin TIMESTAMP) */ if (nargs >= 3) { Const *arg = check_time_bucket_argument(lthird(fe->args), "third", process_checks); process_additional_timebucket_parameter(bf, arg, &custom_origin); } /* * Process the fourth and fifth arguments of the time bucket function. This could be `origin` or * `offset`. * * Time bucket function variation with 5 arguments: * - time_bucket(width INTERVAL, ts TIMESTAMPTZ, timezone TEXT, origin TIMESTAMPTZ, * offset INTERVAL) */ if (nargs >= 4) { Const *arg = check_time_bucket_argument(lfourth(fe->args), "fourth", process_checks); process_additional_timebucket_parameter(bf, arg, &custom_origin); } if (nargs == 5) { Const *arg = check_time_bucket_argument(lfifth(fe->args), "fifth", process_checks); process_additional_timebucket_parameter(bf, arg, &custom_origin); } if (process_checks && custom_origin && TIMESTAMP_NOT_FINITE(bf->bucket_time_origin)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid origin value: infinity"))); } /* * We constify width expression here so any immutable expression will be allowed. * Otherwise it would make it harder to create caggs for hypertables with e.g. int8 * partitioning column as int constants default to int4 and so expression would * have a cast and not be a Const. */ width_arg = linitial(fe->args); if (IsA(width_arg, NamedArgExpr)) width_arg = (Node *) castNode(NamedArgExpr, width_arg)->arg; width_arg = eval_const_expressions(NULL, width_arg); if (IsA(width_arg, Const)) { Const *width = castNode(Const, width_arg); bf->bucket_width_type = width->consttype; if (width->constisnull) { if (process_checks && is_cagg_create) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid bucket width for time bucket function"))); } else { if (width->consttype == INTERVALOID) { bf->bucket_time_width = DatumGetIntervalP(width->constvalue); } if (!IS_TIME_BUCKET_INFO_TIME_BASED(bf)) { bf->bucket_integer_width = ts_interval_value_to_internal(width->constvalue, width->consttype); } } } else { if (process_checks) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("only immutable expressions allowed in time bucket function"), errhint("Use an immutable expression as first argument to the time bucket " "function."))); } bf->bucket_function = fe->funcid; bf->bucket_time_based = ts_continuous_agg_bucket_on_interval(bf->bucket_function); bf->bucket_fixed_interval = time_bucket_info_has_fixed_width(bf); } /* * Check if the group-by clauses has exactly 1 time_bucket(.., <col>) where * <col> is the hypertable's partitioning column and other invariants. Then fill * the `bucket_width` and other fields of `tbinfo`. */ static void caggtimebucket_validate(ContinuousAggTimeBucketInfo *tbinfo, List *groupClause, List *targetList, List *rtable, bool is_cagg_create) { ListCell *l; bool found = false; /* Make sure tbinfo was initialized. This assumption is used below. */ Assert(tbinfo->bf->bucket_integer_width == 0); Assert(tbinfo->bf->bucket_time_timezone == NULL); Assert(TIMESTAMP_NOT_FINITE(tbinfo->bf->bucket_time_origin)); List *group_exprs = get_sortgrouplist_exprs(groupClause, targetList); #if PG18_GE /* PG18 introduced RTEs for group clauses so * we can just use rtable to look for GROUP BY expressions. * * https://github.com/postgres/postgres/commit/247dea89 */ List *group_rte_exprs = NIL; foreach (l, rtable) { RangeTblEntry *rte = (RangeTblEntry *) lfirst(l); if (rte->rtekind == RTE_GROUP) group_rte_exprs = list_concat(group_rte_exprs, rte->groupexprs); } group_exprs = group_rte_exprs; #endif foreach (l, group_exprs) { Expr *expr = (Expr *) lfirst(l); if (IsA(expr, FuncExpr)) { FuncExpr *fe = castNode(FuncExpr, expr); /* Filter any non bucketing functions */ FuncInfo *finfo = ts_func_cache_get_bucketing_func(fe->funcid); if (finfo == NULL || !finfo->is_bucketing_func) { continue; } /* Do we have a bucketing function that is not allowed in the CAgg definition? * * This is only validated upon creation. If an older TSDB version has allowed us to use * the function and it's now removed from the list of allowed functions, we should not * error out (e.g., materialized_only setting is changed on a CAgg that uses the * deprecated time_bucket_ng function). */ if (!function_allowed_in_cagg_definition(fe->funcid)) { if (IS_DEPRECATED_TIME_BUCKET_NG_FUNC(finfo)) { if (is_cagg_create) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("experimental bucket functions are not supported inside a " "CAgg " "definition"), errhint("Use a function from the %s schema instead.", FUNCTIONS_SCHEMA_NAME))); } } else { continue; } } if (found) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("continuous aggregate view cannot contain" " multiple time bucket functions"))); else found = true; process_timebucket_parameters(fe, tbinfo->bf, true, is_cagg_create, tbinfo->htpartcolno); } } if (tbinfo->bf->bucket_time_offset != NULL && TIMESTAMP_NOT_FINITE(tbinfo->bf->bucket_time_origin) == false) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("using offset and origin in a time_bucket function at the same time is not " "supported"))); } if (!time_bucket_info_has_fixed_width(tbinfo->bf)) { /* Variable-sized buckets can be used only with intervals. */ Assert(tbinfo->bf->bucket_time_width != NULL); Assert(IS_TIME_BUCKET_INFO_TIME_BASED(tbinfo->bf)); if ((tbinfo->bf->bucket_time_width->month != 0) && ((tbinfo->bf->bucket_time_width->day != 0) || (tbinfo->bf->bucket_time_width->time != 0))) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid interval specified"), errhint("Use either months or days and hours, but not months, days and hours " "together"))); } } if (!found) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("continuous aggregate view must include a valid time bucket function"))); } /* * Check query and extract error details and error hints. * * Returns: * True if the query is supported, false otherwise with hints and errors * added. */ static bool cagg_query_supported(const Query *query, StringInfo hint, StringInfo detail, const bool finalized) { if (!finalized) { /* continuous aggregates with old format will not be allowed */ appendStringInfoString(detail, "Continuous Aggregates with partials is not supported anymore."); appendStringInfoString(hint, "Define the Continuous Aggregate with \"finalized\" parameter set " "to true."); return false; } if (!query->jointree->fromlist) { appendStringInfoString(hint, "FROM clause missing in the query"); return false; } if (query->commandType != CMD_SELECT) { appendStringInfoString(hint, "Use a SELECT query in the continuous aggregate view."); return false; } if (query->hasWindowFuncs) { if (ts_guc_enable_cagg_window_functions) { elog(WARNING, "window function support is experimental and may result in unexpected results " "depending on the functions used."); } else { appendStringInfoString(detail, "Window function support not enabled."); appendStringInfoString(hint, "Enable experimental window function support by setting " "timescaledb.enable_cagg_window_functions."); return false; } } if (query->hasDistinctOn || query->distinctClause) { appendStringInfoString(detail, "DISTINCT / DISTINCT ON queries are not supported by continuous " "aggregates."); return false; } if (query->limitOffset || query->limitCount) { appendStringInfoString(detail, "LIMIT and LIMIT OFFSET are not supported in queries defining " "continuous aggregates."); appendStringInfoString(hint, "Use LIMIT and LIMIT OFFSET in SELECTS from the continuous " "aggregate view instead."); return false; } if (query->hasRecursive || query->hasSubLinks || query->cteList) { appendStringInfoString(detail, "CTEs and subqueries are not supported by " "continuous aggregates."); return false; } if (query->hasForUpdate || query->hasModifyingCTE) { appendStringInfoString(detail, "Data modification is not allowed in continuous aggregate view " "definitions."); return false; } if (query->hasRowSecurity) { appendStringInfoString(detail, "Row level security is not supported by continuous aggregate " "views."); return false; } if (query->groupingSets) { appendStringInfoString(detail, "GROUP BY GROUPING SETS, ROLLUP and CUBE are not supported by " "continuous aggregates"); appendStringInfoString(hint, "Define multiple continuous aggregates with different grouping " "levels."); return false; } if (query->setOperations) { appendStringInfoString(detail, "UNION, EXCEPT & INTERSECT are not supported by continuous " "aggregates"); return false; } if (!query->groupClause) { /* * Query can have aggregate without group by , so look * for groupClause. */ appendStringInfoString(hint, "Include at least one aggregate function" " and a GROUP BY clause with time bucket."); return false; } return true; /* Query was OK and is supported. */ } static Datum get_bucket_width_datum(ContinuousAggTimeBucketInfo bucket_info) { Datum width = (Datum) 0; switch (bucket_info.bf->bucket_width_type) { case INT8OID: case INT4OID: case INT2OID: width = ts_internal_to_interval_value(bucket_info.bf->bucket_integer_width, bucket_info.bf->bucket_width_type); break; case INTERVALOID: width = IntervalPGetDatum(bucket_info.bf->bucket_time_width); break; default: Assert(false); } return width; } static int64 get_bucket_width(ContinuousAggTimeBucketInfo bucket_info) { int64 width = 0; /* Calculate the width. */ switch (bucket_info.bf->bucket_width_type) { case INT8OID: case INT4OID: case INT2OID: width = bucket_info.bf->bucket_integer_width; break; case INTERVALOID: { /* * Original interval should not be changed, hence create a local copy * for this check. */ Interval interval = *bucket_info.bf->bucket_time_width; /* * epoch will treat year as 365.25 days. This leads to the unexpected * result that year is not multiple of day or month, which is perceived * as a bug. For that reason, we treat all months as 30 days regardless of year */ if (interval.month && !interval.day && !interval.time) { interval.day = interval.month * DAYS_PER_MONTH; interval.month = 0; } /* Convert Interval to int64 */ width = ts_interval_value_to_internal(IntervalPGetDatum(&interval), INTERVALOID); break; } default: Assert(false); } return width; } ContinuousAggTimeBucketInfo cagg_validate_query(const Query *query, const bool finalized, const char *cagg_schema, const char *cagg_name, const bool is_cagg_create) { ContinuousAggTimeBucketInfo bucket_info = { 0 }; ContinuousAggTimeBucketInfo bucket_info_parent = { 0 }; Hypertable *ht = NULL, *ht_parent = NULL; RangeTblEntry *rte = NULL; StringInfo hint = makeStringInfo(); StringInfo detail = makeStringInfo(); bool is_hierarchical = false; Query *prev_query = NULL; ContinuousAgg *cagg_parent = NULL; if (!cagg_query_supported(query, hint, detail, finalized)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate query"), hint->len > 0 ? errhint("%s", hint->data) : 0, detail->len > 0 ? errdetail("%s", detail->data) : 0)); } int num_hypertables = 0; ListCell *lc; foreach (lc, query->rtable) { RangeTblEntry *inner_rte = lfirst_node(RangeTblEntry, lc); if (inner_rte->rtekind == RTE_RELATION) { bool is_hypertable = ts_is_hypertable(inner_rte->relid) || ts_continuous_agg_find_by_relid(inner_rte->relid); if (is_hypertable) { num_hypertables++; if (rte == NULL) rte = copyObject(inner_rte); } if (is_hypertable && inner_rte->inh == false) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate view"), errdetail( "FROM ONLY on hypertables is not allowed in continuous aggregate."))); } /* Only inner joins are allowed. */ if (inner_rte->jointype != JOIN_INNER && inner_rte->jointype != JOIN_LEFT) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("only INNER or LEFT joins are supported in continuous aggregates"))); /* Subquery only using LATERAL */ if (inner_rte->subquery && !inner_rte->lateral) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate view"), errdetail("Sub-queries are not supported in FROM clause."))); /* TABLESAMPLE not allowed */ if (inner_rte->tablesample) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate view"), errdetail("TABLESAMPLE is not supported in continuous aggregate."))); } if (num_hypertables > 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate view"), errdetail("Only one hypertable is allowed in continuous aggregate view."))); if (rte == NULL) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate view"), errdetail("At least one hypertable should be used in the view definition."))); } const Dimension *part_dimension = NULL; int32 parent_mat_hypertable_id = INVALID_HYPERTABLE_ID; Cache *hcache = ts_hypertable_cache_pin(); if (rte->relkind == RELKIND_RELATION) { ht = ts_hypertable_cache_get_entry(hcache, rte->relid, CACHE_FLAG_MISSING_OK); if (!ht) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_TS_HYPERTABLE_NOT_EXIST), errmsg("table \"%s\" is not a hypertable", get_rel_name(rte->relid)))); } } else { cagg_parent = ts_continuous_agg_find_by_relid(rte->relid); if (!cagg_parent) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("invalid continuous aggregate query"), errhint("Continuous aggregate needs to query hypertable or another " "continuous aggregate."))); } if (!ContinuousAggIsFinalized(cagg_parent)) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("old format of continuous aggregate is not supported"), errhint("Run \"CALL cagg_migrate('%s.%s');\" to migrate to the new " "format.", NameStr(cagg_parent->data.user_view_schema), NameStr(cagg_parent->data.user_view_name)))); } parent_mat_hypertable_id = cagg_parent->data.mat_hypertable_id; ht = ts_hypertable_cache_get_entry_by_id(hcache, cagg_parent->data.mat_hypertable_id); /* If parent cagg is hierarchical then we should get the matht otherwise the rawht. */ if (ContinuousAggIsHierarchical(cagg_parent)) ht_parent = ts_hypertable_cache_get_entry_by_id(hcache, cagg_parent->data.mat_hypertable_id); else ht_parent = ts_hypertable_cache_get_entry_by_id(hcache, cagg_parent->data.raw_hypertable_id); /* Get the querydef for the source cagg. */ is_hierarchical = true; prev_query = ts_continuous_agg_get_query(cagg_parent); } /* * Check if user can refresh continuous aggregate * We only check for SELECT on the hypertable here but there * could be other permissions needed depending on the query. * For WITH DATA this is not a problem since we try a refresh * immediately but for WITH NO DATA the refresh might still * fail due to other permissions being needed. */ AclResult aclresult = pg_class_aclcheck(ht->main_table_relid, GetUserId(), ACL_SELECT); if (aclresult != ACLCHECK_OK) { /* User doesn't have permission */ aclcheck_error(aclresult, get_relkind_objtype(get_rel_relkind(ht->main_table_relid)), get_rel_name(ht->main_table_relid)); } if (TS_HYPERTABLE_IS_INTERNAL_COMPRESSION_TABLE(ht)) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertable is an internal compressed hypertable"))); } if (rte->relkind == RELKIND_RELATION) { ContinuousAggHypertableStatus status = ts_continuous_agg_hypertable_status(ht->fd.id); /* Prevent create a CAGG over an existing materialization hypertable. */ if (status == HypertableIsMaterialization || status == HypertableIsMaterializationAndRaw) { const ContinuousAgg *cagg = ts_continuous_agg_find_by_mat_hypertable_id(ht->fd.id, false); Assert(cagg != NULL); ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("hypertable is a continuous aggregate materialization table"), errdetail("Materialization hypertable \"%s.%s\".", NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name)), errhint("Do you want to use continuous aggregate \"%s.%s\" instead?", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)))); } } /* Get primary partitioning column information. */ part_dimension = hyperspace_get_open_dimension(ht->space, 0); /* * NOTE: if we ever allow custom partitioning functions we'll need to * change part_dimension->fd.column_type to partitioning_type * below, along with any other fallout. */ if (part_dimension == NULL || part_dimension->partitioning != NULL) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("custom partitioning functions not supported" " with continuous aggregates"))); } if (IS_INTEGER_TYPE(ts_dimension_get_partition_type(part_dimension)) && rte->relkind == RELKIND_RELATION) { const char *funcschema = NameStr(part_dimension->fd.integer_now_func_schema); const char *funcname = NameStr(part_dimension->fd.integer_now_func); if (strlen(funcschema) == 0 || strlen(funcname) == 0) { ts_cache_release(&hcache); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("custom time function required on hypertable \"%s\"", get_rel_name(ht->main_table_relid)), errdetail("An integer-based hypertable requires a custom time function to " "support continuous aggregates."), errhint("Set a custom time function on the hypertable."))); } } caggtimebucketinfo_init(&bucket_info, ht->fd.id, ht->main_table_relid, part_dimension->column_attno, part_dimension->fd.column_type, part_dimension->fd.interval_length, parent_mat_hypertable_id); if (is_hierarchical) { const Dimension *part_dimension_parent = hyperspace_get_open_dimension(ht_parent->space, 0); caggtimebucketinfo_init(&bucket_info_parent, ht_parent->fd.id, ht_parent->main_table_relid, part_dimension_parent->column_attno, part_dimension_parent->fd.column_type, part_dimension_parent->fd.interval_length, INVALID_HYPERTABLE_ID); } ts_cache_release(&hcache); /* * We need a GROUP By clause with time_bucket on the partitioning * column of the hypertable */ Assert(query->groupClause); caggtimebucket_validate(&bucket_info, query->groupClause, query->targetList, query->rtable, is_cagg_create); /* Check row security settings for the table. */ if (ts_has_row_security(rte->relid)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot create continuous aggregate on hypertable with row security"))); /* At this point, we should have a valid bucket function. Otherwise, we have errored out before. */ Ensure(OidIsValid(bucket_info.bf->bucket_function), "unable to find valid bucket function"); /* Ignore time_bucket_ng in this check, since offset and origin were allowed in the past */ FuncInfo *func_info = ts_func_cache_get_bucketing_func(bucket_info.bf->bucket_function); Ensure(func_info != NULL, "bucket function is not found in function cache"); /* hierarchical cagg validations */ if (is_hierarchical) { int64 bucket_width = 0, bucket_width_parent = 0; bool is_greater_or_equal_than_parent = true, is_multiple_of_parent = true; Assert(prev_query->groupClause); caggtimebucket_validate(&bucket_info_parent, prev_query->groupClause, prev_query->targetList, prev_query->rtable, is_cagg_create); /* Cannot create cagg with fixed bucket on top of variable bucket. */ if (time_bucket_info_has_fixed_width(bucket_info_parent.bf) == false && time_bucket_info_has_fixed_width(bucket_info.bf) == true) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot create continuous aggregate with fixed-width bucket on top of " "one using variable-width bucket"), errdetail("Continuous aggregate with a fixed time bucket width (e.g. 61 days) " "cannot be created on top of one using variable time bucket width " "(e.g. 1 month).\n" "The variance can lead to the fixed width one not being a multiple " "of the variable width one."))); } /* Get bucket widths for validation. */ bucket_width = get_bucket_width(bucket_info); bucket_width_parent = get_bucket_width(bucket_info_parent); Assert(bucket_width != 0); Assert(bucket_width_parent != 0); /* Check if the current bucket is greater or equal than the parent. */ is_greater_or_equal_than_parent = (bucket_width >= bucket_width_parent); /* Check if buckets are multiple. */ if (bucket_width_parent != 0) { if (bucket_width_parent > bucket_width && bucket_width != 0) is_multiple_of_parent = ((bucket_width_parent % bucket_width) == 0); else is_multiple_of_parent = ((bucket_width % bucket_width_parent) == 0); } /* Proceed with validation errors. */ if (!is_greater_or_equal_than_parent || !is_multiple_of_parent) { char *message = NULL; /* New bucket should be multiple of the parent. */ if (!is_multiple_of_parent) message = "multiple of"; /* New bucket should be greater than the parent. */ if (!is_greater_or_equal_than_parent) message = "greater or equal than"; ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot create continuous aggregate with incompatible bucket width"), errdetail("Time bucket width of \"%s.%s\" [%s] should be %s the time " "bucket width of \"%s.%s\" [%s].", cagg_schema, cagg_name, ts_datum_to_string(get_bucket_width_datum(bucket_info), bucket_info.bf->bucket_width_type), message, NameStr(cagg_parent->data.user_view_schema), NameStr(cagg_parent->data.user_view_name), ts_datum_to_string(get_bucket_width_datum(bucket_info_parent), bucket_info_parent.bf->bucket_width_type)))); } /* Test compatible time origin values */ if (bucket_info.bf->bucket_time_origin != bucket_info_parent.bf->bucket_time_origin) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "cannot create continuous aggregate with different bucket origin values"), errdetail("Time origin of \"%s.%s\" [%s] and \"%s.%s\" [%s] should be the " "same.", cagg_schema, cagg_name, ts_datum_to_string(TimestampTzGetDatum( bucket_info.bf->bucket_time_origin), TIMESTAMPTZOID), NameStr(cagg_parent->data.user_view_schema), NameStr(cagg_parent->data.user_view_name), ts_datum_to_string(TimestampTzGetDatum( bucket_info_parent.bf->bucket_time_origin), TIMESTAMPTZOID)))); } /* Test compatible time offset values */ if (bucket_info.bf->bucket_time_offset != NULL || bucket_info_parent.bf->bucket_time_offset != NULL) { bool bucket_offset_isnull = bucket_info.bf->bucket_time_offset == NULL; bool bucket_offset_parent_isnull = bucket_info_parent.bf->bucket_time_offset == NULL; Datum offset_datum = IntervalPGetDatum(bucket_info.bf->bucket_time_offset); Datum offset_datum_parent = IntervalPGetDatum(bucket_info_parent.bf->bucket_time_offset); bool both_buckets_are_equal = false; bool both_buckets_have_offset = !bucket_offset_isnull && !bucket_offset_parent_isnull; if (both_buckets_have_offset) { both_buckets_are_equal = DatumGetBool( DirectFunctionCall2(interval_eq, offset_datum, offset_datum_parent)); } if (!both_buckets_are_equal) { char *offset = !bucket_offset_isnull ? DatumGetCString(DirectFunctionCall1(interval_out, offset_datum)) : "NULL"; char *offset_parent = !bucket_offset_parent_isnull ? DatumGetCString(DirectFunctionCall1(interval_out, offset_datum_parent)) : "NULL"; ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot create continuous aggregate with different bucket offset " "values"), errdetail("Time origin of \"%s.%s\" [%s] and \"%s.%s\" [%s] should be the " "same.", cagg_schema, cagg_name, offset, NameStr(cagg_parent->data.user_view_schema), NameStr(cagg_parent->data.user_view_name), offset_parent))); } } /* Test compatible integer offset values */ if (bucket_info.bf->bucket_integer_offset != bucket_info_parent.bf->bucket_integer_offset) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "cannot create continuous aggregate with different bucket offset values"), errdetail("Integer offset of \"%s.%s\" [" INT64_FORMAT "] and \"%s.%s\" [" INT64_FORMAT "] should be the same.", cagg_schema, cagg_name, bucket_info.bf->bucket_integer_offset, NameStr(cagg_parent->data.user_view_schema), NameStr(cagg_parent->data.user_view_name), bucket_info_parent.bf->bucket_integer_offset))); } } if (is_hierarchical) bucket_info.htoidparent = cagg_parent->relid; return bucket_info; } /* * Get oid of function to convert from our internal representation * to postgres representation. */ Oid cagg_get_boundary_converter_funcoid(Oid typoid) { char *function_name; Oid argtyp[] = { INT8OID }; switch (typoid) { case DATEOID: function_name = INTERNAL_TO_DATE_FUNCTION; break; case TIMESTAMPOID: function_name = INTERNAL_TO_TS_FUNCTION; break; case TIMESTAMPTZOID: function_name = INTERNAL_TO_TSTZ_FUNCTION; break; default: /* * This should never be reached and unsupported datatypes * should be caught at much earlier stages. */ ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("no converter function defined for datatype: %s", format_type_be(typoid)))); pg_unreachable(); } List *func_name = list_make2(makeString(FUNCTIONS_SCHEMA_NAME), makeString(function_name)); Oid converter_oid = LookupFuncName(func_name, lengthof(argtyp), argtyp, false); Assert(OidIsValid(converter_oid)); return converter_oid; } static FuncExpr * build_conversion_call(Oid type, FuncExpr *boundary) { /* * If the partitioning column type is not integer we need to convert * to proper representation. */ switch (type) { case INT2OID: case INT4OID: { /* Since the boundary function returns int8 we need to cast to proper type here. */ Oid cast_oid = ts_get_cast_func(INT8OID, type); return makeFuncExpr(cast_oid, type, list_make1(boundary), InvalidOid, InvalidOid, COERCE_IMPLICIT_CAST); } case INT8OID: /* Nothing to do for int8. */ return boundary; case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: { /* * date/timestamp/timestamptz need to be converted since * we store them differently from postgres format. */ Oid converter_oid = cagg_get_boundary_converter_funcoid(type); return makeFuncExpr(converter_oid, type, list_make1(boundary), InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL); } default: /* * All valid types should be handled above, this should * never be reached and error handling at earlier stages * should catch this. */ ereport(ERROR, (errcode(ERRCODE_TS_INTERNAL_ERROR), errmsg("unsupported datatype for continuous aggregates: %s", format_type_be(type)))); pg_unreachable(); } } /* * Return the Oid of the cagg_watermark function */ Oid get_watermark_function_oid(void) { Oid argtyp[] = { INT4OID }; Oid boundary_func_oid = LookupFuncName(list_make2(makeString(FUNCTIONS_SCHEMA_NAME), makeString(BOUNDARY_FUNCTION)), lengthof(argtyp), argtyp, false); return boundary_func_oid; } /* * Build function call that returns boundary for a hypertable * wrapped in type conversion calls when required. */ static FuncExpr * build_boundary_call(int32 ht_id, Oid type) { FuncExpr *boundary; Oid boundary_func_oid = get_watermark_function_oid(); List *func_args = list_make1(makeConst(INT4OID, -1, InvalidOid, 4, Int32GetDatum(ht_id), false, true)); boundary = makeFuncExpr(boundary_func_oid, INT8OID, func_args, InvalidOid, InvalidOid, COERCE_EXPLICIT_CALL); return build_conversion_call(type, boundary); } /* * Create Const of proper type for lower bound of watermark when * watermark has not been set yet. */ static Const * cagg_boundary_make_lower_bound(Oid type) { Datum value; int16 typlen; bool typbyval; get_typlenbyval(type, &typlen, &typbyval); value = ts_time_datum_get_nobegin_or_min(type); return makeConst(type, -1, InvalidOid, typlen, value, false, typbyval); } static Node * build_union_query_quals(int32 ht_id, Oid partcoltype, Oid opno, int varno, AttrNumber attno) { Var *var = makeVar(varno, attno, partcoltype, -1, InvalidOid, InvalidOid); FuncExpr *boundary = build_boundary_call(ht_id, partcoltype); CoalesceExpr *coalesce = makeNode(CoalesceExpr); coalesce->coalescetype = partcoltype; coalesce->coalescecollid = InvalidOid; coalesce->args = list_make2(boundary, cagg_boundary_make_lower_bound(partcoltype)); return (Node *) make_opclause(opno, BOOLOID, false, (Expr *) var, (Expr *) coalesce, InvalidOid, InvalidOid); } static RangeTblEntry * makeRangeTblEntry(Query *query, const char *aliasname) { RangeTblEntry *rte = makeNode(RangeTblEntry); ListCell *lc; rte->rtekind = RTE_SUBQUERY; rte->relid = InvalidOid; rte->subquery = query; rte->alias = makeAlias(aliasname, NIL); rte->eref = copyObject(rte->alias); foreach (lc, query->targetList) { TargetEntry *tle = lfirst_node(TargetEntry, lc); if (!tle->resjunk) rte->eref->colnames = lappend(rte->eref->colnames, makeString(pstrdup(tle->resname))); } rte->lateral = false; rte->inh = false; /* never true for subqueries */ rte->inFromCl = false; return rte; } /* * Build union query combining the materialized data with data from the raw data hypertable. * * q1 is the query on the materialization hypertable with the finalize call * q2 is the query on the raw hypertable which was supplied in the initial CREATE VIEW statement * returns a query as * SELECT * from ( SELECT * from q1 where <coale_qual> * UNION ALL * SELECT * from q2 where existing_qual and <coale_qual> * where coale_qual is: time < ----> (or >= ) * * COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(<htid>)), * '-infinity'::timestamp with time zone) * * See build_union_query_quals for COALESCE clauses. */ Query * build_union_query(ContinuousAggTimeBucketInfo *tbinfo, int matpartcolno, Query *q1, Query *q2, int materialize_htid) { ListCell *lc1, *lc2; List *col_types = NIL; List *col_typmods = NIL; List *col_collations = NIL; List *tlist = NIL; List *sortClause = NIL; int varno; Node *q2_quals = NULL; Assert(list_length(q1->targetList) <= list_length(q2->targetList)); q1 = copyObject(q1); q2 = copyObject(q2); if (q1->sortClause) sortClause = copyObject(q1->sortClause); TypeCacheEntry *tce = lookup_type_cache(tbinfo->htpartcoltype, TYPECACHE_LT_OPR); varno = list_length(q1->rtable); q1->jointree->quals = build_union_query_quals(materialize_htid, tbinfo->htpartcoltype, tce->lt_opr, varno, matpartcolno); /* * If there is join in CAgg definition then adjust varno * to get time column from the hypertable in the join. */ varno = list_length(q2->rtable); if (list_length(q2->rtable) > 1) { int nvarno = 1; foreach (lc2, q2->rtable) { RangeTblEntry *rte = lfirst_node(RangeTblEntry, lc2); if (rte->rtekind == RTE_RELATION) { /* look for hypertable or parent hypertable in RangeTableEntry list */ if (rte->relid == tbinfo->htoid || rte->relid == tbinfo->htoidparent) { varno = nvarno; break; } } nvarno++; } } q2_quals = build_union_query_quals(materialize_htid, tbinfo->htpartcoltype, get_negator(tce->lt_opr), varno, tbinfo->htpartcolno); q2->jointree->quals = make_and_qual(q2->jointree->quals, q2_quals); Query *query = makeNode(Query); SetOperationStmt *setop = makeNode(SetOperationStmt); RangeTblEntry *rte_q1 = makeRangeTblEntry(q1, "*SELECT* 1"); RangeTblEntry *rte_q2 = makeRangeTblEntry(q2, "*SELECT* 2"); RangeTblRef *ref_q1 = makeNode(RangeTblRef); RangeTblRef *ref_q2 = makeNode(RangeTblRef); query->commandType = CMD_SELECT; query->rtable = list_make2(rte_q1, rte_q2); query->setOperations = (Node *) setop; setop->op = SETOP_UNION; setop->all = true; ref_q1->rtindex = 1; ref_q2->rtindex = 2; setop->larg = (Node *) ref_q1; setop->rarg = (Node *) ref_q2; forboth (lc1, q1->targetList, lc2, q2->targetList) { TargetEntry *tle = lfirst_node(TargetEntry, lc1); TargetEntry *tle2 = lfirst_node(TargetEntry, lc2); TargetEntry *tle_union; Var *expr; if (!tle->resjunk) { col_types = lappend_int(col_types, exprType((Node *) tle->expr)); col_typmods = lappend_int(col_typmods, exprTypmod((Node *) tle->expr)); col_collations = lappend_int(col_collations, exprCollation((Node *) tle->expr)); expr = makeVarFromTargetEntry(1, tle); /* * We need to use resname from q2 because that is the query from the * initial CREATE VIEW statement so the VIEW can be updated in place. */ tle_union = makeTargetEntry((Expr *) copyObject(expr), list_length(tlist) + 1, tle2->resname, false); tle_union->resorigtbl = expr->varno; tle_union->resorigcol = expr->varattno; tle_union->ressortgroupref = tle->ressortgroupref; tlist = lappend(tlist, tle_union); } } query->targetList = tlist; query->jointree = makeFromExpr(NIL, NULL); if (sortClause) { query->sortClause = sortClause; } setop->colTypes = col_types; setop->colTypmods = col_typmods; setop->colCollations = col_collations; return query; } /* * Returns true if the time bucket size is fixed */ static bool time_bucket_info_has_fixed_width(const ContinuousAggBucketFunction *bf) { if (!IS_TIME_BUCKET_INFO_TIME_BASED(bf)) { return true; } else { /* Historically, we treat all buckets with timezones as variable. Buckets with only days are * treated as fixed. */ return bf->bucket_time_width->month == 0 && bf->bucket_time_timezone == NULL; } } ContinuousAgg * cagg_get_by_relid_or_fail(const Oid cagg_relid) { ContinuousAgg *cagg; if (!OidIsValid(cagg_relid)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid continuous aggregate"))); cagg = ts_continuous_agg_find_by_relid(cagg_relid); if (NULL == cagg) { const char *relname = get_rel_name(cagg_relid); if (relname == NULL) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_TABLE), (errmsg("continuous aggregate does not exist")))); else ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), (errmsg("relation \"%s\" is not a continuous aggregate", relname)))); } return cagg; } /* Get time bucket function info based on the view definition */ ContinuousAggBucketFunction * ts_cagg_get_bucket_function_info(Oid view_oid) { Relation view_rel = relation_open(view_oid, AccessShareLock); Query *query = copyObject(get_view_query(view_rel)); relation_close(view_rel, NoLock); Assert(query != NULL); Assert(query->commandType == CMD_SELECT); ContinuousAggBucketFunction *bf = palloc0(sizeof(ContinuousAggBucketFunction)); ListCell *l; foreach (l, query->groupClause) { SortGroupClause *sgc = lfirst_node(SortGroupClause, l); TargetEntry *tle = get_sortgroupclause_tle(sgc, query->targetList); Expr *expr = tle->expr; #if PG18_GE /* PG18 introduced RTEs for group clauses so * we can use rtable to look up GROUP BY expressions. * * https://github.com/postgres/postgres/commit/247dea89 */ if (IsA(expr, Var)) { Var *var = castNode(Var, tle->expr); Assert((int) var->varno <= list_length(query->rtable)); RangeTblEntry *rte = list_nth(query->rtable, var->varno - 1); Assert(rte->rtekind == RTE_GROUP); Assert(var->varattno > 0); Expr *node = list_nth(rte->groupexprs, var->varattno - 1); if (IsA(node, FuncExpr)) expr = node; } #endif if (IsA(expr, FuncExpr)) { FuncExpr *fe = castNode(FuncExpr, expr); /* Filter any non bucketing functions */ FuncInfo *finfo = ts_func_cache_get_bucketing_func(fe->funcid); if (finfo == NULL) continue; Assert(finfo->is_bucketing_func); process_timebucket_parameters(fe, bf, false, false, InvalidAttrNumber); break; } } return bf; } /* * This function is responsible to return a list of column names used in * GROUP BY clause of the cagg query. It behaves a bit different depending * of the type of the Continuous Aggregate. * * 1) Partials form (finalized=false) * * Retrieve the "user view query" and find the GROUP BY clause and * "time_bucket" clause. Map them to the column names (of mat.hypertable) * * Note that the "user view query" has 2 forms: * - with UNION * - without UNION * * We have to extract the part of the query that has "finalize_agg" on * the materialized hypertable to find the GROUP BY clauses. * (see continuous_aggs/create.c for more info on the query structure) * * 2) Finals form (finalized=true) (>= 2.7) * * Retrieve the "direct view query" and find the GROUP BY clause and * "time_bucket" clause. We use the "direct view query" because in the * "user view query" we removed the re-aggregation in the part that query * the materialization hypertable so we don't have a GROUP BY clause * anymore. * * Get the column name from the GROUP BY clause because all the column * names are the same in all underlying objects (user view, direct view, * partial view and materialization hypertable). */ List * cagg_find_groupingcols(ContinuousAgg *agg, Hypertable *mat_ht) { List *retlist = NIL; ListCell *lc; Query *cagg_view_query = ts_continuous_agg_get_query(agg); Oid mat_relid = mat_ht->main_table_relid; Query *finalize_query; #if PG16_LT /* The view rule has dummy old and new range table entries as the 1st and 2nd entries */ Assert(list_length(cagg_view_query->rtable) >= 2); #endif if (cagg_view_query->setOperations) { /* * This corresponds to the union view. * PG16_LT the 3rd RTE entry has the SELECT 1 query from the union view. * PG16_GE the 1st RTE entry has the SELECT 1 query from the union view */ #if PG16_LT RangeTblEntry *finalize_query_rte = lthird(cagg_view_query->rtable); #else RangeTblEntry *finalize_query_rte = linitial(cagg_view_query->rtable); #endif if (finalize_query_rte->rtekind != RTE_SUBQUERY) ereport(ERROR, (errcode(ERRCODE_TS_UNEXPECTED), errmsg("unexpected rte type for view %d", finalize_query_rte->rtekind))); finalize_query = finalize_query_rte->subquery; } else { finalize_query = cagg_view_query; } foreach (lc, finalize_query->groupClause) { SortGroupClause *cagg_gc = (SortGroupClause *) lfirst(lc); TargetEntry *cagg_tle = get_sortgroupclause_tle(cagg_gc, finalize_query->targetList); if (ContinuousAggIsFinalized(agg)) { /* "resname" is the same as "mat column names" in the finalized version */ if (!cagg_tle->resjunk && cagg_tle->resname) retlist = lappend(retlist, get_attname(mat_relid, cagg_tle->resno, false)); } else { /* groupby clauses are columns from the mat hypertable */ Var *mat_var = castNode(Var, cagg_tle->expr); retlist = lappend(retlist, get_attname(mat_relid, mat_var->varattno, false)); } } return retlist; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/common.h�������������������������������������������������0000664�0000000�0000000�00000014671�15100345067�0022325�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/reloptions.h> #include <access/xact.h> #include <catalog/pg_aggregate.h> #include <catalog/pg_type.h> #include <catalog/toasting.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/parsenodes.h> #include <nodes/pg_list.h> #include <optimizer/optimizer.h> #include <parser/parse_func.h> #include <parser/parse_oper.h> #include <parser/parsetree.h> #include <rewrite/rewriteHandler.h> #include <rewrite/rewriteManip.h> #include <utils/builtins.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "errors.h" #include "func_cache.h" #include "hypertable_cache.h" #include "timezones.h" #include "ts_catalog/catalog.h" #include "ts_catalog/continuous_agg.h" #define DEFAULT_MATPARTCOLUMN_NAME "time_partition_col" #define CAGG_INVALIDATION_THRESHOLD_NAME "invalidation threshold watermark" #define CAGG_INVALIDATION_WRONG_GREATEST_VALUE ((int64) -210866803200000001) typedef struct FinalizeQueryInfo { List *final_seltlist; /* select target list for finalize query */ Node *final_havingqual; /* having qual for finalize query */ Query *final_userquery; /* user query used to compute the finalize_query */ bool finalized; /* finalized form? */ } FinalizeQueryInfo; typedef struct MaterializationHypertableColumnInfo { List *matcollist; /* column defns for materialization tbl*/ List *partial_seltlist; /* tlist entries for populating the materialization table columns */ List *partial_grouplist; /* group clauses used for populating the materialization table */ List *mat_groupcolname_list; /* names of columns that are populated by the group-by clause correspond to the partial_grouplist. time_bucket column is not included here: it is the matpartcolname */ int matpartcolno; /*index of partitioning column in matcollist */ char *matpartcolname; /*name of the partition column */ } MaterializationHypertableColumnInfo; typedef struct ContinuousAggTimeBucketInfo { int32 htid; /* hypertable id */ int32 parent_mat_hypertable_id; /* parent materialization hypertable id */ Oid htoid; /* hypertable oid */ Oid htoidparent; /* parent hypertable oid in case of hierarchical */ AttrNumber htpartcolno; /* primary partitioning column of raw hypertable */ /* This should also be the column used by time_bucket */ Oid htpartcoltype; /* The collation type */ int64 htpartcol_interval_len; /* interval length setting for primary partitioning column */ /* General bucket information */ ContinuousAggBucketFunction *bf; } ContinuousAggTimeBucketInfo; typedef enum ContinuousAggRefreshCallContext { CAGG_REFRESH_CREATION, CAGG_REFRESH_WINDOW, CAGG_REFRESH_POLICY, CAGG_REFRESH_POLICY_BATCHED } ContinuousAggRefreshCallContext; typedef struct ContinuousAggRefreshContext { ContinuousAggRefreshCallContext callctx; int32 processing_batch; int32 number_of_batches; } ContinuousAggRefreshContext; #define IS_TIME_BUCKET_INFO_TIME_BASED(bucket_function) \ (bucket_function->bucket_width_type == INTERVALOID) #define CAGG_MAKEQUERY(selquery, srcquery) \ do \ { \ (selquery) = makeNode(Query); \ (selquery)->commandType = CMD_SELECT; \ (selquery)->querySource = (srcquery)->querySource; \ (selquery)->queryId = (srcquery)->queryId; \ (selquery)->canSetTag = (srcquery)->canSetTag; \ (selquery)->utilityStmt = copyObject((srcquery)->utilityStmt); \ (selquery)->resultRelation = 0; \ (selquery)->hasAggs = true; \ (selquery)->hasRowSecurity = false; \ (selquery)->rtable = NULL; \ } while (0); extern ContinuousAggTimeBucketInfo cagg_validate_query(const Query *query, const bool finalized, const char *cagg_schema, const char *cagg_name, const bool is_cagg_create); extern Query *destroy_union_query(Query *q); extern void RemoveRangeTableEntries(Query *query); extern Query *build_union_query(ContinuousAggTimeBucketInfo *tbinfo, int matpartcolno, Query *q1, Query *q2, int materialize_htid); extern void mattablecolumninfo_init(MaterializationHypertableColumnInfo *matcolinfo, List *grouplist); extern bool function_allowed_in_cagg_definition(Oid funcid); extern Oid get_watermark_function_oid(void); extern Oid cagg_get_boundary_converter_funcoid(Oid typoid); extern ContinuousAgg *cagg_get_by_relid_or_fail(const Oid cagg_relid); extern List *cagg_find_groupingcols(ContinuousAgg *agg, Hypertable *mat_ht); static inline int64 cagg_get_time_min(const ContinuousAgg *cagg) { if (cagg->bucket_function->bucket_fixed_interval == false) { /* * To determine inscribed/circumscribed refresh window for variable-sized * buckets we should be able to calculate time_bucket(window.begin) and * time_bucket(window.end). This, however, is not possible in general case. * As an example, the minimum date is 4714-11-24 BC, which is before any * reasonable default `origin` value. Thus for variable-sized buckets * instead of minimum date we use -infinity since time_bucket(-infinity) * is well-defined as -infinity. * * For more details see: * - ts_compute_inscribed_bucketed_refresh_window_variable() * - ts_compute_circumscribed_bucketed_refresh_window_variable() */ return ts_time_get_nobegin_or_min(cagg->partition_type); } /* For fixed-sized buckets return min (start of time) */ return ts_time_get_min(cagg->partition_type); } ContinuousAggBucketFunction *ts_cagg_get_bucket_function_info(Oid view_oid); �����������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/create.c�������������������������������������������������0000664�0000000�0000000�00000116353�15100345067�0022273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains the code for processing continuous aggregate * DDL statements which are of the form: * * CREATE MATERIALIZED VIEW <name> WITH (ts_continuous = [option] ) * AS <select query> * The entry point for the code is * tsl_process_continuous_agg_viewstmt * The bulk of the code that creates the underlying tables/views etc. is in * cagg_create. */ #include <postgres.h> #include <access/reloptions.h> #include <access/sysattr.h> #include <access/xact.h> #include <access/xlogutils.h> #include <catalog/index.h> #include <catalog/indexing.h> #include <catalog/pg_namespace.h> #include <catalog/pg_type.h> #include <catalog/toasting.h> #include <commands/defrem.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <commands/view.h> #include <executor/spi.h> #include <fmgr.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/nodes.h> #include <nodes/parsenodes.h> #include <nodes/pg_list.h> #include <optimizer/clauses.h> #include <optimizer/optimizer.h> #include <optimizer/prep.h> #include <optimizer/tlist.h> #include <parser/analyze.h> #include <parser/parse_func.h> #include <parser/parse_oper.h> #include <parser/parse_relation.h> #include <parser/parse_type.h> #include <parser/parsetree.h> #include <replication/logical.h> #include <replication/slot.h> #include <storage/lwlocknames.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/catcache.h> #include <utils/elog.h> #include <utils/pg_lsn.h> #include <utils/rel.h> #include <utils/resowner.h> #include <utils/ruleutils.h> #include <utils/snapshot.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "common.h" #include "config.h" #include "create.h" #include "finalize.h" #include "invalidation_threshold.h" #include "continuous_aggs/invalidation_multi.h" #include "debug_assert.h" #include "dimension.h" #include "extension_constants.h" #include "guc.h" #include "hypertable.h" #include "hypertable_cache.h" #include "invalidation.h" #include "refresh.h" #include "time_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/continuous_aggs_watermark.h" #include "with_clause/create_materialized_view_with_clause.h" static void create_cagg_catalog_entry(int32 matht_id, int32 rawht_id, const char *user_schema, const char *user_view, const char *partial_schema, const char *partial_view, bool materialized_only, const char *direct_schema, const char *direct_view, const bool finalized, const int32 parent_mat_hypertable_id); static void create_bucket_function_catalog_entry(int32 matht_id, Oid bucket_function, const char *bucket_width, const char *origin, const char *offset, const char *timezone, const bool bucket_fixed_width); static void cagg_create_hypertable(int32 hypertable_id, Oid mat_tbloid, const char *matpartcolname, int64 mat_tbltimecol_interval); static void mattablecolumninfo_add_mattable_index(MaterializationHypertableColumnInfo *matcolinfo, Hypertable *ht); static ObjectAddress create_view_for_query(Query *selquery, RangeVar *viewrel); static void fixup_userview_query_tlist(Query *userquery, List *tlist_aliases); static void cagg_create(const CreateTableAsStmt *create_stmt, ViewStmt *stmt, Query *panquery, ContinuousAggTimeBucketInfo *bucket_info, WithClauseResult *with_clause_options); #define MATPARTCOL_INTERVAL_FACTOR 10 static void makeMaterializedTableName(char *buf, const char *prefix, int hypertable_id) { int ret = snprintf(buf, NAMEDATALEN, prefix, hypertable_id); if (ret < 0 || ret > NAMEDATALEN) { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("bad materialization internal name"))); } } /* STATIC functions defined on the structs above. */ static int32 mattablecolumninfo_create_materialization_table( MaterializationHypertableColumnInfo *matcolinfo, int32 hypertable_id, RangeVar *mat_rel, ContinuousAggTimeBucketInfo *bucket_info, bool create_addl_index, char *tablespacename, char *table_access_method, int64 matpartcol_interval, ObjectAddress *mataddress); static Query * mattablecolumninfo_get_partial_select_query(MaterializationHypertableColumnInfo *mattblinfo, Query *userview_query, bool finalized); /* * Create a entry for the materialization table in table CONTINUOUS_AGGS. */ static void create_cagg_catalog_entry(int32 matht_id, int32 rawht_id, const char *user_schema, const char *user_view, const char *partial_schema, const char *partial_view, bool materialized_only, const char *direct_schema, const char *direct_view, const bool finalized, const int32 parent_mat_hypertable_id) { Catalog *catalog = ts_catalog_get(); Relation rel; TupleDesc desc; NameData user_schnm, user_viewnm, partial_schnm, partial_viewnm, direct_schnm, direct_viewnm; Datum values[Natts_continuous_agg]; bool nulls[Natts_continuous_agg] = { false }; CatalogSecurityContext sec_ctx; namestrcpy(&user_schnm, user_schema); namestrcpy(&user_viewnm, user_view); namestrcpy(&partial_schnm, partial_schema); namestrcpy(&partial_viewnm, partial_view); namestrcpy(&direct_schnm, direct_schema); namestrcpy(&direct_viewnm, direct_view); rel = table_open(catalog_get_table_id(catalog, CONTINUOUS_AGG), RowExclusiveLock); desc = RelationGetDescr(rel); memset(values, 0, sizeof(values)); values[AttrNumberGetAttrOffset(Anum_continuous_agg_mat_hypertable_id)] = matht_id; values[AttrNumberGetAttrOffset(Anum_continuous_agg_raw_hypertable_id)] = rawht_id; if (parent_mat_hypertable_id == INVALID_HYPERTABLE_ID) nulls[AttrNumberGetAttrOffset(Anum_continuous_agg_parent_mat_hypertable_id)] = true; else { values[AttrNumberGetAttrOffset(Anum_continuous_agg_parent_mat_hypertable_id)] = parent_mat_hypertable_id; } values[AttrNumberGetAttrOffset(Anum_continuous_agg_user_view_schema)] = NameGetDatum(&user_schnm); values[AttrNumberGetAttrOffset(Anum_continuous_agg_user_view_name)] = NameGetDatum(&user_viewnm); values[AttrNumberGetAttrOffset(Anum_continuous_agg_partial_view_schema)] = NameGetDatum(&partial_schnm); values[AttrNumberGetAttrOffset(Anum_continuous_agg_partial_view_name)] = NameGetDatum(&partial_viewnm); values[AttrNumberGetAttrOffset(Anum_continuous_agg_direct_view_schema)] = NameGetDatum(&direct_schnm); values[AttrNumberGetAttrOffset(Anum_continuous_agg_direct_view_name)] = NameGetDatum(&direct_viewnm); values[AttrNumberGetAttrOffset(Anum_continuous_agg_materialize_only)] = BoolGetDatum(materialized_only); values[AttrNumberGetAttrOffset(Anum_continuous_agg_finalized)] = BoolGetDatum(finalized); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); table_close(rel, RowExclusiveLock); } /* * Create a entry for the materialization table in table * CONTINUOUS_AGGS_BUCKET_FUNCTION. */ static void create_bucket_function_catalog_entry(int32 matht_id, Oid bucket_function, const char *bucket_width, const char *bucket_origin, const char *bucket_offset, const char *bucket_timezone, const bool bucket_fixed_width) { Catalog *catalog = ts_catalog_get(); Relation rel; TupleDesc desc; Datum values[Natts_continuous_aggs_bucket_function]; bool nulls[Natts_continuous_aggs_bucket_function] = { false }; CatalogSecurityContext sec_ctx; Assert(OidIsValid(bucket_function)); Assert(bucket_width != NULL); rel = table_open(catalog_get_table_id(catalog, CONTINUOUS_AGGS_BUCKET_FUNCTION), RowExclusiveLock); desc = RelationGetDescr(rel); memset(values, 0, sizeof(values)); /* Hypertable ID */ values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_mat_hypertable_id)] = matht_id; /* Bucket function */ values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_function)] = CStringGetTextDatum(format_procedure_qualified(bucket_function)); /* Bucket width */ values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_width)] = CStringGetTextDatum(bucket_width); /* Bucket origin */ if (bucket_origin != NULL) { values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)] = CStringGetTextDatum(bucket_origin); } else { nulls[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)] = true; } /* Bucket offset */ if (bucket_offset != NULL) { values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_offset)] = CStringGetTextDatum(bucket_offset); } else { nulls[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_offset)] = true; } /* Bucket timezone */ if (bucket_timezone != NULL) { values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_timezone)] = CStringGetTextDatum(bucket_timezone); } else { nulls[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_timezone)] = true; } /* Bucket fixed width */ values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_fixed_width)] = BoolGetDatum(bucket_fixed_width); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); table_close(rel, RowExclusiveLock); } /* * Create hypertable for the table referred by mat_tbloid * matpartcolname - partition column for hypertable * timecol_interval - is the partitioning column's interval for hypertable partition */ static void cagg_create_hypertable(int32 hypertable_id, Oid mat_tbloid, const char *matpartcolname, int64 mat_tbltimecol_interval) { bool created; int flags = 0; NameData mat_tbltimecol; DimensionInfo *time_dim_info; ChunkSizingInfo *chunk_sizing_info; namestrcpy(&mat_tbltimecol, matpartcolname); time_dim_info = ts_dimension_info_create_open(mat_tbloid, &mat_tbltimecol, Int64GetDatum(mat_tbltimecol_interval), INT8OID, InvalidOid); /* * Ideally would like to change/expand the API so setting the column name manually is * unnecessary, but not high priority. */ chunk_sizing_info = ts_chunk_sizing_info_get_default_disabled(mat_tbloid); chunk_sizing_info->colname = matpartcolname; created = ts_hypertable_create_from_info(mat_tbloid, hypertable_id, flags, time_dim_info, NULL, NULL, NULL, chunk_sizing_info); if (!created) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("could not create materialization hypertable"))); } /* * Add a logical decoding slot for reading invalidations. * * It is the responsibility of the caller to check that the replication slot * does not exist. There is an assert to check this. * * This code is mostly copied from create_logical_replication_slot and friends * in slotfunc.c. * * It is important that the slot exists if and only if there are continuous * aggregates that use the WAL to collect invalidations. * * Obviously, the slot is needed to read invalidations for the hypertables and * it needs to have the version expected by the timescale extension. If the * versions do not match, the rows returned by pg_logical_slot_get_changes() * will not match what is expected and decoding will fail. * * Less obvious, the slot needs to be removed once there are no more continuous * aggregates that need the slot. If not, the WAL will not be used and will * start to fill up storage. * * There is a bug in PostgreSQL causing it to error out before the slot is * created in LogicalDecodingProcessRecord() trying to allocate too much * memory if you have too many other concurrent transactions in progress. */ static void cagg_add_logical_decoding_slot_prepare(const char *slot_name) { CatalogSecurityContext sec_ctx; LogicalDecodingContext *ctx = NULL; const char *plugin_name = CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_PLUGIN_NAME; Assert(!MyReplicationSlot); Assert(SearchNamedReplicationSlot(slot_name, true) == NULL); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); TS_DEBUG_LOG("create invalidation slot %s", slot_name); /* * Similar to how it works in create_logical_replication_slot(), this * initially create persistent slot as ephemeral to be able to handle * errors during initialization and allow it to be dropped if this * transaction fails. It's made persistent after the continuous aggregate * has been successfully created. */ #if PG17_LT ReplicationSlotCreate(slot_name, true, RS_EPHEMERAL, false); #else ReplicationSlotCreate(slot_name, true, RS_EPHEMERAL, false, false, false); #endif TS_DEBUG_LOG("init plugin %s", plugin_name); ctx = CreateInitDecodingContext(plugin_name, NIL, false, InvalidXLogRecPtr, XL_ROUTINE(.page_read = read_local_xlog_page, .segment_open = wal_segment_open, .segment_close = wal_segment_close), NULL, NULL, NULL); /* * To avoid the above mentioned bug, we can find our own start point here * in a manner that does not require allocating a lot of memory. */ TS_DEBUG_LOG("find startpoint"); DecodingContextFindStartpoint(ctx); TS_DEBUG_LOG("free decoding context"); FreeDecodingContext(ctx); ts_catalog_restore_user(&sec_ctx); } static void cagg_add_logical_decoding_slot_finalize(void) { TS_DEBUG_LOG("persist invalidation slot"); ReplicationSlotPersist(); ReplicationSlotRelease(); } /* * Add additional indexes to materialization table for the columns derived from * the group-by column list of the partial select query. * If partial select query has: * GROUP BY timebucket_expr, <grpcol1, grpcol2, grpcol3 ...> * index on mattable is <grpcol1, timebucketcol>, <grpcol2, timebucketcol> ... and so on. * i.e. #indexes =( #grp-cols - 1) */ static void mattablecolumninfo_add_mattable_index(MaterializationHypertableColumnInfo *matcolinfo, Hypertable *ht) { IndexStmt stmt = { .type = T_IndexStmt, .accessMethod = DEFAULT_INDEX_TYPE, .idxname = NULL, .relation = makeRangeVar(NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), 0), .tableSpace = get_tablespace_name(get_rel_tablespace(ht->main_table_relid)), }; IndexElem timeelem = { .type = T_IndexElem, .name = matcolinfo->matpartcolname, .ordering = SORTBY_DESC }; ListCell *le = NULL; foreach (le, matcolinfo->mat_groupcolname_list) { NameData indxname; ObjectAddress indxaddr; HeapTuple indxtuple; char *grpcolname = (char *) lfirst(le); IndexElem grpelem = { .type = T_IndexElem, .name = grpcolname }; stmt.indexParams = list_make2(&grpelem, &timeelem); indxaddr = DefineIndexCompat(ht->main_table_relid, &stmt, InvalidOid, /* indexRelationId */ InvalidOid, /* parentIndexId */ InvalidOid, /* parentConstraintId */ -1, /* total_parts */ false, /* is_alter_table */ false, /* check_rights */ false, /* check_not_in_use */ false, /* skip_build */ false); /* quiet */ indxtuple = SearchSysCache1(RELOID, ObjectIdGetDatum(indxaddr.objectId)); if (!HeapTupleIsValid(indxtuple)) elog(ERROR, "cache lookup failed for index relid %u", indxaddr.objectId); indxname = ((Form_pg_class) GETSTRUCT(indxtuple))->relname; elog(DEBUG1, "adding index %s ON %s.%s USING BTREE(%s, %s)", NameStr(indxname), NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name), grpcolname, matcolinfo->matpartcolname); ReleaseSysCache(indxtuple); } } /* * Create the materialization hypertable root by faking up a * CREATE TABLE parsetree and passing it to DefineRelation. * Reuse the information from ViewStmt: * Remove the options on the into clause that we will not honour * Modify the relname to ts_internal_<name> * * Parameters: * mat_rel: relation information for the materialization table * bucket_info: bucket information used for setting up the * hypertable partitioning (`chunk_interval_size`). * tablespace_name: Name of the tablespace for the materialization table. * table_access_method: Name of the table access method to use for the * materialization table. * mataddress: return the ObjectAddress RETURNS: hypertable id of the * materialization table */ static int32 mattablecolumninfo_create_materialization_table( MaterializationHypertableColumnInfo *matcolinfo, int32 hypertable_id, RangeVar *mat_rel, ContinuousAggTimeBucketInfo *bucket_info, bool create_addl_index, char *const tablespacename, char *const table_access_method, int64 matpartcol_interval, ObjectAddress *mataddress) { Oid uid, saved_uid; int sec_ctx; char *matpartcolname = matcolinfo->matpartcolname; CreateStmt *create; Datum toast_options; #if PG18_LT char *validnsps[] = HEAP_RELOPT_NAMESPACES; #else const char *const validnsps[] = HEAP_RELOPT_NAMESPACES; #endif int32 mat_htid; Oid mat_relid; Cache *hcache; Hypertable *mat_ht = NULL, *orig_ht = NULL; Oid owner = GetUserId(); create = makeNode(CreateStmt); create->relation = mat_rel; create->tableElts = matcolinfo->matcollist; create->inhRelations = NIL; create->ofTypename = NULL; create->constraints = NIL; create->options = NULL; create->oncommit = ONCOMMIT_NOOP; create->tablespacename = tablespacename; create->accessMethod = table_access_method; create->if_not_exists = false; /* Create the materialization table. */ SWITCH_TO_TS_USER(mat_rel->schemaname, uid, saved_uid, sec_ctx); *mataddress = DefineRelation(create, RELKIND_RELATION, owner, NULL, NULL); CommandCounterIncrement(); mat_relid = mataddress->objectId; /* NewRelationCreateToastTable calls CommandCounterIncrement. */ toast_options = transformRelOptions((Datum) 0, create->options, "toast", validnsps, true, false); (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); NewRelationCreateToastTable(mat_relid, toast_options); RESTORE_USER(uid, saved_uid, sec_ctx); cagg_create_hypertable(hypertable_id, mat_relid, matpartcolname, matpartcol_interval); /* Retrieve the hypertable id from the cache. */ mat_ht = ts_hypertable_cache_get_cache_and_entry(mat_relid, CACHE_FLAG_NONE, &hcache); mat_htid = mat_ht->fd.id; /* Create additional index on the group-by columns for the materialization table. */ if (create_addl_index) mattablecolumninfo_add_mattable_index(matcolinfo, mat_ht); /* * Initialize the invalidation log for the cagg. Initially, everything is * invalid. Add an infinite invalidation for the continuous * aggregate. This is the initial state of the aggregate before any * refreshes. */ orig_ht = ts_hypertable_cache_get_entry(hcache, bucket_info->htoid, CACHE_FLAG_NONE); continuous_agg_invalidate_mat_ht(orig_ht, mat_ht, TS_TIME_NOBEGIN, TS_TIME_NOEND); ts_cache_release(&hcache); return mat_htid; } /* * Use the userview query to create the partial query to populate * the materialization columns and remove HAVING clause and ORDER BY. */ static Query * mattablecolumninfo_get_partial_select_query(MaterializationHypertableColumnInfo *mattblinfo, Query *userview_query, bool finalized) { Query *partial_selquery = NULL; if (!finalized) { CAGG_MAKEQUERY(partial_selquery, userview_query); partial_selquery->rtable = copyObject(userview_query->rtable); partial_selquery->jointree = copyObject(userview_query->jointree); #if PG16_GE partial_selquery->rteperminfos = copyObject(userview_query->rteperminfos); #endif partial_selquery->targetList = mattblinfo->partial_seltlist; partial_selquery->groupClause = mattblinfo->partial_grouplist; partial_selquery->havingQual = NULL; partial_selquery->sortClause = NULL; } else { partial_selquery = copyObject(userview_query); /* Partial view should always include the time dimension column */ partial_selquery->targetList = mattblinfo->partial_seltlist; partial_selquery->groupClause = mattblinfo->partial_grouplist; } return partial_selquery; } /* * Create a view for the query using the SELECt stmt sqlquery * and view name from RangeVar viewrel. */ static ObjectAddress create_view_for_query(Query *selquery, RangeVar *viewrel) { Oid uid, saved_uid; int sec_ctx; ObjectAddress address; CreateStmt *create; List *selcollist = NIL; Oid owner = GetUserId(); ListCell *lc; foreach (lc, selquery->targetList) { TargetEntry *tle = (TargetEntry *) lfirst(lc); if (!tle->resjunk) { ColumnDef *col = makeColumnDef(tle->resname, exprType((Node *) tle->expr), exprTypmod((Node *) tle->expr), exprCollation((Node *) tle->expr)); selcollist = lappend(selcollist, col); } } create = makeNode(CreateStmt); create->relation = viewrel; create->tableElts = selcollist; create->inhRelations = NIL; create->ofTypename = NULL; create->constraints = NIL; create->options = NULL; create->oncommit = ONCOMMIT_NOOP; create->tablespacename = NULL; create->if_not_exists = false; /* * Create the view. Viewname is in viewrel. */ SWITCH_TO_TS_USER(viewrel->schemaname, uid, saved_uid, sec_ctx); address = DefineRelation(create, RELKIND_VIEW, owner, NULL, NULL); CommandCounterIncrement(); StoreViewQuery(address.objectId, selquery, false); CommandCounterIncrement(); RESTORE_USER(uid, saved_uid, sec_ctx); return address; } /* * Assign aliases to the targetlist in the query according to the * column_names provided in the CREATE VIEW statement. */ static void fixup_userview_query_tlist(Query *userquery, List *tlist_aliases) { if (tlist_aliases != NIL) { ListCell *lc; ListCell *alist_item = list_head(tlist_aliases); foreach (lc, userquery->targetList) { TargetEntry *tle = (TargetEntry *) lfirst(lc); /* Junk columns don't get aliases. */ if (tle->resjunk) continue; tle->resname = pstrdup(strVal(lfirst(alist_item))); alist_item = lnext(tlist_aliases, alist_item); if (alist_item == NULL) break; /* done assigning aliases */ } if (alist_item != NULL) ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("too many column names specified"))); } } /* * Modifies the passed in ViewStmt to do the following * a) Create a hypertable for the continuous agg materialization. * b) create a view that references the underlying * materialization table instead of the original table used in * the CREATE VIEW stmt. * Example: * CREATE VIEW mcagg ... * AS select a, min(b)+max(d) from foo group by a,timebucket(a); * * Step 1. create a materialiation table which stores the partials for the * aggregates and the grouping columns + internal columns. * So we have a table like _materialization_hypertable * with columns: *( a, col1, col2, col3, internal-columns) * where col1 = partialize(min(b)), col2= partialize(max(d)), * col3= timebucket(a)) * * Step 2: Create a view with modified select query * CREATE VIEW mcagg * as * select a, finalize( col1) + finalize(col2)) * from _materialization_hypertable * group by a, col3 * * Step 3: Create a view to populate the materialization table * create view ts_internal_mcagg_view * as * select a, partialize(min(b)), partialize(max(d)), timebucket(a), <internal-columns> * from foo * group by <internal-columns> , a , timebucket(a); * * Notes: ViewStmt->query is the raw parse tree * panquery is the output of running parse_anlayze( ViewStmt->query) * Since 1.7, we support real time aggregation. * If real time aggregation is off i.e. materialized only, the mcagg view is as described in Step 2. * If it is turned on * we build a union query that selects from the internal mat view and the raw hypertable * (see build_union_query for details) * CREATE VIEW mcagg * as * SELECT * from * ( SELECT a, finalize(col1) + finalize(col2) from ts_internal_mcagg_view * ---> query from Step 2 with additional where clause * WHERE timecol < materialization threshold * group by <internal-columns> , a , timebucket(a); * UNION ALL * SELECT a, min(b)+max(d) from foo ---> original view stmt * ----> with additional where clause * WHERE timecol >= materialization threshold * GROUP BY a, time_bucket(a) * ) */ static void cagg_create(const CreateTableAsStmt *create_stmt, ViewStmt *stmt, Query *panquery, ContinuousAggTimeBucketInfo *bucket_info, WithClauseResult *with_clause_options) { ObjectAddress mataddress; char relnamebuf[NAMEDATALEN]; MaterializationHypertableColumnInfo mattblinfo; FinalizeQueryInfo finalqinfo; CatalogSecurityContext sec_ctx; bool is_create_mattbl_index; Query *final_selquery; Query *partial_selquery; /* query to populate the mattable*/ Query *orig_userview_query; /* copy of the original user query for dummy view */ Oid nspid; RangeVar *part_rel = NULL, *mat_rel = NULL, *dum_rel = NULL; int32 materialize_hypertable_id; bool materialized_only = DatumGetBool(with_clause_options[CreateMaterializedViewFlagMaterializedOnly].parsed); bool finalized = DatumGetBool(with_clause_options[CreateMaterializedViewFlagFinalized].parsed); bool slot_prepared = false; int64 matpartcol_interval = 0; if (!with_clause_options[CreateMaterializedViewFlagChunkTimeInterval].is_default) { matpartcol_interval = interval_to_usec(DatumGetIntervalP( with_clause_options[CreateMaterializedViewFlagChunkTimeInterval].parsed)); } else { matpartcol_interval = bucket_info->htpartcol_interval_len; /* Apply the factor just for non-Hierachical CAggs */ if (bucket_info->parent_mat_hypertable_id == INVALID_HYPERTABLE_ID) matpartcol_interval *= MATPARTCOL_INTERVAL_FACTOR; } finalqinfo.finalized = finalized; /* * Assign the column_name aliases in CREATE VIEW to the query. * No other modifications to panquery. */ fixup_userview_query_tlist(panquery, stmt->aliases); mattablecolumninfo_init(&mattblinfo, copyObject(panquery->groupClause)); finalizequery_init(&finalqinfo, panquery, &mattblinfo); /* * Invalidate all options on the stmt before using it * The options are valid only for internal use (ts_continuous). */ stmt->options = NULL; /* * Step 0: Create logical replication slot if used. This needs to be first * since we cannot do this in a transaction that has performed any writes. */ if (ts_guc_enable_cagg_wal_based_invalidation) { char slot_name[TS_INVALIDATION_SLOT_NAME_MAX]; ts_get_invalidation_replication_slot_name(slot_name, sizeof(slot_name)); if (SearchNamedReplicationSlot(slot_name, true) == NULL) { cagg_add_logical_decoding_slot_prepare(slot_name); slot_prepared = true; } } /* * Old format caggs are not supported anymore, there is no need to add * an internal chunk id column for materialized hypertable. * * Step 1: create the materialization table. */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); materialize_hypertable_id = ts_catalog_table_next_seq_id(ts_catalog_get(), HYPERTABLE); ts_catalog_restore_user(&sec_ctx); makeMaterializedTableName(relnamebuf, "_materialized_hypertable_%d", materialize_hypertable_id); mat_rel = makeRangeVar(pstrdup(INTERNAL_SCHEMA_NAME), pstrdup(relnamebuf), -1); is_create_mattbl_index = DatumGetBool(with_clause_options[CreateMaterializedViewFlagCreateGroupIndexes].parsed); mattablecolumninfo_create_materialization_table(&mattblinfo, materialize_hypertable_id, mat_rel, bucket_info, is_create_mattbl_index, create_stmt->into->tableSpaceName, create_stmt->into->accessMethod, matpartcol_interval, &mataddress); /* * Step 2: Create view with select finalize from materialization table. */ final_selquery = finalizequery_get_select_query(&finalqinfo, mattblinfo.matcollist, &mataddress, mat_rel->relname); if (!materialized_only) final_selquery = build_union_query(bucket_info, mattblinfo.matpartcolno, final_selquery, panquery, materialize_hypertable_id); /* Copy view acl to materialization hypertable. */ ObjectAddress view_address = create_view_for_query(final_selquery, stmt->view); ts_copy_relation_acl(view_address.objectId, mataddress.objectId, GetUserId()); /* * Step 3: create the internal view with select partialize(..). */ partial_selquery = mattablecolumninfo_get_partial_select_query(&mattblinfo, panquery, finalqinfo.finalized); makeMaterializedTableName(relnamebuf, "_partial_view_%d", materialize_hypertable_id); part_rel = makeRangeVar(pstrdup(INTERNAL_SCHEMA_NAME), pstrdup(relnamebuf), -1); create_view_for_query(partial_selquery, part_rel); /* * Additional miscellaneous steps. */ /* * Create a dummy view to store the user supplied view query. * This is to get PG to display the view correctly without * having to replicate the PG source code for make_viewdef. */ orig_userview_query = copyObject(panquery); makeMaterializedTableName(relnamebuf, "_direct_view_%d", materialize_hypertable_id); dum_rel = makeRangeVar(pstrdup(INTERNAL_SCHEMA_NAME), pstrdup(relnamebuf), -1); create_view_for_query(orig_userview_query, dum_rel); /* Step 4: Add catalog table entry for the objects we just created. */ nspid = RangeVarGetCreationNamespace(stmt->view); create_cagg_catalog_entry(materialize_hypertable_id, bucket_info->htid, get_namespace_name(nspid), /*schema name for user view */ stmt->view->relname, part_rel->schemaname, part_rel->relname, materialized_only, dum_rel->schemaname, dum_rel->relname, finalized, bucket_info->parent_mat_hypertable_id); char *bucket_origin = NULL; char *bucket_offset = NULL; char *bucket_width = NULL; if (IS_TIME_BUCKET_INFO_TIME_BASED(bucket_info->bf)) { /* Bucketing on time */ Assert(bucket_info->bf->bucket_time_width != NULL); bucket_width = DatumGetCString( DirectFunctionCall1(interval_out, IntervalPGetDatum(bucket_info->bf->bucket_time_width))); if (!TIMESTAMP_NOT_FINITE(bucket_info->bf->bucket_time_origin)) { bucket_origin = DatumGetCString( DirectFunctionCall1(timestamptz_out, TimestampTzGetDatum(bucket_info->bf->bucket_time_origin))); } if (bucket_info->bf->bucket_time_offset != NULL) { bucket_offset = DatumGetCString( DirectFunctionCall1(interval_out, IntervalPGetDatum(bucket_info->bf->bucket_time_offset))); } } else { /* Bucketing on integers */ bucket_width = palloc0(MAXINT8LEN + 1); pg_lltoa(bucket_info->bf->bucket_integer_width, bucket_width); /* Integer buckets with origin are not supported, so noting to do. */ Assert(bucket_origin == NULL); if (bucket_info->bf->bucket_integer_offset != 0) { bucket_offset = palloc0(MAXINT8LEN + 1); pg_lltoa(bucket_info->bf->bucket_integer_offset, bucket_offset); } } create_bucket_function_catalog_entry(materialize_hypertable_id, bucket_info->bf->bucket_function, bucket_width, bucket_origin, bucket_offset, bucket_info->bf->bucket_time_timezone, bucket_info->bf->bucket_fixed_interval); /* Step 5: Finalize slot creation if using wal based invalidation. */ if (ts_guc_enable_cagg_wal_based_invalidation && slot_prepared) cagg_add_logical_decoding_slot_finalize(); } DDLResult tsl_process_continuous_agg_viewstmt(Node *node, const char *query_string, void *pstmt, WithClauseResult *with_clause_options) { const CreateTableAsStmt *stmt = castNode(CreateTableAsStmt, node); ContinuousAggTimeBucketInfo timebucket_exprinfo; Oid nspid; bool finalized = with_clause_options[CreateMaterializedViewFlagFinalized].parsed; ViewStmt viewstmt = { .type = T_ViewStmt, .view = stmt->into->rel, .query = (Node *) stmt->into->viewQuery, .options = stmt->into->options, .aliases = stmt->into->colNames, }; ContinuousAgg *cagg; Hypertable *mat_ht; Oid relid; char *schema_name; ts_feature_flag_check(FEATURE_CAGG); nspid = RangeVarGetCreationNamespace(stmt->into->rel); relid = get_relname_relid(stmt->into->rel->relname, nspid); if (OidIsValid(relid)) { if (stmt->if_not_exists) { ereport(NOTICE, (errcode(ERRCODE_DUPLICATE_TABLE), errmsg("continuous aggregate \"%s\" already exists, skipping", stmt->into->rel->relname))); return DDL_DONE; } else { ereport(ERROR, (errcode(ERRCODE_DUPLICATE_TABLE), errmsg("continuous aggregate \"%s\" already exists", stmt->into->rel->relname), errhint("Drop or rename the existing continuous aggregate first or use " "another name."))); } } if (!with_clause_options[CreateMaterializedViewFlagColumnstore].is_default) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot enable compression while creating a continuous aggregate"), errhint("Use ALTER MATERIALIZED VIEW to enable compression."))); } schema_name = get_namespace_name(nspid); timebucket_exprinfo = cagg_validate_query((Query *) stmt->into->viewQuery, finalized, schema_name, stmt->into->rel->relname, true); cagg_create(stmt, &viewstmt, (Query *) stmt->query, &timebucket_exprinfo, with_clause_options); /* Insert the MIN of the time dimension type for the new watermark */ CommandCounterIncrement(); relid = get_relname_relid(stmt->into->rel->relname, nspid); Ensure(OidIsValid(relid), "relation \"%s\".\"%s\" not found", schema_name, stmt->into->rel->relname); cagg = ts_continuous_agg_find_by_relid(relid); Ensure(NULL != cagg, "continuous aggregate \"%s\".\"%s\" not found", schema_name, stmt->into->rel->relname); mat_ht = ts_hypertable_get_by_id(cagg->data.mat_hypertable_id); Ensure(NULL != mat_ht, "materialization hypertable %d not found", cagg->data.mat_hypertable_id); ts_cagg_watermark_insert(mat_ht, 0, true); invalidation_threshold_initialize(cagg); if (!stmt->into->skipData) { InternalTimeRange refresh_window = { .type = InvalidOid, }; /* * We are creating a refresh window here in a similar way to how it's * done in continuous_agg_refresh. We do not call the PG function * directly since we want to be able to suppress the output in that * function and adding a 'verbose' parameter to is not useful for a * user. */ refresh_window.type = cagg->partition_type; /* * To determine inscribed/circumscribed refresh window for variable-sized * buckets we should be able to calculate time_bucket(window.begin) and * time_bucket(window.end). This, however, is not possible in general case. * As an example, the minimum date is 4714-11-24 BC, which is before any * reasonable default `origin` value. Thus for variable-sized buckets * instead of minimum date we use -infinity since time_bucket(-infinity) * is well-defined as -infinity. * * For more details see: * - ts_compute_inscribed_bucketed_refresh_window_variable() * - ts_compute_circumscribed_bucketed_refresh_window_variable() */ refresh_window.start = cagg_get_time_min(cagg); refresh_window.end = ts_time_get_noend_or_max(refresh_window.type); ContinuousAggRefreshContext context = { .callctx = CAGG_REFRESH_CREATION }; continuous_agg_refresh_internal(cagg, &refresh_window, context, true, /* start_isnull */ true, /* end_isnull */ true, /* bucketing_refresh_window */ false, /* force */ true, /* process_hypertable_invalidations */ false /*extend_last_bucket*/); } return DDL_DONE; } /* * Flip the view definition of an existing continuous aggregate from * real-time to materialized-only or vice versa depending on the current state. */ void cagg_flip_realtime_view_definition(ContinuousAgg *agg, Hypertable *mat_ht) { int sec_ctx; Oid uid, saved_uid; Query *result_view_query; /* User view query of the user defined CAGG. */ Oid user_view_oid = ts_get_relation_relid(NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name), false); Relation user_view_rel = relation_open(user_view_oid, AccessShareLock); Query *user_query = copyObject(get_view_query(user_view_rel)); /* Keep lock until end of transaction. */ relation_close(user_view_rel, NoLock); RemoveRangeTableEntries(user_query); /* Direct view query of the original user view definition at CAGG creation. */ Oid direct_view_oid = ts_get_relation_relid(NameStr(agg->data.direct_view_schema), NameStr(agg->data.direct_view_name), false); Relation direct_view_rel = relation_open(direct_view_oid, AccessShareLock); Query *direct_query = copyObject(get_view_query(direct_view_rel)); /* Keep lock until end of transaction. */ relation_close(direct_view_rel, NoLock); RemoveRangeTableEntries(direct_query); ContinuousAggTimeBucketInfo timebucket_exprinfo = cagg_validate_query(direct_query, agg->data.finalized, NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name), false); /* Flip */ agg->data.materialized_only = !agg->data.materialized_only; if (agg->data.materialized_only) { result_view_query = destroy_union_query(user_query); } else { /* Get primary partitioning column information of time bucketing. */ const Dimension *mat_part_dimension = hyperspace_get_open_dimension(mat_ht->space, 0); result_view_query = build_union_query(&timebucket_exprinfo, mat_part_dimension->column_attno, user_query, direct_query, mat_ht->fd.id); } SWITCH_TO_TS_USER(NameStr(agg->data.user_view_schema), uid, saved_uid, sec_ctx); StoreViewQuery(user_view_oid, result_view_query, true); CommandCounterIncrement(); RESTORE_USER(uid, saved_uid, sec_ctx); } void cagg_rename_view_columns(ContinuousAgg *agg) { ListCell *lc; int sec_ctx; Oid uid, saved_uid; /* User view query of the user defined CAGG. */ Oid user_view_oid = ts_get_relation_relid(NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name), false); Relation user_view_rel = relation_open(user_view_oid, AccessShareLock); Query *user_query = copyObject(get_view_query(user_view_rel)); RemoveRangeTableEntries(user_query); /* * When calling StoreViewQuery the target list names of the query have to * match the view's tuple descriptor attribute names. But if a column of the * continuous aggregate has been renamed, the query tree will not have the correct * names in the target list, which will error out when calling StoreViewQuery. * For that reason, we fetch the name from the user view relation and update the * resource name in the query target list to match the name in the user view. */ TupleDesc desc = RelationGetDescr(user_view_rel); int i = 0; foreach (lc, user_query->targetList) { TargetEntry *user_tle; FormData_pg_attribute *attr = TupleDescAttr(desc, i); user_tle = lfirst_node(TargetEntry, lc); if (user_tle->resjunk) break; user_tle->resname = NameStr(attr->attname); ++i; } SWITCH_TO_TS_USER(NameStr(agg->data.user_view_schema), uid, saved_uid, sec_ctx); StoreViewQuery(user_view_oid, user_query, true); CommandCounterIncrement(); RESTORE_USER(uid, saved_uid, sec_ctx); /* * Keep locks until end of transaction and do not close the relation * before the call to StoreViewQuery since it can otherwise release the * memory for attr->attname, causing a segfault. */ relation_close(user_view_rel, NoLock); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/create.h�������������������������������������������������0000664�0000000�0000000�00000001176�15100345067�0022274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "ts_catalog/continuous_agg.h" #include "with_clause/with_clause_parser.h" #include <process_utility.h> DDLResult tsl_process_continuous_agg_viewstmt(Node *node, const char *query_string, void *pstmt, WithClauseResult *with_clause_options); extern void cagg_flip_realtime_view_definition(ContinuousAgg *agg, Hypertable *mat_ht); extern void cagg_rename_view_columns(ContinuousAgg *agg); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/finalize.c�����������������������������������������������0000664�0000000�0000000�00000027211�15100345067�0022623�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains the code related to the *NOT* finalized version of * Continuous Aggregates (with partials) */ #include "finalize.h" #include <parser/parse_relation.h> #include "common.h" #include "create.h" #include <partialize_finalize.h> /* Static function prototypes */ static Var *mattablecolumninfo_addentry(MaterializationHypertableColumnInfo *out, Node *input, List *rtable, int original_query_resno, bool finalized, bool *skip_adding); static inline void makeMaterializeColumnName(char *colbuf, const char *type, int original_query_resno, int colno); static inline void makeMaterializeColumnName(char *colbuf, const char *type, int original_query_resno, int colno) { int ret = snprintf(colbuf, NAMEDATALEN, "%s_%d_%d", type, original_query_resno, colno); if (ret < 0 || ret >= NAMEDATALEN) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("bad materialization table column name"))); } /* * Init the finalize query data structure. * Parameters: * orig_query - the original query from user view that is being used as template for the finalize * query tlist_aliases - aliases for the view select list materialization table columns are created * . This will be returned in the mattblinfo * * DO NOT modify orig_query. Make a copy if needed. * SIDE_EFFECT: the data structure in mattblinfo is modified as a side effect by adding new * materialize table columns and partialize exprs. */ void finalizequery_init(FinalizeQueryInfo *inp, Query *orig_query, MaterializationHypertableColumnInfo *mattblinfo) { ListCell *lc; int resno = 1; inp->final_userquery = copyObject(orig_query); inp->final_seltlist = NIL; inp->final_havingqual = NULL; /* * We want all the entries in the targetlist (resjunk or not) * in the materialization table definition so we include group-by/having clause etc. * We have to do 3 things here: * 1) create a column for mat table * 2) partialize_expr to populate it, and * 3) modify the target entry to be a finalize_expr * that selects from the materialization table. */ foreach (lc, orig_query->targetList) { TargetEntry *tle = (TargetEntry *) lfirst(lc); TargetEntry *modte = copyObject(tle); if (!orig_query->sortClause) modte->ressortgroupref = 0; /* * We need columns for non-aggregate targets. * If it is not a resjunk OR appears in the grouping clause. */ if (tle->resjunk == false || tle->ressortgroupref > 0) { Var *var; bool skip_adding = false; var = mattablecolumninfo_addentry(mattblinfo, (Node *) tle, orig_query->rtable, resno, inp->finalized, &skip_adding); /* Skip adding this column for finalized form. */ if (skip_adding) { continue; } /* Fix the expression for the target entry. */ modte->expr = (Expr *) var; } /* * Construct the targetlist for the query on the * materialization table. The TL maps 1-1 with the original query: * e.g select a, min(b)+max(d) from foo group by a,timebucket(a); * becomes * select <a-col>, * ts_internal_cagg_final(..b-col ) + ts_internal_cagg_final(..d-col) * from mattbl * group by a-col, timebucket(a-col) */ /* * We copy the modte target entries, resnos should be the same for * final_selquery and origquery. So tleSortGroupReffor the targetentry * can be reused, only table info needs to be modified. */ Assert(inp->finalized && modte->resno >= resno); resno++; if (IsA(modte->expr, Var)) { modte->resorigcol = ((Var *) modte->expr)->varattno; } inp->final_seltlist = lappend(inp->final_seltlist, modte); } } /* * Create select query with the finalize aggregates * for the materialization table. * matcollist - column list for mat table * mattbladdress - materialization table ObjectAddress * This is the function responsible for creating the final * structures for selecting from the materialized hypertable * created for the Cagg which is * select * from _timescaldeb_internal._materialized_hypertable_<xxx> */ Query * finalizequery_get_select_query(FinalizeQueryInfo *inp, List *matcollist, ObjectAddress *mattbladdress, char *relname) { Query *final_selquery = NULL; CAGG_MAKEQUERY(final_selquery, inp->final_userquery); final_selquery->hasAggs = !inp->finalized; /* New RangeTblEntry for the materialization hypertable */ RangeTblEntry *rte = makeNode(RangeTblEntry); rte->inFromCl = true; rte->inh = true; rte->rellockmode = 1; rte->eref = makeAlias(relname, NIL); rte->relid = mattbladdress->objectId; rte->rtekind = RTE_RELATION; rte->relkind = RELKIND_RELATION; rte->tablesample = NULL; #if PG16_LT rte->requiredPerms |= ACL_SELECT; rte->insertedCols = NULL; rte->updatedCols = NULL; #else RTEPermissionInfo *perminfo = addRTEPermissionInfo(&final_selquery->rteperminfos, rte); perminfo->selectedCols = NULL; perminfo->relid = mattbladdress->objectId; perminfo->requiredPerms |= ACL_SELECT; perminfo->insertedCols = NULL; perminfo->updatedCols = NULL; #endif /* Aliases for column names for the materialization hypertable. */ ListCell *lc; int attno = 0; foreach (lc, matcollist) { ColumnDef *cdef = lfirst_node(ColumnDef, lc); rte->eref->colnames = lappend(rte->eref->colnames, makeString(cdef->colname)); attno = list_length(rte->eref->colnames) - FirstLowInvalidHeapAttributeNumber; #if PG16_LT rte->selectedCols = bms_add_member(rte->selectedCols, attno); #else perminfo->selectedCols = bms_add_member(perminfo->selectedCols, attno); #endif } /* Fixup targetlist with the correct rel information. */ foreach (lc, inp->final_seltlist) { TargetEntry *tle = lfirst_node(TargetEntry, lc); /* * In case when this is a cagg with joins, the Var from the normal table * already has resorigtbl populated and we need to use that to resolve * the Var. Hence only modify the tle when resorigtbl is unset * which means it is Var of the Hypertable */ if (IsA(tle->expr, Var) && !OidIsValid(tle->resorigtbl)) { tle->resorigtbl = rte->relid; tle->resorigcol = castNode(Var, tle->expr)->varattno; } } RangeTblRef *rtr = makeNode(RangeTblRef); rtr->rtindex = 1; final_selquery->rtable = list_make1(rte); final_selquery->jointree = makeFromExpr(list_make1(rtr), NULL); final_selquery->targetList = inp->final_seltlist; final_selquery->sortClause = inp->final_userquery->sortClause; return final_selquery; } /* * Add Information required to create and populate the materialization table columns * a) create a columndef for the materialization table * b) create the corresponding expr to populate the column of the materialization table (e..g for a * column that is an aggref, we create a partialize_agg expr to populate the column Returns: the * Var corresponding to the newly created column of the materialization table * * Notes: make sure the materialization table columns do not save * values computed by mutable function. * * Notes on TargetEntry fields: * - (resname != NULL) means it's projected in our case * - (ressortgroupref > 0) means part of GROUP BY, which can be projected or not, depending of the * value of the resjunk * - (resjunk == true) applies for GROUP BY columns that are not projected * */ static Var * mattablecolumninfo_addentry(MaterializationHypertableColumnInfo *out, Node *input, List *rtable, int original_query_resno, bool finalized, bool *skip_adding) { int matcolno = list_length(out->matcollist) + 1; char colbuf[NAMEDATALEN]; char *colname; TargetEntry *part_te = NULL; ColumnDef *col; Var *var; Oid coltype = InvalidOid, colcollation = InvalidOid; int32 coltypmod; *skip_adding = false; if (contain_mutable_functions(input)) { ereport(WARNING, (errmsg("using non-immutable functions in continuous aggregate view may lead to " "inconsistent results on rematerialization"))); } switch (nodeTag(input)) { case T_TargetEntry: { TargetEntry *tle = (TargetEntry *) input; bool timebkt_chk = false; if (IsA(tle->expr, FuncExpr)) timebkt_chk = function_allowed_in_cagg_definition(((FuncExpr *) tle->expr)->funcid); #if PG18_GE /* PG18 introduced RTEs for group clauses so * we use rtable to look up GROUP BY expressions. * * https://github.com/postgres/postgres/commit/247dea89 */ if (IsA(tle->expr, Var)) { Var *var = castNode(Var, tle->expr); Assert((int) var->varno <= list_length(rtable)); RangeTblEntry *rte = list_nth(rtable, var->varno - 1); Assert(rte->rtekind == RTE_GROUP); Assert(var->varattno > 0); Node *node = list_nth(rte->groupexprs, var->varattno - 1); if (IsA(node, FuncExpr)) { if (contain_mutable_functions(node)) { ereport(WARNING, (errmsg("using non-immutable functions in continuous aggregate " "view may lead to " "inconsistent results on rematerialization"))); } FuncExpr *expr = (FuncExpr *) node; timebkt_chk = function_allowed_in_cagg_definition(((FuncExpr *) expr)->funcid); } } #endif if (tle->resname) colname = pstrdup(tle->resname); else { if (timebkt_chk) colname = DEFAULT_MATPARTCOLUMN_NAME; else { makeMaterializeColumnName(colbuf, "grp", original_query_resno, matcolno); colname = colbuf; /* For finalized form we skip adding extra group by columns. */ *skip_adding = finalized; } } if (timebkt_chk) { tle->resname = pstrdup(colname); out->matpartcolno = matcolno; out->matpartcolname = pstrdup(colname); } else { /* * Add indexes only for columns that are part of the GROUP BY clause * and for finals form. * We skip adding it because we'll not add the extra group by columns * to the materialization hypertable anymore. */ if (!*skip_adding && tle->ressortgroupref > 0) out->mat_groupcolname_list = lappend(out->mat_groupcolname_list, pstrdup(colname)); } coltype = exprType((Node *) tle->expr); coltypmod = exprTypmod((Node *) tle->expr); colcollation = exprCollation((Node *) tle->expr); col = makeColumnDef(colname, coltype, coltypmod, colcollation); part_te = (TargetEntry *) copyObject(input); /* Keep original resjunk if not time bucket. */ if (timebkt_chk) { /* * Need to project all the partial entries so that * materialization table is filled. */ part_te->resjunk = false; } part_te->resno = matcolno; if (timebkt_chk) { col->is_not_null = true; } if (part_te->resname == NULL) { part_te->resname = pstrdup(colname); } } break; case T_Var: { makeMaterializeColumnName(colbuf, "var", original_query_resno, matcolno); colname = colbuf; coltype = exprType(input); coltypmod = exprTypmod(input); colcollation = exprCollation(input); col = makeColumnDef(colname, coltype, coltypmod, colcollation); part_te = makeTargetEntry((Expr *) input, matcolno, pstrdup(colname), false); /* Need to project all the partial entries so that materialization table is filled. */ part_te->resjunk = false; part_te->resno = matcolno; } break; default: elog(ERROR, "invalid node type %d", nodeTag(input)); break; } Assert(finalized && list_length(out->matcollist) <= list_length(out->partial_seltlist)); Assert(col != NULL); Assert(part_te != NULL); if (!*skip_adding) { out->matcollist = lappend(out->matcollist, col); } out->partial_seltlist = lappend(out->partial_seltlist, part_te); var = makeVar(1, matcolno, coltype, coltypmod, colcollation, 0); return var; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/finalize.h�����������������������������������������������0000664�0000000�0000000�00000001775�15100345067�0022637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <catalog/pg_aggregate.h> #include <catalog/pg_collation.h> #include <catalog/pg_type.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/pg_list.h> #include <parser/parse_func.h> #include <utils/builtins.h> #include <utils/regproc.h> #include <utils/syscache.h> #include "common.h" #include "ts_catalog/catalog.h" #define FINALFN "finalize_agg" extern Query *finalize_query_get_select_query(FinalizeQueryInfo *inp, List *matcollist, ObjectAddress *mattbladdress); extern void finalizequery_init(FinalizeQueryInfo *inp, Query *orig_query, MaterializationHypertableColumnInfo *mattblinfo); extern Query *finalizequery_get_select_query(FinalizeQueryInfo *inp, List *matcollist, ObjectAddress *mattbladdress, char *relname); ���timescaledb-2.23.0/tsl/src/continuous_aggs/insert.c�������������������������������������������������0000664�0000000�0000000�00000037047�15100345067�0022336�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/tupconvert.h> #include <access/xact.h> #include <catalog/pg_type.h> #include <commands/dbcommands.h> #include <commands/trigger.h> #include <executor/spi.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <miscadmin.h> #include <storage/lmgr.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/hsearch.h> #include <utils/rel.h> #include <utils/relcache.h> #include <utils/snapmgr.h> #include <scanner.h> #include "compat/compat.h" #include "chunk.h" #include "debug_point.h" #include "dimension.h" #include "export.h" #include "guc.h" #include "hypertable.h" #include "hypertable_cache.h" #include "invalidation.h" #include "partitioning.h" #include "time_bucket.h" #include "ts_catalog/catalog.h" #include "ts_catalog/continuous_agg.h" #include "utils.h" #include "continuous_aggs/common.h" #include "continuous_aggs/insert.h" /* * When tuples in a hypertable that has a continuous aggregate are modified, the * lowest modified value and the greatest modified value must be tracked over * the course of a transaction or statement. At the end of the statement these * values will be inserted into the proper cache invalidation log table for * their associated hypertable if they are below the speculative materialization * watermark (or, if in REPEATABLE_READ isolation level or higher, they will be * inserted no matter what as we cannot see if a materialization transaction has * started and moved the watermark during our transaction in that case). * * We accomplish this at the transaction level by keeping a hash table of each * hypertable that has been modified in the transaction and the lowest and * greatest modified values. The hashtable will be updated via a trigger that * will be called for every row that is inserted, updated or deleted. We use a * hashtable because we need to keep track of this on a per hypertable basis and * multiple can have tuples modified during a single transaction. (And if we * move to per-chunk cache-invalidation it makes it even easier). * */ typedef struct ContinuousAggsCacheInvalEntry { int32 hypertable_id; Oid hypertable_relid; Dimension hypertable_open_dimension; Oid previous_chunk_relid; AttrNumber previous_chunk_open_dimension; bool value_is_set; int64 lowest_modified_value; int64 greatest_modified_value; } ContinuousAggsCacheInvalEntry; static int64 get_lowest_invalidated_time_for_hypertable(Oid hypertable_relid); #define CA_CACHE_INVAL_INIT_HTAB_SIZE 64 static HTAB *continuous_aggs_cache_inval_htab = NULL; static MemoryContext continuous_aggs_trigger_mctx = NULL; static int64 tuple_get_time(Dimension *d, HeapTuple tuple, AttrNumber col, TupleDesc tupdesc); static inline void cache_inval_entry_init(ContinuousAggsCacheInvalEntry *cache_entry, int32 hypertable_id); static inline void cache_entry_switch_to_chunk(ContinuousAggsCacheInvalEntry *cache_entry, Oid chunk_reloid, Relation chunk_relation); static inline void update_cache_entry(ContinuousAggsCacheInvalEntry *cache_entry, int64 timeval); static void cache_inval_entry_write(ContinuousAggsCacheInvalEntry *entry); static void cache_inval_cleanup(void); static void cache_inval_htab_write(void); static void continuous_agg_xact_invalidation_callback(XactEvent event, void *arg); static ScanTupleResult invalidation_tuple_found(TupleInfo *ti, void *min); static void cache_inval_init() { HASHCTL ctl; Assert(continuous_aggs_trigger_mctx == NULL); continuous_aggs_trigger_mctx = AllocSetContextCreate(TopTransactionContext, "ContinuousAggsTriggerCtx", ALLOCSET_DEFAULT_SIZES); memset(&ctl, 0, sizeof(ctl)); ctl.keysize = sizeof(int32); ctl.entrysize = sizeof(ContinuousAggsCacheInvalEntry); ctl.hcxt = continuous_aggs_trigger_mctx; continuous_aggs_cache_inval_htab = hash_create("TS Continuous Aggs Cache Inval", CA_CACHE_INVAL_INIT_HTAB_SIZE, &ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); }; static int64 tuple_get_time(Dimension *d, HeapTuple tuple, AttrNumber col, TupleDesc tupdesc) { Datum datum; bool isnull; Oid dimtype; datum = heap_getattr(tuple, col, tupdesc, &isnull); /* * Since this is the value of the primary partitioning column and we require * partitioning columns to be NOT NULL we should never see a NULL here. */ Ensure(!isnull, "primary partition column cannot be NULL"); if (NULL != d->partitioning) { Oid collation = TupleDescAttr(tupdesc, col)->attcollation; datum = ts_partitioning_func_apply(d->partitioning, collation, datum); } Assert(d->type == DIMENSION_TYPE_OPEN); dimtype = ts_dimension_get_partition_type(d); return ts_time_value_to_internal(datum, dimtype); } static inline void cache_inval_entry_init(ContinuousAggsCacheInvalEntry *cache_entry, int32 hypertable_id) { Cache *ht_cache = ts_hypertable_cache_pin(); /* NOTE: we can remove the id=>relid scan, if it becomes an issue, by getting the * hypertable_relid directly from the Chunk*/ Hypertable *ht = ts_hypertable_cache_get_entry_by_id(ht_cache, hypertable_id); if (ht == NULL) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unable to determine relid for hypertable %d", hypertable_id))); } cache_entry->hypertable_id = hypertable_id; cache_entry->hypertable_relid = ht->main_table_relid; const Dimension *open_dim = hyperspace_get_open_dimension(ht->space, 0); Ensure(open_dim != NULL, "hypertable %d has no open partitioning dimension", hypertable_id); cache_entry->hypertable_open_dimension = *open_dim; if (cache_entry->hypertable_open_dimension.partitioning != NULL) { PartitioningInfo *open_dim_part_info = MemoryContextAllocZero(continuous_aggs_trigger_mctx, sizeof(*open_dim_part_info)); *open_dim_part_info = *cache_entry->hypertable_open_dimension.partitioning; cache_entry->hypertable_open_dimension.partitioning = open_dim_part_info; } cache_entry->previous_chunk_relid = InvalidOid; cache_entry->value_is_set = false; cache_entry->lowest_modified_value = INVAL_POS_INFINITY; cache_entry->greatest_modified_value = INVAL_NEG_INFINITY; ts_cache_release(&ht_cache); } static inline void cache_entry_switch_to_chunk(ContinuousAggsCacheInvalEntry *cache_entry, Oid chunk_reloid, Relation chunk_relation) { Chunk *modified_tuple_chunk = ts_chunk_get_by_relid(chunk_reloid, false); if (modified_tuple_chunk == NULL) { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("continuous agg trigger function must be called on hypertable chunks only"), errdetail("Called on '%s'.", get_rel_name(chunk_reloid)))); } cache_entry->previous_chunk_relid = modified_tuple_chunk->table_id; cache_entry->previous_chunk_open_dimension = get_attnum(chunk_relation->rd_id, NameStr(cache_entry->hypertable_open_dimension.fd.column_name)); if (cache_entry->previous_chunk_open_dimension == InvalidAttrNumber) { ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("open dimension '%s' not found in chunk %s", NameStr(cache_entry->hypertable_open_dimension.fd.column_name), get_rel_name(chunk_relation->rd_id)))); } } static inline void update_cache_entry(ContinuousAggsCacheInvalEntry *cache_entry, int64 timeval) { cache_entry->value_is_set = true; if (timeval < cache_entry->lowest_modified_value) cache_entry->lowest_modified_value = timeval; if (timeval > cache_entry->greatest_modified_value) cache_entry->greatest_modified_value = timeval; } void continuous_agg_dml_invalidate(int32 hypertable_id, Relation chunk_rel, HeapTuple chunk_tuple, HeapTuple chunk_newtuple, bool update) { Assert(!ts_guc_enable_cagg_wal_based_invalidation); execute_cagg_trigger(hypertable_id, chunk_rel, chunk_tuple, chunk_newtuple, update); } /* * chunk_tuple is the tuple from trigdata->tg_trigtuple * i.e. the one being/inserts/deleted/updated. * (for updates: this is the row before modification) * chunk_newtuple is the tuple from trigdata->tg_newtuple. */ void execute_cagg_trigger(int32 hypertable_id, Relation chunk_rel, HeapTuple chunk_tuple, HeapTuple chunk_newtuple, bool update) { ContinuousAggsCacheInvalEntry *cache_entry; bool found; int64 timeval; Oid chunk_relid = chunk_rel->rd_id; /* On first call, init the mctx and hash table */ if (!continuous_aggs_cache_inval_htab) cache_inval_init(); cache_entry = (ContinuousAggsCacheInvalEntry *) hash_search(continuous_aggs_cache_inval_htab, &hypertable_id, HASH_ENTER, &found); if (!found) cache_inval_entry_init(cache_entry, hypertable_id); /* handle the case where we need to repopulate the cached chunk data */ if (cache_entry->previous_chunk_relid != chunk_relid) cache_entry_switch_to_chunk(cache_entry, chunk_relid, chunk_rel); timeval = tuple_get_time(&cache_entry->hypertable_open_dimension, chunk_tuple, cache_entry->previous_chunk_open_dimension, RelationGetDescr(chunk_rel)); update_cache_entry(cache_entry, timeval); if (!update) return; /* on update we need to invalidate the new time value as well as the old one */ timeval = tuple_get_time(&cache_entry->hypertable_open_dimension, chunk_newtuple, cache_entry->previous_chunk_open_dimension, RelationGetDescr(chunk_rel)); update_cache_entry(cache_entry, timeval); } static void cache_inval_entry_write(ContinuousAggsCacheInvalEntry *entry) { int64 liv; if (!entry->value_is_set) return; /* The materialization worker uses a READ COMMITTED isolation level by default. Therefore, if we * use a stronger isolation level, the isolation threshold could update without us seeing the * new value. In order to prevent serialization errors, we always append invalidation entries in * the case when we're using a strong enough isolation level that we won't see the new * threshold. The materializer can handle invalidations that are beyond the threshold * gracefully. */ if (IsolationUsesXactSnapshot()) { invalidation_hyper_log_add_entry(entry->hypertable_id, entry->lowest_modified_value, entry->greatest_modified_value); return; } liv = get_lowest_invalidated_time_for_hypertable(entry->hypertable_relid); if (entry->lowest_modified_value < liv) invalidation_hyper_log_add_entry(entry->hypertable_id, entry->lowest_modified_value, entry->greatest_modified_value); }; static void cache_inval_cleanup(void) { Assert(continuous_aggs_cache_inval_htab != NULL); hash_destroy(continuous_aggs_cache_inval_htab); MemoryContextDelete(continuous_aggs_trigger_mctx); continuous_aggs_cache_inval_htab = NULL; continuous_aggs_trigger_mctx = NULL; }; static void cache_inval_htab_write(void) { HASH_SEQ_STATUS hash_seq; ContinuousAggsCacheInvalEntry *current_entry; Catalog *catalog; if (hash_get_num_entries(continuous_aggs_cache_inval_htab) == 0) return; catalog = ts_catalog_get(); /* The invalidation threshold must remain locked until the end of * the transaction to ensure the materializer will see our updates, * so we explicitly lock it here */ LockRelationOid(catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), AccessShareLock); hash_seq_init(&hash_seq, continuous_aggs_cache_inval_htab); while ((current_entry = hash_seq_search(&hash_seq)) != NULL) cache_inval_entry_write(current_entry); }; /* * We use TopTransactionContext for our cached invalidations. * We need to make sure cache_inval_cleanup() is always called after cache_inval_htab_write(). * We need this memory context to survive the transaction lifetime so that cache_inval_cleanup() * does not attempt to tear down memory that has already been freed due to a transaction ending. * * The order of operations in postgres can be this: * CallXactCallbacks(XACT_EVENT_PRE_PREPARE); * ... * CallXactCallbacks(XACT_EVENT_PREPARE); * ... * MemoryContextDelete(TopTransactionContext); * * or that: * CallXactCallbacks(XACT_EVENT_PRE_COMMIT); * ... * CallXactCallbacks(XACT_EVENT_COMMIT); * ... * MemoryContextDelete(TopTransactionContext); * * In the case of a 2PC transaction, we need to make sure to apply the invalidations at * XACT_EVENT_PRE_PREPARE time, before TopTransactionContext is torn down by PREPARE TRANSACTION. * Otherwise, we are unable to call cache_inval_cleanup() without corrupting the memory. For * this reason, we also deallocate at XACT_EVENT_PREPARE time. * * For local transactions we apply the invalidations at XACT_EVENT_PRE_COMMIT time. * Similar care is taken of parallel workers and aborting transactions. */ static void continuous_agg_xact_invalidation_callback(XactEvent event, void *arg) { /* Return quickly if we never initialize the hashtable */ if (!continuous_aggs_cache_inval_htab) return; switch (event) { case XACT_EVENT_PRE_PREPARE: case XACT_EVENT_PRE_COMMIT: case XACT_EVENT_PARALLEL_PRE_COMMIT: cache_inval_htab_write(); break; case XACT_EVENT_PREPARE: case XACT_EVENT_COMMIT: case XACT_EVENT_PARALLEL_COMMIT: case XACT_EVENT_ABORT: case XACT_EVENT_PARALLEL_ABORT: cache_inval_cleanup(); break; default: break; } } void _continuous_aggs_cache_inval_init(void) { RegisterXactCallback(continuous_agg_xact_invalidation_callback, NULL); } void _continuous_aggs_cache_inval_fini(void) { UnregisterXactCallback(continuous_agg_xact_invalidation_callback, NULL); } static ScanTupleResult invalidation_tuple_found(TupleInfo *ti, void *min) { bool isnull; Datum watermark = slot_getattr(ti->slot, Anum_continuous_aggs_invalidation_threshold_watermark, &isnull); Assert(!isnull); if (DatumGetInt64(watermark) < *((int64 *) min)) *((int64 *) min) = DatumGetInt64(watermark); DEBUG_WAITPOINT("invalidation_tuple_found_done"); /* * Return SCAN_CONTINUE because we check for multiple tuples as an error * condition. */ return SCAN_CONTINUE; } static int64 get_lowest_invalidated_time_for_hypertable(Oid hypertable_relid) { int64 min_val = INVAL_POS_INFINITY; Catalog *catalog = ts_catalog_get(); ScanKeyData scankey[1]; ScannerCtx scanctx; PushActiveSnapshot(GetLatestSnapshot()); ScanKeyInit(&scankey[0], Anum_continuous_aggs_invalidation_threshold_pkey_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(ts_hypertable_relid_to_id(hypertable_relid))); scanctx = (ScannerCtx){ .table = catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), .index = catalog_get_index(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY), .nkeys = 1, .scankey = scankey, .tuple_found = &invalidation_tuple_found, .filter = NULL, .data = &min_val, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, .result_mctx = NULL, /* We need to define a custom snapshot for this scan. The default snapshot (SNAPSHOT_SELF) reads data of all committed transactions, even if they have started after our scan. If a parallel session updates the scanned value and commits during a scan, we end up in a situation where we see the old and the new value. This causes ts_scanner_scan_one() to fail. */ .snapshot = GetActiveSnapshot(), }; /* If we don't find any invalidation threshold watermark, then we've never done any * materialization we'll treat this as if the invalidation timestamp is at min value, since the * first materialization needs to scan the entire table anyway; the invalidations are redundant. */ if (!ts_scanner_scan_one(&scanctx, false, CAGG_INVALIDATION_THRESHOLD_NAME)) min_val = INVAL_NEG_INFINITY; PopActiveSnapshot(); return min_val; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/insert.h�������������������������������������������������0000664�0000000�0000000�00000001212�15100345067�0022324�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> extern void _continuous_aggs_cache_inval_init(void); extern void _continuous_aggs_cache_inval_fini(void); extern void execute_cagg_trigger(int32 hypertable_id, Relation chunk_rel, HeapTuple chunk_tuple, HeapTuple chunk_newtuple, bool update); extern void continuous_agg_dml_invalidate(int32 hypertable_id, Relation chunk_rel, HeapTuple chunk_tuple, HeapTuple chunk_newtuple, bool update); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation.c�������������������������������������������0000664�0000000�0000000�00000132601�15100345067�0023503�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup.h> #include <access/htup_details.h> #include <access/xact.h> #include <extension.h> #include <fmgr.h> #include <funcapi.h> #include <hypertable_cache.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <nodes/memnodes.h> #include <parser/parse_func.h> #include <scan_iterator.h> #include <scanner.h> #include <storage/lockdefs.h> #include <time_bucket.h> #include <time_utils.h> #include <utils.h> #include <utils/builtins.h> #include <utils/elog.h> #include <utils/memutils.h> #include <utils/palloc.h> #include <utils/snapmgr.h> #include <utils/tuplestore.h> #include "cache.h" #include "continuous_aggs/invalidation_multi.h" #include "continuous_aggs/invalidation_threshold.h" #include "continuous_aggs/materialize.h" #include "guc.h" #include "invalidation.h" #include "refresh.h" #include "ts_catalog/catalog.h" #include "ts_catalog/continuous_agg.h" /* * Invalidation processing for continuous aggregates. * * Invalidations track the regions/intervals [start, end] of a continuous * aggregate that are out-of-date relative to the source hypertable on top of * which the aggregate is defined. When a continuous aggregate is out-of-date * across one or more regions, it can be refreshed with a window covering * those regions in order to bring it up-to-date with the source data again. * * Invalidations are generated by mutations on the source hypertable (INSERT, * DELETE, UPDATE, TRUNCATE, drop_chunks, etc.) and are initially written to a * hypertable invalidation log [hypertable_id, start, end]. * * When a continuous aggregate is refreshed, invalidations are moved from the * hypertable invalidation log to a continuous aggregate invalidation log, * where each original entry creates one new entry per continuous aggregate * [cagg_id, start, end]. Thus, if one continuous aggregate is refreshed but * not others, then only the invalidations for the refreshed aggregate are * processed. * * Simplified, invalidations move through the following stages: * * insert_trigger => hypertable_inval_log => cagg_inval_log => refreshing * * Thus, invalidations are generated by mutations and are processed and used * as input for refreshing the a continuous aggregate. * * Invalidations can overlap or be duplicates. Therefore, invalidations are * merged during processing to reduce the number of entries in the logs. This * typically happens during a refresh of a continuous aggregate, which also * cuts invalidations along the refresh window. The cutting will leave some * parts of entries in the invalidation log while the entries that fall * within the refresh window are stored in an invalidation store and used for * refreshing: * * |-------------| refresh window * * |-----| |---| |----| invalidations * * => * * |---| |--| invalidations that remain in the log * * |-| |---| |--| invalidations that are used for refreshing * * The invalidation store will spill to disk in case of many invalidations so * it won't blow up memory usage. If there are no invalidations in the store * after processing, then the continuous aggregate is up-to-date in the region * defined by the refresh window. */ /* * Processing state used while processing the materialization invalidation log * and refreshing the continuous aggregate. */ typedef struct ContinuousAggInvalidationState { const ContinuousAgg *cagg; MemoryContext per_tuple_mctx; Relation cagg_log_rel; Relation cagg_queue_rel; Snapshot snapshot; Tuplestorestate *invalidations; } ContinuousAggInvalidationState; /* * Processing state used while moving invalidations from hypertable * invalidation log to materialization invalidation log. */ typedef struct HypertableInvalidationState { int32 hypertable_id; Oid dimtype; /* Type of the underlying hypertable's bucketed attribute */ const ContinuousAggInfo *all_caggs; MemoryContext per_tuple_mctx; Relation cagg_log_rel; Snapshot snapshot; } HypertableInvalidationState; typedef enum ContinuousAggTableType { HYPER_INVALIDATION_LOG, CAGG_INVALIDATION_LOG, CAGG_MATERIALIZATION_RANGES, } ContinuousAggTableType; static Relation open_cagg_table(ContinuousAggTableType type, LOCKMODE lockmode); static void hypertable_invalidation_scan_init(ScanIterator *iterator, int32 hyper_id, LOCKMODE lockmode); static HeapTuple create_materialization_ranges_tup(TupleDesc tupdesc, int32 cagg_hyper_id, int64 start, int64 end); static void insert_new_cagg_materialization_ranges(const ContinuousAggInvalidationState *state, const InternalTimeRange refresh_window, int32 cagg_hyper_id); static bool save_invalidation_for_refresh(const ContinuousAggInvalidationState *state, const Invalidation *invalidation); static void set_remainder_after_cut(Invalidation *remainder, int32 hyper_id, int64 lowest_modified_value, int64 greatest_modified_value); static void invalidation_entry_reset(Invalidation *entry); static void invalidation_entry_set_from_hyper_invalidation(Invalidation *entry, const TupleInfo *ti, int32 hyper_id, Oid dimtype, const ContinuousAggBucketFunction *bucket_function); static void invalidation_entry_set_from_cagg_invalidation(Invalidation *entry, const TupleInfo *ti, Oid dimtype, const ContinuousAggBucketFunction *bucket_function); static bool invalidations_can_be_merged(const Invalidation *a, const Invalidation *b); static bool invalidation_entry_try_merge(Invalidation *entry, const Invalidation *newentry); static void insert_new_cagg_invalidation(const HypertableInvalidationState *state, const Invalidation *entry, int32 cagg_hyper_id); static void move_invalidations_from_hyper_to_cagg_log(const HypertableInvalidationState *state); static void cagg_invalidations_scan_by_hypertable_init(ScanIterator *iterator, int32 cagg_hyper_id, LOCKMODE lockmode); static Invalidation cut_cagg_invalidation(const ContinuousAggInvalidationState *state, const InternalTimeRange *refresh_window, const Invalidation *entry); static Invalidation cut_cagg_invalidation_and_compute_remainder( const ContinuousAggInvalidationState *state, const InternalTimeRange *refresh_window, const Invalidation *mergedentry, const Invalidation *current_remainder); static void clear_cagg_invalidations_for_refresh(const ContinuousAggInvalidationState *state, const InternalTimeRange *refresh_window, bool force); static void cagg_invalidation_state_init(ContinuousAggInvalidationState *state, const ContinuousAgg *cagg); static void cagg_invalidation_state_cleanup(const ContinuousAggInvalidationState *state); static void continuous_agg_process_hypertable_invalidations_single(Oid hypertable_relid); static void continuous_agg_process_hypertable_invalidations_multi(ArrayType *hypertable_array); static Relation open_cagg_table(ContinuousAggTableType type, LOCKMODE lockmode) { static const CatalogTable logmappings[] = { [HYPER_INVALIDATION_LOG] = CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG, [CAGG_INVALIDATION_LOG] = CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG, [CAGG_MATERIALIZATION_RANGES] = CONTINUOUS_AGGS_MATERIALIZATION_RANGES, }; Catalog *catalog = ts_catalog_get(); Oid relid = catalog_get_table_id(catalog, logmappings[type]); return table_open(relid, lockmode); } static void hypertable_invalidation_scan_init(ScanIterator *iterator, int32 hyper_id, LOCKMODE lockmode) { *iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG, lockmode, CurrentMemoryContext); iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG, CONTINUOUS_AGGS_HYPERTABLE_INVALIDATION_LOG_IDX); ts_scan_iterator_scan_key_init( iterator, Anum_continuous_aggs_hypertable_invalidation_log_idx_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hyper_id)); } HeapTuple create_invalidation_tup(const TupleDesc tupdesc, int32 cagg_hyper_id, int64 start, int64 end) { Datum values[Natts_continuous_aggs_materialization_invalidation_log] = { 0 }; bool isnull[Natts_continuous_aggs_materialization_invalidation_log] = { false }; values[AttrNumberGetAttrOffset( Anum_continuous_aggs_materialization_invalidation_log_materialization_id)] = Int32GetDatum(cagg_hyper_id); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_materialization_invalidation_log_lowest_modified_value)] = Int64GetDatum(start); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_materialization_invalidation_log_greatest_modified_value)] = Int64GetDatum(end); return heap_form_tuple(tupdesc, values, isnull); } /* * Add an entry to the continuous aggregate invalidation log. */ void invalidation_cagg_log_add_entry(int32 cagg_hyper_id, int64 start, int64 end) { Relation rel = open_cagg_table(CAGG_INVALIDATION_LOG, RowExclusiveLock); CatalogSecurityContext sec_ctx; HeapTuple tuple; Assert(start <= end); tuple = create_invalidation_tup(RelationGetDescr(rel), cagg_hyper_id, start, end); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_only(rel, tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(tuple); table_close(rel, NoLock); } void invalidation_hyper_log_add_entry(int32 hyper_id, int64 start, int64 end) { Relation rel = open_cagg_table(HYPER_INVALIDATION_LOG, RowExclusiveLock); CatalogSecurityContext sec_ctx; Datum values[Natts_continuous_aggs_hypertable_invalidation_log]; bool nulls[Natts_continuous_aggs_hypertable_invalidation_log] = { false }; Assert(start <= end); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_hypertable_invalidation_log_hypertable_id)] = Int32GetDatum(hyper_id); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_hypertable_invalidation_log_lowest_modified_value)] = Int64GetDatum(start); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_hypertable_invalidation_log_greatest_modified_value)] = Int64GetDatum(end); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, RelationGetDescr(rel), values, nulls); ts_catalog_restore_user(&sec_ctx); table_close(rel, NoLock); elog(DEBUG1, "hypertable log for hypertable %d added entry [" INT64_FORMAT ", " INT64_FORMAT "]", hyper_id, start, end); } /* * Invalidate one or more continuous aggregates. * * Add an invalidation in the given range. The invalidation is added either to * the hypertable invalidation log or the continuous aggregate invalidation * log depending on the type of the given hypertable. If the hypertable is a * "raw" hypertable (i.e., one that has one or more continuous aggregates), the * entry is added to the hypertable invalidation log and will invalidate all * the associated continuous aggregates. If the hypertable is instead an * materialized hypertable, the entry is added to the cagg invalidation log * and only invalidates the continuous aggregate owning that materialized * hypertable. */ void continuous_agg_invalidate_raw_ht(const Hypertable *raw_ht, int64 start, int64 end) { Assert(raw_ht != NULL); invalidation_hyper_log_add_entry(raw_ht->fd.id, start, end); } void continuous_agg_invalidate_mat_ht(const Hypertable *raw_ht, const Hypertable *mat_ht, int64 start, int64 end) { Assert((raw_ht != NULL) && (mat_ht != NULL)); invalidation_cagg_log_add_entry(mat_ht->fd.id, start, end); } static HeapTuple create_materialization_ranges_tup(TupleDesc tupdesc, int32 cagg_hyper_id, int64 start, int64 end) { Datum values[Natts_continuous_aggs_materialization_ranges] = { 0 }; bool isnull[Natts_continuous_aggs_materialization_ranges] = { false }; values[AttrNumberGetAttrOffset( Anum_continuous_aggs_materialization_ranges_materialization_id)] = Int32GetDatum(cagg_hyper_id); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_materialization_ranges_lowest_modified_value)] = Int64GetDatum(start); values[AttrNumberGetAttrOffset( Anum_continuous_aggs_materialization_ranges_greatest_modified_value)] = Int64GetDatum(end); return heap_form_tuple(tupdesc, values, isnull); } static void insert_new_cagg_materialization_ranges(const ContinuousAggInvalidationState *state, const InternalTimeRange refresh_window, int32 cagg_hyper_id) { CatalogSecurityContext sec_ctx; TupleDesc tupdesc = RelationGetDescr(state->cagg_queue_rel); HeapTuple tuple = create_materialization_ranges_tup(tupdesc, cagg_hyper_id, refresh_window.start, refresh_window.end); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_only(state->cagg_queue_rel, tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(tuple); } typedef enum InvalidationResult { INVAL_NOMATCH, INVAL_DELETE, INVAL_CUT, } InvalidationResult; #define IS_VALID_INVALIDATION(entry) ((entry)->hyper_id > 0) static bool save_invalidation_for_refresh(const ContinuousAggInvalidationState *state, const Invalidation *invalidation) { if (!IS_VALID_INVALIDATION(invalidation)) return false; int32 cagg_hyper_id = state->cagg->data.mat_hypertable_id; TupleDesc tupdesc = RelationGetDescr(state->cagg_log_rel); HeapTuple refresh_tup = create_invalidation_tup(tupdesc, cagg_hyper_id, invalidation->lowest_modified_value, invalidation->greatest_modified_value); tuplestore_puttuple(state->invalidations, refresh_tup); heap_freetuple(refresh_tup); InternalTimeRange refresh_window = { .type = state->cagg->partition_type, .start = invalidation->lowest_modified_value, /* Invalidations are inclusive at the end, while refresh windows aren't, so add one to the end of the invalidated region */ .end = ts_time_saturating_add(invalidation->greatest_modified_value, 1, state->cagg->partition_type), }; InternalTimeRange bucketed_refresh_window = compute_circumscribed_bucketed_refresh_window(state->cagg, &refresh_window, state->cagg->bucket_function); insert_new_cagg_materialization_ranges(state, bucketed_refresh_window, cagg_hyper_id); return true; } static void set_remainder_after_cut(Invalidation *remainder, int32 hyper_id, int64 lowest_modified_value, int64 greatest_modified_value) { MemSet(remainder, 0, sizeof(*remainder)); remainder->hyper_id = hyper_id; remainder->lowest_modified_value = lowest_modified_value; remainder->greatest_modified_value = greatest_modified_value; } /* * Try to cut an invalidation against the refresh window. * * If an invalidation entry overlaps with the refresh window, it needs * additional processing: it is either cut, deleted, or left unmodified. * * The part(s) of the invalidation that are outside the refresh window after * the cut will remain in the log. The part of the invalidation that fits * within the window is returned as the "remainder". * * Note that the refresh window is exclusive in the end while invalidations * are inclusive. */ static InvalidationResult cut_invalidation_along_refresh_window(const ContinuousAggInvalidationState *state, const Invalidation *invalidation, const InternalTimeRange *refresh_window, Invalidation *remainder) { int32 cagg_hyper_id = state->cagg->data.mat_hypertable_id; TupleDesc tupdesc = RelationGetDescr(state->cagg_log_rel); InvalidationResult result = INVAL_NOMATCH; HeapTuple lower = NULL; HeapTuple upper = NULL; Assert(remainder != NULL); /* Entry is completely enclosed by the refresh window */ if (invalidation->lowest_modified_value >= refresh_window->start && invalidation->greatest_modified_value < refresh_window->end) { /* * Entry completely enclosed so can be deleted: * * [---------------) * [+++++] */ result = INVAL_DELETE; set_remainder_after_cut(remainder, cagg_hyper_id, invalidation->lowest_modified_value, invalidation->greatest_modified_value); } else { if (invalidation->lowest_modified_value < refresh_window->start && invalidation->greatest_modified_value >= refresh_window->start) { /* * Need to cut in right end: * * [------) * [++++++] * * [++] */ lower = create_invalidation_tup(tupdesc, cagg_hyper_id, invalidation->lowest_modified_value, refresh_window->start - 1); set_remainder_after_cut(remainder, cagg_hyper_id, refresh_window->start, /* Refresh window not exclusive at end */ MIN(refresh_window->end - 1, invalidation->greatest_modified_value)); result = INVAL_CUT; } if (invalidation->lowest_modified_value < refresh_window->end && invalidation->greatest_modified_value >= refresh_window->end) { /* * If the invalidation is already cut on the left above, the reminder is set and * will be reset here. The assert prevents from losing information from the reminder. */ Assert((result == INVAL_CUT && remainder->lowest_modified_value == refresh_window->start) || result == INVAL_NOMATCH); /* * Need to cut in left end: * * [------) * [++++++++] * * [++++] */ upper = create_invalidation_tup(tupdesc, cagg_hyper_id, refresh_window->end, invalidation->greatest_modified_value); set_remainder_after_cut(remainder, cagg_hyper_id, MAX(invalidation->lowest_modified_value, refresh_window->start), /* Refresh window exclusive at end */ refresh_window->end - 1); result = INVAL_CUT; } } /* Insert any modifications into the cagg invalidation log */ if (result == INVAL_CUT) { CatalogSecurityContext sec_ctx; HeapTuple other_range = NULL; ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); /* We'd like to do one update (unless the TID is not set), and * optionally one insert. We pick one of the tuples for an update, and * the other one will be an insert. */ if (lower || upper) { HeapTuple tup = lower ? lower : upper; other_range = lower ? upper : lower; /* If the TID is set, we are updating an existing tuple, i.e., we * are processing and entry in the cagg log itself. Otherwise, we * are processing the hypertable invalidation log and need to * insert a new entry. */ if (ItemPointerIsValid(&invalidation->tid)) { ItemPointerData tid = invalidation->tid; ts_catalog_update_tid_only(state->cagg_log_rel, &tid, tup); } else ts_catalog_insert_only(state->cagg_log_rel, tup); heap_freetuple(tup); } if (other_range) { ts_catalog_insert_only(state->cagg_log_rel, other_range); heap_freetuple(other_range); } ts_catalog_restore_user(&sec_ctx); } return result; } static void invalidation_entry_reset(Invalidation *entry) { MemSet(entry, 0, sizeof(Invalidation)); } /* * Expand an invalidation to bucket boundaries. * * Since a refresh always materializes full buckets, we can safely expand an * invalidation to bucket boundaries and in the process merge a lot more * invalidations. */ void invalidation_expand_to_bucket_boundaries(Invalidation *inv, Oid time_type_oid, const ContinuousAggBucketFunction *bucket_function) { const int64 time_dimension_min = ts_time_get_min(time_type_oid); const int64 time_dimension_max = ts_time_get_max(time_type_oid); int64 min_bucket_start; int64 max_bucket_end; if (bucket_function->bucket_fixed_interval == false) { ts_compute_circumscribed_bucketed_refresh_window_variable(&inv->lowest_modified_value, &inv->greatest_modified_value, bucket_function); return; } int64 bucket_width = ts_continuous_agg_fixed_bucket_width(bucket_function); Assert(bucket_width > 0); /* Compute the start of the "first" bucket for the type. The min value * must be at the start of the "first" bucket or somewhere in the * bucket. If the min value falls on the exact start of the bucket we are * good. Otherwise, we need to move to the next full bucket. */ min_bucket_start = ts_time_saturating_add(time_dimension_min, bucket_width - 1, time_type_oid); min_bucket_start = ts_time_bucket_by_type(bucket_width, min_bucket_start, time_type_oid); /* Compute the end of the "last" bucket for the time type. Remember that * invalidations are inclusive, so the "greatest" value should be the last * value of the last full bucket. Either the max value is already the last * value of the last bucket, or we need to return the last value of the * previous full bucket. */ max_bucket_end = ts_time_bucket_by_type(bucket_width, time_dimension_max, time_type_oid); /* Check if the max value was already the last value of the last bucket */ if (ts_time_saturating_add(max_bucket_end, bucket_width - 1, time_type_oid) == time_dimension_max) { max_bucket_end = time_dimension_max; } else { /* The last bucket was partial. To get the end of previous bucket, we * need to move one step down from the partial last bucket. */ max_bucket_end = ts_time_saturating_sub(max_bucket_end, 1, time_type_oid); } if (inv->lowest_modified_value < min_bucket_start) /* Below the min bucket, so treat as invalid to -infinity. */ inv->lowest_modified_value = INVAL_NEG_INFINITY; else if (inv->lowest_modified_value > max_bucket_end) /* Above the max bucket, so treat as invalid to +infinity. */ inv->lowest_modified_value = INVAL_POS_INFINITY; else inv->lowest_modified_value = ts_time_bucket_by_type(bucket_width, inv->lowest_modified_value, time_type_oid); if (inv->greatest_modified_value < min_bucket_start) /* Below the min bucket, so treat as invalid to -infinity. */ inv->greatest_modified_value = INVAL_NEG_INFINITY; else if (inv->greatest_modified_value > max_bucket_end) /* Above the max bucket, so treat as invalid to +infinity. */ inv->greatest_modified_value = INVAL_POS_INFINITY; else { inv->greatest_modified_value = ts_time_bucket_by_type(bucket_width, inv->greatest_modified_value, time_type_oid); inv->greatest_modified_value = ts_time_saturating_add(inv->greatest_modified_value, bucket_width - 1, time_type_oid); } } /* * Macro to set an Invalidation from a tuple. The tuple can either have the * format of the hypertable invalidation log or the continuous aggregate * invalidation log (as determined by the type parameter). */ #define INVALIDATION_ENTRY_SET(entry, ti, hypertable_id, type) \ do \ { \ bool should_free; \ HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); \ type form; \ form = (type) GETSTRUCT(tuple); \ (entry)->hyper_id = form->hypertable_id; \ (entry)->lowest_modified_value = form->lowest_modified_value; \ (entry)->greatest_modified_value = form->greatest_modified_value; \ (entry)->is_modified = false; \ ItemPointerCopy(&tuple->t_self, &(entry)->tid); \ \ if (should_free) \ heap_freetuple(tuple); \ } while (0); static void invalidation_entry_set_from_hyper_invalidation(Invalidation *entry, const TupleInfo *ti, int32 hyper_id, Oid dimtype, const ContinuousAggBucketFunction *bucket_function) { INVALIDATION_ENTRY_SET(entry, ti, hypertable_id, Form_continuous_aggs_hypertable_invalidation_log); /* Since hypertable invalidations are moved to the continuous aggregate * invalidation log, a different hypertable ID must be set (the ID of the * materialized hypertable). */ entry->hyper_id = hyper_id; invalidation_expand_to_bucket_boundaries(entry, dimtype, bucket_function); } static void invalidation_entry_set_from_cagg_invalidation(Invalidation *entry, const TupleInfo *ti, Oid dimtype, const ContinuousAggBucketFunction *bucket_function) { INVALIDATION_ENTRY_SET(entry, ti, materialization_id, Form_continuous_aggs_materialization_invalidation_log); /* It isn't strictly necessary to expand the invalidation to bucket * boundaries here since all invalidations were already expanded when * copied from the hypertable invalidation log. However, since * invalidation expansion wasn't implemented in early 2.0.x versions of * the extension, there might be unexpanded entries in the cagg * invalidation log for some users. Therefore we try to expand * invalidation entries also here, although in most cases it would do * nothing. */ invalidation_expand_to_bucket_boundaries(entry, dimtype, bucket_function); } /* * Check if two invalidations can be merged into one. * * Since invalidations are inclusive in both ends, two adjacent invalidations * can be merged. */ static bool invalidations_can_be_merged(const Invalidation *a, const Invalidation *b) { /* To account for adjacency, expand one window 1 step in each * direction. This makes adjacent invalidations overlapping. */ int64 a_start = int64_saturating_sub(a->lowest_modified_value, 1); int64 a_end = int64_saturating_add(a->greatest_modified_value, 1); return a_end >= b->lowest_modified_value && a_start <= b->greatest_modified_value; } /* * Try to merge two invalidations into one. * * Returns true if the invalidations were merged, otherwise false. * * Given that we scan ordered on lowest_modified_value, the previous and * current invalidation can overlap in two ways (generalized): * * |------| * |++++++++| * * |-------------| * |++++++++| * * The closest non-overlapping case is (note that adjacent invalidations can * be merged since they are inclusive in both ends): * * |--| * |++++++++| * */ static bool invalidation_entry_try_merge(Invalidation *entry, const Invalidation *newentry) { if (!IS_VALID_INVALIDATION(newentry)) return false; /* Quick exit if no overlap */ if (!invalidations_can_be_merged(entry, newentry)) return false; /* Check if the new entry expands beyond the old one (first case above) */ if (entry->greatest_modified_value < newentry->greatest_modified_value) { entry->greatest_modified_value = newentry->greatest_modified_value; entry->is_modified = true; } return true; } static void insert_new_cagg_invalidation(const HypertableInvalidationState *state, const Invalidation *entry, int32 cagg_hyper_id) { CatalogSecurityContext sec_ctx; TupleDesc tupdesc = RelationGetDescr(state->cagg_log_rel); HeapTuple tuple = create_invalidation_tup(tupdesc, cagg_hyper_id, entry->lowest_modified_value, entry->greatest_modified_value); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_only(state->cagg_log_rel, tuple); ts_catalog_restore_user(&sec_ctx); heap_freetuple(tuple); } /* * Process invalidations in the hypertable invalidation log. * * Copy and delete all entries from the hypertable invalidation log. * * Note that each entry gets one copy per continuous aggregate in the cagg * invalidation log (unless it was merged or matched the refresh * window). These copied entries are later used to track invalidations across * refreshes on a per-cagg basis. * * After this function has run, there are no entries left in the hypertable * invalidation log. */ static void move_invalidations_from_hyper_to_cagg_log(const HypertableInvalidationState *state) { const ContinuousAggInfo *all_caggs = state->all_caggs; int32 hyper_id = state->hypertable_id; int32 last_cagg_hyper_id; ListCell *lc1, *lc2; last_cagg_hyper_id = llast_int(all_caggs->mat_hypertable_ids); /* We use a per-tuple memory context in the scan loop since we could be * processing a lot of invalidations (basically an unbounded * amount). Initialize it here by resetting it. */ MemoryContextReset(state->per_tuple_mctx); /* * Looping over all continuous aggregates in the outer loop ensures all * tuples for a specific continuous aggregate is inserted consecutively in * the cagg invalidation log. This creates better locality for scanning * the invalidations later. */ forboth (lc1, all_caggs->mat_hypertable_ids, lc2, all_caggs->bucket_functions) { int32 cagg_hyper_id = lfirst_int(lc1); const ContinuousAggBucketFunction *bucket_function = lfirst(lc2); Invalidation mergedentry; ScanIterator iterator; invalidation_entry_reset(&mergedentry); hypertable_invalidation_scan_init(&iterator, hyper_id, RowExclusiveLock); iterator.ctx.snapshot = state->snapshot; /* Scan all invalidations */ ts_scanner_foreach(&iterator) { TupleInfo *ti; MemoryContext oldmctx; Invalidation logentry; oldmctx = MemoryContextSwitchTo(state->per_tuple_mctx); ti = ts_scan_iterator_tuple_info(&iterator); invalidation_entry_set_from_hyper_invalidation(&logentry, ti, cagg_hyper_id, state->dimtype, bucket_function); if (!IS_VALID_INVALIDATION(&mergedentry)) { mergedentry = logentry; mergedentry.hyper_id = cagg_hyper_id; } else if (!invalidation_entry_try_merge(&mergedentry, &logentry)) { insert_new_cagg_invalidation(state, &mergedentry, cagg_hyper_id); mergedentry = logentry; } if (cagg_hyper_id == last_cagg_hyper_id) { CatalogSecurityContext sec_ctx; /* The invalidation has been processed for all caggs, so the * only thing left is to delete it from the source hypertable * invalidation log. */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_delete_tid_only(ti->scanrel, &logentry.tid); ts_catalog_restore_user(&sec_ctx); } MemoryContextSwitchTo(oldmctx); MemoryContextReset(state->per_tuple_mctx); } ts_scan_iterator_close(&iterator); /* Handle the last merged invalidation */ if (IS_VALID_INVALIDATION(&mergedentry)) insert_new_cagg_invalidation(state, &mergedentry, cagg_hyper_id); } } static void cagg_invalidations_scan_by_hypertable_init(ScanIterator *iterator, int32 cagg_hyper_id, LOCKMODE lockmode) { *iterator = ts_scan_iterator_create(CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG, lockmode, CurrentMemoryContext); iterator->ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG, CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG_IDX); ts_scan_iterator_scan_key_init( iterator, Anum_continuous_aggs_materialization_invalidation_log_idx_materialization_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(cagg_hyper_id)); } /* * Cut an invalidation and return the part, if any, that remains within the * refresh window. */ static Invalidation cut_cagg_invalidation(const ContinuousAggInvalidationState *state, const InternalTimeRange *refresh_window, const Invalidation *entry) { InvalidationResult result; Invalidation remainder; ItemPointerData tid = entry->tid; invalidation_entry_reset(&remainder); result = cut_invalidation_along_refresh_window(state, entry, refresh_window, &remainder); switch (result) { case INVAL_NOMATCH: /* If no cutting was done (i.e., the invalidation was outside the * refresh window), but the invalidation was previously merged * (expanded) with another invalidation, then we still need to * update it. */ if (entry->is_modified) { HeapTuple tuple = create_invalidation_tup(RelationGetDescr(state->cagg_log_rel), entry->hyper_id, entry->lowest_modified_value, entry->greatest_modified_value); ts_catalog_update_tid_only(state->cagg_log_rel, &tid, tuple); heap_freetuple(tuple); } break; case INVAL_DELETE: ts_catalog_delete_tid_only(state->cagg_log_rel, &tid); break; case INVAL_CUT: /* Nothing to do */ break; } return remainder; } static Invalidation cut_cagg_invalidation_and_compute_remainder(const ContinuousAggInvalidationState *state, const InternalTimeRange *refresh_window, const Invalidation *mergedentry, const Invalidation *current_remainder) { Invalidation new_remainder; Invalidation remainder = *current_remainder; /* The previous and current invalidation could not be merged. We * need to cut the prev invalidation against the refresh window */ new_remainder = cut_cagg_invalidation(state, refresh_window, mergedentry); if (!IS_VALID_INVALIDATION(&remainder)) remainder = new_remainder; else if (!invalidation_entry_try_merge(&remainder, &new_remainder)) { save_invalidation_for_refresh(state, &remainder); remainder = new_remainder; } return remainder; } /* * Clear all cagg invalidations that match a refresh window. * * This function clears all invalidations in the cagg invalidation log that * matches a window, and adds the invalidation segments covered by the window * to the invalidation store (tuple store) in the state argument. The * remaining segments that are added to the invalidation store are regions * that require materialization. * * An invalidation entry that gets processed is either completely enclosed * (covered) by the refresh window, or it partially overlaps. In the former * case, the invalidation entry is removed and for the latter case it is * cut. Thus, an entry can either disappear, reduce in size, or be cut in two. * * Note that the refresh window is inclusive at the start and exclusive at the * end. This function also assumes that invalidations are scanned in order of * lowest_modified_value. */ static void clear_cagg_invalidations_for_refresh(const ContinuousAggInvalidationState *state, const InternalTimeRange *refresh_window, bool force) { ScanIterator iterator; Invalidation mergedentry; Invalidation remainder; invalidation_entry_reset(&mergedentry); invalidation_entry_reset(&remainder); cagg_invalidations_scan_by_hypertable_init(&iterator, state->cagg->data.mat_hypertable_id, RowExclusiveLock); iterator.ctx.data = &state; iterator.ctx.snapshot = state->snapshot; ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, .lockflags = TUPLE_LOCK_FLAG_FIND_LAST_VERSION, }; iterator.ctx.tuplock = &scantuplock; iterator.ctx.flags = SCANNER_F_KEEPLOCK; MemoryContextReset(state->per_tuple_mctx); /* Force refresh within the entire window */ if (force) { mergedentry.hyper_id = state->cagg->data.mat_hypertable_id; mergedentry.lowest_modified_value = refresh_window->start; mergedentry.greatest_modified_value = refresh_window->end; mergedentry.is_modified = false; ItemPointerSet(&mergedentry.tid, InvalidBlockNumber, 0); /* Jump to process remainder to properly cut the invalidation */ goto process_remainder; } /* Process all invalidations for the continuous aggregate */ ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); MemoryContext oldmctx; Invalidation logentry; oldmctx = MemoryContextSwitchTo(state->per_tuple_mctx); invalidation_entry_set_from_cagg_invalidation(&logentry, ti, state->cagg->partition_type, state->cagg->bucket_function); if (!IS_VALID_INVALIDATION(&mergedentry)) mergedentry = logentry; else if (invalidation_entry_try_merge(&mergedentry, &logentry)) { /* * The previous and current invalidation were merged into * one entry (i.e., they overlapped or were adjacent). */ ts_catalog_delete_tid_only(state->cagg_log_rel, &logentry.tid); } else { remainder = cut_cagg_invalidation_and_compute_remainder(state, refresh_window, &mergedentry, &remainder); mergedentry = logentry; } MemoryContextSwitchTo(oldmctx); MemoryContextReset(state->per_tuple_mctx); } ts_scan_iterator_close(&iterator); process_remainder: /* Handle the last (merged) invalidation */ if (IS_VALID_INVALIDATION(&mergedentry)) remainder = cut_cagg_invalidation_and_compute_remainder(state, refresh_window, &mergedentry, &remainder); /* Handle the last (merged) remainder */ save_invalidation_for_refresh(state, &remainder); } static void cagg_invalidation_state_init(ContinuousAggInvalidationState *state, const ContinuousAgg *cagg) { state->cagg = cagg; state->cagg_log_rel = open_cagg_table(CAGG_INVALIDATION_LOG, RowExclusiveLock); state->cagg_queue_rel = open_cagg_table(CAGG_MATERIALIZATION_RANGES, RowExclusiveLock); state->per_tuple_mctx = AllocSetContextCreate(CurrentMemoryContext, "Materialization invalidations", ALLOCSET_DEFAULT_SIZES); state->snapshot = RegisterSnapshot(GetTransactionSnapshot()); } static void cagg_invalidation_state_cleanup(const ContinuousAggInvalidationState *state) { table_close(state->cagg_log_rel, NoLock); table_close(state->cagg_queue_rel, NoLock); UnregisterSnapshot(state->snapshot); MemoryContextDelete(state->per_tuple_mctx); } static void hypertable_invalidation_state_init(HypertableInvalidationState *state, int32 hypertable_id, Oid dimtype, const ContinuousAggInfo *all_caggs) { state->hypertable_id = hypertable_id; state->dimtype = dimtype; state->all_caggs = all_caggs; state->cagg_log_rel = open_cagg_table(CAGG_INVALIDATION_LOG, RowExclusiveLock); state->per_tuple_mctx = AllocSetContextCreate(CurrentMemoryContext, "Hypertable invalidations", ALLOCSET_DEFAULT_SIZES); state->snapshot = RegisterSnapshot(GetTransactionSnapshot()); } static void hypertable_invalidation_state_cleanup(const HypertableInvalidationState *state) { table_close(state->cagg_log_rel, NoLock); UnregisterSnapshot(state->snapshot); MemoryContextDelete(state->per_tuple_mctx); } /* * Move invalidations for a single hypertable from hypertable invalidation log * to materialization invalidation log. This will move *all* hypertable * invalidations for the hypertable to the associated continuous aggregates. */ void invalidation_process_hypertable_log(int32 hypertable_id, Oid dimtype) { HypertableInvalidationState state; const ContinuousAggInfo all_caggs = ts_continuous_agg_get_all_caggs_info(hypertable_id); hypertable_invalidation_state_init(&state, hypertable_id, dimtype, &all_caggs); move_invalidations_from_hyper_to_cagg_log(&state); hypertable_invalidation_state_cleanup(&state); } InvalidationStore * invalidation_process_cagg_log(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, long max_materializations, ContinuousAggRefreshContext context, bool force) { ContinuousAggInvalidationState state; InvalidationStore *store = NULL; long count; cagg_invalidation_state_init(&state, cagg); state.invalidations = tuplestore_begin_heap(false, false, work_mem); clear_cagg_invalidations_for_refresh(&state, refresh_window, force); count = tuplestore_tuple_count(state.invalidations); if (count == 0) { tuplestore_end(state.invalidations); } else { store = palloc(sizeof(InvalidationStore)); store->tupstore = state.invalidations; store->tupdesc = CreateTupleDescCopy(RelationGetDescr(state.cagg_log_rel)); } cagg_invalidation_state_cleanup(&state); return store; } void invalidation_store_free(InvalidationStore *store) { FreeTupleDesc(store->tupdesc); tuplestore_end(store->tupstore); pfree(store); } /* * Wrapper function to move all invalidations from the hypertable invalidation * log to the materialization invalidation log. * * This will call the appropriate function depending on the type of the * argument. * * It accepts NAME, REGCLASS, or REGCLASS[]. We need the NAME overload since * we do not want the user to have to write "'my_table'::regclass" when * calling it with a simple table name and the "fallback" case for implicit * conversions is any type int he "String" type category. * * See https://www.postgresql.org/docs/current/typeconv-func.html#TYPECONV-FUNC */ Datum continuous_agg_process_hypertable_invalidations(PG_FUNCTION_ARGS) { Oid *argtypes; char **argnames; char *argmodes; ts_feature_flag_check(FEATURE_CAGG); TS_PREVENT_IN_TRANSACTION_BLOCK(get_func_name(FC_FN_OID(fcinfo))); if (PG_ARGISNULL(0)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("parameter cannot be null"))); /* * Check the types and number of arguments that we passed in and validate * what we can handle it. */ HeapTuple func_tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fcinfo->flinfo->fn_oid)); if (!HeapTupleIsValid(func_tuple)) elog(ERROR, "cache lookup failed for function %u", fcinfo->flinfo->fn_oid); int numargs = get_func_arg_info(func_tuple, &argtypes, &argnames, &argmodes); ReleaseSysCache(func_tuple); Ensure(numargs == 1, "expected one argument, but got %d", numargs); Ensure(argtypes[0] == NAMEOID || argtypes[0] == REGCLASSOID || argtypes[0] == REGCLASSARRAYOID, "bad argument type %d", argtypes[0]); if (argtypes[0] == NAMEOID) { /* * We deal with text explicitly to not have to cast the argument to * REGCLASS. We just call the input function directly here. */ Name name = PG_GETARG_NAME(0); /* * We do not use DirectInputFunctionCallSafe here because it does not * exist prior to PG16. */ Datum result = DirectFunctionCall3(regclassin, NameGetDatum(name), ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1)); Oid hypertable_relid = DatumGetObjectId(result); continuous_agg_process_hypertable_invalidations_single(hypertable_relid); } else if (argtypes[0] == REGCLASSOID) { Oid hypertable_relid = PG_GETARG_OID(0); continuous_agg_process_hypertable_invalidations_single(hypertable_relid); } else if (argtypes[0] == REGCLASSARRAYOID) { ArrayType *hypertable_array = PG_GETARG_ARRAYTYPE_P(0); continuous_agg_process_hypertable_invalidations_multi(hypertable_array); } PG_RETURN_VOID(); } static void continuous_agg_process_hypertable_invalidations_single(Oid hypertable_relid) { if (!OidIsValid(hypertable_relid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("invalid relation"))); ts_hypertable_permissions_check(hypertable_relid, GetUserId()); int32 hypertable_id = ts_hypertable_relid_to_id(hypertable_relid); const Hypertable *ht = ts_hypertable_get_by_id(hypertable_id); if (!ht) ereport(ERROR, errcode(ERRCODE_UNDEFINED_TABLE), errmsg("relation \"%s\" is not a hypertable", get_rel_name(hypertable_relid))); const Dimension *dim = hyperspace_get_open_dimension(ht->space, 0); Ensure(dim != NULL, "partitioning dimension not found for hypertable \"%s\"", get_rel_name(hypertable_relid)); Oid dimtype = ts_dimension_get_partition_type(dim); Assert(OidIsValid(dimtype)); invalidation_threshold_get(hypertable_id, dimtype); invalidation_process_hypertable_log(hypertable_id, dimtype); } static void append_string_info_relid(StringInfo info, ListCell *lc) { Oid relid = lfirst_oid(lc); const char *name = get_rel_name(relid); if (name) appendStringInfo(info, "\"%s\"", name); else appendStringInfo(info, "%d", relid); } /* * PostgreSQL function to move hypertable invalidations to materialization * invalidation log. */ static void continuous_agg_process_hypertable_invalidations_multi(ArrayType *hypertable_array) { ArrayIterator array_iterator = array_create_iterator(hypertable_array, 0, NULL); List *hypertables = NIL; List *bad_objects = NIL; Datum value; bool isnull; while (array_iterate(array_iterator, &value, &isnull)) { /* Function signature only allow OIDs, so we will always have an OID. */ Oid hypertable_relid = DatumGetObjectId(value); Cache *hcache; Hypertable *ht = ts_hypertable_cache_get_cache_and_entry(hypertable_relid, CACHE_FLAG_MISSING_OK, &hcache); if (ht) { int32 hypertable_id = ht->fd.id; TS_DEBUG_LOG("add relation \"%s\" to list: hypertable_id=%d", get_rel_name(hypertable_relid), hypertable_id); ts_hypertable_permissions_check(hypertable_relid, GetUserId()); hypertables = lappend_int(hypertables, hypertable_id); } else { TS_DEBUG_LOG("relation \"%s\" is not a hypertable", get_rel_name(hypertable_relid)); bad_objects = lappend_oid(bad_objects, hypertable_relid); } ts_cache_release(&hcache); } array_free_iterator(array_iterator); const int bad_count = list_length(bad_objects); if (bad_count == 1) { const Oid relid = linitial_oid(bad_objects); const char *name = get_rel_name(relid); if (name) ereport(ERROR, errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("table \"%s\" is not a hypertable", name)); else ereport(ERROR, errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("OID %d is not a hypertable", relid)); } else if (bad_count > 1) { ereport(ERROR, errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("%d objects in list are not hypertables", bad_count), errdetail("Bad objects are %s.", ts_list_to_string(bad_objects, append_string_info_relid))); } multi_invalidation_process_hypertable_log(hypertables); } �������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation.h�������������������������������������������0000664�0000000�0000000�00000004000�15100345067�0023477�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "continuous_aggs/materialize.h" #include "ts_catalog/continuous_agg.h" /* * Invalidation. * * A common representation of an invalidation that works across both the * hypertable invalidation log and the continuous aggregate invalidation log. */ typedef struct Invalidation { int32 hyper_id; int64 lowest_modified_value; int64 greatest_modified_value; bool is_modified; ItemPointerData tid; } Invalidation; #define INVAL_NEG_INFINITY PG_INT64_MIN #define INVAL_POS_INFINITY PG_INT64_MAX typedef struct InvalidationStore { Tuplestorestate *tupstore; TupleDesc tupdesc; } InvalidationStore; typedef struct Hypertable Hypertable; extern void invalidation_cagg_log_add_entry(int32 cagg_hyper_id, int64 start, int64 end); extern void invalidation_hyper_log_add_entry(int32 hyper_id, int64 start, int64 end); extern void continuous_agg_invalidate_raw_ht(const Hypertable *raw_ht, int64 start, int64 end); extern void continuous_agg_invalidate_mat_ht(const Hypertable *raw_ht, const Hypertable *mat_ht, int64 start, int64 end); extern Datum continuous_agg_process_hypertable_invalidations(PG_FUNCTION_ARGS); extern void invalidation_process_hypertable_log(int32 hypertable_id, Oid dimtype); extern InvalidationStore *invalidation_process_cagg_log(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, long max_materializations, ContinuousAggRefreshContext context, bool force); extern void invalidation_store_free(InvalidationStore *store); extern void invalidation_expand_to_bucket_boundaries(Invalidation *inv, Oid time_type_oid, const ContinuousAggBucketFunction *bucket_function); extern HeapTuple create_invalidation_tup(const TupleDesc tupdesc, int32 cagg_hyper_id, int64 start, int64 end); timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_multi.c�������������������������������������0000664�0000000�0000000�00000055104�15100345067�0024717�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Module for processing invalidations for multiple hypertables in one single * pass. It will build up a multi-range for each continuous aggregate using * the internal time type. * * The multi-invalidation module will collect ranges for all continuous * aggregates associated with a hypertable and automatically write them to the * materialization log as needed to meet the memory bounds. * * When setting up the module, a log and high and low working memory limits * are provided. As ranges are added, the used memory is tracked and when it * exceeds the high working memory limit, invalidation ranges will be flushed * to the materialization log until reaching the low working memory limit. */ #include "invalidation_multi.h" #include <postgres.h> #include <access/tupdesc.h> #include <catalog/pg_class_d.h> #include <catalog/pg_type_d.h> #include <common/int.h> #include <executor/spi.h> #include <lib/stringinfo.h> #include <miscadmin.h> #include <nodes/pg_list.h> #include <postgres_ext.h> #include <replication/logicalproto.h> #include <storage/lockdefs.h> #include <utils/array.h> #include <utils/elog.h> #include <utils/memutils.h> #include <utils/palloc.h> #include <utils/rangetypes.h> #include <utils/typcache.h> #include "continuous_aggs/invalidation.h" #include "continuous_aggs/invalidation_record.h" #include "continuous_aggs/invalidation_threshold.h" #include "debug_point.h" #include "guc.h" #include "ts_catalog/continuous_agg.h" /* * Initialize the multi-invalidation state to collect invalidations for * continuous aggregates. * * The multi-invalidation state tracks invalidation ranges for continuous * aggregates and is used to combine multiple ranges from the hypertable log * into a set of smaller ranges aligned to bucket widths for each continuous * aggregate. */ void multi_invalidation_state_init(MultiInvalidationState *state, const char *slot_name, Size low_work_mem, Size high_work_mem) { state->hash_context = AllocSetContextCreate(CurrentMemoryContext, "InvalidationHashContext", ALLOCSET_START_SMALL_SIZES); state->work_context = AllocSetContextCreate(CurrentMemoryContext, "InvalidationProcessingContext", ALLOCSET_START_SMALL_SIZES); HASHCTL hypertables_ctl = { .keysize = sizeof(int32), .entrysize = sizeof(MultiInvalidationEntry), .hcxt = state->hash_context }; HASHCTL ranges_ctl = { .keysize = sizeof(int32), .entrysize = sizeof(MultiInvalidationRangeEntry), .hcxt = state->hash_context }; state->hypertables = hash_create("Multi-invalidation hypertables cache", 32, &hypertables_ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); state->ranges = hash_create("Multi-invalidation continuous aggregate ranges cache", 32, &ranges_ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); Catalog *const catalog = ts_catalog_get(); Oid relid = catalog_get_table_id(catalog, CONTINUOUS_AGGS_MATERIALIZATION_INVALIDATION_LOG); state->logrel = table_open(relid, RowExclusiveLock); state->typecache = lookup_type_cache(INT8MULTIRANGEOID, TYPECACHE_MULTIRANGE_INFO); namestrcpy(&state->slot_name, slot_name); state->low_work_mem = low_work_mem; state->high_work_mem = high_work_mem; } void multi_invalidation_state_cleanup(MultiInvalidationState *state) { hash_destroy(state->ranges); hash_destroy(state->hypertables); table_close(state->logrel, NoLock); MemoryContextDelete(state->hash_context); MemoryContextDelete(state->work_context); } static void multi_invalidation_range_entry_init(MultiInvalidationState *state, MultiInvalidationRangeEntry *entry, int32 materialization_id, ContinuousAggBucketFunction *bucket_function, MemoryContext context) { entry->context = context; entry->materialization_id = materialization_id; entry->bucket_function = bucket_function; entry->ranges_count = 0; entry->ranges_alloc = 16; /* Starting count, but will increase */ entry->ranges = MemoryContextAllocZero(entry->context, entry->ranges_alloc * sizeof(RangeType *)); } /* * Clear the range entry. * * This is typically done before it is removed from the hash table. If you * want to use it again, you need to call multi_invalidation_range_init. * * Both the ranges and the range entry are stored in the hash memory context * for the processing state, so we need to free them explicitly. */ static void multi_invalidation_range_entry_destroy(MultiInvalidationState *state, MultiInvalidationRangeEntry *entry) { Assert(entry->ranges != NULL && entry->context != NULL); TS_DEBUG_LOG("destroying context %s with %u KiB", entry->context->name, (unsigned int) (MemoryContextMemAllocated(entry->context, false) / 1024)); MemoryContextDelete(entry->context); entry->ranges = NULL; } /* * Initialize the hypertable invalidation entry. * * Returns all associated continuous aggregates that are using WAL to collect * invalidations. */ static void multi_invalidation_hypertable_entry_init(MultiInvalidationState *state, MultiInvalidationEntry *entry, int32 hypertable_id) { const Hypertable *const ht = ts_hypertable_get_by_id(hypertable_id); const Dimension *const dim = hyperspace_get_open_dimension(ht->space, 0); ListCell *lc; entry->hypertable_id = hypertable_id; entry->dimtype = ts_dimension_get_partition_type(dim); entry->caggs = NIL; /* * We can add all continuous aggregates for the hypertable since they are * using the WAL-based invalidation collection method and we expect to * start writing to them. We allocate these on the hash context. */ MemoryContext old_context = MemoryContextSwitchTo(state->hash_context); List *caggs = ts_continuous_aggs_find_by_raw_table_id(hypertable_id); foreach (lc, caggs) { ContinuousAgg *cagg = lfirst(lc); entry->caggs = lappend_int(entry->caggs, cagg->data.mat_hypertable_id); } MemoryContextSwitchTo(old_context); } /* * Fetch a hypertable entry for update * * This will fetch the hypertable entry for the given hypertable, and * construct it if it was not there. * * Returns a pointer to the entry that was either found or added. */ MultiInvalidationEntry * multi_invalidation_state_hypertable_entry_get_for_update(MultiInvalidationState *state, int32 hypertable_id) { bool hypertables_entry_found; MultiInvalidationEntry *hypertables_entry = hash_search(state->hypertables, &hypertable_id, HASH_ENTER, &hypertables_entry_found); /* If hypertable entry was not found, initialize it. */ if (!hypertables_entry_found) multi_invalidation_hypertable_entry_init(state, hypertables_entry, hypertable_id); Assert(hypertables_entry != NULL); return hypertables_entry; } void multi_invalidation_range_add(MultiInvalidationState *state, const Invalidation *invalidation) { Size allocated_hash_mem = MemoryContextMemAllocated(state->hash_context, true); /* * If we are exceeding the high working memory mark, start to flush ranges * until we are below the low working memory mark. We first check the * amount of memory allocated, because this is quick, but then we need to * check if it was a false alarm and we actually had space left. */ TS_DEBUG_LOG("used memory: %u KiB / %u KiB", (unsigned int) (allocated_hash_mem / 1024), (unsigned int) (state->high_work_mem / 1024)); if (allocated_hash_mem > state->high_work_mem) multi_invalidation_flush_ranges(state); MemoryContext old_context = MemoryContextSwitchTo(state->hash_context); MultiInvalidationEntry *hypertables_entry = multi_invalidation_state_hypertable_entry_get_for_update(state, invalidation->hyper_id); /* Iterate over all associated caggs of the hypertable, expand the range * to the bucket boundaries for the continuous aggregate, and add it to * the ranges to build. */ ListCell *lc; foreach (lc, hypertables_entry->caggs) { const int32 materialized_id = lfirst_int(lc); /* We copy all the fields of the invalidation, but modify the hypertable id to be the id of * the materialization table. */ Invalidation cagg_invalidation = *invalidation; cagg_invalidation.hyper_id = materialized_id; bool ranges_entry_found; MultiInvalidationRangeEntry *ranges_entry = hash_search(state->ranges, &materialized_id, HASH_ENTER, &ranges_entry_found); if (!ranges_entry_found) { /* * The init below does a lot of scans so to be able to throw away that memory we use the * range entry context for this scan. When destroying the memory context while flushing * ranges we will get rid of this as well. */ MemoryContext context = AllocSetContextCreate(state->hash_context, "InvalidationRangeEntryContext", ALLOCSET_START_SMALL_SIZES); MemoryContext old_context = MemoryContextSwitchTo(context); ContinuousAgg *cagg = ts_continuous_agg_find_by_mat_hypertable_id(materialized_id, false); multi_invalidation_range_entry_init(state, ranges_entry, materialized_id, cagg->bucket_function, context); MemoryContextSwitchTo(old_context); } MemoryContext old_context = MemoryContextSwitchTo(ranges_entry->context); /* Check invariant for processing to make sure that we do not write * outside allocated memory. */ Assert(ranges_entry->ranges_count < ranges_entry->ranges_alloc); invalidation_expand_to_bucket_boundaries(&cagg_invalidation, hypertables_entry->dimtype, ranges_entry->bucket_function); /* * Add the new range to the list. * * Ranges in the materialization log are int64, just like in the * hypertable invalidation log, so we use INT8RANGE for those. * * Both the upper and the lower bounds are inclusive for invalidations * that we store. */ RangeBound lbound = { .val = Int64GetDatum(cagg_invalidation.lowest_modified_value), .infinite = (cagg_invalidation.lowest_modified_value == INVAL_NEG_INFINITY), .inclusive = true, .lower = true, }; RangeBound ubound = { .val = Int64GetDatum(cagg_invalidation.greatest_modified_value), .infinite = (cagg_invalidation.greatest_modified_value == INVAL_POS_INFINITY), .inclusive = true, .lower = false, }; /* * Make sure the range is allocated in the range entry context and add * it to the array of ranges. */ RangeType *newrange = make_range_compat(state->typecache->rngtype, &lbound, &ubound, false, NULL); ranges_entry->ranges[ranges_entry->ranges_count++] = newrange; TS_DEBUG_LOG("adding range %s for hypertable %d to invalidation state", datum_as_string(INT8RANGEOID, RangeTypePGetDatum(newrange), false), ranges_entry->materialization_id); /* * Double the capacity if we have hit the ceiling. This will extend * the array in the range memory context. */ if (ranges_entry->ranges_count >= ranges_entry->ranges_alloc) { ranges_entry->ranges_alloc *= 2; ranges_entry->ranges = repalloc(ranges_entry->ranges, ranges_entry->ranges_alloc * sizeof(RangeType *)); } MemoryContextSwitchTo(old_context); Assert(ranges_entry->ranges_count < ranges_entry->ranges_alloc); } MemoryContextSwitchTo(old_context); } /* * Write the aggregated ranges to the log. * * This will first check if it is necessary to evict any range entries because * we risk exceeding the memory limit. If that is the case, it will start to * evict entries until it has "sufficient margins" to continue running. * * This will first create a multi-range from all the collected ranges to * eliminate duplicates and merge adjacent ranges, and then write all the * ranges to the materialization log. */ static void multi_invalidation_range_entry_write(MultiInvalidationState *state, MultiInvalidationRangeEntry *entry) { int32 range_count; RangeType **ranges; TupleDesc tupdesc = RelationGetDescr(state->logrel); MemoryContext old_context = MemoryContextSwitchTo(state->work_context); /* Create a multirange from the collected ranges. This will also combine * and merge any overlapping entries. It is allocated in the work context * that we switched to above. */ MultirangeType *multirange = make_multirange(INT8MULTIRANGEOID, state->typecache->rngtype, entry->ranges_count, entry->ranges); /* Deserialize the multirange to a sequence of ranges and write them * to the materialization log table. */ multirange_deserialize(state->typecache->rngtype, multirange, &range_count, &ranges); for (int i = 0; i < range_count; i++) { bool empty; RangeBound lower, upper; /* Deserialize the range to get the lower and upper bound. */ range_deserialize(state->typecache->rngtype, ranges[i], &lower, &upper, &empty); /* There should be no empty ranges returned, but if there is, we just * ignore them in release builds. */ Assert(!empty); if (!empty) { CatalogSecurityContext sec_ctx; HeapTuple newtup = create_invalidation_tup(tupdesc, entry->materialization_id, lower.infinite ? INVAL_NEG_INFINITY : DatumGetInt64(lower.val), upper.infinite ? INVAL_POS_INFINITY : DatumGetInt64(upper.val)); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_only(state->logrel, newtup); ts_catalog_restore_user(&sec_ctx); } } /* * We cannot reset the work memory context inside the loop since the * multi-range is allocated in this memory. Doing so might thrash that * data. * * A possible optimization is to create a temporary working context for * the memory allocated in the loop, but this seems excessive unless we * know a lot of memory is used here. */ MemoryContextSwitchTo(old_context); MemoryContextReset(state->work_context); } void multi_invalidation_range_write_all(MultiInvalidationState *state) { HASH_SEQ_STATUS hash_seq; MultiInvalidationRangeEntry *entry; hash_seq_init(&hash_seq, state->ranges); while ((entry = hash_seq_search(&hash_seq)) != NULL) multi_invalidation_range_entry_write(state, entry); } #if PG17_LT static inline int pg_cmp_size(size_t a, size_t b) { return (a > b) - (a < b); } #endif static int range_entry_size_cmp(const void *lhs, const void *rhs) { const MultiInvalidationRangeEntry *lhs_entry = *(MultiInvalidationRangeEntry **) lhs; const MultiInvalidationRangeEntry *rhs_entry = *(MultiInvalidationRangeEntry **) rhs; const Size lhs_size = MemoryContextMemAllocated(lhs_entry->context, false); const Size rhs_size = MemoryContextMemAllocated(rhs_entry->context, false); return pg_cmp_size(lhs_size, rhs_size); } /* * Flush ranges until we read low working memory. */ void multi_invalidation_flush_ranges(MultiInvalidationState *state) { HASH_SEQ_STATUS hash_seq; MultiInvalidationRangeEntry *entry; int count; /* * We do *not* allocate this array on the work context since we are using * the work context when processing the range entries. We explicitly free * the memory after processing. */ Assert(CurrentMemoryContext != state->work_context); const long num_entries = hash_get_num_entries(state->ranges); MultiInvalidationRangeEntry **entries = palloc_array(MultiInvalidationRangeEntry *, num_entries); hash_seq_init(&hash_seq, state->ranges); for (count = 0; (entry = hash_seq_search(&hash_seq)) != NULL; ++count) entries[count] = entry; Assert(count == num_entries); /* Sort entries on the number of ranges in each entry */ qsort(entries, num_entries, sizeof(MultiInvalidationRangeEntry *), range_entry_size_cmp); /* * Flush range entries (and remove them from the hash table) until we are * below the low working memory limit. We start from the largest entries * (that is, the end of the array). */ int idx = num_entries; while (idx-- > 0 && state->low_work_mem < MemoryContextMemAllocated(state->hash_context, true)) { multi_invalidation_range_entry_write(state, entries[idx]); multi_invalidation_range_entry_destroy(state, entries[idx]); hash_search(state->ranges, &entries[idx]->materialization_id, HASH_REMOVE, NULL); } /* * If we ran out of entries to flush and still exceed working memory, we * abort with an error. There is nothing we can do. * * This is not particularly likely, unless maintenance work memory is set * really low. */ if (state->low_work_mem < MemoryContextMemAllocated(state->hash_context, true)) ereport(ERROR, errcode(ERRCODE_OUT_OF_MEMORY), errmsg("not enough memory available to process invalidations")); pfree(entries); } /* * Get array of hypertables to collect changes. * * The array consists of interleaving table names and attribute names. The * attribute name is the name of the primary partition column for the table. * This array is intended to be used as the variadic array for * pg_logical_slot_get_binary_changes(). */ static ArrayType * get_array_for_changes(MultiInvalidationState *state) { HASH_SEQ_STATUS hash_seq; MultiInvalidationEntry *entry; const long tables_count = hash_get_num_entries(state->hypertables); const size_t values_count = 2 * tables_count; Datum *values = palloc(values_count * sizeof(Datum)); hash_seq_init(&hash_seq, state->hypertables); for (int i = 0; (entry = hash_seq_search(&hash_seq)) != NULL; i += 2) { const Hypertable *ht = ts_hypertable_get_by_id(entry->hypertable_id); const Dimension *dim = hyperspace_get_open_dimension(ht->space, 0); const char *qual_table_name = quote_qualified_identifier(NameStr(ht->fd.schema_name), NameStr(ht->fd.table_name)); const char *column_name = NameStr(dim->fd.column_name); TS_DEBUG_LOG("hypertable=%s, attribute=%s", qual_table_name, column_name); values[i + 0] = PointerGetDatum(cstring_to_text(qual_table_name)); values[i + 1] = PointerGetDatum(cstring_to_text(column_name)); } /* Not sure we need the array of values after this. It seems like the * datums are actually copied, but it is not entirely clear. */ #if PG16_GE return construct_array_builtin(values, values_count, TEXTOID); #else return construct_array(values, values_count, TEXTOID, -1, false, TYPALIGN_INT); #endif } /* * Move invalidations for multiple hypertables in one pass. * * We process the invalidation in batches to avoid eating up too much * memory. This is configurable using the GUC * timescaledb.continuous_aggregate_processing_wal_batch_size. */ void multi_invalidation_move_invalidations(MultiInvalidationState *state) { static SPIPlanPtr plan_get_invalidations = NULL; static const char *query_get_invalidations = "SELECT data FROM pg_logical_slot_get_binary_changes($1, NULL, $2, variadic $3)"; char nulls[3]; Datum args[3]; if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Set up plan if not already set up */ if (plan_get_invalidations == NULL) { Oid argtypes[3] = { NAMEOID, INT4OID, TEXTARRAYOID }; TS_DEBUG_LOG("setting up plan for query \"%s\"", query_get_invalidations); SPIPlanPtr plan = SPI_prepare(query_get_invalidations, 3, argtypes); if (plan == NULL) elog(ERROR, "SPI_prepare failed for \"%s\"", query_get_invalidations); SPI_keepplan(plan); plan_get_invalidations = plan; } /* Collect all hypertables with corresponding attributes in an array. We * will use this for the call. The array consists of interleaving table * name and attribute name. */ ArrayType *array = get_array_for_changes(state); /* * Set up arguments for the prepared statement to get a batch of ranges to * process. */ memset(nulls, ' ', sizeof(nulls) / sizeof(*nulls)); args[0] = NameGetDatum(&state->slot_name); args[1] = Int32GetDatum(ts_guc_cagg_wal_batch_size); args[2] = PointerGetDatum(array); TS_DEBUG_LOG("array: %s", datum_as_string(TEXTARRAYOID, args[2], false)); while (true) { CatalogSecurityContext sec_ctx; TS_DEBUG_LOG("executing plan for query \"%s\"", query_get_invalidations); /* Fetch batches and add them to the multi-table state */ ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); int rc = SPI_execute_plan(plan_get_invalidations, args, nulls, true, 0); ts_catalog_restore_user(&sec_ctx); if (rc < 0) elog(ERROR, "SPI_execute_plan_extended failed executing query \"%s\": %s", query_get_invalidations, SPI_result_code_string(rc)); TS_DEBUG_LOG("got %lu rows to process", (unsigned long) SPI_processed); if (SPI_processed == 0) break; /* No more batches to read */ /* Process batch of rows and add invalidation ranges to state. */ for (uint64 i = 0; i < SPI_processed; i++) { Datum data; bool isnull; TS_DEBUG_LOG("processing row %lu", (unsigned long) i); data = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull); if (isnull) continue; bytea *raw_record = DatumGetByteaP(data); StringInfoData info; initReadOnlyStringInfo(&info, VARDATA_ANY(raw_record), VARSIZE_ANY_EXHDR(raw_record)); InvalidationMessage msg; ts_invalidation_record_decode(&info, &msg); Invalidation invalidation = { .hyper_id = ts_hypertable_relid_to_id(msg.ver1.hypertable_relid), .lowest_modified_value = msg.ver1.lowest_modified, .greatest_modified_value = msg.ver1.highest_modified, }; multi_invalidation_range_add(state, &invalidation); } } SPI_finish(); /* Add invalidations to the materialization log. */ multi_invalidation_range_write_all(state); } void multi_invalidation_process_hypertable_log(List *hypertables) { MultiInvalidationState state; ListCell *lc; char slotname[TS_INVALIDATION_SLOT_NAME_MAX]; /* * This typically runs under PortalContext that lives for the duration of * the query / call. */ TS_DEBUG_LOG("CurrentMemoryContext \"%s\" with %u KiB", CurrentMemoryContext->name, (unsigned int) (MemoryContextMemAllocated(CurrentMemoryContext, true) / 1024)); ts_get_invalidation_replication_slot_name(slotname, sizeof(slotname)); multi_invalidation_state_init(&state, slotname, 1024 * ts_guc_cagg_low_work_mem, 1024 * ts_guc_cagg_high_work_mem); foreach (lc, hypertables) (void) multi_invalidation_state_hypertable_entry_get_for_update(&state, lfirst_int(lc)); /* * Lock WAL to coordinate refreshes. * * We use LockDatabaseObject() on the materialization log relation since * that will not conflict with relation locks on the relation (it is an * database object lock), only with other "database object lockers" on the * relation. */ LockDatabaseObject(RelationRelationId, state.logrel->rd_id, 0, AccessExclusiveLock); DEBUG_WAITPOINT("multi_invalidation_process_invalidations"); multi_invalidation_move_invalidations(&state); UnlockDatabaseObject(RelationRelationId, state.logrel->rd_id, 0, AccessExclusiveLock); multi_invalidation_state_cleanup(&state); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_multi.h�������������������������������������0000664�0000000�0000000�00000010550�15100345067�0024720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <utils/multirangetypes.h> #include <utils/typcache.h> #include "continuous_aggs/invalidation.h" #include "ts_catalog/continuous_agg.h" /* * Multi invalidations information. * * Information about the hypertable being processed is stored here, including * partitioning column type and list of continuous aggregates associated with the * hypertable. */ typedef struct MultiInvalidationEntry { /* Key fields */ int32 hypertable_id; /* Value fields */ Oid dimtype; /* Partition column dimension type */ List *caggs; /* Materialization table ids for associated caggs */ } MultiInvalidationEntry; /* * Multi-hypertable invalidation ranges for a continuous aggregate. * * Information necessary for building the multiranges for the continuous * aggregate is stored here, including the bucket function and information * about the continuous aggregate. * * Note that the ranges are stored in internal time type (microseconds since * Epoch). This is what we write to the materialization log. * * The type cache entry need to contain the element type, the range type, and * the multirange type, which means that it has to be an entry for the * multirange type. * * Note that range types are varlen objects, so we have to store an array of * pointers to range types, not an array of range types. */ typedef struct MultiInvalidationRangeEntry { /* Key fields */ int32 materialization_id; /* Materialization table for continuous aggregate */ /* Value fields */ int ranges_alloc; /* Number of range entries allocated in array */ int ranges_count; /* Number of range entries in array */ RangeType **ranges; /* Array of pointers to collected invalidation ranges */ MemoryContext context; /* Memory context for the ranges in this entry */ ContinuousAggBucketFunction *bucket_function; } MultiInvalidationRangeEntry; /* * State for multi-hypertable invalidations. * * This state lives for the duration of the processing, including the entries * in the hash tables. * * When the high work memory limit is exceeded, range entries will get written * to the materialization invalidation log until we get below the low memory * limit after which it will proceed to add entries. * * The reason for a high and low working memory limit is to avoid * flip-flopping between writing to materialization log and adding ranges when * we're close to the high working memory mark. * * The type cache entry need to contain the element type, the range type, and * the multirange type, which means that it has to be an entry for the * multirange type. */ typedef struct MultiInvalidationState { MemoryContext hash_context; /* Memory context for stored data */ MemoryContext work_context; /* Memory context for short-lived processing data */ TypeCacheEntry *typecache; /* Typecache entry for multirange type */ Size high_work_mem; /* High limit on the working memory (in bytes) */ Size low_work_mem; /* Low limit on the working memory (in bytes) */ HTAB *hypertables; /* Cache for information about hypertables being processed */ HTAB *ranges; /* Cache with ranges for all continuous aggregates */ Relation logrel; /* Materialization invalidation log table being written */ NameData slot_name; /* Slot name used while processing invalidations */ } MultiInvalidationState; extern void multi_invalidation_state_init(MultiInvalidationState *state, const char *slot_name, Size low_work_mem, Size high_work_mem); extern void multi_invalidation_state_cleanup(MultiInvalidationState *state); extern void multi_invalidation_flush_ranges(MultiInvalidationState *state); extern void multi_invalidation_range_add(MultiInvalidationState *state, const Invalidation *invalidation); extern void multi_invalidation_range_write_all(MultiInvalidationState *state); extern void multi_invalidation_move_invalidations(MultiInvalidationState *state); extern MultiInvalidationEntry * multi_invalidation_state_hypertable_entry_get_for_update(MultiInvalidationState *state, int32 hypertable_id); extern void multi_invalidation_process_hypertable_log(List *hypertables); extern Datum continuous_agg_process_multi_hypertable_invalidations(PG_FUNCTION_ARGS); ��������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_plugin.c������������������������������������0000664�0000000�0000000�00000036311�15100345067�0025062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <inttypes.h> #include <miscadmin.h> #include <access/attnum.h> #include <access/genam.h> #include <access/htup.h> #include <access/table.h> #include <access/transam.h> #include <access/tupdesc.h> #include <catalog/namespace.h> #include <catalog/pg_attribute.h> #include <catalog/pg_inherits.h> #include <commands/defrem.h> #include <executor/tuptable.h> #include <libpq/pqformat.h> #include <nodes/makefuncs.h> #include <replication/logical.h> #include <replication/output_plugin.h> #include <storage/lockdefs.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/hsearch.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/palloc.h> #include <utils/regproc.h> #include <utils/varlena.h> #include "compat/compat.h" #include "invalidation_plugin_cache.h" #include "invalidation_record.h" #include "utils.h" PG_MODULE_MAGIC; #if PG16_LT extern TSDLLEXPORT void _PG_output_plugin_init(OutputPluginCallbacks *cb); #endif typedef struct TrackRelInfo { Oid hypertable_relid; /* Relid of the hypertable that we're collecting * invalidations for */ AttrNumber attnum; /* Attribute number of the attribute to read from * the chunks. */ } TrackRelInfo; /* * Hash table with relations seen. * * In order to avoid multiple lookups of a relation, we record all relations * seen as entries in a hash table for the duration of a run (e.g., one call * of pg_logical_slot_get_binary_changes). * * If we see a new relation, we look up the inheritance parent and if it has * one, we check if it is one of the relations that we should track and set * the "track" field to true in that case. * * If the relation does not have an inheritance parent, or if the inheritance * parent is not one of the relations we track, we will set the "track" field * to false. * * Note that since hypertables are single-level inheritance tables, we do not * look further up the inheritance chain. If you want to be able to handle * multi-level inheritance changes, you need to update this. */ typedef struct SeenRelsEntry { Oid relid; /* Relid, also key */ bool track; /* Shall this relation be tracked or not? */ TrackRelInfo *relinfo; /* Relation information, or NULL if not tracked */ } SeenRelsEntry; typedef struct InvalidationsPluginData { MemoryContext invals_context; /* Memory context for allocations for a transaction */ HTAB *invals_cache; /* Invalidations cache with entries for a transaction. */ } InvalidationsPluginData; /* * Hash table with relations to track. * * Might include relations that are dropped, but this is safe since it just * means we return invalidations for some data that does not exist any * more. * * The hash table and all it's entries are allocated in the logical decoding * memory context, which is long-lived. */ static HTAB *RelationSeenCache = NULL; /* * Find the parent of a relid. * * This is inspired by has_superclass() in src/backend/catalog/pg_inherits.c * but returns the parent instead of just checking if it has a parent. */ static Oid find_parent(Oid relid) { ScanKeyData skey; Oid parent_relid = InvalidOid; HeapTuple inhtup; Relation catalog = table_open(InheritsRelationId, AccessShareLock); ScanKeyInit(&skey, Anum_pg_inherits_inhrelid, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(relid)); SysScanDesc scan = systable_beginscan(catalog, InheritsRelidSeqnoIndexId, true, NULL, 1, &skey); if ((inhtup = systable_getnext(scan)) != NULL) { Form_pg_inherits inh = (Form_pg_inherits) GETSTRUCT(inhtup); parent_relid = inh->inhparent; } systable_endscan(scan); table_close(catalog, AccessShareLock); return parent_relid; } /* * Find all inheritance children of a relation and store in a hash table. * * This is a simplified version of find_all_inheritors from pg_inherits.c * intended for hypertables only. * * Note that we are not locking the relids once we've found them. */ static void add_inheritance_children(HTAB *rels, TrackRelInfo *relinfo) { List *children = find_inheritance_children(relinfo->hypertable_relid, NoLock); children = lappend_oid(children, relinfo->hypertable_relid); ListCell *lc; foreach (lc, children) { Oid child_oid = lfirst_oid(lc); bool found; SeenRelsEntry *entry = hash_search(rels, &child_oid, HASH_ENTER, &found); /* We shouldn't have duplicates, but in case we do, we just skip them */ if (!found) { entry->relid = child_oid; entry->track = true; entry->relinfo = relinfo; } } pfree(children); } /* * Check if relation should be tracked. * * A relation should be tracked either if it is in the cache and is marked as * being tracked, or it has a parent that is tracked. * * This will also update the hash of relations that we have seen. * * The relinfo field is set to the relation information for the relation it * should be tracked under, i.e., the hypertable. */ static bool is_relation_tracked(Oid relid, TrackRelInfo **relinfo_var) { bool found; Assert(RelationSeenCache != NULL); SeenRelsEntry *entry = hash_search(RelationSeenCache, &relid, HASH_ENTER, &found); if (!found) { Oid parent_relid = find_parent(relid); if (OidIsValid(parent_relid)) { SeenRelsEntry *parent_entry = hash_search(RelationSeenCache, &parent_relid, HASH_FIND, &found); entry->track = found; entry->relinfo = found ? parent_entry->relinfo : NULL; } else { entry->track = false; } } *relinfo_var = entry->relinfo; return entry->track; } #if PG_VERSION_NUM < 170000 static HeapTuple as_tuple(ReorderBufferTupleBuf *buf) { return &buf->tuple; } #else static HeapTuple as_tuple(HeapTuple tuple) { return tuple; } #endif static void init_rel_seen_cache(List *relinfo_list) { HASHCTL ctl = { .keysize = sizeof(Oid), .entrysize = sizeof(SeenRelsEntry), .hcxt = CurrentMemoryContext, }; if (RelationSeenCache) return; RelationSeenCache = hash_create("relations for invalidations plugin", 128, &ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); ListCell *lc; foreach (lc, relinfo_list) { TrackRelInfo *track_relinfo = lfirst(lc); add_inheritance_children(RelationSeenCache, track_relinfo); } } static void invalidations_insert_tuple(InvalidationsPluginData *data, TrackRelInfo *relinfo, Relation rel, HeapTuple tuple) { TupleDesc tupdesc = RelationGetDescr(rel); Form_pg_attribute attr = TupleDescAttr(tupdesc, relinfo->attnum - 1); Assert(relinfo->attnum != InvalidAttrNumber); /* * It might be that the attribute is dropped somewhere in the stream we * are reading, but for that case, the attribute number will not change, * it will just be set as dropped, so we will just ignore it. * * Note that this is expected to be a partitioning attribute, and it * should not be possible to drop a partitioning attribute, but for the * unexpected case that we in non-debug-built code get a tuple that have a * dropped partitioning attribute, is seems excessive to raise an error * when we can just ignore the tuple. */ Assert(!attr->attisdropped); if (attr->attisdropped) return; bool isnull; Datum datum = heap_getattr(tuple, relinfo->attnum, tupdesc, &isnull); Assert(!isnull); if (isnull) return; invalidation_cache_record_entry(data->invals_cache, relinfo->hypertable_relid, ts_time_value_to_internal(datum, attr->atttypid)); } static void invalidations_record_insert(InvalidationsPluginData *data, TrackRelInfo *relinfo, LogicalDecodingContext *ctx, Relation relation, ReorderBufferChange *change) { invalidations_insert_tuple(data, relinfo, relation, as_tuple(change->data.tp.newtuple)); } static void invalidations_record_update(InvalidationsPluginData *data, TrackRelInfo *relinfo, LogicalDecodingContext *ctx, Relation relation, ReorderBufferChange *change) { /* * The field oldtuple is only set if any of the columns in the replica * identity are modified. Otherwise, oldtuple is set to NULL. * * This means that if oldtuple is NULL, it is sufficient to use newtuple * to decide what range that was updated. */ if (change->data.tp.oldtuple) invalidations_insert_tuple(data, relinfo, relation, as_tuple(change->data.tp.oldtuple)); invalidations_insert_tuple(data, relinfo, relation, as_tuple(change->data.tp.newtuple)); } static void invalidations_record_delete(InvalidationsPluginData *data, TrackRelInfo *relinfo, LogicalDecodingContext *ctx, Relation relation, ReorderBufferChange *change) { /* * We need a replica identity to deal with deletes. If the table does not * have a replica identity, we would have to invalidate the entire table, * so instead we throw an error if the delete does not have an oldtuple. */ if (!change->data.tp.oldtuple) ereport(ERROR, errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("table is missing replica identity"), errdetail("Table \"%s\" need to have a replica identity to handle DELETE.", RelationGetRelationName(relation))); invalidations_insert_tuple(data, relinfo, relation, as_tuple(change->data.tp.oldtuple)); } static List * parse_output_parameters(List *options) { ListCell *option; List *relinfo_list = NIL; /* * Options are pairs of relation names and the attribute to read. * * We do not check if the "key" is a hypertable since we do not want to * rely on the TimescaleDB metadata. */ foreach (option, options) { DefElem *elem = lfirst(option); const char *name = elem->defname; #if PG16_LT List *qname = stringToQualifiedNameList(name); #else List *qname = stringToQualifiedNameList(name, NULL); #endif TrackRelInfo *relinfo = palloc0(sizeof(TrackRelInfo)); RangeVar *hypertable_rv = makeRangeVarFromNameList(qname); relinfo->hypertable_relid = RangeVarGetRelid(hypertable_rv, AccessShareLock, true); if (!OidIsValid(relinfo->hypertable_relid)) ereport(ERROR, errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("relation \"%s\" does not exist", name)); NameData attname; namestrcpy(&attname, strVal(elem->arg)); relinfo->attnum = get_attnum(relinfo->hypertable_relid, NameStr(attname)); if (relinfo->attnum == InvalidAttrNumber) ereport(ERROR, errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("attribute \"%s\" does not exist", NameStr(attname))); relinfo_list = lappend(relinfo_list, relinfo); } return relinfo_list; } static void invalidations_write_record(InvalidationCacheEntry *entry, bool last_write, InvalidationsContext *args) { LogicalDecodingContext *ctx = args->ctx; TS_DEBUG_LOG("write entry: hypertable=\"%s\", lowest_modified=" UINT64_FORMAT ", highest_modified=" UINT64_FORMAT, get_rel_name(entry->hypertable_relid), entry->lowest_modified, entry->highest_modified); InvalidationMessage msg; msg.ver1.hypertable_relid = entry->hypertable_relid; msg.ver1.lowest_modified = entry->lowest_modified; msg.ver1.highest_modified = entry->highest_modified; OutputPluginPrepareWrite(ctx, last_write); ts_invalidation_record_encode(&msg, ctx->out); OutputPluginWrite(ctx, last_write); } static void invalidations_startup(LogicalDecodingContext *ctx, OutputPluginOptions *opt, bool is_init) { InvalidationsPluginData *data = palloc0(sizeof(InvalidationsPluginData)); TS_DEBUG_LOG("startup in memory context \"%s\"", ctx->context->name); data->invals_context = AllocSetContextCreate(ctx->context, "Continuous aggregates invalidations memory context", ALLOCSET_DEFAULT_SIZES); ctx->output_plugin_private = data; opt->output_type = OUTPUT_PLUGIN_BINARY_OUTPUT; if (!is_init) { TS_DEBUG_LOG("current memory context when parsing parameters: \"%s\"", CurrentMemoryContext->name); List *relinfo_list = parse_output_parameters(ctx->output_plugin_options); init_rel_seen_cache(relinfo_list); } } static void invalidations_shutdown(LogicalDecodingContext *ctx) { InvalidationsPluginData *data = ctx->output_plugin_private; MemoryContextDelete(data->invals_context); if (RelationSeenCache) { hash_destroy(RelationSeenCache); RelationSeenCache = NULL; } } /* * BEGIN callback: set up the cache to collect the invalidation * ranges inside the transaction. * * This is similar to how the execute_cagg_trigger function works, which * collects invalidation entries on a per-transaction basis. */ static void invalidations_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) { InvalidationsPluginData *data = ctx->output_plugin_private; Assert(data->invals_cache == NULL); data->invals_cache = invalidation_cache_create(data->invals_context); } /* * COMMIT callback that will write the collected ranges to the output using * logical replication format. */ static void invalidations_commit_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, XLogRecPtr commit_lsn) { InvalidationsPluginData *data = ctx->output_plugin_private; invalidation_cache_foreach_entry(data->invals_cache, invalidations_write_record, &(InvalidationsContext){ .ctx = ctx, .txn = txn }); invalidation_cache_destroy(data->invals_cache); data->invals_cache = NULL; } /* * BEGIN PREPARE callback. Nothing to do here. */ static void invalidations_begin_prepare_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn) { } /* * PREPARE callback. Nothing to do here. */ static void invalidations_prepare_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, XLogRecPtr prepare_lsn) { } /* * ROLLBACK PREPARED callback */ static void invalidations_rollback_prepared_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, XLogRecPtr prepare_end_lsn, TimestampTz prepare_time) { } static bool invalidations_filter_prepare(LogicalDecodingContext *ctx, TransactionId xid, const char *gid) { return false; } /* Change callback. */ static void invalidations_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn, Relation relation, ReorderBufferChange *change) { InvalidationsPluginData *data = ctx->output_plugin_private; Oid relid = RelationGetRelid(relation); TrackRelInfo *track_relinfo = NULL; if (!is_relation_tracked(relid, &track_relinfo)) return; Assert(track_relinfo != NULL); MemoryContext old = MemoryContextSwitchTo(data->invals_context); switch (change->action) { case REORDER_BUFFER_CHANGE_INSERT: invalidations_record_insert(data, track_relinfo, ctx, relation, change); break; case REORDER_BUFFER_CHANGE_UPDATE: invalidations_record_update(data, track_relinfo, ctx, relation, change); break; case REORDER_BUFFER_CHANGE_DELETE: invalidations_record_delete(data, track_relinfo, ctx, relation, change); break; default: Assert(false); } MemoryContextSwitchTo(old); } void _PG_output_plugin_init(OutputPluginCallbacks *cb) { memset(cb, 0, sizeof(OutputPluginCallbacks)); cb->startup_cb = invalidations_startup; cb->begin_cb = invalidations_begin_txn; cb->change_cb = invalidations_change; cb->commit_cb = invalidations_commit_txn; cb->shutdown_cb = invalidations_shutdown; cb->filter_prepare_cb = invalidations_filter_prepare; cb->prepare_cb = invalidations_prepare_txn; cb->begin_prepare_cb = invalidations_begin_prepare_txn; cb->rollback_prepared_cb = invalidations_rollback_prepared_txn; } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_plugin_cache.c������������������������������0000664�0000000�0000000�00000004050�15100345067�0026200�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Cache for the invalidations read by the plugin. * * The cache is used to accumulate invalidations for continuous aggregates based on * changes to the source hypertable aggregated. When processing the WAL, * multiple entries in the WAL might invalidate the same or overlapping ranges. The * cache is used to merge those ranges into singular ranges until the cache is flushed * at the end of a transaction. * * The cache key is the source hypertable relid from which the * invalidation was generated. */ #include <postgres.h> #include <fmgr.h> #include "invalidation_plugin_cache.h" #include <inttypes.h> #include "invalidation_record.h" /* * Record the value in the invalidation range cache. */ void invalidation_cache_record_entry(HTAB *cache, Oid relid, int64 value) { bool found; InvalidationCacheEntry *entry = hash_search(cache, &relid, HASH_ENTER, &found); if (!found) { entry->hypertable_relid = relid; entry->lowest_modified = value; entry->highest_modified = value; } else if (value < entry->lowest_modified) entry->lowest_modified = value; else if (value > entry->highest_modified) entry->highest_modified = value; } HTAB * invalidation_cache_create(MemoryContext mcxt) { HASHCTL ctl = { .keysize = sizeof(Oid), .entrysize = sizeof(InvalidationCacheEntry), .hcxt = mcxt, }; return hash_create("hypertable log invalidation cache", 32, &ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); } void invalidation_cache_destroy(HTAB *cache) { hash_destroy(cache); } void invalidation_cache_foreach_entry(HTAB *cache, ProcessInvalidationFunction func, InvalidationsContext *args) { HASH_SEQ_STATUS hash_seq; InvalidationCacheEntry *entry; int count = hash_get_num_entries(cache); hash_seq_init(&hash_seq, cache); while ((entry = hash_seq_search(&hash_seq)) != NULL) (*func)(entry, (--count == 0), args); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_plugin_cache.h������������������������������0000664�0000000�0000000�00000003013�15100345067�0026203�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <replication/logical.h> #include <utils/hsearch.h> /* * Invalidation log cache entry. * * This structure is deliberately distinct from InvalidationEntry in * invalidation_record.h, even though they contain similar information. * * The reason is that this structure might add more data that is being tracked * as part of a transaction that should not be present in the record being * sent back from the plugin. If we need to add fields here, it would affect * the format of the records sent back, and we don't what that to happen even * accidentally. */ typedef struct InvalidationCacheEntry { Oid hypertable_relid; int64 lowest_modified; int64 highest_modified; } InvalidationCacheEntry; /* * Context for the invalidation execution. */ typedef struct InvalidationsContext { LogicalDecodingContext *ctx; ReorderBufferTXN *txn; } InvalidationsContext; typedef void ProcessInvalidationFunction(InvalidationCacheEntry *, bool, InvalidationsContext *); extern HTAB *invalidation_cache_create(MemoryContext mcxt); extern void invalidation_cache_destroy(HTAB *cache); extern void invalidation_cache_record_entry(HTAB *cache, Oid hypertable_relid, int64 value); extern void invalidation_cache_foreach_entry(HTAB *cache, ProcessInvalidationFunction func, InvalidationsContext *args); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_record.c������������������������������������0000664�0000000�0000000�00000007061�15100345067�0025042�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <funcapi.h> #include "invalidation_record.h" #include <access/tupdesc.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include "compat/compat.h" #include "export.h" #include <utils/elog.h> TS_FUNCTION_INFO_V1(ts_invalidation_read_record); /* * Helper macros to always use the current version when encoding the entry. */ #define _field(v) CppConcat(ver, v) #define _ver _field(INVALIDATION_MESSAGE_CURRENT_VERSION) /* * Read an encoded invalidation record coming from the plugin. * * Records from the plugin is coming in logical replication format, so decode * it and produce a single composite value in the same format as the * invalidation table. */ Datum ts_invalidation_read_record(PG_FUNCTION_ARGS) { bytea *raw_record = PG_GETARG_BYTEA_P(0); TupleDesc tupdesc; if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); tupdesc = BlessTupleDesc(tupdesc); StringInfoData info; initReadOnlyStringInfo(&info, VARDATA_ANY(raw_record), VARSIZE_ANY_EXHDR(raw_record)); InvalidationMessage msg; ts_invalidation_record_decode(&info, &msg); Datum values[] = { [0] = ObjectIdGetDatum(msg._ver.hypertable_relid), [1] = Int64GetDatum(msg._ver.lowest_modified), [2] = Int64GetDatum(msg._ver.highest_modified), }; bool nulls[3] = { 0 }; Assert(tupdesc->natts == sizeof(values) / sizeof(*values)); HeapTuple htup = heap_form_tuple(tupdesc, values, nulls); PG_RETURN_DATUM(HeapTupleGetDatum(htup)); } /* * Decode invalidation record in byte array format. * * This needs to handle all supported version formats, not just the current * one. This function should be used on the receiving side of the invalidation * plugin and be used to decode records arriving from the plugin. */ void ts_invalidation_record_decode(StringInfo record, InvalidationMessage *msg) { /* * The header is the same for all versions of the invalidation record. */ msg->hdr.version = pq_getmsgint(record, 2); msg->hdr.padding = pq_getmsgint(record, 2); switch (msg->hdr.version) { case 1: msg->ver1.hypertable_relid = pq_getmsgint32(record); msg->ver1.lowest_modified = pq_getmsgint64(record); msg->ver1.highest_modified = pq_getmsgint64(record); break; default: ereport(ERROR, errcode(ERRCODE_PROTOCOL_VIOLATION), errmsg("unrecognized invalidation record version %d", msg->hdr.version), errdetail( "Invalidation record from invalidation plugin is using an unrecognized " "version, suggesting that it is newer than the extension."), errhint("Make sure that invalidation plugin is not from a newer build than the " "extension.")); break; } } /* * Encode an invalidation tuple in byte array format. */ void ts_invalidation_record_encode(InvalidationMessage *msg, StringInfo record) { /* * Header is always the same for all versions. We deliberately set the * version here to avoid bugs in calling this function. */ msg->hdr.version = INVALIDATION_MESSAGE_CURRENT_VERSION; msg->hdr.padding = 0; pq_sendint16(record, msg->hdr.version); pq_sendint16(record, msg->hdr.padding); pq_sendint32(record, msg->_ver.hypertable_relid); pq_sendint64(record, msg->_ver.lowest_modified); pq_sendint64(record, msg->_ver.highest_modified); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_record.h������������������������������������0000664�0000000�0000000�00000004542�15100345067�0025050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This module (header file plus implementation file) needs to be linked with * both the plugin and with the extension, so it should not have any * unresolved linking dependencies on the extension. */ #pragma once #include <postgres.h> #include <access/attnum.h> /* * Invalidation entry. * * We use the relid of the hypertable rather than the hypertable id to keep * processing fast and also avoid linking dependencies on the timescaledb * extension. * * The translation from hypertable relid to hypertable id will be done on the * receiving end before writing the records to the materialization log. * * The lowest and highest modified values are still in microseconds since the * epoch, but the libraries for this do not require any dynamic linking so we * can just build the plugin with these files directly. * * In order to deal with versions correctly, the entry consists of a union of * structures representing the different versions of the record. There is a * version number added as well so that we can deal with necessary changes. * * If you want to add a new version, step the version by adding one to * INVALIDATION_MESSAGE_CURRENT_VERSION add a new structure with the name * "ver<version>". Then you need to update the decode function as well to * handle the new version. */ typedef struct InvalidationMessageHeader { uint16 version; uint16 padding; } InvalidationMessageHeader; typedef struct InvalidationMessageBodyV1 { InvalidationMessageHeader hdr; Oid hypertable_relid; int64 lowest_modified; int64 highest_modified; } InvalidationMessageBodyV1; typedef union InvalidationMessage { InvalidationMessageHeader hdr; InvalidationMessageBodyV1 ver1; } InvalidationMessage; #define INVALIDATION_MESSAGE_CURRENT_VERSION 1 extern PGDLLEXPORT Datum ts_invalidation_read_record(PG_FUNCTION_ARGS); /* Parameters to these two functions are such that the updated entry is * last. This is to avoid mixing the functions up and let the compiler * complain. */ extern PGDLLEXPORT void ts_invalidation_record_decode(StringInfo record, InvalidationMessage *msg); extern PGDLLEXPORT void ts_invalidation_record_encode(InvalidationMessage *msg, StringInfo record); ��������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_threshold.c���������������������������������0000664�0000000�0000000�00000032447�15100345067�0025566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup.h> #include <access/htup_details.h> #include <access/tableam.h> #include <access/xact.h> #include <nodes/memnodes.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <utils/builtins.h> #include <utils/memutils.h> #include <utils/snapmgr.h> #include <compat/compat.h> #include "ts_catalog/catalog.h" #include <scan_iterator.h> #include <scanner.h> #include <time_bucket.h> #include <time_utils.h> #include "continuous_aggs/materialize.h" #include "debug_point.h" #include "invalidation_threshold.h" #include "ts_catalog/continuous_agg.h" /* * Invalidation threshold. * * The invalidation threshold acts as a dampener on a hypertable to make sure * that invalidations written during inserts won't cause too much write * amplification in "hot" regions---typically the "head" of the table. The * presumption is that most inserts happen at recent time intervals, and those * intervals will be invalid until writes move out of them. Therefore, it * isn't worth writing invalidations in that region since it is presumed * out-of-date anyway. Further, although it is possible to refresh a * continuous aggregate in those "hot" regions, it will lead to partially * filled buckets. Thus, refreshing those intervals is discouraged since the * aggregate will be immediately out-of-date until the buckets are filled. The * invalidation threshold is, in other words, used as a marker that lags * behind the head of the hypertable, where invalidations are written before * the threshold but not after it. * * The invalidation threshold is moved forward (and only forward) by refreshes * on continuous aggregates when it covers a window that stretches beyond the * current threshold. The invalidation threshold needs to be moved in its own * transaction, with exclusive access, before the refresh starts to * materialize data. This is to avoid losing any invalidations that occur * between the start of the transaction that moves the threshold and its end * (when the new threshold becomes visible). * * ______________________________________________ * |_______________________________________|_____| recent data * ^ * invalidations written here | no invalidations * | * invalidation threshold * * Transactions that use an isolation level stronger than READ COMMITTED will * not be able to "see" changes to the invalidation threshold that may have * been made while they were running. Therefore, they always create records * in the hypertable invalidation log. See the cache_inval_entry_write() * implementation in tsl/src/continuous_aggs/insert.c */ typedef struct InvalidationThresholdData { const ContinuousAgg *cagg; const InternalTimeRange *refresh_window; int64 computed_invalidation_threshold; } InvalidationThresholdData; typedef struct InvalidationThresholdGetData { int32 hypertable_id; int64 threshold; } InvalidationThresholdGetData; static ScanTupleResult invalidation_threshold_scan_get(TupleInfo *ti, void *const data) { InvalidationThresholdGetData *the_data = (InvalidationThresholdGetData *) data; bool isnull; Datum datum; if (ti->lockresult == TM_Updated || ti->lockresult == TM_Deleted) return SCAN_RESTART_WITH_NEW_SNAPSHOT; Ensure(ti->lockresult == TM_Ok, "unable to lock invalidation threshold tuple for hypertable %d (lock result %d)", the_data->hypertable_id, ti->lockresult); datum = slot_getattr(ti->slot, Anum_continuous_aggs_invalidation_threshold_watermark, &isnull); Ensure(!isnull, "invalidation threshold for hypertable %d is null", the_data->hypertable_id); the_data->threshold = DatumGetInt64(datum); return SCAN_DONE; } static ScanTupleResult invalidation_threshold_scan_update(TupleInfo *ti, void *const data) { DEBUG_WAITPOINT("invalidation_threshold_scan_update_enter"); InvalidationThresholdData *invthresh = (InvalidationThresholdData *) data; /* If the tuple was modified concurrently, retry the operation and use a new snapshot * to see the updated tuple. */ if (ti->lockresult == TM_Updated) return SCAN_RESTART_WITH_NEW_SNAPSHOT; if (ti->lockresult != TM_Ok) { elog(ERROR, "unable to lock invalidation threshold tuple for hypertable %d (lock result %d)", invthresh->cagg->data.raw_hypertable_id, ti->lockresult); pg_unreachable(); } bool isnull; Datum datum = slot_getattr(ti->slot, Anum_continuous_aggs_invalidation_threshold_watermark, &isnull); /* NULL should never happen because we always initialize the threshold with the MIN * value of the partition type */ Ensure(!isnull, "invalidation threshold for hypertable %d is null", invthresh->cagg->data.raw_hypertable_id); int64 current_invalidation_threshold = DatumGetInt64(datum); /* Compute new invalidation threshold. Note that this computation caps the * threshold at the end of the last bucket that holds data in the * underlying hypertable. */ invthresh->computed_invalidation_threshold = invalidation_threshold_compute(invthresh->cagg, invthresh->refresh_window); if (invthresh->computed_invalidation_threshold > current_invalidation_threshold) { bool nulls[Natts_continuous_agg]; Datum values[Natts_continuous_agg]; bool do_replace[Natts_continuous_agg] = { false }; bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); HeapTuple new_tuple; TupleDesc tupdesc = ts_scanner_get_tupledesc(ti); heap_deform_tuple(tuple, tupdesc, values, nulls); do_replace[AttrNumberGetAttrOffset(Anum_continuous_aggs_invalidation_threshold_watermark)] = true; values[AttrNumberGetAttrOffset(Anum_continuous_aggs_invalidation_threshold_watermark)] = Int64GetDatum(invthresh->computed_invalidation_threshold); new_tuple = heap_modify_tuple(tuple, tupdesc, values, nulls, do_replace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); } else { elog(DEBUG1, "hypertable %d existing watermark >= new invalidation threshold " INT64_FORMAT " " INT64_FORMAT, invthresh->cagg->data.raw_hypertable_id, current_invalidation_threshold, invthresh->computed_invalidation_threshold); invthresh->computed_invalidation_threshold = current_invalidation_threshold; } return SCAN_CONTINUE; } /* * Get the invalidation threshold for the hypertable. * * This will also lock the row. */ int64 invalidation_threshold_get(int32 hypertable_id, Oid type) { InvalidationThresholdGetData data = { .hypertable_id = hypertable_id }; ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; PushActiveSnapshot(GetLatestSnapshot()); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), .index = catalog_get_index(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY), .nkeys = 1, .scankey = scankey, .data = &data, .tuple_found = invalidation_threshold_scan_get, .lockmode = RowShareLock, .scandirection = ForwardScanDirection, .result_mctx = CurrentMemoryContext, .tuplock = &scantuplock, .flags = SCANNER_F_KEEPLOCK, .snapshot = GetActiveSnapshot(), }; ScanKeyInit(&scankey[0], Anum_continuous_aggs_invalidation_threshold_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(hypertable_id)); bool found = ts_scanner_scan_one(&scanctx, false, CAGG_INVALIDATION_THRESHOLD_NAME); Ensure(found, "invalidation threshold for hypertable %d not found", hypertable_id); PopActiveSnapshot(); return data.threshold; } /* * Set a new invalidation threshold. * * The threshold is only updated if the new threshold is greater than the old * one. * * On success, the new threshold is returned, otherwise the existing threshold * is returned instead. */ int64 invalidation_threshold_set_or_get(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window) { bool found = false; ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); ScanTupLock scantuplock = { .waitpolicy = LockWaitBlock, .lockmode = LockTupleExclusive, }; InvalidationThresholdData updatectx = { .cagg = cagg, .refresh_window = refresh_window, }; PushActiveSnapshot(GetLatestSnapshot()); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), .index = catalog_get_index(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY), .nkeys = 1, .scankey = scankey, .data = &updatectx, .tuple_found = invalidation_threshold_scan_update, .lockmode = RowExclusiveLock, .scandirection = ForwardScanDirection, .result_mctx = CurrentMemoryContext, .tuplock = &scantuplock, .flags = SCANNER_F_KEEPLOCK, /* We update the threshold value using this scanner. Since the scanner uses SnapshotSelf * per default, the updated tuple would become immediately visible to the scanner (the * snapshot includes "changes made by the current command") and ts_scanner_scan_one() * would fail due to the second found tuple. A normal MVCC snapshot is used to prevent * the update is immediately seen by the scanner. */ .snapshot = GetActiveSnapshot(), }; ScanKeyInit(&scankey[0], Anum_continuous_aggs_invalidation_threshold_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(cagg->data.raw_hypertable_id)); found = ts_scanner_scan_one(&scanctx, false, CAGG_INVALIDATION_THRESHOLD_NAME); Ensure(found, "invalidation threshold for hypertable %d not found", cagg->data.raw_hypertable_id); PopActiveSnapshot(); return updatectx.computed_invalidation_threshold; } /* * Compute a new invalidation threshold. * * The new invalidation threshold returned is the end of the given refresh * window, unless it ends at "infinity" in which case the threshold is capped * at the end of the last bucket materialized. */ int64 invalidation_threshold_compute(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window) { bool max_refresh = false; Hypertable *ht = ts_hypertable_get_by_id(cagg->data.raw_hypertable_id); if (IS_TIMESTAMP_TYPE(refresh_window->type)) max_refresh = TS_TIME_IS_END(refresh_window->end, refresh_window->type) || TS_TIME_IS_NOEND(refresh_window->end, refresh_window->type); else max_refresh = TS_TIME_IS_MAX(refresh_window->end, refresh_window->type); if (max_refresh) { bool isnull; int64 maxval = ts_hypertable_get_open_dim_max_value(ht, 0, &isnull); if (isnull) { /* No data in hypertable */ return cagg_get_time_min(cagg); } else { if (cagg->bucket_function->bucket_fixed_interval == false) { return ts_compute_beginning_of_the_next_bucket_variable(maxval, cagg->bucket_function); } int64 bucket_width = ts_continuous_agg_fixed_bucket_width(cagg->bucket_function); Assert(bucket_width > 0); int64 bucket_start = ts_time_bucket_by_type(bucket_width, maxval, refresh_window->type); /* Add one bucket to get to the end of the last bucket */ return ts_time_saturating_add(bucket_start, bucket_width, refresh_window->type); } } return refresh_window->end; } /* * Initialize the invalidation threshold. * * The initial value of the invalidation threshold should be the MIN * value for the Continuous Aggregate partition type. */ void invalidation_threshold_initialize(const ContinuousAgg *cagg) { bool found = false; ScanKeyData scankey[1]; Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), .index = catalog_get_index(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD_PKEY), .nkeys = 1, .scankey = scankey, .lockmode = ShareUpdateExclusiveLock, .scandirection = ForwardScanDirection, .result_mctx = CurrentMemoryContext, .flags = SCANNER_F_KEEPLOCK, }; ScanKeyInit(&scankey[0], Anum_continuous_aggs_invalidation_threshold_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(cagg->data.raw_hypertable_id)); found = ts_scanner_scan_one(&scanctx, false, CAGG_INVALIDATION_THRESHOLD_NAME); if (!found) { Relation rel = table_open(catalog_get_table_id(catalog, CONTINUOUS_AGGS_INVALIDATION_THRESHOLD), ShareUpdateExclusiveLock); TupleDesc desc = RelationGetDescr(rel); Datum values[Natts_continuous_aggs_invalidation_threshold]; bool nulls[Natts_continuous_aggs_invalidation_threshold] = { false }; CatalogSecurityContext sec_ctx; /* get the MIN value for the partition type */ int64 min_value = cagg_get_time_min(cagg); values[AttrNumberGetAttrOffset(Anum_continuous_aggs_invalidation_threshold_hypertable_id)] = Int32GetDatum(cagg->data.raw_hypertable_id); values[AttrNumberGetAttrOffset(Anum_continuous_aggs_invalidation_threshold_watermark)] = Int64GetDatum(min_value); ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); ts_catalog_insert_values(rel, desc, values, nulls); ts_catalog_restore_user(&sec_ctx); table_close(rel, NoLock); } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/invalidation_threshold.h���������������������������������0000664�0000000�0000000�00000001376�15100345067�0025570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> typedef struct InternalTimeRange InternalTimeRange; typedef struct ContinuousAgg ContinuousAgg; typedef struct Hypertable Hypertable; extern int64 invalidation_threshold_get(int32 hypertable_id, Oid dimtype); extern int64 invalidation_threshold_set_or_get(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window); extern int64 invalidation_threshold_compute(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window); extern void invalidation_threshold_initialize(const ContinuousAgg *cagg); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/materialize.c��������������������������������������������0000664�0000000�0000000�00000075576�15100345067�0023351�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <executor/spi.h> #include <fmgr.h> #include <lib/stringinfo.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/guc.h> #include <utils/palloc.h> #include <utils/rel.h> #include <utils/relcache.h> #include <utils/snapmgr.h> #include <utils/timestamp.h> #include "compat/compat.h" #include "debug_assert.h" #include "guc.h" #include "materialize.h" #include "scan_iterator.h" #include "scanner.h" #include "time_utils.h" #include "ts_catalog/continuous_agg.h" #include "ts_catalog/continuous_aggs_watermark.h" #define CONTINUOUS_AGG_CHUNK_ID_COL_NAME "chunk_id" /********************* * utility functions * *********************/ static TimeRange internal_time_range_to_time_range(InternalTimeRange internal); static Datum internal_to_time_value_or_infinite(int64 internal, Oid time_type, bool *is_infinite_out); static List *cagg_find_aggref_and_var_cols(ContinuousAgg *cagg, Hypertable *mat_ht); static char *build_merge_insert_columns(List *strings, const char *separator, const char *prefix); static char *build_merge_join_clause(List *column_names); static char *build_merge_update_clause(List *column_names); /*************************** * materialization support * ***************************/ typedef enum MaterializationPlanType { PLAN_TYPE_INSERT, PLAN_TYPE_DELETE, PLAN_TYPE_EXISTS, PLAN_TYPE_MERGE, PLAN_TYPE_MERGE_DELETE, PLAN_TYPE_RANGES_SELECT, PLAN_TYPE_RANGES_DELETE, PLAN_TYPE_RANGES_PENDING, _MAX_MATERIALIZATION_PLAN_TYPES } MaterializationPlanType; typedef struct MaterializationContext { Hypertable *mat_ht; const ContinuousAgg *cagg; SchemaAndName partial_view; SchemaAndName materialization_table; NameData *time_column_name; TimeRange materialization_range; InternalTimeRange internal_materialization_range; char *chunk_condition; ItemPointer tupleid; int nargs; } MaterializationContext; typedef char *(*MaterializationCreateStatement)(MaterializationContext *context); typedef void (*MaterializationEmitError)(MaterializationContext *context); typedef void (*MaterializationEmitProgress)(MaterializationContext *context, uint64 rows_processed); typedef struct MaterializationPlan { SPIPlanPtr plan; bool read_only; bool catalog_security_context; int nargs; MaterializationCreateStatement create_statement; MaterializationEmitError emit_error; MaterializationEmitProgress emit_progress; } MaterializationPlan; static char *create_materialization_insert_statement(MaterializationContext *context); static char *create_materialization_delete_statement(MaterializationContext *context); static char *create_materialization_exists_statement(MaterializationContext *context); static char *create_materialization_merge_statement(MaterializationContext *context); static char *create_materialization_merge_delete_statement(MaterializationContext *context); static char *create_materialization_ranges_select_statement(MaterializationContext *context); static char *create_materialization_ranges_delete_statement(MaterializationContext *context); static char *create_materialization_ranges_pending_statement(MaterializationContext *context); static void emit_materialization_insert_error(MaterializationContext *context); static void emit_materialization_delete_error(MaterializationContext *context); static void emit_materialization_exists_error(MaterializationContext *context); static void emit_materialization_merge_error(MaterializationContext *context); static void emit_materialization_ranges_select_error(MaterializationContext *context); static void emit_materialization_ranges_delete_error(MaterializationContext *context); static void emit_materialization_ranges_pending_error(MaterializationContext *context); static void emit_materialization_insert_progress(MaterializationContext *context, uint64 rows_processed); static void emit_materialization_delete_progress(MaterializationContext *context, uint64 rows_processed); static void emit_materialization_merge_progress(MaterializationContext *context, uint64 rows_processed); static MaterializationPlan materialization_plans[_MAX_MATERIALIZATION_PLAN_TYPES + 1] = { [PLAN_TYPE_INSERT] = { .nargs = 2, .create_statement = create_materialization_insert_statement, .emit_error = emit_materialization_insert_error, .emit_progress = emit_materialization_insert_progress }, [PLAN_TYPE_DELETE] = { .nargs = 2, .create_statement = create_materialization_delete_statement, .emit_error = emit_materialization_delete_error, .emit_progress = emit_materialization_delete_progress }, [PLAN_TYPE_EXISTS] = { .read_only = true, .nargs = 2, .create_statement = create_materialization_exists_statement, .emit_error = emit_materialization_exists_error }, [PLAN_TYPE_MERGE] = { .nargs = 2, .create_statement = create_materialization_merge_statement, .emit_error = emit_materialization_merge_error, .emit_progress = emit_materialization_merge_progress }, [PLAN_TYPE_MERGE_DELETE] = { .nargs = 2, .create_statement = create_materialization_merge_delete_statement, .emit_error = emit_materialization_delete_error, .emit_progress = emit_materialization_delete_progress }, [PLAN_TYPE_RANGES_SELECT] = { .catalog_security_context = true, .nargs = 3, .create_statement = create_materialization_ranges_select_statement, .emit_error = emit_materialization_ranges_select_error }, [PLAN_TYPE_RANGES_DELETE] = { .catalog_security_context = true, .nargs = 1, .create_statement = create_materialization_ranges_delete_statement, .emit_error = emit_materialization_ranges_delete_error }, [PLAN_TYPE_RANGES_PENDING] = { .read_only = true, .nargs = 3, .create_statement = create_materialization_ranges_pending_statement, .emit_error = emit_materialization_ranges_pending_error }, }; static Oid *create_materialization_plan_argtypes(MaterializationContext *context, MaterializationPlanType plan_type, int nargs); static MaterializationPlan *create_materialization_plan(MaterializationContext *context, MaterializationPlanType plan_type); static void create_materialization_plan_args(MaterializationContext *context, MaterializationPlanType plan_type, Datum **values, char **nulls); static uint64 execute_materialization_plan(MaterializationContext *context, MaterializationPlanType plan_type); static void free_materialization_plan(MaterializationContext *context, MaterializationPlanType plan_type); static void free_materialization_plans(MaterializationContext *context); static void update_watermark(MaterializationContext *context); static void execute_materializations(MaterializationContext *context); /* API to update materializations from refresh code */ void continuous_agg_update_materialization(Hypertable *mat_ht, const ContinuousAgg *cagg, SchemaAndName partial_view, SchemaAndName materialization_table, const NameData *time_column_name, InternalTimeRange materialization_range, int32 chunk_id) { MaterializationContext context = { .mat_ht = mat_ht, .cagg = cagg, .partial_view = partial_view, .materialization_table = materialization_table, .time_column_name = (NameData *) time_column_name, .materialization_range = internal_time_range_to_time_range(materialization_range), .internal_materialization_range = materialization_range, /* * chunk_id is valid if the materializaion update should be done only on the given chunk. * This is used currently for refresh on chunk drop only. In other cases, manual * call to refresh_continuous_aggregate or call from a refresh policy, chunk_id is * not provided, i.e., invalid. Also the chunk_id is used only on the old format. */ .chunk_condition = chunk_id != INVALID_CHUNK_ID && !ContinuousAggIsFinalized(cagg) ? psprintf(" AND %s = %d", CONTINUOUS_AGG_CHUNK_ID_COL_NAME, chunk_id) : "", }; /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); /* pin the start of new_materialization to the end of new_materialization, * we are not allowed to materialize beyond that point */ if (materialization_range.start > materialization_range.end) materialization_range.start = materialization_range.end; /* Then insert the materializations */ context.materialization_range = internal_time_range_to_time_range(materialization_range); execute_materializations(&context); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); } /* API to check for pending materialization ranges */ bool continuous_agg_has_pending_materializations(const ContinuousAgg *cagg, InternalTimeRange materialization_range) { MaterializationContext context = { .cagg = cagg, .internal_materialization_range = materialization_range, }; /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); if (materialization_range.start > materialization_range.end) materialization_range.start = materialization_range.end; bool has_pending_materializations = (execute_materialization_plan(&context, PLAN_TYPE_RANGES_PENDING) > 0); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); return has_pending_materializations; } static Datum time_range_internal_to_min_time_value(Oid type) { switch (type) { case TIMESTAMPOID: return TimestampGetDatum(DT_NOBEGIN); case TIMESTAMPTZOID: return TimestampTzGetDatum(DT_NOBEGIN); case DATEOID: return DateADTGetDatum(DATEVAL_NOBEGIN); default: return ts_internal_to_time_value(PG_INT64_MIN, type); } } static Datum time_range_internal_to_max_time_value(Oid type) { switch (type) { case TIMESTAMPOID: return TimestampGetDatum(DT_NOEND); case TIMESTAMPTZOID: return TimestampTzGetDatum(DT_NOEND); case DATEOID: return DateADTGetDatum(DATEVAL_NOEND); break; default: return ts_internal_to_time_value(PG_INT64_MAX, type); } } static Datum internal_to_time_value_or_infinite(int64 internal, Oid time_type, bool *is_infinite_out) { /* MIN and MAX can occur due to NULL thresholds, or due to a lack of invalidations. Since our * regular conversion function errors in those cases, and we want to use those as markers for an * open threshold in one direction, we special case this here*/ if (internal == PG_INT64_MIN) { if (is_infinite_out != NULL) *is_infinite_out = true; return time_range_internal_to_min_time_value(time_type); } else if (internal == PG_INT64_MAX) { if (is_infinite_out != NULL) *is_infinite_out = true; return time_range_internal_to_max_time_value(time_type); } else { if (is_infinite_out != NULL) *is_infinite_out = false; return ts_internal_to_time_value(internal, time_type); } } static TimeRange internal_time_range_to_time_range(InternalTimeRange internal) { TimeRange range; range.type = internal.type; range.start = internal_to_time_value_or_infinite(internal.start, internal.type, NULL); range.end = internal_to_time_value_or_infinite(internal.end, internal.type, NULL); return range; } static List * cagg_find_aggref_and_var_cols(ContinuousAgg *cagg, Hypertable *mat_ht) { List *retlist = NIL; ListCell *lc; Query *cagg_view_query = ts_continuous_agg_get_query(cagg); foreach (lc, cagg_view_query->targetList) { TargetEntry *tle = castNode(TargetEntry, lfirst(lc)); if (!tle->resjunk && (tle->ressortgroupref == 0 || get_sortgroupref_clause_noerr(tle->ressortgroupref, cagg_view_query->groupClause) == NULL)) retlist = lappend(retlist, get_attname(mat_ht->main_table_relid, tle->resno, false)); } return retlist; } static char * build_merge_insert_columns(List *strings, const char *separator, const char *prefix) { StringInfo ret = makeStringInfo(); Assert(strings != NIL); ListCell *lc; foreach (lc, strings) { char *grpcol = (char *) lfirst(lc); if (ret->len > 0) appendStringInfoString(ret, separator); if (prefix) appendStringInfoString(ret, prefix); appendStringInfoString(ret, quote_identifier(grpcol)); } elog(DEBUG2, "%s: %s", __func__, ret->data); return ret->data; } static char * build_merge_join_clause(List *column_names) { StringInfo ret = makeStringInfo(); Assert(column_names != NIL); ListCell *lc; foreach (lc, column_names) { char *column = (char *) lfirst(lc); if (ret->len > 0) appendStringInfoString(ret, " AND "); appendStringInfoString(ret, "P."); appendStringInfoString(ret, quote_identifier(column)); appendStringInfoString(ret, " IS NOT DISTINCT FROM M."); appendStringInfoString(ret, quote_identifier(column)); } elog(DEBUG2, "%s: %s", __func__, ret->data); return ret->data; } static char * build_merge_update_clause(List *column_names) { StringInfo ret = makeStringInfo(); Assert(column_names != NIL); ListCell *lc; foreach (lc, column_names) { char *column = (char *) lfirst(lc); if (ret->len > 0) appendStringInfoString(ret, ", "); appendStringInfoString(ret, quote_identifier(column)); appendStringInfoString(ret, " = P."); appendStringInfoString(ret, quote_identifier(column)); } elog(DEBUG2, "%s: %s", __func__, ret->data); return ret->data; } /* Create INSERT statement */ static char * create_materialization_insert_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); appendStringInfo(&query, "INSERT INTO %s.%s SELECT * FROM %s.%s AS I " "WHERE I.%s >= $1 AND I.%s < $2 %s;", quote_identifier(NameStr(*context->materialization_table.schema)), quote_identifier(NameStr(*context->materialization_table.name)), quote_identifier(NameStr(*context->partial_view.schema)), quote_identifier(NameStr(*context->partial_view.name)), quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name)), context->chunk_condition); return query.data; } /* Create DELETE statement */ static char * create_materialization_delete_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); appendStringInfo(&query, "DELETE FROM %s.%s AS D " "WHERE D.%s >= $1 AND D.%s < $2 %s;", quote_identifier(NameStr(*context->materialization_table.schema)), quote_identifier(NameStr(*context->materialization_table.name)), quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name)), context->chunk_condition); return query.data; } /* Create SELECT EXISTS statement */ static char * create_materialization_exists_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); appendStringInfo(&query, "SELECT 1 FROM %s.%s AS M " "WHERE M.%s >= $1 AND M.%s < $2 " "LIMIT 1;", quote_identifier(NameStr(*context->materialization_table.schema)), quote_identifier(NameStr(*context->materialization_table.name)), quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name))); return query.data; } /* Create MERGE statement */ static char * create_materialization_merge_statement(MaterializationContext *context) { List *grp_colnames = cagg_find_groupingcols((ContinuousAgg *) context->cagg, context->mat_ht); List *agg_colnames = cagg_find_aggref_and_var_cols((ContinuousAgg *) context->cagg, context->mat_ht); List *all_columns = NIL; /* Concat both lists into a single one*/ all_columns = list_concat(all_columns, grp_colnames); all_columns = list_concat(all_columns, agg_colnames); StringInfoData merge_update; initStringInfo(&merge_update); char *merge_update_clause = build_merge_update_clause(all_columns); /* It make no sense but is possible to create a cagg only with time bucket (without * aggregate functions) */ if (merge_update_clause != NULL) { appendStringInfo(&merge_update, " WHEN MATCHED AND ROW(M.*) IS DISTINCT FROM ROW(P.*) THEN " " UPDATE SET %s ", merge_update_clause); } StringInfoData query; initStringInfo(&query); /* MERGE statement to UPDATE affected buckets and INSERT new ones */ appendStringInfo(&query, "WITH partial AS ( " " SELECT * " " FROM %s.%s " " WHERE %s >= $1 AND %s < $2 " ") " "MERGE INTO %s.%s M " "USING partial P ON %s AND M.%s >= $1 AND M.%s < $2 " " %s " /* UPDATE */ " WHEN NOT MATCHED THEN " " INSERT (%s) VALUES (%s) ", /* partial VIEW */ quote_identifier(NameStr(*context->partial_view.schema)), quote_identifier(NameStr(*context->partial_view.name)), /* partial WHERE */ quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name)), /* materialization hypertable */ quote_identifier(NameStr(*context->materialization_table.schema)), quote_identifier(NameStr(*context->materialization_table.name)), /* MERGE JOIN condition */ build_merge_join_clause(grp_colnames), /* extra MERGE JOIN condition with primary dimension */ quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name)), /* UPDATE */ merge_update.data, /* INSERT */ build_merge_insert_columns(all_columns, ", ", NULL), build_merge_insert_columns(all_columns, ", ", "P.")); return query.data; } /* Create DELETE after MERGE query statement */ static char * create_materialization_merge_delete_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); List *grp_colnames = cagg_find_groupingcols((ContinuousAgg *) context->cagg, context->mat_ht); appendStringInfo(&query, "DELETE " "FROM %s.%s M " "WHERE M.%s >= $1 AND M.%s < $2 " "AND NOT EXISTS (" " SELECT FROM %s.%s P " " WHERE %s AND P.%s >= $1 AND P.%s < $2) ", /* materialization hypertable */ quote_identifier(NameStr(*context->materialization_table.schema)), quote_identifier(NameStr(*context->materialization_table.name)), /* materialization hypertable WHERE */ quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name)), /* partial VIEW */ quote_identifier(NameStr(*context->partial_view.schema)), quote_identifier(NameStr(*context->partial_view.name)), /* MERGE JOIN condition */ build_merge_join_clause(grp_colnames), /* partial WHERE */ quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->time_column_name))); return query.data; } static char * create_materialization_ranges_select_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); appendStringInfo(&query, "SELECT ctid, lowest_modified_value, greatest_modified_value " "FROM _timescaledb_catalog.continuous_aggs_materialization_ranges " "WHERE materialization_id = $1 " "AND pg_catalog.int8range(lowest_modified_value, greatest_modified_value) && " "pg_catalog.int8range($2, $3) " "ORDER BY lowest_modified_value ASC " "LIMIT 1 " "FOR UPDATE SKIP LOCKED "); return query.data; } static char * create_materialization_ranges_delete_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); appendStringInfo(&query, "DELETE " "FROM _timescaledb_catalog.continuous_aggs_materialization_ranges " "WHERE ctid = $1"); return query.data; } static char * create_materialization_ranges_pending_statement(MaterializationContext *context) { StringInfoData query; initStringInfo(&query); appendStringInfo(&query, "SELECT * " "FROM _timescaledb_catalog.continuous_aggs_materialization_ranges " "WHERE materialization_id = $1 " "AND pg_catalog.int8range(lowest_modified_value, greatest_modified_value) && " "pg_catalog.int8range($2, $3) " "LIMIT 1 "); return query.data; } static void emit_materialization_insert_error(MaterializationContext *context) { elog(ERROR, "could not insert old values into materialization table \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_delete_error(MaterializationContext *context) { elog(ERROR, "could not delete old values from materialization table \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_exists_error(MaterializationContext *context) { elog(ERROR, "could not check the materialization table \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_merge_error(MaterializationContext *context) { elog(ERROR, "could not merge old values into materialization table \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_ranges_select_error(MaterializationContext *context) { elog(ERROR, "could not select invalidation entries for materialization table \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_ranges_delete_error(MaterializationContext *context) { elog(ERROR, "could not delete invalidation entries for materialization table \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_ranges_pending_error(MaterializationContext *context) { elog(ERROR, "could not select pending materialization ranges \"%s.%s\"", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_insert_progress(MaterializationContext *context, uint64 rows_processed) { elog(LOG, "inserted " UINT64_FORMAT " row(s) into materialization table \"%s.%s\"", rows_processed, NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_delete_progress(MaterializationContext *context, uint64 rows_processed) { elog(LOG, "deleted " UINT64_FORMAT " row(s) from materialization table \"%s.%s\"", rows_processed, NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static void emit_materialization_merge_progress(MaterializationContext *context, uint64 rows_processed) { elog(LOG, "merged " UINT64_FORMAT " row(s) into materialization table \"%s.%s\"", rows_processed, NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); } static Oid * create_materialization_plan_argtypes(MaterializationContext *context, MaterializationPlanType plan_type, int nargs) { Oid *argtypes = (Oid *) palloc(nargs * sizeof(Oid)); switch (plan_type) { case PLAN_TYPE_RANGES_SELECT: /* 3 arguments */ case PLAN_TYPE_RANGES_PENDING: argtypes[0] = INT4OID; /* materialization_id */ argtypes[1] = INT8OID; argtypes[2] = INT8OID; break; case PLAN_TYPE_RANGES_DELETE: /* 1 argument1 */ argtypes[0] = TIDOID; /* ctid */ break; default: /* 2 arguments */ argtypes[0] = context->materialization_range.type; argtypes[1] = context->materialization_range.type; break; } return argtypes; } static MaterializationPlan * create_materialization_plan(MaterializationContext *context, MaterializationPlanType plan_type) { Assert(plan_type >= PLAN_TYPE_INSERT); Assert(plan_type < _MAX_MATERIALIZATION_PLAN_TYPES); MaterializationPlan *materialization = &materialization_plans[plan_type]; if (materialization->plan == NULL) { char *query = materialization->create_statement(context); Oid *argtypes = create_materialization_plan_argtypes(context, plan_type, materialization->nargs); elog(DEBUG2, "%s: %s", __func__, query); materialization->plan = SPI_prepare(query, materialization->nargs, argtypes); if (materialization->plan == NULL) elog(ERROR, "%s: SPI_prepare failed: %s", __func__, query); SPI_keepplan(materialization->plan); pfree(query); pfree(argtypes); } return materialization; } static void create_materialization_plan_args(MaterializationContext *context, MaterializationPlanType plan_type, Datum **values, char **nulls) { switch (plan_type) { case PLAN_TYPE_RANGES_SELECT: /* 3 arguments */ case PLAN_TYPE_RANGES_PENDING: { (*values)[0] = Int32GetDatum(context->cagg->data.mat_hypertable_id); (*values)[1] = Int64GetDatum(context->internal_materialization_range.start); (*values)[2] = Int64GetDatum(context->internal_materialization_range.end); (*nulls)[0] = false; (*nulls)[1] = false; (*nulls)[2] = false; break; } case PLAN_TYPE_RANGES_DELETE: /* 1 argument */ { (*values)[0] = ItemPointerGetDatum(context->tupleid); (*nulls)[0] = false; break; } default: /* 2 arguments */ { (*values)[0] = context->materialization_range.start; (*values)[1] = context->materialization_range.end; (*nulls)[0] = false; (*nulls)[1] = false; break; } } } static uint64 execute_materialization_plan(MaterializationContext *context, MaterializationPlanType plan_type) { MaterializationPlan *materialization = create_materialization_plan(context, plan_type); Datum *values = (Datum *) palloc(materialization->nargs * sizeof(Datum)); char *nulls = (char *) palloc(materialization->nargs * sizeof(char)); create_materialization_plan_args(context, plan_type, &values, &nulls); CatalogSecurityContext sec_ctx; if (materialization->catalog_security_context) ts_catalog_database_info_become_owner(ts_catalog_database_info_get(), &sec_ctx); int res = SPI_execute_plan(materialization->plan, values, nulls, materialization->read_only, 0); if (materialization->catalog_security_context) ts_catalog_restore_user(&sec_ctx); if (res < 0) { if (materialization->emit_error) materialization->emit_error(context); } if (materialization->emit_progress) materialization->emit_progress(context, SPI_processed); if (SPI_processed > 0 && plan_type == PLAN_TYPE_RANGES_SELECT) { bool isnull; Datum dat; Assert(SPI_processed == 1); /* ctid */ dat = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); context->tupleid = DatumGetItemPointer(dat); /* lowest_modified_value */ dat = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull); context->materialization_range.start = internal_to_time_value_or_infinite(DatumGetInt64(dat), context->materialization_range.type, NULL); /* greatest_modified_value */ dat = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull); context->materialization_range.end = internal_to_time_value_or_infinite(DatumGetInt64(dat), context->materialization_range.type, NULL); } pfree(values); pfree(nulls); return SPI_processed; } static void free_materialization_plan(MaterializationContext *context, MaterializationPlanType plan_type) { MaterializationPlan *materialization = &materialization_plans[plan_type]; if (materialization->plan != NULL) { SPI_freeplan(materialization->plan); materialization->plan = NULL; } } static void free_materialization_plans(MaterializationContext *context) { for (int plan_type = PLAN_TYPE_INSERT; plan_type < _MAX_MATERIALIZATION_PLAN_TYPES; plan_type++) { free_materialization_plan(context, plan_type); } } static void update_watermark(MaterializationContext *context) { int res; StringInfo command = makeStringInfo(); Oid types[] = { context->materialization_range.type }; Datum values[] = { context->materialization_range.start }; char nulls[] = { false }; appendStringInfo(command, "SELECT %s FROM %s.%s AS I " "WHERE I.%s >= $1 %s " "ORDER BY 1 DESC LIMIT 1;", quote_identifier(NameStr(*context->time_column_name)), quote_identifier(NameStr(*context->materialization_table.schema)), quote_identifier(NameStr(*context->materialization_table.name)), quote_identifier(NameStr(*context->time_column_name)), context->chunk_condition); elog(DEBUG2, "%s: %s", __func__, command->data); res = SPI_execute_with_args(command->data, 1, types, values, nulls, false /* read_only */, 0 /* count */); if (res < 0) elog(ERROR, "%s: could not get the last bucket of the materialized data", __func__); Ensure(SPI_gettypeid(SPI_tuptable->tupdesc, 1) == context->materialization_range.type, "partition types for result (%d) and dimension (%d) do not match", SPI_gettypeid(SPI_tuptable->tupdesc, 1), context->materialization_range.type); if (SPI_processed > 0) { bool isnull; Datum maxdat = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull); if (!isnull) { int64 watermark = ts_time_value_to_internal(maxdat, context->materialization_range.type); ts_cagg_watermark_update(context->mat_ht, watermark, isnull, false); } } } static void execute_materializations(MaterializationContext *context) { volatile uint64 rows_processed = 0; PG_TRY(); { while (execute_materialization_plan(context, PLAN_TYPE_RANGES_SELECT) > 0) { /* MERGE statement is supported only in the new format of CAggs and for non-compressed * hypertables */ if (ts_guc_enable_merge_on_cagg_refresh && ContinuousAggIsFinalized(context->cagg) && !TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(context->mat_ht)) { /* Fallback to INSERT materializations if there are no rows to change on it */ if (execute_materialization_plan(context, PLAN_TYPE_EXISTS) == 0) { elog(DEBUG2, "no rows to merge on materialization table \"%s.%s\", falling back to " "INSERT", NameStr(*context->materialization_table.schema), NameStr(*context->materialization_table.name)); rows_processed = execute_materialization_plan(context, PLAN_TYPE_INSERT); } else { rows_processed += execute_materialization_plan(context, PLAN_TYPE_MERGE); rows_processed += execute_materialization_plan(context, PLAN_TYPE_MERGE_DELETE); } } else { rows_processed += execute_materialization_plan(context, PLAN_TYPE_DELETE); rows_processed += execute_materialization_plan(context, PLAN_TYPE_INSERT); } /* Delete the invalidation entry */ rows_processed += execute_materialization_plan(context, PLAN_TYPE_RANGES_DELETE); } /* Free all cached plans */ free_materialization_plans(context); } PG_CATCH(); { /* Make sure all cached plans in the session be released before rethrowing the error */ free_materialization_plans(context); PG_RE_THROW(); } PG_END_TRY(); /* Get the max(time_dimension) of the materialized data */ if (rows_processed > 0) { update_watermark(context); } } ����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/materialize.h��������������������������������������������0000664�0000000�0000000�00000002173�15100345067�0023335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "common.h" #include "ts_catalog/continuous_agg.h" #include <fmgr.h> #include <nodes/pg_list.h> typedef struct SchemaAndName { Name schema; Name name; } SchemaAndName; /*********************** * Time ranges ***********************/ typedef struct TimeRange { Oid type; Datum start; Datum end; } TimeRange; typedef struct InternalTimeRange { Oid type; int64 start; /* inclusive */ int64 end; /* exclusive */ bool start_isnull; bool end_isnull; } InternalTimeRange; void continuous_agg_update_materialization(Hypertable *mat_ht, const ContinuousAgg *cagg, SchemaAndName partial_view, SchemaAndName materialization_table, const NameData *time_column_name, InternalTimeRange materialization_range, int32 chunk_id); bool continuous_agg_has_pending_materializations(const ContinuousAgg *cagg, InternalTimeRange materialization_range); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/options.c������������������������������������������������0000664�0000000�0000000�00000016270�15100345067�0022520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/namespace.h> #include <commands/view.h> #include <miscadmin.h> #include <nodes/makefuncs.h> #include <optimizer/optimizer.h> #include <rewrite/rewriteManip.h> #include <utils/builtins.h> #include "cache.h" #include "compression/create.h" #include "continuous_aggs/common.h" #include "continuous_aggs/create.h" #include "errors.h" #include "hypertable_cache.h" #include "options.h" #include "scan_iterator.h" #include "ts_catalog/continuous_agg.h" #include "with_clause/alter_table_with_clause.h" #include "with_clause/create_materialized_view_with_clause.h" static void cagg_update_materialized_only(ContinuousAgg *agg, bool materialized_only); static List *cagg_get_compression_params(ContinuousAgg *agg, Hypertable *mat_ht); static void cagg_alter_compression(ContinuousAgg *agg, Hypertable *mat_ht, List *compress_defelems); static void cagg_update_materialized_only(ContinuousAgg *agg, bool materialized_only) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, RowExclusiveLock, CurrentMemoryContext); iterator.ctx.index = catalog_get_index(ts_catalog_get(), CONTINUOUS_AGG, CONTINUOUS_AGG_PKEY); ts_scan_iterator_scan_key_init(&iterator, Anum_continuous_agg_pkey_mat_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(agg->data.mat_hypertable_id)); ts_scanner_foreach(&iterator) { TupleInfo *ti = ts_scan_iterator_tuple_info(&iterator); bool nulls[Natts_continuous_agg]; Datum values[Natts_continuous_agg]; bool doReplace[Natts_continuous_agg] = { false }; bool should_free; HeapTuple tuple = ts_scan_iterator_fetch_heap_tuple(&iterator, false, &should_free); HeapTuple new_tuple; TupleDesc tupdesc = ts_scan_iterator_tupledesc(&iterator); heap_deform_tuple(tuple, tupdesc, values, nulls); doReplace[AttrNumberGetAttrOffset(Anum_continuous_agg_materialize_only)] = true; values[AttrNumberGetAttrOffset(Anum_continuous_agg_materialize_only)] = BoolGetDatum(materialized_only); new_tuple = heap_modify_tuple(tuple, tupdesc, values, nulls, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); break; } ts_scan_iterator_close(&iterator); } /* get the compression parameters for cagg. The parameters are * derived from the cagg view definition. * Computes: * compress_segmentby = GROUP BY columns from cagg query * compress_orderby = time_bucket column from cagg query */ static List * cagg_get_compression_params(ContinuousAgg *agg, Hypertable *mat_ht) { List *defelems = NIL; const Dimension *mat_ht_dim = hyperspace_get_open_dimension(mat_ht->space, 0); const char *mat_ht_timecolname = quote_identifier(NameStr(mat_ht_dim->fd.column_name)); DefElem *ordby = makeDefElemExtended(EXTENSION_NAMESPACE, "compress_orderby", (Node *) makeString((char *) mat_ht_timecolname), DEFELEM_UNSPEC, -1); defelems = lappend(defelems, ordby); List *grp_colnames = cagg_find_groupingcols(agg, mat_ht); if (grp_colnames) { StringInfo info = makeStringInfo(); ListCell *lc; foreach (lc, grp_colnames) { char *grpcol = (char *) lfirst(lc); /* skip time dimension col if it appears in group-by list */ if (namestrcmp((Name) & (mat_ht_dim->fd.column_name), grpcol) == 0) continue; if (info->len > 0) appendStringInfoString(info, ","); appendStringInfoString(info, quote_identifier(grpcol)); } if (info->len > 0) { DefElem *segby; segby = makeDefElemExtended(EXTENSION_NAMESPACE, "compress_segmentby", (Node *) makeString(info->data), DEFELEM_UNSPEC, -1); defelems = lappend(defelems, segby); } } return defelems; } /* forwards compression related changes via an alter statement to the underlying HT */ static void cagg_alter_compression(ContinuousAgg *agg, Hypertable *mat_ht, List *compress_defelems) { Assert(mat_ht != NULL); WithClauseResult *with_clause_options = ts_alter_table_with_clause_parse(compress_defelems); if (with_clause_options[AlterTableFlagColumnstore].parsed) { List *default_compress_defelems = cagg_get_compression_params(agg, mat_ht); WithClauseResult *default_with_clause_options = ts_alter_table_with_clause_parse(default_compress_defelems); /* Merge defaults if there's any. */ for (int i = 0; i < AlterTableFlagsMax; i++) { if (with_clause_options[i].is_default && !default_with_clause_options[i].is_default) { with_clause_options[i] = default_with_clause_options[i]; elog(NOTICE, "defaulting %s to %s", with_clause_options[i].definition->arg_names[0], ts_with_clause_result_deparse_value(&with_clause_options[i])); } } } tsl_process_compress_table(mat_ht, with_clause_options); } void continuous_agg_update_options(ContinuousAgg *agg, WithClauseResult *with_clause_options) { if (!with_clause_options[CreateMaterializedViewFlagContinuous].is_default) elog(ERROR, "cannot disable continuous aggregates"); if (!with_clause_options[CreateMaterializedViewFlagMaterializedOnly].is_default) { bool materialized_only = DatumGetBool(with_clause_options[CreateMaterializedViewFlagMaterializedOnly].parsed); Cache *hcache = ts_hypertable_cache_pin(); Hypertable *mat_ht = ts_hypertable_cache_get_entry_by_id(hcache, agg->data.mat_hypertable_id); if (materialized_only == agg->data.materialized_only) { /* nothing changed, so just return */ ts_cache_release(&hcache); return; } Assert(mat_ht != NULL); cagg_flip_realtime_view_definition(agg, mat_ht); cagg_update_materialized_only(agg, materialized_only); ts_cache_release(&hcache); } if (!with_clause_options[CreateMaterializedViewFlagChunkTimeInterval].is_default) { Cache *hcache = ts_hypertable_cache_pin(); Hypertable *mat_ht = ts_hypertable_cache_get_entry_by_id(hcache, agg->data.mat_hypertable_id); int64 interval = interval_to_usec(DatumGetIntervalP( with_clause_options[CreateMaterializedViewFlagChunkTimeInterval].parsed)); Dimension *dim = ts_hyperspace_get_mutable_dimension(mat_ht->space, DIMENSION_TYPE_OPEN, 0); ts_dimension_set_chunk_interval(dim, interval); ts_cache_release(&hcache); } List *compression_options = ts_continuous_agg_get_compression_defelems(with_clause_options); if (list_length(compression_options) > 0) { Cache *hcache = ts_hypertable_cache_pin(); Hypertable *mat_ht = ts_hypertable_cache_get_entry_by_id(hcache, agg->data.mat_hypertable_id); Assert(mat_ht != NULL); cagg_alter_compression(agg, mat_ht, compression_options); ts_cache_release(&hcache); } if (!with_clause_options[CreateMaterializedViewFlagCreateGroupIndexes].is_default) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter create_group_indexes option for continuous aggregates"))); } if (!with_clause_options[CreateMaterializedViewFlagFinalized].is_default) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot alter finalized option for continuous aggregates"))); } } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/options.h������������������������������������������������0000664�0000000�0000000�00000000653�15100345067�0022523�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "ts_catalog/continuous_agg.h" #include "with_clause/with_clause_parser.h" extern void continuous_agg_update_options(ContinuousAgg *cagg, WithClauseResult *with_clause_options); �������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/planner.c������������������������������������������������0000664�0000000�0000000�00000036615�15100345067�0022471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/nodes.h> #include <nodes/pg_list.h> #include <parser/parse_func.h> #include "continuous_aggs/common.h" #include "planner.h" #include "ts_catalog/continuous_aggs_watermark.h" /* * The watermark function of a CAgg query is embedded into further functions. It * has the following structure: * * 1. a coalesce expression * 2. an optional to timestamp conversion function (date, timestamp, timestamptz) * 3. the actual watermark function * * For example: * ... COALESCE(to_timestamp(cagg_watermark(59)), XXX) ... * ... COALESCE(cagg_watermark(59), XXX) ... * * We use the following data structure while walking to the query to analyze the query * and collect references to the needed functions. The data structure contains: * * (a) values (e.g., function Oids) which are needed to analyze the query * (b) values that are changed during walking through the query * (e.g., references to parent functions) * (c) result data like the watermark functions and their parent functions */ typedef struct { /* (a) Values initialized after creating the context */ List *to_timestamp_func_oids; // List of Oids of the timestamp conversion functions /* (b) Values changed while walking through the query */ CoalesceExpr *parent_coalesce_expr; // the current parent coalesce_expr FuncExpr *parent_to_timestamp_func; // the current parent timestamp function /* (c) Result values */ List *watermark_parent_functions; // List of parent functions of a watermark (1) and (2) List *watermark_functions; // List of watermark functions (3) List *relids; // List of used relids by the query bool valid_query; // Is the query valid a valid CAgg query or not } ConstifyWatermarkContext; /* Oid of the watermark function. It can be stored into a static variable because it will not * change over the lifetime of a backend session, so we can lookup it only once. */ static Oid watermark_function_oid = InvalidOid; /* * Walk through the elements of the query and detect the watermark functions and their * parent functions. */ static bool constify_cagg_watermark_walker(Node *node, ConstifyWatermarkContext *context) { if (node == NULL) return false; if (IsA(node, FuncExpr)) { FuncExpr *funcExpr = castNode(FuncExpr, node); /* Handle watermark function */ if (watermark_function_oid == funcExpr->funcid) { /* The watermark function takes exactly one argument */ Assert(list_length(funcExpr->args) == 1); /* No coalesce expression found so far or function parameter is not constant, we are not * interested in this expression */ if (context->parent_coalesce_expr == NULL || !IsA(linitial(funcExpr->args), Const) || (castNode(Const, linitial(funcExpr->args))->constisnull)) { context->valid_query = false; return false; } context->watermark_functions = lappend(context->watermark_functions, funcExpr); /* Only on time based hypertables, we have a to_timestamp function */ if (context->parent_to_timestamp_func != NULL) { /* to_timestamp functions take only one parameter. This should be a reference to our * function */ Assert(linitial(context->parent_to_timestamp_func->args) == node); context->watermark_parent_functions = lappend(context->watermark_parent_functions, context->parent_to_timestamp_func); } else { /* For non int64 partitioned tables, the watermark function is wrapped into a cast * for example: COALESCE((_timescaledb_functions.cagg_watermark(11))::integer, * '-2147483648'::integer)) */ Node *coalesce_arg = linitial(context->parent_coalesce_expr->args); if (coalesce_arg != node) { /* Check if the watermark function is wrapped into a cast function */ if (!IsA(coalesce_arg, FuncExpr) || ((FuncExpr *) coalesce_arg)->args == NIL || linitial(((FuncExpr *) coalesce_arg)->args) != node) { context->valid_query = false; return false; } context->watermark_parent_functions = lappend(context->watermark_parent_functions, coalesce_arg); } else { context->watermark_parent_functions = lappend(context->watermark_parent_functions, context->parent_coalesce_expr); } } } /* Capture the timestamp conversion function */ if (list_member_oid(context->to_timestamp_func_oids, funcExpr->funcid)) { FuncExpr *old_func_expr = context->parent_to_timestamp_func; context->parent_to_timestamp_func = funcExpr; bool result = expression_tree_walker(node, constify_cagg_watermark_walker, context); context->parent_to_timestamp_func = old_func_expr; return result; } } else if (IsA(node, Query)) { /* Recurse into subselects */ Query *query = castNode(Query, node); return query_tree_walker(query, constify_cagg_watermark_walker, context, QTW_EXAMINE_RTES_BEFORE); } else if (IsA(node, CoalesceExpr)) { /* Capture the CoalesceExpr */ CoalesceExpr *parent_coalesce_expr = context->parent_coalesce_expr; context->parent_coalesce_expr = castNode(CoalesceExpr, node); bool result = expression_tree_walker(node, constify_cagg_watermark_walker, context); context->parent_coalesce_expr = parent_coalesce_expr; return result; } else if (IsA(node, RangeTblEntry)) { /* Collect the Oid of the used range tables */ RangeTblEntry *rte = (RangeTblEntry *) node; if (rte->rtekind == RTE_RELATION) { context->relids = list_append_unique_oid(context->relids, rte->relid); } /* allow range_table_walker to continue */ return false; } return expression_tree_walker(node, constify_cagg_watermark_walker, context); } /* * The entry of the watermark HTAB. */ typedef struct WatermarkConstEntry { int32 key; Const *watermark_constant; } WatermarkConstEntry; /* The query can contain multiple watermarks (i.e., two hierarchal real-time CAggs) * We maintain a hash map (hypertable id -> constant) to ensure we use the same constant * for the same watermark across the while query. */ static HTAB *pg_nodiscard init_watermark_map() { struct HASHCTL hctl = { .keysize = sizeof(int32), .entrysize = sizeof(WatermarkConstEntry), .hcxt = CurrentMemoryContext, }; /* Use 4 initial elements to have enough space for normal and hierarchical CAggs */ return hash_create("Watermark const values", 4, &hctl, HASH_ELEM | HASH_CONTEXT | HASH_BLOBS); } /* * Get a constant value for our watermark function. The constant is cached * in a hash map to ensure we use the same constant for invocations of the * watermark function with the same parameter across the whole query. */ static Const * get_watermark_const(HTAB *watermarks, int32 watermark_hypertable_id, List *range_table_oids) { bool found; WatermarkConstEntry *watermark_const = hash_search(watermarks, &watermark_hypertable_id, HASH_ENTER, &found); if (!found) { /* * Check that the argument of the watermark function is also a range table of the query. We * only constify the value when this condition is true. Only in this case, the query will be * removed from the query cache by PostgreSQL when an invalidation for the watermark * hypertable is processed (see CacheInvalidateRelcacheByRelid). */ Oid ht_relid = ts_hypertable_id_to_relid(watermark_hypertable_id, false); /* Given table is not a part of our range tables */ if (!list_member_oid(range_table_oids, ht_relid)) { watermark_const->watermark_constant = NULL; return NULL; } /* Not found, create a new constant */ int64 watermark = ts_cagg_watermark_get(watermark_hypertable_id); Const *const_watermark = makeConst(INT8OID, -1, InvalidOid, sizeof(int64), Int64GetDatum(watermark), false, FLOAT8PASSBYVAL); watermark_const->watermark_constant = const_watermark; } return watermark_const->watermark_constant; } /* * Replace the collected references to the watermark function in the context variable * with constant values. */ static void replace_watermark_with_const(ConstifyWatermarkContext *context) { Assert(context != NULL); Assert(context->valid_query); /* We need to have at least one watermark value */ if (list_length(context->watermark_functions) < 1) return; HTAB *watermarks = init_watermark_map(); /* The list of watermark function should have the same length as the parent functions. In * other words, each watermark function should have exactly one parent function. */ Assert(list_length(context->watermark_parent_functions) == list_length(context->watermark_functions)); /* Iterate over the function parents and the actual watermark functions. Get a * const value for each function and replace the reference to the watermark function * in the function parent. */ ListCell *parent_lc, *watermark_lc; forboth (parent_lc, context->watermark_parent_functions, watermark_lc, context->watermark_functions) { FuncExpr *watermark_function = lfirst(watermark_lc); Assert(watermark_function_oid == watermark_function->funcid); Const *arg = (Const *) linitial(watermark_function->args); int32 watermark_hypertable_id = DatumGetInt32(arg->constvalue); Const *watermark_const = get_watermark_const(watermarks, watermark_hypertable_id, context->relids); /* No constant created, it means the hypertable id used by the watermark function is not a * range table and no invalidations would be processed. So, not replacing the function * invocation. */ if (watermark_const == NULL) continue; /* Replace cagg_watermark FuncExpr node by a Const node */ if (IsA(lfirst(parent_lc), FuncExpr)) { FuncExpr *parent_func_expr = castNode(FuncExpr, lfirst(parent_lc)); linitial(parent_func_expr->args) = (Node *) watermark_const; } else { /* Check that the assumed parent function is our parent function */ CoalesceExpr *parent_coalesce_expr = castNode(CoalesceExpr, lfirst(parent_lc)); linitial(parent_coalesce_expr->args) = (Node *) watermark_const; } } /* Clean up the hash map */ hash_destroy(watermarks); } /* * Constify all references to the CAgg watermark function if the query is a union query on a CAgg */ void constify_cagg_watermark(Query *parse) { if (parse == NULL) return; /* process only SELECT queries */ if (parse->commandType != CMD_SELECT) return; Node *node = (Node *) parse; ConstifyWatermarkContext context = { 0 }; context.valid_query = true; if (!OidIsValid(watermark_function_oid)) { watermark_function_oid = get_watermark_function_oid(); Ensure(OidIsValid(watermark_function_oid), "unable to determine watermark function Oid"); } /* Get Oid of all used timestamp converter functions. * * The watermark function can be invoked by a timestamp conversion function. * For example: to_timestamp(cagg_watermark(XX)). We collect the Oid of all these * converter functions in the list to_timestamp_func_oids. */ context.to_timestamp_func_oids = NIL; context.to_timestamp_func_oids = lappend_oid(context.to_timestamp_func_oids, cagg_get_boundary_converter_funcoid(DATEOID)); context.to_timestamp_func_oids = lappend_oid(context.to_timestamp_func_oids, cagg_get_boundary_converter_funcoid(TIMESTAMPOID)); context.to_timestamp_func_oids = lappend_oid(context.to_timestamp_func_oids, cagg_get_boundary_converter_funcoid(TIMESTAMPTZOID)); /* Walk through the query and collect function information */ constify_cagg_watermark_walker(node, &context); /* Replace watermark functions with const value if the query might belong to the CAgg query */ if (context.valid_query) replace_watermark_with_const(&context); } /* * Push down ORDER BY and LIMIT into subqueries of UNION for realtime * continuous aggregates when sorting by time. * * This is only enabled on PG16 and above because the internal structure is different * in previous versions. */ void cagg_sort_pushdown(Query *parse, int *cursor_opts) { ListCell *lc; /* We dont optimize aggregations on top of caggs for now. */ if (parse->groupClause) return; /* Nothing to do if we have no valid sort clause */ if (list_length(parse->rtable) != 1 || list_length(parse->sortClause) != 1 || !OidIsValid(linitial_node(SortGroupClause, parse->sortClause)->sortop)) return; Cache *cache = ts_hypertable_cache_pin(); foreach (lc, parse->rtable) { RangeTblEntry *rte = lfirst(lc); /* * Realtime cagg view will have 2 rtable entries, one for the materialized data and one for * the not yet materialized data. */ if (rte->rtekind != RTE_SUBQUERY || rte->relkind != RELKIND_VIEW || list_length(rte->subquery->rtable) != 2) continue; ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(rte->relid); /* * This optimization only applies to realtime caggs. */ if (!cagg || !cagg->data.finalized || cagg->data.materialized_only) continue; Hypertable *ht = ts_hypertable_cache_get_entry_by_id(cache, cagg->data.mat_hypertable_id); Dimension const *dim = hyperspace_get_open_dimension(ht->space, 0); /* We should only encounter hypertables with an open dimension */ if (!dim) continue; SortGroupClause *sort = linitial_node(SortGroupClause, parse->sortClause); TargetEntry *tle = get_sortgroupref_tle(sort->tleSortGroupRef, parse->targetList); /* * We only pushdown ORDER BY when it's single column * ORDER BY on the time column. */ AttrNumber time_col = dim->column_attno; if (!IsA(tle->expr, Var) || castNode(Var, tle->expr)->varattno != time_col) continue; RangeTblEntry *mat_rte = linitial_node(RangeTblEntry, rte->subquery->rtable); RangeTblEntry *rt_rte = lsecond_node(RangeTblEntry, rte->subquery->rtable); mat_rte->subquery->sortClause = list_copy(parse->sortClause); rt_rte->subquery->sortClause = list_copy(parse->sortClause); TargetEntry *mat_tle = list_nth(mat_rte->subquery->targetList, time_col - 1); TargetEntry *rt_tle = list_nth(rt_rte->subquery->targetList, time_col - 1); SortGroupClause *cagg_group = linitial(rt_rte->subquery->groupClause); cagg_group = list_nth(rt_rte->subquery->groupClause, rt_tle->ressortgroupref - 1); cagg_group->sortop = sort->sortop; cagg_group->nulls_first = sort->nulls_first; #if PG18_GE /* Track sort order * https://github.com/postgres/postgres/commit/0d2aa4d4 */ cagg_group->reverse_sort = sort->reverse_sort; #endif linitial_node(SortGroupClause, rt_rte->subquery->sortClause)->tleSortGroupRef = rt_tle->ressortgroupref; mat_tle->ressortgroupref = linitial_node(SortGroupClause, mat_rte->subquery->sortClause)->tleSortGroupRef; Oid placeholder; CompareType strategy; get_ordering_op_properties(sort->sortop, &placeholder, &placeholder, &strategy); /* * If this is DESC order and the sortop is the commutator of the cagg_group sortop, * we can align the sortop of the cagg_group with the sortop of the sort clause, which * will allow us to have the GroupAggregate node to produce the correct order and avoid * having to resort. */ if (strategy == BTGreaterStrategyNumber) { rte->subquery->rtable = list_make2(rt_rte, mat_rte); } /* * We have to prevent parallelism when we do this optimization because * the subplans of the Append have to be processed sequentially. */ *cursor_opts = *cursor_opts & ~CURSOR_OPT_PARALLEL_OK; parse->sortClause = NIL; rte->subquery->sortClause = NIL; } ts_cache_release(&cache); } �������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/planner.h������������������������������������������������0000664�0000000�0000000�00000000660�15100345067�0022465�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifndef TIMESCALEDB_TSL_CONTINUOUS_AGGS_PLANNER_H #define TIMESCALEDB_TSL_CONTINUOUS_AGGS_PLANNER_H #include "planner/planner.h" void constify_cagg_watermark(Query *parse); void cagg_sort_pushdown(Query *parse, int *cursor_opts); #endif ��������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/refresh.c������������������������������������������������0000664�0000000�0000000�00000134712�15100345067�0022465�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <executor/spi.h> #include <fmgr.h> #include <miscadmin.h> #include <storage/lmgr.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/fmgrprotos.h> #include <utils/guc.h> #include <utils/lsyscache.h> #include <utils/snapmgr.h> #include "bgw_policy/policies_v2.h" #include "continuous_aggs/invalidation_multi.h" #include "debug_point.h" #include "dimension.h" #include "dimension_slice.h" #include "guc.h" #include "hypertable.h" #include "invalidation.h" #include "invalidation_threshold.h" #include "jsonb_utils.h" #include "materialize.h" #include "process_utility.h" #include "refresh.h" #include "time_bucket.h" #include "time_utils.h" #include "ts_catalog/catalog.h" #include "ts_catalog/continuous_agg.h" #define CAGG_REFRESH_LOG_LEVEL \ (context.callctx == CAGG_REFRESH_POLICY || context.callctx == CAGG_REFRESH_POLICY_BATCHED ? \ LOG : \ DEBUG1) typedef struct ContinuousAggRefreshState { ContinuousAgg cagg; Hypertable *cagg_ht; InternalTimeRange refresh_window; SchemaAndName partial_view; bool bucketing_refresh_window; } ContinuousAggRefreshState; static Hypertable *cagg_get_hypertable_or_fail(int32 hypertable_id); static InternalTimeRange get_largest_bucketed_window(Oid timetype, int64 bucket_width); static InternalTimeRange compute_inscribed_bucketed_refresh_window(const ContinuousAgg *cagg, const InternalTimeRange *const refresh_window, const int64 bucket_width); static void continuous_agg_refresh_init(ContinuousAggRefreshState *refresh, const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, bool bucketing_refresh_window); static void continuous_agg_refresh_execute(const ContinuousAggRefreshState *refresh, const InternalTimeRange *bucketed_refresh_window, const int32 chunk_id); static void log_refresh_window(int elevel, const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, ContinuousAggRefreshContext context); static void continuous_agg_refresh_execute_wrapper(const InternalTimeRange *bucketed_refresh_window, const ContinuousAggRefreshContext context, const long iteration, void *arg1_refresh, void *arg2_chunk_id); static void continuous_agg_refresh_with_window(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const InvalidationStore *invalidations, int32 chunk_id, const ContinuousAggRefreshContext context, bool bucketing_refresh_window); static void emit_up_to_date_notice(const ContinuousAgg *cagg, const ContinuousAggRefreshContext context); static bool process_cagg_invalidations_and_refresh(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const ContinuousAggRefreshContext context, int32 chunk_id, bool bucketing_refresh_window, bool force); static void fill_bucket_offset_origin(const ContinuousAgg *cagg, const InternalTimeRange *const refresh_window, NullableDatum *offset, NullableDatum *origin); /* * Get all hypertables that are using WAL-invalidations. */ static List * get_all_wal_using_hypertables(void) { ScanIterator iterator = ts_scan_iterator_create(CONTINUOUS_AGG, AccessShareLock, CurrentMemoryContext); List *hypertables = NIL; /* Collect OID of all tables using continuous aggregates */ ts_scanner_foreach(&iterator) { bool isnull; Datum datum = slot_getattr(ts_scan_iterator_slot(&iterator), Anum_continuous_agg_raw_hypertable_id, &isnull); Assert(!isnull); int32 hypertable_id = DatumGetInt32(datum); hypertables = list_append_unique_int(hypertables, hypertable_id); } ts_scan_iterator_close(&iterator); return hypertables; } static Hypertable * cagg_get_hypertable_or_fail(int32 hypertable_id) { Hypertable *ht = ts_hypertable_get_by_id(hypertable_id); if (NULL == ht) ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("invalid continuous aggregate state"), errdetail("A continuous aggregate references a hypertable that does not exist."))); return ht; } /* * Compute the largest possible bucketed window given the time type and * internal restrictions. * * The largest bucketed window is governed by restrictions set by the type and * internal, TimescaleDB-specific legacy details (see get_max_window above for * further explanation). */ static InternalTimeRange get_largest_bucketed_window(Oid timetype, int64 bucket_width) { InternalTimeRange maxwindow = { .type = timetype, .start = ts_time_get_min(timetype), .end = ts_time_get_end_or_max(timetype), }; InternalTimeRange maxbuckets = { .type = timetype, }; /* For the MIN value, the corresponding bucket either falls on the exact * MIN or it will be below it. Therefore, we add (bucket_width - 1) to * move to the next bucket to be within the allowed range. */ maxwindow.start = ts_time_saturating_add(maxwindow.start, bucket_width - 1, timetype); maxbuckets.start = ts_time_bucket_by_type(bucket_width, maxwindow.start, timetype); maxbuckets.end = ts_time_get_end_or_max(timetype); return maxbuckets; } /* * Adjust the refresh window to align with inscribed buckets, so it includes buckets, which are * fully covered by the refresh window. * * Bucketing refresh window is necessary for a continuous aggregate refresh, which can refresh only * entire buckets. The result of the function is a bucketed window, where its start is at the start * of the first bucket, which is fully inside the refresh window, and its end is at the end of the * last fully covered bucket. * * Example1, the window needs to shrink: * [---------) - given refresh window * .|....|....|....|. - buckets * [----) - inscribed bucketed window * * Example2, the window is already aligned: * [----) - given refresh window * .|....|....|....|. - buckets * [----) - inscribed bucketed window * * This function is called for the continuous aggregate policy and manual refresh. In such case * excluding buckets, which are not fully covered by the refresh window, avoids refreshing a bucket, * where part of its data were dropped by a retention policy. See #2198 for details. */ static InternalTimeRange compute_inscribed_bucketed_refresh_window(const ContinuousAgg *cagg, const InternalTimeRange *const refresh_window, const int64 bucket_width) { Assert(cagg != NULL); Assert(cagg->bucket_function != NULL); NullableDatum NULL_DATUM = INIT_NULL_DATUM; InternalTimeRange result = *refresh_window; InternalTimeRange largest_bucketed_window = get_largest_bucketed_window(refresh_window->type, bucket_width); if (refresh_window->start <= largest_bucketed_window.start) { result.start = largest_bucketed_window.start; } else { /* The start time needs to be aligned with the first fully enclosed bucket. * So the original window start is moved to next bucket, except if the start is * already aligned with a bucket, thus 1 is subtracted to avoid moving into next * bucket in the aligned case. */ int64 included_bucket = ts_time_saturating_add(refresh_window->start, bucket_width - 1, refresh_window->type); /* Get the start of the included bucket. */ result.start = ts_time_bucket_by_type_extended(bucket_width, included_bucket, refresh_window->type, NULL_DATUM, NULL_DATUM); } if (refresh_window->end >= largest_bucketed_window.end) { result.end = largest_bucketed_window.end; } else { /* The window is reduced to the beginning of the bucket, which contains the exclusive * end of the refresh window. */ result.end = ts_time_bucket_by_type_extended(bucket_width, refresh_window->end, refresh_window->type, NULL_DATUM, NULL_DATUM); } return result; } /* * Get the offset as Datum value of an integer based bucket */ static Datum int_bucket_offset_to_datum(Oid type, const ContinuousAggBucketFunction *bucket_function) { Assert(bucket_function->bucket_time_based == false); switch (type) { case INT2OID: return Int16GetDatum(bucket_function->bucket_integer_offset); case INT4OID: return Int32GetDatum(bucket_function->bucket_integer_offset); case INT8OID: return Int64GetDatum(bucket_function->bucket_integer_offset); default: elog(ERROR, "invalid integer time_bucket type \"%s\"", format_type_be(type)); pg_unreachable(); } } /* * Get a NullableDatum for offset and origin based on the CAgg information */ static void fill_bucket_offset_origin(const ContinuousAgg *cagg, const InternalTimeRange *const refresh_window, NullableDatum *offset, NullableDatum *origin) { Assert(cagg != NULL); Assert(offset != NULL); Assert(origin != NULL); Assert(offset->isnull); Assert(origin->isnull); if (cagg->bucket_function->bucket_time_based) { if (cagg->bucket_function->bucket_time_offset != NULL) { offset->isnull = false; offset->value = IntervalPGetDatum(cagg->bucket_function->bucket_time_offset); } if (TIMESTAMP_NOT_FINITE(cagg->bucket_function->bucket_time_origin) == false) { origin->isnull = false; if (refresh_window->type == DATEOID) { /* Date was converted into a timestamp in process_additional_timebucket_parameter(), * build a Date again */ origin->value = DirectFunctionCall1(timestamp_date, TimestampGetDatum( cagg->bucket_function->bucket_time_origin)); } else { origin->value = TimestampGetDatum(cagg->bucket_function->bucket_time_origin); } } } else { if (cagg->bucket_function->bucket_integer_offset != 0) { offset->isnull = false; offset->value = int_bucket_offset_to_datum(refresh_window->type, cagg->bucket_function); } } } /* * Adjust the refresh window to align with circumscribed buckets, so it includes buckets, which * fully cover the refresh window. * * Bucketing refresh window is necessary for a continuous aggregate refresh, which can refresh only * entire buckets. The result of the function is a bucketed window, where its start is at the start * of a bucket, which contains the start of the refresh window, and its end is at the end of a * bucket, which contains the end of the refresh window. * * Example1, the window needs to expand: * [---------) - given refresh window * .|....|....|....|. - buckets * [--------------) - circumscribed bucketed window * * Example2, the window is already aligned: * [----) - given refresh window * .|....|....|....|. - buckets * [----) - inscribed bucketed window * * This function is called for an invalidation window before refreshing it and after the * invalidation window was adjusted to be fully inside a refresh window. In the case of a * continuous aggregate policy or manual refresh, the refresh window is the inscribed bucketed * window. * * The circumscribed behaviour is also used for a refresh on drop, when the refresh is called during * dropping chunks manually or as part of retention policy. */ InternalTimeRange compute_circumscribed_bucketed_refresh_window(const ContinuousAgg *cagg, const InternalTimeRange *const refresh_window, const ContinuousAggBucketFunction *bucket_function) { Assert(cagg != NULL); Assert(cagg->bucket_function != NULL); if (bucket_function->bucket_fixed_interval == false) { InternalTimeRange result = *refresh_window; ts_compute_circumscribed_bucketed_refresh_window_variable(&result.start, &result.end, bucket_function); return result; } /* Interval is fixed */ int64 bucket_width = ts_continuous_agg_fixed_bucket_width(bucket_function); Assert(bucket_width > 0); InternalTimeRange result = *refresh_window; InternalTimeRange largest_bucketed_window = get_largest_bucketed_window(refresh_window->type, bucket_width); /* Get offset and origin for bucket function */ NullableDatum offset = INIT_NULL_DATUM; NullableDatum origin = INIT_NULL_DATUM; fill_bucket_offset_origin(cagg, refresh_window, &offset, &origin); /* Defined offset and origin in one function is not supported */ Assert(offset.isnull == true || origin.isnull == true); if (refresh_window->start <= largest_bucketed_window.start) { result.start = largest_bucketed_window.start; } else { /* For alignment with a bucket, which includes the start of the refresh window, we just * need to get start of the bucket. */ result.start = ts_time_bucket_by_type_extended(bucket_width, refresh_window->start, refresh_window->type, offset, origin); } if (refresh_window->end >= largest_bucketed_window.end) { result.end = largest_bucketed_window.end; } else { int64 exclusive_end; int64 bucketed_end; Assert(refresh_window->end > result.start); /* The end of the window is non-inclusive so subtract one before * bucketing in case we're already at the end of the bucket (we don't * want to add an extra bucket). */ exclusive_end = ts_time_saturating_sub(refresh_window->end, 1, refresh_window->type); bucketed_end = ts_time_bucket_by_type_extended(bucket_width, exclusive_end, refresh_window->type, offset, origin); /* We get the time value for the start of the bucket, so need to add * bucket_width to get the end of it. */ result.end = ts_time_saturating_add(bucketed_end, bucket_width, refresh_window->type); } return result; } /* * Initialize the refresh state for a continuous aggregate. * * The state holds information for executing a refresh of a continuous aggregate. */ static void continuous_agg_refresh_init(ContinuousAggRefreshState *refresh, const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, bool bucketing_refresh_window) { MemSet(refresh, 0, sizeof(*refresh)); refresh->cagg = *cagg; refresh->cagg_ht = cagg_get_hypertable_or_fail(cagg->data.mat_hypertable_id); refresh->refresh_window = *refresh_window; refresh->bucketing_refresh_window = bucketing_refresh_window; refresh->partial_view.schema = &refresh->cagg.data.partial_view_schema; refresh->partial_view.name = &refresh->cagg.data.partial_view_name; } /* * Execute a refresh. * * The refresh will materialize the area given by the refresh window in the * refresh state. */ static void continuous_agg_refresh_execute(const ContinuousAggRefreshState *refresh, const InternalTimeRange *bucketed_refresh_window, const int32 chunk_id) { SchemaAndName cagg_hypertable_name = { .schema = &refresh->cagg_ht->fd.schema_name, .name = &refresh->cagg_ht->fd.table_name, }; const Dimension *time_dim = hyperspace_get_open_dimension(refresh->cagg_ht->space, 0); Assert(time_dim != NULL); continuous_agg_update_materialization(refresh->cagg_ht, &refresh->cagg, refresh->partial_view, cagg_hypertable_name, &time_dim->fd.column_name, *bucketed_refresh_window, chunk_id); } static void log_refresh_window(int elevel, const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, ContinuousAggRefreshContext context) { const char *msg = "continuous aggregate refresh (individual invalidation) on"; if (context.callctx == CAGG_REFRESH_POLICY_BATCHED) elog(elevel, "%s \"%s\" in window [ %s, %s ] (batch %d of %d)", msg, NameStr(cagg->data.user_view_name), ts_internal_to_time_string(refresh_window->start, refresh_window->type), ts_internal_to_time_string(refresh_window->end, refresh_window->type), context.processing_batch, context.number_of_batches); else elog(elevel, "%s \"%s\" in window [ %s, %s ]", msg, NameStr(cagg->data.user_view_name), ts_internal_to_time_string(refresh_window->start, refresh_window->type), ts_internal_to_time_string(refresh_window->end, refresh_window->type)); } typedef void (*scan_refresh_ranges_funct_t)(const InternalTimeRange *bucketed_refresh_window, const ContinuousAggRefreshContext context, const long iteration, /* 0 is first range */ void *arg1, void *arg2); static void continuous_agg_refresh_execute_wrapper(const InternalTimeRange *bucketed_refresh_window, const ContinuousAggRefreshContext context, const long iteration, void *arg1_refresh, void *arg2_chunk_id) { const ContinuousAggRefreshState *refresh = (const ContinuousAggRefreshState *) arg1_refresh; const int32 chunk_id = *(const int32 *) arg2_chunk_id; (void) iteration; log_refresh_window(CAGG_REFRESH_LOG_LEVEL, &refresh->cagg, bucketed_refresh_window, context); continuous_agg_refresh_execute(refresh, bucketed_refresh_window, chunk_id); } static long continuous_agg_scan_refresh_window_ranges(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const InvalidationStore *invalidations, const ContinuousAggRefreshContext context, scan_refresh_ranges_funct_t exec_func, void *func_arg1, void *func_arg2) { TupleTableSlot *slot; long count = 0; ContinuousAggRefreshState *refresh = (ContinuousAggRefreshState *) func_arg1; slot = MakeSingleTupleTableSlot(invalidations->tupdesc, &TTSOpsMinimalTuple); while (tuplestore_gettupleslot(invalidations->tupstore, true /* forward */, false /* copy */, slot)) { bool isnull; Datum start = slot_getattr( slot, Anum_continuous_aggs_materialization_invalidation_log_lowest_modified_value, &isnull); Datum end = slot_getattr( slot, Anum_continuous_aggs_materialization_invalidation_log_greatest_modified_value, &isnull); InternalTimeRange invalidation = { .type = refresh_window->type, .start = DatumGetInt64(start), /* Invalidations are inclusive at the end, while refresh windows * aren't, so add one to the end of the invalidated region */ .end = ts_time_saturating_add(DatumGetInt64(end), 1, refresh_window->type), }; InternalTimeRange bucketed_refresh_window = { .type = invalidation.type, .start = invalidation.start, .end = invalidation.end, }; if (refresh->bucketing_refresh_window) { bucketed_refresh_window = compute_circumscribed_bucketed_refresh_window(cagg, &invalidation, cagg->bucket_function); } (*exec_func)(&bucketed_refresh_window, context, count, func_arg1, func_arg2); count++; } ExecDropSingleTupleTableSlot(slot); return count; } /* * Execute refreshes based on the processed invalidations. * * The given refresh window covers a set of buckets, some of which are * out-of-date (invalid) and some which are up-to-date (valid). Invalid * buckets that are adjacent form larger ranges, as shown below. * * Refresh window: [-----------------------------------------) * Invalid ranges: [-----] [-] [--] [-] [---] * Merged range: [---------------------------) * * The maximum number of individual (non-mergeable) ranges are * #buckets_in_window/2 (i.e., every other bucket is invalid). * * Since it might not be efficient to materialize a lot buckets separately * when there are many invalid (non-adjecent) buckets/ranges, we put a limit * on the number of individual materializations we do. This limit is * determined by the MATERIALIZATIONS_PER_REFRESH_WINDOW setting. * * Thus, if the refresh window covers a large number of buckets, but only a * few of them are invalid, it is likely beneficial to materialized these * separately to avoid materializing a lot of buckets that are already * up-to-date. But if the number of invalid buckets/ranges go above the * threshold, we materialize all of them in one go using the "merged range", * as illustrated above. */ static void continuous_agg_refresh_with_window(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const InvalidationStore *invalidations, int32 chunk_id, const ContinuousAggRefreshContext context, bool bucketing_refresh_window) { ContinuousAggRefreshState refresh; continuous_agg_refresh_init(&refresh, cagg, refresh_window, bucketing_refresh_window); /* * If we're refreshing a finalized CAgg then we should force * the `chunk_id` to be `INVALID_CHUNK_ID` because this column * does not exist anymore in the materialization hypertable. * * The underlying function `spi_update_materialization` that * actually will DELETE and INSERT data into the materialization * hypertable is responsible for check if the `chunk_id` is valid * and then use it or not during the refresh. */ if (ContinuousAggIsFinalized(cagg)) chunk_id = INVALID_CHUNK_ID; long count pg_attribute_unused(); count = continuous_agg_scan_refresh_window_ranges(cagg, refresh_window, invalidations, context, continuous_agg_refresh_execute_wrapper, (void *) &refresh /* arg1 */, (void *) &chunk_id /* arg2 */); Assert(count); } #define REFRESH_FUNCTION_NAME "refresh_continuous_aggregate()" /* * Refresh a continuous aggregate across the given window. */ Datum continuous_agg_refresh(PG_FUNCTION_ARGS) { Oid cagg_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); bool force = PG_ARGISNULL(3) ? false : PG_GETARG_BOOL(3); Jsonb *options = PG_ARGISNULL(4) ? NULL : PG_GETARG_JSONB_P(4); bool process_hypertable_invalidations = true; ContinuousAgg *cagg; InternalTimeRange refresh_window = { .type = InvalidOid, }; ts_feature_flag_check(FEATURE_CAGG); if (options) { bool found; bool value = ts_jsonb_get_bool_field(options, POL_REFRESH_CONF_KEY_PROCESS_HYPERTABLE_INVALIDATIONS, &found); process_hypertable_invalidations = !found || value; } cagg = cagg_get_by_relid_or_fail(cagg_relid); refresh_window.type = cagg->partition_type; if (!PG_ARGISNULL(1)) refresh_window.start = ts_time_value_from_arg(PG_GETARG_DATUM(1), get_fn_expr_argtype(fcinfo->flinfo, 1), refresh_window.type, true); else /* get min time for a cagg depending of the primary partition type */ refresh_window.start = cagg_get_time_min(cagg); if (!PG_ARGISNULL(2)) refresh_window.end = ts_time_value_from_arg(PG_GETARG_DATUM(2), get_fn_expr_argtype(fcinfo->flinfo, 2), refresh_window.type, true); else refresh_window.end = ts_time_get_noend_or_max(refresh_window.type); ContinuousAggRefreshContext context = { .callctx = CAGG_REFRESH_WINDOW }; continuous_agg_refresh_internal(cagg, &refresh_window, context, PG_ARGISNULL(1), PG_ARGISNULL(2), true, force, process_hypertable_invalidations, false /*extend_last_bucket*/); PG_RETURN_VOID(); } static void emit_up_to_date_notice(const ContinuousAgg *cagg, const ContinuousAggRefreshContext context) { switch (context.callctx) { case CAGG_REFRESH_WINDOW: case CAGG_REFRESH_CREATION: elog(NOTICE, "continuous aggregate \"%s\" is already up-to-date", NameStr(cagg->data.user_view_name)); break; case CAGG_REFRESH_POLICY: case CAGG_REFRESH_POLICY_BATCHED: break; } } static bool process_cagg_invalidations_and_refresh(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const ContinuousAggRefreshContext context, int32 chunk_id, bool bucketing_refresh_window, bool force) { InvalidationStore *invalidations; Oid hyper_relid = ts_hypertable_id_to_relid(cagg->data.mat_hypertable_id, false); /* Lock the continuous aggregate's materialized hypertable to protect against * concurrent invalidation log processing. * * It will produce rows in the `continuous_aggs_materialization_ranges` table * to be materialized later either serially or in parallel for non-overlap * refresh ranges. * * This is supposed to be a short transaction and in the future we can consider * relaxing this lock. */ LockRelationOid(hyper_relid, ShareUpdateExclusiveLock); invalidations = invalidation_process_cagg_log(cagg, refresh_window, ts_guc_cagg_max_individual_materializations, context, force); DEBUG_WAITPOINT("before_process_cagg_invalidations_for_refresh_lock"); SPI_commit_and_chain(); DEBUG_WAITPOINT("after_process_cagg_invalidations_for_refresh_lock"); if (invalidations != NULL) { if (context.callctx == CAGG_REFRESH_CREATION) { Assert(OidIsValid(cagg->relid)); ereport(NOTICE, (errmsg("refreshing continuous aggregate \"%s\"", get_rel_name(cagg->relid)), errhint("Use WITH NO DATA if you do not want to refresh the continuous " "aggregate on creation."))); } continuous_agg_refresh_with_window(cagg, refresh_window, invalidations, chunk_id, context, bucketing_refresh_window); if (invalidations) invalidation_store_free(invalidations); return true; } return false; } void continuous_agg_refresh_internal(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window_arg, const ContinuousAggRefreshContext context, const bool start_isnull, const bool end_isnull, bool bucketing_refresh_window, bool force, bool process_hypertable_invalidations, bool extend_last_bucket) { int32 mat_id = cagg->data.mat_hypertable_id; InternalTimeRange refresh_window = *refresh_window_arg; int64 invalidation_threshold; bool nonatomic = ts_process_utility_is_context_nonatomic(); /* Reset the saved ProcessUtilityContext value promptly before * calling Prevent* checks so the potential unsupported (atomic) * value won't linger there in case of ereport exit. */ ts_process_utility_context_reset(); PreventCommandIfReadOnly(REFRESH_FUNCTION_NAME); /* Prevent running refresh if we're in a transaction block since a refresh * can run two transactions and might take a long time to release locks if * there's a lot to materialize. Strictly, it is optional to prohibit * transaction blocks since there will be only one transaction if the * invalidation threshold needs no update. However, materialization might * still take a long time and it is probably best for consistency to always * prevent transaction blocks. */ PreventInTransactionBlock(nonatomic, REFRESH_FUNCTION_NAME); /* * We don't cagg refresh to fail because of decompression limit. So disable * the decompression limit for the duration of the refresh. */ const char *old_decompression_limit = GetConfigOption("timescaledb.max_tuples_decompressed_per_dml_transaction", false, false); SetConfigOption("timescaledb.max_tuples_decompressed_per_dml_transaction", "0", PGC_USERSET, PGC_S_SESSION); /* Connect to SPI manager due to the underlying SPI calls */ int rc = SPI_connect_ext(SPI_OPT_NONATOMIC); if (rc != SPI_OK_CONNECT) elog(ERROR, "SPI_connect failed: %s", SPI_result_code_string(rc)); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); /* Like regular materialized views, require owner to refresh. */ if (!object_ownercheck(RelationRelationId, cagg->relid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(cagg->relid)), get_rel_name(cagg->relid)); /* No bucketing when open ended */ if (bucketing_refresh_window && !(start_isnull && end_isnull)) { if (cagg->bucket_function->bucket_fixed_interval == false) { refresh_window = *refresh_window_arg; ts_compute_inscribed_bucketed_refresh_window_variable(&refresh_window.start, &refresh_window.end, cagg->bucket_function); } else { int64 bucket_width = ts_continuous_agg_fixed_bucket_width(cagg->bucket_function); Assert(bucket_width > 0); refresh_window = compute_inscribed_bucketed_refresh_window(cagg, refresh_window_arg, bucket_width); } } if (refresh_window.start >= refresh_window.end) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("refresh window too small"), errdetail("The refresh window must cover at least one bucket of data."), errhint("Align the refresh window with the bucket" " time zone or use at least two buckets."))); /* If there is no other policy defined after this, the inscribed bucket calculated above * is correct. However, in the case of concurrent policies, if this isn't the last * policy defined then we should extend the end of the window to include the partial * bucket. This is done to ensure concurrent policies that are 'adjacent' don't skip a * bucket We don't need to do this when the CAgg is created WITH DATA, or manually * refreshed */ if (extend_last_bucket && !(start_isnull && end_isnull)) { if (cagg->bucket_function->bucket_fixed_interval == false) { refresh_window.end = ts_compute_beginning_of_the_next_bucket_variable(refresh_window.end, cagg->bucket_function); } else { int64 bucket_width = ts_continuous_agg_fixed_bucket_width(cagg->bucket_function); refresh_window.end = ts_time_saturating_add(refresh_window.end, bucket_width - 1, refresh_window.type); } } /* * Perform the refresh across two transactions. * * The first transaction moves the invalidation threshold (if needed) and * copies over invalidations from the hypertable log to the cagg * invalidation log. Doing the threshold and copying as part of the first * transaction ensures that the threshold and new invalidations will be * visible as soon as possible to concurrent refreshes and that we keep * locks for only a short period. * * The second transaction processes the cagg invalidation log and then * performs the actual refresh (materialization of data). This transaction * serializes around a lock on the materialized hypertable for the * continuous aggregate that gets refreshed. */ /* Set the new invalidation threshold. Note that this only updates the * threshold if the new value is greater than the old one. Otherwise, the * existing threshold is returned. */ invalidation_threshold = invalidation_threshold_set_or_get(cagg, &refresh_window); /* We must also cap the refresh window at the invalidation threshold. If * we process invalidations after the threshold, the continuous aggregates * won't be refreshed when the threshold is moved forward in the * future. The invalidation threshold should already be aligned on bucket * boundary. */ if (refresh_window.end > invalidation_threshold) refresh_window.end = invalidation_threshold; /* Capping the end might have made the window 0, or negative, so nothing to refresh in that * case. * * For variable width buckets we use a refresh_window.start value that is lower than the * -infinity value (ts_time_get_nobegin < ts_time_get_min). Therefore, the first check in the * following if statement is not enough. If the invalidation_threshold returns the min_value for * the data type, we end up with [nobegin, min_value] which is an invalid time interval. * Therefore, we have also to check if the invalidation_threshold is defined. If not, no refresh * is needed. */ if ((refresh_window.start >= refresh_window.end) || (IS_TIMESTAMP_TYPE(refresh_window.type) && invalidation_threshold == ts_time_get_min(refresh_window.type))) { emit_up_to_date_notice(cagg, context); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); rc = SPI_finish(); if (rc != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc)); return; } if (process_hypertable_invalidations) { /* * If we are using trigger-based invalidations, we can process the * invalidations for the associated hypertable only and later read the * invalidations for other hypertables, but when using WAL-based * invalidation we need to process all of the hypertables that are * currently using WAL. * * We want to prevent any changes to how invalidations are collected * in the meantime since changing the invalidation collection method * while this is running might cause problems and miss invalidations. * * Concurrency on the replication slot is controlled using some * special sauce in ReplicationSlotAcquire(), which is called inside * pg_logical_slot_get_changes_guts(). * * This will currently generate an error rather than blocking on the * lock, so we need to add a separate lock to ensure a blocking * behaviour. */ if (!ts_guc_enable_cagg_wal_based_invalidation) invalidation_process_hypertable_log(cagg->data.raw_hypertable_id, refresh_window.type); else multi_invalidation_process_hypertable_log(get_all_wal_using_hypertables()); } /* Commit and Start a new transaction */ SPI_commit_and_chain(); cagg = ts_continuous_agg_find_by_mat_hypertable_id(mat_id, false); bool refreshed = process_cagg_invalidations_and_refresh(cagg, &refresh_window, context, INVALID_CHUNK_ID, bucketing_refresh_window, force); /* check if we have any pending materializations in our refresh window range, * if so, we need to process them * Note that we use the original refresh window range here, not the one that has been processed * by the refresh function*/ refresh_window = *refresh_window_arg; bool has_pending_materializations = continuous_agg_has_pending_materializations(cagg, refresh_window); if (has_pending_materializations) { ContinuousAggRefreshState refresh; continuous_agg_refresh_init(&refresh, cagg, &refresh_window, bucketing_refresh_window); InternalTimeRange invalidation = { .type = refresh_window.type, .start = refresh_window.start, /* Invalidations are inclusive at the end, while refresh windows * aren't, so add one to the end of the invalidated region */ .end = ts_time_saturating_add(refresh_window.end, 1, refresh_window.type), }; InternalTimeRange bucketed_refresh_window = { .type = invalidation.type, .start = invalidation.start, .end = invalidation.end, }; if (bucketing_refresh_window) { bucketed_refresh_window = compute_circumscribed_bucketed_refresh_window(cagg, &invalidation, cagg->bucket_function); } continuous_agg_refresh_execute(&refresh, &bucketed_refresh_window, INVALID_CHUNK_ID); } if (!refreshed && !has_pending_materializations) emit_up_to_date_notice(cagg, context); DEBUG_WAITPOINT("after_process_cagg_materializations"); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); SetConfigOption("timescaledb.max_tuples_decompressed_per_dml_transaction", old_decompression_limit, PGC_USERSET, PGC_S_SESSION); rc = SPI_finish(); if (rc != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc)); } static void debug_refresh_window(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const char *msg) { elog(DEBUG1, "%s \"%s\" in window [ %s, %s ] internal [ " INT64_FORMAT ", " INT64_FORMAT " ] minimum [ %s ]", msg, NameStr(cagg->data.user_view_name), ts_internal_to_time_string(refresh_window->start, refresh_window->type), ts_internal_to_time_string(refresh_window->end, refresh_window->type), refresh_window->start, refresh_window->end, ts_datum_to_string(Int64GetDatum(ts_time_get_min(refresh_window->type)), refresh_window->type)); } List * continuous_agg_split_refresh_window(ContinuousAgg *cagg, InternalTimeRange *original_refresh_window, int32 buckets_per_batch, bool refresh_newest_first) { /* Do not produce batches when the number of buckets per batch is zero (disabled) */ if (buckets_per_batch == 0) { return NIL; } InternalTimeRange refresh_window = { .type = original_refresh_window->type, .start = original_refresh_window->start, .start_isnull = original_refresh_window->start_isnull, .end = original_refresh_window->end, .end_isnull = original_refresh_window->end_isnull, }; debug_refresh_window(cagg, &refresh_window, "begin"); const Hypertable *ht = cagg_get_hypertable_or_fail(cagg->data.raw_hypertable_id); const Dimension *time_dim = hyperspace_get_open_dimension(ht->space, 0); /* * Cap the refresh window to the min and max time of the hypertable * * In order to don't produce unnecessary batches we need to check if the start and end of the * refresh window is NULL then get the min/max slice from the original hypertable * */ if (refresh_window.start_isnull) { debug_refresh_window(cagg, &refresh_window, "START IS NULL"); DimensionSlice *slice = ts_dimension_slice_nth_earliest_slice(time_dim->fd.id, 1); /* If still there's no MIN slice range start then return no batches */ if (NULL == slice || TS_TIME_IS_MIN(slice->fd.range_start, refresh_window.type) || TS_TIME_IS_NOBEGIN(slice->fd.range_start, refresh_window.type)) { elog(LOG, "no min slice range start for continuous aggregate \"%s.%s\", falling back to " "single batch processing", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)); return NIL; } refresh_window.start = slice->fd.range_start; refresh_window.start_isnull = false; } if (refresh_window.end_isnull) { debug_refresh_window(cagg, &refresh_window, "END IS NULL"); DimensionSlice *slice = ts_dimension_slice_nth_latest_slice(time_dim->fd.id, 1); /* If still there's no MAX slice range start then return no batches */ if (NULL == slice || TS_TIME_IS_MAX(slice->fd.range_end, refresh_window.type) || TS_TIME_IS_NOEND(slice->fd.range_end, refresh_window.type)) { elog(LOG, "no min slice range start for continuous aggregate \"%s.%s\", falling back to " "single batch processing", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)); return NIL; } refresh_window.end = slice->fd.range_end; refresh_window.end_isnull = false; } /* Compute the inscribed bucket for the capped refresh window range */ const int64 bucket_width = ts_continuous_agg_bucket_width(cagg->bucket_function); if (cagg->bucket_function->bucket_fixed_interval == false) { ts_compute_inscribed_bucketed_refresh_window_variable(&refresh_window.start, &refresh_window.end, cagg->bucket_function); } else { refresh_window = compute_inscribed_bucketed_refresh_window(cagg, &refresh_window, bucket_width); } /* Check if the refresh size is large enough to produce bathes, if not then return no batches */ const int64 refresh_window_size = i64abs(refresh_window.end - refresh_window.start); const int64 batch_size = (bucket_width * buckets_per_batch); if (refresh_window_size <= batch_size) { Oid type = IS_TIMESTAMP_TYPE(refresh_window.type) ? INTERVALOID : refresh_window.type; Datum refresh_size_interval = ts_internal_to_interval_value(refresh_window_size, type); Datum batch_size_interval = ts_internal_to_interval_value(batch_size, type); elog(LOG, "refresh window size (%s) is smaller than or equal to batch size (%s), falling back " "to single batch processing", ts_datum_to_string(refresh_size_interval, type), ts_datum_to_string(batch_size_interval, type)); return NIL; } debug_refresh_window(cagg, &refresh_window, "before produce batches"); /* * Produce the batches to be processed * * The refresh window is split into multiple batches of size `batch_size` each. The batches are * produced in reverse order so that the first range produced is the last range to be processed. * * The batches are produced in reverse order because the most recent data should be the first to * be processed and be visible for the users. * * It takes in account the invalidation logs (hypertable and materialization hypertable) to * avoid producing wholes that have no data to be processed. * * The logic is something like the following: * 1. Get dimension slices from the original hypertables * 2. Get either hypertable and materialization hypertable invalidation logs * 3. Produce the batches in reverse order * 4. Check if the produced batch overlaps either with dimension slices #1 and invalidation logs * #2 * 5. If the batch overlaps with both then it's a valid batch to be processed * 6. If the batch overlaps with only one of them then it's not a valid batch to be processed * 7. If the batch does not overlap with any of them then it's not a valid batch to be processed */ const char *query_str_template = " \ WITH dimension_slices AS ( \ SELECT \ range_start AS start, \ range_end AS end \ FROM \ _timescaledb_catalog.dimension_slice \ JOIN _timescaledb_catalog.dimension ON dimension.id = dimension_slice.dimension_id \ WHERE \ hypertable_id = $1 \ AND dimension_id = $2 \ AND range_end >= range_start \ ORDER BY \ %s \ ), \ invalidation_logs AS ( \ SELECT \ lowest_modified_value, \ greatest_modified_value \ FROM \ _timescaledb_catalog.continuous_aggs_materialization_invalidation_log \ WHERE \ materialization_id = $3 \ AND greatest_modified_value >= lowest_modified_value \ UNION ALL \ SELECT \ pg_catalog.min(lowest_modified_value) AS lowest_modified_value, \ pg_catalog.max(greatest_modified_value) AS greatest_modified_value \ FROM \ _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log \ WHERE \ hypertable_id = $1 \ AND greatest_modified_value >= lowest_modified_value \ ) \ SELECT \ refresh_start AS start, \ LEAST($6::numeric, refresh_start::numeric + $4::numeric)::bigint AS end \ FROM \ pg_catalog.generate_series($5, $6, $4) AS refresh_start \ WHERE \ EXISTS ( \ SELECT FROM dimension_slices \ WHERE \ pg_catalog.int8range(refresh_start, LEAST($6::numeric, refresh_start::numeric + $4::numeric)::bigint) \ OPERATOR(pg_catalog.&&) \ pg_catalog.int8range(dimension_slices.start, dimension_slices.end) \ ) \ AND EXISTS ( \ SELECT FROM \ invalidation_logs \ WHERE \ pg_catalog.int8range(refresh_start, LEAST($6::numeric, refresh_start::numeric + $4::numeric)::bigint) \ OPERATOR(pg_catalog.&&) \ pg_catalog.int8range(lowest_modified_value, greatest_modified_value) \ AND lowest_modified_value IS NOT NULL \ AND (greatest_modified_value IS NOT NULL AND greatest_modified_value != $7) \ ) \ ORDER BY \ refresh_start %s;"; const char *query_str = psprintf(query_str_template, refresh_newest_first ? "range_end DESC" : "range_start ASC", refresh_newest_first ? "DESC" : "ASC"); /* List of InternalTimeRange elements to be returned */ List *refresh_window_list = NIL; /* Prepare for SPI call */ int res; Oid types[] = { INT4OID, INT4OID, INT4OID, INT8OID, INT8OID, INT8OID, INT8OID }; Datum values[] = { Int32GetDatum(ht->fd.id), Int32GetDatum(time_dim->fd.id), Int32GetDatum(cagg->data.mat_hypertable_id), Int64GetDatum(batch_size), Int64GetDatum(refresh_window.start), Int64GetDatum(refresh_window.end), Int64GetDatum(CAGG_INVALIDATION_WRONG_GREATEST_VALUE) }; char nulls[] = { false, false, false, false, false, false, false }; MemoryContext oldcontext = CurrentMemoryContext; if (SPI_connect() != SPI_OK_CONNECT) elog(ERROR, "could not connect to SPI"); /* Lock down search_path */ int save_nestlevel = NewGUCNestLevel(); RestrictSearchPath(); res = SPI_execute_with_args(query_str, 7, types, values, nulls, false /* read_only */, 0 /* count */); if (res < 0) elog(ERROR, "%s: could not produce batches for the policy cagg refresh", __func__); if (SPI_processed == 1) { elog(LOG, "only one batch produced for continuous aggregate \"%s.%s\", falling back to single " "batch processing", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)); /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); return NIL; } /* Build the batches list */ for (uint64 batch = 0; batch < SPI_processed; batch++) { bool range_start_isnull, range_end_isnull; Datum range_start = SPI_getbinval(SPI_tuptable->vals[batch], SPI_tuptable->tupdesc, 1, &range_start_isnull); Datum range_end = SPI_getbinval(SPI_tuptable->vals[batch], SPI_tuptable->tupdesc, 2, &range_end_isnull); /* We need to allocate the list in the old memory context because here we're in the SPI * context */ MemoryContext saved_context = MemoryContextSwitchTo(oldcontext); InternalTimeRange *range = palloc0(sizeof(InternalTimeRange)); range->start = DatumGetInt64(range_start); range->start_isnull = range_start_isnull; range->end = DatumGetInt64(range_end); range->end_isnull = range_end_isnull; range->type = original_refresh_window->type; /* * To make sure that the first range (or last range in case of refreshing from oldest to * newest) is aligned with the end of the refresh window we need to set the end to the * maximum value of the time type if the original refresh window end is NULL. */ if (((batch == 0 && refresh_newest_first) || (batch == (SPI_processed - 1) && !refresh_newest_first)) && original_refresh_window->end_isnull) { range->end = ts_time_get_noend_or_max(range->type); range->end_isnull = true; } /* * To make sure that the last range (or first range in case of refreshing from oldest to * newest) is aligned with the start of the refresh window we need to set the start to the * maximum value of the time type if the original refresh window start is NULL. */ if (((batch == (SPI_processed - 1) && refresh_newest_first) || (batch == 0 && !refresh_newest_first)) && original_refresh_window->start_isnull) { range->start = cagg_get_time_min(cagg); range->start_isnull = true; } refresh_window_list = lappend(refresh_window_list, range); MemoryContextSwitchTo(saved_context); debug_refresh_window(cagg, range, "batch produced"); } /* Restore search_path */ AtEOXact_GUC(false, save_nestlevel); res = SPI_finish(); if (res != SPI_OK_FINISH) elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(res)); if (refresh_window_list == NIL) { elog(LOG, "no valid batches produced for continuous aggregate \"%s.%s\", falling back to single " "batch processing", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)); } return refresh_window_list; } ������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/refresh.h������������������������������������������������0000664�0000000�0000000�00000002127�15100345067�0022464�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include "invalidation.h" #include "materialize.h" extern Datum continuous_agg_refresh(PG_FUNCTION_ARGS); extern void continuous_agg_refresh_internal(const ContinuousAgg *cagg, const InternalTimeRange *refresh_window, const ContinuousAggRefreshContext context, const bool start_isnull, const bool end_isnull, bool bucketing_refresh_window, bool force, bool process_hypertable_invalidations, bool extend_last_bucket); extern List *continuous_agg_split_refresh_window(ContinuousAgg *cagg, InternalTimeRange *original_refresh_window, int32 buckets_per_batch, bool refresh_newest_first); InternalTimeRange compute_circumscribed_bucketed_refresh_window(const ContinuousAgg *cagg, const InternalTimeRange *const refresh_window, const ContinuousAggBucketFunction *bucket_function); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/repair.c�������������������������������������������������0000664�0000000�0000000�00000017415�15100345067�0022311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "repair.h" #include <funcapi.h> #include "func_cache.h" static void cagg_rebuild_view_definition(ContinuousAgg *agg, Hypertable *mat_ht, bool force_rebuild); /* * Test the view definition of an existing continuous aggregate * for errors and attempt to rebuild it if required. */ static void cagg_rebuild_view_definition(ContinuousAgg *agg, Hypertable *mat_ht, bool force_rebuild) { bool test_failed = false; char *relname = NameStr(agg->data.user_view_name); char *schema = NameStr(agg->data.user_view_schema); ListCell *lc1, *lc2; int sec_ctx; Oid uid, saved_uid; bool finalized = ContinuousAggIsFinalized(agg); if (!finalized) { ereport(WARNING, (errmsg("repairing Continuous Aggregates with partials are not supported anymore."), errdetail("Migrate the Continuous Aggregates to finalized form to rebuild."), errhint("Run \"CALL cagg_migrate('%s.%s');\" to migrate to the new " "format.", schema, relname))); return; } /* Cagg view created by the user. */ Oid user_view_oid = ts_get_relation_relid(NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name), false); Relation user_view_rel = relation_open(user_view_oid, AccessShareLock); Query *user_query = get_view_query(user_view_rel); bool rebuild_cagg_with_joins = false; /* Extract final query from user view query. */ Query *final_query = copyObject(user_query); RemoveRangeTableEntries(final_query); if (finalized && !force_rebuild) { /* This continuous aggregate does not have partials, do not check for defects. */ elog(DEBUG1, "[cagg_rebuild_view_definition] %s.%s does not have partials, do not check for " "defects!", NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name) ); relation_close(user_view_rel, NoLock); return; } if (!agg->data.materialized_only) { final_query = destroy_union_query(final_query); } FinalizeQueryInfo fqi; MaterializationHypertableColumnInfo mattblinfo; ObjectAddress mataddress = { .classId = RelationRelationId, .objectId = mat_ht->main_table_relid, }; Oid direct_view_oid = ts_get_relation_relid(NameStr(agg->data.direct_view_schema), NameStr(agg->data.direct_view_name), false); Relation direct_view_rel = relation_open(direct_view_oid, AccessShareLock); Query *direct_query = copyObject(get_view_query(direct_view_rel)); RemoveRangeTableEntries(direct_query); /* * If there is a join in CAggs then rebuild it definitely, * because v2.10.0 has created the definition with missing structs. * * Removed the check for direct_query->jointree != NULL because * we don't allow queries without FROM clause in Continuous Aggregate * definition. * * Per coverityscan: * https://scan4.scan.coverity.com/reports.htm#v54116/p12995/fileInstanceId=131745632&defectInstanceId=14569562&mergedDefectId=384045 * */ if (force_rebuild) { ListCell *l; foreach (l, direct_query->jointree->fromlist) { Node *jtnode = (Node *) lfirst(l); if (IsA(jtnode, JoinExpr)) rebuild_cagg_with_joins = true; } } if (!rebuild_cagg_with_joins && finalized) { /* There's nothing to fix, so no need to rebuild */ elog(DEBUG1, "[cagg_rebuild_view_definition] %s.%s does not have JOINS, so no need to rebuild the " "definition!", NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name) ); relation_close(user_view_rel, NoLock); relation_close(direct_view_rel, NoLock); return; } else elog(DEBUG1, "[cagg_rebuild_view_definition] %s.%s has been rebuilt!", NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name)); ContinuousAggTimeBucketInfo timebucket_exprinfo = cagg_validate_query(direct_query, finalized, NameStr(agg->data.user_view_schema), NameStr(agg->data.user_view_name), false); mattablecolumninfo_init(&mattblinfo, copyObject(direct_query->groupClause)); fqi.finalized = finalized; finalizequery_init(&fqi, direct_query, &mattblinfo); Query *view_query = finalizequery_get_select_query(&fqi, mattblinfo.matcollist, &mataddress, NameStr(mat_ht->fd.table_name)); if (!agg->data.materialized_only) { view_query = build_union_query(&timebucket_exprinfo, mattblinfo.matpartcolno, view_query, direct_query, mat_ht->fd.id); } if (list_length(mattblinfo.matcollist) != ts_get_relnatts(mat_ht->main_table_relid)) /* * There is a mismatch of columns between the current version's finalization view * building logic and the existing schema of the materialization table. As of version * 2.7.0 this only happens due to buggy view generation in previous versions. Do not * rebuild those views since the materialization table can not be queried correctly. */ test_failed = true; /* * When calling StoreViewQuery the target list names of the query have to * match the view's tuple descriptor attribute names. But if a column of the continuous * aggregate has been renamed, the query tree will not have the correct * names in the target list, which will error out when calling * StoreViewQuery. For that reason, we fetch the name from the user view * relation and update the resource name in the query target list to match * the name in the user view. */ TupleDesc desc = RelationGetDescr(user_view_rel); int i = 0; forboth (lc1, view_query->targetList, lc2, user_query->targetList) { TargetEntry *view_tle, *user_tle; FormData_pg_attribute *attr = TupleDescAttr(desc, i); view_tle = lfirst_node(TargetEntry, lc1); user_tle = lfirst_node(TargetEntry, lc2); if (view_tle->resjunk && user_tle->resjunk) break; else if (view_tle->resjunk || user_tle->resjunk) { /* * This should never happen but if it ever does it's safer to * error here instead of creating broken view definitions. */ test_failed = true; break; } view_tle->resname = user_tle->resname = NameStr(attr->attname); ++i; } if (test_failed) { ereport(WARNING, (errmsg("Inconsistent view definitions for continuous aggregate view " "\"%s.%s\"", schema, relname), errdetail("Continuous aggregate data possibly corrupted."), errhint("You may need to recreate the continuous aggregate with CREATE " "MATERIALIZED VIEW."))); } else { SWITCH_TO_TS_USER(NameStr(agg->data.user_view_schema), uid, saved_uid, sec_ctx); StoreViewQuery(user_view_oid, view_query, true); CommandCounterIncrement(); RESTORE_USER(uid, saved_uid, sec_ctx); } /* * Keep locks until end of transaction and do not close the relation * before the call to StoreViewQuery since it can otherwise release the * memory for attr->attname, causing a segfault. */ relation_close(direct_view_rel, NoLock); relation_close(user_view_rel, NoLock); } Datum tsl_cagg_try_repair(PG_FUNCTION_ARGS) { Oid relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); char relkind = get_rel_relkind(relid); bool force_rebuild = PG_ARGISNULL(0) ? false : PG_GETARG_BOOL(1); ContinuousAgg *cagg = NULL; if (RELKIND_VIEW == relkind) cagg = ts_continuous_agg_find_by_relid(relid); if (RELKIND_VIEW != relkind || !cagg) { ereport(WARNING, (errmsg("invalid OID \"%u\" for continuous aggregate view", relid), errdetail("Check for database corruption."))); PG_RETURN_VOID(); } Cache *hcache = ts_hypertable_cache_pin(); Hypertable *mat_ht = ts_hypertable_cache_get_entry_by_id(hcache, cagg->data.mat_hypertable_id); Assert(mat_ht != NULL); cagg_rebuild_view_definition(cagg, mat_ht, force_rebuild); ts_cache_release(&hcache); PG_RETURN_VOID(); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/repair.h�������������������������������������������������0000664�0000000�0000000�00000000717�15100345067�0022313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <commands/view.h> #include "continuous_aggs/common.h" #include "continuous_aggs/finalize.h" #include "continuous_aggs/materialize.h" #include "ts_catalog/continuous_agg.h" extern Datum tsl_cagg_try_repair(PG_FUNCTION_ARGS); �������������������������������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/utils.c��������������������������������������������������0000664�0000000�0000000�00000073745�15100345067�0022177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <commands/view.h> #include <storage/lmgr.h> #include <utils/acl.h> #include <utils/regproc.h> #include <utils/snapmgr.h> #include <utils/timestamp.h> #include "extension.h" #include "guc.h" #include "time_bucket.h" #include "utils.h" enum { Anum_cagg_validate_query_valid = 1, Anum_cagg_validate_query_error_level, Anum_cagg_validate_query_error_code, Anum_cagg_validate_query_error_message, Anum_cagg_validate_query_error_detail, Anum_cagg_validate_query_error_hint, _Anum_cagg_validate_query_max }; #define Natts_cagg_validate_query (_Anum_cagg_validate_query_max - 1) #define ORIGIN_PARAMETER_NAME "origin" static Datum create_cagg_validate_query_datum(TupleDesc tupdesc, const bool is_valid_query, ErrorData *edata) { NullableDatum datums[Natts_cagg_validate_query] = { { 0 } }; HeapTuple tuple; tupdesc = BlessTupleDesc(tupdesc); ts_datum_set_bool(Anum_cagg_validate_query_valid, datums, is_valid_query, false); ts_datum_set_text_from_cstring(Anum_cagg_validate_query_error_level, datums, edata->elevel > 0 ? error_severity(edata->elevel) : NULL); ts_datum_set_text_from_cstring(Anum_cagg_validate_query_error_code, datums, edata->sqlerrcode > 0 ? unpack_sql_state(edata->sqlerrcode) : NULL); ts_datum_set_text_from_cstring(Anum_cagg_validate_query_error_message, datums, edata->message ? edata->message : NULL); ts_datum_set_text_from_cstring(Anum_cagg_validate_query_error_detail, datums, edata->detail ? edata->detail : NULL); ts_datum_set_text_from_cstring(Anum_cagg_validate_query_error_hint, datums, edata->hint ? edata->hint : NULL); Assert(tupdesc->natts == Natts_cagg_validate_query); tuple = ts_heap_form_tuple(tupdesc, datums); return HeapTupleGetDatum(tuple); } Datum continuous_agg_validate_query(PG_FUNCTION_ARGS) { text *query_text = PG_GETARG_TEXT_P(0); char *sql; volatile bool is_valid_query = false; Datum datum_sql; TupleDesc tupdesc; ErrorData *edata; MemoryContext oldcontext = CurrentMemoryContext; /* Change $1, $2 ... placeholders to NULL constant. This is necessary to make parser happy */ sql = text_to_cstring(query_text); elog(DEBUG1, "sql: %s", sql); datum_sql = CStringGetTextDatum(sql); datum_sql = DirectFunctionCall4Coll(textregexreplace, C_COLLATION_OID, datum_sql, CStringGetTextDatum("\\$[0-9]+"), CStringGetTextDatum("NULL"), CStringGetTextDatum("g")); sql = text_to_cstring(DatumGetTextP(datum_sql)); elog(DEBUG1, "sql: %s", sql); if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "function returning record called in context that cannot accept type record"); PG_TRY(); { List *tree; Node *node; RawStmt *rawstmt; ParseState *pstate; Query *query; edata = (ErrorData *) palloc0(sizeof(ErrorData)); edata->message = NULL; edata->detail = NULL; edata->hint = NULL; tree = pg_parse_query(sql); if (tree == NIL) { edata->elevel = ERROR; edata->sqlerrcode = ERRCODE_INTERNAL_ERROR; edata->message = "failed to parse query"; } else if (list_length(tree) > 1) { edata->elevel = WARNING; edata->sqlerrcode = ERRCODE_FEATURE_NOT_SUPPORTED; edata->message = "multiple statements are not supported"; } else { node = linitial(tree); rawstmt = (RawStmt *) node; pstate = make_parsestate(NULL); Assert(IsA(node, RawStmt)); if (!IsA(rawstmt->stmt, SelectStmt)) { edata->elevel = WARNING; edata->sqlerrcode = ERRCODE_FEATURE_NOT_SUPPORTED; edata->message = "only select statements are supported"; } else { pstate->p_sourcetext = sql; query = transformTopLevelStmt(pstate, rawstmt); free_parsestate(pstate); (void) cagg_validate_query(query, true, "public", "cagg_validate", false); is_valid_query = true; } } } PG_CATCH(); { MemoryContextSwitchTo(oldcontext); edata = CopyErrorData(); FlushErrorState(); } PG_END_TRY(); PG_RETURN_DATUM(create_cagg_validate_query_datum(tupdesc, is_valid_query, edata)); } /* * Find proper time_bucket replacement for time_bucket_ng function * * need_order_flip indicates if the origin and timezone parameters needs to be changed * (see inline comment for more details). * */ static Oid get_replacement_timebucket_function(const ContinuousAgg *cagg, bool *need_parameter_order_change) { Oid bucket_function = cagg->bucket_function->bucket_function; Assert(OidIsValid(bucket_function)); /* Return type of the current bucket function */ Oid bucket_function_rettype = get_func_rettype(bucket_function); Assert(OidIsValid(bucket_function_rettype)); FuncInfo *func_info = ts_func_cache_get(bucket_function); Ensure(func_info != NULL, "unable to get function info for Oid %d", bucket_function); /* The input and output parameters of the function has to be the same * (parameter 0 is the bucket size, parameter 1 the input attribute). */ Assert(bucket_function_rettype == func_info->arg_types[1]); /* Check if the CAgg is actually using a deprecated time_bucket_ng function */ if (!IS_DEPRECATED_TIME_BUCKET_NG_FUNC(func_info)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("CAgg %s does not use a deprecated bucket function", get_rel_name(cagg->relid)))); } /* Should never happen since time_bucket_ng does not support these configuration. But just to be * sure about the configured parameter. */ Ensure(cagg->bucket_function->bucket_time_based, "CAgg seems to be integer based, however time_bucket_ng does not support this"); Ensure(cagg->bucket_function->bucket_time_origin, "CAgg seems to have an origin, however time_bucket_ng does not support this"); /* Return values of func_get_detail */ Oid funcid; Oid rettype; bool retset; int nvargs; Oid vatype; Oid *declared_arg_types; List *argdefaults; List *arg_names = NIL; int func_nargs = func_info->nargs; Oid *func_arg_types = func_info->arg_types; *need_parameter_order_change = false; /* * Create a new private copy of the arguments with space for n+1 Oids. We will add one entry or * re-order entries and we don't want to modify the entry in the catalog cache. */ Assert(!OidIsValid(func_arg_types[func_nargs])); func_arg_types = palloc0((func_nargs + 1) * sizeof(Oid)); memcpy(func_arg_types, func_info->arg_types, func_nargs * sizeof(Oid)); Assert(!OidIsValid(func_arg_types[func_nargs])); /* Add argument for new origin value */ if (cagg->bucket_function->bucket_time_based && TIMESTAMP_NOT_FINITE(cagg->bucket_function->bucket_time_origin)) { /* Add new origin parameter. The origin parameter has the same type as the return type of * the function. For example, a time_bucket function processing dates, takes also a date a * origin parameter. */ func_arg_types[func_nargs] = bucket_function_rettype; arg_names = list_make1(ORIGIN_PARAMETER_NAME); func_nargs++; } else if (func_nargs == 4) { /* * timebucket_ng and time_bucket take the timezone at different positions, * change parameter order to help PostgreSQL to find the right function: * * time_bucket_ng * bucket_width interval, ts timestamp with time zone, * origin timestamp with time zone, timezone text * * time_bucket * bucket_width interval, ts timestamp with time zone, timezone text, * origin timestamp with time zone DEFAULT NULL, * offset interval DEFAULT NULL */ if (func_arg_types[2] == TIMESTAMPTZOID && func_arg_types[3] == TEXTOID) { func_arg_types[2] = TEXTOID; func_arg_types[3] = TIMESTAMPTZOID; *need_parameter_order_change = true; } } FuncDetailCode fdresult = func_get_detail(list_make1(makeString("time_bucket")), NIL, arg_names, func_nargs, func_arg_types, true /* expand_variadic */, true /* expand_defaults */, false /* include_out_arguments */, &funcid, &rettype, &retset, &nvargs, &vatype, &declared_arg_types, &argdefaults); if (fdresult == FUNCDETAIL_NOTFOUND) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unable to find replacement for function %s", func_info->funcname))); } Assert(fdresult == FUNCDETAIL_NORMAL); Ensure(rettype == bucket_function_rettype, "unable to find a bucket replacement function with the same return type"); FuncInfo *func_info_new = ts_func_cache_get(funcid); Ensure(func_info_new != NULL, "unable to get function info for Oid %d", funcid); Ensure(func_info_new->allowed_in_cagg_definition, "new time_bucket function is not allowed in CAggs"); return funcid; } /* * Update the cagg bucket function catalog table. During the migration, we set a new bucket * function and a origin if the bucket function is time based. */ static ScanTupleResult cagg_time_bucket_update(TupleInfo *ti, void *data) { bool should_free; HeapTuple tuple = ts_scanner_fetch_heap_tuple(ti, false, &should_free); TupleDesc tupleDesc = ts_scanner_get_tupledesc(ti); const ContinuousAgg *cagg = (ContinuousAgg *) data; Datum values[Natts_continuous_aggs_bucket_function] = { 0 }; bool isnull[Natts_continuous_aggs_bucket_function] = { 0 }; bool doReplace[Natts_continuous_aggs_bucket_function] = { 0 }; /* Update the bucket function */ values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_function)] = CStringGetTextDatum(format_procedure_qualified(cagg->bucket_function->bucket_function)); doReplace[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_function)] = true; /* Set new origin if not already present. Time_bucket and time_bucket_ng use different * origin values for time based values. */ if (cagg->bucket_function->bucket_time_based) { char *origin_value = DatumGetCString( DirectFunctionCall1(timestamptz_out, TimestampTzGetDatum(cagg->bucket_function->bucket_time_origin))); values[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)] = CStringGetTextDatum(origin_value); doReplace[AttrNumberGetAttrOffset(Anum_continuous_aggs_bucket_function_bucket_origin)] = true; } HeapTuple new_tuple = heap_modify_tuple(tuple, tupleDesc, values, isnull, doReplace); ts_catalog_update(ti->scanrel, new_tuple); heap_freetuple(new_tuple); if (should_free) heap_freetuple(tuple); return SCAN_DONE; } /* * Search for the bucket function entry in the catalog and update the values. */ static int replace_time_bucket_function_in_catalog(ContinuousAgg *cagg) { ScanKeyData scankey[1]; ScanKeyInit(&scankey[0], Anum_continuous_aggs_bucket_function_pkey_mat_hypertable_id, BTEqualStrategyNumber, F_INT4EQ, Int32GetDatum(cagg->data.mat_hypertable_id)); Catalog *catalog = ts_catalog_get(); ScannerCtx scanctx = { .table = catalog_get_table_id(catalog, CONTINUOUS_AGGS_BUCKET_FUNCTION), .index = catalog_get_index(catalog, CONTINUOUS_AGGS_BUCKET_FUNCTION, CONTINUOUS_AGGS_BUCKET_FUNCTION_PKEY_IDX), .nkeys = 1, .scankey = scankey, .data = cagg, .limit = 1, .tuple_found = cagg_time_bucket_update, .lockmode = AccessShareLock, .scandirection = ForwardScanDirection, }; return ts_scanner_scan(&scanctx); } typedef struct TimeBucketInfoContext { /* The updated cagg definition */ const ContinuousAgg *cagg; /* The Oid of the old bucket function that should be replaced */ Oid function_to_replace; /* Was the defined origin added during the migration and needs * to be added to the function parameters during rewrite? */ bool origin_added_during_migration; /* Do we need to flip the timezone and the origin parameter during migration? */ bool need_parameter_order_change; } TimeBucketInfoContext; /* * Build a new const value for the origin parameter of the given type */ static Const * build_const_value_for_origin(TimeBucketInfoContext *context, Oid origin_type) { Datum const_datum; switch (origin_type) { case TIMESTAMPTZOID: const_datum = TimestampTzGetDatum(context->cagg->bucket_function->bucket_time_origin); break; case TIMESTAMPOID: const_datum = DirectFunctionCall1(timestamptz_timestamp, TimestampTzGetDatum( context->cagg->bucket_function->bucket_time_origin)); break; case DATEOID: const_datum = DirectFunctionCall1(timestamptz_date, TimestampTzGetDatum( context->cagg->bucket_function->bucket_time_origin)); break; default: elog(ERROR, "unable to build const value for bucket function with unsupported return type: %s", format_type_extended(origin_type, -1, 0)); pg_unreachable(); } TypeCacheEntry *tce = lookup_type_cache(origin_type, 0); /* The new origin value for the function */ Const *const_value = makeConst(origin_type /* consttype */, -1 /* consttypmod */, InvalidOid /* constcollid */, tce->typlen /* constlen */, const_datum /* constvalue */, false /* constisnull */, tce->typbyval /* constbyval */ ); return const_value; } /* * Replace the old time_bucket_ng function with the time_bucket function. Add a custom origin if * needed. */ static Node * cagg_user_query_mutator(Node *node, TimeBucketInfoContext *context) { Assert(context != NULL); if (node == NULL) return NULL; if (IsA(node, FuncExpr)) { FuncExpr *funcExpr = castNode(FuncExpr, node); if (context->function_to_replace == funcExpr->funcid) { FuncExpr *new_func = (FuncExpr *) copyObject(node); new_func->funcid = context->cagg->bucket_function->bucket_function; /* Origin can be added during migration OR we have an existing origin and need to shift * parameters */ Assert(context->origin_added_during_migration == false || context->need_parameter_order_change == false); /* Ensure the new bucket function produces buckets with the same origin as the old one */ if (context->origin_added_during_migration) { /* The origin parameter of the bucket function has the same type as the function * result. Build a new const value for the origin parameter of the needed type. */ Const *origin = build_const_value_for_origin(context, funcExpr->funcresulttype); /* Build wrapping named arg node */ NamedArgExpr *origin_arg = makeNode(NamedArgExpr); origin_arg->argnumber = list_length(funcExpr->args); origin_arg->location = -1; origin_arg->name = ORIGIN_PARAMETER_NAME; origin_arg->arg = (Expr *) origin; new_func->args = lappend(new_func->args, origin_arg); } if (context->need_parameter_order_change) { /* The existing CAgg should to have an origin before migration */ Assert(context->origin_added_during_migration == false); /* We need 4 elements (see comment in get_replacement_timebucket_function())*/ Assert(list_length(new_func->args) == 4); /* Change parameter order of origin and timezone */ ListCell lc = new_func->args->elements[2]; new_func->args->elements[2] = new_func->args->elements[3]; new_func->args->elements[3] = lc; } return (Node *) new_func; } } else if (IsA(node, Query)) { /* Recurse into subselects */ Query *query = castNode(Query, node); return (Node *) query_tree_mutator(query, cagg_user_query_mutator, context, 0); } return expression_tree_mutator(node, cagg_user_query_mutator, context); } /* * Rewrite the given CAgg view and replace the bucket function */ static void continuous_agg_rewrite_view(Oid view_oid, const ContinuousAgg *cagg, TimeBucketInfoContext *context) { int sec_ctx; Oid uid, saved_uid; Relation direct_view_rel = relation_open(view_oid, AccessShareLock); Query *direct_query = copyObject(get_view_query(direct_view_rel)); /* Keep lock until end of transaction. */ relation_close(direct_view_rel, NoLock); RemoveRangeTableEntries(direct_query); /* Update bucket function in CAgg query */ Query *updated_direct_query = (Query *) cagg_user_query_mutator((Node *) direct_query, context); /* Store updated CAgg query */ SWITCH_TO_TS_USER(NameStr(cagg->data.user_view_schema), uid, saved_uid, sec_ctx); StoreViewQuery(view_oid, updated_direct_query, true); CommandCounterIncrement(); RESTORE_USER(uid, saved_uid, sec_ctx); } /* * Replace the bucket function in the CAgg view definition */ static void continuous_agg_replace_function(const ContinuousAgg *cagg, Oid function_to_replace, bool origin_added_during_migration, bool need_parameter_order_change) { TimeBucketInfoContext context = { 0 }; context.cagg = cagg; context.function_to_replace = function_to_replace; context.origin_added_during_migration = origin_added_during_migration; context.need_parameter_order_change = need_parameter_order_change; /* Rewrite the direct_view */ Oid direct_view_oid = ts_get_relation_relid(NameStr(cagg->data.direct_view_schema), NameStr(cagg->data.direct_view_name), false); continuous_agg_rewrite_view(direct_view_oid, cagg, &context); /* Rewrite the partial_view */ Oid partial_view_oid = ts_get_relation_relid(NameStr(cagg->data.partial_view_schema), NameStr(cagg->data.partial_view_name), false); continuous_agg_rewrite_view(partial_view_oid, cagg, &context); /* Rewrite the user facing view if needed */ if (!cagg->data.materialized_only) { Oid user_view_oid = ts_get_relation_relid(NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name), false); continuous_agg_rewrite_view(user_view_oid, cagg, &context); } } /* * Get the default origin value for time_bucket to be compatible with * the default origin of time_bucket_ng. */ static TimestampTz continuous_agg_get_default_origin(Oid new_bucket_function) { Assert(OidIsValid(new_bucket_function)); Oid bucket_function_rettype = get_func_rettype(new_bucket_function); Assert(OidIsValid(bucket_function_rettype)); Datum origin; /* Get default origin for the given datatype */ if (bucket_function_rettype == TIMESTAMPTZOID) { origin = DirectFunctionCall3(timestamptz_in, CStringGetDatum(TIME_BUCKET_NG_DEFAULT_ORIGIN_TIMESTAMPSTAMPTZ), ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1)); } else if (bucket_function_rettype == TIMESTAMPOID) { origin = DirectFunctionCall1(timestamp_timestamptz, DirectFunctionCall3(timestamp_in, CStringGetDatum( TIME_BUCKET_NG_DEFAULT_ORIGIN_TIMESTAMP), ObjectIdGetDatum(InvalidOid), Int32GetDatum(-1))); } else if (bucket_function_rettype == DATEOID) { origin = DirectFunctionCall1(date_timestamptz, DirectFunctionCall1(date_in, CStringGetDatum( TIME_BUCKET_NG_DEFAULT_ORIGIN_DATE))); } else { elog(ERROR, "unable to determine default origin for time_bucket of type %s", format_type_extended(bucket_function_rettype, -1, 0)); pg_unreachable(); } return DatumGetTimestampTz(origin); } /* * Migrate a CAgg which is using time_bucket_ng as a bucket function into * a CAgg which is using the regular time_bucket function. */ Datum continuous_agg_migrate_to_time_bucket(PG_FUNCTION_ARGS) { Oid cagg_relid = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); ts_feature_flag_check(FEATURE_CAGG); ContinuousAgg *cagg = cagg_get_by_relid_or_fail(cagg_relid); Assert(cagg_relid == cagg->relid); /* Allow migration only if owner */ if (!object_ownercheck(RelationRelationId, cagg->relid, GetUserId())) aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(get_rel_relkind(cagg->relid)), get_rel_name(cagg->relid)); PreventCommandIfReadOnly("continuous_agg_migrate_to_time_bucket"); /* Allow migration only on finalized CAggs */ if (!ContinuousAggIsFinalized(cagg)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("operation not supported on continuous aggregates that are not " "finalized"), errhint("Run \"CALL cagg_migrate('%s.%s');\" to migrate to the new " "format.", NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name)))); } /* Ensure CAgg is not updated/deleted by somebody else concurrently. Should be moved * into the scanner since the CAgg can be deleted after we found it in the catalog. */ Assert(OidIsValid(cagg_relid)); LockRelationOid(cagg_relid, ShareUpdateExclusiveLock); /* Get the new time_bucket replacement function */ bool need_parameter_order_change; Oid new_bucket_function = get_replacement_timebucket_function(cagg, &need_parameter_order_change); Oid old_bucket_function = cagg->bucket_function->bucket_function; Assert(OidIsValid(new_bucket_function)); Assert(new_bucket_function != cagg->bucket_function->bucket_function); /* Update the time_bucket_fuction */ cagg->bucket_function->bucket_function = new_bucket_function; bool origin_added_during_migration = false; /* Set new origin if not already present in the function definition. This is needed since * time_bucket and time_bucket_ng use different origin default values. */ if (cagg->bucket_function->bucket_time_based && TIMESTAMP_NOT_FINITE(cagg->bucket_function->bucket_time_origin)) { cagg->bucket_function->bucket_time_origin = continuous_agg_get_default_origin(new_bucket_function); origin_added_during_migration = true; } /* Update the catalog */ replace_time_bucket_function_in_catalog(cagg); /* Fetch new CAgg definition from catalog */ ContinuousAgg PG_USED_FOR_ASSERTS_ONLY *new_cagg_definition = cagg_get_by_relid_or_fail(cagg_relid); Assert(new_cagg_definition->bucket_function->bucket_function == new_bucket_function); Assert(cagg->bucket_function->bucket_time_origin == new_cagg_definition->bucket_function->bucket_time_origin); /* Modify the CAgg view definition */ continuous_agg_replace_function(cagg, old_bucket_function, origin_added_during_migration, need_parameter_order_change); /* The migration is a procedure, no return value is expected */ PG_RETURN_VOID(); } /* Get the Oid of the direct view of the CAgg. We cannot use the TimescaleDB internal * functions such as ts_continuous_agg_find_by_mat_hypertable_id() at this point since this * function can be called during an extension upgrade and ts_catalog_get() does not work. */ static Oid get_direct_view_oid(int32 mat_hypertable_id) { RangeVar *ts_cagg = makeRangeVar(CATALOG_SCHEMA_NAME, CONTINUOUS_AGG_TABLE_NAME, -1 /* taken location unknown */); Relation cagg_rel = relation_openrv_extended(ts_cagg, AccessShareLock, /* missing ok */ true); RangeVar *ts_cagg_idx = makeRangeVar(CATALOG_SCHEMA_NAME, TS_CAGG_CATALOG_IDX, -1 /* taken location unknown */); Relation cagg_idx_rel = relation_openrv_extended(ts_cagg_idx, AccessShareLock, /* missing ok */ true); /* Prepare relation scan */ TupleTableSlot *slot = table_slot_create(cagg_rel, NULL); ScanKeyData scankeys[1]; ScanKeyEntryInitialize(&scankeys[0], 0, 1, BTEqualStrategyNumber, InvalidOid, InvalidOid, F_INT4EQ, Int32GetDatum(mat_hypertable_id)); /* Prepare index scan */ PushActiveSnapshot(GetTransactionSnapshot()); IndexScanDesc indexscan = index_beginscan_compat(cagg_rel, cagg_idx_rel, GetActiveSnapshot(), NULL, 1, 0); index_rescan(indexscan, scankeys, 1, NULL, 0); /* Read tuple from relation */ bool got_next_slot = index_getnext_slot(indexscan, ForwardScanDirection, slot); if (!got_next_slot) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid materialized hypertable ID: %d", mat_hypertable_id))); bool is_null = false; /* We use the view_schema and view_name to get data from the system catalog. Even char pointers * are passed to the catalog, it calls namehashfast() internally, which assumes that a char of * NAMEDATALEN is allocated. */ NameData view_schema_name; NameData view_name_name; /* We need to get the attribute names dynamically since this function can be called during an * upgrade and the fixed attribution numbers (i.e., Anum_continuous_agg_direct_view_schema) can * be different. */ AttrNumber direct_view_schema_attr = get_attnum(cagg_rel->rd_id, "direct_view_schema"); Ensure(direct_view_schema_attr != InvalidAttrNumber, "unable to get attribute number for direct_view_schema"); AttrNumber direct_view_name_attr = get_attnum(cagg_rel->rd_id, "direct_view_name"); Ensure(direct_view_name_attr != InvalidAttrNumber, "unable to get attribute number for direct_view_name"); char *view_schema = DatumGetCString(slot_getattr(slot, direct_view_schema_attr, &is_null)); Ensure(!is_null, "unable to get view schema for oid %d", mat_hypertable_id); Assert(view_schema != NULL); namestrcpy(&view_schema_name, view_schema); char *view_name = DatumGetCString(slot_getattr(slot, direct_view_name_attr, &is_null)); Ensure(!is_null, "unable to get view name for oid %d", mat_hypertable_id); Assert(view_name != NULL); namestrcpy(&view_name_name, view_name); got_next_slot = index_getnext_slot(indexscan, ForwardScanDirection, slot); Ensure(!got_next_slot, "found duplicate definitions for CAgg mat_ht %d", mat_hypertable_id); /* End relation scan */ index_endscan(indexscan); ExecDropSingleTupleTableSlot(slot); relation_close(cagg_rel, AccessShareLock); relation_close(cagg_idx_rel, AccessShareLock); PopActiveSnapshot(); /* Get Oid of user view */ Oid direct_view_oid = ts_get_relation_relid(NameStr(view_schema_name), NameStr(view_name_name), false); Assert(OidIsValid(direct_view_oid)); return direct_view_oid; } enum { Anum_cagg_bucket_function_oid = 1, Anum_cagg_bucket_function_width, Anum_cagg_bucket_function_origin, Anum_cagg_bucket_function_offset, Anum_cagg_bucket_function_timezone, Anum_cagg_bucket_function_fixed_width, _Anum_cagg_bucket_function_max }; #define Natts_cagg_bucket_function (_Anum_cagg_bucket_function_max - 1) static Datum create_cagg_get_bucket_function_datum(TupleDesc tupdesc, ContinuousAggBucketFunction *bf) { NullableDatum datums[Natts_cagg_bucket_function] = { { 0 } }; HeapTuple tuple; char *bucket_origin = NULL; char *bucket_offset = NULL; char *bucket_width = NULL; if (IS_TIME_BUCKET_INFO_TIME_BASED(bf)) { /* Bucketing on time */ Assert(bf->bucket_time_width != NULL); bucket_width = DatumGetCString( DirectFunctionCall1(interval_out, IntervalPGetDatum(bf->bucket_time_width))); if (!TIMESTAMP_NOT_FINITE(bf->bucket_time_origin)) { bucket_origin = DatumGetCString( DirectFunctionCall1(timestamptz_out, TimestampTzGetDatum(bf->bucket_time_origin))); } if (bf->bucket_time_offset != NULL) { bucket_offset = DatumGetCString( DirectFunctionCall1(interval_out, IntervalPGetDatum(bf->bucket_time_offset))); } } else { /* Bucketing on integers */ bucket_width = palloc0((MAXINT8LEN + 1) * sizeof(char)); pg_lltoa(bf->bucket_integer_width, bucket_width); /* Integer buckets with origin are not supported, so nothing to do. */ Assert(bucket_origin == NULL); if (bf->bucket_integer_offset != 0) { bucket_offset = palloc0((MAXINT8LEN + 1) * sizeof(char)); pg_lltoa(bf->bucket_integer_offset, bucket_offset); } } tupdesc = BlessTupleDesc(tupdesc); ts_datum_set_objectid(Anum_cagg_bucket_function_oid, datums, bf->bucket_function); ts_datum_set_text_from_cstring(Anum_cagg_bucket_function_width, datums, bucket_width); ts_datum_set_text_from_cstring(Anum_cagg_bucket_function_origin, datums, bucket_origin); ts_datum_set_text_from_cstring(Anum_cagg_bucket_function_offset, datums, bucket_offset); ts_datum_set_text_from_cstring(Anum_cagg_bucket_function_timezone, datums, bf->bucket_time_timezone); ts_datum_set_bool(Anum_cagg_bucket_function_fixed_width, datums, bf->bucket_fixed_interval, false); Assert(tupdesc->natts == Natts_cagg_validate_query); tuple = ts_heap_form_tuple(tupdesc, datums); return HeapTupleGetDatum(tuple); } /* * Get the bucket function information for the given materialized hypertable id. * * When running `cagg_get_bucket_function_info` the function returns the following fields: * - oid: The Oid of the bucket function * - width: The width of the bucket function * - origin: The origin of the bucket function * - offset: The offset of the bucket function * - timezone: The timezone of the bucket function * - fixed_width: Is the bucket width fixed * * When running `cagg_get_bucket_function` the function returns the following fields: * - oid: The Oid of the bucket function */ static Datum cagg_get_bucket_function_datum(int32 mat_hypertable_id, FunctionCallInfo fcinfo) { Oid direct_view_oid = get_direct_view_oid(mat_hypertable_id); TupleDesc tupdesc; if (fcinfo != NULL && get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) elog(ERROR, "function returning record called in context that cannot accept type record"); ContinuousAggBucketFunction *bf = ts_cagg_get_bucket_function_info(direct_view_oid); if (!OidIsValid(bf->bucket_function)) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("time_bucket function not found in CAgg definition for " "mat_ht_id: %d", mat_hypertable_id))); pg_unreachable(); } if (fcinfo != NULL) return create_cagg_get_bucket_function_datum(tupdesc, bf); return ObjectIdGetDatum(bf->bucket_function); } /* * This function returns the `time_bucket` function Oid in the user view definition * of a given materialization hupertable. * * NOTE: this function is deprecated and should be removed in the future, use * `cagg_get_bucket_function_info` instead. */ Datum continuous_agg_get_bucket_function(PG_FUNCTION_ARGS) { /* Return the oid of the bucket function */ PG_RETURN_DATUM(cagg_get_bucket_function_datum(PG_GETARG_INT32(0), NULL)); } /* * This function returns all information about the `time_bucket` function of a given * materialization hypertable using the user view definition stored in Postgres catalog. */ Datum continuous_agg_get_bucket_function_info(PG_FUNCTION_ARGS) { /* Return all bucket function info */ PG_RETURN_DATUM(cagg_get_bucket_function_datum(PG_GETARG_INT32(0), fcinfo)); } ���������������������������timescaledb-2.23.0/tsl/src/continuous_aggs/utils.h��������������������������������������������������0000664�0000000�0000000�00000001254�15100345067�0022166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <catalog/pg_collation.h> #include <funcapi.h> #include <parser/analyze.h> #include <parser/parser.h> #include <tcop/tcopprot.h> #include "compat/compat.h" #include "common.h" extern Datum continuous_agg_validate_query(PG_FUNCTION_ARGS); extern Datum continuous_agg_migrate_to_time_bucket(PG_FUNCTION_ARGS); extern Datum continuous_agg_get_bucket_function(PG_FUNCTION_ARGS); extern Datum continuous_agg_get_bucket_function_info(PG_FUNCTION_ARGS); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/import/������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016756�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/import/CMakeLists.txt����������������������������������������������������0000664�0000000�0000000�00000000742�15100345067�0021521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES) if(USE_UMASH) list(APPEND SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/umash.c) endif() if(SOURCES) # Disable clang-tidy for imported code add_library(target_no_static_code_analysis OBJECT ${SOURCES}) set_target_properties(target_no_static_code_analysis PROPERTIES C_CLANG_TIDY "") target_sources(${TSL_LIBRARY_NAME} PRIVATE $<TARGET_OBJECTS:target_no_static_code_analysis>) endif() ������������������������������timescaledb-2.23.0/tsl/src/import/ts_like_match.c���������������������������������������������������0000664�0000000�0000000�00000014007�15100345067�0021732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the PostgreSQL database, which is licensed under the open-source * PostgreSQL License. Please see the NOTICE at the top level * directory for a copy of the PostgreSQL License. * * This is a copy of backend/utils/adt/like_match.c from PG 15.0, git commit sha * 2a7ce2e2ce474504a707ec03e128fde66cfb8b48. * It has one modification: the check_stack_depth() check is moved to happen * before recursion to simplify the non-recursive code path. */ /*-------------------- * Match text and pattern, return LIKE_TRUE, LIKE_FALSE, or LIKE_ABORT. * * LIKE_TRUE: they match * LIKE_FALSE: they don't match * LIKE_ABORT: not only don't they match, but the text is too short. * * If LIKE_ABORT is returned, then no suffix of the text can match the * pattern either, so an upper-level % scan can stop scanning now. *-------------------- */ #ifdef MATCH_LOWER #define GETCHAR(t) MATCH_LOWER(t) #else #define GETCHAR(t) (t) #endif static int MatchText(const char *t, int tlen, const char *p, int plen) { /* Fast path for match-everything pattern */ if (plen == 1 && *p == '%') return LIKE_TRUE; /* * In this loop, we advance by char when matching wildcards (and thus on * recursive entry to this function we are properly char-synced). On other * occasions it is safe to advance by byte, as the text and pattern will * be in lockstep. This allows us to perform all comparisons between the * text and pattern on a byte by byte basis, even for multi-byte * encodings. */ while (tlen > 0 && plen > 0) { if (*p == '\\') { /* Next pattern byte must match literally, whatever it is */ NextByte(p, plen); /* ... and there had better be one, per SQL standard */ if (plen <= 0) ereport(ERROR, (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE), errmsg("LIKE pattern must not end with escape character"))); if (GETCHAR(*p) != GETCHAR(*t)) return LIKE_FALSE; } else if (*p == '%') { char firstpat; /* * % processing is essentially a search for a text position at * which the remainder of the text matches the remainder of the * pattern, using a recursive call to check each potential match. * * If there are wildcards immediately following the %, we can skip * over them first, using the idea that any sequence of N _'s and * one or more %'s is equivalent to N _'s and one % (ie, it will * match any sequence of at least N text characters). In this way * we will always run the recursive search loop using a pattern * fragment that begins with a literal character-to-match, thereby * not recursing more than we have to. */ NextByte(p, plen); while (plen > 0) { if (*p == '%') NextByte(p, plen); else if (*p == '_') { /* If not enough text left to match the pattern, ABORT */ if (tlen <= 0) return LIKE_ABORT; NextChar(t, tlen); NextByte(p, plen); } else break; /* Reached a non-wildcard pattern char */ } /* * If we're at end of pattern, match: we have a trailing % which * matches any remaining text string. */ if (plen <= 0) return LIKE_TRUE; /* * Otherwise, scan for a text position at which we can match the * rest of the pattern. The first remaining pattern char is known * to be a regular or escaped literal character, so we can compare * the first pattern byte to each text byte to avoid recursing * more than we have to. This fact also guarantees that we don't * have to consider a match to the zero-length substring at the * end of the text. */ if (*p == '\\') { if (plen < 2) ereport(ERROR, (errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE), errmsg("LIKE pattern must not end with escape character"))); firstpat = GETCHAR(p[1]); } else firstpat = GETCHAR(*p); while (tlen > 0) { if (GETCHAR(*t) == firstpat) { /* Since this function recurses, it could be driven to stack overflow */ check_stack_depth(); int matched = MatchText(t, tlen, p, plen); if (matched != LIKE_FALSE) return matched; /* TRUE or ABORT */ } NextChar(t, tlen); } /* * End of text with no match, so no point in trying later places * to start matching this pattern. */ return LIKE_ABORT; } else if (*p == '_') { /* _ matches any single character, and we know there is one */ NextChar(t, tlen); NextByte(p, plen); continue; } else if (GETCHAR(*p) != GETCHAR(*t)) { /* non-wildcard pattern char fails to match text char */ return LIKE_FALSE; } /* * Pattern and text match, so advance. * * It is safe to use NextByte instead of NextChar here, even for * multi-byte character sets, because we are not following immediately * after a wildcard character. If we are in the middle of a multibyte * character, we must already have matched at least one byte of the * character from both text and pattern; so we cannot get out-of-sync * on character boundaries. And we know that no backend-legal * encoding allows ASCII characters such as '%' to appear as non-first * bytes of characters, so we won't mistakenly detect a new wildcard. */ NextByte(t, tlen); NextByte(p, plen); } if (tlen > 0) return LIKE_FALSE; /* end of pattern, but not of text */ /* * End of text, but perhaps not of pattern. Match iff the remaining * pattern can match a zero-length string, ie, it's zero or more %'s. */ while (plen > 0 && *p == '%') NextByte(p, plen); if (plen <= 0) return LIKE_TRUE; /* * End of text with no match, so no point in trying later places to start * matching this pattern. */ return LIKE_ABORT; } /* MatchText() */ #ifdef CHAREQ #undef CHAREQ #endif #undef NextChar #undef CopyAdvChar #undef MatchText #undef GETCHAR #ifdef MATCH_LOWER #undef MATCH_LOWER #endif �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/import/umash.c�����������������������������������������������������������0000664�0000000�0000000�00000112375�15100345067�0020250�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the UMASH hash implementation at https://github.com/backtrace-labs/umash. * * This is a copy of umash.c, git commit sha * fc4c5b6ca1f06c308e96c43aa080bd766238e092. */ #include "umash.h" /* * UMASH is distributed under the MIT license. * * SPDX-License-Identifier: MIT * * Copyright 2020-2022 Backtrace I/O, Inc. * Copyright 2022 Paul Khuong * Copyright 2022 Dougall Johnson * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, copy, * modify, merge, publish, distribute, sublicense, and/or sell copies * of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #if !defined(UMASH_TEST_ONLY) && !defined(NDEBUG) #define NDEBUG #endif /** * -DUMASH_LONG_INPUTS=0 to disable the routine specialised for long * inputs, and -DUMASH_LONG_INPUTS=1 to enable it. If the variable * isn't defined, we try to probe for `umash_long.inc`: that's where * the long input routines are defined. */ #ifndef UMASH_LONG_INPUTS #ifdef __has_include #if __has_include("umash_long.inc") #define UMASH_LONG_INPUTS 1 #endif /* __has_include() */ #endif /* __has_include */ #ifndef UMASH_LONG_INPUTS #define UMASH_LONG_INPUTS 0 #endif /* !UMASH_LONG_INPUTS */ #endif /* !UMASH_LONG_INPUTS */ /* * Default to dynamically dispatching implementations on x86-64 * (there's nothing to dispatch on aarch64). */ #ifndef UMASH_DYNAMIC_DISPATCH #ifdef __x86_64__ #define UMASH_DYNAMIC_DISPATCH 1 #else #define UMASH_DYNAMIC_DISPATCH 0 #endif #endif /* * Enable inline assembly by default when building with recent GCC or * compatible compilers. It should always be safe to disable this * option, although there may be a performance cost. */ #ifndef UMASH_INLINE_ASM #if defined(__clang__) /* * We need clang 8+ for output flags, and 10+ for relaxed vector * constraints. */ #if __clang_major__ >= 10 #define UMASH_INLINE_ASM 1 #else #define UMASH_INLINE_ASM 0 #endif /* __clang_major__ */ #elif defined(__GNUC__) #if __GNUC__ >= 6 #define UMASH_INLINE_ASM 1 #else #define UMASH_INLINE_ASM 0 #endif /* __GNUC__ */ #else #define UMASH_INLINE_ASM 0 #endif #endif #include <assert.h> #include <string.h> #ifdef __PCLMUL__ /* If we have access to x86 PCLMUL (and some basic SSE). */ #include <immintrin.h> /* We only use 128-bit vector, as pairs of 64-bit integers. */ typedef __m128i v128; #define V128_ZERO { 0 }; static inline v128 v128_create(uint64_t lo, uint64_t hi) { return _mm_set_epi64x(hi, lo); } /* Shift each 64-bit lane left by one bit. */ static inline v128 v128_shift(v128 x) { return _mm_add_epi64(x, x); } /* Computes the 128-bit carryless product of x and y. */ static inline v128 v128_clmul(uint64_t x, uint64_t y) { return _mm_clmulepi64_si128(_mm_cvtsi64_si128(x), _mm_cvtsi64_si128(y), 0); } /* Computes the 128-bit carryless product of the high and low halves of x. */ static inline v128 v128_clmul_cross(v128 x) { return _mm_clmulepi64_si128(x, x, 1); } #elif defined(__ARM_FEATURE_CRYPTO) #include <arm_neon.h> typedef uint64x2_t v128; #define V128_ZERO { 0 }; static inline v128 v128_create(uint64_t lo, uint64_t hi) { return vcombine_u64(vcreate_u64(lo), vcreate_u64(hi)); } static inline v128 v128_shift(v128 x) { return vshlq_n_u64(x, 1); } static inline v128 v128_clmul(uint64_t x, uint64_t y) { return vreinterpretq_u64_p128(vmull_p64(x, y)); } static inline v128 v128_clmul_cross(v128 x) { v128 swapped = vextq_u64(x, x, 1); #if UMASH_INLINE_ASM /* Keep the result out of GPRs. */ __asm__("" : "+w"(swapped)); #endif return v128_clmul(vgetq_lane_u64(x, 0), vgetq_lane_u64(swapped, 0)); } #else #error \ "Unsupported platform: umash requires CLMUL (-mpclmul) on x86-64, or crypto (-march=...+crypto) extensions on aarch64." #endif /* * #define UMASH_STAP_PROBE=1 to insert probe points in public UMASH * functions. * * This functionality depends on Systemtap's SDT header file. */ #if defined(UMASH_STAP_PROBE) && UMASH_STAP_PROBE #include <sys/sdt.h> #else #define DTRACE_PROBE1(lib, name, a0) #define DTRACE_PROBE2(lib, name, a0, a1) #define DTRACE_PROBE3(lib, name, a0, a1, a2) #define DTRACE_PROBE4(lib, name, a0, a1, a2, a3) #endif /* * #define UMASH_SECTION="special_section" to emit all UMASH symbols * in the `special_section` ELF section. */ #if defined(UMASH_SECTION) && defined(__GNUC__) #define FN __attribute__((__section__(UMASH_SECTION))) #else #define FN #endif /* * Defining UMASH_TEST_ONLY switches to a debug build with internal * symbols exposed. */ #ifdef UMASH_TEST_ONLY #define TEST_DEF FN #include "t/umash_test_only.h" #else #define TEST_DEF static FN #endif #ifdef __GNUC__ #define LIKELY(X) __builtin_expect(!!(X), 1) #define UNLIKELY(X) __builtin_expect(!!(X), 0) #define HOT __attribute__((__hot__)) #define COLD __attribute__((__cold__)) #else #define LIKELY(X) X #define UNLIKELY(X) X #define HOT #define COLD #endif #define ARRAY_SIZE(ARR) (sizeof(ARR) / sizeof(ARR[0])) #define BLOCK_SIZE (sizeof(uint64_t) * UMASH_OH_PARAM_COUNT) /* * We derive independent short hashes by offsetting the constant array * by four u64s. In theory, any positive even number works, but this * is the constant we used in an earlier incarnation, and it works. */ #define OH_SHORT_HASH_SHIFT 4 /* Incremental UMASH consumes 16 bytes at a time. */ #define INCREMENTAL_GRANULARITY 16 /** * Modular arithmetic utilities. * * The code below uses GCC extensions. It should be possible to add * support for other compilers. */ #if !defined(__x86_64__) || !UMASH_INLINE_ASM static inline void mul128(uint64_t x, uint64_t y, uint64_t *hi, uint64_t *lo) { __uint128_t product = x; product *= y; *hi = product >> 64; *lo = product; return; } #else static inline void mul128(uint64_t x, uint64_t y, uint64_t *hi, uint64_t *lo) { uint64_t mulhi, mullo; __asm__("mul %3" : "=a"(mullo), "=d"(mulhi) : "%a"(x), "r"(y) : "cc"); *hi = mulhi; *lo = mullo; return; } #endif TEST_DEF inline uint64_t add_mod_fast(uint64_t x, uint64_t y) { unsigned long long sum; /* If `sum` overflows, `sum + 8` does not. */ return (__builtin_uaddll_overflow(x, y, &sum) ? sum + 8 : sum); } static FN COLD uint64_t add_mod_slow_slow_path(uint64_t sum, uint64_t fixup) { /* Reduce sum, mod 2**64 - 8. */ sum = (sum >= (uint64_t)-8) ? sum + 8 : sum; /* sum < 2**64 - 8, so this doesn't overflow. */ sum += fixup; /* Reduce again. */ sum = (sum >= (uint64_t)-8) ? sum + 8 : sum; return sum; } TEST_DEF inline uint64_t add_mod_slow(uint64_t x, uint64_t y) { unsigned long long sum; uint64_t fixup = 0; /* x + y \equiv sum + fixup */ if (__builtin_uaddll_overflow(x, y, &sum)) fixup = 8; /* * We must ensure `sum + fixup < 2**64 - 8`. * * We want a conditional branch here, but not in the * overflowing add: overflows happen roughly half the time on * pseudorandom inputs, but `sum < 2**64 - 16` is almost * always true, for pseudorandom `sum`. */ if (LIKELY(sum < (uint64_t)-16)) return sum + fixup; #ifdef UMASH_INLINE_ASM /* * Some compilers like to compile the likely branch above with * conditional moves or predication. Insert a compiler barrier * in the slow path here to force a branch. */ __asm__("" : "+r"(sum)); #endif return add_mod_slow_slow_path(sum, fixup); } TEST_DEF inline uint64_t mul_mod_fast(uint64_t m, uint64_t x) { uint64_t hi, lo; mul128(m, x, &hi, &lo); return add_mod_fast(lo, 8 * hi); } TEST_DEF inline uint64_t horner_double_update(uint64_t acc, uint64_t m0, uint64_t m1, uint64_t x, uint64_t y) { acc = add_mod_fast(acc, x); return add_mod_slow(mul_mod_fast(m0, acc), mul_mod_fast(m1, y)); } /** * Salsa20 stream generator, used to derive struct umash_param. * * Slightly prettified version of D. J. Bernstein's public domain NaCL * (version 20110121), without paying any attention to constant time * execution or any other side-channel. */ static inline uint32_t rotate(uint32_t u, int c) { return (u << c) | (u >> (32 - c)); } static inline uint32_t load_littleendian(const void *buf) { uint32_t ret = 0; uint8_t x[4]; memcpy(x, buf, sizeof(x)); for (size_t i = 0; i < 4; i++) ret |= (uint32_t)x[i] << (8 * i); return ret; } static inline void store_littleendian(void *dst, uint32_t u) { for (size_t i = 0; i < 4; i++) { uint8_t lo = u; memcpy(dst, &lo, 1); u >>= 8; dst = (char *)dst + 1; } return; } static FN void core_salsa20(char *out, const uint8_t in[static 16], const uint8_t key[static 32], const uint8_t constant[16]) { enum { ROUNDS = 20 }; uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15; uint32_t j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15; j0 = x0 = load_littleendian(constant + 0); j1 = x1 = load_littleendian(key + 0); j2 = x2 = load_littleendian(key + 4); j3 = x3 = load_littleendian(key + 8); j4 = x4 = load_littleendian(key + 12); j5 = x5 = load_littleendian(constant + 4); j6 = x6 = load_littleendian(in + 0); j7 = x7 = load_littleendian(in + 4); j8 = x8 = load_littleendian(in + 8); j9 = x9 = load_littleendian(in + 12); j10 = x10 = load_littleendian(constant + 8); j11 = x11 = load_littleendian(key + 16); j12 = x12 = load_littleendian(key + 20); j13 = x13 = load_littleendian(key + 24); j14 = x14 = load_littleendian(key + 28); j15 = x15 = load_littleendian(constant + 12); for (size_t i = 0; i < ROUNDS; i += 2) { x4 ^= rotate(x0 + x12, 7); x8 ^= rotate(x4 + x0, 9); x12 ^= rotate(x8 + x4, 13); x0 ^= rotate(x12 + x8, 18); x9 ^= rotate(x5 + x1, 7); x13 ^= rotate(x9 + x5, 9); x1 ^= rotate(x13 + x9, 13); x5 ^= rotate(x1 + x13, 18); x14 ^= rotate(x10 + x6, 7); x2 ^= rotate(x14 + x10, 9); x6 ^= rotate(x2 + x14, 13); x10 ^= rotate(x6 + x2, 18); x3 ^= rotate(x15 + x11, 7); x7 ^= rotate(x3 + x15, 9); x11 ^= rotate(x7 + x3, 13); x15 ^= rotate(x11 + x7, 18); x1 ^= rotate(x0 + x3, 7); x2 ^= rotate(x1 + x0, 9); x3 ^= rotate(x2 + x1, 13); x0 ^= rotate(x3 + x2, 18); x6 ^= rotate(x5 + x4, 7); x7 ^= rotate(x6 + x5, 9); x4 ^= rotate(x7 + x6, 13); x5 ^= rotate(x4 + x7, 18); x11 ^= rotate(x10 + x9, 7); x8 ^= rotate(x11 + x10, 9); x9 ^= rotate(x8 + x11, 13); x10 ^= rotate(x9 + x8, 18); x12 ^= rotate(x15 + x14, 7); x13 ^= rotate(x12 + x15, 9); x14 ^= rotate(x13 + x12, 13); x15 ^= rotate(x14 + x13, 18); } x0 += j0; x1 += j1; x2 += j2; x3 += j3; x4 += j4; x5 += j5; x6 += j6; x7 += j7; x8 += j8; x9 += j9; x10 += j10; x11 += j11; x12 += j12; x13 += j13; x14 += j14; x15 += j15; store_littleendian(out + 0, x0); store_littleendian(out + 4, x1); store_littleendian(out + 8, x2); store_littleendian(out + 12, x3); store_littleendian(out + 16, x4); store_littleendian(out + 20, x5); store_littleendian(out + 24, x6); store_littleendian(out + 28, x7); store_littleendian(out + 32, x8); store_littleendian(out + 36, x9); store_littleendian(out + 40, x10); store_littleendian(out + 44, x11); store_littleendian(out + 48, x12); store_littleendian(out + 52, x13); store_littleendian(out + 56, x14); store_littleendian(out + 60, x15); return; } TEST_DEF void salsa20_stream( void *dst, size_t len, const uint8_t nonce[static 8], const uint8_t key[static 32]) { static const uint8_t sigma[16] = "expand 32-byte k"; uint8_t in[16]; if (len == 0) return; memcpy(in, nonce, 8); memset(in + 8, 0, 8); while (len >= 64) { unsigned int u; core_salsa20(dst, in, key, sigma); u = 1; for (size_t i = 8; i < 16; i++) { u += in[i]; in[i] = u; u >>= 8; } dst = (char *)dst + 64; len -= 64; } if (len > 0) { char block[64]; core_salsa20(block, in, key, sigma); memcpy(dst, block, len); } return; } #if defined(UMASH_TEST_ONLY) || UMASH_LONG_INPUTS #include "umash_long.inc" #endif /** * OH block compression. */ TEST_DEF struct umash_oh oh_varblock(const uint64_t *params, uint64_t tag, const void *block, size_t n_bytes) { struct umash_oh ret; v128 acc = V128_ZERO; /* The final block processes `remaining > 0` bytes. */ size_t remaining = 1 + ((n_bytes - 1) % sizeof(v128)); size_t end_full_pairs = (n_bytes - remaining) / sizeof(uint64_t); const void *last_ptr = (const char *)block + n_bytes - sizeof(v128); size_t i; for (i = 0; i < end_full_pairs; i += 2) { v128 x, k; memcpy(&x, block, sizeof(x)); block = (const char *)block + sizeof(x); memcpy(&k, ¶ms[i], sizeof(k)); x ^= k; acc ^= v128_clmul_cross(x); } memcpy(&ret, &acc, sizeof(ret)); /* Compress the final (potentially partial) pair. */ { uint64_t x, y, enh_hi, enh_lo; memcpy(&x, last_ptr, sizeof(x)); last_ptr = (const char *)last_ptr + sizeof(x); memcpy(&y, last_ptr, sizeof(y)); x += params[i]; y += params[i + 1]; mul128(x, y, &enh_hi, &enh_lo); enh_hi += tag; ret.bits[0] ^= enh_lo; ret.bits[1] ^= enh_hi ^ enh_lo; } return ret; } TEST_DEF void oh_varblock_fprint(struct umash_oh dst[static restrict 2], const uint64_t *restrict params, uint64_t tag, const void *restrict block, size_t n_bytes) { v128 acc = V128_ZERO; /* Base umash */ v128 acc_shifted = V128_ZERO; /* Accumulates shifted values */ v128 lrc; /* The final block processes `remaining > 0` bytes. */ size_t remaining = 1 + ((n_bytes - 1) % sizeof(v128)); size_t end_full_pairs = (n_bytes - remaining) / sizeof(uint64_t); const void *last_ptr = (const char *)block + n_bytes - sizeof(v128); size_t i; lrc = v128_create(params[UMASH_OH_PARAM_COUNT], params[UMASH_OH_PARAM_COUNT + 1]); for (i = 0; i < end_full_pairs; i += 2) { v128 x, k; memcpy(&x, block, sizeof(x)); block = (const char *)block + sizeof(x); memcpy(&k, ¶ms[i], sizeof(k)); x ^= k; lrc ^= x; x = v128_clmul_cross(x); acc ^= x; if (i + 2 >= end_full_pairs) break; acc_shifted ^= x; acc_shifted = v128_shift(acc_shifted); } /* * Update the LRC for the last chunk before treating it * specially. */ { v128 x, k; memcpy(&x, last_ptr, sizeof(x)); memcpy(&k, ¶ms[end_full_pairs], sizeof(k)); lrc ^= x ^ k; } acc_shifted ^= acc; acc_shifted = v128_shift(acc_shifted); acc_shifted ^= v128_clmul_cross(lrc); memcpy(&dst[0], &acc, sizeof(dst[0])); memcpy(&dst[1], &acc_shifted, sizeof(dst[1])); { uint64_t x, y, kx, ky, enh_hi, enh_lo; memcpy(&x, last_ptr, sizeof(x)); last_ptr = (const char *)last_ptr + sizeof(x); memcpy(&y, last_ptr, sizeof(y)); kx = x + params[end_full_pairs]; ky = y + params[end_full_pairs + 1]; mul128(kx, ky, &enh_hi, &enh_lo); enh_hi += tag; enh_hi ^= enh_lo; dst[0].bits[0] ^= enh_lo; dst[0].bits[1] ^= enh_hi; dst[1].bits[0] ^= enh_lo; dst[1].bits[1] ^= enh_hi; } return; } /** * Returns `then` if `cond` is true, `otherwise` if false. * * This noise helps compiler emit conditional moves. */ static inline const void * select_ptr(bool cond, const void *then, const void *otherwise) { const char *ret; #if UMASH_INLINE_ASM /* Force strict evaluation of both arguments. */ __asm__("" ::"r"(then), "r"(otherwise)); #endif ret = (cond) ? then : otherwise; #if UMASH_INLINE_ASM /* And also force the result to be materialised with a blackhole. */ __asm__("" : "+r"(ret)); #endif return ret; } /** * Short UMASH (<= 8 bytes). */ TEST_DEF inline uint64_t vec_to_u64(const void *data, size_t n_bytes) { const char zeros[2] = { 0 }; uint32_t hi, lo; /* * If there are at least 4 bytes to read, read the first 4 in * `lo`, and the last 4 in `hi`. This covers the whole range, * since `n_bytes` is at most 8. */ if (LIKELY(n_bytes >= sizeof(lo))) { memcpy(&lo, data, sizeof(lo)); memcpy(&hi, (const char *)data + n_bytes - sizeof(hi), sizeof(hi)); } else { /* 0 <= n_bytes < 4. Decode the size in binary. */ uint16_t word; uint8_t byte; /* * If the size is odd, load the first byte in `byte`; * otherwise, load in a zero. */ memcpy(&byte, select_ptr(n_bytes & 1, data, zeros), 1); lo = byte; /* * If the size is 2 or 3, load the last two bytes in `word`; * otherwise, load in a zero. */ memcpy(&word, select_ptr(n_bytes & 2, (const char *)data + n_bytes - 2, zeros), 2); /* * We have now read `bytes[0 ... n_bytes - 1]` * exactly once without overwriting any data. */ hi = word; } /* * Mix `hi` with the `lo` bits: SplitMix64 seems to have * trouble with the top 4 bits. */ return ((uint64_t)hi << 32) | (lo + hi); } TEST_DEF uint64_t umash_short(const uint64_t *params, uint64_t seed, const void *data, size_t n_bytes) { uint64_t h; seed += params[n_bytes]; h = vec_to_u64(data, n_bytes); h ^= h >> 30; h *= 0xbf58476d1ce4e5b9ULL; h = (h ^ seed) ^ (h >> 27); h *= 0x94d049bb133111ebULL; h ^= h >> 31; return h; } static FN struct umash_fp umash_fp_short(const uint64_t *params, uint64_t seed, const void *data, size_t n_bytes) { struct umash_fp ret; uint64_t h; ret.hash[0] = seed + params[n_bytes]; ret.hash[1] = seed + params[n_bytes + OH_SHORT_HASH_SHIFT]; h = vec_to_u64(data, n_bytes); h ^= h >> 30; h *= 0xbf58476d1ce4e5b9ULL; h ^= h >> 27; #define TAIL(i) \ do { \ ret.hash[i] ^= h; \ ret.hash[i] *= 0x94d049bb133111ebULL; \ ret.hash[i] ^= ret.hash[i] >> 31; \ } while (0) TAIL(0); TAIL(1); #undef TAIL return ret; } /** * Rotates `x` left by `n` bits. */ static inline uint64_t rotl64(uint64_t x, int n) { return (x << n) | (x >> (64 - n)); } TEST_DEF inline uint64_t finalize(uint64_t x) { return (x ^ rotl64(x, 8)) ^ rotl64(x, 33); } TEST_DEF uint64_t umash_medium(const uint64_t multipliers[static 2], const uint64_t *oh, uint64_t seed, const void *data, size_t n_bytes) { uint64_t enh_hi, enh_lo; { uint64_t x, y; memcpy(&x, data, sizeof(x)); memcpy(&y, (const char *)data + n_bytes - sizeof(y), sizeof(y)); x += oh[0]; y += oh[1]; mul128(x, y, &enh_hi, &enh_lo); enh_hi += seed ^ n_bytes; } enh_hi ^= enh_lo; return finalize(horner_double_update( /*acc=*/0, multipliers[0], multipliers[1], enh_lo, enh_hi)); } static FN struct umash_fp umash_fp_medium(const uint64_t multipliers[static 2][2], const uint64_t *oh, uint64_t seed, const void *data, size_t n_bytes) { struct umash_fp ret; const uint64_t offset = seed ^ n_bytes; uint64_t enh_hi, enh_lo; union { v128 v; uint64_t u64[2]; } mixed_lrc; uint64_t lrc[2] = { oh[UMASH_OH_PARAM_COUNT], oh[UMASH_OH_PARAM_COUNT + 1] }; uint64_t x, y; uint64_t a, b; /* Expand the 9-16 bytes to 16. */ memcpy(&x, data, sizeof(x)); memcpy(&y, (const char *)data + n_bytes - sizeof(y), sizeof(y)); a = oh[0]; b = oh[1]; lrc[0] ^= x ^ a; lrc[1] ^= y ^ b; mixed_lrc.v = v128_clmul(lrc[0], lrc[1]); a += x; b += y; mul128(a, b, &enh_hi, &enh_lo); enh_hi += offset; enh_hi ^= enh_lo; ret.hash[0] = finalize(horner_double_update( /*acc=*/0, multipliers[0][0], multipliers[0][1], enh_lo, enh_hi)); ret.hash[1] = finalize(horner_double_update(/*acc=*/0, multipliers[1][0], multipliers[1][1], enh_lo ^ mixed_lrc.u64[0], enh_hi ^ mixed_lrc.u64[1])); return ret; } TEST_DEF uint64_t umash_long(const uint64_t multipliers[static 2], const uint64_t *oh, uint64_t seed, const void *data, size_t n_bytes) { uint64_t acc = 0; /* * umash_long.inc defines this variable when the long input * routine is enabled. */ #ifdef UMASH_MULTIPLE_BLOCKS_THRESHOLD if (UNLIKELY(n_bytes >= UMASH_MULTIPLE_BLOCKS_THRESHOLD)) { size_t n_block = n_bytes / BLOCK_SIZE; const void *remaining; n_bytes %= BLOCK_SIZE; remaining = (const char *)data + (n_block * BLOCK_SIZE); acc = umash_multiple_blocks(acc, multipliers, oh, seed, data, n_block); data = remaining; if (n_bytes == 0) goto finalize; goto last_block; } #else /* Avoid warnings about the unused labels. */ if (0) { goto last_block; goto finalize; } #endif while (n_bytes > BLOCK_SIZE) { struct umash_oh compressed; compressed = oh_varblock(oh, seed, data, BLOCK_SIZE); data = (const char *)data + BLOCK_SIZE; n_bytes -= BLOCK_SIZE; acc = horner_double_update(acc, multipliers[0], multipliers[1], compressed.bits[0], compressed.bits[1]); } last_block: /* Do the final block. */ { struct umash_oh compressed; seed ^= (uint8_t)n_bytes; compressed = oh_varblock(oh, seed, data, n_bytes); acc = horner_double_update(acc, multipliers[0], multipliers[1], compressed.bits[0], compressed.bits[1]); } finalize: return finalize(acc); } TEST_DEF struct umash_fp umash_fp_long(const uint64_t multipliers[static 2][2], const uint64_t *oh, uint64_t seed, const void *data, size_t n_bytes) { struct umash_oh compressed[2]; struct umash_fp ret; uint64_t acc[2] = { 0, 0 }; #ifdef UMASH_MULTIPLE_BLOCKS_THRESHOLD if (UNLIKELY(n_bytes >= UMASH_MULTIPLE_BLOCKS_THRESHOLD)) { struct umash_fp poly = { .hash = { 0, 0 } }; size_t n_block = n_bytes / BLOCK_SIZE; const void *remaining; n_bytes %= BLOCK_SIZE; remaining = (const char *)data + (n_block * BLOCK_SIZE); poly = umash_fprint_multiple_blocks( poly, multipliers, oh, seed, data, n_block); acc[0] = poly.hash[0]; acc[1] = poly.hash[1]; data = remaining; if (n_bytes == 0) goto finalize; goto last_block; } #else /* Avoid warnings about the unused labels. */ if (0) { goto last_block; goto finalize; } #endif while (n_bytes > BLOCK_SIZE) { oh_varblock_fprint(compressed, oh, seed, data, BLOCK_SIZE); #define UPDATE(i) \ acc[i] = horner_double_update(acc[i], multipliers[i][0], multipliers[i][1], \ compressed[i].bits[0], compressed[i].bits[1]) UPDATE(0); UPDATE(1); #undef UPDATE data = (const char *)data + BLOCK_SIZE; n_bytes -= BLOCK_SIZE; } last_block: oh_varblock_fprint(compressed, oh, seed ^ (uint8_t)n_bytes, data, n_bytes); #define FINAL(i) \ do { \ acc[i] = horner_double_update(acc[i], multipliers[i][0], \ multipliers[i][1], compressed[i].bits[0], compressed[i].bits[1]); \ } while (0) FINAL(0); FINAL(1); #undef FINAL finalize: ret.hash[0] = finalize(acc[0]); ret.hash[1] = finalize(acc[1]); return ret; } static FN bool value_is_repeated(const uint64_t *values, size_t n, uint64_t needle) { for (size_t i = 0; i < n; i++) { if (values[i] == needle) return true; } return false; } FN bool umash_params_prepare(struct umash_params *params) { static const uint64_t modulo = (1UL << 61) - 1; /* * The polynomial parameters have two redundant fields (for * the pre-squared multipliers). Use them as our source of * extra entropy if needed. */ uint64_t buf[] = { params->poly[0][0], params->poly[1][0] }; size_t buf_idx = 0; #define GET_RANDOM(DST) \ do { \ if (buf_idx >= ARRAY_SIZE(buf)) \ return false; \ \ (DST) = buf[buf_idx++]; \ } while (0) /* Check the polynomial multipliers: we don't want 0s. */ for (size_t i = 0; i < ARRAY_SIZE(params->poly); i++) { uint64_t f = params->poly[i][1]; while (true) { /* * Zero out bits and use rejection sampling to * guarantee uniformity. */ f &= (1UL << 61) - 1; if (f != 0 && f < modulo) break; GET_RANDOM(f); } /* We can work in 2**64 - 8 and reduce after the fact. */ params->poly[i][0] = mul_mod_fast(f, f) % modulo; params->poly[i][1] = f; } /* Avoid repeated OH noise values. */ for (size_t i = 0; i < ARRAY_SIZE(params->oh); i++) { while (value_is_repeated(params->oh, i, params->oh[i])) GET_RANDOM(params->oh[i]); } return true; } FN void umash_params_derive(struct umash_params *params, uint64_t bits, const void *key) { uint8_t umash_key[32] = "Do not use UMASH VS adversaries."; if (key != NULL) memcpy(umash_key, key, sizeof(umash_key)); while (true) { uint8_t nonce[8]; for (size_t i = 0; i < 8; i++) nonce[i] = bits >> (8 * i); salsa20_stream(params, sizeof(*params), nonce, umash_key); if (umash_params_prepare(params)) return; /* * This should practically never fail, so really * shouldn't happen multiple times. If it does, an * infinite loop is as good as anything else. */ bits++; } } /* * Updates the polynomial state at the end of a block. */ static FN void sink_update_poly(struct umash_sink *sink) { uint64_t oh0, oh1; oh0 = sink->oh_acc.bits[0]; oh1 = sink->oh_acc.bits[1]; sink->poly_state[0].acc = horner_double_update(sink->poly_state[0].acc, sink->poly_state[0].mul[0], sink->poly_state[0].mul[1], oh0, oh1); sink->oh_acc = (struct umash_oh) { .bits = { 0 } }; if (sink->hash_wanted == 0) return; oh0 = sink->oh_twisted.acc.bits[0]; oh1 = sink->oh_twisted.acc.bits[1]; sink->poly_state[1].acc = horner_double_update(sink->poly_state[1].acc, sink->poly_state[1].mul[0], sink->poly_state[1].mul[1], oh0, oh1); sink->oh_twisted = (struct umash_twisted_oh) { .lrc = { sink->oh[UMASH_OH_PARAM_COUNT], sink->oh[UMASH_OH_PARAM_COUNT + 1] } }; return; } /* * Updates the OH state with 16 bytes of data. If `final` is true, we * are definitely consuming the last chunk in the input. */ static FN void sink_consume_buf( struct umash_sink *sink, const char buf[static INCREMENTAL_GRANULARITY], bool final) { const size_t buf_begin = sizeof(sink->buf) - INCREMENTAL_GRANULARITY; const size_t param = sink->oh_iter; const uint64_t k0 = sink->oh[param]; const uint64_t k1 = sink->oh[param + 1]; uint64_t x, y; /* Use GPR loads to avoid forwarding stalls. */ memcpy(&x, buf, sizeof(x)); memcpy(&y, buf + sizeof(x), sizeof(y)); /* All but the last 16-byte chunk of each block goes through PH. */ if (sink->oh_iter < UMASH_OH_PARAM_COUNT - 2 && !final) { v128 acc, h, twisted_acc, prev; uint64_t m0, m1; m0 = x ^ k0; m1 = y ^ k1; memcpy(&acc, &sink->oh_acc, sizeof(acc)); h = v128_clmul(m0, m1); acc ^= h; memcpy(&sink->oh_acc, &acc, sizeof(acc)); if (sink->hash_wanted == 0) goto next; sink->oh_twisted.lrc[0] ^= m0; sink->oh_twisted.lrc[1] ^= m1; memcpy(&twisted_acc, &sink->oh_twisted.acc, sizeof(twisted_acc)); memcpy(&prev, sink->oh_twisted.prev, sizeof(prev)); twisted_acc ^= prev; twisted_acc = v128_shift(twisted_acc); memcpy(&sink->oh_twisted.acc, &twisted_acc, sizeof(twisted_acc)); memcpy(&sink->oh_twisted.prev, &h, sizeof(h)); } else { /* The last chunk is combined with the size tag with ENH. */ uint64_t tag = sink->seed ^ (uint8_t)(sink->block_size + sink->bufsz); uint64_t enh_hi, enh_lo; mul128(x + k0, y + k1, &enh_hi, &enh_lo); enh_hi += tag; enh_hi ^= enh_lo; if (sink->hash_wanted != 0) { union { v128 vec; uint64_t h[2]; } lrc_hash; uint64_t lrc0, lrc1; uint64_t oh0, oh1; uint64_t oh_twisted0, oh_twisted1; lrc0 = sink->oh_twisted.lrc[0] ^ x ^ k0; lrc1 = sink->oh_twisted.lrc[1] ^ y ^ k1; lrc_hash.vec = v128_clmul(lrc0, lrc1); oh_twisted0 = sink->oh_twisted.acc.bits[0]; oh_twisted1 = sink->oh_twisted.acc.bits[1]; oh0 = sink->oh_acc.bits[0]; oh1 = sink->oh_acc.bits[1]; oh0 ^= oh_twisted0; oh0 <<= 1; oh1 ^= oh_twisted1; oh1 <<= 1; oh0 ^= lrc_hash.h[0]; oh1 ^= lrc_hash.h[1]; sink->oh_twisted.acc.bits[0] = oh0 ^ enh_lo; sink->oh_twisted.acc.bits[1] = oh1 ^ enh_hi; } sink->oh_acc.bits[0] ^= enh_lo; sink->oh_acc.bits[1] ^= enh_hi; } next: memmove(&sink->buf, buf, buf_begin); sink->block_size += sink->bufsz; sink->bufsz = 0; sink->oh_iter += 2; if (sink->oh_iter == UMASH_OH_PARAM_COUNT || final) { sink_update_poly(sink); sink->block_size = 0; sink->oh_iter = 0; } return; } /** * Hashes full 256-byte blocks into a sink that just dumped its OH * state in the toplevel polynomial hash and reset the block state. */ static FN size_t block_sink_update(struct umash_sink *sink, const void *data, size_t n_bytes) { size_t consumed = 0; assert(n_bytes >= BLOCK_SIZE); assert(sink->bufsz == 0); assert(sink->block_size == 0); assert(sink->oh_iter == 0); #ifdef UMASH_MULTIPLE_BLOCKS_THRESHOLD if (UNLIKELY(n_bytes > UMASH_MULTIPLE_BLOCKS_THRESHOLD)) { /* * We leave the last block (partial or not) for the * caller: incremental hashing must save some state * at the end of a block. */ size_t n_blocks = (n_bytes - 1) / BLOCK_SIZE; if (sink->hash_wanted != 0) { const uint64_t multipliers[2][2] = { [0][0] = sink->poly_state[0].mul[0], [0][1] = sink->poly_state[0].mul[1], [1][0] = sink->poly_state[1].mul[0], [1][1] = sink->poly_state[1].mul[1], }; struct umash_fp poly = { .hash[0] = sink->poly_state[0].acc, .hash[1] = sink->poly_state[1].acc, }; poly = umash_fprint_multiple_blocks( poly, multipliers, sink->oh, sink->seed, data, n_blocks); sink->poly_state[0].acc = poly.hash[0]; sink->poly_state[1].acc = poly.hash[1]; } else { sink->poly_state[0].acc = umash_multiple_blocks( sink->poly_state[0].acc, sink->poly_state[0].mul, sink->oh, sink->seed, data, n_blocks); } return n_blocks * BLOCK_SIZE; } #endif while (n_bytes > BLOCK_SIZE) { /* * Is this worth unswitching? Not obviously, given * the amount of work in one OH block. */ if (sink->hash_wanted != 0) { struct umash_oh hashes[2]; oh_varblock_fprint( hashes, sink->oh, sink->seed, data, BLOCK_SIZE); sink->oh_acc = hashes[0]; sink->oh_twisted.acc = hashes[1]; } else { sink->oh_acc = oh_varblock(sink->oh, sink->seed, data, BLOCK_SIZE); } sink_update_poly(sink); consumed += BLOCK_SIZE; data = (const char *)data + BLOCK_SIZE; n_bytes -= BLOCK_SIZE; } return consumed; } FN void umash_sink_update(struct umash_sink *sink, const void *data, size_t n_bytes) { const size_t buf_begin = sizeof(sink->buf) - INCREMENTAL_GRANULARITY; size_t remaining = INCREMENTAL_GRANULARITY - sink->bufsz; DTRACE_PROBE4(libumash, umash_sink_update, sink, remaining, data, n_bytes); if (n_bytes < remaining) { memcpy(&sink->buf[buf_begin + sink->bufsz], data, n_bytes); sink->bufsz += n_bytes; return; } memcpy(&sink->buf[buf_begin + sink->bufsz], data, remaining); data = (const char *)data + remaining; n_bytes -= remaining; /* We know we're hashing at least 16 bytes. */ sink->large_umash = true; sink->bufsz = INCREMENTAL_GRANULARITY; /* * We can't compress a 16-byte buffer until we know whether * data is coming: the last 16-byte chunk goes to `NH` instead * of `PH`. We could try to detect when the buffer is the * last chunk in a block and immediately go to `NH`, but it * seems more robust to always let the stores settle before we * read them, just in case the combination is bad for forwarding. */ if (n_bytes == 0) return; sink_consume_buf(sink, sink->buf + buf_begin, /*final=*/false); while (n_bytes > INCREMENTAL_GRANULARITY) { size_t consumed; if (sink->oh_iter == 0 && n_bytes > BLOCK_SIZE) { consumed = block_sink_update(sink, data, n_bytes); assert(consumed >= BLOCK_SIZE); /* * Save the tail of the data we just consumed * in `sink->buf[0 ... buf_begin - 1]`: the * final digest may need those bytes for its * redundant read. */ memcpy(sink->buf, (const char *)data + (consumed - INCREMENTAL_GRANULARITY), buf_begin); } else { consumed = INCREMENTAL_GRANULARITY; sink->bufsz = INCREMENTAL_GRANULARITY; sink_consume_buf(sink, data, /*final=*/false); } n_bytes -= consumed; data = (const char *)data + consumed; } memcpy(&sink->buf[buf_begin], data, n_bytes); sink->bufsz = n_bytes; return; } FN uint64_t umash_full(const struct umash_params *params, uint64_t seed, int which, const void *data, size_t n_bytes) { DTRACE_PROBE4(libumash, umash_full, params, which, data, n_bytes); /* * We don't (yet) implement code that only evaluates the * second hash. We don't currently use that logic, and it's * about to become a bit more complex, so let's just go for a * full fingerprint and take what we need. * * umash_full is also rarely used that way: usually we want * either the main hash, or the full fingerprint. */ if (UNLIKELY(which != 0)) { struct umash_fp fp; fp = umash_fprint(params, seed, data, n_bytes); return fp.hash[1]; } /* * It's not that short inputs are necessarily more likely, but * we want to make sure they fall through correctly to * minimise latency. */ if (LIKELY(n_bytes <= sizeof(v128))) { if (LIKELY(n_bytes <= sizeof(uint64_t))) return umash_short(params->oh, seed, data, n_bytes); return umash_medium(params->poly[0], params->oh, seed, data, n_bytes); } return umash_long(params->poly[0], params->oh, seed, data, n_bytes); } FN struct umash_fp umash_fprint( const struct umash_params *params, uint64_t seed, const void *data, size_t n_bytes) { DTRACE_PROBE3(libumash, umash_fprint, params, data, n_bytes); if (LIKELY(n_bytes <= sizeof(v128))) { if (LIKELY(n_bytes <= sizeof(uint64_t))) return umash_fp_short(params->oh, seed, data, n_bytes); return umash_fp_medium(params->poly, params->oh, seed, data, n_bytes); } return umash_fp_long(params->poly, params->oh, seed, data, n_bytes); } FN void umash_init(struct umash_state *state, const struct umash_params *params, uint64_t seed, int which) { which = (which == 0) ? 0 : 1; DTRACE_PROBE3(libumash, umash_init, state, params, which); state->sink = (struct umash_sink) { .poly_state[0] = { .mul = { params->poly[0][0], params->poly[0][1], }, }, .poly_state[1]= { .mul = { params->poly[1][0], params->poly[1][1], }, }, .oh = params->oh, .hash_wanted = which, .oh_twisted.lrc = { params->oh[UMASH_OH_PARAM_COUNT], params->oh[UMASH_OH_PARAM_COUNT + 1] }, .seed = seed, }; return; } FN void umash_fp_init( struct umash_fp_state *state, const struct umash_params *params, uint64_t seed) { DTRACE_PROBE2(libumash, umash_fp_init, state, params); state->sink = (struct umash_sink) { .poly_state[0] = { .mul = { params->poly[0][0], params->poly[0][1], }, }, .poly_state[1]= { .mul = { params->poly[1][0], params->poly[1][1], }, }, .oh = params->oh, .hash_wanted = 2, .oh_twisted.lrc = { params->oh[UMASH_OH_PARAM_COUNT], params->oh[UMASH_OH_PARAM_COUNT + 1] }, .seed = seed, }; return; } /** * Pumps any last block out of the incremental state. */ static FN void digest_flush(struct umash_sink *sink) { if (sink->bufsz > 0) sink_consume_buf(sink, &sink->buf[sink->bufsz], /*final=*/true); return; } /** * Finalizes a digest out of `sink`'s current state. * * The `sink` must be `digest_flush`ed if it is a `large_umash`. * * @param index 0 to return the first (only, if hashing) value, 1 for the * second independent value for fingerprinting. */ static FN uint64_t digest(const struct umash_sink *sink, int index) { const size_t buf_begin = sizeof(sink->buf) - INCREMENTAL_GRANULARITY; const size_t shift = (index == 0) ? 0 : OH_SHORT_HASH_SHIFT; if (sink->large_umash) return finalize(sink->poly_state[index].acc); if (sink->bufsz <= sizeof(uint64_t)) return umash_short( &sink->oh[shift], sink->seed, &sink->buf[buf_begin], sink->bufsz); return umash_medium(sink->poly_state[index].mul, sink->oh, sink->seed, &sink->buf[buf_begin], sink->bufsz); } static FN struct umash_fp fp_digest_sink(const struct umash_sink *sink) { struct umash_sink copy; struct umash_fp ret; const size_t buf_begin = sizeof(sink->buf) - INCREMENTAL_GRANULARITY; if (sink->large_umash) { copy = *sink; digest_flush(©); sink = © } else if (sink->bufsz <= sizeof(uint64_t)) { return umash_fp_short( sink->oh, sink->seed, &sink->buf[buf_begin], sink->bufsz); } else { const struct umash_params *params; /* * Back out the params struct from our pointer to its * `oh` member. */ params = (const void *)((const char *)sink->oh - __builtin_offsetof(struct umash_params, oh)); return umash_fp_medium(params->poly, sink->oh, sink->seed, &sink->buf[buf_begin], sink->bufsz); } for (size_t i = 0; i < ARRAY_SIZE(ret.hash); i++) ret.hash[i] = digest(sink, i); return ret; } FN uint64_t umash_digest(const struct umash_state *state) { struct umash_sink copy; const struct umash_sink *sink = &state->sink; DTRACE_PROBE1(libumash, umash_digest, state); if (sink->hash_wanted == 1) { struct umash_fp fp; fp = fp_digest_sink(sink); return fp.hash[1]; } if (sink->large_umash) { copy = *sink; digest_flush(©); sink = © } return digest(sink, 0); } FN struct umash_fp umash_fp_digest(const struct umash_fp_state *state) { DTRACE_PROBE1(libumash, umash_fp_digest, state); return fp_digest_sink(&state->sink); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/import/umash.h�����������������������������������������������������������0000664�0000000�0000000�00000025722�15100345067�0020254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from * the UMASH hash implementation at https://github.com/backtrace-labs/umash. * * This is a copy of umash.h, git commit sha * fc4c5b6ca1f06c308e96c43aa080bd766238e092. */ /* * UMASH is distributed under the MIT license. * * SPDX-License-Identifier: MIT * * Copyright 2020-2022 Backtrace I/O, Inc. * Copyright 2022 Paul Khuong * Copyright 2022 Dougall Johnson * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef UMASH_H #define UMASH_H #include <stdbool.h> #include <stddef.h> #include <stdint.h> #ifndef TS_USE_UMASH #error "UMASH usage is disabled, but the header is included" #endif /** * # UMASH: a non-cryptographic hash function with collision bounds * * SPDX-License-Identifier: MIT * Copyright 2020-2022 Backtrace I/O, Inc. * Copyright 2022 Paul Khuong * * UMASH is a fast (9-22 ns latency for inputs of 1-64 bytes and 22 * GB/s peak throughput, on a 2.5 GHz Intel 8175M) 64-bit hash * function with mathematically proven collision bounds: it is * [ceil(s / 4096) * 2^{-55}]-almost-universal for inputs of s or * fewer bytes. * * When that's not enough, UMASH can also generate a pair of 64-bit * hashes in a single traversal. The resulting fingerprint reduces * the collision probability to less than [ceil(s / 2^{26})^2 * 2^{-83}]; * the probability that two distinct inputs receive the same * fingerprint is less 2^{-83} for inputs up to 64 MB, and less than * 2^{-70} as long as the inputs are shorter than 5 GB each. This * expectation is taken over the randomly generated `umash_params`. * If an attacker can infer the contents of these parameters, the * bounds do not apply. * * ## Initialisation * * In order to use `UMASH`, one must first generate a `struct * umash_params`; each such param defines a distinct `UMASH` function * (a pair of such functions, in fact). Ideally, one would fill * a struct with random bytes and call`umash_params_prepare`. * * - `umash_params_prepare`: attempts to convert the contents of * randomly filled `struct umash_params` into a valid UMASH * parameter struct (key). When the input consists of uniformly * generated random bytes, the probability of failure is * astronomically small. * * - `umash_params_derive`: deterministically constructs a `struct * umash_params` from a 64-bit seed and an optional 32-byte secret. * The seed and secret are expanded into random bytes with Salsa20; * the resulting `umash_params` should be practically random, as * long the seed or secret are unknown. * * ## Batch hashing and fingerprinting * * Once we have a `struct umash_params`, we can use `umash_full` or * `umash_fprint` like regular hash functions. * * - `umash_full` can compute either of the two UMASH functions * described by a `struct umash_params`. Its `seed` argument will * change the output, but is not associated with any collision * bound. * * - `umash_fprint` computes both `UMASH` functions described by a * `struct umash_params`. `umash_fp::hash[0]` corresponds to * calling `umash_full` with the same arguments and `which = 0`; * `umash_fp::hash[1]` corresponds to `which = 1`. * * ## Incremental hashing and fingerprinting * * We can also compute UMASH values by feeding bytes incrementally. * The result is guaranteed to the same as if we had buffered all the * bytes and called `umash_full` or `umash_fprint`. * * - `umash_init` initialises a `struct umash_state` with the same * parameters one would pass to `umash_full`. * * - `umash_digest` computes the value `umash_full` would return * were it passed the arguments that were given to `umash_init`, * and the bytes "fed" into the `umash_state`. * * - `umash_fp_init` initialises a `struct umash_fp_state` with the * same parameters one would pass to `umash_fprint`. * * - `umash_fp_digest` computes the value `umash_fprint` would return * for the bytes "fed" into the `umash_fp_state`. * * In both cases, one passes a pointer to `struct umash_state::sink` * or `struct umash_fp_state::sink` to callees that wish to feed bytes * into the `umash_state` or `umash_fp_state`. * * - `umash_sink_update` feeds a byte range to the `umash_sink` * initialised by calling `umash_init` or `umash_fp_init`. The sink * does not take ownership of anything and the input bytes may be * overwritten or freed as soon as `umash_sink_update` returns. */ #ifdef __cplusplus extern "C" { #endif enum { UMASH_OH_PARAM_COUNT = 32, UMASH_OH_TWISTING_COUNT = 2 }; /** * A single UMASH params struct stores the parameters for a pair of * independent `UMASH` functions. */ struct umash_params { /* * Each uint64_t[2] array consists of {f^2, f}, where f is a * random multiplier in mod 2**61 - 1. */ uint64_t poly[2][2]; /* * The second (twisted) OH function uses an additional * 128-bit constant stored in the last two elements. */ uint64_t oh[UMASH_OH_PARAM_COUNT + UMASH_OH_TWISTING_COUNT]; }; /** * A fingerprint consists of two independent `UMASH` hash values. */ struct umash_fp { uint64_t hash[2]; }; /** * This struct holds the state for incremental UMASH hashing or * fingerprinting. * * A sink owns no allocation, and simply borrows a pointer to its * `umash_params`. It can be byte-copied to snapshot its state. * * The layout works best with alignment to 64 bytes, but does not * require it. */ struct umash_sink { /* * We incrementally maintain two states when fingerprinting. * When hashing, only the first `poly_state` and `oh_acc` * entries are active. */ struct { uint64_t mul[2]; /* Multiplier, and multiplier^2. */ uint64_t acc; /* Current Horner accumulator. */ } poly_state[2]; /* * We write new bytes to the second half, and keep the previous * 16 byte chunk in the first half. * * We may temporarily have a full 16-byte buffer in the second half: * we must know if the first 16 byte chunk is the first of many, or * the whole input. */ char buf[2 * 16]; /* The next 64 bytes are accessed in the `OH` inner loop. */ /* key->oh. */ const uint64_t *oh; /* oh_iter tracks where we are in the inner loop, times 2. */ uint32_t oh_iter; uint8_t bufsz; /* Write pointer in `buf + 16`. */ uint8_t block_size; /* Current OH block size, excluding `bufsz`. */ bool large_umash; /* True once we definitely have >= 16 bytes. */ /* * 0 if we're computing the first umash, 1 for the second, and * 2 for a fingerprint. * * In practice, we treat 1 and 2 the same (always compute a * full fingerprint), and return only the second half if we * only want that half. */ uint8_t hash_wanted; /* Accumulators for the current OH value. */ struct umash_oh { uint64_t bits[2]; } oh_acc; struct umash_twisted_oh { uint64_t lrc[2]; uint64_t prev[2]; struct umash_oh acc; } oh_twisted; uint64_t seed; }; /** * The `umash_state` struct wraps a sink in a type-safe interface: we * don't want to try and extract a fingerprint from a sink configured * for hashing. */ struct umash_state { struct umash_sink sink; }; /** * Similarly, the `umash_fp_state` struct wraps a sink from which we * should extract a fingerprint. */ struct umash_fp_state { struct umash_sink sink; }; /** * Converts a `umash_params` struct filled with random values into * something usable by the UMASH functions below. * * When it succeeds, this function is idempotent. Failure happens * with probability < 2**-110 is `params` is filled with uniformly * distributed random bits. That's an astronomically unlikely event, * and most likely signals an issue with the caller's (pseudo-)random * number generator. * * @return false on failure, probably because the input was not random. */ bool umash_params_prepare(struct umash_params *params); /** * Deterministically derives a `umash_params` struct from `bits` and * `key`. The `bits` values do not have to be particularly well * distributed, and can be generated sequentially. * * @param key a pointer to exactly 32 secret bytes. NULL will be * replaced with "Do not use UMASH VS adversaries.", the default * UMASH secret. */ void umash_params_derive(struct umash_params *, uint64_t bits, const void *key); /** * Updates a `umash_sink` to take into account `data[0 ... n_bytes)`. */ void umash_sink_update(struct umash_sink *, const void *data, size_t n_bytes); /** * Computes the UMASH hash of `data[0 ... n_bytes)`. * * Randomly generated `param` lead to independent UMASH values and * associated worst-case collision bounds; changing the `seed` comes * with no guarantee. * * @param which 0 to compute the first UMASH defined by `params`, 1 * for the second. */ uint64_t umash_full(const struct umash_params *params, uint64_t seed, int which, const void *data, size_t n_bytes); /** * Computes the UMASH fingerprint of `data[0 ... n_bytes)`. * * Randomly generated `param` lead to independent UMASH values and * associated worst-case collision bounds; changing the `seed` comes * with no guarantee. */ struct umash_fp umash_fprint( const struct umash_params *params, uint64_t seed, const void *data, size_t n_bytes); /** * Prepares a `umash_state` for computing the `which`th UMASH function in * `params`. */ void umash_init( struct umash_state *, const struct umash_params *params, uint64_t seed, int which); /** * Returns the UMASH value for the bytes that have been * `umash_sink_update`d into the state. */ uint64_t umash_digest(const struct umash_state *); /** * Prepares a `umash_fp_state` for computing the UMASH fingerprint in * `params`. */ void umash_fp_init( struct umash_fp_state *, const struct umash_params *params, uint64_t seed); /** * Returns the UMASH fingerprint for the bytes that have been * `umash_sink_update`d into the state. */ struct umash_fp umash_fp_digest(const struct umash_fp_state *); #ifdef __cplusplus } #endif #endif /* !UMASH_H */ ����������������������������������������������timescaledb-2.23.0/tsl/src/init.c�������������������������������������������������������������������0000664�0000000�0000000�00000022566�15100345067�0016566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <storage/ipc.h> #include "bgw_policy/compression_api.h" #include "bgw_policy/continuous_aggregate_api.h" #include "bgw_policy/job.h" #include "bgw_policy/job_api.h" #include "bgw_policy/policies_v2.h" #include "bgw_policy/process_hyper_inval_api.h" #include "bgw_policy/reorder_api.h" #include "bgw_policy/retention_api.h" #include "chunk.h" #include "chunk_api.h" #include "compression/algorithms/array.h" #include "compression/algorithms/bool_compress.h" #include "compression/algorithms/deltadelta.h" #include "compression/algorithms/dictionary.h" #include "compression/algorithms/gorilla.h" #include "compression/algorithms/uuid_compress.h" #include "compression/api.h" #include "compression/compression.h" #include "compression/create.h" #include "compression/recompress.h" #include "compression/sparse_index_bloom1.h" #include "continuous_aggs/create.h" #include "continuous_aggs/insert.h" #include "continuous_aggs/invalidation.h" #include "continuous_aggs/invalidation_multi.h" #include "continuous_aggs/invalidation_record.h" #include "continuous_aggs/options.h" #include "continuous_aggs/refresh.h" #include "continuous_aggs/repair.h" #include "continuous_aggs/utils.h" #include "cross_module_fn.h" #include "export.h" #include "hypertable.h" #include "license_guc.h" #include "nodes/columnar_scan/planner.h" #include "nodes/gapfill/gapfill_functions.h" #include "nodes/skip_scan/skip_scan.h" #include "nodes/vector_agg/plan.h" #include "partialize_finalize.h" #include "planner.h" #include "process_utility.h" #include "reorder.h" #ifdef PG_MODULE_MAGIC PG_MODULE_MAGIC; #endif #ifdef APACHE_ONLY #error "cannot compile the TSL for ApacheOnly mode" #endif #if PG16_LT extern void PGDLLEXPORT _PG_init(void); #endif /* * Cross module function initialization. * * During module start we set ts_cm_functions to point at the tsl version of the * function registry. * * NOTE: To ensure that your cross-module function has a correct default, you * must also add it to ts_cm_functions_default in cross_module_fn.c in the * Apache codebase. */ CrossModuleFunctions tsl_cm_functions = { .create_upper_paths_hook = tsl_create_upper_paths_hook, .set_rel_pathlist_dml = tsl_set_rel_pathlist_dml, .set_rel_pathlist_query = tsl_set_rel_pathlist_query, /* bgw policies */ .policy_compression_add = policy_compression_add, .policy_compression_remove = policy_compression_remove, .policy_recompression_proc = policy_recompression_proc, .policy_compression_check = policy_compression_check, .policy_refresh_cagg_add = policy_refresh_cagg_add, .policy_refresh_cagg_proc = policy_refresh_cagg_proc, .policy_refresh_cagg_check = policy_refresh_cagg_check, .policy_refresh_cagg_remove = policy_refresh_cagg_remove, .policy_process_hyper_inval_add = policy_process_hyper_inval_add, .policy_process_hyper_inval_proc = policy_process_hyper_inval_proc, .policy_process_hyper_inval_check = policy_process_hyper_inval_check, .policy_process_hyper_inval_remove = policy_process_hyper_inval_remove, .policy_reorder_add = policy_reorder_add, .policy_reorder_proc = policy_reorder_proc, .policy_reorder_check = policy_reorder_check, .policy_reorder_remove = policy_reorder_remove, .policy_retention_add = policy_retention_add, .policy_retention_proc = policy_retention_proc, .policy_retention_check = policy_retention_check, .policy_retention_remove = policy_retention_remove, .job_add = job_add, .job_alter = job_alter, .job_alter_set_hypertable_id = job_alter_set_hypertable_id, .job_delete = job_delete, .job_run = job_run, .job_execute = job_execute, /* gapfill */ .gapfill_marker = gapfill_marker, .gapfill_int16_time_bucket = gapfill_int16_time_bucket, .gapfill_int32_time_bucket = gapfill_int32_time_bucket, .gapfill_int64_time_bucket = gapfill_int64_time_bucket, .gapfill_date_time_bucket = gapfill_date_time_bucket, .gapfill_timestamp_time_bucket = gapfill_timestamp_time_bucket, .gapfill_timestamptz_time_bucket = gapfill_timestamptz_time_bucket, .gapfill_timestamptz_timezone_time_bucket = gapfill_timestamptz_timezone_time_bucket, .reorder_chunk = tsl_reorder_chunk, .move_chunk = tsl_move_chunk, .policies_add = policies_add, .policies_remove = policies_remove, .policies_remove_all = policies_remove_all, .policies_alter = policies_alter, .policies_show = policies_show, /* Vectorized queries */ .tsl_postprocess_plan = tsl_postprocess_plan, /* Continuous Aggregates */ .partialize_agg = tsl_partialize_agg, .finalize_agg_sfunc = tsl_finalize_agg_sfunc, .finalize_agg_ffunc = tsl_finalize_agg_ffunc, .process_cagg_viewstmt = tsl_process_continuous_agg_viewstmt, .continuous_agg_refresh = continuous_agg_refresh, .continuous_agg_process_hypertable_invalidations = continuous_agg_process_hypertable_invalidations, .continuous_agg_invalidate_raw_ht = continuous_agg_invalidate_raw_ht, .continuous_agg_invalidate_mat_ht = continuous_agg_invalidate_mat_ht, .continuous_agg_dml_invalidate = continuous_agg_dml_invalidate, .continuous_agg_update_options = continuous_agg_update_options, .continuous_agg_validate_query = continuous_agg_validate_query, .continuous_agg_get_bucket_function = continuous_agg_get_bucket_function, .continuous_agg_get_bucket_function_info = continuous_agg_get_bucket_function_info, .continuous_agg_migrate_to_time_bucket = continuous_agg_migrate_to_time_bucket, .continuous_agg_read_invalidation_record = ts_invalidation_read_record, .cagg_try_repair = tsl_cagg_try_repair, /* Compression */ .compressed_data_decompress_forward = tsl_compressed_data_decompress_forward, .compressed_data_decompress_reverse = tsl_compressed_data_decompress_reverse, .compressed_data_send = tsl_compressed_data_send, .compressed_data_recv = tsl_compressed_data_recv, .compressed_data_in = tsl_compressed_data_in, .compressed_data_out = tsl_compressed_data_out, .compressed_data_info = tsl_compressed_data_info, .compressed_data_has_nulls = tsl_compressed_data_has_nulls, .deltadelta_compressor_append = tsl_deltadelta_compressor_append, .deltadelta_compressor_finish = tsl_deltadelta_compressor_finish, .gorilla_compressor_append = tsl_gorilla_compressor_append, .gorilla_compressor_finish = tsl_gorilla_compressor_finish, .dictionary_compressor_append = tsl_dictionary_compressor_append, .dictionary_compressor_finish = tsl_dictionary_compressor_finish, .array_compressor_append = tsl_array_compressor_append, .array_compressor_finish = tsl_array_compressor_finish, .bool_compressor_append = tsl_bool_compressor_append, .bool_compressor_finish = tsl_bool_compressor_finish, .uuid_compressor_append = tsl_uuid_compressor_append, .uuid_compressor_finish = tsl_uuid_compressor_finish, .bloom1_contains = bloom1_contains, .bloom1_get_hash_function = bloom1_get_hash_function, .process_compress_table = tsl_process_compress_table, .process_altertable_cmd = tsl_process_altertable_cmd, .process_rename_cmd = tsl_process_rename_cmd, .compress_chunk = tsl_compress_chunk, .decompress_chunk = tsl_decompress_chunk, .decompress_batches_for_insert = decompress_batches_for_insert, .init_decompress_state_for_insert = init_decompress_state_for_insert, .decompress_target_segments = decompress_target_segments, .columnstore_setup = tsl_columnstore_setup, .compressor_init = tsl_compressor_init, .compressor_add_slot = tsl_compressor_add_slot, .compressor_flush = tsl_compressor_flush, .compressor_free = tsl_compressor_free, .compression_chunk_create = tsl_compression_chunk_create, .show_chunk = chunk_show, .create_compressed_chunk = tsl_create_compressed_chunk, .create_chunk = chunk_create, .chunk_freeze_chunk = chunk_freeze_chunk, .chunk_unfreeze_chunk = chunk_unfreeze_chunk, .recompress_chunk_segmentwise = tsl_recompress_chunk_segmentwise, .get_compressed_chunk_index_for_recompression = tsl_get_compressed_chunk_index_for_recompression, .preprocess_query_tsl = tsl_preprocess_query, .merge_chunks = chunk_merge_chunks, .split_chunk = chunk_split_chunk, .detach_chunk = chunk_detach, .attach_chunk = chunk_attach, }; static void ts_module_cleanup_on_pg_exit(int code, Datum arg) { _continuous_aggs_cache_inval_fini(); } TS_FUNCTION_INFO_V1(ts_module_init); /* * Module init function, sets ts_cm_functions to point at tsl_cm_functions */ PGDLLEXPORT Datum ts_module_init(PG_FUNCTION_ARGS) { bool register_proc_exit = PG_GETARG_BOOL(0); ts_cm_functions = &tsl_cm_functions; _continuous_aggs_cache_inval_init(); _columnar_scan_init(); _skip_scan_init(); _vector_agg_init(); /* Register a cleanup function to be called when the backend exits */ if (register_proc_exit) on_proc_exit(ts_module_cleanup_on_pg_exit, 0); PG_RETURN_BOOL(true); } /* Informative functions */ PGDLLEXPORT void _PG_init(void) { /* * In a normal backend, we disable loading the tsl until after the main * timescale library is loaded, after which we enable it from the loader. * In parallel workers the restore shared libraries function will load the * libraries itself, and we bypass the loader, so we need to ensure that * timescale is aware it can use the tsl if needed. It is always safe to * do this here, because if we reach this point, we must have already * loaded the tsl, so we no longer need to worry about its load order * relative to the other libraries. */ ts_license_enable_module_loading(); } ������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/�������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016554�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/CMakeLists.txt�����������������������������������������������������0000664�0000000�0000000�00000000332�15100345067�0021312�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) add_subdirectory(columnar_scan) add_subdirectory(frozen_chunk_dml) add_subdirectory(gapfill) add_subdirectory(skip_scan) add_subdirectory(vector_agg) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/README.md����������������������������������������������������������0000664�0000000�0000000�00000000430�15100345067�0020030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# TimescaleDB Optimizations TimescaleDB has a number of optimizations to improve performance of query execution. - [Skip scan](skip_scan/README.md) optimize queries involving `DISTINCT` - [Gapfill](gapfill/README.md) supports gapfilling time-series using LOCF and interpolation ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/�����������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0021400�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/CMakeLists.txt���������������������������������������0000664�0000000�0000000�00000001255�15100345067�0024143�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Add all *.c to sources in upperlevel directory set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/batch_array.c ${CMAKE_CURRENT_SOURCE_DIR}/batch_queue_heap.c ${CMAKE_CURRENT_SOURCE_DIR}/batch_queue_fifo.c ${CMAKE_CURRENT_SOURCE_DIR}/compressed_batch.c ${CMAKE_CURRENT_SOURCE_DIR}/columnar_scan.c ${CMAKE_CURRENT_SOURCE_DIR}/detoaster.c ${CMAKE_CURRENT_SOURCE_DIR}/exec.c ${CMAKE_CURRENT_SOURCE_DIR}/planner.c ${CMAKE_CURRENT_SOURCE_DIR}/pred_text.c ${CMAKE_CURRENT_SOURCE_DIR}/pred_vector_array.c ${CMAKE_CURRENT_SOURCE_DIR}/qual_pushdown.c ${CMAKE_CURRENT_SOURCE_DIR}/vector_predicates.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_array.c����������������������������������������0000664�0000000�0000000�00000006525�15100345067�0024033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "nodes/columnar_scan/batch_array.h" #include "compression/compression.h" #include "nodes/columnar_scan/compressed_batch.h" /* * Create states to hold information for up to n batches. */ void batch_array_init(BatchArray *array, int nbatches, int ncolumns_per_batch) { Assert(nbatches >= 0); array->n_batch_states = nbatches; array->n_columns_per_batch = ncolumns_per_batch; array->unused_batch_states = bms_add_range(NULL, 0, nbatches - 1); array->n_batch_state_bytes = sizeof(DecompressBatchState) + sizeof(CompressedColumnValues) * ncolumns_per_batch; array->batch_states = palloc0(array->n_batch_state_bytes * nbatches); Assert(bms_num_members(array->unused_batch_states) == array->n_batch_states); } /* * Destroy batch states. */ void batch_array_destroy(BatchArray *array) { for (int i = 0; i < array->n_batch_states; i++) { DecompressBatchState *batch_state = batch_array_get_at(array, i); compressed_batch_destroy(batch_state); } pfree(array->batch_states); array->batch_states = NULL; } /* * Enhance the capacity of existing batch states. */ static void batch_array_enlarge(BatchArray *array, int new_number) { Assert(new_number > array->n_batch_states); /* Request additional memory */ array->batch_states = repalloc(array->batch_states, array->n_batch_state_bytes * new_number); /* Zero out the tail. The batch states are initialized on first use. */ memset(((char *) array->batch_states) + (array->n_batch_state_bytes * array->n_batch_states), 0x0, array->n_batch_state_bytes * (new_number - array->n_batch_states)); /* Register the new states as unused */ array->unused_batch_states = bms_add_range(array->unused_batch_states, array->n_batch_states, new_number - 1); Assert(bms_num_members(array->unused_batch_states) == new_number - array->n_batch_states); /* Update number of available batch states */ array->n_batch_states = new_number; } /* * Mark a DecompressBatchState as unused */ void batch_array_clear_at(BatchArray *array, int batch_index) { Assert(batch_index >= 0); Assert(batch_index < array->n_batch_states); DecompressBatchState *batch_state = batch_array_get_at(array, batch_index); /* Reset batch state */ compressed_batch_discard_tuples(batch_state); array->unused_batch_states = bms_add_member(array->unused_batch_states, batch_index); } void batch_array_clear_all(BatchArray *array) { for (int i = 0; i < array->n_batch_states; i++) batch_array_clear_at(array, i); Assert(bms_num_members(array->unused_batch_states) == array->n_batch_states); } /* * Get the next free and unused batch state and mark as used */ int batch_array_get_unused_slot(BatchArray *array) { if (bms_is_empty(array->unused_batch_states)) batch_array_enlarge(array, array->n_batch_states * 2); Assert(!bms_is_empty(array->unused_batch_states)); int next_unused_batch = bms_next_member(array->unused_batch_states, -1); Assert(next_unused_batch >= 0); Assert(next_unused_batch < array->n_batch_states); Assert(TupIsNull(compressed_batch_current_tuple(batch_array_get_at(array, next_unused_batch)))); array->unused_batch_states = bms_del_member(array->unused_batch_states, next_unused_batch); return next_unused_batch; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_array.h����������������������������������������0000664�0000000�0000000�00000003313�15100345067�0024030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/bitmapset.h> #include <stdbool.h> /* The value for an invalid batch id */ #define INVALID_BATCH_ID -1 typedef struct BatchArray { /* Batch states */ int n_batch_states; /* Number of batch states */ /* * The batch states. It's void* because they have a variable length * column array, so normal indexing can't be used. Use the batch_array_get_at * accessor instead. */ void *batch_states; int n_batch_state_bytes; int n_columns_per_batch; Bitmapset *unused_batch_states; /* The unused batch states */ } BatchArray; /* * Create states to hold information for up to n batches */ void batch_array_init(BatchArray *array, int nbatches, int ncolumns_per_batch); void batch_array_destroy(BatchArray *array); extern int batch_array_get_unused_slot(BatchArray *array); inline static struct DecompressBatchState * batch_array_get_at(const BatchArray *array, int batch_index) { /* * Since we're accessing batch states through a "char" pointer, use * "restrict" to tell the compiler that it doesn't alias with anything. * Might be important in hot loops. */ return (struct DecompressBatchState *) ((char *restrict) array->batch_states + array->n_batch_state_bytes * batch_index); } extern void batch_array_clear_at(BatchArray *array, int batch_index); extern void batch_array_clear_all(BatchArray *array); inline static bool batch_array_has_active_batches(const BatchArray *array) { return bms_num_members(array->unused_batch_states) != array->n_batch_states; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_queue.h����������������������������������������0000664�0000000�0000000�00000001765�15100345067�0024047�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifndef TIMESCALEDB_BATCH_QUEUE_H #define TIMESCALEDB_BATCH_QUEUE_H #include <postgres.h> #include <executor/tuptable.h> #include "decompress_context.h" /* Initial amount of batch states */ #define INITIAL_BATCH_CAPACITY 16 struct BatchQueue; typedef struct BatchQueueFunctions { void (*free)(struct BatchQueue *); bool (*needs_next_batch)(struct BatchQueue *); void (*pop)(struct BatchQueue *, DecompressContext *); void (*push_batch)(struct BatchQueue *, DecompressContext *, TupleTableSlot *); void (*reset)(struct BatchQueue *); TupleTableSlot *(*top_tuple)(struct BatchQueue *); } BatchQueueFunctions; typedef struct BatchQueue { BatchArray batch_array; const BatchQueueFunctions *funcs; } BatchQueue; #include "batch_queue_fifo.h" #include "batch_queue_heap.h" #endif /* TIMESCALEDB_BATCH_QUEUE_H */ �����������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_queue_fifo.c�����������������������������������0000664�0000000�0000000�00000001474�15100345067�0025042�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "batch_queue_fifo.h" #include "batch_array.h" /* * Create a FIFO batch queue. * * Pass the function struct as argument to ensure it is a pointer to the * struct that is inlined at the place this function is called. This is mostly * to be able to later Assert() that the struct pointer is pointing to the * expected function struct. */ BatchQueue * batch_queue_fifo_create(int num_compressed_cols, const BatchQueueFunctions *funcs) { BatchQueue *bq = palloc0(sizeof(BatchQueue)); batch_array_init(&bq->batch_array, INITIAL_BATCH_CAPACITY, num_compressed_cols); bq->funcs = funcs; return bq; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_queue_fifo.h�����������������������������������0000664�0000000�0000000�00000004026�15100345067�0025043�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "batch_queue.h" #include "compressed_batch.h" static inline void batch_queue_fifo_free(BatchQueue *bq) { batch_array_destroy(&bq->batch_array); pfree(bq); } static inline bool batch_queue_fifo_needs_next_batch(BatchQueue *bq) { return TupIsNull(compressed_batch_current_tuple(batch_array_get_at(&bq->batch_array, 0))); } static inline void batch_queue_fifo_pop(BatchQueue *bq, DecompressContext *dcontext) { DecompressBatchState *batch_state = batch_array_get_at(&bq->batch_array, 0); if (TupIsNull(compressed_batch_current_tuple(batch_state))) { /* Allow this function to be called on the initial empty queue. */ return; } compressed_batch_advance(dcontext, batch_state); } static inline void batch_queue_fifo_push_batch(BatchQueue *bq, DecompressContext *dcontext, TupleTableSlot *compressed_slot) { BatchArray *batch_array = &bq->batch_array; DecompressBatchState *batch_state = batch_array_get_at(batch_array, 0); Assert(TupIsNull(compressed_batch_current_tuple(batch_array_get_at(batch_array, 0)))); compressed_batch_set_compressed_tuple(dcontext, batch_state, compressed_slot); compressed_batch_advance(dcontext, batch_state); } static inline void batch_queue_fifo_reset(BatchQueue *bq) { batch_array_clear_all(&bq->batch_array); } static inline TupleTableSlot * batch_queue_fifo_top_tuple(BatchQueue *bq) { return compressed_batch_current_tuple(batch_array_get_at(&bq->batch_array, 0)); } static const struct BatchQueueFunctions BatchQueueFunctionsFifo = { .free = batch_queue_fifo_free, .needs_next_batch = batch_queue_fifo_needs_next_batch, .pop = batch_queue_fifo_pop, .push_batch = batch_queue_fifo_push_batch, .reset = batch_queue_fifo_reset, .top_tuple = batch_queue_fifo_top_tuple, }; extern BatchQueue *batch_queue_fifo_create(int num_compressed_cols, const BatchQueueFunctions *funcs); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_queue_heap.c�����������������������������������0000664�0000000�0000000�00000033167�15100345067�0025040�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <lib/binaryheap.h> #include <nodes/bitmapset.h> #include "compression/compression.h" #include "nodes/columnar_scan/batch_array.h" #include "nodes/columnar_scan/batch_queue.h" #include "nodes/columnar_scan/compressed_batch.h" typedef struct { Datum value; bool null; } HeapEntryColumn; typedef struct BatchQueueHeap { BatchQueue queue; binaryheap *merge_heap; /* Binary heap of slot indices */ /* * Requested sort order of the heap. */ int nkeys; SortSupport sortkeys; /* * This is the actual entries of the heap we're going to compare. We're using * these minimal structures for better memory locality instead of addressing * the entire compressed batches. Would be even better to put them into the * heap inline, but unfortunately the Postgres binary heap doesn't support * this. * * For each batch, we have nkeys of HeapEntryColumn values, which contain * the latest decompressed values. */ HeapEntryColumn *heap_entries; /* * We use this to check when we have to ask for the next input batch. */ TupleTableSlot *last_batch_first_tuple_slot; HeapEntryColumn *last_batch_first_tuple_entry; } BatchQueueHeap; /* * Compare heap entries for two batches. This function is used for comparing the * first tuple of the last batch to the current top tuple, so it is only called * once per input tuple, and optimized specializations for it are less important. */ static int32 compare_entries(HeapEntryColumn *entryA, HeapEntryColumn *entryB, const SortSupport sortkeys, int nkeys) { for (int key = 0; key < nkeys; key++) { int compare = ApplySortComparator(entryA[key].value, entryA[key].null, entryB[key].value, entryB[key].null, &sortkeys[key]); if (compare != 0) { INVERT_COMPARE_RESULT(compare); return compare; } } return 0; } /* * Compare top tuples of two given batch array slots. We support specializations * for comparison of the first tuple, like tuplesort. */ static pg_attribute_always_inline int32 compare_heap_pos_impl(Datum a, Datum b, void *arg, int32 (*apply_first_datum_comparator)(Datum, bool, Datum, bool, SortSupport)) { BatchQueueHeap *queue = (BatchQueueHeap *) arg; PG_USED_FOR_ASSERTS_ONLY BatchArray *batch_array = &queue->queue.batch_array; int batchA = DatumGetInt32(a); Assert(batchA <= batch_array->n_batch_states); int batchB = DatumGetInt32(b); Assert(batchB <= batch_array->n_batch_states); const int nkeys = queue->nkeys; SortSupport sortkeys = queue->sortkeys; HeapEntryColumn *entryA = &queue->heap_entries[batchA * nkeys]; HeapEntryColumn *entryB = &queue->heap_entries[batchB * nkeys]; int compare = apply_first_datum_comparator(entryA[0].value, entryA[0].null, entryB[0].value, entryB[0].null, &sortkeys[0]); if (compare != 0) { INVERT_COMPARE_RESULT(compare); return compare; } for (int key = 1; key < nkeys; key++) { int compare = ApplySortComparator(entryA[key].value, entryA[key].null, entryB[key].value, entryB[key].null, &sortkeys[key]); if (compare != 0) { INVERT_COMPARE_RESULT(compare); return compare; } } return 0; } static int32 compare_heap_pos_generic(Datum a, Datum b, void *arg) { return compare_heap_pos_impl(a, b, arg, ApplySortComparator); } static int32 compare_heap_pos_int32(Datum a, Datum b, void *arg) { return compare_heap_pos_impl(a, b, arg, ApplyInt32SortComparator); } #if SIZEOF_DATUM >= 8 static int32 compare_heap_pos_signed(Datum a, Datum b, void *arg) { return compare_heap_pos_impl(a, b, arg, ApplySignedSortComparator); } #endif /* Add a new datum to the heap and perform an automatic resizing if needed. In contrast to * the binaryheap_add_unordered() function, the capacity of the heap is automatically * increased if needed. */ static pg_nodiscard binaryheap * binaryheap_add_unordered_autoresize(binaryheap *heap, Datum d) { /* Resize heap if needed */ if (heap->bh_size >= heap->bh_space) { heap->bh_space = heap->bh_space * 2; Size new_size = offsetof(binaryheap, bh_nodes) + (sizeof(Datum) * heap->bh_space); heap = (binaryheap *) repalloc(heap, new_size); } /* Insert new element */ binaryheap_add(heap, d); return heap; } static void batch_queue_heap_pop(BatchQueue *bq, DecompressContext *dcontext) { BatchQueueHeap *queue = (BatchQueueHeap *) bq; BatchArray *batch_array = &bq->batch_array; if (binaryheap_empty(queue->merge_heap)) { /* Allow this function to be called on the initial empty heap. */ return; } const int top_batch_index = DatumGetInt32(binaryheap_first(queue->merge_heap)); DecompressBatchState *top_batch = batch_array_get_at(batch_array, top_batch_index); compressed_batch_advance(dcontext, top_batch); TupleTableSlot *top_tuple = compressed_batch_current_tuple(top_batch); if (TupIsNull(top_tuple)) { /* Batch is exhausted, recycle batch_state */ (void) binaryheap_remove_first(queue->merge_heap); batch_array_clear_at(batch_array, top_batch_index); } else { /* * Update the heap entries for this batch with the current decompressed * tuple values. */ for (int key = 0; key < queue->nkeys; key++) { SortSupport sortKey = &queue->sortkeys[key]; const AttrNumber attr = AttrNumberGetAttrOffset(sortKey->ssup_attno); /* * We're working with virtual tuple slots so no need for slot_getattr(). */ Assert(TTS_IS_VIRTUAL(top_tuple)); queue->heap_entries[(top_batch_index * queue->nkeys) + key].value = top_tuple->tts_values[attr]; queue->heap_entries[(top_batch_index * queue->nkeys) + key].null = top_tuple->tts_isnull[attr]; } /* Place this batch on the heap according to its new decompressed tuple. */ binaryheap_replace_first(queue->merge_heap, Int32GetDatum(top_batch_index)); } } static bool batch_queue_heap_needs_next_batch(BatchQueue *_queue) { BatchQueueHeap *queue = (BatchQueueHeap *) _queue; if (binaryheap_empty(queue->merge_heap)) { return true; } const int top_batch_index = DatumGetInt32(binaryheap_first(queue->merge_heap)); const int comparison_result = compare_entries(&queue->heap_entries[queue->nkeys * top_batch_index], queue->last_batch_first_tuple_entry, queue->sortkeys, queue->nkeys); /* * The invariant we have to preserve is that either: * 1) the current top tuple sorts before the first tuple of the last * added batch, * 2) the input has ended. * Since the incoming batches arrive in the order of their first tuple, * if this invariant holds, then the current top tuple is found inside the * heap. * If it doesn't hold, the top tuple might be in the next incoming batches, * and we have to continue adding them. */ return comparison_result <= 0; } static void batch_queue_heap_push_batch(BatchQueue *_queue, DecompressContext *dcontext, TupleTableSlot *compressed_slot) { BatchQueueHeap *queue = (BatchQueueHeap *) _queue; BatchArray *batch_array = &queue->queue.batch_array; Assert(!TupIsNull(compressed_slot)); const int old_size = batch_array->n_batch_states; const int new_batch_index = batch_array_get_unused_slot(batch_array); if (batch_array->n_batch_states != old_size) { queue->heap_entries = repalloc(queue->heap_entries, sizeof(HeapEntryColumn) * queue->nkeys * batch_array->n_batch_states); } DecompressBatchState *batch_state = batch_array_get_at(batch_array, new_batch_index); compressed_batch_set_compressed_tuple(dcontext, batch_state, compressed_slot); compressed_batch_save_first_tuple(dcontext, batch_state, queue->last_batch_first_tuple_slot); /* * Update the heap entries for the first tuple of the last batch. */ for (int key = 0; key < queue->nkeys; key++) { SortSupport sortKey = &queue->sortkeys[key]; const AttrNumber attr = AttrNumberGetAttrOffset(sortKey->ssup_attno); /* * We're working with virtual tuple slots so no need for slot_getattr(). */ Assert(TTS_IS_VIRTUAL(queue->last_batch_first_tuple_slot)); queue->last_batch_first_tuple_entry[key].value = queue->last_batch_first_tuple_slot->tts_values[attr]; queue->last_batch_first_tuple_entry[key].null = queue->last_batch_first_tuple_slot->tts_isnull[attr]; } TupleTableSlot *current_tuple = compressed_batch_current_tuple(batch_state); if (TupIsNull(current_tuple)) { /* Might happen if there are no tuples in the batch that pass the quals. */ batch_array_clear_at(batch_array, new_batch_index); return; } /* * Update the heap entries for this batch with the first decompressed tuple * values. */ for (int key = 0; key < queue->nkeys; key++) { SortSupport sortKey = &queue->sortkeys[key]; const AttrNumber attr = AttrNumberGetAttrOffset(sortKey->ssup_attno); /* * We're working with virtual tuple slots so no need for slot_getattr(). */ Assert(TTS_IS_VIRTUAL(current_tuple)); queue->heap_entries[(new_batch_index * queue->nkeys) + key].value = current_tuple->tts_values[attr]; queue->heap_entries[(new_batch_index * queue->nkeys) + key].null = current_tuple->tts_isnull[attr]; } /* * Put the batch on the heap. */ queue->merge_heap = binaryheap_add_unordered_autoresize(queue->merge_heap, new_batch_index); } static TupleTableSlot * batch_queue_heap_top_tuple(BatchQueue *bq) { BatchQueueHeap *bqh = (BatchQueueHeap *) bq; BatchArray *batch_array = &bq->batch_array; if (binaryheap_empty(bqh->merge_heap)) { return NULL; } const int top_batch_index = DatumGetInt32(binaryheap_first(bqh->merge_heap)); DecompressBatchState *top_batch = batch_array_get_at(batch_array, top_batch_index); TupleTableSlot *top_tuple = compressed_batch_current_tuple(top_batch); Assert(!TupIsNull(top_tuple)); return top_tuple; } static void batch_queue_heap_reset(BatchQueue *bq) { BatchQueueHeap *bqh = (BatchQueueHeap *) bq; binaryheap_reset(bqh->merge_heap); } /* * Free the binary heap. */ static void batch_queue_heap_free(BatchQueue *_queue) { BatchQueueHeap *queue = (BatchQueueHeap *) _queue; BatchArray *batch_array = &queue->queue.batch_array; elog(DEBUG3, "heap has capacity of %d", queue->merge_heap->bh_space); elog(DEBUG3, "created batch states %d", batch_array->n_batch_states); batch_array_clear_all(batch_array); pfree(queue->heap_entries); binaryheap_free(queue->merge_heap); queue->merge_heap = NULL; pfree(queue->sortkeys); ExecDropSingleTupleTableSlot(queue->last_batch_first_tuple_slot); pfree(queue->last_batch_first_tuple_entry); batch_array_destroy(batch_array); pfree(queue); } const struct BatchQueueFunctions BatchQueueFunctionsHeap = { .free = batch_queue_heap_free, .needs_next_batch = batch_queue_heap_needs_next_batch, .pop = batch_queue_heap_pop, .push_batch = batch_queue_heap_push_batch, .reset = batch_queue_heap_reset, .top_tuple = batch_queue_heap_top_tuple, }; static SortSupport build_batch_sorted_merge_info(const List *sortinfo, int *nkeys) { Assert(sortinfo != NULL); List *sort_col_idx = linitial(sortinfo); List *sort_ops = lsecond(sortinfo); List *sort_collations = lthird(sortinfo); List *sort_nulls = lfourth(sortinfo); *nkeys = list_length(linitial((sortinfo))); Assert(list_length(sort_col_idx) == list_length(sort_ops)); Assert(list_length(sort_ops) == list_length(sort_collations)); Assert(list_length(sort_collations) == list_length(sort_nulls)); Assert(*nkeys > 0); SortSupportData *sortkeys = palloc0(sizeof(SortSupportData) * *nkeys); /* Inspired by nodeMergeAppend.c */ for (int i = 0; i < *nkeys; i++) { SortSupportData *sortkey = &sortkeys[i]; sortkey->ssup_cxt = CurrentMemoryContext; sortkey->ssup_collation = list_nth_oid(sort_collations, i); sortkey->ssup_nulls_first = list_nth_oid(sort_nulls, i); sortkey->ssup_attno = list_nth_oid(sort_col_idx, i); /* * It isn't feasible to perform abbreviated key conversion, since * tuples are pulled into mergestate's binary heap as needed. It * would likely be counter-productive to convert tuples into an * abbreviated representation as they're pulled up, so opt out of that * additional optimization entirely. */ sortkey->abbreviate = false; PrepareSortSupportFromOrderingOp(list_nth_oid(sort_ops, i), sortkey); } return sortkeys; } BatchQueue * batch_queue_heap_create(int num_compressed_cols, const List *sortinfo, const TupleDesc result_tupdesc, const BatchQueueFunctions *funcs) { BatchQueueHeap *queue = palloc0(sizeof(BatchQueueHeap)); batch_array_init(&queue->queue.batch_array, INITIAL_BATCH_CAPACITY, num_compressed_cols); queue->sortkeys = build_batch_sorted_merge_info(sortinfo, &queue->nkeys); queue->heap_entries = palloc(sizeof(HeapEntryColumn) * queue->nkeys * INITIAL_BATCH_CAPACITY); /* * Choose a specialization for faster comparison of the first column. This is * the approach that tuplesort uses, see e.g. qsort_tuple_signed(). * The ssup_datum_unsigned_cmp is used only for abbreviated keys which the * batch sorted merge doesn't use, so we use a generic comparator in this * case. */ binaryheap_comparator comparator = compare_heap_pos_generic; if (queue->sortkeys[0].comparator == ssup_datum_int32_cmp) { comparator = compare_heap_pos_int32; } #if SIZEOF_DATUM >= 8 else if (queue->sortkeys[0].comparator == ssup_datum_signed_cmp) { comparator = compare_heap_pos_signed; } #endif queue->merge_heap = binaryheap_allocate(INITIAL_BATCH_CAPACITY, comparator, queue); queue->last_batch_first_tuple_slot = MakeSingleTupleTableSlot(result_tupdesc, &TTSOpsVirtual); queue->last_batch_first_tuple_entry = palloc(sizeof(HeapEntryColumn) * queue->nkeys); queue->queue.funcs = funcs; return &queue->queue; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/batch_queue_heap.h�����������������������������������0000664�0000000�0000000�00000000740�15100345067�0025034�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "batch_queue.h" extern BatchQueue *batch_queue_heap_create(int num_compressed_cols, const List *sortinfo, const TupleDesc result_tupdesc, const BatchQueueFunctions *funcs); extern const struct BatchQueueFunctions BatchQueueFunctionsHeap; ��������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/columnar_scan.c��������������������������������������0000664�0000000�0000000�00000270455�15100345067�0024405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "chunk.h" #include "hypertable_cache.h" #include <catalog/pg_operator.h> #include <math.h> #include <miscadmin.h> #include <nodes/bitmapset.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <parser/parse_relation.h> #include <parser/parsetree.h> #include <planner/planner.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/typcache.h> #include <planner.h> #include "compat/compat.h" #include "compression/compression.h" #include "compression/create.h" #include "cross_module_fn.h" #include "custom_type_cache.h" #include "debug_assert.h" #include "import/allpaths.h" #include "import/planner.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/columnar_scan/planner.h" #include "nodes/columnar_scan/qual_pushdown.h" #include "ts_catalog/array_utils.h" #include "utils.h" static CustomPathMethods columnar_scan_path_methods = { .CustomName = "ColumnarScan", .PlanCustomPath = columnar_scan_plan_create, }; typedef struct SortInfo { List *required_compressed_pathkeys; List *required_eq_classes; bool needs_sequence_num; bool use_compressed_sort; /* sort can be pushed below ColumnarScan */ bool use_batch_sorted_merge; bool reverse; List *decompressed_sort_pathkeys; QualCost decompressed_sort_pathkeys_cost; } SortInfo; static RangeTblEntry *columnar_scan_make_rte(Oid compressed_relid, LOCKMODE lockmode, Query *parse); static void create_compressed_scan_paths(PlannerInfo *root, RelOptInfo *compressed_rel, const CompressionInfo *compression_info, const SortInfo *sort_info); static ColumnarScanPath *columnar_scan_path_create(PlannerInfo *root, const CompressionInfo *info, Path *compressed_path); static void columnar_scan_add_plannerinfo(PlannerInfo *root, CompressionInfo *info, const Chunk *chunk, RelOptInfo *chunk_rel, bool needs_sequence_num); static SortInfo build_sortinfo(PlannerInfo *root, const Chunk *chunk, RelOptInfo *chunk_rel, const CompressionInfo *info, List *pathkeys); static Bitmapset *find_const_segmentby(RelOptInfo *chunk_rel, const CompressionInfo *info); static EquivalenceClass * append_ec_for_seqnum(PlannerInfo *root, const CompressionInfo *info, const SortInfo *sort_info, Var *var, Oid sortop, bool nulls_first) { MemoryContext oldcontext = MemoryContextSwitchTo(root->planner_cxt); Oid opfamily, opcintype, equality_op; CompareType strategy; List *opfamilies; EquivalenceClass *newec = makeNode(EquivalenceClass); EquivalenceMember *em = makeNode(EquivalenceMember); /* Find the operator in pg_amop --- failure shouldn't happen */ if (!get_ordering_op_properties(sortop, &opfamily, &opcintype, &strategy)) elog(ERROR, "operator %u is not a valid ordering operator", sortop); /* * EquivalenceClasses need to contain opfamily lists based on the family * membership of mergejoinable equality operators, which could belong to * more than one opfamily. So we have to look up the opfamily's equality * operator and get its membership. */ equality_op = get_opfamily_member(opfamily, opcintype, opcintype, BTEqualStrategyNumber); if (!OidIsValid(equality_op)) /* shouldn't happen */ elog(ERROR, "missing operator %d(%u,%u) in opfamily %u", BTEqualStrategyNumber, opcintype, opcintype, opfamily); opfamilies = get_mergejoin_opfamilies(equality_op); if (!opfamilies) /* certainly should find some */ elog(ERROR, "could not find opfamilies for equality operator %u", equality_op); em->em_expr = (Expr *) var; em->em_relids = bms_make_singleton(info->compressed_rel->relid); #if PG16_LT em->em_nullable_relids = NULL; #endif em->em_is_const = false; em->em_is_child = false; em->em_datatype = INT4OID; newec->ec_opfamilies = list_copy(opfamilies); newec->ec_collation = 0; newec->ec_members = list_make1(em); newec->ec_sources = NIL; newec->ec_derives_list = NIL; newec->ec_relids = bms_make_singleton(info->compressed_rel->relid); newec->ec_has_const = false; newec->ec_has_volatile = false; #if PG16_LT newec->ec_below_outer_join = false; #endif newec->ec_broken = false; newec->ec_sortref = 0; newec->ec_min_security = UINT_MAX; newec->ec_max_security = 0; newec->ec_merged = NULL; info->compressed_rel->eclass_indexes = bms_add_member(info->compressed_rel->eclass_indexes, list_length(root->eq_classes)); root->eq_classes = lappend(root->eq_classes, newec); MemoryContextSwitchTo(oldcontext); return newec; } static EquivalenceClass * append_ec_for_metadata_col(PlannerInfo *root, const CompressionInfo *info, Var *var, PathKey *pk) { MemoryContext oldcontext = MemoryContextSwitchTo(root->planner_cxt); EquivalenceMember *em = makeNode(EquivalenceMember); em->em_expr = (Expr *) var; em->em_relids = bms_make_singleton(info->compressed_rel->relid); em->em_is_const = false; em->em_is_child = false; em->em_datatype = var->vartype; EquivalenceClass *ec = makeNode(EquivalenceClass); ec->ec_opfamilies = pk->pk_eclass->ec_opfamilies; ec->ec_collation = pk->pk_eclass->ec_collation; ec->ec_members = list_make1(em); ec->ec_sources = list_copy(pk->pk_eclass->ec_sources); ec->ec_derives_list = list_copy(pk->pk_eclass->ec_derives_list); ec->ec_relids = bms_make_singleton(info->compressed_rel->relid); ec->ec_has_const = pk->pk_eclass->ec_has_const; ec->ec_has_volatile = pk->pk_eclass->ec_has_volatile; #if PG16_LT ec->ec_below_outer_join = pk->pk_eclass->ec_below_outer_join; #endif ec->ec_broken = pk->pk_eclass->ec_broken; ec->ec_sortref = pk->pk_eclass->ec_sortref; ec->ec_min_security = pk->pk_eclass->ec_min_security; ec->ec_max_security = pk->pk_eclass->ec_max_security; ec->ec_merged = pk->pk_eclass->ec_merged; root->eq_classes = lappend(root->eq_classes, ec); MemoryContextSwitchTo(oldcontext); info->compressed_rel->eclass_indexes = bms_add_member(info->compressed_rel->eclass_indexes, root->eq_classes->length - 1); return ec; } static List * build_compressed_scan_pathkeys(const SortInfo *sort_info, PlannerInfo *root, List *chunk_pathkeys, const CompressionInfo *info) { Var *var; int varattno; List *required_compressed_pathkeys = NIL; ListCell *lc = NULL; PathKey *pk; /* * all segmentby columns need to be prefix of pathkeys * except those with equality constraint in baserestrictinfo */ if (info->num_segmentby_columns > 0) { TimescaleDBPrivate *compressed_fdw_private = (TimescaleDBPrivate *) info->compressed_rel->fdw_private; /* * We don't need any sorting for the segmentby columns that are equated * to a constant. The respective constant ECs are excluded from * canonical pathkeys, so we won't see these columns here. Count them as * seen from the start, so that we arrive at the proper counts of seen * segmentby columns in the end. */ for (lc = list_head(chunk_pathkeys); lc; lc = lnext(chunk_pathkeys, lc)) { PathKey *pk = lfirst(lc); EquivalenceMember *compressed_em = NULL; ListCell *ec_em_pair_cell; foreach (ec_em_pair_cell, compressed_fdw_private->compressed_ec_em_pairs) { List *pair = lfirst(ec_em_pair_cell); if (linitial(pair) == pk->pk_eclass) { compressed_em = lsecond(pair); break; } } /* * We should exit the loop after we've seen all required segmentby * columns. If we haven't seen them all, but the next pathkey * already refers a compressed column, it is a bug. See * build_sortinfo(). */ if (!compressed_em) break; required_compressed_pathkeys = lappend(required_compressed_pathkeys, pk); } } /* * If pathkeys contains non-segmentby columns the rest of the ordering * requirements will be satisfied by ordering by sequence_num. */ if (sort_info->needs_sequence_num) { /* TODO: split up legacy sequence number path and non-sequence number path into dedicated * functions. */ if (info->has_seq_num) { bool nulls_first; Oid sortop; varattno = get_attnum(info->compressed_rte->relid, COMPRESSION_COLUMN_METADATA_SEQUENCE_NUM_NAME); var = makeVar(info->compressed_rel->relid, varattno, INT4OID, -1, InvalidOid, 0); if (sort_info->reverse) { sortop = get_commutator(Int4LessOperator); nulls_first = true; } else { sortop = Int4LessOperator; nulls_first = false; } /* * Create the EquivalenceClass for the sequence number column of this * compressed chunk, so that we can build the PathKey that refers to it. */ EquivalenceClass *ec = append_ec_for_seqnum(root, info, sort_info, var, sortop, nulls_first); /* Find the operator in pg_amop --- failure shouldn't happen. */ Oid opfamily, opcintype; CompareType strategy; if (!get_ordering_op_properties(sortop, &opfamily, &opcintype, &strategy)) elog(ERROR, "operator %u is not a valid ordering operator", sortop); pk = make_canonical_pathkey(root, ec, opfamily, strategy, nulls_first); required_compressed_pathkeys = lappend(required_compressed_pathkeys, pk); } else { /* If there are no segmentby pathkeys, start from the beginning of the list */ if (info->num_segmentby_columns == 0) { lc = list_head(chunk_pathkeys); } Assert(lc != NULL); Expr *expr; char *column_name; for (; lc != NULL; lc = lnext(chunk_pathkeys, lc)) { pk = lfirst(lc); expr = ts_find_em_expr_for_rel(pk->pk_eclass, info->chunk_rel); Assert(expr != NULL && IsA(expr, Var)); var = castNode(Var, expr); Assert(var->varattno > 0); column_name = get_attname(info->chunk_rte->relid, var->varattno, false); int16 orderby_index = ts_array_position(info->settings->fd.orderby, column_name); varattno = get_attnum(info->compressed_rte->relid, column_segment_min_name(orderby_index)); Assert(orderby_index != 0); bool orderby_desc = ts_array_get_element_bool(info->settings->fd.orderby_desc, orderby_index); bool orderby_nullsfirst = ts_array_get_element_bool(info->settings->fd.orderby_nullsfirst, orderby_index); bool nulls_first; CompareType strategy; if (sort_info->reverse) { strategy = orderby_desc ? BTLessStrategyNumber : BTGreaterStrategyNumber; nulls_first = !orderby_nullsfirst; } else { strategy = orderby_desc ? BTGreaterStrategyNumber : BTLessStrategyNumber; nulls_first = orderby_nullsfirst; } var = makeVar(info->compressed_rel->relid, varattno, var->vartype, var->vartypmod, var->varcollid, var->varlevelsup); EquivalenceClass *min_ec = append_ec_for_metadata_col(root, info, var, pk); PathKey *min = make_canonical_pathkey(root, min_ec, pk->pk_opfamily, strategy, nulls_first); required_compressed_pathkeys = lappend(required_compressed_pathkeys, min); varattno = get_attnum(info->compressed_rte->relid, column_segment_max_name(orderby_index)); var = makeVar(info->compressed_rel->relid, varattno, var->vartype, var->vartypmod, var->varcollid, var->varlevelsup); EquivalenceClass *max_ec = append_ec_for_metadata_col(root, info, var, pk); PathKey *max = make_canonical_pathkey(root, max_ec, pk->pk_opfamily, strategy, nulls_first); required_compressed_pathkeys = lappend(required_compressed_pathkeys, max); } } } return required_compressed_pathkeys; } ColumnarScanPath * copy_columnar_scan_path(ColumnarScanPath *src) { Assert(ts_is_columnar_scan_path(&src->custom_path.path)); ColumnarScanPath *dst = palloc(sizeof(ColumnarScanPath)); memcpy(dst, src, sizeof(ColumnarScanPath)); return dst; } /* * Maps the attno of the min metadata column in the compressed chunk to the * attno of the corresponding max metadata column. Zero if none or not applicable. */ typedef struct SelectivityEstimationContext { AttrNumber *min_to_max; AttrNumber *max_to_min; List *vars; } SelectivityEstimationContext; /* * Collect the Vars referencing the "min" metadata columns into the context->vars. */ static bool min_metadata_vars_collector(Node *orig_node, SelectivityEstimationContext *context) { if (orig_node == NULL) { /* * An expression node can have a NULL field and the mutator will be * still called for it, so we have to handle this. */ return false; } if (!IsA(orig_node, Var)) { /* * Recurse. */ return expression_tree_walker(orig_node, min_metadata_vars_collector, context); } Var *orig_var = castNode(Var, orig_node); if (orig_var->varattno <= 0) { /* * We don't handle special variables. Not sure how it could happen though. */ return false; } AttrNumber replaced_attno = context->min_to_max[orig_var->varattno]; if (replaced_attno == InvalidAttrNumber) { /* * No replacement for this column. */ return false; } context->vars = lappend(context->vars, orig_var); return false; } static void set_compressed_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel, CompressionInfo *compression_info) { /* * We need some custom selectivity estimation code for the compressed chunk * table, because some pushed down filters require special handling. * * An equality condition can be pushed down to the minmax sparse index * condition, and becomes x_min <= const and const <= x_max. Postgres * treats the part of this condition as independent, which leads to * significant overestimates when x has high cardinality, and therefore * not using the Index Scan. This stems from the fact that Postgres doesn't * know that x_max is always just very slightly more than x_min for the * given compressed batch. * To work around this, temporarily replace all conditions on x_min with * conditions on x_max before feeding them to the Postgres clauselist * selectivity functions. Since the range of x_min to x_max for a given * batch is small relative to the range of x in the entire chunk, this * should not introduce much error, but at the same time allow Postgres to * see the correlation. * * We do this here for the entire baserestrictinfo and not per-rinfo as we * add them during filter pushdown, because the Postgres clauselist * selectivity estimator must see the entire clause list to detect the range * conditions. * * First, build the correspondence of min metadata attno -> max metadata * attno for all minmax metadata. */ AttrNumber *storage = palloc0(2 * sizeof(AttrNumber) * compression_info->compressed_rel->max_attr); SelectivityEstimationContext context = { .min_to_max = &storage[0], .max_to_min = &storage[compression_info->compressed_rel->max_attr], }; for (int uncompressed_attno = 1; uncompressed_attno <= compression_info->chunk_rel->max_attr; uncompressed_attno++) { if (get_rte_attribute_is_dropped(compression_info->chunk_rte, uncompressed_attno)) { /* Skip the dropped column. */ continue; } const char *attname = get_attname(compression_info->chunk_rte->relid, uncompressed_attno, /* missing_ok = */ false); const int16 orderby_pos = ts_array_position(compression_info->settings->fd.orderby, attname); if (orderby_pos == 0) { /* * This reasoning is only applicable to orderby columns, where each * batch is a thin slice of the entire range of the column. It also does * not have many intersections, because the compressed batches mostly * follow the total order of orderby columns, that is relaxed for the * last orderby columns or unordered chunks.This does not necessarily * hold for non-orderby columns that can also have a sparse index. */ continue; } AttrNumber min_attno = compressed_column_metadata_attno(compression_info->settings, compression_info->chunk_rte->relid, uncompressed_attno, compression_info->compressed_rte->relid, "min"); AttrNumber max_attno = compressed_column_metadata_attno(compression_info->settings, compression_info->chunk_rte->relid, uncompressed_attno, compression_info->compressed_rte->relid, "max"); if (min_attno == InvalidAttrNumber || max_attno == InvalidAttrNumber) { continue; } context.min_to_max[min_attno] = max_attno; context.max_to_min[max_attno] = min_attno; } /* * Then, replace all conditions on min metadata column with conditions on * max metadata column. */ ListCell *lc; foreach (lc, rel->baserestrictinfo) { RestrictInfo *orig_restrictinfo = castNode(RestrictInfo, lfirst(lc)); Node *orig_clause = (Node *) orig_restrictinfo->clause; expression_tree_walker(orig_clause, min_metadata_vars_collector, &context); } /* * Temporarily replace "min" with "max" in-place to save on memory allocations. */ foreach (lc, context.vars) { Var *var = castNode(Var, lfirst(lc)); Assert(var->varattno != InvalidAttrNumber); Assert(context.min_to_max[var->varattno] != InvalidAttrNumber); Assert(context.max_to_min[context.min_to_max[var->varattno]] == var->varattno); var->varattno = context.min_to_max[var->varattno]; } /* * Compute selectivity with the updated filters. */ set_baserel_size_estimates(root, rel); /* * Replace the Vars back. */ foreach (lc, context.vars) { Var *var = castNode(Var, lfirst(lc)); var->varattno = context.max_to_min[var->varattno]; } pfree(storage); } static CompressionInfo * build_compressioninfo(PlannerInfo *root, const Hypertable *ht, const Chunk *chunk, RelOptInfo *chunk_rel) { AppendRelInfo *appinfo; CompressionInfo *info = palloc0(sizeof(CompressionInfo)); info->compresseddata_oid = ts_custom_type_cache_get(CUSTOM_TYPE_COMPRESSED_DATA)->type_oid; info->chunk_rel = chunk_rel; info->chunk_rte = planner_rt_fetch(chunk_rel->relid, root); info->settings = ts_compression_settings_get(chunk->table_id); if (chunk_rel->reloptkind == RELOPT_OTHER_MEMBER_REL) { appinfo = ts_get_appendrelinfo(root, chunk_rel->relid, false); RangeTblEntry *rte = planner_rt_fetch(appinfo->parent_relid, root); if (rte->rtekind == RTE_RELATION) { info->ht_rte = rte; info->ht_rel = root->simple_rel_array[appinfo->parent_relid]; } else { /* In UNION queries referencing chunks directly, the parent rel can be a subquery */ Assert(rte->rtekind == RTE_SUBQUERY); info->single_chunk = true; info->ht_rte = info->chunk_rte; info->ht_rel = info->chunk_rel; } } else { Assert(chunk_rel->reloptkind == RELOPT_BASEREL); info->single_chunk = true; info->ht_rte = info->chunk_rte; info->ht_rel = info->chunk_rel; } info->hypertable_id = ht->fd.id; info->num_orderby_columns = ts_array_length(info->settings->fd.orderby); info->num_segmentby_columns = ts_array_length(info->settings->fd.segmentby); if (info->num_segmentby_columns) { ArrayIterator it = array_create_iterator(info->settings->fd.segmentby, 0, NULL); Datum datum; bool isnull; while (array_iterate(it, &datum, &isnull)) { Ensure(!isnull, "NULL element in catalog array"); AttrNumber chunk_attno = get_attnum(info->chunk_rte->relid, TextDatumGetCString(datum)); info->chunk_segmentby_attnos = bms_add_member(info->chunk_segmentby_attnos, chunk_attno); } } info->has_seq_num = get_attnum(info->settings->fd.compress_relid, COMPRESSION_COLUMN_METADATA_SEQUENCE_NUM_NAME) != InvalidAttrNumber; info->chunk_const_segmentby = find_const_segmentby(chunk_rel, info); /* * If the chunk is member of hypertable expansion or a UNION, find its * parent relation ids. We will use it later to filter out some parameterized * paths. */ if (chunk_rel->reloptkind == RELOPT_OTHER_MEMBER_REL) { info->parent_relids = find_childrel_parents(root, chunk_rel); } return info; } /* * Estimate the average count of elements in the compressed batch based on the * Postgres statistics for _ts_meta_count column. * Returns TARGET_COMPRESSED_BATCH_SIZE when no pg_statistic entry exists. */ static double estimate_compressed_batch_size(PlannerInfo *root, const CompressionInfo *compression_info) { AttrNumber attnum = get_attnum(compression_info->compressed_rte->relid, "_ts_meta_count"); if (attnum == InvalidAttrNumber) return TARGET_COMPRESSED_BATCH_SIZE; Var *var = makeVar(compression_info->compressed_rel->relid, attnum, INT4OID, -1, InvalidOid, 0); /* fetch statistics */ VariableStatData vardata; examine_variable(root, (Node *) var, 0, &vardata); if (!HeapTupleIsValid(vardata.statsTuple)) { ReleaseVariableStats(vardata); return TARGET_COMPRESSED_BATCH_SIZE; } double mcv_sum = 0.0; double mcv_freq = 0.0; /* exact MCV contribution */ AttStatsSlot mcvslot; if (get_attstatsslot(&mcvslot, vardata.statsTuple, STATISTIC_KIND_MCV, InvalidOid, ATTSTATSSLOT_VALUES | ATTSTATSSLOT_NUMBERS)) { for (int i = 0; i < mcvslot.nvalues; i++) { double val = (double) DatumGetInt32(mcvslot.values[i]); double freq = (double) mcvslot.numbers[i]; mcv_sum += val * freq; mcv_freq += freq; } free_attstatsslot(&mcvslot); } double hist_sum = 0.0; /* histogram contribution */ AttStatsSlot histslot; if (get_attstatsslot(&histslot, vardata.statsTuple, STATISTIC_KIND_HISTOGRAM, InvalidOid, ATTSTATSSLOT_VALUES)) { int buckets = histslot.nvalues - 1; if (buckets > 0 && mcv_freq < 1.0) { for (int i = 0; i < buckets; i++) { double lo = (double) DatumGetInt32(histslot.values[i]); double hi = (double) DatumGetInt32(histslot.values[i + 1]); hist_sum += (lo + hi) / 2.0; } hist_sum *= (1.0 - mcv_freq) / buckets; } free_attstatsslot(&histslot); } ReleaseVariableStats(vardata); const double final_result = mcv_sum + hist_sum; if (final_result == 0) { /* * For tables with few rows, the statistics tuple will contain all zero * values. We shouldn't return zero in this case to avoid weird behavior. */ return TARGET_COMPRESSED_BATCH_SIZE; } return final_result; } /* * calculate cost for ColumnarScanPath * * since we have to read whole batch before producing tuple * we put cost of 1 tuple of compressed_scan as startup cost */ static void cost_columnar_scan(PlannerInfo *root, const CompressionInfo *compression_info, Path *path, Path *compressed_path) { /* startup_cost is cost before fetching first tuple */ const double compressed_rows = Max(1, compressed_path->rows); path->startup_cost = compressed_path->startup_cost + (compressed_path->total_cost - compressed_path->startup_cost) / compressed_rows; /* total_cost is cost for fetching all tuples */ path->rows = compressed_path->rows * compression_info->compressed_batch_size; path->total_cost = compressed_path->total_cost + path->rows * cpu_tuple_cost; #if PG18_GE /* PG18 changes the way we handle disabled nodes so we * need to take those into account as well. * * https://github.com/postgres/postgres/commit/e2225346 */ path->disabled_nodes = compressed_path->disabled_nodes; #endif } /* Smoothstep function S1 (the h01 cubic Hermite spline). */ static double smoothstep(double x, double start, double end) { x = (x - start) / (end - start); if (x < 0) { x = 0; } else if (x > 1) { x = 1; } return x * x * (3.0F - 2.0F * x); } /* * If the query 'order by' is prefix of the compression 'order by' (or equal), we can exploit * the ordering of the individual batches to create a total ordered result without resorting * the tuples. This speeds up all queries that use this ordering (because no sort node is * needed). In particular, queries that use a LIMIT are speed-up because only the top elements * of the affected batches needs to be decompressed. Without the optimization, the entire batches * are decompressed, sorted, and then the top elements are taken from the result. * * The idea is to do something similar to the MergeAppend node; a BinaryHeap is used * to merge the per segment by column sorted individual batches into a sorted result. So, we end * up which a data flow which looks as follows: * * ColumnarScan * * Decompress Batch 1 * * Decompress Batch 2 * * Decompress Batch 3 * [....] * * Decompress Batch N * * Using the presorted batches, we are able to open these batches dynamically. If we don't presort * them, we would have to open all batches at the same time. This would be similar to the work the * MergeAppend does, but this is not needed in our case and we could reduce the size of the heap and * the amount of parallel open batches. * * The algorithm works as follows: * * (1) A sort node is placed below the decompress scan node and on top of the scan * on the compressed chunk. This sort node uses the min/max values of the 'order by' * columns from the metadata of the batch to get them into an order which can be * used to merge them. * * [Scan on compressed chunk] -> [Sort on min/max values] -> [Decompress and merge] * * For example, the batches are sorted on the min value of the 'order by' metadata * column: [0, 3] [0, 5] [3, 7] [6, 10] * * (2) The decompress chunk node initializes a binary heap, opens the first batch and * decompresses the first tuple from the batch. The tuple is put on the heap. In addition * the opened batch is marked as the most recent batch (MRB). * * (3) As soon as a tuple is requested from the heap, the following steps are performed: * (3a) If the heap is empty, we are done. * (3b) The top tuple from the heap is taken. It is checked if this tuple is from the * MRB. If this is the case, the next batch is opened, the first tuple is decompressed, * placed on the heap and this batch is marked as MRB. This is repeated until the * top tuple from the heap is not from the MRB. After the top tuple is not from the * MRB, all batches (and one ahead) which might contain the most recent tuple are * opened and placed on the heap. * * In the example above, the first three batches are opened because the first two * batches might contain tuples with a value of 0. * (3c) The top element from the heap is removed, the next tuple from the batch is * decompressed (if present) and placed on the heap. * (3d) The former top tuple of the heap is returned. * * This function calculate the costs for retrieving the decompressed in-order * using a binary heap. */ static void cost_batch_sorted_merge(PlannerInfo *root, const CompressionInfo *compression_info, ColumnarScanPath *dcpath, Path *compressed_path) { Path sort_path; /* dummy for result of cost_sort */ /* * Don't disable the compressed batch sorted merge plan with the enable_sort * GUC. We have a separate GUC for it, and this way you can try to force the * batch sorted merge plan by disabling sort. */ const bool old_enable_sort = enable_sort; enable_sort = true; cost_sort(&sort_path, root, dcpath->required_compressed_pathkeys, #if PG18_GE compressed_path->disabled_nodes, #endif compressed_path->total_cost, compressed_path->rows, compressed_path->pathtarget->width, 0.0, work_mem, -1); enable_sort = old_enable_sort; /* * In compressed batch sorted merge, for each distinct segmentby value we * have to keep the corresponding latest batch open. Estimate the number of * these batches with the usual Postgres estimator for grouping cardinality. */ List *segmentby_groupexprs = NIL; for (int segmentby_attno = bms_next_member(compression_info->chunk_segmentby_attnos, -1); segmentby_attno > 0; segmentby_attno = bms_next_member(compression_info->chunk_segmentby_attnos, segmentby_attno)) { char *colname = get_attname(compression_info->chunk_rte->relid, segmentby_attno, /* missing_ok = */ false); AttrNumber compressed_attno = get_attnum(compression_info->compressed_rte->relid, colname); Ensure(compressed_attno != InvalidAttrNumber, "segmentby column %s not found in compressed chunk %d", colname, compression_info->compressed_rte->relid); Var *var = palloc(sizeof(Var)); *var = (Var){ .xpr.type = T_Var, .varno = compression_info->compressed_rel->relid, .varattno = compressed_attno }; segmentby_groupexprs = lappend(segmentby_groupexprs, var); } const double open_batches_estimated = estimate_num_groups(root, segmentby_groupexprs, dcpath->custom_path.path.rows, NULL, NULL); Assert(open_batches_estimated > 0); /* * We can't have more open batches than the total number of compressed rows, * so clamp it for sanity of the following calculations. */ const double open_batches_clamped = Min(open_batches_estimated, sort_path.rows); /* * Keeping a lot of batches open might use a lot of memory. The batch sorted * merge can't offload anything to disk, so we just penalize it heavily if * we expect it to go over the work_mem. First, estimate the amount of * memory we'll need. We do this on the basis of uncompressed chunk width, * as if we had to materialize entire decompressed batches. This might * be less precise when bulk decompression is not used, because we * materialize only the compressed data which is smaller. But it accounts * for projections, which is probably more important than precision, because * we often read a small subset of columns in analytical queries. The * compressed chunk is never projected so we can't use it for that. */ const double work_mem_bytes = work_mem * 1024.0; const double needed_memory_bytes = open_batches_clamped * compression_info->compressed_batch_size * dcpath->custom_path.path.pathtarget->width; /* * Next, calculate the cost penalty. It is a smooth step, starting at 75% of * work_mem, and ending at 125%. We want to effectively disable this plan * if it doesn't fit into the available memory, so the penalty should be * comparable to disable_cost but still less than it, so that the * manual disables still have priority. */ const double work_mem_penalty = 0.1 * disable_cost * smoothstep(needed_memory_bytes, 0.75 * work_mem_bytes, 1.25 * work_mem_bytes); Assert(work_mem_penalty >= 0); /* * startup_cost is cost before fetching first tuple. Batch sorted merge has * to load at least the number of batches we expect to be open * simultaneously, before it can produce the first row. */ const double sort_path_cost_for_startup = sort_path.startup_cost + ((sort_path.total_cost - sort_path.startup_cost) * (open_batches_clamped / sort_path.rows)); Assert(sort_path_cost_for_startup >= 0); dcpath->custom_path.path.startup_cost = sort_path_cost_for_startup + work_mem_penalty; /* * Finally, to run this path to completion, we have to complete the * underlying sort path, and return all uncompressed rows. Getting one * uncompressed row involves replacing the top row in the heap, which costs * O(log(heap size)). The constant multiplier is found empirically by * benchmarking the queries returning 1 - 1e9 tuples, with segmentby * cardinality 1 to 1e4, and adjusting the cost so that the fastest plan is * used. The "+ 1" under the logarithm is to avoid zero uncompressed row cost * when we expect to have only 1 batch open. */ const double sort_path_cost_rest = sort_path.total_cost - sort_path_cost_for_startup; Assert(sort_path_cost_rest >= 0); const double uncompressed_row_cost = 1.5 * log(open_batches_clamped + 1) * cpu_tuple_cost; Assert(uncompressed_row_cost > 0); dcpath->custom_path.path.total_cost = dcpath->custom_path.path.startup_cost + sort_path_cost_rest + dcpath->custom_path.path.rows * uncompressed_row_cost; #if PG18_GE /* PG18 changes the way we handle disabled nodes so we * need to take those into account as well. * * https://github.com/postgres/postgres/commit/e2225346 */ dcpath->custom_path.path.disabled_nodes = sort_path.disabled_nodes; #endif } /* * This function adds per-chunk sorted paths for compressed chunks if beneficial. This has two * advantages: * * (1) Make ChunkAppend possible. If at least one chunk of a hypertable is uncompressed, PostgreSQL * will generate a MergeAppend path in generate_orderedappend_paths() / create_merge_append_path() * due to the existing pathkeys of the index on the uncompressed chunk. If all chunks are * compressed, no path keys are present and no MergeAppend path is generated by PostgreSQL. In that * case, the ChunkAppend optimization cannot be used because MergeAppend path can be promoted in * ts_chunk_append_path_create(). Adding a sorted path with pathkeys makes ChunkAppend possible for * these queries. * * (2) Sorting on a per-chunk basis and merging / appending these results could be faster than * sorting the whole input. Especially limit queries that use an ORDER BY that is compatible with * the partitioning of the hypertable could be inefficiently executed otherwise. For example, an * expensive query plan with a sort node on top of the append node could be chosen. Due to the sort * node at the high level in the query plan and the missing ChunkAppend node (see (1)), all chunks * are decompressed (instead of only the actually needed ones). * * If existing index pathkeys do not match query pathkeys and sort cannot be pushed down * into compressed index, for example "SELECT * FROM ... ORDER BY (segcol, time DESC, some_col)" if * compressed index is (segcol, time DESC), we should allow SortPath over (ColumnarScan * <- IndexScan) for such cases, i.e. should consider IndexScan compressed paths along with SeqScan * compressed paths. IndexScans with useful index conditions can be cheaper than SeqScans. * * The logic is inspired by PostgreSQL's add_paths_with_pathkeys_for_rel() function. * * Note: This function adds only non-partial paths. In parallel plans PostgreSQL prefers sorting * directly under the gather (merge) node and the per-chunk sorting are not used in parallel plans. * To save planning time, we therefore refrain from adding them. */ static Path * make_chunk_sorted_path(PlannerInfo *root, RelOptInfo *chunk_rel, Path *path, Path *compressed_path, const SortInfo *sort_info) { /* * Don't have a useful sorting after decompression. */ if (sort_info->decompressed_sort_pathkeys == NIL) { return NULL; } Assert(ts_is_columnar_scan_path(path)); /* * We should be given an unsorted ColumnarScan path. */ Assert(path->pathkeys == NIL); /* * Create the sorted path for these useful_pathkeys. Copy the decompress * chunk path because the original can be recycled in add_path, and our * sorted path must be independent. */ ColumnarScanPath *path_copy = copy_columnar_scan_path((ColumnarScanPath *) path); /* * Create the Sort path. */ Path *sorted_path = (Path *) create_sort_path(root, chunk_rel, (Path *) path_copy, sort_info->decompressed_sort_pathkeys, root->limit_tuples); /* Set in "create_sort_path" in PG18GE, have to set separately for PG17LE. * Need to preserve info for sort over parametrized index paths. */ sorted_path->param_info = path->param_info; /* * Now, we need another dumb workaround for Postgres problems. When creating * a sort plan, it performs a linear search of equivalence member of a * pathkey's equivalence class, that matches the sorted relation (see * prepare_sort_from_pathkeys()). This is effectively quadratic in the * number of chunks, and becomes a real CPU sink after we pass 1k chunks. * Try to reflect this in the costs, because in some cases a chunk-wise sort * might be avoided, e.g. Limit 1 over MergeAppend over chunk-wise Sort can * be just as well replaced with a Limit 1 over Sort over Append of chunks, * that is just marginally costlier. * * We can't easily know the number of chunks in the query here, so add some * startup cost that is quadratic in the current chunk index, which * hopefully should be a good enough replacement. */ const int parent_relindex = bms_next_member(chunk_rel->top_parent_relids, -1); if (parent_relindex) { const int chunk_index = chunk_rel->relid - parent_relindex; sorted_path->startup_cost += cpu_operator_cost * chunk_index * chunk_index; sorted_path->total_cost += cpu_operator_cost * chunk_index * chunk_index; } return sorted_path; } static List *build_on_single_compressed_path(PlannerInfo *root, const Chunk *chunk, RelOptInfo *chunk_rel, Path *compressed_path, bool add_uncompressed_part, List *uncompressed_table_pathlist, const SortInfo *sort_info, const CompressionInfo *compression_info); void ts_columnar_scan_generate_paths(PlannerInfo *root, RelOptInfo *chunk_rel, const Hypertable *ht, const Chunk *chunk) { /* * For UPDATE/DELETE commands, the executor decompresses and brings the rows into * the uncompressed chunk. Therefore, it's necessary to add the scan on the * uncompressed portion. */ bool add_uncompressed_part = ts_chunk_is_partial(chunk); if (ts_chunk_is_compressed(chunk) && ts_cm_functions->decompress_target_segments && !add_uncompressed_part) { for (PlannerInfo *proot = root->parent_root; proot != NULL && !add_uncompressed_part; proot = proot->parent_root) { /* * We could additionally check and compare that the relation involved in the subquery * and the DML target relation are one and the same. But these kinds of queries * should be rare. */ if (proot->parse->commandType == CMD_UPDATE || proot->parse->commandType == CMD_DELETE #if PG15_GE || proot->parse->commandType == CMD_MERGE #endif ) { add_uncompressed_part = true; } } } CompressionInfo *compression_info = build_compressioninfo(root, ht, chunk, chunk_rel); /* double check we don't end up here on single chunk queries with ONLY */ Assert(compression_info->chunk_rel->reloptkind == RELOPT_OTHER_MEMBER_REL || (compression_info->chunk_rel->reloptkind == RELOPT_BASEREL && ts_rte_is_marked_for_expansion(compression_info->chunk_rte))); SortInfo sort_info = build_sortinfo(root, chunk, chunk_rel, compression_info, root->query_pathkeys); Assert(chunk->fd.compressed_chunk_id > 0); List *uncompressed_table_pathlist = chunk_rel->pathlist; List *uncompressed_table_parallel_pathlist = chunk_rel->partial_pathlist; chunk_rel->pathlist = NIL; chunk_rel->partial_pathlist = NIL; /* add RangeTblEntry and RelOptInfo for compressed chunk */ columnar_scan_add_plannerinfo(root, compression_info, chunk, chunk_rel, sort_info.needs_sequence_num); if (sort_info.use_compressed_sort) { sort_info.required_compressed_pathkeys = build_compressed_scan_pathkeys(&sort_info, root, root->query_pathkeys, compression_info); } RelOptInfo *compressed_rel = compression_info->compressed_rel; compressed_rel->consider_parallel = chunk_rel->consider_parallel; /* translate chunk_rel->baserestrictinfo */ pushdown_quals(root, compression_info->settings, chunk_rel, compressed_rel, add_uncompressed_part); /* * Estimate the size of the compressed chunk table. */ set_compressed_baserel_size_estimates(root, compressed_rel, compression_info); /* * Estimate the size of the compressed batch from Postgres * statistics. */ compression_info->compressed_batch_size = estimate_compressed_batch_size(root, compression_info); /* * Estimate the size of decompressed chunk based on the compressed chunk. * * The tuple estimates derived from pg_class will be empty, so we have to * compute that based on the compressed relation as well. Wrong estimates * there lead to wrong join order choice and wrong low cost for Sort over * Append, and also different MergeAppend costs on Postgres before 17 due to * a bug there. */ const double new_row_estimate = compressed_rel->rows * compression_info->compressed_batch_size; const double new_tuples_estimate = compressed_rel->tuples * compression_info->compressed_batch_size; if (!compression_info->single_chunk) { /* * Adjust the hypertable estimate by the diff of new and old chunk * estimate. */ AppendRelInfo *chunk_info = ts_get_appendrelinfo(root, chunk_rel->relid, false); const Index ht_relid = chunk_info->parent_relid; RelOptInfo *hypertable_rel = root->simple_rel_array[ht_relid]; const double delta = new_row_estimate - chunk_rel->rows; hypertable_rel->rows += delta; /* * For appendrel, set tuples to the same value as rows, * like set_append_rel_size() does. */ hypertable_rel->tuples += delta; } chunk_rel->rows = new_row_estimate; chunk_rel->tuples = new_tuples_estimate; /* * Create the paths for the compressed chunk table. */ create_compressed_scan_paths(root, compressed_rel, compression_info, &sort_info); /* create non-parallel paths */ ListCell *compressed_cell; foreach (compressed_cell, compressed_rel->pathlist) { Path *compressed_path = lfirst(compressed_cell); List *decompressed_paths = build_on_single_compressed_path(root, chunk, chunk_rel, compressed_path, add_uncompressed_part, uncompressed_table_pathlist, &sort_info, compression_info); /* * We want to consider startup costs so that IndexScan is preferred to * sorted SeqScan when we may have a chance to use SkipScan. We consider * startup costs for LIMIT queries, and SkipScan is basically a * "LIMIT 1" query run "ndistinct" times. At this point we don't have * all information to check if SkipScan can be used, but we can narrow * it down. */ if (!chunk_rel->consider_startup && IsA(compressed_path, IndexPath)) { /* Candidate for SELECT DISTINCT SkipScan */ if (list_length(root->distinct_pathkeys) == 1 /* Candidate for DISTINCT aggregate SkipScan */ || (root->numOrderedAggs >= 1 && list_length(root->group_pathkeys) == 1)) { chunk_rel->consider_startup = true; } } /* * Add the paths to the chunk relation. */ ListCell *decompressed_cell; foreach (decompressed_cell, decompressed_paths) { Path *path = lfirst(decompressed_cell); add_path(chunk_rel, path); } } /* create parallel paths */ List *uncompressed_paths_with_parallel = list_concat(uncompressed_table_parallel_pathlist, uncompressed_table_pathlist); foreach (compressed_cell, compressed_rel->partial_pathlist) { Path *compressed_path = lfirst(compressed_cell); List *decompressed_paths = build_on_single_compressed_path(root, chunk, chunk_rel, compressed_path, add_uncompressed_part, uncompressed_paths_with_parallel, &sort_info, compression_info); /* * Add the paths to the chunk relation. */ ListCell *decompressed_cell; foreach (decompressed_cell, decompressed_paths) { Path *path = lfirst(decompressed_cell); add_partial_path(chunk_rel, path); } } /* the chunk_rel now owns the paths, remove them from the compressed_rel so they can't be freed * if it's planned */ compressed_rel->pathlist = NIL; compressed_rel->partial_pathlist = NIL; /* * Remove the compressed_rel from planner arrays to prevent it from being * referenced again. */ root->simple_rel_array[compressed_rel->relid] = NULL; root->append_rel_array[compressed_rel->relid] = NULL; /* We should never get in the situation with no viable paths. */ Ensure(chunk_rel->pathlist, "could not create decompression path"); } /* * Add various decompression paths that are possible based on the given * compressed path. */ static List * build_on_single_compressed_path(PlannerInfo *root, const Chunk *chunk, RelOptInfo *chunk_rel, Path *compressed_path, bool add_uncompressed_part, List *uncompressed_table_pathlist, const SortInfo *sort_info, const CompressionInfo *compression_info) { /* * We skip any BitmapScan parameterized paths here as supporting * those would require fixing up the internal scan. Since we * currently do not do this BitmapScans would be generated * when we have a parameterized path on a compressed column * that would have invalid references due to our * EquivalenceClasses. */ if (IsA(compressed_path, BitmapHeapPath) && compressed_path->param_info) return NIL; /* * Filter out all paths that try to JOIN the compressed chunk on the * hypertable or the uncompressed chunk * Ideally, we wouldn't create these paths in the first place. * However, create_join_clause code is called by PG while generating paths for the * compressed_rel via generate_implied_equalities_for_column. * create_join_clause ends up creating rinfo's between compressed_rel and ht because * PG does not know that compressed_rel is related to ht in anyway. * The parent-child relationship between chunk_rel and ht is known * to PG and so it does not try to create meaningless rinfos for that case. */ if (compressed_path->param_info != NULL) { if (bms_is_member(chunk_rel->relid, compressed_path->param_info->ppi_req_outer)) return NIL; /* check if this is path made with references between * compressed_rel + hypertable or a nesting subquery. * The latter can happen in the case of UNION queries. see github 2917. This * happens since PG is not aware that the nesting * subquery that references the hypertable is a parent of compressed_rel as well. */ if (bms_overlap(compression_info->parent_relids, compressed_path->param_info->ppi_req_outer)) { return NIL; } } Path *chunk_path_no_sort = (Path *) columnar_scan_path_create(root, compression_info, compressed_path); List *decompressed_paths = list_make1(chunk_path_no_sort); /* * Create a path for the batch sorted merge optimization. This optimization * performs a sorted merge of the involved batches by using a binary heap * and preserving the compression order. This optimization is only * considered if we can't push down the sort to the compressed chunk. If we * can push down the sort, the batches can be directly consumed in this * order and we don't need to use this optimization. */ if (sort_info->use_batch_sorted_merge && ts_guc_enable_decompression_sorted_merge) { Assert(!sort_info->use_compressed_sort); ColumnarScanPath *path_copy = copy_columnar_scan_path((ColumnarScanPath *) chunk_path_no_sort); path_copy->reverse = sort_info->reverse; path_copy->batch_sorted_merge = true; /* * The segment by optimization is only enabled if it can deliver the tuples in the * same order as the query requested it. So, we can just copy the pathkeys of the * query here. */ path_copy->custom_path.path.pathkeys = sort_info->decompressed_sort_pathkeys; cost_batch_sorted_merge(root, compression_info, path_copy, compressed_path); if (ts_guc_debug_require_batch_sorted_merge == DRO_Force) { path_copy->custom_path.path.startup_cost = cpu_tuple_cost; path_copy->custom_path.path.total_cost = 2 * cpu_tuple_cost; } decompressed_paths = lappend(decompressed_paths, path_copy); } else if (ts_guc_debug_require_batch_sorted_merge == DRO_Require || ts_guc_debug_require_batch_sorted_merge == DRO_Force) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("debug: batch sorted merge is required but not possible at planning " "time"))); } /* * If we can push down the sort below the ColumnarScan node, we set the * pathkeys of the decompress node to the decompressed_sort_pathkeys. We * will determine whether to put an actual sort between the decompression * node and the scan during plan creation. */ if (sort_info->use_compressed_sort) { if (pathkeys_contained_in(sort_info->required_compressed_pathkeys, compressed_path->pathkeys)) { /* * The compressed path already has the required ordering. Modify * in place the no-sorting path we just created above. */ ColumnarScanPath *path = (ColumnarScanPath *) chunk_path_no_sort; path->reverse = sort_info->reverse; path->needs_sequence_num = sort_info->needs_sequence_num; path->required_compressed_pathkeys = sort_info->required_compressed_pathkeys; path->custom_path.path.pathkeys = sort_info->decompressed_sort_pathkeys; } else { /* * We must sort the underlying compressed path to get the * required ordering. Make a copy of no-sorting path and modify * it accordingly */ ColumnarScanPath *path_copy = copy_columnar_scan_path((ColumnarScanPath *) chunk_path_no_sort); path_copy->reverse = sort_info->reverse; path_copy->needs_sequence_num = sort_info->needs_sequence_num; path_copy->required_compressed_pathkeys = sort_info->required_compressed_pathkeys; path_copy->custom_path.path.pathkeys = sort_info->decompressed_sort_pathkeys; /* * Add costing for a sort. The standard Postgres pattern is to add the cost during * path creation, but not add the sort path itself, that's done during plan * creation. Examples of this in: create_merge_append_path & * create_merge_append_plan */ Path sort_path; /* dummy for result of cost_sort */ cost_sort(&sort_path, root, sort_info->required_compressed_pathkeys, #if PG18_GE compressed_path->disabled_nodes, #endif compressed_path->total_cost, compressed_path->rows, compressed_path->pathtarget->width, 0.0, work_mem, -1); cost_columnar_scan(root, compression_info, &path_copy->custom_path.path, &sort_path); decompressed_paths = lappend(decompressed_paths, path_copy); } } /* * Also try explicit sort after decompression, if we couldn't push down the * sort. Don't do this for parallel plans, because in this case it is * typically done with Sort under Gather node. This splits the Sort in * per-worker buckets, so splitting the buckets further per-chunk is less * important. */ if (!sort_info->use_compressed_sort && chunk_path_no_sort->parallel_workers == 0) { Path *sort_above_chunk = make_chunk_sorted_path(root, chunk_rel, chunk_path_no_sort, compressed_path, sort_info); if (sort_above_chunk != NULL) { decompressed_paths = lappend(decompressed_paths, sort_above_chunk); } } if (!add_uncompressed_part) { /* * If the chunk has only the compressed part, we're done. */ return decompressed_paths; } /* * This is a partially compressed chunk, we have to combine data from * compressed and uncompressed chunk. */ List *combined_paths = NIL; /* * All decompressed paths we've built have the same parameterization since * we're building on a single compressed path. We only inherit the * parameterization from it and don't add our own. */ Bitmapset *req_outer = PATH_REQ_OUTER(chunk_path_no_sort); /* * Look up the uncompressed chunk paths. We might need an unordered path * (SeqScan) and an ordered path (e.g. IndexScan). */ Path *unordered_uncompressed_path = get_cheapest_path_for_pathkeys(uncompressed_table_pathlist, NIL, req_outer, TOTAL_COST, false); Ensure(unordered_uncompressed_path != NULL, "couldn't find a scan path for uncompressed chunk table"); Path *ordered_uncompressed_path = NULL; if (sort_info->decompressed_sort_pathkeys != NIL) { ordered_uncompressed_path = get_cheapest_path_for_pathkeys(uncompressed_table_pathlist, sort_info->decompressed_sort_pathkeys, req_outer, TOTAL_COST, false); } /* * All children of an append path are required to have the same parameterization * so we reparameterize here when we couldn't get a path with the parameterization * we need. Reparameterization should always succeed here since uncompressed_path * should always be a scan. */ if (!bms_equal(req_outer, PATH_REQ_OUTER(unordered_uncompressed_path))) { unordered_uncompressed_path = reparameterize_path(root, unordered_uncompressed_path, req_outer, 1.0); Ensure(unordered_uncompressed_path != NULL, "couldn't reparameterize a scan path for uncompressed chunk table"); } if (ordered_uncompressed_path != NULL && !bms_equal(req_outer, PATH_REQ_OUTER(ordered_uncompressed_path))) { ordered_uncompressed_path = reparameterize_path(root, ordered_uncompressed_path, req_outer, 1.0); } /* * Create plain Append, potentially parallel. It only makes sense for the * unsorted input paths. */ { const int workers = Max(chunk_path_no_sort->parallel_workers, unordered_uncompressed_path->parallel_workers); List *parallel_paths = NIL; List *sequential_paths = NIL; if (chunk_path_no_sort->parallel_workers > 0) { parallel_paths = lappend(parallel_paths, chunk_path_no_sort); } else { sequential_paths = lappend(sequential_paths, chunk_path_no_sort); } if (unordered_uncompressed_path->parallel_workers > 0) { parallel_paths = lappend(parallel_paths, unordered_uncompressed_path); } else { sequential_paths = lappend(sequential_paths, unordered_uncompressed_path); } Path *plain_append = (Path *) create_append_path(root, chunk_rel, sequential_paths, parallel_paths, /* pathkeys = */ NIL, req_outer, workers, workers > 0, chunk_path_no_sort->rows + unordered_uncompressed_path->rows); combined_paths = lappend(combined_paths, plain_append); } if (sort_info->decompressed_sort_pathkeys == NIL) { /* * No sorting requested, so we're done after creating the plain Append * above. */ return combined_paths; } /* * We require sorting, try MergeAppend. */ Path *uncompressed_path_for_merge = ordered_uncompressed_path; if (uncompressed_path_for_merge == NULL || IsA(uncompressed_path_for_merge, SortPath)) { /* * Don't use explicit Sort as MergeAppend child, because the * MergeAppend adds the required sorting anyway. With the explicit * Sort it still works but performs the pathkey lookups twice, which * leads to planning performance regression. */ uncompressed_path_for_merge = unordered_uncompressed_path; } if (uncompressed_path_for_merge->parallel_workers > 0) { /* * MergeAppend can't be parallel. */ return combined_paths; } /* * For Merge Append, we consider: * 1) explicit sorting over decompressed path, * 2) compressed sort pushdown path, * 3) batch sorted merge path. * We have to make a cost-based decision between them (i.e. batch sorted * merge might be more expensive due to memory requirements). */ ListCell *lc; foreach (lc, decompressed_paths) { Path *decompression_path = lfirst(lc); if (decompression_path->parallel_workers > 0) { /* * MergeAppend can't be parallel. */ continue; } if (decompression_path == chunk_path_no_sort) { /* * We can't use the unsorted decompression path directly because it * doesn't have the sort projection cost workaround. */ continue; } if (!bms_is_empty(chunk_rel->lateral_relids) || !bms_is_empty(req_outer)) { /* * Parametrized MergeAppend paths are not supported. */ continue; } if (IsA(decompression_path, SortPath)) { /* * We have to remove the explicit Sort, otherwise it will lead to * planning time regression because of double call of * prepare_sort_from_pathkeys() in MergeAppend plan creation. Still, * we have to use the copy of ColumnarScan path that we created * for explicit sorting, because it has the sort projection cost * workaround. */ decompression_path = castNode(SortPath, decompression_path)->subpath; } Path *merge_append = (Path *) create_merge_append_path(root, chunk_rel, list_make2(decompression_path, uncompressed_path_for_merge), sort_info->decompressed_sort_pathkeys, req_outer); combined_paths = lappend(combined_paths, merge_append); } return combined_paths; } /* * Add a var for a particular column to the reltarget. attrs_used is a bitmap * of which columns we already have in reltarget. We do not add the columns that * are already there, and update it after adding something. */ static void compressed_reltarget_add_var_for_column(RelOptInfo *compressed_rel, Oid compressed_relid, const char *column_name, Bitmapset **attrs_used) { AttrNumber attnum = get_attnum(compressed_relid, column_name); Assert(attnum > 0); if (bms_is_member(attnum, *attrs_used)) { /* This column is already in reltarget, we don't need duplicates. */ return; } *attrs_used = bms_add_member(*attrs_used, attnum); Oid typid, collid; int32 typmod; get_atttypetypmodcoll(compressed_relid, attnum, &typid, &typmod, &collid); compressed_rel->reltarget->exprs = lappend(compressed_rel->reltarget->exprs, makeVar(compressed_rel->relid, attnum, typid, typmod, collid, 0)); } /* copy over the vars from the chunk_rel->reltarget to the compressed_rel->reltarget * altering the fields that need it */ static void compressed_rel_setup_reltarget(RelOptInfo *compressed_rel, CompressionInfo *info, bool needs_sequence_num) { bool have_whole_row_var = false; Bitmapset *attrs_used = NULL; Oid compressed_relid = info->compressed_rte->relid; /* * We have to decompress three kinds of columns: * 1) output targetlist of the relation, * 2) columns required for the quals (WHERE), * 3) columns required for joins. */ List *exprs = list_copy(info->chunk_rel->reltarget->exprs); ListCell *lc; foreach (lc, info->chunk_rel->baserestrictinfo) { exprs = lappend(exprs, ((RestrictInfo *) lfirst(lc))->clause); } foreach (lc, info->chunk_rel->joininfo) { exprs = lappend(exprs, ((RestrictInfo *) lfirst(lc))->clause); } /* * Now go over the required expressions we prepared above, and add the * required columns to the compressed reltarget. */ info->compressed_rel->reltarget->exprs = NIL; foreach (lc, exprs) { ListCell *lc2; List *chunk_vars = pull_var_clause(lfirst(lc), PVC_RECURSE_PLACEHOLDERS); foreach (lc2, chunk_vars) { char *column_name; Var *chunk_var = castNode(Var, lfirst(lc2)); /* skip vars that aren't from the uncompressed chunk */ if ((Index) chunk_var->varno != info->chunk_rel->relid) { continue; } /* * If there's a system column or whole-row reference, add a whole- * row reference, and we're done. */ if (chunk_var->varattno <= 0) { have_whole_row_var = true; continue; } column_name = get_attname(info->chunk_rte->relid, chunk_var->varattno, false); compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, column_name, &attrs_used); /* if the column is an orderby, add it's metadata columns too */ int16 index = ts_array_position(info->settings->fd.orderby, column_name); if (index != 0) { compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, column_segment_min_name(index), &attrs_used); compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, column_segment_max_name(index), &attrs_used); } } } /* always add the count column */ compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, COMPRESSION_COLUMN_METADATA_COUNT_NAME, &attrs_used); /* add the sequence number or orderby metadata columns if we try to order by them*/ if (needs_sequence_num) { if (info->has_seq_num) { compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, COMPRESSION_COLUMN_METADATA_SEQUENCE_NUM_NAME, &attrs_used); } else { for (int i = 1; i <= ts_array_length(info->settings->fd.orderby); i++) { compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, column_segment_min_name(i), &attrs_used); compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, column_segment_max_name(i), &attrs_used); } } } /* * It doesn't make sense to request a whole-row var from the compressed * chunk scan. If it is requested, just fetch the rest of columns. The * whole-row var will be created by the projection of ColumnarScan node. */ if (have_whole_row_var) { for (int i = 1; i <= info->chunk_rel->max_attr; i++) { char *column_name = get_attname(info->chunk_rte->relid, i, /* missing_ok = */ false); AttrNumber chunk_attno = get_attnum(info->chunk_rte->relid, column_name); if (chunk_attno == InvalidAttrNumber) { /* Skip the dropped column. */ continue; } AttrNumber compressed_attno = get_attnum(info->compressed_rte->relid, column_name); if (compressed_attno == InvalidAttrNumber) { elog(ERROR, "column '%s' not found in the compressed chunk '%s'", column_name, get_rel_name(info->compressed_rte->relid)); } if (bms_is_member(compressed_attno, attrs_used)) { continue; } compressed_reltarget_add_var_for_column(compressed_rel, compressed_relid, column_name, &attrs_used); } } } static Bitmapset * columnar_scan_adjust_child_relids(Bitmapset *src, int chunk_relid, int compressed_chunk_relid) { Bitmapset *result = NULL; if (src != NULL) { result = bms_copy(src); result = bms_del_member(result, chunk_relid); result = bms_add_member(result, compressed_chunk_relid); } return result; } /* based on adjust_appendrel_attrs_mutator handling of RestrictInfo */ static Node * chunk_joininfo_mutator(Node *node, CompressionInfo *context) { if (node == NULL) return NULL; if (IsA(node, Var)) { Var *var = castNode(Var, node); Var *compress_var = copyObject(var); char *column_name; AttrNumber compressed_attno; if ((Index) var->varno != context->chunk_rel->relid) return (Node *) var; column_name = get_attname(context->chunk_rte->relid, var->varattno, false); compressed_attno = get_attnum(context->compressed_rte->relid, column_name); compress_var->varno = context->compressed_rel->relid; compress_var->varattno = compressed_attno; return (Node *) compress_var; } else if (IsA(node, RestrictInfo)) { RestrictInfo *oldinfo = (RestrictInfo *) node; RestrictInfo *newinfo = makeNode(RestrictInfo); /* Copy all flat-copiable fields */ memcpy(newinfo, oldinfo, sizeof(RestrictInfo)); /* Recursively fix the clause itself */ newinfo->clause = (Expr *) chunk_joininfo_mutator((Node *) oldinfo->clause, context); /* and the modified version, if an OR clause */ newinfo->orclause = (Expr *) chunk_joininfo_mutator((Node *) oldinfo->orclause, context); /* adjust relid sets too */ newinfo->clause_relids = columnar_scan_adjust_child_relids(oldinfo->clause_relids, context->chunk_rel->relid, context->compressed_rel->relid); newinfo->required_relids = columnar_scan_adjust_child_relids(oldinfo->required_relids, context->chunk_rel->relid, context->compressed_rel->relid); newinfo->outer_relids = columnar_scan_adjust_child_relids(oldinfo->outer_relids, context->chunk_rel->relid, context->compressed_rel->relid); #if PG16_LT newinfo->nullable_relids = columnar_scan_adjust_child_relids(oldinfo->nullable_relids, context->chunk_rel->relid, context->compressed_rel->relid); #endif newinfo->left_relids = columnar_scan_adjust_child_relids(oldinfo->left_relids, context->chunk_rel->relid, context->compressed_rel->relid); newinfo->right_relids = columnar_scan_adjust_child_relids(oldinfo->right_relids, context->chunk_rel->relid, context->compressed_rel->relid); newinfo->eval_cost.startup = -1; newinfo->norm_selec = -1; newinfo->outer_selec = -1; newinfo->left_em = NULL; newinfo->right_em = NULL; newinfo->scansel_cache = NIL; newinfo->left_bucketsize = -1; newinfo->right_bucketsize = -1; newinfo->left_mcvfreq = -1; newinfo->right_mcvfreq = -1; return (Node *) newinfo; } return expression_tree_mutator(node, chunk_joininfo_mutator, context); } /* Check if the expression references a compressed column in compressed chunk. */ static bool has_compressed_vars_walker(Node *node, CompressionInfo *info) { if (node == NULL) { return false; } if (IsA(node, Var)) { Var *var = castNode(Var, node); if ((Index) var->varno != info->compressed_rel->relid) { return false; } if (var->varattno <= 0) { /* * Shouldn't see a system var here, might be a whole row var? * In any case, we can't push it down to the compressed scan level. */ return true; } if (bms_is_member(var->varattno, info->compressed_attnos_in_compressed_chunk)) { return true; } return false; } return expression_tree_walker(node, has_compressed_vars_walker, info); } static bool has_compressed_vars(RestrictInfo *ri, CompressionInfo *info) { return expression_tree_walker((Node *) ri->clause, has_compressed_vars_walker, info); } /* translate chunk_rel->joininfo for compressed_rel * this is necessary for create_index_path which gets join clauses from * rel->joininfo and sets up parameterized paths (in rel->ppilist). * ppi_clauses is finally used to add any additional filters on the * indexpath when creating a plan in create_indexscan_plan. * Otherwise we miss additional filters that need to be applied after * the index plan is executed (github issue 1558) */ static void compressed_rel_setup_joininfo(RelOptInfo *compressed_rel, CompressionInfo *info) { RelOptInfo *chunk_rel = info->chunk_rel; ListCell *lc; List *compress_joininfo = NIL; foreach (lc, chunk_rel->joininfo) { RestrictInfo *ri = (RestrictInfo *) lfirst(lc); RestrictInfo *adjusted = (RestrictInfo *) chunk_joininfo_mutator((Node *) ri, info); Assert(IsA(adjusted, RestrictInfo)); if (has_compressed_vars(adjusted, info)) { /* * We can't check clauses that refer to compressed columns during * the compressed scan. */ continue; } compress_joininfo = lappend(compress_joininfo, adjusted); } compressed_rel->joininfo = compress_joininfo; } typedef struct EMCreationContext { Oid uncompressed_relid; Oid compressed_relid; Index uncompressed_relid_idx; Index compressed_relid_idx; CompressionSettings *settings; } EMCreationContext; static Node * create_var_for_compressed_equivalence_member(Var *var, const EMCreationContext *context, const char *attname) { /* based on adjust_appendrel_attrs_mutator */ Assert((Index) var->varno == context->uncompressed_relid_idx); Assert(var->varattno > 0); var = (Var *) copyObject(var); if (var->varlevelsup == 0) { var->varno = context->compressed_relid_idx; var->varattno = get_attnum(context->compressed_relid, attname); var->varnosyn = var->varno; var->varattnosyn = var->varattno; return (Node *) var; } return NULL; } /* This function is inspired by the Postgres add_child_rel_equivalences. */ static bool add_segmentby_to_equivalence_class(PlannerInfo *root, EquivalenceClass *cur_ec, CompressionInfo *info, EMCreationContext *context) { TimescaleDBPrivate *compressed_fdw_private = (TimescaleDBPrivate *) info->compressed_rel->fdw_private; Assert(compressed_fdw_private != NULL); EquivalenceMember *cur_em; #if PG18_GE /* Use specialized iterator to include child ems. * * https://github.com/postgres/postgres/commit/d69d45a5 */ EquivalenceMemberIterator it; setup_eclass_member_iterator(&it, cur_ec, bms_make_singleton(info->chunk_rel->relid)); while ((cur_em = eclass_member_iterator_next(&it)) != NULL) { #else ListCell *lc; foreach (lc, cur_ec->ec_members) { cur_em = (EquivalenceMember *) lfirst(lc); #endif Expr *child_expr; Relids new_relids; Var *var; Assert(!bms_overlap(cur_em->em_relids, info->compressed_rel->relids)); /* only consider EquivalenceMembers that are Vars, possibly with RelabelType, of the * uncompressed chunk */ var = (Var *) cur_em->em_expr; while (var && IsA(var, RelabelType)) var = (Var *) ((RelabelType *) var)->arg; if (!(var && IsA(var, Var))) continue; /* * We want to base our equivalence member on the hypertable equivalence * member, not on the uncompressed chunk one. We can't just check for * em_is_child though because the hypertable might be a child itself and not * a top-level EquivalenceMember. This is mostly relevant for PG16+ where * we have to specify a parent for the newly created equivalence member. */ if ((Index) var->varno != info->ht_rel->relid) continue; if (var->varattno <= 0) { /* * We can have equivalence members that refer to special variables, * but these variables can't be segmentby, so we're not interested * in them here. */ continue; } /* given that the em is a var of the uncompressed chunk, the relid of the chunk should * be set on the em */ Assert(bms_is_member(info->ht_rel->relid, cur_em->em_relids)); Assert(OidIsValid(info->ht_rte->relid)); const char *attname = get_attname(info->ht_rte->relid, var->varattno, false); if (!ts_array_is_member(context->settings->fd.segmentby, attname)) continue; child_expr = (Expr *) create_var_for_compressed_equivalence_member(var, context, attname); if (child_expr == NULL) continue; /* #8681: coerce compressed var to current equivalence member type/collation, * in case we dug the "cur_em->em_expr" var from under RelabelTypes */ child_expr = canonicalize_ec_expression(child_expr, cur_em->em_datatype, cur_ec->ec_collation); /* * Transform em_relids to match. Note we do *not* do * pull_varnos(child_expr) here, as for example the * transformation might have substituted a constant, but we * don't want the child member to be marked as constant. */ new_relids = bms_copy(cur_em->em_relids); new_relids = bms_del_member(new_relids, info->ht_rel->relid); new_relids = bms_add_members(new_relids, info->compressed_rel->relids); /* copied from add_eq_member */ { EquivalenceMember *em = makeNode(EquivalenceMember); em->em_expr = child_expr; em->em_relids = new_relids; em->em_is_const = false; em->em_is_child = true; em->em_datatype = cur_em->em_datatype; #if PG16_GE em->em_jdomain = cur_em->em_jdomain; em->em_parent = cur_em; #endif #if PG16_LT /* * For versions less than PG16, transform and set em_nullable_relids similar to * em_relids. Note that this code assumes parent and child relids are singletons. */ Relids new_nullable_relids = cur_em->em_nullable_relids; if (bms_is_member(info->ht_rel->relid, new_nullable_relids)) { new_nullable_relids = bms_copy(new_nullable_relids); new_nullable_relids = bms_del_member(new_nullable_relids, info->ht_rel->relid); new_nullable_relids = bms_add_members(new_nullable_relids, info->compressed_rel->relids); } em->em_nullable_relids = new_nullable_relids; #endif /* * In some cases the new EC member is likely to be accessed soon, so * it would make sense to add it to the front, but we cannot do that * here. If we do that, the compressed chunk EM might get picked as * SortGroupExpr by cost_incremental_sort, and estimate_num_groups * will assert that the rel is simple rel, but it will fail because * the compressed chunk rel is a deadrel. Anyway, it wouldn't make * sense to estimate the group numbers by one append member, * probably Postgres expects to see the parent relation first in the * EMs. */ #if PG18_LT cur_ec->ec_members = lappend(cur_ec->ec_members, em); cur_ec->ec_relids = bms_add_members(cur_ec->ec_relids, info->compressed_rel->relids); #else ts_add_child_eq_member(root, cur_ec, em, info->compressed_rel->relid); #endif /* * Cache the matching EquivalenceClass and EquivalenceMember for * segmentby column for future use, if we want to build a path that * sorts on it. Sorting is defined by PathKeys, which refer to * EquivalenceClasses, so it's a convenient form. */ compressed_fdw_private->compressed_ec_em_pairs = lappend(compressed_fdw_private->compressed_ec_em_pairs, list_make2(cur_ec, em)); return true; } } return false; } static void compressed_rel_setup_equivalence_classes(PlannerInfo *root, CompressionInfo *info) { EMCreationContext context = { .uncompressed_relid = info->ht_rte->relid, .compressed_relid = info->compressed_rte->relid, .uncompressed_relid_idx = info->ht_rel->relid, .compressed_relid_idx = info->compressed_rel->relid, .settings = info->settings, }; Assert(info->chunk_rte->relid != info->compressed_rel->relid); Assert(info->chunk_rel->relid != info->compressed_rel->relid); /* based on add_child_rel_equivalences */ int i = -1; Assert(root->ec_merging_done); /* use chunk rel's eclass_indexes to avoid traversing all * the root's eq_classes */ while ((i = bms_next_member(info->chunk_rel->eclass_indexes, i)) >= 0) { EquivalenceClass *cur_ec = (EquivalenceClass *) list_nth(root->eq_classes, i); /* * If this EC contains a volatile expression, then generating child * EMs would be downright dangerous, so skip it. We rely on a * volatile EC having only one EM. */ if (cur_ec->ec_has_volatile) continue; /* if the compressed rel is already part of this EC, * we don't need to re-add it */ if (bms_overlap(cur_ec->ec_relids, info->compressed_rel->relids)) continue; bool em_added = add_segmentby_to_equivalence_class(root, cur_ec, info, &context); /* Record this EC index for the compressed rel */ if (em_added) info->compressed_rel->eclass_indexes = bms_add_member(info->compressed_rel->eclass_indexes, i); } info->compressed_rel->has_eclass_joins = info->chunk_rel->has_eclass_joins; } /* * create RangeTblEntry and RelOptInfo for the compressed chunk * and add it to PlannerInfo */ static void columnar_scan_add_plannerinfo(PlannerInfo *root, CompressionInfo *info, const Chunk *chunk, RelOptInfo *chunk_rel, bool needs_sequence_num) { Index compressed_index = root->simple_rel_array_size; /* * Add the compressed chunk to the baserel cache. Note that it belongs to * a different hypertable, the internal compression table. */ const Chunk *compressed_chunk = ts_chunk_get_by_relid(info->settings->fd.compress_relid, true); ts_add_baserel_cache_entry_for_chunk(info->settings->fd.compress_relid, ts_planner_get_hypertable(compressed_chunk ->hypertable_relid, CACHE_FLAG_NONE)); expand_planner_arrays(root, 1); info->compressed_rte = columnar_scan_make_rte(info->settings->fd.compress_relid, info->chunk_rte->rellockmode, root->parse); root->simple_rte_array[compressed_index] = info->compressed_rte; root->parse->rtable = lappend(root->parse->rtable, info->compressed_rte); root->simple_rel_array[compressed_index] = NULL; RelOptInfo *compressed_rel = build_simple_rel(root, compressed_index, NULL); #if PG16_GE /* * When initially creating the RTE we add a RTEPerminfo entry for the * RTE but that is only to make build_simple_rel happy. * Asserts in the permission check code will fail with an RTEPerminfo * with no permissions to check so we remove it again here as we don't * want permission checks on the compressed chunks when querying * hypertables with compressed data. */ root->parse->rteperminfos = list_delete_last(root->parse->rteperminfos); info->compressed_rte->perminfoindex = 0; #endif /* github issue :1558 * set up top_parent_relids for this rel as the same as the * original hypertable, otherwise eq classes are not computed correctly * in generate_join_implied_equalities (called by * get_baserel_parampathinfo <- create_index_paths) */ Assert(info->single_chunk || chunk_rel->top_parent_relids != NULL); compressed_rel->top_parent_relids = bms_copy(chunk_rel->top_parent_relids); root->simple_rel_array[compressed_index] = compressed_rel; info->compressed_rel = compressed_rel; Relation r = table_open(info->compressed_rte->relid, AccessShareLock); for (int i = 0; i < r->rd_att->natts; i++) { Form_pg_attribute attr = TupleDescAttr(r->rd_att, i); if (attr->attisdropped || attr->atttypid != info->compresseddata_oid) continue; info->compressed_attnos_in_compressed_chunk = bms_add_member(info->compressed_attnos_in_compressed_chunk, attr->attnum); } table_close(r, NoLock); compressed_rel_setup_reltarget(compressed_rel, info, needs_sequence_num); compressed_rel_setup_equivalence_classes(root, info); /* translate chunk_rel->joininfo for compressed_rel */ compressed_rel_setup_joininfo(compressed_rel, info); /* * Force parallel plan creation, see compute_parallel_worker(). * This is not compatible with ts_classify_relation(), but on the other hand * the compressed chunk rel shouldn't exist anywhere outside of the * decompression planning, it is removed at the end. * * This is not needed for direct select from a single chunk, in which case * the chunk reloptkind will be RELOPT_BASEREL */ if (chunk_rel->reloptkind == RELOPT_OTHER_MEMBER_REL) { compressed_rel->reloptkind = RELOPT_OTHER_MEMBER_REL; /* * We have to minimally initialize the append relation info for the * compressed chunks, so that the generate_implied_equalities() works. * Only the parent hypertable relindex is needed. */ root->append_rel_array[compressed_rel->relid] = makeNode(AppendRelInfo); root->append_rel_array[compressed_rel->relid]->parent_relid = info->ht_rel->relid; compressed_rel->top_parent_relids = chunk_rel->top_parent_relids; } } static ColumnarScanPath * columnar_scan_path_create(PlannerInfo *root, const CompressionInfo *compression_info, Path *compressed_path) { ColumnarScanPath *path; path = (ColumnarScanPath *) newNode(sizeof(ColumnarScanPath), T_CustomPath); path->info = compression_info; path->custom_path.path.pathtype = T_CustomScan; path->custom_path.path.parent = compression_info->chunk_rel; path->custom_path.path.pathtarget = compression_info->chunk_rel->reltarget; if (compressed_path->param_info != NULL) { /* * Note that we have to separately generate the parameterized path info * for decompressed chunk path. The compressed parameterized path only * checks the clauses on segmentby columns, not on the compressed * columns. */ path->custom_path.path.param_info = get_baserel_parampathinfo(root, compression_info->chunk_rel, compressed_path->param_info->ppi_req_outer); Assert(path->custom_path.path.param_info != NULL); } else { path->custom_path.path.param_info = NULL; } path->custom_path.flags = 0; path->custom_path.methods = &columnar_scan_path_methods; path->batch_sorted_merge = false; /* * ColumnarScan doesn't manage any parallelism itself. */ path->custom_path.path.parallel_aware = false; /* * It can be applied per parallel worker, if its underlying scan is parallel. */ path->custom_path.path.parallel_safe = compressed_path->parallel_safe; path->custom_path.path.parallel_workers = compressed_path->parallel_workers; path->custom_path.custom_paths = list_make1(compressed_path); path->reverse = false; path->required_compressed_pathkeys = NIL; cost_columnar_scan(root, compression_info, &path->custom_path.path, compressed_path); return path; } /* NOTE: this needs to be called strictly after all restrictinfos have been added * to the compressed rel */ static void create_compressed_scan_paths(PlannerInfo *root, RelOptInfo *compressed_rel, const CompressionInfo *compression_info, const SortInfo *sort_info) { Path *compressed_path; /* clamp total_table_pages to 10 pages since this is the * minimum estimate for number of pages. * Add the value to any existing estimates */ root->total_table_pages += Max(compressed_rel->pages, 10); /* create non parallel scan path */ compressed_path = create_seqscan_path(root, compressed_rel, NULL, 0); add_path(compressed_rel, compressed_path); /* * Create parallel seq scan path. * We marked the compressed rel as RELOPT_OTHER_MEMBER_REL when creating it, * so we should get a nonzero number of parallel workers even for small * tables, so that they don't prevent parallelism in the entire append plan. * See compute_parallel_workers(). This also applies to the creation of * index paths below. */ if (compressed_rel->consider_parallel) { int parallel_workers = compute_parallel_worker(compressed_rel, compressed_rel->pages, -1, max_parallel_workers_per_gather); if (parallel_workers > 0) { add_partial_path(compressed_rel, create_seqscan_path(root, compressed_rel, NULL, parallel_workers)); } } if (sort_info->use_compressed_sort) { /* * If we can push down sort below decompression we temporarily switch * out root->query_pathkeys to allow matching to pathkeys produces by * decompression */ List *orig_pathkeys = root->query_pathkeys; List *orig_eq_classes = root->eq_classes; Bitmapset *orig_eclass_indexes = compression_info->compressed_rel->eclass_indexes; root->query_pathkeys = sort_info->required_compressed_pathkeys; /* We can optimize iterating over EquivalenceClasses by reducing them to * the subset which are from the compressed chunk. This only works if we don't * have joins based on equivalence classes involved since those * use eclass_indexes which is not valid with this optimization. * * Clauseless joins work fine since they don't rely on eclass_indexes. */ if (!compression_info->chunk_rel->has_eclass_joins) { int i = -1; List *required_eq_classes = NIL; while ((i = bms_next_member(compression_info->compressed_rel->eclass_indexes, i)) >= 0) { EquivalenceClass *cur_ec = (EquivalenceClass *) list_nth(root->eq_classes, i); required_eq_classes = lappend(required_eq_classes, cur_ec); } root->eq_classes = required_eq_classes; compression_info->compressed_rel->eclass_indexes = NULL; } check_index_predicates(root, compressed_rel); create_index_paths(root, compressed_rel); root->query_pathkeys = orig_pathkeys; root->eq_classes = orig_eq_classes; compression_info->compressed_rel->eclass_indexes = orig_eclass_indexes; } else { check_index_predicates(root, compressed_rel); create_index_paths(root, compressed_rel); } } /* * create RangeTblEntry for compressed chunk */ static RangeTblEntry * columnar_scan_make_rte(Oid compressed_relid, LOCKMODE lockmode, Query *parse) { RangeTblEntry *rte = makeNode(RangeTblEntry); Relation r = table_open(compressed_relid, lockmode); int varattno; rte->rtekind = RTE_RELATION; rte->relid = compressed_relid; rte->relkind = r->rd_rel->relkind; rte->rellockmode = lockmode; rte->eref = makeAlias(RelationGetRelationName(r), NULL); /* * inlined from buildRelationAliases() * alias handling has been stripped because we won't * need alias handling at this level */ for (varattno = 0; varattno < r->rd_att->natts; varattno++) { Form_pg_attribute attr = TupleDescAttr(r->rd_att, varattno); /* Always insert an empty string for a dropped column */ const char *attrname = attr->attisdropped ? "" : NameStr(attr->attname); rte->eref->colnames = lappend(rte->eref->colnames, makeString(pstrdup(attrname))); } /* * Drop the rel refcount, but keep the access lock till end of transaction * so that the table can't be deleted or have its schema modified * underneath us. */ table_close(r, NoLock); /* * Set flags and access permissions. * * The initial default on access checks is always check-for-READ-access, * which is the right thing for all except target tables. */ rte->lateral = false; rte->inh = false; rte->inFromCl = false; #if PG16_LT rte->requiredPerms = 0; rte->checkAsUser = InvalidOid; /* not set-uid by default, either */ rte->selectedCols = NULL; rte->insertedCols = NULL; rte->updatedCols = NULL; #else /* Add empty perminfo for the new RTE to make build_simple_rel happy. */ addRTEPermissionInfo(&parse->rteperminfos, rte); #endif return rte; } /* * Find segmentby columns that are equated to a constant by a toplevel * baserestrictinfo. * * This will detect Var = Const and Var = Param and set the corresponding bit * in CompressionInfo->chunk_const_segmentby. */ static Bitmapset * find_const_segmentby(RelOptInfo *chunk_rel, const CompressionInfo *info) { Bitmapset *segmentby_columns = NULL; if (chunk_rel->baserestrictinfo != NIL) { ListCell *lc_ri; foreach (lc_ri, chunk_rel->baserestrictinfo) { RestrictInfo *ri = lfirst(lc_ri); if (IsA(ri->clause, OpExpr) && list_length(castNode(OpExpr, ri->clause)->args) == 2) { OpExpr *op = castNode(OpExpr, ri->clause); Var *lvar, *rvar, *var; Expr *other; if (op->opretset) continue; lvar = linitial(op->args); while (lvar && IsA(lvar, RelabelType)) lvar = (Var *) ((RelabelType *) lvar)->arg; rvar = lsecond(op->args); while (rvar && IsA(rvar, RelabelType)) rvar = (Var *) ((RelabelType *) rvar)->arg; Assert(lvar && rvar); if (IsA(lvar, Var)) { var = castNode(Var, lvar); other = lsecond(op->args); } else if (IsA(rvar, Var)) { var = castNode(Var, rvar); other = linitial(op->args); } else continue; if ((Index) var->varno != chunk_rel->relid || var->varattno <= 0) continue; if (IsA(other, Const) || IsA(other, Param)) { TypeCacheEntry *tce = lookup_type_cache(var->vartype, TYPECACHE_EQ_OPR); if (op->opno != tce->eq_opr) continue; if (bms_is_member(var->varattno, info->chunk_segmentby_attnos)) segmentby_columns = bms_add_member(segmentby_columns, var->varattno); } } } } return segmentby_columns; } /* * Returns whether the pathkeys starting at the given offset match the compression * orderby, and whether the order is reverse. */ static bool match_pathkeys_to_compression_orderby(List *pathkeys, List *chunk_em_exprs, int starting_pathkey_offset, const CompressionInfo *compression_info, bool *out_reverse) { int compressed_pk_index = 0; for (int i = starting_pathkey_offset; i < list_length(pathkeys); i++) { compressed_pk_index++; PathKey *pk = list_nth_node(PathKey, pathkeys, i); Expr *expr = (Expr *) list_nth(chunk_em_exprs, i); while (expr && IsA(expr, RelabelType)) expr = ((RelabelType *) expr)->arg; if (expr == NULL || !IsA(expr, Var)) { return false; } Var *var = castNode(Var, expr); if (var->varattno <= 0) { return false; } char *column_name = get_attname(compression_info->chunk_rte->relid, var->varattno, false); int orderby_index = ts_array_position(compression_info->settings->fd.orderby, column_name); if (orderby_index != compressed_pk_index) { return false; } bool orderby_desc = ts_array_get_element_bool(compression_info->settings->fd.orderby_desc, orderby_index); bool orderby_nullsfirst = ts_array_get_element_bool(compression_info->settings->fd.orderby_nullsfirst, orderby_index); /* * In PG18+: pk_cmptype is either COMPARE_LT (for ASC) or COMPARE_GT (for DESC) * For previous PG versions we have compatibility macros to make these new names available. */ bool this_pathkey_reverse = false; if (pk->pk_cmptype == COMPARE_LT) { if (!orderby_desc && orderby_nullsfirst == pk->pk_nulls_first) { this_pathkey_reverse = false; } else if (orderby_desc && orderby_nullsfirst != pk->pk_nulls_first) { this_pathkey_reverse = true; } else { return false; } } else if (pk->pk_cmptype == COMPARE_GT) { if (orderby_desc && orderby_nullsfirst == pk->pk_nulls_first) { this_pathkey_reverse = false; } else if (!orderby_desc && orderby_nullsfirst != pk->pk_nulls_first) { this_pathkey_reverse = true; } else { return false; } } /* * first pathkey match determines if this is forward or backward scan * any further pathkey items need to have same direction */ if (compressed_pk_index == 1) { *out_reverse = this_pathkey_reverse; } else if (this_pathkey_reverse != *out_reverse) { return false; } } return true; } /* * Check if we can push down the sort below the ColumnarSacn node and fill * SortInfo accordingly * * The following conditions need to be true for pushdown: * - all segmentby columns need to be prefix of pathkeys or have equality constraint * - the rest of pathkeys needs to match compress_orderby * * If query pathkeys is shorter than segmentby + compress_orderby pushdown can still be done */ static SortInfo build_sortinfo(PlannerInfo *root, const Chunk *chunk, RelOptInfo *chunk_rel, const CompressionInfo *compression_info, List *pathkeys) { Var *var; char *column_name; ListCell *lc; SortInfo sort_info = { 0 }; if (pathkeys == NIL) { return sort_info; } /* * Translate the pathkeys to chunk expressions, creating a List of them * parallel to the pathkeys list, with NULL entries if we didn't find a * match. */ List *chunk_em_exprs = NIL; foreach (lc, pathkeys) { PathKey *pk = lfirst(lc); EquivalenceClass *ec = pk->pk_eclass; Expr *em_expr = NULL; if (!ec->ec_has_volatile) { em_expr = ts_find_em_expr_for_rel(pk->pk_eclass, compression_info->chunk_rel); } chunk_em_exprs = lappend(chunk_em_exprs, em_expr); } Assert(list_length(chunk_em_exprs) == list_length(pathkeys)); /* Find the pathkeys we can use for explicitly sorting after decompression. */ List *sort_pathkey_exprs = NIL; List *sort_pathkeys = NIL; for (int i = 0; i < list_length(chunk_em_exprs); i++) { PathKey *pk = list_nth_node(PathKey, pathkeys, i); Expr *chunk_em_expr = (Expr *) list_nth(chunk_em_exprs, i); if (chunk_em_expr == NULL) { break; } sort_pathkeys = lappend(sort_pathkeys, pk); sort_pathkey_exprs = lappend(sort_pathkey_exprs, chunk_em_expr); } if (sort_pathkeys == NIL) { return sort_info; } sort_info.decompressed_sort_pathkeys = sort_pathkeys; cost_qual_eval(&sort_info.decompressed_sort_pathkeys_cost, sort_pathkey_exprs, root); /* * Next, check if we can push the sort down to the uncompressed part. * * Not possible if the chunk is unordered. */ if (ts_chunk_is_unordered(chunk)) return sort_info; /* all segmentby columns need to be prefix of pathkeys */ int i = 0; if (compression_info->num_segmentby_columns > 0) { Bitmapset *segmentby_columns; /* * initialize segmentby with equality constraints from baserestrictinfo because * those columns dont need to be prefix of pathkeys */ segmentby_columns = bms_copy(compression_info->chunk_const_segmentby); /* * loop over pathkeys until we find one that is not a segmentby column * we keep looping even if we found all segmentby columns in case a * columns appears both in baserestrictinfo and in ORDER BY clause */ for (i = 0; i < list_length(pathkeys); i++) { Assert(bms_num_members(segmentby_columns) <= compression_info->num_segmentby_columns); Expr *expr = (Expr *) list_nth(chunk_em_exprs, i); while (expr && IsA(expr, RelabelType)) expr = ((RelabelType *) expr)->arg; if (expr == NULL || !IsA(expr, Var)) break; var = castNode(Var, expr); if (var->varattno <= 0) break; column_name = get_attname(compression_info->chunk_rte->relid, var->varattno, false); if (!ts_array_is_member(compression_info->settings->fd.segmentby, column_name)) break; segmentby_columns = bms_add_member(segmentby_columns, var->varattno); } /* * If pathkeys still has items, but we didn't find all segmentby columns, * we cannot satisfy these pathkeys by sorting the compressed chunk table. */ if (i != list_length(pathkeys) && bms_num_members(segmentby_columns) != compression_info->num_segmentby_columns) { /* * If we didn't have any segmentby columns in pathkeys, try batch sorted merge * instead. */ if (i == 0) { sort_info.use_batch_sorted_merge = match_pathkeys_to_compression_orderby(pathkeys, chunk_em_exprs, /* starting_pathkey_offset = */ 0, compression_info, &sort_info.reverse); } return sort_info; } } if (i == list_length(pathkeys)) { /* * Pathkeys satisfied by sorting the compressed data on segmentby columns. */ sort_info.use_compressed_sort = true; return sort_info; } /* * Pathkeys includes columns past segmentby columns, so we need sequence_num * in the targetlist for ordering. */ sort_info.needs_sequence_num = true; /* * loop over the rest of pathkeys * this needs to exactly match the configured compress_orderby */ sort_info.use_compressed_sort = match_pathkeys_to_compression_orderby(pathkeys, chunk_em_exprs, i, compression_info, &sort_info.reverse); return sort_info; } /* Check if the provided path is a ColumnarScanPath */ bool ts_is_columnar_scan_path(Path *path) { return IsA(path, CustomPath) && castNode(CustomPath, path)->methods == &columnar_scan_path_methods; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/columnar_scan.h��������������������������������������0000664�0000000�0000000�00000003547�15100345067�0024406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/bitmapset.h> #include <nodes/extensible.h> #include "chunk.h" #include "hypertable.h" #include "ts_catalog/compression_settings.h" typedef struct CompressionInfo { RelOptInfo *chunk_rel; RelOptInfo *compressed_rel; RelOptInfo *ht_rel; RangeTblEntry *chunk_rte; RangeTblEntry *compressed_rte; RangeTblEntry *ht_rte; Oid compresseddata_oid; CompressionSettings *settings; int hypertable_id; List *hypertable_compression_info; int num_orderby_columns; int num_segmentby_columns; /* chunk attribute numbers that are segmentby columns */ Bitmapset *chunk_segmentby_attnos; /* * Chunk segmentby attribute numbers that are equated to a constant by a * baserestrictinfo. */ Bitmapset *chunk_const_segmentby; /* compressed chunk attribute numbers for columns that are compressed */ Bitmapset *compressed_attnos_in_compressed_chunk; bool single_chunk; /* query on explicit chunk */ bool has_seq_num; /* legacy sequence number support */ Relids parent_relids; /* relids of the parent hypertable and UNION */ /* Compressed batch size estimated from statistics. */ double compressed_batch_size; } CompressionInfo; typedef struct ColumnarScanPath { CustomPath custom_path; const CompressionInfo *info; List *required_compressed_pathkeys; bool needs_sequence_num; bool reverse; bool batch_sorted_merge; } ColumnarScanPath; void ts_columnar_scan_generate_paths(PlannerInfo *root, RelOptInfo *rel, const Hypertable *ht, const Chunk *chunk); extern bool ts_is_columnar_scan_path(Path *path); extern bool ts_is_columnar_scan_plan(Plan *plan); ColumnarScanPath *copy_columnar_scan_path(ColumnarScanPath *src); ���������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/compressed_batch.c�����������������������������������0000664�0000000�0000000�00000126062�15100345067�0025060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <executor/tuptable.h> #include <nodes/bitmapset.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/timestamp.h> #include <utils/uuid.h> #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "debug_assert.h" #include "guc.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/columnar_scan/vector_dict.h" #include "nodes/columnar_scan/vector_predicates.h" #include "nodes/columnar_scan/vector_quals.h" /* * Create a single-value ArrowArray of an arithmetic type. This is a specialized * function because arithmetic types have a particular layout of ArrowArrays. */ static ArrowArray * make_single_value_arrow_arithmetic(Oid arithmetic_type, Datum datum, bool isnull) { struct ArrowWithBuffers { ArrowArray arrow; uint64 arrow_buffers_array_storage[2]; uint64 validity_buffer[1]; /* The value buffer has 64-byte padding as required by Arrow. */ uint64 values_buffer[8]; }; struct ArrowWithBuffers *with_buffers = palloc0(sizeof(struct ArrowWithBuffers)); ArrowArray *arrow = &with_buffers->arrow; arrow->length = 1; arrow->buffers = (const void **) with_buffers->arrow_buffers_array_storage; arrow->n_buffers = 2; arrow->buffers[0] = with_buffers->validity_buffer; arrow->buffers[1] = with_buffers->values_buffer; if (isnull) { /* * The validity bitmap was initialized to invalid on allocation, and * the Datum might be invalid if the value is null (important on i386 * where it might be pass-by-reference), so don't read it. */ arrow->null_count = 1; return arrow; } arrow_set_row_validity((uint64 *) arrow->buffers[0], 0, true); #define FOR_TYPE(PGTYPE, CTYPE, FROMDATUM) \ case PGTYPE: \ *((CTYPE *) arrow->buffers[1]) = FROMDATUM(datum); \ break switch (arithmetic_type) { FOR_TYPE(INT8OID, int64, DatumGetInt64); FOR_TYPE(INT4OID, int32, DatumGetInt32); FOR_TYPE(INT2OID, int16, DatumGetInt16); FOR_TYPE(FLOAT8OID, float8, DatumGetFloat8); FOR_TYPE(FLOAT4OID, float4, DatumGetFloat4); FOR_TYPE(TIMESTAMPTZOID, TimestampTz, DatumGetTimestampTz); FOR_TYPE(TIMESTAMPOID, Timestamp, DatumGetTimestamp); FOR_TYPE(DATEOID, DateADT, DatumGetDateADT); FOR_TYPE(UUIDOID, pg_uuid_t, *DatumGetUUIDP); default: elog(ERROR, "unexpected column type '%s'", format_type_be(arithmetic_type)); pg_unreachable(); } return arrow; } /* * Create a single-value ArrowArray of text. This is a specialized function * because the text ArrowArray has a specialized layout. */ static ArrowArray * make_single_value_arrow_text(Datum datum, bool isnull) { struct ArrowWithBuffers { ArrowArray arrow; uint64 arrow_buffers_array_storage[3]; uint64 validity_buffer[1]; uint32 offsets_buffer[2]; /* The value buffer has 64-byte padding as required by Arrow. */ uint64 values_buffer[8]; }; struct ArrowWithBuffers *with_buffers = palloc0(sizeof(struct ArrowWithBuffers)); ArrowArray *arrow = &with_buffers->arrow; arrow->length = 1; arrow->buffers = (const void **) with_buffers->arrow_buffers_array_storage; arrow->n_buffers = 3; arrow->buffers[0] = with_buffers->validity_buffer; arrow->buffers[1] = with_buffers->offsets_buffer; arrow->buffers[2] = with_buffers->values_buffer; if (isnull) { /* * The validity bitmap was initialized to invalid on allocation, and * the Datum might be invalid if the value is null (important on i386 * where it might be pass-by-reference), so don't read it. */ arrow->null_count = 1; return arrow; } arrow_set_row_validity((uint64 *) arrow->buffers[0], 0, true); text *detoasted = PG_DETOAST_DATUM(datum); ((uint32 *) arrow->buffers[1])[1] = VARSIZE_ANY_EXHDR(detoasted); arrow->buffers[2] = VARDATA(detoasted); return arrow; } /* * Create a single value ArrowArray from Postgres Datum. This is used to run * the usual vectorized predicates on compressed columns with default values. */ ArrowArray * make_single_value_arrow(Oid pgtype, Datum datum, bool isnull) { if (pgtype == TEXTOID) { return make_single_value_arrow_text(datum, isnull); } return make_single_value_arrow_arithmetic(pgtype, datum, isnull); } static int get_max_text_datum_size(ArrowArray *text_array) { int maxbytes = 0; uint32 *offsets = (uint32 *) text_array->buffers[1]; for (int i = 0; i < text_array->length; i++) { const int curbytes = offsets[i + 1] - offsets[i]; if (curbytes > maxbytes) { maxbytes = curbytes; } } return maxbytes; } static void decompress_column(DecompressContext *dcontext, DecompressBatchState *batch_state, TupleTableSlot *compressed_slot, int i) { CompressionColumnDescription *column_description = &dcontext->compressed_chunk_columns[i]; CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; column_values->arrow = NULL; const AttrNumber attr = AttrNumberGetAttrOffset(column_description->custom_scan_attno); column_values->output_value = &compressed_batch_current_tuple(batch_state)->tts_values[attr]; column_values->output_isnull = &compressed_batch_current_tuple(batch_state)->tts_isnull[attr]; const int value_bytes = get_typlen(column_description->typid); Assert(value_bytes != 0); bool isnull; Datum value = slot_getattr(compressed_slot, column_description->compressed_scan_attno, &isnull); if (isnull) { /* * The column will have a default value for the entire batch, * set it now. */ column_values->decompression_type = DT_Scalar; /* * We might use a custom targetlist-based scan tuple which has no * default values, so the default values are fetched from the * uncompressed chunk tuple descriptor. */ *column_values->output_value = getmissingattr(dcontext->uncompressed_chunk_tdesc, column_description->uncompressed_chunk_attno, column_values->output_isnull); return; } /* Detoast the compressed datum. */ value = PointerGetDatum(detoaster_detoast_attr_copy((struct varlena *) DatumGetPointer(value), &dcontext->detoaster, batch_state->per_batch_context)); CompressedDataHeader *header = (CompressedDataHeader *) value; /* First check if this is a block of NULL values. */ if (header->compression_algorithm == COMPRESSION_ALGORITHM_NULL) { column_values->decompression_type = DT_Scalar; *column_values->output_isnull = true; *column_values->output_value = (Datum) NULL; return; } /* Decompress the entire batch if it is supported. */ ArrowArray *arrow = NULL; if (dcontext->enable_bulk_decompression && column_description->bulk_decompression_supported) { if (dcontext->bulk_decompression_context == NULL) { dcontext->bulk_decompression_context = create_bulk_decompression_mctx( MemoryContextGetParent(batch_state->per_batch_context)); } DecompressAllFunction decompress_all = tsl_get_decompress_all_function(header->compression_algorithm, column_description->typid); Assert(decompress_all != NULL); MemoryContext context_before_decompression = MemoryContextSwitchTo(dcontext->bulk_decompression_context); arrow = decompress_all(PointerGetDatum(header), column_description->typid, batch_state->per_batch_context); MemoryContextSwitchTo(context_before_decompression); MemoryContextReset(dcontext->bulk_decompression_context); } if (arrow == NULL) { /* As a fallback, decompress row-by-row. */ column_values->decompression_type = DT_Iterator; MemoryContext old_context = MemoryContextSwitchTo(batch_state->per_batch_context); column_values->buffers[0] = tsl_get_decompression_iterator_init(header->compression_algorithm, dcontext->reverse)(PointerGetDatum(header), column_description->typid); MemoryContextSwitchTo(old_context); return; } /* Should have been filled from the count metadata column. */ Assert(batch_state->total_batch_rows != 0); if (batch_state->total_batch_rows != arrow->length) { elog(ERROR, "compressed column out of sync with batch counter"); } column_values->arrow = arrow; if (value_bytes > 0) { /* Fixed-width column. */ column_values->decompression_type = value_bytes; column_values->buffers[0] = arrow->buffers[0]; column_values->buffers[1] = arrow->buffers[1]; column_values->buffers[2] = NULL; column_values->buffers[3] = NULL; if (column_description->typid == BOOLOID) { /* The bool columns have a dedicated storage format. */ column_values->decompression_type = DT_ArrowBits; } } else { /* * Text column. Pre-allocate memory for its text Datum in the * decompressed scan slot. We can't put direct references to Arrow * memory there, because it doesn't have the varlena headers that * Postgres expects for text. */ const int maxbytes = VARHDRSZ + (arrow->dictionary ? get_max_text_datum_size(arrow->dictionary) : get_max_text_datum_size(arrow)); *column_values->output_value = PointerGetDatum(MemoryContextAlloc(batch_state->per_batch_context, maxbytes)); /* * Set up the datum conversion based on whether we use the dictionary. */ if (arrow->dictionary == NULL) { column_values->decompression_type = DT_ArrowText; column_values->buffers[0] = arrow->buffers[0]; column_values->buffers[1] = arrow->buffers[1]; column_values->buffers[2] = arrow->buffers[2]; column_values->buffers[3] = NULL; } else { column_values->decompression_type = DT_ArrowTextDict; column_values->buffers[0] = arrow->buffers[0]; column_values->buffers[1] = arrow->dictionary->buffers[1]; column_values->buffers[2] = arrow->dictionary->buffers[2]; column_values->buffers[3] = arrow->buffers[1]; } } } /* * Get the arrow array for the compressed batch via the VectorQualState. * * This is a ColumnarScan-specific implementation of the * VectorQualState->get_arrow_array() function used to interface with the * vector qual code across different scan nodes. */ const ArrowArray * compressed_batch_get_arrow_array(VectorQualState *vqstate, Expr *expr, bool *is_default_value) { CompressedBatchVectorQualState *cbvqstate = (CompressedBatchVectorQualState *) vqstate; DecompressContext *dcontext = cbvqstate->dcontext; DecompressBatchState *batch_state = cbvqstate->batch_state; CompressionColumnDescription *column_description = NULL; TupleTableSlot *compressed_slot = vqstate->slot; const Var *var = castNode(Var, expr); int column_index = 0; for (; column_index < dcontext->num_data_columns; column_index++) { column_description = &dcontext->compressed_chunk_columns[column_index]; if (var->varno == INDEX_VAR) { /* * Reference into custom scan tlist, happens when we are using a * non-default custom scan tuple. */ if (column_description->custom_scan_attno == var->varattno) { break; } } else { /* * Reference into uncompressed chunk tuple. * * Note that this is somewhat redundant, because this branch is * taken when we do not use a custom scan tuple, and in this case * the custom scan attno is the same as the uncompressed chunk attno, * so the above branch would do as well. This difference might * become relevant in the future, if we stop outputting the * columns that are needed only for the vectorized quals. */ if (column_description->uncompressed_chunk_attno == var->varattno) { break; } } } Ensure(column_index < dcontext->num_data_columns, "decompressed column %d not found in batch", var->varattno); Assert(column_description != NULL); Assert(column_description->typid == var->vartype); CompressedColumnValues *column_values = &batch_state->compressed_columns[column_index]; if (column_values->decompression_type == DT_Invalid) { /* * We decompress the compressed columns on demand, so that we can * skip decompressing some columns if the entire batch doesn't pass * the quals. */ decompress_column(dcontext, batch_state, compressed_slot, column_index); Assert(column_values->decompression_type != DT_Invalid); } Ensure(column_values->decompression_type != DT_Iterator, "expected arrow array but got iterator for column index %d", column_index); /* * Prepare to compute the vector predicate. We have to handle the * default values in a special way because they don't produce the usual * decompressed ArrowArrays. */ const ArrowArray *vector = column_values->arrow; if (column_values->arrow == NULL) { /* * The compressed column had a default value. We can't fall back to * the non-vectorized quals now, so build a single-value ArrowArray * with this default value, check if it passes the predicate, and apply * it to the entire batch. */ Assert(column_values->decompression_type == DT_Scalar); /* * We saved the actual default value into the decompressed scan slot * above, so pull it from there. */ vector = make_single_value_arrow(column_description->typid, *column_values->output_value, *column_values->output_isnull); /* * We start from an all-valid bitmap, because the predicate is * AND-ed to it. */ *is_default_value = true; } else *is_default_value = false; return vector; } static void compute_plain_qual(VectorQualState *vqstate, TupleTableSlot *slot, Node *qual, uint64 *restrict result) { /* * Some predicates can be evaluated to a Const at run time. */ if (IsA(qual, Const)) { Const *c = castNode(Const, qual); if (c->constisnull || !DatumGetBool(c->constvalue)) { /* * Some predicates are evaluated to a null Const, like a * strict comparison with stable expression that evaluates to null. * No rows pass. */ const size_t n_batch_result_words = (vqstate->num_results + 63) / 64; for (size_t i = 0; i < n_batch_result_words; i++) { result[i] = 0; } } else { /* * This is a constant true qual, every row passes and we can * just ignore it. No idea how it can happen though. */ Assert(false); } return; } /* * For now, we support NullTest, "Var ? Const" predicates, * boolean Variables, the negation of boolean variables * and ScalarArrayOperations. */ List *args = NULL; RegProcedure vector_const_opcode = InvalidOid; ScalarArrayOpExpr *saop = NULL; OpExpr *opexpr = NULL; NullTest *nulltest = NULL; BooleanTest *booltest = NULL; Var *bool_var = NULL; bool negate_bool_var = false; if (IsA(qual, NullTest)) { nulltest = castNode(NullTest, qual); args = list_make1(nulltest->arg); } else if (IsA(qual, ScalarArrayOpExpr)) { saop = castNode(ScalarArrayOpExpr, qual); args = saop->args; vector_const_opcode = get_opcode(saop->opno); } else if (IsA(qual, Var)) { bool_var = castNode(Var, qual); Ensure(bool_var->vartype == BOOLOID, "expected boolean Var"); args = list_make1(bool_var); } else if (IsA(qual, BoolExpr)) { BoolExpr *boolexpr = castNode(BoolExpr, qual); Ensure(boolexpr->boolop == NOT_EXPR, "expected NOT BoolExpr"); Ensure(list_length(boolexpr->args) == 1, "expected one argument in NOT BoolExpr"); Ensure(IsA(linitial(boolexpr->args), Var), "expected Var in NOT BoolExpr"); bool_var = castNode(Var, linitial(boolexpr->args)); Ensure(bool_var->vartype == BOOLOID, "expected boolean Var"); /* * We can vectorize boolean variables like 'COL = false' which is * transformed to BoolExpr(NOT_EXPR, Var). */ negate_bool_var = true; bool_var = castNode(Var, linitial(boolexpr->args)); args = list_make1(bool_var); } else if (IsA(qual, BooleanTest)) { booltest = castNode(BooleanTest, qual); Ensure(IsA(booltest->arg, Var), "expected Var in BooleanTest"); args = list_make1(booltest->arg); } else { Ensure(IsA(qual, OpExpr), "expected OpExpr"); opexpr = castNode(OpExpr, qual); args = opexpr->args; vector_const_opcode = get_opcode(opexpr->opno); } /* * Find the compressed column referred to by the Var. */ Expr *expr = linitial(args); uint64 default_value_predicate_result[1]; uint64 *predicate_result = result; bool default_value = false; const ArrowArray *vector = vqstate->get_arrow_array(vqstate, expr, &default_value); if (default_value) { /* * We start from an all-valid bitmap, because the predicate is * AND-ed to it. */ default_value_predicate_result[0] = 1; predicate_result = default_value_predicate_result; } if (nulltest) { vector_nulltest(vector, nulltest->nulltesttype, predicate_result); } else if (bool_var) { vector_booleantest(vector, (negate_bool_var ? IS_FALSE : IS_TRUE), predicate_result); } else if (booltest) { vector_booleantest(vector, booltest->booltesttype, predicate_result); } else { /* * Find the vector_const predicate. */ VectorPredicate *vector_const_predicate = get_vector_const_predicate(vector_const_opcode); Assert(vector_const_predicate != NULL); Ensure(IsA(lsecond(args), Const), "failed to evaluate runtime constant in vectorized filter"); /* * The vectorizable predicates should be STRICT, so we shouldn't see null * constants here. However, a null constant can still come from a scalar * array expression like x = any(null::int[]). Such a predicate fails * for all rows. */ Const *constnode = castNode(Const, lsecond(args)); Ensure(saop != NULL || !constnode->constisnull, "vectorized predicate called for a null value"); if (constnode->constisnull) { const size_t n_batch_result_words = (vqstate->num_results + 63) / 64; for (size_t i = 0; i < n_batch_result_words; i++) { result[i] = 0; } return; } /* * If the data is dictionary-encoded, we are going to compute the * predicate on dictionary and then translate the results. */ const ArrowArray *vector_nodict = NULL; uint64 *restrict predicate_result_nodict = NULL; uint64 dict_result[(GLOBAL_MAX_ROWS_PER_COMPRESSION + 63) / 64]; if (vector->dictionary) { const size_t dict_rows = vector->dictionary->length; const size_t dict_result_words = (dict_rows + 63) / 64; memset(dict_result, 0xFF, dict_result_words * 8); predicate_result_nodict = dict_result; vector_nodict = vector->dictionary; } else { predicate_result_nodict = predicate_result; vector_nodict = vector; } /* * At last, compute the predicate. */ if (saop) { vector_array_predicate(vector_const_predicate, saop->useOr, vector_nodict, constnode->constvalue, predicate_result_nodict); } else { vector_const_predicate(vector_nodict, constnode->constvalue, predicate_result_nodict); } /* * If the vector is dictionary-encoded, we have just computed the * predicate for dictionary and now have to translate it. */ if (vector->dictionary) { translate_bitmap_from_dictionary(vector, predicate_result_nodict, predicate_result); } /* * Account for nulls which shouldn't pass the predicate. Note that the * vector here might have only one row, in contrast with the number of * rows in the batch, if the column has a default value in this batch. */ const size_t n_vector_result_words = (vector->length + 63) / 64; Assert((predicate_result != default_value_predicate_result) || n_vector_result_words == 1); /* to placate Coverity. */ const uint64 *validity = (const uint64 *) vector->buffers[0]; if (validity) { for (size_t i = 0; i < n_vector_result_words; i++) { predicate_result[i] &= validity[i]; } } else { Assert(vector->null_count == 0); } } /* Translate the result if the column had a default value. */ if (default_value) { if (!(default_value_predicate_result[0] & 1)) { /* * We had a default value for the compressed column, and it * didn't pass the predicate, so the entire batch didn't pass. */ const size_t n_batch_result_words = (vqstate->num_results + 63) / 64; for (size_t i = 0; i < n_batch_result_words; i++) { result[i] = 0; } } } } static void compute_one_qual(VectorQualState *vqstate, TupleTableSlot *compressed_slot, Node *qual, uint64 *restrict result); static void compute_qual_conjunction(VectorQualState *vqstate, TupleTableSlot *compressed_slot, List *quals, uint64 *restrict result) { ListCell *lc; foreach (lc, quals) { compute_one_qual(vqstate, compressed_slot, lfirst(lc), result); if (get_vector_qual_summary(result, vqstate->num_results) == NoRowsPass) { /* * Exit early if no rows pass already. This might allow us to avoid * reading the columns required for the subsequent quals. */ return; } } } static void compute_qual_disjunction(VectorQualState *vqstate, TupleTableSlot *compressed_slot, List *quals, uint64 *restrict result) { const size_t n_rows = vqstate->num_results; const size_t n_result_words = (n_rows + 63) / 64; uint64 *or_result = MemoryContextAlloc(vqstate->per_vector_mcxt, (sizeof(uint64) * n_result_words)); for (size_t i = 0; i < n_result_words; i++) { or_result[i] = 0; } uint64 *one_qual_result = MemoryContextAlloc(vqstate->per_vector_mcxt, (sizeof(uint64) * n_result_words)); ListCell *lc; foreach (lc, quals) { for (size_t i = 0; i < n_result_words; i++) { one_qual_result[i] = (uint64) -1; } compute_one_qual(vqstate, compressed_slot, lfirst(lc), one_qual_result); for (size_t i = 0; i < n_result_words; i++) { or_result[i] |= one_qual_result[i]; } if (get_vector_qual_summary(or_result, n_rows) == AllRowsPass) { /* * We can sometimes avoing reading the columns required for the * rest of conditions if we break out early here. */ return; } } for (size_t i = 0; i < n_result_words; i++) { result[i] &= or_result[i]; } } static void compute_one_qual(VectorQualState *vqstate, TupleTableSlot *compressed_slot, Node *qual, uint64 *restrict result) { if (!IsA(qual, BoolExpr)) { compute_plain_qual(vqstate, compressed_slot, qual, result); return; } BoolExpr *boolexpr = castNode(BoolExpr, qual); if (boolexpr->boolop == AND_EXPR) { compute_qual_conjunction(vqstate, compressed_slot, boolexpr->args, result); return; } /* * Postgres removes NOT for operators we can vectorize, so we don't support * NOT in general, except when the column is boolean and the expression is * like 'Col = false'. In this case, the NOT is present and we can vectorize * it. * * Apart from these cases, only OR is left. */ if (boolexpr->boolop == NOT_EXPR) { if (list_length(boolexpr->args) == 1 && IsA(linitial(boolexpr->args), Var)) { compute_plain_qual(vqstate, compressed_slot, qual, result); return; } } Ensure(boolexpr->boolop == OR_EXPR, "expected OR"); compute_qual_disjunction(vqstate, compressed_slot, boolexpr->args, result); } /* * Compute the vectorized filters. Returns true if we have any passing rows. If not, * it means the entire batch is filtered out, and we use this for further * optimizations. */ BatchQualSummary vector_qual_compute(VectorQualState *vqstate) { /* * Allocate the bitmap that will hold the vectorized qual results. We will * initialize it to all ones and AND the individual quals to it. */ const size_t n_rows = vqstate->num_results; const int bitmap_bytes = sizeof(uint64) * ((n_rows + 63) / 64); vqstate->vector_qual_result = MemoryContextAlloc(vqstate->per_vector_mcxt, bitmap_bytes); memset(vqstate->vector_qual_result, 0xFF, bitmap_bytes); if (n_rows % 64 != 0) { /* * We have to zero out the bits for past-the-end elements in the last * bitmap word. Since all predicates are ANDed to the result bitmap, * we can do it here once instead of doing it in each predicate. */ const uint64 mask = ((uint64) -1) >> (64 - vqstate->num_results % 64); vqstate->vector_qual_result[vqstate->num_results / 64] = mask; } /* * Compute the quals. */ compute_qual_conjunction(vqstate, vqstate->slot, vqstate->vectorized_quals_constified, vqstate->vector_qual_result); return get_vector_qual_summary(vqstate->vector_qual_result, n_rows); } /* * Scrolls the compressed batch to the end, discarding any tuples left in it. * This makes the batch ready to accept the next compressed tuple, but without * de-initializing its expensive reusable parts such as memory context and tuple * slots. This is used when vectorized quals don't pass for the entire batch, * and also in batch array to free the batch state for reuse. */ void compressed_batch_discard_tuples(DecompressBatchState *batch_state) { batch_state->next_batch_row = batch_state->total_batch_rows; batch_state->vector_qual_result = NULL; if (batch_state->per_batch_context != NULL) { ExecClearTuple(&batch_state->decompressed_scan_slot_data.base); MemoryContextReset(batch_state->per_batch_context); } else { /* * Check that we have a valid zero-initialized batch here. */ Assert(IsA(&batch_state->decompressed_scan_slot_data, Invalid)); Assert(batch_state->decompressed_scan_slot_data.base.tts_ops == NULL); } } /* * Initializes the zero-initialized batch state. We do this on demand, because * it involves the creation of memory context and tuple slots, which are * relatively expensive. */ static void compressed_batch_lazy_init(DecompressContext *dcontext, DecompressBatchState *batch_state) { /* Init memory context */ batch_state->per_batch_context = create_per_batch_mctx(dcontext); Assert(batch_state->per_batch_context != NULL); /* Get a reference to the decompressed scan TupleTableSlot */ TupleTableSlot *decompressed_slot = dcontext->custom_scan_slot; /* * This code follows Postgres' MakeTupleTableSlot(). */ TupleTableSlot *slot = &batch_state->decompressed_scan_slot_data.base; Assert(IsA(slot, Invalid)); Assert(slot->tts_ops == NULL); slot->type = T_TupleTableSlot; slot->tts_flags = TTS_FLAG_EMPTY | TTS_FLAG_FIXED; /* * The decompressed slot and the respective tuple descriptor are owned by * DecompressContext and live throughout the entire decompression process, * so here we can reuse a plain pointer to the tuple descriptor without * additional reference counting. */ slot->tts_tupleDescriptor = decompressed_slot->tts_tupleDescriptor; slot->tts_mcxt = CurrentMemoryContext; slot->tts_nvalid = 0; slot->tts_values = palloc0(MAXALIGN(slot->tts_tupleDescriptor->natts * sizeof(Datum)) + MAXALIGN(slot->tts_tupleDescriptor->natts * sizeof(bool))); slot->tts_isnull = (bool *) ((char *) slot->tts_values) + MAXALIGN(slot->tts_tupleDescriptor->natts * sizeof(Datum)); /* * Have to initially set nulls to true, because this is the uncompressed chunk * tuple, and some of its columns might be not even decompressed. The tuple * slot functions will get confused by them, because they expect a non-null * value for attributes not marked as null. */ memset(slot->tts_isnull, true, slot->tts_tupleDescriptor->natts * sizeof(bool)); /* * ColumnarScan produces virtual tuple slots. */ *((const TupleTableSlotOps **) &slot->tts_ops) = &TTSOpsVirtual; slot->tts_ops->init(slot); } /* * Initialize the batch decompression state with the new compressed tuple. */ void compressed_batch_set_compressed_tuple(DecompressContext *dcontext, DecompressBatchState *batch_state, TupleTableSlot *compressed_slot) { Assert(TupIsNull(compressed_batch_current_tuple(batch_state))); /* * The batch states are initialized on demand, because creating the memory * context and the tuple table slots is expensive. */ if (batch_state->per_batch_context == NULL) { compressed_batch_lazy_init(dcontext, batch_state); } TupleTableSlot *decompressed_tuple = compressed_batch_current_tuple(batch_state); Assert(decompressed_tuple != NULL); batch_state->total_batch_rows = 0; batch_state->next_batch_row = 0; MemoryContextReset(batch_state->per_batch_context); for (int i = 0; i < dcontext->num_columns_with_metadata; i++) { CompressionColumnDescription *column_description = &dcontext->compressed_chunk_columns[i]; switch (column_description->type) { case COMPRESSED_COLUMN: { /* * We decompress the compressed columns on demand, so that we can * skip decompressing some columns if the entire batch doesn't pass * the quals. Skip them for now. */ Assert(i < dcontext->num_data_columns); CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; column_values->decompression_type = DT_Invalid; column_values->arrow = NULL; break; } case SEGMENTBY_COLUMN: { /* * A segmentby column is not going to change during one batch, * and our output tuples are read-only, so it's enough to only * save it once per batch, which we do here. */ Assert(i < dcontext->num_data_columns); CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; column_values->decompression_type = DT_Scalar; AttrNumber attr = AttrNumberGetAttrOffset(column_description->custom_scan_attno); Datum *output_value = &decompressed_tuple->tts_values[attr]; bool *output_isnull = &decompressed_tuple->tts_isnull[attr]; column_values->output_value = output_value; column_values->output_isnull = output_isnull; column_values->arrow = NULL; *output_value = slot_getattr(compressed_slot, column_description->compressed_scan_attno, output_isnull); /* * Note that if it's not a by-value type, we should copy it into * the slot context. */ if (!column_description->by_value && !*output_isnull && DatumGetPointer(*output_value) != NULL) { if (column_description->value_bytes < 0) { /* This is a varlena type. */ *output_value = PointerGetDatum( detoaster_detoast_attr_copy((struct varlena *) *output_value, &dcontext->detoaster, batch_state->per_batch_context)); } else { /* This is a fixed-length by-reference type. */ void *tmp = MemoryContextAlloc(batch_state->per_batch_context, column_description->value_bytes); memcpy(tmp, DatumGetPointer(*output_value), column_description->value_bytes); *output_value = PointerGetDatum(tmp); } } break; } case COUNT_COLUMN: { bool isnull; Datum value = slot_getattr(compressed_slot, column_description->compressed_scan_attno, &isnull); /* count column should never be NULL */ Assert(!isnull); int count_value = DatumGetInt32(value); if (count_value <= 0) { ereport(ERROR, (errmsg("the compressed data is corrupt: got a segment with length %d", count_value))); } Assert(batch_state->total_batch_rows == 0); CheckCompressedData(count_value <= UINT16_MAX); batch_state->total_batch_rows = count_value; break; } case SEQUENCE_NUM_COLUMN: /* * nothing to do here for sequence number * we only needed this for sorting in node below */ break; } } CompressedBatchVectorQualState cbvqstate = { .vqstate = { .vectorized_quals_constified = dcontext->vectorized_quals_constified, .num_results = batch_state->total_batch_rows, .per_vector_mcxt = batch_state->per_batch_context, .slot = compressed_slot, .get_arrow_array = compressed_batch_get_arrow_array, }, .batch_state = batch_state, .dcontext = dcontext, }; VectorQualState *vqstate = &cbvqstate.vqstate; BatchQualSummary vector_qual_summary = vqstate->vectorized_quals_constified != NIL ? vector_qual_compute(vqstate) : AllRowsPass; batch_state->vector_qual_result = vqstate->vector_qual_result; if (vector_qual_summary == NoRowsPass && !dcontext->batch_sorted_merge) { /* * The entire batch doesn't pass the vectorized quals, so we might be * able to avoid reading and decompressing other columns. Scroll it to * the end. * Note that this optimization can't work with "batch sorted merge", * because the latter always has to read the first row of the batch for * its sorting needs, so it always has to read and decompress all * columns. This can be improved by only decompressing the columns * needed for sorting. */ compressed_batch_discard_tuples(batch_state); InstrCountTuples2(dcontext->ps, 1); InstrCountFiltered1(dcontext->ps, batch_state->total_batch_rows); } else { /* * We have some rows in the batch that pass the vectorized filters, so * we have to decompress the rest of the compressed columns. */ const int num_data_columns = dcontext->num_data_columns; for (int i = 0; i < num_data_columns; i++) { CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; if (column_values->decompression_type == DT_Invalid) { decompress_column(dcontext, batch_state, compressed_slot, i); Assert(column_values->decompression_type != DT_Invalid); } } /* * If all rows pass, no need to test the vector qual for each row. This * is a common case for time range conditions. */ if (vector_qual_summary == AllRowsPass) { batch_state->vector_qual_result = NULL; vqstate->vector_qual_result = NULL; } } } static void store_text_datum(CompressedColumnValues *column_values, int arrow_row) { const uint32 start = ((uint32 *) column_values->buffers[1])[arrow_row]; const int32 value_bytes = ((uint32 *) column_values->buffers[1])[arrow_row + 1] - start; Assert(value_bytes >= 0); const int total_bytes = value_bytes + VARHDRSZ; Assert(DatumGetPointer(*column_values->output_value) != NULL); SET_VARSIZE(*column_values->output_value, total_bytes); memcpy(VARDATA(*column_values->output_value), &((uint8 *) column_values->buffers[2])[start], value_bytes); } /* * Construct the next tuple in the decompressed scan slot. * Doesn't check the quals. */ static void make_next_tuple(DecompressBatchState *batch_state, uint16 arrow_row, int num_data_columns) { TupleTableSlot *decompressed_scan_slot = &batch_state->decompressed_scan_slot_data.base; Assert(batch_state->total_batch_rows > 0); Assert(batch_state->next_batch_row < batch_state->total_batch_rows); for (int i = 0; i < num_data_columns; i++) { CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; if (column_values->decompression_type == DT_Iterator) { DecompressionIterator *iterator = (DecompressionIterator *) column_values->buffers[0]; DecompressResult result = iterator->try_next(iterator); if (result.is_done) { elog(ERROR, "compressed column out of sync with batch counter"); } *column_values->output_isnull = result.is_null; *column_values->output_value = result.val; } else if (column_values->decompression_type > SIZEOF_DATUM) { /* * Fixed-width by-reference type that doesn't fit into a Datum. * For now this only happens for 8-byte types on 32-bit systems, * but eventually we could also use it for bigger by-value types * such as UUID. */ const uint8 value_bytes = column_values->decompression_type; const char *src = column_values->buffers[1]; *column_values->output_value = PointerGetDatum(&src[value_bytes * arrow_row]); *column_values->output_isnull = !arrow_row_is_valid(column_values->buffers[0], arrow_row); } else if (column_values->decompression_type == DT_ArrowBits) { /* * The DT_ArrowBits type is a special case, because the value is * stored as an Array of bits. */ *column_values->output_value = BoolGetDatum(arrow_row_is_valid(column_values->buffers[1], arrow_row)); *column_values->output_isnull = !arrow_row_is_valid(column_values->buffers[0], arrow_row); } else if (column_values->decompression_type > 0) { /* * Fixed-width by-value type that fits into a Datum. * * The conversion of Datum to more narrow types will truncate * the higher bytes, so we don't care if we read some garbage * into them, and can always read 8 bytes. These are unaligned * reads, so technically we have to do memcpy. */ const uint8 value_bytes = column_values->decompression_type; Assert(value_bytes <= SIZEOF_DATUM); const char *src = column_values->buffers[1]; memcpy(column_values->output_value, &src[value_bytes * arrow_row], SIZEOF_DATUM); *column_values->output_isnull = !arrow_row_is_valid(column_values->buffers[0], arrow_row); } else if (column_values->decompression_type == DT_ArrowText) { store_text_datum(column_values, arrow_row); *column_values->output_isnull = !arrow_row_is_valid(column_values->buffers[0], arrow_row); } else if (column_values->decompression_type == DT_ArrowTextDict) { const int16 index = ((int16 *) column_values->buffers[3])[arrow_row]; store_text_datum(column_values, index); *column_values->output_isnull = !arrow_row_is_valid(column_values->buffers[0], arrow_row); } else { /* A compressed column with default value, do nothing. */ Assert(column_values->decompression_type == DT_Scalar); } } /* * It's a virtual tuple slot, so no point in clearing/storing it * per each row, we can just update the values in-place. This saves * some CPU. We have to store it after ExecQual returns false (the tuple * didn't pass the filter), or after a new batch. The standard protocol * is to clear and set the tuple slot for each row, but our output tuple * slots are read-only, and the memory is owned by this node, so it is * safe to violate this protocol. */ Assert(TTS_IS_VIRTUAL(decompressed_scan_slot)); if (TTS_EMPTY(decompressed_scan_slot)) { ExecStoreVirtualTuple(decompressed_scan_slot); } } static bool vector_qual(DecompressBatchState *batch_state, uint16 arrow_row) { Assert(batch_state->total_batch_rows > 0); Assert(batch_state->next_batch_row < batch_state->total_batch_rows); if (!batch_state->vector_qual_result) { return true; } return arrow_row_is_valid(batch_state->vector_qual_result, arrow_row); } static bool postgres_qual(DecompressContext *dcontext, DecompressBatchState *batch_state) { TupleTableSlot *decompressed_scan_slot = &batch_state->decompressed_scan_slot_data.base; Assert(IsA(decompressed_scan_slot, TupleTableSlot)); Assert(!TupIsNull(decompressed_scan_slot)); if (dcontext->ps == NULL || dcontext->ps->qual == NULL) { return true; } /* Perform the usual Postgres selection. */ ExprContext *econtext = dcontext->ps->ps_ExprContext; econtext->ecxt_scantuple = decompressed_scan_slot; ResetExprContext(econtext); return ExecQual(dcontext->ps->qual, econtext); } /* * Decompress the next tuple from the batch indicated by batch state. The result is stored * in batch_state->decompressed_scan_slot. The slot will be empty if the batch * is entirely processed. */ void compressed_batch_advance(DecompressContext *dcontext, DecompressBatchState *batch_state) { Assert(batch_state->total_batch_rows > 0); TupleTableSlot *decompressed_scan_slot = &batch_state->decompressed_scan_slot_data.base; const bool reverse = dcontext->reverse; const int num_data_columns = dcontext->num_data_columns; for (; batch_state->next_batch_row < batch_state->total_batch_rows; batch_state->next_batch_row++) { const uint16 output_row = batch_state->next_batch_row; const uint16 arrow_row = unlikely(reverse) ? batch_state->total_batch_rows - 1 - output_row : output_row; if (!vector_qual(batch_state, arrow_row)) { /* * This row doesn't pass the vectorized quals. Advance the iterated * compressed columns if we have any. */ for (int i = 0; i < num_data_columns; i++) { CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; if (column_values->decompression_type == DT_Iterator) { DecompressionIterator *iterator = (DecompressionIterator *) column_values->buffers[0]; iterator->try_next(iterator); } } InstrCountFiltered1(dcontext->ps, 1); continue; } make_next_tuple(batch_state, arrow_row, num_data_columns); if (!postgres_qual(dcontext, batch_state)) { /* * The tuple didn't pass the qual, fetch the next one in the next * iteration. */ InstrCountFiltered1(dcontext->ps, 1); continue; } /* The tuple passed the qual. */ batch_state->next_batch_row++; return; } /* * Reached end of batch. Check that the columns that we're decompressing * row-by-row have also ended. */ Assert(batch_state->next_batch_row == batch_state->total_batch_rows); for (int i = 0; i < num_data_columns; i++) { CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; if (column_values->decompression_type == DT_Iterator) { DecompressionIterator *iterator = (DecompressionIterator *) column_values->buffers[0]; DecompressResult result = iterator->try_next(iterator); if (!result.is_done) { elog(ERROR, "compressed column out of sync with batch counter"); } } } /* Clear old slot state */ ExecClearTuple(decompressed_scan_slot); } /* * Before loading the first matching tuple from the batch, also save the very * first one into the given slot, even if it doesn't pass the quals. This is * needed for batch sorted merge. */ void compressed_batch_save_first_tuple(DecompressContext *dcontext, DecompressBatchState *batch_state, TupleTableSlot *first_tuple_slot) { Assert(batch_state->next_batch_row == 0); Assert(batch_state->total_batch_rows > 0); Assert(TupIsNull(compressed_batch_current_tuple(batch_state))); /* * Check that we have decompressed all columns even if the vector quals * didn't pass for the entire batch. We need them because we're asked * to save the first tuple. This doesn't actually happen yet, because the * vectorized decompression is disabled with sorted merge. */ #ifdef USE_ASSERT_CHECKING const int num_data_columns = dcontext->num_data_columns; for (int i = 0; i < num_data_columns; i++) { CompressedColumnValues *column_values = &batch_state->compressed_columns[i]; Assert(column_values->decompression_type != DT_Invalid); } #endif /* Make the first tuple and save it. */ Assert(batch_state->next_batch_row == 0); const uint16 arrow_row = dcontext->reverse ? batch_state->total_batch_rows - 1 : 0; make_next_tuple(batch_state, arrow_row, dcontext->num_data_columns); ExecCopySlot(first_tuple_slot, &batch_state->decompressed_scan_slot_data.base); /* * Check the quals and advance, so that the batch is in the correct state * for the subsequent calls (matching tuple is in decompressed scan slot). */ const bool qual_passed = vector_qual(batch_state, arrow_row) && postgres_qual(dcontext, batch_state); batch_state->next_batch_row++; if (!qual_passed) { InstrCountFiltered1(dcontext->ps, 1); compressed_batch_advance(dcontext, batch_state); } } /* * Frees all resources used by the compressed batch. * * If the batch is intended to be reused, use compressed_batch_discard_tuples() * instead. */ void compressed_batch_destroy(DecompressBatchState *batch_state) { Assert(batch_state != NULL); if (batch_state->per_batch_context != NULL) { MemoryContextDelete(batch_state->per_batch_context); batch_state->per_batch_context = NULL; } if (batch_state->decompressed_scan_slot_data.base.tts_values != NULL) { /* * Can be separately NULL in the current simplified prototype for * vectorized aggregation, but ideally it should change together with * per-batch context. */ pfree(batch_state->decompressed_scan_slot_data.base.tts_values); batch_state->decompressed_scan_slot_data.base.tts_values = NULL; } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/compressed_batch.h�����������������������������������0000664�0000000�0000000�00000016726�15100345067�0025072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "compression/compression.h" #include "nodes/columnar_scan/decompress_context.h" #include "nodes/columnar_scan/vector_quals.h" #include <executor/tuptable.h> typedef struct ArrowArray ArrowArray; /* How to obtain the decompressed datum for individual row. */ typedef enum { /* * The decompressed value is a boolean and is stored as a vector of bits. */ DT_ArrowBits = -5, DT_ArrowTextDict = -4, DT_ArrowText = -3, /* * The decompressed value is already in the decompressed slot. This is used * for segmentby and compressed columns with default value in batch. */ DT_Scalar = -2, DT_Iterator = -1, DT_Invalid = 0, /* * Any positive number is also valid for the decompression type. It means * arrow array of a fixed-size by-value type, with size in bytes given by * the number. */ } DecompressionType; typedef struct CompressedColumnValues { /* How to obtain the decompressed datum for individual row. */ DecompressionType decompression_type; /* Where to put the decompressed datum. */ Datum *output_value; bool *output_isnull; /* * The flattened source buffers for getting the decompressed datum. * Depending on decompression type, they are as follows: * iterator: iterator * arrow fixed: validity, value * arrow text: validity, uint32* offsets, void* bodies * arrow dict text: validity, uint32* dict offsets, void* dict bodies, int16* indices */ const void *restrict buffers[4]; /* * The source arrow array, if any. We don't use it for building the * individual rows, and use the flattened buffers instead to lessen the * amount of indirections. However, it is used for vectorized filters. */ ArrowArray *arrow; } CompressedColumnValues; /* * All the information needed to decompress a batch. */ typedef struct DecompressBatchState { /* * The slot for the decompressed tuple. * * We embed it into the batch state as the first member (data inheritance), * so that it's easier to pass out to parent nodes, while following the usual * Postgres interface of passing the tuple table slots. * We use &batch_state->decompressed_scan_slot_data.base everywhere where we * need the TupleTableSlot*, and some parent nodes can cast this pointer to * DecompressBatchState* to use our custom interfaces. * * The slot itself follows the TTSVirtualOps tuple slot protocol, because Postgres * expression executor has special fast path for virtual tuples, and we don't * really need the custom tuple slot protocol for anything. One potential use * case for it would be late decompression by implementing custom slot_getattr(). * It was actually implemented and didn't show any benefits in the preliminary * testing, compared to what we already achieve with lazy decompression after * vectorized filters. One reason is that the Postgres expression compiler * can be eager in requesting materialization. For example, it would call * slot_getattr up to the last attribute used by every filter in a qualifier, * before running any qualifiers. This might be possible to configure, but * the area needs more research. * * See the PR #6628 for context. */ VirtualTupleTableSlot decompressed_scan_slot_data; uint16 total_batch_rows; uint16 next_batch_row; MemoryContext per_batch_context; /* * Arrow-style bitmap that says whether the vector quals passed for a given * row. Indexed same as arrow arrays, w/o accounting for the reverse scan * direction. Initialized to all ones, i.e. all rows pass. */ const uint64 *restrict vector_qual_result; /* * This follows DecompressContext.compressed_chunk_columns, but does not * include the trailing metadata columns, but only the leading data columns. * These columns are compressed and segmentby columns, their total number is * given by DecompressContext.num_data_columns. */ CompressedColumnValues compressed_columns[FLEXIBLE_ARRAY_MEMBER]; } DecompressBatchState; extern void compressed_batch_set_compressed_tuple(DecompressContext *dcontext, DecompressBatchState *batch_state, TupleTableSlot *compressed_slot); extern void compressed_batch_advance(DecompressContext *dcontext, DecompressBatchState *batch_state); extern void compressed_batch_save_first_tuple(DecompressContext *dcontext, DecompressBatchState *batch_state, TupleTableSlot *first_tuple_slot); /* * Initialize the batch memory context and bulk decompression context. * * We use Generation context here because the AllocSet has a hardcoded threshold * of 8kB per allocation, after which it allocates directly through malloc. We * want to make the blocks as big as possible, but below the malloc's mmap * threshold. For small queries, these contexts are basically single-shot and * the page faults after an mmap slow them down significantly. The threshold * should be 128 kiB according to the docs, but I'm seeing 64 kiB in testing. * * If bulk decompression is not used, use the default size for batch context. * This reduces memory usage and improves performance with batch sorted merge. */ #define create_bulk_decompression_mctx(parent_mctx) \ GenerationContextCreate(parent_mctx, \ "DecompressBatchState bulk decompression", \ 0, \ 64 * 1024, \ 64 * 1024); #define create_per_batch_mctx(dcontext) \ GenerationContextCreate(CurrentMemoryContext, \ "DecompressBatchState per-batch", \ 0, \ dcontext->enable_bulk_decompression ? 64 * 1024 : 8 * 1024, \ dcontext->enable_bulk_decompression ? 64 * 1024 : 8 * 1024); extern void compressed_batch_destroy(DecompressBatchState *batch_state); extern void compressed_batch_discard_tuples(DecompressBatchState *batch_state); /* * Returns the current decompressed tuple in the compressed batch. */ inline static TupleTableSlot * compressed_batch_current_tuple(DecompressBatchState *batch_state) { if (IsA(&batch_state->decompressed_scan_slot_data, Invalid)) { /* * For convenience, we want a zero-initialized batch to be a valid * "empty" state, but unfortunately a zero-initialized TupleTableSlotData * is not a valid tuple slot, so here we have to work around this mismatch. */ Assert(batch_state->decompressed_scan_slot_data.base.tts_ops == NULL); Assert(batch_state->per_batch_context == NULL); return NULL; } Assert(batch_state->per_batch_context != NULL); return &batch_state->decompressed_scan_slot_data.base; } /* * VectorQualState for a compressed batch used to pass * ColumnarScan-specific data to vector qual functions that are shared * across scan nodes. */ typedef struct CompressedBatchVectorQualState { VectorQualState vqstate; DecompressBatchState *batch_state; DecompressContext *dcontext; } CompressedBatchVectorQualState; const ArrowArray *compressed_batch_get_arrow_array(VectorQualState *vqstate, Expr *expr, bool *is_default_value); ������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/decompress_context.h���������������������������������0000664�0000000�0000000�00000005313�15100345067�0025463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifndef TIMESCALEDB_DECOMPRESS_CONTEXT_H #define TIMESCALEDB_DECOMPRESS_CONTEXT_H #include <postgres.h> #include <access/attnum.h> #include <executor/tuptable.h> #include <nodes/execnodes.h> #include <nodes/pg_list.h> #include "batch_array.h" #include "detoaster.h" typedef enum CompressionColumnType { SEGMENTBY_COLUMN, COMPRESSED_COLUMN, COUNT_COLUMN, SEQUENCE_NUM_COLUMN, } CompressionColumnType; typedef struct CompressionColumnDescription { CompressionColumnType type; Oid typid; int16 value_bytes; bool by_value; /* * Attno of the decompressed column in the scan tuple of ColumnarScan node. * Negative values are special columns that do not have a representation in * the decompressed chunk, but are still used for decompression. The `type` * field is set accordingly for these columns. */ AttrNumber custom_scan_attno; /* * Attno of this column in the uncompressed chunks. We use it to fetch the * default value from the uncompressed chunk tuple descriptor. */ AttrNumber uncompressed_chunk_attno; /* * Attno of the compressed column in the input compressed chunk scan. */ AttrNumber compressed_scan_attno; bool bulk_decompression_supported; } CompressionColumnDescription; typedef struct DecompressContext { /* * Note that this array contains only those columns that are decompressed * (output_attno != 0), and the order is different from the compressed chunk * tuple order: first go the actual data columns, and after that the metadata * columns. */ CompressionColumnDescription *compressed_chunk_columns; /* * This includes all decompressed columns (output_attno != 0), including the * metadata columns. */ int num_columns_with_metadata; /* This excludes the metadata columns. */ int num_data_columns; List *vectorized_quals_constified; bool reverse; bool batch_sorted_merge; /* Batch sorted merge optimization enabled. */ bool enable_bulk_decompression; /* * Scratch space for bulk decompression which might need a lot of temporary * data. */ MemoryContext bulk_decompression_context; TupleTableSlot *custom_scan_slot; /* * The scan tuple descriptor might be different from the uncompressed chunk * one, and it doesn't have the default column values in that case, so we * have to fetch the default values from the uncompressed chunk tuple * descriptor which we store here. */ TupleDesc uncompressed_chunk_tdesc; PlanState *ps; /* Set for filtering and instrumentation */ Detoaster detoaster; } DecompressContext; #endif /* TIMESCALEDB_DECOMPRESS_CONTEXT_H */ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/detoaster.c������������������������������������������0000664�0000000�0000000�00000027446�15100345067�0023553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "detoaster.h" #include <access/detoast.h> #include <access/genam.h> #include <access/heaptoast.h> #include <access/relscan.h> #include <access/skey.h> #include <access/stratnum.h> #include <access/table.h> #include <access/tableam.h> #include <access/toast_internals.h> #include <utils/expandeddatum.h> #include <utils/fmgroids.h> #include <utils/rel.h> #include <utils/relcache.h> #include <compat/compat.h> #include "debug_assert.h" #include <compression/compression.h> /* We redefine this postgres macro to fix a warning about signed integer comparison. */ #define TS_VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer) \ (((int32) VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer)) < (toast_pointer).va_rawsize - VARHDRSZ) /* * Fetch a TOAST slice from a heap table. * * This function is a modified copy of heap_fetch_toast_slice(). The difference * is that it holds the open toast relation, index and other intermediate data * for detoasting in the Detoaster struct, to allow them to be reused over many * input tuples. */ static void ts_fetch_toast(Detoaster *detoaster, struct varatt_external *toast_pointer, struct varlena *result) { const Oid valueid = toast_pointer->va_valueid; /* * Open the toast relation and its indexes */ if (detoaster->toastrel == NULL) { MemoryContext old_mctx = MemoryContextSwitchTo(detoaster->mctx); detoaster->toastrel = table_open(toast_pointer->va_toastrelid, AccessShareLock); int num_indexes; Relation *toastidxs; /* Look for the valid index of toast relation */ const int validIndex = toast_open_indexes(detoaster->toastrel, AccessShareLock, &toastidxs, &num_indexes); detoaster->index = toastidxs[validIndex]; for (int i = 0; i < num_indexes; i++) { if (i != validIndex) { index_close(toastidxs[i], AccessShareLock); } } /* Set up a scan key to fetch from the index. */ ScanKeyInit(&detoaster->toastkey, (AttrNumber) 1, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(valueid)); /* Prepare for scan */ #if PG18_GE detoaster->SnapshotToast = *get_toast_snapshot(); #else init_toast_snapshot(&detoaster->SnapshotToast); #endif detoaster->toastscan = systable_beginscan_ordered(detoaster->toastrel, detoaster->index, &detoaster->SnapshotToast, 1, &detoaster->toastkey); MemoryContextSwitchTo(old_mctx); } else { Ensure(detoaster->toastrel->rd_id == toast_pointer->va_toastrelid, "unexpected toast pointer relid %d, expected %d", toast_pointer->va_toastrelid, detoaster->toastrel->rd_id); detoaster->toastkey.sk_argument = ObjectIdGetDatum(valueid); index_rescan(detoaster->toastscan->iscan, &detoaster->toastkey, 1, NULL, 0); } TupleDesc toasttupDesc = detoaster->toastrel->rd_att; /////////////////////////////////////////////// /* * Read the chunks by index * * The index is on (valueid, chunkidx) so they will come in order */ const int32 attrsize = VARATT_EXTERNAL_GET_EXTSIZE(*toast_pointer); const int32 totalchunks = ((attrsize - 1) / TOAST_MAX_CHUNK_SIZE) + 1; const int startchunk = 0; const int endchunk = (attrsize - 1) / TOAST_MAX_CHUNK_SIZE; Assert(endchunk <= totalchunks); HeapTuple ttup; int32 expectedchunk = startchunk; while ((ttup = systable_getnext_ordered(detoaster->toastscan, ForwardScanDirection)) != NULL) { int32 curchunk; Pointer chunk; bool isnull; char *chunkdata; int32 chunksize; int32 expected_size; int32 chcpystrt; int32 chcpyend; /* * Have a chunk, extract the sequence number and the data */ curchunk = DatumGetInt32(fastgetattr(ttup, 2, toasttupDesc, &isnull)); Assert(!isnull); chunk = DatumGetPointer(fastgetattr(ttup, 3, toasttupDesc, &isnull)); Assert(!isnull); if (!VARATT_IS_EXTENDED(chunk)) { chunksize = VARSIZE(chunk) - VARHDRSZ; chunkdata = VARDATA(chunk); } else if (VARATT_IS_SHORT(chunk)) { /* could happen due to heap_form_tuple doing its thing */ chunksize = VARSIZE_SHORT(chunk) - VARHDRSZ_SHORT; chunkdata = VARDATA_SHORT(chunk); } else { /* should never happen */ elog(ERROR, "found toasted toast chunk for toast value %u in %s", valueid, RelationGetRelationName(detoaster->toastrel)); chunksize = 0; /* keep compiler quiet */ chunkdata = NULL; } /* * Some checks on the data we've found */ if (curchunk != expectedchunk) ereport(ERROR, (errcode(ERRCODE_DATA_CORRUPTED), errmsg_internal("unexpected chunk number %d (expected %d) for toast value %u " "in %s", curchunk, expectedchunk, valueid, RelationGetRelationName(detoaster->toastrel)))); if (curchunk > endchunk) ereport(ERROR, (errcode(ERRCODE_DATA_CORRUPTED), errmsg_internal("unexpected chunk number %d (out of range %d..%d) for toast " "value %u in %s", curchunk, startchunk, endchunk, valueid, RelationGetRelationName(detoaster->toastrel)))); expected_size = curchunk < totalchunks - 1 ? TOAST_MAX_CHUNK_SIZE : attrsize - ((totalchunks - 1) * TOAST_MAX_CHUNK_SIZE); if (chunksize != expected_size) ereport(ERROR, (errcode(ERRCODE_DATA_CORRUPTED), errmsg_internal("unexpected chunk size %d (expected %d) in chunk %d of %d for " "toast value %u in %s", chunksize, expected_size, curchunk, totalchunks, valueid, RelationGetRelationName(detoaster->toastrel)))); /* * Copy the data into proper place in our result */ chcpystrt = 0; chcpyend = chunksize - 1; if (curchunk == startchunk) chcpystrt = 0; if (curchunk == endchunk) chcpyend = (attrsize - 1) % TOAST_MAX_CHUNK_SIZE; memcpy(VARDATA(result) + (curchunk * TOAST_MAX_CHUNK_SIZE) + chcpystrt, chunkdata + chcpystrt, (chcpyend - chcpystrt) + 1); expectedchunk++; } /* * Final checks that we successfully fetched the datum */ if (expectedchunk != (endchunk + 1)) ereport(ERROR, (errcode(ERRCODE_DATA_CORRUPTED), errmsg_internal("missing chunk number %d for toast value %u in %s", expectedchunk, valueid, RelationGetRelationName(detoaster->toastrel)))); } /* * The memory context is used to store intermediate data, and is supposed to * live over the calls to detoaster_detoast_attr_copy(). * That function itself can be called in a short-lived memory context. */ void detoaster_init(Detoaster *detoaster, MemoryContext mctx) { detoaster->toastrel = NULL; detoaster->mctx = mctx; } void detoaster_close(Detoaster *detoaster) { /* Close toast table */ if (detoaster->toastrel != NULL) { systable_endscan_ordered(detoaster->toastscan); table_close(detoaster->toastrel, AccessShareLock); index_close(detoaster->index, AccessShareLock); detoaster->toastrel = NULL; detoaster->index = NULL; } } /* * Copy of Postgres' toast_fetch_datum(): Reconstruct an in memory Datum from * the chunks saved in the toast relation. */ static struct varlena * ts_toast_fetch_datum(struct varlena *attr, Detoaster *detoaster, MemoryContext dest_mctx) { struct varlena *result; struct varatt_external toast_pointer; int32 attrsize; if (!VARATT_IS_EXTERNAL_ONDISK(attr)) elog(ERROR, "toast_fetch_datum shouldn't be called for non-ondisk datums"); /* Must copy to access aligned fields */ VARATT_EXTERNAL_GET_POINTER(toast_pointer, attr); attrsize = VARATT_EXTERNAL_GET_EXTSIZE(toast_pointer); result = (struct varlena *) MemoryContextAlloc(dest_mctx, attrsize + VARHDRSZ); if (TS_VARATT_EXTERNAL_IS_COMPRESSED(toast_pointer)) SET_VARSIZE_COMPRESSED(result, attrsize + VARHDRSZ); else SET_VARSIZE(result, attrsize + VARHDRSZ); if (attrsize == 0) return result; /* Probably shouldn't happen, but just in * case. */ /* Fetch all chunks */ ts_fetch_toast(detoaster, &toast_pointer, result); return result; } #include <access/toast_compression.h> static struct varlena * ts_toast_decompress_datum(struct varlena *attr) { ToastCompressionId cmid; Assert(VARATT_IS_COMPRESSED(attr)); /* * Fetch the compression method id stored in the compression header and * decompress the data using the appropriate decompression routine. */ cmid = TOAST_COMPRESS_METHOD(attr); switch (cmid) { case TOAST_PGLZ_COMPRESSION_ID: return pglz_decompress_datum(attr); case TOAST_LZ4_COMPRESSION_ID: return lz4_decompress_datum(attr); default: elog(ERROR, "invalid compression method id %d", cmid); return NULL; /* keep compiler quiet */ } } /* * Modification of Postgres' detoast_attr() where we use the stateful Detoaster * and skip some cases that don't occur for the toasted compressed data. Even if * the data is inline and no detoasting is needed, copies it into the destination * memory context. */ struct varlena * detoaster_detoast_attr_copy(struct varlena *attr, Detoaster *detoaster, MemoryContext dest_mctx) { if (!VARATT_IS_EXTENDED(attr)) { /* * This case is unlikely because the compressed data is almost always * toasted and not inline, but we still have to copy the data into the * destination memory context. The source compressed tuple may have * independent unknown lifetime. */ Size len = VARSIZE(attr); struct varlena *result = (struct varlena *) MemoryContextAlloc(dest_mctx, len); memcpy(result, attr, len); return result; } if (VARATT_IS_EXTERNAL_ONDISK(attr)) { /* * This is an externally stored datum --- fetch it back from there. */ attr = ts_toast_fetch_datum(attr, detoaster, dest_mctx); /* If it's compressed, decompress it */ if (VARATT_IS_COMPRESSED(attr)) { struct varlena *tmp = attr; MemoryContext old_context = MemoryContextSwitchTo(dest_mctx); attr = ts_toast_decompress_datum(tmp); MemoryContextSwitchTo(old_context); pfree(tmp); } return attr; } /* * Can't get indirect TOAST here (out-of-line Datum that's stored in memory), * because we're reading from the compressed chunk table. */ Ensure(!VARATT_IS_EXTERNAL_INDIRECT(attr), "got indirect TOAST for compressed data"); /* * Compressed data doesn't have an expanded representation. */ Ensure(!VARATT_IS_EXTERNAL_EXPANDED(attr), "got expanded TOAST for compressed data"); if (VARATT_IS_COMPRESSED(attr)) { /* * This is a compressed value stored inline in the main tuple. It rarely * occurs in practice, because we set a low toast_tuple_target = 128 * for the compressed chunks, but is still technically possible. * * Note that the attr comes from the compressed tuple slot here, so we * don't have to free it unlike the above case of decompression. */ MemoryContext old_context = MemoryContextSwitchTo(dest_mctx); attr = ts_toast_decompress_datum(attr); MemoryContextSwitchTo(old_context); return attr; } /* * The only option left is a short-header varlena --- convert to 4-byte * header format. */ Ensure(VARATT_IS_SHORT(attr), "got unexpected TOAST type for compressed data"); /* * Check that the size of datum is not less than the size of header, which * could lead to data_size of UINT64_MAX. This is possible in case of * TOAST data corruption. Postgres doesn't specifically check for this, * because in any case it will be detected by the subsequent palloc call, * but we do it to silence the Coverity warning. */ CheckCompressedData(VARSIZE_SHORT(attr) >= VARHDRSZ_SHORT); Size data_size = VARSIZE_SHORT(attr) - VARHDRSZ_SHORT; Size new_size = data_size + VARHDRSZ; struct varlena *new_attr; new_attr = (struct varlena *) MemoryContextAlloc(dest_mctx, new_size); SET_VARSIZE(new_attr, new_size); memcpy(VARDATA(new_attr), VARDATA_SHORT(attr), data_size); attr = new_attr; return attr; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/detoaster.h������������������������������������������0000664�0000000�0000000�00000001420�15100345067�0023540�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/genam.h> #include <access/relscan.h> #include <access/skey.h> #include <utils/snapshot.h> typedef struct RelationData *Relation; typedef struct Detoaster { MemoryContext mctx; Relation toastrel; Relation index; SnapshotData SnapshotToast; ScanKeyData toastkey; SysScanDesc toastscan; } Detoaster; void detoaster_init(Detoaster *detoaster, MemoryContext mctx); void detoaster_close(Detoaster *detoaster); struct varlena *detoaster_detoast_attr_copy(struct varlena *attr, Detoaster *detoaster, MemoryContext dest_mctx); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/exec.c�����������������������������������������������0000664�0000000�0000000�00000040223�15100345067�0022471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/sysattr.h> #include <executor/executor.h> #include <miscadmin.h> #include <nodes/bitmapset.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/optimizer.h> #include <parser/parsetree.h> #include <rewrite/rewriteManip.h> #include <tcop/tcopprot.h> #include <utils/datum.h> #include <utils/memutils.h> #include <utils/typcache.h> #include "compat/compat.h" #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "guc.h" #include "import/ts_explain.h" #include "nodes/columnar_scan/batch_array.h" #include "nodes/columnar_scan/batch_queue.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/columnar_scan/exec.h" #include "nodes/columnar_scan/planner.h" #if PG18_GE #include <commands/explain_format.h> #include <commands/explain_state.h> #endif static void columnar_scan_begin(CustomScanState *node, EState *estate, int eflags); static void columnar_scan_end(CustomScanState *node); static void columnar_scan_rescan(CustomScanState *node); static void columnar_scan_explain(CustomScanState *node, List *ancestors, ExplainState *es); static CustomExecMethods columnar_scan_state_methods = { .BeginCustomScan = columnar_scan_begin, .ExecCustomScan = NULL, /* To be determined later. */ .EndCustomScan = columnar_scan_end, .ReScanCustomScan = columnar_scan_rescan, .ExplainCustomScan = columnar_scan_explain, }; /* * Build the sortkeys data structure from the list structure in the * custom_private field of the custom scan. This sort info is used to sort * binary heap used for batch sorted merge. */ Node * columnar_scan_state_create(CustomScan *cscan) { ColumnarScanState *chunk_state; chunk_state = (ColumnarScanState *) newNode(sizeof(ColumnarScanState), T_CustomScanState); chunk_state->exec_methods = columnar_scan_state_methods; chunk_state->csstate.methods = &chunk_state->exec_methods; Assert(IsA(cscan->custom_private, List)); Assert(list_length(cscan->custom_private) == DCP_Count); List *settings = list_nth(cscan->custom_private, DCP_Settings); chunk_state->decompression_map = list_nth(cscan->custom_private, DCP_DecompressionMap); chunk_state->is_segmentby_column = list_nth(cscan->custom_private, DCP_IsSegmentbyColumn); chunk_state->bulk_decompression_column = list_nth(cscan->custom_private, DCP_BulkDecompressionColumn); chunk_state->sortinfo = list_nth(cscan->custom_private, DCP_SortInfo); chunk_state->custom_scan_tlist = cscan->custom_scan_tlist; Assert(IsA(settings, IntList)); Assert(list_length(settings) == DCS_Count); chunk_state->hypertable_id = list_nth_int(settings, DCS_HypertableId); chunk_state->chunk_relid = list_nth_int(settings, DCS_ChunkRelid); chunk_state->decompress_context.reverse = list_nth_int(settings, DCS_Reverse); chunk_state->decompress_context.batch_sorted_merge = list_nth_int(settings, DCS_BatchSortedMerge); chunk_state->decompress_context.enable_bulk_decompression = list_nth_int(settings, DCS_EnableBulkDecompression); chunk_state->has_row_marks = list_nth_int(settings, DCS_HasRowMarks); Assert(IsA(cscan->custom_exprs, List)); Assert(list_length(cscan->custom_exprs) == 1); chunk_state->vectorized_quals_original = linitial(cscan->custom_exprs); Assert(list_length(chunk_state->decompression_map) == list_length(chunk_state->is_segmentby_column)); return (Node *) chunk_state; } typedef struct ConstifyTableOidContext { Index chunk_index; Oid chunk_relid; bool made_changes; } ConstifyTableOidContext; static Node * constify_tableoid_walker(Node *node, ConstifyTableOidContext *ctx) { if (node == NULL) return NULL; if (IsA(node, Var)) { Var *var = castNode(Var, node); if ((Index) var->varno != ctx->chunk_index) return node; if (var->varattno == TableOidAttributeNumber) { ctx->made_changes = true; return ( Node *) makeConst(OIDOID, -1, InvalidOid, 4, (Datum) ctx->chunk_relid, false, true); } /* * we doublecheck system columns here because projection will * segfault if any system columns get through */ if (var->varattno < SelfItemPointerAttributeNumber) ereport(ERROR, (errcode(ERRCODE_INVALID_COLUMN_REFERENCE), errmsg("transparent decompression only supports tableoid system column"))); return node; } return expression_tree_mutator(node, constify_tableoid_walker, (void *) ctx); } static List * constify_tableoid(List *node, Index chunk_index, Oid chunk_relid) { ConstifyTableOidContext ctx = { .chunk_index = chunk_index, .chunk_relid = chunk_relid, .made_changes = false, }; List *result = (List *) constify_tableoid_walker((Node *) node, &ctx); if (ctx.made_changes) { return result; } return node; } pg_attribute_always_inline static TupleTableSlot * columnar_scan_exec_impl(ColumnarScanState *chunk_state, const BatchQueueFunctions *funcs); static TupleTableSlot * columnar_scan_exec_fifo(CustomScanState *node) { ColumnarScanState *chunk_state = (ColumnarScanState *) node; Assert(!chunk_state->decompress_context.batch_sorted_merge); return columnar_scan_exec_impl(chunk_state, &BatchQueueFunctionsFifo); } static TupleTableSlot * columnar_scan_exec_heap(CustomScanState *node) { ColumnarScanState *chunk_state = (ColumnarScanState *) node; Assert(chunk_state->decompress_context.batch_sorted_merge); return columnar_scan_exec_impl(chunk_state, &BatchQueueFunctionsHeap); } /* * Complete initialization of the supplied CustomScanState. * * Standard fields have been initialized by ExecInitCustomScan, * but any private fields should be initialized here. */ static void columnar_scan_begin(CustomScanState *node, EState *estate, int eflags) { ColumnarScanState *chunk_state = (ColumnarScanState *) node; DecompressContext *dcontext = &chunk_state->decompress_context; CustomScan *cscan = castNode(CustomScan, node->ss.ps.plan); Plan *compressed_scan = linitial(cscan->custom_plans); Assert(list_length(cscan->custom_plans) == 1); PlanState *ps = &node->ss.ps; if (ps->ps_ProjInfo) { /* * if we are projecting we need to constify tableoid references here * because decompressed tuple are virtual tuples and don't have * system columns. * * We do the constify in executor because even after plan creation * our targetlist might still get modified by parent nodes pushing * down targetlist. */ List *tlist = ps->plan->targetlist; List *modified_tlist = constify_tableoid(tlist, cscan->scan.scanrelid, chunk_state->chunk_relid); if (modified_tlist != tlist) { ps->ps_ProjInfo = ExecBuildProjectionInfo(modified_tlist, ps->ps_ExprContext, ps->ps_ResultTupleSlot, ps, node->ss.ss_ScanTupleSlot->tts_tupleDescriptor); } } /* * Sort keys should only be present at the level of this node when batch * sorted merge is used. * In other cases of sort pushdown, sorting is performed by the underlying * compressed scan. */ Assert(dcontext->batch_sorted_merge == true || list_length(chunk_state->sortinfo) == 0); /* * Init the underlying compressed scan. */ node->custom_ps = lappend(node->custom_ps, ExecInitNode(compressed_scan, estate, eflags)); /* * Count the actual data columns we have to decompress, skipping the * metadata columns. We only need the metadata columns when initializing the * compressed batch, so they are not saved in the compressed batch itself, * it tracks only the data columns. We put the metadata columns to the end * of the array to have the same column indexes in compressed batch state * and in decompression context. */ int num_data_columns = 0; int num_columns_with_metadata = 0; ListCell *dest_cell; ListCell *is_segmentby_cell; forboth (dest_cell, chunk_state->decompression_map, is_segmentby_cell, chunk_state->is_segmentby_column) { AttrNumber output_attno = lfirst_int(dest_cell); if (output_attno == 0) { /* We are asked not to decompress this column, skip it. */ continue; } if (output_attno > 0) { /* * Not a metadata column. */ num_data_columns++; } num_columns_with_metadata++; } Assert(num_data_columns <= num_columns_with_metadata); dcontext->num_data_columns = num_data_columns; dcontext->num_columns_with_metadata = num_columns_with_metadata; dcontext->compressed_chunk_columns = palloc0(sizeof(CompressionColumnDescription) * num_columns_with_metadata); dcontext->custom_scan_slot = node->ss.ss_ScanTupleSlot; dcontext->uncompressed_chunk_tdesc = RelationGetDescr(node->ss.ss_currentRelation); dcontext->ps = &node->ss.ps; TupleDesc desc = dcontext->custom_scan_slot->tts_tupleDescriptor; /* * Compressed columns go in front, and the rest go to the back, so we have * separate indices for them. */ int current_compressed = 0; int current_not_compressed = num_data_columns; for (int compressed_index = 0; compressed_index < list_length(chunk_state->decompression_map); compressed_index++) { CompressionColumnDescription column = { .compressed_scan_attno = AttrOffsetGetAttrNumber(compressed_index), .custom_scan_attno = list_nth_int(chunk_state->decompression_map, compressed_index), .bulk_decompression_supported = list_nth_int(chunk_state->bulk_decompression_column, compressed_index) }; if (column.custom_scan_attno == 0) { /* We are asked not to decompress this column, skip it. */ continue; } if (column.custom_scan_attno > 0) { /* normal column that is also present in decompressed chunk */ Form_pg_attribute attribute = TupleDescAttr(desc, AttrNumberGetAttrOffset(column.custom_scan_attno)); column.typid = attribute->atttypid; get_typlenbyval(column.typid, &column.value_bytes, &column.by_value); if (list_nth_int(chunk_state->is_segmentby_column, compressed_index)) column.type = SEGMENTBY_COLUMN; else column.type = COMPRESSED_COLUMN; if (cscan->custom_scan_tlist == NIL) { column.uncompressed_chunk_attno = column.custom_scan_attno; } else { Var *var = castNode(Var, castNode(TargetEntry, list_nth(cscan->custom_scan_tlist, AttrNumberGetAttrOffset(column.custom_scan_attno))) ->expr); column.uncompressed_chunk_attno = var->varattno; } } else { /* metadata columns */ switch (column.custom_scan_attno) { case COLUMNAR_SCAN_COUNT_ID: column.type = COUNT_COLUMN; break; case COLUMNAR_SCAN_SEQUENCE_NUM_ID: column.type = SEQUENCE_NUM_COLUMN; break; default: elog(ERROR, "Invalid column attno \"%d\"", column.custom_scan_attno); break; } } if (column.custom_scan_attno > 0) { /* Data column. */ Assert(current_compressed < num_data_columns); dcontext->compressed_chunk_columns[current_compressed++] = column; } else { /* Metadata column. */ Assert(current_not_compressed < num_columns_with_metadata); dcontext->compressed_chunk_columns[current_not_compressed++] = column; } } Assert(current_compressed == num_data_columns); Assert(current_not_compressed == num_columns_with_metadata); /* * Choose which batch queue we are going to use: heap for batch sorted * merge, and one-element FIFO for normal decompression. */ if (dcontext->batch_sorted_merge) { chunk_state->batch_queue = batch_queue_heap_create(num_data_columns, chunk_state->sortinfo, dcontext->custom_scan_slot->tts_tupleDescriptor, &BatchQueueFunctionsHeap); chunk_state->exec_methods.ExecCustomScan = columnar_scan_exec_heap; } else { chunk_state->batch_queue = batch_queue_fifo_create(num_data_columns, &BatchQueueFunctionsFifo); chunk_state->exec_methods.ExecCustomScan = columnar_scan_exec_fifo; } if ((ts_guc_debug_require_batch_sorted_merge == DRO_Require || ts_guc_debug_require_batch_sorted_merge == DRO_Force) && !dcontext->batch_sorted_merge) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("debug: batch sorted merge is required but not used"))); } if (ts_guc_debug_require_batch_sorted_merge == DRO_Forbid && dcontext->batch_sorted_merge) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("debug: batch sorted merge is used when it is forbidden"))); } /* Constify stable expressions in vectorized predicates. */ PlannerGlobal glob = { .boundParams = node->ss.ps.state->es_param_list_info, }; PlannerInfo root = { .glob = &glob, }; ListCell *lc; foreach (lc, chunk_state->vectorized_quals_original) { Node *constified = estimate_expression_value(&root, (Node *) lfirst(lc)); dcontext->vectorized_quals_constified = lappend(dcontext->vectorized_quals_constified, constified); } detoaster_init(&dcontext->detoaster, CurrentMemoryContext); } /* * The exec function for the ColumnarScan node. It takes the explicit queue * functions pointer as an optimization, to allow these functions to be * inlined in the FIFO case. This is important because this is a part of a * relatively hot loop. */ pg_attribute_always_inline static TupleTableSlot * columnar_scan_exec_impl(ColumnarScanState *chunk_state, const BatchQueueFunctions *bqfuncs) { DecompressContext *dcontext = &chunk_state->decompress_context; BatchQueue *bq = chunk_state->batch_queue; Assert(bq->funcs == bqfuncs); bqfuncs->pop(bq, dcontext); while (bqfuncs->needs_next_batch(bq)) { TupleTableSlot *subslot = ExecProcNode(linitial(chunk_state->csstate.custom_ps)); if (TupIsNull(subslot)) { /* Won't have more compressed tuples. */ break; } bqfuncs->push_batch(bq, dcontext, subslot); } TupleTableSlot *result_slot = bqfuncs->top_tuple(bq); if (TupIsNull(result_slot)) { return NULL; } if (chunk_state->has_row_marks) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("locking compressed tuples is not supported"))); } if (chunk_state->csstate.ss.ps.ps_ProjInfo) { ExprContext *econtext = chunk_state->csstate.ss.ps.ps_ExprContext; econtext->ecxt_scantuple = result_slot; return ExecProject(chunk_state->csstate.ss.ps.ps_ProjInfo); } return result_slot; } static void columnar_scan_rescan(CustomScanState *node) { ColumnarScanState *chunk_state = (ColumnarScanState *) node; BatchQueue *bq = chunk_state->batch_queue; bq->funcs->reset(bq); if (node->ss.ps.chgParam != NULL) UpdateChangedParamSet(linitial(node->custom_ps), node->ss.ps.chgParam); ExecReScan(linitial(node->custom_ps)); } /* End the decompress operation and free the requested resources */ static void columnar_scan_end(CustomScanState *node) { ColumnarScanState *chunk_state = (ColumnarScanState *) node; BatchQueue *bq = chunk_state->batch_queue; bq->funcs->free(bq); ExecEndNode(linitial(node->custom_ps)); detoaster_close(&chunk_state->decompress_context.detoaster); } /* * Output additional information for EXPLAIN of a custom-scan plan node. */ static void columnar_scan_explain(CustomScanState *node, List *ancestors, ExplainState *es) { ColumnarScanState *chunk_state = (ColumnarScanState *) node; DecompressContext *dcontext = &chunk_state->decompress_context; ts_show_scan_qual(chunk_state->vectorized_quals_original, "Vectorized Filter", &node->ss.ps, ancestors, es); if (!node->ss.ps.plan->qual && chunk_state->vectorized_quals_original) { /* * The normal explain won't show this if there are no normal quals but * only the vectorized ones. */ ts_show_instrumentation_count("Rows Removed by Filter", 1, &node->ss.ps, es); } if (es->analyze && es->verbose && (node->ss.ps.instrument->ntuples2 > 0 || es->format != EXPLAIN_FORMAT_TEXT)) { ExplainPropertyFloat("Batches Removed by Filter", NULL, node->ss.ps.instrument->ntuples2, 0, es); } if (es->verbose || es->format != EXPLAIN_FORMAT_TEXT) { if (dcontext->batch_sorted_merge) { ExplainPropertyBool("Batch Sorted Merge", dcontext->batch_sorted_merge, es); } if (dcontext->reverse) { ExplainPropertyBool("Reverse", dcontext->reverse, es); } if (es->analyze) { ExplainPropertyBool("Bulk Decompression", chunk_state->decompress_context.enable_bulk_decompression, es); } } } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/exec.h�����������������������������������������������0000664�0000000�0000000�00000002414�15100345067�0022476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "batch_queue.h" #include "decompress_context.h" #include <nodes/extensible.h> #define COLUMNAR_SCAN_COUNT_ID -9 #define COLUMNAR_SCAN_SEQUENCE_NUM_ID -10 typedef struct ColumnarScanState { CustomScanState csstate; List *decompression_map; List *is_segmentby_column; List *bulk_decompression_column; List *custom_scan_tlist; bool has_row_marks; DecompressContext decompress_context; int hypertable_id; Oid chunk_relid; BatchQueue *batch_queue; CustomExecMethods exec_methods; List *sortinfo; /* * For some predicates, we have more efficient implementation that work on * the entire compressed batch in one go. They go to this list, and the rest * goes into the usual ss.ps.qual. Note that we constify stable functions * in these predicates at execution time, but have to keep the original * version for EXPLAIN. We also need special handling for quals that * evaluate to constant false, hence the flag. */ List *vectorized_quals_original; } ColumnarScanState; extern Node *columnar_scan_state_create(CustomScan *cscan); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/planner.c��������������������������������������������0000664�0000000�0000000�00000127042�15100345067�0023211�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/sysattr.h> #include <catalog/pg_namespace.h> #include <catalog/pg_operator.h> #include <nodes/bitmapset.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/nodes.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/paths.h> #include <optimizer/plancat.h> #include <optimizer/restrictinfo.h> #include <optimizer/tlist.h> #include <parser/parse_relation.h> #include <parser/parsetree.h> #include <utils/builtins.h> #include <utils/typcache.h> #include "compression/compression.h" #include "compression/create.h" #include "custom_type_cache.h" #include "guc.h" #include "import/list.h" #include "import/planner.h" #include "nodes/chunk_append/transform.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/columnar_scan/exec.h" #include "nodes/columnar_scan/planner.h" #include "nodes/columnar_scan/vector_quals.h" #include "nodes/vector_agg/exec.h" #include "ts_catalog/array_utils.h" #include "vector_predicates.h" static CustomScanMethods columnar_scan_plan_methods = { .CustomName = "ColumnarScan", .CreateCustomScanState = columnar_scan_state_create, }; /* Check if the provided plan is a ColumnarScanPlan */ bool ts_is_columnar_scan_plan(Plan *plan) { return IsA(plan, CustomScan) && castNode(CustomScan, plan)->methods == &columnar_scan_plan_methods; } void _columnar_scan_init(void) { TryRegisterCustomScanMethods(&columnar_scan_plan_methods); } static void check_for_system_columns(Bitmapset *attrs_used) { int bit = bms_next_member(attrs_used, -1); if (bit > 0 && bit + FirstLowInvalidHeapAttributeNumber < 0) { /* we support tableoid so skip that */ if (bit == TableOidAttributeNumber - FirstLowInvalidHeapAttributeNumber) bit = bms_next_member(attrs_used, bit); if (bit > 0 && bit + FirstLowInvalidHeapAttributeNumber < 0) ereport(ERROR, (errcode(ERRCODE_INVALID_COLUMN_REFERENCE), errmsg("transparent decompression only supports tableoid system column"))); } } typedef struct { bool bulk_decompression_possible; int custom_scan_attno; } UncompressedColumnInfo; typedef struct { /* Can be negative if it's a metadata column, zero if not decompressed. */ int uncompressed_chunk_attno; bool bulk_decompression_possible; bool is_segmentby; } CompressedColumnInfo; /* * Scratch space for mapping out the decompressed columns. */ typedef struct { PlannerInfo *root; ColumnarScanPath *decompress_path; Bitmapset *uncompressed_attrs_needed; /* * If we produce at least some columns that support bulk decompression. */ bool have_bulk_decompression_columns; /* * Maps the uncompressed chunk attno to the respective column compression * info. This lives only during planning so that we can understand on which * columns we can apply vectorized quals, and which uncompressed attno goes * to which custom scan attno (it's not the same if we're using a custom * scan targetlist). */ UncompressedColumnInfo *uncompressed_attno_info; /* * Maps the compressed chunk attno to the respective column compression info. */ CompressedColumnInfo *compressed_attno_info; /* * We might use a custom scan targetlist for ColumnarScan node if it * allows us to avoid projection. */ List *custom_scan_targetlist; /* * Next, we have basically the same data as the above, but expressed as * several Lists, to allow passing them through the custom plan settings. */ /* * decompression_map maps targetlist entries of the compressed scan to * custom scan attnos. Negative values are metadata columns in the compressed * scan that do not have a representation in the uncompressed chunk, but are * still used for decompression. */ List *decompression_map; /* * This Int list is parallel to the compressed scan targetlist, just like * the above one. The value is true if a given targetlist entry is a * segmentby column, false otherwise. Has the same length as the above list. * We have to use the parallel lists and not a list of structs, because the * Plans have to be copyable by the Postgres _copy functions, and we can't * do that for a custom struct. */ List *is_segmentby_column; /* * Same structure as above, says whether we support bulk decompression for this * column. */ List *bulk_decompression_column; } DecompressionMapContext; static bool * build_vector_attrs_array(const UncompressedColumnInfo *colinfo, const CompressionInfo *info) { const AttrNumber arrlen = info->chunk_rel->max_attr + 1; bool *vector_attrs = palloc(sizeof(bool) * arrlen); for (AttrNumber attno = 0; attno < arrlen; attno++) { vector_attrs[attno] = colinfo[attno].bulk_decompression_possible; } return vector_attrs; } /* * Try to make the custom scan targetlist that follows the order of the * pathtarget. This would allow us to avoid a projection from scan tuple to * output tuple. * Returns NIL if it's not possible, e.g. if there are whole-row variables or * variables that are used for quals but not for output. */ static List * follow_uncompressed_output_tlist(const DecompressionMapContext *context) { List *result = NIL; Bitmapset *uncompressed_attrs_found = NULL; const CompressionInfo *info = context->decompress_path->info; const PathTarget *pathtarget = context->decompress_path->custom_path.path.pathtarget; int custom_scan_attno = 1; for (int i = 0; i < list_length(pathtarget->exprs); i++) { Expr *expr = list_nth(pathtarget->exprs, i); if (!IsA(expr, Var)) { /* * The pathtarget has some non-var expressions, so we won't be able * to build a matching decompressed scan targetlist. */ return NIL; } Var *var = castNode(Var, expr); /* This should produce uncompressed chunk columns. */ Assert((Index) var->varno == info->chunk_rel->relid); const int uncompressed_chunk_attno = var->varattno; if (uncompressed_chunk_attno <= 0) { /* * The pathtarget has some special vars so we won't be able to * build a matching decompressed scan targetlist. */ return NIL; } char *attname = get_attname(info->chunk_rte->relid, uncompressed_chunk_attno, /* missing_ok = */ false); TargetEntry *target_entry = makeTargetEntry((Expr *) copyObject(var), /* resno = */ custom_scan_attno, /* resname = */ attname, /* resjunk = */ false); target_entry->ressortgroupref = pathtarget->sortgrouprefs ? pathtarget->sortgrouprefs[i] : 0; result = lappend(result, target_entry); uncompressed_attrs_found = bms_add_member(uncompressed_attrs_found, uncompressed_chunk_attno - FirstLowInvalidHeapAttributeNumber); custom_scan_attno++; } if (!bms_equal(uncompressed_attrs_found, context->uncompressed_attrs_needed)) { /* * There are some variables that are not in the pathtarget that are used * for quals. We still have to have them in the scan tuple in this case. * Note that while we could possibly relax this at execution time for * vectorized quals, the requirement that the qual var be found in the * scan targetlist is a Postgres one. */ return NIL; } return result; } /* * Given the compressed output targetlist and the bitmapset of the needed * columns, determine which compressed chunk column become which uncompressed * chunk column. * * Note that the uncompressed_attrs_needed bitmap is offset by the * FirstLowInvalidHeapAttributeNumber, similar to RelOptInfo.attr_needed. This * allows to encode the requirement for system columns, which have negative * attnos. */ static void build_decompression_map(DecompressionMapContext *context, List *compressed_output_tlist) { ColumnarScanPath *path = context->decompress_path; const CompressionInfo *info = path->info; /* * Track which normal and metadata columns we were able to find in the * targetlist. */ bool missing_count = true; Bitmapset *uncompressed_attrs_found = NULL; Bitmapset *selectedCols = NULL; #if PG16_LT selectedCols = info->ht_rte->selectedCols; #else if (info->ht_rte->perminfoindex > 0) { RTEPermissionInfo *perminfo = getRTEPermissionInfo(context->root->parse->rteperminfos, info->ht_rte); selectedCols = perminfo->selectedCols; } #endif /* * TODO this way to determine which columns are used is actually wrong, see * https://github.com/timescale/timescaledb/issues/4195#issuecomment-1104238863 * Left as is for now, because changing it uncovers a whole new story with * ctid. */ check_for_system_columns(selectedCols); /* * We allow tableoid system column, it won't be in the targetlist but will * be added at decompression time. Always mark it as found. */ if (bms_is_member(TableOidAttributeNumber - FirstLowInvalidHeapAttributeNumber, context->uncompressed_attrs_needed)) { uncompressed_attrs_found = bms_add_member(uncompressed_attrs_found, TableOidAttributeNumber - FirstLowInvalidHeapAttributeNumber); } ListCell *lc; context->uncompressed_attno_info = palloc0(sizeof(*context->uncompressed_attno_info) * (info->chunk_rel->max_attr + 1)); context->compressed_attno_info = palloc0(sizeof(*context->compressed_attno_info) * (info->compressed_rel->max_attr + 1)); /* * Go over the scan targetlist and determine to which output column each * scan column goes, saving other additional info as we do that. */ context->have_bulk_decompression_columns = false; context->decompression_map = NIL; foreach (lc, compressed_output_tlist) { TargetEntry *target = (TargetEntry *) lfirst(lc); if (!IsA(target->expr, Var)) { elog(ERROR, "compressed scan targetlist entries must be Vars"); } Var *var = castNode(Var, target->expr); Assert((Index) var->varno == info->compressed_rel->relid); AttrNumber compressed_chunk_attno = var->varattno; if (compressed_chunk_attno == InvalidAttrNumber) { /* * We shouldn't have whole-row vars in the compressed scan tlist, * they are going to be built by final projection of ColumnarScan * custom scan. * See compressed_rel_setup_reltarget(). */ elog(ERROR, "compressed scan targetlist must not have whole-row vars"); } const char *column_name = get_attname(info->compressed_rte->relid, compressed_chunk_attno, /* missing_ok = */ false); AttrNumber uncompressed_chunk_attno = get_attnum(info->chunk_rte->relid, column_name); AttrNumber destination_attno = 0; if (uncompressed_chunk_attno != InvalidAttrNumber) { /* * Normal column, not a metadata column. */ Assert(uncompressed_chunk_attno != InvalidAttrNumber); if (bms_is_member(0 - FirstLowInvalidHeapAttributeNumber, context->uncompressed_attrs_needed)) { /* * attno = 0 means whole-row var. Output all the columns. */ destination_attno = uncompressed_chunk_attno; uncompressed_attrs_found = bms_add_member(uncompressed_attrs_found, uncompressed_chunk_attno - FirstLowInvalidHeapAttributeNumber); } else if (bms_is_member(uncompressed_chunk_attno - FirstLowInvalidHeapAttributeNumber, context->uncompressed_attrs_needed)) { destination_attno = uncompressed_chunk_attno; uncompressed_attrs_found = bms_add_member(uncompressed_attrs_found, uncompressed_chunk_attno - FirstLowInvalidHeapAttributeNumber); } } else { /* * Metadata column. * We always need count column, and sometimes a sequence number * column. We don't output them, but use them for decompression, * hence the special negative destination attnos. * The min/max metadata columns are normally not required for output * or decompression, they are used only as filter for the compressed * scan, so we skip them here. */ Assert(strncmp(column_name, COMPRESSION_COLUMN_METADATA_PREFIX, strlen(COMPRESSION_COLUMN_METADATA_PREFIX)) == 0); if (strcmp(column_name, COMPRESSION_COLUMN_METADATA_COUNT_NAME) == 0) { destination_attno = COLUMNAR_SCAN_COUNT_ID; missing_count = false; } } const bool is_segment = ts_array_is_member(info->settings->fd.segmentby, column_name); /* * Determine if we can use bulk decompression for this column. */ Oid typoid = get_atttype(info->chunk_rte->relid, uncompressed_chunk_attno); const bool bulk_decompression_possible = !is_segment && destination_attno > 0 && tsl_get_decompress_all_function(compression_get_default_algorithm(typoid), typoid) != NULL; context->have_bulk_decompression_columns |= bulk_decompression_possible; /* * Save information about decompressed columns in uncompressed chunk * for planning of vectorized filters. */ if (uncompressed_chunk_attno != InvalidAttrNumber) { context->uncompressed_attno_info[uncompressed_chunk_attno] = (UncompressedColumnInfo){ .bulk_decompression_possible = bulk_decompression_possible, .custom_scan_attno = InvalidAttrNumber, }; } context->compressed_attno_info[compressed_chunk_attno] = (CompressedColumnInfo){ .bulk_decompression_possible = bulk_decompression_possible, .uncompressed_chunk_attno = destination_attno, .is_segmentby = is_segment, }; } /* * Check that we have found all the needed columns in the compressed targetlist. * We can't conveniently check that we have all columns for all-row vars, so * skip attno 0 in this check. */ Bitmapset *attrs_not_found = bms_difference(context->uncompressed_attrs_needed, uncompressed_attrs_found); int bit = bms_next_member(attrs_not_found, 0 - FirstLowInvalidHeapAttributeNumber); if (bit >= 0) { elog(ERROR, "column '%s' (%d) not found in the targetlist for compressed chunk '%s'", get_attname(info->chunk_rte->relid, bit + FirstLowInvalidHeapAttributeNumber, /* missing_ok = */ true), bit + FirstLowInvalidHeapAttributeNumber, get_rel_name(info->compressed_rte->relid)); } if (missing_count) { elog(ERROR, "the count column was not found in the compressed targetlist"); } /* * If possible, try to make the custom scan targetlist same as the required * output targetlist, so that we can avoid a projection there. */ context->custom_scan_targetlist = follow_uncompressed_output_tlist(context); if (context->custom_scan_targetlist != NIL) { /* * The decompression will produce a custom scan tuple, set the custom * scan attnos accordingly. */ int custom_scan_attno = 1; foreach (lc, context->custom_scan_targetlist) { const int uncompressed_chunk_attno = castNode(Var, castNode(TargetEntry, lfirst(lc))->expr)->varattno; context->uncompressed_attno_info[uncompressed_chunk_attno].custom_scan_attno = custom_scan_attno; custom_scan_attno++; } } else { /* * The decompression will produce the uncompressed chunk tuple, set the * custom scan attnos accordingly. * Note that we might have dropped columns here, but we can set these * attnos for them just as well, they won't be decompressed anyway * because they are not in the compressed scan output. */ for (int i = 1; i <= info->chunk_rel->max_attr; i++) { UncompressedColumnInfo *uncompressed_info = &context->uncompressed_attno_info[i]; uncompressed_info->custom_scan_attno = i; } } /* * Finally, we have to convert the decompression information we've build * into several lists so that it can be passed through the custom path * settings. */ foreach (lc, compressed_output_tlist) { TargetEntry *target = (TargetEntry *) lfirst(lc); Var *var = castNode(Var, target->expr); Assert((Index) var->varno == info->compressed_rel->relid); const AttrNumber compressed_chunk_attno = var->varattno; Assert(compressed_chunk_attno != InvalidAttrNumber); CompressedColumnInfo *compressed_info = &context->compressed_attno_info[compressed_chunk_attno]; /* * Note that the decompressed custom scan targetlist might follow * neither its output targetlist (when we need more columns for filters) * nor the uncompressed chunk tuple. So here we have to do this * additional conversion. */ int compressed_column_destination; if (compressed_info->uncompressed_chunk_attno <= 0) { compressed_column_destination = compressed_info->uncompressed_chunk_attno; } else { UncompressedColumnInfo *uncompressed_info = &context->uncompressed_attno_info[compressed_info->uncompressed_chunk_attno]; compressed_column_destination = uncompressed_info->custom_scan_attno; } context->decompression_map = lappend_int(context->decompression_map, compressed_column_destination); context->is_segmentby_column = lappend_int(context->is_segmentby_column, compressed_info->is_segmentby); context->bulk_decompression_column = lappend_int(context->bulk_decompression_column, compressed_info->bulk_decompression_possible); } } /* replace vars that reference the compressed table with ones that reference the * uncompressed one. Based on replace_nestloop_params */ static Node * replace_compressed_vars(Node *node, const CompressionInfo *info) { if (node == NULL) return NULL; if (IsA(node, Var)) { Var *var = (Var *) node; Var *new_var; char *colname; /* constify tableoid in quals */ if ((Index) var->varno == info->chunk_rel->relid && var->varattno == TableOidAttributeNumber) return (Node *) makeConst(OIDOID, -1, InvalidOid, 4, (Datum) info->chunk_rte->relid, false, true); /* Upper-level Vars should be long gone at this point */ Assert(var->varlevelsup == 0); /* If not to be replaced, we can just return the Var unmodified */ if ((Index) var->varno != info->compressed_rel->relid) return node; /* Create a decompressed Var to replace the compressed one */ colname = get_attname(info->compressed_rte->relid, var->varattno, false); new_var = makeVar(info->chunk_rel->relid, get_attnum(info->chunk_rte->relid, colname), var->vartype, var->vartypmod, var->varcollid, var->varlevelsup); if (!AttributeNumberIsValid(new_var->varattno)) elog(ERROR, "cannot find column %s on decompressed chunk", colname); /* And return the replacement var */ return (Node *) new_var; } if (IsA(node, PlaceHolderVar)) elog(ERROR, "ignoring placeholders"); return expression_tree_mutator(node, replace_compressed_vars, (void *) info); } /* * Find the resno of the given attribute in the provided target list */ static AttrNumber find_attr_pos_in_tlist(List *targetlist, AttrNumber pos) { ListCell *lc; Assert(targetlist != NIL); Assert(pos > 0 && pos != InvalidAttrNumber); foreach (lc, targetlist) { TargetEntry *target = (TargetEntry *) lfirst(lc); if (!IsA(target->expr, Var)) elog(ERROR, "compressed scan targetlist entries must be Vars"); Var *var = castNode(Var, target->expr); AttrNumber compressed_attno = var->varattno; if (compressed_attno == pos) return target->resno; } elog(ERROR, "Unable to locate var %d in targetlist", pos); pg_unreachable(); } static bool contains_volatile_functions_checker(Oid func_id, void *context) { return (func_volatile(func_id) == PROVOLATILE_VOLATILE); } static bool is_not_runtime_constant_walker(Node *node, void *context) { if (node == NULL) { return false; } switch (nodeTag(node)) { case T_Var: case T_PlaceHolderVar: /* * We might want to support these nodes to have vectorizable join * clauses (T_Var) or join clauses referencing a variable that is * above outer join (T_PlaceHolderVar). We don't support them at the * moment. */ return true; case T_Param: /* * We support external query parameters (e.g. from parameterized * prepared statements), because they are constant for the duration * of the query. * * Join and initplan parameters are passed as PARAM_EXEC and require * support in the Rescan functions of the custom scan node. We don't * support them at the moment. */ return castNode(Param, node)->paramkind != PARAM_EXTERN; default: if (check_functions_in_node(node, contains_volatile_functions_checker, /* context = */ NULL)) { return true; } return expression_tree_walker(node, is_not_runtime_constant_walker, /* context = */ NULL); } } /* * Check if the given node is a run-time constant, i.e. it doesn't contain * volatile functions or variables or parameters. This means we can evaluate * it at run time, allowing us to apply the vectorized comparison operators * that have the form "Var op Const". This applies for example to filter * expressions like `time > now() - interval '1 hour'`. * Note that we do the same evaluation when doing run time chunk exclusion, but * there is no good way to pass the evaluated clauses to the underlying nodes * like this ColumnarScan node. * * Similar checks are performed for sparse index pushdown. */ static bool is_not_runtime_constant(Node *node) { bool result = is_not_runtime_constant_walker(node, /* context = */ NULL); return result; } /* * Try to check if the current qual is vectorizable, and if needed make a * commuted copy. If not, return NULL. */ Node * vector_qual_make(Node *qual, const VectorQualInfo *vqinfo) { /* * We can vectorize BoolExpr (AND/OR/NOT). */ if (IsA(qual, BoolExpr)) { BoolExpr *boolexpr = castNode(BoolExpr, qual); if (boolexpr->boolop == NOT_EXPR) { /* * NOT should be removed by Postgres for all operators we can * vectorize (see prepqual.c) except when the where clause is * something like 'COL = false' for bool columns. In this case, we * have to check if it was transformed to BoolExpr(NOT_EXPR, Var) so * we can vectorize it, provided that the column supports bulk * decompression. */ if (list_length(boolexpr->args) == 1 && IsA(linitial(boolexpr->args), Var)) { if (!vqinfo->vector_attrs[castNode(Var, linitial(boolexpr->args))->varattno]) { return NULL; } } else { return NULL; } } bool need_copy = false; List *vectorized_args = NIL; ListCell *lc; foreach (lc, boolexpr->args) { Node *arg = lfirst(lc); Node *vectorized_arg = vector_qual_make(arg, vqinfo); if (vectorized_arg == NULL) { return NULL; } if (vectorized_arg != arg) { need_copy = true; } vectorized_args = lappend(vectorized_args, vectorized_arg); } if (!need_copy) { return (Node *) boolexpr; } BoolExpr *boolexpr_copy = (BoolExpr *) copyObject(boolexpr); boolexpr_copy->args = vectorized_args; return (Node *) boolexpr_copy; } /* * Among the simple predicates, we vectorize some "Var op Const" binary * predicates, scalar array operations with these predicates, boolean variables * and null test. */ NullTest *nulltest = NULL; OpExpr *opexpr = NULL; ScalarArrayOpExpr *saop = NULL; Node *arg1 = NULL; Node *arg2 = NULL; Oid opno = InvalidOid; Var *var = NULL; if (IsA(qual, OpExpr)) { opexpr = castNode(OpExpr, qual); opno = opexpr->opno; if (list_length(opexpr->args) != 2) { return NULL; } arg1 = (Node *) linitial(opexpr->args); arg2 = (Node *) lsecond(opexpr->args); } else if (IsA(qual, ScalarArrayOpExpr)) { saop = castNode(ScalarArrayOpExpr, qual); opno = saop->opno; Assert(list_length(saop->args) == 2); arg1 = (Node *) linitial(saop->args); arg2 = (Node *) lsecond(saop->args); } else if (IsA(qual, NullTest)) { nulltest = castNode(NullTest, qual); arg1 = (Node *) nulltest->arg; } else if (IsA(qual, BooleanTest)) { BooleanTest *booltest = castNode(BooleanTest, qual); if (IsA(booltest->arg, Var)) { var = castNode(Var, booltest->arg); if (!vqinfo->vector_attrs[var->varattno]) { return NULL; } return (Node *) booltest; } else { return NULL; } } else if (IsA(qual, Var) && (castNode(Var, qual))->vartype == BOOLOID) { /* We can vectorize boolean variables if bulk decompression is possible. */ var = castNode(Var, qual); if (!vqinfo->vector_attrs[var->varattno]) { return NULL; } return (Node *) var; } else { return NULL; } if (opexpr && IsA(arg2, Var)) { /* * Try to commute the operator if we have Var on the right. */ opno = get_commutator(opno); if (!OidIsValid(opno)) { return NULL; } opexpr = (OpExpr *) copyObject(opexpr); opexpr->opno = opno; /* * opfuncid is a cache, we can set it to InvalidOid like the * CommuteOpExpr() does. */ opexpr->opfuncid = InvalidOid; opexpr->args = list_make2(arg2, arg1); Node *tmp = arg1; arg1 = arg2; arg2 = tmp; } /* * We can vectorize the operation where the left side is a Var. */ if (!IsA(arg1, Var)) { return NULL; } var = castNode(Var, arg1); if ((Index) var->varno != vqinfo->rti) { /* * We have a Var from other relation (join clause), can't vectorize it * at the moment. */ return NULL; } if (var->varattno <= 0) { /* * Can't vectorize operators with special variables such as whole-row var. */ return NULL; } /* * ExecQual is performed before ExecProject and operates on the decompressed * scan slot, so the qual attnos are the uncompressed chunk attnos. */ if (!vqinfo->vector_attrs[var->varattno]) { /* This column doesn't support bulk decompression. */ return NULL; } if (nulltest) { /* * The checks we've done to this point is all that is required for null * test. */ return (Node *) nulltest; } /* * We can vectorize the operation where the right side is a constant or can * be evaluated to a constant at run time (e.g. contains stable functions). */ Assert(arg2); if (is_not_runtime_constant(arg2)) { return NULL; } Oid opcode = get_opcode(opno); if (!get_vector_const_predicate(opcode)) { return NULL; } if (OidIsValid(var->varcollid) && !get_collation_isdeterministic(var->varcollid)) { /* * Can't vectorize string equality with a nondeterministic collation. * Not sure if we have to check the collation of Const as well, but it * will be known only at planning time. Currently we don't check it at * all. Also this is untested because we don't have nondeterministic * collations in all test configurations. */ return NULL; } if (opexpr) { /* * The checks we've done to this point is all that is required for * OpExpr. */ return (Node *) opexpr; } /* * The only option that is left is a ScalarArrayOpExpr. */ Assert(saop != NULL); /* * The planner can decide to build a hash table. It's still somewhat slower * than our vectorized lookups for array lengths <= 32. */ if (saop->hashfuncid) { if (!IsA(arg2, Const)) { /* * The planner as of PG 17 only uses hashing for plan-time constants, * but double-check. */ return NULL; } Const *c = castNode(Const, arg2); if (c->constisnull) { /* * Shouldn't happen, but not controlled by us. */ return NULL; } Datum arrdatum = c->constvalue; ArrayType *arr = (ArrayType *) DatumGetPointer(arrdatum); const int nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr)); if (nitems > 32) { return NULL; } } return (Node *) saop; } /* * Find the scan qualifiers that can be vectorized and put them into a separate * list. */ static void find_vectorized_quals(DecompressionMapContext *context, ColumnarScanPath *path, List *qual_list, List **vectorized, List **nonvectorized) { VectorQualInfo vqi = { .maxattno = path->info->chunk_rel->max_attr, .vector_attrs = build_vector_attrs_array(context->uncompressed_attno_info, path->info), .rti = path->info->chunk_rel->relid, }; ListCell *lc; foreach (lc, qual_list) { Node *source_qual = lfirst(lc); /* * We can't vectorize the stable cross-type operators (for example * timestamp > timestamptz), so try to cast the constant to the same * type to convert it to the same-type operator. We do the same thing * for chunk exclusion. */ Node *transformed_comparison = (Node *) ts_transform_cross_datatype_comparison((Expr *) source_qual); Node *vectorized_qual = vector_qual_make(transformed_comparison, &vqi); if (vectorized_qual) { *vectorized = lappend(*vectorized, vectorized_qual); } else { *nonvectorized = lappend(*nonvectorized, source_qual); } } pfree(vqi.vector_attrs); } /* * Copy of the Postgres' static function from createplan.c. * * Some places in this file build Sort nodes that don't have a directly * corresponding Path node. The cost of the sort is, or should have been, * included in the cost of the Path node we're working from, but since it's * not split out, we have to re-figure it using cost_sort(). This is just * to label the Sort node nicely for EXPLAIN. * * limit_tuples is as for cost_sort (in particular, pass -1 if no limit) */ static void ts_label_sort_with_costsize(PlannerInfo *root, Sort *plan, double limit_tuples) { Plan *lefttree = plan->plan.lefttree; Path sort_path; /* dummy for result of cost_sort */ /* * This function shouldn't have to deal with IncrementalSort plans because * they are only created from corresponding Path nodes. */ Assert(IsA(plan, Sort)); cost_sort(&sort_path, root, NIL, #if PG18_GE lefttree->disabled_nodes, #endif lefttree->total_cost, lefttree->plan_rows, lefttree->plan_width, 0.0, work_mem, limit_tuples); plan->plan.startup_cost = sort_path.startup_cost; plan->plan.total_cost = sort_path.total_cost; plan->plan.plan_rows = lefttree->plan_rows; plan->plan.plan_width = lefttree->plan_width; plan->plan.parallel_aware = false; plan->plan.parallel_safe = lefttree->parallel_safe; } /* * Find a variable of the given relation somewhere in the expression tree. * Currently we use this to find the Var argument of time_bucket, when we prepare * the batch sorted merge parameters after using the monotonous sorting transform * optimization. */ static Var * find_var_subexpression(void *expr, Index varno) { List *varlist = pull_var_clause((Node *) expr, 0); if (list_length(varlist) == 1) { Var *var = (Var *) linitial(varlist); if ((Index) var->varno == (Index) varno) { return var; } return NULL; } return NULL; } Plan * columnar_scan_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path, List *output_targetlist, List *clauses, List *custom_plans) { ColumnarScanPath *dcpath = (ColumnarScanPath *) path; CustomScan *decompress_plan = makeNode(CustomScan); Scan *compressed_scan = linitial(custom_plans); Path *compressed_path = linitial(path->custom_paths); List *settings; ListCell *lc; Assert(list_length(custom_plans) == 1); Assert(list_length(path->custom_paths) == 1); decompress_plan->flags = path->flags; decompress_plan->methods = &columnar_scan_plan_methods; decompress_plan->scan.scanrelid = dcpath->info->chunk_rel->relid; if (IsA(compressed_path, IndexPath)) { /* * Check if any of the decompressed scan clauses are redundant with * the compressed index scan clauses. Note that we can't use * is_redundant_derived_clause() here, because it can't work with * IndexClause's, so we use some custom code based on it. */ IndexPath *ipath = castNode(IndexPath, compressed_path); foreach (lc, clauses) { RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc); ListCell *indexclause_cell = NULL; if (rinfo->parent_ec != NULL) { foreach (indexclause_cell, ipath->indexclauses) { IndexClause *indexclause = lfirst(indexclause_cell); RestrictInfo *index_rinfo = indexclause->rinfo; if (index_rinfo->parent_ec == rinfo->parent_ec) { break; } } } if (indexclause_cell != NULL) { /* We already have an index clause derived from same EquivalenceClass. */ continue; } /* * We don't have this clause in the underlying index scan, add it * to the decompressed scan. */ decompress_plan->scan.plan.qual = lappend(decompress_plan->scan.plan.qual, rinfo->clause); } } else { foreach (lc, clauses) { RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc); decompress_plan->scan.plan.qual = lappend(decompress_plan->scan.plan.qual, rinfo->clause); } } decompress_plan->scan.plan.qual = (List *) replace_compressed_vars((Node *) decompress_plan->scan.plan.qual, dcpath->info); /* * Try to use a physical tlist if possible. There's no reason to do the * extra work of projecting the result of compressed chunk scan, because * ColumnarScan can choose only the needed columns itself. * Note that Postgres uses the CP_EXACT_TLIST option when planning the child * paths of the Custom path, so we won't automatically get a physical tlist * here. */ bool target_list_compressed_is_physical = false; if (compressed_path->pathtype == T_IndexOnlyScan) { compressed_scan->plan.targetlist = ((IndexPath *) compressed_path)->indexinfo->indextlist; } else { List *physical_tlist = build_physical_tlist(root, dcpath->info->compressed_rel); /* Can be null if the relation has dropped columns. */ if (physical_tlist) { compressed_scan->plan.targetlist = physical_tlist; target_list_compressed_is_physical = true; } } /* * Determine which columns we have to decompress. * output_targetlist is sometimes empty, e.g. for a direct select from * chunk. We have a ProjectionPath above ColumnarScan in this case, and * the targetlist for this path is not built by the planner * (CP_IGNORE_TLIST). This is why we have to examine rel pathtarget. * Looking at the targetlist is not enough, we also have to decompress the * columns participating in quals and in pathkeys. */ Bitmapset *uncompressed_attrs_needed = NULL; pull_varattnos((Node *) decompress_plan->scan.plan.qual, dcpath->info->chunk_rel->relid, &uncompressed_attrs_needed); pull_varattnos((Node *) dcpath->custom_path.path.pathtarget->exprs, dcpath->info->chunk_rel->relid, &uncompressed_attrs_needed); /* * Determine which compressed column goes to which output column. */ DecompressionMapContext context = { .root = root, .decompress_path = dcpath, .uncompressed_attrs_needed = uncompressed_attrs_needed }; build_decompression_map(&context, compressed_scan->plan.targetlist); /* Build heap sort info for batch sorted merge. */ List *sort_options = NIL; if (dcpath->batch_sorted_merge) { /* * 'order by' of the query and the 'order by' of the compressed batches * match, so we will we use a heap to merge the batches. For the heap we * need a compare function that determines the heap order. This function * is constructed here. * * Batch sorted merge is done over the decompressed chunk scan tuple, so * we must match the pathkeys to the decompressed chunk tupdesc. */ int numsortkeys = list_length(dcpath->custom_path.path.pathkeys); List *sort_col_idx = NIL; List *sort_ops = NIL; List *sort_collations = NIL; List *sort_nulls = NIL; /* */ ListCell *lc; foreach (lc, dcpath->custom_path.path.pathkeys) { PathKey *pk = lfirst(lc); EquivalenceClass *ec = pk->pk_eclass; /* * Find the equivalence member that belongs to decompressed relation. */ EquivalenceMember *em; ListCell *membercell = NULL; #if PG18_GE /* In PG18, iterating over child ems requires you to * use child relids with a special iterator. Here we gather * them by collecting them from childmembers array. * * https://github.com/postgres/postgres/commit/d69d45a5 */ EquivalenceMemberIterator it; setup_eclass_member_iterator(&it, ec, dcpath->custom_path.path.parent->relids); while ((em = eclass_member_iterator_next(&it)) != NULL) { /* Setting up so that the check below doesn't complain */ membercell = &list_make_int_cell(1); #else foreach (membercell, ec->ec_members) { em = lfirst(membercell); #endif if (em->em_is_const) { continue; } int em_relid; if (!bms_get_singleton_member(em->em_relids, &em_relid)) { continue; } if ((Index) em_relid != dcpath->info->chunk_rel->relid) { continue; } /* * The equivalence member expression might be a monotonous * expression of the decompressed relation Var, so recurse to * find it. */ Var *var = find_var_subexpression(em->em_expr, em_relid); Ensure(var != NULL, "non-Var pathkey not expected for compressed batch sorted merge"); Assert((Index) var->varno == (Index) em_relid); /* * Convert its varattno which is the varattno of the * uncompressed chunk tuple, to the decompressed scan tuple * varattno. */ const int decompressed_scan_attno = context.uncompressed_attno_info[var->varattno].custom_scan_attno; Assert(decompressed_scan_attno > 0); /* * Look up the correct sort operator from the PathKey's slightly * abstracted representation. */ Oid sortop = get_opfamily_member(pk->pk_opfamily, var->vartype, var->vartype, pk->pk_cmptype); if (!OidIsValid(sortop)) /* should not happen */ elog(ERROR, "missing operator %d(%u,%u) in opfamily %u", pk->pk_cmptype, var->vartype, var->vartype, pk->pk_opfamily); sort_col_idx = lappend_oid(sort_col_idx, decompressed_scan_attno); sort_collations = lappend_oid(sort_collations, var->varcollid); sort_nulls = lappend_oid(sort_nulls, pk->pk_nulls_first); sort_ops = lappend_oid(sort_ops, sortop); break; } Ensure(membercell != NULL, "could not find matching decompressed chunk column for batch sorted merge " "pathkey"); } sort_options = list_make4(sort_col_idx, sort_ops, sort_collations, sort_nulls); /* * Build a sort node for the compressed batches. The sort function is * derived from the sort function of the pathkeys, except that it refers * to the min and max metadata columns of the batches. We have already * verified that the pathkeys match the compression order_by, so this * mapping is possible. */ AttrNumber *sortColIdx = palloc(sizeof(AttrNumber) * numsortkeys); Oid *sortOperators = palloc(sizeof(Oid) * numsortkeys); Oid *collations = palloc(sizeof(Oid) * numsortkeys); bool *nullsFirst = palloc(sizeof(bool) * numsortkeys); for (int i = 0; i < numsortkeys; i++) { Oid sortop = list_nth_oid(sort_ops, i); /* Find the operator in pg_amop --- failure shouldn't happen */ Oid opfamily, opcintype; CompareType strategy; if (!get_ordering_op_properties(list_nth_oid(sort_ops, i), &opfamily, &opcintype, &strategy)) elog(ERROR, "operator %u is not a valid ordering operator", sortOperators[i]); /* * This way to determine the matching metadata column works, because * we have already verified that the pathkeys match the compression * orderby. */ Assert(strategy == BTLessStrategyNumber || strategy == BTGreaterStrategyNumber); char *meta_col_name = strategy == BTLessStrategyNumber ? column_segment_min_name(i + 1) : column_segment_max_name(i + 1); AttrNumber attr_position = get_attnum(dcpath->info->compressed_rte->relid, meta_col_name); if (attr_position == InvalidAttrNumber) elog(ERROR, "couldn't find metadata column \"%s\"", meta_col_name); /* * If the the compressed target list is not based on the layout of * the uncompressed chunk (see comment for physical_tlist above), * adjust the position of the attribute. */ if (target_list_compressed_is_physical) sortColIdx[i] = attr_position; else sortColIdx[i] = find_attr_pos_in_tlist(compressed_scan->plan.targetlist, attr_position); sortOperators[i] = sortop; collations[i] = list_nth_oid(sort_collations, i); nullsFirst[i] = list_nth_oid(sort_nulls, i); } /* Now build the compressed batches sort node */ Sort *sort = ts_make_sort((Plan *) compressed_scan, numsortkeys, sortColIdx, sortOperators, collations, nullsFirst); ts_label_sort_with_costsize(root, sort, /* limit_tuples = */ -1.0); decompress_plan->custom_plans = list_make1(sort); } else { /* * Add a sort if the compressed scan is not ordered appropriately. */ if (!pathkeys_contained_in(dcpath->required_compressed_pathkeys, compressed_path->pathkeys)) { List *compressed_pks = dcpath->required_compressed_pathkeys; Sort *sort = ts_make_sort_from_pathkeys((Plan *) compressed_scan, compressed_pks, bms_make_singleton(compressed_scan->scanrelid)); ts_label_sort_with_costsize(root, sort, /* limit_tuples = */ -1.0); decompress_plan->custom_plans = list_make1(sort); } else { decompress_plan->custom_plans = custom_plans; } } Assert(list_length(custom_plans) == 1); const bool enable_bulk_decompression = !dcpath->batch_sorted_merge && ts_guc_enable_bulk_decompression && context.have_bulk_decompression_columns; /* * For some predicates, we have more efficient implementation that work on * the entire compressed batch in one go. They go to this list, and the rest * goes into the usual scan.plan.qual. */ List *vectorized_quals = NIL; if (enable_bulk_decompression) { List *nonvectorized_quals = NIL; find_vectorized_quals(&context, dcpath, decompress_plan->scan.plan.qual, &vectorized_quals, &nonvectorized_quals); decompress_plan->scan.plan.qual = nonvectorized_quals; } #ifdef TS_DEBUG if (ts_guc_debug_require_vector_qual == DRO_Forbid && list_length(vectorized_quals) > 0) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("debug: encountered vector quals when they are disabled"))); } else if (ts_guc_debug_require_vector_qual == DRO_Require) { if (list_length(decompress_plan->scan.plan.qual) > 0) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("debug: encountered non-vector quals when they are disabled"))); } if (list_length(vectorized_quals) == 0) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("debug: did not encounter vector quals when they are required"))); } } #endif settings = ts_new_list(T_IntList, DCS_Count); lfirst_int(list_nth_cell(settings, DCS_HypertableId)) = dcpath->info->hypertable_id; lfirst_int(list_nth_cell(settings, DCS_ChunkRelid)) = dcpath->info->chunk_rte->relid; lfirst_int(list_nth_cell(settings, DCS_Reverse)) = dcpath->reverse; lfirst_int(list_nth_cell(settings, DCS_BatchSortedMerge)) = dcpath->batch_sorted_merge; lfirst_int(list_nth_cell(settings, DCS_EnableBulkDecompression)) = enable_bulk_decompression; lfirst_int(list_nth_cell(settings, DCS_HasRowMarks)) = root->parse->rowMarks != NIL; /* * Vectorized quals must go into custom_exprs, because Postgres has to see * them and perform the varno adjustments on them when flattening the * subqueries. */ decompress_plan->custom_exprs = list_make1(vectorized_quals); decompress_plan->custom_private = ts_new_list(T_List, DCP_Count); lfirst(list_nth_cell(decompress_plan->custom_private, DCP_Settings)) = settings; lfirst(list_nth_cell(decompress_plan->custom_private, DCP_DecompressionMap)) = context.decompression_map; lfirst(list_nth_cell(decompress_plan->custom_private, DCP_IsSegmentbyColumn)) = context.is_segmentby_column; lfirst(list_nth_cell(decompress_plan->custom_private, DCP_BulkDecompressionColumn)) = context.bulk_decompression_column; lfirst(list_nth_cell(decompress_plan->custom_private, DCP_SortInfo)) = sort_options; /* * We might be using a custom scan tuple if it allows us to avoid the * projection. Otherwise, this tlist is NIL and we'll be using the * uncompressed tuple as the custom scan tuple. */ decompress_plan->custom_scan_tlist = context.custom_scan_targetlist; /* * Note that we cannot decide here that we require a projection. It is * decided at Path stage, now we must produce the requested targetlist. */ decompress_plan->scan.plan.targetlist = output_targetlist; return &decompress_plan->scan.plan; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/planner.h��������������������������������������������0000664�0000000�0000000�00000001461�15100345067�0023212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> typedef enum { DCS_HypertableId = 0, DCS_ChunkRelid = 1, DCS_Reverse = 2, DCS_BatchSortedMerge = 3, DCS_EnableBulkDecompression = 4, DCS_HasRowMarks = 5, DCS_Count } ColumnarScanSettingsIndex; typedef enum { DCP_Settings = 0, DCP_DecompressionMap = 1, DCP_IsSegmentbyColumn = 2, DCP_BulkDecompressionColumn = 3, DCP_SortInfo = 4, DCP_Count } ColumnarScanPrivateIndex; extern Plan *columnar_scan_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path, List *output_targetlist, List *clauses, List *custom_plans); extern void _columnar_scan_init(void); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/pred_text.c������������������������������������������0000664�0000000�0000000�00000013523�15100345067�0023546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "pred_text.h" #include <miscadmin.h> #include "compat/compat.h" #if PG16_GE #include <varatt.h> #endif static void vector_const_text_comparison(const ArrowArray *arrow, const Datum constdatum, bool needequal, uint64 *restrict result) { Assert(!arrow->dictionary); text *consttext = (text *) DatumGetPointer(constdatum); const size_t textlen = VARSIZE_ANY_EXHDR(consttext); const uint8 *cstring = (uint8 *) VARDATA_ANY(consttext); const uint32 *offsets = (uint32 *) arrow->buffers[1]; const uint8 *values = (uint8 *) arrow->buffers[2]; const size_t n = arrow->length; for (size_t outer = 0; outer < n / 64; outer++) { uint64 word = 0; for (size_t inner = 0; inner < 64; inner++) { const size_t row = (outer * 64) + inner; const size_t bit_index = inner; #define INNER_LOOP \ const uint32 start = offsets[row]; \ const uint32 end = offsets[row + 1]; \ Assert(end >= start); \ const uint32 veclen = end - start; \ bool isequal = veclen != textlen ? \ false : \ (strncmp((char *) &values[start], (char *) cstring, textlen) == 0); \ word |= ((uint64) (isequal == needequal)) << bit_index; INNER_LOOP } result[outer] &= word; } if (n % 64) { uint64 word = 0; for (size_t row = (n / 64) * 64; row < n; row++) { const size_t bit_index = row % 64; INNER_LOOP } result[n / 64] &= word; } #undef INNER_LOOP } void vector_const_texteq(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result) { vector_const_text_comparison(arrow, constdatum, /* needequal = */ true, result); } void vector_const_textne(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result) { vector_const_text_comparison(arrow, constdatum, /* needequal = */ false, result); } /* * Generate specializations for LIKE functions based on database encoding. This * follows the Postgres code from backend/utils/adt/like.c, version 15.0, * commit sha 2a7ce2e2ce474504a707ec03e128fde66cfb8b48. * The copy of PG code begins here. * ---------------------------------------------------------------------------- */ #define LIKE_TRUE 1 #define LIKE_FALSE 0 #define LIKE_ABORT (-1) /* setup to compile like_match.c for UTF8 encoding, using fast NextChar */ #define NextByte(p, plen) ((p)++, (plen)--) #define NextChar(p, plen) \ do \ { \ (p)++; \ (plen)--; \ } while ((plen) > 0 && (*(p) &0xC0) == 0x80) #define MatchText UTF8_MatchText #include "import/ts_like_match.c" /* * ---------------------------------------------------------------------------- * The copy of PG code ends here. */ static void vector_const_like_impl(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result, int (*match)(const char *, int, const char *, int), bool should_match) { Assert(!arrow->dictionary); text *consttext = (text *) DatumGetPointer(constdatum); const size_t textlen = VARSIZE_ANY_EXHDR(consttext); const char *restrict cstring = VARDATA_ANY(consttext); const uint32 *offsets = (uint32 *) arrow->buffers[1]; const char *restrict values = arrow->buffers[2]; const size_t n = arrow->length; for (size_t outer = 0; outer < n / 64; outer++) { uint64 word = 0; for (size_t inner = 0; inner < 64; inner++) { const size_t row = (outer * 64) + inner; const size_t bit_index = inner; /* * The inner loop could have been an inline function, but it would have 5 * parameters and one of them in/out, so a macro probably has better * readability. */ #define INNER_LOOP \ const uint32 start = offsets[row]; \ const uint32 end = offsets[row + 1]; \ Assert(end >= start); \ const uint32 veclen = end - start; \ int result = match(&values[start], veclen, cstring, textlen); \ bool valid = (result == LIKE_TRUE) == should_match; \ word |= ((uint64) valid) << bit_index; INNER_LOOP } result[outer] &= word; } if (n % 64) { uint64 word = 0; for (size_t row = (n / 64) * 64; row < n; row++) { const size_t bit_index = row % 64; INNER_LOOP } result[n / 64] &= word; } #undef INNER_LOOP } void vector_const_textlike_utf8(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result) { vector_const_like_impl(arrow, constdatum, result, UTF8_MatchText, /* should_match = */ true); } void vector_const_textnlike_utf8(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result) { vector_const_like_impl(arrow, constdatum, result, UTF8_MatchText, /* should_match = */ false); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/pred_text.h������������������������������������������0000664�0000000�0000000�00000001371�15100345067�0023551�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "compression/arrow_c_data_interface.h" extern void vector_const_texteq(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result); extern void vector_const_textne(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result); extern void vector_const_textlike_utf8(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result); extern void vector_const_textnlike_utf8(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/pred_vector_array.c����������������������������������0000664�0000000�0000000�00000007774�15100345067�0025275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "compression/arrow_c_data_interface.h" #include "compression/compression.h" #include "src/utils.h" #include "vector_predicates.h" /* * Vectorized implementation of ScalarArrayOpExpr. Applies scalar_predicate for * vector and each element of array, combines the result according to "is_or" * flag. Written along the lines of ExecEvalScalarArrayOp(). */ void vector_array_predicate(VectorPredicate *vector_const_predicate, bool is_or, const ArrowArray *vector, Datum array, uint64 *restrict final_result) { const size_t n_rows = vector->length; const size_t result_words = (n_rows + 63) / 64; uint64 *restrict array_result = final_result; /* * For OR, we need an intermediate storage to accumulate the results * from all elements. * For AND, we can apply predicate for each element to the final result. */ uint64 array_result_storage[(GLOBAL_MAX_ROWS_PER_COMPRESSION + 63) / 64]; if (is_or) { array_result = array_result_storage; for (size_t i = 0; i < result_words; i++) { array_result_storage[i] = 0; } } ArrayType *arr = DatumGetArrayTypeP(array); int16 typlen; bool typbyval; char typalign; get_typlenbyvalalign(ARR_ELEMTYPE(arr), &typlen, &typbyval, &typalign); const char *array_data = (const char *) ARR_DATA_PTR(arr); const size_t nitems = ArrayGetNItems(ARR_NDIM(arr), ARR_DIMS(arr)); const uint64 *array_null_bitmap = (uint64 *) ARR_NULLBITMAP(arr); for (size_t array_index = 0; array_index < nitems; array_index++) { if (array_null_bitmap != NULL && !arrow_row_is_valid(array_null_bitmap, array_index)) { /* * This array element is NULL. We can't avoid NULLS when evaluating * the stable functions at run time, so we have to support them. * This is a predicate, not a generic scalar array operation, so * thankfully we return a non-nullable bool. * For ANY: null | true = true, null | false = null, so this means * we can skip the null element and continue evaluation. * For ALL: null & true = null, null & false = false, so this means * that for each row the condition goes to false, and we don't have * to evaluate the next elements. */ if (is_or) { continue; } for (size_t word = 0; word < result_words; word++) { final_result[word] = 0; } return; } Datum constvalue = ts_fetch_att(array_data, typbyval, typlen); array_data = att_addlength_pointer(array_data, typlen, array_data); array_data = (const char *) att_align_nominal(array_data, typalign); /* * For OR, we also need an intermediate storage for predicate result * for each array element, since the predicates AND their result. * * For AND, we can and apply predicate for each array element to the * final result. */ uint64 single_result_storage[(GLOBAL_MAX_ROWS_PER_COMPRESSION + 63) / 64]; uint64 *restrict single_result; if (is_or) { single_result = single_result_storage; for (size_t outer = 0; outer < result_words; outer++) { single_result[outer] = ~0ULL; } } else { single_result = array_result; } vector_const_predicate(vector, constvalue, single_result); if (is_or) { for (size_t outer = 0; outer < result_words; outer++) { array_result[outer] |= single_result[outer]; } } /* * The bitmaps are small, no more than 15 qwords for our maximal * compressed batch size of 1000 rows, so we can check for early exit * after every row. */ BatchQualSummary summary = get_vector_qual_summary(array_result, n_rows); if (summary == (is_or ? AllRowsPass : NoRowsPass)) { return; } } if (is_or) { for (size_t outer = 0; outer < result_words; outer++) { /* * The tail bits corresponding to past-the-end rows when n % 64 != 0 * should be already zeroed out in the final_result. */ final_result[outer] &= array_result[outer]; } } } ����timescaledb-2.23.0/tsl/src/nodes/columnar_scan/pred_vector_const_arithmetic_all.c�������������������0000664�0000000�0000000�00000006321�15100345067�0030331�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Define all supported "vector ? const" predicates for arithmetic types. */ /* int8 functions. */ #define VECTOR_CTYPE int64 #define CONST_CTYPE int64 #define CONST_CONVERSION(X) DatumGetInt64(X) #define PG_PREDICATE(X) F_INT8##X: case F_TIMESTAMPTZ_##X: case F_TIMESTAMP_##X #include "pred_vector_const_arithmetic_type_pair.c" /* int84 functions. */ #define VECTOR_CTYPE int64 #define CONST_CTYPE int32 #define CONST_CONVERSION(X) DatumGetInt32(X) #define PG_PREDICATE(X) F_INT84##X #include "pred_vector_const_arithmetic_type_pair.c" /* int82 functions. */ #define VECTOR_CTYPE int64 #define CONST_CTYPE int16 #define CONST_CONVERSION(X) DatumGetInt16(X) #define PG_PREDICATE(X) F_INT82##X #include "pred_vector_const_arithmetic_type_pair.c" /* int48 functions. */ #define VECTOR_CTYPE int32 #define CONST_CTYPE int64 #define CONST_CONVERSION(X) DatumGetInt64(X) #define PG_PREDICATE(X) F_INT48##X #include "pred_vector_const_arithmetic_type_pair.c" /* int4 functions. */ #define VECTOR_CTYPE int32 #define CONST_CTYPE int32 #define CONST_CONVERSION(X) DatumGetInt32(X) #define PG_PREDICATE(X) F_INT4##X #include "pred_vector_const_arithmetic_type_pair.c" /* int42 functions. */ #define VECTOR_CTYPE int32 #define CONST_CTYPE int16 #define CONST_CONVERSION(X) DatumGetInt16(X) #define PG_PREDICATE(X) F_INT42##X #include "pred_vector_const_arithmetic_type_pair.c" /* int28 functions. */ #define VECTOR_CTYPE int16 #define CONST_CTYPE int64 #define CONST_CONVERSION(X) DatumGetInt64(X) #define PG_PREDICATE(X) F_INT28##X #include "pred_vector_const_arithmetic_type_pair.c" /* int24 functions. */ #define VECTOR_CTYPE int16 #define CONST_CTYPE int32 #define CONST_CONVERSION(X) DatumGetInt32(X) #define PG_PREDICATE(X) F_INT24##X #include "pred_vector_const_arithmetic_type_pair.c" /* int2 functions. */ #define VECTOR_CTYPE int16 #define CONST_CTYPE int16 #define CONST_CONVERSION(X) DatumGetInt16(X) #define PG_PREDICATE(X) F_INT2##X #include "pred_vector_const_arithmetic_type_pair.c" /* float8 functions. */ #define VECTOR_CTYPE float8 #define CONST_CTYPE float8 #define CONST_CONVERSION(X) DatumGetFloat8(X) #define PG_PREDICATE(X) F_FLOAT8##X #include "pred_vector_const_arithmetic_type_pair.c" /* float84 functions. */ #define VECTOR_CTYPE float8 #define CONST_CTYPE float4 #define CONST_CONVERSION(X) DatumGetFloat4(X) #define PG_PREDICATE(X) F_FLOAT84##X #include "pred_vector_const_arithmetic_type_pair.c" /* float48 functions. */ #define VECTOR_CTYPE float4 #define CONST_CTYPE float8 #define CONST_CONVERSION(X) DatumGetFloat8(X) #define PG_PREDICATE(X) F_FLOAT48##X #include "pred_vector_const_arithmetic_type_pair.c" /* float4 functions. */ #define VECTOR_CTYPE float4 #define CONST_CTYPE float4 #define CONST_CONVERSION(X) DatumGetFloat4(X) #define PG_PREDICATE(X) F_FLOAT4##X #include "pred_vector_const_arithmetic_type_pair.c" /* date functions. */ #define VECTOR_CTYPE DateADT #define CONST_CTYPE DateADT #define CONST_CONVERSION(X) DatumGetDateADT(X) #define PG_PREDICATE(X) F_DATE_##X #include "pred_vector_const_arithmetic_type_pair.c" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/pred_vector_const_arithmetic_single.c����������������0000664�0000000�0000000�00000003613�15100345067�0031043�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Compute a vector-const predicate and AND it to the filter bitmap. * Specialized for particular arithmetic data types and predicate. * Marked as noinline for the ease of debugging. Inlining it shouldn't be * beneficial because it's a big self-contained loop. */ #define PG_PREDICATE_HELPER(X) PG_PREDICATE(X) #define FUNCTION_NAME_HELPER(X, Y, Z) predicate_##X##_##Y##_vector_##Z##_const #define FUNCTION_NAME(X, Y, Z) FUNCTION_NAME_HELPER(X, Y, Z) #ifdef GENERATE_DISPATCH_TABLE case PG_PREDICATE_HELPER(PREDICATE_NAME): return FUNCTION_NAME(PREDICATE_NAME, VECTOR_CTYPE, CONST_CTYPE); #else static pg_noinline void FUNCTION_NAME(PREDICATE_NAME, VECTOR_CTYPE, CONST_CTYPE)(const ArrowArray *arrow, const Datum constdatum, uint64 *restrict result) { const size_t n = arrow->length; /* Now run the predicate itself. */ const CONST_CTYPE constvalue = CONST_CONVERSION(constdatum); const VECTOR_CTYPE *vector = (const VECTOR_CTYPE *) arrow->buffers[1]; for (size_t outer = 0; outer < n / 64; outer++) { /* no need to check the values if the result is already invalid */ if (result[outer] == 0) continue; uint64 word = 0; for (size_t inner = 0; inner < 64; inner++) { const bool valid = PREDICATE_EXPRESSION(vector[outer * 64 + inner], constvalue); word |= ((uint64) valid) << inner; } result[outer] &= word; } if (n % 64) { uint64 tail_word = 0; for (size_t i = (n / 64) * 64; i < n; i++) { const bool valid = PREDICATE_EXPRESSION(vector[i], constvalue); tail_word |= ((uint64) valid) << (i % 64); } result[n / 64] &= tail_word; } } #endif #undef PG_PREDICATE_HELPER #undef FUNCTION_NAME #undef FUNCTION_NAME_HELPER #undef PREDICATE_EXPRESSION #undef PREDICATE_NAME ���������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/pred_vector_const_arithmetic_type_pair.c�������������0000664�0000000�0000000�00000002675�15100345067�0031565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Vector-const predicates for one pair of arithmetic types. For NaN comparison, * Postgres has its own nonstandard rules different from the IEEE floats. */ #define PREDICATE_NAME GE #define PREDICATE_EXPRESSION(X, Y) (isnan((double) (X)) || (!isnan((double) (Y)) && (X) >= (Y))) #include "pred_vector_const_arithmetic_single.c" #define PREDICATE_NAME LE #define PREDICATE_EXPRESSION(X, Y) (isnan((double) (Y)) || (!isnan((double) (X)) && (X) <= (Y))) #include "pred_vector_const_arithmetic_single.c" #define PREDICATE_NAME LT #define PREDICATE_EXPRESSION(X, Y) (!isnan((double) (X)) && (isnan((double) (Y)) || (X) < (Y))) #include "pred_vector_const_arithmetic_single.c" #define PREDICATE_NAME GT #define PREDICATE_EXPRESSION(X, Y) (!isnan((double) (Y)) && (isnan((double) (X)) || (X) > (Y))) #include "pred_vector_const_arithmetic_single.c" #define PREDICATE_NAME EQ #define PREDICATE_EXPRESSION(X, Y) (isnan((double) (X)) ? isnan((double) (Y)) : ((X) == (Y))) #include "pred_vector_const_arithmetic_single.c" #define PREDICATE_NAME NE #define PREDICATE_EXPRESSION(X, Y) (isnan((double) (X)) ? !isnan((double) (Y)) : ((X) != (Y))) #include "pred_vector_const_arithmetic_single.c" #undef VECTOR_CTYPE #undef CONST_CTYPE #undef CONST_CONVERSION #undef PG_PREDICATE �������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/qual_pushdown.c��������������������������������������0000664�0000000�0000000�00000046120�15100345067�0024440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/optimizer.h> #include <optimizer/restrictinfo.h> #include <parser/parse_func.h> #include <parser/parsetree.h> #include <utils/builtins.h> #include <utils/typcache.h> #include "columnar_scan.h" #include "compression/create.h" #include "custom_type_cache.h" #include "guc.h" #include "ts_catalog/array_utils.h" #include "qual_pushdown.h" typedef struct QualPushdownContext { RelOptInfo *chunk_rel; RelOptInfo *compressed_rel; RangeTblEntry *chunk_rte; RangeTblEntry *compressed_rte; CompressionSettings *settings; /* * This is actually the result, not the static input context like above, but * there's no way to separate this properly using the expression tree mutator * interface. */ bool can_pushdown; bool needs_recheck; } QualPushdownContext; static QualPushdownContext copy_context(const QualPushdownContext *source) { QualPushdownContext copy; copy = *source; copy.can_pushdown = true; copy.needs_recheck = false; return copy; } static Node *qual_pushdown_mutator(Node *node, QualPushdownContext *context); void pushdown_quals(PlannerInfo *root, CompressionSettings *settings, RelOptInfo *chunk_rel, RelOptInfo *compressed_rel, bool chunk_partial) { ListCell *lc; List *decompress_clauses = NIL; QualPushdownContext base_context = { .chunk_rel = chunk_rel, .compressed_rel = compressed_rel, .chunk_rte = planner_rt_fetch(chunk_rel->relid, root), .compressed_rte = planner_rt_fetch(compressed_rel->relid, root), .settings = settings, }; foreach (lc, chunk_rel->baserestrictinfo) { RestrictInfo *ri = lfirst(lc); QualPushdownContext clause_context = copy_context(&base_context); Node *pushed_down = qual_pushdown_mutator((Node *) ri->clause, &clause_context); if (clause_context.can_pushdown) { /* * We have to call eval_const_expressions after pushing down * the quals, to normalize the bool expressions. Namely, we might add an * AND boolexpr on minmax metadata columns, but the normal form is not * allowed to have nested AND boolexprs. They break some functions like * generate_bitmap_or_paths(). */ pushed_down = eval_const_expressions(root, pushed_down); if (IsA(pushed_down, BoolExpr) && castNode(BoolExpr, pushed_down)->boolop == AND_EXPR) { /* have to separate out and expr into different restrict infos */ ListCell *lc_and; BoolExpr *bool_expr = castNode(BoolExpr, pushed_down); foreach (lc_and, bool_expr->args) { compressed_rel->baserestrictinfo = lappend(compressed_rel->baserestrictinfo, make_simple_restrictinfo(root, lfirst(lc_and))); } } else compressed_rel->baserestrictinfo = lappend(compressed_rel->baserestrictinfo, make_simple_restrictinfo(root, (Expr *) pushed_down)); } /* * We need to check the restriction clause on the decompress node if the clause can't be * pushed down or needs re-checking. */ if (!clause_context.can_pushdown || clause_context.needs_recheck || chunk_partial) { decompress_clauses = lappend(decompress_clauses, ri); } } chunk_rel->baserestrictinfo = decompress_clauses; } static OpExpr * make_segment_meta_opexpr(QualPushdownContext *context, Oid opno, AttrNumber meta_column_attno, Var *uncompressed_var, Expr *compare_to_expr, StrategyNumber strategy) { Var *meta_var = makeVar(context->compressed_rel->relid, meta_column_attno, uncompressed_var->vartype, -1, InvalidOid, 0); return (OpExpr *) make_opclause(opno, BOOLOID, false, (Expr *) meta_var, copyObject(compare_to_expr), InvalidOid, uncompressed_var->varcollid); } static void expr_fetch_minmax_metadata(QualPushdownContext *context, Expr *expr, AttrNumber *min_attno, AttrNumber *max_attno) { *min_attno = InvalidAttrNumber; *max_attno = InvalidAttrNumber; if (!IsA(expr, Var)) return; Var *var = castNode(Var, expr); /* * Not on the chunk we expect. This doesn't really happen because we don't * push down the join quals, only the baserestrictinfo. */ if ((Index) var->varno != context->chunk_rel->relid) return; /* ignore system attributes or whole row references */ if (var->varattno <= 0) return; *min_attno = compressed_column_metadata_attno(context->settings, context->chunk_rte->relid, var->varattno, context->compressed_rte->relid, "min"); *max_attno = compressed_column_metadata_attno(context->settings, context->chunk_rte->relid, var->varattno, context->compressed_rte->relid, "max"); } static void * pushdown_op_to_segment_meta_min_max(QualPushdownContext *context, OpExpr *orig_opexpr) { /* * This always requires rechecking the decompressed data. */ context->needs_recheck = true; List *expr_args = orig_opexpr->args; Assert(list_length(expr_args) == 2); Expr *orig_leftop = linitial(expr_args); Expr *orig_rightop = lsecond(expr_args); if (IsA(orig_leftop, RelabelType)) orig_leftop = ((RelabelType *) orig_leftop)->arg; if (IsA(orig_rightop, RelabelType)) orig_rightop = ((RelabelType *) orig_rightop)->arg; /* Find the side that has var with segment meta set expr to the other side */ Oid op_oid = orig_opexpr->opno; AttrNumber min_attno; AttrNumber max_attno; expr_fetch_minmax_metadata(context, orig_leftop, &min_attno, &max_attno); if (min_attno == InvalidAttrNumber || max_attno == InvalidAttrNumber) { /* No metadata for the left operand, try to commute the operator. */ op_oid = get_commutator(op_oid); Expr *tmp = orig_leftop; orig_leftop = orig_rightop; orig_rightop = tmp; expr_fetch_minmax_metadata(context, orig_leftop, &min_attno, &max_attno); } if (min_attno == InvalidAttrNumber || max_attno == InvalidAttrNumber) { /* No metadata for either operand. */ context->can_pushdown = false; return orig_opexpr; } Var *var_with_segment_meta = castNode(Var, orig_leftop); /* May be able to allow non-strict operations as well. * Next steps: Think through edge cases, either allow and write tests or figure out why we must * block strict operations */ if (!OidIsValid(op_oid) || !op_strict(op_oid)) { context->can_pushdown = false; return orig_opexpr; } /* If the collation to be used by the OP doesn't match the column's collation do not push down * as the materialized min/max value do not match the semantics of what we need here */ Oid op_collation = orig_opexpr->inputcollid; if (var_with_segment_meta->varcollid != op_collation) { context->can_pushdown = false; return orig_opexpr; } TypeCacheEntry *tce = lookup_type_cache(var_with_segment_meta->vartype, TYPECACHE_BTREE_OPFAMILY); const int strategy = get_op_opfamily_strategy(op_oid, tce->btree_opf); if (strategy == InvalidStrategy) { context->can_pushdown = false; return orig_opexpr; } /* * Check if the righthand expression is safe to push down. We cannot combine * it with the original operator if there can be false negatives. */ QualPushdownContext tmp_context = copy_context(context); Expr *pushed_down_rightop = (Expr *) qual_pushdown_mutator((Node *) orig_rightop, &tmp_context); if (!tmp_context.can_pushdown || tmp_context.needs_recheck) { context->can_pushdown = false; return orig_opexpr; } Assert(pushed_down_rightop != NULL); const Oid expr_type_id = exprType((Node *) pushed_down_rightop); switch (strategy) { case BTEqualStrategyNumber: { /* var = expr implies min < expr and max > expr */ Oid opno_le = get_opfamily_member(tce->btree_opf, tce->type_id, expr_type_id, BTLessEqualStrategyNumber); Oid opno_ge = get_opfamily_member(tce->btree_opf, tce->type_id, expr_type_id, BTGreaterEqualStrategyNumber); if (!OidIsValid(opno_le) || !OidIsValid(opno_ge)) { /* * Shouldn't be possible if we managed to create the min/max * sparse index, but defend against catalog corruption. */ context->can_pushdown = false; return orig_opexpr; } return make_andclause( list_make2(make_segment_meta_opexpr(context, opno_le, min_attno, var_with_segment_meta, pushed_down_rightop, BTLessEqualStrategyNumber), make_segment_meta_opexpr(context, opno_ge, max_attno, var_with_segment_meta, pushed_down_rightop, BTGreaterEqualStrategyNumber))); } case BTLessStrategyNumber: case BTLessEqualStrategyNumber: /* var < expr implies min < expr */ { Oid opno = get_opfamily_member(tce->btree_opf, tce->type_id, expr_type_id, strategy); if (!OidIsValid(opno)) { /* * Shouldn't be possible if we managed to create the min/max * sparse index, but defend against catalog corruption. */ context->can_pushdown = false; return orig_opexpr; } return (Expr *) make_segment_meta_opexpr(context, opno, min_attno, var_with_segment_meta, pushed_down_rightop, strategy); } case BTGreaterStrategyNumber: case BTGreaterEqualStrategyNumber: /* var > expr implies max > expr */ { Oid opno = get_opfamily_member(tce->btree_opf, tce->type_id, expr_type_id, strategy); if (!OidIsValid(opno)) { /* * Shouldn't be possible if we managed to create the min/max * sparse index, but defend against catalog corruption. */ context->can_pushdown = false; return orig_opexpr; } return (Expr *) make_segment_meta_opexpr(context, opno, max_attno, var_with_segment_meta, pushed_down_rightop, strategy); } default: context->can_pushdown = false; return orig_opexpr; } } static void expr_fetch_bloom1_metadata(QualPushdownContext *context, Expr *expr, AttrNumber *bloom1_attno) { *bloom1_attno = InvalidAttrNumber; if (!IsA(expr, Var)) return; Var *var = castNode(Var, expr); /* * Not on the chunk we expect. This doesn't really happen because we don't * push down the join quals, only the baserestrictinfo. */ if ((Index) var->varno != context->chunk_rel->relid) return; /* ignore system attributes or whole row references */ if (var->varattno <= 0) return; *bloom1_attno = compressed_column_metadata_attno(context->settings, context->chunk_rte->relid, var->varattno, context->compressed_rte->relid, "bloom1"); } static void * pushdown_op_to_segment_meta_bloom1(QualPushdownContext *context, OpExpr *orig_opexpr) { /* * This always requires rechecking the decompressed data. */ context->needs_recheck = true; List *expr_args = orig_opexpr->args; Assert(list_length(expr_args) == 2); Expr *orig_leftop = linitial(expr_args); Expr *orig_rightop = lsecond(expr_args); if (IsA(orig_leftop, RelabelType)) orig_leftop = ((RelabelType *) orig_leftop)->arg; if (IsA(orig_rightop, RelabelType)) orig_rightop = ((RelabelType *) orig_rightop)->arg; /* Find the side that has var with segment meta set expr to the other side */ Oid op_oid = orig_opexpr->opno; AttrNumber bloom1_attno = InvalidAttrNumber; expr_fetch_bloom1_metadata(context, orig_leftop, &bloom1_attno); if (bloom1_attno == InvalidAttrNumber) { /* No metadata for the left operand, try to commute the operator. */ op_oid = get_commutator(op_oid); Expr *tmp = orig_leftop; orig_leftop = orig_rightop; orig_rightop = tmp; expr_fetch_bloom1_metadata(context, orig_leftop, &bloom1_attno); } if (bloom1_attno == InvalidAttrNumber) { /* No metadata for either operand. */ context->can_pushdown = false; return orig_opexpr; } Var *var_with_segment_meta = castNode(Var, orig_leftop); /* * Play it safe and don't push down if the operator collation doesn't match * the column collation. */ Oid op_collation = orig_opexpr->inputcollid; if (var_with_segment_meta->varcollid != op_collation) { context->can_pushdown = false; return orig_opexpr; } /* * We cannot use bloom filters for non-deterministic collations. */ if (OidIsValid(op_collation) && !get_collation_isdeterministic(op_collation)) { context->can_pushdown = false; return orig_opexpr; } /* * We only support hashable equality operators. */ TypeCacheEntry *tce = lookup_type_cache(var_with_segment_meta->vartype, TYPECACHE_HASH_OPFAMILY); const int strategy = get_op_opfamily_strategy(op_oid, tce->hash_opf); if (strategy != HTEqualStrategyNumber) { context->can_pushdown = false; return orig_opexpr; } /* * The hash equality operators are supposed to be strict. */ Assert(op_strict(op_oid)); /* * Check if the righthand expression is safe to push down. We cannot combine * it with the original operator if there can be false negatives. */ QualPushdownContext tmp_context = copy_context(context); Expr *pushed_down_rightop = (Expr *) qual_pushdown_mutator((Node *) orig_rightop, &tmp_context); if (!tmp_context.can_pushdown || tmp_context.needs_recheck) { context->can_pushdown = false; return orig_opexpr; } Assert(pushed_down_rightop != NULL); /* * var = expr implies bloom1_contains(var_bloom, expr). */ Var *bloom_var = makeVar(context->compressed_rel->relid, bloom1_attno, ts_custom_type_cache_get(CUSTOM_TYPE_BLOOM1)->type_oid, -1, InvalidOid, 0); Oid func = LookupFuncName(list_make2(makeString("_timescaledb_functions"), makeString("bloom1_contains")), /* nargs = */ -1, /* argtypes = */ (void *) -1, /* missing_ok = */ false); return (Expr *) makeFuncExpr(func, BOOLOID, list_make2(bloom_var, pushed_down_rightop), /* funccollid = */ InvalidOid, /* inputcollid = */ InvalidOid, COERCE_EXPLICIT_CALL); } static bool contain_volatile_functions_checker(Oid func_id, void *context) { return (func_volatile(func_id) == PROVOLATILE_VOLATILE); } /* * Push down the given expression node. * * This is used as a mutator for expression_tree_mutator(). * * We return the original node if we cannot push it down, to be consistent with * the expression_tree_mutator behavior. The caller must check * context.can_pushdown. */ static Node * qual_pushdown_mutator(Node *orig_node, QualPushdownContext *context) { if (orig_node == NULL) { /* * An expression node can have a NULL field and the mutator will be * still called for it, so we have to handle this. */ return NULL; } if (!context->can_pushdown) { /* * Stop early if we already know we can't push down this filter. */ return orig_node; } if (check_functions_in_node(orig_node, contain_volatile_functions_checker, /* context = */ NULL)) { /* pushdown is not safe for volatile expressions */ context->can_pushdown = false; return orig_node; } switch (nodeTag(orig_node)) { case T_Var: { Var *var = castNode(Var, orig_node); Assert((Index) var->varno == context->chunk_rel->relid); if (var->varattno <= 0) { /* Can't do this for system columns such as whole-row var. */ context->can_pushdown = false; return orig_node; } char *attname = get_attname(context->chunk_rte->relid, var->varattno, false); /* we can only push down quals for segmentby columns */ if (!ts_array_is_member(context->settings->fd.segmentby, attname)) { context->can_pushdown = false; return orig_node; } var = copyObject(var); var->varno = context->compressed_rel->relid; var->varattno = get_attnum(context->compressed_rte->relid, attname); return (Node *) var; } case T_OpExpr: { OpExpr *opexpr = (OpExpr *) orig_node; /* * It might be possible to push down the OpExpr as is, if it * references only the segmentby columns. Check this case first. * * Note that we can't push down the entire operator if we pushed * down both sides inexactly, i.e. they require recheck. This means * we can have false positives there, and combining false positives * with the original operator could lead to false negatives, which * would be a bug. Consider for example (x = 1) = (y = 1) in case * where both sides are false, but there's a false posistive for the * pushed down version of the left side but not the right side. */ QualPushdownContext tmp_context = copy_context(context); void *pushed_down = expression_tree_mutator((Node *) orig_node, qual_pushdown_mutator, &tmp_context); if (tmp_context.can_pushdown && !tmp_context.needs_recheck) { return pushed_down; } if (opexpr->opresulttype != BOOLOID) { /* * The following pushdown options only support operators that * return bool. */ context->can_pushdown = false; return orig_node; } if (list_length(opexpr->args) != 2) { /* * The following pushdown options only support operators with * two operands. */ context->can_pushdown = false; return orig_node; } /* * Try bloom1 sparse index. */ if (ts_guc_enable_sparse_index_bloom) { tmp_context = copy_context(context); pushed_down = pushdown_op_to_segment_meta_bloom1(&tmp_context, opexpr); if (tmp_context.can_pushdown) { context->needs_recheck |= tmp_context.needs_recheck; return pushed_down; } } /* * Try minmax sparse index. */ tmp_context = copy_context(context); pushed_down = pushdown_op_to_segment_meta_min_max(&tmp_context, opexpr); if (tmp_context.can_pushdown) { context->needs_recheck |= tmp_context.needs_recheck; return pushed_down; } /* * No other options to push down the OpExpr. */ context->can_pushdown = false; return orig_node; } case T_ScalarArrayOpExpr: { /* * It can be possible to push down the scalar array operation as is, * if it references only the segmentby columns. Check this case * first. * * See the comment for OpExpr about needs_recheck handling. */ QualPushdownContext tmp_context = copy_context(context); void *pushed_down = expression_tree_mutator((Node *) orig_node, qual_pushdown_mutator, &tmp_context); if (tmp_context.can_pushdown && !tmp_context.needs_recheck) { return pushed_down; } /* * No other ways to push it down, so consider it failed. */ context->can_pushdown = false; return orig_node; } /* * These nodes do not influence the pushdown by themselves, so we * recurse. */ case T_BoolExpr: case T_FuncExpr: case T_CoerceViaIO: case T_RelabelType: case T_List: case T_Const: case T_NullTest: case T_Param: case T_SQLValueFunction: case T_CaseExpr: case T_CaseWhen: case T_ArrayExpr: { Node *pushed_down = expression_tree_mutator((Node *) orig_node, qual_pushdown_mutator, context); return pushed_down; } /* * We don't know how to work with other nodes. */ default: context->can_pushdown = false; return orig_node; } } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/qual_pushdown.h��������������������������������������0000664�0000000�0000000�00000000567�15100345067�0024452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> void pushdown_quals(PlannerInfo *root, CompressionSettings *settings, RelOptInfo *chunk_rel, RelOptInfo *compressed_rel, bool chunk_partial); �����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/vector_dict.h����������������������������������������0000664�0000000�0000000�00000002763�15100345067�0024066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "compression/arrow_c_data_interface.h" /* * When we have a dictionary-encoded Arrow Array, and have run a predicate on * the dictionary, this function is used to translate the dictionary predicate * result to the final predicate result. */ static void translate_bitmap_from_dictionary(const ArrowArray *arrow, const uint64 *dict_result, uint64 *restrict final_result) { Assert(arrow->dictionary != NULL); const size_t n = arrow->length; const int16 *indices = (int16 *) arrow->buffers[1]; for (size_t outer = 0; outer < n / 64; outer++) { uint64 word = 0; for (size_t inner = 0; inner < 64; inner++) { const size_t row = (outer * 64) + inner; const size_t bit_index = inner; #define INNER_LOOP \ const int16 index = indices[row]; \ const bool valid = arrow_row_is_valid(dict_result, index); \ word |= ((uint64) valid) << bit_index; INNER_LOOP } final_result[outer] &= word; } if (n % 64) { uint64 word = 0; for (size_t row = (n / 64) * 64; row < n; row++) { const size_t bit_index = row % 64; INNER_LOOP } final_result[n / 64] &= word; } #undef INNER_LOOP } �������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/vector_predicates.c����������������������������������0000664�0000000�0000000�00000015071�15100345067�0025255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Functions for working with vectorized predicates. */ #include <postgres.h> #include <mb/pg_wchar.h> #include <utils/date.h> #include <utils/fmgroids.h> #include <utils/uuid.h> #include "compression/arrow_c_data_interface.h" #include "vector_predicates.h" #include "compat/compat.h" #include "compression/compression.h" #include "debug_assert.h" /* * We include all implementations of vector-const predicates here. No separate * declarations for them to reduce the amount of macro template magic. */ #include "pred_vector_const_arithmetic_all.c" #include "pred_text.h" /* * Look up the vectorized implementation for a Postgres predicate, specified by * its Oid in pg_proc. Note that this Oid is different from the opcode. */ VectorPredicate * get_vector_const_predicate(Oid pg_predicate) { switch (pg_predicate) { #define GENERATE_DISPATCH_TABLE #include "pred_vector_const_arithmetic_all.c" #undef GENERATE_DISPATCH_TABLE case F_TEXTEQ: return vector_const_texteq; case F_TEXTNE: return vector_const_textne; case F_BOOLEQ: return vector_booleq; case F_UUID_EQ: return vector_uuideq; case F_UUID_NE: return vector_uuidne; default: /* * More checks below, this branch is to placate the static analyzers. */ break; } if (GetDatabaseEncoding() == PG_UTF8) { /* We have some simple LIKE vectorization for case-sensitive UTF8. */ switch (pg_predicate) { case F_TEXTLIKE: return vector_const_textlike_utf8; case F_TEXTNLIKE: return vector_const_textnlike_utf8; default: /* * This branch is to placate the static analyzers. */ break; } } return NULL; } void vector_nulltest(const ArrowArray *arrow, int test_type, uint64 *restrict result) { const bool should_be_null = test_type == IS_NULL; const uint16 bitmap_words = (arrow->length + 63) / 64; const uint64 *validity = (const uint64 *) arrow->buffers[0]; for (uint16 i = 0; i < bitmap_words; i++) { const uint64 validity_word = validity != NULL ? validity[i] : ~0ULL; if (should_be_null) { result[i] &= ~validity_word; } else { result[i] &= validity_word; } } } void vector_booleq(const ArrowArray *arrow, Datum arg, uint64 *restrict result) { bool check_val = DatumGetBool(arg); if (check_val) { vector_booleantest(arrow, IS_TRUE, result); } else { vector_booleantest(arrow, IS_FALSE, result); } } typedef union UUIDBuffer { uint64 components[2]; pg_uuid_t uuid; #ifdef HAVE_INT128 int128 i128; #endif } UUIDBuffer; #define VECTOR_CTYPE UUIDBuffer #define CONST_CTYPE UUIDBuffer #define CONST_CONVERSION(X) *((UUIDBuffer *) DatumGetPointer(X)) #define PREDICATE_NAME NE #ifdef HAVE_INT128 #define PREDICATE_EXPRESSION(X, Y) (((X).i128) != ((Y).i128)) #else #define PREDICATE_EXPRESSION(X, Y) \ ((X.components[0]) != (Y.components[0]) || (X.components[1]) != (Y.components[1])) #endif #include "pred_vector_const_arithmetic_single.c" void vector_uuidne(const ArrowArray *arrow, Datum arg, uint64 *restrict result) { pg_uuid_t *uuid = DatumGetUUIDP(arg); /* * No assumptions are being made about the alignment of the argument UUID, * so we copy the values to a local variable. This is because uuid is defined as typalign 'c'. */ UUIDBuffer arg_values; memcpy(&arg_values.uuid, uuid, sizeof(pg_uuid_t)); predicate_NE_UUIDBuffer_vector_UUIDBuffer_const(arrow, PointerGetDatum(&arg_values), result); } #undef VECTOR_CTYPE #undef CONST_CTYPE #undef CONST_CONVERSION #undef PG_PREDICATE #define VECTOR_CTYPE UUIDBuffer #define CONST_CTYPE UUIDBuffer #define CONST_CONVERSION(X) *((UUIDBuffer *) DatumGetPointer(X)) #define PREDICATE_NAME EQ #ifdef HAVE_INT128 #define PREDICATE_EXPRESSION(X, Y) (((X).i128) == ((Y).i128)) #else #define PREDICATE_EXPRESSION(X, Y) \ ((X.components[0]) == (Y.components[0]) && (X.components[1]) == (Y.components[1])) #endif #include "pred_vector_const_arithmetic_single.c" void vector_uuideq(const ArrowArray *arrow, Datum arg, uint64 *restrict result) { pg_uuid_t *uuid = DatumGetUUIDP(arg); /* * No assumptions are being made about the alignment of the argument UUID, * so we copy the values to a local variable. This is because uuid is defined as typalign 'c'. */ UUIDBuffer arg_values; memcpy(&arg_values.uuid, uuid, sizeof(pg_uuid_t)); predicate_EQ_UUIDBuffer_vector_UUIDBuffer_const(arrow, PointerGetDatum(&arg_values), result); } #undef VECTOR_CTYPE #undef CONST_CTYPE #undef CONST_CONVERSION #undef PG_PREDICATE void vector_booleantest(const ArrowArray *arrow, int test_type, uint64 *restrict result) { const uint16 bitmap_words = (arrow->length + 63) / 64; const uint64 *restrict validity = (const uint64 *) arrow->buffers[0]; const uint64 *restrict values = (const uint64 *) arrow->buffers[1]; switch (test_type) { case IS_TRUE: { if (validity) { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= validity[i] & values[i]; } } else { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= values[i]; } } break; } case IS_NOT_TRUE: { if (validity) { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= (~validity[i] | ~values[i]); } } else { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= ~values[i]; } } break; } case IS_FALSE: { if (validity) { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= validity[i] & ~values[i]; } } else { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= ~values[i]; } } break; } case IS_NOT_FALSE: { if (validity) { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= (~validity[i] | values[i]); } } else { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= values[i]; } } break; } case IS_UNKNOWN: { if (validity) { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= ~validity[i]; } } else { /* No validity, so all rows are valid and all result rows are filtered out. */ memset(result, 0, bitmap_words * sizeof(uint64)); } break; } case IS_NOT_UNKNOWN: { if (validity) { for (uint16 i = 0; i < bitmap_words; i++) { result[i] &= validity[i]; } } break; } default: Assert(false); break; } } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/vector_predicates.h����������������������������������0000664�0000000�0000000�00000004016�15100345067�0025257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Functions for working with vectorized predicates. */ #pragma once typedef void(VectorPredicate)(const ArrowArray *, Datum, uint64 *restrict); VectorPredicate *get_vector_const_predicate(Oid pg_predicate); void vector_array_predicate(VectorPredicate *vector_const_predicate, bool is_or, const ArrowArray *vector, Datum array, uint64 *restrict final_result); void vector_nulltest(const ArrowArray *arrow, int test_type, uint64 *restrict result); /* this implements the vectorized BooleanTest, where NULLs are handled in a special way: * for example IS_NOT_TRUE(NULL) is true and IS_NOT_FALSE(NULL) is true, plus there are * NULL test types, like IS_UNKNOWN and IS_NOT_UNKNOWN. */ void vector_booleantest(const ArrowArray *arrow, int test_type, uint64 *restrict result); void vector_booleq(const ArrowArray *arrow, Datum arg, uint64 *restrict result); void vector_uuideq(const ArrowArray *arrow, Datum arg, uint64 *restrict result); void vector_uuidne(const ArrowArray *arrow, Datum arg, uint64 *restrict result); typedef enum BatchQualSummary { AllRowsPass, NoRowsPass, SomeRowsPass } BatchQualSummary; static pg_attribute_always_inline BatchQualSummary get_vector_qual_summary(const uint64 *qual_result, size_t n_rows) { bool any_rows_pass = false; bool all_rows_pass = true; for (size_t i = 0; i < n_rows / 64; i++) { any_rows_pass = any_rows_pass || (qual_result[i] != 0); all_rows_pass = all_rows_pass && (~qual_result[i] == 0); } if (n_rows % 64 != 0) { const uint64 last_word_mask = ~0ULL >> (64 - n_rows % 64); any_rows_pass |= (qual_result[n_rows / 64] & last_word_mask) != 0; all_rows_pass &= ((~qual_result[n_rows / 64]) & last_word_mask) == 0; } Assert(!(all_rows_pass && !any_rows_pass)); if (!any_rows_pass) { return NoRowsPass; } if (all_rows_pass) { return AllRowsPass; } return SomeRowsPass; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/columnar_scan/vector_quals.h���������������������������������������0000664�0000000�0000000�00000003545�15100345067�0024267�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <executor/tuptable.h> #include <nodes/primnodes.h> #include "compression/arrow_c_data_interface.h" #include "vector_predicates.h" /* * VectorQualInfo provides planner time information for extracting * vectorizable quals from regular quals. */ typedef struct VectorQualInfo { /* * The range-table index of the relation to compute vectorized quals * for. */ Index rti; bool reverse; /* * Arrays indexed by uncompressed attno indicating whether an * attribute/column is a vectorizable type and/or a segmentby attribute. * * Note: array lengths are maxattno + 1. */ bool *vector_attrs; bool *segmentby_attrs; /* Max attribute number found in arrays above */ AttrNumber maxattno; } VectorQualInfo; /* * VectorQualState keeps the necessary state needed for the computation of * vectorized filters in scan nodes. */ typedef struct VectorQualState { List *vectorized_quals_constified; uint16 num_results; uint64 *vector_qual_result; MemoryContext per_vector_mcxt; TupleTableSlot *slot; /* * Interface function to be provided by scan node. * * Given a (compressed) tuple/slot, and a column reference (Var), get the * corresponding arrow array. * * Scan-node specific context data can be provided by wrapping this struct * in a larger one. */ const ArrowArray *(*get_arrow_array)(struct VectorQualState *vqstate, Expr *expr, bool *is_default_value); } VectorQualState; extern Node *vector_qual_make(Node *qual, const VectorQualInfo *vqinfo); extern BatchQualSummary vector_qual_compute(VectorQualState *vqstate); extern ArrowArray *make_single_value_arrow(Oid pgtype, Datum datum, bool isnull); �����������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/frozen_chunk_dml/��������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0022103�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/frozen_chunk_dml/CMakeLists.txt������������������������������������0000664�0000000�0000000�00000000244�15100345067�0024643�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Add all *.c to sources in upperlevel directory set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/frozen_chunk_dml.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/frozen_chunk_dml/frozen_chunk_dml.c��������������������������������0000664�0000000�0000000�00000010441�15100345067�0025576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <nodes/extensible.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include "compat/compat.h" #include "chunk.h" #include "frozen_chunk_dml.h" #include "hypertable.h" #include "utils.h" /* * Path, Plan and State node for blocking DML on frozen chunks. */ static Path *frozen_chunk_dml_path_create(Path *subpath, Oid chunk_relid); static Plan *frozen_chunk_dml_plan_create(PlannerInfo *root, RelOptInfo *relopt, CustomPath *best_path, List *tlist, List *clauses, List *custom_plans); static Node *frozen_chunk_dml_state_create(CustomScan *scan); static void frozen_chunk_dml_begin(CustomScanState *node, EState *estate, int eflags); static TupleTableSlot *frozen_chunk_dml_exec(CustomScanState *node); static void frozen_chunk_dml_end(CustomScanState *node); static void frozen_chunk_dml_rescan(CustomScanState *node); static CustomPathMethods frozen_chunk_dml_path_methods = { .CustomName = "FrozenChunkDml", .PlanCustomPath = frozen_chunk_dml_plan_create, }; static CustomScanMethods frozen_chunk_dml_plan_methods = { .CustomName = "FrozenChunkDml", .CreateCustomScanState = frozen_chunk_dml_state_create, }; static CustomExecMethods frozen_chunk_dml_state_methods = { .CustomName = FROZEN_CHUNK_DML_STATE_NAME, .BeginCustomScan = frozen_chunk_dml_begin, .EndCustomScan = frozen_chunk_dml_end, .ExecCustomScan = frozen_chunk_dml_exec, .ReScanCustomScan = frozen_chunk_dml_rescan, }; static void frozen_chunk_dml_begin(CustomScanState *node, EState *estate, int eflags) { CustomScan *cscan = castNode(CustomScan, node->ss.ps.plan); Plan *subplan = linitial(cscan->custom_plans); node->custom_ps = list_make1(ExecInitNode(subplan, estate, eflags)); } /* * nothing to reset for rescan in dml blocker */ static void frozen_chunk_dml_rescan(CustomScanState *node) { } /* we cannot update/delete rows if we have a frozen chunk. so * throw an error. Note this subplan will return 0 tuples as the chunk is empty * and all rows are saved in the compressed chunk. */ static TupleTableSlot * frozen_chunk_dml_exec(CustomScanState *node) { FrozenChunkDmlState *state = (FrozenChunkDmlState *) node; Oid chunk_relid = state->chunk_relid; ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("cannot update/delete rows from chunk \"%s\" as it is frozen", get_rel_name(chunk_relid)))); return NULL; } static void frozen_chunk_dml_end(CustomScanState *node) { PlanState *substate = linitial(node->custom_ps); ExecEndNode(substate); } static Path * frozen_chunk_dml_path_create(Path *subpath, Oid chunk_relid) { FrozenChunkDmlPath *path = (FrozenChunkDmlPath *) palloc0(sizeof(FrozenChunkDmlPath)); memcpy(&path->cpath.path, subpath, sizeof(Path)); path->cpath.path.type = T_CustomPath; path->cpath.path.pathtype = T_CustomScan; path->cpath.path.parent = subpath->parent; path->cpath.path.pathtarget = subpath->pathtarget; path->cpath.methods = &frozen_chunk_dml_path_methods; path->cpath.custom_paths = list_make1(subpath); path->chunk_relid = chunk_relid; return &path->cpath.path; } static Plan * frozen_chunk_dml_plan_create(PlannerInfo *root, RelOptInfo *relopt, CustomPath *best_path, List *tlist, List *clauses, List *custom_plans) { FrozenChunkDmlPath *cdpath = (FrozenChunkDmlPath *) best_path; CustomScan *cscan = makeNode(CustomScan); Assert(list_length(custom_plans) == 1); cscan->methods = &frozen_chunk_dml_plan_methods; cscan->custom_plans = custom_plans; cscan->scan.scanrelid = relopt->relid; cscan->scan.plan.targetlist = tlist; cscan->custom_scan_tlist = NIL; cscan->custom_private = list_make1_oid(cdpath->chunk_relid); return &cscan->scan.plan; } static Node * frozen_chunk_dml_state_create(CustomScan *scan) { FrozenChunkDmlState *state; state = (FrozenChunkDmlState *) newNode(sizeof(FrozenChunkDmlState), T_CustomScanState); state->chunk_relid = linitial_oid(scan->custom_private); state->cscan_state.methods = &frozen_chunk_dml_state_methods; return (Node *) state; } Path * frozen_chunk_dml_generate_path(Path *subpath, Chunk *chunk) { return frozen_chunk_dml_path_create(subpath, chunk->table_id); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/frozen_chunk_dml/frozen_chunk_dml.h��������������������������������0000664�0000000�0000000�00000001145�15100345067�0025604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/execnodes.h> #include "hypertable.h" typedef struct FrozenChunkDmlPath { CustomPath cpath; Oid chunk_relid; } FrozenChunkDmlPath; typedef struct FrozenChunkDmlState { CustomScanState cscan_state; Oid chunk_relid; } FrozenChunkDmlState; Path *frozen_chunk_dml_generate_path(Path *subpath, Chunk *chunk); #define FROZEN_CHUNK_DML_STATE_NAME "FrozenChunkDmlState" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/�����������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020172�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/CMakeLists.txt���������������������������������������������0000664�0000000�0000000�00000000453�15100345067�0022734�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/gapfill_functions.c ${CMAKE_CURRENT_SOURCE_DIR}/gapfill_plan.c ${CMAKE_CURRENT_SOURCE_DIR}/gapfill_exec.c ${CMAKE_CURRENT_SOURCE_DIR}/locf.c ${CMAKE_CURRENT_SOURCE_DIR}/interpolate.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/README.md��������������������������������������������������0000664�0000000�0000000�00000003205�15100345067�0021451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# Gap filling This module implements first level support for gap fill queries, including support for LOCF (last observation carried forward) and interpolation, without requiring to join against `generate_series`. This makes it easier to join timeseries with different or irregular sampling intervals. ## Design This introduces a new gapfill customscan node that is inserted above the aggregation node of a query. The node will inject tuples for time intervals without data. The node requires data to be sorted by time, but it will inject sort nodes in the plan to ensure data is sorted correctly if the query order does not match the required order. The time_bucket_gapfill functions only serves to trigger injecting the gapfill customscan node in the planner all the tuple injecting happens in the gapfill node and time_bucket_gapfill just calls plain time_bucket. The locf and interpolate function calls serve as markers in the plan to trigger locf or interpolate behaviour. In the targetlist of the gapfill node those functions will be toplevel function calls. The gapfill state transitions are described in gapfill_internal.h ## Usage Gapfill query ``` SELECT time_bucket_gapfill(1,time,0,6) AS time, min(value) AS value FROM (values (0,1),(5,6)) v(time,value) GROUP BY 1 ORDER BY 1; ``` Gapfill query with LOCF ``` SELECT time_bucket_gapfill(1,time,0,6) AS time, locf(min(value)) AS value FROM (values (0,1),(5,6)) v(time,value) GROUP BY 1 ORDER BY 1; ``` Gapfill query with interpolation ``` SELECT time_bucket_gapfill(1,time,0,6) AS time, interpolate(min(value)) AS value FROM (values (0,1),(5,6)) v(time,value) GROUP BY 1 ORDER BY 1; ``` �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/gapfill.h��������������������������������������������������0000664�0000000�0000000�00000001324�15100345067�0021761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pathnodes.h> #include <nodes/primnodes.h> #define GAPFILL_FUNCTION "time_bucket_gapfill" #define GAPFILL_LOCF_FUNCTION "locf" #define GAPFILL_INTERPOLATE_FUNCTION "interpolate" void plan_add_gapfill(PlannerInfo *root, RelOptInfo *group_rel); void gapfill_adjust_window_targetlist(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel); typedef struct GapFillPath { CustomPath cpath; FuncExpr *func; /* time_bucket_gapfill function call */ } GapFillPath; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/gapfill_exec.c���������������������������������������������0000664�0000000�0000000�00000116170�15100345067�0022766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/attnum.h> #include <access/htup_details.h> #include <c.h> #include <catalog/pg_cast.h> #include <catalog/pg_collation.h> #include <catalog/pg_type.h> #include <miscadmin.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/primnodes.h> #include <optimizer/clauses.h> #include <optimizer/optimizer.h> #include <utils/builtins.h> #include <utils/date.h> #include <utils/datum.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/syscache.h> #include <utils/timestamp.h> #include <utils/typcache.h> #include <compat/compat.h> #include "gapfill.h" #include "gapfill_internal.h" #include "interpolate.h" #include "locf.h" #include "time_bucket.h" #include <annotations.h> typedef enum GapFillBoundary { GAPFILL_START, GAPFILL_END, } GapFillBoundary; typedef union GapFillColumnStateUnion { GapFillColumnState *base; GapFillGroupColumnState *group; GapFillInterpolateColumnState *interpolate; GapFillLocfColumnState *locf; } GapFillColumnStateUnion; #define foreach_column(column, index, state) \ Assert((state)->ncolumns > 0); \ for ((index) = 0, (column) = (state)->columns[index]; \ (index) < (state)->ncolumns && ((column) = (state)->columns[index], true); \ (index)++) static void gapfill_begin(CustomScanState *node, EState *estate, int eflags); static void gapfill_end(CustomScanState *node); static void gapfill_rescan(CustomScanState *node); static TupleTableSlot *gapfill_exec(CustomScanState *node); static void gapfill_state_reset_group(GapFillState *state, TupleTableSlot *slot); static TupleTableSlot *gapfill_state_gaptuple_create(GapFillState *state, int64 time); static bool gapfill_state_is_new_group(GapFillState *state, TupleTableSlot *slot); static void gapfill_state_set_next(GapFillState *state, TupleTableSlot *subslot); static TupleTableSlot *gapfill_state_return_subplan_slot(GapFillState *state); static TupleTableSlot *gapfill_fetch_next_tuple(GapFillState *state); static void gapfill_state_initialize_columns(GapFillState *state, List *exec_tlist); static GapFillColumnState *gapfill_column_state_create(GapFillColumnType ctype, Oid typeid); static bool gapfill_is_group_column(GapFillState *state, TargetEntry *tle); static TargetEntry *gapfill_get_fixed_agg_expr_column(GapFillState *state, TargetEntry *tle); static CustomExecMethods gapfill_state_methods = { .BeginCustomScan = gapfill_begin, .ExecCustomScan = gapfill_exec, .EndCustomScan = gapfill_end, .ReScanCustomScan = gapfill_rescan, }; /* * convert Datum to int64 according to type * internally we store all times as int64 in the * same format postgres does */ int64 gapfill_datum_get_internal(Datum value, Oid type) { switch (type) { case INT2OID: return DatumGetInt16(value); case DATEOID: case INT4OID: return DatumGetInt32(value); case TIMESTAMPOID: case TIMESTAMPTZOID: case INT8OID: return DatumGetInt64(value); default: /* * should never happen since time_bucket_gapfill is not defined * for other datatypes */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported datatype for time_bucket_gapfill: %s", format_type_be(type)))); pg_unreachable(); break; } } /* * convert int64 to Datum according to type * internally we store all times as int64 in the * same format postgres does */ static inline Datum gapfill_internal_get_datum(int64 value, Oid type) { switch (type) { case INT2OID: return Int16GetDatum(value); case DATEOID: case INT4OID: return Int32GetDatum(value); case TIMESTAMPOID: case TIMESTAMPTZOID: case INT8OID: return Int64GetDatum(value); default: /* * should never happen since time_bucket_gapfill is not defined * for other datatypes */ Assert(false); return Int64GetDatum(0); } } static Expr * get_start_arg(GapFillState *state) { if (!state->have_timezone) return lthird(state->args); else return lfourth(state->args); } static Expr * get_finish_arg(GapFillState *state) { if (!state->have_timezone) return lfourth(state->args); else return lfifth(state->args); } static Expr * get_timezone_arg(GapFillState *state) { Assert(state->have_timezone); return lthird(state->args); } static inline int64 gapfill_period_get_internal(Oid timetype, Oid argtype, Datum arg, Interval **interval) { switch (timetype) { case DATEOID: case TIMESTAMPOID: case TIMESTAMPTZOID: Assert(INTERVALOID == argtype); Interval *interval_arg = DatumGetIntervalP(arg); if (interval_arg->time < 0 || interval_arg->day < 0 || interval_arg->month < 0 || interval_arg->time + interval_arg->day + interval_arg->month == 0) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: bucket_width must be " "greater than 0"))); } *interval = interval_arg; return 0; break; case INT2OID: Assert(INT2OID == argtype); return DatumGetInt16(arg); case INT4OID: Assert(INT4OID == argtype); return DatumGetInt32(arg); case INT8OID: Assert(INT8OID == argtype); return DatumGetInt64(arg); default: /* * should never happen since time_bucket_gapfill is not defined * for other datatypes */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported datatype for time_bucket_gapfill: %s", format_type_be(timetype)))); pg_unreachable(); break; } } /* * Create a GapFill node from this plan. This is the full execution * state that replaces the plan node as the plan moves from planning to * execution. */ Node * gapfill_state_create(CustomScan *cscan) { GapFillState *state = (GapFillState *) newNode(sizeof(GapFillState), T_CustomScanState); state->csstate.methods = &gapfill_state_methods; state->subplan = linitial(cscan->custom_plans); state->args = lfourth(cscan->custom_private); state->have_timezone = list_length(state->args) == 5; return (Node *) state; } static bool is_const_null(Expr *expr) { return IsA(expr, Const) && castNode(Const, expr)->constisnull; } /* * lookup cast func oid in pg_cast * * throws an error if no cast can be found */ static Oid get_cast_func(Oid source, Oid target) { Oid result = InvalidOid; HeapTuple casttup; casttup = SearchSysCache2(CASTSOURCETARGET, ObjectIdGetDatum(source), ObjectIdGetDatum(target)); if (HeapTupleIsValid(casttup)) { Form_pg_cast castform = (Form_pg_cast) GETSTRUCT(casttup); result = castform->castfunc; ReleaseSysCache(casttup); } if (!OidIsValid(result)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("could not find cast from %s to %s", format_type_be(source), format_type_be(target)))); return result; } /* * returns true if v1 and v2 reference the same object */ static bool var_equal(Var *v1, Var *v2) { return v1->varno == v2->varno && v1->varattno == v2->varattno && v1->vartype == v2->vartype; } static bool is_simple_expr_walker(Node *node, void *context) { if (node == NULL) return false; /* * since expression_tree_walker does early exit on true * logic is reverted and return value of true means expression * is not simple, this is reverted in parent */ switch (nodeTag(node)) { /* * whitelist expression types we deem safe to execute in a * separate expression context */ case T_Const: case T_FuncExpr: case T_NamedArgExpr: case T_OpExpr: case T_DistinctExpr: case T_NullIfExpr: case T_ScalarArrayOpExpr: case T_BoolExpr: case T_CoerceViaIO: case T_CaseExpr: case T_CaseWhen: break; case T_Param: if (castNode(Param, node)->paramkind != PARAM_EXTERN) return true; break; default: return true; } return expression_tree_walker(node, is_simple_expr_walker, context); } /* * check if expression is simple expression and contains only simple * subexpressions */ static bool is_simple_expr(Expr *node) { /* * since expression_tree_walker does early exit on true and we use that to * skip processing on first non-simple expression we invert return value * from expression_tree_walker here */ return !is_simple_expr_walker((Node *) node, NULL); } /* * align a value with the bucket boundary * even though we use int64 as our internal representation we cannot call * ts_int64_bucket here because int variants of time_bucket align differently * then non-int variants because the bucket start is on monday for the latter */ static int64 align_with_time_bucket(GapFillState *state, Expr *expr) { CustomScan *cscan = castNode(CustomScan, state->csstate.ss.ps.plan); FuncExpr *time_bucket = copyObject(linitial(cscan->custom_private)); Datum value; bool isnull; if (!is_simple_expr(expr)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg( "invalid time_bucket_gapfill argument: start must be a simple expression"))); if (state->have_timezone) { if (IsA(get_timezone_arg(state), Const) && castNode(Const, get_timezone_arg(state))->constisnull) { ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: timezone cannot be NULL"))); } time_bucket->args = list_make3(linitial(time_bucket->args), expr, lthird(time_bucket->args)); } else { time_bucket->args = list_make2(linitial(time_bucket->args), expr); } value = gapfill_exec_expr(state, state->scanslot, (Expr *) time_bucket, &isnull); /* start expression must not evaluate to NULL */ if (isnull) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: start cannot be NULL"), errhint("Specify start and finish as arguments or in the WHERE clause."))); return gapfill_datum_get_internal(value, state->gapfill_typid); } static int64 get_boundary_expr_value(GapFillState *state, GapFillBoundary boundary, Expr *expr) { Datum arg_value; bool isnull; /* * add an explicit cast here if types do not match */ if (exprType((Node *) expr) != state->gapfill_typid) { Oid cast_oid = get_cast_func(exprType((Node *) expr), state->gapfill_typid); expr = (Expr *) makeFuncExpr(cast_oid, state->gapfill_typid, list_make1(expr), InvalidOid, InvalidOid, 0); } arg_value = gapfill_exec_expr(state, state->scanslot, expr, &isnull); if (isnull) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: %s cannot be NULL", boundary == GAPFILL_START ? "start" : "finish"), errhint("Specify start and finish as arguments or in the WHERE clause."))); return gapfill_datum_get_internal(arg_value, state->gapfill_typid); } typedef struct CollectBoundaryContext { List *quals; Var *ts_var; } CollectBoundaryContext; /* * expression references our gapfill time column and could be * a boundary expression, more thorough check is in * infer_gapfill_boundary */ static bool is_boundary_expr(Node *node, CollectBoundaryContext *context) { OpExpr *op; Node *left, *right; if (!IsA(node, OpExpr)) return false; op = castNode(OpExpr, node); if (op->args->length != 2) return false; left = linitial(op->args); right = llast(op->args); /* Var OP Var is not useful here because we are not yet at a point * where we could evaluate them */ if (IsA(left, Var) && IsA(right, Var)) return false; if (IsA(left, Var) && var_equal(castNode(Var, left), context->ts_var)) return true; if (IsA(right, Var) && var_equal(castNode(Var, right), context->ts_var)) return true; return false; } static bool collect_boundary_walker(Node *node, CollectBoundaryContext *context) { Node *quals = NULL; if (node == NULL) return false; if (IsA(node, FromExpr)) { quals = castNode(FromExpr, node)->quals; } else if (IsA(node, JoinExpr)) { JoinExpr *j = castNode(JoinExpr, node); /* don't descend into outer join */ if (IS_OUTER_JOIN(j->jointype)) return false; quals = j->quals; } if (quals) { ListCell *lc; foreach (lc, castNode(List, quals)) { if (is_boundary_expr(lfirst(lc), context)) context->quals = lappend(context->quals, lfirst(lc)); } } return expression_tree_walker(node, collect_boundary_walker, context); } /* * traverse jointree to look for expressions referencing * the time column of our gapfill call */ static List * collect_boundary_expressions(Node *node, Var *ts_var) { CollectBoundaryContext context = { .quals = NIL, .ts_var = ts_var }; collect_boundary_walker(node, &context); return context.quals; } static int64 infer_gapfill_boundary(GapFillState *state, GapFillBoundary boundary) { CustomScan *cscan = castNode(CustomScan, state->csstate.ss.ps.plan); FuncExpr *func = linitial(cscan->custom_private); FromExpr *jt = lthird(cscan->custom_private); ListCell *lc; Var *ts_var; TypeCacheEntry *tce = lookup_type_cache(state->gapfill_typid, TYPECACHE_BTREE_OPFAMILY); int strategy; Oid lefttype, righttype; List *quals; int64 boundary_value = 0; bool boundary_found = false; /* * if the second argument to time_bucket_gapfill is not a column reference * we cannot match WHERE clause to the time column */ if (!IsA(lsecond(func->args), Var)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: ts needs to refer to a single " "column if no start or finish is supplied"), errhint("Specify start and finish as arguments or in the WHERE clause."))); ts_var = castNode(Var, lsecond(func->args)); quals = collect_boundary_expressions((Node *) jt, ts_var); foreach (lc, quals) { OpExpr *opexpr = lfirst_node(OpExpr, lc); Var *var; Expr *expr; Oid op; int64 value; if (IsA(linitial(opexpr->args), Var)) { var = linitial(opexpr->args); expr = lsecond(opexpr->args); op = opexpr->opno; } else if (IsA(lsecond(opexpr->args), Var)) { var = lsecond(opexpr->args); expr = linitial(opexpr->args); op = get_commutator(opexpr->opno); } else { /* collect_boundary_expressions has filtered those out already */ Assert(false); continue; } if (!op_in_opfamily(op, tce->btree_opf)) continue; /* * only allow simple expressions because Params have not been set up * at this stage and Vars will not work either because we execute in * separate execution context */ if (!is_simple_expr(expr) || !var_equal(ts_var, var)) continue; get_op_opfamily_properties(op, tce->btree_opf, false, &strategy, &lefttype, &righttype); if (boundary == GAPFILL_START && strategy != BTGreaterStrategyNumber && strategy != BTGreaterEqualStrategyNumber) continue; if (boundary == GAPFILL_END && strategy != BTLessStrategyNumber && strategy != BTLessEqualStrategyNumber) continue; value = get_boundary_expr_value(state, boundary, expr); /* * if the boundary expression operator does not match the operator * used by the gapfill node we adjust the value by 1 here * * the operators for the gapfill node are >= for start and < for end * column > value becomes start >= value + 1 column <= value becomes * end < value + 1 */ if (strategy == BTGreaterStrategyNumber || strategy == BTLessEqualStrategyNumber) value += 1; if (!boundary_found) { boundary_found = true; boundary_value = value; } else { if (boundary == GAPFILL_START) boundary_value = Max(boundary_value, value); else boundary_value = Min(boundary_value, value); } } if (boundary_found) return boundary_value; ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("missing time_bucket_gapfill argument: could not infer %s from WHERE clause", boundary == GAPFILL_START ? "start" : "finish"), errhint("Specify start and finish as arguments or in the WHERE clause."))); pg_unreachable(); } static Const * make_const_value_for_gapfill_internal(Oid typid, int64 value) { TypeCacheEntry *tce = lookup_type_cache(typid, 0); Datum d = gapfill_internal_get_datum(value, typid); return makeConst(typid, -1, InvalidOid, tce->typlen, d, false, tce->typbyval); } static void gapfill_advance_timestamp(GapFillState *state) { Datum next; switch (state->gapfill_typid) { case DATEOID: next = DirectFunctionCall2(date_pl_interval, DateADTGetDatum(state->gapfill_start), IntervalPGetDatum(state->next_offset)); next = DirectFunctionCall1(timestamp_date, next); state->next_timestamp = DatumGetDateADT(next); break; case TIMESTAMPOID: next = DirectFunctionCall2(timestamp_pl_interval, TimestampGetDatum(state->gapfill_start), IntervalPGetDatum(state->next_offset)); state->next_timestamp = DatumGetTimestamp(next); break; case TIMESTAMPTZOID: /* * To be consistent with time_bucket we do UTC bucketing unless * a different timezone got explicitly passed to the function * and we are bucketing by non-fixed intervals. */ if (state->have_timezone && (state->next_offset->day != 0 || state->next_offset->month != 0)) { bool isnull; /* TODO: optimize by constifying and caching the datum if possible */ Datum tzname = gapfill_exec_expr(state, state->scanslot, get_timezone_arg(state), &isnull); Assert(!isnull); /* Convert to local timestamp */ next = DirectFunctionCall2(timestamptz_zone, tzname, TimestampTzGetDatum(state->gapfill_start)); /* Add interval */ next = DirectFunctionCall2(timestamp_pl_interval, next, IntervalPGetDatum(state->next_offset)); /* Convert back to specified timezone */ next = DirectFunctionCall2(timestamp_zone, tzname, next); } else { next = DirectFunctionCall2(timestamp_pl_interval, TimestampTzGetDatum(state->gapfill_start), IntervalPGetDatum(state->next_offset)); } state->next_timestamp = DatumGetTimestampTz(next); break; default: state->next_timestamp += state->gapfill_period; break; } /* Advance the interval offset if necessary */ if (state->gapfill_interval) { Datum tspan = DirectFunctionCall2(interval_pl, IntervalPGetDatum(state->gapfill_interval), IntervalPGetDatum(state->next_offset)); state->next_offset = DatumGetIntervalP(tspan); } } /* * Initialize the scan state */ static void gapfill_begin(CustomScanState *node, EState *estate, int eflags) { GapFillState *state = (GapFillState *) node; CustomScan *cscan = castNode(CustomScan, state->csstate.ss.ps.plan); /* * this is the time_bucket_gapfill call from the plan which is used to * extract arguments and to align gapfill_start */ FuncExpr *func = linitial(cscan->custom_private); TupleDesc tupledesc = state->csstate.ss.ps.ps_ResultTupleSlot->tts_tupleDescriptor; List *targetlist = copyObject(state->csstate.ss.ps.plan->targetlist); bool isnull; Datum arg_value; state->gapfill_typid = func->funcresulttype; state->state = FETCHED_NONE; state->subslot = MakeSingleTupleTableSlot(tupledesc, &TTSOpsVirtual); state->scanslot = MakeSingleTupleTableSlot(tupledesc, &TTSOpsVirtual); /* bucket_width */ if (!is_simple_expr(linitial(state->args))) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: bucket_width must be a simple " "expression"))); arg_value = gapfill_exec_expr(state, NULL, linitial(state->args), &isnull); if (isnull) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: bucket_width cannot be NULL"))); state->gapfill_period = gapfill_period_get_internal(func->funcresulttype, exprType(linitial(state->args)), arg_value, &state->gapfill_interval); /* * this would error when trying to align start and stop to bucket_width as well below * but checking this explicitly here will make a nicer error message */ if (state->gapfill_period <= 0 && !state->gapfill_interval) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg( "invalid time_bucket_gapfill argument: bucket_width must be greater than 0"))); /* * check if gapfill start was left out so we have to infer from WHERE * clause */ if (is_const_null(get_start_arg(state))) { int64 start = infer_gapfill_boundary(state, GAPFILL_START); Const *expr = make_const_value_for_gapfill_internal(state->gapfill_typid, start); state->gapfill_start = align_with_time_bucket(state, (Expr *) expr); } else { /* * pass gapfill start through time_bucket so it is aligned with bucket * start */ state->gapfill_start = align_with_time_bucket(state, get_start_arg(state)); } state->next_timestamp = state->gapfill_start; state->next_offset = state->gapfill_interval; /* gap fill end */ if (is_const_null(get_finish_arg(state))) state->gapfill_end = infer_gapfill_boundary(state, GAPFILL_END); else { if (!is_simple_expr(get_finish_arg(state))) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: finish must be a simple " "expression"))); arg_value = gapfill_exec_expr(state, NULL, get_finish_arg(state), &isnull); /* * the default value for finish is NULL but this is checked above, * when a non-Const is passed here that evaluates to NULL we bail */ if (isnull) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: finish cannot be NULL"), errhint("Specify start and finish as arguments or in the WHERE clause."))); state->gapfill_end = gapfill_datum_get_internal(arg_value, func->funcresulttype); } gapfill_state_initialize_columns(state, targetlist); /* * Build ProjectionInfo that will be used for gap filled tuples only. */ state->pi = ExecBuildProjectionInfo(targetlist, state->csstate.ss.ps.ps_ExprContext, MakeSingleTupleTableSlot(tupledesc, &TTSOpsVirtual), &state->csstate.ss.ps, NULL); state->csstate.custom_ps = list_make1(ExecInitNode(state->subplan, estate, eflags)); } /* * This is the main loop of the node it is called whenever the upper node * wants to consume a new tuple. Returning NULL signals that the tuples * are exhausted. All gapfill state transitions happen in this function. */ static TupleTableSlot * gapfill_exec(CustomScanState *node) { GapFillState *state = (GapFillState *) node; TupleTableSlot *slot = NULL; while (true) { CHECK_FOR_INTERRUPTS(); /* fetch next tuple from subplan */ if (FETCHED_NONE == state->state) { slot = gapfill_fetch_next_tuple(state); if (slot) { if (state->multigroup && gapfill_state_is_new_group(state, slot)) state->state = FETCHED_NEXT_GROUP; else state->state = FETCHED_ONE; gapfill_state_set_next(state, slot); } else { /* * if GROUP BY has non time_bucket_gapfill columns but the * query has not initialized the groups there is nothing we * can do here */ if (state->multigroup && !state->groups_initialized) return NULL; else state->state = FETCHED_LAST; } } /* return any subplan tuples before gapfill_start */ if (FETCHED_ONE == state->state && state->subslot_time < state->gapfill_start) { state->state = FETCHED_NONE; return gapfill_state_return_subplan_slot(state); } /* if we have tuple from subplan check if it needs to be inserted now */ if (FETCHED_ONE == state->state && state->subslot_time == state->next_timestamp) { state->state = FETCHED_NONE; gapfill_advance_timestamp(state); return gapfill_state_return_subplan_slot(state); } /* if we are within gapfill boundaries we need to insert tuple */ if (state->next_timestamp < state->gapfill_end) { Assert(state->state != FETCHED_NONE); slot = gapfill_state_gaptuple_create(state, state->next_timestamp); gapfill_advance_timestamp(state); return slot; } /* return any remaining subplan tuples after gapfill_end */ if (FETCHED_ONE == state->state) { state->state = FETCHED_NONE; return gapfill_state_return_subplan_slot(state); } /* * Done with current group, prepare for next */ if (FETCHED_NEXT_GROUP == state->state) { state->state = FETCHED_ONE; state->next_timestamp = state->gapfill_start; gapfill_state_reset_group(state, state->subslot); continue; } return NULL; } } static void gapfill_end(CustomScanState *node) { if (node->custom_ps != NIL) { ExecEndNode(linitial(node->custom_ps)); } } static void gapfill_rescan(CustomScanState *node) { if (node->custom_ps != NIL) { ExecReScan(linitial(node->custom_ps)); } ((GapFillState *) node)->state = FETCHED_NONE; } static void gapfill_state_reset_group(GapFillState *state, TupleTableSlot *slot) { GapFillColumnStateUnion column; int i; Datum value; bool isnull; foreach_column(column.base, i, state) { value = slot_getattr(slot, AttrOffsetGetAttrNumber(i), &isnull); switch (column.base->ctype) { case INTERPOLATE_COLUMN: gapfill_interpolate_group_change(column.interpolate, state->subslot_time, value, isnull); break; case LOCF_COLUMN: gapfill_locf_group_change(column.locf); break; case GROUP_COLUMN: case DERIVED_COLUMN: column.group->isnull = isnull; if (!isnull) column.group->value = datumCopy(value, column.base->typbyval, column.base->typlen); break; default: break; } } state->next_offset = state->gapfill_interval; } /* * Create generated tuple according to column state */ static TupleTableSlot * gapfill_state_gaptuple_create(GapFillState *state, int64 time) { TupleTableSlot *slot = state->scanslot; GapFillColumnStateUnion column; int i; ExecClearTuple(slot); /* * we need to fill in group columns first because locf and interpolation * might reference those columns when doing out of bounds lookup */ foreach_column(column.base, i, state) { switch (column.base->ctype) { case TIME_COLUMN: slot->tts_values[i] = gapfill_internal_get_datum(time, state->gapfill_typid); slot->tts_isnull[i] = false; break; case GROUP_COLUMN: case DERIVED_COLUMN: slot->tts_values[i] = column.group->value; slot->tts_isnull[i] = column.group->isnull; break; case NULL_COLUMN: slot->tts_isnull[i] = true; break; default: break; } } /* * mark slot as containing data so it can be used in locf and interpolate * lookup expressions */ ExecStoreVirtualTuple(slot); foreach_column(column.base, i, state) { switch (column.base->ctype) { case LOCF_COLUMN: /* We may execute lookup expression over a generated tuple which fills the gap */ gapfill_locf_calculate(column.locf, state, slot, time, &slot->tts_values[i], &slot->tts_isnull[i]); break; case INTERPOLATE_COLUMN: gapfill_interpolate_calculate(column.interpolate, state, time, &slot->tts_values[i], &slot->tts_isnull[i]); break; default: break; } } ResetExprContext(state->pi->pi_exprContext); state->pi->pi_exprContext->ecxt_scantuple = slot; return ExecProject(state->pi); } /* * Returns true if tuple in the TupleTableSlot belongs to the next * aggregation group */ static bool gapfill_state_is_new_group(GapFillState *state, TupleTableSlot *slot) { GapFillColumnStateUnion column; int i; Datum value; bool isnull; /* groups not initialized yet */ if (!state->groups_initialized) { state->groups_initialized = true; gapfill_state_reset_group(state, slot); return false; } foreach_column(column.base, i, state) { if (column.base->ctype == GROUP_COLUMN) { value = slot_getattr(slot, AttrOffsetGetAttrNumber(i), &isnull); if (isnull && column.group->isnull) continue; if (isnull != column.group->isnull) return true; /* We need to use FunctionCall2Coll here since equality comparison * functions can try to access flinfo (see arrayfuncs.c). */ if (!DatumGetBool(FunctionCall2Coll(&column.group->eq_func, column.group->collation, value, column.group->value))) return true; } } return false; } /* * Returns subslot tuple and adjusts column state accordingly */ static TupleTableSlot * gapfill_state_return_subplan_slot(GapFillState *state) { GapFillColumnStateUnion column; CustomScanState *node = castNode(CustomScanState, state); int i; Datum value; bool isnull; foreach_column(column.base, i, state) { switch (column.base->ctype) { case LOCF_COLUMN: value = slot_getattr(state->subslot, AttrOffsetGetAttrNumber(i), &isnull); /* We may execute lookup expression over an input tuple from the subplan to override * NULL value when NULLs are treated as missing. Use the correct tuple for the * purpose. */ if (isnull && column.locf->treat_null_as_missing) gapfill_locf_calculate(column.locf, state, state->subslot, state->subslot_time, &state->subslot->tts_values[i], &state->subslot->tts_isnull[i]); else gapfill_locf_tuple_returned(column.locf, value, isnull); break; case INTERPOLATE_COLUMN: value = slot_getattr(state->subslot, AttrOffsetGetAttrNumber(i), &isnull); gapfill_interpolate_tuple_returned(column.interpolate, state->subslot_time, value, isnull); break; default: break; } } if (node->ss.ps.ps_ProjInfo) { ExprContext *econtext = node->ss.ps.ps_ExprContext; ResetExprContext(econtext); econtext->ecxt_scantuple = state->subslot; return ExecProject(node->ss.ps.ps_ProjInfo); } return state->subslot; } static void gapfill_state_set_next(GapFillState *state, TupleTableSlot *subslot) { GapFillColumnStateUnion column; int i; Datum value; bool isnull; /* * if this tuple is for next group we dont update column state yet * updating of column state happens in gapfill_state_reset_group instead */ if (FETCHED_NEXT_GROUP == state->state) return; foreach_column(column.base, i, state) { /* nothing to do here for locf */ if (INTERPOLATE_COLUMN == column.base->ctype) { value = slot_getattr(subslot, AttrOffsetGetAttrNumber(i), &isnull); gapfill_interpolate_tuple_fetched(column.interpolate, state->subslot_time, value, isnull); } } } static TupleTableSlot * gapfill_fetch_next_tuple(GapFillState *state) { Datum time_value; bool isnull; PlanState *subplan = linitial(castNode(CustomScanState, state)->custom_ps); TupleTableSlot *subslot = ExecProcNode(subplan); if (TupIsNull(subslot)) return NULL; /* we cannot simply treat an arbitrary source slot as virtual, * instead we must copy the data into our own slot in order to be able to * modify it */ ExecCopySlot(state->subslot, subslot); time_value = slot_getattr(subslot, AttrOffsetGetAttrNumber(state->time_index), &isnull); if (isnull) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("invalid time_bucket_gapfill argument: ts cannot be NULL"))); state->subslot_time = gapfill_datum_get_internal(time_value, state->gapfill_typid); return state->subslot; } /* * Initialize column meta data */ static void gapfill_state_initialize_columns(GapFillState *state, List *exec_tlist) { TupleDesc tupledesc = state->csstate.ss.ps.ps_ResultTupleSlot->tts_tupleDescriptor; CustomScan *cscan = castNode(CustomScan, state->csstate.ss.ps.plan); TargetEntry *tle; Expr *expr; int i; state->ncolumns = tupledesc->natts; state->columns = (GapFillColumnState **) palloc(state->ncolumns * sizeof(GapFillColumnState *)); for (i = 0; i < state->ncolumns; i++) { tle = list_nth(cscan->custom_scan_tlist, i); expr = tle->expr; if (tle->ressortgroupref && gapfill_is_group_column(state, tle)) { /* * if there is time_bucket_gapfill function call this is our time * column */ if (IsA(expr, FuncExpr) && strncmp(get_func_name(castNode(FuncExpr, expr)->funcid), GAPFILL_FUNCTION, NAMEDATALEN) == 0) { state->columns[i] = gapfill_column_state_create(TIME_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); state->time_index = i; continue; } /* otherwise this is a normal group column */ state->columns[i] = gapfill_column_state_create(GROUP_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); state->multigroup = true; state->groups_initialized = false; continue; } else if (IsA(expr, FuncExpr)) { /* locf and interpolate will be toplevel function calls in the gapfill node */ if (strncmp(get_func_name(castNode(FuncExpr, expr)->funcid), GAPFILL_LOCF_FUNCTION, NAMEDATALEN) == 0) { state->columns[i] = gapfill_column_state_create(LOCF_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); gapfill_locf_initialize((GapFillLocfColumnState *) state->columns[i], state, (FuncExpr *) expr); continue; } if (strncmp(get_func_name(castNode(FuncExpr, expr)->funcid), GAPFILL_INTERPOLATE_FUNCTION, NAMEDATALEN) == 0) { state->columns[i] = gapfill_column_state_create(INTERPOLATE_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); gapfill_interpolate_initialize((GapFillInterpolateColumnState *) state->columns[i], state, (FuncExpr *) expr); continue; } } /* * any column that does not have an aggregation function and is not * an explicit GROUP BY column has to be derived from a GROUP BY * column so we treat those similar to GROUP BY column for gapfill * purposes. */ bool column_contains_aggs = contain_agg_clause((Node *) expr); if (!column_contains_aggs && contain_var_clause((Node *) expr)) { state->columns[i] = gapfill_column_state_create(DERIVED_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); state->multigroup = true; state->groups_initialized = false; continue; } /* * For every column with Aggrefs we take the original expression tree from the * subplan and replace Aggref nodes with Const NULL nodes. This is * necessary because the expression might be evaluated below the * aggregation so we need to pull up expression from subplan into * projection for gapfilled tuples so expressions like COALESCE work * correctly for gapfilled tuples. */ if (column_contains_aggs) { TargetEntry *agg_expr_tle = gapfill_get_fixed_agg_expr_column(state, tle); Assert(agg_expr_tle); Node *entry = copyObject((Node *) agg_expr_tle); /* Fix for #4894 when we have expressions like (agg + group_expr): * after getting fixed entry where aggs are replaced with NULLs * and group expressions are replaced with exec group columns, * check whether this column contains group columns and needs to be DERIVED or NULL. */ if (contain_var_clause(entry)) { state->columns[i] = gapfill_column_state_create(DERIVED_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); state->multigroup = true; state->groups_initialized = false; } else state->columns[i] = gapfill_column_state_create(NULL_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); lfirst(list_nth_cell(exec_tlist, i)) = entry; continue; } /* column with no special action from gap fill node */ state->columns[i] = gapfill_column_state_create(NULL_COLUMN, TupleDescAttr(tupledesc, i)->atttypid); } } /* * Create GapFillColumnState object, set proper type and fill in datatype information */ static GapFillColumnState * gapfill_column_state_create(GapFillColumnType ctype, Oid typeid) { TypeCacheEntry *tce; int tc_flags = 0; GapFillColumnState *column; size_t size; switch (ctype) { case GROUP_COLUMN: tc_flags |= TYPECACHE_EQ_OPR; TS_FALLTHROUGH; case DERIVED_COLUMN: size = sizeof(GapFillGroupColumnState); break; case LOCF_COLUMN: size = sizeof(GapFillLocfColumnState); break; case INTERPOLATE_COLUMN: size = sizeof(GapFillInterpolateColumnState); break; default: size = sizeof(GapFillColumnState); break; } tce = lookup_type_cache(typeid, tc_flags); column = palloc0(size); column->ctype = ctype; column->typid = tce->type_id; column->typbyval = tce->typbyval; column->typlen = tce->typlen; if (ctype == GROUP_COLUMN) { GapFillGroupColumnState *gcolumn = (GapFillGroupColumnState *) column; Oid eq_opr_func = get_opcode(tce->eq_opr); fmgr_info_cxt(eq_opr_func, &gcolumn->eq_func, CurrentMemoryContext); gcolumn->collation = tce->typcollation; } return column; } /* * check if the target entry is a GROUP BY column, we need * this check because ressortgroupref will be nonzero for * ORDER BY and GROUP BY columns but we are only interested * in actual GROUP BY columns */ static bool gapfill_is_group_column(GapFillState *state, TargetEntry *tle) { ListCell *lc; CustomScan *cscan = castNode(CustomScan, state->csstate.ss.ps.plan); List *groups = lsecond(cscan->custom_private); foreach (lc, groups) { if (tle->ressortgroupref == ((SortGroupClause *) lfirst(lc))->tleSortGroupRef) return true; } return false; } /* * If the target entry contains an aggregate, it has been fixed in "custom_exprs" * so that the aggregate is replaced with NULL * and any group expressions are replaced with exec group vars. * We will get the fixed aggregate expression here and use it in exec tlist. */ static TargetEntry * gapfill_get_fixed_agg_expr_column(GapFillState *state, TargetEntry *tle) { ListCell *lc; CustomScan *cscan = castNode(CustomScan, state->csstate.ss.ps.plan); List *mutated_agg_exprs_list = castNode(List, cscan->custom_exprs); Assert(list_length(mutated_agg_exprs_list) == 1); List *mutated_agg_exprs = castNode(List, linitial(mutated_agg_exprs_list)); foreach (lc, mutated_agg_exprs) { TargetEntry *mutated_agg_expr_tle = castNode(TargetEntry, lfirst(lc)); if (tle->resno == mutated_agg_expr_tle->resno) return mutated_agg_expr_tle; } return NULL; } /* * Execute expression and return result of expression */ Datum gapfill_exec_expr(GapFillState *state, TupleTableSlot *ecxt_slot, Expr *expr, bool *isnull) { ExprState *exprstate = ExecInitExpr(expr, &state->csstate.ss.ps); ExprContext *exprcontext = GetPerTupleExprContext(state->csstate.ss.ps.state); exprcontext->ecxt_scantuple = ecxt_slot; return ExecEvalExprSwitchContext(exprstate, exprcontext, isnull); } /* * Adjust attribute number of all Var nodes in an expression to have the * proper index into the gap filled tuple. This is necessary to make column * references in correlated subqueries in lookup queries work. */ Expr * gapfill_adjust_varnos(GapFillState *state, Expr *expr) { ListCell *lc_var, *lc_tle; List *vars = pull_var_clause((Node *) expr, 0); List *tlist = castNode(CustomScan, state->csstate.ss.ps.plan)->custom_scan_tlist; foreach (lc_var, vars) { Var *var = lfirst(lc_var); foreach (lc_tle, tlist) { TargetEntry *tle = lfirst(lc_tle); /* * subqueries in aggregate queries can only reference columns so * we only need to look for targetlist toplevel column references */ if (IsA(tle->expr, Var) && castNode(Var, tle->expr)->varattno == var->varattno) { var->varattno = tle->resno; break; } } } return expr; } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/gapfill_functions.c����������������������������������������0000664�0000000�0000000�00000004214�15100345067�0024045�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <fmgr.h> #include <utils/lsyscache.h> #include "gapfill_functions.h" #include "time_bucket.h" Datum gapfill_marker(PG_FUNCTION_ARGS) { if (PG_ARGISNULL(0)) PG_RETURN_NULL(); else PG_RETURN_DATUM(PG_GETARG_DATUM(0)); } #define GAPFILL_TIMEBUCKET_WRAPPER(datatype) \ Datum gapfill_##datatype##_time_bucket(PG_FUNCTION_ARGS) \ { \ /* \ * since time_bucket is STRICT and time_bucket_gapfill \ * is not we need to add explicit checks for NULL here \ */ \ if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) \ PG_RETURN_NULL(); \ return DirectFunctionCall2(ts_##datatype##_bucket, \ PG_GETARG_DATUM(0), \ PG_GETARG_DATUM(1)); \ } GAPFILL_TIMEBUCKET_WRAPPER(int16); GAPFILL_TIMEBUCKET_WRAPPER(int32); GAPFILL_TIMEBUCKET_WRAPPER(int64); GAPFILL_TIMEBUCKET_WRAPPER(date); GAPFILL_TIMEBUCKET_WRAPPER(timestamp); GAPFILL_TIMEBUCKET_WRAPPER(timestamptz); Datum gapfill_timestamptz_timezone_time_bucket(PG_FUNCTION_ARGS) { /* * since time_bucket is STRICT and time_bucket_gapfill * is not we need to add explicit checks for NULL here */ if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)) PG_RETURN_NULL(); return DirectFunctionCall3(ts_timestamptz_timezone_bucket, PG_GETARG_DATUM(0), PG_GETARG_DATUM(1), PG_GETARG_DATUM(2)); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/gapfill_functions.h����������������������������������������0000664�0000000�0000000�00000001515�15100345067�0024053�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * Functions used by gapfill which are exported to SQL. * Shell functions for these are defined in src/gapfill.c */ #include <postgres.h> #include <fmgr.h> extern Datum gapfill_marker(PG_FUNCTION_ARGS); extern Datum gapfill_int16_time_bucket(PG_FUNCTION_ARGS); extern Datum gapfill_int32_time_bucket(PG_FUNCTION_ARGS); extern Datum gapfill_int64_time_bucket(PG_FUNCTION_ARGS); extern Datum gapfill_timestamp_time_bucket(PG_FUNCTION_ARGS); extern Datum gapfill_timestamptz_time_bucket(PG_FUNCTION_ARGS); extern Datum gapfill_timestamptz_timezone_time_bucket(PG_FUNCTION_ARGS); extern Datum gapfill_date_time_bucket(PG_FUNCTION_ARGS); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/gapfill_internal.h�����������������������������������������0000664�0000000�0000000�00000007204�15100345067�0023660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <datatype/timestamp.h> #include <nodes/execnodes.h> /* * GapFillFetchState describes the state of subslot in GapFillState: * FETCHED_NONE: no tuple in subslot * FETCHED_ONE: valid tuple in subslot * FETCHED_LAST: no tuple in subslot and no more tuples from subplan * FETCHED_NEXT_GROUP: tuple in subslot belongs to next aggregation group * * The start state is FETCHED_NONE and the end state is FETCHED_LAST * * State transition with single group by time * * no tuple returned * FETCHED_NONE --> fetch_next_tuple -------------------> FETCHED_LAST * ^ | * | | tuple found * | | * | v * â””----------FETCHED_ONE * tuple returned * * State transition with multiple groups * * no tuple returned * FETCHED_NONE --> fetch_next_tuple -------------------> FETCHED_LAST * ^ | * | | tuple found * | v * | check_group_changed -------> FETCHED_NEXT_GROUP * | | yes | * | | no | * | | | * | v | * â””----------FETCHED_ONE <----------------- * tuple returned */ typedef enum GapFillFetchState { FETCHED_NONE, FETCHED_ONE, FETCHED_NEXT_GROUP, FETCHED_LAST, } GapFillFetchState; /* * NULL_COLUMN: column with no special action from gapfill e.g. min(value) * TIME_COLUMN: column with time_bucket_gapfill call * GROUP_COLUMN: any column appearing in GROUP BY clause * DERIVED_COLUMN: column not appearing in GROUP BY but dependent on GROUP BY column * LOCF_COLUMN: column with locf call * INTERPOLATE_COLUMN: column with interpolate call */ typedef enum GapFillColumnType { NULL_COLUMN, TIME_COLUMN, GROUP_COLUMN, DERIVED_COLUMN, LOCF_COLUMN, INTERPOLATE_COLUMN } GapFillColumnType; typedef struct GapFillColumnState { GapFillColumnType ctype; Oid typid; bool typbyval; int16 typlen; } GapFillColumnState; typedef struct GapFillGroupColumnState { GapFillColumnState base; Datum value; bool isnull; Oid collation; FmgrInfo eq_func; } GapFillGroupColumnState; typedef struct GapFillState { CustomScanState csstate; Plan *subplan; Oid gapfill_typid; /* arguments of the gapfill function call */ List *args; bool have_timezone; int64 gapfill_start; int64 gapfill_end; /* bucket width for fixed-size buckets */ int64 gapfill_period; /* bucket width when bucketing by month */ Interval *gapfill_interval; int64 next_timestamp; /* interval offset for next_timestamp from gapfill_start */ Interval *next_offset; int64 subslot_time; /* time of tuple in subslot */ int time_index; /* position of time column */ TupleTableSlot *subslot; /* TupleTableSlot storing data from subplan */ bool multigroup; /* multiple groupings */ bool groups_initialized; int ncolumns; GapFillColumnState **columns; ProjectionInfo *pi; TupleTableSlot *scanslot; GapFillFetchState state; } GapFillState; Node *gapfill_state_create(CustomScan *); Expr *gapfill_adjust_varnos(GapFillState *state, Expr *expr); Datum gapfill_exec_expr(GapFillState *state, TupleTableSlot *, Expr *expr, bool *isnull); int64 gapfill_datum_get_internal(Datum, Oid); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/gapfill_plan.c���������������������������������������������0000664�0000000�0000000�00000043045�15100345067�0022774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <nodes/execnodes.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <optimizer/clauses.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/tlist.h> #include <parser/parse_func.h> #include <utils/lsyscache.h> #include "compat/compat.h" #include "gapfill.h" #include "gapfill_internal.h" static CustomScanMethods gapfill_plan_methods = { .CustomName = "GapFill", .CreateCustomScanState = gapfill_state_create, }; typedef struct gapfill_walker_context { union { Node *node; Expr *expr; FuncExpr *func; WindowFunc *window; } call; int count; } gapfill_walker_context; /* * Replace Aggref with const NULL */ static Node * gapfill_aggref_mutator(Node *node, void *context) { if (node == NULL) return NULL; if (IsA(node, Aggref)) return (Node *) makeConst(((Aggref *) node)->aggtype, -1, InvalidOid, -2, (Datum) 0, true, false); return expression_tree_mutator(node, gapfill_aggref_mutator, context); } /* * FuncExpr is time_bucket_gapfill function call */ static inline bool is_gapfill_function_call(FuncExpr *call) { char *func_name = get_func_name(call->funcid); return strncmp(func_name, GAPFILL_FUNCTION, NAMEDATALEN) == 0; } /* * FuncExpr is locf or interpolate function call */ static inline bool is_marker_function_call(FuncExpr *call) { char *func_name = get_func_name(call->funcid); return strncmp(func_name, GAPFILL_LOCF_FUNCTION, NAMEDATALEN) == 0 || strncmp(func_name, GAPFILL_INTERPOLATE_FUNCTION, NAMEDATALEN) == 0; } /* * Find time_bucket_gapfill function call */ static bool gapfill_function_walker(Node *node, gapfill_walker_context *context) { if (node == NULL) return false; if (IsA(node, FuncExpr) && is_gapfill_function_call(castNode(FuncExpr, node))) { context->call.node = node; context->count++; } return expression_tree_walker(node, gapfill_function_walker, context); } /* * Find locf/interpolate function call */ static bool marker_function_walker(Node *node, gapfill_walker_context *context) { if (node == NULL) return false; if (IsA(node, FuncExpr) && is_marker_function_call(castNode(FuncExpr, node))) { context->call.node = node; context->count++; } return expression_tree_walker(node, marker_function_walker, context); } /* * Find window function calls */ static bool window_function_walker(Node *node, gapfill_walker_context *context) { if (node == NULL) return false; if (IsA(node, WindowFunc)) { context->call.node = node; context->count++; } return expression_tree_walker(node, window_function_walker, context); } /* * check if ordering matches the order we need: * all groups need to be part of order * pathkeys must consist of group elements only * last element of pathkeys needs to be time_bucket_gapfill ASC */ static bool gapfill_correct_order(PlannerInfo *root, Path *subpath, FuncExpr *func) { int num_groupby_pathkeys; #if PG16_LT num_groupby_pathkeys = list_length(root->group_pathkeys); #else /* In PG16 group_pathkeys can contain additional pathkeys * used for optimization on ordered aggregates. * We only want to deal with group by elements only here. */ num_groupby_pathkeys = root->num_groupby_pathkeys; #endif if (list_length(subpath->pathkeys) != num_groupby_pathkeys) return false; if (list_length(subpath->pathkeys) > 0) { PathKey *pk = llast(subpath->pathkeys); EquivalenceMember *em = linitial(pk->pk_eclass->ec_members); /* time_bucket_gapfill is last element */ if (pk->pk_cmptype == COMPARE_LT && IsA(em->em_expr, FuncExpr) && ((FuncExpr *) em->em_expr)->funcid == func->funcid) { int i; /* check all groupby pathkeys are part of subpath pathkeys */ for (i = 0; i < num_groupby_pathkeys; i++) { if (!list_member(subpath->pathkeys, list_nth(root->group_pathkeys, i))) return false; } return true; } } return false; } /* Create a gapfill plan node in the form of a CustomScan node. The * purpose of this plan node is to insert tuples for missing groups. * * Note that CustomScan nodes cannot be extended (by struct embedding) because * they might be copied, therefore we pass any extra info in the custom_private * field. * * The gapfill plan takes the original Agg node and imposes itself on top of the * Agg node. During execution, the gapfill node will produce the new tuples. */ static Plan * gapfill_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path, List *tlist, List *clauses, List *custom_plans) { GapFillPath *gfpath = (GapFillPath *) path; CustomScan *cscan = makeNode(CustomScan); List *args = list_copy(gfpath->func->args); cscan->scan.scanrelid = 0; cscan->scan.plan.targetlist = tlist; cscan->custom_plans = custom_plans; cscan->custom_scan_tlist = tlist; /* When we have original target entries like (agg + group_expr) * we will replace agg with NULL and put resulting expression into exec-fixed "targetlist", * but we need to fix "group_expr" to refer to exec targetlist group column. * Only then we can safely put (NULL + group_column_exec) entry into exec-fixed targetlist. */ List *mutated_agg_exprs = NIL; if (contain_agg_clause((Node *) tlist)) { TargetEntry *tle; ListCell *lc; foreach (lc, tlist) { tle = lfirst(lc); if (contain_agg_clause((Node *) tle)) { Node *entry = copyObject((Node *) tle); entry = gapfill_aggref_mutator(entry, NULL); mutated_agg_exprs = lappend(mutated_agg_exprs, entry); } } } cscan->custom_exprs = list_make1(mutated_agg_exprs); cscan->flags = path->flags; cscan->methods = &gapfill_plan_methods; cscan->custom_private = list_make4(gfpath->func, root->parse->groupClause, root->parse->jointree, args); return &cscan->scan.plan; } static CustomPathMethods gapfill_path_methods = { .CustomName = "GapFill", .PlanCustomPath = gapfill_plan_create, }; static bool gapfill_expression_walker(Expr *node, bool (*walker)(Node *, gapfill_walker_context *), gapfill_walker_context *context) { context->count = 0; context->call.node = NULL; return (*walker)((Node *) node, context); } /* * Build expression lists for the gapfill node and the node below. * All marker functions will be top-level function calls in the * resulting gapfill node targetlist and will not be included in * the subpath expression list */ static void gapfill_build_pathtarget(PathTarget *pt_upper, PathTarget *pt_path, PathTarget *pt_subpath) { ListCell *lc; int i = -1; foreach (lc, pt_upper->exprs) { Expr *expr = lfirst(lc); gapfill_walker_context context; i++; /* check for locf/interpolate calls */ gapfill_expression_walker(expr, marker_function_walker, &context); if (context.count > 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("multiple interpolate/locf function calls per resultset column not " "supported"))); if (context.count == 1) { /* * marker needs to be toplevel for now unless we have a projection capable * node above gapfill node */ if (expr != context.call.expr && !contain_window_function((Node *) expr)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("%s must be toplevel function call", get_func_name(context.call.func->funcid)))); /* if there is an aggregation it needs to be a child of the marker function */ if (contain_agg_clause((Node *) expr) && !contain_agg_clause(linitial(context.call.func->args))) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("aggregate functions must be below %s", get_func_name(context.call.func->funcid)))); if (contain_window_function(context.call.node)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("window functions must not be below %s", get_func_name(context.call.func->funcid)))); add_column_to_pathtarget(pt_path, context.call.expr, pt_upper->sortgrouprefs[i]); add_column_to_pathtarget(pt_subpath, linitial(context.call.func->args), pt_upper->sortgrouprefs[i]); continue; } /* check for plain window function calls without locf/interpolate */ gapfill_expression_walker(expr, window_function_walker, &context); if (context.count > 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("multiple window function calls per column not supported"))); if (context.count == 1) { /* * window functions without arguments like rank() don't need to * appear in the target list below WindowAgg node */ if (context.call.window->args != NIL) { ListCell *lc_arg; /* * check arguments past first argument dont have Vars */ for (lc_arg = lnext(context.call.window->args, list_head(context.call.window->args)); lc_arg != NULL; lc_arg = lnext(context.call.window->args, lc_arg)) { if (contain_var_clause(lfirst(lc_arg))) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("window functions with multiple column " "references not supported"))); } if (contain_var_clause(linitial(context.call.window->args))) { add_column_to_pathtarget(pt_path, linitial(context.call.window->args), pt_upper->sortgrouprefs[i]); add_column_to_pathtarget(pt_subpath, linitial(context.call.window->args), pt_upper->sortgrouprefs[i]); } } } else { /* * no locf/interpolate or window functions found so we can * use expression verbatim */ add_column_to_pathtarget(pt_path, expr, pt_upper->sortgrouprefs[i]); add_column_to_pathtarget(pt_subpath, expr, pt_upper->sortgrouprefs[i]); } } } /* * Create a Gapfill Path node. * * The gap fill node needs rows to be sorted by time ASC * so we insert sort paths if the query order does not match * that */ static Path * gapfill_path_create(PlannerInfo *root, Path *subpath, FuncExpr *func) { GapFillPath *path; path = (GapFillPath *) newNode(sizeof(GapFillPath), T_CustomPath); path->cpath.path.pathtype = T_CustomScan; path->cpath.methods = &gapfill_path_methods; /* * parallel_safe must be false because it is not safe to execute this node * in parallel, but it is safe for child nodes to be parallel */ Assert(!path->cpath.path.parallel_safe); path->cpath.path.rows = subpath->rows; path->cpath.path.parent = subpath->parent; path->cpath.path.param_info = subpath->param_info; path->cpath.flags = 0; path->cpath.path.pathkeys = subpath->pathkeys; path->cpath.path.pathtarget = create_empty_pathtarget(); subpath->pathtarget = create_empty_pathtarget(); gapfill_build_pathtarget(root->upper_targets[UPPERREL_FINAL], path->cpath.path.pathtarget, subpath->pathtarget); if (!gapfill_correct_order(root, subpath, func)) { List *new_order = NIL; PathKey *pk_func = NULL; int num_groupby_pathkeys; #if PG16_LT num_groupby_pathkeys = list_length(root->group_pathkeys); #else /* In PG16 group_pathkeys can contain additional pathkeys * used for optimization on ordered aggregates. * We only want to deal with group by elements only here. */ num_groupby_pathkeys = root->num_groupby_pathkeys; #endif int i; /* subpath does not have correct order */ for (i = 0; i < num_groupby_pathkeys; i++) { PathKey *pk = list_nth(root->group_pathkeys, i); EquivalenceMember *em = linitial(pk->pk_eclass->ec_members); if (!pk_func && IsA(em->em_expr, FuncExpr) && ((FuncExpr *) em->em_expr)->funcid == func->funcid) { if (pk->pk_cmptype == COMPARE_LT) pk_func = pk; else pk_func = make_canonical_pathkey(root, pk->pk_eclass, pk->pk_opfamily, BTLessStrategyNumber, pk->pk_nulls_first); } else new_order = lappend(new_order, pk); } if (!pk_func) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("no top level time_bucket_gapfill in group by clause"))); new_order = lappend(new_order, pk_func); subpath = (Path *) create_sort_path(root, subpath->parent, subpath, new_order, root->limit_tuples); } path->cpath.path.startup_cost = subpath->startup_cost; path->cpath.path.total_cost = subpath->total_cost; path->cpath.path.pathkeys = subpath->pathkeys; path->cpath.custom_paths = list_make1(subpath); path->func = func; return &path->cpath.path; } /* * Prepend GapFill node to every group_rel path. * The implementation assumes that TimescaleDB planning hook is called only once * per grouping. */ void plan_add_gapfill(PlannerInfo *root, RelOptInfo *group_rel) { ListCell *lc; Query *parse = root->parse; gapfill_walker_context context = { .call.node = NULL, .count = 0 }; if (CMD_SELECT != parse->commandType || parse->groupClause == NIL) return; /* * Look for time_bucket_gapfill function call in the target list, which * will succeed on every call to plan_add_gapfill, thus it will lead to * incorrect query plan if plan_add_gapfill is called more than once per * grouping. */ gapfill_function_walker((Node *) parse->targetList, &context); if (context.count == 0) return; if (context.count > 1) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("multiple time_bucket_gapfill calls not allowed"))); if (context.count == 1) { List *copy = group_rel->pathlist; group_rel->pathlist = NIL; group_rel->cheapest_total_path = NULL; group_rel->cheapest_startup_path = NULL; group_rel->cheapest_unique_path = NULL; /* Parameterized paths pathlist is currently deleted instead of being processed */ list_free(group_rel->ppilist); group_rel->ppilist = NULL; list_free(group_rel->cheapest_parameterized_paths); group_rel->cheapest_parameterized_paths = NULL; foreach (lc, copy) { add_path(group_rel, gapfill_path_create(root, lfirst(lc), context.call.func)); } list_free(copy); } } static inline bool is_gapfill_path(Path *path) { return IsA(path, CustomPath) && castNode(CustomPath, path)->methods == &gapfill_path_methods; } /* * Since we construct the targetlist for the gapfill node from the * final targetlist we need to adjust any intermediate targetlists * between toplevel window agg node and gapfill node. This adjustment * is only necessary if multiple WindowAgg nodes are present. * In that case we need to adjust the targetlists of nodes between * toplevel WindowAgg node and Gapfill node * * Gapfill plan with multiple WindowAgg nodes: * * WindowAgg * -> WindowAgg * -> Custom Scan (GapFill) * -> Sort * Sort Key: (time_bucket_gapfill(1, "time")) * -> HashAggregate * Group Key: time_bucket_gapfill(1, "time") * -> Seq Scan on metrics_int * */ void gapfill_adjust_window_targetlist(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel) { ListCell *lc; if (!is_gapfill_path(linitial(input_rel->pathlist))) return; foreach (lc, output_rel->pathlist) { WindowAggPath *toppath = lfirst(lc); /* * the toplevel WindowAggPath has the highest index. If winref is * 1 we only have one WindowAggPath if its greater then 1 then there * are multiple WindowAgg nodes. * * we skip toplevel WindowAggPath because targetlist of toplevel WindowAggPath * is our starting point for building gapfill targetlist so we don't need to * adjust the toplevel targetlist */ if (IsA(toppath, WindowAggPath) && toppath->winclause->winref > 1) { WindowAggPath *path; for (path = (WindowAggPath *) toppath->subpath; IsA(path, WindowAggPath); path = (WindowAggPath *) path->subpath) { PathTarget *pt_top = toppath->path.pathtarget; PathTarget *pt; ListCell *lc_expr; int i = -1; pt = create_empty_pathtarget(); /* * for each child we build targetlist based on top path * targetlist */ foreach (lc_expr, pt_top->exprs) { gapfill_walker_context context; i++; gapfill_expression_walker(lfirst(lc_expr), window_function_walker, &context); /* * we error out on multiple window functions per resultset column * when building gapfill node targetlist so we only assert here */ Assert(context.count <= 1); if (context.count == 1) { if (context.call.window->winref <= path->winclause->winref) /* * window function of current level or below * so we can put in verbatim */ add_column_to_pathtarget(pt, lfirst(lc_expr), pt_top->sortgrouprefs[i]); else if (context.call.window->args != NIL) { ListCell *lc_arg; if (list_length(context.call.window->args) > 1) /* * check arguments past first argument dont have Vars */ for (lc_arg = lnext(context.call.window->args, list_head(context.call.window->args)); lc_arg != NULL; lc_arg = lnext(context.call.window->args, lc_arg)) { if (contain_var_clause(lfirst(lc_arg))) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("window functions with multiple column " "references not supported"))); } if (contain_var_clause(linitial(context.call.window->args))) add_column_to_pathtarget(pt, linitial(context.call.window->args), pt_top->sortgrouprefs[i]); } } else add_column_to_pathtarget(pt, lfirst(lc_expr), pt_top->sortgrouprefs[i]); } path->path.pathtarget = pt; } } } } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/interpolate.c����������������������������������������������0000664�0000000�0000000�00000021057�15100345067�0022671�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/numeric.h> #include <utils/typcache.h> #include "compat/compat.h" #include "gapfill_internal.h" #include "interpolate.h" #define INTERPOLATE(x, x0, x1, y0, y1) (((y0) * ((x1) - (x)) + (y1) * ((x) - (x0))) / ((x1) - (x0))) /* * gapfill_interpolate_initialize gets called when plan is initialized for every interpolate column */ void gapfill_interpolate_initialize(GapFillInterpolateColumnState *interpolate, GapFillState *state, FuncExpr *function) { interpolate->prev.isnull = true; interpolate->next.isnull = true; if (list_length(function->args) > 1) interpolate->lookup_before = gapfill_adjust_varnos(state, lsecond(function->args)); if (list_length(function->args) > 2) interpolate->lookup_after = gapfill_adjust_varnos(state, lthird(function->args)); } /* * gapfill_interpolate_group_change gets called when a new aggregation group becomes active */ void gapfill_interpolate_group_change(GapFillInterpolateColumnState *column, int64 time, Datum value, bool isnull) { column->prev.isnull = true; column->next.isnull = isnull; if (!isnull) { column->next.time = time; column->next.value = datumCopy(value, column->base.typbyval, column->base.typlen); } } /* * gapfill_interpolate_tuple_fetched gets called when a new tuple is fetched from subplan */ void gapfill_interpolate_tuple_fetched(GapFillInterpolateColumnState *column, int64 time, Datum value, bool isnull) { column->next.isnull = isnull; if (!isnull) { column->next.time = time; column->next.value = datumCopy(value, column->base.typbyval, column->base.typlen); } } /* * gapfill_interpolate_tuple_returned gets called when subplan tuple is returned */ void gapfill_interpolate_tuple_returned(GapFillInterpolateColumnState *column, int64 time, Datum value, bool isnull) { column->next.isnull = true; column->prev.isnull = isnull; if (!isnull) { column->prev.time = time; column->prev.value = datumCopy(value, column->base.typbyval, column->base.typlen); } } /* * Do out of bounds lookup for interpolation */ static void gapfill_fetch_sample(GapFillState *state, GapFillInterpolateColumnState *column, GapFillInterpolateSample *sample, Expr *lookup) { HeapTupleHeader th; HeapTupleData tuple; TupleDesc tupdesc; Datum value; bool isnull; Datum datum = gapfill_exec_expr(state, state->scanslot, lookup, &isnull); if (isnull) { sample->isnull = true; return; } th = DatumGetHeapTupleHeader(datum); if (HeapTupleHeaderGetNatts(th) != 2) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("interpolate RECORD arguments must have 2 elements"))); /* Extract type information from the tuple itself */ Assert(RECORDOID == HeapTupleHeaderGetTypeId(th)); tupdesc = lookup_rowtype_tupdesc(HeapTupleHeaderGetTypeId(th), HeapTupleHeaderGetTypMod(th)); /* Build a temporary HeapTuple control structure */ tuple.t_len = HeapTupleHeaderGetDatumLength(th); ItemPointerSetInvalid(&(tuple.t_self)); tuple.t_tableOid = InvalidOid; tuple.t_data = th; /* check first element in record matches timestamp datatype */ if (TupleDescAttr(tupdesc, 0)->atttypid != state->columns[state->time_index]->typid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("first argument of interpolate returned record must match used timestamp " "datatype"), errdetail("Returned type %s does not match expected type %s.", format_type_be(TupleDescAttr(tupdesc, 0)->atttypid), format_type_be(column->base.typid)))); /* check second element in record matches interpolate datatype */ if (TupleDescAttr(tupdesc, 1)->atttypid != column->base.typid) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("second argument of interpolate returned record must match used " "interpolate datatype"), errdetail("Returned type %s does not match expected type %s.", format_type_be(TupleDescAttr(tupdesc, 1)->atttypid), format_type_be(column->base.typid)))); value = heap_getattr(&tuple, 1, tupdesc, &sample->isnull); if (!sample->isnull) { sample->time = gapfill_datum_get_internal(value, state->gapfill_typid); value = heap_getattr(&tuple, 2, tupdesc, &sample->isnull); if (!sample->isnull) sample->value = datumCopy(value, column->base.typbyval, column->base.typlen); } ReleaseTupleDesc(tupdesc); } /* Calculate the interpolation using numerics, returning the result as a numeric datum */ static Datum interpolate_numeric(int64 x_i, int64 x0_i, int64 x1_i, Datum y0, Datum y1) { Datum x0 = DirectFunctionCall1(int8_numeric, Int64GetDatum(x0_i)); Datum x1 = DirectFunctionCall1(int8_numeric, Int64GetDatum(x1_i)); Datum x = DirectFunctionCall1(int8_numeric, Int64GetDatum(x_i)); Datum x1_sub_x = DirectFunctionCall2(numeric_sub, x1, x); Datum x_sub_x0 = DirectFunctionCall2(numeric_sub, x, x0); Datum y0_mul_x1_sub_x = DirectFunctionCall2(numeric_mul, y0, x1_sub_x); Datum y1_mul_x_sub_x0 = DirectFunctionCall2(numeric_mul, y1, x_sub_x0); Datum numerator = DirectFunctionCall2(numeric_add, y0_mul_x1_sub_x, y1_mul_x_sub_x0); Datum denominator = DirectFunctionCall2(numeric_sub, x1, x0); return DirectFunctionCall2(numeric_div, numerator, denominator); } /* * gapfill_interpolate_calculate gets called for every gapfilled tuple to calculate values * * Calculate linear interpolation value * y = (y0(x1-x) + y1(x-x0))/(x1-x0) */ void gapfill_interpolate_calculate(GapFillInterpolateColumnState *column, GapFillState *state, int64 time, Datum *value, bool *isnull) { int64 x, x0, x1; Datum y0, y1; /* only evaluate expr for first tuple */ if (column->prev.isnull && column->lookup_before && time == state->gapfill_start) gapfill_fetch_sample(state, column, &column->prev, column->lookup_before); if (column->next.isnull && column->lookup_after && (FETCHED_LAST == state->state || FETCHED_NEXT_GROUP == state->state)) gapfill_fetch_sample(state, column, &column->next, column->lookup_after); *isnull = column->prev.isnull || column->next.isnull; if (*isnull) return; y0 = column->prev.value; y1 = column->next.value; x = time; x0 = column->prev.time; x1 = column->next.time; switch (column->base.typid) { /* All integer types must use numeric-based interpolation calculations since they are * multiplied by int64 and this could cause an overflow. numerics also interpolate better * because the answer is rounded and not truncated. We can't use float8 because that doesn't handle really big ints exactly. We can't use the Postgres INT128 implementation because it doesn't support division. */ case INT2OID: *value = DirectFunctionCall1(numeric_int2, interpolate_numeric(x, x0, x1, DirectFunctionCall1(int2_numeric, y0), DirectFunctionCall1(int2_numeric, y1))); break; case INT4OID: *value = DirectFunctionCall1(numeric_int4, interpolate_numeric(x, x0, x1, DirectFunctionCall1(int4_numeric, y0), DirectFunctionCall1(int4_numeric, y1))); break; case INT8OID: *value = DirectFunctionCall1(numeric_int8, interpolate_numeric(x, x0, x1, DirectFunctionCall1(int8_numeric, y0), DirectFunctionCall1(int8_numeric, y1))); break; case FLOAT4OID: /* Shortcircuit calculation when y0 == y1 for float because otherwise * output will be unstable for certain values due to float rounding. */ if (DatumGetFloat4(y0) == DatumGetFloat4(y1)) *value = y0; else *value = Float4GetDatum(INTERPOLATE(x, x0, x1, DatumGetFloat4(y0), DatumGetFloat4(y1))); break; case FLOAT8OID: /* Shortcircuit calculation when y0 == y1 for float because otherwise * output will be unstable for certain values due to float rounding. */ if (DatumGetFloat8(y0) == DatumGetFloat8(y1)) *value = y0; else *value = Float8GetDatum(INTERPOLATE(x, x0, x1, DatumGetFloat8(y0), DatumGetFloat8(y1))); break; default: /* * should never happen since interpolate is not defined for other * datatypes */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("unsupported datatype for interpolate: %s", format_type_be(column->base.typid)))); pg_unreachable(); break; } } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/interpolate.h����������������������������������������������0000664�0000000�0000000�00000002043�15100345067�0022670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "gapfill_internal.h" typedef struct GapFillInterpolateSample { int64 time; Datum value; bool isnull; } GapFillInterpolateSample; typedef struct GapFillInterpolateColumnState { GapFillColumnState base; Expr *lookup_before; Expr *lookup_after; GapFillInterpolateSample prev; GapFillInterpolateSample next; } GapFillInterpolateColumnState; void gapfill_interpolate_initialize(GapFillInterpolateColumnState *, GapFillState *, FuncExpr *); void gapfill_interpolate_group_change(GapFillInterpolateColumnState *, int64, Datum, bool); void gapfill_interpolate_tuple_fetched(GapFillInterpolateColumnState *, int64, Datum, bool); void gapfill_interpolate_tuple_returned(GapFillInterpolateColumnState *, int64, Datum, bool); void gapfill_interpolate_calculate(GapFillInterpolateColumnState *, GapFillState *, int64, Datum *, bool *); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/locf.c�����������������������������������������������������0000664�0000000�0000000�00000004241�15100345067�0021262�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_type.h> #include <utils/datum.h> #include "gapfill_internal.h" #include "locf.h" /* * gapfill_locf_initialize gets called when plan is initialized for every locf column */ void gapfill_locf_initialize(GapFillLocfColumnState *locf, GapFillState *state, FuncExpr *function) { locf->isnull = true; /* check if out of boundary lookup expression was supplied */ if (list_length(function->args) > 1) locf->lookup_last = gapfill_adjust_varnos(state, lsecond(function->args)); /* check if treat_null_as_missing was supplied */ if (list_length(function->args) > 2) { Const *treat_null_as_missing = lthird(function->args); if (!IsA(treat_null_as_missing, Const) || treat_null_as_missing->consttype != BOOLOID) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "invalid locf argument: treat_null_as_missing must be a BOOL literal"))); if (!treat_null_as_missing->constisnull) locf->treat_null_as_missing = DatumGetBool(treat_null_as_missing->constvalue); } } /* * gapfill_locf_group_change gets called when a new aggregation group becomes active */ void gapfill_locf_group_change(GapFillLocfColumnState *locf) { locf->isnull = true; } /* * gapfill_locf_tuple_returned gets called when subplan tuple is returned */ void gapfill_locf_tuple_returned(GapFillLocfColumnState *locf, Datum value, bool isnull) { locf->isnull = isnull; if (!isnull) locf->value = datumCopy(value, locf->base.typbyval, locf->base.typlen); } /* * gapfill_locf_calculate gets called for every gapfilled tuple to calculate values */ void gapfill_locf_calculate(GapFillLocfColumnState *locf, GapFillState *state, TupleTableSlot *ecxt_slot, int64 time, Datum *value, bool *isnull) { /* only evaluate expr for first tuple */ if (locf->isnull && locf->lookup_last && time == state->gapfill_start) locf->value = gapfill_exec_expr(state, ecxt_slot, locf->lookup_last, &locf->isnull); *value = locf->value; *isnull = locf->isnull; } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/gapfill/locf.h�����������������������������������������������������0000664�0000000�0000000�00000001374�15100345067�0021273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "gapfill_internal.h" typedef struct GapFillLocfColumnState { GapFillColumnState base; Expr *lookup_last; Datum value; bool isnull; bool treat_null_as_missing; } GapFillLocfColumnState; void gapfill_locf_initialize(GapFillLocfColumnState *, GapFillState *, FuncExpr *); void gapfill_locf_group_change(GapFillLocfColumnState *); void gapfill_locf_tuple_returned(GapFillLocfColumnState *, Datum, bool); void gapfill_locf_calculate(GapFillLocfColumnState *, GapFillState *, TupleTableSlot *, int64, Datum *, bool *); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/skip_scan/���������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020526�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/skip_scan/CMakeLists.txt�������������������������������������������0000664�0000000�0000000�00000000231�15100345067�0023262�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/planner.c ${CMAKE_CURRENT_SOURCE_DIR}/exec.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/skip_scan/README.md������������������������������������������������0000664�0000000�0000000�00000005767�15100345067�0022024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# SkipScan # This module implements SkipScan; an optimization for `SELECT DISTINCT ON`. Usually for `SELECT DISTINCT ON` Postgres will plan either a `UNIQUE` over a sorted path, or some form of aggregate. In either case, it needs to scan the entire table, even in cases where there are only a few unique values. A skip scan optimizes this case when we have an ordered index. Instead of scanning the entire table and deduplicating after, the scan remembers the last value returned, and searches the index for the next value after that one. This means that for a table with `k` keys, with `u` distinct values, a skip scan runs in time `u * log(k)` as opposed to scanning then deduplicating, which takes time `k`. We can write the number of unique values `u` as of function of `k` by dividing by the number of repeats `r` i.e. `u = k/r` this means that a skip scan will be faster if each key is repeated more than a logarithmic number of times, i.e. if `r > log(k)` then `u * log(k) < k/log(k) * log(k) < k`. ## Implementation ## We plan our skip scan with a tree something like ```SQL Custom Scan (SkipScan) on table -> Index Scan using table_key_idx on table Index Cond: (key > NULL) ``` After each iteration through the `SkipScan` we replace the `key > NULL` with a `key > [next value we are returning]` and restart the underlying `IndexScan`. There are some subtleties around `NULL` handling, see the source file for more detail. ## Planning Heuristics ## To plan our SkipScan we look for a compatible plan, for instance ```SQL Unique -> Index Scan ``` or ```SQL Unique -> Merge Append -> Index Scan ... ``` given such a plan, we know the index is sorted in an order with the distinct key(s) first, so we can add quals to the `IndexScan` representing the previous key returned, and thus skip over the repeated values. The `Unique` node tells us which columns are relevant. We use this to create plans that look like ```SQL Unique -> Custom Scan (SkipScan) on skip_scan -> Index Scan using skip_scan_dev_name_idx on skip_scan ``` or ```SQL Unique -> Merge Append Sort Key: _hyper_2_1_chunk.dev_name -> Custom Scan (SkipScan) on _hyper_2_1_chunk -> Index Scan using _hyper_2_1_chunk_idx on _hyper_2_1_chunk -> Custom Scan (SkipScan) on _hyper_2_2_chunk -> Index Scan using _hyper_2_2_chunk_idx on _hyper_2_2_chunk ``` respectively. While we could remove the top-level Unique node for the single chunk/normal table case we keep it so we don't need to support projection as postgres won't modify the SkipScan targetlist that way. ## Postgres-Native Skip Scan ## Upstream postgres is also working on a skip scan implementation, see e.g. https://commitfest.postgresql.org/32/1741/ As when this document was first written, it is not yet merged. Their strategy involves integrating this functionality into the btree searching code, and will be available in PG15 at the earliest. The two implementations should not interfere with eachother. ���������timescaledb-2.23.0/tsl/src/nodes/skip_scan/exec.c���������������������������������������������������0000664�0000000�0000000�00000044171�15100345067�0021625�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * SkipScan is an optimized form of SELECT DISTINCT ON (column) * Conceptually, a SkipScan is a regular IndexScan with an additional skip-qual like * WHERE column > [previous value of column] * * Implementing this qual is complicated by two factors: * 1. The first time through the SkipScan there is no previous value for the * DISTINCT column. * 2. NULL values don't behave nicely with ordering operators. * * To get around these issues, we have to special case those two cases. All in * all, the SkipScan's state machine evolves according to the following flowchart * * start * | * +================================+ * | search for NULL if NULLS FIRST | * +================================+ * | * v * +=====================+ +==============================+ * | search for non-NULL |--found-->| search for values after prev | * +=====================+ value +==============================+ * | | * v v * +================================+ * | search for NULL if NULLS LAST | * +================================+ * | * v * /===========\ * | DONE | * \===========/ * * * * N-key SkipScan needs to do 2^N null check stages when using the above scheme, * made even more complicated with having to change searches for previous keys. * * So we made a decision to support multikey SkipScan in NOT NULL mode only. * * For N-key SkipScan we search with these predicates when current key = K: * (key_1 = prev_1),...,(key_K > prev_K),(key_K+1 IS NOT NULL)...(key_N IS NOT NULL) * * As all skip keys are NOT NULL, "IS NOT NULL" fetches the tuple with no previous value. * * We start the search with K=1 i.e. with these predicates: * (key_1 IS NOT NULL),...,(key_N IS NOT NULL). * * When a tuple is fetched we set K=N as we can fill all previous values, search is now: * (key_1 = prev_1),...,(key_N > prev_N) * * When no tuple is fetched and K>1 we can relax the search and move to previous key (K-1): * (key_1 = prev_1),...,(key_K-1 > prev_K-1),(key_K IS NOT NULL)...(key_N IS NOT NULL) * * When no tuple is fetched and K=1, we are done. * * Multikey SkipScan flowchart: * start (K=1) * | +---------+ * | | | * v v | * +=================================+ | * | search for NOT NULL after K | | * +=================================+ | * | | | * | found value | | * v | | * +==============================+ | | * | search for values after prev | | | * +==============================+ | | * | | | * | no value | | * v v | * +======================+ | * | K=1 | K>1 | * v v | * /===========\ +=========+ | * | DONE | | K = K-1 |---+ * \===========/ +=========+ * */ #include <postgres.h> #include <access/genam.h> #include <access/nbtree.h> #include <nodes/extensible.h> #include <nodes/pg_list.h> #include <utils/datum.h> #include "guc.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/columnar_scan/exec.h" #include "nodes/skip_scan/skip_scan.h" typedef enum SkipScanStage { SS_BEGIN = 0, SS_NULLS_FIRST, SS_NOT_NULL, SS_VALUES, SS_NULLS_LAST, SS_PREV_KEY, SS_END, } SkipScanStage; typedef struct SkipKeyData { ScanKey skip_key; /* Comparison value filled in at runtime */ Datum prev_datum; bool prev_is_null; /* Info about the type we are performing DISTINCT on */ bool distinct_by_val; int distinct_col_attnum; int distinct_typ_len; int sk_attno; SkipKeyNullStatus nulls; } SkipKeyData; typedef struct SkipScanState { CustomScanState cscan_state; IndexScanDesc *scan_desc; MemoryContext ctx; /* Interior Index(Only)Scan the SkipScan runs over */ ScanState *idx; /* Pointers into the Index(Only)Scan */ int *num_scan_keys; ScanKey *scan_keys; int num_skip_keys; SkipKeyData *skip_keys; /* Skip key with ">" qual, coming after "=" skip quals for multikey SkipScan */ int current_key; /* For Multikey SkipScan we keep copies of "sk_func" for "=" and ">" for keys 1..N-1 * to be swapped during execution. */ FmgrInfo *eq_funcs; /* Will be filled after IndexScan scankeys have been initialized */ FmgrInfo *comp_funcs; StrategyNumber *comp_strategies; SkipScanStage stage; /* rescan required before getting next tuple */ bool needs_rescan; /* child_plan node is the input for skip scan plan node. * if skip scan is directly over index scan, child_plan = idx_scan * if skip scan is over compressed chunk, * idx_scan = compressed index scan, * child_plan = decompressed input into skip scan */ Plan *child_plan; void *idx_scan; } SkipScanState; static bool has_nulls_first(SkipScanState *state); static bool has_nulls_last(SkipScanState *state); static void skip_scan_rescan_index(SkipScanState *state); static void skip_scan_switch_stage(SkipScanState *state, SkipScanStage new_stage); static void skip_scan_begin(CustomScanState *node, EState *estate, int eflags) { SkipScanState *state = (SkipScanState *) node; state->ctx = AllocSetContextCreate(estate->es_query_cxt, "skipscan", ALLOCSET_DEFAULT_SIZES); node->custom_ps = list_make1((ScanState *) ExecInitNode(state->child_plan, estate, eflags)); ScanState *child_state = linitial(node->custom_ps); if (state->child_plan == state->idx_scan) { state->idx = child_state; } else if (IsA(child_state, CustomScanState)) { Assert(ts_is_columnar_scan_plan(state->child_plan)); state->idx = linitial(castNode(CustomScanState, child_state)->custom_ps); } else elog(ERROR, "unknown subscan type in SkipScan"); if (IsA(state->idx_scan, IndexScan)) { IndexScanState *idx = castNode(IndexScanState, state->idx); state->scan_keys = &idx->iss_ScanKeys; state->num_scan_keys = &idx->iss_NumScanKeys; state->scan_desc = &idx->iss_ScanDesc; } else if (IsA(state->idx_scan, IndexOnlyScan)) { IndexOnlyScanState *idx = castNode(IndexOnlyScanState, state->idx); state->scan_keys = &idx->ioss_ScanKeys; state->num_scan_keys = &idx->ioss_NumScanKeys; state->scan_desc = &idx->ioss_ScanDesc; } else elog(ERROR, "unknown subscan type in SkipScan"); /* scankeys are not setup for explain only */ if (eflags & EXEC_FLAG_EXPLAIN_ONLY) return; /* find position of our skip key * skip key is put as first key for the respective column in sort_indexquals */ ScanKey scankeydata = *state->scan_keys; int j = 0; for (int i = 0; i < *state->num_scan_keys; i++) { if (scankeydata[i].sk_flags == SK_ISNULL && scankeydata[i].sk_attno == state->skip_keys[j].sk_attno) { SkipKeyData *skipkeydata = &state->skip_keys[j++]; skipkeydata->skip_key = &scankeydata[i]; /* Set up ">" sk_func swaps for skip keys 1..N-1 */ if (j < state->num_skip_keys) { state->comp_strategies[j - 1] = scankeydata[i].sk_strategy; fmgr_info_copy(&state->comp_funcs[j - 1], &scankeydata[i].sk_func, CurrentMemoryContext); } if (j == state->num_skip_keys) break; } } if (j < state->num_skip_keys) elog(ERROR, "ScanKey for skip qual not found"); /* when we fetch the 1st tuple we update all skip keys from 0 to N */ state->current_key = 0; } static bool has_nulls_first(SkipScanState *state) { return state->skip_keys[0].nulls == SK_NULLS_FIRST; } static bool has_nulls_last(SkipScanState *state) { return state->skip_keys[0].nulls == SK_NULLS_LAST; } static void skip_scan_rescan_index(SkipScanState *state) { /* if the scan in the child scan has not been * setup yet which is true before the first tuple * has been retrieved from child scan we cannot * trigger rescan but since the child scan * has not been initialized it will pick up * any ScanKey changes we did */ if (*state->scan_desc) { index_rescan(*state->scan_desc, *state->scan_keys, *state->num_scan_keys, NULL /*orderbys*/, 0 /*norderbys*/); /* Discard current compressed index tuple as we are ready to move to the next compressed * tuple via SkipScan */ ScanState *child = linitial(state->cscan_state.custom_ps); if (ts_is_columnar_scan_plan(state->child_plan)) { ColumnarScanState *ds = (ColumnarScanState *) child; TupleTableSlot *slot = ds->batch_queue->funcs->top_tuple(ds->batch_queue); if (slot) { compressed_batch_discard_tuples((DecompressBatchState *) slot); } } } state->needs_rescan = false; } /* * Update skip scankey flags according to stage */ static void skip_scan_switch_stage(SkipScanState *state, SkipScanStage new_stage) { Assert(new_stage > state->stage || state->num_skip_keys > 1); switch (new_stage) { case SS_NOT_NULL: for (int i = 0; i < state->num_skip_keys; i++) { state->skip_keys[i].skip_key->sk_flags = SK_ISNULL | SK_SEARCHNOTNULL; state->skip_keys[i].skip_key->sk_argument = 0; } state->current_key = 0; state->needs_rescan = true; break; case SS_PREV_KEY: /* Done searching with ">" for this key: set this key to NOT NULL i.e. any value, * set previous "=" key to search with ">". */ state->skip_keys[state->current_key].skip_key->sk_flags = SK_ISNULL | SK_SEARCHNOTNULL; state->current_key--; state->skip_keys[state->current_key].skip_key->sk_flags = 0; fmgr_info_copy(&state->skip_keys[state->current_key].skip_key->sk_func, &state->comp_funcs[state->current_key], CurrentMemoryContext); state->skip_keys[state->current_key].skip_key->sk_strategy = state->comp_strategies[state->current_key]; state->needs_rescan = true; break; case SS_VALUES: for (int i = 0; i < state->num_skip_keys; i++) { state->skip_keys[i].skip_key->sk_flags = 0; /* reset all ">" back to "=" from the current key to N-1 */ if (i >= state->current_key && i < state->num_skip_keys - 1) { fmgr_info_copy(&state->skip_keys[i].skip_key->sk_func, &state->eq_funcs[i], CurrentMemoryContext); state->skip_keys[i].skip_key->sk_strategy = BTEqualStrategyNumber; } } state->current_key = state->num_skip_keys - 1; state->needs_rescan = true; break; case SS_NULLS_LAST: case SS_NULLS_FIRST: state->skip_keys[0].skip_key->sk_flags = SK_ISNULL | SK_SEARCHNULL; state->skip_keys[0].skip_key->sk_argument = 0; state->needs_rescan = true; break; case SS_BEGIN: case SS_END: break; } state->stage = new_stage; } static void skip_scan_update_key(SkipScanState *state, TupleTableSlot *slot) { for (int i = state->current_key; i < state->num_skip_keys; i++) { if (!state->skip_keys[i].prev_is_null && !state->skip_keys[i].distinct_by_val) { Assert(state->stage == SS_VALUES || state->num_skip_keys > 1); pfree(DatumGetPointer(state->skip_keys[i].prev_datum)); } MemoryContext old_ctx = MemoryContextSwitchTo(state->ctx); state->skip_keys[i].prev_datum = slot_getattr(slot, state->skip_keys[i].distinct_col_attnum, &state->skip_keys[i].prev_is_null); if (state->skip_keys[i].prev_is_null) { state->skip_keys[i].skip_key->sk_flags = SK_ISNULL; state->skip_keys[i].skip_key->sk_argument = 0; } else { state->skip_keys[i].prev_datum = datumCopy(state->skip_keys[i].prev_datum, state->skip_keys[i].distinct_by_val, state->skip_keys[i].distinct_typ_len); state->skip_keys[i].skip_key->sk_argument = state->skip_keys[i].prev_datum; } MemoryContextSwitchTo(old_ctx); } /* we need to do a rescan whenever we modify the ScanKey */ state->needs_rescan = true; } static TupleTableSlot * skip_scan_exec(CustomScanState *node) { SkipScanState *state = (SkipScanState *) node; TupleTableSlot *result; ScanState *child_state; /* * We are not supporting projection here since no plan * we generate will need it as our SkipScan node will * always be below Unique need so our targetlist * will not get modified by postgres. */ Assert(!node->ss.ps.ps_ProjInfo); while (true) { if (state->needs_rescan) skip_scan_rescan_index(state); switch (state->stage) { case SS_BEGIN: if (has_nulls_first(state)) skip_scan_switch_stage(state, SS_NULLS_FIRST); else skip_scan_switch_stage(state, SS_NOT_NULL); break; case SS_NULLS_FIRST: child_state = linitial(state->cscan_state.custom_ps); result = child_state->ps.ExecProcNode(&child_state->ps); /* * if we found a NULL value we return it, otherwise * we restart the scan looking for non-NULL */ skip_scan_switch_stage(state, SS_NOT_NULL); if (!TupIsNull(result)) return result; break; case SS_NOT_NULL: case SS_PREV_KEY: case SS_VALUES: child_state = linitial(state->cscan_state.custom_ps); result = child_state->ps.ExecProcNode(&child_state->ps); if (!TupIsNull(result)) { /* * if we found a tuple we update the skip scan key * and look for values greater than the value we just * found. If this is the first non-NULL value we * also switch stage to look for values greater than * that in subsequent calls. */ skip_scan_update_key(state, result); if (state->stage == SS_NOT_NULL || state->stage == SS_PREV_KEY) skip_scan_switch_stage(state, SS_VALUES); return result; } else { /* * if there are no more values that satisfy * the skip constraint we are either done * for NULLS FIRST ordering or need to check * for NULLs if we have NULLS LAST ordering * * Or we can move back one key for multikey SkipScan to relax the search, * i.e. make current key NOT NULL (any value) and change previous search from * "=" to ">" */ if (has_nulls_last(state)) skip_scan_switch_stage(state, SS_NULLS_LAST); else if (state->current_key > 0) skip_scan_switch_stage(state, SS_PREV_KEY); else skip_scan_switch_stage(state, SS_END); } break; case SS_NULLS_LAST: child_state = linitial(state->cscan_state.custom_ps); result = child_state->ps.ExecProcNode(&child_state->ps); skip_scan_switch_stage(state, SS_END); return result; break; case SS_END: return NULL; break; } } } static void skip_scan_end(CustomScanState *node) { SkipScanState *state = (SkipScanState *) node; ScanState *child_state = linitial(state->cscan_state.custom_ps); ExecEndNode(&child_state->ps); } static void skip_scan_rescan(CustomScanState *node) { SkipScanState *state = (SkipScanState *) node; /* reset stage so we can assert in skip_scan_switch_stage that stage always moves forward */ state->stage = SS_BEGIN; /* Switching state here instead of in the main loop * means we dont have to call skip_scan_rescan_index * as ExecReScan on the child scan takes care of that. */ if (has_nulls_first(state)) skip_scan_switch_stage(state, SS_NULLS_FIRST); else skip_scan_switch_stage(state, SS_NOT_NULL); for (int i = 0; i < state->num_skip_keys; i++) { state->skip_keys[i].prev_is_null = true; state->skip_keys[i].prev_datum = 0; } state->needs_rescan = false; ScanState *child_state = linitial(state->cscan_state.custom_ps); ExecReScan(&child_state->ps); MemoryContextReset(state->ctx); } static CustomExecMethods skip_scan_state_methods = { .CustomName = "SkipScanState", .BeginCustomScan = skip_scan_begin, .EndCustomScan = skip_scan_end, .ExecCustomScan = skip_scan_exec, .ReScanCustomScan = skip_scan_rescan, }; Node * tsl_skip_scan_state_create(CustomScan *cscan) { SkipScanState *state = (SkipScanState *) newNode(sizeof(SkipScanState), T_CustomScanState); state->child_plan = linitial(cscan->custom_plans); if (ts_is_columnar_scan_plan(state->child_plan)) { CustomScan *csplan = castNode(CustomScan, state->child_plan); state->idx_scan = linitial(csplan->custom_plans); } else { state->idx_scan = state->child_plan; } state->stage = SS_BEGIN; /* set up N skipkeyinfos for N skip keys */ List *skinfos = (List *) linitial(cscan->custom_private); state->num_skip_keys = list_length(skinfos); state->skip_keys = palloc(sizeof(SkipKeyData) * state->num_skip_keys); ListCell *lc; int i = 0; foreach (lc, skinfos) { List *skipkeyinfo = (List *) lfirst(lc); state->skip_keys[i].distinct_col_attnum = list_nth_int(skipkeyinfo, SK_DistinctColAttno); state->skip_keys[i].distinct_by_val = list_nth_int(skipkeyinfo, SK_DistinctByVal); state->skip_keys[i].distinct_typ_len = list_nth_int(skipkeyinfo, SK_DistinctTypeLen); state->skip_keys[i].nulls = list_nth_int(skipkeyinfo, SK_NullStatus); Assert(state->num_skip_keys == 1 || state->skip_keys[i].nulls == SK_NOT_NULL); state->skip_keys[i].sk_attno = list_nth_int(skipkeyinfo, SK_IndexKeyAttno); state->skip_keys[i].prev_is_null = true; i++; } state->eq_funcs = NULL; state->comp_funcs = NULL; state->comp_strategies = NULL; /* set up N-1 equality ops for N skip keys if N>1 */ if (state->num_skip_keys > 1) { /* Should have a list of N-1 equality op Oids for N skip keys if N>1 */ Assert(list_length(cscan->custom_private) == 2); List *eqoids = (List *) lsecond(cscan->custom_private); state->eq_funcs = palloc(sizeof(FmgrInfo) * (state->num_skip_keys - 1)); state->comp_funcs = palloc(sizeof(FmgrInfo) * (state->num_skip_keys - 1)); state->comp_strategies = palloc(sizeof(StrategyNumber) * (state->num_skip_keys - 1)); int i = 0; /* Set up "=" sk_funcs for keys 1..N-1 */ foreach (lc, eqoids) { Oid eqoid = lfirst_oid(lc); Assert(OidIsValid(eqoid)); fmgr_info(eqoid, &state->eq_funcs[i++]); } Assert(i == state->num_skip_keys - 1); } state->cscan_state.methods = &skip_scan_state_methods; return (Node *) state; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/skip_scan/planner.c������������������������������������������������0000664�0000000�0000000�00000131472�15100345067�0022341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/sysattr.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/pathnodes.h> #include <optimizer/clauses.h> #include <optimizer/cost.h> #include <optimizer/optimizer.h> #include <optimizer/pathnode.h> #include <optimizer/paths.h> #include <optimizer/planmain.h> #include <optimizer/prep.h> #include <optimizer/restrictinfo.h> #include <optimizer/tlist.h> #include <parser/parse_coerce.h> #include <parser/parsetree.h> #include <rewrite/rewriteManip.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "compat/compat.h" #include "guc.h" #include "nodes/chunk_append/chunk_append.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/constraint_aware_append/constraint_aware_append.h" #include "nodes/skip_scan/skip_scan.h" #include <import/planner.h> #include <math.h> typedef struct SkipKeyInfo { /* Index clause which we'll use to skip past elements we've already seen */ RestrictInfo *skip_clause; /* Is this key guaranteed to be not null? */ bool notnull; /* attribute number of the distinct column on the table/chunk which provides comparison value * for Skip qual */ AttrNumber distinct_attno; /* attribute number of the Skip qual comparison column on the indexed table/chunk * "indexed_column_attno = distinct_attno" for (SkipScan <- Index Scan) scenario, * it can be different for (SkipScan <- ColumnarScan <- compressed Index Scan) scenario, * in that case "indexed_column_attno" is the attribute number of the compressed chunk column * corresponding to the distinct column "distinct_attno" on the decompressed chunk consumed by * SkipScan */ AttrNumber indexed_column_attno; /* The column offset on the index we are calling DISTINCT on */ AttrNumber scankey_attno; int distinct_typ_len; bool distinct_by_val; /* InvalidOid for the last skip key, always invalid for one-key SkipScan * For N-key SkipScan default quals are (sk1 = p1), (sk2 = p2), .. (sk_n > p_n), * we'll switch to (sk_i > p_i) when no more values for (sk_i+1 > p_i+1), * so we will store "=" along with ">" comparator for keys 1..N-1. */ Oid eqcomp; } SkipKeyInfo; typedef struct SkipScanPath { CustomPath cpath; IndexPath *index_path; /* List of skip column attributes for each skip key */ List *skipkeyinfo; /* Vars referencing the distinct columns on the relation */ List *dvars; } SkipScanPath; typedef struct DistinctPathInfo { UpperRelationKind stage; /* What kind of Upper distinct path we are dealing with */ Path *unique_path; /* If not NULL, valid Upper distinct path */ List * distinct_expr; /* If not NULL, list of valid distinct expressions for Upper distinct path */ } DistinctPathInfo; static int get_idx_key(IndexOptInfo *idxinfo, AttrNumber attno); static List *sort_indexquals(IndexOptInfo *indexinfo, List *quals); static OpExpr *fix_indexqual(IndexOptInfo *index, RestrictInfo *rinfo, AttrNumber scankey_attno); static bool build_skip_qual(PlannerInfo *root, SkipKeyInfo *skinfo, IndexPath *index_path, Var *var, bool build_eqop); static List *build_subpath(PlannerInfo *root, List *subpaths, DistinctPathInfo *dpinfo, List *top_pathkeys); static Var *get_distinct_var(PlannerInfo *root, Expr *tlexpr, IndexPath *index_path, Path *child_path, SkipKeyInfo *skinfo); static TargetEntry *tlist_member_match_var(Var *var, List *targetlist); /************************** * SkipScan Plan Creation * **************************/ static CustomScanMethods skip_scan_plan_methods = { .CustomName = "SkipScan", .CreateCustomScanState = tsl_skip_scan_state_create, }; void _skip_scan_init(void) { TryRegisterCustomScanMethods(&skip_scan_plan_methods); } static Plan * setup_index_plan(CustomScan *skip_plan, Plan *child_plan) { Plan *plan = child_plan; if (IsA(child_plan, IndexScan)) { skip_plan->scan = castNode(IndexScan, child_plan)->scan; } else if (IsA(child_plan, IndexOnlyScan)) { skip_plan->scan = castNode(IndexOnlyScan, child_plan)->scan; } else if (ts_is_columnar_scan_plan(child_plan)) { CustomScan *csplan = castNode(CustomScan, plan); skip_plan->scan = csplan->scan; plan = linitial(csplan->custom_plans); } else elog(ERROR, "unsupported subplan type for SkipScan: %s", ts_get_node_name((Node *) child_plan)); return plan; } static Plan * skip_scan_plan_create(PlannerInfo *root, RelOptInfo *relopt, CustomPath *best_path, List *tlist, List *clauses, List *custom_plans) { SkipScanPath *path = (SkipScanPath *) best_path; CustomScan *skip_plan = makeNode(CustomScan); IndexPath *index_path = path->index_path; Plan *child_plan = linitial(custom_plans); Plan *plan = setup_index_plan(skip_plan, child_plan); skip_plan->scan.plan.targetlist = tlist; skip_plan->custom_scan_tlist = list_copy(tlist); skip_plan->scan.plan.qual = NIL; skip_plan->scan.plan.type = T_CustomScan; skip_plan->methods = &skip_scan_plan_methods; skip_plan->custom_plans = custom_plans; /* Setup for SkipScan debug info */ StringInfoData debuginfo; RangeTblEntry *indexed_rte = NULL; char *sep = ""; if (ts_guc_debug_skip_scan_info) { initStringInfo(&debuginfo); RelOptInfo *indexed_rel = index_path->path.parent; indexed_rte = planner_rt_fetch(indexed_rel->relid, root); Oid indrelid = InvalidOid; if (IsA(plan, IndexScan)) { IndexScan *idx_plan = castNode(IndexScan, plan); indrelid = idx_plan->indexid; } else if (IsA(plan, IndexOnlyScan)) { IndexOnlyScan *idx_plan = castNode(IndexOnlyScan, plan); indrelid = idx_plan->indexid; } appendStringInfo(&debuginfo, "SkipScan used on %s(", get_rel_name(indrelid)); } ListCell *lc, *lv; /* List of N-1 equality op Oids for N-key skipscan, stays NIL for one-key skipscan */ List *eqcomps = NIL; /* List of N skipkeyinfo Int lists for N-key skipscan */ List *skinfos = NIL; forboth (lc, path->skipkeyinfo, lv, path->dvars) { SkipKeyInfo *skinfo = (SkipKeyInfo *) lfirst(lc); Var *dvar = castNode(Var, lfirst(lv)); OpExpr *op = fix_indexqual(index_path->indexinfo, skinfo->skip_clause, skinfo->scankey_attno); if (OidIsValid(skinfo->eqcomp)) eqcomps = lappend_oid(eqcomps, skinfo->eqcomp); if (IsA(plan, IndexScan)) { IndexScan *idx_plan = castNode(IndexScan, plan); /* we prepend skip qual here so sort_indexquals will put it as first qual for that * column */ idx_plan->indexqual = sort_indexquals(index_path->indexinfo, lcons(op, idx_plan->indexqual)); } else if (IsA(plan, IndexOnlyScan)) { IndexOnlyScan *idx_plan = castNode(IndexOnlyScan, plan); /* we prepend skip qual here so sort_indexquals will put it as first qual for that * column */ idx_plan->indexqual = sort_indexquals(index_path->indexinfo, lcons(op, idx_plan->indexqual)); } else elog(ERROR, "unsupported subplan type for SkipScan: %s", ts_get_node_name((Node *) plan)); /* get position of distinct column in tuples produced by child scan */ TargetEntry *tle = tlist_member_match_var(dvar, child_plan->targetlist); SkipKeyNullStatus sknulls; if (skinfo->notnull) sknulls = SK_NOT_NULL; else { bool nulls_first = index_path->indexinfo->nulls_first[skinfo->scankey_attno - 1]; if (index_path->indexscandir == BackwardScanDirection) nulls_first = !nulls_first; sknulls = (nulls_first ? SK_NULLS_FIRST : SK_NULLS_LAST); } skinfos = lappend(skinfos, list_make5_int(tle->resno, skinfo->distinct_by_val, skinfo->distinct_typ_len, sknulls, skinfo->scankey_attno)); /* Debug info about skip key */ if (ts_guc_debug_skip_scan_info) { char *attname = get_attname(indexed_rte->relid, skinfo->indexed_column_attno, false); appendStringInfo(&debuginfo, "%s%s %s", sep, attname, (sknulls == SK_NOT_NULL ? "NOT NULL" : (sknulls == SK_NULLS_FIRST ? "NULLS FIRST" : "NULLS LAST"))); sep = ", "; } } if (ts_guc_debug_skip_scan_info) { appendStringInfoString(&debuginfo, ")"); elog(INFO, "%s", debuginfo.data); } skip_plan->custom_private = lappend(skip_plan->custom_private, skinfos); /* Don't need equality ops for one-key skipscan */ if (eqcomps != NIL) { Assert(list_length(skinfos) > 1); skip_plan->custom_private = lappend(skip_plan->custom_private, eqcomps); } return &skip_plan->scan.plan; } /************************* * SkipScanPath Creation * *************************/ static CustomPathMethods skip_scan_path_methods = { .CustomName = "SkipScanPath", .PlanCustomPath = skip_scan_plan_create, }; #if PG16_GE typedef struct FindAggrefsContext { List *aggrefs; /* all non-nested Aggrefs found in a node */ } FindAggrefsContext; static bool find_aggrefs_walker(Node *node, FindAggrefsContext *context) { if (node == NULL) return false; if (IsA(node, Aggref)) { context->aggrefs = lappend(context->aggrefs, node); /* don't recurse inside Aggrefs */ return false; } return expression_tree_walker(node, find_aggrefs_walker, context); } #endif static Expr * get_distint_clause_expr(PlannerInfo *root, SortGroupClause *distinct_clause) { Node *expr = get_sortgroupclause_expr(distinct_clause, root->parse->targetList); /* we ignore any columns that can be constified to allow for cases like DISTINCT 'abc', * column */ if (IsA(estimate_expression_value(root, expr), Const)) return NULL; /* We ignore binary-compatible relabeling */ Expr *tlexpr = (Expr *) expr; while (tlexpr && IsA(tlexpr, RelabelType)) tlexpr = ((RelabelType *) tlexpr)->arg; if (!IsA(tlexpr, Var)) return NULL; return tlexpr; } /* We can get upper path Distinct expression once for upper path, * rather than repeat this check for each child path of an upper path input */ static List * get_upper_distinct_expr(PlannerInfo *root, UpperRelationKind stage) { ListCell *lc; Expr *tlexpr = NULL; List *result = NULL; if (stage == UPPERREL_DISTINCT && root->parse->distinctClause) { /* Obtain Distinct key from the target list, we ruled out numkeys > 1 cases before. * Examples of queries with 1 Distinct key but multiple target entries: * SELECT dev, dev FROM t; SELECT 1, dev FROM t; SELECT dev, time FROM t WHERE time = 100; */ SortGroupClause *distinct_clause = NULL; #if PG16_GE foreach (lc, root->processed_distinctClause) { distinct_clause = (SortGroupClause *) lfirst(lc); tlexpr = get_distint_clause_expr(root, distinct_clause); if (tlexpr) result = lappend(result, tlexpr); else return NULL; } #else if (root->distinct_pathkeys) { foreach (lc, root->distinct_pathkeys) { PathKey *pathkey = (PathKey *) lfirst(lc); if (pathkey->pk_eclass->ec_sortref) { foreach (lc, root->parse->distinctClause) { SortGroupClause *clause = lfirst_node(SortGroupClause, lc); if (clause->tleSortGroupRef == pathkey->pk_eclass->ec_sortref) { distinct_clause = clause; break; } } if (!distinct_clause) return NULL; } /* We can get PathKey with ec_sortref = 0 in PG15 * when False filter is not pushed into a relation with distinct column (i.e. it's * on top of a join), so need to support this case in PG15 */ else return NULL; tlexpr = get_distint_clause_expr(root, distinct_clause); if (tlexpr) result = lappend(result, tlexpr); else return NULL; } } /* In PG16+ we use LIMIT instead of UpperUniquePath for (numkeys = 0), * but in PG15- we would still create UpperUniquePath for (numkeys = 0), so handle this case * here */ else { foreach (lc, root->parse->distinctClause) { distinct_clause = lfirst_node(SortGroupClause, lc); tlexpr = get_distint_clause_expr(root, distinct_clause); if (tlexpr) result = lappend(result, tlexpr); else return NULL; } } #endif } #if PG16_GE else if (stage == UPPERREL_GROUP_AGG) { /* Find all non-nested Aggrefs in the query target list */ FindAggrefsContext agg_ctx = { .aggrefs = NULL }; find_aggrefs_walker((Node *) root->parse->targetList, &agg_ctx); foreach (lc, agg_ctx.aggrefs) { Aggref *agg = lfirst_node(Aggref, lc); /* Only distinct aggs with 1 sorted argument are eligible*/ if (agg->aggdistinct && agg->aggpresorted && list_length(agg->args) == 1) { TargetEntry *tle = (TargetEntry *) linitial(agg->args); Expr *expr = tle->expr; /* We ignore binary-compatible relabeling */ while (expr && IsA(expr, RelabelType)) expr = ((RelabelType *) expr)->arg; /* Distinct agg over a Const is OK */ if (IsA(estimate_expression_value(root, (Node *) expr), Const)) continue; /* Don't support no-var arguments */ if (!IsA(expr, Var)) return NULL; /* Don't support multiple distinct aggs over different columns */ if (tlexpr && !tlist_member_match_var((Var *) tlexpr, agg->args)) return NULL; /* If Distinct agg path has a groupby column, it needs to match Distinct agg column */ if (root->processed_groupClause) { /* Should have bailed out on gby exprs > 1 earlier * Only 1-key SkipScan is supported for distinct aggregates */ Assert(list_length(root->processed_groupClause) == 1); SortGroupClause *sortcl = (SortGroupClause *) linitial(root->processed_groupClause); Expr *gbykey = (Expr *) get_sortgroupclause_expr(sortcl, root->processed_tlist); if (!equal(gbykey, expr)) return NULL; } /* Found a valid distinct agg over a valid Var */ if (!tlexpr) { tlexpr = expr; result = lappend(result, tlexpr); } } else { return NULL; } } } #endif return result; } static void obtain_upper_distinct_path(PlannerInfo *root, RelOptInfo *output_rel, DistinctPathInfo *dpinfo) { ListCell *lc; /* * look for Unique Path so we dont have to repeat some of * the calculations done by postgres and can also assume * that the DISTINCT clause is eligible for sort based * DISTINCT */ if (dpinfo->stage == UPPERREL_DISTINCT) { if (!ts_guc_enable_skip_scan) return; foreach (lc, output_rel->pathlist) { if (IsA(lfirst(lc), UpperUniquePath)) { UpperUniquePath *unique = (UpperUniquePath *) lfirst_node(UpperUniquePath, lc); /* We can handle DISTINCT on more than one key if all keys are guaranteed not-nulls. * To do so, we break down the SkipScan into subproblems: first * find the minimal tuple then for each prefix find all unique suffix * tuples. For instance, if we are searching over (int, int), we would * first find (0, 0) then find (0, N) for all N in the domain, then * find (1, N), then (2, N), etc */ if (!ts_guc_enable_multikey_skip_scan && unique->numkeys > 1) return; #if PG16_GE /* since PG16+ we no longer create UpperUniquePath with 0 numkeys, * we create LIMIT path instead, so shouldn't be here with 0 numkeys */ Assert(unique->numkeys >= 1); #endif dpinfo->unique_path = (Path *) unique; break; } } } /* Sorted inputs for Distinct aggs weren't supported until PG16 */ #if PG16_GE /* Look for Aggpath with eligible Distinct aggregates */ else if (dpinfo->stage == UPPERREL_GROUP_AGG) { if (!ts_guc_enable_skip_scan_for_distinct_aggregates) return; /* Cannot apply SkipScan to distinct aggregates with more than one key */ if (list_length(root->group_pathkeys) > 1) return; foreach (lc, output_rel->pathlist) { if (IsA(lfirst(lc), AggPath)) { AggPath *unique = (AggPath *) lfirst_node(AggPath, lc); /* If Distinct agg path has a group key, it must match Distinct aggregate input sort * key, otherwise cannot apply SkipScan */ if (unique->path.pathkeys && !pathkeys_contained_in(unique->path.pathkeys, unique->subpath->pathkeys)) { return; } dpinfo->unique_path = (Path *) lfirst_node(AggPath, lc); break; } } } #endif else return; if (!dpinfo->unique_path) return; /* Check if we have valid distinct expression to source from the underlying index */ dpinfo->distinct_expr = get_upper_distinct_expr(root, dpinfo->stage); if (!dpinfo->distinct_expr) { dpinfo->unique_path = NULL; return; } /* Need to make a copy of the unique path here because add_path() in the * pathlist loop below might prune it if the new unique path * (SkipScanPath) dominates the old one. When the unique path is pruned, * the pointer will no longer be valid in the next iteration of the * pathlist loop. Fortunately, the Path object is not deeply freed, so a * shallow copy is enough. */ if (dpinfo->stage == UPPERREL_DISTINCT) { UpperUniquePath *unique = makeNode(UpperUniquePath); memcpy(unique, lfirst_node(UpperUniquePath, lc), sizeof(UpperUniquePath)); dpinfo->unique_path = (Path *) unique; } else if (dpinfo->stage == UPPERREL_GROUP_AGG) { AggPath *dist_agg_path = makeNode(AggPath); memcpy(dist_agg_path, lfirst_node(AggPath, lc), sizeof(AggPath)); dpinfo->unique_path = (Path *) dist_agg_path; } } static SkipScanPath *skip_scan_path_create(PlannerInfo *root, Path *child_path, DistinctPathInfo *dpinfo); /* * Create SkipScan paths based on existing Unique paths. * For a Unique path on a simple relation like the following * * Unique * -> Index Scan using skip_scan_dev_name_idx on skip_scan * * a SkipScan path like this will be created: * * Unique * -> Custom Scan (SkipScan) on skip_scan * -> Index Scan using skip_scan_dev_name_idx on skip_scan * * For a Unique path on a hypertable with multiple chunks like the following * * Unique * -> Merge Append * Sort Key: _hyper_2_1_chunk.dev_name * -> Index Scan using _hyper_2_1_chunk_idx on _hyper_2_1_chunk * -> Index Scan using _hyper_2_2_chunk_idx on _hyper_2_2_chunk * * a SkipScan path like this will be created: * * Unique * -> Merge Append * Sort Key: _hyper_2_1_chunk.dev_name * -> Custom Scan (SkipScan) on _hyper_2_1_chunk * -> Index Scan using _hyper_2_1_chunk_idx on _hyper_2_1_chunk * -> Custom Scan (SkipScan) on _hyper_2_2_chunk * -> Index Scan using _hyper_2_2_chunk_idx on _hyper_2_2_chunk */ void tsl_skip_scan_paths_add(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel, UpperRelationKind stage) { DistinctPathInfo dpinfo = { .stage = stage, .unique_path = NULL, .distinct_expr = NULL, }; obtain_upper_distinct_path(root, output_rel, &dpinfo); if (!dpinfo.unique_path) return; Assert(IsA(dpinfo.unique_path, UpperUniquePath) || IsA(dpinfo.unique_path, AggPath)); ListCell *lc; foreach (lc, input_rel->pathlist) { bool has_caa = false; Path *subpath = lfirst(lc); List *top_pathkeys = NULL; /* Unique path has to be sorted on at least DISTINCT ON key */ if (IsA(dpinfo.unique_path, UpperUniquePath)) { if (!pathkeys_contained_in(dpinfo.unique_path->pathkeys, subpath->pathkeys)) continue; } /* AggPath with distinct aggs may not be sorted, but the input into distinct aggs needs to * be sorted */ else if (IsA(dpinfo.unique_path, AggPath)) { if (!subpath->pathkeys || !pathkeys_contained_in(dpinfo.unique_path->pathkeys, subpath->pathkeys)) continue; /* Need to check sortedness for inputs of Distinct aggs, so we'll keep track of the * input pathkeys */ top_pathkeys = subpath->pathkeys; } /* If path is a ProjectionPath we strip it off for processing * but also add a ProjectionPath on top of the SKipScanPaths * later. */ ProjectionPath *proj = NULL; if (IsA(subpath, ProjectionPath)) { proj = castNode(ProjectionPath, subpath); subpath = proj->subpath; } /* Path might be wrapped in a ConstraintAwareAppendPath if this * is a MergeAppend that could benefit from runtime exclusion. * We treat this similar to ProjectionPath and add it back * later */ if (ts_is_constraint_aware_append_path(subpath)) { subpath = linitial(castNode(CustomPath, subpath)->custom_paths); Assert(IsA(subpath, MergeAppendPath)); has_caa = true; } if (IsA(subpath, IndexPath) || ts_is_columnar_scan_path(subpath)) { subpath = (Path *) skip_scan_path_create(root, subpath, &dpinfo); if (!subpath) continue; } else if (IsA(subpath, MergeAppendPath)) { MergeAppendPath *merge_path = castNode(MergeAppendPath, subpath); List *new_paths = build_subpath(root, merge_path->subpaths, &dpinfo, top_pathkeys); /* build_subpath returns NULL when no SkipScanPath was created */ if (!new_paths) continue; subpath = (Path *) create_merge_append_path(root, merge_path->path.parent, new_paths, merge_path->path.pathkeys, NULL); subpath->pathtarget = copy_pathtarget(merge_path->path.pathtarget); } /* We may have Append over one input which will be removed from the plan later. * Consider it when it is sorted correctly. #7778 */ else if (IsA(subpath, AppendPath)) { AppendPath *append_path = castNode(AppendPath, subpath); if (list_length(append_path->subpaths) > 1) continue; List *new_paths = build_subpath(root, append_path->subpaths, &dpinfo, top_pathkeys); /* build_subpath returns NULL when no SkipScanPath was created */ if (!new_paths) continue; subpath = (Path *) create_append_path(root, append_path->path.parent, new_paths, NULL, append_path->path.pathkeys, NULL, append_path->path.parallel_workers, append_path->path.parallel_aware, -1); subpath->pathtarget = copy_pathtarget(append_path->path.pathtarget); } else if (ts_is_chunk_append_path(subpath)) { ChunkAppendPath *ca = (ChunkAppendPath *) subpath; List *new_paths = build_subpath(root, ca->cpath.custom_paths, &dpinfo, top_pathkeys); /* ChunkAppend should never be wrapped in ConstraintAwareAppendPath */ Assert(!has_caa); /* build_subpath returns NULL when no SkipScanPath was created */ if (!new_paths) continue; /* We copy the existing ChunkAppendPath here because we don't have all the * information used for creating the original one and we don't want to * duplicate all the checks done when creating the original one. */ subpath = (Path *) ts_chunk_append_path_copy(ca, new_paths, ca->cpath.path.pathtarget); } else { continue; } /* add ConstraintAwareAppendPath if the original path had one */ if (has_caa) subpath = ts_constraint_aware_append_path_create(root, subpath); Path *new_unique = NULL; if (IsA(dpinfo.unique_path, UpperUniquePath)) { UpperUniquePath *unique = (UpperUniquePath *) dpinfo.unique_path; new_unique = (Path *) create_upper_unique_path(root, output_rel, subpath, unique->numkeys, unique->path.rows); new_unique->pathtarget = unique->path.pathtarget; if (proj) new_unique = (Path *) create_projection_path(root, output_rel, new_unique, copy_pathtarget(new_unique->pathtarget)); } else if (IsA(dpinfo.unique_path, AggPath)) { AggPath *dist_agg_path = (AggPath *) dpinfo.unique_path; if (proj) { proj->subpath = subpath; subpath = (Path *) proj; } AggClauseCosts agg_costs; MemSet(&agg_costs, 0, sizeof(AggClauseCosts)); get_agg_clause_costs(root, dist_agg_path->aggsplit, &agg_costs); new_unique = (Path *) create_agg_path(root, output_rel, subpath, dist_agg_path->path.pathtarget, dist_agg_path->aggstrategy, dist_agg_path->aggsplit, dist_agg_path->groupClause, dist_agg_path->qual, (const AggClauseCosts *) &agg_costs, dist_agg_path->numGroups); } add_path(output_rel, new_unique); } } #if PG17_LT static bool attr_is_notnull(Oid relid, AttrNumber attno) { HeapTuple tp = SearchSysCache2(ATTNUM, ObjectIdGetDatum(relid), Int16GetDatum(attno)); if (!HeapTupleIsValid(tp)) return false; Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp); bool result = att_tup->attnotnull; ReleaseSysCache(tp); return result; } #endif /* Check if skip key is guaranteed not-null */ static void check_notnull_skipkey(SkipKeyInfo *skinfo, Path *child_path, IndexPath *index_path) { ListCell *l; /* Quickly look through index clauses on this skip key */ foreach (l, index_path->indexclauses) { IndexClause *ic = (IndexClause *) lfirst(l); /* index quals are ordered by indexcol, nothing to see if we've passed our indexcol */ if (ic->indexcol > skinfo->scankey_attno - 1) break; /* We may have row comparison with skip key not being a leading col, * like (col, skipcol) > (3, 5), but it can allow NULL skipcols to pass if (col>3) is true, * so for row comparisons we will only look at leading "indexcol" and not at "indexcols". */ if (ic->indexcol == skinfo->scankey_attno - 1) { /* Any simple index qual but "isNull" filters out nulls, * including "lossy" index quals extracted from index clauses. */ ListCell *lc; foreach (lc, ic->indexquals) { RestrictInfo *iqual = (RestrictInfo *) lfirst(lc); if (!(IsA(iqual->clause, NullTest) && ((NullTest *) iqual->clause)->nulltesttype == IS_NULL)) { skinfo->notnull = true; return; } } } } /* Otherwise look at all non-indexqual index filters on the key (like (key+1)>5) to see if they * filter out NULLs */ RelOptInfo *indexed_rel = index_path->path.parent; foreach (l, index_path->indexinfo->indrestrictinfo) { RestrictInfo *ri = castNode(RestrictInfo, lfirst(l)); Bitmapset *clause_attnos = NULL; pull_varattnos((Node *) ri->clause, indexed_rel->relid, &clause_attnos); if (bms_is_member(skinfo->indexed_column_attno - FirstLowInvalidHeapAttributeNumber, clause_attnos)) { if (!contain_nonstrict_functions((Node *) ri->clause)) { skinfo->notnull = true; return; } } } /* Failing that, look at filters not pushed down into index (like col1+col2>1) to see if they * filter out NULLs */ RelOptInfo *child_rel = child_path->parent; foreach (l, child_rel->baserestrictinfo) { RestrictInfo *ri = castNode(RestrictInfo, lfirst(l)); Bitmapset *clause_attnos = NULL; pull_varattnos((Node *) ri->clause, child_rel->relid, &clause_attnos); if (bms_is_member(skinfo->distinct_attno - FirstLowInvalidHeapAttributeNumber, clause_attnos)) { if (!contain_nonstrict_functions((Node *) ri->clause)) { skinfo->notnull = true; return; } } } } static IndexPath * get_compressed_index_path(ColumnarScanPath *dcpath) { Path *compressed_path = linitial(dcpath->custom_path.custom_paths); if (IsA(compressed_path, IndexPath)) { IndexPath *index_path = castNode(IndexPath, compressed_path); if (!pathkeys_contained_in(dcpath->required_compressed_pathkeys, compressed_path->pathkeys)) return NULL; return index_path; } return NULL; } static SkipScanPath * skip_scan_path_create(PlannerInfo *root, Path *child_path, DistinctPathInfo *dpinfo) { IndexPath *index_path = NULL; if (IsA(child_path, IndexPath)) { index_path = castNode(IndexPath, child_path); } else if (ts_is_columnar_scan_path(child_path)) { if (!ts_guc_enable_compressed_skip_scan) return NULL; ColumnarScanPath *dcpath = (ColumnarScanPath *) child_path; index_path = get_compressed_index_path(dcpath); } if (!index_path) return NULL; /* cannot use SkipScan with non-orderable index or IndexPath without pathkeys */ if (!index_path->path.pathkeys || !index_path->indexinfo->sortopfamily) return NULL; /* orderbyops are not compatible with skipscan */ if (index_path->indexorderbys != NIL) return NULL; SkipScanPath *skip_scan_path = (SkipScanPath *) newNode(sizeof(SkipScanPath), T_CustomPath); skip_scan_path->cpath.path.pathtype = T_CustomScan; skip_scan_path->cpath.path.pathkeys = child_path->pathkeys; skip_scan_path->cpath.path.pathtarget = child_path->pathtarget; skip_scan_path->cpath.path.param_info = child_path->param_info; skip_scan_path->cpath.path.parent = child_path->parent; skip_scan_path->cpath.custom_paths = list_make1(child_path); skip_scan_path->cpath.methods = &skip_scan_path_methods; /* While add_path may pfree paths with higher costs * it will never free IndexPaths and only ever do a shallow * free so reusing the IndexPath here is safe. */ skip_scan_path->index_path = index_path; ListCell *lc; int sk_no = 0; int num_skipkeys = list_length(dpinfo->distinct_expr); foreach (lc, dpinfo->distinct_expr) { Expr *dexpr = (Expr *) lfirst(lc); /* Placeholder for skip key attributes */ SkipKeyInfo *skinfo = palloc(sizeof(SkipKeyInfo)); Var *dvar = get_distinct_var(root, dexpr, index_path, child_path, skinfo); if (!dvar) { pfree(skinfo); return NULL; } /* build skip qual this may fail if we cannot look up the operator */ if (!build_skip_qual(root, skinfo, index_path, dvar, (++sk_no) < num_skipkeys)) { pfree(skinfo); return NULL; } if (!skinfo->notnull) check_notnull_skipkey(skinfo, child_path, index_path); /* Multikey SkipScan is only supported in not-null mode */ if (!skinfo->notnull && num_skipkeys > 1) return NULL; skip_scan_path->dvars = lappend(skip_scan_path->dvars, dvar); skip_scan_path->skipkeyinfo = lappend(skip_scan_path->skipkeyinfo, skinfo); } /* We have valid SkipScanPath: now we can cost it */ double startup = child_path->startup_cost; double total = child_path->total_cost; double rows = child_path->rows; double indexscan_rows = index_path->path.rows; /* Also true for SkipScan over compressed chunks as can't have more distinct segmentby values * than number of batches */ int ndistinct = indexscan_rows; /* For SELECT DISTINCT path, #rows can cap "ndistinct", * but for Distinct aggregates #rows = 1 usually, i.e. we can't cap "ndistinct" in this case. */ if (dpinfo->stage == UPPERREL_DISTINCT) ndistinct = Min(ndistinct, dpinfo->unique_path->rows); /* If we are on a chunk rather than on a PG table, we want to get "ndistinct" for this chunk, * as Unique path rows may combine rows from each chunk and may not represent a true * "ndistinct". Consider a hypertable with 1000 chunks, each chunk has the same 1 distinct * value, Unique path will add them up and we will get "ndistinct" = 1000 instead of 1. If * Unique path has "ndistinct=1" we can't go any smaller so will just accept this number. */ if (ndistinct > 1) { ndistinct = Max(1, floor(estimate_num_groups(root, skip_scan_path->dvars, ndistinct, NULL, NULL))); } skip_scan_path->cpath.path.rows = ndistinct; /* Addressing #8107: filters on the indexed data which are not index quals * will require sequential scanning of indexed tuples until finding a tuple passing the filter. * For some highly selective filters it may mean scanning a lot of tuples, sometimes the entire * input. SeqScan may perform better than IndexScan for such filters. We need to account for * such filters in the cost model i.e. cost the number of tuples to scan before passing the * filter. */ List *clauses_needing_scan = NULL; /* If a filter is not pushed down into compessed indexed data, it's a filter for which we will * need to scan and decompress until filter is passed */ if ((Path *) index_path != child_path) clauses_needing_scan = child_path->parent->baserestrictinfo; else { /* For uncompressed index data we need a finer check for which filters on the indexed data * are index quals or not */ ListCell *lc; foreach (lc, index_path->indexinfo->indrestrictinfo) { RestrictInfo *ri = (RestrictInfo *) lfirst(lc); bool match_found = false; ListCell *l; foreach (l, index_path->indexclauses) { IndexClause *ic = (IndexClause *) lfirst(l); if (ri == ic->rinfo) { match_found = true; break; } } /* This is a filter which is not an index qual: will have to scan indexed data until * this filter is passed */ if (!match_found) clauses_needing_scan = lappend(clauses_needing_scan, ri); } } /* Heuristic for accounting for previous key shifts in multikey SkipScan * In general, we will have (k_1*k_2*..*k_N + k_1*..*k_N-1 + ... + k_1) shifts * where numdistinct = k_1*k_2*..*k_N and for each key "k_i" we have "k_i+1" distinct values. * * Worst case scenario is when k_1 = numdistinct and the rest =1, then we'll have (numdistinct * * N) shifts. If it's uniform for each key i.e. numdistinct = k^N we'll have less than * (numdistinct * 2) shifts. We pick something in the middle to avoid evaluating k_i for each * key. */ int numkeys_multiplier = 1.0 + (num_skipkeys - 1) * 0.5; /* We calculate SkipScan cost as ndistinct * startup_cost + (ndistinct/rows) * total_cost * ndistinct * startup_cost is to account for the rescans we have to do and since startup * cost for indexes does not include page access cost we add a fraction of the total cost * accounting for the number of rows we expect to fetch. * If the row estimate for the scan is 1 we assume that the estimate got clamped to 1 * and no rows would be returned by this scan and this chunk will most likely be excluded * by runtime exclusion. Otherwise the cost for this path would be highly inflated due * to (ndistinct / rows) * total leading to SkipScan not being chosen for queries on * hypertables with a lot of excluded chunks. * * This is the cost of (SkipScan <- IndexScan) scenario */ if (clauses_needing_scan == NULL && (Path *) index_path == child_path) { skip_scan_path->cpath.path.startup_cost = startup; if (indexscan_rows > 1) skip_scan_path->cpath.path.total_cost = ndistinct * startup * numkeys_multiplier + (ndistinct / rows) * total; else skip_scan_path->cpath.path.total_cost = startup; } /* For (SkipScan <- ColumnarScan <- compressed IndexScan) scenario * we will estimate cost as (ndistinct * costs( child_path LIMIT 1 OFFSET x)) * i.e. as if we computed "ndistinct" LIMIT 1 queries on the "child_path" after initial setup. * If there is no qual above IndexScan, then OFFSET=0 (we don't need to scan tuples to pass qual * before returning the 1st tuple), otherwise OFFSET = (1 / qual_selectivity - 1), i.e. we have * to skip OFFSET tuples until we get the one which passes the qual. */ else { int64 offset_until_qual_pass = 0; if (clauses_needing_scan != NULL) { /* Avoid division by qual_selectivity = 0.0 */ Selectivity qual_selectivity = Max(1.0 / (rows + 1), clauselist_selectivity(root, clauses_needing_scan, 0, JOIN_INNER, NULL)); offset_until_qual_pass = Max(0, floor(1 / qual_selectivity)); } adjust_limit_rows_costs(&rows, &startup, &total, offset_until_qual_pass, 1); skip_scan_path->cpath.path.startup_cost = startup; if (indexscan_rows > 1) skip_scan_path->cpath.path.total_cost = startup + (total - startup) * ndistinct * numkeys_multiplier; else skip_scan_path->cpath.path.total_cost = startup; } /* Finally, adjust SkipScan run costs with GUC multiplier (1.0 by default), to give users more * control over choosing SkipScan */ skip_scan_path->cpath.path.total_cost = startup + (skip_scan_path->cpath.path.total_cost - startup) * ts_guc_skip_scan_run_cost_multiplier; return skip_scan_path; } /* Extract the Var to use for the SkipScan and do attno mapping if required. */ static Var * get_distinct_var(PlannerInfo *root, Expr *tlexpr, IndexPath *index_path, Path *child_path, SkipKeyInfo *skinfo) { RelOptInfo *rel = child_path->parent; RelOptInfo *indexed_rel = index_path->path.parent; Assert(tlexpr && IsA(tlexpr, Var)); Var *var = castNode(Var, tlexpr); RangeTblEntry *ht_rte = planner_rt_fetch(var->varno, root); /* check whether a skip var is declared NOT NULL * it's enough to check hypertable for NOT NULL * as NOT NULL constraint will be propagated to and checked on all chunks */ #if PG17_LT skinfo->notnull = attr_is_notnull(ht_rte->relid, var->varattno); #else RelOptInfo *baserel = ((Index) var->varno == rel->relid ? rel : rel->parent); skinfo->notnull = bms_is_member(var->varattno, baserel->notnullattnums); #endif /* If we are dealing with a hypertable Var extracted from distinctClause will point to * the parent hypertable while the IndexPath will be on a Chunk. * For a normal PG table they point to the same relation and we are done here. */ if ((Index) var->varno == rel->relid) { /* Get attribute number for distinct column on a normal PG table */ skinfo->indexed_column_attno = var->varattno; return var; } RangeTblEntry *chunk_rte = planner_rt_fetch(rel->relid, root); RangeTblEntry *indexed_rte = (indexed_rel == rel ? chunk_rte : planner_rt_fetch(indexed_rel->relid, root)); /* Check for hypertable */ if (!ts_is_hypertable(ht_rte->relid) || !bms_is_member(var->varno, rel->top_parent_relids)) return NULL; char *attname = get_attname(ht_rte->relid, var->varattno, false); var = copyObject(var); var->varattno = get_attnum(chunk_rte->relid, attname); /* Get attribute number for distinct column on a compressed chunk */ if (ts_is_columnar_scan_path(child_path)) { /* distinct column has to be a segmentby column */ ColumnarScanPath *dcpath = (ColumnarScanPath *) child_path; if (!bms_is_member(var->varattno, dcpath->info->chunk_segmentby_attnos)) { return NULL; } skinfo->indexed_column_attno = get_attnum(indexed_rte->relid, attname); } /* Get attribute number for distinct column on an uncompressed chunk */ else { skinfo->indexed_column_attno = var->varattno; } var->varno = rel->relid; return var; } /* * Creates SkipScanPath for each path of subpaths that is an IndexPath * If no subpath can be changed to SkipScanPath returns NULL * otherwise returns list of new paths */ static List * build_subpath(PlannerInfo *root, List *subpaths, DistinctPathInfo *dpinfo, List *top_pathkeys) { bool has_skip_path = false; List *new_paths = NIL; ListCell *lc; foreach (lc, subpaths) { Path *child = lfirst(lc); if (IsA(child, IndexPath) || ts_is_columnar_scan_path(child)) { if (top_pathkeys && !pathkeys_contained_in(top_pathkeys, child->pathkeys)) continue; SkipScanPath *skip_path = skip_scan_path_create(root, child, dpinfo); if (skip_path) { child = (Path *) skip_path; has_skip_path = true; } } new_paths = lappend(new_paths, child); } if (!has_skip_path && new_paths) { pfree(new_paths); return NIL; } return new_paths; } static bool build_skip_qual(PlannerInfo *root, SkipKeyInfo *skinfo, IndexPath *index_path, Var *var, bool build_eqop) { IndexOptInfo *info = index_path->indexinfo; Oid column_type = exprType((Node *) var); Oid column_collation = get_typcollation(column_type); TypeCacheEntry *tce = lookup_type_cache(column_type, 0); bool need_coerce = false; /* * Skipscan is not applicable for the following case: * We might have a path with an index that produces the correct pathkeys for the target ordering * without actually including all the columns of the ORDER BY. If the path uses an index that * does not include the distinct column, we cannot use it for skipscan and have to discard this * path from skipscan generation. This happens, for instance, when we have an order by clause * (like ORDER BY a, b) with constraints in the WHERE clause (like WHERE a = <constant>) . "a" * can now be removed from the Pathkeys (since it is a constant) and the query can be satisfied * by using an index on just column "b". * * Example query: * SELECT DISTINCT ON (a) * FROM test WHERE a in (2) ORDER BY a ASC, time DESC; * Since a is always 2 due to the WHERE clause we can create the correct ordering for the * ORDER BY with an index that does not include the a column and only includes the time column. */ int idx_key = get_idx_key(index_path->indexinfo, skinfo->indexed_column_attno); if (idx_key < 0) return false; /* sk_attno of the skip qual */ skinfo->scankey_attno = idx_key + 1; skinfo->distinct_attno = var->varattno; skinfo->distinct_by_val = tce->typbyval; skinfo->distinct_typ_len = tce->typlen; int16 strategy = info->reverse_sort[idx_key] ? BTLessStrategyNumber : BTGreaterStrategyNumber; if (index_path->indexscandir == BackwardScanDirection) { strategy = (strategy == BTLessStrategyNumber) ? BTGreaterStrategyNumber : BTLessStrategyNumber; } Oid opcintype = info->opcintype[idx_key]; Oid comparator = get_opfamily_member(info->sortopfamily[idx_key], column_type, column_type, strategy); Oid eqop = InvalidOid; if (build_eqop) eqop = get_opfamily_member(info->sortopfamily[idx_key], column_type, column_type, BTEqualStrategyNumber); /* If there is no exact operator match for the column type we have here check * if we can coerce to the type of the operator class. */ if (!OidIsValid(comparator)) { if (IsBinaryCoercible(column_type, opcintype)) { comparator = get_opfamily_member(info->sortopfamily[idx_key], opcintype, opcintype, strategy); if (!OidIsValid(comparator)) return false; if (build_eqop) eqop = get_opfamily_member(info->sortopfamily[idx_key], opcintype, opcintype, BTEqualStrategyNumber); need_coerce = true; } else return false; /* cannot use this index */ } Const *prev_val = makeNullConst(need_coerce ? opcintype : column_type, -1, column_collation); Expr *current_val = (Expr *) makeVar(info->rel->relid /*varno*/, skinfo->indexed_column_attno /*varattno*/, column_type /*vartype*/, -1 /*vartypmod*/, column_collation /*varcollid*/, 0 /*varlevelsup*/); if (need_coerce) { CoerceViaIO *coerce = makeNode(CoerceViaIO); coerce->arg = current_val; coerce->resulttype = opcintype; coerce->resultcollid = column_collation; coerce->coerceformat = COERCE_IMPLICIT_CAST; coerce->location = -1; current_val = &coerce->xpr; } Expr *comparison_expr = make_opclause(comparator, BOOLOID /*opresulttype*/, false /*opretset*/, current_val /*leftop*/, &prev_val->xpr /*rightop*/, InvalidOid /*opcollid*/, info->indexcollations[idx_key] /*inputcollid*/); set_opfuncid(castNode(OpExpr, comparison_expr)); skinfo->eqcomp = (build_eqop ? get_opcode(eqop) : InvalidOid); skinfo->skip_clause = make_simple_restrictinfo(root, comparison_expr); return true; } static int get_idx_key(IndexOptInfo *idxinfo, AttrNumber attno) { for (int i = 0; i < idxinfo->nkeycolumns; i++) { if (attno == idxinfo->indexkeys[i]) return i; } return -1; } /* Sort quals according to index column order. * ScanKeys need to be sorted by the position of the index column * they are referencing but since we don't want to adjust actual * ScanKey array we presort qual list when creating plan. */ static List * sort_indexquals(IndexOptInfo *indexinfo, List *quals) { List *indexclauses[INDEX_MAX_KEYS] = { 0 }; List *ordered_list = NIL; ListCell *lc; int i; foreach (lc, quals) { Bitmapset *bms = NULL; pull_varattnos(lfirst(lc), INDEX_VAR, &bms); Assert(bms_num_members(bms) >= 1); i = bms_next_member(bms, -1) + FirstLowInvalidHeapAttributeNumber - 1; indexclauses[i] = lappend(indexclauses[i], lfirst(lc)); } for (i = 0; i < indexinfo->nkeycolumns; i++) { if (indexclauses[i] != NIL) ordered_list = list_concat(ordered_list, indexclauses[i]); } return ordered_list; } static OpExpr * fix_indexqual(IndexOptInfo *index, RestrictInfo *rinfo, AttrNumber scankey_attno) { /* technically our placeholder col > NULL is unsatisfiable, and in some instances * the planner will realize this and use is as an excuse to remove other quals. * in order to prevent this, we prepare this qual ourselves. */ /* fix_indexqual_references */ OpExpr *op = copyObject(castNode(OpExpr, rinfo->clause)); Assert(list_length(op->args) == 2); Assert(bms_equal(rinfo->left_relids, index->rel->relids)); /* fix_indexqual_operand */ Assert(index->indexkeys[scankey_attno - 1] != 0); Var *node = linitial_node(Var, pull_var_clause(linitial(op->args), 0)); Assert((Index) ((Var *) node)->varno == index->rel->relid && ((Var *) node)->varattno == index->indexkeys[scankey_attno - 1]); Var *result = (Var *) copyObject(node); result->varno = INDEX_VAR; result->varattno = scankey_attno; linitial(op->args) = result; return op; } /* * tlist_member_match_var * Same as tlist_member, except that we match the provided Var on the basis * of varno/varattno/varlevelsup/vartype only, rather than full equal(). * * This is needed in some cases where we can't be sure of an exact typmod * match. For safety, though, we insist on vartype match. * * static function copied from src/backend/optimizer/util/tlist.c */ static TargetEntry * tlist_member_match_var(Var *var, List *targetlist) { ListCell *temp; foreach (temp, targetlist) { TargetEntry *tlentry = (TargetEntry *) lfirst(temp); Var *tlvar = (Var *) tlentry->expr; if (!tlvar || !IsA(tlvar, Var)) continue; if (var->varno == tlvar->varno && var->varattno == tlvar->varattno && var->varlevelsup == tlvar->varlevelsup && var->vartype == tlvar->vartype) return tlentry; } return NULL; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/skip_scan/skip_scan.h����������������������������������������������0000664�0000000�0000000�00000001356�15100345067�0022656�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/plannodes.h> typedef enum SkipKeyNullStatus { SK_NOT_NULL = 0, SK_NULLS_FIRST, SK_NULLS_LAST } SkipKeyNullStatus; typedef enum { SK_DistinctColAttno = 0, SK_DistinctByVal = 1, SK_DistinctTypeLen = 2, SK_NullStatus = 3, SK_IndexKeyAttno = 4 } SkipScanPrivateIndex; extern void tsl_skip_scan_paths_add(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *output_rel, UpperRelationKind stage); extern Node *tsl_skip_scan_state_create(CustomScan *cscan); extern void _skip_scan_init(void); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/��������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020674�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/CMakeLists.txt������������������������������������������0000664�0000000�0000000�00000000553�15100345067�0023437�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������add_subdirectory(function) add_subdirectory(hashing) set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/exec.c ${CMAKE_CURRENT_SOURCE_DIR}/grouping_policy_batch.c ${CMAKE_CURRENT_SOURCE_DIR}/grouping_policy_hash.c ${CMAKE_CURRENT_SOURCE_DIR}/plan.c ${CMAKE_CURRENT_SOURCE_DIR}/plan_columnar_scan.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) �����������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/exec.c��������������������������������������������������0000664�0000000�0000000�00000041152�15100345067�0021767�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <commands/explain.h> #include <executor/executor.h> #include <executor/tuptable.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/pg_list.h> #include <optimizer/optimizer.h> #include "nodes/vector_agg/exec.h" #include "compat/compat.h" #include "compression/arrow_c_data_interface.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/columnar_scan/exec.h" #include "nodes/columnar_scan/vector_quals.h" #include "nodes/vector_agg.h" #include "nodes/vector_agg/plan.h" #if PG18_GE #include "commands/explain_format.h" #include "commands/explain_state.h" #endif static int get_input_offset(const ColumnarScanState *decompress_state, const Var *var) { const DecompressContext *dcontext = &decompress_state->decompress_context; /* * All variable references in the vectorized aggregation node were * translated to uncompressed chunk variables when it was created. */ const CustomScan *cscan = castNode(CustomScan, decompress_state->csstate.ss.ps.plan); Ensure((Index) var->varno == (Index) cscan->scan.scanrelid, "got vector varno %d expected %d", var->varno, cscan->scan.scanrelid); const CompressionColumnDescription *value_column_description = NULL; for (int i = 0; i < dcontext->num_data_columns; i++) { const CompressionColumnDescription *current_column = &dcontext->compressed_chunk_columns[i]; if (current_column->uncompressed_chunk_attno == var->varattno) { value_column_description = current_column; break; } } Ensure(value_column_description != NULL, "aggregated compressed column not found"); Assert(value_column_description->type == COMPRESSED_COLUMN || value_column_description->type == SEGMENTBY_COLUMN); const int index = value_column_description - dcontext->compressed_chunk_columns; return index; } static void get_column_storage_properties(const ColumnarScanState *state, int input_offset, GroupingColumn *result) { const DecompressContext *dcontext = &state->decompress_context; const CompressionColumnDescription *desc = &dcontext->compressed_chunk_columns[input_offset]; result->value_bytes = desc->value_bytes; result->by_value = desc->by_value; } static void vector_agg_begin(CustomScanState *node, EState *estate, int eflags) { CustomScan *cscan = castNode(CustomScan, node->ss.ps.plan); node->custom_ps = lappend(node->custom_ps, ExecInitNode(linitial(cscan->custom_plans), estate, eflags)); VectorAggState *vector_agg_state = (VectorAggState *) node; vector_agg_state->input_ended = false; CustomScanState *childstate = (CustomScanState *) linitial(vector_agg_state->custom.custom_ps); /* * Set up the helper structures used to evaluate stable expressions in * vectorized FILTER clauses. */ PlannerGlobal glob = { .boundParams = node->ss.ps.state->es_param_list_info, }; PlannerInfo root = { .glob = &glob, }; /* * The aggregated targetlist with Aggrefs is in the custom scan targetlist * of the custom scan node that is performing the vectorized aggregation. * We do this to avoid projections at this node, because the postgres * projection functions complain when they see an Aggref in a custom * node output targetlist. * The output targetlist, in turn, consists of just the INDEX_VAR references * into the custom_scan_tlist. * Now, iterate through the aggregated targetlist to collect aggregates and * output grouping columns. */ List *aggregated_tlist = castNode(CustomScan, vector_agg_state->custom.ss.ps.plan)->custom_scan_tlist; const int tlist_length = list_length(aggregated_tlist); /* * First, count how many grouping columns and aggregate functions we have. */ int agg_functions_counter = 0; int grouping_column_counter = 0; for (int i = 0; i < tlist_length; i++) { TargetEntry *tlentry = list_nth_node(TargetEntry, aggregated_tlist, i); if (IsA(tlentry->expr, Aggref)) { agg_functions_counter++; } else { /* This is a grouping column. */ Assert(IsA(tlentry->expr, Var)); grouping_column_counter++; } } Assert(agg_functions_counter + grouping_column_counter == tlist_length); /* * Allocate the storage for definitions of aggregate function and grouping * columns. */ vector_agg_state->num_agg_defs = agg_functions_counter; vector_agg_state->agg_defs = palloc0(sizeof(*vector_agg_state->agg_defs) * vector_agg_state->num_agg_defs); vector_agg_state->num_grouping_columns = grouping_column_counter; vector_agg_state->grouping_columns = palloc0(sizeof(*vector_agg_state->grouping_columns) * vector_agg_state->num_grouping_columns); /* * Loop through the aggregated targetlist again and fill the definitions. */ agg_functions_counter = 0; grouping_column_counter = 0; for (int i = 0; i < tlist_length; i++) { TargetEntry *tlentry = list_nth_node(TargetEntry, aggregated_tlist, i); if (IsA(tlentry->expr, Aggref)) { /* This is an aggregate function. */ VectorAggDef *def = &vector_agg_state->agg_defs[agg_functions_counter++]; def->output_offset = i; Aggref *aggref = castNode(Aggref, tlentry->expr); VectorAggFunctions *func = get_vector_aggregate(aggref->aggfnoid); Assert(func != NULL); def->func = *func; if (list_length(aggref->args) > 0) { Assert(list_length(aggref->args) == 1); /* The aggregate should be a partial aggregate */ Assert(aggref->aggsplit == AGGSPLIT_INITIAL_SERIAL); Var *var = castNode(Var, castNode(TargetEntry, linitial(aggref->args))->expr); def->input_offset = get_input_offset((const ColumnarScanState *) childstate, var); } else { def->input_offset = -1; } if (aggref->aggfilter != NULL) { Node *constified = estimate_expression_value(&root, (Node *) aggref->aggfilter); def->filter_clauses = list_make1(constified); } } else { /* This is a grouping column. */ Assert(IsA(tlentry->expr, Var)); GroupingColumn *col = &vector_agg_state->grouping_columns[grouping_column_counter++]; col->output_offset = i; Var *var = castNode(Var, tlentry->expr); col->input_offset = get_input_offset((const ColumnarScanState *) childstate, var); get_column_storage_properties((const ColumnarScanState *) childstate, col->input_offset, col); } } /* * Create the grouping policy chosen at plan time. */ const VectorAggGroupingType grouping_type = intVal(list_nth(cscan->custom_private, VASI_GroupingType)); if (grouping_type == VAGT_Batch) { /* * Per-batch grouping. */ vector_agg_state->grouping = create_grouping_policy_batch(vector_agg_state->num_agg_defs, vector_agg_state->agg_defs, vector_agg_state->num_grouping_columns, vector_agg_state->grouping_columns); } else { /* * Hash grouping. */ vector_agg_state->grouping = create_grouping_policy_hash(vector_agg_state->num_agg_defs, vector_agg_state->agg_defs, vector_agg_state->num_grouping_columns, vector_agg_state->grouping_columns, grouping_type); } } static void vector_agg_end(CustomScanState *node) { ExecEndNode(linitial(node->custom_ps)); } static void vector_agg_rescan(CustomScanState *node) { if (node->ss.ps.chgParam != NULL) UpdateChangedParamSet(linitial(node->custom_ps), node->ss.ps.chgParam); ExecReScan(linitial(node->custom_ps)); VectorAggState *state = (VectorAggState *) node; state->input_ended = false; state->grouping->gp_reset(state->grouping); } /* * Get the next slot to aggregate for a compressed batch. * * Implements "get next slot" on top of ColumnarScan. Note that compressed * tuples are read directly from the ColumnarScan child node, which means * that the processing normally done in ColumnarScan is actually done here * (batch processing and filtering). * * Returns an TupleTableSlot that implements a compressed batch. */ static TupleTableSlot * compressed_batch_get_next_slot(VectorAggState *vector_agg_state) { ColumnarScanState *decompress_state = (ColumnarScanState *) linitial(vector_agg_state->custom.custom_ps); DecompressContext *dcontext = &decompress_state->decompress_context; BatchQueue *batch_queue = decompress_state->batch_queue; DecompressBatchState *batch_state = batch_array_get_at(&batch_queue->batch_array, 0); do { /* * We discard the previous compressed batch here and not earlier, * because the grouping column values returned by the batch grouping * policy are owned by the compressed batch memory context. This is done * to avoid generic value copying in the grouping policy to simplify its * code. */ compressed_batch_discard_tuples(batch_state); TupleTableSlot *compressed_slot = ExecProcNode(linitial(decompress_state->csstate.custom_ps)); if (TupIsNull(compressed_slot)) { vector_agg_state->input_ended = true; return NULL; } if (dcontext->ps->instrument) { /* * Ensure proper EXPLAIN output for the underlying ColumnarScan * node. * * This value is normally updated by InstrStopNode(), and is * required so that the calculations in InstrEndLoop() run properly. * We have to call it manually because we run the underlying * ColumnarScan manually and not as a normal Postgres node. */ dcontext->ps->instrument->running = true; } compressed_batch_set_compressed_tuple(dcontext, batch_state, compressed_slot); /* If the entire batch is filtered out, then immediately read the next * one */ } while (batch_state->next_batch_row >= batch_state->total_batch_rows); /* * Count rows filtered out by vectorized filters for EXPLAIN. Normally * this is done in tuple-by-tuple interface of ColumnarScan, so that * it doesn't say it filtered out more rows that were returned (e.g. * with LIMIT). Here we always work in full batches. The batches that * were fully filtered out, and their rows, were already counted in * compressed_batch_set_compressed_tuple(). */ const int not_filtered_rows = arrow_num_valid(batch_state->vector_qual_result, batch_state->total_batch_rows); InstrCountFiltered1(dcontext->ps, batch_state->total_batch_rows - not_filtered_rows); if (dcontext->ps->instrument) { /* * Ensure proper EXPLAIN output for the underlying ColumnarScan * node. * * This value is normally updated by InstrStopNode(), and is * required so that the calculations in InstrEndLoop() run properly. * We have to call it manually because we run the underlying * ColumnarScan manually and not as a normal Postgres node. */ dcontext->ps->instrument->tuplecount += not_filtered_rows; } return &batch_state->decompressed_scan_slot_data.base; } /* * Initialize vector quals for a compressed batch. * * Used to implement vectorized aggregate function filter clause. */ static VectorQualState * compressed_batch_init_vector_quals(VectorAggState *agg_state, VectorAggDef *agg_def, TupleTableSlot *slot) { ColumnarScanState *decompress_state = (ColumnarScanState *) linitial(agg_state->custom.custom_ps); DecompressContext *dcontext = &decompress_state->decompress_context; DecompressBatchState *batch_state = (DecompressBatchState *) slot; agg_state->vqual_state = (CompressedBatchVectorQualState) { .vqstate = { .vectorized_quals_constified = agg_def->filter_clauses, .num_results = batch_state->total_batch_rows, .per_vector_mcxt = batch_state->per_batch_context, .slot = decompress_state->csstate.ss.ss_ScanTupleSlot, .get_arrow_array = compressed_batch_get_arrow_array, }, .batch_state = batch_state, .dcontext = dcontext, }; return &agg_state->vqual_state.vqstate; } static TupleTableSlot * vector_agg_exec(CustomScanState *node) { VectorAggState *vector_agg_state = (VectorAggState *) node; ExprContext *econtext = node->ss.ps.ps_ExprContext; ResetExprContext(econtext); TupleTableSlot *aggregated_slot = vector_agg_state->custom.ss.ps.ps_ResultTupleSlot; ExecClearTuple(aggregated_slot); /* * If we have more partial aggregation results, continue returning them. */ GroupingPolicy *grouping = vector_agg_state->grouping; MemoryContext old_context = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory); bool have_partial = grouping->gp_do_emit(grouping, aggregated_slot); MemoryContextSwitchTo(old_context); if (have_partial) { /* The grouping policy produced a partial aggregation result. */ return ExecStoreVirtualTuple(aggregated_slot); } /* * If the partial aggregation results have ended, and the input has ended, * we're done. */ if (vector_agg_state->input_ended) { return NULL; } /* * Have no more partial aggregation results and still have input, have to * reset the grouping policy and start a new cycle of partial aggregation. */ grouping->gp_reset(grouping); /* * Now we loop through the input compressed tuples, until they end or until * the grouping policy asks us to emit partials. */ while (!grouping->gp_should_emit(grouping)) { /* * Get the next slot to aggregate. It will be either a compressed * batch or an arrow tuple table slot. Both hold arrow arrays of data * that can be vectorized. */ TupleTableSlot *slot = vector_agg_state->get_next_slot(vector_agg_state); /* * Exit if there is no more data. Note that it is not possible to do * the standard TupIsNull() check here because the compressed batch's * implementation of TupleTableSlot never clears the empty flag bit * (TTS_EMPTY), so it will always look empty. Therefore, look at the * "input_ended" flag instead. */ if (vector_agg_state->input_ended) break; /* * Compute the vectorized filters for the aggregate function FILTER * clauses. */ const int naggs = vector_agg_state->num_agg_defs; for (int i = 0; i < naggs; i++) { VectorAggDef *agg_def = &vector_agg_state->agg_defs[i]; if (agg_def->filter_clauses == NIL) { continue; } VectorQualState *vqstate = vector_agg_state->init_vector_quals(vector_agg_state, agg_def, slot); vector_qual_compute(vqstate); agg_def->filter_result = vqstate->vector_qual_result; } /* * Finally, pass the compressed batch to the grouping policy. */ grouping->gp_add_batch(grouping, slot); } /* * If we have partial aggregation results, start returning them. */ old_context = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory); have_partial = grouping->gp_do_emit(grouping, aggregated_slot); MemoryContextSwitchTo(old_context); if (have_partial) { /* Have partial aggregation results. */ return ExecStoreVirtualTuple(aggregated_slot); } if (vector_agg_state->input_ended) { /* * Have no partial aggregation results and the input has ended, so we're * done. We can get here only if we had no input at all, otherwise the * grouping policy would have produced some partials above. */ return NULL; } /* * We cannot get here. This would mean we still have input, and the * grouping policy asked us to stop but couldn't produce any partials. */ Assert(false); pg_unreachable(); return NULL; } static void vector_agg_explain(CustomScanState *node, List *ancestors, ExplainState *es) { VectorAggState *state = (VectorAggState *) node; if (es->verbose || es->format != EXPLAIN_FORMAT_TEXT) { ExplainPropertyText("Grouping Policy", state->grouping->gp_explain(state->grouping), es); } } static struct CustomExecMethods exec_methods = { .CustomName = VECTOR_AGG_NODE_NAME, .BeginCustomScan = vector_agg_begin, .ExecCustomScan = vector_agg_exec, .EndCustomScan = vector_agg_end, .ReScanCustomScan = vector_agg_rescan, .ExplainCustomScan = vector_agg_explain, }; Node * vector_agg_state_create(CustomScan *cscan) { VectorAggState *state = (VectorAggState *) newNode(sizeof(VectorAggState), T_CustomScanState); Assert(ts_is_columnar_scan_plan((Plan *) linitial(cscan->custom_plans))); state->custom.methods = &exec_methods; /* * Initialize VectorAggState to process vector slots from different * subnodes. * * When the child is ColumnarScan, VectorAgg doesn't read the slot from * the child node. Instead, it bypasses ColumnarScan and reads * compressed tuples directly from the grandchild. It therefore needs to * handle batch decompression and vectorized qual filtering itself, in its * own "get next slot" implementation. * * The vector qual init functions are needed to implement vectorized * aggregate function FILTER clauses for arrow tuple table slots and * compressed batches, respectively. */ state->get_next_slot = compressed_batch_get_next_slot; state->init_vector_quals = compressed_batch_init_vector_quals; return (Node *) state; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/exec.h��������������������������������������������������0000664�0000000�0000000�00000003161�15100345067�0021772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include "nodes/columnar_scan/compressed_batch.h" #include <nodes/execnodes.h> #include "function/functions.h" #include "grouping_policy.h" typedef struct VectorAggDef { VectorAggFunctions func; int input_offset; int output_offset; List *filter_clauses; uint64 *filter_result; } VectorAggDef; typedef struct GroupingColumn { int input_offset; int output_offset; int16 value_bytes; bool by_value; } GroupingColumn; typedef struct VectorAggState { CustomScanState custom; int num_agg_defs; VectorAggDef *agg_defs; int num_grouping_columns; GroupingColumn *grouping_columns; /* * We can't call the underlying scan after it has ended, or it will be * restarted. This is the behavior of Postgres heap scans. So we have to * track whether it has ended to avoid this. */ bool input_ended; GroupingPolicy *grouping; /* * State to compute vector quals for FILTER clauses. */ CompressedBatchVectorQualState vqual_state; /* * Initialization function for vectorized quals depending on slot type. */ VectorQualState *(*init_vector_quals)(struct VectorAggState *agg_state, VectorAggDef *agg_def, TupleTableSlot *slot); /* * Function for getting the next slot from the child node depending on * child node type. */ TupleTableSlot *(*get_next_slot)(struct VectorAggState *vector_agg_state); } VectorAggState; extern Node *vector_agg_state_create(CustomScan *cscan); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/�����������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0022521�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/CMakeLists.txt���������������������������������0000664�0000000�0000000�00000000676�15100345067�0025272�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/functions.c ${CMAKE_CURRENT_SOURCE_DIR}/minmax_templates.c ${CMAKE_CURRENT_SOURCE_DIR}/int24_sum_templates.c ${CMAKE_CURRENT_SOURCE_DIR}/sum_float_templates.c ${CMAKE_CURRENT_SOURCE_DIR}/float48_accum_templates.c ${CMAKE_CURRENT_SOURCE_DIR}/int24_avg_accum_templates.c ${CMAKE_CURRENT_SOURCE_DIR}/int128_accum_templates.c) target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) ������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/agg_many_vector_helper.c�����������������������0000664�0000000�0000000�00000003711�15100345067�0027372�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * A generic implementation of adding the given batch to many aggregate function * states with given offsets. Used for hash aggregation, and builds on the * FUNCTION_NAME(one) function, which adds one passing non-null row to the given * aggregate function state. */ static pg_attribute_always_inline void FUNCTION_NAME(many_vector_impl)(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, const ArrowArray *vector, MemoryContext agg_extra_mctx) { FUNCTION_NAME(state) *restrict states = (FUNCTION_NAME(state) *) agg_states; const CTYPE *values = vector->buffers[1]; MemoryContext old = MemoryContextSwitchTo(agg_extra_mctx); for (int row = start_row; row < end_row; row++) { const CTYPE value = values[row]; FUNCTION_NAME(state) *restrict state = &states[offsets[row]]; if (arrow_row_is_valid(filter, row)) { Assert(offsets[row] != 0); FUNCTION_NAME(one)(state, value); } } MemoryContextSwitchTo(old); } static pg_noinline void FUNCTION_NAME(many_vector_all_valid)(void *restrict agg_states, const uint32 *offsets, int start_row, int end_row, const ArrowArray *vector, MemoryContext agg_extra_mctx) { FUNCTION_NAME(many_vector_impl) (agg_states, offsets, NULL, start_row, end_row, vector, agg_extra_mctx); } static void FUNCTION_NAME(many_vector)(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, const ArrowArray *vector, MemoryContext agg_extra_mctx) { if (filter == NULL) { FUNCTION_NAME(many_vector_all_valid) (agg_states, offsets, start_row, end_row, vector, agg_extra_mctx); } else { FUNCTION_NAME(many_vector_impl) (agg_states, offsets, filter, start_row, end_row, vector, agg_extra_mctx); } } �������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/agg_scalar_helper.c����������������������������0000664�0000000�0000000�00000001514�15100345067�0026310�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * A generic function for aggregating a constant input. We use a very simple * implementation here, because aggregating a segmentby column or a column with * default value is a relatively rare case, but it requires a fully custom * implementation otherwise. */ static void FUNCTION_NAME(scalar)(void *agg_state, Datum constvalue, bool constisnull, int n, MemoryContext agg_extra_mctx) { if (constisnull) { return; } const CTYPE value = DATUM_TO_CTYPE(constvalue); MemoryContext old = MemoryContextSwitchTo(agg_extra_mctx); for (int i = 0; i < n; i++) { FUNCTION_NAME(one)(agg_state, value); } MemoryContextSwitchTo(old); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/agg_vector_validity_helper.c�������������������0000664�0000000�0000000�00000003176�15100345067�0030260�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Generate a separate implementation of aggregating an ArrowArray for the * common cases where we have no nulls and/or all rows pass the filter. It * avoids branches so can be more easily vectorized. */ static pg_attribute_always_inline void FUNCTION_NAME(vector_impl_arrow)(void *agg_state, const ArrowArray *vector, const uint64 *filter, MemoryContext agg_extra_mctx) { const int n = vector->length; const CTYPE *values = vector->buffers[1]; FUNCTION_NAME(vector_impl)(agg_state, n, values, filter, agg_extra_mctx); } static pg_noinline void FUNCTION_NAME(vector_all_valid)(void *agg_state, const ArrowArray *vector, MemoryContext agg_extra_mctx) { FUNCTION_NAME(vector_impl_arrow)(agg_state, vector, NULL, agg_extra_mctx); } static pg_noinline void FUNCTION_NAME(vector_one_validity)(void *agg_state, const ArrowArray *vector, const uint64 *filter, MemoryContext agg_extra_mctx) { FUNCTION_NAME(vector_impl_arrow)(agg_state, vector, filter, agg_extra_mctx); } static void FUNCTION_NAME(vector)(void *agg_state, const ArrowArray *vector, const uint64 *filter, MemoryContext agg_extra_mctx) { if (filter == NULL) { /* All rows are valid and we don't have to check any validity bitmaps. */ FUNCTION_NAME(vector_all_valid)(agg_state, vector, agg_extra_mctx); } else { /* Have to check only one combined validity bitmap. */ FUNCTION_NAME(vector_one_validity)(agg_state, vector, filter, agg_extra_mctx); } } ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/float48_accum_single.c�������������������������0000664�0000000�0000000�00000021017�15100345067�0026660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Vectorized implementation of a Postgres float{4,8}_accum() transition * function for a single type. They use the same Youngs-Cramer state, but for * AVG we can skip calculating the Sxx variable. */ #ifdef GENERATE_DISPATCH_TABLE /* * Forward declaration for the vectorized aggregate function definition. */ extern VectorAggFunctions FUNCTION_NAME(argdef); /* * Helper macros to generate the cases for the given argument type. We support * different aggregate functions based on whether we calculate the Sxx variable. */ #ifdef NEED_SXX #define ACCUM_CASE_HELPER(PG_TYPE) \ case F_STDDEV_##PG_TYPE: \ case F_STDDEV_SAMP_##PG_TYPE: \ case F_STDDEV_POP_##PG_TYPE: \ case F_VARIANCE_##PG_TYPE: \ case F_VAR_SAMP_##PG_TYPE: \ case F_VAR_POP_##PG_TYPE: #else #define ACCUM_CASE_HELPER(PG_TYPE) case F_AVG_##PG_TYPE: #endif #define ACCUM_CASE(PG_TYPE) ACCUM_CASE_HELPER(PG_TYPE) /* * The actual case label. */ ACCUM_CASE(PG_TYPE) return &FUNCTION_NAME(argdef); #else /* * State of Youngs-Cramer algorithm, see the comments for float8_accum() * Postgres function. */ typedef struct { double N; double Sx; #ifdef NEED_SXX double Sxx; #endif } FUNCTION_NAME(state); static void FUNCTION_NAME(init)(void *restrict agg_states, int n) { FUNCTION_NAME(state) *states = (FUNCTION_NAME(state) *) agg_states; for (int i = 0; i < n; i++) { states[i] = (FUNCTION_NAME(state)){ 0 }; } } static void FUNCTION_NAME(emit)(void *agg_state, Datum *out_result, bool *out_isnull) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; const size_t nbytes = 3 * sizeof(float8) + ARR_OVERHEAD_NONULLS(/* ndims = */ 1); ArrayType *result = palloc(nbytes); SET_VARSIZE(result, nbytes); result->ndim = 1; result->dataoffset = 0; result->elemtype = FLOAT8OID; ARR_DIMS(result)[0] = 3; ARR_LBOUND(result)[0] = 1; /* * The array elements are stored by value, regardless of if the float8 * itself is by-value on this platform. */ ((float8 *) ARR_DATA_PTR(result))[0] = state->N; ((float8 *) ARR_DATA_PTR(result))[1] = state->Sx; ((float8 *) ARR_DATA_PTR(result))[2] = /* * Sxx should be NaN if any of the inputs are infinite or NaN. This is * checked by float8_combine even if it's not used for the actual * calculations. */ 0. * state->Sx #ifdef NEED_SXX + state->Sxx #endif ; *out_result = PointerGetDatum(result); *out_isnull = false; } /* * Youngs-Cramer update for rows after the first. */ static pg_attribute_always_inline void FUNCTION_NAME(update)(const uint64 *filter, const CTYPE *values, int row, double *N, double *Sx #ifdef NEED_SXX , double *Sxx #endif ) { const CTYPE newval = values[row]; if (!arrow_row_is_valid(filter, row)) { return; } /* * This code follows the Postgres float8_accum() transition function, see * the comments there. */ const double newN = *N + 1.0; const double newSx = *Sx + newval; #ifdef NEED_SXX Assert(*N > 0.0); const double tmp = newval * newN - newSx; *Sxx += tmp * tmp / (*N * newN); #endif *N = newN; *Sx = newSx; } /* * Combine two Youngs-Cramer states following the float8_combine() function. */ static pg_attribute_always_inline void FUNCTION_NAME(combine)(double *inout_N, double *inout_Sx, #ifdef NEED_SXX double *inout_Sxx, #endif double N2, double Sx2 #ifdef NEED_SXX , double Sxx2 #endif ) { const double N1 = *inout_N; const double Sx1 = *inout_Sx; #ifdef NEED_SXX const double Sxx1 = *inout_Sxx; #endif if (unlikely(N1 == 0)) { *inout_N = N2; *inout_Sx = Sx2; #ifdef NEED_SXX *inout_Sxx = Sxx2; #endif return; } if (unlikely(N2 == 0)) { *inout_N = N1; *inout_Sx = Sx1; #ifdef NEED_SXX *inout_Sxx = Sxx1; #endif return; } const double combinedN = N1 + N2; const double combinedSx = Sx1 + Sx2; #ifdef NEED_SXX const double tmp = Sx1 / N1 - Sx2 / N2; const double combinedSxx = Sxx1 + Sxx2 + N1 * N2 * tmp * tmp / combinedN; #endif *inout_N = combinedN; *inout_Sx = combinedSx; #ifdef NEED_SXX *inout_Sxx = combinedSxx; #endif } #ifdef NEED_SXX #define UPDATE(filter, values, row, N, Sx, Sxx) \ FUNCTION_NAME(update)(filter, values, row, N, Sx, Sxx) #define COMBINE(inout_N, inout_Sx, inout_Sxx, N2, Sx2, Sxx2) \ FUNCTION_NAME(combine)(inout_N, inout_Sx, inout_Sxx, N2, Sx2, Sxx2) #else #define UPDATE(filter, values, row, N, Sx, Sxx) FUNCTION_NAME(update)(filter, values, row, N, Sx) #define COMBINE(inout_N, inout_Sx, inout_Sxx, N2, Sx2, Sxx2) \ FUNCTION_NAME(combine)(inout_N, inout_Sx, N2, Sx2) #endif static pg_attribute_always_inline void FUNCTION_NAME(vector_impl)(void *agg_state, size_t n, const CTYPE *values, const uint64 *filter, MemoryContext agg_extra_mctx) { /* * Vector registers can be up to 512 bits wide. */ #define UNROLL_SIZE ((int) (512 / 8 / sizeof(CTYPE))) /* * Each inner iteration works with its own accumulators to avoid data * dependencies. */ double Narray[UNROLL_SIZE] = { 0 }; double Sxarray[UNROLL_SIZE] = { 0 }; #ifdef NEED_SXX double Sxxarray[UNROLL_SIZE] = { 0 }; #endif size_t row = 0; #ifdef NEED_SXX /* * Initialize each state with the first matching row. We do this separately * to make the actual update function branchless, namely the computation of * Sxx which works differently for the first row. */ for (size_t inner = 0; inner < UNROLL_SIZE; inner++) { for (; row < n; row++) { const CTYPE newval = values[row]; if (arrow_row_is_valid(filter, row)) { Narray[inner] = 1; Sxarray[inner] = newval; Sxxarray[inner] = 0 * newval; row++; break; } } } /* * Scroll to the row that is a multiple of UNROLL_SIZE. This is the correct * row at which to enter the unrolled loop below. */ for (size_t inner = row % UNROLL_SIZE; inner > 0 && inner < UNROLL_SIZE && row < n; inner++, row++) { UPDATE(filter, values, row, &Narray[inner], &Sxarray[inner], &Sxxarray[inner]); } #endif /* * Unrolled loop. */ Assert(row % UNROLL_SIZE == 0 || row == n); for (; row < UNROLL_SIZE * (n / UNROLL_SIZE); row += UNROLL_SIZE) { for (size_t inner = 0; inner < UNROLL_SIZE; inner++) { UPDATE(filter, values, row + inner, &Narray[inner], &Sxarray[inner], &Sxxarray[inner]); } } /* * Process the odd tail. */ for (; row < n; row++) { const size_t inner = row % UNROLL_SIZE; UPDATE(filter, values, row, &Narray[inner], &Sxarray[inner], &Sxxarray[inner]); } /* * Merge all intermediate states into the first one. */ for (int i = 1; i < UNROLL_SIZE; i++) { COMBINE(&Narray[0], &Sxarray[0], &Sxxarray[0], Narray[i], Sxarray[i], Sxxarray[i]); } #undef UNROLL_SIZE /* * Merge the total computed state into the aggregate function state. */ FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; COMBINE(&state->N, &state->Sx, &state->Sxx, Narray[0], Sxarray[0], Sxxarray[0]); } static pg_attribute_always_inline void FUNCTION_NAME(one)(void *restrict agg_state, const CTYPE value) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; /* * This code follows the Postgres float8_accum() transition function, see * the comments there. */ const double newN = state->N + 1.0; const double newSx = state->Sx + value; #ifdef NEED_SXX if (state->N > 0.0) { const double tmp = value * newN - newSx; state->Sxx += tmp * tmp / (state->N * newN); } else { state->Sxx = 0 * value; } #endif state->N = newN; state->Sx = newSx; } #include "agg_many_vector_helper.c" #include "agg_scalar_helper.c" #include "agg_vector_validity_helper.c" VectorAggFunctions FUNCTION_NAME(argdef) = { .state_bytes = sizeof(FUNCTION_NAME(state)), .agg_init = FUNCTION_NAME(init), .agg_emit = FUNCTION_NAME(emit), .agg_scalar = FUNCTION_NAME(scalar), .agg_vector = FUNCTION_NAME(vector), .agg_many_vector = FUNCTION_NAME(many_vector), }; #undef UPDATE #undef COMBINE #endif #undef PG_TYPE #undef CTYPE #undef DATUM_TO_CTYPE #undef CTYPE_TO_DATUM #undef ACCUM_CASE #undef ACCUM_CASE_HELPER �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/float48_accum_templates.c����������������������0000664�0000000�0000000�00000001562�15100345067�0027400�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Common parts for aggregate functions that use the float{4,8}_accum transition. */ #include <postgres.h> #include <catalog/pg_type_d.h> #include <utils/array.h> #include <utils/float.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include "functions.h" #include "template_helper.h" #include <compression/arrow_c_data_interface.h> #ifndef GENERATE_DISPATCH_TABLE #endif /* * Templated parts for vectorized avg(float). */ #define AGG_NAME accum_no_squares #include "float48_accum_types.c" /* * Templated parts for vectorized functions that use the Sxx state (stddev etc). */ #define AGG_NAME accum_with_squares #define NEED_SXX #include "float48_accum_types.c" ����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/float48_accum_types.c��������������������������0000664�0000000�0000000�00000001333�15100345067�0026542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Functions handled by *accum() aggregate functions states, implementation for * all types. They use the same Youngs-Cramer state, but for AVG we can skip * calculating the Sxx variable. */ #define PG_TYPE FLOAT4 #define CTYPE float #define CTYPE_TO_DATUM Float4GetDatum #define DATUM_TO_CTYPE DatumGetFloat4 #include "float48_accum_single.c" #define PG_TYPE FLOAT8 #define CTYPE double #define CTYPE_TO_DATUM Float8GetDatum #define DATUM_TO_CTYPE DatumGetFloat8 #include "float48_accum_single.c" #undef AGG_NAME #undef NEED_SXX �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/functions.c������������������������������������0000664�0000000�0000000�00000011741�15100345067�0024701�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <limits.h> #include <postgres.h> #include <common/int.h> #include <utils/date.h> #include <utils/float.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include "functions.h" #include "compat/compat.h" /* * Aggregate function count(*). */ typedef struct { int64 count; } CountState; static void count_init(void *restrict agg_states, int n) { CountState *states = (CountState *) agg_states; for (int i = 0; i < n; i++) { states[i].count = 0; } } static void count_emit(void *agg_state, Datum *out_result, bool *out_isnull) { CountState *state = (CountState *) agg_state; *out_result = Int64GetDatum(state->count); *out_isnull = false; } static void count_star_scalar(void *agg_state, Datum constvalue, bool constisnull, int n, MemoryContext agg_extra_mctx) { CountState *state = (CountState *) agg_state; state->count += n; } static pg_attribute_always_inline void count_star_many_scalar_impl(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, Datum constvalue, bool constisnull, MemoryContext agg_extra_mctx) { CountState *states = (CountState *) agg_states; for (int row = start_row; row < end_row; row++) { if (arrow_row_is_valid(filter, row)) { states[offsets[row]].count++; } } } static pg_noinline void count_star_many_scalar_nofilter(void *restrict agg_states, const uint32 *offsets, int start_row, int end_row, Datum constvalue, bool constisnull, MemoryContext agg_extra_mctx) { count_star_many_scalar_impl(agg_states, offsets, NULL, start_row, end_row, constvalue, constisnull, agg_extra_mctx); } static void count_star_many_scalar(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, Datum constvalue, bool constisnull, MemoryContext agg_extra_mctx) { if (filter == NULL) { count_star_many_scalar_nofilter(agg_states, offsets, start_row, end_row, constvalue, constisnull, agg_extra_mctx); } else { count_star_many_scalar_impl(agg_states, offsets, filter, start_row, end_row, constvalue, constisnull, agg_extra_mctx); } } VectorAggFunctions count_star_agg = { .state_bytes = sizeof(CountState), .agg_init = count_init, .agg_scalar = count_star_scalar, .agg_emit = count_emit, .agg_many_scalar = count_star_many_scalar, }; /* * Aggregate function count(x). */ static void count_any_scalar(void *agg_state, Datum constvalue, bool constisnull, int n, MemoryContext agg_extra_mctx) { if (constisnull) { return; } CountState *state = (CountState *) agg_state; state->count += n; } static void count_any_vector(void *agg_state, const ArrowArray *vector, const uint64 *filter, MemoryContext agg_extra_mctx) { CountState *state = (CountState *) agg_state; const int n = vector->length; /* First, process the full words. */ for (int i = 0; i < n / 64; i++) { const uint64 filter_word = filter ? filter[i] : ~0ULL; #ifdef HAVE__BUILTIN_POPCOUNT state->count += __builtin_popcountll(filter_word); #else /* * Unfortunately, we have to have this fallback for Windows. */ for (uint16 i = 0; i < 64; i++) { const bool this_bit = (filter_word >> i) & 1; state->count += this_bit; } #endif } /* * The tail word needs special handling because not all rows there are valid * (some are past-the-end) even when the bitmap is null. */ for (int i = 64 * (n / 64); i < n; i++) { state->count += arrow_row_is_valid(filter, i); } } static void count_any_many_vector(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, const ArrowArray *vector, MemoryContext agg_extra_mctx) { for (int row = start_row; row < end_row; row++) { CountState *state = (offsets[row] + (CountState *) agg_states); if (arrow_row_is_valid(filter, row)) { state->count++; } } } VectorAggFunctions count_any_agg = { .state_bytes = sizeof(CountState), .agg_init = count_init, .agg_emit = count_emit, .agg_scalar = count_any_scalar, .agg_vector = count_any_vector, .agg_many_vector = count_any_many_vector, }; /* * Return the vector aggregate definition corresponding to the given * PG aggregate function Oid. */ VectorAggFunctions * get_vector_aggregate(Oid aggfnoid) { switch (aggfnoid) { case F_COUNT_: return &count_star_agg; case F_COUNT_ANY: return &count_any_agg; #define GENERATE_DISPATCH_TABLE 1 #include "float48_accum_templates.c" #include "int128_accum_templates.c" #include "int24_avg_accum_templates.c" #include "int24_sum_templates.c" #include "minmax_templates.c" #include "sum_float_templates.c" #undef GENERATE_DISPATCH_TABLE default: return NULL; } } �������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/functions.h������������������������������������0000664�0000000�0000000�00000004116�15100345067�0024704�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <compression/arrow_c_data_interface.h> /* * Function table for a vectorized implementation of an aggregate function. * * One state of aggregate function corresponds to one set of rows that are * supposed to be grouped together (e.g. for one grouping key). * * There are functions for adding a compressed batch to one aggregate function * state (no grouping keys), and to multiple aggregate function states laid out * contiguously in memory. */ typedef struct { /* Size of the aggregate function state. */ size_t state_bytes; /* * Initialize the n aggregate function states stored contiguously at the * given pointer. */ void (*agg_init)(void *restrict agg_states, int n); /* Aggregate a given arrow array. */ void (*agg_vector)(void *restrict agg_state, const ArrowArray *vector, const uint64 *filter, MemoryContext agg_extra_mctx); /* Aggregate a scalar value, like segmentby or column with default value. */ void (*agg_scalar)(void *restrict agg_state, Datum constvalue, bool constisnull, int n, MemoryContext agg_extra_mctx); /* * Add the rows of the given arrow array to aggregate function states given * by the respective offsets. */ void (*agg_many_vector)(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, const ArrowArray *vector, MemoryContext agg_extra_mctx); /* * Same as above, but for a scalar argument. This is mostly important for * count(*) and can be NULL. */ void (*agg_many_scalar)(void *restrict agg_states, const uint32 *offsets, const uint64 *filter, int start_row, int end_row, Datum constvalue, bool constisnull, MemoryContext agg_extra_mctx); /* Emit a partial aggregation result. */ void (*agg_emit)(void *restrict agg_state, Datum *out_result, bool *out_isnull); } VectorAggFunctions; VectorAggFunctions *get_vector_aggregate(Oid aggfnoid); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/int128_accum_single.c��������������������������0000664�0000000�0000000�00000006167�15100345067�0026435�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Vectorized implementation of a single transition function that uses the * Int128AggState transition state. Note that the serialization format differs * based on whether the sum of squares is needed. */ #ifdef GENERATE_DISPATCH_TABLE extern VectorAggFunctions FUNCTION_NAME(argdef); AGG_CASES return &FUNCTION_NAME(argdef); #else typedef struct { int64 N; int128 sumX; #ifdef NEED_SUMX2 int128 sumX2; #endif } FUNCTION_NAME(state); static void FUNCTION_NAME(init)(void *restrict agg_states, int n) { FUNCTION_NAME(state) *states = (FUNCTION_NAME(state) *) agg_states; for (int i = 0; i < n; i++) { states[i].N = 0; states[i].sumX = 0; #ifdef NEED_SUMX2 states[i].sumX2 = 0; #endif } } static void FUNCTION_NAME(emit)(void *agg_state, Datum *out_result, bool *out_isnull) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; PgInt128AggState result = { .N = state->N, .sumX = state->sumX, #ifdef NEED_SUMX2 .sumX2 = state->sumX2, #endif }; /* * The serialization functions insist on being called in aggregate context, * but thankfully don't use it in any way so we can use this dummy. */ AggState agg_context = { .ss.ps.type = T_AggState }; LOCAL_FCINFO(fcinfo, 1); InitFunctionCallInfoData(*fcinfo, NULL, 1, InvalidOid, (Node *) &agg_context, NULL); fcinfo->args[0].value = PointerGetDatum(&result); fcinfo->args[0].isnull = false; #ifdef NEED_SUMX2 *out_result = numeric_poly_serialize(fcinfo); #else *out_result = int8_avg_serialize(fcinfo); #endif *out_isnull = false; } static pg_attribute_always_inline void FUNCTION_NAME(vector_impl)(void *agg_state, int n, const CTYPE *values, const uint64 *filter, MemoryContext agg_extra_mctx) { int64 N = 0; int128 sumX = 0; #ifdef NEED_SUMX2 int128 sumX2 = 0; #endif for (int row = 0; row < n; row++) { const bool row_ok = arrow_row_is_valid(filter, row); const CTYPE value = values[row]; N += row_ok; sumX += value * row_ok; #ifdef NEED_SUMX2 sumX2 += ((int128) value) * ((int128) value) * row_ok; #endif } FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; state->N += N; state->sumX += sumX; #ifdef NEED_SUMX2 state->sumX2 += sumX2; #endif } static pg_attribute_always_inline void FUNCTION_NAME(one)(void *restrict agg_state, const CTYPE value) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; state->N++; state->sumX += value; #ifdef NEED_SUMX2 state->sumX2 += ((int128) value) * ((int128) value); #endif } #include "agg_many_vector_helper.c" #include "agg_scalar_helper.c" #include "agg_vector_validity_helper.c" VectorAggFunctions FUNCTION_NAME(argdef) = { .state_bytes = sizeof(FUNCTION_NAME(state)), .agg_init = FUNCTION_NAME(init), .agg_emit = FUNCTION_NAME(emit), .agg_scalar = FUNCTION_NAME(scalar), .agg_vector = FUNCTION_NAME(vector), .agg_many_vector = FUNCTION_NAME(many_vector), }; #endif #undef PG_TYPE #undef CTYPE #undef DATUM_TO_CTYPE #undef AGG_CASES #undef AGG_NAME #undef NEED_SUMX2 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/int128_accum_templates.c�����������������������0000664�0000000�0000000�00000005756�15100345067�0027155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Vectorized transition functions that use the Int128AggState transition state. */ #include <postgres.h> #include <nodes/execnodes.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include "functions.h" #include "template_helper.h" #include <compression/arrow_c_data_interface.h> #ifdef HAVE_INT128 #ifndef GENERATE_DISPATCH_TABLE /* * The PG aggregation state that we have to serialize. Copied from numeric.c. */ typedef struct { bool calcSumX2; /* if true, calculate sumX2 */ int64 N; /* count of processed numbers */ int128 sumX; /* sum of processed numbers */ int128 sumX2; /* sum of squares of processed numbers */ } PgInt128AggState; #endif /* * Vectorized implementation of int8_avg_accum() function. */ #define AGG_NAME accum_no_squares #define AGG_CASES \ case PG_AGG_OID_HELPER(SUM, PG_TYPE): \ case PG_AGG_OID_HELPER(AVG, PG_TYPE): #define PG_TYPE INT8 #define CTYPE int64 #define DATUM_TO_CTYPE DatumGetInt64 #include "int128_accum_single.c" /* * Vectorized implementation of int2_accum() function. */ #define NEED_SUMX2 #define AGG_NAME accum_with_squares #define AGG_CASES \ case PG_AGG_OID_HELPER(STDDEV, PG_TYPE): \ case PG_AGG_OID_HELPER(STDDEV_SAMP, PG_TYPE): \ case PG_AGG_OID_HELPER(STDDEV_POP, PG_TYPE): \ case PG_AGG_OID_HELPER(VARIANCE, PG_TYPE): \ case PG_AGG_OID_HELPER(VAR_SAMP, PG_TYPE): \ case PG_AGG_OID_HELPER(VAR_POP, PG_TYPE): #define PG_TYPE INT2 #define CTYPE int16 #define DATUM_TO_CTYPE DatumGetInt16 #include "int128_accum_single.c" /* * Vectorized implementation of int4_accum() function. */ #define NEED_SUMX2 #define AGG_NAME accum_with_squares #define AGG_CASES \ case PG_AGG_OID_HELPER(STDDEV, PG_TYPE): \ case PG_AGG_OID_HELPER(STDDEV_SAMP, PG_TYPE): \ case PG_AGG_OID_HELPER(STDDEV_POP, PG_TYPE): \ case PG_AGG_OID_HELPER(VARIANCE, PG_TYPE): \ case PG_AGG_OID_HELPER(VAR_SAMP, PG_TYPE): \ case PG_AGG_OID_HELPER(VAR_POP, PG_TYPE): #define PG_TYPE INT4 #define CTYPE int32 #define DATUM_TO_CTYPE DatumGetInt32 #include "int128_accum_single.c" #endif ������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/int24_avg_accum_single.c�����������������������0000664�0000000�0000000�00000003044�15100345067�0027174�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifdef GENERATE_DISPATCH_TABLE extern VectorAggFunctions FUNCTION_NAME(argdef); case PG_AGG_OID_HELPER(AGG_NAME, PG_TYPE): return &FUNCTION_NAME(argdef); #else static pg_attribute_always_inline void FUNCTION_NAME(vector_impl)(void *agg_state, int n, const CTYPE *values, const uint64 *filter, MemoryContext agg_extra_mctx) { int64 batch_count = 0; int64 batch_sum = 0; for (int row = 0; row < n; row++) { const bool row_ok = arrow_row_is_valid(filter, row); batch_count += row_ok; batch_sum += values[row] * row_ok; } Int24AvgAccumState *state = (Int24AvgAccumState *) agg_state; state->count += batch_count; state->sum += batch_sum; } typedef Int24AvgAccumState FUNCTION_NAME(state); static pg_attribute_always_inline void FUNCTION_NAME(one)(void *restrict agg_state, const CTYPE value) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; state->count++; state->sum += value; } #include "agg_many_vector_helper.c" #include "agg_scalar_helper.c" #include "agg_vector_validity_helper.c" VectorAggFunctions FUNCTION_NAME(argdef) = { .state_bytes = sizeof(Int24AvgAccumState), .agg_init = int24_avg_accum_init, .agg_emit = int24_avg_accum_emit, .agg_scalar = FUNCTION_NAME(scalar), .agg_vector = FUNCTION_NAME(vector), .agg_many_vector = FUNCTION_NAME(many_vector), }; #endif #undef PG_TYPE #undef CTYPE #undef DATUM_TO_CTYPE ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/int24_avg_accum_templates.c��������������������0000664�0000000�0000000�00000003436�15100345067�0027716�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Vectorized implementation for int{2,4}_avg_accum transition functions. */ #include <postgres.h> #include <catalog/pg_type_d.h> #include <utils/array.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include "functions.h" #include "template_helper.h" #include <compression/arrow_c_data_interface.h> #ifndef GENERATE_DISPATCH_TABLE typedef struct { int64 count; int64 sum; } Int24AvgAccumState; static void int24_avg_accum_init(void *restrict agg_states, int n) { Int24AvgAccumState *states = (Int24AvgAccumState *) agg_states; for (int i = 0; i < n; i++) { states[i].count = 0; states[i].sum = 0; } } static void int24_avg_accum_emit(void *agg_state, Datum *out_result, bool *out_isnull) { Int24AvgAccumState *state = (Int24AvgAccumState *) agg_state; const size_t nbytes = 2 * sizeof(int64) + ARR_OVERHEAD_NONULLS(/* ndims = */ 1); ArrayType *result = palloc(nbytes); SET_VARSIZE(result, nbytes); result->ndim = 1; result->dataoffset = 0; result->elemtype = INT8OID; ARR_DIMS(result)[0] = 2; ARR_LBOUND(result)[0] = 1; /* * The array elements are stored by value, regardless of if the int8 itself * is by-value on this platform. */ ((int64 *) ARR_DATA_PTR(result))[0] = state->count; ((int64 *) ARR_DATA_PTR(result))[1] = state->sum; *out_result = PointerGetDatum(result); *out_isnull = false; } #endif #define AGG_NAME AVG #define PG_TYPE INT2 #define CTYPE int16 #define DATUM_TO_CTYPE DatumGetInt16 #include "int24_avg_accum_single.c" #define PG_TYPE INT4 #define CTYPE int32 #define DATUM_TO_CTYPE DatumGetInt32 #include "int24_avg_accum_single.c" #undef AGG_NAME ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/int24_sum_single.c�����������������������������0000664�0000000�0000000�00000004624�15100345067�0026060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifdef GENERATE_DISPATCH_TABLE extern VectorAggFunctions FUNCTION_NAME(argdef); case PG_AGG_OID_HELPER(AGG_NAME, PG_TYPE): return &FUNCTION_NAME(argdef); #else static pg_attribute_always_inline void FUNCTION_NAME(vector_impl)(void *agg_state, int n, const CTYPE *values, const uint64 *filter, MemoryContext agg_extra_mctx) { Int24SumState *state = (Int24SumState *) agg_state; /* * We accumulate the sum as int64, so we can sum INT_MAX = 2^31 - 1 * at least 2^31 times without incurring an overflow of the int64 * accumulator. The same is true for negative numbers. The * compressed batch size is currently capped at 1000 rows, but even * if it's changed in the future, it's unlikely that we support * batches larger than 65536 rows, not to mention 2^31. Therefore, * we don't need to check for overflows within the loop, which would * slow down the calculation. */ Assert(n <= INT_MAX); /* * Note that we use a simplest loop here, there are many possibilities of * optimizing this function (for example, this loop is not unrolled by * clang-16). */ int64 batch_sum = 0; bool have_result = false; for (int row = 0; row < n; row++) { const bool row_ok = arrow_row_is_valid(filter, row); batch_sum += values[row] * row_ok; have_result = have_result || row_ok; } if (unlikely(pg_add_s64_overflow(state->result, batch_sum, &state->result))) { ereport(ERROR, (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), errmsg("bigint out of range"))); } state->isvalid = state->isvalid || have_result; } static pg_attribute_always_inline void FUNCTION_NAME(one)(void *restrict agg_state, const CTYPE value) { Int24SumState *state = (Int24SumState *) agg_state; state->result += value; state->isvalid = true; } typedef Int24SumState FUNCTION_NAME(state); #include "agg_many_vector_helper.c" #include "agg_scalar_helper.c" #include "agg_vector_validity_helper.c" VectorAggFunctions FUNCTION_NAME(argdef) = { .state_bytes = sizeof(Int24SumState), .agg_init = int_sum_init, .agg_emit = int_sum_emit, .agg_scalar = FUNCTION_NAME(scalar), .agg_vector = FUNCTION_NAME(vector), .agg_many_vector = FUNCTION_NAME(many_vector), }; #endif #undef PG_TYPE #undef CTYPE #undef DATUM_TO_CTYPE #undef CTYPE_TO_DATUM ������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/int24_sum_templates.c��������������������������0000664�0000000�0000000�00000002425�15100345067�0026572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Common parts for vectorized sum(int). */ #include <limits.h> #include <postgres.h> #include <common/int.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include "functions.h" #include "template_helper.h" #include <compression/arrow_c_data_interface.h> #ifndef GENERATE_DISPATCH_TABLE typedef struct { int64 result; bool isvalid; } Int24SumState; static void int_sum_init(void *restrict agg_states, int n) { Int24SumState *states = (Int24SumState *) agg_states; for (int i = 0; i < n; i++) { states[i].result = 0; states[i].isvalid = false; } } static void int_sum_emit(void *agg_state, Datum *out_result, bool *out_isnull) { Int24SumState *state = (Int24SumState *) agg_state; *out_result = Int64GetDatum(state->result); *out_isnull = !state->isvalid; } #endif /* * Templated parts for vectorized sum(int). */ #define AGG_NAME SUM #define PG_TYPE INT4 #define CTYPE int32 #define DATUM_TO_CTYPE DatumGetInt32 #include "int24_sum_single.c" #define PG_TYPE INT2 #define CTYPE int16 #define DATUM_TO_CTYPE DatumGetInt16 #include "int24_sum_single.c" #undef AGG_NAME �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/minmax_arithmetic_single.c���������������������0000664�0000000�0000000�00000004462�15100345067�0027736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifdef GENERATE_DISPATCH_TABLE extern VectorAggFunctions FUNCTION_NAME(argdef); case PG_AGG_OID_HELPER(AGG_NAME, PG_TYPE): return &FUNCTION_NAME(argdef); #else static pg_attribute_always_inline void FUNCTION_NAME(vector_impl)(void *agg_state, int n, const CTYPE *values, const uint64 *filter, MemoryContext agg_extra_mctx) { MinMaxState *state = (MinMaxState *) agg_state; CTYPE outer_result = state->isvalid ? DATUM_TO_CTYPE(state->value) : 0; bool outer_isvalid = state->isvalid; for (int row = 0; row < n; row++) { const CTYPE new_value = values[row]; const bool new_value_ok = arrow_row_is_valid(filter, row); /* * Note that we have to properly handle NaNs and Infinities for floats. */ const bool do_replace = new_value_ok && (unlikely(!outer_isvalid) || PREDICATE(outer_result, new_value)); outer_result = do_replace ? new_value : outer_result; outer_isvalid = outer_isvalid || do_replace; } state->isvalid = outer_isvalid; /* Note that float8 Datum is by-reference on 32-bit systems. */ MemoryContext old = MemoryContextSwitchTo(agg_extra_mctx); state->value = CTYPE_TO_DATUM(outer_result); MemoryContextSwitchTo(old); } typedef MinMaxState FUNCTION_NAME(state); static pg_attribute_always_inline void FUNCTION_NAME(one)(void *restrict agg_state, const CTYPE value) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; if (!state->isvalid || PREDICATE(DATUM_TO_CTYPE(state->value), value) || isnan((double) value)) { /* * Note that float8 Datum is by-reference on 32-bit systems, and this * function is called in the extra aggregate data memory context. */ state->value = CTYPE_TO_DATUM(value); state->isvalid = true; } } #include "agg_many_vector_helper.c" #include "agg_scalar_helper.c" #include "agg_vector_validity_helper.c" VectorAggFunctions FUNCTION_NAME(argdef) = { .state_bytes = sizeof(MinMaxState), .agg_init = minmax_init, .agg_emit = minmax_emit, .agg_scalar = FUNCTION_NAME(scalar), .agg_vector = FUNCTION_NAME(vector), .agg_many_vector = FUNCTION_NAME(many_vector), }; #endif #undef PG_TYPE #undef CTYPE #undef DATUM_TO_CTYPE #undef CTYPE_TO_DATUM ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/minmax_arithmetic_types.c����������������������0000664�0000000�0000000�00000002752�15100345067�0027621�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #define PG_TYPE INT2 #define CTYPE int16 #define DATUM_TO_CTYPE DatumGetInt16 #define CTYPE_TO_DATUM Int16GetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE INT4 #define CTYPE int32 #define DATUM_TO_CTYPE DatumGetInt32 #define CTYPE_TO_DATUM Int32GetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE INT8 #define CTYPE int64 #define DATUM_TO_CTYPE DatumGetInt64 #define CTYPE_TO_DATUM Int64GetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE FLOAT4 #define CTYPE float #define DATUM_TO_CTYPE DatumGetFloat4 #define CTYPE_TO_DATUM Float4GetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE FLOAT8 #define CTYPE double #define DATUM_TO_CTYPE DatumGetFloat8 #define CTYPE_TO_DATUM Float8GetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE TIMESTAMP #define CTYPE Timestamp #define DATUM_TO_CTYPE DatumGetTimestamp #define CTYPE_TO_DATUM TimestampGetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE TIMESTAMPTZ #define CTYPE TimestampTz #define DATUM_TO_CTYPE DatumGetTimestampTz #define CTYPE_TO_DATUM TimestampTzGetDatum #include "minmax_arithmetic_single.c" #define PG_TYPE DATE #define CTYPE DateADT #define DATUM_TO_CTYPE DatumGetDateADT #define CTYPE_TO_DATUM DateADTGetDatum #include "minmax_arithmetic_single.c" #undef PREDICATE #undef AGG_NAME ����������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/minmax_templates.c�����������������������������0000664�0000000�0000000�00000003074�15100345067�0026240�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <utils/date.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #include <utils/timestamp.h> #include "functions.h" #include "template_helper.h" #include <compression/arrow_c_data_interface.h> /* * Common parts for vectorized min(), max(). */ #ifndef GENERATE_DISPATCH_TABLE typedef struct { bool isvalid; Datum value; } MinMaxState; static void minmax_init(void *restrict agg_states, int n) { MinMaxState *states = (MinMaxState *) agg_states; for (int i = 0; i < n; i++) { states[i].isvalid = false; states[i].value = 0; } } static void minmax_emit(void *agg_state, Datum *out_result, bool *out_isnull) { MinMaxState *state = (MinMaxState *) agg_state; *out_result = state->value; *out_isnull = !state->isvalid; } #endif /* * Templated parts for vectorized min(), max(). * * NaN handled similar to equivalent PG functions. */ #define AGG_NAME MIN #define PREDICATE(CURRENT, NEW) \ (unlikely(!isnan((double) (NEW))) && (isnan((double) (CURRENT)) || (CURRENT) > (NEW))) #include "minmax_arithmetic_types.c" #define AGG_NAME MAX #define PREDICATE(CURRENT, NEW) \ (unlikely(!isnan((double) (CURRENT))) && (isnan((double) (NEW)) || (CURRENT) < (NEW))) #include "minmax_arithmetic_types.c" #undef AGG_NAME ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/sum_float_single.c�����������������������������0000664�0000000�0000000�00000007406�15100345067�0026226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #ifdef GENERATE_DISPATCH_TABLE extern VectorAggFunctions FUNCTION_NAME(argdef); case PG_AGG_OID_HELPER(AGG_NAME, PG_TYPE): return &FUNCTION_NAME(argdef); #else StaticAssertDecl(sizeof(CTYPE) == sizeof(MASKTYPE), "CTYPE and MASKTYPE must be the same size"); static void FUNCTION_NAME(emit)(void *agg_state, Datum *out_result, bool *out_isnull) { FloatSumState *state = (FloatSumState *) agg_state; const CTYPE result_casted = state->result; *out_result = CTYPE_TO_DATUM(result_casted); *out_isnull = !state->isvalid; } static pg_attribute_always_inline void FUNCTION_NAME(vector_impl)(void *agg_state, int n, const CTYPE *values, const uint64 *filter, MemoryContext agg_extra_mctx) { /* * Vector registers can be up to 512 bits wide. */ #define UNROLL_SIZE ((int) (512 / 8 / sizeof(CTYPE))) bool have_result_accu[UNROLL_SIZE] = { 0 }; double sum_accu[UNROLL_SIZE] = { 0 }; for (int outer = 0; outer < UNROLL_SIZE * (n / UNROLL_SIZE); outer += UNROLL_SIZE) { for (int inner = 0; inner < UNROLL_SIZE; inner++) { const int row = outer + inner; double *dest = &sum_accu[inner]; bool *have_result = &have_result_accu[inner]; /* * We're using a trick with bitmasking the numbers that don't * pass the filter, to allow for branchless code generation. This is * analogous to integer version where we just multiply the integers * by bool, but for floats we can't use multiplication because of * infinities and NaNs. */ #define INNER_LOOP \ const bool row_valid = arrow_row_is_valid(filter, row); \ union \ { \ CTYPE f; \ MASKTYPE m; \ } u = { .f = values[row] }; \ u.m &= row_valid ? ~(MASKTYPE) 0 : (MASKTYPE) 0; \ *dest += u.f; \ *have_result = *have_result || row_valid; INNER_LOOP } } for (int row = UNROLL_SIZE * (n / UNROLL_SIZE); row < n; row++) { double *dest = &sum_accu[0]; bool *have_result = &have_result_accu[0]; INNER_LOOP } for (int i = 1; i < UNROLL_SIZE; i++) { sum_accu[0] += sum_accu[i]; have_result_accu[0] = have_result_accu[0] || have_result_accu[i]; } #undef UNROLL_SIZE #undef INNER_LOOP FloatSumState *state = (FloatSumState *) agg_state; state->isvalid = state->isvalid || have_result_accu[0]; state->result += sum_accu[0]; } typedef FloatSumState FUNCTION_NAME(state); static pg_attribute_always_inline void FUNCTION_NAME(one)(void *restrict agg_state, const CTYPE value) { FUNCTION_NAME(state) *state = (FUNCTION_NAME(state) *) agg_state; state->isvalid = true; state->result += value; } #include "agg_many_vector_helper.c" #include "agg_scalar_helper.c" #include "agg_vector_validity_helper.c" VectorAggFunctions FUNCTION_NAME(argdef) = { .state_bytes = sizeof(FloatSumState), .agg_init = float_sum_init, .agg_emit = FUNCTION_NAME(emit), .agg_scalar = FUNCTION_NAME(scalar), .agg_vector = FUNCTION_NAME(vector), .agg_many_vector = FUNCTION_NAME(many_vector), }; #endif #undef PG_TYPE #undef CTYPE #undef MASKTYPE #undef DATUM_TO_CTYPE #undef CTYPE_TO_DATUM ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/sum_float_templates.c��������������������������0000664�0000000�0000000�00000002232�15100345067�0026733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Common parts for vectorized sum(float). */ #include <postgres.h> #include "functions.h" #include "template_helper.h" #include <compression/arrow_c_data_interface.h> #include <utils/fmgroids.h> #include <utils/fmgrprotos.h> #ifndef GENERATE_DISPATCH_TABLE typedef struct { double result; bool isvalid; } FloatSumState; static void float_sum_init(void *restrict agg_states, int n) { FloatSumState *states = (FloatSumState *) agg_states; for (int i = 0; i < n; i++) { states[i].result = 0; states[i].isvalid = false; } } #endif /* * Templated parts for vectorized sum(float). */ #define AGG_NAME SUM #define PG_TYPE FLOAT4 #define CTYPE float #define MASKTYPE uint32 #define CTYPE_TO_DATUM Float4GetDatum #define DATUM_TO_CTYPE DatumGetFloat4 #include "sum_float_single.c" #define PG_TYPE FLOAT8 #define CTYPE double #define MASKTYPE uint64 #define CTYPE_TO_DATUM Float8GetDatum #define DATUM_TO_CTYPE DatumGetFloat8 #include "sum_float_single.c" #undef AGG_NAME ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/function/template_helper.h������������������������������0000664�0000000�0000000�00000000773�15100345067�0026053�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #define PG_AGG_OID(AGG_NAME, ARGUMENT_TYPE) F_##AGG_NAME##_##ARGUMENT_TYPE #define PG_AGG_OID_HELPER(X, Y) PG_AGG_OID(X, Y) #define FUNCTION_NAME_HELPER2(X, Y, Z) X##_##Y##_##Z #define FUNCTION_NAME_HELPER(X, Y, Z) FUNCTION_NAME_HELPER2(X, Y, Z) #define FUNCTION_NAME(Z) FUNCTION_NAME_HELPER(AGG_NAME, PG_TYPE, Z) �����timescaledb-2.23.0/tsl/src/nodes/vector_agg/grouping_policy.h���������������������������������������0000664�0000000�0000000�00000004246�15100345067�0024264�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <executor/tuptable.h> typedef struct GroupingPolicy GroupingPolicy; typedef struct TupleTableSlot TupleTableSlot; typedef struct VectorAggDef VectorAggDef; typedef struct GroupingColumn GroupingColumn; /* * This is a common interface for grouping policies which define how the rows * are grouped for aggregation -- e.g. there can be an implementation for no * grouping, grouping by compression segmentby columns, grouping over sorted * input (GroupAggregate), grouping using a hash table, and so on. */ typedef struct GroupingPolicy { /* * Used for rescans in the Postgres sense. */ void (*gp_reset)(GroupingPolicy *gp); /* * Aggregate a single compressed batch. */ void (*gp_add_batch)(GroupingPolicy *gp, TupleTableSlot *vector_slot); /* * Is a partial aggregation result ready? */ bool (*gp_should_emit)(GroupingPolicy *gp); /* * Emit a partial aggregation result into the result slot. */ bool (*gp_do_emit)(GroupingPolicy *gp, TupleTableSlot *aggregated_slot); /* * Destroy the grouping policy. */ void (*gp_destroy)(GroupingPolicy *gp); /* * Description of this grouping policy for the EXPLAIN output. */ char *(*gp_explain)(GroupingPolicy *gp); } GroupingPolicy; /* * The various types of grouping we might use, as determined at planning time. * The hashed subtypes are all implemented by hash grouping policy. */ typedef enum { VAGT_Invalid, VAGT_Batch, VAGT_HashSingleFixed2, VAGT_HashSingleFixed4, VAGT_HashSingleFixed8, VAGT_HashSingleText, VAGT_HashSerialized, } VectorAggGroupingType; extern GroupingPolicy *create_grouping_policy_batch(int num_agg_defs, VectorAggDef *agg_defs, int num_grouping_columns, GroupingColumn *grouping_columns); extern GroupingPolicy *create_grouping_policy_hash(int num_agg_defs, VectorAggDef *agg_defs, int num_grouping_columns, GroupingColumn *grouping_columns, VectorAggGroupingType grouping_type); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/grouping_policy_batch.c���������������������������������0000664�0000000�0000000�00000021723�15100345067�0025417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This grouping policy aggregates entire compressed batches. It can be used to * aggregate with no grouping, or to produce partial aggregates per each batch * to group by segmentby columns. */ #include <postgres.h> #include <access/attnum.h> #include <executor/tuptable.h> #include <nodes/pg_list.h> #include "grouping_policy.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/vector_slot.h" typedef struct { GroupingPolicy funcs; int num_agg_defs; VectorAggDef *agg_defs; /* * Temporary storage for combined bitmap of batch filter and aggregate * argument validity. */ uint64 *tmp_filter; uint64 num_tmp_filter_words; void **agg_states; int num_grouping_columns; GroupingColumn *grouping_columns; Datum *output_grouping_values; bool *output_grouping_isnull; bool have_results; /* * A memory context for aggregate functions to allocate additional data, * i.e. if they store strings or float8 datum on 32-bit systems, or they * have variable-length state like the exact distinct function or the * statistical sketches. * Valid until the grouping policy is reset. */ MemoryContext agg_extra_mctx; } GroupingPolicyBatch; static const GroupingPolicy grouping_policy_batch_functions; GroupingPolicy * create_grouping_policy_batch(int num_agg_defs, VectorAggDef *agg_defs, int num_grouping_columns, GroupingColumn *output_grouping_columns) { GroupingPolicyBatch *policy = palloc0(sizeof(GroupingPolicyBatch)); policy->funcs = grouping_policy_batch_functions; policy->num_grouping_columns = num_grouping_columns; policy->grouping_columns = output_grouping_columns; policy->num_agg_defs = num_agg_defs; policy->agg_defs = agg_defs; policy->agg_extra_mctx = AllocSetContextCreate(CurrentMemoryContext, "agg extra", ALLOCSET_DEFAULT_SIZES); policy->agg_states = (void **) palloc(sizeof(*policy->agg_states) * policy->num_agg_defs); for (int i = 0; i < policy->num_agg_defs; i++) { VectorAggDef *agg_def = &policy->agg_defs[i]; policy->agg_states[i] = palloc(agg_def->func.state_bytes); } policy->output_grouping_values = (Datum *) palloc0(MAXALIGN(num_grouping_columns * sizeof(Datum)) + MAXALIGN(num_grouping_columns * sizeof(bool))); policy->output_grouping_isnull = (bool *) ((char *) policy->output_grouping_values + MAXALIGN(num_grouping_columns * sizeof(Datum))); return &policy->funcs; } static void gp_batch_reset(GroupingPolicy *obj) { GroupingPolicyBatch *policy = (GroupingPolicyBatch *) obj; MemoryContextReset(policy->agg_extra_mctx); const int naggs = policy->num_agg_defs; for (int i = 0; i < naggs; i++) { VectorAggDef *agg_def = &policy->agg_defs[i]; void *agg_state = policy->agg_states[i]; agg_def->func.agg_init(agg_state, 1); } const int ngrp = policy->num_grouping_columns; for (int i = 0; i < ngrp; i++) { policy->output_grouping_values[i] = 0; policy->output_grouping_isnull[i] = true; } policy->have_results = false; } static void compute_single_aggregate(GroupingPolicyBatch *policy, TupleTableSlot *vector_slot, VectorAggDef *agg_def, void *agg_state, MemoryContext agg_extra_mctx) { const ArrowArray *arg_arrow = NULL; const uint64 *arg_validity_bitmap = NULL; Datum arg_datum = 0; bool arg_isnull = true; uint16 total_batch_rows = 0; const uint64 *vector_qual_result = vector_slot_get_qual_result(vector_slot, &total_batch_rows); /* * We have functions with one argument, and one function with no arguments * (count(*)). Collect the arguments. */ if (agg_def->input_offset >= 0) { const AttrNumber attnum = AttrOffsetGetAttrNumber(agg_def->input_offset); const CompressedColumnValues *values = vector_slot_get_compressed_column_values(vector_slot, attnum); Assert(values->decompression_type != DT_Invalid); Ensure(values->decompression_type != DT_Iterator, "expected arrow array but got iterator for attnum %d", attnum); if (values->arrow != NULL) { arg_arrow = values->arrow; arg_validity_bitmap = values->buffers[0]; } else { Assert(values->decompression_type == DT_Scalar); arg_datum = *values->output_value; arg_isnull = *values->output_isnull; } } /* * Compute the unified validity bitmap. */ const size_t num_words = (total_batch_rows + 63) / 64; const uint64 *filter = arrow_combine_validity(num_words, policy->tmp_filter, vector_qual_result, agg_def->filter_result, arg_validity_bitmap); /* * Now call the function. */ if (arg_arrow != NULL) { /* Arrow argument. */ agg_def->func.agg_vector(agg_state, arg_arrow, filter, agg_extra_mctx); } else { /* * Scalar argument, or count(*). Have to also count the valid rows in * the batch. * * The batches that are fully filtered out by vectorized quals should * have been skipped by the caller, but we also have to check for the * case when no rows match the aggregate FILTER clause. */ const int n = arrow_num_valid(filter, total_batch_rows); if (n > 0) { agg_def->func.agg_scalar(agg_state, arg_datum, arg_isnull, n, agg_extra_mctx); } } } static void gp_batch_add_batch(GroupingPolicy *gp, TupleTableSlot *vector_slot) { GroupingPolicyBatch *policy = (GroupingPolicyBatch *) gp; uint16 total_batch_rows = 0; vector_slot_get_qual_result(vector_slot, &total_batch_rows); /* * Allocate the temporary filter array for computing the combined results of * batch filter, aggregate filter and column validity. */ const size_t num_words = (total_batch_rows + 63) / 64; if (num_words > policy->num_tmp_filter_words) { const size_t new_words = (num_words * 2) + 1; if (policy->tmp_filter != NULL) { pfree(policy->tmp_filter); } policy->tmp_filter = palloc(sizeof(*policy->tmp_filter) * new_words); policy->num_tmp_filter_words = new_words; } /* * Compute the aggregates. */ const int naggs = policy->num_agg_defs; for (int i = 0; i < naggs; i++) { VectorAggDef *agg_def = &policy->agg_defs[i]; void *agg_state = policy->agg_states[i]; compute_single_aggregate(policy, vector_slot, agg_def, agg_state, policy->agg_extra_mctx); } /* * Save the values of the grouping columns. */ const int ngrp = policy->num_grouping_columns; for (int i = 0; i < ngrp; i++) { GroupingColumn *col = &policy->grouping_columns[i]; const AttrNumber attnum = AttrOffsetGetAttrNumber(col->input_offset); Assert(col->input_offset >= 0); Assert(col->output_offset >= 0); const CompressedColumnValues *values = vector_slot_get_compressed_column_values(vector_slot, attnum); Assert(values->decompression_type == DT_Scalar); /* * By sheer luck, we can avoid generically copying the Datum here, * because if we have any output grouping columns in this policy, it * means we're grouping by segmentby, and these values will be valid * until the next call to the vector agg node. */ policy->output_grouping_values[i] = *values->output_value; policy->output_grouping_isnull[i] = *values->output_isnull; } policy->have_results = true; } static bool gp_batch_should_emit(GroupingPolicy *gp) { GroupingPolicyBatch *policy = (GroupingPolicyBatch *) gp; /* * If we're grouping by segmentby columns, we have to output partials for * every batch. */ return policy->num_grouping_columns > 0 && policy->have_results; } static bool gp_batch_do_emit(GroupingPolicy *gp, TupleTableSlot *aggregated_slot) { GroupingPolicyBatch *policy = (GroupingPolicyBatch *) gp; if (!policy->have_results) { return false; } const int naggs = policy->num_agg_defs; for (int i = 0; i < naggs; i++) { VectorAggDef *agg_def = &policy->agg_defs[i]; void *agg_state = policy->agg_states[i]; agg_def->func.agg_emit(agg_state, &aggregated_slot->tts_values[agg_def->output_offset], &aggregated_slot->tts_isnull[agg_def->output_offset]); } const int ngrp = policy->num_grouping_columns; for (int i = 0; i < ngrp; i++) { GroupingColumn *col = &policy->grouping_columns[i]; Assert(col->input_offset >= 0); Assert(col->output_offset >= 0); aggregated_slot->tts_values[col->output_offset] = policy->output_grouping_values[i]; aggregated_slot->tts_isnull[col->output_offset] = policy->output_grouping_isnull[i]; } /* * We only have one partial aggregation result for this policy. */ policy->have_results = false; return true; } static char * gp_batch_explain(GroupingPolicy *gp) { GroupingPolicyBatch *policy = (GroupingPolicyBatch *) gp; /* * If we're grouping by segmentby columns, we have to output partials for * every batch. */ return policy->num_grouping_columns > 0 ? "per compressed batch" : "all compressed batches"; } static const GroupingPolicy grouping_policy_batch_functions = { .gp_reset = gp_batch_reset, .gp_add_batch = gp_batch_add_batch, .gp_should_emit = gp_batch_should_emit, .gp_do_emit = gp_batch_do_emit, .gp_explain = gp_batch_explain, }; ���������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/grouping_policy_hash.c����������������������������������0000664�0000000�0000000�00000035240�15100345067�0025260�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This grouping policy groups the rows using a hash table. Currently it only * supports a single fixed-size by-value compressed column that fits into a Datum. */ #include <postgres.h> #include <access/attnum.h> #include <access/tupdesc.h> #include <executor/tuptable.h> #include <nodes/pg_list.h> #include "grouping_policy.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/vector_slot.h" #include "grouping_policy_hash.h" #ifdef USE_FLOAT8_BYVAL #define DEBUG_LOG(MSG, ...) elog(DEBUG3, MSG, __VA_ARGS__) #else /* * On 32-bit platforms we'd have to use the cross-platform int width printf * specifiers which are really unreadable. */ #define DEBUG_LOG(...) #endif extern HashingStrategy single_fixed_2_strategy; extern HashingStrategy single_fixed_4_strategy; extern HashingStrategy single_fixed_8_strategy; #ifdef TS_USE_UMASH extern HashingStrategy single_text_strategy; extern HashingStrategy serialized_strategy; #endif static const GroupingPolicy grouping_policy_hash_functions; GroupingPolicy * create_grouping_policy_hash(int num_agg_defs, VectorAggDef *agg_defs, int num_grouping_columns, GroupingColumn *grouping_columns, VectorAggGroupingType grouping_type) { GroupingPolicyHash *policy = palloc0(sizeof(GroupingPolicyHash)); policy->funcs = grouping_policy_hash_functions; policy->num_grouping_columns = num_grouping_columns; policy->grouping_columns = grouping_columns; policy->agg_extra_mctx = AllocSetContextCreate(CurrentMemoryContext, "agg extra", ALLOCSET_DEFAULT_SIZES); policy->num_allocated_per_key_agg_states = TARGET_COMPRESSED_BATCH_SIZE; policy->num_agg_defs = num_agg_defs; policy->agg_defs = agg_defs; policy->per_agg_per_key_states = palloc(sizeof(*policy->per_agg_per_key_states) * policy->num_agg_defs); for (int i = 0; i < policy->num_agg_defs; i++) { const VectorAggDef *agg_def = &policy->agg_defs[i]; policy->per_agg_per_key_states[i] = palloc(agg_def->func.state_bytes * policy->num_allocated_per_key_agg_states); } policy->current_batch_grouping_column_values = palloc(sizeof(CompressedColumnValues) * num_grouping_columns); switch (grouping_type) { #ifdef TS_USE_UMASH case VAGT_HashSerialized: policy->hashing = serialized_strategy; break; case VAGT_HashSingleText: policy->hashing = single_text_strategy; break; #endif case VAGT_HashSingleFixed8: policy->hashing = single_fixed_8_strategy; break; case VAGT_HashSingleFixed4: policy->hashing = single_fixed_4_strategy; break; case VAGT_HashSingleFixed2: policy->hashing = single_fixed_2_strategy; break; default: Ensure(false, "failed to determine the hashing strategy"); break; } policy->hashing.key_body_mctx = policy->agg_extra_mctx; policy->hashing.init(&policy->hashing, policy); return &policy->funcs; } static void gp_hash_reset(GroupingPolicy *obj) { GroupingPolicyHash *policy = (GroupingPolicyHash *) obj; MemoryContextReset(policy->agg_extra_mctx); policy->returning_results = false; policy->hashing.reset(&policy->hashing); policy->stat_input_valid_rows = 0; policy->stat_input_total_rows = 0; policy->stat_bulk_filtered_rows = 0; policy->stat_consecutive_keys = 0; } static void compute_single_aggregate(GroupingPolicyHash *policy, TupleTableSlot *vector_slot, int start_row, int end_row, const VectorAggDef *agg_def, void *agg_states) { const ArrowArray *arg_arrow = NULL; const uint64 *arg_validity_bitmap = NULL; Datum arg_datum = 0; bool arg_isnull = true; uint16 total_batch_rows = 0; const uint32 *offsets = policy->key_index_for_row; MemoryContext agg_extra_mctx = policy->agg_extra_mctx; const uint64 *vector_qual_result = vector_slot_get_qual_result(vector_slot, &total_batch_rows); /* * We have functions with one argument, and one function with no arguments * (count(*)). Collect the arguments. */ if (agg_def->input_offset >= 0) { const AttrNumber attnum = AttrOffsetGetAttrNumber(agg_def->input_offset); const CompressedColumnValues *values = vector_slot_get_compressed_column_values(vector_slot, attnum); Assert(values->decompression_type != DT_Invalid); Ensure(values->decompression_type != DT_Iterator, "expected arrow array but got iterator for attnum %d", attnum); if (values->arrow != NULL) { arg_arrow = values->arrow; arg_validity_bitmap = values->buffers[0]; } else { Assert(values->decompression_type == DT_Scalar); arg_datum = *values->output_value; arg_isnull = *values->output_isnull; } } /* * Compute the unified validity bitmap. */ const size_t num_words = (total_batch_rows + 63) / 64; const uint64 *filter = arrow_combine_validity(num_words, policy->tmp_filter, agg_def->filter_result, vector_qual_result, arg_validity_bitmap); /* * Now call the function. */ if (arg_arrow != NULL) { /* Arrow argument. */ agg_def->func.agg_many_vector(agg_states, offsets, filter, start_row, end_row, arg_arrow, agg_extra_mctx); } else { /* * Scalar argument, or count(*). The latter has an optimized * implementation. */ if (agg_def->func.agg_many_scalar != NULL) { agg_def->func.agg_many_scalar(agg_states, offsets, filter, start_row, end_row, arg_datum, arg_isnull, agg_extra_mctx); } else { for (int i = start_row; i < end_row; i++) { if (!arrow_row_is_valid(filter, i)) { continue; } void *state = (offsets[i] * agg_def->func.state_bytes + (char *) agg_states); agg_def->func.agg_scalar(state, arg_datum, arg_isnull, 1, agg_extra_mctx); } } } } static void add_one_range(GroupingPolicyHash *policy, TupleTableSlot *vector_slot, const int start_row, const int end_row) { const int num_fns = policy->num_agg_defs; Assert(start_row < end_row); /* * Remember which aggregation states have already existed, and which we * have to initialize. State index zero is invalid. */ const uint32 last_initialized_key_index = policy->hashing.last_used_key_index; Assert(last_initialized_key_index <= policy->num_allocated_per_key_agg_states); /* * Match rows to aggregation states using a hash table. */ Assert((size_t) end_row <= policy->num_key_index_for_row); policy->hashing.fill_offsets(policy, vector_slot, start_row, end_row); /* * Process the aggregate function states. We are processing single aggregate * function for the entire batch to improve the memory locality. */ const uint64 new_aggstate_rows = policy->num_allocated_per_key_agg_states * 2 + 1; for (int agg_index = 0; agg_index < num_fns; agg_index++) { const VectorAggDef *agg_def = &policy->agg_defs[agg_index]; /* * If we added new keys, initialize the aggregate function states for * them. */ if (policy->hashing.last_used_key_index > last_initialized_key_index) { /* * If the aggregate function states don't fit into the existing * storage, reallocate it. */ if (policy->hashing.last_used_key_index >= policy->num_allocated_per_key_agg_states) { policy->per_agg_per_key_states[agg_index] = repalloc(policy->per_agg_per_key_states[agg_index], new_aggstate_rows * agg_def->func.state_bytes); } void *first_uninitialized_state = agg_def->func.state_bytes * (last_initialized_key_index + 1) + (char *) policy->per_agg_per_key_states[agg_index]; agg_def->func.agg_init(first_uninitialized_state, policy->hashing.last_used_key_index - last_initialized_key_index); } /* * Add this batch to the states of this aggregate function. */ compute_single_aggregate(policy, vector_slot, start_row, end_row, agg_def, policy->per_agg_per_key_states[agg_index]); } /* * Record the newly allocated number of aggregate function states in case we * had to reallocate. */ if (policy->hashing.last_used_key_index >= policy->num_allocated_per_key_agg_states) { Assert(new_aggstate_rows > policy->num_allocated_per_key_agg_states); policy->num_allocated_per_key_agg_states = new_aggstate_rows; } } static void gp_hash_add_batch(GroupingPolicy *gp, TupleTableSlot *vector_slot) { GroupingPolicyHash *policy = (GroupingPolicyHash *) gp; uint16 n; const uint64 *restrict filter = vector_slot_get_qual_result(vector_slot, &n); Assert(!policy->returning_results); /* * Initialize the array for storing the aggregate state offsets corresponding * to a given batch row. We don't need the offsets for the previous batch * that are currently stored there, so we don't need to use repalloc. */ if ((size_t) n > policy->num_key_index_for_row) { if (policy->key_index_for_row != NULL) { pfree(policy->key_index_for_row); } policy->num_key_index_for_row = n; policy->key_index_for_row = palloc(sizeof(policy->key_index_for_row[0]) * policy->num_key_index_for_row); } memset(policy->key_index_for_row, 0, n * sizeof(policy->key_index_for_row[0])); /* * Allocate the temporary filter array for computing the combined results of * batch filter, aggregate filter and column validity. */ const size_t num_words = (n + 63) / 64; if (num_words > policy->num_tmp_filter_words) { policy->tmp_filter = palloc(sizeof(*policy->tmp_filter) * (num_words * 2 + 1)); policy->num_tmp_filter_words = (num_words * 2 + 1); } /* * Arrange the input compressed columns in the order of grouping columns. */ for (int i = 0; i < policy->num_grouping_columns; i++) { const GroupingColumn *def = &policy->grouping_columns[i]; policy->current_batch_grouping_column_values[i] = *vector_slot_get_compressed_column_values(vector_slot, AttrOffsetGetAttrNumber(def->input_offset)); } /* * Call the per-batch initialization function of the hashing strategy. */ policy->hashing.prepare_for_batch(policy, vector_slot); /* * Add the batch rows to aggregate function states. */ if (filter == NULL) { /* * We don't have a filter on this batch, so aggregate it entirely in one * go. */ add_one_range(policy, vector_slot, 0, n); } else { /* * If we have a filter, skip the rows for which the entire words of the * filter bitmap are zero. This improves performance for highly * selective filters. */ int statistics_range_row = 0; int start_word = 0; int end_word = 0; int past_the_end_word = (n - 1) / 64 + 1; for (;;) { /* * Skip the bitmap words which are zero. */ for (start_word = end_word; start_word < past_the_end_word && filter[start_word] == 0; start_word++) ; if (start_word >= past_the_end_word) { break; } /* * Collect the consecutive bitmap words which are nonzero. */ for (end_word = start_word + 1; end_word < past_the_end_word && filter[end_word] != 0; end_word++) ; /* * Now we have the [start, end] range of bitmap words that are * nonzero. * * Determine starting and ending rows, also skipping the starting * and trailing zero bits at the ends of the range. */ const int start_row = start_word * 64 + pg_rightmost_one_pos64(filter[start_word]); Assert(start_row <= n); /* * The bits for past-the-end rows must be set to zero, so this * calculation should yield no more than n. */ Assert(end_word > start_word); const int end_row = (end_word - 1) * 64 + pg_leftmost_one_pos64(filter[end_word - 1]) + 1; Assert(end_row <= n); statistics_range_row += end_row - start_row; add_one_range(policy, vector_slot, start_row, end_row); } policy->stat_bulk_filtered_rows += n - statistics_range_row; } policy->stat_input_total_rows += n; policy->stat_input_valid_rows += arrow_num_valid(filter, n); } static bool gp_hash_should_emit(GroupingPolicy *gp) { GroupingPolicyHash *policy = (GroupingPolicyHash *) gp; if (policy->hashing.last_used_key_index > UINT32_MAX - GLOBAL_MAX_ROWS_PER_COMPRESSION) { /* * The max valid key index is UINT32_MAX, so we have to spill if the next * batch can possibly lead to key index overflow. */ return true; } /* * Don't grow the hash table cardinality too much, otherwise we become bound * by memory reads. In general, when this first stage of grouping doesn't * significantly reduce the cardinality, it becomes pure overhead and the * work will be done by the final Postgres aggregation, so we should bail * out early here. */ return policy->hashing.get_size_bytes(&policy->hashing) > 512 * 1024; } static bool gp_hash_do_emit(GroupingPolicy *gp, TupleTableSlot *aggregated_slot) { GroupingPolicyHash *policy = (GroupingPolicyHash *) gp; if (!policy->returning_results) { policy->returning_results = true; policy->last_returned_key = 1; const float keys = policy->hashing.last_used_key_index; if (keys > 0) { DEBUG_LOG("spill after " UINT64_FORMAT " input, " UINT64_FORMAT " valid, " UINT64_FORMAT " bulk filtered, " UINT64_FORMAT " cons, %.0f keys, " "%f ratio, %ld curctx bytes, %ld aggstate bytes", policy->stat_input_total_rows, policy->stat_input_valid_rows, policy->stat_bulk_filtered_rows, policy->stat_consecutive_keys, keys, policy->stat_input_valid_rows / keys, MemoryContextMemAllocated(CurrentMemoryContext, false), MemoryContextMemAllocated(policy->agg_extra_mctx, false)); } } else { policy->last_returned_key++; } const uint32 current_key = policy->last_returned_key; const uint32 keys_end = policy->hashing.last_used_key_index + 1; if (current_key >= keys_end) { policy->returning_results = false; return false; } const int naggs = policy->num_agg_defs; for (int i = 0; i < naggs; i++) { const VectorAggDef *agg_def = &policy->agg_defs[i]; void *agg_states = policy->per_agg_per_key_states[i]; void *agg_state = current_key * agg_def->func.state_bytes + (char *) agg_states; agg_def->func.agg_emit(agg_state, &aggregated_slot->tts_values[agg_def->output_offset], &aggregated_slot->tts_isnull[agg_def->output_offset]); } policy->hashing.emit_key(policy, current_key, aggregated_slot); DEBUG_PRINT("%p: output key index %d\n", policy, current_key); return true; } static char * gp_hash_explain(GroupingPolicy *gp) { GroupingPolicyHash *policy = (GroupingPolicyHash *) gp; return psprintf("hashed with %s key", policy->hashing.explain_name); } static const GroupingPolicy grouping_policy_hash_functions = { .gp_reset = gp_hash_reset, .gp_add_batch = gp_hash_add_batch, .gp_should_emit = gp_hash_should_emit, .gp_do_emit = gp_hash_do_emit, .gp_explain = gp_hash_explain, }; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/grouping_policy_hash.h����������������������������������0000664�0000000�0000000�00000010777�15100345067�0025275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <nodes/pg_list.h> #include "grouping_policy.h" #include "nodes/columnar_scan/compressed_batch.h" #include "hashing/hashing_strategy.h" typedef struct GroupingPolicyHash GroupingPolicyHash; /* * Hash grouping policy. * * The grouping and aggregation is performed as follows: * * 0) The grouping policy keeps track of the unique grouping keys seen in * the input rows, and the states of aggregate functions for each key. This * spans multiple input compressed batches, and is reset after the partial * aggregation results are emitted. * * 1) For each row of the new compressed batch, we obtain an index that * uniquely identifies its grouping key. This is done by matching the row's * grouping columns to the hash table recording the unique grouping keys and * their respective indexes. It is performed in bulk for all rows of the batch, * to improve memory locality. The details of this are managed by the hashing * strategy. * * 2) The key indexes are used to locate the aggregate function states * corresponding to a given row's key, and update it. This is done in bulk for all * rows of the batch, and for each aggregate function separately, to generate * simpler and potentially vectorizable code, and improve memory locality. * * 3) After the input has ended, or if the memory limit is reached, the partial * results are emitted into the output slot. This is done in the order of unique * grouping key indexes, thereby preserving the incoming key order. This * guarantees that this policy works correctly even in a Partial GroupAggregate * node, even though it's not optimal performance-wise. We only support the * direct order of records in batch though, not reverse. This is checked at * planning time. */ typedef struct GroupingPolicyHash { /* * We're using data inheritance from the GroupingPolicy. */ GroupingPolicy funcs; /* * Aggregate function definitions. */ int num_agg_defs; const VectorAggDef *restrict agg_defs; /* * Grouping column definitions. */ int num_grouping_columns; const GroupingColumn *restrict grouping_columns; /* * The values of the grouping columns picked from the compressed batch and * arranged in the order of grouping column definitions. */ CompressedColumnValues *restrict current_batch_grouping_column_values; /* * Hashing strategy that is responsible for mapping the rows to the unique * indexes of their grouping keys. */ HashingStrategy hashing; /* * Temporary storage of unique indexes of keys corresponding to a given row * of the compressed batch that is currently being aggregated. We keep it in * the policy because it is potentially too big to keep on stack, and we * don't want to reallocate it for each batch. */ uint32 *restrict key_index_for_row; uint64 num_key_index_for_row; /* * The temporary filter bitmap we use to combine the results of the * vectorized filters in WHERE, validity of the aggregate function argument, * and the aggregate FILTER clause. It is then used by the aggregate * function implementation to filter out the rows that don't pass. */ uint64 *tmp_filter; uint64 num_tmp_filter_words; /* * Aggregate function states. Each element is an array of states for the * respective function from agg_defs. These arrays are indexed by the unique * grouping key indexes. The key index 0 is invalid, so the corresponding * states are unused. * The states of each aggregate function are stored separately and * contiguously, to achieve better memory locality when updating them. */ void **per_agg_per_key_states; uint64 num_allocated_per_key_agg_states; /* * A memory context for aggregate functions to allocate additional data, * i.e. if they store strings or float8 datum on 32-bit systems. Valid until * the grouping policy is reset. */ MemoryContext agg_extra_mctx; /* * Whether we are in the mode of returning the partial aggregation results. * If we are, track the index of the last returned grouping key. */ bool returning_results; uint32 last_returned_key; /* * Some statistics for debugging. */ uint64 stat_input_total_rows; uint64 stat_input_valid_rows; uint64 stat_bulk_filtered_rows; uint64 stat_consecutive_keys; } GroupingPolicyHash; //#define DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__) #ifndef DEBUG_PRINT #define DEBUG_PRINT(...) #endif �timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0022315�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/CMakeLists.txt����������������������������������0000664�0000000�0000000�00000000735�15100345067�0025062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/hash_strategy_single_fixed_2.c ${CMAKE_CURRENT_SOURCE_DIR}/hash_strategy_single_fixed_4.c ${CMAKE_CURRENT_SOURCE_DIR}/hash_strategy_single_fixed_8.c ${CMAKE_CURRENT_SOURCE_DIR}/hash_strategy_common.c) if(USE_UMASH) list(APPEND SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/hash_strategy_single_text.c ${CMAKE_CURRENT_SOURCE_DIR}/hash_strategy_serialized.c) endif() target_sources(${TSL_LIBRARY_NAME} PRIVATE ${SOURCES}) �����������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/batch_hashing_params.h��������������������������0000664�0000000�0000000�00000002642�15100345067�0026617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "nodes/vector_agg/grouping_policy_hash.h" #include "nodes/vector_agg/vector_slot.h" /* * The data required to map the rows of the given compressed batch to the unique * indexes of grouping keys, using a hash table. */ typedef struct BatchHashingParams { const uint64 *batch_filter; CompressedColumnValues single_grouping_column; int num_grouping_columns; const CompressedColumnValues *grouping_column_values; GroupingPolicyHash *policy; HashingStrategy *restrict hashing; uint32 *restrict result_key_indexes; } BatchHashingParams; static pg_attribute_always_inline BatchHashingParams build_batch_hashing_params(GroupingPolicyHash *policy, TupleTableSlot *vector_slot) { uint16 nrows; BatchHashingParams params = { .policy = policy, .hashing = &policy->hashing, .batch_filter = vector_slot_get_qual_result(vector_slot, &nrows), .num_grouping_columns = policy->num_grouping_columns, .grouping_column_values = policy->current_batch_grouping_column_values, .result_key_indexes = policy->key_index_for_row, }; Assert(policy->num_grouping_columns > 0); if (policy->num_grouping_columns == 1) { params.single_grouping_column = policy->current_batch_grouping_column_values[0]; } return params; } ����������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash64.h����������������������������������������0000664�0000000�0000000�00000001532�15100345067�0023564�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * We can use crc32 as a hash function, it has bad properties but takes only one * cycle, which is why it is sometimes used in the existing hash table * implementations. When we don't have the crc32 instruction, use the SplitMix64 * finalizer. */ static pg_attribute_always_inline uint64 hash64_splitmix(uint64 x) { x ^= x >> 30; x *= 0xbf58476d1ce4e5b9U; x ^= x >> 27; x *= 0x94d049bb133111ebU; x ^= x >> 31; return x; } #ifdef USE_SSE42_CRC32C #include <nmmintrin.h> static pg_attribute_always_inline uint64 hash64_crc(uint64 x) { return _mm_crc32_u64(~0ULL, x); } #define HASH64 hash64_crc #else #define HASH64 hash64_splitmix #endif ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_common.c��������������������������0000664�0000000�0000000�00000003224�15100345067�0026677�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "hashing_strategy.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/grouping_policy_hash.h" /* * Allocate enough storage for keys, given that each row of the new compressed * batch might turn out to be a new grouping key. We do this separately to avoid * allocations in the hot loop that fills the hash table. */ void hash_strategy_output_key_alloc(GroupingPolicyHash *policy, uint16 nrows) { HashingStrategy *hashing = &policy->hashing; const uint32 num_possible_keys = hashing->last_used_key_index + 1 + nrows; if (num_possible_keys > hashing->num_allocated_output_keys) { hashing->num_allocated_output_keys = num_possible_keys * 2 + 1; const size_t new_bytes = sizeof(Datum) * hashing->num_allocated_output_keys; if (hashing->output_keys == NULL) { hashing->output_keys = palloc(new_bytes); } else { hashing->output_keys = repalloc(hashing->output_keys, new_bytes); } } } /* * Emit a single-column grouping key with the given index into the aggregated * slot. */ void hash_strategy_output_key_single_emit(GroupingPolicyHash *policy, uint32 current_key, TupleTableSlot *aggregated_slot) { HashingStrategy *hashing = &policy->hashing; Assert(policy->num_grouping_columns == 1); const GroupingColumn *col = &policy->grouping_columns[0]; aggregated_slot->tts_values[col->output_offset] = hashing->output_keys[current_key]; aggregated_slot->tts_isnull[col->output_offset] = current_key == hashing->null_key_index; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_impl.c����������������������������0000664�0000000�0000000�00000013463�15100345067�0026356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include "batch_hashing_params.h" #include "nodes/vector_agg/vector_slot.h" /* * The hash table maps the value of the grouping key to its unique index. * We don't store any extra information here, because we're accessing the memory * of the hash table randomly, and want it to be as small as possible to fit the * caches. */ typedef struct FUNCTION_NAME(entry) { /* Key index 0 is invalid. */ uint32 key_index; uint8 status; HASH_TABLE_KEY_TYPE hash_table_key; } FUNCTION_NAME(entry); #define SH_PREFIX KEY_VARIANT #define SH_ELEMENT_TYPE FUNCTION_NAME(entry) #define SH_KEY_TYPE HASH_TABLE_KEY_TYPE #define SH_KEY hash_table_key #define SH_HASH_KEY(tb, key) KEY_HASH(key) #define SH_EQUAL(tb, a, b) KEY_EQUAL(a, b) #define SH_SCOPE static inline #define SH_DECLARE #define SH_DEFINE #include <lib/simplehash.h> struct FUNCTION_NAME(hash); static uint64 FUNCTION_NAME(get_size_bytes)(HashingStrategy *hashing) { struct FUNCTION_NAME(hash) *hash = (struct FUNCTION_NAME(hash) *) hashing->table; return hash->members * sizeof(FUNCTION_NAME(entry)); } static void FUNCTION_NAME(hash_strategy_init)(HashingStrategy *hashing, GroupingPolicyHash *policy) { hashing->table = FUNCTION_NAME(create)(CurrentMemoryContext, policy->num_allocated_per_key_agg_states, NULL); FUNCTION_NAME(key_hashing_init)(hashing); } static void FUNCTION_NAME(hash_strategy_reset)(HashingStrategy *hashing) { struct FUNCTION_NAME(hash) *table = (struct FUNCTION_NAME(hash) *) hashing->table; FUNCTION_NAME(reset)(table); hashing->last_used_key_index = 0; hashing->null_key_index = 0; /* * Have to reset this because it's in the key body context which is also * reset here. */ hashing->tmp_key_storage = NULL; hashing->num_tmp_key_storage_bytes = 0; } static void FUNCTION_NAME(hash_strategy_prepare_for_batch)(GroupingPolicyHash *policy, TupleTableSlot *vector_slot) { uint16 nrows = 0; vector_slot_get_qual_result(vector_slot, &nrows); hash_strategy_output_key_alloc(policy, nrows); FUNCTION_NAME(key_hashing_prepare_for_batch)(policy, vector_slot); } /* * Fill the unique key indexes for all rows of the batch, using a hash table. */ static pg_attribute_always_inline void FUNCTION_NAME(fill_offsets_impl)(BatchHashingParams params, int start_row, int end_row) { HashingStrategy *restrict hashing = params.hashing; uint32 *restrict indexes = params.result_key_indexes; struct FUNCTION_NAME(hash) *restrict table = hashing->table; HASH_TABLE_KEY_TYPE prev_hash_table_key = { 0 }; uint32 previous_key_index = 0; for (int row = start_row; row < end_row; row++) { if (!arrow_row_is_valid(params.batch_filter, row)) { /* The row doesn't pass the filter. */ DEBUG_PRINT("%p: row %d doesn't pass batch filter\n", hashing, row); continue; } /* * Get the key for the given row. For some hashing strategies, the key * that is used for the hash table is different from actual values of * the grouping columns, termed "output key" here. */ bool key_valid = false; OUTPUT_KEY_TYPE output_key = { 0 }; HASH_TABLE_KEY_TYPE hash_table_key = { 0 }; FUNCTION_NAME(key_hashing_get_key)(params, row, &output_key, &hash_table_key, &key_valid); if (unlikely(!key_valid)) { /* The key is null. */ if (hashing->null_key_index == 0) { hashing->null_key_index = ++hashing->last_used_key_index; } indexes[row] = hashing->null_key_index; DEBUG_PRINT("%p: row %d null key index %d\n", hashing, row, hashing->null_key_index); continue; } if (likely(previous_key_index != 0) && KEY_EQUAL(hash_table_key, prev_hash_table_key)) { /* * In real data sets, we often see consecutive rows with the * same value of a grouping column, so checking for this case * improves performance. For multi-column keys, this is unlikely, * but we currently often have suboptimal plans that use this policy * as a GroupAggregate, so we still use this as an easy optimization * for that case. */ indexes[row] = previous_key_index; #ifndef NDEBUG params.policy->stat_consecutive_keys++; #endif DEBUG_PRINT("%p: row %d consecutive key index %d\n", hashing, row, previous_key_index); continue; } /* * Find the key using the hash table. */ bool found = false; FUNCTION_NAME(entry) *restrict entry = FUNCTION_NAME(insert)(table, hash_table_key, &found); if (!found) { /* * New key, have to store it persistently. */ const uint32 index = ++hashing->last_used_key_index; entry->key_index = index; FUNCTION_NAME(key_hashing_store_new)(hashing, index, output_key); DEBUG_PRINT("%p: row %d new key index %d\n", hashing, row, index); } else { DEBUG_PRINT("%p: row %d old key index %d\n", hashing, row, entry->key_index); } indexes[row] = entry->key_index; previous_key_index = entry->key_index; prev_hash_table_key = entry->hash_table_key; } } static void FUNCTION_NAME(fill_offsets)(GroupingPolicyHash *policy, TupleTableSlot *vector_slot, int start_row, int end_row) { Assert((size_t) end_row <= policy->num_key_index_for_row); BatchHashingParams params = build_batch_hashing_params(policy, vector_slot); FUNCTION_NAME(fill_offsets_impl)(params, start_row, end_row); } HashingStrategy FUNCTION_NAME(strategy) = { .emit_key = FUNCTION_NAME(emit_key), .explain_name = EXPLAIN_NAME, .fill_offsets = FUNCTION_NAME(fill_offsets), .get_size_bytes = FUNCTION_NAME(get_size_bytes), .init = FUNCTION_NAME(hash_strategy_init), .prepare_for_batch = FUNCTION_NAME(hash_strategy_prepare_for_batch), .reset = FUNCTION_NAME(hash_strategy_reset), }; #undef EXPLAIN_NAME #undef KEY_VARIANT #undef KEY_EQUAL #undef OUTPUT_KEY_TYPE #undef HASH_TABLE_KEY_TYPE #undef USE_DICT_HASHING �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_impl_single_fixed_key.c�����������0000664�0000000�0000000�00000004032�15100345067�0031736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Key handling function for a single fixed-size grouping key. */ #include "batch_hashing_params.h" static void FUNCTION_NAME(key_hashing_init)(HashingStrategy *hashing) { } static void FUNCTION_NAME(key_hashing_prepare_for_batch)(GroupingPolicyHash *policy, TupleTableSlot *vector_slot) { } static pg_attribute_always_inline void FUNCTION_NAME(key_hashing_get_key)(BatchHashingParams params, int row, void *restrict output_key_ptr, void *restrict hash_table_key_ptr, bool *restrict valid) { OUTPUT_KEY_TYPE *restrict output_key = (OUTPUT_KEY_TYPE *) output_key_ptr; HASH_TABLE_KEY_TYPE *restrict hash_table_key = (HASH_TABLE_KEY_TYPE *) hash_table_key_ptr; if (unlikely(params.single_grouping_column.decompression_type == DT_Scalar)) { *output_key = DATUM_TO_OUTPUT_KEY(*params.single_grouping_column.output_value); *valid = !*params.single_grouping_column.output_isnull; } else if (params.single_grouping_column.decompression_type == sizeof(OUTPUT_KEY_TYPE)) { const OUTPUT_KEY_TYPE *values = params.single_grouping_column.buffers[1]; *valid = arrow_row_is_valid(params.single_grouping_column.buffers[0], row); *output_key = values[row]; } else { pg_unreachable(); } /* * For the fixed-size hash grouping, we use the output key as the hash table * key as well. */ *hash_table_key = *output_key; } static pg_attribute_always_inline void FUNCTION_NAME(key_hashing_store_new)(HashingStrategy *restrict hashing, uint32 new_key_index, OUTPUT_KEY_TYPE output_key) { hashing->output_keys[new_key_index] = OUTPUT_KEY_TO_DATUM(output_key); } static void FUNCTION_NAME(emit_key)(GroupingPolicyHash *policy, uint32 current_key, TupleTableSlot *aggregated_slot) { hash_strategy_output_key_single_emit(policy, current_key, aggregated_slot); } #undef DATUM_TO_OUTPUT_KEY #undef OUTPUT_KEY_TO_DATUM ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_serialized.c����������������������0000664�0000000�0000000�00000033630�15100345067�0027546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Implementation of column hashing for multiple serialized columns. */ #include <postgres.h> #include <common/hashfn.h> #include "compression/arrow_c_data_interface.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/grouping_policy_hash.h" #include "template_helper.h" #include "batch_hashing_params.h" #include "umash_fingerprint_key.h" #define EXPLAIN_NAME "serialized" #define KEY_VARIANT serialized #define OUTPUT_KEY_TYPE text * static void serialized_key_hashing_init(HashingStrategy *hashing) { hashing->umash_params = umash_key_hashing_init(); } static void serialized_key_hashing_prepare_for_batch(GroupingPolicyHash *policy, TupleTableSlot *vector_slot) { } static pg_attribute_always_inline bool byte_bitmap_row_is_valid(const uint8 *bitmap, size_t row_number) { const size_t byte_index = row_number / 8; const size_t bit_index = row_number % 8; const uint8 mask = ((uint8) 1) << bit_index; return bitmap[byte_index] & mask; } static pg_attribute_always_inline void byte_bitmap_set_row_validity(uint8 *bitmap, size_t row_number, bool value) { const size_t byte_index = row_number / 8; const size_t bit_index = row_number % 8; const uint8 mask = ((uint8) 1) << bit_index; const uint8 new_bit = ((uint8) value) << bit_index; bitmap[byte_index] = (bitmap[byte_index] & ~mask) | new_bit; Assert(byte_bitmap_row_is_valid(bitmap, row_number) == value); } static pg_attribute_always_inline void serialized_key_hashing_get_key(BatchHashingParams params, int row, void *restrict output_key_ptr, void *restrict hash_table_key_ptr, bool *restrict valid) { HashingStrategy *hashing = params.hashing; text **restrict output_key = (text **) output_key_ptr; HASH_TABLE_KEY_TYPE *restrict hash_table_key = (HASH_TABLE_KEY_TYPE *) hash_table_key_ptr; const int num_columns = params.num_grouping_columns; const size_t bitmap_bytes = (num_columns + 7) / 8; /* * Loop through the grouping columns to determine the length of the key. We * need that to allocate memory to store it. * * The key has the null bitmap at the beginning. */ size_t num_bytes = bitmap_bytes; for (int column_index = 0; column_index < num_columns; column_index++) { const CompressedColumnValues *column_values = ¶ms.grouping_column_values[column_index]; if (column_values->decompression_type == DT_Scalar) { if (!*column_values->output_isnull) { const GroupingColumn *def = ¶ms.policy->grouping_columns[column_index]; if (def->value_bytes > 0) { num_bytes += def->value_bytes; } else { /* * The default value always has a long varlena header, but * we are going to use short if it fits. */ const int32 value_bytes = VARSIZE_ANY_EXHDR(*column_values->output_value); if (value_bytes + VARHDRSZ_SHORT <= VARATT_SHORT_MAX) { /* Short varlena, unaligned. */ const int total_bytes = value_bytes + VARHDRSZ_SHORT; num_bytes += total_bytes; } else { /* Long varlena, requires alignment. */ const int total_bytes = value_bytes + VARHDRSZ; num_bytes = TYPEALIGN(4, num_bytes) + total_bytes; } } } continue; } const bool is_valid = arrow_row_is_valid(column_values->buffers[0], row); if (!is_valid) { continue; } if (column_values->decompression_type > 0) { num_bytes += column_values->decompression_type; continue; } if (column_values->decompression_type == DT_ArrowBits) { num_bytes += 1; continue; } Assert(column_values->decompression_type == DT_ArrowText || column_values->decompression_type == DT_ArrowTextDict); Assert((column_values->decompression_type == DT_ArrowTextDict) == (column_values->buffers[3] != NULL)); const uint32 data_row = (column_values->decompression_type == DT_ArrowTextDict) ? ((int16 *) column_values->buffers[3])[row] : row; const uint32 start = ((uint32 *) column_values->buffers[1])[data_row]; const int32 value_bytes = ((uint32 *) column_values->buffers[1])[data_row + 1] - start; if (value_bytes + VARHDRSZ_SHORT <= VARATT_SHORT_MAX) { /* Short varlena, unaligned. */ const int total_bytes = value_bytes + VARHDRSZ_SHORT; num_bytes += total_bytes; } else { /* Long varlena, requires alignment. */ const int total_bytes = value_bytes + VARHDRSZ; num_bytes = TYPEALIGN(4, num_bytes) + total_bytes; } } /* * The key has short or long varlena header. This is a little tricky, we * decide the header length after we have counted all the columns, but we * put it at the beginning. Technically it could change the length because * of the alignment. In practice, we only use alignment by 4 bytes for long * varlena strings, and if we have at least one long varlena string column, * the key is also going to use the long varlena header which is 4 bytes, so * the alignment is not affected. If we use the short varlena header for the * key, it necessarily means that there were no long varlena columns and * therefore no alignment is needed. */ const bool key_uses_short_header = num_bytes + VARHDRSZ_SHORT <= VARATT_SHORT_MAX; num_bytes += key_uses_short_header ? VARHDRSZ_SHORT : VARHDRSZ; /* * Use temporary storage for the new key, reallocate if it's too small. */ if (num_bytes > hashing->num_tmp_key_storage_bytes) { if (hashing->tmp_key_storage != NULL) { pfree(hashing->tmp_key_storage); } hashing->tmp_key_storage = MemoryContextAlloc(hashing->key_body_mctx, num_bytes); hashing->num_tmp_key_storage_bytes = num_bytes; } uint8 *restrict serialized_key_storage = hashing->tmp_key_storage; /* * Build the actual grouping key. */ uint32 offset = 0; offset += key_uses_short_header ? VARHDRSZ_SHORT : VARHDRSZ; /* * We must always save the validity bitmap, even when there are no * null words, so that the key is uniquely deserializable. Otherwise a key * with some nulls might collide with a key with no nulls. */ uint8 *restrict serialized_key_validity_bitmap = &serialized_key_storage[offset]; offset += bitmap_bytes; /* * Loop through the grouping columns again and add their values to the * grouping key. */ for (int column_index = 0; column_index < num_columns; column_index++) { const CompressedColumnValues *column_values = ¶ms.grouping_column_values[column_index]; if (column_values->decompression_type == DT_Scalar) { const bool is_valid = !*column_values->output_isnull; byte_bitmap_set_row_validity(serialized_key_validity_bitmap, column_index, is_valid); if (is_valid) { const GroupingColumn *def = ¶ms.policy->grouping_columns[column_index]; if (def->by_value) { memcpy(&serialized_key_storage[offset], column_values->output_value, def->value_bytes); offset += def->value_bytes; } else if (def->value_bytes > 0) { memcpy(&serialized_key_storage[offset], DatumGetPointer(*column_values->output_value), def->value_bytes); offset += def->value_bytes; } else { /* * The default value always has a long varlena header, but * we are going to use short if it fits. */ const int32 value_bytes = VARSIZE_ANY_EXHDR(*column_values->output_value); if (value_bytes + VARHDRSZ_SHORT <= VARATT_SHORT_MAX) { /* Short varlena, no alignment. */ const int32 total_bytes = value_bytes + VARHDRSZ_SHORT; SET_VARSIZE_SHORT(&serialized_key_storage[offset], total_bytes); offset += VARHDRSZ_SHORT; } else { /* Long varlena, requires alignment. Zero out the alignment bytes. */ memset(&serialized_key_storage[offset], 0, 4); offset = TYPEALIGN(4, offset); const int32 total_bytes = value_bytes + VARHDRSZ; SET_VARSIZE(&serialized_key_storage[offset], total_bytes); offset += VARHDRSZ; } memcpy(&serialized_key_storage[offset], VARDATA_ANY(*column_values->output_value), value_bytes); offset += value_bytes; } } continue; } const bool is_valid = arrow_row_is_valid(column_values->buffers[0], row); byte_bitmap_set_row_validity(serialized_key_validity_bitmap, column_index, is_valid); if (!is_valid) { continue; } if (column_values->decompression_type > 0) { Assert(offset <= UINT_MAX - column_values->decompression_type); switch ((int) column_values->decompression_type) { case 2: memcpy(&serialized_key_storage[offset], row + (int16 *) column_values->buffers[1], 2); break; case 4: memcpy(&serialized_key_storage[offset], row + (int32 *) column_values->buffers[1], 4); break; case 8: memcpy(&serialized_key_storage[offset], row + (int64 *) column_values->buffers[1], 8); break; case 16: memcpy(&serialized_key_storage[offset], (row * 2) + (int64 *) column_values->buffers[1], 16); break; default: pg_unreachable(); break; } offset += column_values->decompression_type; continue; } if (column_values->decompression_type == DT_ArrowBits) { serialized_key_storage[offset] = arrow_row_is_valid(column_values->buffers[1], row); offset += 1; continue; } Assert(column_values->decompression_type == DT_ArrowText || column_values->decompression_type == DT_ArrowTextDict); const uint32 data_row = column_values->decompression_type == DT_ArrowTextDict ? ((int16 *) column_values->buffers[3])[row] : row; const uint32 start = ((uint32 *) column_values->buffers[1])[data_row]; const int32 value_bytes = ((uint32 *) column_values->buffers[1])[data_row + 1] - start; if (value_bytes + VARHDRSZ_SHORT <= VARATT_SHORT_MAX) { /* Short varlena, unaligned. */ const int32 total_bytes = value_bytes + VARHDRSZ_SHORT; SET_VARSIZE_SHORT(&serialized_key_storage[offset], total_bytes); offset += VARHDRSZ_SHORT; } else { /* Long varlena, requires alignment. Zero out the alignment bytes. */ memset(&serialized_key_storage[offset], 0, 4); offset = TYPEALIGN(4, offset); const int32 total_bytes = value_bytes + VARHDRSZ; SET_VARSIZE(&serialized_key_storage[offset], total_bytes); offset += VARHDRSZ; } memcpy(&serialized_key_storage[offset], &((uint8 *) column_values->buffers[2])[start], value_bytes); offset += value_bytes; } Assert(offset == num_bytes); if (key_uses_short_header) { SET_VARSIZE_SHORT(serialized_key_storage, offset); } else { SET_VARSIZE(serialized_key_storage, offset); } DEBUG_PRINT("key is %d bytes: ", offset); for (size_t i = 0; i < offset; i++) { DEBUG_PRINT("%.2x.", serialized_key_storage[i]); } DEBUG_PRINT("\n"); *output_key = (text *) serialized_key_storage; Assert(VARSIZE_ANY(*output_key) == num_bytes); /* * The multi-column key is always considered non-null, and the null flags * for the individual columns are stored in a bitmap that is part of the * key. */ *valid = true; const struct umash_fp fp = umash_fprint(params.hashing->umash_params, /* seed = */ ~0ULL, serialized_key_storage, num_bytes); *hash_table_key = umash_fingerprint_get_key(fp); } static pg_attribute_always_inline void serialized_key_hashing_store_new(HashingStrategy *restrict hashing, uint32 new_key_index, text *output_key) { /* * We will store this key so we have to consume the temporary storage that * was used for it. The subsequent keys will need to allocate new memory. */ Assert(hashing->tmp_key_storage == (void *) output_key); hashing->tmp_key_storage = NULL; hashing->num_tmp_key_storage_bytes = 0; hashing->output_keys[new_key_index] = PointerGetDatum(output_key); } static void serialized_emit_key(GroupingPolicyHash *policy, uint32 current_key, TupleTableSlot *aggregated_slot) { const HashingStrategy *hashing = &policy->hashing; const int num_key_columns = policy->num_grouping_columns; const Datum serialized_key_datum = hashing->output_keys[current_key]; const uint8 *serialized_key = (const uint8 *) VARDATA_ANY(serialized_key_datum); PG_USED_FOR_ASSERTS_ONLY const int key_data_bytes = VARSIZE_ANY_EXHDR(serialized_key_datum); const uint8 *restrict ptr = serialized_key; /* * We have the column validity bitmap at the beginning of the key. */ const int bitmap_bytes = (num_key_columns + 7) / 8; Assert(bitmap_bytes <= key_data_bytes); const uint8 *restrict key_validity_bitmap = serialized_key; ptr += bitmap_bytes; DEBUG_PRINT("emit key #%d, with header %ld without %d bytes: ", current_key, VARSIZE_ANY(serialized_key_datum), key_data_bytes); for (size_t i = 0; i < VARSIZE_ANY(serialized_key_datum); i++) { DEBUG_PRINT("%.2x.", ((const uint8 *) serialized_key_datum)[i]); } DEBUG_PRINT("\n"); for (int column_index = 0; column_index < num_key_columns; column_index++) { const GroupingColumn *col = &policy->grouping_columns[column_index]; const bool isnull = !byte_bitmap_row_is_valid(key_validity_bitmap, column_index); aggregated_slot->tts_isnull[col->output_offset] = isnull; if (isnull) { continue; } Datum *output = &aggregated_slot->tts_values[col->output_offset]; if (col->value_bytes > 0) { if (col->by_value) { Assert(col->by_value); Assert((size_t) col->value_bytes <= sizeof(Datum)); *output = 0; memcpy(output, ptr, col->value_bytes); } else { *output = PointerGetDatum(ptr); } ptr += col->value_bytes; } else { Assert(col->value_bytes == -1); Assert(!col->by_value); if (VARATT_IS_SHORT(ptr)) { *output = PointerGetDatum(ptr); ptr += VARSIZE_SHORT(ptr); } else { ptr = (const uint8 *) TYPEALIGN(4, ptr); *output = PointerGetDatum(ptr); ptr += VARSIZE(ptr); } } } Assert(ptr == serialized_key + key_data_bytes); } #include "hash_strategy_impl.c" ��������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_single_fixed_2.c������������������0000664�0000000�0000000�00000001613�15100345067�0030270�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Implementation of column hashing for a single fixed size 2-byte column. */ #include <postgres.h> #include "compression/arrow_c_data_interface.h" #include "hash64.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/grouping_policy_hash.h" #include "template_helper.h" #define EXPLAIN_NAME "single 2-byte" #define KEY_VARIANT single_fixed_2 #define OUTPUT_KEY_TYPE int16 #define HASH_TABLE_KEY_TYPE OUTPUT_KEY_TYPE #define DATUM_TO_OUTPUT_KEY DatumGetInt16 #define OUTPUT_KEY_TO_DATUM Int16GetDatum #include "hash_strategy_impl_single_fixed_key.c" #define KEY_EQUAL(a, b) a == b #define KEY_HASH(X) HASH64(X) #include "hash_strategy_impl.c" ���������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_single_fixed_4.c������������������0000664�0000000�0000000�00000001601�15100345067�0030267�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Implementation of column hashing for a single fixed size 4-byte column. */ #include <postgres.h> #include "compression/arrow_c_data_interface.h" #include "hash64.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/grouping_policy_hash.h" #include "template_helper.h" #define EXPLAIN_NAME "single 4-byte" #define KEY_VARIANT single_fixed_4 #define OUTPUT_KEY_TYPE int32 #define HASH_TABLE_KEY_TYPE int32 #define DATUM_TO_OUTPUT_KEY DatumGetInt32 #define OUTPUT_KEY_TO_DATUM Int32GetDatum #include "hash_strategy_impl_single_fixed_key.c" #define KEY_EQUAL(a, b) a == b #define KEY_HASH(X) HASH64(X) #include "hash_strategy_impl.c" �������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_single_fixed_8.c������������������0000664�0000000�0000000�00000001601�15100345067�0030273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Implementation of column hashing for a single fixed size 8-byte column. */ #include <postgres.h> #include "compression/arrow_c_data_interface.h" #include "hash64.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/grouping_policy_hash.h" #include "template_helper.h" #define EXPLAIN_NAME "single 8-byte" #define KEY_VARIANT single_fixed_8 #define OUTPUT_KEY_TYPE int64 #define HASH_TABLE_KEY_TYPE int64 #define DATUM_TO_OUTPUT_KEY DatumGetInt64 #define OUTPUT_KEY_TO_DATUM Int64GetDatum #include "hash_strategy_impl_single_fixed_key.c" #define KEY_EQUAL(a, b) a == b #define KEY_HASH(X) HASH64(X) #include "hash_strategy_impl.c" �������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hash_strategy_single_text.c���������������������0000664�0000000�0000000�00000007751�15100345067�0027745�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * Implementation of column hashing for a single text column. */ #include <postgres.h> #include <common/hashfn.h> #include "compression/arrow_c_data_interface.h" #include "nodes/columnar_scan/compressed_batch.h" #include "nodes/vector_agg/exec.h" #include "nodes/vector_agg/grouping_policy_hash.h" #include "template_helper.h" #include "batch_hashing_params.h" #include "umash_fingerprint_key.h" #define EXPLAIN_NAME "single text" #define KEY_VARIANT single_text #define OUTPUT_KEY_TYPE BytesView static void single_text_key_hashing_init(HashingStrategy *hashing) { hashing->umash_params = umash_key_hashing_init(); } typedef struct BytesView { const uint8 *data; uint32 len; } BytesView; static BytesView get_bytes_view(CompressedColumnValues *column_values, int arrow_row) { const uint32 start = ((uint32 *) column_values->buffers[1])[arrow_row]; const int32 value_bytes = ((uint32 *) column_values->buffers[1])[arrow_row + 1] - start; Assert(value_bytes >= 0); return (BytesView){ .len = value_bytes, .data = &((uint8 *) column_values->buffers[2])[start] }; } static pg_attribute_always_inline void single_text_key_hashing_get_key(BatchHashingParams params, int row, void *restrict output_key_ptr, void *restrict hash_table_key_ptr, bool *restrict valid) { Assert(params.policy->num_grouping_columns == 1); BytesView *restrict output_key = (BytesView *) output_key_ptr; HASH_TABLE_KEY_TYPE *restrict hash_table_key = (HASH_TABLE_KEY_TYPE *) hash_table_key_ptr; if (unlikely(params.single_grouping_column.decompression_type == DT_Scalar)) { *valid = !*params.single_grouping_column.output_isnull; if (*valid) { output_key->len = VARSIZE_ANY_EXHDR(*params.single_grouping_column.output_value); output_key->data = (const uint8 *) VARDATA_ANY(*params.single_grouping_column.output_value); } else { output_key->len = 0; output_key->data = NULL; } } else if (params.single_grouping_column.decompression_type == DT_ArrowText) { *output_key = get_bytes_view(¶ms.single_grouping_column, row); *valid = arrow_row_is_valid(params.single_grouping_column.buffers[0], row); } else if (params.single_grouping_column.decompression_type == DT_ArrowTextDict) { const int16 index = ((int16 *) params.single_grouping_column.buffers[3])[row]; *output_key = get_bytes_view(¶ms.single_grouping_column, index); *valid = arrow_row_is_valid(params.single_grouping_column.buffers[0], row); } else { pg_unreachable(); } DEBUG_PRINT("%p consider key row %d key index %d is %d bytes: ", params.hashing, row, params.hashing->last_used_key_index + 1, output_key->len); for (size_t i = 0; i < output_key->len; i++) { DEBUG_PRINT("%.2x.", output_key->data[i]); } DEBUG_PRINT("\n"); const struct umash_fp fp = umash_fprint(params.policy->hashing.umash_params, /* seed = */ ~0ULL, output_key->data, output_key->len); *hash_table_key = umash_fingerprint_get_key(fp); } static pg_attribute_always_inline void single_text_key_hashing_store_new(HashingStrategy *restrict hashing, uint32 new_key_index, BytesView output_key) { const int total_bytes = output_key.len + VARHDRSZ; text *restrict stored = (text *) MemoryContextAlloc(hashing->key_body_mctx, total_bytes); SET_VARSIZE(stored, total_bytes); memcpy(VARDATA(stored), output_key.data, output_key.len); hashing->output_keys[new_key_index] = PointerGetDatum(stored); } /* * We use the standard single-key key output functions. */ static void single_text_emit_key(GroupingPolicyHash *policy, uint32 current_key, TupleTableSlot *aggregated_slot) { return hash_strategy_output_key_single_emit(policy, current_key, aggregated_slot); } static void single_text_key_hashing_prepare_for_batch(GroupingPolicyHash *policy, TupleTableSlot *vector_slot) { } #include "hash_strategy_impl.c" �����������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/hashing_strategy.h������������������������������0000664�0000000�0000000�00000005235�15100345067�0026036�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> typedef struct GroupingPolicyHash GroupingPolicyHash; typedef struct HashingStrategy HashingStrategy; typedef struct DecompressBatchState DecompressBatchState; typedef struct TupleTableSlot TupleTableSlot; /* * The hashing strategy manages the details of how the grouping keys are stored * in a hash table. */ typedef struct HashingStrategy { char *explain_name; void (*init)(HashingStrategy *hashing, GroupingPolicyHash *policy); void (*reset)(HashingStrategy *hashing); uint64 (*get_size_bytes)(HashingStrategy *hashing); void (*prepare_for_batch)(GroupingPolicyHash *policy, TupleTableSlot *vector_slot); void (*fill_offsets)(GroupingPolicyHash *policy, TupleTableSlot *vector_slot, int start_row, int end_row); void (*emit_key)(GroupingPolicyHash *policy, uint32 current_key, TupleTableSlot *aggregated_slot); /* * The hash table we use for grouping. It matches each grouping key to its * unique integer index. */ void *table; /* * For each unique grouping key, we store the values of the grouping columns. * This is stored separately from hash table keys, because they might not * have the full column values, and also storing them contiguously here * leads to better memory access patterns when emitting the results. * The details of the key storage are managed by the hashing strategy. The * by-reference keys can use a separate memory context for dense storage. */ Datum *restrict output_keys; uint64 num_allocated_output_keys; MemoryContext key_body_mctx; /* * The last used index of an unique grouping key. Key index 0 is invalid. */ uint32 last_used_key_index; /* * In single-column grouping, we store the null key outside of the hash * table, and its index is given by this value. Key index 0 is invalid. * This is done to avoid having an "is null" flag in the hash table entries, * to reduce the hash table size. */ uint32 null_key_index; #ifdef TS_USE_UMASH /* * UMASH fingerprinting parameters. */ struct umash_params *umash_params; #endif /* * Temporary key storages. Some hashing strategies need to put the key in a * separate memory area, we don't want to alloc/free it on each row. */ uint8 *tmp_key_storage; uint64 num_tmp_key_storage_bytes; } HashingStrategy; void hash_strategy_output_key_alloc(GroupingPolicyHash *policy, uint16 nrows); void hash_strategy_output_key_single_emit(GroupingPolicyHash *policy, uint32 current_key, TupleTableSlot *aggregated_slot); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/template_helper.h�������������������������������0000664�0000000�0000000�00000000566�15100345067�0025647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #define FUNCTION_NAME_HELPER2(X, Y) X##_##Y #define FUNCTION_NAME_HELPER(X, Y) FUNCTION_NAME_HELPER2(X, Y) #define FUNCTION_NAME(Y) FUNCTION_NAME_HELPER(KEY_VARIANT, Y) ������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/hashing/umash_fingerprint_key.h�������������������������0000664�0000000�0000000�00000002163�15100345067�0027064�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once /* * Helpers to use the umash fingerprint as a hash table key in our hashing * strategies for vectorized grouping. */ #include "import/umash.h" /* * The struct is packed so that the hash table entry fits into 16 * bytes with the uint32 key index that goes before. */ struct umash_fingerprint_key { uint32 hash; uint64 rest; } pg_attribute_packed(); #define HASH_TABLE_KEY_TYPE struct umash_fingerprint_key #define KEY_HASH(X) (X.hash) #define KEY_EQUAL(a, b) (a.hash == b.hash && a.rest == b.rest) static inline struct umash_fingerprint_key umash_fingerprint_get_key(struct umash_fp fp) { const struct umash_fingerprint_key key = { .hash = fp.hash[0] & (~(uint32) 0), .rest = fp.hash[1], }; return key; } static inline struct umash_params * umash_key_hashing_init() { struct umash_params *params = palloc0(sizeof(struct umash_params)); umash_params_derive(params, 0xabcdef1234567890ull, NULL); return params; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/plan.c��������������������������������������������������0000664�0000000�0000000�00000040305�15100345067�0021774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/attnum.h> #include <commands/explain.h> #include <executor/executor.h> #include <nodes/extensible.h> #include <nodes/makefuncs.h> #include <nodes/nodeFuncs.h> #include <nodes/plannodes.h> #include <parser/parsetree.h> #include <utils/fmgroids.h> #include "plan.h" #include "exec.h" #include "import/list.h" #include "nodes/columnar_scan/vector_quals.h" #include "nodes/vector_agg.h" #include "utils.h" static struct CustomScanMethods scan_methods = { .CustomName = VECTOR_AGG_NODE_NAME, .CreateCustomScanState = vector_agg_state_create }; void _vector_agg_init(void) { TryRegisterCustomScanMethods(&scan_methods); } /* * Build an output targetlist for a custom node that just references all the * custom scan targetlist entries. */ static inline List * build_trivial_custom_output_targetlist(List *scan_targetlist) { List *result = NIL; ListCell *lc; foreach (lc, scan_targetlist) { TargetEntry *scan_entry = (TargetEntry *) lfirst(lc); Var *var = makeVar(INDEX_VAR, scan_entry->resno, exprType((Node *) scan_entry->expr), exprTypmod((Node *) scan_entry->expr), exprCollation((Node *) scan_entry->expr), /* varlevelsup = */ 0); TargetEntry *output_entry = makeTargetEntry((Expr *) var, scan_entry->resno, scan_entry->resname, scan_entry->resjunk); result = lappend(result, output_entry); } return result; } static Node * resolve_outer_special_vars_mutator(Node *node, void *context) { if (node == NULL) { return NULL; } if (!IsA(node, Var)) { return expression_tree_mutator(node, resolve_outer_special_vars_mutator, context); } Var *var = castNode(Var, node); CustomScan *custom = castNode(CustomScan, context); if ((Index) var->varno == (Index) custom->scan.scanrelid) { /* * This is already the uncompressed chunk var. We can see it referenced * by expressions in the output targetlist of the child scan node. */ return (Node *) copyObject(var); } if (var->varno == OUTER_VAR) { /* * Reference into the output targetlist of the child scan node. */ TargetEntry *columnar_scan_tentry = castNode(TargetEntry, list_nth(custom->scan.plan.targetlist, var->varattno - 1)); return resolve_outer_special_vars_mutator((Node *) columnar_scan_tentry->expr, context); } if (var->varno == INDEX_VAR) { /* * This is a reference into the custom scan targetlist, we have to resolve * it as well. */ var = castNode(Var, castNode(TargetEntry, list_nth(custom->custom_scan_tlist, var->varattno - 1)) ->expr); Assert(var->varno > 0); return (Node *) copyObject(var); } Ensure(false, "encountered unexpected varno %d as an aggregate argument", var->varno); return node; } /* * Resolve the OUTER_VAR special variables, that are used in the output * targetlists of aggregation nodes, replacing them with the uncompressed chunk * variables. */ static List * resolve_outer_special_vars(List *agg_tlist, Plan *childplan) { return castNode(List, resolve_outer_special_vars_mutator((Node *) agg_tlist, childplan)); } /* * Create a vectorized aggregation node to replace the given partial aggregation * node. */ static Plan * vector_agg_plan_create(Plan *childplan, Agg *agg, List *resolved_targetlist, VectorAggGroupingType grouping_type) { CustomScan *vector_agg = (CustomScan *) makeNode(CustomScan); vector_agg->custom_plans = list_make1(childplan); vector_agg->methods = &scan_methods; vector_agg->custom_scan_tlist = resolved_targetlist; /* * Note that this is being called from the post-planning hook, and therefore * after set_plan_refs(). The meaning of output targetlists is different from * the previous planning stages, and they contain special varnos referencing * the scan targetlists. */ vector_agg->scan.plan.targetlist = build_trivial_custom_output_targetlist(vector_agg->custom_scan_tlist); /* * Copy the costs from the normal aggregation node, so that they show up in * the EXPLAIN output. They are not used for any other purposes, because * this hook is called after the planning is finished. */ vector_agg->scan.plan.plan_rows = agg->plan.plan_rows; vector_agg->scan.plan.plan_width = agg->plan.plan_width; vector_agg->scan.plan.startup_cost = agg->plan.startup_cost; vector_agg->scan.plan.total_cost = agg->plan.total_cost; vector_agg->scan.plan.parallel_aware = false; vector_agg->scan.plan.parallel_safe = childplan->parallel_safe; vector_agg->scan.plan.async_capable = false; vector_agg->scan.plan.plan_node_id = agg->plan.plan_node_id; Assert(agg->plan.qual == NIL); vector_agg->scan.plan.initPlan = agg->plan.initPlan; vector_agg->scan.plan.extParam = bms_copy(agg->plan.extParam); vector_agg->scan.plan.allParam = bms_copy(agg->plan.allParam); vector_agg->custom_private = ts_new_list(T_List, VASI_Count); lfirst(list_nth_cell(vector_agg->custom_private, VASI_GroupingType)) = makeInteger(grouping_type); return (Plan *) vector_agg; } /* * Whether the expression can be used for vectorized processing: must be a Var * that refers to either a bulk-decompressed or a segmentby column. */ static bool is_vector_var(const VectorQualInfo *vqinfo, Expr *expr) { if (!IsA(expr, Var)) { /* Can aggregate only a bare decompressed column, not an expression. */ return false; } Var *var = castNode(Var, expr); if (var->varattno <= 0) { /* Can't work with special attributes like tableoid. */ return false; } Assert(var->varattno <= vqinfo->maxattno); return vqinfo->vector_attrs && vqinfo->vector_attrs[var->varattno]; } /* * Whether we can vectorize this particular aggregate. */ static bool can_vectorize_aggref(const VectorQualInfo *vqi, Aggref *aggref) { if (aggref->aggdirectargs != NIL) { /* Can't process ordered-set aggregates with direct arguments. */ return false; } if (aggref->aggorder != NIL) { /* Can't process aggregates with an ORDER BY clause. */ return false; } if (aggref->aggdistinct != NIL) { /* Can't process aggregates with DISTINCT clause. */ return false; } if (aggref->aggfilter != NULL) { /* Can process aggregates with filter clause if it's vectorizable. */ Node *aggfilter_vectorized = vector_qual_make((Node *) aggref->aggfilter, vqi); if (aggfilter_vectorized == NULL) { return false; } aggref->aggfilter = (Expr *) aggfilter_vectorized; } if (get_vector_aggregate(aggref->aggfnoid) == NULL) { /* * We don't have a vectorized implementation for this particular * aggregate function. */ return false; } if (aggref->args == NIL) { /* This must be count(*), we can vectorize it. */ return true; } /* The function must have one argument, check it. */ Assert(list_length(aggref->args) == 1); TargetEntry *argument = castNode(TargetEntry, linitial(aggref->args)); return is_vector_var(vqi, argument->expr); } /* * What vectorized grouping strategy we can use for the given grouping columns. */ static VectorAggGroupingType get_vectorized_grouping_type(const VectorQualInfo *vqinfo, Agg *agg, List *resolved_targetlist) { /* * The Agg->numCols value can be less than the number of the non-aggregated * vars in the aggregated targetlist, if some of them are equated to a * constant. This behavior started with PG 16. This case is not very * important, so we treat all non-aggregated columns as grouping columns to * keep the vectorized aggregation node simple. */ int num_grouping_columns = 0; bool all_segmentby = true; Var *single_grouping_var = NULL; ListCell *lc; foreach (lc, resolved_targetlist) { TargetEntry *target_entry = lfirst_node(TargetEntry, lc); if (IsA(target_entry->expr, Aggref)) { continue; } if (!IsA(target_entry->expr, Var)) { /* * We shouldn't see anything except Vars or Aggrefs in the * aggregated targetlists. Just say it's not vectorizable, because * here we are working with arbitrary plans that we don't control. */ return VAGT_Invalid; } num_grouping_columns++; if (!is_vector_var(vqinfo, target_entry->expr)) return VAGT_Invalid; Var *var = castNode(Var, target_entry->expr); all_segmentby &= vqinfo->segmentby_attrs[var->varattno]; /* * If we have a single grouping column, record it for the additional * checks later. */ single_grouping_var = var; } if (num_grouping_columns != 1) { single_grouping_var = NULL; } Assert(num_grouping_columns == 1 || single_grouping_var == NULL); Assert(num_grouping_columns >= agg->numCols); /* * We support vectorized aggregation without grouping. */ if (num_grouping_columns == 0) { return VAGT_Batch; } /* * We support grouping by any number of columns if all of them are segmentby. */ if (all_segmentby) { return VAGT_Batch; } /* * We support hashed vectorized grouping by one fixed-size by-value * compressed column. * We can use our hash table for GroupAggregate as well, because it preserves * the input order of the keys, but only for the direct order, not reverse. */ if (num_grouping_columns == 1) { int16 typlen; bool typbyval; get_typlenbyval(single_grouping_var->vartype, &typlen, &typbyval); if (typbyval) { switch (typlen) { case 1: #ifdef TS_USE_UMASH return VAGT_HashSerialized; #else return VAGT_Invalid; #endif case 2: return VAGT_HashSingleFixed2; case 4: return VAGT_HashSingleFixed4; case 8: return VAGT_HashSingleFixed8; default: Ensure(false, "invalid fixed size %d of a vector type", typlen); break; } } #ifdef TS_USE_UMASH /* * We also have the UUID type which is by-reference and has a * columnar in-memory representation, but no specialized single-column * vectorized grouping support. It can use the serialized grouping * strategy. */ else if (single_grouping_var->vartype == TEXTOID) { return VAGT_HashSingleText; } #endif } #ifdef TS_USE_UMASH /* * Use hashing of serialized keys when we have many grouping columns. */ return VAGT_HashSerialized; #else return VAGT_Invalid; #endif } /* * Check if we have a vectorized aggregation node and the usual Postgres * aggregation node in the plan tree. This is used for testing. */ bool has_vector_agg_node(Plan *plan, bool *has_postgres_partial_agg) { if (IsA(plan, Agg) && castNode(Agg, plan)->aggsplit == AGGSPLIT_INITIAL_SERIAL) { *has_postgres_partial_agg = true; return false; } if (plan->lefttree && has_vector_agg_node(plan->lefttree, has_postgres_partial_agg)) { return true; } if (plan->righttree && has_vector_agg_node(plan->righttree, has_postgres_partial_agg)) { return true; } CustomScan *custom = NULL; List *append_plans = NIL; if (IsA(plan, Append)) { append_plans = castNode(Append, plan)->appendplans; } if (IsA(plan, MergeAppend)) { append_plans = castNode(MergeAppend, plan)->mergeplans; } else if (IsA(plan, CustomScan)) { custom = castNode(CustomScan, plan); if (strcmp("ChunkAppend", custom->methods->CustomName) == 0) { append_plans = custom->custom_plans; } } else if (IsA(plan, SubqueryScan)) { SubqueryScan *subquery = castNode(SubqueryScan, plan); append_plans = list_make1(subquery->subplan); } if (append_plans) { ListCell *lc; foreach (lc, append_plans) { if (has_vector_agg_node(lfirst(lc), has_postgres_partial_agg)) { return true; } } return false; } if (custom == NULL) { return false; } if (strcmp(VECTOR_AGG_NODE_NAME, custom->methods->CustomName) == 0) { return true; } return false; } /* * Check if a VectorAgg is possible on top of the given child plan. * * If the child plan is compatible, also initialize the VectorQualInfo struct * for aggregation FILTER clauses. * * Returns true if the scan node is a supported child, otherwise false. */ static bool vectoragg_plan_possible(Plan *childplan, const List *rtable, VectorQualInfo *vqi) { if (!IsA(childplan, CustomScan)) return false; if (childplan->qual != NIL) { /* Can't do vectorized aggregation if we have Postgres quals. */ return false; } CustomScan *customscan = castNode(CustomScan, childplan); if (strcmp(customscan->methods->CustomName, "ColumnarScan") == 0) { vectoragg_plan_columnar_scan(childplan, vqi); return true; } return false; } /* * Where possible, replace the partial aggregation plan nodes with our own * vectorized aggregation node. The replacement is done in-place. */ Plan * try_insert_vector_agg_node(Plan *plan, List *rtable) { if (plan->lefttree) { plan->lefttree = try_insert_vector_agg_node(plan->lefttree, rtable); } if (plan->righttree) { plan->righttree = try_insert_vector_agg_node(plan->righttree, rtable); } List *append_plans = NIL; if (IsA(plan, Append)) { append_plans = castNode(Append, plan)->appendplans; } else if (IsA(plan, MergeAppend)) { append_plans = castNode(MergeAppend, plan)->mergeplans; } else if (IsA(plan, CustomScan)) { CustomScan *custom = castNode(CustomScan, plan); if (strcmp("ChunkAppend", custom->methods->CustomName) == 0) { append_plans = custom->custom_plans; } } else if (IsA(plan, SubqueryScan)) { SubqueryScan *subquery = castNode(SubqueryScan, plan); append_plans = list_make1(subquery->subplan); } if (append_plans) { ListCell *lc; foreach (lc, append_plans) { lfirst(lc) = try_insert_vector_agg_node(lfirst(lc), rtable); } return plan; } if (plan->type != T_Agg) { return plan; } Agg *agg = castNode(Agg, plan); if (agg->aggsplit != AGGSPLIT_INITIAL_SERIAL) { /* Can only vectorize partial aggregation node. */ return plan; } if (agg->groupingSets != NIL) { /* No GROUPING SETS support. */ return plan; } if (agg->plan.qual != NIL) { /* * No HAVING support. Probably we can't have it in this node in any case, * because we only replace the partial aggregation nodes which can't * check the HAVING clause. */ return plan; } if (agg->plan.lefttree == NULL) { /* * Not sure what this would mean, but check for it just to be on the * safe side because we can effectively see any possible plan here. */ return plan; } Plan *childplan = agg->plan.lefttree; VectorQualInfo vqi; MemSet(&vqi, 0, sizeof(VectorQualInfo)); /* * Build supplementary info to determine whether we can vectorize the * aggregate FILTER clauses. */ if (!vectoragg_plan_possible(childplan, rtable, &vqi)) { /* Not a compatible vectoragg child node */ return plan; } /* * To make it easier to examine the variables participating in the aggregation, * the subsequent checks are performed on the aggregated targetlist with * all variables resolved to uncompressed chunk variables. */ List *resolved_targetlist = resolve_outer_special_vars(agg->plan.targetlist, childplan); const VectorAggGroupingType grouping_type = get_vectorized_grouping_type(&vqi, agg, resolved_targetlist); if (grouping_type == VAGT_Invalid) { /* The grouping is not vectorizable. */ return plan; } /* * The hash grouping strategies do not preserve the input key order when the * reverse ordering is requested, so in this case they cannot work in * GroupAggregate mode. */ if (grouping_type != VAGT_Batch && agg->aggstrategy != AGG_HASHED) { if (vqi.reverse) { return plan; } } /* Now check the output targetlist. */ ListCell *lc; foreach (lc, resolved_targetlist) { TargetEntry *target_entry = lfirst_node(TargetEntry, lc); if (IsA(target_entry->expr, Aggref)) { Aggref *aggref = castNode(Aggref, target_entry->expr); if (!can_vectorize_aggref(&vqi, aggref)) { /* Aggregate function not vectorizable. */ return plan; } } else if (IsA(target_entry->expr, Var)) { if (!is_vector_var(&vqi, target_entry->expr)) { /* Variable not vectorizable. */ return plan; } } else { /* * Sometimes the plan can require this node to perform a projection, * e.g. we can see a nested loop param in its output targetlist. We * can't handle this case currently. */ return plan; } } /* * Finally, all requirements are satisfied and we can vectorize this partial * aggregation node. */ return vector_agg_plan_create(childplan, agg, resolved_targetlist, grouping_type); } ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/plan.h��������������������������������������������������0000664�0000000�0000000�00000001320�15100345067�0021773�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <nodes/plannodes.h> #include <utils/relcache.h> #include "nodes/columnar_scan/vector_quals.h" /* * The indexes of settings that we have to pass through the custom_private list. */ typedef enum { VASI_GroupingType = 0, VASI_Count } VectorAggSettingsIndex; extern void _vector_agg_init(void); extern void vectoragg_plan_columnar_scan(Plan *childplan, VectorQualInfo *vqi); Plan *try_insert_vector_agg_node(Plan *plan, List *rtable); bool has_vector_agg_node(Plan *plan, bool *has_normal_agg); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/plan_columnar_scan.c������������������������������������0000664�0000000�0000000�00000010136�15100345067�0024677�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <nodes/pathnodes.h> #include <nodes/plannodes.h> #include "nodes/columnar_scan/planner.h" #include "plan.h" /* * Whether the given compressed column index corresponds to a vector variable. */ static bool is_vector_compressed_column(const CustomScan *custom, int compressed_column_index, bool *out_is_segmentby) { List *bulk_decompression_column = list_nth(custom->custom_private, DCP_BulkDecompressionColumn); const bool bulk_decompression_enabled_for_column = list_nth_int(bulk_decompression_column, compressed_column_index); /* * Bulk decompression can be disabled for all columns in the ColumnarScan * node settings, we can't do vectorized aggregation for compressed columns * in that case. For segmentby columns it's still possible. */ List *settings = linitial(custom->custom_private); const bool bulk_decompression_enabled_globally = list_nth_int(settings, DCS_EnableBulkDecompression); /* * Check if this column is a segmentby. */ List *is_segmentby_column = list_nth(custom->custom_private, DCP_IsSegmentbyColumn); const bool is_segmentby = list_nth_int(is_segmentby_column, compressed_column_index); if (out_is_segmentby) { *out_is_segmentby = is_segmentby; } /* * We support vectorized aggregation either for segmentby columns or for * columns with bulk decompression enabled. */ if (!is_segmentby && !(bulk_decompression_enabled_for_column && bulk_decompression_enabled_globally)) { /* Vectorized aggregation not possible for this particular column. */ return false; } return true; } /* * Map the custom scan attribute number to the uncompressed chunk attribute * number. */ static int custom_scan_to_uncompressed_chunk_attno(List *custom_scan_tlist, int custom_scan_attno) { if (custom_scan_tlist == NIL) { return custom_scan_attno; } Var *var = castNode(Var, castNode(TargetEntry, list_nth(custom_scan_tlist, AttrNumberGetAttrOffset(custom_scan_attno))) ->expr); return var->varattno; } void vectoragg_plan_columnar_scan(Plan *childplan, VectorQualInfo *vqi) { const CustomScan *custom = castNode(CustomScan, childplan); vqi->rti = custom->scan.scanrelid; /* * Now, we have to translate the decompressed varno into the compressed * column index, to check if the column supports bulk decompression. */ List *decompression_map = list_nth(custom->custom_private, DCP_DecompressionMap); /* * There's no easy way to determine maximum attribute number for uncompressed * chunk at this stage, so we'll have to go through all the compressed columns * for this. */ int maxattno = 0; for (int compressed_column_index = 0; compressed_column_index < list_length(decompression_map); compressed_column_index++) { const int custom_scan_attno = list_nth_int(decompression_map, compressed_column_index); if (custom_scan_attno <= 0) { continue; } const int uncompressed_chunk_attno = custom_scan_to_uncompressed_chunk_attno(custom->custom_scan_tlist, custom_scan_attno); if (uncompressed_chunk_attno > maxattno) { maxattno = uncompressed_chunk_attno; } } vqi->maxattno = maxattno; vqi->vector_attrs = (bool *) palloc0(sizeof(bool) * (maxattno + 1)); vqi->segmentby_attrs = (bool *) palloc0(sizeof(bool) * (maxattno + 1)); for (int compressed_column_index = 0; compressed_column_index < list_length(decompression_map); compressed_column_index++) { const int custom_scan_attno = list_nth_int(decompression_map, compressed_column_index); if (custom_scan_attno <= 0) { continue; } const int uncompressed_chunk_attno = custom_scan_to_uncompressed_chunk_attno(custom->custom_scan_tlist, custom_scan_attno); vqi->vector_attrs[uncompressed_chunk_attno] = is_vector_compressed_column(custom, compressed_column_index, &vqi->segmentby_attrs[uncompressed_chunk_attno]); } List *settings = linitial(custom->custom_private); vqi->reverse = list_nth_int(settings, DCS_Reverse); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/nodes/vector_agg/vector_slot.h�������������������������������������������0000664�0000000�0000000�00000002422�15100345067�0023410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <access/attnum.h> #include <access/tupdesc.h> #include <nodes/columnar_scan/compressed_batch.h> /* * Vector slot functions. * * These functions provide a common interface for arrow slots and compressed * batches. * */ /* * Get the result vectorized filter bitmap. */ static inline const uint64 * vector_slot_get_qual_result(const TupleTableSlot *slot, uint16 *num_rows) { const DecompressBatchState *batch_state = (const DecompressBatchState *) slot; *num_rows = batch_state->total_batch_rows; return batch_state->vector_qual_result; } /* * Return the arrow array or the datum (in case of single scalar value) for a * given attribute as a CompressedColumnValues struct. */ static inline const CompressedColumnValues * vector_slot_get_compressed_column_values(TupleTableSlot *slot, const AttrNumber attnum) { const uint16 offset = AttrNumberGetAttrOffset(attnum); const DecompressBatchState *batch_state = (const DecompressBatchState *) slot; const CompressedColumnValues *values = &batch_state->compressed_columns[offset]; return values; } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/partialize_finalize.c����������������������������������������������������0000664�0000000�0000000�00000066246�15100345067�0021653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <catalog/namespace.h> #include <catalog/pg_aggregate.h> #include <catalog/pg_collation.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <parser/parse_agg.h> #include <parser/parse_coerce.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/datum.h> #include <utils/fmgroids.h> #include <utils/palloc.h> #include <utils/resowner.h> #include <utils/syscache.h> #include "partialize_finalize.h" #include "utils.h" /* * This file implements functions to split the calculation of partial and final * aggregates into separate steps such that the partials can be passed out of a * sql query (in their internal state) and then passed into another sql query to * be finalized and the actual aggregate returned. * * For instance: `SELECT sum(a) FROM foo;` can be transformed into `SELECT * finalize(partial_sum_a) FROM (SELECT partialize(sum(a)) FROM foo);` * * The partialize function is implemented as a regular function, the function * call itself does very little except ensure that the type returned is what the * node is expecting, most of the work is done in plan_partialize.c, where calls * to that function are intercepted and the plan is modified to return the * partial state of the aggregate rather than its finalized state. It always * returns a BYTEA. * * The finalize function is implemented as an aggregate which takes in the * schema qualified name of the agg we're finalizing (we'll call this the inner * agg from now on), the partial/transition state of the inner agg (as a BYTEA), * some collation info and the return type of the original inner agg (an * ANYELEMENT that will just be a null/dummy element that tells the planner what * type we're going to return from our agg). This function then serves basically * as a wrapper, it takes the transition state of the inner aggregate as its * input, calls the combine function of the inner aggregate as its transition * function and the finalfunc of the inner aggregate. */ /* * We're modeling much of our design on nodeAgg.c, and the long comment there * describes the design decisions well, we won't repeat all of that here, but we * will repeat some of it. Namely that we want to split out as much state as * possible that can eventually be moved to being instantiated in an higher * memory context than per group as it is invariant between groups and the * lookups/extra memory overhead per group can have a significant impact. * Therefore we have 3 structs, one to define all of the invariants to apply the * combine function of the inner agg, one to define all of the invariants needed * to apply the finalize function of the inner agg and a third that carries the * current state of the agg in the group. * * tsl_finalize_agg_sfunc is the state transition function * tsl_finalize_agg_ffunc is the finalize function */ /* State for calling the combine + deserialize functions of the inner aggregate */ typedef struct FACombineFnMeta { Oid combinefnoid; Oid deserialfnoid; Oid transtype; Oid recv_fn; Oid typIOParam; FmgrInfo deserialfn; FmgrInfo internal_deserialfn; FmgrInfo combinefn; /* either deserialfn_fcinfo or internal_deserialfn_fcinfo is valid*/ FunctionCallInfo deserialfn_fcinfo; FunctionCallInfo internal_deserialfn_fcinfo; FunctionCallInfo combfn_fcinfo; } FACombineFnMeta; /* State for calling the final function of the inner aggregate */ typedef struct FAFinalFnMeta { Oid finalfnoid; FmgrInfo finalfn; FunctionCallInfo finalfn_fcinfo; } FAFinalFnMeta; /* * Per group state of the finalize aggregate. Note that if we have a strict combine * function, both arg values have to be non-null (like min/max). When we see * first non-null value, initialize trans_value and set trans_value_initialized true. see PG11 * advance_transition_function */ typedef struct FAPerGroupState { Datum trans_value; bool trans_value_isnull; bool trans_value_initialized; } FAPerGroupState; /* metadata information that is common for the entire query */ typedef struct FAPerQueryState { FACombineFnMeta combine_meta; FAFinalFnMeta final_meta; } FAPerQueryState; typedef struct FATransitionState { FAPerQueryState *per_query_state; FAPerGroupState *per_group_state; } FATransitionState; static Oid aggfnoid_from_aggname(text *aggfn) { char *funcname = text_to_cstring(aggfn); Oid oid; oid = DatumGetObjectId(DirectFunctionCall1(regprocedurein, CStringGetDatum(funcname))); if (!OidIsValid(oid)) ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("function \"%s\" does not exist", funcname))); return oid; } static Oid collation_oid_from_name(char *schema_name, char *collation_name) { List *namel = NIL; if (NULL == collation_name) return InvalidOid; if (NULL != schema_name) namel = list_make1(makeString(schema_name)); namel = lappend(namel, makeString(collation_name)); return get_collation_oid(namel, false); } /* * ======================================= * Record serialized partials errata here: * ======================================= * * ================================================================================================ * The numeric format changed between PG13 and PG14 to include infinities. Consequently the * internal aggregate for the combine functions changed as well, which lead to the serialized * partial state of numeric aggregates also changing format. * * If a user that has stored partials (by using Continuous Aggregates or calling * _timescaledb_functions.finalize_agg()) upgrades to PG14 then the partial state deserialization * will lead to errors due to the mismatch with the PG14 code. * * For F_NUMERIC_AVG_DESERIALIZE and F_NUMERIC_DESERIALIZE the length of the serialized aggregate * state is 16 bytes longer than the previous versions. It suffices to zero out the extra bytes of * pInfcount and nInfcount in the numeric aggregate combine state. Those fields are only there to * support infinity and -infinity in the numeric type, which wasn't supported in older PostgreSQL * versions. * * PostgreSQL versions < 14 * F_NUMERIC_AVG_DESERIALIZE serialized partial length = X * F_NUMERIC_DESERIALIZE serialized partial length = X + 10 * * PostgreSQL versions >= 14 * F_NUMERIC_AVG_DESERIALIZE serialized partial length = X + 16 * F_NUMERIC_DESERIALIZE serialized partial length = X + 10 + 16 * * For more information see: https://www.postgresql.org/message-id/606717.1591924582@sss.pgh.pa.us * * Non-numeric aggregate functions affected: * 1. var_pop(int8) * 2. var_samp(int8) * 3. variance(int8) * 4. stddev_pop(int8) * 5. stddev_samp(int8) * 6. stddev(int8) * ================================================================================================ * F_NUMERIC_POLY_DESERIALIZE depends on compiler support for HAVE_INT128. As a result, recompiling * the same versions of PostgreSQL and TimescaleDB with a different compiler can lead to corruption * if the same database is reused. * * Non-numeric aggregate functions affected: * 1. var_pop(int4) * 2. var_pop(int2) * 3. var_samp(int4) * 4. var_samp(int2) * 5. variance(int4) * 6. variance(int2) * 7. stddev_pop(int4) * 8. stddev_pop(int2) * 9. stddev_samp(int4) * 10. stddev_samp(int2) * 11. stddev(int4) * 12. stddev(int2) */ #define NUMERIC_PARTIAL_MISSING_LENGTH (16) static bytea * zero_fill_bytearray(bytea *serialized_partial, size_t missing_length) { size_t original_length = VARSIZE_ANY_EXHDR(serialized_partial); size_t desired_length = original_length + missing_length; bytea *new_bytea = repalloc(serialized_partial, desired_length + VARHDRSZ); SET_VARSIZE(new_bytea, desired_length + VARHDRSZ); void *end_of_serialized_partial = VARDATA(new_bytea) + original_length; memset(end_of_serialized_partial, 0, missing_length); return new_bytea; } /* Only call this function if the partial is known to be problematic. */ static bytea * sanitize_serialized_partial(Oid deserialfnoid, bytea *serialized_partial) { if ((deserialfnoid == F_NUMERIC_DESERIALIZE) || (deserialfnoid == F_NUMERIC_AVG_DESERIALIZE)) { /* * Always add NUMERIC_PARTIAL_MISSING_LENGTH extra bytes because the length is not fixed. * This is only safe to do when the partial state is known to be short, otherwise an * exception is thrown if the serialized_partial is not fully consumed by deserialfn(). */ TS_DEBUG_LOG("zero-filling serialized numeric type"); return zero_fill_bytearray(serialized_partial, NUMERIC_PARTIAL_MISSING_LENGTH); } return serialized_partial; } /* * deserialize from the internal format in which data is stored in bytea * parameter. Callers need to check deserialized_isnull . Only if this is set to false, * a valid value is returned. * The serialized_partial argument is declared volatile to avoid the mistaken * gcc-11 warning -Wclobbered. */ static Datum inner_agg_deserialize(FACombineFnMeta *combine_meta, bytea *volatile serialized_partial, bool serialized_isnull, bool *deserialized_isnull) { Datum deserialized = (Datum) 0; FunctionCallInfo deser_fcinfo = combine_meta->deserialfn_fcinfo; *deserialized_isnull = true; if (OidIsValid(combine_meta->deserialfnoid)) { if (serialized_isnull && combine_meta->deserialfn.fn_strict) { PG_RETURN_VOID(); /*don't call the deser function */ } FC_ARG(deser_fcinfo, 0) = PointerGetDatum(serialized_partial); FC_NULL(deser_fcinfo, 0) = serialized_isnull; deser_fcinfo->isnull = false; /* * When an exception is thrown and longjmp() is called, * CurrentMemoryContext is potentially different than what it was * inside the PG_TRY() block below. * * Restore it to the old value so that the code in the subsequent * PG_CATCH() block does not corrupt the memory. * * No need for volatile variables since we don't modify any of this * function's stack frame inside the PG_TRY() block. * * We create a subtransaction to run the functions below, in case they * abort. */ MemoryContext oldcontext = CurrentMemoryContext; ResourceOwner oldowner = CurrentResourceOwner; /* * For testing, we print out the memory context before and after the * block. * * It would be nice to print the resource owner name here as well to * make sure that it is the same as before, but this is hidden inside * resowner.c. */ ereport(DEBUG2, errmsg("%s - deserializing partial", __func__), errdetail("mcxt: %s", CurrentMemoryContext->name)); BeginInternalSubTransaction(NULL); PG_TRY(); { deserialized = FunctionCallInvoke(deser_fcinfo); ReleaseCurrentSubTransaction(); MemoryContextSwitchTo(oldcontext); CurrentResourceOwner = oldowner; } PG_CATCH(); { const int sqlerrcode = geterrcode(); /* * If we get a data exception category error or a protocol * violation or an internal error (which is generated by default * when using elog()), the format is in the old numeric and we can * attempt to repair it. * * If the error is an insufficient resources category we should * *not* continue executing. * * Errors in other categories are not expected, but we cannot do * anything with them anyway, so just re-throw them too. */ if (ERRCODE_TO_CATEGORY(sqlerrcode) != ERRCODE_DATA_EXCEPTION && sqlerrcode != ERRCODE_PROTOCOL_VIOLATION && sqlerrcode != ERRCODE_INTERNAL_ERROR) { PG_RE_THROW(); } FlushErrorState(); RollbackAndReleaseCurrentSubTransaction(); MemoryContextSwitchTo(oldcontext); CurrentResourceOwner = oldowner; ereport(DEBUG2, errmsg("%s - attempting repair of serialized partial", __func__), errdetail("mcxt: %s", CurrentMemoryContext->name)); serialized_partial = sanitize_serialized_partial(combine_meta->deserialfnoid, serialized_partial); FC_ARG(deser_fcinfo, 0) = PointerGetDatum(serialized_partial); deser_fcinfo->isnull = false; deserialized = FunctionCallInvoke(deser_fcinfo); } PG_END_TRY(); *deserialized_isnull = deser_fcinfo->isnull; } else if (!serialized_isnull) { int32 typmod = -1; StringInfo string = makeStringInfo(); FunctionCallInfo internal_deserialfn_fcinfo = combine_meta->internal_deserialfn_fcinfo; appendBinaryStringInfo(string, VARDATA_ANY(serialized_partial), VARSIZE_ANY_EXHDR(serialized_partial)); FC_SET_ARG(internal_deserialfn_fcinfo, 0, PointerGetDatum(string)); FC_SET_ARG(internal_deserialfn_fcinfo, 1, ObjectIdGetDatum(combine_meta->typIOParam)); FC_SET_ARG(internal_deserialfn_fcinfo, 2, Int32GetDatum(typmod)); internal_deserialfn_fcinfo->isnull = false; deserialized = FunctionCallInvoke(internal_deserialfn_fcinfo); *deserialized_isnull = internal_deserialfn_fcinfo->isnull; } PG_RETURN_DATUM(deserialized); } /* Convert a 2-dimensional array of schema, names to type OIDs */ static Oid * get_input_types(ArrayType *input_types, size_t *number_types) { ArrayMetaState meta = { .element_type = NAMEOID }; ArrayIterator iter; Datum slice_datum; bool slice_null; Oid *type_oids; int type_index = 0; if (input_types == NULL) elog(ERROR, "cannot pass null input_type with FINALFUNC_EXTRA aggregates"); get_typlenbyvalalign(meta.element_type, &meta.typlen, &meta.typbyval, &meta.typalign); if (ARR_NDIM(input_types) != 2) elog(ERROR, "invalid input type array: wrong number of dimensions"); *number_types = ARR_DIMS(input_types)[0]; type_oids = palloc0(sizeof(*type_oids) * (*number_types)); iter = array_create_iterator(input_types, 1, &meta); while (array_iterate(iter, &slice_datum, &slice_null)) { Datum *slice_fields; int slice_elems; Name schema; Name type_name; Oid schema_oid; Oid type_oid; ArrayType *slice_array = DatumGetArrayTypeP(slice_datum); if (slice_null) elog(ERROR, "invalid input type array slice: cannot be null"); deconstruct_array(slice_array, meta.element_type, meta.typlen, meta.typbyval, meta.typalign, &slice_fields, NULL, &slice_elems); if (slice_elems != 2) elog(ERROR, "invalid input type array: expecting slices of size 2"); schema = DatumGetName(slice_fields[0]); type_name = DatumGetName(slice_fields[1]); schema_oid = get_namespace_oid(NameStr(*schema), false); type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid, PointerGetDatum(NameStr(*type_name)), ObjectIdGetDatum(schema_oid)); if (!OidIsValid(type_oid)) elog(ERROR, "invalid input type: %s.%s", NameStr(*schema), NameStr(*type_name)); type_oids[type_index++] = type_oid; } return type_oids; }; static FATransitionState * fa_transition_state_init(MemoryContext *fa_context, FAPerQueryState *qstate, AggState *fa_aggstate) { FATransitionState *tstate = NULL; tstate = (FATransitionState *) MemoryContextAlloc(*fa_context, sizeof(*tstate)); tstate->per_query_state = qstate; tstate->per_group_state = (FAPerGroupState *) MemoryContextAlloc(*fa_context, sizeof(*tstate->per_group_state)); /* Need to init tstate->per_group_state->trans_value */ tstate->per_group_state->trans_value_isnull = true; tstate->per_group_state->trans_value_initialized = false; return tstate; } static FAPerQueryState * fa_perquery_state_init(FunctionCallInfo fcinfo) { char *inner_agg_input_coll_schema = PG_ARGISNULL(2) ? NULL : NameStr(*PG_GETARG_NAME(2)); char *inner_agg_input_coll_name = PG_ARGISNULL(3) ? NULL : NameStr(*PG_GETARG_NAME(3)); ArrayType *input_types = PG_ARGISNULL(4) ? NULL : PG_GETARG_ARRAYTYPE_P(4); Oid inner_agg_fn_oid = aggfnoid_from_aggname(PG_GETARG_TEXT_PP(1)); Oid collation = collation_oid_from_name(inner_agg_input_coll_schema, inner_agg_input_coll_name); FAPerQueryState *tstate; HeapTuple inner_agg_tuple; Form_pg_aggregate inner_agg_form; MemoryContext qcontext = fcinfo->flinfo->fn_mcxt; MemoryContext oldcontext = MemoryContextSwitchTo(qcontext); AggState *fa_aggstate = (AggState *) fcinfo->context; bool aggfinalextra; /* look up catalog entry and populate what we need */ inner_agg_tuple = SearchSysCache1(AGGFNOID, inner_agg_fn_oid); if (!HeapTupleIsValid(inner_agg_tuple)) elog(ERROR, "cache lookup failed for aggregate %u", inner_agg_fn_oid); inner_agg_form = (Form_pg_aggregate) GETSTRUCT(inner_agg_tuple); /* we only support aggregates with 0 direct args (only ordered set aggs do not meet this * condition)*/ if (inner_agg_form->aggnumdirectargs != 0) elog(ERROR, "function calls with direct args are not supported by TimescaleDB finalize agg"); tstate = (FAPerQueryState *) MemoryContextAlloc(qcontext, sizeof(FAPerQueryState)); tstate->final_meta.finalfnoid = inner_agg_form->aggfinalfn; tstate->combine_meta.combinefnoid = inner_agg_form->aggcombinefn; tstate->combine_meta.deserialfnoid = inner_agg_form->aggdeserialfn; tstate->combine_meta.transtype = inner_agg_form->aggtranstype; aggfinalextra = inner_agg_form->aggfinalextra; ReleaseSysCache(inner_agg_tuple); /* initialize combine specific state, both the deserialize function and combine function */ if (!OidIsValid(tstate->combine_meta.combinefnoid)) elog(ERROR, "no valid combine function for the aggregate specified in Timescale finalize call"); fmgr_info_cxt(tstate->combine_meta.combinefnoid, &tstate->combine_meta.combinefn, qcontext); tstate->combine_meta.combfn_fcinfo = HEAP_FCINFO(2); InitFunctionCallInfoData(*tstate->combine_meta.combfn_fcinfo, &tstate->combine_meta.combinefn, 2, /* combine fn always has two args */ collation, (void *) fa_aggstate, NULL); if (OidIsValid(tstate->combine_meta.deserialfnoid)) /* deserial fn not necessary, no need to throw errors if not found */ { fmgr_info_cxt(tstate->combine_meta.deserialfnoid, &tstate->combine_meta.deserialfn, qcontext); tstate->combine_meta.deserialfn_fcinfo = HEAP_FCINFO(1); InitFunctionCallInfoData(*tstate->combine_meta.deserialfn_fcinfo, &tstate->combine_meta.deserialfn, 1, /* deserialize always has 1 arg */ collation, (void *) fa_aggstate, NULL); } else { /* save information for internal deserialization. caching instead of calling ReceiveFunctionCall */ /* If the argument type of the aggregate function is a pseudotype the * lookup/execution of the input function will fail. In that case we * use the argument type of the finalize_agg_ffunc return_type_dummy_val * argument instead. */ Oid column_type; if (TypeCategory(tstate->combine_meta.transtype) != TYPCATEGORY_PSEUDOTYPE) column_type = tstate->combine_meta.transtype; else column_type = get_fn_expr_argtype(fcinfo->flinfo, 6); getTypeBinaryInputInfo(column_type, &tstate->combine_meta.recv_fn, &tstate->combine_meta.typIOParam); fmgr_info_cxt(tstate->combine_meta.recv_fn, &tstate->combine_meta.internal_deserialfn, qcontext); tstate->combine_meta.internal_deserialfn_fcinfo = HEAP_FCINFO(3); InitFunctionCallInfoData(*tstate->combine_meta.internal_deserialfn_fcinfo, &tstate->combine_meta.internal_deserialfn, 3, InvalidOid, NULL, NULL); } /* initialize finalfn specific state */ if (OidIsValid(tstate->final_meta.finalfnoid)) { int num_args = 1; Oid *types = NULL; size_t number_types = 0; if (aggfinalextra) { types = get_input_types(input_types, &number_types); num_args += number_types; } if (num_args != get_func_nargs(tstate->final_meta.finalfnoid)) elog(ERROR, "invalid number of input types"); fmgr_info_cxt(tstate->final_meta.finalfnoid, &tstate->final_meta.finalfn, qcontext); /* pass the aggstate information from our current call context */ tstate->final_meta.finalfn_fcinfo = HEAP_FCINFO(num_args); InitFunctionCallInfoData(*tstate->final_meta.finalfn_fcinfo, &tstate->final_meta.finalfn, num_args, collation, (void *) fa_aggstate, NULL); if (number_types > 0) { Expr *expr; int i; build_aggregate_finalfn_expr(types, num_args, tstate->combine_meta.transtype, types[number_types - 1], collation, tstate->final_meta.finalfnoid, &expr); fmgr_info_set_expr((Node *) expr, &tstate->final_meta.finalfn); for (i = 1; i < num_args; i++) FC_SET_NULL(tstate->final_meta.finalfn_fcinfo, i); } } fcinfo->flinfo->fn_extra = (void *) tstate; MemoryContextSwitchTo(oldcontext); return tstate; } /* * Take the previous value in the group state and call the combine function specified to combine * with the new value that's passed in. */ static void group_state_advance(FAPerGroupState *per_group_state, FACombineFnMeta *combine_meta, Datum newval, bool newval_isnull) { FC_ARG(combine_meta->combfn_fcinfo, 0) = per_group_state->trans_value; FC_NULL(combine_meta->combfn_fcinfo, 0) = per_group_state->trans_value_isnull; FC_ARG(combine_meta->combfn_fcinfo, 1) = newval; FC_NULL(combine_meta->combfn_fcinfo, 1) = newval_isnull; combine_meta->combfn_fcinfo->isnull = false; per_group_state->trans_value = FunctionCallInvoke(combine_meta->combfn_fcinfo); per_group_state->trans_value_isnull = combine_meta->combfn_fcinfo->isnull; }; /* * The parameters for tsl_finalize_agg_sfunc (see util_aggregates.sql sql input names) * tstate The internal state of the aggregate * Text aggregatefn: text format of agg function whose state is passed, * this should match the output of regprocedureout(<oid>) * we use this to retrieve the inner_agg_fn_oid by calling regprocedurein. * Name inner_agg_collation_schema: schema name for input collation name used by the aggregate * Name inner_agg_collation_name: input collation name used by the aggregate when state was stored. * bytea inner_agg_serialized_state: the partial state of the inner aggregate, in its serialized * form (as stored in the materialization table in materialized aggs) ANYELEMENT * return_type_dummy_val: used for type inference of the return type, populated from the initial agg * node. * * We use the combine function of the aggregatefn to combine the states. * Respect the "strict" nature of the combine function when we encounter * nulls in the data. */ Datum tsl_finalize_agg_sfunc(PG_FUNCTION_ARGS) { FATransitionState *tstate = PG_ARGISNULL(0) ? NULL : (FATransitionState *) PG_GETARG_POINTER(0); bytea *inner_agg_serialized_state = PG_ARGISNULL(5) ? NULL : PG_GETARG_BYTEA_P(5); bool inner_agg_serialized_state_isnull = PG_ARGISNULL(5) ? true : false; Datum inner_agg_deserialized_state; MemoryContext fa_context, old_context; if (!AggCheckCallContext(fcinfo, &fa_context) || !IsA(fcinfo->context, AggState)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "finalize_agg_sfunc called in non-aggregate context"); } if (PG_ARGISNULL(1)) elog(ERROR, "finalize_agg_sfunc called with NULL aggfn"); old_context = MemoryContextSwitchTo(fa_context); if (tstate == NULL) { FAPerQueryState *qstate = (FAPerQueryState *) fcinfo->flinfo->fn_extra; if (qstate == NULL) { qstate = fa_perquery_state_init(fcinfo); Assert(fcinfo->flinfo->fn_extra != NULL); } tstate = fa_transition_state_init(&fa_context, qstate, (AggState *) fcinfo->context); /* initial trans_value = the partial state of the inner agg from first invocation */ tstate->per_group_state->trans_value = inner_agg_deserialize(&tstate->per_query_state->combine_meta, inner_agg_serialized_state, inner_agg_serialized_state_isnull, &tstate->per_group_state->trans_value_isnull); tstate->per_group_state->trans_value_initialized = !(tstate->per_group_state->trans_value_isnull); } else { bool deser_isnull; bool call_combine; inner_agg_deserialized_state = inner_agg_deserialize(&tstate->per_query_state->combine_meta, inner_agg_serialized_state, inner_agg_serialized_state_isnull, &deser_isnull); /* * When we have a strict combine function, both arguments to combinefn * have to be non-null. It also means that if we initialized our * trans_value with a null value above, it doesn't actually count, so we * need to try that again if so. */ call_combine = true; if (tstate->per_query_state->combine_meta.combinefn.fn_strict) { if (tstate->per_group_state->trans_value_initialized == false && deser_isnull == false) { /* first time we got non-null value, so init the trans_value with it*/ tstate->per_group_state->trans_value = inner_agg_deserialized_state; tstate->per_group_state->trans_value_isnull = false; tstate->per_group_state->trans_value_initialized = true; call_combine = false; } else if (deser_isnull || tstate->per_group_state->trans_value_isnull) call_combine = false; } if (call_combine) group_state_advance(tstate->per_group_state, &tstate->per_query_state->combine_meta, inner_agg_deserialized_state, deser_isnull); } MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(tstate); } /* * Apply the finalize function on the state we have accumulated * * The state passed down to this function can be used by other aggregate * functions so it is important to not change the state when computing the * final result. */ Datum tsl_finalize_agg_ffunc(PG_FUNCTION_ARGS) { FATransitionState *tstate = PG_ARGISNULL(0) ? NULL : (FATransitionState *) PG_GETARG_POINTER(0); MemoryContext fa_context, old_context; Datum result = tstate->per_group_state->trans_value; bool result_isnull = tstate->per_group_state->trans_value_isnull; Assert(tstate != NULL); if (!AggCheckCallContext(fcinfo, &fa_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "finalize_agg_ffunc called in non-aggregate context"); } old_context = MemoryContextSwitchTo(fa_context); if (OidIsValid(tstate->per_query_state->final_meta.finalfnoid)) { /* don't execute if strict and the trans value is NULL or there are extra args (all extra * args are always NULL) */ if (!(tstate->per_query_state->final_meta.finalfn.fn_strict && tstate->per_group_state->trans_value_isnull) && !(tstate->per_query_state->final_meta.finalfn.fn_strict && tstate->per_query_state->final_meta.finalfn_fcinfo->nargs > 1)) { FunctionCallInfo finalfn_fcinfo = tstate->per_query_state->final_meta.finalfn_fcinfo; FC_ARG(finalfn_fcinfo, 0) = tstate->per_group_state->trans_value; FC_NULL(finalfn_fcinfo, 0) = tstate->per_group_state->trans_value_isnull; finalfn_fcinfo->isnull = false; result = FunctionCallInvoke(finalfn_fcinfo); result_isnull = finalfn_fcinfo->isnull; } } MemoryContextSwitchTo(old_context); if (result_isnull) PG_RETURN_NULL(); else PG_RETURN_DATUM(result); } /* * the partialize_agg function mainly serves as a marker that the aggregate called * within should return a partial instead of a result. Most of the actual work * occurs in the planner, with the actual function just used to ensure the * return type is correct. */ Datum tsl_partialize_agg(PG_FUNCTION_ARGS) { Datum arg; Oid arg_type; Oid send_fn; bool type_is_varlena; if (PG_ARGISNULL(0)) PG_RETURN_NULL(); arg = PG_GETARG_DATUM(0); arg_type = get_fn_expr_argtype(fcinfo->flinfo, 0); if (arg_type == BYTEAOID) PG_RETURN_DATUM(arg); getTypeBinaryOutputInfo(arg_type, &send_fn, &type_is_varlena); PG_RETURN_BYTEA_P(OidSendFunctionCall(send_fn, arg)); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/partialize_finalize.h����������������������������������������������������0000664�0000000�0000000�00000000742�15100345067�0021645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <fmgr.h> #include "compat/compat.h" #define PARTIALIZE_FUNC_NAME "partialize_agg" extern Datum tsl_finalize_agg_sfunc(PG_FUNCTION_ARGS); extern Datum tsl_finalize_agg_ffunc(PG_FUNCTION_ARGS); extern Datum tsl_partialize_agg(PG_FUNCTION_ARGS); ������������������������������timescaledb-2.23.0/tsl/src/planner.c����������������������������������������������������������������0000664�0000000�0000000�00000015501�15100345067�0017251�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <catalog/pg_trigger.h> #include <commands/extension.h> #include <foreign/fdwapi.h> #include <nodes/nodeFuncs.h> #include <nodes/parsenodes.h> #include <optimizer/paths.h> #include <parser/parsetree.h> #include "compat/compat.h" #include "chunk.h" #include "chunkwise_agg.h" #include "continuous_aggs/planner.h" #include "guc.h" #include "hypertable.h" #include "nodes/columnar_scan/columnar_scan.h" #include "nodes/frozen_chunk_dml/frozen_chunk_dml.h" #include "nodes/gapfill/gapfill.h" #include "nodes/skip_scan/skip_scan.h" #include "nodes/vector_agg/plan.h" #include "planner.h" #include "planner/partialize.h" #include <math.h> #define OSM_EXTENSION_NAME "timescaledb_osm" static int osm_present = -1; static bool is_osm_present() { if (osm_present == -1) { Oid osm_oid = get_extension_oid(OSM_EXTENSION_NAME, true); osm_present = OidIsValid(osm_oid); } return osm_present; } static bool involves_hypertable(PlannerInfo *root, RelOptInfo *parent) { for (int relid = bms_next_member(parent->relids, -1); relid > 0; relid = bms_next_member(parent->relids, relid)) { Hypertable *ht; RelOptInfo *child = root->simple_rel_array[relid]; /* * RelOptInfo can be null here for join RTEs on PG >= 16. This doesn't * matter because we'll have all the baserels in relids bitmap as well. */ if (child != NULL && ts_classify_relation(root, child, &ht) == TS_REL_HYPERTABLE) { return true; } } return false; } void tsl_create_upper_paths_hook(PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, RelOptInfo *output_rel, TsRelType input_reltype, Hypertable *ht, void *extra) { switch (stage) { case UPPERREL_GROUP_AGG: if (input_reltype != TS_REL_HYPERTABLE_CHILD) { plan_add_gapfill(root, output_rel); } if (ts_guc_enable_chunkwise_aggregation && input_rel != NULL && !IS_DUMMY_REL(input_rel) && output_rel != NULL && involves_hypertable(root, input_rel)) { tsl_pushdown_partial_agg(root, ht, input_rel, output_rel, extra); } if (root->numOrderedAggs && !IS_DUMMY_REL(input_rel) && output_rel != NULL) { tsl_skip_scan_paths_add(root, input_rel, output_rel, stage); } break; case UPPERREL_WINDOW: if (IsA(linitial(input_rel->pathlist), CustomPath)) gapfill_adjust_window_targetlist(root, input_rel, output_rel); break; case UPPERREL_DISTINCT: tsl_skip_scan_paths_add(root, input_rel, output_rel, stage); break; default: break; } } /* * Check if a chunk should be decompressed via a ColumnarScan plan. * * Check first that it is a compressed chunk. Then, decompress unless it is * SELECT * FROM ONLY <chunk>. We check if it is the ONLY case by calling * ts_rte_is_marked_for_expansion. Respecting ONLY here is important to not * break postgres tools like pg_dump. */ static inline bool use_columnar_scan(const RelOptInfo *rel, const RangeTblEntry *rte, const Chunk *chunk) { if (!ts_guc_enable_transparent_decompression) return false; /* Check that the chunk is actually compressed */ return chunk->fd.compressed_chunk_id != INVALID_CHUNK_ID && /* Check that it is _not_ SELECT FROM ONLY <chunk> */ (rel->reloptkind != RELOPT_BASEREL || ts_rte_is_marked_for_expansion(rte)); } void tsl_set_rel_pathlist_query(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte, Hypertable *ht) { /* Only interested in queries on relations that are part of hypertables * with compression enabled, so quick exit if not this case. */ if (ht == NULL || !TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) return; /* * For a chunk, we can get here via a query on the hypertable that expands * to the chunk or by direct query on the chunk. In the former case, * reloptkind will be RELOPT_OTHER_MEMBER_REL (nember of hypertable) or in * the latter case reloptkind will be RELOPT_BASEREL (standalone rel). * * These two cases are checked in ts_planner_chunk_fetch(). */ const Chunk *chunk = ts_planner_chunk_fetch(root, rel); if (chunk == NULL) return; if (use_columnar_scan(rel, rte, chunk)) { ts_columnar_scan_generate_paths(root, rel, ht, chunk); } } void tsl_set_rel_pathlist_dml(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte, Hypertable *ht) { if (is_osm_present()) { Chunk *chunk = ts_chunk_get_by_relid(rte->relid, false); if (chunk && ts_chunk_is_frozen(chunk)) { ListCell *lc; foreach (lc, rel->pathlist) { Path **pathptr = (Path **) &lfirst(lc); *pathptr = frozen_chunk_dml_generate_path(*pathptr, chunk); } return; } } /* * We do not support MERGE command with UPDATE/DELETE merge actions on * compressed hypertables, because Custom Scan (ModifyHypertable) node is * not generated in the plan for MERGE command on compressed hypertables */ if (ht != NULL && TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht)) { if (root->parse->commandType == CMD_MERGE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("The MERGE command with UPDATE/DELETE merge actions is not support on " "compressed hypertables"))); } } /* * Run preprocess query optimizations */ void tsl_preprocess_query(Query *parse, int *cursor_opts) { Assert(parse != NULL); /* Check if constification of watermark values is enabled */ if (ts_guc_enable_cagg_watermark_constify) { constify_cagg_watermark(parse); } #if PG16_GE /* Push down ORDER BY and LIMIT for realtime cagg (PG16+ only) */ if (ts_guc_enable_cagg_sort_pushdown) { cagg_sort_pushdown(parse, cursor_opts); } #endif } /* * Run plan postprocessing optimizations. */ void tsl_postprocess_plan(PlannedStmt *stmt) { if (ts_guc_enable_vectorized_aggregation) { stmt->planTree = try_insert_vector_agg_node(stmt->planTree, stmt->rtable); } #ifdef TS_DEBUG if (ts_guc_debug_require_vector_agg != DRO_Allow) { bool has_postgres_partial_agg = false; const bool has_vector_partial_agg = has_vector_agg_node(stmt->planTree, &has_postgres_partial_agg); /* * For convenience, we don't complain about queries that don't have * aggregation at all. */ if (has_postgres_partial_agg || has_vector_partial_agg) { if (has_postgres_partial_agg && ts_guc_debug_require_vector_agg == DRO_Require) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("postgres partial aggregation nodes inconsistent with " "debug_require_vector_agg GUC"))); } if (has_vector_partial_agg && ts_guc_debug_require_vector_agg == DRO_Forbid) { ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("vectorized partial aggregation nodes inconsistent with " "debug_require_vector_agg GUC"))); } } } #endif } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/planner.h����������������������������������������������������������������0000664�0000000�0000000�00000001362�15100345067�0017256�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> #include <optimizer/planner.h> #include "hypertable.h" #include <planner/planner.h> void tsl_create_upper_paths_hook(PlannerInfo *, UpperRelationKind, RelOptInfo *, RelOptInfo *, TsRelType, Hypertable *, void *); void tsl_set_rel_pathlist_query(PlannerInfo *, RelOptInfo *, Index, RangeTblEntry *, Hypertable *); void tsl_set_rel_pathlist_dml(PlannerInfo *, RelOptInfo *, Index, RangeTblEntry *, Hypertable *); void tsl_preprocess_query(Query *parse, int *cursor_opts); void tsl_postprocess_plan(PlannedStmt *stmt); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/process_utility.c��������������������������������������������������������0000664�0000000�0000000�00000004317�15100345067�0021056�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/xact.h> #include <catalog/namespace.h> #include <catalog/pg_trigger.h> #include <commands/event_trigger.h> #include <commands/tablecmds.h> #include <nodes/makefuncs.h> #include <nodes/nodes.h> #include <nodes/parsenodes.h> #include <storage/lockdefs.h> #include "compression/create.h" #include "continuous_aggs/create.h" #include "guc.h" #include "hypertable_cache.h" #include "process_utility.h" #include "ts_catalog/continuous_agg.h" /* AlterTableCmds that need tsl side processing invoke this function * we only process AddColumn command right now. */ void tsl_process_altertable_cmd(Hypertable *ht, const AlterTableCmd *cmd) { switch (cmd->subtype) { case AT_AddColumn: #if PG16_LT case AT_AddColumnRecurse: #endif if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht) || TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) { ColumnDef *orig_coldef = castNode(ColumnDef, cmd->def); tsl_process_compress_table_add_column(ht, orig_coldef); } break; case AT_DropColumn: #if PG16_LT case AT_DropColumnRecurse: #endif if (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht) || TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht)) { tsl_process_compress_table_drop_column(ht, cmd->name); } break; default: break; } } void tsl_process_rename_cmd(Oid relid, Cache *hcache, const RenameStmt *stmt) { if (stmt->renameType == OBJECT_COLUMN) { Hypertable *ht = ts_hypertable_cache_get_entry(hcache, relid, CACHE_FLAG_MISSING_OK); if (!ht) { ContinuousAgg *cagg = ts_continuous_agg_find_by_relid(relid); if (cagg) { ht = ts_hypertable_cache_get_entry_by_id(hcache, cagg->data.mat_hypertable_id); Assert(ht); cagg_rename_view_columns(cagg); } } /* Continuous aggregates do not have compression right now, but we * check the status for the materialized hypertable anyway since it is * harmless. */ if (ht && (TS_HYPERTABLE_HAS_COMPRESSION_TABLE(ht) || TS_HYPERTABLE_HAS_COMPRESSION_ENABLED(ht))) { tsl_process_compress_table_rename_column(ht, stmt); } } } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/process_utility.h��������������������������������������������������������0000664�0000000�0000000�00000001065�15100345067�0021060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <commands/event_trigger.h> #include <process_utility.h> extern void tsl_process_altertable_cmd(Hypertable *ht, const AlterTableCmd *cmd); extern void tsl_process_rename_cmd(Oid relid, Cache *hcache, const RenameStmt *stmt); extern DDLResult tsl_ddl_command_start(ProcessUtilityArgs *args); extern void tsl_ddl_command_end(EventTriggerData *command); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/reorder.c����������������������������������������������������������������0000664�0000000�0000000�00000066151�15100345067�0017263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ /* * This file contains source code that was copied and/or modified from the * PostgreSQL database, which is licensed under the open-source PostgreSQL * License. Please see the NOTICE at the top level directory for a copy of * the PostgreSQL License. */ /* see postgres commit ab5e9caa4a3ec4765348a0482e88edcf3f6aab4a */ #include <postgres.h> #include <access/amapi.h> #include <access/multixact.h> #include <access/relscan.h> #include <access/rewriteheap.h> #include <access/transam.h> #include <access/xact.h> #include <access/xlog.h> #include <catalog/catalog.h> #include <catalog/dependency.h> #include <catalog/heap.h> #include <catalog/index.h> #include <catalog/namespace.h> #include <catalog/objectaccess.h> #include <catalog/pg_am.h> #include <catalog/pg_authid.h> #include <catalog/pg_tablespace_d.h> #include <catalog/toasting.h> #include <commands/cluster.h> #include <commands/tablecmds.h> #include <commands/tablespace.h> #include <commands/vacuum.h> #include <executor/spi.h> #include <miscadmin.h> #include <nodes/pg_list.h> #include <optimizer/planner.h> #include <storage/bufmgr.h> #include <storage/lmgr.h> #include <storage/lockdefs.h> #include <storage/predicate.h> #include <storage/smgr.h> #include <tcop/tcopprot.h> #include <utils/acl.h> #include <utils/builtins.h> #include <utils/fmgroids.h> #include <utils/guc.h> #include <utils/inval.h> #include <utils/lsyscache.h> #include <utils/memutils.h> #include <utils/pg_rusage.h> #include <utils/relmapper.h> #include <utils/snapmgr.h> #include <utils/syscache.h> #include <utils/tuplesort.h> #include <access/toast_internals.h> #include "chunk.h" #include "chunk_index.h" #include "hypertable_cache.h" #include "import/heapswap.h" #include "indexing.h" #include "reorder.h" static void reorder_rel(Oid tableOid, Oid indexOid, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace); #define REORDER_ACCESS_EXCLUSIVE_DEADLOCK_TIMEOUT "101000" static void rebuild_relation(Relation OldHeap, Oid indexOid, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace); static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, bool verbose, bool *pSwapToastByContent, TransactionId *pFreezeXid, MultiXactId *pCutoffMulti); static Oid chunk_get_reorder_index(Hypertable *ht, Chunk *chunk, Oid index_relid); Datum tsl_reorder_chunk(PG_FUNCTION_ARGS) { Oid chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Oid index_id = PG_ARGISNULL(1) ? InvalidOid : PG_GETARG_OID(1); bool verbose = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2); /* used for debugging purposes only see finish_heap_swaps */ Oid wait_id = PG_NARGS() < 4 || PG_ARGISNULL(3) ? InvalidOid : PG_GETARG_OID(3); /* * Allow reorder in transactions for testing purposes only */ if (!OidIsValid(wait_id)) PreventInTransactionBlock(true, "reorder"); reorder_chunk(chunk_id, index_id, verbose, wait_id, InvalidOid, InvalidOid); PG_RETURN_VOID(); } Datum tsl_move_chunk(PG_FUNCTION_ARGS) { Oid chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Oid destination_tablespace = PG_ARGISNULL(1) ? InvalidOid : get_tablespace_oid(PG_GETARG_NAME(1)->data, false); Oid index_destination_tablespace = PG_ARGISNULL(2) ? InvalidOid : get_tablespace_oid(PG_GETARG_NAME(2)->data, false); Oid index_id = PG_ARGISNULL(3) ? InvalidOid : PG_GETARG_OID(3); bool verbose = PG_ARGISNULL(4) ? false : PG_GETARG_BOOL(4); Chunk *chunk; /* used for debugging purposes only see finish_heap_swaps */ Oid wait_id = PG_NARGS() < 6 || PG_ARGISNULL(5) ? InvalidOid : PG_GETARG_OID(5); /* * Allow move in transactions for testing purposes only */ if (!OidIsValid(wait_id)) PreventInTransactionBlock(true, "move"); /* * Index_destination_tablespace is currently a required parameter in order * to avoid situations where there is ambiguity about where indexes should * be placed based on where the index was created and the new tablespace * (and avoid interactions with multi-tablespace hypertable functionality). * Eventually we may want to offer an option to keep indexes in the * tablespace of their parent if it is specified. */ if (!OidIsValid(chunk_id) || !OidIsValid(destination_tablespace) || !OidIsValid(index_destination_tablespace)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("valid chunk, destination_tablespace, and index_destination_tablespaces " "are required"))); chunk = ts_chunk_get_by_relid(chunk_id, false); if (NULL == chunk) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("\"%s\" is not a chunk", get_rel_name(chunk_id)))); if (ts_chunk_contains_compressed_data(chunk)) { Chunk *chunk_parent = ts_chunk_get_compressed_chunk_parent(chunk); ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot directly move internal columnstore data"), errdetail("Chunk \"%s\" contains columnstore data for chunk \"%s\" and cannot be " "moved directly.", get_rel_name(chunk_id), get_rel_name(chunk_parent->table_id)), errhint("Moving chunk \"%s\" will also move the columnstore data.", get_rel_name(chunk_parent->table_id)))); } /* If chunk is compressed move it by altering tablespace on both chunks */ if (OidIsValid(chunk->fd.compressed_chunk_id)) { Chunk *compressed_chunk = ts_chunk_get_by_id(chunk->fd.compressed_chunk_id, true); AlterTableCmd cmd = { .type = T_AlterTableCmd, .subtype = AT_SetTableSpace, .name = get_tablespace_name(destination_tablespace) }; if (OidIsValid(index_id)) ereport(NOTICE, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("ignoring index parameter"), errdetail("Chunk will not be reordered as it has columnstore data."))); ts_alter_table_with_event_trigger(chunk_id, fcinfo->context, list_make1(&cmd), false); ts_alter_table_with_event_trigger(compressed_chunk->table_id, fcinfo->context, list_make1(&cmd), false); /* move indexes on original and compressed chunk */ ts_chunk_index_move_all(chunk_id, index_destination_tablespace); ts_chunk_index_move_all(compressed_chunk->table_id, index_destination_tablespace); } else { reorder_chunk(chunk_id, index_id, verbose, wait_id, destination_tablespace, index_destination_tablespace); } PG_RETURN_VOID(); } void reorder_chunk(Oid chunk_id, Oid index_id, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace) { Chunk *chunk; Cache *hcache; Hypertable *ht; if (!OidIsValid(chunk_id)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("must provide a valid chunk to cluster"))); chunk = ts_chunk_get_by_relid(chunk_id, false); if (NULL == chunk) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("\"%s\" is not a chunk", get_rel_name(chunk_id)))); ht = ts_hypertable_cache_get_cache_and_entry(chunk->hypertable_relid, CACHE_FLAG_NONE, &hcache); /* Our check gives better error messages, but keep the original one too. */ ts_hypertable_permissions_check(ht->main_table_relid, GetUserId()); if (!object_ownercheck(RelationRelationId, ht->main_table_relid, GetUserId())) { Oid main_table_relid = ht->main_table_relid; ts_cache_release(&hcache); aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TABLE, get_rel_name(main_table_relid)); } Oid index_relid = chunk_get_reorder_index(ht, chunk, index_id); if (!OidIsValid(index_relid)) { ts_cache_release(&hcache); if (OidIsValid(index_id)) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("\"%s\" is not a valid clustering index for table \"%s\"", get_rel_name(index_id), get_rel_name(chunk_id)))); else ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("there is no previously clustered index for table \"%s\"", get_rel_name(chunk_id)))); } if (OidIsValid(destination_tablespace) && destination_tablespace != MyDatabaseTableSpace) { AclResult aclresult; aclresult = object_aclcheck(TableSpaceRelationId, destination_tablespace, GetUserId(), ACL_CREATE); if (aclresult != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for tablespace \"%s\"", get_tablespace_name(destination_tablespace)))); ; } if (OidIsValid(index_tablespace) && index_tablespace != MyDatabaseTableSpace) { AclResult aclresult; aclresult = object_aclcheck(TableSpaceRelationId, index_tablespace, GetUserId(), ACL_CREATE); if (aclresult != ACLCHECK_OK) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), errmsg("permission denied for tablespace \"%s\"", get_tablespace_name(index_tablespace)))); } /* * We must mark each chunk index as clustered before calling reorder_rel() * because it expects indexes that need to be rechecked (due to new * transaction) to already have that mark set */ ts_chunk_index_mark_clustered(chunk->table_id, index_relid); reorder_rel(chunk->table_id, index_relid, verbose, wait_id, destination_tablespace, index_tablespace); ts_cache_release(&hcache); } static bool index_belongs_to_relation(Oid relid, Oid index_oid) { HeapTuple tuple; Form_pg_index rd_index; bool result; tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(index_oid)); if (!HeapTupleIsValid(tuple)) return false; rd_index = (Form_pg_index) GETSTRUCT(tuple); result = rd_index->indrelid == relid; ReleaseSysCache(tuple); return result; } /* * Find the index to reorder a chunk on based on a possibly NULL indexname * returns InvalidOid if no such index is found */ static Oid chunk_get_reorder_index(Hypertable *ht, Chunk *chunk, Oid index_relid) { /* * Index search order: 1. Explicitly named index 2. Chunk cluster index 3. * - index belongs to the chunk * - index belongs to the hypertable * - any clustered index on the chunk * - any clustered index on the hypertable */ if (OidIsValid(index_relid)) { if (index_belongs_to_relation(chunk->table_id, index_relid)) return index_relid; if (index_belongs_to_relation(ht->main_table_relid, index_relid)) { Relation chunk_rel = table_open(chunk->table_id, AccessShareLock); Oid chunk_index_oid = ts_chunk_index_get_by_hypertable_indexrelid(chunk_rel, index_relid); table_close(chunk_rel, NoLock); return chunk_index_oid; } return InvalidOid; } index_relid = ts_indexing_find_clustered_index(chunk->table_id); if (OidIsValid(index_relid)) return index_relid; index_relid = ts_indexing_find_clustered_index(ht->main_table_relid); if (OidIsValid(index_relid)) { Relation chunk_rel = table_open(chunk->table_id, AccessShareLock); Oid chunk_index_oid = ts_chunk_index_get_by_hypertable_indexrelid(chunk_rel, index_relid); table_close(chunk_rel, NoLock); return chunk_index_oid; } return InvalidOid; } /* The following functions are based on their equivalents in postgres's cluster.c */ /* * reorder_rel * * This clusters the table by creating a new, clustered table and * swapping the relfilenodes of the new table and the old table, so * the OID of the original table is preserved. * * Indexes are rebuilt in the same manner. */ static void reorder_rel(Oid tableOid, Oid indexOid, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace) { Relation OldHeap; HeapTuple tuple; Form_pg_index indexForm; if (!OidIsValid(indexOid)) elog(ERROR, "Reorder must specify an index."); /* Check for user-requested abort. */ CHECK_FOR_INTERRUPTS(); /* * We grab exclusive access to the target rel and index for the duration * of the transaction. (This is redundant for the single-transaction * case, since cluster() already did it.) The index lock is taken inside * check_index_is_clusterable. */ OldHeap = try_relation_open(tableOid, ExclusiveLock); /* If the table has gone away, we can skip processing it */ if (!OldHeap) { ereport(WARNING, (errcode(ERRCODE_WARNING), errmsg("table disappeared during reorder"))); return; } /* * Since we may open a new transaction for each relation, we have to check * that the relation still is what we think it is. */ /* Check that the user still owns the relation */ if (!object_ownercheck(RelationRelationId, tableOid, GetUserId())) { relation_close(OldHeap, ExclusiveLock); ereport(WARNING, (errcode(ERRCODE_WARNING), errmsg("ownership changed during reorder"))); return; } if (IsSystemRelation(OldHeap)) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot reorder a system relation"))); if (OldHeap->rd_rel->relpersistence != RELPERSISTENCE_PERMANENT) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("can only reorder a permanent table"))); /* We do not allow reordering on shared catalogs. */ if (OldHeap->rd_rel->relisshared) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot reorder a shared catalog"))); if (OldHeap->rd_rel->relkind != RELKIND_RELATION) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("can only reorder a relation"))); /* * Check that the index still exists */ if (!SearchSysCacheExists1(RELOID, ObjectIdGetDatum(indexOid))) { ereport(WARNING, (errcode(ERRCODE_WARNING), errmsg("index disappeared during reorder"))); relation_close(OldHeap, ExclusiveLock); return; } /* * Check that the index is still the one with indisclustered set. */ tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexOid)); if (!HeapTupleIsValid(tuple)) /* probably can't happen */ { ereport(WARNING, (errcode(ERRCODE_WARNING), errmsg("invalid index heap during reorder"))); relation_close(OldHeap, ExclusiveLock); return; } indexForm = (Form_pg_index) GETSTRUCT(tuple); /* * We always mark indexes as clustered when we intercept a cluster * command, if it's not marked as such here, something has gone wrong */ if (!indexForm->indisclustered) ereport(ERROR, (errcode(ERRCODE_ASSERT_FAILURE), errmsg("invalid index heap during reorder"))); ReleaseSysCache(tuple); /* * Also check for active uses of the relation in the current transaction, * including open scans and pending AFTER trigger events. */ CheckTableNotInUse(OldHeap, "CLUSTER"); /* Check heap and index are valid to cluster on */ check_index_is_clusterable(OldHeap, indexOid, ExclusiveLock); /* rebuild_relation does all the dirty work */ rebuild_relation(OldHeap, indexOid, verbose, wait_id, destination_tablespace, index_tablespace); /* NB: rebuild_relation does table_close() on OldHeap */ } static void reorder_finish_heap_swaps(Oid OIDOldHeap, Oid OIDNewHeap, char relpersistence, List *old_index_oids, List *new_index_oids, bool swap_toast_by_content, bool is_internal, TransactionId frozenXid, MultiXactId cutoffMulti, Oid wait_id) { ListCell *old_index_cell; ListCell *new_index_cell; Oid mapped_tables[4]; int config_change; #ifdef DEBUG /* * For debug purposes we serialize against wait_id if it exists, this * allows us to "pause" reorder immediately before swapping in the new * table */ if (OidIsValid(wait_id)) { Relation waiter = table_open(wait_id, AccessExclusiveLock); table_close(waiter, AccessExclusiveLock); } #endif /* * There's a risk of deadlock if some other process is also trying to * upgrade their lock in the same manner as us, at this time. Since our * transaction has performed a large amount of work, and only needs to be * run once per chunk, we do not want to abort it due to this deadlock. To * prevent abort we set our `deadlock_timeout` to a large value in the * expectation that the other process will timeout and abort first. * Currently we set `deadlock_timeout` to 1 hour, as this should be longer * than any other normal process, while still allowing the system to make * progress in the event of a real deadlock. As this is the last lock we * grab, and the setting is local to our transaction we do not bother * changing the guc back. */ config_change = set_config_option("deadlock_timeout", REORDER_ACCESS_EXCLUSIVE_DEADLOCK_TIMEOUT, PGC_SUSET, PGC_S_SESSION, GUC_ACTION_LOCAL, true, 0, false); if (config_change == 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("deadlock_timeout guc does not exist."))); else if (config_change < 0) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("could not set deadlock_timeout guc."))); /* Upgrade to an AccessExclusiveLock for the heap swap */ LockRelationOid(OIDOldHeap, AccessExclusiveLock); /* Swap the contents of the indexes */ Assert(list_length(old_index_oids) == list_length(new_index_oids)); forboth (old_index_cell, old_index_oids, new_index_cell, new_index_oids) { Oid old_index_oid = lfirst_oid(old_index_cell); Oid new_index_oid = lfirst_oid(new_index_cell); ts_swap_relation_files(old_index_oid, new_index_oid, false, swap_toast_by_content, true, frozenXid, cutoffMulti, mapped_tables); } /* Old indexes must be visible for deletion */ CommandCounterIncrement(); /* * Swap the physical files of the target and transient tables, then * rebuild the target's indexes and throw away the transient table. */ ts_finish_heap_swap(OIDOldHeap, OIDNewHeap, false, swap_toast_by_content, true, true, true, frozenXid, cutoffMulti, relpersistence); } /* * rebuild_relation: rebuild an existing relation in index or physical order * * OldHeap: table to rebuild --- must be opened and exclusive-locked! * indexOid: index to cluster by, or InvalidOid to rewrite in physical order. * * NB: this routine closes OldHeap at the right time; caller should not. */ static void rebuild_relation(Relation OldHeap, Oid indexOid, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace) { Oid tableOid = RelationGetRelid(OldHeap); Oid tableSpace = OidIsValid(destination_tablespace) ? destination_tablespace : OldHeap->rd_rel->reltablespace; Oid OIDNewHeap; List *old_index_oids; List *new_index_oids; char relpersistence; bool swap_toast_by_content; TransactionId frozenXid; MultiXactId cutoffMulti; /* Mark the correct index as clustered */ mark_index_clustered(OldHeap, indexOid, true); /* Remember info about rel before closing OldHeap */ relpersistence = OldHeap->rd_rel->relpersistence; /* Close relcache entry, but keep lock until transaction commit */ table_close(OldHeap, NoLock); /* Create the transient table that will receive the re-ordered data */ OIDNewHeap = make_new_heap(tableOid, tableSpace, OldHeap->rd_rel->relam, relpersistence, ExclusiveLock); /* Copy the heap data into the new table in the desired order */ copy_heap_data(OIDNewHeap, tableOid, indexOid, verbose, &swap_toast_by_content, &frozenXid, &cutoffMulti); /* Create versions of the tables indexes for the new table */ new_index_oids = ts_chunk_index_duplicate(tableOid, OIDNewHeap, &old_index_oids, index_tablespace); reorder_finish_heap_swaps(tableOid, OIDNewHeap, relpersistence, old_index_oids, new_index_oids, swap_toast_by_content, true, frozenXid, cutoffMulti, wait_id); } /* * Do the physical copying of heap data. * * There are three output parameters: * *pSwapToastByContent is set true if toast tables must be swapped by content. * *pFreezeXid receives the TransactionId used as freeze cutoff point. * *pCutoffMulti receives the MultiXactId used as a cutoff point. */ static void copy_heap_data(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex, bool verbose, bool *pSwapToastByContent, TransactionId *pFreezeXid, MultiXactId *pCutoffMulti) { Relation NewHeap, OldHeap, OldIndex; Relation relRelation; HeapTuple reltup; Form_pg_class relform; TupleDesc PG_USED_FOR_ASSERTS_ONLY oldTupDesc; TupleDesc newTupDesc; int natts; Datum *values; bool *isnull; bool use_sort; double num_tuples = 0, tups_vacuumed = 0, tups_recently_dead = 0; BlockNumber num_pages; int elevel = verbose ? INFO : DEBUG2; PGRUsage ru0; pg_rusage_init(&ru0); /* * Open the relations we need. */ NewHeap = table_open(OIDNewHeap, AccessExclusiveLock); OldHeap = table_open(OIDOldHeap, ExclusiveLock); if (OidIsValid(OIDOldIndex)) OldIndex = index_open(OIDOldIndex, ExclusiveLock); else OldIndex = NULL; /* * Their tuple descriptors should be exactly alike, but here we only need * assume that they have the same number of columns. */ oldTupDesc = RelationGetDescr(OldHeap); newTupDesc = RelationGetDescr(NewHeap); Assert(newTupDesc->natts == oldTupDesc->natts); /* Preallocate values/isnull arrays */ natts = newTupDesc->natts; values = (Datum *) palloc(natts * sizeof(Datum)); isnull = (bool *) palloc(natts * sizeof(bool)); /* * If the OldHeap has a toast table, get lock on the toast table to keep * it from being vacuumed. This is needed because autovacuum processes * toast tables independently of their main tables, with no lock on the * latter. If an autovacuum were to start on the toast table after we * compute our OldestXmin below, it would use a later OldestXmin, and then * possibly remove as DEAD toast tuples belonging to main tuples we think * are only RECENTLY_DEAD. Then we'd fail while trying to copy those * tuples. * * We don't need to open the toast relation here, just lock it. The lock * will be held till end of transaction. */ if (OldHeap->rd_rel->reltoastrelid) LockRelationOid(OldHeap->rd_rel->reltoastrelid, ExclusiveLock); /* use_wal off requires smgr_targblock be initially invalid */ Assert(RelationGetTargetBlock(NewHeap) == InvalidBlockNumber); /* * If both tables have TOAST tables, perform toast swap by content. It is * possible that the old table has a toast table but the new one doesn't, * if toastable columns have been dropped. In that case we have to do * swap by links. This is okay because swap by content is only essential * for system catalogs, and we don't support schema changes for them. */ if (OldHeap->rd_rel->reltoastrelid && NewHeap->rd_rel->reltoastrelid) { *pSwapToastByContent = true; /* * When doing swap by content, any toast pointers written into NewHeap * must use the old toast table's OID, because that's where the toast * data will eventually be found. Set this up by setting rd_toastoid. * This also tells toast_save_datum() to preserve the toast value * OIDs, which we want so as not to invalidate toast pointers in * system catalog caches, and to avoid making multiple copies of a * single toast value. * * Note that we must hold NewHeap open until we are done writing data, * since the relcache will not guarantee to remember this setting once * the relation is closed. Also, this technique depends on the fact * that no one will try to read from the NewHeap until after we've * finished writing it and swapping the rels --- otherwise they could * follow the toast pointers to the wrong place. (It would actually * work for values copied over from the old toast table, but not for * any values that we toast which were previously not toasted.) */ NewHeap->rd_toastoid = OldHeap->rd_rel->reltoastrelid; } else *pSwapToastByContent = false; /* * Compute xids used to freeze and weed out dead tuples and multixacts. * Since we're going to rewrite the whole table anyway, there's no reason * not to be aggressive about this. */ struct VacuumCutoffs cutoffs; VacuumParams params; memset(¶ms, 0, sizeof(VacuumParams)); vacuum_get_cutoffs(OldHeap, ¶ms, &cutoffs); /* * FreezeXid will become the table's new relfrozenxid, and that mustn't go * backwards, so take the max. */ { TransactionId relfrozenxid = OldHeap->rd_rel->relfrozenxid; if (TransactionIdIsValid(relfrozenxid) && TransactionIdPrecedes(cutoffs.FreezeLimit, relfrozenxid)) cutoffs.FreezeLimit = relfrozenxid; } /* * MultiXactCutoff, similarly, shouldn't go backwards either. */ { MultiXactId relminmxid = OldHeap->rd_rel->relminmxid; if (MultiXactIdIsValid(relminmxid) && MultiXactIdPrecedes(cutoffs.MultiXactCutoff, relminmxid)) cutoffs.MultiXactCutoff = relminmxid; } /* return selected values to caller */ *pFreezeXid = cutoffs.FreezeLimit; *pCutoffMulti = cutoffs.MultiXactCutoff; /* * We know how to use a sort to duplicate the ordering of a btree index, * and will use seqscan-and-sort for that. Otherwise, always use an * indexscan for other indexes or plain seqscan if no index is supplied. */ if (OldIndex != NULL && OldIndex->rd_rel->relam == BTREE_AM_OID) use_sort = true; else use_sort = false; /* Log what we're doing */ if (OldIndex != NULL && !use_sort) ereport(elevel, (errmsg("reordering \"%s.%s\" using index scan on \"%s\"", get_namespace_name(RelationGetNamespace(OldHeap)), RelationGetRelationName(OldHeap), RelationGetRelationName(OldIndex)))); else if (use_sort) ereport(elevel, (errmsg("reordering \"%s.%s\" using sequential scan and sort", get_namespace_name(RelationGetNamespace(OldHeap)), RelationGetRelationName(OldHeap)))); else ereport(ERROR, (errmsg("tried to use a reorder without an index \"%s.%s\"", get_namespace_name(RelationGetNamespace(OldHeap)), RelationGetRelationName(OldHeap)))); table_relation_copy_for_cluster(OldHeap, NewHeap, OldIndex, use_sort, cutoffs.OldestXmin, &cutoffs.FreezeLimit, &cutoffs.MultiXactCutoff, &num_tuples, &tups_vacuumed, &tups_recently_dead); /* Reset rd_toastoid just to be tidy --- it shouldn't be looked at again */ NewHeap->rd_toastoid = InvalidOid; num_pages = RelationGetNumberOfBlocks(NewHeap); /* Log what we did */ ereport(elevel, (errmsg("\"%s\": found %.0f removable, %.0f nonremovable row versions in %u pages", RelationGetRelationName(OldHeap), tups_vacuumed, num_tuples, RelationGetNumberOfBlocks(OldHeap)), errdetail("%.0f dead row versions cannot be removed yet.\n" "%s.", tups_recently_dead, pg_rusage_show(&ru0)))); /* Clean up */ pfree(values); pfree(isnull); if (OldIndex != NULL) index_close(OldIndex, NoLock); table_close(OldHeap, NoLock); table_close(NewHeap, NoLock); /* Update pg_class to reflect the correct values of pages and tuples. */ relRelation = table_open(RelationRelationId, RowExclusiveLock); reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(OIDNewHeap)); if (!HeapTupleIsValid(reltup)) elog(ERROR, "cache lookup failed for relation %u", OIDNewHeap); relform = (Form_pg_class) GETSTRUCT(reltup); relform->relpages = num_pages; relform->reltuples = num_tuples; /* Don't update the stats for pg_class. See swap_relation_files. */ Assert(OIDOldHeap != RelationRelationId); CacheInvalidateRelcacheByTuple(reltup); /* Clean up. */ heap_freetuple(reltup); table_close(relRelation, RowExclusiveLock); /* Make the update visible */ CommandCounterIncrement(); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/src/reorder.h����������������������������������������������������������������0000664�0000000�0000000�00000000721�15100345067�0017257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include <postgres.h> extern Datum tsl_reorder_chunk(PG_FUNCTION_ARGS); extern Datum tsl_move_chunk(PG_FUNCTION_ARGS); extern void reorder_chunk(Oid chunk_id, Oid index_id, bool verbose, Oid wait_id, Oid destination_tablespace, Oid index_tablespace); �����������������������������������������������timescaledb-2.23.0/tsl/test/������������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0015634�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/.gitignore��������������������������������������������������������������0000664�0000000�0000000�00000000104�15100345067�0017617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������results/ dump/ regression.diffs regression.out unit/testoutputs.tmp ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/CMakeLists.txt����������������������������������������������������������0000664�0000000�0000000�00000012251�15100345067�0020375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������include("${PRIMARY_TEST_DIR}/test-defs.cmake") set(_local_install_checks) set(_install_checks) # No checks for REGRESS_CHECKS needed here since all the checks are done in the # parent CMakeLists.txt. if(PG_REGRESS) # This custom target executes one command for each test configuration. It # might be possible to automatically generate this custom target, but for now # the configurations are hard-coded. add_custom_target( regresscheck-t COMMAND ${CMAKE_COMMAND} -E env ${PG_REGRESS_ENV} EXE_DIR=${CMAKE_CURRENT_SOURCE_DIR} TEST_SCHEDULE=${TEST_SCHEDULE} TEST_PGPORT=${TEST_PGPORT_TEMP_INSTANCE} ${PRIMARY_TEST_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_OPTS_EXTRA} ${PG_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_TEMP_INSTANCE} --temp-config=${TEST_OUTPUT_DIR}/postgresql.conf USES_TERMINAL) add_custom_target( regresscheck-t-rerun COMMAND ${PRIMARY_TEST_DIR}/ci_rerun.sh regresscheck-t USES_TERMINAL) add_custom_target( regresschecklocal-t COMMAND ${CMAKE_COMMAND} -E env ${PG_REGRESS_ENV} EXE_DIR=${CMAKE_CURRENT_SOURCE_DIR} TEST_PGPORT=${TEST_PGPORT_LOCAL} TEST_SCHEDULE=${TEST_SCHEDULE} ${PRIMARY_TEST_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_OPTS_EXTRA} ${PG_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_LOCAL_INSTANCE} USES_TERMINAL) list(APPEND _local_install_checks regresschecklocal-t) list(APPEND _install_checks regresscheck-t) add_custom_target( regresscheck-shared COMMAND ${CMAKE_COMMAND} -E env ${PG_REGRESS_ENV} EXE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/shared TEST_SCHEDULE=${TEST_SCHEDULE_SHARED} TEST_PGPORT=${TEST_PGPORT_TEMP_INSTANCE} ${PRIMARY_TEST_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_SHARED_OPTS_EXTRA} ${PG_REGRESS_SHARED_OPTS_INOUT} ${PG_REGRESS_OPTS_TEMP_INSTANCE} --temp-config=${TEST_OUTPUT_DIR}/postgresql.conf USES_TERMINAL) add_custom_target( regresscheck-shared-rerun COMMAND ${PRIMARY_TEST_DIR}/ci_rerun.sh regresscheck-shared USES_TERMINAL) add_custom_target( regresschecklocal-shared COMMAND ${CMAKE_COMMAND} -E env ${PG_REGRESS_ENV} EXE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/shared TEST_SCHEDULE=${TEST_SCHEDULE_SHARED} TEST_PGPORT=${TEST_PGPORT_LOCAL} ${PRIMARY_TEST_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_REGRESS_SHARED_OPTS_EXTRA} ${PG_REGRESS_SHARED_OPTS_INOUT} ${PG_REGRESS_OPTS_LOCAL_INSTANCE} USES_TERMINAL) list(APPEND _install_checks regresscheck-shared) list(APPEND _local_install_checks regresschecklocal-shared) elseif(REQUIRE_ALL_TESTS) message( FATAL_ERROR "All tests were required but 'pg_regress' could not be found") endif() if(TAP_CHECKS) add_custom_target( provecheck-t COMMAND rm -rf ${CMAKE_CURRENT_BINARY_DIR}/tmp_check COMMAND CONFDIR=${CMAKE_BINARY_DIR}/tsl/test PATH="${PG_BINDIR}:$ENV{PATH}" PG_REGRESS=${PG_REGRESS} SRC_DIR=${PG_SOURCE_DIR} CM_SRC_DIR=${CMAKE_SOURCE_DIR} PG_LIBDIR=${PG_LIBDIR} PG_VERSION_MAJOR=${PG_VERSION_MAJOR} ${PRIMARY_TEST_DIR}/pg_prove.sh USES_TERMINAL) list(APPEND _install_checks provecheck-t) elseif(REQUIRE_ALL_TESTS) message( FATAL_ERROR "All tests were required but TAP_CHECKS was off (see previous messages why)" ) endif() if(PG_ISOLATION_REGRESS) add_custom_target( isolationcheck-t COMMAND ${CMAKE_COMMAND} -E env ${PG_ISOLATION_REGRESS_ENV} EXE_DIR=${CMAKE_CURRENT_SOURCE_DIR} SPECS_DIR=${CMAKE_CURRENT_BINARY_DIR}/isolation/specs TEST_PGPORT=${TEST_PGPORT_TEMP_INSTANCE} ${PRIMARY_TEST_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_ISOLATION_REGRESS_OPTS_EXTRA} ${PG_ISOLATION_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_TEMP_INSTANCE} --temp-config=${TEST_OUTPUT_DIR}/postgresql.conf USES_TERMINAL) add_custom_target( isolationcheck-t-rerun COMMAND ${PRIMARY_TEST_DIR}/ci_rerun.sh isolationcheck-t USES_TERMINAL) add_custom_target( isolationchecklocal-t COMMAND ${CMAKE_COMMAND} -E env ${PG_ISOLATION_REGRESS_ENV} EXE_DIR=${CMAKE_CURRENT_SOURCE_DIR} SPECS_DIR=${CMAKE_CURRENT_BINARY_DIR}/isolation/specs TEST_PGPORT=${TEST_PGPORT_LOCAL} ${PRIMARY_TEST_DIR}/pg_regress.sh ${PG_REGRESS_OPTS_BASE} ${PG_ISOLATION_REGRESS_OPTS_EXTRA} ${PG_ISOLATION_REGRESS_OPTS_INOUT} ${PG_REGRESS_OPTS_LOCAL_INSTANCE} USES_TERMINAL) list(APPEND _local_install_checks isolationchecklocal-t) list(APPEND _install_checks isolationcheck-t) elseif(REQUIRE_ALL_TESTS) message( FATAL_ERROR "All tests were required but 'pg_isolation_regress' could not be found") endif() add_subdirectory(shared) add_subdirectory(sql) add_subdirectory(isolation) add_subdirectory(t) # installchecklocal tests against an existing postgres instance if(_local_install_checks) add_custom_target(installchecklocal-t DEPENDS ${_local_install_checks}) add_dependencies(installchecklocal installchecklocal-t) endif() if(_install_checks) add_custom_target(installcheck-t DEPENDS ${_install_checks}) add_dependencies(installcheck installcheck-t) endif() if(CMAKE_BUILD_TYPE MATCHES Debug OR COMPRESSION_FUZZING) add_subdirectory(src) endif() �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/���������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017435�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/agg_partials_pushdown.out��������������������������������������0000664�0000000�0000000�00000131257�15100345067�0024563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, verbose, buffers off, costs off, timing off, summary off)' -- Make parallel plans predictable SET max_parallel_workers_per_gather = 1; SET parallel_leader_participation = off; CREATE TABLE testtable(filter_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('testtable', 'time'); create_hypertable ------------------------ (1,public,testtable,t) ALTER TABLE testtable SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); INSERT INTO testtable(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-10 23:55:00+0','1day') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(c) FROM show_chunks('testtable') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk ANALYZE testtable; -- Pushdown aggregation to the chunk level SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; count | sum | sum | sum | sum -------+-----+-----+-----+----- 50 | 200 | 250 | 175 | :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*), sum(testtable.v0), sum(testtable.v1), sum(testtable.v2), sum(testtable.v3) -> Append (actual rows=2.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_1_chunk.v0)), (PARTIAL sum(_hyper_1_1_chunk.v1)), (PARTIAL sum(_hyper_1_1_chunk.v2)), (PARTIAL sum(_hyper_1_1_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: ((_hyper_1_1_chunk."time" >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.device_id, compress_hyper_2_3_chunk.filter_1, compress_hyper_2_3_chunk.filler_2, compress_hyper_2_3_chunk.filler_3, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk."time", compress_hyper_2_3_chunk.v0, compress_hyper_2_3_chunk.v1, compress_hyper_2_3_chunk.v2, compress_hyper_2_3_chunk.v3 Filter: ((compress_hyper_2_3_chunk._ts_meta_max_1 >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_2_3_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_2_chunk.v0)), (PARTIAL sum(_hyper_1_2_chunk.v1)), (PARTIAL sum(_hyper_1_2_chunk.v2)), (PARTIAL sum(_hyper_1_2_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Vectorized Filter: ((_hyper_1_2_chunk."time" >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.device_id, compress_hyper_2_4_chunk.filter_1, compress_hyper_2_4_chunk.filler_2, compress_hyper_2_4_chunk.filler_3, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk."time", compress_hyper_2_4_chunk.v0, compress_hyper_2_4_chunk.v1, compress_hyper_2_4_chunk.v2, compress_hyper_2_4_chunk.v3 Filter: ((compress_hyper_2_4_chunk._ts_meta_max_1 >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_2_4_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) -- Create partially compressed chunk INSERT INTO testtable(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-10 23:55:00+0','1day') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE testtable; -- Pushdown aggregation to the chunk level SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; count | sum | sum | sum | sum -------+-----+-----+-----+----- 100 | 400 | 500 | 350 | :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*), sum(testtable.v0), sum(testtable.v1), sum(testtable.v2), sum(testtable.v3) -> Append (actual rows=4.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_1_chunk.v0)), (PARTIAL sum(_hyper_1_1_chunk.v1)), (PARTIAL sum(_hyper_1_1_chunk.v2)), (PARTIAL sum(_hyper_1_1_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: ((_hyper_1_1_chunk."time" >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.device_id, compress_hyper_2_3_chunk.filter_1, compress_hyper_2_3_chunk.filler_2, compress_hyper_2_3_chunk.filler_3, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk."time", compress_hyper_2_3_chunk.v0, compress_hyper_2_3_chunk.v1, compress_hyper_2_3_chunk.v2, compress_hyper_2_3_chunk.v3 Filter: ((compress_hyper_2_3_chunk._ts_meta_max_1 >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_2_3_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_1_chunk.v0), PARTIAL sum(_hyper_1_1_chunk.v1), PARTIAL sum(_hyper_1_1_chunk.v2), PARTIAL sum(_hyper_1_1_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Filter: ((_hyper_1_1_chunk."time" >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_2_chunk.v0)), (PARTIAL sum(_hyper_1_2_chunk.v1)), (PARTIAL sum(_hyper_1_2_chunk.v2)), (PARTIAL sum(_hyper_1_2_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Vectorized Filter: ((_hyper_1_2_chunk."time" >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.device_id, compress_hyper_2_4_chunk.filter_1, compress_hyper_2_4_chunk.filler_2, compress_hyper_2_4_chunk.filler_3, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk."time", compress_hyper_2_4_chunk.v0, compress_hyper_2_4_chunk.v1, compress_hyper_2_4_chunk.v2, compress_hyper_2_4_chunk.v3 Filter: ((compress_hyper_2_4_chunk._ts_meta_max_1 >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_2_4_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_2_chunk.v0), PARTIAL sum(_hyper_1_2_chunk.v1), PARTIAL sum(_hyper_1_2_chunk.v2), PARTIAL sum(_hyper_1_2_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: ((_hyper_1_2_chunk."time" >= 'Fri Dec 31 16:00:00 1999 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone)) -- Same query using chunk append SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; count | sum | sum | sum | sum -------+-----+-----+-----+----- 100 | 400 | 500 | 350 | :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*), sum(testtable.v0), sum(testtable.v1), sum(testtable.v2), sum(testtable.v3) -> Custom Scan (ChunkAppend) on public.testtable (actual rows=4.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(testtable.v0)), (PARTIAL sum(testtable.v1)), (PARTIAL sum(testtable.v2)), (PARTIAL sum(testtable.v3)) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_1_chunk.v0)), (PARTIAL sum(_hyper_1_1_chunk.v1)), (PARTIAL sum(_hyper_1_1_chunk.v2)), (PARTIAL sum(_hyper_1_1_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: ((_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.device_id, compress_hyper_2_3_chunk.filter_1, compress_hyper_2_3_chunk.filler_2, compress_hyper_2_3_chunk.filler_3, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk."time", compress_hyper_2_3_chunk.v0, compress_hyper_2_3_chunk.v1, compress_hyper_2_3_chunk.v2, compress_hyper_2_3_chunk.v3 Filter: ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_1_chunk.v0), PARTIAL sum(_hyper_1_1_chunk.v1), PARTIAL sum(_hyper_1_1_chunk.v2), PARTIAL sum(_hyper_1_1_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Filter: ((_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_2_chunk.v0)), (PARTIAL sum(_hyper_1_2_chunk.v1)), (PARTIAL sum(_hyper_1_2_chunk.v2)), (PARTIAL sum(_hyper_1_2_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Vectorized Filter: ((_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.device_id, compress_hyper_2_4_chunk.filter_1, compress_hyper_2_4_chunk.filler_2, compress_hyper_2_4_chunk.filler_3, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk."time", compress_hyper_2_4_chunk.v0, compress_hyper_2_4_chunk.v1, compress_hyper_2_4_chunk.v2, compress_hyper_2_4_chunk.v3 Filter: ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_2_chunk.v0), PARTIAL sum(_hyper_1_2_chunk.v1), PARTIAL sum(_hyper_1_2_chunk.v2), PARTIAL sum(_hyper_1_2_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: ((_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -- Perform chunk append startup chunk exclusion - issue 6282 :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-09 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'::text::timestamptz; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*), sum(testtable.v0), sum(testtable.v1), sum(testtable.v2), sum(testtable.v3) -> Custom Scan (ChunkAppend) on public.testtable (actual rows=2.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(testtable.v0)), (PARTIAL sum(testtable.v1)), (PARTIAL sum(testtable.v2)), (PARTIAL sum(testtable.v3)) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 2 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_2_chunk.v0)), (PARTIAL sum(_hyper_1_2_chunk.v1)), (PARTIAL sum(_hyper_1_2_chunk.v2)), (PARTIAL sum(_hyper_1_2_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=10.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Vectorized Filter: ((_hyper_1_2_chunk."time" >= ('2000-01-09 00:00:00+0'::cstring)::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= ('2000-02-01 00:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.device_id, compress_hyper_2_4_chunk.filter_1, compress_hyper_2_4_chunk.filler_2, compress_hyper_2_4_chunk.filler_3, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk."time", compress_hyper_2_4_chunk.v0, compress_hyper_2_4_chunk.v1, compress_hyper_2_4_chunk.v2, compress_hyper_2_4_chunk.v3 Filter: ((compress_hyper_2_4_chunk._ts_meta_max_1 >= ('2000-01-09 00:00:00+0'::cstring)::timestamp with time zone) AND (compress_hyper_2_4_chunk._ts_meta_min_1 <= ('2000-02-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_2_chunk.v0), PARTIAL sum(_hyper_1_2_chunk.v1), PARTIAL sum(_hyper_1_2_chunk.v2), PARTIAL sum(_hyper_1_2_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=10.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: ((_hyper_1_2_chunk."time" >= ('2000-01-09 00:00:00+0'::cstring)::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= ('2000-02-01 00:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 -- Force plain / sorted aggregation SET enable_hashagg = OFF; SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; count | sum | sum | sum | sum -------+-----+-----+-----+----- 100 | 400 | 500 | 350 | :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*), sum(testtable.v0), sum(testtable.v1), sum(testtable.v2), sum(testtable.v3) -> Custom Scan (ChunkAppend) on public.testtable (actual rows=4.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(testtable.v0)), (PARTIAL sum(testtable.v1)), (PARTIAL sum(testtable.v2)), (PARTIAL sum(testtable.v3)) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_1_chunk.v0)), (PARTIAL sum(_hyper_1_1_chunk.v1)), (PARTIAL sum(_hyper_1_1_chunk.v2)), (PARTIAL sum(_hyper_1_1_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: ((_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.device_id, compress_hyper_2_3_chunk.filter_1, compress_hyper_2_3_chunk.filler_2, compress_hyper_2_3_chunk.filler_3, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk."time", compress_hyper_2_3_chunk.v0, compress_hyper_2_3_chunk.v1, compress_hyper_2_3_chunk.v2, compress_hyper_2_3_chunk.v3 Filter: ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_1_chunk.v0), PARTIAL sum(_hyper_1_1_chunk.v1), PARTIAL sum(_hyper_1_1_chunk.v2), PARTIAL sum(_hyper_1_1_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk (actual rows=25.00 loops=1) Output: _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Filter: ((_hyper_1_1_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_1_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_2_chunk.v0)), (PARTIAL sum(_hyper_1_2_chunk.v1)), (PARTIAL sum(_hyper_1_2_chunk.v2)), (PARTIAL sum(_hyper_1_2_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Vectorized Filter: ((_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.device_id, compress_hyper_2_4_chunk.filter_1, compress_hyper_2_4_chunk.filler_2, compress_hyper_2_4_chunk.filler_3, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk."time", compress_hyper_2_4_chunk.v0, compress_hyper_2_4_chunk.v1, compress_hyper_2_4_chunk.v2, compress_hyper_2_4_chunk.v3 Filter: ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_2_chunk.v0), PARTIAL sum(_hyper_1_2_chunk.v1), PARTIAL sum(_hyper_1_2_chunk.v2), PARTIAL sum(_hyper_1_2_chunk.v3) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=25.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: ((_hyper_1_2_chunk."time" <= 'Mon Jan 31 16:00:00 2000 PST'::timestamp with time zone) AND (_hyper_1_2_chunk."time" >= ('2000-01-01 00:00:00+0'::cstring)::timestamp with time zone)) RESET enable_hashagg; -- Check chunk exclusion for index scans SET enable_seqscan = OFF; SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-09 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'::text::timestamptz; count | sum | sum | sum | sum -------+-----+-----+-----+----- 20 | 80 | 100 | 70 | :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-09 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'::text::timestamptz; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*), sum(testtable.v0), sum(testtable.v1), sum(testtable.v2), sum(testtable.v3) -> Custom Scan (ChunkAppend) on public.testtable (actual rows=2.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(testtable.v0)), (PARTIAL sum(testtable.v1)), (PARTIAL sum(testtable.v2)), (PARTIAL sum(testtable.v3)) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 2 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)), (PARTIAL sum(_hyper_1_2_chunk.v0)), (PARTIAL sum(_hyper_1_2_chunk.v1)), (PARTIAL sum(_hyper_1_2_chunk.v2)), (PARTIAL sum(_hyper_1_2_chunk.v3)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=10.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Vectorized Filter: ((_hyper_1_2_chunk."time" >= ('2000-01-09 00:00:00+0'::cstring)::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= ('2000-02-01 00:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 Bulk Decompression: true -> Index Scan using compress_hyper_2_4_chunk_device_id__ts_meta_min_1__ts_meta__idx on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.device_id, compress_hyper_2_4_chunk.filter_1, compress_hyper_2_4_chunk.filler_2, compress_hyper_2_4_chunk.filler_3, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk."time", compress_hyper_2_4_chunk.v0, compress_hyper_2_4_chunk.v1, compress_hyper_2_4_chunk.v2, compress_hyper_2_4_chunk.v3 Index Cond: ((compress_hyper_2_4_chunk._ts_meta_min_1 <= ('2000-02-01 00:00:00+0'::cstring)::timestamp with time zone) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= ('2000-01-09 00:00:00+0'::cstring)::timestamp with time zone)) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*), PARTIAL sum(_hyper_1_2_chunk.v0), PARTIAL sum(_hyper_1_2_chunk.v1), PARTIAL sum(_hyper_1_2_chunk.v2), PARTIAL sum(_hyper_1_2_chunk.v3) -> Index Scan using _hyper_1_2_chunk_testtable_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=10.00 loops=1) Output: _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Index Cond: ((_hyper_1_2_chunk."time" >= ('2000-01-09 00:00:00+0'::cstring)::timestamp with time zone) AND (_hyper_1_2_chunk."time" <= ('2000-02-01 00:00:00+0'::cstring)::timestamp with time zone)) RESET enable_seqscan; -- Check Append Node under ChunkAppend RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; CREATE TABLE testtable2 ( timecustom BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON testtable2 (timeCustom DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('testtable2', 'timecustom', 'device_id', number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 3 | public | testtable2 | t INSERT INTO testtable2 VALUES (1257894000000000000, 'dev1', 1.5, 1, 2, true), (1257894000000000000, 'dev1', 1.5, 2, NULL, NULL), (1257894000000001000, 'dev1', 2.5, 3, NULL, NULL), (1257894001000000000, 'dev1', 3.5, 4, NULL, NULL), (1257897600000000000, 'dev1', 4.5, 5, NULL, false), (1257894002000000000, 'dev1', 5.5, 6, NULL, true), (1257894002000000000, 'dev1', 5.5, 7, NULL, false); INSERT INTO testtable2(timeCustom, device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; t | min ---------------------+----- 1257987600000000000 | 1.5 1257897600000000000 | 4.5 :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) Output: testtable2.timecustom, (min(testtable2.series_0)) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Output: testtable2.timecustom, min(testtable2.series_0) Group Key: testtable2.timecustom -> Custom Scan (ChunkAppend) on public.testtable2 (actual rows=3.00 loops=1) Output: testtable2.timecustom, (PARTIAL min(testtable2.series_0)) Order: testtable2.timecustom DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_7_chunk.timecustom, PARTIAL min(_hyper_3_7_chunk.series_0) Group Key: _hyper_3_7_chunk.timecustom -> Index Scan using _hyper_3_7_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_7_chunk (actual rows=2.00 loops=1) Output: _hyper_3_7_chunk.timecustom, _hyper_3_7_chunk.series_0 -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_6_chunk.timecustom, PARTIAL min(_hyper_3_6_chunk.series_0) Group Key: _hyper_3_6_chunk.timecustom -> Index Scan using _hyper_3_6_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_6_chunk (actual rows=1.00 loops=1) Output: _hyper_3_6_chunk.timecustom, _hyper_3_6_chunk.series_0 -> Merge Append (actual rows=1.00 loops=1) Sort Key: testtable2.timecustom DESC NULLS LAST -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_8_chunk.timecustom, PARTIAL min(_hyper_3_8_chunk.series_0) Group Key: _hyper_3_8_chunk.timecustom -> Index Scan using _hyper_3_8_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_8_chunk (actual rows=1.00 loops=1) Output: _hyper_3_8_chunk.timecustom, _hyper_3_8_chunk.series_0 -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_5_chunk.timecustom, PARTIAL min(_hyper_3_5_chunk.series_0) Group Key: _hyper_3_5_chunk.timecustom -> Index Scan using _hyper_3_5_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_5_chunk (actual rows=4.00 loops=1) Output: _hyper_3_5_chunk.timecustom, _hyper_3_5_chunk.series_0 -- Force parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; t | min ---------------------+----- 1257987600000000000 | 1.5 1257897600000000000 | 4.5 :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --- QUERY PLAN --- Gather (actual rows=2.00 loops=1) Output: testtable2.timecustom, (min(testtable2.series_0)) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> Limit (actual rows=2.00 loops=1) Output: testtable2.timecustom, (min(testtable2.series_0)) Worker 0: actual rows=2.00 loops=1 -> Finalize GroupAggregate (actual rows=2.00 loops=1) Output: testtable2.timecustom, min(testtable2.series_0) Group Key: testtable2.timecustom Worker 0: actual rows=2.00 loops=1 -> Custom Scan (ChunkAppend) on public.testtable2 (actual rows=3.00 loops=1) Output: testtable2.timecustom, (PARTIAL min(testtable2.series_0)) Order: testtable2.timecustom DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false Worker 0: actual rows=3.00 loops=1 -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_7_chunk.timecustom, PARTIAL min(_hyper_3_7_chunk.series_0) Group Key: _hyper_3_7_chunk.timecustom Worker 0: actual rows=1.00 loops=1 -> Index Scan using _hyper_3_7_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_7_chunk (actual rows=2.00 loops=1) Output: _hyper_3_7_chunk.timecustom, _hyper_3_7_chunk.series_0 Worker 0: actual rows=2.00 loops=1 -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_6_chunk.timecustom, PARTIAL min(_hyper_3_6_chunk.series_0) Group Key: _hyper_3_6_chunk.timecustom Worker 0: actual rows=1.00 loops=1 -> Index Scan using _hyper_3_6_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_6_chunk (actual rows=1.00 loops=1) Output: _hyper_3_6_chunk.timecustom, _hyper_3_6_chunk.series_0 Worker 0: actual rows=1.00 loops=1 -> Merge Append (actual rows=1.00 loops=1) Sort Key: testtable2.timecustom DESC NULLS LAST Worker 0: actual rows=1.00 loops=1 -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_8_chunk.timecustom, PARTIAL min(_hyper_3_8_chunk.series_0) Group Key: _hyper_3_8_chunk.timecustom Worker 0: actual rows=1.00 loops=1 -> Index Scan using _hyper_3_8_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_8_chunk (actual rows=1.00 loops=1) Output: _hyper_3_8_chunk.timecustom, _hyper_3_8_chunk.series_0 Worker 0: actual rows=1.00 loops=1 -> Partial GroupAggregate (actual rows=1.00 loops=1) Output: _hyper_3_5_chunk.timecustom, PARTIAL min(_hyper_3_5_chunk.series_0) Group Key: _hyper_3_5_chunk.timecustom Worker 0: actual rows=1.00 loops=1 -> Index Scan using _hyper_3_5_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_5_chunk (actual rows=4.00 loops=1) Output: _hyper_3_5_chunk.timecustom, _hyper_3_5_chunk.series_0 Worker 0: actual rows=4.00 loops=1 -- Test that we don't process groupingSets :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY ROLLUP(t); --- QUERY PLAN --- Gather (actual rows=7.00 loops=1) Output: testtable2.timecustom, (min(testtable2.series_0)) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> MixedAggregate (actual rows=7.00 loops=1) Output: testtable2.timecustom, min(testtable2.series_0) Hash Key: testtable2.timecustom Group Key: () Worker 0: actual rows=7.00 loops=1 -> Append (actual rows=11.00 loops=1) Worker 0: actual rows=11.00 loops=1 -> Seq Scan on _timescaledb_internal._hyper_3_5_chunk (actual rows=7.00 loops=1) Output: _hyper_3_5_chunk.timecustom, _hyper_3_5_chunk.series_0 Worker 0: actual rows=7.00 loops=1 -> Seq Scan on _timescaledb_internal._hyper_3_6_chunk (actual rows=1.00 loops=1) Output: _hyper_3_6_chunk.timecustom, _hyper_3_6_chunk.series_0 Worker 0: actual rows=1.00 loops=1 -> Seq Scan on _timescaledb_internal._hyper_3_7_chunk (actual rows=2.00 loops=1) Output: _hyper_3_7_chunk.timecustom, _hyper_3_7_chunk.series_0 Worker 0: actual rows=2.00 loops=1 -> Seq Scan on _timescaledb_internal._hyper_3_8_chunk (actual rows=1.00 loops=1) Output: _hyper_3_8_chunk.timecustom, _hyper_3_8_chunk.series_0 Worker 0: actual rows=1.00 loops=1 -- Check parallel fallback into a non-partial aggregation SET timescaledb.enable_chunkwise_aggregation = OFF; SET enable_hashagg = OFF; SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; t | min ---------------------+----- 1257987600000000000 | 1.5 1257897600000000000 | 4.5 :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; --- QUERY PLAN --- Gather (actual rows=2.00 loops=1) Output: testtable2.timecustom, (min(testtable2.series_0)) Workers Planned: 1 Workers Launched: 1 Single Copy: true -> Limit (actual rows=2.00 loops=1) Output: testtable2.timecustom, (min(testtable2.series_0)) Worker 0: actual rows=2.00 loops=1 -> GroupAggregate (actual rows=2.00 loops=1) Output: testtable2.timecustom, min(testtable2.series_0) Group Key: testtable2.timecustom Worker 0: actual rows=2.00 loops=1 -> Custom Scan (ChunkAppend) on public.testtable2 (actual rows=4.00 loops=1) Output: testtable2.timecustom, testtable2.series_0 Order: testtable2.timecustom DESC NULLS LAST Startup Exclusion: false Runtime Exclusion: false Worker 0: actual rows=4.00 loops=1 -> Index Scan using _hyper_3_7_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_7_chunk (actual rows=2.00 loops=1) Output: _hyper_3_7_chunk.timecustom, _hyper_3_7_chunk.series_0 Worker 0: actual rows=2.00 loops=1 -> Index Scan using _hyper_3_6_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_6_chunk (actual rows=1.00 loops=1) Output: _hyper_3_6_chunk.timecustom, _hyper_3_6_chunk.series_0 Worker 0: actual rows=1.00 loops=1 -> Merge Append (actual rows=1.00 loops=1) Sort Key: testtable2.timecustom DESC NULLS LAST Worker 0: actual rows=1.00 loops=1 -> Index Scan using _hyper_3_8_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_8_chunk (actual rows=1.00 loops=1) Output: _hyper_3_8_chunk.timecustom, _hyper_3_8_chunk.series_0 Worker 0: actual rows=1.00 loops=1 -> Index Scan using _hyper_3_5_chunk_testtable2_timecustom_device_id_idx on _timescaledb_internal._hyper_3_5_chunk (actual rows=1.00 loops=1) Output: _hyper_3_5_chunk.timecustom, _hyper_3_5_chunk.series_0 Worker 0: actual rows=1.00 loops=1 RESET timescaledb.enable_chunkwise_aggregation; RESET enable_hashagg; -- Test aggregation pushdown with MergeAppend node CREATE TABLE merge_append_test (start_time timestamptz, sensor_id int, cluster varchar (253), cost_recommendation_memory numeric); SELECT * FROM create_hypertable('merge_append_test', 'start_time'); WARNING: column type "character varying" used for "cluster" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------+--------- 4 | public | merge_append_test | t CREATE INDEX merge_append_test_sensorid ON merge_append_test USING btree (start_time, sensor_id); INSERT INTO merge_append_test SELECT date_series, 1, 'production-1', random() * 100 FROM generate_series('2023-10-01 00:00:00', '2023-12-01 00:00:00', INTERVAL '1 hour') AS date_series ; INSERT INTO merge_append_test SELECT date_series, sensor_id, 'production-2', random() * 100 FROM generate_series('2023-10-01 00:00:00', '2023-12-01 00:00:00', INTERVAL '1 hour') AS date_series, generate_series(1, 100, 1) AS sensor_id ; ANALYZE merge_append_test; SET enable_seqscan = off; SET random_page_cost = 0; SET cpu_operator_cost = 0; SET enable_hashagg = off; RESET parallel_setup_cost; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END, 'off', false); set_config ------------ off :PREFIX SELECT start_time, sensor_id, SUM(cost_recommendation_memory) FROM merge_append_test WHERE start_time >= '2023-11-27 00:00:00Z' AND start_time <= '2023-12-01 00:00:00Z' AND sensor_id < 10 AND CLUSTER = 'production-2' GROUP BY 1, 2; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=873.00 loops=1) Output: merge_append_test.start_time, merge_append_test.sensor_id, sum(merge_append_test.cost_recommendation_memory) Group Key: merge_append_test.start_time, merge_append_test.sensor_id -> Merge Append (actual rows=873.00 loops=1) Sort Key: merge_append_test.start_time, merge_append_test.sensor_id -> Partial GroupAggregate (actual rows=648.00 loops=1) Output: _hyper_4_17_chunk.start_time, _hyper_4_17_chunk.sensor_id, PARTIAL sum(_hyper_4_17_chunk.cost_recommendation_memory) Group Key: _hyper_4_17_chunk.start_time, _hyper_4_17_chunk.sensor_id -> Index Scan using _hyper_4_17_chunk_merge_append_test_sensorid on _timescaledb_internal._hyper_4_17_chunk (actual rows=648.00 loops=1) Output: _hyper_4_17_chunk.start_time, _hyper_4_17_chunk.sensor_id, _hyper_4_17_chunk.cost_recommendation_memory Index Cond: ((_hyper_4_17_chunk.start_time >= 'Sun Nov 26 16:00:00 2023 PST'::timestamp with time zone) AND (_hyper_4_17_chunk.start_time <= 'Thu Nov 30 16:00:00 2023 PST'::timestamp with time zone) AND (_hyper_4_17_chunk.sensor_id < 10)) Filter: ((_hyper_4_17_chunk.cluster)::text = 'production-2'::text) Rows Removed by Filter: 72 -> Partial GroupAggregate (actual rows=225.00 loops=1) Output: _hyper_4_18_chunk.start_time, _hyper_4_18_chunk.sensor_id, PARTIAL sum(_hyper_4_18_chunk.cost_recommendation_memory) Group Key: _hyper_4_18_chunk.start_time, _hyper_4_18_chunk.sensor_id -> Index Scan using _hyper_4_18_chunk_merge_append_test_sensorid on _timescaledb_internal._hyper_4_18_chunk (actual rows=225.00 loops=1) Output: _hyper_4_18_chunk.start_time, _hyper_4_18_chunk.sensor_id, _hyper_4_18_chunk.cost_recommendation_memory Index Cond: ((_hyper_4_18_chunk.start_time >= 'Sun Nov 26 16:00:00 2023 PST'::timestamp with time zone) AND (_hyper_4_18_chunk.start_time <= 'Thu Nov 30 16:00:00 2023 PST'::timestamp with time zone) AND (_hyper_4_18_chunk.sensor_id < 10)) Filter: ((_hyper_4_18_chunk.cluster)::text = 'production-2'::text) Rows Removed by Filter: 25 RESET enable_seqscan; RESET random_page_cost; RESET cpu_operator_cost; RESET enable_hashagg; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/attach_chunk.out�����������������������������������������������0000664�0000000�0000000�00000036204�15100345067�0022627�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :"TEST_DBNAME" TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- Create test tables and hypertables (reusing from detach_chunk test) CREATE TABLE devices(id int PRIMARY KEY); INSERT INTO devices VALUES (1), (2), (3); CREATE TABLE attach_test(id int, time timestamptz not null, device int, temp float); CREATE INDEX attach_test_device_idx ON attach_test (device); ALTER TABLE attach_test ADD CONSTRAINT attach_test_temp_check CHECK (temp > 0), ADD CONSTRAINT attach_test_device_fkey FOREIGN KEY (device) REFERENCES devices(id), ADD CONSTRAINT attach_test_id_time_unique UNIQUE (id, time); SELECT * FROM create_hypertable('attach_test', 'time', 'id', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 1 | public | attach_test | t CREATE TABLE attach_test_ref ( id int PRIMARY KEY, ref_id int, ref_time timestamptz, FOREIGN KEY (ref_id, ref_time) REFERENCES attach_test(id, time) ); INSERT INTO attach_test VALUES (1, '2025-06-01 05:00:00+3', 1, 23.4), (2, '2025-06-15 05:00:00+3', 2, 24.5), (3, '2025-06-30 05:00:00+3', 3, 25.6); -- Get chunk information for testing SELECT chunk_id AS "CHUNK_ID", hypertable_id AS "HYPERTABLE_ID", schema_name AS "CHUNK_SCHEMA", table_name AS "CHUNK_TABLE", schema_name || '.' || table_name AS "CHUNK_NAME", slices AS "CHUNK_SLICES" FROM _timescaledb_functions.show_chunk((SELECT show_chunks('attach_test') LIMIT 1)); \gset CHUNK_ID | HYPERTABLE_ID | CHUNK_SCHEMA | CHUNK_TABLE | CHUNK_NAME | CHUNK_SLICES ----------+---------------+-----------------------+------------------+----------------------------------------+------------------------------------------------------------------------------------------ 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk | {"id": [-9223372036854775808, 1073741823], "time": [1748476800000000, 1749081600000000]} -- Successful attachment CREATE TABLE regular_table_to_attach(id int, time timestamptz not null, device int, temp float); CREATE INDEX regular_table_device_idx ON regular_table_to_attach (device); ALTER TABLE regular_table_to_attach ADD CONSTRAINT attach_test_temp_check CHECK (temp > 0), ADD CONSTRAINT pre_attach_temp_check CHECK (temp < 100), ADD CONSTRAINT pre_attach_id_time_unique UNIQUE (id, time); INSERT INTO regular_table_to_attach VALUES (10, '2025-07-05 13:00:00+3', 2, 27.8); -- Attach it as a chunk CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Verify data is accessible through the hypertable SELECT count(*) > 0 FROM attach_test WHERE time >= '2025-07-5'::timestamptz; ?column? ---------- t -- Check the chunk and related metadata are set up correctly SELECT id AS "ATTACHED_CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID' AND table_name = 'regular_table_to_attach'; \gset ATTACHED_CHUNK ---------------- 4 -- Verify that each constraint/index on a auto-created chunk is also present on the attached chunk SELECT hypertable_constraint_name FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'CHUNK_ID' EXCEPT SELECT hypertable_constraint_name FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'ATTACHED_CHUNK'; hypertable_constraint_name ---------------------------- SELECT * FROM test.show_indexesp('regular_table_to_attach'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace -------------------------+----------------------------------------------+-----------+------+--------+---------+-----------+------------ regular_table_to_attach | regular_table_device_idx | {device} | | f | f | f | regular_table_to_attach | pre_attach_id_time_unique | {id,time} | | t | f | f | regular_table_to_attach | regular_table_to_attach_attach_test_time_idx | {time} | | f | f | f | SELECT * FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.chunk_constraint cc ON ds.id = cc.dimension_slice_id WHERE cc.chunk_id = :'ATTACHED_CHUNK'; id | dimension_id | range_start | range_end | chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----+--------------+----------------------+------------------+----------+--------------------+-----------------+---------------------------- 2 | 2 | -9223372036854775808 | 1073741823 | 4 | 2 | constraint_2 | 6 | 1 | 1751335200000000 | 1751853600000000 | 4 | 6 | constraint_6 | -- Verify that the chunk is a child of the hypertable SELECT count(*) > 0 FROM pg_inherits WHERE inhrelid = 'regular_table_to_attach'::regclass::oid AND inhparent = 'attach_test'::regclass::oid; ?column? ---------- t -- Verify foreign key references work SELECT count(*) > 0 FROM pg_constraint WHERE contype = 'f' AND confrelid = 'regular_table_to_attach'::regclass::oid; ?column? ---------- t SELECT count(*) > 0 FROM pg_constraint WHERE contype = 'f' AND conrelid = 'regular_table_to_attach'::regclass::oid; ?column? ---------- t -- Verify data is routed to the correct chunk SELECT count(*) FROM attach_test WHERE time > '2025-07-01'::timestamptz; count ------- 1 INSERT INTO attach_test VALUES (5, '2025-07-4 05:00:00+3', 2, 19.5); SELECT count(*) FROM regular_table_to_attach; count ------- 2 -- Detach and re-attach a chunk CALL detach_chunk(:'CHUNK_NAME'); CALL attach_chunk('attach_test', :'CHUNK_NAME', :'CHUNK_SLICES'); -- Store the new chunk id SELECT chunk_id AS "CHUNK_ID" FROM _timescaledb_functions.show_chunk(:'CHUNK_NAME'); \gset CHUNK_ID ---------- 5 -- Verify it's re-attached SELECT count(*) > 0 FROM pg_inherits WHERE inhrelid = :'CHUNK_NAME'::regclass::oid; ?column? ---------- t -- Verify constraints and indexes are restored SELECT * FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'CHUNK_ID'; chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----------+--------------------+--------------------------------+---------------------------- 5 | | 1_2_attach_test_id_time_unique | attach_test_id_time_unique 5 | | 5_8_attach_test_device_fkey | attach_test_device_fkey 5 | 2 | constraint_2 | 5 | 7 | constraint_7 | SELECT * FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.chunk_constraint cc ON ds.id = cc.dimension_slice_id WHERE cc.chunk_id = :'CHUNK_ID'; id | dimension_id | range_start | range_end | chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----+--------------+----------------------+------------------+----------+--------------------+-----------------+---------------------------- 2 | 2 | -9223372036854775808 | 1073741823 | 5 | 2 | constraint_2 | 7 | 1 | 1748476800000000 | 1749081600000000 | 5 | 7 | constraint_7 | -- Attach a chunk to another hypertable with a different dimension CALL detach_chunk('regular_table_to_attach'); CREATE TABLE hypertable_with_different_dimension(id int, time timestamptz not null, device int, temp float); SELECT * FROM create_hypertable('hypertable_with_different_dimension', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------------------------------+--------- 2 | public | hypertable_with_different_dimension | t CALL attach_chunk('hypertable_with_different_dimension', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"]}'); CALL detach_chunk('regular_table_to_attach'); CREATE TABLE not_a_hypertable(id int, time timestamptz not null, device int, temp float); -- Error cases \set ON_ERROR_STOP 0 CALL attach_chunk('attach_test', 'nonexistent_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: relation "nonexistent_table" does not exist at character 34 CALL attach_chunk('not_a_hypertable', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: table "not_a_hypertable" is not a hypertable CALL attach_chunk('nonexistent_hypertable', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: relation "nonexistent_hypertable" does not exist at character 19 CALL attach_chunk(98765, 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: relation with OID 98765 does not exist CALL attach_chunk(0, 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: invalid hypertable relation OID -- invalid json format CALL attach_chunk('attach_test', 'regular_table_to_attach', '"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]'); ERROR: invalid input syntax for type json at character 61 -- incorrect dimension information CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025123-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: timestamp out of range: "2025123-07-01 05:00:00+3" CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "incorrect_key": [-9223372036854775808, 1073741823]}'); ERROR: invalid hypercube for hypertable "attach_test" CALL attach_chunk('attach_test', 'regular_table_to_attach', NULL); ERROR: invalid dimension slices argument CALL attach_chunk('attach_test', 'regular_table_to_attach', :'CHUNK_SLICES'); ERROR: chunk creation failed due to collision CALL attach_chunk('attach_test', :'CHUNK_NAME', :'CHUNK_SLICES'); ERROR: cannot attach chunk that is already a child of another table -- Attach a chunk of another hypertable CALL attach_chunk('hypertable_with_different_dimension', :'CHUNK_NAME', :'CHUNK_SLICES'); ERROR: cannot attach chunk that is already a child of another table -- Try to attach a table that's already a child of another table CREATE TABLE parent_table(id int); CREATE TABLE child_table(time timestamptz not null, device int, temp float) INHERITS (parent_table); CALL attach_chunk('attach_test', 'child_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: cannot attach chunk that is already a child of another table -- Try to attach a table with incompatible types CREATE TABLE incompatible_table(id int, time timestamptz not null, device text, temp float); CALL attach_chunk('attach_test', 'incompatible_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: child table "incompatible_table" has different type for column "device" -- Try to attach a table with missing columns CREATE TABLE missing_col_table(id int, time timestamptz not null); CALL attach_chunk('attach_test', 'missing_col_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: child table is missing column "device" -- Try to attach a table with extra columns CREATE TABLE extra_col_table(id int, time timestamptz not null, device int, temp float, extra_col int); CALL attach_chunk('attach_test', 'extra_col_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: table "extra_col_table" contains column "extra_col" not found in parent "attach_test" -- Attach by non-owner is not allowed set role :ROLE_1; CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: must be owner of table regular_table_to_attach set role :ROLE_DEFAULT_PERM_USER; CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-06-01 05:00:00+3", "2025-06-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: chunk creation failed due to collision -- Attach hypertable as a chunk CALL attach_chunk('attach_test', 'hypertable_with_different_dimension', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: cannot attach hypertable as a chunk \set ON_ERROR_STOP 1 -- Test rollback behavior SELECT count(*) AS "PRE_ROLLBACK_CHUNKS" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; \gset PRE_ROLLBACK_CHUNKS --------------------- 3 BEGIN; CREATE TABLE rollback_test_table(id int, time timestamptz not null, device int, temp float); ALTER TABLE rollback_test_table ADD CONSTRAINT attach_test_temp_check CHECK (temp > 0); CALL attach_chunk('attach_test', 'rollback_test_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ROLLBACK; SELECT count(*) = :'PRE_ROLLBACK_CHUNKS' FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; ?column? ---------- t CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00", "2025-07-07 05:00:00"], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01", "2025-07-07"], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["Tue July 1 05:00:00 2025 GMT+3", "Mon July 7 05:00:00 2025 GMT+3"], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": [1751356800000000, 1751875200000000], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); -- Attach a table with rows violating chunk constraints INSERT INTO regular_table_to_attach VALUES (4, '2024-07-05 13:00:00+3', 2, 27.8); \set ON_ERROR_STOP 0 CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ERROR: dimension constraint for column "time" violated by some row \set ON_ERROR_STOP 1 -- Clean up DROP TABLE regular_table_to_attach; DROP TABLE attach_test_ref; DROP TABLE attach_test; DROP TABLE devices CASCADE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_custom.out�������������������������������������������������0000664�0000000�0000000�00000131250�15100345067�0022341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE custom_log(job_id int, args jsonb, extra text, runner NAME DEFAULT CURRENT_ROLE); CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS VOID LANGUAGE SQL AS $$ INSERT INTO custom_log VALUES($1, $2, 'custom_func'); $$; CREATE OR REPLACE FUNCTION custom_func_definer(jobid int, args jsonb) RETURNS VOID LANGUAGE SQL AS $$ INSERT INTO custom_log VALUES($1, $2, 'security definer'); $$ SECURITY DEFINER; CREATE OR REPLACE PROCEDURE custom_proc(job_id int, args jsonb) LANGUAGE SQL AS $$ INSERT INTO custom_log VALUES($1, $2, 'custom_proc'); $$; -- procedure with transaction handling CREATE OR REPLACE PROCEDURE custom_proc2(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN INSERT INTO custom_log VALUES($1, $2, 'custom_proc2 1 COMMIT ' || (args->>'type')); COMMIT; INSERT INTO custom_log VALUES($1, $2, 'custom_proc2 2 ROLLBACK ' || (args->>'type')); ROLLBACK; INSERT INTO custom_log VALUES($1, $2, 'custom_proc2 3 COMMIT ' || (args->>'type')); COMMIT; END $$; \set ON_ERROR_STOP 0 -- test bad input SELECT add_job(NULL, '1h'); ERROR: function or procedure cannot be NULL SELECT add_job(0, '1h'); ERROR: function or procedure with OID 0 does not exist -- this will return an error about Oid 4294967295 -- while regproc is unsigned int postgres has an implicit cast from int to regproc SELECT add_job(-1, '1h'); ERROR: function or procedure with OID 4294967295 does not exist SELECT add_job('invalid_func', '1h'); ERROR: function "invalid_func" does not exist at character 16 SELECT add_job('custom_func', NULL); ERROR: schedule interval cannot be NULL SELECT add_job('custom_func', 'invalid interval'); ERROR: invalid input syntax for type interval: "invalid interval" at character 31 SELECT add_job('custom_func', '1h', job_name := 'this_is_a_really_really_really_long_application_name_to_overflow'); ERROR: application name too long. \set ON_ERROR_STOP 1 select '2000-01-01 00:00:00+00' as time_zero \gset SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); add_job --------- 1001 SELECT add_job('custom_proc','1h', config:='{"type":"procedure"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); add_job --------- 1002 SELECT add_job('custom_proc2','1h', config:= '{"type":"procedure"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); add_job --------- 1003 SELECT add_job('custom_func', '1h', config:='{"type":"function"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); add_job --------- 1004 SELECT add_job('custom_func_definer', '1h', config:='{"type":"function"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ, job_name := 'custom_job_name'); add_job --------- 1005 -- exclude internal jobs SELECT * FROM timescaledb_information.jobs WHERE job_id >= 1000 ORDER BY 1; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+----------------------------+-------------------+-------------+-------------+--------------+-------------+---------------------+-------------------+-----------+----------------+-----------------------+------------------------------+------------------------------+-------------------+-----------------+--------------+------------ 1001 | User-Defined Action [1001] | @ 1 hour | @ 0 | -1 | @ 5 mins | public | custom_func | default_perm_user | t | t | {"type": "function"} | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | | | | 1002 | User-Defined Action [1002] | @ 1 hour | @ 0 | -1 | @ 5 mins | public | custom_proc | default_perm_user | t | t | {"type": "procedure"} | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | | | | 1003 | User-Defined Action [1003] | @ 1 hour | @ 0 | -1 | @ 5 mins | public | custom_proc2 | default_perm_user | t | t | {"type": "procedure"} | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | | | | 1004 | User-Defined Action [1004] | @ 1 hour | @ 0 | -1 | @ 5 mins | public | custom_func | default_perm_user | t | t | {"type": "function"} | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | | | | 1005 | custom_job_name [1005] | @ 1 hour | @ 0 | -1 | @ 5 mins | public | custom_func_definer | default_perm_user | t | t | {"type": "function"} | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | | | | SELECT count(*) FROM _timescaledb_config.bgw_job WHERE config->>'type' IN ('procedure', 'function'); count ------- 5 \set ON_ERROR_STOP 0 -- test bad input CALL run_job(NULL); ERROR: job ID cannot be NULL CALL run_job(-1); ERROR: job -1 not found \set ON_ERROR_STOP 1 CALL run_job(1001); CALL run_job(1002); CALL run_job(1003); CALL run_job(1004); CALL run_job(1005); SELECT * FROM custom_log ORDER BY job_id, extra; job_id | args | extra | runner --------+-----------------------+---------------------------------+------------------- 1001 | {"type": "function"} | custom_func | default_perm_user 1002 | {"type": "procedure"} | custom_proc | default_perm_user 1003 | {"type": "procedure"} | custom_proc2 1 COMMIT procedure | default_perm_user 1003 | {"type": "procedure"} | custom_proc2 3 COMMIT procedure | default_perm_user 1004 | {"type": "function"} | custom_func | default_perm_user 1005 | {"type": "function"} | security definer | default_perm_user \set ON_ERROR_STOP 0 -- test bad input SELECT delete_job(NULL); delete_job ------------ SELECT delete_job(-1); ERROR: job -1 not found \set ON_ERROR_STOP 1 -- We keep job 1001 for some additional checks. SELECT delete_job(1002); delete_job ------------ SELECT delete_job(1003); delete_job ------------ SELECT delete_job(1004); delete_job ------------ SELECT delete_job(1005); delete_job ------------ -- check jobs got removed SELECT count(*) FROM timescaledb_information.jobs WHERE job_id >= 1002; count ------- 0 \c :TEST_DBNAME :ROLE_SUPERUSER -- create a new job with longer id SELECT nextval('_timescaledb_config.bgw_job_id_seq') as nextval \gset SELECT setval('_timescaledb_config.bgw_job_id_seq', 2147483647, false); setval ------------ 2147483647 SELECT add_job('custom_func', '1h', config:='{"type":"function"}'::jsonb, job_name := 'custom_job_name'); add_job ------------ 2147483647 \set ON_ERROR_STOP 0 -- test bad input SELECT alter_job(NULL, if_exists => false); ERROR: job ID cannot be NULL SELECT alter_job(-1, if_exists => false); ERROR: job -1 not found SELECT alter_job(1001, job_name => 'this_is_a_really_really_really_long_application_name_to_overflow'); ERROR: application name too long. SELECT alter_job(2147483647, job_name => 'this_is_a_really_really_really_long_application_name_to_overflow'); ERROR: application name too long. \set ON_ERROR_STOP 1 -- test bad input but don't fail SELECT alter_job(NULL, if_exists => true); NOTICE: job 0 not found, skipping alter_job ----------- SELECT alter_job(-1, if_exists => true); NOTICE: job -1 not found, skipping alter_job ----------- -- test altering job with NULL config SELECT job_id FROM alter_job(1001,scheduled:=false); job_id -------- 1001 SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; scheduled | config -----------+---------------------- f | {"type": "function"} -- test updating job settings SELECT job_id FROM alter_job(1001,config:='{"test":"test"}'); job_id -------- 1001 SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; scheduled | config -----------+------------------ f | {"test": "test"} SELECT job_id FROM alter_job(1001,scheduled:=true); job_id -------- 1001 SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; scheduled | config -----------+------------------ t | {"test": "test"} SELECT job_id FROM alter_job(1001,scheduled:=false); job_id -------- 1001 SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; scheduled | config -----------+------------------ f | {"test": "test"} -- test updating the job name SELECT job_id, application_name FROM alter_job(1001,job_name:='custom_name_2'); job_id | application_name --------+---------------------- 1001 | custom_name_2 [1001] SELECT job_id, application_name FROM alter_job(2147483647,job_name:='short_name_to_fit'); job_id | application_name ------------+-------------------------------- 2147483647 | short_name_to_fit [2147483647] SELECT application_name FROM timescaledb_information.jobs WHERE job_id >= 1001; application_name -------------------------------- custom_name_2 [1001] short_name_to_fit [2147483647] -- Done with jobs now, so remove it. SELECT delete_job(1001); delete_job ------------ SELECT delete_job(2147483647); delete_job ------------ -- reset the sequence to its previous value SELECT setval('_timescaledb_config.bgw_job_id_seq', :nextval, false); setval -------- 1006 --test for #2793 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- background workers are disabled, so the job will not run -- SELECT add_job( proc=>'custom_func', schedule_interval=>'1h', initial_start =>'2018-01-01 10:00:00-05') AS job_id_1 \gset SELECT job_id, next_start, scheduled, schedule_interval FROM timescaledb_information.jobs WHERE job_id > 1001; job_id | next_start | scheduled | schedule_interval --------+------------------------------+-----------+------------------- 1006 | Mon Jan 01 07:00:00 2018 PST | t | @ 1 hour \x SELECT * FROM timescaledb_information.job_stats WHERE job_id > 1001; -[ RECORD 1 ]----------+----------------------------- hypertable_schema | hypertable_name | job_id | 1006 last_run_started_at | -infinity last_successful_finish | -infinity last_run_status | job_status | Scheduled last_run_duration | next_start | Mon Jan 01 07:00:00 2018 PST total_runs | 0 total_successes | 0 total_failures | 0 \x SELECT delete_job(:job_id_1); delete_job ------------ -- tests for #3545 TRUNCATE custom_log; -- Nested procedure call CREATE OR REPLACE PROCEDURE custom_proc_nested(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN INSERT INTO custom_log VALUES($1, $2, 'custom_proc_nested 1 COMMIT'); COMMIT; INSERT INTO custom_log VALUES($1, $2, 'custom_proc_nested 2 ROLLBACK'); ROLLBACK; INSERT INTO custom_log VALUES($1, $2, 'custom_proc_nested 3 COMMIT'); COMMIT; END $$; CREATE OR REPLACE PROCEDURE custom_proc3(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN CALL custom_proc_nested(job_id, args); END $$; CREATE OR REPLACE PROCEDURE custom_proc4(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN INSERT INTO custom_log VALUES($1, $2, 'custom_proc4 1 COMMIT'); COMMIT; INSERT INTO custom_log VALUES($1, $2, 'custom_proc4 2 ROLLBACK'); ROLLBACK; RAISE EXCEPTION 'forced exception'; INSERT INTO custom_log VALUES($1, $2, 'custom_proc4 3 ABORT'); COMMIT; END $$; CREATE OR REPLACE PROCEDURE custom_proc5(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('conditions_summary_daily', '2021-08-01 00:00', '2021-08-31 00:00'); END $$; -- Remove any default jobs, e.g., telemetry \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_config.bgw_job RESTART IDENTITY CASCADE; NOTICE: truncate cascades to table "bgw_job_stat" NOTICE: truncate cascades to table "bgw_policy_chunk_stats" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_job('custom_proc2', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_1 \gset SELECT add_job('custom_proc3', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_2 \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Start Background Workers SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t -- Wait for jobs SELECT test.wait_for_job_to_run(:job_id_1, 1); wait_for_job_to_run --------------------- t SELECT test.wait_for_job_to_run(:job_id_2, 1); wait_for_job_to_run --------------------- t -- Check results SELECT * FROM custom_log ORDER BY job_id, extra; job_id | args | extra | runner --------+-----------------------+---------------------------------+------------------- 1000 | {"type": "procedure"} | custom_proc2 1 COMMIT procedure | default_perm_user 1000 | {"type": "procedure"} | custom_proc2 3 COMMIT procedure | default_perm_user 1001 | {"type": "procedure"} | custom_proc_nested 1 COMMIT | default_perm_user 1001 | {"type": "procedure"} | custom_proc_nested 3 COMMIT | default_perm_user -- Delete previous jobs SELECT delete_job(:job_id_1); delete_job ------------ SELECT delete_job(:job_id_2); delete_job ------------ TRUNCATE custom_log; -- Forced Exception SELECT add_job('custom_proc4', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_3 \gset SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_3, 1); INFO: wait_for_job_to_run: job execution failed wait_for_job_to_run --------------------- f -- Check results SELECT * FROM custom_log ORDER BY job_id, extra; job_id | args | extra | runner --------+-----------------------+-----------------------+------------ 1002 | {"type": "procedure"} | custom_proc4 1 COMMIT | super_user -- Delete previous jobs SELECT delete_job(:job_id_3); delete_job ------------ CREATE TABLE conditions ( time TIMESTAMP NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ) WITH (autovacuum_enabled = FALSE); SELECT create_hypertable('conditions', 'time', chunk_time_interval := '15 days'::interval); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (1,public,conditions,t) ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'time' ); INSERT INTO conditions SELECT generate_series('2021-08-01 00:00'::timestamp, '2021-08-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; -- Chunk compress stats SELECT * FROM _timescaledb_internal.compressed_chunk_stats ORDER BY chunk_name; hypertable_schema | hypertable_name | chunk_schema | chunk_name | compression_status | uncompressed_heap_size | uncompressed_index_size | uncompressed_toast_size | uncompressed_total_size | compressed_heap_size | compressed_index_size | compressed_toast_size | compressed_total_size -------------------+-----------------+-----------------------+------------------+--------------------+------------------------+-------------------------+-------------------------+-------------------------+----------------------+-----------------------+-----------------------+----------------------- public | conditions | _timescaledb_internal | _hyper_1_1_chunk | Uncompressed | | | | | | | | public | conditions | _timescaledb_internal | _hyper_1_2_chunk | Uncompressed | | | | | | | | public | conditions | _timescaledb_internal | _hyper_1_3_chunk | Uncompressed | | | | | | | | -- Compression policy SELECT add_compression_policy('conditions', interval '1 day') AS job_id_4 \gset SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_4, 1); wait_for_job_to_run --------------------- t -- Chunk compress stats SELECT * FROM _timescaledb_internal.compressed_chunk_stats ORDER BY chunk_name; hypertable_schema | hypertable_name | chunk_schema | chunk_name | compression_status | uncompressed_heap_size | uncompressed_index_size | uncompressed_toast_size | uncompressed_total_size | compressed_heap_size | compressed_index_size | compressed_toast_size | compressed_total_size -------------------+-----------------+-----------------------+------------------+--------------------+------------------------+-------------------------+-------------------------+-------------------------+----------------------+-----------------------+-----------------------+----------------------- public | conditions | _timescaledb_internal | _hyper_1_1_chunk | Compressed | 8192 | 16384 | 8192 | 32768 | 16384 | 16384 | 8192 | 40960 public | conditions | _timescaledb_internal | _hyper_1_2_chunk | Compressed | 8192 | 16384 | 8192 | 32768 | 16384 | 16384 | 8192 | 40960 public | conditions | _timescaledb_internal | _hyper_1_3_chunk | Compressed | 8192 | 16384 | 8192 | 32768 | 16384 | 16384 | 8192 | 40960 --TEST compression job after inserting data into previously compressed chunk INSERT INTO conditions SELECT generate_series('2021-08-01 00:00'::timestamp, '2021-08-31 00:00'::timestamp, '1 day'), 'NYC', 'nycity', 40, 40; SELECT id, table_name, status from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'conditions') order by id; id | table_name | status ----+------------------+-------- 1 | _hyper_1_1_chunk | 9 2 | _hyper_1_2_chunk | 9 3 | _hyper_1_3_chunk | 9 --running job second time, wait for it to complete select t.schedule_interval FROM alter_job(:job_id_4, next_start=> now() ) t; schedule_interval ------------------- @ 12 hours SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_4, 2); wait_for_job_to_run --------------------- t SELECT id, table_name, status from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'conditions') order by id; id | table_name | status ----+------------------+-------- 1 | _hyper_1_1_chunk | 1 2 | _hyper_1_2_chunk | 1 3 | _hyper_1_3_chunk | 1 -- Drop the compression job SELECT delete_job(:job_id_4); delete_job ------------ -- Decompress chunks before create the cagg SELECT decompress_chunk(c) FROM show_chunks('conditions') c; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk -- TEST Continuous Aggregate job CREATE MATERIALIZED VIEW conditions_summary_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature), MAX(temperature), MIN(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; -- Refresh Continous Aggregate by Job SELECT add_job('custom_proc5', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_5 \gset SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_5, 1); wait_for_job_to_run --------------------- t SELECT count(*) FROM conditions_summary_daily; count ------- 62 -- TESTs for alter_job_set_hypertable_id API SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id_5, NULL); alter_job_set_hypertable_id ----------------------------- 1004 SELECT id, proc_name, hypertable_id FROM _timescaledb_config.bgw_job WHERE id = :job_id_5; id | proc_name | hypertable_id ------+--------------+--------------- 1004 | custom_proc5 | -- error case, try to associate with a PG relation \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id_5, 'custom_log'); ERROR: relation "custom_log" is not a hypertable or continuous aggregate \set ON_ERROR_STOP 1 -- TEST associate the cagg with the job SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id_5, 'conditions_summary_daily'::regclass); alter_job_set_hypertable_id ----------------------------- 1004 SELECT id, proc_name, hypertable_id FROM _timescaledb_config.bgw_job WHERE id = :job_id_5; id | proc_name | hypertable_id ------+--------------+--------------- 1004 | custom_proc5 | 3 --verify that job is dropped when cagg is dropped DROP MATERIALIZED VIEW conditions_summary_daily; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_7_chunk SELECT id, proc_name, hypertable_id FROM _timescaledb_config.bgw_job WHERE id = :job_id_5; id | proc_name | hypertable_id ----+-----------+--------------- -- Cleanup DROP TABLE conditions; DROP TABLE custom_log; -- Stop Background Workers SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t \set ON_ERROR_STOP 0 -- add test for custom jobs with custom check functions -- create the functions/procedures to be used as checking functions CREATE OR REPLACE PROCEDURE test_config_check_proc(config jsonb) LANGUAGE PLPGSQL AS $$ DECLARE drop_after interval; BEGIN SELECT jsonb_object_field_text (config, 'drop_after')::interval INTO STRICT drop_after; IF drop_after IS NULL THEN RAISE EXCEPTION 'Config must be not NULL and have drop_after'; END IF ; END $$; CREATE OR REPLACE FUNCTION test_config_check_func(config jsonb) RETURNS VOID AS $$ DECLARE drop_after interval; BEGIN IF config IS NULL THEN RETURN; END IF; SELECT jsonb_object_field_text (config, 'drop_after')::interval INTO STRICT drop_after; IF drop_after IS NULL THEN RAISE EXCEPTION 'Config can be NULL but must have drop_after if not'; END IF ; END $$ LANGUAGE PLPGSQL; -- step 2, create a procedure to run as a custom job CREATE OR REPLACE PROCEDURE test_proc_with_check(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE NOTICE 'Will only print this if config passes checks, my config is %', config; END $$; -- step 3, add the job with the config check function passed as argument -- test procedures, should get an unsupported error select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_proc'::regproc); ERROR: unsupported function type -- test functions select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func'::regproc); ERROR: Config can be NULL but must have drop_after if not select add_job('test_proc_with_check', '5 secs', config => NULL, check_config => 'test_config_check_func'::regproc); add_job --------- 1005 select add_job('test_proc_with_check', '5 secs', config => '{"drop_after": "chicken"}', check_config => 'test_config_check_func'::regproc); ERROR: invalid input syntax for type interval: "chicken" select add_job('test_proc_with_check', '5 secs', config => '{"drop_after": "2 weeks"}', check_config => 'test_config_check_func'::regproc) as job_with_func_check_id \gset --- test alter_job select alter_job(:job_with_func_check_id, config => '{"drop_after":"chicken"}'); ERROR: invalid input syntax for type interval: "chicken" select config from alter_job(:job_with_func_check_id, config => '{"drop_after":"5 years"}'); config --------------------------- {"drop_after": "5 years"} -- test that jobs with an incorrect check function signature will not be registered -- these are all incorrect function signatures CREATE OR REPLACE FUNCTION test_config_check_func_0args() RETURNS VOID AS $$ BEGIN RAISE NOTICE 'I take no arguments and will validate anything you give me!'; END $$ LANGUAGE PLPGSQL; CREATE OR REPLACE FUNCTION test_config_check_func_2args(config jsonb, intarg int) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'I take two arguments (jsonb, int) and I should fail to run!'; END $$ LANGUAGE PLPGSQL; CREATE OR REPLACE FUNCTION test_config_check_func_intarg(config int) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'I take one argument which is an integer and I should fail to run!'; END $$ LANGUAGE PLPGSQL; -- -- this should fail, it has an incorrect check function select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_0args'::regproc); ERROR: function or procedure public.test_config_check_func_0args(config jsonb) not found -- -- so should this select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_2args'::regproc); ERROR: function or procedure public.test_config_check_func_2args(config jsonb) not found -- and this select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_intarg'::regproc); ERROR: function or procedure public.test_config_check_func_intarg(config jsonb) not found -- and this fails as it calls a nonexistent function select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_nonexistent_check_func'::regproc); ERROR: function "test_nonexistent_check_func" does not exist at character 82 -- when called with a valid check function and a NULL config no check should occur CREATE OR REPLACE FUNCTION test_config_check_func(config jsonb) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'This message will get printed for both NULL and not NULL config'; END $$ LANGUAGE PLPGSQL; SET client_min_messages = NOTICE; -- check done for both NULL and non-NULL config select add_job('test_proc_with_check', '5 secs', config => NULL, check_config => 'test_config_check_func'::regproc); NOTICE: This message will get printed for both NULL and not NULL config add_job --------- 1007 -- check done select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func'::regproc) as job_id \gset NOTICE: This message will get printed for both NULL and not NULL config -- check function not returning void CREATE OR REPLACE FUNCTION test_config_check_func_returns_int(config jsonb) RETURNS INT AS $$ BEGIN raise notice 'I print a message, and then I return least(1,2)'; RETURN LEAST(1, 2); END $$ LANGUAGE PLPGSQL; select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_returns_int'::regproc, initial_start => :'time_zero'::timestamptz) as job_id_int \gset NOTICE: I print a message, and then I return least(1,2) -- rename the check function and then call alter_job to register the new name ALTER FUNCTION test_config_check_func RENAME TO renamed_func; select job_id, schedule_interval, config, check_config from alter_job(:job_id, check_config => 'renamed_func'::regproc, schedule_interval => '1 hour'); NOTICE: This message will get printed for both NULL and not NULL config job_id | schedule_interval | config | check_config --------+-------------------+--------+--------------------- 1008 | @ 1 hour | {} | public.renamed_func -- run alter again, should get a config check select job_id, schedule_interval, config, check_config from alter_job(:job_id, config => '{}'); NOTICE: This message will get printed for both NULL and not NULL config job_id | schedule_interval | config | check_config --------+-------------------+--------+--------------------- 1008 | @ 1 hour | {} | public.renamed_func -- drop the registered check function, verify that alter_job will work and print a warning that -- the check is being skipped due to the check function missing DROP FUNCTION test_config_check_func_returns_int; select job_id, schedule_interval, config, check_config from alter_job(:job_id_int, config => '{"field":"value"}'); WARNING: function public.test_config_check_func_returns_int(config jsonb) not found, skipping config validation for job 1009 job_id | schedule_interval | config | check_config --------+-------------------+--------------------+------------------------------------------- 1009 | @ 5 secs | {"field": "value"} | public.test_config_check_func_returns_int -- do not drop the current check function but register a new one CREATE OR REPLACE FUNCTION substitute_check_func(config jsonb) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'This message is a substitute of the previously printed one'; END $$ LANGUAGE PLPGSQL; -- register the new check select job_id, schedule_interval, config, check_config from alter_job(:job_id, check_config => 'substitute_check_func'); NOTICE: This message is a substitute of the previously printed one job_id | schedule_interval | config | check_config --------+-------------------+--------+------------------------------ 1008 | @ 1 hour | {} | public.substitute_check_func select job_id, schedule_interval, config, check_config from alter_job(:job_id, config => '{}'); NOTICE: This message is a substitute of the previously printed one job_id | schedule_interval | config | check_config --------+-------------------+--------+------------------------------ 1008 | @ 1 hour | {} | public.substitute_check_func RESET client_min_messages; -- test an oid that doesn't exist select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 17424217::regproc); ERROR: function with OID 17424217 does not exist \c :TEST_DBNAME :ROLE_SUPERUSER -- test a function with insufficient privileges create schema test_schema; create role user_noexec with login; grant usage on schema test_schema to user_noexec; CREATE OR REPLACE FUNCTION test_schema.test_config_check_func_privileges(config jsonb) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'This message will only get printed if privileges suffice'; END $$ LANGUAGE PLPGSQL; revoke execute on function test_schema.test_config_check_func_privileges from public; -- verify the user doesn't have execute permissions on the function select has_function_privilege('user_noexec', 'test_schema.test_config_check_func_privileges(jsonb)', 'execute'); has_function_privilege ------------------------ f \c :TEST_DBNAME user_noexec -- user_noexec should not have exec permissions on this function select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_schema.test_config_check_func_privileges'::regproc); ERROR: permission denied for function "test_config_check_func_privileges" \c :TEST_DBNAME :ROLE_SUPERUSER -- check that alter_job rejects a check function with invalid signature select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'renamed_func', initial_start => :'time_zero'::timestamptz) as job_id_alter \gset NOTICE: This message will get printed for both NULL and not NULL config select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter, check_config => 'test_config_check_func_0args'); ERROR: function or procedure public.test_config_check_func_0args(config jsonb) not found select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter); NOTICE: This message will get printed for both NULL and not NULL config job_id | schedule_interval | config | check_config --------+-------------------+--------+--------------------- 1010 | @ 5 secs | {} | public.renamed_func -- test that we can unregister the check function select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter, check_config => 0); job_id | schedule_interval | config | check_config --------+-------------------+--------+-------------- 1010 | @ 5 secs | {} | -- no message printed now select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter, config => '{}'); job_id | schedule_interval | config | check_config --------+-------------------+--------+-------------- 1010 | @ 5 secs | {} | -- test the case where we have a background job that registers jobs with a check fn CREATE OR REPLACE PROCEDURE add_scheduled_jobs_with_check(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN perform add_job('test_proc_with_check', schedule_interval => '10 secs', config => '{}', check_config => 'renamed_func'); END $$; select add_job('add_scheduled_jobs_with_check', schedule_interval => '1 hour') as last_job_id \gset -- wait for enough time SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:last_job_id, 1); wait_for_job_to_run --------------------- t select total_runs, total_successes, last_run_status from timescaledb_information.job_stats where job_id = :last_job_id; total_runs | total_successes | last_run_status ------------+-----------------+----------------- 1 | 1 | Success -- test coverage for alter_job -- registering an invalid oid select alter_job(:job_id_alter, check_config => 123456789::regproc); ERROR: function with OID 123456789 does not exist -- registering a function with insufficient privileges \c :TEST_DBNAME user_noexec select * from add_job('test_proc_with_check', '5 secs', config => '{}') as job_id_owner \gset select * from alter_job(:job_id_owner, check_config => 'test_schema.test_config_check_func_privileges'::regproc); ERROR: permission denied for function "test_config_check_func_privileges" \c :TEST_DBNAME :ROLE_SUPERUSER DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to function test_schema.test_config_check_func_privileges(jsonb) -- Delete all jobs with that owner before we can drop the user. DELETE FROM _timescaledb_config.bgw_job WHERE owner = 'user_noexec'::regrole; DROP ROLE user_noexec; -- test with aggregate check proc create function jsonb_add (j1 jsonb, j2 jsonb) returns jsonb AS $$ BEGIN RETURN j1 || j2; END $$ LANGUAGE PLPGSQL; CREATE AGGREGATE sum_jsb (jsonb) ( sfunc = jsonb_add, stype = jsonb, initcond = '{}' ); -- for test coverage, check unsupported aggregate type select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'sum_jsb'::regproc); ERROR: unsupported function type -- Cleanup jobs TRUNCATE _timescaledb_config.bgw_job CASCADE; NOTICE: truncate cascades to table "bgw_job_stat" NOTICE: truncate cascades to table "bgw_policy_chunk_stats" -- github issue 4610 CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null ); SELECT FROM create_hypertable('sensor_data','time'); -- SELECT '2022-10-06 00:00:00+00' as start_date_sd \gset INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date_sd'::timestamptz - INTERVAL '1 months', :'start_date_sd'::timestamptz - INTERVAL '1 week', INTERVAL '30 minute') AS g1(time), generate_series(1, 50, 1 ) AS g2(sensor_id) ORDER BY time; -- enable compression ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); -- create new chunks INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date_sd'::timestamptz - INTERVAL '2 months', :'start_date_sd'::timestamptz - INTERVAL '2 week', INTERVAL '60 minute') AS g1(time), generate_series(1, 30, 1 ) AS g2(sensor_id) ORDER BY time; -- get the name of a new uncompressed chunk SELECT chunk_name AS new_uncompressed_chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'sensor_data' AND NOT is_compressed LIMIT 1 \gset -- change compression status so that this chunk is skipped when policy is run update _timescaledb_catalog.chunk set status=3 where table_name = :'new_uncompressed_chunk_name'; -- add new compression policy job SELECT add_compression_policy('sensor_data', INTERVAL '1' minute) AS compressjob_id \gset -- set recompress to true SELECT alter_job(id,config:=jsonb_set(config,'{recompress}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; alter_job --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1014,"@ 12 hours","@ 0",-1,"@ 1 hour",t,"{""recompress"": true, ""hypertable_id"": 4, ""compress_after"": ""@ 1 min""}",-infinity,_timescaledb_functions.policy_compression_check,f,,,"Columnstore Policy [1014]") -- verify that there are other uncompressed new chunks that need to be compressed SELECT count(*) > 1 FROM timescaledb_information.chunks WHERE hypertable_name = 'sensor_data' AND NOT is_compressed; ?column? ---------- t -- disable notice/warning as the new_uncompressed_chunk_name -- is dynamic and it will be printed in those messages. SET client_min_messages TO ERROR; CALL run_job(:compressjob_id); ERROR: columnstore policy failure SET client_min_messages TO NOTICE; -- check compression status is not changed for the chunk whose status was manually updated SELECT status FROM _timescaledb_catalog.chunk where table_name = :'new_uncompressed_chunk_name'; status -------- 3 -- confirm all the other new chunks are now compressed despite -- facing an error when trying to compress :'new_uncompressed_chunk_name' SELECT count(*) = 0 FROM timescaledb_information.chunks WHERE hypertable_name = 'sensor_data' AND NOT is_compressed; ?column? ---------- t -- cleanup SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t DROP TABLE sensor_data; SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t -- Github issue #5537 -- Proc that waits until the given job enters the expected state CREATE OR REPLACE PROCEDURE wait_for_job_status(job_param_id INTEGER, expected_status TEXT, spins INTEGER=:TEST_SPINWAIT_ITERS) LANGUAGE PLPGSQL AS $$ DECLARE jobstatus TEXT; BEGIN FOR i in 1..spins LOOP SELECT job_status FROM timescaledb_information.job_stats WHERE job_id = job_param_id INTO jobstatus; IF jobstatus = expected_status THEN RETURN; END IF; PERFORM pg_sleep(0.1); ROLLBACK; END LOOP; RAISE EXCEPTION 'wait_for_job_status(%): timeout after % tries', job_param_id, spins; END; $$; -- Proc that sleeps for 1m - to keep the test jobs in running state CREATE OR REPLACE PROCEDURE proc_that_sleeps(job_id INT, config JSONB) LANGUAGE PLPGSQL AS $$ BEGIN PERFORM pg_sleep(60); END $$; -- create new jobs and ensure that the second one gets scheduled -- before the first one by adjusting the initial_start values SELECT add_job('proc_that_sleeps', '1h', initial_start => now()::timestamptz + interval '2s') AS job_id_1 \gset SELECT add_job('proc_that_sleeps', '1h', initial_start => now()::timestamptz - interval '2s') AS job_id_2 \gset SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t -- wait for the jobs to start running job_2 will start running first CALL wait_for_job_status(:job_id_2, 'Running'); CALL wait_for_job_status(:job_id_1, 'Running'); -- add a new job and wait for it to start SELECT add_job('proc_that_sleeps', '1h') AS job_id_3 \gset CALL wait_for_job_status(:job_id_3, 'Running'); -- verify that none of the jobs crashed SELECT job_id, job_status, next_start, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id IN (:job_id_1, :job_id_2, :job_id_3) ORDER BY job_id; job_id | job_status | next_start | total_runs | total_successes | total_failures --------+------------+------------+------------+-----------------+---------------- 1015 | Running | -infinity | 1 | 0 | 0 1016 | Running | -infinity | 1 | 0 | 0 1017 | Running | -infinity | 1 | 0 | 0 SELECT job_id, err_message FROM timescaledb_information.job_errors WHERE job_id IN (:job_id_1, :job_id_2, :job_id_3); job_id | err_message --------+------------- -- cleanup SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t CALL wait_for_job_status(:job_id_1, 'Scheduled'); CALL wait_for_job_status(:job_id_2, 'Scheduled'); CALL wait_for_job_status(:job_id_3, 'Scheduled'); SELECT delete_job(:job_id_1); delete_job ------------ SELECT delete_job(:job_id_2); delete_job ------------ SELECT delete_job(:job_id_3); delete_job ------------ CREATE OR REPLACE FUNCTION ts_test_bgw_job_function_call_string(job_id INTEGER) RETURNS text AS :MODULE_PATHNAME LANGUAGE C STABLE STRICT; \set ON_ERROR_STOP 0 SELECT ts_test_bgw_job_function_call_string(999999); ERROR: job 999999 not found \set ON_ERROR_STOP 1 SELECT add_job('custom_func', '1h') AS job_func \gset SELECT add_job('custom_proc', '1h') AS job_proc \gset SELECT ts_test_bgw_job_function_call_string(:job_func); ts_test_bgw_job_function_call_string ----------------------------------------- SELECT public.custom_func('1018', NULL) SELECT ts_test_bgw_job_function_call_string(:job_proc); ts_test_bgw_job_function_call_string --------------------------------------- CALL public.custom_proc('1019', NULL) SELECT delete_job(:job_func); delete_job ------------ SELECT delete_job(:job_proc); delete_job ------------ SELECT add_job('custom_func', '1h', config => '{"type":"function"}'::jsonb) AS job_func \gset SELECT add_job('custom_proc', '1h', config => '{"type":"procedure"}'::jsonb) AS job_proc \gset SELECT ts_test_bgw_job_function_call_string(:job_func); ts_test_bgw_job_function_call_string ----------------------------------------------------------- SELECT public.custom_func('1020', '{"type": "function"}') SELECT ts_test_bgw_job_function_call_string(:job_proc); ts_test_bgw_job_function_call_string ---------------------------------------------------------- CALL public.custom_proc('1021', '{"type": "procedure"}') -- Remove the procedure and let's check it fallingback to PROKIND_FUNCTION DROP PROCEDURE custom_proc(jobid int, args jsonb); SELECT ts_test_bgw_job_function_call_string(:job_proc); ts_test_bgw_job_function_call_string ------------------------------------------------------------ SELECT public.custom_proc('1021', '{"type": "procedure"}') \set ON_ERROR_STOP 0 -- Mess with pg catalog to don't identify the PROKIND BEGIN; UPDATE pg_catalog.pg_proc SET prokind = 'X' WHERE oid = 'custom_func(int,jsonb)'::regprocedure; SELECT ts_test_bgw_job_function_call_string(:job_func); ERROR: unsupported function type: X ROLLBACK; \set ON_ERROR_STOP 1 SELECT delete_job(:job_func); delete_job ------------ SELECT delete_job(:job_proc); delete_job ------------ ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_db_scheduler.out�������������������������������������������0000664�0000000�0000000�00000206262�15100345067�0023460�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_test_job_sleep(job_id INT, config JSONB) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION insert_job( application_name NAME, job_type NAME, schedule_interval INTERVAL, max_runtime INTERVAL, retry_period INTERVAL, owner regrole DEFAULT CURRENT_ROLE::regrole, scheduled BOOL DEFAULT true, fixed_schedule BOOL DEFAULT false ) RETURNS INT LANGUAGE SQL SECURITY DEFINER AS $$ INSERT INTO _timescaledb_config.bgw_job(application_name,schedule_interval,max_runtime,max_retries, retry_period,proc_name,proc_schema,owner,scheduled,fixed_schedule) VALUES($1,$3,$4,5,$5,$2,'public',$6,$7,$8) RETURNING id; $$; CREATE OR REPLACE FUNCTION test_toggle_scheduled(job_id INTEGER) RETURNS VOID LANGUAGE SQL SECURITY DEFINER AS $$ UPDATE _timescaledb_config.bgw_job SET scheduled = NOT scheduled WHERE id = $1; $$; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 \set WAIT_FOR_STANDARD_WAITLATCH 3 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION get_application_pid(app_name TEXT) RETURNS INTEGER LANGUAGE SQL AS $BODY$ SELECT pid FROM pg_stat_activity WHERE application_name = app_name; $BODY$; CREATE FUNCTION wait_application_pid(app_name TEXT, wait_for_start BOOLEAN = true) RETURNS INTEGER LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT get_application_pid(app_name) INTO r; IF (wait_for_start AND r IS NULL) OR (NOT wait_for_start AND r IS NOT NULL) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN r; END IF; END LOOP; RETURN NULL; END $BODY$; CREATE FUNCTION wait_for_logentry(job_id INTEGER) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE app_name TEXT; message TEXT; BEGIN SELECT application_name INTO app_name FROM _timescaledb_config.bgw_job WHERE id = job_id; --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT msg INTO message FROM bgw_log WHERE application_name = app_name ORDER BY msg_no DESC LIMIT 1; IF FOUND THEN RETURN message; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RETURN NULL; END $BODY$; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- -- -- Test running the scheduler with no jobs -- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- empty -- turn on extended display to make the many fields of the table easier to parse \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; \x off -- empty SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) -- -- Test running the scheduler with a job marked as unscheduled -- TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT insert_job('unscheduled', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s',scheduled:= false); insert_job ------------ 1000 SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- empty \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; \x off SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- | | 1000 | | | | Paused | | | | | SELECT test_toggle_scheduled(1000); test_toggle_scheduled ----------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; -[ RECORD 1 ]-----------+-------------------------------- job_id | 1000 last_start | Fri Dec 31 16:00:00.05 1999 PST last_finish | Fri Dec 31 16:00:00.05 1999 PST next_start | Fri Dec 31 16:00:00.15 1999 PST last_successful_finish | Fri Dec 31 16:00:00.05 1999 PST last_run_success | t total_runs | 1 total_duration | @ 0 total_duration_failures | @ 0 total_successes | 1 total_failures | 0 total_crashes | 0 consecutive_failures | 0 consecutive_crashes | 0 flags | 0 \x off SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------------------+---------------------------------+-----------------+------------+-------------------+---------------------------------+------------+-----------------+---------------- | | 1000 | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | Success | Scheduled | | Fri Dec 31 16:00:00.15 1999 PST | 1 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | unscheduled | Execute job 1 SELECT delete_job(1000); delete_job ------------ -- -- test deleting job also terminates running jobs -- SELECT add_job('ts_bgw_test_job_sleep','1h') AS job_id \gset SELECT ts_bgw_db_scheduler_test_run(); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_for_logentry(:job_id); wait_for_logentry ------------------- Before sleep SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; application_name ---------------------------- User-Defined Action [1001] \x on SELECT job_id, job_status FROM timescaledb_information.job_stats; -[ RECORD 1 ]------- job_id | 1001 job_status | Running -- Showing non-volatile information from pg_stat_activity for -- debugging purposes. Information schema above reads from this view. SELECT datname, usename, application_name, state, query, wait_event_type, wait_event FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; -[ RECORD 1 ]----+------------------------------------ datname | db_bgw_db_scheduler usename | default_perm_user application_name | User-Defined Action [1001] state | active query | CALL public.ts_bgw_test_job_sleep() wait_event_type | Timeout wait_event | PgSleep \x off -- have to suppress notices here as delete_job will print pid of the running background worker processes SET client_min_messages TO WARNING; SELECT delete_job(:job_id); delete_job ------------ RESET client_min_messages; SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; application_name ------------------ -- wait for scheduler finish SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- -- -- Test running a normal job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq RESTART; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT insert_job('test_job_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1000 select * from _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+------------------+-------------------+-----------------+-------------+--------------+-------------+----------------+------------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- 1000 | test_job_1 | @ 0.1 secs | @ 1 min 40 secs | 5 | @ 1 sec | public | bgw_test_job_1 | super_user | t | f | | | | | | \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --Tests that the scheduler start a job right away if it's the first time and there is no job_stat entry for it SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.1 1999 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 --Test that the scheduler will not run job again if not enough time has passed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1000 | t | 1 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) --After enough time has passed the scheduler will run the job again SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.2 1999 PST | Fri Dec 31 16:00:00.1 1999 PST | t | 2 | 2 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 --Now it runs it one more time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(120, 100); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.3 1999 PST | Fri Dec 31 16:00:00.2 1999 PST | t | 3 | 3 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 -- -- Test what happens when running a job that throws an error -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_2', 'bgw_test_job_2_error', INTERVAL '100ms', INTERVAL '100s', INTERVAL '100ms') AS test_job_2_id \gset \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --Run the first time and error SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 1 | 0 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; last_finish | last_successful_finish | last_run_success ------------------------------+------------------------+------------------ Fri Dec 31 16:00:00 1999 PST | -infinity | f --Scheduler runs the job again, sees another error, and increases the wait time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(125); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 2 | 0 | 2 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 --The job runs and fails again a few more times increasing the wait time each time. SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(225); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 3 | 0 | 3 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(425); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 4 | 0 | 4 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 --Once the wait time reaches 500ms it stops increasion SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(525); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 5 | 0 | 5 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 reached max_retries after 5 consecutive failures 2 | test_job_2 | job 1001 threw an error 3 | test_job_2 | Error job 2 -- Get status of failing job `test_job_2` to check it reached `max_retries` and -- the new `job_status` now is `Paused` SELECT job_id, last_run_status, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id = :test_job_2_id; job_id | last_run_status | job_status | total_runs | total_successes | total_failures --------+-----------------+------------+------------+-----------------+---------------- 1001 | Failed | Paused | 5 | 0 | 5 -- Alter job to be rescheduled and run it again \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT scheduled FROM alter_job(:test_job_2_id, scheduled => true) AS discard; scheduled ----------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(525); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :test_job_2_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 6 | 0 | 6 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 reached max_retries after 6 consecutive failures 2 | test_job_2 | job 1001 threw an error 3 | test_job_2 | Error job 2 -- -- Test timeout logic -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; --set timeout lower than job length SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '20ms', INTERVAL '50ms'); insert_job ------------ 1002 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_params_mock_wait_returns_immediately(:IMMEDIATELY_SET_UNTIL); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --Test that the scheduler kills a job that takes too long SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1002 | f | 1 | 0 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | terminating connection due to timeout 3 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 4 | DB Scheduler | job 1002 failed --Check that the scheduler does not kill a job with infinite timeout \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; --set timeout to 0 SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '0', INTERVAL '10ms'); insert_job ------------ 1003 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(550); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1003 | t | 1 | 1 | 0 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | After sleep job 3 SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- -- -- Test signal handling -- --Test sending a SIGTERM to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '500ms'); insert_job ------------ 1004 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --escalated priv needed for access to pg_stat_activity \c :TEST_DBNAME :ROLE_SUPERUSER SELECT ts_bgw_db_scheduler_test_run(300); ts_bgw_db_scheduler_test_run ------------------------------ SELECT pg_terminate_backend(wait_application_pid('test_job_3_long')); pg_terminate_backend ---------------------- t SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command 2 | DB Scheduler | job 1004 failed SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1004 | f | 1 | 0 | 1 | 0 -- Test that the job is able to run again and succeed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(900); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1004 | t | 2 | 1 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | job 1004 failed 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | After sleep job 3 --Test sending a SIGHUP to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_STANDARD_WAITLATCH); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- SELECT ts_bgw_db_scheduler_test_run(-1); ts_bgw_db_scheduler_test_run ------------------------------ SHOW timescaledb.shutdown_bgw_scheduler; timescaledb.shutdown_bgw_scheduler ------------------------------------ off ALTER SYSTEM SET timescaledb.shutdown_bgw_scheduler TO 'on'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; timescaledb.shutdown_bgw_scheduler ------------------------------------ on SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- -- The number of scheduler restarts is not deterministic during [..]_wait_for_scheduler_finish(). -- Therefore, we filter these messages to get a deterministic test output. SELECT * FROM sorted_bgw_log WHERE msg NOT LIKE '[TESTING] Wait until%'; msg_no | application_name | msg --------+------------------+----------------------------------------------- 0 | DB Scheduler | bgw scheduler stopped due to shutdown_bgw guc ALTER SYSTEM RESET timescaledb.shutdown_bgw_scheduler; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; timescaledb.shutdown_bgw_scheduler ------------------------------------ off SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --Test that sending SIGTERM to scheduler terminates the jobs as well \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); insert_job ------------ 1005 SELECT ts_bgw_db_scheduler_test_run(500); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_application_pid('test_job_3_long') IS NOT NULL ; ?column? ---------- t SELECT pg_terminate_backend(wait_application_pid('DB Scheduler Test')); pg_terminate_backend ---------------------- t SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT job_id, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+-------------+------------------+------------+-----------------+----------------+---------------+--------------------- 1005 | -infinity | f | 1 | 0 | 0 | 1 | 1 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | terminating connection due to administrator command 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command --After a SIGTERM to scheduler and jobs, the jobs are considered crashed and there is a imposed wait of 5 min before a job can be run. --See that there is no run again because of the crash-imposed wait (not run with the 10ms retry_period) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(500); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_finish | next_start | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+-------------+------------+------------------+------------+-----------------+----------------+---------------+--------------------- 1005 | -infinity | -infinity | f | 1 | 0 | 0 | 1 | 1 --But after the 5 min period the job is again run SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(400000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_finish | next_start | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+---------------+--------------------- 1005 | Fri Dec 31 16:05:00.5 1999 PST | Fri Dec 31 16:05:05.5 1999 PST | t | 2 | 1 | 0 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | terminating connection due to administrator command 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | After sleep job 3 CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_3_to_finish(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='After sleep job 3' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; -- -- Test starting more jobs than availlable workers -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --Our normal limit is 8 jobs (1 already taken up by the launcher, we don't register the test scheduler) --so start 8 workers. Make the schedule_INTERVAL long and the retry period short so that the --retries happen within the scheduler run time but everything only runs once. SELECT insert_job('test_job_3_long_1', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_2', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_3', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_4', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_5', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_6', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); insert_job | insert_job | insert_job | insert_job | insert_job | insert_job ------------+------------+------------+------------+------------+------------ 1006 | 1007 | 1008 | 1009 | 1010 | 1011 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run(25000); --quit at second 25 ts_bgw_db_scheduler_test_run ------------------------------ --the first 7 jobs will run right away, but not the last one SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t SELECT wait_for_job_3_to_finish(6); wait_for_job_3_to_finish -------------------------- t SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1006 | t | 1 | 1 | 0 | 0 | 0 1007 | t | 1 | 1 | 0 | 0 | 0 1008 | t | 1 | 1 | 0 | 0 | 0 1009 | t | 1 | 1 | 0 | 0 | 0 1010 | t | 1 | 1 | 0 | 0 | 0 1011 | t | 1 | 1 | 0 | 0 | 0 SELECT ts_bgw_params_reset_time(30000000, true); --set to second 30, which causes a quit. ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- --should have all 8 runs, all with success runs SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1006 | t | 1 | 1 | 0 | 0 | 0 1007 | t | 1 | 1 | 0 | 0 | 0 1008 | t | 1 | 1 | 0 | 0 | 0 1009 | t | 1 | 1 | 0 | 0 | 0 1010 | t | 1 | 1 | 0 | 0 | 0 1011 | t | 1 | 1 | 0 | 0 | 0 SELECT * FROM sorted_bgw_log WHERE application_name = 'DB Scheduler' ORDER BY application_name, msg_no; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Registered new background worker 3 | DB Scheduler | [TESTING] Registered new background worker 4 | DB Scheduler | [TESTING] Registered new background worker 5 | DB Scheduler | [TESTING] Registered new background worker 6 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) SELECT ts_bgw_params_destroy(); ts_bgw_params_destroy ----------------------- -- -- Test setting next_start time within a job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_4', 'bgw_test_job_4', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1012 select * from _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+------------------+-------------------+-----------------+-------------+--------------+-------------+----------------+------------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- 1012 | test_job_4 | @ 0.1 secs | @ 1 min 40 secs | 5 | @ 1 sec | public | bgw_test_job_4 | super_user | t | f | | | | | | \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now run and make sure next_start is 200ms away, not 100ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1012 | t | 1 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_4 | Execute job 4 -- Now just make sure that the job actually runs in 200ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- Print next_start and last_finish explicitly, instead of the difference, to make sure the times have changed -- since the last run SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+--------------- 1012 | Fri Dec 31 16:00:00.4 1999 PST | Fri Dec 31 16:00:00.2 1999 PST | t | 2 | 2 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_4 | Execute job 4 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_4 | Execute job 4 -- Test updating jobs list TRUNCATE bgw_log; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.stop_background_workers(); ERROR: must be superuser to stop background workers SELECT _timescaledb_functions.restart_background_workers(); ERROR: must be superuser to restart background workers SELECT _timescaledb_functions.start_background_workers(); ERROR: must be superuser to start background workers \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t CREATE OR REPLACE FUNCTION ts_test_job_refresh() RETURNS TABLE( id INTEGER, application_name NAME, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INT, retry_period INTERVAL, next_start TIMESTAMPTZ, timeout_at TIMESTAMPTZ, reserved_worker BOOLEAN, may_next_mark_end BOOLEAN ) AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION verify_refresh_correct() RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_jobs INTEGER; num_jobs_in_list INTEGER; BEGIN SELECT COUNT(*) from _timescaledb_config.bgw_job INTO num_jobs; select COUNT(*) from ts_test_job_refresh() JOIN _timescaledb_config.bgw_job USING (id,application_name,schedule_interval,max_runtime,max_retries,retry_period) INTO num_jobs_in_list; IF (num_jobs = num_jobs_in_list) THEN RETURN true; END IF; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_1_to_run(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='Execute job 1' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t -- Should return the same table select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job; -- Make sure jobs list is empty select count(*) from ts_test_job_refresh(); count ------- 0 SELECT insert_job('test_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job | insert_job | insert_job ------------+------------+------------ 1013 | 1014 | 1015 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE from _timescaledb_config.bgw_job where application_name='test_2'; SELECT insert_job('test_4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1016 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_10', 'test_10', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1017 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t -- Should be idempotent select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job | insert_job | insert_job | insert_job | insert_job ------------+------------+------------+------------+------------ 1018 | 1019 | 1020 | 1021 | 1022 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job where application_name='another' OR application_name='another3'; SELECT insert_job('blah', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1023 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t -- Now test a real scheduler-mock running in a loop and updating the list of jobs TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- SELECT ts_bgw_db_scheduler_test_run(500); ts_bgw_db_scheduler_test_run ------------------------------ -- Wait for scheduler to start up SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); alter_job ----------------------------------------------------------------------------- (1024,"@ 0.1 secs","@ 1 min 40 secs",5,"@ 1 sec",t,,-infinity,,f,,,another) SELECT ts_bgw_params_reset_time(50000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(50000); wait_for_timer_to_run ----------------------- t SELECT wait_for_job_1_to_run(1); wait_for_job_1_to_run ----------------------- t SELECT ts_bgw_params_reset_time(150000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(150000); wait_for_timer_to_run ----------------------- t SELECT wait_for_job_1_to_run(2); wait_for_job_1_to_run ----------------------- t \x on select * from _timescaledb_internal.bgw_job_stat; -[ RECORD 1 ]-----------+-------------------------------- job_id | 1024 last_start | Fri Dec 31 16:00:00.15 1999 PST last_finish | Fri Dec 31 16:00:00.15 1999 PST next_start | Fri Dec 31 16:00:00.25 1999 PST last_successful_finish | Fri Dec 31 16:00:00.15 1999 PST last_run_success | t total_runs | 2 total_duration | @ 0 total_duration_failures | @ 0 total_successes | 2 total_failures | 0 total_crashes | 0 consecutive_failures | 0 consecutive_crashes | 0 flags | 0 \x off SELECT delete_job(x.id) FROM (select * from _timescaledb_config.bgw_job) x; delete_job ------------ -- test null handling in delete_job SELECT delete_job(NULL); delete_job ------------ SELECT ts_bgw_params_reset_time(200000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(200000); wait_for_timer_to_run ----------------------- t -- In the next time interval, nothing should be run because scheduler should have an empty list SELECT ts_bgw_params_reset_time(300000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(300000); wait_for_timer_to_run ----------------------- t -- Same for this time interval SELECT ts_bgw_params_reset_time(400000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(400000); wait_for_timer_to_run ----------------------- t -- Now add a new job and make sure it gets run before the scheduler dies SELECT insert_job('new_job', 'bgw_test_job_1', INTERVAL '10ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); alter_job ------------------------------------------------------------------------------ (1025,"@ 0.01 secs","@ 1 min 40 secs",5,"@ 1 sec",t,,-infinity,,f,,,new_job) SELECT ts_bgw_params_reset_time(450000, true); ts_bgw_params_reset_time -------------------------- -- New job should be run once, for a total of 3 runs of this job in the log SELECT wait_for_job_1_to_run(3); wait_for_job_1_to_run ----------------------- t -- New job should be run again SELECT ts_bgw_params_reset_time(480000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_job_1_to_run(4); wait_for_job_1_to_run ----------------------- t SELECT ts_bgw_params_reset_time(500000, true); ts_bgw_params_reset_time -------------------------- SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | another | Execute job 1 3 | DB Scheduler | [TESTING] Registered new background worker 4 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | another | Execute job 1 5 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 6 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 7 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 8 | DB Scheduler | [TESTING] Registered new background worker 9 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | new_job | Execute job 1 10 | DB Scheduler | [TESTING] Registered new background worker 11 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | new_job | Execute job 1 \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; -[ RECORD 1 ]-----------+-------------------------------- job_id | 1025 last_start | Fri Dec 31 16:00:00.48 1999 PST last_finish | Fri Dec 31 16:00:00.48 1999 PST next_start | Fri Dec 31 16:00:00.49 1999 PST last_successful_finish | Fri Dec 31 16:00:00.48 1999 PST last_run_success | t total_runs | 2 total_duration | @ 0 total_duration_failures | @ 0 total_successes | 2 total_failures | 0 total_crashes | 0 consecutive_failures | 0 consecutive_crashes | 0 flags | 0 \x off -- -- Test without retry -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- DELETE FROM _timescaledb_config.bgw_job; INSERT INTO _timescaledb_config.bgw_job(application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name) VALUES('bgw_test_job_2_error', INTERVAL '5000ms', INTERVAL '20ms', 0, INTERVAL '20ms', 'public', 'bgw_test_job_2_error') RETURNING id; id ------ 1026 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Run the first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1026 | f | 1 | 0 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+----------------------+----------------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | bgw_test_job_2_error | job 1026 reached max_retries after 1 consecutive failures 2 | bgw_test_job_2_error | job 1026 threw an error 3 | bgw_test_job_2_error | Error job 2 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; last_finish | last_successful_finish | last_run_success ------------------------------+------------------------+------------------ Fri Dec 31 16:00:00 1999 PST | -infinity | f -- Run the second time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1026 | f | 1 | 0 | 1 | 0 -- We increase the mock time a lot to ensure the job does not get restarted. However, the amount of scheduler sleep/wakeup cycles -- is not deterministic. Therefore, we filter these messages to get a deterministic test output. SELECT * FROM sorted_bgw_log WHERE msg NOT LIKE '[TESTING] Wait until%'; msg_no | application_name | msg --------+----------------------+----------------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | bgw_test_job_2_error | job 1026 reached max_retries after 1 consecutive failures 2 | bgw_test_job_2_error | job 1026 threw an error 3 | bgw_test_job_2_error | Error job 2 SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; last_finish | last_successful_finish | last_run_success ------------------------------+------------------------+------------------ Fri Dec 31 16:00:00 1999 PST | -infinity | f -- clean up jobs \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_db_scheduler_fixed.out�������������������������������������0000664�0000000�0000000�00000254624�15100345067�0024644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; -- this mock_start_time doesnt seem to be used anywhere CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_test_job_sleep(job_id INT, config JSONB) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- we use insert_job instead of add_job because we want to be able to set and use max_retries, max_runtime, retry_period which are not part of the add_job api CREATE OR REPLACE FUNCTION insert_job( application_name NAME, job_type NAME, schedule_interval INTERVAL, max_runtime INTERVAL, retry_period INTERVAL, owner regrole DEFAULT pg_catalog.quote_ident(current_role)::regrole, scheduled BOOL DEFAULT true, fixed_schedule BOOL DEFAULT true ) RETURNS INT LANGUAGE SQL SECURITY DEFINER AS $$ INSERT INTO _timescaledb_config.bgw_job(application_name,schedule_interval,max_runtime,max_retries, retry_period,proc_name,proc_schema,owner,scheduled,fixed_schedule,initial_start) VALUES($1,$3,$4,5,$5,$2,'public',$6,$7,$8,'2000-01-01 00:00:00+00'::timestamptz) RETURNING id; $$; CREATE OR REPLACE FUNCTION test_toggle_scheduled(job_id INTEGER) RETURNS VOID LANGUAGE SQL SECURITY DEFINER AS $$ UPDATE _timescaledb_config.bgw_job SET scheduled = NOT scheduled WHERE id = $1; $$; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 \set WAIT_FOR_STANDARD_WAITLATCH 3 -- simply sets the wait type CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION get_application_pid(app_name TEXT) RETURNS INTEGER LANGUAGE SQL AS $BODY$ SELECT pid FROM pg_stat_activity WHERE application_name = app_name; $BODY$; CREATE FUNCTION wait_application_pid(app_name TEXT, wait_for_start BOOLEAN = true) RETURNS INTEGER LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT get_application_pid(app_name) INTO r; IF (wait_for_start AND r IS NULL) OR (NOT wait_for_start AND r IS NOT NULL) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN r; END IF; END LOOP; RETURN NULL; END $BODY$; CREATE FUNCTION wait_for_logentry(job_id INTEGER) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE app_name TEXT; message TEXT; BEGIN SELECT application_name INTO app_name FROM _timescaledb_config.bgw_job WHERE id = job_id; --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT msg INTO message FROM bgw_log WHERE application_name = app_name ORDER BY msg_no DESC LIMIT 1; IF FOUND THEN RETURN message; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RETURN NULL; END $BODY$; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- -- -- Test running the scheduler with no jobs -- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- empty SELECT * FROM _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+------------+-------------+------------+------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- -- empty SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) -- -- Test running the scheduler with a job marked as unscheduled -- TRUNCATE bgw_log; -- this function sets the counter (microseconds) that corresponds to the current time to the -- given value (defalut 0, and the default for setting the latch is false) SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT insert_job('unscheduled', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s',scheduled:= false); insert_job ------------ 1000 SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- empty SELECT * FROM _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+------------+-------------+------------+------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- | | 1000 | | | | Paused | | | | | SELECT test_toggle_scheduled(1000); test_toggle_scheduled ----------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+---------------------------------+---------------------------------+--------------------------------+---------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1000 | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.1 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | t | 1 | @ 0 | @ 0 | 1 | 0 | 0 | 0 | 0 | 0 SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------------------+---------------------------------+-----------------+------------+-------------------+--------------------------------+------------+-----------------+---------------- | | 1000 | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | Success | Scheduled | | Fri Dec 31 16:00:00.1 1999 PST | 1 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | unscheduled | Execute job 1 SELECT delete_job(1000); delete_job ------------ -- -- test deleting job also terminates running jobs -- SELECT add_job('ts_bgw_test_job_sleep','1h') AS job_id \gset SELECT ts_bgw_db_scheduler_test_run(); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_for_logentry(:job_id); wait_for_logentry ------------------- Before sleep SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; application_name ---------------------------- User-Defined Action [1001] \x on SELECT job_id, job_status FROM timescaledb_information.job_stats; -[ RECORD 1 ]------- job_id | 1001 job_status | Running -- Showing non-volatile information from pg_stat_activity for -- debugging purposes. Information schema above reads from this view. SELECT datname, usename, application_name, state, query, wait_event_type, wait_event FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; -[ RECORD 1 ]----+------------------------------------ datname | db_bgw_db_scheduler_fixed usename | default_perm_user application_name | User-Defined Action [1001] state | active query | CALL public.ts_bgw_test_job_sleep() wait_event_type | Timeout wait_event | PgSleep \x off -- have to suppress notices here as delete_job will print pid of the running background worker processes SET client_min_messages TO WARNING; SELECT delete_job(:job_id); delete_job ------------ RESET client_min_messages; SELECT count(*) FROM wait_for_logentry(:job_id); count ------- 1 SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; application_name ------------------ -- -- Test running a normal job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq RESTART; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT insert_job('test_job_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1000 select * from _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+------------------+-------------------+-----------------+-------------+--------------+-------------+----------------+------------+-----------+----------------+------------------------------+---------------+--------+--------------+------------+---------- 1000 | test_job_1 | @ 0.1 secs | @ 1 min 40 secs | 5 | @ 1 sec | public | bgw_test_job_1 | super_user | t | t | Fri Dec 31 16:00:00 1999 PST | | | | | \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; --Tests that the scheduler start a job right away if it's the first time and there is no job_stat entry for it SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.1 1999 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 --Test that the scheduler will not run job again if not enough time has passed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1000 | t | 1 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) --After enough time has passed the scheduler will run the job again SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.2 1999 PST | Fri Dec 31 16:00:00.1 1999 PST | t | 2 | 2 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 --Now it runs it one more time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(120, 100); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.3 1999 PST | Fri Dec 31 16:00:00.2 1999 PST | t | 3 | 3 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1 | Execute job 1 -- -- Test what happens when running a job that throws an error -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; -- schedule_interval, max_runtime, retry_period SELECT insert_job('test_job_2', 'bgw_test_job_2_error', INTERVAL '800ms', INTERVAL '100s', INTERVAL '200ms'); insert_job ------------ 1001 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; --Run the first time and error SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 1 | 0 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; last_finish | last_successful_finish | last_run_success ------------------------------+------------------------+------------------ Fri Dec 31 16:00:00 1999 PST | -infinity | f -- what we aim to verify here is the following: -- 1. that the job is run again on its next scheduled slot, if the next_start calculated based -- on failure count would surpass it -- the next_start on failure is calculated by adding failure_count * retry_period to finish time -- maximum backoff is 5 * schedule interval, but for a fixed job, if we surpass the next_scheduled_slot -- for it this way, then we execute again at the next scheduled slot instead --Scheduler runs the job again, sees another error, and increases the wait time -- this retry time is before the next scheduled execution, so the job is allowed to retry before then SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(225); -- will see 2 failures now ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 2 | 0 | 2 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 -- as we have a job on a fixed_schedule, the next_start will not be more than the next scheduled slot -- If the calculated next_start is more than the next scheduled execution slot, then -- we will execute again at the next scheduled slot. -- again this is before the next scheduled slot so the job retries before then SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(425); -- will see 3 failures now ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 3 | 0 | 3 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 -- will see 4 failures now SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(625); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 4 | 0 | 4 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 -- will see 5 failures now because job executes again on its next scheduled slot (800ms after its initial start, which is 0) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(825); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 5 | 0 | 5 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 threw an error 2 | test_job_2 | Error job 2 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | test_job_2 | job 1001 reached max_retries after 5 consecutive failures 2 | test_job_2 | job 1001 threw an error 3 | test_job_2 | Error job 2 -- Get status of failing job `test_job_2` to check it reached `max_retries` and -- the new `job_status` now is `Paused` SELECT job_id, last_run_status, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id = 1001; job_id | last_run_status | job_status | total_runs | total_successes | total_failures --------+-----------------+------------+------------+-----------------+---------------- 1001 | Failed | Paused | 5 | 0 | 5 -- Alter job to be rescheduled and run it again \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT scheduled FROM alter_job(1001, scheduled => true) AS discard; scheduled ----------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(825); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat WHERE job_id = 1001; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | f | 6 | 0 | 6 | 0 -- -- Test timeout logic -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; --set timeout lower than job length SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '20ms', INTERVAL '50ms'); insert_job ------------ 1002 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_params_mock_wait_returns_immediately(:IMMEDIATELY_SET_UNTIL); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --Test that the scheduler kills a job that takes too long SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1002 | f | 1 | 0 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | terminating connection due to timeout 3 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 4 | DB Scheduler | job 1002 failed --Check that the scheduler does not kill a job with infinite timeout \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; --set timeout to 0 SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '0', INTERVAL '10ms'); insert_job ------------ 1003 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(550); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1003 | t | 1 | 1 | 0 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | After sleep job 3 SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- -- -- Test signal handling -- --Test sending a SIGTERM to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '500ms'); insert_job ------------ 1004 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --escalated priv needed for access to pg_stat_activity \c :TEST_DBNAME :ROLE_SUPERUSER SELECT ts_bgw_db_scheduler_test_run(300); ts_bgw_db_scheduler_test_run ------------------------------ SELECT pg_terminate_backend(wait_application_pid('test_job_3_long')); pg_terminate_backend ---------------------- t SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command 2 | DB Scheduler | job 1004 failed SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1004 | f | 1 | 0 | 1 | 0 -- Test that the job is able to run again and succeed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(900); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1004 | t | 2 | 1 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | job 1004 failed 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | After sleep job 3 --Test sending a SIGHUP to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_STANDARD_WAITLATCH); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- SELECT ts_bgw_db_scheduler_test_run(-1); ts_bgw_db_scheduler_test_run ------------------------------ SHOW timescaledb.shutdown_bgw_scheduler; timescaledb.shutdown_bgw_scheduler ------------------------------------ off ALTER SYSTEM SET timescaledb.shutdown_bgw_scheduler TO 'on'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; timescaledb.shutdown_bgw_scheduler ------------------------------------ on SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------- 0 | DB Scheduler | bgw scheduler stopped due to shutdown_bgw guc ALTER SYSTEM RESET timescaledb.shutdown_bgw_scheduler; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; timescaledb.shutdown_bgw_scheduler ------------------------------------ off SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --Test that sending SIGTERM to scheduler terminates the jobs as well \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); insert_job ------------ 1005 SELECT ts_bgw_db_scheduler_test_run(500); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_application_pid('test_job_3_long') IS NOT NULL ; ?column? ---------- t SELECT pg_terminate_backend(wait_application_pid('DB Scheduler Test')); pg_terminate_backend ---------------------- t SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT job_id, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+-------------+------------------+------------+-----------------+----------------+---------------+--------------------- 1005 | -infinity | f | 1 | 0 | 0 | 1 | 1 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | terminating connection due to administrator command 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command --After a SIGTERM to scheduler and jobs, the jobs are considered crashed and there is a imposed wait of 5 min before a job can be run. --See that there is no run again because of the crash-imposed wait (not run with the 10ms retry_period) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(500); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_finish | next_start | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+-------------+------------+------------------+------------+-----------------+----------------+---------------+--------------------- 1005 | -infinity | -infinity | f | 1 | 0 | 0 | 1 | 1 --But after the 5 min period the job is again run SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(400000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_finish | next_start | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+--------------------------------+------------------------------+------------------+------------+-----------------+----------------+---------------+--------------------- 1005 | Fri Dec 31 16:05:00.5 1999 PST | Fri Dec 31 16:05:05 1999 PST | t | 2 | 1 | 0 | 1 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+----------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 2 | DB Scheduler | terminating connection due to administrator command 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | terminating connection due to administrator command 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_3_long | Before sleep job 3 1 | test_job_3_long | After sleep job 3 CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_3_to_finish(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='After sleep job 3' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; -- -- Test starting more jobs than availlable workers -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --Our normal limit is 8 jobs (1 already taken up by the launcher, we don't register the test scheduler) --so start 8 workers. Make the schedule_INTERVAL long and the retry period short so that the --retries happen within the scheduler run time but everything only runs once. SELECT insert_job('test_job_3_long_1', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_2', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_3', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_4', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_5', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_6', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); insert_job | insert_job | insert_job | insert_job | insert_job | insert_job ------------+------------+------------+------------+------------+------------ 1006 | 1007 | 1008 | 1009 | 1010 | 1011 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run(25000); --quit at second 25 ts_bgw_db_scheduler_test_run ------------------------------ --the first 7 jobs will run right away, but not the last one SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t SELECT wait_for_job_3_to_finish(6); wait_for_job_3_to_finish -------------------------- t SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1006 | t | 1 | 1 | 0 | 0 | 0 1007 | t | 1 | 1 | 0 | 0 | 0 1008 | t | 1 | 1 | 0 | 0 | 0 1009 | t | 1 | 1 | 0 | 0 | 0 1010 | t | 1 | 1 | 0 | 0 | 0 1011 | t | 1 | 1 | 0 | 0 | 0 SELECT ts_bgw_params_reset_time(30000000, true); --set to second 30, which causes a quit. ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- --should have all 8 runs, all with success runs SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes | consecutive_crashes --------+------------------+------------+-----------------+----------------+---------------+--------------------- 1006 | t | 1 | 1 | 0 | 0 | 0 1007 | t | 1 | 1 | 0 | 0 | 0 1008 | t | 1 | 1 | 0 | 0 | 0 1009 | t | 1 | 1 | 0 | 0 | 0 1010 | t | 1 | 1 | 0 | 0 | 0 1011 | t | 1 | 1 | 0 | 0 | 0 SELECT * FROM sorted_bgw_log WHERE application_name = 'DB Scheduler' ORDER BY application_name, msg_no; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Registered new background worker 3 | DB Scheduler | [TESTING] Registered new background worker 4 | DB Scheduler | [TESTING] Registered new background worker 5 | DB Scheduler | [TESTING] Registered new background worker 6 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) SELECT ts_bgw_params_destroy(); ts_bgw_params_destroy ----------------------- -- -- Test setting next_start time within a job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_4', 'bgw_test_job_4', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1012 select * from _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+------------------+-------------------+-----------------+-------------+--------------+-------------+----------------+------------+-----------+----------------+------------------------------+---------------+--------+--------------+------------+---------- 1012 | test_job_4 | @ 0.1 secs | @ 1 min 40 secs | 5 | @ 1 sec | public | bgw_test_job_4 | super_user | t | t | Fri Dec 31 16:00:00 1999 PST | | | | | \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now run and make sure next_start is 200ms away, not 100ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1012 | t | 1 | 1 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_4 | Execute job 4 -- Now just make sure that the job actually runs in 200ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- Print next_start and last_finish explicitly, instead of the difference, to make sure the times have changed -- since the last run SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; job_id | next_start | last_finish | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+--------------------------------+--------------------------------+------------------+------------+-----------------+----------------+--------------- 1012 | Fri Dec 31 16:00:00.4 1999 PST | Fri Dec 31 16:00:00.2 1999 PST | t | 2 | 2 | 0 | 0 SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Registered new background worker 1 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_4 | Execute job 4 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_4 | Execute job 4 -- Test updating jobs list TRUNCATE bgw_log; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.stop_background_workers(); ERROR: must be superuser to stop background workers SELECT _timescaledb_functions.restart_background_workers(); ERROR: must be superuser to restart background workers SELECT _timescaledb_functions.start_background_workers(); ERROR: must be superuser to start background workers \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SET timezone TO PST8PDT; CREATE OR REPLACE FUNCTION ts_test_job_refresh() RETURNS TABLE( id INTEGER, application_name NAME, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INT, retry_period INTERVAL, next_start TIMESTAMPTZ, timeout_at TIMESTAMPTZ, reserved_worker BOOLEAN, may_next_mark_end BOOLEAN ) AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION verify_refresh_correct() RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_jobs INTEGER; num_jobs_in_list INTEGER; BEGIN SELECT COUNT(*) from _timescaledb_config.bgw_job INTO num_jobs; select COUNT(*) from ts_test_job_refresh() JOIN _timescaledb_config.bgw_job USING (id,application_name,schedule_interval,max_runtime,max_retries,retry_period) INTO num_jobs_in_list; IF (num_jobs = num_jobs_in_list) THEN RETURN true; END IF; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_1_to_run(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='Execute job 1' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t -- Should return the same table select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job; -- Make sure jobs list is empty select count(*) from ts_test_job_refresh(); count ------- 0 SELECT insert_job('test_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job | insert_job | insert_job ------------+------------+------------ 1013 | 1014 | 1015 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE from _timescaledb_config.bgw_job where application_name='test_2'; SELECT insert_job('test_4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1016 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_10', 'test_10', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1017 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t -- Should be idempotent select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job | insert_job | insert_job | insert_job | insert_job ------------+------------+------------+------------+------------ 1018 | 1019 | 1020 | 1021 | 1022 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t DELETE FROM _timescaledb_config.bgw_job where application_name='another' OR application_name='another3'; SELECT insert_job('blah', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); insert_job ------------ 1023 select * from verify_refresh_correct(); verify_refresh_correct ------------------------ t -- Now test a real scheduler-mock running in a loop and updating the list of jobs TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- SELECT ts_bgw_db_scheduler_test_run(500); ts_bgw_db_scheduler_test_run ------------------------------ -- Wait for scheduler to start up SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); alter_job ----------------------------------------------------------------------------------------------------------- (1024,"@ 0.1 secs","@ 1 min 40 secs",5,"@ 1 sec",t,,-infinity,,t,"Fri Dec 31 16:00:00 1999 PST",,another) SELECT ts_bgw_params_reset_time(50000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(50000); wait_for_timer_to_run ----------------------- t SELECT wait_for_job_1_to_run(1); wait_for_job_1_to_run ----------------------- t SELECT ts_bgw_params_reset_time(150000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(150000); wait_for_timer_to_run ----------------------- t SELECT wait_for_job_1_to_run(2); wait_for_job_1_to_run ----------------------- t select * from _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+---------------------------------+---------------------------------+--------------------------------+---------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1024 | Fri Dec 31 16:00:00.15 1999 PST | Fri Dec 31 16:00:00.15 1999 PST | Fri Dec 31 16:00:00.2 1999 PST | Fri Dec 31 16:00:00.15 1999 PST | t | 2 | @ 0 | @ 0 | 2 | 0 | 0 | 0 | 0 | 0 SELECT delete_job(x.id) FROM (select * from _timescaledb_config.bgw_job) x; delete_job ------------ -- test null handling in delete_job SELECT delete_job(NULL); delete_job ------------ SELECT ts_bgw_params_reset_time(200000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(200000); wait_for_timer_to_run ----------------------- t -- In the next time interval, nothing should be run because scheduler should have an empty list SELECT ts_bgw_params_reset_time(300000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(300000); wait_for_timer_to_run ----------------------- t -- Same for this time interval SELECT ts_bgw_params_reset_time(400000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_timer_to_run(400000); wait_for_timer_to_run ----------------------- t -- Now add a new job and make sure it gets run before the scheduler dies SELECT insert_job('new_job', 'bgw_test_job_1', INTERVAL '10ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); alter_job ------------------------------------------------------------------------------------------------------------ (1025,"@ 0.01 secs","@ 1 min 40 secs",5,"@ 1 sec",t,,-infinity,,t,"Fri Dec 31 16:00:00 1999 PST",,new_job) SELECT ts_bgw_params_reset_time(450000, true); ts_bgw_params_reset_time -------------------------- -- New job should be run once, for a total of 3 runs of this job in the log SELECT wait_for_job_1_to_run(3); wait_for_job_1_to_run ----------------------- t -- New job should be run again SELECT ts_bgw_params_reset_time(480000, true); ts_bgw_params_reset_time -------------------------- SELECT wait_for_job_1_to_run(4); wait_for_job_1_to_run ----------------------- t SELECT ts_bgw_params_reset_time(500000, true); ts_bgw_params_reset_time -------------------------- SELECT * FROM sorted_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 1 | DB Scheduler | [TESTING] Registered new background worker 2 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | another | Execute job 1 3 | DB Scheduler | [TESTING] Registered new background worker 4 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | another | Execute job 1 5 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 6 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 7 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 8 | DB Scheduler | [TESTING] Registered new background worker 9 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | new_job | Execute job 1 10 | DB Scheduler | [TESTING] Registered new background worker 11 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | new_job | Execute job 1 SELECT * FROM _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+---------------------------------+---------------------------------+---------------------------------+---------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1025 | Fri Dec 31 16:00:00.48 1999 PST | Fri Dec 31 16:00:00.48 1999 PST | Fri Dec 31 16:00:00.49 1999 PST | Fri Dec 31 16:00:00.48 1999 PST | t | 2 | @ 0 | @ 0 | 2 | 0 | 0 | 0 | 0 | 0 -- clean up jobs SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t select delete_job(:job_id); delete_job ------------ -- test the new API with all its parameters: with timezone, without timezone TRUNCATE bgw_log; TRUNCATE bgw_dsm_handle_store; INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- CREATE TABLE test_table_scheduler ( time timestamptz not null, a int, b int ); select '2000-01-01 00:00:00+00' as init \gset select create_hypertable('test_table_scheduler', 'time', chunk_time_interval => interval '1 month'); create_hypertable ----------------------------------- (1,public,test_table_scheduler,t) INSERT INTO test_table_scheduler values (now() - interval '10 years', 1, 1), (now() - interval '8 years', 1, 1), (now() - interval '6 years', 1, 1), (now() - interval '4 years', 1, 1), (now() - interval '2 years', 1, 1), (now() - interval '1 years', 2, 2), (now() - interval '6 months', 3, 3), (now() - interval '3 months', 4, 4); CREATE MATERIALIZED VIEW cagg_scheduler(time, avg_a) WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', time), avg(a) FROM test_table_scheduler GROUP BY time_bucket('1 month', time) WITH NO DATA; SELECT set_chunk_time_interval('_timescaledb_internal._materialized_hypertable_2', interval '36500 days'); set_chunk_time_interval ------------------------- select show_chunks('test_table_scheduler'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk alter table test_table_scheduler set (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); select add_retention_policy('test_table_scheduler', interval '2 year', initial_start => :'init'::timestamptz, timezone => 'Europe/Berlin'); add_retention_policy ---------------------- 1026 select add_compression_policy('test_table_scheduler', interval '1 year', initial_start => :'init'::timestamptz, timezone => 'Europe/Berlin'); add_compression_policy ------------------------ 1027 select add_continuous_aggregate_policy('cagg_scheduler', interval '1 year', interval '2 months', interval '3 weeks', initial_start => :'init'::timestamptz + interval '5 ms', timezone => 'Europe/Athens'); add_continuous_aggregate_policy --------------------------------- 1028 select * from _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+------------+-----------+----------------+----------------------------------+---------------+--------------------------------------------------------------------------------+------------------------+-------------------------------------------+--------------- 1026 | Retention Policy [1026] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | super_user | t | t | Fri Dec 31 16:00:00 1999 PST | 1 | {"drop_after": "@ 2 years", "hypertable_id": 1} | _timescaledb_functions | policy_retention_check | Europe/Berlin 1027 | Columnstore Policy [1027] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | super_user | t | t | Fri Dec 31 16:00:00 1999 PST | 1 | {"hypertable_id": 1, "compress_after": "@ 1 year"} | _timescaledb_functions | policy_compression_check | Europe/Berlin 1028 | Refresh Continuous Aggregate Policy [1028] | @ 21 days | @ 0 | -1 | @ 21 days | _timescaledb_functions | policy_refresh_continuous_aggregate | super_user | t | t | Fri Dec 31 16:00:00.005 1999 PST | 2 | {"end_offset": "@ 2 mons", "start_offset": "@ 1 year", "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | Europe/Athens -- now wait for scheduler to run the policies SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * from _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+----------------------------------+----------------------------------+----------------------------------+----------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1026 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Sat Jan 01 16:00:00 2000 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | @ 0 | @ 0 | 1 | 0 | 0 | 0 | 0 | 0 1027 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Sat Jan 01 04:00:00 2000 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | @ 0 | @ 0 | 1 | 0 | 0 | 0 | 0 | 0 1028 | Fri Dec 31 16:00:00.005 1999 PST | Fri Dec 31 16:00:00.005 1999 PST | Fri Jan 21 16:00:00.005 2000 PST | Fri Dec 31 16:00:00.005 1999 PST | t | 1 | @ 0 | @ 0 | 1 | 0 | 0 | 0 | 0 | 0 SELECT show_chunks('test_table_scheduler'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk select hypertable_schema, hypertable_name, chunk_schema, chunk_name, is_compressed from timescaledb_information.chunks ; hypertable_schema | hypertable_name | chunk_schema | chunk_name | is_compressed -----------------------+----------------------------+-----------------------+-------------------+--------------- public | test_table_scheduler | _timescaledb_internal | _hyper_1_5_chunk | t public | test_table_scheduler | _timescaledb_internal | _hyper_1_6_chunk | f public | test_table_scheduler | _timescaledb_internal | _hyper_1_7_chunk | f public | test_table_scheduler | _timescaledb_internal | _hyper_1_8_chunk | f _timescaledb_internal | _materialized_hypertable_2 | _timescaledb_internal | _hyper_2_10_chunk | f select avg_a from cagg_scheduler ORDER BY 1; avg_a -------------------- 3.0000000000000000 4.0000000000000000 -- test the API for add_job too create or replace procedure job_test_fixed(jobid int, config jsonb) language plpgsql as $$ begin raise NOTICE 'this is job_test_fixed'; end $$; \set ON_ERROR_STOP 0 select add_job('job_test_fixed', interval '7 months', initial_start => :'init'::timestamptz + interval '10 ms'); add_job --------- 1029 select add_job('job_test_fixed', interval '7 months', initial_start => :'init'::timestamptz + interval '10 ms', timezone => 'Europe/Athens'); add_job --------- 1030 -- this will fail because the timezone has a bad value select add_job('job_test_fixed', interval '8 weeks', timezone => 'EuRoPe/AmEriCa'); ERROR: time zone "EuRoPe/AmEriCa" not recognized select add_reorder_policy('test_table_scheduler','test_table_scheduler_time_idx', initial_start => :'init'::timestamptz + interval '15 ms', timezone => 'Europe/Berlin'); add_reorder_policy -------------------- 1031 SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select * from _timescaledb_config.bgw_job order by id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+------------+-----------+----------------+----------------------------------+---------------+--------------------------------------------------------------------------------+------------------------+-------------------------------------------+--------------- 1026 | Retention Policy [1026] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | super_user | t | t | Fri Dec 31 16:00:00 1999 PST | 1 | {"drop_after": "@ 2 years", "hypertable_id": 1} | _timescaledb_functions | policy_retention_check | Europe/Berlin 1027 | Columnstore Policy [1027] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | super_user | t | t | Fri Dec 31 16:00:00 1999 PST | 1 | {"hypertable_id": 1, "compress_after": "@ 1 year"} | _timescaledb_functions | policy_compression_check | Europe/Berlin 1028 | Refresh Continuous Aggregate Policy [1028] | @ 21 days | @ 0 | -1 | @ 21 days | _timescaledb_functions | policy_refresh_continuous_aggregate | super_user | t | t | Fri Dec 31 16:00:00.005 1999 PST | 2 | {"end_offset": "@ 2 mons", "start_offset": "@ 1 year", "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | Europe/Athens 1029 | User-Defined Action [1029] | @ 7 mons | @ 0 | -1 | @ 5 mins | public | job_test_fixed | super_user | t | t | Fri Dec 31 16:00:00.01 1999 PST | | | | | 1030 | User-Defined Action [1030] | @ 7 mons | @ 0 | -1 | @ 5 mins | public | job_test_fixed | super_user | t | t | Fri Dec 31 16:00:00.01 1999 PST | | | | | Europe/Athens 1031 | Reorder Policy [1031] | @ 360 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | super_user | t | t | Fri Dec 31 16:00:00.015 1999 PST | 1 | {"index_name": "test_table_scheduler_time_idx", "hypertable_id": 1} | _timescaledb_functions | policy_reorder_check | Europe/Berlin SELECT job_id, date_trunc('second',last_start) AS last_start, date_trunc('second',last_finish) AS last_finish, date_trunc('second',next_start) AS next_start, date_trunc('second',last_successful_finish) as last_successful_finish FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | last_start | last_finish | next_start | last_successful_finish --------+------------------------------+------------------------------+------------------------------+------------------------------ 1026 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Sat Jan 01 16:00:00 2000 PST | Fri Dec 31 16:00:00 1999 PST 1027 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Sat Jan 01 04:00:00 2000 PST | Fri Dec 31 16:00:00 1999 PST 1028 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Fri Jan 21 16:00:00 2000 PST | Fri Dec 31 16:00:00 1999 PST 1029 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Mon Jul 31 16:00:00 2000 PDT | Fri Dec 31 16:00:00 1999 PST 1030 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Mon Jul 31 16:00:00 2000 PDT | Fri Dec 31 16:00:00 1999 PST 1031 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | Sat Jan 15 16:00:00 2000 PST | Fri Dec 31 16:00:00 1999 PST -- test ability to switch from one type of schedule to another CREATE OR REPLACE PROCEDURE job_test(jobid int, config jsonb) language plpgsql as $$ BEGIN PERFORM pg_sleep(0.5); END $$; SELECT add_job('job_test', '8 min', fixed_schedule => false) AS jobid_drifting_1 \gset SELECT add_job('job_test', '8 min', fixed_schedule => false) AS jobid_drifting_2 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT last_finish AS finish_time_drifting_1 FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_drifting_1 \gset -- job is on fixed schedule, so changing the timezone and initial start, has no effect on its next start, -- which should be 8 min after the finish time SELECT next_start AS next_start_drifting_1 FROM alter_job(:jobid_drifting_1, schedule_interval => interval '10 min', timezone => 'Europe/Athens') \gset SELECT :'next_start_drifting_1'::timestamptz - :'finish_time_drifting_1'::timestamptz as diff_interval; diff_interval --------------- @ 10 mins -- this will print a notice about using the current time as initial start -- suppress the notice though as it will lead to flaky tests set client_min_messages = 'warning'; SELECT next_start, initial_start FROM alter_job(:jobid_drifting_1, schedule_interval => interval '10 min', fixed_schedule => true, initial_start => '-infinity') \gset -- should be 10 min SELECT :'next_start'::timestamptz - :'initial_start'::timestamptz; ?column? ----------- @ 10 mins -- if job is not on fixed schedule, and we change it to fixed schedule, then user should also provide initial_start. -- if they don't, a notice is printed that we're using current time as initial start SELECT next_start, initial_start FROM alter_job(:jobid_drifting_2, schedule_interval => interval '10 min', fixed_schedule => true) \gset SELECT :'next_start'::timestamptz - :'initial_start'::timestamptz; ?column? ----------- @ 10 mins reset client_min_messages; -- jobs starting with fixed schedules SELECT add_job('job_test', '1 month', initial_start => '2000-01-01 00:03') as jobid_fixed_1 \gset -- wait for the job to run, then check its next_start: (3 minutes = 180mil microseconds) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(180000005); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT last_finish, next_start from _timescaledb_internal.bgw_job_stat where job_id = :jobid_fixed_1; last_finish | next_start ------------------------------+------------------------------ Sat Jan 01 00:03:00 2000 PST | Tue Feb 01 00:03:00 2000 PST SELECT date_part('hour',next_start)::integer, date_part('minute',next_start)::integer, date_part('second',next_start)::integer FROM alter_job(:jobid_fixed_1, initial_start => '2020-01-01 04:00'); date_part | date_part | date_part -----------+-----------+----------- 4 | 0 | 0 SELECT date_part('hour',next_start)::integer, date_part('minute',next_start)::integer, date_part('second',next_start)::integer FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_fixed_1; date_part | date_part | date_part -----------+-----------+----------- 4 | 0 | 0 -- go from fixed_schedule to drifting schedule SELECT ts_bgw_params_destroy(); ts_bgw_params_destroy ----------------------- SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- SELECT add_job('job_test', '30 sec', initial_start => '2000-01-01 00:00:23') as jobid_fixed_2 \gset -- wait for the job to run, check the next_start, once it's finished, switch to drifting schedule and -- check the next_start again -- wait for 30 seconds to pass SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(30000025); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select * from _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_fixed_2; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+------------------------------+------------------------------+------------------------------+------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1035 | Sat Jan 01 00:00:23 2000 PST | Sat Jan 01 00:00:23 2000 PST | Sat Jan 01 00:00:53 2000 PST | Sat Jan 01 00:00:23 2000 PST | t | 1 | @ 0 | @ 0 | 1 | 0 | 0 | 0 | 0 | 0 UPDATE _timescaledb_internal.bgw_job_stat SET last_finish = last_finish + interval '10 sec', last_successful_finish = last_successful_finish + interval '10 sec' WHERE job_id = :jobid_fixed_2; -- next_start is unchanged SELECT * FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_fixed_2; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+------------------------------+------------------------------+------------------------------+------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1035 | Sat Jan 01 00:00:23 2000 PST | Sat Jan 01 00:00:33 2000 PST | Sat Jan 01 00:00:53 2000 PST | Sat Jan 01 00:00:33 2000 PST | t | 1 | @ 0 | @ 0 | 1 | 0 | 0 | 0 | 0 | 0 -- next start is now updated SELECT alter_job(:jobid_fixed_2, fixed_schedule => false); alter_job ------------------------------------------------------------------------------------------------------------------------------------------ (1035,"@ 30 secs","@ 0",-1,"@ 5 mins",t,,"Sat Jan 01 00:01:03 2000 PST",,f,"Sat Jan 01 00:00:23 2000 PST",,"User-Defined Action [1035]") ������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_job_ddl.out������������������������������������������������0000664�0000000�0000000�00000015205�15100345067�0022425�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test for DDL-like functionality CREATE VIEW my_jobs AS SELECT proc_schema, proc_name, owner FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY proc_schema, proc_name, owner; GRANT SELECT ON my_jobs TO PUBLIC; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION insert_job( application_name NAME, job_type NAME, schedule_interval INTERVAL, max_runtime INTERVAL, retry_period INTERVAL, owner regrole DEFAULT CURRENT_ROLE::regrole, scheduled BOOL DEFAULT true, fixed_schedule BOOL DEFAULT false ) RETURNS INT LANGUAGE SQL SECURITY DEFINER AS $$ INSERT INTO _timescaledb_config.bgw_job(application_name,schedule_interval,max_runtime,max_retries, retry_period,proc_name,proc_schema,owner,scheduled,fixed_schedule) VALUES($1,$3,$4,5,$5,$2,'public',$6,$7,$8) RETURNING id; $$; CREATE PROCEDURE more_magic(job_id INT, config jsonb) LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'done'; END; $$; CREATE PROCEDURE some_magic(job_id INT, config jsonb) LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'done'; END; $$; CREATE USER another_user; SET ROLE another_user; SELECT insert_job('one_job', 'some_magic', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id_2 \gset SELECT insert_job('another_one', 'more_magic', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------- public | more_magic | another_user public | some_magic | another_user -- Test that reassigning to another user privileges does not work for -- a normal user. We test both users with superuser privileges and -- default permissions. \set ON_ERROR_STOP 0 REASSIGN OWNED BY another_user TO :ROLE_CLUSTER_SUPERUSER; ERROR: permission denied to reassign objects REASSIGN OWNED BY another_user TO :ROLE_DEFAULT_PERM_USER; ERROR: permission denied to reassign objects \set ON_ERROR_STOP 1 RESET ROLE; -- Test that renaming a user changes keeps the job assigned to that user. ALTER USER another_user RENAME TO renamed_user; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------- public | more_magic | renamed_user public | some_magic | renamed_user -- Test that renaming the procedure also modifies the entry in the -- jobs table. ALTER PROCEDURE more_magic RENAME TO magic; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------- public | magic | renamed_user public | some_magic | renamed_user -- Test that modifying the schema also modifies the entry in the jobs -- table. CREATE SCHEMA frugal; ALTER PROCEDURE magic SET SCHEMA frugal; ALTER PROCEDURE some_magic SET SCHEMA frugal; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------- frugal | magic | renamed_user frugal | some_magic | renamed_user -- Test that renaming the schema will rename the procedure schema START TRANSACTION; ALTER SCHEMA frugal RENAME TO wicked; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------- wicked | magic | renamed_user wicked | some_magic | renamed_user ROLLBACK; \set VERBOSITY default \set ON_ERROR_STOP 0 SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------- frugal | magic | renamed_user frugal | some_magic | renamed_user -- Test that dropping a user owning a job fails. DROP USER renamed_user; ERROR: role "renamed_user" cannot be dropped because some objects depend on it DETAIL: owner of job 1001 -- Test that dropping the procedure fails since there is a background -- job using it. DROP PROCEDURE frugal.magic; ERROR: cannot drop frugal.magic because background job 1001 depends on it HINT: Use delete_job() to drop the job first. -- Test that re-assigning objects owned by an unknown user still fails REASSIGN OWNED BY renamed_user, unknown_user TO :ROLE_DEFAULT_PERM_USER; ERROR: role "unknown_user" does not exist -- Test that dropping the schema without CASCADE will error out DROP SCHEMA frugal; ERROR: cannot drop schema frugal because other objects depend on it DETAIL: function frugal.magic(integer,jsonb) depends on schema frugal function frugal.some_magic(integer,jsonb) depends on schema frugal HINT: Use DROP ... CASCADE to drop the dependent objects too. \set ON_ERROR_STOP 1 -- Test that reassigning the owned job actually changes the owner of -- the job. START TRANSACTION; REASSIGN OWNED BY renamed_user TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+------------------- frugal | magic | default_perm_user frugal | some_magic | default_perm_user ROLLBACK; -- Test that reassigning to postgres works REASSIGN OWNED BY renamed_user TO :ROLE_CLUSTER_SUPERUSER; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------------- frugal | magic | cluster_super_user frugal | some_magic | cluster_super_user -- Dropping the user now should work. DROP USER renamed_user; -- Dropping using Cascade should work and remove the background worker -- entry as well. START TRANSACTION; SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------------- frugal | magic | cluster_super_user frugal | some_magic | cluster_super_user DROP PROCEDURE frugal.magic CASCADE; NOTICE: drop cascades to job 1001 SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------------- frugal | some_magic | cluster_super_user ROLLBACK; DELETE FROM _timescaledb_config.bgw_job WHERE id = :job_id; -- We should be able to drop the procedure without CASCADE now since -- it is not used by any job. DROP PROCEDURE frugal.magic; -- We should be able to drop the schema with CASCADE despite -- containing a procedure used by a background worker, but this should -- remove the job from the background worker table. SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+------------+-------------------- frugal | some_magic | cluster_super_user DROP SCHEMA frugal CASCADE; NOTICE: drop cascades to job 1000 NOTICE: drop cascades to function frugal.some_magic(integer,jsonb) SELECT * FROM my_jobs; proc_schema | proc_name | owner -------------+-----------+------- �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_job_stat_history.out���������������������������������������0000664�0000000�0000000�00000101125�15100345067�0024413�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE PROCEDURE custom_job_ok(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE INFO 'custom_job'; END $$; CREATE PROCEDURE custom_job_error(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN PERFORM 1/0; END $$; CREATE VIEW job_history_summary AS SELECT job_id, succeeded, count(*) AS record_count FROM _timescaledb_internal.bgw_job_stat_history GROUP BY job_id, succeeded; CREATE VIEW recent_job_history_summary AS SELECT job_id, succeeded, count(*) AS record_count FROM _timescaledb_internal.bgw_job_stat_history WHERE execution_finish > now() - interval '30 days' GROUP BY job_id, succeeded; -- Do not log all jobs, only FAILED executions SHOW timescaledb.enable_job_execution_logging; timescaledb.enable_job_execution_logging ------------------------------------------ off SELECT add_job('custom_job_ok', schedule_interval => interval '1 hour', initial_start := now()) AS job_id_1 \gset SELECT add_job('custom_job_error', schedule_interval => interval '1 hour', initial_start := now()) AS job_id_2 \gset -- Start Background Workers SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t SELECT test.wait_for_job_to_run(:job_id_1, 1); wait_for_job_to_run --------------------- t SELECT test.wait_for_job_to_run(:job_id_2, 1); INFO: wait_for_job_to_run: job execution failed wait_for_job_to_run --------------------- f -- only 1 failure SELECT count(*), succeeded FROM timescaledb_information.job_history WHERE job_id >= 1000 GROUP BY 2 ORDER BY 2; count | succeeded -------+----------- 1 | f SELECT proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id >= 1000 AND succeeded IS FALSE; proc_schema | proc_name | sqlerrcode | err_message -------------+------------------+------------+------------------ public | custom_job_error | 22012 | division by zero -- Check current jobs status SELECT job_id, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id >= 1000 ORDER BY job_id; job_id | job_status | total_runs | total_successes | total_failures --------+------------+------------+-----------------+---------------- 1000 | Scheduled | 1 | 1 | 0 1001 | Scheduled | 1 | 0 | 1 -- Log all executions ALTER SYSTEM SET timescaledb.enable_job_execution_logging TO ON; SELECT pg_reload_conf(); pg_reload_conf ---------------- t -- Reconnect to make sure the GUC is set \c :TEST_DBNAME :ROLE_SUPERUSER SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); scheduled ----------- t SELECT scheduled FROM alter_job(:job_id_2, next_start => now()); scheduled ----------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_1, 2); wait_for_job_to_run --------------------- t SELECT test.wait_for_job_to_run(:job_id_2, 2); INFO: wait_for_job_to_run: job execution failed wait_for_job_to_run --------------------- f -- 1 succeeded 2 failures SELECT count(*), succeeded FROM timescaledb_information.job_history WHERE job_id >= 1000 GROUP BY 2 ORDER BY 2; count | succeeded -------+----------- 2 | f 1 | t -- Check current jobs status SELECT job_id, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id >= 1000 ORDER BY job_id; job_id | job_status | total_runs | total_successes | total_failures --------+------------+------------+-----------------+---------------- 1000 | Scheduled | 2 | 2 | 0 1001 | Scheduled | 2 | 0 | 2 -- Check config changes over time SELECT scheduled FROM alter_job(:job_id_1, config => '{"foo": 1}'::jsonb); scheduled ----------- t SELECT scheduled FROM alter_job(:job_id_2, config => '{"bar": 1}'::jsonb); scheduled ----------- t SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); scheduled ----------- t SELECT scheduled FROM alter_job(:job_id_2, next_start => now()); scheduled ----------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_1, 3); wait_for_job_to_run --------------------- t SELECT test.wait_for_job_to_run(:job_id_2, 3); INFO: wait_for_job_to_run: job execution failed wait_for_job_to_run --------------------- f -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id >= 1000 ORDER BY id, job_id; job_id | pid | proc_schema | proc_name | succeeded | config | sqlerrcode | err_message --------+-----+-------------+------------------+-----------+------------+------------+------------------ 1001 | t | public | custom_job_error | f | | 22012 | division by zero 1000 | t | public | custom_job_ok | t | | | 1001 | t | public | custom_job_error | f | | 22012 | division by zero 1000 | t | public | custom_job_ok | t | {"foo": 1} | | 1001 | t | public | custom_job_error | f | {"bar": 1} | 22012 | division by zero -- Changing the config of one job SELECT scheduled FROM alter_job(:job_id_1, config => '{"foo": 2, "bar": 1}'::jsonb); scheduled ----------- t SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); scheduled ----------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_1, 4); wait_for_job_to_run --------------------- t -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id = :job_id_1 ORDER BY id; job_id | pid | proc_schema | proc_name | succeeded | config | sqlerrcode | err_message --------+-----+-------------+---------------+-----------+----------------------+------------+------------- 1000 | t | public | custom_job_ok | t | | | 1000 | t | public | custom_job_ok | t | {"foo": 1} | | 1000 | t | public | custom_job_ok | t | {"bar": 1, "foo": 2} | | -- Change the job procedure to alter the job configuration during the execution CREATE OR REPLACE PROCEDURE custom_job_ok(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE INFO 'custom_job'; PERFORM alter_job(job_id, config => '{"config_changed_by_job_execution": 1}'::jsonb); END $$; -- Run the job SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); scheduled ----------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_1, 5); wait_for_job_to_run --------------------- t -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id = :job_id_1 ORDER BY id; job_id | pid | proc_schema | proc_name | succeeded | config | sqlerrcode | err_message --------+-----+-------------+---------------+-----------+----------------------------------------+------------+------------- 1000 | t | public | custom_job_ok | t | | | 1000 | t | public | custom_job_ok | t | {"foo": 1} | | 1000 | t | public | custom_job_ok | t | {"bar": 1, "foo": 2} | | 1000 | t | public | custom_job_ok | t | {"config_changed_by_job_execution": 1} | | -- Change the job procedure to alter the job configuration during the execution CREATE OR REPLACE PROCEDURE custom_job_ok(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE INFO 'custom_job'; PERFORM alter_job(job_id, config => '{"change_not_logged": 1}'::jsonb); COMMIT; PERFORM alter_job(job_id, config => '{"only_last_change_is_logged": 1}'::jsonb); COMMIT; END $$; -- Run the job SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); scheduled ----------- t SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_1, 6); wait_for_job_to_run --------------------- t -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id = :job_id_1 ORDER BY id; job_id | pid | proc_schema | proc_name | succeeded | config | sqlerrcode | err_message --------+-----+-------------+---------------+-----------+----------------------------------------+------------+------------- 1000 | t | public | custom_job_ok | t | | | 1000 | t | public | custom_job_ok | t | {"foo": 1} | | 1000 | t | public | custom_job_ok | t | {"bar": 1, "foo": 2} | | 1000 | t | public | custom_job_ok | t | {"config_changed_by_job_execution": 1} | | 1000 | t | public | custom_job_ok | t | {"only_last_change_is_logged": 1} | | -- Alter other information about the job CREATE PROCEDURE custom_job_alter(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE LOG 'custom_job_alter'; END $$; SELECT add_job('custom_job_alter', schedule_interval => interval '1 hour', initial_start := now()) AS job_id_3 \gset SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_3, 1); wait_for_job_to_run --------------------- t SELECT timezone, fixed_schedule, config, schedule_interval FROM alter_job(:job_id_3, timezone => 'America/Sao_Paulo', fixed_schedule => false, config => '{"key": "value"}'::jsonb, schedule_interval => interval '10 min', next_start => now()); timezone | fixed_schedule | config | schedule_interval -------------------+----------------+------------------+------------------- America/Sao_Paulo | f | {"key": "value"} | @ 10 mins SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(:job_id_3, 2); wait_for_job_to_run --------------------- t -- Should return two executions, the second will show the changed values SELECT job_id, succeeded, data->'job'->>'timezone' AS timezone, data->'job'->>'fixed_schedule' AS fixed_schedule, data->'job'->>'schedule_interval' AS schedule_interval, data->'job'->'config' AS config FROM _timescaledb_internal.bgw_job_stat_history WHERE job_id = :job_id_3 ORDER BY id; job_id | succeeded | timezone | fixed_schedule | schedule_interval | config --------+-----------+-------------------+----------------+-------------------+------------------ 1002 | t | | true | 01:00:00 | 1002 | t | America/Sao_Paulo | false | 00:10:00 | {"key": "value"} SELECT delete_job(:job_id_1); delete_job ------------ SELECT delete_job(:job_id_2); delete_job ------------ SELECT delete_job(:job_id_3); delete_job ------------ ALTER SYSTEM RESET timescaledb.enable_job_execution_logging; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER -- The GUC is PGC_SIGHUP context so only ALTER SYSTEM is allowed \set ON_ERROR_STOP 0 SHOW timescaledb.enable_job_execution_logging; timescaledb.enable_job_execution_logging ------------------------------------------ off SET timescaledb.enable_job_execution_logging TO OFF; ERROR: parameter "timescaledb.enable_job_execution_logging" cannot be changed now SHOW timescaledb.enable_job_execution_logging; timescaledb.enable_job_execution_logging ------------------------------------------ off ALTER DATABASE :TEST_DBNAME SET timescaledb.enable_job_execution_logging TO ON; ERROR: parameter "timescaledb.enable_job_execution_logging" cannot be changed now SHOW timescaledb.enable_job_execution_logging; timescaledb.enable_job_execution_logging ------------------------------------------ off \set ON_ERROR_STOP 1 SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t -- Test bgw_job_stat_history retention job -- Alter the drop_after interval to be fixed (30 days) to ensure tests are deterministic SELECT config AS config FROM _timescaledb_config.bgw_job WHERE id = 3 \gset SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{drop_after}', '"30 days"')); config ---------------------------------------------------------------------------------------- {"drop_after": "30 days", "max_failures_per_job": 1000, "max_successes_per_job": 1000} -- These configuration should fail since they are not valid. \set ON_ERROR_STOP 0 SELECT config FROM alter_job(3, config => :'config'::jsonb - 'drop_after'); ERROR: drop_after interval not provided SELECT config FROM alter_job(3, config => :'config'::jsonb - 'max_successes_per_job'); ERROR: max_successes_per_job not provided SELECT config FROM alter_job(3, config => :'config'::jsonb - 'max_failures_per_job'); ERROR: max_failures_per_job not provided SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_successes_per_job}', '0')); ERROR: max_successes_per_job has to be at least 10 SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_failures_per_job}', '0')); ERROR: max_failures_per_job has to be at least 10 SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_successes_per_job}', '"none"')); ERROR: invalid input syntax for type integer: "none" SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_failures_per_job}', '"none"')); ERROR: invalid input syntax for type integer: "none" \set ON_ERROR_STOP 1 -- Test 1 TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Insert test data: jobs every 15 minutes from 3 months ago to today -- Each job runs for 5 minutes (job_id=100, pid=12345) -- Fix NOW to ensure the tests are deterministic INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 100 as job_id, 12345 as pid, true as succeeded, ts as execution_start, ts + interval '5 minutes' as execution_finish, '{}'::jsonb as data FROM generate_series(now() - interval '90 days', now(), interval '15 minutes') as ts; -- Check data after insertion select * from job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 100 | t | 8641 -- Test the retention job (job id 3) CALL run_job(3); -- Check data after retention SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 100 | t | 1000 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 100 | t | 1000 -- Cleanup TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 2: Empty table (no job history) CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- -- Test 3: Odd number of entries (5 entries) INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (301, 3001, true, now() - interval '60 days', now() - interval '60 days' + interval '5 minutes', '{}'), (302, 3002, true, now() - interval '6 weeks', now() - interval '6 weeks' + interval '5 minutes', '{}'), (303, 3003, true, now() - interval '30 days', now() - interval '30 days' + interval '5 minutes', '{}'), (301, 3001, true, now() - interval '2 weeks', now() - interval '2 weeks' + interval '5 minutes', '{}'), (304, 3004, true, now() - interval '1 week', now() - interval '1 week' + interval '5 minutes', '{}'); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 301 | t | 2 302 | t | 1 303 | t | 1 304 | t | 1 CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 301 | t | 1 303 | t | 1 304 | t | 1 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 301 | t | 1 303 | t | 1 304 | t | 1 TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 4: Even number of entries (6 entries) INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (401, 4001, true, now() - interval '90 days', now() - interval '90 days' + interval '5 minutes', '{}'), (402, 4002, true, now() - interval '60 days', now() - interval '60 days' + interval '5 minutes', '{}'), (403, 4003, true, now() - interval '6 weeks', now() - interval '6 weeks' + interval '5 minutes', '{}'), (401, 4001, true, now() - interval '30 days', now() - interval '30 days' + interval '5 minutes', '{}'), (404, 4004, true, now() - interval '2 weeks', now() - interval '2 weeks' + interval '5 minutes', '{}'), (402, 4002, true, now() - interval '1 week', now() - interval '1 week' + interval '5 minutes', '{}'); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 403 | t | 1 401 | t | 2 404 | t | 1 402 | t | 2 CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 401 | t | 1 404 | t | 1 402 | t | 1 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 401 | t | 1 404 | t | 1 402 | t | 1 TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 5: Missing middle job id (gaps in sequence) INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 501 + (row_number() over () % 3) as job_id, 5001 + (row_number() over () % 3) as pid, true as succeeded, ts as execution_start, ts + interval '5 minutes' as execution_finish, '{}'::jsonb as data FROM generate_series(now() - interval '60 days', now() - interval '1 week', interval '1 week') as ts; -- Delete some records to create gaps DELETE FROM _timescaledb_internal.bgw_job_stat_history WHERE id IN (SELECT id FROM _timescaledb_internal.bgw_job_stat_history ORDER BY id LIMIT 2 OFFSET 2); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 503 | t | 3 502 | t | 2 501 | t | 1 CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 503 | t | 1 502 | t | 1 501 | t | 1 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 503 | t | 1 502 | t | 1 501 | t | 1 TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 6: All records older than retention period INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (601, 6001, true, now() - interval '90 days', now() - interval '90 days' + interval '5 minutes', '{}'), (602, 6002, true, now() - interval '60 days', now() - interval '60 days' + interval '5 minutes', '{}'), (601, 6001, true, now() - interval '6 weeks', now() - interval '6 weeks' + interval '5 minutes', '{}'); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 601 | t | 2 602 | t | 1 CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 601 | t | 2 602 | t | 1 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 7: No records older than retention period INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (701, 7001, true, now() - interval '1 week', now() - interval '1 week' + interval '7 minutes', '{}'), (702, 7002, true, now() - interval '6 days', now() - interval '6 days' + interval '7 minutes', '{}'), (703, 7003, true, now() - interval '7 days', now() - interval '7 days' + interval '7 minutes', '{}'), (701, 7001, true, now() - interval '4 days', now() - interval '4 days' + interval '7 minutes', '{}'); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 701 | t | 2 702 | t | 1 703 | t | 1 CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 701 | t | 2 702 | t | 1 703 | t | 1 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 701 | t | 2 702 | t | 1 703 | t | 1 TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 8: No records older than retention period and not more than -- the expected number of successes and failures per job. SELECT config AS config FROM _timescaledb_config.bgw_job WHERE id = 3 \gset SELECT config FROM alter_job(3, config => jsonb_set(jsonb_set(:'config', '{max_failures_per_job}', '15'), '{max_successes_per_job}', '10')); config ------------------------------------------------------------------------------------ {"drop_after": "30 days", "max_failures_per_job": 15, "max_successes_per_job": 10} INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (803, 7003, true, now() - interval '7 days', now() - interval '7 days' + interval '7 minutes', '{}'), (801, 7001, true, now() - interval '4 days', now() - interval '4 days' + interval '7 minutes', '{}'); INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 801, 7001, true, now() - format('%s hour', hours)::interval, now() - interval '1 week' + interval '7 minutes', '{}' FROM generate_series(1,20) hours; INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 802, 7001, false, now() - format('%s minutes', hours)::interval, now() - interval '6 days' + interval '7 minutes', '{}' FROM generate_series(1,20) hours; SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 801 | t | 21 803 | t | 1 802 | f | 20 CALL run_job(3); SELECT * FROM job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 801 | t | 10 803 | t | 1 802 | f | 15 -- Verify only recent records remain SELECT * FROM recent_job_history_summary; job_id | succeeded | record_count --------+-----------+-------------- 801 | t | 10 803 | t | 1 802 | f | 15 -- Cleanup TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test that lock_timeout can be configured SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{lock_timeout}', '"1s"')); config -------------------------------------------------------------------------------------------------------------- {"drop_after": "30 days", "lock_timeout": "1s", "max_failures_per_job": 1000, "max_successes_per_job": 1000} CALL run_job(3); -- Test the job_history_bsearch function directly as well -- It returns the first element where execution_finish >= search_point or NULL if no such element exists \set NOW '2025-08-15 12:34:00' -- No elements in table SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 month'); job_history_bsearch --------------------- -- Single element INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 601, 6001, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'); -- Return the single element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 month'); job_history_bsearch --------------------- 5 -- Return NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 week'); job_history_bsearch --------------------- TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Two elements INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 701, 7001, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (6, 702, 7002, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'); -- Returns the first element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 month'); job_history_bsearch --------------------- 5 -- Returns the second element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks'); job_history_bsearch --------------------- 6 -- Returns NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 days'); job_history_bsearch --------------------- TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Odd number of elements INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 801, 8001, true, :'NOW'::timestamptz - interval '5 weeks', :'NOW'::timestamptz - interval '5 weeks' + interval '5 minutes', '{}'), (6, 802, 8002, true, :'NOW'::timestamptz - interval '4 weeks', :'NOW'::timestamptz - interval '4 weeks' + interval '5 minutes', '{}'), (7, 803, 8003, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (8, 804, 8004, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'), (9, 805, 8005, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'); -- Returns the first element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '6 weeks'); job_history_bsearch --------------------- 5 -- Returns the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 weeks'); job_history_bsearch --------------------- 7 -- Returns one after the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks 3 days'); job_history_bsearch --------------------- 8 -- Returns NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 days'); job_history_bsearch --------------------- TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Even number of elements INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 902, 9002, true, :'NOW'::timestamptz - interval '5 weeks', :'NOW'::timestamptz - interval '5 weeks' + interval '5 minutes', '{}'), (6, 903, 9003, true, :'NOW'::timestamptz - interval '4 weeks', :'NOW'::timestamptz - interval '4 weeks' + interval '5 minutes', '{}'), (7, 904, 9004, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (8, 905, 9005, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'), (9, 906, 9006, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'), (10, 907, 9007, true, :'NOW'::timestamptz - interval '3 days', :'NOW'::timestamptz - interval '3 days' + interval '5 minutes', '{}'); -- Returns the first element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '6 weeks'); job_history_bsearch --------------------- 5 -- Returns the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 weeks'); job_history_bsearch --------------------- 7 -- Returns one after the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks 3 days'); job_history_bsearch --------------------- 8 -- Returns NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 days'); job_history_bsearch --------------------- TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- With gaps in id INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (10, 1001, 10001, true, :'NOW'::timestamptz - interval '5 weeks', :'NOW'::timestamptz - interval '5 weeks' + interval '5 minutes', '{}'), (11, 1002, 10002, true, :'NOW'::timestamptz - interval '4 weeks', :'NOW'::timestamptz - interval '4 weeks' + interval '5 minutes', '{}'), (13, 1003, 10003, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (15, 1004, 10004, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'), (16, 1005, 10005, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'); -- Returns id before the gap SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 weeks 3 days') AS result_gap_trigger1; result_gap_trigger1 --------------------- 13 -- Returns id after the gap SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks 3 days') AS result_gap_trigger2; result_gap_trigger2 --------------------- 15 -- Returns second element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '4 weeks 3 days') AS result_gap_trigger3; result_gap_trigger3 --------------------- 11 -- Final cleanup TRUNCATE _timescaledb_internal.bgw_job_stat_history; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_job_stat_history_errors.out��������������������������������0000664�0000000�0000000�00000022246�15100345067�0026015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set client_min_messages TO NOTICE; create or replace procedure job_fail(jobid int, config jsonb) language plpgsql as $$ begin perform pg_sleep(2); raise exception 'raising an exception'; end $$; -- very simple case: job that raises an exception select add_job('job_fail', '4 minutes') as jobf_id \gset -- test jobs that try to update concurrently CREATE TABLE custom_log ( a int, b int, msg text ); insert into custom_log values (0, 0, 'msg0'); ALTER SYSTEM SET DEFAULT_TRANSACTION_ISOLATION TO 'serializable'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t -- Reconnect to make sure the GUC is set \c :TEST_DBNAME :ROLE_SUPERUSER -- test a concurrent update CREATE OR REPLACE PROCEDURE custom_proc1(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE custom_log set msg = 'msg1' where msg = 'msg0'; perform pg_sleep(5); COMMIT; END $$; CREATE OR REPLACE PROCEDURE custom_proc2(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE custom_log set msg = 'msg2' where msg = 'msg0'; COMMIT; END $$; select add_job('custom_proc1', '2 min', initial_start => now()); add_job --------- 1001 -- to make sure custom_log is first updated by custom_proc_1 select add_job('custom_proc2', '2 min', initial_start => now() + interval '2 seconds'); add_job --------- 1002 SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t -- enough time to for job_fail to fail select pg_sleep(5); pg_sleep ---------- select job_id, data->'job'->>'proc_name' as proc_name, data->'error_data'->>'message' as err_message, data->'error_data'->>'sqlerrcode' as sqlerrcode from _timescaledb_internal.bgw_job_stat_history where job_id = :jobf_id and succeeded is false; job_id | proc_name | err_message | sqlerrcode --------+-----------+----------------------+------------ 1000 | job_fail | raising an exception | P0001 select delete_job(:jobf_id); delete_job ------------ select pg_sleep(5); pg_sleep ---------- -- exclude internal jobs select job_id, data->'job'->>'proc_name' as proc_name, data->'error_data'->>'message' as err_message, data->'error_data'->>'sqlerrcode' as sqlerrcode from _timescaledb_internal.bgw_job_stat_history WHERE job_id >= 1000 and succeeded is false; job_id | proc_name | err_message | sqlerrcode --------+--------------+-----------------------------------------------------+------------ 1000 | job_fail | raising an exception | P0001 1002 | custom_proc2 | could not serialize access due to concurrent update | 40001 ALTER SYSTEM RESET DEFAULT_TRANSACTION_ISOLATION; SELECT pg_reload_conf(); pg_reload_conf ---------------- t -- Reconnect to make sure the GUC is set \c :TEST_DBNAME :ROLE_SUPERUSER -- test the retention job SELECT next_start FROM alter_job(3, next_start => '2060-01-01 00:00:00+00'::timestamptz); next_start ------------------------------ Wed Dec 31 16:00:00 2059 PST DELETE FROM _timescaledb_internal.bgw_job_stat_history; INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (123, 12345, false, '2000-01-01 00:00:00+00'::timestamptz, '2000-01-01 00:00:10+00'::timestamptz, '{}'), (456, 45678, false, '2000-01-01 00:00:20+00'::timestamptz, '2000-01-01 00:00:40+00'::timestamptz, '{}'), -- not older than a month (123, 23456, false, '2050-01-01 00:00:00+00'::timestamptz, '2050-01-01 00:00:10+00'::timestamptz, '{}'); -- 3 rows in the table before policy runs SELECT job_id, pid, succeeded, execution_start, execution_finish, data FROM _timescaledb_internal.bgw_job_stat_history WHERE succeeded IS FALSE; job_id | pid | succeeded | execution_start | execution_finish | data --------+-------+-----------+------------------------------+------------------------------+------ 123 | 12345 | f | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:10 1999 PST | {} 456 | 45678 | f | Fri Dec 31 16:00:20 1999 PST | Fri Dec 31 16:00:40 1999 PST | {} 123 | 23456 | f | Fri Dec 31 16:00:00 2049 PST | Fri Dec 31 16:00:10 2049 PST | {} -- drop all job_stats for the retention job DELETE FROM _timescaledb_internal.bgw_job_stat WHERE job_id = 3; SELECT FROM alter_job(3, next_start => now()); -- SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t SELECT test.wait_for_job_to_run(3, 1); wait_for_job_to_run --------------------- t -- only the last row remains SELECT job_id, pid, succeeded, execution_start, execution_finish, data FROM _timescaledb_internal.bgw_job_stat_history WHERE succeeded IS FALSE; job_id | pid | succeeded | execution_start | execution_finish | data --------+-------+-----------+------------------------------+------------------------------+------ 123 | 23456 | f | Fri Dec 31 16:00:00 2049 PST | Fri Dec 31 16:00:10 2049 PST | {} -- test failure when starting jobs \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t -- Job didn't finish yet and Crash detected DELETE FROM _timescaledb_internal.bgw_job_stat_history; INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (1, NULL, NULL, '2000-01-01 00:00:00+00'::timestamptz, NULL, '{}'), -- Crash server detected (2, 2222, false, '2000-01-01 00:00:00+00'::timestamptz, NULL, '{}'), -- Didn't finished yet (3, 3333, false, '2000-01-01 00:00:00+00'::timestamptz, '2000-01-01 01:00:00+00'::timestamptz, '{}'), -- Finish with ERROR (4, 4444, true, '2000-01-01 00:00:00+00'::timestamptz, '2000-01-01 01:00:00+00'::timestamptz, '{}'); -- Finish with SUCCESS SELECT job_id, pid, succeeded, start_time, finish_time, config, err_message FROM timescaledb_information.job_history ORDER BY job_id; job_id | pid | succeeded | start_time | finish_time | config | err_message --------+------+-----------+------------------------------+------------------------------+--------+------------------------------------- 1 | | | Fri Dec 31 16:00:00 1999 PST | | | job crash detected, see server logs 2 | 2222 | f | Fri Dec 31 16:00:00 1999 PST | | | 3 | 3333 | f | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 17:00:00 1999 PST | | 4 | 4444 | t | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 17:00:00 1999 PST | | SELECT job_id, pid, start_time, finish_time, err_message FROM timescaledb_information.job_errors ORDER BY job_id; job_id | pid | start_time | finish_time | err_message --------+------+------------------------------+------------------------------+------------------------------------- 1 | | Fri Dec 31 16:00:00 1999 PST | | job crash detected, see server logs 2 | 2222 | Fri Dec 31 16:00:00 1999 PST | | 3 | 3333 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 17:00:00 1999 PST | DELETE FROM _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_internal.bgw_job_stat_history; DELETE FROM _timescaledb_config.bgw_job CASCADE; SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t \set VERBOSITY default -- Setup Jobs DO $TEST$ DECLARE stmt TEXT; njobs INT := 26; BEGIN RAISE INFO 'Creating % jobs', njobs; FOR stmt IN SELECT format('CREATE PROCEDURE custom_job%s(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN PERFORM pg_sleep(0.1); END; $$', i) FROM generate_series(1, njobs) AS i LOOP EXECUTE stmt; END LOOP; RAISE INFO 'Scheduling % jobs', njobs; PERFORM add_job(format('custom_job%s', i)::regproc, schedule_interval => interval '1 hour', initial_start := now()) FROM generate_series(1, njobs) AS i; END; $TEST$; INFO: Creating 26 jobs INFO: Scheduling 26 jobs SELECT _timescaledb_functions.restart_background_workers(); restart_background_workers ---------------------------- t -- Wait for jobs to run DO $TEST$ DECLARE njobs INT := 26; BEGIN RAISE INFO 'Waiting for the % jobs to run', njobs; SET LOCAL client_min_messages TO WARNING; PERFORM test.wait_for_job_to_run_or_fail(id) FROM _timescaledb_config.bgw_job WHERE id >= 1000; END; $TEST$; INFO: Waiting for the 26 jobs to run SELECT count(*) > 0 FROM timescaledb_information.job_history WHERE succeeded IS FALSE AND err_message ~ 'failed to start job'; ?column? ---------- t SELECT count(*) > 0 FROM timescaledb_information.job_errors WHERE err_message ~ 'failed to start job'; ?column? ---------- t \set VERBOSITY terse \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_job_stat_history_errors_permissions.out��������������������0000664�0000000�0000000�00000013441�15100345067�0030445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Table to update concurrently to generate error message CREATE TABLE my_table (a int, b int); INSERT INTO my_table VALUES (0, 0); GRANT ALL ON my_table TO PUBLIC; ALTER SYSTEM SET DEFAULT_TRANSACTION_ISOLATION TO 'serializable'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE OR REPLACE PROCEDURE job_fail(jobid int, config jsonb) AS $$ BEGIN RAISE EXCEPTION 'raising an exception'; END $$ LANGUAGE plpgsql; SELECT add_job('job_fail', '4 minutes', initial_start => now()) as job_fail_id \gset CREATE OR REPLACE PROCEDURE custom_proc1(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE my_table SET b = 1 WHERE a = 0; PERFORM pg_sleep(5); COMMIT; END $$; SELECT add_job('custom_proc1', '2 min', initial_start => now()) as custom_proc1_id \gset SET ROLE :ROLE_DEFAULT_PERM_USER_2; CREATE OR REPLACE PROCEDURE custom_proc2(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE my_table SET b = 2 WHERE a = 0; PERFORM pg_sleep(5); COMMIT; END $$; -- to make sure custom_log is first updated by custom_proc_1 select add_job('custom_proc2', '2 min', initial_start => now() + interval '1 seconds') as custom_proc2_id \gset SET ROLE :ROLE_SUPERUSER; SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t SELECT pg_sleep(6); pg_sleep ---------- \d timescaledb_information.job_errors View "timescaledb_information.job_errors" Column | Type | Collation | Nullable | Default -------------+--------------------------+-----------+----------+--------- job_id | integer | | | proc_schema | text | | | proc_name | text | | | pid | integer | | | start_time | timestamp with time zone | | | finish_time | timestamp with time zone | | | sqlerrcode | text | | | err_message | text | | | -- We add a few entries without a matching job id, so that we get a -- null owner. Note that the second entry does not have a message -- defined, so it will print a standardized message assuming that the -- job crashed. \set start '2000-01-01 00:00:00+00' \set finish '2000-01-01 00:00:10+00' INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (11111, 12345, false, :'start'::timestamptz, :'finish'::timestamptz, '{"error_data": {"message": "not an error"}}'), (22222, 45678, false, :'start'::timestamptz, NULL, '{}'), -- Started and didn't finished yet (33333, NULL, NULL, :'start'::timestamptz, NULL, NULL); -- Crash detected cause not assigned an PID -- We check the log as different users and should only see what we -- have permissions to see. We only bother about jobs at 1000 or -- larger since the standard jobs are flaky. SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT job_id, proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_errors WHERE job_id >= 1000 ORDER BY job_id; job_id | proc_schema | proc_name | sqlerrcode | err_message --------+-------------+--------------+------------+----------------------------------------------------- 1000 | public | job_fail | P0001 | raising an exception 1002 | public | custom_proc2 | 40001 | could not serialize access due to concurrent update 11111 | | | | not an error 22222 | | | | SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT job_id, proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_errors WHERE job_id >= 1000 ORDER BY job_id; job_id | proc_schema | proc_name | sqlerrcode | err_message --------+-------------+--------------+------------+----------------------------------------------------- 1000 | public | job_fail | P0001 | raising an exception 1002 | public | custom_proc2 | 40001 | could not serialize access due to concurrent update 11111 | | | | not an error 22222 | | | | SET ROLE :ROLE_SUPERUSER; SELECT job_id, proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_errors WHERE job_id >= 1000 ORDER BY job_id; job_id | proc_schema | proc_name | sqlerrcode | err_message --------+-------------+--------------+------------+----------------------------------------------------- 1000 | public | job_fail | P0001 | raising an exception 1002 | public | custom_proc2 | 40001 | could not serialize access due to concurrent update 11111 | | | | not an error 22222 | | | | 33333 | | | | job crash detected, see server logs SELECT delete_job(:custom_proc2_id); delete_job ------------ SELECT delete_job(:custom_proc1_id); delete_job ------------ SELECT delete_job(:job_fail_id); delete_job ------------ ALTER SYSTEM RESET DEFAULT_TRANSACTION_ISOLATION; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_policy.out�������������������������������������������������0000664�0000000�0000000�00000072074�15100345067�0022336�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE FUNCTION reorder_called(chunk_id INT) RETURNS BOOL AS $$ SELECT indisclustered FROM _timescaledb_catalog.chunk ch JOIN pg_index i on indrelid = format('%I.%I',ch.schema_name,ch.table_name)::regclass WHERE ch.id = chunk_id; $$ LANGUAGE SQL; CREATE TABLE test_table(time timestamptz, chunk_id int); SELECT create_hypertable('test_table', 'time'); create_hypertable ------------------------- (1,public,test_table,t) -- These inserts should create 5 different chunks INSERT INTO test_table VALUES (now() - INTERVAL '3 weeks', 1); INSERT INTO test_table VALUES (now(), 2); INSERT INTO test_table VALUES (now() - INTERVAL '5 months', 3); INSERT INTO test_table VALUES (now() - INTERVAL '3 months', 4); INSERT INTO test_table VALUES (now() - INTERVAL '8 months', 5); SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table'; count ------- 5 -- Make sure reorder correctly selects chunks to reorder -- by starting with oldest chunks select add_reorder_policy('test_table', 'test_table_time_idx') as reorder_job_id \gset select * from _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------+------------------------+----------------------+---------- 1000 | Reorder Policy [1000] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 1 | {"index_name": "test_table_time_idx", "hypertable_id": 1} | _timescaledb_functions | policy_reorder_check | select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- -- Make a manual calls to reorder: make sure the correct chunk is called -- Chunk 5 should be first CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 -- Confirm that reorder was called on the correct chunk Oid SELECT reorder_called(5); reorder_called ---------------- t -- Chunk 3 is next CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 1000 | 3 | 1 SELECT reorder_called(3); reorder_called ---------------- t -- Chunk 4 is next CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 1000 | 3 | 1 1000 | 4 | 1 SELECT reorder_called(4); reorder_called ---------------- t -- The following calls should not reorder any chunk, because they're all too new CALL run_job(:reorder_job_id); NOTICE: no chunks need reordering for hypertable public.test_table select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 1000 | 3 | 1 1000 | 4 | 1 CALL run_job(:reorder_job_id); NOTICE: no chunks need reordering for hypertable public.test_table select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 1000 | 3 | 1 1000 | 4 | 1 INSERT INTO test_table VALUES (now() - INTERVAL '7 days', 6); -- This call should reorder chunk 1 CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 1000 | 3 | 1 1000 | 4 | 1 1000 | 1 | 1 SELECT reorder_called(1); reorder_called ---------------- t -- Should not reorder anything, because all chunks are too new CALL run_job(:reorder_job_id); NOTICE: no chunks need reordering for hypertable public.test_table select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1000 | 5 | 1 1000 | 3 | 1 1000 | 4 | 1 1000 | 1 | 1 select remove_reorder_policy('test_table'); remove_reorder_policy ----------------------- -- Now do drop_chunks test select add_retention_policy('test_table', INTERVAL '4 months', true) as drop_chunks_job_id \gset SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table'; count ------- 6 -- Now simulate drop_chunks running automatically by calling it explicitly CALL run_job(:drop_chunks_job_id); -- Should have 4 chunks left SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset before_ select :before_count=4; ?column? ---------- t -- Make sure this second call does nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset after_ -- Should be true select :before_count=:after_count; ?column? ---------- t INSERT INTO test_table VALUES (now() - INTERVAL '2 weeks', 1); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset before_ -- This call should also do nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset after_ -- Should be true select :before_count=:after_count; ?column? ---------- t select remove_retention_policy('test_table'); remove_retention_policy ------------------------- -- Now test reorder chunk selection when there is space partitioning TRUNCATE test_table; SELECT add_dimension('public.test_table', 'chunk_id', 2); add_dimension ---------------------------------- (2,public,test_table,chunk_id,t) INSERT INTO test_table VALUES (now() - INTERVAL '3 weeks', 1); INSERT INTO test_table VALUES (now(), 2); INSERT INTO test_table VALUES (now() - INTERVAL '5 months', 3); INSERT INTO test_table VALUES (now() - INTERVAL '3 months', 4); INSERT INTO test_table VALUES (now() - INTERVAL '3 months', -4); INSERT INTO test_table VALUES (now() - INTERVAL '8 months', 5); INSERT INTO test_table VALUES (now() - INTERVAL '8 months', -5); select add_reorder_policy('test_table', 'test_table_time_idx') as reorder_job_id \gset -- Should be nothing in the chunk_stats table select count(*) from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id; count ------- 0 -- Make a manual calls to reorder: make sure the correct (oldest) chunk is called select chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1002 | 13 | 1 -- Confirm that reorder was called on the correct chunk Oid SELECT reorder_called(:oldest_chunk_id); reorder_called ---------------- t -- Now run reorder again and pick the next oldest chunk select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1002 | 14 | 1 -- Confirm that reorder was called on the correct chunk Oid SELECT reorder_called(:oldest_chunk_id); reorder_called ---------------- t -- Again select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1002 | 10 | 1 SELECT reorder_called(:oldest_chunk_id); reorder_called ---------------- t -- Again select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1002 | 11 | 1 SELECT reorder_called(:oldest_chunk_id); reorder_called ---------------- t -- Again select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1002 | 12 | 1 SELECT reorder_called(:oldest_chunk_id); reorder_called ---------------- t -- Ran out of chunks, so should be a noop CALL run_job(:reorder_job_id); NOTICE: no chunks need reordering for hypertable public.test_table -- Corner case: when there are no recent-enough chunks to reorder, -- DO NOT reorder any new chunks created by space partitioning. -- We only want to reorder when new dimension_slices on time are created. INSERT INTO test_table VALUES (now() - INTERVAL '5 months', -5); INSERT INTO test_table VALUES (now() - INTERVAL '3 weeks', -5); INSERT INTO test_table VALUES (now(), -25); -- Should be noop CALL run_job(:reorder_job_id); NOTICE: no chunks need reordering for hypertable public.test_table -- But if we create a new time dimension, reorder it INSERT INTO test_table VALUES (now() - INTERVAL '1 year', 1); select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1002 | 16 | 1 SELECT reorder_called(:oldest_chunk_id); reorder_called ---------------- t -- Should be noop again CALL run_job(:reorder_job_id); NOTICE: no chunks need reordering for hypertable public.test_table CREATE TABLE test_table_int(time bigint, junk int); CREATE TABLE test_overflow_smallint(time smallint, junk int); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 1); create_hypertable ----------------------------- (2,public,test_table_int,t) SELECT create_hypertable('test_overflow_smallint', 'time', chunk_time_interval => 1); create_hypertable ------------------------------------- (3,public,test_overflow_smallint,t) create or replace function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; create or replace function dummy_now2() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 2::BIGINT'; create or replace function overflow_now() returns SMALLINT LANGUAGE SQL IMMUTABLE as 'SELECT 32767::SMALLINT'; CREATE TABLE test_table_perm(time timestamp PRIMARY KEY); SELECT create_hypertable('test_table_perm', 'time', chunk_time_interval => 1); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices WARNING: unexpected interval: smaller than one second create_hypertable ------------------------------ (4,public,test_table_perm,t) \set ON_ERROR_STOP 0 -- we cannot add a drop_chunks policy on a table whose open dimension is not time and no now_func is set select add_retention_policy('test_table_int', INTERVAL '4 months', true); ERROR: invalid value for parameter drop_after \set ON_ERROR_STOP 1 INSERT INTO test_table_int VALUES (-2, -2), (-1, -1), (0,0), (1, 1), (2, 2), (3, 3); \c :TEST_DBNAME :ROLE_SUPERUSER; CREATE USER unprivileged; \c :TEST_DBNAME unprivileged -- should fail as the user has no permissions on the table \set ON_ERROR_STOP 0 select set_integer_now_func('test_table_int', 'dummy_now'); ERROR: must be owner of hypertable "test_table_int" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER; DROP USER unprivileged; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select set_integer_now_func('test_table_int', 'dummy_now'); set_integer_now_func ---------------------- select * from test_table_int; time | junk ------+------ -2 | -2 -1 | -1 0 | 0 1 | 1 2 | 2 3 | 3 SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int'; count ------- 6 select add_retention_policy('test_table_int', 1, true) as drop_chunks_job_id \gset -- Now simulate drop_chunks running automatically by calling it explicitly CALL run_job(:drop_chunks_job_id); select * from test_table_int; time | junk ------+------ 0 | 0 1 | 1 2 | 2 3 | 3 -- Should have 4 chunks left SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset before_ select :before_count=4; ?column? ---------- t -- Make sure this second call does nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ -- Should be true select :before_count=:after_count; ?column? ---------- t INSERT INTO test_table_int VALUES (42, 42); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset before_ -- This call should also do nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ -- Should be true select :before_count=:after_count; ?column? ---------- t INSERT INTO test_table_int VALUES (-1, -1); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset add_one_ select :before_count+1=:add_one_count; ?column? ---------- t CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ -- (-1,-1) was in droping range so it should be dropped by background job select :before_count=:after_count; ?column? ---------- t select set_integer_now_func('test_table_int', 'dummy_now2', replace_if_exists=>true); set_integer_now_func ---------------------- select * from test_table_int; time | junk ------+------ 0 | 0 1 | 1 2 | 2 3 | 3 42 | 42 CALL run_job(:drop_chunks_job_id); -- added one to now() so time entry with value 0 should be dropped now SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ select :before_count=:after_count+1; ?column? ---------- t select * from test_table_int; time | junk ------+------ 1 | 1 2 | 2 3 | 3 42 | 42 -- make the now() function invalid -- returns INT and not BIGINT drop function dummy_now2(); create or replace function dummy_now2() returns INT LANGUAGE SQL IMMUTABLE as 'SELECT 2::INT'; \set ON_ERROR_STOP 0 CALL run_job(:drop_chunks_job_id); ERROR: invalid integer_now function \set ON_ERROR_STOP 1 -- test the expected use case of set_integer_now_func create function nowstamp() returns bigint language sql STABLE as 'SELECT extract(epoch from now())::BIGINT'; select set_integer_now_func('test_table_int', 'nowstamp', replace_if_exists=>true); set_integer_now_func ---------------------- CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ select :after_count=0; ?column? ---------- t -- test the case when now()-interval overflows select set_integer_now_func('test_overflow_smallint', 'overflow_now'); set_integer_now_func ---------------------- select add_retention_policy('test_overflow_smallint', -2) as drop_chunks_job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:drop_chunks_job_id); ERROR: integer time overflow \set ON_ERROR_STOP 1 -- test the case when partitioning function and now function are set. create table part_time_now_func(time float8, temp float8); create or replace function time_partfunc(unixtime float8) returns bigint language plpgsql immutable as $body$ declare retval bigint; begin retval := unixtime::bigint; raise notice 'time value for % is %', unixtime, retval; return retval; end $body$; create or replace function dummy_now() returns bigint language sql immutable as 'select 2::bigint'; select create_hypertable('part_time_now_func', 'time', time_partitioning_func => 'time_partfunc', chunk_time_interval=>1); create_hypertable --------------------------------- (5,public,part_time_now_func,t) insert into part_time_now_func values (1.1, 23.4), (2.2, 22.3), (3.3, 42.3); NOTICE: time value for 1.1 is 1 NOTICE: time value for 1.1 is 1 NOTICE: time value for 1.1 is 1 NOTICE: time value for 1.1 is 1 NOTICE: time value for 2.2 is 2 NOTICE: time value for 2.2 is 2 NOTICE: time value for 2.2 is 2 NOTICE: time value for 2.2 is 2 NOTICE: time value for 3.3 is 3 NOTICE: time value for 3.3 is 3 NOTICE: time value for 3.3 is 3 NOTICE: time value for 3.3 is 3 select * from part_time_now_func; time | temp ------+------ 1.1 | 23.4 2.2 | 22.3 3.3 | 42.3 select set_integer_now_func('part_time_now_func', 'dummy_now'); set_integer_now_func ---------------------- select add_retention_policy('part_time_now_func', 0) as drop_chunks_job_id \gset CALL run_job(:drop_chunks_job_id); select * from part_time_now_func; time | temp ------+------ 2.2 | 22.3 3.3 | 42.3 select remove_retention_policy('part_time_now_func'); remove_retention_policy ------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER alter function dummy_now() rename to dummy_now_renamed; alter schema public rename to new_public; select * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+-----------------------------+---------+------------+--------------------------+--------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp with time zone | t | | | | 604800000000 | | | 2 | 1 | chunk_id | integer | f | 2 | _timescaledb_functions | get_partition_hash | | | | 5 | 4 | time | timestamp without time zone | t | | | | 1 | | | 6 | 5 | time | double precision | t | | new_public | time_partfunc | 1 | | new_public | dummy_now 3 | 2 | time | bigint | t | | | | 1 | | new_public | nowstamp 4 | 3 | time | smallint | t | | | | 1 | | new_public | overflow_now alter schema new_public rename to public; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- test that the behavior is strict when providing NULL required arguments create table test_strict (time timestamptz not null, a int, b int); select create_hypertable('test_strict', 'time'); create_hypertable -------------------------- (6,public,test_strict,t) \set ON_ERROR_STOP 0 select add_reorder_policy('test_table_perm', 'test_table_perm_pkey'); ERROR: must be owner of hypertable "test_table_perm" select remove_reorder_policy('test_table'); ERROR: must be owner of hypertable "test_table" select add_retention_policy('test_table_perm', INTERVAL '4 months', true); ERROR: must be owner of hypertable "test_table_perm" select remove_retention_policy('test_table'); ERROR: must be owner of hypertable "test_table" select add_retention_policy('test_strict', drop_after => NULL); ERROR: need to specify one of "drop_after" or "drop_created_before" \set ON_ERROR_STOP 1 -- Check the number of non-internal policies SELECT proc_name, count(*) FROM _timescaledb_config.bgw_job WHERE id >= 1000 GROUP BY proc_name; proc_name | count ------------------+------- policy_reorder | 1 policy_retention | 2 -- test retention with null arguments select add_retention_policy(NULL, NULL); add_retention_policy ---------------------- select add_retention_policy(NULL, drop_after => interval '2 days'); add_retention_policy ---------------------- -- this is an optional argument select add_retention_policy('test_strict', drop_after => interval '2 days', if_not_exists => NULL); add_retention_policy ---------------------- select add_retention_policy('test_strict', interval '2 days', schedule_interval => NULL); add_retention_policy ---------------------- 1006 -- test compression with null arguments alter table test_strict set (timescaledb.compress); select add_compression_policy(NULL, compress_after => NULL); add_compression_policy ------------------------ select add_compression_policy('test_strict', INTERVAL '2 weeks', if_not_exists => NULL); add_compression_policy ------------------------ select add_compression_policy('test_strict', INTERVAL '2 weeks', schedule_interval => NULL); add_compression_policy ------------------------ 1007 -- test that we get the default schedule_interval if nothing is specified create table test_missing_schedint (time timestamptz not null, a int, b int); select create_hypertable('test_missing_schedint', 'time', chunk_time_interval=> '31days'::interval); create_hypertable ------------------------------------ (8,public,test_missing_schedint,t) -- we expect shedule_interval to be 1 day select add_retention_policy('test_missing_schedint', interval '2 weeks') as retenion_id_missing_schedint \gset -- we expect schedule_interval to be chunk_time_interval/2 for timestamptz time alter table test_missing_schedint set (timescaledb.compress); select add_compression_policy('test_missing_schedint', interval '60 days') as compression_id_missing_schedint \gset -- we expect schedule_interval to be 1 day for int time create table test_missing_schedint_integer (time int not null, a int, b int); -- 10 days interval select create_hypertable('test_missing_schedint_integer', 'time', chunk_time_interval => 864000000); create_hypertable --------------------------------------------- (10,public,test_missing_schedint_integer,t) alter table test_missing_schedint_integer set (timescaledb.compress); select add_compression_policy('test_missing_schedint_integer', BIGINT '600000') as compression_id_integer \gset select * from _timescaledb_config.bgw_job where id in (:retenion_id_missing_schedint, :compression_id_missing_schedint, :compression_id_integer); id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+---------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------+------------------------+--------------------------+---------- 1008 | Retention Policy [1008] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user_2 | t | f | | 8 | {"drop_after": "@ 14 days", "hypertable_id": 8} | _timescaledb_functions | policy_retention_check | 1009 | Columnstore Policy [1009] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user_2 | t | f | | 8 | {"hypertable_id": 8, "compress_after": "@ 60 days"} | _timescaledb_functions | policy_compression_check | 1010 | Columnstore Policy [1010] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user_2 | t | f | | 10 | {"hypertable_id": 10, "compress_after": 600000} | _timescaledb_functions | policy_compression_check | -- test policy check functions with NULL args \set ON_ERROR_STOP 0 select add_compression_policy('test_strict', compress_after => NULL); ERROR: need to specify one of "compress_after" or "compress_created_before" SELECT _timescaledb_functions.policy_compression_check(NULL); ERROR: config must not be NULL SELECT _timescaledb_functions.policy_refresh_continuous_aggregate_check(NULL); ERROR: config must not be NULL SELECT _timescaledb_functions.policy_reorder_check(NULL); ERROR: config must not be NULL SELECT _timescaledb_functions.policy_retention_check(NULL); ERROR: config must not be NULL \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_reorder_drop_chunks.out������������������������������������0000664�0000000�0000000�00000134377�15100345067�0025105�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(CASE WHEN length(msg) > 80 THEN substring(msg, 1, 80) || '...' ELSE msg END, '(execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ------------------------------ -- test reorder policy runs -- ------------------------------ CREATE TABLE test_reorder_table(time int, chunk_id int); SELECT create_hypertable('test_reorder_table', 'time', chunk_time_interval => 1); create_hypertable --------------------------------- (1,public,test_reorder_table,t) -- These inserts should create 5 different chunks INSERT INTO test_reorder_table VALUES (1, 1); INSERT INTO test_reorder_table VALUES (2, 2); INSERT INTO test_reorder_table VALUES (3, 3); INSERT INTO test_reorder_table VALUES (4, 4); INSERT INTO test_reorder_table VALUES (5, 5); SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_reorder_table'; count ------- 5 SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_reorder'; count ------- 0 select add_reorder_policy('test_reorder_table', 'test_reorder_table_time_idx') as reorder_job_id \gset SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_reorder'; count ------- 1 -- job was created SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+-------------------------------------------------------------------+------------+---------------+-------------------+--------------------+------------------------+---------------------- 1000 | Reorder Policy [1000] | @ 4 days | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | {"index_name": "test_reorder_table_time_idx", "hypertable_id": 1} | | | public | test_reorder_table | _timescaledb_functions | policy_reorder_check -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- -- nothing clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered ------------+---------------- -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+-------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+-------------------------------------------------------------------+------------------------------+---------------+-------------------+--------------------+------------------------+---------------------- 1000 | Reorder Policy [1000] | @ 4 days | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | {"index_name": "test_reorder_table_time_idx", "hypertable_id": 1} | Fri Dec 31 16:00:00 1999 PST | | public | test_reorder_table | _timescaledb_functions | policy_reorder_check -- job ran once, successfully SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------------------+------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | 1 | 0 | 0 -- first chunk reordered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_test_reorder_table_time_idx | t -- second call to scheduler should immediately run reorder again, due to catchup SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+---------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 0 | 25000 | DB Scheduler | [TESTING] Registered new background worker 1 | 25000 | DB Scheduler | [TESTING] Wait until 50000, started at 25000 SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+-------------------------------------------------------------------+----------------------------------+---------------+-------------------+--------------------+------------------------+---------------------- 1000 | Reorder Policy [1000] | @ 4 days | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | {"index_name": "test_reorder_table_time_idx", "hypertable_id": 1} | Fri Dec 31 16:00:00.025 1999 PST | | public | test_reorder_table | _timescaledb_functions | policy_reorder_check -- two runs SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+----------------------------------+----------------------------------+------------------+------------+-----------------+----------------+--------------- 1000 | Fri Dec 31 16:00:00.025 1999 PST | Fri Dec 31 16:00:00.025 1999 PST | t | 2 | 2 | 0 | 0 -- two chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_2_chunk_test_reorder_table_time_idx | t -- third call to scheduler should immediately run reorder again, due to catchup SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- job info is gone SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+----------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 0 | 25000 | DB Scheduler | [TESTING] Registered new background worker 1 | 25000 | DB Scheduler | [TESTING] Wait until 50000, started at 25000 0 | 50000 | DB Scheduler | [TESTING] Registered new background worker 1 | 50000 | DB Scheduler | [TESTING] Wait until 100000, started at 50000 SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+-------------------------------------------------------------------+---------------------------------+---------------+-------------------+--------------------+------------------------+---------------------- 1000 | Reorder Policy [1000] | @ 4 days | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | {"index_name": "test_reorder_table_time_idx", "hypertable_id": 1} | Tue Jan 04 16:00:00.05 2000 PST | | public | test_reorder_table | _timescaledb_functions | policy_reorder_check SELECT * FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+---------------------------------+---------------------------------+---------------------------------+---------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1000 | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | Tue Jan 04 16:00:00.05 2000 PST | Fri Dec 31 16:00:00.05 1999 PST | t | 3 | @ 0 | @ 0 | 3 | 0 | 0 | 0 | 0 | 0 -- three chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_2_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_3_chunk_test_reorder_table_time_idx | t -- running is a nop SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+------------------------------------------------ 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 0 | 25000 | DB Scheduler | [TESTING] Registered new background worker 1 | 25000 | DB Scheduler | [TESTING] Wait until 50000, started at 25000 0 | 50000 | DB Scheduler | [TESTING] Registered new background worker 1 | 50000 | DB Scheduler | [TESTING] Wait until 100000, started at 50000 0 | 100000 | DB Scheduler | [TESTING] Wait until 200000, started at 100000 SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+-------------------------------------------------------------------+---------------------------------+---------------+-------------------+--------------------+------------------------+---------------------- 1000 | Reorder Policy [1000] | @ 4 days | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | {"index_name": "test_reorder_table_time_idx", "hypertable_id": 1} | Tue Jan 04 16:00:00.05 2000 PST | | public | test_reorder_table | _timescaledb_functions | policy_reorder_check SELECT * FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+---------------------------------+---------------------------------+---------------------------------+---------------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- 1000 | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | Tue Jan 04 16:00:00.05 2000 PST | Fri Dec 31 16:00:00.05 1999 PST | t | 3 | @ 0 | @ 0 | 3 | 0 | 0 | 0 | 0 | 0 -- still have 3 chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_2_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_3_chunk_test_reorder_table_time_idx | t --check that views work correctly SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+--------------------+--------+---------------------------------+---------------------------------+-----------------+------------+-------------------+---------------------------------+------------+-----------------+---------------- public | test_reorder_table | 1000 | Fri Dec 31 16:00:00.05 1999 PST | Fri Dec 31 16:00:00.05 1999 PST | Success | Scheduled | | Tue Jan 04 16:00:00.05 2000 PST | 3 | 3 | 0 -- test deleting the policy SELECT remove_reorder_policy('test_reorder_table'); remove_reorder_policy ----------------------- SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+--------+------------+---------------+-------------------+-----------------+--------------+------------ SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(125); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+------------------------------------------------ 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 0 | 25000 | DB Scheduler | [TESTING] Registered new background worker 1 | 25000 | DB Scheduler | [TESTING] Wait until 50000, started at 25000 0 | 50000 | DB Scheduler | [TESTING] Registered new background worker 1 | 50000 | DB Scheduler | [TESTING] Wait until 100000, started at 50000 0 | 100000 | DB Scheduler | [TESTING] Wait until 200000, started at 100000 0 | 200000 | DB Scheduler | [TESTING] Wait until 325000, started at 200000 SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+--------+------------+---------------+-------------------+-----------------+--------------+------------ -- still only 3 chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_2_chunk_test_reorder_table_time_idx | t _timescaledb_internal._hyper_1_3_chunk_test_reorder_table_time_idx | t \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ----------------------------------- -- test drop chunks policy runs -- ----------------------------------- CREATE TABLE test_drop_chunks_table(time timestamptz, drop_order int); SELECT create_hypertable('test_drop_chunks_table', 'time', chunk_time_interval => INTERVAL '1 week'); create_hypertable ------------------------------------- (2,public,test_drop_chunks_table,t) -- These inserts should create 5 different chunks INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_drop_chunks_table VALUES (now(), 5); INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '8 months', 1); SELECT show_chunks('test_drop_chunks_table'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_drop_chunks_table'; count ------- 5 SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; count ------- 0 SELECT add_retention_policy('test_drop_chunks_table', INTERVAL '4 months') as drop_chunks_job_id \gset SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; count ------- 1 SELECT alter_job(:drop_chunks_job_id, schedule_interval => INTERVAL '1 second'); alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1001,"@ 1 sec","@ 5 mins",-1,"@ 5 mins",t,"{""drop_after"": ""@ 4 mons"", ""hypertable_id"": 2}",-infinity,_timescaledb_functions.policy_retention_check,f,,,"Retention Policy [1001]") SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+------------------------------------------------+------------+---------------+-------------------+------------------------+------------------------+------------------------ 1001 | Retention Policy [1001] | @ 1 sec | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | {"drop_after": "@ 4 mons", "hypertable_id": 2} | | | public | test_drop_chunks_table | _timescaledb_functions | policy_retention_check -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:drop_chunks_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- -- all chunks are there SELECT show_chunks('test_drop_chunks_table'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+-------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+------------------------------------------------+------------------------------+---------------+-------------------+------------------------+------------------------+------------------------ 1001 | Retention Policy [1001] | @ 1 sec | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | {"drop_after": "@ 4 mons", "hypertable_id": 2} | Fri Dec 31 16:00:01 1999 PST | | public | test_drop_chunks_table | _timescaledb_functions | policy_retention_check -- job ran once, successfully SELECT job_id, time_bucket('1m',next_start) AS next_start, time_bucket('1m',last_finish) as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:drop_chunks_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------------------+------------------------------+------------------+------------+-----------------+----------------+--------------- 1001 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | 1 | 0 | 0 -- chunks 8 and 10 dropped SELECT show_chunks('test_drop_chunks_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_9_chunk -- job doesn't run again immediately SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+---------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 0 | 25000 | DB Scheduler | [TESTING] Wait until 50000, started at 25000 SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+------------------------------------------------+------------------------------+---------------+-------------------+------------------------+------------------------+------------------------ 1001 | Retention Policy [1001] | @ 1 sec | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | {"drop_after": "@ 4 mons", "hypertable_id": 2} | Fri Dec 31 16:00:01 1999 PST | | public | test_drop_chunks_table | _timescaledb_functions | policy_retention_check -- still only 1 run SELECT job_id, time_bucket('1m',next_start) AS next_start, time_bucket('1m',last_finish) as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:drop_chunks_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------------------+------------------------------+------------------+------------+-----------------+----------------+--------------- 1001 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | t | 1 | 1 | 0 | 0 -- same chunks SELECT show_chunks('test_drop_chunks_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_9_chunk -- a new chunk older than the drop date will be dropped INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '12 months', 0); SELECT show_chunks('test_drop_chunks_table'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_11_chunk SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(10000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+------------------+--------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until 25000, started at 0 0 | 25000 | DB Scheduler | [TESTING] Wait until 50000, started at 25000 0 | 50000 | DB Scheduler | [TESTING] Wait until 1000000, started at 50000 1 | 1000000 | DB Scheduler | [TESTING] Registered new background worker 2 | 1000000 | DB Scheduler | [TESTING] Wait until 10050000, started at 1000000 SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+------------------------------------------------+------------------------------+---------------+-------------------+------------------------+------------------------+------------------------ 1001 | Retention Policy [1001] | @ 1 sec | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | {"drop_after": "@ 4 mons", "hypertable_id": 2} | Fri Dec 31 16:00:02 1999 PST | | public | test_drop_chunks_table | _timescaledb_functions | policy_retention_check -- 2 runs SELECT job_id, time_bucket('1m',next_start) AS next_start, time_bucket('1m',last_finish) as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:drop_chunks_job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------------------+------------------------------+------------------+------------+-----------------+----------------+--------------- 1001 | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | t | 2 | 2 | 0 | 0 SELECT show_chunks('test_drop_chunks_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_9_chunk --test that views work SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+------------------------+--------+------------------------------+------------------------------+-----------------+------------+-------------------+------------------------------+------------+-----------------+---------------- public | test_drop_chunks_table | 1001 | Fri Dec 31 16:00:01 1999 PST | Fri Dec 31 16:00:01 1999 PST | Success | Scheduled | | Fri Dec 31 16:00:02 1999 PST | 2 | 2 | 0 -- Test that add_retention_policy also works with timestamp (without time zone) and date types -- and that the policy execution is being logged -- Test for date CREATE TABLE test_drop_chunks_table_date(time date, drop_order int); SELECT create_hypertable('test_drop_chunks_table_date', 'time', chunk_time_interval => INTERVAL '1 week'); create_hypertable ------------------------------------------ (3,public,test_drop_chunks_table_date,t) INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_drop_chunks_table_date VALUES (now(), 5); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '8 months', 1); -- Clear the job stats and reset timer, this will also clear the bgw_log \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Test for timestamp CREATE TABLE test_drop_chunks_table_tsntz(time date, drop_order int); SELECT create_hypertable('test_drop_chunks_table_tsntz', 'time', chunk_time_interval => INTERVAL '1 week'); create_hypertable ------------------------------------------- (4,public,test_drop_chunks_table_tsntz,t) INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_drop_chunks_table_tsntz VALUES (now(), 5); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '8 months', 1); -- Add retention policies for both tables SELECT add_retention_policy('test_drop_chunks_table_date', INTERVAL '4 months') as drop_chunks_date_job_id \gset SELECT add_retention_policy('test_drop_chunks_table_tsntz', INTERVAL '4 months') as drop_chunks_tsntz_job_id \gset -- Test that retention policy is being logged SELECT alter_job(id,config:=jsonb_set(config,'{verbose_log}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :drop_chunks_date_job_id; alter_job ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1002,"@ 1 day","@ 5 mins",-1,"@ 5 mins",t,"{""drop_after"": ""@ 4 mons"", ""verbose_log"": true, ""hypertable_id"": 3}",-infinity,_timescaledb_functions.policy_retention_check,f,,,"Retention Policy [1002]") SELECT alter_job(id,config:=jsonb_set(config,'{verbose_log}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :drop_chunks_tsntz_job_id; alter_job ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1003,"@ 1 day","@ 5 mins",-1,"@ 5 mins",t,"{""drop_after"": ""@ 4 mons"", ""verbose_log"": true, ""hypertable_id"": 4}",-infinity,_timescaledb_functions.policy_retention_check,f,,,"Retention Policy [1003]") SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+-------------------------+------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Registered new background worker 2 | 0 | DB Scheduler | [TESTING] Wait until 1000000, started at 0 0 | 0 | Retention Policy [1002] | applying retention policy to hypertable "test_drop_chunks_table_date": dropping ... 0 | 0 | Retention Policy [1003] | applying retention policy to hypertable "test_drop_chunks_table_tsntz": dropping... -- test the schedule_interval parameter for policies CREATE TABLE test_schedint(time timestamptz, a int, b int); select create_hypertable('test_schedint', 'time'); create_hypertable ---------------------------- (5,public,test_schedint,t) insert into test_schedint values (now(), 1, 2), (now() + interval '2 seconds', 2, 3); -- test the retention policy select add_retention_policy('test_schedint', interval '2 months', schedule_interval => '30 seconds') as polret_schedint \gset -- wait for a bit more than "schedule_interval" seconds, then verify the policy has run twice select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polret_schedint; total_runs | total_successes | total_failures ------------+-----------------+---------------- 1 | 1 | 0 select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(30000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polret_schedint; total_runs | total_successes | total_failures ------------+-----------------+---------------- 2 | 2 | 0 -- if we wait another 30s, we should see 3 runs of the job select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(30000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polret_schedint; total_runs | total_successes | total_failures ------------+-----------------+---------------- 3 | 3 | 0 -- test the compression policy alter table test_schedint set (timescaledb.compress); select add_compression_policy('test_schedint', interval '3 weeks', schedule_interval => '40 seconds') as polcomp_schedint \gset select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polcomp_schedint; total_runs | total_successes | total_failures ------------+-----------------+---------------- 1 | 1 | 0 select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(40000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polcomp_schedint; total_runs | total_successes | total_failures ------------+-----------------+---------------- 2 | 2 | 0 -- if we wait another 40s, we should see 3 runs of the job select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(40000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polcomp_schedint; total_runs | total_successes | total_failures ------------+-----------------+---------------- 3 | 3 | 0 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_scheduler_control.out��������������������������������������0000664�0000000�0000000�00000014377�15100345067�0024557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(INT, INT) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION ts_bgw_params_reset_time(set_time BIGINT, wait BOOLEAN) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; ALTER DATABASE :TEST_DBNAME OWNER TO :ROLE_DEFAULT_PERM_USER; GRANT EXECUTE ON FUNCTION pg_reload_conf TO :ROLE_DEFAULT_PERM_USER; GRANT ALTER SYSTEM, SET ON PARAMETER timescaledb.bgw_log_level TO :ROLE_DEFAULT_PERM_USER; -- These are needed to set up the test scheduler CREATE TABLE public.bgw_dsm_handle_store(handle BIGINT); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- -- Test scheduler automatically writes to this table by name, so -- create it. CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW cleaned_bgw_log AS SELECT msg_no, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time|database) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; -- Remove all default jobs DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; -- -- Set bgw log level and reload config. -- -- Debug messages should be in log now which it wasn't before. -- -- We change user to make sure that granting SET and ALTER SYSTEM -- privileges to the default user actually works. SET ROLE :ROLE_DEFAULT_PERM_USER; ALTER DATABASE :TEST_DBNAME SET timescaledb.bgw_log_level = 'DEBUG1'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t RESET ROLE; SELECT ts_bgw_params_reset_time(0, false); ts_bgw_params_reset_time -------------------------- INSERT INTO _timescaledb_config.bgw_job( application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, fixed_schedule ) VALUES ( 'test_job_1b', --application_name INTERVAL '100ms', --schedule_interval INTERVAL '100s', --max_runtime 5, --max_retries INTERVAL '1s', --retry_period 'public', --proc_schema 'bgw_test_job_1', --proc_name CURRENT_ROLE::regrole, --owner TRUE, --scheduled FALSE --fixed_schedule ) RETURNING id AS job_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM cleaned_bgw_log; msg_no | application_name | msg --------+------------------+------------------------------------------------------------------------- 0 | DB Scheduler | extension state changed: unknown to created 1 | DB Scheduler | database scheduler for database (RANDOM) starting 2 | DB Scheduler | launching job 1000 "test_job_1b" 3 | DB Scheduler | [TESTING] Registered new background worker 4 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | test_job_1b | Execute job 1 1 | test_job_1b | job 1000 (test_job_1b) exiting with success: execution time (RANDOM) ms 5 | DB Scheduler | scheduler for database (RANDOM) exiting with exit status 0 -- We test that we can set it to FATAL, which removed LOG level -- entries from the log. ALTER DATABASE :TEST_DBNAME SET timescaledb.bgw_log_level = 'FATAL'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(0, false); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM cleaned_bgw_log; msg_no | application_name | msg --------+------------------+----- -- We test that we can set it to ERROR. ALTER DATABASE :TEST_DBNAME SET timescaledb.bgw_log_level = 'ERROR'; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(0, false); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM cleaned_bgw_log; msg_no | application_name | msg --------+------------------+----- -- Reset the log level and check that normal entries are showing up -- again. ALTER DATABASE :TEST_DBNAME RESET timescaledb.bgw_log_level; SELECT pg_reload_conf(); pg_reload_conf ---------------- t \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(0, false); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM cleaned_bgw_log; msg_no | application_name | msg --------+------------------+---------------------------------------------------- 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) SELECT delete_job(:job_id); delete_job ------------ SET ROLE :ROLE_DEFAULT_PERM_USER; -- Make sure we can set the variable using ALTER SYSTEM using the -- previous grants. We don't bother about checking that it has an -- effect here since we already knows it works from the above code. ALTER SYSTEM SET timescaledb.bgw_log_level TO 'DEBUG2'; ALTER SYSTEM RESET timescaledb.bgw_log_level; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_scheduler_restart.out��������������������������������������0000664�0000000�0000000�00000016723�15100345067�0024560�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW tsdb_bgw AS SELECT datname, pid, backend_type, application_name FROM pg_stat_activity WHERE backend_type LIKE '%TimescaleDB%' ORDER BY datname, backend_type, application_name; -- Wait for at least one background worker matching pattern to have -- started. CREATE PROCEDURE wait_for_some_started( min_time double precision, timeout double precision, pattern text ) AS $$ DECLARE backend_count int; BEGIN FOR i IN 0..(timeout / min_time)::int LOOP PERFORM pg_sleep(min_time); SELECT count(*) INTO backend_count FROM tsdb_bgw WHERE backend_type LIKE pattern; IF backend_count > 0 THEN RETURN; END IF; END LOOP; RAISE EXCEPTION 'backend matching % did not start before timeout', pattern; END; $$ LANGUAGE plpgsql; -- Wait for the number of background workers matching pattern to be -- zero. CREATE PROCEDURE wait_for_all_stopped( min_time double precision, timeout double precision, pattern text ) AS $$ DECLARE backend_count int; BEGIN FOR i IN 0..(timeout / min_time)::int LOOP PERFORM pg_sleep(min_time); SELECT count(*) INTO backend_count FROM tsdb_bgw WHERE backend_type LIKE pattern; IF backend_count = 0 THEN RETURN; END IF; END LOOP; RAISE EXCEPTION 'backend matching % did not start before timeout', pattern; END; $$ LANGUAGE plpgsql; CREATE PROCEDURE ts_terminate_launcher() AS $$ SELECT pg_terminate_backend(pid) FROM tsdb_bgw WHERE backend_type LIKE '%Launcher%'; $$ LANGUAGE SQL; -- Show the default scheduler restart time SHOW timescaledb.bgw_scheduler_restart_time; timescaledb.bgw_scheduler_restart_time ---------------------------------------- -1 -- Test that it cannot be set to something between -1 and 10 \set ON_ERROR_STOP 0 \set VERBOSITY default ALTER SYSTEM SET timescaledb.bgw_scheduler_restart_time TO '5s'; ERROR: invalid value for parameter "timescaledb.bgw_scheduler_restart_time": 5 DETAIL: Scheduler restart time must be be either -1 or at least 10 seconds. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Set scheduler restart time to a lower value to make the test a -- little faster. ALTER SYSTEM SET timescaledb.bgw_scheduler_restart_time TO '10s'; ALTER SYSTEM SET timescaledb.debug_bgw_scheduler_exit_status TO 1; SELECT pg_reload_conf(); pg_reload_conf ---------------- t -- Reconnect and check the restart time to make sure that it is -- correct. \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.bgw_scheduler_restart_time; timescaledb.bgw_scheduler_restart_time ---------------------------------------- 10s -- Launcher is running, so we need to restart it for the scheduler -- restart time to take effect. SELECT datname, application_name FROM tsdb_bgw; datname | application_name ---------+---------------------------------------- | TimescaleDB Background Worker Launcher CALL ts_terminate_launcher(); -- It will restart automatically, but we wait for it to start. CALL wait_for_some_started(1, 50, '%Launcher%'); -- Make sure that the new value of the scheduler restart time is -- correct or the rest of the tests will fail. SHOW timescaledb.bgw_scheduler_restart_time; timescaledb.bgw_scheduler_restart_time ---------------------------------------- 10s -- Verify that launcher is running. If it is not, the rest of the test -- will fail. SELECT datname, application_name FROM tsdb_bgw; datname | application_name --------------------------+----------------------------------------- db_bgw_scheduler_restart | TimescaleDB Background Worker Scheduler | TimescaleDB Background Worker Launcher -- Now we can start the background workers. SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t -- They should start immediately, but let's wait for them to start. CALL wait_for_some_started(1, 50, '%Scheduler%'); -- Check that the schedulers are running. If they are not, the rest of -- the test is meaningless. SELECT datname, application_name FROM tsdb_bgw; datname | application_name --------------------------+----------------------------------------- db_bgw_scheduler_restart | TimescaleDB Background Worker Scheduler | TimescaleDB Background Worker Launcher -- Kill the schedulers and check that they restart. SELECT pg_terminate_backend(pid) FROM tsdb_bgw WHERE datname = :'TEST_DBNAME' AND backend_type LIKE '%Scheduler%'; pg_terminate_backend ---------------------- t -- Wait for scheduler to exit, they should exit immediately. CALL wait_for_all_stopped(1, 50, '%Scheduler%'); -- Check that the schedulers really exited. SELECT datname, application_name FROM tsdb_bgw; datname | application_name ---------+---------------------------------------- | TimescaleDB Background Worker Launcher -- Wait for scheduler to restart. CALL wait_for_some_started(10, 100, '%Scheduler%'); -- Make sure that the launcher and schedulers are running. Otherwise -- the test will fail. SELECT datname, application_name FROM tsdb_bgw; datname | application_name --------------------------+----------------------------------------- db_bgw_scheduler_restart | TimescaleDB Background Worker Scheduler | TimescaleDB Background Worker Launcher -- Now, we had a previous bug where killing the launcher at this point -- would leave the schedulers running (because the launcher did not -- have a handle for them) and when launcher is restarting, it would -- start more schedulers, leaving two schedulers per database. -- Get the PID of the launcher to be able to compare it after the restart SELECT pid AS orig_pid FROM tsdb_bgw WHERE backend_type LIKE '%Launcher%' \gset -- Kill the launcher. Since there are new restarted schedulers, the -- handle could not be used to terminate them, and they would be left -- running. CALL ts_terminate_launcher(); -- Launcher will restart immediately, but we wait one second to give -- it a chance to start. CALL wait_for_some_started(1, 50, '%Launcher%'); -- Check that the launcher is running and that there are exactly one -- scheduler per database. Here the old schedulers are killed, so it -- will be schedulers with a different PID than the ones before the -- launcher was killed, but we are not showing this here. SELECT (pid != :orig_pid) AS different_pid, datname, application_name FROM tsdb_bgw; different_pid | datname | application_name ---------------+--------------------------+----------------------------------------- t | db_bgw_scheduler_restart | TimescaleDB Background Worker Scheduler t | | TimescaleDB Background Worker Launcher ALTER SYSTEM RESET timescaledb.bgw_scheduler_restart_time; ALTER SYSTEM RESET timescaledb.debug_bgw_scheduler_exit_status; SELECT pg_reload_conf(); pg_reload_conf ---------------- t SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t -- We need to restart the launcher as well to read the reset -- configuration or it will affect other tests. CALL ts_terminate_launcher(); ���������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_security.out�����������������������������������������������0000664�0000000�0000000�00000003003�15100345067�0022670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ROLE_ADMIN :TEST_DBNAME _admin \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE :ROLE_ADMIN LOGIN; GRANT :ROLE_ADMIN TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE custom_log (ts integer, msg text); GRANT ALL ON custom_log TO PUBLIC; CREATE PROCEDURE custom_job(integer, jsonb) AS $$ INSERT INTO custom_log values($1, 'custom_job'); $$ LANGUAGE SQL; SET ROLE :ROLE_ADMIN; SELECT add_job('custom_job', '1h') AS job_id \gset RESET ROLE; SELECT id, proc_name, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id; id | proc_name | owner ------+------------+----------------------- 1000 | custom_job | db_bgw_security_admin \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- We should fail to execute and delete the job since we do not own it -- or belong to the group that owns it. \set ON_ERROR_STOP 0 CALL run_job(:job_id); ERROR: insufficient permissions to run job 1000 SELECT delete_job(:job_id); ERROR: insufficient permissions to delete job owned by "db_bgw_security_admin" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- This should succeed since the role belongs to the job owner group. CALL run_job(:job_id); -- This should succeed since we belong to the owners role. SELECT delete_job(:job_id); delete_job ------------ \c :TEST_DBNAME :ROLE_SUPERUSER DROP ROLE :ROLE_ADMIN; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/bgw_telemetry.out����������������������������������������������0000664�0000000�0000000�00000002656�15100345067�0023050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Check that we can use run_job() with the telemetry job, so first -- locate the job id for it (should be 1, but who knows, and it is not -- important for this test). SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_telemetry' \gset -- It should be possible to run it twice and running it should change -- the last_finish time. Since job_stats can be empty to start with, -- we run it once first to populate job_stats. CALL run_job(:job_id); SELECT last_finish AS last_finish FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :job_id \gset SELECT pg_sleep(1); pg_sleep ---------- CALL run_job(:job_id); SELECT last_finish > :'last_finish' AS job_executed, last_run_success FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :job_id; job_executed | last_run_success --------------+------------------ t | f -- Running it as the default user should fail since they do not own -- the job. This should be the case also for the telemetry job, which -- is a little special. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 0 CALL run_job(:job_id); ERROR: insufficient permissions to run job 1 \set ON_ERROR_STOP 1 ����������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_api.out���������������������������������������������������0000664�0000000�0000000�00000044475�15100345067�0021736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO CET; SET datestyle TO ISO; CREATE VIEW continuous_aggregates AS SELECT mat_hypertable_id AS materialization_id, format('%I.%I', user_view_schema, user_view_name)::regclass AS continuous_aggregate FROM _timescaledb_catalog.hypertable JOIN _timescaledb_catalog.continuous_agg ON hypertable.id = continuous_agg.mat_hypertable_id; CREATE TABLE hyper_ts (time timestamp NOT NULL, value float); CREATE TABLE hyper_tstz (time timestamptz NOT NULL, value float); CREATE TABLE hyper_multi (time timestamptz NOT NULL, device int, value float); CREATE TABLE hyper_no_cagg (time timestamptz NOT NULL, device int, value float); CREATE TABLE normal_ts(time timestamp NOT NULL, value float); SELECT * FROM create_hypertable('hyper_ts', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper_ts | t SELECT * FROM create_hypertable('hyper_tstz', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | hyper_tstz | t SELECT * FROM create_hypertable('hyper_no_cagg', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 3 | public | hyper_no_cagg | t SELECT * FROM create_hypertable('hyper_multi', 'time', 'device', 4); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 4 | public | hyper_multi | t INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-01'::timestamp, '2025-01-06', '1m') time; INSERT INTO hyper_tstz SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-01'::timestamptz, '2025-01-06', '1m') time; CREATE MATERIALIZED VIEW ts_temperature_1h WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time), avg(value) FROM hyper_ts GROUP BY 1; NOTICE: refreshing continuous aggregate "ts_temperature_1h" CREATE MATERIALIZED VIEW ts_temperature_15m WITH (timescaledb.continuous) AS SELECT time_bucket('15 minutes', time), avg(value) FROM hyper_ts GROUP BY 1; NOTICE: refreshing continuous aggregate "ts_temperature_15m" CREATE MATERIALIZED VIEW tstz_temperature_1h WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time), avg(value) FROM hyper_tstz GROUP BY 1; NOTICE: refreshing continuous aggregate "tstz_temperature_1h" CREATE MATERIALIZED VIEW tstz_temperature_15m WITH (timescaledb.continuous) AS SELECT time_bucket('15 minutes', time), avg(value) FROM hyper_tstz GROUP BY 1; NOTICE: refreshing continuous aggregate "tstz_temperature_15m" CREATE MATERIALIZED VIEW multi_temperature_15m WITH (timescaledb.continuous) AS SELECT time_bucket('15 minutes', time), avg(value) FROM hyper_multi GROUP BY 1; NOTICE: continuous aggregate "multi_temperature_15m" is already up-to-date SET search_path TO _timescaledb_functions, public; -- These are not part of the API, but we test them here just to make -- sure they work as expected. SELECT table_name, get_materialization_info(table_name) FROM ( VALUES ('tstz_temperature_15m'), ('multi_temperature_15m') ) t(table_name); table_name | get_materialization_info -----------------------+-------------------------- tstz_temperature_15m | (8,"@ 15 mins") multi_temperature_15m | (9,"@ 15 mins") \set ON_ERROR_STOP 0 SELECT get_materialization_info('hyper_no_cagg'); ERROR: "public.hyper_no_cagg" is not a continuous aggregate \set ON_ERROR_STOP 1 -- This is not part of the API either, but added a test here to make -- sure that it works as expected. SELECT materialization_id, to_timestamp(lowest_modified_value), to_timestamp(greatest_modified_value) FROM get_raw_materialization_ranges('timestamptz'); materialization_id | to_timestamp | to_timestamp --------------------+--------------+-------------- -- Here are tests of the API SELECT * INTO before FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; CALL _timescaledb_functions.add_materialization_invalidations( 'tstz_temperature_15m'::regclass, '["2025-04-25 11:10:00+02","2025-04-26 11:14:00+02"]'::tstzrange ); CALL _timescaledb_functions.add_materialization_invalidations( 'ts_temperature_15m'::regclass, '["2025-04-25 11:10:00+02","2025-04-26 11:14:00+02"]'::tsrange ); -- Custom refresh function that iterate over the ranges inside the -- restriction and refresh them. This is to check that the refresh -- function does the right thing with the ranges returned by the API -- function. CREATE PROCEDURE custom_refresh(cagg REGCLASS, restriction ANYRANGE) AS $body$ DECLARE inval restriction%TYPE; BEGIN FOR inval IN SELECT UNNEST(invalidations) FROM _timescaledb_functions.get_materialization_invalidations(cagg, restriction) LOOP RAISE NOTICE 'Updating range %', inval; CALL refresh_continuous_aggregate(cagg, lower(inval), upper(inval)); COMMIT; END LOOP; END $body$ LANGUAGE plpgsql; SELECT continuous_aggregate, to_timestamp(lhs.lowest_modified_value), to_timestamp(lhs.greatest_modified_value) FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log lhs JOIN continuous_aggregates USING (materialization_id) LEFT JOIN before rhs ON row(lhs.*) = row(rhs.*) WHERE lhs.materialization_id IS NULL OR rhs.materialization_id IS NULL; continuous_aggregate | to_timestamp | to_timestamp ----------------------+------------------------+------------------------ ts_temperature_15m | 2025-04-25 11:00:00+02 | 2025-04-26 11:15:00+02 tstz_temperature_15m | 2025-04-25 11:00:00+02 | 2025-04-26 11:15:00+02 SELECT materialization_id, to_timestamp(lowest_modified_value), to_timestamp(greatest_modified_value) FROM get_raw_materialization_ranges('timestamptz'); materialization_id | to_timestamp | to_timestamp --------------------+------------------------+------------------------ 6 | 2025-04-25 11:00:00+02 | 2025-04-26 11:15:00+02 8 | 2025-04-25 11:00:00+02 | 2025-04-26 11:15:00+02 SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'ts_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tsrange ); invalidations ------------------------------------------------- {["2025-04-25 09:00:00","2025-04-26 00:00:00")} CALL custom_refresh('ts_temperature_15m', '["2025-04-25","2025-04-26"]'::tsrange); NOTICE: Updating range ["2025-04-25 09:00:00","2025-04-26 00:00:00") SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'ts_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tsrange ); invalidations -------------------------------------------------------- {["2025-04-25 00:00:00","2025-04-25 08:59:59.999999")} SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'tstz_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tstzrange ); invalidations ------------------------------------------------------- {["2025-04-25 11:00:00+02","2025-04-26 00:00:00+02")} CALL custom_refresh('tstz_temperature_15m', '["2025-04-25","2025-04-26"]'::tsrange); NOTICE: Updating range ["2025-04-25 09:00:00","2025-04-26 00:00:00") SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'tstz_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tstzrange ); invalidations -------------------------------------------------------------- {["2025-04-25 00:00:00+02","2025-04-25 10:59:59.999999+02")} -- Generate some invalidations. These new values need to be before the -- invalidation threshold, which is set to end time of the insertion -- above. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-04 10:00:00'::timestamp, '2025-01-04 11:12:00', '9 minutes') time; INSERT INTO hyper_tstz SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-04 12:00:00'::timestamptz, '2025-01-04 13:12:00', '8 minutes') time; -- Check the invalidation threshold. If that is not after the -- insertions above, nothing will show up in the invalidation log. SELECT hypertable_id, _timescaledb_functions.to_timestamp_without_timezone(watermark) AS watermark FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1; hypertable_id | watermark ---------------+------------------------ 1 | 2025-04-26 00:00:00 2 | 2025-04-26 00:00:00 4 | 4714-11-24 00:00:00 BC -- Check that there indeed is something in the hypertable invalidation -- log. If not, this will fail anyway. We show the "raw" timestamps, -- which is in UTC if it was originally a timestamp with timezone. -- -- We ignore duplicates since those will be merged when moving -- invalidations and hence does not affect correctness and can cause -- test flakiness otherwise. SELECT DISTINCT hypertable_id, _timescaledb_functions.to_timestamp_without_timezone(lowest_modified_value) AS start, _timescaledb_functions.to_timestamp_without_timezone(greatest_modified_value) AS finish FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log ORDER BY 1; hypertable_id | start | finish ---------------+---------------------+--------------------- 1 | 2025-01-04 10:00:00 | 2025-01-04 11:12:00 2 | 2025-01-04 11:00:00 | 2025-01-04 12:12:00 \set VERBOSITY default -- Check that we can handle hypertables with single and multiple -- dimensions. This function is not part of the official API but we -- add tests for it here. SELECT _timescaledb_functions.get_hypertable_id('hyper_ts', 'timestamp'); get_hypertable_id ------------------- 1 SELECT _timescaledb_functions.get_hypertable_id('hyper_tstz', 'timestamptz'); get_hypertable_id ------------------- 2 SELECT _timescaledb_functions.get_hypertable_id('hyper_multi', 'timestamptz'); get_hypertable_id ------------------- 4 \set ON_ERROR_STOP 0 -- Not a hypertable SELECT _timescaledb_functions.get_hypertable_id('normal_ts', 'timestamp'); ERROR: table "public.normal_ts" is not a hypertable CONTEXT: PL/pgSQL function _timescaledb_functions.get_hypertable_id(regclass,regtype) line 15 at RAISE SELECT _timescaledb_functions.get_hypertable_invalidations('normal_ts', null::timestamp, array['15 minutes', '1 hour']::interval[]); ERROR: table "public.normal_ts" is not a hypertable CONTEXT: PL/pgSQL function _timescaledb_functions.get_hypertable_id(regclass,regtype) line 15 at RAISE PL/pgSQL function _timescaledb_functions.get_hypertable_invalidations(regclass,timestamp without time zone,interval[]) line 3 during statement block local variable initialization -- No continuous aggregate connected SELECT _timescaledb_functions.get_hypertable_id('hyper_no_cagg', 'timestamp'); ERROR: hypertable "public.hyper_no_cagg" has no continuous aggregate HINT: Define a continuous aggregate for the hypertable to read invalidations. CONTEXT: PL/pgSQL function _timescaledb_functions.get_hypertable_id(regclass,regtype) line 20 at RAISE SELECT _timescaledb_functions.get_hypertable_invalidations('hyper_no_cagg', null::timestamp, array['15 minutes', '1 hour']::interval[]); ERROR: hypertable "public.hyper_no_cagg" has no continuous aggregate HINT: Define a continuous aggregate for the hypertable to read invalidations. CONTEXT: PL/pgSQL function _timescaledb_functions.get_hypertable_id(regclass,regtype) line 20 at RAISE PL/pgSQL function _timescaledb_functions.get_hypertable_invalidations(regclass,timestamp without time zone,interval[]) line 3 during statement block local variable initialization -- Wrong type used SELECT _timescaledb_functions.get_hypertable_id('hyper_ts', 'timestamptz'); ERROR: wrong column type for hypertable public.hyper_ts HINT: hypertable type was "timestamp without time zone", but caller expected "timestamp with time zone" CONTEXT: PL/pgSQL function _timescaledb_functions.get_hypertable_id(regclass,regtype) line 26 at RAISE SELECT _timescaledb_functions.get_hypertable_invalidations('hyper_ts', null::timestamptz, array['15 minutes', '1 hour']::interval[]); ERROR: wrong column type for hypertable public.hyper_ts HINT: hypertable type was "timestamp without time zone", but caller expected "timestamp with time zone" CONTEXT: PL/pgSQL function _timescaledb_functions.get_hypertable_id(regclass,regtype) line 26 at RAISE PL/pgSQL function _timescaledb_functions.get_hypertable_invalidations(regclass,timestamp with time zone,interval[]) line 3 during statement block local variable initialization \set ON_ERROR_STOP 1 SELECT * INTO saved_invalidations_1 FROM _timescaledb_functions.get_hypertable_invalidations('hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[]); SELECT bucket_width, invalidations FROM saved_invalidations_1; bucket_width | invalidations --------------+------------------------------------------------- @ 15 mins | {["2025-01-04 10:00:00","2025-01-04 11:15:00")} @ 1 hour | {["2025-01-04 10:00:00","2025-01-04 12:00:00")} -- Calling it twice should return same invalidations since we haven't -- inserted anything between. SELECT * INTO saved_invalidations_2 FROM _timescaledb_functions.get_hypertable_invalidations('hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[]); SELECT * FROM saved_invalidations_2 s1 FULL JOIN saved_invalidations_2 s2 ON row(s1.*) = row(s2.*) WHERE s1.token IS NULL OR s2.token IS NULL; bucket_width | token | invalidations | bucket_width | token | invalidations --------------+-------+---------------+--------------+-------+--------------- SELECT token FROM saved_invalidations_1 LIMIT 1 \gset -- Test some error cases \set ON_ERROR_STOP 0 CALL _timescaledb_functions.accept_hypertable_invalidations('normal_ts', :'token'); ERROR: table "public.normal_ts" is not a hypertable CONTEXT: PL/pgSQL function _timescaledb_functions.accept_hypertable_invalidations(regclass,text) line 14 at RAISE CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_no_cagg', :'token'); ERROR: hypertable "public.hyper_no_cagg" has no continuous aggregate HINT: Define a continuous aggregate for the hypertable to handle invalidations. CONTEXT: PL/pgSQL function _timescaledb_functions.accept_hypertable_invalidations(regclass,text) line 19 at RAISE CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_ts', 'garbage'); ERROR: invalid input syntax for type pg_snapshot: "garbage" HINT: Use the token from the get_hypertable_invalidations() call. CONTEXT: PL/pgSQL function _timescaledb_functions.accept_hypertable_invalidations(regclass,text) line 29 at RAISE \set ON_ERROR_STOP 1 -- Accept the invalidations as processed by passing in the token. CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_ts', :'token'); -- This should now show no validations. SELECT bucket_width, invalidations FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ); bucket_width | invalidations --------------+--------------- -- Check that the invalidations associated with the token are removed -- when there are inserts in between. -- First insert some rows. All invalidations were removed above, so we -- should only see these. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-03 10:00:00'::timestamp, '2025-01-03 11:12:00', '10 minutes') time; -- Get invalidations from the hypertable, with a token. SELECT * INTO saved_3 FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ); SELECT token FROM saved_3 LIMIT 1 \gset -- Insert some more rows into the hypertable that are disjoint with -- the invalidations associated with the token above. These should be -- fully removed. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-02 10:00:00'::timestamp, '2025-01-02 11:12:00', '10 minutes') time; -- Insert some more rows into the hypertable that are inside the range -- associated with the token above. These should remain after -- accepting the token. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-03 10:30:00'::timestamp, '2025-01-03 10:50:00', '5 minutes') time; -- Check that we have them in the invalidation log SELECT bucket_width, unnest(invalidations) AS inval FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ) ORDER BY 1, 2; bucket_width | inval --------------+----------------------------------------------- @ 15 mins | ["2025-01-02 10:00:00","2025-01-02 11:15:00") @ 15 mins | ["2025-01-03 10:00:00","2025-01-03 11:15:00") @ 1 hour | ["2025-01-02 10:00:00","2025-01-02 12:00:00") @ 1 hour | ["2025-01-03 10:00:00","2025-01-03 12:00:00") -- Accept the original invalidations CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_ts', :'token'); -- Check that we only removed the ones associated with the token. SELECT bucket_width, unnest(invalidations) AS inval FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ) ORDER BY 1, 2; bucket_width | inval --------------+----------------------------------------------- @ 15 mins | ["2025-01-02 10:00:00","2025-01-02 11:15:00") @ 15 mins | ["2025-01-03 10:30:00","2025-01-03 11:00:00") @ 1 hour | ["2025-01-02 10:00:00","2025-01-02 12:00:00") @ 1 hour | ["2025-01-03 10:00:00","2025-01-03 11:00:00") ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_bgw-15.out������������������������������������������������0000664�0000000�0000000�00000136153�15100345067�0022162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; --test that this all works under the community license ALTER DATABASE :TEST_DBNAME SET timescaledb.license_key='Community'; --create a function with no permissions to execute CREATE FUNCTION get_constant_no_perms() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant_no_perms() FROM PUBLIC; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- SELECT * FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | raw_hypertable_id | parent_mat_hypertable_id | user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name | materialized_only | finalized -------------------+-------------------+--------------------------+------------------+----------------+---------------------+-------------------+--------------------+------------------+-------------------+----------- -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO :ROLE_DEFAULT_PERM_USER; WARNING: no privileges were granted for "public" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_continuous_agg_table(time int, data int); SELECT create_hypertable('test_continuous_agg_table', 'time', chunk_time_interval => 10); create_hypertable ---------------------------------------- (1,public,test_continuous_agg_table,t) CREATE OR REPLACE FUNCTION integer_now_test() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table $$; SELECT set_integer_now_func('test_continuous_agg_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', NULL, 4::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 SELECT id as raw_table_id FROM _timescaledb_catalog.hypertable WHERE table_name='test_continuous_agg_table' \gset -- min distance from end should be 1 SELECT mat_hypertable_id, user_view_schema, user_view_name FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | user_view_schema | user_view_name -------------------+------------------+-------------------------- 2 | public | test_continuous_agg_view SELECT mat_hypertable_id, bucket_width FROM _timescaledb_catalog.continuous_aggs_bucket_function; mat_hypertable_id | bucket_width -------------------+-------------- 2 | 2 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id \gset -- job was created SELECT * FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- create 10 time buckets INSERT INTO test_continuous_agg_table SELECT i, i FROM (SELECT generate_series(0, 10) as i) AS j; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- -- no data in view SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 1 of 3) 1 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 2 of 3) 4 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -2147483648, 2 ] (batch 3 of 3) 7 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" SELECT * FROM _timescaledb_config.bgw_job where id=:job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- job ran once, successfully SELECT job_id, next_start-last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1000 | @ 12 hours | t | 1 | 1 | 0 | 0 --clear log for next run of scheduler. TRUNCATE public.bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; --make sure there is 1 job to start with SELECT test.wait_for_job_to_run(:job_id, 1); wait_for_job_to_run --------------------- t SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --start the scheduler on 0 time SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run(extract(epoch from interval '24 hour')::int * 1000, 0); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t --advance to 12:00 so that it runs one more time; now we know the --scheduler has loaded up the job with the old schedule_interval SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 2); wait_for_job_to_run --------------------- t --advance clock 1us to make the scheduler realize the job is done SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+1, true); ts_bgw_params_reset_time -------------------------- --alter the refresh interval and check if next_start is altered SELECT alter_job(:job_id, schedule_interval => '1m', retry_period => '1m'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:01:00 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT job_id, next_start - last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id;; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 2 --advance to 12:02, job should have run at 12:01 SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 3); wait_for_job_to_run --------------------- t --next run in 1 minute SELECT job_id, next_start-last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 3 --change next run to be after 30s instead SELECT (next_start - '30s'::interval) AS "NEW_NEXT_START" FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id \gset SELECT alter_job(:job_id, next_start => :'NEW_NEXT_START'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:02:30 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute 30 seconds')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 4); wait_for_job_to_run --------------------- t --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- TRUNCATE public.bgw_log; -- data before 8 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 -- invalidations test by running job multiple times SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_3_chunk CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE hypertable_id=:mat_hypertable_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" -- job ran once, successfully SELECT job_id, last_finish - next_start as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+----------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours ago | t | 1 | 1 | 0 | 0 -- should have refreshed everything we have so far SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 13 8 | 17 10 | 10 -- invalidate some data UPDATE test_continuous_agg_table SET data = 11 WHERE time = 6; --advance time by 12h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours | t | 2 | 2 | 0 | 0 -- should have updated data for time=6 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 18 8 | 17 10 | 10 \x on --check the information views -- select view_name, view_owner, materialization_hypertable_schema, materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---------------------+--------------------------- view_name | test_continuous_agg_view view_owner | default_perm_user materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_3 select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---+------------------------------------------------------------------------- view_name | test_continuous_agg_view view_definition | SELECT time_bucket(2, test_continuous_agg_table."time") AS time_bucket,+ | sum(test_continuous_agg_table.data) AS value + | FROM test_continuous_agg_table + | GROUP BY (time_bucket(2, test_continuous_agg_table."time")); select job_status, last_run_duration from timescaledb_information.job_stats ps, timescaledb_information.continuous_aggregates cagg where cagg.view_name::text like '%test_continuous_agg_view' and cagg.materialization_hypertable_name = ps.hypertable_name; -[ RECORD 1 ]-----+---------- job_status | Scheduled last_run_duration | \x off -- test merged refresh (change data in two chunks) UPDATE test_continuous_agg_table SET data = 11; --advance time by 1day so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1day')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 86400000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 86400000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 1 of 5) 1 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 2 of 5) 4 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 3 of 5) 7 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 4 of 5) 10 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 5 of 5) 13 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_4_chunk --create a view with a function that it has no permission to execute CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value, get_constant_no_perms() FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- job fails SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1002 | f | 1 | 0 | 1 | 0 DROP MATERIALIZED VIEW test_continuous_agg_view; --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --clear log for next run of the scheduler TRUNCATE public.bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- -- -- Test creating continuous aggregate with a user that is the non-owner of the raw table -- CREATE TABLE test_continuous_agg_table_w_grant(time int, data int); SELECT create_hypertable('test_continuous_agg_table_w_grant', 'time', chunk_time_interval => 10); create_hypertable ------------------------------------------------ (5,public,test_continuous_agg_table_w_grant,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table_w_grant $$; SELECT set_integer_now_func('test_continuous_agg_table_w_grant', 'integer_now_test1'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON test_continuous_agg_table_w_grant TO public; INSERT INTO test_continuous_agg_table_w_grant SELECT 1 , 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- make sure view can be created CREATE MATERIALIZED VIEW test_continuous_agg_view_user_2 WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table_w_grant GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view_user_2', NULL, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1003 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT id, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id ; id | owner ------+--------------------- 1003 | default_perm_user_2 SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1003 | @ 12 hours | t | 1 | 1 | 0 | 0 --view is populated SELECT * FROM test_continuous_agg_view_user_2 ORDER BY 1; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke permissions from the continuous agg view owner to select from raw table --no further updates to cont agg should happen REVOKE SELECT ON test_continuous_agg_table_w_grant FROM public; --add new data to table INSERT INTO test_continuous_agg_table_w_grant VALUES(5,1); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --advance time by 12h so that job tries to run one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ --should show a failing execution because no longer has permissions (due to lack of permission on partial view owner's part) SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1003 | f | 2 | 1 | 1 | 0 --view was NOT updated; but the old stuff is still there SELECT * FROM test_continuous_agg_view_user_2; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * from sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1003] | refresh window size (2) is smaller than or equal to batch size (2), falling back to single batch processing 1 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view_user_2" in window [ -2147483648, 2 ] 2 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_6" 3 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_6" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | job 1003 threw an error 1 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | permission denied for table test_continuous_agg_table_w_grant -- Count the number of continuous aggregate policies SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_refresh_continuous_aggregate'; count ------- 1 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_bgw-16.out������������������������������������������������0000664�0000000�0000000�00000135751�15100345067�0022166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; --test that this all works under the community license ALTER DATABASE :TEST_DBNAME SET timescaledb.license_key='Community'; --create a function with no permissions to execute CREATE FUNCTION get_constant_no_perms() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant_no_perms() FROM PUBLIC; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- SELECT * FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | raw_hypertable_id | parent_mat_hypertable_id | user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name | materialized_only | finalized -------------------+-------------------+--------------------------+------------------+----------------+---------------------+-------------------+--------------------+------------------+-------------------+----------- -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO :ROLE_DEFAULT_PERM_USER; WARNING: no privileges were granted for "public" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_continuous_agg_table(time int, data int); SELECT create_hypertable('test_continuous_agg_table', 'time', chunk_time_interval => 10); create_hypertable ---------------------------------------- (1,public,test_continuous_agg_table,t) CREATE OR REPLACE FUNCTION integer_now_test() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table $$; SELECT set_integer_now_func('test_continuous_agg_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', NULL, 4::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 SELECT id as raw_table_id FROM _timescaledb_catalog.hypertable WHERE table_name='test_continuous_agg_table' \gset -- min distance from end should be 1 SELECT mat_hypertable_id, user_view_schema, user_view_name FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | user_view_schema | user_view_name -------------------+------------------+-------------------------- 2 | public | test_continuous_agg_view SELECT mat_hypertable_id, bucket_width FROM _timescaledb_catalog.continuous_aggs_bucket_function; mat_hypertable_id | bucket_width -------------------+-------------- 2 | 2 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id \gset -- job was created SELECT * FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- create 10 time buckets INSERT INTO test_continuous_agg_table SELECT i, i FROM (SELECT generate_series(0, 10) as i) AS j; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- -- no data in view SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 1 of 3) 1 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 2 of 3) 4 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -2147483648, 2 ] (batch 3 of 3) 7 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" SELECT * FROM _timescaledb_config.bgw_job where id=:job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- job ran once, successfully SELECT job_id, next_start-last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1000 | @ 12 hours | t | 1 | 1 | 0 | 0 --clear log for next run of scheduler. TRUNCATE public.bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; --make sure there is 1 job to start with SELECT test.wait_for_job_to_run(:job_id, 1); wait_for_job_to_run --------------------- t SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --start the scheduler on 0 time SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run(extract(epoch from interval '24 hour')::int * 1000, 0); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t --advance to 12:00 so that it runs one more time; now we know the --scheduler has loaded up the job with the old schedule_interval SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 2); wait_for_job_to_run --------------------- t --advance clock 1us to make the scheduler realize the job is done SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+1, true); ts_bgw_params_reset_time -------------------------- --alter the refresh interval and check if next_start is altered SELECT alter_job(:job_id, schedule_interval => '1m', retry_period => '1m'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:01:00 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT job_id, next_start - last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id;; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 2 --advance to 12:02, job should have run at 12:01 SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 3); wait_for_job_to_run --------------------- t --next run in 1 minute SELECT job_id, next_start-last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 3 --change next run to be after 30s instead SELECT (next_start - '30s'::interval) AS "NEW_NEXT_START" FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id \gset SELECT alter_job(:job_id, next_start => :'NEW_NEXT_START'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:02:30 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute 30 seconds')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 4); wait_for_job_to_run --------------------- t --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- TRUNCATE public.bgw_log; -- data before 8 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 -- invalidations test by running job multiple times SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_3_chunk CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE hypertable_id=:mat_hypertable_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" -- job ran once, successfully SELECT job_id, last_finish - next_start as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+----------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours ago | t | 1 | 1 | 0 | 0 -- should have refreshed everything we have so far SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 13 8 | 17 10 | 10 -- invalidate some data UPDATE test_continuous_agg_table SET data = 11 WHERE time = 6; --advance time by 12h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours | t | 2 | 2 | 0 | 0 -- should have updated data for time=6 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 18 8 | 17 10 | 10 \x on --check the information views -- select view_name, view_owner, materialization_hypertable_schema, materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---------------------+--------------------------- view_name | test_continuous_agg_view view_owner | default_perm_user materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_3 select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---+----------------------------------------------- view_name | test_continuous_agg_view view_definition | SELECT time_bucket(2, "time") AS time_bucket,+ | sum(data) AS value + | FROM test_continuous_agg_table + | GROUP BY (time_bucket(2, "time")); select job_status, last_run_duration from timescaledb_information.job_stats ps, timescaledb_information.continuous_aggregates cagg where cagg.view_name::text like '%test_continuous_agg_view' and cagg.materialization_hypertable_name = ps.hypertable_name; -[ RECORD 1 ]-----+---------- job_status | Scheduled last_run_duration | \x off -- test merged refresh (change data in two chunks) UPDATE test_continuous_agg_table SET data = 11; --advance time by 1day so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1day')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 86400000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 86400000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 1 of 5) 1 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 2 of 5) 4 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 3 of 5) 7 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 4 of 5) 10 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 5 of 5) 13 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_4_chunk --create a view with a function that it has no permission to execute CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value, get_constant_no_perms() FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- job fails SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1002 | f | 1 | 0 | 1 | 0 DROP MATERIALIZED VIEW test_continuous_agg_view; --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --clear log for next run of the scheduler TRUNCATE public.bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- -- -- Test creating continuous aggregate with a user that is the non-owner of the raw table -- CREATE TABLE test_continuous_agg_table_w_grant(time int, data int); SELECT create_hypertable('test_continuous_agg_table_w_grant', 'time', chunk_time_interval => 10); create_hypertable ------------------------------------------------ (5,public,test_continuous_agg_table_w_grant,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table_w_grant $$; SELECT set_integer_now_func('test_continuous_agg_table_w_grant', 'integer_now_test1'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON test_continuous_agg_table_w_grant TO public; INSERT INTO test_continuous_agg_table_w_grant SELECT 1 , 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- make sure view can be created CREATE MATERIALIZED VIEW test_continuous_agg_view_user_2 WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table_w_grant GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view_user_2', NULL, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1003 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT id, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id ; id | owner ------+--------------------- 1003 | default_perm_user_2 SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1003 | @ 12 hours | t | 1 | 1 | 0 | 0 --view is populated SELECT * FROM test_continuous_agg_view_user_2 ORDER BY 1; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke permissions from the continuous agg view owner to select from raw table --no further updates to cont agg should happen REVOKE SELECT ON test_continuous_agg_table_w_grant FROM public; --add new data to table INSERT INTO test_continuous_agg_table_w_grant VALUES(5,1); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --advance time by 12h so that job tries to run one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ --should show a failing execution because no longer has permissions (due to lack of permission on partial view owner's part) SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1003 | f | 2 | 1 | 1 | 0 --view was NOT updated; but the old stuff is still there SELECT * FROM test_continuous_agg_view_user_2; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * from sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1003] | refresh window size (2) is smaller than or equal to batch size (2), falling back to single batch processing 1 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view_user_2" in window [ -2147483648, 2 ] 2 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_6" 3 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_6" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | job 1003 threw an error 1 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | permission denied for table test_continuous_agg_table_w_grant -- Count the number of continuous aggregate policies SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_refresh_continuous_aggregate'; count ------- 1 �����������������������timescaledb-2.23.0/tsl/test/expected/cagg_bgw-17.out������������������������������������������������0000664�0000000�0000000�00000135751�15100345067�0022167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; --test that this all works under the community license ALTER DATABASE :TEST_DBNAME SET timescaledb.license_key='Community'; --create a function with no permissions to execute CREATE FUNCTION get_constant_no_perms() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant_no_perms() FROM PUBLIC; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- SELECT * FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | raw_hypertable_id | parent_mat_hypertable_id | user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name | materialized_only | finalized -------------------+-------------------+--------------------------+------------------+----------------+---------------------+-------------------+--------------------+------------------+-------------------+----------- -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO :ROLE_DEFAULT_PERM_USER; WARNING: no privileges were granted for "public" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_continuous_agg_table(time int, data int); SELECT create_hypertable('test_continuous_agg_table', 'time', chunk_time_interval => 10); create_hypertable ---------------------------------------- (1,public,test_continuous_agg_table,t) CREATE OR REPLACE FUNCTION integer_now_test() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table $$; SELECT set_integer_now_func('test_continuous_agg_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', NULL, 4::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 SELECT id as raw_table_id FROM _timescaledb_catalog.hypertable WHERE table_name='test_continuous_agg_table' \gset -- min distance from end should be 1 SELECT mat_hypertable_id, user_view_schema, user_view_name FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | user_view_schema | user_view_name -------------------+------------------+-------------------------- 2 | public | test_continuous_agg_view SELECT mat_hypertable_id, bucket_width FROM _timescaledb_catalog.continuous_aggs_bucket_function; mat_hypertable_id | bucket_width -------------------+-------------- 2 | 2 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id \gset -- job was created SELECT * FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- create 10 time buckets INSERT INTO test_continuous_agg_table SELECT i, i FROM (SELECT generate_series(0, 10) as i) AS j; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- -- no data in view SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 1 of 3) 1 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 2 of 3) 4 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -2147483648, 2 ] (batch 3 of 3) 7 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" SELECT * FROM _timescaledb_config.bgw_job where id=:job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- job ran once, successfully SELECT job_id, next_start-last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1000 | @ 12 hours | t | 1 | 1 | 0 | 0 --clear log for next run of scheduler. TRUNCATE public.bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; --make sure there is 1 job to start with SELECT test.wait_for_job_to_run(:job_id, 1); wait_for_job_to_run --------------------- t SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --start the scheduler on 0 time SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run(extract(epoch from interval '24 hour')::int * 1000, 0); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t --advance to 12:00 so that it runs one more time; now we know the --scheduler has loaded up the job with the old schedule_interval SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 2); wait_for_job_to_run --------------------- t --advance clock 1us to make the scheduler realize the job is done SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+1, true); ts_bgw_params_reset_time -------------------------- --alter the refresh interval and check if next_start is altered SELECT alter_job(:job_id, schedule_interval => '1m', retry_period => '1m'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:01:00 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT job_id, next_start - last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id;; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 2 --advance to 12:02, job should have run at 12:01 SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 3); wait_for_job_to_run --------------------- t --next run in 1 minute SELECT job_id, next_start-last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 3 --change next run to be after 30s instead SELECT (next_start - '30s'::interval) AS "NEW_NEXT_START" FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id \gset SELECT alter_job(:job_id, next_start => :'NEW_NEXT_START'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:02:30 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute 30 seconds')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 4); wait_for_job_to_run --------------------- t --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- TRUNCATE public.bgw_log; -- data before 8 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 -- invalidations test by running job multiple times SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_3_chunk CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE hypertable_id=:mat_hypertable_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" -- job ran once, successfully SELECT job_id, last_finish - next_start as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+----------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours ago | t | 1 | 1 | 0 | 0 -- should have refreshed everything we have so far SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 13 8 | 17 10 | 10 -- invalidate some data UPDATE test_continuous_agg_table SET data = 11 WHERE time = 6; --advance time by 12h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours | t | 2 | 2 | 0 | 0 -- should have updated data for time=6 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 18 8 | 17 10 | 10 \x on --check the information views -- select view_name, view_owner, materialization_hypertable_schema, materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---------------------+--------------------------- view_name | test_continuous_agg_view view_owner | default_perm_user materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_3 select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---+----------------------------------------------- view_name | test_continuous_agg_view view_definition | SELECT time_bucket(2, "time") AS time_bucket,+ | sum(data) AS value + | FROM test_continuous_agg_table + | GROUP BY (time_bucket(2, "time")); select job_status, last_run_duration from timescaledb_information.job_stats ps, timescaledb_information.continuous_aggregates cagg where cagg.view_name::text like '%test_continuous_agg_view' and cagg.materialization_hypertable_name = ps.hypertable_name; -[ RECORD 1 ]-----+---------- job_status | Scheduled last_run_duration | \x off -- test merged refresh (change data in two chunks) UPDATE test_continuous_agg_table SET data = 11; --advance time by 1day so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1day')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 86400000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 86400000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 1 of 5) 1 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 2 of 5) 4 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 3 of 5) 7 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 4 of 5) 10 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 5 of 5) 13 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_4_chunk --create a view with a function that it has no permission to execute CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value, get_constant_no_perms() FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- job fails SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1002 | f | 1 | 0 | 1 | 0 DROP MATERIALIZED VIEW test_continuous_agg_view; --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --clear log for next run of the scheduler TRUNCATE public.bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- -- -- Test creating continuous aggregate with a user that is the non-owner of the raw table -- CREATE TABLE test_continuous_agg_table_w_grant(time int, data int); SELECT create_hypertable('test_continuous_agg_table_w_grant', 'time', chunk_time_interval => 10); create_hypertable ------------------------------------------------ (5,public,test_continuous_agg_table_w_grant,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table_w_grant $$; SELECT set_integer_now_func('test_continuous_agg_table_w_grant', 'integer_now_test1'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON test_continuous_agg_table_w_grant TO public; INSERT INTO test_continuous_agg_table_w_grant SELECT 1 , 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- make sure view can be created CREATE MATERIALIZED VIEW test_continuous_agg_view_user_2 WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table_w_grant GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view_user_2', NULL, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1003 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT id, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id ; id | owner ------+--------------------- 1003 | default_perm_user_2 SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1003 | @ 12 hours | t | 1 | 1 | 0 | 0 --view is populated SELECT * FROM test_continuous_agg_view_user_2 ORDER BY 1; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke permissions from the continuous agg view owner to select from raw table --no further updates to cont agg should happen REVOKE SELECT ON test_continuous_agg_table_w_grant FROM public; --add new data to table INSERT INTO test_continuous_agg_table_w_grant VALUES(5,1); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --advance time by 12h so that job tries to run one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ --should show a failing execution because no longer has permissions (due to lack of permission on partial view owner's part) SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1003 | f | 2 | 1 | 1 | 0 --view was NOT updated; but the old stuff is still there SELECT * FROM test_continuous_agg_view_user_2; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * from sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1003] | refresh window size (2) is smaller than or equal to batch size (2), falling back to single batch processing 1 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view_user_2" in window [ -2147483648, 2 ] 2 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_6" 3 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_6" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | job 1003 threw an error 1 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | permission denied for table test_continuous_agg_table_w_grant -- Count the number of continuous aggregate policies SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_refresh_continuous_aggregate'; count ------- 1 �����������������������timescaledb-2.23.0/tsl/test/expected/cagg_bgw-18.out������������������������������������������������0000664�0000000�0000000�00000135751�15100345067�0022170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; --test that this all works under the community license ALTER DATABASE :TEST_DBNAME SET timescaledb.license_key='Community'; --create a function with no permissions to execute CREATE FUNCTION get_constant_no_perms() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant_no_perms() FROM PUBLIC; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- SELECT * FROM timescaledb_information.job_stats; hypertable_schema | hypertable_name | job_id | last_run_started_at | last_successful_finish | last_run_status | job_status | last_run_duration | next_start | total_runs | total_successes | total_failures -------------------+-----------------+--------+---------------------+------------------------+-----------------+------------+-------------------+------------+------------+-----------------+---------------- SELECT * FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | raw_hypertable_id | parent_mat_hypertable_id | user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name | materialized_only | finalized -------------------+-------------------+--------------------------+------------------+----------------+---------------------+-------------------+--------------------+------------------+-------------------+----------- -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO :ROLE_DEFAULT_PERM_USER; WARNING: no privileges were granted for "public" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_continuous_agg_table(time int, data int); SELECT create_hypertable('test_continuous_agg_table', 'time', chunk_time_interval => 10); create_hypertable ---------------------------------------- (1,public,test_continuous_agg_table,t) CREATE OR REPLACE FUNCTION integer_now_test() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table $$; SELECT set_integer_now_func('test_continuous_agg_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', NULL, 4::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 SELECT id as raw_table_id FROM _timescaledb_catalog.hypertable WHERE table_name='test_continuous_agg_table' \gset -- min distance from end should be 1 SELECT mat_hypertable_id, user_view_schema, user_view_name FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | user_view_schema | user_view_name -------------------+------------------+-------------------------- 2 | public | test_continuous_agg_view SELECT mat_hypertable_id, bucket_width FROM _timescaledb_catalog.continuous_aggs_bucket_function; mat_hypertable_id | bucket_width -------------------+-------------- 2 | 2 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id \gset -- job was created SELECT * FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- create 10 time buckets INSERT INTO test_continuous_agg_table SELECT i, i FROM (SELECT generate_series(0, 10) as i) AS j; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; job_id | next_start | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------+------------------+------------+-----------------+----------------+--------------- -- no data in view SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 1 of 3) 1 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 2 of 3) 4 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -2147483648, 2 ] (batch 3 of 3) 7 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" SELECT * FROM _timescaledb_config.bgw_job where id=:job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 4, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | -- job ran once, successfully SELECT job_id, next_start-last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1000 | @ 12 hours | t | 1 | 1 | 0 | 0 --clear log for next run of scheduler. TRUNCATE public.bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; --make sure there is 1 job to start with SELECT test.wait_for_job_to_run(:job_id, 1); wait_for_job_to_run --------------------- t SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --start the scheduler on 0 time SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run(extract(epoch from interval '24 hour')::int * 1000, 0); ts_bgw_db_scheduler_test_run ------------------------------ SELECT wait_for_timer_to_run(0); wait_for_timer_to_run ----------------------- t --advance to 12:00 so that it runs one more time; now we know the --scheduler has loaded up the job with the old schedule_interval SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 2); wait_for_job_to_run --------------------- t --advance clock 1us to make the scheduler realize the job is done SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+1, true); ts_bgw_params_reset_time -------------------------- --alter the refresh interval and check if next_start is altered SELECT alter_job(:job_id, schedule_interval => '1m', retry_period => '1m'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:01:00 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT job_id, next_start - last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id;; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 2 --advance to 12:02, job should have run at 12:01 SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 3); wait_for_job_to_run --------------------- t --next run in 1 minute SELECT job_id, next_start-last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id; job_id | until_next | total_runs --------+------------+------------ 1000 | @ 1 min | 3 --change next run to be after 30s instead SELECT (next_start - '30s'::interval) AS "NEW_NEXT_START" FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id \gset SELECT alter_job(:job_id, next_start => :'NEW_NEXT_START'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 min","@ 0",-1,"@ 1 min",t,"{""end_offset"": 4, ""start_offset"": null, ""mat_hypertable_id"": 2}","Sat Jan 01 04:02:30 2000 PST",_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute 30 seconds')::bigint * 1000000), true); ts_bgw_params_reset_time -------------------------- SELECT test.wait_for_job_to_run(:job_id, 4); wait_for_job_to_run --------------------- t --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- TRUNCATE public.bgw_log; -- data before 8 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 -- invalidations test by running job multiple times SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_3_chunk CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE hypertable_id=:mat_hypertable_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" -- job ran once, successfully SELECT job_id, last_finish - next_start as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+----------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours ago | t | 1 | 1 | 0 | 0 -- should have refreshed everything we have so far SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 13 8 | 17 10 | 10 -- invalidate some data UPDATE test_continuous_agg_table SET data = 11 WHERE time = 6; --advance time by 12h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1001 | @ 12 hours | t | 2 | 2 | 0 | 0 -- should have updated data for time=6 SELECT * FROM test_continuous_agg_view ORDER BY 1; time_bucket | value -------------+------- 0 | 1 2 | 5 4 | 9 6 | 18 8 | 17 10 | 10 \x on --check the information views -- select view_name, view_owner, materialization_hypertable_schema, materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---------------------+--------------------------- view_name | test_continuous_agg_view view_owner | default_perm_user materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_3 select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; -[ RECORD 1 ]---+----------------------------------------------- view_name | test_continuous_agg_view view_definition | SELECT time_bucket(2, "time") AS time_bucket,+ | sum(data) AS value + | FROM test_continuous_agg_table + | GROUP BY (time_bucket(2, "time")); select job_status, last_run_duration from timescaledb_information.job_stats ps, timescaledb_information.continuous_aggregates cagg where cagg.view_name::text like '%test_continuous_agg_view' and cagg.materialization_hypertable_name = ps.hypertable_name; -[ RECORD 1 ]-----+---------- job_status | Scheduled last_run_duration | \x off -- test merged refresh (change data in two chunks) UPDATE test_continuous_agg_table SET data = 11; --advance time by 1day so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1day')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50, 50); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 10, 12 ] (batch 1 of 6) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 2 of 6) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 3 of 6) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 4 of 6) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 5 of 6) 13 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 15 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 6 of 6) 16 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 17 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | no valid batches produced for continuous aggregate "public.test_continuous_agg_view", falling back to single batch processing 1 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ -90, 0 ] 2 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 4 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] 5 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 43200000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 0 | 86400000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 86400000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 8, 10 ] (batch 1 of 5) 1 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 3 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 6, 8 ] (batch 2 of 5) 4 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 5 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 6 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 4, 6 ] (batch 3 of 5) 7 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 8 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 9 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 2, 4 ] (batch 4 of 5) 10 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 11 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" 12 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view" in window [ 0, 2 ] (batch 5 of 5) 13 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 14 | 86400000000 | Refresh Continuous Aggregate Policy [1001] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" DROP MATERIALIZED VIEW test_continuous_agg_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_4_chunk --create a view with a function that it has no permission to execute CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value, get_constant_no_perms() FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ -- job fails SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1002 | f | 1 | 0 | 1 | 0 DROP MATERIALIZED VIEW test_continuous_agg_view; --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); ts_bgw_db_scheduler_test_wait_for_scheduler_finish ---------------------------------------------------- SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); ts_bgw_params_mock_wait_returns_immediately --------------------------------------------- --clear log for next run of the scheduler TRUNCATE public.bgw_log; SELECT ts_bgw_params_reset_time(); ts_bgw_params_reset_time -------------------------- -- -- Test creating continuous aggregate with a user that is the non-owner of the raw table -- CREATE TABLE test_continuous_agg_table_w_grant(time int, data int); SELECT create_hypertable('test_continuous_agg_table_w_grant', 'time', chunk_time_interval => 10); create_hypertable ------------------------------------------------ (5,public,test_continuous_agg_table_w_grant,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table_w_grant $$; SELECT set_integer_now_func('test_continuous_agg_table_w_grant', 'integer_now_test1'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON test_continuous_agg_table_w_grant TO public; INSERT INTO test_continuous_agg_table_w_grant SELECT 1 , 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- make sure view can be created CREATE MATERIALIZED VIEW test_continuous_agg_view_user_2 WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table_w_grant GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view_user_2', NULL, -2::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1003 SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT id, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id ; id | owner ------+--------------------- 1003 | default_perm_user_2 SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | until_next | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------+------------------+------------+-----------------+----------------+--------------- 1003 | @ 12 hours | t | 1 | 1 | 0 | 0 --view is populated SELECT * FROM test_continuous_agg_view_user_2 ORDER BY 1; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke permissions from the continuous agg view owner to select from raw table --no further updates to cont agg should happen REVOKE SELECT ON test_continuous_agg_table_w_grant FROM public; --add new data to table INSERT INTO test_continuous_agg_table_w_grant VALUES(5,1); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --advance time by 12h so that job tries to run one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ --should show a failing execution because no longer has permissions (due to lack of permission on partial view owner's part) SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1003 | f | 2 | 1 | 1 | 0 --view was NOT updated; but the old stuff is still there SELECT * FROM test_continuous_agg_view_user_2; time_bucket | value -------------+------- 0 | 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * from sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1003] | refresh window size (2) is smaller than or equal to batch size (2), falling back to single batch processing 1 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "test_continuous_agg_view_user_2" in window [ -2147483648, 2 ] 2 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_6" 3 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_6" 0 | 43200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 43200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | job 1003 threw an error 1 | 43200000000 | Refresh Continuous Aggregate Policy [1003] | permission denied for table test_continuous_agg_table_w_grant -- Count the number of continuous aggregate policies SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_refresh_continuous_aggregate'; count ------- 1 �����������������������timescaledb-2.23.0/tsl/test/expected/cagg_bgw_drop_chunks.out���������������������������������������0000664�0000000�0000000�00000012120�15100345067�0024321�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup for testing bgw jobs --- -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT * FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- ----------------------------------- -- test drop chunks policy runs for materialized hypertables created for -- cont. aggregates ----------------------------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE drop_chunks_table(time BIGINT, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 1) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT 40::bigint $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view1 WITH (timescaledb.continuous) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; --raw hypertable will have 40 chunks and the mat. hypertable will have 2 and 4 -- chunks respectively SELECT set_chunk_time_interval('_timescaledb_internal._materialized_hypertable_2', 10); set_chunk_time_interval ------------------------- \set ON_ERROR_STOP 0 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(1, 39) AS i; \set ON_ERROR_STOP 1 CALL refresh_continuous_aggregate('drop_chunks_view1', NULL, NULL); --TEST1 specify drop chunks policy on mat. hypertable by -- directly does not work \set ON_ERROR_STOP 0 SELECT add_retention_policy( '_timescaledb_internal._materialized_hypertable_2', drop_after => -50) as drop_chunks_job_id1 \gset ERROR: cannot add retention policy to materialized hypertable "_materialized_hypertable_2" \set ON_ERROR_STOP 1 --TEST2 specify drop chunks policy on cont. aggregate -- integer_now func on raw hypertable is used by the drop -- chunks policy SELECT hypertable_id, table_name, integer_now_func FROM _timescaledb_catalog.dimension d, _timescaledb_catalog.hypertable ht WHERE ht.id = d.hypertable_id; hypertable_id | table_name | integer_now_func ---------------+----------------------------+------------------- 1 | drop_chunks_table | integer_now_test2 2 | _materialized_hypertable_2 | SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = '_materialized_hypertable_2' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer -------------------+---------------------+------------------- _hyper_2_40_chunk | 0 | 10 _hyper_2_41_chunk | 10 | 20 _hyper_2_42_chunk | 20 | 30 _hyper_2_43_chunk | 30 | 40 SELECT add_retention_policy( 'drop_chunks_view1', drop_after => 10) as drop_chunks_job_id1 \gset SELECT alter_job(:drop_chunks_job_id1, schedule_interval => INTERVAL '1 second'); alter_job -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 sec","@ 5 mins",-1,"@ 5 mins",t,"{""drop_after"": 10, ""hypertable_id"": 2}",-infinity,_timescaledb_functions.policy_retention_check,f,,,"Retention Policy [1000]") SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(2000000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT count(c) from show_chunks('drop_chunks_view1') as c ; count ------- 1 SELECT remove_retention_policy('drop_chunks_view1'); remove_retention_policy ------------------------- \set ON_ERROR_STOP 0 SELECT remove_retention_policy('unknown'); ERROR: relation "unknown" does not exist at character 32 SELECT remove_retention_policy('1'); ERROR: relation is not a hypertable or continuous aggregate \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_config.out������������������������������������������������0000664�0000000�0000000�00000003233�15100345067�0022415�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Show the defaults SHOW timescaledb.cagg_processing_wal_batch_size; timescaledb.cagg_processing_wal_batch_size -------------------------------------------- 10000 SHOW timescaledb.cagg_processing_low_work_mem; timescaledb.cagg_processing_low_work_mem ------------------------------------------ 39321kB SHOW timescaledb.cagg_processing_high_work_mem; timescaledb.cagg_processing_high_work_mem ------------------------------------------- 52428kB \set VERBOSITY default \set ON_ERROR_STOP 0 SET timescaledb.cagg_processing_wal_batch_size TO 100; ERROR: 100 is outside the valid range for parameter "timescaledb.cagg_processing_wal_batch_size" (1000 .. 10000000) SET timescaledb.cagg_processing_wal_batch_size TO 10000001; ERROR: 10000001 is outside the valid range for parameter "timescaledb.cagg_processing_wal_batch_size" (1000 .. 10000000) SET timescaledb.cagg_processing_low_work_mem TO 52428; ERROR: invalid value for parameter "timescaledb.cagg_processing_low_work_mem": 52428 DETAIL: "cagg_processing_low_work_mem" must be less than value of "cagg_processing_high_work_mem". HINT: Set "cagg_processing_low_work_mem" to a value less than 52428. SET timescaledb.cagg_processing_high_work_mem TO 39321; ERROR: invalid value for parameter "timescaledb.cagg_processing_high_work_mem": 39321 DETAIL: "cagg_processing_high_work_mem" must be greater than value of "cagg_processing_low_work_mem". HINT: Set "cagg_processing_high_work_mem" to a value greater than 39321. \set ON_ERROR_STOP 1 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_ddl-15.out������������������������������������������������0000664�0000000�0000000�00000266240�15100345067�0022147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH '../../../../test/sql/include/query_result_test_equal.sql' SET ROLE :ROLE_DEFAULT_PERM_USER; --DDL commands on continuous aggregates CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions -- schema tests \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO 'UTC+8'; -- drop if the tablespace1 and/or tablespace2 exists SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; CREATE SCHEMA rename_schema; GRANT ALL ON SCHEMA rename_schema TO :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE foo(time TIMESTAMPTZ NOT NULL, data INTEGER); SELECT create_hypertable('foo', 'time'); create_hypertable ------------------- (2,public,foo,t) CREATE MATERIALIZED VIEW rename_test_old WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1week', time), COUNT(data) FROM foo GROUP BY 1 WITH NO DATA; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+-----------------+-----------------------+------------------- public | rename_test_old | _timescaledb_internal | _partial_view_3 ALTER TABLE rename_test_old RENAME TO rename_test; ALTER TABLE rename_test SET SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- test_schema | rename_test | _timescaledb_internal | _partial_view_3 ALTER MATERIALIZED VIEW test_schema.rename_test SET SCHEMA rename_schema; DROP SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- rename_schema | rename_test | _timescaledb_internal | _partial_view_3 SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'rename_test' \gset RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- rename_schema | rename_test | public | _partial_view_3 --alter direct view schema SELECT user_view_schema, user_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | direct_view_schema | direct_view_name ------------------+----------------+-----------------------+------------------ rename_schema | rename_test | _timescaledb_internal | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ rename_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA rename_schema RENAME TO new_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 ALTER VIEW :"PART_VIEW_NAME" SET SCHEMA new_name_schema; ALTER VIEW :"DIR_VIEW_NAME" SET SCHEMA new_name_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | new_name_schema | _partial_view_3 | new_name_schema | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA new_name_schema RENAME TO foo_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- foo_name_schema | rename_test | foo_name_schema | _partial_view_3 ALTER MATERIALIZED VIEW foo_name_schema.rename_test SET SCHEMA public; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | foo_name_schema | _partial_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA foo_name_schema RENAME TO rename_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | rename_schema | _partial_view_3 ALTER MATERIALIZED VIEW rename_test RENAME TO rename_c_aggregate; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+--------------------+---------------------+------------------- public | rename_c_aggregate | rename_schema | _partial_view_3 SELECT * FROM rename_c_aggregate; time_bucket | count -------------+------- ALTER VIEW rename_schema.:"PART_VIEW_NAME" RENAME TO partial_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | _direct_view_3 --rename direct view ALTER VIEW rename_schema.:"DIR_VIEW_NAME" RENAME TO direct_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | direct_view -- drop_chunks tests DROP TABLE conditions CASCADE; DROP TABLE foo CASCADE; NOTICE: drop cascades to 2 other objects CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), COUNT(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; -- Only refresh up to bucket 15 initially. Matches the old refresh -- behavior that didn't materialize everything CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- cannot drop directly from the materialization table without specifying -- cont. aggregate view name explicitly \set ON_ERROR_STOP 0 SELECT drop_chunks(:'drop_chunks_mat_table', newer_than => -20, verbose => true); ERROR: operation not supported on materialized hypertable \set ON_ERROR_STOP 1 SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- drop chunks when the chunksize and time_bucket aren't aligned DROP TABLE drop_chunks_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_5_4_chunk CREATE TABLE drop_chunks_table_u(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_u_id FROM create_hypertable('drop_chunks_table_u', 'time', chunk_time_interval => 7) \gset CREATE OR REPLACE FUNCTION integer_now_test1() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table_u $$; SELECT set_integer_now_func('drop_chunks_table_u', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('3', time), COUNT(data) FROM drop_chunks_table_u GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table_u, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_u_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_u_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table_u SELECT i, i FROM generate_series(0, 21) AS i; -- Refresh up to bucket 15 to match old materializer behavior CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table_u') AS c; count ------- 4 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 -- TRUNCATE test -- Can truncate regular hypertables that have caggs TRUNCATE drop_chunks_table_u; \set ON_ERROR_STOP 0 -- Can't truncate materialized hypertables directly TRUNCATE :drop_chunks_mat_table_u; ERROR: cannot TRUNCATE a hypertable underlying a continuous aggregate \set ON_ERROR_STOP 1 -- Check that we don't interfere with TRUNCATE of normal table and -- partitioned table CREATE TABLE truncate (value int); INSERT INTO truncate VALUES (1), (2); TRUNCATE truncate; SELECT * FROM truncate; value ------- CREATE TABLE truncate_partitioned (value int) PARTITION BY RANGE(value); CREATE TABLE truncate_p1 PARTITION OF truncate_partitioned FOR VALUES FROM (1) TO (3); INSERT INTO truncate_partitioned VALUES (1), (2); TRUNCATE truncate_partitioned; SELECT * FROM truncate_partitioned; value ------- -- ALTER TABLE tests \set ON_ERROR_STOP 0 -- test a variety of ALTER TABLE statements ALTER TABLE :drop_chunks_mat_table_u RENAME time_bucket TO bad_name; ERROR: renaming columns on materialization tables is not supported ALTER TABLE :drop_chunks_mat_table_u ADD UNIQUE(time_bucket); ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET UNLOGGED; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ENABLE ROW LEVEL SECURITY; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ADD COLUMN fizzle INTEGER; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DROP COLUMN time_bucket; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket DROP NOT NULL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET DEFAULT 1; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET STORAGE EXTERNAL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DISABLE TRIGGER ALL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET TABLESPACE foo; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u NOT OF; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u OWNER TO CURRENT_USER; ERROR: operation not supported on materialization tables \set ON_ERROR_STOP 1 ALTER TABLE :drop_chunks_mat_table_u SET SCHEMA public; ALTER TABLE :drop_chunks_mat_table_u_name RENAME TO new_name; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT * FROM new_name ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 \set ON_ERROR_STOP 0 -- no continuous aggregates on a continuous aggregate materialization table CREATE MATERIALIZED VIEW new_name_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('6', time_bucket), COUNT("count") FROM new_name GROUP BY 1 WITH NO DATA; ERROR: hypertable is a continuous aggregate materialization table \set ON_ERROR_STOP 1 CREATE TABLE metrics(time timestamptz NOT NULL, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (8,public,metrics,t) INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2 FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; time | const | numeric | first | case | coalesce | avg1 | avg2 ------------------------------+-------+---------+----------------------------------------------+------+----------+------+------ Fri Dec 31 16:00:00 1999 UTC | Const | 4.3 | ("Sat Jan 01 00:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sat Jan 01 16:00:00 2000 UTC | Const | 4.3 | ("Sat Jan 01 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sun Jan 02 16:00:00 2000 UTC | Const | 4.3 | ("Sun Jan 02 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Mon Jan 03 16:00:00 2000 UTC | Const | 4.3 | ("Mon Jan 03 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Tue Jan 04 16:00:00 2000 UTC | Const | 4.3 | ("Tue Jan 04 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 --test materialization of invalidation before drop DROP TABLE IF EXISTS drop_chunks_table CASCADE; NOTICE: table "drop_chunks_table" does not exist, skipping DROP TABLE IF EXISTS drop_chunks_table_u CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_7_9_chunk CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --dropping chunks will process the invalidations SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_13_chunk SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 10 | 10 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(20, 35) AS i; CALL refresh_continuous_aggregate('drop_chunks_view', 10, 40); --this will be seen after the drop its within the invalidation window and will be dropped INSERT INTO drop_chunks_table VALUES (26, 100); --this will not be processed by the drop since chunk 30-39 is not dropped but will be seen after refresh --shows that the drop doesn't do more work than necessary INSERT INTO drop_chunks_table VALUES (31, 200); --move the time up to 39 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(35, 39) AS i; --the chunks and ranges we have thus far SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table'; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_14_chunk | 10 | 20 _hyper_10_15_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --the invalidation on 25 not yet seen SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 29 20 | 24 15 | 19 10 | 14 --refresh to process the invalidations and then drop CALL refresh_continuous_aggregate('drop_chunks_view', NULL, (integer_now_test2()-9)); SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_14_chunk _timescaledb_internal._hyper_10_15_chunk --new values on 25 now seen in view SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 100 20 | 24 15 | 19 10 | 14 --earliest datapoint now in table SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 30 | 30 --chunks are removed SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE dropped; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- --still see data in the view SELECT * FROM drop_chunks_view WHERE time_bucket < (integer_now_test2()-9) ORDER BY time_bucket DESC; time_bucket | max -------------+----- 25 | 100 20 | 24 15 | 19 10 | 14 --no data but covers dropped chunks SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ --recreate the dropped chunk INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --see data from recreated region SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ 20 | 20 19 | 19 18 | 18 17 | 17 16 | 16 15 | 15 14 | 14 13 | 13 12 | 12 11 | 11 10 | 10 9 | 9 8 | 8 7 | 7 6 | 6 5 | 5 4 | 4 3 | 3 2 | 2 1 | 1 0 | 0 --should show chunk with old name and old ranges SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --We dropped everything up to the bucket starting at 30 and then --inserted new data up to and including time 20. Therefore, the --dropped data should stay the same as long as we only refresh --buckets that have non-dropped data. CALL refresh_continuous_aggregate('drop_chunks_view', 30, 40); SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 39 30 | 200 25 | 100 20 | 24 15 | 19 10 | 14 SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_tablen, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_nid AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- TEST drop chunks from continuous aggregates by specifying view name SELECT drop_chunks('drop_chunks_view', newer_than => -20, verbose => true); INFO: dropping chunk _timescaledb_internal._hyper_11_17_chunk drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- Test that we cannot drop chunks when specifying materialized -- hypertable INSERT INTO drop_chunks_table SELECT generate_series(45, 55), 500; CALL refresh_continuous_aggregate('drop_chunks_view', 45, 55); SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = :'drop_chunks_mat_table_name' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_11_23_chunk | 0 | 100 \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT drop_chunks(:'drop_chunks_mat_tablen', older_than => 60); ERROR: operation not supported on materialized hypertable DETAIL: Hypertable "_materialized_hypertable_11" is a materialized hypertable. HINT: Try the operation on the continuous aggregate instead. \set VERBOSITY terse \set ON_ERROR_STOP 1 ----------------------------------------------------------------- -- Test that refresh_continuous_aggregate on chunk will refresh, -- but only in the regions covered by the show chunks. ----------------------------------------------------------------- SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Pick the second chunk as the one to drop WITH numbered_chunks AS ( SELECT row_number() OVER (ORDER BY range_start_integer), chunk_schema, chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 1 ) SELECT format('%I.%I', chunk_schema, chunk_name) AS chunk_to_drop, range_start_integer, range_end_integer FROM numbered_chunks WHERE row_number = 2 \gset -- There's data in the table for the chunk/range we will drop SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 16 | 16 17 | 17 18 | 18 19 | 19 -- Make sure there is also data in the continuous aggregate -- CARE: -- Note that this behaviour of dropping the materialization table chunks and expecting a refresh -- that overlaps that time range to NOT update those chunks is undefined. CALL refresh_continuous_aggregate('drop_chunks_view', 0, 50); SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 9 10 | 14 15 | 19 20 | 20 45 | 500 50 | 500 -- Drop the second chunk, to leave a gap in the data DROP TABLE :chunk_to_drop; -- Verify that the second chunk is dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Data is no longer in the table but still in the view SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ SELECT * FROM drop_chunks_view WHERE time_bucket >= :range_start_integer AND time_bucket < :range_end_integer ORDER BY 1; time_bucket | max -------------+----- 10 | 14 15 | 19 -- Insert a large value in one of the chunks that will be dropped INSERT INTO drop_chunks_table VALUES (:range_start_integer-1, 100); -- Now refresh and drop the two adjecent chunks CALL refresh_continuous_aggregate('drop_chunks_view', NULL, 30); SELECT drop_chunks('drop_chunks_table', older_than=>30); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_18_chunk _timescaledb_internal._hyper_10_20_chunk -- Verify that the chunks are dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- The continuous aggregate should be refreshed in the regions covered -- by the dropped chunks, but not in the "gap" region, i.e., the -- region of the chunk that was dropped via DROP TABLE. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 100 20 | 20 45 | 500 50 | 500 -- Now refresh in the region of the first two dropped chunks CALL refresh_continuous_aggregate('drop_chunks_view', 0, :range_end_integer); -- Aggregate data in the refreshed range should no longer exist since -- the underlying data was dropped. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 20 | 20 45 | 500 50 | 500 -------------------------------------------------------------------- -- Check that we can create a materialized table in a tablespace. We -- create one with tablespace and one without and compare them. CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, pg_get_userbyid(relowner) AS user_view_owner, relname AS mat_table, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = mat_relid) AS mat_table_owner, direct_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = direct_view) AS direct_view_owner, partial_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = partial_view) AS partial_view_owner, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; CREATE VIEW chunk_info AS SELECT ht.schema_name, ht.table_name, relname AS chunk_name, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class c, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.table_name = c.relname AND ht.id = ch.hypertable_id; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset SELECT set_integer_now_func('whatever', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW whatever_view_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW whatever_view_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) TABLESPACE tablespace1 AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; CALL refresh_continuous_aggregate('whatever_view_1', NULL, NULL); CALL refresh_continuous_aggregate('whatever_view_2', NULL, NULL); SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | | _hyper_13_27_chunk | whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 ALTER MATERIALIZED VIEW whatever_view_1 SET TABLESPACE tablespace2; SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | tablespace2 | _hyper_13_27_chunk | tablespace2 whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 DROP MATERIALIZED VIEW whatever_view_1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_27_chunk DROP MATERIALIZED VIEW whatever_view_2; NOTICE: drop cascades to table _timescaledb_internal._hyper_14_28_chunk -- test bucket width expressions on integer hypertables CREATE TABLE metrics_int2 ( time int2 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int4 ( time int4 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int8 ( time int8 NOT NULL, device_id int, v1 float, v2 float ); SELECT create_hypertable (('metrics_' || dt)::regclass, 'time', chunk_time_interval => 10) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); create_hypertable ---------------------------- (15,public,metrics_int2,t) (16,public,metrics_int4,t) (17,public,metrics_int8,t) CREATE OR REPLACE FUNCTION int2_now () RETURNS int2 LANGUAGE SQL STABLE AS $$ SELECT 10::int2 $$; CREATE OR REPLACE FUNCTION int4_now () RETURNS int4 LANGUAGE SQL STABLE AS $$ SELECT 10::int4 $$; CREATE OR REPLACE FUNCTION int8_now () RETURNS int8 LANGUAGE SQL STABLE AS $$ SELECT 10::int8 $$; SELECT set_integer_now_func (('metrics_' || dt)::regclass, (dt || '_now')::regproc) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); set_integer_now_func ---------------------- -- width expression for int2 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint + 2::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int4 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int8 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; \set ON_ERROR_STOP 0 -- non-immutable expresions should be rejected CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::smallint, time) FROM metrics_int2 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int4 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int8 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function \set ON_ERROR_STOP 1 -- Test various ALTER MATERIALIZED VIEW statements. SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE MATERIALIZED VIEW owner_check WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1 WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | default_perm_user mat_table | _materialized_hypertable_24 mat_table_owner | default_perm_user direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | default_perm_user partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | default_perm_user tablespace | \x off -- This should not work since the target user has the wrong role, but -- we test that the normal checks are done when changing the owner. \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; ERROR: must be member of role "test_role_1" \set ON_ERROR_STOP 1 -- Superuser can always change owner SET ROLE :ROLE_CLUSTER_SUPERUSER; ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | test_role_1 mat_table | _materialized_hypertable_24 mat_table_owner | test_role_1 direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | test_role_1 partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | test_role_1 tablespace | \x off -- -- Test drop continuous aggregate cases -- -- Issue: #2608 -- CREATE OR REPLACE FUNCTION test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE conditionsnm(time_int INT NOT NULL, device INT, value FLOAT); SELECT create_hypertable('conditionsnm', 'time_int', chunk_time_interval => 10); create_hypertable ---------------------------- (25,public,conditionsnm,t) SELECT set_integer_now_func('conditionsnm', 'test_int_now'); set_integer_now_func ---------------------- INSERT INTO conditionsnm SELECT time_val, time_val % 4, 3.14 FROM generate_series(0,100,1) AS time_val; -- Case 1: DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4; NOTICE: drop cascades to table _timescaledb_internal._hyper_26_40_chunk -- Case 2: DROP CASCADE should have similar behaviour as DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4 CASCADE; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_41_chunk -- Case 3: require CASCADE in case of dependent object CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" CREATE VIEW see_cagg as select * from conditionsnm_4; \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW conditionsnm_4; ERROR: cannot drop view conditionsnm_4 because other objects depend on it \set ON_ERROR_STOP 1 -- Case 4: DROP CASCADE with dependency DROP MATERIALIZED VIEW conditionsnm_4 CASCADE; NOTICE: drop cascades to view see_cagg NOTICE: drop cascades to table _timescaledb_internal._hyper_28_42_chunk -- Test DROP SCHEMA CASCADE with continuous aggregates -- -- Issue: #2350 -- -- Case 1: DROP SCHEMA CASCADE CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (29,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.telemetry_1s WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'telemetry_1s'; raw_hypertable_id | schema_name | MAT_TABLE_NAME | PART_VIEW_NAME | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 29 | _timescaledb_internal | _materialized_hypertable_30 | _partial_view_30 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 4 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'telemetry_1s'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 -- Case 2: DROP SCHEMA CASCADE with multiple caggs CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (31,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; CREATE MATERIALIZED VIEW test_schema.cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME1", partial_view_name as "PART_VIEW_NAME1", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg1'; raw_hypertable_id | schema_name | MAT_TABLE_NAME1 | PART_VIEW_NAME1 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_32 | _partial_view_32 | _timescaledb_internal \gset SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME2", partial_view_name as "PART_VIEW_NAME2", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg2'; raw_hypertable_id | schema_name | MAT_TABLE_NAME2 | PART_VIEW_NAME2 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_33 | _partial_view_33 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 7 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg2'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Check that we can rename a column of a materialized view and still -- rebuild it after (#3051, #3405) CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (34,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'por', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT format('%I.%I', '_timescaledb_internal', h.table_name) AS "MAT_TABLE_NAME", format('%I.%I', '_timescaledb_internal', partial_view_name) AS "PART_VIEW_NAME", format('%I.%I', '_timescaledb_internal', direct_view_name) AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_daily' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns('conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | t avg | double precision | f ALTER MATERIALIZED VIEW conditions_daily RENAME COLUMN bucket to "time"; -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns(' conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | t avg | double precision | f -- This will rebuild the materialized view and should succeed. ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only = false); -- Refresh the continuous aggregate to check that it works after the -- rename. \set VERBOSITY verbose CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); \set VERBOSITY terse -- -- Indexes on continuous aggregate -- \set ON_ERROR_STOP 0 -- unique indexes are not supported CREATE UNIQUE INDEX index_unique_error ON conditions_daily ("time", location); ERROR: continuous aggregates do not support UNIQUE indexes -- concurrently index creation not supported CREATE INDEX CONCURRENTLY index_concurrently_avg ON conditions_daily (avg); ERROR: hypertables do not support concurrent index creation \set ON_ERROR_STOP 1 CREATE INDEX index_avg ON conditions_daily (avg); CREATE INDEX index_avg_only ON ONLY conditions_daily (avg); CREATE INDEX index_avg_include ON conditions_daily (avg) INCLUDE (location); CREATE INDEX index_avg_expr ON conditions_daily ((avg + 1)); CREATE INDEX index_avg_location_sfo ON conditions_daily (avg) WHERE location = 'SFO'; CREATE INDEX index_avg_expr_location_sfo ON conditions_daily ((avg + 2)) WHERE location = 'SFO'; SELECT * FROM test.show_indexespred(:'MAT_TABLE_NAME'); Index | Columns | Expr | Pred | Unique | Primary | Exclusion | Tablespace -----------------------------------------------------------------------+-------------------+---------------------------+------------------------+--------+---------+-----------+------------ _timescaledb_internal._materialized_hypertable_35_bucket_idx | {bucket} | | | f | f | f | _timescaledb_internal._materialized_hypertable_35_location_bucket_idx | {location,bucket} | | | f | f | f | _timescaledb_internal.index_avg | {avg} | | | f | f | f | _timescaledb_internal.index_avg_expr | {expr} | avg + 1::double precision | | f | f | f | _timescaledb_internal.index_avg_expr_location_sfo | {expr} | avg + 2::double precision | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_include | {avg,location} | | | f | f | f | _timescaledb_internal.index_avg_location_sfo | {avg} | | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_only | {avg} | | | f | f | f | -- #3696 assertion failure when referencing columns not present in result CREATE TABLE i3696(time timestamptz NOT NULL, search_query text, cnt integer, cnt2 integer); SELECT table_name FROM create_hypertable('i3696','time'); table_name ------------ i3696 CREATE MATERIALIZED VIEW i3696_cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt +cnt2 , bucket, search_query; NOTICE: continuous aggregate "i3696_cagg1" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg1 SET (timescaledb.materialized_only = 'true'); CREATE MATERIALIZED VIEW i3696_cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt + cnt2, bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: continuous aggregate "i3696_cagg2" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg2 SET (timescaledb.materialized_only = 'true'); --TEST test with multiple settings on continuous aggregates -- -- test for materialized_only + compress combinations (real time aggs enabled initially) CREATE TABLE test_setting(time timestamptz not null, val numeric); SELECT create_hypertable('test_setting', 'time'); create_hypertable ---------------------------- (39,public,test_setting,t) CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: continuous aggregate "test_setting_cagg" is already up-to-date INSERT INTO test_setting SELECT generate_series( '2020-01-10 8:00'::timestamp, '2020-01-30 10:00+00'::timestamptz, '1 day'::interval), 10.0; CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 DELETE FROM test_setting WHERE val = 20; --TEST test with multiple settings on continuous aggregates with real time aggregates turned off initially -- -- test for materialized_only + compress combinations (real time aggs enabled initially) DROP MATERIALIZED VIEW test_setting_cagg; NOTICE: drop cascades to table _timescaledb_internal._hyper_40_50_chunk CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: refreshing continuous aggregate "test_setting_cagg" CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 -- END TEST with multiple settings -- Test View Target Entries that contain both aggrefs and Vars in the same expression CREATE TABLE transactions ( "time" timestamp with time zone NOT NULL, dummy1 integer, dummy2 integer, dummy3 integer, dummy4 integer, dummy5 integer, amount integer, fiat_value integer ); SELECT create_hypertable('transactions', 'time'); create_hypertable ---------------------------- (44,public,transactions,t) INSERT INTO transactions VALUES ( '2018-01-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:30:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:20:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 10:40:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 11:50:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 12:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 13:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-02 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-02 10:30:00-08', 0, 0, 0, 0, 0, -1, 10); CREATE materialized view cashflows( bucket, amount, cashflow, cashflow2 ) WITH ( timescaledb.continuous, timescaledb.materialized_only = true ) AS SELECT time_bucket ('1 day', time) AS bucket, amount, CASE WHEN amount < 0 THEN (0 - sum(fiat_value)) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) FROM transactions GROUP BY bucket, amount; NOTICE: refreshing continuous aggregate "cashflows" SELECT h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", direct_view_name AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cashflows' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. \d+ "_timescaledb_internal".:"DIRECT_VIEW_NAME" View "_timescaledb_internal._direct_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, transactions."time") AS bucket, transactions.amount, CASE WHEN transactions.amount < 0 THEN 0 - sum(transactions.fiat_value) ELSE sum(transactions.fiat_value) END AS cashflow, transactions.amount + sum(transactions.fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, transactions."time")), transactions.amount; \d+ "_timescaledb_internal".:"PART_VIEW_NAME" View "_timescaledb_internal._partial_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, transactions."time") AS bucket, transactions.amount, CASE WHEN transactions.amount < 0 THEN 0 - sum(transactions.fiat_value) ELSE sum(transactions.fiat_value) END AS cashflow, transactions.amount + sum(transactions.fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, transactions."time")), transactions.amount; \d+ "_timescaledb_internal".:"MAT_TABLE_NAME" Table "_timescaledb_internal._materialized_hypertable_45" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -----------+--------------------------+-----------+----------+---------+---------+--------------+------------- bucket | timestamp with time zone | | not null | | plain | | amount | integer | | | | plain | | cashflow | bigint | | | | plain | | cashflow2 | bigint | | | | plain | | Indexes: "_materialized_hypertable_45_amount_bucket_idx" btree (amount, bucket DESC) "_materialized_hypertable_45_bucket_idx" btree (bucket DESC) Child tables: _timescaledb_internal._hyper_45_55_chunk, _timescaledb_internal._hyper_45_56_chunk \d+ 'cashflows' View "public.cashflows" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT _materialized_hypertable_45.bucket, _materialized_hypertable_45.amount, _materialized_hypertable_45.cashflow, _materialized_hypertable_45.cashflow2 FROM _timescaledb_internal._materialized_hypertable_45; SELECT * FROM cashflows ORDER BY cashflows; bucket | amount | cashflow | cashflow2 ------------------------------+--------+----------+----------- Sun Dec 31 16:00:00 2017 UTC | 1 | 10 | 11 Mon Jan 01 16:00:00 2018 UTC | -1 | -30 | 29 Wed Oct 31 16:00:00 2018 UTC | -1 | -20 | 19 Wed Oct 31 16:00:00 2018 UTC | 1 | 30 | 31 Thu Nov 01 16:00:00 2018 UTC | -1 | -10 | 9 Thu Nov 01 16:00:00 2018 UTC | 1 | 10 | 11 -- test cagg creation with named arguments in time_bucket -- note that positional arguments cannot follow named arguments -- 1. test named origin -- 2. test named timezone -- 3. test named ts -- 4. test named bucket width -- named origin CREATE MATERIALIZED VIEW cagg_named_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named timezone CREATE MATERIALIZED VIEW cagg_named_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named ts CREATE MATERIALIZED VIEW cagg_named_ts_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named bucket width CREATE MATERIALIZED VIEW cagg_named_all WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(bucket_width => '1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- Refreshing from the beginning (NULL) of a CAGG with variable time bucket and -- using an INTERVAL for the end timestamp (issue #5534) CREATE MATERIALIZED VIEW transactions_montly WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; -- No rows SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min --------+-----+-----+----- -- Refresh from beginning of the CAGG for 1 month CALL refresh_continuous_aggregate('transactions_montly', NULL, INTERVAL '1 month'); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 TRUNCATE transactions_montly; -- Partial refresh the CAGG from beginning to an specific timestamp CALL refresh_continuous_aggregate('transactions_montly', NULL, '2018-11-01 11:50:00-08'::timestamptz); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 -- Full refresh the CAGG CALL refresh_continuous_aggregate('transactions_montly', NULL, NULL); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 -- Check set_chunk_time_interval on continuous aggregate CREATE MATERIALIZED VIEW cagg_set_chunk_time_interval WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; SELECT set_chunk_time_interval('cagg_set_chunk_time_interval', chunk_time_interval => interval '1 month'); set_chunk_time_interval ------------------------- CALL refresh_continuous_aggregate('cagg_set_chunk_time_interval', NULL, NULL); SELECT _timescaledb_functions.to_interval(d.interval_length) = interval '1 month' FROM _timescaledb_catalog.dimension d RIGHT JOIN _timescaledb_catalog.continuous_agg ca ON ca.user_view_name = 'cagg_set_chunk_time_interval' WHERE d.hypertable_id = ca.mat_hypertable_id; ?column? ---------- t -- Since #6077 CAggs are materialized only by default DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'POR', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT _materialized_hypertable_53.location, _materialized_hypertable_53.bucket, _materialized_hypertable_53.avg FROM _timescaledb_internal._materialized_hypertable_53; -- Should return NO ROWS SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+--------+----- ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=false); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT _materialized_hypertable_53.location, _materialized_hypertable_53.bucket, _materialized_hypertable_53.avg FROM _timescaledb_internal._materialized_hypertable_53 WHERE _materialized_hypertable_53.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) UNION ALL SELECT conditions.location, time_bucket('@ 1 day'::interval, conditions."time") AS bucket, avg(conditions.temperature) AS avg FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) GROUP BY conditions.location, (time_bucket('@ 1 day'::interval, conditions."time")); -- Should return ROWS because now it is realtime SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Should return ROWS because we refreshed it ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=true); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT _materialized_hypertable_53.location, _materialized_hypertable_53.bucket, _materialized_hypertable_53.avg FROM _timescaledb_internal._materialized_hypertable_53; CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Test TRUNCATE over a Realtime CAgg DROP MATERIALIZED VIEW conditions_daily; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_daily' \gset -- Check the current watermark for an empty CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_empty_cagg; watermak_empty_cagg --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Refresh the CAGG CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); -- Check the watermark after the refresh and before truncate the CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_before; watermak_before ------------------------------ Fri Nov 02 16:00:00 2018 UTC -- Exists chunks before truncate the cagg (> 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 2 -- Truncate the given CAgg, it should reset the watermark to the empty state TRUNCATE conditions_daily; -- No chunks remains after truncate the cagg (= 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 0 -- Watermark should be reseted SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_after; watermak_after --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Should return ROWS because the watermark was reseted by the TRUNCATE SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- check compression settings are cleaned up when deleting a cagg with compression CREATE TABLE cagg_cleanup(time timestamptz not null); SELECT table_name FROM create_hypertable('cagg_cleanup','time'); table_name -------------- cagg_cleanup INSERT INTO cagg_cleanup SELECT '2020-01-01'; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1h',time) FROM cagg_cleanup GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" ALTER MATERIALIZED VIEW cagg1 SET (timescaledb.compress); NOTICE: defaulting compress_orderby to time_bucket SELECT count(compress_chunk(ch)) FROM show_chunks('cagg1') ch; count ------- 1 DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_56_70_chunk SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- -- test WITH namespace alias CREATE TABLE with_alias(time timestamptz not null); CREATE MATERIALIZED VIEW cagg_alias WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; ALTER MATERIALIZED VIEW cagg_alias SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_alias SET (tsdb.materialized_only=false); DROP MATERIALIZED VIEW cagg_alias; -- test SET chunk_time_interval CREATE MATERIALIZED VIEW cagg_set WITH (tsdb.continuous, tsdb.chunk_interval='1day') AS SELECT time_bucket(INTERVAL '1 day', time) AS cagg_interval_setter FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 1 day ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='23 day'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 23 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='6 month'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 180 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='1 year'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 360 days -- test cagg with stable functions CREATE MATERIALIZED VIEW cagg_stable WITH (tsdb.continuous) AS SELECT sum(temperature), max(time + INTERVAL '1h') FROM conditions GROUP BY time_bucket('1week', time), location; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization NOTICE: refreshing continuous aggregate "cagg_stable" SELECT * FROM cagg_stable t ORDER BY t; sum | max -----+------------------------------ 65 | Tue Jan 02 10:10:00 2018 UTC 100 | Tue Jan 02 10:30:00 2018 UTC 120 | Tue Jan 02 10:20:00 2018 UTC 355 | Fri Nov 02 11:30:00 2018 UTC --aggregate without combine function but stable function CREATE MATERIALIZED VIEW cagg_json_agg WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT json_agg(location) from conditions group by time_bucket('1week', time), location WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE FUNCTION test_stablefunc(int) RETURNS int LANGUAGE 'sql' STABLE AS 'SELECT $1 + 10'; CREATE MATERIALIZED VIEW cagg_stable2 WITH (tsdb.continuous) AS SELECT sum(test_stablefunc(temperature::int)), min(location) FROM conditions GROUP BY time_bucket('1week', time) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE MATERIALIZED VIEW cagg_stable3 WITH (tsdb.continuous) AS SELECT sum(temperature), min(location) FROM conditions GROUP BY time_bucket('1week', time), test_stablefunc(temperature::int) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- test window functions in caggs -- first do sanity check that we error without the GUC \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_window WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; ERROR: invalid continuous aggregate query \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_window_functions TO on; CREATE MATERIALIZED VIEW cagg_window_1 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_1" CREATE MATERIALIZED VIEW cagg_window_2 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time), location) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_2" CREATE MATERIALIZED VIEW cagg_window_3 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_3" CREATE MATERIALIZED VIEW cagg_window_4 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER w FROM conditions GROUP BY 1, location WINDOW w AS (PARTITION BY time_bucket('1 week',time)); WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_4" -- test setting chunk_interval on a cagg CREATE MATERIALIZED VIEW cagg_chunk_interval WITH (tsdb.continuous, tsdb.chunk_interval='1000 day') AS SELECT time_bucket('1 week', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 1000 days ALTER MATERIALIZED VIEW cagg_chunk_interval SET (tsdb.chunk_interval='110 day'); SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 110 days -- test columnstore options CREATE MATERIALIZED VIEW columnstore_options WITH (tsdb.continuous, tsdb.chunk_interval='1 day') AS SELECT time_bucket('1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.columnstore, tsdb.chunk_interval='1 day', tsdb.orderby='time_bucket DESC', tsdb.compress_chunk_interval='2 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 172800000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_interval='3 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 259200000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_time_interval='4 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 345600000000 -- test set returning functions in caggs CREATE TABLE kpis_raw (time TIMESTAMP NOT NULL, value INTEGER, groups TEXT[]) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO kpis_raw (time, value, groups) VALUES ('2025-01-01', 10, '{group1,group2,group3}'), ('2025-01-02', 20, '{group1,group4}'), ('2025-02-01', 10, '{group1,group3}'), ('2025-02-01', 20, '{group1,group4}'); CREATE MATERIALIZED VIEW kpis_cagg WITH (tsdb.continuous) AS SELECT time_bucket('7 day', time) AS bucket, count(*) AS number_of_records, avg(value) AS average, unnest(groups) AS kpi_group FROM kpis_raw GROUP BY bucket, kpi_group; NOTICE: refreshing continuous aggregate "kpis_cagg" SELECT * FROM kpis_cagg ORDER BY bucket, kpi_group; bucket | number_of_records | average | kpi_group --------------------------+-------------------+---------------------+----------- Mon Dec 30 00:00:00 2024 | 2 | 15.0000000000000000 | group1 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group2 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group3 Mon Dec 30 00:00:00 2024 | 1 | 20.0000000000000000 | group4 Mon Jan 27 00:00:00 2025 | 2 | 15.0000000000000000 | group1 Mon Jan 27 00:00:00 2025 | 1 | 10.0000000000000000 | group3 Mon Jan 27 00:00:00 2025 | 1 | 20.0000000000000000 | group4 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_ddl-16.out������������������������������������������������0000664�0000000�0000000�00000265240�15100345067�0022147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH '../../../../test/sql/include/query_result_test_equal.sql' SET ROLE :ROLE_DEFAULT_PERM_USER; --DDL commands on continuous aggregates CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions -- schema tests \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO 'UTC+8'; -- drop if the tablespace1 and/or tablespace2 exists SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; CREATE SCHEMA rename_schema; GRANT ALL ON SCHEMA rename_schema TO :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE foo(time TIMESTAMPTZ NOT NULL, data INTEGER); SELECT create_hypertable('foo', 'time'); create_hypertable ------------------- (2,public,foo,t) CREATE MATERIALIZED VIEW rename_test_old WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1week', time), COUNT(data) FROM foo GROUP BY 1 WITH NO DATA; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+-----------------+-----------------------+------------------- public | rename_test_old | _timescaledb_internal | _partial_view_3 ALTER TABLE rename_test_old RENAME TO rename_test; ALTER TABLE rename_test SET SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- test_schema | rename_test | _timescaledb_internal | _partial_view_3 ALTER MATERIALIZED VIEW test_schema.rename_test SET SCHEMA rename_schema; DROP SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- rename_schema | rename_test | _timescaledb_internal | _partial_view_3 SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'rename_test' \gset RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- rename_schema | rename_test | public | _partial_view_3 --alter direct view schema SELECT user_view_schema, user_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | direct_view_schema | direct_view_name ------------------+----------------+-----------------------+------------------ rename_schema | rename_test | _timescaledb_internal | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ rename_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA rename_schema RENAME TO new_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 ALTER VIEW :"PART_VIEW_NAME" SET SCHEMA new_name_schema; ALTER VIEW :"DIR_VIEW_NAME" SET SCHEMA new_name_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | new_name_schema | _partial_view_3 | new_name_schema | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA new_name_schema RENAME TO foo_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- foo_name_schema | rename_test | foo_name_schema | _partial_view_3 ALTER MATERIALIZED VIEW foo_name_schema.rename_test SET SCHEMA public; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | foo_name_schema | _partial_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA foo_name_schema RENAME TO rename_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | rename_schema | _partial_view_3 ALTER MATERIALIZED VIEW rename_test RENAME TO rename_c_aggregate; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+--------------------+---------------------+------------------- public | rename_c_aggregate | rename_schema | _partial_view_3 SELECT * FROM rename_c_aggregate; time_bucket | count -------------+------- ALTER VIEW rename_schema.:"PART_VIEW_NAME" RENAME TO partial_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | _direct_view_3 --rename direct view ALTER VIEW rename_schema.:"DIR_VIEW_NAME" RENAME TO direct_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | direct_view -- drop_chunks tests DROP TABLE conditions CASCADE; DROP TABLE foo CASCADE; NOTICE: drop cascades to 2 other objects CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), COUNT(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; -- Only refresh up to bucket 15 initially. Matches the old refresh -- behavior that didn't materialize everything CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- cannot drop directly from the materialization table without specifying -- cont. aggregate view name explicitly \set ON_ERROR_STOP 0 SELECT drop_chunks(:'drop_chunks_mat_table', newer_than => -20, verbose => true); ERROR: operation not supported on materialized hypertable \set ON_ERROR_STOP 1 SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- drop chunks when the chunksize and time_bucket aren't aligned DROP TABLE drop_chunks_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_5_4_chunk CREATE TABLE drop_chunks_table_u(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_u_id FROM create_hypertable('drop_chunks_table_u', 'time', chunk_time_interval => 7) \gset CREATE OR REPLACE FUNCTION integer_now_test1() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table_u $$; SELECT set_integer_now_func('drop_chunks_table_u', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('3', time), COUNT(data) FROM drop_chunks_table_u GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table_u, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_u_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_u_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table_u SELECT i, i FROM generate_series(0, 21) AS i; -- Refresh up to bucket 15 to match old materializer behavior CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table_u') AS c; count ------- 4 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 -- TRUNCATE test -- Can truncate regular hypertables that have caggs TRUNCATE drop_chunks_table_u; \set ON_ERROR_STOP 0 -- Can't truncate materialized hypertables directly TRUNCATE :drop_chunks_mat_table_u; ERROR: cannot TRUNCATE a hypertable underlying a continuous aggregate \set ON_ERROR_STOP 1 -- Check that we don't interfere with TRUNCATE of normal table and -- partitioned table CREATE TABLE truncate (value int); INSERT INTO truncate VALUES (1), (2); TRUNCATE truncate; SELECT * FROM truncate; value ------- CREATE TABLE truncate_partitioned (value int) PARTITION BY RANGE(value); CREATE TABLE truncate_p1 PARTITION OF truncate_partitioned FOR VALUES FROM (1) TO (3); INSERT INTO truncate_partitioned VALUES (1), (2); TRUNCATE truncate_partitioned; SELECT * FROM truncate_partitioned; value ------- -- ALTER TABLE tests \set ON_ERROR_STOP 0 -- test a variety of ALTER TABLE statements ALTER TABLE :drop_chunks_mat_table_u RENAME time_bucket TO bad_name; ERROR: renaming columns on materialization tables is not supported ALTER TABLE :drop_chunks_mat_table_u ADD UNIQUE(time_bucket); ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET UNLOGGED; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ENABLE ROW LEVEL SECURITY; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ADD COLUMN fizzle INTEGER; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DROP COLUMN time_bucket; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket DROP NOT NULL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET DEFAULT 1; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET STORAGE EXTERNAL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DISABLE TRIGGER ALL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET TABLESPACE foo; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u NOT OF; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u OWNER TO CURRENT_USER; ERROR: operation not supported on materialization tables \set ON_ERROR_STOP 1 ALTER TABLE :drop_chunks_mat_table_u SET SCHEMA public; ALTER TABLE :drop_chunks_mat_table_u_name RENAME TO new_name; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT * FROM new_name ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 \set ON_ERROR_STOP 0 -- no continuous aggregates on a continuous aggregate materialization table CREATE MATERIALIZED VIEW new_name_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('6', time_bucket), COUNT("count") FROM new_name GROUP BY 1 WITH NO DATA; ERROR: hypertable is a continuous aggregate materialization table \set ON_ERROR_STOP 1 CREATE TABLE metrics(time timestamptz NOT NULL, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (8,public,metrics,t) INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2 FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; time | const | numeric | first | case | coalesce | avg1 | avg2 ------------------------------+-------+---------+----------------------------------------------+------+----------+------+------ Fri Dec 31 16:00:00 1999 UTC | Const | 4.3 | ("Sat Jan 01 00:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sat Jan 01 16:00:00 2000 UTC | Const | 4.3 | ("Sat Jan 01 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sun Jan 02 16:00:00 2000 UTC | Const | 4.3 | ("Sun Jan 02 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Mon Jan 03 16:00:00 2000 UTC | Const | 4.3 | ("Mon Jan 03 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Tue Jan 04 16:00:00 2000 UTC | Const | 4.3 | ("Tue Jan 04 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 --test materialization of invalidation before drop DROP TABLE IF EXISTS drop_chunks_table CASCADE; NOTICE: table "drop_chunks_table" does not exist, skipping DROP TABLE IF EXISTS drop_chunks_table_u CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_7_9_chunk CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --dropping chunks will process the invalidations SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_13_chunk SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 10 | 10 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(20, 35) AS i; CALL refresh_continuous_aggregate('drop_chunks_view', 10, 40); --this will be seen after the drop its within the invalidation window and will be dropped INSERT INTO drop_chunks_table VALUES (26, 100); --this will not be processed by the drop since chunk 30-39 is not dropped but will be seen after refresh --shows that the drop doesn't do more work than necessary INSERT INTO drop_chunks_table VALUES (31, 200); --move the time up to 39 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(35, 39) AS i; --the chunks and ranges we have thus far SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table'; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_14_chunk | 10 | 20 _hyper_10_15_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --the invalidation on 25 not yet seen SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 29 20 | 24 15 | 19 10 | 14 --refresh to process the invalidations and then drop CALL refresh_continuous_aggregate('drop_chunks_view', NULL, (integer_now_test2()-9)); SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_14_chunk _timescaledb_internal._hyper_10_15_chunk --new values on 25 now seen in view SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 100 20 | 24 15 | 19 10 | 14 --earliest datapoint now in table SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 30 | 30 --chunks are removed SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE dropped; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- --still see data in the view SELECT * FROM drop_chunks_view WHERE time_bucket < (integer_now_test2()-9) ORDER BY time_bucket DESC; time_bucket | max -------------+----- 25 | 100 20 | 24 15 | 19 10 | 14 --no data but covers dropped chunks SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ --recreate the dropped chunk INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --see data from recreated region SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ 20 | 20 19 | 19 18 | 18 17 | 17 16 | 16 15 | 15 14 | 14 13 | 13 12 | 12 11 | 11 10 | 10 9 | 9 8 | 8 7 | 7 6 | 6 5 | 5 4 | 4 3 | 3 2 | 2 1 | 1 0 | 0 --should show chunk with old name and old ranges SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --We dropped everything up to the bucket starting at 30 and then --inserted new data up to and including time 20. Therefore, the --dropped data should stay the same as long as we only refresh --buckets that have non-dropped data. CALL refresh_continuous_aggregate('drop_chunks_view', 30, 40); SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 39 30 | 200 25 | 100 20 | 24 15 | 19 10 | 14 SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_tablen, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_nid AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- TEST drop chunks from continuous aggregates by specifying view name SELECT drop_chunks('drop_chunks_view', newer_than => -20, verbose => true); INFO: dropping chunk _timescaledb_internal._hyper_11_17_chunk drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- Test that we cannot drop chunks when specifying materialized -- hypertable INSERT INTO drop_chunks_table SELECT generate_series(45, 55), 500; CALL refresh_continuous_aggregate('drop_chunks_view', 45, 55); SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = :'drop_chunks_mat_table_name' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_11_23_chunk | 0 | 100 \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT drop_chunks(:'drop_chunks_mat_tablen', older_than => 60); ERROR: operation not supported on materialized hypertable DETAIL: Hypertable "_materialized_hypertable_11" is a materialized hypertable. HINT: Try the operation on the continuous aggregate instead. \set VERBOSITY terse \set ON_ERROR_STOP 1 ----------------------------------------------------------------- -- Test that refresh_continuous_aggregate on chunk will refresh, -- but only in the regions covered by the show chunks. ----------------------------------------------------------------- SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Pick the second chunk as the one to drop WITH numbered_chunks AS ( SELECT row_number() OVER (ORDER BY range_start_integer), chunk_schema, chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 1 ) SELECT format('%I.%I', chunk_schema, chunk_name) AS chunk_to_drop, range_start_integer, range_end_integer FROM numbered_chunks WHERE row_number = 2 \gset -- There's data in the table for the chunk/range we will drop SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 16 | 16 17 | 17 18 | 18 19 | 19 -- Make sure there is also data in the continuous aggregate -- CARE: -- Note that this behaviour of dropping the materialization table chunks and expecting a refresh -- that overlaps that time range to NOT update those chunks is undefined. CALL refresh_continuous_aggregate('drop_chunks_view', 0, 50); SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 9 10 | 14 15 | 19 20 | 20 45 | 500 50 | 500 -- Drop the second chunk, to leave a gap in the data DROP TABLE :chunk_to_drop; -- Verify that the second chunk is dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Data is no longer in the table but still in the view SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ SELECT * FROM drop_chunks_view WHERE time_bucket >= :range_start_integer AND time_bucket < :range_end_integer ORDER BY 1; time_bucket | max -------------+----- 10 | 14 15 | 19 -- Insert a large value in one of the chunks that will be dropped INSERT INTO drop_chunks_table VALUES (:range_start_integer-1, 100); -- Now refresh and drop the two adjecent chunks CALL refresh_continuous_aggregate('drop_chunks_view', NULL, 30); SELECT drop_chunks('drop_chunks_table', older_than=>30); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_18_chunk _timescaledb_internal._hyper_10_20_chunk -- Verify that the chunks are dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- The continuous aggregate should be refreshed in the regions covered -- by the dropped chunks, but not in the "gap" region, i.e., the -- region of the chunk that was dropped via DROP TABLE. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 100 20 | 20 45 | 500 50 | 500 -- Now refresh in the region of the first two dropped chunks CALL refresh_continuous_aggregate('drop_chunks_view', 0, :range_end_integer); -- Aggregate data in the refreshed range should no longer exist since -- the underlying data was dropped. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 20 | 20 45 | 500 50 | 500 -------------------------------------------------------------------- -- Check that we can create a materialized table in a tablespace. We -- create one with tablespace and one without and compare them. CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, pg_get_userbyid(relowner) AS user_view_owner, relname AS mat_table, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = mat_relid) AS mat_table_owner, direct_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = direct_view) AS direct_view_owner, partial_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = partial_view) AS partial_view_owner, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; CREATE VIEW chunk_info AS SELECT ht.schema_name, ht.table_name, relname AS chunk_name, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class c, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.table_name = c.relname AND ht.id = ch.hypertable_id; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset SELECT set_integer_now_func('whatever', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW whatever_view_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW whatever_view_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) TABLESPACE tablespace1 AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; CALL refresh_continuous_aggregate('whatever_view_1', NULL, NULL); CALL refresh_continuous_aggregate('whatever_view_2', NULL, NULL); SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | | _hyper_13_27_chunk | whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 ALTER MATERIALIZED VIEW whatever_view_1 SET TABLESPACE tablespace2; SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | tablespace2 | _hyper_13_27_chunk | tablespace2 whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 DROP MATERIALIZED VIEW whatever_view_1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_27_chunk DROP MATERIALIZED VIEW whatever_view_2; NOTICE: drop cascades to table _timescaledb_internal._hyper_14_28_chunk -- test bucket width expressions on integer hypertables CREATE TABLE metrics_int2 ( time int2 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int4 ( time int4 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int8 ( time int8 NOT NULL, device_id int, v1 float, v2 float ); SELECT create_hypertable (('metrics_' || dt)::regclass, 'time', chunk_time_interval => 10) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); create_hypertable ---------------------------- (15,public,metrics_int2,t) (16,public,metrics_int4,t) (17,public,metrics_int8,t) CREATE OR REPLACE FUNCTION int2_now () RETURNS int2 LANGUAGE SQL STABLE AS $$ SELECT 10::int2 $$; CREATE OR REPLACE FUNCTION int4_now () RETURNS int4 LANGUAGE SQL STABLE AS $$ SELECT 10::int4 $$; CREATE OR REPLACE FUNCTION int8_now () RETURNS int8 LANGUAGE SQL STABLE AS $$ SELECT 10::int8 $$; SELECT set_integer_now_func (('metrics_' || dt)::regclass, (dt || '_now')::regproc) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); set_integer_now_func ---------------------- -- width expression for int2 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint + 2::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int4 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int8 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; \set ON_ERROR_STOP 0 -- non-immutable expresions should be rejected CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::smallint, time) FROM metrics_int2 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int4 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int8 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function \set ON_ERROR_STOP 1 -- Test various ALTER MATERIALIZED VIEW statements. SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE MATERIALIZED VIEW owner_check WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1 WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | default_perm_user mat_table | _materialized_hypertable_24 mat_table_owner | default_perm_user direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | default_perm_user partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | default_perm_user tablespace | \x off -- This should not work since the target user has the wrong role, but -- we test that the normal checks are done when changing the owner. \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; ERROR: must be able to SET ROLE "test_role_1" \set ON_ERROR_STOP 1 -- Superuser can always change owner SET ROLE :ROLE_CLUSTER_SUPERUSER; ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | test_role_1 mat_table | _materialized_hypertable_24 mat_table_owner | test_role_1 direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | test_role_1 partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | test_role_1 tablespace | \x off -- -- Test drop continuous aggregate cases -- -- Issue: #2608 -- CREATE OR REPLACE FUNCTION test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE conditionsnm(time_int INT NOT NULL, device INT, value FLOAT); SELECT create_hypertable('conditionsnm', 'time_int', chunk_time_interval => 10); create_hypertable ---------------------------- (25,public,conditionsnm,t) SELECT set_integer_now_func('conditionsnm', 'test_int_now'); set_integer_now_func ---------------------- INSERT INTO conditionsnm SELECT time_val, time_val % 4, 3.14 FROM generate_series(0,100,1) AS time_val; -- Case 1: DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4; NOTICE: drop cascades to table _timescaledb_internal._hyper_26_40_chunk -- Case 2: DROP CASCADE should have similar behaviour as DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4 CASCADE; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_41_chunk -- Case 3: require CASCADE in case of dependent object CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" CREATE VIEW see_cagg as select * from conditionsnm_4; \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW conditionsnm_4; ERROR: cannot drop view conditionsnm_4 because other objects depend on it \set ON_ERROR_STOP 1 -- Case 4: DROP CASCADE with dependency DROP MATERIALIZED VIEW conditionsnm_4 CASCADE; NOTICE: drop cascades to view see_cagg NOTICE: drop cascades to table _timescaledb_internal._hyper_28_42_chunk -- Test DROP SCHEMA CASCADE with continuous aggregates -- -- Issue: #2350 -- -- Case 1: DROP SCHEMA CASCADE CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (29,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.telemetry_1s WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'telemetry_1s'; raw_hypertable_id | schema_name | MAT_TABLE_NAME | PART_VIEW_NAME | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 29 | _timescaledb_internal | _materialized_hypertable_30 | _partial_view_30 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 4 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'telemetry_1s'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 -- Case 2: DROP SCHEMA CASCADE with multiple caggs CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (31,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; CREATE MATERIALIZED VIEW test_schema.cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME1", partial_view_name as "PART_VIEW_NAME1", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg1'; raw_hypertable_id | schema_name | MAT_TABLE_NAME1 | PART_VIEW_NAME1 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_32 | _partial_view_32 | _timescaledb_internal \gset SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME2", partial_view_name as "PART_VIEW_NAME2", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg2'; raw_hypertable_id | schema_name | MAT_TABLE_NAME2 | PART_VIEW_NAME2 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_33 | _partial_view_33 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 7 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg2'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Check that we can rename a column of a materialized view and still -- rebuild it after (#3051, #3405) CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (34,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'por', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT format('%I.%I', '_timescaledb_internal', h.table_name) AS "MAT_TABLE_NAME", format('%I.%I', '_timescaledb_internal', partial_view_name) AS "PART_VIEW_NAME", format('%I.%I', '_timescaledb_internal', direct_view_name) AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_daily' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns('conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | t avg | double precision | f ALTER MATERIALIZED VIEW conditions_daily RENAME COLUMN bucket to "time"; -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns(' conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | t avg | double precision | f -- This will rebuild the materialized view and should succeed. ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only = false); -- Refresh the continuous aggregate to check that it works after the -- rename. \set VERBOSITY verbose CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); \set VERBOSITY terse -- -- Indexes on continuous aggregate -- \set ON_ERROR_STOP 0 -- unique indexes are not supported CREATE UNIQUE INDEX index_unique_error ON conditions_daily ("time", location); ERROR: continuous aggregates do not support UNIQUE indexes -- concurrently index creation not supported CREATE INDEX CONCURRENTLY index_concurrently_avg ON conditions_daily (avg); ERROR: hypertables do not support concurrent index creation \set ON_ERROR_STOP 1 CREATE INDEX index_avg ON conditions_daily (avg); CREATE INDEX index_avg_only ON ONLY conditions_daily (avg); CREATE INDEX index_avg_include ON conditions_daily (avg) INCLUDE (location); CREATE INDEX index_avg_expr ON conditions_daily ((avg + 1)); CREATE INDEX index_avg_location_sfo ON conditions_daily (avg) WHERE location = 'SFO'; CREATE INDEX index_avg_expr_location_sfo ON conditions_daily ((avg + 2)) WHERE location = 'SFO'; SELECT * FROM test.show_indexespred(:'MAT_TABLE_NAME'); Index | Columns | Expr | Pred | Unique | Primary | Exclusion | Tablespace -----------------------------------------------------------------------+-------------------+---------------------------+------------------------+--------+---------+-----------+------------ _timescaledb_internal._materialized_hypertable_35_bucket_idx | {bucket} | | | f | f | f | _timescaledb_internal._materialized_hypertable_35_location_bucket_idx | {location,bucket} | | | f | f | f | _timescaledb_internal.index_avg | {avg} | | | f | f | f | _timescaledb_internal.index_avg_expr | {expr} | avg + 1::double precision | | f | f | f | _timescaledb_internal.index_avg_expr_location_sfo | {expr} | avg + 2::double precision | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_include | {avg,location} | | | f | f | f | _timescaledb_internal.index_avg_location_sfo | {avg} | | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_only | {avg} | | | f | f | f | -- #3696 assertion failure when referencing columns not present in result CREATE TABLE i3696(time timestamptz NOT NULL, search_query text, cnt integer, cnt2 integer); SELECT table_name FROM create_hypertable('i3696','time'); table_name ------------ i3696 CREATE MATERIALIZED VIEW i3696_cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt +cnt2 , bucket, search_query; NOTICE: continuous aggregate "i3696_cagg1" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg1 SET (timescaledb.materialized_only = 'true'); CREATE MATERIALIZED VIEW i3696_cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt + cnt2, bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: continuous aggregate "i3696_cagg2" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg2 SET (timescaledb.materialized_only = 'true'); --TEST test with multiple settings on continuous aggregates -- -- test for materialized_only + compress combinations (real time aggs enabled initially) CREATE TABLE test_setting(time timestamptz not null, val numeric); SELECT create_hypertable('test_setting', 'time'); create_hypertable ---------------------------- (39,public,test_setting,t) CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: continuous aggregate "test_setting_cagg" is already up-to-date INSERT INTO test_setting SELECT generate_series( '2020-01-10 8:00'::timestamp, '2020-01-30 10:00+00'::timestamptz, '1 day'::interval), 10.0; CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 DELETE FROM test_setting WHERE val = 20; --TEST test with multiple settings on continuous aggregates with real time aggregates turned off initially -- -- test for materialized_only + compress combinations (real time aggs enabled initially) DROP MATERIALIZED VIEW test_setting_cagg; NOTICE: drop cascades to table _timescaledb_internal._hyper_40_50_chunk CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: refreshing continuous aggregate "test_setting_cagg" CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 -- END TEST with multiple settings -- Test View Target Entries that contain both aggrefs and Vars in the same expression CREATE TABLE transactions ( "time" timestamp with time zone NOT NULL, dummy1 integer, dummy2 integer, dummy3 integer, dummy4 integer, dummy5 integer, amount integer, fiat_value integer ); SELECT create_hypertable('transactions', 'time'); create_hypertable ---------------------------- (44,public,transactions,t) INSERT INTO transactions VALUES ( '2018-01-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:30:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:20:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 10:40:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 11:50:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 12:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 13:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-02 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-02 10:30:00-08', 0, 0, 0, 0, 0, -1, 10); CREATE materialized view cashflows( bucket, amount, cashflow, cashflow2 ) WITH ( timescaledb.continuous, timescaledb.materialized_only = true ) AS SELECT time_bucket ('1 day', time) AS bucket, amount, CASE WHEN amount < 0 THEN (0 - sum(fiat_value)) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) FROM transactions GROUP BY bucket, amount; NOTICE: refreshing continuous aggregate "cashflows" SELECT h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", direct_view_name AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cashflows' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. \d+ "_timescaledb_internal".:"DIRECT_VIEW_NAME" View "_timescaledb_internal._direct_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, "time") AS bucket, amount, CASE WHEN amount < 0 THEN 0 - sum(fiat_value) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, "time")), amount; \d+ "_timescaledb_internal".:"PART_VIEW_NAME" View "_timescaledb_internal._partial_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, "time") AS bucket, amount, CASE WHEN amount < 0 THEN 0 - sum(fiat_value) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, "time")), amount; \d+ "_timescaledb_internal".:"MAT_TABLE_NAME" Table "_timescaledb_internal._materialized_hypertable_45" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -----------+--------------------------+-----------+----------+---------+---------+--------------+------------- bucket | timestamp with time zone | | not null | | plain | | amount | integer | | | | plain | | cashflow | bigint | | | | plain | | cashflow2 | bigint | | | | plain | | Indexes: "_materialized_hypertable_45_amount_bucket_idx" btree (amount, bucket DESC) "_materialized_hypertable_45_bucket_idx" btree (bucket DESC) Child tables: _timescaledb_internal._hyper_45_55_chunk, _timescaledb_internal._hyper_45_56_chunk \d+ 'cashflows' View "public.cashflows" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT bucket, amount, cashflow, cashflow2 FROM _timescaledb_internal._materialized_hypertable_45; SELECT * FROM cashflows ORDER BY cashflows; bucket | amount | cashflow | cashflow2 ------------------------------+--------+----------+----------- Sun Dec 31 16:00:00 2017 UTC | 1 | 10 | 11 Mon Jan 01 16:00:00 2018 UTC | -1 | -30 | 29 Wed Oct 31 16:00:00 2018 UTC | -1 | -20 | 19 Wed Oct 31 16:00:00 2018 UTC | 1 | 30 | 31 Thu Nov 01 16:00:00 2018 UTC | -1 | -10 | 9 Thu Nov 01 16:00:00 2018 UTC | 1 | 10 | 11 -- test cagg creation with named arguments in time_bucket -- note that positional arguments cannot follow named arguments -- 1. test named origin -- 2. test named timezone -- 3. test named ts -- 4. test named bucket width -- named origin CREATE MATERIALIZED VIEW cagg_named_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named timezone CREATE MATERIALIZED VIEW cagg_named_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named ts CREATE MATERIALIZED VIEW cagg_named_ts_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named bucket width CREATE MATERIALIZED VIEW cagg_named_all WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(bucket_width => '1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- Refreshing from the beginning (NULL) of a CAGG with variable time bucket and -- using an INTERVAL for the end timestamp (issue #5534) CREATE MATERIALIZED VIEW transactions_montly WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; -- No rows SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min --------+-----+-----+----- -- Refresh from beginning of the CAGG for 1 month CALL refresh_continuous_aggregate('transactions_montly', NULL, INTERVAL '1 month'); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 TRUNCATE transactions_montly; -- Partial refresh the CAGG from beginning to an specific timestamp CALL refresh_continuous_aggregate('transactions_montly', NULL, '2018-11-01 11:50:00-08'::timestamptz); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 -- Full refresh the CAGG CALL refresh_continuous_aggregate('transactions_montly', NULL, NULL); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 -- Check set_chunk_time_interval on continuous aggregate CREATE MATERIALIZED VIEW cagg_set_chunk_time_interval WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; SELECT set_chunk_time_interval('cagg_set_chunk_time_interval', chunk_time_interval => interval '1 month'); set_chunk_time_interval ------------------------- CALL refresh_continuous_aggregate('cagg_set_chunk_time_interval', NULL, NULL); SELECT _timescaledb_functions.to_interval(d.interval_length) = interval '1 month' FROM _timescaledb_catalog.dimension d RIGHT JOIN _timescaledb_catalog.continuous_agg ca ON ca.user_view_name = 'cagg_set_chunk_time_interval' WHERE d.hypertable_id = ca.mat_hypertable_id; ?column? ---------- t -- Since #6077 CAggs are materialized only by default DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'POR', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT location, bucket, avg FROM _timescaledb_internal._materialized_hypertable_53; -- Should return NO ROWS SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+--------+----- ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=false); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT _materialized_hypertable_53.location, _materialized_hypertable_53.bucket, _materialized_hypertable_53.avg FROM _timescaledb_internal._materialized_hypertable_53 WHERE _materialized_hypertable_53.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) UNION ALL SELECT conditions.location, time_bucket('@ 1 day'::interval, conditions."time") AS bucket, avg(conditions.temperature) AS avg FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) GROUP BY conditions.location, (time_bucket('@ 1 day'::interval, conditions."time")); -- Should return ROWS because now it is realtime SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Should return ROWS because we refreshed it ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=true); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT location, bucket, avg FROM _timescaledb_internal._materialized_hypertable_53; CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Test TRUNCATE over a Realtime CAgg DROP MATERIALIZED VIEW conditions_daily; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_daily' \gset -- Check the current watermark for an empty CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_empty_cagg; watermak_empty_cagg --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Refresh the CAGG CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); -- Check the watermark after the refresh and before truncate the CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_before; watermak_before ------------------------------ Fri Nov 02 16:00:00 2018 UTC -- Exists chunks before truncate the cagg (> 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 2 -- Truncate the given CAgg, it should reset the watermark to the empty state TRUNCATE conditions_daily; -- No chunks remains after truncate the cagg (= 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 0 -- Watermark should be reseted SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_after; watermak_after --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Should return ROWS because the watermark was reseted by the TRUNCATE SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- check compression settings are cleaned up when deleting a cagg with compression CREATE TABLE cagg_cleanup(time timestamptz not null); SELECT table_name FROM create_hypertable('cagg_cleanup','time'); table_name -------------- cagg_cleanup INSERT INTO cagg_cleanup SELECT '2020-01-01'; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1h',time) FROM cagg_cleanup GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" ALTER MATERIALIZED VIEW cagg1 SET (timescaledb.compress); NOTICE: defaulting compress_orderby to time_bucket SELECT count(compress_chunk(ch)) FROM show_chunks('cagg1') ch; count ------- 1 DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_56_70_chunk SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- -- test WITH namespace alias CREATE TABLE with_alias(time timestamptz not null); CREATE MATERIALIZED VIEW cagg_alias WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; ALTER MATERIALIZED VIEW cagg_alias SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_alias SET (tsdb.materialized_only=false); DROP MATERIALIZED VIEW cagg_alias; -- test SET chunk_time_interval CREATE MATERIALIZED VIEW cagg_set WITH (tsdb.continuous, tsdb.chunk_interval='1day') AS SELECT time_bucket(INTERVAL '1 day', time) AS cagg_interval_setter FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 1 day ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='23 day'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 23 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='6 month'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 180 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='1 year'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 360 days -- test cagg with stable functions CREATE MATERIALIZED VIEW cagg_stable WITH (tsdb.continuous) AS SELECT sum(temperature), max(time + INTERVAL '1h') FROM conditions GROUP BY time_bucket('1week', time), location; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization NOTICE: refreshing continuous aggregate "cagg_stable" SELECT * FROM cagg_stable t ORDER BY t; sum | max -----+------------------------------ 65 | Tue Jan 02 10:10:00 2018 UTC 100 | Tue Jan 02 10:30:00 2018 UTC 120 | Tue Jan 02 10:20:00 2018 UTC 355 | Fri Nov 02 11:30:00 2018 UTC --aggregate without combine function but stable function CREATE MATERIALIZED VIEW cagg_json_agg WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT json_agg(location) from conditions group by time_bucket('1week', time), location WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE FUNCTION test_stablefunc(int) RETURNS int LANGUAGE 'sql' STABLE AS 'SELECT $1 + 10'; CREATE MATERIALIZED VIEW cagg_stable2 WITH (tsdb.continuous) AS SELECT sum(test_stablefunc(temperature::int)), min(location) FROM conditions GROUP BY time_bucket('1week', time) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE MATERIALIZED VIEW cagg_stable3 WITH (tsdb.continuous) AS SELECT sum(temperature), min(location) FROM conditions GROUP BY time_bucket('1week', time), test_stablefunc(temperature::int) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- test window functions in caggs -- first do sanity check that we error without the GUC \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_window WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; ERROR: invalid continuous aggregate query \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_window_functions TO on; CREATE MATERIALIZED VIEW cagg_window_1 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_1" CREATE MATERIALIZED VIEW cagg_window_2 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time), location) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_2" CREATE MATERIALIZED VIEW cagg_window_3 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_3" CREATE MATERIALIZED VIEW cagg_window_4 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER w FROM conditions GROUP BY 1, location WINDOW w AS (PARTITION BY time_bucket('1 week',time)); WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_4" -- test setting chunk_interval on a cagg CREATE MATERIALIZED VIEW cagg_chunk_interval WITH (tsdb.continuous, tsdb.chunk_interval='1000 day') AS SELECT time_bucket('1 week', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 1000 days ALTER MATERIALIZED VIEW cagg_chunk_interval SET (tsdb.chunk_interval='110 day'); SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 110 days -- test columnstore options CREATE MATERIALIZED VIEW columnstore_options WITH (tsdb.continuous, tsdb.chunk_interval='1 day') AS SELECT time_bucket('1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.columnstore, tsdb.chunk_interval='1 day', tsdb.orderby='time_bucket DESC', tsdb.compress_chunk_interval='2 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 172800000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_interval='3 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 259200000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_time_interval='4 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 345600000000 -- test set returning functions in caggs CREATE TABLE kpis_raw (time TIMESTAMP NOT NULL, value INTEGER, groups TEXT[]) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO kpis_raw (time, value, groups) VALUES ('2025-01-01', 10, '{group1,group2,group3}'), ('2025-01-02', 20, '{group1,group4}'), ('2025-02-01', 10, '{group1,group3}'), ('2025-02-01', 20, '{group1,group4}'); CREATE MATERIALIZED VIEW kpis_cagg WITH (tsdb.continuous) AS SELECT time_bucket('7 day', time) AS bucket, count(*) AS number_of_records, avg(value) AS average, unnest(groups) AS kpi_group FROM kpis_raw GROUP BY bucket, kpi_group; NOTICE: refreshing continuous aggregate "kpis_cagg" SELECT * FROM kpis_cagg ORDER BY bucket, kpi_group; bucket | number_of_records | average | kpi_group --------------------------+-------------------+---------------------+----------- Mon Dec 30 00:00:00 2024 | 2 | 15.0000000000000000 | group1 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group2 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group3 Mon Dec 30 00:00:00 2024 | 1 | 20.0000000000000000 | group4 Mon Jan 27 00:00:00 2025 | 2 | 15.0000000000000000 | group1 Mon Jan 27 00:00:00 2025 | 1 | 10.0000000000000000 | group3 Mon Jan 27 00:00:00 2025 | 1 | 20.0000000000000000 | group4 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_ddl-17.out������������������������������������������������0000664�0000000�0000000�00000265240�15100345067�0022150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH '../../../../test/sql/include/query_result_test_equal.sql' SET ROLE :ROLE_DEFAULT_PERM_USER; --DDL commands on continuous aggregates CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions -- schema tests \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO 'UTC+8'; -- drop if the tablespace1 and/or tablespace2 exists SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; CREATE SCHEMA rename_schema; GRANT ALL ON SCHEMA rename_schema TO :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE foo(time TIMESTAMPTZ NOT NULL, data INTEGER); SELECT create_hypertable('foo', 'time'); create_hypertable ------------------- (2,public,foo,t) CREATE MATERIALIZED VIEW rename_test_old WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1week', time), COUNT(data) FROM foo GROUP BY 1 WITH NO DATA; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+-----------------+-----------------------+------------------- public | rename_test_old | _timescaledb_internal | _partial_view_3 ALTER TABLE rename_test_old RENAME TO rename_test; ALTER TABLE rename_test SET SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- test_schema | rename_test | _timescaledb_internal | _partial_view_3 ALTER MATERIALIZED VIEW test_schema.rename_test SET SCHEMA rename_schema; DROP SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- rename_schema | rename_test | _timescaledb_internal | _partial_view_3 SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'rename_test' \gset RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- rename_schema | rename_test | public | _partial_view_3 --alter direct view schema SELECT user_view_schema, user_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | direct_view_schema | direct_view_name ------------------+----------------+-----------------------+------------------ rename_schema | rename_test | _timescaledb_internal | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ rename_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA rename_schema RENAME TO new_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 ALTER VIEW :"PART_VIEW_NAME" SET SCHEMA new_name_schema; ALTER VIEW :"DIR_VIEW_NAME" SET SCHEMA new_name_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | new_name_schema | _partial_view_3 | new_name_schema | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA new_name_schema RENAME TO foo_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- foo_name_schema | rename_test | foo_name_schema | _partial_view_3 ALTER MATERIALIZED VIEW foo_name_schema.rename_test SET SCHEMA public; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | foo_name_schema | _partial_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA foo_name_schema RENAME TO rename_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | rename_schema | _partial_view_3 ALTER MATERIALIZED VIEW rename_test RENAME TO rename_c_aggregate; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+--------------------+---------------------+------------------- public | rename_c_aggregate | rename_schema | _partial_view_3 SELECT * FROM rename_c_aggregate; time_bucket | count -------------+------- ALTER VIEW rename_schema.:"PART_VIEW_NAME" RENAME TO partial_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | _direct_view_3 --rename direct view ALTER VIEW rename_schema.:"DIR_VIEW_NAME" RENAME TO direct_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | direct_view -- drop_chunks tests DROP TABLE conditions CASCADE; DROP TABLE foo CASCADE; NOTICE: drop cascades to 2 other objects CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), COUNT(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; -- Only refresh up to bucket 15 initially. Matches the old refresh -- behavior that didn't materialize everything CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- cannot drop directly from the materialization table without specifying -- cont. aggregate view name explicitly \set ON_ERROR_STOP 0 SELECT drop_chunks(:'drop_chunks_mat_table', newer_than => -20, verbose => true); ERROR: operation not supported on materialized hypertable \set ON_ERROR_STOP 1 SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- drop chunks when the chunksize and time_bucket aren't aligned DROP TABLE drop_chunks_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_5_4_chunk CREATE TABLE drop_chunks_table_u(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_u_id FROM create_hypertable('drop_chunks_table_u', 'time', chunk_time_interval => 7) \gset CREATE OR REPLACE FUNCTION integer_now_test1() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table_u $$; SELECT set_integer_now_func('drop_chunks_table_u', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('3', time), COUNT(data) FROM drop_chunks_table_u GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table_u, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_u_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_u_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table_u SELECT i, i FROM generate_series(0, 21) AS i; -- Refresh up to bucket 15 to match old materializer behavior CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table_u') AS c; count ------- 4 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 -- TRUNCATE test -- Can truncate regular hypertables that have caggs TRUNCATE drop_chunks_table_u; \set ON_ERROR_STOP 0 -- Can't truncate materialized hypertables directly TRUNCATE :drop_chunks_mat_table_u; ERROR: cannot TRUNCATE a hypertable underlying a continuous aggregate \set ON_ERROR_STOP 1 -- Check that we don't interfere with TRUNCATE of normal table and -- partitioned table CREATE TABLE truncate (value int); INSERT INTO truncate VALUES (1), (2); TRUNCATE truncate; SELECT * FROM truncate; value ------- CREATE TABLE truncate_partitioned (value int) PARTITION BY RANGE(value); CREATE TABLE truncate_p1 PARTITION OF truncate_partitioned FOR VALUES FROM (1) TO (3); INSERT INTO truncate_partitioned VALUES (1), (2); TRUNCATE truncate_partitioned; SELECT * FROM truncate_partitioned; value ------- -- ALTER TABLE tests \set ON_ERROR_STOP 0 -- test a variety of ALTER TABLE statements ALTER TABLE :drop_chunks_mat_table_u RENAME time_bucket TO bad_name; ERROR: renaming columns on materialization tables is not supported ALTER TABLE :drop_chunks_mat_table_u ADD UNIQUE(time_bucket); ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET UNLOGGED; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ENABLE ROW LEVEL SECURITY; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ADD COLUMN fizzle INTEGER; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DROP COLUMN time_bucket; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket DROP NOT NULL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET DEFAULT 1; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET STORAGE EXTERNAL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DISABLE TRIGGER ALL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET TABLESPACE foo; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u NOT OF; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u OWNER TO CURRENT_USER; ERROR: operation not supported on materialization tables \set ON_ERROR_STOP 1 ALTER TABLE :drop_chunks_mat_table_u SET SCHEMA public; ALTER TABLE :drop_chunks_mat_table_u_name RENAME TO new_name; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT * FROM new_name ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 \set ON_ERROR_STOP 0 -- no continuous aggregates on a continuous aggregate materialization table CREATE MATERIALIZED VIEW new_name_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('6', time_bucket), COUNT("count") FROM new_name GROUP BY 1 WITH NO DATA; ERROR: hypertable is a continuous aggregate materialization table \set ON_ERROR_STOP 1 CREATE TABLE metrics(time timestamptz NOT NULL, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (8,public,metrics,t) INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2 FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; time | const | numeric | first | case | coalesce | avg1 | avg2 ------------------------------+-------+---------+----------------------------------------------+------+----------+------+------ Fri Dec 31 16:00:00 1999 UTC | Const | 4.3 | ("Sat Jan 01 00:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sat Jan 01 16:00:00 2000 UTC | Const | 4.3 | ("Sat Jan 01 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sun Jan 02 16:00:00 2000 UTC | Const | 4.3 | ("Sun Jan 02 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Mon Jan 03 16:00:00 2000 UTC | Const | 4.3 | ("Mon Jan 03 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Tue Jan 04 16:00:00 2000 UTC | Const | 4.3 | ("Tue Jan 04 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 --test materialization of invalidation before drop DROP TABLE IF EXISTS drop_chunks_table CASCADE; NOTICE: table "drop_chunks_table" does not exist, skipping DROP TABLE IF EXISTS drop_chunks_table_u CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_7_9_chunk CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --dropping chunks will process the invalidations SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_13_chunk SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 10 | 10 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(20, 35) AS i; CALL refresh_continuous_aggregate('drop_chunks_view', 10, 40); --this will be seen after the drop its within the invalidation window and will be dropped INSERT INTO drop_chunks_table VALUES (26, 100); --this will not be processed by the drop since chunk 30-39 is not dropped but will be seen after refresh --shows that the drop doesn't do more work than necessary INSERT INTO drop_chunks_table VALUES (31, 200); --move the time up to 39 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(35, 39) AS i; --the chunks and ranges we have thus far SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table'; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_14_chunk | 10 | 20 _hyper_10_15_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --the invalidation on 25 not yet seen SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 29 20 | 24 15 | 19 10 | 14 --refresh to process the invalidations and then drop CALL refresh_continuous_aggregate('drop_chunks_view', NULL, (integer_now_test2()-9)); SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_14_chunk _timescaledb_internal._hyper_10_15_chunk --new values on 25 now seen in view SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 100 20 | 24 15 | 19 10 | 14 --earliest datapoint now in table SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 30 | 30 --chunks are removed SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE dropped; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- --still see data in the view SELECT * FROM drop_chunks_view WHERE time_bucket < (integer_now_test2()-9) ORDER BY time_bucket DESC; time_bucket | max -------------+----- 25 | 100 20 | 24 15 | 19 10 | 14 --no data but covers dropped chunks SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ --recreate the dropped chunk INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --see data from recreated region SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ 20 | 20 19 | 19 18 | 18 17 | 17 16 | 16 15 | 15 14 | 14 13 | 13 12 | 12 11 | 11 10 | 10 9 | 9 8 | 8 7 | 7 6 | 6 5 | 5 4 | 4 3 | 3 2 | 2 1 | 1 0 | 0 --should show chunk with old name and old ranges SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --We dropped everything up to the bucket starting at 30 and then --inserted new data up to and including time 20. Therefore, the --dropped data should stay the same as long as we only refresh --buckets that have non-dropped data. CALL refresh_continuous_aggregate('drop_chunks_view', 30, 40); SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 39 30 | 200 25 | 100 20 | 24 15 | 19 10 | 14 SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_tablen, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_nid AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- TEST drop chunks from continuous aggregates by specifying view name SELECT drop_chunks('drop_chunks_view', newer_than => -20, verbose => true); INFO: dropping chunk _timescaledb_internal._hyper_11_17_chunk drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- Test that we cannot drop chunks when specifying materialized -- hypertable INSERT INTO drop_chunks_table SELECT generate_series(45, 55), 500; CALL refresh_continuous_aggregate('drop_chunks_view', 45, 55); SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = :'drop_chunks_mat_table_name' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_11_23_chunk | 0 | 100 \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT drop_chunks(:'drop_chunks_mat_tablen', older_than => 60); ERROR: operation not supported on materialized hypertable DETAIL: Hypertable "_materialized_hypertable_11" is a materialized hypertable. HINT: Try the operation on the continuous aggregate instead. \set VERBOSITY terse \set ON_ERROR_STOP 1 ----------------------------------------------------------------- -- Test that refresh_continuous_aggregate on chunk will refresh, -- but only in the regions covered by the show chunks. ----------------------------------------------------------------- SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Pick the second chunk as the one to drop WITH numbered_chunks AS ( SELECT row_number() OVER (ORDER BY range_start_integer), chunk_schema, chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 1 ) SELECT format('%I.%I', chunk_schema, chunk_name) AS chunk_to_drop, range_start_integer, range_end_integer FROM numbered_chunks WHERE row_number = 2 \gset -- There's data in the table for the chunk/range we will drop SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 16 | 16 17 | 17 18 | 18 19 | 19 -- Make sure there is also data in the continuous aggregate -- CARE: -- Note that this behaviour of dropping the materialization table chunks and expecting a refresh -- that overlaps that time range to NOT update those chunks is undefined. CALL refresh_continuous_aggregate('drop_chunks_view', 0, 50); SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 9 10 | 14 15 | 19 20 | 20 45 | 500 50 | 500 -- Drop the second chunk, to leave a gap in the data DROP TABLE :chunk_to_drop; -- Verify that the second chunk is dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Data is no longer in the table but still in the view SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ SELECT * FROM drop_chunks_view WHERE time_bucket >= :range_start_integer AND time_bucket < :range_end_integer ORDER BY 1; time_bucket | max -------------+----- 10 | 14 15 | 19 -- Insert a large value in one of the chunks that will be dropped INSERT INTO drop_chunks_table VALUES (:range_start_integer-1, 100); -- Now refresh and drop the two adjecent chunks CALL refresh_continuous_aggregate('drop_chunks_view', NULL, 30); SELECT drop_chunks('drop_chunks_table', older_than=>30); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_18_chunk _timescaledb_internal._hyper_10_20_chunk -- Verify that the chunks are dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- The continuous aggregate should be refreshed in the regions covered -- by the dropped chunks, but not in the "gap" region, i.e., the -- region of the chunk that was dropped via DROP TABLE. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 100 20 | 20 45 | 500 50 | 500 -- Now refresh in the region of the first two dropped chunks CALL refresh_continuous_aggregate('drop_chunks_view', 0, :range_end_integer); -- Aggregate data in the refreshed range should no longer exist since -- the underlying data was dropped. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 20 | 20 45 | 500 50 | 500 -------------------------------------------------------------------- -- Check that we can create a materialized table in a tablespace. We -- create one with tablespace and one without and compare them. CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, pg_get_userbyid(relowner) AS user_view_owner, relname AS mat_table, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = mat_relid) AS mat_table_owner, direct_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = direct_view) AS direct_view_owner, partial_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = partial_view) AS partial_view_owner, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; CREATE VIEW chunk_info AS SELECT ht.schema_name, ht.table_name, relname AS chunk_name, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class c, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.table_name = c.relname AND ht.id = ch.hypertable_id; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset SELECT set_integer_now_func('whatever', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW whatever_view_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW whatever_view_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) TABLESPACE tablespace1 AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; CALL refresh_continuous_aggregate('whatever_view_1', NULL, NULL); CALL refresh_continuous_aggregate('whatever_view_2', NULL, NULL); SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | | _hyper_13_27_chunk | whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 ALTER MATERIALIZED VIEW whatever_view_1 SET TABLESPACE tablespace2; SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | tablespace2 | _hyper_13_27_chunk | tablespace2 whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 DROP MATERIALIZED VIEW whatever_view_1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_27_chunk DROP MATERIALIZED VIEW whatever_view_2; NOTICE: drop cascades to table _timescaledb_internal._hyper_14_28_chunk -- test bucket width expressions on integer hypertables CREATE TABLE metrics_int2 ( time int2 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int4 ( time int4 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int8 ( time int8 NOT NULL, device_id int, v1 float, v2 float ); SELECT create_hypertable (('metrics_' || dt)::regclass, 'time', chunk_time_interval => 10) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); create_hypertable ---------------------------- (15,public,metrics_int2,t) (16,public,metrics_int4,t) (17,public,metrics_int8,t) CREATE OR REPLACE FUNCTION int2_now () RETURNS int2 LANGUAGE SQL STABLE AS $$ SELECT 10::int2 $$; CREATE OR REPLACE FUNCTION int4_now () RETURNS int4 LANGUAGE SQL STABLE AS $$ SELECT 10::int4 $$; CREATE OR REPLACE FUNCTION int8_now () RETURNS int8 LANGUAGE SQL STABLE AS $$ SELECT 10::int8 $$; SELECT set_integer_now_func (('metrics_' || dt)::regclass, (dt || '_now')::regproc) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); set_integer_now_func ---------------------- -- width expression for int2 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint + 2::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int4 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int8 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; \set ON_ERROR_STOP 0 -- non-immutable expresions should be rejected CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::smallint, time) FROM metrics_int2 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int4 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int8 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function \set ON_ERROR_STOP 1 -- Test various ALTER MATERIALIZED VIEW statements. SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE MATERIALIZED VIEW owner_check WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1 WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | default_perm_user mat_table | _materialized_hypertable_24 mat_table_owner | default_perm_user direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | default_perm_user partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | default_perm_user tablespace | \x off -- This should not work since the target user has the wrong role, but -- we test that the normal checks are done when changing the owner. \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; ERROR: must be able to SET ROLE "test_role_1" \set ON_ERROR_STOP 1 -- Superuser can always change owner SET ROLE :ROLE_CLUSTER_SUPERUSER; ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | test_role_1 mat_table | _materialized_hypertable_24 mat_table_owner | test_role_1 direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | test_role_1 partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | test_role_1 tablespace | \x off -- -- Test drop continuous aggregate cases -- -- Issue: #2608 -- CREATE OR REPLACE FUNCTION test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE conditionsnm(time_int INT NOT NULL, device INT, value FLOAT); SELECT create_hypertable('conditionsnm', 'time_int', chunk_time_interval => 10); create_hypertable ---------------------------- (25,public,conditionsnm,t) SELECT set_integer_now_func('conditionsnm', 'test_int_now'); set_integer_now_func ---------------------- INSERT INTO conditionsnm SELECT time_val, time_val % 4, 3.14 FROM generate_series(0,100,1) AS time_val; -- Case 1: DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4; NOTICE: drop cascades to table _timescaledb_internal._hyper_26_40_chunk -- Case 2: DROP CASCADE should have similar behaviour as DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4 CASCADE; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_41_chunk -- Case 3: require CASCADE in case of dependent object CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" CREATE VIEW see_cagg as select * from conditionsnm_4; \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW conditionsnm_4; ERROR: cannot drop view conditionsnm_4 because other objects depend on it \set ON_ERROR_STOP 1 -- Case 4: DROP CASCADE with dependency DROP MATERIALIZED VIEW conditionsnm_4 CASCADE; NOTICE: drop cascades to view see_cagg NOTICE: drop cascades to table _timescaledb_internal._hyper_28_42_chunk -- Test DROP SCHEMA CASCADE with continuous aggregates -- -- Issue: #2350 -- -- Case 1: DROP SCHEMA CASCADE CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (29,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.telemetry_1s WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'telemetry_1s'; raw_hypertable_id | schema_name | MAT_TABLE_NAME | PART_VIEW_NAME | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 29 | _timescaledb_internal | _materialized_hypertable_30 | _partial_view_30 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 4 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'telemetry_1s'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 -- Case 2: DROP SCHEMA CASCADE with multiple caggs CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (31,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; CREATE MATERIALIZED VIEW test_schema.cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME1", partial_view_name as "PART_VIEW_NAME1", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg1'; raw_hypertable_id | schema_name | MAT_TABLE_NAME1 | PART_VIEW_NAME1 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_32 | _partial_view_32 | _timescaledb_internal \gset SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME2", partial_view_name as "PART_VIEW_NAME2", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg2'; raw_hypertable_id | schema_name | MAT_TABLE_NAME2 | PART_VIEW_NAME2 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_33 | _partial_view_33 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 7 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg2'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Check that we can rename a column of a materialized view and still -- rebuild it after (#3051, #3405) CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (34,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'por', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT format('%I.%I', '_timescaledb_internal', h.table_name) AS "MAT_TABLE_NAME", format('%I.%I', '_timescaledb_internal', partial_view_name) AS "PART_VIEW_NAME", format('%I.%I', '_timescaledb_internal', direct_view_name) AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_daily' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns('conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | t avg | double precision | f ALTER MATERIALIZED VIEW conditions_daily RENAME COLUMN bucket to "time"; -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns(' conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | t avg | double precision | f -- This will rebuild the materialized view and should succeed. ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only = false); -- Refresh the continuous aggregate to check that it works after the -- rename. \set VERBOSITY verbose CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); \set VERBOSITY terse -- -- Indexes on continuous aggregate -- \set ON_ERROR_STOP 0 -- unique indexes are not supported CREATE UNIQUE INDEX index_unique_error ON conditions_daily ("time", location); ERROR: continuous aggregates do not support UNIQUE indexes -- concurrently index creation not supported CREATE INDEX CONCURRENTLY index_concurrently_avg ON conditions_daily (avg); ERROR: hypertables do not support concurrent index creation \set ON_ERROR_STOP 1 CREATE INDEX index_avg ON conditions_daily (avg); CREATE INDEX index_avg_only ON ONLY conditions_daily (avg); CREATE INDEX index_avg_include ON conditions_daily (avg) INCLUDE (location); CREATE INDEX index_avg_expr ON conditions_daily ((avg + 1)); CREATE INDEX index_avg_location_sfo ON conditions_daily (avg) WHERE location = 'SFO'; CREATE INDEX index_avg_expr_location_sfo ON conditions_daily ((avg + 2)) WHERE location = 'SFO'; SELECT * FROM test.show_indexespred(:'MAT_TABLE_NAME'); Index | Columns | Expr | Pred | Unique | Primary | Exclusion | Tablespace -----------------------------------------------------------------------+-------------------+---------------------------+------------------------+--------+---------+-----------+------------ _timescaledb_internal._materialized_hypertable_35_bucket_idx | {bucket} | | | f | f | f | _timescaledb_internal._materialized_hypertable_35_location_bucket_idx | {location,bucket} | | | f | f | f | _timescaledb_internal.index_avg | {avg} | | | f | f | f | _timescaledb_internal.index_avg_expr | {expr} | avg + 1::double precision | | f | f | f | _timescaledb_internal.index_avg_expr_location_sfo | {expr} | avg + 2::double precision | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_include | {avg,location} | | | f | f | f | _timescaledb_internal.index_avg_location_sfo | {avg} | | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_only | {avg} | | | f | f | f | -- #3696 assertion failure when referencing columns not present in result CREATE TABLE i3696(time timestamptz NOT NULL, search_query text, cnt integer, cnt2 integer); SELECT table_name FROM create_hypertable('i3696','time'); table_name ------------ i3696 CREATE MATERIALIZED VIEW i3696_cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt +cnt2 , bucket, search_query; NOTICE: continuous aggregate "i3696_cagg1" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg1 SET (timescaledb.materialized_only = 'true'); CREATE MATERIALIZED VIEW i3696_cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt + cnt2, bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: continuous aggregate "i3696_cagg2" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg2 SET (timescaledb.materialized_only = 'true'); --TEST test with multiple settings on continuous aggregates -- -- test for materialized_only + compress combinations (real time aggs enabled initially) CREATE TABLE test_setting(time timestamptz not null, val numeric); SELECT create_hypertable('test_setting', 'time'); create_hypertable ---------------------------- (39,public,test_setting,t) CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: continuous aggregate "test_setting_cagg" is already up-to-date INSERT INTO test_setting SELECT generate_series( '2020-01-10 8:00'::timestamp, '2020-01-30 10:00+00'::timestamptz, '1 day'::interval), 10.0; CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 DELETE FROM test_setting WHERE val = 20; --TEST test with multiple settings on continuous aggregates with real time aggregates turned off initially -- -- test for materialized_only + compress combinations (real time aggs enabled initially) DROP MATERIALIZED VIEW test_setting_cagg; NOTICE: drop cascades to table _timescaledb_internal._hyper_40_50_chunk CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: refreshing continuous aggregate "test_setting_cagg" CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 -- END TEST with multiple settings -- Test View Target Entries that contain both aggrefs and Vars in the same expression CREATE TABLE transactions ( "time" timestamp with time zone NOT NULL, dummy1 integer, dummy2 integer, dummy3 integer, dummy4 integer, dummy5 integer, amount integer, fiat_value integer ); SELECT create_hypertable('transactions', 'time'); create_hypertable ---------------------------- (44,public,transactions,t) INSERT INTO transactions VALUES ( '2018-01-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:30:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:20:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 10:40:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 11:50:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 12:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 13:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-02 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-02 10:30:00-08', 0, 0, 0, 0, 0, -1, 10); CREATE materialized view cashflows( bucket, amount, cashflow, cashflow2 ) WITH ( timescaledb.continuous, timescaledb.materialized_only = true ) AS SELECT time_bucket ('1 day', time) AS bucket, amount, CASE WHEN amount < 0 THEN (0 - sum(fiat_value)) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) FROM transactions GROUP BY bucket, amount; NOTICE: refreshing continuous aggregate "cashflows" SELECT h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", direct_view_name AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cashflows' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. \d+ "_timescaledb_internal".:"DIRECT_VIEW_NAME" View "_timescaledb_internal._direct_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, "time") AS bucket, amount, CASE WHEN amount < 0 THEN 0 - sum(fiat_value) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, "time")), amount; \d+ "_timescaledb_internal".:"PART_VIEW_NAME" View "_timescaledb_internal._partial_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, "time") AS bucket, amount, CASE WHEN amount < 0 THEN 0 - sum(fiat_value) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, "time")), amount; \d+ "_timescaledb_internal".:"MAT_TABLE_NAME" Table "_timescaledb_internal._materialized_hypertable_45" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -----------+--------------------------+-----------+----------+---------+---------+--------------+------------- bucket | timestamp with time zone | | not null | | plain | | amount | integer | | | | plain | | cashflow | bigint | | | | plain | | cashflow2 | bigint | | | | plain | | Indexes: "_materialized_hypertable_45_amount_bucket_idx" btree (amount, bucket DESC) "_materialized_hypertable_45_bucket_idx" btree (bucket DESC) Child tables: _timescaledb_internal._hyper_45_55_chunk, _timescaledb_internal._hyper_45_56_chunk \d+ 'cashflows' View "public.cashflows" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT bucket, amount, cashflow, cashflow2 FROM _timescaledb_internal._materialized_hypertable_45; SELECT * FROM cashflows ORDER BY cashflows; bucket | amount | cashflow | cashflow2 ------------------------------+--------+----------+----------- Sun Dec 31 16:00:00 2017 UTC | 1 | 10 | 11 Mon Jan 01 16:00:00 2018 UTC | -1 | -30 | 29 Wed Oct 31 16:00:00 2018 UTC | -1 | -20 | 19 Wed Oct 31 16:00:00 2018 UTC | 1 | 30 | 31 Thu Nov 01 16:00:00 2018 UTC | -1 | -10 | 9 Thu Nov 01 16:00:00 2018 UTC | 1 | 10 | 11 -- test cagg creation with named arguments in time_bucket -- note that positional arguments cannot follow named arguments -- 1. test named origin -- 2. test named timezone -- 3. test named ts -- 4. test named bucket width -- named origin CREATE MATERIALIZED VIEW cagg_named_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named timezone CREATE MATERIALIZED VIEW cagg_named_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named ts CREATE MATERIALIZED VIEW cagg_named_ts_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named bucket width CREATE MATERIALIZED VIEW cagg_named_all WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(bucket_width => '1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- Refreshing from the beginning (NULL) of a CAGG with variable time bucket and -- using an INTERVAL for the end timestamp (issue #5534) CREATE MATERIALIZED VIEW transactions_montly WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; -- No rows SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min --------+-----+-----+----- -- Refresh from beginning of the CAGG for 1 month CALL refresh_continuous_aggregate('transactions_montly', NULL, INTERVAL '1 month'); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 TRUNCATE transactions_montly; -- Partial refresh the CAGG from beginning to an specific timestamp CALL refresh_continuous_aggregate('transactions_montly', NULL, '2018-11-01 11:50:00-08'::timestamptz); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 -- Full refresh the CAGG CALL refresh_continuous_aggregate('transactions_montly', NULL, NULL); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 -- Check set_chunk_time_interval on continuous aggregate CREATE MATERIALIZED VIEW cagg_set_chunk_time_interval WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; SELECT set_chunk_time_interval('cagg_set_chunk_time_interval', chunk_time_interval => interval '1 month'); set_chunk_time_interval ------------------------- CALL refresh_continuous_aggregate('cagg_set_chunk_time_interval', NULL, NULL); SELECT _timescaledb_functions.to_interval(d.interval_length) = interval '1 month' FROM _timescaledb_catalog.dimension d RIGHT JOIN _timescaledb_catalog.continuous_agg ca ON ca.user_view_name = 'cagg_set_chunk_time_interval' WHERE d.hypertable_id = ca.mat_hypertable_id; ?column? ---------- t -- Since #6077 CAggs are materialized only by default DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'POR', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT location, bucket, avg FROM _timescaledb_internal._materialized_hypertable_53; -- Should return NO ROWS SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+--------+----- ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=false); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT _materialized_hypertable_53.location, _materialized_hypertable_53.bucket, _materialized_hypertable_53.avg FROM _timescaledb_internal._materialized_hypertable_53 WHERE _materialized_hypertable_53.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) UNION ALL SELECT conditions.location, time_bucket('@ 1 day'::interval, conditions."time") AS bucket, avg(conditions.temperature) AS avg FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) GROUP BY conditions.location, (time_bucket('@ 1 day'::interval, conditions."time")); -- Should return ROWS because now it is realtime SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Should return ROWS because we refreshed it ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=true); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT location, bucket, avg FROM _timescaledb_internal._materialized_hypertable_53; CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Test TRUNCATE over a Realtime CAgg DROP MATERIALIZED VIEW conditions_daily; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_daily' \gset -- Check the current watermark for an empty CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_empty_cagg; watermak_empty_cagg --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Refresh the CAGG CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); -- Check the watermark after the refresh and before truncate the CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_before; watermak_before ------------------------------ Fri Nov 02 16:00:00 2018 UTC -- Exists chunks before truncate the cagg (> 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 2 -- Truncate the given CAgg, it should reset the watermark to the empty state TRUNCATE conditions_daily; -- No chunks remains after truncate the cagg (= 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 0 -- Watermark should be reseted SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_after; watermak_after --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Should return ROWS because the watermark was reseted by the TRUNCATE SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- check compression settings are cleaned up when deleting a cagg with compression CREATE TABLE cagg_cleanup(time timestamptz not null); SELECT table_name FROM create_hypertable('cagg_cleanup','time'); table_name -------------- cagg_cleanup INSERT INTO cagg_cleanup SELECT '2020-01-01'; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1h',time) FROM cagg_cleanup GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" ALTER MATERIALIZED VIEW cagg1 SET (timescaledb.compress); NOTICE: defaulting compress_orderby to time_bucket SELECT count(compress_chunk(ch)) FROM show_chunks('cagg1') ch; count ------- 1 DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_56_70_chunk SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- -- test WITH namespace alias CREATE TABLE with_alias(time timestamptz not null); CREATE MATERIALIZED VIEW cagg_alias WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; ALTER MATERIALIZED VIEW cagg_alias SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_alias SET (tsdb.materialized_only=false); DROP MATERIALIZED VIEW cagg_alias; -- test SET chunk_time_interval CREATE MATERIALIZED VIEW cagg_set WITH (tsdb.continuous, tsdb.chunk_interval='1day') AS SELECT time_bucket(INTERVAL '1 day', time) AS cagg_interval_setter FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 1 day ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='23 day'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 23 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='6 month'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 180 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='1 year'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 360 days -- test cagg with stable functions CREATE MATERIALIZED VIEW cagg_stable WITH (tsdb.continuous) AS SELECT sum(temperature), max(time + INTERVAL '1h') FROM conditions GROUP BY time_bucket('1week', time), location; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization NOTICE: refreshing continuous aggregate "cagg_stable" SELECT * FROM cagg_stable t ORDER BY t; sum | max -----+------------------------------ 65 | Tue Jan 02 10:10:00 2018 UTC 100 | Tue Jan 02 10:30:00 2018 UTC 120 | Tue Jan 02 10:20:00 2018 UTC 355 | Fri Nov 02 11:30:00 2018 UTC --aggregate without combine function but stable function CREATE MATERIALIZED VIEW cagg_json_agg WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT json_agg(location) from conditions group by time_bucket('1week', time), location WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE FUNCTION test_stablefunc(int) RETURNS int LANGUAGE 'sql' STABLE AS 'SELECT $1 + 10'; CREATE MATERIALIZED VIEW cagg_stable2 WITH (tsdb.continuous) AS SELECT sum(test_stablefunc(temperature::int)), min(location) FROM conditions GROUP BY time_bucket('1week', time) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE MATERIALIZED VIEW cagg_stable3 WITH (tsdb.continuous) AS SELECT sum(temperature), min(location) FROM conditions GROUP BY time_bucket('1week', time), test_stablefunc(temperature::int) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- test window functions in caggs -- first do sanity check that we error without the GUC \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_window WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; ERROR: invalid continuous aggregate query \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_window_functions TO on; CREATE MATERIALIZED VIEW cagg_window_1 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_1" CREATE MATERIALIZED VIEW cagg_window_2 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time), location) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_2" CREATE MATERIALIZED VIEW cagg_window_3 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_3" CREATE MATERIALIZED VIEW cagg_window_4 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER w FROM conditions GROUP BY 1, location WINDOW w AS (PARTITION BY time_bucket('1 week',time)); WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_4" -- test setting chunk_interval on a cagg CREATE MATERIALIZED VIEW cagg_chunk_interval WITH (tsdb.continuous, tsdb.chunk_interval='1000 day') AS SELECT time_bucket('1 week', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 1000 days ALTER MATERIALIZED VIEW cagg_chunk_interval SET (tsdb.chunk_interval='110 day'); SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 110 days -- test columnstore options CREATE MATERIALIZED VIEW columnstore_options WITH (tsdb.continuous, tsdb.chunk_interval='1 day') AS SELECT time_bucket('1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.columnstore, tsdb.chunk_interval='1 day', tsdb.orderby='time_bucket DESC', tsdb.compress_chunk_interval='2 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 172800000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_interval='3 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 259200000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_time_interval='4 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 345600000000 -- test set returning functions in caggs CREATE TABLE kpis_raw (time TIMESTAMP NOT NULL, value INTEGER, groups TEXT[]) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO kpis_raw (time, value, groups) VALUES ('2025-01-01', 10, '{group1,group2,group3}'), ('2025-01-02', 20, '{group1,group4}'), ('2025-02-01', 10, '{group1,group3}'), ('2025-02-01', 20, '{group1,group4}'); CREATE MATERIALIZED VIEW kpis_cagg WITH (tsdb.continuous) AS SELECT time_bucket('7 day', time) AS bucket, count(*) AS number_of_records, avg(value) AS average, unnest(groups) AS kpi_group FROM kpis_raw GROUP BY bucket, kpi_group; NOTICE: refreshing continuous aggregate "kpis_cagg" SELECT * FROM kpis_cagg ORDER BY bucket, kpi_group; bucket | number_of_records | average | kpi_group --------------------------+-------------------+---------------------+----------- Mon Dec 30 00:00:00 2024 | 2 | 15.0000000000000000 | group1 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group2 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group3 Mon Dec 30 00:00:00 2024 | 1 | 20.0000000000000000 | group4 Mon Jan 27 00:00:00 2025 | 2 | 15.0000000000000000 | group1 Mon Jan 27 00:00:00 2025 | 1 | 10.0000000000000000 | group3 Mon Jan 27 00:00:00 2025 | 1 | 20.0000000000000000 | group4 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_ddl-18.out������������������������������������������������0000664�0000000�0000000�00000265240�15100345067�0022151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH '../../../../test/sql/include/query_result_test_equal.sql' SET ROLE :ROLE_DEFAULT_PERM_USER; --DDL commands on continuous aggregates CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions -- schema tests \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO 'UTC+8'; -- drop if the tablespace1 and/or tablespace2 exists SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; CREATE SCHEMA rename_schema; GRANT ALL ON SCHEMA rename_schema TO :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE foo(time TIMESTAMPTZ NOT NULL, data INTEGER); SELECT create_hypertable('foo', 'time'); create_hypertable ------------------- (2,public,foo,t) CREATE MATERIALIZED VIEW rename_test_old WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1week', time), COUNT(data) FROM foo GROUP BY 1 WITH NO DATA; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+-----------------+-----------------------+------------------- public | rename_test_old | _timescaledb_internal | _partial_view_3 ALTER TABLE rename_test_old RENAME TO rename_test; ALTER TABLE rename_test SET SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- test_schema | rename_test | _timescaledb_internal | _partial_view_3 ALTER MATERIALIZED VIEW test_schema.rename_test SET SCHEMA rename_schema; DROP SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+-----------------------+------------------- rename_schema | rename_test | _timescaledb_internal | _partial_view_3 SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'rename_test' \gset RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- rename_schema | rename_test | public | _partial_view_3 --alter direct view schema SELECT user_view_schema, user_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | direct_view_schema | direct_view_name ------------------+----------------+-----------------------+------------------ rename_schema | rename_test | _timescaledb_internal | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ rename_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA rename_schema RENAME TO new_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | public | _partial_view_3 | public | _direct_view_3 ALTER VIEW :"PART_VIEW_NAME" SET SCHEMA new_name_schema; ALTER VIEW :"DIR_VIEW_NAME" SET SCHEMA new_name_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+----------------+---------------------+-------------------+--------------------+------------------ new_name_schema | rename_test | new_name_schema | _partial_view_3 | new_name_schema | _direct_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA new_name_schema RENAME TO foo_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- foo_name_schema | rename_test | foo_name_schema | _partial_view_3 ALTER MATERIALIZED VIEW foo_name_schema.rename_test SET SCHEMA public; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | foo_name_schema | _partial_view_3 RESET ROLE; SELECT current_user; current_user -------------------- cluster_super_user ALTER SCHEMA foo_name_schema RENAME TO rename_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+----------------+---------------------+------------------- public | rename_test | rename_schema | _partial_view_3 ALTER MATERIALIZED VIEW rename_test RENAME TO rename_c_aggregate; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name ------------------+--------------------+---------------------+------------------- public | rename_c_aggregate | rename_schema | _partial_view_3 SELECT * FROM rename_c_aggregate; time_bucket | count -------------+------- ALTER VIEW rename_schema.:"PART_VIEW_NAME" RENAME TO partial_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | _direct_view_3 --rename direct view ALTER VIEW rename_schema.:"DIR_VIEW_NAME" RENAME TO direct_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; user_view_schema | user_view_name | partial_view_schema | partial_view_name | direct_view_schema | direct_view_name ------------------+--------------------+---------------------+-------------------+--------------------+------------------ public | rename_c_aggregate | rename_schema | partial_view | rename_schema | direct_view -- drop_chunks tests DROP TABLE conditions CASCADE; DROP TABLE foo CASCADE; NOTICE: drop cascades to 2 other objects CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), COUNT(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; -- Only refresh up to bucket 15 initially. Matches the old refresh -- behavior that didn't materialize everything CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- cannot drop directly from the materialization table without specifying -- cont. aggregate view name explicitly \set ON_ERROR_STOP 0 SELECT drop_chunks(:'drop_chunks_mat_table', newer_than => -20, verbose => true); ERROR: operation not supported on materialized hypertable \set ON_ERROR_STOP 1 SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; count ------- 3 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 -- drop chunks when the chunksize and time_bucket aren't aligned DROP TABLE drop_chunks_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_5_4_chunk CREATE TABLE drop_chunks_table_u(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_u_id FROM create_hypertable('drop_chunks_table_u', 'time', chunk_time_interval => 7) \gset CREATE OR REPLACE FUNCTION integer_now_test1() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table_u $$; SELECT set_integer_now_func('drop_chunks_table_u', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('3', time), COUNT(data) FROM drop_chunks_table_u GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table_u, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_u_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_u_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table_u SELECT i, i FROM generate_series(0, 21) AS i; -- Refresh up to bucket 15 to match old materializer behavior CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table_u') AS c; count ------- 4 SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; count ------- 1 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 -- TRUNCATE test -- Can truncate regular hypertables that have caggs TRUNCATE drop_chunks_table_u; \set ON_ERROR_STOP 0 -- Can't truncate materialized hypertables directly TRUNCATE :drop_chunks_mat_table_u; ERROR: cannot TRUNCATE a hypertable underlying a continuous aggregate \set ON_ERROR_STOP 1 -- Check that we don't interfere with TRUNCATE of normal table and -- partitioned table CREATE TABLE truncate (value int); INSERT INTO truncate VALUES (1), (2); TRUNCATE truncate; SELECT * FROM truncate; value ------- CREATE TABLE truncate_partitioned (value int) PARTITION BY RANGE(value); CREATE TABLE truncate_p1 PARTITION OF truncate_partitioned FOR VALUES FROM (1) TO (3); INSERT INTO truncate_partitioned VALUES (1), (2); TRUNCATE truncate_partitioned; SELECT * FROM truncate_partitioned; value ------- -- ALTER TABLE tests \set ON_ERROR_STOP 0 -- test a variety of ALTER TABLE statements ALTER TABLE :drop_chunks_mat_table_u RENAME time_bucket TO bad_name; ERROR: renaming columns on materialization tables is not supported ALTER TABLE :drop_chunks_mat_table_u ADD UNIQUE(time_bucket); ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET UNLOGGED; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ENABLE ROW LEVEL SECURITY; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ADD COLUMN fizzle INTEGER; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DROP COLUMN time_bucket; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket DROP NOT NULL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET DEFAULT 1; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET STORAGE EXTERNAL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u DISABLE TRIGGER ALL; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u SET TABLESPACE foo; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u NOT OF; ERROR: operation not supported on materialization tables ALTER TABLE :drop_chunks_mat_table_u OWNER TO CURRENT_USER; ERROR: operation not supported on materialization tables \set ON_ERROR_STOP 1 ALTER TABLE :drop_chunks_mat_table_u SET SCHEMA public; ALTER TABLE :drop_chunks_mat_table_u_name RENAME TO new_name; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT * FROM new_name ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | count -------------+------- 0 | 3 3 | 3 6 | 3 9 | 3 12 | 3 \set ON_ERROR_STOP 0 -- no continuous aggregates on a continuous aggregate materialization table CREATE MATERIALIZED VIEW new_name_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('6', time_bucket), COUNT("count") FROM new_name GROUP BY 1 WITH NO DATA; ERROR: hypertable is a continuous aggregate materialization table \set ON_ERROR_STOP 1 CREATE TABLE metrics(time timestamptz NOT NULL, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (8,public,metrics,t) INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2 FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; time | const | numeric | first | case | coalesce | avg1 | avg2 ------------------------------+-------+---------+----------------------------------------------+------+----------+------+------ Fri Dec 31 16:00:00 1999 UTC | Const | 4.3 | ("Sat Jan 01 00:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sat Jan 01 16:00:00 2000 UTC | Const | 4.3 | ("Sat Jan 01 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Sun Jan 02 16:00:00 2000 UTC | Const | 4.3 | ("Sun Jan 02 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Mon Jan 03 16:00:00 2000 UTC | Const | 4.3 | ("Mon Jan 03 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 Tue Jan 04 16:00:00 2000 UTC | Const | 4.3 | ("Tue Jan 04 16:00:00 2000 UTC",1,0.25,0.75) | foo | coalesce | 1 | 1 --test materialization of invalidation before drop DROP TABLE IF EXISTS drop_chunks_table CASCADE; NOTICE: table "drop_chunks_table" does not exist, skipping DROP TABLE IF EXISTS drop_chunks_table_u CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_7_9_chunk CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --dropping chunks will process the invalidations SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_13_chunk SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 10 | 10 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(20, 35) AS i; CALL refresh_continuous_aggregate('drop_chunks_view', 10, 40); --this will be seen after the drop its within the invalidation window and will be dropped INSERT INTO drop_chunks_table VALUES (26, 100); --this will not be processed by the drop since chunk 30-39 is not dropped but will be seen after refresh --shows that the drop doesn't do more work than necessary INSERT INTO drop_chunks_table VALUES (31, 200); --move the time up to 39 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(35, 39) AS i; --the chunks and ranges we have thus far SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table'; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_14_chunk | 10 | 20 _hyper_10_15_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --the invalidation on 25 not yet seen SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 29 20 | 24 15 | 19 10 | 14 --refresh to process the invalidations and then drop CALL refresh_continuous_aggregate('drop_chunks_view', NULL, (integer_now_test2()-9)); SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_14_chunk _timescaledb_internal._hyper_10_15_chunk --new values on 25 now seen in view SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 35 30 | 34 25 | 100 20 | 24 15 | 19 10 | 14 --earliest datapoint now in table SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; time | data ------+------ 30 | 30 --chunks are removed SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE dropped; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-------------+------------+---------------------+---------+--------+----------- --still see data in the view SELECT * FROM drop_chunks_view WHERE time_bucket < (integer_now_test2()-9) ORDER BY time_bucket DESC; time_bucket | max -------------+----- 25 | 100 20 | 24 15 | 19 10 | 14 --no data but covers dropped chunks SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ --recreate the dropped chunk INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --see data from recreated region SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; time | data ------+------ 20 | 20 19 | 19 18 | 18 17 | 17 16 | 16 15 | 15 14 | 14 13 | 13 12 | 12 11 | 11 10 | 10 9 | 9 8 | 8 7 | 7 6 | 6 5 | 5 4 | 4 3 | 3 2 | 2 1 | 1 0 | 0 --should show chunk with old name and old ranges SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 --We dropped everything up to the bucket starting at 30 and then --inserted new data up to and including time 20. Therefore, the --dropped data should stay the same as long as we only refresh --buckets that have non-dropped data. CALL refresh_continuous_aggregate('drop_chunks_view', 30, 40); SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; time_bucket | max -------------+----- 35 | 39 30 | 200 25 | 100 20 | 24 15 | 19 10 | 14 SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_tablen, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_nid AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- TEST drop chunks from continuous aggregates by specifying view name SELECT drop_chunks('drop_chunks_view', newer_than => -20, verbose => true); INFO: dropping chunk _timescaledb_internal._hyper_11_17_chunk drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- Test that we cannot drop chunks when specifying materialized -- hypertable INSERT INTO drop_chunks_table SELECT generate_series(45, 55), 500; CALL refresh_continuous_aggregate('drop_chunks_view', 45, 55); SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = :'drop_chunks_mat_table_name' ORDER BY range_start_integer; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_11_23_chunk | 0 | 100 \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT drop_chunks(:'drop_chunks_mat_tablen', older_than => 60); ERROR: operation not supported on materialized hypertable DETAIL: Hypertable "_materialized_hypertable_11" is a materialized hypertable. HINT: Try the operation on the continuous aggregate instead. \set VERBOSITY terse \set ON_ERROR_STOP 1 ----------------------------------------------------------------- -- Test that refresh_continuous_aggregate on chunk will refresh, -- but only in the regions covered by the show chunks. ----------------------------------------------------------------- SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_19_chunk | 10 | 20 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Pick the second chunk as the one to drop WITH numbered_chunks AS ( SELECT row_number() OVER (ORDER BY range_start_integer), chunk_schema, chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 1 ) SELECT format('%I.%I', chunk_schema, chunk_name) AS chunk_to_drop, range_start_integer, range_end_integer FROM numbered_chunks WHERE row_number = 2 \gset -- There's data in the table for the chunk/range we will drop SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 16 | 16 17 | 17 18 | 18 19 | 19 -- Make sure there is also data in the continuous aggregate -- CARE: -- Note that this behaviour of dropping the materialization table chunks and expecting a refresh -- that overlaps that time range to NOT update those chunks is undefined. CALL refresh_continuous_aggregate('drop_chunks_view', 0, 50); SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 9 10 | 14 15 | 19 20 | 20 45 | 500 50 | 500 -- Drop the second chunk, to leave a gap in the data DROP TABLE :chunk_to_drop; -- Verify that the second chunk is dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_18_chunk | 0 | 10 _hyper_10_20_chunk | 20 | 30 _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- Data is no longer in the table but still in the view SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; time | data ------+------ SELECT * FROM drop_chunks_view WHERE time_bucket >= :range_start_integer AND time_bucket < :range_end_integer ORDER BY 1; time_bucket | max -------------+----- 10 | 14 15 | 19 -- Insert a large value in one of the chunks that will be dropped INSERT INTO drop_chunks_table VALUES (:range_start_integer-1, 100); -- Now refresh and drop the two adjecent chunks CALL refresh_continuous_aggregate('drop_chunks_view', NULL, 30); SELECT drop_chunks('drop_chunks_table', older_than=>30); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_18_chunk _timescaledb_internal._hyper_10_20_chunk -- Verify that the chunks are dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; chunk_name | range_start_integer | range_end_integer --------------------+---------------------+------------------- _hyper_10_16_chunk | 30 | 40 _hyper_10_21_chunk | 40 | 50 _hyper_10_22_chunk | 50 | 60 -- The continuous aggregate should be refreshed in the regions covered -- by the dropped chunks, but not in the "gap" region, i.e., the -- region of the chunk that was dropped via DROP TABLE. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 0 | 4 5 | 100 20 | 20 45 | 500 50 | 500 -- Now refresh in the region of the first two dropped chunks CALL refresh_continuous_aggregate('drop_chunks_view', 0, :range_end_integer); -- Aggregate data in the refreshed range should no longer exist since -- the underlying data was dropped. SELECT * FROM drop_chunks_view ORDER BY 1; time_bucket | max -------------+----- 20 | 20 45 | 500 50 | 500 -------------------------------------------------------------------- -- Check that we can create a materialized table in a tablespace. We -- create one with tablespace and one without and compare them. CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, pg_get_userbyid(relowner) AS user_view_owner, relname AS mat_table, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = mat_relid) AS mat_table_owner, direct_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = direct_view) AS direct_view_owner, partial_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = partial_view) AS partial_view_owner, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; CREATE VIEW chunk_info AS SELECT ht.schema_name, ht.table_name, relname AS chunk_name, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class c, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.table_name = c.relname AND ht.id = ch.hypertable_id; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset SELECT set_integer_now_func('whatever', 'integer_now_test'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW whatever_view_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW whatever_view_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) TABLESPACE tablespace1 AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; CALL refresh_continuous_aggregate('whatever_view_1', NULL, NULL); CALL refresh_continuous_aggregate('whatever_view_2', NULL, NULL); SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | | _hyper_13_27_chunk | whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 ALTER MATERIALIZED VIEW whatever_view_1 SET TABLESPACE tablespace2; SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; user_view | mat_table | mat_tablespace | chunk_name | chunk_tablespace -----------------+-----------------------------+----------------+--------------------+------------------ whatever_view_1 | _materialized_hypertable_13 | tablespace2 | _hyper_13_27_chunk | tablespace2 whatever_view_2 | _materialized_hypertable_14 | tablespace1 | _hyper_14_28_chunk | tablespace1 DROP MATERIALIZED VIEW whatever_view_1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_27_chunk DROP MATERIALIZED VIEW whatever_view_2; NOTICE: drop cascades to table _timescaledb_internal._hyper_14_28_chunk -- test bucket width expressions on integer hypertables CREATE TABLE metrics_int2 ( time int2 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int4 ( time int4 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int8 ( time int8 NOT NULL, device_id int, v1 float, v2 float ); SELECT create_hypertable (('metrics_' || dt)::regclass, 'time', chunk_time_interval => 10) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); create_hypertable ---------------------------- (15,public,metrics_int2,t) (16,public,metrics_int4,t) (17,public,metrics_int8,t) CREATE OR REPLACE FUNCTION int2_now () RETURNS int2 LANGUAGE SQL STABLE AS $$ SELECT 10::int2 $$; CREATE OR REPLACE FUNCTION int4_now () RETURNS int4 LANGUAGE SQL STABLE AS $$ SELECT 10::int4 $$; CREATE OR REPLACE FUNCTION int8_now () RETURNS int8 LANGUAGE SQL STABLE AS $$ SELECT 10::int8 $$; SELECT set_integer_now_func (('metrics_' || dt)::regclass, (dt || '_now')::regproc) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); set_integer_now_func ---------------------- -- width expression for int2 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint + 2::smallint, time) FROM metrics_int2 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int4 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int4 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; -- width expression for int8 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1; NOTICE: continuous aggregate "width_expr" is already up-to-date DROP MATERIALIZED VIEW width_expr; \set ON_ERROR_STOP 0 -- non-immutable expresions should be rejected CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::smallint, time) FROM metrics_int2 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int4 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int8 GROUP BY 1; ERROR: only immutable expressions allowed in time bucket function \set ON_ERROR_STOP 1 -- Test various ALTER MATERIALIZED VIEW statements. SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE MATERIALIZED VIEW owner_check WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1 WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | default_perm_user mat_table | _materialized_hypertable_24 mat_table_owner | default_perm_user direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | default_perm_user partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | default_perm_user tablespace | \x off -- This should not work since the target user has the wrong role, but -- we test that the normal checks are done when changing the owner. \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; ERROR: must be able to SET ROLE "test_role_1" \set ON_ERROR_STOP 1 -- Superuser can always change owner SET ROLE :ROLE_CLUSTER_SUPERUSER; ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; -[ RECORD 1 ]------+--------------------------------------- user_view | owner_check user_view_owner | test_role_1 mat_table | _materialized_hypertable_24 mat_table_owner | test_role_1 direct_view | _timescaledb_internal._direct_view_24 direct_view_owner | test_role_1 partial_view | _timescaledb_internal._partial_view_24 partial_view_owner | test_role_1 tablespace | \x off -- -- Test drop continuous aggregate cases -- -- Issue: #2608 -- CREATE OR REPLACE FUNCTION test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE conditionsnm(time_int INT NOT NULL, device INT, value FLOAT); SELECT create_hypertable('conditionsnm', 'time_int', chunk_time_interval => 10); create_hypertable ---------------------------- (25,public,conditionsnm,t) SELECT set_integer_now_func('conditionsnm', 'test_int_now'); set_integer_now_func ---------------------- INSERT INTO conditionsnm SELECT time_val, time_val % 4, 3.14 FROM generate_series(0,100,1) AS time_val; -- Case 1: DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4; NOTICE: drop cascades to table _timescaledb_internal._hyper_26_40_chunk -- Case 2: DROP CASCADE should have similar behaviour as DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" DROP materialized view conditionsnm_4 CASCADE; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_41_chunk -- Case 3: require CASCADE in case of dependent object CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditionsnm_4" CREATE VIEW see_cagg as select * from conditionsnm_4; \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW conditionsnm_4; ERROR: cannot drop view conditionsnm_4 because other objects depend on it \set ON_ERROR_STOP 1 -- Case 4: DROP CASCADE with dependency DROP MATERIALIZED VIEW conditionsnm_4 CASCADE; NOTICE: drop cascades to view see_cagg NOTICE: drop cascades to table _timescaledb_internal._hyper_28_42_chunk -- Test DROP SCHEMA CASCADE with continuous aggregates -- -- Issue: #2350 -- -- Case 1: DROP SCHEMA CASCADE CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (29,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.telemetry_1s WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'telemetry_1s'; raw_hypertable_id | schema_name | MAT_TABLE_NAME | PART_VIEW_NAME | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 29 | _timescaledb_internal | _materialized_hypertable_30 | _partial_view_30 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 4 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'telemetry_1s'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 -- Case 2: DROP SCHEMA CASCADE with multiple caggs CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); create_hypertable ---------------------------------- (31,test_schema,telemetry_raw,t) CREATE MATERIALIZED VIEW test_schema.cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; CREATE MATERIALIZED VIEW test_schema.cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME1", partial_view_name as "PART_VIEW_NAME1", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg1'; raw_hypertable_id | schema_name | MAT_TABLE_NAME1 | PART_VIEW_NAME1 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_32 | _partial_view_32 | _timescaledb_internal \gset SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME2", partial_view_name as "PART_VIEW_NAME2", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg2'; raw_hypertable_id | schema_name | MAT_TABLE_NAME2 | PART_VIEW_NAME2 | partial_view_schema -------------------+-----------------------+-----------------------------+------------------+----------------------- 31 | _timescaledb_internal | _materialized_hypertable_33 | _partial_view_33 | _timescaledb_internal \gset DROP SCHEMA test_schema CASCADE; NOTICE: drop cascades to 7 other objects SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg1'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME2'; count ------- 0 SELECT count(*) FROM pg_class WHERE relname = 'cagg2'; count ------- 0 SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; count ------- 0 DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Check that we can rename a column of a materialized view and still -- rebuild it after (#3051, #3405) CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (34,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'por', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT format('%I.%I', '_timescaledb_internal', h.table_name) AS "MAT_TABLE_NAME", format('%I.%I', '_timescaledb_internal', partial_view_name) AS "PART_VIEW_NAME", format('%I.%I', '_timescaledb_internal', direct_view_name) AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_daily' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns('conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f bucket | timestamp with time zone | t avg | double precision | f ALTER MATERIALIZED VIEW conditions_daily RENAME COLUMN bucket to "time"; -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns(' conditions_daily'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | f avg | double precision | f SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); Column | Type | NotNull ----------+--------------------------+--------- location | text | f time | timestamp with time zone | t avg | double precision | f -- This will rebuild the materialized view and should succeed. ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only = false); -- Refresh the continuous aggregate to check that it works after the -- rename. \set VERBOSITY verbose CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); \set VERBOSITY terse -- -- Indexes on continuous aggregate -- \set ON_ERROR_STOP 0 -- unique indexes are not supported CREATE UNIQUE INDEX index_unique_error ON conditions_daily ("time", location); ERROR: continuous aggregates do not support UNIQUE indexes -- concurrently index creation not supported CREATE INDEX CONCURRENTLY index_concurrently_avg ON conditions_daily (avg); ERROR: hypertables do not support concurrent index creation \set ON_ERROR_STOP 1 CREATE INDEX index_avg ON conditions_daily (avg); CREATE INDEX index_avg_only ON ONLY conditions_daily (avg); CREATE INDEX index_avg_include ON conditions_daily (avg) INCLUDE (location); CREATE INDEX index_avg_expr ON conditions_daily ((avg + 1)); CREATE INDEX index_avg_location_sfo ON conditions_daily (avg) WHERE location = 'SFO'; CREATE INDEX index_avg_expr_location_sfo ON conditions_daily ((avg + 2)) WHERE location = 'SFO'; SELECT * FROM test.show_indexespred(:'MAT_TABLE_NAME'); Index | Columns | Expr | Pred | Unique | Primary | Exclusion | Tablespace -----------------------------------------------------------------------+-------------------+---------------------------+------------------------+--------+---------+-----------+------------ _timescaledb_internal._materialized_hypertable_35_bucket_idx | {bucket} | | | f | f | f | _timescaledb_internal._materialized_hypertable_35_location_bucket_idx | {location,bucket} | | | f | f | f | _timescaledb_internal.index_avg | {avg} | | | f | f | f | _timescaledb_internal.index_avg_expr | {expr} | avg + 1::double precision | | f | f | f | _timescaledb_internal.index_avg_expr_location_sfo | {expr} | avg + 2::double precision | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_include | {avg,location} | | | f | f | f | _timescaledb_internal.index_avg_location_sfo | {avg} | | location = 'SFO'::text | f | f | f | _timescaledb_internal.index_avg_only | {avg} | | | f | f | f | -- #3696 assertion failure when referencing columns not present in result CREATE TABLE i3696(time timestamptz NOT NULL, search_query text, cnt integer, cnt2 integer); SELECT table_name FROM create_hypertable('i3696','time'); table_name ------------ i3696 CREATE MATERIALIZED VIEW i3696_cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt +cnt2 , bucket, search_query; NOTICE: continuous aggregate "i3696_cagg1" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg1 SET (timescaledb.materialized_only = 'true'); CREATE MATERIALIZED VIEW i3696_cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt + cnt2, bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: continuous aggregate "i3696_cagg2" is already up-to-date ALTER MATERIALIZED VIEW i3696_cagg2 SET (timescaledb.materialized_only = 'true'); --TEST test with multiple settings on continuous aggregates -- -- test for materialized_only + compress combinations (real time aggs enabled initially) CREATE TABLE test_setting(time timestamptz not null, val numeric); SELECT create_hypertable('test_setting', 'time'); create_hypertable ---------------------------- (39,public,test_setting,t) CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: continuous aggregate "test_setting_cagg" is already up-to-date INSERT INTO test_setting SELECT generate_series( '2020-01-10 8:00'::timestamp, '2020-01-30 10:00+00'::timestamptz, '1 day'::interval), 10.0; CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 DELETE FROM test_setting WHERE val = 20; --TEST test with multiple settings on continuous aggregates with real time aggregates turned off initially -- -- test for materialized_only + compress combinations (real time aggs enabled initially) DROP MATERIALIZED VIEW test_setting_cagg; NOTICE: drop cascades to table _timescaledb_internal._hyper_40_50_chunk CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; NOTICE: refreshing continuous aggregate "test_setting_cagg" CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | t | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | f --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 21 ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; view_name | compression_enabled | materialized_only -------------------+---------------------+------------------- test_setting_cagg | f | t --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; count ------- 20 -- END TEST with multiple settings -- Test View Target Entries that contain both aggrefs and Vars in the same expression CREATE TABLE transactions ( "time" timestamp with time zone NOT NULL, dummy1 integer, dummy2 integer, dummy3 integer, dummy4 integer, dummy5 integer, amount integer, fiat_value integer ); SELECT create_hypertable('transactions', 'time'); create_hypertable ---------------------------- (44,public,transactions,t) INSERT INTO transactions VALUES ( '2018-01-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:30:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:20:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 10:40:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 11:50:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 12:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 13:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-02 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-02 10:30:00-08', 0, 0, 0, 0, 0, -1, 10); CREATE materialized view cashflows( bucket, amount, cashflow, cashflow2 ) WITH ( timescaledb.continuous, timescaledb.materialized_only = true ) AS SELECT time_bucket ('1 day', time) AS bucket, amount, CASE WHEN amount < 0 THEN (0 - sum(fiat_value)) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) FROM transactions GROUP BY bucket, amount; NOTICE: refreshing continuous aggregate "cashflows" SELECT h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", direct_view_name AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cashflows' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. \d+ "_timescaledb_internal".:"DIRECT_VIEW_NAME" View "_timescaledb_internal._direct_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, "time") AS bucket, amount, CASE WHEN amount < 0 THEN 0 - sum(fiat_value) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, "time")), amount; \d+ "_timescaledb_internal".:"PART_VIEW_NAME" View "_timescaledb_internal._partial_view_45" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT time_bucket('@ 1 day'::interval, "time") AS bucket, amount, CASE WHEN amount < 0 THEN 0 - sum(fiat_value) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) AS cashflow2 FROM transactions GROUP BY (time_bucket('@ 1 day'::interval, "time")), amount; \d+ "_timescaledb_internal".:"MAT_TABLE_NAME" Table "_timescaledb_internal._materialized_hypertable_45" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -----------+--------------------------+-----------+----------+---------+---------+--------------+------------- bucket | timestamp with time zone | | not null | | plain | | amount | integer | | | | plain | | cashflow | bigint | | | | plain | | cashflow2 | bigint | | | | plain | | Indexes: "_materialized_hypertable_45_amount_bucket_idx" btree (amount, bucket DESC) "_materialized_hypertable_45_bucket_idx" btree (bucket DESC) Child tables: _timescaledb_internal._hyper_45_55_chunk, _timescaledb_internal._hyper_45_56_chunk \d+ 'cashflows' View "public.cashflows" Column | Type | Collation | Nullable | Default | Storage | Description -----------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | amount | integer | | | | plain | cashflow | bigint | | | | plain | cashflow2 | bigint | | | | plain | View definition: SELECT bucket, amount, cashflow, cashflow2 FROM _timescaledb_internal._materialized_hypertable_45; SELECT * FROM cashflows ORDER BY cashflows; bucket | amount | cashflow | cashflow2 ------------------------------+--------+----------+----------- Sun Dec 31 16:00:00 2017 UTC | 1 | 10 | 11 Mon Jan 01 16:00:00 2018 UTC | -1 | -30 | 29 Wed Oct 31 16:00:00 2018 UTC | -1 | -20 | 19 Wed Oct 31 16:00:00 2018 UTC | 1 | 30 | 31 Thu Nov 01 16:00:00 2018 UTC | -1 | -10 | 9 Thu Nov 01 16:00:00 2018 UTC | 1 | 10 | 11 -- test cagg creation with named arguments in time_bucket -- note that positional arguments cannot follow named arguments -- 1. test named origin -- 2. test named timezone -- 3. test named ts -- 4. test named bucket width -- named origin CREATE MATERIALIZED VIEW cagg_named_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named timezone CREATE MATERIALIZED VIEW cagg_named_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named ts CREATE MATERIALIZED VIEW cagg_named_ts_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named bucket width CREATE MATERIALIZED VIEW cagg_named_all WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(bucket_width => '1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- Refreshing from the beginning (NULL) of a CAGG with variable time bucket and -- using an INTERVAL for the end timestamp (issue #5534) CREATE MATERIALIZED VIEW transactions_montly WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; -- No rows SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min --------+-----+-----+----- -- Refresh from beginning of the CAGG for 1 month CALL refresh_continuous_aggregate('transactions_montly', NULL, INTERVAL '1 month'); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 TRUNCATE transactions_montly; -- Partial refresh the CAGG from beginning to an specific timestamp CALL refresh_continuous_aggregate('transactions_montly', NULL, '2018-11-01 11:50:00-08'::timestamptz); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 -- Full refresh the CAGG CALL refresh_continuous_aggregate('transactions_montly', NULL, NULL); SELECT * FROM transactions_montly ORDER BY bucket; bucket | sum | max | min ------------------------------+-----+-----+----- Sun Dec 31 16:00:00 2017 UTC | 40 | 10 | 10 Wed Oct 31 16:00:00 2018 UTC | 70 | 10 | 10 -- Check set_chunk_time_interval on continuous aggregate CREATE MATERIALIZED VIEW cagg_set_chunk_time_interval WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; SELECT set_chunk_time_interval('cagg_set_chunk_time_interval', chunk_time_interval => interval '1 month'); set_chunk_time_interval ------------------------- CALL refresh_continuous_aggregate('cagg_set_chunk_time_interval', NULL, NULL); SELECT _timescaledb_functions.to_interval(d.interval_length) = interval '1 month' FROM _timescaledb_catalog.dimension d RIGHT JOIN _timescaledb_catalog.continuous_agg ca ON ca.user_view_name = 'cagg_set_chunk_time_interval' WHERE d.hypertable_id = ca.mat_hypertable_id; ?column? ---------- t -- Since #6077 CAggs are materialized only by default DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'POR', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT location, bucket, avg FROM _timescaledb_internal._materialized_hypertable_53; -- Should return NO ROWS SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+--------+----- ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=false); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT _materialized_hypertable_53.location, _materialized_hypertable_53.bucket, _materialized_hypertable_53.avg FROM _timescaledb_internal._materialized_hypertable_53 WHERE _materialized_hypertable_53.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) UNION ALL SELECT conditions.location, time_bucket('@ 1 day'::interval, conditions."time") AS bucket, avg(conditions.temperature) AS avg FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) GROUP BY conditions.location, (time_bucket('@ 1 day'::interval, conditions."time")); -- Should return ROWS because now it is realtime SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Should return ROWS because we refreshed it ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=true); \d+ conditions_daily View "public.conditions_daily" Column | Type | Collation | Nullable | Default | Storage | Description ----------+--------------------------+-----------+----------+---------+----------+------------- location | text | | | | extended | bucket | timestamp with time zone | | | | plain | avg | double precision | | | | plain | View definition: SELECT location, bucket, avg FROM _timescaledb_internal._materialized_hypertable_53; CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- Test TRUNCATE over a Realtime CAgg DROP MATERIALIZED VIEW conditions_daily; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_daily' \gset -- Check the current watermark for an empty CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_empty_cagg; watermak_empty_cagg --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Refresh the CAGG CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); -- Check the watermark after the refresh and before truncate the CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_before; watermak_before ------------------------------ Fri Nov 02 16:00:00 2018 UTC -- Exists chunks before truncate the cagg (> 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 2 -- Truncate the given CAgg, it should reset the watermark to the empty state TRUNCATE conditions_daily; -- No chunks remains after truncate the cagg (= 0) SELECT count(*) FROM show_chunks('conditions_daily'); count ------- 0 -- Watermark should be reseted SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_after; watermak_after --------------------------------- Sun Nov 23 16:00:00 4714 UTC BC -- Should return ROWS because the watermark was reseted by the TRUNCATE SELECT * FROM conditions_daily ORDER BY bucket, location; location | bucket | avg ----------+------------------------------+----- SFO | Sun Dec 31 16:00:00 2017 UTC | 55 NYC | Mon Jan 01 16:00:00 2018 UTC | 65 POR | Mon Jan 01 16:00:00 2018 UTC | 100 SFO | Mon Jan 01 16:00:00 2018 UTC | 65 NYC | Wed Oct 31 16:00:00 2018 UTC | 65 NYC | Thu Nov 01 16:00:00 2018 UTC | 15 -- check compression settings are cleaned up when deleting a cagg with compression CREATE TABLE cagg_cleanup(time timestamptz not null); SELECT table_name FROM create_hypertable('cagg_cleanup','time'); table_name -------------- cagg_cleanup INSERT INTO cagg_cleanup SELECT '2020-01-01'; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1h',time) FROM cagg_cleanup GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" ALTER MATERIALIZED VIEW cagg1 SET (timescaledb.compress); NOTICE: defaulting compress_orderby to time_bucket SELECT count(compress_chunk(ch)) FROM show_chunks('cagg1') ch; count ------- 1 DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_56_70_chunk SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- -- test WITH namespace alias CREATE TABLE with_alias(time timestamptz not null); CREATE MATERIALIZED VIEW cagg_alias WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; ALTER MATERIALIZED VIEW cagg_alias SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_alias SET (tsdb.materialized_only=false); DROP MATERIALIZED VIEW cagg_alias; -- test SET chunk_time_interval CREATE MATERIALIZED VIEW cagg_set WITH (tsdb.continuous, tsdb.chunk_interval='1day') AS SELECT time_bucket(INTERVAL '1 day', time) AS cagg_interval_setter FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 1 day ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='23 day'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 23 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='6 month'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 180 days ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='1 year'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; column_name | time_interval ----------------------+--------------- cagg_interval_setter | @ 360 days -- test cagg with stable functions CREATE MATERIALIZED VIEW cagg_stable WITH (tsdb.continuous) AS SELECT sum(temperature), max(time + INTERVAL '1h') FROM conditions GROUP BY time_bucket('1week', time), location; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization NOTICE: refreshing continuous aggregate "cagg_stable" SELECT * FROM cagg_stable t ORDER BY t; sum | max -----+------------------------------ 65 | Tue Jan 02 10:10:00 2018 UTC 100 | Tue Jan 02 10:30:00 2018 UTC 120 | Tue Jan 02 10:20:00 2018 UTC 355 | Fri Nov 02 11:30:00 2018 UTC --aggregate without combine function but stable function CREATE MATERIALIZED VIEW cagg_json_agg WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT json_agg(location) from conditions group by time_bucket('1week', time), location WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE FUNCTION test_stablefunc(int) RETURNS int LANGUAGE 'sql' STABLE AS 'SELECT $1 + 10'; CREATE MATERIALIZED VIEW cagg_stable2 WITH (tsdb.continuous) AS SELECT sum(test_stablefunc(temperature::int)), min(location) FROM conditions GROUP BY time_bucket('1week', time) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization CREATE MATERIALIZED VIEW cagg_stable3 WITH (tsdb.continuous) AS SELECT sum(temperature), min(location) FROM conditions GROUP BY time_bucket('1week', time), test_stablefunc(temperature::int) WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- test window functions in caggs -- first do sanity check that we error without the GUC \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_window WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; ERROR: invalid continuous aggregate query \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_window_functions TO on; CREATE MATERIALIZED VIEW cagg_window_1 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_1" CREATE MATERIALIZED VIEW cagg_window_2 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time), location) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_2" CREATE MATERIALIZED VIEW cagg_window_3 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1, location; WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_3" CREATE MATERIALIZED VIEW cagg_window_4 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER w FROM conditions GROUP BY 1, location WINDOW w AS (PARTITION BY time_bucket('1 week',time)); WARNING: window function support is experimental and may result in unexpected results depending on the functions used. NOTICE: refreshing continuous aggregate "cagg_window_4" -- test setting chunk_interval on a cagg CREATE MATERIALIZED VIEW cagg_chunk_interval WITH (tsdb.continuous, tsdb.chunk_interval='1000 day') AS SELECT time_bucket('1 week', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 1000 days ALTER MATERIALIZED VIEW cagg_chunk_interval SET (tsdb.chunk_interval='110 day'); SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; time_interval --------------- @ 110 days -- test columnstore options CREATE MATERIALIZED VIEW columnstore_options WITH (tsdb.continuous, tsdb.chunk_interval='1 day') AS SELECT time_bucket('1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.columnstore, tsdb.chunk_interval='1 day', tsdb.orderby='time_bucket DESC', tsdb.compress_chunk_interval='2 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 172800000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_interval='3 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 259200000000 ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_time_interval='4 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; column_name | compress_interval_length -------------+-------------------------- time_bucket | 345600000000 -- test set returning functions in caggs CREATE TABLE kpis_raw (time TIMESTAMP NOT NULL, value INTEGER, groups TEXT[]) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column INSERT INTO kpis_raw (time, value, groups) VALUES ('2025-01-01', 10, '{group1,group2,group3}'), ('2025-01-02', 20, '{group1,group4}'), ('2025-02-01', 10, '{group1,group3}'), ('2025-02-01', 20, '{group1,group4}'); CREATE MATERIALIZED VIEW kpis_cagg WITH (tsdb.continuous) AS SELECT time_bucket('7 day', time) AS bucket, count(*) AS number_of_records, avg(value) AS average, unnest(groups) AS kpi_group FROM kpis_raw GROUP BY bucket, kpi_group; NOTICE: refreshing continuous aggregate "kpis_cagg" SELECT * FROM kpis_cagg ORDER BY bucket, kpi_group; bucket | number_of_records | average | kpi_group --------------------------+-------------------+---------------------+----------- Mon Dec 30 00:00:00 2024 | 2 | 15.0000000000000000 | group1 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group2 Mon Dec 30 00:00:00 2024 | 1 | 10.0000000000000000 | group3 Mon Dec 30 00:00:00 2024 | 1 | 20.0000000000000000 | group4 Mon Jan 27 00:00:00 2025 | 2 | 15.0000000000000000 | group1 Mon Jan 27 00:00:00 2025 | 1 | 10.0000000000000000 | group3 Mon Jan 27 00:00:00 2025 | 1 | 20.0000000000000000 | group4 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_deprecated_bucket_ng.out����������������������������������0000664�0000000�0000000�00000003507�15100345067�0025275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions( time timestamptz NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'time', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ------------------------- (1,public,conditions,t) -- Ensure no CAgg using time_bucket_ng can be created \set ON_ERROR_STOP 0 -- Regular CAgg CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', time, 'UTC') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: experimental bucket functions are not supported inside a CAgg definition -- CAgg with origin CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', time, '2024-01-16 18:00:00+00') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: experimental bucket functions are not supported inside a CAgg definition -- CAgg with origin and timezone CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', time, '2024-01-16 18:00:00+00', 'UTC') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: experimental bucket functions are not supported inside a CAgg definition \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_drop_chunks.out�������������������������������������������0000664�0000000�0000000�00000027723�15100345067�0023501�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; -- -- Check that drop chunks with a unique constraint works as expected. -- CREATE TABLE clients ( id SERIAL PRIMARY KEY, name TEXT NOT NULL, UNIQUE(name) ); CREATE TABLE records ( time TIMESTAMPTZ NOT NULL, clientId INT NOT NULL REFERENCES clients(id), value DOUBLE PRECISION, UNIQUE(time, clientId) ); SELECT * FROM create_hypertable('records', 'time', chunk_time_interval => INTERVAL '1h'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | records | t CREATE MATERIALIZED VIEW records_monthly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time) as bucket, clientId, avg(value) as value_avg, max(value)-min(value) as value_spread FROM records GROUP BY bucket, clientId WITH NO DATA; INSERT INTO clients(name) VALUES ('test-client'); INSERT INTO records SELECT generate_series('2000-03-01'::timestamptz,'2000-04-01','1 day'),1,3.14; SELECT * FROM records_monthly; bucket | clientid | value_avg | value_spread ------------------------------+----------+-----------+-------------- Mon Mar 27 16:00:00 2000 PST | 1 | 3.14 | 0 Fri Mar 10 16:00:00 2000 PST | 1 | 3.14 | 0 Tue Mar 07 16:00:00 2000 PST | 1 | 3.14 | 0 Fri Mar 24 16:00:00 2000 PST | 1 | 3.14 | 0 Sun Mar 19 16:00:00 2000 PST | 1 | 3.14 | 0 Wed Mar 29 16:00:00 2000 PST | 1 | 3.14 | 0 Wed Mar 15 16:00:00 2000 PST | 1 | 3.14 | 0 Fri Mar 31 16:00:00 2000 PST | 1 | 3.14 | 0 Mon Mar 20 16:00:00 2000 PST | 1 | 3.14 | 0 Thu Mar 30 16:00:00 2000 PST | 1 | 3.14 | 0 Sat Mar 11 16:00:00 2000 PST | 1 | 3.14 | 0 Mon Mar 13 16:00:00 2000 PST | 1 | 3.14 | 0 Sun Mar 12 16:00:00 2000 PST | 1 | 3.14 | 0 Tue Mar 28 16:00:00 2000 PST | 1 | 3.14 | 0 Sun Mar 26 16:00:00 2000 PST | 1 | 3.14 | 0 Wed Mar 22 16:00:00 2000 PST | 1 | 3.14 | 0 Thu Mar 16 16:00:00 2000 PST | 1 | 3.14 | 0 Sat Mar 25 16:00:00 2000 PST | 1 | 3.14 | 0 Thu Mar 23 16:00:00 2000 PST | 1 | 3.14 | 0 Thu Mar 02 16:00:00 2000 PST | 1 | 3.14 | 0 Sat Mar 18 16:00:00 2000 PST | 1 | 3.14 | 0 Mon Mar 06 16:00:00 2000 PST | 1 | 3.14 | 0 Tue Feb 29 16:00:00 2000 PST | 1 | 3.14 | 0 Fri Mar 17 16:00:00 2000 PST | 1 | 3.14 | 0 Tue Mar 14 16:00:00 2000 PST | 1 | 3.14 | 0 Wed Mar 08 16:00:00 2000 PST | 1 | 3.14 | 0 Sat Mar 04 16:00:00 2000 PST | 1 | 3.14 | 0 Sun Mar 05 16:00:00 2000 PST | 1 | 3.14 | 0 Tue Mar 21 16:00:00 2000 PST | 1 | 3.14 | 0 Wed Mar 01 16:00:00 2000 PST | 1 | 3.14 | 0 Thu Mar 09 16:00:00 2000 PST | 1 | 3.14 | 0 Fri Mar 03 16:00:00 2000 PST | 1 | 3.14 | 0 SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'records_monthly' ORDER BY range_start; chunk_name | range_start | range_end ------------+-------------+----------- SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'records' ORDER BY range_start; chunk_name | range_start | range_end -------------------+------------------------------+------------------------------ _hyper_1_1_chunk | Wed Mar 01 00:00:00 2000 PST | Wed Mar 01 01:00:00 2000 PST _hyper_1_2_chunk | Thu Mar 02 00:00:00 2000 PST | Thu Mar 02 01:00:00 2000 PST _hyper_1_3_chunk | Fri Mar 03 00:00:00 2000 PST | Fri Mar 03 01:00:00 2000 PST _hyper_1_4_chunk | Sat Mar 04 00:00:00 2000 PST | Sat Mar 04 01:00:00 2000 PST _hyper_1_5_chunk | Sun Mar 05 00:00:00 2000 PST | Sun Mar 05 01:00:00 2000 PST _hyper_1_6_chunk | Mon Mar 06 00:00:00 2000 PST | Mon Mar 06 01:00:00 2000 PST _hyper_1_7_chunk | Tue Mar 07 00:00:00 2000 PST | Tue Mar 07 01:00:00 2000 PST _hyper_1_8_chunk | Wed Mar 08 00:00:00 2000 PST | Wed Mar 08 01:00:00 2000 PST _hyper_1_9_chunk | Thu Mar 09 00:00:00 2000 PST | Thu Mar 09 01:00:00 2000 PST _hyper_1_10_chunk | Fri Mar 10 00:00:00 2000 PST | Fri Mar 10 01:00:00 2000 PST _hyper_1_11_chunk | Sat Mar 11 00:00:00 2000 PST | Sat Mar 11 01:00:00 2000 PST _hyper_1_12_chunk | Sun Mar 12 00:00:00 2000 PST | Sun Mar 12 01:00:00 2000 PST _hyper_1_13_chunk | Mon Mar 13 00:00:00 2000 PST | Mon Mar 13 01:00:00 2000 PST _hyper_1_14_chunk | Tue Mar 14 00:00:00 2000 PST | Tue Mar 14 01:00:00 2000 PST _hyper_1_15_chunk | Wed Mar 15 00:00:00 2000 PST | Wed Mar 15 01:00:00 2000 PST _hyper_1_16_chunk | Thu Mar 16 00:00:00 2000 PST | Thu Mar 16 01:00:00 2000 PST _hyper_1_17_chunk | Fri Mar 17 00:00:00 2000 PST | Fri Mar 17 01:00:00 2000 PST _hyper_1_18_chunk | Sat Mar 18 00:00:00 2000 PST | Sat Mar 18 01:00:00 2000 PST _hyper_1_19_chunk | Sun Mar 19 00:00:00 2000 PST | Sun Mar 19 01:00:00 2000 PST _hyper_1_20_chunk | Mon Mar 20 00:00:00 2000 PST | Mon Mar 20 01:00:00 2000 PST _hyper_1_21_chunk | Tue Mar 21 00:00:00 2000 PST | Tue Mar 21 01:00:00 2000 PST _hyper_1_22_chunk | Wed Mar 22 00:00:00 2000 PST | Wed Mar 22 01:00:00 2000 PST _hyper_1_23_chunk | Thu Mar 23 00:00:00 2000 PST | Thu Mar 23 01:00:00 2000 PST _hyper_1_24_chunk | Fri Mar 24 00:00:00 2000 PST | Fri Mar 24 01:00:00 2000 PST _hyper_1_25_chunk | Sat Mar 25 00:00:00 2000 PST | Sat Mar 25 01:00:00 2000 PST _hyper_1_26_chunk | Sun Mar 26 00:00:00 2000 PST | Sun Mar 26 01:00:00 2000 PST _hyper_1_27_chunk | Mon Mar 27 00:00:00 2000 PST | Mon Mar 27 01:00:00 2000 PST _hyper_1_28_chunk | Tue Mar 28 00:00:00 2000 PST | Tue Mar 28 01:00:00 2000 PST _hyper_1_29_chunk | Wed Mar 29 00:00:00 2000 PST | Wed Mar 29 01:00:00 2000 PST _hyper_1_30_chunk | Thu Mar 30 00:00:00 2000 PST | Thu Mar 30 01:00:00 2000 PST _hyper_1_31_chunk | Fri Mar 31 00:00:00 2000 PST | Fri Mar 31 01:00:00 2000 PST _hyper_1_32_chunk | Sat Apr 01 00:00:00 2000 PST | Sat Apr 01 01:00:00 2000 PST CALL refresh_continuous_aggregate('records_monthly', NULL, NULL); \set VERBOSITY default SELECT drop_chunks('records', '2000-03-16'::timestamptz); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_9_chunk _timescaledb_internal._hyper_1_10_chunk _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk _timescaledb_internal._hyper_1_14_chunk _timescaledb_internal._hyper_1_15_chunk \set VERBOSITY terse DROP MATERIALIZED VIEW records_monthly; NOTICE: drop cascades to 32 other objects DROP TABLE records; DROP TABLE clients; \set VERBOSITY default CREATE PROCEDURE refresh_cagg_by_chunk_range(_cagg REGCLASS, _hypertable REGCLASS, _older_than INTEGER) AS $$ DECLARE _r RECORD; BEGIN WITH _chunks AS ( SELECT relname, nspname FROM show_chunks(_hypertable, _older_than) AS relid JOIN pg_catalog.pg_class ON pg_class.oid = relid AND pg_class.relkind = 'r' JOIN pg_catalog.pg_namespace ON pg_namespace.oid = pg_class.relnamespace ) SELECT MIN(range_start) AS range_start, MAX(range_end) AS range_end INTO _r FROM _chunks JOIN _timescaledb_catalog.chunk ON chunk.schema_name = _chunks.nspname AND chunk.table_name = _chunks.relname JOIN _timescaledb_catalog.chunk_constraint ON chunk_id = chunk.id JOIN _timescaledb_catalog.dimension_slice ON dimension_slice.id = dimension_slice_id; RAISE INFO 'range_start=% range_end=%', _r.range_start::int, _r.range_end::int; CALL refresh_continuous_aggregate(_cagg, _r.range_start::int, _r.range_end::int + 1); END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION test_int_now() returns INT LANGUAGE SQL STABLE as $$ SELECT 125 $$; CREATE TABLE conditions(time_int INT NOT NULL, value FLOAT); SELECT create_hypertable('conditions', 'time_int', chunk_time_interval => 4); create_hypertable ------------------------- (3,public,conditions,t) INSERT INTO conditions SELECT time_val, 1 FROM generate_series(0, 19, 1) AS time_val; SELECT set_integer_now_func('conditions', 'test_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW conditions_2 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(2, time_int) as bucket, SUM(value), COUNT(value) FROM conditions GROUP BY bucket WITH DATA; NOTICE: refreshing continuous aggregate "conditions_2" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM conditions_2 ORDER BY bucket; bucket | sum | count --------+-----+------- 0 | 2 | 2 2 | 2 | 2 4 | 2 | 2 6 | 2 | 2 8 | 2 | 2 10 | 2 | 2 12 | 2 | 2 14 | 2 | 2 16 | 2 | 2 18 | 2 | 2 UPDATE conditions SET value = 4.00 WHERE time_int = 0; UPDATE conditions SET value = 4.00 WHERE time_int = 6; CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', 4); INFO: range_start=0 range_end=4 SELECT drop_chunks('conditions', 4); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_3_65_chunk SELECT * FROM conditions_2 ORDER BY bucket; bucket | sum | count --------+-----+------- 0 | 5 | 2 2 | 2 | 2 4 | 2 | 2 6 | 2 | 2 8 | 2 | 2 10 | 2 | 2 12 | 2 | 2 14 | 2 | 2 16 | 2 | 2 18 | 2 | 2 CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', 8); INFO: range_start=4 range_end=8 SELECT * FROM conditions_2 ORDER BY bucket; bucket | sum | count --------+-----+------- 0 | 5 | 2 2 | 2 | 2 4 | 2 | 2 6 | 5 | 2 8 | 2 | 2 10 | 2 | 2 12 | 2 | 2 14 | 2 | 2 16 | 2 | 2 18 | 2 | 2 UPDATE conditions SET value = 4.00 WHERE time_int = 19; SELECT drop_chunks('conditions', 8); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_3_66_chunk CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', 12); INFO: range_start=8 range_end=12 SELECT * FROM conditions_2 ORDER BY bucket; bucket | sum | count --------+-----+------- 0 | 5 | 2 2 | 2 | 2 4 | 2 | 2 6 | 5 | 2 8 | 2 | 2 10 | 2 | 2 12 | 2 | 2 14 | 2 | 2 16 | 2 | 2 18 | 2 | 2 CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', NULL); INFO: range_start=8 range_end=20 SELECT * FROM conditions_2 ORDER BY bucket; bucket | sum | count --------+-----+------- 0 | 5 | 2 2 | 2 | 2 4 | 2 | 2 6 | 5 | 2 8 | 2 | 2 10 | 2 | 2 12 | 2 | 2 14 | 2 | 2 16 | 2 | 2 18 | 5 | 2 DROP PROCEDURE refresh_cagg_by_chunk_range(REGCLASS, REGCLASS, INTEGER); ���������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_dump.out��������������������������������������������������0000664�0000000�0000000�00000014570�15100345067�0022123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; CREATE TYPE custom_type AS (high int, low int); CREATE TABLE conditions_before ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null, highlow custom_type null, bit_int smallint, good_life boolean ); SELECT table_name FROM create_hypertable( 'conditions_before', 'timec'); table_name ------------------- conditions_before INSERT INTO conditions_before SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO conditions_before SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO conditions_before SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL, NULL, 8, true; CREATE TABLE conditions_after (like conditions_before including all); SELECT table_name FROM create_hypertable( 'conditions_after', 'timec'); table_name ------------------ conditions_after INSERT INTO conditions_after SELECT * FROM conditions_before; SELECT $$ SELECT time_bucket('1week', timec) as bucket, location, min(allnull) as min_allnull, max(temperature) as max_temp, sum(temperature)+sum(humidity) as agg_sum_expr, avg(humidity), stddev(humidity), bit_and(bit_int), bit_or(bit_int), bool_and(good_life), every(temperature > 0), bool_or(good_life), count(*) as count_rows, count(temperature) as count_temp, count(allnull) as count_zero, corr(temperature, humidity), covar_pop(temperature, humidity), covar_samp(temperature, humidity), regr_avgx(temperature, humidity), regr_avgy(temperature, humidity), regr_count(temperature, humidity), regr_intercept(temperature, humidity), regr_r2(temperature, humidity), regr_slope(temperature, humidity), regr_sxx(temperature, humidity), regr_sxy(temperature, humidity), regr_syy(temperature, humidity), stddev(temperature) as stddev_temp, stddev_pop(temperature), stddev_samp(temperature), variance(temperature), var_pop(temperature), var_samp(temperature), last(temperature, timec) as last_temp, last(highlow, timec) as last_hl, first(highlow, timec) as first_hl, histogram(temperature, 0, 100, 5) FROM TABLE GROUP BY bucket, location HAVING min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY_TEMPLATE" \gset SELECT replace(:'QUERY_TEMPLATE', 'TABLE', 'conditions_before') AS "QUERY_BEFORE", replace(:'QUERY_TEMPLATE', 'TABLE', 'conditions_after') AS "QUERY_AFTER" \gset DROP MATERIALIZED VIEW IF EXISTS mat_test; NOTICE: materialized view "mat_test" does not exist, skipping --materialize this VIEW before dump this tests --that the partial state survives the dump intact CREATE MATERIALIZED VIEW mat_before WITH (timescaledb.continuous) AS :QUERY_BEFORE WITH NO DATA; --materialize this VIEW after dump this tests --that the partialize VIEW and refresh mechanics --survives the dump intact CREATE MATERIALIZED VIEW mat_after WITH (timescaledb.continuous) AS :QUERY_AFTER WITH NO DATA; --materialize mat_before SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_before', NULL, NULL); SELECT count(*) FROM conditions_before; count ------- 137 SELECT count(*) FROM conditions_after; count ------- 137 SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_VIEW_name as "PART_VIEW_NAME", partial_VIEW_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_VIEW_name = 'mat_before' \gset SELECT count(*) FROM conditions_before; count ------- 137 SELECT count(*) FROM conditions_after; count ------- 137 --dump & restore \c postgres :ROLE_SUPERUSER \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; --\! cp dump/pg_dump.sql /tmp/dump.sql SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; --make sure the appropriate DROP are still blocked. \set ON_ERROR_STOP 0 DROP table :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; ERROR: cannot drop table _timescaledb_internal._materialized_hypertable_3 because other objects depend on it DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate \set ON_ERROR_STOP 1 --materialize mat_after CALL refresh_continuous_aggregate('mat_after', NULL, NULL); SELECT count(*) FROM mat_after; count ------- 16 --compare results SELECT count(*) FROM conditions_before; count ------- 137 SELECT count(*) FROM conditions_after; count ------- 137 \set VIEW_NAME mat_before \set QUERY :QUERY_BEFORE \set ECHO errors description | view_name | count ---------------------------------------------------------------+------------+------- Number of rows different between view and original (expect 0) | mat_before | 0 \set VIEW_NAME mat_after \set QUERY :QUERY_AFTER \set ECHO errors description | view_name | count ---------------------------------------------------------------+-----------+------- Number of rows different between view and original (expect 0) | mat_after | 0 DROP MATERIALIZED VIEW mat_after; NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW mat_before; NOTICE: drop cascades to 2 other objects ����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_errors.out������������������������������������������������0000664�0000000�0000000�00000066713�15100345067�0022500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 \set VERBOSITY default SET timezone TO PST8PDT; --negative tests for query validation create table mat_t1( a integer, b integer,c TEXT); CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.myfill = 1) as select location , min(temperature) from conditions group by time_bucket('1d', timec), location WITH NO DATA; ERROR: unrecognized parameter "timescaledb.myfill" HINT: Valid timescaledb parameters are: continuous, create_group_indexes, materialized_only, columnstore, finalized, chunk_interval, segmentby, orderby, compress_chunk_interval --valid PG option CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false, check_option = LOCAL ) as select * from conditions , mat_t1 WITH NO DATA; ERROR: unsupported combination of storage parameters DETAIL: A continuous aggregate does not support standard storage parameters. HINT: Use only parameters with the "timescaledb." prefix when creating a continuous aggregate. --non-hypertable CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select a, count(*) from mat_t1 group by a WITH NO DATA; ERROR: invalid continuous aggregate view DETAIL: At least one hypertable should be used in the view definition. -- no group by CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select count(*) from conditions WITH NO DATA; ERROR: invalid continuous aggregate query HINT: Include at least one aggregate function and a GROUP BY clause with time bucket. -- no time_bucket in group by CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select count(*) from conditions group by location WITH NO DATA; ERROR: continuous aggregate view must include a valid time bucket function -- with valid query in a CTE CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS with m1 as ( Select location, count(*) from conditions group by time_bucket('1week', timec) , location) select * from m1 WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: CTEs and subqueries are not supported by continuous aggregates. --with DISTINCT ON CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select distinct on ( location ) count(*) from conditions group by location, time_bucket('1week', timec) WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: DISTINCT / DISTINCT ON queries are not supported by continuous aggregates. -- time_bucket on non partitioning column of hypertable CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket('1week', timemeasure) , location WITH NO DATA; ERROR: time bucket function must reference the primary hypertable dimension column --time_bucket on expression CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket('1week', timec+ '10 minutes'::interval) , location WITH NO DATA; ERROR: time bucket function must reference the primary hypertable dimension column --multiple time_bucket functions CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket('1week', timec) , time_bucket('1month', timec), location WITH NO DATA; ERROR: continuous aggregate view cannot contain multiple time bucket functions --time_bucket using non-const for first argument CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket( timeinterval, timec) , location WITH NO DATA; ERROR: only immutable expressions allowed in time bucket function HINT: Use an immutable expression as first argument to the time bucket function. --window function CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select avg(temperature) over( order by humidity) from conditions WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: Window function support not enabled. HINT: Enable experimental window function support by setting timescaledb.enable_cagg_window_functions. -- using subqueries CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from ( select humidity, temperature, location, timec from conditions ) q group by time_bucket('1week', timec) , location WITH NO DATA; ERROR: invalid continuous aggregate view DETAIL: Sub-queries are not supported in FROM clause. CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS select * from ( Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location ) q WITH NO DATA; ERROR: invalid continuous aggregate query HINT: Include at least one aggregate function and a GROUP BY clause with time bucket. --using limit /limit offset CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location limit 10 WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: LIMIT and LIMIT OFFSET are not supported in queries defining continuous aggregates. HINT: Use LIMIT and LIMIT OFFSET in SELECTS from the continuous aggregate view instead. CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location offset 10 WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: LIMIT and LIMIT OFFSET are not supported in queries defining continuous aggregates. HINT: Use LIMIT and LIMIT OFFSET in SELECTS from the continuous aggregate view instead. --using FETCH CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location fetch first 10 rows only WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: LIMIT and LIMIT OFFSET are not supported in queries defining continuous aggregates. HINT: Use LIMIT and LIMIT OFFSET in SELECTS from the continuous aggregate view instead. --using locking clauses FOR clause --all should be disabled. we cannot guarntee locks on the hypertable CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR KEY SHARE WITH NO DATA; ERROR: FOR KEY SHARE is not allowed with GROUP BY clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR SHARE WITH NO DATA; ERROR: FOR SHARE is not allowed with GROUP BY clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR UPDATE WITH NO DATA; ERROR: FOR UPDATE is not allowed with GROUP BY clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR NO KEY UPDATE WITH NO DATA; ERROR: FOR NO KEY UPDATE is not allowed with GROUP BY clause --tablesample clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions tablesample bernoulli(0.2) group by time_bucket('1week', timec) , location WITH NO DATA; ERROR: invalid continuous aggregate view DETAIL: TABLESAMPLE is not supported in continuous aggregate. -- ONLY in from clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from ONLY conditions group by time_bucket('1week', timec) , location WITH NO DATA; ERROR: invalid continuous aggregate view DETAIL: FROM ONLY on hypertables is not allowed in continuous aggregate. --grouping sets and variants CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by grouping sets(time_bucket('1week', timec) , location ) WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: GROUP BY GROUPING SETS, ROLLUP and CUBE are not supported by continuous aggregates HINT: Define multiple continuous aggregates with different grouping levels. CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by rollup(time_bucket('1week', timec) , location ) WITH NO DATA; ERROR: invalid continuous aggregate query DETAIL: GROUP BY GROUPING SETS, ROLLUP and CUBE are not supported by continuous aggregates HINT: Define multiple continuous aggregates with different grouping levels. -- Should use CREATE MATERIALIZED VIEW to create continuous aggregates CREATE VIEW continuous_aggs_errors_tbl1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 week', timec) FROM conditions GROUP BY time_bucket('1 week', timec); ERROR: cannot create continuous aggregate with CREATE VIEW HINT: Use CREATE MATERIALIZED VIEW to create a continuous aggregate. -- invalid `bucket_width` for `time_bucket` function CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(NULL, timec), sum(temperature), min(location) FROM conditions GROUP BY 1 WITH NO DATA; ERROR: invalid bucket width for time bucket function -- row security on table create table rowsec_tab( a bigint, b integer, c integer); select table_name from create_hypertable( 'rowsec_tab', 'a', chunk_time_interval=>10); table_name ------------ rowsec_tab CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0)::bigint FROM rowsec_tab $$; SELECT set_integer_now_func('rowsec_tab', 'integer_now_test'); set_integer_now_func ---------------------- alter table rowsec_tab ENABLE ROW LEVEL SECURITY; create policy rowsec_tab_allview ON rowsec_tab FOR SELECT USING(true); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum( b), min(c) from rowsec_tab group by time_bucket('1', a) WITH NO DATA; ERROR: cannot create continuous aggregate on hypertable with row security drop table conditions cascade; --negative tests for WITH options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test' \gset \set ON_ERROR_STOP 0 -- triggers not allowed on continuous aggregate CREATE OR REPLACE FUNCTION not_allowed() RETURNS trigger AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER not_allowed_trigger INSTEAD OF INSERT ON mat_with_test FOR EACH ROW EXECUTE FUNCTION not_allowed(); ERROR: triggers are not supported on continuous aggregate ALTER MATERIALIZED VIEW mat_with_test SET(timescaledb.create_group_indexes = 'false'); ERROR: cannot alter create_group_indexes option for continuous aggregates ALTER MATERIALIZED VIEW mat_with_test SET(timescaledb.create_group_indexes = 'true'); ERROR: cannot alter create_group_indexes option for continuous aggregates ALTER MATERIALIZED VIEW mat_with_test ALTER timec DROP default; ERROR: cannot alter only SET options of a continuous aggregate \set ON_ERROR_STOP 1 \set VERBOSITY terse DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec SMALLINT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_test_s() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0)::smallint FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test_s'); set_integer_now_func ---------------------- \set ON_ERROR_STOP 0 create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; ERROR: time bucket function must reference the primary hypertable dimension column create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; ERROR: time bucket function must reference the primary hypertable dimension column ALTER TABLE conditions ALTER timec type int; create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; \set ON_ERROR_STOP 1 DROP TABLE conditions cascade; NOTICE: drop cascades to 3 other objects CREATE TABLE conditions ( timec BIGINT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_test_b() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0)::bigint FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test_b'); set_integer_now_func ---------------------- create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(BIGINT '100', timec), min(location), sum(temperature),sum(humidity) from conditions group by 1 WITH NO DATA; -- custom time partition functions are not supported with invalidations CREATE FUNCTION text_part_func(TEXT) RETURNS BIGINT AS $$ SELECT length($1)::BIGINT $$ LANGUAGE SQL IMMUTABLE; CREATE TABLE text_time(time TEXT); SELECT create_hypertable('text_time', 'time', chunk_time_interval => 10, time_partitioning_func => 'text_part_func'); create_hypertable ------------------------ (9,public,text_time,t) \set VERBOSITY default \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW text_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', text_part_func(time)), COUNT(time) FROM text_time GROUP BY 1 WITH NO DATA; ERROR: custom partitioning functions not supported with continuous aggregates \set ON_ERROR_STOP 1 -- Check that we get an error when mixing normal materialized views -- and continuous aggregates. CREATE MATERIALIZED VIEW normal_mat_view AS SELECT time_bucket('5', text_part_func(time)), COUNT(time) FROM text_time GROUP BY 1 WITH NO DATA; \set VERBOSITY terse \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW normal_mat_view, mat_with_test; ERROR: mixing continuous aggregates and other objects not allowed \set ON_ERROR_STOP 1 DROP TABLE text_time CASCADE; NOTICE: drop cascades to materialized view normal_mat_view CREATE TABLE measurements (time TIMESTAMPTZ NOT NULL, device INT, value FLOAT); SELECT create_hypertable('measurements', 'time'); create_hypertable ---------------------------- (10,public,measurements,t) INSERT INTO measurements VALUES ('2019-03-04 13:30', 1, 1.3); -- Add a continuous aggregate on the measurements table and a policy -- to be able to test error cases for the add_job function. CREATE MATERIALIZED VIEW measurements_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time), COUNT(time) FROM measurements GROUP BY 1 WITH NO DATA; -- First test that add_job checks the config. It is currently possible -- to add non-custom jobs using the add_job function so we need to -- test that the function actually checks the config parameters. These -- should all generate errors, for different reasons... \set ON_ERROR_STOP 0 -- ... this one because it is missing a field. SELECT add_job( '_timescaledb_functions.policy_refresh_continuous_aggregate'::regproc, '1 hour'::interval, check_config => '_timescaledb_functions.policy_refresh_continuous_aggregate_check'::regproc, config => '{"end_offset": null, "start_offset": null}'); ERROR: could not find "mat_hypertable_id" in config for job -- ... this one because it has a bad value for start_offset SELECT add_job( '_timescaledb_functions.policy_refresh_continuous_aggregate'::regproc, '1 hour'::interval, check_config => '_timescaledb_functions.policy_refresh_continuous_aggregate_check'::regproc, config => '{"end_offset": null, "start_offset": "1 fortnight", "mat_hypertable_id": 11}'); ERROR: invalid input syntax for type interval: "1 fortnight" -- ... this one because it has a bad value for end_offset SELECT add_job( '_timescaledb_functions.policy_refresh_continuous_aggregate'::regproc, '1 hour'::interval, check_config => '_timescaledb_functions.policy_refresh_continuous_aggregate_check'::regproc, config => '{"end_offset": "chicken", "start_offset": null, "mat_hypertable_id": 11}'); ERROR: invalid input syntax for type interval: "chicken" \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('measurements_summary', NULL, NULL, '1 h'::interval) AS job_id \gset \x on SELECT * FROM _timescaledb_config.bgw_job WHERE id = :job_id; -[ RECORD 1 ]-----+-------------------------------------------------------------------- id | 1000 application_name | Refresh Continuous Aggregate Policy [1000] schedule_interval | @ 1 hour max_runtime | @ 0 max_retries | -1 retry_period | @ 1 hour proc_schema | _timescaledb_functions proc_name | policy_refresh_continuous_aggregate owner | default_perm_user scheduled | t fixed_schedule | f initial_start | hypertable_id | 11 config | {"end_offset": null, "start_offset": null, "mat_hypertable_id": 11} check_schema | _timescaledb_functions check_name | policy_refresh_continuous_aggregate_check timezone | \x off -- These are all weird values for the parameters for the continuous -- aggregate jobs and should generate an error. Since the config will -- be replaced, we will also generate error for missing arguments. \set ON_ERROR_STOP 0 SELECT alter_job(:job_id, config => '{"end_offset": "1 week", "start_offset": "2 fortnights"}'); ERROR: could not find "mat_hypertable_id" in config for job SELECT alter_job(:job_id, config => '{"mat_hypertable_id": 11, "end_offset": "chicken", "start_offset": "1 fortnights"}'); ERROR: invalid input syntax for type interval: "1 fortnights" SELECT alter_job(:job_id, config => '{"mat_hypertable_id": 11, "end_offset": "chicken", "start_offset": "1 week"}'); ERROR: invalid input syntax for type interval: "chicken" \set ON_ERROR_STOP 1 DROP TABLE measurements CASCADE; NOTICE: drop cascades to 3 other objects DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects -- test handling of invalid mat_hypertable_id create table i2980(time timestamptz not null); select create_hypertable('i2980','time'); create_hypertable --------------------- (12,public,i2980,t) create materialized view i2980_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(7) FROM i2980 GROUP BY 1; NOTICE: continuous aggregate "i2980_cagg" is already up-to-date select add_continuous_aggregate_policy('i2980_cagg',NULL,NULL,'4h') AS job_id \gset \set ON_ERROR_STOP 0 select alter_job(:job_id,config:='{"end_offset": null, "start_offset": null, "mat_hypertable_id": 1000}'); ERROR: invalid materialized hypertable ID: 1000 --test creating continuous aggregate with compression enabled -- CREATE MATERIALIZED VIEW i2980_cagg2 with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.compress) AS SELECT time_bucket('1h',time), avg(7) FROM i2980 GROUP BY 1; ERROR: cannot enable compression while creating a continuous aggregate --this one succeeds CREATE MATERIALIZED VIEW i2980_cagg2 with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time) as bucket, avg(7) FROM i2980 GROUP BY 1; NOTICE: continuous aggregate "i2980_cagg2" is already up-to-date --now enable compression with invalid parameters ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'bucket'); NOTICE: defaulting compress_orderby to bucket ERROR: cannot use column "bucket" for both ordering and segmenting ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress, timescaledb.compress_orderby = 'bucket'); --enable compression and test re-enabling compression ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress); NOTICE: defaulting compress_orderby to bucket insert into i2980 select now(); call refresh_continuous_aggregate('i2980_cagg2', NULL, NULL); SELECT compress_chunk(ch) FROM show_chunks('i2980_cagg2') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_14_3_chunk ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress = 'false'); ERROR: cannot disable columnstore on hypertable with columnstore chunks ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress = 'true'); NOTICE: defaulting compress_orderby to bucket ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'bucket'); NOTICE: defaulting compress_orderby to bucket ERROR: cannot use column "bucket" for both ordering and segmenting --Errors with compression policy on caggs-- select add_continuous_aggregate_policy('i2980_cagg2', interval '10 day', interval '2 day' ,'4h') AS job_id ; job_id -------- 1002 SELECT add_compression_policy('i2980_cagg', '8 day'::interval); ERROR: columnstore not enabled on continuous aggregate "i2980_cagg" ALTER MATERIALIZED VIEW i2980_cagg SET ( timescaledb.compress ); NOTICE: defaulting compress_orderby to time_bucket SELECT add_continuous_aggregate_policy('i2980_cagg2', '10 day'::interval, '6 day'::interval); ERROR: function add_continuous_aggregate_policy(unknown, interval, interval) does not exist at character 8 SELECT add_compression_policy('i2980_cagg2', '3'::integer); ERROR: unsupported compress_after argument type, expected type : interval SELECT add_compression_policy('i2980_cagg2', 13::integer); ERROR: unsupported compress_after argument type, expected type : interval SELECT materialization_hypertable_schema || '.' || materialization_hypertable_name AS "MAT_TABLE_NAME" FROM timescaledb_information.continuous_aggregates WHERE view_name = 'i2980_cagg2' \gset SELECT add_compression_policy( :'MAT_TABLE_NAME', 13::integer); ERROR: cannot add compression policy to materialized hypertable "_materialized_hypertable_14" --TEST compressing cagg chunks without enabling compression SELECT count(*) FROM (select decompress_chunk(ch) FROM show_chunks('i2980_cagg2') ch ) q; count ------- 1 ALTER MATERIALIZED VIEW i2980_cagg2 SET (timescaledb.compress = 'false'); SELECT compress_chunk(ch) FROM show_chunks('i2980_cagg2') ch; ERROR: columnstore not enabled on "i2980_cagg2" -- test error handling when trying to create cagg on internal hypertable CREATE TABLE comp_ht_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('comp_ht_test','time'); table_name -------------- comp_ht_test ALTER TABLE comp_ht_test SET (timescaledb.compress); SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "INTERNALTABLE" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'comp_ht_test') \gset CREATE MATERIALIZED VIEW cagg1 WITH(timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',now()) FROM :INTERNALTABLE GROUP BY 1; ERROR: hypertable is an internal compressed hypertable --TEST ht + cagg, do not enable compression on ht and try to compress chunk on ht. --Check error handling for this case SELECT compress_chunk(ch) FROM show_chunks('i2980') ch; ERROR: columnstore not enabled on "i2980" -- cagg on normal view should error out CREATE VIEW v1 AS SELECT now() AS time; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time) FROM v1 GROUP BY 1; ERROR: invalid continuous aggregate view -- cagg on normal view should error out CREATE MATERIALIZED VIEW matv1 AS SELECT now() AS time; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time) FROM matv1 GROUP BY 1; ERROR: invalid continuous aggregate view -- No FROM clause in CAGG definition CREATE MATERIALIZED VIEW cagg1 with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT 1 GROUP BY 1 WITH NO DATA; ERROR: invalid continuous aggregate query �����������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_invalidation.out������������������������������������������0000664�0000000�0000000�00000133612�15100345067�0023636�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Disable background workers since we are testing manual refresh \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SET ROLE :ROLE_DEFAULT_PERM_USER; SET datestyle TO 'ISO, YMD'; SET timezone TO 'UTC'; CREATE VIEW hypertable_invalidation_thresholds AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1; CREATE TABLE conditions (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 10); create_hypertable ------------------------- (1,public,conditions,t) CREATE TABLE measurements (time int NOT NULL, device int, temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (2,public,measurements,t) CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM measurements $$; SELECT set_integer_now_func('conditions', 'bigint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('measurements', 'int_now'); set_integer_now_func ---------------------- INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE TABLE temp AS SELECT * FROM conditions; INSERT INTO measurements SELECT * FROM temp; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; time | device | temp ------+--------+------ 100 | 0 | 8 99 | 1 | 5 98 | 2 | 26 97 | 2 | 10 96 | 2 | 34 95 | 2 | 30 94 | 3 | 31 93 | 0 | 4 92 | 0 | 32 91 | 3 | 15 -- Create two continuous aggregates on the same hypertable to test -- that invalidations are handled correctly across both of them. CREATE MATERIALIZED VIEW cond_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '10', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW cond_20 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW measure_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, device, avg(temp) AS avg_temp FROM measurements GROUP BY 1,2 WITH NO DATA; -- There should be three continuous aggregates, two on one hypertable -- and one on the other: SELECT mat_hypertable_id, raw_hypertable_id, user_view_name FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | raw_hypertable_id | user_view_name -------------------+-------------------+---------------- 3 | 1 | cond_10 4 | 1 | cond_20 5 | 2 | measure_10 -- The continuous aggregates should be empty SELECT * FROM cond_10 ORDER BY 1 DESC, 2; bucket | device | avg_temp --------+--------+---------- SELECT * FROM cond_20 ORDER BY 1 DESC, 2; bucket | device | avg_temp --------+--------+---------- SELECT * FROM measure_10 ORDER BY 1 DESC, 2; bucket | device | avg_temp --------+--------+---------- CREATE OR REPLACE FUNCTION get_hyper_invals() RETURNS TABLE ( "hyper_id" INT, "start" BIGINT, "end" BIGINT ) LANGUAGE SQL VOLATILE AS $$ SELECT hypertable_id, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log ORDER BY 1,2,3 $$; CREATE OR REPLACE FUNCTION get_cagg_invals() RETURNS TABLE ( "cagg_id" INT, "start" BIGINT, "end" BIGINT ) LANGUAGE SQL VOLATILE AS $$ SELECT materialization_id, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1,2,3 $$; CREATE VIEW hyper_invals AS SELECT * FROM get_hyper_invals(); CREATE VIEW cagg_invals AS SELECT * FROM get_cagg_invals(); -- Must refresh to move the invalidation threshold, or no -- invalidations will be generated. Initially, threshold is the -- MIN of the time dimension data type: SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; hypertable_id | watermark ---------------+---------------------- 1 | -9223372036854775808 2 | -2147483648 -- There should be only "infinite" invalidations in the cagg -- invalidation log: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | 9223372036854775807 4 | -9223372036854775808 | 9223372036854775807 5 | -9223372036854775808 | 9223372036854775807 -- Now refresh up to 50 without the first bucket, and the threshold should be updated accordingly: CALL refresh_continuous_aggregate('cond_10', 1, 50); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; hypertable_id | watermark ---------------+------------- 1 | 50 2 | -2147483648 -- Invalidations should be cleared inside the refresh window: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | 9 3 | 50 | 9223372036854775807 4 | -9223372036854775808 | 9223372036854775807 5 | -9223372036854775808 | 9223372036854775807 -- Refresh up to 50 from the beginning CALL refresh_continuous_aggregate('cond_10', 0, 50); SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 50 | 9223372036854775807 4 | -9223372036854775808 | 9223372036854775807 5 | -9223372036854775808 | 9223372036854775807 -- Refreshing below the threshold does not move it: CALL refresh_continuous_aggregate('cond_10', 20, 49); NOTICE: continuous aggregate "cond_10" is already up-to-date SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; hypertable_id | watermark ---------------+------------- 1 | 50 2 | -2147483648 -- Nothing changes with invalidations either since the region was -- already refreshed and no new invalidations have been generated: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 50 | 9223372036854775807 4 | -9223372036854775808 | 9223372036854775807 5 | -9223372036854775808 | 9223372036854775807 -- Refreshing measure_10 moves the threshold only for the other hypertable: CALL refresh_continuous_aggregate('measure_10', 0, 30); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 1 | 50 2 | 30 SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 50 | 9223372036854775807 4 | -9223372036854775808 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Refresh on the second continuous aggregate, cond_20, on the first -- hypertable moves the same threshold as when refreshing cond_10: CALL refresh_continuous_aggregate('cond_20', 60, 100); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 1 | 100 2 | 30 SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 50 | 9223372036854775807 4 | -9223372036854775808 | 59 4 | 100 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- There should be no hypertable invalidations initially: SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 50 | 9223372036854775807 4 | -9223372036854775808 | 59 4 | 100 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Create invalidations across different ranges. Some of these should -- be deleted and others cut in different ways when a refresh is -- run. Note that the refresh window is inclusive in the start of the -- window but exclusive at the end. -- Entries that should be left unmodified: INSERT INTO conditions VALUES (10, 4, 23.7); INSERT INTO conditions VALUES (10, 5, 23.8), (19, 3, 23.6); INSERT INTO conditions VALUES (60, 3, 23.7), (70, 4, 23.7); -- Should see some invaliations in the hypertable invalidation log: SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 10 | 10 1 | 10 | 19 1 | 60 | 70 -- Generate some invalidations for the other hypertable INSERT INTO measurements VALUES (20, 4, 23.7); INSERT INTO measurements VALUES (30, 5, 23.8), (80, 3, 23.6); -- Should now see invalidations for both hypertables SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 10 | 10 1 | 10 | 19 1 | 60 | 70 2 | 20 | 20 -- First refresh a window where we don't have any invalidations. This -- allows us to see only the copying of the invalidations to the per -- cagg log without additional processing. CALL refresh_continuous_aggregate('cond_10', 20, 60); -- Invalidation threshold remains at 100: SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 1 | 100 2 | 30 -- Invalidations should be moved from the hypertable invalidation log -- to the continuous aggregate log, but only for the hypertable that -- the refreshed aggregate belongs to: SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 2 | 20 | 20 SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 10 | 19 3 | 60 | 9223372036854775807 4 | -9223372036854775808 | 59 4 | 0 | 19 4 | 60 | 79 4 | 100 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Now add more invalidations to test a refresh that overlaps with them. -- Entries that should be deleted: INSERT INTO conditions VALUES (30, 1, 23.4), (59, 1, 23.4); INSERT INTO conditions VALUES (20, 1, 23.4), (30, 1, 23.4); -- Entries that should be cut to the right, leaving an invalidation to -- the left of the refresh window: INSERT INTO conditions VALUES (1, 4, 23.7), (25, 1, 23.4); INSERT INTO conditions VALUES (19, 4, 23.7), (59, 1, 23.4); -- Entries that should be cut to the left and right, leaving two -- invalidation entries on each side of the refresh window: INSERT INTO conditions VALUES (2, 2, 23.5), (60, 1, 23.4); INSERT INTO conditions VALUES (3, 2, 23.5), (80, 1, 23.4); -- Entries that should be cut to the left, leaving an invalidation to -- the right of the refresh window: INSERT INTO conditions VALUES (60, 3, 23.6), (90, 3, 23.6); INSERT INTO conditions VALUES (20, 5, 23.8), (100, 3, 23.6); -- New invalidations in the hypertable invalidation log: SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 1 | 25 1 | 2 | 60 1 | 3 | 80 1 | 19 | 59 1 | 20 | 30 1 | 20 | 100 1 | 30 | 59 1 | 60 | 90 2 | 20 | 20 -- But nothing has yet changed in the cagg invalidation log: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 10 | 19 3 | 60 | 9223372036854775807 4 | -9223372036854775808 | 59 4 | 0 | 19 4 | 60 | 79 4 | 100 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Refresh to process invalidations for daily temperature: CALL refresh_continuous_aggregate('cond_10', 20, 60); -- Invalidations should be moved from the hypertable invalidation log -- to the continuous aggregate log. SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 2 | 20 | 20 -- Only the cond_10 cagg should have its entries cut: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | 19 3 | 60 | 9223372036854775807 4 | -9223372036854775808 | 59 4 | 0 | 19 4 | 0 | 119 4 | 60 | 79 4 | 100 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Refresh also cond_20: CALL refresh_continuous_aggregate('cond_20', 20, 60); -- The cond_20 cagg should also have its entries cut: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | 19 3 | 60 | 9223372036854775807 4 | -9223372036854775808 | 19 4 | 60 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Refresh cond_10 to completely remove an invalidation: CALL refresh_continuous_aggregate('cond_10', 0, 20); -- The 1-19 invalidation should be deleted: SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 60 | 9223372036854775807 4 | -9223372036854775808 | 19 4 | 60 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Clear everything between 0 and 100 to make way for new -- invalidations CALL refresh_continuous_aggregate('cond_10', 0, 100); -- Test refreshing with non-overlapping invalidations INSERT INTO conditions VALUES (20, 1, 23.4), (25, 1, 23.4); INSERT INTO conditions VALUES (30, 1, 23.4), (46, 1, 23.4); CALL refresh_continuous_aggregate('cond_10', 1, 40); SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 40 | 49 3 | 100 | 9223372036854775807 4 | -9223372036854775808 | 19 4 | 20 | 59 4 | 60 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Refresh whithout cutting (in area where there are no -- invalidations). Merging of overlapping entries should still happen: INSERT INTO conditions VALUES (15, 1, 23.4), (42, 1, 23.4); CALL refresh_continuous_aggregate('cond_10', 90, 100); NOTICE: continuous aggregate "cond_10" is already up-to-date SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -1 3 | 10 | 49 3 | 100 | 9223372036854775807 4 | -9223372036854775808 | 19 4 | 0 | 59 4 | 20 | 59 4 | 60 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 -- Test max refresh window CALL refresh_continuous_aggregate('cond_10', NULL, NULL); SELECT * FROM cagg_invals; cagg_id | start | end ---------+----------------------+--------------------- 3 | 110 | 9223372036854775807 4 | -9223372036854775808 | 19 4 | 0 | 59 4 | 20 | 59 4 | 60 | 9223372036854775807 5 | -9223372036854775808 | -1 5 | 30 | 9223372036854775807 SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 2 | 20 | 20 -- Pick the first chunk of conditions to TRUNCATE SELECT show_chunks AS chunk_to_truncate FROM show_chunks('conditions') ORDER BY 1 LIMIT 1 \gset -- Show the data before truncating one of the chunks SELECT * FROM :chunk_to_truncate ORDER BY 1; time | device | temp ------+--------+------ 1 | 4 | 23.7 1 | 0 | 16 2 | 2 | 23.5 2 | 1 | 25 3 | 2 | 23.5 3 | 0 | 20 4 | 2 | 10 5 | 2 | 26 6 | 1 | 13 7 | 3 | 35 8 | 1 | 37 9 | 3 | 7 -- Truncate one chunk TRUNCATE TABLE :chunk_to_truncate; -- Should see new invalidation entries for conditions SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 0 | 10 2 | 20 | 20 -- TRUNCATE the hypertable to invalidate all its continuous aggregates TRUNCATE conditions; -- Now empty SELECT * FROM conditions; time | device | temp ------+--------+------ -- Should see an infinite invalidation entry for conditions SELECT * FROM hyper_invals; hyper_id | start | end ----------+----------------------+--------------------- 1 | -9223372036854775808 | 9223372036854775807 1 | 0 | 10 2 | 20 | 20 -- Aggregates still hold data SELECT * FROM cond_10 ORDER BY 1,2 LIMIT 5; bucket | device | avg_temp --------+--------+---------- 0 | 0 | 18 0 | 1 | 25 0 | 2 | 20.75 0 | 3 | 21 0 | 4 | 23.7 SELECT * FROM cond_20 ORDER BY 1,2 LIMIT 5; bucket | device | avg_temp --------+--------+------------------ 20 | 0 | 18.2857142857143 20 | 1 | 23.5142857142857 20 | 2 | 26 20 | 3 | 23 20 | 5 | 23.8 CALL refresh_continuous_aggregate('cond_10', NULL, NULL); CALL refresh_continuous_aggregate('cond_20', NULL, NULL); -- Both should now be empty after refresh SELECT * FROM cond_10 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- SELECT * FROM cond_20 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- -- Insert new data again and refresh INSERT INTO conditions VALUES (1, 1, 23.4), (4, 3, 14.3), (5, 1, 13.6), (6, 2, 17.9), (12, 1, 18.3), (19, 3, 28.2), (10, 3, 22.3), (11, 2, 34.9), (15, 2, 45.6), (21, 1, 15.3), (22, 2, 12.3), (29, 3, 16.3); CALL refresh_continuous_aggregate('cond_10', NULL, NULL); CALL refresh_continuous_aggregate('cond_20', NULL, NULL); -- Should now hold data again SELECT * FROM cond_10 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 18.5 0 | 2 | 17.9 0 | 3 | 14.3 10 | 1 | 18.3 10 | 2 | 40.25 10 | 3 | 25.25 20 | 1 | 15.3 20 | 2 | 12.3 20 | 3 | 16.3 SELECT * FROM cond_20 ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 1 | 18.4333333333333 0 | 2 | 32.8 0 | 3 | 21.6 20 | 1 | 15.3 20 | 2 | 12.3 20 | 3 | 16.3 -- Truncate one of the aggregates, but first test that we block -- TRUNCATE ONLY \set ON_ERROR_STOP 0 TRUNCATE ONLY cond_20; ERROR: cannot truncate only a continuous aggregate \set ON_ERROR_STOP 1 TRUNCATE cond_20; -- Should now be empty SELECT * FROM cond_20 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- -- Other aggregate is not affected SELECT * FROM cond_10 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 18.5 0 | 2 | 17.9 0 | 3 | 14.3 10 | 1 | 18.3 10 | 2 | 40.25 10 | 3 | 25.25 20 | 1 | 15.3 20 | 2 | 12.3 20 | 3 | 16.3 -- Refresh again to bring data back CALL refresh_continuous_aggregate('cond_20', NULL, NULL); -- The aggregate should be populated again SELECT * FROM cond_20 ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 1 | 18.4333333333333 0 | 2 | 32.8 0 | 3 | 21.6 20 | 1 | 15.3 20 | 2 | 12.3 20 | 3 | 16.3 ------------------------------------------------------- -- Test corner cases against a minimal bucket aggregate ------------------------------------------------------- -- First, clear the table and aggregate TRUNCATE conditions; SELECT * FROM conditions; time | device | temp ------+--------+------ CALL refresh_continuous_aggregate('cond_10', NULL, NULL); SELECT * FROM cond_10 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- CREATE MATERIALIZED VIEW cond_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '1', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; SELECT mat_hypertable_id AS cond_1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'cond_1' \gset -- Test invalidations with bucket size 1 INSERT INTO conditions VALUES (0, 1, 1.0); SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 0 | 0 2 | 20 | 20 -- Refreshing around the bucket should not update the aggregate CALL refresh_continuous_aggregate('cond_1', -1, 0); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- CALL refresh_continuous_aggregate('cond_1', 1, 2); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- -- Refresh only the invalidated bucket CALL refresh_continuous_aggregate('cond_1', 0, 1); SELECT * FROM cagg_invals WHERE cagg_id = :cond_1_id; cagg_id | start | end ---------+----------------------+--------------------- 6 | -9223372036854775808 | -2 6 | 2 | 9223372036854775807 SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 -- Refresh 1 extra bucket on the left INSERT INTO conditions VALUES (0, 1, 2.0); CALL refresh_continuous_aggregate('cond_1', -1, 1); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1.5 -- Refresh 1 extra bucket on the right INSERT INTO conditions VALUES (0, 1, 3.0); CALL refresh_continuous_aggregate('cond_1', 0, 2); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 2 -- Refresh 1 extra bucket on each side INSERT INTO conditions VALUES (0, 1, 4.0); CALL refresh_continuous_aggregate('cond_1', -1, 2); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 2.5 -- Clear to reset aggregate TRUNCATE conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); -- Test invalidation of size 2 INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0); -- Refresh one bucket at a time CALL refresh_continuous_aggregate('cond_1', 0, 1); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 CALL refresh_continuous_aggregate('cond_1', 1, 2); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 1 | 1 | 2 -- Repeat the same thing but refresh the whole invalidation at once TRUNCATE conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0); CALL refresh_continuous_aggregate('cond_1', 0, 2); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 1 | 1 | 2 -- Test invalidation of size 3 TRUNCATE conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0), (2, 1, 3.0); -- Invalidation extends beyond the refresh window on both ends CALL refresh_continuous_aggregate('cond_1', 1, 2); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 1 | 1 | 2 -- Should leave one invalidation on each side of the refresh window SELECT * FROM cagg_invals WHERE cagg_id = :cond_1_id; cagg_id | start | end ---------+-------+--------------------- 6 | 0 | 0 6 | 2 | 2 6 | 110 | 9223372036854775807 -- Refresh the two remaining invalidations CALL refresh_continuous_aggregate('cond_1', 0, 1); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 1 | 1 | 2 CALL refresh_continuous_aggregate('cond_1', 2, 3); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 1 | 1 | 2 2 | 1 | 3 -- Clear and repeat but instead refresh the whole range in one go. The -- result should be the same as the three partial refreshes. Use -- DELETE instead of TRUNCATE to clear this time. DELETE FROM conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0), (2, 1, 3.0); CALL refresh_continuous_aggregate('cond_1', 0, 3); SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 1 | 1 | 2 2 | 1 | 3 ---------------------------------------------- -- Test that invalidation threshold is capped ---------------------------------------------- CREATE table threshold_test (time int, value int); SELECT create_hypertable('threshold_test', 'time', chunk_time_interval => 4); create_hypertable ----------------------------- (7,public,threshold_test,t) SELECT set_integer_now_func('threshold_test', 'int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW thresh_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(2, time) AS bucket, max(value) AS max FROM threshold_test GROUP BY 1 WITH NO DATA; SELECT raw_hypertable_id AS thresh_hyper_id, mat_hypertable_id AS thresh_cagg_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'thresh_2' \gset -- There's no invalidation threshold initially SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; hypertable_id | watermark ---------------+------------- 7 | -2147483648 -- Test that threshold is initilized to min value when there's no data -- and we specify an infinite end. Note that the min value may differ -- depending on time type. CALL refresh_continuous_aggregate('thresh_2', 0, NULL); NOTICE: continuous aggregate "thresh_2" is already up-to-date SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; hypertable_id | watermark ---------------+------------- 7 | -2147483648 INSERT INTO threshold_test SELECT v, v FROM generate_series(1, 10) v; CALL refresh_continuous_aggregate('thresh_2', 0, 5); -- Threshold should move to end of the last refreshed bucket, which is -- the last bucket fully included in the window, i.e., the window -- shrinks to end of previous bucket. SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 7 | 4 -- Refresh where both the start and end of the window is above the -- max data value CALL refresh_continuous_aggregate('thresh_2', 14, NULL); NOTICE: continuous aggregate "thresh_2" is already up-to-date SELECT watermark AS thresh_hyper_id_watermark FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id \gset -- Refresh where we start from the current watermark to infinity CALL refresh_continuous_aggregate('thresh_2', :thresh_hyper_id_watermark, NULL); NOTICE: continuous aggregate "thresh_2" is already up-to-date -- Now refresh with max end of the window to test that the -- invalidation threshold is capped at the last bucket of data CALL refresh_continuous_aggregate('thresh_2', 0, NULL); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 7 | 12 -- Should not have processed invalidations beyond the invalidation -- threshold. SELECT * FROM cagg_invals WHERE cagg_id = :thresh_cagg_id; cagg_id | start | end ---------+----------------------+--------------------- 8 | -9223372036854775808 | -1 8 | 12 | 9223372036854775807 -- Check that things are properly materialized SELECT * FROM thresh_2 ORDER BY 1; bucket | max --------+----- 0 | 1 2 | 3 4 | 5 6 | 7 8 | 9 10 | 10 -- Delete the last data SELECT show_chunks AS chunk_to_drop FROM show_chunks('threshold_test') ORDER BY 1 DESC LIMIT 1 \gset DELETE FROM threshold_test WHERE time > 6; -- The last data in the hypertable is gone SELECT time_bucket(2, time) AS bucket, max(value) AS max FROM threshold_test GROUP BY 1 ORDER BY 1; bucket | max --------+----- 0 | 1 2 | 3 4 | 5 6 | 6 -- The aggregate still holds data SELECT * FROM thresh_2 ORDER BY 1; bucket | max --------+----- 0 | 1 2 | 3 4 | 5 6 | 7 8 | 9 10 | 10 -- Refresh the aggregate to bring it up-to-date CALL refresh_continuous_aggregate('thresh_2', 0, NULL); -- Data also gone from the aggregate SELECT * FROM thresh_2 ORDER BY 1; bucket | max --------+----- 0 | 1 2 | 3 4 | 5 6 | 6 -- The invalidation threshold remains the same SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 7 | 12 -- Insert new data beyond the invalidation threshold to move it -- forward INSERT INTO threshold_test SELECT v, v FROM generate_series(7, 15) v; CALL refresh_continuous_aggregate('thresh_2', 0, NULL); -- Aggregate now updated to reflect newly aggregated data SELECT * FROM thresh_2 ORDER BY 1; bucket | max --------+----- 0 | 1 2 | 3 4 | 5 6 | 7 8 | 9 10 | 11 12 | 13 14 | 15 -- The invalidation threshold should have moved forward to the end of -- the new data SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; hypertable_id | watermark ---------------+----------- 7 | 16 -- The aggregate remains invalid beyond the invalidation threshold SELECT * FROM cagg_invals WHERE cagg_id = :thresh_cagg_id; cagg_id | start | end ---------+----------------------+--------------------- 8 | -9223372036854775808 | -1 8 | 16 | 9223372036854775807 ---------------------------------------------------------------------- -- Test that dropping a chunk invalidates the dropped region. First -- create another chunk so that we have two chunks. One of the chunks -- will be dropped. --------------------------------------------------------------------- INSERT INTO conditions VALUES (10, 1, 10.0); -- Chunks currently associated with the hypertable SELECT show_chunks AS chunk_to_drop FROM show_chunks('conditions'); chunk_to_drop ----------------------------------------- _timescaledb_internal._hyper_1_35_chunk _timescaledb_internal._hyper_1_41_chunk -- Pick the first one to drop SELECT show_chunks AS chunk_to_drop FROM show_chunks('conditions') ORDER BY 1 LIMIT 1 \gset -- Show the data before dropping one of the chunks SELECT * FROM conditions ORDER BY 1,2; time | device | temp ------+--------+------ 0 | 1 | 1 1 | 1 | 2 2 | 1 | 3 10 | 1 | 10 -- Drop one chunk DROP TABLE :chunk_to_drop; -- The chunk's data no longer exists in the hypertable SELECT * FROM conditions ORDER BY 1,2; time | device | temp ------+--------+------ 10 | 1 | 10 -- Aggregate still remains in continuous aggregate, however SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 0 | 1 | 1 1 | 1 | 2 2 | 1 | 3 -- Refresh the continuous aggregate to make the dropped data be -- reflected in the aggregate CALL refresh_continuous_aggregate('cond_1', NULL, NULL); -- Aggregate now up-to-date with the source hypertable SELECT * FROM cond_1 ORDER BY 1,2; bucket | device | avg_temp --------+--------+---------- 10 | 1 | 10 -- Test that adjacent invalidations are merged INSERT INTO conditions VALUES(1, 1, 1.0), (2, 1, 2.0); INSERT INTO conditions VALUES(3, 1, 1.0); INSERT INTO conditions VALUES(4, 1, 1.0); INSERT INTO conditions VALUES(6, 1, 1.0); CALL refresh_continuous_aggregate('cond_1', 10, NULL); NOTICE: continuous aggregate "cond_1" is already up-to-date SELECT * FROM cagg_invals WHERE cagg_id = :cond_1_id; cagg_id | start | end ---------+-------+--------------------- 6 | 1 | 4 6 | 6 | 6 6 | 110 | 9223372036854775807 --------------------------------------------------------------------- -- Test that single timestamp invalidations are expanded to buckets, -- and adjacent buckets merged. --------------------------------------------------------------------- -- First clear invalidations in a range: CALL refresh_continuous_aggregate('cond_10', -20, 60); -- The following three should be merged to one range 0-29 INSERT INTO conditions VALUES (5, 1, 1.0); INSERT INTO conditions VALUES (15, 1, 1.0); INSERT INTO conditions VALUES (25, 1, 1.0); -- The last one should not merge with the others INSERT INTO conditions VALUES (40, 1, 1.0); -- Refresh to process invalidations, but outside the range of -- invalidations we inserted so that we don't clear them. CALL refresh_continuous_aggregate('cond_10', 50, 60); NOTICE: continuous aggregate "cond_10" is already up-to-date SELECT mat_hypertable_id AS cond_10_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'cond_10' \gset SELECT * FROM cagg_invals WHERE cagg_id = :cond_10_id; cagg_id | start | end ---------+----------------------+--------------------- 3 | -9223372036854775808 | -21 3 | 0 | 29 3 | 40 | 49 3 | 60 | 9223372036854775807 -- should trigger two individual refreshes CALL refresh_continuous_aggregate('cond_10', 0, 200); -- Insert into every second bucket INSERT INTO conditions VALUES (20, 1, 1.0); INSERT INTO conditions VALUES (40, 1, 1.0); INSERT INTO conditions VALUES (60, 1, 1.0); INSERT INTO conditions VALUES (80, 1, 1.0); INSERT INTO conditions VALUES (100, 1, 1.0); INSERT INTO conditions VALUES (120, 1, 1.0); INSERT INTO conditions VALUES (140, 1, 1.0); CALL refresh_continuous_aggregate('cond_10', 0, 200); -- Test refresh with undefined invalidation threshold and variable sized buckets CREATE TABLE timestamp_ht ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('timestamp_ht', 'time'); create_hypertable --------------------------- (9,public,timestamp_ht,t) CREATE MATERIALIZED VIEW temperature_4h WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; NOTICE: continuous aggregate "temperature_4h" is already up-to-date -- We also treat time_buckets with an hourly interval that uses a time-zone -- as a variable see caggtimebucket_validate(). CREATE MATERIALIZED VIEW temperature_4h_2 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, 'Europe/Berlin') AS bucket_4h, avg(value) AS average FROM timestamp_ht GROUP BY 1 ORDER BY 1; NOTICE: continuous aggregate "temperature_4h_2" is already up-to-date CREATE MATERIALIZED VIEW temperature_1month WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', time), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; NOTICE: continuous aggregate "temperature_1month" is already up-to-date CREATE MATERIALIZED VIEW temperature_1month_ts WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', time, 'Europe/Berlin'), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; NOTICE: continuous aggregate "temperature_1month_ts" is already up-to-date CREATE MATERIALIZED VIEW temperature_1month_hierarchical WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', bucket_4h), avg(average) FROM temperature_4h_2 GROUP BY 1 ORDER BY 1; NOTICE: continuous aggregate "temperature_1month_hierarchical" is already up-to-date CREATE MATERIALIZED VIEW temperature_1month_hierarchical_ts WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', bucket_4h, 'Europe/Berlin'), avg(average) FROM temperature_4h_2 GROUP BY 1 ORDER BY 1; NOTICE: continuous aggregate "temperature_1month_hierarchical_ts" is already up-to-date --------------------------------------------------------------------- --- Issue 5474 --------------------------------------------------------------------- CREATE TABLE i5474 ( time timestamptz NOT NULL, sensor_id integer NOT NULL, cpu double precision NOT NULL, temperature double precision NOT NULL); SELECT create_hypertable('i5474','time'); create_hypertable --------------------- (16,public,i5474,t) CREATE MATERIALIZED VIEW i5474_summary_daily WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, 'AWST') AS bucket, sensor_id, avg(cpu) AS avg_cpu FROM i5474 GROUP BY bucket, sensor_id; NOTICE: continuous aggregate "i5474_summary_daily" is already up-to-date SELECT add_continuous_aggregate_policy('i5474_summary_daily', start_offset => NULL, end_offset => INTERVAL '10 MINUTES', schedule_interval => INTERVAL '1 MINUTE' ) new_job_id \gset -- Check that start_offset = NULL is handled properly by the refresh job... CALL run_job(:new_job_id); -- ...and the CAgg can be refreshed afterward CALL refresh_continuous_aggregate('i5474_summary_daily', NULL, '2023-03-21 05:00:00+00'); NOTICE: continuous aggregate "i5474_summary_daily" is already up-to-date INSERT INTO i5474 (time, sensor_id, cpu, temperature) VALUES ('2000-01-01 05:00:00+00', 1, 1.0, 1.0); CALL refresh_continuous_aggregate('i5474_summary_daily', NULL, '2023-01-01 01:00:00+00'); -- CAgg should be up-to-date now CALL refresh_continuous_aggregate('i5474_summary_daily', NULL, '2023-01-01 01:00:00+00'); NOTICE: continuous aggregate "i5474_summary_daily" is already up-to-date -- -- Test the invalidation move function -- -- Make sure to move the threshold for the insertions we are going to -- do. CALL refresh_continuous_aggregate('measure_10', 0, 200); SELECT * FROM hypertable_invalidation_thresholds WHERE hypertable IN ('conditions'::regclass, 'measurements'::regclass); hypertable | threshold --------------+----------- conditions | 200 measurements | 200 SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- -- Save away the contents of some materialized views so that we can -- check that they are not updated when we move invalidations. SELECT * INTO saved_measure_10 FROM measure_10; SELECT * INTO saved_cond_10 FROM cond_10; -- Generate some invalidations for the hypertables INSERT INTO conditions VALUES (110, 14, 23.7); INSERT INTO conditions VALUES (110, 15, 23.8), (119, 3, 23.6); INSERT INTO conditions VALUES (160, 13, 23.7), (170, 4, 23.7); INSERT INTO measurements VALUES (120, 14, 23.7); INSERT INTO measurements VALUES (130, 15, 23.8), (180, 3, 23.6); -- Move hypertable invalidations one hypertable at a time and see that -- they are moved and that attached continuous aggregates are not -- updated. SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 110 | 110 1 | 110 | 119 1 | 160 | 170 2 | 120 | 120 2 | 130 | 180 CALL _timescaledb_functions.process_hypertable_invalidations('measurements'); SELECT * FROM measure_10 FULL JOIN saved_measure_10 ON row(measure_10.*) = row(saved_measure_10.*) WHERE measure_10.bucket IS NULL OR saved_measure_10.bucket IS NULL ORDER BY 1, 2; bucket | device | avg_temp | bucket | device | avg_temp --------+--------+----------+--------+--------+---------- SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- 1 | 110 | 110 1 | 110 | 119 1 | 160 | 170 CALL _timescaledb_functions.process_hypertable_invalidations('conditions'); SELECT * FROM cond_10 FULL JOIN saved_cond_10 ON row(cond_10.*) = row(saved_cond_10.*) WHERE cond_10.bucket IS NULL OR saved_cond_10.bucket IS NULL ORDER BY 1, 2; bucket | device | avg_temp | bucket | device | avg_temp --------+--------+----------+--------+--------+---------- SELECT * FROM hyper_invals; hyper_id | start | end ----------+-------+----- -- Check that once we refresh the continuous aggregates, the changes -- are there. CALL refresh_continuous_aggregate('measure_10', NULL, NULL); SELECT * FROM measure_10 FULL JOIN saved_measure_10 ON row(measure_10.*) = row(saved_measure_10.*) WHERE measure_10.bucket IS NULL OR saved_measure_10.bucket IS NULL ORDER BY 1, 2; bucket | device | avg_temp | bucket | device | avg_temp --------+--------+----------+--------+--------+---------- 120 | 14 | 23.7 | | | 130 | 15 | 23.8 | | | 180 | 3 | 23.6 | | | CALL refresh_continuous_aggregate('cond_10', NULL, NULL); SELECT * FROM cond_10 FULL JOIN saved_cond_10 ON row(cond_10.*) = row(saved_cond_10.*) WHERE cond_10.bucket IS NULL OR saved_cond_10.bucket IS NULL ORDER BY 1, 2; bucket | device | avg_temp | bucket | device | avg_temp --------+--------+----------+--------+--------+---------- 110 | 3 | 23.6 | | | 110 | 14 | 23.7 | | | 110 | 15 | 23.8 | | | 160 | 13 | 23.7 | | | 170 | 4 | 23.7 | | | -- These should fail for different reasons \set ON_ERROR_STOP 0 CALL _timescaledb_functions.process_hypertable_invalidations(NULL); ERROR: parameter cannot be null CALL _timescaledb_functions.process_hypertable_invalidations(0); ERROR: invalid relation CALL _timescaledb_functions.process_hypertable_invalidations('measure_10'); ERROR: relation "measure_10" is not a hypertable SET ROLE :ROLE_DEFAULT_PERM_USER_2; CALL _timescaledb_functions.process_hypertable_invalidations('measurements'); ERROR: must be owner of hypertable "measurements" \set ON_ERROR_STOP 1 ����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_invalidation_multi.out������������������������������������0000664�0000000�0000000�00000022054�15100345067�0025045�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Disable background workers since we are testing manual refresh \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t SET datestyle TO 'ISO, YMD'; SET timezone TO 'UTC'; SET timescaledb.enable_cagg_wal_based_invalidation TO true; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW hypertable_invalidation_thresholds AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id; CREATE VIEW mat_invals AS SELECT ca.user_view_name AS aggregate_name, ht.table_name, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ml ON ca.mat_hypertable_id = ml.materialization_id JOIN _timescaledb_catalog.hypertable ht ON materialization_id = ht.id; CREATE VIEW invalidation_slots AS SELECT replace(slot_name::text, dboid::text, 'DBOID') AS slot_name, slot_type, database FROM pg_replication_slots, (select oid from pg_database where current_database() = datname) t(dboid) WHERE plugin = :'plugin_name'; CREATE TABLE conditions (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 10); create_hypertable ------------------------- (1,public,conditions,t) CREATE TABLE measurements (time int NOT NULL, device int, temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (2,public,measurements,t) CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM measurements $$; SELECT set_integer_now_func('conditions', 'bigint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('measurements', 'int_now'); set_integer_now_func ---------------------- INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE TABLE temp AS SELECT * FROM conditions; INSERT INTO measurements SELECT * FROM temp; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; time | device | temp ------+--------+------ 100 | 0 | 8 99 | 1 | 5 98 | 2 | 26 97 | 2 | 10 96 | 2 | 34 95 | 2 | 30 94 | 3 | 31 93 | 0 | 4 92 | 0 | 32 91 | 3 | 15 SELECT * FROM invalidation_slots; slot_name | slot_type | database -----------+-----------+---------- -- Create two continuous aggregates on the same hypertable to test -- that invalidations are handled correctly across both of them. -- set client_min_messages to debug2; CREATE MATERIALIZED VIEW cond_10 WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(BIGINT '10', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2; NOTICE: refreshing continuous aggregate "cond_10" CREATE MATERIALIZED VIEW cond_20 WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2; NOTICE: refreshing continuous aggregate "cond_20" CREATE MATERIALIZED VIEW measure_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, device, avg(temp) AS avg_temp FROM measurements GROUP BY 1,2; NOTICE: refreshing continuous aggregate "measure_10" -- We need to refresh to move the invalidation threshold, or -- invalidations will not be generated. Check initial value of -- thresholds and materialization invalidations. SELECT * FROM hypertable_invalidation_thresholds ORDER BY 1,2; hypertable | threshold --------------+----------- conditions | 120 measurements | 110 SELECT * INTO saved_invals FROM mat_invals; INSERT INTO conditions VALUES (10, 4, 23.7), (10, 5, 23.8), (19, 3, 23.6), (60, 3, 23.7), (70, 4, 23.7); INSERT INTO measurements VALUES (20, 4, 23.7), (30, 5, 23.8), (80, 3, 23.6); INSERT INTO measurements VALUES (20, 4, 23.7), (140, 5, 23.8), (200, 3, 23.6); SELECT * FROM invalidation_slots; slot_name | slot_type | database ---------------+-----------+---------------------------- ts_DBOID_cagg | logical | db_cagg_invalidation_multi CALL _timescaledb_functions.process_hypertable_invalidations( ARRAY['measurements', 'conditions'] ); SELECT m.* FROM mat_invals m FULL JOIN saved_invals s ON row(m.*) = row(s.*) WHERE m.table_name IS NULL OR s.table_name IS NULL ORDER BY 1,2,3; aggregate_name | table_name | lowest_modified_value | greatest_modified_value ----------------+----------------------------+-----------------------+------------------------- cond_10 | _materialized_hypertable_3 | 10 | 80 cond_20 | _materialized_hypertable_4 | 0 | 80 measure_10 | _materialized_hypertable_5 | 20 | 210 DROP TABLE saved_invals; -- Insert a lot of invalidations (more than 256) to trigger the code -- that grows the ranges array and make sure that works as well. We -- need to generate separate transactions for each insert, so we do -- this using a loop rather than a single insert. SELECT * FROM hypertable_invalidation_thresholds ORDER BY 1,2; hypertable | threshold --------------+----------- conditions | 120 measurements | 110 DO $$ DECLARE rec RECORD; BEGIN FOR rec IN SELECT t, d FROM generate_series(1,100) t, generate_series(1,100) d LOOP INSERT INTO conditions VALUES (rec.t, rec.d, 100.0 * random()); COMMIT; END LOOP; END $$; SELECT * INTO saved_invals FROM mat_invals; -- Peek at the WAL to check what we've got recorded. SELECT slot_name FROM pg_replication_slots WHERE slot_name LIKE 'ts%cagg' \gset SELECT count(data) FROM pg_logical_slot_peek_binary_changes(:'slot_name', NULL, 1000, variadic ARRAY['conditions', 'time']); count ------- 1000 -- We set the work memory quite low to trigger range shedding when -- running out of memory. SET timescaledb.cagg_processing_low_work_mem TO 64; SET timescaledb.cagg_processing_high_work_mem TO 96; CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions']); -- Here we should get invalidations aligned to the bucket widths based -- on the invalidation above. -- -- We collect all the ranges into a multirange to avoid flakes because -- of additional entries as a result of shedding below. The complete -- invalidated ranges should be the same regardless. SELECT m.aggregate_name, unnest(range_agg(multirange(int8range(m.lowest_modified_value, m.greatest_modified_value)))) FROM mat_invals m FULL JOIN saved_invals s ON row(m.*) = row(s.*) WHERE m.table_name IS NULL OR s.table_name IS NULL GROUP BY 1 ORDER BY 1,2; aggregate_name | unnest ----------------+--------- cond_10 | [0,110) cond_20 | [0,120) -- This should be fine but not process any tables. Odd usage, but -- nothing wrong with it. CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY[]::regclass[]); -- These should error out \set ON_ERROR_STOP 0 \set VERBOSITY default CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['cond_10']); ERROR: table "cond_10" is not a hypertable CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY[0]); ERROR: OID 0 is not a hypertable CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['cond_10', 'cond_20']); ERROR: 2 objects in list are not hypertables DETAIL: Bad objects are "cond_10" and "cond_20". CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 'cond_20']); ERROR: table "cond_20" is not a hypertable CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 123456]::regclass[]); ERROR: OID 123456 is not a hypertable CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 123456, 'cond_10']::regclass[]); ERROR: 2 objects in list are not hypertables DETAIL: Bad objects are 123456 and "cond_10". CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 123456, 'cond_10', 'cond_20']::regclass[]); ERROR: 3 objects in list are not hypertables DETAIL: Bad objects are 123456, "cond_10", and "cond_20". \set VERBOSITY terse \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_joins.out�������������������������������������������������0000664�0000000�0000000�00000175104�15100345067�0022301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set VERBOSITY default SET timezone TO PST8PDT; CREATE TABLE conditions( day TIMESTAMPTZ NOT NULL, city text NOT NULL, temperature INT NOT NULL, device_id int NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'day', chunk_time_interval => INTERVAL '1 day'); table_name ------------ conditions INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-14', 'Moscow', 26,1), ('2021-06-15', 'Berlin', 22,2), ('2021-06-16', 'Stockholm', 24,3), ('2021-06-17', 'London', 24,4), ('2021-06-18', 'London', 27,4), ('2021-06-19', 'Moscow', 28,4), ('2021-06-20', 'Moscow', 30,1), ('2021-06-21', 'Berlin', 31,1), ('2021-06-22', 'Stockholm', 34,1), ('2021-06-23', 'Stockholm', 34,2), ('2021-06-24', 'Moscow', 34,2), ('2021-06-25', 'London', 32,3), ('2021-06-26', 'Moscow', 32,3), ('2021-06-27', 'Moscow', 31,3); CREATE TABLE conditions_dup AS SELECT * FROM conditions; SELECT table_name FROM create_hypertable('conditions_dup', 'day', chunk_time_interval => INTERVAL '1 day', migrate_data => true); NOTICE: migrating data to chunks DETAIL: Migration might take a while depending on the amount of data. table_name ---------------- conditions_dup CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); CREATE TABLE location (location_id INTEGER, name TEXT); INSERT INTO location VALUES (1, 'Moscow'), (2, 'Berlin'), (3, 'London'), (4, 'Stockholm'); CREATE TABLE devices_dup AS SELECT * FROM devices; CREATE VIEW devices_view AS SELECT * FROM devices; -- Cagg with inner join + realtime aggregate CREATE MATERIALIZED VIEW cagg_realtime WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_realtime" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \d+ cagg_realtime View "public.cagg_realtime" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | avg | numeric | | | | main | name | text | | | | extended | View definition: ( SELECT _materialized_hypertable_3.bucket, _materialized_hypertable_3.avg, _materialized_hypertable_3.name FROM _timescaledb_internal._materialized_hypertable_3 WHERE _materialized_hypertable_3.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) ORDER BY _materialized_hypertable_3.bucket) UNION ALL ( SELECT time_bucket('@ 1 day'::interval, conditions.day) AS bucket, avg(conditions.temperature) AS avg, devices.name FROM conditions, devices WHERE conditions.device_id = devices.device_id AND conditions.day >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) GROUP BY devices.name, (time_bucket('@ 1 day'::interval, conditions.day)) ORDER BY (time_bucket('@ 1 day'::interval, conditions.day))) ORDER BY 1; SELECT * FROM cagg_realtime ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-30', 'Moscow', 28, 3); SELECT * FROM cagg_realtime ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg with inner join + realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_realtime_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_realtime_join" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \d+ cagg_realtime_join View "public.cagg_realtime_join" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | avg | numeric | | | | main | name | text | | | | extended | View definition: ( SELECT _materialized_hypertable_4.bucket, _materialized_hypertable_4.avg, _materialized_hypertable_4.name FROM _timescaledb_internal._materialized_hypertable_4 WHERE _materialized_hypertable_4.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(4)), '-infinity'::timestamp with time zone) ORDER BY _materialized_hypertable_4.bucket) UNION ALL ( SELECT time_bucket('@ 1 day'::interval, conditions.day) AS bucket, avg(conditions.temperature) AS avg, devices.name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.day >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(4)), '-infinity'::timestamp with time zone) GROUP BY devices.name, (time_bucket('@ 1 day'::interval, conditions.day)) ORDER BY (time_bucket('@ 1 day'::interval, conditions.day))) ORDER BY 1; SELECT * FROM cagg_realtime_join ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-30', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_join ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg with inner join + realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_realtime_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING (device_id) GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_realtime_using" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \d+ cagg_realtime_using View "public.cagg_realtime_using" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | avg | numeric | | | | main | name | text | | | | extended | View definition: ( SELECT _materialized_hypertable_5.bucket, _materialized_hypertable_5.avg, _materialized_hypertable_5.name FROM _timescaledb_internal._materialized_hypertable_5 WHERE _materialized_hypertable_5.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(5)), '-infinity'::timestamp with time zone) ORDER BY _materialized_hypertable_5.bucket) UNION ALL ( SELECT time_bucket('@ 1 day'::interval, conditions.day) AS bucket, avg(conditions.temperature) AS avg, devices.name FROM conditions JOIN devices USING (device_id) WHERE conditions.day >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(5)), '-infinity'::timestamp with time zone) GROUP BY devices.name, (time_bucket('@ 1 day'::interval, conditions.day)) ORDER BY (time_bucket('@ 1 day'::interval, conditions.day))) ORDER BY 1; SELECT * FROM cagg_realtime_using ORDER BY bucket; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-30', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_using ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Reorder tables in FROM clause -- Cagg with inner join + realtime aggregate CREATE MATERIALIZED VIEW cagg_realtime_reorder WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices, conditions WHERE conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_realtime_reorder" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \d+ cagg_realtime_reorder View "public.cagg_realtime_reorder" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | avg | numeric | | | | main | name | text | | | | extended | View definition: ( SELECT _materialized_hypertable_6.bucket, _materialized_hypertable_6.avg, _materialized_hypertable_6.name FROM _timescaledb_internal._materialized_hypertable_6 WHERE _materialized_hypertable_6.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp with time zone) ORDER BY _materialized_hypertable_6.bucket) UNION ALL ( SELECT time_bucket('@ 1 day'::interval, conditions.day) AS bucket, avg(conditions.temperature) AS avg, devices.name FROM devices, conditions WHERE conditions.device_id = devices.device_id AND conditions.day >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp with time zone) GROUP BY devices.name, (time_bucket('@ 1 day'::interval, conditions.day)) ORDER BY (time_bucket('@ 1 day'::interval, conditions.day))) ORDER BY 1; SELECT * FROM cagg_realtime_reorder ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-07-01', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_reorder ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Reorder tables in FROM clause -- Cagg with inner join + realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_realtime_reorder_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions ON conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_realtime_reorder_join" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \d+ cagg_realtime_reorder_join View "public.cagg_realtime_reorder_join" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | avg | numeric | | | | main | name | text | | | | extended | View definition: ( SELECT _materialized_hypertable_7.bucket, _materialized_hypertable_7.avg, _materialized_hypertable_7.name FROM _timescaledb_internal._materialized_hypertable_7 WHERE _materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp with time zone) ORDER BY _materialized_hypertable_7.bucket) UNION ALL ( SELECT time_bucket('@ 1 day'::interval, conditions.day) AS bucket, avg(conditions.temperature) AS avg, devices.name FROM devices JOIN conditions ON conditions.device_id = devices.device_id WHERE conditions.day >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp with time zone) GROUP BY devices.name, (time_bucket('@ 1 day'::interval, conditions.day)) ORDER BY (time_bucket('@ 1 day'::interval, conditions.day))) ORDER BY 1; SELECT * FROM cagg_realtime_reorder_join ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-07-01', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_reorder_join; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Reorder tables in FROM clause -- Cagg with inner join + realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_realtime_reorder_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions USING (device_id) GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_realtime_reorder_using" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \d+ cagg_realtime_reorder_using View "public.cagg_realtime_reorder_using" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | avg | numeric | | | | main | name | text | | | | extended | View definition: ( SELECT _materialized_hypertable_8.bucket, _materialized_hypertable_8.avg, _materialized_hypertable_8.name FROM _timescaledb_internal._materialized_hypertable_8 WHERE _materialized_hypertable_8.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone) ORDER BY _materialized_hypertable_8.bucket) UNION ALL ( SELECT time_bucket('@ 1 day'::interval, conditions.day) AS bucket, avg(conditions.temperature) AS avg, devices.name FROM devices JOIN conditions USING (device_id) WHERE conditions.day >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone) GROUP BY devices.name, (time_bucket('@ 1 day'::interval, conditions.day)) ORDER BY (time_bucket('@ 1 day'::interval, conditions.day))) ORDER BY 1; SELECT * FROM cagg_realtime_reorder_using ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-07-01', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_reorder_using ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg with inner joins - realtime aggregate CREATE MATERIALIZED VIEW cagg WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name, devices.device_id AS thermo_id FROM conditions, devices WHERE conditions.device_id = devices.device_id GROUP BY bucket, name, thermo_id ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg ORDER BY bucket, name, thermo_id; bucket | avg | name | thermo_id ------------------------------+---------------------+----------+----------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 | 1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 | 2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 | 3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 | 4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 | 4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 | 4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 | 1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 | 1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 | 1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 | 2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 | 2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 | 3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 | 3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 | 3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 | 3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 | 3 -- Cagg with inner joins - realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id GROUP BY bucket,name ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_join" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_join ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg with inner joins - realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING (device_id) GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_using" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_using; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Reorder tables in FROM clause -- Cagg with inner joins - realtime aggregate CREATE MATERIALIZED VIEW cagg_reorder WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices, conditions WHERE conditions.device_id = devices.device_id GROUP BY bucket, name ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_reorder" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_reorder ORDER BY bucket, name; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg with inner joins - realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_reorder_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions ON conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_reorder_join" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_reorder_join; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg with inner joins - realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_reorder_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions USING (device_id) GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_reorder_using" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_reorder_using; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Cagg join with another table using FROM ONLY CREATE MATERIALIZED VIEW cagg_from_only WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ONLY devices JOIN conditions USING (device_id) GROUP BY name, bucket ORDER BY bucket; NOTICE: refreshing continuous aggregate "cagg_from_only" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_from_only; bucket | avg | name ------------------------------+---------------------+---------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 -- Create CAgg with join and additional WHERE conditions CREATE MATERIALIZED VIEW cagg_more_conds WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_more_conds" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_more_conds ORDER BY bucket; bucket | avg | name ------------------------------+---------------------+---------- Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 -- Cagg with more conditions and USING clause CREATE MATERIALIZED VIEW cagg_more_conds_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING (device_id) WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_more_conds_using" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_more_conds_using ORDER BY bucket; bucket | avg | name ------------------------------+---------------------+---------- Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 -- Hierarchical CAgg with join CREATE MATERIALIZED VIEW cagg_on_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 day', bucket) AS bucket, SUM(avg) AS temperature FROM cagg, devices WHERE devices.device_id = cagg.thermo_id GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg_on_cagg" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_on_cagg; bucket | temperature ------------------------------+--------------------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 DROP MATERIALIZED VIEW cagg_on_cagg CASCADE; NOTICE: drop cascades to 2 other objects DETAIL: drop cascades to table _timescaledb_internal._hyper_18_61_chunk drop cascades to table _timescaledb_internal._hyper_18_62_chunk -- Nested CAgg over a CAgg with JOIN clause CREATE MATERIALIZED VIEW cagg_on_cagg_join WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 day', bucket) AS bucket, SUM(avg) AS temperature FROM cagg JOIN devices ON devices.device_id = cagg.thermo_id GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg_on_cagg_join" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_on_cagg_join; bucket | temperature ------------------------------+--------------------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 DROP MATERIALIZED VIEW cagg_on_cagg_join CASCADE; NOTICE: drop cascades to 2 other objects DETAIL: drop cascades to table _timescaledb_internal._hyper_19_63_chunk drop cascades to table _timescaledb_internal._hyper_19_64_chunk -- Create CAgg with join and ORDER BY CREATE MATERIALIZED VIEW cagg_ordered WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket ORDER BY name; NOTICE: refreshing continuous aggregate "cagg_ordered" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_ordered ORDER BY bucket; bucket | avg | name ------------------------------+---------------------+---------- Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 CREATE MATERIALIZED VIEW cagg_ordered_2 WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket ORDER BY name DESC; NOTICE: refreshing continuous aggregate "cagg_ordered_2" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_ordered_2 ORDER BY bucket; bucket | avg | name ------------------------------+---------------------+---------- Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 CREATE MATERIALIZED VIEW cagg_ordered_3 WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket ORDER BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_ordered_3" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM cagg_ordered_3 ORDER BY bucket; bucket | avg | name ------------------------------+---------------------+---------- Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 CREATE MATERIALIZED VIEW cagg_cagg WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), devices.device_id device_id, name FROM conditions, devices WHERE conditions.device_id = devices.device_id GROUP BY name, bucket, devices.device_id; NOTICE: refreshing continuous aggregate "cagg_cagg" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. --Join between cagg and normal table CREATE MATERIALIZED VIEW cagg_nested WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', cagg.bucket) AS bucket, devices.name FROM cagg_cagg cagg, devices WHERE cagg.device_id = devices.device_id GROUP BY 1,2; NOTICE: refreshing continuous aggregate "cagg_nested" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. DROP MATERIALIZED VIEW cagg_nested CASCADE; NOTICE: drop cascades to 2 other objects DETAIL: drop cascades to table _timescaledb_internal._hyper_24_73_chunk drop cascades to table _timescaledb_internal._hyper_24_74_chunk -- CAgg with multiple join conditions without JOIN clause CREATE MATERIALIZED VIEW cagg_more_joins_conds WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), MAX(temperature), MIN(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id AND conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_more_joins_conds" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. -- With LATERAL multiple tables in new format CREATE TABLE mat_t1(a integer, b integer, c TEXT); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, temperature, count(*) from conditions, LATERAL (SELECT * FROM mat_t1 WHERE mat_t1.a = conditions.temperature) q GROUP BY bucket, temperature; NOTICE: refreshing continuous aggregate "mat_m1" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. -- Joining a hypertable and view CREATE MATERIALIZED VIEW cagg_view WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), devices_view.device_id, name FROM conditions, devices_view WHERE conditions.device_id = devices_view.device_id GROUP BY name, bucket, devices_view.device_id; NOTICE: refreshing continuous aggregate "cagg_view" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE TABLE cities(name text, currency text); INSERT INTO cities VALUES ('Berlin', 'EUR'), ('London', 'PND'); --Error out when FROM clause has sub selects \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN (SELECT * FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) dev ON conditions.device_id = dev.device_id GROUP BY name, bucket; ERROR: invalid continuous aggregate view DETAIL: Sub-queries are not supported in FROM clause. --Error out when WHERE clause has sub selects CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.city IN ( SELECT location FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) AND conditions.device_id = devices.device_id GROUP BY name, bucket; ERROR: invalid continuous aggregate query DETAIL: CTEs and subqueries are not supported by continuous aggregates. CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING(device_id) WHERE conditions.city IN ( SELECT location FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) GROUP BY name, bucket; ERROR: invalid continuous aggregate query DETAIL: CTEs and subqueries are not supported by continuous aggregates. CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city IN ( SELECT location FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) GROUP BY name, bucket; ERROR: invalid continuous aggregate query DETAIL: CTEs and subqueries are not supported by continuous aggregates. DROP TABLE cities CASCADE; --Error out when join is between two hypertables CREATE MATERIALIZED VIEW cagg_ht WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', conditions.day) AS bucket, AVG(conditions.temperature) FROM conditions, conditions_dup WHERE conditions.device_id = conditions_dup.device_id GROUP BY bucket; ERROR: invalid continuous aggregate view DETAIL: Only one hypertable is allowed in continuous aggregate view. --Error out when join is between two normal tables CREATE MATERIALIZED VIEW cagg_nt WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT AVG(devices.device_id), devices.name, devices.location FROM devices, devices_dup WHERE devices.device_id = devices_dup.device_id GROUP BY devices.name, devices.location; ERROR: invalid continuous aggregate view DETAIL: At least one hypertable should be used in the view definition. \set ON_ERROR_STOP 1 -- JOIN with non-equality condition CREATE MATERIALIZED VIEW cagg_unequal1 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.device_id <> devices.device_id GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_unequal1" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. -- JOIN with non-equality condition CREATE MATERIALIZED VIEW cagg_unequal2 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.device_id = devices.device_id AND conditions.city like '%cow*' GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_unequal2" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. -- JOIN with non-equality condition CREATE MATERIALIZED VIEW cagg_unequal3 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id OR conditions.city LIKE '%cow*' GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_unequal3" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. -- Error out when join type is not INNER or LEFT \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_outer WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions FULL JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket; ERROR: only INNER or LEFT joins are supported in continuous aggregates CREATE MATERIALIZED VIEW cagg_right WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions RIGHT JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket; ERROR: only INNER or LEFT joins are supported in continuous aggregates \set ON_ERROR_STOP 1 -- LEFT JOIN is allowed CREATE MATERIALIZED VIEW cagg_left_join WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions LEFT JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket; NOTICE: refreshing continuous aggregate "cagg_left_join" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. -- Error out for join between cagg and hypertable \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_nested_ht WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', cagg.bucket) AS bucket, cagg.name, conditions.temperature FROM cagg_cagg cagg, conditions WHERE cagg.device_id = conditions.device_id GROUP BY 1,2,3; ERROR: invalid continuous aggregate view DETAIL: Only one hypertable is allowed in continuous aggregate view. \set ON_ERROR_STOP 1 -- Multiple JOINS are supported CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', conditions.day) AS bucket, AVG(conditions.temperature), devices.name AS device, location.name AS location FROM conditions JOIN devices ON conditions.device_id = devices.device_id JOIN location ON location.name = devices.location GROUP BY bucket, devices.name, location.name; NOTICE: refreshing continuous aggregate "conditions_by_day" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. SELECT * FROM conditions_by_day ORDER BY bucket, device, location; bucket | avg | device | location ------------------------------+---------------------+----------+----------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 | Moscow Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 | Berlin Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 | London Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 | Stockholm Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 | Stockholm Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 | Stockholm Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 | Moscow Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 | Moscow Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 | Moscow Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 | Berlin Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 | Berlin Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 | London Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 | London Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 | London Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 | London Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 | London ALTER MATERIALIZED VIEW conditions_by_day SET (timescaledb.materialized_only = FALSE); -- Insert one more row on conditions and check the result (should have one more row) INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2024-07-01', 'Moscow', 28, 3); SELECT * FROM conditions_by_day ORDER BY bucket, device, location; bucket | avg | device | location ------------------------------+---------------------+----------+----------- Sun Jun 13 17:00:00 2021 PDT | 26.0000000000000000 | thermo_1 | Moscow Mon Jun 14 17:00:00 2021 PDT | 22.0000000000000000 | thermo_2 | Berlin Tue Jun 15 17:00:00 2021 PDT | 24.0000000000000000 | thermo_3 | London Wed Jun 16 17:00:00 2021 PDT | 24.0000000000000000 | thermo_4 | Stockholm Thu Jun 17 17:00:00 2021 PDT | 27.0000000000000000 | thermo_4 | Stockholm Fri Jun 18 17:00:00 2021 PDT | 28.0000000000000000 | thermo_4 | Stockholm Sat Jun 19 17:00:00 2021 PDT | 30.0000000000000000 | thermo_1 | Moscow Sun Jun 20 17:00:00 2021 PDT | 31.0000000000000000 | thermo_1 | Moscow Mon Jun 21 17:00:00 2021 PDT | 34.0000000000000000 | thermo_1 | Moscow Tue Jun 22 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 | Berlin Wed Jun 23 17:00:00 2021 PDT | 34.0000000000000000 | thermo_2 | Berlin Thu Jun 24 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 | London Fri Jun 25 17:00:00 2021 PDT | 32.0000000000000000 | thermo_3 | London Sat Jun 26 17:00:00 2021 PDT | 31.0000000000000000 | thermo_3 | London Tue Jun 29 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 | London Wed Jun 30 17:00:00 2021 PDT | 28.0000000000000000 | thermo_3 | London Sun Jun 30 17:00:00 2024 PDT | 28.0000000000000000 | thermo_3 | London -- JOIN with a foreign table \c :TEST_DBNAME :ROLE_SUPERUSER SELECT current_setting('port') AS "PGPORT", current_database() AS "PGDATABASE" \gset CREATE EXTENSION postgres_fdw; CREATE SERVER loopback FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'localhost', dbname :'PGDATABASE', port :'PGPORT'); CREATE USER MAPPING FOR :ROLE_DEFAULT_PERM_USER SERVER loopback OPTIONS (user :'ROLE_DEFAULT_PERM_USER', password 'nopassword'); ALTER USER MAPPING FOR :ROLE_DEFAULT_PERM_USER SERVER loopback OPTIONS (ADD password_required 'false'); GRANT USAGE ON FOREIGN SERVER loopback TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER; SET timezone TO PST8PDT; CREATE FOREIGN TABLE devices_fdw ( device_id int not null, name text, location text ) SERVER loopback OPTIONS (table_name 'devices'); CREATE MATERIALIZED VIEW conditions_fdw WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', conditions.day) AS bucket, AVG(conditions.temperature), devices.name AS device FROM conditions JOIN devices_fdw AS devices ON conditions.device_id = devices.device_id GROUP BY bucket, devices.name; NOTICE: refreshing continuous aggregate "conditions_fdw" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. \set VERBOSITY terse SET client_min_messages TO WARNING; DROP TABLE conditions CASCADE; DROP TABLE devices CASCADE; DROP TABLE conditions_dup CASCADE; DROP TABLE devices_dup CASCADE; RESET client_min_messages; \set VERBOSITY default -- SDC #1859 CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, value FLOAT8 NOT NULL, device_id int NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => INTERVAL '1 day'); table_name ------------ conditions INSERT INTO conditions (time, value, device_id) SELECT t, 1, 1 FROM generate_series('2024-01-01 00:00:00-00'::timestamptz, '2024-12-31 00:00:00-00'::timestamptz, '1 hour'::interval) AS t; CREATE TABLE devices (device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW cagg_realtime WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, MAX(value), MIN(value), AVG(value), devices.name, devices.location FROM conditions JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, location, bucket WITH NO DATA; \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER VACUUM ANALYZE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT a.* FROM cagg_realtime a WHERE a.location = 'Moscow' ORDER BY bucket LIMIT 2; bucket | max | min | avg | name | location ------------------------------+-----+-----+-----+----------+---------- Sun Dec 31 16:00:00 2023 PST | 1 | 1 | 1 | thermo_1 | Moscow Mon Jan 01 16:00:00 2024 PST | 1 | 1 | 1 | thermo_1 | Moscow \set VERBOSITY terse SET client_min_messages TO WARNING; DROP TABLE conditions CASCADE; DROP TABLE devices CASCADE; RESET client_min_messages; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_migrate.out�����������������������������������������������0000664�0000000�0000000�00001051055�15100345067�0022606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER -- ######################################################## -- ## INTEGER data type tests -- ######################################################## \set IS_TIME_DIMENSION FALSE \set TIME_DIMENSION_DATATYPE INTEGER \ir include/cagg_migrate_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Setup some variables SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset -- restore dump SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \ir :TEST_SCHEMA_FILE -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" integer NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_2 AS SELECT public.time_bucket(24, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(24, "time")); CREATE VIEW _timescaledb_internal._direct_view_3 AS SELECT public.time_bucket(24, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(24, "time")); CREATE VIEW _timescaledb_internal._direct_view_4 AS SELECT public.time_bucket(168, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(168, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_2 ( bucket integer NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_3 ( bucket integer NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_4 ( bucket integer NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_2 AS SELECT public.time_bucket(24, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(24, "time")); CREATE VIEW _timescaledb_internal._partial_view_3 AS SELECT public.time_bucket(24, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket(24, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_4 AS SELECT public.time_bucket(168, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket(168, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_3.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE (_materialized_hypertable_3.bucket < COALESCE((_timescaledb_functions.cagg_watermark(3))::integer, '-2147483648'::integer)) GROUP BY _materialized_hypertable_3.bucket UNION ALL SELECT public.time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(3))::integer, '-2147483648'::integer)) GROUP BY (public.time_bucket(24, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.avg, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE (_materialized_hypertable_2.bucket < COALESCE((_timescaledb_functions.cagg_watermark(2))::integer, '-2147483648'::integer)) UNION ALL SELECT public.time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(2))::integer, '-2147483648'::integer)) GROUP BY (public.time_bucket(24, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_4.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_4 WHERE (_materialized_hypertable_4.bucket < COALESCE((_timescaledb_functions.cagg_watermark(4))::integer, '-2147483648'::integer)) GROUP BY _materialized_hypertable_4.bucket UNION ALL SELECT public.time_bucket(168, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(4))::integer, '-2147483648'::integer)) GROUP BY (public.time_bucket(168, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 4, true); setval -------- 4 SELECT pg_catalog.setval('_timescaledb_catalog.hypertable_id_seq', 4, true); setval -------- 4 CREATE INDEX _materialized_hypertable_2_bucket_idx ON _timescaledb_internal._materialized_hypertable_2 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_3_bucket_idx ON _timescaledb_internal._materialized_hypertable_3 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_4_bucket_idx ON _timescaledb_internal._materialized_hypertable_4 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t -- Make sure no scheduled job will be executed during the regression tests SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature) SELECT generate_series('2022-01-01 00:00:00-00'::timestamptz, '2022-12-31 23:59:59-00'::timestamptz, '1 hour'), 0.25; \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM public.conditions $$; INSERT INTO conditions ("time", temperature) SELECT generate_series(1, 1000, 1), 0.25; \endif CALL refresh_continuous_aggregate('conditions_summary_daily', NULL, NULL); CALL refresh_continuous_aggregate('conditions_summary_weekly', NULL, NULL); \set ON_ERROR_STOP 0 -- should fail because we don't need to migrate finalized caggs CALL cagg_migrate('conditions_summary_daily_new'); psql:include/cagg_migrate_common.sql:42: ERROR: continuous aggregate "public.conditions_summary_daily_new" does not require any migration -- should fail relation does not exist CALL cagg_migrate('conditions_summary_not_cagg'); psql:include/cagg_migrate_common.sql:45: ERROR: relation "conditions_summary_not_cagg" does not exist at character 19 CREATE TABLE conditions_summary_not_cagg(); -- should fail continuous agg does not exist CALL cagg_migrate('conditions_summary_not_cagg'); psql:include/cagg_migrate_common.sql:50: ERROR: continuous aggregate "public.conditions_summary_not_cagg" does not exist \set ON_ERROR_STOP 1 DROP TABLE conditions_summary_not_cagg; SELECT ca.raw_hypertable_id AS "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", partial_view_schema AS "PART_VIEW_SCHEMA", direct_view_name AS "DIR_VIEW_NAME", direct_view_schema AS "DIR_VIEW_SCHEMA", user_view_name AS "USER_VIEW_NAME", user_view_schema AS "USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily' \gset \set ON_ERROR_STOP 0 -- should fail because the new cagg with suffix '_new' already exists CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:74: ERROR: continuous aggregate "public.conditions_summary_daily_new" already exists \set ON_ERROR_STOP 1 -- remove the new cagg to execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; -- get and set all the cagg data SELECT _timescaledb_functions.cagg_migrate_pre_validation( 'public', 'conditions_summary_daily', 'conditions_summary_daily_new' ) AS "CAGG_DATA" \gset CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); \x on SELECT mat_hypertable_id, user_view_definition FROM _timescaledb_catalog.continuous_agg_migrate_plan; -[ RECORD 1 ]--------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mat_hypertable_id | 3 user_view_definition | SELECT _materialized_hypertable_3.bucket, + | _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_2_2, NULL::numeric) AS min,+ | _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_3_3, NULL::numeric) AS max,+ | _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_4_4, NULL::numeric) AS avg,+ | _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_5_5, NULL::numeric) AS sum + | FROM _timescaledb_internal._materialized_hypertable_3 + | WHERE (_materialized_hypertable_3.bucket < COALESCE((_timescaledb_functions.cagg_watermark(3))::integer, '-2147483648'::integer)) + | GROUP BY _materialized_hypertable_3.bucket + | UNION ALL + | SELECT public.time_bucket(24, conditions."time") AS bucket, + | min(conditions.temperature) AS min, + | max(conditions.temperature) AS max, + | avg(conditions.temperature) AS avg, + | sum(conditions.temperature) AS sum + | FROM public.conditions + | WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(3))::integer, '-2147483648'::integer)) + | GROUP BY (public.time_bucket(24, conditions."time")); \x off SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+-------------+------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------- 3 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "1008"} 3 | 2 | NOT STARTED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 3 | 3 | NOT STARTED | DISABLE POLICIES | {"policies": null} 3 | 4 | NOT STARTED | REFRESH NEW CAGG | {"window_start": "1008", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "integer"} 3 | 5 | NOT STARTED | COPY DATA | {"end_ts": "240", "start_ts": "0", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 6 | NOT STARTED | COPY DATA | {"end_ts": "480", "start_ts": "240", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 7 | NOT STARTED | COPY DATA | {"end_ts": "720", "start_ts": "480", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 8 | NOT STARTED | COPY DATA | {"end_ts": "960", "start_ts": "720", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 9 | NOT STARTED | COPY DATA | {"end_ts": "1200", "start_ts": "960", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 10 | NOT STARTED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_daily_new"} 3 | 11 | NOT STARTED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 3 | 12 | NOT STARTED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 3 | 13 | NOT STARTED | ENABLE POLICIES | -- should resume the execution CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:96: WARNING: resuming the migration of the continuous aggregate "public.conditions_summary_daily" psql:include/cagg_migrate_common.sql:96: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('1008' AS integer), NULL);" SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------- 3 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "1008"} 3 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 3 | 3 | FINISHED | DISABLE POLICIES | {"policies": null} 3 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "1008", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "integer"} 3 | 5 | FINISHED | COPY DATA | {"end_ts": "240", "start_ts": "0", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 6 | FINISHED | COPY DATA | {"end_ts": "480", "start_ts": "240", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 7 | FINISHED | COPY DATA | {"end_ts": "720", "start_ts": "480", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 8 | FINISHED | COPY DATA | {"end_ts": "960", "start_ts": "720", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 9 | FINISHED | COPY DATA | {"end_ts": "1200", "start_ts": "960", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 10 | FINISHED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_daily_new"} 3 | 11 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 3 | 12 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 3 | 13 | FINISHED | ENABLE POLICIES | \set ON_ERROR_STOP 0 -- should error because plan already exists CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); psql:include/cagg_migrate_common.sql:101: ERROR: plan already exists for materialized hypertable 3 CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:102: ERROR: plan already exists for continuous aggregate public.conditions_summary_daily \set ON_ERROR_STOP 1 -- policies for test ALTER MATERIALIZED VIEW conditions_summary_daily SET (timescaledb.compress=true); psql:include/cagg_migrate_common.sql:106: NOTICE: defaulting compress_orderby to bucket \if :IS_TIME_DIMENSION SELECT add_retention_policy('conditions_summary_daily', '30 days'::interval); SELECT add_continuous_aggregate_policy('conditions_summary_daily', '30 days'::interval, '1 day'::interval, '1 hour'::interval); SELECT add_compression_policy('conditions_summary_daily', '45 days'::interval); \else SELECT add_retention_policy('conditions_summary_daily', '400'::integer); add_retention_policy ---------------------- 1000 SELECT add_continuous_aggregate_policy('conditions_summary_daily', '50'::integer, '1'::integer, '1 hour'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT add_compression_policy('conditions_summary_daily', '100'::integer); add_compression_policy ------------------------ 1002 \endif SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'USER_VIEW_SCHEMA' AND hypertable_name = :'USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------------------------------------------------------+------------+---------------+-------------------+--------------------------+------------------------+------------------------------------------- 1000 | Retention Policy [1000] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | {"drop_after": 400, "hypertable_id": 3} | | | public | conditions_summary_daily | _timescaledb_functions | policy_retention_check 1001 | Refresh Continuous Aggregate Policy [1001] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 3} | | | public | conditions_summary_daily | _timescaledb_functions | policy_refresh_continuous_aggregate_check 1002 | Columnstore Policy [1002] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | {"hypertable_id": 3, "compress_after": 100} | | | public | conditions_summary_daily | _timescaledb_functions | policy_compression_check -- execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:125: NOTICE: drop cascades to 10 other objects TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:126: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:127: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:127: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('1008' AS integer), NULL);" SELECT ca.raw_hypertable_id AS "NEW_RAW_HYPERTABLE_ID", h.schema_name AS "NEW_MAT_SCHEMA_NAME", h.table_name AS "NEW_MAT_TABLE_NAME", partial_view_name AS "NEW_PART_VIEW_NAME", partial_view_schema AS "NEW_PART_VIEW_SCHEMA", direct_view_name AS "NEW_DIR_VIEW_NAME", direct_view_schema AS "NEW_DIR_VIEW_SCHEMA", user_view_name AS "NEW_USER_VIEW_NAME", user_view_schema AS "NEW_USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily_new' \gset \d+ conditions_summary_daily_new View "public.conditions_summary_daily_new" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_7.bucket, _materialized_hypertable_7.min, _materialized_hypertable_7.max, _materialized_hypertable_7.avg, _materialized_hypertable_7.sum FROM _timescaledb_internal._materialized_hypertable_7 WHERE _materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.cagg_watermark(7)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(7)::integer, '-2147483648'::integer) GROUP BY (time_bucket(24, conditions."time")); SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'NEW_USER_VIEW_SCHEMA' AND hypertable_name = :'NEW_USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------------------------------------------------------+------------+---------------+-------------------+------------------------------+------------------------+------------------------------------------- 1003 | Retention Policy [1003] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | {"drop_after": 400, "hypertable_id": 7} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_retention_check 1004 | Refresh Continuous Aggregate Policy [1004] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 7} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_refresh_continuous_aggregate_check 1005 | Columnstore Policy [1005] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | {"hypertable_id": 7, "compress_after": 100} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_compression_check SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------- 3 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "1008"} 3 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 3 | 3 | FINISHED | DISABLE POLICIES | {"policies": [1000, 1002]} 3 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "1008", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "integer"} 3 | 5 | FINISHED | COPY DATA | {"end_ts": "240", "start_ts": "0", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 6 | FINISHED | COPY DATA | {"end_ts": "480", "start_ts": "240", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 7 | FINISHED | COPY DATA | {"end_ts": "720", "start_ts": "480", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 8 | FINISHED | COPY DATA | {"end_ts": "960", "start_ts": "720", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 9 | FINISHED | COPY DATA | {"end_ts": "1200", "start_ts": "960", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 3 | 10 | FINISHED | COPY POLICIES | {"policies": [1000, 1001, 1002], "cagg_name_new": "conditions_summary_daily_new"} 3 | 11 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 3 | 12 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 3 | 13 | FINISHED | ENABLE POLICIES | {"policies": [1003, 1004, 1005, 1000, 1001, 1002]} -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- -- compress both caggs SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily') c ORDER BY c::regclass::text; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_3_102_chunk _timescaledb_internal._hyper_3_103_chunk _timescaledb_internal._hyper_3_104_chunk _timescaledb_internal._hyper_3_105_chunk _timescaledb_internal._hyper_3_106_chunk _timescaledb_internal._hyper_3_107_chunk _timescaledb_internal._hyper_3_108_chunk _timescaledb_internal._hyper_3_109_chunk _timescaledb_internal._hyper_3_110_chunk _timescaledb_internal._hyper_3_111_chunk SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily_new') c ORDER BY c::regclass::text; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_7_128_chunk _timescaledb_internal._hyper_7_129_chunk _timescaledb_internal._hyper_7_130_chunk _timescaledb_internal._hyper_7_131_chunk _timescaledb_internal._hyper_7_132_chunk _timescaledb_internal._hyper_7_133_chunk _timescaledb_internal._hyper_7_134_chunk _timescaledb_internal._hyper_7_135_chunk _timescaledb_internal._hyper_7_136_chunk _timescaledb_internal._hyper_7_137_chunk -- check migrated data after compression. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- CREATE OR REPLACE VIEW cagg_jobs AS SELECT user_view_schema AS schema, user_view_name AS name, bgw_job.* FROM _timescaledb_config.bgw_job JOIN _timescaledb_catalog.continuous_agg ON mat_hypertable_id = hypertable_id ORDER BY bgw_job.id; -- test migration overriding the new cagg and keeping the old DROP MATERIALIZED VIEW conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:177: NOTICE: drop cascades to 10 other objects TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:178: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1000 | Retention Policy [1000] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 3 | {"drop_after": 400, "hypertable_id": 3} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1001 | Refresh Continuous Aggregate Policy [1001] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 3 | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 3} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1002 | Columnstore Policy [1002] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 3 | {"hypertable_id": 3, "compress_after": 100} | _timescaledb_functions | policy_compression_check | CALL cagg_migrate('conditions_summary_daily', override => TRUE); psql:include/cagg_migrate_common.sql:181: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:181: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily', CAST('1008' AS integer), NULL);" -- cagg with the new format because it was overriden \d+ conditions_summary_daily View "public.conditions_summary_daily" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_9.bucket, _materialized_hypertable_9.min, _materialized_hypertable_9.max, _materialized_hypertable_9.avg, _materialized_hypertable_9.sum FROM _timescaledb_internal._materialized_hypertable_9 WHERE _materialized_hypertable_9.bucket < COALESCE(_timescaledb_functions.cagg_watermark(9)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(9)::integer, '-2147483648'::integer) GROUP BY (time_bucket(24, conditions."time")); -- cagg with the old format because it was overriden \d+ conditions_summary_daily_old View "public.conditions_summary_daily_old" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_3.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE _materialized_hypertable_3.bucket < COALESCE(_timescaledb_functions.cagg_watermark(3)::integer, '-2147483648'::integer) GROUP BY _materialized_hypertable_3.bucket UNION ALL SELECT time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(3)::integer, '-2147483648'::integer) GROUP BY (time_bucket(24, conditions."time")); \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:188: ERROR: relation "conditions_summary_daily_new" does not exist at character 15 \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1006 | Retention Policy [1006] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 9 | {"drop_after": 400, "hypertable_id": 9} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1007 | Refresh Continuous Aggregate Policy [1007] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 9 | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 9} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1008 | Columnstore Policy [1008] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 9 | {"hypertable_id": 9, "compress_after": 100} | _timescaledb_functions | policy_compression_check | -- should return the old cagg jobs SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily_old | 1000 | Retention Policy [1000] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 3 | {"drop_after": 400, "hypertable_id": 3} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily_old | 1001 | Refresh Continuous Aggregate Policy [1001] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 3 | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 3} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily_old | 1002 | Columnstore Policy [1002] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 3 | {"hypertable_id": 3, "compress_after": 100} | _timescaledb_functions | policy_compression_check | -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- test migration overriding the new cagg and removing the old TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:198: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; psql:include/cagg_migrate_common.sql:199: NOTICE: drop cascades to 10 other objects ALTER MATERIALIZED VIEW conditions_summary_daily_old RENAME TO conditions_summary_daily; -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1000 | Retention Policy [1000] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 3 | {"drop_after": 400, "hypertable_id": 3} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1001 | Refresh Continuous Aggregate Policy [1001] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 3 | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 3} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1002 | Columnstore Policy [1002] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 3 | {"hypertable_id": 3, "compress_after": 100} | _timescaledb_functions | policy_compression_check | CALL cagg_migrate('conditions_summary_daily', override => TRUE, drop_old => TRUE); psql:include/cagg_migrate_common.sql:203: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:203: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily', CAST('1008' AS integer), NULL);" psql:include/cagg_migrate_common.sql:203: NOTICE: drop cascades to 10 other objects psql:include/cagg_migrate_common.sql:203: NOTICE: job 1000 not found, skipping psql:include/cagg_migrate_common.sql:203: NOTICE: job 1001 not found, skipping psql:include/cagg_migrate_common.sql:203: NOTICE: job 1002 not found, skipping -- cagg with the new format because it was overriden \d+ conditions_summary_daily View "public.conditions_summary_daily" Column | Type | Collation | Nullable | Default | Storage | Description --------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_11.bucket, _materialized_hypertable_11.min, _materialized_hypertable_11.max, _materialized_hypertable_11.avg, _materialized_hypertable_11.sum FROM _timescaledb_internal._materialized_hypertable_11 WHERE _materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.cagg_watermark(11)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(11)::integer, '-2147483648'::integer) GROUP BY (time_bucket(24, conditions."time")); \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:208: ERROR: relation "conditions_summary_daily_new" does not exist at character 15 -- should fail because the old cagg was removed SELECT * FROM conditions_summary_daily_old; psql:include/cagg_migrate_common.sql:210: ERROR: relation "conditions_summary_daily_old" does not exist at character 15 \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+----------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1009 | Retention Policy [1009] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 11 | {"drop_after": 400, "hypertable_id": 11} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1010 | Refresh Continuous Aggregate Policy [1010] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 11 | {"end_offset": 1, "start_offset": 50, "mat_hypertable_id": 11} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1011 | Columnstore Policy [1011] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 11 | {"hypertable_id": 11, "compress_after": 100} | _timescaledb_functions | policy_compression_check | -- should return no rows because the old cagg was removed SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- permission tests TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:220: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" GRANT ALL ON TABLE conditions TO :ROLE_DEFAULT_PERM_USER; ALTER MATERIALIZED VIEW conditions_summary_weekly OWNER TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan' catalog table CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:227: ERROR: permission denied for table continuous_agg_migrate_plan \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step' catalog table CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:237: ERROR: permission denied for table continuous_agg_migrate_plan_step \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step_step_id_seq' catalog sequence CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:247: ERROR: permission denied for sequence continuous_agg_migrate_plan_step_step_id_seq \set ON_ERROR_STOP 1 RESET ROLE; GRANT USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- all necessary permissions granted CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:256: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_weekly_new', CAST('1008' AS integer), NULL);" -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_weekly EXCEPT SELECT * FROM conditions_summary_weekly_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------- 4 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "1008"} 4 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_weekly_new"} 4 | 3 | FINISHED | DISABLE POLICIES | {"policies": null} 4 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "1008", "cagg_name_new": "conditions_summary_weekly_new", "window_start_type": "integer"} 4 | 5 | FINISHED | COPY DATA | {"end_ts": "1680", "start_ts": "0", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "integer"} 4 | 6 | FINISHED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_weekly_new"} 4 | 7 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_weekly_new"} 4 | 8 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_weekly_new"} 4 | 9 | FINISHED | ENABLE POLICIES | RESET ROLE; -- according to the official documentation trying to execute a procedure with -- transaction control statements inside an explicit transaction should fail: -- https://www.postgresql.org/docs/current/sql-call.html -- `If CALL is executed in a transaction block, then the called procedure cannot -- execute transaction control statements. Transaction control statements are only -- allowed if CALL is executed in its own transaction.` TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:273: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_weekly_new; psql:include/cagg_migrate_common.sql:274: NOTICE: drop cascades to 6 other objects \set ON_ERROR_STOP 0 BEGIN; -- should fail with `invalid transaction termination` CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:279: ERROR: invalid transaction termination ROLLBACK; \set ON_ERROR_STOP 1 CREATE FUNCTION execute_migration() RETURNS void AS $$ BEGIN CALL cagg_migrate('conditions_summary_weekly'); RETURN; END; $$ LANGUAGE plpgsql; \set ON_ERROR_STOP 0 -- execute migration inside a plpgsql function BEGIN; -- should fail with `invalid transaction termination` SELECT execute_migration(); psql:include/cagg_migrate_common.sql:296: ERROR: invalid transaction termination ROLLBACK; \set ON_ERROR_STOP 1 -- -- test dropping chunks -- -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------+--------- -- drop 1 chunk \if :IS_TIME_DIMENSION SELECT drop_chunks('conditions', older_than => CAST('2022-01-08 00:00:00-00' AS :TIME_DIMENSION_DATATYPE)); \else SELECT drop_chunks('conditions', older_than => 10); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk \endif -- now he have one chunk marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------------+--------- _hyper_1_1_chunk | t -- this migration should remove the chunk metadata marked as dropped CALL cagg_migrate('conditions_summary_weekly', override => TRUE, drop_old => TRUE); psql:include/cagg_migrate_common.sql:328: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_weekly', CAST('1008' AS integer), NULL);" psql:include/cagg_migrate_common.sql:328: NOTICE: drop cascades to 6 other objects psql:include/cagg_migrate_common.sql:328: INFO: Removing metadata of chunk 1 from hypertable 1 -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------+--------- -- cleanup DROP FUNCTION execute_migration(); REVOKE SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan FROM :ROLE_DEFAULT_PERM_USER; REVOKE USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq FROM :ROLE_DEFAULT_PERM_USER; TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:342: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; psql:include/cagg_migrate_common.sql:343: NOTICE: drop cascades to 10 other objects DROP MATERIALIZED VIEW conditions_summary_weekly; psql:include/cagg_migrate_common.sql:344: NOTICE: drop cascades to 6 other objects DROP TABLE conditions; SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t -- ######################################################## -- ## TIMESTAMP data type tests -- ######################################################## \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMP \ir include/cagg_migrate_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Setup some variables SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset -- restore dump SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \ir :TEST_SCHEMA_FILE -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" timestamp without time zone NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_6 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_7 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_8 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_6 ( bucket timestamp without time zone NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_7 ( bucket timestamp without time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_8 ( bucket timestamp without time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_6 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._partial_view_7 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_8 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_7.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_7 WHERE (_materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) GROUP BY _materialized_hypertable_7.bucket UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_6.bucket, _materialized_hypertable_6.min, _materialized_hypertable_6.max, _materialized_hypertable_6.avg, _materialized_hypertable_6.sum FROM _timescaledb_internal._materialized_hypertable_6 WHERE (_materialized_hypertable_6.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp without time zone)) UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_8.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_8 WHERE (_materialized_hypertable_8.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp without time zone)) GROUP BY _materialized_hypertable_8.bucket UNION ALL SELECT public.time_bucket('7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('7 days'::interval, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 8, true); setval -------- 8 SELECT pg_catalog.setval('_timescaledb_catalog.hypertable_id_seq', 8, true); setval -------- 8 CREATE INDEX _materialized_hypertable_6_bucket_idx ON _timescaledb_internal._materialized_hypertable_6 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_7_bucket_idx ON _timescaledb_internal._materialized_hypertable_7 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_8_bucket_idx ON _timescaledb_internal._materialized_hypertable_8 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t -- Make sure no scheduled job will be executed during the regression tests SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature) SELECT generate_series('2022-01-01 00:00:00-00'::timestamptz, '2022-12-31 23:59:59-00'::timestamptz, '1 hour'), 0.25; \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM public.conditions $$; INSERT INTO conditions ("time", temperature) SELECT generate_series(1, 1000, 1), 0.25; \endif CALL refresh_continuous_aggregate('conditions_summary_daily', NULL, NULL); CALL refresh_continuous_aggregate('conditions_summary_weekly', NULL, NULL); \set ON_ERROR_STOP 0 -- should fail because we don't need to migrate finalized caggs CALL cagg_migrate('conditions_summary_daily_new'); psql:include/cagg_migrate_common.sql:42: ERROR: continuous aggregate "public.conditions_summary_daily_new" does not require any migration -- should fail relation does not exist CALL cagg_migrate('conditions_summary_not_cagg'); psql:include/cagg_migrate_common.sql:45: ERROR: relation "conditions_summary_not_cagg" does not exist at character 19 CREATE TABLE conditions_summary_not_cagg(); -- should fail continuous agg does not exist CALL cagg_migrate('conditions_summary_not_cagg'); psql:include/cagg_migrate_common.sql:50: ERROR: continuous aggregate "public.conditions_summary_not_cagg" does not exist \set ON_ERROR_STOP 1 DROP TABLE conditions_summary_not_cagg; SELECT ca.raw_hypertable_id AS "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", partial_view_schema AS "PART_VIEW_SCHEMA", direct_view_name AS "DIR_VIEW_NAME", direct_view_schema AS "DIR_VIEW_SCHEMA", user_view_name AS "USER_VIEW_NAME", user_view_schema AS "USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily' \gset \set ON_ERROR_STOP 0 -- should fail because the new cagg with suffix '_new' already exists CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:74: ERROR: continuous aggregate "public.conditions_summary_daily_new" already exists \set ON_ERROR_STOP 1 -- remove the new cagg to execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; -- get and set all the cagg data SELECT _timescaledb_functions.cagg_migrate_pre_validation( 'public', 'conditions_summary_daily', 'conditions_summary_daily_new' ) AS "CAGG_DATA" \gset CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); \x on SELECT mat_hypertable_id, user_view_definition FROM _timescaledb_catalog.continuous_agg_migrate_plan; -[ RECORD 1 ]--------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mat_hypertable_id | 7 user_view_definition | SELECT _materialized_hypertable_7.bucket, + | _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_2_2, NULL::numeric) AS min, + | _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_3_3, NULL::numeric) AS max, + | _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_4_4, NULL::numeric) AS avg, + | _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_5_5, NULL::numeric) AS sum + | FROM _timescaledb_internal._materialized_hypertable_7 + | WHERE (_materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone))+ | GROUP BY _materialized_hypertable_7.bucket + | UNION ALL + | SELECT public.time_bucket('@ 1 day'::interval, conditions."time") AS bucket, + | min(conditions.temperature) AS min, + | max(conditions.temperature) AS max, + | avg(conditions.temperature) AS avg, + | sum(conditions.temperature) AS sum + | FROM public.conditions + | WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) + | GROUP BY (public.time_bucket('@ 1 day'::interval, conditions."time")); \x off SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+-------------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 7 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2023-01-01 00:00:00"} 7 | 2 | NOT STARTED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 7 | 3 | NOT STARTED | DISABLE POLICIES | {"policies": null} 7 | 4 | NOT STARTED | REFRESH NEW CAGG | {"window_start": "2023-01-01 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "timestamp without time zone"} 7 | 5 | NOT STARTED | COPY DATA | {"end_ts": "2022-01-10 00:00:00", "start_ts": "2021-12-31 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 6 | NOT STARTED | COPY DATA | {"end_ts": "2022-01-20 00:00:00", "start_ts": "2022-01-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 7 | NOT STARTED | COPY DATA | {"end_ts": "2022-01-30 00:00:00", "start_ts": "2022-01-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 8 | NOT STARTED | COPY DATA | {"end_ts": "2022-02-09 00:00:00", "start_ts": "2022-01-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 9 | NOT STARTED | COPY DATA | {"end_ts": "2022-02-19 00:00:00", "start_ts": "2022-02-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 10 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-01 00:00:00", "start_ts": "2022-02-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 11 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-11 00:00:00", "start_ts": "2022-03-01 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 12 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-21 00:00:00", "start_ts": "2022-03-11 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 13 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-31 00:00:00", "start_ts": "2022-03-21 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 14 | NOT STARTED | COPY DATA | {"end_ts": "2022-04-10 00:00:00", "start_ts": "2022-03-31 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 15 | NOT STARTED | COPY DATA | {"end_ts": "2022-04-20 00:00:00", "start_ts": "2022-04-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 16 | NOT STARTED | COPY DATA | {"end_ts": "2022-04-30 00:00:00", "start_ts": "2022-04-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 17 | NOT STARTED | COPY DATA | {"end_ts": "2022-05-10 00:00:00", "start_ts": "2022-04-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 18 | NOT STARTED | COPY DATA | {"end_ts": "2022-05-20 00:00:00", "start_ts": "2022-05-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 19 | NOT STARTED | COPY DATA | {"end_ts": "2022-05-30 00:00:00", "start_ts": "2022-05-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 20 | NOT STARTED | COPY DATA | {"end_ts": "2022-06-09 00:00:00", "start_ts": "2022-05-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 21 | NOT STARTED | COPY DATA | {"end_ts": "2022-06-19 00:00:00", "start_ts": "2022-06-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 22 | NOT STARTED | COPY DATA | {"end_ts": "2022-06-29 00:00:00", "start_ts": "2022-06-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 23 | NOT STARTED | COPY DATA | {"end_ts": "2022-07-09 00:00:00", "start_ts": "2022-06-29 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 24 | NOT STARTED | COPY DATA | {"end_ts": "2022-07-19 00:00:00", "start_ts": "2022-07-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 25 | NOT STARTED | COPY DATA | {"end_ts": "2022-07-29 00:00:00", "start_ts": "2022-07-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 26 | NOT STARTED | COPY DATA | {"end_ts": "2022-08-08 00:00:00", "start_ts": "2022-07-29 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 27 | NOT STARTED | COPY DATA | {"end_ts": "2022-08-18 00:00:00", "start_ts": "2022-08-08 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 28 | NOT STARTED | COPY DATA | {"end_ts": "2022-08-28 00:00:00", "start_ts": "2022-08-18 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 29 | NOT STARTED | COPY DATA | {"end_ts": "2022-09-07 00:00:00", "start_ts": "2022-08-28 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 30 | NOT STARTED | COPY DATA | {"end_ts": "2022-09-17 00:00:00", "start_ts": "2022-09-07 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 31 | NOT STARTED | COPY DATA | {"end_ts": "2022-09-27 00:00:00", "start_ts": "2022-09-17 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 32 | NOT STARTED | COPY DATA | {"end_ts": "2022-10-07 00:00:00", "start_ts": "2022-09-27 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 33 | NOT STARTED | COPY DATA | {"end_ts": "2022-10-17 00:00:00", "start_ts": "2022-10-07 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 34 | NOT STARTED | COPY DATA | {"end_ts": "2022-10-27 00:00:00", "start_ts": "2022-10-17 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 35 | NOT STARTED | COPY DATA | {"end_ts": "2022-11-06 00:00:00", "start_ts": "2022-10-27 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 36 | NOT STARTED | COPY DATA | {"end_ts": "2022-11-16 00:00:00", "start_ts": "2022-11-06 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 37 | NOT STARTED | COPY DATA | {"end_ts": "2022-11-26 00:00:00", "start_ts": "2022-11-16 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 38 | NOT STARTED | COPY DATA | {"end_ts": "2022-12-06 00:00:00", "start_ts": "2022-11-26 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 39 | NOT STARTED | COPY DATA | {"end_ts": "2022-12-16 00:00:00", "start_ts": "2022-12-06 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 40 | NOT STARTED | COPY DATA | {"end_ts": "2022-12-26 00:00:00", "start_ts": "2022-12-16 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 41 | NOT STARTED | COPY DATA | {"end_ts": "2023-01-05 00:00:00", "start_ts": "2022-12-26 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 42 | NOT STARTED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_daily_new"} 7 | 43 | NOT STARTED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 7 | 44 | NOT STARTED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 7 | 45 | NOT STARTED | ENABLE POLICIES | -- should resume the execution CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:96: WARNING: resuming the migration of the continuous aggregate "public.conditions_summary_daily" psql:include/cagg_migrate_common.sql:96: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('2023-01-01 00:00:00' AS timestamp without time zone), NULL);" SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 7 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2023-01-01 00:00:00"} 7 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 7 | 3 | FINISHED | DISABLE POLICIES | {"policies": null} 7 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "2023-01-01 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "timestamp without time zone"} 7 | 5 | FINISHED | COPY DATA | {"end_ts": "2022-01-10 00:00:00", "start_ts": "2021-12-31 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 6 | FINISHED | COPY DATA | {"end_ts": "2022-01-20 00:00:00", "start_ts": "2022-01-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 7 | FINISHED | COPY DATA | {"end_ts": "2022-01-30 00:00:00", "start_ts": "2022-01-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 8 | FINISHED | COPY DATA | {"end_ts": "2022-02-09 00:00:00", "start_ts": "2022-01-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 9 | FINISHED | COPY DATA | {"end_ts": "2022-02-19 00:00:00", "start_ts": "2022-02-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 10 | FINISHED | COPY DATA | {"end_ts": "2022-03-01 00:00:00", "start_ts": "2022-02-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 11 | FINISHED | COPY DATA | {"end_ts": "2022-03-11 00:00:00", "start_ts": "2022-03-01 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 12 | FINISHED | COPY DATA | {"end_ts": "2022-03-21 00:00:00", "start_ts": "2022-03-11 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 13 | FINISHED | COPY DATA | {"end_ts": "2022-03-31 00:00:00", "start_ts": "2022-03-21 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 14 | FINISHED | COPY DATA | {"end_ts": "2022-04-10 00:00:00", "start_ts": "2022-03-31 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 15 | FINISHED | COPY DATA | {"end_ts": "2022-04-20 00:00:00", "start_ts": "2022-04-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 16 | FINISHED | COPY DATA | {"end_ts": "2022-04-30 00:00:00", "start_ts": "2022-04-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 17 | FINISHED | COPY DATA | {"end_ts": "2022-05-10 00:00:00", "start_ts": "2022-04-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 18 | FINISHED | COPY DATA | {"end_ts": "2022-05-20 00:00:00", "start_ts": "2022-05-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 19 | FINISHED | COPY DATA | {"end_ts": "2022-05-30 00:00:00", "start_ts": "2022-05-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 20 | FINISHED | COPY DATA | {"end_ts": "2022-06-09 00:00:00", "start_ts": "2022-05-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 21 | FINISHED | COPY DATA | {"end_ts": "2022-06-19 00:00:00", "start_ts": "2022-06-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 22 | FINISHED | COPY DATA | {"end_ts": "2022-06-29 00:00:00", "start_ts": "2022-06-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 23 | FINISHED | COPY DATA | {"end_ts": "2022-07-09 00:00:00", "start_ts": "2022-06-29 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 24 | FINISHED | COPY DATA | {"end_ts": "2022-07-19 00:00:00", "start_ts": "2022-07-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 25 | FINISHED | COPY DATA | {"end_ts": "2022-07-29 00:00:00", "start_ts": "2022-07-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 26 | FINISHED | COPY DATA | {"end_ts": "2022-08-08 00:00:00", "start_ts": "2022-07-29 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 27 | FINISHED | COPY DATA | {"end_ts": "2022-08-18 00:00:00", "start_ts": "2022-08-08 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 28 | FINISHED | COPY DATA | {"end_ts": "2022-08-28 00:00:00", "start_ts": "2022-08-18 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 29 | FINISHED | COPY DATA | {"end_ts": "2022-09-07 00:00:00", "start_ts": "2022-08-28 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 30 | FINISHED | COPY DATA | {"end_ts": "2022-09-17 00:00:00", "start_ts": "2022-09-07 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 31 | FINISHED | COPY DATA | {"end_ts": "2022-09-27 00:00:00", "start_ts": "2022-09-17 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 32 | FINISHED | COPY DATA | {"end_ts": "2022-10-07 00:00:00", "start_ts": "2022-09-27 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 33 | FINISHED | COPY DATA | {"end_ts": "2022-10-17 00:00:00", "start_ts": "2022-10-07 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 34 | FINISHED | COPY DATA | {"end_ts": "2022-10-27 00:00:00", "start_ts": "2022-10-17 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 35 | FINISHED | COPY DATA | {"end_ts": "2022-11-06 00:00:00", "start_ts": "2022-10-27 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 36 | FINISHED | COPY DATA | {"end_ts": "2022-11-16 00:00:00", "start_ts": "2022-11-06 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 37 | FINISHED | COPY DATA | {"end_ts": "2022-11-26 00:00:00", "start_ts": "2022-11-16 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 38 | FINISHED | COPY DATA | {"end_ts": "2022-12-06 00:00:00", "start_ts": "2022-11-26 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 39 | FINISHED | COPY DATA | {"end_ts": "2022-12-16 00:00:00", "start_ts": "2022-12-06 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 40 | FINISHED | COPY DATA | {"end_ts": "2022-12-26 00:00:00", "start_ts": "2022-12-16 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 41 | FINISHED | COPY DATA | {"end_ts": "2023-01-05 00:00:00", "start_ts": "2022-12-26 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 42 | FINISHED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_daily_new"} 7 | 43 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 7 | 44 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 7 | 45 | FINISHED | ENABLE POLICIES | \set ON_ERROR_STOP 0 -- should error because plan already exists CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); psql:include/cagg_migrate_common.sql:101: ERROR: plan already exists for materialized hypertable 7 CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:102: ERROR: plan already exists for continuous aggregate public.conditions_summary_daily \set ON_ERROR_STOP 1 -- policies for test ALTER MATERIALIZED VIEW conditions_summary_daily SET (timescaledb.compress=true); psql:include/cagg_migrate_common.sql:106: NOTICE: defaulting compress_orderby to bucket \if :IS_TIME_DIMENSION SELECT add_retention_policy('conditions_summary_daily', '30 days'::interval); add_retention_policy ---------------------- 1012 SELECT add_continuous_aggregate_policy('conditions_summary_daily', '30 days'::interval, '1 day'::interval, '1 hour'::interval); add_continuous_aggregate_policy --------------------------------- 1013 SELECT add_compression_policy('conditions_summary_daily', '45 days'::interval); add_compression_policy ------------------------ 1014 \else SELECT add_retention_policy('conditions_summary_daily', '400'::integer); SELECT add_continuous_aggregate_policy('conditions_summary_daily', '50'::integer, '1'::integer, '1 hour'::interval); SELECT add_compression_policy('conditions_summary_daily', '100'::integer); \endif SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'USER_VIEW_SCHEMA' AND hypertable_name = :'USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+--------------------------------------------------------------------------------+------------+---------------+-------------------+--------------------------+------------------------+------------------------------------------- 1012 | Retention Policy [1012] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | {"drop_after": "@ 30 days", "hypertable_id": 7} | | | public | conditions_summary_daily | _timescaledb_functions | policy_retention_check 1013 | Refresh Continuous Aggregate Policy [1013] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 7} | | | public | conditions_summary_daily | _timescaledb_functions | policy_refresh_continuous_aggregate_check 1014 | Columnstore Policy [1014] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | {"hypertable_id": 7, "compress_after": "@ 45 days"} | | | public | conditions_summary_daily | _timescaledb_functions | policy_compression_check -- execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:125: NOTICE: drop cascades to 6 other objects TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:126: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:127: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:127: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('2023-01-01 00:00:00' AS timestamp without time zone), NULL);" SELECT ca.raw_hypertable_id AS "NEW_RAW_HYPERTABLE_ID", h.schema_name AS "NEW_MAT_SCHEMA_NAME", h.table_name AS "NEW_MAT_TABLE_NAME", partial_view_name AS "NEW_PART_VIEW_NAME", partial_view_schema AS "NEW_PART_VIEW_SCHEMA", direct_view_name AS "NEW_DIR_VIEW_NAME", direct_view_schema AS "NEW_DIR_VIEW_SCHEMA", user_view_name AS "NEW_USER_VIEW_NAME", user_view_schema AS "NEW_USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily_new' \gset \d+ conditions_summary_daily_new View "public.conditions_summary_daily_new" Column | Type | Collation | Nullable | Default | Storage | Description --------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_11.bucket, _materialized_hypertable_11.min, _materialized_hypertable_11.max, _materialized_hypertable_11.avg, _materialized_hypertable_11.sum FROM _timescaledb_internal._materialized_hypertable_11 WHERE _materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'NEW_USER_VIEW_SCHEMA' AND hypertable_name = :'NEW_USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------------------------------------------------------------------------+------------+---------------+-------------------+------------------------------+------------------------+------------------------------------------- 1015 | Retention Policy [1015] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | {"drop_after": "@ 30 days", "hypertable_id": 11} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_retention_check 1016 | Refresh Continuous Aggregate Policy [1016] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 11} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_refresh_continuous_aggregate_check 1017 | Columnstore Policy [1017] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | {"hypertable_id": 11, "compress_after": "@ 45 days"} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_compression_check SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 7 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2023-01-01 00:00:00"} 7 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 7 | 3 | FINISHED | DISABLE POLICIES | {"policies": [1012, 1014]} 7 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "2023-01-01 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "timestamp without time zone"} 7 | 5 | FINISHED | COPY DATA | {"end_ts": "2022-01-10 00:00:00", "start_ts": "2021-12-31 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 6 | FINISHED | COPY DATA | {"end_ts": "2022-01-20 00:00:00", "start_ts": "2022-01-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 7 | FINISHED | COPY DATA | {"end_ts": "2022-01-30 00:00:00", "start_ts": "2022-01-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 8 | FINISHED | COPY DATA | {"end_ts": "2022-02-09 00:00:00", "start_ts": "2022-01-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 9 | FINISHED | COPY DATA | {"end_ts": "2022-02-19 00:00:00", "start_ts": "2022-02-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 10 | FINISHED | COPY DATA | {"end_ts": "2022-03-01 00:00:00", "start_ts": "2022-02-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 11 | FINISHED | COPY DATA | {"end_ts": "2022-03-11 00:00:00", "start_ts": "2022-03-01 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 12 | FINISHED | COPY DATA | {"end_ts": "2022-03-21 00:00:00", "start_ts": "2022-03-11 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 13 | FINISHED | COPY DATA | {"end_ts": "2022-03-31 00:00:00", "start_ts": "2022-03-21 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 14 | FINISHED | COPY DATA | {"end_ts": "2022-04-10 00:00:00", "start_ts": "2022-03-31 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 15 | FINISHED | COPY DATA | {"end_ts": "2022-04-20 00:00:00", "start_ts": "2022-04-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 16 | FINISHED | COPY DATA | {"end_ts": "2022-04-30 00:00:00", "start_ts": "2022-04-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 17 | FINISHED | COPY DATA | {"end_ts": "2022-05-10 00:00:00", "start_ts": "2022-04-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 18 | FINISHED | COPY DATA | {"end_ts": "2022-05-20 00:00:00", "start_ts": "2022-05-10 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 19 | FINISHED | COPY DATA | {"end_ts": "2022-05-30 00:00:00", "start_ts": "2022-05-20 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 20 | FINISHED | COPY DATA | {"end_ts": "2022-06-09 00:00:00", "start_ts": "2022-05-30 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 21 | FINISHED | COPY DATA | {"end_ts": "2022-06-19 00:00:00", "start_ts": "2022-06-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 22 | FINISHED | COPY DATA | {"end_ts": "2022-06-29 00:00:00", "start_ts": "2022-06-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 23 | FINISHED | COPY DATA | {"end_ts": "2022-07-09 00:00:00", "start_ts": "2022-06-29 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 24 | FINISHED | COPY DATA | {"end_ts": "2022-07-19 00:00:00", "start_ts": "2022-07-09 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 25 | FINISHED | COPY DATA | {"end_ts": "2022-07-29 00:00:00", "start_ts": "2022-07-19 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 26 | FINISHED | COPY DATA | {"end_ts": "2022-08-08 00:00:00", "start_ts": "2022-07-29 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 27 | FINISHED | COPY DATA | {"end_ts": "2022-08-18 00:00:00", "start_ts": "2022-08-08 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 28 | FINISHED | COPY DATA | {"end_ts": "2022-08-28 00:00:00", "start_ts": "2022-08-18 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 29 | FINISHED | COPY DATA | {"end_ts": "2022-09-07 00:00:00", "start_ts": "2022-08-28 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 30 | FINISHED | COPY DATA | {"end_ts": "2022-09-17 00:00:00", "start_ts": "2022-09-07 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 31 | FINISHED | COPY DATA | {"end_ts": "2022-09-27 00:00:00", "start_ts": "2022-09-17 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 32 | FINISHED | COPY DATA | {"end_ts": "2022-10-07 00:00:00", "start_ts": "2022-09-27 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 33 | FINISHED | COPY DATA | {"end_ts": "2022-10-17 00:00:00", "start_ts": "2022-10-07 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 34 | FINISHED | COPY DATA | {"end_ts": "2022-10-27 00:00:00", "start_ts": "2022-10-17 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 35 | FINISHED | COPY DATA | {"end_ts": "2022-11-06 00:00:00", "start_ts": "2022-10-27 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 36 | FINISHED | COPY DATA | {"end_ts": "2022-11-16 00:00:00", "start_ts": "2022-11-06 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 37 | FINISHED | COPY DATA | {"end_ts": "2022-11-26 00:00:00", "start_ts": "2022-11-16 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 38 | FINISHED | COPY DATA | {"end_ts": "2022-12-06 00:00:00", "start_ts": "2022-11-26 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 39 | FINISHED | COPY DATA | {"end_ts": "2022-12-16 00:00:00", "start_ts": "2022-12-06 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 40 | FINISHED | COPY DATA | {"end_ts": "2022-12-26 00:00:00", "start_ts": "2022-12-16 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 41 | FINISHED | COPY DATA | {"end_ts": "2023-01-05 00:00:00", "start_ts": "2022-12-26 00:00:00", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 7 | 42 | FINISHED | COPY POLICIES | {"policies": [1012, 1013, 1014], "cagg_name_new": "conditions_summary_daily_new"} 7 | 43 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 7 | 44 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 7 | 45 | FINISHED | ENABLE POLICIES | {"policies": [1015, 1016, 1017, 1012, 1013, 1014]} -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- -- compress both caggs SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily') c ORDER BY c::regclass::text; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_7_243_chunk _timescaledb_internal._hyper_7_244_chunk _timescaledb_internal._hyper_7_245_chunk _timescaledb_internal._hyper_7_246_chunk _timescaledb_internal._hyper_7_247_chunk _timescaledb_internal._hyper_7_248_chunk SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily_new') c ORDER BY c::regclass::text; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_262_chunk _timescaledb_internal._hyper_11_263_chunk _timescaledb_internal._hyper_11_264_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_266_chunk -- check migrated data after compression. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- CREATE OR REPLACE VIEW cagg_jobs AS SELECT user_view_schema AS schema, user_view_name AS name, bgw_job.* FROM _timescaledb_config.bgw_job JOIN _timescaledb_catalog.continuous_agg ON mat_hypertable_id = hypertable_id ORDER BY bgw_job.id; -- test migration overriding the new cagg and keeping the old DROP MATERIALIZED VIEW conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:177: NOTICE: drop cascades to 6 other objects TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:178: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+--------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1012 | Retention Policy [1012] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 7 | {"drop_after": "@ 30 days", "hypertable_id": 7} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1013 | Refresh Continuous Aggregate Policy [1013] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 7 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 7} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1014 | Columnstore Policy [1014] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 7 | {"hypertable_id": 7, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | CALL cagg_migrate('conditions_summary_daily', override => TRUE); psql:include/cagg_migrate_common.sql:181: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:181: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily', CAST('2023-01-01 00:00:00' AS timestamp without time zone), NULL);" -- cagg with the new format because it was overriden \d+ conditions_summary_daily View "public.conditions_summary_daily" Column | Type | Collation | Nullable | Default | Storage | Description --------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_13.bucket, _materialized_hypertable_13.min, _materialized_hypertable_13.max, _materialized_hypertable_13.avg, _materialized_hypertable_13.sum FROM _timescaledb_internal._materialized_hypertable_13 WHERE _materialized_hypertable_13.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(13)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(13)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); -- cagg with the old format because it was overriden \d+ conditions_summary_daily_old View "public.conditions_summary_daily_old" Column | Type | Collation | Nullable | Default | Storage | Description --------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_7.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_7 WHERE _materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone) GROUP BY _materialized_hypertable_7.bucket UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:188: ERROR: relation "conditions_summary_daily_new" does not exist at character 15 \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1018 | Retention Policy [1018] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 13 | {"drop_after": "@ 30 days", "hypertable_id": 13} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1019 | Refresh Continuous Aggregate Policy [1019] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 13 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 13} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1020 | Columnstore Policy [1020] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 13 | {"hypertable_id": 13, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | -- should return the old cagg jobs SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+--------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily_old | 1012 | Retention Policy [1012] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 7 | {"drop_after": "@ 30 days", "hypertable_id": 7} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily_old | 1013 | Refresh Continuous Aggregate Policy [1013] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 7 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 7} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily_old | 1014 | Columnstore Policy [1014] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 7 | {"hypertable_id": 7, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- test migration overriding the new cagg and removing the old TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:198: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; psql:include/cagg_migrate_common.sql:199: NOTICE: drop cascades to 6 other objects ALTER MATERIALIZED VIEW conditions_summary_daily_old RENAME TO conditions_summary_daily; -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+--------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1012 | Retention Policy [1012] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 7 | {"drop_after": "@ 30 days", "hypertable_id": 7} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1013 | Refresh Continuous Aggregate Policy [1013] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 7 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 7} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1014 | Columnstore Policy [1014] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 7 | {"hypertable_id": 7, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | CALL cagg_migrate('conditions_summary_daily', override => TRUE, drop_old => TRUE); psql:include/cagg_migrate_common.sql:203: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:203: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily', CAST('2023-01-01 00:00:00' AS timestamp without time zone), NULL);" psql:include/cagg_migrate_common.sql:203: NOTICE: drop cascades to 6 other objects psql:include/cagg_migrate_common.sql:203: NOTICE: job 1012 not found, skipping psql:include/cagg_migrate_common.sql:203: NOTICE: job 1013 not found, skipping psql:include/cagg_migrate_common.sql:203: NOTICE: job 1014 not found, skipping -- cagg with the new format because it was overriden \d+ conditions_summary_daily View "public.conditions_summary_daily" Column | Type | Collation | Nullable | Default | Storage | Description --------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_15.bucket, _materialized_hypertable_15.min, _materialized_hypertable_15.max, _materialized_hypertable_15.avg, _materialized_hypertable_15.sum FROM _timescaledb_internal._materialized_hypertable_15 WHERE _materialized_hypertable_15.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(15)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(15)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:208: ERROR: relation "conditions_summary_daily_new" does not exist at character 15 -- should fail because the old cagg was removed SELECT * FROM conditions_summary_daily_old; psql:include/cagg_migrate_common.sql:210: ERROR: relation "conditions_summary_daily_old" does not exist at character 15 \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1021 | Retention Policy [1021] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 15 | {"drop_after": "@ 30 days", "hypertable_id": 15} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1022 | Refresh Continuous Aggregate Policy [1022] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 15 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 15} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1023 | Columnstore Policy [1023] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 15 | {"hypertable_id": 15, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | -- should return no rows because the old cagg was removed SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- permission tests TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:220: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" GRANT ALL ON TABLE conditions TO :ROLE_DEFAULT_PERM_USER; ALTER MATERIALIZED VIEW conditions_summary_weekly OWNER TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan' catalog table CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:227: ERROR: permission denied for table continuous_agg_migrate_plan \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step' catalog table CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:237: ERROR: permission denied for sequence continuous_agg_migrate_plan_step_step_id_seq \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step_step_id_seq' catalog sequence CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:247: ERROR: permission denied for sequence continuous_agg_migrate_plan_step_step_id_seq \set ON_ERROR_STOP 1 RESET ROLE; GRANT USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- all necessary permissions granted CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:256: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_weekly_new', CAST('2023-01-02 00:00:00' AS timestamp without time zone), NULL);" -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_weekly EXCEPT SELECT * FROM conditions_summary_weekly_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 8 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2023-01-02 00:00:00"} 8 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_weekly_new"} 8 | 3 | FINISHED | DISABLE POLICIES | {"policies": null} 8 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "2023-01-02 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "window_start_type": "timestamp without time zone"} 8 | 5 | FINISHED | COPY DATA | {"end_ts": "2022-03-07 00:00:00", "start_ts": "2021-12-27 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 8 | 6 | FINISHED | COPY DATA | {"end_ts": "2022-05-16 00:00:00", "start_ts": "2022-03-07 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 8 | 7 | FINISHED | COPY DATA | {"end_ts": "2022-07-25 00:00:00", "start_ts": "2022-05-16 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 8 | 8 | FINISHED | COPY DATA | {"end_ts": "2022-10-03 00:00:00", "start_ts": "2022-07-25 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 8 | 9 | FINISHED | COPY DATA | {"end_ts": "2022-12-12 00:00:00", "start_ts": "2022-10-03 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 8 | 10 | FINISHED | COPY DATA | {"end_ts": "2023-02-20 00:00:00", "start_ts": "2022-12-12 00:00:00", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp without time zone"} 8 | 11 | FINISHED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_weekly_new"} 8 | 12 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_weekly_new"} 8 | 13 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_weekly_new"} 8 | 14 | FINISHED | ENABLE POLICIES | RESET ROLE; -- according to the official documentation trying to execute a procedure with -- transaction control statements inside an explicit transaction should fail: -- https://www.postgresql.org/docs/current/sql-call.html -- `If CALL is executed in a transaction block, then the called procedure cannot -- execute transaction control statements. Transaction control statements are only -- allowed if CALL is executed in its own transaction.` TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:273: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_weekly_new; psql:include/cagg_migrate_common.sql:274: NOTICE: drop cascades to 6 other objects \set ON_ERROR_STOP 0 BEGIN; -- should fail with `invalid transaction termination` CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:279: ERROR: invalid transaction termination ROLLBACK; \set ON_ERROR_STOP 1 CREATE FUNCTION execute_migration() RETURNS void AS $$ BEGIN CALL cagg_migrate('conditions_summary_weekly'); RETURN; END; $$ LANGUAGE plpgsql; \set ON_ERROR_STOP 0 -- execute migration inside a plpgsql function BEGIN; -- should fail with `invalid transaction termination` SELECT execute_migration(); psql:include/cagg_migrate_common.sql:296: ERROR: invalid transaction termination ROLLBACK; \set ON_ERROR_STOP 1 -- -- test dropping chunks -- -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------+--------- -- drop 1 chunk \if :IS_TIME_DIMENSION SELECT drop_chunks('conditions', older_than => CAST('2022-01-08 00:00:00-00' AS :TIME_DIMENSION_DATATYPE)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_5_190_chunk \else SELECT drop_chunks('conditions', older_than => 10); \endif -- now he have one chunk marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped --------------------+--------- _hyper_5_190_chunk | t -- this migration should remove the chunk metadata marked as dropped CALL cagg_migrate('conditions_summary_weekly', override => TRUE, drop_old => TRUE); psql:include/cagg_migrate_common.sql:328: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_weekly', CAST('2023-01-02 00:00:00' AS timestamp without time zone), NULL);" psql:include/cagg_migrate_common.sql:328: NOTICE: drop cascades to 6 other objects psql:include/cagg_migrate_common.sql:328: INFO: Removing metadata of chunk 190 from hypertable 5 -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------+--------- -- cleanup DROP FUNCTION execute_migration(); REVOKE SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan FROM :ROLE_DEFAULT_PERM_USER; REVOKE USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq FROM :ROLE_DEFAULT_PERM_USER; TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:342: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; psql:include/cagg_migrate_common.sql:343: NOTICE: drop cascades to 6 other objects DROP MATERIALIZED VIEW conditions_summary_weekly; psql:include/cagg_migrate_common.sql:344: NOTICE: drop cascades to 6 other objects DROP TABLE conditions; SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t -- ######################################################## -- ## TIMESTAMPTZ data type tests -- ######################################################## \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \ir include/cagg_migrate_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Setup some variables SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset -- restore dump SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \ir :TEST_SCHEMA_FILE -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" timestamp with time zone NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_10 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_11 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_12 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_10 ( bucket timestamp with time zone NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_11 ( bucket timestamp with time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_12 ( bucket timestamp with time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_10 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._partial_view_11 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_12 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_11.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_11 WHERE (_materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) GROUP BY _materialized_hypertable_11.bucket UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_10.bucket, _materialized_hypertable_10.min, _materialized_hypertable_10.max, _materialized_hypertable_10.avg, _materialized_hypertable_10.sum FROM _timescaledb_internal._materialized_hypertable_10 WHERE (_materialized_hypertable_10.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)) UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_12.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_12 WHERE (_materialized_hypertable_12.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(12)), '-infinity'::timestamp with time zone)) GROUP BY _materialized_hypertable_12.bucket UNION ALL SELECT public.time_bucket('7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(12)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('7 days'::interval, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 12, true); setval -------- 12 CREATE INDEX _materialized_hypertable_10_bucket_idx ON _timescaledb_internal._materialized_hypertable_10 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_11_bucket_idx ON _timescaledb_internal._materialized_hypertable_11 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_12_bucket_idx ON _timescaledb_internal._materialized_hypertable_12 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t -- Make sure no scheduled job will be executed during the regression tests SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature) SELECT generate_series('2022-01-01 00:00:00-00'::timestamptz, '2022-12-31 23:59:59-00'::timestamptz, '1 hour'), 0.25; \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM public.conditions $$; INSERT INTO conditions ("time", temperature) SELECT generate_series(1, 1000, 1), 0.25; \endif CALL refresh_continuous_aggregate('conditions_summary_daily', NULL, NULL); CALL refresh_continuous_aggregate('conditions_summary_weekly', NULL, NULL); \set ON_ERROR_STOP 0 -- should fail because we don't need to migrate finalized caggs CALL cagg_migrate('conditions_summary_daily_new'); psql:include/cagg_migrate_common.sql:42: ERROR: continuous aggregate "public.conditions_summary_daily_new" does not require any migration -- should fail relation does not exist CALL cagg_migrate('conditions_summary_not_cagg'); psql:include/cagg_migrate_common.sql:45: ERROR: relation "conditions_summary_not_cagg" does not exist at character 19 CREATE TABLE conditions_summary_not_cagg(); -- should fail continuous agg does not exist CALL cagg_migrate('conditions_summary_not_cagg'); psql:include/cagg_migrate_common.sql:50: ERROR: continuous aggregate "public.conditions_summary_not_cagg" does not exist \set ON_ERROR_STOP 1 DROP TABLE conditions_summary_not_cagg; SELECT ca.raw_hypertable_id AS "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", partial_view_schema AS "PART_VIEW_SCHEMA", direct_view_name AS "DIR_VIEW_NAME", direct_view_schema AS "DIR_VIEW_SCHEMA", user_view_name AS "USER_VIEW_NAME", user_view_schema AS "USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily' \gset \set ON_ERROR_STOP 0 -- should fail because the new cagg with suffix '_new' already exists CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:74: ERROR: continuous aggregate "public.conditions_summary_daily_new" already exists \set ON_ERROR_STOP 1 -- remove the new cagg to execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; -- get and set all the cagg data SELECT _timescaledb_functions.cagg_migrate_pre_validation( 'public', 'conditions_summary_daily', 'conditions_summary_daily_new' ) AS "CAGG_DATA" \gset CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); \x on SELECT mat_hypertable_id, user_view_definition FROM _timescaledb_catalog.continuous_agg_migrate_plan; -[ RECORD 1 ]--------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- mat_hypertable_id | 11 user_view_definition | SELECT _materialized_hypertable_11.bucket, + | _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_2_2, NULL::numeric) AS min,+ | _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_3_3, NULL::numeric) AS max,+ | _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_4_4, NULL::numeric) AS avg,+ | _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_5_5, NULL::numeric) AS sum + | FROM _timescaledb_internal._materialized_hypertable_11 + | WHERE (_materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) + | GROUP BY _materialized_hypertable_11.bucket + | UNION ALL + | SELECT public.time_bucket('@ 1 day'::interval, conditions."time") AS bucket, + | min(conditions.temperature) AS min, + | max(conditions.temperature) AS max, + | avg(conditions.temperature) AS avg, + | sum(conditions.temperature) AS sum + | FROM public.conditions + | WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) + | GROUP BY (public.time_bucket('@ 1 day'::interval, conditions."time")); \x off SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+-------------+------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 11 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2022-12-31 16:00:00-08"} 11 | 2 | NOT STARTED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 11 | 3 | NOT STARTED | DISABLE POLICIES | {"policies": null} 11 | 4 | NOT STARTED | REFRESH NEW CAGG | {"window_start": "2022-12-31 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "timestamp with time zone"} 11 | 5 | NOT STARTED | COPY DATA | {"end_ts": "2022-01-10 16:00:00-08", "start_ts": "2021-12-31 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 6 | NOT STARTED | COPY DATA | {"end_ts": "2022-01-20 16:00:00-08", "start_ts": "2022-01-10 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 7 | NOT STARTED | COPY DATA | {"end_ts": "2022-01-30 16:00:00-08", "start_ts": "2022-01-20 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 8 | NOT STARTED | COPY DATA | {"end_ts": "2022-02-09 16:00:00-08", "start_ts": "2022-01-30 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 9 | NOT STARTED | COPY DATA | {"end_ts": "2022-02-19 16:00:00-08", "start_ts": "2022-02-09 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 10 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-01 16:00:00-08", "start_ts": "2022-02-19 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 11 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-11 16:00:00-08", "start_ts": "2022-03-01 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 12 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-21 16:00:00-07", "start_ts": "2022-03-11 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 13 | NOT STARTED | COPY DATA | {"end_ts": "2022-03-31 16:00:00-07", "start_ts": "2022-03-21 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 14 | NOT STARTED | COPY DATA | {"end_ts": "2022-04-10 16:00:00-07", "start_ts": "2022-03-31 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 15 | NOT STARTED | COPY DATA | {"end_ts": "2022-04-20 16:00:00-07", "start_ts": "2022-04-10 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 16 | NOT STARTED | COPY DATA | {"end_ts": "2022-04-30 16:00:00-07", "start_ts": "2022-04-20 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 17 | NOT STARTED | COPY DATA | {"end_ts": "2022-05-10 16:00:00-07", "start_ts": "2022-04-30 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 18 | NOT STARTED | COPY DATA | {"end_ts": "2022-05-20 16:00:00-07", "start_ts": "2022-05-10 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 19 | NOT STARTED | COPY DATA | {"end_ts": "2022-05-30 16:00:00-07", "start_ts": "2022-05-20 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 20 | NOT STARTED | COPY DATA | {"end_ts": "2022-06-09 16:00:00-07", "start_ts": "2022-05-30 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 21 | NOT STARTED | COPY DATA | {"end_ts": "2022-06-19 16:00:00-07", "start_ts": "2022-06-09 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 22 | NOT STARTED | COPY DATA | {"end_ts": "2022-06-29 16:00:00-07", "start_ts": "2022-06-19 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 23 | NOT STARTED | COPY DATA | {"end_ts": "2022-07-09 16:00:00-07", "start_ts": "2022-06-29 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 24 | NOT STARTED | COPY DATA | {"end_ts": "2022-07-19 16:00:00-07", "start_ts": "2022-07-09 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 25 | NOT STARTED | COPY DATA | {"end_ts": "2022-07-29 16:00:00-07", "start_ts": "2022-07-19 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 26 | NOT STARTED | COPY DATA | {"end_ts": "2022-08-08 16:00:00-07", "start_ts": "2022-07-29 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 27 | NOT STARTED | COPY DATA | {"end_ts": "2022-08-18 16:00:00-07", "start_ts": "2022-08-08 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 28 | NOT STARTED | COPY DATA | {"end_ts": "2022-08-28 16:00:00-07", "start_ts": "2022-08-18 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 29 | NOT STARTED | COPY DATA | {"end_ts": "2022-09-07 16:00:00-07", "start_ts": "2022-08-28 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 30 | NOT STARTED | COPY DATA | {"end_ts": "2022-09-17 16:00:00-07", "start_ts": "2022-09-07 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 31 | NOT STARTED | COPY DATA | {"end_ts": "2022-09-27 16:00:00-07", "start_ts": "2022-09-17 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 32 | NOT STARTED | COPY DATA | {"end_ts": "2022-10-07 16:00:00-07", "start_ts": "2022-09-27 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 33 | NOT STARTED | COPY DATA | {"end_ts": "2022-10-17 16:00:00-07", "start_ts": "2022-10-07 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 34 | NOT STARTED | COPY DATA | {"end_ts": "2022-10-27 16:00:00-07", "start_ts": "2022-10-17 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 35 | NOT STARTED | COPY DATA | {"end_ts": "2022-11-06 16:00:00-08", "start_ts": "2022-10-27 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 36 | NOT STARTED | COPY DATA | {"end_ts": "2022-11-16 16:00:00-08", "start_ts": "2022-11-06 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 37 | NOT STARTED | COPY DATA | {"end_ts": "2022-11-26 16:00:00-08", "start_ts": "2022-11-16 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 38 | NOT STARTED | COPY DATA | {"end_ts": "2022-12-06 16:00:00-08", "start_ts": "2022-11-26 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 39 | NOT STARTED | COPY DATA | {"end_ts": "2022-12-16 16:00:00-08", "start_ts": "2022-12-06 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 40 | NOT STARTED | COPY DATA | {"end_ts": "2022-12-26 16:00:00-08", "start_ts": "2022-12-16 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 41 | NOT STARTED | COPY DATA | {"end_ts": "2023-01-05 16:00:00-08", "start_ts": "2022-12-26 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 42 | NOT STARTED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_daily_new"} 11 | 43 | NOT STARTED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 11 | 44 | NOT STARTED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 11 | 45 | NOT STARTED | ENABLE POLICIES | -- should resume the execution CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:96: WARNING: resuming the migration of the continuous aggregate "public.conditions_summary_daily" psql:include/cagg_migrate_common.sql:96: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('2022-12-31 16:00:00-08' AS timestamp with time zone), NULL);" SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 11 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2022-12-31 16:00:00-08"} 11 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 11 | 3 | FINISHED | DISABLE POLICIES | {"policies": null} 11 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "2022-12-31 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "timestamp with time zone"} 11 | 5 | FINISHED | COPY DATA | {"end_ts": "2022-01-10 16:00:00-08", "start_ts": "2021-12-31 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 6 | FINISHED | COPY DATA | {"end_ts": "2022-01-20 16:00:00-08", "start_ts": "2022-01-10 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 7 | FINISHED | COPY DATA | {"end_ts": "2022-01-30 16:00:00-08", "start_ts": "2022-01-20 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 8 | FINISHED | COPY DATA | {"end_ts": "2022-02-09 16:00:00-08", "start_ts": "2022-01-30 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 9 | FINISHED | COPY DATA | {"end_ts": "2022-02-19 16:00:00-08", "start_ts": "2022-02-09 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 10 | FINISHED | COPY DATA | {"end_ts": "2022-03-01 16:00:00-08", "start_ts": "2022-02-19 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 11 | FINISHED | COPY DATA | {"end_ts": "2022-03-11 16:00:00-08", "start_ts": "2022-03-01 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 12 | FINISHED | COPY DATA | {"end_ts": "2022-03-21 16:00:00-07", "start_ts": "2022-03-11 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 13 | FINISHED | COPY DATA | {"end_ts": "2022-03-31 16:00:00-07", "start_ts": "2022-03-21 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 14 | FINISHED | COPY DATA | {"end_ts": "2022-04-10 16:00:00-07", "start_ts": "2022-03-31 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 15 | FINISHED | COPY DATA | {"end_ts": "2022-04-20 16:00:00-07", "start_ts": "2022-04-10 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 16 | FINISHED | COPY DATA | {"end_ts": "2022-04-30 16:00:00-07", "start_ts": "2022-04-20 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 17 | FINISHED | COPY DATA | {"end_ts": "2022-05-10 16:00:00-07", "start_ts": "2022-04-30 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 18 | FINISHED | COPY DATA | {"end_ts": "2022-05-20 16:00:00-07", "start_ts": "2022-05-10 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 19 | FINISHED | COPY DATA | {"end_ts": "2022-05-30 16:00:00-07", "start_ts": "2022-05-20 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 20 | FINISHED | COPY DATA | {"end_ts": "2022-06-09 16:00:00-07", "start_ts": "2022-05-30 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 21 | FINISHED | COPY DATA | {"end_ts": "2022-06-19 16:00:00-07", "start_ts": "2022-06-09 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 22 | FINISHED | COPY DATA | {"end_ts": "2022-06-29 16:00:00-07", "start_ts": "2022-06-19 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 23 | FINISHED | COPY DATA | {"end_ts": "2022-07-09 16:00:00-07", "start_ts": "2022-06-29 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 24 | FINISHED | COPY DATA | {"end_ts": "2022-07-19 16:00:00-07", "start_ts": "2022-07-09 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 25 | FINISHED | COPY DATA | {"end_ts": "2022-07-29 16:00:00-07", "start_ts": "2022-07-19 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 26 | FINISHED | COPY DATA | {"end_ts": "2022-08-08 16:00:00-07", "start_ts": "2022-07-29 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 27 | FINISHED | COPY DATA | {"end_ts": "2022-08-18 16:00:00-07", "start_ts": "2022-08-08 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 28 | FINISHED | COPY DATA | {"end_ts": "2022-08-28 16:00:00-07", "start_ts": "2022-08-18 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 29 | FINISHED | COPY DATA | {"end_ts": "2022-09-07 16:00:00-07", "start_ts": "2022-08-28 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 30 | FINISHED | COPY DATA | {"end_ts": "2022-09-17 16:00:00-07", "start_ts": "2022-09-07 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 31 | FINISHED | COPY DATA | {"end_ts": "2022-09-27 16:00:00-07", "start_ts": "2022-09-17 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 32 | FINISHED | COPY DATA | {"end_ts": "2022-10-07 16:00:00-07", "start_ts": "2022-09-27 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 33 | FINISHED | COPY DATA | {"end_ts": "2022-10-17 16:00:00-07", "start_ts": "2022-10-07 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 34 | FINISHED | COPY DATA | {"end_ts": "2022-10-27 16:00:00-07", "start_ts": "2022-10-17 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 35 | FINISHED | COPY DATA | {"end_ts": "2022-11-06 16:00:00-08", "start_ts": "2022-10-27 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 36 | FINISHED | COPY DATA | {"end_ts": "2022-11-16 16:00:00-08", "start_ts": "2022-11-06 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 37 | FINISHED | COPY DATA | {"end_ts": "2022-11-26 16:00:00-08", "start_ts": "2022-11-16 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 38 | FINISHED | COPY DATA | {"end_ts": "2022-12-06 16:00:00-08", "start_ts": "2022-11-26 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 39 | FINISHED | COPY DATA | {"end_ts": "2022-12-16 16:00:00-08", "start_ts": "2022-12-06 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 40 | FINISHED | COPY DATA | {"end_ts": "2022-12-26 16:00:00-08", "start_ts": "2022-12-16 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 41 | FINISHED | COPY DATA | {"end_ts": "2023-01-05 16:00:00-08", "start_ts": "2022-12-26 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 42 | FINISHED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_daily_new"} 11 | 43 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 11 | 44 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 11 | 45 | FINISHED | ENABLE POLICIES | \set ON_ERROR_STOP 0 -- should error because plan already exists CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); psql:include/cagg_migrate_common.sql:101: ERROR: plan already exists for materialized hypertable 11 CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:102: ERROR: plan already exists for continuous aggregate public.conditions_summary_daily \set ON_ERROR_STOP 1 -- policies for test ALTER MATERIALIZED VIEW conditions_summary_daily SET (timescaledb.compress=true); psql:include/cagg_migrate_common.sql:106: NOTICE: defaulting compress_orderby to bucket \if :IS_TIME_DIMENSION SELECT add_retention_policy('conditions_summary_daily', '30 days'::interval); add_retention_policy ---------------------- 1024 SELECT add_continuous_aggregate_policy('conditions_summary_daily', '30 days'::interval, '1 day'::interval, '1 hour'::interval); add_continuous_aggregate_policy --------------------------------- 1025 SELECT add_compression_policy('conditions_summary_daily', '45 days'::interval); add_compression_policy ------------------------ 1026 \else SELECT add_retention_policy('conditions_summary_daily', '400'::integer); SELECT add_continuous_aggregate_policy('conditions_summary_daily', '50'::integer, '1'::integer, '1 hour'::interval); SELECT add_compression_policy('conditions_summary_daily', '100'::integer); \endif SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'USER_VIEW_SCHEMA' AND hypertable_name = :'USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------------------------------------------------------------------------+------------+---------------+-------------------+--------------------------+------------------------+------------------------------------------- 1024 | Retention Policy [1024] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | {"drop_after": "@ 30 days", "hypertable_id": 11} | | | public | conditions_summary_daily | _timescaledb_functions | policy_retention_check 1025 | Refresh Continuous Aggregate Policy [1025] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 11} | | | public | conditions_summary_daily | _timescaledb_functions | policy_refresh_continuous_aggregate_check 1026 | Columnstore Policy [1026] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | {"hypertable_id": 11, "compress_after": "@ 45 days"} | | | public | conditions_summary_daily | _timescaledb_functions | policy_compression_check -- execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:125: NOTICE: drop cascades to 6 other objects TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:126: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_common.sql:127: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:127: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('2022-12-31 16:00:00-08' AS timestamp with time zone), NULL);" SELECT ca.raw_hypertable_id AS "NEW_RAW_HYPERTABLE_ID", h.schema_name AS "NEW_MAT_SCHEMA_NAME", h.table_name AS "NEW_MAT_TABLE_NAME", partial_view_name AS "NEW_PART_VIEW_NAME", partial_view_schema AS "NEW_PART_VIEW_SCHEMA", direct_view_name AS "NEW_DIR_VIEW_NAME", direct_view_schema AS "NEW_DIR_VIEW_SCHEMA", user_view_name AS "NEW_USER_VIEW_NAME", user_view_schema AS "NEW_USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily_new' \gset \d+ conditions_summary_daily_new View "public.conditions_summary_daily_new" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_21.bucket, _materialized_hypertable_21.min, _materialized_hypertable_21.max, _materialized_hypertable_21.avg, _materialized_hypertable_21.sum FROM _timescaledb_internal._materialized_hypertable_21 WHERE _materialized_hypertable_21.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(21)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(21)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'NEW_USER_VIEW_SCHEMA' AND hypertable_name = :'NEW_USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------------------------------------------------------------------------+------------+---------------+-------------------+------------------------------+------------------------+------------------------------------------- 1027 | Retention Policy [1027] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | {"drop_after": "@ 30 days", "hypertable_id": 21} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_retention_check 1028 | Refresh Continuous Aggregate Policy [1028] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 21} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_refresh_continuous_aggregate_check 1029 | Columnstore Policy [1029] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | {"hypertable_id": 21, "compress_after": "@ 45 days"} | | | public | conditions_summary_daily_new | _timescaledb_functions | policy_compression_check SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 11 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2022-12-31 16:00:00-08"} 11 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_daily_new"} 11 | 3 | FINISHED | DISABLE POLICIES | {"policies": [1024, 1026]} 11 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "2022-12-31 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "window_start_type": "timestamp with time zone"} 11 | 5 | FINISHED | COPY DATA | {"end_ts": "2022-01-10 16:00:00-08", "start_ts": "2021-12-31 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 6 | FINISHED | COPY DATA | {"end_ts": "2022-01-20 16:00:00-08", "start_ts": "2022-01-10 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 7 | FINISHED | COPY DATA | {"end_ts": "2022-01-30 16:00:00-08", "start_ts": "2022-01-20 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 8 | FINISHED | COPY DATA | {"end_ts": "2022-02-09 16:00:00-08", "start_ts": "2022-01-30 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 9 | FINISHED | COPY DATA | {"end_ts": "2022-02-19 16:00:00-08", "start_ts": "2022-02-09 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 10 | FINISHED | COPY DATA | {"end_ts": "2022-03-01 16:00:00-08", "start_ts": "2022-02-19 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 11 | FINISHED | COPY DATA | {"end_ts": "2022-03-11 16:00:00-08", "start_ts": "2022-03-01 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 12 | FINISHED | COPY DATA | {"end_ts": "2022-03-21 16:00:00-07", "start_ts": "2022-03-11 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 13 | FINISHED | COPY DATA | {"end_ts": "2022-03-31 16:00:00-07", "start_ts": "2022-03-21 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 14 | FINISHED | COPY DATA | {"end_ts": "2022-04-10 16:00:00-07", "start_ts": "2022-03-31 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 15 | FINISHED | COPY DATA | {"end_ts": "2022-04-20 16:00:00-07", "start_ts": "2022-04-10 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 16 | FINISHED | COPY DATA | {"end_ts": "2022-04-30 16:00:00-07", "start_ts": "2022-04-20 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 17 | FINISHED | COPY DATA | {"end_ts": "2022-05-10 16:00:00-07", "start_ts": "2022-04-30 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 18 | FINISHED | COPY DATA | {"end_ts": "2022-05-20 16:00:00-07", "start_ts": "2022-05-10 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 19 | FINISHED | COPY DATA | {"end_ts": "2022-05-30 16:00:00-07", "start_ts": "2022-05-20 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 20 | FINISHED | COPY DATA | {"end_ts": "2022-06-09 16:00:00-07", "start_ts": "2022-05-30 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 21 | FINISHED | COPY DATA | {"end_ts": "2022-06-19 16:00:00-07", "start_ts": "2022-06-09 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 22 | FINISHED | COPY DATA | {"end_ts": "2022-06-29 16:00:00-07", "start_ts": "2022-06-19 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 23 | FINISHED | COPY DATA | {"end_ts": "2022-07-09 16:00:00-07", "start_ts": "2022-06-29 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 24 | FINISHED | COPY DATA | {"end_ts": "2022-07-19 16:00:00-07", "start_ts": "2022-07-09 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 25 | FINISHED | COPY DATA | {"end_ts": "2022-07-29 16:00:00-07", "start_ts": "2022-07-19 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 26 | FINISHED | COPY DATA | {"end_ts": "2022-08-08 16:00:00-07", "start_ts": "2022-07-29 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 27 | FINISHED | COPY DATA | {"end_ts": "2022-08-18 16:00:00-07", "start_ts": "2022-08-08 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 28 | FINISHED | COPY DATA | {"end_ts": "2022-08-28 16:00:00-07", "start_ts": "2022-08-18 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 29 | FINISHED | COPY DATA | {"end_ts": "2022-09-07 16:00:00-07", "start_ts": "2022-08-28 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 30 | FINISHED | COPY DATA | {"end_ts": "2022-09-17 16:00:00-07", "start_ts": "2022-09-07 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 31 | FINISHED | COPY DATA | {"end_ts": "2022-09-27 16:00:00-07", "start_ts": "2022-09-17 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 32 | FINISHED | COPY DATA | {"end_ts": "2022-10-07 16:00:00-07", "start_ts": "2022-09-27 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 33 | FINISHED | COPY DATA | {"end_ts": "2022-10-17 16:00:00-07", "start_ts": "2022-10-07 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 34 | FINISHED | COPY DATA | {"end_ts": "2022-10-27 16:00:00-07", "start_ts": "2022-10-17 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 35 | FINISHED | COPY DATA | {"end_ts": "2022-11-06 16:00:00-08", "start_ts": "2022-10-27 16:00:00-07", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 36 | FINISHED | COPY DATA | {"end_ts": "2022-11-16 16:00:00-08", "start_ts": "2022-11-06 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 37 | FINISHED | COPY DATA | {"end_ts": "2022-11-26 16:00:00-08", "start_ts": "2022-11-16 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 38 | FINISHED | COPY DATA | {"end_ts": "2022-12-06 16:00:00-08", "start_ts": "2022-11-26 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 39 | FINISHED | COPY DATA | {"end_ts": "2022-12-16 16:00:00-08", "start_ts": "2022-12-06 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 40 | FINISHED | COPY DATA | {"end_ts": "2022-12-26 16:00:00-08", "start_ts": "2022-12-16 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 41 | FINISHED | COPY DATA | {"end_ts": "2023-01-05 16:00:00-08", "start_ts": "2022-12-26 16:00:00-08", "cagg_name_new": "conditions_summary_daily_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 11 | 42 | FINISHED | COPY POLICIES | {"policies": [1024, 1025, 1026], "cagg_name_new": "conditions_summary_daily_new"} 11 | 43 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 11 | 44 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_daily_new"} 11 | 45 | FINISHED | ENABLE POLICIES | {"policies": [1027, 1028, 1029, 1024, 1025, 1026]} -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- -- compress both caggs SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily') c ORDER BY c::regclass::text; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_11_356_chunk _timescaledb_internal._hyper_11_357_chunk _timescaledb_internal._hyper_11_358_chunk _timescaledb_internal._hyper_11_359_chunk _timescaledb_internal._hyper_11_360_chunk _timescaledb_internal._hyper_11_361_chunk SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily_new') c ORDER BY c::regclass::text; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_21_374_chunk _timescaledb_internal._hyper_21_375_chunk _timescaledb_internal._hyper_21_376_chunk _timescaledb_internal._hyper_21_377_chunk _timescaledb_internal._hyper_21_378_chunk _timescaledb_internal._hyper_21_379_chunk -- check migrated data after compression. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- CREATE OR REPLACE VIEW cagg_jobs AS SELECT user_view_schema AS schema, user_view_name AS name, bgw_job.* FROM _timescaledb_config.bgw_job JOIN _timescaledb_catalog.continuous_agg ON mat_hypertable_id = hypertable_id ORDER BY bgw_job.id; -- test migration overriding the new cagg and keeping the old DROP MATERIALIZED VIEW conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:177: NOTICE: drop cascades to 6 other objects TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:178: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1024 | Retention Policy [1024] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 11 | {"drop_after": "@ 30 days", "hypertable_id": 11} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1025 | Refresh Continuous Aggregate Policy [1025] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 11 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 11} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1026 | Columnstore Policy [1026] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 11 | {"hypertable_id": 11, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | CALL cagg_migrate('conditions_summary_daily', override => TRUE); psql:include/cagg_migrate_common.sql:181: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:181: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily', CAST('2022-12-31 16:00:00-08' AS timestamp with time zone), NULL);" -- cagg with the new format because it was overriden \d+ conditions_summary_daily View "public.conditions_summary_daily" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_23.bucket, _materialized_hypertable_23.min, _materialized_hypertable_23.max, _materialized_hypertable_23.avg, _materialized_hypertable_23.sum FROM _timescaledb_internal._materialized_hypertable_23 WHERE _materialized_hypertable_23.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(23)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(23)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); -- cagg with the old format because it was overriden \d+ conditions_summary_daily_old View "public.conditions_summary_daily_old" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_11.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_11 WHERE _materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone) GROUP BY _materialized_hypertable_11.bucket UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:188: ERROR: relation "conditions_summary_daily_new" does not exist at character 15 \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1030 | Retention Policy [1030] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 23 | {"drop_after": "@ 30 days", "hypertable_id": 23} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1031 | Refresh Continuous Aggregate Policy [1031] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 23 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 23} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1032 | Columnstore Policy [1032] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 23 | {"hypertable_id": 23, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | -- should return the old cagg jobs SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily_old | 1024 | Retention Policy [1024] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 11 | {"drop_after": "@ 30 days", "hypertable_id": 11} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily_old | 1025 | Refresh Continuous Aggregate Policy [1025] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 11 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 11} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily_old | 1026 | Columnstore Policy [1026] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 11 | {"hypertable_id": 11, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- test migration overriding the new cagg and removing the old TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:198: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; psql:include/cagg_migrate_common.sql:199: NOTICE: drop cascades to 6 other objects ALTER MATERIALIZED VIEW conditions_summary_daily_old RENAME TO conditions_summary_daily; -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1024 | Retention Policy [1024] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 11 | {"drop_after": "@ 30 days", "hypertable_id": 11} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1025 | Refresh Continuous Aggregate Policy [1025] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 11 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 11} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1026 | Columnstore Policy [1026] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 11 | {"hypertable_id": 11, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | CALL cagg_migrate('conditions_summary_daily', override => TRUE, drop_old => TRUE); psql:include/cagg_migrate_common.sql:203: NOTICE: defaulting compress_orderby to bucket psql:include/cagg_migrate_common.sql:203: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily', CAST('2022-12-31 16:00:00-08' AS timestamp with time zone), NULL);" psql:include/cagg_migrate_common.sql:203: NOTICE: drop cascades to 6 other objects psql:include/cagg_migrate_common.sql:203: NOTICE: job 1024 not found, skipping psql:include/cagg_migrate_common.sql:203: NOTICE: job 1025 not found, skipping psql:include/cagg_migrate_common.sql:203: NOTICE: job 1026 not found, skipping -- cagg with the new format because it was overriden \d+ conditions_summary_daily View "public.conditions_summary_daily" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | numeric | | | | main | max | numeric | | | | main | avg | numeric | | | | main | sum | numeric | | | | main | View definition: SELECT _materialized_hypertable_25.bucket, _materialized_hypertable_25.min, _materialized_hypertable_25.max, _materialized_hypertable_25.avg, _materialized_hypertable_25.sum FROM _timescaledb_internal._materialized_hypertable_25 WHERE _materialized_hypertable_25.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(25)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(25)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; psql:include/cagg_migrate_common.sql:208: ERROR: relation "conditions_summary_daily_new" does not exist at character 15 -- should fail because the old cagg was removed SELECT * FROM conditions_summary_daily_old; psql:include/cagg_migrate_common.sql:210: ERROR: relation "conditions_summary_daily_old" does not exist at character 15 \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+--------------------------+------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+--------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+-------------------------------------------+---------- public | conditions_summary_daily | 1033 | Retention Policy [1033] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | cluster_super_user | t | f | | 25 | {"drop_after": "@ 30 days", "hypertable_id": 25} | _timescaledb_functions | policy_retention_check | public | conditions_summary_daily | 1034 | Refresh Continuous Aggregate Policy [1034] | @ 1 hour | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | cluster_super_user | t | f | | 25 | {"end_offset": "@ 1 day", "start_offset": "@ 30 days", "mat_hypertable_id": 25} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | public | conditions_summary_daily | 1035 | Columnstore Policy [1035] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | cluster_super_user | t | f | | 25 | {"hypertable_id": 25, "compress_after": "@ 45 days"} | _timescaledb_functions | policy_compression_check | -- should return no rows because the old cagg was removed SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; schema | name | id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone --------+------+----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- permission tests TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:220: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" GRANT ALL ON TABLE conditions TO :ROLE_DEFAULT_PERM_USER; ALTER MATERIALIZED VIEW conditions_summary_weekly OWNER TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan' catalog table CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:227: ERROR: permission denied for table continuous_agg_migrate_plan \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step' catalog table CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:237: ERROR: permission denied for sequence continuous_agg_migrate_plan_step_step_id_seq \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step_step_id_seq' catalog sequence CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:247: ERROR: permission denied for sequence continuous_agg_migrate_plan_step_step_id_seq \set ON_ERROR_STOP 1 RESET ROLE; GRANT USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- all necessary permissions granted CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:256: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_weekly_new', CAST('2023-01-01 16:00:00-08' AS timestamp with time zone), NULL);" -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_weekly EXCEPT SELECT * FROM conditions_summary_weekly_new; bucket | min | max | avg | sum --------+-----+-----+-----+----- SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; mat_hypertable_id | step_id | status | type | config -------------------+---------+----------+------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 12 | 1 | FINISHED | SAVE WATERMARK | {"watermark": "2023-01-01 16:00:00-08"} 12 | 2 | FINISHED | CREATE NEW CAGG | {"cagg_name_new": "conditions_summary_weekly_new"} 12 | 3 | FINISHED | DISABLE POLICIES | {"policies": null} 12 | 4 | FINISHED | REFRESH NEW CAGG | {"window_start": "2023-01-01 16:00:00-08", "cagg_name_new": "conditions_summary_weekly_new", "window_start_type": "timestamp with time zone"} 12 | 5 | FINISHED | COPY DATA | {"end_ts": "2022-03-06 16:00:00-08", "start_ts": "2021-12-26 16:00:00-08", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 12 | 6 | FINISHED | COPY DATA | {"end_ts": "2022-05-15 16:00:00-07", "start_ts": "2022-03-06 16:00:00-08", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 12 | 7 | FINISHED | COPY DATA | {"end_ts": "2022-07-24 16:00:00-07", "start_ts": "2022-05-15 16:00:00-07", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 12 | 8 | FINISHED | COPY DATA | {"end_ts": "2022-10-02 16:00:00-07", "start_ts": "2022-07-24 16:00:00-07", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 12 | 9 | FINISHED | COPY DATA | {"end_ts": "2022-12-11 16:00:00-08", "start_ts": "2022-10-02 16:00:00-07", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 12 | 10 | FINISHED | COPY DATA | {"end_ts": "2023-02-19 16:00:00-08", "start_ts": "2022-12-11 16:00:00-08", "cagg_name_new": "conditions_summary_weekly_new", "bucket_column_name": "bucket", "bucket_column_type": "timestamp with time zone"} 12 | 11 | FINISHED | COPY POLICIES | {"policies": null, "cagg_name_new": "conditions_summary_weekly_new"} 12 | 12 | FINISHED | OVERRIDE CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_weekly_new"} 12 | 13 | FINISHED | DROP OLD CAGG | {"drop_old": false, "override": false, "cagg_name_new": "conditions_summary_weekly_new"} 12 | 14 | FINISHED | ENABLE POLICIES | RESET ROLE; -- according to the official documentation trying to execute a procedure with -- transaction control statements inside an explicit transaction should fail: -- https://www.postgresql.org/docs/current/sql-call.html -- `If CALL is executed in a transaction block, then the called procedure cannot -- execute transaction control statements. Transaction control statements are only -- allowed if CALL is executed in its own transaction.` TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:273: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_weekly_new; psql:include/cagg_migrate_common.sql:274: NOTICE: drop cascades to 6 other objects \set ON_ERROR_STOP 0 BEGIN; -- should fail with `invalid transaction termination` CALL cagg_migrate('conditions_summary_weekly'); psql:include/cagg_migrate_common.sql:279: ERROR: invalid transaction termination ROLLBACK; \set ON_ERROR_STOP 1 CREATE FUNCTION execute_migration() RETURNS void AS $$ BEGIN CALL cagg_migrate('conditions_summary_weekly'); RETURN; END; $$ LANGUAGE plpgsql; \set ON_ERROR_STOP 0 -- execute migration inside a plpgsql function BEGIN; -- should fail with `invalid transaction termination` SELECT execute_migration(); psql:include/cagg_migrate_common.sql:296: ERROR: invalid transaction termination ROLLBACK; \set ON_ERROR_STOP 1 -- -- test dropping chunks -- -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------+--------- -- drop 1 chunk \if :IS_TIME_DIMENSION SELECT drop_chunks('conditions', older_than => CAST('2022-01-08 00:00:00-00' AS :TIME_DIMENSION_DATATYPE)); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_9_303_chunk \else SELECT drop_chunks('conditions', older_than => 10); \endif -- now he have one chunk marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped --------------------+--------- _hyper_9_303_chunk | t -- this migration should remove the chunk metadata marked as dropped CALL cagg_migrate('conditions_summary_weekly', override => TRUE, drop_old => TRUE); psql:include/cagg_migrate_common.sql:328: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_weekly', CAST('2023-01-01 16:00:00-08' AS timestamp with time zone), NULL);" psql:include/cagg_migrate_common.sql:328: NOTICE: drop cascades to 6 other objects psql:include/cagg_migrate_common.sql:328: INFO: Removing metadata of chunk 303 from hypertable 9 -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; chunk_name | dropped ------------+--------- -- cleanup DROP FUNCTION execute_migration(); REVOKE SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan FROM :ROLE_DEFAULT_PERM_USER; REVOKE USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq FROM :ROLE_DEFAULT_PERM_USER; TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_common.sql:342: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; psql:include/cagg_migrate_common.sql:343: NOTICE: drop cascades to 6 other objects DROP MATERIALIZED VIEW conditions_summary_weekly; psql:include/cagg_migrate_common.sql:344: NOTICE: drop cascades to 6 other objects DROP TABLE conditions; SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t -- ######################################################### -- Issue 5359 - custom timezones should not break the migration -- ######################################################### SET timezone = 'Europe/Budapest'; -- Test with timestamp \set TIME_DIMENSION_DATATYPE TIMESTAMP \ir include/cagg_migrate_custom_timezone.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \ir :TEST_SCHEMA_FILE -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" timestamp without time zone NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_6 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_7 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_8 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_6 ( bucket timestamp without time zone NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_7 ( bucket timestamp without time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_8 ( bucket timestamp without time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_6 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._partial_view_7 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_8 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_7.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_7 WHERE (_materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) GROUP BY _materialized_hypertable_7.bucket UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_6.bucket, _materialized_hypertable_6.min, _materialized_hypertable_6.max, _materialized_hypertable_6.avg, _materialized_hypertable_6.sum FROM _timescaledb_internal._materialized_hypertable_6 WHERE (_materialized_hypertable_6.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp without time zone)) UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_8.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_8 WHERE (_materialized_hypertable_8.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp without time zone)) GROUP BY _materialized_hypertable_8.bucket UNION ALL SELECT public.time_bucket('7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('7 days'::interval, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 8, true); setval -------- 8 SELECT pg_catalog.setval('_timescaledb_catalog.hypertable_id_seq', 8, true); setval -------- 8 CREATE INDEX _materialized_hypertable_6_bucket_idx ON _timescaledb_internal._materialized_hypertable_6 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_7_bucket_idx ON _timescaledb_internal._materialized_hypertable_7 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_8_bucket_idx ON _timescaledb_internal._materialized_hypertable_8 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t -- Check restored watermark values SELECT mat_hypertable_id, _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(mat_hypertable_id)) FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | to_timestamp -------------------+--------------------------------- 6 | Mon Nov 24 01:16:20 4714 LMT BC 7 | Mon Nov 24 01:16:20 4714 LMT BC 8 | Mon Nov 24 01:16:20 4714 LMT BC DROP MATERIALIZED VIEW conditions_summary_daily_new; CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_custom_timezone.sql:17: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('4714-11-24 00:00:00 BC' AS timestamp without time zone), NULL);" -- Cleanup TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_custom_timezone.sql:20: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; DROP MATERIALIZED VIEW conditions_summary_weekly; DROP TABLE conditions CASCADE; psql:include/cagg_migrate_custom_timezone.sql:23: NOTICE: drop cascades to 3 other objects -- Test with timestamptz \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \ir include/cagg_migrate_custom_timezone.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \ir :TEST_SCHEMA_FILE -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" timestamp with time zone NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_10 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_11 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_12 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_10 ( bucket timestamp with time zone NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_11 ( bucket timestamp with time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_12 ( bucket timestamp with time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_10 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._partial_view_11 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_12 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_11.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_11 WHERE (_materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) GROUP BY _materialized_hypertable_11.bucket UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_10.bucket, _materialized_hypertable_10.min, _materialized_hypertable_10.max, _materialized_hypertable_10.avg, _materialized_hypertable_10.sum FROM _timescaledb_internal._materialized_hypertable_10 WHERE (_materialized_hypertable_10.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)) UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_12.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_12 WHERE (_materialized_hypertable_12.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(12)), '-infinity'::timestamp with time zone)) GROUP BY _materialized_hypertable_12.bucket UNION ALL SELECT public.time_bucket('7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(12)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('7 days'::interval, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 12, true); setval -------- 12 CREATE INDEX _materialized_hypertable_10_bucket_idx ON _timescaledb_internal._materialized_hypertable_10 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_11_bucket_idx ON _timescaledb_internal._materialized_hypertable_11 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_12_bucket_idx ON _timescaledb_internal._materialized_hypertable_12 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t -- Check restored watermark values SELECT mat_hypertable_id, _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(mat_hypertable_id)) FROM _timescaledb_catalog.continuous_agg; mat_hypertable_id | to_timestamp -------------------+--------------------------------- 10 | Mon Nov 24 01:16:20 4714 LMT BC 11 | Mon Nov 24 01:16:20 4714 LMT BC 12 | Mon Nov 24 01:16:20 4714 LMT BC DROP MATERIALIZED VIEW conditions_summary_daily_new; CALL cagg_migrate('conditions_summary_daily'); psql:include/cagg_migrate_custom_timezone.sql:17: WARNING: refresh the continuous aggregate after the migration executing this statement: "CALL public.refresh_continuous_aggregate('public.conditions_summary_daily_new', CAST('4714-11-24 01:16:20+01:16:20 BC' AS timestamp with time zone), NULL);" -- Cleanup TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; psql:include/cagg_migrate_custom_timezone.sql:20: NOTICE: truncate cascades to table "continuous_agg_migrate_plan_step" DROP MATERIALIZED VIEW conditions_summary_daily; DROP MATERIALIZED VIEW conditions_summary_weekly; DROP TABLE conditions CASCADE; psql:include/cagg_migrate_custom_timezone.sql:23: NOTICE: drop cascades to 3 other objects -- ######################################################### -- Issue 6976 - space partitioning should not cause catalog corruption -- ######################################################### CREATE TABLE space_partitioning ( time timestamptz, device_id integer, value float ); -- Updating sequence numbers so creating a hypertable doesn't mess with -- data imports used by migration tests SELECT setval('_timescaledb_catalog.hypertable_id_seq', 999, true); setval -------- 999 SELECT setval('_timescaledb_catalog.chunk_id_seq', 999, true); setval -------- 999 SELECT setval('_timescaledb_catalog.dimension_id_seq', 999, true); setval -------- 999 SELECT setval('_timescaledb_catalog.dimension_slice_id_seq', 999, true); setval -------- 999 SELECT create_hypertable('space_partitioning', 'time', chunk_time_interval=>'1 hour'::interval); create_hypertable ------------------------------------ (1000,public,space_partitioning,t) SELECT add_dimension('space_partitioning', 'device_id', 3); add_dimension ---------------------------------------------- (1001,public,space_partitioning,device_id,t) INSERT INTO space_partitioning SELECT t, 1, 1.0 FROM generate_series('2024-01-01'::timestamptz, '2024-02-01'::timestamptz, '10 minutes'::interval) t; INSERT INTO space_partitioning SELECT t, 1000, 1.0 FROM generate_series('2024-01-01'::timestamptz, '2024-02-01'::timestamptz, '10 minutes'::interval) t; CREATE MATERIALIZED VIEW space_partitioning_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, device_id, MIN(value), MAX(value), SUM(value) FROM space_partitioning GROUP BY 1, 2 WITH NO DATA; -- setting up the state so that remove_dropped_chunk_metadata -- would run on the hypertable and trigger the catalog corruption UPDATE _timescaledb_catalog.chunk SET dropped = TRUE FROM _timescaledb_catalog.hypertable WHERE chunk.hypertable_id = hypertable.id AND hypertable.table_name = 'space_partitioning' AND chunk.id = 1000; UPDATE _timescaledb_catalog.continuous_agg SET finalized = true FROM _timescaledb_catalog.hypertable WHERE continuous_agg.raw_hypertable_id = hypertable.id AND hypertable.table_name = 'space_partitioning'; SET timescaledb.restoring TO ON; DROP TABLE _timescaledb_internal._hyper_1000_1000_chunk; SET timescaledb.restoring TO OFF; SELECT _timescaledb_functions.remove_dropped_chunk_metadata(id) FROM _timescaledb_catalog.hypertable WHERE table_name = 'space_partitioning'; INFO: Removing metadata of chunk 1000 from hypertable 1000 remove_dropped_chunk_metadata ------------------------------- 1 -- check every chunk has as many chunk constraints as -- there are dimensions, should return empty result -- this ensures we have avoided catalog corruption WITH dimension_count as ( SELECT ht.id, count(*) FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.dimension d ON d.hypertable_id = ht.id WHERE table_name = 'space_partitioning' GROUP BY 1), chunk_constraint_count AS ( SELECT c.hypertable_id, cc.chunk_id, count(*) FROM _timescaledb_catalog.chunk_constraint cc INNER JOIN _timescaledb_catalog.chunk c ON cc.chunk_id = c.id GROUP BY 1, 2 ) SELECT * FROM dimension_count dc INNER JOIN chunk_constraint_count ccc ON ccc.hypertable_id = dc.id WHERE dc.count != ccc.count; id | count | hypertable_id | chunk_id | count ----+-------+---------------+----------+------- �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_migrate_function-15.out�����������������������������������0000664�0000000�0000000�00000221453�15100345067�0024736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Run test as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Prepare a hypertable with date values CREATE TABLE temperaturedate ( time date NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturedate', 'time'); create_hypertable ------------------------------ (1,public,temperaturedate,t) INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamp values CREATE TABLE temperature ( time timestamp NOT NULL, sensor int, value float ); SELECT create_hypertable('temperature', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (2,public,temperature,t) INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamptz values CREATE TABLE temperaturetz ( time timestamptz NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturetz', 'time'); create_hypertable ---------------------------- (3,public,temperaturetz,t) INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; --- Tests with date -- -- Tested function signatures -- -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date, origin date --- CREATE MATERIALIZED VIEW cagg_tempdate_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 4 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date) | @ 7 days | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time") AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time")), temperaturedate.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time") AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time")), temperaturedate.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_4."time", + _materialized_hypertable_4.sensor, + _materialized_hypertable_4.avg + FROM _timescaledb_internal._materialized_hypertable_4; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 4 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, temperaturedate."time", origin => '01-01-2000'::date) AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, temperaturedate."time", origin => '01-01-2000'::date)), temperaturedate.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, temperaturedate."time", origin => '01-01-2000'::date) AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, temperaturedate."time", origin => '01-01-2000'::date)), temperaturedate.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_4."time", + _materialized_hypertable_4.sensor, + _materialized_hypertable_4.avg + FROM _timescaledb_internal._materialized_hypertable_4; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_tempdate_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time, '2020-01-04') as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date) AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date)), temperaturedate.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date) AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date)), temperaturedate.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_5."time", + _materialized_hypertable_5.sensor, + _materialized_hypertable_5.avg + FROM _timescaledb_internal._materialized_hypertable_5; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date) AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date)), temperaturedate.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date) AS "time", + temperaturedate.sensor, + avg(temperaturedate.value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, temperaturedate."time", '01-04-2020'::date)), temperaturedate.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_5."time", + _materialized_hypertable_5.sensor, + _materialized_hypertable_5.avg + FROM _timescaledb_internal._materialized_hypertable_5; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamp -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone, origin timestamp without time zone --- CREATE MATERIALIZED VIEW cagg_temp_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 6 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone) | @ 5 mins | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time") AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time")), temperature.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time") AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time")), temperature.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_6."time", + _materialized_hypertable_6.sensor, + _materialized_hypertable_6.avg + FROM _timescaledb_internal._materialized_hypertable_6; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 6 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, temperature."time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, temperature."time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), temperature.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, temperature."time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, temperature."time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), temperature.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_6."time", + _materialized_hypertable_6.sensor, + _materialized_hypertable_6.avg + FROM _timescaledb_internal._materialized_hypertable_6; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temp_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-01-01 04:00:00') as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), temperature.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), temperature.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_7."time", + _materialized_hypertable_7.sensor, + _materialized_hypertable_7.avg + FROM _timescaledb_internal._materialized_hypertable_7; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), temperature.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + temperature.sensor, + avg(temperature.value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, temperature."time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), temperature.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_7."time", + _materialized_hypertable_7.sensor, + _materialized_hypertable_7.avg + FROM _timescaledb_internal._materialized_hypertable_7; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamptz -- -- Not tested signatures since they are not supported by CAggs -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone, timezone text -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, timezone text --- -- Create a CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temptz_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 8 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_8."time", + _materialized_hypertable_8.sensor, + _materialized_hypertable_8.avg + FROM _timescaledb_internal._materialized_hypertable_8; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 8 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_8."time", + _materialized_hypertable_8.sensor, + _materialized_hypertable_8.avg + FROM _timescaledb_internal._materialized_hypertable_8; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temptz_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-04-01'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration - special case, order of origin and timezone needs to be swapped \set CAGG_NAME 'cagg_temptz_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone,pg_catalog.text) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), temperaturetz.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), temperaturetz.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_9."time", + _materialized_hypertable_9.sensor, + _materialized_hypertable_9.avg + FROM _timescaledb_internal._materialized_hypertable_9; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), temperaturetz.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), temperaturetz.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_9."time", + _materialized_hypertable_9.sensor, + _materialized_hypertable_9.avg + FROM _timescaledb_internal._materialized_hypertable_9; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); -- Test real-time CAggs as well -- Create a real-time CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; \set CAGG_NAME 'cagg_temptz_ng_rt' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 10 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 10 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + UNION ALL + SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); ---- -- Check bucket conversion -- timestamptz without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Sun Dec 27 15:00:00 2009 PST | 1 | 101 Sun Dec 27 15:00:00 2009 PST | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00+01'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamptz with custom origin ---- TRUNCATE temperaturetz; INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); CREATE MATERIALIZED VIEW cagg_temp_ng_1week_corgin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); SELECT * FROM cagg_temp_ng_1week_corgin; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_corgin'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_corgin ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamp without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_timestamp WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Mon Dec 28 00:00:00 2009 | 1 | 101 Mon Dec 28 00:00:00 2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_timestamp; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_timestamp'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00'), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_timestamp ORDER BY time, sensor; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 ---- -- Check bucket conversion -- date without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_date WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-28-2009 | 1 | 101 12-28-2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_date; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 01:00:00+00'), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_date ORDER BY time, sensor; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure we error out when the CAgg does not use a deprecated function \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); ERROR: CAgg cagg_temp_ng_1week_date does not use a deprecated bucket function \set ON_ERROR_STOP 1 ---- -- Test migration as non-owner (should fail) ---- CREATE MATERIALIZED VIEW cagg_tempdate_ng_acl WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_tempdate_ng_acl'); ERROR: must be owner of view cagg_tempdate_ng_acl \set ON_ERROR_STOP 1 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_migrate_function-16.out�����������������������������������0000664�0000000�0000000�00000206673�15100345067�0024746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Run test as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Prepare a hypertable with date values CREATE TABLE temperaturedate ( time date NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturedate', 'time'); create_hypertable ------------------------------ (1,public,temperaturedate,t) INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamp values CREATE TABLE temperature ( time timestamp NOT NULL, sensor int, value float ); SELECT create_hypertable('temperature', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (2,public,temperature,t) INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamptz values CREATE TABLE temperaturetz ( time timestamptz NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturetz', 'time'); create_hypertable ---------------------------- (3,public,temperaturetz,t) INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; --- Tests with date -- -- Tested function signatures -- -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date, origin date --- CREATE MATERIALIZED VIEW cagg_tempdate_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 4 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date) | @ 7 days | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time")), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time")), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_4; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 4 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_4; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_tempdate_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time, '2020-01-04') as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_5; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_5; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamp -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone, origin timestamp without time zone --- CREATE MATERIALIZED VIEW cagg_temp_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 6 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone) | @ 5 mins | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time")), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time")), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_6; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 6 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_6; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temp_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-01-01 04:00:00') as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_7; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_7; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamptz -- -- Not tested signatures since they are not supported by CAggs -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone, timezone text -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, timezone text --- -- Create a CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temptz_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 8 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_8; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 8 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_8; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temptz_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-04-01'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration - special case, order of origin and timezone needs to be swapped \set CAGG_NAME 'cagg_temptz_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone,pg_catalog.text) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_9; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_9; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); -- Test real-time CAggs as well -- Create a real-time CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; \set CAGG_NAME 'cagg_temptz_ng_rt' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 10 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 10 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + UNION ALL + SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); ---- -- Check bucket conversion -- timestamptz without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Sun Dec 27 15:00:00 2009 PST | 1 | 101 Sun Dec 27 15:00:00 2009 PST | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00+01'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamptz with custom origin ---- TRUNCATE temperaturetz; INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); CREATE MATERIALIZED VIEW cagg_temp_ng_1week_corgin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); SELECT * FROM cagg_temp_ng_1week_corgin; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_corgin'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_corgin ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamp without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_timestamp WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Mon Dec 28 00:00:00 2009 | 1 | 101 Mon Dec 28 00:00:00 2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_timestamp; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_timestamp'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00'), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_timestamp ORDER BY time, sensor; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 ---- -- Check bucket conversion -- date without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_date WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-28-2009 | 1 | 101 12-28-2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_date; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 01:00:00+00'), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_date ORDER BY time, sensor; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure we error out when the CAgg does not use a deprecated function \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); ERROR: CAgg cagg_temp_ng_1week_date does not use a deprecated bucket function \set ON_ERROR_STOP 1 ---- -- Test migration as non-owner (should fail) ---- CREATE MATERIALIZED VIEW cagg_tempdate_ng_acl WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_tempdate_ng_acl'); ERROR: must be owner of view cagg_tempdate_ng_acl \set ON_ERROR_STOP 1 ���������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_migrate_function-17.out�����������������������������������0000664�0000000�0000000�00000206673�15100345067�0024747�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Run test as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Prepare a hypertable with date values CREATE TABLE temperaturedate ( time date NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturedate', 'time'); create_hypertable ------------------------------ (1,public,temperaturedate,t) INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamp values CREATE TABLE temperature ( time timestamp NOT NULL, sensor int, value float ); SELECT create_hypertable('temperature', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (2,public,temperature,t) INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamptz values CREATE TABLE temperaturetz ( time timestamptz NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturetz', 'time'); create_hypertable ---------------------------- (3,public,temperaturetz,t) INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; --- Tests with date -- -- Tested function signatures -- -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date, origin date --- CREATE MATERIALIZED VIEW cagg_tempdate_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 4 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date) | @ 7 days | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time")), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time")), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_4; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 4 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_4; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_tempdate_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time, '2020-01-04') as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_5; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_5; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamp -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone, origin timestamp without time zone --- CREATE MATERIALIZED VIEW cagg_temp_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 6 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone) | @ 5 mins | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time")), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time")), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_6; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 6 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_6; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temp_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-01-01 04:00:00') as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_7; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_7; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamptz -- -- Not tested signatures since they are not supported by CAggs -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone, timezone text -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, timezone text --- -- Create a CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temptz_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 8 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_8; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 8 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_8; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temptz_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-04-01'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration - special case, order of origin and timezone needs to be swapped \set CAGG_NAME 'cagg_temptz_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone,pg_catalog.text) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_9; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_9; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); -- Test real-time CAggs as well -- Create a real-time CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; \set CAGG_NAME 'cagg_temptz_ng_rt' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 10 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 10 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + UNION ALL + SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); ---- -- Check bucket conversion -- timestamptz without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Sun Dec 27 15:00:00 2009 PST | 1 | 101 Sun Dec 27 15:00:00 2009 PST | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00+01'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamptz with custom origin ---- TRUNCATE temperaturetz; INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); CREATE MATERIALIZED VIEW cagg_temp_ng_1week_corgin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); SELECT * FROM cagg_temp_ng_1week_corgin; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_corgin'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_corgin ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamp without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_timestamp WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Mon Dec 28 00:00:00 2009 | 1 | 101 Mon Dec 28 00:00:00 2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_timestamp; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_timestamp'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00'), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_timestamp ORDER BY time, sensor; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 ---- -- Check bucket conversion -- date without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_date WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-28-2009 | 1 | 101 12-28-2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_date; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 01:00:00+00'), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_date ORDER BY time, sensor; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure we error out when the CAgg does not use a deprecated function \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); ERROR: CAgg cagg_temp_ng_1week_date does not use a deprecated bucket function \set ON_ERROR_STOP 1 ---- -- Test migration as non-owner (should fail) ---- CREATE MATERIALIZED VIEW cagg_tempdate_ng_acl WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_tempdate_ng_acl'); ERROR: must be owner of view cagg_tempdate_ng_acl \set ON_ERROR_STOP 1 ���������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_migrate_function-18.out�����������������������������������0000664�0000000�0000000�00000206673�15100345067�0024750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Run test as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Prepare a hypertable with date values CREATE TABLE temperaturedate ( time date NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturedate', 'time'); create_hypertable ------------------------------ (1,public,temperaturedate,t) INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamp values CREATE TABLE temperature ( time timestamp NOT NULL, sensor int, value float ); SELECT create_hypertable('temperature', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------- (2,public,temperature,t) INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamptz values CREATE TABLE temperaturetz ( time timestamptz NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturetz', 'time'); create_hypertable ---------------------------- (3,public,temperaturetz,t) INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; --- Tests with date -- -- Tested function signatures -- -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date, origin date --- CREATE MATERIALIZED VIEW cagg_tempdate_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 4 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date) | @ 7 days | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time")), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time")), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_4; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 4 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", origin => '01-01-2000'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_4; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_tempdate_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time, '2020-01-04') as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_5; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 5 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 7 days | Sat Jan 04 00:00:00 2020 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------- SELECT time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date) AS "time", + sensor, + avg(value) AS avg + FROM temperaturedate + GROUP BY (time_bucket('@ 7 days'::interval, "time", '01-04-2020'::date)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_5; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamp -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone, origin timestamp without time zone --- CREATE MATERIALIZED VIEW cagg_temp_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 6 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone) | @ 5 mins | | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time")), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef --------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time") AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time")), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_6; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 6 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Sat Jan 01 00:00:00 2000 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", origin => 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_6; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temp_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-01-01 04:00:00') as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-----------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_7; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 7 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 5 mins | Tue Dec 31 20:00:00 2019 PST | | | t SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperature + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Wed Jan 01 04:00:00 2020'::timestamp without time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_7; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); --- Tests with timestamptz -- -- Not tested signatures since they are not supported by CAggs -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone, timezone text -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, timezone text --- -- Create a CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temptz_ng' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 8 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_8; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 8 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_8; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); CREATE MATERIALIZED VIEW cagg_temptz_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-04-01'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration - special case, order of origin and timezone needs to be swapped \set CAGG_NAME 'cagg_temptz_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone,pg_catalog.text) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone, 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_9; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 9 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Wed Apr 01 00:00:00 2020 PDT | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------------------------------------- SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, 'Wed Apr 01 00:00:00 2020 PDT'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ----------------------------------------------------------- SELECT "time", + sensor, + avg + FROM _timescaledb_internal._materialized_hypertable_9; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); -- Test real-time CAggs as well -- Create a real-time CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; \set CAGG_NAME 'cagg_temptz_ng_rt' \ir include/cagg_run_timebucket_migration.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+--------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 10 | timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 5 mins | | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef -------------------------------------------------------------------------------------------------------------------- SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, "time", 'Europe/Berlin'::text)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (timescaledb_experimental.time_bucket_ng('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text)), temperaturetz.sensor; CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- 10 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 5 mins | Fri Dec 31 15:00:00 1999 PST | | Europe/Berlin | f SELECT pg_get_viewdef(:'partial_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'direct_view', true); pg_get_viewdef ------------------------------------------------------------------------------------------------------------------------------------------------------------ SELECT time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + sensor, + avg(value) AS avg + FROM temperaturetz + GROUP BY (time_bucket('@ 5 mins'::interval, "time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), sensor; SELECT pg_get_viewdef(:'CAGG_NAME', true); pg_get_viewdef ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_10."time", + _materialized_hypertable_10.sensor, + _materialized_hypertable_10.avg + FROM _timescaledb_internal._materialized_hypertable_10 + WHERE _materialized_hypertable_10."time" < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + UNION ALL + SELECT time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone) AS "time", + temperaturetz.sensor, + avg(temperaturetz.value) AS avg + FROM temperaturetz + WHERE temperaturetz."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 5 mins'::interval, temperaturetz."time", 'Europe/Berlin'::text, origin => 'Fri Dec 31 15:00:00 1999 PST'::timestamp with time zone)), temperaturetz.sensor; -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); ---- -- Check bucket conversion -- timestamptz without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Sun Dec 27 15:00:00 2009 PST | 1 | 101 Sun Dec 27 15:00:00 2009 PST | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00+01'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Fri Dec 25 15:00:00 2009 PST | 1 | 101 Fri Dec 25 15:00:00 2009 PST | 2 | 104 Fri Jan 01 15:00:00 2010 PST | 1 | 101 Fri Jan 01 15:00:00 2010 PST | 2 | 104 Fri Dec 27 15:00:00 2019 PST | 1 | 101 Fri Dec 27 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamptz with custom origin ---- TRUNCATE temperaturetz; INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); CREATE MATERIALIZED VIEW cagg_temp_ng_1week_corgin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); SELECT * FROM cagg_temp_ng_1week_corgin; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_corgin'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_corgin ORDER BY time, sensor; time | sensor | avg ------------------------------+--------+----- Sat Dec 26 15:00:00 2009 PST | 1 | 101 Sat Dec 26 15:00:00 2009 PST | 2 | 104 Sat Dec 28 15:00:00 2019 PST | 1 | 101 Sat Dec 28 15:00:00 2019 PST | 2 | 104 ---- -- Check bucket conversion -- timestamp without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_timestamp WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Mon Dec 28 00:00:00 2009 | 1 | 101 Mon Dec 28 00:00:00 2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_timestamp; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_timestamp'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00'), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_timestamp ORDER BY time, sensor; time | sensor | avg --------------------------+--------+----- Sat Dec 26 00:00:00 2009 | 1 | 101 Sat Dec 26 00:00:00 2009 | 2 | 104 Sat Dec 28 00:00:00 2019 | 1 | 101 Sat Dec 28 00:00:00 2019 | 2 | 104 ---- -- Check bucket conversion -- date without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_date WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-28-2009 | 1 | 101 12-28-2009 | 2 | 104 SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_date; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket_ng | sensor | avg ----------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 01:00:00+00'), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; time_bucket | sensor | avg -------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_date ORDER BY time, sensor; time | sensor | avg ------------+--------+----- 12-26-2009 | 1 | 101 12-26-2009 | 2 | 104 12-28-2019 | 1 | 101 12-28-2019 | 2 | 104 -- Ensure we error out when the CAgg does not use a deprecated function \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); ERROR: CAgg cagg_temp_ng_1week_date does not use a deprecated bucket function \set ON_ERROR_STOP 1 ---- -- Test migration as non-owner (should fail) ---- CREATE MATERIALIZED VIEW cagg_tempdate_ng_acl WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_tempdate_ng_acl'); ERROR: must be owner of view cagg_tempdate_ng_acl \set ON_ERROR_STOP 1 ���������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_multi.out�������������������������������������������������0000664�0000000�0000000�00000032066�15100345067�0022310�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; CREATE TABLE continuous_agg_test(timeval integer, col1 integer, col2 integer); select create_hypertable('continuous_agg_test', 'timeval', chunk_time_interval=> 2); create_hypertable ---------------------------------- (1,public,continuous_agg_test,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timeval), 0) FROM continuous_agg_test $$; SELECT set_integer_now_func('continuous_agg_test', 'integer_now_test1'); set_integer_now_func ---------------------- INSERT INTO continuous_agg_test VALUES (10, - 4, 1), (11, - 3, 5), (12, - 3, 7), (13, - 3, 9), (14,-4, 11), (15, -4, 22), (16, -4, 23); -- TEST for multiple continuous aggs --- invalidations are picked up by both caggs CREATE MATERIALIZED VIEW cagg_1( timed, cnt ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket( 2, timeval), COUNT(col1) FROM continuous_agg_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW cagg_2( timed, grp, maxval) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(2, timeval), col1, max(col2) FROM continuous_agg_test GROUP BY 1, 2 WITH NO DATA; select view_name, view_owner, materialization_hypertable_name from timescaledb_information.continuous_aggregates ORDER BY 1; view_name | view_owner | materialization_hypertable_name -----------+-------------------+--------------------------------- cagg_1 | default_perm_user | _materialized_hypertable_2 cagg_2 | default_perm_user | _materialized_hypertable_3 --TEST1: cagg_1 is materialized, not cagg_2. CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; timed | cnt -------+----- 10 | 2 12 | 2 14 | 2 16 | 1 SELECT time_bucket(2, timeval), COUNT(col1) as value FROM continuous_agg_test GROUP BY 1 order by 1; time_bucket | value -------------+------- 10 | 2 12 | 2 14 | 2 16 | 1 -- check that cagg_2 not materialized select * from cagg_2 order by 1,2; timed | grp | maxval -------+-----+-------- CALL refresh_continuous_aggregate('cagg_2', NULL, NULL); select * from cagg_2 order by 1,2; timed | grp | maxval -------+-----+-------- 10 | -4 | 1 10 | -3 | 5 12 | -3 | 9 14 | -4 | 22 16 | -4 | 23 SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 18 --TEST2: cagg_2 gets invalidations after cagg_1's refresh --will trigger invalidations INSERT INTO continuous_agg_test VALUES (10, -4, 10), (11, - 3, 50), (11, - 3, 70), (10, - 4, 10); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 18 CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; timed | cnt -------+----- 10 | 6 12 | 2 14 | 2 16 | 1 SELECT time_bucket(2, timeval), COUNT(col1) as value FROM continuous_agg_test GROUP BY 1 order by 1; time_bucket | value -------------+------- 10 | 6 12 | 2 14 | 2 16 | 1 -- are the invalidations picked up here? select * from cagg_2 order by 1, 2; timed | grp | maxval -------+-----+-------- 10 | -4 | 1 10 | -3 | 5 12 | -3 | 9 14 | -4 | 22 16 | -4 | 23 SELECT time_bucket(2, timeval), col1, max(col2) FROM continuous_agg_test GROUP BY 1, 2 order by 1,2 ; time_bucket | col1 | max -------------+------+----- 10 | -4 | 10 10 | -3 | 70 12 | -3 | 9 14 | -4 | 22 16 | -4 | 23 CALL refresh_continuous_aggregate('cagg_2', NULL, NULL); select * from cagg_2 order by 1, 2; timed | grp | maxval -------+-----+-------- 10 | -4 | 10 10 | -3 | 70 12 | -3 | 9 14 | -4 | 22 16 | -4 | 23 --TEST3: invalidations left over by cagg_1 are dropped --trigger another invalidation INSERT INTO continuous_agg_test VALUES (10, -4, 1000); select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 1 select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 4 CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 5 --now drop cagg_1, should still have materialization_invalidation_log DROP MATERIALIZED VIEW cagg_1; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_5_chunk select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 3 --cagg_2 still exists select view_name from timescaledb_information.continuous_aggregates; view_name ----------- cagg_2 drop table continuous_agg_test cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_3_6_chunk select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 0 select view_name from timescaledb_information.continuous_aggregates; view_name ----------- --TEST4: invalidations that are copied over by cagg1 are not deleted by cagg2 refresh if -- they do not meet materialization invalidation threshold for cagg2. CREATE TABLE continuous_agg_test(timeval integer, col1 integer, col2 integer); select create_hypertable('continuous_agg_test', 'timeval', chunk_time_interval=> 2); create_hypertable ---------------------------------- (4,public,continuous_agg_test,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timeval), 0) FROM continuous_agg_test $$; SELECT set_integer_now_func('continuous_agg_test', 'integer_now_test1'); set_integer_now_func ---------------------- INSERT INTO continuous_agg_test VALUES (10, -4, 1), (11, -3, 5), (12, -3, 7), (13, -3, 9), (14, -4, 11), (15, -4, 22), (16, -4, 23); CREATE MATERIALIZED VIEW cagg_1( timed, cnt ) WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket( 2, timeval), COUNT(col1) FROM continuous_agg_test GROUP BY 1 WITH DATA; NOTICE: refreshing continuous aggregate "cagg_1" CREATE MATERIALIZED VIEW cagg_2( timed, maxval) WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(2, timeval), max(col2) FROM continuous_agg_test GROUP BY 1 WITH NO DATA; --cagg_1 already refreshed on creation select * from cagg_1 order by 1; timed | cnt -------+----- 10 | 2 12 | 2 14 | 2 16 | 1 --partially refresh cagg_2 to 14 to test inserts that won't be seen in --one of the caggs CALL refresh_continuous_aggregate('cagg_2', NULL, 14); select * from cagg_2 order by 1; timed | maxval -------+-------- 10 | 5 12 | 9 --this insert will be processed only by cagg_1 and copied over to cagg_2 insert into continuous_agg_test values( 14, -2, 100); CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; timed | cnt -------+----- 10 | 2 12 | 2 14 | 3 16 | 1 CALL refresh_continuous_aggregate('cagg_2', NULL, 14); NOTICE: continuous aggregate "cagg_2" is already up-to-date select * from cagg_2 order by 1; timed | maxval -------+-------- 10 | 5 12 | 9 SET ROLE :ROLE_SUPERUSER; select * from _timescaledb_catalog.continuous_aggs_invalidation_threshold order by 1; hypertable_id | watermark ---------------+----------- 4 | 18 select * from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log order by 1; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 5 | -9223372036854775808 | -2147483649 5 | 18 | 9223372036854775807 6 | -9223372036854775808 | -2147483649 6 | 14 | 9223372036854775807 SET ROLE :ROLE_DEFAULT_PERM_USER; --this insert will be processed only by cagg_1 and cagg_2 will process the previous --one insert into continuous_agg_test values( 18, -2, 200); CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; timed | cnt -------+----- 10 | 2 12 | 2 14 | 3 16 | 1 18 | 1 -- Now make changes visible up to 16 CALL refresh_continuous_aggregate('cagg_2', NULL, 16); select * from cagg_2 order by 1; timed | maxval -------+-------- 10 | 5 12 | 9 14 | 100 --TEST5 2 inserts with the same value can be copied over to materialization invalidation log insert into continuous_agg_test values( 18, -2, 100); insert into continuous_agg_test values( 18, -2, 100); select * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log order by 1; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 4 | 18 | 18 4 | 18 | 18 CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 where timed = 18 ; timed | cnt -------+----- 18 | 3 --copied over for cagg_2 to process later? select * from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log order by 1; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 5 | -9223372036854775808 | -2147483649 5 | 20 | 9223372036854775807 6 | -9223372036854775808 | -2147483649 6 | 16 | 9223372036854775807 6 | 18 | 19 DROP MATERIALIZED VIEW cagg_1; NOTICE: drop cascades to table _timescaledb_internal._hyper_5_11_chunk DROP MATERIALIZED VIEW cagg_2; NOTICE: drop cascades to table _timescaledb_internal._hyper_6_12_chunk ----TEST7 multiple continuous aggregates with real time aggregates test---- create table foo (a integer, b integer, c integer); select table_name FROM create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo INSERT into foo values( 1 , 10 , 20); INSERT into foo values( 1 , 11 , 20); INSERT into foo values( 1 , 12 , 20); INSERT into foo values( 1 , 13 , 20); INSERT into foo values( 1 , 14 , 20); INSERT into foo values( 5 , 14 , 20); INSERT into foo values( 5 , 15 , 20); INSERT into foo values( 5 , 16 , 20); INSERT into foo values( 20 , 16 , 20); INSERT into foo values( 20 , 26 , 20); INSERT into foo values( 20 , 16 , 20); INSERT into foo values( 21 , 15 , 30); INSERT into foo values( 21 , 15 , 30); INSERT into foo values( 21 , 15 , 30); INSERT into foo values( 45 , 14 , 70); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10, a), count(*) FROM foo GROUP BY time_bucket(10, a) WITH NO DATA; CREATE MATERIALIZED VIEW mat_m2(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), count(*) FROM foo GROUP BY time_bucket(5, a) WITH NO DATA; select view_name, materialized_only from timescaledb_information.continuous_aggregates WHERE view_name::text like 'mat_m%' order by view_name; view_name | materialized_only -----------+------------------- mat_m1 | f mat_m2 | f CALL refresh_continuous_aggregate('mat_m1', NULL, 35); CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); -- the results from the view should match the direct query SELECT * from mat_m1 order by 1; a | countb ----+-------- 0 | 8 20 | 6 40 | 1 SELECT time_bucket(5, a), count(*) FROM foo GROUP BY time_bucket(5, a) ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 3 20 | 6 45 | 1 SELECT * from mat_m2 order by 1; a | countb ----+-------- 0 | 5 5 | 3 20 | 6 45 | 1 SELECT time_bucket(10, a), count(*) FROM foo GROUP BY time_bucket(10, a) ORDER BY 1; time_bucket | count -------------+------- 0 | 8 20 | 6 40 | 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_on_cagg.out�����������������������������������������������0000664�0000000�0000000�00000737771�15100345067�0022572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Global test variables \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set IS_JOIN FALSE \set INTERVAL_TEST FALSE -- ######################################################## -- ## INTEGER data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION FALSE \set TIME_DIMENSION_DATATYPE INTEGER \set CAGG_NAME_1ST_LEVEL conditions_summary_1_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2_5 \set CAGG_NAME_3TH_LEVEL conditions_summary_3_10 -- -- Run common tests for INTEGER -- \set BUCKET_WIDTH_1ST 'INTEGER \'1\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set BUCKET_WIDTH_3TH 'INTEGER \'10\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; psql:include/cagg_on_cagg_setup.sql:8: NOTICE: table "conditions" does not exist, skipping \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); table_name ------------ conditions \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); set_integer_now_func ---------------------- INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -------------------------+---------------- conditions | 10 conditions_summary_1_1 | 100 conditions_summary_2_5 | 100 conditions_summary_3_10 | 100 \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 10 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 10 | 2 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 17 5 | 20 10 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 37 10 | 2 -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 17 5 | 20 10 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 37 10 | 2 -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_1 because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_5 because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_1" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_5" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_4_4_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_10" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_5" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_2_7_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_1" does not exist at character 15 \set ON_ERROR_STOP 1 -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); table_name ------------ conditions \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); set_integer_now_func ---------------------- INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -------------------------+---------------- conditions | 10 conditions_summary_1_1 | 100 conditions_summary_2_5 | 100 conditions_summary_3_10 | 100 \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 15 5 | 20 10 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 35 10 | 2 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 17 5 | 20 10 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 37 10 | 2 -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- 0 | 17 5 | 20 10 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- 0 | 37 10 | 2 -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_1 because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_5 because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_1" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_5" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_8_11_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_10" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_5" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_6_14_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_1" does not exist at character 15 \set ON_ERROR_STOP 1 -- -- Validation test for non-multiple bucket sizes -- \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_9.bucket, _materialized_hypertable_9.temperature FROM _timescaledb_internal._materialized_hypertable_9 WHERE _materialized_hypertable_9.bucket < COALESCE(_timescaledb_functions.cagg_watermark(9)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(2, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(9)::integer, '-2147483648'::integer) GROUP BY (time_bucket(2, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [5] should be multiple of the time bucket width of "public.conditions_summary_1" [2]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for equal bucket sizes -- \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_10.bucket, _materialized_hypertable_10.temperature FROM _timescaledb_internal._materialized_hypertable_10 WHERE _materialized_hypertable_10.bucket < COALESCE(_timescaledb_functions.cagg_watermark(10)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(2, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(10)::integer, '-2147483648'::integer) GROUP BY (time_bucket(2, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE SHOULD WORK because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_11.bucket, _materialized_hypertable_11.temperature FROM _timescaledb_internal._materialized_hypertable_11 WHERE _materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.cagg_watermark(11)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(2, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.cagg_watermark(11)::integer, '-2147483648'::integer) GROUP BY (time_bucket(2, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for bucket size less than source -- \set BUCKET_WIDTH_1ST 'INTEGER \'4\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_12.bucket, _materialized_hypertable_12.temperature FROM _timescaledb_internal._materialized_hypertable_12 WHERE _materialized_hypertable_12.bucket < COALESCE(_timescaledb_functions.cagg_watermark(12)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(4, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(12)::integer, '-2147483648'::integer) GROUP BY (time_bucket(4, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [2] should be greater or equal than the time bucket width of "public.conditions_summary_1" [4]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- ######################################################## -- ## TIMESTAMP data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMP \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMP -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); psql:include/cagg_on_cagg_setup.sql:30: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 Mon Jan 03 00:00:00 2022 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 Mon Jan 03 00:00:00 2022 | 2 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 17 Sun Jan 02 00:00:00 2022 | 20 Mon Jan 03 00:00:00 2022 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 37 Mon Jan 03 00:00:00 2022 | 2 -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 17 Sun Jan 02 00:00:00 2022 | 20 Mon Jan 03 00:00:00 2022 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 37 Mon Jan 03 00:00:00 2022 | 2 -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_18_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_20_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); psql:include/cagg_on_cagg_setup.sql:30: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 15 Sun Jan 02 00:00:00 2022 | 20 Mon Jan 03 00:00:00 2022 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 35 Mon Jan 03 00:00:00 2022 | 2 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 17 Sun Jan 02 00:00:00 2022 | 20 Mon Jan 03 00:00:00 2022 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 37 Mon Jan 03 00:00:00 2022 | 2 -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------------------------+------------- Sat Jan 01 00:00:00 2022 | 17 Sun Jan 02 00:00:00 2022 | 20 Mon Jan 03 00:00:00 2022 | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------------------------+------------- Mon Dec 27 00:00:00 2021 | 37 Mon Jan 03 00:00:00 2022 | 2 -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_26_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- -- Validation test for variable bucket on top of fixed bucket -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_21.bucket, _materialized_hypertable_21.temperature FROM _timescaledb_internal._materialized_hypertable_21 WHERE _materialized_hypertable_21.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(21)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(21)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with fixed-width bucket on top of one using variable-width bucket DETAIL: Continuous aggregate with a fixed time bucket width (e.g. 61 days) cannot be created on top of one using variable time bucket width (e.g. 1 month). The variance can lead to the fixed width one not being a multiple of the variable width one. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for non-multiple bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_22.bucket, _materialized_hypertable_22.temperature FROM _timescaledb_internal._materialized_hypertable_22 WHERE _materialized_hypertable_22.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(22)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(22)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 3 hours] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for equal bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_23.bucket, _materialized_hypertable_23.temperature FROM _timescaledb_internal._materialized_hypertable_23 WHERE _materialized_hypertable_23.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(23)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(23)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE SHOULD WORK because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_24.bucket, _materialized_hypertable_24.temperature FROM _timescaledb_internal._materialized_hypertable_24 WHERE _materialized_hypertable_24.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(24)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(24)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for bucket size less than source -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_25.bucket, _materialized_hypertable_25.temperature FROM _timescaledb_internal._materialized_hypertable_25 WHERE _materialized_hypertable_25.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(25)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(25)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 hour] should be greater or equal than the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- ######################################################## -- ## TIMESTAMPTZ data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMPTZ -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 Mon Jan 03 00:00:00 2022 UTC | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 Mon Jan 03 00:00:00 2022 UTC | 2 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 17 Sun Jan 02 00:00:00 2022 UTC | 20 Mon Jan 03 00:00:00 2022 UTC | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 37 Mon Jan 03 00:00:00 2022 UTC | 2 -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 17 Sun Jan 02 00:00:00 2022 UTC | 20 Mon Jan 03 00:00:00 2022 UTC | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 37 Mon Jan 03 00:00:00 2022 UTC | 2 -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_30_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_32_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 15 Sun Jan 02 00:00:00 2022 UTC | 20 Mon Jan 03 00:00:00 2022 UTC | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 35 Mon Jan 03 00:00:00 2022 UTC | 2 -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 17 Sun Jan 02 00:00:00 2022 UTC | 20 Mon Jan 03 00:00:00 2022 UTC | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 37 Mon Jan 03 00:00:00 2022 UTC | 2 -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature --------+------------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature ------------------------------+------------- Sat Jan 01 00:00:00 2022 UTC | 17 Sun Jan 02 00:00:00 2022 UTC | 20 Mon Jan 03 00:00:00 2022 UTC | 2 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature ------------------------------+------------- Mon Dec 27 00:00:00 2021 UTC | 37 Mon Jan 03 00:00:00 2022 UTC | 2 -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_33_36_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature --------+------------- -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_31_38_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- -- Validation test for variable bucket on top of fixed bucket -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_34.bucket, _materialized_hypertable_34.temperature FROM _timescaledb_internal._materialized_hypertable_34 WHERE _materialized_hypertable_34.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(34)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(34)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with fixed-width bucket on top of one using variable-width bucket DETAIL: Continuous aggregate with a fixed time bucket width (e.g. 61 days) cannot be created on top of one using variable time bucket width (e.g. 1 month). The variance can lead to the fixed width one not being a multiple of the variable width one. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for non-multiple bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_35.bucket, _materialized_hypertable_35.temperature FROM _timescaledb_internal._materialized_hypertable_35 WHERE _materialized_hypertable_35.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(35)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(35)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 3 hours] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for equal bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_36.bucket, _materialized_hypertable_36.temperature FROM _timescaledb_internal._materialized_hypertable_36 WHERE _materialized_hypertable_36.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(36)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(36)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE SHOULD WORK because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_37.bucket, _materialized_hypertable_37.temperature FROM _timescaledb_internal._materialized_hypertable_37 WHERE _materialized_hypertable_37.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(37)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(37)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for bucket size less than source -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_38.bucket, _materialized_hypertable_38.temperature FROM _timescaledb_internal._materialized_hypertable_38 WHERE _materialized_hypertable_38.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(38)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(38)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 hour] should be greater or equal than the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validations using time bucket with timezone (ref issue #5126) -- \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set CAGG_NAME_1ST_LEVEL conditions_summary_1_5m \set CAGG_NAME_2TH_LEVEL conditions_summary_2_1h \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'US/Pacific' \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_39.bucket, _materialized_hypertable_39.temperature FROM _timescaledb_internal._materialized_hypertable_39 WHERE _materialized_hypertable_39.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(39)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(39)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_40.bucket, _materialized_hypertable_40.temperature FROM _timescaledb_internal._materialized_hypertable_40 WHERE _materialized_hypertable_40.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(40)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket, 'US/Pacific'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(40)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket, 'US/Pacific'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'16 minutes\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_41.bucket, _materialized_hypertable_41.temperature FROM _timescaledb_internal._materialized_hypertable_41 WHERE _materialized_hypertable_41.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(41)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(41)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 16 mins] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 5 mins]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Variable bucket size with the same timezones -- \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_42.bucket, _materialized_hypertable_42.temperature FROM _timescaledb_internal._materialized_hypertable_42 WHERE _materialized_hypertable_42.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(42)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(42)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_43.bucket, _materialized_hypertable_43.temperature FROM _timescaledb_internal._materialized_hypertable_43 WHERE _materialized_hypertable_43.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(43)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(43)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; --#Bugfix 5734 #1 \set INTERVAL_TEST TRUE \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_44.bucket, _materialized_hypertable_44.temperature FROM _timescaledb_internal._materialized_hypertable_44 WHERE _materialized_hypertable_44.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(44)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(44)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_45.bucket, _materialized_hypertable_45.temperature FROM _timescaledb_internal._materialized_hypertable_45 WHERE _materialized_hypertable_45.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(45)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(45)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; psql:include/cagg_on_cagg_validations.sql:71: NOTICE: refreshing continuous aggregate "conditions_summary_3" \d+ :CAGG_NAME_3TH_LEVEL View "public.conditions_summary_3" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | View definition: SELECT _materialized_hypertable_46.bucket FROM _timescaledb_internal._materialized_hypertable_46 WHERE _materialized_hypertable_46.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(46)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_2.bucket, 'UTC'::text) AS bucket FROM conditions_summary_2 WHERE conditions_summary_2.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(46)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_2.bucket, 'UTC'::text)); --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; bucket ------------------------------ Sat Jan 01 00:00:00 2022 UTC DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:79: NOTICE: drop cascades to table _timescaledb_internal._hyper_46_43_chunk DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: drop cascades to table _timescaledb_internal._hyper_45_42_chunk DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_validations.sql:87: NOTICE: drop cascades to table _timescaledb_internal._hyper_44_41_chunk \set INTERVAL_TEST FALSE -- -- Variable bucket size with different timezones -- \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_47.bucket, _materialized_hypertable_47.temperature FROM _timescaledb_internal._materialized_hypertable_47 WHERE _materialized_hypertable_47.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(47)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(47)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_48.bucket, _materialized_hypertable_48.temperature FROM _timescaledb_internal._materialized_hypertable_48 WHERE _materialized_hypertable_48.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(48)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(48)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; --#Bugfix 5734 #2 \set INTERVAL_TEST TRUE \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_49.bucket, _materialized_hypertable_49.temperature FROM _timescaledb_internal._materialized_hypertable_49 WHERE _materialized_hypertable_49.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(49)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(49)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_50.bucket, _materialized_hypertable_50.temperature FROM _timescaledb_internal._materialized_hypertable_50 WHERE _materialized_hypertable_50.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(50)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(50)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; psql:include/cagg_on_cagg_validations.sql:71: NOTICE: refreshing continuous aggregate "conditions_summary_3" \d+ :CAGG_NAME_3TH_LEVEL View "public.conditions_summary_3" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | View definition: SELECT _materialized_hypertable_51.bucket FROM _timescaledb_internal._materialized_hypertable_51 WHERE _materialized_hypertable_51.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(51)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_2.bucket, 'UTC'::text) AS bucket FROM conditions_summary_2 WHERE conditions_summary_2.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(51)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_2.bucket, 'UTC'::text)); --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; bucket ------------------------------ Sat Jan 01 00:00:00 2022 UTC DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:79: NOTICE: drop cascades to table _timescaledb_internal._hyper_51_46_chunk DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: drop cascades to table _timescaledb_internal._hyper_50_45_chunk DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_validations.sql:87: NOTICE: drop cascades to table _timescaledb_internal._hyper_49_44_chunk \set INTERVAL_TEST FALSE -- -- TZ bucket on top of non-TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_52.bucket, _materialized_hypertable_52.temperature FROM _timescaledb_internal._materialized_hypertable_52 WHERE _materialized_hypertable_52.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(52)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(52)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_53.bucket, _materialized_hypertable_53.temperature FROM _timescaledb_internal._materialized_hypertable_53 WHERE _materialized_hypertable_53.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; --#Bugfix 5734 #3 \set INTERVAL_TEST TRUE \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_54.bucket, _materialized_hypertable_54.temperature FROM _timescaledb_internal._materialized_hypertable_54 WHERE _materialized_hypertable_54.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(54)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(54)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_55.bucket, _materialized_hypertable_55.temperature FROM _timescaledb_internal._materialized_hypertable_55 WHERE _materialized_hypertable_55.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(55)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(55)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; psql:include/cagg_on_cagg_validations.sql:71: NOTICE: refreshing continuous aggregate "conditions_summary_3" \d+ :CAGG_NAME_3TH_LEVEL View "public.conditions_summary_3" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | View definition: SELECT _materialized_hypertable_56.bucket FROM _timescaledb_internal._materialized_hypertable_56 WHERE _materialized_hypertable_56.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(56)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_2.bucket, 'UTC'::text) AS bucket FROM conditions_summary_2 WHERE conditions_summary_2.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(56)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_2.bucket, 'UTC'::text)); --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; bucket ------------------------------ Sat Jan 01 00:00:00 2022 UTC DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:79: NOTICE: drop cascades to table _timescaledb_internal._hyper_56_49_chunk DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: drop cascades to table _timescaledb_internal._hyper_55_48_chunk DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_validations.sql:87: NOTICE: drop cascades to table _timescaledb_internal._hyper_54_47_chunk \set INTERVAL_TEST FALSE -- -- non-TZ bucket on top of TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_57.bucket, _materialized_hypertable_57.temperature FROM _timescaledb_internal._materialized_hypertable_57 WHERE _materialized_hypertable_57.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(57)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(57)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_58.bucket, _materialized_hypertable_58.temperature FROM _timescaledb_internal._materialized_hypertable_58 WHERE _materialized_hypertable_58.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(58)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(58)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- test some intuitive intervals that should work but -- were not working due to unix epochs -- validation test for 1 year on top of one day -- validation test for 1 year on top of 1 month -- validation test for 1 year on top of 1 week -- bug report 5231 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_59.bucket, _materialized_hypertable_59.temperature FROM _timescaledb_internal._materialized_hypertable_59 WHERE _materialized_hypertable_59.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_60.bucket, _materialized_hypertable_60.temperature FROM _timescaledb_internal._materialized_hypertable_60 WHERE _materialized_hypertable_60.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(60)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 year'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(60)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 year'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_61.bucket, _materialized_hypertable_61.temperature FROM _timescaledb_internal._materialized_hypertable_61 WHERE _materialized_hypertable_61.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(61)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(61)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_62.bucket, _materialized_hypertable_62.temperature FROM _timescaledb_internal._materialized_hypertable_62 WHERE _materialized_hypertable_62.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(62)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 3 mons'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(62)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 3 mons'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_63.bucket, _materialized_hypertable_63.temperature FROM _timescaledb_internal._materialized_hypertable_63 WHERE _materialized_hypertable_63.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(63)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(63)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_64.bucket, _materialized_hypertable_64.temperature FROM _timescaledb_internal._materialized_hypertable_64 WHERE _materialized_hypertable_64.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(64)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 year'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(64)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 year'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_65.bucket, _materialized_hypertable_65.temperature FROM _timescaledb_internal._materialized_hypertable_65 WHERE _materialized_hypertable_65.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(65)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(65)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 year] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 7 days]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_66.bucket, _materialized_hypertable_66.temperature FROM _timescaledb_internal._materialized_hypertable_66 WHERE _materialized_hypertable_66.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(66)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(66)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 mon] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 7 days]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- bug report 5277 \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE -- epoch plus cast to int would compute a bucket width of 0 for parent \set BUCKET_WIDTH_1ST 'INTERVAL \'146 ms\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1168 ms\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_67.bucket, _materialized_hypertable_67.temperature FROM _timescaledb_internal._materialized_hypertable_67 WHERE _materialized_hypertable_67.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(67)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 0.146 secs'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(67)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 0.146 secs'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_68.bucket, _materialized_hypertable_68.temperature FROM _timescaledb_internal._materialized_hypertable_68 WHERE _materialized_hypertable_68.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(68)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1.168 secs'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(68)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1.168 secs'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'9344 ms\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'74752 ms\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_69.bucket, _materialized_hypertable_69.temperature FROM _timescaledb_internal._materialized_hypertable_69 WHERE _materialized_hypertable_69.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(69)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 9.344 secs'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(69)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 9.344 secs'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_70.bucket, _materialized_hypertable_70.temperature FROM _timescaledb_internal._materialized_hypertable_70 WHERE _materialized_hypertable_70.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(70)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 min 14.752 secs'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(70)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 min 14.752 secs'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'74752 ms\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'598016 ms\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_71.bucket, _materialized_hypertable_71.temperature FROM _timescaledb_internal._materialized_hypertable_71 WHERE _materialized_hypertable_71.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(71)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 min 14.752 secs'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(71)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 min 14.752 secs'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_72.bucket, _materialized_hypertable_72.temperature FROM _timescaledb_internal._materialized_hypertable_72 WHERE _materialized_hypertable_72.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(72)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 9 mins 58.016 secs'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(72)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 9 mins 58.016 secs'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- test microseconds - should pass \set BUCKET_WIDTH_1ST 'INTERVAL \'146 usec\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1168 usec\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_73.bucket, _materialized_hypertable_73.temperature FROM _timescaledb_internal._materialized_hypertable_73 WHERE _materialized_hypertable_73.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(73)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 0.000146 secs'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(73)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 0.000146 secs'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_74.bucket, _materialized_hypertable_74.temperature FROM _timescaledb_internal._materialized_hypertable_74 WHERE _materialized_hypertable_74.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(74)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 0.001168 secs'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(74)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 0.001168 secs'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- test microseconds - SHOULD FAIL \set BUCKET_WIDTH_1ST 'INTERVAL \'146 usec\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1160 usec\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_75.bucket, _materialized_hypertable_75.temperature FROM _timescaledb_internal._materialized_hypertable_75 WHERE _materialized_hypertable_75.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(75)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 0.000146 secs'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(75)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 0.000146 secs'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 0.00116 secs] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 0.000146 secs]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; �������timescaledb-2.23.0/tsl/test/expected/cagg_on_cagg_joins.out�����������������������������������������0000664�0000000�0000000�00000643273�15100345067�0023765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Global test variables \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set IS_JOIN TRUE \set INTERVAL_TEST FALSE -- ######################################################## -- ## INTEGER data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION FALSE \set TIME_DIMENSION_DATATYPE INTEGER \set CAGG_NAME_1ST_LEVEL conditions_summary_1_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2_5 \set CAGG_NAME_3TH_LEVEL conditions_summary_3_10 -- -- Run common tests for INTEGER -- \set BUCKET_WIDTH_1ST 'INTEGER \'1\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set BUCKET_WIDTH_3TH 'INTEGER \'10\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; psql:include/cagg_on_cagg_setup.sql:8: NOTICE: table "conditions" does not exist, skipping \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; psql:include/cagg_on_cagg_setup.sql:24: NOTICE: table "devices" does not exist, skipping CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); table_name ------------ conditions \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); set_integer_now_func ---------------------- INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -------------------------+---------------- conditions | 10 conditions_summary_1_1 | 100 conditions_summary_2_5 | 100 conditions_summary_3_10 | 100 \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_1 because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_5 because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_1" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_5" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_4_4_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_10" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_5" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_2_7_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_1" does not exist at character 15 \set ON_ERROR_STOP 1 -- Default tests \set ON_ERROR_STOP 0 \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); table_name ------------ conditions \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); set_integer_now_func ---------------------- INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -------------------------+---------------- conditions | 10 conditions_summary_1_1 | 100 conditions_summary_2_5 | 100 conditions_summary_3_10 | 100 \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+---------- 0 | 5 | 2 | thermo_2 0 | 10 | 1 | thermo_1 5 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+----------+---------- 0 | 5 | 2 | thermo_2 | Berlin 0 | 10 | 1 | thermo_1 | Moscow 0 | 20 | 3 | thermo_3 | London -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_1 because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_5 because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_1" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_5" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_8_11_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_10" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_5" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- 1 | 10 | 1 2 | 2 | 2 | 5 | 2 5 | 20 | 3 10 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_6_14_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_1" does not exist at character 15 \set ON_ERROR_STOP 1 -- -- Validation test for non-multiple bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_9.bucket, _materialized_hypertable_9.temperature FROM _timescaledb_internal._materialized_hypertable_9 WHERE _materialized_hypertable_9.bucket < COALESCE(_timescaledb_functions.cagg_watermark(9)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(2, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(9)::integer, '-2147483648'::integer) GROUP BY (time_bucket(2, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [5] should be multiple of the time bucket width of "public.conditions_summary_1" [2]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for equal bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_10.bucket, _materialized_hypertable_10.temperature FROM _timescaledb_internal._materialized_hypertable_10 WHERE _materialized_hypertable_10.bucket < COALESCE(_timescaledb_functions.cagg_watermark(10)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(2, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(10)::integer, '-2147483648'::integer) GROUP BY (time_bucket(2, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE SHOULD WORK because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_11.bucket, _materialized_hypertable_11.temperature FROM _timescaledb_internal._materialized_hypertable_11 WHERE _materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.cagg_watermark(11)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(2, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.cagg_watermark(11)::integer, '-2147483648'::integer) GROUP BY (time_bucket(2, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for bucket size less than source -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTEGER \'4\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+---------+-----------+----------+---------+---------+------------- bucket | integer | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_12.bucket, _materialized_hypertable_12.temperature FROM _timescaledb_internal._materialized_hypertable_12 WHERE _materialized_hypertable_12.bucket < COALESCE(_timescaledb_functions.cagg_watermark(12)::integer, '-2147483648'::integer) UNION ALL SELECT time_bucket(4, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.cagg_watermark(12)::integer, '-2147483648'::integer) GROUP BY (time_bucket(4, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [2] should be greater or equal than the time bucket width of "public.conditions_summary_1" [4]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- ######################################################## -- ## TIMESTAMP data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMP \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly \set IS_JOIN TRUE SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMP -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); psql:include/cagg_on_cagg_setup.sql:30: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_18_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_20_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); psql:include/cagg_on_cagg_setup.sql:30: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 | 20 | 3 | thermo_3 | London -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 | 10 | 1 Sat Jan 01 01:00:00 2022 | 2 | Sat Jan 01 01:00:00 2022 | 5 | 2 Sun Jan 02 01:00:00 2022 | 20 | 3 Mon Jan 03 01:00:00 2022 | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_26_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- -- Validation test for variable bucket on top of fixed bucket -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_21.bucket, _materialized_hypertable_21.temperature FROM _timescaledb_internal._materialized_hypertable_21 WHERE _materialized_hypertable_21.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(21)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(21)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with fixed-width bucket on top of one using variable-width bucket DETAIL: Continuous aggregate with a fixed time bucket width (e.g. 61 days) cannot be created on top of one using variable time bucket width (e.g. 1 month). The variance can lead to the fixed width one not being a multiple of the variable width one. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for non-multiple bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_22.bucket, _materialized_hypertable_22.temperature FROM _timescaledb_internal._materialized_hypertable_22 WHERE _materialized_hypertable_22.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(22)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(22)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 3 hours] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for equal bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_23.bucket, _materialized_hypertable_23.temperature FROM _timescaledb_internal._materialized_hypertable_23 WHERE _materialized_hypertable_23.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(23)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(23)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE SHOULD WORK because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_24.bucket, _materialized_hypertable_24.temperature FROM _timescaledb_internal._materialized_hypertable_24 WHERE _materialized_hypertable_24.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(24)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(24)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for bucket size less than source -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+-----------------------------+-----------+----------+---------+---------+------------- bucket | timestamp without time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_25.bucket, _materialized_hypertable_25.temperature FROM _timescaledb_internal._materialized_hypertable_25 WHERE _materialized_hypertable_25.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(25)), '-infinity'::timestamp without time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(25)), '-infinity'::timestamp without time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 hour] should be greater or equal than the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- ######################################################## -- ## TIMESTAMPTZ data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMPTZ -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set ON_ERROR_STOP 0 \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_30_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_32_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- Default tests \set ON_ERROR_STOP 0 \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif \ir include/cagg_on_cagg_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; name | chunk_interval -----------------------------+---------------- conditions | @ 7 days conditions_summary_1_hourly | @ 70 days conditions_summary_2_daily | @ 70 days conditions_summary_3_weekly | @ 70 days \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id --------+-------------+----------- SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location --------+-------------+-----------+------+---------- -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name ------------------------------+-------------+-----------+---------- Sat Jan 01 00:00:00 2022 UTC | 5 | 2 | thermo_2 Sat Jan 01 00:00:00 2022 UTC | 10 | 1 | thermo_1 Sun Jan 02 00:00:00 2022 UTC | 20 | 3 | thermo_3 SELECT * FROM :CAGG_NAME_3TH_LEVEL; bucket | temperature | device_id | name | location ------------------------------+-------------+-----------+----------+---------- Mon Dec 27 00:00:00 2021 UTC | 5 | 2 | thermo_2 | Berlin Mon Dec 27 00:00:00 2021 UTC | 10 | 1 | thermo_1 | Moscow Mon Dec 27 00:00:00 2021 UTC | 20 | 3 | thermo_3 | London -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:172: ERROR: cannot drop view conditions_summary_1_hourly because other objects depend on it DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:173: ERROR: cannot drop view conditions_summary_2_daily because other objects depend on it CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:174: NOTICE: continuous aggregate "conditions_summary_1_hourly" is already up-to-date CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); psql:include/cagg_on_cagg_common.sql:175: NOTICE: continuous aggregate "conditions_summary_2_daily" is already up-to-date \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:179: NOTICE: drop cascades to table _timescaledb_internal._hyper_33_36_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; psql:include/cagg_on_cagg_common.sql:182: ERROR: relation "conditions_summary_3_weekly" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | SELECT * FROM :CAGG_NAME_2TH_LEVEL; bucket | temperature | device_id | name --------+-------------+-----------+------ -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_common.sql:196: ERROR: relation "conditions_summary_2_daily" does not exist at character 15 \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; bucket | temperature | device_id ------------------------------+-------------+----------- Sat Jan 01 00:00:00 2022 UTC | 10 | 1 Sat Jan 01 01:00:00 2022 UTC | 2 | Sat Jan 01 01:00:00 2022 UTC | 5 | 2 Sun Jan 02 01:00:00 2022 UTC | 20 | 3 Mon Jan 03 01:00:00 2022 UTC | 2 | -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:203: NOTICE: drop cascades to table _timescaledb_internal._hyper_31_38_chunk \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; psql:include/cagg_on_cagg_common.sql:206: ERROR: relation "conditions_summary_1_hourly" does not exist at character 15 \set ON_ERROR_STOP 1 -- -- Validation test for variable bucket on top of fixed bucket -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_34.bucket, _materialized_hypertable_34.temperature FROM _timescaledb_internal._materialized_hypertable_34 WHERE _materialized_hypertable_34.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(34)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(34)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with fixed-width bucket on top of one using variable-width bucket DETAIL: Continuous aggregate with a fixed time bucket width (e.g. 61 days) cannot be created on top of one using variable time bucket width (e.g. 1 month). The variance can lead to the fixed width one not being a multiple of the variable width one. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for non-multiple bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_35.bucket, _materialized_hypertable_35.temperature FROM _timescaledb_internal._materialized_hypertable_35 WHERE _materialized_hypertable_35.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(35)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(35)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 3 hours] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for equal bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_36.bucket, _materialized_hypertable_36.temperature FROM _timescaledb_internal._materialized_hypertable_36 WHERE _materialized_hypertable_36.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(36)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(36)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE SHOULD WORK because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_37.bucket, _materialized_hypertable_37.temperature FROM _timescaledb_internal._materialized_hypertable_37 WHERE _materialized_hypertable_37.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(37)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(37)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validation test for bucket size less than source -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_38.bucket, _materialized_hypertable_38.temperature FROM _timescaledb_internal._materialized_hypertable_38 WHERE _materialized_hypertable_38.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(38)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 2 hours'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(38)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 2 hours'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because new bucket should be greater than previous CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 hour] should be greater or equal than the time bucket width of "public.conditions_summary_1" [@ 2 hours]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Validations using time bucket with timezone (ref issue #5126) -- \set ON_ERROR_STOP 0 \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set CAGG_NAME_1ST_LEVEL conditions_summary_1_5m \set CAGG_NAME_2TH_LEVEL conditions_summary_2_1h \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'US/Pacific' \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_39.bucket, _materialized_hypertable_39.temperature FROM _timescaledb_internal._materialized_hypertable_39 WHERE _materialized_hypertable_39.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(39)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(39)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_40.bucket, _materialized_hypertable_40.temperature FROM _timescaledb_internal._materialized_hypertable_40 WHERE _materialized_hypertable_40.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(40)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket, 'US/Pacific'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(40)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 hour'::interval, conditions_summary_1.bucket, 'US/Pacific'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'16 minutes\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_41.bucket, _materialized_hypertable_41.temperature FROM _timescaledb_internal._materialized_hypertable_41 WHERE _materialized_hypertable_41.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(41)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(41)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 5 mins'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD ERROR because non-multiple bucket sizes CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 16 mins] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 5 mins]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Variable bucket size with the same timezones -- \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_42.bucket, _materialized_hypertable_42.temperature FROM _timescaledb_internal._materialized_hypertable_42 WHERE _materialized_hypertable_42.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(42)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(42)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_43.bucket, _materialized_hypertable_43.temperature FROM _timescaledb_internal._materialized_hypertable_43 WHERE _materialized_hypertable_43.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(43)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(43)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- Variable bucket size with different timezones -- \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_44.bucket, _materialized_hypertable_44.temperature FROM _timescaledb_internal._materialized_hypertable_44 WHERE _materialized_hypertable_44.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(44)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'US/Pacific'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(44)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'US/Pacific'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_45.bucket, _materialized_hypertable_45.temperature FROM _timescaledb_internal._materialized_hypertable_45 WHERE _materialized_hypertable_45.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(45)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(45)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- TZ bucket on top of non-TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_46.bucket, _materialized_hypertable_46.temperature FROM _timescaledb_internal._materialized_hypertable_46 WHERE _materialized_hypertable_46.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(46)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time") AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(46)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time")); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_47.bucket, _materialized_hypertable_47.temperature FROM _timescaledb_internal._materialized_hypertable_47 WHERE _materialized_hypertable_47.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(47)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(47)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket, 'UTC'::text)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- -- non-TZ bucket on top of TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_48.bucket, _materialized_hypertable_48.temperature FROM _timescaledb_internal._materialized_hypertable_48 WHERE _materialized_hypertable_48.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(48)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(48)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_49.bucket, _materialized_hypertable_49.temperature FROM _timescaledb_internal._materialized_hypertable_49 WHERE _materialized_hypertable_49.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(49)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(49)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; -- test some intuitive intervals that should work but -- were not working due to unix epochs -- validation test for 1 year on top of one day -- validation test for 1 year on top of 1 month -- validation test for 1 year on top of 1 week -- bug report 5231 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_50.bucket, _materialized_hypertable_50.temperature FROM _timescaledb_internal._materialized_hypertable_50 WHERE _materialized_hypertable_50.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(50)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(50)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_51.bucket, _materialized_hypertable_51.temperature FROM _timescaledb_internal._materialized_hypertable_51 WHERE _materialized_hypertable_51.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(51)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 year'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(51)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 year'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_52.bucket, _materialized_hypertable_52.temperature FROM _timescaledb_internal._materialized_hypertable_52 WHERE _materialized_hypertable_52.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(52)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(52)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_53.bucket, _materialized_hypertable_53.temperature FROM _timescaledb_internal._materialized_hypertable_53 WHERE _materialized_hypertable_53.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 3 mons'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(53)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 3 mons'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_54.bucket, _materialized_hypertable_54.temperature FROM _timescaledb_internal._materialized_hypertable_54 WHERE _materialized_hypertable_54.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(54)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 mon'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(54)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 mon'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL View "public.conditions_summary_2" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_55.bucket, _materialized_hypertable_55.temperature FROM _timescaledb_internal._materialized_hypertable_55 WHERE _materialized_hypertable_55.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(55)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 year'::interval, conditions_summary_1.bucket) AS bucket, sum(conditions_summary_1.temperature) AS temperature FROM conditions_summary_1 WHERE conditions_summary_1.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(55)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 year'::interval, conditions_summary_1.bucket)); \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_56.bucket, _materialized_hypertable_56.temperature FROM _timescaledb_internal._materialized_hypertable_56 WHERE _materialized_hypertable_56.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(56)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(56)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 year] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 7 days]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL View "public.conditions_summary_1" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | temperature | numeric | | | | main | View definition: SELECT _materialized_hypertable_57.bucket, _materialized_hypertable_57.temperature FROM _timescaledb_internal._materialized_hypertable_57 WHERE _materialized_hypertable_57.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(57)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text) AS bucket, sum(conditions.temperature) AS temperature FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(57)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time", 'UTC'::text)); -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE -- SHOULD WORK CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; psql:include/cagg_on_cagg_validations.sql:44: ERROR: cannot create continuous aggregate with incompatible bucket width DETAIL: Time bucket width of "public.conditions_summary_2" [@ 1 mon] should be multiple of the time bucket width of "public.conditions_summary_1" [@ 7 days]. \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; psql:include/cagg_on_cagg_validations.sql:86: NOTICE: materialized view "conditions_summary_2" does not exist, skipping DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_permissions-15.out����������������������������������������0000664�0000000�0000000�00000033373�15100345067�0023756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, (SELECT relacl FROM pg_class WHERE oid = user_view) AS user_view_perm, relname AS mat_table, (relacl) AS mat_table_perm, direct_view, (SELECT relacl FROM pg_class WHERE oid = direct_view) AS direct_view_perm, partial_view, (SELECT relacl FROM pg_class WHERE oid = partial_view) AS partial_view_perm FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; -- Manually create index on CAgg CREATE INDEX cagg_idx on mat_refresh_test(location); \c :TEST_DBNAME :ROLE_SUPERUSER CREATE USER not_priv; \c :TEST_DBNAME not_priv -- A user with no ownership on the Cagg cannot create index on it. -- This should fail \set ON_ERROR_STOP 0 CREATE INDEX cagg_idx on mat_refresh_test(humidity); ERROR: must be owner of hypertable "_materialized_hypertable_2" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER not_priv; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_continuous_aggregate_policy('mat_refresh_test', NULL, -200::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate(' mat_refresh_test', NULL, NULL); SELECT id as cagg_job_id FROM _timescaledb_config.bgw_job order by id desc limit 1 \gset SELECT format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name ) as materialization_hypertable FROM timescaledb_information.continuous_aggregates WHERE view_name = 'mat_refresh_test' \gset SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_refresh_test' \gset SELECT schema_name as mat_chunk_schema, table_name as mat_chunk_table FROM _timescaledb_catalog.chunk WHERE hypertable_id = :mat_hypertable_id ORDER BY id desc LIMIT 1 \gset CREATE TABLE conditions_for_perm_check ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check', 'timec', chunk_time_interval=> 100); table_name --------------------------- conditions_for_perm_check CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check $$; SELECT set_integer_now_func('conditions_for_perm_check', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE TABLE conditions_for_perm_check_w_grant ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check_w_grant', 'timec', chunk_time_interval=> 100); table_name ----------------------------------- conditions_for_perm_check_w_grant CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check_w_grant $$; SELECT set_integer_now_func('conditions_for_perm_check_w_grant', 'integer_now_test3'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; insert into conditions_for_perm_check_w_grant select generate_series(0, 30, 10), 'POR', 55, 75, 40, 70, NULL; --need both select and trigger permissions to create a materialized view on top of it. GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; \c :TEST_DBNAME :ROLE_SUPERUSER create schema custom_schema; CREATE FUNCTION get_constant() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant() FROM PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:cagg_job_id, max_runtime => NULL); ERROR: insufficient permissions to alter job 1000 --make sure that commands fail ALTER MATERIALIZED VIEW mat_refresh_test SET(timescaledb.materialized_only = true); ERROR: must be owner of continuous aggregate "mat_refresh_test" DROP MATERIALIZED VIEW mat_refresh_test; ERROR: must be owner of view mat_refresh_test CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); ERROR: must be owner of view mat_refresh_test SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test -- Test permissions also when the watermark is not constified and the ACL checks -- in ts_continuous_agg_watermark are executed SET timescaledb.enable_cagg_watermark_constify = OFF; SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test RESET timescaledb.enable_cagg_watermark_constify; SELECT * FROM :materialization_hypertable; ERROR: permission denied for table _materialized_hypertable_2 SELECT * FROM :"mat_chunk_schema".:"mat_chunk_table"; ERROR: permission denied for table _hyper_2_2_chunk --cannot create a mat view without select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for table conditions_for_perm_check --cannot create mat view in a schema without create privileges CREATE MATERIALIZED VIEW custom_schema.mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for schema custom_schema --cannot use a function without EXECUTE privileges --you can create a VIEW but cannot refresh it CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity), get_constant() from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; --this should fail CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for function get_constant DROP MATERIALIZED VIEW mat_perm_view_test; \set ON_ERROR_STOP 1 --can create a mat view on something with select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke select permissions from role with mat view REVOKE SELECT ON conditions_for_perm_check_w_grant FROM public; insert into conditions_for_perm_check_w_grant select generate_series(100, 130, 10), 'POR', 65, 85, 30, 90, NULL; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 --refresh mat view should now fail due to lack of permissions CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for table conditions_for_perm_check_w_grant \set ON_ERROR_STOP 1 --but the old data will still be there SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \set VERBOSITY default -- Test that grants and revokes are propagated to the implementation -- objects, that is, the user view, the partial view, the direct view, -- and the materialization table. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('devices', 'time'); create_hypertable ---------------------- (8,public,devices,t) GRANT SELECT, TRIGGER ON devices TO :ROLE_DEFAULT_PERM_USER_2; INSERT INTO devices SELECT time, (random() * 30)::int, random() * 80 FROM generate_series('2020-02-01 00:00:00'::timestamptz, '2020-03-01 00:00:00', '1 hour') AS time; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CREATE MATERIALIZED VIEW devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM devices GROUP BY bucket, device WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+-------------------------------------- user_view | devices_summary user_view_perm | mat_table | _materialized_hypertable_9 mat_table_perm | direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | GRANT ALL ON devices_summary TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+------------------------------------------------------------------------------------------------ user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} REVOKE SELECT, UPDATE ON devices_summary FROM :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+---------------------------------------------------------------------------------------------- user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} \x off -- Check for default privilege permissions get propagated to the materialization hypertable \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA test_default_privileges; GRANT USAGE ON SCHEMA "test_default_privileges" TO :ROLE_DEFAULT_PERM_USER; ALTER DEFAULT PRIVILEGES IN SCHEMA "test_default_privileges" GRANT SELECT ON TABLES TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE test_default_privileges.devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('test_default_privileges.devices', 'time'); create_hypertable ---------------------------------------- (10,test_default_privileges,devices,t) CREATE MATERIALIZED VIEW test_default_privileges.devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM test_default_privileges.devices GROUP BY bucket, device WITH NO DATA; -- check if user view perms have been propagated to the mat-ht SELECT user_view_perm IS NOT DISTINCT FROM mat_table_perm FROM cagg_info WHERE user_view = 'test_default_privileges.devices_summary'::regclass; ?column? ---------- t ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_permissions-16.out����������������������������������������0000664�0000000�0000000�00000033373�15100345067�0023757�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, (SELECT relacl FROM pg_class WHERE oid = user_view) AS user_view_perm, relname AS mat_table, (relacl) AS mat_table_perm, direct_view, (SELECT relacl FROM pg_class WHERE oid = direct_view) AS direct_view_perm, partial_view, (SELECT relacl FROM pg_class WHERE oid = partial_view) AS partial_view_perm FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; -- Manually create index on CAgg CREATE INDEX cagg_idx on mat_refresh_test(location); \c :TEST_DBNAME :ROLE_SUPERUSER CREATE USER not_priv; \c :TEST_DBNAME not_priv -- A user with no ownership on the Cagg cannot create index on it. -- This should fail \set ON_ERROR_STOP 0 CREATE INDEX cagg_idx on mat_refresh_test(humidity); ERROR: must be owner of hypertable "_materialized_hypertable_2" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER not_priv; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_continuous_aggregate_policy('mat_refresh_test', NULL, -200::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate(' mat_refresh_test', NULL, NULL); SELECT id as cagg_job_id FROM _timescaledb_config.bgw_job order by id desc limit 1 \gset SELECT format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name ) as materialization_hypertable FROM timescaledb_information.continuous_aggregates WHERE view_name = 'mat_refresh_test' \gset SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_refresh_test' \gset SELECT schema_name as mat_chunk_schema, table_name as mat_chunk_table FROM _timescaledb_catalog.chunk WHERE hypertable_id = :mat_hypertable_id ORDER BY id desc LIMIT 1 \gset CREATE TABLE conditions_for_perm_check ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check', 'timec', chunk_time_interval=> 100); table_name --------------------------- conditions_for_perm_check CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check $$; SELECT set_integer_now_func('conditions_for_perm_check', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE TABLE conditions_for_perm_check_w_grant ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check_w_grant', 'timec', chunk_time_interval=> 100); table_name ----------------------------------- conditions_for_perm_check_w_grant CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check_w_grant $$; SELECT set_integer_now_func('conditions_for_perm_check_w_grant', 'integer_now_test3'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; insert into conditions_for_perm_check_w_grant select generate_series(0, 30, 10), 'POR', 55, 75, 40, 70, NULL; --need both select and trigger permissions to create a materialized view on top of it. GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; \c :TEST_DBNAME :ROLE_SUPERUSER create schema custom_schema; CREATE FUNCTION get_constant() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant() FROM PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:cagg_job_id, max_runtime => NULL); ERROR: insufficient permissions to alter job 1000 --make sure that commands fail ALTER MATERIALIZED VIEW mat_refresh_test SET(timescaledb.materialized_only = true); ERROR: must be owner of continuous aggregate "mat_refresh_test" DROP MATERIALIZED VIEW mat_refresh_test; ERROR: must be owner of view mat_refresh_test CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); ERROR: must be owner of view mat_refresh_test SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test -- Test permissions also when the watermark is not constified and the ACL checks -- in ts_continuous_agg_watermark are executed SET timescaledb.enable_cagg_watermark_constify = OFF; SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test RESET timescaledb.enable_cagg_watermark_constify; SELECT * FROM :materialization_hypertable; ERROR: permission denied for table _materialized_hypertable_2 SELECT * FROM :"mat_chunk_schema".:"mat_chunk_table"; ERROR: permission denied for table _hyper_2_2_chunk --cannot create a mat view without select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for table conditions_for_perm_check --cannot create mat view in a schema without create privileges CREATE MATERIALIZED VIEW custom_schema.mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for schema custom_schema --cannot use a function without EXECUTE privileges --you can create a VIEW but cannot refresh it CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity), get_constant() from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; --this should fail CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for function get_constant DROP MATERIALIZED VIEW mat_perm_view_test; \set ON_ERROR_STOP 1 --can create a mat view on something with select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke select permissions from role with mat view REVOKE SELECT ON conditions_for_perm_check_w_grant FROM public; insert into conditions_for_perm_check_w_grant select generate_series(100, 130, 10), 'POR', 65, 85, 30, 90, NULL; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 --refresh mat view should now fail due to lack of permissions CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for table conditions_for_perm_check_w_grant \set ON_ERROR_STOP 1 --but the old data will still be there SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \set VERBOSITY default -- Test that grants and revokes are propagated to the implementation -- objects, that is, the user view, the partial view, the direct view, -- and the materialization table. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('devices', 'time'); create_hypertable ---------------------- (8,public,devices,t) GRANT SELECT, TRIGGER ON devices TO :ROLE_DEFAULT_PERM_USER_2; INSERT INTO devices SELECT time, (random() * 30)::int, random() * 80 FROM generate_series('2020-02-01 00:00:00'::timestamptz, '2020-03-01 00:00:00', '1 hour') AS time; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CREATE MATERIALIZED VIEW devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM devices GROUP BY bucket, device WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+-------------------------------------- user_view | devices_summary user_view_perm | mat_table | _materialized_hypertable_9 mat_table_perm | direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | GRANT ALL ON devices_summary TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+------------------------------------------------------------------------------------------------ user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=arwdDxt/default_perm_user_2} REVOKE SELECT, UPDATE ON devices_summary FROM :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+---------------------------------------------------------------------------------------------- user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxt/default_perm_user_2,default_perm_user=adDxt/default_perm_user_2} \x off -- Check for default privilege permissions get propagated to the materialization hypertable \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA test_default_privileges; GRANT USAGE ON SCHEMA "test_default_privileges" TO :ROLE_DEFAULT_PERM_USER; ALTER DEFAULT PRIVILEGES IN SCHEMA "test_default_privileges" GRANT SELECT ON TABLES TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE test_default_privileges.devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('test_default_privileges.devices', 'time'); create_hypertable ---------------------------------------- (10,test_default_privileges,devices,t) CREATE MATERIALIZED VIEW test_default_privileges.devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM test_default_privileges.devices GROUP BY bucket, device WITH NO DATA; -- check if user view perms have been propagated to the mat-ht SELECT user_view_perm IS NOT DISTINCT FROM mat_table_perm FROM cagg_info WHERE user_view = 'test_default_privileges.devices_summary'::regclass; ?column? ---------- t ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_permissions-17.out����������������������������������������0000664�0000000�0000000�00000033417�15100345067�0023757�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, (SELECT relacl FROM pg_class WHERE oid = user_view) AS user_view_perm, relname AS mat_table, (relacl) AS mat_table_perm, direct_view, (SELECT relacl FROM pg_class WHERE oid = direct_view) AS direct_view_perm, partial_view, (SELECT relacl FROM pg_class WHERE oid = partial_view) AS partial_view_perm FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; -- Manually create index on CAgg CREATE INDEX cagg_idx on mat_refresh_test(location); \c :TEST_DBNAME :ROLE_SUPERUSER CREATE USER not_priv; \c :TEST_DBNAME not_priv -- A user with no ownership on the Cagg cannot create index on it. -- This should fail \set ON_ERROR_STOP 0 CREATE INDEX cagg_idx on mat_refresh_test(humidity); ERROR: must be owner of hypertable "_materialized_hypertable_2" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER not_priv; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_continuous_aggregate_policy('mat_refresh_test', NULL, -200::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate(' mat_refresh_test', NULL, NULL); SELECT id as cagg_job_id FROM _timescaledb_config.bgw_job order by id desc limit 1 \gset SELECT format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name ) as materialization_hypertable FROM timescaledb_information.continuous_aggregates WHERE view_name = 'mat_refresh_test' \gset SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_refresh_test' \gset SELECT schema_name as mat_chunk_schema, table_name as mat_chunk_table FROM _timescaledb_catalog.chunk WHERE hypertable_id = :mat_hypertable_id ORDER BY id desc LIMIT 1 \gset CREATE TABLE conditions_for_perm_check ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check', 'timec', chunk_time_interval=> 100); table_name --------------------------- conditions_for_perm_check CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check $$; SELECT set_integer_now_func('conditions_for_perm_check', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE TABLE conditions_for_perm_check_w_grant ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check_w_grant', 'timec', chunk_time_interval=> 100); table_name ----------------------------------- conditions_for_perm_check_w_grant CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check_w_grant $$; SELECT set_integer_now_func('conditions_for_perm_check_w_grant', 'integer_now_test3'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; insert into conditions_for_perm_check_w_grant select generate_series(0, 30, 10), 'POR', 55, 75, 40, 70, NULL; --need both select and trigger permissions to create a materialized view on top of it. GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; \c :TEST_DBNAME :ROLE_SUPERUSER create schema custom_schema; CREATE FUNCTION get_constant() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant() FROM PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:cagg_job_id, max_runtime => NULL); ERROR: insufficient permissions to alter job 1000 --make sure that commands fail ALTER MATERIALIZED VIEW mat_refresh_test SET(timescaledb.materialized_only = true); ERROR: must be owner of continuous aggregate "mat_refresh_test" DROP MATERIALIZED VIEW mat_refresh_test; ERROR: must be owner of view mat_refresh_test CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); ERROR: must be owner of view mat_refresh_test SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test -- Test permissions also when the watermark is not constified and the ACL checks -- in ts_continuous_agg_watermark are executed SET timescaledb.enable_cagg_watermark_constify = OFF; SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test RESET timescaledb.enable_cagg_watermark_constify; SELECT * FROM :materialization_hypertable; ERROR: permission denied for table _materialized_hypertable_2 SELECT * FROM :"mat_chunk_schema".:"mat_chunk_table"; ERROR: permission denied for table _hyper_2_2_chunk --cannot create a mat view without select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for table conditions_for_perm_check --cannot create mat view in a schema without create privileges CREATE MATERIALIZED VIEW custom_schema.mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for schema custom_schema --cannot use a function without EXECUTE privileges --you can create a VIEW but cannot refresh it CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity), get_constant() from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; --this should fail CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for function get_constant DROP MATERIALIZED VIEW mat_perm_view_test; \set ON_ERROR_STOP 1 --can create a mat view on something with select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke select permissions from role with mat view REVOKE SELECT ON conditions_for_perm_check_w_grant FROM public; insert into conditions_for_perm_check_w_grant select generate_series(100, 130, 10), 'POR', 65, 85, 30, 90, NULL; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 --refresh mat view should now fail due to lack of permissions CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for table conditions_for_perm_check_w_grant \set ON_ERROR_STOP 1 --but the old data will still be there SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \set VERBOSITY default -- Test that grants and revokes are propagated to the implementation -- objects, that is, the user view, the partial view, the direct view, -- and the materialization table. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('devices', 'time'); create_hypertable ---------------------- (8,public,devices,t) GRANT SELECT, TRIGGER ON devices TO :ROLE_DEFAULT_PERM_USER_2; INSERT INTO devices SELECT time, (random() * 30)::int, random() * 80 FROM generate_series('2020-02-01 00:00:00'::timestamptz, '2020-03-01 00:00:00', '1 hour') AS time; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CREATE MATERIALIZED VIEW devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM devices GROUP BY bucket, device WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+-------------------------------------- user_view | devices_summary user_view_perm | mat_table | _materialized_hypertable_9 mat_table_perm | direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | GRANT ALL ON devices_summary TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+-------------------------------------------------------------------------------------------------- user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} REVOKE SELECT, UPDATE ON devices_summary FROM :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+------------------------------------------------------------------------------------------------ user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} \x off -- Check for default privilege permissions get propagated to the materialization hypertable \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA test_default_privileges; GRANT USAGE ON SCHEMA "test_default_privileges" TO :ROLE_DEFAULT_PERM_USER; ALTER DEFAULT PRIVILEGES IN SCHEMA "test_default_privileges" GRANT SELECT ON TABLES TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE test_default_privileges.devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('test_default_privileges.devices', 'time'); create_hypertable ---------------------------------------- (10,test_default_privileges,devices,t) CREATE MATERIALIZED VIEW test_default_privileges.devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM test_default_privileges.devices GROUP BY bucket, device WITH NO DATA; -- check if user view perms have been propagated to the mat-ht SELECT user_view_perm IS NOT DISTINCT FROM mat_table_perm FROM cagg_info WHERE user_view = 'test_default_privileges.devices_summary'::regclass; ?column? ---------- t �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_permissions-18.out����������������������������������������0000664�0000000�0000000�00000033417�15100345067�0023760�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, (SELECT relacl FROM pg_class WHERE oid = user_view) AS user_view_perm, relname AS mat_table, (relacl) AS mat_table_perm, direct_view, (SELECT relacl FROM pg_class WHERE oid = direct_view) AS direct_view_perm, partial_view, (SELECT relacl FROM pg_class WHERE oid = partial_view) AS partial_view_perm FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test1'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; -- Manually create index on CAgg CREATE INDEX cagg_idx on mat_refresh_test(location); \c :TEST_DBNAME :ROLE_SUPERUSER CREATE USER not_priv; \c :TEST_DBNAME not_priv -- A user with no ownership on the Cagg cannot create index on it. -- This should fail \set ON_ERROR_STOP 0 CREATE INDEX cagg_idx on mat_refresh_test(humidity); ERROR: must be owner of hypertable "_materialized_hypertable_2" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER not_priv; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_continuous_aggregate_policy('mat_refresh_test', NULL, -200::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate(' mat_refresh_test', NULL, NULL); SELECT id as cagg_job_id FROM _timescaledb_config.bgw_job order by id desc limit 1 \gset SELECT format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name ) as materialization_hypertable FROM timescaledb_information.continuous_aggregates WHERE view_name = 'mat_refresh_test' \gset SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_refresh_test' \gset SELECT schema_name as mat_chunk_schema, table_name as mat_chunk_table FROM _timescaledb_catalog.chunk WHERE hypertable_id = :mat_hypertable_id ORDER BY id desc LIMIT 1 \gset CREATE TABLE conditions_for_perm_check ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check', 'timec', chunk_time_interval=> 100); table_name --------------------------- conditions_for_perm_check CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check $$; SELECT set_integer_now_func('conditions_for_perm_check', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE TABLE conditions_for_perm_check_w_grant ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check_w_grant', 'timec', chunk_time_interval=> 100); table_name ----------------------------------- conditions_for_perm_check_w_grant CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check_w_grant $$; SELECT set_integer_now_func('conditions_for_perm_check_w_grant', 'integer_now_test3'); set_integer_now_func ---------------------- GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; insert into conditions_for_perm_check_w_grant select generate_series(0, 30, 10), 'POR', 55, 75, 40, 70, NULL; --need both select and trigger permissions to create a materialized view on top of it. GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; \c :TEST_DBNAME :ROLE_SUPERUSER create schema custom_schema; CREATE FUNCTION get_constant() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant() FROM PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:cagg_job_id, max_runtime => NULL); ERROR: insufficient permissions to alter job 1000 --make sure that commands fail ALTER MATERIALIZED VIEW mat_refresh_test SET(timescaledb.materialized_only = true); ERROR: must be owner of continuous aggregate "mat_refresh_test" DROP MATERIALIZED VIEW mat_refresh_test; ERROR: must be owner of view mat_refresh_test CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); ERROR: must be owner of view mat_refresh_test SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test -- Test permissions also when the watermark is not constified and the ACL checks -- in ts_continuous_agg_watermark are executed SET timescaledb.enable_cagg_watermark_constify = OFF; SELECT * FROM mat_refresh_test; ERROR: permission denied for view mat_refresh_test RESET timescaledb.enable_cagg_watermark_constify; SELECT * FROM :materialization_hypertable; ERROR: permission denied for table _materialized_hypertable_2 SELECT * FROM :"mat_chunk_schema".:"mat_chunk_table"; ERROR: permission denied for table _hyper_2_2_chunk --cannot create a mat view without select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for table conditions_for_perm_check --cannot create mat view in a schema without create privileges CREATE MATERIALIZED VIEW custom_schema.mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; ERROR: permission denied for schema custom_schema --cannot use a function without EXECUTE privileges --you can create a VIEW but cannot refresh it CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity), get_constant() from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; --this should fail CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for function get_constant DROP MATERIALIZED VIEW mat_perm_view_test; \set ON_ERROR_STOP 1 --can create a mat view on something with select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke select permissions from role with mat view REVOKE SELECT ON conditions_for_perm_check_w_grant FROM public; insert into conditions_for_perm_check_w_grant select generate_series(100, 130, 10), 'POR', 65, 85, 30, 90, NULL; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 --refresh mat view should now fail due to lack of permissions CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); ERROR: permission denied for table conditions_for_perm_check_w_grant \set ON_ERROR_STOP 1 --but the old data will still be there SELECT * FROM mat_perm_view_test; location | max ----------+----- POR | 75 \set VERBOSITY default -- Test that grants and revokes are propagated to the implementation -- objects, that is, the user view, the partial view, the direct view, -- and the materialization table. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('devices', 'time'); create_hypertable ---------------------- (8,public,devices,t) GRANT SELECT, TRIGGER ON devices TO :ROLE_DEFAULT_PERM_USER_2; INSERT INTO devices SELECT time, (random() * 30)::int, random() * 80 FROM generate_series('2020-02-01 00:00:00'::timestamptz, '2020-03-01 00:00:00', '1 hour') AS time; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CREATE MATERIALIZED VIEW devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM devices GROUP BY bucket, device WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+-------------------------------------- user_view | devices_summary user_view_perm | mat_table | _materialized_hypertable_9 mat_table_perm | direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | GRANT ALL ON devices_summary TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+-------------------------------------------------------------------------------------------------- user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=arwdDxtm/default_perm_user_2} REVOKE SELECT, UPDATE ON devices_summary FROM :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; -[ RECORD 1 ]-----+------------------------------------------------------------------------------------------------ user_view | devices_summary user_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} mat_table | _materialized_hypertable_9 mat_table_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} direct_view | _timescaledb_internal._direct_view_9 direct_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} partial_view | _timescaledb_internal._partial_view_9 partial_view_perm | {default_perm_user_2=arwdDxtm/default_perm_user_2,default_perm_user=adDxtm/default_perm_user_2} \x off -- Check for default privilege permissions get propagated to the materialization hypertable \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA test_default_privileges; GRANT USAGE ON SCHEMA "test_default_privileges" TO :ROLE_DEFAULT_PERM_USER; ALTER DEFAULT PRIVILEGES IN SCHEMA "test_default_privileges" GRANT SELECT ON TABLES TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE test_default_privileges.devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('test_default_privileges.devices', 'time'); create_hypertable ---------------------------------------- (10,test_default_privileges,devices,t) CREATE MATERIALIZED VIEW test_default_privileges.devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM test_default_privileges.devices GROUP BY bucket, device WITH NO DATA; -- check if user view perms have been propagated to the mat-ht SELECT user_view_perm IS NOT DISTINCT FROM mat_table_perm FROM cagg_info WHERE user_view = 'test_default_privileges.devices_summary'::regclass; ?column? ---------- t �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_planning.out����������������������������������������������0000664�0000000�0000000�00000150562�15100345067�0022766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TEST_BASE_NAME cagg_planning SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_baseline.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_BASELINE", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED" \gset SELECT format('\! diff -u --label Baseline --label Optimized %s %s', :'TEST_RESULTS_BASELINE', :'TEST_RESULTS_OPTIMIZED') AS "DIFF_CMD" \gset SET timezone TO PST8PDT; CREATE TABLE metrics(time timestamptz, device text, metric text, value float); SELECT create_hypertable('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) -- insert initial data to be in materialized part of cagg INSERT INTO metrics SELECT '2020-01-01'::timestamptz + format('%s day', i::text)::interval, 'device 1', 'metric 1', i FROM generate_series(0, 9, 1) g(i); -- cagg with grouping only by time column CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), avg(value) FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" CREATE MATERIALIZED VIEW cagg1_ordered_asc WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), avg(value) FROM metrics GROUP BY 1 ORDER BY 1; NOTICE: refreshing continuous aggregate "cagg1_ordered_asc" CREATE MATERIALIZED VIEW cagg1_ordered_desc WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), avg(value) FROM metrics GROUP BY 1 ORDER BY 1 DESC; NOTICE: refreshing continuous aggregate "cagg1_ordered_desc" -- cagg with grouping by device and time column CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT device, time_bucket('3 day', time), avg(value) FROM metrics GROUP BY device, 2; NOTICE: refreshing continuous aggregate "cagg2" -- cagg with first/last CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), first(value, time), last(value, time), array_agg(value ORDER BY value) AS array_asc, array_agg(value ORDER BY value DESC) AS array_desc FROM metrics GROUP BY device, 1; NOTICE: refreshing continuous aggregate "cagg3" -- insert more data to be in real-time part of cagg INSERT INTO metrics SELECT '2020-01-01'::timestamptz + format('%s day', i::text)::interval, 'device 1', 'metric 1', i FROM generate_series(10, 16, 1) g(i); \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW timescaledb.enable_cagg_sort_pushdown; timescaledb.enable_cagg_sort_pushdown --------------------------------------- on :PREFIX SELECT 'query 01' AS label, * FROM cagg1 ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_2 (actual rows=4.00 loops=1) Order: _materialized_hypertable_2.time_bucket -> Index Scan Backward using _hyper_2_4_chunk__materialized_hypertable_2_time_bucket_idx on _hyper_2_4_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_5_chunk__materialized_hypertable_2_time_bucket_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: time_bucket('@ 3 days'::interval, metrics."time") -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan Backward using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 02' AS label, * FROM cagg1 ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: time_bucket('@ 3 days'::interval, metrics."time") DESC -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on _materialized_hypertable_2 (actual rows=4.00 loops=1) Order: _materialized_hypertable_2.time_bucket DESC -> Index Scan using _hyper_2_5_chunk__materialized_hypertable_2_time_bucket_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_time_bucket_idx on _hyper_2_4_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 03' AS label, * FROM cagg1_ordered_asc ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_3 (actual rows=4.00 loops=1) Order: _materialized_hypertable_3.time_bucket -> Index Scan Backward using _hyper_3_6_chunk__materialized_hypertable_3_time_bucket_idx on _hyper_3_6_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_3_7_chunk__materialized_hypertable_3_time_bucket_idx on _hyper_3_7_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: time_bucket('@ 3 days'::interval, metrics."time") -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan Backward using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 04' AS label, * FROM cagg1_ordered_asc ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: time_bucket('@ 3 days'::interval, metrics."time") DESC -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on _materialized_hypertable_3 (actual rows=4.00 loops=1) Order: _materialized_hypertable_3.time_bucket DESC -> Index Scan using _hyper_3_7_chunk__materialized_hypertable_3_time_bucket_idx on _hyper_3_7_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_time_bucket_idx on _hyper_3_6_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 05' AS label, * FROM cagg1_ordered_desc ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_4 (actual rows=4.00 loops=1) Order: _materialized_hypertable_4.time_bucket -> Index Scan Backward using _hyper_4_9_chunk__materialized_hypertable_4_time_bucket_idx on _hyper_4_9_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_4_8_chunk__materialized_hypertable_4_time_bucket_idx on _hyper_4_8_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: time_bucket('@ 3 days'::interval, metrics."time") -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan Backward using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 06' AS label, * FROM cagg1_ordered_desc ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: time_bucket('@ 3 days'::interval, metrics."time") DESC -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on _materialized_hypertable_4 (actual rows=4.00 loops=1) Order: _materialized_hypertable_4.time_bucket DESC -> Index Scan using _hyper_4_8_chunk__materialized_hypertable_4_time_bucket_idx on _hyper_4_8_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_4_9_chunk__materialized_hypertable_4_time_bucket_idx on _hyper_4_9_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 07' AS label, * FROM cagg2 ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_5 (actual rows=4.00 loops=1) Order: _materialized_hypertable_5.time_bucket -> Index Scan Backward using _hyper_5_10_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_10_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_5_11_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_11_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time"), _hyper_1_3_chunk.device -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time"), _hyper_1_14_chunk.device -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 08' AS label, * FROM cagg2 ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time"), _hyper_1_14_chunk.device -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time"), _hyper_1_3_chunk.device -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on _materialized_hypertable_5 (actual rows=4.00 loops=1) Order: _materialized_hypertable_5.time_bucket DESC -> Index Scan using _hyper_5_11_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_11_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_5_10_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_10_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 07' AS label, * FROM cagg3 ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_6 (actual rows=4.00 loops=1) Order: _materialized_hypertable_6.time_bucket -> Index Scan Backward using _hyper_6_12_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_12_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_6_13_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_13_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Subquery Scan on "*SELECT* 2" (actual rows=2.00 loops=1) -> GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device, metrics.value Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 08' AS label, * FROM cagg3 ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Subquery Scan on "*SELECT* 2" (actual rows=2.00 loops=1) -> GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC, metrics.device, metrics.value Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Custom Scan (ChunkAppend) on _materialized_hypertable_6 (actual rows=4.00 loops=1) Order: _materialized_hypertable_6.time_bucket DESC -> Index Scan using _hyper_6_13_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_13_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_6_12_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_12_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -- not optimized atm :PREFIX SELECT 'query 101' AS label, * FROM cagg2 ORDER BY time_bucket::date; --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: ((_materialized_hypertable_5.time_bucket)::date) Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_5_10_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_10_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_5_11_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_11_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: metrics.device, (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_3_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_14_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 102' AS label, * FROM cagg2 ORDER BY time_bucket::date DESC; --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: ((_materialized_hypertable_5.time_bucket)::date) DESC Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_5_10_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_10_chunk (actual rows=3.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan using _hyper_5_11_chunk__materialized_hypertable_5_time_bucket_idx on _hyper_5_11_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: metrics.device, (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_3_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Index Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_14_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Index Scan using _hyper_1_14_chunk_metrics_time_idx on _hyper_1_14_chunk (actual rows=2.00 loops=1) Index Cond: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) \set ECHO none -- diff baseline and optimized results :DIFF_CMD --- Baseline +++ Optimized @@ -1,6 +1,6 @@ timescaledb.enable_cagg_sort_pushdown --------------------------------------- - off + on label | time_bucket | avg --dump & restore \c postgres :ROLE_SUPERUSER \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t -- Repeat tests after restore \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TEST_BASE_NAME cagg_planning SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_baseline_after_restore.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_BASELINE_AFTER_RESTORE", format('%s/results/%s_results_optimized_after_restore.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED_AFTER_RESTORE" \gset SELECT format('\! diff -u --label Baseline --label Optimized %s %s', :'TEST_RESULTS_BASELINE_AFTER_RESTORE', :'TEST_RESULTS_OPTIMIZED_AFTER_RESTORE') AS "DIFF_CMD" \gset SET timezone TO PST8PDT; \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW timescaledb.enable_cagg_sort_pushdown; timescaledb.enable_cagg_sort_pushdown --------------------------------------- on :PREFIX SELECT 'query 01' AS label, * FROM cagg1 ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_2.time_bucket Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_2_5_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 02' AS label, * FROM cagg1 ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_2.time_bucket DESC Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_2_5_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_2_4_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 03' AS label, * FROM cagg1_ordered_asc ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_3.time_bucket Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 04' AS label, * FROM cagg1_ordered_asc ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_3.time_bucket DESC Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 05' AS label, * FROM cagg1_ordered_desc ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_4.time_bucket Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_4_9_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_8_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 06' AS label, * FROM cagg1_ordered_desc ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_4.time_bucket DESC Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_4_8_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_4_9_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 07' AS label, * FROM cagg2 ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_5.time_bucket Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_5_10_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_5_11_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time"), _hyper_1_3_chunk.device -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time"), _hyper_1_14_chunk.device -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 08' AS label, * FROM cagg2 ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC Sort Method: quicksort -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time"), _hyper_1_14_chunk.device -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time"), _hyper_1_3_chunk.device -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_5.time_bucket DESC Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_5_11_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_5_10_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 07' AS label, * FROM cagg3 ORDER BY time_bucket; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_6.time_bucket Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_6_12_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_6_13_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Subquery Scan on "*SELECT* 2" (actual rows=2.00 loops=1) -> GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device, metrics.value Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) :PREFIX SELECT 'query 08' AS label, * FROM cagg3 ORDER BY time_bucket DESC; --- QUERY PLAN --- Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Subquery Scan on "*SELECT* 2" (actual rows=2.00 loops=1) -> GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 3 days'::interval, metrics."time")), metrics.device -> Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('@ 3 days'::interval, metrics."time")) DESC, metrics.device, metrics.value Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=4.00 loops=1) Sort Key: _materialized_hypertable_6.time_bucket DESC Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_6_13_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_6_12_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -- not optimized atm :PREFIX SELECT 'query 101' AS label, * FROM cagg2 ORDER BY time_bucket::date; --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: ((_materialized_hypertable_5.time_bucket)::date) Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_5_10_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_5_11_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: metrics.device, (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_14_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_3_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 :PREFIX SELECT 'query 102' AS label, * FROM cagg2 ORDER BY time_bucket::date DESC; --- QUERY PLAN --- Sort (actual rows=6.00 loops=1) Sort Key: ((_materialized_hypertable_5.time_bucket)::date) DESC Sort Method: quicksort -> Result (actual rows=6.00 loops=1) -> Append (actual rows=6.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Seq Scan on _hyper_5_10_chunk (actual rows=3.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Seq Scan on _hyper_5_11_chunk (actual rows=1.00 loops=1) Filter: (time_bucket < 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: metrics.device, (time_bucket('@ 3 days'::interval, metrics."time")) -> Append (actual rows=3.00 loops=1) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_14_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_14_chunk."time") -> Seq Scan on _hyper_1_14_chunk (actual rows=2.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) -> Partial HashAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_3_chunk.device, time_bucket('@ 3 days'::interval, _hyper_1_3_chunk."time") -> Seq Scan on _hyper_1_3_chunk (actual rows=4.00 loops=1) Filter: ("time" >= 'Sat Jan 11 16:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 3 \set ECHO none -- diff baseline and optimized results :DIFF_CMD --- Baseline +++ Optimized @@ -1,6 +1,6 @@ timescaledb.enable_cagg_sort_pushdown --------------------------------------- - off + on label | time_bucket | avg -- diff baseline before and after restore SELECT format('\! diff -u --label Baseline --label Baseline_After_Restore %s %s', :'TEST_RESULTS_BASELINE', :'TEST_RESULTS_BASELINE_AFTER_RESTORE') AS "DIFF_CMD" \gset :DIFF_CMD -- diff optimized before and after restore SELECT format('\! diff -u --label Optimized --label Optimized_After_Restore %s %s', :'TEST_RESULTS_OPTIMIZED', :'TEST_RESULTS_OPTIMIZED_AFTER_RESTORE') AS "DIFF_CMD" \gset :DIFF_CMD ����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_plugin.out������������������������������������������������0000664�0000000�0000000�00000031675�15100345067�0022461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Test the invalidation plugin and make sure it can return the data -- we expect. We do that by creating a hypertable and then registering -- a logical decoding slot on it and using the plugin to get the -- changes. SET timezone TO UTC; SET datestyle TO ISO; SELECT setseed(1); setseed --------- CREATE FUNCTION get_invalidations(slot text, hypertable name, attr name) RETURNS TABLE (hypertable_relid regclass, lowest_modified_value timestamptz, greatest_modified_value timestamptz) AS $$ WITH changes AS ( SELECT (_timescaledb_functions.cagg_parse_invalidation_record(data)).* FROM pg_logical_slot_get_binary_changes(slot, NULL, NULL, hypertable, attr)) SELECT hypertable_relid, _timescaledb_functions.to_timestamp(lowest_modified_value), _timescaledb_functions.to_timestamp(greatest_modified_value) FROM changes ORDER BY 1,2,3; $$ LANGUAGE sql; select _timescaledb_functions.invalidation_plugin_name() as plugin_name \gset -- Creating a table with a primary key since we need a replica -- identity to use logical decoding. CREATE TABLE conditions ( recorded_at timestamptz NOT NULL, device_id int, temp float, primary key (recorded_at, device_id) ); SELECT create_hypertable('conditions', 'recorded_at'); create_hypertable ------------------------- (1,public,conditions,t) SELECT setseed(1.0); setseed --------- INSERT INTO conditions SELECT recorded_at, (random()*3 + 1)::int, random()*80 - 40 FROM generate_series('2025-02-01'::timestamptz, '2025-03-31'::timestamptz, '1 minute'::interval) AS recorded_at; select from pg_create_logical_replication_slot('my_slot', :'plugin_name', false, true); -- -- Generate a few entries in one go. This caused some problems -- initially, so check this first. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 98, 37.0); INSERT INTO conditions VALUES ('2020-05-02 12:34:56Z', 98, 37.0), ('2020-05-02 13:45:00Z', 98, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2020-05-01 12:34:56+00 conditions | 2020-05-02 12:34:56+00 | 2020-05-02 13:45:00+00 -- Generate a single invalidation line and check how that appears. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 99, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2020-05-01 12:34:56+00 INSERT INTO conditions VALUES ('2020-05-02 12:34:56Z', 99, 37.0), ('2020-05-02 13:45:00Z', 99, 37.0); -- Check that we got the invalidations SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-02 12:34:56+00 | 2020-05-02 13:45:00+00 -- This should generate an invalidation including the full range since -- it is inside a transaction. INSERT INTO conditions SELECT recorded_at, 99, random()*80 - 40 FROM generate_series('2025-02-01'::timestamptz, '2025-03-31'::timestamptz, '1 minute'::interval) AS recorded_at; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2025-02-01 00:00:00+00 | 2025-03-31 00:00:00+00 UPDATE conditions SET temp = 0.0 WHERE device_id = 99; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2025-03-31 00:00:00+00 DELETE FROM conditions WHERE device_id = 99; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2025-03-31 00:00:00+00 -- Test that we can do multiple changes (in different transactions) in -- a suite and get the changes for that using the plugin. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 99, 37.0); INSERT INTO conditions VALUES ('2020-05-02 12:34:56Z', 99, 37.0), ('2020-05-02 13:45:00Z', 99, 37.0); INSERT INTO conditions SELECT recorded_at, 99, random()*80 - 40 FROM generate_series('2025-02-01'::timestamptz, '2025-03-31'::timestamptz, '1 minute'::interval) AS recorded_at; UPDATE conditions SET temp = 0.0 WHERE device_id = 99; DELETE FROM conditions WHERE device_id = 99; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2020-05-01 12:34:56+00 conditions | 2020-05-01 12:34:56+00 | 2025-03-31 00:00:00+00 conditions | 2020-05-01 12:34:56+00 | 2025-03-31 00:00:00+00 conditions | 2020-05-02 12:34:56+00 | 2020-05-02 13:45:00+00 conditions | 2025-02-01 00:00:00+00 | 2025-03-31 00:00:00+00 -- Test that we can do multiple changes in a single transaction get -- the changes for that using the plugin. START TRANSACTION; INSERT INTO conditions VALUES ('2020-06-01 12:34:56Z', 101, 37.0); INSERT INTO conditions VALUES ('2020-06-02 12:34:56Z', 101, 37.0), ('2020-06-02 13:45:00Z', 101, 37.0); INSERT INTO conditions SELECT recorded_at, 101, random()*80 - 40 FROM generate_series('2020-06-10'::timestamptz, '2020-07-31'::timestamptz, '1 minute'::interval) AS recorded_at; UPDATE conditions SET temp = 0.0 WHERE device_id = 101; DELETE FROM conditions WHERE device_id = 101; COMMIT; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-06-01 12:34:56+00 | 2020-07-31 00:00:00+00 -- Insert some tuples, remove a column, and insert some more data, all -- inside a transaction, and check that it behaves sane even when the -- tuple format changes within a transaction. START TRANSACTION; INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 102, 37.0); ALTER TABLE conditions DROP COLUMN temp; INSERT INTO conditions VALUES ('2020-05-01 12:34:57Z', 102); ALTER TABLE conditions ADD COLUMN temp numeric; INSERT INTO conditions VALUES ('2020-05-01 12:34:58Z', 102, 38.0); COMMIT; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2020-05-01 12:34:58+00 -- Test to insert some changes and then drop the table to check that -- it behaves sane. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 103, 37.0); DROP TABLE conditions; \set ON_ERROR_STOP 0 SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); ERROR: relation "conditions" does not exist \set ON_ERROR_STOP 1 -- Create the hypertable again with the same name and see that we do -- not read bad data. CREATE TABLE conditions ( recorded_at timestamptz NOT NULL, device_id int, temp float, primary key (recorded_at, device_id) ); SELECT create_hypertable('conditions', 'recorded_at'); create_hypertable ------------------------- (2,public,conditions,t) -- New hypertable: we should not see the ones that we inserted before -- dropping the old version of the hypertable. SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+-----------------------+------------------------- -- Insert some data so that we have some entries. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 104, 37.0); -- Check that trying to read a non-existing attribute generates an -- error. \set ON_ERROR_STOP 0 SELECT * FROM get_invalidations('my_slot', 'conditions', 'does_not_exist'); ERROR: attribute "does_not_exist" does not exist \set ON_ERROR_STOP 1 -- We should still be able to get invalidations if we provide a good -- attribute after this. (This turned out to be a problem during -- testing.) SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions | 2020-05-01 12:34:56+00 | 2020-05-01 12:34:56+00 -- Check that adding a lot of invalidations as separate transactions -- in one go reads them all from the WAL. DO $$ DECLARE rec RECORD; BEGIN FOR rec IN SELECT t, d FROM generate_series('2020-05-10'::timestamptz, '2020-05-11'::timestamptz, '1 minute'::interval) t, generate_series(1,10) d LOOP INSERT INTO conditions VALUES (rec.t, rec.d, 100.0 * random()); COMMIT; END LOOP; END $$; SELECT count(*) FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); count ------- 14410 -- Test using a table without a primary key but with an index that can -- be used as replica identity. CREATE TABLE conditions_index ( captured_at TIMESTAMPTZ NOT NULL, device_id INT NOT NULL, temp FLOAT, UNIQUE (captured_at, device_id) ); ALTER TABLE conditions_index REPLICA IDENTITY USING INDEX conditions_index_captured_at_device_id_key; SELECT create_hypertable('conditions_index', 'captured_at'); create_hypertable ------------------------------- (3,public,conditions_index,t) INSERT INTO conditions_index VALUES ('2020-05-02 12:34:56Z', 42, 37.0), ('2020-05-02 13:45:00Z', 42, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions_index', 'captured_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions_index | 2020-05-02 12:34:56+00 | 2020-05-02 13:45:00+00 -- Test using a table without a primary key but with a replica -- identity using full rows. CREATE TABLE conditions_full ( recorded_at TIMESTAMPTZ NOT NULL, device_id INT NOT NULL, temp FLOAT ); ALTER TABLE conditions_full REPLICA IDENTITY FULL; SELECT create_hypertable('conditions_full', 'recorded_at'); create_hypertable ------------------------------ (4,public,conditions_full,t) INSERT INTO conditions_full VALUES ('2020-05-02 12:34:56Z', 42, 37.0), ('2020-05-02 13:45:00Z', 42, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions_full', 'recorded_at'); hypertable_relid | lowest_modified_value | greatest_modified_value ------------------+------------------------+------------------------- conditions_full | 2020-05-02 12:34:56+00 | 2020-05-02 13:45:00+00 -- Test getting invalidations for multiple hypertables in one go, to -- make sure that the plugin works with multiple tables as well. -- We add more invalidations to more tables than we actually fetch, -- because that should work too. INSERT INTO conditions_full VALUES ('2020-05-03 11:34:00Z', 43, 37.0), ('2020-05-03 12:45:00Z', 43, 37.0); INSERT INTO conditions_index VALUES ('2020-05-03 12:00:00Z', 43, 37.0), ('2020-05-03 13:00:00Z', 43, 37.0); INSERT INTO conditions VALUES ('2020-05-03 15:00:01Z', 43, 37.0); -- Capture only two of the three tables above, also with different -- attribute names. WITH changes AS ( SELECT (_timescaledb_functions.cagg_parse_invalidation_record(data)).* FROM pg_logical_slot_get_binary_changes('my_slot', NULL, NULL, 'conditions_full', 'recorded_at', 'conditions_index', 'captured_at')) SELECT hypertable_relid, _timescaledb_functions.to_timestamp(lowest_modified_value), _timescaledb_functions.to_timestamp(greatest_modified_value) FROM changes ORDER BY hypertable_relid; hypertable_relid | to_timestamp | to_timestamp ------------------+------------------------+------------------------ conditions_index | 2020-05-03 12:00:00+00 | 2020-05-03 13:00:00+00 conditions_full | 2020-05-03 11:34:00+00 | 2020-05-03 12:45:00+00 SELECT * FROM pg_drop_replication_slot('my_slot'); pg_drop_replication_slot -------------------------- �������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_policy.out������������������������������������������������0000664�0000000�0000000�00000175627�15100345067�0022470�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test add and remove refresh policy apis SET ROLE :ROLE_DEFAULT_PERM_USER; --TEST1 --- --basic test with count CREATE TABLE int_tab (a integer, b integer, c integer); SELECT table_name FROM create_hypertable('int_tab', 'a', chunk_time_interval=> 10); table_name ------------ int_tab INSERT INTO int_tab VALUES( 3 , 16 , 20); INSERT INTO int_tab VALUES( 1 , 10 , 20); INSERT INTO int_tab VALUES( 1 , 11 , 20); INSERT INTO int_tab VALUES( 1 , 12 , 20); INSERT INTO int_tab VALUES( 1 , 13 , 20); INSERT INTO int_tab VALUES( 1 , 14 , 20); INSERT INTO int_tab VALUES( 2 , 14 , 20); INSERT INTO int_tab VALUES( 2 , 15 , 20); INSERT INTO int_tab VALUES( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_int_tab() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM int_tab $$; SELECT set_integer_now_func('int_tab', 'integer_now_int_tab'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT a, count(b) FROM int_tab GROUP BY time_bucket(1, a), a WITH NO DATA; \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM _timescaledb_config.bgw_job; count ------- 0 \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for integer type buckets ALTER materialized view mat_m1 set (timescaledb.compress = true); NOTICE: defaulting compress_segmentby to a NOTICE: defaulting compress_orderby to time_partition_col -- No policy is added if one errors out SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 1, refresh_end_offset => 10, compress_after => 11, drop_after => 20); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "integer". SELECT timescaledb_experimental.show_policies('mat_m1'); show_policies --------------- -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 10, refresh_end_offset => 1, compress_after => 11, drop_after => 20); add_policies -------------- t SELECT timescaledb_experimental.show_policies('mat_m1'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": 11, "compress_interval": "@ 1 day"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 10} {"drop_after": 20, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} --Test coverage: new view for policies on CAggs SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; relation_name | relation_schema | schedule_interval | proc_schema | proc_name | config | hypertable_schema | hypertable_name ---------------+-----------------+-------------------+------------------------+-------------------------------------+---------------------------------------------------------------+-----------------------+---------------------------- mat_m1 | public | @ 1 day | _timescaledb_functions | policy_compression | {"hypertable_id": 2, "compress_after": 11} | _timescaledb_internal | _materialized_hypertable_2 mat_m1 | public | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | {"end_offset": 1, "start_offset": 10, "mat_hypertable_id": 2} | _timescaledb_internal | _materialized_hypertable_2 mat_m1 | public | @ 1 day | _timescaledb_functions | policy_retention | {"drop_after": 20, "hypertable_id": 2} | _timescaledb_internal | _materialized_hypertable_2 --Test coverage: new view for policies only shows the policies for CAggs SELECT add_retention_policy('int_tab', 20); add_retention_policy ---------------------- 1003 SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; relation_name | relation_schema | schedule_interval | proc_schema | proc_name | config | hypertable_schema | hypertable_name ---------------+-----------------+-------------------+------------------------+-------------------------------------+---------------------------------------------------------------+-----------------------+---------------------------- mat_m1 | public | @ 1 day | _timescaledb_functions | policy_compression | {"hypertable_id": 2, "compress_after": 11} | _timescaledb_internal | _materialized_hypertable_2 mat_m1 | public | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | {"end_offset": 1, "start_offset": 10, "mat_hypertable_id": 2} | _timescaledb_internal | _materialized_hypertable_2 mat_m1 | public | @ 1 day | _timescaledb_functions | policy_retention | {"drop_after": 20, "hypertable_id": 2} | _timescaledb_internal | _materialized_hypertable_2 SELECT remove_retention_policy('int_tab'); remove_retention_policy ------------------------- -- Test for duplicated policies (issue #5492) CREATE MATERIALIZED VIEW mat_m2( a, sumb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT a, sum(b) FROM int_tab GROUP BY time_bucket(1, a), a WITH NO DATA; -- add refresh policy SELECT timescaledb_experimental.add_policies('mat_m2', refresh_start_offset => 10, refresh_end_offset => 1); add_policies -------------- t SELECT timescaledb_experimental.show_policies('mat_m2'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 10} -- check for only one refresh policy for each cagg SELECT * FROM timescaledb_experimental.policies WHERE proc_name ~ 'refresh' ORDER BY relation_name, proc_name; relation_name | relation_schema | schedule_interval | proc_schema | proc_name | config | hypertable_schema | hypertable_name ---------------+-----------------+-------------------+------------------------+-------------------------------------+---------------------------------------------------------------+-----------------------+---------------------------- mat_m1 | public | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | {"end_offset": 1, "start_offset": 10, "mat_hypertable_id": 2} | _timescaledb_internal | _materialized_hypertable_2 mat_m2 | public | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | {"end_offset": 1, "start_offset": 10, "mat_hypertable_id": 4} | _timescaledb_internal | _materialized_hypertable_4 SELECT timescaledb_experimental.remove_all_policies('mat_m2'); remove_all_policies --------------------- t DROP MATERIALIZED VIEW mat_m2; -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_m1', refresh_start_offset => 11, compress_after=>13, drop_after => 25); alter_policies ---------------- t SELECT timescaledb_experimental.show_policies('mat_m1'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": 13, "compress_interval": "@ 1 day"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 11} {"drop_after": 25, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Remove one or more policy SELECT timescaledb_experimental.remove_policies('mat_m1', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); remove_policies ----------------- t SELECT timescaledb_experimental.show_policies('mat_m1'); show_policies ---------------------------------------------------------------------------------------- {"drop_after": 25, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Add one policy SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 10, refresh_end_offset => 1); add_policies -------------- t SELECT timescaledb_experimental.show_policies('mat_m1'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 10} {"drop_after": 25, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Remove all policies SELECT timescaledb_experimental.remove_policies('mat_m1', false, 'policy_refresh_continuous_aggregate', 'policy_retention'); remove_policies ----------------- t SELECT timescaledb_experimental.show_policies('mat_m1'); show_policies --------------- --Cross policy checks --refresh and compression policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 12, refresh_end_offset => 1, compress_after=>11); ERROR: refresh and columnstore policies overlap --refresh and retention policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 12, refresh_end_offset => 1, drop_after=>11); ERROR: refresh and retention policies overlap --compression and retention policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', compress_after => 10, drop_after => 10); ERROR: columnstore and retention policies overlap -- Alter non existent policies SELECT timescaledb_experimental.alter_policies('mat_m1', refresh_start_offset => 12, compress_after=>11, drop_after => 15); ERROR: no jobs found ALTER materialized view mat_m1 set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('int_tab', '1 day'::interval, 10 , '1 h'::interval); ERROR: "int_tab" is not a continuous aggregate SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::interval, 10 , '1 h'::interval); ERROR: invalid parameter value for start_offset HINT: Use time interval of type integer with the continuous aggregate. SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::interval, 10 ); ERROR: function add_continuous_aggregate_policy(unknown, interval, integer) does not exist LINE 1: SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::in... ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. SELECT add_continuous_aggregate_policy('mat_m1', 10, '1 day'::interval, '1 h'::interval); ERROR: invalid parameter value for end_offset HINT: Use time interval of type integer with the continuous aggregate. --start_interval < end_interval SELECT add_continuous_aggregate_policy('mat_m1', 5, 10, '1h'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "integer". --refresh window less than two buckets SELECT add_continuous_aggregate_policy('mat_m1', 11, 10, '1h'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "integer". SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval) as job_id \gset --adding again should warn/error SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>false); ERROR: continuous aggregate refresh policy already exists for "mat_m1" DETAIL: A refresh policy with the same start and end offset already exists for continuous aggregate "mat_m1". SELECT add_continuous_aggregate_policy('mat_m1', 20, 15, '1h'::interval, if_not_exists=>true); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping DETAIL: A refresh policy with the same start and end offset already exists for continuous aggregate "mat_m1". add_continuous_aggregate_policy --------------------------------- -1 -- modify config and try to add, should error out SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; config ---------------------------------------------------------------- {"end_offset": 10, "start_offset": 20, "mat_hypertable_id": 2} SELECT hypertable_id as mat_id FROM _timescaledb_config.bgw_job where id = :job_id \gset \set VERBOSITY terse \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; UPDATE _timescaledb_config.bgw_job SET config = jsonb_build_object('mat_hypertable_id', :mat_id) WHERE id = :job_id; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; config -------------------------- {"mat_hypertable_id": 2} \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>true); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('int_tab'); ERROR: "int_tab" is not a continuous aggregate SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ -- add with NULL offset, readd with NULL offset SELECT add_continuous_aggregate_policy('mat_m1', 20, NULL, '1h'::interval, if_not_exists=>true); add_continuous_aggregate_policy --------------------------------- 1010 SELECT add_continuous_aggregate_policy('mat_m1', 20, NULL, '1h'::interval, if_not_exists=>true); -- same param values, so we get a NOTICE NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping DETAIL: A refresh policy with the same start and end offset already exists for continuous aggregate "mat_m1". add_continuous_aggregate_policy --------------------------------- -1 SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '1h'::interval, if_not_exists=>true); -- different values, so we get a WARNING ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 20, '1h'::interval, if_not_exists=>true); add_continuous_aggregate_policy --------------------------------- 1011 SELECT add_continuous_aggregate_policy('mat_m1', NULL, 20, '1h'::interval, if_not_exists=>true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping DETAIL: A refresh policy with the same start and end offset already exists for continuous aggregate "mat_m1". add_continuous_aggregate_policy --------------------------------- -1 SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '1h'::interval, if_not_exists=>true); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ --this one will fail SELECT remove_continuous_aggregate_policy('mat_m1'); ERROR: continuous aggregate policy not found for "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1', if_not_exists=>true); NOTICE: continuous aggregate policy not found for "mat_m1", skipping remove_continuous_aggregate_policy ------------------------------------ --now try to add a policy as a different user than the one that created the cagg --should fail SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval) as job_id ; ERROR: must be owner of continuous aggregate "mat_m1" \set VERBOSITY terse \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW mat_m1; --- code coverage tests : add policy for timestamp and date based table --- CREATE TABLE continuous_agg_max_mat_date(time DATE); SELECT create_hypertable('continuous_agg_max_mat_date', 'time'); create_hypertable ------------------------------------------ (5,public,continuous_agg_max_mat_date,t) CREATE MATERIALIZED VIEW max_mat_view_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) FROM continuous_agg_max_mat_date GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for timestamp type buckets ALTER materialized view max_mat_view_date set (timescaledb.compress = true); NOTICE: defaulting compress_orderby to time_bucket -- Only works for cagg SELECT timescaledb_experimental.add_policies('continuous_agg_max_mat_date', refresh_start_offset => '1 day'::interval, refresh_end_offset => '2 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); ERROR: "continuous_agg_max_mat_date" is not a continuous aggregate SELECT timescaledb_experimental.show_policies('continuous_agg_max_mat_date'); ERROR: "continuous_agg_max_mat_date" is not a continuous aggregate SELECT timescaledb_experimental.alter_policies('continuous_agg_max_mat_date', compress_after=>'16 days'::interval); ERROR: "continuous_agg_max_mat_date" is not a continuous aggregate SELECT timescaledb_experimental.remove_policies('continuous_agg_max_mat_date', false, 'policy_refresh_continuous_aggregate'); ERROR: "continuous_agg_max_mat_date" is not a continuous aggregate -- No policy is added if one errors out SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '1 day'::interval, refresh_end_offset => '2 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "date". SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies --------------- -- Create open ended refresh_policy SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => '2 day'::interval); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": "@ 2 days", "refresh_start_offset": null} SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); remove_policies ----------------- t SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => '2 day'::interval, refresh_start_offset=>'-infinity'); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": "@ 2 days", "refresh_start_offset": null} SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); remove_policies ----------------- t SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '2 day'::interval); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": null, "refresh_start_offset": "@ 2 days"} SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); remove_policies ----------------- t SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '2 day'::interval, refresh_end_offset=>'infinity'); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": null, "refresh_start_offset": "@ 2 days"} SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); remove_policies ----------------- t -- Open ended at both sides, for code coverage SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => 'infinity', refresh_start_offset => '-infinity'); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": null, "refresh_start_offset": null} SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); remove_policies ----------------- t -- All policies are added in one step SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '15 days'::interval, refresh_end_offset => '1 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": "@ 20 days", "compress_interval": "@ 12 hours"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": "@ 1 day", "refresh_start_offset": "@ 15 days"} {"drop_after": "@ 25 days", "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Alter policies SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset => '16 days'::interval, compress_after=>'26 days'::interval, drop_after => '40 days'::interval); alter_policies ---------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": "@ 26 days", "compress_interval": "@ 12 hours"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": "@ 1 day", "refresh_start_offset": "@ 16 days"} {"drop_after": "@ 40 days", "policy_name": "policy_retention", "retention_interval": "@ 1 day"} --Alter refresh_policy to make it open ended SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_retention', 'policy_compression'); remove_policies ----------------- t SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'-infinity'); alter_policies ---------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies ------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": "@ 1 day", "refresh_start_offset": null} SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_end_offset =>'infinity', refresh_start_offset =>'5 days'::interval); alter_policies ---------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": null, "refresh_start_offset": "@ 5 days"} --Cross policy checks -- Refresh and compression policies overlap SELECT timescaledb_experimental.add_policies('max_mat_view_date', compress_after => '20 days'::interval, drop_after => '25 days'::interval); add_policies -------------- t SELECT timescaledb_experimental.alter_policies('max_mat_view_date', compress_after=> '4 days'::interval); ERROR: refresh and columnstore policies overlap SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": "@ 20 days", "compress_interval": "@ 12 hours"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": null, "refresh_start_offset": "@ 5 days"} {"drop_after": "@ 25 days", "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Refresh and retention policies overlap SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'5 days'::interval, drop_after=> '4 days'::interval); ERROR: refresh and retention policies overlap SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": "@ 20 days", "compress_interval": "@ 12 hours"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": null, "refresh_start_offset": "@ 5 days"} {"drop_after": "@ 25 days", "policy_name": "policy_retention", "retention_interval": "@ 1 day"} --Do not allow refreshed data to be deleted SELECT add_retention_policy('continuous_agg_max_mat_date', '25 days'::interval); add_retention_policy ---------------------- 1027 SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'25 days'::interval); ERROR: refresh policy of continuous aggregate and retention policy of underlying hypertable overlap SELECT remove_retention_policy('continuous_agg_max_mat_date'); remove_retention_policy ------------------------- -- Remove one or more policy -- Code coverage: no policy names provided SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false); remove_policies ----------------- f -- Code coverage: incorrect name of policy SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'refresh_policy'); NOTICE: No relevant policy found remove_policies ----------------- f SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); remove_policies ----------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies ------------------------------------------------------------------------------------------------- {"drop_after": "@ 25 days", "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Add one policy SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '15 day'::interval, refresh_end_offset => '1 day'::interval); add_policies -------------- t SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies -------------------------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": "@ 1 day", "refresh_start_offset": "@ 15 days"} {"drop_after": "@ 25 days", "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Remove all policies SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; relation_name | relation_schema | schedule_interval | proc_schema | proc_name | config | hypertable_schema | hypertable_name -------------------+-----------------+-------------------+------------------------+-------------------------------------+--------------------------------------------------------------------------------+-----------------------+---------------------------- max_mat_view_date | public | @ 1 hour | _timescaledb_functions | policy_refresh_continuous_aggregate | {"end_offset": "@ 1 day", "start_offset": "@ 15 days", "mat_hypertable_id": 6} | _timescaledb_internal | _materialized_hypertable_6 max_mat_view_date | public | @ 1 day | _timescaledb_functions | policy_retention | {"drop_after": "@ 25 days", "hypertable_id": 6} | _timescaledb_internal | _materialized_hypertable_6 SELECT timescaledb_experimental.remove_all_policies(NULL); -- should fail remove_all_policies --------------------- f SELECT timescaledb_experimental.remove_all_policies('continuous_agg_max_mat_date'); -- should fail ERROR: "continuous_agg_max_mat_date" is not a continuous aggregate SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', false); remove_all_policies --------------------- t SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', false); -- should fail remove_all_policies --------------------- f CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS RECORD LANGUAGE SQL AS $$ VALUES($1, $2, 'custom_func'); $$; -- inject custom job SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS job_id \gset SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id, 'max_mat_view_date'::regclass); alter_job_set_hypertable_id ----------------------------- 1029 SELECT * FROM timescaledb_information.jobs WHERE job_id != 1 ORDER BY 1; job_id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | config | next_start | initial_start | hypertable_schema | hypertable_name | check_schema | check_name --------+----------------------------+-------------------+-------------+-------------+--------------+-------------+-------------+-------------------+-----------+----------------+----------------------+------------------------------+------------------------------+-------------------+-------------------+--------------+------------ 1029 | User-Defined Action [1029] | @ 1 hour | @ 0 | -1 | @ 5 mins | public | custom_func | default_perm_user | t | t | {"type": "function"} | Fri Dec 31 16:00:00 1999 PST | Fri Dec 31 16:00:00 1999 PST | public | max_mat_view_date | | SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', true); -- ignore custom job NOTICE: Ignoring custom job remove_all_policies --------------------- t SELECT delete_job(:job_id); delete_job ------------ DROP FUNCTION custom_func; SELECT timescaledb_experimental.show_policies('max_mat_view_date'); show_policies --------------- ALTER materialized view max_mat_view_date set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('max_mat_view_date', '2 days', 10, '1 day'::interval); ERROR: invalid parameter value for end_offset HINT: Use time interval with a continuous aggregate using timestamp-based time bucket. --start_interval < end_interval SELECT add_continuous_aggregate_policy('max_mat_view_date', '1 day'::interval, '2 days'::interval , '1 day'::interval) ; ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "date". --interval less than two buckets SELECT add_continuous_aggregate_policy('max_mat_view_date', '7 days', '1 day', '1 day'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "date". SELECT add_continuous_aggregate_policy('max_mat_view_date', '14 days', '1 day', '1 day'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "date". SELECT add_continuous_aggregate_policy('max_mat_view_date', '13 days', '-10 hours', '1 day'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "date". \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Negative start offset gives two bucket window: SELECT add_continuous_aggregate_policy('max_mat_view_date', '13 days', '-1 day', '1 day'::interval); add_continuous_aggregate_policy --------------------------------- 1030 SELECT remove_continuous_aggregate_policy('max_mat_view_date'); remove_continuous_aggregate_policy ------------------------------------ -- Both offsets NULL: SELECT add_continuous_aggregate_policy('max_mat_view_date', NULL, NULL, '1 day'::interval); add_continuous_aggregate_policy --------------------------------- 1031 SELECT remove_continuous_aggregate_policy('max_mat_view_date'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('max_mat_view_date', '15 days', '1 day', '1 day'::interval) as job_id \gset SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; config -------------------------------------------------------------------------------- {"end_offset": "@ 1 day", "start_offset": "@ 15 days", "mat_hypertable_id": 6} INSERT INTO continuous_agg_max_mat_date SELECT generate_series('2019-09-01'::date, '2019-09-10'::date, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; CALL run_job(:job_id); RESET client_min_messages; DROP MATERIALIZED VIEW max_mat_view_date; CREATE TABLE continuous_agg_timestamp(time TIMESTAMP); SELECT create_hypertable('continuous_agg_timestamp', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------------- (8,public,continuous_agg_timestamp,t) CREATE MATERIALIZED VIEW max_mat_view_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) FROM continuous_agg_timestamp GROUP BY 1 WITH NO DATA; --the start offset overflows the smallest time value, but is capped at --the min value SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '1000000 years', '1 day' , '1 h'::interval); add_continuous_aggregate_policy --------------------------------- 1033 SELECT remove_continuous_aggregate_policy('max_mat_view_timestamp'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 0 \set VERBOSITY default --start and end offset capped at the lowest time value, which means --zero size window SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '1000000 years', '900000 years' , '1 h'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "timestamp without time zone". SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '301 days', '10 months' , '1 h'::interval); ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "timestamp without time zone". \set VERBOSITY terse \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 days', '1 h'::interval , '1 h'::interval) as job_id \gset --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; CALL run_job(:job_id); RESET client_min_messages ; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; config --------------------------------------------------------------------------------- {"end_offset": "@ 1 hour", "start_offset": "@ 15 days", "mat_hypertable_id": 9} \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; UPDATE _timescaledb_config.bgw_job SET config = jsonb_build_object('mat_hypertable_id', :mat_id) WHERE id = :job_id; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; config -------------------------- {"mat_hypertable_id": 2} \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 day', '1 day', '1h'::interval, if_not_exists=>true); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "max_mat_view_timestamp" SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', 'xyz', '1 day', '1h'::interval, if_not_exists=>true); ERROR: invalid input syntax for type interval: "xyz" \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW max_mat_view_timestamp; --smallint table CREATE TABLE smallint_tab (a smallint); SELECT table_name FROM create_hypertable('smallint_tab', 'a', chunk_time_interval=> 10); table_name -------------- smallint_tab CREATE OR REPLACE FUNCTION integer_now_smallint_tab() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a)::smallint, 0::smallint) FROM smallint_tab ; $$; SELECT set_integer_now_func('smallint_tab', 'integer_now_smallint_tab'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_smallint( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT time_bucket( SMALLINT '1', a) , count(*) FROM smallint_tab GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for smallint type buckets ALTER materialized view mat_smallint set (timescaledb.compress = true); NOTICE: defaulting compress_orderby to a -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_smallint', refresh_start_offset => 10::smallint, refresh_end_offset => 1::smallint, compress_after => 11::smallint, drop_after => 20::smallint); add_policies -------------- t SELECT timescaledb_experimental.show_policies('mat_smallint'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": 11, "compress_interval": "@ 1 day"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 10} {"drop_after": 20, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_smallint', refresh_start_offset => 11::smallint, compress_after=>13::smallint, drop_after => 25::smallint); alter_policies ---------------- t SELECT timescaledb_experimental.show_policies('mat_smallint'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": 13, "compress_interval": "@ 1 day"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 11} {"drop_after": 25, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} SELECT timescaledb_experimental.remove_all_policies('mat_smallint', false); remove_all_policies --------------------- t ALTER materialized view mat_smallint set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('mat_smallint', 15, 0 , '1 h'::interval); ERROR: invalid parameter value for start_offset HINT: Use time interval of type smallint with the continuous aggregate. SELECT add_continuous_aggregate_policy('mat_smallint', 98898::smallint , 0::smallint, '1 h'::interval); ERROR: smallint out of range SELECT add_continuous_aggregate_policy('mat_smallint', 5::smallint, 10::smallint , '1 h'::interval) as job_id \gset ERROR: policy refresh window too small DETAIL: The start and end offsets must cover at least two buckets in the valid time range of type "smallint". \set VERBOSITY terse \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('mat_smallint', 15::smallint, 0::smallint , '1 h'::interval) as job_id \gset INSERT INTO smallint_tab VALUES(5); INSERT INTO smallint_tab VALUES(10); INSERT INTO smallint_tab VALUES(20); CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; a | countb ----+-------- 5 | 1 10 | 1 --remove all the data-- TRUNCATE table smallint_tab; CALL refresh_continuous_aggregate('mat_smallint', NULL, NULL); SELECT * FROM mat_smallint ORDER BY 1; a | countb ---+-------- -- Case 1: overflow by subtracting from PG_INT16_MIN --overflow start_interval, end_interval [-32768, -32768) SELECT remove_continuous_aggregate_policy('mat_smallint'); remove_continuous_aggregate_policy ------------------------------------ INSERT INTO smallint_tab VALUES( -32768 ); SELECT integer_now_smallint_tab(); integer_now_smallint_tab -------------------------- -32768 SELECT add_continuous_aggregate_policy('mat_smallint', 10::smallint, 5::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); ERROR: invalid refresh window \set ON_ERROR_STOP 1 SELECT * FROM mat_smallint ORDER BY 1; a | countb ---+-------- -- overflow start_interval. now this runs as range is capped [-32768, -32765) INSERT INTO smallint_tab VALUES( -32760 ); SELECT maxval, maxval - 10, maxval -5 FROM integer_now_smallint_tab() as maxval; maxval | ?column? | ?column? --------+----------+---------- -32760 | -32770 | -32765 CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; a | countb --------+-------- -32768 | 1 --remove all the data-- TRUNCATE table smallint_tab; CALL refresh_continuous_aggregate('mat_smallint', NULL, NULL); SELECT * FROM mat_smallint ORDER BY 1; a | countb ---+-------- -- Case 2: overflow by subtracting from PG_INT16_MAX --overflow start and end . will fail as range is [32767, 32767] SELECT remove_continuous_aggregate_policy('mat_smallint'); remove_continuous_aggregate_policy ------------------------------------ INSERT INTO smallint_tab VALUES( 32766 ); INSERT INTO smallint_tab VALUES( 32767 ); SELECT maxval, maxval - (-1), maxval - (-2) FROM integer_now_smallint_tab() as maxval; maxval | ?column? | ?column? --------+----------+---------- 32767 | 32768 | 32769 SELECT add_continuous_aggregate_policy('mat_smallint', -1::smallint, -3::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); ERROR: invalid refresh window \set ON_ERROR_STOP 1 SELECT * FROM mat_smallint ORDER BY 1; a | countb ---+-------- SELECT remove_continuous_aggregate_policy('mat_smallint'); remove_continuous_aggregate_policy ------------------------------------ --overflow end . will work range is [32765, 32767) SELECT maxval, maxval - (1), maxval - (-2) FROM integer_now_smallint_tab() as maxval; maxval | ?column? | ?column? --------+----------+---------- 32767 | 32766 | 32769 SELECT add_continuous_aggregate_policy('mat_smallint', 1::smallint, -3::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; a | countb -------+-------- 32766 | 1 -- tests for interval argument conversions -- \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_smallint', 15, 10, '1h'::interval, if_not_exists=>true); ERROR: invalid parameter value for start_offset SELECT add_continuous_aggregate_policy('mat_smallint', '15', 10, '1h'::interval, if_not_exists=>true); ERROR: invalid parameter value for end_offset SELECT add_continuous_aggregate_policy('mat_smallint', '15', '10', '1h'::interval, if_not_exists=>true); add_continuous_aggregate_policy --------------------------------- 1045 \set ON_ERROR_STOP 1 --bigint table CREATE TABLE bigint_tab (a bigint); SELECT table_name FROM create_hypertable('bigint_tab', 'a', chunk_time_interval=> 10); table_name ------------ bigint_tab CREATE OR REPLACE FUNCTION integer_now_bigint_tab() returns bigint LANGUAGE SQL STABLE as $$ SELECT 20::bigint $$; SELECT set_integer_now_func('bigint_tab', 'integer_now_bigint_tab'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_bigint( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT time_bucket( BIGINT '1', a) , count(*) FROM bigint_tab GROUP BY 1 WITH NO DATA; -- Test 1 step policy for bigint type buckets ALTER materialized view mat_bigint set (timescaledb.compress = true); NOTICE: defaulting compress_orderby to a -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_bigint', refresh_start_offset => 10::bigint, refresh_end_offset => 1::bigint, compress_after => 11::bigint, drop_after => 20::bigint); add_policies -------------- t SELECT timescaledb_experimental.show_policies('mat_bigint'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": 11, "compress_interval": "@ 1 day"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 10} {"drop_after": 20, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_bigint', refresh_start_offset => 11::bigint, compress_after=>13::bigint, drop_after => 25::bigint); alter_policies ---------------- t SELECT timescaledb_experimental.show_policies('mat_bigint'); show_policies --------------------------------------------------------------------------------------------------------------------------------------------- {"policy_name": "policy_compression", "compress_after": 13, "compress_interval": "@ 1 day"} {"policy_name": "policy_refresh_continuous_aggregate", "refresh_interval": "@ 1 hour", "refresh_end_offset": 1, "refresh_start_offset": 11} {"drop_after": 25, "policy_name": "policy_retention", "retention_interval": "@ 1 day"} SELECT timescaledb_experimental.remove_all_policies('mat_bigint', false); remove_all_policies --------------------- t ALTER materialized view mat_bigint set (timescaledb.compress = false); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_bigint', 5::bigint, 10::bigint , '1 h'::interval) ; ERROR: policy refresh window too small \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('mat_bigint', 15::bigint, 0::bigint , '1 h'::interval) as job_mid \gset INSERT INTO bigint_tab VALUES(5); INSERT INTO bigint_tab VALUES(10); INSERT INTO bigint_tab VALUES(20); CALL run_job(:job_mid); SELECT * FROM mat_bigint ORDER BY 1; a | countb ----+-------- 5 | 1 10 | 1 -- test NULL for end SELECT remove_continuous_aggregate_policy('mat_bigint'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_bigint', 1::smallint, NULL , '1 h'::interval) as job_id \gset INSERT INTO bigint_tab VALUES(500); CALL run_job(:job_id); SELECT * FROM mat_bigint WHERE a>100 ORDER BY 1; a | countb -----+-------- 500 | 1 ALTER MATERIALIZED VIEW mat_bigint SET (timescaledb.compress); NOTICE: defaulting compress_orderby to a ALTER MATERIALIZED VIEW mat_smallint SET (timescaledb.compress); NOTICE: defaulting compress_orderby to a -- With immutable compressed chunks, these policies would fail by overlapping the refresh window SELECT add_compression_policy('mat_smallint', -4::smallint); add_compression_policy ------------------------ 1054 SELECT remove_compression_policy('mat_smallint'); remove_compression_policy --------------------------- t SELECT add_compression_policy('mat_bigint', 0::bigint); add_compression_policy ------------------------ 1055 SELECT remove_compression_policy('mat_bigint'); remove_compression_policy --------------------------- t -- End previous limitation tests SELECT add_compression_policy('mat_smallint', 5::smallint); add_compression_policy ------------------------ 1056 SELECT add_compression_policy('mat_bigint', 20::bigint); add_compression_policy ------------------------ 1057 -- end of coverage tests --TEST continuous aggregate + compression policy on caggs CREATE TABLE metrics ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable('metrics', 'time'); create_hypertable ----------------------- (18,public,metrics,t) INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-02 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); ALTER TABLE metrics SET ( timescaledb.compress ); SELECT compress_chunk(ch) FROM show_chunks('metrics') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_18_19_chunk CREATE MATERIALIZED VIEW metrics_cagg WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1 day', time) as dayb, device_id, sum(v0), avg(v3) FROM metrics GROUP BY 1, 2 WITH NO DATA; -- this was previously crashing SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, NULL, '1 h'::interval, if_not_exists => true); add_continuous_aggregate_policy --------------------------------- 1058 \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, '1 day'::interval, '1 h'::interval, if_not_exists => true); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "metrics_cagg" SELECT remove_continuous_aggregate_policy('metrics_cagg'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, '1 day'::interval, '1h'::interval, if_not_exists=>true); add_continuous_aggregate_policy --------------------------------- 1059 SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, '1 day'::interval, '1h'::interval, if_not_exists=>true); -- same param values, so we get a NOTICE NOTICE: continuous aggregate refresh policy already exists for "metrics_cagg", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, NULL, '1h'::interval, if_not_exists=>true); -- different values, so we get a WARNING ERROR: refresh interval overlaps with an existing continuous aggregate policy on "metrics_cagg" SELECT remove_continuous_aggregate_policy('metrics_cagg'); remove_continuous_aggregate_policy ------------------------------------ --can set compression policy only after setting up refresh policy -- SELECT add_compression_policy('metrics_cagg', '1 day'::interval); ERROR: setup a refresh policy for "metrics_cagg" before setting up a columnstore policy --can set compression policy only after enabling compression -- SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, '1 day'::interval, '1 h'::interval) as "REFRESH_JOB" \gset SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" ; ERROR: columnstore not enabled on continuous aggregate "metrics_cagg" ALTER MATERIALIZED VIEW metrics_cagg SET (timescaledb.compress); NOTICE: defaulting compress_segmentby to device_id NOTICE: defaulting compress_orderby to dayb --cannot use compress_created_before with cagg SELECT add_compression_policy('metrics_cagg', compress_created_before => '8 day'::interval) AS "COMP_JOB" ; ERROR: cannot use "compress_created_before" with continuous aggregate "metrics_cagg" \set ON_ERROR_STOP 1 SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" ; COMP_JOB ---------- 1061 SELECT remove_compression_policy('metrics_cagg'); remove_compression_policy --------------------------- t SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" \gset --verify that jobs were added for the policies --- SELECT materialization_hypertable_name AS "MAT_TABLE_NAME", view_name AS "VIEW_NAME" FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_cagg' \gset SELECT count(*) FROM timescaledb_information.jobs WHERE hypertable_name = :'VIEW_NAME'; count ------- 2 --exec the cagg compression job -- CALL refresh_continuous_aggregate('metrics_cagg', NULL, '2001-02-01 00:00:00+0'); CALL run_job(:COMP_JOB); SELECT count(*), count(*) FILTER ( WHERE is_compressed is TRUE ) FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; count | count -------+------- 1 | 1 --add some new data into metrics_cagg so that cagg policy job has something to do INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT now() - '5 day'::interval, 102, 0, 10, 10, 10, 10; CALL run_job(:REFRESH_JOB); --now we have a new chunk and it is not compressed SELECT count(*), count(*) FILTER ( WHERE is_compressed is TRUE ) FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; count | count -------+------- 2 | 1 --verify that both jobs are dropped when view is dropped DROP MATERIALIZED VIEW metrics_cagg; NOTICE: drop cascades to 2 other objects SELECT count(*) FROM timescaledb_information.jobs WHERE hypertable_name = :'VIEW_NAME'; count ------- 0 -- add test case for issue 4252 CREATE TABLE IF NOT EXISTS sensor_data( time TIMESTAMPTZ NOT NULL, sensor_id INTEGER, temperature DOUBLE PRECISION, cpu DOUBLE PRECISION); SELECT create_hypertable('sensor_data','time'); create_hypertable --------------------------- (22,public,sensor_data,t) INSERT INTO sensor_data(time, sensor_id, cpu, temperature) SELECT time, sensor_id, extract(dow from time) AS cpu, extract(doy from time) AS temperature FROM generate_series('2022-05-05'::timestamp at time zone 'UTC' - interval '6 weeks', '2022-05-05'::timestamp at time zone 'UTC', interval '5 hours') as g1(time), generate_series(1,1000,1) as g2(sensor_id); CREATE materialized view deals_best_weekly WITH (timescaledb.continuous) AS SELECT time_bucket('7 days', "time") AS bucket, avg(temperature) AS avg_temp, max(cpu) AS max_rating FROM sensor_data GROUP BY bucket WITH NO DATA; CREATE materialized view deals_best_daily WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', "time") AS bucket, avg(temperature) AS avg_temp, max(cpu) AS max_rating FROM sensor_data GROUP BY bucket WITH NO DATA; ALTER materialized view deals_best_weekly set (timescaledb.materialized_only=true); ALTER materialized view deals_best_daily set (timescaledb.materialized_only=true); -- we have data from 6 weeks before to May 5 2022 (Thu) CALL refresh_continuous_aggregate('deals_best_weekly', '2022-04-24', '2022-05-03'); SELECT * FROM deals_best_weekly ORDER BY bucket; bucket | avg_temp | max_rating ------------------------------+------------------+------------ Sun Apr 24 17:00:00 2022 PDT | 117.764705882353 | 6 CALL refresh_continuous_aggregate('deals_best_daily', '2022-04-20', '2022-05-04'); SELECT * FROM deals_best_daily ORDER BY bucket LIMIT 2; bucket | avg_temp | max_rating ------------------------------+----------+------------ Wed Apr 20 17:00:00 2022 PDT | 110.8 | 4 Thu Apr 21 17:00:00 2022 PDT | 111.75 | 5 -- expect to get an up-to-date notice CALL refresh_continuous_aggregate('deals_best_weekly', '2022-04-24', '2022-05-05'); NOTICE: continuous aggregate "deals_best_weekly" is already up-to-date SELECT * FROM deals_best_weekly ORDER BY bucket; bucket | avg_temp | max_rating ------------------------------+------------------+------------ Sun Apr 24 17:00:00 2022 PDT | 117.764705882353 | 6 -- github issue 5907: segfault when creating 1-step policies on cagg -- whose underlying hypertable has a retention policy setup CREATE TABLE t(a integer NOT NULL, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); create_hypertable ------------------- (25,public,t,t) CREATE OR REPLACE FUNCTION unix_now() returns int LANGUAGE SQL IMMUTABLE as $$ SELECT extract(epoch from now())::INT $$; SELECT set_integer_now_func('t', 'unix_now'); set_integer_now_func ---------------------- SELECT add_retention_policy('t', 20); add_retention_policy ---------------------- 1063 CREATE MATERIALIZED VIEW cagg(a, sumb) WITH (timescaledb.continuous) AS SELECT time_bucket(1, a), sum(b) FROM t GROUP BY time_bucket(1, a); NOTICE: continuous aggregate "cagg" is already up-to-date SELECT timescaledb_experimental.add_policies('cagg'); add_policies -------------- f -- Issue #6902 -- Fix timestamp out of range in a refresh policy when setting `end_offset=>NULL` -- for a CAgg with variable sized bucket (i.e: using `time_bucket` with timezone) CREATE TABLE issue_6902 ( ts TIMESTAMPTZ NOT NULL, temperature NUMERIC ) WITH ( timescaledb.hypertable, timescaledb.partition_column='ts', timescaledb.chunk_interval='1 day', timescaledb.compress='off' ); INSERT INTO issue_6902 SELECT t, 1 FROM generate_series(now() - interval '3 hours', now(), interval '1 minute') AS t; CREATE MATERIALIZED VIEW issue_6902_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', ts, 'America/Sao_Paulo') AS bucket, -- using timezone MAX(temperature), MIN(temperature), COUNT(*) FROM issue_6902 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy ( 'issue_6902_by_hour', start_offset => INTERVAL '3 hours', end_offset => NULL, schedule_interval => INTERVAL '12 hour', initial_start => now() + INTERVAL '12 hour' ) AS job_id \gset -- 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; count ------- 181 -- run again without any change, remain 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; count ------- 181 -- change existing data UPDATE issue_6902 SET temperature = temperature + 1; -- run again without any change, remain 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; count ------- 181 -- insert more data INSERT INTO issue_6902 SELECT t, 1 FROM generate_series(now() - interval '3 hours', now(), interval '1 minute') AS t; -- run again without and should have 362 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; count ------- 362 ���������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_policy_concurrent.out�������������������������������������0000664�0000000�0000000�00000155173�15100345067�0024724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test creation of multiple refresh policies SET timezone TO PST8PDT; SET timescaledb.current_timestamp_mock TO '2025-06-01 0:30:00+00'; SELECT setseed(1); setseed --------- -- test interval checking with bigint CREATE TABLE overlap_test_bigint ( time BIGINT NOT NULL, a INTEGER, b INTEGER ); SELECT create_hypertable('overlap_test_bigint', 'time', chunk_time_interval => 100); create_hypertable ---------------------------------- (1,public,overlap_test_bigint,t) CREATE OR REPLACE FUNCTION integer_now_overlap_test_bigint() RETURNS BIGINT LANGUAGE SQL STABLE AS $$ SELECT COALESCE(MAX(time), 0) FROM overlap_test_bigint $$; SELECT set_integer_now_func('overlap_test_bigint', 'integer_now_overlap_test_bigint'); set_integer_now_func ---------------------- INSERT INTO overlap_test_bigint SELECT i, (i % 5), random() * 100 FROM generate_series(1, 2000) i; CREATE MATERIALIZED VIEW mat_m1(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, count(a), sum(b) FROM overlap_test_bigint GROUP BY 1 WITH NO DATA; /* Test interval checking when multiple policies are created on the same cagg */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 SELECT add_continuous_aggregate_policy('mat_m1', 1000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Creating policies in either order should work */ SELECT add_continuous_aggregate_policy('mat_m1', 1000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1003 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 3000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1004 SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1005 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Test non-null offsets on both sides too */ SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1006 SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 3000::bigint,'12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1007 SELECT add_continuous_aggregate_policy('mat_m1', 3000::bigint, 2000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1008 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Check overlap is detected correctly */ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1009 SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1010 SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', 5000::bigint, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1011 SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1012 SELECT add_continuous_aggregate_policy('mat_m1', 5000::bigint, 1000::bigint, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1013 SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1014 SELECT add_continuous_aggregate_policy('mat_m1', 1000::bigint, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Check behaviour when exact policy is already defined */ \set ON_ERROR_STOP 0 /*if_not_exists=false*/ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1015 SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1016 SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); ERROR: continuous aggregate refresh policy already exists for "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1017 SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval); ERROR: continuous aggregate refresh policy already exists for "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /*if_not_exists => true*/ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1018 SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1019 SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval, if_not_exists => true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1020 SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval, if_not_exists => true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Throw an error if there is an overlap even if if_not_exists => true */ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1021 \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', 3000::bigint, 1000::bigint, '12 h'::interval, if_not_exists => true); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Test `alter_job` changing the config */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 3000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1022 SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1023 /* Alter end offset but don't overlap */ SELECT jsonb_set(:'config', '{end_offset}', '2000') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+--------------------------------------------------------------------+------------+------------------------------------------------------------------+----------------+---------------+----------+-------------------------------------------- 1022 | @ 12 hours | @ 0 | -1 | @ 12 hours | t | {"end_offset": 2000, "start_offset": null, "mat_hypertable_id": 2} | -infinity | _timescaledb_functions.policy_refresh_continuous_aggregate_check | f | | | Refresh Continuous Aggregate Policy [1022] \set ON_ERROR_STOP 0 /* Alter end offset to overlap with another job*/ SELECT jsonb_set(:'config', '{end_offset}', '1000') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" /* Alter end offset to be null */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" /* Alter job to be identical to existing job */ SELECT jsonb_set(:'config', '{start_offset}', '2000') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: continuous aggregate refresh policy already exists for "mat_m1" \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1024 SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', NULL, 3000::bigint, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1025 /* Alter end offset to null but no overlap */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+--------------------------------------------------------------------+------------+------------------------------------------------------------------+----------------+---------------+----------+-------------------------------------------- 1024 | @ 12 hours | @ 0 | -1 | @ 12 hours | t | {"end_offset": null, "start_offset": 2000, "mat_hypertable_id": 2} | -infinity | _timescaledb_functions.policy_refresh_continuous_aggregate_check | f | | | Refresh Continuous Aggregate Policy [1024] SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Test that refresh is done correctly even though multiple policies exist */ /* We do this by creating two CAggs on the same hypertable */ /* One will have a single policy while the other will have two policies with adjacent offsets */ CREATE MATERIALIZED VIEW mat_m2(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, count(a), sum(b) FROM overlap_test_bigint GROUP BY 1 WITH NO DATA; /* Create two policies on mat_m1 */ SELECT add_continuous_aggregate_policy('mat_m1', 5000::bigint, 3000::bigint, '12 h'::interval) AS agg_m1_job_1 \gset SELECT add_continuous_aggregate_policy('mat_m1', 3000::bigint, 1000::bigint, '12 h'::interval) AS agg_m1_job_2 \gset /* Create single policy on mat_m2 */ SELECT add_continuous_aggregate_policy('mat_m2', 5000::bigint, 1000::bigint, '12 h'::interval) AS agg_m2_job \gset /* Cleanup any existing data */ TRUNCATE mat_m1; TRUNCATE mat_m2; /* Refresh both continuous aggs immediately */ CALL run_job(:agg_m1_job_1); CALL run_job(:agg_m1_job_2); CALL run_job(:agg_m2_job); /* Compare both outputs */ SELECT count(*) AS exp_row_count from mat_m1 \gset SELECT count(*) AS actual_row_count from ( SELECT * from mat_m1 UNION SELECT * from mat_m2) union_q \gset /* Row counts should be the same */ SELECT :exp_row_count = :actual_row_count, :exp_row_count, :actual_row_count; ?column? | ?column? | ?column? ----------+----------+---------- t | 100 | 100 SELECT * from mat_m2 EXCEPT SELECT * from mat_m1; time | counta | sum ------+--------+----- SELECT * from mat_m1 EXCEPT SELECT * from mat_m2; time | counta | sum ------+--------+----- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_22_chunk DROP MATERIALIZED VIEW mat_m2; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_23_chunk CREATE TABLE overlap_test_timestamptz ( time timestamptz NOT NULL, a INTEGER, b INTEGER ); SELECT create_hypertable('overlap_test_timestamptz', 'time', chunk_time_interval => '1 day'::interval); create_hypertable --------------------------------------- (4,public,overlap_test_timestamptz,t) INSERT INTO overlap_test_timestamptz SELECT t, (i % 5), random() * 100 FROM generate_series('2025-01-01T01:01:01+00', '2025-06-01T01:01:01+00', INTERVAL '1 days') t, generate_series(1, 10) i; CREATE MATERIALIZED VIEW mat_m1(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz GROUP BY 1 WITH NO DATA; /* Test interval checking when multiple policies are created on the same cagg */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1029 SELECT add_continuous_aggregate_policy('mat_m1', '29 days'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1030 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Creating policies in either order should work */ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1031 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1032 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1033 SELECT add_continuous_aggregate_policy('mat_m1', '15 days'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1034 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Test non-null offsets on both sides too */ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '20 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1035 SELECT add_continuous_aggregate_policy('mat_m1', '10 days'::interval, '5 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1036 SELECT add_continuous_aggregate_policy('mat_m1', '19 days'::interval, '11 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1037 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Check overlap is detected correctly */ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1038 SELECT add_continuous_aggregate_policy('mat_m1', '45 days'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '45 days'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1039 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '10 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1040 SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, '15 days'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, '15 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1041 SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '10 days'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1042 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '20 days'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1043 SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Check behaviour when exact policy is already defined */ \set ON_ERROR_STOP 0 /*if_not_exists=false*/ SELECT add_continuous_aggregate_policy('mat_m1', '45 days'::interval, '30 days', '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1044 SELECT add_continuous_aggregate_policy('mat_m1', '31 days'::interval, '15 days', '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT add_continuous_aggregate_policy('mat_m1', '31 days'::interval, '15 days', '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1045 SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); ERROR: continuous aggregate refresh policy already exists for "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /*if_not_exists => true*/ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', '45 days', '30 days', '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1046 SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '15 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1047 SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '15 days'::interval, '12 h'::interval, if_not_exists => true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1048 SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval, if_not_exists => true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Throw an error if there is an overlap even if if_not_exists => true */ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '10 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1049 \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', '15 days'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Mixing different interval units should also work correctly*/ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1050 SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1051 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1052 SELECT add_continuous_aggregate_policy('mat_m1', '5 weeks'::interval, '-7 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1053 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1054 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1055 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1056 SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Check overlap with negative offsets */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1057 SELECT add_continuous_aggregate_policy('mat_m1', '-1 month'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1058 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '-2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1059 SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Test `alter_job` changing the config */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1060 SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1061 /* Alter end offset but don't overlap */ SELECT jsonb_set(:'config', '{end_offset}', '"30 days"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+-------------------------------------------------------------------------+------------+------------------------------------------------------------------+----------------+---------------+----------+-------------------------------------------- 1060 | @ 12 hours | @ 0 | -1 | @ 12 hours | t | {"end_offset": "30 days", "start_offset": null, "mat_hypertable_id": 5} | -infinity | _timescaledb_functions.policy_refresh_continuous_aggregate_check | f | | | Refresh Continuous Aggregate Policy [1060] \set ON_ERROR_STOP 0 /* Alter end offset to overlap with another job*/ SELECT jsonb_set(:'config', '{end_offset}', '"1 week"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" /* Alter end offset to be null */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" /* Alter job to be identical to existing job */ SELECT jsonb_set(:'config', '{start_offset}', '"2 weeks"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: continuous aggregate refresh policy already exists for "mat_m1" \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1062 SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1063 /* Alter end offset to null but no overlap */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+---------------------------------------------------------------------------+------------+------------------------------------------------------------------+----------------+---------------+----------+-------------------------------------------- 1062 | @ 12 hours | @ 0 | -1 | @ 12 hours | t | {"end_offset": null, "start_offset": "@ 14 days", "mat_hypertable_id": 5} | -infinity | _timescaledb_functions.policy_refresh_continuous_aggregate_check | f | | | Refresh Continuous Aggregate Policy [1062] SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ CREATE MATERIALIZED VIEW mat_m2(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz GROUP BY 1 WITH NO DATA; /* Create two policies on mat_m1 */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval) AS agg_m1_job_1 \gset SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval) AS agg_m1_job_2 \gset /* Create single policy on mat_m2 */ SELECT add_continuous_aggregate_policy('mat_m2', NULL, NULL, '12 h'::interval) AS agg_m2_job \gset /* Cleanup any existing data */ TRUNCATE mat_m1; TRUNCATE mat_m2; /* Refresh both continuous aggs immediately */ CALL run_job(:agg_m1_job_1); CALL run_job(:agg_m1_job_2); CALL run_job(:agg_m2_job); /* Compare both outputs */ SELECT count(*) AS exp_row_count from mat_m1 \gset SELECT count(*) AS actual_row_count from ( SELECT * from mat_m1 UNION SELECT * from mat_m2) AS union_q \gset /* Row counts should be the same */ SELECT :exp_row_count = :actual_row_count, :exp_row_count, :actual_row_count; ?column? | ?column? | ?column? ----------+----------+---------- t | 152 | 152 SELECT * from mat_m2 EXCEPT SELECT * from mat_m1; time | counta | sum ------+--------+----- SELECT * from mat_m1 EXCEPT SELECT * from mat_m2; time | counta | sum ------+--------+----- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 17 other objects DROP MATERIALIZED VIEW mat_m2; NOTICE: drop cascades to 17 other objects /* Test with variable sized buckets */ CREATE TABLE overlap_test_timestamptz_var ( time timestamptz NOT NULL, a INTEGER, b INTEGER ); SELECT create_hypertable('overlap_test_timestamptz_var', 'time', chunk_time_interval => '1 month'::interval); create_hypertable ------------------------------------------- (7,public,overlap_test_timestamptz_var,t) INSERT INTO overlap_test_timestamptz_var SELECT t, (i % 5), random() * 100 FROM generate_series('2024-01-01T01:01:01+00', '2025-06-01T01:01:01+00', INTERVAL '1 day') t, generate_series(1, 10) i; CREATE MATERIALIZED VIEW mat_m1(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz_var GROUP BY 1 WITH NO DATA; /* Test interval checking when multiple policies are created on the same cagg */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '3 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1067 SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1068 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Creating policies in either order should work */ SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1069 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '3 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1070 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '3 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1071 SELECT add_continuous_aggregate_policy('mat_m1', '2 months'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1072 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Test non-null offsets on both sides too */ SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '6 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1073 SELECT add_continuous_aggregate_policy('mat_m1', '6 months'::interval, '12 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1074 SELECT add_continuous_aggregate_policy('mat_m1', '12 weeks'::interval, '1 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1075 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ /* Check overlap is detected correctly */ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1076 SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1077 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '6 months'::interval, '1 week'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1078 SELECT add_continuous_aggregate_policy('mat_m1', '4 months'::interval, '2 weeks'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '4 months'::interval, '2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1079 SELECT add_continuous_aggregate_policy('mat_m1', '6 months'::interval, '1 week'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1080 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '20 days'::interval, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1081 SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Check behaviour when exact policy is already defined */ \set ON_ERROR_STOP 0 /*if_not_exists=false*/ SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '8 months', '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1082 SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1083 SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval); ERROR: continuous aggregate refresh policy already exists for "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1084 SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); ERROR: continuous aggregate refresh policy already exists for "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /*if_not_exists => true*/ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '8 months', '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1085 SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1086 SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval, if_not_exists => true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1087 SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval, if_not_exists => true); NOTICE: continuous aggregate refresh policy already exists for "mat_m1", skipping add_continuous_aggregate_policy --------------------------------- -1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Mixing different interval units should also work correctly*/ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1088 SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1089 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1090 SELECT add_continuous_aggregate_policy('mat_m1', '8 weeks'::interval, '-7 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1091 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1092 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1093 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1094 SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Check overlap with negative offsets */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1095 SELECT add_continuous_aggregate_policy('mat_m1', '-1 month'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1096 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '-2 weeks'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1097 SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ \set ON_ERROR_STOP 1 /* Test `alter_job` changing the config */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1098 SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1099 /* Alter end offset but don't overlap */ SELECT jsonb_set(:'config', '{end_offset}', '"30 days"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+-------------------------------------------------------------------------+------------+------------------------------------------------------------------+----------------+---------------+----------+-------------------------------------------- 1098 | @ 12 hours | @ 0 | -1 | @ 12 hours | t | {"end_offset": "30 days", "start_offset": null, "mat_hypertable_id": 8} | -infinity | _timescaledb_functions.policy_refresh_continuous_aggregate_check | f | | | Refresh Continuous Aggregate Policy [1098] \set ON_ERROR_STOP 0 /* Alter end offset to overlap with another job*/ SELECT jsonb_set(:'config', '{end_offset}', '"1 week"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" /* Alter end offset to be null */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: refresh interval overlaps with an existing continuous aggregate policy on "mat_m1" /* Alter job to be identical to existing job */ SELECT jsonb_set(:'config', '{start_offset}', '"2 weeks"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); ERROR: continuous aggregate refresh policy already exists for "mat_m1" \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1100 SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1101 /* Alter end offset to null but no overlap */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+---------------------------------------------------------------------------+------------+------------------------------------------------------------------+----------------+---------------+----------+-------------------------------------------- 1100 | @ 12 hours | @ 0 | -1 | @ 12 hours | t | {"end_offset": null, "start_offset": "@ 14 days", "mat_hypertable_id": 8} | -infinity | _timescaledb_functions.policy_refresh_continuous_aggregate_check | f | | | Refresh Continuous Aggregate Policy [1100] SELECT remove_continuous_aggregate_policy('mat_m1'); remove_continuous_aggregate_policy ------------------------------------ CREATE MATERIALIZED VIEW mat_m2(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz_var GROUP BY 1 WITH NO DATA; /* Create two policies on mat_m1 */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval) AS agg_m1_job_1 \gset SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval) AS agg_m1_job_2 \gset /* Create single policy on mat_m2 */ SELECT add_continuous_aggregate_policy('mat_m2', NULL, NULL, '12 h'::interval) AS agg_m2_job \gset /* Cleanup any existing data */ TRUNCATE mat_m1; TRUNCATE mat_m2; /* Refresh both continuous aggs immediately */ CALL run_job(:agg_m1_job_1); CALL run_job(:agg_m1_job_2); CALL run_job(:agg_m2_job); /* Compare both outputs */ SELECT count(*) AS exp_row_count from mat_m1 \gset SELECT count(*) AS actual_row_count from ( SELECT * from mat_m1 UNION SELECT * from mat_m2) AS union_q \gset /* Row counts should be the same */ SELECT :exp_row_count = :actual_row_count, :exp_row_count, :actual_row_count; ?column? | ?column? | ?column? ----------+----------+---------- t | 18 | 18 SELECT * from mat_m2 EXCEPT SELECT * from mat_m1; time | counta | sum ------+--------+----- SELECT * from mat_m1 EXCEPT SELECT * from mat_m2; time | counta | sum ------+--------+----- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 3 other objects DROP MATERIALIZED VIEW mat_m2; NOTICE: drop cascades to 3 other objects /* Concurrent policies aren't allowed on hierarchical continuous aggs */ CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, count(a) AS counta, sum(b) AS sumb FROM overlap_test_timestamptz GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1_rollup WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', bucket) AS bucket, sum(counta) AS counta, sum(sumb) AS sumb FROM mat_m1 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1_rollup', NULL, '30 days'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1105 \set ON_ERROR_STOP 0 -- Multiple policies on hierarchical cagg should not be allowed SELECT add_continuous_aggregate_policy('mat_m1_rollup', '29 days'::interval, NULL, '12 h'::interval); ERROR: multiple refresh policies are not supported for hierarchical continuous aggregates \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_policy_incremental.out������������������������������������0000664�0000000�0000000�00000120164�15100345067�0025033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Create a user with specific timezone and mock time CREATE ROLE test_cagg_refresh_policy_user WITH LOGIN; ALTER ROLE test_cagg_refresh_policy_user SET timezone TO 'UTC'; ALTER ROLE test_cagg_refresh_policy_user SET timescaledb.current_timestamp_mock TO '2025-03-11 00:00:00+00'; GRANT ALL ON SCHEMA public TO test_cagg_refresh_policy_user; \c :TEST_DBNAME test_cagg_refresh_policy_user CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- CREATE TABLE conditions ( time TIMESTAMP WITH TIME ZONE NOT NULL, device_id INTEGER, temperature NUMERIC ); SELECT FROM create_hypertable('conditions', by_range('time')); -- INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2025-02-05 00:00:00+00', '2025-03-05 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time), device_id, count(*), min(temperature), max(temperature), avg(temperature), sum(temperature) FROM conditions GROUP BY 1, 2 WITH NO DATA; SELECT add_continuous_aggregate_policy( 'conditions_by_day', start_offset => NULL, end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 10 ) AS job_id \gset SELECT config FROM timescaledb_information.jobs WHERE job_id = :'job_id' \gset SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Registered new background worker 2 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sat Mar 01 00:00:00 2025 UTC, Thu Mar 06 00:00:00 2025 UTC ] (batch 1 of 4) 1 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Wed Feb 19 00:00:00 2025 UTC, Sat Mar 01 00:00:00 2025 UTC ] (batch 2 of 4) 4 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sun Feb 09 00:00:00 2025 UTC, Wed Feb 19 00:00:00 2025 UTC ] (batch 3 of 4) 7 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 9 | 0 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Mon Nov 24 00:00:00 4714 UTC BC, Sun Feb 09 00:00:00 2025 UTC ] (batch 4 of 4) 10 | 0 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 11 | 0 | Refresh Continuous Aggregate Policy [1000] | inserted 20 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" CREATE MATERIALIZED VIEW conditions_by_day_manual_refresh WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time), device_id, count(*), min(temperature), max(temperature), avg(temperature), sum(temperature) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_day_manual_refresh', NULL, NULL); SELECT count(*) FROM conditions_by_day; count ------- 145 SELECT count(*) FROM conditions_by_day_manual_refresh; count ------- 145 -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; has_diff ---------- f TRUNCATE bgw_log, conditions_by_day; SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{max_batches_per_execution}', '2') ); config ----------------------------------------------------------------------------------------------------------------------------- {"end_offset": null, "start_offset": null, "buckets_per_batch": 10, "mat_hypertable_id": 2, "max_batches_per_execution": 2} -- advance time by 1h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+------------+--------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 3600000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 3600000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sat Mar 01 00:00:00 2025 UTC, Thu Mar 06 00:00:00 2025 UTC ] (batch 1 of 4) 1 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Wed Feb 19 00:00:00 2025 UTC, Sat Mar 01 00:00:00 2025 UTC ] (batch 2 of 4) 4 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | reached maximum number of batches per execution (2), batches not processed (2) SELECT count(*) FROM conditions_by_day; count ------- 75 SELECT count(*) FROM conditions_by_day_manual_refresh; count ------- 145 -- Should have differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; has_diff ---------- t -- advance time by 2h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '2 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+------------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 3600000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 3600000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sat Mar 01 00:00:00 2025 UTC, Thu Mar 06 00:00:00 2025 UTC ] (batch 1 of 4) 1 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Wed Feb 19 00:00:00 2025 UTC, Sat Mar 01 00:00:00 2025 UTC ] (batch 2 of 4) 4 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 3600000000 | Refresh Continuous Aggregate Policy [1000] | reached maximum number of batches per execution (2), batches not processed (2) 0 | 7200000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 7200000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 7200000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sun Feb 09 00:00:00 2025 UTC, Wed Feb 19 00:00:00 2025 UTC ] (batch 1 of 2) 1 | 7200000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 7200000000 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 7200000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Mon Nov 24 00:00:00 4714 UTC BC, Sun Feb 09 00:00:00 2025 UTC ] (batch 2 of 2) 4 | 7200000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 7200000000 | Refresh Continuous Aggregate Policy [1000] | inserted 20 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; has_diff ---------- f -- Set max_batches_per_execution to 10 SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{max_batches_per_execution}', '10') ); config ------------------------------------------------------------------------------------------------------------------------------ {"end_offset": null, "start_offset": null, "buckets_per_batch": 10, "mat_hypertable_id": 2, "max_batches_per_execution": 10} TRUNCATE bgw_log; -- Insert data into the past INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2020-02-05 00:00:00+00', '2020-03-05 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; -- advance time by 3h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '3 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- -- Should process all four batches in the past SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 10800000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 10800000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sat Feb 29 00:00:00 2020 UTC, Fri Mar 06 00:00:00 2020 UTC ] (batch 1 of 4) 1 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | inserted 30 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Wed Feb 19 00:00:00 2020 UTC, Sat Feb 29 00:00:00 2020 UTC ] (batch 2 of 4) 4 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sun Feb 09 00:00:00 2020 UTC, Wed Feb 19 00:00:00 2020 UTC ] (batch 3 of 4) 7 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | inserted 50 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 9 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Wed Feb 05 00:00:00 2020 UTC, Sun Feb 09 00:00:00 2020 UTC ] (batch 4 of 4) 10 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 11 | 10800000000 | Refresh Continuous Aggregate Policy [1000] | inserted 20 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" SELECT count(*) FROM conditions_by_day; count ------- 295 SELECT count(*) FROM conditions_by_day_manual_refresh; count ------- 145 CALL refresh_continuous_aggregate('conditions_by_day_manual_refresh', NULL, NULL); SELECT count(*) FROM conditions_by_day; count ------- 295 SELECT count(*) FROM conditions_by_day_manual_refresh; count ------- 295 -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; has_diff ---------- f -- Check invalid configurations \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{max_batches_per_execution}', '-1') ); ERROR: invalid max batches per execution DETAIL: max_batches_per_execution: -1 HINT: The max batches per execution should be greater than or equal to zero. SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{buckets_per_batch}', '-1') ); ERROR: invalid buckets per batch DETAIL: buckets_per_batch: -1 HINT: The buckets per batch should be greater than or equal to zero. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Truncate all data from the original hypertable TRUNCATE bgw_log, conditions; -- advance time by 4h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '4 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- -- Should fallback to single batch processing because there's no data to be refreshed on the original hypertable SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 14400000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 14400000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 14400000000 | Refresh Continuous Aggregate Policy [1000] | no min slice range start for continuous aggregate "public.conditions_by_day", falling back to single batch processing 1 | 14400000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Mon Nov 24 00:00:00 4714 UTC BC, Thu Mar 06 00:00:00 2025 UTC ] 2 | 14400000000 | Refresh Continuous Aggregate Policy [1000] | deleted 295 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 14400000000 | Refresh Continuous Aggregate Policy [1000] | inserted 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" -- Should return zero rows SELECT count(*) FROM conditions_by_day; count ------- 0 -- 1 day of data INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2020-02-05 00:00:00+00', '2020-02-06 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; TRUNCATE bgw_log; -- advance time by 5h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '5 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- -- Should fallback to single batch processing because the refresh size is too small SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 18000000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 18000000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 18000000000 | Refresh Continuous Aggregate Policy [1000] | only one batch produced for continuous aggregate "public.conditions_by_day", falling back to single batch processing 1 | 18000000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Wed Feb 05 00:00:00 2020 UTC, Fri Feb 07 00:00:00 2020 UTC ] 2 | 18000000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 18000000000 | Refresh Continuous Aggregate Policy [1000] | inserted 10 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" -- Should return 10 rows because the bucket width is `1 day` and buckets per batch is `10` SELECT count(*) FROM conditions_by_day; count ------- 10 TRUNCATE conditions_by_day, conditions, bgw_log; -- Less than 1 day of data (smaller than the bucket width) INSERT INTO conditions VALUES ('2020-02-05 00:00:00+00', 1, 10); -- advance time by 6h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '6 hour')::bigint * 1000000, true); ts_bgw_params_reset_time -------------------------- -- Should fallback to single batch processing because the refresh size is too small SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-------------+--------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 21600000000 | DB Scheduler | [TESTING] Registered new background worker 1 | 21600000000 | DB Scheduler | [TESTING] Registered new background worker 2 | 21600000000 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 21600000000 | Refresh Continuous Aggregate Policy [1000] | refresh window size (7 days) is smaller than or equal to batch size (10 days), falling back to single batch processing 1 | 21600000000 | Refresh Continuous Aggregate Policy [1000] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Mon Nov 24 00:00:00 4714 UTC BC, Thu Mar 06 00:00:00 2025 UTC ] 2 | 21600000000 | Refresh Continuous Aggregate Policy [1000] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 21600000000 | Refresh Continuous Aggregate Policy [1000] | inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" -- Should return 1 row SELECT count(*) FROM conditions_by_day; count ------- 1 SELECT delete_job(:job_id); delete_job ------------ SELECT add_continuous_aggregate_policy( 'conditions_by_day', start_offset => INTERVAL '15 days', end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 5, refresh_newest_first => true -- explicitly set to true to test the default behavior ) AS job_id \gset SELECT add_continuous_aggregate_policy( 'conditions_by_day_manual_refresh', start_offset => INTERVAL '15 days', end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 0 -- 0 means no batching, so it will refresh all buckets in one go ) AS job_id_manual \gset TRUNCATE bgw_log, conditions_by_day, conditions_by_day_manual_refresh, conditions; INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2025-03-11 00:00:00+00'::timestamptz - INTERVAL '30 days', '2025-03-11 00:00:00+00'::timestamptz, '1 hour'::interval) AS t, generate_series(1,5) AS d; SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Registered new background worker 2 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Tue Mar 11 00:00:00 2025 UTC, Wed Mar 12 00:00:00 2025 UTC ] (batch 1 of 4) 1 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 5 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Thu Mar 06 00:00:00 2025 UTC, Tue Mar 11 00:00:00 2025 UTC ] (batch 2 of 4) 4 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sat Mar 01 00:00:00 2025 UTC, Thu Mar 06 00:00:00 2025 UTC ] (batch 3 of 4) 7 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 9 | 0 | Refresh Continuous Aggregate Policy [1001] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Mon Feb 24 00:00:00 2025 UTC, Sat Mar 01 00:00:00 2025 UTC ] (batch 4 of 4) 10 | 0 | Refresh Continuous Aggregate Policy [1001] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 11 | 0 | Refresh Continuous Aggregate Policy [1001] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 0 | 0 | Refresh Continuous Aggregate Policy [1002] | continuous aggregate refresh (individual invalidation) on "conditions_by_day_manual_refresh" in window [ Mon Feb 24 00:00:00 2025 UTC, Wed Mar 12 00:00:00 2025 UTC ] 1 | 0 | Refresh Continuous Aggregate Policy [1002] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_3" 2 | 0 | Refresh Continuous Aggregate Policy [1002] | inserted 80 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_3" -- Both continuous aggregates should have the same data SELECT count(*) FROM conditions_by_day; count ------- 80 SELECT count(*) FROM conditions_by_day_manual_refresh; count ------- 80 -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; has_diff ---------- f -- Testing with explicit refresh_newest_first = false (from oldest to newest) SELECT delete_job(:job_id); delete_job ------------ SELECT delete_job(:job_id_manual); delete_job ------------ SELECT add_continuous_aggregate_policy( 'conditions_by_day', start_offset => INTERVAL '15 days', end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 5, refresh_newest_first => false ) AS job_id \gset SELECT config FROM timescaledb_information.jobs WHERE job_id = :'job_id'; config ---------------------------------------------------------------------------------------------------------------------------------- {"end_offset": null, "start_offset": "@ 15 days", "buckets_per_batch": 5, "mat_hypertable_id": 2, "refresh_newest_first": false} TRUNCATE bgw_log, conditions_by_day; SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Mon Feb 24 00:00:00 2025 UTC, Sat Mar 01 00:00:00 2025 UTC ] (batch 1 of 4) 1 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 2 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 3 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Sat Mar 01 00:00:00 2025 UTC, Thu Mar 06 00:00:00 2025 UTC ] (batch 2 of 4) 4 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 5 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 6 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Thu Mar 06 00:00:00 2025 UTC, Tue Mar 11 00:00:00 2025 UTC ] (batch 3 of 4) 7 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 8 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 25 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" 9 | 0 | Refresh Continuous Aggregate Policy [1003] | continuous aggregate refresh (individual invalidation) on "conditions_by_day" in window [ Tue Mar 11 00:00:00 2025 UTC, Wed Mar 12 00:00:00 2025 UTC ] (batch 4 of 4) 10 | 0 | Refresh Continuous Aggregate Policy [1003] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_2" 11 | 0 | Refresh Continuous Aggregate Policy [1003] | inserted 5 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_2" -- Both continuous aggregates should have the same data SELECT count(*) FROM conditions_by_day; count ------- 80 SELECT count(*) FROM conditions_by_day_manual_refresh; count ------- 80 -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; has_diff ---------- f -- Tests with Variable sized bucket SELECT delete_job(:job_id); delete_job ------------ TRUNCATE conditions; INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2025-01-01 00:00:00+00', '2025-10-08 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; CREATE MATERIALIZED VIEW conditions_by_month WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time), device_id, count(*), min(temperature), max(temperature), avg(temperature), sum(temperature) FROM conditions GROUP BY 1, 2 WITH NO DATA; SELECT add_continuous_aggregate_policy( 'conditions_by_month', start_offset => INTERVAL '600 days', end_offset => INTERVAL '7 days', schedule_interval => INTERVAL '1 day', refresh_newest_first => false ) AS job_id \gset SELECT config FROM timescaledb_information.jobs WHERE job_id = :'job_id'; config ----------------------------------------------------------------------------------------------------------------- {"end_offset": "@ 7 days", "start_offset": "@ 600 days", "mat_hypertable_id": 4, "refresh_newest_first": false} TRUNCATE bgw_log, conditions_by_day; SELECT ts_bgw_params_reset_time(0, true); ts_bgw_params_reset_time -------------------------- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT * FROM sorted_bgw_log; msg_no | mock_time | application_name | msg --------+-----------+--------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | 0 | DB Scheduler | [TESTING] Registered new background worker 1 | 0 | DB Scheduler | [TESTING] Wait until (RANDOM), started at (RANDOM) 0 | 0 | Refresh Continuous Aggregate Policy [1004] | continuous aggregate refresh (individual invalidation) on "conditions_by_month" in window [ Mon Dec 23 00:00:00 2024 UTC, Wed Jan 22 00:00:00 2025 UTC ] (batch 1 of 3) 1 | 0 | Refresh Continuous Aggregate Policy [1004] | deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_4" 2 | 0 | Refresh Continuous Aggregate Policy [1004] | inserted 5 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_4" 3 | 0 | Refresh Continuous Aggregate Policy [1004] | continuous aggregate refresh (individual invalidation) on "conditions_by_month" in window [ Wed Jan 22 00:00:00 2025 UTC, Fri Feb 21 00:00:00 2025 UTC ] (batch 2 of 3) 4 | 0 | Refresh Continuous Aggregate Policy [1004] | deleted 5 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_4" 5 | 0 | Refresh Continuous Aggregate Policy [1004] | inserted 10 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_4" 6 | 0 | Refresh Continuous Aggregate Policy [1004] | continuous aggregate refresh (individual invalidation) on "conditions_by_month" in window [ Fri Feb 21 00:00:00 2025 UTC, Sat Mar 01 00:00:00 2025 UTC ] (batch 3 of 3) 7 | 0 | Refresh Continuous Aggregate Policy [1004] | deleted 5 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_4" 8 | 0 | Refresh Continuous Aggregate Policy [1004] | inserted 5 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_4" \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER REASSIGN OWNED BY test_cagg_refresh_policy_user TO :ROLE_CLUSTER_SUPERUSER; REVOKE ALL ON SCHEMA public FROM test_cagg_refresh_policy_user; DROP ROLE test_cagg_refresh_policy_user; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_policy_move.out�������������������������������������������0000664�0000000�0000000�00000037125�15100345067�0023504�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE VIEW hypertable_invalidation_thresholds AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1; CREATE VIEW hypertable_invalidations AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, hypertable_id, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1, 2, 3; CREATE FUNCTION get_job_id_for(REGCLASS) RETURNS INTEGER AS $$ SELECT DISTINCT job.id AS job_id FROM _timescaledb_catalog.hypertable AS ht JOIN _timescaledb_config.bgw_job AS job ON hypertable_id = ht.id WHERE format('%I.%I', schema_name, table_name)::regclass = $1 $$ LANGUAGE SQL; CREATE TABLE conditions (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 10); create_hypertable ------------------------- (1,public,conditions,t) CREATE TABLE measurements (time int NOT NULL, device int, temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (2,public,measurements,t) CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM measurements $$; SELECT set_integer_now_func('conditions', 'bigint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('measurements', 'int_now'); set_integer_now_func ---------------------- INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; INSERT INTO measurements SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE MATERIALIZED VIEW conditions_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '10', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2; NOTICE: refreshing continuous aggregate "conditions_10" -- Trying to add to a hypertable that does not have any continuous -- aggregates should fail. \set ON_ERROR_STOP 0 CALL add_process_hypertable_invalidations_policy('measurements', schedule_interval => '1 minute'::interval); ERROR: "measurements" does not have an associated continuous aggregate \set ON_ERROR_STOP 1 CREATE MATERIALIZED VIEW measure_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, device, avg(temp) AS avg_temp FROM measurements GROUP BY 1,2; NOTICE: refreshing continuous aggregate "measure_10" CALL add_process_hypertable_invalidations_policy('measurements', schedule_interval => '1 minute'::interval); -- Check thresholds to make sure that what we're writing below is not -- after the threshold. SELECT * FROM hypertable_invalidation_thresholds; hypertable | threshold --------------+----------- conditions | 110 measurements | 110 INSERT INTO conditions VALUES (10, 4, 23.7); INSERT INTO conditions VALUES (10, 5, 23.8), (19, 3, 23.6); INSERT INTO conditions VALUES (60, 3, 23.7), (70, 4, 23.7); INSERT INTO measurements VALUES (20, 4, 23.7); INSERT INTO measurements VALUES (30, 5, 23.8), (80, 3, 23.6); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- conditions | 10 | 10 conditions | 10 | 19 conditions | 60 | 70 measurements | 20 | 20 measurements | 30 | 80 \set ON_ERROR_STOP 0 CALL add_process_hypertable_invalidations_policy('conditions_10', schedule_interval => '1 minute'::interval); ERROR: table "conditions_10" is not a hypertable CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, timezone => 'QQQ'); ERROR: time zone "QQQ" not recognized \set ON_ERROR_STOP 1 CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, initial_start => 'epoch'::timestamptz + '9223371331200000000'::bigint * '1 microsecond'::interval ); -- This should error out and print notice, respectively \set ON_ERROR_STOP 0 CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, if_not_exists => false); ERROR: move hypertable invalidations policy already exists for "conditions" CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, if_not_exists => true); NOTICE: move hypertable invalidations policy already exists for "conditions", skipping \set ON_ERROR_STOP 1 \x on SELECT application_name, owner, format('%I.%I', proc_schema, proc_name), schedule_interval, fixed_schedule, initial_start, next_start, -- to check initial start hypertable_id, config FROM _timescaledb_config.bgw_job LEFT JOIN _timescaledb_internal.bgw_job_stat ON id = job_id WHERE application_name LIKE '%Move Hypertables Invalidation Policy%'; -[ RECORD 1 ]-----+--------------------------------------------------------------- application_name | Move Hypertables Invalidation Policy [1000] owner | default_perm_user format | _timescaledb_functions.policy_process_hypertable_invalidations schedule_interval | @ 1 min fixed_schedule | f initial_start | next_start | hypertable_id | 2 config | {"hypertable_id": 2} -[ RECORD 2 ]-----+--------------------------------------------------------------- application_name | Move Hypertables Invalidation Policy [1001] owner | default_perm_user format | _timescaledb_functions.policy_process_hypertable_invalidations schedule_interval | @ 1 min fixed_schedule | t initial_start | Fri Jan 01 16:00:00 294247 PST next_start | Fri Jan 01 16:00:00 294247 PST hypertable_id | 1 config | {"hypertable_id": 1} \x off -- Get a job id and a valid configuration for testing below. SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE application_name LIKE '%Move Hypertables Invalidation Policy%' AND hypertable_id = 1 \gset -- Test that the check function capture a bad configurations. \set ON_ERROR_STOP 0 SELECT alter_job(:job_id, config => '{"hyper_id": 1}'); ERROR: could not find hypertable_id in config for job -- Picking something really out of bounds to check that it triggers if -- hypertable do not exist. SELECT alter_job(:job_id, config => '{"hypertable_id": 4711}'); ERROR: configuration hypertable id 4711 not found SELECT alter_job(:job_id, config => '{"hypertable_id": "garbage"}'); ERROR: invalid input syntax for type integer: "garbage" \set ON_ERROR_STOP 1 -- This is just resetting the config to the same, but is used to get -- coverage for the "good path" in the check function. \x on SELECT * FROM alter_job(:job_id, config => :'config'); -[ RECORD 1 ]-----+--------------------------------------------------------------------- job_id | 1001 schedule_interval | @ 1 min max_runtime | @ 0 max_retries | -1 retry_period | @ 1 min scheduled | t config | {"hypertable_id": 1} next_start | Fri Jan 01 16:00:00 294247 PST check_config | _timescaledb_functions.policy_process_hypertable_invalidations_check fixed_schedule | t initial_start | Fri Jan 01 16:00:00 294247 PST timezone | application_name | Move Hypertables Invalidation Policy [1001] \x off -- Test to run the job and check that hypertable invalidations are -- processed. SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- conditions | 10 | 10 conditions | 10 | 19 conditions | 60 | 70 measurements | 20 | 20 measurements | 30 | 80 CALL run_job(get_job_id_for('conditions')); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 20 | 20 measurements | 30 | 80 -- Running it twice should work and not change anything. CALL run_job(get_job_id_for('conditions')); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 20 | 20 measurements | 30 | 80 CALL run_job(get_job_id_for('measurements')); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value ------------+-----------------------+------------------------- \set ON_ERROR_STOP 0 CALL _timescaledb_functions.policy_process_hypertable_invalidations(NULL, NULL); CALL _timescaledb_functions.policy_process_hypertable_invalidations(1, NULL); CALL _timescaledb_functions.policy_process_hypertable_invalidations(NULL, :'config'); \set ON_ERROR_STOP 1 -- Check that a refresh with hypertable invalidation processing -- disabled does not move the invalidations. INSERT INTO measurements VALUES (40, 12, 12.3); INSERT INTO measurements VALUES (50, 13, 34.5); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 40 | 40 measurements | 50 | 50 CALL refresh_continuous_aggregate('measure_10', NULL, NULL, options => '{"process_hypertable_invalidations": false}'); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 40 | 40 measurements | 50 | 50 -- Check that a refresh with hypertable invalidation processing -- enabled move the invalidations. CALL refresh_continuous_aggregate('measure_10', NULL, NULL, options => '{"process_hypertable_invalidations": true}'); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value ------------+-----------------------+------------------------- -- Check that a refresh by default moves the invalidations. INSERT INTO measurements VALUES (60, 16, 12.3); INSERT INTO measurements VALUES (61, 17, 34.5); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 60 | 60 measurements | 61 | 61 CALL refresh_continuous_aggregate('measure_10', NULL, NULL); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value ------------+-----------------------+------------------------- -- Check permissions. Only owner should be able to remove policy. \set ON_ERROR_STOP 0 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CALL remove_process_hypertable_invalidations_policy('conditions'); ERROR: must be owner of hypertable "conditions" \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CALL remove_process_hypertable_invalidations_policy('conditions'); \set ON_ERROR_STOP 0 CALL remove_process_hypertable_invalidations_policy('conditions_10'); ERROR: table "conditions_10" is not a hypertable CALL remove_process_hypertable_invalidations_policy('conditions', if_exists => false); ERROR: move invalidations policy for "conditions" not found CALL remove_process_hypertable_invalidations_policy('conditions', if_exists => true); NOTICE: move invalidations policy for "conditions" not found, skipping \set ON_ERROR_STOP 1 -- Add a policy that has hypertable invalidations processing disabled -- and check that it does not move invalidations. SELECT add_continuous_aggregate_policy('measure_10', 100::int, 10::int, '1h'::interval) as job_id \gset SELECT jsonb_set(config, '{process_hypertable_invalidations}', 'false') AS config FROM _timescaledb_config.bgw_job WHERE id = :job_id \gset SELECT jsonb_pretty(config) FROM alter_job(:job_id, config := :'config'); jsonb_pretty ----------------------------------------------- { + "end_offset": 10, + "start_offset": 100, + "mat_hypertable_id": 4, + "process_hypertable_invalidations": false+ } INSERT INTO measurements VALUES (70, 19, 12.3), (71, 20, 34.5); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 70 | 71 CALL run_job(:job_id); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value --------------+-----------------------+------------------------- measurements | 70 | 71 -- Enable invalidations and check that it now moves invalidations SELECT jsonb_pretty(config) FROM alter_job(:job_id, config := jsonb_set(:'config', '{process_hypertable_invalidations}', 'true')); jsonb_pretty ---------------------------------------------- { + "end_offset": 10, + "start_offset": 100, + "mat_hypertable_id": 4, + "process_hypertable_invalidations": true+ } CALL run_job(:job_id); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; hypertable | lowest_modified_value | greatest_modified_value ------------+-----------------------+------------------------- �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_policy_run.out��������������������������������������������0000664�0000000�0000000�00000006005�15100345067�0023333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- The tests in this file use mock timestamps to test policies -- for timestamp based tables and can be run only with debug builds. SET ROLE :ROLE_DEFAULT_PERM_USER; --- code coverage tests : add policy for timestamp and date based table --- CREATE TABLE continuous_agg_max_mat_date(time DATE); SELECT create_hypertable('continuous_agg_max_mat_date', 'time'); create_hypertable ------------------------------------------ (1,public,continuous_agg_max_mat_date,t) CREATE MATERIALIZED VIEW max_mat_view_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 days', time), count(*) FROM continuous_agg_max_mat_date GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('max_mat_view_date', '3 days', '1 day', '1 day'::interval) as job_id \gset SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; config ------------------------------------------------------------------------------- {"end_offset": "@ 1 day", "start_offset": "@ 3 days", "mat_hypertable_id": 2} INSERT INTO continuous_agg_max_mat_date SELECT generate_series('2019-09-01'::date, '2019-09-10'::date, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; SET timescaledb.current_timestamp_mock = '2019-09-10 00:00'; CALL run_job(:job_id); SELECT * FROM max_mat_view_date order by 1; time_bucket | count -------------+------- 09-07-2019 | 1 09-08-2019 | 1 RESET client_min_messages ; DROP MATERIALIZED VIEW max_mat_view_date; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_3_chunk CREATE TABLE continuous_agg_timestamp(time TIMESTAMP); SELECT create_hypertable('continuous_agg_timestamp', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------------------- (3,public,continuous_agg_timestamp,t) CREATE MATERIALIZED VIEW max_mat_view_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time), count(*) FROM continuous_agg_timestamp GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 days', '1 h'::interval , '1 h'::interval) as job_id \gset INSERT INTO continuous_agg_timestamp SELECT generate_series('2019-09-01 00:00'::timestamp, '2019-09-10 00:00'::timestamp, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; SET timescaledb.current_timestamp_mock = '2019-09-11 00:00'; CALL run_job(:job_id); SELECT * FROM max_mat_view_timestamp; time_bucket | count --------------------------+------- Mon Sep 02 00:00:00 2019 | 7 RESET client_min_messages ; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query-15.out����������������������������������������������0000664�0000000�0000000�00000435214�15100345067�0022550�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; \set TEST_BASE_NAME cagg_query \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_38" psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query-16.out����������������������������������������������0000664�0000000�0000000�00000434124�15100345067�0022550�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; \set TEST_BASE_NAME cagg_query \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_38" psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query-17.out����������������������������������������������0000664�0000000�0000000�00000434124�15100345067�0022551�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; \set TEST_BASE_NAME cagg_query \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_38" psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query-18.out����������������������������������������������0000664�0000000�0000000�00000434124�15100345067�0022552�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; \set TEST_BASE_NAME cagg_query \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_38" psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query_using_merge-15.out����������������������������������0000664�0000000�0000000�00000433224�15100345067�0025133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; \set TEST_BASE_NAME cagg_query_using_merge \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query_using_merge-16.out����������������������������������0000664�0000000�0000000�00000432134�15100345067�0025133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; \set TEST_BASE_NAME cagg_query_using_merge \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query_using_merge-17.out����������������������������������0000664�0000000�0000000�00000432134�15100345067�0025134�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; \set TEST_BASE_NAME cagg_query_using_merge \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_query_using_merge-18.out����������������������������������0000664�0000000�0000000�00000432134�15100345067�0025135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; \set TEST_BASE_NAME cagg_query_using_merge \ir include/cagg_query_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; time_bucket ------------------------------ Sat Nov 03 17:00:00 2018 PDT CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.sumh, _materialized_hypertable_2.sumt, _materialized_hypertable_2.minl, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from regview order by timec desc; --- QUERY PLAN --- Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: (time_bucket('@ 1 day'::interval, conditions.timec)) DESC -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec desc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec DESC -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 order by location, timec asc; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.location, _materialized_hypertable_2.timec -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; --- QUERY PLAN --- Sort Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: l.locid, _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Hash Cond: (l.locname = _hyper_2_4_chunk.location) -> Seq Scan on public.location_tab l Output: l.locid, l.locname -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; --- QUERY PLAN --- Append -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) DESC, _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --- QUERY PLAN --- Limit Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp -> Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC, _hyper_3_6_chunk.location NULLS FIRST -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; --- QUERY PLAN --- Sort Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Sort Key: _hyper_3_6_chunk.timec DESC -> Append -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: ((_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_3_6_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: ((_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, _materialized_hypertable_3.location, _materialized_hypertable_3.timec, _materialized_hypertable_3.firsth, _materialized_hypertable_3.lasth, _materialized_hypertable_3.maxtemp, _materialized_hypertable_3.mintemp Hash Cond: (_materialized_hypertable_3.timec = _hyper_2_4_chunk.timec) -> Append -> Append -> Index Scan using _hyper_3_5_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.location, _hyper_3_5_chunk.timec, _hyper_3_5_chunk.firsth, _hyper_3_5_chunk.lasth, _hyper_3_5_chunk.maxtemp, _hyper_3_5_chunk.mintemp Index Cond: (_hyper_3_5_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_3_6_chunk__materialized_hypertable_3_timec_idx on _timescaledb_internal._hyper_3_6_chunk Output: _hyper_3_6_chunk.location, _hyper_3_6_chunk.timec, _hyper_3_6_chunk.firsth, _hyper_3_6_chunk.lasth, _hyper_3_6_chunk.maxtemp, _hyper_3_6_chunk.mintemp Index Cond: (_hyper_3_6_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), first(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), last(_hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec), max(_hyper_1_2_chunk.temperature), min(_hyper_1_2_chunk.temperature) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.humidity, _hyper_1_2_chunk.temperature Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; --- QUERY PLAN --- Sort Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Sort Key: _hyper_2_4_chunk.timec DESC -> Hash Join Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh, conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (min(conditions.location)), (sum(conditions.temperature)), (sum(conditions.humidity)) Hash Cond: ((time_bucket('@ 1 day'::interval, conditions.timec)) = _hyper_2_4_chunk.timec) -> Finalize GroupAggregate Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), min(conditions.location), sum(conditions.temperature), sum(conditions.humidity) Group Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Sort Output: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)), (PARTIAL min(conditions.location)), (PARTIAL sum(conditions.temperature)), (PARTIAL sum(conditions.humidity)) Sort Key: conditions.location, (time_bucket('@ 1 day'::interval, conditions.timec)) -> Append -> Partial GroupAggregate Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), PARTIAL min(_hyper_1_1_chunk.location), PARTIAL sum(_hyper_1_1_chunk.temperature), PARTIAL sum(_hyper_1_1_chunk.humidity) Group Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Sort Output: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity Sort Key: _hyper_1_1_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_1_chunk.timec), _hyper_1_1_chunk.temperature, _hyper_1_1_chunk.humidity -> Partial GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), PARTIAL min(_hyper_1_2_chunk.location), PARTIAL sum(_hyper_1_2_chunk.temperature), PARTIAL sum(_hyper_1_2_chunk.humidity) Group Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Hash Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh -> Append -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: ((_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_2_4_chunk.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) -> GroupAggregate Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), min(_hyper_1_2_chunk_1.location), sum(_hyper_1_2_chunk_1.temperature), sum(_hyper_1_2_chunk_1.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Sort Output: _hyper_1_2_chunk_1.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec)), _hyper_1_2_chunk_1.location -> Result Output: _hyper_1_2_chunk_1.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec), _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk _hyper_1_2_chunk_1 Output: _hyper_1_2_chunk_1.location, _hyper_1_2_chunk_1.timec, _hyper_1_2_chunk_1.temperature, _hyper_1_2_chunk_1.humidity Index Cond: ((_hyper_1_2_chunk_1.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) AND (_hyper_1_2_chunk_1.timec > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk_1.timec) > 'Mon Oct 01 00:00:00 2018 PDT'::timestamp with time zone) select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; locid | location | timec | minl | sumt | sumh -------+----------+------------------------------+------+------+------ 2 | NYC | Fri Nov 02 17:00:00 2018 PDT | NYC | | 2 | NYC | Thu Nov 01 17:00:00 2018 PDT | NYC | 30 | 25 2 | NYC | Wed Oct 31 17:00:00 2018 PDT | NYC | 325 | 200 \set ECHO none ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; --- QUERY PLAN --- Sort Output: _materialized_hypertable_2.location, _materialized_hypertable_2.timec, _materialized_hypertable_2.minl, _materialized_hypertable_2.sumt, _materialized_hypertable_2.sumh Sort Key: _materialized_hypertable_2.timec DESC, _materialized_hypertable_2.location -> Append -> Append -> Index Scan using _hyper_2_3_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_3_chunk Output: _hyper_2_3_chunk.location, _hyper_2_3_chunk.timec, _hyper_2_3_chunk.minl, _hyper_2_3_chunk.sumt, _hyper_2_3_chunk.sumh Index Cond: (_hyper_2_3_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> Index Scan using _hyper_2_4_chunk__materialized_hypertable_2_timec_idx on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.location, _hyper_2_4_chunk.timec, _hyper_2_4_chunk.minl, _hyper_2_4_chunk.sumt, _hyper_2_4_chunk.sumh Index Cond: (_hyper_2_4_chunk.timec < 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) -> GroupAggregate Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), min(_hyper_1_2_chunk.location), sum(_hyper_1_2_chunk.temperature), sum(_hyper_1_2_chunk.humidity) Group Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Sort Output: _hyper_1_2_chunk.location, (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec)), _hyper_1_2_chunk.location -> Result Output: _hyper_1_2_chunk.location, time_bucket('@ 1 day'::interval, _hyper_1_2_chunk.timec), _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity -> Index Scan using _hyper_1_2_chunk_conditions_timec_idx on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.location, _hyper_1_2_chunk.timec, _hyper_1_2_chunk.temperature, _hyper_1_2_chunk.humidity Index Cond: (_hyper_1_2_chunk.timec >= 'Sat Nov 03 17:00:00 2018 PDT'::timestamp with time zone) ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh ----------+------------------------------+------+------ NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 NYC | Fri Nov 02 17:00:00 2018 PDT | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; max ------------------------------ Fri Nov 02 17:00:00 2018 PDT -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST _hyper_2_4_chunk | Wed Sep 05 17:00:00 2018 PDT | Wed Nov 14 16:00:00 2018 PST SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_2_3_chunk | Wed Nov 29 16:00:00 2017 PST | Wed Feb 07 16:00:00 2018 PST -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); to_timestamp ------------------------------ Tue Jan 02 16:00:00 2018 PST -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; to_timestamp ------------------------------ Sat Nov 03 17:00:00 2018 PDT -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; max ------------------------------ Mon Jan 01 16:00:00 2018 PST -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Sun Dec 02 16:00:00 2018 PST | 110 | 75 | 45 | 30 | 65 | 45 NYC | Fri Nov 02 17:00:00 2018 PDT | | | | | | NYC | Thu Nov 01 17:00:00 2018 PDT | 30 | 25 | 10 | | 20 | 10 NYC | Wed Oct 31 17:00:00 2018 PDT | 325 | 200 | 30 | 50 | 85 | 45 NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 02 16:00:00 2018 PST | 120 | 90 | 45 | 45 | 65 | 55 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; location | timec | sumt | sumh | firsth | lasth | maxtemp | mintemp ----------+------------------------------+------+------+--------+-------+---------+--------- NYC | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Mon Jan 01 16:00:00 2018 PST | 65 | 45 | 45 | 45 | 65 | 65 SFO | Sun Dec 31 16:00:00 2017 PST | 55 | 45 | 45 | 45 | 55 | 55 por | Mon Jan 01 16:00:00 2018 PST | 100 | 100 | 100 | 100 | 100 | 100 | | | | 10 | | 20 | 10 | | | | 30 | 50 | 85 | 45 | | | | 45 | 30 | 65 | 45 | | | | 45 | 45 | 65 | 55 | | | | | | | ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); create_hypertable -------------------------- (4,public,temperature,t) INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); psql:include/cagg_query_common.sql:316: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------- (5,public,temperature_wo_tz,t) INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); create_hypertable ------------------------------- (6,public,temperature_date,t) INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); create_hypertable ----------------------------- (7,public,table_smallint,t) SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); create_hypertable ------------------------ (8,public,table_int,t) SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); create_hypertable --------------------------- (9,public,table_bigint,t) CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_int', 'integer_now_int'); set_integer_now_func ---------------------- SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); set_integer_now_func ---------------------- INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:372: NOTICE: refreshing continuous aggregate "cagg_4_hours" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours | public.time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t DROP MATERIALIZED VIEW cagg_4_hours; psql:include/cagg_query_common.sql:374: NOTICE: drop cascades to table _timescaledb_internal._hyper_10_14_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:380: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset; psql:include/cagg_query_common.sql:382: NOTICE: drop cascades to table _timescaledb_internal._hyper_11_15_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:388: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset2 | public.time_bucket(interval,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset2; psql:include/cagg_query_common.sql:390: NOTICE: drop cascades to table _timescaledb_internal._hyper_12_16_chunk -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:397: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | | @ 30 mins | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; psql:include/cagg_query_common.sql:399: NOTICE: drop cascades to table _timescaledb_internal._hyper_13_17_chunk CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:405: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin; psql:include/cagg_query_common.sql:407: NOTICE: drop cascades to table _timescaledb_internal._hyper_14_18_chunk -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:414: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin2 | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin2; psql:include/cagg_query_common.sql:416: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_19_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:423: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; psql:include/cagg_query_common.sql:425: NOTICE: drop cascades to table _timescaledb_internal._hyper_16_20_chunk -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:432: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 4 hours | Sat Jan 01 01:00:00 2000 PST | | UTC | f DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; psql:include/cagg_query_common.sql:434: NOTICE: drop cascades to table _timescaledb_internal._hyper_17_21_chunk -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:441: NOTICE: refreshing continuous aggregate "cagg_4_hours_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+----------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_wo_tz | public.time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:448: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; psql:include/cagg_query_common.sql:450: NOTICE: drop cascades to table _timescaledb_internal._hyper_19_23_chunk -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:457: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin_ts_wo_tz2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------+--------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_origin_ts_wo_tz2 | public.time_bucket(interval,timestamp without time zone,timestamp without time zone) | @ 4 hours | Fri Dec 31 17:00:00 1999 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; psql:include/cagg_query_common.sql:459: NOTICE: drop cascades to table _timescaledb_internal._hyper_20_24_chunk CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:465: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset_wo_tz" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_offset_wo_tz | public.time_bucket(interval,timestamp without time zone,interval) | @ 4 hours | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; psql:include/cagg_query_common.sql:467: NOTICE: drop cascades to table _timescaledb_internal._hyper_21_25_chunk DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; psql:include/cagg_query_common.sql:468: NOTICE: drop cascades to table _timescaledb_internal._hyper_18_22_chunk -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:475: NOTICE: refreshing continuous aggregate "cagg_4_hours_date" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------+----------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date | public.time_bucket(interval,pg_catalog.date) | @ 4 days | | | | t DROP MATERIALIZED VIEW cagg_4_hours_date; psql:include/cagg_query_common.sql:477: NOTICE: drop cascades to table _timescaledb_internal._hyper_22_26_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:483: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin; psql:include/cagg_query_common.sql:485: NOTICE: drop cascades to table _timescaledb_internal._hyper_23_27_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:491: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------------+--------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_origin2 | public.time_bucket(interval,pg_catalog.date,pg_catalog.date) | @ 4 days | Sat Jan 01 00:00:00 2000 PST | | | t DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; psql:include/cagg_query_common.sql:493: NOTICE: drop cascades to table _timescaledb_internal._hyper_24_28_chunk CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:499: NOTICE: refreshing continuous aggregate "cagg_4_hours_date_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------------+-------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_4_hours_date_offset | public.time_bucket(interval,pg_catalog.date,interval) | @ 4 days | | @ 30 mins | | t DROP MATERIALIZED VIEW cagg_4_hours_date_offset; psql:include/cagg_query_common.sql:501: NOTICE: drop cascades to table _timescaledb_internal._hyper_25_29_chunk -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:508: NOTICE: refreshing continuous aggregate "cagg_smallint" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+---------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint | public.time_bucket(smallint,smallint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_smallint; psql:include/cagg_query_common.sql:510: NOTICE: drop cascades to table _timescaledb_internal._hyper_26_30_chunk CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; psql:include/cagg_query_common.sql:516: NOTICE: refreshing continuous aggregate "cagg_smallint_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------------+------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_smallint_offset | public.time_bucket(smallint,smallint,smallint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_smallint_offset; psql:include/cagg_query_common.sql:518: NOTICE: drop cascades to table _timescaledb_internal._hyper_27_31_chunk CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:524: NOTICE: refreshing continuous aggregate "cagg_int" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int | public.time_bucket(integer,integer) | 2 | | | | t DROP MATERIALIZED VIEW cagg_int; psql:include/cagg_query_common.sql:526: NOTICE: drop cascades to table _timescaledb_internal._hyper_28_32_chunk CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; psql:include/cagg_query_common.sql:532: NOTICE: refreshing continuous aggregate "cagg_int_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-----------------+---------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_int_offset | public.time_bucket(integer,integer,integer) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_int_offset; psql:include/cagg_query_common.sql:534: NOTICE: drop cascades to table _timescaledb_internal._hyper_29_33_chunk CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+----------------+-----------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint | public.time_bucket(bigint,bigint) | 2 | | | | t DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+---------------------+------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_bigint_offset2 | public.time_bucket(bigint,bigint,bigint) | 2 | | 1 | | t -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); psql:include/cagg_query_common.sql:566: ERROR: function "func_does_not_exist()" does not exist ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:580: ERROR: function time_bucket(unknown, timestamp with time zone, offset => interval, origin => timestamp with time zone) does not exist at character 140 -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:587: ERROR: using offset and origin in a time_bucket function at the same time is not supported \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; TimeZone ---------- PST8PDT -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:613: NOTICE: refreshing continuous aggregate "cagg_4_hours" CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:619: NOTICE: refreshing continuous aggregate "cagg_4_hours_offset" -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:626: NOTICE: refreshing continuous aggregate "cagg_4_hours_origin" -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 6 -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+----- Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+----- Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+----- Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; user_view_name | watermark | to_timestamp ---------------------+------------------+------------------------------ cagg_4_hours | 1577952000000000 | Thu Jan 02 00:00:00 2020 PST cagg_4_hours_offset | 1577953800000000 | Thu Jan 02 00:30:00 2020 PST cagg_4_hours_origin | 1577955600000000 | Thu Jan 02 01:00:00 2020 PST -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 10 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 10 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:683: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Thu Jan 02 00:00:00 2020 PST, Thu Jan 02 12:00:00 2020 PST ] psql:include/cagg_query_common.sql:683: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:684: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:684: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Wed Jan 01 20:30:00 2020 PST, Thu Jan 02 12:30:00 2020 PST ] psql:include/cagg_query_common.sql:684: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:684: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_34" CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:685: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577995200000000 psql:include/cagg_query_common.sql:685: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Wed Jan 01 21:00:00 2020 PST, Thu Jan 02 13:00:00 2020 PST ] psql:include/cagg_query_common.sql:685: LOG: merged 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:685: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_35" RESET client_min_messages; psql:include/cagg_query_common.sql:686: LOG: statement: RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 6 Wed Jan 01 20:00:00 2020 PST | 10 Thu Jan 02 00:00:00 2020 PST | 2222 Thu Jan 02 04:00:00 2020 PST | 5555 Thu Jan 02 08:00:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 6 Wed Jan 01 16:30:00 2020 PST | 6 Wed Jan 01 20:30:00 2020 PST | 2222 Thu Jan 02 04:30:00 2020 PST | 5555 Thu Jan 02 08:30:00 2020 PST | 8888 SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 6 Wed Jan 01 17:00:00 2020 PST | 6 Wed Jan 01 21:00:00 2020 PST | 2222 Thu Jan 02 05:00:00 2020 PST | 5555 Thu Jan 02 09:00:00 2020 PST | 8888 -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); psql:include/cagg_query_common.sql:725: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Sat Jan 01 00:00:00 2000 PST, Sun Jan 02 00:00:00 2000 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 946800000000000 psql:include/cagg_query_common.sql:725: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours" in window [ Wed Jan 01 00:00:00 2020 PST, Thu Jan 02 00:00:00 2020 PST ] psql:include/cagg_query_common.sql:725: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_33" psql:include/cagg_query_common.sql:725: DEBUG: hypertable 33 existing watermark >= new watermark 1577995200000000 1577952000000000 CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); psql:include/cagg_query_common.sql:726: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Fri Dec 31 20:30:00 1999 PST, Sun Jan 02 00:30:00 2000 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 946801800000000 psql:include/cagg_query_common.sql:726: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_offset" in window [ Tue Dec 31 20:30:00 2019 PST, Thu Jan 02 00:30:00 2020 PST ] psql:include/cagg_query_common.sql:726: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_34" psql:include/cagg_query_common.sql:726: DEBUG: hypertable 34 existing watermark >= new watermark 1577997000000000 1577953800000000 CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: LOG: statement: CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); psql:include/cagg_query_common.sql:727: DEBUG: hypertable 4 existing watermark >= new invalidation threshold 1577995200000000 1577952000000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Fri Dec 31 21:00:00 1999 PST, Sun Jan 02 01:00:00 2000 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 6 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 946803600000000 psql:include/cagg_query_common.sql:727: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_4_hours_origin" in window [ Tue Dec 31 21:00:00 2019 PST, Thu Jan 02 01:00:00 2020 PST ] psql:include/cagg_query_common.sql:727: LOG: inserted 7 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_35" psql:include/cagg_query_common.sql:727: DEBUG: hypertable 35 existing watermark >= new watermark 1577998800000000 1577955600000000 RESET client_min_messages; psql:include/cagg_query_common.sql:728: LOG: statement: RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:00:00 2000 PST | 5 Sat Jan 01 04:00:00 2000 PST | 5 Sat Jan 01 08:00:00 2000 PST | 5 Sat Jan 01 12:00:00 2000 PST | 5 Sat Jan 01 16:00:00 2000 PST | 5 Sat Jan 01 20:00:00 2000 PST | 5 Wed Jan 01 00:00:00 2020 PST | 6 Wed Jan 01 04:00:00 2020 PST | 6 Wed Jan 01 08:00:00 2020 PST | 6 Wed Jan 01 12:00:00 2020 PST | 6 Wed Jan 01 16:00:00 2020 PST | 5555 Wed Jan 01 20:00:00 2020 PST | 8888 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 00:30:00 2000 PST | 5 Sat Jan 01 04:30:00 2000 PST | 5 Sat Jan 01 08:30:00 2000 PST | 5 Sat Jan 01 12:30:00 2000 PST | 5 Sat Jan 01 16:30:00 2000 PST | 5 Sat Jan 01 20:30:00 2000 PST | 5 Tue Dec 31 20:30:00 2019 PST | 6 Wed Jan 01 00:30:00 2020 PST | 6 Wed Jan 01 04:30:00 2020 PST | 6 Wed Jan 01 08:30:00 2020 PST | 6 Wed Jan 01 12:30:00 2020 PST | 2222 Wed Jan 01 16:30:00 2020 PST | 8888 Wed Jan 01 20:30:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------ Sat Jan 01 01:00:00 2000 PST | 5 Sat Jan 01 05:00:00 2000 PST | 5 Sat Jan 01 09:00:00 2000 PST | 5 Sat Jan 01 13:00:00 2000 PST | 5 Sat Jan 01 17:00:00 2000 PST | 5 Sat Jan 01 21:00:00 2000 PST | 5 Tue Dec 31 21:00:00 2019 PST | 6 Wed Jan 01 01:00:00 2020 PST | 6 Wed Jan 01 05:00:00 2020 PST | 6 Wed Jan 01 09:00:00 2020 PST | 6 Wed Jan 01 13:00:00 2020 PST | 5555 Wed Jan 01 17:00:00 2020 PST | 8888 Wed Jan 01 21:00:00 2020 PST | 6 --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | 1577995200000000 | 9223372036854775807 CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:766: NOTICE: refreshing continuous aggregate "cagg_1_year" SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 2 | -9223372036854775808 | -210866803200000001 2 | 1541289600000000 | 9223372036854775807 3 | -9223372036854775808 | -210866803200000001 3 | 1541289600000000 | 9223372036854775807 33 | -9223372036854775808 | -210866803200000001 33 | -9223372036854775808 | 9223372036854775807 33 | 1577995200000000 | 9223372036854775807 34 | -9223372036854775808 | -210866803200000001 34 | -9223372036854775808 | 9223372036854775807 34 | 1577995200000000 | 9223372036854775807 35 | -9223372036854775808 | -210866803200000001 35 | -9223372036854775808 | 9223372036854775807 35 | 1577995200000000 | 9223372036854775807 36 | 1609459200000000 | 9223372036854775807 --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:783: NOTICE: refreshing continuous aggregate "cagg_int" CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:789: NOTICE: refreshing continuous aggregate "cagg_int_offset" -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 5 100 | 555 CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 30 95 | 555 CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; time_bucket | value -------------+------- -50 | 50 -40 | 50 -30 | 50 -20 | 50 -10 | 50 0 | 50 10 | 50 20 | 50 30 | 50 40 | 50 50 | 105 100 | 555 SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: LOG: statement: CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); psql:include/cagg_query_common.sql:824: DEBUG: continuous aggregate refresh (individual invalidation) on "cagg_int_offset" in window [ 105, 135 ] psql:include/cagg_query_common.sql:824: DEBUG: building index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" on table "_hyper_38_67_chunk" serially psql:include/cagg_query_common.sql:824: DEBUG: index "_hyper_38_67_chunk__materialized_hypertable_38_time_bucket_idx" can safely use deduplication psql:include/cagg_query_common.sql:824: LOG: inserted 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_38" RESET client_min_messages; psql:include/cagg_query_common.sql:825: LOG: statement: RESET client_min_messages; SELECT * FROM cagg_int_offset; time_bucket | value -------------+------- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; time_bucket | sum -------------+----- -55 | 25 -45 | 50 -35 | 50 -25 | 50 -15 | 50 -5 | 50 5 | 50 15 | 50 25 | 50 35 | 50 45 | 130 95 | 555 105 | 0 -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:835: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 year | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; psql:include/cagg_query_common.sql:837: NOTICE: drop cascades to 2 other objects -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:844: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin2" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+---------------------------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin2 | public.time_bucket(interval,timestamp with time zone,pg_catalog.text,timestamp with time zone,interval) | @ 1 hour | Fri Dec 31 17:05:00 1999 PST | | UTC | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; psql:include/cagg_query_common.sql:846: NOTICE: drop cascades to 2 other objects -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:853: NOTICE: refreshing continuous aggregate "cagg_1_hour_variable_bucket_fixed_origin3" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+-------------------------------------------+----------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- public | cagg_1_hour_variable_bucket_fixed_origin3 | public.time_bucket(interval,timestamp with time zone,interval) | @ 1 year | | @ 5 mins | | f DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; psql:include/cagg_query_common.sql:855: NOTICE: drop cascades to 2 other objects --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:870: NOTICE: refreshing continuous aggregate "cagg_1_hour_origin" CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:876: ERROR: cannot create continuous aggregate with different bucket origin values -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:883: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:889: ERROR: cannot create continuous aggregate with different bucket offset values -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:897: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_null_offset" [NULL] and "public.cagg_1_hour_offset" [@ 30 mins] should be the same. -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:904: NOTICE: refreshing continuous aggregate "cagg_1_hour_null_offset" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:910: ERROR: cannot create continuous aggregate with different bucket offset values DETAIL: Time origin of "public.cagg_1_week_non_null_offset" [@ 35 mins] and "public.cagg_1_hour_null_offset" [NULL] should be the same. \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:918: NOTICE: refreshing continuous aggregate "cagg_int_offset_5" CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:924: ERROR: cannot create continuous aggregate with different bucket offset values \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; psql:include/cagg_query_common.sql:928: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_1_hour_offset; psql:include/cagg_query_common.sql:929: NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW cagg_int_offset_5; psql:include/cagg_query_common.sql:930: NOTICE: drop cascades to 3 other objects --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:939: NOTICE: refreshing continuous aggregate "cagg_1_hour_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_hour_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 1 hour | Sun Jan 02 01:00:00 2000 PST | | | t CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; psql:include/cagg_query_common.sql:946: NOTICE: refreshing continuous aggregate "cagg_1_week_offset" SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; user_view_schema | user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width ------------------+--------------------+--------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- public | cagg_1_week_offset | public.time_bucket(interval,timestamp with time zone,timestamp with time zone) | @ 7 days | Sun Jan 02 01:00:00 2000 PST | | | t -- Compare output SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+----- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max ------------------------------+------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; week_bucket | max_value ------------------------------+----------- Sun Jan 30 01:00:00 2000 PST | 5 Sun Jan 26 01:00:00 2020 PST | 6 Sun Dec 30 01:00:00 2029 PST | 55555 SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; time_bucket | max -------------+----- DROP VIEW caggs_info; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_refresh_using_merge.out�����������������������������������0000664�0000000�0000000�00000132240�15100345067�0025173�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; SET timezone TO PST8PDT; \ir include/cagg_refresh_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions (time timestamptz NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time'); create_hypertable ------------------------- (1,public,conditions,t) -- Test refresh on a cagg built on an empty table CREATE MATERIALIZED VIEW daily_temp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); psql:include/cagg_refresh_common.sql:17: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', NULL, NULL, force => true); psql:include/cagg_refresh_common.sql:18: NOTICE: continuous aggregate "daily_temp" is already up-to-date SELECT setseed(.12); setseed --------- INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(t::timestamp))%4)::int, abs(timestamp_hash(t::timestamp))%40 FROM generate_series('2020-05-01', '2020-05-05', '10 minutes'::interval) t; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; time | device | temp ------------------------------+--------+------ Tue May 05 00:00:00 2020 PDT | 2 | 30 Mon May 04 23:50:00 2020 PDT | 2 | 10 Mon May 04 23:40:00 2020 PDT | 0 | 20 Mon May 04 23:30:00 2020 PDT | 1 | 1 Mon May 04 23:20:00 2020 PDT | 2 | 34 Mon May 04 23:10:00 2020 PDT | 1 | 37 Mon May 04 23:00:00 2020 PDT | 0 | 4 Mon May 04 22:50:00 2020 PDT | 2 | 10 Mon May 04 22:40:00 2020 PDT | 1 | 37 Mon May 04 22:30:00 2020 PDT | 0 | 8 -- The continuous aggregate should be empty SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp -----+--------+---------- -- Refresh one bucket (1 day): SHOW timezone; TimeZone ---------- PST8PDT -- The refresh of a single bucket must align with the start of the day -- in the bucket's time zone (which is UTC, since time_bucket doesn't -- support time zone arg) CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 17:00 PDT', '2020-05-04 17:00 PDT'); \set ON_ERROR_STOP 0 \set VERBOSITY default -- These refreshes will fail since they don't align with the bucket's -- time zone CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-04'); psql:include/cagg_refresh_common.sql:47: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 PDT', '2020-05-04 00:00 PDT'); psql:include/cagg_refresh_common.sql:48: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. -- Refresh window less than one bucket CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-03 23:59 UTC'); psql:include/cagg_refresh_common.sql:51: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. -- Refresh window bigger than one bucket, but failing since it is not -- aligned with bucket boundaries so that it covers a full bucket: -- -- Refresh window: [----------) -- Buckets: [------|------] CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 01:00 UTC', '2020-05-04 08:00 UTC'); psql:include/cagg_refresh_common.sql:57: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Refresh the most recent few days: CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 -- Refresh the rest CALL refresh_continuous_aggregate('daily_temp', '2020-04-30', '2020-05-04'); -- Compare the aggregate to the equivalent query on the source table SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 Fri May 01 17:00:00 2020 PDT | 0 | 19 Fri May 01 17:00:00 2020 PDT | 1 | 15.1463414634146 Fri May 01 17:00:00 2020 PDT | 2 | 19.7674418604651 Fri May 01 17:00:00 2020 PDT | 3 | 22.25 Thu Apr 30 17:00:00 2020 PDT | 0 | 17.6666666666667 Thu Apr 30 17:00:00 2020 PDT | 1 | 18.8333333333333 Thu Apr 30 17:00:00 2020 PDT | 2 | 16.7586206896552 Thu Apr 30 17:00:00 2020 PDT | 3 | 20.76 SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 ORDER BY 1 DESC,2; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 Fri May 01 17:00:00 2020 PDT | 0 | 19 Fri May 01 17:00:00 2020 PDT | 1 | 15.1463414634146 Fri May 01 17:00:00 2020 PDT | 2 | 19.7674418604651 Fri May 01 17:00:00 2020 PDT | 3 | 22.25 Thu Apr 30 17:00:00 2020 PDT | 0 | 17.6666666666667 Thu Apr 30 17:00:00 2020 PDT | 1 | 18.8333333333333 Thu Apr 30 17:00:00 2020 PDT | 2 | 16.7586206896552 Thu Apr 30 17:00:00 2020 PDT | 3 | 20.76 -- Test unusual, but valid input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::timestamptz, '2020-05-03'::date); psql:include/cagg_refresh_common.sql:80: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::date, '2020-05-03'::date); psql:include/cagg_refresh_common.sql:81: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Unbounded window forward in time CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', NULL); psql:include/cagg_refresh_common.sql:84: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); -- Unbounded window back in time CALL refresh_continuous_aggregate('daily_temp', NULL, '2020-05-01'); psql:include/cagg_refresh_common.sql:88: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Test bad input \set ON_ERROR_STOP 0 -- Bad continuous aggregate name CALL refresh_continuous_aggregate(NULL, '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:93: ERROR: invalid continuous aggregate CALL refresh_continuous_aggregate('xyz', '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:94: ERROR: relation "xyz" does not exist at character 35 -- Valid object, but not a continuous aggregate CALL refresh_continuous_aggregate('conditions', '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:96: ERROR: relation "conditions" is not a continuous aggregate -- Object ID with no object CALL refresh_continuous_aggregate(1, '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:98: ERROR: continuous aggregate does not exist -- Lacking arguments CALL refresh_continuous_aggregate('daily_temp'); psql:include/cagg_refresh_common.sql:100: ERROR: procedure refresh_continuous_aggregate(unknown) does not exist at character 6 CALL refresh_continuous_aggregate('daily_temp', '2020-05-03'); psql:include/cagg_refresh_common.sql:101: ERROR: procedure refresh_continuous_aggregate(unknown, unknown) does not exist at character 6 -- Bad time ranges CALL refresh_continuous_aggregate('daily_temp', 'xyz', '2020-05-05'); psql:include/cagg_refresh_common.sql:103: ERROR: invalid input syntax for type timestamp with time zone: "xyz" CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', 'xyz'); psql:include/cagg_refresh_common.sql:104: ERROR: invalid input syntax for type timestamp with time zone: "xyz" CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-01'); psql:include/cagg_refresh_common.sql:105: ERROR: refresh window too small -- Bad time input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::text, '2020-05-03'::text); psql:include/cagg_refresh_common.sql:107: ERROR: invalid time argument type "text" CALL refresh_continuous_aggregate('daily_temp', 0, '2020-05-01'); psql:include/cagg_refresh_common.sql:108: ERROR: invalid time argument type "integer" \set ON_ERROR_STOP 1 -- Test forceful refreshment. Here we simulate the situation that we've seen -- with tiered data when `timescaledb.enable_tiered_reads` were disabled on the -- server level. In that case we would not see materialized tiered data and -- we wouldn't be able to re-materialize the data using a normal refresh call -- because it would skip previously materialized ranges, but it should be -- possible with `force=>true` parameter. To simulate this use-case we clear -- the materialization hypertable and forefully re-materialize it. SELECT format('%I.%I', ht.schema_name, ht.table_name) AS mat_ht, mat_hypertable_id FROM _timescaledb_catalog.continuous_agg cagg JOIN _timescaledb_catalog.hypertable ht ON cagg.mat_hypertable_id = ht.id WHERE user_view_name = 'daily_temp' \gset -- Delete the data from the materialization hypertable DELETE FROM :mat_ht; -- Run regular refresh, it should not touch previously materialized range CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); psql:include/cagg_refresh_common.sql:126: NOTICE: continuous aggregate "daily_temp" is already up-to-date SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp -----+--------+---------- -- Run it again with force=>true, the data should be rematerialized CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00', force=>true); SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 -- Test different time types CREATE TABLE conditions_date (time date NOT NULL, device int, temp float); SELECT create_hypertable('conditions_date', 'time'); create_hypertable ------------------------------ (3,public,conditions_date,t) CREATE MATERIALIZED VIEW daily_temp_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_date GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp_date', '2020-05-01', '2020-05-03'); -- Try max refresh window size CALL refresh_continuous_aggregate('daily_temp_date', NULL, NULL); -- Test smallint-based continuous aggregate CREATE TABLE conditions_smallint (time smallint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_smallint', 'time', chunk_time_interval => 20); create_hypertable ---------------------------------- (5,public,conditions_smallint,t) INSERT INTO conditions_smallint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::smallint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM conditions_smallint $$; \set ON_ERROR_STOP 0 -- First try to create an integer-based continuous aggregate without -- an now function. This should not be allowed. CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; psql:include/cagg_refresh_common.sql:175: ERROR: custom time function required on hypertable "conditions_smallint" \set ON_ERROR_STOP 1 SELECT set_integer_now_func('conditions_smallint', 'smallint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_smallint', 0::smallint, 70::smallint); SELECT * FROM cond_20_smallint ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_smallint', NULL, NULL); -- Test int-based continuous aggregate CREATE TABLE conditions_int (time int NOT NULL, device int, temp float); SELECT create_hypertable('conditions_int', 'time', chunk_time_interval => 20); create_hypertable ----------------------------- (7,public,conditions_int,t) INSERT INTO conditions_int SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions_int $$; SELECT set_integer_now_func('conditions_int', 'int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_int GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_int', 0, 65); SELECT * FROM cond_20_int ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_int', NULL, NULL); -- Test bigint-based continuous aggregate CREATE TABLE conditions_bigint (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_bigint', 'time', chunk_time_interval => 20); create_hypertable -------------------------------- (9,public,conditions_bigint,t) INSERT INTO conditions_bigint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::bigint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM conditions_bigint $$; SELECT set_integer_now_func('conditions_bigint', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_bigint GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_bigint', 0, 75); SELECT * FROM cond_20_bigint ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_bigint', NULL, NULL); -- Test that WITH NO DATA and WITH DATA works (we use whatever is the -- default for Postgres, so we do not need to have test for the -- default). CREATE MATERIALIZED VIEW weekly_temp_without_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW weekly_temp_with_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; psql:include/cagg_refresh_common.sql:280: NOTICE: refreshing continuous aggregate "weekly_temp_with_data" SELECT * FROM weekly_temp_without_data; day | device | avg_temp -----+--------+---------- SELECT * FROM weekly_temp_with_data ORDER BY 1,2; day | device | avg_temp ------------------------------+--------+------------------ Sun Apr 26 17:00:00 2020 PDT | 0 | 17.8181818181818 Sun Apr 26 17:00:00 2020 PDT | 1 | 17.2474226804124 Sun Apr 26 17:00:00 2020 PDT | 2 | 18.9803921568627 Sun Apr 26 17:00:00 2020 PDT | 3 | 21.5631067961165 Sun May 03 17:00:00 2020 PDT | 0 | 16.7659574468085 Sun May 03 17:00:00 2020 PDT | 1 | 22.7272727272727 Sun May 03 17:00:00 2020 PDT | 2 | 15.811320754717 Sun May 03 17:00:00 2020 PDT | 3 | 19 \set ON_ERROR_STOP 0 -- REFRESH MATERIALIZED VIEW is blocked on continuous aggregates REFRESH MATERIALIZED VIEW weekly_temp_without_data; psql:include/cagg_refresh_common.sql:287: ERROR: operation not supported on continuous aggregate -- These should fail since we do not allow refreshing inside a -- transaction, not even as part of CREATE MATERIALIZED VIEW. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; END $$; psql:include/cagg_refresh_common.sql:299: ERROR: CREATE MATERIALIZED VIEW ... WITH DATA cannot be executed from a function BEGIN; CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; psql:include/cagg_refresh_common.sql:308: ERROR: CREATE MATERIALIZED VIEW ... WITH DATA cannot run inside a transaction block COMMIT; \set ON_ERROR_STOP 1 -- This should not fail since we do not refresh the continuous -- aggregate. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; END $$; BEGIN; CREATE MATERIALIZED VIEW weekly_conditions_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; COMMIT; -- refresh_continuous_aggregate can run two transactions, thus it cannot be -- called in a transaction block (from a function, from dynamic SQL) or in a -- subtransaction (from a procedure block with an EXCEPTION clause). Though it -- does NOT require a top level context and can be called from a procedure -- block without an EXCEPTION clause. -- DO block DO $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; psql:include/cagg_refresh_common.sql:345: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Procedure without subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_normal() LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CALL refresh_cagg_proc_normal(); psql:include/cagg_refresh_common.sql:355: NOTICE: continuous aggregate "daily_temp" is already up-to-date \set ON_ERROR_STOP 0 -- Procedure with subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_subtransaction() LANGUAGE PLPGSQL AS $$ DECLARE errmsg TEXT; BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS errmsg = MESSAGE_TEXT; RAISE EXCEPTION '%', errmsg; END; $$; CALL refresh_cagg_proc_subtransaction(); psql:include/cagg_refresh_common.sql:372: ERROR: refresh_continuous_aggregate() cannot run inside a transaction block -- Function CREATE OR REPLACE FUNCTION refresh_cagg_fun() RETURNS INT LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); RETURN 1; END; $$; SELECT * from refresh_cagg_fun(); psql:include/cagg_refresh_common.sql:383: ERROR: refresh_continuous_aggregate() cannot be executed from a function -- Dynamic SQL DO $$ BEGIN EXECUTE $inner$ CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); $inner$; END; $$; psql:include/cagg_refresh_common.sql:391: ERROR: refresh_continuous_aggregate() cannot be executed from a function -- Trigger CREATE TABLE refresh_cagg_trigger_table(a int); CREATE FUNCTION refresh_cagg_trigger_fun() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CREATE TRIGGER refresh_cagg_trigger AFTER INSERT ON refresh_cagg_trigger_table EXECUTE FUNCTION refresh_cagg_trigger_fun(); INSERT INTO refresh_cagg_trigger_table VALUES(1); psql:include/cagg_refresh_common.sql:405: ERROR: refresh_continuous_aggregate() cannot be executed from a function \set ON_ERROR_STOP 1 -- check that cagg refresh is not blocked by decompression limit CREATE TABLE conditions_decompress_limit (time timestamptz NOT NULL, device text, temp float) WITH (tsdb.hypertable, tsdb.partition_column='time'); INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 1.0 FROM generate_series(1,100) g(i); CREATE MATERIALIZED VIEW daily_temp_decompress_limit WITH (tsdb.continuous) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_decompress_limit GROUP BY 1,2 WITH NO DATA; ALTER MATERIALIZED VIEW daily_temp_decompress_limit SET (tsdb.columnstore,tsdb.segmentby = 'device'); psql:include/cagg_refresh_common.sql:413: NOTICE: defaulting compress_orderby to day CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SELECT compress_chunk(show_chunks('daily_temp_decompress_limit')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_26_chunk INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 2.0 FROM generate_series(1,100) g(i); SET timescaledb.max_tuples_decompressed_per_dml_transaction TO 1; CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SHOW timescaledb.max_tuples_decompressed_per_dml_transaction; timescaledb.max_tuples_decompressed_per_dml_transaction --------------------------------------------------------- 1 -- More tests for forceful refreshment TRUNCATE conditions; INSERT INTO conditions VALUES -- daily bucket 2025-07-04 10:00:00+00 ('2025-07-04 10:00:00+00', 1, 1), ('2025-07-04 10:05:00+00', 1, 1), -- daily bucket 2025-07-04 11:00:00+00 ('2025-07-04 11:00:00+00', 1, 1), ('2025-07-04 11:05:00+00', 1, 1), -- daily bucket 2025-07-04 12:00:00+00 ('2025-07-04 12:00:00+00', 1, 1), ('2025-07-04 12:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, -- Fixed bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_hour ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Fri Jul 04 03:00:00 2025 PDT | 1 | 1 | 1 | 2 Fri Jul 04 04:00:00 2025 PDT | 1 | 1 | 1 | 2 CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_hour ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Fri Jul 04 03:00:00 2025 PDT | 1 | 1 | 1 | 2 Fri Jul 04 04:00:00 2025 PDT | 1 | 1 | 1 | 2 -- Monthly buckets INSERT INTO conditions VALUES -- monthly bucket 2025-05-01 00:00:00+00 ('2025-05-04 10:00:00+00', 1, 1), ('2025-05-04 10:05:00+00', 1, 1), -- monthly bucket 2025-06-01 00:00:00+00 ('2025-06-04 11:00:00+00', 1, 1), ('2025-06-04 11:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_month WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, -- Variable bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_month ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Wed Apr 30 17:00:00 2025 PDT | 1 | 1 | 1 | 2 Sat May 31 17:00:00 2025 PDT | 1 | 1 | 1 | 2 CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_month ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Wed Apr 30 17:00:00 2025 PDT | 1 | 1 | 1 | 2 Sat May 31 17:00:00 2025 PDT | 1 | 1 | 1 | 2 -- Additional tests for MERGE refresh DROP TABLE conditions CASCADE; NOTICE: drop cascades to 14 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_12_24_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_19_29_chunk NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION, humidity DOUBLE PRECISION ); SELECT FROM create_hypertable( 'conditions', 'time'); -- INSERT INTO conditions VALUES ('2018-01-01 09:20:00-08', 'SFO', 55, 45), ('2018-01-02 09:30:00-08', 'POR', 100, 100), ('2018-01-02 09:20:00-08', 'SFO', 65, 45), ('2018-01-02 09:10:00-08', 'NYC', 65, 45), ('2018-11-01 09:20:00-08', 'NYC', 45, 30), ('2018-11-01 10:40:00-08', 'NYC', 55, 35), ('2018-11-01 11:50:00-08', 'NYC', 65, 40), ('2018-11-01 12:10:00-08', 'NYC', 75, 45), ('2018-11-01 13:10:00-08', 'NYC', 85, 50), ('2018-11-02 09:20:00-08', 'NYC', 10, 10), ('2018-11-02 10:30:00-08', 'NYC', 20, 15), ('2018-11-02 11:40:00-08', 'NYC', null, null), ('2018-11-03 09:50:00-08', 'NYC', null, null); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, location, AVG(temperature), MAX(temperature), MIN(temperature) FROM conditions GROUP BY bucket, location WITH NO DATA; -- First refresh using MERGE should fall back to INSERT SET client_min_messages TO LOG; CALL refresh_continuous_aggregate('conditions_daily', NULL, '2018-11-01 23:59:59-08'); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', NULL, '2018-11-01 23:59:59-08'); LOG: inserted 5 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_22" SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 -- Second refresh using MERGE should also fall back to INSERT since there's no data in the materialization hypertable CALL refresh_continuous_aggregate('conditions_daily', '2018-11-01', NULL); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', '2018-11-01', NULL); LOG: inserted 2 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_22" SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 Thu Nov 01 17:00:00 2018 PDT | NYC | 15 | 20 | 10 Fri Nov 02 17:00:00 2018 PDT | NYC | | | -- All data should be in the materialization hypertable CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); NOTICE: continuous aggregate "conditions_daily" is already up-to-date SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 Thu Nov 01 17:00:00 2018 PDT | NYC | 15 | 20 | 10 Fri Nov 02 17:00:00 2018 PDT | NYC | | | -- Changing past data that is not part of the cagg UPDATE conditions SET humidity = humidity + 100 WHERE time = '2018-01-02 09:20:00-08' AND location = 'SFO'; LOG: statement: UPDATE conditions SET humidity = humidity + 100 WHERE time = '2018-01-02 09:20:00-08' AND location = 'SFO'; -- Shoudn't affect the materialization hypertable (merged=0 and deleted=0) CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: merged 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_22" LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_22" SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 Thu Nov 01 17:00:00 2018 PDT | NYC | 15 | 20 | 10 Fri Nov 02 17:00:00 2018 PDT | NYC | | | -- Backfill some data in the past INSERT INTO conditions VALUES ('2017-01-01 09:20:00-08', 'GRU', 55, 45), ('2017-01-01 09:30:00-08', 'POA', 100, 100), ('2017-01-02 09:20:00-08', 'CNF', 65, 45); LOG: statement: INSERT INTO conditions VALUES ('2017-01-01 09:20:00-08', 'GRU', 55, 45), ('2017-01-01 09:30:00-08', 'POA', 100, 100), ('2017-01-02 09:20:00-08', 'CNF', 65, 45); -- There's no data in the affected range so the refresh should fall back to INSERT CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_22" SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sat Dec 31 16:00:00 2016 PST | GRU | 55 | 55 | 55 Sat Dec 31 16:00:00 2016 PST | POA | 100 | 100 | 100 Sun Jan 01 16:00:00 2017 PST | CNF | 65 | 65 | 65 Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 Thu Nov 01 17:00:00 2018 PDT | NYC | 15 | 20 | 10 Fri Nov 02 17:00:00 2018 PDT | NYC | | | -- Update already materilized data in the past UPDATE conditions SET temperature = temperature + 100 WHERE time = '2018-11-02 10:30:00-08' AND location = 'NYC'; LOG: statement: UPDATE conditions SET temperature = temperature + 100 WHERE time = '2018-11-02 10:30:00-08' AND location = 'NYC'; -- Should merge 1 bucket (merged=1 and deleted=0) CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: merged 1 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_22" LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_22" SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sat Dec 31 16:00:00 2016 PST | GRU | 55 | 55 | 55 Sat Dec 31 16:00:00 2016 PST | POA | 100 | 100 | 100 Sun Jan 01 16:00:00 2017 PST | CNF | 65 | 65 | 65 Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 Thu Nov 01 17:00:00 2018 PDT | NYC | 65 | 120 | 10 Fri Nov 02 17:00:00 2018 PDT | NYC | | | -- Delete one entire bucket DELETE FROM conditions WHERE time >= '2018-11-02' AND time < '2018-11-03' AND location = 'NYC'; LOG: statement: DELETE FROM conditions WHERE time >= '2018-11-02' AND time < '2018-11-03' AND location = 'NYC'; -- Should not merge any bucket but delete one bucket (merged=0 and deleted=1) CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: statement: CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); LOG: merged 0 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_22" LOG: deleted 1 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_22" SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; LOG: statement: SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; bucket | location | avg | max | min ------------------------------+----------+-----+-----+----- Sat Dec 31 16:00:00 2016 PST | GRU | 55 | 55 | 55 Sat Dec 31 16:00:00 2016 PST | POA | 100 | 100 | 100 Sun Jan 01 16:00:00 2017 PST | CNF | 65 | 65 | 65 Sun Dec 31 16:00:00 2017 PST | SFO | 55 | 55 | 55 Mon Jan 01 16:00:00 2018 PST | NYC | 65 | 65 | 65 Mon Jan 01 16:00:00 2018 PST | POR | 100 | 100 | 100 Mon Jan 01 16:00:00 2018 PST | SFO | 65 | 65 | 65 Wed Oct 31 17:00:00 2018 PDT | NYC | 65 | 85 | 45 Fri Nov 02 17:00:00 2018 PDT | NYC | | | DROP TABLE conditions CASCADE; LOG: statement: DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 3 other objects -- -- A nullable conditions test -- CREATE TABLE conditions_nullable ( time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION ); LOG: statement: CREATE TABLE conditions_nullable ( time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION ); CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION, humidity DOUBLE PRECISION ); LOG: statement: CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION, humidity DOUBLE PRECISION ); SELECT FROM create_hypertable( 'conditions', 'time'); LOG: statement: SELECT FROM create_hypertable( 'conditions', 'time'); -- INSERT INTO conditions VALUES ('2018-01-01 09:20:00-08', 'SFO', 55), ('2018-01-02 09:30:00-08', null, 100); LOG: statement: INSERT INTO conditions VALUES ('2018-01-01 09:20:00-08', 'SFO', 55), ('2018-01-02 09:30:00-08', null, 100); CREATE MATERIALIZED VIEW conditions_nullable_daily WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, location, AVG(temperature) FROM conditions GROUP BY bucket, location WITH NO DATA; LOG: statement: CREATE MATERIALIZED VIEW conditions_nullable_daily WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, location, AVG(temperature) FROM conditions GROUP BY bucket, location WITH NO DATA; -- First refresh using MERGE should fall back to INSERT SET client_min_messages TO LOG; LOG: statement: SET client_min_messages TO LOG; CALL refresh_continuous_aggregate('conditions_nullable_daily', NULL, '2018-11-01 23:59:59-08'); LOG: statement: CALL refresh_continuous_aggregate('conditions_nullable_daily', NULL, '2018-11-01 23:59:59-08'); LOG: inserted 2 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_24" RESET client_min_messages; LOG: statement: RESET client_min_messages; SELECT * FROM conditions_nullable_daily ORDER BY 1, 2 NULLS LAST, 3 NULLS LAST; bucket | location | avg ------------------------------+----------+----- Sun Dec 31 16:00:00 2017 PST | SFO | 55 Mon Jan 01 16:00:00 2018 PST | | 100 -- Inserting a new data should ensure we get correct results INSERT INTO conditions VALUES ('2018-01-01 19:20:00-08', 'SFO', 65), ('2018-01-02 19:30:00-08', null, 200); -- Second refresh *should* use the merge, and return correct results. SET client_min_messages TO LOG; CALL refresh_continuous_aggregate('conditions_nullable_daily', NULL, '2018-11-01 23:59:59-08'); LOG: statement: CALL refresh_continuous_aggregate('conditions_nullable_daily', NULL, '2018-11-01 23:59:59-08'); LOG: merged 2 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_24" LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_24" RESET client_min_messages; LOG: statement: RESET client_min_messages; SELECT * FROM conditions_nullable_daily ORDER BY 1, 2 NULLS LAST, 3 NULLS LAST; bucket | location | avg ------------------------------+----------+----- Sun Dec 31 16:00:00 2017 PST | SFO | 55 Mon Jan 01 16:00:00 2018 PST | SFO | 65 Mon Jan 01 16:00:00 2018 PST | | 100 Tue Jan 02 16:00:00 2018 PST | | 200 DROP MATERIALIZED VIEW conditions_nullable_daily; NOTICE: drop cascades to table _timescaledb_internal._hyper_24_41_chunk DROP TABLE conditions CASCADE; -- test cagg refresh with updated values CREATE TABLE metrics(time timestamptz NOT NULL, device text, value float8) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO metrics SELECT time, 'd'||device::text, 1 FROM generate_series('2025-02-05 17:00+00'::timestamptz,'2025-02-05 19:00+00'::timestamptz, '5 min'::interval) AS g(time), generate_series(1, 10) AS device; CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous) AS SELECT device, time_bucket('00:05:00'::interval, time) AS bucket, sum(value) AS value FROM metrics GROUP BY 1, 2; NOTICE: refreshing continuous aggregate "metrics_summary" UPDATE metrics SET value = value - 1 WHERE device='d1' and time ='2025-02-05 17:40:00+00'; CALL refresh_continuous_aggregate('metrics_summary', '2025-02-04', '2025-02-10'); SET enable_bitmapscan TO off; SET enable_seqscan TO true; SET enable_indexscan TO false; -- should be 250 SELECT count(*) FROM metrics_summary WHERE bucket >= '2025-02-05 17:00:00+00' AND bucket < '2025-02-05 23:00:00+00'; count ------- 250 SET enable_seqscan TO false; SET enable_indexscan TO true; -- should match the result of the previous query SELECT count(*) FROM metrics_summary WHERE bucket >= '2025-02-05 17:00:00+00' AND bucket < '2025-02-05 23:00:00+00'; count ------- 250 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_refresh_using_trigger.out���������������������������������0000664�0000000�0000000�00000073212�15100345067�0025542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; \ir include/cagg_refresh_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions (time timestamptz NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time'); create_hypertable ------------------------- (1,public,conditions,t) -- Test refresh on a cagg built on an empty table CREATE MATERIALIZED VIEW daily_temp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); psql:include/cagg_refresh_common.sql:17: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', NULL, NULL, force => true); psql:include/cagg_refresh_common.sql:18: NOTICE: continuous aggregate "daily_temp" is already up-to-date SELECT setseed(.12); setseed --------- INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(t::timestamp))%4)::int, abs(timestamp_hash(t::timestamp))%40 FROM generate_series('2020-05-01', '2020-05-05', '10 minutes'::interval) t; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; time | device | temp ------------------------------+--------+------ Tue May 05 00:00:00 2020 PDT | 2 | 30 Mon May 04 23:50:00 2020 PDT | 2 | 10 Mon May 04 23:40:00 2020 PDT | 0 | 20 Mon May 04 23:30:00 2020 PDT | 1 | 1 Mon May 04 23:20:00 2020 PDT | 2 | 34 Mon May 04 23:10:00 2020 PDT | 1 | 37 Mon May 04 23:00:00 2020 PDT | 0 | 4 Mon May 04 22:50:00 2020 PDT | 2 | 10 Mon May 04 22:40:00 2020 PDT | 1 | 37 Mon May 04 22:30:00 2020 PDT | 0 | 8 -- The continuous aggregate should be empty SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp -----+--------+---------- -- Refresh one bucket (1 day): SHOW timezone; TimeZone ---------- PST8PDT -- The refresh of a single bucket must align with the start of the day -- in the bucket's time zone (which is UTC, since time_bucket doesn't -- support time zone arg) CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 17:00 PDT', '2020-05-04 17:00 PDT'); \set ON_ERROR_STOP 0 \set VERBOSITY default -- These refreshes will fail since they don't align with the bucket's -- time zone CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-04'); psql:include/cagg_refresh_common.sql:47: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 PDT', '2020-05-04 00:00 PDT'); psql:include/cagg_refresh_common.sql:48: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. -- Refresh window less than one bucket CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-03 23:59 UTC'); psql:include/cagg_refresh_common.sql:51: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. -- Refresh window bigger than one bucket, but failing since it is not -- aligned with bucket boundaries so that it covers a full bucket: -- -- Refresh window: [----------) -- Buckets: [------|------] CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 01:00 UTC', '2020-05-04 08:00 UTC'); psql:include/cagg_refresh_common.sql:57: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Refresh the most recent few days: CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 -- Refresh the rest CALL refresh_continuous_aggregate('daily_temp', '2020-04-30', '2020-05-04'); -- Compare the aggregate to the equivalent query on the source table SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 Fri May 01 17:00:00 2020 PDT | 0 | 19 Fri May 01 17:00:00 2020 PDT | 1 | 15.1463414634146 Fri May 01 17:00:00 2020 PDT | 2 | 19.7674418604651 Fri May 01 17:00:00 2020 PDT | 3 | 22.25 Thu Apr 30 17:00:00 2020 PDT | 0 | 17.6666666666667 Thu Apr 30 17:00:00 2020 PDT | 1 | 18.8333333333333 Thu Apr 30 17:00:00 2020 PDT | 2 | 16.7586206896552 Thu Apr 30 17:00:00 2020 PDT | 3 | 20.76 SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 ORDER BY 1 DESC,2; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 Fri May 01 17:00:00 2020 PDT | 0 | 19 Fri May 01 17:00:00 2020 PDT | 1 | 15.1463414634146 Fri May 01 17:00:00 2020 PDT | 2 | 19.7674418604651 Fri May 01 17:00:00 2020 PDT | 3 | 22.25 Thu Apr 30 17:00:00 2020 PDT | 0 | 17.6666666666667 Thu Apr 30 17:00:00 2020 PDT | 1 | 18.8333333333333 Thu Apr 30 17:00:00 2020 PDT | 2 | 16.7586206896552 Thu Apr 30 17:00:00 2020 PDT | 3 | 20.76 -- Test unusual, but valid input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::timestamptz, '2020-05-03'::date); psql:include/cagg_refresh_common.sql:80: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::date, '2020-05-03'::date); psql:include/cagg_refresh_common.sql:81: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Unbounded window forward in time CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', NULL); psql:include/cagg_refresh_common.sql:84: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); -- Unbounded window back in time CALL refresh_continuous_aggregate('daily_temp', NULL, '2020-05-01'); psql:include/cagg_refresh_common.sql:88: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Test bad input \set ON_ERROR_STOP 0 -- Bad continuous aggregate name CALL refresh_continuous_aggregate(NULL, '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:93: ERROR: invalid continuous aggregate CALL refresh_continuous_aggregate('xyz', '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:94: ERROR: relation "xyz" does not exist at character 35 -- Valid object, but not a continuous aggregate CALL refresh_continuous_aggregate('conditions', '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:96: ERROR: relation "conditions" is not a continuous aggregate -- Object ID with no object CALL refresh_continuous_aggregate(1, '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:98: ERROR: continuous aggregate does not exist -- Lacking arguments CALL refresh_continuous_aggregate('daily_temp'); psql:include/cagg_refresh_common.sql:100: ERROR: procedure refresh_continuous_aggregate(unknown) does not exist at character 6 CALL refresh_continuous_aggregate('daily_temp', '2020-05-03'); psql:include/cagg_refresh_common.sql:101: ERROR: procedure refresh_continuous_aggregate(unknown, unknown) does not exist at character 6 -- Bad time ranges CALL refresh_continuous_aggregate('daily_temp', 'xyz', '2020-05-05'); psql:include/cagg_refresh_common.sql:103: ERROR: invalid input syntax for type timestamp with time zone: "xyz" CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', 'xyz'); psql:include/cagg_refresh_common.sql:104: ERROR: invalid input syntax for type timestamp with time zone: "xyz" CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-01'); psql:include/cagg_refresh_common.sql:105: ERROR: refresh window too small -- Bad time input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::text, '2020-05-03'::text); psql:include/cagg_refresh_common.sql:107: ERROR: invalid time argument type "text" CALL refresh_continuous_aggregate('daily_temp', 0, '2020-05-01'); psql:include/cagg_refresh_common.sql:108: ERROR: invalid time argument type "integer" \set ON_ERROR_STOP 1 -- Test forceful refreshment. Here we simulate the situation that we've seen -- with tiered data when `timescaledb.enable_tiered_reads` were disabled on the -- server level. In that case we would not see materialized tiered data and -- we wouldn't be able to re-materialize the data using a normal refresh call -- because it would skip previously materialized ranges, but it should be -- possible with `force=>true` parameter. To simulate this use-case we clear -- the materialization hypertable and forefully re-materialize it. SELECT format('%I.%I', ht.schema_name, ht.table_name) AS mat_ht, mat_hypertable_id FROM _timescaledb_catalog.continuous_agg cagg JOIN _timescaledb_catalog.hypertable ht ON cagg.mat_hypertable_id = ht.id WHERE user_view_name = 'daily_temp' \gset -- Delete the data from the materialization hypertable DELETE FROM :mat_ht; -- Run regular refresh, it should not touch previously materialized range CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); psql:include/cagg_refresh_common.sql:126: NOTICE: continuous aggregate "daily_temp" is already up-to-date SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp -----+--------+---------- -- Run it again with force=>true, the data should be rematerialized CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00', force=>true); SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 -- Test different time types CREATE TABLE conditions_date (time date NOT NULL, device int, temp float); SELECT create_hypertable('conditions_date', 'time'); create_hypertable ------------------------------ (3,public,conditions_date,t) CREATE MATERIALIZED VIEW daily_temp_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_date GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp_date', '2020-05-01', '2020-05-03'); -- Try max refresh window size CALL refresh_continuous_aggregate('daily_temp_date', NULL, NULL); -- Test smallint-based continuous aggregate CREATE TABLE conditions_smallint (time smallint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_smallint', 'time', chunk_time_interval => 20); create_hypertable ---------------------------------- (5,public,conditions_smallint,t) INSERT INTO conditions_smallint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::smallint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM conditions_smallint $$; \set ON_ERROR_STOP 0 -- First try to create an integer-based continuous aggregate without -- an now function. This should not be allowed. CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; psql:include/cagg_refresh_common.sql:175: ERROR: custom time function required on hypertable "conditions_smallint" \set ON_ERROR_STOP 1 SELECT set_integer_now_func('conditions_smallint', 'smallint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_smallint', 0::smallint, 70::smallint); SELECT * FROM cond_20_smallint ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_smallint', NULL, NULL); -- Test int-based continuous aggregate CREATE TABLE conditions_int (time int NOT NULL, device int, temp float); SELECT create_hypertable('conditions_int', 'time', chunk_time_interval => 20); create_hypertable ----------------------------- (7,public,conditions_int,t) INSERT INTO conditions_int SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions_int $$; SELECT set_integer_now_func('conditions_int', 'int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_int GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_int', 0, 65); SELECT * FROM cond_20_int ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_int', NULL, NULL); -- Test bigint-based continuous aggregate CREATE TABLE conditions_bigint (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_bigint', 'time', chunk_time_interval => 20); create_hypertable -------------------------------- (9,public,conditions_bigint,t) INSERT INTO conditions_bigint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::bigint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM conditions_bigint $$; SELECT set_integer_now_func('conditions_bigint', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_bigint GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_bigint', 0, 75); SELECT * FROM cond_20_bigint ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_bigint', NULL, NULL); -- Test that WITH NO DATA and WITH DATA works (we use whatever is the -- default for Postgres, so we do not need to have test for the -- default). CREATE MATERIALIZED VIEW weekly_temp_without_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW weekly_temp_with_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; psql:include/cagg_refresh_common.sql:280: NOTICE: refreshing continuous aggregate "weekly_temp_with_data" SELECT * FROM weekly_temp_without_data; day | device | avg_temp -----+--------+---------- SELECT * FROM weekly_temp_with_data ORDER BY 1,2; day | device | avg_temp ------------------------------+--------+------------------ Sun Apr 26 17:00:00 2020 PDT | 0 | 17.8181818181818 Sun Apr 26 17:00:00 2020 PDT | 1 | 17.2474226804124 Sun Apr 26 17:00:00 2020 PDT | 2 | 18.9803921568627 Sun Apr 26 17:00:00 2020 PDT | 3 | 21.5631067961165 Sun May 03 17:00:00 2020 PDT | 0 | 16.7659574468085 Sun May 03 17:00:00 2020 PDT | 1 | 22.7272727272727 Sun May 03 17:00:00 2020 PDT | 2 | 15.811320754717 Sun May 03 17:00:00 2020 PDT | 3 | 19 \set ON_ERROR_STOP 0 -- REFRESH MATERIALIZED VIEW is blocked on continuous aggregates REFRESH MATERIALIZED VIEW weekly_temp_without_data; psql:include/cagg_refresh_common.sql:287: ERROR: operation not supported on continuous aggregate -- These should fail since we do not allow refreshing inside a -- transaction, not even as part of CREATE MATERIALIZED VIEW. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; END $$; psql:include/cagg_refresh_common.sql:299: ERROR: CREATE MATERIALIZED VIEW ... WITH DATA cannot be executed from a function BEGIN; CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; psql:include/cagg_refresh_common.sql:308: ERROR: CREATE MATERIALIZED VIEW ... WITH DATA cannot run inside a transaction block COMMIT; \set ON_ERROR_STOP 1 -- This should not fail since we do not refresh the continuous -- aggregate. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; END $$; BEGIN; CREATE MATERIALIZED VIEW weekly_conditions_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; COMMIT; -- refresh_continuous_aggregate can run two transactions, thus it cannot be -- called in a transaction block (from a function, from dynamic SQL) or in a -- subtransaction (from a procedure block with an EXCEPTION clause). Though it -- does NOT require a top level context and can be called from a procedure -- block without an EXCEPTION clause. -- DO block DO $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; psql:include/cagg_refresh_common.sql:345: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Procedure without subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_normal() LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CALL refresh_cagg_proc_normal(); psql:include/cagg_refresh_common.sql:355: NOTICE: continuous aggregate "daily_temp" is already up-to-date \set ON_ERROR_STOP 0 -- Procedure with subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_subtransaction() LANGUAGE PLPGSQL AS $$ DECLARE errmsg TEXT; BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS errmsg = MESSAGE_TEXT; RAISE EXCEPTION '%', errmsg; END; $$; CALL refresh_cagg_proc_subtransaction(); psql:include/cagg_refresh_common.sql:372: ERROR: refresh_continuous_aggregate() cannot run inside a transaction block -- Function CREATE OR REPLACE FUNCTION refresh_cagg_fun() RETURNS INT LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); RETURN 1; END; $$; SELECT * from refresh_cagg_fun(); psql:include/cagg_refresh_common.sql:383: ERROR: refresh_continuous_aggregate() cannot be executed from a function -- Dynamic SQL DO $$ BEGIN EXECUTE $inner$ CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); $inner$; END; $$; psql:include/cagg_refresh_common.sql:391: ERROR: refresh_continuous_aggregate() cannot be executed from a function -- Trigger CREATE TABLE refresh_cagg_trigger_table(a int); CREATE FUNCTION refresh_cagg_trigger_fun() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CREATE TRIGGER refresh_cagg_trigger AFTER INSERT ON refresh_cagg_trigger_table EXECUTE FUNCTION refresh_cagg_trigger_fun(); INSERT INTO refresh_cagg_trigger_table VALUES(1); psql:include/cagg_refresh_common.sql:405: ERROR: refresh_continuous_aggregate() cannot be executed from a function \set ON_ERROR_STOP 1 -- check that cagg refresh is not blocked by decompression limit CREATE TABLE conditions_decompress_limit (time timestamptz NOT NULL, device text, temp float) WITH (tsdb.hypertable, tsdb.partition_column='time'); INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 1.0 FROM generate_series(1,100) g(i); CREATE MATERIALIZED VIEW daily_temp_decompress_limit WITH (tsdb.continuous) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_decompress_limit GROUP BY 1,2 WITH NO DATA; ALTER MATERIALIZED VIEW daily_temp_decompress_limit SET (tsdb.columnstore,tsdb.segmentby = 'device'); psql:include/cagg_refresh_common.sql:413: NOTICE: defaulting compress_orderby to day CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SELECT compress_chunk(show_chunks('daily_temp_decompress_limit')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_26_chunk INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 2.0 FROM generate_series(1,100) g(i); SET timescaledb.max_tuples_decompressed_per_dml_transaction TO 1; CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SHOW timescaledb.max_tuples_decompressed_per_dml_transaction; timescaledb.max_tuples_decompressed_per_dml_transaction --------------------------------------------------------- 1 -- More tests for forceful refreshment TRUNCATE conditions; INSERT INTO conditions VALUES -- daily bucket 2025-07-04 10:00:00+00 ('2025-07-04 10:00:00+00', 1, 1), ('2025-07-04 10:05:00+00', 1, 1), -- daily bucket 2025-07-04 11:00:00+00 ('2025-07-04 11:00:00+00', 1, 1), ('2025-07-04 11:05:00+00', 1, 1), -- daily bucket 2025-07-04 12:00:00+00 ('2025-07-04 12:00:00+00', 1, 1), ('2025-07-04 12:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, -- Fixed bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_hour ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Fri Jul 04 03:00:00 2025 PDT | 1 | 1 | 1 | 2 Fri Jul 04 04:00:00 2025 PDT | 1 | 1 | 1 | 2 CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_hour ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Fri Jul 04 03:00:00 2025 PDT | 1 | 1 | 1 | 2 Fri Jul 04 04:00:00 2025 PDT | 1 | 1 | 1 | 2 -- Monthly buckets INSERT INTO conditions VALUES -- monthly bucket 2025-05-01 00:00:00+00 ('2025-05-04 10:00:00+00', 1, 1), ('2025-05-04 10:05:00+00', 1, 1), -- monthly bucket 2025-06-01 00:00:00+00 ('2025-06-04 11:00:00+00', 1, 1), ('2025-06-04 11:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_month WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, -- Variable bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_month ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Wed Apr 30 17:00:00 2025 PDT | 1 | 1 | 1 | 2 Sat May 31 17:00:00 2025 PDT | 1 | 1 | 1 | 2 CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_month ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Wed Apr 30 17:00:00 2025 PDT | 1 | 1 | 1 | 2 Sat May 31 17:00:00 2025 PDT | 1 | 1 | 1 | 2 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_refresh_using_wal.out�������������������������������������0000664�0000000�0000000�00000073306�15100345067�0024666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; SET timescaledb.enable_cagg_wal_based_invalidation TO true; \ir include/cagg_refresh_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions (time timestamptz NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time'); create_hypertable ------------------------- (1,public,conditions,t) -- Test refresh on a cagg built on an empty table CREATE MATERIALIZED VIEW daily_temp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); psql:include/cagg_refresh_common.sql:17: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', NULL, NULL, force => true); psql:include/cagg_refresh_common.sql:18: NOTICE: continuous aggregate "daily_temp" is already up-to-date SELECT setseed(.12); setseed --------- INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(t::timestamp))%4)::int, abs(timestamp_hash(t::timestamp))%40 FROM generate_series('2020-05-01', '2020-05-05', '10 minutes'::interval) t; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; time | device | temp ------------------------------+--------+------ Tue May 05 00:00:00 2020 PDT | 2 | 30 Mon May 04 23:50:00 2020 PDT | 2 | 10 Mon May 04 23:40:00 2020 PDT | 0 | 20 Mon May 04 23:30:00 2020 PDT | 1 | 1 Mon May 04 23:20:00 2020 PDT | 2 | 34 Mon May 04 23:10:00 2020 PDT | 1 | 37 Mon May 04 23:00:00 2020 PDT | 0 | 4 Mon May 04 22:50:00 2020 PDT | 2 | 10 Mon May 04 22:40:00 2020 PDT | 1 | 37 Mon May 04 22:30:00 2020 PDT | 0 | 8 -- The continuous aggregate should be empty SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp -----+--------+---------- -- Refresh one bucket (1 day): SHOW timezone; TimeZone ---------- PST8PDT -- The refresh of a single bucket must align with the start of the day -- in the bucket's time zone (which is UTC, since time_bucket doesn't -- support time zone arg) CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 17:00 PDT', '2020-05-04 17:00 PDT'); \set ON_ERROR_STOP 0 \set VERBOSITY default -- These refreshes will fail since they don't align with the bucket's -- time zone CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-04'); psql:include/cagg_refresh_common.sql:47: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 PDT', '2020-05-04 00:00 PDT'); psql:include/cagg_refresh_common.sql:48: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. -- Refresh window less than one bucket CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-03 23:59 UTC'); psql:include/cagg_refresh_common.sql:51: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. -- Refresh window bigger than one bucket, but failing since it is not -- aligned with bucket boundaries so that it covers a full bucket: -- -- Refresh window: [----------) -- Buckets: [------|------] CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 01:00 UTC', '2020-05-04 08:00 UTC'); psql:include/cagg_refresh_common.sql:57: ERROR: refresh window too small DETAIL: The refresh window must cover at least one bucket of data. HINT: Align the refresh window with the bucket time zone or use at least two buckets. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Refresh the most recent few days: CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 -- Refresh the rest CALL refresh_continuous_aggregate('daily_temp', '2020-04-30', '2020-05-04'); -- Compare the aggregate to the equivalent query on the source table SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 Fri May 01 17:00:00 2020 PDT | 0 | 19 Fri May 01 17:00:00 2020 PDT | 1 | 15.1463414634146 Fri May 01 17:00:00 2020 PDT | 2 | 19.7674418604651 Fri May 01 17:00:00 2020 PDT | 3 | 22.25 Thu Apr 30 17:00:00 2020 PDT | 0 | 17.6666666666667 Thu Apr 30 17:00:00 2020 PDT | 1 | 18.8333333333333 Thu Apr 30 17:00:00 2020 PDT | 2 | 16.7586206896552 Thu Apr 30 17:00:00 2020 PDT | 3 | 20.76 SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 ORDER BY 1 DESC,2; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 Fri May 01 17:00:00 2020 PDT | 0 | 19 Fri May 01 17:00:00 2020 PDT | 1 | 15.1463414634146 Fri May 01 17:00:00 2020 PDT | 2 | 19.7674418604651 Fri May 01 17:00:00 2020 PDT | 3 | 22.25 Thu Apr 30 17:00:00 2020 PDT | 0 | 17.6666666666667 Thu Apr 30 17:00:00 2020 PDT | 1 | 18.8333333333333 Thu Apr 30 17:00:00 2020 PDT | 2 | 16.7586206896552 Thu Apr 30 17:00:00 2020 PDT | 3 | 20.76 -- Test unusual, but valid input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::timestamptz, '2020-05-03'::date); psql:include/cagg_refresh_common.sql:80: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::date, '2020-05-03'::date); psql:include/cagg_refresh_common.sql:81: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Unbounded window forward in time CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', NULL); psql:include/cagg_refresh_common.sql:84: NOTICE: continuous aggregate "daily_temp" is already up-to-date CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); -- Unbounded window back in time CALL refresh_continuous_aggregate('daily_temp', NULL, '2020-05-01'); psql:include/cagg_refresh_common.sql:88: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Test bad input \set ON_ERROR_STOP 0 -- Bad continuous aggregate name CALL refresh_continuous_aggregate(NULL, '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:93: ERROR: invalid continuous aggregate CALL refresh_continuous_aggregate('xyz', '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:94: ERROR: relation "xyz" does not exist at character 35 -- Valid object, but not a continuous aggregate CALL refresh_continuous_aggregate('conditions', '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:96: ERROR: relation "conditions" is not a continuous aggregate -- Object ID with no object CALL refresh_continuous_aggregate(1, '2020-05-03', '2020-05-05'); psql:include/cagg_refresh_common.sql:98: ERROR: continuous aggregate does not exist -- Lacking arguments CALL refresh_continuous_aggregate('daily_temp'); psql:include/cagg_refresh_common.sql:100: ERROR: procedure refresh_continuous_aggregate(unknown) does not exist at character 6 CALL refresh_continuous_aggregate('daily_temp', '2020-05-03'); psql:include/cagg_refresh_common.sql:101: ERROR: procedure refresh_continuous_aggregate(unknown, unknown) does not exist at character 6 -- Bad time ranges CALL refresh_continuous_aggregate('daily_temp', 'xyz', '2020-05-05'); psql:include/cagg_refresh_common.sql:103: ERROR: invalid input syntax for type timestamp with time zone: "xyz" CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', 'xyz'); psql:include/cagg_refresh_common.sql:104: ERROR: invalid input syntax for type timestamp with time zone: "xyz" CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-01'); psql:include/cagg_refresh_common.sql:105: ERROR: refresh window too small -- Bad time input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::text, '2020-05-03'::text); psql:include/cagg_refresh_common.sql:107: ERROR: invalid time argument type "text" CALL refresh_continuous_aggregate('daily_temp', 0, '2020-05-01'); psql:include/cagg_refresh_common.sql:108: ERROR: invalid time argument type "integer" \set ON_ERROR_STOP 1 -- Test forceful refreshment. Here we simulate the situation that we've seen -- with tiered data when `timescaledb.enable_tiered_reads` were disabled on the -- server level. In that case we would not see materialized tiered data and -- we wouldn't be able to re-materialize the data using a normal refresh call -- because it would skip previously materialized ranges, but it should be -- possible with `force=>true` parameter. To simulate this use-case we clear -- the materialization hypertable and forefully re-materialize it. SELECT format('%I.%I', ht.schema_name, ht.table_name) AS mat_ht, mat_hypertable_id FROM _timescaledb_catalog.continuous_agg cagg JOIN _timescaledb_catalog.hypertable ht ON cagg.mat_hypertable_id = ht.id WHERE user_view_name = 'daily_temp' \gset -- Delete the data from the materialization hypertable DELETE FROM :mat_ht; -- Run regular refresh, it should not touch previously materialized range CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); psql:include/cagg_refresh_common.sql:126: NOTICE: continuous aggregate "daily_temp" is already up-to-date SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp -----+--------+---------- -- Run it again with force=>true, the data should be rematerialized CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00', force=>true); SELECT * FROM daily_temp ORDER BY day DESC, device; day | device | avg_temp ------------------------------+--------+------------------ Mon May 04 17:00:00 2020 PDT | 0 | 19.3846153846154 Mon May 04 17:00:00 2020 PDT | 1 | 16.5555555555556 Mon May 04 17:00:00 2020 PDT | 2 | 18.5714285714286 Mon May 04 17:00:00 2020 PDT | 3 | 23.5714285714286 Sun May 03 17:00:00 2020 PDT | 0 | 15.7647058823529 Sun May 03 17:00:00 2020 PDT | 1 | 24.3142857142857 Sun May 03 17:00:00 2020 PDT | 2 | 14.8205128205128 Sun May 03 17:00:00 2020 PDT | 3 | 18.1111111111111 Sat May 02 17:00:00 2020 PDT | 0 | 17 Sat May 02 17:00:00 2020 PDT | 1 | 18.75 Sat May 02 17:00:00 2020 PDT | 2 | 20 Sat May 02 17:00:00 2020 PDT | 3 | 21.5217391304348 -- Test different time types CREATE TABLE conditions_date (time date NOT NULL, device int, temp float); SELECT create_hypertable('conditions_date', 'time'); create_hypertable ------------------------------ (3,public,conditions_date,t) CREATE MATERIALIZED VIEW daily_temp_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_date GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp_date', '2020-05-01', '2020-05-03'); -- Try max refresh window size CALL refresh_continuous_aggregate('daily_temp_date', NULL, NULL); -- Test smallint-based continuous aggregate CREATE TABLE conditions_smallint (time smallint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_smallint', 'time', chunk_time_interval => 20); create_hypertable ---------------------------------- (5,public,conditions_smallint,t) INSERT INTO conditions_smallint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::smallint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM conditions_smallint $$; \set ON_ERROR_STOP 0 -- First try to create an integer-based continuous aggregate without -- an now function. This should not be allowed. CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; psql:include/cagg_refresh_common.sql:175: ERROR: custom time function required on hypertable "conditions_smallint" \set ON_ERROR_STOP 1 SELECT set_integer_now_func('conditions_smallint', 'smallint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_smallint', 0::smallint, 70::smallint); SELECT * FROM cond_20_smallint ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_smallint', NULL, NULL); -- Test int-based continuous aggregate CREATE TABLE conditions_int (time int NOT NULL, device int, temp float); SELECT create_hypertable('conditions_int', 'time', chunk_time_interval => 20); create_hypertable ----------------------------- (7,public,conditions_int,t) INSERT INTO conditions_int SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions_int $$; SELECT set_integer_now_func('conditions_int', 'int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_int GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_int', 0, 65); SELECT * FROM cond_20_int ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_int', NULL, NULL); -- Test bigint-based continuous aggregate CREATE TABLE conditions_bigint (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_bigint', 'time', chunk_time_interval => 20); create_hypertable -------------------------------- (9,public,conditions_bigint,t) INSERT INTO conditions_bigint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::bigint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM conditions_bigint $$; SELECT set_integer_now_func('conditions_bigint', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cond_20_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_bigint GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_bigint', 0, 75); SELECT * FROM cond_20_bigint ORDER BY 1,2; bucket | device | avg_temp --------+--------+------------------ 0 | 0 | 6 0 | 1 | 19 0 | 2 | 14.5 0 | 3 | 21.4 20 | 0 | 15 20 | 1 | 16 20 | 2 | 23.3333333333333 20 | 3 | 13.6666666666667 40 | 0 | 21 40 | 1 | 19.4 40 | 2 | 22 40 | 3 | 21.4 -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_bigint', NULL, NULL); -- Test that WITH NO DATA and WITH DATA works (we use whatever is the -- default for Postgres, so we do not need to have test for the -- default). CREATE MATERIALIZED VIEW weekly_temp_without_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW weekly_temp_with_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; psql:include/cagg_refresh_common.sql:280: NOTICE: refreshing continuous aggregate "weekly_temp_with_data" SELECT * FROM weekly_temp_without_data; day | device | avg_temp -----+--------+---------- SELECT * FROM weekly_temp_with_data ORDER BY 1,2; day | device | avg_temp ------------------------------+--------+------------------ Sun Apr 26 17:00:00 2020 PDT | 0 | 17.8181818181818 Sun Apr 26 17:00:00 2020 PDT | 1 | 17.2474226804124 Sun Apr 26 17:00:00 2020 PDT | 2 | 18.9803921568627 Sun Apr 26 17:00:00 2020 PDT | 3 | 21.5631067961165 Sun May 03 17:00:00 2020 PDT | 0 | 16.7659574468085 Sun May 03 17:00:00 2020 PDT | 1 | 22.7272727272727 Sun May 03 17:00:00 2020 PDT | 2 | 15.811320754717 Sun May 03 17:00:00 2020 PDT | 3 | 19 \set ON_ERROR_STOP 0 -- REFRESH MATERIALIZED VIEW is blocked on continuous aggregates REFRESH MATERIALIZED VIEW weekly_temp_without_data; psql:include/cagg_refresh_common.sql:287: ERROR: operation not supported on continuous aggregate -- These should fail since we do not allow refreshing inside a -- transaction, not even as part of CREATE MATERIALIZED VIEW. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; END $$; psql:include/cagg_refresh_common.sql:299: ERROR: CREATE MATERIALIZED VIEW ... WITH DATA cannot be executed from a function BEGIN; CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; psql:include/cagg_refresh_common.sql:308: ERROR: CREATE MATERIALIZED VIEW ... WITH DATA cannot run inside a transaction block COMMIT; \set ON_ERROR_STOP 1 -- This should not fail since we do not refresh the continuous -- aggregate. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; END $$; BEGIN; CREATE MATERIALIZED VIEW weekly_conditions_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; COMMIT; -- refresh_continuous_aggregate can run two transactions, thus it cannot be -- called in a transaction block (from a function, from dynamic SQL) or in a -- subtransaction (from a procedure block with an EXCEPTION clause). Though it -- does NOT require a top level context and can be called from a procedure -- block without an EXCEPTION clause. -- DO block DO $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; psql:include/cagg_refresh_common.sql:345: NOTICE: continuous aggregate "daily_temp" is already up-to-date -- Procedure without subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_normal() LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CALL refresh_cagg_proc_normal(); psql:include/cagg_refresh_common.sql:355: NOTICE: continuous aggregate "daily_temp" is already up-to-date \set ON_ERROR_STOP 0 -- Procedure with subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_subtransaction() LANGUAGE PLPGSQL AS $$ DECLARE errmsg TEXT; BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS errmsg = MESSAGE_TEXT; RAISE EXCEPTION '%', errmsg; END; $$; CALL refresh_cagg_proc_subtransaction(); psql:include/cagg_refresh_common.sql:372: ERROR: refresh_continuous_aggregate() cannot run inside a transaction block -- Function CREATE OR REPLACE FUNCTION refresh_cagg_fun() RETURNS INT LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); RETURN 1; END; $$; SELECT * from refresh_cagg_fun(); psql:include/cagg_refresh_common.sql:383: ERROR: refresh_continuous_aggregate() cannot be executed from a function -- Dynamic SQL DO $$ BEGIN EXECUTE $inner$ CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); $inner$; END; $$; psql:include/cagg_refresh_common.sql:391: ERROR: refresh_continuous_aggregate() cannot be executed from a function -- Trigger CREATE TABLE refresh_cagg_trigger_table(a int); CREATE FUNCTION refresh_cagg_trigger_fun() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CREATE TRIGGER refresh_cagg_trigger AFTER INSERT ON refresh_cagg_trigger_table EXECUTE FUNCTION refresh_cagg_trigger_fun(); INSERT INTO refresh_cagg_trigger_table VALUES(1); psql:include/cagg_refresh_common.sql:405: ERROR: refresh_continuous_aggregate() cannot be executed from a function \set ON_ERROR_STOP 1 -- check that cagg refresh is not blocked by decompression limit CREATE TABLE conditions_decompress_limit (time timestamptz NOT NULL, device text, temp float) WITH (tsdb.hypertable, tsdb.partition_column='time'); INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 1.0 FROM generate_series(1,100) g(i); CREATE MATERIALIZED VIEW daily_temp_decompress_limit WITH (tsdb.continuous) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_decompress_limit GROUP BY 1,2 WITH NO DATA; ALTER MATERIALIZED VIEW daily_temp_decompress_limit SET (tsdb.columnstore,tsdb.segmentby = 'device'); psql:include/cagg_refresh_common.sql:413: NOTICE: defaulting compress_orderby to day CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SELECT compress_chunk(show_chunks('daily_temp_decompress_limit')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_26_chunk INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 2.0 FROM generate_series(1,100) g(i); SET timescaledb.max_tuples_decompressed_per_dml_transaction TO 1; CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SHOW timescaledb.max_tuples_decompressed_per_dml_transaction; timescaledb.max_tuples_decompressed_per_dml_transaction --------------------------------------------------------- 1 -- More tests for forceful refreshment TRUNCATE conditions; INSERT INTO conditions VALUES -- daily bucket 2025-07-04 10:00:00+00 ('2025-07-04 10:00:00+00', 1, 1), ('2025-07-04 10:05:00+00', 1, 1), -- daily bucket 2025-07-04 11:00:00+00 ('2025-07-04 11:00:00+00', 1, 1), ('2025-07-04 11:05:00+00', 1, 1), -- daily bucket 2025-07-04 12:00:00+00 ('2025-07-04 12:00:00+00', 1, 1), ('2025-07-04 12:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, -- Fixed bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_hour ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Fri Jul 04 03:00:00 2025 PDT | 1 | 1 | 1 | 2 Fri Jul 04 04:00:00 2025 PDT | 1 | 1 | 1 | 2 CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_hour ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Fri Jul 04 03:00:00 2025 PDT | 1 | 1 | 1 | 2 Fri Jul 04 04:00:00 2025 PDT | 1 | 1 | 1 | 2 -- Monthly buckets INSERT INTO conditions VALUES -- monthly bucket 2025-05-01 00:00:00+00 ('2025-05-04 10:00:00+00', 1, 1), ('2025-05-04 10:05:00+00', 1, 1), -- monthly bucket 2025-06-01 00:00:00+00 ('2025-06-04 11:00:00+00', 1, 1), ('2025-06-04 11:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_month WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, -- Variable bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_month ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Wed Apr 30 17:00:00 2025 PDT | 1 | 1 | 1 | 2 Sat May 31 17:00:00 2025 PDT | 1 | 1 | 1 | 2 CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_month ORDER BY bucket; bucket | device | max | min | count ------------------------------+--------+-----+-----+------- Wed Apr 30 17:00:00 2025 PDT | 1 | 1 | 1 | 2 Sat May 31 17:00:00 2025 PDT | 1 | 1 | 1 | 2 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_repair-15.out���������������������������������������������0000664�0000000�0000000�00000037746�15100345067�0022675�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; CREATE PROCEDURE _timescaledb_internal.cagg_try_repair ( cagg_view REGCLASS, force_rebuild BOOLEAN ) AS :MODULE_PATHNAME, 'ts_cagg_try_repair' LANGUAGE C SET client_min_messages TO DEBUG1; CREATE TABLE conditions ( "time" TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INTEGER NOT NULL, device_id INTEGER NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions INSERT INTO conditions ("time", city, temperature, device_id) VALUES ('2021-06-14 00:00:00-00', 'Moscow', 26,1), ('2021-06-15 00:00:00-00', 'Berlin', 22,2), ('2021-06-16 00:00:00-00', 'Stockholm', 24,3), ('2021-06-17 00:00:00-00', 'London', 24,4), ('2021-06-18 00:00:00-00', 'London', 27,4), ('2021-06-19 00:00:00-00', 'Moscow', 28,4), ('2021-06-20 00:00:00-00', 'Moscow', 30,1), ('2021-06-21 00:00:00-00', 'Berlin', 31,1), ('2021-06-22 00:00:00-00', 'Stockholm', 34,1), ('2021-06-23 00:00:00-00', 'Stockholm', 34,2), ('2021-06-24 00:00:00-00', 'Moscow', 34,2), ('2021-06-25 00:00:00-00', 'London', 32,3), ('2021-06-26 00:00:00-00', 'Moscow', 32,3), ('2021-06-27 00:00:00-00', 'Moscow', 31,3); CREATE TABLE devices ( id INTEGER NOT NULL, name TEXT, location TEXT ); INSERT INTO devices (id, name, location) VALUES (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'), (3, 'thermo_3', 'London'), (4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, devices.name AS device_name, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions JOIN devices ON devices.id = conditions.device_id GROUP BY 1, 2 WITH NO DATA; \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2; CALL refresh_continuous_aggregate('conditions_summary', NULL, '2021-06-22 00:00:00-00'); SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Execute repair for materialized only cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Switch to realtime cagg ALTER MATERIALIZED VIEW conditions_summary SET (timescaledb.materialized_only=false); \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Execute repair for realtime cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Tests without join CREATE MATERIALIZED VIEW conditions_summary_nojoin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions GROUP BY 1 WITH NO DATA; CALL _timescaledb_internal.cagg_try_repair('conditions_summary_nojoin', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary_nojoin does not have JOINS, so no need to rebuild the definition! \d+ conditions_summary_nojoin View "public.conditions_summary_nojoin" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_3.bucket, _materialized_hypertable_3.min, _materialized_hypertable_3.max, _materialized_hypertable_3.sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE _materialized_hypertable_3.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")); DROP PROCEDURE _timescaledb_internal.cagg_try_repair (REGCLASS, BOOLEAN); ��������������������������timescaledb-2.23.0/tsl/test/expected/cagg_repair-16.out���������������������������������������������0000664�0000000�0000000�00000037121�15100345067�0022661�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; CREATE PROCEDURE _timescaledb_internal.cagg_try_repair ( cagg_view REGCLASS, force_rebuild BOOLEAN ) AS :MODULE_PATHNAME, 'ts_cagg_try_repair' LANGUAGE C SET client_min_messages TO DEBUG1; CREATE TABLE conditions ( "time" TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INTEGER NOT NULL, device_id INTEGER NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions INSERT INTO conditions ("time", city, temperature, device_id) VALUES ('2021-06-14 00:00:00-00', 'Moscow', 26,1), ('2021-06-15 00:00:00-00', 'Berlin', 22,2), ('2021-06-16 00:00:00-00', 'Stockholm', 24,3), ('2021-06-17 00:00:00-00', 'London', 24,4), ('2021-06-18 00:00:00-00', 'London', 27,4), ('2021-06-19 00:00:00-00', 'Moscow', 28,4), ('2021-06-20 00:00:00-00', 'Moscow', 30,1), ('2021-06-21 00:00:00-00', 'Berlin', 31,1), ('2021-06-22 00:00:00-00', 'Stockholm', 34,1), ('2021-06-23 00:00:00-00', 'Stockholm', 34,2), ('2021-06-24 00:00:00-00', 'Moscow', 34,2), ('2021-06-25 00:00:00-00', 'London', 32,3), ('2021-06-26 00:00:00-00', 'Moscow', 32,3), ('2021-06-27 00:00:00-00', 'Moscow', 31,3); CREATE TABLE devices ( id INTEGER NOT NULL, name TEXT, location TEXT ); INSERT INTO devices (id, name, location) VALUES (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'), (3, 'thermo_3', 'London'), (4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, devices.name AS device_name, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions JOIN devices ON devices.id = conditions.device_id GROUP BY 1, 2 WITH NO DATA; \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; CALL refresh_continuous_aggregate('conditions_summary', NULL, '2021-06-22 00:00:00-00'); SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Execute repair for materialized only cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Switch to realtime cagg ALTER MATERIALIZED VIEW conditions_summary SET (timescaledb.materialized_only=false); \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Execute repair for realtime cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Tests without join CREATE MATERIALIZED VIEW conditions_summary_nojoin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions GROUP BY 1 WITH NO DATA; CALL _timescaledb_internal.cagg_try_repair('conditions_summary_nojoin', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary_nojoin does not have JOINS, so no need to rebuild the definition! \d+ conditions_summary_nojoin View "public.conditions_summary_nojoin" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_3.bucket, _materialized_hypertable_3.min, _materialized_hypertable_3.max, _materialized_hypertable_3.sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE _materialized_hypertable_3.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")); DROP PROCEDURE _timescaledb_internal.cagg_try_repair (REGCLASS, BOOLEAN); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_repair-17.out���������������������������������������������0000664�0000000�0000000�00000037121�15100345067�0022662�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; CREATE PROCEDURE _timescaledb_internal.cagg_try_repair ( cagg_view REGCLASS, force_rebuild BOOLEAN ) AS :MODULE_PATHNAME, 'ts_cagg_try_repair' LANGUAGE C SET client_min_messages TO DEBUG1; CREATE TABLE conditions ( "time" TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INTEGER NOT NULL, device_id INTEGER NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions INSERT INTO conditions ("time", city, temperature, device_id) VALUES ('2021-06-14 00:00:00-00', 'Moscow', 26,1), ('2021-06-15 00:00:00-00', 'Berlin', 22,2), ('2021-06-16 00:00:00-00', 'Stockholm', 24,3), ('2021-06-17 00:00:00-00', 'London', 24,4), ('2021-06-18 00:00:00-00', 'London', 27,4), ('2021-06-19 00:00:00-00', 'Moscow', 28,4), ('2021-06-20 00:00:00-00', 'Moscow', 30,1), ('2021-06-21 00:00:00-00', 'Berlin', 31,1), ('2021-06-22 00:00:00-00', 'Stockholm', 34,1), ('2021-06-23 00:00:00-00', 'Stockholm', 34,2), ('2021-06-24 00:00:00-00', 'Moscow', 34,2), ('2021-06-25 00:00:00-00', 'London', 32,3), ('2021-06-26 00:00:00-00', 'Moscow', 32,3), ('2021-06-27 00:00:00-00', 'Moscow', 31,3); CREATE TABLE devices ( id INTEGER NOT NULL, name TEXT, location TEXT ); INSERT INTO devices (id, name, location) VALUES (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'), (3, 'thermo_3', 'London'), (4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, devices.name AS device_name, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions JOIN devices ON devices.id = conditions.device_id GROUP BY 1, 2 WITH NO DATA; \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; CALL refresh_continuous_aggregate('conditions_summary', NULL, '2021-06-22 00:00:00-00'); SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Execute repair for materialized only cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Switch to realtime cagg ALTER MATERIALIZED VIEW conditions_summary SET (timescaledb.materialized_only=false); \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Execute repair for realtime cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Tests without join CREATE MATERIALIZED VIEW conditions_summary_nojoin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions GROUP BY 1 WITH NO DATA; CALL _timescaledb_internal.cagg_try_repair('conditions_summary_nojoin', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary_nojoin does not have JOINS, so no need to rebuild the definition! \d+ conditions_summary_nojoin View "public.conditions_summary_nojoin" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_3.bucket, _materialized_hypertable_3.min, _materialized_hypertable_3.max, _materialized_hypertable_3.sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE _materialized_hypertable_3.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")); DROP PROCEDURE _timescaledb_internal.cagg_try_repair (REGCLASS, BOOLEAN); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_repair-18.out���������������������������������������������0000664�0000000�0000000�00000037121�15100345067�0022663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; CREATE PROCEDURE _timescaledb_internal.cagg_try_repair ( cagg_view REGCLASS, force_rebuild BOOLEAN ) AS :MODULE_PATHNAME, 'ts_cagg_try_repair' LANGUAGE C SET client_min_messages TO DEBUG1; CREATE TABLE conditions ( "time" TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INTEGER NOT NULL, device_id INTEGER NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time'); table_name ------------ conditions INSERT INTO conditions ("time", city, temperature, device_id) VALUES ('2021-06-14 00:00:00-00', 'Moscow', 26,1), ('2021-06-15 00:00:00-00', 'Berlin', 22,2), ('2021-06-16 00:00:00-00', 'Stockholm', 24,3), ('2021-06-17 00:00:00-00', 'London', 24,4), ('2021-06-18 00:00:00-00', 'London', 27,4), ('2021-06-19 00:00:00-00', 'Moscow', 28,4), ('2021-06-20 00:00:00-00', 'Moscow', 30,1), ('2021-06-21 00:00:00-00', 'Berlin', 31,1), ('2021-06-22 00:00:00-00', 'Stockholm', 34,1), ('2021-06-23 00:00:00-00', 'Stockholm', 34,2), ('2021-06-24 00:00:00-00', 'Moscow', 34,2), ('2021-06-25 00:00:00-00', 'London', 32,3), ('2021-06-26 00:00:00-00', 'Moscow', 32,3), ('2021-06-27 00:00:00-00', 'Moscow', 31,3); CREATE TABLE devices ( id INTEGER NOT NULL, name TEXT, location TEXT ); INSERT INTO devices (id, name, location) VALUES (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'), (3, 'thermo_3', 'London'), (4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, devices.name AS device_name, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions JOIN devices ON devices.id = conditions.device_id GROUP BY 1, 2 WITH NO DATA; \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; CALL refresh_continuous_aggregate('conditions_summary', NULL, '2021-06-22 00:00:00-00'); SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Execute repair for materialized only cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT bucket, device_name, min, max, sum FROM _timescaledb_internal._materialized_hypertable_2; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 -- Switch to realtime cagg ALTER MATERIALIZED VIEW conditions_summary SET (timescaledb.materialized_only=false); \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Execute repair for realtime cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary does not have partials, do not check for defects! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary has been rebuilt! \d+ conditions_summary View "public.conditions_summary" Column | Type | Collation | Nullable | Default | Storage | Description -------------+--------------------------+-----------+----------+---------+----------+------------- bucket | timestamp with time zone | | | | plain | device_name | text | | | | extended | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.device_name, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE _materialized_hypertable_2.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, devices.name AS device_name, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions JOIN devices ON devices.id = conditions.device_id WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")), devices.name; SELECT * FROM conditions_summary ORDER BY bucket, device_name; bucket | device_name | min | max | sum ------------------------------+-------------+-----+-----+----- Sun Jun 13 17:00:00 2021 PDT | thermo_1 | 26 | 30 | 56 Sun Jun 13 17:00:00 2021 PDT | thermo_2 | 22 | 22 | 22 Sun Jun 13 17:00:00 2021 PDT | thermo_3 | 24 | 24 | 24 Sun Jun 13 17:00:00 2021 PDT | thermo_4 | 24 | 28 | 79 Sun Jun 20 17:00:00 2021 PDT | thermo_1 | 31 | 34 | 65 Sun Jun 20 17:00:00 2021 PDT | thermo_2 | 34 | 34 | 68 Sun Jun 20 17:00:00 2021 PDT | thermo_3 | 31 | 32 | 95 -- Tests without join CREATE MATERIALIZED VIEW conditions_summary_nojoin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions GROUP BY 1 WITH NO DATA; CALL _timescaledb_internal.cagg_try_repair('conditions_summary_nojoin', TRUE); DEBUG: [cagg_rebuild_view_definition] public.conditions_summary_nojoin does not have JOINS, so no need to rebuild the definition! \d+ conditions_summary_nojoin View "public.conditions_summary_nojoin" Column | Type | Collation | Nullable | Default | Storage | Description --------+--------------------------+-----------+----------+---------+---------+------------- bucket | timestamp with time zone | | | | plain | min | integer | | | | plain | max | integer | | | | plain | sum | bigint | | | | plain | View definition: SELECT _materialized_hypertable_3.bucket, _materialized_hypertable_3.min, _materialized_hypertable_3.max, _materialized_hypertable_3.sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE _materialized_hypertable_3.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, sum(conditions.temperature) AS sum FROM conditions WHERE conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 7 days'::interval, conditions."time")); DROP PROCEDURE _timescaledb_internal.cagg_try_repair (REGCLASS, BOOLEAN); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_tableam.out�����������������������������������������������0000664�0000000�0000000�00000006412�15100345067�0022557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, relname AS mat_table, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), bigint '0') FROM whatever $$; SELECT set_integer_now_func('whatever', 'integer_now_test'); set_integer_now_func ---------------------- INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; -- Checking that the access method for the materialized hypertable is -- set to the correct access method. CREATE MATERIALIZED VIEW tableam_view USING heap2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW notableam_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; SELECT user_view, mat_table, amname FROM cagg_info, LATERAL (SELECT relam FROM pg_class WHERE relname = mat_table) AS cls, LATERAL (SELECT amname FROM pg_am WHERE oid = relam) AS am WHERE user_view::text IN ('tableam_view', 'notableam_view'); user_view | mat_table | amname ----------------+----------------------------+-------- tableam_view | _materialized_hypertable_2 | heap2 notableam_view | _materialized_hypertable_3 | heap -- Check that the view with the other access method actually works. SELECT * FROM notableam_view ORDER BY 1; time_bucket | count -------------+------- SELECT * FROM tableam_view ORDER BY 1; time_bucket | count -------------+------- CALL refresh_continuous_aggregate('notableam_view', NULL, NULL); CALL refresh_continuous_aggregate('tableam_view', NULL, NULL); SELECT * FROM notableam_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 15 | 5 20 | 5 25 | 5 SELECT * FROM tableam_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 5 | 5 10 | 5 15 | 5 20 | 5 25 | 5 DROP MATERIALIZED VIEW notableam_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_3_4_chunk DROP MATERIALIZED VIEW tableam_view; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_5_chunk ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_union_view-15.out�����������������������������������������0000664�0000000�0000000�00000131155�15100345067�0023562�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- disable background workers to make results reproducible \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE metrics(f1 int, f2 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN f1; INSERT INTO metrics(time, device_id, value) SELECT '2000-01-01'::timestamptz, device_id, 0.5 FROM generate_series(1,3) g(device_id); -- -- test switching continuous agg view between different modes -- -- check default view for new continuous aggregate CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; ALTER TABLE metrics DROP COLUMN f2; -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view again ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- try upgrade view to union view that is already union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- refresh CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); -- result should not change after refresh for union view SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2; -- view should have results now after refresh SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 DROP MATERIALIZED VIEW metrics_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk -- check default view for new continuous aggregate with materialized_only to true CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_3.time_bucket, + _materialized_hypertable_3.avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_3.time_bucket, + _materialized_hypertable_3.avg + FROM _timescaledb_internal._materialized_hypertable_3 + WHERE _materialized_hypertable_3.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_3.time_bucket, + _materialized_hypertable_3.avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- DROP MATERIALIZED VIEW metrics_summary; -- -- test queries on union view -- CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- should be marked as materialized_only in catalog SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t -- query should not have results since cagg is materialized only and no refresh has happened yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- after switch to union view all results should be returned SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- materialized only view should return data now too because refresh has happened SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- add some more data INSERT INTO metrics(time, device_id, value) SELECT '2000-02-01'::timestamptz, device_id, device_id/10.0 FROM generate_series(1,3) g(device_id); -- materialized only view should not have new data yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- but union view should ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 Mon Jan 31 16:00:00 2000 PST | 0.2 -- and after refresh non union view should have new data too CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-30'); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION boundary_test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; -- test watermark interaction with just in time aggregates CREATE TABLE boundary_test(time int, value float); SELECT create_hypertable('boundary_test','time',chunk_time_interval:=10); create_hypertable ---------------------------- (5,public,boundary_test,t) SELECT set_integer_now_func('boundary_test','boundary_test_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW boundary_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM boundary_test GROUP BY 1 WITH NO DATA; INSERT INTO boundary_test SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); SELECT mat_hypertable_id AS boundary_view_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'boundary_view' \gset -- watermark should be NULL SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- -2147483648 -- first UNION child should have no rows because no materialization has happened yet and 2nd child should have 4 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=4.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=4.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_5_chunk."time") -> Index Scan Backward using _hyper_5_5_chunk_boundary_test_time_idx on _hyper_5_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_6_chunk."time") -> Index Scan Backward using _hyper_5_6_chunk_boundary_test_time_idx on _hyper_5_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- Refresh up to 30 to leave some unmaterialized data at the head and -- thus have something to union. CALL refresh_continuous_aggregate('boundary_view', NULL, 30); -- watermark should be 30 SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- 30 -- both sides of the UNION should return 2 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_6_9_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_9_chunk (actual rows=2.00 loops=1) Index Cond: (time_bucket < 30) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=2.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 ---- TEST union view with WHERE, GROUP BY and HAVING clause ---- create table ht_intdata (a integer, b integer, c integer); select table_name FROM create_hypertable('ht_intdata', 'a', chunk_time_interval=> 10); table_name ------------ ht_intdata INSERT into ht_intdata values( 3 , 16 , 20); INSERT into ht_intdata values( 1 , 10 , 20); INSERT into ht_intdata values( 1 , 11 , 20); INSERT into ht_intdata values( 1 , 12 , 20); INSERT into ht_intdata values( 1 , 13 , 20); INSERT into ht_intdata values( 1 , 14 , 20); INSERT into ht_intdata values( 2 , 14 , 20); INSERT into ht_intdata values( 2 , 15 , 20); INSERT into ht_intdata values( 2 , 16 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 20 , 26 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); CREATE OR REPLACE FUNCTION integer_now_ht_intdata() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM ht_intdata $$; SELECT set_integer_now_func('ht_intdata', 'integer_now_ht_intdata'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb, sumbc, spreadcb, avgc) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 WITH NO DATA; -- Do partial refresh to have something to union CALL refresh_continuous_aggregate('mat_m1', NULL, 11); --results from real time cont.agg and direct query should match SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 --verify that materialized only doesn't have rows with a> 20 ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = true); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ---+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 --again revert the view to include real time aggregates ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = false); INSERT into ht_intdata values( 31 , 15 , 30); INSERT into ht_intdata values( 31 , 14 , 70); --cagg was not refreshed, should include all rows SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 --the selects against mat_m1 before and after refresh should match this query SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_8_12_chunk --- TEST union view with multiple WHERE and HAVING clauses CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 WITH NO DATA; INSERT into ht_intdata values( 42 , 15 , 80); INSERT into ht_intdata values( 42 , 15 , 18); INSERT into ht_intdata values( 41 , 18 , 21); -- Do partial refresh so that we leave data to UNION CALL refresh_continuous_aggregate('mat_m1', NULL, 25); SELECT mat_hypertable_id AS mat_m1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_m1' \gset -- Show the new watermark SELECT _timescaledb_functions.cagg_watermark(:mat_m1_id); cagg_watermark ---------------- 25 -- Data inserted after refresh and after cagg_watermark should be -- reflected in the real-time aggregation INSERT into ht_intdata VALUES (34, 13, 65), (26, 12, 78), (28, 9, 32); --view and direct query should return same results SELECT * from mat_m1 ORDER BY 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 ORDER by 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 -- plan output :PREFIX SELECT * FROM mat_m1 ORDER BY 1; --- QUERY PLAN --- Sort (actual rows=3.00 loops=1) Sort Key: _hyper_9_15_chunk.time_bucket Sort Method: quicksort -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_9_15_chunk__materialized_hypertable_9_time_bucket_idx on _hyper_9_15_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 25) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(5, ht_intdata.a)) Filter: ((sum(ht_intdata.c) > 50) AND ((avg(ht_intdata.b))::integer > 12)) Rows Removed by Filter: 1 -> Merge Append (actual rows=3.00 loops=1) Sort Key: (time_bucket(5, ht_intdata.a)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_11_chunk.a) -> Index Scan Backward using _hyper_7_11_chunk_ht_intdata_a_idx on _hyper_7_11_chunk (actual rows=2.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_13_chunk.a) -> Index Scan Backward using _hyper_7_13_chunk_ht_intdata_a_idx on _hyper_7_13_chunk (actual rows=3.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_14_chunk.a) -> Index Scan Backward using _hyper_7_14_chunk_ht_intdata_a_idx on _hyper_7_14_chunk (actual rows=1.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) Rows Removed by Filter: 2 -- Test caggs with different time types CREATE TABLE smallint_table (time smallint, value int); CREATE TABLE int_table (time int, value int); CREATE TABLE bigint_table (time bigint, value int); CREATE TABLE date_table (time date, value int); CREATE TABLE timestamp_table (time timestamp, value int); CREATE TABLE timestamptz_table (time timestamptz, value int); SELECT create_hypertable('smallint_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------------ (10,public,smallint_table,t) SELECT create_hypertable('int_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------- (11,public,int_table,t) SELECT create_hypertable('bigint_table', 'time', chunk_time_interval=>20); create_hypertable ---------------------------- (12,public,bigint_table,t) SELECT create_hypertable('date_table', 'time'); create_hypertable -------------------------- (13,public,date_table,t) SELECT create_hypertable('timestamp_table', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------------- (14,public,timestamp_table,t) SELECT create_hypertable('timestamptz_table', 'time'); create_hypertable --------------------------------- (15,public,timestamptz_table,t) CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM smallint_table $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM int_table $$; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM bigint_table $$; SELECT set_integer_now_func('smallint_table', 'smallint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('int_table', 'int_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('bigint_table', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW smallint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(SMALLINT '10', time) AS bucket, avg(value) FROM smallint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW int_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, time) AS bucket, avg(value) FROM int_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW bigint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(BIGINT '10', time) AS bucket, avg(value) FROM bigint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW date_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM date_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamp_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamp_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamptz_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamptz_table GROUP BY 1 WITH NO DATA; -- Refresh first without data CALL refresh_continuous_aggregate('int_agg', NULL, NULL); NOTICE: continuous aggregate "int_agg" is already up-to-date CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); NOTICE: continuous aggregate "smallint_agg" is already up-to-date CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); NOTICE: continuous aggregate "bigint_agg" is already up-to-date CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date -- Watermarks at min for the above caggs: SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id), _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id), _timescaledb_functions.cagg_watermark(mat_hypertable_id) = _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id) AS is_equal FROM _timescaledb_catalog.continuous_agg NATURAL JOIN _timescaledb_catalog.continuous_aggs_watermark ORDER BY 1, 2, 3; user_view_name | cagg_watermark | cagg_watermark_materialized | is_equal -----------------+----------------------+-----------------------------+---------- bigint_agg | -9223372036854775808 | -9223372036854775808 | t boundary_view | 30 | 30 | t date_agg | -210866803200000000 | -210866803200000000 | t int_agg | -2147483648 | -2147483648 | t mat_m1 | 25 | 25 | t metrics_summary | 946771200000000 | 946771200000000 | t smallint_agg | -32768 | -32768 | t timestamp_agg | -210866803200000000 | -210866803200000000 | t timestamptz_agg | -210866803200000000 | -210866803200000000 | t INSERT INTO smallint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO int_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO bigint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO date_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamp_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamptz_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); -- Refresh to move the watermarks CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks should reflect the new materializations SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+------------------ bigint_agg | 20 boundary_view | 30 date_agg | 1578614400000000 int_agg | 20 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 20 timestamp_agg | 1578614400000000 timestamptz_agg | 1578614400000000 -- Test overflow of valid ranges by inserting values close to the max -- supported time values. Adding one bucket to these values overflow -- the valid time ranges so the watermark should end up at the end of -- valid range for the type. INSERT INTO smallint_table VALUES (32765, 1); INSERT INTO int_table VALUES (2147483645, 1); INSERT INTO bigint_table VALUES (9223372036854775804, 1); INSERT INTO date_table VALUES ('294247-01-01', 1); INSERT INTO timestamp_table VALUES ('294247-01-01 00:00:00-00', 1); INSERT INTO timestamptz_table VALUES ('294247-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks after refresh hould be at the end of the valid range for -- the time type SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+--------------------- bigint_agg | 9223372036854775807 boundary_view | 30 date_agg | 9223372036854775807 int_agg | 2147483647 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 32767 timestamp_agg | 9223372036854775807 timestamptz_agg | 9223372036854775807 -- Querying the aggs should work even when fully materialized SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 \set ON_ERROR_STOP 0 ------------------------------------- -- Test invalid inputs for cagg_watermark ------------------------------------- -- Non-existing materialized hypertable SELECT _timescaledb_functions.cagg_watermark(100); ERROR: invalid materialized hypertable ID: 100 -- NULL hypertable ID. Function is STRICT, so does nothing: SELECT _timescaledb_functions.cagg_watermark(NULL); cagg_watermark ---------------- \set ON_ERROR_STOP 1 -- Remove stored watermark, so query and refresh should error \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_aggs_watermark; \set ON_ERROR_STOP 0 SELECT * FROM smallint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 16 SELECT * FROM int_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 17 SELECT * FROM bigint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 18 SELECT * FROM date_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 19 SELECT * FROM timestamp_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 20 SELECT * FROM timestamptz_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 21 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 17 CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 16 CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 18 CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date \set ON_ERROR_STOP 1 -- Fix all continuous aggregates inserting materialized watermark into the metadata table INSERT INTO _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) SELECT a.mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(a.mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg a LEFT JOIN _timescaledb_catalog.continuous_aggs_watermark b ON b.mat_hypertable_id = a.mat_hypertable_id WHERE b.mat_hypertable_id IS NULL ORDER BY 1; SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_union_view-16.out�����������������������������������������0000664�0000000�0000000�00000130617�15100345067�0023565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- disable background workers to make results reproducible \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE metrics(f1 int, f2 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN f1; INSERT INTO metrics(time, device_id, value) SELECT '2000-01-01'::timestamptz, device_id, 0.5 FROM generate_series(1,3) g(device_id); -- -- test switching continuous agg view between different modes -- -- check default view for new continuous aggregate CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; ALTER TABLE metrics DROP COLUMN f2; -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_2; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view again ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- try upgrade view to union view that is already union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- refresh CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); -- result should not change after refresh for union view SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_2; -- view should have results now after refresh SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 DROP MATERIALIZED VIEW metrics_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk -- check default view for new continuous aggregate with materialized_only to true CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_3.time_bucket, + _materialized_hypertable_3.avg + FROM _timescaledb_internal._materialized_hypertable_3 + WHERE _materialized_hypertable_3.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- DROP MATERIALIZED VIEW metrics_summary; -- -- test queries on union view -- CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- should be marked as materialized_only in catalog SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t -- query should not have results since cagg is materialized only and no refresh has happened yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- after switch to union view all results should be returned SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- materialized only view should return data now too because refresh has happened SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- add some more data INSERT INTO metrics(time, device_id, value) SELECT '2000-02-01'::timestamptz, device_id, device_id/10.0 FROM generate_series(1,3) g(device_id); -- materialized only view should not have new data yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- but union view should ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 Mon Jan 31 16:00:00 2000 PST | 0.2 -- and after refresh non union view should have new data too CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-30'); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION boundary_test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; -- test watermark interaction with just in time aggregates CREATE TABLE boundary_test(time int, value float); SELECT create_hypertable('boundary_test','time',chunk_time_interval:=10); create_hypertable ---------------------------- (5,public,boundary_test,t) SELECT set_integer_now_func('boundary_test','boundary_test_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW boundary_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM boundary_test GROUP BY 1 WITH NO DATA; INSERT INTO boundary_test SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); SELECT mat_hypertable_id AS boundary_view_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'boundary_view' \gset -- watermark should be NULL SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- -2147483648 -- first UNION child should have no rows because no materialization has happened yet and 2nd child should have 4 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=4.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=4.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_5_chunk."time") -> Index Scan Backward using _hyper_5_5_chunk_boundary_test_time_idx on _hyper_5_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_6_chunk."time") -> Index Scan Backward using _hyper_5_6_chunk_boundary_test_time_idx on _hyper_5_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- Refresh up to 30 to leave some unmaterialized data at the head and -- thus have something to union. CALL refresh_continuous_aggregate('boundary_view', NULL, 30); -- watermark should be 30 SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- 30 -- both sides of the UNION should return 2 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_6_9_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_9_chunk (actual rows=2.00 loops=1) Index Cond: (time_bucket < 30) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=2.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 ---- TEST union view with WHERE, GROUP BY and HAVING clause ---- create table ht_intdata (a integer, b integer, c integer); select table_name FROM create_hypertable('ht_intdata', 'a', chunk_time_interval=> 10); table_name ------------ ht_intdata INSERT into ht_intdata values( 3 , 16 , 20); INSERT into ht_intdata values( 1 , 10 , 20); INSERT into ht_intdata values( 1 , 11 , 20); INSERT into ht_intdata values( 1 , 12 , 20); INSERT into ht_intdata values( 1 , 13 , 20); INSERT into ht_intdata values( 1 , 14 , 20); INSERT into ht_intdata values( 2 , 14 , 20); INSERT into ht_intdata values( 2 , 15 , 20); INSERT into ht_intdata values( 2 , 16 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 20 , 26 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); CREATE OR REPLACE FUNCTION integer_now_ht_intdata() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM ht_intdata $$; SELECT set_integer_now_func('ht_intdata', 'integer_now_ht_intdata'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb, sumbc, spreadcb, avgc) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 WITH NO DATA; -- Do partial refresh to have something to union CALL refresh_continuous_aggregate('mat_m1', NULL, 11); --results from real time cont.agg and direct query should match SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 --verify that materialized only doesn't have rows with a> 20 ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = true); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ---+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 --again revert the view to include real time aggregates ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = false); INSERT into ht_intdata values( 31 , 15 , 30); INSERT into ht_intdata values( 31 , 14 , 70); --cagg was not refreshed, should include all rows SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 --the selects against mat_m1 before and after refresh should match this query SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_8_12_chunk --- TEST union view with multiple WHERE and HAVING clauses CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 WITH NO DATA; INSERT into ht_intdata values( 42 , 15 , 80); INSERT into ht_intdata values( 42 , 15 , 18); INSERT into ht_intdata values( 41 , 18 , 21); -- Do partial refresh so that we leave data to UNION CALL refresh_continuous_aggregate('mat_m1', NULL, 25); SELECT mat_hypertable_id AS mat_m1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_m1' \gset -- Show the new watermark SELECT _timescaledb_functions.cagg_watermark(:mat_m1_id); cagg_watermark ---------------- 25 -- Data inserted after refresh and after cagg_watermark should be -- reflected in the real-time aggregation INSERT into ht_intdata VALUES (34, 13, 65), (26, 12, 78), (28, 9, 32); --view and direct query should return same results SELECT * from mat_m1 ORDER BY 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 ORDER by 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 -- plan output :PREFIX SELECT * FROM mat_m1 ORDER BY 1; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_9_15_chunk__materialized_hypertable_9_time_bucket_idx on _hyper_9_15_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 25) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(5, ht_intdata.a)) Filter: ((sum(ht_intdata.c) > 50) AND ((avg(ht_intdata.b))::integer > 12)) Rows Removed by Filter: 1 -> Custom Scan (ChunkAppend) on ht_intdata (actual rows=3.00 loops=1) Order: time_bucket(5, ht_intdata.a) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_11_chunk.a) -> Index Scan Backward using _hyper_7_11_chunk_ht_intdata_a_idx on _hyper_7_11_chunk (actual rows=2.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_13_chunk.a) -> Index Scan Backward using _hyper_7_13_chunk_ht_intdata_a_idx on _hyper_7_13_chunk (actual rows=3.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_14_chunk.a) -> Index Scan Backward using _hyper_7_14_chunk_ht_intdata_a_idx on _hyper_7_14_chunk (actual rows=1.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) Rows Removed by Filter: 2 -- Test caggs with different time types CREATE TABLE smallint_table (time smallint, value int); CREATE TABLE int_table (time int, value int); CREATE TABLE bigint_table (time bigint, value int); CREATE TABLE date_table (time date, value int); CREATE TABLE timestamp_table (time timestamp, value int); CREATE TABLE timestamptz_table (time timestamptz, value int); SELECT create_hypertable('smallint_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------------ (10,public,smallint_table,t) SELECT create_hypertable('int_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------- (11,public,int_table,t) SELECT create_hypertable('bigint_table', 'time', chunk_time_interval=>20); create_hypertable ---------------------------- (12,public,bigint_table,t) SELECT create_hypertable('date_table', 'time'); create_hypertable -------------------------- (13,public,date_table,t) SELECT create_hypertable('timestamp_table', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------------- (14,public,timestamp_table,t) SELECT create_hypertable('timestamptz_table', 'time'); create_hypertable --------------------------------- (15,public,timestamptz_table,t) CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM smallint_table $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM int_table $$; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM bigint_table $$; SELECT set_integer_now_func('smallint_table', 'smallint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('int_table', 'int_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('bigint_table', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW smallint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(SMALLINT '10', time) AS bucket, avg(value) FROM smallint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW int_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, time) AS bucket, avg(value) FROM int_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW bigint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(BIGINT '10', time) AS bucket, avg(value) FROM bigint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW date_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM date_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamp_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamp_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamptz_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamptz_table GROUP BY 1 WITH NO DATA; -- Refresh first without data CALL refresh_continuous_aggregate('int_agg', NULL, NULL); NOTICE: continuous aggregate "int_agg" is already up-to-date CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); NOTICE: continuous aggregate "smallint_agg" is already up-to-date CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); NOTICE: continuous aggregate "bigint_agg" is already up-to-date CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date -- Watermarks at min for the above caggs: SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id), _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id), _timescaledb_functions.cagg_watermark(mat_hypertable_id) = _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id) AS is_equal FROM _timescaledb_catalog.continuous_agg NATURAL JOIN _timescaledb_catalog.continuous_aggs_watermark ORDER BY 1, 2, 3; user_view_name | cagg_watermark | cagg_watermark_materialized | is_equal -----------------+----------------------+-----------------------------+---------- bigint_agg | -9223372036854775808 | -9223372036854775808 | t boundary_view | 30 | 30 | t date_agg | -210866803200000000 | -210866803200000000 | t int_agg | -2147483648 | -2147483648 | t mat_m1 | 25 | 25 | t metrics_summary | 946771200000000 | 946771200000000 | t smallint_agg | -32768 | -32768 | t timestamp_agg | -210866803200000000 | -210866803200000000 | t timestamptz_agg | -210866803200000000 | -210866803200000000 | t INSERT INTO smallint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO int_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO bigint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO date_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamp_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamptz_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); -- Refresh to move the watermarks CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks should reflect the new materializations SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+------------------ bigint_agg | 20 boundary_view | 30 date_agg | 1578614400000000 int_agg | 20 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 20 timestamp_agg | 1578614400000000 timestamptz_agg | 1578614400000000 -- Test overflow of valid ranges by inserting values close to the max -- supported time values. Adding one bucket to these values overflow -- the valid time ranges so the watermark should end up at the end of -- valid range for the type. INSERT INTO smallint_table VALUES (32765, 1); INSERT INTO int_table VALUES (2147483645, 1); INSERT INTO bigint_table VALUES (9223372036854775804, 1); INSERT INTO date_table VALUES ('294247-01-01', 1); INSERT INTO timestamp_table VALUES ('294247-01-01 00:00:00-00', 1); INSERT INTO timestamptz_table VALUES ('294247-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks after refresh hould be at the end of the valid range for -- the time type SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+--------------------- bigint_agg | 9223372036854775807 boundary_view | 30 date_agg | 9223372036854775807 int_agg | 2147483647 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 32767 timestamp_agg | 9223372036854775807 timestamptz_agg | 9223372036854775807 -- Querying the aggs should work even when fully materialized SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 \set ON_ERROR_STOP 0 ------------------------------------- -- Test invalid inputs for cagg_watermark ------------------------------------- -- Non-existing materialized hypertable SELECT _timescaledb_functions.cagg_watermark(100); ERROR: invalid materialized hypertable ID: 100 -- NULL hypertable ID. Function is STRICT, so does nothing: SELECT _timescaledb_functions.cagg_watermark(NULL); cagg_watermark ---------------- \set ON_ERROR_STOP 1 -- Remove stored watermark, so query and refresh should error \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_aggs_watermark; \set ON_ERROR_STOP 0 SELECT * FROM smallint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 16 SELECT * FROM int_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 17 SELECT * FROM bigint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 18 SELECT * FROM date_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 19 SELECT * FROM timestamp_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 20 SELECT * FROM timestamptz_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 21 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 17 CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 16 CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 18 CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date \set ON_ERROR_STOP 1 -- Fix all continuous aggregates inserting materialized watermark into the metadata table INSERT INTO _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) SELECT a.mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(a.mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg a LEFT JOIN _timescaledb_catalog.continuous_aggs_watermark b ON b.mat_hypertable_id = a.mat_hypertable_id WHERE b.mat_hypertable_id IS NULL ORDER BY 1; SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_union_view-17.out�����������������������������������������0000664�0000000�0000000�00000130617�15100345067�0023566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- disable background workers to make results reproducible \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE metrics(f1 int, f2 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN f1; INSERT INTO metrics(time, device_id, value) SELECT '2000-01-01'::timestamptz, device_id, 0.5 FROM generate_series(1,3) g(device_id); -- -- test switching continuous agg view between different modes -- -- check default view for new continuous aggregate CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; ALTER TABLE metrics DROP COLUMN f2; -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_2; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view again ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- try upgrade view to union view that is already union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- refresh CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); -- result should not change after refresh for union view SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_2; -- view should have results now after refresh SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 DROP MATERIALIZED VIEW metrics_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk -- check default view for new continuous aggregate with materialized_only to true CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_3.time_bucket, + _materialized_hypertable_3.avg + FROM _timescaledb_internal._materialized_hypertable_3 + WHERE _materialized_hypertable_3.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- DROP MATERIALIZED VIEW metrics_summary; -- -- test queries on union view -- CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- should be marked as materialized_only in catalog SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t -- query should not have results since cagg is materialized only and no refresh has happened yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- after switch to union view all results should be returned SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- materialized only view should return data now too because refresh has happened SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- add some more data INSERT INTO metrics(time, device_id, value) SELECT '2000-02-01'::timestamptz, device_id, device_id/10.0 FROM generate_series(1,3) g(device_id); -- materialized only view should not have new data yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- but union view should ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 Mon Jan 31 16:00:00 2000 PST | 0.2 -- and after refresh non union view should have new data too CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-30'); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION boundary_test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; -- test watermark interaction with just in time aggregates CREATE TABLE boundary_test(time int, value float); SELECT create_hypertable('boundary_test','time',chunk_time_interval:=10); create_hypertable ---------------------------- (5,public,boundary_test,t) SELECT set_integer_now_func('boundary_test','boundary_test_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW boundary_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM boundary_test GROUP BY 1 WITH NO DATA; INSERT INTO boundary_test SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); SELECT mat_hypertable_id AS boundary_view_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'boundary_view' \gset -- watermark should be NULL SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- -2147483648 -- first UNION child should have no rows because no materialization has happened yet and 2nd child should have 4 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=4.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=4.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_5_chunk."time") -> Index Scan Backward using _hyper_5_5_chunk_boundary_test_time_idx on _hyper_5_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_6_chunk."time") -> Index Scan Backward using _hyper_5_6_chunk_boundary_test_time_idx on _hyper_5_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- Refresh up to 30 to leave some unmaterialized data at the head and -- thus have something to union. CALL refresh_continuous_aggregate('boundary_view', NULL, 30); -- watermark should be 30 SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- 30 -- both sides of the UNION should return 2 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_6_9_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_9_chunk (actual rows=2.00 loops=1) Index Cond: (time_bucket < 30) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=2.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 ---- TEST union view with WHERE, GROUP BY and HAVING clause ---- create table ht_intdata (a integer, b integer, c integer); select table_name FROM create_hypertable('ht_intdata', 'a', chunk_time_interval=> 10); table_name ------------ ht_intdata INSERT into ht_intdata values( 3 , 16 , 20); INSERT into ht_intdata values( 1 , 10 , 20); INSERT into ht_intdata values( 1 , 11 , 20); INSERT into ht_intdata values( 1 , 12 , 20); INSERT into ht_intdata values( 1 , 13 , 20); INSERT into ht_intdata values( 1 , 14 , 20); INSERT into ht_intdata values( 2 , 14 , 20); INSERT into ht_intdata values( 2 , 15 , 20); INSERT into ht_intdata values( 2 , 16 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 20 , 26 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); CREATE OR REPLACE FUNCTION integer_now_ht_intdata() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM ht_intdata $$; SELECT set_integer_now_func('ht_intdata', 'integer_now_ht_intdata'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb, sumbc, spreadcb, avgc) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 WITH NO DATA; -- Do partial refresh to have something to union CALL refresh_continuous_aggregate('mat_m1', NULL, 11); --results from real time cont.agg and direct query should match SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 --verify that materialized only doesn't have rows with a> 20 ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = true); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ---+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 --again revert the view to include real time aggregates ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = false); INSERT into ht_intdata values( 31 , 15 , 30); INSERT into ht_intdata values( 31 , 14 , 70); --cagg was not refreshed, should include all rows SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 --the selects against mat_m1 before and after refresh should match this query SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_8_12_chunk --- TEST union view with multiple WHERE and HAVING clauses CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 WITH NO DATA; INSERT into ht_intdata values( 42 , 15 , 80); INSERT into ht_intdata values( 42 , 15 , 18); INSERT into ht_intdata values( 41 , 18 , 21); -- Do partial refresh so that we leave data to UNION CALL refresh_continuous_aggregate('mat_m1', NULL, 25); SELECT mat_hypertable_id AS mat_m1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_m1' \gset -- Show the new watermark SELECT _timescaledb_functions.cagg_watermark(:mat_m1_id); cagg_watermark ---------------- 25 -- Data inserted after refresh and after cagg_watermark should be -- reflected in the real-time aggregation INSERT into ht_intdata VALUES (34, 13, 65), (26, 12, 78), (28, 9, 32); --view and direct query should return same results SELECT * from mat_m1 ORDER BY 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 ORDER by 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 -- plan output :PREFIX SELECT * FROM mat_m1 ORDER BY 1; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_9_15_chunk__materialized_hypertable_9_time_bucket_idx on _hyper_9_15_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 25) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(5, ht_intdata.a)) Filter: ((sum(ht_intdata.c) > 50) AND ((avg(ht_intdata.b))::integer > 12)) Rows Removed by Filter: 1 -> Custom Scan (ChunkAppend) on ht_intdata (actual rows=3.00 loops=1) Order: time_bucket(5, ht_intdata.a) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_11_chunk.a) -> Index Scan Backward using _hyper_7_11_chunk_ht_intdata_a_idx on _hyper_7_11_chunk (actual rows=2.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_13_chunk.a) -> Index Scan Backward using _hyper_7_13_chunk_ht_intdata_a_idx on _hyper_7_13_chunk (actual rows=3.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_14_chunk.a) -> Index Scan Backward using _hyper_7_14_chunk_ht_intdata_a_idx on _hyper_7_14_chunk (actual rows=1.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) Rows Removed by Filter: 2 -- Test caggs with different time types CREATE TABLE smallint_table (time smallint, value int); CREATE TABLE int_table (time int, value int); CREATE TABLE bigint_table (time bigint, value int); CREATE TABLE date_table (time date, value int); CREATE TABLE timestamp_table (time timestamp, value int); CREATE TABLE timestamptz_table (time timestamptz, value int); SELECT create_hypertable('smallint_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------------ (10,public,smallint_table,t) SELECT create_hypertable('int_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------- (11,public,int_table,t) SELECT create_hypertable('bigint_table', 'time', chunk_time_interval=>20); create_hypertable ---------------------------- (12,public,bigint_table,t) SELECT create_hypertable('date_table', 'time'); create_hypertable -------------------------- (13,public,date_table,t) SELECT create_hypertable('timestamp_table', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------------- (14,public,timestamp_table,t) SELECT create_hypertable('timestamptz_table', 'time'); create_hypertable --------------------------------- (15,public,timestamptz_table,t) CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM smallint_table $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM int_table $$; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM bigint_table $$; SELECT set_integer_now_func('smallint_table', 'smallint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('int_table', 'int_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('bigint_table', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW smallint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(SMALLINT '10', time) AS bucket, avg(value) FROM smallint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW int_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, time) AS bucket, avg(value) FROM int_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW bigint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(BIGINT '10', time) AS bucket, avg(value) FROM bigint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW date_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM date_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamp_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamp_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamptz_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamptz_table GROUP BY 1 WITH NO DATA; -- Refresh first without data CALL refresh_continuous_aggregate('int_agg', NULL, NULL); NOTICE: continuous aggregate "int_agg" is already up-to-date CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); NOTICE: continuous aggregate "smallint_agg" is already up-to-date CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); NOTICE: continuous aggregate "bigint_agg" is already up-to-date CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date -- Watermarks at min for the above caggs: SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id), _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id), _timescaledb_functions.cagg_watermark(mat_hypertable_id) = _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id) AS is_equal FROM _timescaledb_catalog.continuous_agg NATURAL JOIN _timescaledb_catalog.continuous_aggs_watermark ORDER BY 1, 2, 3; user_view_name | cagg_watermark | cagg_watermark_materialized | is_equal -----------------+----------------------+-----------------------------+---------- bigint_agg | -9223372036854775808 | -9223372036854775808 | t boundary_view | 30 | 30 | t date_agg | -210866803200000000 | -210866803200000000 | t int_agg | -2147483648 | -2147483648 | t mat_m1 | 25 | 25 | t metrics_summary | 946771200000000 | 946771200000000 | t smallint_agg | -32768 | -32768 | t timestamp_agg | -210866803200000000 | -210866803200000000 | t timestamptz_agg | -210866803200000000 | -210866803200000000 | t INSERT INTO smallint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO int_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO bigint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO date_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamp_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamptz_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); -- Refresh to move the watermarks CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks should reflect the new materializations SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+------------------ bigint_agg | 20 boundary_view | 30 date_agg | 1578614400000000 int_agg | 20 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 20 timestamp_agg | 1578614400000000 timestamptz_agg | 1578614400000000 -- Test overflow of valid ranges by inserting values close to the max -- supported time values. Adding one bucket to these values overflow -- the valid time ranges so the watermark should end up at the end of -- valid range for the type. INSERT INTO smallint_table VALUES (32765, 1); INSERT INTO int_table VALUES (2147483645, 1); INSERT INTO bigint_table VALUES (9223372036854775804, 1); INSERT INTO date_table VALUES ('294247-01-01', 1); INSERT INTO timestamp_table VALUES ('294247-01-01 00:00:00-00', 1); INSERT INTO timestamptz_table VALUES ('294247-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks after refresh hould be at the end of the valid range for -- the time type SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+--------------------- bigint_agg | 9223372036854775807 boundary_view | 30 date_agg | 9223372036854775807 int_agg | 2147483647 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 32767 timestamp_agg | 9223372036854775807 timestamptz_agg | 9223372036854775807 -- Querying the aggs should work even when fully materialized SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 \set ON_ERROR_STOP 0 ------------------------------------- -- Test invalid inputs for cagg_watermark ------------------------------------- -- Non-existing materialized hypertable SELECT _timescaledb_functions.cagg_watermark(100); ERROR: invalid materialized hypertable ID: 100 -- NULL hypertable ID. Function is STRICT, so does nothing: SELECT _timescaledb_functions.cagg_watermark(NULL); cagg_watermark ---------------- \set ON_ERROR_STOP 1 -- Remove stored watermark, so query and refresh should error \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_aggs_watermark; \set ON_ERROR_STOP 0 SELECT * FROM smallint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 16 SELECT * FROM int_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 17 SELECT * FROM bigint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 18 SELECT * FROM date_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 19 SELECT * FROM timestamp_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 20 SELECT * FROM timestamptz_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 21 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 17 CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 16 CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 18 CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date \set ON_ERROR_STOP 1 -- Fix all continuous aggregates inserting materialized watermark into the metadata table INSERT INTO _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) SELECT a.mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(a.mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg a LEFT JOIN _timescaledb_catalog.continuous_aggs_watermark b ON b.mat_hypertable_id = a.mat_hypertable_id WHERE b.mat_hypertable_id IS NULL ORDER BY 1; SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_union_view-18.out�����������������������������������������0000664�0000000�0000000�00000130617�15100345067�0023567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- disable background workers to make results reproducible \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); stop_background_workers ------------------------- t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE metrics(f1 int, f2 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN f1; INSERT INTO metrics(time, device_id, value) SELECT '2000-01-01'::timestamptz, device_id, 0.5 FROM generate_series(1,3) g(device_id); -- -- test switching continuous agg view between different modes -- -- check default view for new continuous aggregate CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; ALTER TABLE metrics DROP COLUMN f2; -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_2; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view again ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- try upgrade view to union view that is already union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_2.time_bucket, + _materialized_hypertable_2.avg + FROM _timescaledb_internal._materialized_hypertable_2 + WHERE _materialized_hypertable_2.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(2)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- refresh CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); -- result should not change after refresh for union view SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_2; -- view should have results now after refresh SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 DROP MATERIALIZED VIEW metrics_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk -- check default view for new continuous aggregate with materialized_only to true CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- -- upgrade view to union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | f SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- SELECT _materialized_hypertable_3.time_bucket, + _materialized_hypertable_3.avg + FROM _timescaledb_internal._materialized_hypertable_3 + WHERE _materialized_hypertable_3.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone)+ UNION ALL + SELECT time_bucket('@ 1 day'::interval, metrics."time") AS time_bucket, + avg(metrics.value) AS avg + FROM metrics + WHERE metrics."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(3)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 1 day'::interval, metrics."time")); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t SELECT pg_get_viewdef('metrics_summary',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + avg + FROM _timescaledb_internal._materialized_hypertable_3; SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- DROP MATERIALIZED VIEW metrics_summary; -- -- test queries on union view -- CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- should be marked as materialized_only in catalog SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; user_view_name | materialized_only -----------------+------------------- metrics_summary | t -- query should not have results since cagg is materialized only and no refresh has happened yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg -------------+----- ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- after switch to union view all results should be returned SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- materialized only view should return data now too because refresh has happened SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- add some more data INSERT INTO metrics(time, device_id, value) SELECT '2000-02-01'::timestamptz, device_id, device_id/10.0 FROM generate_series(1,3) g(device_id); -- materialized only view should not have new data yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- but union view should ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 Mon Jan 31 16:00:00 2000 PST | 0.2 -- and after refresh non union view should have new data too CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-30'); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; time_bucket | avg ------------------------------+----- Fri Dec 31 16:00:00 1999 PST | 0.5 -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION boundary_test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; -- test watermark interaction with just in time aggregates CREATE TABLE boundary_test(time int, value float); SELECT create_hypertable('boundary_test','time',chunk_time_interval:=10); create_hypertable ---------------------------- (5,public,boundary_test,t) SELECT set_integer_now_func('boundary_test','boundary_test_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW boundary_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM boundary_test GROUP BY 1 WITH NO DATA; INSERT INTO boundary_test SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); SELECT mat_hypertable_id AS boundary_view_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'boundary_view' \gset -- watermark should be NULL SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- -2147483648 -- first UNION child should have no rows because no materialization has happened yet and 2nd child should have 4 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=4.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=4.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_5_chunk."time") -> Index Scan Backward using _hyper_5_5_chunk_boundary_test_time_idx on _hyper_5_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_6_chunk."time") -> Index Scan Backward using _hyper_5_6_chunk_boundary_test_time_idx on _hyper_5_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= '-2147483648'::integer) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- Refresh up to 30 to leave some unmaterialized data at the head and -- thus have something to union. CALL refresh_continuous_aggregate('boundary_view', NULL, 30); -- watermark should be 30 SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); cagg_watermark ---------------- 30 -- both sides of the UNION should return 2 rows :PREFIX SELECT * FROM boundary_view; --- QUERY PLAN --- Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_6_9_chunk__materialized_hypertable_6_time_bucket_idx on _hyper_6_9_chunk (actual rows=2.00 loops=1) Index Cond: (time_bucket < 30) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(10, boundary_test."time")) -> Merge Append (actual rows=2.00 loops=1) Sort Key: (time_bucket(10, boundary_test."time")) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_7_chunk."time") -> Index Scan Backward using _hyper_5_7_chunk_boundary_test_time_idx on _hyper_5_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(10, _hyper_5_8_chunk."time") -> Index Scan Backward using _hyper_5_8_chunk_boundary_test_time_idx on _hyper_5_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 30) -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 ---- TEST union view with WHERE, GROUP BY and HAVING clause ---- create table ht_intdata (a integer, b integer, c integer); select table_name FROM create_hypertable('ht_intdata', 'a', chunk_time_interval=> 10); table_name ------------ ht_intdata INSERT into ht_intdata values( 3 , 16 , 20); INSERT into ht_intdata values( 1 , 10 , 20); INSERT into ht_intdata values( 1 , 11 , 20); INSERT into ht_intdata values( 1 , 12 , 20); INSERT into ht_intdata values( 1 , 13 , 20); INSERT into ht_intdata values( 1 , 14 , 20); INSERT into ht_intdata values( 2 , 14 , 20); INSERT into ht_intdata values( 2 , 15 , 20); INSERT into ht_intdata values( 2 , 16 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 20 , 26 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); CREATE OR REPLACE FUNCTION integer_now_ht_intdata() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM ht_intdata $$; SELECT set_integer_now_func('ht_intdata', 'integer_now_ht_intdata'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb, sumbc, spreadcb, avgc) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 WITH NO DATA; -- Do partial refresh to have something to union CALL refresh_continuous_aggregate('mat_m1', NULL, 11); --results from real time cont.agg and direct query should match SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 --verify that materialized only doesn't have rows with a> 20 ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = true); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ---+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 --again revert the view to include real time aggregates ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = false); INSERT into ht_intdata values( 31 , 15 , 30); INSERT into ht_intdata values( 31 , 14 , 70); --cagg was not refreshed, should include all rows SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); SELECT * FROM mat_m1 ORDER BY 1; a | countb | sumbc | spreadcb | avgc ----+--------+-------+----------+------ 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 --the selects against mat_m1 before and after refresh should match this query SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; time_bucket | count | sum | ?column? | avg -------------+-------+-----+----------+----- 1 | 5 | 160 | 10 | 20 21 | 3 | 135 | 15 | 30 31 | 2 | 129 | 56 | 50 DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_8_12_chunk --- TEST union view with multiple WHERE and HAVING clauses CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 WITH NO DATA; INSERT into ht_intdata values( 42 , 15 , 80); INSERT into ht_intdata values( 42 , 15 , 18); INSERT into ht_intdata values( 41 , 18 , 21); -- Do partial refresh so that we leave data to UNION CALL refresh_continuous_aggregate('mat_m1', NULL, 25); SELECT mat_hypertable_id AS mat_m1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_m1' \gset -- Show the new watermark SELECT _timescaledb_functions.cagg_watermark(:mat_m1_id); cagg_watermark ---------------- 25 -- Data inserted after refresh and after cagg_watermark should be -- reflected in the real-time aggregation INSERT into ht_intdata VALUES (34, 13, 65), (26, 12, 78), (28, 9, 32); --view and direct query should return same results SELECT * from mat_m1 ORDER BY 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 ORDER by 1; time_bucket | sum -------------+----- 20 | 135 30 | 207 40 | 95 -- plan output :PREFIX SELECT * FROM mat_m1 ORDER BY 1; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_9_15_chunk__materialized_hypertable_9_time_bucket_idx on _hyper_9_15_chunk (actual rows=1.00 loops=1) Index Cond: (time_bucket < 25) -> Finalize GroupAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket(5, ht_intdata.a)) Filter: ((sum(ht_intdata.c) > 50) AND ((avg(ht_intdata.b))::integer > 12)) Rows Removed by Filter: 1 -> Custom Scan (ChunkAppend) on ht_intdata (actual rows=3.00 loops=1) Order: time_bucket(5, ht_intdata.a) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_11_chunk.a) -> Index Scan Backward using _hyper_7_11_chunk_ht_intdata_a_idx on _hyper_7_11_chunk (actual rows=2.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_13_chunk.a) -> Index Scan Backward using _hyper_7_13_chunk_ht_intdata_a_idx on _hyper_7_13_chunk (actual rows=3.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket(5, _hyper_7_14_chunk.a) -> Index Scan Backward using _hyper_7_14_chunk_ht_intdata_a_idx on _hyper_7_14_chunk (actual rows=1.00 loops=1) Index Cond: (a >= 25) Filter: ((b < 16) AND (c > 20)) Rows Removed by Filter: 2 -- Test caggs with different time types CREATE TABLE smallint_table (time smallint, value int); CREATE TABLE int_table (time int, value int); CREATE TABLE bigint_table (time bigint, value int); CREATE TABLE date_table (time date, value int); CREATE TABLE timestamp_table (time timestamp, value int); CREATE TABLE timestamptz_table (time timestamptz, value int); SELECT create_hypertable('smallint_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------------ (10,public,smallint_table,t) SELECT create_hypertable('int_table', 'time', chunk_time_interval=>20); create_hypertable ------------------------- (11,public,int_table,t) SELECT create_hypertable('bigint_table', 'time', chunk_time_interval=>20); create_hypertable ---------------------------- (12,public,bigint_table,t) SELECT create_hypertable('date_table', 'time'); create_hypertable -------------------------- (13,public,date_table,t) SELECT create_hypertable('timestamp_table', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------------- (14,public,timestamp_table,t) SELECT create_hypertable('timestamptz_table', 'time'); create_hypertable --------------------------------- (15,public,timestamptz_table,t) CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM smallint_table $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM int_table $$; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM bigint_table $$; SELECT set_integer_now_func('smallint_table', 'smallint_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('int_table', 'int_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('bigint_table', 'bigint_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW smallint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(SMALLINT '10', time) AS bucket, avg(value) FROM smallint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW int_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, time) AS bucket, avg(value) FROM int_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW bigint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(BIGINT '10', time) AS bucket, avg(value) FROM bigint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW date_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM date_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamp_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamp_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamptz_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamptz_table GROUP BY 1 WITH NO DATA; -- Refresh first without data CALL refresh_continuous_aggregate('int_agg', NULL, NULL); NOTICE: continuous aggregate "int_agg" is already up-to-date CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); NOTICE: continuous aggregate "smallint_agg" is already up-to-date CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); NOTICE: continuous aggregate "bigint_agg" is already up-to-date CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date -- Watermarks at min for the above caggs: SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id), _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id), _timescaledb_functions.cagg_watermark(mat_hypertable_id) = _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id) AS is_equal FROM _timescaledb_catalog.continuous_agg NATURAL JOIN _timescaledb_catalog.continuous_aggs_watermark ORDER BY 1, 2, 3; user_view_name | cagg_watermark | cagg_watermark_materialized | is_equal -----------------+----------------------+-----------------------------+---------- bigint_agg | -9223372036854775808 | -9223372036854775808 | t boundary_view | 30 | 30 | t date_agg | -210866803200000000 | -210866803200000000 | t int_agg | -2147483648 | -2147483648 | t mat_m1 | 25 | 25 | t metrics_summary | 946771200000000 | 946771200000000 | t smallint_agg | -32768 | -32768 | t timestamp_agg | -210866803200000000 | -210866803200000000 | t timestamptz_agg | -210866803200000000 | -210866803200000000 | t INSERT INTO smallint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO int_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO bigint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO date_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamp_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamptz_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); -- Refresh to move the watermarks CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks should reflect the new materializations SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+------------------ bigint_agg | 20 boundary_view | 30 date_agg | 1578614400000000 int_agg | 20 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 20 timestamp_agg | 1578614400000000 timestamptz_agg | 1578614400000000 -- Test overflow of valid ranges by inserting values close to the max -- supported time values. Adding one bucket to these values overflow -- the valid time ranges so the watermark should end up at the end of -- valid range for the type. INSERT INTO smallint_table VALUES (32765, 1); INSERT INTO int_table VALUES (2147483645, 1); INSERT INTO bigint_table VALUES (9223372036854775804, 1); INSERT INTO date_table VALUES ('294247-01-01', 1); INSERT INTO timestamp_table VALUES ('294247-01-01 00:00:00-00', 1); INSERT INTO timestamptz_table VALUES ('294247-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks after refresh hould be at the end of the valid range for -- the time type SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; user_view_name | cagg_watermark -----------------+--------------------- bigint_agg | 9223372036854775807 boundary_view | 30 date_agg | 9223372036854775807 int_agg | 2147483647 mat_m1 | 25 metrics_summary | 946771200000000 smallint_agg | 32767 timestamp_agg | 9223372036854775807 timestamptz_agg | 9223372036854775807 -- Querying the aggs should work even when fully materialized SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 \set ON_ERROR_STOP 0 ------------------------------------- -- Test invalid inputs for cagg_watermark ------------------------------------- -- Non-existing materialized hypertable SELECT _timescaledb_functions.cagg_watermark(100); ERROR: invalid materialized hypertable ID: 100 -- NULL hypertable ID. Function is STRICT, so does nothing: SELECT _timescaledb_functions.cagg_watermark(NULL); cagg_watermark ---------------- \set ON_ERROR_STOP 1 -- Remove stored watermark, so query and refresh should error \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_aggs_watermark; \set ON_ERROR_STOP 0 SELECT * FROM smallint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 16 SELECT * FROM int_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 17 SELECT * FROM bigint_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 18 SELECT * FROM date_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 19 SELECT * FROM timestamp_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 20 SELECT * FROM timestamptz_agg ORDER BY 1,2; ERROR: watermark not defined for continuous aggregate: 21 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 17 CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 16 CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); ERROR: watermark not defined for continuous aggregate: 18 CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date \set ON_ERROR_STOP 1 -- Fix all continuous aggregates inserting materialized watermark into the metadata table INSERT INTO _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) SELECT a.mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(a.mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg a LEFT JOIN _timescaledb_catalog.continuous_aggs_watermark b ON b.mat_hypertable_id = a.mat_hypertable_id WHERE b.mat_hypertable_id IS NULL ORDER BY 1; SELECT * FROM smallint_agg ORDER BY 1,2; bucket | avg --------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 32760 | 1.00000000000000000000 SELECT * FROM int_agg ORDER BY 1,2; bucket | avg ------------+------------------------ 0 | 1.5000000000000000 5 | 7.0000000000000000 15 | 19.0000000000000000 2147483645 | 1.00000000000000000000 SELECT * FROM bigint_agg ORDER BY 1,2; bucket | avg ---------------------+------------------------ 0 | 4.2500000000000000 10 | 19.0000000000000000 9223372036854775800 | 1.00000000000000000000 SELECT * FROM date_agg ORDER BY 1,2; bucket | avg --------------+------------------------ 12-31-2019 | 1.00000000000000000000 01-02-2020 | 2.0000000000000000 01-06-2020 | 6.0000000000000000 01-08-2020 | 8.0000000000000000 12-31-294246 | 1.00000000000000000000 SELECT * FROM timestamp_agg ORDER BY 1,2; bucket | avg ----------------------------+------------------------ Tue Dec 31 00:00:00 2019 | 1.00000000000000000000 Thu Jan 02 00:00:00 2020 | 2.0000000000000000 Mon Jan 06 00:00:00 2020 | 6.0000000000000000 Wed Jan 08 00:00:00 2020 | 8.0000000000000000 Thu Dec 31 00:00:00 294246 | 1.00000000000000000000 SELECT * FROM timestamptz_agg ORDER BY 1,2; bucket | avg --------------------------------+------------------------ Mon Dec 30 16:00:00 2019 PST | 1.00000000000000000000 Wed Jan 01 16:00:00 2020 PST | 2.0000000000000000 Sun Jan 05 16:00:00 2020 PST | 6.0000000000000000 Tue Jan 07 16:00:00 2020 PST | 8.0000000000000000 Wed Dec 30 16:00:00 294246 PST | 1.00000000000000000000 CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); NOTICE: continuous aggregate "date_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); NOTICE: continuous aggregate "timestamp_agg" is already up-to-date CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); NOTICE: continuous aggregate "timestamptz_agg" is already up-to-date �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_usage-15.out����������������������������������������������0000664�0000000�0000000�00000067404�15100345067�0022511�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST SETUP -- \set ON_ERROR_STOP 0 SET client_min_messages TO NOTICE; SET work_mem TO '64MB'; SET timezone TO PST8PDT; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW invalidation_slots AS SELECT * FROM pg_replication_slots WHERE plugin = :'plugin_name'; -- START OF USAGE TEST -- --First create your hypertable CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); table_name ----------------- device_readings --Next, create your continuous aggregate view CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) --This flag is what makes the view continuous AS SELECT time_bucket('1 hour', observation_time) as bucket, --time_bucket is required device_id, avg(metric) as metric_avg, --We can use regular aggregates max(metric)-min(metric) as metric_spread --We can also use expressions on aggregates and constants FROM device_readings GROUP BY bucket, device_id WITH NO DATA; --We have to group by the bucket column, but can also add other group-by columns SELECT add_continuous_aggregate_policy('device_summary', NULL, '2 h'::interval, '2 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 --Next, insert some data into the raw hypertable INSERT INTO device_readings SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO device_readings SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; --Initially, it will be empty. SELECT * FROM device_summary; bucket | device_id | metric_avg | metric_spread --------+-----------+------------+--------------- -- Simulate a policy that refreshes with lag, i.e., it doesn't refresh -- the entire data set. In this case up to the given date. CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-30 22:00'); --Now you can run selects over your view as normal SELECT * FROM device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 21:00:00 2018 PST | device_1 | 1546204500 | 1800 Sun Dec 30 21:00:00 2018 PST | device_2 | 1546204500 | 1800 Sun Dec 30 20:00:00 2018 PST | device_1 | 1546200900 | 1800 Sun Dec 30 20:00:00 2018 PST | device_2 | 1546200900 | 1800 Sun Dec 30 19:00:00 2018 PST | device_1 | 1546197300 | 1800 Sun Dec 30 19:00:00 2018 PST | device_2 | 1546197300 | 1800 Sun Dec 30 18:00:00 2018 PST | device_1 | 1546193700 | 1800 Sun Dec 30 18:00:00 2018 PST | device_2 | 1546193700 | 1800 Sun Dec 30 17:00:00 2018 PST | device_1 | 1546190100 | 1800 Sun Dec 30 17:00:00 2018 PST | device_2 | 1546190100 | 1800 --You can view informaton about your continuous aggregates. The meaning of these fields will be explained further down. \x SELECT * FROM timescaledb_information.continuous_aggregates; -[ RECORD 1 ]---------------------+------------------------------------------------------------------------------------------------------------- hypertable_schema | public hypertable_name | device_readings view_schema | public view_name | device_summary view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_2 view_definition | SELECT time_bucket('@ 1 hour'::interval, device_readings.observation_time) AS bucket, + | device_readings.device_id, + | avg(device_readings.metric) AS metric_avg, + | (max(device_readings.metric) - min(device_readings.metric)) AS metric_spread + | FROM device_readings + | GROUP BY (time_bucket('@ 1 hour'::interval, device_readings.observation_time)), device_readings.device_id; finalized | t \x -- Refresh interval -- -- The refresh interval determines how often the background worker -- for automatic materialization will run. The default is (2 x bucket_width) SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 2 hours -- You can change this setting with ALTER VIEW (equivalently, specify in WITH clause of CREATE VIEW) SELECT alter_job(1000, schedule_interval := '1h'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 hour","@ 0",-1,"@ 2 hours",t,"{""end_offset"": ""@ 2 hours"", ""start_offset"": null, ""mat_hypertable_id"": 2}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 1 hour -- -- Refresh with lag -- -- It is possible to use a policy or manual refresh with a lag, which -- means the materialization will not contain the most up-to-date -- data. SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Sun Dec 30 21:00:00 2018 PST CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-31 01:00'); SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Mon Dec 31 00:00:00 2018 PST -- -- Invalidations -- --Changes to the raw table, for values that have already been materialized are propagated asynchronously, after the materialization next runs. --Before update: SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 INSERT INTO device_readings VALUES ('Sun Dec 30 13:01:00 2018 PST', 'device_1', 1.0); --Change not reflected before materializer runs. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 CALL refresh_continuous_aggregate('device_summary', NULL, NULL); --But is reflected after. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1030783800.33333 | 1546176599 -- -- Dealing with timezones -- -- You have three options: -- Option 1: be explicit in your timezone: DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_6_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time AT TIME ZONE 'EST') as min_time, --note the explict timezone device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; DROP MATERIALIZED VIEW device_summary; -- Option 2: Keep things as TIMESTAMPTZ in the view and convert to local time when -- querying from the view DROP MATERIALIZED VIEW device_summary; ERROR: materialized view "device_summary" does not exist CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time) as min_time, --this is a TIMESTAMPTZ device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH DATA; NOTICE: refreshing continuous aggregate "device_summary" SELECT min(min_time)::timestamp FROM device_summary; min -------------------------- Sat Dec 01 00:00:00 2018 -- Option 3: use stable expressions in the cagg definition -- in this case it is up to the user to ensure cagg refreshes -- run with consistent values DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_4_7_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time::timestamp) as min_time, --note the cast to localtime device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- -- test just in time aggregate / materialization only view -- -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE device_readings_int(time int, value float); SELECT create_hypertable('device_readings_int','time',chunk_time_interval:=10); create_hypertable ---------------------------------- (6,public,device_readings_int,t) SELECT set_integer_now_func('device_readings_int','device_readings_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW device_readings_mat_only WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW device_readings_jit WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); -- materialization only should have 0 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- simulate a refresh policy with lag, i.e., one that doesn't refresh -- up to the latest data. Max value is 40. CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, 30); CALL refresh_continuous_aggregate('device_readings_jit', NULL, 30); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- add 2 more rows INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(50,60,10) AS g(i); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- hardcoding now to 100 will lead to 80 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 100; $BODY$; -- refresh should materialize all now CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, NULL); CALL refresh_continuous_aggregate('device_readings_jit', NULL, NULL); -- materialization only should have 6 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- START OF BASIC USAGE TESTS -- -- Check that continuous aggregate and materialized table is dropped -- together. CREATE TABLE whatever(time TIMESTAMPTZ NOT NULL, metric INTEGER); SELECT * FROM create_hypertable('whatever', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 9 | public | whatever | t CREATE MATERIALIZED VIEW whatever_summary WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, avg(metric) FROM whatever GROUP BY bucket WITH NO DATA; SELECT (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = raw_hypertable_id) AS raw_table , (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = mat_hypertable_id) AS mat_table FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'whatever_summary' \gset SELECT relname FROM pg_class WHERE oid = :mat_table; relname ----------------------------- _materialized_hypertable_10 ---------------------------------------------------------------- -- Should generate an error since the cagg is dependent on the table. DROP TABLE whatever; ERROR: cannot drop table whatever because other objects depend on it ---------------------------------------------------------------- -- Checking that a cagg cannot be dropped if there is a dependent -- object on it. CREATE VIEW whatever_summary_dependency AS SELECT * FROM whatever_summary; -- Should generate an error DROP MATERIALIZED VIEW whatever_summary; ERROR: cannot drop view whatever_summary because other objects depend on it -- Dropping the dependent view so that we can do a proper drop below. DROP VIEW whatever_summary_dependency; ---------------------------------------------------------------- -- Dropping the cagg should also remove the materialized table DROP MATERIALIZED VIEW whatever_summary; SELECT relname FROM pg_class WHERE oid = :mat_table; relname --------- ---------------------------------------------------------------- -- Cleanup DROP TABLE whatever; -- END OF BASIC USAGE TESTS -- CREATE TABLE metrics(time timestamptz, device TEXT, value float); SELECT table_name FROM create_hypertable('metrics','time'); table_name ------------ metrics INSERT INTO metrics SELECT generate_series('1999-12-20'::timestamptz,'2000-02-01'::timestamptz,'12 day'::interval), 'dev1', 0.25; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" SELECT * FROM cagg1; time_bucket ------------------------------ Mon Dec 20 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg2" SELECT * FROM cagg2; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- custom origin with variable size CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', '2000-01-01'::timestamptz) FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg3" SELECT * FROM cagg3; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- offset with variable size CREATE MATERIALIZED VIEW cagg4 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', "offset":= INTERVAL '15 day') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg4" SELECT * FROM cagg4; time_bucket ------------------------------ Thu Dec 16 00:00:00 1999 PST Sun Jan 16 00:00:00 2000 PST -- -- drop chunks tests -- -- should return 4 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_16_chunk | 0 | f | _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- all caggs in the new format (finalized=true) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | t cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should also remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-01 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_16_chunk -- should return 3 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- let's update the catalog to fake an old format cagg (finalized=false) \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_agg SET finalized=FALSE WHERE user_view_name = 'cagg1'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- cagg1 now is a fake old format (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | f cagg2 | t cagg3 | t cagg4 | t -- cagg1 now is in the old format (finalized=false) -- dropping chunk should NOT remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-13 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- should return 3 chunks and one of them should be marked as dropped SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- remove the fake old format cagg DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_12_20_chunk -- no more old format caggs (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-25 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_18_chunk -- should return 2 chunks and one of them should be marked as dropped -- because we dropped chunk before when an old format cagg exists SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_19_chunk | 0 | f | \set ON_ERROR_STOP 1 SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 CREATE TABLE magic1(time timestamptz not null, device int, value float); CREATE TABLE magic2(time timestamptz not null, device int, value float); CREATE TABLE magic3(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('magic1','time'); table_name ------------ magic1 SELECT table_name FROM create_hypertable('magic2','time'); table_name ------------ magic2 SELECT table_name FROM create_hypertable('magic3','time'); table_name ------------ magic3 INSERT INTO magic1 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic2 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic3 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Creating a materialized view with a failure between adding the slot -- and finishing adding the slot should not leave a slot around. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE bad(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('bad','time'); table_name ------------ bad -- We create such an error by setting the hypertable id sequence -- number to an already existing one, which will generate an error -- when adding the new hypertable data to the catalog. select currval('_timescaledb_catalog.hypertable_id_seq') - 1 as prev_htid \gset select setval('_timescaledb_catalog.hypertable_id_seq', :prev_htid, false); setval -------- 18 \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW bad_summary_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM bad GROUP BY 1,2; ERROR: duplicate key value violates unique constraint "hypertable_pkey" \set ON_ERROR_STOP 1 -- There should be no replication slot around. SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Advance the sequence again to consume the value we set before. SELECT FROM nextval('_timescaledb_catalog.hypertable_id_seq'); -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_cagg_wal_based_invalidation TO true; -- Test the option "invalidate_using". This should create the continuous -- aggregate and there should be a replication slot. CREATE MATERIALIZED VIEW magic1_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary1_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on the same hypertable to be -- able to check that the slot remains after one continuous aggregate -- has been dropped. CREATE MATERIALIZED VIEW magic1_summary2_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary2_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on a different hypertable that -- uses WAL-based invalidation collection. This is used to check that -- the slot stays when we remove all continuous aggregates for a -- hypertable. CREATE MATERIALIZED VIEW magic2_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic2 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic2_summary1_wal" SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 1 DROP MATERIALIZED VIEW magic2_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_22_38_chunk -- Slot should be there. We have another hypertable using WAL-based -- invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_20_36_chunk -- Slot should be there. We have yet another continuous aggregate for -- the hypertable using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary2_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_21_37_chunk -- Now slot should be gone and we should not have any continuous -- aggregates using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_usage-16.out����������������������������������������������0000664�0000000�0000000�00000067044�15100345067�0022512�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST SETUP -- \set ON_ERROR_STOP 0 SET client_min_messages TO NOTICE; SET work_mem TO '64MB'; SET timezone TO PST8PDT; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW invalidation_slots AS SELECT * FROM pg_replication_slots WHERE plugin = :'plugin_name'; -- START OF USAGE TEST -- --First create your hypertable CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); table_name ----------------- device_readings --Next, create your continuous aggregate view CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) --This flag is what makes the view continuous AS SELECT time_bucket('1 hour', observation_time) as bucket, --time_bucket is required device_id, avg(metric) as metric_avg, --We can use regular aggregates max(metric)-min(metric) as metric_spread --We can also use expressions on aggregates and constants FROM device_readings GROUP BY bucket, device_id WITH NO DATA; --We have to group by the bucket column, but can also add other group-by columns SELECT add_continuous_aggregate_policy('device_summary', NULL, '2 h'::interval, '2 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 --Next, insert some data into the raw hypertable INSERT INTO device_readings SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO device_readings SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; --Initially, it will be empty. SELECT * FROM device_summary; bucket | device_id | metric_avg | metric_spread --------+-----------+------------+--------------- -- Simulate a policy that refreshes with lag, i.e., it doesn't refresh -- the entire data set. In this case up to the given date. CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-30 22:00'); --Now you can run selects over your view as normal SELECT * FROM device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 21:00:00 2018 PST | device_1 | 1546204500 | 1800 Sun Dec 30 21:00:00 2018 PST | device_2 | 1546204500 | 1800 Sun Dec 30 20:00:00 2018 PST | device_1 | 1546200900 | 1800 Sun Dec 30 20:00:00 2018 PST | device_2 | 1546200900 | 1800 Sun Dec 30 19:00:00 2018 PST | device_1 | 1546197300 | 1800 Sun Dec 30 19:00:00 2018 PST | device_2 | 1546197300 | 1800 Sun Dec 30 18:00:00 2018 PST | device_1 | 1546193700 | 1800 Sun Dec 30 18:00:00 2018 PST | device_2 | 1546193700 | 1800 Sun Dec 30 17:00:00 2018 PST | device_1 | 1546190100 | 1800 Sun Dec 30 17:00:00 2018 PST | device_2 | 1546190100 | 1800 --You can view informaton about your continuous aggregates. The meaning of these fields will be explained further down. \x SELECT * FROM timescaledb_information.continuous_aggregates; -[ RECORD 1 ]---------------------+----------------------------------------------------------------------------- hypertable_schema | public hypertable_name | device_readings view_schema | public view_name | device_summary view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_2 view_definition | SELECT time_bucket('@ 1 hour'::interval, observation_time) AS bucket, + | device_id, + | avg(metric) AS metric_avg, + | (max(metric) - min(metric)) AS metric_spread + | FROM device_readings + | GROUP BY (time_bucket('@ 1 hour'::interval, observation_time)), device_id; finalized | t \x -- Refresh interval -- -- The refresh interval determines how often the background worker -- for automatic materialization will run. The default is (2 x bucket_width) SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 2 hours -- You can change this setting with ALTER VIEW (equivalently, specify in WITH clause of CREATE VIEW) SELECT alter_job(1000, schedule_interval := '1h'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 hour","@ 0",-1,"@ 2 hours",t,"{""end_offset"": ""@ 2 hours"", ""start_offset"": null, ""mat_hypertable_id"": 2}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 1 hour -- -- Refresh with lag -- -- It is possible to use a policy or manual refresh with a lag, which -- means the materialization will not contain the most up-to-date -- data. SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Sun Dec 30 21:00:00 2018 PST CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-31 01:00'); SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Mon Dec 31 00:00:00 2018 PST -- -- Invalidations -- --Changes to the raw table, for values that have already been materialized are propagated asynchronously, after the materialization next runs. --Before update: SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 INSERT INTO device_readings VALUES ('Sun Dec 30 13:01:00 2018 PST', 'device_1', 1.0); --Change not reflected before materializer runs. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 CALL refresh_continuous_aggregate('device_summary', NULL, NULL); --But is reflected after. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1030783800.33333 | 1546176599 -- -- Dealing with timezones -- -- You have three options: -- Option 1: be explicit in your timezone: DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_6_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time AT TIME ZONE 'EST') as min_time, --note the explict timezone device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; DROP MATERIALIZED VIEW device_summary; -- Option 2: Keep things as TIMESTAMPTZ in the view and convert to local time when -- querying from the view DROP MATERIALIZED VIEW device_summary; ERROR: materialized view "device_summary" does not exist CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time) as min_time, --this is a TIMESTAMPTZ device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH DATA; NOTICE: refreshing continuous aggregate "device_summary" SELECT min(min_time)::timestamp FROM device_summary; min -------------------------- Sat Dec 01 00:00:00 2018 -- Option 3: use stable expressions in the cagg definition -- in this case it is up to the user to ensure cagg refreshes -- run with consistent values DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_4_7_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time::timestamp) as min_time, --note the cast to localtime device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- -- test just in time aggregate / materialization only view -- -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE device_readings_int(time int, value float); SELECT create_hypertable('device_readings_int','time',chunk_time_interval:=10); create_hypertable ---------------------------------- (6,public,device_readings_int,t) SELECT set_integer_now_func('device_readings_int','device_readings_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW device_readings_mat_only WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW device_readings_jit WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); -- materialization only should have 0 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- simulate a refresh policy with lag, i.e., one that doesn't refresh -- up to the latest data. Max value is 40. CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, 30); CALL refresh_continuous_aggregate('device_readings_jit', NULL, 30); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- add 2 more rows INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(50,60,10) AS g(i); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- hardcoding now to 100 will lead to 80 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 100; $BODY$; -- refresh should materialize all now CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, NULL); CALL refresh_continuous_aggregate('device_readings_jit', NULL, NULL); -- materialization only should have 6 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- START OF BASIC USAGE TESTS -- -- Check that continuous aggregate and materialized table is dropped -- together. CREATE TABLE whatever(time TIMESTAMPTZ NOT NULL, metric INTEGER); SELECT * FROM create_hypertable('whatever', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 9 | public | whatever | t CREATE MATERIALIZED VIEW whatever_summary WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, avg(metric) FROM whatever GROUP BY bucket WITH NO DATA; SELECT (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = raw_hypertable_id) AS raw_table , (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = mat_hypertable_id) AS mat_table FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'whatever_summary' \gset SELECT relname FROM pg_class WHERE oid = :mat_table; relname ----------------------------- _materialized_hypertable_10 ---------------------------------------------------------------- -- Should generate an error since the cagg is dependent on the table. DROP TABLE whatever; ERROR: cannot drop table whatever because other objects depend on it ---------------------------------------------------------------- -- Checking that a cagg cannot be dropped if there is a dependent -- object on it. CREATE VIEW whatever_summary_dependency AS SELECT * FROM whatever_summary; -- Should generate an error DROP MATERIALIZED VIEW whatever_summary; ERROR: cannot drop view whatever_summary because other objects depend on it -- Dropping the dependent view so that we can do a proper drop below. DROP VIEW whatever_summary_dependency; ---------------------------------------------------------------- -- Dropping the cagg should also remove the materialized table DROP MATERIALIZED VIEW whatever_summary; SELECT relname FROM pg_class WHERE oid = :mat_table; relname --------- ---------------------------------------------------------------- -- Cleanup DROP TABLE whatever; -- END OF BASIC USAGE TESTS -- CREATE TABLE metrics(time timestamptz, device TEXT, value float); SELECT table_name FROM create_hypertable('metrics','time'); table_name ------------ metrics INSERT INTO metrics SELECT generate_series('1999-12-20'::timestamptz,'2000-02-01'::timestamptz,'12 day'::interval), 'dev1', 0.25; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" SELECT * FROM cagg1; time_bucket ------------------------------ Mon Dec 20 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg2" SELECT * FROM cagg2; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- custom origin with variable size CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', '2000-01-01'::timestamptz) FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg3" SELECT * FROM cagg3; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- offset with variable size CREATE MATERIALIZED VIEW cagg4 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', "offset":= INTERVAL '15 day') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg4" SELECT * FROM cagg4; time_bucket ------------------------------ Thu Dec 16 00:00:00 1999 PST Sun Jan 16 00:00:00 2000 PST -- -- drop chunks tests -- -- should return 4 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_16_chunk | 0 | f | _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- all caggs in the new format (finalized=true) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | t cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should also remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-01 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_16_chunk -- should return 3 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- let's update the catalog to fake an old format cagg (finalized=false) \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_agg SET finalized=FALSE WHERE user_view_name = 'cagg1'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- cagg1 now is a fake old format (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | f cagg2 | t cagg3 | t cagg4 | t -- cagg1 now is in the old format (finalized=false) -- dropping chunk should NOT remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-13 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- should return 3 chunks and one of them should be marked as dropped SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- remove the fake old format cagg DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_12_20_chunk -- no more old format caggs (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-25 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_18_chunk -- should return 2 chunks and one of them should be marked as dropped -- because we dropped chunk before when an old format cagg exists SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_19_chunk | 0 | f | \set ON_ERROR_STOP 1 SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 CREATE TABLE magic1(time timestamptz not null, device int, value float); CREATE TABLE magic2(time timestamptz not null, device int, value float); CREATE TABLE magic3(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('magic1','time'); table_name ------------ magic1 SELECT table_name FROM create_hypertable('magic2','time'); table_name ------------ magic2 SELECT table_name FROM create_hypertable('magic3','time'); table_name ------------ magic3 INSERT INTO magic1 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic2 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic3 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Creating a materialized view with a failure between adding the slot -- and finishing adding the slot should not leave a slot around. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE bad(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('bad','time'); table_name ------------ bad -- We create such an error by setting the hypertable id sequence -- number to an already existing one, which will generate an error -- when adding the new hypertable data to the catalog. select currval('_timescaledb_catalog.hypertable_id_seq') - 1 as prev_htid \gset select setval('_timescaledb_catalog.hypertable_id_seq', :prev_htid, false); setval -------- 18 \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW bad_summary_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM bad GROUP BY 1,2; ERROR: duplicate key value violates unique constraint "hypertable_pkey" \set ON_ERROR_STOP 1 -- There should be no replication slot around. SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Advance the sequence again to consume the value we set before. SELECT FROM nextval('_timescaledb_catalog.hypertable_id_seq'); -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_cagg_wal_based_invalidation TO true; -- Test the option "invalidate_using". This should create the continuous -- aggregate and there should be a replication slot. CREATE MATERIALIZED VIEW magic1_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary1_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on the same hypertable to be -- able to check that the slot remains after one continuous aggregate -- has been dropped. CREATE MATERIALIZED VIEW magic1_summary2_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary2_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on a different hypertable that -- uses WAL-based invalidation collection. This is used to check that -- the slot stays when we remove all continuous aggregates for a -- hypertable. CREATE MATERIALIZED VIEW magic2_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic2 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic2_summary1_wal" SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 1 DROP MATERIALIZED VIEW magic2_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_22_38_chunk -- Slot should be there. We have another hypertable using WAL-based -- invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_20_36_chunk -- Slot should be there. We have yet another continuous aggregate for -- the hypertable using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary2_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_21_37_chunk -- Now slot should be gone and we should not have any continuous -- aggregates using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_usage-17.out����������������������������������������������0000664�0000000�0000000�00000067044�15100345067�0022513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST SETUP -- \set ON_ERROR_STOP 0 SET client_min_messages TO NOTICE; SET work_mem TO '64MB'; SET timezone TO PST8PDT; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW invalidation_slots AS SELECT * FROM pg_replication_slots WHERE plugin = :'plugin_name'; -- START OF USAGE TEST -- --First create your hypertable CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); table_name ----------------- device_readings --Next, create your continuous aggregate view CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) --This flag is what makes the view continuous AS SELECT time_bucket('1 hour', observation_time) as bucket, --time_bucket is required device_id, avg(metric) as metric_avg, --We can use regular aggregates max(metric)-min(metric) as metric_spread --We can also use expressions on aggregates and constants FROM device_readings GROUP BY bucket, device_id WITH NO DATA; --We have to group by the bucket column, but can also add other group-by columns SELECT add_continuous_aggregate_policy('device_summary', NULL, '2 h'::interval, '2 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 --Next, insert some data into the raw hypertable INSERT INTO device_readings SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO device_readings SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; --Initially, it will be empty. SELECT * FROM device_summary; bucket | device_id | metric_avg | metric_spread --------+-----------+------------+--------------- -- Simulate a policy that refreshes with lag, i.e., it doesn't refresh -- the entire data set. In this case up to the given date. CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-30 22:00'); --Now you can run selects over your view as normal SELECT * FROM device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 21:00:00 2018 PST | device_1 | 1546204500 | 1800 Sun Dec 30 21:00:00 2018 PST | device_2 | 1546204500 | 1800 Sun Dec 30 20:00:00 2018 PST | device_1 | 1546200900 | 1800 Sun Dec 30 20:00:00 2018 PST | device_2 | 1546200900 | 1800 Sun Dec 30 19:00:00 2018 PST | device_1 | 1546197300 | 1800 Sun Dec 30 19:00:00 2018 PST | device_2 | 1546197300 | 1800 Sun Dec 30 18:00:00 2018 PST | device_1 | 1546193700 | 1800 Sun Dec 30 18:00:00 2018 PST | device_2 | 1546193700 | 1800 Sun Dec 30 17:00:00 2018 PST | device_1 | 1546190100 | 1800 Sun Dec 30 17:00:00 2018 PST | device_2 | 1546190100 | 1800 --You can view informaton about your continuous aggregates. The meaning of these fields will be explained further down. \x SELECT * FROM timescaledb_information.continuous_aggregates; -[ RECORD 1 ]---------------------+----------------------------------------------------------------------------- hypertable_schema | public hypertable_name | device_readings view_schema | public view_name | device_summary view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_2 view_definition | SELECT time_bucket('@ 1 hour'::interval, observation_time) AS bucket, + | device_id, + | avg(metric) AS metric_avg, + | (max(metric) - min(metric)) AS metric_spread + | FROM device_readings + | GROUP BY (time_bucket('@ 1 hour'::interval, observation_time)), device_id; finalized | t \x -- Refresh interval -- -- The refresh interval determines how often the background worker -- for automatic materialization will run. The default is (2 x bucket_width) SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 2 hours -- You can change this setting with ALTER VIEW (equivalently, specify in WITH clause of CREATE VIEW) SELECT alter_job(1000, schedule_interval := '1h'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 hour","@ 0",-1,"@ 2 hours",t,"{""end_offset"": ""@ 2 hours"", ""start_offset"": null, ""mat_hypertable_id"": 2}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 1 hour -- -- Refresh with lag -- -- It is possible to use a policy or manual refresh with a lag, which -- means the materialization will not contain the most up-to-date -- data. SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Sun Dec 30 21:00:00 2018 PST CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-31 01:00'); SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Mon Dec 31 00:00:00 2018 PST -- -- Invalidations -- --Changes to the raw table, for values that have already been materialized are propagated asynchronously, after the materialization next runs. --Before update: SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 INSERT INTO device_readings VALUES ('Sun Dec 30 13:01:00 2018 PST', 'device_1', 1.0); --Change not reflected before materializer runs. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 CALL refresh_continuous_aggregate('device_summary', NULL, NULL); --But is reflected after. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1030783800.33333 | 1546176599 -- -- Dealing with timezones -- -- You have three options: -- Option 1: be explicit in your timezone: DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_6_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time AT TIME ZONE 'EST') as min_time, --note the explict timezone device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; DROP MATERIALIZED VIEW device_summary; -- Option 2: Keep things as TIMESTAMPTZ in the view and convert to local time when -- querying from the view DROP MATERIALIZED VIEW device_summary; ERROR: materialized view "device_summary" does not exist CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time) as min_time, --this is a TIMESTAMPTZ device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH DATA; NOTICE: refreshing continuous aggregate "device_summary" SELECT min(min_time)::timestamp FROM device_summary; min -------------------------- Sat Dec 01 00:00:00 2018 -- Option 3: use stable expressions in the cagg definition -- in this case it is up to the user to ensure cagg refreshes -- run with consistent values DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_4_7_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time::timestamp) as min_time, --note the cast to localtime device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- -- test just in time aggregate / materialization only view -- -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE device_readings_int(time int, value float); SELECT create_hypertable('device_readings_int','time',chunk_time_interval:=10); create_hypertable ---------------------------------- (6,public,device_readings_int,t) SELECT set_integer_now_func('device_readings_int','device_readings_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW device_readings_mat_only WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW device_readings_jit WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); -- materialization only should have 0 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- simulate a refresh policy with lag, i.e., one that doesn't refresh -- up to the latest data. Max value is 40. CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, 30); CALL refresh_continuous_aggregate('device_readings_jit', NULL, 30); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- add 2 more rows INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(50,60,10) AS g(i); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- hardcoding now to 100 will lead to 80 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 100; $BODY$; -- refresh should materialize all now CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, NULL); CALL refresh_continuous_aggregate('device_readings_jit', NULL, NULL); -- materialization only should have 6 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- START OF BASIC USAGE TESTS -- -- Check that continuous aggregate and materialized table is dropped -- together. CREATE TABLE whatever(time TIMESTAMPTZ NOT NULL, metric INTEGER); SELECT * FROM create_hypertable('whatever', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 9 | public | whatever | t CREATE MATERIALIZED VIEW whatever_summary WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, avg(metric) FROM whatever GROUP BY bucket WITH NO DATA; SELECT (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = raw_hypertable_id) AS raw_table , (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = mat_hypertable_id) AS mat_table FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'whatever_summary' \gset SELECT relname FROM pg_class WHERE oid = :mat_table; relname ----------------------------- _materialized_hypertable_10 ---------------------------------------------------------------- -- Should generate an error since the cagg is dependent on the table. DROP TABLE whatever; ERROR: cannot drop table whatever because other objects depend on it ---------------------------------------------------------------- -- Checking that a cagg cannot be dropped if there is a dependent -- object on it. CREATE VIEW whatever_summary_dependency AS SELECT * FROM whatever_summary; -- Should generate an error DROP MATERIALIZED VIEW whatever_summary; ERROR: cannot drop view whatever_summary because other objects depend on it -- Dropping the dependent view so that we can do a proper drop below. DROP VIEW whatever_summary_dependency; ---------------------------------------------------------------- -- Dropping the cagg should also remove the materialized table DROP MATERIALIZED VIEW whatever_summary; SELECT relname FROM pg_class WHERE oid = :mat_table; relname --------- ---------------------------------------------------------------- -- Cleanup DROP TABLE whatever; -- END OF BASIC USAGE TESTS -- CREATE TABLE metrics(time timestamptz, device TEXT, value float); SELECT table_name FROM create_hypertable('metrics','time'); table_name ------------ metrics INSERT INTO metrics SELECT generate_series('1999-12-20'::timestamptz,'2000-02-01'::timestamptz,'12 day'::interval), 'dev1', 0.25; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" SELECT * FROM cagg1; time_bucket ------------------------------ Mon Dec 20 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg2" SELECT * FROM cagg2; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- custom origin with variable size CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', '2000-01-01'::timestamptz) FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg3" SELECT * FROM cagg3; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- offset with variable size CREATE MATERIALIZED VIEW cagg4 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', "offset":= INTERVAL '15 day') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg4" SELECT * FROM cagg4; time_bucket ------------------------------ Thu Dec 16 00:00:00 1999 PST Sun Jan 16 00:00:00 2000 PST -- -- drop chunks tests -- -- should return 4 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_16_chunk | 0 | f | _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- all caggs in the new format (finalized=true) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | t cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should also remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-01 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_16_chunk -- should return 3 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- let's update the catalog to fake an old format cagg (finalized=false) \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_agg SET finalized=FALSE WHERE user_view_name = 'cagg1'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- cagg1 now is a fake old format (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | f cagg2 | t cagg3 | t cagg4 | t -- cagg1 now is in the old format (finalized=false) -- dropping chunk should NOT remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-13 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- should return 3 chunks and one of them should be marked as dropped SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- remove the fake old format cagg DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_12_20_chunk -- no more old format caggs (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-25 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_18_chunk -- should return 2 chunks and one of them should be marked as dropped -- because we dropped chunk before when an old format cagg exists SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_19_chunk | 0 | f | \set ON_ERROR_STOP 1 SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 CREATE TABLE magic1(time timestamptz not null, device int, value float); CREATE TABLE magic2(time timestamptz not null, device int, value float); CREATE TABLE magic3(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('magic1','time'); table_name ------------ magic1 SELECT table_name FROM create_hypertable('magic2','time'); table_name ------------ magic2 SELECT table_name FROM create_hypertable('magic3','time'); table_name ------------ magic3 INSERT INTO magic1 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic2 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic3 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Creating a materialized view with a failure between adding the slot -- and finishing adding the slot should not leave a slot around. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE bad(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('bad','time'); table_name ------------ bad -- We create such an error by setting the hypertable id sequence -- number to an already existing one, which will generate an error -- when adding the new hypertable data to the catalog. select currval('_timescaledb_catalog.hypertable_id_seq') - 1 as prev_htid \gset select setval('_timescaledb_catalog.hypertable_id_seq', :prev_htid, false); setval -------- 18 \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW bad_summary_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM bad GROUP BY 1,2; ERROR: duplicate key value violates unique constraint "hypertable_pkey" \set ON_ERROR_STOP 1 -- There should be no replication slot around. SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Advance the sequence again to consume the value we set before. SELECT FROM nextval('_timescaledb_catalog.hypertable_id_seq'); -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_cagg_wal_based_invalidation TO true; -- Test the option "invalidate_using". This should create the continuous -- aggregate and there should be a replication slot. CREATE MATERIALIZED VIEW magic1_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary1_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on the same hypertable to be -- able to check that the slot remains after one continuous aggregate -- has been dropped. CREATE MATERIALIZED VIEW magic1_summary2_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary2_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on a different hypertable that -- uses WAL-based invalidation collection. This is used to check that -- the slot stays when we remove all continuous aggregates for a -- hypertable. CREATE MATERIALIZED VIEW magic2_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic2 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic2_summary1_wal" SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 1 DROP MATERIALIZED VIEW magic2_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_22_38_chunk -- Slot should be there. We have another hypertable using WAL-based -- invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_20_36_chunk -- Slot should be there. We have yet another continuous aggregate for -- the hypertable using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary2_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_21_37_chunk -- Now slot should be gone and we should not have any continuous -- aggregates using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_usage-18.out����������������������������������������������0000664�0000000�0000000�00000067044�15100345067�0022514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST SETUP -- \set ON_ERROR_STOP 0 SET client_min_messages TO NOTICE; SET work_mem TO '64MB'; SET timezone TO PST8PDT; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW invalidation_slots AS SELECT * FROM pg_replication_slots WHERE plugin = :'plugin_name'; -- START OF USAGE TEST -- --First create your hypertable CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); table_name ----------------- device_readings --Next, create your continuous aggregate view CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) --This flag is what makes the view continuous AS SELECT time_bucket('1 hour', observation_time) as bucket, --time_bucket is required device_id, avg(metric) as metric_avg, --We can use regular aggregates max(metric)-min(metric) as metric_spread --We can also use expressions on aggregates and constants FROM device_readings GROUP BY bucket, device_id WITH NO DATA; --We have to group by the bucket column, but can also add other group-by columns SELECT add_continuous_aggregate_policy('device_summary', NULL, '2 h'::interval, '2 h'::interval); add_continuous_aggregate_policy --------------------------------- 1000 --Next, insert some data into the raw hypertable INSERT INTO device_readings SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO device_readings SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; --Initially, it will be empty. SELECT * FROM device_summary; bucket | device_id | metric_avg | metric_spread --------+-----------+------------+--------------- -- Simulate a policy that refreshes with lag, i.e., it doesn't refresh -- the entire data set. In this case up to the given date. CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-30 22:00'); --Now you can run selects over your view as normal SELECT * FROM device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 21:00:00 2018 PST | device_1 | 1546204500 | 1800 Sun Dec 30 21:00:00 2018 PST | device_2 | 1546204500 | 1800 Sun Dec 30 20:00:00 2018 PST | device_1 | 1546200900 | 1800 Sun Dec 30 20:00:00 2018 PST | device_2 | 1546200900 | 1800 Sun Dec 30 19:00:00 2018 PST | device_1 | 1546197300 | 1800 Sun Dec 30 19:00:00 2018 PST | device_2 | 1546197300 | 1800 Sun Dec 30 18:00:00 2018 PST | device_1 | 1546193700 | 1800 Sun Dec 30 18:00:00 2018 PST | device_2 | 1546193700 | 1800 Sun Dec 30 17:00:00 2018 PST | device_1 | 1546190100 | 1800 Sun Dec 30 17:00:00 2018 PST | device_2 | 1546190100 | 1800 --You can view informaton about your continuous aggregates. The meaning of these fields will be explained further down. \x SELECT * FROM timescaledb_information.continuous_aggregates; -[ RECORD 1 ]---------------------+----------------------------------------------------------------------------- hypertable_schema | public hypertable_name | device_readings view_schema | public view_name | device_summary view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_2 view_definition | SELECT time_bucket('@ 1 hour'::interval, observation_time) AS bucket, + | device_id, + | avg(metric) AS metric_avg, + | (max(metric) - min(metric)) AS metric_spread + | FROM device_readings + | GROUP BY (time_bucket('@ 1 hour'::interval, observation_time)), device_id; finalized | t \x -- Refresh interval -- -- The refresh interval determines how often the background worker -- for automatic materialization will run. The default is (2 x bucket_width) SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 2 hours -- You can change this setting with ALTER VIEW (equivalently, specify in WITH clause of CREATE VIEW) SELECT alter_job(1000, schedule_interval := '1h'); alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 hour","@ 0",-1,"@ 2 hours",t,"{""end_offset"": ""@ 2 hours"", ""start_offset"": null, ""mat_hypertable_id"": 2}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1000]") SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; schedule_interval ------------------- @ 1 hour -- -- Refresh with lag -- -- It is possible to use a policy or manual refresh with a lag, which -- means the materialization will not contain the most up-to-date -- data. SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Sun Dec 30 21:00:00 2018 PST CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-31 01:00'); SELECT max(observation_time) FROM device_readings; max ------------------------------ Mon Dec 31 00:00:00 2018 PST SELECT max(bucket) FROM device_summary; max ------------------------------ Mon Dec 31 00:00:00 2018 PST -- -- Invalidations -- --Changes to the raw table, for values that have already been materialized are propagated asynchronously, after the materialization next runs. --Before update: SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 INSERT INTO device_readings VALUES ('Sun Dec 30 13:01:00 2018 PST', 'device_1', 1.0); --Change not reflected before materializer runs. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1546175700 | 1800 CALL refresh_continuous_aggregate('device_summary', NULL, NULL); --But is reflected after. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; bucket | device_id | metric_avg | metric_spread ------------------------------+-----------+------------------+--------------- Sun Dec 30 13:00:00 2018 PST | device_1 | 1030783800.33333 | 1546176599 -- -- Dealing with timezones -- -- You have three options: -- Option 1: be explicit in your timezone: DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_6_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time AT TIME ZONE 'EST') as min_time, --note the explict timezone device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; DROP MATERIALIZED VIEW device_summary; -- Option 2: Keep things as TIMESTAMPTZ in the view and convert to local time when -- querying from the view DROP MATERIALIZED VIEW device_summary; ERROR: materialized view "device_summary" does not exist CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time) as min_time, --this is a TIMESTAMPTZ device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH DATA; NOTICE: refreshing continuous aggregate "device_summary" SELECT min(min_time)::timestamp FROM device_summary; min -------------------------- Sat Dec 01 00:00:00 2018 -- Option 3: use stable expressions in the cagg definition -- in this case it is up to the user to ensure cagg refreshes -- run with consistent values DROP MATERIALIZED VIEW device_summary; NOTICE: drop cascades to table _timescaledb_internal._hyper_4_7_chunk CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time::timestamp) as min_time, --note the cast to localtime device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; WARNING: using non-immutable functions in continuous aggregate view may lead to inconsistent results on rematerialization -- -- test just in time aggregate / materialization only view -- -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE device_readings_int(time int, value float); SELECT create_hypertable('device_readings_int','time',chunk_time_interval:=10); create_hypertable ---------------------------------- (6,public,device_readings_int,t) SELECT set_integer_now_func('device_readings_int','device_readings_int_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW device_readings_mat_only WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW device_readings_jit WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); -- materialization only should have 0 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- simulate a refresh policy with lag, i.e., one that doesn't refresh -- up to the latest data. Max value is 40. CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, 30); CALL refresh_continuous_aggregate('device_readings_jit', NULL, 30); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 -- add 2 more rows INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(50,60,10) AS g(i); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- hardcoding now to 100 will lead to 80 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 100; $BODY$; -- refresh should materialize all now CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, NULL); CALL refresh_continuous_aggregate('device_readings_jit', NULL, NULL); -- materialization only should have 6 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; time_bucket | avg -------------+----- 10 | 100 20 | 200 30 | 300 40 | 400 50 | 500 60 | 600 -- START OF BASIC USAGE TESTS -- -- Check that continuous aggregate and materialized table is dropped -- together. CREATE TABLE whatever(time TIMESTAMPTZ NOT NULL, metric INTEGER); SELECT * FROM create_hypertable('whatever', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 9 | public | whatever | t CREATE MATERIALIZED VIEW whatever_summary WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, avg(metric) FROM whatever GROUP BY bucket WITH NO DATA; SELECT (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = raw_hypertable_id) AS raw_table , (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = mat_hypertable_id) AS mat_table FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'whatever_summary' \gset SELECT relname FROM pg_class WHERE oid = :mat_table; relname ----------------------------- _materialized_hypertable_10 ---------------------------------------------------------------- -- Should generate an error since the cagg is dependent on the table. DROP TABLE whatever; ERROR: cannot drop table whatever because other objects depend on it ---------------------------------------------------------------- -- Checking that a cagg cannot be dropped if there is a dependent -- object on it. CREATE VIEW whatever_summary_dependency AS SELECT * FROM whatever_summary; -- Should generate an error DROP MATERIALIZED VIEW whatever_summary; ERROR: cannot drop view whatever_summary because other objects depend on it -- Dropping the dependent view so that we can do a proper drop below. DROP VIEW whatever_summary_dependency; ---------------------------------------------------------------- -- Dropping the cagg should also remove the materialized table DROP MATERIALIZED VIEW whatever_summary; SELECT relname FROM pg_class WHERE oid = :mat_table; relname --------- ---------------------------------------------------------------- -- Cleanup DROP TABLE whatever; -- END OF BASIC USAGE TESTS -- CREATE TABLE metrics(time timestamptz, device TEXT, value float); SELECT table_name FROM create_hypertable('metrics','time'); table_name ------------ metrics INSERT INTO metrics SELECT generate_series('1999-12-20'::timestamptz,'2000-02-01'::timestamptz,'12 day'::interval), 'dev1', 0.25; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" SELECT * FROM cagg1; time_bucket ------------------------------ Mon Dec 20 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST Tue Jan 25 00:00:00 2000 PST CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg2" SELECT * FROM cagg2; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- custom origin with variable size CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', '2000-01-01'::timestamptz) FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg3" SELECT * FROM cagg3; time_bucket ------------------------------ Wed Dec 01 00:00:00 1999 PST Sat Jan 01 00:00:00 2000 PST -- offset with variable size CREATE MATERIALIZED VIEW cagg4 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', "offset":= INTERVAL '15 day') FROM metrics GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg4" SELECT * FROM cagg4; time_bucket ------------------------------ Thu Dec 16 00:00:00 1999 PST Sun Jan 16 00:00:00 2000 PST -- -- drop chunks tests -- -- should return 4 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_16_chunk | 0 | f | _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- all caggs in the new format (finalized=true) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | t cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should also remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-01 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_16_chunk -- should return 3 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | f | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- let's update the catalog to fake an old format cagg (finalized=false) \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_agg SET finalized=FALSE WHERE user_view_name = 'cagg1'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- cagg1 now is a fake old format (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg1 | f cagg2 | t cagg3 | t cagg4 | t -- cagg1 now is in the old format (finalized=false) -- dropping chunk should NOT remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-13 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_17_chunk -- should return 3 chunks and one of them should be marked as dropped SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_18_chunk | 0 | f | _hyper_11_19_chunk | 0 | f | -- remove the fake old format cagg DROP MATERIALIZED VIEW cagg1; NOTICE: drop cascades to table _timescaledb_internal._hyper_12_20_chunk -- no more old format caggs (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; user_view_name | finalized ----------------+----------- cagg2 | t cagg3 | t cagg4 | t -- dropping chunk should remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-25 00:00:00-02'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_11_18_chunk -- should return 2 chunks and one of them should be marked as dropped -- because we dropped chunk before when an old format cagg exists SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_11_17_chunk | 0 | t | _hyper_11_19_chunk | 0 | f | \set ON_ERROR_STOP 1 SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 CREATE TABLE magic1(time timestamptz not null, device int, value float); CREATE TABLE magic2(time timestamptz not null, device int, value float); CREATE TABLE magic3(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('magic1','time'); table_name ------------ magic1 SELECT table_name FROM create_hypertable('magic2','time'); table_name ------------ magic2 SELECT table_name FROM create_hypertable('magic3','time'); table_name ------------ magic3 INSERT INTO magic1 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic2 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic3 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Creating a materialized view with a failure between adding the slot -- and finishing adding the slot should not leave a slot around. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE bad(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('bad','time'); table_name ------------ bad -- We create such an error by setting the hypertable id sequence -- number to an already existing one, which will generate an error -- when adding the new hypertable data to the catalog. select currval('_timescaledb_catalog.hypertable_id_seq') - 1 as prev_htid \gset select setval('_timescaledb_catalog.hypertable_id_seq', :prev_htid, false); setval -------- 18 \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW bad_summary_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM bad GROUP BY 1,2; ERROR: duplicate key value violates unique constraint "hypertable_pkey" \set ON_ERROR_STOP 1 -- There should be no replication slot around. SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 0 -- Advance the sequence again to consume the value we set before. SELECT FROM nextval('_timescaledb_catalog.hypertable_id_seq'); -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_cagg_wal_based_invalidation TO true; -- Test the option "invalidate_using". This should create the continuous -- aggregate and there should be a replication slot. CREATE MATERIALIZED VIEW magic1_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary1_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on the same hypertable to be -- able to check that the slot remains after one continuous aggregate -- has been dropped. CREATE MATERIALIZED VIEW magic1_summary2_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic1_summary2_wal" SELECT count(*) FROM invalidation_slots WHERE database = current_database(); count ------- 1 -- Create another continuous aggregate on a different hypertable that -- uses WAL-based invalidation collection. This is used to check that -- the slot stays when we remove all continuous aggregates for a -- hypertable. CREATE MATERIALIZED VIEW magic2_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic2 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "magic2_summary1_wal" SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 1 DROP MATERIALIZED VIEW magic2_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_22_38_chunk -- Slot should be there. We have another hypertable using WAL-based -- invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary1_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_20_36_chunk -- Slot should be there. We have yet another continuous aggregate for -- the hypertable using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 DROP MATERIALIZED VIEW magic1_summary2_wal; NOTICE: drop cascades to table _timescaledb_internal._hyper_21_37_chunk -- Now slot should be gone and we should not have any continuous -- aggregates using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); count ------- 0 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_utils.out�������������������������������������������������0000664�0000000�0000000�00000061450�15100345067�0022315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET search_path TO public, _timescaledb_functions; SET timezone TO PST8PDT; CREATE TABLE devices ( id INTEGER, name TEXT ); CREATE TABLE metrics ( "time" TIMESTAMPTZ NOT NULL, device_id INTEGER, value FLOAT8 ); SELECT table_name FROM create_hypertable('metrics', 'time'); table_name ------------ metrics -- fixed bucket size CREATE MATERIALIZED VIEW metrics_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, count(*) FROM metrics GROUP BY 1 WITH NO DATA; -- variable bucket size CREATE MATERIALIZED VIEW metrics_by_month WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 WITH NO DATA; -- -- ERRORS -- -- return NULL SELECT * FROM cagg_validate_query(NULL); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ | | | | | -- nothing to parse SELECT * FROM cagg_validate_query(''); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+-----------------------+--------------+------------ f | ERROR | XX000 | failed to parse query | | SELECT * FROM cagg_validate_query('--'); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+-----------------------+--------------+------------ f | ERROR | XX000 | failed to parse query | | SELECT * FROM cagg_validate_query(';'); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+-----------------------+--------------+------------ f | ERROR | XX000 | failed to parse query | | -- syntax error SELECT * FROM cagg_validate_query('blahh'); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------------------------+--------------+------------ f | ERROR | 42601 | syntax error at or near "blahh" | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket(blahh "time") FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+----------------------------------+--------------+------------ f | ERROR | 42601 | syntax error at or near ""time"" | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour' "time") FROM metrics GROUP BY $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+----------------------------------+--------------+------------ f | ERROR | 42601 | syntax error at or near ""time"" | | -- multiple statements are not allowed SELECT * FROM cagg_validate_query($$ SELECT 1; SELECT 2; $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------------------------------+--------------+------------ f | WARNING | 0A000 | multiple statements are not supported | | -- only SELECT queries are allowed SELECT * FROM cagg_validate_query($$ DELETE FROM pg_catalog.pg_class $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+--------------------------------------+--------------+------------ f | WARNING | 0A000 | only select statements are supported | | SELECT * FROM cagg_validate_query($$ UPDATE pg_catalog.pg_class SET relkind = 'r' $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+--------------------------------------+--------------+------------ f | WARNING | 0A000 | only select statements are supported | | SELECT * FROM cagg_validate_query($$ DELETE FROM pg_catalog.pg_class $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+--------------------------------------+--------------+------------ f | WARNING | 0A000 | only select statements are supported | | SELECT * FROM cagg_validate_query($$ VACUUM (ANALYZE) $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+--------------------------------------+--------------+------------ f | WARNING | 0A000 | only select statements are supported | | -- invalid queries SELECT * FROM cagg_validate_query($$ SELECT 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+------------------------------------+--------------+---------------------------------- f | ERROR | 0A000 | invalid continuous aggregate query | | FROM clause missing in the query SELECT * FROM cagg_validate_query($$ SELECT 1 FROM pg_catalog.pg_class $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+------------------------------------+--------------+--------------------------------------------------------------------------------- f | ERROR | 0A000 | invalid continuous aggregate query | | Include at least one aggregate function and a GROUP BY clause with time bucket. SELECT * FROM cagg_validate_query($$ SELECT relkind, count(*) FROM pg_catalog.pg_class GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+-----------------------------------+----------------------------------------------------------------+------------ f | ERROR | 0A000 | invalid continuous aggregate view | At least one hypertable should be used in the view definition. | -- time_bucket with offset is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", "offset" => '-1 minute'::interval), count(*) FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- time_bucket with origin is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", origin => '2023-01-01'::timestamptz), count(*) FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- time_bucket with origin is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", origin => '2023-01-01'::timestamptz), count(*) FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- time_bucket_gapfill is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket_gapfill('1 hour', "time"), count(*) FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------------------------------------------------------------+--------------+------------ f | ERROR | 0A000 | continuous aggregate view must include a valid time bucket function | | -- invalid join queries SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', a."time"), count(*) FROM metrics a, metrics b GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+-----------------------------------+--------------------------------------------------------------+------------ f | ERROR | 0A000 | invalid continuous aggregate view | Only one hypertable is allowed in continuous aggregate view. | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), count(*) FROM metrics, devices a, devices b GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics LEFT JOIN devices ON id = device_id GROUP BY 1, 2 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id = device_id AND name = 'foo' GROUP BY 1, 2 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id < device_id GROUP BY 1, 2 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- invalid caggs on caggs SELECT * FROM cagg_validate_query($$ SELECT time_bucket('60 days', bucket) AS bucket, sum(count) AS count FROM metrics_by_month GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+------------ f | ERROR | 0A000 | cannot create continuous aggregate with fixed-width bucket on top of one using variable-width bucket | Continuous aggregate with a fixed time bucket width (e.g. 61 days) cannot be created on top of one using variable time bucket width (e.g. 1 month).+| | | | | The variance can lead to the fixed width one not being a multiple of the variable width one. | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 day 33 minutes', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+-------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------+------------ f | ERROR | 0A000 | cannot create continuous aggregate with incompatible bucket width | Time bucket width of "public.cagg_validate" [@ 1 day 33 mins] should be multiple of the time bucket width of "public.metrics_by_hour" [@ 1 hour]. | -- -- OK -- -- valid join queries SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id = device_id GROUP BY 1, 2 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id = device_id WHERE devices.name = 'foo' GROUP BY 1, 2 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- valid queries SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), count(*) FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", timezone => 'UTC'), count(*) FROM metrics GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", timezone => 'UTC'), count(*) FROM metrics GROUP BY 1 HAVING count(*) > 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- caggs on caggs SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 day', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 month', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 year', bucket) AS bucket, sum(count) AS count FROM metrics_by_month GROUP BY 1 $$); is_valid | error_level | error_code | error_message | error_detail | error_hint ----------+-------------+------------+---------------+--------------+------------ t | | | | | -- -- Test bucket Oid recovery -- SET timezone TO PST8PDT; CREATE TABLE timestamp_ht ( time timestamp NOT NULL, value float ); SELECT create_hypertable('timestamp_ht', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable --------------------------- (4,public,timestamp_ht,t) INSERT INTO timestamp_ht SELECT time, ceil(random() * 100)::int FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW temperature_4h WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; NOTICE: refreshing continuous aggregate "temperature_4h" CREATE TABLE timestamptz_ht ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('timestamptz_ht', 'time'); create_hypertable ----------------------------- (6,public,timestamptz_ht,t) INSERT INTO timestamptz_ht SELECT time, ceil(random() * 100)::int FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW temperature_tz_4h WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; NOTICE: refreshing continuous aggregate "temperature_tz_4h" CREATE MATERIALIZED VIEW temperature_tz_4h_ts WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, 'Europe/Berlin'), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; NOTICE: refreshing continuous aggregate "temperature_tz_4h_ts" CREATE MATERIALIZED VIEW temperature_tz_4h_ts_origin WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, timezone => 'Europe/Berlin', origin => '2001-01-01'::timestamptz), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; NOTICE: refreshing continuous aggregate "temperature_tz_4h_ts_origin" CREATE MATERIALIZED VIEW temperature_tz_4h_ts_offset WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, timezone => 'Europe/Berlin', "offset" => '1 hour'::interval), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; NOTICE: refreshing continuous aggregate "temperature_tz_4h_ts_offset" CREATE TABLE integer_ht(a integer, b integer, c integer); SELECT table_name FROM create_hypertable('integer_ht', 'a', chunk_time_interval=> 10); table_name ------------ integer_ht CREATE OR REPLACE FUNCTION integer_now_integer_ht() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM integer_ht $$; SELECT set_integer_now_func('integer_ht', 'integer_now_integer_ht'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW integer_ht_cagg WITH (timescaledb.continuous) AS SELECT time_bucket(1, a) AS bucket, a, count(b) FROM integer_ht GROUP BY bucket, a; NOTICE: continuous aggregate "integer_ht_cagg" is already up-to-date CREATE MATERIALIZED VIEW integer_ht_cagg_offset WITH (timescaledb.continuous) AS SELECT time_bucket(1, a, "offset" => 10) AS bucket, a, count(b) FROM integer_ht GROUP BY bucket, a; NOTICE: continuous aggregate "integer_ht_cagg_offset" is already up-to-date -- Get the bucket Oids SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name IN ('temperature_4h', 'temperature_tz_4h', 'temperature_tz_4h_ts', 'temperature_tz_4h_ts_origin', 'temperature_tz_4h_ts_offset', 'integer_ht_cagg', 'integer_ht_cagg_offset') ORDER BY user_view_name; user_view_name | bucket_func -----------------------------+--------------------------------------------------------------------------------------- integer_ht_cagg | time_bucket(integer,integer) integer_ht_cagg_offset | time_bucket(integer,integer,integer) temperature_4h | time_bucket(interval,timestamp without time zone) temperature_tz_4h | time_bucket(interval,timestamp with time zone) temperature_tz_4h_ts | time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) temperature_tz_4h_ts_offset | time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) temperature_tz_4h_ts_origin | time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) -- Get all bucket function information SELECT user_view_name, bf.* FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name IN ('temperature_4h', 'temperature_tz_4h', 'temperature_tz_4h_ts', 'temperature_tz_4h_ts_origin', 'temperature_tz_4h_ts_offset', 'integer_ht_cagg', 'integer_ht_cagg_offset') ORDER BY user_view_name; user_view_name | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -----------------------------+---------------------------------------------------------------------------------------+--------------+------------------------------+---------------+-----------------+-------------------- integer_ht_cagg | time_bucket(integer,integer) | 1 | | | | t integer_ht_cagg_offset | time_bucket(integer,integer,integer) | 1 | | 10 | | t temperature_4h | time_bucket(interval,timestamp without time zone) | @ 4 hours | | | | t temperature_tz_4h | time_bucket(interval,timestamp with time zone) | @ 4 hours | | | | t temperature_tz_4h_ts | time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) | @ 4 hours | | | Europe/Berlin | f temperature_tz_4h_ts_offset | time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) | @ 4 hours | | @ 1 hour | Europe/Berlin | f temperature_tz_4h_ts_origin | time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) | @ 4 hours | Mon Jan 01 00:00:00 2001 PST | | Europe/Berlin | f -- Valid multiple time_bucket usage on view definition CREATE MATERIALIZED VIEW temperature_tz_4h_2 WITH (timescaledb.continuous) AS SELECT (time_bucket('4 hour', time) at time zone 'utc')::date, avg(value) FROM timestamptz_ht GROUP BY time_bucket('4 hour', time) ORDER BY 1 WITH NO DATA; SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name = 'temperature_tz_4h_2' ORDER BY user_view_name; user_view_name | bucket_func ---------------------+------------------------------------------------ temperature_tz_4h_2 | time_bucket(interval,timestamp with time zone) -- Corrupt the direct view definition \c :TEST_DBNAME :ROLE_SUPERUSER SELECT direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'temperature_tz_4h_2' \gset CREATE OR REPLACE VIEW :direct_view_schema.:direct_view_name AS SELECT NULL::date AS timezone, NULL::FLOAT8 AS avg; \set ON_ERROR_STOP 0 -- Should error because there's no time_bucket function on the view definition SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name = 'temperature_tz_4h_2' ORDER BY user_view_name; ERROR: time_bucket function not found in CAgg definition for mat_ht_id: 14 \set ON_ERROR_STOP 1 -- Group by another function to make sure it will be ignored CREATE FUNCTION skip() RETURNS INTEGER AS $$ SELECT 1; $$ IMMUTABLE LANGUAGE SQL; CREATE MATERIALIZED VIEW temperature_tz_4h_3 WITH (timescaledb.continuous) AS SELECT skip(), time_bucket('4 hour', time), avg(value) FROM timestamptz_ht GROUP BY 1, 2 ORDER BY 1 WITH NO DATA; SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name = 'temperature_tz_4h_3' ORDER BY user_view_name; user_view_name | bucket_func ---------------------+------------------------------------------------ temperature_tz_4h_3 | time_bucket(interval,timestamp with time zone) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/cagg_watermark.out���������������������������������������������0000664�0000000�0000000�00000360611�15100345067�0023153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN_ANALYZE 'EXPLAIN (analyze,buffers off, costs off,timing off,summary off)' CREATE TABLE continuous_agg_test(time int, data int); SELECT create_hypertable('continuous_agg_test', 'time', chunk_time_interval=> 10); create_hypertable ---------------------------------- (1,public,continuous_agg_test,t) CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM continuous_agg_test $$; SELECT set_integer_now_func('continuous_agg_test', 'integer_now_test1'); set_integer_now_func ---------------------- -- watermark tabels start out empty SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- -- inserting into a table that does not have continuous_agg_insert_trigger doesn't change the watermark INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2), (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- CREATE MATERIALIZED VIEW cagg1 WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket('5', time) FROM continuous_agg_test GROUP BY 1 WITH NO DATA; -- inserting into the table still doesn't change the watermark since there's no -- continuous_aggs_invalidation_threshold. We treat that case as a invalidation_watermark of -- BIG_INT_MIN, since the first run of the aggregation will need to scan the -- entire table anyway. INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2), (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+------------- 1 | -2147483648 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- -- set the continuous_aggs_invalidation_threshold to 15, any insertions below that value need an invalidation \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_aggs_invalidation_threshold SET watermark = 15 WHERE hypertable_id = 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2), (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 -- INSERTs only above the continuous_aggs_invalidation_threshold won't change the continuous_aggs_hypertable_invalidation_log INSERT INTO continuous_agg_test VALUES (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 -- INSERTs only below the continuous_aggs_invalidation_threshold will change the continuous_aggs_hypertable_invalidation_log INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 1 | 10 | 11 -- test INSERTing other values INSERT INTO continuous_agg_test VALUES (1, 7), (12, 6), (24, 5), (51, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 1 | 10 | 11 1 | 1 | 51 -- INSERT after dropping a COLUMN ALTER TABLE continuous_agg_test DROP COLUMN data; INSERT INTO continuous_agg_test VALUES (-1), (-2), (-3), (-4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 1 | 10 | 11 1 | 1 | 51 1 | -4 | -1 INSERT INTO continuous_agg_test VALUES (100); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 1 | 10 | 11 1 | 1 | 51 1 | -4 | -1 -- INSERT after adding a COLUMN ALTER TABLE continuous_agg_test ADD COLUMN d BOOLEAN; INSERT INTO continuous_agg_test VALUES (-6, true), (-7, false), (-3, true), (-4, false); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 1 | 10 | 11 1 | 1 | 51 1 | -4 | -1 1 | -7 | -3 INSERT INTO continuous_agg_test VALUES (120, false), (200, true); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 1 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 1 | 10 | 22 1 | 10 | 11 1 | 1 | 51 1 | -4 | -1 1 | -7 | -3 \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_agg where mat_hypertable_id = 2; DELETE FROM _timescaledb_config.bgw_job WHERE id = 2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER DROP TABLE continuous_agg_test CASCADE; NOTICE: drop cascades to 3 other objects \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; TRUNCATE _timescaledb_catalog.continuous_aggs_invalidation_threshold; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- CREATE VIEW creates the invalidation trigger correctly CREATE TABLE ca_inval_test(time int); SELECT create_hypertable('ca_inval_test', 'time', chunk_time_interval=> 10); create_hypertable ---------------------------- (3,public,ca_inval_test,t) CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM ca_inval_test $$; SELECT set_integer_now_func('ca_inval_test', 'integer_now_test2'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW cit_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM ca_inval_test GROUP BY 1 WITH NO DATA; INSERT INTO ca_inval_test SELECT generate_series(0, 5); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+------------- 3 | -2147483648 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_aggs_invalidation_threshold SET watermark = 15 WHERE hypertable_id = 3; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER INSERT INTO ca_inval_test SELECT generate_series(5, 15); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 3 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 3 | 5 | 15 INSERT INTO ca_inval_test SELECT generate_series(16, 20); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 3 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 3 | 5 | 15 \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- updates below the threshold update both the old and new values UPDATE ca_inval_test SET time = 5 WHERE time = 6; UPDATE ca_inval_test SET time = 7 WHERE time = 5; UPDATE ca_inval_test SET time = 17 WHERE time = 14; UPDATE ca_inval_test SET time = 12 WHERE time = 16; -- updates purely above the threshold are not logged UPDATE ca_inval_test SET time = 19 WHERE time = 18; UPDATE ca_inval_test SET time = 17 WHERE time = 19; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 3 | 15 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 3 | 5 | 6 3 | 5 | 7 3 | 14 | 17 3 | 12 | 16 DROP TABLE ca_inval_test CASCADE; NOTICE: drop cascades to 3 other objects \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; TRUNCATE _timescaledb_catalog.continuous_aggs_invalidation_threshold; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- invalidation trigger is created correctly on chunks that existed before -- the view was created CREATE TABLE ts_continuous_test(time INTEGER, location INTEGER); SELECT create_hypertable('ts_continuous_test', 'time', chunk_time_interval => 10); create_hypertable --------------------------------- (5,public,ts_continuous_test,t) CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM ts_continuous_test $$; SELECT set_integer_now_func('ts_continuous_test', 'integer_now_test3'); set_integer_now_func ---------------------- INSERT INTO ts_continuous_test SELECT i, i FROM (SELECT generate_series(0, 29) AS i) AS i; CREATE MATERIALIZED VIEW continuous_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+------------- 5 | -2147483648 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_aggs_invalidation_threshold SET watermark = 2 WHERE hypertable_id = 5; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER INSERT INTO ts_continuous_test VALUES (1, 1); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 5 | 2 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 5 | 1 | 1 -- aborts don't get written BEGIN; INSERT INTO ts_continuous_test VALUES (-20, -20); ABORT; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; hypertable_id | watermark ---------------+----------- 5 | 2 SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 5 | 1 | 1 DROP TABLE ts_continuous_test CASCADE; NOTICE: drop cascades to 3 other objects ---- -- Test watermark invalidation and chunk exclusion with prepared and ad-hoc queries ---- CREATE TABLE chunks(time timestamptz, device int, value float); SELECT FROM create_hypertable('chunks','time',chunk_time_interval:='1d'::interval); -- CREATE MATERIALIZED VIEW chunks_1h WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 hour', time) AS bucket, device, max(value) AS max FROM chunks GROUP BY 1, 2; NOTICE: continuous aggregate "chunks_1h" is already up-to-date -- Get id of the materialization hypertable SELECT id AS "MAT_HT_ID_1H" FROM _timescaledb_catalog.hypertable WHERE table_name=( SELECT materialization_hypertable_name FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1h' ) \gset SELECT materialization_hypertable_schema || '.' || materialization_hypertable_name AS "MAT_HT_NAME_1H" FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1h' \gset -- Prepared scan on hypertable (identical to the query of a real-time CAgg) PREPARE ht_scan_realtime_1h AS SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('01:00:00'::interval, chunks."time") AS bucket, chunks.device, max(chunks.value) AS max FROM chunks WHERE chunks."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('01:00:00'::interval, chunks."time")), chunks.device; PREPARE cagg_scan_1h AS SELECT * FROM chunks_1h; :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, chunks."time"), chunks.device -> Result (actual rows=0.00 loops=1) One-Time Filter: false INSERT INTO chunks VALUES ('2000-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Mon Jul 31 18:00:00 2000 PDT :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_16_chunk."time"), _hyper_7_16_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_16_chunk_chunks_time_idx on _hyper_7_16_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -- Compare prepared statement with ad-hoc query EXECUTE cagg_scan_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 SELECT * FROM chunks_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 -- Add new chunks to the non materialized part of the CAgg INSERT INTO chunks VALUES ('2001-08-01 01:01:01+01', 1, 2); :EXPLAIN_ANALYZE EXECUTE cagg_scan_1h; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Finalize HashAggregate (actual rows=1.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Append (actual rows=1.00 loops=1) -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_16_chunk."time"), _hyper_7_16_chunk.device -> Index Scan using _hyper_7_16_chunk_chunks_time_idx on _hyper_7_16_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_18_chunk."time"), _hyper_7_18_chunk.device -> Index Scan using _hyper_7_18_chunk_chunks_time_idx on _hyper_7_18_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Finalize HashAggregate (actual rows=1.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Append (actual rows=1.00 loops=1) -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_16_chunk."time"), _hyper_7_16_chunk.device -> Index Scan using _hyper_7_16_chunk_chunks_time_idx on _hyper_7_16_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_18_chunk."time"), _hyper_7_18_chunk.device -> Index Scan using _hyper_7_18_chunk_chunks_time_idx on _hyper_7_18_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) INSERT INTO chunks VALUES ('2002-08-01 01:01:01+01', 1, 2); :EXPLAIN_ANALYZE EXECUTE cagg_scan_1h; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Append (actual rows=2.00 loops=1) -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_16_chunk."time"), _hyper_7_16_chunk.device -> Index Scan using _hyper_7_16_chunk_chunks_time_idx on _hyper_7_16_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_18_chunk."time"), _hyper_7_18_chunk.device -> Index Scan using _hyper_7_18_chunk_chunks_time_idx on _hyper_7_18_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_19_chunk."time"), _hyper_7_19_chunk.device -> Index Scan using _hyper_7_19_chunk_chunks_time_idx on _hyper_7_19_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Finalize HashAggregate (actual rows=2.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Append (actual rows=2.00 loops=1) -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_16_chunk."time"), _hyper_7_16_chunk.device -> Index Scan using _hyper_7_16_chunk_chunks_time_idx on _hyper_7_16_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_18_chunk."time"), _hyper_7_18_chunk.device -> Index Scan using _hyper_7_18_chunk_chunks_time_idx on _hyper_7_18_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -> Partial HashAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_19_chunk."time"), _hyper_7_19_chunk.device -> Index Scan using _hyper_7_19_chunk_chunks_time_idx on _hyper_7_19_chunk (actual rows=1.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2000 PDT'::timestamp with time zone) -- Materialize CAgg and check for plan time chunk exclusion CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE cagg_scan_1h; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_19_chunk."time"), _hyper_7_19_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_19_chunk_chunks_time_idx on _hyper_7_19_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_19_chunk."time"), _hyper_7_19_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_19_chunk_chunks_time_idx on _hyper_7_19_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -- Check plan when chunk_append and constraint_aware_append cannot be used -- There should be no plans for scans of chunks that are materialized in the CAgg -- on the underlying hypertable SET timescaledb.enable_chunk_append = OFF; SET timescaledb.enable_constraint_aware_append = OFF; :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_19_chunk."time"), _hyper_7_19_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_19_chunk_chunks_time_idx on _hyper_7_19_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Wed Jul 31 18:00:00 2002 PDT'::timestamp with time zone) RESET timescaledb.enable_chunk_append; RESET timescaledb.enable_constraint_aware_append; -- Insert new values and check watermark changes INSERT INTO chunks VALUES ('2003-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Thu Jul 31 18:00:00 2003 PDT :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=4.00 loops=1) -> Append (actual rows=4.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2003 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2003 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2003 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2003 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_22_chunk."time"), _hyper_7_22_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_22_chunk_chunks_time_idx on _hyper_7_22_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Thu Jul 31 18:00:00 2003 PDT'::timestamp with time zone) -- Compare prepared statement with ad-hoc query EXECUTE cagg_scan_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 Tue Jul 31 17:00:00 2001 PDT | 1 | 2 Wed Jul 31 17:00:00 2002 PDT | 1 | 2 Thu Jul 31 17:00:00 2003 PDT | 1 | 2 SELECT * FROM chunks_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 Tue Jul 31 17:00:00 2001 PDT | 1 | 2 Wed Jul 31 17:00:00 2002 PDT | 1 | 2 Thu Jul 31 17:00:00 2003 PDT | 1 | 2 INSERT INTO chunks VALUES ('2004-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Sat Jul 31 18:00:00 2004 PDT :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=5.00 loops=1) -> Append (actual rows=5.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Jul 31 18:00:00 2004 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Jul 31 18:00:00 2004 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Jul 31 18:00:00 2004 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Jul 31 18:00:00 2004 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Jul 31 18:00:00 2004 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_24_chunk."time"), _hyper_7_24_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_24_chunk_chunks_time_idx on _hyper_7_24_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Sat Jul 31 18:00:00 2004 PDT'::timestamp with time zone) -- Two invalidations without prepared statement execution between INSERT INTO chunks VALUES ('2005-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); INSERT INTO chunks VALUES ('2006-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Mon Jul 31 18:00:00 2006 PDT :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=7.00 loops=1) -> Append (actual rows=7.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_28_chunk."time"), _hyper_7_28_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_28_chunk_chunks_time_idx on _hyper_7_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -- Multiple prepared statement executions followed by one invalidation :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=7.00 loops=1) -> Append (actual rows=7.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_28_chunk."time"), _hyper_7_28_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_28_chunk_chunks_time_idx on _hyper_7_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=7.00 loops=1) -> Append (actual rows=7.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_28_chunk."time"), _hyper_7_28_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_28_chunk_chunks_time_idx on _hyper_7_28_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Mon Jul 31 18:00:00 2006 PDT'::timestamp with time zone) INSERT INTO chunks VALUES ('2007-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=8.00 loops=1) -> Append (actual rows=8.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_30_chunk."time"), _hyper_7_30_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_30_chunk_chunks_time_idx on _hyper_7_30_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -- Compare prepared statement with ad-hoc query EXECUTE cagg_scan_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 Tue Jul 31 17:00:00 2001 PDT | 1 | 2 Wed Jul 31 17:00:00 2002 PDT | 1 | 2 Thu Jul 31 17:00:00 2003 PDT | 1 | 2 Sat Jul 31 17:00:00 2004 PDT | 1 | 2 Sun Jul 31 17:00:00 2005 PDT | 1 | 2 Mon Jul 31 17:00:00 2006 PDT | 1 | 2 Tue Jul 31 17:00:00 2007 PDT | 1 | 2 SELECT * FROM chunks_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 Tue Jul 31 17:00:00 2001 PDT | 1 | 2 Wed Jul 31 17:00:00 2002 PDT | 1 | 2 Thu Jul 31 17:00:00 2003 PDT | 1 | 2 Sat Jul 31 17:00:00 2004 PDT | 1 | 2 Sun Jul 31 17:00:00 2005 PDT | 1 | 2 Mon Jul 31 17:00:00 2006 PDT | 1 | 2 Tue Jul 31 17:00:00 2007 PDT | 1 | 2 -- Delete data from hypertable - data is only present in cagg after this point. If the watermark in the prepared -- statement is not moved to the most-recent watermark, we would see an empty result. TRUNCATE chunks; EXECUTE cagg_scan_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 Tue Jul 31 17:00:00 2001 PDT | 1 | 2 Wed Jul 31 17:00:00 2002 PDT | 1 | 2 Thu Jul 31 17:00:00 2003 PDT | 1 | 2 Sat Jul 31 17:00:00 2004 PDT | 1 | 2 Sun Jul 31 17:00:00 2005 PDT | 1 | 2 Mon Jul 31 17:00:00 2006 PDT | 1 | 2 Tue Jul 31 17:00:00 2007 PDT | 1 | 2 SELECT * FROM chunks_1h; bucket | device | max ------------------------------+--------+----- Mon Jul 31 17:00:00 2000 PDT | 1 | 2 Tue Jul 31 17:00:00 2001 PDT | 1 | 2 Wed Jul 31 17:00:00 2002 PDT | 1 | 2 Thu Jul 31 17:00:00 2003 PDT | 1 | 2 Sat Jul 31 17:00:00 2004 PDT | 1 | 2 Sun Jul 31 17:00:00 2005 PDT | 1 | 2 Mon Jul 31 17:00:00 2006 PDT | 1 | 2 Tue Jul 31 17:00:00 2007 PDT | 1 | 2 -- Refresh the CAgg CALL refresh_continuous_aggregate('chunks_1h', NULL, NULL); EXECUTE cagg_scan_1h; bucket | device | max --------+--------+----- SELECT * FROM chunks_1h; bucket | device | max --------+--------+----- -- Check new watermark SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Tue Jul 31 18:00:00 2007 PDT :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Append (actual rows=0.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Tue Jul 31 18:00:00 2007 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, "time"), device -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Update after truncate INSERT INTO chunks VALUES ('2008-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Thu Jul 31 18:00:00 2008 PDT :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_32_chunk."time"), _hyper_7_32_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_32_chunk_chunks_time_idx on _hyper_7_32_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Thu Jul 31 18:00:00 2008 PDT'::timestamp with time zone) -- Test with CAgg on CAgg CREATE MATERIALIZED VIEW chunks_1d WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 days', bucket) AS bucket, device, max(max) AS max FROM chunks_1h GROUP BY 1, 2; NOTICE: refreshing continuous aggregate "chunks_1d" SELECT id AS "MAT_HT_ID_1D" FROM _timescaledb_catalog.hypertable WHERE table_name=( SELECT materialization_hypertable_name FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1d' ) \gset SELECT materialization_hypertable_schema || '.' || materialization_hypertable_name AS "MAT_HT_NAME_1D" FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1d' \gset -- Prepared scan on hypertable (identical to the query of a real-time CAgg) PREPARE ht_scan_realtime_1d AS SELECT bucket, device, max FROM :MAT_HT_NAME_1D WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1D)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1D)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; PREPARE cagg_scan_1d AS SELECT * FROM chunks_1d; :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1d; --- QUERY PLAN --- Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_9_34_chunk__materialized_hypertable_9_bucket_idx on _hyper_9_34_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Fri Aug 01 17:00:00 2008 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, (time_bucket('@ 1 hour'::interval, "time"))), device -> Result (actual rows=0.00 loops=1) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, "time"), device -> Result (actual rows=0.00 loops=1) One-Time Filter: false INSERT INTO chunks VALUES ('2009-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); CALL refresh_continuous_aggregate('chunks_1d', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1d; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_9_34_chunk__materialized_hypertable_9_bucket_idx on _hyper_9_34_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Aug 01 17:00:00 2009 PDT'::timestamp with time zone) -> Index Scan using _hyper_9_37_chunk__materialized_hypertable_9_bucket_idx on _hyper_9_37_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sat Aug 01 17:00:00 2009 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, (time_bucket('@ 1 hour'::interval, "time"))), device -> Result (actual rows=0.00 loops=1) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, "time"), device -> Result (actual rows=0.00 loops=1) One-Time Filter: false INSERT INTO chunks VALUES ('2010-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); CALL refresh_continuous_aggregate('chunks_1d', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1d; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_9_34_chunk__materialized_hypertable_9_bucket_idx on _hyper_9_34_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sun Aug 01 17:00:00 2010 PDT'::timestamp with time zone) -> Index Scan using _hyper_9_37_chunk__materialized_hypertable_9_bucket_idx on _hyper_9_37_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sun Aug 01 17:00:00 2010 PDT'::timestamp with time zone) -> Index Scan using _hyper_9_40_chunk__materialized_hypertable_9_bucket_idx on _hyper_9_40_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Sun Aug 01 17:00:00 2010 PDT'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, (time_bucket('@ 1 hour'::interval, "time"))), device -> Result (actual rows=0.00 loops=1) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, "time"), device -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Stored procedure - watermark CREATE FUNCTION cur_watermark_plsql(mat_table int) RETURNS timestamptz AS $$ DECLARE cur_watermark_value timestamptz; BEGIN SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(mat_table)) INTO cur_watermark_value; RETURN cur_watermark_value; END$$ LANGUAGE plpgsql; SELECT * FROM cur_watermark_plsql(:MAT_HT_ID_1H); cur_watermark_plsql ------------------------------ Sat Jul 31 18:00:00 2010 PDT INSERT INTO chunks VALUES ('2011-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM cur_watermark_plsql(:MAT_HT_ID_1H); cur_watermark_plsql ------------------------------ Sun Jul 31 18:00:00 2011 PDT INSERT INTO chunks VALUES ('2012-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM cur_watermark_plsql(:MAT_HT_ID_1H); cur_watermark_plsql ------------------------------ Tue Jul 31 18:00:00 2012 PDT -- Stored procedure - result CREATE FUNCTION cur_cagg_result_count() RETURNS int AS $$ DECLARE count_value int; BEGIN SELECT count(*) FROM chunks_1h INTO count_value; RETURN count_value; END$$ LANGUAGE plpgsql; -- Cache function value SELECT * FROM cur_cagg_result_count(); cur_cagg_result_count ----------------------- 5 -- Add to non-materialized part INSERT INTO chunks VALUES ('2013-08-01 01:01:01+01', 1, 2); SELECT * FROM cur_cagg_result_count(); cur_cagg_result_count ----------------------- 6 -- Materialize CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM cur_cagg_result_count(); cur_cagg_result_count ----------------------- 6 -- Ensure all elements are materialized (i.e., watermark is moved properly) TRUNCATE chunks; SELECT * FROM cur_cagg_result_count(); cur_cagg_result_count ----------------------- 6 SELECT count(*) FROM chunks_1h; count ------- 6 -- Test watermark call directly PREPARE watermark_query AS SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Wed Jul 31 18:00:00 2013 PDT EXECUTE watermark_query; to_timestamp ------------------------------ Wed Jul 31 18:00:00 2013 PDT INSERT INTO chunks VALUES ('2013-09-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); to_timestamp ------------------------------ Sat Aug 31 18:00:00 2013 PDT EXECUTE watermark_query; to_timestamp ------------------------------ Sat Aug 31 18:00:00 2013 PDT -- Disable constification of watermark values SET timescaledb.enable_cagg_watermark_constify = OFF; INSERT INTO chunks VALUES ('2014-01-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 (actual rows=2.00 loops=1) Chunks excluded during startup: 0 -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Finalize HashAggregate (actual rows=0.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Custom Scan (ChunkAppend) on chunks (actual rows=0.00 loops=1) Chunks excluded during startup: 1 -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_49_chunk."time"), _hyper_7_49_chunk.device -> Index Scan using _hyper_7_49_chunk_chunks_time_idx on _hyper_7_49_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) RESET timescaledb.enable_cagg_watermark_constify; -- Select with projection INSERT INTO chunks VALUES ('2015-01-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE SELECT device FROM chunks_1h; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Subquery Scan on "*SELECT* 1" (actual rows=3.00 loops=1) -> Result (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Subquery Scan on "*SELECT* 2" (actual rows=0.00 loops=1) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"), _hyper_7_51_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -- Watermark function use other tables in WHERE condition (should not be constified) CREATE TABLE continuous_agg_test(time int, data int); :EXPLAIN_ANALYZE (SELECT * FROM continuous_agg_test AS t1) UNION ALL (SELECT * from continuous_agg_test AS t2 WHERE COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) IS NOT NULL); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Seq Scan on continuous_agg_test t1 (actual rows=0.00 loops=1) -> Result (actual rows=0.00 loops=1) One-Time Filter: (COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone) IS NOT NULL) -> Seq Scan on continuous_agg_test t2 (actual rows=0.00 loops=1) -- Query without COALESCE - should not be optimized :EXPLAIN_ANALYZE (SELECT * FROM chunks_1h AS t1) UNION ALL (SELECT * from chunks_1h AS t2 WHERE _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)) IS NOT NULL); --- QUERY PLAN --- Append (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 (actual rows=3.00 loops=1) Chunks excluded during startup: 0 -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Finalize HashAggregate (actual rows=0.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Custom Scan (ChunkAppend) on chunks (actual rows=0.00 loops=1) Chunks excluded during startup: 2 -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"), _hyper_7_51_chunk.device -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Append (actual rows=3.00 loops=1) -> Result (actual rows=3.00 loops=1) One-Time Filter: (_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)) IS NOT NULL) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 _materialized_hypertable_8_1 (actual rows=3.00 loops=1) Chunks excluded during startup: 0 -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk _hyper_8_17_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk _hyper_8_20_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk _hyper_8_21_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk _hyper_8_23_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk _hyper_8_25_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk _hyper_8_27_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk _hyper_8_29_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk _hyper_8_31_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk _hyper_8_33_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk _hyper_8_36_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk _hyper_8_39_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk _hyper_8_42_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk _hyper_8_44_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk _hyper_8_46_chunk_1 (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk _hyper_8_48_chunk_1 (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk _hyper_8_50_chunk_1 (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk _hyper_8_52_chunk_1 (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Result (actual rows=0.00 loops=1) One-Time Filter: (_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)) IS NOT NULL) -> Finalize HashAggregate (actual rows=0.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks_1."time")), chunks_1.device -> Custom Scan (ChunkAppend) on chunks chunks_1 (actual rows=0.00 loops=1) Chunks excluded during startup: 2 -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk_1."time"), _hyper_7_51_chunk_1.device -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk _hyper_7_51_chunk_1 (actual rows=0.00 loops=1) Index Cond: ("time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -- Aggregation query over CAgg should be constified :EXPLAIN_ANALYZE SELECT max(device) from chunks_1h; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Subquery Scan on "*SELECT* 1" (actual rows=3.00 loops=1) -> Result (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Subquery Scan on "*SELECT* 2" (actual rows=0.00 loops=1) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"), _hyper_7_51_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -- Test with integer partitioning CREATE TABLE integer_ht(time int, data int); SELECT create_hypertable('integer_ht', 'time', chunk_time_interval => 10); create_hypertable -------------------------- (10,public,integer_ht,t) CREATE FUNCTION integer_now_integer_ht() RETURNS INTEGER LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM integer_ht $$; SELECT set_integer_now_func('integer_ht', 'integer_now_integer_ht'); set_integer_now_func ---------------------- INSERT INTO integer_ht SELECT i, i FROM generate_series(0, 25) AS i; CREATE MATERIALIZED VIEW integer_ht_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM integer_ht GROUP BY 1; NOTICE: refreshing continuous aggregate "integer_ht_cagg" SELECT * FROM integer_ht_cagg; time_bucket | count -------------+------- 25 | 1 20 | 5 15 | 5 10 | 5 5 | 5 0 | 5 :EXPLAIN_ANALYZE SELECT * FROM integer_ht_cagg; --- QUERY PLAN --- Append (actual rows=6.00 loops=1) -> Index Scan using _hyper_11_56_chunk__materialized_hypertable_11_time_bucket_idx on _hyper_11_56_chunk (actual rows=6.00 loops=1) Index Cond: (time_bucket < 30) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket(5, "time") -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Test with big integer partitioning CREATE TABLE big_integer_ht(time bigint, data bigint); SELECT create_hypertable('big_integer_ht', 'time', chunk_time_interval => 10); create_hypertable ------------------------------ (12,public,big_integer_ht,t) CREATE FUNCTION integer_now_big_integer_ht() RETURNS BIGINT LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM big_integer_ht $$; SELECT set_integer_now_func('big_integer_ht', 'integer_now_big_integer_ht'); set_integer_now_func ---------------------- INSERT INTO big_integer_ht SELECT i, i FROM generate_series(0, 25) AS i; CREATE MATERIALIZED VIEW big_integer_ht_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM big_integer_ht GROUP BY 1; NOTICE: refreshing continuous aggregate "big_integer_ht_cagg" SELECT * FROM big_integer_ht_cagg; time_bucket | count -------------+------- 25 | 1 20 | 5 15 | 5 10 | 5 5 | 5 0 | 5 :EXPLAIN_ANALYZE SELECT * FROM big_integer_ht_cagg; --- QUERY PLAN --- Append (actual rows=6.00 loops=1) -> Index Scan using _hyper_13_60_chunk__materialized_hypertable_13_time_bucket_idx on _hyper_13_60_chunk (actual rows=6.00 loops=1) Index Cond: (time_bucket < '30'::bigint) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('5'::bigint, "time") -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Test with small integer partitioning CREATE TABLE small_integer_ht(time bigint, data bigint); SELECT create_hypertable('small_integer_ht', 'time', chunk_time_interval => 10); create_hypertable -------------------------------- (14,public,small_integer_ht,t) CREATE FUNCTION integer_now_small_integer_ht() RETURNS BIGINT LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM small_integer_ht $$; SELECT set_integer_now_func('small_integer_ht', 'integer_now_small_integer_ht'); set_integer_now_func ---------------------- INSERT INTO small_integer_ht SELECT i, i FROM generate_series(0, 25) AS i; CREATE MATERIALIZED VIEW small_integer_ht_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM small_integer_ht GROUP BY 1; NOTICE: refreshing continuous aggregate "small_integer_ht_cagg" SELECT * FROM small_integer_ht_cagg; time_bucket | count -------------+------- 25 | 1 20 | 5 15 | 5 10 | 5 5 | 5 0 | 5 :EXPLAIN_ANALYZE SELECT * FROM small_integer_ht_cagg; --- QUERY PLAN --- Append (actual rows=6.00 loops=1) -> Index Scan using _hyper_15_64_chunk__materialized_hypertable_15_time_bucket_idx on _hyper_15_64_chunk (actual rows=6.00 loops=1) Index Cond: (time_bucket < '30'::bigint) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('5'::bigint, "time") -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- Test handling of multiple watermark functions on integer based hypertables -- This is not a usual CAgg query. So, no constification should be done. However, -- the constification code should detect this and do nothing. SELECT id AS "MAT_HT_ID_SMALL_INTEGER" FROM _timescaledb_catalog.hypertable WHERE table_name=( SELECT materialization_hypertable_name FROM timescaledb_information.continuous_aggregates WHERE view_name='small_integer_ht_cagg' ) \gset :EXPLAIN_ANALYZE SELECT time_bucket(5, time) AS time_bucket, count(time) AS count FROM small_integer_ht WHERE small_integer_ht."time" >= COALESCE(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer, _timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer) GROUP BY (time_bucket(5, small_integer_ht."time")) UNION ALL SELECT time_bucket(5, time) AS time_bucket, count(time) AS count FROM small_integer_ht WHERE small_integer_ht."time" < COALESCE(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer, _timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer) GROUP BY (time_bucket(5, small_integer_ht."time")); --- QUERY PLAN --- Append (actual rows=6.00 loops=1) -> Finalize GroupAggregate (actual rows=0.00 loops=1) Group Key: (time_bucket('5'::bigint, small_integer_ht."time")) -> Sort (actual rows=0.00 loops=1) Sort Key: (time_bucket('5'::bigint, small_integer_ht."time")) Sort Method: quicksort -> Custom Scan (ChunkAppend) on small_integer_ht (actual rows=0.00 loops=1) Chunks excluded during startup: 3 -> Finalize GroupAggregate (actual rows=6.00 loops=1) Group Key: (time_bucket('5'::bigint, small_integer_ht_1."time")) -> Sort (actual rows=6.00 loops=1) Sort Key: (time_bucket('5'::bigint, small_integer_ht_1."time")) Sort Method: quicksort -> Custom Scan (ChunkAppend) on small_integer_ht small_integer_ht_1 (actual rows=6.00 loops=1) Chunks excluded during startup: 0 -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('5'::bigint, _hyper_14_61_chunk."time") -> Index Only Scan Backward using _hyper_14_61_chunk_small_integer_ht_time_idx on _hyper_14_61_chunk (actual rows=10.00 loops=1) Index Cond: ("time" < COALESCE((_timescaledb_functions.cagg_watermark(15))::integer, (_timescaledb_functions.cagg_watermark(15))::integer)) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('5'::bigint, _hyper_14_62_chunk."time") -> Index Only Scan Backward using _hyper_14_62_chunk_small_integer_ht_time_idx on _hyper_14_62_chunk (actual rows=10.00 loops=1) Index Cond: ("time" < COALESCE((_timescaledb_functions.cagg_watermark(15))::integer, (_timescaledb_functions.cagg_watermark(15))::integer)) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('5'::bigint, _hyper_14_63_chunk."time") -> Index Only Scan Backward using _hyper_14_63_chunk_small_integer_ht_time_idx on _hyper_14_63_chunk (actual rows=6.00 loops=1) Index Cond: ("time" < COALESCE((_timescaledb_functions.cagg_watermark(15))::integer, (_timescaledb_functions.cagg_watermark(15))::integer)) -- test with non constant value of the watermark function (should not be constified) :EXPLAIN_ANALYZE SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(COALESCE(:MAT_HT_ID_1H, :MAT_HT_ID_1H))), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 (actual rows=3.00 loops=1) Chunks excluded during startup: 0 -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, _materialized_hypertable_8_1.bucket), _materialized_hypertable_8_1.device -> Result (actual rows=0.00 loops=1) -> Append (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 _materialized_hypertable_8_1 (actual rows=0.00 loops=1) Chunks excluded during startup: 16 -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk _hyper_8_52_chunk_1 (actual rows=0.00 loops=1) Index Cond: ((bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) AND (bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone))) -> Finalize HashAggregate (actual rows=0.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Custom Scan (ChunkAppend) on chunks (actual rows=0.00 loops=1) Chunks excluded during startup: 2 -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"), _hyper_7_51_chunk.device -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) Filter: (time_bucket('@ 1 hour'::interval, "time") >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -- test with NULL constant value of the watermark function (should not be constified) :EXPLAIN_ANALYZE SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(COALESCE(:MAT_HT_ID_1H, :MAT_HT_ID_1H))), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 (actual rows=3.00 loops=1) Chunks excluded during startup: 0 -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, _materialized_hypertable_8_1.bucket), _materialized_hypertable_8_1.device -> Result (actual rows=0.00 loops=1) -> Append (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on _materialized_hypertable_8 _materialized_hypertable_8_1 (actual rows=0.00 loops=1) Chunks excluded during startup: 16 -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk _hyper_8_52_chunk_1 (actual rows=0.00 loops=1) Index Cond: ((bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) AND (bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone))) -> Finalize HashAggregate (actual rows=0.00 loops=1) Group Key: (time_bucket('@ 1 hour'::interval, chunks."time")), chunks.device -> Custom Scan (ChunkAppend) on chunks (actual rows=0.00 loops=1) Chunks excluded during startup: 2 -> Partial HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"), _hyper_7_51_chunk.device -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk (actual rows=0.00 loops=1) Index Cond: ("time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) Filter: (time_bucket('@ 1 hour'::interval, "time") >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp with time zone)) -- test with double COALESCE function (should be constified) :EXPLAIN_ANALYZE SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_8_17_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_17_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_20_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_20_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_21_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_21_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_23_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_23_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_25_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_25_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_27_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_27_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_29_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_29_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_31_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_31_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_33_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_33_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_36_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_39_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_39_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_42_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_42_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_44_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_44_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_46_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_46_chunk (actual rows=0.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_48_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_48_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_50_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_50_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> Index Scan using _hyper_8_52_chunk__materialized_hypertable_8_bucket_idx on _hyper_8_52_chunk (actual rows=1.00 loops=1) Index Cond: (bucket < 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, (time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"))), _hyper_7_51_chunk.device -> Result (actual rows=0.00 loops=1) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('@ 1 hour'::interval, _hyper_7_51_chunk."time"), _hyper_7_51_chunk.device -> Result (actual rows=0.00 loops=1) -> Index Scan using _hyper_7_51_chunk_chunks_time_idx on _hyper_7_51_chunk (actual rows=0.00 loops=1) Index Cond: (("time" >= 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) AND ("time" >= 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone)) Filter: (time_bucket('@ 1 hour'::interval, "time") >= 'Wed Dec 31 17:00:00 2014 PST'::timestamp with time zone) \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; TRUNCATE _timescaledb_catalog.continuous_aggs_invalidation_threshold; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Issue #6722: constify cagg_watermark using window func when querying a cagg :EXPLAIN_ANALYZE SELECT time_bucket, lead(count) OVER (ORDER BY time_bucket) FROM small_integer_ht_cagg; --- QUERY PLAN --- WindowAgg (actual rows=6.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_15_64_chunk.time_bucket Sort Method: quicksort -> Append (actual rows=6.00 loops=1) -> Index Scan using _hyper_15_64_chunk__materialized_hypertable_15_time_bucket_idx on _hyper_15_64_chunk (actual rows=6.00 loops=1) Index Cond: (time_bucket < '30'::bigint) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('5'::bigint, "time") -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- SDC #1905: Using cagg on CTE should be constified :EXPLAIN_ANALYZE WITH cagg AS ( SELECT * FROM small_integer_ht_cagg ) SELECT * FROM cagg WHERE time_bucket > 10; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_15_64_chunk__materialized_hypertable_15_time_bucket_idx on _hyper_15_64_chunk (actual rows=3.00 loops=1) Index Cond: ((time_bucket < '30'::bigint) AND (time_bucket > 10)) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('5'::bigint, "time") -> Result (actual rows=0.00 loops=1) One-Time Filter: false :EXPLAIN_ANALYZE WITH cagg AS ( SELECT * FROM small_integer_ht_cagg ), other AS ( SELECT * FROM generate_series(1,10) ) SELECT * FROM cagg, other WHERE time_bucket > 10; --- QUERY PLAN --- Nested Loop (actual rows=30.00 loops=1) -> Function Scan on generate_series (actual rows=10.00 loops=1) -> Materialize (actual rows=3.00 loops=10) -> Append (actual rows=3.00 loops=1) -> Index Scan using _hyper_15_64_chunk__materialized_hypertable_15_time_bucket_idx on _hyper_15_64_chunk (actual rows=3.00 loops=1) Index Cond: ((time_bucket < '30'::bigint) AND (time_bucket > 10)) -> HashAggregate (actual rows=0.00 loops=1) Group Key: time_bucket('5'::bigint, "time") -> Result (actual rows=0.00 loops=1) One-Time Filter: false �����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/chunk_api.out��������������������������������������������������0000664�0000000�0000000�00000056671�15100345067�0022146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :"TEST_DBNAME" TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA "ChunkSchema"; -- Use range types as well for columns CREATE TABLE chunkapi(time timestamptz not null, device int, temp float, rng int8range); SELECT * FROM create_hypertable('chunkapi', 'time', 'device', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | chunkapi | t INSERT INTO chunkapi VALUES ('2018-01-01 05:00:00-8', 1, 23.4, int8range(4, 10)); SELECT (_timescaledb_functions.show_chunk(show_chunks)).* FROM show_chunks('chunkapi') ORDER BY chunk_id; chunk_id | hypertable_id | schema_name | table_name | relkind | slices ----------+---------------+-----------------------+------------------+---------+---------------------------------------------------------------------------------------------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | r | {"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]} -- Creating a chunk with the constraints of an existing chunk should -- return the existing chunk SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+------------------+---------+----------------------------------------------------------------------------------------------+--------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | r | {"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]} | f \set VERBOSITY default \set ON_ERROR_STOP 0 -- Modified time constraint should fail with collision SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); ERROR: chunk creation failed due to collision -- Missing dimension SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000]}'); ERROR: invalid hypercube for hypertable "chunkapi" DETAIL: invalid number of hypercube dimensions -- Extra dimension SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "device": [-9223372036854775808, 1073741823], "time2": [1514419600000000, 1515024000000000]}'); ERROR: invalid hypercube for hypertable "chunkapi" DETAIL: invalid number of hypercube dimensions -- Bad dimension name SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "dev": [-9223372036854775808, 1073741823]}'); ERROR: invalid hypercube for hypertable "chunkapi" DETAIL: dimension "dev" does not exist in hypertable -- Same dimension twice SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "time": [1514419600000000, 1515024000000000]}'); ERROR: invalid hypercube for hypertable "chunkapi" DETAIL: invalid number of hypercube dimensions -- Bad bounds value SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": ["-1514419200000000", 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); ERROR: time zone displacement out of range: "-1514419200000000" -- Bad bounds value SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": ["badtimestamp", 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); ERROR: invalid input syntax for type timestamp with time zone: "badtimestamp" -- Bad slices format SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1515024000000000], "device": [-9223372036854775808, 1073741823]}'); ERROR: invalid hypercube for hypertable "chunkapi" DETAIL: unexpected number of dimensional bounds for dimension "time" -- Bad slices json SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time: [1515024000000000] "device": [-9223372036854775808, 1073741823]}'); ERROR: invalid input syntax for type json LINE 1: ...OM _timescaledb_functions.create_chunk('chunkapi',' {"time: ... ^ DETAIL: Token "device" is invalid. CONTEXT: JSON data, line 1: {"time: [1515024000000000] "device... -- Bad bound type SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [true, 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); ERROR: invalid hypercube for hypertable "chunkapi" DETAIL: constraint for dimension "time" should be either numeric or string \set ON_ERROR_STOP 1 -- Test that granting insert on tables allow create_chunk to be -- called. This will also create a chunk that does not collide and has -- a custom schema and name. SET ROLE :ROLE_SUPERUSER; GRANT INSERT ON chunkapi TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1515024000000000, 1519024000000000], "device": [-9223372036854775808, 1073741823]}', 'ChunkSchema', 'My_chunk_Table_name'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-------------+---------------------+---------+----------------------------------------------------------------------------------------------+--------- 2 | 1 | ChunkSchema | My_chunk_Table_name | r | {"time": [1515024000000000, 1519024000000000], "device": [-9223372036854775808, 1073741823]} | t SET ROLE :ROLE_SUPERUSER; DROP TABLE chunkapi; -- Test creating a chunk from an existing chunk table which was not -- created via create_chunk_table and having a different name. CREATE TABLE devices (id int PRIMARY KEY); INSERT INTO devices VALUES (1); CREATE TABLE chunkapi (time timestamptz NOT NULL PRIMARY KEY, device int REFERENCES devices(id), temp float CHECK(temp > 0)); SELECT * FROM create_hypertable('chunkapi', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | chunkapi | t INSERT INTO chunkapi VALUES ('2018-01-01 05:00:00-8', 1, 23.4); SELECT chunk_schema AS "CHUNK_SCHEMA", chunk_name AS "CHUNK_NAME" FROM timescaledb_information.chunks c ORDER BY chunk_name DESC LIMIT 1 \gset SELECT slices AS "SLICES" FROM _timescaledb_functions.show_chunk(:'CHUNK_SCHEMA'||'.'||:'CHUNK_NAME') \gset TRUNCATE chunkapi; CREATE TABLE newchunk (time timestamptz NOT NULL, device int, temp float); SELECT * FROM test.show_constraints('newchunk'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated ------------+------+---------+-------+------+------------+----------+----------- INSERT INTO newchunk VALUES ('2018-01-01 05:00:00-8', 1, 23.4); \set ON_ERROR_STOP 0 -- Creating the chunk without required CHECK constraints on a table -- should fail. Currently, PostgreSQL only enforces presence of CHECK -- constraints, but not foreign key, unique, or primary key -- constraints. We should probably add checks to enforce the latter -- too or auto-create all constraints. SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', :'SLICES', :'CHUNK_SCHEMA', :'CHUNK_NAME', 'newchunk'); ERROR: child table is missing constraint "chunkapi_temp_check" \set ON_ERROR_STOP 1 -- Add the missing CHECK constraint. Note that the name must be the -- same as on the parent table. ALTER TABLE newchunk ADD CONSTRAINT chunkapi_temp_check CHECK (temp > 0); CREATE TABLE newchunk2 as select * from newchunk; ALTER TABLE newchunk2 ADD CONSTRAINT chunkapi_temp_check CHECK (temp > 0); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', :'SLICES', :'CHUNK_SCHEMA', :'CHUNK_NAME', 'newchunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+------------------+---------+------------------------------------------------+--------- 5 | 2 | _timescaledb_internal | _hyper_2_3_chunk | r | {"time": [1514419200000000, 1515024000000000]} | t -- adding an existing table to an exiting range must fail \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', :'SLICES', :'CHUNK_SCHEMA', :'CHUNK_NAME', 'newchunk2'); ERROR: chunk creation failed due to collision \set ON_ERROR_STOP 1 -- Show the chunk and that names are what we'd expect SELECT :'CHUNK_SCHEMA' AS expected_schema, :'CHUNK_NAME' AS expected_table_name, (_timescaledb_functions.show_chunk(ch)).* FROM show_chunks('chunkapi') ch; expected_schema | expected_table_name | chunk_id | hypertable_id | schema_name | table_name | relkind | slices -----------------------+---------------------+----------+---------------+-----------------------+------------------+---------+------------------------------------------------ _timescaledb_internal | _hyper_2_3_chunk | 5 | 2 | _timescaledb_internal | _hyper_2_3_chunk | r | {"time": [1514419200000000, 1515024000000000]} -- The chunk should inherit the hypertable SELECT relname FROM pg_catalog.pg_inherits, pg_class WHERE inhrelid = (:'CHUNK_SCHEMA'||'.'||:'CHUNK_NAME')::regclass AND inhparent = oid; relname ---------- chunkapi -- Test that it is possible to query the data via the hypertable SELECT * FROM chunkapi ORDER BY 1,2,3; time | device | temp ------------------------------+--------+------ Mon Jan 01 05:00:00 2018 PST | 1 | 23.4 -- Show that the chunk has all the necessary constraints. These -- include inheritable constraints and dimensional constraints, which -- are specific to the chunk. Currently, foreign key, unique, and -- primary key constraints are not inherited or auto-created. SELECT * FROM test.show_constraints(format('%I.%I', :'CHUNK_SCHEMA', :'CHUNK_NAME')::regclass); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated --------------------------+------+----------+-------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------+------------+----------+----------- 5_5_chunkapi_device_fkey | f | {device} | devices_pkey | | f | f | t 5_6_chunkapi_pkey | p | {time} | _timescaledb_internal."5_6_chunkapi_pkey" | | f | f | t chunkapi_temp_check | c | {temp} | - | (temp > (0)::double precision) | f | f | t constraint_6 | c | {time} | - | (("time" >= 'Wed Dec 27 16:00:00 2017 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2018 PST'::timestamp with time zone)) | f | f | t TRUNCATE chunkapi; -- Create a table with extra columns CREATE TABLE extra_col_chunk (time timestamptz NOT NULL, device int, temp float, extra int, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); -- Adding a new chunk with extra column should fail \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1514419200000000, 1515024000000000]}', NULL, NULL, 'extra_col_chunk'); ERROR: table "extra_col_chunk" contains column "extra" not found in parent "chunkapi" DETAIL: The new chunk can contain only the columns present in parent. \set ON_ERROR_STOP 1 -- It should succeed after dropping the extra column ALTER TABLE extra_col_chunk DROP COLUMN extra; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1514419200000000, 1515024000000000]}', NULL, NULL, 'extra_col_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+------------------+---------+------------------------------------------------+--------- 6 | 2 | _timescaledb_internal | _hyper_2_6_chunk | r | {"time": [1514419200000000, 1515024000000000]} | t -- Test creating a chunk with columns in different order CREATE TABLE reordered_chunk (device int, temp float, time timestamptz NOT NULL, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515024000000000, 1515628800000000]}', NULL, NULL, 'reordered_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+------------------+---------+------------------------------------------------+--------- 7 | 2 | _timescaledb_internal | _hyper_2_7_chunk | r | {"time": [1515024000000000, 1515628800000000]} | t -- Test creating a chunk with initially missing a column CREATE TABLE missing_col_chunk (time timestamptz NOT NULL, device int); INSERT INTO missing_col_chunk (time, device) VALUES ('2018-01-11 05:00:00-8', 1); ALTER TABLE missing_col_chunk ADD COLUMN temp float CONSTRAINT chunkapi_temp_check CHECK (temp > 0); INSERT INTO missing_col_chunk (time, device, temp) VALUES ('2018-01-12 05:00:00-8', 1, 19.5); -- This should succeed since all required columns are now present SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515628800000000, 1516233600000000]}', NULL, NULL, 'missing_col_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+------------------+---------+------------------------------------------------+--------- 8 | 2 | _timescaledb_internal | _hyper_2_8_chunk | r | {"time": [1515628800000000, 1516233600000000]} | t -- Test creating a chunk with mismatched column types CREATE TABLE wrong_type_chunk (time timestamptz NOT NULL, device text, temp float CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); -- This should fail due to type mismatch \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1516233600000000, 1516838400000000]}', NULL, NULL, 'wrong_type_chunk'); ERROR: child table "_hyper_2_9_chunk" has different type for column "device" \set ON_ERROR_STOP 1 -- Test creating a chunk with binary coercible types ALTER TABLE chunkapi ADD COLUMN name varchar(10); CREATE TABLE coercible_type_chunk (time timestamptz NOT NULL, device int, temp float CONSTRAINT chunkapi_temp_check CHECK (temp > 0), name text); INSERT INTO coercible_type_chunk (time, device, temp, name) VALUES ('2018-01-20 06:00:00-8', 1, 25.1, 'device1'); \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1516233600000000, 1516838400000000]}', NULL, NULL, 'coercible_type_chunk'); ERROR: child table "_hyper_2_10_chunk" has different type for column "name" \set ON_ERROR_STOP 1 ALTER TABLE chunkapi DROP COLUMN name; -- Test data routing to the successfully created chunks. Each row should go to a different chunks INSERT INTO chunkapi VALUES ('2018-01-01 05:00:00-8', 1, 23.4), ('2018-01-08 05:00:00-8', 1, 24.5), ('2018-01-15 05:00:00-8', 1, 25.6); -- Verify data was routed correctly SELECT 'SELECT * FROM ' || chunk_schema || '.' || chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'chunkapi'; \gexec ?column? ------------------------------------------------------ SELECT * FROM _timescaledb_internal._hyper_2_6_chunk SELECT * FROM _timescaledb_internal._hyper_2_7_chunk SELECT * FROM _timescaledb_internal._hyper_2_8_chunk SELECT * FROM _timescaledb_internal._hyper_2_6_chunk time | device | temp ------------------------------+--------+------ Mon Jan 01 05:00:00 2018 PST | 1 | 23.4 SELECT * FROM _timescaledb_internal._hyper_2_7_chunk device | temp | time --------+------+------------------------------ 1 | 24.5 | Mon Jan 08 05:00:00 2018 PST SELECT * FROM _timescaledb_internal._hyper_2_8_chunk time | device | temp ------------------------------+--------+------ Thu Jan 11 05:00:00 2018 PST | 1 | Fri Jan 12 05:00:00 2018 PST | 1 | 19.5 Mon Jan 15 05:00:00 2018 PST | 1 | 25.6 TRUNCATE chunkapi; -- Test generated columns -- This should fail since generated column is not allowed in chunks if parent does not have the column as generated. CREATE TABLE generated_col_chunk (time timestamptz NOT NULL, device int, temp float GENERATED ALWAYS AS (device::float) STORED, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1516838400000000, 1517443200000000]}', NULL, NULL, 'generated_col_chunk'); ERROR: column "temp" in chunk table must not be a generated column DETAIL: Chunk column must be generated if and only if parent column is also generated \set ON_ERROR_STOP 1 -- When parent has a generated column while the chunk does not have the same column as generated, it should fail too. CREATE TABLE non_generated_chunk (time timestamptz NOT NULL, device int, temp float, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); \set ON_ERROR_STOP 0 ALTER TABLE chunkapi DROP COLUMN temp; ALTER TABLE chunkapi ADD COLUMN temp float GENERATED ALWAYS AS (device::float) STORED; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1517443200000000, 1518048000000000]}', NULL, NULL, 'non_generated_chunk'); ERROR: column "temp" in child table must be a generated column \set ON_ERROR_STOP 1 -- Generation expression cannot be different from the parent \set ON_ERROR_STOP 0 ALTER TABLE generated_col_chunk DROP COLUMN temp; ALTER TABLE generated_col_chunk ADD COLUMN temp float GENERATED ALWAYS AS ((device::float)+1) STORED; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1518048000000000, 1518652800000000]}', NULL, NULL, 'generated_col_chunk'); ERROR: chunk column "temp" must have the same expression as the hypertable column. \set ON_ERROR_STOP 1 -- This should succeed since the generated column is now the same as in the parent ALTER TABLE generated_col_chunk DROP COLUMN temp; ALTER TABLE generated_col_chunk ADD COLUMN temp float GENERATED ALWAYS AS ((device::float)) STORED; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1518652800000000, 1519257600000000]}', NULL, NULL, 'generated_col_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+-------------------+---------+------------------------------------------------+--------- 12 | 2 | _timescaledb_internal | _hyper_2_12_chunk | r | {"time": [1518652800000000, 1519257600000000]} | t INSERT INTO chunkapi VALUES ('2018-02-20 05:00:00-8', 1); SELECT 'SELECT * FROM ' || chunk_schema || '.' || chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'chunkapi'; \gexec ?column? ------------------------------------------------------- SELECT * FROM _timescaledb_internal._hyper_2_12_chunk SELECT * FROM _timescaledb_internal._hyper_2_12_chunk time | device | temp ------------------------------+--------+------ Tue Feb 20 05:00:00 2018 PST | 1 | 1 DROP TABLE chunkapi; -- Test the fix for Bug #8577 -- Mismatch in attnum between chunk and hypertable should not fail CREATE TABLE chunkapi(col_to_drop int, time timestamptz not null, device int); SELECT create_hypertable('chunkapi', 'time', 'device', 2); create_hypertable ----------------------- (3,public,chunkapi,t) ALTER TABLE chunkapi DROP COLUMN col_to_drop; CREATE TABLE new_chunk(time timestamptz not null, device int); INSERT INTO new_chunk VALUES ('2018-01-01 05:00:00-8', 1); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]}', NULL, NULL, 'new_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+-------------------+---------+----------------------------------------------------------------------------------------------+--------- 13 | 3 | _timescaledb_internal | _hyper_3_13_chunk | r | {"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]} | t CREATE TABLE reordered_chunk(device int, time timestamptz not null); INSERT INTO reordered_chunk VALUES (1, '2018-01-08 05:00:00-8'); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515024000000000, 1515628800000000], "device": [-9223372036854775808, 1073741823]}', NULL, NULL, 'reordered_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+-------------------+---------+----------------------------------------------------------------------------------------------+--------- 14 | 3 | _timescaledb_internal | _hyper_3_14_chunk | r | {"time": [1515024000000000, 1515628800000000], "device": [-9223372036854775808, 1073741823]} | t CREATE TABLE new_col_chunk(time timestamptz not null, temp float, device int); INSERT INTO new_col_chunk VALUES ('2018-01-15 05:00:00-8', 23.4, 1); ALTER TABLE chunkapi ADD COLUMN temp float; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515628800000000, 1516233600000000], "device": [-9223372036854775808, 1073741823]}', NULL, NULL, 'new_col_chunk'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+-------------------+---------+----------------------------------------------------------------------------------------------+--------- 15 | 3 | _timescaledb_internal | _hyper_3_15_chunk | r | {"time": [1515628800000000, 1516233600000000], "device": [-9223372036854775808, 1073741823]} | t �����������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/chunk_column_stats.out�����������������������������������������0000664�0000000�0000000�00000107030�15100345067�0024072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off, timing off, summary off)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name || '.' || c.table_name as chunk_name, c.status as chunk_status FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); CREATE INDEX sense_idx ON sample_table (sensor_id); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | sample_table | t \set start_date '2022-01-28 01:09:53.583252+05:30' -- insert into chunk1 INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 2, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 3, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 8, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 121.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 117.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 121.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 9, 121.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 14, 121.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 15, 10.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 16, 14.6554, 47, 'new row3'); -- Non-int, date, timestamp cannot be specified as a min/max ranges for now -- We could expand to FLOATs, NUMERICs later \set ON_ERROR_STOP 0 -- Error if you try enabling without enabling the GUC first SELECT * FROM enable_chunk_skipping('sample_table', 'name'); ERROR: chunk skipping functionality disabled, enable it by first setting timescaledb.enable_chunk_skipping to on -- Enable the chunk skipping GUC SET timescaledb.enable_chunk_skipping to ON; SELECT * FROM enable_chunk_skipping('sample_table', 'name'); ERROR: data type "character varying" unsupported for range calculation SELECT * FROM enable_chunk_skipping('sample_table', NULL); ERROR: column name cannot be NULL SELECT * FROM enable_chunk_skipping(NULL, 'name'); ERROR: hypertable cannot be NULL SELECT * FROM enable_chunk_skipping('sample_table1', 'name'); ERROR: relation "sample_table1" does not exist at character 37 CREATE TABLE plain_table(like sample_table); SELECT * FROM enable_chunk_skipping('plain_table', 'sensor_id'); ERROR: table "plain_table" is not a hypertable DROP TABLE plain_table; \set ON_ERROR_STOP 1 -- Specify tracking of min/max ranges for a column SELECT * FROM enable_chunk_skipping('sample_table', 'sensor_id'); column_stats_id | enabled -----------------+--------- 1 | t -- The above should add an entry with MIN/MAX int64 entries for invalid chunk id -- to indicate that ranges on this column should be calculated for chunks SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 1 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 2 | 1 | 1 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 3 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- Skipping should work SELECT * FROM enable_chunk_skipping('sample_table', 'sensor_id', true); NOTICE: already enabled for column "sensor_id", skipping column_stats_id | enabled -----------------+--------- 1 | t -- A query using a WHERE clause on "sensor_id" column will scan all the chunks :PREFIX SELECT * FROM sample_table WHERE sensor_id > 9; --- QUERY PLAN --- Append -> Index Scan using _hyper_1_1_chunk_sense_idx on _hyper_1_1_chunk Index Cond: (sensor_id > 9) -> Index Scan using _hyper_1_2_chunk_sense_idx on _hyper_1_2_chunk Index Cond: (sensor_id > 9) -- For the purposes of min/max range tracking, a compressed chunk is considered as a -- completed chunk. -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'sensor_id' ); -- -- compress one chunk SELECT show_chunks('sample_table') AS "CH_NAME" order by 1 limit 1 \gset SELECT compress_chunk(:'CH_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT id AS "CHUNK_ID" from _timescaledb_catalog.chunk WHERE table_name = '_hyper_1_1_chunk' \gset -- There should be an entry with min/max range computed for this chunk for this -- "sensor_id" column. SELECT * from _timescaledb_catalog.chunk_column_stats where chunk_id = :'CHUNK_ID'; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+-------------+-----------+------- 2 | 1 | 1 | sensor_id | 1 | 9 | t -- check chunk compression status SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' AND chunk_name = :'CH_NAME'; chunk_status -------------- 1 :PREFIX SELECT * FROM sample_table WHERE sensor_id > 9; --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_sense_idx on _hyper_1_2_chunk Index Cond: (sensor_id > 9) -- do update, this will change the status of the chunk UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- check chunk compression status SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' AND chunk_name = :'CH_NAME'; chunk_status -------------- 9 -- There should be an entry with "valid" set to false for this chunk SELECT * from _timescaledb_catalog.chunk_column_stats WHERE chunk_id = :'CHUNK_ID'; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+-------------+-----------+------- 2 | 1 | 1 | sensor_id | 1 | 9 | f -- A query using a WHERE clause on "sensor_id" column will go back to scanning all the chunks -- along with an expensive DECOMPRESS on the first chunk :PREFIX SELECT * FROM sample_table WHERE sensor_id > 9; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: (sensor_id > 9) -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id > 9) -> Index Scan using _hyper_1_1_chunk_sense_idx on _hyper_1_1_chunk Index Cond: (sensor_id > 9) -> Index Scan using _hyper_1_2_chunk_sense_idx on _hyper_1_2_chunk Index Cond: (sensor_id > 9) -- Remove the index to check the sequential min/max calculation code as well DROP INDEX sense_idx; -- recompress the partial chunk SELECT compress_chunk(:'CH_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- check chunk compression status SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' AND chunk_name = :'CH_NAME'; chunk_status -------------- 1 -- The chunk entry should become "valid" again SELECT min(sensor_id), max(sensor_id) FROM :CH_NAME; min | max -----+----- 1 | 8 SELECT * from _timescaledb_catalog.chunk_column_stats WHERE chunk_id = :'CHUNK_ID'; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+-------------+-----------+------- 2 | 1 | 1 | sensor_id | 1 | 9 | t -- A query using a WHERE clause on "sensor_id" column will scan the proper chunk -- due to chunk exclusion using min/max ranges calculated above -- First chunk has [start,end) values of [1,9), here we confirm that its being -- filtered out when we are not hitting that range. -- Query ranges outside of chunk stats, should not include first chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id < 1; --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: (sensor_id < 1) :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 0; --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: (sensor_id <= 0) :PREFIX SELECT * FROM sample_table WHERE sensor_id > 8; --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: (sensor_id > 8) :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 9; --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: (sensor_id >= 9) :PREFIX SELECT * FROM sample_table WHERE sensor_id = 10; --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: (sensor_id = 10) -- Query intersecting ranges, should include chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id = 7; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id = 7) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id = 7) :PREFIX SELECT * FROM sample_table WHERE sensor_id < 2; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id < 2) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id < 2) :PREFIX SELECT * FROM sample_table WHERE sensor_id > 3; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id > 3) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id > 3) :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 1; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id <= 1) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id <= 1) :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 8; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id >= 8) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id >= 8) :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 8 AND sensor_id <= 10; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id >= 8) AND (sensor_id <= 10)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id >= 8) AND (sensor_id <= 10)) :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 4 AND sensor_id > -5; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id <= 4) AND (sensor_id > '-5'::integer)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id <= 4) AND (sensor_id > '-5'::integer)) :PREFIX SELECT * FROM sample_table WHERE sensor_id > 6 AND sensor_id < 10; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id > 6) AND (sensor_id < 10)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id > 6) AND (sensor_id < 10)) :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 5 AND sensor_id > -1; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id <= 5) AND (sensor_id > '-1'::integer)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id <= 5) AND (sensor_id > '-1'::integer)) -- Query chunk superset ranges, should include chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id > -2; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id > '-2'::integer) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id > '-2'::integer) :PREFIX SELECT * FROM sample_table WHERE sensor_id < 11; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id < 11) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id < 11) :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 1 AND sensor_id <= 8; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id >= 1) AND (sensor_id <= 8)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id >= 1) AND (sensor_id <= 8)) :PREFIX SELECT * FROM sample_table WHERE sensor_id > 0 AND sensor_id < 9; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id > 0) AND (sensor_id < 9)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id > 0) AND (sensor_id < 9)) -- Query chunk subset ranges, should include chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id > 2 AND sensor_id < 7; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id > 2) AND (sensor_id < 7)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id > 2) AND (sensor_id < 7)) :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 3 AND sensor_id <= 6; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id >= 3) AND (sensor_id <= 6)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id >= 3) AND (sensor_id <= 6)) :PREFIX SELECT * FROM sample_table WHERE sensor_id > 4 AND sensor_id <= 5; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id > 4) AND (sensor_id <= 5)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id > 4) AND (sensor_id <= 5)) :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 6 AND sensor_id < 8; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: ((sensor_id >= 6) AND (sensor_id < 8)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id >= 6) AND (sensor_id < 8)) -- Disabling the GUC will prevent plan time chunk skipping RESET timescaledb.enable_chunk_skipping; :PREFIX SELECT * FROM sample_table WHERE sensor_id < 1; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id < 1) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id < 1) SET timescaledb.enable_chunk_skipping to ON; -- Query ranges with OR clause will not work properly due to the way -- hypertable expansion works as of now. Once we fix that, it should -- fix the issue here too. -- Should not include but it does. :PREFIX SELECT * FROM sample_table WHERE sensor_id < 1 OR sensor_id > 8; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Seq Scan on compress_hyper_2_3_chunk Filter: ((sensor_id < 1) OR (sensor_id > 8)) -> Seq Scan on _hyper_1_2_chunk Filter: ((sensor_id < 1) OR (sensor_id > 8)) -- Executor startup time exclusion will also use these ranges appropriately :PREFIX UPDATE sample_table set sensor_id = 10 WHERE sensor_id > length(substring(version(),1,9)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on sample_table Update on _hyper_1_1_chunk sample_table Update on _hyper_1_2_chunk sample_table_1 -> Result -> Custom Scan (ChunkAppend) on sample_table Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_2_chunk sample_table_1 Filter: (sensor_id > length("substring"(version(), 1, 9))) :PREFIX DELETE FROM sample_table WHERE sensor_id > length(substring(version(),1,10)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on sample_table Delete on _hyper_1_1_chunk sample_table Delete on _hyper_1_2_chunk sample_table_1 -> Custom Scan (ChunkAppend) on sample_table Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_2_chunk sample_table_1 Filter: (sensor_id > length("substring"(version(), 1, 10))) :PREFIX SELECT * FROM sample_table WHERE sensor_id > length(substring(version(),1,11)); --- QUERY PLAN --- Custom Scan (ChunkAppend) on sample_table Chunks excluded during startup: 1 -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id > length("substring"(version(), 1, 11))) -- Scan both chunks :PREFIX SELECT * FROM sample_table WHERE sensor_id > length(substring(version(),1,6)); --- QUERY PLAN --- Custom Scan (ChunkAppend) on sample_table Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id > length("substring"(version(), 1, 6))) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id > length("substring"(version(), 1, 6))) -- Disabling the GUC will prevent execution time chunk skipping RESET timescaledb.enable_chunk_skipping; :PREFIX UPDATE sample_table set sensor_id = 10 WHERE sensor_id > length(substring(version(),1,9)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on sample_table Update on _hyper_1_1_chunk sample_table_1 Update on _hyper_1_2_chunk sample_table_2 -> Result -> Custom Scan (ChunkAppend) on sample_table Chunks excluded during startup: 0 -> Seq Scan on _hyper_1_1_chunk sample_table_1 Filter: (sensor_id > length("substring"(version(), 1, 9))) -> Seq Scan on _hyper_1_2_chunk sample_table_2 Filter: (sensor_id > length("substring"(version(), 1, 9))) SET timescaledb.enable_chunk_skipping to ON; -- IN/ANY is not supported for now :PREFIX SELECT * FROM sample_table WHERE sensor_id IN (9, 10, 11); --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id = ANY ('{9,10,11}'::integer[])) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id = ANY ('{9,10,11}'::integer[])) :PREFIX SELECT * FROM sample_table WHERE sensor_id = ANY(ARRAY[9, 10, 11]); --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_sensor_id__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk Index Cond: (sensor_id = ANY ('{9,10,11}'::integer[])) -> Seq Scan on _hyper_1_2_chunk Filter: (sensor_id = ANY ('{9,10,11}'::integer[])) -- Newly added chunks should also have MIN/MAX entry \set start_date '2024-01-28 01:09:51.583252+05:30' INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 9, 78.999, 'new row4'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 1 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 2 | 1 | 1 | sensor_id | 1 | 9 | t 3 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 4 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- Check that a RENAME COLUMN works ok ALTER TABLE sample_table RENAME COLUMN sensor_id TO sense_id; -- use the disable_chunk_skipping API to remove the min/max range entries SELECT * from disable_chunk_skipping('sample_table', 'sense_id'); hypertable_id | column_name | disabled ---------------+-------------+---------- 1 | sense_id | t SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+-------------+-----------+------- SELECT * from disable_chunk_skipping('sample_table', 'sense_id', true); NOTICE: statistics not enabled for column "sense_id", skipping hypertable_id | column_name | disabled ---------------+-------------+---------- 1 | sense_id | f ALTER TABLE sample_table RENAME COLUMN sense_id TO sensor_id; \set ON_ERROR_STOP 0 SELECT * from disable_chunk_skipping('sample_table', 'sensor_id'); ERROR: statistics not enabled for column "sensor_id" SELECT * from disable_chunk_skipping('sample_table', NULL); ERROR: column name cannot be NULL SELECT * from disable_chunk_skipping(NULL, 'sensor_id'); ERROR: hypertable cannot be NULL SELECT * from disable_chunk_skipping('sample_table1', 'sensor_id'); ERROR: relation "sample_table1" does not exist at character 38 -- should only work on columns that have been enabled for tracking SELECT * from disable_chunk_skipping('sample_table', 'time'); ERROR: statistics not enabled for column "time" SELECT * from disable_chunk_skipping('sample_table', 'cpu'); ERROR: statistics not enabled for column "cpu" \set ON_ERROR_STOP 1 SELECT * FROM enable_chunk_skipping('sample_table', 'sensor_id'); column_stats_id | enabled -----------------+--------- 5 | t -- Chunk was already compressed before we enabled stats. It will -- point to min/max entries till the ranges get refreshed later. SELECT decompress_chunk(:'CH_NAME'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 5 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 6 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 7 | 1 | 1 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 8 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- Compressing a chunk again should calculate proper ranges SELECT compress_chunk(:'CH_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 5 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 6 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 7 | 1 | 1 | sensor_id | 1 | 9 | t 8 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t SELECT decompress_chunk(:'CH_NAME'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- Entry should be reset for this chunk now SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 5 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 6 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 7 | 1 | 1 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 8 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- Check that truncate resets the entry in the catalog SELECT compress_chunk(:'CH_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 5 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 6 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 7 | 1 | 1 | sensor_id | 1 | 9 | t 8 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t TRUNCATE :CH_NAME; SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 5 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 6 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 7 | 1 | 1 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 8 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- Check that drop chunk also removes entries from the catalog SELECT drop_chunks('sample_table', older_than => '2022-02-28'); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- Entry should be removed for this chunk now SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 5 | 1 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 6 | 1 | 2 | sensor_id | -9223372036854775808 | 9223372036854775807 | t 8 | 1 | 4 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- disable compression to allow dropping of the column ALTER TABLE sample_table SET ( timescaledb.compress = FALSE ); -- Check that a DROP COLUMN removes entries from catalogs as well ALTER TABLE sample_table DROP COLUMN sensor_id; SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+-------------+-----------+------- DROP TABLE sample_table; SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+-------------+-----------+------- -- Check that empty hypertables can have enable_chunk_skipping and -- that new chunks get entries in the catalog as they get added CREATE TABLE sample_table1 ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); CREATE INDEX sense_idx ON sample_table1 (sensor_id); SELECT * FROM create_hypertable('sample_table1', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 3 | public | sample_table1 | t SELECT * FROM enable_chunk_skipping('sample_table1', 'sensor_id'); column_stats_id | enabled -----------------+--------- 9 | t SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 9 | 3 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table1 VALUES (:'start_date'::timestamptz, 12, 21, 33.123, 'new row1'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 9 | 3 | | sensor_id | -9223372036854775808 | 9223372036854775807 | t 10 | 3 | 7 | sensor_id | -9223372036854775808 | 9223372036854775807 | t -- Check that ALTER TYPE for a column on which stats are enabled only works -- in a few sub types ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE BIGINT; \set ON_ERROR_STOP 0 ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE TIMESTAMPTZ; ERROR: column "sensor_id" cannot be cast automatically to type timestamp with time zone ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE TEXT; ERROR: data type "text" unsupported for statistics calculation \set ON_ERROR_STOP 1 SELECT * FROM disable_chunk_skipping('sample_table1', 'sensor_id'); hypertable_id | column_name | disabled ---------------+-------------+---------- 3 | sensor_id | t ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE TEXT; -- Check that column mapping between hypertable and chunk doesn't break when -- hypertable has dropped columns -- See: https://github.com/timescale/timescaledb/issues/7932 CREATE TABLE sample_table ( time TIMESTAMPTZ NOT NULL, sensor_id INTEGER, cpu NUMERIC, temperature BIGINT); CREATE INDEX ON sample_table (temperature); SELECT create_hypertable('sample_table', 'time', chunk_time_interval=>'7 days'::interval); create_hypertable --------------------------- (4,public,sample_table,t) ALTER TABLE sample_table DROP COLUMN sensor_id; INSERT INTO sample_table VALUES (now(), 1, 366), (now(), 2, 501); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='temperature'); set timescaledb.enable_chunk_skipping = on; SELECT enable_chunk_skipping('sample_table', 'temperature'); enable_chunk_skipping ----------------------- (11,t) SELECT show_chunks('sample_table') AS "CH_NAME" order by 1 limit 1 \gset SELECT compress_chunk(:'CH_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_4_8_chunk SELECT * FROM _timescaledb_catalog.chunk_column_stats ORDER BY 1; id | hypertable_id | chunk_id | column_name | range_start | range_end | valid ----+---------------+----------+-------------+----------------------+---------------------+------- 11 | 4 | | temperature | -9223372036854775808 | 9223372036854775807 | t 12 | 4 | 8 | temperature | 366 | 502 | t -- Check min/max ranges for partial chunks with segmentby columns get recalculated correctly by seementwise recompression CREATE TABLE chunk_skipping(time timestamptz,device text, updated_at timestamptz) WITH (tsdb.hypertable, tsdb.partition_column='time',tsdb.segmentby='device'); SELECT enable_chunk_skipping('chunk_skipping', 'updated_at'); enable_chunk_skipping ----------------------- (13,t) INSERT INTO chunk_skipping SELECT '2025-01-01', 'd1', '2025-01-01'; SELECT compress_chunk(show_chunks('chunk_skipping')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_6_10_chunk SELECT * from chunk_skipping where updated_at < '2026-01-01'; time | device | updated_at ------------------------------+--------+------------------------------ Wed Jan 01 00:00:00 2025 PST | d1 | Wed Jan 01 00:00:00 2025 PST INSERT INTO chunk_skipping SELECT '2025-01-01', 'd2', '2026-01-01'; SELECT compress_chunk(show_chunks('chunk_skipping')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_6_10_chunk SELECT * from chunk_skipping where updated_at < '2026-01-01'; time | device | updated_at ------------------------------+--------+------------------------------ Wed Jan 01 00:00:00 2025 PST | d1 | Wed Jan 01 00:00:00 2025 PST ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/chunk_merge.out������������������������������������������������0000664�0000000�0000000�00000015611�15100345067�0022461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_merge_chunks_on_dimension(chunk REGCLASS, merge_chunk REGCLASS, dimension_id INTEGER) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_merge_chunks_on_dimension' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE test1 ("Time" timestamptz, i integer, value integer); SELECT table_name FROM Create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test1 SELECT table_name FROM add_dimension('test1', 'i', number_partitions=> 2); table_name ------------ test1 ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); -- This creates chunks 1 - 3 on first hypertable. INSERT INTO test1 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; -- This creates chunks 4 - 6 on first hypertable. INSERT INTO test1 SELECT t, 2, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; CREATE TABLE test2 ("Time" timestamptz, i integer, value integer); SELECT table_name FROM Create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test2 -- This creates chunks 7 - 9 on second hypertable. INSERT INTO test2 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | | f | 0 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 1 | _timescaledb_internal | _hyper_1_4_chunk | | f | 0 | f 5 | 1 | _timescaledb_internal | _hyper_1_5_chunk | | f | 0 | f 6 | 1 | _timescaledb_internal | _hyper_1_6_chunk | | f | 0 | f 7 | 3 | _timescaledb_internal | _hyper_3_7_chunk | | f | 0 | f 8 | 3 | _timescaledb_internal | _hyper_3_8_chunk | | f | 0 | f 9 | 3 | _timescaledb_internal | _hyper_3_9_chunk | | f | 0 | f \set ON_ERROR_STOP 0 -- Cannot merge chunks from different hypertables SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_3_7_chunk', 1); ERROR: cannot merge chunks from different hypertables -- Cannot merge non-adjacent chunks SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_3_chunk', 1); ERROR: cannot merge non-adjacent chunks over supplied dimension -- Cannot merge same chunk to itself (its not adjacent to itself). SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_1_chunk', 1); ERROR: cannot merge non-adjacent chunks over supplied dimension -- Cannot merge chunks on with different partitioning schemas. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_4_chunk', 1); ERROR: cannot merge chunks with different partitioning schemas -- Cannot merge chunks on with non-existant dimension slice. -- NOTE: we are merging the same chunk just so they have the exact same partitioning schema and we don't hit the previous test error. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_1_chunk', 999); ERROR: cannot find slice for merging dimension \set ON_ERROR_STOP 1 -- Merge on open (time) dimension. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_5_chunk','_timescaledb_internal._hyper_1_6_chunk', 1); test_merge_chunks_on_dimension -------------------------------- -- Merge on closed dimension. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_4_chunk', 2); test_merge_chunks_on_dimension -------------------------------- SELECT compress_chunk(i) FROM show_chunks('test1') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_5_chunk \set ON_ERROR_STOP 0 -- Cannot merge chunks internal compressed chunks, no dimensions on them. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal.compress_hyper_2_10_chunk','_timescaledb_internal.compress_hyper_2_11_chunk', 1); ERROR: cannot find slice for merging dimension \set ON_ERROR_STOP 1 -- This creates more data so caggs has multiple chunks. INSERT INTO test1 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 3:00'::TIMESTAMPTZ, '2018-03-03 3:00', '1 minute') t; CREATE MATERIALIZED VIEW test_cagg WITH (timescaledb.continuous) AS SELECT i, time_bucket(INTERVAL '1 hour', "Time") AS bucket, AVG(value) FROM test1 GROUP BY i, bucket; NOTICE: refreshing continuous aggregate "test_cagg" -- Merging cagg chunks should also work. WITH adjacent_slices AS (SELECT S1.id AS PRIMARY, s2.id AS secondary FROM _timescaledb_catalog.dimension_slice s2 INNER JOIN _timescaledb_catalog.dimension_slice s1 ON s1.range_end = s2.range_start WHERE s1.dimension_id = 4 AND s2.dimension_id = 4 LIMIT 1), chunks AS (SELECT c1.chunk_id AS primary_chunk, c2.chunk_id AS secondary_chunk FROM adjacent_slices INNER JOIN _timescaledb_catalog.chunk_constraint c1 ON c1.dimension_slice_id = adjacent_slices.primary INNER JOIN _timescaledb_catalog.chunk_constraint c2 ON c2.dimension_slice_id = adjacent_slices.secondary) SELECT _timescaledb_internal.test_merge_chunks_on_dimension(format('_timescaledb_internal._hyper_4_%s_chunk', chunks.primary_chunk), format('_timescaledb_internal._hyper_4_%s_chunk', chunks.secondary_chunk), 4) FROM chunks; test_merge_chunks_on_dimension -------------------------------- �����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/chunk_utils_compression.out������������������������������������0000664�0000000�0000000�00000014514�15100345067�0025144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------------------------------------------------------- -- show_chunks and drop_chunks functions on a compressed table -- (issue https://github.com/timescale/timescaledb/issues/1535) -- create a table that will not be compressed CREATE TABLE public.uncompressed_table(time date NOT NULL, temp float8, device_id text); CREATE INDEX ON public.uncompressed_table(time DESC); SELECT create_hypertable('public.uncompressed_table', 'time', chunk_time_interval => interval '1 day'); create_hypertable --------------------------------- (1,public,uncompressed_table,t) INSERT INTO public.uncompressed_table VALUES('2020-03-01', 1.0, 'dev1'); INSERT INTO public.uncompressed_table VALUES('2020-03-05', 2.0, 'dev1'); INSERT INTO public.uncompressed_table VALUES('2020-03-07', 3.0, 'dev1'); INSERT INTO public.uncompressed_table VALUES('2020-03-08', 4.0, 'dev7'); INSERT INTO public.uncompressed_table VALUES('2020-03-09', 5.0, 'dev7'); INSERT INTO public.uncompressed_table VALUES('2020-03-10', 6.0, 'dev7'); -- create next table that is going to be compressed: CREATE TABLE public.table_to_compress (time date NOT NULL, acq_id bigint, value bigint); CREATE INDEX idx_table_to_compress_acq_id ON public.table_to_compress(acq_id); SELECT create_hypertable('public.table_to_compress', 'time', chunk_time_interval => interval '1 day'); create_hypertable -------------------------------- (2,public,table_to_compress,t) ALTER TABLE public.table_to_compress SET (timescaledb.compress, timescaledb.compress_segmentby = 'acq_id'); INSERT INTO public.table_to_compress VALUES ('2020-01-01', 1234567, 777888); INSERT INTO public.table_to_compress VALUES ('2020-02-01', 567567, 890890); INSERT INTO public.table_to_compress VALUES ('2020-02-10', 1234, 5678); SELECT show_chunks('public.uncompressed_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk SELECT show_chunks('public.table_to_compress'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk SELECT show_chunks('public.table_to_compress', older_than=>'1 day'::interval); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk SELECT show_chunks('public.table_to_compress', newer_than=>'1 day'::interval); show_chunks ------------- -- compress all chunks of the table: SELECT compress_chunk(show_chunks('public.table_to_compress')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk -- check that approx size function works. We call VACUUM to ensure all forks exist VACUUM public.table_to_compress; SELECT * FROM hypertable_approximate_size('public.table_to_compress'); hypertable_approximate_size ----------------------------- 262144 SELECT * FROM hypertable_size('public.table_to_compress'); hypertable_size ----------------- 262144 -- and run the queries again to make sure results are the same SELECT show_chunks('public.uncompressed_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk SELECT show_chunks('public.table_to_compress'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk SELECT show_chunks('public.table_to_compress', older_than=>'1 day'::interval); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk SELECT show_chunks('public.table_to_compress', newer_than=>'1 day'::interval); show_chunks ------------- -- truncate one compressed chunk SELECT chunk_schema || '.' || chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'table_to_compress' and hypertable_schema = 'public' ORDER BY chunk_name LIMIT 1 \gset SELECT count(*) FROM :CHNAME; count ------- 1 TRUNCATE TABLE :CHNAME; SELECT count(*) FROM :CHNAME; count ------- 0 -- drop all hypertables' old chunks SELECT drop_chunks(table_name::regclass, older_than=>'1 day'::interval) FROM _timescaledb_catalog.hypertable WHERE schema_name = current_schema() ORDER BY table_name DESC; drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk SELECT show_chunks('public.uncompressed_table'); show_chunks ------------- SELECT show_chunks('public.table_to_compress'); show_chunks ------------- -- test calling on internal compressed table SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "TABLENAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'table_to_compress') \gset \set ON_ERROR_STOP 0 SELECT show_chunks(:'TABLENAME'); ERROR: invalid operation on compressed hypertable SELECT drop_chunks(:'TABLENAME',now()); ERROR: hypertable has no open partitioning dimension \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/chunk_utils_internal.out���������������������������������������0000664�0000000�0000000�00000216712�15100345067�0024423�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- These tests work for PG14 or greater -- Remember to corordinate any changes to functionality with the Cloud -- Storage team. Tests for the following API: -- * freeze_chunk -- * drop_chunk -- * attach_foreign_table_chunk -- * hypertable_osm_range_update \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' CREATE OR REPLACE VIEW chunk_view AS SELECT ht.table_name AS hypertable_name, srcch.schema_name AS schema_name, srcch.table_name AS chunk_name, _timescaledb_functions.to_timestamp(dimsl.range_start) AS range_start, _timescaledb_functions.to_timestamp(dimsl.range_end) AS range_end FROM _timescaledb_catalog.chunk srcch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = srcch.hypertable_id INNER JOIN _timescaledb_catalog.chunk_constraint chcons ON srcch.id = chcons.chunk_id INNER JOIN _timescaledb_catalog.dimension dim ON srcch.hypertable_id = dim.hypertable_id INNER JOIN _timescaledb_catalog.dimension_slice dimsl ON dim.id = dimsl.dimension_id AND chcons.dimension_slice_id = dimsl.id; GRANT SELECT on chunk_view TO PUBLIC; \c :TEST_DBNAME :ROLE_SUPERUSER -- fake presence of timescaledb_osm INSERT INTO pg_extension(oid,extname,extowner,extnamespace,extrelocatable,extversion) SELECT 1,'timescaledb_osm',10,11,false,'1.0'; CREATE SCHEMA test1; GRANT CREATE ON SCHEMA test1 TO :ROLE_DEFAULT_PERM_USER; GRANT USAGE ON SCHEMA test1 TO :ROLE_DEFAULT_PERM_USER; GRANT USAGE ON SCHEMA test1 TO :ROLE_4; -- mock hooks for OSM interaction with timescaledb CREATE OR REPLACE FUNCTION ts_setup_osm_hook( ) RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_undo_osm_hook( ) RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE test1.hyper1 (time bigint, temp float); SELECT create_hypertable('test1.hyper1', 'time', chunk_time_interval => 10); create_hypertable -------------------- (1,test1,hyper1,t) INSERT INTO test1.hyper1 VALUES (10, 0.5); INSERT INTO test1.hyper1 VALUES (30, 0.5); SELECT chunk_schema as "CHSCHEMA", chunk_name as "CHNAME", range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name ; CHSCHEMA | CHNAME | range_start_integer | range_end_integer -----------------------+------------------+---------------------+------------------- _timescaledb_internal | _hyper_1_1_chunk | 10 | 20 _timescaledb_internal | _hyper_1_2_chunk | 30 | 40 ----- TESTS for freeze and unfreeze chunk ------------ --TEST internal api that freezes a chunk --freeze one of the chunks SELECT chunk_schema || '.' || chunk_name as "CHNAME", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset -- Freeze SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); freeze_chunk -------------- t SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 30 | 0.5 -- TEST updates and deletes on frozen chunk should fail \set ON_ERROR_STOP 0 SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 30 | 0.5 -- Value (time = 20) does not exist UPDATE test1.hyper1 SET temp = 40 WHERE time = 20; -- Frozen chunk is affected UPDATE test1.hyper1 SET temp = 40 WHERE temp = 0.5; ERROR: cannot update/delete rows from chunk "_hyper_1_1_chunk" as it is frozen -- Frozen chunk is affected UPDATE test1.hyper1 SET temp = 40 WHERE time = 10; ERROR: cannot update/delete rows from chunk "_hyper_1_1_chunk" as it is frozen -- Frozen chunk is affected DELETE FROM test1.hyper1 WHERE time = 10; ERROR: cannot update/delete rows from chunk "_hyper_1_1_chunk" as it is frozen SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 30 | 0.5 BEGIN; DELETE FROM test1.hyper1 WHERE time = 20; DELETE FROM test1.hyper1 WHERE temp = 0.5; ERROR: cannot update/delete rows from chunk "_hyper_1_1_chunk" as it is frozen ROLLBACK; -- TEST update on unfrozen chunk should be possible BEGIN; SELECT * FROM test1.hyper1; time | temp ------+------ 10 | 0.5 30 | 0.5 UPDATE test1.hyper1 SET temp = 40 WHERE time = 30; SELECT * FROM test1.hyper1; time | temp ------+------ 10 | 0.5 30 | 40 ROLLBACK; -- Test with cast (chunk path pruning can not be done during query planning) BEGIN; SELECT * FROM test1.hyper1 WHERE time = 30; time | temp ------+------ 30 | 0.5 UPDATE test1.hyper1 SET temp = 40 WHERE time = 30::text::float; ERROR: cannot update/delete rows from chunk "_hyper_1_1_chunk" as it is frozen SELECT * FROM test1.hyper1 WHERE time = 30; ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- TEST delete on unfrozen chunks should be possible BEGIN; SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 30 | 0.5 DELETE FROM test1.hyper1 WHERE time = 30; SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 ROLLBACK; -- Test with cast BEGIN; SELECT * FROM test1.hyper1 WHERE time = 30; time | temp ------+------ 30 | 0.5 DELETE FROM test1.hyper1 WHERE time = 30::text::float; ERROR: cannot update/delete rows from chunk "_hyper_1_1_chunk" as it is frozen SELECT * FROM test1.hyper1 WHERE time = 30; ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; -- TEST inserts into a frozen chunk fails INSERT INTO test1.hyper1 VALUES ( 11, 11); ERROR: cannot INSERT into frozen chunk "_hyper_1_1_chunk" -- Test truncating table should fail TRUNCATE :CHNAME; ERROR: cannot TRUNCATE frozen chunk "_hyper_1_1_chunk" SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 30 | 0.5 \set ON_ERROR_STOP 1 --insert into non-frozen chunk works INSERT INTO test1.hyper1 VALUES ( 31, 31); SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ 10 | 0.5 30 | 0.5 31 | 31 -- TEST unfreeze frozen chunk and then drop SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'CHUNK_NAME'; table_name | status ------------------+-------- _hyper_1_1_chunk | 4 SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME'); unfreeze_chunk ---------------- t SELECT tgname, tgtype FROM pg_trigger WHERE tgrelid = :'CHNAME'::regclass ORDER BY tgname, tgtype; tgname | tgtype --------+-------- --verify status in catalog SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'CHUNK_NAME'; table_name | status ------------------+-------- _hyper_1_1_chunk | 0 -- Test update works after unfreeze UPDATE test1.hyper1 SET temp = 40; -- Test delete works after unfreeze DELETE FROM test1.hyper1; --unfreezing again works SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME'); unfreeze_chunk ---------------- t SELECT _timescaledb_functions.drop_chunk( :'CHNAME'); drop_chunk ------------ t -- TEST freeze_chunk api on a chunk that is compressed CREATE TABLE public.table_to_compress (time date NOT NULL, acq_id bigint, value bigint); CREATE INDEX idx_table_to_compress_acq_id ON public.table_to_compress(acq_id); SELECT create_hypertable('public.table_to_compress', 'time', chunk_time_interval => interval '1 day'); create_hypertable -------------------------------- (2,public,table_to_compress,t) ALTER TABLE public.table_to_compress SET (timescaledb.compress, timescaledb.compress_segmentby = 'acq_id'); INSERT INTO public.table_to_compress VALUES ('2020-01-01', 1234567, 777888); INSERT INTO public.table_to_compress VALUES ('2020-02-01', 567567, 890890); INSERT INTO public.table_to_compress VALUES ('2020-02-10', 1234, 5678); SELECT show_chunks('public.table_to_compress'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_3_chunk _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk SELECT chunk_schema || '.' || chunk_name as "CHNAME", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'table_to_compress' and hypertable_schema = 'public' ORDER BY chunk_name LIMIT 1 \gset SELECT compress_chunk( :'CHNAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_2_3_chunk SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); freeze_chunk -------------- t SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'CHUNK_NAME'; table_name | status ------------------+-------- _hyper_2_3_chunk | 5 --now chunk is frozen, cannot decompress \set ON_ERROR_STOP 0 SELECT decompress_chunk( :'CHNAME'); ERROR: decompress_chunk not permitted on frozen chunk "_hyper_2_3_chunk" --insert into frozen chunk, should fail INSERT INTO public.table_to_compress VALUES ('2020-01-01 10:00', 12, 77); ERROR: cannot INSERT into frozen chunk "_hyper_2_3_chunk" --touches all chunks UPDATE public.table_to_compress SET value = 3; ERROR: cannot modify frozen chunk status --touches only frozen chunk DELETE FROM public.table_to_compress WHERE time < '2020-01-02'; ERROR: cannot update/delete rows from chunk "_hyper_2_3_chunk" as it is frozen \set ON_ERROR_STOP 1 --try to refreeze SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); freeze_chunk -------------- t --touches non-frozen chunk SELECT * from public.table_to_compress ORDER BY 1, 3; time | acq_id | value ------------+---------+-------- 01-01-2020 | 1234567 | 777888 02-01-2020 | 567567 | 890890 02-10-2020 | 1234 | 5678 DELETE FROM public.table_to_compress WHERE time > '2020-01-02'; SELECT * from public.table_to_compress ORDER BY 1, 3; time | acq_id | value ------------+---------+-------- 01-01-2020 | 1234567 | 777888 --TEST cannot drop frozen chunk, no error is reported. -- simply skips SELECT drop_chunks('table_to_compress', older_than=> '1 day'::interval); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk --unfreeze and drop it SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME'); unfreeze_chunk ---------------- t SELECT _timescaledb_functions.drop_chunk( :'CHNAME'); drop_chunk ------------ t --add a new chunk INSERT INTO public.table_to_compress VALUES ('2019-01-01', 1234567, 777888); --TEST compress a frozen chunk fails SELECT chunk_schema || '.' || chunk_name as "CHNAME", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'table_to_compress' and hypertable_schema = 'public' ORDER BY chunk_name DESC LIMIT 1 \gset SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); freeze_chunk -------------- t \set ON_ERROR_STOP 0 SELECT compress_chunk( :'CHNAME'); ERROR: compress_chunk not permitted on frozen chunk "_hyper_2_7_chunk" \set ON_ERROR_STOP 1 --TEST dropping a frozen chunk --DO NOT CHANGE this behavior --- -- frozen chunks cannot be dropped. \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.drop_chunk(:'CHNAME'); ERROR: drop_chunk not permitted on frozen chunk "_hyper_2_7_chunk" \set ON_ERROR_STOP 1 -- Prepare table for CAGG tests TRUNCATE test1.hyper1; INSERT INTO test1.hyper1(time, temp) values(30, 0.5), (31, 31); --TEST drop_chunk in the presence of caggs. Does not affect cagg data CREATE OR REPLACE FUNCTION hyper_dummy_now() RETURNS BIGINT LANGUAGE SQL IMMUTABLE AS 'SELECT 100::BIGINT'; SELECT set_integer_now_func('test1.hyper1', 'hyper_dummy_now'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW hyper1_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket( 5, "time") as bucket, count(*) FROM test1.hyper1 GROUP BY 1; NOTICE: refreshing continuous aggregate "hyper1_cagg" SELECT * FROM hyper1_cagg ORDER BY 1; bucket | count --------+------- 30 | 2 --now freeze chunk and try to drop it SELECT chunk_schema || '.' || chunk_name as "CHNAME1", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset SELECT _timescaledb_functions.freeze_chunk( :'CHNAME1'); freeze_chunk -------------- t --cannot drop frozen chunk \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.drop_chunk( :'CHNAME1'); ERROR: drop_chunk not permitted on frozen chunk "_hyper_1_8_chunk" \set ON_ERROR_STOP 1 -- unfreeze the chunk, then drop the single chunk SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME1'); unfreeze_chunk ---------------- t --drop the single chunk and verify that cagg is unaffected. SELECT * FROM test1.hyper1 ORDER BY 1; time | temp ------+------ 30 | 0.5 31 | 31 SELECT _timescaledb_functions.drop_chunk( :'CHNAME1'); drop_chunk ------------ t SELECT * from test1.hyper1 ORDER BY 1; time | temp ------+------ SELECT * FROM hyper1_cagg ORDER BY 1; bucket | count --------+------- 30 | 2 -- check that dropping cagg triggers OSM callback SELECT ts_setup_osm_hook(); ts_setup_osm_hook ------------------- BEGIN; DROP MATERIALIZED VIEW hyper1_cagg CASCADE; NOTICE: drop cascades to table _timescaledb_internal._hyper_4_9_chunk NOTICE: hypertable_drop_hook DROP TABLE test1.hyper1; NOTICE: hypertable_drop_hook ROLLBACK; BEGIN; DROP TABLE test1.hyper1 CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_4_9_chunk NOTICE: hypertable_drop_hook NOTICE: hypertable_drop_hook ROLLBACK; SELECT ts_undo_osm_hook(); ts_undo_osm_hook ------------------ --TEST error case (un)freeze a non-chunk CREATE TABLE nochunk_tab( a timestamp, b integer); \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.freeze_chunk('nochunk_tab'); ERROR: chunk not found SELECT _timescaledb_functions.unfreeze_chunk('nochunk_tab'); ERROR: chunk not found \set ON_ERROR_STOP 1 ----- TESTS for attach_osm_table_chunk ------------ --TEST for attaching a foreign table as a chunk --need superuser access to create foreign data server \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE postgres_fdw_db; GRANT ALL PRIVILEGES ON DATABASE postgres_fdw_db TO :ROLE_4; \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_table( timec timestamptz NOT NULL , acq_id bigint, value bigint); INSERT INTO fdw_table VALUES( '2020-01-01 01:00', 100, 1000); --create foreign server and user mappings as superuser \c :TEST_DBNAME :ROLE_SUPERUSER SELECT current_setting('port') as "PORTNO" \gset CREATE EXTENSION postgres_fdw; CREATE SERVER s3_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS ( host 'localhost', dbname 'postgres_fdw_db', port :'PORTNO'); GRANT USAGE ON FOREIGN SERVER s3_server TO :ROLE_4; CREATE USER MAPPING FOR :ROLE_4 SERVER s3_server OPTIONS ( user :'ROLE_4' , password :'ROLE_4_PASS'); ALTER USER MAPPING FOR :ROLE_4 SERVER s3_server OPTIONS (ADD password_required 'false'); \c :TEST_DBNAME :ROLE_4; -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_fdw_table (timec timestamptz NOT NULL, acq_id bigint, value bigint) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_table'); --now attach foreign table as a chunk of the hypertable. CREATE TABLE ht_try(timec timestamptz NOT NULL, acq_id bigint, value bigint); SELECT create_hypertable('ht_try', 'timec', chunk_time_interval => interval '1 day'); create_hypertable --------------------- (5,public,ht_try,t) INSERT INTO ht_try VALUES ('2022-05-05 01:00', 222, 222); SELECT * FROM child_fdw_table; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 -- test size functions on foreign table SELECT * FROM _timescaledb_functions.relation_approximate_size('child_fdw_table'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 SELECT * FROM _timescaledb_functions.relation_size('child_fdw_table'); total_size | heap_size | index_size | toast_size ------------+-----------+------------+------------ 0 | 0 | 0 | 0 -- error should be thrown as the hypertable does not yet have an associated tiered chunk \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try','2020-01-01 01:00'::timestamptz, '2020-01-01 03:00'); ERROR: no OSM chunk found for hypertable public.ht_try \set ON_ERROR_STOP 1 SELECT _timescaledb_functions.attach_osm_table_chunk('ht_try', 'child_fdw_table'); attach_osm_table_chunk ------------------------ t -- check hypertable status SELECT status FROM _timescaledb_catalog.hypertable WHERE table_name = 'ht_try'; status -------- 3 -- must also update the range since the created chunk contains data SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2020-01-01'::timestamptz, '2020-01-02'); hypertable_osm_range_update ----------------------------- f -- OSM chunk is not visible in chunks view SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'ht_try' ORDER BY 1; chunk_name | range_start | range_end -------------------+------------------------------+------------------------------ _hyper_5_10_chunk | Wed May 04 17:00:00 2022 PDT | Thu May 05 17:00:00 2022 PDT SELECT chunk_name, range_start, range_end FROM chunk_view WHERE hypertable_name = 'ht_try' ORDER BY chunk_name; chunk_name | range_start | range_end -------------------+------------------------------+------------------------------ _hyper_5_10_chunk | Wed May 04 17:00:00 2022 PDT | Thu May 05 17:00:00 2022 PDT child_fdw_table | Wed Jan 01 00:00:00 2020 PST | Thu Jan 02 00:00:00 2020 PST SELECT * FROM ht_try ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 Thu May 05 01:00:00 2022 PDT | 222 | 222 -- Check that the direct select from OSM chunk doesn't lead to bad effects. SELECT * FROM child_fdw_table; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 SELECT relname, relowner::regrole FROM pg_class WHERE relname in ( select chunk_name FROM chunk_view WHERE hypertable_name = 'ht_try' ) ORDER BY relname; relname | relowner -------------------+------------- _hyper_5_10_chunk | test_role_4 child_fdw_table | test_role_4 SELECT inhrelid::regclass FROM pg_inherits WHERE inhparent = 'ht_try'::regclass ORDER BY 1; inhrelid ----------------------------------------- child_fdw_table _timescaledb_internal._hyper_5_10_chunk --TEST chunk exclusion code does not filter out OSM chunk SELECT * from ht_try ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 Thu May 05 01:00:00 2022 PDT | 222 | 222 SELECT * from ht_try WHERE timec < '2022-01-01 01:00' ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 SELECT * from ht_try WHERE timec = '2020-01-01 01:00' ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 SELECT * from ht_try WHERE timec > '2000-01-01 01:00' and timec < '2022-01-01 01:00' ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 SELECT * from ht_try WHERE timec > '2020-01-01 01:00' ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Thu May 05 01:00:00 2022 PDT | 222 | 222 -- test ordered append BEGIN; -- before updating the ranges :EXPLAIN SELECT * FROM ht_try ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on ht_try Order: ht_try.timec -> Foreign Scan on child_fdw_table -> Index Scan Backward using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk -- range before update SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.table_name = 'child_fdw_table' AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+-----------------+--------+-----------+--------------------+------------------+------------------ 11 | child_fdw_table | 0 | t | 10 | 1577865600000000 | 1577952000000000 SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2020-01-01 01:00'::timestamptz, '2020-01-02'); hypertable_osm_range_update ----------------------------- f SELECT id, schema_name, table_name, status FROM _timescaledb_catalog.hypertable WHERE table_name = 'ht_try'; id | schema_name | table_name | status ----+-------------+------------+-------- 5 | public | ht_try | 1 -- verify range was updated SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.table_name = 'child_fdw_table' AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+-----------------+--------+-----------+--------------------+------------------+------------------ 11 | child_fdw_table | 0 | t | 10 | 1577869200000000 | 1577952000000000 -- should be ordered append now :EXPLAIN SELECT * FROM ht_try ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on ht_try Order: ht_try.timec -> Foreign Scan on child_fdw_table -> Index Scan Backward using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk SELECT * FROM ht_try ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 Thu May 05 01:00:00 2022 PDT | 222 | 222 -- test invalid range - should not be ordered append SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try'); hypertable_osm_range_update ----------------------------- f :EXPLAIN SELECT * from ht_try ORDER BY 1; --- QUERY PLAN --- Merge Append Sort Key: ht_try.timec -> Index Scan Backward using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk -> Foreign Scan on child_fdw_table SELECT * from ht_try ORDER BY 1; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 Thu May 05 01:00:00 2022 PDT | 222 | 222 ROLLBACK; \set ON_ERROR_STOP 0 -- test that error is produced when range_start < range_end SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2020-01-02 01:00'::timestamptz, '2020-01-02 00:00'); ERROR: dimension slice range_end cannot be less than range_start -- error when range overlaps SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2022-05-05 01:00'::timestamptz, '2022-05-06'); ERROR: attempting to set overlapping range for tiered chunk of public.ht_try \set ON_ERROR_STOP 1 -- test that approximate size function works when a osm chunk is present SELECT * FROM hypertable_approximate_size('ht_try'); hypertable_approximate_size ----------------------------- 32768 --TEST GUC variable to enable/disable OSM chunk SET timescaledb.enable_tiered_reads=false; :EXPLAIN SELECT * from ht_try; --- QUERY PLAN --- Seq Scan on _hyper_5_10_chunk :EXPLAIN SELECT * from ht_try WHERE timec > '2022-01-01 01:00'; --- QUERY PLAN --- Index Scan using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk Index Cond: (timec > 'Sat Jan 01 01:00:00 2022 PST'::timestamp with time zone) :EXPLAIN SELECT * from ht_try WHERE timec < '2023-01-01 01:00'; --- QUERY PLAN --- Index Scan using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk Index Cond: (timec < 'Sun Jan 01 01:00:00 2023 PST'::timestamp with time zone) SET timescaledb.enable_tiered_reads=true; :EXPLAIN SELECT * from ht_try; --- QUERY PLAN --- Append -> Foreign Scan on child_fdw_table -> Seq Scan on _hyper_5_10_chunk -- foreign chunk contains data from Jan 2020, so it is skipped during planning :EXPLAIN SELECT * from ht_try WHERE timec > '2022-01-01 01:00'; --- QUERY PLAN --- Index Scan using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk Index Cond: (timec > 'Sat Jan 01 01:00:00 2022 PST'::timestamp with time zone) :EXPLAIN SELECT * from ht_try WHERE timec < '2023-01-01 01:00'; --- QUERY PLAN --- Append -> Foreign Scan on child_fdw_table -> Index Scan using _hyper_5_10_chunk_ht_try_timec_idx on _hyper_5_10_chunk Index Cond: (timec < 'Sun Jan 01 01:00:00 2023 PST'::timestamp with time zone) -- Test forceful refreshment. Here we simulate the situation that we've seen -- with tiered data when `timescaledb.enable_tiered_reads` were disabled on the -- server level. In that case we would not see materialized tiered data and -- we wouldn't be able to re-materialize the data using a normal refresh call -- because it would skip previously materialized ranges, but it should be -- possible with `force=>true` parameter. CREATE MATERIALIZED VIEW ht_try_weekly WITH (timescaledb.continuous) AS SELECT time_bucket(interval '1 week', timec) AS ts_bucket, avg(value) FROM ht_try GROUP BY 1 WITH NO DATA; SELECT * FROM ht_try_weekly; ts_bucket | avg -----------+----- SET timescaledb.enable_tiered_reads=false; CALL refresh_continuous_aggregate('ht_try_weekly', '2019-12-29', '2020-01-10', force=>false); SELECT * FROM ht_try_weekly; ts_bucket | avg -----------+----- SET timescaledb.enable_tiered_reads=true; CALL refresh_continuous_aggregate('ht_try_weekly', '2019-12-29', '2020-01-10', force=>true); SELECT * FROM ht_try_weekly; ts_bucket | avg ------------------------------+----------------------- Sun Dec 29 16:00:00 2019 PST | 1000.0000000000000000 DROP MATERIALIZED VIEW ht_try_weekly; NOTICE: drop cascades to table _timescaledb_internal._hyper_6_12_chunk -- Test refresh policy with different settings of `include_tiered_data` parameter CREATE FUNCTION create_test_cagg(include_tiered_data BOOL) RETURNS INTEGER AS $$ DECLARE cfg jsonb; job_id INTEGER; BEGIN CREATE MATERIALIZED VIEW ht_try_weekly WITH (timescaledb.continuous) AS SELECT time_bucket(interval '1 week', timec) AS ts_bucket, avg(value) FROM ht_try GROUP BY 1 WITH NO DATA; job_id := add_continuous_aggregate_policy( 'ht_try_weekly', start_offset => NULL, end_offset => INTERVAL '1 hour', schedule_interval => INTERVAL '1 hour', include_tiered_data => include_tiered_data ); cfg := config FROM _timescaledb_config.bgw_job WHERE id = job_id; RAISE NOTICE 'config: %', jsonb_pretty(cfg); RETURN job_id; END $$ LANGUAGE plpgsql; -- include tiered data SELECT create_test_cagg(true) AS job_id \gset NOTICE: config: { "end_offset": "@ 1 hour", "start_offset": null, "mat_hypertable_id": 7, "include_tiered_data": true } CALL run_job(:job_id); SELECT * FROM ht_try_weekly ORDER BY 1; ts_bucket | avg ------------------------------+----------------------- Sun Dec 29 16:00:00 2019 PST | 1000.0000000000000000 Sun May 01 17:00:00 2022 PDT | 222.0000000000000000 DROP MATERIALIZED VIEW ht_try_weekly; NOTICE: drop cascades to 2 other objects -- exclude tiered data SELECT create_test_cagg(false) AS job_id \gset NOTICE: config: { "end_offset": "@ 1 hour", "start_offset": null, "mat_hypertable_id": 8, "include_tiered_data": false } CALL run_job(:job_id); SELECT * FROM ht_try_weekly ORDER BY 1; ts_bucket | avg ------------------------------+---------------------- Sun May 01 17:00:00 2022 PDT | 222.0000000000000000 DROP MATERIALIZED VIEW ht_try_weekly; NOTICE: drop cascades to table _timescaledb_internal._hyper_8_15_chunk -- default behavior: use instance-wide GUC value SELECT create_test_cagg(null) AS job_id \gset NOTICE: config: { "end_offset": "@ 1 hour", "start_offset": null, "mat_hypertable_id": 9 } CALL run_job(:job_id); SELECT * FROM ht_try_weekly ORDER BY 1; ts_bucket | avg ------------------------------+----------------------- Sun Dec 29 16:00:00 2019 PST | 1000.0000000000000000 Sun May 01 17:00:00 2022 PDT | 222.0000000000000000 DROP MATERIALIZED VIEW ht_try_weekly; NOTICE: drop cascades to 2 other objects -- This test verifies that a bugfix regarding the way `ROWID_VAR`s are adjusted -- in the chunks' targetlists on DELETE/UPDATE works (including partially -- compressed chunks) ALTER table ht_try SET (timescaledb.compress); INSERT INTO ht_try VALUES ('2021-06-05 01:00', 10, 222); SELECT compress_chunk(show_chunks('ht_try', newer_than => '2021-01-01'::timestamptz)); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_10_chunk _timescaledb_internal._hyper_5_18_chunk INSERT INTO ht_try VALUES ('2021-06-05 01:00', 10, 222); DO $$ DECLARE r RECORD; BEGIN EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE ht_try SET value = 2 WHERE acq_id = 10 AND timec > now() - '15 years'::interval INTO r; END $$ LANGUAGE plpgsql; -- Check that the direct select from OSM chunk doesn't lead to bad effects in -- presence of compression. SELECT * FROM child_fdw_table; timec | acq_id | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | 100 | 1000 --TEST insert into a OSM chunk fails. actually any insert will fail. But we just need -- to mock the hook and make sure the timescaledb code works correctly. SELECT ts_setup_osm_hook(); ts_setup_osm_hook ------------------- \set ON_ERROR_STOP 0 --the mock hook returns true always. so cannot create a new chunk on the hypertable INSERT INTO ht_try VALUES ('2022-06-05 01:00', 222, 222); NOTICE: chunk_insert_check_hook ERROR: Cannot insert into tiered chunk range of public.ht_try - attempt to create new chunk with range [Sat Jun 04 17:00:00 2022 PDT Sun Jun 05 17:00:00 2022 PDT] failed \set ON_ERROR_STOP 1 SELECT ts_undo_osm_hook(); ts_undo_osm_hook ------------------ -- TEST error have to be hypertable owner to attach a chunk to it \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.attach_osm_table_chunk('ht_try', 'child_fdw_table'); ERROR: must be owner of hypertable "ht_try" -- TEST error try to attach to non hypertable CREATE TABLE non_ht (time bigint, temp float); SELECT _timescaledb_functions.attach_osm_table_chunk('non_ht', 'child_fdw_table'); ERROR: "non_ht" is not a hypertable -- TEST drop OSM chunk \c :TEST_DBNAME :ROLE_4 -- We need the OSM chunk for other tests so we run the test in a single -- transaction so that we could roll it back in the end BEGIN; -- get OSM chunk id SELECT c.id as osm_chunk_id, c.table_name as osm_chunk_name, ds.id as osm_dimension_slice FROM _timescaledb_catalog.chunk c JOIN _timescaledb_catalog.hypertable ht ON ht.id = c.hypertable_id JOIN _timescaledb_catalog.chunk_constraint cc ON cc.chunk_id = c.id JOIN _timescaledb_catalog.dimension_slice ds ON ds.id = cc.dimension_slice_id WHERE ht.table_name = 'ht_try' AND osm_chunk = true \gset \echo :osm_chunk_id, :osm_chunk_name, :osm_dimension_slice 11, child_fdw_table, 10 -- drop OSM chunk SELECT _timescaledb_functions.drop_osm_chunk('ht_try'); drop_osm_chunk ---------------- t -- status should be 0 meaning hypertable doesn't have an OSM chunk SELECT status FROM _timescaledb_catalog.hypertable WHERE table_name = 'ht_try'; status -------- 0 -- chunk, chunk_constraint and dimension slice should have been cleaned up SELECT FROM _timescaledb_catalog.chunk WHERE id = :osm_chunk_id; -- SELECT FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :osm_chunk_id; -- SELECT FROM _timescaledb_catalog.dimension_slice WHERE id = :osm_dimension_slice; -- -- foreign chunk no longer appears in the inheritance hierarchy SELECT * FROM test.show_subtables('ht_try'); Child | Tablespace -----------------------------------------+------------ _timescaledb_internal._hyper_5_10_chunk | _timescaledb_internal._hyper_5_18_chunk | -- verify that still can read from the table after catalog manipulations EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) SELECT * FROM ht_try; --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_10_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_10_19_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_18_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_10_20_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_5_18_chunk (actual rows=1.00 loops=1) ROLLBACK; -- TEST error out when trying to drop an OSM chunk from a hypertable that -- doesn't have it SELECT _timescaledb_functions.drop_osm_chunk('test1.hyper1'); ERROR: chunk not found -- TEST error out when trying to drop an OSM chunk from a regular table SELECT _timescaledb_functions.drop_osm_chunk('non_ht'); ERROR: "non_ht" is not a hypertable or a continuous aggregate \set ON_ERROR_STOP 1 -- TEST drop the hypertable and make sure foreign chunks are dropped as well -- \c :TEST_DBNAME :ROLE_4; DROP TABLE ht_try; SELECT relname FROM pg_class WHERE relname = 'child_fdw_table'; relname --------- SELECT table_name, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE hypertable_id IN (SELECT id from _timescaledb_catalog.hypertable WHERE table_name = 'ht_try') ORDER BY table_name; table_name | status | osm_chunk ------------+--------+----------- -- TEST can create OSM chunk if there are constraints on the hypertable \c :TEST_DBNAME :ROLE_4 CREATE TABLE measure( id integer PRIMARY KEY, mname varchar(10)); INSERT INTO measure VALUES( 1, 'temp'); INSERT INTO measure VALUES( 2, 'osmtemp'); CREATE TABLE devices( id integer PRIMARY KEY, devname varchar(10) ); INSERT INTO devices VALUES( 111, 'dev1'); INSERT INTO devices VALUES( 222, 'osmdev'); CREATE TABLE devicesref( id integer PRIMARY KEY, devname varchar(10) ); INSERT INTO devicesref VALUES( 44, 'devref'); INSERT INTO devicesref VALUES( 55, 'osmdevref'); CREATE TABLE hyper_constr ( id integer, time bigint, temp float, mid integer ,dev integer ,devref integer ,PRIMARY KEY (id, time) ,FOREIGN KEY ( mid) REFERENCES measure(id) ,FOREIGN KEY ( dev ) REFERENCES devices(id) ON DELETE CASCADE ,FOREIGN KEY ( devref ) REFERENCES devicesref(id) ON DELETE RESTRICT ,CHECK ( temp > 10) ); SELECT create_hypertable('hyper_constr', 'time', chunk_time_interval => 10); create_hypertable ---------------------------- (11,public,hyper_constr,t) INSERT INTO hyper_constr VALUES( 10, 200, 22, 1, 111, 44); \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_hyper_constr(id integer, time bigint, temp float, mid integer, dev integer, devref integer); INSERT INTO fdw_hyper_constr VALUES( 10, 100, 33, 2, 222, 55); \c :TEST_DBNAME :ROLE_4 -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_hyper_constr ( id integer NOT NULL, time bigint NOT NULL, temp float, mid integer, dev integer, devref integer) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_hyper_constr'); --check constraints are automatically added for the foreign table SELECT _timescaledb_functions.attach_osm_table_chunk('hyper_constr', 'child_hyper_constr'); attach_osm_table_chunk ------------------------ t -- was attached with data, so must update the range SELECT _timescaledb_functions.hypertable_osm_range_update('hyper_constr', 100, 110); hypertable_osm_range_update ----------------------------- f SELECT table_name, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE hypertable_id IN (SELECT id from _timescaledb_catalog.hypertable WHERE table_name = 'hyper_constr') ORDER BY table_name; table_name | status | osm_chunk --------------------+--------+----------- _hyper_11_21_chunk | 0 | f child_hyper_constr | 0 | t SELECT * FROM hyper_constr order by time; id | time | temp | mid | dev | devref ----+------+------+-----+-----+-------- 10 | 100 | 33 | 2 | 222 | 55 10 | 200 | 22 | 1 | 111 | 44 --verify the check constraint exists on the OSM chunk SELECT * FROM test.show_constraints('child_hyper_constr'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -------------------------+------+---------+-------+---------------------------------+------------+----------+----------- hyper_constr_temp_check | c | {temp} | - | (temp > (10)::double precision) | f | f | t -- TEST foreign key trigger: deleting data from foreign table measure -- does not error out due to data in osm chunk \set ON_ERROR_STOP 0 BEGIN; -- only show sqlstate here to hide constraint name difference \set VERBOSITY sqlstate DELETE FROM measure where id = 1; ERROR: 23503 \set VERBOSITY terse ROLLBACK; \set ON_ERROR_STOP 1 --this touches osm chunk. should succeed silently without deleting any data BEGIN; DELETE FROM measure where id = 2; SELECT * FROM measure order by id; id | mname ----+------- 1 | temp ROLLBACK; BEGIN; DELETE FROM devices where id = 222; SELECT * FROM devices order by id; id | devname -----+--------- 111 | dev1 ROLLBACK; BEGIN; DELETE FROM devicesref where id = 55; SELECT * FROM devicesref order by id; id | devname ----+--------- 44 | devref ROLLBACK; --TEST retention policy is applied on OSM chunk by calling registered callback CREATE OR REPLACE FUNCTION dummy_now_smallint() RETURNS BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 500::bigint' ; SELECT set_integer_now_func('hyper_constr', 'dummy_now_smallint'); set_integer_now_func ---------------------- SELECT add_retention_policy('hyper_constr', 100::int) AS deljob_id \gset --add hooks for osm callbacks that are triggered when drop_chunks is invoked--- SELECT ts_setup_osm_hook(); ts_setup_osm_hook ------------------- BEGIN; SELECT drop_chunks('hyper_constr', 10::int); NOTICE: hypertable_drop_chunks_hook drop_chunks ------------------------------ _timescaledb_internal.dummy0 _timescaledb_internal.dummy1 SELECT id, table_name FROM _timescaledb_catalog.chunk where hypertable_id = (Select id from _timescaledb_catalog.hypertable where table_name = 'hyper_constr') ORDER BY id; id | table_name ----+-------------------- 21 | _hyper_11_21_chunk 22 | child_hyper_constr -- show_chunks will not show the OSM chunk which is visible via the above query SELECT show_chunks('hyper_constr'); show_chunks ------------------------------------------ _timescaledb_internal._hyper_11_21_chunk ROLLBACK; CALL run_job(:deljob_id); NOTICE: hypertable_drop_chunks_hook CALL run_job(:deljob_id); NOTICE: hypertable_drop_chunks_hook SELECT chunk_name, range_start, range_end FROM chunk_view WHERE hypertable_name = 'hyper_constr' ORDER BY chunk_name; chunk_name | range_start | range_end --------------------+-----------------------------------+------------------------------------ child_hyper_constr | Wed Dec 31 16:00:00.0001 1969 PST | Wed Dec 31 16:00:00.00011 1969 PST SELECT ts_undo_osm_hook(); ts_undo_osm_hook ------------------ ----- TESTS for copy into frozen chunk ------------ \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1.copy_test ( "time" timestamptz NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('test1.copy_test', 'time', chunk_time_interval => interval '1 day'); create_hypertable ------------------------ (12,test1,copy_test,t) COPY test1.copy_test FROM STDIN DELIMITER ','; -- Freeze one of the chunks SELECT chunk_schema || '.' || chunk_name as "COPY_CHNAME", chunk_name as "COPY_CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'copy_test' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset SELECT _timescaledb_functions.freeze_chunk( :'COPY_CHNAME'); freeze_chunk -------------- t -- Check state SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'COPY_CHUNK_NAME'; table_name | status --------------------+-------- _hyper_12_23_chunk | 4 \set ON_ERROR_STOP 0 -- Copy should fail because one of che chunks is frozen COPY test1.copy_test FROM STDIN DELIMITER ','; ERROR: cannot INSERT into frozen chunk "_hyper_12_23_chunk" \set ON_ERROR_STOP 1 -- Count existing rows SELECT COUNT(*) FROM test1.copy_test; count ------- 2 -- Check state SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'COPY_CHUNK_NAME'; table_name | status --------------------+-------- _hyper_12_23_chunk | 4 \set ON_ERROR_STOP 0 -- Copy should fail because one of che chunks is frozen COPY test1.copy_test FROM STDIN DELIMITER ','; ERROR: cannot INSERT into frozen chunk "_hyper_12_23_chunk" \set ON_ERROR_STOP 1 -- Count existing rows SELECT COUNT(*) FROM test1.copy_test; count ------- 2 -- Check unfreeze restored chunk SELECT _timescaledb_functions.unfreeze_chunk( :'COPY_CHNAME'); unfreeze_chunk ---------------- t -- Check state SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'COPY_CHUNK_NAME'; table_name | status --------------------+-------- _hyper_12_23_chunk | 0 -- Copy should work now COPY test1.copy_test FROM STDIN DELIMITER ','; --Utility functions -check index creation on hypertable with OSM chunk -- Indexes are not created on OSM chunks, they are skipped as these are foreign tables \c :TEST_DBNAME :ROLE_4 CREATE INDEX hyper_constr_mid_idx ON hyper_constr( mid, time); NOTICE: skipping index creation for tiered data SELECT indexname, tablename FROM pg_indexes WHERE indexname = 'hyper_constr_mid_idx'; indexname | tablename ----------------------+-------------- hyper_constr_mid_idx | hyper_constr DROP INDEX hyper_constr_mid_idx; CREATE INDEX hyper_constr_mid_idx ON hyper_constr(mid, time) WITH (timescaledb.transaction_per_chunk); NOTICE: skipping index creation for tiered data SELECT indexname, tablename FROM pg_indexes WHERE indexname = 'hyper_constr_mid_idx'; indexname | tablename ----------------------+-------------- hyper_constr_mid_idx | hyper_constr DROP INDEX hyper_constr_mid_idx; \i include/chunk_utils_internal_orderedappend.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TESTS for hypertable_osm_range_update_function -- orderedappend (needs hypertable_osm_range_update to update catalog range) -- (so that ordered append will work with OSM chunks) -- TEST for hypertable_osm_range_update function -- test range of dimension slice for osm chunk for different datatypes CREATE TABLE osm_int2(time int2 NOT NULL); CREATE TABLE osm_int4(time int4 NOT NULL); CREATE TABLE osm_int8(time int8 NOT NULL); CREATE TABLE osm_date(time date NOT NULL); CREATE TABLE osm_ts(time timestamp NOT NULL); CREATE TABLE osm_tstz(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('osm_int2','time',chunk_time_interval:=1000); table_name ------------ osm_int2 SELECT table_name FROM create_hypertable('osm_int4','time',chunk_time_interval:=1000); table_name ------------ osm_int4 SELECT table_name FROM create_hypertable('osm_int8','time',chunk_time_interval:=1000); table_name ------------ osm_int8 SELECT table_name FROM create_hypertable('osm_date','time'); table_name ------------ osm_date SELECT table_name FROM create_hypertable('osm_ts','time'); psql:include/chunk_utils_internal_orderedappend.sql:21: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------ osm_ts SELECT table_name FROM create_hypertable('osm_tstz','time'); table_name ------------ osm_tstz CREATE FOREIGN TABLE osm_int2_fdw_child(time int2 NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_int4_fdw_child(time int4 NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_int8_fdw_child(time int8 NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_date_fdw_child(time date NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_ts_fdw_child(time timestamp NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_tstz_fdw_child(time timestamptz NOT NULL) SERVER s3_server; SELECT dt, _timescaledb_functions.attach_osm_table_chunk('osm_' || dt, 'osm_' || dt || '_fdw_child') FROM unnest('{int2,int4,int8,date,ts,tstz}'::text[]) u(dt); dt | attach_osm_table_chunk ------+------------------------ int2 | t int4 | t int8 | t date | t ts | t tstz | t SELECT ht.table_name, ds.* FROM _timescaledb_catalog.dimension_slice ds INNER JOIN _timescaledb_catalog.dimension d ON d.id=ds.dimension_id INNER JOIN _timescaledb_catalog.hypertable ht on ht.id=d.hypertable_id WHERE ht.table_name LIKE 'osm%' ORDER BY 2,3; table_name | id | dimension_id | range_start | range_end ------------+----+--------------+---------------------+--------------------- osm_int2 | 22 | 11 | 9223372036854775806 | 9223372036854775807 osm_int4 | 23 | 12 | 9223372036854775806 | 9223372036854775807 osm_int8 | 24 | 13 | 9223372036854775806 | 9223372036854775807 osm_date | 25 | 14 | 9223372036854775806 | 9223372036854775807 osm_ts | 26 | 15 | 9223372036854775806 | 9223372036854775807 osm_tstz | 27 | 16 | 9223372036854775806 | 9223372036854775807 -- test that correct slice is found and updated for table with multiple chunk constraints CREATE TABLE test_multicon(time timestamptz not null unique, a int); SELECT hypertable_id as htid FROM create_hypertable('test_multicon', 'time', chunk_time_interval => interval '1 day') \gset insert into test_multicon values ('2020-01-02 01:00'::timestamptz, 1); SELECT c.id, c.hypertable_id, c.schema_name, c.table_name, c.compressed_chunk_id, c.dropped, c.status, c.osm_chunk, cc.chunk_id, cc.dimension_slice_id, cc.constraint_name, cc.hypertable_constraint_name FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc WHERE c.hypertable_id = :htid AND c.id = cc.chunk_id; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk | chunk_id | dimension_slice_id | constraint_name | hypertable_constraint_name ----+---------------+-----------------------+--------------------+---------------------+---------+--------+-----------+----------+--------------------+-----------------------------+---------------------------- 31 | 19 | _timescaledb_internal | _hyper_19_31_chunk | | f | 0 | f | 31 | | 31_5_test_multicon_time_key | test_multicon_time_key 31 | 19 | _timescaledb_internal | _hyper_19_31_chunk | | f | 0 | f | 31 | 28 | constraint_28 | \c :TEST_DBNAME :ROLE_SUPERUSER ; UPDATE _timescaledb_catalog.chunk SET osm_chunk = true WHERE hypertable_id = :htid; \c :TEST_DBNAME :ROLE_4; SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', '2020-01-02 01:00'::timestamptz, '2020-01-04 01:00'); hypertable_osm_range_update ----------------------------- f -- view udpated range SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+--------------------+--------+-----------+--------------------+------------------+------------------ 31 | _hyper_19_31_chunk | 0 | t | 28 | 1577955600000000 | 1578128400000000 -- check that range was reset to default - infinity \set ON_ERROR_STOP 0 -- both range_start and range_end must be NULL, or non-NULL SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', NULL, '2020-01-04 01:00'::timestamptz); psql:include/chunk_utils_internal_orderedappend.sql:58: ERROR: range_start and range_end parameters must be both NULL or both non-NULL SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', NULL, NULL); psql:include/chunk_utils_internal_orderedappend.sql:59: ERROR: could not determine polymorphic type because input has type unknown SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon'); hypertable_osm_range_update ----------------------------- f \set ON_ERROR_STOP 1 SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', NULL::timestamptz, NULL); hypertable_osm_range_update ----------------------------- f SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+--------------------+--------+-----------+--------------------+---------------------+--------------------- 31 | _hyper_19_31_chunk | 0 | t | 28 | 9223372036854775806 | 9223372036854775807 -- TEST for orderedappend that depends on hypertable_osm_range_update functionality -- test further with ordered append \c postgres_fdw_db :ROLE_4; CREATE TABLE test_chunkapp_fdw (time timestamptz NOT NULL, a int); INSERT INTO test_chunkapp_fdw (time, a) VALUES ('2020-01-03 02:00'::timestamptz, 3); \c :TEST_DBNAME :ROLE_4 CREATE TABLE test_chunkapp(time timestamptz NOT NULL, a int); SELECT hypertable_id as htid FROM create_hypertable('test_chunkapp', 'time', chunk_time_interval => interval '1day') \gset INSERT INTO test_chunkapp (time, a) VALUES ('2020-01-01 01:00'::timestamptz, 1), ('2020-01-02 01:00'::timestamptz, 2); CREATE FOREIGN TABLE test_chunkapp_fdw_child(time timestamptz NOT NULL, a int) SERVER s3_server OPTIONS (schema_name 'public', table_name 'test_chunkapp_fdw');; SELECT _timescaledb_functions.attach_osm_table_chunk('test_chunkapp','test_chunkapp_fdw_child'); attach_osm_table_chunk ------------------------ t -- view range before update SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+-------------------------+--------+-----------+--------------------+---------------------+--------------------- 32 | _hyper_20_32_chunk | 0 | f | 29 | 1577836800000000 | 1577923200000000 33 | _hyper_20_33_chunk | 0 | f | 30 | 1577923200000000 | 1578009600000000 34 | test_chunkapp_fdw_child | 0 | t | 31 | 9223372036854775806 | 9223372036854775807 -- attempt to update overlapping range, should fail \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp', '2020-01-02 01:00'::timestamptz, '2020-01-04 01:00'); psql:include/chunk_utils_internal_orderedappend.sql:86: ERROR: attempting to set overlapping range for tiered chunk of public.test_chunkapp \set ON_ERROR_STOP 1 -- update actual range of OSM chunk, should work SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp', '2020-01-03 00:00'::timestamptz, '2020-01-04 00:00'); hypertable_osm_range_update ----------------------------- f -- view udpated range SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+-------------------------+--------+-----------+--------------------+------------------+------------------ 32 | _hyper_20_32_chunk | 0 | f | 29 | 1577836800000000 | 1577923200000000 33 | _hyper_20_33_chunk | 0 | f | 30 | 1577923200000000 | 1578009600000000 34 | test_chunkapp_fdw_child | 0 | t | 31 | 1578038400000000 | 1578124800000000 -- ordered append should be possible as ranges do not overlap :EXPLAIN SELECT * FROM test_chunkapp ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_chunkapp Order: test_chunkapp."time" -> Index Scan Backward using _hyper_20_32_chunk_test_chunkapp_time_idx on _hyper_20_32_chunk -> Index Scan Backward using _hyper_20_33_chunk_test_chunkapp_time_idx on _hyper_20_33_chunk -> Foreign Scan on test_chunkapp_fdw_child SELECT * FROM test_chunkapp ORDER BY 1; time | a ------------------------------+--- Wed Jan 01 01:00:00 2020 PST | 1 Thu Jan 02 01:00:00 2020 PST | 2 Fri Jan 03 02:00:00 2020 PST | 3 -- but, insert should not be possible SELECT ts_setup_osm_hook(); ts_setup_osm_hook ------------------- \set ON_ERROR_STOP 0 INSERT INTO test_chunkapp VALUES ('2020-01-03 02:00'::timestamptz, 3); psql:include/chunk_utils_internal_orderedappend.sql:100: ERROR: Cannot insert into tiered chunk range of public.test_chunkapp - attempt to create new chunk with range [Fri Jan 03 00:00:00 2020 PST Sat Jan 04 00:00:00 2020 PST] failed \set ON_ERROR_STOP 1 SELECT ts_undo_osm_hook(); ts_undo_osm_hook ------------------ -- reset range to infinity SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp',empty:=false); hypertable_osm_range_update ----------------------------- f -- ordered append not possible because range is invalid and empty was not specified :EXPLAIN SELECT * FROM test_chunkapp ORDER BY 1; --- QUERY PLAN --- Merge Append Sort Key: test_chunkapp."time" -> Index Scan Backward using _hyper_20_32_chunk_test_chunkapp_time_idx on _hyper_20_32_chunk -> Index Scan Backward using _hyper_20_33_chunk_test_chunkapp_time_idx on _hyper_20_33_chunk -> Foreign Scan on test_chunkapp_fdw_child SELECT * FROM test_chunkapp ORDER BY 1; time | a ------------------------------+--- Wed Jan 01 01:00:00 2020 PST | 1 Thu Jan 02 01:00:00 2020 PST | 2 Fri Jan 03 02:00:00 2020 PST | 3 SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; chunk_id | table_name | status | osm_chunk | dimension_slice_id | range_start | range_end ----------+-------------------------+--------+-----------+--------------------+---------------------+--------------------- 32 | _hyper_20_32_chunk | 0 | f | 29 | 1577836800000000 | 1577923200000000 33 | _hyper_20_33_chunk | 0 | f | 30 | 1577923200000000 | 1578009600000000 34 | test_chunkapp_fdw_child | 0 | t | 31 | 9223372036854775806 | 9223372036854775807 -- but also, OSM chunk should be included in the scan, since range is invalid and chunk is not empty :EXPLAIN SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; --- QUERY PLAN --- Merge Append Sort Key: test_chunkapp."time" -> Index Scan Backward using _hyper_20_32_chunk_test_chunkapp_time_idx on _hyper_20_32_chunk Index Cond: ("time" < 'Sun Jan 01 00:00:00 2023 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_20_33_chunk_test_chunkapp_time_idx on _hyper_20_33_chunk Index Cond: ("time" < 'Sun Jan 01 00:00:00 2023 PST'::timestamp with time zone) -> Foreign Scan on test_chunkapp_fdw_child SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; time | a ------------------------------+--- Wed Jan 01 01:00:00 2020 PST | 1 Thu Jan 02 01:00:00 2020 PST | 2 Fri Jan 03 02:00:00 2020 PST | 3 -- now set empty to true, should ordered append \c postgres_fdw_db :ROLE_4; DELETE FROM test_chunkapp_fdw; \c :TEST_DBNAME :ROLE_4; SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp', NULL::timestamptz, NULL, empty => true); hypertable_osm_range_update ----------------------------- f :EXPLAIN SELECT * FROM test_chunkapp ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_chunkapp Order: test_chunkapp."time" -> Index Scan Backward using _hyper_20_32_chunk_test_chunkapp_time_idx on _hyper_20_32_chunk -> Index Scan Backward using _hyper_20_33_chunk_test_chunkapp_time_idx on _hyper_20_33_chunk -> Foreign Scan on test_chunkapp_fdw_child SELECT * FROM test_chunkapp ORDER BY 1; time | a ------------------------------+--- Wed Jan 01 01:00:00 2020 PST | 1 Thu Jan 02 01:00:00 2020 PST | 2 -- should exclude the OSM chunk this time since it is empty :EXPLAIN SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_chunkapp Order: test_chunkapp."time" -> Index Scan Backward using _hyper_20_32_chunk_test_chunkapp_time_idx on _hyper_20_32_chunk Index Cond: ("time" < 'Sun Jan 01 00:00:00 2023 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_20_33_chunk_test_chunkapp_time_idx on _hyper_20_33_chunk Index Cond: ("time" < 'Sun Jan 01 00:00:00 2023 PST'::timestamp with time zone) SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; time | a ------------------------------+--- Wed Jan 01 01:00:00 2020 PST | 1 Thu Jan 02 01:00:00 2020 PST | 2 \set ON_ERROR_STOP 0 -- test adding constraint directly on OSM chunk is blocked ALTER TABLE test_chunkapp_fdw_child ADD CHECK (a > 0); -- non-dimensional psql:include/chunk_utils_internal_orderedappend.sql:127: ERROR: operation not supported on OSM chunk tables ALTER TABLE test_chunkapp_fdw_child ADD CHECK (time > '1600-01-01'::timestamptz); -- dimensional psql:include/chunk_utils_internal_orderedappend.sql:128: ERROR: operation not supported on OSM chunk tables -- but on hypertable, it is allowed ALTER TABLE test_chunkapp ADD CHECK (a > 0); SELECT * FROM test.show_constraints('test_chunkapp_fdw_child'); Constraint | Type | Columns | Index | Expr | Deferrable | Deferred | Validated -----------------------+------+---------+-------+---------+------------+----------+----------- test_chunkapp_a_check | c | {a} | - | (a > 0) | f | f | t \set ON_ERROR_STOP 1 -- test error is triggered when time dimension not found CREATE TABLE test2(time timestamptz not null, a int); SELECT create_hypertable('test2', 'time'); create_hypertable --------------------- (21,public,test2,t) INSERT INTO test2 VALUES ('2020-01-01'::timestamptz, 1); ALTER TABLE test2 SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_21_35_chunk -- find internal compression table, call API function on it SELECT format('%I.%I', cht.schema_name, cht.table_name) AS "COMPRESSION_TBLNM" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.hypertable cht WHERE ht.table_name = 'test2' and cht.id = ht.compressed_hypertable_id \gset \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update(:'COMPRESSION_TBLNM'::regclass, '2020-01-01'::timestamptz); psql:include/chunk_utils_internal_orderedappend.sql:145: ERROR: could not find time dimension for hypertable _timescaledb_internal._compressed_hypertable_22 \set ON_ERROR_STOP 1 -- test wrong/incompatible data types with hypertable time dimension -- update range of int2 with int4 \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update('osm_int2', range_start => 65540::int4, range_end => 100000::int4); psql:include/chunk_utils_internal_orderedappend.sql:151: ERROR: invalid time argument type "integer" -- update range of int8 with int4 SELECT _timescaledb_functions.hypertable_osm_range_update('osm_int8', 120, 150); hypertable_osm_range_update ----------------------------- f -- update range of timestamptz with date SELECT _timescaledb_functions.hypertable_osm_range_update('osm_tstz', '2020-01-01'::date, '2020-01-03'::date); hypertable_osm_range_update ----------------------------- f -- udpate range of timestamp with bigint SELECT _timescaledb_functions.hypertable_osm_range_update('osm_tstz', 9223372036854771806, 9223372036854775406); psql:include/chunk_utils_internal_orderedappend.sql:157: ERROR: invalid time argument type "bigint" \set ON_ERROR_STOP 1 -- test dimension slice tuple visibility \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE osm_slice_update(time int not null); SELECT hypertable_id AS ht_id FROM create_hypertable('osm_slice_update', 'time', chunk_time_interval => 10) \gset INSERT INTO osm_slice_update VALUES (1); UPDATE _timescaledb_catalog.hypertable SET status = 3 WHERE id = :ht_id; UPDATE _timescaledb_catalog.chunk SET osm_chunk = true WHERE hypertable_id = :ht_id; \c BEGIN; SELECT _timescaledb_functions.hypertable_osm_range_update('osm_slice_update',40,50); hypertable_osm_range_update ----------------------------- f ROLLBACK; \c -- new session should not be affected by previous rolled back transaction -- should show 0 10 as range \set ON_ERROR_STOP 0 INSERT INTO osm_slice_update VALUES (1); psql:include/chunk_utils_internal_orderedappend.sql:178: ERROR: Cannot insert into tiered chunk range of public.osm_slice_update - attempt to create new chunk with range [0 10] failed INSERT INTO osm_slice_update VALUES (1); psql:include/chunk_utils_internal_orderedappend.sql:179: ERROR: Cannot insert into tiered chunk range of public.osm_slice_update - attempt to create new chunk with range [0 10] failed \set ON_ERROR_STOP 1 --TEST hypertable with foreign key into it \c :TEST_DBNAME :ROLE_4 CREATE TABLE hyper_fk(ts timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('hyper_fk', 'ts'); table_name ------------ hyper_fk INSERT INTO hyper_fk(ts, device, value) VALUES ('2020-01-01 00:00:00+00', 'd1', 1.0); \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_hyper_fk(ts timestamptz NOT NULL, device text, value float); INSERT INTO fdw_hyper_fk VALUES( '2021-05-05 00:00:00+00', 'd2', 2.0); \c :TEST_DBNAME :ROLE_4 -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_hyper_fk (ts timestamptz NOT NULL, device text, value float) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_hyper_fk'); SELECT _timescaledb_functions.attach_osm_table_chunk('hyper_fk', 'child_hyper_fk'); attach_osm_table_chunk ------------------------ t --create table with fk into hypertable CREATE TABLE event(ts timestamptz REFERENCES hyper_fk(ts) , info text); -- NOTE: current behavior is to allow inserts/deletes from PG tables when data -- references OSM table. --insert referencing OSM chunk INSERT INTO event VALUES( '2021-05-05 00:00:00+00' , 'osm_chunk_ts'); --insert referencing non-existent value \set ON_ERROR_STOP 0 INSERT INTO event VALUES( '2020-01-02 00:00:00+00' , 'does_not_exist_ts'); ERROR: insert or update on table "event" violates foreign key constraint "event_ts_fkey" \set ON_ERROR_STOP 1 INSERT INTO event VALUES( '2020-01-01 00:00:00+00' , 'chunk_ts'); SELECT * FROM event ORDER BY ts; ts | info ------------------------------+-------------- Tue Dec 31 16:00:00 2019 PST | chunk_ts Tue May 04 17:00:00 2021 PDT | osm_chunk_ts DELETE FROM event WHERE info = 'osm_chunk_ts'; DELETE FROM event WHERE info = 'chunk_ts'; SELECT * FROM event ORDER BY ts; ts | info ----+------ -- event triggers on chunk creation CREATE TABLE ht_try(timec timestamptz NOT NULL, acq_id bigint, value bigint); SELECT create_hypertable('ht_try', 'timec', chunk_time_interval => interval '1 day'); create_hypertable ---------------------- (25,public,ht_try,t) -- creating event triggers requires superuser permissions \c :TEST_DBNAME :ROLE_SUPERUSER -- event trigger on ddl_start CREATE OR REPLACE FUNCTION ddl_start_trigger_func() RETURNS EVENT_TRIGGER AS $$ BEGIN RAISE NOTICE 'ddl_start_trigger_func() is invoked'; END; $$ LANGUAGE plpgsql; CREATE EVENT TRIGGER ddl_start_trigger ON ddl_command_start WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION ddl_start_trigger_func(); -- event trigger on ddl_end CREATE OR REPLACE FUNCTION ddl_end_trigger_func() RETURNS EVENT_TRIGGER AS $$ DECLARE cmd RECORD; BEGIN RAISE NOTICE 'ddl_end_trigger_func() is invoked'; FOR cmd IN SELECT * FROM pg_event_trigger_ddl_commands() LOOP RAISE NOTICE 'tag: %, object: %', cmd.command_tag, cmd.object_identity::regclass; END LOOP; END; $$ LANGUAGE plpgsql; CREATE EVENT TRIGGER ddl_end_trigger ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION ddl_end_trigger_func(); -- by default event triggers on chunk creation are disabled INSERT INTO ht_try VALUES ('2025-05-01 00:00', 1, 10); SET timescaledb.enable_event_triggers = on; INSERT INTO ht_try VALUES ('2025-05-02 00:00', 1, 10); NOTICE: ddl_start_trigger_func() is invoked NOTICE: ddl_end_trigger_func() is invoked NOTICE: tag: CREATE TABLE, object: _timescaledb_internal._hyper_25_41_chunk RESET timescaledb.enable_event_triggers; DROP EVENT TRIGGER ddl_start_trigger; DROP EVENT TRIGGER ddl_end_trigger; DROP TABLE ht_try; --TEST ALTER TABLE propagation with foreign chunks \c :TEST_DBNAME :ROLE_4 CREATE TABLE ht_alter(ts timestamptz) WITH (tsdb.hypertable,tsdb.compress=false); NOTICE: using column "ts" as partitioning column INSERT INTO ht_alter SELECT '2025-01-01'; \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_ht_alter(ts timestamptz NOT NULL, device text, value float); INSERT INTO fdw_ht_alter SELECT '2021-05-05'; \c :TEST_DBNAME :ROLE_4 -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_ht_alter(ts timestamptz NOT NULL) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_ht_alter'); SELECT _timescaledb_functions.attach_osm_table_chunk('ht_alter', 'child_ht_alter'); attach_osm_table_chunk ------------------------ t ALTER TABLE ht_alter SET (autovacuum_enabled = false); ALTER TABLE ht_alter RESET (autovacuum_enabled); -- test DML blocker on frozen chunks CREATE TABLE dml_blocks (time timestamptz, device text, value float) WITH (tsdb.hypertable, tsdb.segmentby='device'); NOTICE: using column "time" as partitioning column -- DML on hypertable before freezing should work INSERT INTO dml_blocks VALUES ('2025-01-01','dev1',1.0); BEGIN; UPDATE dml_blocks SET value = 2.0 WHERE device = 'dev1'; DELETE FROM dml_blocks WHERE device = 'dev2'; COPY dml_blocks FROM STDIN; ROLLBACK; SELECT show_chunks('dml_blocks') AS "CHUNK" \gset -- DML on chunk before freezing should work BEGIN; INSERT INTO :CHUNK VALUES ('2025-01-01','dev1',1.0); UPDATE :CHUNK SET value = 2.0 WHERE device = 'dev1'; DELETE FROM :CHUNK WHERE device = 'dev2'; COPY :CHUNK FROM STDIN; ROLLBACK; SELECT _timescaledb_functions.freeze_chunk(:'CHUNK'); freeze_chunk -------------- t -- DML on hypertable after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO dml_blocks VALUES ('2025-01-01','dev1',1.0); ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" UPDATE dml_blocks SET value = 2.0 WHERE device = 'dev1'; ERROR: cannot update/delete rows from chunk "_hyper_27_44_chunk" as it is frozen DELETE FROM dml_blocks WHERE device = 'dev2'; ERROR: cannot update/delete rows from chunk "_hyper_27_44_chunk" as it is frozen COPY dml_blocks FROM STDIN; ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" \set ON_ERROR_STOP 1 -- DML on chunk after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2025-01-01','dev1',1.0); ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" UPDATE :CHUNK SET value = 2.0 WHERE device = 'dev1'; ERROR: cannot update/delete rows from chunk "_hyper_27_44_chunk" as it is frozen DELETE FROM :CHUNK WHERE device = 'dev2'; ERROR: cannot update/delete rows from chunk "_hyper_27_44_chunk" as it is frozen COPY :CHUNK FROM STDIN; ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" \set ON_ERROR_STOP 1 -- repeat tests with compressed chunk SELECT _timescaledb_functions.unfreeze_chunk(:'CHUNK'); unfreeze_chunk ---------------- t SELECT compress_chunk(:'CHUNK'); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_27_44_chunk SELECT _timescaledb_functions.freeze_chunk(:'CHUNK'); freeze_chunk -------------- t SELECT format('%I.%I', schema_name, table_name) AS "COMPRESSED_CHUNK" FROM _timescaledb_catalog.chunk ORDER BY id DESC LIMIT 1 \gset -- DML on hypertable after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO dml_blocks VALUES ('2025-01-01','dev1',1.0); ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" UPDATE dml_blocks SET value = 2.0 WHERE device = 'dev1'; ERROR: cannot modify frozen chunk status DELETE FROM dml_blocks WHERE device = 'dev2'; ERROR: cannot update/delete rows from chunk "_hyper_27_44_chunk" as it is frozen COPY dml_blocks FROM STDIN; ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" \set ON_ERROR_STOP 1 -- DML on chunk after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2025-01-01','dev1',1.0); ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" UPDATE :CHUNK SET value = 2.0 WHERE device = 'dev1'; ERROR: cannot modify frozen chunk status DELETE FROM :CHUNK WHERE device = 'dev2'; ERROR: cannot update/delete rows from chunk "_hyper_27_44_chunk" as it is frozen COPY :CHUNK FROM STDIN; ERROR: cannot INSERT into frozen chunk "_hyper_27_44_chunk" \set ON_ERROR_STOP 1 -- DML on chunk after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO :COMPRESSED_CHUNK SELECT; ERROR: cannot modify compressed chunk belonging to a frozen chunk UPDATE :COMPRESSED_CHUNK SET device = 'dev3' WHERE device = 'dev1'; ERROR: cannot modify compressed chunk belonging to a frozen chunk DELETE FROM :COMPRESSED_CHUNK WHERE device = 'dev1'; ERROR: cannot modify compressed chunk belonging to a frozen chunk COPY :COMPRESSED_CHUNK FROM STDIN; ERROR: cannot COPY into chunk belonging to a frozen chunk \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER -- clean up databases created DROP DATABASE postgres_fdw_db WITH (FORCE); ������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/columnar_scan_cost.out�����������������������������������������0000664�0000000�0000000�00000034027�15100345067�0024050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Some primitive tests that show cost of DecompressChunk node so that we can -- monitor the changes. create table costtab(ts int, s text, c text, ti text, fi float); select create_hypertable('costtab', 'ts'); create_hypertable ---------------------- (1,public,costtab,t) alter table costtab set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into costtab select ts, ts % 10, ts::text, ts::text, ts::float from generate_series(1, 10000) ts; create index on costtab(ti); create index on costtab(fi); select count(compress_chunk(x)) from show_chunks('costtab') x; count ------- 1 vacuum freeze analyze costtab; explain (buffers off) select * from costtab; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.10 rows=10000 width=108) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.10 rows=10 width=142) explain (buffers off) select * from costtab where s = '1'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=1.12..11.12 rows=1000 width=108) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.12 rows=1 width=142) Filter: (s = '1'::text) explain (buffers off) select * from costtab where c = '100'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.10 rows=10000 width=108) Vectorized Filter: (c = '100'::text) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.10 rows=10 width=142) explain (buffers off) select * from costtab where ti = '200'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.38..31.12 rows=3000 width=108) Vectorized Filter: (ti = '200'::text) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.12 rows=3 width=142) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_ti, '200'::text) explain (buffers off) select * from costtab where fi = 200; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.15 rows=10000 width=108) Vectorized Filter: (fi = '200'::double precision) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.15 rows=10 width=142) Filter: ((_ts_meta_v2_min_fi <= '200'::double precision) AND (_ts_meta_v2_max_fi >= '200'::double precision)) explain (buffers off) select ts from costtab; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.10 rows=10000 width=4) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.10 rows=10 width=44) explain (buffers off) select ts from costtab where s = '1'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=1.12..11.12 rows=1000 width=4) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.12 rows=1 width=46) Filter: (s = '1'::text) explain (buffers off) select ts from costtab where c = '100'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.10 rows=10000 width=4) Vectorized Filter: (c = '100'::text) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.10 rows=10 width=76) explain (buffers off) select ts, s from costtab; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.10 rows=10000 width=36) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.10 rows=10 width=46) explain (buffers off) select ts, s from costtab where s = '1'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=1.12..11.12 rows=1000 width=36) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.12 rows=1 width=46) Filter: (s = '1'::text) explain (buffers off) select ts, s from costtab where c = '100'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=0.11..101.10 rows=10000 width=36) Vectorized Filter: (c = '100'::text) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.10 rows=10 width=78) explain (buffers off) select * from costtab where ts = 5000; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=1.15..11.15 rows=1000 width=108) Vectorized Filter: (ts = 5000) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.15 rows=1 width=142) Filter: ((_ts_meta_min_1 <= 5000) AND (_ts_meta_max_1 >= 5000)) explain (buffers off) select * from costtab where fi = 200 and ts = 5000; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=1.20..11.20 rows=1000 width=108) Vectorized Filter: ((fi = '200'::double precision) AND (ts = 5000)) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.20 rows=1 width=142) Filter: ((_ts_meta_v2_min_fi <= '200'::double precision) AND (_ts_meta_v2_max_fi >= '200'::double precision) AND (_ts_meta_min_1 <= 5000) AND (_ts_meta_max_1 >= 5000)) explain (buffers off) select * from costtab where s = '1' or (fi = 200 and ts = 5000); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (cost=1.23..11.22 rows=1000 width=108) Filter: ((s = '1'::text) OR ((fi = '200'::double precision) AND (ts = 5000))) -> Seq Scan on compress_hyper_2_2_chunk (cost=0.00..1.23 rows=1 width=142) Filter: ((s = '1'::text) OR ((_ts_meta_v2_min_fi <= '200'::double precision) AND (_ts_meta_v2_max_fi >= '200'::double precision) AND (_ts_meta_min_1 <= 5000) AND (_ts_meta_max_1 >= 5000))) -- Test estimation of compressed batch size using the _ts_meta_count stats. create table estimate_count(time timestamptz, device int, value float); select create_hypertable('estimate_count','time'); create_hypertable ----------------------------- (3,public,estimate_count,t) alter table estimate_count set (timescaledb.compress, timescaledb.compress_segmentby = 'device', timescaledb.compress_orderby = 'time'); -- same batch sizes insert into estimate_count select t, d, 1 from generate_series('2025-01-01'::timestamptz,'2025-01-03','15 min') t, generate_series(1, 1000) d ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; count ------- 2 vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; --- QUERY PLAN --- Append (cost=0.04..2974.00 rows=193000 width=20) (actual rows=193000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_3_chunk (cost=0.04..679.00 rows=64000 width=20) (actual rows=64000.00 loops=1) -> Seq Scan on compress_hyper_4_5_chunk (cost=0.00..39.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_4_chunk (cost=0.04..1330.00 rows=129000 width=20) (actual rows=129000.00 loops=1) -> Seq Scan on compress_hyper_4_6_chunk (cost=0.00..40.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -- different batch sizes truncate estimate_count; insert into estimate_count select t, d, 2 from generate_series(1, 1000) d, lateral generate_series('2025-01-01'::timestamptz,'2025-01-03', interval '15 min' * (d % 10 + 1)) t ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; count ------- 2 vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; --- QUERY PLAN --- Append (cost=0.04..934.50 rows=57100 width=20) (actual rows=57100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (cost=0.04..230.00 rows=19100 width=20) (actual rows=19100.00 loops=1) -> Seq Scan on compress_hyper_4_9_chunk (cost=0.00..39.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (cost=0.04..419.00 rows=38000 width=20) (actual rows=38000.00 loops=1) -> Seq Scan on compress_hyper_4_10_chunk (cost=0.00..39.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -- more different batch sizes truncate estimate_count; insert into estimate_count select t, d, 2 from generate_series(1, 1000) d, lateral generate_series('2025-01-01'::timestamptz,'2025-01-03', interval '15 min' + interval '1 minute' * d) t ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; count ------- 2 vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; --- QUERY PLAN --- Append (cost=0.04..265.21 rows=12548 width=20) (actual rows=12559.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (cost=0.04..83.50 rows=4550 width=20) (actual rows=4553.00 loops=1) -> Seq Scan on compress_hyper_4_13_chunk (cost=0.00..38.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_12_chunk (cost=0.04..118.97 rows=7997 width=20) (actual rows=8006.00 loops=1) -> Seq Scan on compress_hyper_4_14_chunk (cost=0.00..39.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -- more different + one very frequent truncate estimate_count; insert into estimate_count select t, d, 2 from generate_series(1, 1000) d, lateral generate_series('2025-01-01'::timestamptz,'2025-01-03', case when d % 2 = 0 then interval '10 min' else interval '15 min' + interval '1 minute' * d end) t ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; count ------- 2 vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; --- QUERY PLAN --- Append (cost=0.04..2340.10 rows=150807 width=20) (actual rows=150830.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (cost=0.04..541.81 rows=50281 width=20) (actual rows=50287.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (cost=0.00..39.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_16_chunk (cost=0.04..1044.26 rows=100526 width=20) (actual rows=100543.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (cost=0.00..39.00 rows=1000 width=88) (actual rows=1000.00 loops=1) -- single row. Postgres generates all-zero entry in pg_statistics in this case, -- but we want to avoid zero row counts. truncate estimate_count; insert into estimate_count select '2025-01-01', 1, 2 ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; count ------- 1 vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_19_chunk (cost=1.01..11.01 rows=1000 width=20) (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_4_20_chunk (cost=0.00..1.01 rows=1 width=88) (actual rows=1.00 loops=1) -- no statistics truncate estimate_count; vacuum analyze estimate_count; insert into estimate_count select t, d, 1 from generate_series('2025-01-01'::timestamptz,'2025-01-03','15 min') t, generate_series(1, 1000) d ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; count ------- 2 explain (analyze, timing off, summary off, buffers off) select * from estimate_count; --- QUERY PLAN --- Append (cost=0.02..67308.80 rows=4480000 width=20) (actual rows=193000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_21_chunk (cost=0.02..22454.40 rows=2240000 width=20) (actual rows=64000.00 loops=1) -> Seq Scan on compress_hyper_4_23_chunk (cost=0.00..54.40 rows=2240 width=88) (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_22_chunk (cost=0.02..22454.40 rows=2240000 width=20) (actual rows=129000.00 loops=1) -> Seq Scan on compress_hyper_4_24_chunk (cost=0.00..54.40 rows=2240 width=88) (actual rows=1000.00 loops=1) -- Test a high-cardinality orderby column create table highcard(ts int) with (tsdb.hypertable, tsdb.partition_column = 'ts', tsdb.compress_orderby = 'ts', tsdb.chunk_interval = 10000000); insert into highcard select generate_series(1, 1000000); select count(compress_chunk(x)) from show_chunks('highcard') x; count ------- 1 vacuum freeze analyze highcard; explain (buffers off, analyze, timing off, summary off) select * from highcard where ts > 200000 and ts < 300000; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_25_chunk (cost=0.43..1005.58 rows=99000 width=4) (actual rows=99999.00 loops=1) Vectorized Filter: ((ts > 200000) AND (ts < 300000)) Rows Removed by Filter: 1 -> Index Scan using compress_hyper_6_26_chunk__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_26_chunk (cost=0.28..15.58 rows=99 width=44) (actual rows=100.00 loops=1) Index Cond: ((_ts_meta_min_1 < 300000) AND (_ts_meta_max_1 > 200000)) explain (buffers off, analyze, timing off, summary off) select * from highcard where ts = 500000; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_25_chunk (cost=18.70..28.70 rows=1000 width=4) (actual rows=1.00 loops=1) Vectorized Filter: (ts = 500000) Rows Removed by Filter: 999 -> Index Scan using compress_hyper_6_26_chunk__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_26_chunk (cost=0.28..18.70 rows=1 width=44) (actual rows=1.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 500000) AND (_ts_meta_max_1 >= 500000)) explain (buffers off, analyze, timing off, summary off) select * from highcard where ts < 500000; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_25_chunk (cost=0.32..5001.61 rows=498000 width=4) (actual rows=499999.00 loops=1) Vectorized Filter: (ts < 500000) Rows Removed by Filter: 1 -> Index Scan using compress_hyper_6_26_chunk__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_26_chunk (cost=0.28..21.61 rows=498 width=44) (actual rows=500.00 loops=1) Index Cond: (_ts_meta_min_1 < 500000) explain (buffers off, analyze, timing off, summary off) select * from highcard where ts > 500000; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_25_chunk (cost=0.05..5035.50 rows=501000 width=4) (actual rows=500000.00 loops=1) Vectorized Filter: (ts > 500000) -> Seq Scan on compress_hyper_6_26_chunk (cost=0.00..25.50 rows=501 width=44) (actual rows=500.00 loops=1) Filter: (_ts_meta_max_1 > 500000) Rows Removed by Filter: 500 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/columnstore_aliases.out����������������������������������������0000664�0000000�0000000�00000013341�15100345067�0024243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE PROCEDURE convert_hypertable_to_columnstore(regclass) LANGUAGE plpgsql AS $$ DECLARE chunk REGCLASS; BEGIN FOR chunk IN SELECT show_chunks($1) LOOP CALL convert_to_columnstore(chunk); END LOOP; END $$; CREATE PROCEDURE convert_hypertable_to_rowstore(regclass) LANGUAGE plpgsql AS $$ DECLARE chunk REGCLASS; BEGIN FOR chunk IN SELECT show_chunks($1) LOOP CALL convert_to_rowstore(chunk); END LOOP; END $$; -- These are mostly taken from compression_ddl.sql and are only -- intended to check that aliases work. In that sense, the actual -- result of each query is not particularly important. CREATE TABLE test1 (ts timestamptz, i integer, b bigint, t text); SELECT * FROM create_hypertable('test1', 'ts'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | test1 | t INSERT INTO test1 SELECT t, random(), random(), random()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test1 set ( timescaledb.enable_columnstore, timescaledb.segmentby = 'b', timescaledb.orderby = 'ts desc' ); CALL convert_hypertable_to_columnstore('test1'); CALL convert_hypertable_to_rowstore('test1'); CALL convert_hypertable_to_columnstore('test1'); -- Pick one chunk to play with and test option names. We mostly use -- default since we are only interested in that the option names are -- accepted. SELECT chunk FROM show_chunks('test1') tbl(chunk) LIMIT 1 \gset CALL convert_to_rowstore(:'chunk', if_columnstore => true); CALL convert_to_columnstore(:'chunk', if_not_columnstore => true, recompress => false); CALL add_columnstore_policy('test1', interval '1 day'); CALL remove_columnstore_policy('test1'); SELECT * FROM timescaledb_information.hypertable_columnstore_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- test1 | b | ts DESC | | SELECT * FROM timescaledb_information.chunk_columnstore_settings ORDER BY chunk; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+---------+----------------------------------------------------------- test1 | _timescaledb_internal._hyper_1_1_chunk | b | ts DESC | [{"type": "minmax", "column": "ts", "source": "orderby"}] test1 | _timescaledb_internal._hyper_1_2_chunk | b | ts DESC | [{"type": "minmax", "column": "ts", "source": "orderby"}] test1 | _timescaledb_internal._hyper_1_3_chunk | b | ts DESC | [{"type": "minmax", "column": "ts", "source": "orderby"}] test1 | _timescaledb_internal._hyper_1_4_chunk | b | ts DESC | [{"type": "minmax", "column": "ts", "source": "orderby"}] VACUUM FULL test1; -- We only care about the column names for the result. They should be -- the same as for the original function. SELECT * FROM chunk_columnstore_stats('test1') where 1 = 2 order by chunk_name; chunk_schema | chunk_name | compression_status | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+------------+--------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- SELECT * FROM hypertable_columnstore_stats('test1') where 1 = 2; total_chunks | number_compressed_chunks | before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name --------------+--------------------------+--------------------------------+--------------------------------+--------------------------------+--------------------------------+-------------------------------+-------------------------------+-------------------------------+-------------------------------+----------- CREATE TABLE test2 (ts timestamptz, i integer, b bigint, t text); SELECT * FROM create_hypertable('test2', 'ts'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 3 | public | test2 | t INSERT INTO test2 SELECT t, random(), random(), random()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test2 set ( timescaledb.columnstore, timescaledb.segmentby = 'b', timescaledb.orderby = 'ts desc' ); SELECT * FROM timescaledb_information.hypertables WHERE hypertable_name = 'test2'; hypertable_schema | hypertable_name | owner | num_dimensions | num_chunks | compression_enabled | tablespaces | primary_dimension | primary_dimension_type -------------------+-----------------+-------------------+----------------+------------+---------------------+-------------+-------------------+-------------------------- public | test2 | default_perm_user | 1 | 4 | t | | ts | timestamp with time zone �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_auto_sparse_index.out���������������������������������0000664�0000000�0000000�00000011660�15100345067�0025621�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. create table sparse(ts int, value float); select create_hypertable('sparse', 'ts'); create_hypertable --------------------- (1,public,sparse,t) insert into sparse select x, x from generate_series(1, 10000) x; alter table sparse set (timescaledb.compress, timescaledb.order_by='ts desc'); -- When the chunks are compressed, minmax metadata are created for columns that -- have btree indexes. create index ii on sparse(value); select count(compress_chunk(x)) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_2_chunk Filter: ((_ts_meta_v2_min_value <= '1'::double precision) AND (_ts_meta_v2_max_value >= '1'::double precision)) -- Should be disabled with the GUC set timescaledb.auto_sparse_indexes to off; select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_3_chunk reset timescaledb.auto_sparse_indexes; select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_4_chunk Filter: ((_ts_meta_v2_min_value <= '1'::double precision) AND (_ts_meta_v2_max_value >= '1'::double precision)) -- Should survive renames. alter table sparse rename column value to wert; explain (buffers off, costs off) select * from sparse where wert = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (wert = '1'::double precision) -> Seq Scan on compress_hyper_2_4_chunk Filter: ((_ts_meta_v2_min_wert <= '1'::double precision) AND (_ts_meta_v2_max_wert >= '1'::double precision)) alter table sparse rename column wert to value; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_4_chunk Filter: ((_ts_meta_v2_min_value <= '1'::double precision) AND (_ts_meta_v2_max_value >= '1'::double precision)) -- Not for expression indexes. drop index ii; create index ii on sparse((value + 1)); select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_5_chunk -- Not for other index types. drop index ii; create index ii on sparse using hash(value); select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_6_chunk Filter: ((_ts_meta_v2_min_value <= '1'::double precision) AND (_ts_meta_v2_max_value >= '1'::double precision)) -- When the chunk is recompressed without index, no sparse index is created. drop index ii; select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (value = '1'::double precision) -> Seq Scan on compress_hyper_2_7_chunk -- Long column names. select count(decompress_chunk(x)) from show_chunks('sparse') x; count ------- 1 \set ECHO none select count(compress_chunk(x)) from show_chunks('sparse') x; count ------- 1 vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where Abcdef012345678_Bbcdef012345678_Cbcdef012345678_Dbcdef0 = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (abcdef012345678_bbcdef012345678_cbcdef012345678_dbcdef0 = 1) -> Seq Scan on compress_hyper_2_8_chunk Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_9218_abcdef012345678_bbcdef012345678_cbcdef0, 1) ��������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_bgw_reorder_drop_chunks.out���������������������������0000664�0000000�0000000�00000027575�15100345067�0027021�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT * FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ts_bgw_params_create ---------------------- ----------------------------------- -- test retention policy runs for compressed hypertables -- ----------------------------------- CREATE TABLE test_retention_table(time timestamptz, drop_order int); SELECT create_hypertable('test_retention_table', 'time', chunk_time_interval => INTERVAL '1 week'); create_hypertable ----------------------------------- (1,public,test_retention_table,t) -- These inserts should create 5 different chunks INSERT INTO test_retention_table VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_retention_table VALUES (now(), 5); INSERT INTO test_retention_table VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_retention_table VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_retention_table VALUES (now() - INTERVAL '8 months', 1); SELECT show_chunks('test_retention_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_retention_table'; count ------- 5 SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; count ------- 0 SELECT add_retention_policy('test_retention_table', INTERVAL '4 months') as retention_job_id \gset SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; count ------- 1 SELECT alter_job(:retention_job_id, schedule_interval => INTERVAL '1 second'); alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1000,"@ 1 sec","@ 5 mins",-1,"@ 5 mins",t,"{""drop_after"": ""@ 4 mons"", ""hypertable_id"": 1}",-infinity,_timescaledb_functions.policy_retention_check,f,,,"Retention Policy [1000]") SELECT * FROM _timescaledb_config.bgw_job where id=:retention_job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+------------------------------------------------+------------------------+------------------------+---------- 1000 | Retention Policy [1000] | @ 1 sec | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 1 | {"drop_after": "@ 4 mons", "hypertable_id": 1} | _timescaledb_functions | policy_retention_check | --turn on compression and compress all chunks ALTER TABLE test_retention_table set (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test_retention_table') ch; count ------- 5 --make sure same # of compressed and uncompressed chunks before policy SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test_retention_table'; count_chunks_uncompressed --------------------------- 5 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test_retention_table'; count_chunks_compressed ------------------------- 5 SELECT show_chunks('test_retention_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000000); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT show_chunks('test_retention_table'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_4_chunk --make sure same # of compressed and uncompressed chunks after policy, reduced by 2 SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test_retention_table'; count_chunks_uncompressed --------------------------- 3 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test_retention_table'; count_chunks_compressed ------------------------- 3 ------------------------------ -- Test reorder policy runs on compressed tables. Reorder policy job must skip compressed chunks -- (see issue https://github.com/timescale/timescaledb/issues/1810). -- More tests for reorder policy can be found at bgw_reorder_drop_chunks.sql ------------------------------ CREATE TABLE test_reorder_chunks_table(time int not null, chunk_id int); CREATE INDEX test_reorder_chunks_table_time_idx ON test_reorder_chunks_table(time); SELECT create_hypertable('test_reorder_chunks_table', 'time', chunk_time_interval => 1); create_hypertable ---------------------------------------- (3,public,test_reorder_chunks_table,t) -- These inserts should create 6 different chunks INSERT INTO test_reorder_chunks_table VALUES (1, 1); INSERT INTO test_reorder_chunks_table VALUES (2, 2); INSERT INTO test_reorder_chunks_table VALUES (3, 3); INSERT INTO test_reorder_chunks_table VALUES (4, 4); INSERT INTO test_reorder_chunks_table VALUES (5, 5); INSERT INTO test_reorder_chunks_table VALUES (6, 6); -- Enable compression ALTER TABLE test_reorder_chunks_table set (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); -- Compress 2 chunks: SELECT compress_chunk(show_chunks('test_reorder_chunks_table', newer_than => 2, older_than => 4)); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_12_chunk _timescaledb_internal._hyper_3_13_chunk -- make sure we have total of 6 chunks: SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test_reorder_chunks_table'; count_chunks_uncompressed --------------------------- 6 -- and 2 compressed ones: SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test_reorder_chunks_table'; count_chunks_compressed ------------------------- 2 -- enable reorder policy SELECT add_reorder_policy('test_reorder_chunks_table', 'test_reorder_chunks_table_time_idx') AS reorder_job_id \gset -- nothing is clustered yet SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered ------------+---------------- -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | t | 1 | 1 | 0 | 0 -- first chunk reordered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered ----------------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_3_11_chunk_test_reorder_chunks_table_time_idx | t -- second call to scheduler SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish ------------------------------------------------------------ SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; job_id | last_run_success | total_runs | total_successes | total_failures | total_crashes --------+------------------+------------+-----------------+----------------+--------------- 1001 | t | 2 | 2 | 0 | 0 -- two chunks clustered, skips the compressed chunks SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered ----------------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_3_11_chunk_test_reorder_chunks_table_time_idx | t _timescaledb_internal._hyper_3_14_chunk_test_reorder_chunks_table_time_idx | t �����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_bitmap_scan.out���������������������������������������0000664�0000000�0000000�00000037550�15100345067�0024373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Exercise the Bitmap Heap Scan over the compressed chunk table. It requires -- big tables with high selectivity OR queries on indexed columns, so it almost -- doesn't happen in the normal tests. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; set max_parallel_workers_per_gather = 0; set enable_memoize to off; create table bscan(ts int, s int, id int, payload int); select create_hypertable('bscan', 'ts', chunk_time_interval => 500001); create_hypertable -------------------- (1,public,bscan,t) alter table bscan set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'id, ts'); insert into bscan select ts, ts % 239 s, ts % 111721 id, (mix(ts % 1483) * 1483)::int payload from generate_series(1, 1000000) ts; -- tweak dataset to get whole number actual row results update bscan set payload = -537, s = 1 where id in (1,2); delete from bscan where payload = -537 and id not in (1,2); create index on bscan(payload); select count(compress_chunk(x)) from show_chunks('bscan') x; count ------- 2 vacuum full analyze bscan; -- We have many conditions here, so it's less selective and the bitmap scan -- overhead grows. This query should use Seq Scan. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from bscan where id = 1 or id = 2 or id = 3 or id = 4 or id = 5 or id = 6 or id = 7 or id = 8 ; --- QUERY PLAN --- Append (actual rows=72.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=40.00 loops=1) Output: _hyper_1_1_chunk.ts, _hyper_1_1_chunk.s, _hyper_1_1_chunk.id, _hyper_1_1_chunk.payload Vectorized Filter: ((_hyper_1_1_chunk.id = 1) OR (_hyper_1_1_chunk.id = 2) OR (_hyper_1_1_chunk.id = 3) OR (_hyper_1_1_chunk.id = 4) OR (_hyper_1_1_chunk.id = 5) OR (_hyper_1_1_chunk.id = 6) OR (_hyper_1_1_chunk.id = 7) OR (_hyper_1_1_chunk.id = 8)) Rows Removed by Filter: 34960 Batches Removed by Filter: 4 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=35.00 loops=1) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.s, compress_hyper_2_3_chunk._ts_meta_min_2, compress_hyper_2_3_chunk._ts_meta_max_2, compress_hyper_2_3_chunk.ts, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk.id, compress_hyper_2_3_chunk._ts_meta_v2_bloom1_payload, compress_hyper_2_3_chunk.payload Filter: (((compress_hyper_2_3_chunk._ts_meta_min_1 <= 1) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 1)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 2) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 2)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 3) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 3)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 4) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 4)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 5) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 5)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 6) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 6)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 7) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 7)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 8) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 8))) Rows Removed by Filter: 682 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=32.00 loops=1) Output: _hyper_1_2_chunk.ts, _hyper_1_2_chunk.s, _hyper_1_2_chunk.id, _hyper_1_2_chunk.payload Vectorized Filter: ((_hyper_1_2_chunk.id = 1) OR (_hyper_1_2_chunk.id = 2) OR (_hyper_1_2_chunk.id = 3) OR (_hyper_1_2_chunk.id = 4) OR (_hyper_1_2_chunk.id = 5) OR (_hyper_1_2_chunk.id = 6) OR (_hyper_1_2_chunk.id = 7) OR (_hyper_1_2_chunk.id = 8)) Rows Removed by Filter: 28968 Batches Removed by Filter: 4 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=29.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.s, compress_hyper_2_4_chunk._ts_meta_min_2, compress_hyper_2_4_chunk._ts_meta_max_2, compress_hyper_2_4_chunk.ts, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk.id, compress_hyper_2_4_chunk._ts_meta_v2_bloom1_payload, compress_hyper_2_4_chunk.payload Filter: (((compress_hyper_2_4_chunk._ts_meta_min_1 <= 1) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 1)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 2) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 2)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 3) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 3)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 4) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 4)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 5) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 5)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 6) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 6)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 7) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 7)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 8) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 8))) Rows Removed by Filter: 688 -- This should be Bitmap Heap Scan because we have an OR of highly selective -- conditions. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from bscan where id = 1 or id = 2 ; --- QUERY PLAN --- Append (actual rows=18.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=10.00 loops=1) Output: _hyper_1_1_chunk.ts, _hyper_1_1_chunk.s, _hyper_1_1_chunk.id, _hyper_1_1_chunk.payload Vectorized Filter: ((_hyper_1_1_chunk.id = 1) OR (_hyper_1_1_chunk.id = 2)) Rows Removed by Filter: 4990 Batches Removed by Filter: 4 Bulk Decompression: true -> Bitmap Heap Scan on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.s, compress_hyper_2_3_chunk._ts_meta_min_2, compress_hyper_2_3_chunk._ts_meta_max_2, compress_hyper_2_3_chunk.ts, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk.id, compress_hyper_2_3_chunk._ts_meta_v2_bloom1_payload, compress_hyper_2_3_chunk.payload Recheck Cond: (((compress_hyper_2_3_chunk._ts_meta_min_1 <= 1) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 1)) OR ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 2) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 2))) Heap Blocks: exact=5 -> BitmapOr (actual rows=0.00 loops=1) -> Bitmap Index Scan on compress_hyper_2_3_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 1) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 1)) -> Bitmap Index Scan on compress_hyper_2_3_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_3_chunk._ts_meta_min_1 <= 2) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= 2)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk (actual rows=8.00 loops=1) Output: _hyper_1_2_chunk.ts, _hyper_1_2_chunk.s, _hyper_1_2_chunk.id, _hyper_1_2_chunk.payload Vectorized Filter: ((_hyper_1_2_chunk.id = 1) OR (_hyper_1_2_chunk.id = 2)) Rows Removed by Filter: 4992 Batches Removed by Filter: 4 Bulk Decompression: true -> Bitmap Heap Scan on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.s, compress_hyper_2_4_chunk._ts_meta_min_2, compress_hyper_2_4_chunk._ts_meta_max_2, compress_hyper_2_4_chunk.ts, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk.id, compress_hyper_2_4_chunk._ts_meta_v2_bloom1_payload, compress_hyper_2_4_chunk.payload Recheck Cond: (((compress_hyper_2_4_chunk._ts_meta_min_1 <= 1) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 1)) OR ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 2) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 2))) Heap Blocks: exact=5 -> BitmapOr (actual rows=0.00 loops=1) -> Bitmap Index Scan on compress_hyper_2_4_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 1) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 1)) -> Bitmap Index Scan on compress_hyper_2_4_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_4_chunk._ts_meta_min_1 <= 2) AND (compress_hyper_2_4_chunk._ts_meta_max_1 >= 2)) -- Also try a join with a Bitmap Heap Scan set enable_mergejoin to off; set enable_hashjoin to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from bscan t1, bscan t2 where (t2.id = 1 or t2.id = 2) and t1.s = t2.s and t1.payload = -537; --- QUERY PLAN --- Nested Loop (actual rows=324.00 loops=1) Output: t1.ts, t1.s, t1.id, t1.payload, t2.ts, t2.s, t2.id, t2.payload -> Append (actual rows=18.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk t2_1 (actual rows=10.00 loops=1) Output: t2_1.ts, t2_1.s, t2_1.id, t2_1.payload Vectorized Filter: ((t2_1.id = 1) OR (t2_1.id = 2)) Rows Removed by Filter: 4990 Batches Removed by Filter: 4 Bulk Decompression: true -> Bitmap Heap Scan on _timescaledb_internal.compress_hyper_2_3_chunk compress_hyper_2_3_chunk_1 (actual rows=5.00 loops=1) Output: compress_hyper_2_3_chunk_1._ts_meta_count, compress_hyper_2_3_chunk_1.s, compress_hyper_2_3_chunk_1._ts_meta_min_2, compress_hyper_2_3_chunk_1._ts_meta_max_2, compress_hyper_2_3_chunk_1.ts, compress_hyper_2_3_chunk_1._ts_meta_min_1, compress_hyper_2_3_chunk_1._ts_meta_max_1, compress_hyper_2_3_chunk_1.id, compress_hyper_2_3_chunk_1._ts_meta_v2_bloom1_payload, compress_hyper_2_3_chunk_1.payload Recheck Cond: (((compress_hyper_2_3_chunk_1._ts_meta_min_1 <= 1) AND (compress_hyper_2_3_chunk_1._ts_meta_max_1 >= 1)) OR ((compress_hyper_2_3_chunk_1._ts_meta_min_1 <= 2) AND (compress_hyper_2_3_chunk_1._ts_meta_max_1 >= 2))) Heap Blocks: exact=5 -> BitmapOr (actual rows=0.00 loops=1) -> Bitmap Index Scan on compress_hyper_2_3_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_3_chunk_1._ts_meta_min_1 <= 1) AND (compress_hyper_2_3_chunk_1._ts_meta_max_1 >= 1)) -> Bitmap Index Scan on compress_hyper_2_3_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_3_chunk_1._ts_meta_min_1 <= 2) AND (compress_hyper_2_3_chunk_1._ts_meta_max_1 >= 2)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk t2_2 (actual rows=8.00 loops=1) Output: t2_2.ts, t2_2.s, t2_2.id, t2_2.payload Vectorized Filter: ((t2_2.id = 1) OR (t2_2.id = 2)) Rows Removed by Filter: 4992 Batches Removed by Filter: 4 Bulk Decompression: true -> Bitmap Heap Scan on _timescaledb_internal.compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=5.00 loops=1) Output: compress_hyper_2_4_chunk_1._ts_meta_count, compress_hyper_2_4_chunk_1.s, compress_hyper_2_4_chunk_1._ts_meta_min_2, compress_hyper_2_4_chunk_1._ts_meta_max_2, compress_hyper_2_4_chunk_1.ts, compress_hyper_2_4_chunk_1._ts_meta_min_1, compress_hyper_2_4_chunk_1._ts_meta_max_1, compress_hyper_2_4_chunk_1.id, compress_hyper_2_4_chunk_1._ts_meta_v2_bloom1_payload, compress_hyper_2_4_chunk_1.payload Recheck Cond: (((compress_hyper_2_4_chunk_1._ts_meta_min_1 <= 1) AND (compress_hyper_2_4_chunk_1._ts_meta_max_1 >= 1)) OR ((compress_hyper_2_4_chunk_1._ts_meta_min_1 <= 2) AND (compress_hyper_2_4_chunk_1._ts_meta_max_1 >= 2))) Heap Blocks: exact=5 -> BitmapOr (actual rows=0.00 loops=1) -> Bitmap Index Scan on compress_hyper_2_4_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_4_chunk_1._ts_meta_min_1 <= 1) AND (compress_hyper_2_4_chunk_1._ts_meta_max_1 >= 1)) -> Bitmap Index Scan on compress_hyper_2_4_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx (actual rows=5.00 loops=1) Index Cond: ((compress_hyper_2_4_chunk_1._ts_meta_min_1 <= 2) AND (compress_hyper_2_4_chunk_1._ts_meta_max_1 >= 2)) -> Append (actual rows=18.00 loops=18) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk t1_1 (actual rows=10.00 loops=18) Output: t1_1.ts, t1_1.s, t1_1.id, t1_1.payload Vectorized Filter: (t1_1.payload = '-537'::integer) Rows Removed by Filter: 990 Bulk Decompression: true -> Index Scan using compress_hyper_2_3_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx on _timescaledb_internal.compress_hyper_2_3_chunk (actual rows=1.00 loops=18) Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.s, compress_hyper_2_3_chunk._ts_meta_min_2, compress_hyper_2_3_chunk._ts_meta_max_2, compress_hyper_2_3_chunk.ts, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk.id, compress_hyper_2_3_chunk._ts_meta_v2_bloom1_payload, compress_hyper_2_3_chunk.payload Index Cond: (compress_hyper_2_3_chunk.s = t2.s) Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_3_chunk._ts_meta_v2_bloom1_payload, '-537'::integer) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk t1_2 (actual rows=8.00 loops=18) Output: t1_2.ts, t1_2.s, t1_2.id, t1_2.payload Vectorized Filter: (t1_2.payload = '-537'::integer) Rows Removed by Filter: 992 Bulk Decompression: true -> Index Scan using compress_hyper_2_4_chunk_s__ts_meta_min_1__ts_meta_max_1__t_idx on _timescaledb_internal.compress_hyper_2_4_chunk (actual rows=1.00 loops=18) Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.s, compress_hyper_2_4_chunk._ts_meta_min_2, compress_hyper_2_4_chunk._ts_meta_max_2, compress_hyper_2_4_chunk.ts, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk.id, compress_hyper_2_4_chunk._ts_meta_v2_bloom1_payload, compress_hyper_2_4_chunk.payload Index Cond: (compress_hyper_2_4_chunk.s = t2.s) Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_4_chunk._ts_meta_v2_bloom1_payload, '-537'::integer) Rows Removed by Filter: 2 ; reset enable_mergejoin; reset enable_hashjoin; ��������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_bloom_sparse-15.out�����������������������������������0000664�0000000�0000000�00000141744�15100345067�0025024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; create table bloom(x int, value text, u uuid, ts timestamp); select create_hypertable('bloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable -------------------- (1,public,bloom,t) insert into bloom select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on bloom using brin(value text_bloom_ops); create index on bloom using brin(u uuid_bloom_ops); create index on bloom using brin(ts timestamp_minmax_ops); alter table bloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('bloom') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- bloom | | {} | {x} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] vacuum full analyze bloom; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'bloom') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_2_2_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_value | _timescaledb_internal.bloom1 | | | | external | 1000 | value | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts | timestamp without time zone | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = md5(7248::text); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 9 select count(*) from bloom where value = md5(7248::text); count ------- 1 -- The join condition is not pushed down to the compressed scan for some reason. set enable_mergejoin to off; set enable_hashjoin to off; set enable_material to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) CTE query -> Values Scan on "*VALUES*" (actual rows=3.00 loops=1) Output: "*VALUES*".column1 -> Nested Loop (actual rows=3.00 loops=1) Join Filter: (_hyper_1_1_chunk.value = query.value) Rows Removed by Join Filter: 29997 -> CTE Scan on query (actual rows=3.00 loops=1) Output: query.value -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=10000.00 loops=3) Output: _hyper_1_1_chunk.value Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=3) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts ; with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; count ------- 3 ; reset enable_mergejoin; reset enable_hashjoin; reset enable_material; -- Stable expression that yields null set timescaledb.enable_chunk_append to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else null end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; -- Stable expression that yields not null explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else md5(5837::text) end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 9 -- Stable expression on minmax index explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < case when now() < '1970-01-01' then 1 else 1000 end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=999.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 9 -- Parameter on minmax index set timescaledb.enable_chunk_append to off; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from bloom where x < $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(1000); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < $1) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < $1) Rows Removed by Filter: 9 deallocate p; -- Parameter on bloom index prepare p as select count(*) from bloom where value = $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(md5('2345')); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 9 -- Null parameter on bloom index explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(null); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; deallocate p; -- Function of parameter on bloom index prepare p as select count(*) from bloom where value = md5($1); explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p('2345'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = md5($1)) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, md5($1)) Rows Removed by Filter: 9 deallocate p; reset plan_cache_mode; reset timescaledb.enable_chunk_append; -- Scalar array operations are not yet supported explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < any(array[1000, 2000]::int[]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < ANY ('{1000,2000}'::integer[])) Rows Removed by Filter: 8001 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = any(array[md5('1000'), md5('2000')]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=2.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = ANY ('{a9b7ba70783b617e9998dc4dd82eb3c5,08f90c1a417155361a5c4b8d297e0d78}'::text[])) Rows Removed by Filter: 9998 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 9 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=9999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Rows Removed by Filter: 10 -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where ts between '2021-01-07' and '2021-01-14'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=169.00 loops=1) Vectorized Filter: ((_hyper_1_1_chunk.ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (_hyper_1_1_chunk.ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 831 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: ((compress_hyper_2_2_chunk._ts_meta_v2_max_ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (compress_hyper_2_2_chunk._ts_meta_v2_min_ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 9 -- Test some corner cases create table corner(ts int, s text, c text); select create_hypertable('corner', 'ts'); create_hypertable --------------------- (3,public,corner,t) alter table corner set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); -- Detoasting the second argument of "bloom filter contains" function. insert into corner values (1, repeat('long', 100), 'short'); -- Null bloom filter. insert into corner values(2, 'normal', null); -- A match and a short varlena header in the bloom filter. insert into corner values(3, 'match', 'match'); -- Long varlena header in the bloom filter. insert into corner select 4, 'longheader', generate_series(1, 1000)::text; create index on corner(c); select count(compress_chunk(x)) from show_chunks('corner') x; count ------- 1 vacuum full analyze corner; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Vectorized Filter: (_hyper_3_3_chunk.c = 'short'::text) Rows Removed by Filter: 1 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, 'short'::text) Rows Removed by Filter: 2 -- Cross-type equality operator. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'::name; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = 'short'::name) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Comparison with segmentby. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.s) Rows Removed by Filter: 2 -- Can push down only some parts of the expression but not the others, so the -- pushdown shouldn't work in this case. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s or c = random()::text; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=1.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) OR (_hyper_3_3_chunk.c = (random())::text)) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'test' or c = case when now() > '1970-01-01' then 'test2' else random()::text end ; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=0.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=0.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = 'test'::text) OR (_hyper_3_3_chunk.c = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 'test2'::text ELSE (random())::text END)) Rows Removed by Filter: 1003 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Unsupported operator explain (buffers off, costs off) select * from corner where c > s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_3_chunk Filter: (c > s) -> Seq Scan on compress_hyper_4_4_chunk -- Test a bad hash function. create type badint; create or replace function badintin(cstring) returns badint as 'int8in' language internal strict immutable parallel safe; NOTICE: return type badint is only a shell create or replace function badintout(badint) returns cstring as 'int8out' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell create or replace function badinteq(badint, badint) returns bool as 'int8eq' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell NOTICE: argument type badint is only a shell create type badint (like = int8, input = badintin, output = badintout); create cast (bigint as badint) without function as implicit; create cast (badint as bigint) without function as implicit; create operator = (procedure = badinteq, leftarg = badint, rightarg = badint); -- The btree opfamily equality operator must be in sync with the potential hash family. -- If we don't create it explicitly, Postgres will choose the int8 family because -- it's binary compatible, and the equality operator won't match. create function badint_cmp(left badint, right badint) returns integer as 'btint8cmp' language internal immutable parallel safe strict; create function badint_lt(a badint, b badint) returns boolean as 'int8lt' language internal immutable parallel safe strict; create function badint_le(a badint, b badint) returns boolean as 'int8le' language internal immutable parallel safe strict; create function badint_gt(a badint, b badint) returns boolean as 'int8gt' language internal immutable parallel safe strict; create function badint_ge(a badint, b badint) returns boolean as 'int8ge' language internal immutable parallel safe strict; create operator < (leftarg = badint, rightarg = badint, procedure = badint_lt ); create operator <= (leftarg = badint, rightarg = badint, procedure = badint_le ); create operator >= (leftarg = badint, rightarg = badint, procedure = badint_ge ); create operator > (leftarg = badint, rightarg = badint, procedure = badint_gt ); create operator class badint_btree_ops default for type badint using btree as operator 1 <, operator 2 <=, operator 3 =, operator 4 >=, operator 5 >, function 1 badint_cmp(badint, badint) ; create table badtable(ts int, s int, b badint); select create_hypertable('badtable', 'ts'); create_hypertable ----------------------- (5,public,badtable,t) \set ON_ERROR_STOP 0 alter table badtable set (timescaledb.compress, timescaledb.compress_orderby = '"ts" desc', timescaledb.compress_segmentby = 's', timescaledb.compress_index = 'bloom("b")'); ERROR: invalid bloom filter column type badint \set ON_ERROR_STOP 1 alter table badtable set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into badtable select generate_series(1, 10000), 0, 0::int8; insert into badtable select generate_series(1, 10000), 1, 1::int8; insert into badtable select generate_series(1, 10000), -1, -1::int8; insert into badtable select x, 2, x::int8 from generate_series(1, 10000) x; insert into badtable select x, 3, (pow(2, 32) * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 4, (16834 * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 5, (4096 * x)::int8 from generate_series(1, 10000) x; create index on badtable(b); -- First, try compressing w/o the hash function. We shouldn't get a bloom filter -- index. select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_6_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_b | badint | | | | plain | 1000 | _ts_meta_v2_max_b | badint | | | | plain | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_6_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 -- Then, create the hash functions. -- The simple hash is actually used for dictionary compression, so we have to -- avoid overflows there. create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select (val & ((1::bigint << 31) - 1))::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select val; $$; create operator class badint_hash_ops default for type badint using hash as operator 1 = (badint, badint), function 1 badint_identity_hash(badint), function 2 badint_identity_hash_extended(badint, bigint) ; -- Recompress after creating the hash functions select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- badtable | | {s} | {ts} | {f} | {f} | bloom | | {} | {x} | {f} | {f} | corner | | {s} | {ts} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_3_3_chunk | _timescaledb_internal.compress_hyper_4_4_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "c", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal.compress_hyper_6_7_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "b", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] vacuum full analyze badtable; -- Verify that we actually got the bloom filter index. select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_7_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_b | _timescaledb_internal.bloom1 | | | | external | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_7_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- Check index pushdown with one value. explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 5999 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=6.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) Rows Removed by Filter: 64 -- Check index pushdown and absence of negatives with multiple value. The query -- shape is a little weird to achieve the parameterized compressed scan, for -- joins it doesn't work at the moment due to general problem with parameterized -- DecompressChunk there. explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 3229 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=4.00 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) Rows Removed by Filter: 23 ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Now, repeat the entire exercise with an even worse hash of constant zero. select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select 0::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select 0; $$; select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 69999 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=70.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 25784 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=27.00 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Test a non-by-value 8-byte type. create table byref(ts int, x macaddr8); select create_hypertable('byref', 'ts'); create_hypertable -------------------- (7,public,byref,t) create index on byref(x); alter table byref set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'ts'); create function float8tomacaddr8(x float8) returns macaddr8 as $$ select to_hex(right(float8send(x)::text, -1)::bit(64)::bigint)::macaddr8; $$ language sql immutable parallel safe strict; insert into byref select x, float8tomacaddr8(mix(x)) from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('byref') x; count ------- 1 vacuum analyze byref; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from byref where x = float8tomacaddr8(mix(1)); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_9_chunk (actual rows=1.00 loops=1) Output: _hyper_7_9_chunk.ts, _hyper_7_9_chunk.x Filter: (_hyper_7_9_chunk.x = '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_8_10_chunk (actual rows=1.00 loops=1) Output: compress_hyper_8_10_chunk._ts_meta_count, compress_hyper_8_10_chunk._ts_meta_min_1, compress_hyper_8_10_chunk._ts_meta_max_1, compress_hyper_8_10_chunk.ts, compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, compress_hyper_8_10_chunk.x Filter: _timescaledb_functions.bloom1_contains(compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 9 -- Test an array type. create table arraybloom(x int, value int[], ts timestamp); select create_hypertable('arraybloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------------- (9,public,arraybloom,t) insert into arraybloom select x, array[x], '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on arraybloom(value); alter table arraybloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('arraybloom') x; count ------- 1 vacuum full analyze arraybloom; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from arraybloom where value = array[7248::int]; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_11_chunk (actual rows=1.00 loops=1) Filter: (_hyper_9_11_chunk.value = '{7248}'::integer[]) Rows Removed by Filter: 999 Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_10_12_chunk (actual rows=1.00 loops=1) Output: compress_hyper_10_12_chunk._ts_meta_count, compress_hyper_10_12_chunk._ts_meta_min_1, compress_hyper_10_12_chunk._ts_meta_max_1, compress_hyper_10_12_chunk.x, compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, compress_hyper_10_12_chunk.value, compress_hyper_10_12_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, '{7248}'::integer[]) Rows Removed by Filter: 9 select count(*) from arraybloom where value = array[7248::int]; count ------- 1 -- Cleanup drop table bloom; drop table corner; drop table badtable; drop table byref; drop table arraybloom; ����������������������������timescaledb-2.23.0/tsl/test/expected/compress_bloom_sparse-16.out�����������������������������������0000664�0000000�0000000�00000141744�15100345067�0025025�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; create table bloom(x int, value text, u uuid, ts timestamp); select create_hypertable('bloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable -------------------- (1,public,bloom,t) insert into bloom select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on bloom using brin(value text_bloom_ops); create index on bloom using brin(u uuid_bloom_ops); create index on bloom using brin(ts timestamp_minmax_ops); alter table bloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('bloom') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- bloom | | {} | {x} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] vacuum full analyze bloom; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'bloom') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_2_2_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_value | _timescaledb_internal.bloom1 | | | | external | 1000 | value | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts | timestamp without time zone | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = md5(7248::text); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 9 select count(*) from bloom where value = md5(7248::text); count ------- 1 -- The join condition is not pushed down to the compressed scan for some reason. set enable_mergejoin to off; set enable_hashjoin to off; set enable_material to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) CTE query -> Values Scan on "*VALUES*" (actual rows=3.00 loops=1) Output: "*VALUES*".column1 -> Nested Loop (actual rows=3.00 loops=1) Join Filter: (_hyper_1_1_chunk.value = query.value) Rows Removed by Join Filter: 29997 -> CTE Scan on query (actual rows=3.00 loops=1) Output: query.value -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=10000.00 loops=3) Output: _hyper_1_1_chunk.value Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=3) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts ; with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; count ------- 3 ; reset enable_mergejoin; reset enable_hashjoin; reset enable_material; -- Stable expression that yields null set timescaledb.enable_chunk_append to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else null end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; -- Stable expression that yields not null explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else md5(5837::text) end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 9 -- Stable expression on minmax index explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < case when now() < '1970-01-01' then 1 else 1000 end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=999.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 9 -- Parameter on minmax index set timescaledb.enable_chunk_append to off; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from bloom where x < $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(1000); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < $1) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < $1) Rows Removed by Filter: 9 deallocate p; -- Parameter on bloom index prepare p as select count(*) from bloom where value = $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(md5('2345')); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 9 -- Null parameter on bloom index explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(null); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; deallocate p; -- Function of parameter on bloom index prepare p as select count(*) from bloom where value = md5($1); explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p('2345'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = md5($1)) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, md5($1)) Rows Removed by Filter: 9 deallocate p; reset plan_cache_mode; reset timescaledb.enable_chunk_append; -- Scalar array operations are not yet supported explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < any(array[1000, 2000]::int[]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < ANY ('{1000,2000}'::integer[])) Rows Removed by Filter: 8001 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = any(array[md5('1000'), md5('2000')]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=2.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = ANY ('{a9b7ba70783b617e9998dc4dd82eb3c5,08f90c1a417155361a5c4b8d297e0d78}'::text[])) Rows Removed by Filter: 9998 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 9 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=9999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Rows Removed by Filter: 10 -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where ts between '2021-01-07' and '2021-01-14'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=169.00 loops=1) Vectorized Filter: ((_hyper_1_1_chunk.ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (_hyper_1_1_chunk.ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 831 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: ((compress_hyper_2_2_chunk._ts_meta_v2_max_ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (compress_hyper_2_2_chunk._ts_meta_v2_min_ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 9 -- Test some corner cases create table corner(ts int, s text, c text); select create_hypertable('corner', 'ts'); create_hypertable --------------------- (3,public,corner,t) alter table corner set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); -- Detoasting the second argument of "bloom filter contains" function. insert into corner values (1, repeat('long', 100), 'short'); -- Null bloom filter. insert into corner values(2, 'normal', null); -- A match and a short varlena header in the bloom filter. insert into corner values(3, 'match', 'match'); -- Long varlena header in the bloom filter. insert into corner select 4, 'longheader', generate_series(1, 1000)::text; create index on corner(c); select count(compress_chunk(x)) from show_chunks('corner') x; count ------- 1 vacuum full analyze corner; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Vectorized Filter: (_hyper_3_3_chunk.c = 'short'::text) Rows Removed by Filter: 1 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, 'short'::text) Rows Removed by Filter: 2 -- Cross-type equality operator. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'::name; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = 'short'::name) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Comparison with segmentby. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.s) Rows Removed by Filter: 2 -- Can push down only some parts of the expression but not the others, so the -- pushdown shouldn't work in this case. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s or c = random()::text; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=1.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) OR (_hyper_3_3_chunk.c = (random())::text)) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'test' or c = case when now() > '1970-01-01' then 'test2' else random()::text end ; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=0.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=0.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = 'test'::text) OR (_hyper_3_3_chunk.c = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 'test2'::text ELSE (random())::text END)) Rows Removed by Filter: 1003 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Unsupported operator explain (buffers off, costs off) select * from corner where c > s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_3_chunk Filter: (c > s) -> Seq Scan on compress_hyper_4_4_chunk -- Test a bad hash function. create type badint; create or replace function badintin(cstring) returns badint as 'int8in' language internal strict immutable parallel safe; NOTICE: return type badint is only a shell create or replace function badintout(badint) returns cstring as 'int8out' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell create or replace function badinteq(badint, badint) returns bool as 'int8eq' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell NOTICE: argument type badint is only a shell create type badint (like = int8, input = badintin, output = badintout); create cast (bigint as badint) without function as implicit; create cast (badint as bigint) without function as implicit; create operator = (procedure = badinteq, leftarg = badint, rightarg = badint); -- The btree opfamily equality operator must be in sync with the potential hash family. -- If we don't create it explicitly, Postgres will choose the int8 family because -- it's binary compatible, and the equality operator won't match. create function badint_cmp(left badint, right badint) returns integer as 'btint8cmp' language internal immutable parallel safe strict; create function badint_lt(a badint, b badint) returns boolean as 'int8lt' language internal immutable parallel safe strict; create function badint_le(a badint, b badint) returns boolean as 'int8le' language internal immutable parallel safe strict; create function badint_gt(a badint, b badint) returns boolean as 'int8gt' language internal immutable parallel safe strict; create function badint_ge(a badint, b badint) returns boolean as 'int8ge' language internal immutable parallel safe strict; create operator < (leftarg = badint, rightarg = badint, procedure = badint_lt ); create operator <= (leftarg = badint, rightarg = badint, procedure = badint_le ); create operator >= (leftarg = badint, rightarg = badint, procedure = badint_ge ); create operator > (leftarg = badint, rightarg = badint, procedure = badint_gt ); create operator class badint_btree_ops default for type badint using btree as operator 1 <, operator 2 <=, operator 3 =, operator 4 >=, operator 5 >, function 1 badint_cmp(badint, badint) ; create table badtable(ts int, s int, b badint); select create_hypertable('badtable', 'ts'); create_hypertable ----------------------- (5,public,badtable,t) \set ON_ERROR_STOP 0 alter table badtable set (timescaledb.compress, timescaledb.compress_orderby = '"ts" desc', timescaledb.compress_segmentby = 's', timescaledb.compress_index = 'bloom("b")'); ERROR: invalid bloom filter column type badint \set ON_ERROR_STOP 1 alter table badtable set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into badtable select generate_series(1, 10000), 0, 0::int8; insert into badtable select generate_series(1, 10000), 1, 1::int8; insert into badtable select generate_series(1, 10000), -1, -1::int8; insert into badtable select x, 2, x::int8 from generate_series(1, 10000) x; insert into badtable select x, 3, (pow(2, 32) * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 4, (16834 * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 5, (4096 * x)::int8 from generate_series(1, 10000) x; create index on badtable(b); -- First, try compressing w/o the hash function. We shouldn't get a bloom filter -- index. select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_6_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_b | badint | | | | plain | 1000 | _ts_meta_v2_max_b | badint | | | | plain | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_6_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 -- Then, create the hash functions. -- The simple hash is actually used for dictionary compression, so we have to -- avoid overflows there. create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select (val & ((1::bigint << 31) - 1))::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select val; $$; create operator class badint_hash_ops default for type badint using hash as operator 1 = (badint, badint), function 1 badint_identity_hash(badint), function 2 badint_identity_hash_extended(badint, bigint) ; -- Recompress after creating the hash functions select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- badtable | | {s} | {ts} | {f} | {f} | bloom | | {} | {x} | {f} | {f} | corner | | {s} | {ts} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_3_3_chunk | _timescaledb_internal.compress_hyper_4_4_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "c", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal.compress_hyper_6_7_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "b", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] vacuum full analyze badtable; -- Verify that we actually got the bloom filter index. select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_7_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_b | _timescaledb_internal.bloom1 | | | | external | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_7_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- Check index pushdown with one value. explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 5999 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=6.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) Rows Removed by Filter: 64 -- Check index pushdown and absence of negatives with multiple value. The query -- shape is a little weird to achieve the parameterized compressed scan, for -- joins it doesn't work at the moment due to general problem with parameterized -- DecompressChunk there. explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 3229 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=4.00 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) Rows Removed by Filter: 23 ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Now, repeat the entire exercise with an even worse hash of constant zero. select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select 0::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select 0; $$; select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 69999 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=70.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 25784 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=27.00 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Test a non-by-value 8-byte type. create table byref(ts int, x macaddr8); select create_hypertable('byref', 'ts'); create_hypertable -------------------- (7,public,byref,t) create index on byref(x); alter table byref set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'ts'); create function float8tomacaddr8(x float8) returns macaddr8 as $$ select to_hex(right(float8send(x)::text, -1)::bit(64)::bigint)::macaddr8; $$ language sql immutable parallel safe strict; insert into byref select x, float8tomacaddr8(mix(x)) from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('byref') x; count ------- 1 vacuum analyze byref; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from byref where x = float8tomacaddr8(mix(1)); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_9_chunk (actual rows=1.00 loops=1) Output: _hyper_7_9_chunk.ts, _hyper_7_9_chunk.x Filter: (_hyper_7_9_chunk.x = '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_8_10_chunk (actual rows=1.00 loops=1) Output: compress_hyper_8_10_chunk._ts_meta_count, compress_hyper_8_10_chunk._ts_meta_min_1, compress_hyper_8_10_chunk._ts_meta_max_1, compress_hyper_8_10_chunk.ts, compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, compress_hyper_8_10_chunk.x Filter: _timescaledb_functions.bloom1_contains(compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 9 -- Test an array type. create table arraybloom(x int, value int[], ts timestamp); select create_hypertable('arraybloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------------- (9,public,arraybloom,t) insert into arraybloom select x, array[x], '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on arraybloom(value); alter table arraybloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('arraybloom') x; count ------- 1 vacuum full analyze arraybloom; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from arraybloom where value = array[7248::int]; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_11_chunk (actual rows=1.00 loops=1) Filter: (_hyper_9_11_chunk.value = '{7248}'::integer[]) Rows Removed by Filter: 999 Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_10_12_chunk (actual rows=1.00 loops=1) Output: compress_hyper_10_12_chunk._ts_meta_count, compress_hyper_10_12_chunk._ts_meta_min_1, compress_hyper_10_12_chunk._ts_meta_max_1, compress_hyper_10_12_chunk.x, compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, compress_hyper_10_12_chunk.value, compress_hyper_10_12_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, '{7248}'::integer[]) Rows Removed by Filter: 9 select count(*) from arraybloom where value = array[7248::int]; count ------- 1 -- Cleanup drop table bloom; drop table corner; drop table badtable; drop table byref; drop table arraybloom; ����������������������������timescaledb-2.23.0/tsl/test/expected/compress_bloom_sparse-17.out�����������������������������������0000664�0000000�0000000�00000141744�15100345067�0025026�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; create table bloom(x int, value text, u uuid, ts timestamp); select create_hypertable('bloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable -------------------- (1,public,bloom,t) insert into bloom select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on bloom using brin(value text_bloom_ops); create index on bloom using brin(u uuid_bloom_ops); create index on bloom using brin(ts timestamp_minmax_ops); alter table bloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('bloom') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- bloom | | {} | {x} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] vacuum full analyze bloom; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'bloom') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_2_2_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_value | _timescaledb_internal.bloom1 | | | | external | 1000 | value | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts | timestamp without time zone | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = md5(7248::text); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 9 select count(*) from bloom where value = md5(7248::text); count ------- 1 -- The join condition is not pushed down to the compressed scan for some reason. set enable_mergejoin to off; set enable_hashjoin to off; set enable_material to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) CTE query -> Values Scan on "*VALUES*" (actual rows=3.00 loops=1) Output: "*VALUES*".column1 -> Nested Loop (actual rows=3.00 loops=1) Join Filter: (_hyper_1_1_chunk.value = query.value) Rows Removed by Join Filter: 29997 -> CTE Scan on query (actual rows=3.00 loops=1) Output: query.value -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=10000.00 loops=3) Output: _hyper_1_1_chunk.value Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=3) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts ; with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; count ------- 3 ; reset enable_mergejoin; reset enable_hashjoin; reset enable_material; -- Stable expression that yields null set timescaledb.enable_chunk_append to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else null end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; -- Stable expression that yields not null explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else md5(5837::text) end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 9 -- Stable expression on minmax index explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < case when now() < '1970-01-01' then 1 else 1000 end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=999.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 9 -- Parameter on minmax index set timescaledb.enable_chunk_append to off; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from bloom where x < $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(1000); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < $1) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < $1) Rows Removed by Filter: 9 deallocate p; -- Parameter on bloom index prepare p as select count(*) from bloom where value = $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(md5('2345')); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 9 -- Null parameter on bloom index explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(null); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; deallocate p; -- Function of parameter on bloom index prepare p as select count(*) from bloom where value = md5($1); explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p('2345'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = md5($1)) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, md5($1)) Rows Removed by Filter: 9 deallocate p; reset plan_cache_mode; reset timescaledb.enable_chunk_append; -- Scalar array operations are not yet supported explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < any(array[1000, 2000]::int[]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < ANY ('{1000,2000}'::integer[])) Rows Removed by Filter: 8001 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = any(array[md5('1000'), md5('2000')]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=2.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = ANY ('{a9b7ba70783b617e9998dc4dd82eb3c5,08f90c1a417155361a5c4b8d297e0d78}'::text[])) Rows Removed by Filter: 9998 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 9 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=9999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Rows Removed by Filter: 10 -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where ts between '2021-01-07' and '2021-01-14'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=169.00 loops=1) Vectorized Filter: ((_hyper_1_1_chunk.ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (_hyper_1_1_chunk.ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 831 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: ((compress_hyper_2_2_chunk._ts_meta_v2_max_ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (compress_hyper_2_2_chunk._ts_meta_v2_min_ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 9 -- Test some corner cases create table corner(ts int, s text, c text); select create_hypertable('corner', 'ts'); create_hypertable --------------------- (3,public,corner,t) alter table corner set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); -- Detoasting the second argument of "bloom filter contains" function. insert into corner values (1, repeat('long', 100), 'short'); -- Null bloom filter. insert into corner values(2, 'normal', null); -- A match and a short varlena header in the bloom filter. insert into corner values(3, 'match', 'match'); -- Long varlena header in the bloom filter. insert into corner select 4, 'longheader', generate_series(1, 1000)::text; create index on corner(c); select count(compress_chunk(x)) from show_chunks('corner') x; count ------- 1 vacuum full analyze corner; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Vectorized Filter: (_hyper_3_3_chunk.c = 'short'::text) Rows Removed by Filter: 1 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, 'short'::text) Rows Removed by Filter: 2 -- Cross-type equality operator. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'::name; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = 'short'::name) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Comparison with segmentby. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.s) Rows Removed by Filter: 2 -- Can push down only some parts of the expression but not the others, so the -- pushdown shouldn't work in this case. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s or c = random()::text; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=1.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) OR (_hyper_3_3_chunk.c = (random())::text)) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'test' or c = case when now() > '1970-01-01' then 'test2' else random()::text end ; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=0.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=0.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = 'test'::text) OR (_hyper_3_3_chunk.c = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 'test2'::text ELSE (random())::text END)) Rows Removed by Filter: 1003 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Unsupported operator explain (buffers off, costs off) select * from corner where c > s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_3_chunk Filter: (c > s) -> Seq Scan on compress_hyper_4_4_chunk -- Test a bad hash function. create type badint; create or replace function badintin(cstring) returns badint as 'int8in' language internal strict immutable parallel safe; NOTICE: return type badint is only a shell create or replace function badintout(badint) returns cstring as 'int8out' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell create or replace function badinteq(badint, badint) returns bool as 'int8eq' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell NOTICE: argument type badint is only a shell create type badint (like = int8, input = badintin, output = badintout); create cast (bigint as badint) without function as implicit; create cast (badint as bigint) without function as implicit; create operator = (procedure = badinteq, leftarg = badint, rightarg = badint); -- The btree opfamily equality operator must be in sync with the potential hash family. -- If we don't create it explicitly, Postgres will choose the int8 family because -- it's binary compatible, and the equality operator won't match. create function badint_cmp(left badint, right badint) returns integer as 'btint8cmp' language internal immutable parallel safe strict; create function badint_lt(a badint, b badint) returns boolean as 'int8lt' language internal immutable parallel safe strict; create function badint_le(a badint, b badint) returns boolean as 'int8le' language internal immutable parallel safe strict; create function badint_gt(a badint, b badint) returns boolean as 'int8gt' language internal immutable parallel safe strict; create function badint_ge(a badint, b badint) returns boolean as 'int8ge' language internal immutable parallel safe strict; create operator < (leftarg = badint, rightarg = badint, procedure = badint_lt ); create operator <= (leftarg = badint, rightarg = badint, procedure = badint_le ); create operator >= (leftarg = badint, rightarg = badint, procedure = badint_ge ); create operator > (leftarg = badint, rightarg = badint, procedure = badint_gt ); create operator class badint_btree_ops default for type badint using btree as operator 1 <, operator 2 <=, operator 3 =, operator 4 >=, operator 5 >, function 1 badint_cmp(badint, badint) ; create table badtable(ts int, s int, b badint); select create_hypertable('badtable', 'ts'); create_hypertable ----------------------- (5,public,badtable,t) \set ON_ERROR_STOP 0 alter table badtable set (timescaledb.compress, timescaledb.compress_orderby = '"ts" desc', timescaledb.compress_segmentby = 's', timescaledb.compress_index = 'bloom("b")'); ERROR: invalid bloom filter column type badint \set ON_ERROR_STOP 1 alter table badtable set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into badtable select generate_series(1, 10000), 0, 0::int8; insert into badtable select generate_series(1, 10000), 1, 1::int8; insert into badtable select generate_series(1, 10000), -1, -1::int8; insert into badtable select x, 2, x::int8 from generate_series(1, 10000) x; insert into badtable select x, 3, (pow(2, 32) * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 4, (16834 * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 5, (4096 * x)::int8 from generate_series(1, 10000) x; create index on badtable(b); -- First, try compressing w/o the hash function. We shouldn't get a bloom filter -- index. select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_6_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_b | badint | | | | plain | 1000 | _ts_meta_v2_max_b | badint | | | | plain | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_6_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 -- Then, create the hash functions. -- The simple hash is actually used for dictionary compression, so we have to -- avoid overflows there. create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select (val & ((1::bigint << 31) - 1))::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select val; $$; create operator class badint_hash_ops default for type badint using hash as operator 1 = (badint, badint), function 1 badint_identity_hash(badint), function 2 badint_identity_hash_extended(badint, bigint) ; -- Recompress after creating the hash functions select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- badtable | | {s} | {ts} | {f} | {f} | bloom | | {} | {x} | {f} | {f} | corner | | {s} | {ts} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_3_3_chunk | _timescaledb_internal.compress_hyper_4_4_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "c", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal.compress_hyper_6_7_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "b", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] vacuum full analyze badtable; -- Verify that we actually got the bloom filter index. select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_7_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_b | _timescaledb_internal.bloom1 | | | | external | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_7_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- Check index pushdown with one value. explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 5999 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=6.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) Rows Removed by Filter: 64 -- Check index pushdown and absence of negatives with multiple value. The query -- shape is a little weird to achieve the parameterized compressed scan, for -- joins it doesn't work at the moment due to general problem with parameterized -- DecompressChunk there. explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 3229 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=4.00 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) Rows Removed by Filter: 23 ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Now, repeat the entire exercise with an even worse hash of constant zero. select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select 0::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select 0; $$; select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 69999 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=70.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 25784 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=27.00 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Test a non-by-value 8-byte type. create table byref(ts int, x macaddr8); select create_hypertable('byref', 'ts'); create_hypertable -------------------- (7,public,byref,t) create index on byref(x); alter table byref set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'ts'); create function float8tomacaddr8(x float8) returns macaddr8 as $$ select to_hex(right(float8send(x)::text, -1)::bit(64)::bigint)::macaddr8; $$ language sql immutable parallel safe strict; insert into byref select x, float8tomacaddr8(mix(x)) from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('byref') x; count ------- 1 vacuum analyze byref; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from byref where x = float8tomacaddr8(mix(1)); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_9_chunk (actual rows=1.00 loops=1) Output: _hyper_7_9_chunk.ts, _hyper_7_9_chunk.x Filter: (_hyper_7_9_chunk.x = '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_8_10_chunk (actual rows=1.00 loops=1) Output: compress_hyper_8_10_chunk._ts_meta_count, compress_hyper_8_10_chunk._ts_meta_min_1, compress_hyper_8_10_chunk._ts_meta_max_1, compress_hyper_8_10_chunk.ts, compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, compress_hyper_8_10_chunk.x Filter: _timescaledb_functions.bloom1_contains(compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 9 -- Test an array type. create table arraybloom(x int, value int[], ts timestamp); select create_hypertable('arraybloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------------- (9,public,arraybloom,t) insert into arraybloom select x, array[x], '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on arraybloom(value); alter table arraybloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('arraybloom') x; count ------- 1 vacuum full analyze arraybloom; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from arraybloom where value = array[7248::int]; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_11_chunk (actual rows=1.00 loops=1) Filter: (_hyper_9_11_chunk.value = '{7248}'::integer[]) Rows Removed by Filter: 999 Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_10_12_chunk (actual rows=1.00 loops=1) Output: compress_hyper_10_12_chunk._ts_meta_count, compress_hyper_10_12_chunk._ts_meta_min_1, compress_hyper_10_12_chunk._ts_meta_max_1, compress_hyper_10_12_chunk.x, compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, compress_hyper_10_12_chunk.value, compress_hyper_10_12_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, '{7248}'::integer[]) Rows Removed by Filter: 9 select count(*) from arraybloom where value = array[7248::int]; count ------- 1 -- Cleanup drop table bloom; drop table corner; drop table badtable; drop table byref; drop table arraybloom; ����������������������������timescaledb-2.23.0/tsl/test/expected/compress_bloom_sparse-18.out�����������������������������������0000664�0000000�0000000�00000142024�15100345067�0025017�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; create table bloom(x int, value text, u uuid, ts timestamp); select create_hypertable('bloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable -------------------- (1,public,bloom,t) insert into bloom select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on bloom using brin(value text_bloom_ops); create index on bloom using brin(u uuid_bloom_ops); create index on bloom using brin(ts timestamp_minmax_ops); alter table bloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('bloom') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- bloom | | {} | {x} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] vacuum full analyze bloom; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'bloom') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_2_2_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description --------------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_value | _timescaledb_internal.bloom1 | | | | external | 1000 | value | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts | timestamp without time zone | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = md5(7248::text); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, '1f4183315762e30ea441d3caef5e64ad'::text) Rows Removed by Filter: 9 select count(*) from bloom where value = md5(7248::text); count ------- 1 -- The join condition is not pushed down to the compressed scan for some reason. set enable_mergejoin to off; set enable_hashjoin to off; set enable_material to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) CTE query -> Values Scan on "*VALUES*" (actual rows=3.00 loops=1) Output: "*VALUES*".column1 -> Nested Loop (actual rows=3.00 loops=1) Join Filter: (_hyper_1_1_chunk.value = query.value) Rows Removed by Join Filter: 29997 -> CTE Scan on query (actual rows=3.00 loops=1) Output: query.value -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=10000.00 loops=3) Output: _hyper_1_1_chunk.value Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=3) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts ; with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; count ------- 3 ; reset enable_mergejoin; reset enable_hashjoin; reset enable_material; -- Stable expression that yields null set timescaledb.enable_chunk_append to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else null end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE NULL::text END) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; -- Stable expression that yields not null explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else md5(5837::text) end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN '81b073de9370ea873f548e31b8adc081'::text ELSE 'd1e39c9bda5c80ac3d8ea9d658163967'::text END) Rows Removed by Filter: 9 -- Stable expression on minmax index explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < case when now() < '1970-01-01' then 1 else 1000 end ; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=999.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < CASE WHEN (now() < 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE 1000 END) Rows Removed by Filter: 9 -- Parameter on minmax index set timescaledb.enable_chunk_append to off; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from bloom where x < $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(1000); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < $1) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: (compress_hyper_2_2_chunk._ts_meta_min_1 < $1) Rows Removed by Filter: 9 deallocate p; -- Parameter on bloom index prepare p as select count(*) from bloom where value = $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(md5('2345')); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 9 -- Null parameter on bloom index explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(null); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = $1) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, $1) Rows Removed by Filter: 10 reset timescaledb.enable_chunk_append; deallocate p; -- Function of parameter on bloom index prepare p as select count(*) from bloom where value = md5($1); explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p('2345'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ChunkAppend) on public.bloom (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = md5($1)) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, md5($1)) Rows Removed by Filter: 9 deallocate p; reset plan_cache_mode; reset timescaledb.enable_chunk_append; -- Scalar array operations are not yet supported explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < any(array[1000, 2000]::int[]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.x < ANY ('{1000,2000}'::integer[])) Rows Removed by Filter: 8001 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = any(array[md5('1000'), md5('2000')]); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=2.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.value = ANY ('{a9b7ba70783b617e9998dc4dd82eb3c5,08f90c1a417155361a5c4b8d297e0d78}'::text[])) Rows Removed by Filter: 9998 Batches Removed by Filter: 8 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 9 explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=9999.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=10.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid) explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (_hyper_1_1_chunk.u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, '6c1d0998-05f3-452c-abd3-45afe72bbcac'::uuid) Rows Removed by Filter: 10 -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where ts between '2021-01-07' and '2021-01-14'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=169.00 loops=1) Vectorized Filter: ((_hyper_1_1_chunk.ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (_hyper_1_1_chunk.ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 831 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk.x, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_value, compress_hyper_2_2_chunk.value, compress_hyper_2_2_chunk._ts_meta_v2_bloom1_u, compress_hyper_2_2_chunk.u, compress_hyper_2_2_chunk._ts_meta_v2_min_ts, compress_hyper_2_2_chunk._ts_meta_v2_max_ts, compress_hyper_2_2_chunk.ts Filter: ((compress_hyper_2_2_chunk._ts_meta_v2_max_ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (compress_hyper_2_2_chunk._ts_meta_v2_min_ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 9 -- Test some corner cases create table corner(ts int, s text, c text); select create_hypertable('corner', 'ts'); create_hypertable --------------------- (3,public,corner,t) alter table corner set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); -- Detoasting the second argument of "bloom filter contains" function. insert into corner values (1, repeat('long', 100), 'short'); -- Null bloom filter. insert into corner values(2, 'normal', null); -- A match and a short varlena header in the bloom filter. insert into corner values(3, 'match', 'match'); -- Long varlena header in the bloom filter. insert into corner select 4, 'longheader', generate_series(1, 1000)::text; create index on corner(c); select count(compress_chunk(x)) from show_chunks('corner') x; count ------- 1 vacuum full analyze corner; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Vectorized Filter: (_hyper_3_3_chunk.c = 'short'::text) Rows Removed by Filter: 1 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, 'short'::text) Rows Removed by Filter: 2 -- Cross-type equality operator. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'::name; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = 'short'::name) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Comparison with segmentby. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: (_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) Rows Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=2.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.s) Rows Removed by Filter: 2 -- Can push down only some parts of the expression but not the others, so the -- pushdown shouldn't work in this case. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s or c = random()::text; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=1.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=1.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = _hyper_3_3_chunk.s) OR (_hyper_3_3_chunk.c = (random())::text)) Rows Removed by Filter: 1002 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'test' or c = case when now() > '1970-01-01' then 'test2' else random()::text end ; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.corner (actual rows=0.00 loops=1) Output: corner.ts, corner.s, corner.c Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=0.00 loops=1) Output: _hyper_3_3_chunk.ts, _hyper_3_3_chunk.s, _hyper_3_3_chunk.c Filter: ((_hyper_3_3_chunk.c = 'test'::text) OR (_hyper_3_3_chunk.c = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 'test2'::text ELSE (random())::text END)) Rows Removed by Filter: 1003 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=4.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.s, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk.ts, compress_hyper_4_4_chunk._ts_meta_v2_bloom1_c, compress_hyper_4_4_chunk.c -- Unsupported operator explain (buffers off, costs off) select * from corner where c > s; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_3_chunk Filter: (c > s) -> Seq Scan on compress_hyper_4_4_chunk -- Test a bad hash function. create type badint; create or replace function badintin(cstring) returns badint as 'int8in' language internal strict immutable parallel safe; NOTICE: return type badint is only a shell create or replace function badintout(badint) returns cstring as 'int8out' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell at character 38 create or replace function badinteq(badint, badint) returns bool as 'int8eq' language internal strict immutable parallel safe; NOTICE: argument type badint is only a shell at character 37 NOTICE: argument type badint is only a shell at character 45 create type badint (like = int8, input = badintin, output = badintout); create cast (bigint as badint) without function as implicit; create cast (badint as bigint) without function as implicit; create operator = (procedure = badinteq, leftarg = badint, rightarg = badint); -- The btree opfamily equality operator must be in sync with the potential hash family. -- If we don't create it explicitly, Postgres will choose the int8 family because -- it's binary compatible, and the equality operator won't match. create function badint_cmp(left badint, right badint) returns integer as 'btint8cmp' language internal immutable parallel safe strict; create function badint_lt(a badint, b badint) returns boolean as 'int8lt' language internal immutable parallel safe strict; create function badint_le(a badint, b badint) returns boolean as 'int8le' language internal immutable parallel safe strict; create function badint_gt(a badint, b badint) returns boolean as 'int8gt' language internal immutable parallel safe strict; create function badint_ge(a badint, b badint) returns boolean as 'int8ge' language internal immutable parallel safe strict; create operator < (leftarg = badint, rightarg = badint, procedure = badint_lt ); create operator <= (leftarg = badint, rightarg = badint, procedure = badint_le ); create operator >= (leftarg = badint, rightarg = badint, procedure = badint_ge ); create operator > (leftarg = badint, rightarg = badint, procedure = badint_gt ); create operator class badint_btree_ops default for type badint using btree as operator 1 <, operator 2 <=, operator 3 =, operator 4 >=, operator 5 >, function 1 badint_cmp(badint, badint) ; create table badtable(ts int, s int, b badint); select create_hypertable('badtable', 'ts'); create_hypertable ----------------------- (5,public,badtable,t) \set ON_ERROR_STOP 0 alter table badtable set (timescaledb.compress, timescaledb.compress_orderby = '"ts" desc', timescaledb.compress_segmentby = 's', timescaledb.compress_index = 'bloom("b")'); ERROR: invalid bloom filter column type badint \set ON_ERROR_STOP 1 alter table badtable set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into badtable select generate_series(1, 10000), 0, 0::int8; insert into badtable select generate_series(1, 10000), 1, 1::int8; insert into badtable select generate_series(1, 10000), -1, -1::int8; insert into badtable select x, 2, x::int8 from generate_series(1, 10000) x; insert into badtable select x, 3, (pow(2, 32) * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 4, (16834 * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 5, (4096 * x)::int8 from generate_series(1, 10000) x; create index on badtable(b); -- First, try compressing w/o the hash function. We shouldn't get a bloom filter -- index. select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_6_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description -------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_b | badint | | | | plain | 1000 | _ts_meta_v2_max_b | badint | | | | plain | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_6_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 -- Then, create the hash functions. -- The simple hash is actually used for dictionary compression, so we have to -- avoid overflows there. create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select (val & ((1::bigint << 31) - 1))::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select val; $$; create operator class badint_hash_ops default for type badint using hash as operator 1 = (badint, badint), function 1 badint_identity_hash(badint), function 2 badint_identity_hash_extended(badint, bigint) ; -- Recompress after creating the hash functions select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- badtable | | {s} | {ts} | {f} | {f} | bloom | | {} | {x} | {f} | {f} | corner | | {s} | {ts} | {f} | {f} | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_2_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "default"}, {"type": "bloom", "column": "u", "source": "default"}, {"type": "minmax", "column": "ts", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_3_3_chunk | _timescaledb_internal.compress_hyper_4_4_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "c", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] _timescaledb_internal._hyper_5_5_chunk | _timescaledb_internal.compress_hyper_6_7_chunk | {s} | {ts} | {f} | {f} | [{"type": "bloom", "column": "b", "source": "default"}, {"type": "minmax", "column": "ts", "source": "orderby"}] vacuum full analyze badtable; -- Verify that we actually got the bloom filter index. select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_7_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | s | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_b | _timescaledb_internal.bloom1 | | | | external | 1000 | b | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_6_7_chunk_s__ts_meta_min_1__ts_meta_max_1_idx" btree (s, _ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- Check index pushdown with one value. explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 5999 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=6.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) Rows Removed by Filter: 64 -- Check index pushdown and absence of negatives with multiple value. The query -- shape is a little weird to achieve the parameterized compressed scan, for -- joins it doesn't work at the moment due to general problem with parameterized -- DecompressChunk there. explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 3229 -> Seq Scan on compress_hyper_6_7_chunk (actual rows=4.22 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) Rows Removed by Filter: 23 ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Now, repeat the entire exercise with an even worse hash of constant zero. select count(decompress_chunk(x)) from show_chunks('badtable') x; count ------- 1 create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select 0::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select 0; $$; select count(compress_chunk(x)) from show_chunks('badtable') x; count ------- 1 vacuum full analyze badtable; explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=1) Filter: (b = '1000'::badint) Rows Removed by Filter: 69999 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=70.00 loops=1) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, '1000'::badint) explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; --- QUERY PLAN --- CTE Scan on v_badint (actual rows=9.00 loops=1) CTE v_badint -> Values Scan on "*VALUES*" (actual rows=9.00 loops=1) SubPlan 2 -> Custom Scan (ChunkAppend) on badtable (actual rows=1.00 loops=9) Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_5_5_chunk (actual rows=1.00 loops=9) Filter: (b = v_badint.b) Rows Removed by Filter: 25784 -> Seq Scan on compress_hyper_6_8_chunk (actual rows=26.78 loops=9) Filter: _timescaledb_functions.bloom1_contains(_ts_meta_v2_bloom1_b, v_badint.b) ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; exists -------- t t t t t t t t t ; -- Test a non-by-value 8-byte type. create table byref(ts int, x macaddr8); select create_hypertable('byref', 'ts'); create_hypertable -------------------- (7,public,byref,t) create index on byref(x); alter table byref set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'ts'); create function float8tomacaddr8(x float8) returns macaddr8 as $$ select to_hex(right(float8send(x)::text, -1)::bit(64)::bigint)::macaddr8; $$ language sql immutable parallel safe strict; insert into byref select x, float8tomacaddr8(mix(x)) from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('byref') x; count ------- 1 vacuum analyze byref; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from byref where x = float8tomacaddr8(mix(1)); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_9_chunk (actual rows=1.00 loops=1) Output: _hyper_7_9_chunk.ts, _hyper_7_9_chunk.x Filter: (_hyper_7_9_chunk.x = '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_8_10_chunk (actual rows=1.00 loops=1) Output: compress_hyper_8_10_chunk._ts_meta_count, compress_hyper_8_10_chunk._ts_meta_min_1, compress_hyper_8_10_chunk._ts_meta_max_1, compress_hyper_8_10_chunk.ts, compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, compress_hyper_8_10_chunk.x Filter: _timescaledb_functions.bloom1_contains(compress_hyper_8_10_chunk._ts_meta_v2_bloom1_x, '3f:b6:70:e3:3c:00:00:00'::macaddr8) Rows Removed by Filter: 9 -- Test an array type. create table arraybloom(x int, value int[], ts timestamp); select create_hypertable('arraybloom', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------------- (9,public,arraybloom,t) insert into arraybloom select x, array[x], '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on arraybloom(value); alter table arraybloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('arraybloom') x; count ------- 1 vacuum full analyze arraybloom; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from arraybloom where value = array[7248::int]; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_11_chunk (actual rows=1.00 loops=1) Filter: (_hyper_9_11_chunk.value = '{7248}'::integer[]) Rows Removed by Filter: 999 Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_10_12_chunk (actual rows=1.00 loops=1) Output: compress_hyper_10_12_chunk._ts_meta_count, compress_hyper_10_12_chunk._ts_meta_min_1, compress_hyper_10_12_chunk._ts_meta_max_1, compress_hyper_10_12_chunk.x, compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, compress_hyper_10_12_chunk.value, compress_hyper_10_12_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_10_12_chunk._ts_meta_v2_bloom1_value, '{7248}'::integer[]) Rows Removed by Filter: 9 select count(*) from arraybloom where value = array[7248::int]; count ------- 1 -- Cleanup drop table bloom; drop table corner; drop table badtable; drop table byref; drop table arraybloom; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_bloom_sparse_debug.out��������������������������������0000664�0000000�0000000�00000014255�15100345067�0025743�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; create table test(ts int, s text, c text); select create_hypertable('test', 'ts'); create_hypertable ------------------- (1,public,test,t) alter table test set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into test select ts, ts % 10 s, mix(ts)::text c from generate_series(1, 10000) ts; insert into test select ts, 10 + ts % 10 s, mix(ts % 100)::text c from generate_series(10001, 15000) ts; insert into test select ts, 20 + ts % 10 s, mix(ts % 10)::text c from generate_series(15001, 20000) ts; create index on test using brin(c text_bloom_ops); select count(compress_chunk(x)) from show_chunks('test') x; count ------- 1 -- Test the debug function create or replace function ts_bloom1_debug_info(in _timescaledb_internal.bloom1, out toast_header int, out toasted_bytes int, out compressed_bytes int, out detoasted_bytes int, out bits_total int, out bits_set int, out estimated_elements int) as :TSL_MODULE_PATHNAME, 'ts_bloom1_debug_info' language c immutable parallel safe; select schema_name || '.' || table_name chunk, 'c' column from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test') limit 1) \gset with col as ( select _ts_meta_count rows, _ts_meta_v2_bloom1_:column f, :column cc from :chunk), blooms as ( select *, (ts_bloom1_debug_info(f)).*, pg_column_compression(f) filter_column_compression, pg_column_size(f) filter_column_size from col) select (toast_header::bit(16), bits_total, filter_column_compression) kind, avg(rows)::int rows, count(*), count(*) filter (where _timescaledb_functions.bloom1_contains(f, mix(1)::text)) h, array_agg(distinct bits_total) filter_bit_sizes, array_agg(distinct filter_column_compression) filter_compression_algorithms, round(avg(detoasted_bytes / compressed_bytes::numeric), 2) filter_compression_ratio, avg(estimated_elements)::int estimated_elements, avg(bits_set)::int bits_set, round(avg(pg_column_size(cc)) / (avg(bits_total) / 8.), 2) column_to_filter_ratio from blooms group by 1 order by min(bits_total); kind | rows | count | h | filter_bit_sizes | filter_compression_algorithms | filter_compression_ratio | estimated_elements | bits_set | column_to_filter_ratio --------------------------+------+-------+---+------------------+-------------------------------+--------------------------+--------------------+----------+------------------------ (0000000000010011,64,) | 500 | 10 | 1 | {64} | {NULL} | | 1 | 6 | 9.75 (0000000000100011,128,) | 500 | 10 | 1 | {128} | {NULL} | | 9 | 48 | 31.54 (0000000000000001,8192,) | 1000 | 10 | 1 | {8192} | {NULL} | | 985 | 4211 | 13.61 -- One way to inspect the IO efficiency: ratio of bytes that would have been -- read w/o the index to the sum of bytes read by the bloom filter check -- and the actual column check. with col as ( select _ts_meta_count b, _ts_meta_v2_bloom1_:column f, :column cc from :chunk) select round( sum(pg_column_size(cc))::numeric / (sum(pg_column_size(f)) + sum(pg_column_size(cc)) filter (where _timescaledb_functions.bloom1_contains(f, '0.4067781441845'::text))), 2) from col; round ------- 5.95 -- Compressed bytes-per-value vs bloom filter bytes-per-value. with col as ( select _ts_meta_count rows, _ts_meta_v2_bloom1_:column f, :column cc from :chunk) select round(sum(pg_column_size(cc))::numeric / sum(rows), 2) compressed_bytes_per_row, round(sum(pg_column_size(f))::numeric / sum(rows), 2) filter_bytes_per_row from col; compressed_bytes_per_row | filter_bytes_per_row --------------------------+---------------------- 7.26 | 0.53 -- Test the debug hash function. create or replace function ts_bloom1_debug_hash(in anyelement, out int8) as :TSL_MODULE_PATHNAME, 'ts_bloom1_debug_hash' language c immutable parallel safe; select min(ts_bloom1_debug_hash(c)) from test; min ---------------------- -9221783940407213644 -- This shouldn't change compared to what was released in 2.20, not to break the -- binary compatibility. select ts_bloom1_debug_hash('test'::text); ts_bloom1_debug_hash ---------------------- 505112506223281103 select ts_bloom1_debug_hash('test'::varchar); ts_bloom1_debug_hash ---------------------- 505112506223281103 select ts_bloom1_debug_hash('test'::bpchar); ts_bloom1_debug_hash ---------------------- -8127218844099566047 select ts_bloom1_debug_hash('c9757a73-7632-462e-bcfa-d5d9659e498f'::uuid); ts_bloom1_debug_hash ---------------------- -1807136374307054089 select ts_bloom1_debug_hash(1::int4); ts_bloom1_debug_hash ---------------------- 4717996019076358352 select ts_bloom1_debug_hash(1::int8); ts_bloom1_debug_hash ---------------------- 4717996019076358352 select ts_bloom1_debug_hash(1::float4); ts_bloom1_debug_hash ---------------------- 4033440226552636220 select ts_bloom1_debug_hash(1::float8); ts_bloom1_debug_hash ---------------------- 4033440226552636220 select ts_bloom1_debug_hash('2025-05-05'::date); ts_bloom1_debug_hash ---------------------- -5348595084310508225 select ts_bloom1_debug_hash('2025-05-05'::timestamp); ts_bloom1_debug_hash ---------------------- 6141104473732294652 select ts_bloom1_debug_hash('2025-05-05'::timestamptz); ts_bloom1_debug_hash ---------------------- 2448302731963240730 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_default.out�������������������������������������������0000664�0000000�0000000�00000002704�15100345067�0023530�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Use a weird compression configuration to test decompression of all-default -- batch. create table t(ts int); select create_hypertable('t', 'ts'); create_hypertable ------------------- (1,public,t,t) \set ON_ERROR_STOP 0 alter table t set(timescaledb.compress, timescaledb.compress_segmentby = 'ts', timescaledb.compress_orderby = ''); ERROR: ordering column can not be empty \set ON_ERROR_STOP 1 alter table t set(timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t select generate_series(1, 10000); select count(*) from t; count ------- 10000 select count(compress_chunk(x, true)) from show_chunks('t') x; count ------- 1 select count(*) from t; count ------- 10000 select count(decompress_chunk(x, true)) from show_chunks('t') x; count ------- 1 select count(*) from t; count ------- 10000 -- Now add a column which will be all default in the compressed chunk select count(compress_chunk(x, true)) from show_chunks('t') x; count ------- 1 alter table t add column x int default 7; select count(*), x from t group by x; count | x -------+--- 10000 | 7 select count(decompress_chunk(x, true)) from show_chunks('t') x; count ------- 1 select count(*), x from t group by x; count | x -------+--- 10000 | 7 ������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_dml_copy.out������������������������������������������0000664�0000000�0000000�00000003326�15100345067�0023713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test various cases of COPY with decompression and different chunk layouts. create table cdmlcopy(filler bigint, ts int, value float, metric text); select create_hypertable('cdmlcopy', 'ts', chunk_time_interval => 1000); create_hypertable ----------------------- (1,public,cdmlcopy,t) alter table cdmlcopy add unique (metric, ts); alter table cdmlcopy set (timescaledb.compress, timescaledb.compress_segmentby = 'metric'); \copy cdmlcopy from stdin select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; count ------- 1 alter table cdmlcopy drop column filler; \copy cdmlcopy from stdin select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore count ------- 2 \set ON_ERROR_STOP 0 \copy cdmlcopy from stdin ERROR: duplicate key value violates unique constraint "1_1_cdmlcopy_metric_ts_key" \copy cdmlcopy from stdin ERROR: duplicate key value violates unique constraint "3_2_cdmlcopy_metric_ts_key" \set ON_ERROR_STOP 1 -- Also test the code path where the chunk insert state goes out of cache. set timescaledb.max_open_chunks_per_insert = 1; select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_3_chunk" is already converted to columnstore count ------- 2 \copy cdmlcopy from stdin reset timescaledb.max_open_chunks_per_insert; select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; count ------- 2 drop table cdmlcopy; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_float8_corrupt.out������������������������������������0000664�0000000�0000000�00000122076�15100345067�0025064�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- A test for https://github.com/timescale/timescaledb/issues/6681 -- create hypertable with enabled compression CREATE TABLE corrupt_float8 ( time timestamptz NOT NULL, value double precision NULL ); SELECT create_hypertable('corrupt_float8','time'); create_hypertable ----------------------------- (1,public,corrupt_float8,t) ALTER TABLE corrupt_float8 SET (timescaledb.compress); -- insert these 1000 values INSERT INTO corrupt_float8 VALUES ('2023-09-21 01:47:02.979+00', 11510.1), ('2023-09-21 01:48:03.58+00', 11510.6), ('2023-09-21 01:49:01.92+00', 11511), ('2023-09-21 01:50:02.49+00', 11511.5), ('2023-09-21 01:51:03.057+00', 11511.9), ('2023-09-21 01:52:01.554+00', 11512.4), ('2023-09-21 01:53:02.046+00', 11512.8), ('2023-09-21 01:54:02.826+00', 11513.3), ('2023-09-21 01:55:01.146+00', 11513.7), ('2023-09-21 01:56:01.816+00', 11514.2), ('2023-09-21 01:57:02.965+00', 11514.6), ('2023-09-21 01:58:02.167+00', 11515.1), ('2023-09-21 01:59:02.156+00', 11515.5), ('2023-09-21 02:00:02.447+00', 11516), ('2023-09-21 02:01:02.417+00', 11516.4), ('2023-09-21 02:02:02.581+00', 11516.9), ('2023-09-21 02:03:02.738+00', 11517.3), ('2023-09-21 02:04:03.17+00', 11517.8), ('2023-09-21 02:05:02.911+00', 11518.2), ('2023-09-21 02:06:02.123+00', 11518.7), ('2023-09-21 02:07:02.146+00', 11519.1), ('2023-09-21 02:08:02.247+00', 11519.5), ('2023-09-21 02:09:02.487+00', 11520), ('2023-09-21 02:10:02.804+00', 11520.4), ('2023-09-21 02:11:02.74+00', 11520.9), ('2023-09-21 02:12:02.932+00', 11521.3), ('2023-09-21 02:13:03.136+00', 11521.8), ('2023-09-21 02:14:02.162+00', 11522.2), ('2023-09-21 02:15:02.095+00', 11522.7), ('2023-09-21 02:16:02.506+00', 11523.1), ('2023-09-21 02:17:02.415+00', 11523.6), ('2023-09-21 02:18:02.822+00', 11524), ('2023-09-21 02:19:02.741+00', 11524.5), ('2023-09-21 02:20:02.918+00', 11524.9), ('2023-09-21 02:20:56.717+00', 11525.4), ('2023-09-21 02:21:57.127+00', 11525.8), ('2023-09-21 02:22:55.815+00', 11526.3), ('2023-09-21 02:23:56.451+00', 11526.7), ('2023-09-21 02:24:56.807+00', 11527.2), ('2023-09-21 02:25:55.308+00', 11527.6), ('2023-09-21 02:26:56.045+00', 11528.1), ('2023-09-21 02:27:56.367+00', 11528.5), ('2023-09-21 02:28:57.977+00', 11529), ('2023-09-21 02:29:58.144+00', 11529.4), ('2023-09-21 02:30:58.068+00', 11529.9), ('2023-09-21 02:31:57.158+00', 11530.3), ('2023-09-21 02:32:57.335+00', 11530.8), ('2023-09-21 02:33:57.451+00', 11531.2), ('2023-09-21 02:34:57.638+00', 11531.7), ('2023-09-21 02:35:57.792+00', 11532.1), ('2023-09-21 02:36:58.004+00', 11532.6), ('2023-09-21 02:37:58.344+00', 11533), ('2023-09-21 02:38:58.149+00', 11533.5), ('2023-09-21 02:39:57.412+00', 11533.9), ('2023-09-21 02:40:57.304+00', 11534.4), ('2023-09-21 02:41:57.685+00', 11534.8), ('2023-09-21 02:42:57.646+00', 11535.3), ('2023-09-21 02:43:57.785+00', 11535.7), ('2023-09-21 02:44:58.146+00', 11536.2), ('2023-09-21 02:45:51.775+00', 11536.6), ('2023-09-21 02:46:58.2+00', 11537.1), ('2023-09-21 02:47:57.326+00', 11537.5), ('2023-09-21 02:48:51.291+00', 11538), ('2023-09-21 02:49:51.858+00', 11538.4), ('2023-09-21 02:50:52.619+00', 11538.9), ('2023-09-21 02:51:50.777+00', 11539.3), ('2023-09-21 02:52:51.612+00', 11539.8), ('2023-09-21 02:53:51.985+00', 11540.2), ('2023-09-21 02:54:50.686+00', 11540.7), ('2023-09-21 02:55:51.064+00', 11541.1), ('2023-09-21 02:56:49.45+00', 11541.5), ('2023-09-21 02:57:50.012+00', 11542), ('2023-09-21 02:58:50.812+00', 11542.4), ('2023-09-21 02:59:49.043+00', 11542.9), ('2023-09-21 03:00:49.771+00', 11543.3), ('2023-09-21 03:01:52.277+00', 11543.8), ('2023-09-21 03:02:53.108+00', 11544.2), ('2023-09-21 03:03:53.297+00', 11544.7), ('2023-09-21 03:04:52.198+00', 11545.1), ('2023-09-21 03:05:52.32+00', 11545.6), ('2023-09-21 03:06:52.705+00', 11546), ('2023-09-21 03:07:52.653+00', 11546.5), ('2023-09-21 03:08:53.057+00', 11546.9), ('2023-09-21 03:09:52.978+00', 11547.4), ('2023-09-21 03:10:53.347+00', 11547.8), ('2023-09-21 03:11:53.323+00', 11548.3), ('2023-09-21 03:12:52.369+00', 11548.7), ('2023-09-21 03:13:52.352+00', 11549.2), ('2023-09-21 03:14:47.077+00', 11549.6), ('2023-09-21 03:15:47.383+00', 11550.1), ('2023-09-21 03:16:45.782+00', 11550.5), ('2023-09-21 03:17:46.458+00', 11551), ('2023-09-21 03:18:47.182+00', 11551.4), ('2023-09-21 03:19:47.6+00', 11551.9), ('2023-09-21 03:20:45.985+00', 11552.3), ('2023-09-21 03:21:46.534+00', 11552.7), ('2023-09-21 03:22:44.923+00', 11553.2), ('2023-09-21 03:23:45.56+00', 11553.6), ('2023-09-21 03:24:46.298+00', 11554.1), ('2023-09-21 03:25:44.604+00', 11554.5), ('2023-09-21 03:26:45.336+00', 11555), ('2023-09-21 03:27:45.636+00', 11555.4), ('2023-09-21 03:28:44.379+00', 11555.9), ('2023-09-21 03:29:44.737+00', 11556.3), ('2023-09-21 03:30:45.456+00', 11556.8), ('2023-09-21 03:31:43.739+00', 11557.2), ('2023-09-21 03:32:44.469+00', 11557.7), ('2023-09-21 03:33:42.794+00', 11558.1), ('2023-09-21 03:34:43.601+00', 11558.6), ('2023-09-21 03:35:43.845+00', 11559), ('2023-09-21 03:36:43.557+00', 11559.5), ('2023-09-21 03:37:44.316+00', 11559.9), ('2023-09-21 03:38:43.429+00', 11560.4), ('2023-09-21 03:39:42.446+00', 11560.8), ('2023-09-21 03:40:42.807+00', 11561.3), ('2023-09-21 03:41:43.031+00', 11561.7), ('2023-09-21 03:42:43.143+00', 11562.2), ('2023-09-21 03:43:43.107+00', 11562.6), ('2023-09-21 03:44:43.412+00', 11563.1), ('2023-09-21 03:45:43.438+00', 11563.5), ('2023-09-21 03:46:43.625+00', 11564), ('2023-09-21 03:47:42.403+00', 11564.4), ('2023-09-21 03:48:42.798+00', 11564.8), ('2023-09-21 03:49:42.735+00', 11565.3), ('2023-09-21 03:50:43.084+00', 11565.7), ('2023-09-21 03:51:43.065+00', 11566.2), ('2023-09-21 03:52:43.273+00', 11566.6), ('2023-09-21 03:53:43.627+00', 11567.1), ('2023-09-21 03:54:43.503+00', 11567.5), ('2023-09-21 03:55:42.395+00', 11568), ('2023-09-21 03:56:42.804+00', 11568.4), ('2023-09-21 03:57:42.73+00', 11568.9), ('2023-09-21 03:58:42.866+00', 11569.3), ('2023-09-21 03:59:43.089+00', 11569.8), ('2023-09-21 04:00:43.191+00', 11570.2), ('2023-09-21 04:01:43.656+00', 11570.7), ('2023-09-21 04:02:43.518+00', 11571.1), ('2023-09-21 04:03:42.432+00', 11571.6), ('2023-09-21 04:04:42.773+00', 11572), ('2023-09-21 04:05:42.751+00', 11572.5), ('2023-09-21 04:06:42.883+00', 11572.9), ('2023-09-21 04:07:43.263+00', 11573.4), ('2023-09-21 04:08:37.077+00', 11573.8), ('2023-09-21 04:09:37.691+00', 11574.3), ('2023-09-21 04:10:38.38+00', 11574.7), ('2023-09-21 04:11:36.603+00', 11575.2), ('2023-09-21 04:12:37.418+00', 11575.6), ('2023-09-21 04:13:37.783+00', 11576.1), ('2023-09-21 04:14:36.29+00', 11576.5), ('2023-09-21 04:15:36.894+00', 11576.9), ('2023-09-21 04:16:35.21+00', 11577.4), ('2023-09-21 04:17:35.845+00', 11577.8), ('2023-09-21 04:18:36.612+00', 11578.3), ('2023-09-21 04:19:34.883+00', 11578.7), ('2023-09-21 04:20:35.386+00', 11579.2), ('2023-09-21 04:21:35.932+00', 11579.6), ('2023-09-21 04:22:34.707+00', 11580.1), ('2023-09-21 04:23:34.972+00', 11580.5), ('2023-09-21 04:24:35.399+00', 11581), ('2023-09-21 04:25:34.019+00', 11581.4), ('2023-09-21 04:26:34.753+00', 11581.9), ('2023-09-21 04:27:35.001+00', 11582.3), ('2023-09-21 04:28:33.671+00', 11582.8), ('2023-09-21 04:29:34.134+00', 11583.2), ('2023-09-21 04:30:32.864+00', 11583.7), ('2023-09-21 04:31:33.162+00', 11584.1), ('2023-09-21 04:32:33.664+00', 11584.6), ('2023-09-21 04:33:33.127+00', 11585), ('2023-09-21 04:34:32.725+00', 11585.5), ('2023-09-21 04:35:33.492+00', 11585.9), ('2023-09-21 04:36:33.81+00', 11586.4), ('2023-09-21 04:37:32.392+00', 11586.8), ('2023-09-21 04:38:32.822+00', 11587.3), ('2023-09-21 04:39:34.116+00', 11587.7), ('2023-09-21 04:40:31.785+00', 11588.2), ('2023-09-21 04:41:32.284+00', 11588.6), ('2023-09-21 04:42:31.139+00', 11589.1), ('2023-09-21 04:43:31.423+00', 11589.5), ('2023-09-21 04:44:31.965+00', 11590), ('2023-09-21 04:45:30.468+00', 11590.4), ('2023-09-21 04:46:30.953+00', 11590.9), ('2023-09-21 04:47:31.54+00', 11591.3), ('2023-09-21 04:48:29.913+00', 11591.8), ('2023-09-21 04:49:30.531+00', 11592.2), ('2023-09-21 04:50:28.958+00', 11592.7), ('2023-09-21 04:51:29.642+00', 11593.1), ('2023-09-21 04:52:30.051+00', 11593.6), ('2023-09-21 04:53:28.669+00', 11594), ('2023-09-21 04:54:29.338+00', 11594.5), ('2023-09-21 04:55:29.727+00', 11594.9), ('2023-09-21 04:56:28.166+00', 11595.4), ('2023-09-21 04:57:28.687+00', 11595.8), ('2023-09-21 04:58:29.489+00', 11596.3), ('2023-09-21 04:59:27.771+00', 11596.7), ('2023-09-21 05:00:28.293+00', 11597.2), ('2023-09-21 05:01:28.719+00', 11597.6), ('2023-09-21 05:02:27.536+00', 11598.1), ('2023-09-21 05:03:27.875+00', 11598.5), ('2023-09-21 05:04:28.608+00', 11599), ('2023-09-21 05:05:26.938+00', 11599.4), ('2023-09-21 05:06:27.614+00', 11599.9), ('2023-09-21 05:07:25.913+00', 11600.3), ('2023-09-21 05:08:26.482+00', 11600.8), ('2023-09-21 05:09:27.02+00', 11601.2), ('2023-09-21 05:10:25.724+00', 11601.7), ('2023-09-21 05:11:28.978+00', 11602.1), ('2023-09-21 05:12:29.345+00', 11602.6), ('2023-09-21 05:13:29.338+00', 11603), ('2023-09-21 05:14:29.482+00', 11603.5), ('2023-09-21 05:15:29.81+00', 11603.9), ('2023-09-21 05:16:29.778+00', 11604.4), ('2023-09-21 05:17:29.805+00', 11604.8), ('2023-09-21 05:18:29.015+00', 11605.3), ('2023-09-21 05:19:28.97+00', 11605.7), ('2023-09-21 05:20:29.351+00', 11606.2), ('2023-09-21 05:21:29.312+00', 11606.6), ('2023-09-21 05:22:29.46+00', 11607.1), ('2023-09-21 05:23:29.721+00', 11607.5), ('2023-09-21 05:24:22.792+00', 11608), ('2023-09-21 05:25:23.341+00', 11608.4), ('2023-09-21 05:26:28.889+00', 11608.9), ('2023-09-21 05:27:29.059+00', 11609.3), ('2023-09-21 05:28:23.166+00', 11609.8), ('2023-09-21 05:29:23.487+00', 11610.2), ('2023-09-21 05:30:21.988+00', 11610.7), ('2023-09-21 05:31:22.489+00', 11611.1), ('2023-09-21 05:32:23.127+00', 11611.6), ('2023-09-21 05:33:21.422+00', 11612), ('2023-09-21 05:34:22.057+00', 11612.5), ('2023-09-21 05:35:22.46+00', 11612.9), ('2023-09-21 05:36:21.052+00', 11613.4), ('2023-09-21 05:37:21.574+00', 11613.8), ('2023-09-21 05:38:22.161+00', 11614.3), ('2023-09-21 05:39:20.551+00', 11614.7), ('2023-09-21 05:40:23.755+00', 11615.2), ('2023-09-21 05:41:24.794+00', 11615.6), ('2023-09-21 05:42:23.801+00', 11616.1), ('2023-09-21 05:43:23.864+00', 11616.5), ('2023-09-21 05:44:24.049+00', 11617), ('2023-09-21 05:45:24.428+00', 11617.4), ('2023-09-21 05:46:24.395+00', 11617.9), ('2023-09-21 05:47:18.864+00', 11618.3), ('2023-09-21 05:48:19.389+00', 11618.8), ('2023-09-21 05:49:20.095+00', 11619.2), ('2023-09-21 05:50:18.402+00', 11619.7), ('2023-09-21 05:51:18.817+00', 11620.1), ('2023-09-21 05:52:19.442+00', 11620.6), ('2023-09-21 05:53:17.993+00', 11621), ('2023-09-21 05:54:18.579+00', 11621.5), ('2023-09-21 05:55:19.253+00', 11621.9), ('2023-09-21 05:56:17.538+00', 11622.4), ('2023-09-21 05:57:18.311+00', 11622.8), ('2023-09-21 05:58:18.536+00', 11623.3), ('2023-09-21 05:59:17.092+00', 11623.7), ('2023-09-21 06:00:17.608+00', 11624.2), ('2023-09-21 06:01:18.148+00', 11624.6), ('2023-09-21 06:02:16.704+00', 11625.1), ('2023-09-21 06:03:17.407+00', 11625.5), ('2023-09-21 06:04:15.791+00', 11626), ('2023-09-21 06:05:16.247+00', 11626.4), ('2023-09-21 06:06:16.787+00', 11626.9), ('2023-09-21 06:07:17.481+00', 11627.3), ('2023-09-21 06:08:15.829+00', 11627.8), ('2023-09-21 06:09:16.542+00', 11628.2), ('2023-09-21 06:10:14.868+00', 11628.7), ('2023-09-21 06:11:15.393+00', 11629.1), ('2023-09-21 06:12:15.852+00', 11629.6), ('2023-09-21 06:13:14.443+00', 11630.1), ('2023-09-21 06:14:16.033+00', 11630.5), ('2023-09-21 06:15:16.215+00', 11631), ('2023-09-21 06:16:16.338+00', 11631.4), ('2023-09-21 06:17:14.444+00', 11631.9), ('2023-09-21 06:18:15.135+00', 11632.3), ('2023-09-21 06:19:13.871+00', 11632.8), ('2023-09-21 06:20:14.107+00', 11633.2), ('2023-09-21 06:21:12.515+00', 11633.7), ('2023-09-21 06:22:13.252+00', 11634.1), ('2023-09-21 06:23:13.651+00', 11634.6), ('2023-09-21 06:24:14.148+00', 11635.1), ('2023-09-21 06:25:12.924+00', 11635.5), ('2023-09-21 06:26:13.286+00', 11636), ('2023-09-21 06:27:11.948+00', 11636.4), ('2023-09-21 06:28:12.262+00', 11636.9), ('2023-09-21 06:29:13.047+00', 11637.3), ('2023-09-21 06:30:11.366+00', 11637.8), ('2023-09-21 06:31:11.891+00', 11638.2), ('2023-09-21 06:32:12.416+00', 11638.7), ('2023-09-21 06:33:11.149+00', 11639.2), ('2023-09-21 06:34:11.408+00', 11639.6), ('2023-09-21 06:35:11.948+00', 11640.1), ('2023-09-21 06:36:10.468+00', 11640.5), ('2023-09-21 06:37:11.025+00', 11641), ('2023-09-21 06:38:09.54+00', 11641.4), ('2023-09-21 06:39:10.056+00', 11641.9), ('2023-09-21 06:40:10.609+00', 11642.4), ('2023-09-21 06:41:09.119+00', 11642.8), ('2023-09-21 06:42:09.584+00', 11643.3), ('2023-09-21 06:43:10.271+00', 11643.7), ('2023-09-21 06:44:08.672+00', 11644.2), ('2023-09-21 06:45:09.145+00', 11644.6), ('2023-09-21 06:46:09.605+00', 11645.1), ('2023-09-21 06:47:11.081+00', 11645.6), ('2023-09-21 06:48:11.102+00', 11646), ('2023-09-21 06:49:10.165+00', 11646.5), ('2023-09-21 06:50:10.302+00', 11646.9), ('2023-09-21 06:51:10.416+00', 11647.4), ('2023-09-21 06:52:10.651+00', 11647.8), ('2023-09-21 06:53:10.815+00', 11648.3), ('2023-09-21 06:54:11.113+00', 11648.8), ('2023-09-21 06:55:11.041+00', 11649.2), ('2023-09-21 06:56:11.373+00', 11649.7), ('2023-09-21 06:57:10.195+00', 11650.1), ('2023-09-21 06:58:10.392+00', 11650.6), ('2023-09-21 06:59:10.447+00', 11651), ('2023-09-21 07:00:10.605+00', 11651.5), ('2023-09-21 07:01:10.186+00', 11652), ('2023-09-21 07:02:10.96+00', 11652.4), ('2023-09-21 07:03:11.098+00', 11652.9), ('2023-09-21 07:04:11.103+00', 11653.3), ('2023-09-21 07:05:10.124+00', 11653.8), ('2023-09-21 07:06:10.018+00', 11654.2), ('2023-09-21 07:07:04.697+00', 11654.7), ('2023-09-21 07:08:05.308+00', 11655.2), ('2023-09-21 07:09:05.957+00', 11655.6), ('2023-09-21 07:10:05.837+00', 11656.1), ('2023-09-21 07:11:05.948+00', 11656.5), ('2023-09-21 07:12:06.985+00', 11657), ('2023-09-21 07:13:03.86+00', 11657.4), ('2023-09-21 07:14:04.378+00', 11657.9), ('2023-09-21 07:15:04.933+00', 11658.3), ('2023-09-21 07:16:03.452+00', 11658.8), ('2023-09-21 07:17:03.96+00', 11659.3), ('2023-09-21 07:18:02.426+00', 11659.7), ('2023-09-21 07:19:02.987+00', 11660.2), ('2023-09-21 07:20:03.485+00', 11660.6), ('2023-09-21 07:21:01.898+00', 11661.1), ('2023-09-21 07:22:02.569+00', 11661.5), ('2023-09-21 07:23:03.288+00', 11662), ('2023-09-21 07:24:01.604+00', 11662.5), ('2023-09-21 07:25:02.039+00', 11662.9), ('2023-09-21 07:26:02.688+00', 11663.4), ('2023-09-21 07:27:01.368+00', 11663.8), ('2023-09-21 07:28:01.709+00', 11664.3), ('2023-09-21 07:29:02.413+00', 11664.7), ('2023-09-21 07:30:03.995+00', 11665.2), ('2023-09-21 07:31:04.014+00', 11665.6), ('2023-09-21 07:32:04.187+00', 11666.1), ('2023-09-21 07:33:04.579+00', 11666.6), ('2023-09-21 07:34:04.576+00', 11667), ('2023-09-21 07:35:04.743+00', 11667.5), ('2023-09-21 07:36:04.816+00', 11667.9), ('2023-09-21 07:37:03.935+00', 11668.4), ('2023-09-21 07:38:03.944+00', 11668.8), ('2023-09-21 07:39:04.262+00', 11669.3), ('2023-09-21 07:40:04.182+00', 11669.7), ('2023-09-21 07:40:58.554+00', 11670.2), ('2023-09-21 07:41:59.049+00', 11670.6), ('2023-09-21 07:42:59.797+00', 11671.1), ('2023-09-21 07:43:58.071+00', 11671.6), ('2023-09-21 07:44:58.855+00', 11672), ('2023-09-21 07:45:59.156+00', 11672.5), ('2023-09-21 07:46:57.866+00', 11672.9), ('2023-09-21 07:47:58.175+00', 11673.4), ('2023-09-21 07:48:58.634+00', 11673.8), ('2023-09-21 07:49:57.234+00', 11674.3), ('2023-09-21 07:50:57.819+00', 11674.7), ('2023-09-21 07:51:58.313+00', 11675.2), ('2023-09-21 07:52:56.995+00', 11675.6), ('2023-09-21 07:53:57.402+00', 11676.1), ('2023-09-21 07:54:55.891+00', 11676.6), ('2023-09-21 07:55:56.369+00', 11677), ('2023-09-21 07:56:57.119+00', 11677.5), ('2023-09-21 07:57:55.453+00', 11677.9), ('2023-09-21 07:58:56.174+00', 11678.4), ('2023-09-21 07:59:56.469+00', 11678.8), ('2023-09-21 08:00:55.199+00', 11679.3), ('2023-09-21 08:01:55.557+00', 11679.7), ('2023-09-21 08:02:56.072+00', 11680.2), ('2023-09-21 08:03:54.811+00', 11680.6), ('2023-09-21 08:04:55.138+00', 11681.1), ('2023-09-21 08:05:55.696+00', 11681.6), ('2023-09-21 08:06:54.367+00', 11682),('2023-09-21 08:07:54.539+00', 11682.5), ('2023-09-21 08:08:55.395+00', 11682.9), ('2023-09-21 08:09:53.689+00', 11683.4), ('2023-09-21 08:10:54.472+00', 11683.8), ('2023-09-21 08:11:52.816+00', 11684.3),('2023-09-21 08:12:53.36+00', 11684.7), ('2023-09-21 08:13:53.873+00', 11685.2), ('2023-09-21 08:14:52.398+00', 11685.6), ('2023-09-21 08:15:53.109+00', 11686.1), ('2023-09-21 08:16:53.569+00', 11686.5), ('2023-09-21 08:17:51.902+00', 11687), ('2023-09-21 08:18:52.423+00', 11687.5), ('2023-09-21 08:19:53.196+00', 11687.9), ('2023-09-21 08:20:51.481+00', 11688.4), ('2023-09-21 08:21:52.268+00', 11688.8),('2023-09-21 08:22:53.475+00', 11689.3), ('2023-09-21 08:23:53.368+00', 11689.7), ('2023-09-21 08:24:51.489+00', 11690.2), ('2023-09-21 08:25:50.098+00', 11690.6), ('2023-09-21 08:26:50.545+00', 11691.1), ('2023-09-21 08:27:51.451+00', 11691.5), ('2023-09-21 08:28:51.869+00', 11692), ('2023-09-21 08:29:50.213+00', 11692.5), ('2023-09-21 08:30:50.808+00', 11692.9), ('2023-09-21 08:31:49.158+00', 11693.4), ('2023-09-21 08:32:49.82+00', 11693.8), ('2023-09-21 08:33:50.416+00', 11694.3), ('2023-09-21 08:34:48.849+00', 11694.7), ('2023-09-21 08:35:49.29+00', 11695.2), ('2023-09-21 08:36:49.922+00', 11695.6), ('2023-09-21 08:37:48.329+00', 11696.1), ('2023-09-21 08:38:48.988+00', 11696.6), ('2023-09-21 08:39:49.492+00', 11697), ('2023-09-21 08:40:47.935+00', 11697.5), ('2023-09-21 08:41:48.595+00', 11697.9), ('2023-09-21 08:42:47.033+00', 11698.4), ('2023-09-21 08:43:47.533+00', 11698.8), ('2023-09-21 08:44:48.1+00', 11699.3), ('2023-09-21 08:45:48.509+00', 11699.7), ('2023-09-21 08:46:47.043+00', 11700.2), ('2023-09-21 08:47:47.651+00', 11700.6), ('2023-09-21 08:48:48.275+00', 11701.1), ('2023-09-21 08:49:46.592+00', 11701.5), ('2023-09-21 08:50:47.252+00', 11702), ('2023-09-21 08:51:45.76+00', 11702.5), ('2023-09-21 08:52:46.439+00', 11702.9), ('2023-09-21 08:53:46.835+00', 11703.4), ('2023-09-21 08:54:45.358+00', 11703.8), ('2023-09-21 08:55:46.072+00', 11704.3), ('2023-09-21 08:56:46.419+00', 11704.7), ('2023-09-21 08:57:45.119+00', 11705.2), ('2023-09-21 08:58:45.536+00', 11705.6), ('2023-09-21 08:59:45.95+00', 11706.1), ('2023-09-21 09:00:44.454+00', 11706.5), ('2023-09-21 09:01:45.887+00', 11707), ('2023-09-21 09:02:45.451+00', 11707.4), ('2023-09-21 09:03:43.964+00', 11707.9), ('2023-09-21 09:04:44.669+00', 11708.4), ('2023-09-21 09:05:43.095+00', 11708.8), ('2023-09-21 09:06:43.746+00', 11709.3), ('2023-09-21 09:07:44.38+00', 11709.7), ('2023-09-21 09:08:42.674+00', 11710.2), ('2023-09-21 09:09:43.368+00', 11710.6), ('2023-09-21 09:10:43.729+00', 11711.1), ('2023-09-21 09:11:42.397+00', 11711.5), ('2023-09-21 09:12:42.799+00', 11712), ('2023-09-21 09:13:43.478+00', 11712.4), ('2023-09-21 09:14:41.831+00', 11712.9), ('2023-09-21 09:15:42.571+00', 11713.4), ('2023-09-21 09:16:42.938+00', 11713.8), ('2023-09-21 09:17:41.378+00', 11714.3), ('2023-09-21 09:18:41.944+00', 11714.7), ('2023-09-21 09:19:42.644+00', 11715.2), ('2023-09-21 09:20:40.934+00', 11715.6), ('2023-09-21 09:21:41.641+00', 11716.1), ('2023-09-21 09:22:41.987+00', 11716.5), ('2023-09-21 09:23:40.707+00', 11717), ('2023-09-21 09:24:41.053+00', 11717.5), ('2023-09-21 09:25:41.714+00', 11717.9), ('2023-09-21 09:26:40.355+00', 11718.4), ('2023-09-21 09:27:40.575+00', 11718.8), ('2023-09-21 09:28:40.676+00', 11719.3), ('2023-09-21 09:29:40.733+00', 11719.8), ('2023-09-21 09:30:40.143+00', 11720.2), ('2023-09-21 09:31:39.855+00', 11720.7), ('2023-09-21 09:32:40.03+00', 11721.2), ('2023-09-21 09:33:40.392+00', 11721.6), ('2023-09-21 09:34:40.367+00', 11722.1), ('2023-09-21 09:35:40.537+00', 11722.6), ('2023-09-21 09:36:40.654+00', 11723), ('2023-09-21 09:37:40.918+00', 11723.5), ('2023-09-21 09:38:39.712+00', 11724), ('2023-09-21 09:39:40.146+00', 11724.4), ('2023-09-21 09:40:39.999+00', 11724.9), ('2023-09-21 09:41:40.216+00', 11725.4), ('2023-09-21 09:42:40.392+00', 11725.8), ('2023-09-21 09:43:40.541+00', 11726.3), ('2023-09-21 09:44:40.68+00', 11726.8), ('2023-09-21 09:45:40.815+00', 11727.2), ('2023-09-21 09:46:40.768+00', 11727.7), ('2023-09-21 09:47:40.039+00', 11728.1), ('2023-09-21 09:48:40.001+00', 11728.6), ('2023-09-21 09:49:36.444+00', 11729.1), ('2023-09-21 09:50:36.697+00', 11729.5), ('2023-09-21 09:51:35.355+00', 11730), ('2023-09-21 09:52:35.677+00', 11730.5), ('2023-09-21 09:53:36.315+00', 11730.9), ('2023-09-21 09:54:34.723+00', 11731.4), ('2023-09-21 09:55:35.299+00', 11731.9), ('2023-09-21 09:56:35.851+00', 11732.3), ('2023-09-21 09:57:34.322+00', 11732.8), ('2023-09-21 09:58:35.417+00', 11733.2), ('2023-09-21 09:59:35.401+00', 11733.7), ('2023-09-21 10:00:35.567+00', 11734.2), ('2023-09-21 10:01:35.55+00', 11734.6), ('2023-09-21 10:02:34.606+00', 11735.1), ('2023-09-21 10:03:34.787+00', 11735.6), ('2023-09-21 10:04:35.087+00', 11736), ('2023-09-21 10:05:35.1+00', 11736.5), ('2023-09-21 10:06:35.482+00', 11737), ('2023-09-21 10:07:38.022+00', 11737.4), ('2023-09-21 10:08:32.068+00', 11737.9), ('2023-09-21 10:09:32.563+00', 11738.4), ('2023-09-21 10:10:34.745+00', 11738.8), ('2023-09-21 10:11:31.612+00', 11739.3), ('2023-09-21 10:12:32.372+00', 11739.8), ('2023-09-21 10:13:30.661+00', 11740.2), ('2023-09-21 10:14:31.241+00', 11740.7), ('2023-09-21 10:15:31.732+00', 11741.1), ('2023-09-21 10:16:30.403+00', 11741.6), ('2023-09-21 10:17:30.774+00', 11742.1), ('2023-09-21 10:18:31.534+00', 11742.5), ('2023-09-21 10:19:29.866+00', 11743), ('2023-09-21 10:20:30.35+00', 11743.5),('2023-09-21 10:21:30.874+00', 11743.9), ('2023-09-21 10:22:29.553+00', 11744.4), ('2023-09-21 10:23:29.869+00', 11744.9), ('2023-09-21 10:24:30.676+00', 11745.3), ('2023-09-21 10:25:28.967+00', 11745.8), ('2023-09-21 10:26:29.472+00', 11746.2), ('2023-09-21 10:27:29.967+00', 11746.7), ('2023-09-21 10:28:28.424+00', 11747.2), ('2023-09-21 10:29:31.324+00', 11747.6), ('2023-09-21 10:30:31.457+00', 11748.1), ('2023-09-21 10:31:30.26+00', 11748.6), ('2023-09-21 10:32:28.606+00', 11749), ('2023-09-21 10:33:29.332+00', 11749.5), ('2023-09-21 10:34:29.651+00', 11750), ('2023-09-21 10:35:29.608+00', 11750.4), ('2023-09-21 10:36:29.987+00', 11750.9), ('2023-09-21 10:37:30.03+00', 11751.3), ('2023-09-21 10:38:30.122+00', 11751.8), ('2023-09-21 10:39:28.979+00', 11752.3), ('2023-09-21 10:40:29.138+00', 11752.7), ('2023-09-21 10:41:29.347+00', 11753.2), ('2023-09-21 10:42:29.681+00', 11753.6), ('2023-09-21 10:43:29.631+00', 11754.1), ('2023-09-21 10:44:29.887+00', 11754.6), ('2023-09-21 10:45:29.97+00', 11755), ('2023-09-21 10:46:30.025+00', 11755.5), ('2023-09-21 10:47:29.226+00', 11755.9), ('2023-09-21 10:48:29.189+00', 11756.4), ('2023-09-21 10:49:29.301+00', 11756.8), ('2023-09-21 10:50:29.486+00', 11757.3), ('2023-09-21 10:51:29.688+00', 11757.8), ('2023-09-21 10:52:29.971+00', 11758.2), ('2023-09-21 10:53:29.963+00', 11758.7), ('2023-09-21 10:54:30.021+00', 11759.1), ('2023-09-21 10:55:28.991+00', 11759.6), ('2023-09-21 10:56:23.028+00', 11760), ('2023-09-21 10:57:23.685+00', 11760.5), ('2023-09-21 10:58:24.122+00', 11761), ('2023-09-21 10:59:24.993+00', 11761.4), ('2023-09-21 11:00:24.91+00', 11761.9), ('2023-09-21 11:01:28.903+00', 11762.3), ('2023-09-21 11:02:22.265+00', 11762.8), ('2023-09-21 11:03:25.233+00', 11763.2), ('2023-09-21 11:04:26.619+00', 11763.7), ('2023-09-21 11:05:26.779+00', 11764.2), ('2023-09-21 11:06:27.107+00', 11764.6), ('2023-09-21 11:07:27.037+00', 11765.1), ('2023-09-21 11:08:27.222+00', 11765.5), ('2023-09-21 11:09:27.252+00', 11766), ('2023-09-21 11:10:26.536+00', 11766.4), ('2023-09-21 11:11:21.076+00', 11766.9), ('2023-09-21 11:12:21.514+00', 11767.3), ('2023-09-21 11:13:22.228+00', 11767.8), ('2023-09-21 11:14:20.66+00', 11768.2), ('2023-09-21 11:15:21.099+00', 11768.7), ('2023-09-21 11:16:19.7+00', 11769.1), ('2023-09-21 11:17:20.101+00', 11769.6), ('2023-09-21 11:18:20.629+00', 11770.1), ('2023-09-21 11:19:19.144+00', 11770.5), ('2023-09-21 11:20:19.682+00', 11771), ('2023-09-21 11:21:20.096+00', 11771.4), ('2023-09-21 11:22:18.827+00', 11771.9), ('2023-09-21 11:23:19.092+00', 11772.3), ('2023-09-21 11:24:19.848+00', 11772.8), ('2023-09-21 11:25:18.18+00', 11773.2), ('2023-09-21 11:26:18.847+00', 11773.7), ('2023-09-21 11:27:19.375+00', 11774.1), ('2023-09-21 11:28:17.932+00', 11774.6), ('2023-09-21 11:29:18.24+00', 11775), ('2023-09-21 11:30:16.906+00', 11775.5), ('2023-09-21 11:31:17.314+00', 11775.9), ('2023-09-21 11:32:20.845+00', 11776.4), ('2023-09-21 11:33:18.501+00', 11776.9), ('2023-09-21 11:34:17.06+00', 11777.3), ('2023-09-21 11:35:17.405+00', 11777.8), ('2023-09-21 11:36:16.025+00', 11778.2), ('2023-09-21 11:37:16.534+00', 11778.7), ('2023-09-21 11:38:16.981+00', 11779.1), ('2023-09-21 11:39:15.554+00', 11779.6), ('2023-09-21 11:40:16.115+00', 11780), ('2023-09-21 11:41:16.68+00', 11780.5), ('2023-09-21 11:42:15.136+00', 11780.9), ('2023-09-21 11:43:15.916+00', 11781.4), ('2023-09-21 11:44:16.234+00', 11781.8), ('2023-09-21 11:45:14.933+00', 11782.3), ('2023-09-21 11:46:15.224+00', 11782.7), ('2023-09-21 11:47:15.665+00', 11783.2), ('2023-09-21 11:48:14.307+00', 11783.6), ('2023-09-21 11:49:14.827+00', 11784.1), ('2023-09-21 11:50:18.735+00', 11784.5), ('2023-09-21 11:51:16.13+00', 11785), ('2023-09-21 11:52:16.147+00', 11785.4), ('2023-09-21 11:53:15.412+00', 11785.9), ('2023-09-21 11:54:15.415+00', 11786.3), ('2023-09-21 11:55:15.755+00', 11786.8), ('2023-09-21 11:56:15.768+00', 11787.2), ('2023-09-21 11:57:16.069+00', 11787.7), ('2023-09-21 11:58:16.037+00', 11788.1), ('2023-09-21 11:59:16.23+00', 11788.6), ('2023-09-21 12:00:16.24+00', 11789), ('2023-09-21 12:01:12.992+00', 11789.5), ('2023-09-21 12:02:11.59+00', 11789.9), ('2023-09-21 12:03:12.348+00', 11790.4), ('2023-09-21 12:04:12.664+00', 11790.8), ('2023-09-21 12:05:11.419+00', 11791.3), ('2023-09-21 12:06:11.719+00', 11791.7), ('2023-09-21 12:07:10.443+00', 11792.2), ('2023-09-21 12:08:10.8+00', 11792.6), ('2023-09-21 12:09:11.316+00', 11793.1), ('2023-09-21 12:10:09.786+00', 11793.5), ('2023-09-21 12:11:10.404+00', 11794), ('2023-09-21 12:12:10.908+00', 11794.4), ('2023-09-21 12:13:10.951+00', 11794.9), ('2023-09-21 12:14:10.929+00', 11795.3), ('2023-09-21 12:15:11.16+00', 11795.8), ('2023-09-21 12:16:11.263+00', 11796.2), ('2023-09-21 12:17:09.518+00', 11796.6), ('2023-09-21 12:18:10.283+00', 11797.1), ('2023-09-21 12:19:10.559+00', 11797.5), ('2023-09-21 12:20:11.842+00', 11798), ('2023-09-21 12:21:09.596+00', 11798.4), ('2023-09-21 12:22:08.003+00', 11798.9), ('2023-09-21 12:23:08.591+00', 11799.3), ('2023-09-21 12:24:09.11+00', 11799.8), ('2023-09-21 12:25:07.746+00', 11800.2), ('2023-09-21 12:26:08.472+00', 11800.7), ('2023-09-21 12:27:06.725+00', 11801.1), ('2023-09-21 12:28:07.322+00', 11801.6), ('2023-09-21 12:29:07.773+00', 11802), ('2023-09-21 12:30:06.47+00', 11802.4), ('2023-09-21 12:31:06.836+00', 11802.9), ('2023-09-21 12:32:07.465+00', 11803.3), ('2023-09-21 12:33:05.827+00', 11803.8), ('2023-09-21 12:34:06.427+00', 11804.2), ('2023-09-21 12:35:06.883+00', 11804.7), ('2023-09-21 12:36:05.623+00', 11805.1), ('2023-09-21 12:37:09.441+00', 11805.6), ('2023-09-21 12:38:09.018+00', 11806), ('2023-09-21 12:39:09.77+00', 11806.5), ('2023-09-21 12:40:05.987+00', 11806.9), ('2023-09-21 12:41:06.134+00', 11807.4), ('2023-09-21 12:42:04.763+00', 11807.8), ('2023-09-21 12:43:05.215+00', 11808.3), ('2023-09-21 12:44:03.786+00', 11808.7), ('2023-09-21 12:45:06.96+00', 11809.2), ('2023-09-21 12:46:07.047+00', 11809.6), ('2023-09-21 12:47:03.313+00', 11810.1), ('2023-09-21 12:48:03.766+00', 11810.5), ('2023-09-21 12:49:04.268+00', 11811), ('2023-09-21 12:50:02.874+00', 11811.4), ('2023-09-21 12:51:03.321+00', 11811.8), ('2023-09-21 12:52:04.015+00', 11812.3), ('2023-09-21 12:53:02.348+00', 11812.7), ('2023-09-21 12:54:02.87+00', 11813.2), ('2023-09-21 12:55:03.392+00', 11813.6), ('2023-09-21 12:56:02.056+00', 11814.1), ('2023-09-21 12:57:02.546+00', 11814.5), ('2023-09-21 12:58:06.511+00', 11815), ('2023-09-21 12:59:02.926+00', 11815.4), ('2023-09-21 13:00:02.203+00', 11815.9), ('2023-09-21 13:01:00.586+00', 11816.3), ('2023-09-21 13:02:01.156+00', 11816.8), ('2023-09-21 13:03:01.737+00', 11817.2), ('2023-09-21 13:04:00.227+00', 11817.7), ('2023-09-21 13:05:00.75+00', 11818.1), ('2023-09-21 13:06:01.276+00', 11818.6), ('2023-09-21 13:07:00.013+00', 11819), ('2023-09-21 13:08:00.403+00', 11819.5), ('2023-09-21 13:09:00.719+00', 11819.9), ('2023-09-21 13:10:00.882+00', 11820.4), ('2023-09-21 13:11:03.409+00', 11820.8), ('2023-09-21 13:12:00.495+00', 11821.3), ('2023-09-21 13:12:58.86+00', 11821.7), ('2023-09-21 13:14:03.981+00', 11822.2), ('2023-09-21 13:15:00.279+00', 11822.6), ('2023-09-21 13:16:00.353+00', 11823.1), ('2023-09-21 13:17:00.498+00', 11823.5), ('2023-09-21 13:17:57.688+00', 11824), ('2023-09-21 13:18:57.933+00', 11824.4), ('2023-09-21 13:19:58.472+00', 11824.9), ('2023-09-21 13:20:57.313+00', 11825.3), ('2023-09-21 13:21:57.631+00', 11825.8), ('2023-09-21 13:22:58.245+00', 11826.2), ('2023-09-21 13:24:01.669+00', 11826.7), ('2023-09-21 13:25:02.019+00', 11827.1), ('2023-09-21 13:26:02.019+00', 11827.6), ('2023-09-21 13:26:59.552+00', 11828), ('2023-09-21 13:27:59.704+00', 11828.5), ('2023-09-21 13:28:58.61+00', 11828.9), ('2023-09-21 13:29:58.764+00', 11829.4), ('2023-09-21 13:30:58.875+00', 11829.8), ('2023-09-21 13:31:59.107+00', 11830.3), ('2023-09-21 13:33:00.545+00', 11830.7), ('2023-09-21 13:34:00.709+00', 11831.2), ('2023-09-21 13:35:00.857+00', 11831.6), ('2023-09-21 13:35:54.972+00', 11832.1), ('2023-09-21 13:36:55.494+00', 11832.5), ('2023-09-21 13:37:54.207+00', 11833), ('2023-09-21 13:38:54.571+00', 11833.4), ('2023-09-21 13:39:55.053+00', 11833.9), ('2023-09-21 13:40:53.604+00', 11834.3), ('2023-09-21 13:41:54.32+00', 11834.8), ('2023-09-21 13:42:54.624+00', 11835.2), ('2023-09-21 13:43:53.368+00', 11835.7), ('2023-09-21 13:44:53.689+00', 11836.1), ('2023-09-21 13:45:54.473+00', 11836.6), ('2023-09-21 13:46:52.757+00', 11837), ('2023-09-21 13:47:53.142+00', 11837.5), ('2023-09-21 13:48:53.979+00', 11837.9), ('2023-09-21 13:49:52.222+00', 11838.4), ('2023-09-21 13:50:52.906+00', 11838.8), ('2023-09-21 13:51:51.387+00', 11839.3), ('2023-09-21 13:52:52.112+00', 11839.7), ('2023-09-21 13:53:52.454+00', 11840.2), ('2023-09-21 13:54:51.235+00', 11840.6), ('2023-09-21 13:55:51.653+00', 11841.1), ('2023-09-21 13:56:52.024+00', 11841.5), ('2023-09-21 13:57:50.473+00', 11842), ('2023-09-21 13:58:51.15+00', 11842.4), ('2023-09-21 13:59:51.573+00', 11842.9), ('2023-09-21 14:00:50.873+00', 11843.3), ('2023-09-21 14:01:51.317+00', 11843.8), ('2023-09-21 14:02:51.287+00', 11844.2), ('2023-09-21 14:03:51.571+00', 11844.7), ('2023-09-21 14:04:50.797+00', 11845.1), ('2023-09-21 14:05:50.74+00', 11845.6), ('2023-09-21 14:06:50.578+00', 11846), ('2023-09-21 14:07:51.149+00', 11846.5), ('2023-09-21 14:08:51.828+00', 11846.9), ('2023-09-21 14:09:51.077+00', 11847.4), ('2023-09-21 14:10:52.151+00', 11847.8), ('2023-09-21 14:11:51.228+00', 11848.3), ('2023-09-21 14:12:50.821+00', 11848.7), ('2023-09-21 14:13:50.41+00', 11849.2), ('2023-09-21 14:14:50.543+00', 11849.6), ('2023-09-21 14:15:50.756+00', 11850.1), ('2023-09-21 14:16:50.795+00', 11850.5), ('2023-09-21 14:17:51.059+00', 11851), ('2023-09-21 14:18:47.501+00', 11851.4), ('2023-09-21 14:19:47.927+00', 11851.9), ('2023-09-21 14:20:46.57+00', 11852.3), ('2023-09-21 14:21:47.108+00', 11852.8), ('2023-09-21 14:22:47.755+00', 11853.2), ('2023-09-21 14:23:46.144+00', 11853.7), ('2023-09-21 14:24:46.648+00', 11854.1), ('2023-09-21 14:25:46.147+00', 11854.6), ('2023-09-21 14:26:46.139+00', 11855), ('2023-09-21 14:27:46.272+00', 11855.5), ('2023-09-21 14:28:46.812+00', 11855.9), ('2023-09-21 14:29:45.342+00', 11856.4), ('2023-09-21 14:30:45.802+00', 11856.8), ('2023-09-21 14:31:44.242+00', 11857.3), ('2023-09-21 14:32:44.867+00', 11857.7), ('2023-09-21 14:33:51.275+00', 11858.2), ('2023-09-21 14:34:43.904+00', 11858.6), ('2023-09-21 14:35:44.441+00', 11859.1), ('2023-09-21 14:36:44.998+00', 11859.5), ('2023-09-21 14:37:43.419+00', 11860), ('2023-09-21 14:38:44.052+00', 11860.4), ('2023-09-21 14:39:44.584+00', 11860.9), ('2023-09-21 14:40:43.036+00', 11861.3), ('2023-09-21 14:41:43.614+00', 11861.8), ('2023-09-21 14:42:42.136+00', 11862.2), ('2023-09-21 14:43:42.857+00', 11862.7), ('2023-09-21 14:44:43.092+00', 11863.1), ('2023-09-21 14:45:43.633+00', 11863.6), ('2023-09-21 14:46:42.493+00', 11864), ('2023-09-21 14:47:42.746+00', 11864.5), ('2023-09-21 14:48:41.239+00', 11864.9), ('2023-09-21 14:49:41.806+00', 11865.4), ('2023-09-21 14:50:42.36+00', 11865.8), ('2023-09-21 14:51:41.334+00', 11866.2), ('2023-09-21 14:52:41.364+00', 11866.7), ('2023-09-21 14:53:42.106+00', 11867.1), ('2023-09-21 14:54:41.611+00', 11867.6), ('2023-09-21 14:55:40.985+00', 11868), ('2023-09-21 14:56:41.471+00', 11868.5), ('2023-09-21 14:57:40.907+00', 11868.9), ('2023-09-21 14:58:41.05+00', 11869.4), ('2023-09-21 14:59:41.333+00', 11869.8), ('2023-09-21 15:00:41.325+00', 11870.3), ('2023-09-21 15:01:41.489+00', 11870.7), ('2023-09-21 15:02:41.82+00', 11871.2), ('2023-09-21 15:03:40.576+00', 11871.6), ('2023-09-21 15:04:41.613+00', 11872.1), ('2023-09-21 15:05:40.874+00', 11872.5), ('2023-09-21 15:06:41.058+00', 11873), ('2023-09-21 15:07:41.308+00', 11873.4), ('2023-09-21 15:08:41.305+00', 11873.9), ('2023-09-21 15:09:41.686+00', 11874.3), ('2023-09-21 15:10:41.624+00', 11874.8), ('2023-09-21 15:11:40.526+00', 11875.2), ('2023-09-21 15:12:40.874+00', 11875.7), ('2023-09-21 15:13:40.826+00', 11876.1), ('2023-09-21 15:14:41.218+00', 11876.6), ('2023-09-21 15:15:41.148+00', 11877), ('2023-09-21 15:16:41.344+00', 11877.5), ('2023-09-21 15:17:41.694+00', 11877.9), ('2023-09-21 15:18:41.597+00', 11878.4), ('2023-09-21 15:19:41.933+00', 11878.8), ('2023-09-21 15:20:40.748+00', 11879.3), ('2023-09-21 15:21:40.84+00', 11879.7), ('2023-09-21 15:22:41.175+00', 11880.2), ('2023-09-21 15:23:41.204+00', 11880.6), ('2023-09-21 15:24:41.363+00', 11881.1), ('2023-09-21 15:25:41.679+00', 11881.5), ('2023-09-21 15:26:35.239+00', 11882), ('2023-09-21 15:27:41.761+00', 11882.4), ('2023-09-21 15:28:34.231+00', 11882.9), ('2023-09-21 15:29:34.765+00', 11883.3), ('2023-09-21 15:30:35.519+00', 11883.8), ('2023-09-21 15:31:33.727+00', 11884.2), ('2023-09-21 15:32:34.382+00', 11884.7), ('2023-09-21 15:33:34.907+00', 11885.1), ('2023-09-21 15:34:33.395+00', 11885.5), ('2023-09-21 15:35:33.933+00', 11886), ('2023-09-21 15:36:32.429+00', 11886.4), ('2023-09-21 15:37:33.164+00', 11886.9), ('2023-09-21 15:38:33.509+00', 11887.3), ('2023-09-21 15:39:36.092+00', 11887.8), ('2023-09-21 15:40:36.234+00', 11888.2), ('2023-09-21 15:41:36.341+00', 11888.7), ('2023-09-21 15:42:36.51+00', 11889.1), ('2023-09-21 15:43:36.884+00', 11889.5), ('2023-09-21 15:44:36.744+00', 11890), ('2023-09-21 15:45:35.923+00', 11890.4), ('2023-09-21 15:46:35.842+00', 11890.9), ('2023-09-21 15:47:36.243+00', 11891.3), ('2023-09-21 15:48:36.188+00', 11891.8), ('2023-09-21 15:49:36.405+00', 11892.2), ('2023-09-21 15:50:36.517+00', 11892.7), ('2023-09-21 15:51:30.52+00', 11893.1), ('2023-09-21 15:52:30.82+00', 11893.5), ('2023-09-21 15:53:31.578+00', 11894), ('2023-09-21 15:54:29.937+00', 11894.4), ('2023-09-21 15:55:30.613+00', 11894.9), ('2023-09-21 15:56:30.967+00', 11895.3), ('2023-09-21 15:57:29.658+00', 11895.8), ('2023-09-21 15:58:30.028+00', 11896.2), ('2023-09-21 15:59:28.505+00', 11896.6), ('2023-09-21 16:00:29.05+00', 11897.1), ('2023-09-21 16:01:29.795+00', 11897.5), ('2023-09-21 16:02:28.036+00', 11898), ('2023-09-21 16:03:28.822+00', 11898.4), ('2023-09-21 16:04:29.125+00', 11898.9), ('2023-09-21 16:05:27.837+00', 11899.3), ('2023-09-21 16:06:28.168+00', 11899.7), ('2023-09-21 16:07:28.893+00', 11900.2), ('2023-09-21 16:08:27.245+00', 11900.6), ('2023-09-21 16:09:27.794+00', 11901.1), ('2023-09-21 16:10:28.277+00', 11901.5), ('2023-09-21 16:11:26.959+00', 11901.9), ('2023-09-21 16:12:27.303+00', 11902.4), ('2023-09-21 16:13:26.305+00', 11902.8), ('2023-09-21 16:14:26.366+00', 11903.3), ('2023-09-21 16:15:27.073+00', 11903.7), ('2023-09-21 16:16:27.427+00', 11904.1), ('2023-09-21 16:17:26.989+00', 11904.6), ('2023-09-21 16:18:26.88+00', 11905), ('2023-09-21 16:19:27.017+00', 11905.5), ('2023-09-21 16:20:25.967+00', 11905.9), ('2023-09-21 16:21:26.123+00', 11906.3), ('2023-09-21 16:22:26.513+00', 11906.8), ('2023-09-21 16:23:26.439+00', 11907.2), ('2023-09-21 16:24:26.644+00', 11907.7), ('2023-09-21 16:25:26.936+00', 11908.1), ('2023-09-21 16:26:26.902+00', 11908.5), ('2023-09-21 16:27:26.927+00', 11909), ('2023-09-21 16:28:26.127+00', 11909.4), ('2023-09-21 16:29:26.163+00', 11909.9), ('2023-09-21 16:30:26.258+00', 11910.3), ('2023-09-21 16:31:26.631+00', 11910.7), ('2023-09-21 16:32:26.61+00', 11911.2), ('2023-09-21 16:33:26.751+00', 11911.6), ('2023-09-21 16:34:27.13+00', 11912.1), ('2023-09-21 16:35:26.984+00', 11912.5), ('2023-09-21 16:36:26.009+00', 11912.9), ('2023-09-21 16:37:26.324+00', 11913.4), ('2023-09-21 16:38:26.316+00', 11913.8), ('2023-09-21 16:39:26.675+00', 11914.2), ('2023-09-21 16:40:26.586+00', 11914.7), ('2023-09-21 16:41:26.758+00', 11915.1), ('2023-09-21 16:42:27.065+00', 11915.6), ('2023-09-21 16:43:26.978+00', 11916), ('2023-09-21 16:44:25.965+00', 11916.4), ('2023-09-21 16:45:20.803+00', 11916.9), ('2023-09-21 16:46:21.124+00', 11917.3), ('2023-09-21 16:47:19.645+00', 11917.8), ('2023-09-21 16:48:20.354+00', 11918.2), ('2023-09-21 16:49:20.767+00', 11918.6), ('2023-09-21 16:50:21.993+00', 11919.1), ('2023-09-21 16:51:22.061+00', 11919.5), ('2023-09-21 16:52:22.221+00', 11920), ('2023-09-21 16:53:21.035+00', 11920.4), ('2023-09-21 16:54:21.347+00', 11920.9), ('2023-09-21 16:55:21.292+00', 11921.3), ('2023-09-21 16:56:21.666+00', 11921.7), ('2023-09-21 16:57:21.613+00', 11922.2), ('2023-09-21 16:58:22.02+00', 11922.6), ('2023-09-21 16:59:17.96+00', 11923.1), ('2023-09-21 17:00:18.735+00', 11923.5), ('2023-09-21 17:01:18.984+00', 11923.9), ('2023-09-21 17:02:17.459+00', 11924.4), ('2023-09-21 17:03:18.003+00', 11924.8), ('2023-09-21 17:04:18.805+00', 11925.3), ('2023-09-21 17:05:17.113+00', 11925.7), ('2023-09-21 17:06:17.785+00', 11926.1), ('2023-09-21 17:07:16.099+00', 11926.6), ('2023-09-21 17:08:16.856+00', 11927), ('2023-09-21 17:09:17.072+00', 11927.5), ('2023-09-21 17:10:17.863+00', 11927.9), ('2023-09-21 17:11:16.189+00', 11928.3), ('2023-09-21 17:12:16.947+00', 11928.8), ('2023-09-21 17:13:15.265+00', 11929.2), ('2023-09-21 17:14:15.981+00', 11929.7), ('2023-09-21 17:15:16.335+00', 11930.1), ('2023-09-21 17:16:15.037+00', 11930.5), ('2023-09-21 17:17:15.352+00', 11931), ('2023-09-21 17:18:16.168+00', 11931.4), ('2023-09-21 17:19:16.251+00', 11931.9), ('2023-09-21 17:20:16.588+00', 11932.3), ('2023-09-21 17:21:16.536+00', 11932.8), ('2023-09-21 17:22:16.865+00', 11933.2), ('2023-09-21 17:23:16.875+00', 11933.6), ('2023-09-21 17:24:17.176+00', 11934.1), ('2023-09-21 17:25:17.147+00', 11934.5), ('2023-09-21 17:26:16.241+00', 11935), ('2023-09-21 17:27:16.208+00', 11935.4), ('2023-09-21 17:28:16.574+00', 11935.8), ('2023-09-21 17:29:16.503+00', 11936.3), ('2023-09-21 17:30:16.863+00', 11936.7), ('2023-09-21 17:31:16.947+00', 11937.2), ('2023-09-21 17:32:17.174+00', 11937.6), ('2023-09-21 17:33:17.14+00', 11938), ('2023-09-21 17:34:17.457+00', 11938.5), ('2023-09-21 17:35:16.257+00', 11938.9), ('2023-09-21 17:36:16.535+00', 11939.4), ('2023-09-21 17:37:16.559+00', 11939.8), ('2023-09-21 17:38:16.888+00', 11940.2), ('2023-09-21 17:39:10.976+00', 11940.7), ('2023-09-21 17:40:11.642+00', 11941.1), ('2023-09-21 17:41:11.999+00', 11941.6), ('2023-09-21 17:42:10.67+00', 11942), ('2023-09-21 17:43:11.007+00', 11942.4), ('2023-09-21 17:44:09.736+00', 11942.9), ('2023-09-21 17:45:10.109+00', 11943.3), ('2023-09-21 17:46:10.56+00', 11943.8), ('2023-09-21 17:47:09.306+00', 11944.2), ('2023-09-21 17:48:09.585+00', 11944.6), ('2023-09-21 17:49:10.437+00', 11945.1), ('2023-09-21 17:50:08.653+00', 11945.5), ('2023-09-21 17:51:09.193+00', 11946), ('2023-09-21 17:52:10.222+00', 11946.4), ('2023-09-21 17:53:08.226+00', 11946.8), ('2023-09-21 17:54:09.018+00', 11947.3), ('2023-09-21 17:55:09.311+00', 11947.7), ('2023-09-21 17:56:07.987+00', 11948.2), ('2023-09-21 17:57:08.348+00', 11948.6), ('2023-09-21 17:58:07.236+00', 11949), ('2023-09-21 17:59:07.364+00', 11949.5), ('2023-09-21 18:00:08.088+00', 11949.9), ('2023-09-21 18:01:08.454+00', 11950.4), ('2023-09-21 18:02:07.135+00', 11950.8), ('2023-09-21 18:03:07.473+00', 11951.3), ('2023-09-21 18:04:08.255+00', 11951.7), ('2023-09-21 18:05:06.918+00', 11952.1), ('2023-09-21 18:06:07.268+00', 11952.6), ('2023-09-21 18:07:07.286+00', 11953), ('2023-09-21 18:08:07.574+00', 11953.5), ('2023-09-21 18:09:06.639+00', 11953.9), ('2023-09-21 18:10:06.595+00', 11954.3), ('2023-09-21 18:11:06.632+00', 11954.8), ('2023-09-21 18:12:06.986+00', 11955.2), ('2023-09-21 18:13:06.962+00', 11955.7), ('2023-09-21 18:14:07.264+00', 11956.1), ('2023-09-21 18:15:07.205+00', 11956.6), ('2023-09-21 18:16:07.619+00', 11957), ('2023-09-21 18:17:06.313+00', 11957.4), ('2023-09-21 18:18:06.624+00', 11957.9), ('2023-09-21 18:19:06.559+00', 11958.3), ('2023-09-21 18:20:07.012+00', 11958.8), ('2023-09-21 18:21:06.909+00', 11959.2), ('2023-09-21 18:22:07.287+00', 11959.6), ('2023-09-21 18:23:07.248+00', 11960.1) ; -- calculating average works when data is not compressed SELECT avg(value) FROM corrupt_float8; avg ------------ 11735.8166 -- compress the chunk SELECT compress_chunk(x) FROM show_chunks('corrupt_float8') x; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- should work as well when the data is compressed SELECT avg(value) FROM corrupt_float8; avg ------------ 11735.8166 SELECT extract(day from time) AS day, avg(value) FROM corrupt_float8 GROUP BY 1 ORDER BY 2; day | avg -----+------------------ 20 | 11580.3964968153 21 | 11806.9564139942 DROP TABLE corrupt_float8; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_qualpushdown_saop.out���������������������������������0000664�0000000�0000000�00000074654�15100345067�0025675�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Planning tests for compressed chunk table filter pushdown with scalar array -- operations. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; -- a lower() function that is stable create function stable_lower(x text) returns text as 'lower' language internal stable; -- a lower() function that is volatile create function volatile_lower(x text) returns text as 'lower' language internal volatile; set max_parallel_workers_per_gather = 0; create table saop(ts int, segmentby text, with_minmax text, with_bloom text); select create_hypertable('saop', 'ts', chunk_time_interval => 50001); create_hypertable ------------------- (1,public,saop,t) alter table saop set (timescaledb.compress, timescaledb.compress_segmentby = 'segmentby', timescaledb.compress_orderby = 'with_minmax, ts'); insert into saop select ts, ts % 23 segmentby, ts % 29 with_minmax, (mix(ts % 1483) * 1483)::int::text with_bloom from generate_series(0, 100000) ts; create index on saop(with_bloom); select count(compress_chunk(x)) from show_chunks('saop') x; count ------- 2 vacuum full analyze saop; explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = any(array['1', '10']); --- QUERY PLAN --- Append (actual rows=8696.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=4348.00 loops=1) -> Index Scan using compress_hyper_2_3_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk (actual rows=6.00 loops=1) Index Cond: (segmentby = ANY ('{1,10}'::text[])) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=4348.00 loops=1) -> Index Scan using compress_hyper_2_4_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_4_chunk (actual rows=6.00 loops=1) Index Cond: (segmentby = ANY ('{1,10}'::text[])) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_minmax = any(array['1', '10']); --- QUERY PLAN --- Append (actual rows=6897.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3449.00 loops=1) Vectorized Filter: (with_minmax = ANY ('{1,10}'::text[])) Rows Removed by Filter: 46552 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=3448.00 loops=1) Vectorized Filter: (with_minmax = ANY ('{1,10}'::text[])) Rows Removed by Filter: 46552 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array['1', '10']); --- QUERY PLAN --- Append (actual rows=270.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=135.00 loops=1) Vectorized Filter: (with_bloom = ANY ('{1,10}'::text[])) Rows Removed by Filter: 49866 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=135.00 loops=1) Vectorized Filter: (with_bloom = ANY ('{1,10}'::text[])) Rows Removed by Filter: 49865 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array['1', '10']); --- QUERY PLAN --- Result (actual rows=0.00 loops=1) One-Time Filter: false explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_minmax < any(array['1', '10']); --- QUERY PLAN --- Append (actual rows=6898.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3450.00 loops=1) Filter: (with_minmax < ANY ('{1,10}'::text[])) Rows Removed by Filter: 46551 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=3448.00 loops=1) Filter: (with_minmax < ANY ('{1,10}'::text[])) Rows Removed by Filter: 46552 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_minmax < all(array['1', '10']); --- QUERY PLAN --- Append (actual rows=3449.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1725.00 loops=1) Filter: (with_minmax < ALL ('{1,10}'::text[])) Rows Removed by Filter: 48276 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1724.00 loops=1) Filter: (with_minmax < ALL ('{1,10}'::text[])) Rows Removed by Filter: 48276 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[segmentby, '10']); --- QUERY PLAN --- Append (actual rows=250.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=126.00 loops=1) Filter: (with_bloom = ANY (ARRAY[segmentby, '10'::text])) Rows Removed by Filter: 49875 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=124.00 loops=1) Filter: (with_bloom = ANY (ARRAY[segmentby, '10'::text])) Rows Removed by Filter: 49876 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[segmentby, null]); --- QUERY PLAN --- Append (actual rows=57.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Filter: (with_bloom = ANY (ARRAY[segmentby, NULL::text])) Rows Removed by Filter: 49971 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=27.00 loops=1) Filter: (with_bloom = ANY (ARRAY[segmentby, NULL::text])) Rows Removed by Filter: 49973 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[segmentby, null, with_minmax]); --- QUERY PLAN --- Append (actual rows=116.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=59.00 loops=1) Filter: (with_bloom = ANY (ARRAY[segmentby, NULL::text, with_minmax])) Rows Removed by Filter: 49942 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=57.00 loops=1) Filter: (with_bloom = ANY (ARRAY[segmentby, NULL::text, with_minmax])) Rows Removed by Filter: 49943 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[stable_lower(segmentby), stable_lower('1')]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=122.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=62.00 loops=1) Filter: (with_bloom = ANY (ARRAY[stable_lower(segmentby), stable_lower('1'::text)])) Rows Removed by Filter: 49939 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=60.00 loops=1) Filter: (with_bloom = ANY (ARRAY[stable_lower(segmentby), stable_lower('1'::text)])) Rows Removed by Filter: 49940 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[stable_lower(segmentby), stable_lower('1'), volatile_lower('10')]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=315.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=158.00 loops=1) Filter: (with_bloom = ANY (ARRAY[stable_lower(segmentby), stable_lower('1'::text), volatile_lower('10'::text)])) Rows Removed by Filter: 49843 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=157.00 loops=1) Filter: (with_bloom = ANY (ARRAY[stable_lower(segmentby), stable_lower('1'::text), volatile_lower('10'::text)])) Rows Removed by Filter: 49843 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[]::text[]); --- QUERY PLAN --- Result (actual rows=0.00 loops=1) One-Time Filter: false explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[null, null]); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (with_bloom = ANY ('{NULL,NULL}'::text[])) Rows Removed by Filter: 50001 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) Vectorized Filter: (with_bloom = ANY ('{NULL,NULL}'::text[])) Rows Removed by Filter: 50000 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = any(array[with_bloom, with_minmax]); --- QUERY PLAN --- Append (actual rows=3504.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1752.00 loops=1) Filter: (segmentby = ANY (ARRAY[with_bloom, with_minmax])) Rows Removed by Filter: 48249 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1752.00 loops=1) Filter: (segmentby = ANY (ARRAY[with_bloom, with_minmax])) Rows Removed by Filter: 48248 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = all(array[with_bloom, with_minmax]); --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) Filter: (segmentby = ALL (ARRAY[with_bloom, with_minmax])) Rows Removed by Filter: 49998 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (segmentby = ALL (ARRAY[with_bloom, with_minmax])) Rows Removed by Filter: 50000 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) -- If the arguments of an operator can pushed down but require recheck, combining -- them is wrong. explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (with_bloom = '1') = (with_minmax = '1'); --- QUERY PLAN --- Append (actual rows=96490.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=48246.00 loops=1) Filter: ((with_bloom = '1'::text) = (with_minmax = '1'::text)) Rows Removed by Filter: 1755 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=48244.00 loops=1) Filter: ((with_bloom = '1'::text) = (with_minmax = '1'::text)) Rows Removed by Filter: 1756 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (with_bloom = any(array['1', '10'])) = (with_minmax = any(array['1', '10'])); --- QUERY PLAN --- Append (actual rows=92870.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=46435.00 loops=1) Filter: ((with_bloom = ANY ('{1,10}'::text[])) = (with_minmax = ANY ('{1,10}'::text[]))) Rows Removed by Filter: 3566 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=46435.00 loops=1) Filter: ((with_bloom = ANY ('{1,10}'::text[])) = (with_minmax = ANY ('{1,10}'::text[]))) Rows Removed by Filter: 3565 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (segmentby = '1') = (segmentby = '2'); --- QUERY PLAN --- Append (actual rows=91305.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=45653.00 loops=1) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=63.00 loops=1) Filter: ((segmentby = '1'::text) = (segmentby = '2'::text)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=45652.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=63.00 loops=1) Filter: ((segmentby = '1'::text) = (segmentby = '2'::text)) Rows Removed by Filter: 6 explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (segmentby = any(array['1', '2'])) = (segmentby = any(array['3', '4'])); --- QUERY PLAN --- Append (actual rows=82609.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=41305.00 loops=1) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=57.00 loops=1) Filter: ((segmentby = ANY ('{1,2}'::text[])) = (segmentby = ANY ('{3,4}'::text[]))) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=41304.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=57.00 loops=1) Filter: ((segmentby = ANY ('{1,2}'::text[])) = (segmentby = ANY ('{3,4}'::text[]))) Rows Removed by Filter: 12 -- Partial pushdown of AND scalar array operation. explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array[with_minmax, with_minmax]); --- QUERY PLAN --- Append (actual rows=62.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=32.00 loops=1) Filter: (with_bloom = ALL (ARRAY[with_minmax, with_minmax])) Rows Removed by Filter: 49969 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=30.00 loops=1) Filter: (with_bloom = ALL (ARRAY[with_minmax, with_minmax])) Rows Removed by Filter: 49970 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array['1', with_minmax]); --- QUERY PLAN --- Append (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) Filter: (with_bloom = ALL (ARRAY['1'::text, with_minmax])) Rows Removed by Filter: 49999 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (with_bloom = ALL (ARRAY['1'::text, with_minmax])) Rows Removed by Filter: 49999 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' and with_bloom = all(array['1', with_minmax]); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (with_bloom = ALL (ARRAY['1'::text, with_minmax])) Rows Removed by Filter: 2174 -> Index Scan using compress_hyper_2_3_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk (actual rows=3.00 loops=1) Index Cond: (segmentby = '1'::text) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (with_bloom = ALL (ARRAY['1'::text, with_minmax])) Rows Removed by Filter: 2174 -> Index Scan using compress_hyper_2_4_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) Index Cond: (segmentby = '1'::text) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' or with_bloom = all(array['1', with_minmax]); --- QUERY PLAN --- Append (actual rows=4351.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2176.00 loops=1) Filter: ((segmentby = '1'::text) OR (with_bloom = ALL (ARRAY['1'::text, with_minmax]))) Rows Removed by Filter: 47825 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=2175.00 loops=1) Filter: ((segmentby = '1'::text) OR (with_bloom = ALL (ARRAY['1'::text, with_minmax]))) Rows Removed by Filter: 47825 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) -- Partial pushdown with volatile functions. explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[stable_lower(segmentby), volatile_lower(segmentby)]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=57.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Filter: (with_bloom = ANY (ARRAY[stable_lower(segmentby), volatile_lower(segmentby)])) Rows Removed by Filter: 49971 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=27.00 loops=1) Filter: (with_bloom = ANY (ARRAY[stable_lower(segmentby), volatile_lower(segmentby)])) Rows Removed by Filter: 49973 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = stable_lower(segmentby) or with_bloom = volatile_lower(segmentby); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=57.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Filter: ((with_bloom = stable_lower(segmentby)) OR (with_bloom = volatile_lower(segmentby))) Rows Removed by Filter: 49971 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=27.00 loops=1) Filter: ((with_bloom = stable_lower(segmentby)) OR (with_bloom = volatile_lower(segmentby))) Rows Removed by Filter: 49973 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array[stable_lower(segmentby), volatile_lower(segmentby)]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=57.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Filter: (with_bloom = ALL (ARRAY[stable_lower(segmentby), volatile_lower(segmentby)])) Rows Removed by Filter: 49971 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=27.00 loops=1) Filter: (with_bloom = ALL (ARRAY[stable_lower(segmentby), volatile_lower(segmentby)])) Rows Removed by Filter: 49973 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' or with_bloom = all(array[stable_lower('1'), volatile_lower('1')]); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=4413.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2206.00 loops=1) Filter: ((segmentby = '1'::text) OR (with_bloom = ALL (ARRAY[stable_lower('1'::text), volatile_lower('1'::text)]))) Rows Removed by Filter: 47795 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=2207.00 loops=1) Filter: ((segmentby = '1'::text) OR (with_bloom = ALL (ARRAY[stable_lower('1'::text), volatile_lower('1'::text)]))) Rows Removed by Filter: 47793 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' or (with_bloom = stable_lower('1') and with_bloom = volatile_lower('1')); --- QUERY PLAN --- Custom Scan (ChunkAppend) on saop (actual rows=4413.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2206.00 loops=1) Filter: ((segmentby = '1'::text) OR ((with_bloom = stable_lower('1'::text)) AND (with_bloom = volatile_lower('1'::text)))) Rows Removed by Filter: 47795 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=2207.00 loops=1) Filter: ((segmentby = '1'::text) OR ((with_bloom = stable_lower('1'::text)) AND (with_bloom = volatile_lower('1'::text)))) Rows Removed by Filter: 47793 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) -- Some joins. explain (analyze, buffers off, costs off, timing off, summary off) with arrays as (select array[segmentby] a from saop group by segmentby order by segmentby limit 10) select * from saop, arrays where segmentby = any(a); --- QUERY PLAN --- Nested Loop (actual rows=43480.00 loops=1) -> Limit (actual rows=10.00 loops=1) -> Group (actual rows=10.00 loops=1) Group Key: saop_1.segmentby -> Merge Append (actual rows=39133.00 loops=1) Sort Key: saop_1.segmentby -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=19567.00 loops=1) -> Index Scan using compress_hyper_2_3_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk compress_hyper_2_3_chunk_1 (actual rows=28.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=19567.00 loops=1) -> Index Scan using compress_hyper_2_4_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=28.00 loops=1) -> Append (actual rows=4348.00 loops=10) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2174.00 loops=10) Filter: (segmentby = ANY ((ARRAY[saop_1.segmentby]))) -> Index Scan using compress_hyper_2_3_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk (actual rows=3.00 loops=10) Index Cond: (segmentby = ANY ((ARRAY[saop_1.segmentby]))) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=2174.00 loops=10) Filter: (segmentby = ANY ((ARRAY[saop_1.segmentby]))) -> Index Scan using compress_hyper_2_4_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_4_chunk (actual rows=3.00 loops=10) Index Cond: (segmentby = ANY ((ARRAY[saop_1.segmentby]))) explain (analyze, buffers off, costs off, timing off, summary off) with arrays as (select array[segmentby] a from saop group by segmentby order by segmentby limit 10) select * from saop, arrays where with_minmax = any(a); --- QUERY PLAN --- Nested Loop (actual rows=34482.00 loops=1) Join Filter: (saop.with_minmax = ANY (arrays.a)) Rows Removed by Join Filter: 965528 -> Append (actual rows=100001.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=50001.00 loops=1) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=50000.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) -> Materialize (actual rows=10.00 loops=100001) -> Subquery Scan on arrays (actual rows=10.00 loops=1) -> Limit (actual rows=10.00 loops=1) -> Group (actual rows=10.00 loops=1) Group Key: saop_1.segmentby -> Merge Append (actual rows=39133.00 loops=1) Sort Key: saop_1.segmentby -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=19567.00 loops=1) -> Index Scan using compress_hyper_2_3_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk compress_hyper_2_3_chunk_1 (actual rows=28.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=19567.00 loops=1) -> Index Scan using compress_hyper_2_4_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=28.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) with arrays as (select array[segmentby] a from saop group by segmentby order by segmentby limit 10) select * from saop, arrays where with_bloom = any(a); --- QUERY PLAN --- Nested Loop (actual rows=474.00 loops=1) Join Filter: (saop.with_bloom = ANY (arrays.a)) Rows Removed by Join Filter: 999536 -> Append (actual rows=100001.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=50001.00 loops=1) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=50000.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) -> Materialize (actual rows=10.00 loops=100001) -> Subquery Scan on arrays (actual rows=10.00 loops=1) -> Limit (actual rows=10.00 loops=1) -> Group (actual rows=10.00 loops=1) Group Key: saop_1.segmentby -> Merge Append (actual rows=39133.00 loops=1) Sort Key: saop_1.segmentby -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=19567.00 loops=1) -> Index Scan using compress_hyper_2_3_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_3_chunk compress_hyper_2_3_chunk_1 (actual rows=28.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=19567.00 loops=1) -> Index Scan using compress_hyper_2_4_chunk_segmentby__ts_meta_min_1__ts_meta__idx on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=28.00 loops=1) -- Array parameter of prepared statements. prepare array_param as select * from saop where with_bloom = any($1); set timescaledb.enable_chunk_append to off; -- Generic plans. set plan_cache_mode = force_generic_plan; explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array['1', '10']); --- QUERY PLAN --- Append (actual rows=270.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=135.00 loops=1) Vectorized Filter: (with_bloom = ANY ($1)) Rows Removed by Filter: 49866 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=135.00 loops=1) Vectorized Filter: (with_bloom = ANY ($1)) Rows Removed by Filter: 49865 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array[]::text[]); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (with_bloom = ANY ($1)) Rows Removed by Filter: 50001 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) Vectorized Filter: (with_bloom = ANY ($1)) Rows Removed by Filter: 50000 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) -- Custom plans. set plan_cache_mode = force_custom_plan; explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array['1', '10']); --- QUERY PLAN --- Append (actual rows=270.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=135.00 loops=1) Vectorized Filter: (with_bloom = ANY ('{1,10}'::text[])) Rows Removed by Filter: 49866 -> Seq Scan on compress_hyper_2_3_chunk (actual rows=69.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=135.00 loops=1) Vectorized Filter: (with_bloom = ANY ('{1,10}'::text[])) Rows Removed by Filter: 49865 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=69.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array[]::text[]); --- QUERY PLAN --- Result (actual rows=0.00 loops=1) One-Time Filter: false reset timescaledb.enable_chunk_append; ������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_sort_transform.out������������������������������������0000664�0000000�0000000�00000063731�15100345067�0025175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this test checks the validity of the produced plans for partially compressed chunks -- when injecting query_pathkeys on top of the append -- path that combines the uncompressed and compressed parts of a chunk. set work_mem to '64MB'; set enable_hashagg to off; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE ht_metrics_partially_compressed(time timestamptz, device int, value float); SELECT create_hypertable('ht_metrics_partially_compressed','time'); create_hypertable ---------------------------------------------- (1,public,ht_metrics_partially_compressed,t) ALTER TABLE ht_metrics_partially_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); INSERT INTO ht_metrics_partially_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02'::timestamptz,'2020-01-18'::timestamptz,'20 minute') time, generate_series(1,3) device; SELECT compress_chunk(c) FROM show_chunks('ht_metrics_partially_compressed') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk -- make them partially compressed INSERT INTO ht_metrics_partially_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02'::timestamptz,'2020-01-18'::timestamptz,'30 minute') time, generate_series(1,3) device; VACUUM ANALYZE ht_metrics_partially_compressed; -- sort transform -- Grouping can use compressed data order. :PREFIX select device, time_bucket('1 minute', time), count(*) from ht_metrics_partially_compressed group by 1, 2 order by 1, 2 limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Finalize GroupAggregate (actual rows=1.00 loops=1) Group Key: ht_metrics_partially_compressed.device, (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Merge Append (actual rows=3.00 loops=1) Sort Key: ht_metrics_partially_compressed.device, (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.device, time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: _hyper_1_1_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_1_1_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=960.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_2_chunk.device, time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_5_chunk.device, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_5_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_2_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time")) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_2_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time")) Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=1008.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_3_chunk.device, time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_6_chunk.device, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_1_3_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time")) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_1_3_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time")) Sort Method: quicksort -> Seq Scan on _hyper_1_3_chunk (actual rows=339.00 loops=1) -- Batch sorted merge. :PREFIX select time_bucket('1 minute', time), count(*) from ht_metrics_partially_compressed group by 1 order by 1 limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Finalize GroupAggregate (actual rows=1.00 loops=1) Group Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Custom Scan (ChunkAppend) on ht_metrics_partially_compressed (actual rows=3.00 loops=1) Order: time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time") -> Merge Append (actual rows=3.00 loops=1) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Index Only Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Index Only Scan Backward using _hyper_1_2_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_6_chunk (never executed) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Index Only Scan Backward using _hyper_1_3_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_3_chunk (never executed) -- Batch sorted merge with different order in SELECT list. :PREFIX select count(*), time_bucket('1 minute', time) from ht_metrics_partially_compressed group by 2 order by 2 limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Finalize GroupAggregate (actual rows=1.00 loops=1) Group Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Custom Scan (ChunkAppend) on ht_metrics_partially_compressed (actual rows=3.00 loops=1) Order: time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time") -> Merge Append (actual rows=3.00 loops=1) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Index Only Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Index Only Scan Backward using _hyper_1_2_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_6_chunk (never executed) -> Partial GroupAggregate (never executed) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Index Only Scan Backward using _hyper_1_3_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_3_chunk (never executed) -- Batch sorted merge with grouping column not in SELECT list. :PREFIX select count(*) from ht_metrics_partially_compressed group by time_bucket('1 minute', time) limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Finalize GroupAggregate (actual rows=1.00 loops=1) Group Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Merge Append (actual rows=3.00 loops=1) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=2.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time") -> Index Only Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_5_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time") -> Index Only Scan Backward using _hyper_1_2_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time") -> Index Only Scan Backward using _hyper_1_3_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) -- Ordering by time_bucket. :PREFIX select time_bucket('1 minute', time), * from ht_metrics_partially_compressed order by 1 limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_partially_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Index Scan Backward using _hyper_1_2_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_6_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_3_chunk (never executed) -- Ordering by time_bucket, but it's not in the SELECT list. :PREFIX select * from ht_metrics_partially_compressed order by time_bucket('1 minute', time) limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_partially_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Index Scan Backward using _hyper_1_2_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_2_6_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_3_chunk (never executed) -- Ordering in compressed data order. :PREFIX select * from ht_metrics_partially_compressed order by device, time_bucket('1 minute', time) limit 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_partially_compressed.device, (time_bucket('@ 1 min'::interval, ht_metrics_partially_compressed."time")) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_1_chunk."time")) Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=960.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_5_chunk.device, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_5_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_2_chunk."time")) Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=1008.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_6_chunk.device, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk.device, (time_bucket('@ 1 min'::interval, _hyper_1_3_chunk."time")) Sort Method: top-N heapsort -> Seq Scan on _hyper_1_3_chunk (actual rows=339.00 loops=1) -- Test incorrect transformation into a Pathkey on different relation through -- a join EquivalenceClass. set max_parallel_workers_per_gather = 0; :PREFIX select time_bucket('1 minute', a.time) from ht_metrics_partially_compressed a join ht_metrics_partially_compressed b on a.time = b.time where b.time < '2020-01-07' group by 1 ; --- QUERY PLAN --- Group (actual rows=480.00 loops=1) Group Key: (time_bucket('@ 1 min'::interval, a."time")) -> Sort (actual rows=7560.00 loops=1) Sort Key: (time_bucket('@ 1 min'::interval, a."time")) Sort Method: quicksort -> Hash Join (actual rows=7560.00 loops=1) Hash Cond: (a."time" = b."time") -> Append (actual rows=1800.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk a_1 (actual rows=1080.00 loops=1) Vectorized Filter: ("time" < 'Tue Jan 07 00:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 360 -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_1 < 'Tue Jan 07 00:00:00 2020 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk a_1 (actual rows=720.00 loops=1) Index Cond: ("time" < 'Tue Jan 07 00:00:00 2020 PST'::timestamp with time zone) -> Hash (actual rows=1800.00 loops=1) -> Append (actual rows=1800.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk b_1 (actual rows=1080.00 loops=1) Vectorized Filter: ("time" < 'Tue Jan 07 00:00:00 2020 PST'::timestamp with time zone) Rows Removed by Filter: 360 -> Seq Scan on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=3.00 loops=1) Filter: (_ts_meta_min_1 < 'Tue Jan 07 00:00:00 2020 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_1_chunk_ht_metrics_partially_compressed_time_idx on _hyper_1_1_chunk b_1 (actual rows=720.00 loops=1) Index Cond: ("time" < 'Tue Jan 07 00:00:00 2020 PST'::timestamp with time zone) reset max_parallel_workers_per_gather; reset work_mem; reset enable_hashagg; ���������������������������������������timescaledb-2.23.0/tsl/test/expected/compress_sparse_config.out�������������������������������������0000664�0000000�0000000�00000124403�15100345067�0024727�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- Test configurable sparse indexes settings create table test_settings(x int, value text, u uuid, ts timestamp); select create_hypertable('test_settings', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ---------------------------- (1,public,test_settings,t) -- defaults alter table test_settings set (timescaledb.compress); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+------- test_settings | | | | | | -- no custom sparse indexes alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+------- test_settings | | | {x} | {f} | {f} | -- one sparse index alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u")'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+---------------------------------------------------------------------------------------------------------------- test_settings | | | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'minmax("ts")'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------ test_settings | | | {x} | {f} | {f} | [{"type": "minmax", "column": "ts", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] --multi column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), bloom("ts")'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------- test_settings | | | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "bloom", "column": "ts", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(u), bloom(ts)'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------- test_settings | | | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "bloom", "column": "ts", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] --test errors \set ON_ERROR_STOP 0 -- invalid syntax alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), bloom(count(u))'); ERROR: sparse index bloom's first option must reference a valid column. alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = '"u", minmax("u")'); ERROR: unable to parse sparse index option ""u", minmax("u")" alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'foo("u")'); ERROR: unrecognized sparse index type "foo" alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(public.u)'); ERROR: invalid sparse index column reference syntax alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'select count(*)'); ERROR: unable to parse sparse index option "select count(*)" alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom (ts); select count(*)'); ERROR: unable to parse sparse index option "bloom (ts); select count(*)" alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = ';'); ERROR: unable to parse sparse index option ";" alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = ' '); ERROR: unable to parse sparse index option " " -- same column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), minmax("u")'); ERROR: duplicate column name "u" -- multiple columns alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u,ts")'); ERROR: column "u,ts" does not exist alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(u,ts)'); ERROR: sparse index "bloom" can only have one column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(u,abc)'); ERROR: sparse index "bloom" can only have one column -- duplicate column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), bloom("u")'); ERROR: duplicate column name "u" -- invalid column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), minmax("foo")'); ERROR: column "foo" does not exist -- no orderby alter table test_settings reset (timescaledb.compress_orderby); alter table test_settings set (timescaledb.compress, timescaledb.compress_index = 'bloom("u"), minmax("x")'); ERROR: cannot set sparse index option without orderby option -- guc disabled set timescaledb.enable_sparse_index_bloom to false; alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u")'); ERROR: Creating bloom sparse index is disabled reset timescaledb.enable_sparse_index_bloom; \set ON_ERROR_STOP 1 -- empty sparse index alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'ts', timescaledb.compress_index = ''); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------------------------------------------------------------- test_settings | | | {ts,x} | {f,t} | {f,t} | [{"source": "config"}, {"type": "minmax", "column": "ts", "source": "orderby"}, {"type": "minmax", "column": "x", "source": "orderby"}] -- change orderby setting (sparse index changes) alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'u'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+---------------------------------------------------------------------------------------------------------------------------------------- test_settings | | | {u,x} | {f,t} | {f,t} | [{"source": "config"}, {"type": "minmax", "column": "u", "source": "orderby"}, {"type": "minmax", "column": "x", "source": "orderby"}] -- same column as orderby should succeed since minmax alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'ts', timescaledb.compress_index = 'bloom("value"), minmax("ts")'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- test_settings | | | {ts,x} | {f,t} | {f,t} | [{"type": "bloom", "column": "value", "source": "config"}, {"type": "minmax", "column": "ts", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] -- change orderby setting (sparse index doesn't change) alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'u'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ test_settings | | | {u,x} | {f,t} | {f,t} | [{"type": "bloom", "column": "value", "source": "config"}, {"type": "minmax", "column": "ts", "source": "config"}, {"type": "minmax", "column": "u", "source": "orderby"}, {"type": "minmax", "column": "x", "source": "orderby"}] alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'minmax("x")'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'u'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------------------------------------- test_settings | | | {u,x} | {f,t} | {f,t} | [{"type": "minmax", "column": "x", "source": "config"}, {"type": "minmax", "column": "u", "source": "orderby"}] -- same column as orderby should fail since bloom \set ON_ERROR_STOP 0 alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("x"), minmax("ts")'); ERROR: the orderby column "x" cannot have a bloom sparse index \set ON_ERROR_STOP 1 drop table test_settings; -- Test configurable sparse indexes functionality create table test_sparse_index(x int, value text, u uuid, ts timestamp, data jsonb); select create_hypertable('test_sparse_index', 'x'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable -------------------------------- (3,public,test_sparse_index,t) create index gin_jsonb_idx on test_sparse_index using gin (data); insert into test_sparse_index select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x, jsonb_build_object('id', x, 'tag', case when x % 2 = 0 then 'even' else 'odd' end, 'active', x % 10 = 0) from generate_series(1, 10000) x; alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('test_sparse_index') x; count ------- 1 alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"),minmax("ts")'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------ test_sparse_index | | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "minmax", "column": "ts", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_3_1_chunk | _timescaledb_internal.compress_hyper_4_2_chunk | {} | {x} | {f} | {f} | [{"type": "minmax", "column": "x", "source": "orderby"}] select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; count ------- 1 vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_4_3_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | value | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts | timestamp without time zone | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | data | _timescaledb_internal.compressed_data | | | | extended | 0 | Indexes: "compress_hyper_4_3_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_3_1_chunk.u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_3_chunk (actual rows=1.00 loops=1) Output: compress_hyper_4_3_chunk._ts_meta_count, compress_hyper_4_3_chunk._ts_meta_min_1, compress_hyper_4_3_chunk._ts_meta_max_1, compress_hyper_4_3_chunk.x, compress_hyper_4_3_chunk.value, compress_hyper_4_3_chunk._ts_meta_v2_bloom1_u, compress_hyper_4_3_chunk.u, compress_hyper_4_3_chunk._ts_meta_v2_min_ts, compress_hyper_4_3_chunk._ts_meta_v2_max_ts, compress_hyper_4_3_chunk.ts, compress_hyper_4_3_chunk.data Filter: _timescaledb_functions.bloom1_contains(compress_hyper_4_3_chunk._ts_meta_v2_bloom1_u, '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 9 -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where ts between '2021-01-07' and '2021-01-14'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_1_chunk (actual rows=169.00 loops=1) Vectorized Filter: ((_hyper_3_1_chunk.ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (_hyper_3_1_chunk.ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 831 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_3_chunk (actual rows=1.00 loops=1) Output: compress_hyper_4_3_chunk._ts_meta_count, compress_hyper_4_3_chunk._ts_meta_min_1, compress_hyper_4_3_chunk._ts_meta_max_1, compress_hyper_4_3_chunk.x, compress_hyper_4_3_chunk.value, compress_hyper_4_3_chunk._ts_meta_v2_bloom1_u, compress_hyper_4_3_chunk.u, compress_hyper_4_3_chunk._ts_meta_v2_min_ts, compress_hyper_4_3_chunk._ts_meta_v2_max_ts, compress_hyper_4_3_chunk.ts, compress_hyper_4_3_chunk.data Filter: ((compress_hyper_4_3_chunk._ts_meta_v2_max_ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (compress_hyper_4_3_chunk._ts_meta_v2_min_ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 9 drop table test_sparse_index; -- Test configurable sparse index in CREATE TABLE .. WITH create table test_sparse_index(x int, value text, u uuid, ts timestamp) with ( tsdb.hypertable, tsdb.partition_column='x', tsdb.order_by='x', tsdb.index='bloom("u"),minmax("ts")'); select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------------------+----------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------ test_sparse_index | | | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "minmax", "column": "ts", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] insert into test_sparse_index select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('test_sparse_index') x; count ------- 1 vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_5_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | value | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts | timestamp without time zone | | | | plain | 1000 | ts | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_6_5_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- these tests show that despite column having multiple sparse indexes, the appropriate one is selected by the planner -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_4_chunk (actual rows=1.00 loops=1) Vectorized Filter: (_hyper_5_4_chunk.u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 999 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_5_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_5_chunk._ts_meta_count, compress_hyper_6_5_chunk._ts_meta_min_1, compress_hyper_6_5_chunk._ts_meta_max_1, compress_hyper_6_5_chunk.x, compress_hyper_6_5_chunk.value, compress_hyper_6_5_chunk._ts_meta_v2_bloom1_u, compress_hyper_6_5_chunk.u, compress_hyper_6_5_chunk._ts_meta_v2_min_ts, compress_hyper_6_5_chunk._ts_meta_v2_max_ts, compress_hyper_6_5_chunk.ts Filter: _timescaledb_functions.bloom1_contains(compress_hyper_6_5_chunk._ts_meta_v2_bloom1_u, '90ec9e8e-4501-4232-9d03-6d7cf6132815'::uuid) Rows Removed by Filter: 9 -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where ts between '2021-01-07' and '2021-01-14'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_4_chunk (actual rows=169.00 loops=1) Vectorized Filter: ((_hyper_5_4_chunk.ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (_hyper_5_4_chunk.ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 831 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_5_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_5_chunk._ts_meta_count, compress_hyper_6_5_chunk._ts_meta_min_1, compress_hyper_6_5_chunk._ts_meta_max_1, compress_hyper_6_5_chunk.x, compress_hyper_6_5_chunk.value, compress_hyper_6_5_chunk._ts_meta_v2_bloom1_u, compress_hyper_6_5_chunk.u, compress_hyper_6_5_chunk._ts_meta_v2_min_ts, compress_hyper_6_5_chunk._ts_meta_v2_max_ts, compress_hyper_6_5_chunk.ts Filter: ((compress_hyper_6_5_chunk._ts_meta_v2_max_ts >= 'Thu Jan 07 00:00:00 2021'::timestamp without time zone) AND (compress_hyper_6_5_chunk._ts_meta_v2_min_ts <= 'Thu Jan 14 00:00:00 2021'::timestamp without time zone)) Rows Removed by Filter: 9 -- Test recompression when the bloom filter index is disabled by a GUC set timescaledb.enable_sparse_index_bloom to off; select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; WARNING: Creating bloom sparse index is disabled count ------- 1 reset timescaledb.enable_sparse_index_bloom; -- Test rename column -- change a non-sparse index column alter table test_sparse_index rename value to value_new; -- change sparse index column alter table test_sparse_index rename ts to ts_new; select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- test_sparse_index | | | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "minmax", "column": "ts_new", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_5_4_chunk | _timescaledb_internal.compress_hyper_6_6_chunk | | {x} | {f} | {f} | [{"type": "bloom", "column": "u", "source": "config"}, {"type": "minmax", "column": "ts_new", "source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_6_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ------------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | value_new | _timescaledb_internal.compressed_data | | | | extended | 0 | _ts_meta_v2_bloom1_u | _timescaledb_internal.bloom1 | | | | external | 1000 | u | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_min_ts_new | timestamp without time zone | | | | plain | 1000 | _ts_meta_v2_max_ts_new | timestamp without time zone | | | | plain | 1000 | ts_new | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_6_6_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 -- Test same minmax and orderby column alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'minmax("x")'); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; count ------- 1 select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_7_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | value_new | _timescaledb_internal.compressed_data | | | | extended | 0 | u | _timescaledb_internal.compressed_data | | | | external | 0 | ts_new | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_6_7_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+--------------------------------------------------------- test_sparse_index | | {} | {x} | {f} | {f} | [{"type": "minmax", "column": "x", "source": "config"}] _timescaledb_internal._hyper_5_4_chunk | _timescaledb_internal.compress_hyper_6_7_chunk | {} | {x} | {f} | {f} | [{"type": "minmax", "column": "x", "source": "config"}] -- Test auto sparse index create index ii on test_sparse_index(value_new); alter table test_sparse_index reset (timescaledb.compress_index); alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; count ------- 1 select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_8_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ------------------------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | _ts_meta_v2_bloom1_value_new | _timescaledb_internal.bloom1 | | | | external | 1000 | value_new | _timescaledb_internal.compressed_data | | | | extended | 0 | u | _timescaledb_internal.compressed_data | | | | external | 0 | ts_new | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_6_8_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------- test_sparse_index | | {} | {x} | {f} | {f} | _timescaledb_internal._hyper_5_4_chunk | _timescaledb_internal.compress_hyper_6_8_chunk | {} | {x} | {f} | {f} | [{"type": "bloom", "column": "value_new", "source": "default"}, {"type": "minmax", "column": "x", "source": "orderby"}] -- Test empty sparse index alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x', timescaledb.compress_index = ''); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; count ------- 1 vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_9_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | value_new | _timescaledb_internal.compressed_data | | | | extended | 0 | u | _timescaledb_internal.compressed_data | | | | external | 0 | ts_new | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_6_9_chunk__ts_meta_min_1__ts_meta_max_1_idx" btree (_ts_meta_min_1, _ts_meta_max_1) Options: toast_tuple_target=128 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+-------------------------------------------------------------------------------- test_sparse_index | | {} | {x} | {f} | {f} | [{"source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] _timescaledb_internal._hyper_5_4_chunk | _timescaledb_internal.compress_hyper_6_9_chunk | {} | {x} | {f} | {f} | [{"source": "config"}, {"type": "minmax", "column": "x", "source": "orderby"}] -- Test default orderby without sparse index set timescaledb.enable_sparse_index_bloom to false; alter table test_sparse_index reset (timescaledb.compress_segmentby, timescaledb.compress_orderby, timescaledb.compress_index); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; count ------- 1 vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk Table "_timescaledb_internal.compress_hyper_6_10_chunk" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description ----------------+---------------------------------------+-----------+----------+---------+----------+--------------+------------- _ts_meta_count | integer | | | | plain | 1000 | value_new | text | | | | extended | 1000 | _ts_meta_min_1 | integer | | | | plain | 1000 | _ts_meta_max_1 | integer | | | | plain | 1000 | x | _timescaledb_internal.compressed_data | | | | external | 0 | u | _timescaledb_internal.compressed_data | | | | external | 0 | ts_new | _timescaledb_internal.compressed_data | | | | external | 0 | Indexes: "compress_hyper_6_10_chunk_value_new__ts_meta_min_1__ts_meta_idx" btree (value_new, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC) Options: toast_tuple_target=128 select * from settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+-------------------------------------------------+-------------+---------+--------------+--------------------+---------------------------------------------------------- test_sparse_index | | | | | | _timescaledb_internal._hyper_5_4_chunk | _timescaledb_internal.compress_hyper_6_10_chunk | {value_new} | {x} | {t} | {t} | [{"type": "minmax", "column": "x", "source": "orderby"}] reset timescaledb.enable_sparse_index_bloom; drop table test_sparse_index; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compressed_collation.out���������������������������������������0000664�0000000�0000000�00000004742�15100345067�0024405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- We have different collation names such as en_US, en-US-x-icu and so on, -- that are available on different platforms. with encodings as ( select -1 union all select encoding from pg_database where datname = current_database() ) , pattern(pattern, priority) as ( values ('en_us%', 2), ('en_us_utf%8%', 1) ) , collations as ( select priority, collname from pg_collation join pattern on collname ilike pattern where collencoding in (select * from encodings) order by priority, collencoding, collname ) select * from ( select 3 priority, 'C' "COLLATION" union all select * from collations ) c order by priority limit 1 \gset create table compressed_collation_ht(time timestamp, name text collate :"COLLATION", value float); select create_hypertable('compressed_collation_ht', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable -------------------------------------- (1,public,compressed_collation_ht,t) alter table compressed_collation_ht set (timescaledb.compress, timescaledb.compress_segmentby = 'name', timescaledb.compress_orderby = 'time'); insert into compressed_collation_ht values ('2021-01-01 01:01:01', 'á', '1'), ('2021-01-01 01:01:02', 'b', '2'), ('2021-01-01 01:01:03', 'ç', '2'); SELECT count(compress_chunk(ch)) FROM show_chunks('compressed_collation_ht') ch; count ------- 1 vacuum analyze compressed_collation_ht; SELECT format('%I.%I',ch.schema_name, ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.compressed_hypertable_id AND ht.table_name = 'compressed_collation_ht' \gset create index on :CHUNK (name); set enable_seqscan to off; explain (buffers off, costs off) select * from compressed_collation_ht order by name; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_2_chunk_name_idx on compress_hyper_2_2_chunk select * from compressed_collation_ht order by name; time | name | value --------------------------+------+------- Fri Jan 01 01:01:01 2021 | á | 1 Fri Jan 01 01:01:02 2021 | b | 2 Fri Jan 01 01:01:03 2021 | ç | 2 ������������������������������timescaledb-2.23.0/tsl/test/expected/compressed_detoaster.out���������������������������������������0000664�0000000�0000000�00000003133�15100345067�0024404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Make a compressed table with a compressed string of varying length, to test -- the various ways the compressed data can be toasted. create table longstr(ts int default 1, s1 text); select create_hypertable('longstr', 'ts'); create_hypertable ---------------------- (1,public,longstr,t) alter table longstr set (timescaledb.compress); -- We want to test the case for inline compression. It is technically possible, -- but very hard to hit with the usual toast_tuple_target = 128 on compressed -- chunks. So here we increase the toast_tuple_target to simplify -- testing. set timescaledb.debug_toast_tuple_target = 512; -- Now, test compression and decompression with various string lengths. create function test(repeats int, decompress bool) returns table(ns bigint) as $$ begin raise log 'repeats %', repeats; truncate longstr; insert into longstr(s1) select repeat('aaaa', repeats); perform count(compress_chunk(x, true)) from show_chunks('longstr') x; if decompress then perform decompress_chunk(x) from show_chunks('longstr') x; end if; return query select sum(length(s1)) from longstr; end; $$ language plpgsql volatile; select sum(t) from generate_series(1, 30) x, lateral test(x * x * x, false) t; sum -------- 864900 -- Also test decompression which uses the detoaster as well. select sum(t) from generate_series(1, 30) x, lateral test(x * x * x, true) t; sum -------- 864900 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression.out������������������������������������������������0000664�0000000�0000000�00000447404�15100345067�0022544�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_transparent_decompression to OFF; SET timezone TO 'America/Los_Angeles'; \set PREFIX 'EXPLAIN (analyze, verbose, buffers off, costs off, timing off, summary off)' \ir include/rand_generator.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------- -- cheap rand generator -- -------------------------- create table rand_minstd_state(i bigint); create function rand_minstd_advance(bigint) returns bigint language sql immutable as $$ select (16807 * $1) % 2147483647 $$; create function gen_rand_minstd() returns bigint language sql security definer as $$ update rand_minstd_state set i = rand_minstd_advance(i) returning i $$; -- seed the random num generator insert into rand_minstd_state values (321); --test_collation --- --basic test with count create table foo (a integer, b integer, c integer, d integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo create unique index foo_uniq ON foo (a, b); --note that the "d" order by column is all NULL insert into foo values( 3 , 16 , 20, NULL); insert into foo values( 10 , 10 , 20, NULL); insert into foo values( 20 , 11 , 20, NULL); insert into foo values( 30 , 12 , 20, NULL); analyze foo; -- check that approximate_row_count works with a regular table SELECT approximate_row_count('foo'); approximate_row_count ----------------------- 4 SELECT count(*) from foo; count ------- 4 alter table foo set (timescaledb.compress, timescaledb.compress_segmentby = 'a,b', timescaledb.compress_orderby = 'c desc, d asc nulls last'); --test self-refencing updates SET timescaledb.enable_transparent_decompression to ON; update foo set c = 40 where a = (SELECT max(a) FROM foo); SET timescaledb.enable_transparent_decompression to OFF; SELECT id, schema_name, table_name, compression_state as compressed, compressed_hypertable_id FROM _timescaledb_catalog.hypertable ORDER BY id; id | schema_name | table_name | compressed | compressed_hypertable_id ----+-----------------------+--------------------------+------------+-------------------------- 1 | public | foo | 1 | 2 2 | _timescaledb_internal | _compressed_hypertable_2 | 2 | SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY relid::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | {a,b} | {c,d} | {t,f} | {t,f} | SELECT * FROM timescaledb_information.compression_settings ORDER BY hypertable_name; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | foo | a | 1 | | | public | foo | b | 2 | | | public | foo | c | | 1 | f | t public | foo | d | | 2 | t | f -- TEST2 compress-chunk for the chunks created earlier -- select compress_chunk( '_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk select tgname , tgtype, tgenabled , relname from pg_trigger t, pg_class rel where t.tgrelid = rel.oid and rel.relname like '_hyper_1_2_chunk' order by tgname; tgname | tgtype | tgenabled | relname --------+--------+-----------+--------- \x select * from chunk_compression_stats('foo') order by chunk_name limit 2; -[ RECORD 1 ]------------------+---------------------- chunk_schema | _timescaledb_internal chunk_name | _hyper_1_1_chunk compression_status | Uncompressed before_compression_table_bytes | before_compression_index_bytes | before_compression_toast_bytes | before_compression_total_bytes | after_compression_table_bytes | after_compression_index_bytes | after_compression_toast_bytes | after_compression_total_bytes | node_name | -[ RECORD 2 ]------------------+---------------------- chunk_schema | _timescaledb_internal chunk_name | _hyper_1_2_chunk compression_status | Compressed before_compression_table_bytes | 8192 before_compression_index_bytes | 32768 before_compression_toast_bytes | 0 before_compression_total_bytes | 40960 after_compression_table_bytes | 16384 after_compression_index_bytes | 16384 after_compression_toast_bytes | 8192 after_compression_total_bytes | 40960 node_name | \x select compress_chunk( '_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk \x select * from _timescaledb_catalog.compression_chunk_size order by chunk_id; -[ RECORD 1 ]--------------+------ chunk_id | 1 compressed_chunk_id | 6 uncompressed_heap_size | 8192 uncompressed_toast_size | 0 uncompressed_index_size | 32768 compressed_heap_size | 16384 compressed_toast_size | 8192 compressed_index_size | 16384 numrows_pre_compression | 1 numrows_post_compression | 1 numrows_frozen_immediately | 1 -[ RECORD 2 ]--------------+------ chunk_id | 2 compressed_chunk_id | 5 uncompressed_heap_size | 8192 uncompressed_toast_size | 0 uncompressed_index_size | 32768 compressed_heap_size | 16384 compressed_toast_size | 8192 compressed_index_size | 16384 numrows_pre_compression | 1 numrows_post_compression | 1 numrows_frozen_immediately | 1 \x select ch1.id, ch1.schema_name, ch1.table_name , ch2.table_name as compress_table from _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2 where ch1.compressed_chunk_id = ch2.id; id | schema_name | table_name | compress_table ----+-----------------------+------------------+-------------------------- 2 | _timescaledb_internal | _hyper_1_2_chunk | compress_hyper_2_5_chunk 1 | _timescaledb_internal | _hyper_1_1_chunk | compress_hyper_2_6_chunk \set ON_ERROR_STOP 0 --cannot compress the chunk the second time around select compress_chunk( '_timescaledb_internal._hyper_1_2_chunk', false); ERROR: chunk "_hyper_1_2_chunk" is already converted to columnstore --TEST2a try DML on a compressed chunk BEGIN; insert into foo values( 11 , 10 , 20, 120); ROLLBACK; update foo set b =20 where a = 10; delete from foo where a = 10; --TEST2b try complex DML on compressed chunk create table foo_join ( a integer, newval integer); select table_name from create_hypertable('foo_join', 'a', chunk_time_interval=> 10); table_name ------------ foo_join insert into foo_join select generate_series(0,40, 10), 111; create table foo_join2 ( a integer, newval integer); select table_name from create_hypertable('foo_join2', 'a', chunk_time_interval=> 10); table_name ------------ foo_join2 insert into foo_join select generate_series(0,40, 10), 222; update foo set b = newval from foo_join where foo.a = foo_join.a; update foo set b = newval from foo_join where foo.a = foo_join.a and foo_join.a > 10; --here the chunk gets excluded , so succeeds -- update foo set b = newval from foo_join where foo.a = foo_join.a and foo.a > 20; update foo set b = (select f1.newval from foo_join f1 left join lateral (select newval as newval2 from foo_join2 f2 where f1.a= f2.a ) subq on true limit 1); --upsert test -- insert into foo values(10, 12, 12, 12) on conflict( a, b) do update set b = excluded.b; SELECT * from foo ORDER BY a,b; a | b | c | d ----+-----+----+---- 3 | 111 | 20 | 10 | 12 | 12 | 12 20 | 111 | 20 | 30 | 111 | 40 | --TEST2c Do DML directly on the chunk. insert into _timescaledb_internal._hyper_1_2_chunk values(10, 12, 12, 12) on conflict( a, b) do update set b = excluded.b + 12; SELECT * from foo ORDER BY a,b; a | b | c | d ----+-----+----+---- 3 | 111 | 20 | 10 | 24 | 12 | 12 20 | 111 | 20 | 30 | 111 | 40 | update _timescaledb_internal._hyper_1_2_chunk set b = 12; delete from _timescaledb_internal._hyper_1_2_chunk; --TEST2d decompress the chunk and try DML select decompress_chunk( '_timescaledb_internal._hyper_1_2_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk insert into foo values( 11 , 10 , 20, 120); update foo set b =20 where a = 10; select * from _timescaledb_internal._hyper_1_2_chunk order by a,b; a | b | c | d ----+----+----+----- 11 | 10 | 20 | 120 delete from foo where a = 10; select * from _timescaledb_internal._hyper_1_2_chunk order by a,b; a | b | c | d ----+----+----+----- 11 | 10 | 20 | 120 -- TEST3 check if compress data from views is accurate CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select create_hypertable( 'conditions', 'time', chunk_time_interval=> '31days'::interval); create_hypertable ------------------------- (5,public,conditions,t) alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'time'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 'klick', 55, 75; SELECT id, schema_name, table_name, compression_state as compressed, compressed_hypertable_id FROM _timescaledb_catalog.hypertable WHERE table_name = 'conditions'; id | schema_name | table_name | compressed | compressed_hypertable_id ----+-------------+------------+------------+-------------------------- 5 | public | conditions | 1 | 6 SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'conditions'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ------------+----------------+------------+---------+--------------+--------------------+------- conditions | | {location} | {time} | {f} | {f} | select attname, attstorage, typname from pg_attribute at, pg_class cl , pg_type ty where cl.oid = at.attrelid and at.attnum > 0 and cl.relname = '_compressed_hypertable_4' and atttypid = ty.oid order by at.attnum; attname | attstorage | typname ---------+------------+--------- SELECT ch1.schema_name|| '.' || ch1.table_name as "CHUNK_NAME", ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'conditions' ORDER BY ch1.id LIMIT 1 \gset SELECT count(*) from :CHUNK_NAME; count ------- 42 SELECT count(*) as "ORIGINAL_CHUNK_COUNT" from :CHUNK_NAME \gset select tableoid::regclass, count(*) from conditions group by tableoid order by tableoid; tableoid | count -----------------------------------------+------- _timescaledb_internal._hyper_5_12_chunk | 42 _timescaledb_internal._hyper_5_13_chunk | 20 SELECT compress_chunk(ch) FROM show_chunks('conditions') ch LIMIT 1; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_12_chunk --test that only one chunk was affected --note tables with 0 rows will not show up in here. select tableoid::regclass, count(*) from conditions group by tableoid order by tableoid; tableoid | count -----------------------------------------+------- _timescaledb_internal._hyper_5_13_chunk | 20 SELECT compress_chunk(ch, true) FROM show_chunks('conditions') ch ORDER BY ch::text DESC LIMIT 1; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk select tableoid::regclass, count(*) from conditions group by tableoid order by tableoid; tableoid | count ----------+------- select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset SELECT count(*) from :CHUNK_NAME; count ------- 0 SELECT count(*) from :COMPRESSED_CHUNK_NAME; count ------- 2 SELECT sum(_ts_meta_count) from :COMPRESSED_CHUNK_NAME; sum ----- 42 SELECT location, _ts_meta_min_1, _ts_meta_max_1 from :COMPRESSED_CHUNK_NAME ORDER BY 1,2; location | _ts_meta_min_1 | _ts_meta_max_1 ----------+------------------------------+------------------------------ NYC | Sat Dec 01 00:00:00 2018 PST | Fri Dec 21 00:00:00 2018 PST POR | Sat Dec 01 00:00:00 2018 PST | Fri Dec 21 00:00:00 2018 PST \x SELECT chunk_id, numrows_pre_compression, numrows_post_compression FROM _timescaledb_catalog.chunk srcch, _timescaledb_catalog.compression_chunk_size map, _timescaledb_catalog.hypertable srcht WHERE map.chunk_id = srcch.id and srcht.id = srcch.hypertable_id and srcht.table_name like 'conditions' order by chunk_id; -[ RECORD 1 ]------------+--- chunk_id | 12 numrows_pre_compression | 42 numrows_post_compression | 2 -[ RECORD 2 ]------------+--- chunk_id | 13 numrows_pre_compression | 20 numrows_post_compression | 2 select * from chunk_compression_stats('conditions') order by chunk_name; -[ RECORD 1 ]------------------+---------------------- chunk_schema | _timescaledb_internal chunk_name | _hyper_5_12_chunk compression_status | Compressed before_compression_table_bytes | 8192 before_compression_index_bytes | 16384 before_compression_toast_bytes | 8192 before_compression_total_bytes | 32768 after_compression_table_bytes | 16384 after_compression_index_bytes | 16384 after_compression_toast_bytes | 8192 after_compression_total_bytes | 40960 node_name | -[ RECORD 2 ]------------------+---------------------- chunk_schema | _timescaledb_internal chunk_name | _hyper_5_13_chunk compression_status | Compressed before_compression_table_bytes | 8192 before_compression_index_bytes | 16384 before_compression_toast_bytes | 8192 before_compression_total_bytes | 32768 after_compression_table_bytes | 16384 after_compression_index_bytes | 16384 after_compression_toast_bytes | 8192 after_compression_total_bytes | 40960 node_name | select * from hypertable_compression_stats('foo'); -[ RECORD 1 ]------------------+------ total_chunks | 4 number_compressed_chunks | 1 before_compression_table_bytes | 8192 before_compression_index_bytes | 32768 before_compression_toast_bytes | 0 before_compression_total_bytes | 40960 after_compression_table_bytes | 16384 after_compression_index_bytes | 16384 after_compression_toast_bytes | 8192 after_compression_total_bytes | 40960 node_name | select * from hypertable_compression_stats('conditions'); -[ RECORD 1 ]------------------+------ total_chunks | 2 number_compressed_chunks | 2 before_compression_table_bytes | 16384 before_compression_index_bytes | 32768 before_compression_toast_bytes | 16384 before_compression_total_bytes | 65536 after_compression_table_bytes | 32768 after_compression_index_bytes | 32768 after_compression_toast_bytes | 16384 after_compression_total_bytes | 81920 node_name | vacuum full foo; vacuum full conditions; -- After vacuum, table_bytes is 0, but any associated index/toast storage is not -- completely reclaimed. Sets it at 8K (page size). So a chunk which has -- been compressed still incurs an overhead of n * 8KB (for every index + toast table) storage on the original uncompressed chunk. select pg_size_pretty(table_bytes), pg_size_pretty(index_bytes), pg_size_pretty(toast_bytes), pg_size_pretty(total_bytes) from hypertable_detailed_size('conditions'); -[ RECORD 1 ]--+------- pg_size_pretty | 16 kB pg_size_pretty | 56 kB pg_size_pretty | 40 kB pg_size_pretty | 112 kB select * from timescaledb_information.hypertables where hypertable_name like 'foo' or hypertable_name like 'conditions' order by hypertable_name; -[ RECORD 1 ]----------+------------------------- hypertable_schema | public hypertable_name | conditions owner | default_perm_user num_dimensions | 1 num_chunks | 2 compression_enabled | t tablespaces | primary_dimension | time primary_dimension_type | timestamp with time zone -[ RECORD 2 ]----------+------------------------- hypertable_schema | public hypertable_name | foo owner | default_perm_user num_dimensions | 1 num_chunks | 4 compression_enabled | t tablespaces | primary_dimension | a primary_dimension_type | integer \x SELECT count(decompress_chunk(ch)) FROM show_chunks('conditions') ch; count ------- 2 SELECT count(*), count(*) = :'ORIGINAL_CHUNK_COUNT' from :CHUNK_NAME; count | ?column? -------+---------- 42 | t --check that the compressed chunk is dropped \set ON_ERROR_STOP 0 SELECT count(*) from :COMPRESSED_CHUNK_NAME; ERROR: relation "_timescaledb_internal.compress_hyper_6_14_chunk" does not exist at character 22 \set ON_ERROR_STOP 1 --size information is gone too select count(*) FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.compression_chunk_size map where ch1.hypertable_id = ht.id and ht.table_name like 'conditions' and map.chunk_id = ch1.id; count ------- 0 --make sure compressed_chunk_id is reset to NULL select ch1.compressed_chunk_id IS NULL FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'conditions'; ?column? ---------- t t -- test plans get invalidated when chunks get compressed SET timescaledb.enable_transparent_decompression TO ON; CREATE TABLE plan_inval(time timestamptz, device_id int); SELECT create_hypertable('plan_inval','time'); create_hypertable ------------------------- (7,public,plan_inval,t) ALTER TABLE plan_inval SET (timescaledb.compress,timescaledb.compress_orderby='time desc'); -- create 2 chunks INSERT INTO plan_inval SELECT * FROM (VALUES ('2000-01-01'::timestamptz,1), ('2000-01-07'::timestamptz,1)) v(time,device_id); SET max_parallel_workers_per_gather to 0; -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; PREPARE prep_plan AS SELECT count(*) FROM plan_inval; EXECUTE prep_plan; count ------- 2 EXECUTE prep_plan; count ------- 2 EXECUTE prep_plan; count ------- 2 -- get name of first chunk SELECT tableoid::regclass AS "CHUNK_NAME" FROM plan_inval ORDER BY time LIMIT 1 \gset SELECT compress_chunk(:'CHUNK_NAME'); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_16_chunk VACUUM ANALYZE plan_inval; EXECUTE prep_plan; count ------- 2 EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE prep_plan; --- QUERY PLAN --- Finalize Aggregate -> Append -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_7_16_chunk -> Seq Scan on compress_hyper_8_18_chunk -> Partial Aggregate -> Seq Scan on _hyper_7_17_chunk SET enable_hashagg = ON; CREATE TABLE test_collation ( time TIMESTAMPTZ NOT NULL, device_id TEXT COLLATE "C" NULL, device_id_2 TEXT COLLATE "POSIX" NULL, val_1 TEXT COLLATE "C" NULL, val_2 TEXT COLLATE "POSIX" NULL ); --we want all the data to go into 1 chunk. so use 1 year chunk interval select create_hypertable( 'test_collation', 'time', chunk_time_interval=> '1 day'::interval); create_hypertable ----------------------------- (9,public,test_collation,t) \set ON_ERROR_STOP 0 --forbid setting collation in compression ORDER BY clause. (parse error is fine) alter table test_collation set (timescaledb.compress, timescaledb.compress_segmentby='device_id, device_id_2', timescaledb.compress_orderby = 'val_1 COLLATE "POSIX", val2, time'); ERROR: unable to parse ordering option "val_1 COLLATE "POSIX", val2, time" \set ON_ERROR_STOP 1 alter table test_collation set (timescaledb.compress, timescaledb.compress_segmentby='device_id, device_id_2', timescaledb.compress_orderby = 'val_1, val_2, time'); insert into test_collation select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_1', 'device_3', gen_rand_minstd(), gen_rand_minstd(); insert into test_collation select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_2', 'device_4', gen_rand_minstd(), gen_rand_minstd(); insert into test_collation select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), NULL, 'device_5', gen_rand_minstd(), gen_rand_minstd(); --compress 2 chunks SELECT compress_chunk(ch) FROM show_chunks('test_collation') ch LIMIT 2; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_19_chunk _timescaledb_internal._hyper_9_20_chunk VACUUM ANALYZE test_collation; --segment bys are pushed down correctly EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE device_id < 'a'; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk -> Seq Scan on compress_hyper_10_29_chunk Filter: (device_id < 'a'::text) -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk -> Seq Scan on compress_hyper_10_30_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_21_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_22_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_23_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_24_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_25_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_26_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_27_chunk Filter: (device_id < 'a'::text) -> Seq Scan on _hyper_9_28_chunk Filter: (device_id < 'a'::text) EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE device_id < 'a' COLLATE "POSIX"; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk -> Seq Scan on compress_hyper_10_29_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk -> Seq Scan on compress_hyper_10_30_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_21_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_22_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_23_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_24_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_25_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_26_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_27_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_28_chunk Filter: (device_id < 'a'::text COLLATE "POSIX") \set ON_ERROR_STOP 0 EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE device_id COLLATE "POSIX" < device_id_2 COLLATE "C"; ERROR: collation mismatch between explicit collations "POSIX" and "C" at character 109 SELECT device_id < device_id_2 FROM test_collation; ERROR: could not determine which collation to use for string comparison \set ON_ERROR_STOP 1 --segment meta on order bys pushdown --should work EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_1 < 'a'; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on compress_hyper_10_29_chunk Filter: (_ts_meta_min_1 < 'a'::text) -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on compress_hyper_10_30_chunk Filter: (_ts_meta_min_1 < 'a'::text) -> Seq Scan on _hyper_9_21_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_22_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_23_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_24_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_25_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_26_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_27_chunk Filter: (val_1 < 'a'::text) -> Seq Scan on _hyper_9_28_chunk Filter: (val_1 < 'a'::text) EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_2 < 'a'; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on compress_hyper_10_29_chunk Filter: (_ts_meta_min_2 < 'a'::text) -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on compress_hyper_10_30_chunk Filter: (_ts_meta_min_2 < 'a'::text) -> Seq Scan on _hyper_9_21_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_22_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_23_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_24_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_25_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_26_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_27_chunk Filter: (val_2 < 'a'::text) -> Seq Scan on _hyper_9_28_chunk Filter: (val_2 < 'a'::text) EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_1 < 'a' COLLATE "C"; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on compress_hyper_10_29_chunk Filter: (_ts_meta_min_1 < 'a'::text COLLATE "C") -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on compress_hyper_10_30_chunk Filter: (_ts_meta_min_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_21_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_22_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_23_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_24_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_25_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_26_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_27_chunk Filter: (val_1 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_28_chunk Filter: (val_1 < 'a'::text COLLATE "C") EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_2 < 'a' COLLATE "POSIX"; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on compress_hyper_10_29_chunk Filter: (_ts_meta_min_2 < 'a'::text COLLATE "POSIX") -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on compress_hyper_10_30_chunk Filter: (_ts_meta_min_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_21_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_22_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_23_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_24_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_25_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_26_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_27_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_28_chunk Filter: (val_2 < 'a'::text COLLATE "POSIX") --cannot pushdown when op collation does not match column's collation since min/max used different collation than what op needs EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_1 < 'a' COLLATE "POSIX"; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on compress_hyper_10_29_chunk -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on compress_hyper_10_30_chunk -> Seq Scan on _hyper_9_21_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_22_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_23_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_24_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_25_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_26_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_27_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") -> Seq Scan on _hyper_9_28_chunk Filter: (val_1 < 'a'::text COLLATE "POSIX") EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_2 < 'a' COLLATE "C"; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_9_19_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on compress_hyper_10_29_chunk -> Custom Scan (ColumnarScan) on _hyper_9_20_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on compress_hyper_10_30_chunk -> Seq Scan on _hyper_9_21_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_22_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_23_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_24_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_25_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_26_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_27_chunk Filter: (val_2 < 'a'::text COLLATE "C") -> Seq Scan on _hyper_9_28_chunk Filter: (val_2 < 'a'::text COLLATE "C") --test datatypes CREATE TABLE datatype_test( time timestamptz NOT NULL, int2_column int2, int4_column int4, int8_column int8, float4_column float4, float8_column float8, date_column date, timestamp_column timestamp, timestamptz_column timestamptz, interval_column interval, numeric_column numeric, decimal_column decimal, text_column text, char_column char ); SELECT create_hypertable('datatype_test','time'); WARNING: column type "timestamp without time zone" used for "timestamp_column" does not follow best practices create_hypertable ----------------------------- (11,public,datatype_test,t) ALTER TABLE datatype_test SET (timescaledb.compress, timescaledb.compress_orderby='"time" desc'); INSERT INTO datatype_test VALUES ('2000-01-01',2,4,8,4.0,8.0,'2000-01-01','2001-01-01 12:00','2001-01-01 6:00','1 week', 3.41, 4.2, 'text', 'x'); SELECT count(compress_chunk(ch)) FROM show_chunks('datatype_test') ch; count ------- 1 select id, schema_name, table_name, compression_state as compressed, compressed_hypertable_id from _timescaledb_catalog.hypertable where table_name = 'datatype_test'; id | schema_name | table_name | compressed | compressed_hypertable_id ----+-------------+---------------+------------+-------------------------- 11 | public | datatype_test | 1 | 12 SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='datatype_test'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------------+----------------+-----------+---------+--------------+--------------------+------- datatype_test | | | {time} | {t} | {t} | --TEST try to compress a hypertable that has a continuous aggregate CREATE TABLE metrics(time timestamptz, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); create_hypertable ----------------------- (13,public,metrics,t) INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2, count(*) AS cnt FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; time | const | numeric | first | case | coalesce | avg1 | avg2 | cnt ------------------------------+-------+---------+----------------------------------------------+------+----------+------+------+------ Fri Dec 31 16:00:00 1999 PST | Const | 4.3 | ("Sat Jan 01 00:00:00 2000 PST",1,0.25,0.75) | foo | coalesce | 1 | 1 | 960 Sat Jan 01 16:00:00 2000 PST | Const | 4.3 | ("Sat Jan 01 16:00:00 2000 PST",1,0.25,0.75) | foo | coalesce | 1 | 1 | 1440 Sun Jan 02 16:00:00 2000 PST | Const | 4.3 | ("Sun Jan 02 16:00:00 2000 PST",1,0.25,0.75) | foo | coalesce | 1 | 1 | 1440 Mon Jan 03 16:00:00 2000 PST | Const | 4.3 | ("Mon Jan 03 16:00:00 2000 PST",1,0.25,0.75) | foo | coalesce | 1 | 1 | 1440 Tue Jan 04 16:00:00 2000 PST | Const | 4.3 | ("Tue Jan 04 16:00:00 2000 PST",1,0.25,0.75) | foo | coalesce | 1 | 1 | 1440 ALTER TABLE metrics set(timescaledb.compress, timescaledb.compress_orderby='"time" desc'); -- test rescan in compress chunk dml blocker CREATE TABLE rescan_test(id integer NOT NULL, t timestamptz NOT NULL, val double precision, PRIMARY KEY(id, t)); SELECT create_hypertable('rescan_test', 't', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (16,public,rescan_test,t) -- compression ALTER TABLE rescan_test SET (timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby='t desc'); -- INSERT dummy data INSERT INTO rescan_test SELECT 1, time, random() FROM generate_series('2000-01-01'::timestamptz, '2000-01-05'::timestamptz, '1h'::interval) g(time); SELECT count(*) FROM rescan_test; count ------- 97 -- compress first chunk SELECT compress_chunk(ch) FROM show_chunks('rescan_test') ch LIMIT 1; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_16_36_chunk -- count should be equal to count before compression SELECT count(*) FROM rescan_test; count ------- 97 -- single row update is fine UPDATE rescan_test SET val = val + 1 WHERE rescan_test.id = 1 AND rescan_test.t = '2000-01-03 00:00:00+00'; -- multi row update via WHERE is fine UPDATE rescan_test SET val = val + 1 WHERE rescan_test.id = 1 AND rescan_test.t > '2000-01-03 00:00:00+00'; -- single row update with FROM is allowed if no compressed chunks are hit UPDATE rescan_test SET val = tmp.val FROM (SELECT x.id, x.t, x.val FROM unnest(array[(1, '2000-01-03 00:00:00+00', 2.045)]::rescan_test[]) AS x) AS tmp WHERE rescan_test.id = tmp.id AND rescan_test.t = tmp.t AND rescan_test.t >= '2000-01-03'; -- single row update with FROM is blocked \set ON_ERROR_STOP 0 UPDATE rescan_test SET val = tmp.val FROM (SELECT x.id, x.t, x.val FROM unnest(array[(1, '2000-01-03 00:00:00+00', 2.045)]::rescan_test[]) AS x) AS tmp WHERE rescan_test.id = tmp.id AND rescan_test.t = tmp.t; -- bulk row update with FROM is blocked UPDATE rescan_test SET val = tmp.val FROM (SELECT x.id, x.t, x.val FROM unnest(array[(1, '2000-01-03 00:00:00+00', 2.045), (1, '2000-01-03 01:00:00+00', 8.045)]::rescan_test[]) AS x) AS tmp WHERE rescan_test.id = tmp.id AND rescan_test.t = tmp.t; \set ON_ERROR_STOP 1 -- Test FK constraint drop and recreate during compression and decompression on a chunk CREATE TABLE meta (device_id INT PRIMARY KEY); CREATE TABLE hyper( time INT NOT NULL, device_id INT REFERENCES meta(device_id) ON DELETE CASCADE ON UPDATE CASCADE, val INT); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 18 | public | hyper | t ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO meta VALUES (1), (2), (3), (4), (5); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2); SELECT ch1.table_name AS "CHUNK_NAME", ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' ORDER BY ch1.id LIMIT 1 \gset SELECT constraint_schema, constraint_name, table_schema, table_name, constraint_type FROM information_schema.table_constraints WHERE table_name = :'CHUNK_NAME' AND constraint_type = 'FOREIGN KEY' ORDER BY constraint_name; constraint_schema | constraint_name | table_schema | table_name | constraint_type -----------------------+---------------------------+-----------------------+--------------------+----------------- _timescaledb_internal | 42_6_hyper_device_id_fkey | _timescaledb_internal | _hyper_18_42_chunk | FOREIGN KEY SELECT compress_chunk(:'CHUNK_FULL_NAME'); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_18_42_chunk SELECT constraint_schema, constraint_name, table_schema, table_name, constraint_type FROM information_schema.table_constraints WHERE table_name = :'CHUNK_NAME' AND constraint_type = 'FOREIGN KEY' ORDER BY constraint_name; constraint_schema | constraint_name | table_schema | table_name | constraint_type -----------------------+---------------------------+-----------------------+--------------------+----------------- _timescaledb_internal | 42_6_hyper_device_id_fkey | _timescaledb_internal | _hyper_18_42_chunk | FOREIGN KEY -- Delete data from compressed chunk directly fails \set ON_ERROR_STOP 0 DELETE FROM hyper WHERE device_id = 3; \set ON_ERROR_STOP 0 -- Delete data from FK-referenced table deletes data from compressed chunk SELECT * FROM hyper ORDER BY time, device_id; time | device_id | val ------+-----------+----- 1 | 1 | 1 2 | 2 | 1 11 | 4 | 2 11 | 5 | 2 DELETE FROM meta WHERE device_id = 3; SELECT * FROM hyper ORDER BY time, device_id; time | device_id | val ------+-----------+----- 1 | 1 | 1 2 | 2 | 1 11 | 4 | 2 11 | 5 | 2 SELECT decompress_chunk(:'CHUNK_FULL_NAME'); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_18_42_chunk SELECT constraint_schema, constraint_name, table_schema, table_name, constraint_type FROM information_schema.table_constraints WHERE table_name = :'CHUNK_NAME' AND constraint_type = 'FOREIGN KEY' ORDER BY constraint_name; constraint_schema | constraint_name | table_schema | table_name | constraint_type -----------------------+---------------------------+-----------------------+--------------------+----------------- _timescaledb_internal | 42_6_hyper_device_id_fkey | _timescaledb_internal | _hyper_18_42_chunk | FOREIGN KEY -- create hypertable with 2 chunks CREATE TABLE ht5(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('ht5','time'); create_hypertable ------------------- (20,public,ht5,t) INSERT INTO ht5 SELECT '2000-01-01'::TIMESTAMPTZ; INSERT INTO ht5 SELECT '2001-01-01'::TIMESTAMPTZ; -- compressed chunk stats should not show dropped chunks ALTER TABLE ht5 SET (timescaledb.compress, timescaledb.orderby = '"time" desc'); SELECT compress_chunk(i) FROM show_chunks('ht5') i; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_20_45_chunk _timescaledb_internal._hyper_20_46_chunk SELECT drop_chunks('ht5', newer_than => '2000-01-01'::TIMESTAMPTZ); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_20_46_chunk select chunk_name from chunk_compression_stats('ht5') order by chunk_name; chunk_name -------------------- _hyper_20_45_chunk -- Test enabling compression for a table with compound foreign key -- (Issue https://github.com/timescale/timescaledb/issues/2000) CREATE TABLE table2(col1 INT, col2 int, primary key (col1,col2)); CREATE TABLE table1(col1 INT NOT NULL, col2 INT); ALTER TABLE table1 ADD CONSTRAINT fk_table1 FOREIGN KEY (col1,col2) REFERENCES table2(col1,col2); SELECT create_hypertable('table1','col1', chunk_time_interval => 10); create_hypertable ---------------------- (22,public,table1,t) -- Trying to list an incomplete set of fields of the compound key ALTER TABLE table1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'col1'); -- Listing all fields of the compound key should succeed: ALTER TABLE table1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'col1,col2'); SELECT * FROM timescaledb_information.compression_settings ORDER BY hypertable_name; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+-------------+------------------------+----------------------+-------------+-------------------- public | conditions | location | 1 | | | public | conditions | time | | 1 | t | f public | datatype_test | time | | 1 | f | t public | foo | a | 1 | | | public | foo | b | 2 | | | public | foo | c | | 1 | f | t public | foo | d | | 2 | t | f public | ht5 | time | | 1 | f | t public | hyper | device_id | 1 | | | public | hyper | time | | 1 | t | f public | metrics | time | | 1 | f | t public | plan_inval | time | | 1 | f | t public | rescan_test | id | 1 | | | public | rescan_test | t | | 1 | f | t public | table1 | col1 | 1 | | | public | table1 | col2 | 2 | | | public | test_collation | device_id | 1 | | | public | test_collation | device_id_2 | 2 | | | public | test_collation | val_1 | | 1 | t | f public | test_collation | val_2 | | 2 | t | f public | test_collation | time | | 3 | t | f -- test delete/update on non-compressed tables involving hypertables with compression CREATE TABLE uncompressed_ht ( time timestamptz NOT NULL, value double precision, series_id integer ); SELECT table_name FROM create_hypertable ('uncompressed_ht', 'time'); table_name ----------------- uncompressed_ht INSERT INTO uncompressed_ht VALUES ('2020-04-20 01:01', 100, 1), ('2020-05-20 01:01', 100, 1), ('2020-04-20 01:01', 200, 2); CREATE TABLE compressed_ht ( time timestamptz NOT NULL, value double precision, series_id integer ); SELECT table_name FROM create_hypertable ('compressed_ht', 'time'); table_name --------------- compressed_ht ALTER TABLE compressed_ht SET (timescaledb.compress); INSERT INTO compressed_ht VALUES ('2020-04-20 01:01', 100, 1), ('2020-05-20 01:01', 100, 1); SELECT count(compress_chunk(ch)) FROM show_chunks('compressed_ht') ch; count ------- 2 BEGIN; WITH compressed AS ( SELECT series_id FROM compressed_ht WHERE time >= '2020-04-17 17:14:24.161989+00' ) DELETE FROM uncompressed_ht WHERE series_id IN (SELECT series_id FROM compressed); ROLLBACK; -- test delete inside CTE WITH compressed AS ( DELETE FROM compressed_ht RETURNING series_id ) SELECT * FROM uncompressed_ht WHERE series_id IN (SELECT series_id FROM compressed); time | value | series_id ------------------------------+-------+----------- Mon Apr 20 01:01:00 2020 PDT | 100 | 1 Wed May 20 01:01:00 2020 PDT | 100 | 1 -- test update inside CTE is blocked WITH compressed AS ( UPDATE compressed_ht SET value = 0.2 RETURNING * ) SELECT * FROM uncompressed_ht WHERE series_id IN (SELECT series_id FROM compressed); time | value | series_id ------+-------+----------- DROP TABLE compressed_ht; DROP TABLE uncompressed_ht; -- Test that pg_stats and pg_class stats for uncompressed chunks are correctly updated after compression. -- Note that approximate_row_count pulls from pg_class CREATE TABLE stattest(time TIMESTAMPTZ NOT NULL, c1 int); SELECT create_hypertable('stattest', 'time'); create_hypertable ------------------------ (27,public,stattest,t) INSERT INTO stattest SELECT '2020/02/20 01:00'::TIMESTAMPTZ + ('1 hour'::interval * v), 250 * v FROM generate_series(0,25) v; SELECT table_name INTO TEMPORARY temptable FROM _timescaledb_catalog.chunk WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'stattest'); \set statchunk '(select table_name from temptable)' SELECT schemaname, tablename, attname, inherited, null_frac, avg_width, n_distinct, most_common_vals, most_common_freqs, histogram_bounds, correlation, most_common_elems, most_common_elem_freqs, elem_count_histogram FROM pg_stats WHERE tablename = :statchunk; schemaname | tablename | attname | inherited | null_frac | avg_width | n_distinct | most_common_vals | most_common_freqs | histogram_bounds | correlation | most_common_elems | most_common_elem_freqs | elem_count_histogram ------------+-----------+---------+-----------+-----------+-----------+------------+------------------+-------------------+------------------+-------------+-------------------+------------------------+---------------------- ALTER TABLE stattest SET (timescaledb.compress); -- check that approximate_row_count works with all normal chunks SELECT approximate_row_count('stattest'); approximate_row_count ----------------------- 0 SELECT compress_chunk(c) FROM show_chunks('stattest') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_27_55_chunk ANALYZE stattest; -- check that approximate_row_count works with all compressed chunks SELECT approximate_row_count('stattest'); approximate_row_count ----------------------- 1000 -- actual count should match with the above SELECT count(*) from stattest; count ------- 26 -- Uncompressed chunk table is empty since we just compressed the chunk and moved everything to compressed chunk table. -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE was run SELECT relpages, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END as reltuples FROM pg_class WHERE relname = :statchunk; relpages | reltuples ----------+----------- 0 | 0 SELECT compch.table_name as "STAT_COMP_CHUNK_NAME" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch , _timescaledb_catalog.chunk compch WHERE ht.table_name = 'stattest' AND ch.hypertable_id = ht.id AND compch.id = ch.compressed_chunk_id AND ch.compressed_chunk_id > 0 \gset -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE was run SELECT relpages, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END as reltuples FROM pg_class WHERE relname = :'STAT_COMP_CHUNK_NAME'; relpages | reltuples ----------+----------- 1 | 1 -- Unfortunately, the stats on the hypertable won't find any rows to sample from the chunk ANALYZE stattest; SELECT histogram_bounds FROM pg_stats WHERE tablename = 'stattest' AND attname = 'c1'; histogram_bounds ------------------ SELECT relpages, reltuples FROM pg_class WHERE relname = :statchunk; relpages | reltuples ----------+----------- 0 | 0 -- verify that corresponding compressed chunk table stats is updated as well. SELECT relpages, reltuples FROM pg_class WHERE relname = :'STAT_COMP_CHUNK_NAME'; relpages | reltuples ----------+----------- 1 | 1 -- verify that approximate_row_count works fine on a chunk with compressed data SELECT approximate_row_count('_timescaledb_internal.' || :'STAT_COMP_CHUNK_NAME'); approximate_row_count ----------------------- 1 -- Verify partial chunk stats are handled correctly when analyzing -- for both uncompressed and compressed chunk tables INSERT INTO stattest SELECT '2020/02/20 01:00'::TIMESTAMPTZ + ('1 hour'::interval * v), 250 * v FROM generate_series(25,50) v; ANALYZE stattest; SELECT histogram_bounds FROM pg_stats WHERE tablename = :statchunk AND attname = 'c1'; histogram_bounds ------------------------------------------------------------------------------------------------------------------------------------------------ {6250,6500,6750,7000,7250,7500,7750,8000,8250,8500,8750,9000,9250,9500,9750,10000,10250,10500,10750,11000,11250,11500,11750,12000,12250,12500} -- Hypertable will now see the histogram bounds since we have data in the uncompressed chunk table. SELECT histogram_bounds FROM pg_stats WHERE tablename = 'stattest' AND attname = 'c1'; histogram_bounds ------------------------------------------------------------------------------------------------------------------------------------------------ {6250,6500,6750,7000,7250,7500,7750,8000,8250,8500,8750,9000,9250,9500,9750,10000,10250,10500,10750,11000,11250,11500,11750,12000,12250,12500} -- verify that corresponding uncompressed chunk table stats is updated as well. SELECT relpages, reltuples FROM pg_class WHERE relname = :statchunk; relpages | reltuples ----------+----------- 1 | 26 -- verify that corresponding compressed chunk table stats have not changed since -- we didn't compress anything new. SELECT relpages, reltuples FROM pg_class WHERE relname = :'STAT_COMP_CHUNK_NAME'; relpages | reltuples ----------+----------- 1 | 1 -- verify that approximate_row_count works fine on a chunk with a mix of uncompressed -- and compressed data SELECT table_name as "STAT_CHUNK_NAME" from temptable \gset SELECT approximate_row_count('_timescaledb_internal.' || :'STAT_CHUNK_NAME'); approximate_row_count ----------------------- 1026 -- should match with the result via the hypertable post in-memory decompression SELECT count(*) from stattest; count ------- 52 SELECT count(*) from show_chunks('stattest'); count ------- 1 -- Verify that decompressing the chunk restores autoanalyze to the hypertable's setting SELECT reloptions FROM pg_class WHERE relname = :statchunk; reloptions ------------ SELECT decompress_chunk(c) FROM show_chunks('stattest') c; decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_27_55_chunk SELECT reloptions FROM pg_class WHERE relname = :statchunk; reloptions ------------ SELECT compress_chunk(c) FROM show_chunks('stattest') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_27_55_chunk SELECT reloptions FROM pg_class WHERE relname = :statchunk; reloptions ------------ ALTER TABLE stattest SET (autovacuum_enabled = false); SELECT decompress_chunk(c) FROM show_chunks('stattest') c; decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_27_55_chunk SELECT reloptions FROM pg_class WHERE relname = :statchunk; reloptions ---------------------------- {autovacuum_enabled=false} -- Verify that even a global analyze works as well, changing message scope here -- to hide WARNINGs for skipped tables SET client_min_messages TO ERROR; ANALYZE; SET client_min_messages TO NOTICE; SELECT histogram_bounds FROM pg_stats WHERE tablename = :statchunk and attname = 'c1'; histogram_bounds ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ {0,250,500,750,1000,1250,1500,1750,2000,2250,2500,2750,3000,3250,3500,3750,4000,4250,4500,4750,5000,5250,5500,5750,6000,6500,6750,7000,7250,7500,7750,8000,8250,8500,8750,9000,9250,9500,9750,10000,10250,10500,10750,11000,11250,11500,11750,12000,12250,12500} SELECT relpages, reltuples FROM pg_class WHERE relname = :statchunk; relpages | reltuples ----------+----------- 1 | 52 --- Test that analyze on compression internal table updates stats on original chunks CREATE TABLE stattest2(time TIMESTAMPTZ NOT NULL, c1 int, c2 int); SELECT create_hypertable('stattest2', 'time', chunk_time_interval=>'1 day'::interval); create_hypertable ------------------------- (29,public,stattest2,t) ALTER TABLE stattest2 SET (timescaledb.compress, timescaledb.compress_segmentby='c1'); INSERT INTO stattest2 SELECT '2020/06/20 01:00'::TIMESTAMPTZ ,1 , generate_series(1, 200, 1); INSERT INTO stattest2 SELECT '2020/07/20 01:00'::TIMESTAMPTZ ,1 , generate_series(1, 200, 1); SELECT compress_chunk(ch) FROM show_chunks('stattest2') ch LIMIT 1; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_58_chunk -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE has been run SELECT relname, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END AS reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) order by relname; relname | reltuples | relpages | relallvisible --------------------+-----------+----------+--------------- _hyper_29_58_chunk | 0 | 0 | 0 _hyper_29_59_chunk | 0 | 0 | 0 \c :TEST_DBNAME :ROLE_SUPERUSER --overwrite pg_class stats for the compressed chunk. UPDATE pg_class SET reltuples = 0, relpages = 0 WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id AND ch.compressed_chunk_id > 0 ); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE has been run SELECT relname, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END AS reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) order by relname; relname | reltuples | relpages | relallvisible --------------------+-----------+----------+--------------- _hyper_29_58_chunk | 0 | 0 | 0 _hyper_29_59_chunk | 0 | 0 | 0 SELECT '_timescaledb_internal.' || compht.table_name as "STAT_COMP_TABLE", compht.table_name as "STAT_COMP_TABLE_NAME" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.hypertable compht WHERE ht.table_name = 'stattest2' AND ht.compressed_hypertable_id = compht.id \gset --analyze the compressed table, will update stats for the raw table. ANALYZE :STAT_COMP_TABLE; -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE has been run SELECT relname, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END AS reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) ORDER BY relname; relname | reltuples | relpages | relallvisible --------------------+-----------+----------+--------------- _hyper_29_58_chunk | 0 | 0 | 0 _hyper_29_59_chunk | 0 | 0 | 0 SELECT relname, reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = :'STAT_COMP_TABLE_NAME' AND ch.hypertable_id = ht.id ) ORDER BY relname; relname | reltuples | relpages | relallvisible ----------------------------+-----------+----------+--------------- compress_hyper_30_60_chunk | -1 | 0 | 0 --analyze on stattest2 should not overwrite ANALYZE stattest2; SELECT relname, reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) ORDER BY relname; relname | reltuples | relpages | relallvisible --------------------+-----------+----------+--------------- _hyper_29_58_chunk | 0 | 0 | 0 _hyper_29_59_chunk | 200 | 2 | 0 SELECT relname, reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = :'STAT_COMP_TABLE_NAME' AND ch.hypertable_id = ht.id ) ORDER BY relname; relname | reltuples | relpages | relallvisible ----------------------------+-----------+----------+--------------- compress_hyper_30_60_chunk | 1 | 1 | 0 -- analyze on compressed hypertable should restore stats -- Test approximate_row_count() with compressed hypertable -- CREATE TABLE approx_count(time timestamptz not null, device int, temp float); SELECT create_hypertable('approx_count', 'time'); create_hypertable ---------------------------- (31,public,approx_count,t) INSERT INTO approx_count SELECT t, (abs(timestamp_hash(t::timestamp)) % 10) + 1, random()*80 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-04 1:00', '1 hour') t; SELECT count(*) FROM approx_count; count ------- 49 ALTER TABLE approx_count SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby = 'time DESC'); SELECT approximate_row_count('approx_count'); approximate_row_count ----------------------- 0 ANALYZE approx_count; SELECT approximate_row_count('approx_count'); approximate_row_count ----------------------- 49 DROP TABLE approx_count; --TEST drop_chunks from a compressed hypertable (that has caggs defined). -- chunk metadata is still retained. verify correct status for chunk SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 2 SELECT drop_chunks('metrics', older_than=>'1 day'::interval); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_13_33_chunk _timescaledb_internal._hyper_13_34_chunk SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id ------------+--------------+---------+--------- SELECT "time", cnt FROM cagg_expr ORDER BY time LIMIT 5; time | cnt ------------------------------+------ Fri Dec 31 16:00:00 1999 PST | 960 Sat Jan 01 16:00:00 2000 PST | 1440 Sun Jan 02 16:00:00 2000 PST | 1440 Mon Jan 03 16:00:00 2000 PST | 1440 Tue Jan 04 16:00:00 2000 PST | 1440 --now reload data into the dropped chunks region, then compress -- then verify chunk status/dropped column INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 2 SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; chunk_name | chunk_status | dropped | comp_id --------------------+--------------+---------+--------- _hyper_13_64_chunk | 1 | f | 66 _hyper_13_65_chunk | 1 | f | 67 SELECT count(*) FROM metrics; count ------- 12961 -- TODO: remove this test in a separate PR since it introduces -- a lot of changes which hurt readability of test output -- test sequence number is local to segment by CREATE TABLE local_seq(time timestamptz, device int); SELECT table_name FROM create_hypertable('local_seq','time'); table_name ------------ local_seq ALTER TABLE local_seq SET(timescaledb.compress,timescaledb.compress_segmentby='device'); INSERT INTO local_seq SELECT '2000-01-01',1 FROM generate_series(1,3000); INSERT INTO local_seq SELECT '2000-01-01',2 FROM generate_series(1,3500); INSERT INTO local_seq SELECT '2000-01-01',3 FROM generate_series(1,3000); INSERT INTO local_seq SELECT '2000-01-01',4 FROM generate_series(1,3000); INSERT INTO local_seq SELECT '2000-01-01', generate_series(5,8); SELECT compress_chunk(c) FROM show_chunks('local_seq') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_33_68_chunk -- github issue 4872 -- If subplan of ConstraintAwareAppend is TidRangeScan, then SELECT on -- hypertable fails with error "invalid child of chunk append: Node (26)" CREATE TABLE tidrangescan_test(time timestamptz, device_id int, v1 float, v2 float); SELECT create_hypertable('tidrangescan_test','time'); create_hypertable --------------------------------- (35,public,tidrangescan_test,t) INSERT INTO tidrangescan_test SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; CREATE MATERIALIZED VIEW tidrangescan_expr WITH (timescaledb.continuous) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(tidrangescan_test,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2, count(*) AS cnt FROM tidrangescan_test WHERE ctid < '(1,1)'::tid GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('tidrangescan_expr', NULL, NULL); SET timescaledb.enable_chunk_append to off; SET enable_indexscan to off; SELECT time, const, numeric,first, avg1, avg2 FROM tidrangescan_expr ORDER BY time LIMIT 5; time | const | numeric | first | avg1 | avg2 ------------------------------+-------+---------+----------------------------------------------+------+------ Fri Dec 31 16:00:00 1999 PST | Const | 4.3 | ("Sat Jan 01 00:00:00 2000 PST",1,0.25,0.75) | 1 | 1 Wed Jan 05 16:00:00 2000 PST | Const | 4.3 | ("Wed Jan 05 16:00:00 2000 PST",1,0.25,0.75) | 1 | 1 RESET timescaledb.enable_chunk_append; RESET enable_indexscan; -- Test the number of allocated parallel workers for decompression -- Test that a parallel plan is generated -- with different number of parallel workers CREATE TABLE f_sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL, cpu double precision NULL, temperature double precision NULL ); SELECT FROM create_hypertable('f_sensor_data','time'); -- SELECT set_chunk_time_interval('f_sensor_data', INTERVAL '1 year'); set_chunk_time_interval ------------------------- -- Create one chunk manually to ensure, all data is inserted into one chunk SELECT * FROM _timescaledb_functions.create_chunk('f_sensor_data',' {"time": [181900977000000, 515024000000000]}'); chunk_id | hypertable_id | schema_name | table_name | relkind | slices | created ----------+---------------+-----------------------+--------------------+---------+----------------------------------------------+--------- 73 | 37 | _timescaledb_internal | _hyper_37_73_chunk | r | {"time": [181900977000000, 515024000000000]} | t INSERT INTO f_sensor_data SELECT time AS time, sensor_id, 100.0, 36.6 FROM generate_series('1980-01-01 00:00'::timestamp, '1980-02-28 12:00', INTERVAL '1 day') AS g1(time), generate_series(1, 1700, 1 ) AS g2(sensor_id) ORDER BY time; ALTER TABLE f_sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby='sensor_id' ,timescaledb.compress_orderby = 'time DESC'); SELECT compress_chunk(i) FROM show_chunks('f_sensor_data') i; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_37_73_chunk VACUUM ANALYZE f_sensor_data; -- Encourage use of parallel plans SET max_parallel_workers_per_gather = 4; SET min_parallel_index_scan_size = 0; SET min_parallel_table_scan_size = 0; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SHOW max_parallel_workers; max_parallel_workers ---------------------- 8 \set explain 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- We disable enable_parallel_append here to ensure -- that we create the same query plan in all PG 14.X versions SET enable_parallel_append = false; :explain SELECT sum(cpu) FROM f_sensor_data; --- QUERY PLAN --- Finalize Aggregate Output: sum(_hyper_37_73_chunk.cpu) -> Gather Output: (PARTIAL sum(_hyper_37_73_chunk.cpu)) Workers Planned: 4 -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_37_73_chunk.cpu)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_37_73_chunk Output: _hyper_37_73_chunk.cpu -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_38_74_chunk Output: compress_hyper_38_74_chunk._ts_meta_count, compress_hyper_38_74_chunk.sensor_id, compress_hyper_38_74_chunk._ts_meta_min_1, compress_hyper_38_74_chunk._ts_meta_max_1, compress_hyper_38_74_chunk."time", compress_hyper_38_74_chunk.cpu, compress_hyper_38_74_chunk.temperature CREATE INDEX ON f_sensor_data (time, sensor_id); :explain SELECT * FROM f_sensor_data WHERE sensor_id > 1000; --- QUERY PLAN --- Gather Output: _hyper_37_73_chunk."time", _hyper_37_73_chunk.sensor_id, _hyper_37_73_chunk.cpu, _hyper_37_73_chunk.temperature Workers Planned: 2 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_37_73_chunk Output: _hyper_37_73_chunk."time", _hyper_37_73_chunk.sensor_id, _hyper_37_73_chunk.cpu, _hyper_37_73_chunk.temperature -> Parallel Index Scan using compress_hyper_38_74_chunk_sensor_id__ts_meta_min_1__ts_met_idx on _timescaledb_internal.compress_hyper_38_74_chunk Output: compress_hyper_38_74_chunk._ts_meta_count, compress_hyper_38_74_chunk.sensor_id, compress_hyper_38_74_chunk._ts_meta_min_1, compress_hyper_38_74_chunk._ts_meta_max_1, compress_hyper_38_74_chunk."time", compress_hyper_38_74_chunk.cpu, compress_hyper_38_74_chunk.temperature Index Cond: (compress_hyper_38_74_chunk.sensor_id > 1000) RESET enable_parallel_append; -- Test for partially compressed chunks INSERT INTO f_sensor_data SELECT time AS time, sensor_id, 100.0, 36.6 FROM generate_series('1980-01-01 00:00'::timestamp, '1980-01-30 12:00', INTERVAL '1 day') AS g1(time), generate_series(1700, 1800, 1 ) AS g2(sensor_id) ORDER BY time; VACUUM ANALYZE f_sensor_data; :explain SELECT sum(cpu) FROM f_sensor_data; --- QUERY PLAN --- Finalize Aggregate Output: sum(f_sensor_data.cpu) -> Gather Output: (PARTIAL sum(f_sensor_data.cpu)) Workers Planned: 4 -> Parallel Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_37_73_chunk.cpu)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_37_73_chunk Output: _hyper_37_73_chunk.cpu -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_38_74_chunk Output: compress_hyper_38_74_chunk._ts_meta_count, compress_hyper_38_74_chunk.sensor_id, compress_hyper_38_74_chunk._ts_meta_min_1, compress_hyper_38_74_chunk._ts_meta_max_1, compress_hyper_38_74_chunk."time", compress_hyper_38_74_chunk.cpu, compress_hyper_38_74_chunk.temperature -> Partial Aggregate Output: PARTIAL sum(_hyper_37_73_chunk.cpu) -> Parallel Seq Scan on _timescaledb_internal._hyper_37_73_chunk Output: _hyper_37_73_chunk.cpu :explain SELECT * FROM f_sensor_data WHERE sensor_id > 1000; --- QUERY PLAN --- Gather Output: f_sensor_data."time", f_sensor_data.sensor_id, f_sensor_data.cpu, f_sensor_data.temperature Workers Planned: 3 -> Parallel Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_37_73_chunk Output: _hyper_37_73_chunk."time", _hyper_37_73_chunk.sensor_id, _hyper_37_73_chunk.cpu, _hyper_37_73_chunk.temperature Filter: (_hyper_37_73_chunk.sensor_id > 1000) -> Parallel Index Scan using compress_hyper_38_74_chunk_sensor_id__ts_meta_min_1__ts_met_idx on _timescaledb_internal.compress_hyper_38_74_chunk Output: compress_hyper_38_74_chunk._ts_meta_count, compress_hyper_38_74_chunk.sensor_id, compress_hyper_38_74_chunk._ts_meta_min_1, compress_hyper_38_74_chunk._ts_meta_max_1, compress_hyper_38_74_chunk."time", compress_hyper_38_74_chunk.cpu, compress_hyper_38_74_chunk.temperature Index Cond: (compress_hyper_38_74_chunk.sensor_id > 1000) -> Parallel Seq Scan on _timescaledb_internal._hyper_37_73_chunk Output: _hyper_37_73_chunk."time", _hyper_37_73_chunk.sensor_id, _hyper_37_73_chunk.cpu, _hyper_37_73_chunk.temperature Filter: (_hyper_37_73_chunk.sensor_id > 1000) -- Test non-partial paths below append are not executed multiple times CREATE TABLE ts_device_table(time INTEGER, device INTEGER, location INTEGER, value INTEGER); CREATE UNIQUE INDEX device_time_idx on ts_device_table(time, device); SELECT create_hypertable('ts_device_table', 'time', chunk_time_interval => 1000); create_hypertable ------------------------------- (39,public,ts_device_table,t) INSERT INTO ts_device_table SELECT generate_series(0,999,1), 1, 100, 20; ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_segmentby='location', timescaledb.compress_orderby='time'); WARNING: column "device" should be used for segmenting or ordering SELECT compress_chunk(i) AS chunk_name FROM show_chunks('ts_device_table') i \gset VACUUM ANALYZE ts_device_table; SELECT count(*) FROM ts_device_table; count ------- 1000 SELECT count(*) FROM :chunk_name; count ------- 1000 INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; SELECT count(*) FROM :chunk_name; count ------- 1000 SET parallel_setup_cost TO '0'; SET parallel_tuple_cost TO '0'; SET min_parallel_table_scan_size TO '8'; SET min_parallel_index_scan_size TO '8'; SET random_page_cost TO '0'; SELECT count(*) FROM :chunk_name; count ------- 1000 ANALYZE :chunk_name; SELECT count(*) FROM :chunk_name; count ------- 1000 -- Test that parallel plans are chosen even if partial and small chunks are involved RESET min_parallel_index_scan_size; RESET min_parallel_table_scan_size; CREATE TABLE ht_metrics_partially_compressed(time timestamptz, device int, value float); SELECT create_hypertable('ht_metrics_partially_compressed','time',create_default_indexes:=false); create_hypertable ----------------------------------------------- (41,public,ht_metrics_partially_compressed,t) ALTER TABLE ht_metrics_partially_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO ht_metrics_partially_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-01'::timestamptz,'2020-01-02'::timestamptz, INTERVAL '1 m') g(time), LATERAL (SELECT generate_series(1,2) AS device) g2; SELECT compress_chunk(c) FROM show_chunks('ht_metrics_partially_compressed') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_77_chunk _timescaledb_internal._hyper_41_78_chunk INSERT INTO ht_metrics_partially_compressed VALUES ('2020-01-01'::timestamptz, 1, 0.1); VACUUM ANALYZE ht_metrics_partially_compressed; :explain SELECT * FROM ht_metrics_partially_compressed ORDER BY time DESC, device LIMIT 1; --- QUERY PLAN --- Limit Output: ht_metrics_partially_compressed."time", ht_metrics_partially_compressed.device, ht_metrics_partially_compressed.value -> Custom Scan (ChunkAppend) on public.ht_metrics_partially_compressed Output: ht_metrics_partially_compressed."time", ht_metrics_partially_compressed.device, ht_metrics_partially_compressed.value Order: ht_metrics_partially_compressed."time" DESC, ht_metrics_partially_compressed.device Startup Exclusion: false Runtime Exclusion: false -> Sort Output: _hyper_41_78_chunk."time", _hyper_41_78_chunk.device, _hyper_41_78_chunk.value Sort Key: _hyper_41_78_chunk."time" DESC, _hyper_41_78_chunk.device -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_41_78_chunk Output: _hyper_41_78_chunk."time", _hyper_41_78_chunk.device, _hyper_41_78_chunk.value -> Seq Scan on _timescaledb_internal.compress_hyper_42_80_chunk Output: compress_hyper_42_80_chunk._ts_meta_count, compress_hyper_42_80_chunk.device, compress_hyper_42_80_chunk._ts_meta_min_1, compress_hyper_42_80_chunk._ts_meta_max_1, compress_hyper_42_80_chunk."time", compress_hyper_42_80_chunk.value -> Merge Append Sort Key: ht_metrics_partially_compressed."time" DESC, ht_metrics_partially_compressed.device -> Sort Output: _hyper_41_77_chunk."time", _hyper_41_77_chunk.device, _hyper_41_77_chunk.value Sort Key: _hyper_41_77_chunk."time" DESC, _hyper_41_77_chunk.device -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_41_77_chunk Output: _hyper_41_77_chunk."time", _hyper_41_77_chunk.device, _hyper_41_77_chunk.value -> Seq Scan on _timescaledb_internal.compress_hyper_42_79_chunk Output: compress_hyper_42_79_chunk._ts_meta_count, compress_hyper_42_79_chunk.device, compress_hyper_42_79_chunk._ts_meta_min_1, compress_hyper_42_79_chunk._ts_meta_max_1, compress_hyper_42_79_chunk."time", compress_hyper_42_79_chunk.value -> Sort Output: _hyper_41_77_chunk."time", _hyper_41_77_chunk.device, _hyper_41_77_chunk.value Sort Key: _hyper_41_77_chunk."time" DESC, _hyper_41_77_chunk.device -> Seq Scan on _timescaledb_internal._hyper_41_77_chunk Output: _hyper_41_77_chunk."time", _hyper_41_77_chunk.device, _hyper_41_77_chunk.value -- Test parameter change on rescan -- issue 6069 CREATE TABLE IF NOT EXISTS i6069 ( timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL, attr_id SMALLINT NOT NULL, number_val DOUBLE PRECISION DEFAULT NULL ); SELECT table_name FROM create_hypertable( 'i6069', 'timestamp', create_default_indexes => FALSE, if_not_exists => TRUE, chunk_time_interval => INTERVAL '1 day' ); WARNING: column type "timestamp without time zone" used for "timestamp" does not follow best practices table_name ------------ i6069 ALTER TABLE i6069 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'attr_id' ); INSERT INTO i6069 VALUES('2023-07-01', 1, 1),('2023-07-03', 2, 1),('2023-07-05', 3, 1), ('2023-07-01', 4, 1),('2023-07-03', 5, 1),('2023-07-05', 6, 1), ('2023-07-01', 7, 1),('2023-07-03', 8, 1),('2023-07-05', 9, 1), ('2023-07-01', 10, 1),('2023-07-03', 11, 1),('2023-07-05', 12, 1), ('2023-07-01', 13, 1),('2023-07-03', 14, 1),('2023-07-05', 15, 1), ('2023-07-01', 16, 1),('2023-07-03', 17, 1),('2023-07-05', 18, 1), ('2023-07-01', 19, 1),('2023-07-03', 20, 1),('2023-07-05', 21, 1), ('2023-07-01', 22, 1),('2023-07-03', 23, 1),('2023-07-05', 24, 1), ('2023-07-01', 25, 1),('2023-07-03', 26, 1),('2023-07-05', 27, 1), ('2023-07-01', 28, 1),('2023-07-03', 29, 1),('2023-07-05', 30, 1), ('2023-07-01', 31, 1),('2023-07-03', 32, 1),('2023-07-05', 33, 1), ('2023-07-01', 34, 1),('2023-07-03', 35, 1),('2023-07-05', 36, 1), ('2023-07-01', 37, 1),('2023-07-03', 38, 1),('2023-07-05', 39, 1), ('2023-07-01', 40, 1),('2023-07-03', 41, 1),('2023-07-05', 42, 1), ('2023-07-01', 43, 1),('2023-07-03', 44, 1),('2023-07-05', 45, 1), ('2023-07-01', 46, 1),('2023-07-03', 47, 1),('2023-07-05', 48, 1), ('2023-07-01', 49, 1),('2023-07-03', 50, 1),('2023-07-05', 51, 1), ('2023-07-01', 52, 1),('2023-07-03', 53, 1),('2023-07-05', 54, 1), ('2023-07-01', 55, 1),('2023-07-03', 56, 1),('2023-07-05', 57, 1), ('2023-07-01', 58, 1),('2023-07-03', 59, 1),('2023-07-05', 60, 1), ('2023-07-01', 61, 1),('2023-07-03', 62, 1),('2023-07-05', 63, 1), ('2023-07-01', 64, 1),('2023-07-03', 65, 1),('2023-07-05', 66, 1), ('2023-07-01', 67, 1),('2023-07-03', 68, 1),('2023-07-05', 69, 1), ('2023-07-01', 70, 1),('2023-07-03', 71, 1),('2023-07-05', 72, 1), ('2023-07-01', 73, 1),('2023-07-03', 74, 1),('2023-07-05', 75, 1), ('2023-07-01', 76, 1),('2023-07-03', 77, 1),('2023-07-05', 78, 1), ('2023-07-01', 79, 1),('2023-07-03', 80, 1),('2023-07-05', 81, 1), ('2023-07-01', 82, 1),('2023-07-03', 83, 1),('2023-07-05', 84, 1), ('2023-07-01', 85, 1),('2023-07-03', 86, 1),('2023-07-05', 87, 1), ('2023-07-01', 88, 1),('2023-07-03', 89, 1),('2023-07-05', 90, 1), ('2023-07-01', 91, 1),('2023-07-03', 92, 1),('2023-07-05', 93, 1), ('2023-07-01', 94, 1),('2023-07-03', 95, 1),('2023-07-05', 96, 1), ('2023-07-01', 97, 1),('2023-07-03', 98, 1),('2023-07-05', 99, 1), ('2023-07-01', 100, 1),('2023-07-03', 101, 1),('2023-07-05', 102, 1), ('2023-07-01', 103, 1),('2023-07-03', 104, 1),('2023-07-05', 105, 1), ('2023-07-01', 106, 1),('2023-07-03', 107, 1),('2023-07-05', 108, 1), ('2023-07-01', 109, 1),('2023-07-03', 110, 1),('2023-07-05', 111, 1), ('2023-07-01', 112, 1),('2023-07-03', 113, 1),('2023-07-05', 114, 1), ('2023-07-01', 115, 1),('2023-07-03', 116, 1),('2023-07-05', 117, 1), ('2023-07-01', 118, 1),('2023-07-03', 119, 1),('2023-07-05', 120, 1); SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('i6069') i; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_43_81_chunk _timescaledb_internal._hyper_43_82_chunk _timescaledb_internal._hyper_43_83_chunk VACUUM ANALYZE i6069; SET enable_indexscan = ON; SET enable_seqscan = OFF; :explain SELECT * FROM ( VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(10) ) AS attr_ids(attr_id) INNER JOIN LATERAL ( SELECT * FROM i6069 WHERE i6069.attr_id = attr_ids.attr_id AND timestamp > '2023-06-30' AND timestamp < '2023-07-06' ORDER BY timestamp desc LIMIT 1 ) a ON true; --- QUERY PLAN --- Nested Loop Output: "*VALUES*".column1, i6069."timestamp", i6069.attr_id, i6069.number_val -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 -> Limit Output: i6069."timestamp", i6069.attr_id, i6069.number_val -> Custom Scan (ChunkAppend) on public.i6069 Output: i6069."timestamp", i6069.attr_id, i6069.number_val Order: i6069."timestamp" DESC Startup Exclusion: false Runtime Exclusion: true -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_43_83_chunk Output: _hyper_43_83_chunk."timestamp", _hyper_43_83_chunk.attr_id, _hyper_43_83_chunk.number_val Filter: ((_hyper_43_83_chunk."timestamp" > 'Fri Jun 30 00:00:00 2023'::timestamp without time zone) AND (_hyper_43_83_chunk."timestamp" < 'Thu Jul 06 00:00:00 2023'::timestamp without time zone)) Batch Sorted Merge: true -> Sort Output: compress_hyper_44_86_chunk._ts_meta_count, compress_hyper_44_86_chunk.attr_id, compress_hyper_44_86_chunk._ts_meta_min_1, compress_hyper_44_86_chunk._ts_meta_max_1, compress_hyper_44_86_chunk."timestamp", compress_hyper_44_86_chunk.number_val Sort Key: compress_hyper_44_86_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_44_86_chunk_attr_id__ts_meta_min_1__ts_meta__idx on _timescaledb_internal.compress_hyper_44_86_chunk Output: compress_hyper_44_86_chunk._ts_meta_count, compress_hyper_44_86_chunk.attr_id, compress_hyper_44_86_chunk._ts_meta_min_1, compress_hyper_44_86_chunk._ts_meta_max_1, compress_hyper_44_86_chunk."timestamp", compress_hyper_44_86_chunk.number_val Index Cond: ((compress_hyper_44_86_chunk.attr_id = "*VALUES*".column1) AND (compress_hyper_44_86_chunk._ts_meta_min_1 < 'Thu Jul 06 00:00:00 2023'::timestamp without time zone) AND (compress_hyper_44_86_chunk._ts_meta_max_1 > 'Fri Jun 30 00:00:00 2023'::timestamp without time zone)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_43_82_chunk Output: _hyper_43_82_chunk."timestamp", _hyper_43_82_chunk.attr_id, _hyper_43_82_chunk.number_val Filter: ((_hyper_43_82_chunk."timestamp" > 'Fri Jun 30 00:00:00 2023'::timestamp without time zone) AND (_hyper_43_82_chunk."timestamp" < 'Thu Jul 06 00:00:00 2023'::timestamp without time zone)) Batch Sorted Merge: true -> Sort Output: compress_hyper_44_85_chunk._ts_meta_count, compress_hyper_44_85_chunk.attr_id, compress_hyper_44_85_chunk._ts_meta_min_1, compress_hyper_44_85_chunk._ts_meta_max_1, compress_hyper_44_85_chunk."timestamp", compress_hyper_44_85_chunk.number_val Sort Key: compress_hyper_44_85_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_44_85_chunk_attr_id__ts_meta_min_1__ts_meta__idx on _timescaledb_internal.compress_hyper_44_85_chunk Output: compress_hyper_44_85_chunk._ts_meta_count, compress_hyper_44_85_chunk.attr_id, compress_hyper_44_85_chunk._ts_meta_min_1, compress_hyper_44_85_chunk._ts_meta_max_1, compress_hyper_44_85_chunk."timestamp", compress_hyper_44_85_chunk.number_val Index Cond: ((compress_hyper_44_85_chunk.attr_id = "*VALUES*".column1) AND (compress_hyper_44_85_chunk._ts_meta_min_1 < 'Thu Jul 06 00:00:00 2023'::timestamp without time zone) AND (compress_hyper_44_85_chunk._ts_meta_max_1 > 'Fri Jun 30 00:00:00 2023'::timestamp without time zone)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_43_81_chunk Output: _hyper_43_81_chunk."timestamp", _hyper_43_81_chunk.attr_id, _hyper_43_81_chunk.number_val Filter: ((_hyper_43_81_chunk."timestamp" > 'Fri Jun 30 00:00:00 2023'::timestamp without time zone) AND (_hyper_43_81_chunk."timestamp" < 'Thu Jul 06 00:00:00 2023'::timestamp without time zone)) Batch Sorted Merge: true -> Sort Output: compress_hyper_44_84_chunk._ts_meta_count, compress_hyper_44_84_chunk.attr_id, compress_hyper_44_84_chunk._ts_meta_min_1, compress_hyper_44_84_chunk._ts_meta_max_1, compress_hyper_44_84_chunk."timestamp", compress_hyper_44_84_chunk.number_val Sort Key: compress_hyper_44_84_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_44_84_chunk_attr_id__ts_meta_min_1__ts_meta__idx on _timescaledb_internal.compress_hyper_44_84_chunk Output: compress_hyper_44_84_chunk._ts_meta_count, compress_hyper_44_84_chunk.attr_id, compress_hyper_44_84_chunk._ts_meta_min_1, compress_hyper_44_84_chunk._ts_meta_max_1, compress_hyper_44_84_chunk."timestamp", compress_hyper_44_84_chunk.number_val Index Cond: ((compress_hyper_44_84_chunk.attr_id = "*VALUES*".column1) AND (compress_hyper_44_84_chunk._ts_meta_min_1 < 'Thu Jul 06 00:00:00 2023'::timestamp without time zone) AND (compress_hyper_44_84_chunk._ts_meta_max_1 > 'Fri Jun 30 00:00:00 2023'::timestamp without time zone)) SELECT * FROM ( VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(10) ) AS attr_ids(attr_id) INNER JOIN LATERAL ( SELECT * FROM i6069 WHERE i6069.attr_id = attr_ids.attr_id AND timestamp > '2023-06-30' AND timestamp < '2023-07-06' ORDER BY timestamp desc LIMIT 1 ) a ON true; attr_id | timestamp | attr_id | number_val ---------+--------------------------+---------+------------ 1 | Sat Jul 01 00:00:00 2023 | 1 | 1 2 | Mon Jul 03 00:00:00 2023 | 2 | 1 3 | Wed Jul 05 00:00:00 2023 | 3 | 1 4 | Sat Jul 01 00:00:00 2023 | 4 | 1 5 | Mon Jul 03 00:00:00 2023 | 5 | 1 6 | Wed Jul 05 00:00:00 2023 | 6 | 1 7 | Sat Jul 01 00:00:00 2023 | 7 | 1 8 | Mon Jul 03 00:00:00 2023 | 8 | 1 9 | Wed Jul 05 00:00:00 2023 | 9 | 1 10 | Sat Jul 01 00:00:00 2023 | 10 | 1 RESET enable_indexscan; RESET enable_seqscan; -- When all chunks are compressed and a limit query is performed, only the needed -- chunks should be accessed CREATE TABLE sensor_data_compressed ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); SELECT FROM create_hypertable('sensor_data_compressed', 'time'); -- INSERT INTO sensor_data_compressed (time, sensor_id, cpu, temperature) VALUES ('1980-01-02 00:00:00-00', 1, 3, 12.0), ('1980-01-03 00:00:00-00', 3, 4, 15.0), ('1980-02-04 00:00:00-00', 1, 2, 17.0), ('1980-02-05 00:00:00-00', 3, 6, 11.0), ('1980-03-06 00:00:00-00', 1, 8, 13.0), ('1980-03-07 00:00:00-00', 3, 4, 4.0), ('1980-04-08 00:00:00-00', 1, 2, 1.0), ('1980-04-03 00:00:00-00', 3, 5, 33.0), ('1980-05-02 00:00:00-00', 1, 8, 41.0), ('1980-05-03 00:00:00-00', 3, 4, 22.0), ('1980-06-02 00:00:00-00', 1, 1, 45.0), ('1980-06-03 00:00:00-00', 3, 3, 44.0); ALTER TABLE sensor_data_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='sensor_id', timescaledb.compress_orderby = 'time DESC'); -- Increase work_mem slightly so that the batch sorted merge plan is not disabled. SET work_mem = '16MB'; -- Compress three of the chunks SELECT compress_chunk(ch) FROM show_chunks('sensor_data_compressed') ch LIMIT 3; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_45_87_chunk _timescaledb_internal._hyper_45_88_chunk _timescaledb_internal._hyper_45_89_chunk VACUUM ANALYZE sensor_data_compressed; SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; time | sensor_id | cpu | temperature ------------------------------+-----------+-----+------------- Mon Jun 02 17:00:00 1980 PDT | 3 | 3 | 44 Sun Jun 01 17:00:00 1980 PDT | 1 | 1 | 45 Fri May 02 17:00:00 1980 PDT | 3 | 4 | 22 Thu May 01 17:00:00 1980 PDT | 1 | 8 | 41 Mon Apr 07 16:00:00 1980 PST | 1 | 2 | 1 -- Only the first chunks should be accessed (batch sorted merge is enabled) :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature -> Custom Scan (ChunkAppend) on public.sensor_data_compressed (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature Order: sensor_data_compressed."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Index Scan using _hyper_45_93_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_93_chunk (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature -> Index Scan using _hyper_45_92_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_92_chunk (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature -> Index Scan using _hyper_45_91_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_91_chunk (actual rows=1.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature -> Index Scan using _hyper_45_90_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_90_chunk (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_89_chunk (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature Sort Key: compress_hyper_46_96_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_96_chunk (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_88_chunk (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature Sort Key: compress_hyper_46_95_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_95_chunk (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature Sort Key: compress_hyper_46_94_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_94_chunk (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature -- Only the first chunks should be accessed (batch sorted merge is disabled) SET timescaledb.enable_decompression_sorted_merge = FALSE; :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature -> Custom Scan (ChunkAppend) on public.sensor_data_compressed (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature Order: sensor_data_compressed."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Index Scan using _hyper_45_93_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_93_chunk (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature -> Index Scan using _hyper_45_92_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_92_chunk (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature -> Index Scan using _hyper_45_91_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_91_chunk (actual rows=1.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature -> Index Scan using _hyper_45_90_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_90_chunk (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature -> Sort (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Sort Key: _hyper_45_89_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_89_chunk (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_96_chunk (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature -> Sort (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Sort Key: _hyper_45_88_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_88_chunk (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_95_chunk (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature -> Sort (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Sort Key: _hyper_45_87_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_94_chunk (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature RESET timescaledb.enable_decompression_sorted_merge; -- Compress the remaining chunks SELECT compress_chunk(ch, if_not_compressed => true) FROM show_chunks('sensor_data_compressed') ch; NOTICE: chunk "_hyper_45_87_chunk" is already converted to columnstore NOTICE: chunk "_hyper_45_88_chunk" is already converted to columnstore NOTICE: chunk "_hyper_45_89_chunk" is already converted to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_45_87_chunk _timescaledb_internal._hyper_45_88_chunk _timescaledb_internal._hyper_45_89_chunk _timescaledb_internal._hyper_45_90_chunk _timescaledb_internal._hyper_45_91_chunk _timescaledb_internal._hyper_45_92_chunk _timescaledb_internal._hyper_45_93_chunk VACUUM ANALYZE sensor_data_compressed; SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; time | sensor_id | cpu | temperature ------------------------------+-----------+-----+------------- Mon Jun 02 17:00:00 1980 PDT | 3 | 3 | 44 Sun Jun 01 17:00:00 1980 PDT | 1 | 1 | 45 Fri May 02 17:00:00 1980 PDT | 3 | 4 | 22 Thu May 01 17:00:00 1980 PDT | 1 | 8 | 41 Mon Apr 07 16:00:00 1980 PST | 1 | 2 | 1 -- Only the first chunks should be accessed (batch sorted merge is enabled) :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature -> Custom Scan (ChunkAppend) on public.sensor_data_compressed (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature Order: sensor_data_compressed."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_93_chunk (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_46_100_chunk._ts_meta_count, compress_hyper_46_100_chunk.sensor_id, compress_hyper_46_100_chunk._ts_meta_min_1, compress_hyper_46_100_chunk._ts_meta_max_1, compress_hyper_46_100_chunk."time", compress_hyper_46_100_chunk.cpu, compress_hyper_46_100_chunk.temperature Sort Key: compress_hyper_46_100_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_46_100_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_100_chunk._ts_meta_count, compress_hyper_46_100_chunk.sensor_id, compress_hyper_46_100_chunk._ts_meta_min_1, compress_hyper_46_100_chunk._ts_meta_max_1, compress_hyper_46_100_chunk."time", compress_hyper_46_100_chunk.cpu, compress_hyper_46_100_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_92_chunk (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_46_99_chunk._ts_meta_count, compress_hyper_46_99_chunk.sensor_id, compress_hyper_46_99_chunk._ts_meta_min_1, compress_hyper_46_99_chunk._ts_meta_max_1, compress_hyper_46_99_chunk."time", compress_hyper_46_99_chunk.cpu, compress_hyper_46_99_chunk.temperature Sort Key: compress_hyper_46_99_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_46_99_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_99_chunk._ts_meta_count, compress_hyper_46_99_chunk.sensor_id, compress_hyper_46_99_chunk._ts_meta_min_1, compress_hyper_46_99_chunk._ts_meta_max_1, compress_hyper_46_99_chunk."time", compress_hyper_46_99_chunk.cpu, compress_hyper_46_99_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_91_chunk (actual rows=1.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_46_98_chunk._ts_meta_count, compress_hyper_46_98_chunk.sensor_id, compress_hyper_46_98_chunk._ts_meta_min_1, compress_hyper_46_98_chunk._ts_meta_max_1, compress_hyper_46_98_chunk."time", compress_hyper_46_98_chunk.cpu, compress_hyper_46_98_chunk.temperature Sort Key: compress_hyper_46_98_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_46_98_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_98_chunk._ts_meta_count, compress_hyper_46_98_chunk.sensor_id, compress_hyper_46_98_chunk._ts_meta_min_1, compress_hyper_46_98_chunk._ts_meta_max_1, compress_hyper_46_98_chunk."time", compress_hyper_46_98_chunk.cpu, compress_hyper_46_98_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_90_chunk (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_97_chunk._ts_meta_count, compress_hyper_46_97_chunk.sensor_id, compress_hyper_46_97_chunk._ts_meta_min_1, compress_hyper_46_97_chunk._ts_meta_max_1, compress_hyper_46_97_chunk."time", compress_hyper_46_97_chunk.cpu, compress_hyper_46_97_chunk.temperature Sort Key: compress_hyper_46_97_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_97_chunk (never executed) Output: compress_hyper_46_97_chunk._ts_meta_count, compress_hyper_46_97_chunk.sensor_id, compress_hyper_46_97_chunk._ts_meta_min_1, compress_hyper_46_97_chunk._ts_meta_max_1, compress_hyper_46_97_chunk."time", compress_hyper_46_97_chunk.cpu, compress_hyper_46_97_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_89_chunk (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature Sort Key: compress_hyper_46_96_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_96_chunk (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_88_chunk (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature Sort Key: compress_hyper_46_95_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_95_chunk (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature Sort Key: compress_hyper_46_94_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_94_chunk (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature -- Only the first chunks should be accessed (batch sorted merge is disabled) SET timescaledb.enable_decompression_sorted_merge = FALSE; :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature -> Custom Scan (ChunkAppend) on public.sensor_data_compressed (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature Order: sensor_data_compressed."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature Sort Key: _hyper_45_93_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_93_chunk (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_100_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_100_chunk._ts_meta_count, compress_hyper_46_100_chunk.sensor_id, compress_hyper_46_100_chunk._ts_meta_min_1, compress_hyper_46_100_chunk._ts_meta_max_1, compress_hyper_46_100_chunk."time", compress_hyper_46_100_chunk.cpu, compress_hyper_46_100_chunk.temperature -> Sort (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature Sort Key: _hyper_45_92_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_92_chunk (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_99_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_99_chunk._ts_meta_count, compress_hyper_46_99_chunk.sensor_id, compress_hyper_46_99_chunk._ts_meta_min_1, compress_hyper_46_99_chunk._ts_meta_max_1, compress_hyper_46_99_chunk."time", compress_hyper_46_99_chunk.cpu, compress_hyper_46_99_chunk.temperature -> Sort (actual rows=1.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature Sort Key: _hyper_45_91_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_91_chunk (actual rows=2.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_98_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_98_chunk._ts_meta_count, compress_hyper_46_98_chunk.sensor_id, compress_hyper_46_98_chunk._ts_meta_min_1, compress_hyper_46_98_chunk._ts_meta_max_1, compress_hyper_46_98_chunk."time", compress_hyper_46_98_chunk.cpu, compress_hyper_46_98_chunk.temperature -> Sort (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature Sort Key: _hyper_45_90_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_90_chunk (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_97_chunk (never executed) Output: compress_hyper_46_97_chunk._ts_meta_count, compress_hyper_46_97_chunk.sensor_id, compress_hyper_46_97_chunk._ts_meta_min_1, compress_hyper_46_97_chunk._ts_meta_max_1, compress_hyper_46_97_chunk."time", compress_hyper_46_97_chunk.cpu, compress_hyper_46_97_chunk.temperature -> Sort (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Sort Key: _hyper_45_89_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_89_chunk (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_96_chunk (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature -> Sort (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Sort Key: _hyper_45_88_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_88_chunk (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_95_chunk (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature -> Sort (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Sort Key: _hyper_45_87_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_94_chunk (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature RESET timescaledb.enable_decompression_sorted_merge; -- Convert the last chunk into a partially compressed chunk INSERT INTO sensor_data_compressed (time, sensor_id, cpu, temperature) VALUES ('1980-01-02 01:00:00-00', 2, 4, 14.0); VACUUM ANALYZE sensor_data_compressed; -- Only the first chunks should be accessed (batch sorted merge is enabled) :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature -> Custom Scan (ChunkAppend) on public.sensor_data_compressed (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature Order: sensor_data_compressed."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_93_chunk (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_46_100_chunk._ts_meta_count, compress_hyper_46_100_chunk.sensor_id, compress_hyper_46_100_chunk._ts_meta_min_1, compress_hyper_46_100_chunk._ts_meta_max_1, compress_hyper_46_100_chunk."time", compress_hyper_46_100_chunk.cpu, compress_hyper_46_100_chunk.temperature Sort Key: compress_hyper_46_100_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_46_100_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_100_chunk._ts_meta_count, compress_hyper_46_100_chunk.sensor_id, compress_hyper_46_100_chunk._ts_meta_min_1, compress_hyper_46_100_chunk._ts_meta_max_1, compress_hyper_46_100_chunk."time", compress_hyper_46_100_chunk.cpu, compress_hyper_46_100_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_92_chunk (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_46_99_chunk._ts_meta_count, compress_hyper_46_99_chunk.sensor_id, compress_hyper_46_99_chunk._ts_meta_min_1, compress_hyper_46_99_chunk._ts_meta_max_1, compress_hyper_46_99_chunk."time", compress_hyper_46_99_chunk.cpu, compress_hyper_46_99_chunk.temperature Sort Key: compress_hyper_46_99_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_46_99_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_99_chunk._ts_meta_count, compress_hyper_46_99_chunk.sensor_id, compress_hyper_46_99_chunk._ts_meta_min_1, compress_hyper_46_99_chunk._ts_meta_max_1, compress_hyper_46_99_chunk."time", compress_hyper_46_99_chunk.cpu, compress_hyper_46_99_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_91_chunk (actual rows=1.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_46_98_chunk._ts_meta_count, compress_hyper_46_98_chunk.sensor_id, compress_hyper_46_98_chunk._ts_meta_min_1, compress_hyper_46_98_chunk._ts_meta_max_1, compress_hyper_46_98_chunk."time", compress_hyper_46_98_chunk.cpu, compress_hyper_46_98_chunk.temperature Sort Key: compress_hyper_46_98_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_46_98_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_98_chunk._ts_meta_count, compress_hyper_46_98_chunk.sensor_id, compress_hyper_46_98_chunk._ts_meta_min_1, compress_hyper_46_98_chunk._ts_meta_max_1, compress_hyper_46_98_chunk."time", compress_hyper_46_98_chunk.cpu, compress_hyper_46_98_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_90_chunk (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_97_chunk._ts_meta_count, compress_hyper_46_97_chunk.sensor_id, compress_hyper_46_97_chunk._ts_meta_min_1, compress_hyper_46_97_chunk._ts_meta_max_1, compress_hyper_46_97_chunk."time", compress_hyper_46_97_chunk.cpu, compress_hyper_46_97_chunk.temperature Sort Key: compress_hyper_46_97_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_97_chunk (never executed) Output: compress_hyper_46_97_chunk._ts_meta_count, compress_hyper_46_97_chunk.sensor_id, compress_hyper_46_97_chunk._ts_meta_min_1, compress_hyper_46_97_chunk._ts_meta_max_1, compress_hyper_46_97_chunk."time", compress_hyper_46_97_chunk.cpu, compress_hyper_46_97_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_89_chunk (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature Sort Key: compress_hyper_46_96_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_96_chunk (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_88_chunk (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature Sort Key: compress_hyper_46_95_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_95_chunk (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature -> Merge Append (never executed) Sort Key: sensor_data_compressed."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature Sort Key: compress_hyper_46_94_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_46_94_chunk (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature -> Index Scan using _hyper_45_87_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature -- Only the first chunks should be accessed (batch sorted merge is disabled) SET timescaledb.enable_decompression_sorted_merge = FALSE; :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature -> Custom Scan (ChunkAppend) on public.sensor_data_compressed (actual rows=5.00 loops=1) Output: sensor_data_compressed."time", sensor_data_compressed.sensor_id, sensor_data_compressed.cpu, sensor_data_compressed.temperature Order: sensor_data_compressed."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature Sort Key: _hyper_45_93_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_93_chunk (actual rows=2.00 loops=1) Output: _hyper_45_93_chunk."time", _hyper_45_93_chunk.sensor_id, _hyper_45_93_chunk.cpu, _hyper_45_93_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_100_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_100_chunk._ts_meta_count, compress_hyper_46_100_chunk.sensor_id, compress_hyper_46_100_chunk._ts_meta_min_1, compress_hyper_46_100_chunk._ts_meta_max_1, compress_hyper_46_100_chunk."time", compress_hyper_46_100_chunk.cpu, compress_hyper_46_100_chunk.temperature -> Sort (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature Sort Key: _hyper_45_92_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_92_chunk (actual rows=2.00 loops=1) Output: _hyper_45_92_chunk."time", _hyper_45_92_chunk.sensor_id, _hyper_45_92_chunk.cpu, _hyper_45_92_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_99_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_99_chunk._ts_meta_count, compress_hyper_46_99_chunk.sensor_id, compress_hyper_46_99_chunk._ts_meta_min_1, compress_hyper_46_99_chunk._ts_meta_max_1, compress_hyper_46_99_chunk."time", compress_hyper_46_99_chunk.cpu, compress_hyper_46_99_chunk.temperature -> Sort (actual rows=1.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature Sort Key: _hyper_45_91_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_91_chunk (actual rows=2.00 loops=1) Output: _hyper_45_91_chunk."time", _hyper_45_91_chunk.sensor_id, _hyper_45_91_chunk.cpu, _hyper_45_91_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_98_chunk (actual rows=2.00 loops=1) Output: compress_hyper_46_98_chunk._ts_meta_count, compress_hyper_46_98_chunk.sensor_id, compress_hyper_46_98_chunk._ts_meta_min_1, compress_hyper_46_98_chunk._ts_meta_max_1, compress_hyper_46_98_chunk."time", compress_hyper_46_98_chunk.cpu, compress_hyper_46_98_chunk.temperature -> Sort (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature Sort Key: _hyper_45_90_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_90_chunk (never executed) Output: _hyper_45_90_chunk."time", _hyper_45_90_chunk.sensor_id, _hyper_45_90_chunk.cpu, _hyper_45_90_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_97_chunk (never executed) Output: compress_hyper_46_97_chunk._ts_meta_count, compress_hyper_46_97_chunk.sensor_id, compress_hyper_46_97_chunk._ts_meta_min_1, compress_hyper_46_97_chunk._ts_meta_max_1, compress_hyper_46_97_chunk."time", compress_hyper_46_97_chunk.cpu, compress_hyper_46_97_chunk.temperature -> Sort (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Sort Key: _hyper_45_89_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_89_chunk (never executed) Output: _hyper_45_89_chunk."time", _hyper_45_89_chunk.sensor_id, _hyper_45_89_chunk.cpu, _hyper_45_89_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_96_chunk (never executed) Output: compress_hyper_46_96_chunk._ts_meta_count, compress_hyper_46_96_chunk.sensor_id, compress_hyper_46_96_chunk._ts_meta_min_1, compress_hyper_46_96_chunk._ts_meta_max_1, compress_hyper_46_96_chunk."time", compress_hyper_46_96_chunk.cpu, compress_hyper_46_96_chunk.temperature -> Sort (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Sort Key: _hyper_45_88_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_88_chunk (never executed) Output: _hyper_45_88_chunk."time", _hyper_45_88_chunk.sensor_id, _hyper_45_88_chunk.cpu, _hyper_45_88_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_95_chunk (never executed) Output: compress_hyper_46_95_chunk._ts_meta_count, compress_hyper_46_95_chunk.sensor_id, compress_hyper_46_95_chunk._ts_meta_min_1, compress_hyper_46_95_chunk._ts_meta_max_1, compress_hyper_46_95_chunk."time", compress_hyper_46_95_chunk.cpu, compress_hyper_46_95_chunk.temperature -> Merge Append (never executed) Sort Key: sensor_data_compressed."time" DESC -> Sort (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Sort Key: _hyper_45_87_chunk."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_46_94_chunk (never executed) Output: compress_hyper_46_94_chunk._ts_meta_count, compress_hyper_46_94_chunk.sensor_id, compress_hyper_46_94_chunk._ts_meta_min_1, compress_hyper_46_94_chunk._ts_meta_max_1, compress_hyper_46_94_chunk."time", compress_hyper_46_94_chunk.cpu, compress_hyper_46_94_chunk.temperature -> Index Scan using _hyper_45_87_chunk_sensor_data_compressed_time_idx on _timescaledb_internal._hyper_45_87_chunk (never executed) Output: _hyper_45_87_chunk."time", _hyper_45_87_chunk.sensor_id, _hyper_45_87_chunk.cpu, _hyper_45_87_chunk.temperature RESET timescaledb.enable_decompression_sorted_merge; -- create another chunk INSERT INTO stattest SELECT '2021/02/20 01:00'::TIMESTAMPTZ + ('1 hour'::interval * v), 250 * v FROM generate_series(125,140) v; VACUUM ANALYZE stattest; SELECT count(*) from show_chunks('stattest'); count ------- 2 SELECT table_name INTO TEMPORARY temptable FROM _timescaledb_catalog.chunk WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'stattest') ORDER BY creation_time desc limit 1; SELECT table_name as "STAT_CHUNK2_NAME" FROM temptable \gset -- verify that approximate_row_count works ok on normal chunks SELECT approximate_row_count('_timescaledb_internal.' || :'STAT_CHUNK2_NAME'); approximate_row_count ----------------------- 16 -- verify that approximate_row_count works fine on a hypertable with a mix of uncompressed -- and compressed data SELECT approximate_row_count('stattest'); approximate_row_count ----------------------- 68 DROP TABLE stattest; -- test that all variants of compress_chunk produce a fully compressed chunk CREATE TABLE compress_chunk_test(time TIMESTAMPTZ NOT NULL, device text, value float); SELECT create_hypertable('compress_chunk_test', 'time'); create_hypertable ----------------------------------- (47,public,compress_chunk_test,t) INSERT INTO compress_chunk_test SELECT '2020-01-01', 'r2d2', 3.14; ALTER TABLE compress_chunk_test SET (timescaledb.compress); SELECT show_chunks('compress_chunk_test') AS "CHUNK" \gset -- initial call will compress the chunk SELECT compress_chunk(:'CHUNK'); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_102_chunk -- subsequent calls will be noop SELECT compress_chunk(:'CHUNK'); NOTICE: chunk "_hyper_47_102_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_102_chunk -- unless if_not_compressed is set to false \set ON_ERROR_STOP 0 SELECT compress_chunk(:'CHUNK', false); ERROR: chunk "_hyper_47_102_chunk" is already converted to columnstore \set ON_ERROR_STOP 1 ALTER TABLE compress_chunk_test SET (timescaledb.compress_segmentby='device'); SELECT compressed_chunk_id from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name='compress_chunk_test'; compressed_chunk_id --------------------- 103 -- changing compression settings will not recompress the chunk by default SELECT compress_chunk(:'CHUNK'); NOTICE: chunk "_hyper_47_102_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_102_chunk -- unless we specify recompress := true SELECT compress_chunk(:'CHUNK', recompress := true); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_102_chunk -- compressed_chunk_id should be different now SELECT compressed_chunk_id from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name='compress_chunk_test'; compressed_chunk_id --------------------- 104 --test partial handling INSERT INTO compress_chunk_test SELECT '2020-01-01', 'c3po', 3.14; -- should result in merging uncompressed data into compressed chunk SELECT compress_chunk(:'CHUNK'); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_102_chunk -- compressed_chunk_id should not have changed SELECT compressed_chunk_id from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name='compress_chunk_test'; compressed_chunk_id --------------------- 104 -- should return no rows SELECT * FROM ONLY :CHUNK; time | device | value ------+--------+------- ALTER TABLE compress_chunk_test SET (timescaledb.compress_segmentby=''); -- create another chunk INSERT INTO compress_chunk_test SELECT '2021-01-01', 'c3po', 3.14; SELECT show_chunks('compress_chunk_test') AS "CHUNK2" LIMIT 1 OFFSET 1 \gset SELECT compress_chunk(:'CHUNK2'); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_105_chunk -- make it partial and compress again INSERT INTO compress_chunk_test SELECT '2021-01-01', 'r2d2', 3.14; SELECT compress_chunk(:'CHUNK2'); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_47_105_chunk -- should return no rows SELECT * FROM ONLY :CHUNK2; time | device | value ------+--------+------- ------ --- Test copy with a compressed table with unique index ------ CREATE TABLE compressed_table (time timestamptz, a int, b int, c int); CREATE UNIQUE INDEX compressed_table_index ON compressed_table(time, a, b, c); SELECT create_hypertable('compressed_table', 'time'); create_hypertable -------------------------------- (49,public,compressed_table,t) ALTER TABLE compressed_table SET (timescaledb.compress, timescaledb.compress_segmentby='a', timescaledb.compress_orderby = 'time DESC'); WARNING: column "b" should be used for segmenting or ordering WARNING: column "c" should be used for segmenting or ordering COPY compressed_table (time,a,b,c) FROM stdin; SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('compressed_table') i; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_49_107_chunk \set ON_ERROR_STOP 0 COPY compressed_table (time,a,b,c) FROM stdin; ERROR: duplicate key value violates unique constraint "_hyper_49_107_chunk_compressed_table_index" \set ON_ERROR_STOP 1 COPY compressed_table (time,a,b,c) FROM stdin; SELECT * FROM compressed_table ORDER BY time, a; time | a | b | c ------------------------------------+----+---+--- Thu Feb 29 01:00:00 2024 PST | 5 | 1 | 1 Thu Feb 29 06:02:03.87313 2024 PST | 10 | 2 | 2 Thu Feb 29 06:02:03.87313 2024 PST | 20 | 3 | 3 SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('compressed_table') i; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_49_107_chunk -- Check DML decompression limit SET timescaledb.max_tuples_decompressed_per_dml_transaction = 1; \set ON_ERROR_STOP 0 COPY compressed_table (time,a,b,c) FROM stdin; \set ON_ERROR_STOP 1 RESET timescaledb.max_tuples_decompressed_per_dml_transaction; -- Test decompression with DML which compares int8 to int4 CREATE TABLE hyper_84 (time timestamptz, device int8, location int8, temp float8); SELECT create_hypertable('hyper_84', 'time', create_default_indexes => false); create_hypertable ------------------------ (51,public,hyper_84,t) INSERT INTO hyper_84 VALUES ('2024-01-01', 1, 1, 1.0); ALTER TABLE hyper_84 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(ch) FROM show_chunks('hyper_84') ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_51_109_chunk -- indexscan for decompression: UPDATE UPDATE hyper_84 SET temp = 100 where device = 1; SELECT compress_chunk(ch) FROM show_chunks('hyper_84') ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_51_109_chunk -- indexscan for decompression: DELETE DELETE FROM hyper_84 WHERE device = 1; -- Test using DELETE instead of TRUNCATE after compression CREATE TABLE hyper_delete (time timestamptz, device int, location int, temp float, t text); SELECT table_name FROM create_hypertable('hyper_delete', 'time'); table_name -------------- hyper_delete INSERT INTO hyper_delete VALUES ('2024-07-10', 1, 1, 1.0, repeat('X', 10000)); ANALYZE hyper_delete; SELECT ch AS "CHUNK" FROM show_chunks('hyper_delete') ch \gset SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass; relpages | reltuples ----------+----------- 1 | 1 -- One uncompressed row SELECT count(*) FROM :CHUNK; count ------- 1 ALTER TABLE hyper_delete SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SET timescaledb.enable_delete_after_compression TO true; SELECT FROM compress_chunk(:'CHUNK'); NOTICE: timescaledb.enable_delete_after_compression is deprecated and will be removed in a future version. Please use timescaledb.compress_truncate_behaviour instead. -- -- still have more than one tuple SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass; relpages | reltuples ----------+----------- 1 | 1 ANALYZE hyper_delete; -- after ANALYZE we should have no tuples SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass; relpages | reltuples ----------+----------- 1 | 0 -- One compressed row SELECT count(*) FROM :CHUNK; count ------- 1 RESET timescaledb.enable_delete_after_compression; -- Test batch size limiting GUC CREATE TABLE hyper_85 (time timestamptz, device int8, location int8, temp float8); SELECT create_hypertable('hyper_85', 'time', create_default_indexes => false); create_hypertable ------------------------ (55,public,hyper_85,t) INSERT INTO hyper_85 SELECT t, 1, 1, 1.0 FROM generate_series('2024-01-01'::timestamptz, '2024-01-02'::timestamptz, '20 sec'::interval) t; ALTER TABLE hyper_85 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); -- first without the limit BEGIN; SELECT compress_chunk(ch) FROM show_chunks('hyper_85') ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_55_113_chunk SELECT ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'hyper_85' ORDER BY ch1.id LIMIT 1 \gset select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset SELECT _ts_meta_count FROM :COMPRESSED_CHUNK_NAME ORDER BY device, _ts_meta_min_1 DESC; _ts_meta_count ---------------- 1000 1000 1000 1000 321 ROLLBACK; -- now lets set the limit SET timescaledb.compression_batch_size_limit = 505; BEGIN; SELECT compress_chunk(ch) FROM show_chunks('hyper_85') ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_55_113_chunk SELECT ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'hyper_85' ORDER BY ch1.id LIMIT 1 \gset select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset SELECT _ts_meta_count FROM :COMPRESSED_CHUNK_NAME ORDER BY device, _ts_meta_min_1 DESC; _ts_meta_count ---------------- 505 505 505 505 505 505 505 505 281 ROLLBACK; -- Test poor compression rate warning works as expected -- Turn GUC on SET timescaledb.enable_compression_ratio_warnings TO ON; -- Compressing a table with very few rows virtually guarantees a poor compression rate CREATE TABLE badly_compressed_ht (time timestamptz, device_id integer, a integer); SELECT create_hypertable('badly_compressed_ht', 'time'); create_hypertable ----------------------------------- (57,public,badly_compressed_ht,t) ALTER TABLE badly_compressed_ht set (timescaledb.compress, timescaledb.compress_segmentby = 'device_id'); INSERT INTO badly_compressed_ht VALUES ('2025-04-25 00:00'::timestamp, 1, 1), ('2025-04-25 01:00'::timestamp, 2, 2), ('2025-04-25 02:00'::timestamp, 3, 3); \set VERBOSITY default SELECT compress_chunk(show_chunks('badly_compressed_ht')); WARNING: poor compression rate detected for chunk "_hyper_57_116_chunk"' DETAIL: Chunk "_hyper_57_116_chunk" has a poor compression ratio: 0.60. Size before compression: 24576 bytes. Size after compression: 40960 bytes HINT: Changing compression settings for "badly_compressed_ht" can improve compression rate compress_chunk ------------------------------------------- _timescaledb_internal._hyper_57_116_chunk \set VERBOSITY terse RESET timescaledb.enable_compression_ratio_warnings; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_algos.out������������������������������������������0000664�0000000�0000000�00000450337�15100345067�0023730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --install necessary functions for tests \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_compression() RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; \ir include/compression_utils.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- helper function: float -> pseudorandom float [0..1]. create or replace function mix(x float4) returns float4 as $$ select ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ language sql; create or replace function mix(x timestamptz) returns float4 as $$ select mix(extract(epoch from x)::float4) $$ language sql; ------------------ -- C unit tests -- ------------------ SELECT ts_test_compression(); ts_test_compression --------------------- ------------------------ -- BIGINT Compression -- ------------------------ SELECT $$ select item from base_ints order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_ints \set TYPE BIGINT \set COMPRESSION_CMD _timescaledb_internal.compress_deltadelta(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::BIGINT) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::BIGINT) -- random order CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::bigint FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors psql:include/compression_test.sql:7: NOTICE: table "compressed" does not exist, skipping algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | f | 1720 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; -- ascending order with nulls CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::bigint FROM (SELECT generate_series(1, 1000) item) sub; INSERT INTO base_ints VALUES (0, NULL), (10, NULL), (10000, NULL); \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | t | 93 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t SELECT c ints_text FROM compressed; ints_text -------------------------------------------------------------------------------------------------------------------------- BAEAAAAAAAAD6AAAAAAAAAABAAAD6AAAAAIAAAAAAAAA8gAAAAAAAAACAAA8gAAAAAAAAAPrAAAAAwAAAAAAAAHxAAAAAAAABAEAADqgAAAAAAAAAAAAAAAB DROP TABLE base_ints; -- single element CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::bigint FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | f | 45 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; -- really big deltas SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset CREATE TABLE base_ints AS SELECT row_number() over () as rn, item FROM ( VALUES --big deltas (0), (:big_int_max), (:big_int_min), (:big_int_max), (:big_int_min), (0), (:big_int_min), (32), (5), (:big_int_min), (-52), (:big_int_max), (1000), --big delta_deltas (0), (:big_int_max), (:big_int_max), (:big_int_min), (:big_int_min), (:big_int_max), (:big_int_max), (0), (:big_int_max-1), (:big_int_max-1), (:big_int_min), (:big_int_min), (:big_int_max-1), (:big_int_max-1) ) as t(item); \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | f | 184 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; -- NULLs CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(i, 5) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | t | 69 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(i, 1) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | t | 69 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(i, 10) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | t | 69 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | t | 69 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; ------------------------ -- INT Compression -- ------------------------ CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::int FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; SELECT $$ select item::bigint from base_ints order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_ints \set TYPE BIGINT \set COMPRESSION_CMD _timescaledb_internal.compress_deltadelta(item::bigint) \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | f | 1720 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_ints; ----------------------------- -- TIMESTAMPTZ Compression -- ----------------------------- SELECT $$ select item from base_time order by rn $$ AS "QUERY" \gset \set TYPE TIMESTAMPTZ \set TABLE_NAME base_time \set COMPRESSION_CMD _timescaledb_internal.compress_deltadelta(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::TIMESTAMPTZ) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::TIMESTAMPTZ) CREATE TABLE base_time AS SELECT row_number() OVER() as rn, item FROM (select sub.item from (SELECT generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DELTADELTA | f | 5332 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_time; ------------------------ -- FLOAT4 Compression -- ------------------------ SELECT $$ select item from base_floats order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_floats SELECT 'real' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_gorilla(item) SELECT '_timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::float4)' AS "DECOMPRESS_FORWARD_CMD" \gset SELECT '_timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::float4)' AS "DECOMPRESS_REVERSE_CMD" \gset CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, item::float4 FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 1760 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t SELECT c gorilla_text FROM compressed; gorilla_text ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 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 DROP TABLE base_floats; -- single element CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, item::float4 FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 109 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; --special values CREATE TABLE base_floats AS SELECT row_number() over () as rn, item FROM ( VALUES --special (0::float4), ('Infinity'), ('-Infinity'), ('NaN'), --big deltas (0), ('Infinity'), ('-Infinity'), ('Infinity'), ('-Infinity'), (0), ('-Infinity'), (32), (5), ('-Infinity'), (-52), ('Infinity'), (1000), --big delta_deltas (0), ('Infinity'), ('Infinity'), ('-Infinity'), ('-Infinity'), ('Infinity'), ('Infinity') ) as t(item); \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; -- all 0s CREATE TABLE base_floats AS SELECT row_number() over () as rn, 0::float4 as item FROM (SELECT generate_series(1, 1000) ) j; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 109 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; -- NULLs CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_floats; ------------------------ -- DOUBLE Compression -- ------------------------ SELECT $$ select item from base_doubles order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_doubles SELECT 'DOUBLE PRECISION' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_gorilla(item) SELECT '_timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::DOUBLE PRECISION)' AS "DECOMPRESS_FORWARD_CMD" \gset SELECT '_timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::DOUBLE PRECISION)' AS "DECOMPRESS_REVERSE_CMD" \gset CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, item::double precision FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 1752 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t SELECT c gorilla_text FROM compressed; gorilla_text ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 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 DROP TABLE base_doubles; -- single element CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, item::double precision FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 109 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; --special values CREATE TABLE base_doubles AS SELECT row_number() over () as rn, item FROM ( VALUES --special (0::double precision), ('Infinity'), ('-Infinity'), ('NaN'), --big deltas (0), ('Infinity'), ('-Infinity'), ('Infinity'), ('-Infinity'), (0), ('-Infinity'), (32), (5), ('-Infinity'), (-52), ('Infinity'), (1000), --big delta_deltas (0), ('Infinity'), ('Infinity'), ('-Infinity'), ('-Infinity'), ('Infinity'), ('Infinity') ) as t(item); \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 144 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; -- all 0s CREATE TABLE base_doubles AS SELECT row_number() over () as rn, 0::FLOAT(50) as item FROM (SELECT generate_series(1, 1000) ) j; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | f | 109 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; -- NULLs CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- GORILLA | t | 136 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_doubles; ------------------------ -- Dictionary Compression -- ------------------------ SELECT $$ select item from base_texts order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_texts SELECT 'TEXT' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_dictionary(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::TEXT) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::TEXT) -- high cardinality CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | f | 4305 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t SELECT c from compressed; c ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 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 DROP TABLE base_texts; -- low cardinality CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (SELECT i as item FROM generate_series(1, 10) i, generate_series(1, 100) j ORDER BY mix(i + j)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | f | 605 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; -- single element CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | f | 39 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; -- high cardinality with toasted values CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, repeat(item::text, 100000) as item FROM (select sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY mix(item)) sub; --make sure it's toasted SELECT pg_total_relation_size(reltoastrelid) FROM pg_class c WHERE relname = 'base_texts'; pg_total_relation_size ------------------------ 24576 \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | f | 1100092 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; -- NULLs CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 187 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 179 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 178 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 189 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; ----------------------- -- Array Compression -- ----------------------- SELECT $$ select item from base_texts order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_texts SELECT 'TEXT' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_array(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::TEXT) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::TEXT) --basic test CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (select sub.item from (SELECT generate_series(1, 100) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | f | 356 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t SELECT c from compressed; c ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- AQBwZ19jYXRhbG9nAHRleHQAAAEAAABkAAAAAjg0AAAAAjMyAAAAAjE5AAAAAjc0AAAAAjE4AAAAAjI5AAAAAjg5AAAAAjQ1AAAAAjI1AAAAATMAAAACNjgAAAABNQAAAAIxMgAAAAE4AAAAAjk1AAAAAjg3AAAAAjE2AAAAAjM5AAAAAjY0AAAAAjc3AAAAAjE3AAAAAjI4AAAAAjQwAAAAAjQzAAAAAjQ2AAAAAjU0AAAAAjM4AAAAATkAAAACNTkAAAACNDQAAAACMTEAAAACOTgAAAACNTUAAAACODMAAAACMjAAAAACOTkAAAACODIAAAACMzYAAAACNDgAAAACNzAAAAACMTAAAAACNzUAAAACMzQAAAACMTUAAAABNAAAAAIyNAAAAAI4MAAAAAI1MQAAAAI1MgAAAAIxMwAAAAI0NwAAAAE2AAAAAjIyAAAAAjUwAAAAAjgxAAAAAjQ5AAAAATEAAAACNzYAAAACNjcAAAACNjEAAAACNDIAAAACMzcAAAACNzEAAAACNjkAAAACMzMAAAACOTYAAAACNTMAAAACMjYAAAACOTQAAAACMjcAAAACNjAAAAACNTcAAAACMjEAAAACOTAAAAACNjUAAAACODgAAAABMgAAAAI0MQAAAAIzMAAAAAI5MwAAAAI5MQAAAAI1NgAAAAI4NgAAAAE3AAAAAjkyAAAAAjcyAAAAAjE0AAAAAjY2AAAAAjIzAAAAAjYzAAAAAjczAAAAAjU4AAAAAjYyAAAAAjg1AAAAAjc5AAAAAzEwMAAAAAI3OAAAAAIzMQAAAAI5NwAAAAIzNQ== DROP TABLE base_texts; -- single element CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | f | 39 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; -- toasted values CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, repeat(item::text, 100000) as item FROM (select sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY mix(item)) sub; --make sure it's toasted SELECT pg_total_relation_size(reltoastrelid) FROM pg_class c WHERE relname = 'base_texts'; pg_total_relation_size ------------------------ 24576 \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | f | 1100092 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; -- NULLs CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | t | 80 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | t | 80 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | t | 79 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | t | 74 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_texts; ---------------------- -- Bool Compression -- ---------------------- SELECT $$ select item from base_bools order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_bools \set TYPE boolean \set COMPRESSION_CMD _timescaledb_internal.compress_bool(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::boolean) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::boolean) -- bool test, flipping values betweem true and false, no nulls CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, (item%2=0)::boolean as item FROM (SELECT generate_series(1, 1000) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- BOOL | f | 152 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_bools; -- bool test, all true values, no nulls CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, true as item FROM (SELECT generate_series(1, 1000) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- BOOL | f | 29 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_bools; -- bool test, all false, no nulls CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, false as item FROM (SELECT generate_series(1, 1000) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- BOOL | f | 29 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_bools; -- a single true element CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, true as item FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- BOOL | f | 29 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_bools; -- all true, except every 43rd value is null CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, ((NULLIF(i, (CASE WHEN i%43=0 THEN i ELSE -1 END)))>0)::boolean item FROM generate_series(1, 1000) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- BOOL | t | 176 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_bools; -- all false, except every 29th value is null CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, ((NULLIF(i, (CASE WHEN i%29=0 THEN i ELSE -1 END)))<0)::boolean item FROM generate_series(1, 1000) i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- BOOL | t | 176 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_bools; ---------------------- -- UUID Compression -- ---------------------- CREATE TABLE uuid_set (i int, u uuid); INSERT INTO uuid_set (i, u) VALUES (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (18, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (19, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (20, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (21, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (22, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (23, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (24, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (25, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (26, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (27, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (28, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (29, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (30, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (31, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (32, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (33, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (34, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (35, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (36, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (37, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (38, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (39, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (40, '0197a7a9-b48c-7c96-914c-690b7930262f'), (41, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (42, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (43, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (44, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'), (45, '0197a7a9-b48c-7c9b-9319-de9dd58deeee'), (46, '0197a7a9-b48c-7c9c-a9d4-ed6f3e6a41b7'), (47, '0197a7a9-b48c-7c9d-8036-4141e0780323'), (48, '0197a7a9-b48c-7c9e-bfbe-f00eb49ed7f2'), (49, '0197a7a9-b48c-7c9f-8ffe-71cf00a0c0c0'), (50, '0197a7a9-b48c-7ca0-822f-95ced2f95702'), (51, '0197a7a9-b48c-7ca1-8c8a-66582aec95fa'), (52, '0197a7a9-b48c-7ca2-95c3-fe80362a2251'), (53, '0197a7a9-b48c-7ca3-855f-f681b254a8c8'), (54, '0197a7a9-b48c-7ca4-856b-a562eca93c3f'), (55, '0197a7a9-b48c-7ca5-a30e-37c247fb4c46'), (56, '0197a7a9-b48c-7ca6-9e78-a148d54a44ac'), (57, '0197a7a9-b48c-7ca7-badb-4b650bf5bf5f'), (58, '0197a7a9-b48c-7ca8-8275-a8590869ef13'), (59, '0197a7a9-b48c-7ca9-b328-b54c3901223c'), (60, '0197a7a9-b48c-7caa-a15d-f5564e4e552c'), (61, '0197a7a9-b48c-7cab-a4ac-017259746322'), (62, '0197a7a9-b48c-7cac-bda5-74ef12abd6b8'), (63, '0197a7a9-b48c-7cad-a3cd-0e4c93eaba80'), (64, '0197a7a9-b48c-7cae-9667-de4a226418df'), (65, '0197a7a9-b48c-7caf-8aa2-067619170f32'), (66, '0197a7a9-b48c-7cb0-ba8c-91d9e8920845'), (67, '0197a7a9-b48c-7cb1-9681-a62bfffe9237'), (68, '0197a7a9-b48c-7cb2-b78b-037e5ee26ff6'), (69, '0197a7a9-b48c-7cb3-ac27-e24382445188'), (70, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (71, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (72, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (73, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (74, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (75, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (76, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (77, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (78, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (79, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (80, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (81, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (82, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (83, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (84, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (85, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (86, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (87, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (88, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (89, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (90, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (91, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (92, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (93, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (94, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (95, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (96, '0197a7a9-b48c-7c96-914c-690b7930262f'), (97, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (98, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (99, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (100, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'); SELECT $$ select item from base_uuids order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_uuids \set TYPE uuid \set COMPRESSION_CMD _timescaledb_internal.compress_uuid(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::uuid) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::uuid) SET timescaledb.enable_uuid_compression = on; -- basic test, flipping values between UUID v4s, UUID v7s and NULLs CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = gen_random_uuid() WHERE rn % 4 = 0; UPDATE base_uuids SET item = (SELECT u FROM uuid_set WHERE i = rn % 100) WHERE rn % 4 = 1; UPDATE base_uuids SET item = (SELECT u FROM uuid_set WHERE i = rn % 97) WHERE rn % 4 = 2; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 6124 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_uuids; -- all NULLs and a single UUID v7 CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = '0197a7a9-b48b-7c74-a2a4-dcdbce635d11' WHERE rn = 1; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- ARRAY | t | 85 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_uuids; -- no NULLs CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = (SELECT u FROM uuid_set WHERE i = rn % 100); \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 2092 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_uuids; -- flipping values between two UUID v7s and NULLs CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = '0197a7a9-b48b-7c74-a2a4-dcdbce635d11' WHERE rn % 3 = 0; UPDATE base_uuids SET item = '0197a7a9-b48b-7c74-a2a4-dcdbce635d12' WHERE rn % 3 = 1; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size ------------+-----------+----------------- DICTIONARY | t | 320 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_uuids; -- test with a set of UUID v7s CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, u as item FROM uuid_set ORDER BY i; \ir include/compression_test.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors algorithm | has_nulls | compressed size -----------+-----------+----------------- UUID | f | 944 ?column? | count -------------------------------------------------------------------------------+------- Number of rows different between original and decompressed forward (expect 0) | 0 ?column? | count --------------------------------------------------------------------------------+------- Number of rows different between original and decompressed reversed (expect 0) | 0 ?column? | count ----------------------------------------------------------------------------------------------------+------- Number of rows different between original, decompressed, and decompressed deserializeed (expect 0) | 0 ?column? | ?column? -----------------------------------------------------------------------------------------------------+---------- Test that deserialization, decompression, recompression, and serialization results in the same text | t DROP TABLE base_uuids; RESET timescaledb.enable_uuid_compression; DROP table uuid_set; ----------------------------------------------- -- Interesting corrupt data found by fuzzing -- ----------------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER create or replace function ts_read_compressed_data_file(cstring, regtype, cstring, bool = true) returns int as :TSL_MODULE_PATHNAME, 'ts_read_compressed_data_file' language c; \set ON_ERROR_STOP 0 select ts_read_compressed_data_file('gorilla', 'float8', '--nonexistent'); ERROR: could not open the file '--nonexistent' -- Just some random file that returns "compressed data is corrupt", for one-off testing. select ts_read_compressed_data_file('gorilla', 'float8', (:'TEST_INPUT_DIR' || '/fuzzing/compression/gorilla-float8/1f09f12d930daae8e5fd34e11e7b2303e1705b2e')::cstring); ERROR: the compressed data is corrupt \set ON_ERROR_STOP 1 create or replace function ts_read_compressed_data_directory(cstring, regtype, cstring, bool) returns table(path text, bytes int, rows int, sqlstate text, location text) as :TSL_MODULE_PATHNAME, 'ts_read_compressed_data_directory' language c; \set fn 'ts_read_compressed_data_directory(:''algo'', :''type'', format(''%s/fuzzing/compression/%s-%s'', :''TEST_INPUT_DIR'', :''algo'', :''type'')::cstring, ' \set algo gorilla \set type float8 select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; count | bulk_result | rowbyrow_result -------+-------------+----------------- 143 | XX001 | true 82 | XX001 | XX001 54 | true | true 23 | 08P01 | 08P01 \set algo deltadelta \set type int8 select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; count | bulk_result | rowbyrow_result -------+-------------+----------------- 106 | XX001 | XX001 69 | true | true 62 | XX001 | true 13 | 08P01 | 08P01 1 | false | false \set algo array \set type text select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; count | bulk_result | rowbyrow_result -------+-------------+----------------- 18 | true | true 14 | XX001 | XX001 8 | 08P01 | 08P01 2 | 3F000 | 3F000 2 | false | false 1 | 22021 | 22021 \set algo dictionary \set type text select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; count | bulk_result | rowbyrow_result -------+-------------+----------------- 76 | XX001 | XX001 9 | XX001 | true 5 | 08P01 | 08P01 4 | true | true 3 | 22021 | 22021 1 | 3F000 | 3F000 1 | false | false \set algo bool \set type bool select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; count | bulk_result | rowbyrow_result -------+-------------+----------------- 18 | XX001 | XX001 3 | true | true 2 | 08P01 | 08P01 \set algo uuid \set type uuid select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; count | bulk_result | rowbyrow_result -------+-------------+----------------- 1 | true | true �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_allocation.out�������������������������������������0000664�0000000�0000000�00000004110�15100345067�0024730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test array compression overallocation protection CREATE TABLE vector_overalloc (time timestamptz, device int8, ord numeric, value text); SELECT create_hypertable('vector_overalloc', 'time', create_default_indexes => false); create_hypertable ------------------------------- (1,public,vector_overalloc,t) -- This will try to create an array of chars over 1GB allocation limit INSERT INTO vector_overalloc VALUES ('2025-01-01 00:00:00', 1, 1, repeat(md5(random()::text), 32*1024*200)), --200 MB value ('2025-01-01 00:00:01', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:02', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:03', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:04', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:05', 1, 1, repeat(md5(random()::text), 32*1024*200)); ALTER TABLE vector_overalloc SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); SET timescaledb.enable_compressor_batch_limit to true; SELECT compress_chunk(ch) FROM show_chunks('vector_overalloc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'vector_overalloc' ORDER BY ch1.id LIMIT 1 \gset select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset -- Confirm we have multiple batches SELECT _ts_meta_count FROM :COMPRESSED_CHUNK_NAME ORDER BY device, _ts_meta_min_1 ASC; _ts_meta_count ---------------- 5 1 DROP TABLE vector_overalloc; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_bgw.out��������������������������������������������0000664�0000000�0000000�00000126407�15100345067�0023400�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE NOLOGIN_ROLE WITH nologin noinherit; -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO NOLOGIN_ROLE; GRANT NOLOGIN_ROLE TO :ROLE_DEFAULT_PERM_USER WITH ADMIN OPTION; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select create_hypertable( 'conditions', 'time', chunk_time_interval=> '31days'::interval); create_hypertable ------------------------- (1,public,conditions,t) --TEST 1-- --cannot set policy without enabling compression -- \set ON_ERROR_STOP 0 select add_compression_policy('conditions', '60d'::interval); ERROR: columnstore not enabled on hypertable "conditions" \set ON_ERROR_STOP 1 -- TEST2 -- --add a policy to compress chunks -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'time'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; select add_compression_policy('conditions', '60d'::interval) AS compressjob_id \gset select * from _timescaledb_config.bgw_job where id = :compressjob_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------+------------------------+--------------------------+---------- 1000 | Columnstore Policy [1000] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user | t | f | | 1 | {"hypertable_id": 1, "compress_after": "@ 60 days"} | _timescaledb_functions | policy_compression_check | select * from alter_job(:compressjob_id, schedule_interval=>'1s'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+-----------------------------------------------------+------------+-------------------------------------------------+----------------+---------------+----------+--------------------------- 1000 | @ 1 sec | @ 0 | -1 | @ 1 hour | t | {"hypertable_id": 1, "compress_after": "@ 60 days"} | -infinity | _timescaledb_functions.policy_compression_check | f | | | Columnstore Policy [1000] --enable maxchunks to 1 so that only 1 chunk is compressed by the job SELECT alter_job(id,config:=jsonb_set(config,'{maxchunks_to_compress}', '1')) FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; alter_job ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1000,"@ 1 sec","@ 0",-1,"@ 1 hour",t,"{""hypertable_id"": 1, ""compress_after"": ""@ 60 days"", ""maxchunks_to_compress"": 1}",-infinity,_timescaledb_functions.policy_compression_check,f,,,"Columnstore Policy [1000]") select * from _timescaledb_config.bgw_job where id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+-------------------+-----------+----------------+---------------+---------------+---------------------------------------------------------------------------------+------------------------+--------------------------+---------- 1000 | Columnstore Policy [1000] | @ 1 sec | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user | t | f | | 1 | {"hypertable_id": 1, "compress_after": "@ 60 days", "maxchunks_to_compress": 1} | _timescaledb_functions | policy_compression_check | insert into conditions select now()::timestamp, 'TOK', 'sony', 55, 75; -- TEST3 -- --only the old chunks will get compressed when policy is executed-- CALL run_job(:compressjob_id); select chunk_name, pg_size_pretty(before_compression_total_bytes) before_total, pg_size_pretty( after_compression_total_bytes) after_total from chunk_compression_stats('conditions') where compression_status like 'Compressed' order by chunk_name; chunk_name | before_total | after_total ------------------+--------------+------------- _hyper_1_1_chunk | 32 kB | 40 kB SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk ORDER BY id; id | hypertable_id | schema_name | table_name | compressed_chunk_id | dropped | status | osm_chunk ----+---------------+-----------------------+--------------------------+---------------------+---------+--------+----------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | 4 | f | 1 | f 2 | 1 | _timescaledb_internal | _hyper_1_2_chunk | | f | 0 | f 3 | 1 | _timescaledb_internal | _hyper_1_3_chunk | | f | 0 | f 4 | 2 | _timescaledb_internal | compress_hyper_2_4_chunk | | f | 0 | f -- TEST 4 -- --cannot set another policy \set ON_ERROR_STOP 0 select add_compression_policy('conditions', '60d'::interval, if_not_exists=>true); NOTICE: columnstore policy already exists for hypertable "conditions", skipping add_compression_policy ------------------------ -1 select add_compression_policy('conditions', '60d'::interval); ERROR: columnstore policy already exists for hypertable or continuous aggregate "conditions" select add_compression_policy('conditions', '30d'::interval, if_not_exists=>true); WARNING: columnstore policy already exists for hypertable "conditions" add_compression_policy ------------------------ -1 \set ON_ERROR_STOP 1 --TEST 5 -- -- drop the policy -- select remove_compression_policy('conditions'); remove_compression_policy --------------------------- t select count(*) from _timescaledb_config.bgw_job WHERE id>=1000; count ------- 0 --TEST 6 -- -- try to execute the policy after it has been dropped -- \set ON_ERROR_STOP 0 CALL run_job(:compressjob_id); ERROR: job 1000 not found --errors with bad input for add/remove compression policy create view dummyv1 as select * from conditions limit 1; select add_compression_policy( 100 , compress_after=> '1 day'::interval); ERROR: object with id "100" not found select add_compression_policy( 'dummyv1', compress_after=> '1 day'::interval ); ERROR: "dummyv1" is not a hypertable or a continuous aggregate select remove_compression_policy( 100 ); ERROR: relation is not a hypertable or continuous aggregate \set ON_ERROR_STOP 1 -- We're done with the table, so drop it. DROP TABLE IF EXISTS conditions CASCADE; NOTICE: drop cascades to view dummyv1 --TEST 7 --compression policy for smallint, integer or bigint based partition hypertable --smallint test CREATE TABLE test_table_smallint(time SMALLINT, val SMALLINT); SELECT create_hypertable('test_table_smallint', 'time', chunk_time_interval => 1); create_hypertable ---------------------------------- (3,public,test_table_smallint,t) CREATE OR REPLACE FUNCTION dummy_now_smallint() RETURNS SMALLINT LANGUAGE SQL IMMUTABLE AS 'SELECT 5::SMALLINT'; SELECT set_integer_now_func('test_table_smallint', 'dummy_now_smallint'); set_integer_now_func ---------------------- INSERT INTO test_table_smallint SELECT generate_series(1,5), 10; ALTER TABLE test_table_smallint SET (timescaledb.compress); \set ON_ERROR_STOP 0 select add_compression_policy( 'test_table_smallint', compress_after=> '1 day'::interval ); ERROR: invalid value for parameter compress_after \set ON_ERROR_STOP 1 SELECT add_compression_policy('test_table_smallint', 2::SMALLINT) AS compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+-------------------+-----------+----------------+---------------+---------------+-------------------------------------------+------------------------+--------------------------+---------- 1001 | Columnstore Policy [1001] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user | t | f | | 3 | {"hypertable_id": 3, "compress_after": 2} | _timescaledb_functions | policy_compression_check | --will compress all chunks that need compression CALL run_job(:compressjob_id); SELECT chunk_name, before_compression_total_bytes, after_compression_total_bytes FROM chunk_compression_stats('test_table_smallint') WHERE compression_status LIKE 'Compressed' ORDER BY chunk_name; chunk_name | before_compression_total_bytes | after_compression_total_bytes ------------------+--------------------------------+------------------------------- _hyper_3_5_chunk | 24576 | 40960 _hyper_3_6_chunk | 24576 | 40960 --integer tests CREATE TABLE test_table_integer(time INTEGER, val INTEGER); SELECT create_hypertable('test_table_integer', 'time', chunk_time_interval => 1); create_hypertable --------------------------------- (5,public,test_table_integer,t) CREATE OR REPLACE FUNCTION dummy_now_integer() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS 'SELECT 5::INTEGER'; SELECT set_integer_now_func('test_table_integer', 'dummy_now_integer'); set_integer_now_func ---------------------- INSERT INTO test_table_integer SELECT generate_series(1,5), 10; ALTER TABLE test_table_integer SET (timescaledb.compress); SELECT add_compression_policy('test_table_integer', 2::INTEGER) AS compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+-------------------+-----------+----------------+---------------+---------------+-------------------------------------------+------------------------+--------------------------+---------- 1002 | Columnstore Policy [1002] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user | t | f | | 5 | {"hypertable_id": 5, "compress_after": 2} | _timescaledb_functions | policy_compression_check | --will compress all chunks that need compression CALL run_job(:compressjob_id); SELECT chunk_name, before_compression_total_bytes, after_compression_total_bytes FROM chunk_compression_stats('test_table_integer') WHERE compression_status LIKE 'Compressed' ORDER BY chunk_name; chunk_name | before_compression_total_bytes | after_compression_total_bytes -------------------+--------------------------------+------------------------------- _hyper_5_12_chunk | 24576 | 40960 _hyper_5_13_chunk | 24576 | 40960 --bigint test CREATE TABLE test_table_bigint(time BIGINT, val BIGINT); SELECT create_hypertable('test_table_bigint', 'time', chunk_time_interval => 1); create_hypertable -------------------------------- (7,public,test_table_bigint,t) CREATE OR REPLACE FUNCTION dummy_now_bigint() RETURNS BIGINT LANGUAGE SQL IMMUTABLE AS 'SELECT 5::BIGINT'; SELECT set_integer_now_func('test_table_bigint', 'dummy_now_bigint'); set_integer_now_func ---------------------- INSERT INTO test_table_bigint SELECT generate_series(1,5), 10; ALTER TABLE test_table_bigint SET (timescaledb.compress); SELECT add_compression_policy('test_table_bigint', 2::BIGINT) AS compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+-------------------+-----------+----------------+---------------+---------------+-------------------------------------------+------------------------+--------------------------+---------- 1003 | Columnstore Policy [1003] | @ 1 day | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user | t | f | | 7 | {"hypertable_id": 7, "compress_after": 2} | _timescaledb_functions | policy_compression_check | --will compress all chunks that need compression CALL run_job(:compressjob_id); SELECT chunk_name, before_compression_total_bytes, after_compression_total_bytes FROM chunk_compression_stats('test_table_bigint') WHERE compression_status LIKE 'Compressed' ORDER BY chunk_name; chunk_name | before_compression_total_bytes | after_compression_total_bytes -------------------+--------------------------------+------------------------------- _hyper_7_19_chunk | 24576 | 40960 _hyper_7_20_chunk | 24576 | 40960 --TEST 8 --hypertable owner lacks permission to start background worker SET ROLE NOLOGIN_ROLE; CREATE TABLE test_table_nologin(time bigint, val int); SELECT create_hypertable('test_table_nologin', 'time', chunk_time_interval => 1); create_hypertable --------------------------------- (9,public,test_table_nologin,t) SELECT set_integer_now_func('test_table_nologin', 'dummy_now_bigint'); set_integer_now_func ---------------------- ALTER TABLE test_table_nologin set (timescaledb.compress); \set ON_ERROR_STOP 0 SELECT add_compression_policy('test_table_nologin', 2::int); ERROR: permission denied to start background process as role "nologin_role" \set ON_ERROR_STOP 1 DROP TABLE test_table_nologin; RESET ROLE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '1 day'::interval); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 11 | public | conditions | t INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous) AS SELECT device, time_bucket(INTERVAL '1 hour', "time") AS day, AVG(temperature) AS avg_temperature, MAX(temperature) AS max_temperature, MIN(temperature) AS min_temperature FROM conditions GROUP BY device, time_bucket(INTERVAL '1 hour', "time") WITH NO DATA; CALL refresh_continuous_aggregate('conditions_summary', NULL, NULL); ALTER TABLE conditions SET (timescaledb.compress); SELECT COUNT(*) AS dropped_chunks_count FROM drop_chunks('conditions', TIMESTAMPTZ '2018-12-15 00:00'); dropped_chunks_count ---------------------- 14 SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'conditions' and is_compressed = true; count ------- 0 SELECT add_compression_policy AS job_id FROM add_compression_policy('conditions', INTERVAL '1 day') \gset -- job compresses only 1 chunk at a time -- SELECT alter_job(id,config:=jsonb_set(config,'{maxchunks_to_compress}', '1')) FROM _timescaledb_config.bgw_job WHERE id = :job_id; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1004,"@ 12 hours","@ 0",-1,"@ 1 hour",t,"{""hypertable_id"": 11, ""compress_after"": ""@ 1 day"", ""maxchunks_to_compress"": 1}",-infinity,_timescaledb_functions.policy_compression_check,f,,,"Columnstore Policy [1004]") SELECT alter_job(id,config:=jsonb_set(config,'{verbose_log}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :job_id; alter_job ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1004,"@ 12 hours","@ 0",-1,"@ 1 hour",t,"{""verbose_log"": true, ""hypertable_id"": 11, ""compress_after"": ""@ 1 day"", ""maxchunks_to_compress"": 1}",-infinity,_timescaledb_functions.policy_compression_check,f,,,"Columnstore Policy [1004]") set client_min_messages TO LOG; CALL run_job(:job_id); LOG: statement: CALL run_job(1004); LOG: job 1004 completed processing chunk _timescaledb_internal._hyper_11_40_chunk set client_min_messages TO NOTICE; LOG: statement: set client_min_messages TO NOTICE; SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'conditions' and is_compressed = true; count ------- 1 \i include/recompress_basic.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE test2 (timec timestamptz NOT NULL, i integer , b bigint, t text); SELECT table_name from create_hypertable('test2', 'timec', chunk_time_interval=> INTERVAL '7 days'); table_name ------------ test2 INSERT INTO test2 SELECT q, 10, 11, 'hello' FROM generate_series( '2020-01-03 10:00:00+00', '2020-01-03 12:00:00+00' , '5 min'::interval) q; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); SELECT compress_chunk(c) FROM show_chunks('test2') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_62_chunk ---insert into the middle of the range --- INSERT INTO test2 values ( '2020-01-03 10:01:00+00', 20, 11, '2row'); INSERT INTO test2 values ( '2020-01-03 11:01:00+00', 20, 11, '3row'); INSERT INTO test2 values ( '2020-01-03 12:01:00+00', 20, 11, '4row'); --- insert a new segment by --- INSERT INTO test2 values ( '2020-01-03 11:01:00+00', 20, 12, '12row'); SELECT time_bucket(INTERVAL '2 hour', timec), b, count(*) FROM test2 GROUP BY time_bucket(INTERVAL '2 hour', timec), b ORDER BY 1, 2; time_bucket | b | count ------------------------------+----+------- Fri Jan 03 02:00:00 2020 PST | 11 | 26 Fri Jan 03 02:00:00 2020 PST | 12 | 1 Fri Jan 03 04:00:00 2020 PST | 11 | 2 --check status for chunk -- SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 9 | _hyper_14_62_chunk SELECT compressed_chunk_schema || '.' || compressed_chunk_name as "COMP_CHUNK_NAME", chunk_schema || '.' || chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' \gset SELECT count(*) from test2; count ------- 29 SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_62_chunk -- Demonstrate that no locks are held on the hypertable, chunk, or the -- compressed chunk after recompress_chunk has executed. SELECT pid, locktype, relation, relation::regclass, mode, granted FROM pg_locks WHERE relation::regclass::text IN (:'CHUNK_NAME', :'COMP_CHUNK_NAME', 'test2') ORDER BY pid; pid | locktype | relation | relation | mode | granted -----+----------+----------+----------+------+--------- SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_14_62_chunk --- insert into a compressed chunk again + a new chunk-- INSERT INTO test2 values ( '2020-01-03 11:01:03+00', 20, 11, '33row'), ( '2020-01-03 11:01:06+00', 20, 11, '36row'), ( '2020-01-03 11:02:00+00', 20, 12, '12row'), ( '2020-04-03 00:02:00+00', 30, 13, '3013row'); SELECT time_bucket(INTERVAL '2 hour', timec), b, count(*) FROM test2 GROUP BY time_bucket(INTERVAL '2 hour', timec), b ORDER BY 1, 2; time_bucket | b | count ------------------------------+----+------- Fri Jan 03 02:00:00 2020 PST | 11 | 28 Fri Jan 03 02:00:00 2020 PST | 12 | 2 Fri Jan 03 04:00:00 2020 PST | 11 | 2 Thu Apr 02 17:00:00 2020 PDT | 13 | 1 --chunk status should be partially compressed for the previously compressed chunk SELECT chunk_status, chunk_name as "CHUNK_NAME", compressed_chunk_name as "COMPRESSED_CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; chunk_status | CHUNK_NAME | COMPRESSED_CHUNK_NAME --------------+--------------------+---------------------------- 9 | _hyper_14_62_chunk | compress_hyper_15_63_chunk 0 | _hyper_14_64_chunk | SELECT add_compression_policy AS job_id FROM add_compression_policy('test2', '30d'::interval) \gset CALL run_job(:job_id); CALL run_job(:job_id); -- status should be compressed --- -- compressed chunk name should not change for -- the partially compressed chunk indicating -- it was done segmentwise SELECT chunk_status, chunk_name as "CHUNK_NAME", compressed_chunk_name as "COMPRESSED_CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; chunk_status | CHUNK_NAME | COMPRESSED_CHUNK_NAME --------------+--------------------+---------------------------- 1 | _hyper_14_62_chunk | compress_hyper_15_63_chunk 1 | _hyper_14_64_chunk | compress_hyper_15_65_chunk \set ON_ERROR_STOP 0 -- call compress_chunk when status is not unordered SELECT compress_chunk(:'CHUNK_NAME'::regclass); psql:include/recompress_basic.sql:107: NOTICE: chunk "_hyper_14_62_chunk" is already converted to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_62_chunk -- This will succeed and compress the chunk for the test below. SELECT compress_chunk(:'CHUNK_NAME'::regclass); psql:include/recompress_basic.sql:110: NOTICE: chunk "_hyper_14_62_chunk" is already converted to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_62_chunk --now decompress it , then try and recompress SELECT decompress_chunk(:'CHUNK_NAME'::regclass); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_62_chunk SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_62_chunk \set ON_ERROR_STOP 1 -- test recompress policy CREATE TABLE metrics(time timestamptz NOT NULL); SELECT hypertable_id AS "HYPERTABLE_ID", schema_name, table_name, created FROM create_hypertable('metrics','time') \gset ALTER TABLE metrics SET (timescaledb.compress); -- create chunk with some data and compress INSERT INTO metrics SELECT '2000-01-01' FROM generate_series(1,10); -- create custom compression job without recompress boolean SELECT add_job('_timescaledb_functions.policy_compression','1w',('{"hypertable_id": '||:'HYPERTABLE_ID'||', "compress_after": "@ 7 days"}')::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS "JOB_COMPRESS" \gset -- first call should compress CALL run_job(:JOB_COMPRESS); -- 2nd call should do nothing CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 -- do an INSERT so recompress has something to do INSERT INTO metrics SELECT '2000-01-01'; ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 9 -- should recompress CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 -- disable recompress in compress job SELECT alter_job(id,config:=jsonb_set(config,'{recompress}','false'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; alter_job --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1006,"@ 7 days","@ 0",-1,"@ 5 mins",t,"{""recompress"": false, ""hypertable_id"": 16, ""compress_after"": ""@ 7 days""}","Fri Dec 31 16:00:00 1999 PST",,t,"Fri Dec 31 16:00:00 1999 PST",,"User-Defined Action [1006]") -- nothing to do CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 -- do an INSERT so recompress has something to do INSERT INTO metrics SELECT '2000-01-01'; ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 9 -- still nothing to do since we disabled recompress CALL run_job(:JOB_COMPRESS); ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 9 -- reenable recompress in compress job SELECT alter_job(id,config:=jsonb_set(config,'{recompress}','true'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; alter_job -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1006,"@ 7 days","@ 0",-1,"@ 5 mins",t,"{""recompress"": true, ""hypertable_id"": 16, ""compress_after"": ""@ 7 days""}","Fri Dec 31 16:00:00 1999 PST",,t,"Fri Dec 31 16:00:00 1999 PST",,"User-Defined Action [1006]") -- should recompress now CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 SELECT delete_job(:JOB_COMPRESS); delete_job ------------ SELECT add_job('_timescaledb_functions.policy_recompression','1w',('{"hypertable_id": '||:'HYPERTABLE_ID'||', "recompress_after": "@ 7 days", "maxchunks_to_compress": 1}')::jsonb) AS "JOB_RECOMPRESS" \gset ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 ---- nothing to do yet CALL run_job(:JOB_RECOMPRESS); psql:include/recompress_basic.sql:186: NOTICE: no chunks for hypertable "public.metrics" that satisfy recompress chunk policy ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 -- create some work for recompress INSERT INTO metrics SELECT '2000-01-01'; -- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 9 CALL run_job(:JOB_RECOMPRESS); -- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; chunk_status -------------- 1 SELECT delete_job(:JOB_RECOMPRESS); delete_job ------------ --TEST 7 --compression policy should ignore frozen partially compressed chunks CREATE TABLE test_table_frozen(time TIMESTAMPTZ, val SMALLINT); SELECT create_hypertable('test_table_frozen', 'time', chunk_time_interval => '1 day'::interval); create_hypertable --------------------------------- (18,public,test_table_frozen,t) INSERT INTO test_table_frozen SELECT time, (random()*10)::smallint FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; ALTER TABLE test_table_frozen SET (timescaledb.compress); select add_compression_policy( 'test_table_frozen', compress_after=> '1 day'::interval ) as compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+---------------------------+-------------------+-------------+-------------+--------------+------------------------+--------------------+-------------------+-----------+----------------+---------------+---------------+----------------------------------------------------+------------------------+--------------------------+---------- 1008 | Columnstore Policy [1008] | @ 12 hours | @ 0 | -1 | @ 1 hour | _timescaledb_functions | policy_compression | default_perm_user | t | f | | 18 | {"hypertable_id": 18, "compress_after": "@ 1 day"} | _timescaledb_functions | policy_compression_check | SELECT show_chunks('test_table_frozen') as first_chunk LIMIT 1 \gset --will compress all chunks that need compression CALL run_job(:compressjob_id); -- make the chunks partial INSERT INTO test_table_frozen SELECT time, (random()*10)::smallint FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; id | status ----+-------- 69 | 9 -- freeze first chunk SELECT _timescaledb_functions.freeze_chunk(:'first_chunk'); freeze_chunk -------------- t -- first chunk status is 1 (Compressed) + 8 (Partially compressed) + 4 (Frozen) = 13 SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; id | status ----+-------- 69 | 13 --should recompress all chunks except first since its frozen CALL run_job(:compressjob_id); -- first chunk status is unchanged SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; id | status ----+-------- 69 | 13 -- unfreeze first chunk SELECT _timescaledb_functions.unfreeze_chunk(:'first_chunk'); unfreeze_chunk ---------------- t -- should be able to recompress the chunk since its unfrozen CALL run_job(:compressjob_id); -- first chunk status is Compressed (1) SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; id | status ----+-------- 69 | 1 --TEST 8 --reindexing in recompression policy CREATE TABLE metrics2(time DATE NOT NULL); CREATE INDEX metrics2_index ON metrics2(time DESC); SELECT hypertable_id AS "HYPERTABLE_ID", schema_name, table_name, created FROM create_hypertable('metrics2','time') \gset ALTER TABLE metrics2 SET (timescaledb.compress); INSERT INTO metrics2 SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); SELECT add_job('_timescaledb_functions.policy_compression','1w',('{"hypertable_id": '||:'HYPERTABLE_ID'||', "compress_after": "@ 7 days"}')::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS "JOB_COMPRESS" \gset -- first call should compress CALL run_job(:JOB_COMPRESS); -- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics2'; chunk_status -------------- 1 1 1 1 1 -- disable reindex in compress job SELECT alter_job(id,config:=jsonb_set(config,'{reindex}','false'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1009,"@ 7 days","@ 0",-1,"@ 5 mins",t,"{""reindex"": false, ""hypertable_id"": 20, ""compress_after"": ""@ 7 days""}","Fri Dec 31 16:00:00 1999 PST",,t,"Fri Dec 31 16:00:00 1999 PST",,"User-Defined Action [1009]") -- do an INSERT so recompress has something to do INSERT INTO metrics2 SELECT '2000-01-01' FROM generate_series(1,3000); SELECT chunk_schema, chunk_name FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics2' AND chunk_status = 9 LIMIT 1; \gset chunk_schema | chunk_name -----------------------+--------------------- _timescaledb_internal | _hyper_20_131_chunk SELECT format('%I.%I', :'chunk_schema', :'chunk_name') AS "RECOMPRESS_CHUNK_NAME"; \gset RECOMPRESS_CHUNK_NAME ------------------------------------------- _timescaledb_internal._hyper_20_131_chunk -- get size of the chunk that needs recompression VACUUM ANALYZE :RECOMPRESS_CHUNK_NAME; SELECT pg_indexes_size(:'RECOMPRESS_CHUNK_NAME') AS "SIZE_BEFORE_REINDEX"; \gset SIZE_BEFORE_REINDEX --------------------- 40960 CALL run_job(:JOB_COMPRESS); -- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE chunk_schema = :'chunk_schema' AND chunk_name = :'chunk_name'; chunk_status -------------- 1 -- index size should not have decreased VACUUM ANALYZE :RECOMPRESS_CHUNK_NAME; -- index size can vary, vacuuming can even increase the size of the index -- just check that the index size hasn't decreased, this can only happen -- when running VACUUM FULL or REINDEX TABLE SELECT pg_indexes_size(:'RECOMPRESS_CHUNK_NAME') >= :SIZE_BEFORE_REINDEX as size_unchanged; size_unchanged ---------------- t -- enable reindex in compress job SELECT alter_job(id,config:=jsonb_set(config,'{reindex}','true'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; alter_job ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1009,"@ 7 days","@ 0",-1,"@ 5 mins",t,"{""reindex"": true, ""hypertable_id"": 20, ""compress_after"": ""@ 7 days""}","Fri Dec 31 16:00:00 1999 PST",,t,"Fri Dec 31 16:00:00 1999 PST",,"User-Defined Action [1009]") -- do an INSERT so recompress has something to do INSERT INTO metrics2 SELECT '2000-01-01'; ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE chunk_schema = :'chunk_schema' AND chunk_name = :'chunk_name'; chunk_status -------------- 9 -- should recompress CALL run_job(:JOB_COMPRESS); -- index size should decrease due to reindexing (8kB or 16kB) VACUUM ANALYZE metrics2; SELECT pg_indexes_size(:'RECOMPRESS_CHUNK_NAME') <= 16384 as size_empty; size_empty ------------ t DROP TABLE metrics2; --TEST 8 --compression policy errors CREATE TABLE test_compression_policy_errors(time TIMESTAMPTZ, val SMALLINT); SELECT create_hypertable('test_compression_policy_errors', 'time', chunk_time_interval => '1 day'::interval); create_hypertable ---------------------------------------------- (22,public,test_compression_policy_errors,t) ALTER TABLE test_compression_policy_errors SET (timescaledb.compress, timescaledb.compress_segmentby = 'val', timescaledb.compress_orderby = 'time'); INSERT INTO test_compression_policy_errors SELECT time, (random()*10)::smallint FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; SELECT add_compression_policy( 'test_compression_policy_errors', compress_after=> '1 day'::interval, initial_start => now() - interval '1 day' ) as compressjob_id \gset SELECT config AS compressjob_config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id \gset SELECT FROM alter_job(:compressjob_id, config => jsonb_set(:'compressjob_config'::jsonb, '{recompress}', 'true')); -- -- 31 uncompressed chunks (0 - uncompressed, 1 - compressed) SELECT c.status, count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' GROUP BY c.status ORDER BY 2 DESC; status | count --------+------- 0 | 31 \c :TEST_DBNAME :ROLE_SUPERUSER -- Let's mess with the chunk status to for an error when executing the job WITH chunks AS ( SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' ORDER BY c.id LIMIT 20 ) UPDATE _timescaledb_catalog.chunk SET status = 3 FROM chunks WHERE chunk.id = chunks.id AND chunk.status = 0; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- After the mess 20 = status 3 and 11 = status 0 SELECT c.status, count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' GROUP BY c.status ORDER BY 2 DESC; status | count --------+------- 3 | 20 0 | 11 \set ON_ERROR_STOP 0 SET client_min_messages TO ERROR; \set VERBOSITY default -- This should fail with -- 20 chunks failed to compress and 11 chunks compressed successfully CALL run_job(:compressjob_id); ERROR: columnstore policy failure DETAIL: Failed to convert '20' chunks to columnstore. Successfully converted '11' chunks. CONTEXT: PL/pgSQL function _timescaledb_functions.policy_compression_execute(integer,integer,anyelement,integer,boolean,boolean,boolean,boolean) line 118 at RAISE SQL statement "CALL _timescaledb_functions.policy_compression_execute(job_id, htid, lag_value::INTERVAL, maxchunks, verbose_log, recompress_enabled, reindex_enabled, use_creation_time)" PL/pgSQL function _timescaledb_functions.policy_compression(integer,jsonb) line 62 at CALL \set VERBOSITY terse \set ON_ERROR_STOP 1 -- 31 uncompressed chunks (0 - uncompressed, 1 - compressed) SELECT c.status, count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' GROUP BY c.status ORDER BY 2 DESC; status | count --------+------- 3 | 20 1 | 11 -- Teardown test \c :TEST_DBNAME :ROLE_SUPERUSER REVOKE CREATE ON SCHEMA public FROM NOLOGIN_ROLE; DROP ROLE NOLOGIN_ROLE; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_bool_vectorized.out��������������������������������0000664�0000000�0000000�00000004275�15100345067�0026010�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. drop table if exists t1; NOTICE: table "t1" does not exist, skipping set timescaledb.enable_bool_compression = on; create table t1 (ts int, b bool); select create_hypertable('t1','ts'); create_hypertable ------------------- (1,public,t1,t) alter table t1 set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t1 values (1, true); insert into t1 values (2, false); insert into t1 values (3, NULL); insert into t1 values (4, true); insert into t1 values (5, false); insert into t1 values (6, NULL); select compress_chunk(show_chunks('t1')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from t1 order by 1; ts | b ----+--- 1 | t 2 | f 3 | 4 | t 5 | f 6 | select * from t1 where b is null order by 1; ts | b ----+--- 3 | 6 | select * from t1 where b = true order by 1; ts | b ----+--- 1 | t 4 | t select * from t1 where b = false order by 1; ts | b ----+--- 2 | f 5 | f select * from t1 where ts > 3 and b is null order by 1; ts | b ----+--- 6 | select * from t1 where ts > 3 and b = true order by 1; ts | b ----+--- 4 | t select * from t1 where ts > 3 and b = false order by 1; ts | b ----+--- 5 | f -- delete all null values and compress again delete from t1 where b is null; select compress_chunk(show_chunks('t1')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from t1 order by 1; ts | b ----+--- 1 | t 2 | f 4 | t 5 | f select * from t1 where b is null order by 1; ts | b ----+--- select * from t1 where b = true order by 1; ts | b ----+--- 1 | t 4 | t select * from t1 where b = false order by 1; ts | b ----+--- 2 | f 5 | f select * from t1 where ts > 3 and b is null order by 1; ts | b ----+--- select * from t1 where ts > 3 and b = true order by 1; ts | b ----+--- 4 | t select * from t1 where ts > 3 and b = false order by 1; ts | b ----+--- 5 | f �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_bools.out������������������������������������������0000664�0000000�0000000�00000020723�15100345067�0023731�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --install necessary functions for tests \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Create some data with NULLs and bools CREATE TABLE d (ts int, b bool); INSERT INTO d SELECT g AS ts, NULL AS b FROM generate_series(1, 5000) g; -- set b to true for even ts values and set some values to NULL UPDATE d SET b = (ts % 2 = 0); UPDATE d SET b = NULL WHERE (ts % 10 = 0); -- add some bools that can be RLE compressed INSERT INTO d SELECT g AS ts, true AS b FROM generate_series(5001, 20000) g; -- add a few bool columns CREATE TABLE t (ts int, b1 bool, b2 bool, b3 bool); SELECT create_hypertable('t', 'ts', chunk_time_interval => 5000); create_hypertable ------------------- (1,public,t,t) -- explicitly disable bool compression so the test -- doesn't depend on the default setting SET timescaledb.enable_bool_compression = off; INSERT INTO t SELECT d.ts, d.b AS b1, d.b AS b2, d.b AS b3 FROM d ORDER BY ts; SELECT max(ts) FROM t; max ------- 20000 ALTER TABLE t SET (timescaledb.compress, timescaledb.compress_orderby = 'ts'); SELECT compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk CREATE TABLE chunks_done AS SELECT show_chunks('t') AS chunk_name; SELECT * FROM chunks_done; chunk_name ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk SELECT chunk_schema, chunk_name, compression_status, after_compression_total_bytes -- the before compression size differs on platforms, so I dont't -- display it here, and consequently the compression ratio as well FROM chunk_compression_stats('t'); chunk_schema | chunk_name | compression_status | after_compression_total_bytes -----------------------+------------------+--------------------+------------------------------- _timescaledb_internal | _hyper_1_1_chunk | Compressed | 65536 _timescaledb_internal | _hyper_1_2_chunk | Compressed | 65536 _timescaledb_internal | _hyper_1_3_chunk | Compressed | 65536 _timescaledb_internal | _hyper_1_4_chunk | Compressed | 65536 _timescaledb_internal | _hyper_1_5_chunk | Compressed | 40960 -- enable bool compression and add more data, so the two compression -- methods will co-exist and we can test both, plus compare the -- compression ratio -- SET timescaledb.enable_bool_compression = on; INSERT INTO t SELECT (SELECT max(ts) FROM t)+d.ts, d.b AS b1, d.b AS b2, d.b AS b3 FROM d ORDER BY ts; SELECT max(ts) FROM t; max ------- 40000 SELECT compress_chunk(c) FROM show_chunks('t') c WHERE c NOT IN (SELECT chunk_name FROM chunks_done); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk _timescaledb_internal._hyper_1_14_chunk SELECT chunk_schema, chunk_name, compression_status, after_compression_total_bytes -- the before compression size differs on platforms, so I dont't -- display it here, and consequently the compression ratio as well -- -- the after compression size should be smaller than it was before -- the bool compression was enabled -- FROM chunk_compression_stats('t') WHERE format('%I.%I', chunk_schema, chunk_name)::regclass NOT IN (SELECT chunk_name FROM chunks_done); chunk_schema | chunk_name | compression_status | after_compression_total_bytes -----------------------+-------------------+--------------------+------------------------------- _timescaledb_internal | _hyper_1_11_chunk | Compressed | 40960 _timescaledb_internal | _hyper_1_12_chunk | Compressed | 40960 _timescaledb_internal | _hyper_1_13_chunk | Compressed | 40960 _timescaledb_internal | _hyper_1_14_chunk | Compressed | 40960 -- check the compression algorithm for the compressed chunks CREATE TABLE compressed_chunks AS SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as compressed_chunk, ccs.compressed_heap_size, ccs.compressed_toast_size, ccs.compressed_index_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM show_chunks('t') c INNER JOIN _timescaledb_catalog.chunk cat ON (c = format('%I.%I', cat.schema_name, cat.table_name)::regclass) INNER JOIN _timescaledb_catalog.chunk comp ON (cat.compressed_chunk_id = comp.id) INNER JOIN _timescaledb_catalog.compression_chunk_size ccs ON (comp.id = ccs.compressed_chunk_id); CREATE TABLE compression_info (compressed_chunk regclass, result text, compressed_size int, num_rows int); DO $$ DECLARE table_ref regclass; BEGIN FOR table_ref IN SELECT compressed_chunk as table_ref FROM compressed_chunks LOOP EXECUTE format( 'INSERT INTO compression_info ( SELECT %L::regclass as compressed_chunk, (_timescaledb_functions.compressed_data_info(b1))::text as result, sum(pg_column_size(b1)::int) as compressed_size, count(*) as num_rows FROM %s GROUP BY 1,2)', table_ref, table_ref ); END LOOP; END; $$; SELECT ci.*, ccs.compressed_toast_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM compression_info ci INNER JOIN compressed_chunks ccs ON (ci.compressed_chunk = ccs.compressed_chunk) ORDER BY 1,2,3; compressed_chunk | result | compressed_size | num_rows | compressed_toast_size | numrows_pre_compression | numrows_post_compression -------------------------------------------------+-----------+-----------------+----------+-----------------------+-------------------------+-------------------------- _timescaledb_internal.compress_hyper_2_6_chunk | (ARRAY,t) | 320 | 5 | 32768 | 4999 | 5 _timescaledb_internal.compress_hyper_2_7_chunk | (ARRAY,f) | 172 | 4 | 32768 | 5000 | 5 _timescaledb_internal.compress_hyper_2_7_chunk | (ARRAY,t) | 62 | 1 | 32768 | 5000 | 5 _timescaledb_internal.compress_hyper_2_8_chunk | (ARRAY,f) | 215 | 5 | 32768 | 5000 | 5 _timescaledb_internal.compress_hyper_2_9_chunk | (ARRAY,f) | 215 | 5 | 32768 | 5000 | 5 _timescaledb_internal.compress_hyper_2_10_chunk | (ARRAY,f) | 38 | 1 | 8192 | 1 | 1 _timescaledb_internal.compress_hyper_2_15_chunk | (BOOL,f) | 116 | 4 | 8192 | 5000 | 5 _timescaledb_internal.compress_hyper_2_15_chunk | (BOOL,t) | 69 | 1 | 8192 | 5000 | 5 _timescaledb_internal.compress_hyper_2_16_chunk | (BOOL,f) | 145 | 5 | 8192 | 5000 | 5 _timescaledb_internal.compress_hyper_2_17_chunk | (BOOL,f) | 145 | 5 | 8192 | 5000 | 5 _timescaledb_internal.compress_hyper_2_18_chunk | (BOOL,f) | 29 | 1 | 8192 | 1 | 1 DROP TABLE t; DROP TABLE d; DROP TABLE chunks_done; DROP TABLE compression_info; -- reset the compression setting SET timescaledb.enable_bool_compression = default; ���������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_conflicts.out��������������������������������������0000664�0000000�0000000�00000077413�15100345067�0024607�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test conflict handling on compressed hypertables with unique constraints set timescaledb.debug_compression_path_info to on; -- test 1: single column primary key CREATE TABLE comp_conflicts_1(time timestamptz, device text, value float, PRIMARY KEY(time)); SELECT table_name FROM create_hypertable('comp_conflicts_1','time'); table_name ------------------ comp_conflicts_1 ALTER TABLE comp_conflicts_1 SET (timescaledb.compress); -- implicitly create chunk INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); -- sanity check behaviour without compression -- should fail due to multiple entries with same time value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); ERROR: duplicate key value violates unique constraint "1_1_comp_conflicts_1_pkey" INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1), ('2020-01-01','d2',0.2), ('2020-01-01','d3',0.3); ERROR: duplicate key value violates unique constraint "1_1_comp_conflicts_1_pkey" \set ON_ERROR_STOP 1 -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_1 VALUES ('2020-01-01 0:00:01','d1',0.1), ('2020-01-01 0:00:02','d2',0.2), ('2020-01-01 0:00:03','d3',0.3); ROLLBACK; SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_1') c \gset INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- repeat tests on an actual compressed chunk -- should fail due to multiple entries with same time value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); INFO: Using table scan with scan keys: index 0, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "1_1_comp_conflicts_1_pkey" INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1), ('2020-01-01','d2',0.2), ('2020-01-01','d3',0.3); INFO: Using table scan with scan keys: index 0, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "1_1_comp_conflicts_1_pkey" \set ON_ERROR_STOP 1 -- no data should be in uncompressed chunk since the inserts failed and their transaction rolled back SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_1 VALUES ('2020-01-01 0:00:01','d1',0.1), ('2020-01-01 0:00:02','d2',0.2), ('2020-01-01 0:00:03','d3',0.3); INFO: Using table scan with scan keys: index 0, heap 2, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 2, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 2, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- no data should have moved into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 3 ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); INFO: Using table scan with scan keys: index 0, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "1_1_comp_conflicts_1_pkey" \set ON_ERROR_STOP 1 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1) ON CONFLICT DO NOTHING; INFO: Using table scan with scan keys: index 0, heap 2, memory 1. -- data should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- test 2: multi-column unique without segmentby CREATE TABLE comp_conflicts_2(time timestamptz NOT NULL, device text, value float, UNIQUE(time, device)); SELECT table_name FROM create_hypertable('comp_conflicts_2','time'); table_name ------------------ comp_conflicts_2 ALTER TABLE comp_conflicts_2 SET (timescaledb.compress, timescaledb.compress_segmentby=''); -- implicitly create chunk INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1); INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d2',0.2); SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_2') c \gset INFO: using tuplesort to scan rows from "_hyper_3_3_chunk" for converting to columnstore -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should fail due to multiple entries with same time, device value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. ERROR: duplicate key value violates unique constraint "3_2_comp_conflicts_2_time_device_key" INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d2',0.2); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. ERROR: duplicate key value violates unique constraint "3_2_comp_conflicts_2_time_device_key" INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1), ('2020-01-01','d2',0.2), ('2020-01-01','d3',0.3); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. ERROR: duplicate key value violates unique constraint "3_2_comp_conflicts_2_time_device_key" \set ON_ERROR_STOP 1 -- no data should be in uncompressed chunk since the inserts failed and their transaction rolled back SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_2 VALUES ('2020-01-01 0:00:01','d1',0.1), ('2020-01-01 0:00:01','d2',0.2), ('2020-01-01 0:00:01','d3',0.3); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 3 ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. ERROR: duplicate key value violates unique constraint "3_2_comp_conflicts_2_time_device_key" \set ON_ERROR_STOP 1 INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1) ON CONFLICT DO NOTHING; INFO: Using table scan with scan keys: index 0, heap 4, memory 2. -- data should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- test 3: multi-column primary key with segmentby CREATE TABLE comp_conflicts_3(time timestamptz NOT NULL, device text, label text DEFAULT 'label', value float, UNIQUE(time, device, label)); SELECT table_name FROM create_hypertable('comp_conflicts_3','time'); table_name ------------------ comp_conflicts_3 ALTER TABLE comp_conflicts_3 SET (timescaledb.compress,timescaledb.compress_segmentby='device, label'); -- implicitly create chunk INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d2', 'label', 0.2); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01',NULL, 'label', 0.3); SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_3') c \gset INFO: using tuplesort to scan rows from "_hyper_5_5_chunk" for converting to columnstore -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should fail due to multiple entries with same time, device value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d2', 'label', 0.2); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1), ('2020-01-01','d2', 'label', 0.2), ('2020-01-01','d3', 'label', 0.3); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" -- should work the same without the index present BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d2', 'label', 0.2); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1), ('2020-01-01','d2', 'label', 0.2), ('2020-01-01','d3', 'label', 0.3); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; -- using superuser to create indexes on compressed chunks \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER set timescaledb.debug_compression_path_info to on; -- ignore matching partial index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device, label, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC) WHERE label LIKE 'missing'; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; -- ignore matching covering index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX covering_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device) INCLUDE (label, _ts_meta_min_1, _ts_meta_max_1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using index scan with scan keys: index 1, heap 3, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; -- out of order segmentby index, index is still usable BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk (label, device, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; -- index with sequence number in the middle, index should be usable with single index scan key BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX covering_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC, label); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using index scan with scan keys: index 1, heap 3, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; -- ignore expression index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device, lower(label), _ts_meta_min_1 DESC, _ts_meta_max_1 DESC); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; -- ignore non-btree index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk USING brin (device, label, _ts_meta_min_1, _ts_meta_max_1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" ROLLBACK; \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER set timescaledb.debug_compression_path_info to on; -- no data should be in uncompressed chunk since the inserts failed and their transaction rolled back SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- NULL is considered distinct from other NULL so even though the next INSERT looks -- like a conflict it is not a constraint violation (PG15 makes NULL behaviour configurable) BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01',NULL, 'label', 0.3); -- data for 1 segment (count = 1 value + 1 inserted) should be present in uncompressed chunk -- we treat NULLs as NOT DISTINCT and let the constraint configuration handle the check SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; -- check if NULL handling works the same with the compressed index dropped BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01',NULL, 'label', 0.3); -- data for 1 segment (count = 1 value + 1 inserted) should be present in uncompressed chunk -- we treat NULLs as NOT DISTINCT and let the constraint configuration handle the check SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 1. Number of compressed rows filtered by heap filters: 1. -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; -- same as above but no index -- should succeed since there are no conflicts in the values BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1), ('2020-01-01 0:00:01','d2', 'label', 0.2), ('2020-01-01 0:00:01','d3', 'label', 0.3); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 1. Number of compressed rows filtered by heap filters: 1. INFO: Using index scan with scan keys: index 2, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 1. Number of compressed rows filtered by heap filters: 1. INFO: Using index scan with scan keys: index 2, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 0. Number of compressed rows filtered by heap filters: 0. -- no data for should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 3 ROLLBACK; -- same as above but no index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1), ('2020-01-01 0:00:01','d2', 'label', 0.2), ('2020-01-01 0:00:01','d3', 'label', 0.3); INFO: Using table scan with scan keys: index 0, heap 4, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 4, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 4, memory 1. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- no data for should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 3 ROLLBACK; BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d3', 'label', 0.2); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 0. Number of compressed rows filtered by heap filters: 0. -- count = 1 since no data should have move into uncompressed chunk for conflict check since d3 is new segment SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INFO: Using index scan with scan keys: index 2, heap 2, memory 1. ERROR: duplicate key value violates unique constraint "5_3_comp_conflicts_3_time_device_label_key" \set ON_ERROR_STOP 1 INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1) ON CONFLICT DO NOTHING; INFO: Using index scan with scan keys: index 2, heap 2, memory 1. -- data should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- test 4: multi-column primary key with multi-column orderby compression CREATE TABLE comp_conflicts_4(time timestamptz NOT NULL, device text, value float, UNIQUE(time, device)); SELECT table_name FROM create_hypertable('comp_conflicts_4','time'); table_name ------------------ comp_conflicts_4 ALTER TABLE comp_conflicts_4 SET (timescaledb.compress,timescaledb.compress_segmentby='',timescaledb.compress_orderby='time,device'); -- implicitly create chunk INSERT INTO comp_conflicts_4 SELECT generate_series('2020-01-01'::timestamp, '2020-01-01 2:00:00', '1s'), 'd1',0.1; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01','d2',0.2); INSERT INTO comp_conflicts_4 VALUES ('2020-01-01',NULL,0.3); SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_4') c \gset INFO: using tuplesort to scan rows from "_hyper_7_7_chunk" for converting to columnstore -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- NULL is considered distinct from other NULL so even though the next INSERT looks -- like a conflict it is not a constraint violation (PG15 makes NULL behaviour configurable) BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01',NULL,0.3); -- data for 1 segment (count = 1000 values + 1 inserted) should be present in uncompressed chunk -- we treat NULLs as NOT DISTINCT and let the constraint configuration handle the check SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 2:00:01','d1',0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 2:00:01','d1',0.1), ('2020-01-01 2:00:01','d2',0.2), ('2020-01-01 2:00:01','d3',0.3); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- no data for should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; count ------- 3 ROLLBACK; BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 0:00:01','d3',0.2); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INFO: Number of compressed rows fetched from table scan: 0. Number of compressed rows filtered: 0. -- count = 1 since no data should have move into uncompressed chunk for conflict check since d3 is new segment SELECT count(*) FROM ONLY :CHUNK; count ------- 1 ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; count ------- 0 -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_4 VALUES ('2020-01-01','d1',0.1); INFO: Using table scan with scan keys: index 0, heap 4, memory 2. ERROR: duplicate key value violates unique constraint "7_4_comp_conflicts_4_time_device_key" \set ON_ERROR_STOP 1 -- data not should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; count ------- 0 INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 0:00:01','d1',0.1) ON CONFLICT DO NOTHING; INFO: Using table scan with scan keys: index 0, heap 4, memory 2. INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 0:30:00','d1',0.1) ON CONFLICT DO NOTHING; INFO: Using table scan with scan keys: index 0, heap 4, memory 2. -- data should have move into uncompressed chunk for conflict check -- 2 segments (count = 2000) SELECT count(*) FROM ONLY :CHUNK; count ------- 0 CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id; CREATE TABLE compressed_ht ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); CREATE UNIQUE INDEX sensor_id_time_idx on compressed_ht(time, sensor_id); SELECT * FROM create_hypertable('compressed_ht', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+---------------+--------- 9 | public | compressed_ht | t -- create chunk 1 INSERT INTO compressed_ht VALUES ('2017-12-28 01:10:28.192199+05:30', '1', 0.876, 4.123, 'chunk 1'); INSERT INTO compressed_ht VALUES ('2017-12-24 01:10:28.192199+05:30', '1', 0.876, 4.123, 'chunk 1'); -- create chunk 2 INSERT INTO compressed_ht VALUES ('2017-03-28 01:10:28.192199+05:30', '2', 0.876, 4.123, 'chunk 2'); INSERT INTO compressed_ht VALUES ('2017-03-12 01:10:28.192199+05:30', '3', 0.876, 4.123, 'chunk 2'); -- create chunk 3 INSERT INTO compressed_ht VALUES ('2022-01-18 01:10:28.192199+05:30', '4', 0.876, 4.123, 'chunk 3'); INSERT INTO compressed_ht VALUES ('2022-01-08 01:10:28.192199+05:30', '4', 0.876, 4.123, 'chunk 3'); INSERT INTO compressed_ht VALUES ('2022-01-11 01:10:28.192199+05:30', '5', 0.876, 4.123, 'chunk 3'); INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'chunk 3'); ALTER TABLE compressed_ht SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); SELECT COMPRESS_CHUNK(SHOW_CHUNKS('compressed_ht')); INFO: using tuplesort to scan rows from "_hyper_9_9_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_9_10_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_9_11_chunk" for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_9_chunk _timescaledb_internal._hyper_9_10_chunk _timescaledb_internal._hyper_9_11_chunk -- check compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'compressed_ht' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_9_10_chunk 1 | _hyper_9_11_chunk 1 | _hyper_9_9_chunk -- should report 0 row SELECT COUNT(*) FROM compressed_ht WHERE name = 'ON CONFLICT DO UPDATE'; count ------- 0 INSERT INTO compressed_ht VALUES ('2017-12-28 01:10:28.192199+05:30', '1', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO UPDATE SET sensor_id = excluded.sensor_id , name = 'ON CONFLICT DO UPDATE'; INFO: Using index scan with scan keys: index 1, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 1. Number of compressed rows filtered by heap filters: 0. -- should report 1 row SELECT COUNT(*) FROM compressed_ht WHERE name = 'ON CONFLICT DO UPDATE'; count ------- 1 -- check that chunk 1 compression status is set to partial SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'compressed_ht' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_9_10_chunk 1 | _hyper_9_11_chunk 9 | _hyper_9_9_chunk INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO UPDATE SET sensor_id = excluded.sensor_id , name = 'ON CONFLICT DO UPDATE' RETURNING *; INFO: Using index scan with scan keys: index 1, heap 2, memory 1. INFO: Number of compressed rows fetched from index: 1. Number of compressed rows filtered by heap filters: 0. time | sensor_id | cpu | temperature | name -------------------------------------+-----------+-------+-------------+----------------------- Sun Jan 23 11:40:28.192199 2022 PST | 6 | 0.876 | 4.123 | ON CONFLICT DO UPDATE -- check that chunks 1 and 3 compression status is set to partial SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'compressed_ht' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_9_10_chunk 9 | _hyper_9_11_chunk 9 | _hyper_9_9_chunk -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- Should error because we disabled the DML decompression INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO UPDATE SET sensor_id = excluded.sensor_id , name = 'ON CONFLICT DO UPDATE' RETURNING *; ERROR: inserting into compressed chunk with unique constraints disabled INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO NOTHING; ERROR: inserting into compressed chunk with unique constraints disabled -- Even a regular insert will fail due to unique constrant checks for dml decompression INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '7', 0.876, 4.123, 'new insert row'); ERROR: inserting into compressed chunk with unique constraints disabled \set ON_ERROR_STOP 1 RESET timescaledb.enable_dml_decompression; -- gh issue #7342 CREATE TABLE test_collation ( time int8 NOT NULL, device_id int4 NOT NULL, name TEXT NOT NULL, CONSTRAINT test_collation_pkey PRIMARY KEY (time, device_id, name) ); SELECT create_hypertable('test_collation', 'time', chunk_time_interval => 2419200000); create_hypertable ------------------------------ (11,public,test_collation,t) ALTER TABLE test_collation SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id', timescaledb.compress_orderby = 'time DESC, name' ); INSERT INTO "test_collation" ("time", "device_id", "name") VALUES (1609477200000, 41, 'val1'), (1609478100000, 41, 'val1') ON CONFLICT DO NOTHING; SELECT compress_chunk(ch) FROM show_chunks('test_collation') ch; INFO: using tuplesort to scan rows from "_hyper_11_15_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_15_chunk INSERT INTO "test_collation" ("device_id", "time", "name") VALUES (41, 1609477200000, 'val1'), (41, 1609478100000, 'val1') ON CONFLICT DO NOTHING; INFO: Using index scan with scan keys: index 1, heap 4, memory 2. INFO: Using index scan with scan keys: index 1, heap 4, memory 2. RESET timescaledb.debug_compression_path_info; -- gh issue #7672 -- check additional INSERTS after hitting ON CONFLICT clause still go through CREATE TABLE test_i7672(time timestamptz, device text, primary key(time,device)); SELECT create_hypertable('test_i7672', 'time'); create_hypertable -------------------------- (13,public,test_i7672,t) ALTER TABLE test_i7672 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device'); INSERT INTO test_i7672 VALUES ('2025-01-01','d1'); SELECT count(*) FROM (SELECT compress_chunk(show_chunks('test_i7672'))) c; count ------- 1 INSERT INTO test_i7672 VALUES ('2025-01-01','d1'), ('2025-01-01','d2') ON CONFLICT DO NOTHING; SELECT * FROM test_i7672 t ORDER BY t; time | device ------------------------------+-------- Wed Jan 01 00:00:00 2025 PST | d1 Wed Jan 01 00:00:00 2025 PST | d2 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_constraints.out������������������������������������0000664�0000000�0000000�00000042512�15100345067�0025162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); -- test all variations without data BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time); ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); ROLLBACK; -- test all variations with data but no conflict INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 1 \set ON_ERROR_STOP 0 BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ERROR: duplicate key value violates unique constraint "1_1_metrics_pk" ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ERROR: duplicate key value violates unique constraint "1_3_metrics_pk" ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ERROR: duplicate key value violates unique constraint "1_5_metrics_pk" ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ERROR: duplicate key value violates unique constraint "1_7_metrics_pk" ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ERROR: duplicate key value violates unique constraint "_hyper_1_1_chunk_metrics_pk" ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ERROR: duplicate key value violates unique constraint "_hyper_1_1_chunk_metrics_pk" ROLLBACK; \set ON_ERROR_STOP 0 -- test with conflict across uncompressed/compressed INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); ERROR: duplicate key value violates unique constraint ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); ERROR: duplicate key value violates unique constraint ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); ERROR: duplicate key value violates unique constraint ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); ERROR: duplicate key value violates unique constraint CREATE UNIQUE INDEX metrics_pk ON metrics(time); ERROR: duplicate key value violates unique constraint CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 -- test with conflict in compressed SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 1 \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); ERROR: duplicate key value violates unique constraint ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); ERROR: duplicate key value violates unique constraint ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); ERROR: duplicate key value violates unique constraint ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); ERROR: duplicate key value violates unique constraint CREATE UNIQUE INDEX metrics_pk ON metrics(time); ERROR: duplicate key value violates unique constraint CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 DROP TABLE metrics; -- test NULL behaviour CREATE TABLE dist_null(time timestamptz not null, device text, value float); SELECT table_name FROM create_hypertable('dist_null','time',chunk_time_interval:='1 year'::interval); table_name ------------ dist_null ALTER TABLE dist_null SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); -- test behaviour without compression BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; DROP INDEX dist_null_idx; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; ERROR: could not create unique index "_hyper_3_9_chunk_dist_null_idx" \set ON_ERROR_STOP 1 ROLLBACK; -- test behaviour with conflict in compressed BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; count ------- 1 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; DROP INDEX dist_null_idx; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; -- test behaviour with conflict between compressed/uncompressed BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; count ------- 1 INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; DROP INDEX dist_null_idx; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; ERROR: could not create unique index "_hyper_3_14_chunk_dist_null_idx" \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; ERROR: could not create unique index "_hyper_3_15_chunk_dist_null_idx" \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (full compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; count ------- 1 \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (full compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; count ------- 1 \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (partially compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; count ------- 1 INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (partially compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; count ------- 1 INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; -- test foreign keys -- hypertable referencing plain table CREATE TABLE metrics(time timestamptz NOT NULL, device text, value float, PRIMARY KEY(device,time)); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (5,public,metrics,t) INSERT INTO metrics SELECT '2025-01-01','d1',0.1; INSERT INTO metrics SELECT '2025-01-01','d2',0.1; CREATE TABLE device(device TEXT PRIMARY KEY); INSERT INTO device SELECT 'd1'; CREATE TABLE events(time timestamptz, device text, data text); INSERT INTO events SELECT '2025-02-01', 'd1', ''; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); ERROR: insert or update on table "metrics" violates foreign key constraint "device_fk" ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); ERROR: insert or update on table "events" violates foreign key constraint "events_fk" \set ON_ERROR_STOP 1 BEGIN; INSERT INTO device SELECT 'd2'; ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); INSERT INTO metrics SELECT '2025-03-01','d2',0.3; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-03-01','d3',0.3; ERROR: insert or update on table "_hyper_5_25_chunk" violates foreign key constraint "25_11_device_fk" \set ON_ERROR_STOP 1 ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-02-01','d1',0.1; ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); INSERT INTO events SELECT '2025-01-01','d1',''; \set ON_ERROR_STOP 0 INSERT INTO events SELECT '2025-03-01','d1',''; ERROR: insert or update on table "events" violates foreign key constraint "events_fk" \set ON_ERROR_STOP 1 ROLLBACK; ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_orderby='device,time DESC', tsdb.compress_segmentby=''); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 1 \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); ERROR: insert or update on table "metrics" violates foreign key constraint "device_fk" ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); ERROR: insert or update on table "events" violates foreign key constraint "events_fk" \set ON_ERROR_STOP 1 BEGIN; INSERT INTO device SELECT 'd2'; ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); INSERT INTO metrics SELECT '2025-03-01','d2',0.3; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-03-01','d3',0.3; ERROR: insert or update on table "_hyper_5_28_chunk" violates foreign key constraint "28_15_device_fk" \set ON_ERROR_STOP 1 ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-02-01','d1',0.1; ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); INSERT INTO events SELECT '2025-01-01','d1',''; \set ON_ERROR_STOP 0 INSERT INTO events SELECT '2025-03-01','d1',''; ERROR: insert or update on table "events" violates foreign key constraint "events_fk" \set ON_ERROR_STOP 1 ROLLBACK; DROP TABLE metrics CASCADE; DROP TABLE device CASCADE; DROP TABLE events CASCADE; -- test CHECK constraints CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (7,public,metrics,t) ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); INSERT INTO metrics SELECT '2025-01-01','d1',1; INSERT INTO metrics SELECT '2025-01-01','d1',NULL; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 9000); ERROR: check constraint "metrics_check" of relation "_hyper_7_30_chunk" is violated by some row ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (time > '2026-01-01' AND value > 0); ERROR: check constraint "metrics_check" of relation "_hyper_7_30_chunk" is violated by some row \set ON_ERROR_STOP 1 BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 0.9); ALTER TABLE metrics ADD CONSTRAINT metrics_check2 CHECK (time >= '2025-01-01' AND value > 0); INSERT INTO metrics SELECT '2025-01-01','d1',2; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',0; ERROR: new row for relation "_hyper_7_30_chunk" violates check constraint "metrics_check" \set ON_ERROR_STOP 1 ROLLBACK; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 1 \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 9000); ERROR: check constraint "metrics_check" of relation "_hyper_7_30_chunk" is violated by some row ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (time > '2026-01-01' AND value > 0); ERROR: check constraint "metrics_check" of relation "_hyper_7_30_chunk" is violated by some row \set ON_ERROR_STOP 1 BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 0.9); ALTER TABLE metrics ADD CONSTRAINT metrics_check2 CHECK (time >= '2025-01-01' AND value > 0); INSERT INTO metrics SELECT '2025-01-01','d1',2; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',0; ERROR: new row for relation "_hyper_7_30_chunk" violates check constraint "metrics_check" \set ON_ERROR_STOP 1 ROLLBACK; DROP TABLE metrics CASCADE; -- test adding columns and constraints together CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT create_hypertable('metrics','time'); create_hypertable ---------------------- (9,public,metrics,t) ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); INSERT INTO metrics SELECT '2025-01-01','d1',1; -- should fail in validation since the new column will be NULL for existing tuples \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD COLUMN c1 int CHECK ( c1 IS NOT NULL ); ERROR: check constraint "metrics_c1_check" of relation "_hyper_9_32_chunk" is violated by some row \set ON_ERROR_STOP 1 BEGIN; -- should succeed since the CHECK constraint will succeed for NULL values ALTER TABLE metrics ADD COLUMN c1 int CHECK (c1 <> 42); INSERT INTO metrics SELECT '2025-01-01','d1',1,23; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',1,42; ERROR: new row for relation "_hyper_9_32_chunk" violates check constraint "metrics_c1_check" \set ON_ERROR_STOP 1 ROLLBACK; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 1 -- should fail in validation since the new column will be NULL for existing tuples \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD COLUMN c1 int CHECK ( c1 IS NOT NULL ); ERROR: check constraint "metrics_c1_check" of relation "_hyper_9_32_chunk" is violated by some row \set ON_ERROR_STOP 1 BEGIN; -- should succeed since the CHECK constraint will succeed for NULL values ALTER TABLE metrics ADD COLUMN c1 int CHECK (c1 <> 42); INSERT INTO metrics SELECT '2025-01-01','d1',1,23; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',1,42; ERROR: new row for relation "_hyper_9_32_chunk" violates check constraint "metrics_c1_check" \set ON_ERROR_STOP 1 ROLLBACK; -- test unique expression indexes BEGIN; -- should succeed since no conflict CREATE UNIQUE INDEX metrics_unique ON metrics(time, device, md5(value::text)); ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-01-01','d1',1; -- partially compressed chunk -- should fail because there is conflict \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX metrics_unique ON metrics(time, device, md5(value::text)); ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-01-01','d1',1; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; count ------- 1 -- fully compressed chunk -- should fail because there is conflict \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX metrics_unique ON metrics(time, device, md5(value::text)); ERROR: duplicate key value violates unique constraint \set ON_ERROR_STOP 1 ROLLBACK; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_create_compressed_table.out������������������������0000664�0000000�0000000�00000004411�15100345067�0027445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- create compressed hypertable CREATE TABLE "public"."metrics" ( "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ); SELECT create_hypertable('public.metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); -- insert uncompressed row into hypertable INSERT INTO metrics (time, device_id, val) VALUES('2023-05-01T00:00:00Z'::timestamptz, 1, 1.0); SELECT count(*) FROM _timescaledb_internal._hyper_1_1_chunk; count ------- 1 -- compress these rows, we do this to get compressed row data for the test SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- create custom compressed chunk table CREATE TABLE _timescaledb_internal.custom_compressed_chunk( LIKE _timescaledb_internal.compress_hyper_2_2_chunk); -- copy compressed row from compressed table into custom compressed chunk table INSERT INTO "_timescaledb_internal"."custom_compressed_chunk" SELECT * FROM "_timescaledb_internal"."compress_hyper_2_2_chunk"; -- decompress the rows, moving them back to uncompressed space SELECT decompress_chunk('"_timescaledb_internal"."_hyper_1_1_chunk"'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- attach compressed chunk to parent chunk SELECT _timescaledb_functions.create_compressed_chunk( '"_timescaledb_internal"."_hyper_1_1_chunk"'::TEXT::REGCLASS, '"_timescaledb_internal"."custom_compressed_chunk"'::TEXT::REGCLASS, 8192, 8192, 16384, 8192, 8192, 16384, 1, 1 ); create_compressed_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- select total rows in chunk (should be 2) SELECT count(*) FROM "_timescaledb_internal"."_hyper_1_1_chunk"; count ------- 2 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_ddl.out��������������������������������������������0000664�0000000�0000000�00000321333�15100345067�0023357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/rand_generator.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------- -- cheap rand generator -- -------------------------- create table rand_minstd_state(i bigint); create function rand_minstd_advance(bigint) returns bigint language sql immutable as $$ select (16807 * $1) % 2147483647 $$; create function gen_rand_minstd() returns bigint language sql security definer as $$ update rand_minstd_state set i = rand_minstd_advance(i) returning i $$; -- seed the random num generator insert into rand_minstd_state values (321); \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; SET client_min_messages = NOTICE; --test hypertable with tables space CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE test1 ("Time" timestamptz, i integer not null, b bigint, t text); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test1 INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; count ------- 27 VACUUM FULL ANALYZE test1; --make sure allowed ddl still work ALTER TABLE test1 CLUSTER ON "test1_Time_idx"; ALTER TABLE test1 SET WITHOUT CLUSTER; CREATE INDEX new_index ON test1(b); DROP INDEX new_index; ALTER TABLE test1 SET (fillfactor=100); ALTER TABLE test1 RESET (fillfactor); ALTER TABLE test1 ALTER COLUMN b SET STATISTICS 10; -- ensure that REPLICA IDENTITY works SELECT relreplident, count(*) FROM show_chunks('test1') ch INNER JOIN pg_class c ON (ch = c.oid) GROUP BY 1 ORDER BY 1; relreplident | count --------------+------- d | 27 SELECT relreplident FROM pg_class c WHERE c.relname = 'test1'; relreplident -------------- d ALTER TABLE test1 REPLICA IDENTITY FULL; SELECT relname, relreplident FROM pg_class WHERE relname = 'test1' ORDER BY relname; relname | relreplident ---------+-------------- test1 | f -- the chunk's setting should also change to FULL SELECT relreplident, count(*) FROM show_chunks('test1') ch INNER JOIN pg_class c ON (ch = c.oid) GROUP BY 1 ORDER BY 1; relreplident | count --------------+------- f | 27 SELECT relreplident FROM pg_class c WHERE c.relname = 'test1'; relreplident -------------- f ALTER TABLE test1 REPLICA IDENTITY DEFAULT; --test adding boolean columns with default and not null CREATE TABLE records (time timestamp NOT NULL); SELECT create_hypertable('records', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ---------------------- (3,public,records,t) ALTER TABLE records SET (timescaledb.compress = true, timescaledb.compress_orderby='"time" DESC'); ALTER TABLE records ADD COLUMN col1 boolean DEFAULT false NOT NULL; -- NULL constraints are useless and it is safe allow adding this -- column with NULL constraint to a compressed hypertable (Issue #5151) ALTER TABLE records ADD COLUMN col2 BOOLEAN NULL; DROP table records CASCADE; -- TABLESPACES -- For tablepaces with compressed chunks the semantics are the following: -- - compressed chunks get put into the same tablespace as the -- uncompressed chunk on compression. -- - set tablespace on uncompressed hypertable cascades to compressed hypertable+chunks -- - set tablespace on all chunks is blocked (same as w/o compression) -- - move chunks on a uncompressed chunk errors -- - move chunks on compressed chunk works --In the future we will: -- - add tablespace option to compress_chunk function and policy (this will override the setting -- of the uncompressed chunk). This will allow changing tablespaces upon compression -- - Note: The current plan is to never listen to the setting on compressed hypertable. In fact, -- we will block setting tablespace on compressed hypertables SELECT count(*) as "COUNT_CHUNKS_UNCOMPRESSED" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' \gset SELECT count(*) as "COUNT_CHUNKS_COMPRESSED" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' \gset ALTER TABLE test1 SET TABLESPACE tablespace1; --all chunks + both the compressed and uncompressed hypertable moved to new tablespace SELECT count(*) = (:COUNT_CHUNKS_UNCOMPRESSED +:COUNT_CHUNKS_COMPRESSED + 2) FROM pg_tables WHERE tablespace = 'tablespace1'; ?column? ---------- t ALTER TABLE test1 SET TABLESPACE tablespace2; SELECT count(*) = (:COUNT_CHUNKS_UNCOMPRESSED +:COUNT_CHUNKS_COMPRESSED + 2) FROM pg_tables WHERE tablespace = 'tablespace2'; ?column? ---------- t SELECT comp_chunk.schema_name|| '.' || comp_chunk.table_name as "COMPRESSED_CHUNK_NAME", uncomp_chunk.schema_name|| '.' || uncomp_chunk.table_name as "UNCOMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk comp_chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (comp_chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) INNER JOIN _timescaledb_catalog.chunk uncomp_chunk ON (uncomp_chunk.compressed_chunk_id = comp_chunk.id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY comp_chunk.id LIMIT 1\gset -- ensure compression chunk cannot be moved directly SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; tablename ----------- \set ON_ERROR_STOP 0 ALTER TABLE :COMPRESSED_CHUNK_NAME SET TABLESPACE tablespace1; ERROR: changing tablespace of columnstore chunk is not supported \set ON_ERROR_STOP 1 SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; tablename ----------- -- ensure that both compressed and uncompressed chunks moved ALTER TABLE :UNCOMPRESSED_CHUNK_NAME SET TABLESPACE tablespace1; SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; tablename --------------------------- compress_hyper_2_28_chunk _hyper_1_1_chunk ALTER TABLE test1 SET TABLESPACE tablespace2; SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; tablename ----------- \set ON_ERROR_STOP 0 SELECT move_chunk(chunk=>:'COMPRESSED_CHUNK_NAME', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal."compress_hyper_2_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx"'); ERROR: cannot directly move internal columnstore data \set ON_ERROR_STOP 1 -- ensure that both compressed and uncompressed chunks moved SELECT move_chunk(chunk=>:'UNCOMPRESSED_CHUNK_NAME', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal."_hyper_1_1_chunk_test1_Time_idx"'); NOTICE: ignoring index parameter move_chunk ------------ SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; tablename --------------------------- _hyper_1_1_chunk compress_hyper_2_28_chunk -- the compressed chunk is in here now SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; count ------- 2 SELECT decompress_chunk(:'UNCOMPRESSED_CHUNK_NAME'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk --the compresse chunk was dropped by decompression SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; count ------- 1 SELECT move_chunk(chunk=>:'UNCOMPRESSED_CHUNK_NAME', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal."_hyper_1_1_chunk_test1_Time_idx"'); move_chunk ------------ --the uncompressed chunks has now been moved SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; count ------- 1 SELECT compress_chunk(:'UNCOMPRESSED_CHUNK_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk --the compressed chunk is now in the same tablespace as the uncompressed one SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; count ------- 2 -- -- DROP CHUNKS -- SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; count_chunks_uncompressed --------------------------- 27 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; count_chunks_compressed ------------------------- 27 SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset DROP TABLE :UNCOMPRESSED_CHUNK_NAME; --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; count_chunks_uncompressed --------------------------- 26 --make sure there are no orphaned _timescaledb_catalog.compression_chunk_size entries (should be 0) SELECT count(*) as orphaned_compression_chunk_size FROM _timescaledb_catalog.compression_chunk_size size LEFT JOIN _timescaledb_catalog.chunk chunk ON (chunk.id = size.chunk_id) WHERE chunk.id IS NULL; orphaned_compression_chunk_size --------------------------------- 0 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; count_chunks_compressed ------------------------- 26 SELECT drop_chunks('test1', older_than => '2018-03-10'::TIMESTAMPTZ); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; count_chunks_uncompressed --------------------------- 19 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; count_chunks_compressed ------------------------- 19 SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset SELECT chunk.schema_name|| '.' || chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset \set ON_ERROR_STOP 0 DROP TABLE :COMPRESSED_CHUNK_NAME; ERROR: dropping columnstore chunks not supported SELECT _timescaledb_functions.drop_chunk(:'COMPRESSED_CHUNK_NAME'); ERROR: dropping compressed chunks not supported \set ON_ERROR_STOP 1 SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME", comp_chunk.schema_name|| '.' || comp_chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.chunk comp_chunk ON (chunk.compressed_chunk_id = comp_chunk.id) INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset --create a dependent object on the compressed chunk to test cascade behaviour CREATE VIEW dependent_1 AS SELECT * FROM :COMPRESSED_CHUNK_NAME; \set ON_ERROR_STOP 0 --errors due to dependent objects DROP TABLE :UNCOMPRESSED_CHUNK_NAME; ERROR: cannot drop table _timescaledb_internal.compress_hyper_2_36_chunk because other objects depend on it \set ON_ERROR_STOP 1 DROP TABLE :UNCOMPRESSED_CHUNK_NAME CASCADE; NOTICE: drop cascades to view dependent_1 --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; count_chunks_uncompressed --------------------------- 18 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; count_chunks_compressed ------------------------- 18 SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME", comp_chunk.schema_name|| '.' || comp_chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.chunk comp_chunk ON (chunk.compressed_chunk_id = comp_chunk.id) INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset CREATE VIEW dependent_1 AS SELECT * FROM :COMPRESSED_CHUNK_NAME; \set ON_ERROR_STOP 0 \set VERBOSITY default --errors due to dependent objects SELECT drop_chunks('test1', older_than => '2018-03-28'::TIMESTAMPTZ); ERROR: cannot drop table _timescaledb_internal.compress_hyper_2_37_chunk because other objects depend on it DETAIL: view dependent_1 depends on table _timescaledb_internal.compress_hyper_2_37_chunk HINT: Use DROP ... to drop the dependent objects. \set VERBOSITY terse \set ON_ERROR_STOP 1 DROP VIEW dependent_1; SELECT drop_chunks('test1', older_than => '2018-03-28'::TIMESTAMPTZ); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_1_10_chunk _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk _timescaledb_internal._hyper_1_14_chunk _timescaledb_internal._hyper_1_15_chunk _timescaledb_internal._hyper_1_16_chunk _timescaledb_internal._hyper_1_17_chunk _timescaledb_internal._hyper_1_18_chunk _timescaledb_internal._hyper_1_19_chunk _timescaledb_internal._hyper_1_20_chunk _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_22_chunk _timescaledb_internal._hyper_1_23_chunk _timescaledb_internal._hyper_1_24_chunk _timescaledb_internal._hyper_1_25_chunk _timescaledb_internal._hyper_1_26_chunk --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; count_chunks_uncompressed --------------------------- 1 SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; count_chunks_compressed ------------------------- 1 --make sure there are no orphaned _timescaledb_catalog.compression_chunk_size entries (should be 0) SELECT count(*) as orphaned_compression_chunk_size FROM _timescaledb_catalog.compression_chunk_size size LEFT JOIN _timescaledb_catalog.chunk chunk ON (chunk.id = size.chunk_id) WHERE chunk.id IS NULL; orphaned_compression_chunk_size --------------------------------- 0 -- -- DROP HYPERTABLE -- SELECT comp_hyper.schema_name|| '.' || comp_hyper.table_name as "COMPRESSED_HYPER_NAME" FROM _timescaledb_catalog.hypertable comp_hyper INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY comp_hyper.id LIMIT 1 \gset \set ON_ERROR_STOP 0 DROP TABLE :COMPRESSED_HYPER_NAME; ERROR: dropping columnstore hypertables not supported \set ON_ERROR_STOP 1 BEGIN; SELECT hypertable.schema_name|| '.' || hypertable.table_name as "UNCOMPRESSED_HYPER_NAME" FROM _timescaledb_catalog.hypertable hypertable WHERE hypertable.table_name like 'test1' ORDER BY hypertable.id LIMIT 1 \gset --before the drop there are 2 hypertables: the compressed and uncompressed ones SELECT count(*) FROM _timescaledb_catalog.hypertable hypertable; count ------- 2 --add policy to make sure it's dropped later select add_compression_policy(:'UNCOMPRESSED_HYPER_NAME', interval '1 day'); add_compression_policy ------------------------ 1000 SELECT count(*) FROM _timescaledb_config.bgw_job WHERE id >= 1000; count ------- 1 DROP TABLE :UNCOMPRESSED_HYPER_NAME; --verify that there are no more hypertable remaining SELECT count(*) FROM _timescaledb_catalog.hypertable hypertable; count ------- 0 --verify that the policy is gone SELECT count(*) FROM _timescaledb_config.bgw_job WHERE id >= 1000; count ------- 0 ROLLBACK; --create a dependent object on the compressed hypertable to test cascade behaviour CREATE VIEW dependent_1 AS SELECT * FROM :COMPRESSED_HYPER_NAME; \set ON_ERROR_STOP 0 DROP TABLE :UNCOMPRESSED_HYPER_NAME; ERROR: cannot drop table _timescaledb_internal._compressed_hypertable_2 because other objects depend on it \set ON_ERROR_STOP 1 BEGIN; DROP TABLE :UNCOMPRESSED_HYPER_NAME CASCADE; NOTICE: drop cascades to view dependent_1 SELECT count(*) FROM _timescaledb_catalog.hypertable hypertable; count ------- 0 ROLLBACK; DROP VIEW dependent_1; --create a cont agg view on the ht as well then the drop should nuke everything CREATE MATERIALIZED VIEW test1_cont_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', "Time"), SUM(i) FROM test1 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test1_cont_view', NULL, '1 hour'::interval, '1 day'::interval); add_continuous_aggregate_policy --------------------------------- 1001 CALL refresh_continuous_aggregate('test1_cont_view', NULL, NULL); SELECT count(*) FROM test1_cont_view; count ------- 9 \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO 'America/Los_Angeles'; SELECT chunk.schema_name|| '.' || chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset ALTER TABLE test1 OWNER TO :ROLE_DEFAULT_PERM_USER_2; --make sure new owner is propagated down SELECT a.rolname from pg_class c INNER JOIN pg_authid a ON(c.relowner = a.oid) WHERE c.oid = 'test1'::regclass; rolname --------------------- default_perm_user_2 SELECT a.rolname from pg_class c INNER JOIN pg_authid a ON(c.relowner = a.oid) WHERE c.oid = :'COMPRESSED_HYPER_NAME'::regclass; rolname --------------------- default_perm_user_2 SELECT a.rolname from pg_class c INNER JOIN pg_authid a ON(c.relowner = a.oid) WHERE c.oid = :'COMPRESSED_CHUNK_NAME'::regclass; rolname --------------------- default_perm_user_2 -- -- turn off compression -- SELECT count(decompress_chunk(ch)) FROM show_chunks('test1') ch; count ------- 1 VACUUM FULL ANALYZE test1; select add_compression_policy('test1', interval '1 day'); add_compression_policy ------------------------ 1002 \set ON_ERROR_STOP 0 ALTER table test1 set (timescaledb.compress='f'); \set ON_ERROR_STOP 1 select remove_compression_policy('test1'); remove_compression_policy --------------------------- t ALTER table test1 set (timescaledb.compress='f'); --only one hypertable left SELECT count(*) = 1 FROM _timescaledb_catalog.hypertable hypertable; ?column? ---------- f SELECT compressed_hypertable_id IS NULL FROM _timescaledb_catalog.hypertable hypertable WHERE hypertable.table_name like 'test1' ; ?column? ---------- t --make sure there are no orphaned _timescaledb_catalog.compression_chunk_size entries (should be 0) SELECT count(*) as orphaned_compression_chunk_size FROM _timescaledb_catalog.compression_chunk_size size LEFT JOIN _timescaledb_catalog.chunk chunk ON (chunk.id = size.chunk_id) WHERE chunk.id IS NULL; orphaned_compression_chunk_size --------------------------------- 0 --can turn compression back on -- this will fail because current table owner does not have permission to create compressed hypertable -- in the current tablespace, as they do not own it \set ON_ERROR_STOP 0 ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = '"Time" DESC'); ERROR: permission denied for tablespace "tablespace2" by table owner "default_perm_user_2" -- now change the owner and repeat, should work ALTER TABLESPACE tablespace2 OWNER TO :ROLE_DEFAULT_PERM_USER_2; \set ON_ERROR_STOP 1 ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; count ------- 1 VACUUM FULL ANALYZE test1; DROP TABLE test1 CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_5_56_chunk DROP TABLESPACE tablespace1; -- Triggers are NOT fired for compress/decompress CREATE TABLE test1 ("Time" timestamptz, i integer); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test1 CREATE OR REPLACE FUNCTION test1_print_func() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN RAISE NOTICE ' raise notice test1_print_trigger called '; RETURN OLD; END; $BODY$; CREATE TRIGGER test1_trigger BEFORE INSERT OR UPDATE OR DELETE OR TRUNCATE ON test1 FOR EACH STATEMENT EXECUTE FUNCTION test1_print_func(); INSERT INTO test1 SELECT generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 1:00', '1 hour') , 1 ; NOTICE: raise notice test1_print_trigger called -- add a row trigger too -- CREATE TRIGGER test1_trigger2 BEFORE INSERT OR UPDATE OR DELETE ON test1 FOR EACH ROW EXECUTE FUNCTION test1_print_func(); INSERT INTO test1 SELECT '2018-03-02 1:05'::TIMESTAMPTZ, 2; NOTICE: raise notice test1_print_trigger called NOTICE: raise notice test1_print_trigger called ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; count ------- 2 SELECT count(decompress_chunk(ch)) FROM show_chunks('test1') ch; count ------- 2 DROP TABLE test1; -- test disabling compression on hypertables with caggs and dropped chunks -- github issue 2844 CREATE TABLE i2844 (created_at timestamptz NOT NULL,c1 float); SELECT create_hypertable('i2844', 'created_at', chunk_time_interval => '6 hour'::interval); create_hypertable --------------------- (10,public,i2844,t) INSERT INTO i2844 SELECT generate_series('2000-01-01'::timestamptz, '2000-01-02'::timestamptz,'1h'::interval); CREATE MATERIALIZED VIEW test_agg WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', created_at) AS bucket, AVG(c1) AS avg_c1 FROM i2844 GROUP BY bucket; NOTICE: refreshing continuous aggregate "test_agg" ALTER TABLE i2844 SET (timescaledb.compress, timescaledb.compress_orderby = 'created_at DESC'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='i2844'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+--------------+--------------+--------------------+------- i2844 | | | {created_at} | {t} | {t} | SELECT compress_chunk(show_chunks) AS compressed_chunk FROM show_chunks('i2844'); compressed_chunk ------------------------------------------ _timescaledb_internal._hyper_10_62_chunk _timescaledb_internal._hyper_10_63_chunk _timescaledb_internal._hyper_10_64_chunk _timescaledb_internal._hyper_10_65_chunk _timescaledb_internal._hyper_10_66_chunk SELECT drop_chunks('i2844', older_than => '2000-01-01 18:00'::timestamptz); drop_chunks ------------------------------------------ _timescaledb_internal._hyper_10_62_chunk _timescaledb_internal._hyper_10_63_chunk _timescaledb_internal._hyper_10_64_chunk SELECT decompress_chunk(show_chunks, if_compressed => TRUE) AS decompressed_chunks FROM show_chunks('i2844'); decompressed_chunks ------------------------------------------ _timescaledb_internal._hyper_10_65_chunk _timescaledb_internal._hyper_10_66_chunk ALTER TABLE i2844 SET (timescaledb.compress = FALSE); -- TEST compression alter schema tests \ir include/compression_alter.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir compression_utils.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors \ir ../../../../test/sql/include/test_utils.sql -- This file and its contents are licensed under the Apache License 2.0. -- Please see the included NOTICE for copyright information and -- LICENSE-APACHE for a copy of the license. CREATE OR REPLACE FUNCTION assert_true( val boolean ) RETURNS VOID LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN IF val IS NOT TRUE THEN RAISE 'Assert failed'; END IF; END $BODY$; CREATE OR REPLACE FUNCTION assert_equal( val1 anyelement, val2 anyelement ) RETURNS VOID LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ BEGIN IF (val1 = val2) IS NOT TRUE THEN RAISE 'Assert failed: % = %',val1,val2; END IF; END $BODY$; CREATE TABLE test1 ("Time" timestamptz, intcol integer, bntcol bigint, txtcol text); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test1 INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-05 1:00', '1 hour') t; INSERT INTO test1 SELECT '2018-03-04 2:00', 100, 200, 'hello' ; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'bntcol', timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; count ------- 4 -- TEST: ALTER TABLE add column tests -- ALTER TABLE test1 ADD COLUMN new_coli integer; ALTER TABLE test1 ADD COLUMN new_colv varchar(30); SELECT count(*) from test1 where new_coli is not null; count ------- 0 SELECT count(*) from test1 where new_colv is null; count ------- 74 --decompress 1 chunk and query again SELECT count(decompress_chunk(ch)) FROM show_chunks('test1') ch LIMIT 1; count ------- 4 SELECT count(*) from test1 where new_coli is not null; count ------- 0 SELECT count(*) from test1 where new_colv is null; count ------- 74 --compress all chunks and query --- --create new chunk and fill in data -- INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text , 100, '101t' FROM generate_series('2018-03-08 1:00'::TIMESTAMPTZ, '2018-03-09 1:00', '1 hour') t; SELECT count(*) from test1 where new_coli = 100; count ------- 25 SELECT count(*) from test1 where new_colv = '101t'; count ------- 25 SELECT count(compress_chunk(ch, true)) FROM show_chunks('test1') ch; count ------- 6 SELECT count(*) from test1 where new_coli = 100; count ------- 25 SELECT count(*) from test1 where new_colv = '101t'; count ------- 25 CREATE INDEX new_index ON test1(new_colv); -- TEST 2: ALTER TABLE rename column SELECT * from _timescaledb_catalog.hypertable WHERE table_name = 'test1'; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 13 | public | test1 | _timescaledb_internal | _hyper_13 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 1 | 14 | 0 SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='test1'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- test1 | | {bntcol} | {Time} | {t} | {t} | ALTER TABLE test1 RENAME new_coli TO coli; SELECT * from _timescaledb_catalog.hypertable WHERE table_name = 'test1'; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 13 | public | test1 | _timescaledb_internal | _hyper_13 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 1 | 14 | 0 SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='test1'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- test1 | | {bntcol} | {Time} | {t} | {t} | SELECT count(*) from test1 where coli = 100; count ------- 25 --rename segment by column name ALTER TABLE test1 RENAME bntcol TO bigintcol ; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='test1'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-------------+---------+--------------+--------------------+------- test1 | | {bigintcol} | {Time} | {t} | {t} | --query by segment by column name SELECT * from test1 WHERE bigintcol = 100; Time | intcol | bigintcol | txtcol | coli | new_colv ------+--------+-----------+--------+------+---------- SELECT * from test1 WHERE bigintcol = 200; Time | intcol | bigintcol | txtcol | coli | new_colv ------------------------------+--------+-----------+--------+------+---------- Sun Mar 04 02:00:00 2018 PST | 100 | 200 | hello | | -- add a new chunk and compress INSERT INTO test1 SELECT '2019-03-04 2:00', 99, 800, 'newchunk' ; SELECT count(compress_chunk(ch, true)) FROM show_chunks('test1') ch; psql:include/compression_alter.sql:68: NOTICE: chunk "_hyper_13_74_chunk" is already converted to columnstore psql:include/compression_alter.sql:68: NOTICE: chunk "_hyper_13_75_chunk" is already converted to columnstore psql:include/compression_alter.sql:68: NOTICE: chunk "_hyper_13_76_chunk" is already converted to columnstore psql:include/compression_alter.sql:68: NOTICE: chunk "_hyper_13_77_chunk" is already converted to columnstore psql:include/compression_alter.sql:68: NOTICE: chunk "_hyper_13_82_chunk" is already converted to columnstore psql:include/compression_alter.sql:68: NOTICE: chunk "_hyper_13_83_chunk" is already converted to columnstore count ------- 7 --check if all chunks have new column names --both counts should be equal SELECT count(*) FROM _timescaledb_catalog.chunk WHERE hypertable_id = ( SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'test1' ); count ------- 7 SELECT count(*) FROM pg_attribute att INNER JOIN _timescaledb_catalog.chunk ch ON att.attrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name = 'test1' WHERE attname = 'bigintcol'; count ------- 7 --check count on internal compression table too i.e. all the chunks have --the correct column name SELECT format('%I.%I', cht.schema_name, cht.table_name) AS "COMPRESSION_TBLNM" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.hypertable cht WHERE ht.table_name = 'test1' and cht.id = ht.compressed_hypertable_id \gset SELECT count(*) FROM pg_attribute att INNER JOIN _timescaledb_catalog.chunk ch ON att.attrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable ht ON ht.compressed_hypertable_id = ch.hypertable_id AND ht.table_name = 'test1' WHERE attname = 'bigintcol'; count ------- 7 -- check column name truncation with renames -- check if the name change is reflected for settings ALTER TABLE test1 RENAME bigintcol TO ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccabdeeeeeeccccccccccccc; psql:include/compression_alter.sql:97: NOTICE: identifier "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccabdeeeeeeccccccccccccc" will be truncated to "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca" SELECT * from _timescaledb_catalog.compression_settings WHERE relid = 'test1'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-------------------------------------------------------------------+---------+--------------+--------------------+------- test1 | | {cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca} | {Time} | {t} | {t} | SELECT * from timescaledb_information.compression_settings WHERE hypertable_name = 'test1' and attname like 'ccc%'; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+-----------------------------------------------------------------+------------------------+----------------------+-------------+-------------------- public | test1 | cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca | 1 | | | SELECT count(*) FROM pg_attribute att INNER JOIN _timescaledb_catalog.chunk ch ON att.attrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable ht ON ht.compressed_hypertable_id = ch.hypertable_id AND ht.table_name = 'test1' WHERE attname like 'ccc%a'; count ------- 7 ALTER TABLE test1 RENAME ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccabdeeeeeeccccccccccccc TO bigintcol; psql:include/compression_alter.sql:111: NOTICE: identifier "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccabdeeeeeeccccccccccccc" will be truncated to "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccca" SELECT * from timescaledb_information.compression_settings WHERE hypertable_name = 'test1' and attname = 'bigintcol' ; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+-----------+------------------------+----------------------+-------------+-------------------- public | test1 | bigintcol | 1 | | | -- test compression default handling CREATE TABLE test_defaults(time timestamptz NOT NULL, device_id int); SELECT create_hypertable('test_defaults','time'); create_hypertable ----------------------------- (15,public,test_defaults,t) ALTER TABLE test_defaults SET (timescaledb.compress,timescaledb.compress_segmentby='device_id'); -- create 2 chunks INSERT INTO test_defaults SELECT '2000-01-01', 1; INSERT INTO test_defaults SELECT '2001-01-01', 1; -- compress first chunk SELECT compress_chunk(show_chunks) AS compressed_chunk FROM show_chunks('test_defaults') ORDER BY show_chunks::text LIMIT 1; compressed_chunk ------------------------------------------ _timescaledb_internal._hyper_15_92_chunk SELECT * FROM test_defaults ORDER BY 1; time | device_id ------------------------------+----------- Sat Jan 01 00:00:00 2000 PST | 1 Mon Jan 01 00:00:00 2001 PST | 1 ALTER TABLE test_defaults ADD COLUMN c1 int; ALTER TABLE test_defaults ADD COLUMN c2 int NOT NULL DEFAULT 42; SELECT * FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 ------------------------------+-----------+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 Mon Jan 01 00:00:00 2001 PST | 1 | | 42 -- try insert into compressed and recompress INSERT INTO test_defaults SELECT '2000-01-01', 2; SELECT * FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 ------------------------------+-----------+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 Sat Jan 01 00:00:00 2000 PST | 2 | | 42 Mon Jan 01 00:00:00 2001 PST | 1 | | 42 SELECT compress_chunk(ch) FROM show_chunks('test_defaults') ch LIMIT 1; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_92_chunk SELECT * FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 ------------------------------+-----------+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 Sat Jan 01 00:00:00 2000 PST | 2 | | 42 Mon Jan 01 00:00:00 2001 PST | 1 | | 42 -- timescale/timescaledb#5412 ALTER TABLE test_defaults ADD COLUMN c3 int NOT NULL DEFAULT 43; SELECT *,assert_equal(c3,43) FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 | c3 | assert_equal ------------------------------+-----------+----+----+----+-------------- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 | 43 | Sat Jan 01 00:00:00 2000 PST | 2 | | 42 | 43 | Mon Jan 01 00:00:00 2001 PST | 1 | | 42 | 43 | select decompress_chunk(show_chunks('test_defaults'),true); psql:include/compression_alter.sql:142: NOTICE: chunk "_hyper_15_93_chunk" is not converted to columnstore decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_92_chunk SELECT *,assert_equal(c3,43) FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 | c3 | assert_equal ------------------------------+-----------+----+----+----+-------------- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 | 43 | Sat Jan 01 00:00:00 2000 PST | 2 | | 42 | 43 | Mon Jan 01 00:00:00 2001 PST | 1 | | 42 | 43 | select compress_chunk(show_chunks('test_defaults')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_92_chunk _timescaledb_internal._hyper_15_93_chunk SELECT *,assert_equal(c3,43) FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 | c3 | assert_equal ------------------------------+-----------+----+----+----+-------------- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 | 43 | Sat Jan 01 00:00:00 2000 PST | 2 | | 42 | 43 | Mon Jan 01 00:00:00 2001 PST | 1 | | 42 | 43 | -- test dropping columns from compressed CREATE TABLE test_drop(f1 text, f2 text, f3 text, time timestamptz, device int, o1 text, o2 text); SELECT create_hypertable('test_drop','time'); create_hypertable ------------------------- (17,public,test_drop,t) ALTER TABLE test_drop SET (timescaledb.compress,timescaledb.compress_segmentby='device',timescaledb.compress_orderby='o1,o2'); -- dropping segmentby or orderby columns will fail \set ON_ERROR_STOP 0 ALTER TABLE test_drop DROP COLUMN time; psql:include/compression_alter.sql:154: ERROR: cannot drop column named in partition key ALTER TABLE test_drop DROP COLUMN o1; psql:include/compression_alter.sql:155: ERROR: cannot drop orderby or segmentby column from a hypertable with columnstore enabled ALTER TABLE test_drop DROP COLUMN o2; psql:include/compression_alter.sql:156: ERROR: cannot drop orderby or segmentby column from a hypertable with columnstore enabled ALTER TABLE test_drop DROP COLUMN device; psql:include/compression_alter.sql:157: ERROR: cannot drop orderby or segmentby column from a hypertable with columnstore enabled \set ON_ERROR_STOP 1 -- switch to WARNING only to suppress compress_chunk NOTICEs SET client_min_messages TO WARNING; -- create some chunks each with different physical layout ALTER TABLE test_drop DROP COLUMN f1; INSERT INTO test_drop SELECT NULL,NULL,'2000-01-01',1,'o1','o2'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; count ------- 1 ALTER TABLE test_drop DROP COLUMN f2; -- test non-existant column \set ON_ERROR_STOP 0 ALTER TABLE test_drop DROP COLUMN f10; psql:include/compression_alter.sql:171: ERROR: column "f10" of relation "test_drop" does not exist \set ON_ERROR_STOP 1 ALTER TABLE test_drop DROP COLUMN IF EXISTS f10; INSERT INTO test_drop SELECT NULL,'2001-01-01',2,'o1','o2'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; count ------- 2 ALTER TABLE test_drop DROP COLUMN f3; INSERT INTO test_drop SELECT '2003-01-01',3,'o1','o2'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; count ------- 3 ALTER TABLE test_drop ADD COLUMN c1 TEXT; ALTER TABLE test_drop ADD COLUMN c2 TEXT; INSERT INTO test_drop SELECT '2004-01-01',4,'o1','o2','c1','c2-4'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; count ------- 4 ALTER TABLE test_drop DROP COLUMN c1; INSERT INTO test_drop SELECT '2005-01-01',5,'o1','o2','c2-5'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; count ------- 5 RESET client_min_messages; SELECT * FROM test_drop ORDER BY 1; time | device | o1 | o2 | c2 ------------------------------+--------+----+----+------ Sat Jan 01 00:00:00 2000 PST | 1 | o1 | o2 | Mon Jan 01 00:00:00 2001 PST | 2 | o1 | o2 | Wed Jan 01 00:00:00 2003 PST | 3 | o1 | o2 | Thu Jan 01 00:00:00 2004 PST | 4 | o1 | o2 | c2-4 Sat Jan 01 00:00:00 2005 PST | 5 | o1 | o2 | c2-5 -- check dropped columns got removed from catalog -- only segmentby and orderby are in catalog which we dont support removing -- atm, so nothing to see here SELECT * FROM _timescaledb_catalog.hypertable WHERE table_name = 'test_drop'; id | schema_name | table_name | associated_schema_name | associated_table_prefix | num_dimensions | chunk_sizing_func_schema | chunk_sizing_func_name | chunk_target_size | compression_state | compressed_hypertable_id | status ----+-------------+------------+------------------------+-------------------------+----------------+--------------------------+--------------------------+-------------------+-------------------+--------------------------+-------- 17 | public | test_drop | _timescaledb_internal | _hyper_17 | 1 | _timescaledb_functions | calculate_chunk_interval | 0 | 1 | 18 | 0 SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'test_drop'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -----------+----------------+-----------+--------------+--------------+--------------------+------- test_drop | | {device} | {o1,o2,time} | {f,f,t} | {f,f,t} | --TEST tablespaces for compressed chunks with attach_tablespace interface -- CREATE TABLE test2 (timec timestamptz, i integer, t integer); SELECT table_name from create_hypertable('test2', 'timec', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test2 SELECT attach_tablespace('tablespace2', 'test2'); attach_tablespace ------------------- INSERT INTO test2 SELECT t, gen_rand_minstd(), 22 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 13:00', '1 hour') t; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = 'i', timescaledb.compress_orderby = 'timec'); -- the toast table and its index will have a different name depending on -- the order the tests run, so anonymize it SELECT regexp_replace(relname, 'pg_toast_[0-9]+', 'pg_toast_XXX') FROM pg_class WHERE reltablespace in ( SELECT oid from pg_tablespace WHERE spcname = 'tablespace2') ORDER BY 1; regexp_replace ------------------------------------- _compressed_hypertable_20 _hyper_19_107_chunk _hyper_19_107_chunk_test2_timec_idx test2 -- test compress_chunk() with utility statement (SELECT ... INTO) SELECT compress_chunk(ch) INTO compressed_chunks FROM show_chunks('test2') ch; SELECT decompress_chunk(ch) INTO decompressed_chunks FROM show_chunks('test2') ch; -- compress again SELECT compress_chunk(ch) FROM show_chunks('test2') ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_19_107_chunk -- the chunk, compressed chunk + index + toast tables are in tablespace2 now . -- toast table names differ across runs. So we use count to verify the results -- instead of printing the table/index names SELECT count(*) FROM ( SELECT relname FROM pg_class WHERE reltablespace in ( SELECT oid from pg_tablespace WHERE spcname = 'tablespace2'))q; count ------- 8 DROP TABLE test2 CASCADE; DROP TABLESPACE tablespace2; -- Create a table with a compressed table and then delete the -- compressed table and see that the drop of the hypertable does not -- generate an error. This scenario can be triggered if an extension -- is created with compressed hypertables since the tables are dropped -- as part of the drop of the extension. CREATE TABLE issue4140("time" timestamptz NOT NULL, device_id int); SELECT create_hypertable('issue4140', 'time'); create_hypertable ------------------------- (21,public,issue4140,t) ALTER TABLE issue4140 SET(timescaledb.compress); SELECT format('%I.%I', schema_name, table_name)::regclass AS ctable FROM _timescaledb_catalog.hypertable WHERE id = (SELECT compressed_hypertable_id FROM _timescaledb_catalog.hypertable WHERE table_name = 'issue4140') \gset SELECT timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t DROP TABLE :ctable; SELECT timescaledb_post_restore(); timescaledb_post_restore -------------------------- t DROP TABLE issue4140; -- github issue 5104 CREATE TABLE metric( time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL); SELECT create_hypertable('metric', 'time', chunk_time_interval => interval '1 h', create_default_indexes => false); create_hypertable ---------------------- (23,public,metric,t) -- enable compression ALTER TABLE metric set(timescaledb.compress, timescaledb.compress_segmentby = 'series_id, value', timescaledb.compress_orderby = 'time' ); SELECT comp_hypertable.schema_name AS "COMP_SCHEMA_NAME", comp_hypertable.table_name AS "COMP_TABLE_NAME" FROM _timescaledb_catalog.hypertable uc_hypertable INNER JOIN _timescaledb_catalog.hypertable comp_hypertable ON (comp_hypertable.id = uc_hypertable.compressed_hypertable_id) WHERE uc_hypertable.table_name like 'metric' \gset -- get definition of compressed hypertable and notice the index \d :COMP_SCHEMA_NAME.:COMP_TABLE_NAME Table "_timescaledb_internal._compressed_hypertable_24" Column | Type | Collation | Nullable | Default --------+------+-----------+----------+--------- -- #5290 Compression can't be enabled on caggs CREATE TABLE "tEst2" ( "Id" uuid NOT NULL, "Time" timestamp with time zone NOT NULL, CONSTRAINT "test2_pkey" PRIMARY KEY ("Id", "Time") ); SELECT create_hypertable( '"tEst2"', 'Time', chunk_time_interval => INTERVAL '1 day' ); create_hypertable --------------------- (25,public,tEst2,t) alter table "tEst2" set (timescaledb.compress=true, timescaledb.compress_segmentby='"Id"'); CREATE MATERIALIZED VIEW "tEst2_mv" WITH (timescaledb.continuous) AS SELECT "Id" as "Idd", time_bucket(INTERVAL '1 day', "Time") AS "bUcket" FROM public."tEst2" GROUP BY "Idd", "bUcket"; NOTICE: continuous aggregate "tEst2_mv" is already up-to-date ALTER MATERIALIZED VIEW "tEst2_mv" SET (timescaledb.compress = true); NOTICE: defaulting compress_segmentby to "Idd" NOTICE: defaulting compress_orderby to "bUcket" -- #5161 segmentby param CREATE MATERIALIZED VIEW test1_cont_view2 WITH (timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('1 hour', "Time") as t, SUM(intcol) as sum,txtcol as "iDeA" FROM test1 GROUP BY 1,txtcol WITH NO DATA; \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true, timescaledb.compress_segmentby = 'invalid_column' ); NOTICE: defaulting compress_orderby to t ERROR: column "invalid_column" does not exist \set ON_ERROR_STOP 1 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true ); NOTICE: defaulting compress_segmentby to "iDeA" NOTICE: defaulting compress_orderby to t ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true, timescaledb.compress_segmentby = '"iDeA"' ); NOTICE: defaulting compress_orderby to t \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true, timescaledb.compress_orderby = '"iDeA"' ); NOTICE: defaulting compress_segmentby to "iDeA" ERROR: cannot use column "iDeA" for both ordering and segmenting \set ON_ERROR_STOP 1 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = false ); DROP TABLE metric CASCADE; -- inserting into compressed chunks with different physical layouts CREATE TABLE compression_insert(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON compression_insert(time); CREATE INDEX ON compression_insert(device_id,time); SELECT create_hypertable('compression_insert','time',create_default_indexes:=false); create_hypertable ---------------------------------- (31,public,compression_insert,t) ALTER TABLE compression_insert SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); -- test without altering physical layout -- this is a baseline test to compare results with -- next series of tests which should yield identical results -- while changing the physical layouts of chunks INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-03 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(ch, true) AS "CHUNK_NAME" FROM show_chunks('compression_insert') ch ORDER BY ch DESC \gset INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-04 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-01 0:00:00+0' AND time <= '2000-01-05 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | VACUUM ANALYZE compression_insert; -- force index scans to check index mapping -- this verifies that we are actually using compressed chunk index scans -- previously we could not use indexes on uncompressed chunks due to a bug: -- https://github.com/timescale/timescaledb/issues/5432 -- -- this check basically makes sure that the indexes are built properly -- and there are no issues in attribute mappings while building them SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate Group Key: compression_insert.device_id -> Sort Sort Key: compression_insert.device_id -> Append -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_110_chunk -> Index Scan using compress_hyper_32_111_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_111_chunk -> Partial GroupAggregate Group Key: _hyper_31_110_chunk.device_id -> Index Only Scan using _hyper_31_110_chunk_compression_insert_device_id_time_idx on _hyper_31_110_chunk SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 3596 2 | 3596 3 | 3596 4 | 3596 5 | 3596 SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_31_110_chunk SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-01 0:00:00+0' AND time <= '2000-01-05 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 3596 2 | 3596 3 | 3596 4 | 3596 5 | 3596 SET enable_seqscan = default; -- 1. drop column after first insert into chunk, before compressing INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-07 0:00:00+0'::timestamptz,'2000-01-09 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE compression_insert DROP COLUMN filler_1; SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-10 0:00:00+0'::timestamptz,'2000-01-11 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-07 0:00:00+0' AND time <= '2000-01-11 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate Group Key: compression_insert.device_id -> Merge Append Sort Key: compression_insert.device_id -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_110_chunk -> Index Scan using compress_hyper_32_111_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_111_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_112_chunk -> Index Scan using compress_hyper_32_113_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_113_chunk -> Partial GroupAggregate Group Key: _hyper_31_112_chunk.device_id -> Index Only Scan using _hyper_31_112_chunk_compression_insert_device_id_time_idx on _hyper_31_112_chunk SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 7192 2 | 7192 3 | 7192 4 | 7192 5 | 7192 SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_31_112_chunk SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-07 0:00:00+0' AND time <= '2000-01-11 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 7192 2 | 7192 3 | 7192 4 | 7192 5 | 7192 SET enable_seqscan = default; -- 2. drop column after compressing chunk INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-15 0:00:00+0'::timestamptz,'2000-01-17 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset ALTER TABLE compression_insert DROP COLUMN filler_2; INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-18 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-15 0:00:00+0' AND time <= '2000-01-19 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate Group Key: compression_insert.device_id -> Merge Append Sort Key: compression_insert.device_id -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_110_chunk -> Index Scan using compress_hyper_32_111_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_111_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_112_chunk -> Index Scan using compress_hyper_32_113_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_113_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_114_chunk -> Index Scan using compress_hyper_32_115_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_115_chunk -> Partial GroupAggregate Group Key: _hyper_31_114_chunk.device_id -> Index Only Scan using _hyper_31_114_chunk_compression_insert_device_id_time_idx on _hyper_31_114_chunk SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 10788 2 | 10788 3 | 10788 4 | 10788 5 | 10788 SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_31_114_chunk SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-15 0:00:00+0' AND time <= '2000-01-19 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 10788 2 | 10788 3 | 10788 4 | 10788 5 | 10788 SET enable_seqscan = default; -- 3. add new column after first insert into chunk, before compressing INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-22 0:00:00+0'::timestamptz,'2000-01-24 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE compression_insert ADD COLUMN filler_4 int; SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-25 0:00:00+0'::timestamptz,'2000-01-26 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-22 0:00:00+0' AND time <= '2000-01-26 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate Group Key: compression_insert.device_id -> Merge Append Sort Key: compression_insert.device_id -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_110_chunk -> Index Scan using compress_hyper_32_111_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_111_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_112_chunk -> Index Scan using compress_hyper_32_113_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_113_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_114_chunk -> Index Scan using compress_hyper_32_115_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_115_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_116_chunk -> Index Scan using compress_hyper_32_117_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_117_chunk -> Partial GroupAggregate Group Key: _hyper_31_116_chunk.device_id -> Index Only Scan using _hyper_31_116_chunk_compression_insert_device_id_time_idx on _hyper_31_116_chunk SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 14384 2 | 14384 3 | 14384 4 | 14384 5 | 14384 SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_31_116_chunk SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-22 0:00:00+0' AND time <= '2000-01-26 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 14384 2 | 14384 3 | 14384 4 | 14384 5 | 14384 SET enable_seqscan = default; -- 4. add new column after compressing chunk INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-28 0:00:00+0'::timestamptz,'2000-01-30 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset ALTER TABLE compression_insert ADD COLUMN filler_5 int; INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-31 0:00:00+0'::timestamptz,'2000-02-01 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-28 0:00:00+0' AND time <= '2000-02-01 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate Group Key: compression_insert.device_id -> Merge Append Sort Key: compression_insert.device_id -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_110_chunk -> Index Scan using compress_hyper_32_111_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_111_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_112_chunk -> Index Scan using compress_hyper_32_113_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_113_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_114_chunk -> Index Scan using compress_hyper_32_115_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_115_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_116_chunk -> Index Scan using compress_hyper_32_117_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_117_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_31_118_chunk -> Index Scan using compress_hyper_32_119_chunk_device_id__ts_meta_min_1__ts_me_idx on compress_hyper_32_119_chunk -> Partial GroupAggregate Group Key: _hyper_31_118_chunk.device_id -> Index Only Scan using _hyper_31_118_chunk_compression_insert_device_id_time_idx on _hyper_31_118_chunk SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 17980 2 | 17980 3 | 17980 4 | 17980 5 | 17980 SELECT compress_chunk(:'CHUNK_NAME'::regclass); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_31_118_chunk SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-28 0:00:00+0' AND time <= '2000-02-01 23:55:00+0'; count | sum | sum | sum | sum -------+-------+-------+-------+----- 17980 | 71920 | 89900 | 62930 | SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; device_id | count -----------+------- 1 | 17980 2 | 17980 3 | 17980 4 | 17980 5 | 17980 SET enable_seqscan = default; DROP TABLE compression_insert; -- check Chunk Append plans for partially compressed chunks -- F: fully compressed, P : partially compressed, U: uncompressed CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); create_hypertable ----------------------------- (33,public,test_partials,t) INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), ('2020-01-01 00:05'::timestamptz, 3, 1), ('2020-01-01 00:06'::timestamptz, 3, 2), ('2020-01-01 00:07'::timestamptz, 3, 3), ('2020-01-01 00:08'::timestamptz, 4, 1), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), ('2021-01-01 00:05'::timestamptz, 3, 1), ('2021-01-01 00:06'::timestamptz, 3, 2), ('2021-01-01 00:07'::timestamptz, 3, 3), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2), ('2022-01-01 00:05'::timestamptz, 3, 1); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress, timescaledb.compress_segmentby = 'a', timescaledb.compress_orderby = 'time desc'); SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_33_120_chunk _timescaledb_internal._hyper_33_121_chunk _timescaledb_internal._hyper_33_122_chunk VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 7 5 3 -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Sort Sort Key: _hyper_33_120_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_33_120_chunk -> Seq Scan on compress_hyper_34_123_chunk -> Custom Scan (ColumnarScan) on _hyper_33_121_chunk -> Sort Sort Key: compress_hyper_34_124_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_34_124_chunk -> Custom Scan (ColumnarScan) on _hyper_33_122_chunk -> Sort Sort Key: compress_hyper_34_125_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_34_125_chunk -- test P, F, F INSERT INTO test_partials VALUES ('2020-01-01 00:03', 1, 2); vacuum analyze test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 8 5 3 EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Sort Sort Key: test_partials."time" -> Append -> Custom Scan (ColumnarScan) on _hyper_33_120_chunk -> Seq Scan on compress_hyper_34_123_chunk -> Seq Scan on _hyper_33_120_chunk -> Custom Scan (ColumnarScan) on _hyper_33_121_chunk -> Seq Scan on compress_hyper_34_124_chunk -> Custom Scan (ColumnarScan) on _hyper_33_122_chunk -> Seq Scan on compress_hyper_34_125_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:03:00 2020 PST | 1 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Wed Jan 01 00:05:00 2020 PST | 3 | 1 Wed Jan 01 00:06:00 2020 PST | 3 | 2 Wed Jan 01 00:07:00 2020 PST | 3 | 3 Wed Jan 01 00:08:00 2020 PST | 4 | 1 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Fri Jan 01 00:05:00 2021 PST | 3 | 1 Fri Jan 01 00:06:00 2021 PST | 3 | 2 Fri Jan 01 00:07:00 2021 PST | 3 | 3 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 Sat Jan 01 00:05:00 2022 PST | 3 | 1 -- make second chunk partially compressed -- P, P, F INSERT INTO test_partials VALUES ('2021-01-01 00:03', 1, 2); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 8 6 3 EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Sort Sort Key: test_partials."time" -> Append -> Custom Scan (ColumnarScan) on _hyper_33_120_chunk -> Seq Scan on compress_hyper_34_123_chunk -> Seq Scan on _hyper_33_120_chunk -> Custom Scan (ColumnarScan) on _hyper_33_121_chunk -> Seq Scan on compress_hyper_34_124_chunk -> Seq Scan on _hyper_33_121_chunk -> Custom Scan (ColumnarScan) on _hyper_33_122_chunk -> Seq Scan on compress_hyper_34_125_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:03:00 2020 PST | 1 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Wed Jan 01 00:05:00 2020 PST | 3 | 1 Wed Jan 01 00:06:00 2020 PST | 3 | 2 Wed Jan 01 00:07:00 2020 PST | 3 | 3 Wed Jan 01 00:08:00 2020 PST | 4 | 1 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:03:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Fri Jan 01 00:05:00 2021 PST | 3 | 1 Fri Jan 01 00:06:00 2021 PST | 3 | 2 Fri Jan 01 00:07:00 2021 PST | 3 | 3 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 Sat Jan 01 00:05:00 2022 PST | 3 | 1 -- third chunk partially compressed and add new chunk -- P, P, P, U INSERT INTO test_partials VALUES ('2022-01-01 00:03', 1, 2); INSERT INTO test_partials VALUES ('2023-01-01 00:03', 1, 2); INSERT INTO test_partials VALUES ('2023-01-01 00:05', 3, 1); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 8 6 4 2 EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Sort Sort Key: test_partials."time" -> Append -> Custom Scan (ColumnarScan) on _hyper_33_120_chunk -> Seq Scan on compress_hyper_34_123_chunk -> Seq Scan on _hyper_33_120_chunk -> Custom Scan (ColumnarScan) on _hyper_33_121_chunk -> Seq Scan on compress_hyper_34_124_chunk -> Seq Scan on _hyper_33_121_chunk -> Custom Scan (ColumnarScan) on _hyper_33_122_chunk -> Seq Scan on compress_hyper_34_125_chunk -> Seq Scan on _hyper_33_122_chunk -> Seq Scan on _hyper_33_126_chunk -- F, F, P, U -- recompress all chunks DO $$ DECLARE chunk regclass; BEGIN FOR chunk IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk WHERE status = 9 and compressed_chunk_id IS NOT NULL AND NOT dropped ORDER BY id LOOP EXECUTE format('select decompress_chunk(''%s'');', chunk::text); EXECUTE format('select compress_chunk(''%s'');', chunk::text); END LOOP; END $$; INSERT INTO test_partials VALUES ('2022-01-01 00:02', 1, 2); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 8 6 5 2 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Sort Sort Key: test_partials."time" -> Append -> Custom Scan (ColumnarScan) on _hyper_33_120_chunk -> Seq Scan on compress_hyper_34_127_chunk -> Custom Scan (ColumnarScan) on _hyper_33_121_chunk -> Seq Scan on compress_hyper_34_128_chunk -> Custom Scan (ColumnarScan) on _hyper_33_122_chunk -> Seq Scan on compress_hyper_34_129_chunk -> Seq Scan on _hyper_33_122_chunk -> Seq Scan on _hyper_33_126_chunk -- F, F, P, F, F INSERT INTO test_partials VALUES ('2024-01-01 00:02', 1, 2); SELECT compress_chunk(c) FROM show_chunks('test_partials', newer_than => '2022-01-01') c; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_33_126_chunk _timescaledb_internal._hyper_33_130_chunk VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 8 6 5 2 1 EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Sort Sort Key: _hyper_33_120_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_33_120_chunk -> Seq Scan on compress_hyper_34_127_chunk -> Custom Scan (ColumnarScan) on _hyper_33_121_chunk -> Sort Sort Key: compress_hyper_34_128_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_34_128_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_33_122_chunk -> Sort Sort Key: compress_hyper_34_129_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_34_129_chunk -> Index Scan Backward using _hyper_33_122_chunk_test_partials_time_idx on _hyper_33_122_chunk -> Custom Scan (ColumnarScan) on _hyper_33_126_chunk -> Sort Sort Key: compress_hyper_34_131_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_34_131_chunk -> Custom Scan (ColumnarScan) on _hyper_33_130_chunk -> Sort Sort Key: compress_hyper_34_132_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_34_132_chunk -- verify result correctness SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:03:00 2020 PST | 1 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Wed Jan 01 00:05:00 2020 PST | 3 | 1 Wed Jan 01 00:06:00 2020 PST | 3 | 2 Wed Jan 01 00:07:00 2020 PST | 3 | 3 Wed Jan 01 00:08:00 2020 PST | 4 | 1 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:03:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Fri Jan 01 00:05:00 2021 PST | 3 | 1 Fri Jan 01 00:06:00 2021 PST | 3 | 2 Fri Jan 01 00:07:00 2021 PST | 3 | 3 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:02:00 2022 PST | 1 | 2 Sat Jan 01 00:03:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 Sat Jan 01 00:05:00 2022 PST | 3 | 1 Sun Jan 01 00:03:00 2023 PST | 1 | 2 Sun Jan 01 00:05:00 2023 PST | 3 | 1 Mon Jan 01 00:02:00 2024 PST | 1 | 2 -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; count ------- 8 6 5 2 1 -- add test for space partioning with partial chunks CREATE TABLE space_part (time timestamptz, a int, b int, c int); SELECT create_hypertable('space_part', 'time', chunk_time_interval => INTERVAL '1 day'); create_hypertable -------------------------- (35,public,space_part,t) INSERT INTO space_part VALUES -- chunk1 ('2020-01-01 00:00', 1, 1, 1), ('2020-01-01 00:00', 2, 1, 1), ('2020-01-01 00:03', 1, 1, 1), ('2020-01-01 00:03', 2, 1, 1); INSERT INTO space_part values -- chunk2 ('2021-01-01 00:00', 1, 1, 1), ('2021-01-01 00:00', 2, 1, 1), ('2021-01-01 00:03', 1, 1, 1), ('2021-01-01 00:03', 2, 1, 1); -- compress them ALTER TABLE space_part SET (timescaledb.compress, timescaledb.orderby='"time" desc'); SELECT compress_chunk(show_chunks('space_part')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_35_133_chunk _timescaledb_internal._hyper_35_134_chunk -- make first chunk partial INSERT INTO space_part VALUES -- chunk1 ('2020-01-01 00:01', 1, 1, 1), ('2020-01-01 00:01', 2, 1, 1); VACUUM ANALYZE space_part; -------- now enable the space partitioning, this will take effect for chunks created subsequently SELECT add_dimension('space_part', 'a', number_partitions => 5); add_dimension ---------------------------- (19,public,space_part,a,t) -- plan is still the same EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space_part Order: space_part."time" -> Merge Append Sort Key: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_133_chunk -> Sort Sort Key: compress_hyper_36_135_chunk._ts_meta_min_1, compress_hyper_36_135_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_135_chunk -> Index Scan Backward using _hyper_35_133_chunk_space_part_time_idx on _hyper_35_133_chunk -> Custom Scan (ColumnarScan) on _hyper_35_134_chunk -> Sort Sort Key: compress_hyper_36_136_chunk._ts_meta_min_1, compress_hyper_36_136_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_136_chunk -- now add more chunks that do adhere to the new space partitioning -- chunks 3,4 INSERT INTO space_part VALUES ('2022-01-01 00:00', 1, 1, 1), ('2022-01-01 00:00', 2, 1, 1), ('2022-01-01 00:03', 1, 1, 1), ('2022-01-01 00:03', 2, 1, 1); VACUUM ANALYZE space_part; -- plan still ok EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space_part Order: space_part."time" -> Merge Append Sort Key: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_133_chunk -> Sort Sort Key: compress_hyper_36_135_chunk._ts_meta_min_1, compress_hyper_36_135_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_135_chunk -> Index Scan Backward using _hyper_35_133_chunk_space_part_time_idx on _hyper_35_133_chunk -> Custom Scan (ColumnarScan) on _hyper_35_134_chunk -> Sort Sort Key: compress_hyper_36_136_chunk._ts_meta_min_1, compress_hyper_36_136_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_136_chunk -> Merge Append Sort Key: space_part."time" -> Index Scan Backward using _hyper_35_137_chunk_space_part_time_idx on _hyper_35_137_chunk -> Index Scan Backward using _hyper_35_138_chunk_space_part_time_idx on _hyper_35_138_chunk -- compress them SELECT compress_chunk(c, if_not_compressed=>true) FROM show_chunks('space_part') c; NOTICE: chunk "_hyper_35_134_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_35_133_chunk _timescaledb_internal._hyper_35_134_chunk _timescaledb_internal._hyper_35_137_chunk _timescaledb_internal._hyper_35_138_chunk VACUUM ANALYZE space_part; -- plan still ok EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space_part Order: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_133_chunk -> Sort Sort Key: compress_hyper_36_135_chunk._ts_meta_min_1, compress_hyper_36_135_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_135_chunk -> Custom Scan (ColumnarScan) on _hyper_35_134_chunk -> Sort Sort Key: compress_hyper_36_136_chunk._ts_meta_min_1, compress_hyper_36_136_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_136_chunk -> Merge Append Sort Key: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_137_chunk -> Sort Sort Key: compress_hyper_36_139_chunk._ts_meta_min_1, compress_hyper_36_139_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_139_chunk -> Custom Scan (ColumnarScan) on _hyper_35_138_chunk -> Sort Sort Key: compress_hyper_36_140_chunk._ts_meta_min_1, compress_hyper_36_140_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_140_chunk -- make second one of them partial insert into space_part values ('2022-01-01 00:02', 2, 1, 1), ('2022-01-01 00:02', 2, 1, 1); VACUUM ANALYZE space_part; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space_part Order: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_133_chunk -> Sort Sort Key: compress_hyper_36_135_chunk._ts_meta_min_1, compress_hyper_36_135_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_135_chunk -> Custom Scan (ColumnarScan) on _hyper_35_134_chunk -> Sort Sort Key: compress_hyper_36_136_chunk._ts_meta_min_1, compress_hyper_36_136_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_136_chunk -> Merge Append Sort Key: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_137_chunk -> Sort Sort Key: compress_hyper_36_139_chunk._ts_meta_min_1, compress_hyper_36_139_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_139_chunk -> Custom Scan (ColumnarScan) on _hyper_35_138_chunk -> Sort Sort Key: compress_hyper_36_140_chunk._ts_meta_min_1, compress_hyper_36_140_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_140_chunk -> Index Scan Backward using _hyper_35_138_chunk_space_part_time_idx on _hyper_35_138_chunk -- make other one partial too INSERT INTO space_part VALUES ('2022-01-01 00:02', 1, 1, 1); VACUUM ANALYZE space_part; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on space_part Order: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_133_chunk -> Sort Sort Key: compress_hyper_36_135_chunk._ts_meta_min_1, compress_hyper_36_135_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_135_chunk -> Custom Scan (ColumnarScan) on _hyper_35_134_chunk -> Sort Sort Key: compress_hyper_36_136_chunk._ts_meta_min_1, compress_hyper_36_136_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_136_chunk -> Merge Append Sort Key: space_part."time" -> Custom Scan (ColumnarScan) on _hyper_35_137_chunk -> Sort Sort Key: compress_hyper_36_139_chunk._ts_meta_min_1, compress_hyper_36_139_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_139_chunk -> Index Scan Backward using _hyper_35_137_chunk_space_part_time_idx on _hyper_35_137_chunk -> Custom Scan (ColumnarScan) on _hyper_35_138_chunk -> Sort Sort Key: compress_hyper_36_140_chunk._ts_meta_min_1, compress_hyper_36_140_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_140_chunk -> Index Scan Backward using _hyper_35_138_chunk_space_part_time_idx on _hyper_35_138_chunk -- test creation of unique expression index does not interfere with enabling compression -- github issue 6205 create table mytab (col1 varchar(100) not null, col2 integer not null, value double precision not null default 0, arrival_ts timestamptz not null, departure_ts timestamptz not null default current_timestamp); select create_hypertable('mytab', 'departure_ts'); WARNING: column type "character varying" used for "col1" does not follow best practices create_hypertable --------------------- (37,public,mytab,t) create unique index myidx_unique ON mytab (lower(col1::text), col2, departure_ts, arrival_ts); alter table mytab set (timescaledb.compress); -- github issue 6186 -- verify inserting into index works as expected during decompression insert into mytab (col1, col2, value, arrival_ts, departure_ts) values ('meter1', 1, 2.3, '2022-01-01'::timestamptz, '2022-01-01'::timestamptz), ('meTEr1', 2, 2.5, '2022-01-01'::timestamptz, '2022-01-01'::timestamptz), ('METEr1', 1, 2.9, '2022-01-01'::timestamptz, '2022-01-01 01:00'::timestamptz); select compress_chunk(show_chunks('mytab')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_37_141_chunk REINDEX TABLE mytab; -- should update index select decompress_chunk(show_chunks('mytab')); decompress_chunk ------------------------------------------- _timescaledb_internal._hyper_37_141_chunk vacuum analyze mytab; \set EXPLAIN 'EXPLAIN (buffers off, costs off,timing off,summary off)' \set EXPLAIN_ANALYZE 'EXPLAIN (analyze,buffers off, costs off,timing off,summary off)' -- do index scan on uncompressed, should give correct results set enable_seqscan = off; set enable_indexscan = on; :EXPLAIN_ANALYZE select * from mytab where lower(col1::text) = 'meter1'; --- QUERY PLAN --- Index Scan using _hyper_37_141_chunk_myidx_unique on _hyper_37_141_chunk (actual rows=3.00 loops=1) Index Cond: (lower((col1)::text) = 'meter1'::text) select * from mytab where lower(col1::text) = 'meter1'; col1 | col2 | value | arrival_ts | departure_ts --------+------+-------+------------------------------+------------------------------ meter1 | 1 | 2.3 | Sat Jan 01 00:00:00 2022 PST | Sat Jan 01 00:00:00 2022 PST METEr1 | 1 | 2.9 | Sat Jan 01 00:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST meTEr1 | 2 | 2.5 | Sat Jan 01 00:00:00 2022 PST | Sat Jan 01 00:00:00 2022 PST -- check predicate index CREATE INDEX myidx_partial ON mytab (value) WHERE (value > 2.4 AND value < 3); select compress_chunk(show_chunks('mytab')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_37_141_chunk select decompress_chunk(show_chunks('mytab')); decompress_chunk ------------------------------------------- _timescaledb_internal._hyper_37_141_chunk :EXPLAIN_ANALYZE SELECT * FROM mytab WHERE value BETWEEN 2.4 AND 2.8; --- QUERY PLAN --- Seq Scan on _hyper_37_141_chunk (actual rows=1.00 loops=1) Filter: ((value >= '2.4'::double precision) AND (value <= '2.8'::double precision)) Rows Removed by Filter: 2 -- check exclusion constraint with index - should not be supported CREATE TABLE hyper_ex ( time timestamptz, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1, canceled boolean DEFAULT false, EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) ); SELECT * FROM create_hypertable('hyper_ex', 'time', chunk_time_interval=> interval '1 month'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 39 | public | hyper_ex | t INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES ('2022-01-01', 'dev2', 11), ('2022-01-01 01:00', 'dev2', 12); \set ON_ERROR_STOP 0 ALTER TABLE hyper_ex SET (timescaledb.compress, timescaledb.compress_segmentby='device_id'); ERROR: constraint hyper_ex_time_device_id_excl is not supported for converting to columnstore \set ON_ERROR_STOP 1 -- check deferred uniqueness CREATE TABLE hyper_unique_deferred ( time BIGINT UNIQUE DEFERRABLE INITIALLY DEFERRED, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique_deferred', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+-----------------------+--------- 40 | public | hyper_unique_deferred | t INSERT INTO hyper_unique_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); alter table hyper_unique_deferred set (timescaledb.compress); select compress_chunk(show_chunks('hyper_unique_deferred')); -- also worked fine before 2.11.0 compress_chunk ------------------------------------------- _timescaledb_internal._hyper_40_145_chunk select decompress_chunk(show_chunks('hyper_unique_deferred')); decompress_chunk ------------------------------------------- _timescaledb_internal._hyper_40_145_chunk \set ON_ERROR_STOP 0 begin; insert INTO hyper_unique_deferred values (1257987700000000000, 'dev1', 1); abort; ERROR: new row for relation "_hyper_40_145_chunk" violates check constraint "hyper_unique_deferred_sensor_1_check" \set ON_ERROR_STOP 1 select compress_chunk(show_chunks('hyper_unique_deferred')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_40_145_chunk \set ON_ERROR_STOP 0 begin; insert INTO hyper_unique_deferred values (1257987700000000000, 'dev1', 1); abort; ERROR: duplicate key value violates unique constraint "145_2_hyper_unique_deferred_time_key" \set ON_ERROR_STOP 1 -- tests chunks being compressed using different segmentby settings -- github issue #7102 CREATE TABLE compression_drop(time timestamptz NOT NULL, v0 int, v1 int); CREATE INDEX ON compression_drop(time); CREATE INDEX ON compression_drop(v0,time); SELECT create_hypertable('compression_drop','time',create_default_indexes:=false); create_hypertable -------------------------------- (42,public,compression_drop,t) ALTER TABLE compression_drop SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='v0'); -- insert data and compress chunk INSERT INTO compression_drop(time, v0, v1) SELECT time, v0, v0+1 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-03 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gv0(v0); SELECT compress_chunk(ch, true) AS "CHUNK_NAME" FROM show_chunks('compression_drop') ch ORDER BY ch DESC \gset -- change segmentby column ALTER TABLE compression_drop SET (timescaledb.compress_segmentby='v1'); -- insert more data and compress next chunk INSERT INTO compression_drop(time, v0, v1) SELECT time, v0, v0+1 FROM generate_series('2000-01-07 0:00:00+0'::timestamptz,'2000-01-09 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gv0(v0); SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_drop' AND NOT is_compressed; CHUNK_NAME ------------------------------------------- _timescaledb_internal._hyper_42_150_chunk -- try dropping column v0, should fail \set ON_ERROR_STOP 0 ALTER TABLE compression_drop DROP COLUMN v0; ERROR: cannot drop orderby or segmentby column from a chunk with columnstore enabled \set ON_ERROR_STOP 1 DROP TABLE compression_drop; SET client_min_messages = ERROR; CREATE TABLE test2 (ts timestamptz, i integer not null, b bigint, t text); SELECT table_name from create_hypertable('test2', 'ts', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test2 INSERT INTO test2 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'ts DESC' ); \set ON_ERROR_STOP 0 INSERT INTO test2(ts,b,t) VALUES ('2024-11-18 18:04:51',99,'magic'); ERROR: null value in column "i" of relation "_hyper_44_179_chunk" violates not-null constraint \set ON_ERROR_STOP 1 ALTER TABLE test2 ALTER COLUMN i DROP NOT NULL; INSERT INTO test2(ts,b,t) VALUES ('2024-11-18 18:04:51',99,'magic'); SELECT count(*) FROM test2 WHERE i IS NULL; count ------- 1 SELECT count(compress_chunk(ch)) FROM show_chunks('test2') ch; count ------- 28 SELECT count(*) FROM test2 WHERE i IS NULL; count ------- 1 SELECT count(decompress_chunk(ch)) FROM show_chunks('test2') ch; count ------- 28 SELECT count(*) FROM test2 WHERE i IS NULL; count ------- 1 SELECT count(compress_chunk(ch)) FROM show_chunks('test2') ch; count ------- 28 SELECT count(*) FROM test2 WHERE i IS NULL; count ------- 1 \set ON_ERROR_STOP 0 ALTER TABLE test2 ALTER COLUMN i SET NOT NULL; ERROR: column "i" of relation "_hyper_44_180_chunk" contains null values DELETE FROM test2 WHERE i IS NULL; SELECT count(*) FROM test2 WHERE i IS NULL; count ------- 0 ALTER TABLE test2 ALTER COLUMN i SET NOT NULL; \set ON_ERROR_STOP 1 -- test set not null CREATE TABLE test_notnull(time timestamptz, device text, value float); SELECT create_hypertable('test_notnull','time'); create_hypertable ---------------------------- (46,public,test_notnull,t) ALTER TABLE test_notnull SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO test_notnull VALUES ('2025-01-01','d1',NULL); INSERT INTO test_notnull VALUES ('2025-01-01',NULL,NULL); -- should fail since we have NULL value \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ERROR: column "value" of relation "_hyper_46_237_chunk" contains null values ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ERROR: column "device" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 SELECT compress_chunk(show_chunks('test_notnull')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_46_237_chunk -- should fail since we have NULL value \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ERROR: column "value" of relation "_hyper_46_237_chunk" contains null values ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ERROR: column "device" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 UPDATE test_notnull SET value = 1; ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN value DROP NOT NULL; SELECT compress_chunk(show_chunks('test_notnull')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_46_237_chunk ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN value DROP NOT NULL; -- device still has NULL \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ERROR: column "device" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 UPDATE test_notnull SET device = 'd1'; ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN device DROP NOT NULL; SELECT compress_chunk(show_chunks('test_notnull')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_46_237_chunk ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN device DROP NOT NULL; -- test partial compressed chunks -- NULL in uncompressed part only INSERT INTO test_notnull VALUES ('2025-01-01',NULL,NULL); \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ERROR: column "device" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 -- NULL in compressed part only SELECT compress_chunk(show_chunks('test_notnull')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_46_237_chunk INSERT INTO test_notnull VALUES ('2025-01-01','d1',2); \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ERROR: column "device" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 -- test added columns and defaults ALTER TABLE test_notnull ADD COLUMN c1 int; \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN c1 SET NOT NULL; ERROR: column "c1" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 ALTER TABLE test_notnull ADD COLUMN c2 int DEFAULT 42; ALTER TABLE test_notnull ALTER COLUMN c2 SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN c2 DROP NOT NULL; -- test column with default and explicit NULL UPDATE test_notnull SET c2 = NULL; \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN c2 SET NOT NULL; ERROR: column "c2" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 SELECT compress_chunk(show_chunks('test_notnull')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_46_237_chunk \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN c2 SET NOT NULL; ERROR: column "c2" of relation "_hyper_46_237_chunk" contains null values \set ON_ERROR_STOP 1 -- test alias in parameter name CREATE TABLE alias(time timestamptz NOT NULL); SELECT create_hypertable('alias','time'); create_hypertable --------------------- (48,public,alias,t) ALTER TABLE alias SET (tsdb.compress, tsdb.compress_orderby='time DESC',tsdb.compress_segmentby=''); INSERT INTO alias SELECT '2025-01-01'; SELECT count(compress_chunk(ch)) FROM show_chunks('alias') ch; count ------- 1 -- test mixing postgres and timescaledb options CREATE TABLE mix_pg_ts(time timestamptz, device text) WITH (tsdb.hypertable,tsdb.partition_column='time',fillfactor=90); SELECT reloptions FROM pg_class WHERE relname='mix_pg_ts'; reloptions ----------------- {fillfactor=90} SELECT * FROM timescaledb_information.hypertable_compression_settings WHERE hypertable='mix_pg_ts'::regclass; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- mix_pg_ts | | | | ALTER TABLE mix_pg_ts SET (timescaledb.compress, fillfactor=70, tsdb.orderby='time', timescaledb.compress_segmentby='device', autovacuum_enabled=true); SELECT reloptions FROM pg_class WHERE relname='mix_pg_ts'; reloptions ----------------------------------------- {fillfactor=70,autovacuum_enabled=true} SELECT * FROM timescaledb_information.hypertable_compression_settings WHERE hypertable='mix_pg_ts'::regclass; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- mix_pg_ts | device | "time" | | -- test resetting options ALTER TABLE mix_pg_ts RESET (fillfactor, tsdb.segmentby); SELECT reloptions FROM pg_class WHERE relname='mix_pg_ts'; reloptions --------------------------- {autovacuum_enabled=true} SELECT * FROM timescaledb_information.hypertable_compression_settings WHERE hypertable='mix_pg_ts'::regclass; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- mix_pg_ts | | "time" | | �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_defaults.out���������������������������������������0000664�0000000�0000000�00000075525�15100345067�0024434�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE VIEW chunk_settings AS SELECT hypertable, count(*) as chunks, segmentby, orderby, index FROM timescaledb_information.chunk_compression_settings cs group by hypertable,segmentby,orderby, index ORDER BY 1,2,3,4,5; -- statitics on CREATE TABLE "public"."metrics" ( "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); create_hypertable ---------------------- (1,public,metrics,t) insert into metrics SELECT t, 1, extract(epoch from t) from generate_series ( '2007-02-01'::timestamp , '2007-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 2, extract(epoch from t) from generate_series ( '2007-06-01'::timestamp , '2007-10-01'::timestamp , '1 day'::interval) t; ANALYZE metrics; --use the best-scenario unique index CREATE UNIQUE INDEX test_idx ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------- {"columns": ["device_id"], "confidence": 10} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 8} ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 27 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+-------------+------------------------------------------------------------- metrics | 27 | device_id | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 27 ALTER TABLE metrics SET (timescaledb.compress = false); ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_segmentby = 'device_id'); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 27 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+-------------+------------------------------------------------------------- metrics | 27 | device_id | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 27 ALTER TABLE metrics SET (timescaledb.compress = false); --make sure all the GUC combinations work SET timescaledb.compression_segmentby_default_function = ''; SET timescaledb.compression_orderby_default_function = ''; ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_orderby = '"time" desc', timescaledb.compress_segmentby = ''); WARNING: column "device_id" should be used for segmenting or ordering SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------+----------------+-----------+---------+--------------+--------------------+------- metrics | | {} | {time} | {t} | {t} | ALTER TABLE metrics SET (timescaledb.compress = false); SET timescaledb.compression_segmentby_default_function = ''; RESET timescaledb.compression_orderby_default_function; ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 27 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+-----------------------+----------------------------------------------------------------------------------------------------------------------------- metrics | 27 | | device_id,"time" DESC | [{"type": "minmax", "column": "device_id", "source": "orderby"}, {"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 27 ALTER TABLE metrics SET (timescaledb.compress = false); RESET timescaledb.compression_segmentby_default_function; SET timescaledb.compression_orderby_default_function = ''; ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 27 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+-------------+------------------------------------------------------------- metrics | 27 | device_id | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 27 ALTER TABLE metrics SET (timescaledb.compress = false); RESET timescaledb.compression_segmentby_default_function; RESET timescaledb.compression_orderby_default_function; --opposite order of columns drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(time, device_id); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------- {"columns": ["device_id"], "confidence": 10} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 8} --use a high-cardinality column in the index drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 7} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); get_orderby_defaults -------------------------------------------------------- {"clauses": ["val", "\"time\" DESC"], "confidence": 8} --use a non-unique index drop index test_idx; CREATE INDEX test_idx ON metrics(device_id, time, val); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 8} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 5} --another non-unique index column order drop index test_idx; CREATE INDEX test_idx ON metrics(val, device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 8} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); get_orderby_defaults -------------------------------------------------------- {"clauses": ["\"time\" DESC", "val"], "confidence": 5} --use a high-cardinality column in the non-unque index drop index test_idx; CREATE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 7} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); get_orderby_defaults -------------------------------------------------------- {"clauses": ["\"time\" DESC", "val"], "confidence": 5} --use 2 indexes drop index test_idx; CREATE INDEX test_idx1 ON metrics(val, time); CREATE INDEX test_idx2 ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 8} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); get_orderby_defaults -------------------------------------------------------- {"clauses": ["\"time\" DESC", "val"], "confidence": 5} --no indexes drop index test_idx1; drop index test_idx2; SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 7} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 5} ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 27 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+-------------+------------------------------------------------------------- metrics | 27 | device_id | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 27 ALTER TABLE metrics SET (timescaledb.compress = false); -- tables with no stats -- drop table metrics; --serial case CREATE TABLE "public"."metrics" ( id serial NOT NULL, "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); create_hypertable ---------------------- (8,public,metrics,t) --no indexes SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"columns": [], "message": "You do not have any indexes on columns that can be used for segment_by and thus we are not using segment_by for converting to columnstore. Please make sure you are not missing any indexes", "confidence": 5} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 5} --minimum index CREATE UNIQUE INDEX test_idx ON metrics(id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"columns": [], "message": "You do not have any indexes on columns that can be used for segment_by and thus we are not using segment_by for converting to columnstore. Please make sure you are not missing any indexes", "confidence": 5} --index with device_id drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(device_id, id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------------------------------------------------------------------------------------------------------- {"columns": ["device_id"], "message": "Please make sure device_id is not a unique column and appropriate for a segment by", "confidence": 5} --two indexes drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(id, time); CREATE INDEX test_idx2 ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------------------------------------------------------------------------------------------------------- {"columns": ["device_id"], "message": "Please make sure device_id is not a unique column and appropriate for a segment by", "confidence": 5} --separate indexes drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(id); CREATE INDEX test_idx2 ON metrics(time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"columns": [], "message": "You do not have any indexes on columns that can be used for segment_by and thus we are not using segment_by for converting to columnstore. Please make sure you are not missing any indexes", "confidence": 5} --make sure generated identity also works drop table metrics; CREATE TABLE "public"."metrics" ( id int GENERATED ALWAYS AS IDENTITY, "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); create_hypertable ---------------------- (9,public,metrics,t) --minimum index CREATE UNIQUE INDEX test_idx ON metrics(id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"columns": [], "message": "You do not have any indexes on columns that can be used for segment_by and thus we are not using segment_by for converting to columnstore. Please make sure you are not missing any indexes", "confidence": 5} --index with device_id drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(device_id, id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------------------------------------------------------------------------------------------------------- {"columns": ["device_id"], "message": "Please make sure device_id is not a unique column and appropriate for a segment by", "confidence": 5} --test default indexes drop table metrics; CREATE TABLE "public"."metrics" ( id int GENERATED ALWAYS AS IDENTITY, "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>true); create_hypertable ----------------------- (10,public,metrics,t) SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {"columns": [], "message": "You do not have any indexes on columns that can be used for segment_by and thus we are not using segment_by for converting to columnstore. Please make sure you are not missing any indexes", "confidence": 5} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 5} CREATE INDEX test_idx ON metrics(device_id); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------------------------------------------------------------------------------------------------------- {"columns": ["device_id"], "message": "Please make sure device_id is not a unique column and appropriate for a segment by", "confidence": 5} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 5} drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------------------------------------------------------------------------------------------------------- {"columns": ["device_id"], "message": "Please make sure device_id is not a unique column and appropriate for a segment by", "confidence": 5} SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); get_orderby_defaults ------------------------------------------------- {"clauses": ["\"time\" DESC"], "confidence": 8} --test table with skewed statistics drop table metrics; CREATE TABLE "public"."metrics" ( "time" timestamp with time zone NOT NULL, "device_id" "text", "device_id2" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); create_hypertable ----------------------- (11,public,metrics,t) --skew device_id distribution compared to device_id2. --device_id2 will be the favourable default segmentby insert into metrics SELECT t, 1, 1, extract(epoch from t) from generate_series ( '2007-02-01'::timestamp , '2007-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 1, 2, extract(epoch from t) from generate_series ( '2008-02-01'::timestamp , '2008-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 1, 1, extract(epoch from t) from generate_series ( '2012-02-01'::timestamp , '2012-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 2, 2, extract(epoch from t) from generate_series ( '2016-02-01'::timestamp , '2016-04-01'::timestamp , '1 day'::interval) t; ANALYZE metrics; --use the best-scenario unique index (device_id2) CREATE UNIQUE INDEX test_idx ON metrics(device_id, time); CREATE UNIQUE INDEX test_idx2 ON metrics(device_id2, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ----------------------------------------------- {"columns": ["device_id2"], "confidence": 10} --opposite order of columns drop index test_idx; drop index test_idx2; CREATE UNIQUE INDEX test_idx ON metrics(time, device_id); CREATE UNIQUE INDEX test_idx2 ON metrics(time, device_id2); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ----------------------------------------------- {"columns": ["device_id2"], "confidence": 10} --use a high-cardinality column in the index (still choose device_id2) drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ----------------------------------------------- {"columns": ["device_id2"], "confidence": 10} --use a non-unique index drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(device_id, time, val); CREATE INDEX test_idx2 ON metrics(device_id2, time, val); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------- {"columns": ["device_id2"], "confidence": 8} --another non-unique index column order (choose device_id since it is in a lower index position) drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(device_id, time, val); CREATE INDEX test_idx2 ON metrics(val, device_id2, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 8} --use a high-cardinality column in the non-unque index (still choose device_id2) drop index test_idx; CREATE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------- {"columns": ["device_id2"], "confidence": 8} --use 2 indexes (choose device_id since it is an indexed column) drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(val, time); CREATE INDEX test_idx2 ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults --------------------------------------------- {"columns": ["device_id"], "confidence": 8} --no indexes (choose device_id2) drop index test_idx; drop index test_idx2; SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); get_segmentby_defaults ---------------------------------------------- {"columns": ["device_id2"], "confidence": 7} ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 38 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+------------+-------------+------------------------------------------------------------- metrics | 38 | device_id2 | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 38 ALTER TABLE metrics SET (timescaledb.compress = false); ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_segmentby = 'device_id'); select count(compress_chunk(x)) from show_chunks('metrics') x; count ------- 38 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+-------------+------------------------------------------------------------- metrics | 38 | device_id | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] select count(decompress_chunk(x)) from show_chunks('metrics') x; count ------- 38 ALTER TABLE metrics SET (timescaledb.compress = false); DROP TABLE metrics; --test on an empty order_by CREATE TABLE table1(col1 INT NOT NULL, col2 INT); SELECT create_hypertable('table1','col1', chunk_time_interval => 10); create_hypertable ---------------------- (14,public,table1,t) SELECT _timescaledb_functions.get_orderby_defaults('table1', ARRAY['col1']::text[]); get_orderby_defaults ---------------------------------- {"clauses": [], "confidence": 5} ALTER TABLE table1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'col1'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index --------+----------------+-----------+---------+--------------+--------------------+------- table1 | | {col1} | | | | ALTER TABLE table1 SET (timescaledb.compress = false); \set ON_ERROR_STOP 0 SET timescaledb.compression_segmentby_default_function = 'function_does_not_exist'; ERROR: invalid value for parameter "timescaledb.compression_segmentby_default_function": "function_does_not_exist" SET timescaledb.compression_orderby_default_function = 'function_does_not_exist'; ERROR: invalid value for parameter "timescaledb.compression_orderby_default_function": "function_does_not_exist" --wrong function signatures SET timescaledb.compression_segmentby_default_function = '_timescaledb_functions.get_orderby_defaults'; ERROR: invalid value for parameter "timescaledb.compression_segmentby_default_function": "_timescaledb_functions.get_orderby_defaults" SET timescaledb.compression_orderby_default_function = '_timescaledb_functions.get_segmentby_defaults'; ERROR: invalid value for parameter "timescaledb.compression_orderby_default_function": "_timescaledb_functions.get_segmentby_defaults" \set ON_ERROR_STOP 1 SET timescaledb.compression_orderby_default_function = '_timescaledb_functions.get_orderby_defaults'; SET timescaledb.compression_segmentby_default_function = '_timescaledb_functions.get_segmentby_defaults'; RESET timescaledb.compression_segmentby_default_function; RESET timescaledb.compression_orderby_default_function; -- test search_path quoting SET search_path TO ''; CREATE TABLE public.t1 (time timestamptz NOT NULL, segment_value text NOT NULL); SELECT public.create_hypertable('public.t1', 'time'); create_hypertable ------------------- (16,public,t1,t) ALTER TABLE public.t1 SET (timescaledb.compress, timescaledb.compress_orderby = 'segment_value'); RESET search_path; -- test same named objects in different schemas with default orderbys/segmentbys \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA schema1; CREATE SCHEMA schema2; GRANT ALL ON SCHEMA schema1, schema2 to public; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- test the case with default orderbys CREATE TABLE schema1.page_events2 ( time TIMESTAMPTZ NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema1.page_events2', 'time'); create_hypertable ----------------------------- (18,schema1,page_events2,t) ALTER TABLE schema1.page_events2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'page' ); CREATE TABLE schema2.page_events2 ( time TIMESTAMPTZ NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema2.page_events2', 'time'); create_hypertable ----------------------------- (20,schema2,page_events2,t) ALTER TABLE schema2.page_events2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'page' ); DROP TABLE schema1.page_events2; DROP TABLE schema2.page_events2; -- test the case with default segmentbys CREATE TABLE schema1.page_events2 ( time TIMESTAMPTZ NOT NULL, id BIGSERIAL NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema1.page_events2', 'time'); create_hypertable ----------------------------- (22,schema1,page_events2,t) ALTER TABLE schema1.page_events2 SET ( timescaledb.compress, timescaledb.compress_orderby = 'time desc, id asc' ); CREATE TABLE schema2.page_events2 ( time TIMESTAMPTZ NOT NULL UNIQUE, id BIGSERIAL NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema2.page_events2', 'time'); create_hypertable ----------------------------- (24,schema2,page_events2,t) ALTER TABLE schema2.page_events2 SET ( timescaledb.compress, timescaledb.compress_orderby = 'time desc' ); -- test default segmentby diabled when orderby is specified CREATE TABLE test_table ( ts INT NOT NULL, uuid BIGINT NOT NULL, val FLOAT ); CREATE UNIQUE INDEX test_idx ON test_table (uuid, ts); SELECT create_hypertable( 'test_table', 'ts', chunk_time_interval => 1500000 ); create_hypertable -------------------------- (26,public,test_table,t) INSERT INTO test_table (ts, uuid, val) VALUES (1, 1001, 10.1), (2, 1002, 20.2), (3, 1003, 30.3); SELECT _timescaledb_functions.get_segmentby_defaults('public.test_table'); get_segmentby_defaults ------------------------------------------------------------------------------------------------------------------------------------ {"columns": ["uuid"], "message": "Please make sure uuid is not a unique column and appropriate for a segment by", "confidence": 5} ALTER TABLE test_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'uuid' ); SELECT count(compress_chunk(x)) FROM show_chunks('test_table') x; count ------- 1 select * from chunk_settings; hypertable | chunks | segmentby | orderby | index ------------+--------+-----------+--------------+---------------------------------------------------------------------------------------------------------------------- test_table | 1 | | uuid,ts DESC | [{"type": "minmax", "column": "uuid", "source": "orderby"}, {"type": "minmax", "column": "ts", "source": "orderby"}] DROP TABLE test_table; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_errors.out�����������������������������������������0000664�0000000�0000000�00000140305�15100345067�0024126�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 \set VERBOSITY default \set ECHO none --table with special column names -- create table foo2 (a integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('foo2', 'a', chunk_time_interval=> 10); table_name ------------ foo2 create table foo3 (a integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('foo3', 'a', chunk_time_interval=> 10); table_name ------------ foo3 create table non_compressed (a integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('non_compressed', 'a', chunk_time_interval=> 10); table_name ---------------- non_compressed insert into non_compressed values( 3 , 16 , 20, 4); ALTER TABLE foo2 set (timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'c'); ERROR: cannot use column "c" for both ordering and segmenting HINT: Use separate columns for the timescaledb.compress_orderby and timescaledb.compress_segmentby options. ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'c'); ERROR: cannot use column "c" for both ordering and segmenting HINT: Use separate columns for the timescaledb.compress_orderby and timescaledb.compress_segmentby options. ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'd DESC'); ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'd'); -- this is acceptable: having previously set the default value for orderby -- and skipping orderby on a subsequent alter command create table default_skipped (a integer not null, b integer, c integer, d integer); select create_hypertable('default_skipped', 'a', chunk_time_interval=> 10); create_hypertable ------------------------------ (5,public,default_skipped,t) alter table default_skipped set (timescaledb.compress, timescaledb.compress_segmentby = 'c'); alter table default_skipped set (timescaledb.compress, timescaledb.compress_segmentby = 'c'); create table with_rls (a integer, b integer); ALTER TABLE with_rls ENABLE ROW LEVEL SECURITY; select table_name from create_hypertable('with_rls', 'a', chunk_time_interval=> 10); table_name ------------ with_rls ALTER TABLE with_rls set (timescaledb.compress, timescaledb.compress_orderby='a'); ERROR: columnstore cannot be used on table with row security --note that the time column "a" should be added to the end of the orderby list SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY relid::text; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -----------------+----------------+----------------+---------+--------------+--------------------+------- default_skipped | | {c} | | | | foo2 | | {"bacB toD",c} | {d,a} | {f,t} | {f,t} | ALTER TABLE foo3 set (timescaledb.compress, timescaledb.compress_orderby='d DeSc NullS lAsT'); --shold allow alter since segment by was empty ALTER TABLE foo3 set (timescaledb.compress, timescaledb.compress_orderby='d Asc NullS lAsT'); --this is ok too ALTER TABLE foo3 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c', timescaledb.compress_orderby = 'd DeSc NullS lAsT'); -- Negative test cases --- ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c'); alter table default_skipped set (timescaledb.compress, timescaledb.compress_orderby = 'a asc', timescaledb.compress_segmentby = 'c'); alter table default_skipped set (timescaledb.compress, timescaledb.compress_segmentby = 'c'); create table reserved_column_prefix (a integer, _ts_meta_foo integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('reserved_column_prefix', 'a', chunk_time_interval=> 10); table_name ------------------------ reserved_column_prefix ALTER TABLE reserved_column_prefix set (timescaledb.compress); ERROR: cannot convert tables with reserved column prefix '_ts_meta_' to columnstore --basic test with count create table foo (a integer, b integer, c integer, t text, p point); ALTER TABLE foo ADD CONSTRAINT chk_existing CHECK(b > 0); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo insert into foo values( 3 , 16 , 20); insert into foo values( 10 , 10 , 20); insert into foo values( 20 , 11 , 20); insert into foo values( 30 , 12 , 20); ALTER TABLE foo ALTER b SET NOT NULL; select attname, attnotnull from pg_attribute where attrelid = (select oid from pg_class where relname like 'foo') and attname like 'b'; attname | attnotnull ---------+------------ b | t ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'd'); ERROR: column "d" does not exist HINT: The timescaledb.compress_segmentby option must reference a valid column. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = ''); ERROR: ordering column can not be empty HINT: timescaledb.compress_orderby option must reference a valid column or be removed to use default settings. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'd'); ERROR: column "d" does not exist HINT: The timescaledb.compress_orderby option must reference a valid column. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc nulls'); ERROR: unable to parse ordering option "c desc nulls" DETAIL: syntax error at or near "nulls" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc nulls thirsty'); ERROR: unable to parse ordering option "c desc nulls thirsty" DETAIL: syntax error at or near "nulls" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c climb nulls first'); ERROR: unable to parse ordering option "c climb nulls first" DETAIL: syntax error at or near "climb" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c nulls first asC'); ERROR: unable to parse ordering option "c nulls first asC" DETAIL: syntax error at or near "asC" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc nulls first asc'); ERROR: unable to parse ordering option "c desc nulls first asc" DETAIL: syntax error at or near "asc" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc hurry'); ERROR: unable to parse ordering option "c desc hurry" DETAIL: syntax error at or near "hurry" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c descend'); ERROR: unable to parse ordering option "c descend" DETAIL: syntax error at or near "descend" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c; SELECT 1'); ERROR: unable to parse ordering option "c; SELECT 1" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = '1,2'); ERROR: unable to parse ordering option "1,2" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c + 1'); ERROR: unable to parse ordering option "c + 1" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'random()'); ERROR: unable to parse ordering option "random()" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c LIMIT 1'); ERROR: unable to parse ordering option "c LIMIT 1" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c USING <'); ERROR: unable to parse ordering option "c USING <" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 't COLLATE "en_US"'); ERROR: unable to parse ordering option "t COLLATE "en_US"" HINT: The timescaledb.compress_orderby option must be a set of column names with sort options, separated by commas. It is the same format as an ORDER BY clause. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c asc' , timescaledb.compress_orderby = 'c'); ERROR: unable to parse segmenting option "c asc" DETAIL: syntax error at or near "asc" HINT: The option timescaledb.compress_segmentby must be a set of columns separated by commas. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c nulls last'); ERROR: unable to parse segmenting option "c nulls last" DETAIL: syntax error at or near "nulls" HINT: The option timescaledb.compress_segmentby must be a set of columns separated by commas. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c + 1'); ERROR: unable to parse segmenting option "c + 1" HINT: The option timescaledb.compress_segmentby must be a set of columns separated by commas. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'random()'); ERROR: unable to parse segmenting option "random()" HINT: The option timescaledb.compress_segmentby must be a set of columns separated by commas. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c LIMIT 1'); ERROR: unable to parse segmenting option "c LIMIT 1" HINT: The option timescaledb.compress_segmentby must be a set of columns separated by commas. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c + b'); ERROR: unable to parse segmenting option "c + b" HINT: The option timescaledb.compress_segmentby must be a set of columns separated by commas. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, p'); ERROR: invalid ordering column type point DETAIL: Could not identify a less-than operator for the type. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'b, b'); ERROR: duplicate column name "b" HINT: The timescaledb.compress_segmentby option must reference distinct column. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'b, b'); ERROR: duplicate column name "b" HINT: The timescaledb.compress_orderby option must reference distinct column. --should succeed ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_segmentby=''); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_segmentby='c'); -- test alter reset SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | {c} | {a,b} | {f,f} | {f,f} | ALTER TABLE foo RESET (timescaledb.compress_orderby); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | {c} | | | | ALTER TABLE foo RESET (timescaledb.compress_segmentby); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | | | | | ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_index = 'bloom(c)'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------ foo | | | {a,b} | {f,f} | {f,f} | [{"type": "bloom", "column": "c", "source": "config"}, {"type": "minmax", "column": "a", "source": "orderby"}, {"type": "minmax", "column": "b", "source": "orderby"}] ALTER TABLE foo RESET (timescaledb.compress_index); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | | {a,b} | {f,f} | {f,f} | -- should fail ALTER TABLE foo RESET (timescaledb.compress); ERROR: only columnstore options segmentby and orderby can be reset ALTER TABLE foo RESET (timescaledb.compress, timescaledb.compress_segmentby, timescaledb.compress_orderby); ALTER TABLE foo RESET (timescaledb.compress_segmentby = 'a', timescaledb.compress_orderby); ERROR: RESET must not include values for parameters ALTER TABLE foo RESET (timescaledb.compress_segmentby = ''); ERROR: RESET must not include values for parameters -- should succeed ALTER TABLE foo RESET (timescaledb.compress_segmentby, timescaledb.compress_orderby); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | | | | | ALTER TABLE foo SET (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_segmentby=''); create table foo_fake (a integer, b integer, c integer, t text, p point); ALTER TABLE foo_fake RESET (timescaledb.compress_segmentby); ERROR: timescaledb table options can only be specified for hypertables DETAIL: foo_fake is not a hypertable select table_name from create_hypertable('foo_fake', 'a', chunk_time_interval=> 10); table_name ------------ foo_fake ALTER TABLE foo_fake RESET (timescaledb.compress_segmentby); DROP TABLE foo_fake; --ddl on ht with compression ALTER TABLE foo DROP COLUMN a; ERROR: cannot drop column named in partition key DETAIL: Cannot drop column that is a hypertable partitioning (space or time) dimension. ALTER TABLE foo DROP COLUMN b; ERROR: cannot drop orderby or segmentby column from a hypertable with columnstore enabled ALTER TABLE foo ALTER COLUMN t SET NOT NULL; ERROR: column "t" of relation "_hyper_10_2_chunk" contains null values --can add constraints as long as no data is compressed ALTER TABLE foo ADD CONSTRAINT chk CHECK(b > 0); ALTER TABLE foo ADD CONSTRAINT unq UNIQUE(a); --restore ALTER TABLE foo DROP CONSTRAINT chk; ALTER TABLE foo DROP CONSTRAINT unq; --should succeed BEGIN; ALTER TABLE foo DROP CONSTRAINT chk_existing; ROLLBACK; --note that the time column "a" should not be added to the end of the order by list again (should appear first) SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | {} | {a,b} | {f,f} | {f,f} | SELECT decompress_chunk(ch, false) FROM show_chunks('foo') ch limit 1; ERROR: chunk "_hyper_10_2_chunk" is not converted to columnstore --test changing the segment by columns ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a', timescaledb.compress_segmentby = 'b'); SELECT format('%I.%I',chunk_schema,chunk_name) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'foo' ORDER BY chunk_name LIMIT 1\gset select decompress_chunk(:'CHUNK_NAME', if_compressed=>false); ERROR: chunk "_hyper_10_2_chunk" is not converted to columnstore select decompress_chunk(:'CHUNK_NAME'); NOTICE: chunk "_hyper_10_2_chunk" is not converted to columnstore decompress_chunk ------------------ --should succeed select compress_chunk(:'CHUNK_NAME'); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_10_2_chunk select compress_chunk(:'CHUNK_NAME', if_not_compressed=>false); ERROR: chunk "_hyper_10_2_chunk" is already converted to columnstore select compress_chunk(:'CHUNK_NAME'); NOTICE: chunk "_hyper_10_2_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_10_2_chunk SELECT compress_chunk(ch) FROM show_chunks('non_compressed') ch LIMIT 1; ERROR: columnstore not enabled on "non_compressed" DETAIL: It is not possible to convert chunks to columnstore on a hypertable or continuous aggregate that does not have columnstore enabled. HINT: Enable columnstore using ALTER TABLE/MATERIALIZED VIEW with the timescaledb.enable_columnstore option. ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a', timescaledb.compress_segmentby = 'c'); ALTER TABLE foo set (timescaledb.compress='f'); ERROR: cannot disable columnstore on hypertable with columnstore chunks ALTER TABLE foo reset (timescaledb.compress); ERROR: only columnstore options segmentby and orderby can be reset SELECT decompress_chunk(ch) FROM show_chunks('non_compressed') ch LIMIT 1; ERROR: missing columnstore-enabled hypertable --should succeed SELECT decompress_chunk(ch, true) FROM show_chunks('foo') ch; NOTICE: chunk "_hyper_10_3_chunk" is not converted to columnstore NOTICE: chunk "_hyper_10_4_chunk" is not converted to columnstore NOTICE: chunk "_hyper_10_5_chunk" is not converted to columnstore decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_10_2_chunk --should succeed ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a', timescaledb.compress_segmentby = 'b'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- foo | | {b} | {a} | {f} | {f} | SELECT comp_hyper.schema_name|| '.' || comp_hyper.table_name as "COMPRESSED_HYPER_NAME" FROM _timescaledb_catalog.hypertable comp_hyper INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'foo' ORDER BY comp_hyper.id LIMIT 1 \gset select add_retention_policy(:'COMPRESSED_HYPER_NAME', INTERVAL '4 months', true); ERROR: cannot add retention policy to compressed hypertable "_compressed_hypertable_11" HINT: Please add the policy to the corresponding uncompressed hypertable instead. --Constraint checking for compression create table fortable(col integer primary key); create table table_constr( device_id integer, timec integer , location integer , c integer constraint valid_cval check (c > 20) , d integer, primary key ( device_id, timec) ); insert into fortable values (1); select table_name from create_hypertable('table_constr', 'timec', chunk_time_interval=> 10); table_name -------------- table_constr BEGIN; ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_segmentby = 'd'); ROLLBACK; alter table table_constr add constraint table_constr_uk unique (location, timec, device_id); BEGIN; ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_orderby = 'timec', timescaledb.compress_segmentby = 'device_id'); WARNING: column "location" should be used for segmenting or ordering ROLLBACK; --exclusion constraints not allowed alter table table_constr add constraint table_constr_exclu exclude using btree (timec with = ); ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_orderby = 'timec', timescaledb.compress_segmentby = 'device_id, location, d'); ERROR: constraint table_constr_exclu is not supported for converting to columnstore HINT: Exclusion constraints are not supported on hypertables that are converted to columnstore. alter table table_constr drop constraint table_constr_exclu ; --now it works ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_orderby = 'timec', timescaledb.compress_segmentby = 'device_id, location, d'); -- ddl ADD column variants that are not supported ALTER TABLE table_constr ADD COLUMN newcol integer UNIQUE; ERROR: cannot create a unique index without the column "timec" (used in partitioning) HINT: If you're creating a hypertable on a table with a primary key, ensure the partitioning column is part of the primary or composite key. ALTER TABLE table_constr ADD COLUMN newcol integer PRIMARY KEY; ERROR: cannot create a unique index without the column "timec" (used in partitioning) HINT: If you're creating a hypertable on a table with a primary key, ensure the partitioning column is part of the primary or composite key. ALTER TABLE table_constr ADD COLUMN newcol integer NOT NULL; ERROR: cannot add column with NOT NULL constraint without default to a hypertable that has columnstore enabled ALTER TABLE table_constr ADD COLUMN newcol integer DEFAULT random() + random(); ERROR: cannot add column with non-constant default expression to a hypertable that has columnstore enabled ALTER TABLE table_constr ADD COLUMN IF NOT EXISTS newcol integer REFERENCES fortable(col); ERROR: cannot add column with constraints to a hypertable that has columnstore enabled ALTER TABLE table_constr ADD COLUMN IF NOT EXISTS newcol integer GENERATED ALWAYS AS IDENTITY; ERROR: cannot add column with constraints to a hypertable that has columnstore enabled ALTER TABLE table_constr ADD COLUMN IF NOT EXISTS newcol integer GENERATED BY DEFAULT AS IDENTITY; ERROR: cannot add column with constraints to a hypertable that has columnstore enabled ALTER TABLE table_constr ADD COLUMN newcol nonexistent_type; ERROR: type "nonexistent_type" does not exist LINE 1: ALTER TABLE table_constr ADD COLUMN newcol nonexistent_type; ^ --FK check should not error even with dropped columns (previously had a bug related to this) CREATE TABLE table_fk ( time timestamptz NOT NULL, id1 int8 NOT NULL, id2 int8 NOT NULL, value float8 NULL, CONSTRAINT fk1 FOREIGN KEY (id1) REFERENCES fortable(col), CONSTRAINT fk2 FOREIGN KEY (id2) REFERENCES fortable(col) ); SELECT create_hypertable('table_fk', 'time'); create_hypertable ------------------------ (17,public,table_fk,t) ALTER TABLE table_fk DROP COLUMN id1; ALTER TABLE table_fk SET (timescaledb.compress,timescaledb.compress_segmentby = 'id2'); -- TEST fk cascade delete behavior on compressed chunk -- insert into fortable values(10); --we want 2 chunks here -- insert into table_constr values(1000, 1, 44, 44, 1); insert into table_constr values(1000, 10, 44, 44, 10); select ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'table_constr' ORDER BY ch1.id limit 1 \gset -- we have 1 compressed and 1 uncompressed chunk after this. select compress_chunk(:'CHUNK_NAME'); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_13_7_chunk SELECT total_chunks , number_compressed_chunks FROM hypertable_compression_stats('table_constr'); total_chunks | number_compressed_chunks --------------+-------------------------- 2 | 1 --github issue 1661 --disable compression after enabling it on a table that has fk constraints CREATE TABLE table_constr2( device_id integer, timec integer , location integer , d integer references fortable(col), primary key ( device_id, timec) ); SELECT table_name from create_hypertable('table_constr2', 'timec', chunk_time_interval=> 10); table_name --------------- table_constr2 INSERT INTO fortable VALUES( 99 ); INSERT INTO table_constr2 VALUES( 1000, 10, 5, 99); ALTER TABLE table_constr2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id'); ALTER TABLE table_constr2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); --compress a chunk and try to disable compression, it should fail -- SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id and ht.table_name like 'table_constr2' \gset SELECT compress_chunk(:'CHUNK_NAME'); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_10_chunk ALTER TABLE table_constr2 set (timescaledb.compress=false); ERROR: cannot disable columnstore on hypertable with columnstore chunks --decompress all chunks and disable compression. SELECT decompress_chunk(:'CHUNK_NAME'); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_10_chunk ALTER TABLE table_constr2 SET (timescaledb.compress=false); -- TEST compression policy -- modify the config to trigger errors at runtime CREATE TABLE test_table_int(time bigint, val int); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 1); create_hypertable ------------------------------ (21,public,test_table_int,t) CREATE OR REPLACE function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 5::BIGINT'; SELECT set_integer_now_func('test_table_int', 'dummy_now'); set_integer_now_func ---------------------- INSERT INTO test_table_int SELECT generate_series(1,5), 10; ALTER TABLE test_table_int set (timescaledb.compress); SELECT add_compression_policy('test_table_int', 2::int) AS compressjob_id \gset \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_config.bgw_job SET config = config - 'compress_after' WHERE id = :compressjob_id; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; config ----------------------- {"hypertable_id": 21} --should fail CALL run_job(:compressjob_id); ERROR: job 1000 config must have compress_after or compress_created_before CONTEXT: PL/pgSQL function _timescaledb_functions.policy_compression(integer,jsonb) line 50 at RAISE SELECT remove_compression_policy('test_table_int'); remove_compression_policy --------------------------- t --again add a new policy that we'll tamper with SELECT add_compression_policy('test_table_int', 2::int) AS compressjob_id \gset UPDATE _timescaledb_config.bgw_job SET config = config - 'hypertable_id' WHERE id = :compressjob_id; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; config ----------------------- {"compress_after": 2} --should fail CALL run_job(:compressjob_id); ERROR: job 1001 config must have hypertable_id CONTEXT: PL/pgSQL function _timescaledb_functions.policy_compression(integer,jsonb) line 30 at RAISE UPDATE _timescaledb_config.bgw_job SET config = NULL WHERE id = :compressjob_id; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; config -------- --should fail CALL run_job(:compressjob_id); ERROR: job 1001 has null config CONTEXT: PL/pgSQL function _timescaledb_functions.policy_compression(integer,jsonb) line 25 at RAISE -- test ADD COLUMN IF NOT EXISTS CREATE TABLE metric (time TIMESTAMPTZ NOT NULL, val FLOAT8 NOT NULL, dev_id INT4 NOT NULL); SELECT create_hypertable('metric', 'time', 'dev_id', 10); create_hypertable ---------------------- (23,public,metric,t) ALTER TABLE metric SET ( timescaledb.compress, timescaledb.compress_segmentby = 'dev_id', timescaledb.compress_orderby = 'time DESC' ); INSERT INTO metric(time, val, dev_id) SELECT s.*, 3.14+1, 1 FROM generate_series('2021-08-17 00:00:00'::timestamp, '2021-08-17 00:02:00'::timestamp, '1 s'::interval) s; SELECT compress_chunk(show_chunks('metric')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_23_17_chunk -- column does not exist the first time ALTER TABLE metric ADD COLUMN IF NOT EXISTS "medium" VARCHAR ; -- column already exists the second time ALTER TABLE metric ADD COLUMN IF NOT EXISTS "medium" VARCHAR ; NOTICE: column "medium" of relation "metric" already exists, skipping -- also add one without IF NOT EXISTS ALTER TABLE metric ADD COLUMN "medium_1" VARCHAR ; ALTER TABLE metric ADD COLUMN "medium_1" VARCHAR ; ERROR: column "medium_1" of relation "metric" already exists --github issue 3481 --GROUP BY error when setting compress_segmentby with an enum column CREATE TYPE an_enum_type AS ENUM ('home', 'school'); CREATE TABLE test ( time timestamp NOT NULL, enum_col an_enum_type NOT NULL ); SELECT create_hypertable( 'test', 'time' ); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices HINT: Use datatype TIMESTAMPTZ instead. create_hypertable -------------------- (25,public,test,t) INSERT INTO test VALUES ('2001-01-01 00:00', 'home'), ('2001-01-01 01:00', 'school'), ('2001-01-01 02:00', 'home'); --enable compression on enum_col ALTER TABLE test SET ( timescaledb.compress, timescaledb.compress_segmentby = 'enum_col', timescaledb.compress_orderby = 'time' ); --below queries will pass before chunks are compressed SELECT 1 FROM test GROUP BY enum_col; ?column? ---------- 1 1 SELECT DISTINCT 1 FROM test; ?column? ---------- 1 --compress chunks SELECT COMPRESS_CHUNK(X) FROM SHOW_CHUNKS('test') X; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_25_19_chunk ANALYZE test; --below query should pass after chunks are compressed SELECT 1 FROM test GROUP BY enum_col; ?column? ---------- 1 1 SELECT DISTINCT 1 FROM test; ?column? ---------- 1 --github issue 4398 SELECT format('CREATE TABLE data_table AS SELECT now() AS tm, %s', array_to_string(array_agg(format('125 AS c%s',a)), ', ')) FROM generate_series(1,550)a \gexec CREATE TABLE data_table AS SELECT now() AS tm, 125 AS c1, 125 AS c2, 125 AS c3, 125 AS c4, 125 AS c5, 125 AS c6, 125 AS c7, 125 AS c8, 125 AS c9, 125 AS c10, 125 AS c11, 125 AS c12, 125 AS c13, 125 AS c14, 125 AS c15, 125 AS c16, 125 AS c17, 125 AS c18, 125 AS c19, 125 AS c20, 125 AS c21, 125 AS c22, 125 AS c23, 125 AS c24, 125 AS c25, 125 AS c26, 125 AS c27, 125 AS c28, 125 AS c29, 125 AS c30, 125 AS c31, 125 AS c32, 125 AS c33, 125 AS c34, 125 AS c35, 125 AS c36, 125 AS c37, 125 AS c38, 125 AS c39, 125 AS c40, 125 AS c41, 125 AS c42, 125 AS c43, 125 AS c44, 125 AS c45, 125 AS c46, 125 AS c47, 125 AS c48, 125 AS c49, 125 AS c50, 125 AS c51, 125 AS c52, 125 AS c53, 125 AS c54, 125 AS c55, 125 AS c56, 125 AS c57, 125 AS c58, 125 AS c59, 125 AS c60, 125 AS c61, 125 AS c62, 125 AS c63, 125 AS c64, 125 AS c65, 125 AS c66, 125 AS c67, 125 AS c68, 125 AS c69, 125 AS c70, 125 AS c71, 125 AS c72, 125 AS c73, 125 AS c74, 125 AS c75, 125 AS c76, 125 AS c77, 125 AS c78, 125 AS c79, 125 AS c80, 125 AS c81, 125 AS c82, 125 AS c83, 125 AS c84, 125 AS c85, 125 AS c86, 125 AS c87, 125 AS c88, 125 AS c89, 125 AS c90, 125 AS c91, 125 AS c92, 125 AS c93, 125 AS c94, 125 AS c95, 125 AS c96, 125 AS c97, 125 AS c98, 125 AS c99, 125 AS c100, 125 AS c101, 125 AS c102, 125 AS c103, 125 AS c104, 125 AS c105, 125 AS c106, 125 AS c107, 125 AS c108, 125 AS c109, 125 AS c110, 125 AS c111, 125 AS c112, 125 AS c113, 125 AS c114, 125 AS c115, 125 AS c116, 125 AS c117, 125 AS c118, 125 AS c119, 125 AS c120, 125 AS c121, 125 AS c122, 125 AS c123, 125 AS c124, 125 AS c125, 125 AS c126, 125 AS c127, 125 AS c128, 125 AS c129, 125 AS c130, 125 AS c131, 125 AS c132, 125 AS c133, 125 AS c134, 125 AS c135, 125 AS c136, 125 AS c137, 125 AS c138, 125 AS c139, 125 AS c140, 125 AS c141, 125 AS c142, 125 AS c143, 125 AS c144, 125 AS c145, 125 AS c146, 125 AS c147, 125 AS c148, 125 AS c149, 125 AS c150, 125 AS c151, 125 AS c152, 125 AS c153, 125 AS c154, 125 AS c155, 125 AS c156, 125 AS c157, 125 AS c158, 125 AS c159, 125 AS c160, 125 AS c161, 125 AS c162, 125 AS c163, 125 AS c164, 125 AS c165, 125 AS c166, 125 AS c167, 125 AS c168, 125 AS c169, 125 AS c170, 125 AS c171, 125 AS c172, 125 AS c173, 125 AS c174, 125 AS c175, 125 AS c176, 125 AS c177, 125 AS c178, 125 AS c179, 125 AS c180, 125 AS c181, 125 AS c182, 125 AS c183, 125 AS c184, 125 AS c185, 125 AS c186, 125 AS c187, 125 AS c188, 125 AS c189, 125 AS c190, 125 AS c191, 125 AS c192, 125 AS c193, 125 AS c194, 125 AS c195, 125 AS c196, 125 AS c197, 125 AS c198, 125 AS c199, 125 AS c200, 125 AS c201, 125 AS c202, 125 AS c203, 125 AS c204, 125 AS c205, 125 AS c206, 125 AS c207, 125 AS c208, 125 AS c209, 125 AS c210, 125 AS c211, 125 AS c212, 125 AS c213, 125 AS c214, 125 AS c215, 125 AS c216, 125 AS c217, 125 AS c218, 125 AS c219, 125 AS c220, 125 AS c221, 125 AS c222, 125 AS c223, 125 AS c224, 125 AS c225, 125 AS c226, 125 AS c227, 125 AS c228, 125 AS c229, 125 AS c230, 125 AS c231, 125 AS c232, 125 AS c233, 125 AS c234, 125 AS c235, 125 AS c236, 125 AS c237, 125 AS c238, 125 AS c239, 125 AS c240, 125 AS c241, 125 AS c242, 125 AS c243, 125 AS c244, 125 AS c245, 125 AS c246, 125 AS c247, 125 AS c248, 125 AS c249, 125 AS c250, 125 AS c251, 125 AS c252, 125 AS c253, 125 AS c254, 125 AS c255, 125 AS c256, 125 AS c257, 125 AS c258, 125 AS c259, 125 AS c260, 125 AS c261, 125 AS c262, 125 AS c263, 125 AS c264, 125 AS c265, 125 AS c266, 125 AS c267, 125 AS c268, 125 AS c269, 125 AS c270, 125 AS c271, 125 AS c272, 125 AS c273, 125 AS c274, 125 AS c275, 125 AS c276, 125 AS c277, 125 AS c278, 125 AS c279, 125 AS c280, 125 AS c281, 125 AS c282, 125 AS c283, 125 AS c284, 125 AS c285, 125 AS c286, 125 AS c287, 125 AS c288, 125 AS c289, 125 AS c290, 125 AS c291, 125 AS c292, 125 AS c293, 125 AS c294, 125 AS c295, 125 AS c296, 125 AS c297, 125 AS c298, 125 AS c299, 125 AS c300, 125 AS c301, 125 AS c302, 125 AS c303, 125 AS c304, 125 AS c305, 125 AS c306, 125 AS c307, 125 AS c308, 125 AS c309, 125 AS c310, 125 AS c311, 125 AS c312, 125 AS c313, 125 AS c314, 125 AS c315, 125 AS c316, 125 AS c317, 125 AS c318, 125 AS c319, 125 AS c320, 125 AS c321, 125 AS c322, 125 AS c323, 125 AS c324, 125 AS c325, 125 AS c326, 125 AS c327, 125 AS c328, 125 AS c329, 125 AS c330, 125 AS c331, 125 AS c332, 125 AS c333, 125 AS c334, 125 AS c335, 125 AS c336, 125 AS c337, 125 AS c338, 125 AS c339, 125 AS c340, 125 AS c341, 125 AS c342, 125 AS c343, 125 AS c344, 125 AS c345, 125 AS c346, 125 AS c347, 125 AS c348, 125 AS c349, 125 AS c350, 125 AS c351, 125 AS c352, 125 AS c353, 125 AS c354, 125 AS c355, 125 AS c356, 125 AS c357, 125 AS c358, 125 AS c359, 125 AS c360, 125 AS c361, 125 AS c362, 125 AS c363, 125 AS c364, 125 AS c365, 125 AS c366, 125 AS c367, 125 AS c368, 125 AS c369, 125 AS c370, 125 AS c371, 125 AS c372, 125 AS c373, 125 AS c374, 125 AS c375, 125 AS c376, 125 AS c377, 125 AS c378, 125 AS c379, 125 AS c380, 125 AS c381, 125 AS c382, 125 AS c383, 125 AS c384, 125 AS c385, 125 AS c386, 125 AS c387, 125 AS c388, 125 AS c389, 125 AS c390, 125 AS c391, 125 AS c392, 125 AS c393, 125 AS c394, 125 AS c395, 125 AS c396, 125 AS c397, 125 AS c398, 125 AS c399, 125 AS c400, 125 AS c401, 125 AS c402, 125 AS c403, 125 AS c404, 125 AS c405, 125 AS c406, 125 AS c407, 125 AS c408, 125 AS c409, 125 AS c410, 125 AS c411, 125 AS c412, 125 AS c413, 125 AS c414, 125 AS c415, 125 AS c416, 125 AS c417, 125 AS c418, 125 AS c419, 125 AS c420, 125 AS c421, 125 AS c422, 125 AS c423, 125 AS c424, 125 AS c425, 125 AS c426, 125 AS c427, 125 AS c428, 125 AS c429, 125 AS c430, 125 AS c431, 125 AS c432, 125 AS c433, 125 AS c434, 125 AS c435, 125 AS c436, 125 AS c437, 125 AS c438, 125 AS c439, 125 AS c440, 125 AS c441, 125 AS c442, 125 AS c443, 125 AS c444, 125 AS c445, 125 AS c446, 125 AS c447, 125 AS c448, 125 AS c449, 125 AS c450, 125 AS c451, 125 AS c452, 125 AS c453, 125 AS c454, 125 AS c455, 125 AS c456, 125 AS c457, 125 AS c458, 125 AS c459, 125 AS c460, 125 AS c461, 125 AS c462, 125 AS c463, 125 AS c464, 125 AS c465, 125 AS c466, 125 AS c467, 125 AS c468, 125 AS c469, 125 AS c470, 125 AS c471, 125 AS c472, 125 AS c473, 125 AS c474, 125 AS c475, 125 AS c476, 125 AS c477, 125 AS c478, 125 AS c479, 125 AS c480, 125 AS c481, 125 AS c482, 125 AS c483, 125 AS c484, 125 AS c485, 125 AS c486, 125 AS c487, 125 AS c488, 125 AS c489, 125 AS c490, 125 AS c491, 125 AS c492, 125 AS c493, 125 AS c494, 125 AS c495, 125 AS c496, 125 AS c497, 125 AS c498, 125 AS c499, 125 AS c500, 125 AS c501, 125 AS c502, 125 AS c503, 125 AS c504, 125 AS c505, 125 AS c506, 125 AS c507, 125 AS c508, 125 AS c509, 125 AS c510, 125 AS c511, 125 AS c512, 125 AS c513, 125 AS c514, 125 AS c515, 125 AS c516, 125 AS c517, 125 AS c518, 125 AS c519, 125 AS c520, 125 AS c521, 125 AS c522, 125 AS c523, 125 AS c524, 125 AS c525, 125 AS c526, 125 AS c527, 125 AS c528, 125 AS c529, 125 AS c530, 125 AS c531, 125 AS c532, 125 AS c533, 125 AS c534, 125 AS c535, 125 AS c536, 125 AS c537, 125 AS c538, 125 AS c539, 125 AS c540, 125 AS c541, 125 AS c542, 125 AS c543, 125 AS c544, 125 AS c545, 125 AS c546, 125 AS c547, 125 AS c548, 125 AS c549, 125 AS c550 CREATE TABLE ts_table (LIKE data_table); SELECT * FROM create_hypertable('ts_table', 'tm'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 27 | public | ts_table | t --should report a warning \set VERBOSITY terse ALTER TABLE ts_table SET(timescaledb.compress, timescaledb.compress_segmentby = 'c1', timescaledb.compress_orderby = 'tm'); WARNING: compressed row size might exceed maximum row size INSERT INTO ts_table SELECT * FROM data_table; --cleanup tables DROP TABLE data_table cascade; DROP TABLE ts_table cascade; -- #5458 invalid reads for row expressions after column dropped on compressed tables CREATE TABLE readings( "time" TIMESTAMPTZ NOT NULL, battery_status TEXT, battery_temperature DOUBLE PRECISION ); INSERT INTO readings ("time") VALUES ('2022-11-11 11:11:11-00'); SELECT create_hypertable('readings', 'time', chunk_time_interval => interval '12 hour', migrate_data=>true); NOTICE: migrating data to chunks create_hypertable ------------------------ (29,public,readings,t) create unique index readings_uniq_idx on readings("time",battery_temperature); ALTER TABLE readings SET (timescaledb.compress,timescaledb.compress_segmentby = 'battery_temperature'); SELECT compress_chunk(show_chunks('readings')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_22_chunk ALTER TABLE readings DROP COLUMN battery_status; INSERT INTO readings ("time", battery_temperature) VALUES ('2022-11-11 11:11:11', 0.2); SELECT readings FROM readings; readings -------------------------------------- ("Fri Nov 11 03:11:11 2022 PST",) ("Fri Nov 11 11:11:11 2022 PST",0.2) -- #5577 On-insert decompression after schema changes may not work properly SELECT decompress_chunk(show_chunks('readings'),true); NOTICE: chunk "_hyper_29_24_chunk" is not converted to columnstore decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_22_chunk SELECT compress_chunk(show_chunks('readings'),true); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_22_chunk _timescaledb_internal._hyper_29_24_chunk \set ON_ERROR_STOP 0 INSERT INTO readings ("time", battery_temperature) VALUES ('2022-11-11 11:11:11',0.2) -- same record as inserted ; ERROR: duplicate key value violates unique constraint "_hyper_29_24_chunk_readings_uniq_idx" \set ON_ERROR_STOP 1 SELECT * from readings; time | battery_temperature ------------------------------+--------------------- Fri Nov 11 03:11:11 2022 PST | Fri Nov 11 11:11:11 2022 PST | 0.2 SELECT assert_equal(count(1), 2::bigint) FROM readings; assert_equal -------------- -- no unique check failure during decompression SELECT decompress_chunk(show_chunks('readings'),true); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_22_chunk _timescaledb_internal._hyper_29_24_chunk -- #5553 Unique constraints are not always respected on compressed tables CREATE TABLE main_table AS SELECT '2011-11-11 11:11:11'::timestamptz AS time, 'foo' AS device_id; CREATE UNIQUE INDEX xm ON main_table(time, device_id); SELECT create_hypertable('main_table', 'time', chunk_time_interval => interval '12 hour', migrate_data => TRUE); NOTICE: migrating data to chunks create_hypertable -------------------------- (31,public,main_table,t) ALTER TABLE main_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id'); SELECT compress_chunk(show_chunks('main_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_31_27_chunk -- insert rejected \set ON_ERROR_STOP 0 INSERT INTO main_table VALUES ('2011-11-11 11:11:11', 'foo'); ERROR: duplicate key value violates unique constraint "_hyper_31_27_chunk_xm" -- insert rejected in case 1st row doesn't violate constraint with different segmentby INSERT INTO main_table VALUES ('2011-11-11 11:12:11', 'bar'), ('2011-11-11 11:11:11', 'foo'); ERROR: duplicate key value violates unique constraint "_hyper_31_27_chunk_xm" \set ON_ERROR_STOP 1 SELECT assert_equal(count(1), 1::bigint) FROM main_table; assert_equal -------------- -- no unique check failure during decompression SELECT decompress_chunk(show_chunks('main_table'), TRUE); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_31_27_chunk DROP TABLE IF EXISTS readings; CREATE TABLE readings( "time" timestamptz NOT NULL, battery_status text, candy integer, battery_status2 text, battery_temperature text ); SELECT create_hypertable('readings', 'time', chunk_time_interval => interval '12 hour'); create_hypertable ------------------------ (33,public,readings,t) CREATE UNIQUE INDEX readings_uniq_idx ON readings("time", battery_temperature); ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'battery_temperature'); ALTER TABLE readings DROP COLUMN battery_status; ALTER TABLE readings DROP COLUMN battery_status2; INSERT INTO readings("time", candy, battery_temperature) VALUES ('2022-11-11 11:11:11', 88, '0.2'); SELECT compress_chunk(show_chunks('readings'), TRUE); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_33_29_chunk -- no error happens INSERT INTO readings("time", candy, battery_temperature) VALUES ('2022-11-11 11:11:11', 33, 0.3) ; -- Segmentby checks should be done for unique indexes without -- constraints, so create a table without constraints and add a unique -- index and try to create a table without using the right segmentby -- column. CREATE TABLE table_unique_index( location smallint not null, device_id smallint not null, time timestamptz not null, value float8 not null ); CREATE UNIQUE index ON table_unique_index(location, device_id, time); SELECT table_name FROM create_hypertable('table_unique_index', 'time'); table_name -------------------- table_unique_index -- Will warn because the lack of segmentby/orderby compression options ALTER TABLE table_unique_index SET (timescaledb.compress); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'location'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_orderby = 'device_id', timescaledb.compress_segmentby = ''); WARNING: column "location" should be used for segmenting or ordering ALTER TABLE table_unique_index SET (timescaledb.compress = off); -- Will enable compression without warnings ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'device_id'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id,location'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby='', timescaledb.compress_orderby = 'device_id,location'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'time,location', timescaledb.compress_orderby = 'device_id'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'time,location,device_id'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); -- try compressing osm chunk CREATE TABLE osm_table (time timestamptz NOT NULL, device_id text, value float); SELECT table_name FROM create_hypertable('osm_table', 'time'); table_name ------------ osm_table ALTER TABLE osm_table SET (timescaledb.compress); INSERT INTO osm_table VALUES ('2022-11-11 11:11:11', 'foo', 1.0); SELECT format('%I.%I',chunk_schema,chunk_name) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'osm_table' ORDER BY chunk_name LIMIT 1 \gset UPDATE _timescaledb_catalog.chunk ch SET osm_chunk = true FROM _timescaledb_catalog.hypertable ht WHERE ch.hypertable_id = ht.id AND ht.table_name='osm_table'; -- show_chunks should not show any OSM chunks SELECT show_chunks('osm_table'); show_chunks ------------- SELECT compress_chunk(:'CHUNK_NAME'); ERROR: compress_chunk not permitted on tiered chunk "_hyper_44_31_chunk" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_fks.out��������������������������������������������0000664�0000000�0000000�00000003673�15100345067�0023403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test foreign key constraints with compression CREATE TABLE keys(time timestamptz unique); CREATE TABLE ht_with_fk(time timestamptz); SELECT create_hypertable('ht_with_fk','time'); create_hypertable ------------------------- (1,public,ht_with_fk,t) ALTER TABLE ht_with_fk ADD CONSTRAINT keys FOREIGN KEY (time) REFERENCES keys(time) ON DELETE CASCADE; ALTER TABLE ht_with_fk SET (timescaledb.compress,timescaledb.compress_segmentby='time'); -- no keys added yet so any insert into ht_with_fk should fail \set ON_ERROR_STOP 0 INSERT INTO ht_with_fk SELECT '2000-01-01'; ERROR: insert or update on table "_hyper_1_1_chunk" violates foreign key constraint "1_1_keys" \set ON_ERROR_STOP 1 -- create a key in the referenced table INSERT INTO keys SELECT '2000-01-01'; -- now the insert should succeed INSERT INTO ht_with_fk SELECT '2000-01-01'; SELECT compress_chunk(ch) FROM show_chunks('ht_with_fk') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- insert should still succeed after compression INSERT INTO ht_with_fk SELECT '2000-01-01'; -- inserting key not present in keys should fail \set ON_ERROR_STOP 0 INSERT INTO ht_with_fk SELECT '2000-01-01 0:00:01'; ERROR: insert or update on table "_hyper_1_2_chunk" violates foreign key constraint "2_2_keys" \set ON_ERROR_STOP 1 SELECT conrelid::regclass,conname,confrelid::regclass FROM pg_constraint WHERE contype = 'f' AND confrelid = 'keys'::regclass ORDER BY conrelid::regclass::text COLLATE "C",conname; conrelid | conname | confrelid ----------------------------------------+----------+----------- _timescaledb_internal._hyper_1_2_chunk | 2_2_keys | keys ht_with_fk | keys | keys ���������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_hypertable.out�������������������������������������0000664�0000000�0000000�00000054121�15100345067�0024751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/rand_generator.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------- -- cheap rand generator -- -------------------------- create table rand_minstd_state(i bigint); create function rand_minstd_advance(bigint) returns bigint language sql immutable as $$ select (16807 * $1) % 2147483647 $$; create function gen_rand_minstd() returns bigint language sql security definer as $$ update rand_minstd_state set i = rand_minstd_advance(i) returning i $$; -- seed the random num generator insert into rand_minstd_state values (321); \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors CREATE TYPE customtype; SET client_min_messages TO WARNING; CREATE OR REPLACE FUNCTION customtype_in(cstring) RETURNS customtype AS :TSL_MODULE_PATHNAME, 'ts_compression_custom_type_in' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_out(customtype) RETURNS cstring AS :TSL_MODULE_PATHNAME, 'ts_compression_custom_type_out' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_eq(customtype, customtype) RETURNS BOOL AS :TSL_MODULE_PATHNAME, 'ts_compression_custom_type_eq' LANGUAGE C IMMUTABLE STRICT; SET client_min_messages TO DEFAULT; -- for testing purposes we need a fixed length pass-by-ref type, and one whose -- alignment is greater than it's size. This type serves both purposes. CREATE TYPE customtype ( INPUT = customtype_in, OUTPUT = customtype_out, INTERNALLENGTH = 2, ALIGNMENT = double, STORAGE = plain ); create operator = ( leftarg = customtype, rightarg = customtype, procedure = customtype_eq, commutator = = ); CREATE OPERATOR CLASS customtype_ops DEFAULT FOR TYPE customtype USING hash AS OPERATOR 1 =; SELECT count(delete_job(job_id)) from timescaledb_information.jobs ; count ------- 2 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1 ("Time" timestamptz, i integer, b bigint, t text); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test1 INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = '"Time" DESC'); \set QUERY 'SELECT * FROM test1' \set QUERY_ORDER 'ORDER BY "Time"' \set HYPERTABLE_NAME 'test1' \ir include/compression_test_hypertable.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors psql:include/compression_test_hypertable.sql:7: NOTICE: table "original_result" does not exist, skipping count compress ---------------- 27 timescaledb_pre_restore ------------------------- t timescaledb_post_restore -------------------------- t original | decompressed ----------+-------------- count decompress ------------------ 27 table | diff between original and compressed/decompressed -------+--------------------------------------------------- test1 | 0 \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 27 min_correct | max_correct -------------+------------- t | t -- check stats SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid = '_timescaledb_internal._compressed_hypertable_2'::REGCLASS AND attnum > 0 ORDER BY attname; attname | attstattarget ---------+--------------- SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid in (SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = 2) AND attnum > 0 ORDER BY attname; attname | attstattarget ----------------+--------------- Time | 0 _ts_meta_count | 1000 _ts_meta_max_1 | 1000 _ts_meta_min_1 | 1000 b | 0 i | 0 t | 0 -- Test that the GUC to disable bulk decompression works. vacuum analyze test1; explain (analyze, verbose, timing off, buffers off, costs off, summary off) select * from _timescaledb_internal._hyper_1_10_chunk; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk (actual rows=24.00 loops=1) Output: _hyper_1_10_chunk."Time", _hyper_1_10_chunk.i, _hyper_1_10_chunk.b, _hyper_1_10_chunk.t Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_55_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_55_chunk._ts_meta_count, compress_hyper_2_55_chunk._ts_meta_min_1, compress_hyper_2_55_chunk._ts_meta_max_1, compress_hyper_2_55_chunk."Time", compress_hyper_2_55_chunk.i, compress_hyper_2_55_chunk.b, compress_hyper_2_55_chunk.t set timescaledb.enable_bulk_decompression to false; explain (analyze, verbose, timing off, buffers off, costs off, summary off) select * from _timescaledb_internal._hyper_1_10_chunk; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk (actual rows=24.00 loops=1) Output: _hyper_1_10_chunk."Time", _hyper_1_10_chunk.i, _hyper_1_10_chunk.b, _hyper_1_10_chunk.t Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_2_55_chunk (actual rows=1.00 loops=1) Output: compress_hyper_2_55_chunk._ts_meta_count, compress_hyper_2_55_chunk._ts_meta_min_1, compress_hyper_2_55_chunk._ts_meta_max_1, compress_hyper_2_55_chunk."Time", compress_hyper_2_55_chunk.i, compress_hyper_2_55_chunk.b, compress_hyper_2_55_chunk.t reset timescaledb.enable_bulk_decompression; TRUNCATE test1; /* should be no data in table */ SELECT * FROM test1; Time | i | b | t ------+---+---+--- /* nor compressed table */ SELECT * FROM _timescaledb_internal._compressed_hypertable_2; -- /* the compressed table should not have chunks */ SELECT count(*) FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2; count ------- 0 --add test for altered hypertable CREATE TABLE test2 ("Time" timestamptz, i integer, b bigint, t text); SELECT table_name from create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 day'); table_name ------------ test2 --create some chunks with the old column numbers INSERT INTO test2 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-04 1:00', '1 hour') t; ALTER TABLE test2 DROP COLUMN b; --add default a value ALTER TABLE test2 ADD COLUMN c INT DEFAULT -15; --add default NULL ALTER TABLE test2 ADD COLUMN d INT; --write to both old chunks and new chunks with different column #s INSERT INTO test2 SELECT t, gen_rand_minstd(), gen_rand_minstd()::text, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-06 1:00', '1 hour') t; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'c, "Time" DESC'); \set QUERY 'SELECT * FROM test2' \set QUERY_ORDER 'ORDER BY c,"Time"' \set HYPERTABLE_NAME 'test2' \ir include/compression_test_hypertable.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count compress ---------------- 5 timescaledb_pre_restore ------------------------- t timescaledb_post_restore -------------------------- t original | decompressed ----------+-------------- count decompress ------------------ 5 table | diff between original and compressed/decompressed -------+--------------------------------------------------- test2 | 0 \set TYPE int \set ORDER_BY_COL_NAME c \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 5 min_correct | max_correct -------------+------------- t | t \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_2 \set SEGMENT_META_COL_MAX _ts_meta_max_2 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors psql:include/compression_test_hypertable_segment_meta.sql:10: NOTICE: chunk "_hyper_3_82_chunk" is already converted to columnstore psql:include/compression_test_hypertable_segment_meta.sql:10: NOTICE: chunk "_hyper_3_83_chunk" is already converted to columnstore psql:include/compression_test_hypertable_segment_meta.sql:10: NOTICE: chunk "_hyper_3_84_chunk" is already converted to columnstore psql:include/compression_test_hypertable_segment_meta.sql:10: NOTICE: chunk "_hyper_3_85_chunk" is already converted to columnstore psql:include/compression_test_hypertable_segment_meta.sql:10: NOTICE: chunk "_hyper_3_86_chunk" is already converted to columnstore count ------- 5 min_correct | max_correct -------------+------------- t | t --TEST4 create segments with > 1000 rows. CREATE TABLE test4 ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); --we want all the data to go into 1 chunk. so use 1 year chunk interval select create_hypertable( 'test4', 'timec', chunk_time_interval=> '1 year'::interval); create_hypertable -------------------- (5,public,test4,t) alter table test4 set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into test4 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-31 00:00'::timestamp, '1 day'), 'NYC', 'klick', 55, 75; insert into test4 select generate_series('2018-02-01 00:00'::timestamp, '2018-02-14 00:00'::timestamp, '1 min'), 'POR', 'klick', 55, 75; select hypertable_name, num_chunks from timescaledb_information.hypertables where hypertable_name like 'test4'; hypertable_name | num_chunks -----------------+------------ test4 | 1 select location, count(*) from test4 group by location ORDER BY location; location | count ----------+------- NYC | 31 POR | 18721 \set QUERY 'SELECT * FROM test4' \set QUERY_ORDER 'ORDER BY timec' \set HYPERTABLE_NAME 'test4' \ir include/compression_test_hypertable.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count compress ---------------- 1 timescaledb_pre_restore ------------------------- t timescaledb_post_restore -------------------------- t original | decompressed ----------+-------------- count decompress ------------------ 1 table | diff between original and compressed/decompressed -------+--------------------------------------------------- test4 | 0 \set TYPE TIMESTAMPTZ \set ORDER_BY_COL_NAME timec \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 1 min_correct | max_correct -------------+------------- t | t -- check stats with segmentby SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid = '_timescaledb_internal._compressed_hypertable_6'::REGCLASS AND attnum > 0 ORDER BY attname; attname | attstattarget ---------+--------------- SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid in (SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = 6) AND attnum > 0 ORDER BY attname; attname | attstattarget ----------------+--------------- _ts_meta_count | 1000 _ts_meta_max_1 | 1000 _ts_meta_min_1 | 1000 humidity | 0 location | 1000 location2 | 0 temperature | 0 timec | 0 --add hypertable with order by a non by-val type with NULLs CREATE TABLE test5 ( time TIMESTAMPTZ NOT NULL, device_id TEXT NULL, temperature DOUBLE PRECISION NULL ); --we want all the data to go into 1 chunk. so use 1 year chunk interval select create_hypertable( 'test5', 'time', chunk_time_interval=> '1 day'::interval); create_hypertable -------------------- (7,public,test5,t) alter table test5 set (timescaledb.compress, timescaledb.compress_orderby = 'device_id, time'); insert into test5 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_1', gen_rand_minstd(); insert into test5 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_2', gen_rand_minstd(); insert into test5 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), NULL, gen_rand_minstd(); \set QUERY 'SELECT * FROM test5' \set QUERY_ORDER 'ORDER BY device_id, time' \set HYPERTABLE_NAME 'test5' \ir include/compression_test_hypertable.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count compress ---------------- 10 timescaledb_pre_restore ------------------------- t timescaledb_post_restore -------------------------- t original | decompressed ----------+-------------- count decompress ------------------ 10 table | diff between original and compressed/decompressed -------+--------------------------------------------------- test5 | 0 \set TYPE TEXT \set ORDER_BY_COL_NAME device_id \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 10 min_correct | max_correct -------------+------------- t | t TRUNCATE test5; SELECT * FROM test5; time | device_id | temperature ------+-----------+------------- -- test 6, test with custom type, and NULLs in the segmentby CREATE table test6( time INT NOT NULL, device_id INT, data customtype ); SELECT create_hypertable('test6', 'time', chunk_time_interval=> 50); create_hypertable -------------------- (9,public,test6,t) ALTER TABLE test6 SET (timescaledb.compress, timescaledb.compress_segmentby='device_id', timescaledb.compress_orderby = 'time DESC'); INSERT INTO test6 SELECT t, d, customtype_in((t + d)::TEXT::cstring) FROM generate_series(1, 200) t, generate_series(1, 3) d; INSERT INTO test6 SELECT t, NULL, customtype_in(t::TEXT::cstring) FROM generate_series(1, 200) t; \set QUERY 'SELECT * FROM test6' \set QUERY_ORDER 'ORDER BY device_id, time' \set HYPERTABLE_NAME 'test6' \ir include/compression_test_hypertable.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count compress ---------------- 5 timescaledb_pre_restore ------------------------- t timescaledb_post_restore -------------------------- t original | decompressed ----------+-------------- count decompress ------------------ 5 table | diff between original and compressed/decompressed -------+--------------------------------------------------- test6 | 0 \set TYPE INT \set ORDER_BY_COL_NAME time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 5 min_correct | max_correct -------------+------------- t | t DROP TABLE test6; -- test 7, compress misc types, and NULLs in dictionaries CREATE TABLE test7(time INT, c1 DATE, c2 TIMESTAMP, c3 FLOAT, n TEXT); SELECT create_hypertable('test7', 'time', chunk_time_interval=> 200); WARNING: column type "timestamp without time zone" used for "c2" does not follow best practices create_hypertable --------------------- (11,public,test7,t) ALTER TABLE test7 SET (timescaledb.compress, timescaledb.compress_orderby = 'time DESC, c1 DESC'); INSERT INTO test7 SELECT t, d, '2019/07/07 01:00', gen_rand_minstd(), 'a' FROM generate_series(1, 10) t, generate_series('2019/02/01'::DATE, '2019/02/10', '1d') d; INSERT INTO test7 SELECT t, d, '2019/07/07 01:30', gen_rand_minstd(), NULL FROM generate_series(10, 20) t, generate_series('2019/03/01'::DATE, '2019/03/10', '1d') d; \set QUERY 'SELECT * FROM test7' \set QUERY_ORDER 'ORDER BY time, c1' \set HYPERTABLE_NAME 'test7' \ir include/compression_test_hypertable.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count compress ---------------- 1 timescaledb_pre_restore ------------------------- t timescaledb_post_restore -------------------------- t original | decompressed ----------+-------------- count decompress ------------------ 1 table | diff between original and compressed/decompressed -------+--------------------------------------------------- test7 | 0 \set TYPE INT \set ORDER_BY_COL_NAME time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 1 min_correct | max_correct -------------+------------- t | t DROP TABLE test7; -- helper function: float -> pseudorandom float [0..1]. create or replace function mix(x float4) returns float4 as $$ select ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ language sql; -- test gorilla for float4 and deltadelta for int32 and other types create table test8(ts date, id int, value float4, valueint2 int2, valuebool bool); select create_hypertable('test8', 'ts'); create_hypertable --------------------- (13,public,test8,t) alter table test8 set (timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'ts desc') ; insert into test8 select '2022-02-02 02:02:02+03'::timestamptz + interval '1 month' * mix(x), mix(x + 1.) * 20, mix(x + 2.) * 50, mix(x + 3.) * 100, mix(x + 4.) > 0.1 from generate_series(1, 10000) x(x) ; select compress_chunk(x) from show_chunks('test8') x; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_13_148_chunk _timescaledb_internal._hyper_13_149_chunk _timescaledb_internal._hyper_13_150_chunk _timescaledb_internal._hyper_13_151_chunk _timescaledb_internal._hyper_13_152_chunk _timescaledb_internal._hyper_13_153_chunk select distinct on (id) * from test8 order by id, ts desc, value ; ts | id | value | valueint2 | valuebool ------------+----+----------+-----------+----------- 03-03-2022 | 0 | 9.49871 | 97 | t 03-03-2022 | 1 | 2.96871 | 8 | t 03-03-2022 | 2 | 4.17897 | 33 | f 03-03-2022 | 3 | 8.08533 | 96 | t 03-03-2022 | 4 | 16.959 | 46 | f 03-03-2022 | 5 | 2.10652 | 20 | t 03-03-2022 | 6 | 6.77508 | 58 | t 03-03-2022 | 7 | 4.64613 | 56 | t 03-03-2022 | 8 | 2.66474 | 82 | t 03-03-2022 | 9 | 2.59844 | 56 | t 03-03-2022 | 10 | 1.21461 | 44 | t 03-03-2022 | 11 | 6.70618 | 84 | t 03-03-2022 | 12 | 1.52959 | 18 | t 03-03-2022 | 13 | 5.20262 | 84 | t 03-03-2022 | 14 | 2.92403 | 15 | t 03-03-2022 | 15 | 1.70258 | 82 | t 03-03-2022 | 16 | 11.6858 | 43 | t 03-03-2022 | 17 | 11.4363 | 14 | t 03-03-2022 | 18 | 0.496188 | 59 | t 03-03-2022 | 19 | 4.7812 | 51 | t 03-03-2022 | 20 | 8.25849 | 30 | t drop table test8; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_indexcreate.out������������������������������������0000664�0000000�0000000�00000014072�15100345067�0025106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- force index scan to be used when possible set enable_seqscan to false; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, summary off, timing off) ' create table segind(time timestamptz, a int, b int); select create_hypertable('segind', by_range('time')); create_hypertable ------------------- (1,t) -- enable compression on hypertable with no segment by column alter table segind set (timescaledb.compress, timescaledb.compress_segmentby='', timescaledb.compress_orderby='time, b'); insert into segind values('2024-11-08 10:31:28.436014-07', 1, 1), ('2024-11-08 10:32:28.436014-07', 2, 1), ('2024-11-08 10:33:28.436014-07', 3, 1), ('2024-11-08 10:34:28.436014-07', 2, 1), ('2024-11-08 10:35:28.436014-07', 1, 2), ('2024-11-08 10:36:28.436014-07', 4, 1); -- compress chunk -- this should create an index using orderby columns select compress_chunk(show_chunks('segind')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk vacuum analyze segind; -- query using orderby columns should use the index :PREFIX select * from segind where b = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) Vectorized Filter: (b = 1) Rows Removed by Filter: 1 -> Index Scan using compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1__ts__idx on compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Index Cond: ((_ts_meta_min_2 <= 1) AND (_ts_meta_max_2 >= 1)) :PREFIX select * from segind where time = '2024-11-08 10:32:28.436014-07'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1__ts__idx on compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone)) :PREFIX select * from segind where b = 1 and time = '2024-11-08 10:32:28.436014-07'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: ((b = 1) AND ("time" = 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1__ts__idx on compress_hyper_2_2_chunk (actual rows=1.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) AND (_ts_meta_min_2 <= 1) AND (_ts_meta_max_2 >= 1)) -- a query on another column should perform a seq scan since there is no index on it :PREFIX select * from segind where a = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) Vectorized Filter: (a = 1) Rows Removed by Filter: 4 -> Seq Scan on compress_hyper_2_2_chunk (actual rows=1.00 loops=1) -- decompress the chunk to drop the index select decompress_chunk(show_chunks('segind')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- change compression settings to use segmentby column alter table segind set (timescaledb.compress, timescaledb.compress_segmentby='a', timescaledb.compress_orderby='time, b'); -- compress chunk -- this should create an index using segmentby and orderby columns select compress_chunk(show_chunks('segind')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk vacuum analyze segind; -- queries using segmentby or orderby columns should use the index :PREFIX select * from segind where b = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) Vectorized Filter: (b = 1) Rows Removed by Filter: 1 -> Index Scan using compress_hyper_2_3_chunk_a__ts_meta_min_1__ts_meta_max_1__t_idx on compress_hyper_2_3_chunk (actual rows=4.00 loops=1) Index Cond: ((_ts_meta_min_2 <= 1) AND (_ts_meta_max_2 >= 1)) :PREFIX select * from segind where time = '2024-11-08 10:32:28.436014-07'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Index Scan using compress_hyper_2_3_chunk_a__ts_meta_min_1__ts_meta_max_1__t_idx on compress_hyper_2_3_chunk (actual rows=2.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone)) :PREFIX select * from segind where b = 1 and time = '2024-11-08 10:32:28.436014-07'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Vectorized Filter: ((b = 1) AND ("time" = 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone)) Rows Removed by Filter: 3 -> Index Scan using compress_hyper_2_3_chunk_a__ts_meta_min_1__ts_meta_max_1__t_idx on compress_hyper_2_3_chunk (actual rows=2.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Nov 08 09:32:28.436014 2024 PST'::timestamp with time zone) AND (_ts_meta_min_2 <= 1) AND (_ts_meta_max_2 >= 1)) :PREFIX select * from segind where a = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_2_3_chunk_a__ts_meta_min_1__ts_meta_max_1__t_idx on compress_hyper_2_3_chunk (actual rows=1.00 loops=1) Index Cond: (a = 1) -- cleanup RESET enable_seqscan; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_indexscan.out��������������������������������������0000664�0000000�0000000�00000134251�15100345067�0024571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --Enable compression path info SET timescaledb.debug_compression_path_info= 'on'; --Table creation CREATE TABLE tab1 ( time timestamptz not null, id integer not null, c1 double precision null, c2 double precision null ); CREATE TABLE tab2 ( time timestamptz not null, id integer not null, c1 double precision null, c2 double precision null ); --Hypertable creation SELECT FROM create_hypertable('tab1', 'time'); -- SELECT FROM create_hypertable('tab2', 'time'); -- --Data generation INSERT INTO tab1 SELECT time + (INTERVAL '1 minute' * random()) AS time, id, random() AS c1, random()* 100 AS c2 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') AS g1(time), generate_series(1, 100, 1 ) AS g2(id) ORDER BY time; --Test with indexscan enabled SET timescaledb.enable_compression_indexscan = 'ON'; --Test Set 1.1 [ Index(ASC, Null_First), Compression(ASC, Null_First) ] CREATE INDEX idx_asc_null_first ON tab1(id, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | t SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_idx_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_idx_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_idx_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_idx_asc_null_first" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 1.1 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 1.2 [Index(ASC, Null_First), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 1.2 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 1.3 [Index(ASC, Null_First), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | t SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 1.3 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --DROP INDEX idx_asc_null_last --Test Set 1.4 [Index(ASC, Null_First), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 1.4 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_asc_null_first; --Test Set 2.1 [Index(ASC, Null_Last), Compression(ASC,Null_First)] CREATE INDEX idx_asc_null_last ON tab1(id, time); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | t SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 2.1 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 2.2 [Index(ASC, Null_Last), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | f SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_idx_asc_null_last" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_idx_asc_null_last" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_idx_asc_null_last" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_idx_asc_null_last" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 2.2 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 2.3 [Index(ASC, Null_Last), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | t SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 2.3 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --DROP INDEX idx_asc_null_last --Test Set 2.4 [Index(ASC, Null_Last), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 2.4 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_asc_null_last; --Test Set 3.1 [Index(DESC, Null_First), Compression(ASC,Null_First)] CREATE INDEX idx_desc_null_first ON tab1(id, time DESC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | t SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 3.1 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 3.2 [Index(DESC, Null_First), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 3.2 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 3.3 [Index(DESC, Null_First), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | t SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_idx_desc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_idx_desc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_idx_desc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_idx_desc_null_first" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 3.3 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --DROP INDEX idx_asc_null_last --Test Set 3.4 [Index(DESC, Null_First), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 3.4 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_desc_null_first; --Test Set 4.1 [Index(DESC, Null_Last), Compression(ASC,Null_First)] CREATE INDEX idx_desc_null_last ON tab1(id, time DESC); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | t SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 4.1 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 4.2 [Index(DESC, Null_Last), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | t | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 4.2 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 4.3 [Index(DESC, Null_Last), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | t SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_idx_desc_null_last" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_idx_desc_null_last" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_idx_desc_null_last" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_idx_desc_null_last" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 4.3 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 4.4 [Index(DESC, Null_Last), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; hypertable_schema | hypertable_name | attname | segmentby_column_index | orderby_column_index | orderby_asc | orderby_nullsfirst -------------------+-----------------+---------+------------------------+----------------------+-------------+-------------------- public | tab1 | id | 1 | | | public | tab1 | time | | 1 | f | f SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'time'); SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_tab1_time_idx" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_tab1_time_idx" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_tab1_time_idx" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_tab1_time_idx" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Cleanup 4.4 SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_desc_null_last; --Test Set 5 GUC SET timescaledb.enable_compression_indexscan -- Default this flag will be false. RESET timescaledb.enable_compression_indexscan; SHOW timescaledb.enable_compression_indexscan; timescaledb.enable_compression_indexscan ------------------------------------------ off SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test with this guc enabled SET timescaledb.enable_compression_indexscan = 'ON'; SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_tab1_time_idx" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_tab1_time_idx" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_tab1_time_idx" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_tab1_time_idx" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk --Test Set 6 Compare two compression paths INSERT into tab2 SELECT * from tab1; CREATE INDEX idx_asc_null_first ON tab1(id, time ASC NULLS FIRST); CREATE INDEX idx2_asc_null_first ON tab2(id, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); ALTER TABLE tab2 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); RESET timescaledb.enable_compression_indexscan; SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SET timescaledb.enable_compression_indexscan = 'ON'; SELECT compress_chunk(show_chunks('tab2')); INFO: using index "_hyper_2_81_chunk_idx2_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_2_82_chunk_idx2_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_2_83_chunk_idx2_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_2_84_chunk_idx2_asc_null_first" to scan rows for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_81_chunk _timescaledb_internal._hyper_2_82_chunk _timescaledb_internal._hyper_2_83_chunk _timescaledb_internal._hyper_2_84_chunk SELECT id, time from tab1 EXCEPT SELECT id, time from tab2; id | time ----+------ SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab2')); decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_81_chunk _timescaledb_internal._hyper_2_82_chunk _timescaledb_internal._hyper_2_83_chunk _timescaledb_internal._hyper_2_84_chunk DROP INDEX idx2_asc_null_first; DROP INDEX idx_asc_null_first; --Test Set 7.1 with Collation order_by \set ON_ERROR_STOP 1 CREATE TABLE tab3 ( name text, time timestamptz not null ); SELECT FROM create_hypertable('tab3', 'time'); -- --Data generation INSERT INTO tab3 SELECT name, time + (INTERVAL '1 minute' * random()) AS time FROM md5(random()::text) as name, generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') AS g1(time) ORDER BY time; CREATE INDEX idx_asc_null_first ON tab3(name COLLATE "C", time ASC NULLS FIRST); ALTER TABLE tab3 SET(timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'name, time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab3')); INFO: using tuplesort to scan rows from "_hyper_5_93_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_5_94_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_5_95_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_5_96_chunk" for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk SELECT decompress_chunk(show_chunks('tab3')); decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk CREATE INDEX idxcol_asc_null_first ON tab3(name, time ASC NULLS FIRST); SELECT compress_chunk(show_chunks('tab3')); INFO: using index "_hyper_5_93_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_5_94_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_5_95_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_5_96_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk SELECT decompress_chunk(show_chunks('tab3')); decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk DROP INDEX idx_asc_null_first; DROP INDEX idxcol_asc_null_first; --Test Set 7.1 with Collation segment_by CREATE INDEX idx_asc_null_first ON tab3(name COLLATE "ucs_basic", time ASC NULLS FIRST); ALTER TABLE tab3 SET(timescaledb.compress, timescaledb.compress_segmentby = 'name', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab3')); INFO: using tuplesort to scan rows from "_hyper_5_93_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_5_94_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_5_95_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_5_96_chunk" for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk SELECT decompress_chunk(show_chunks('tab3')); decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk CREATE INDEX idxcol_asc_null_first ON tab3(name, time ASC NULLS FIRST); SELECT compress_chunk(show_chunks('tab3')); INFO: using index "_hyper_5_93_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_5_94_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_5_95_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_5_96_chunk_idxcol_asc_null_first" to scan rows for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk SELECT decompress_chunk(show_chunks('tab3')); decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_93_chunk _timescaledb_internal._hyper_5_94_chunk _timescaledb_internal._hyper_5_95_chunk _timescaledb_internal._hyper_5_96_chunk DROP INDEX idx_asc_null_first; DROP INDEX idxcol_asc_null_first; --Test Set 8 with multiple segment_by CREATE INDEX idx_asc_null_first ON tab1(id, c1, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id, c1', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab1')); INFO: using index "_hyper_1_1_chunk_idx_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_2_chunk_idx_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_3_chunk_idx_asc_null_first" to scan rows for converting to columnstore INFO: using index "_hyper_1_4_chunk_idx_asc_null_first" to scan rows for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_asc_null_first; CREATE INDEX idx_asc_null_first ON tab1(id, c1 DESC, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id, c1', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_asc_null_first; --Test Set 9 --Last Column mismatch CREATE INDEX idx_asc_null_first ON tab1(id, c1, c2); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id, c1', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_asc_null_first; --Index Column out of order CREATE INDEX idx_asc_null_first ON tab1(c1, id, time ASC NULLS FIRST); SELECT compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk SELECT decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk DROP INDEX idx_asc_null_first; -- Can't use partial indexes for compression because they refer only to a subset of the table. create index predicate on tab1(id, c1, time nulls first) where c2 = 0; select count(*) from tab1; count ------- 62400 select compress_chunk(show_chunks('tab1')); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_3_chunk" for converting to columnstore INFO: using tuplesort to scan rows from "_hyper_1_4_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk select decompress_chunk(show_chunks('tab1')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk select count(*) from tab1; count ------- 62400 -- Check compression progression messages SET client_min_messages TO LOG; select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); LOG: statement: select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk RESET client_min_messages; LOG: statement: RESET client_min_messages; -- Analyze and use stats now on a larger data set INSERT INTO tab1 SELECT time + (INTERVAL '1 minute' * random()) AS time, id, random() AS c1, random()* 100 AS c2 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '5 minutes') AS g1(time), generate_series(1, 100, 1 ) AS g2(id) ORDER BY time; ANALYZE _timescaledb_internal._hyper_1_2_chunk; SET client_min_messages TO LOG; select compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); LOG: statement: select compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); INFO: using tuplesort to scan rows from "_hyper_1_2_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk RESET client_min_messages; LOG: statement: RESET client_min_messages; drop index predicate; --Tear down DROP TABLE tab1; DROP TABLE tab2; DROP TABLE tab3; SET timescaledb.debug_compression_path_info = 'off'; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_insert.out�����������������������������������������0000664�0000000�0000000�00000166723�15100345067�0024132�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; \set PREFIX 'EXPLAIN (buffers off, costs off, summary off, timing off) ' \set ANALYZE 'EXPLAIN (analyze, buffers off, costs off, summary off, timing off) ' CREATE TABLE test1 (timec timestamptz , i integer , b bigint, t text); SELECT table_name from create_hypertable('test1', 'timec', chunk_time_interval=> INTERVAL '7 days'); table_name ------------ test1 INSERT INTO test1 SELECT q, 10, 11, 'hello' FROM generate_series( '2020-01-03 10:00:00-05', '2020-01-03 12:00:00-05' , '5 min'::interval) q; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); SELECT compress_chunk(c) FROM show_chunks('test1') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT count(*) FROM test1; count ------- 25 --we have 1 compressed row -- SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 -- single and multi row insert into the compressed chunk -- INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , 11, 16, 'new' ; SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , i, i +5, 'clay' FROM (Select generate_series(10, 20, 1) i ) q; SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 SELECT count(*) from test1; count ------- 37 -- single row copy COPY test1 FROM STDIN DELIMITER ','; SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 -- multi row copy COPY test1 FROM STDIN DELIMITER ','; SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 --Verify that all the data went into the initial chunk SELECT count(*) FROM show_chunks('test1') c; count ------- 1 SELECT * FROM test1 WHERE b = 11 order by i, timec ; timec | i | b | t ------------------------------+----+----+------- Fri Jan 03 07:00:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:05:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:10:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:15:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:20:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:25:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:30:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:35:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:40:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:45:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:50:00 2020 PST | 10 | 11 | hello Fri Jan 03 07:55:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:00:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:05:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:10:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:15:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:20:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:25:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:30:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:35:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:40:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:45:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:50:00 2020 PST | 10 | 11 | hello Fri Jan 03 08:55:00 2020 PST | 10 | 11 | hello Fri Jan 03 09:00:00 2020 PST | 10 | 11 | hello SELECT * FROM test1 WHERE i = 11 order by 1, 2, 3, 4; timec | i | b | t ------------------------------+----+----+----------- Thu Jan 02 08:16:00 2020 PST | 11 | 16 | clay Thu Jan 02 08:16:00 2020 PST | 11 | 16 | copy Thu Jan 02 08:16:00 2020 PST | 11 | 16 | multicopy Thu Jan 02 08:16:00 2020 PST | 11 | 16 | new -- insert nulls except for timec INSERT INTO test1 SELECT '2020-01-02 11:46:00-05' , NULL, NULL, NULL; SELECT count(*) FROM show_chunks('test1') c; count ------- 1 -- copy NULL COPY test1 FROM STDIN DELIMITER ',' NULL 'NULL'; SELECT count(*) FROM show_chunks('test1') c; count ------- 1 SELECT * from test1 WHERE i is NULL; timec | i | b | t ------------------------------+---+---+--- Thu Jan 02 08:46:00 2020 PST | | | Thu Jan 02 08:46:00 2020 PST | | | --TEST 2 now alter the table and add a new column to it ALTER TABLE test1 ADD COLUMN newtcol varchar(400); --add rows with segments that overlap some of the previous ones SELECT count(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , 100, 101, 'prev101', 'this is the newtcol101'; INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , i, 16, 'prev16', 'this is the newtcol16' FROM (Select generate_series(11, 16, 1) i ) q; SELECT * FROM test1 WHERE b = 16 order by 1, 2, 3, 4, 5; timec | i | b | t | newtcol ------------------------------+----+----+-----------+----------------------- Thu Jan 02 08:16:00 2020 PST | 11 | 16 | clay | Thu Jan 02 08:16:00 2020 PST | 11 | 16 | copy | Thu Jan 02 08:16:00 2020 PST | 11 | 16 | multicopy | Thu Jan 02 08:16:00 2020 PST | 11 | 16 | new | Thu Jan 02 08:16:00 2020 PST | 11 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 12 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 13 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 14 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 15 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 16 | 16 | prev16 | this is the newtcol16 --number of rows in the chunk SELECT count(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 SELECT count(*) FROM show_chunks('test1') c; count ------- 1 COPY test1 FROM STDIN DELIMITER ','; COPY test1 FROM STDIN DELIMITER ','; --number of rows in the chunk SELECT count(*) from _timescaledb_internal.compress_hyper_2_2_chunk; count ------- 1 SELECT count(*) FROM show_chunks('test1') c; count ------- 1 SELECT * FROM test1 WHERE newtcol IS NOT NULL ORDER BY 1,2,3; timec | i | b | t | newtcol ------------------------------+-----+-----+---------+------------------------ Thu Jan 02 08:16:00 2020 PST | 11 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 11 | 16 | prev16 | newtcol16 Thu Jan 02 08:16:00 2020 PST | 12 | 16 | prev16 | newtcol16 Thu Jan 02 08:16:00 2020 PST | 12 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 13 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 13 | 16 | prev16 | newtcol16 Thu Jan 02 08:16:00 2020 PST | 14 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 15 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 16 | 16 | prev16 | this is the newtcol16 Thu Jan 02 08:16:00 2020 PST | 100 | 101 | prev101 | newtcol101 Thu Jan 02 08:16:00 2020 PST | 100 | 101 | prev101 | this is the newtcol101 DROP TABLE test1; -- TEST 3 add tests with dropped columns on hypertable -- also tests defaults CREATE TABLE test2 ( itime integer, b bigint, t text); SELECT table_name from create_hypertable('test2', 'itime', chunk_time_interval=> 10::integer); table_name ------------ test2 --create a chunk INSERT INTO test2 SELECT t, 10, 'first'::text FROM generate_series(1, 7) t; ALTER TABLE test2 DROP COLUMN b; ALTER TABLE test2 ADD COLUMN c INT DEFAULT -15; ALTER TABLE test2 ADD COLUMN d INT; --create a new chunk INSERT INTO test2 SELECT t, 'second'::text, 120, 1 FROM generate_series(11, 15) t; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'c, itime DESC'); SELECT count(*) from ( SELECT compress_chunk(c) FROM show_chunks('test2') c ) q; count ------- 2 --write to both old chunks and new chunks INSERT INTO test2(itime ,t , d) SELECT 9, '9', 90 ; INSERT INTO test2(itime ,t , d) SELECT 17, '17', 1700 ; COPY test2(itime,t,d) FROM STDIN DELIMITER ','; SELECT count(*) FROM show_chunks('test2') q; count ------- 2 SELECT * from test2 WHERE itime >= 9 and itime <= 17 ORDER BY 1,2,3; itime | t | c | d -------+--------+-----+------ 9 | 9 | -15 | 90 9 | 9copy | -15 | 90 11 | second | 120 | 1 12 | second | 120 | 1 13 | second | 120 | 1 14 | second | 120 | 1 15 | second | 120 | 1 17 | 17 | -15 | 1700 17 | 17copy | -15 | 1700 -- now add a column to the compressed hypertable -- we have dropped columns and newly added columns now ALTER TABLE test2 ADD COLUMN charcol varchar(45); INSERT INTO test2(itime ,t , d, charcol) values (2, '2', 22, 'thisis22'), (17, '17', 1701, 'thisis1700') ; COPY test2(itime,t,d,charcol) FROM STDIN DELIMITER ','; SELECT * from test2 where itime = 2 or itime =17 ORDER BY 1, 2, 3, 4, 5; itime | t | c | d | charcol -------+--------+-----+------+------------ 2 | 2 | -15 | 22 | thisis22 2 | 2copy | -15 | 22 | 22copy 2 | first | -15 | | 17 | 17 | -15 | 1700 | 17 | 17 | -15 | 1701 | thisis1700 17 | 17copy | -15 | 1700 | 17 | 17copy | -15 | 1701 | 1700copy DROP TABLE test2; --- TEST3 tables with defaults --- -- sequences, generated values, check constraints into compressed chunks CREATE TABLE test2 (timec timestamptz , i integer CHECK ( i > 10) , b bigint default 20 , t text NOT NULL, CONSTRAINT rowconstr CHECK ( b > i ) ); SELECT table_name from create_hypertable('test2', 'timec', chunk_time_interval=> INTERVAL '7 days'); table_name ------------ test2 ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); INSERT INTO test2 values('2020-01-02 11:16:00-05' , 100, 105, 'first' ); SELECT compress_chunk(c) FROM show_chunks('test2') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_7_chunk -- test if default value for b is used INSERT INTO test2(timec, i, t) values('2020-01-02 10:16:00-05' , 11, 'default' ); COPY test2(timec,i,t) FROM STDIN DELIMITER ','; SELECT b from test2 ORDER BY 1; b ----- 20 20 105 \set ON_ERROR_STOP 0 --null value for t, should fail INSERT INTO test2 values ( '2020-01-02 01:00:00-05', 100, 200, NULL); ERROR: null value in column "t" of relation "_hyper_5_7_chunk" violates not-null constraint COPY test2 FROM STDIN DELIMITER ',' NULL 'NULL'; ERROR: null value in column "t" of relation "_hyper_5_7_chunk" violates not-null constraint -- i=1, should fail INSERT INTO test2 values ( '2020-01-02 01:00:00-05', 1, 10, 'null i'); ERROR: new row for relation "_hyper_5_7_chunk" violates check constraint "test2_i_check" COPY test2 FROM STDIN DELIMITER ','; ERROR: new row for relation "_hyper_5_7_chunk" violates check constraint "test2_i_check" -- b < i, should fail INSERT INTO test2 values ( '2020-01-02 01:00:00-05', 22, 1, 'null i'); ERROR: new row for relation "_hyper_5_7_chunk" violates check constraint "rowconstr" COPY test2 FROM STDIN DELIMITER ','; ERROR: new row for relation "_hyper_5_7_chunk" violates check constraint "rowconstr" \set ON_ERROR_STOP 1 --verify we are still INSERTing into the compressed chunk i.e did not --create a new chunk SELECT count(c) FROM show_chunks('test2') c; count ------- 1 -- TEST4 with sequence . CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE vessels (timec timestamptz , id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass), i integer CHECK ( i > 10) , b bigint default 20 , t text NOT NULL, CONSTRAINT rowconstr CHECK ( b > i ) ); SELECT table_name from create_hypertable('vessels', 'timec', chunk_time_interval=> INTERVAL '7 days'); table_name ------------ vessels ALTER TABLE vessels set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); INSERT INTO vessels(timec, i, b, t) values('2020-01-02 11:16:00-05' , 100, 105, 'first' ); SELECT compress_chunk(c) FROM show_chunks('vessels') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_7_9_chunk -- test if default value for b and sequence value for id is used INSERT INTO vessels(timec, i, t) values('2020-01-02 10:16:00-05' , 11, 'default' ); COPY vessels(timec,i,t )FROM STDIN DELIMITER ','; SELECT timec, id, b from vessels order by 2, 1; timec | id | b ------------------------------+----+----- Thu Jan 02 08:16:00 2020 PST | 1 | 105 Thu Jan 02 07:16:00 2020 PST | 2 | 20 Thu Jan 02 07:16:00 2020 PST | 3 | 20 -- TEST5 generated values CREATE table test_gen ( id int generated by default AS IDENTITY , payload text ); SELECT create_hypertable('test_gen', 'id', chunk_time_interval=>10); create_hypertable ----------------------- (9,public,test_gen,t) ALTER TABLE test_gen set (timescaledb.compress); INSERT into test_gen (payload) SELECT generate_series(1,15) ; SELECT max(id) from test_gen; max ----- 15 SELECT compress_chunk(c) FROM show_chunks('test_gen') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_11_chunk _timescaledb_internal._hyper_9_12_chunk INSERT INTO test_gen (payload) values(17); SELECT * from test_gen WHERE id = (Select max(id) from test_gen); id | payload ----+--------- 16 | 17 COPY test_gen(payload) FROM STDIN DELIMITER ','; SELECT * from test_gen WHERE id = (Select max(id) from test_gen); id | payload ----+--------- 17 | 18 -- TEST triggers -- insert into compressed hypertables with triggers CREATE OR REPLACE FUNCTION row_trig_value_gt_0() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; IF NEW.value <= 0 THEN RAISE NOTICE 'Skipping insert'; RETURN NULL; END IF; RETURN NEW; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION row_trig_value_mod() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; NEW.value = NEW.value + 100; RETURN NEW; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION stmt_trig_info() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; RETURN NEW; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION stmt_trig_error() RETURNS TRIGGER AS $$ BEGIN RAISE EXCEPTION 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; RETURN NULL; END $$ LANGUAGE plpgsql; CREATE TABLE trigger_test(time timestamptz NOT NULL, device int, value int, dropcol1 int); SELECT create_hypertable('trigger_test','time'); create_hypertable ---------------------------- (11,public,trigger_test,t) --create chunk and compress --the first chunk is created with dropcol1 INSERT INTO trigger_test(time, device, value,dropcol1) SELECT '2000-01-01',1,1,1; -- drop the column before we compress ALTER TABLE trigger_test DROP COLUMN dropcol1; ALTER TABLE trigger_test SET (timescaledb.compress,timescaledb.compress_segmentby='device'); SELECT compress_chunk(c) FROM show_chunks('trigger_test') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_15_chunk -- BEFORE ROW trigger CREATE TRIGGER t1 BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION row_trig_value_gt_0(); -- should be 1 SELECT count(*) FROM trigger_test; count ------- 1 -- try insert that gets skipped by trigger INSERT INTO trigger_test SELECT '2000-01-01',1,0; NOTICE: Trigger t1 BEFORE INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,0) <NULL> NOTICE: Skipping insert COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t1 BEFORE INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,0) <NULL> NOTICE: Skipping insert -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; count ------- 1 -- try again without being skipped BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,1; NOTICE: Trigger t1 BEFORE INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,1) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t1 BEFORE INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,1) <NULL> -- should be 3 SELECT count(*) FROM trigger_test; count ------- 3 ROLLBACK; DROP TRIGGER t1 ON trigger_test; -- BEFORE ROW trigger that modifies tuple CREATE TRIGGER t1_mod BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION row_trig_value_mod(); BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,11; NOTICE: Trigger t1_mod BEFORE INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,11) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t1_mod BEFORE INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,12) <NULL> -- value for both new tuples should be > 100 SELECT * FROM trigger_test ORDER BY 3; time | device | value ------------------------------+--------+------- Sat Jan 01 00:00:00 2000 PST | 1 | 1 Sat Jan 01 00:00:00 2000 PST | 1 | 111 Fri Dec 31 22:00:00 1999 PST | 1 | 112 ROLLBACK; DROP TRIGGER t1_mod ON trigger_test; -- BEFORE ROW conditional trigger CREATE TRIGGER t1_cond BEFORE INSERT ON trigger_test FOR EACH ROW WHEN (NEW.value > 10) EXECUTE FUNCTION row_trig_value_mod(); -- test with condition being false BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,1; COPY trigger_test FROM STDIN DELIMITER ','; -- value for both new tuples should not be > 100 SELECT * FROM trigger_test ORDER BY 3; time | device | value ------------------------------+--------+------- Sat Jan 01 00:00:00 2000 PST | 1 | 1 Sat Jan 01 00:00:00 2000 PST | 1 | 1 Fri Dec 31 22:00:00 1999 PST | 1 | 2 ROLLBACK; -- test with condition being true BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,11; NOTICE: Trigger t1_cond BEFORE INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,11) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t1_cond BEFORE INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,12) <NULL> -- value for both new tuples should be > 100 SELECT * FROM trigger_test ORDER BY 3; time | device | value ------------------------------+--------+------- Sat Jan 01 00:00:00 2000 PST | 1 | 1 Sat Jan 01 00:00:00 2000 PST | 1 | 111 Fri Dec 31 22:00:00 1999 PST | 1 | 112 ROLLBACK; DROP TRIGGER t1_cond ON trigger_test; -- BEFORE ROW error in trigger CREATE TRIGGER t1_error BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION stmt_trig_error(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,11; ERROR: Trigger t1_error BEFORE INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,11) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; ERROR: Trigger t1_error BEFORE INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,12) <NULL> \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; count ------- 1 DROP TRIGGER t1_error ON trigger_test; -- BEFORE STATEMENT trigger CREATE TRIGGER t2 BEFORE INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_info(); BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,0; NOTICE: Trigger t2 BEFORE INSERT STATEMENT on trigger_test: <NULL> <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t2 BEFORE INSERT STATEMENT on trigger_test: <NULL> <NULL> -- should be 3 SELECT count(*) FROM trigger_test; count ------- 3 ROLLBACK; DROP TRIGGER t2 ON trigger_test; -- BEFORE STATEMENT error in trigger CREATE TRIGGER t2_error BEFORE INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_error(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,11; ERROR: Trigger t2_error BEFORE INSERT STATEMENT on trigger_test: <NULL> <NULL> COPY trigger_test FROM STDIN DELIMITER ','; ERROR: Trigger t2_error BEFORE INSERT STATEMENT on trigger_test: <NULL> <NULL> \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; count ------- 1 DROP TRIGGER t2_error ON trigger_test; -- AFTER STATEMENT trigger CREATE TRIGGER t3 AFTER INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_info(); BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,0; NOTICE: Trigger t3 AFTER INSERT STATEMENT on trigger_test: <NULL> <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t3 AFTER INSERT STATEMENT on trigger_test: <NULL> <NULL> -- should be 3 SELECT count(*) FROM trigger_test; count ------- 3 ROLLBACK; DROP TRIGGER t3 ON trigger_test; -- AFTER STATEMENT error in trigger CREATE TRIGGER t3_error AFTER INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_error(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,11; ERROR: Trigger t3_error AFTER INSERT STATEMENT on trigger_test: <NULL> <NULL> COPY trigger_test FROM STDIN DELIMITER ','; ERROR: Trigger t3_error AFTER INSERT STATEMENT on trigger_test: <NULL> <NULL> \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; count ------- 1 DROP TRIGGER t3_error ON trigger_test; -- test unsupported features are blocked -- INSTEAD OF INSERT is only supported for VIEWs \set ON_ERROR_STOP 0 CREATE TRIGGER t4_instead INSTEAD OF INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_info(); ERROR: "trigger_test" is a table \set ON_ERROR_STOP 1 -- AFTER INSERT ROW trigger not supported on compressed chunk CREATE TRIGGER t4_ar AFTER INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION stmt_trig_info(); \set ON_ERROR_STOP 0 \set VERBOSITY default INSERT INTO trigger_test SELECT '2000-01-01',1,0; NOTICE: Trigger t4_ar AFTER INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,0) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t4_ar AFTER INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,0) <NULL> \set VERBOSITY terse \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; count ------- 3 BEGIN; INSERT INTO trigger_test SELECT '2001-01-01',1,0; NOTICE: Trigger t4_ar AFTER INSERT ROW on _hyper_11_17_chunk: ("Mon Jan 01 00:00:00 2001 PST",1,0) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t4_ar AFTER INSERT ROW on _hyper_11_17_chunk: ("Sun Dec 31 22:00:00 2000 PST",1,0) <NULL> -- insert into new uncompressed chunk should not be blocked SELECT count(*) FROM trigger_test; count ------- 5 ROLLBACK; DROP TRIGGER t4_ar ON trigger_test; -- CONSTRAINT trigger not supported on compressed chunk CREATE CONSTRAINT TRIGGER t4_constraint AFTER INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION stmt_trig_info(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,0; NOTICE: Trigger t4_constraint AFTER INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,0) <NULL> COPY trigger_test FROM STDIN DELIMITER ','; NOTICE: Trigger t4_constraint AFTER INSERT ROW on _hyper_11_15_chunk: ("Fri Dec 31 22:00:00 1999 PST",1,0) <NULL> \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; count ------- 5 DROP trigger t4_constraint ON trigger_test; -- test row triggers after adding/dropping columns -- now add a new column to the table and insert into a new chunk ALTER TABLE trigger_test ADD COLUMN addcolv varchar(10); ALTER TABLE trigger_test ADD COLUMN addcoli integer; INSERT INTO trigger_test(time, device, value, addcolv, addcoli) VALUES ( '2010-01-01', 10, 10, 'ten', 222); SELECT compress_chunk(c, true) FROM show_chunks('trigger_test') c; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_15_chunk _timescaledb_internal._hyper_11_18_chunk CREATE TRIGGER t1_mod BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION row_trig_value_mod(); SELECT count(*) FROM trigger_test; count ------- 6 BEGIN; INSERT INTO trigger_test VALUES ( '2000-01-01',1,11, 'eleven', 111), ( '2010-01-01',10,10, 'ten', 222); NOTICE: Trigger t1_mod BEFORE INSERT ROW on _hyper_11_15_chunk: ("Sat Jan 01 00:00:00 2000 PST",1,11,eleven,111) <NULL> NOTICE: Trigger t1_mod BEFORE INSERT ROW on _hyper_11_18_chunk: ("Fri Jan 01 00:00:00 2010 PST",10,10,ten,222) <NULL> SELECT * FROM trigger_test ORDER BY 1 ,2, 3, 5; time | device | value | addcolv | addcoli ------------------------------+--------+-------+---------+--------- Fri Dec 31 22:00:00 1999 PST | 1 | 0 | | Fri Dec 31 22:00:00 1999 PST | 1 | 0 | | Sat Jan 01 00:00:00 2000 PST | 1 | 0 | | Sat Jan 01 00:00:00 2000 PST | 1 | 0 | | Sat Jan 01 00:00:00 2000 PST | 1 | 1 | | Sat Jan 01 00:00:00 2000 PST | 1 | 111 | eleven | 111 Fri Jan 01 00:00:00 2010 PST | 10 | 10 | ten | 222 Fri Jan 01 00:00:00 2010 PST | 10 | 110 | ten | 222 ROLLBACK; DROP TABLE trigger_test; -- test interaction between newly inserted batches and pathkeys/ordered append -- -- The following test operates on a small relation. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following test to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; CREATE TABLE test_ordering(time int); SELECT table_name FROM create_hypertable('test_ordering','time',chunk_time_interval:=100); table_name --------------- test_ordering ALTER TABLE test_ordering SET (timescaledb.compress,timescaledb.compress_orderby='time desc'); INSERT INTO test_ordering VALUES (5),(4),(3); -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; --- QUERY PLAN --- Index Only Scan Backward using _hyper_13_20_chunk_test_ordering_time_idx on _hyper_13_20_chunk SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name), true) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_ordering'; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_20_chunk VACUUM ANALYZE test_ordering; -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_20_chunk -> Sort Sort Key: compress_hyper_14_21_chunk._ts_meta_min_1, compress_hyper_14_21_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_14_21_chunk INSERT INTO test_ordering SELECT 1; VACUUM ANALYZE test_ordering; -- should not be ordered append -- regression introduced by #5599: -- for the case of a single chunk, there is an additional redundant sort node below decompress chunk -- this is due to pushing down the sort node below decompress chunk. In most cases that is beneficial, -- but here a more optimal plan would have been a mergeAppend. -- It was hard to include a path without pushed down sort for consideration, as `add_path` would reject -- the path with sort pushdown, which is desirable in most cases :PREFIX SELECT * FROM test_ordering ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_ordering Order: test_ordering."time" -> Merge Append Sort Key: test_ordering."time" -> Custom Scan (ColumnarScan) on _hyper_13_20_chunk -> Sort Sort Key: compress_hyper_14_21_chunk._ts_meta_min_1, compress_hyper_14_21_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_14_21_chunk -> Index Only Scan Backward using _hyper_13_20_chunk_test_ordering_time_idx on _hyper_13_20_chunk INSERT INTO test_ordering VALUES (105),(104),(103); VACUUM ANALYZE test_ordering; -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_ordering Order: test_ordering."time" -> Merge Append Sort Key: test_ordering."time" -> Custom Scan (ColumnarScan) on _hyper_13_20_chunk -> Sort Sort Key: compress_hyper_14_21_chunk._ts_meta_min_1, compress_hyper_14_21_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_14_21_chunk -> Index Only Scan Backward using _hyper_13_20_chunk_test_ordering_time_idx on _hyper_13_20_chunk -> Index Only Scan Backward using _hyper_13_22_chunk_test_ordering_time_idx on _hyper_13_22_chunk --insert into compressed + uncompressed chunk INSERT INTO test_ordering VALUES (21), (22),(113); SELECT count(*) FROM test_ordering; count ------- 10 INSERT INTO test_ordering VALUES (106) RETURNING *; time ------ 106 -- insert into compressed chunk does support RETURNING INSERT INTO test_ordering VALUES (23), (24), (115) RETURNING *; time ------ 23 24 115 INSERT INTO test_ordering VALUES (23), (24), (115) RETURNING tableoid::regclass, *; tableoid | time ------------------------------------------+------ _timescaledb_internal._hyper_13_20_chunk | 23 _timescaledb_internal._hyper_13_20_chunk | 24 _timescaledb_internal._hyper_13_22_chunk | 115 SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name), true) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_ordering'; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_20_chunk _timescaledb_internal._hyper_13_22_chunk VACUUM ANALYZE test_ordering; -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_ordering Order: test_ordering."time" -> Custom Scan (ColumnarScan) on _hyper_13_20_chunk -> Sort Sort Key: compress_hyper_14_21_chunk._ts_meta_min_1, compress_hyper_14_21_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_14_21_chunk -> Custom Scan (ColumnarScan) on _hyper_13_22_chunk -> Sort Sort Key: compress_hyper_14_23_chunk._ts_meta_min_1, compress_hyper_14_23_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_14_23_chunk SET timescaledb.enable_decompression_sorted_merge = 1; -- TEST cagg triggers with insert into compressed chunk CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions SELECT generate_series('2010-01-01 09:00:00-08'::timestamptz, '2010-01-03 09:00:00-08'::timestamptz, '1 day'), 55 , 45; CREATE MATERIALIZED VIEW cagg_conditions WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket( '7 days', timec) bkt, count(*) cnt, sum(temperature) sumb FROM conditions GROUP BY time_bucket('7 days', timec); NOTICE: refreshing continuous aggregate "cagg_conditions" SELECT * FROM cagg_conditions ORDER BY 1; bkt | cnt | sumb ------------------------------+-----+------ Sun Dec 27 16:00:00 2009 PST | 3 | 165 ALTER TABLE conditions SET (timescaledb.compress); SELECT compress_chunk(ch) FROM show_chunks('conditions') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_24_chunk SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'conditions'; chunk_name | range_start | range_end | is_compressed --------------------+------------------------------+------------------------------+--------------- _hyper_15_24_chunk | Wed Dec 30 16:00:00 2009 PST | Wed Jan 06 16:00:00 2010 PST | t --now insert into compressed chunk INSERT INTO conditions VALUES('2010-01-01 12:00:00-08', 10, 20); INSERT INTO conditions VALUES('2010-01-01 12:00:00-08', 10, 20); --refresh cagg, should have updated info CALL refresh_continuous_aggregate('cagg_conditions', NULL, '2011-01-01 12:00:00-08' ); SELECT * FROM cagg_conditions ORDER BY 1; bkt | cnt | sumb ------------------------------+-----+------ Sun Dec 27 16:00:00 2009 PST | 5 | 185 -- TEST cagg triggers with copy into compressed chunk COPY conditions FROM STDIN DELIMITER ','; --refresh cagg, should have updated info CALL refresh_continuous_aggregate('cagg_conditions', NULL, '2011-01-01 12:00:00-08' ); SELECT * FROM cagg_conditions ORDER BY 1; bkt | cnt | sumb ------------------------------+-----+------ Sun Dec 27 16:00:00 2009 PST | 8 | 485 -- TEST direct insert into internal compressed hypertable should be blocked CREATE TABLE direct_insert(time timestamptz not null); SELECT table_name FROM create_hypertable('direct_insert','time'); table_name --------------- direct_insert ALTER TABLE direct_insert SET(timescaledb.compress); SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "TABLENAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'direct_insert') \gset \set ON_ERROR_STOP 0 INSERT INTO :TABLENAME SELECT; ERROR: direct insert into internal compressed hypertable is not supported \set ON_ERROR_STOP 1 -- Test that inserting into a compressed table works even when the -- column has been dropped. CREATE TABLE test4 ( timestamp timestamp without time zone not null, ident text not null, one double precision, two double precision ); SELECT * FROM create_hypertable('test4', 'timestamp'); WARNING: column type "timestamp without time zone" used for "timestamp" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 20 | public | test4 | t INSERT INTO test4 ( timestamp, ident ) VALUES ( '2021-10-14 17:50:16.207', '2' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2021-11-14 17:50:16.207', '1' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2021-12-14 17:50:16.207', '3' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-01-14 17:50:16.207', '4' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-02-14 17:50:16.207', '5' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-03-14 17:50:16.207', '6' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-04-14 17:50:16.207', '7' ); ALTER TABLE test4 SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp', timescaledb.compress_segmentby = 'ident' ); select count(compress_chunk(ch)) FROM show_chunks('test4') ch; count ------- 7 ALTER TABLE test4 DROP COLUMN two; INSERT INTO test4 VALUES ('2021-10-14 17:50:16.207', '7', NULL); INSERT INTO test4 (timestamp, ident) VALUES ('2021-10-14 17:50:16.207', '7'); DROP TABLE test4; -- Test COPY when trying to flush an empty buffer -- In this case we send an empty slot used to -- search for compressed tuples. CREATE TABLE test_copy ( timestamp int not null, id bigint ); CREATE UNIQUE INDEX timestamp_id_idx ON test_copy(timestamp, id); SELECT * FROM create_hypertable('test_copy', 'timestamp', chunk_time_interval=>10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 22 | public | test_copy | t ALTER TABLE test_copy SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp', timescaledb.compress_segmentby = 'id' ); INSERT INTO test_copy SELECT generate_series(1,25,1), -1; SELECT count(compress_chunk(ch)) FROM show_chunks('test_copy') ch; count ------- 3 \copy test_copy FROM data/copy_data.csv WITH CSV HEADER; -- Also test the code path where the chunk insert state goes out of cache. set timescaledb.max_open_chunks_per_insert = 1; truncate table test_copy; INSERT INTO test_copy SELECT generate_series(1,25,1), -1; SELECT count(compress_chunk(ch)) FROM show_chunks('test_copy') ch; count ------- 3 \copy test_copy FROM data/copy_data.csv WITH CSV HEADER; reset timescaledb.max_open_chunks_per_insert; DROP TABLE test_copy; -- Text limitting decompressed tuple during an insert CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>1000); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 24 | public | test_limit | t INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; CREATE UNIQUE INDEX timestamp_id_idx ON test_limit(timestamp, id); ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'timestamp' ); WARNING: column "id" should be used for segmenting or ordering SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; count ------- 11 SET timescaledb.max_tuples_decompressed_per_dml_transaction = 1; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Inserting in the same period should decompress tuples INSERT INTO test_limit SELECT t, 2 FROM generate_series(1,6000,1000) t; ERROR: duplicate key value violates unique constraint "_hyper_24_53_chunk_timestamp_id_idx" -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; INSERT INTO test_limit SELECT t, 2 FROM generate_series(1,6000,1000) t; ERROR: duplicate key value violates unique constraint "_hyper_24_53_chunk_timestamp_id_idx" \set ON_ERROR_STOP 1 DROP TABLE test_limit; RESET timescaledb.max_tuples_decompressed_per_dml_transaction; -- test multiple unique constraints CREATE TABLE multi_unique (time timestamptz NOT NULL, u1 int, u2 int, value float, unique(time, u1), unique(time, u2)); SELECT table_name FROM create_hypertable('multi_unique', 'time'); table_name -------------- multi_unique ALTER TABLE multi_unique SET (timescaledb.compress, timescaledb.compress_segmentby = 'u1, u2'); INSERT INTO multi_unique VALUES('2024-01-01', 0, 0, 1.0); SELECT count(compress_chunk(c)) FROM show_chunks('multi_unique') c; count ------- 1 \set ON_ERROR_STOP 0 -- all INSERTS should fail with constraint violation BEGIN; INSERT INTO multi_unique VALUES('2024-01-01', 0, 0, 1.0); ROLLBACK; ERROR: duplicate key value violates unique constraint "75_1_multi_unique_time_u1_key" DETAIL: Key ("time", u1)=(Mon Jan 01 00:00:00 2024 PST, 0) already exists. BEGIN; INSERT INTO multi_unique VALUES('2024-01-01', 0, 1, 1.0); ROLLBACK; ERROR: duplicate key value violates unique constraint "75_1_multi_unique_time_u1_key" DETAIL: Key ("time", u1)=(Mon Jan 01 00:00:00 2024 PST, 0) already exists. BEGIN; INSERT INTO multi_unique VALUES('2024-01-01', 1, 0, 1.0); ROLLBACK; ERROR: duplicate key value violates unique constraint "75_2_multi_unique_time_u2_key" DETAIL: Key ("time", u2)=(Mon Jan 01 00:00:00 2024 PST, 0) already exists. \set ON_ERROR_STOP 1 DROP TABLE multi_unique; -- test insert with unique constraints and NULLs CREATE TABLE unique_null(time timestamptz NOT NULL, u1 int, u2 int, value float, unique(time, u1, u2)); SELECT table_name FROM create_hypertable('unique_null', 'time'); table_name ------------- unique_null ALTER TABLE unique_null SET (timescaledb.compress, timescaledb.compress_segmentby = 'u1, u2'); INSERT INTO unique_null VALUES('2024-01-01', 0, 0, 1.0); SELECT count(compress_chunk(c)) FROM show_chunks('unique_null') c; count ------- 1 \set ON_ERROR_STOP 0 -- all INSERTS should fail with constraint violation BEGIN; INSERT INTO unique_null VALUES('2024-01-01', 0, 0, 1.0); ROLLBACK; ERROR: duplicate key value violates unique constraint "77_3_unique_null_time_u1_u2_key" \set ON_ERROR_STOP 1 -- neither of these should need to decompress :ANALYZE INSERT INTO unique_null VALUES('2024-01-01', NULL, 1, 1.0); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on unique_null (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) SELECT count(*) FROM unique_null; count ------- 2 :ANALYZE INSERT INTO unique_null VALUES('2024-01-01', 1, NULL, 1.0); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on unique_null (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) SELECT count(*) FROM unique_null; count ------- 3 :ANALYZE INSERT INTO unique_null VALUES('2024-01-01', NULL, NULL, 1.0); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on unique_null (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) SELECT count(*) FROM unique_null; count ------- 4 INSERT INTO unique_null VALUES('2024-01-01', NULL, NULL, 1.0); SELECT count(*) FROM unique_null; count ------- 5 DROP TABLE unique_null; -- test insert with UNIQUE constraint and all compression algorithms set timescaledb.enable_bool_compression = on; CREATE TABLE unique_all( time timestamptz NOT NULL, device_id int, bool_type bool, numeric_type numeric, float_type float, text_type text, bigint_type bigint, jsonb_type jsonb ); -- Since we don't test uniqueness when we detect a NULL value, making the constraint -- with NULLS NOT DISTINCT CREATE UNIQUE INDEX ultimate_unique ON unique_all(time, device_id, bool_type, numeric_type, float_type, text_type, bigint_type, jsonb_type) NULLS NOT DISTINCT; SELECT table_name FROM create_hypertable('unique_all', 'time'); table_name ------------ unique_all ALTER TABLE unique_all SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); WARNING: column "bool_type" should be used for segmenting or ordering WARNING: column "numeric_type" should be used for segmenting or ordering WARNING: column "float_type" should be used for segmenting or ordering WARNING: column "text_type" should be used for segmenting or ordering WARNING: column "bigint_type" should be used for segmenting or ordering WARNING: column "jsonb_type" should be used for segmenting or ordering INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:01', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:02', 1, false, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:03', 1, true, 2.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:04', 1, true, 1.0, 2.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:05', 1, true, 1.0, 1.0, 'second', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:06', 1, true, 1.0, 1.0, 'first', 2, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:07', 1, true, 1.0, 1.0, 'first', 1, '{"second":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:08', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:09', 1, NULL, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:10', 1, true, NULL, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:11', 1, true, 1.0, NULL, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:12', 1, true, 1.0, 1.0, NULL, 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:13', 1, true, 1.0, 1.0, 'first', NULL, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:14', 1, true, 1.0, 1.0, 'first', 1, NULL); SELECT count(compress_chunk(c)) FROM show_chunks('unique_all') c; count ------- 1 -- test duplicates \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:01', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:02', 1, false, 1.0, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:03', 1, true, 2.0, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:04', 1, true, 1.0, 2.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:05', 1, true, 1.0, 1.0, 'second', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:06', 1, true, 1.0, 1.0, 'first', 2, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:07', 1, true, 1.0, 1.0, 'first', 1, '{"second":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:08', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:09', 1, NULL, 1.0, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:10', 1, true, NULL, 1.0, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:11', 1, true, 1.0, NULL, 'first', 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:12', 1, true, 1.0, 1.0, NULL, 1, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:13', 1, true, 1.0, 1.0, 'first', NULL, '{"first":true}'); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:14', 1, true, 1.0, 1.0, 'first', 1, NULL); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" \set ON_ERROR_STOP 1 -- test non-duplicates INSERT INTO unique_all VALUES('2024-01-01 00:01:01', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:02', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:03', 1, true, 3.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:04', 1, true, 1.0, 3.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:05', 1, true, 1.0, 1.0, 'third', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:06', 1, true, 1.0, 1.0, 'first', 3, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:07', 1, true, 1.0, 1.0, 'first', 1, '{"third":true}'); -- test non-duplicates with non-NULL default values ALTER TABLE unique_all ADD COLUMN added_non_null int DEFAULT 4; DROP INDEX ultimate_unique; CREATE UNIQUE INDEX ultimate_unique ON unique_all(time, device_id, bool_type, numeric_type, float_type, text_type, bigint_type, jsonb_type, added_non_null) NULLS NOT DISTINCT; \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" \set ON_ERROR_STOP 1 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 5); -- make sure everything is correct after recompressing the chunk SELECT count(decompress_chunk(c)) FROM show_chunks('unique_all') c; count ------- 1 SELECT count(compress_chunk(c)) FROM show_chunks('unique_all') c; count ------- 1 \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" \set ON_ERROR_STOP 1 -- test non-duplicates with NULL default values ALTER TABLE unique_all ADD COLUMN added_null int DEFAULT NULL; DROP INDEX ultimate_unique; CREATE UNIQUE INDEX ultimate_unique ON unique_all(time, device_id, bool_type, numeric_type, float_type, text_type, bigint_type, jsonb_type, added_non_null, added_null) NULLS NOT DISTINCT; \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4, NULL); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 5, NULL); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" \set ON_ERROR_STOP 1 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 6, NULL); -- make sure everything is correct after recompressing the chunk SELECT count(decompress_chunk(c)) FROM show_chunks('unique_all') c; count ------- 1 SELECT count(compress_chunk(c)) FROM show_chunks('unique_all') c; count ------- 1 \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4, NULL); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 5, NULL); ERROR: duplicate key value violates unique constraint "_hyper_30_79_chunk_ultimate_unique" \set ON_ERROR_STOP 1 DROP TABLE unique_all; -- test NULL compression algorithm CREATE TABLE unique_null( time timestamptz NOT NULL, device_id int, tag text, tag2 text, value float ); CREATE UNIQUE INDEX unique_nulls ON unique_null(time, device_id, tag, tag2) NULLS NOT DISTINCT; SELECT table_name FROM create_hypertable('unique_null', 'time'); table_name ------------- unique_null ALTER TABLE unique_null SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); WARNING: column "tag" should be used for segmenting or ordering WARNING: column "tag2" should be used for segmenting or ordering INSERT INTO unique_null VALUES ('2024-01-01 00:00', 1, NULL, '1', 1), ('2024-01-01 00:00', 1, NULL, '2', 2), ('2024-01-01 00:00', 1, NULL, '3', 3); SELECT count(compress_chunk(c)) FROM show_chunks('unique_null') c; count ------- 1 \set ON_ERROR_STOP 0 INSERT INTO unique_null VALUES ('2024-01-01 00:00', 1, NULL, '1', 1); ERROR: duplicate key value violates unique constraint "_hyper_32_83_chunk_unique_nulls" \set ON_ERROR_STOP 1 ALTER TABLE unique_null ADD COLUMN tag3 text DEFAULT 'default value'; DROP INDEX unique_nulls; CREATE UNIQUE INDEX unique_nulls ON unique_null(time, device_id, tag, tag2, tag3) NULLS NOT DISTINCT; \set ON_ERROR_STOP 0 INSERT INTO unique_null VALUES ('2024-01-01 00:00', 1, NULL, '1', 1, 'default value'); ERROR: duplicate key value violates unique constraint "_hyper_32_83_chunk_unique_nulls" \set ON_ERROR_STOP 1 INSERT INTO unique_null VALUES ('2024-01-01 00:01', 1, NULL, '1', 1, 'default value'), ('2024-01-01 00:00', 2, NULL, '1', 1, 'default value'); DROP TABLE unique_null; -- test NUMERIC data type CREATE TABLE unique_numeric( time timestamptz NOT NULL, device_id numeric(6,2) NOT NULL, tag text, tag2 text, value float ); CREATE UNIQUE INDEX unique_numeric_idx ON unique_numeric(time, device_id, tag, tag2); SELECT table_name FROM create_hypertable('unique_numeric', 'time'); table_name ---------------- unique_numeric ALTER TABLE unique_numeric SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); WARNING: column "tag" should be used for segmenting or ordering WARNING: column "tag2" should be used for segmenting or ordering INSERT INTO unique_numeric VALUES ('2024-01-01 00:00', 1.1, NULL, '1', 1), ('2024-01-01 00:00', 1.2, NULL, '2', 2), ('2024-01-01 00:00', 1.3, NULL, '3', 3); SELECT count(compress_chunk(c)) FROM show_chunks('unique_numeric') c; count ------- 1 INSERT INTO unique_numeric VALUES ('2024-01-01 00:00', 1.4, NULL, '1', 1); DROP TABLE unique_numeric; -- test UUID data type CREATE TABLE unique_uuid( time timestamptz NOT NULL, device_id UUID NOT NULL, tag text, tag2 text, value float ); CREATE UNIQUE INDEX unique_uuid_idx ON unique_uuid(time, device_id, tag, tag2); SELECT table_name FROM create_hypertable('unique_uuid', 'time'); table_name ------------- unique_uuid ALTER TABLE unique_uuid SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); WARNING: column "tag" should be used for segmenting or ordering WARNING: column "tag2" should be used for segmenting or ordering INSERT INTO unique_uuid VALUES ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000000', NULL, '1', 1), ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000000', NULL, '1', 2), ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000001', NULL, '1', 1), ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000001', NULL, '1', 2); SELECT count(compress_chunk(c)) FROM show_chunks('unique_uuid') c; count ------- 1 INSERT INTO unique_uuid VALUES ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000001', NULL, '1', 3); DROP TABLE unique_uuid; -- regression test for SDC 3006 CREATE TABLE t_1sec( "timestamp" timestamp with time zone NOT NULL, device_id text, speed double precision, derived boolean ); ALTER TABLE t_1sec ADD CONSTRAINT unique_device_timestamp_sensor_derived UNIQUE (device_id, "timestamp", derived); CREATE INDEX t_1sec_timestamp_idx ON t_1sec USING btree ("timestamp" DESC); SELECT create_hypertable( relation => 't_1sec', time_column_name => 'timestamp', chunk_time_interval => interval '06:00:00', create_default_indexes => false ); create_hypertable ---------------------- (38,public,t_1sec,t) ALTER TABLE t_1sec SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id', timescaledb.compress_orderby='"timestamp"' ); WARNING: column "derived" should be used for segmenting or ordering insert into t_1sec ( "timestamp", device_id, speed, derived) values ( '2025-06-06 10:00:00', 'device_id_1', 100, true), ( '2025-06-06 10:01:00', 'device_id_2', 100, true), ( '2025-06-06 10:02:00', 'device_id_3', 100, true); SELECT compress_chunk(show_chunks('t_1sec')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_38_89_chunk insert into t_1sec ( "timestamp", device_id, speed, derived) values ( '2025-06-06 10:03:00', 'device_id_1', 100, true), ( '2025-06-06 10:00:00', 'device_id_1', 110, true), ( '2025-06-06 10:00:00', 'device_id_1', 110, false) ON CONFLICT DO NOTHING; DROP TABLE t_1sec; -- regression test for SDC 3210 CREATE TABLE gen_column( "timestamp" timestamp with time zone NOT NULL, device_id text, device_id_generated text GENERATED ALWAYS AS (device_id) STORED, speed double precision ); ALTER TABLE gen_column ADD CONSTRAINT unique_device_timestamp_sensor UNIQUE (device_id_generated, "timestamp"); CREATE INDEX gen_column_timestamp_idx ON gen_column USING btree ("timestamp" DESC); SELECT create_hypertable( relation => 'gen_column', time_column_name => 'timestamp', chunk_time_interval => interval '06:00:00', create_default_indexes => false ); create_hypertable -------------------------- (40,public,gen_column,t) ALTER TABLE gen_column SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id_generated', timescaledb.compress_orderby='"timestamp"' ); insert into gen_column ( "timestamp", device_id, speed) values ( '2025-06-06 10:00:00', 'device_id_1', 100), ( '2025-06-06 10:01:00', 'device_id_2', 100), ( '2025-06-06 10:02:00', 'device_id_3', 100); SELECT compress_chunk(show_chunks('gen_column')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_40_91_chunk insert into gen_column ( "timestamp", device_id, speed) values ( '2025-06-06 10:03:00', 'device_id_1', 100), ( '2025-06-06 10:00:00', 'device_id_1', 110), ( '2025-06-06 10:00:00', 'device_id_1', 110) ON CONFLICT DO NOTHING; -- should contain 2 rows for device_1 and one per any other device SELECT device_id_generated, count(*) FROM gen_column GROUP BY 1 ORDER BY 1; device_id_generated | count ---------------------+------- device_id_1 | 2 device_id_2 | 1 device_id_3 | 1 SELECT decompress_chunk(show_chunks('gen_column')); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_40_91_chunk ALTER TABLE gen_column SET ( timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby='"timestamp"' ); SELECT compress_chunk(show_chunks('gen_column')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_40_91_chunk insert into gen_column ( "timestamp", device_id, speed) values ( '2025-06-06 10:04:00', 'device_id_1', 100), ( '2025-06-06 10:00:00', 'device_id_1', 110), ( '2025-06-06 10:00:00', 'device_id_1', 110) ON CONFLICT DO NOTHING; -- should contain 3 rows for device_1 and one per any other device SELECT device_id_generated, count(*) FROM gen_column GROUP BY 1 ORDER BY 1; device_id_generated | count ---------------------+------- device_id_1 | 3 device_id_2 | 1 device_id_3 | 1 DROP TABLE gen_column; -- test insert into compressed chunk directly works -- to ensure maintenance operations work unhindered we dont -- want to block direct inserts into compressed chunks CREATE TABLE direct_compressed_insert (time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column HINT: Use "timescaledb.partition_column" to specify a different column to use as partitioning column. INSERT INTO direct_compressed_insert SELECT generate_series('2024-01-01'::timestamptz, '2024-01-01 1:00:00'::timestamptz, '1 second'); SELECT count(compress_chunk(c)) FROM show_chunks('direct_compressed_insert') c; count ------- 1 SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ORDER BY id DESC LIMIT 1 \gset CREATE TABLE compressed_batches AS SELECT * FROM :CHUNK; SELECT _ts_meta_count, count(*) FROM :CHUNK GROUP BY _ts_meta_count ORDER BY 1 DESC; _ts_meta_count | count ----------------+------- 1000 | 3 601 | 1 -- should have not ModifyHypertable node EXPLAIN (costs off,timing off, summary off) INSERT INTO :CHUNK SELECT * FROM compressed_batches; --- QUERY PLAN --- Insert on compress_hyper_43_95_chunk -> Seq Scan on compressed_batches INSERT INTO :CHUNK SELECT * FROM compressed_batches; SELECT _ts_meta_count, count(*) FROM :CHUNK GROUP BY _ts_meta_count ORDER BY 1 DESC; _ts_meta_count | count ----------------+------- 1000 | 6 601 | 2 ���������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_merge.out������������������������������������������0000664�0000000�0000000�00000115243�15100345067�0023714�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/rand_generator.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------- -- cheap rand generator -- -------------------------- create table rand_minstd_state(i bigint); create function rand_minstd_advance(bigint) returns bigint language sql immutable as $$ select (16807 * $1) % 2147483647 $$; create function gen_rand_minstd() returns bigint language sql security definer as $$ update rand_minstd_state set i = rand_minstd_advance(i) returning i $$; -- seed the random num generator insert into rand_minstd_state values (321); \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test1 -- This will generate 24 chunks INSERT INTO test1 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); SELECT $$ SELECT * FROM test1 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test1' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors psql:include/compression_test_merge.sql:7: NOTICE: table "merge_result" does not exist, skipping count_compressed ------------------ 24 ?column? | count -----------------------------------------------------------------------------------+------- Number of rows different between original and query on compressed data (expect 0) | 0 count ------- 12 ?column? | count --------------------------------------------------------------------------------------------------------------+------- Number of rows different between original and data that has been compressed and then decompressed (expect 0) | 0 \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 12 min_correct | max_correct -------------+------------- t | t DROP TABLE test1; CREATE TABLE test2 ("Time" timestamptz, i integer, loc integer, value integer); SELECT table_name from create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test2 -- This will generate 24 1 hour chunks. INSERT INTO test2 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Setting compression with time DESC to confirm we are don't have to recompress due to DESC order -- This is made possible by removal of sequence numbers \set VERBOSITY default ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time" DESC', timescaledb.compress_chunk_time_interval='10 hours'); \set VERBOSITY terse -- Verify we are not generating unordered chunks BEGIN; SELECT count(compress_chunk(chunk, true)) FROM show_chunks('test2') chunk; count ------- 24 SELECT format('%I.%I',ch.schema_name,ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ch JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id JOIN _timescaledb_catalog.hypertable ht2 ON ht.id=ht2.compressed_hypertable_id AND ht2.table_name='test2' LIMIT 1 \gset -- We want to sure we are not fully recompressing them which will make -- the chunk contain multiple batches per segment group SELECT count(*) FROM :CHUNK WHERE i = 1; count ------- 10 ROLLBACK; -- Compression is set to merge those 24 chunks into 3 chunks, two 10 hour chunks and a single 4 hour chunk. \set VERBOSITY default ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='loc,"Time"', timescaledb.compress_chunk_time_interval='10 hours'); WARNING: compress_chunk_time_interval configured and primary dimension not first column in compress_orderby HINT: consider setting "Time" as first compress_orderby column \set VERBOSITY terse -- Verify we are fully recompressing unordered chunks BEGIN; SELECT count(compress_chunk(chunk, true)) FROM show_chunks('test2') chunk; count ------- 24 SELECT format('%I.%I',ch.schema_name,ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ch JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id JOIN _timescaledb_catalog.hypertable ht2 ON ht.id=ht2.compressed_hypertable_id AND ht2.table_name='test2' LIMIT 1 \gset -- Not using time as first column in orderby makes the merged chunks unordered -- We want to sure we are fully recompressing them which will make only -- a single batch per segment group SELECT count(*) FROM :CHUNK WHERE i = 1; count ------- 1 ROLLBACK; SELECT $$ SELECT * FROM test2 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test2' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count_compressed ------------------ 24 ?column? | count -----------------------------------------------------------------------------------+------- Number of rows different between original and query on compressed data (expect 0) | 0 count ------- 3 ?column? | count --------------------------------------------------------------------------------------------------------------+------- Number of rows different between original and data that has been compressed and then decompressed (expect 0) | 0 \set TYPE integer \set ORDER_BY_COL_NAME loc \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 3 min_correct | max_correct -------------+------------- t | t DROP TABLE test2; CREATE TABLE test3 ("Time" timestamptz, i integer, loc integer, value integer); SELECT table_name from create_hypertable('test3', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test3 SELECT table_name from add_dimension('test3', 'i', number_partitions=> 3); table_name ------------ test3 -- This will generate 25 1 hour chunks with a closed space dimension. INSERT INTO test3 SELECT t, 1, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 12:59', '1 minute') t; INSERT INTO test3 SELECT t, 2, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 13:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t; INSERT INTO test3 SELECT t, 3, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 2:00'::TIMESTAMPTZ, '2018-03-02 2:01', '1 minute') t; -- Compression is set to merge those 25 chunks into 12 2 hour chunks and a single 1 hour chunks on a different space dimensions. \set VERBOSITY default ALTER TABLE test3 set (timescaledb.compress, timescaledb.compress_orderby='loc,"Time"', timescaledb.compress_chunk_time_interval='2 hours'); WARNING: compress_chunk_time_interval configured and primary dimension not first column in compress_orderby HINT: consider setting "Time" as first compress_orderby column \set VERBOSITY terse SELECT $$ SELECT * FROM test3 WHERE i = 1 ORDER BY "Time" $$ AS "QUERY" \gset SELECT 'test3' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count_compressed ------------------ 25 ?column? | count -----------------------------------------------------------------------------------+------- Number of rows different between original and query on compressed data (expect 0) | 0 count ------- 13 ?column? | count --------------------------------------------------------------------------------------------------------------+------- Number of rows different between original and data that has been compressed and then decompressed (expect 0) | 0 \set TYPE integer \set ORDER_BY_COL_NAME loc \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 13 min_correct | max_correct -------------+------------- t | t DROP TABLE test3; CREATE TABLE test4 ("Time" timestamptz, i integer, loc integer, value integer); SELECT table_name from create_hypertable('test4', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test4 -- Setting compress_chunk_time_interval to non-multiple of chunk_time_interval should emit a warning. \set VERBOSITY default ALTER TABLE test4 set (timescaledb.compress, timescaledb.compress_orderby='loc,"Time"', timescaledb.compress_chunk_time_interval='90 minutes'); WARNING: compress chunk interval is not a multiple of chunk interval, you should use a factor of chunk interval to merge as much as possible WARNING: compress_chunk_time_interval configured and primary dimension not first column in compress_orderby HINT: consider setting "Time" as first compress_orderby column \set VERBOSITY terse DROP TABLE test4; CREATE TABLE test5 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test5', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test5 -- This will generate 24 chunks. Note that we are forcing everyting into a single segment so we use table scan to when merging chunks. INSERT INTO test5 SELECT t, 1, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t; -- Compression is set to merge those 24 chunks into 1 24 hour chunk ALTER TABLE test5 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='24 hours'); SELECT $$ SELECT * FROM test5 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT compress_chunk(i) FROM show_chunks('test5') i LIMIT 4; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk SELECT format('%I.%I',ch.schema_name,ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ch JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id JOIN _timescaledb_catalog.hypertable ht2 ON ht.id=ht2.compressed_hypertable_id AND ht2.table_name='test5' \gset SELECT schemaname || '.' || indexname AS "INDEXNAME" FROM pg_indexes i INNER JOIN _timescaledb_catalog.chunk cc ON i.schemaname = cc.schema_name and i.tablename = cc.table_name INNER JOIN _timescaledb_catalog.chunk c ON (cc.id = c.compressed_chunk_id) LIMIT 1 \gset DROP INDEX :INDEXNAME; -- Merging works without indexes on compressed chunks SELECT compress_chunk(i, true) FROM show_chunks('test5') i LIMIT 5; NOTICE: chunk "_hyper_9_190_chunk" is already converted to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk _timescaledb_internal._hyper_9_190_chunk SELECT 'test5' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors psql:include/compression_test_merge.sql:12: NOTICE: chunk "_hyper_9_190_chunk" is already converted to columnstore count_compressed ------------------ 17 ?column? | count -----------------------------------------------------------------------------------+------- Number of rows different between original and query on compressed data (expect 0) | 0 count ------- 1 ?column? | count --------------------------------------------------------------------------------------------------------------+------- Number of rows different between original and data that has been compressed and then decompressed (expect 0) | 0 DROP TABLE test5; CREATE TABLE test6 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test6', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test6 -- This will generate 24 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks. ALTER TABLE test6 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); SELECT compress_chunk(i) FROM show_chunks('test6') i; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_11_215_chunk _timescaledb_internal._hyper_11_215_chunk _timescaledb_internal._hyper_11_217_chunk _timescaledb_internal._hyper_11_217_chunk _timescaledb_internal._hyper_11_219_chunk _timescaledb_internal._hyper_11_219_chunk _timescaledb_internal._hyper_11_221_chunk _timescaledb_internal._hyper_11_221_chunk _timescaledb_internal._hyper_11_223_chunk _timescaledb_internal._hyper_11_223_chunk _timescaledb_internal._hyper_11_225_chunk _timescaledb_internal._hyper_11_225_chunk _timescaledb_internal._hyper_11_227_chunk _timescaledb_internal._hyper_11_227_chunk _timescaledb_internal._hyper_11_229_chunk _timescaledb_internal._hyper_11_229_chunk _timescaledb_internal._hyper_11_231_chunk _timescaledb_internal._hyper_11_231_chunk _timescaledb_internal._hyper_11_233_chunk _timescaledb_internal._hyper_11_233_chunk _timescaledb_internal._hyper_11_235_chunk _timescaledb_internal._hyper_11_235_chunk _timescaledb_internal._hyper_11_237_chunk _timescaledb_internal._hyper_11_237_chunk SELECT count(*) as number_of_chunks FROM show_chunks('test6'); number_of_chunks ------------------ 12 -- This will generate another 24 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-03 1:00'::TIMESTAMPTZ, '2018-03-04 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Altering compress chunk time interval will cause us to create 6 chunks from the additional 24 chunks. ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval='4 hours'); SELECT compress_chunk(i, true) FROM show_chunks('test6') i; NOTICE: chunk "_hyper_11_215_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_217_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_219_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_221_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_223_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_225_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_227_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_229_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_231_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_233_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_235_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_237_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_11_215_chunk _timescaledb_internal._hyper_11_217_chunk _timescaledb_internal._hyper_11_219_chunk _timescaledb_internal._hyper_11_221_chunk _timescaledb_internal._hyper_11_223_chunk _timescaledb_internal._hyper_11_225_chunk _timescaledb_internal._hyper_11_227_chunk _timescaledb_internal._hyper_11_229_chunk _timescaledb_internal._hyper_11_231_chunk _timescaledb_internal._hyper_11_233_chunk _timescaledb_internal._hyper_11_235_chunk _timescaledb_internal._hyper_11_237_chunk _timescaledb_internal._hyper_11_237_chunk _timescaledb_internal._hyper_11_237_chunk _timescaledb_internal._hyper_11_253_chunk _timescaledb_internal._hyper_11_253_chunk _timescaledb_internal._hyper_11_253_chunk _timescaledb_internal._hyper_11_253_chunk _timescaledb_internal._hyper_11_257_chunk _timescaledb_internal._hyper_11_257_chunk _timescaledb_internal._hyper_11_257_chunk _timescaledb_internal._hyper_11_257_chunk _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_269_chunk _timescaledb_internal._hyper_11_269_chunk _timescaledb_internal._hyper_11_269_chunk _timescaledb_internal._hyper_11_269_chunk _timescaledb_internal._hyper_11_273_chunk _timescaledb_internal._hyper_11_273_chunk SELECT count(*) as number_of_chunks FROM show_chunks('test6'); number_of_chunks ------------------ 18 -- This will generate another 3 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-04 1:00'::TIMESTAMPTZ, '2018-03-04 3:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Altering compress chunk time interval will cause us to create 3 chunks from the additional 3 chunks. -- Setting compressed chunk to anything less than chunk interval should disable merging chunks. ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval='30 minutes'); WARNING: compress chunk interval is not a multiple of chunk interval, you should use a factor of chunk interval to merge as much as possible SELECT compress_chunk(i, true) FROM show_chunks('test6') i; NOTICE: chunk "_hyper_11_215_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_217_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_219_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_221_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_223_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_225_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_227_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_229_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_231_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_233_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_235_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_237_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_253_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_257_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_261_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_265_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_269_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_273_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_11_215_chunk _timescaledb_internal._hyper_11_217_chunk _timescaledb_internal._hyper_11_219_chunk _timescaledb_internal._hyper_11_221_chunk _timescaledb_internal._hyper_11_223_chunk _timescaledb_internal._hyper_11_225_chunk _timescaledb_internal._hyper_11_227_chunk _timescaledb_internal._hyper_11_229_chunk _timescaledb_internal._hyper_11_231_chunk _timescaledb_internal._hyper_11_233_chunk _timescaledb_internal._hyper_11_235_chunk _timescaledb_internal._hyper_11_237_chunk _timescaledb_internal._hyper_11_253_chunk _timescaledb_internal._hyper_11_257_chunk _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_269_chunk _timescaledb_internal._hyper_11_273_chunk _timescaledb_internal._hyper_11_281_chunk _timescaledb_internal._hyper_11_282_chunk _timescaledb_internal._hyper_11_283_chunk SELECT count(*) as number_of_chunks FROM show_chunks('test6'); number_of_chunks ------------------ 21 -- This will generate another 3 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-04 4:00'::TIMESTAMPTZ, '2018-03-04 6:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Altering compress chunk time interval will cause us to create 3 chunks from the additional 3 chunks. -- Setting compressed chunk to anything less than chunk interval should disable merging chunks. ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval=0); SELECT compress_chunk(i, true) FROM show_chunks('test6') i; NOTICE: chunk "_hyper_11_215_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_217_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_219_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_221_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_223_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_225_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_227_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_229_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_231_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_233_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_235_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_237_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_253_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_257_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_261_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_265_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_269_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_273_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_281_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_282_chunk" is already converted to columnstore NOTICE: chunk "_hyper_11_283_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_11_215_chunk _timescaledb_internal._hyper_11_217_chunk _timescaledb_internal._hyper_11_219_chunk _timescaledb_internal._hyper_11_221_chunk _timescaledb_internal._hyper_11_223_chunk _timescaledb_internal._hyper_11_225_chunk _timescaledb_internal._hyper_11_227_chunk _timescaledb_internal._hyper_11_229_chunk _timescaledb_internal._hyper_11_231_chunk _timescaledb_internal._hyper_11_233_chunk _timescaledb_internal._hyper_11_235_chunk _timescaledb_internal._hyper_11_237_chunk _timescaledb_internal._hyper_11_253_chunk _timescaledb_internal._hyper_11_257_chunk _timescaledb_internal._hyper_11_261_chunk _timescaledb_internal._hyper_11_265_chunk _timescaledb_internal._hyper_11_269_chunk _timescaledb_internal._hyper_11_273_chunk _timescaledb_internal._hyper_11_281_chunk _timescaledb_internal._hyper_11_282_chunk _timescaledb_internal._hyper_11_283_chunk _timescaledb_internal._hyper_11_287_chunk _timescaledb_internal._hyper_11_288_chunk _timescaledb_internal._hyper_11_289_chunk SELECT count(*) as number_of_chunks FROM show_chunks('test6'); number_of_chunks ------------------ 24 -- Setting compress chunk time to NULL will error out. \set ON_ERROR_STOP 0 ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval=NULL); ERROR: invalid value for timescaledb.compress_chunk_time_interval 'null' \set ON_ERROR_STOP 1 DROP TABLE test6; CREATE TABLE test7 ("Time" timestamptz, i integer, j integer, k integer, value integer); SELECT table_name from create_hypertable('test7', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test7 -- This will generate 24 chunks INSERT INTO test7 SELECT t, i, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks with ordering by j column before time column, causing recompression to occur during merge. ALTER TABLE test7 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='j, "Time" desc', timescaledb.compress_chunk_time_interval='2 hours'); WARNING: compress_chunk_time_interval configured and primary dimension not first column in compress_orderby SELECT $$ SELECT * FROM test7 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test7' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count_compressed ------------------ 24 ?column? | count -----------------------------------------------------------------------------------+------- Number of rows different between original and query on compressed data (expect 0) | 0 count ------- 12 ?column? | count --------------------------------------------------------------------------------------------------------------+------- Number of rows different between original and data that has been compressed and then decompressed (expect 0) | 0 DROP TABLE test7; --#5090 CREATE TABLE test8(time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL); SELECT create_hypertable('test8', 'time', chunk_time_interval => INTERVAL '1 h'); create_hypertable --------------------- (15,public,test8,t) ALTER TABLE test8 set (timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time', timescaledb.compress_chunk_time_interval = '1 day'); INSERT INTO test8 (time, series_id, value) SELECT t, s, 1 FROM generate_series(NOW(), NOW()+INTERVAL'4h', INTERVAL '30s') t CROSS JOIN generate_series(0, 100, 1) s; SELECT compress_chunk(c, true) FROM show_chunks('test8') c LIMIT 4; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_15_341_chunk _timescaledb_internal._hyper_15_341_chunk _timescaledb_internal._hyper_15_341_chunk _timescaledb_internal._hyper_15_341_chunk SET enable_indexscan TO OFF; SET enable_seqscan TO OFF; SET enable_bitmapscan TO ON; SELECT count(*) FROM test8 WHERE series_id = 1; count ------- 481 -- Verify rollup is prevented when compression settings differ CREATE TABLE test9(time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL); SELECT create_hypertable('test9', 'time', chunk_time_interval => INTERVAL '1 h'); create_hypertable --------------------- (17,public,test9,t) ALTER TABLE test9 set (timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time', timescaledb.compress_chunk_time_interval = '1 day'); -- create chunk and compress INSERT INTO test9 (time, series_id, value) SELECT '2020-01-01 00:00:00'::TIMESTAMPTZ, 1, 1; SELECT compress_chunk(show_chunks('test9'), true); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_17_347_chunk INSERT INTO test9 (time, series_id, value) SELECT '2020-01-01 01:00:00'::TIMESTAMPTZ, 1, 1; -- should be 2 chunk before rollup SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 01:00:00 2020 PST test9 | Wed Jan 01 01:00:00 2020 PST | Wed Jan 01 02:00:00 2020 PST SELECT compress_chunk(show_chunks('test9'), true); NOTICE: chunk "_hyper_17_347_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_17_347_chunk _timescaledb_internal._hyper_17_347_chunk -- should be 1 chunk because of rollup SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 02:00:00 2020 PST INSERT INTO test9 (time, series_id, value) SELECT '2020-01-01 02:00:00'::TIMESTAMPTZ, 1, 1; -- should be 2 chunks again SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 02:00:00 2020 PST test9 | Wed Jan 01 02:00:00 2020 PST | Wed Jan 01 03:00:00 2020 PST ALTER TABLE test9 SET (timescaledb.compress_segmentby = ''); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); NOTICE: chunk "_hyper_17_347_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_17_347_chunk _timescaledb_internal._hyper_17_350_chunk -- should not be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 02:00:00 2020 PST test9 | Wed Jan 01 02:00:00 2020 PST | Wed Jan 01 03:00:00 2020 PST ROLLBACK; ALTER TABLE test9 SET (timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time DESC'); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); NOTICE: chunk "_hyper_17_347_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_17_347_chunk _timescaledb_internal._hyper_17_350_chunk -- should not be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 02:00:00 2020 PST test9 | Wed Jan 01 02:00:00 2020 PST | Wed Jan 01 03:00:00 2020 PST ROLLBACK; ALTER TABLE test9 SET (timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time NULLS FIRST'); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); NOTICE: chunk "_hyper_17_347_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_17_347_chunk _timescaledb_internal._hyper_17_350_chunk -- should not be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 02:00:00 2020 PST test9 | Wed Jan 01 02:00:00 2020 PST | Wed Jan 01 03:00:00 2020 PST ROLLBACK; -- reset back to original settings ALTER TABLE test9 SET (timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time'); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); NOTICE: chunk "_hyper_17_347_chunk" is already converted to columnstore compress_chunk ------------------------------------------- _timescaledb_internal._hyper_17_347_chunk _timescaledb_internal._hyper_17_347_chunk -- should be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; hypertable_name | range_start | range_end -----------------+------------------------------+------------------------------ test9 | Wed Jan 01 00:00:00 2020 PST | Wed Jan 01 03:00:00 2020 PST ROLLBACK; -- Test RowExclusiveLock on compressed chunk during chunk rollup using a GUC CREATE TABLE test10 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test10', 'Time', chunk_time_interval=> INTERVAL '1 hour'); table_name ------------ test10 INSERT INTO test10 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:59', '10 minutes') t CROSS JOIN generate_series(1, 3, 1) i; ALTER TABLE test10 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); SHOW timescaledb.enable_rowlevel_compression_locking; timescaledb.enable_rowlevel_compression_locking ------------------------------------------------- off SET timescaledb.enable_rowlevel_compression_locking to on; SELECT compress_chunk(show_chunks('test10')); compress_chunk ------------------------------------------- _timescaledb_internal._hyper_19_354_chunk _timescaledb_internal._hyper_19_354_chunk _timescaledb_internal._hyper_19_356_chunk RESET timescaledb.enable_rowlevel_compression_locking; DROP TABLE test10; RESET enable_indexscan; RESET enable_seqscan; RESET enable_bitmapscan; -- Test chunk merging with default compression settings CREATE TABLE test_defaults ("Time" timestamptz, i integer, value integer) WITH (tsdb.hypertable, tsdb.chunk_interval='1 hour'); NOTICE: using column "Time" as partitioning column CREATE INDEX ON test_defaults (i); ALTER TABLE test_defaults set (timescaledb.compress, timescaledb.compress_chunk_time_interval='2 hours'); WARNING: compress_chunk_time_interval configured and primary dimension not first column in compress_orderby SELECT delete_job(1000); delete_job ------------ -- This will generate 24 chunks INSERT INTO test_defaults SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks SELECT $$ SELECT * FROM test_defaults ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test_defaults' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count_compressed ------------------ 24 ?column? | count -----------------------------------------------------------------------------------+------- Number of rows different between original and query on compressed data (expect 0) | 0 count ------- 12 ?column? | count --------------------------------------------------------------------------------------------------------------+------- Number of rows different between original and data that has been compressed and then decompressed (expect 0) | 0 \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors count ------- 12 min_correct | max_correct -------------+------------- t | t DROP TABLE test_defaults; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_null_dump_restore.out������������������������������0000664�0000000�0000000�00000006350�15100345067�0026355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This test is to verify fixing the behaviour reported in: SDC #2912 -- Create destination database \set TEST_DBNAME_3 :TEST_DBNAME _3 \c postgres :ROLE_SUPERUSER CREATE DATABASE :TEST_DBNAME_3; \c :TEST_DBNAME_3 :ROLE_SUPERUSER create extension timescaledb CASCADE; -- Create source database \set TEST_DBNAME_2 :TEST_DBNAME _2 \c postgres :ROLE_SUPERUSER CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER create extension timescaledb CASCADE; -- Create compressed table with one column having all NULL -- values, so it will be compressed with the NULL algorithm -- create table null_dump (ts int primary key, n int); select create_hypertable('null_dump', 'ts'); create_hypertable ------------------------ (1,public,null_dump,t) insert into null_dump values (1), (2), (3), (4); alter table null_dump set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); select compress_chunk(show_chunks('null_dump')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- Dump the content of the source database \setenv TEST_DBNAME :TEST_DBNAME_2 \setenv DUMP_OPTIONS '--quote-all-identifiers --no-tablespaces --no-owner --no-privileges --exclude-schema=test' \c postgres :ROLE_SUPERUSER \! utils/pg_dump_aux_plain_dump.sh dump/null-compress-dump.sql --quote-all-identifiers --no-tablespaces --no-owner --no-privileges --exclude-schema=test --quote-all-identifiers --no-tablespaces --no-owner --no-privileges --exclude-schema=test --quote-all-identifiers --no-tablespaces --no-owner --no-privileges --exclude-schema=test pg_dump: warning: there are circular foreign-key constraints on this table: pg_dump: detail: hypertable pg_dump: hint: You might not be able to restore the dump without using --disable-triggers or temporarily dropping the constraints. pg_dump: hint: Consider using a full dump instead of a --data-only dump to avoid this problem. pg_dump: warning: there are circular foreign-key constraints on this table: pg_dump: detail: chunk pg_dump: hint: You might not be able to restore the dump without using --disable-triggers or temporarily dropping the constraints. pg_dump: hint: Consider using a full dump instead of a --data-only dump to avoid this problem. pg_dump: warning: there are circular foreign-key constraints on this table: pg_dump: detail: continuous_agg pg_dump: hint: You might not be able to restore the dump without using --disable-triggers or temporarily dropping the constraints. pg_dump: hint: Consider using a full dump instead of a --data-only dump to avoid this problem. -- Restore the data into the destination database \c :TEST_DBNAME_3 :ROLE_SUPERUSER select public.timescaledb_pre_restore(); timescaledb_pre_restore ------------------------- t \set ECHO none select public.timescaledb_post_restore(); timescaledb_post_restore -------------------------- t select * from public.null_dump order by 1; ts | n ----+--- 1 | 2 | 3 | 4 | drop database db_compression_null_dump_restore_2 WITH (FORCE); drop database db_compression_null_dump_restore_3 WITH (FORCE); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_nulls_and_defaults.out�����������������������������0000664�0000000�0000000�00000043063�15100345067�0026463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- test case #1: altering a compressed hypertable by adding a new column -- with a default value -- -- The point of this test is to verify the behaviour of the default value if -- the hypertable is compressed before the new column is added. -- It adds rows before and after the column is added to make sure that the -- default value is returned correctly in both cases. This is to make sure -- that changing the code related to the default value does not break the -- behaviour of the default values. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; NOTICE: table "t" does not exist, skipping create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (1,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk alter table t add column a double precision default 7.1; select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 select compress_chunk(show_chunks('t')); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 insert into t (ts,c1) values (7,7); select compress_chunk(show_chunks('t')); NOTICE: segmentwise recompression is disabled, performing full recompression on chunk "_timescaledb_internal._hyper_1_1_chunk" compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 7 | 7 | 7.1 set timescaledb.enable_segmentwise_recompression to on; -- test case #2: altering an uncompressed hypertable by adding a new column -- with a default value -- -- This is another test case to check that the correct behaviour is preserved -- after changing the code related to the default value. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (3,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); alter table t add column a double precision default 7.1; insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_4_chunk update t set a = null; select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_4_chunk select * from t; ts | c1 | a ----+----+--- 6 | 6 | insert into t (ts,c1) values (7,7); update t set a = null; select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_4_chunk select * from t; ts | c1 | a ----+----+--- 6 | 6 | 7 | 7 | -- test case #3: altering an uncompressed hypertable by adding a new column -- with a default value -- -- This is one more testcase for establishing the correct behaviour of the -- default value after changing the code related to the default value. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (5,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); alter table t add column a double precision default 7.1; insert into t (ts,c1) values (4,4); insert into t (ts,c1) values (5,5); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_6_chunk update t set a = null; select * from t; ts | c1 | a ----+----+--- 4 | 4 | 5 | 5 | 6 | 6 | select compress_chunk(show_chunks('t')); NOTICE: segmentwise recompression is disabled, performing full recompression on chunk "_timescaledb_internal._hyper_5_6_chunk" compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_6_chunk select * from t; ts | c1 | a ----+----+--- 4 | 4 | 5 | 5 | 6 | 6 | set timescaledb.enable_segmentwise_recompression to on; -- test case #4: altering a compressed hypertable by adding a new column -- with a default value -- -- This is one more testcase for establishing the correct behaviour of the -- default value after changing the code. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (7,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); alter table t add column a double precision default 7.1; insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_7_9_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 update t set a = null; insert into t (ts,c1) values (7,7); update t set a = null; select compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_7_9_chunk select * from t; ts | c1 | a ----+----+--- 6 | 6 | 7 | 7 | -- test case #5: altering an uncompressed hypertable by adding a new column -- with a default value -- -- This is the first testcase to reproduce the problem found by Sven. -- Before the fix, the default value was not returned correctly after -- compressing the hypertable. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t (ts int); select create_hypertable('t', 'ts'); create_hypertable ------------------- (9,public,t,t) alter table t set(timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t (ts) values (1); alter table t add column c1 double precision default 42.99; update t set c1 = null; select * from t; ts | c1 ----+---- 1 | select compress_chunk(show_chunks('t')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_11_chunk select * from t; ts | c1 ----+---- 1 | set timescaledb.enable_segmentwise_recompression to on; -- test case #6: altering a compressed hypertable by adding a new column -- with a default value -- -- This is the second testcase to reproduce the problem, by Alex. -- Before the fix, the default value was not returned correctly after -- compressing the hypertable the second time. -- drop table if exists t; create table t(ts int); select create_hypertable('t', 'ts'); create_hypertable ------------------- (11,public,t,t) insert into t values (1); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_13_chunk alter table t add column a double precision default 7.987; insert into t values (2, null); select * from t; ts | a ----+------- 1 | 7.987 2 | select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_13_chunk select * from t; ts | a ----+------- 1 | 7.987 2 | -- test case #7: a variation of #1 where -- the default value is changed after the column is added -- -- This is a variation of the first test case where the default value is -- changed after the column is added. This is to make sure that changing the -- default value does not break the behaviour of the default values. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (13,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_15_chunk alter table t add column a double precision default 7.1; select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 select compress_chunk(show_chunks('t')); NOTICE: chunk "_hyper_13_15_chunk" is already converted to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_15_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 alter table t alter column a set default 7.2; insert into t (ts,c1) values (7,7); select compress_chunk(show_chunks('t')); NOTICE: segmentwise recompression is disabled, performing full recompression on chunk "_timescaledb_internal._hyper_13_15_chunk" compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_15_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 7 | 7 | 7.2 set timescaledb.enable_segmentwise_recompression to on; -- test case #8: a variation of #5 and #7 where -- I change the default value multiple times -- -- This is a variation of the previous test cases with changing the default -- values. Before the fix the first default value was returned for all rows -- even if it was changed twice afterwards and the value was set to null. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (15,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_18_chunk alter table t add column a double precision default 7.1; alter table t alter column a set default 8.2; insert into t (ts,c1) values (7,7); select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 7 | 7 | 8.2 select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_18_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 7 | 7 | 8.2 alter table t alter column a set default 9.3; insert into t (ts,c1) values (8,8); select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 7 | 7 | 8.2 8 | 8 | 9.3 update t set a = null; select * from t; ts | c1 | a ----+----+--- 8 | 8 | 6 | 6 | 7 | 7 | select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_18_chunk select * from t; ts | c1 | a ----+----+--- 6 | 6 | 7 | 7 | 8 | 8 | -- test case #9: a variation of the previous ones with the twist -- of updating another column which triggers decompression and -- risk of re-applying the default value for the other column. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (17,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_20_chunk alter table t add column a double precision default 7.1; select compress_chunk(show_chunks('t')); NOTICE: chunk "_hyper_17_20_chunk" is already converted to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_20_chunk select * from t; ts | c1 | a ----+----+----- 6 | 6 | 7.1 update t set a = null; select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_20_chunk select * from t; ts | c1 | a ----+----+--- 6 | 6 | update t set c1 = 99, a = null; select * from t; ts | c1 | a ----+----+--- 6 | 99 | select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_20_chunk select * from t; ts | c1 | a ----+----+--- 6 | 99 | update t set c1 = 98; select * from t; ts | c1 | a ----+----+--- 6 | 98 | -- test case #10: adding a few columns to a compressed hypertable -- and then updating them to null and dropping them -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); create_hypertable ------------------- (19,public,t,t) alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t (ts,c1) values (1,1); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk alter table t add column a double precision default 3.3; insert into t (ts,c1) values (2,2); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | a ----+----+----- 1 | 1 | 3.3 2 | 2 | 3.3 alter table t add column b double precision default 4.4; insert into t (ts,c1) values (3,3); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | a | b ----+----+-----+----- 1 | 1 | 3.3 | 4.4 2 | 2 | 3.3 | 4.4 3 | 3 | 3.3 | 4.4 update t set a = null; select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | a | b ----+----+---+----- 1 | 1 | | 4.4 2 | 2 | | 4.4 3 | 3 | | 4.4 alter table t add column c double precision; insert into t (ts,c1) values (4,4); select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | a | b | c ----+----+-----+-----+--- 1 | 1 | | 4.4 | 2 | 2 | | 4.4 | 3 | 3 | | 4.4 | 4 | 4 | 3.3 | 4.4 | update t set b = null; select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | a | b | c ----+----+-----+---+--- 1 | 1 | | | 2 | 2 | | | 3 | 3 | | | 4 | 4 | 3.3 | | alter table t drop column a; update t set b = null; select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | b | c ----+----+---+--- 1 | 1 | | 2 | 2 | | 3 | 3 | | 4 | 4 | | alter table t drop column b; update t set c = null; select compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_22_chunk select * from t; ts | c1 | c ----+----+--- 1 | 1 | 2 | 2 | 3 | 3 | 4 | 4 | -- this is to make codecove happy so we exercise some -- code paths that are hard to do through the unit tests drop table if exists codecov; NOTICE: table "codecov" does not exist, skipping create table codecov(ts int, c1 int); select create_hypertable('codecov','ts'); create_hypertable ----------------------- (21,public,codecov,t) alter table codecov set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into codecov (ts,c1) values (1,NULL); select compress_chunk(show_chunks('codecov')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_21_24_chunk DO $$ DECLARE comp_regclass REGCLASS; rec RECORD; BEGIN FOR comp_regclass IN SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as comp_regclass FROM _timescaledb_catalog.chunk uncomp, _timescaledb_catalog.chunk comp, (SELECT show_chunks('codecov') as c) as x WHERE uncomp.dropped IS FALSE AND uncomp.compressed_chunk_id IS NOT NULL AND comp.id = uncomp.compressed_chunk_id AND x.c = format('%I.%I', uncomp.schema_name, uncomp.table_name)::regclass LOOP -- codecov to record coverage of 'tsl_compressed_data_info' FOR rec IN EXECUTE format('SELECT c1, _timescaledb_functions.compressed_data_info(c1) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Compressed info results: %', rec; END LOOP; -- codecov to record coverage of 'tsl_compressed_data_has_nulls' FOR rec IN EXECUTE format('SELECT c1, _timescaledb_functions.compressed_data_has_nulls(c1) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Has nulls results: %', rec; END LOOP; END LOOP; END; $$; NOTICE: Compressed info results: (Bg==,"(NULL,t)") NOTICE: Has nulls results: (Bg==,t) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_permissions-15.out���������������������������������0000664�0000000�0000000�00000040461�15100345067�0025412�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 CREATE VIEW hypertable_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ct.schema_name, ct.table_name) FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed, (SELECT relacl FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed_acl FROM _timescaledb_catalog.hypertable ht LEFT JOIN _timescaledb_catalog.hypertable ct ON ht.compressed_hypertable_id = ct.id; CREATE VIEW chunk_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ch.schema_name, ch.table_name) FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk, (SELECT relacl FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk_acl FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=>'1month'::interval); table_name ------------ conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); ERROR: must be owner of table conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --now owner tries and succeeds -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; --try modifying compress properties -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'humidity'); ERROR: must be owner of table conditions --- compress_chunks and decompress_chunks fail without correct perm -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT compress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" SELECT decompress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" select add_compression_policy('conditions', '1day'::interval); ERROR: must be owner of hypertable "conditions" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select add_compression_policy('conditions', '1day'::interval); add_compression_policy ------------------------ 1000 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --try dropping policy select remove_compression_policy('conditions', true); ERROR: must be owner of hypertable "conditions" --Tests for GRANTS. -- as owner grant select , compress chunk and check SELECT works \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT SELECT on conditions to :ROLE_DEFAULT_PERM_USER_2; SELECT count(compress_chunk(ch)) FROM show_chunks('conditions') ch; count ------- 2 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from conditions; count ------- 31 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT INSERT on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 insert into conditions select '2019-04-01 00:00+0'::timestamp with time zone, 'NYC', 'klick', 55, 75; select count(*) from conditions; count ------- 32 update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT UPDATE, DELETE on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- NYC --NOTE constraint exclusion excludes the other chunks here --otherwise update would fail update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- SFO --update expected to fail as executor touches all chunks update conditions set location = 'PNC' where location = 'SFO'; delete from conditions where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- CREATE VIEW v2 as select * from conditions; select count(*) from v2; count ------- 31 --should fail after revoking permissions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER REVOKE SELECT on conditions FROM :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from v2; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLE conditions CASCADE; NOTICE: drop cascades to view v2 -- Testing that permissions propagate to compressed hypertables and to -- compressed chunks. -- Table is created by superuser CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable( 'conditions', 'timec', chunk_time_interval => '1 week'::interval); table_name ------------ conditions ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec' ); INSERT INTO conditions SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75; SELECT compress_chunk(show_chunks('conditions')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk _timescaledb_internal._hyper_3_9_chunk _timescaledb_internal._hyper_3_10_chunk -- Check that ACL propagates to compressed hypertable. We could prune -- the listing by only selecting chunks where the ACL does not match -- the hypertable ACL, but for now we list all to make debugging easy. \x on SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+----------------------------------------------- hypertable | public.conditions hypertable_acl | compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | -[ RECORD 2 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | -[ RECORD 3 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | -[ RECORD 4 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | -[ RECORD 5 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | GRANT SELECT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -- Add some new data and compress the chunks. The chunks should get -- the permissions of the hypertable. We pick a start date to make -- sure that we are not inserting into an already compressed chunk. INSERT INTO conditions SELECT generate_series('2019-01-07 00:00'::timestamp, '2019-02-07 00:00'::timestamp, '1 day'), 'XYZ', 47, 11; SELECT compress_chunk(show_chunks('conditions', newer_than => '2019-01-01')); -[ RECORD 1 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_16_chunk -[ RECORD 2 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_17_chunk -[ RECORD 3 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_18_chunk -[ RECORD 4 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_19_chunk -[ RECORD 5 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_20_chunk -[ RECORD 6 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_21_chunk SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 6 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_22_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 7 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_23_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 8 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_24_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 9 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_25_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 10 ]-+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_26_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 11 ]-+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_27_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} \x off --TEST user that has insert permission can insert into a compressed chunk GRANT INSERT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM conditions; count ------- 63 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 SET ROLE :ROLE_DEFAULT_PERM_USER; --insert into a compressed chunk -- INSERT INTO conditions VALUES( '2018-12-02 00:00'::timestamp, 'NYC', 75, 95); SELECT count(*) FROM conditions; count ------- 64 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_permissions-16.out���������������������������������0000664�0000000�0000000�00000040461�15100345067�0025413�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 CREATE VIEW hypertable_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ct.schema_name, ct.table_name) FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed, (SELECT relacl FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed_acl FROM _timescaledb_catalog.hypertable ht LEFT JOIN _timescaledb_catalog.hypertable ct ON ht.compressed_hypertable_id = ct.id; CREATE VIEW chunk_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ch.schema_name, ch.table_name) FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk, (SELECT relacl FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk_acl FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=>'1month'::interval); table_name ------------ conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); ERROR: must be owner of table conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --now owner tries and succeeds -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; --try modifying compress properties -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'humidity'); ERROR: must be owner of table conditions --- compress_chunks and decompress_chunks fail without correct perm -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT compress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" SELECT decompress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" select add_compression_policy('conditions', '1day'::interval); ERROR: must be owner of hypertable "conditions" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select add_compression_policy('conditions', '1day'::interval); add_compression_policy ------------------------ 1000 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --try dropping policy select remove_compression_policy('conditions', true); ERROR: must be owner of hypertable "conditions" --Tests for GRANTS. -- as owner grant select , compress chunk and check SELECT works \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT SELECT on conditions to :ROLE_DEFAULT_PERM_USER_2; SELECT count(compress_chunk(ch)) FROM show_chunks('conditions') ch; count ------- 2 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from conditions; count ------- 31 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT INSERT on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 insert into conditions select '2019-04-01 00:00+0'::timestamp with time zone, 'NYC', 'klick', 55, 75; select count(*) from conditions; count ------- 32 update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT UPDATE, DELETE on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- NYC --NOTE constraint exclusion excludes the other chunks here --otherwise update would fail update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- SFO --update expected to fail as executor touches all chunks update conditions set location = 'PNC' where location = 'SFO'; delete from conditions where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- CREATE VIEW v2 as select * from conditions; select count(*) from v2; count ------- 31 --should fail after revoking permissions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER REVOKE SELECT on conditions FROM :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from v2; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLE conditions CASCADE; NOTICE: drop cascades to view v2 -- Testing that permissions propagate to compressed hypertables and to -- compressed chunks. -- Table is created by superuser CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable( 'conditions', 'timec', chunk_time_interval => '1 week'::interval); table_name ------------ conditions ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec' ); INSERT INTO conditions SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75; SELECT compress_chunk(show_chunks('conditions')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk _timescaledb_internal._hyper_3_9_chunk _timescaledb_internal._hyper_3_10_chunk -- Check that ACL propagates to compressed hypertable. We could prune -- the listing by only selecting chunks where the ACL does not match -- the hypertable ACL, but for now we list all to make debugging easy. \x on SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+----------------------------------------------- hypertable | public.conditions hypertable_acl | compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | -[ RECORD 2 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | -[ RECORD 3 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | -[ RECORD 4 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | -[ RECORD 5 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | GRANT SELECT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -- Add some new data and compress the chunks. The chunks should get -- the permissions of the hypertable. We pick a start date to make -- sure that we are not inserting into an already compressed chunk. INSERT INTO conditions SELECT generate_series('2019-01-07 00:00'::timestamp, '2019-02-07 00:00'::timestamp, '1 day'), 'XYZ', 47, 11; SELECT compress_chunk(show_chunks('conditions', newer_than => '2019-01-01')); -[ RECORD 1 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_16_chunk -[ RECORD 2 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_17_chunk -[ RECORD 3 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_18_chunk -[ RECORD 4 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_19_chunk -[ RECORD 5 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_20_chunk -[ RECORD 6 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_21_chunk SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 6 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_22_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 7 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_23_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 8 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_24_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 9 ]--+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_25_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 10 ]-+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_26_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} -[ RECORD 11 ]-+--------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_27_chunk chunk_acl | {super_user=arwdDxt/super_user,default_perm_user=r/super_user} \x off --TEST user that has insert permission can insert into a compressed chunk GRANT INSERT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM conditions; count ------- 63 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 SET ROLE :ROLE_DEFAULT_PERM_USER; --insert into a compressed chunk -- INSERT INTO conditions VALUES( '2018-12-02 00:00'::timestamp, 'NYC', 75, 95); SELECT count(*) FROM conditions; count ------- 64 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_permissions-17.out���������������������������������0000664�0000000�0000000�00000040544�15100345067�0025416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 CREATE VIEW hypertable_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ct.schema_name, ct.table_name) FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed, (SELECT relacl FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed_acl FROM _timescaledb_catalog.hypertable ht LEFT JOIN _timescaledb_catalog.hypertable ct ON ht.compressed_hypertable_id = ct.id; CREATE VIEW chunk_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ch.schema_name, ch.table_name) FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk, (SELECT relacl FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk_acl FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=>'1month'::interval); table_name ------------ conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); ERROR: must be owner of table conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --now owner tries and succeeds -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; --try modifying compress properties -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'humidity'); ERROR: must be owner of table conditions --- compress_chunks and decompress_chunks fail without correct perm -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT compress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" SELECT decompress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" select add_compression_policy('conditions', '1day'::interval); ERROR: must be owner of hypertable "conditions" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select add_compression_policy('conditions', '1day'::interval); add_compression_policy ------------------------ 1000 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --try dropping policy select remove_compression_policy('conditions', true); ERROR: must be owner of hypertable "conditions" --Tests for GRANTS. -- as owner grant select , compress chunk and check SELECT works \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT SELECT on conditions to :ROLE_DEFAULT_PERM_USER_2; SELECT count(compress_chunk(ch)) FROM show_chunks('conditions') ch; count ------- 2 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from conditions; count ------- 31 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT INSERT on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 insert into conditions select '2019-04-01 00:00+0'::timestamp with time zone, 'NYC', 'klick', 55, 75; select count(*) from conditions; count ------- 32 update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT UPDATE, DELETE on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- NYC --NOTE constraint exclusion excludes the other chunks here --otherwise update would fail update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- SFO --update expected to fail as executor touches all chunks update conditions set location = 'PNC' where location = 'SFO'; delete from conditions where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- CREATE VIEW v2 as select * from conditions; select count(*) from v2; count ------- 31 --should fail after revoking permissions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER REVOKE SELECT on conditions FROM :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from v2; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLE conditions CASCADE; NOTICE: drop cascades to view v2 -- Testing that permissions propagate to compressed hypertables and to -- compressed chunks. -- Table is created by superuser CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable( 'conditions', 'timec', chunk_time_interval => '1 week'::interval); table_name ------------ conditions ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec' ); INSERT INTO conditions SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75; SELECT compress_chunk(show_chunks('conditions')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk _timescaledb_internal._hyper_3_9_chunk _timescaledb_internal._hyper_3_10_chunk -- Check that ACL propagates to compressed hypertable. We could prune -- the listing by only selecting chunks where the ACL does not match -- the hypertable ACL, but for now we list all to make debugging easy. \x on SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+----------------------------------------------- hypertable | public.conditions hypertable_acl | compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | -[ RECORD 2 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | -[ RECORD 3 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | -[ RECORD 4 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | -[ RECORD 5 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | GRANT SELECT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -- Add some new data and compress the chunks. The chunks should get -- the permissions of the hypertable. We pick a start date to make -- sure that we are not inserting into an already compressed chunk. INSERT INTO conditions SELECT generate_series('2019-01-07 00:00'::timestamp, '2019-02-07 00:00'::timestamp, '1 day'), 'XYZ', 47, 11; SELECT compress_chunk(show_chunks('conditions', newer_than => '2019-01-01')); -[ RECORD 1 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_16_chunk -[ RECORD 2 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_17_chunk -[ RECORD 3 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_18_chunk -[ RECORD 4 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_19_chunk -[ RECORD 5 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_20_chunk -[ RECORD 6 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_21_chunk SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 6 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_22_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 7 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_23_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 8 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_24_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 9 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_25_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 10 ]-+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_26_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 11 ]-+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_27_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} \x off --TEST user that has insert permission can insert into a compressed chunk GRANT INSERT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM conditions; count ------- 63 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 SET ROLE :ROLE_DEFAULT_PERM_USER; --insert into a compressed chunk -- INSERT INTO conditions VALUES( '2018-12-02 00:00'::timestamp, 'NYC', 75, 95); SELECT count(*) FROM conditions; count ------- 64 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 ������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_permissions-18.out���������������������������������0000664�0000000�0000000�00000040544�15100345067�0025417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 CREATE VIEW hypertable_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ct.schema_name, ct.table_name) FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed, (SELECT relacl FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed_acl FROM _timescaledb_catalog.hypertable ht LEFT JOIN _timescaledb_catalog.hypertable ct ON ht.compressed_hypertable_id = ct.id; CREATE VIEW chunk_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ch.schema_name, ch.table_name) FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk, (SELECT relacl FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk_acl FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=>'1month'::interval); table_name ------------ conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); ERROR: must be owner of table conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --now owner tries and succeeds -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; --try modifying compress properties -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'humidity'); ERROR: must be owner of table conditions --- compress_chunks and decompress_chunks fail without correct perm -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT compress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" SELECT decompress_chunk(show_chunks('conditions')); ERROR: must be owner of hypertable "conditions" select add_compression_policy('conditions', '1day'::interval); ERROR: must be owner of hypertable "conditions" \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select add_compression_policy('conditions', '1day'::interval); add_compression_policy ------------------------ 1000 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --try dropping policy select remove_compression_policy('conditions', true); ERROR: must be owner of hypertable "conditions" --Tests for GRANTS. -- as owner grant select , compress chunk and check SELECT works \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT SELECT on conditions to :ROLE_DEFAULT_PERM_USER_2; SELECT count(compress_chunk(ch)) FROM show_chunks('conditions') ch; count ------- 2 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from conditions; count ------- 31 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT INSERT on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 insert into conditions select '2019-04-01 00:00+0'::timestamp with time zone, 'NYC', 'klick', 55, 75; select count(*) from conditions; count ------- 32 update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT UPDATE, DELETE on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- NYC --NOTE constraint exclusion excludes the other chunks here --otherwise update would fail update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- SFO --update expected to fail as executor touches all chunks update conditions set location = 'PNC' where location = 'SFO'; delete from conditions where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; location ---------- CREATE VIEW v2 as select * from conditions; select count(*) from v2; count ------- 31 --should fail after revoking permissions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER REVOKE SELECT on conditions FROM :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from v2; ERROR: permission denied for table conditions \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLE conditions CASCADE; NOTICE: drop cascades to view v2 -- Testing that permissions propagate to compressed hypertables and to -- compressed chunks. -- Table is created by superuser CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable( 'conditions', 'timec', chunk_time_interval => '1 week'::interval); table_name ------------ conditions ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec' ); INSERT INTO conditions SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75; SELECT compress_chunk(show_chunks('conditions')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk _timescaledb_internal._hyper_3_9_chunk _timescaledb_internal._hyper_3_10_chunk -- Check that ACL propagates to compressed hypertable. We could prune -- the listing by only selecting chunks where the ACL does not match -- the hypertable ACL, but for now we list all to make debugging easy. \x on SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+----------------------------------------------- hypertable | public.conditions hypertable_acl | compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | -[ RECORD 2 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | -[ RECORD 3 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | -[ RECORD 4 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | -[ RECORD 5 ]--+------------------------------------------------ hypertable | public.conditions hypertable_acl | chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | GRANT SELECT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; -[ RECORD 1 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} compressed | _timescaledb_internal._compressed_hypertable_4 compressed_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -- Add some new data and compress the chunks. The chunks should get -- the permissions of the hypertable. We pick a start date to make -- sure that we are not inserting into an already compressed chunk. INSERT INTO conditions SELECT generate_series('2019-01-07 00:00'::timestamp, '2019-02-07 00:00'::timestamp, '1 day'), 'XYZ', 47, 11; SELECT compress_chunk(show_chunks('conditions', newer_than => '2019-01-01')); -[ RECORD 1 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_16_chunk -[ RECORD 2 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_17_chunk -[ RECORD 3 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_18_chunk -[ RECORD 4 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_19_chunk -[ RECORD 5 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_20_chunk -[ RECORD 6 ]--+---------------------------------------- compress_chunk | _timescaledb_internal._hyper_3_21_chunk SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -[ RECORD 1 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_11_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 2 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_12_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 3 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_13_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 4 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_14_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 5 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_15_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 6 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_22_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 7 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_23_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 8 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_24_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 9 ]--+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_25_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 10 ]-+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_26_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} -[ RECORD 11 ]-+---------------------------------------------------------------- hypertable | public.conditions hypertable_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} chunk | _timescaledb_internal.compress_hyper_4_27_chunk chunk_acl | {super_user=arwdDxtm/super_user,default_perm_user=r/super_user} \x off --TEST user that has insert permission can insert into a compressed chunk GRANT INSERT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM conditions; count ------- 63 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 SET ROLE :ROLE_DEFAULT_PERM_USER; --insert into a compressed chunk -- INSERT INTO conditions VALUES( '2018-12-02 00:00'::timestamp, 'NYC', 75, 95); SELECT count(*) FROM conditions; count ------- 64 SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; count ------- 11 ������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_policy.out�����������������������������������������0000664�0000000�0000000�00000006576�15100345067�0024124�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. ---- -- Chunk interval 1 month - compression schedule interval should be 12 hours ---- CREATE TABLE sensor_data_1month( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1month', 'time', chunk_time_interval => INTERVAL '1 month'); -- ALTER TABLE sensor_data_1month SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1month','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; schedule_interval ------------------- @ 12 hours ---- -- Chunk interval 1 week - compression schedule interval should be 12 hours ---- CREATE TABLE sensor_data_1week( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1week', 'time', chunk_time_interval => INTERVAL '1 week'); -- ALTER TABLE sensor_data_1week SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1week','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; schedule_interval ------------------- @ 12 hours ---- -- Chunk interval 1 day - compression schedule interval should be 12 hours ---- CREATE TABLE sensor_data_1day( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1day', 'time', chunk_time_interval => INTERVAL '1 day'); -- ALTER TABLE sensor_data_1day SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1day','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; schedule_interval ------------------- @ 12 hours ---- -- Chunk interval 1 hour - compression schedule interval should be 30 minutes ---- CREATE TABLE sensor_data_1hour( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1hour', 'time', chunk_time_interval => INTERVAL '1 hour'); -- ALTER TABLE sensor_data_1hour SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1hour','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; schedule_interval ------------------- @ 30 mins ---- -- Chunk interval 1 hour - compression schedule is set to a custom value ---- CREATE TABLE sensor_data_1hour_custom( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1hour_custom', 'time', chunk_time_interval => INTERVAL '1 hour'); -- ALTER TABLE sensor_data_1hour_custom SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1hour_custom','7 days'::INTERVAL, schedule_interval => '7 days') as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; schedule_interval ------------------- @ 7 days ����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_qualpushdown.out�����������������������������������0000664�0000000�0000000�00000065202�15100345067�0025346�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. set max_parallel_workers_per_gather = 0; -- qual pushdown tests for decompresschunk --- -- Test qual pushdown with ints CREATE TABLE meta (device_id INT PRIMARY KEY); CREATE TABLE hyper( time INT NOT NULL, device_id INT REFERENCES meta(device_id) ON DELETE CASCADE ON UPDATE CASCADE, val INT); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO meta VALUES (1), (2), (3), (4), (5); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2); SELECT ch1.table_name AS "CHUNK_NAME", ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' ORDER BY ch1.id LIMIT 1 \gset SELECT compress_chunk(:'CHUNK_FULL_NAME'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk VACUUM FULL ANALYZE hyper; -- test for qual pushdown explain (buffers off, costs off, verbose) SELECT FROM hyper WHERE time > 2::bigint and time < 4; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Vectorized Filter: ((_hyper_1_1_chunk."time" > '2'::bigint) AND (_hyper_1_1_chunk."time" < 4)) -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.device_id, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk."time", compress_hyper_2_3_chunk.val Filter: ((compress_hyper_2_3_chunk._ts_meta_max_1 > '2'::bigint) AND (compress_hyper_2_3_chunk._ts_meta_min_1 < 4)) explain (buffers off, costs off, verbose) SELECT FROM hyper WHERE time = 3::bigint; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Vectorized Filter: (_hyper_1_1_chunk."time" = '3'::bigint) -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.device_id, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk."time", compress_hyper_2_3_chunk.val Filter: ((compress_hyper_2_3_chunk._ts_meta_min_1 <= '3'::bigint) AND (compress_hyper_2_3_chunk._ts_meta_max_1 >= '3'::bigint)) SELECT * FROM hyper WHERE time > 2::bigint and time < 4; time | device_id | val ------+-----------+----- 3 | 3 | 1 SELECT * FROM hyper WHERE time = 3::bigint; time | device_id | val ------+-----------+----- 3 | 3 | 1 SELECT * FROM hyper where time = val + 1; time | device_id | val ------+-----------+----- 2 | 2 | 1 -- Test some volatile and stable functions SET timescaledb.enable_chunk_append TO OFF; SET timescaledb.enable_constraint_aware_append TO OFF; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = device_id; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: ("time" = device_id) -> Seq Scan on compress_hyper_2_3_chunk Filter: ((_ts_meta_min_1 <= device_id) AND (_ts_meta_max_1 >= device_id)) -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = device_id) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = random()::int; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: ("time" = (random())::integer) -> Seq Scan on compress_hyper_2_3_chunk -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = (random())::integer) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = CASE WHEN now() > '1970-01-01' THEN random()::int ELSE device_id END; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: ("time" = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN (random())::integer ELSE device_id END) -> Seq Scan on compress_hyper_2_3_chunk -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN (random())::integer ELSE device_id END) EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = CASE WHEN now() > '1970-01-01' THEN 1 ELSE device_id END; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: ("time" = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE device_id END) -> Seq Scan on compress_hyper_2_3_chunk Filter: ((_ts_meta_min_1 <= CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE device_id END) AND (_ts_meta_max_1 >= CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE device_id END)) -> Seq Scan on _hyper_1_2_chunk Filter: ("time" = CASE WHEN (now() > 'Thu Jan 01 00:00:00 1970 PST'::timestamp with time zone) THEN 1 ELSE device_id END) RESET timescaledb.enable_chunk_append; RESET timescaledb.enable_constraint_aware_append; --- github issue 1855 --- TESTs for meta column pushdown filters on exprs with casts. CREATE TABLE metaseg_tab ( fmid smallint, factorid smallint, start_dt timestamp without time zone, end_dt timestamp without time zone, interval_number smallint, logret double precision, knowledge_date date NOT NULL ); SELECT create_hypertable('metaseg_tab', 'end_dt', chunk_time_interval=>interval '1 month', create_default_indexes=>false); WARNING: column type "timestamp without time zone" used for "start_dt" does not follow best practices WARNING: column type "timestamp without time zone" used for "end_dt" does not follow best practices create_hypertable -------------------------- (3,public,metaseg_tab,t) SELECT add_dimension('metaseg_tab', 'fmid', chunk_time_interval => 1); add_dimension ------------------------------- (3,public,metaseg_tab,fmid,t) ALTER TABLE metaseg_tab SET (timescaledb.compress, timescaledb.compress_orderby= 'end_dt'); INSERT INTO metaseg_tab values (56,0,'2012-12-10 09:45:00','2012-12-10 09:50:00',1,0.1,'2012-12-10'); SELECT compress_chunk(i) from show_chunks('metaseg_tab') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_4_chunk VACUUM FULL ANALYZE metaseg_tab; select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt between '2012-12-10'::date and '2012-12-11'::date order by factorid, end_dt; factorid | end_dt | logret ----------+--------------------------+-------- 0 | Mon Dec 10 09:50:00 2012 | 0.1 explain (buffers off, costs off, verbose) select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt between '2012-12-10'::date and '2012-12-11'::date order by factorid, end_dt; --- QUERY PLAN --- Sort Output: _hyper_3_4_chunk.factorid, _hyper_3_4_chunk.end_dt, _hyper_3_4_chunk.logret Sort Key: _hyper_3_4_chunk.factorid, _hyper_3_4_chunk.end_dt -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_4_chunk Output: _hyper_3_4_chunk.factorid, _hyper_3_4_chunk.end_dt, _hyper_3_4_chunk.logret Filter: ((_hyper_3_4_chunk.end_dt >= '12-10-2012'::date) AND (_hyper_3_4_chunk.end_dt <= '12-11-2012'::date)) Vectorized Filter: (_hyper_3_4_chunk.fmid = 56) -> Seq Scan on _timescaledb_internal.compress_hyper_4_5_chunk Output: compress_hyper_4_5_chunk._ts_meta_count, compress_hyper_4_5_chunk.fmid, compress_hyper_4_5_chunk.factorid, compress_hyper_4_5_chunk.start_dt, compress_hyper_4_5_chunk._ts_meta_min_1, compress_hyper_4_5_chunk._ts_meta_max_1, compress_hyper_4_5_chunk.end_dt, compress_hyper_4_5_chunk.interval_number, compress_hyper_4_5_chunk.logret, compress_hyper_4_5_chunk.knowledge_date Filter: ((compress_hyper_4_5_chunk._ts_meta_max_1 >= '12-10-2012'::date) AND (compress_hyper_4_5_chunk._ts_meta_min_1 <= '12-11-2012'::date)) --no pushdown here select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date between '2012-12-10'::timestamp and '2012-12-11'::date order by factorid, end_dt; factorid | end_dt | logret ----------+--------------------------+-------- 0 | Mon Dec 10 09:50:00 2012 | 0.1 explain (buffers off, costs off, verbose) select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date between '2012-12-10'::timestamp and '2012-12-11'::date order by factorid, end_dt; --- QUERY PLAN --- Sort Output: _hyper_3_4_chunk.factorid, _hyper_3_4_chunk.end_dt, _hyper_3_4_chunk.logret Sort Key: _hyper_3_4_chunk.factorid, _hyper_3_4_chunk.end_dt -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_4_chunk Output: _hyper_3_4_chunk.factorid, _hyper_3_4_chunk.end_dt, _hyper_3_4_chunk.logret Filter: (((_hyper_3_4_chunk.end_dt)::date >= 'Mon Dec 10 00:00:00 2012'::timestamp without time zone) AND ((_hyper_3_4_chunk.end_dt)::date <= '12-11-2012'::date)) Vectorized Filter: (_hyper_3_4_chunk.fmid = 56) -> Seq Scan on _timescaledb_internal.compress_hyper_4_5_chunk Output: compress_hyper_4_5_chunk._ts_meta_count, compress_hyper_4_5_chunk.fmid, compress_hyper_4_5_chunk.factorid, compress_hyper_4_5_chunk.start_dt, compress_hyper_4_5_chunk._ts_meta_min_1, compress_hyper_4_5_chunk._ts_meta_max_1, compress_hyper_4_5_chunk.end_dt, compress_hyper_4_5_chunk.interval_number, compress_hyper_4_5_chunk.logret, compress_hyper_4_5_chunk.knowledge_date --should fail \set ON_ERROR_STOP 0 select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date = 10; ERROR: operator does not exist: date = integer at character 83 select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date = 'dec 2010'::date; ERROR: invalid input syntax for type date: "dec 2010" at character 85 -- test casts between different char types are pushed down CREATE TABLE pushdown_relabel(time timestamptz NOT NULL, dev_vc varchar(10), dev_c char(10)); SELECT table_name FROM create_hypertable('pushdown_relabel', 'time'); WARNING: column type "character varying" used for "dev_vc" does not follow best practices table_name ------------------ pushdown_relabel ALTER TABLE pushdown_relabel SET (timescaledb.compress, timescaledb.compress_segmentby='dev_vc,dev_c'); INSERT INTO pushdown_relabel SELECT '2000-01-01','varchar','char'; SELECT compress_chunk(i) from show_chunks('pushdown_relabel') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_6_chunk VACUUM FULL ANALYZE pushdown_relabel; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Seq Scan on compress_hyper_6_7_chunk Filter: ((dev_vc)::text = 'varchar'::text) EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_c = 'char'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Seq Scan on compress_hyper_6_7_chunk Filter: (dev_c = 'char'::bpchar) EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar' AND dev_c = 'char'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Seq Scan on compress_hyper_6_7_chunk Filter: (((dev_vc)::text = 'varchar'::text) AND (dev_c = 'char'::bpchar)) EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'::char(10) AND dev_c = 'char'::varchar; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Seq Scan on compress_hyper_6_7_chunk Filter: (((dev_vc)::bpchar = 'varchar '::character(10)) AND (dev_c = 'char'::bpchar)) -- test again with index scans SET enable_seqscan TO false; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Index Scan using compress_hyper_6_7_chunk_dev_vc_dev_c__ts_meta_min_1__ts_me_idx on compress_hyper_6_7_chunk Index Cond: ((dev_vc)::text = 'varchar'::text) EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_c = 'char'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Index Scan using compress_hyper_6_7_chunk_dev_vc_dev_c__ts_meta_min_1__ts_me_idx on compress_hyper_6_7_chunk Index Cond: (dev_c = 'char'::bpchar) EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar' AND dev_c = 'char'; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Index Scan using compress_hyper_6_7_chunk_dev_vc_dev_c__ts_meta_min_1__ts_me_idx on compress_hyper_6_7_chunk Index Cond: (((dev_vc)::text = 'varchar'::text) AND (dev_c = 'char'::bpchar)) EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'::char(10) AND dev_c = 'char'::varchar; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_5_6_chunk -> Index Scan using compress_hyper_6_7_chunk_dev_vc_dev_c__ts_meta_min_1__ts_me_idx on compress_hyper_6_7_chunk Index Cond: (dev_c = 'char'::bpchar) Filter: ((dev_vc)::bpchar = 'varchar '::character(10)) RESET enable_seqscan; -- github issue #5286 CREATE TABLE deleteme AS SELECT generate_series AS timestamp, 1 AS segment, 0 AS data FROM generate_series('2008-03-01 00:00'::timestamp with time zone, '2008-03-04 12:00', '1 second'); SELECT create_hypertable('deleteme', 'timestamp', migrate_data => true); NOTICE: migrating data to chunks create_hypertable ----------------------- (7,public,deleteme,t) ALTER TABLE deleteme SET ( timescaledb.compress, timescaledb.compress_segmentby = 'segment' ); SELECT compress_chunk(i) FROM show_chunks('deleteme') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_7_8_chunk VACUUM FULL ANALYZE deleteme; EXPLAIN (buffers off, costs off) SELECT sum(data) FROM deleteme WHERE segment::text like '%4%'; --- QUERY PLAN --- Aggregate -> Custom Scan (ColumnarScan) on _hyper_7_8_chunk -> Seq Scan on compress_hyper_8_9_chunk Filter: ((segment)::text ~~ '%4%'::text) EXPLAIN (buffers off, costs off) SELECT sum(data) FROM deleteme WHERE '4' = segment::text; --- QUERY PLAN --- Aggregate -> Custom Scan (ColumnarScan) on _hyper_7_8_chunk -> Seq Scan on compress_hyper_8_9_chunk Filter: ('4'::text = (segment)::text) CREATE TABLE deleteme_with_bytea(time bigint NOT NULL, bdata bytea); SELECT create_hypertable('deleteme_with_bytea', 'time', chunk_time_interval => 1000000); create_hypertable ---------------------------------- (9,public,deleteme_with_bytea,t) INSERT INTO deleteme_with_bytea(time, bdata) VALUES (1001, E'\\x'); INSERT INTO deleteme_with_bytea(time, bdata) VALUES (1001, NULL); ALTER TABLE deleteme_with_bytea SET ( timescaledb.compress, timescaledb.compress_segmentby = 'bdata' ); SELECT compress_chunk(i) FROM show_chunks('deleteme_with_bytea') i; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_10_chunk VACUUM FULL ANALYZE deleteme_with_bytea; EXPLAIN (buffers off, costs off) SELECT '1' FROM deleteme_with_bytea WHERE bdata = E'\\x'; --- QUERY PLAN --- Result -> Custom Scan (ColumnarScan) on _hyper_9_10_chunk -> Seq Scan on compress_hyper_10_11_chunk Filter: (bdata = '\x'::bytea) EXPLAIN (buffers off, costs off) SELECT '1' FROM deleteme_with_bytea WHERE bdata::text = '123'; --- QUERY PLAN --- Result -> Custom Scan (ColumnarScan) on _hyper_9_10_chunk -> Seq Scan on compress_hyper_10_11_chunk Filter: ((bdata)::text = '123'::text) DROP table deleteme; DROP table deleteme_with_bytea; -- test sqlvaluefunction pushdown CREATE TABLE svf_pushdown(time timestamptz, c_date date, c_time time, c_timetz timetz, c_timestamp timestamptz, c_name text, c_bool bool); SELECT table_name FROM create_hypertable('svf_pushdown', 'time'); table_name -------------- svf_pushdown ALTER TABLE svf_pushdown SET (timescaledb.compress,timescaledb.compress_segmentby='c_date,c_time, c_timetz,c_timestamp,c_name,c_bool'); INSERT INTO svf_pushdown SELECT '2020-01-01'; SELECT compress_chunk(show_chunks('svf_pushdown')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk VACUUM FULL ANALYZE svf_pushdown; -- constraints should be pushed down into scan below decompresschunk in all cases EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_date = CURRENT_DATE; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_date = CURRENT_DATE) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timetz = CURRENT_TIME; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_timetz = CURRENT_TIME) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timetz = CURRENT_TIME(1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_timetz = CURRENT_TIME(1)) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = CURRENT_TIMESTAMP; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_timestamp = CURRENT_TIMESTAMP) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = CURRENT_TIMESTAMP(1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_timestamp = CURRENT_TIMESTAMP(1)) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_time = LOCALTIME; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_time = LOCALTIME) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_time = LOCALTIME(1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_time = LOCALTIME(1)) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = LOCALTIMESTAMP; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_timestamp = LOCALTIMESTAMP) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = LOCALTIMESTAMP(1); --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_timestamp = LOCALTIMESTAMP(1)) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = USER; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_name = USER) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_USER; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_name = CURRENT_USER) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = SESSION_USER; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_name = SESSION_USER) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_USER OR c_name = SESSION_USER; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: ((c_name = CURRENT_USER) OR (c_name = SESSION_USER)) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_CATALOG; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_name = CURRENT_CATALOG) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_SCHEMA; --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (c_name = CURRENT_SCHEMA) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_bool; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: c_bool EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_bool = true; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: c_bool EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_bool = false; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (NOT c_bool) EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE NOT c_bool; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Seq Scan on compress_hyper_12_13_chunk Filter: (NOT c_bool) -- current_query() is not a sqlvaluefunction and volatile so should not be pushed down EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = current_query(); --- QUERY PLAN --- Custom Scan (ChunkAppend) on svf_pushdown Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk Filter: (c_name = current_query()) -> Seq Scan on compress_hyper_12_13_chunk -- test or constraints in lateral query #6912 SELECT FROM svf_pushdown m1, LATERAL( SELECT FROM svf_pushdown m2 WHERE m1.time = m2.time AND EXISTS (SELECT random()) OR EXISTS (SELECT FROM meta) LIMIT 1 ) l; -- DROP TABLE svf_pushdown; -- Test bool segmentby column to cover bool-returning operator deeper in the -- expression tree. create table booltab(ts int, segmentby bool, flag bool, value int); select create_hypertable('booltab', 'ts'); create_hypertable ----------------------- (13,public,booltab,t) alter table booltab set (timescaledb.compress, timescaledb.compress_segmentby = 'segmentby', timescaledb.compress_orderby = 'ts, flag'); insert into booltab values ( 1, true, true, 1), ( 99, false, false, 99), (100, false, false, 100), (101, false, false, 101) ; select count(compress_chunk(x)) from show_chunks('booltab') x; count ------- 1 vacuum analyze booltab; explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where segmentby = (value = 1); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=4.00 loops=1) Filter: (segmentby = (value = 1)) -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where segmentby = (ts = 1); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=4.00 loops=1) Filter: (segmentby = (ts = 1)) -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where segmentby != (ts = 1); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=0.00 loops=1) Filter: (segmentby <> (ts = 1)) Rows Removed by Filter: 4 -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where (value = 1) = (ts = 1); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=4.00 loops=1) Filter: ((value = 1) = (ts = 1)) -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where flag = (ts = 1); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=4.00 loops=1) Filter: (flag = (ts = 1)) -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where flag = (ts = 99); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=2.00 loops=1) Filter: (flag = (ts = 99)) Rows Removed by Filter: 2 -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where flag = (ts = 99); --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_13_14_chunk (actual rows=2.00 loops=1) Filter: (flag = (ts = 99)) Rows Removed by Filter: 2 -> Seq Scan on compress_hyper_14_15_chunk (actual rows=2.00 loops=1) drop table booltab; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_segment_meta.out�����������������������������������0000664�0000000�0000000�00000016117�15100345067�0025265�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.ts_segment_meta_min_max_append(internal, ANYELEMENT) RETURNS internal AS :TSL_MODULE_PATHNAME, 'ts_segment_meta_min_max_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.ts_segment_meta_min_max_finish_max(internal, ANYELEMENT) RETURNS anyelement AS :TSL_MODULE_PATHNAME, 'ts_segment_meta_min_max_finish_max' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.ts_segment_meta_min_max_finish_min(internal, ANYELEMENT) RETURNS anyelement AS :TSL_MODULE_PATHNAME, 'ts_segment_meta_min_max_finish_min' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE AGGREGATE _timescaledb_internal.segment_meta_min_max_agg_min(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.ts_segment_meta_min_max_append, FINALFUNC = _timescaledb_internal.ts_segment_meta_min_max_finish_min, FINALFUNC_EXTRA ); CREATE AGGREGATE _timescaledb_internal.segment_meta_min_max_agg_max(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.ts_segment_meta_min_max_append, FINALFUNC = _timescaledb_internal.ts_segment_meta_min_max_finish_max, FINALFUNC_EXTRA ); \ir include/rand_generator.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------- -- cheap rand generator -- -------------------------- create table rand_minstd_state(i bigint); create function rand_minstd_advance(bigint) returns bigint language sql immutable as $$ select (16807 * $1) % 2147483647 $$; create function gen_rand_minstd() returns bigint language sql security definer as $$ update rand_minstd_state set i = rand_minstd_advance(i) returning i $$; -- seed the random num generator insert into rand_minstd_state values (321); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE metric (i int); insert into metric select i from generate_series(1, 10) i; \set TYPE int \set TABLE metric \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t ----NULL tests --First truncate metric; insert into metric select NULLIF(i,1) from generate_series(1, 10) i; \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --Last truncate metric; insert into metric select NULLIF(i,10) from generate_series(1, 10) i; \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --Middle truncate metric; insert into metric select NULLIF(i,5) from generate_series(1, 10) i; \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --All NULLS should return null object truncate metric; insert into metric select NULL from generate_series(1, 10) i; SELECT _timescaledb_internal.segment_meta_min_max_agg_min(i) is null, _timescaledb_internal.segment_meta_min_max_agg_max(i) is null FROM metric; ?column? | ?column? ----------+---------- t | t -- --type tests -- --untoasted text CREATE TABLE base_texts AS SELECT repeat(item::text, 1) as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set TYPE text \set TABLE base_texts \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --toasted text DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT repeat(item::text, 100000) as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; --make sure it's toasted SELECT pg_total_relation_size(reltoastrelid) FROM pg_class c WHERE relname = 'base_texts'; pg_total_relation_size ------------------------ 24576 \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --name is a fixed-length pass by reference type CREATE TABLE base_name AS SELECT item::name as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set TYPE name \set TABLE base_name \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --array CREATE TABLE text_array AS SELECT array[item::text, 'abab'] as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set TYPE text[] \set TABLE text_array \ir include/compression_test_segment_meta.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors ?column? | ?column? ----------+---------- t | t --Points doesn't have an ordering so make sure it errors CREATE TABLE points AS SELECT point '(0,1)' as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set ON_ERROR_STOP 0 SELECT _timescaledb_internal.segment_meta_min_max_agg_max(i) FROM points; ERROR: could not identify an less-than operator for type point SELECT _timescaledb_internal.segment_meta_min_max_agg_min(i) FROM points; ERROR: could not identify an less-than operator for type point \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_sequence_num_removal.out���������������������������0000664�0000000�0000000�00000116507�15100345067�0027035�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test query planning with hypertable which contains -- compressed chunks that depend on sequence number optimization -- which is removed in latest schema revision \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' CREATE TABLE hyper( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hyper | t -- test case with segmentby ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2), (21, 2, 3), (22, 3, 3), (23, 4, 3), (30, 1, 4), (31, 3, 4), (31, 5, 4); SELECT compress_chunk(show_chunks('hyper')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk VACUUM ANALYZE hyper; -- output without sequence number chunks, should match output with sequence numbers below :EXPLAIN SELECT * FROM hyper ORDER BY device_id, time; --- QUERY PLAN --- Merge Append Sort Key: hyper.device_id, hyper."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.val -> Sort Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val Sort Key: compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_5_chunk Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.val -> Sort Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val Sort Key: compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_6_chunk Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.val -> Sort Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val Sort Key: compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.val -> Sort Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val Sort Key: compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_8_chunk Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val SELECT * FROM hyper ORDER BY device_id, time; time | device_id | val ------+-----------+----- 1 | 1 | 1 30 | 1 | 4 2 | 2 | 1 21 | 2 | 3 3 | 3 | 1 10 | 3 | 2 22 | 3 | 3 31 | 3 | 4 11 | 4 | 2 23 | 4 | 3 11 | 5 | 2 31 | 5 | 4 -- backwards index scan :EXPLAIN SELECT * FROM hyper ORDER BY device_id DESC, time DESC; --- QUERY PLAN --- Merge Append Sort Key: hyper.device_id DESC, hyper."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.val Reverse: true -> Sort Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val Sort Key: compress_hyper_2_5_chunk.device_id DESC, compress_hyper_2_5_chunk._ts_meta_min_1 DESC, compress_hyper_2_5_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_5_chunk Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.val Reverse: true -> Sort Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val Sort Key: compress_hyper_2_6_chunk.device_id DESC, compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_6_chunk Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.val Reverse: true -> Sort Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val Sort Key: compress_hyper_2_7_chunk.device_id DESC, compress_hyper_2_7_chunk._ts_meta_min_1 DESC, compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.val Reverse: true -> Sort Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val Sort Key: compress_hyper_2_8_chunk.device_id DESC, compress_hyper_2_8_chunk._ts_meta_min_1 DESC, compress_hyper_2_8_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_8_chunk Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val SELECT * FROM hyper ORDER BY device_id DESC, time DESC; time | device_id | val ------+-----------+----- 31 | 5 | 4 11 | 5 | 2 23 | 4 | 3 11 | 4 | 2 31 | 3 | 4 22 | 3 | 3 10 | 3 | 2 3 | 3 | 1 21 | 2 | 3 2 | 2 | 1 30 | 1 | 4 1 | 1 | 1 -- modify two chunks by adding sequence number to the segments -- and rebuild the index based on that column SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id LIMIT 1 \gset SELECT schemaname || '.' || indexname AS "CHUNK_INDEX" FROM pg_indexes where tablename = :'CHUNK_NAME' LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over (partition by device_id) as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY device_id, _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; -- drop exising index DROP INDEX :CHUNK_INDEX; -- create index based on sequence numbers CREATE INDEX ON :CHUNK_FULL_NAME (device_id, _ts_meta_sequence_num); SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id OFFSET 2 LIMIT 1 \gset SELECT schemaname || '.' || indexname AS "CHUNK_INDEX" FROM pg_indexes where tablename = :'CHUNK_NAME' LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over (partition by device_id) as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY device_id, _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; -- drop exising index DROP INDEX :CHUNK_INDEX; -- create index based on sequence numbers CREATE INDEX ON :CHUNK_FULL_NAME (device_id, _ts_meta_sequence_num); SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; -- from this point, two chunks should use sequence numbers and the rest will work without them -- output with sequence number chunks, should match output without sequence numbers above :EXPLAIN SELECT * FROM hyper ORDER BY device_id, time; --- QUERY PLAN --- Merge Append Sort Key: hyper.device_id, hyper."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.val -> Sort Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val, compress_hyper_2_5_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_sequence_num -> Seq Scan on _timescaledb_internal.compress_hyper_2_5_chunk Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val, compress_hyper_2_5_chunk._ts_meta_sequence_num -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.val -> Sort Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val Sort Key: compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_6_chunk Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.val -> Sort Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val, compress_hyper_2_7_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_sequence_num -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val, compress_hyper_2_7_chunk._ts_meta_sequence_num -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.val -> Sort Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val Sort Key: compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_8_chunk Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val SELECT * FROM hyper ORDER BY device_id, time; time | device_id | val ------+-----------+----- 1 | 1 | 1 30 | 1 | 4 2 | 2 | 1 21 | 2 | 3 3 | 3 | 1 10 | 3 | 2 22 | 3 | 3 31 | 3 | 4 11 | 4 | 2 23 | 4 | 3 11 | 5 | 2 31 | 5 | 4 -- backwards index scan :EXPLAIN SELECT * FROM hyper ORDER BY device_id DESC, time DESC; --- QUERY PLAN --- Merge Append Sort Key: hyper.device_id DESC, hyper."time" DESC -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.val Reverse: true -> Sort Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val, compress_hyper_2_5_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_5_chunk.device_id DESC, compress_hyper_2_5_chunk._ts_meta_sequence_num DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_5_chunk Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val, compress_hyper_2_5_chunk._ts_meta_sequence_num -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.val Reverse: true -> Sort Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val Sort Key: compress_hyper_2_6_chunk.device_id DESC, compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_6_chunk Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.val Reverse: true -> Sort Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val, compress_hyper_2_7_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_7_chunk.device_id DESC, compress_hyper_2_7_chunk._ts_meta_sequence_num DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk Output: compress_hyper_2_7_chunk._ts_meta_count, compress_hyper_2_7_chunk.device_id, compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk.val, compress_hyper_2_7_chunk._ts_meta_sequence_num -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.val Reverse: true -> Sort Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val Sort Key: compress_hyper_2_8_chunk.device_id DESC, compress_hyper_2_8_chunk._ts_meta_min_1 DESC, compress_hyper_2_8_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_8_chunk Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val SELECT * FROM hyper ORDER BY device_id DESC, time DESC; time | device_id | val ------+-----------+----- 31 | 5 | 4 11 | 5 | 2 23 | 4 | 3 11 | 4 | 2 31 | 3 | 4 22 | 3 | 3 10 | 3 | 2 3 | 3 | 1 21 | 2 | 3 2 | 2 | 1 30 | 1 | 4 1 | 1 | 1 -- test recompression which should do a full recompress of the chunk -- while dropping sequence numbers INSERT INTO hyper VALUES (20, 1, 1); SELECT compress_chunk(show_chunks('hyper')); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_2_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_4_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk VACUUM ANALYZE hyper; -- removal of sequence numbers from the chunk should be -- reflected in this plan :EXPLAIN SELECT * FROM hyper ORDER BY device_id, time; --- QUERY PLAN --- Merge Append Sort Key: hyper.device_id, hyper."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.val -> Sort Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val, compress_hyper_2_5_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_sequence_num -> Seq Scan on _timescaledb_internal.compress_hyper_2_5_chunk Output: compress_hyper_2_5_chunk._ts_meta_count, compress_hyper_2_5_chunk.device_id, compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1, compress_hyper_2_5_chunk."time", compress_hyper_2_5_chunk.val, compress_hyper_2_5_chunk._ts_meta_sequence_num -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.val -> Sort Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val Sort Key: compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_6_chunk Output: compress_hyper_2_6_chunk._ts_meta_count, compress_hyper_2_6_chunk.device_id, compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1, compress_hyper_2_6_chunk."time", compress_hyper_2_6_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.val -> Sort Output: compress_hyper_2_9_chunk._ts_meta_count, compress_hyper_2_9_chunk.device_id, compress_hyper_2_9_chunk._ts_meta_min_1, compress_hyper_2_9_chunk._ts_meta_max_1, compress_hyper_2_9_chunk."time", compress_hyper_2_9_chunk.val Sort Key: compress_hyper_2_9_chunk.device_id, compress_hyper_2_9_chunk._ts_meta_min_1, compress_hyper_2_9_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_9_chunk Output: compress_hyper_2_9_chunk._ts_meta_count, compress_hyper_2_9_chunk.device_id, compress_hyper_2_9_chunk._ts_meta_min_1, compress_hyper_2_9_chunk._ts_meta_max_1, compress_hyper_2_9_chunk."time", compress_hyper_2_9_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk."time", _hyper_1_4_chunk.device_id, _hyper_1_4_chunk.val -> Sort Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val Sort Key: compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_8_chunk Output: compress_hyper_2_8_chunk._ts_meta_count, compress_hyper_2_8_chunk.device_id, compress_hyper_2_8_chunk._ts_meta_min_1, compress_hyper_2_8_chunk._ts_meta_max_1, compress_hyper_2_8_chunk."time", compress_hyper_2_8_chunk.val -- test case without segmentby TRUNCATE hyper; ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = ''); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2), (21, 2, 3), (22, 3, 3), (23, 4, 3), (30, 1, 4), (31, 3, 4), (31, 5, 4); SELECT compress_chunk(show_chunks('hyper')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_10_chunk _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk VACUUM ANALYZE hyper; :EXPLAIN SELECT * FROM hyper ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.hyper Output: hyper."time", hyper.device_id, hyper.val Order: hyper."time" Startup Exclusion: false Runtime Exclusion: false -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk."time", _hyper_1_10_chunk.device_id, _hyper_1_10_chunk.val -> Sort Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.device_id, compress_hyper_2_14_chunk.val Sort Key: compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.device_id, compress_hyper_2_14_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_11_chunk Output: _hyper_1_11_chunk."time", _hyper_1_11_chunk.device_id, _hyper_1_11_chunk.val -> Sort Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.device_id, compress_hyper_2_15_chunk.val Sort Key: compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.device_id, compress_hyper_2_15_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_12_chunk Output: _hyper_1_12_chunk."time", _hyper_1_12_chunk.device_id, _hyper_1_12_chunk.val -> Sort Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.device_id, compress_hyper_2_16_chunk.val Sort Key: compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.device_id, compress_hyper_2_16_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_13_chunk Output: _hyper_1_13_chunk."time", _hyper_1_13_chunk.device_id, _hyper_1_13_chunk.val -> Sort Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.device_id, compress_hyper_2_17_chunk.val Sort Key: compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.device_id, compress_hyper_2_17_chunk.val -- modify two chunks by adding sequence number to the segments SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over () as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id OFFSET 3 LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over () as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; -- from this point, two chunks should use sequence numbers and the rest will work without them :EXPLAIN SELECT * FROM hyper ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.hyper Output: hyper."time", hyper.device_id, hyper.val Order: hyper."time" Startup Exclusion: false Runtime Exclusion: false -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk."time", _hyper_1_10_chunk.device_id, _hyper_1_10_chunk.val -> Sort Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.device_id, compress_hyper_2_14_chunk.val, compress_hyper_2_14_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_14_chunk._ts_meta_sequence_num -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.device_id, compress_hyper_2_14_chunk.val, compress_hyper_2_14_chunk._ts_meta_sequence_num -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_11_chunk Output: _hyper_1_11_chunk."time", _hyper_1_11_chunk.device_id, _hyper_1_11_chunk.val -> Sort Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.device_id, compress_hyper_2_15_chunk.val Sort Key: compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.device_id, compress_hyper_2_15_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_12_chunk Output: _hyper_1_12_chunk."time", _hyper_1_12_chunk.device_id, _hyper_1_12_chunk.val -> Sort Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.device_id, compress_hyper_2_16_chunk.val Sort Key: compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.device_id, compress_hyper_2_16_chunk.val -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_13_chunk Output: _hyper_1_13_chunk."time", _hyper_1_13_chunk.device_id, _hyper_1_13_chunk.val -> Sort Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.device_id, compress_hyper_2_17_chunk.val, compress_hyper_2_17_chunk._ts_meta_sequence_num Sort Key: compress_hyper_2_17_chunk._ts_meta_sequence_num -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.device_id, compress_hyper_2_17_chunk.val, compress_hyper_2_17_chunk._ts_meta_sequence_num -- test rolling up chunks during compression -- this will not work with chunks which have sequence numbers -- since the last chunk has sequence numbers, new chunks will be only rolled up together ALTER TABLE hyper SET (timescaledb.compress_chunk_time_interval = '30'); INSERT INTO hyper VALUES (41, 1, 1), (42, 2, 1), (43, 3, 1), (50, 3, 2), (51, 4, 2), (51, 5, 2); -- compression should leave the previous 4 chunks alone -- and roll up the two new chunks into a single chunk SELECT compress_chunk(show_chunks('hyper')); NOTICE: chunk "_hyper_1_10_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_11_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_12_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_13_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_10_chunk _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk _timescaledb_internal._hyper_1_18_chunk _timescaledb_internal._hyper_1_18_chunk -- gh issue #7384 -- modifying compressed chunk OID to over INT32_MAX -- to detect if we handle those properly TRUNCATE hyper; ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2), (21, 2, 3), (22, 3, 3), (23, 4, 3), (30, 1, 4), (31, 3, 4), (31, 5, 4); SELECT compress_chunk(show_chunks('hyper')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_21_chunk VACUUM ANALYZE hyper; SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SELECT :'CHUNK_FULL_NAME'::regclass::oid as "CHUNK_OID" \gset SELECT (power(2,31)+1)::bigint as "CHUNK_NEW_OID" \gset UPDATE pg_class SET oid = :CHUNK_NEW_OID WHERE oid = :CHUNK_OID; UPDATE pg_attribute SET attrelid = :CHUNK_NEW_OID WHERE attrelid = :CHUNK_OID; UPDATE _timescaledb_catalog.compression_settings SET compress_relid = :CHUNK_NEW_OID WHERE compress_relid = :CHUNK_OID; :EXPLAIN SELECT * FROM hyper WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_21_chunk Output: _hyper_1_21_chunk."time", _hyper_1_21_chunk.device_id, _hyper_1_21_chunk.val -> Sort Output: compress_hyper_2_25_chunk._ts_meta_count, compress_hyper_2_25_chunk.device_id, compress_hyper_2_25_chunk._ts_meta_min_1, compress_hyper_2_25_chunk._ts_meta_max_1, compress_hyper_2_25_chunk."time", compress_hyper_2_25_chunk.val Sort Key: compress_hyper_2_25_chunk._ts_meta_min_1, compress_hyper_2_25_chunk._ts_meta_max_1 -> Seq Scan on _timescaledb_internal.compress_hyper_2_25_chunk Output: compress_hyper_2_25_chunk._ts_meta_count, compress_hyper_2_25_chunk.device_id, compress_hyper_2_25_chunk._ts_meta_min_1, compress_hyper_2_25_chunk._ts_meta_max_1, compress_hyper_2_25_chunk."time", compress_hyper_2_25_chunk.val Filter: (compress_hyper_2_25_chunk.device_id = 1) SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE hyper; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_settings.out���������������������������������������0000664�0000000�0000000�00000071772�15100345067�0024465�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO ALL CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; CREATE VIEW ht_settings AS SELECT * FROM timescaledb_information.hypertable_compression_settings ORDER BY upper(hypertable::text) COLLATE "C"; CREATE VIEW chunk_settings AS SELECT * FROM timescaledb_information.chunk_compression_settings ORDER BY upper(hypertable::text) COLLATE "C", upper(chunk::text) COLLATE "C"; CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT table_name FROM create_hypertable('metrics','time'); table_name ------------ metrics ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------+----------------+-----------+---------+--------------+--------------------+------- metrics | | {device} | | | | SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- metrics | device | | | SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+-------+-----------+---------+------- -- create 2 chunks INSERT INTO metrics VALUES ('2000-01-01'), ('2001-01-01'); -- no change to settings SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------+----------------+-----------+---------+--------------+--------------------+------- metrics | | {device} | | | | --Enable compression path info SET timescaledb.debug_compression_path_info= 'on'; SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk RESET timescaledb.debug_compression_path_info; SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {device} | | | | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_3_chunk | {device} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_1_1_chunk | device | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {device} | | | | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal.compress_hyper_2_3_chunk | {device} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal.compress_hyper_2_4_chunk | {device} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_1_1_chunk | device | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] metrics | _timescaledb_internal._hyper_1_2_chunk | device | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] -- dropping chunk should remove that chunks compression settings DROP TABLE _timescaledb_internal._hyper_1_1_chunk; SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {device} | | | | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal.compress_hyper_2_4_chunk | {device} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_1_2_chunk | device | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] -- decompress_chunk should remove settings for that chunk SELECT decompress_chunk('_timescaledb_internal._hyper_1_2_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------+----------------+-----------+---------+--------------+--------------------+------- metrics | | {device} | | | | SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+-------+-----------+---------+------- -- compress_chunk should add settings back SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {device} | | | | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal.compress_hyper_2_5_chunk | {device} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_1_2_chunk | device | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] -- dropping hypertable should remove all settings DROP TABLE metrics; SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+-------+-----------+---------+------- CREATE TABLE metrics(time timestamptz not null, d1 text, d2 text, value float); SELECT table_name FROM create_hypertable('metrics','time'); table_name ------------ metrics ALTER TABLE metrics SET (timescaledb.compress); -- hypertable should have default settings now SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------+----------------+-----------+---------+--------------+--------------------+------- metrics | | | | | | SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- metrics | | | | -- create chunk INSERT INTO metrics VALUES ('2000-01-01'); ALTER TABLE metrics SET (timescaledb.compress_segmentby='d1'); -- settings should be updated SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ---------+----------------+-----------+---------+--------------+--------------------+------- metrics | | {d1} | | | | SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- metrics | d1 | | | SELECT compress_chunk(show_chunks('metrics')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_6_chunk -- settings for compressed chunk should be present SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {d1} | | | | _timescaledb_internal._hyper_3_6_chunk | _timescaledb_internal.compress_hyper_4_7_chunk | {d1} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_3_6_chunk | d1 | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] -- changing settings should update settings for hypertable but not existing compressed chunks ALTER TABLE metrics SET (timescaledb.compress_segmentby='d2'); SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {d2} | | | | _timescaledb_internal._hyper_3_6_chunk | _timescaledb_internal.compress_hyper_4_7_chunk | {d1} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- metrics | d2 | | | SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_3_6_chunk | d1 | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] -- changing settings should update settings for hypertable but not existing compressed chunks ALTER TABLE metrics SET (timescaledb.compress_segmentby=''); SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {} | | | | _timescaledb_internal._hyper_3_6_chunk | _timescaledb_internal.compress_hyper_4_7_chunk | {d1} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- metrics | | | | SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_3_6_chunk | d1 | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] -- create another chunk INSERT INTO metrics VALUES ('2000-02-01'); SELECT compress_chunk(show_chunks('metrics'), true); NOTICE: chunk "_hyper_3_6_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_8_chunk SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+------------------------------------------------+-----------+---------+--------------+--------------------+------------------------------------------------------------- metrics | | {} | | | | _timescaledb_internal._hyper_3_6_chunk | _timescaledb_internal.compress_hyper_4_7_chunk | {d1} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] _timescaledb_internal._hyper_3_8_chunk | _timescaledb_internal.compress_hyper_4_9_chunk | {} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+---------+--------------------------+------- metrics | | | | SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+------------------------------------------------------------- metrics | _timescaledb_internal._hyper_3_6_chunk | d1 | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] metrics | _timescaledb_internal._hyper_3_8_chunk | | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] ALTER TABLE metrics SET (timescaledb.compress_orderby='"time" desc', timescaledb.compress_segmentby='d2', timescaledb.index='bloom(value)'); SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL ORDER BY id LIMIT 1 OFFSET 1\gset -- recompressing chunks should apply current hypertable settings SELECT compress_chunk(:'CHUNK', recompress:=true); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_8_chunk SELECT compress_chunk(:'CHUNK', recompress:=true); NOTICE: chunk "_hyper_3_8_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_8_chunk ALTER TABLE metrics SET (timescaledb.compress_orderby='"time" desc', timescaledb.compress_segmentby='d2', timescaledb.index=''); SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL ORDER BY id LIMIT 1 OFFSET 1\gset SELECT compress_chunk(:'CHUNK', recompress:=true); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_8_chunk SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+-------------------------------------------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------- metrics | | {d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] _timescaledb_internal._hyper_3_6_chunk | _timescaledb_internal.compress_hyper_4_7_chunk | {d1} | {time} | {t} | {t} | [{"type": "minmax", "column": "time", "source": "orderby"}] _timescaledb_internal._hyper_3_8_chunk | _timescaledb_internal.compress_hyper_4_11_chunk | {d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+-------------+--------------------------+----------------------------------------------------------------------------------- metrics | d2 | "time" DESC | | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+----------------------------------------------------------------------------------- metrics | _timescaledb_internal._hyper_3_6_chunk | d1 | "time" DESC | [{"type": "minmax", "column": "time", "source": "orderby"}] metrics | _timescaledb_internal._hyper_3_8_chunk | d2 | "time" DESC | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] -- test different order by flags with compression settings view CREATE TABLE metrics2(time timestamptz not null, d1 text, d2 text, value float); SELECT create_hypertable('metrics2','time'); create_hypertable ----------------------- (5,public,metrics2,t) SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+-------------+--------------------------+----------------------------------------------------------------------------------- metrics | d2 | "time" DESC | | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics2 | | | | ALTER TABLE metrics2 SET (timescaledb.compress_orderby='d1 NULLS FIRST, d2 NULLS LAST, time, value ASC'); SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+--------------------------------+--------------------------+----------------------------------------------------------------------------------- metrics | d2 | "time" DESC | | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics2 | | d1 NULLS FIRST,d2,"time",value | | ALTER TABLE metrics2 SET (timescaledb.compress_orderby='d1 DESC NULLS LAST, d2 ASC NULLS FIRST, value DESC, time ASC NULLS FIRST'); SELECT * FROM ht_settings; hypertable | segmentby | orderby | compress_interval_length | index ------------+-----------+-----------------------------------------------------------------+--------------------------+----------------------------------------------------------------------------------- metrics | d2 | "time" DESC | | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics2 | | d1 DESC NULLS LAST,d2 NULLS FIRST,value DESC,"time" NULLS FIRST | | -- test decompression uses the correct settings ALTER TABLE metrics SET (timescaledb.compress_segmentby=''); SELECT compress_chunk(show_chunks('metrics'), recompress:=true); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE metrics SET (timescaledb.compress_segmentby='d1,d2'); SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+----------------------------------------+-----------+-------------+----------------------------------------------------------------------------------- metrics | _timescaledb_internal._hyper_3_6_chunk | | "time" DESC | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics | _timescaledb_internal._hyper_3_8_chunk | | "time" DESC | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] SELECT * FROM metrics WHERE d1 = 'foo'; time | d1 | d2 | value ------+----+----+------- SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------------------------------------+-------------------------------------------------+-----------+--------------------+--------------+--------------------+----------------------------------------------------------------------------------- metrics | | {d1,d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics2 | | | {d1,d2,value,time} | {t,f,t,f} | {f,t,t,t} | _timescaledb_internal._hyper_3_6_chunk | _timescaledb_internal.compress_hyper_4_12_chunk | {} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] _timescaledb_internal._hyper_3_8_chunk | _timescaledb_internal.compress_hyper_4_13_chunk | {} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] -- Check that TRUNCATE <hypertable> also cleans up compression -- settings for chunks that are dropped when truncating. TRUNCATE metrics; SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------+----------------+-----------+--------------------+--------------+--------------------+----------------------------------------------------------------------------------- metrics | | {d1,d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics2 | | | {d1,d2,value,time} | {t,f,t,f} | {f,t,t,t} | SELECT * FROM chunk_settings; hypertable | chunk | segmentby | orderby | index ------------+-------+-----------+---------+------- -- Recreate chunks INSERT INTO metrics VALUES ('2000-01-01'), ('2001-01-01'); SELECT compress_chunk(ch) FROM show_chunks('metrics') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_14_chunk _timescaledb_internal._hyper_3_15_chunk SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -----------------------------------------+-------------------------------------------------+-----------+--------------------+--------------+--------------------+----------------------------------------------------------------------------------- metrics | | {d1,d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] metrics2 | | | {d1,d2,value,time} | {t,f,t,f} | {f,t,t,t} | _timescaledb_internal._hyper_3_14_chunk | _timescaledb_internal.compress_hyper_4_16_chunk | {d1,d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] _timescaledb_internal._hyper_3_15_chunk | _timescaledb_internal.compress_hyper_4_17_chunk | {d1,d2} | {time} | {t} | {t} | [{"source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] -- DROP TABLE with CASCADE uses a different code path for dropping -- hypertable so needs to be tested separately. DROP TABLE metrics CASCADE; SELECT * FROM settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index ----------+----------------+-----------+--------------------+--------------+--------------------+------- metrics2 | | | {d1,d2,value,time} | {t,f,t,f} | {f,t,t,t} | ������timescaledb-2.23.0/tsl/test/expected/compression_sorted_merge.out�����������������������������������0000664�0000000�0000000�00000335330�15100345067�0025275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Increase the working memory limit slightly, otherwise the batch sorted merge -- will be penalized for segmentby cardinalities larger than 100, where it is -- still faster than sort. SET work_mem to '16MB'; \set PREFIX 'EXPLAIN (analyze, verbose, buffers off, costs off, timing off, summary off)' CREATE TABLE test1 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test1', 'time'); -- ALTER TABLE test1 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'time DESC, x3 ASC, x4 ASC'); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); SELECT compress_chunk(i) FROM show_chunks('test1') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk ANALYZE test1; CREATE TABLE test2 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test2', 'time'); -- ALTER TABLE test2 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'time ASC, x3 DESC, x4 DESC'); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); SELECT compress_chunk(i) FROM show_chunks('test2') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_3_chunk ANALYZE test2; CREATE TABLE test_with_defined_null ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer); SELECT FROM create_hypertable('test_with_defined_null','time'); -- ALTER TABLE test_with_defined_null SET (timescaledb.compress,timescaledb.compress_segmentby='x1', timescaledb.compress_orderby='x2 ASC NULLS FIRST'); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01', '1', NULL); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01','2', NULL); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01','1',1); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01','1',2); SELECT compress_chunk(i) FROM show_chunks('test_with_defined_null') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_5_chunk ANALYZE test_with_defined_null; -- test1 uses compress_segmentby='x1, x2, x5' and compress_orderby = 'time DESC, x3 ASC, x4 ASC' -- test2 uses compress_segmentby='x1, x2, x5' and compress_orderby = 'time ASC, x3 DESC, x4 DESC' -- test_with_defined_null uses compress_segmentby='x1' and compress_orderby = 'x2 ASC NULLS FIRST' ------ -- Tests based on ordering ------ set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Should be optimized (implicit NULLS first) :PREFIX SELECT * FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized (implicit NULLS last) :PREFIX SELECT * FROM test1 ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC, compress_hyper_2_2_chunk._ts_meta_min_2 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC, compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_min_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST, x4 DESC NULLS FIRST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_2 DESC, compress_hyper_2_2_chunk._ts_meta_max_3 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test2 ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 Sort Key: compress_hyper_4_4_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 Sort Key: compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 DESC, x4 DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 Sort Key: compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_2 DESC, compress_hyper_4_4_chunk._ts_meta_max_3 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS FIRST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 Sort Key: compress_hyper_4_4_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 Sort Key: compress_hyper_4_4_chunk._ts_meta_max_1 DESC, compress_hyper_4_4_chunk._ts_meta_min_2 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 Sort Key: compress_hyper_4_4_chunk._ts_meta_max_1 DESC, compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_min_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should be optimized :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS FIRST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_5_chunk (actual rows=4.00 loops=1) Output: _hyper_5_5_chunk."time", _hyper_5_5_chunk.x1, _hyper_5_5_chunk.x2, _hyper_5_5_chunk.x3 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_6_6_chunk._ts_meta_count, compress_hyper_6_6_chunk.x1, compress_hyper_6_6_chunk._ts_meta_min_2, compress_hyper_6_6_chunk._ts_meta_max_2, compress_hyper_6_6_chunk."time", compress_hyper_6_6_chunk._ts_meta_min_1, compress_hyper_6_6_chunk._ts_meta_max_1, compress_hyper_6_6_chunk.x2, compress_hyper_6_6_chunk.x3 Sort Key: compress_hyper_6_6_chunk._ts_meta_min_1 NULLS FIRST Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_6_chunk (actual rows=2.00 loops=1) Output: compress_hyper_6_6_chunk._ts_meta_count, compress_hyper_6_6_chunk.x1, compress_hyper_6_6_chunk._ts_meta_min_2, compress_hyper_6_6_chunk._ts_meta_max_2, compress_hyper_6_6_chunk."time", compress_hyper_6_6_chunk._ts_meta_min_1, compress_hyper_6_6_chunk._ts_meta_max_1, compress_hyper_6_6_chunk.x2, compress_hyper_6_6_chunk.x3 -- Should be optimized (backward scan) :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_5_chunk (actual rows=4.00 loops=1) Output: _hyper_5_5_chunk."time", _hyper_5_5_chunk.x1, _hyper_5_5_chunk.x2, _hyper_5_5_chunk.x3 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_6_6_chunk._ts_meta_count, compress_hyper_6_6_chunk.x1, compress_hyper_6_6_chunk._ts_meta_min_2, compress_hyper_6_6_chunk._ts_meta_max_2, compress_hyper_6_6_chunk."time", compress_hyper_6_6_chunk._ts_meta_min_1, compress_hyper_6_6_chunk._ts_meta_max_1, compress_hyper_6_6_chunk.x2, compress_hyper_6_6_chunk.x3 Sort Key: compress_hyper_6_6_chunk._ts_meta_max_1 DESC NULLS LAST Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_6_chunk (actual rows=2.00 loops=1) Output: compress_hyper_6_6_chunk._ts_meta_count, compress_hyper_6_6_chunk.x1, compress_hyper_6_6_chunk._ts_meta_min_2, compress_hyper_6_6_chunk._ts_meta_max_2, compress_hyper_6_6_chunk."time", compress_hyper_6_6_chunk._ts_meta_min_1, compress_hyper_6_6_chunk._ts_meta_max_1, compress_hyper_6_6_chunk.x2, compress_hyper_6_6_chunk.x3 set timescaledb.debug_require_batch_sorted_merge to 'forbid'; -- Should not be optimized (wrong order for x3 in backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS LAST, x3 DESC NULLS FIRST, x4 NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Sort Key: _hyper_3_3_chunk."time" DESC NULLS LAST, _hyper_3_3_chunk.x3 DESC, _hyper_3_3_chunk.x4 NULLS FIRST Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should not be optimized (wrong order for x3 in backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS LAST, x3 DESC NULLS LAST, x4 NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Sort Key: _hyper_3_3_chunk."time" DESC NULLS LAST, _hyper_3_3_chunk.x3 DESC NULLS LAST, _hyper_3_3_chunk.x4 NULLS FIRST Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should not be optimized (NULL order wrong) :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS LAST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Sort Key: _hyper_1_1_chunk."time" DESC NULLS LAST Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should not be optimized (NULL order wrong) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Sort Key: _hyper_1_1_chunk."time" NULLS FIRST Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should not be optimized (wrong order for x4) :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 DESC NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should not be optimized (wrong order for x4 in backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS FIRST, x3 DESC NULLS LAST, x4 ASC; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Sort Key: _hyper_1_1_chunk."time" NULLS FIRST, _hyper_1_1_chunk.x3 DESC NULLS LAST, _hyper_1_1_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 -- Should not be optimized (wrong order for x3) :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 ASC NULLS LAST, x4 DESC; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Sort Key: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should not be optimized (wrong order for x3) :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 ASC NULLS FIRST, x4 DESC; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Sort Key: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x3 NULLS FIRST, _hyper_3_3_chunk.x4 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_3_chunk (actual rows=4.00 loops=1) Output: _hyper_3_3_chunk."time", _hyper_3_3_chunk.x1, _hyper_3_3_chunk.x2, _hyper_3_3_chunk.x3, _hyper_3_3_chunk.x4, _hyper_3_3_chunk.x5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_4_4_chunk (actual rows=3.00 loops=1) Output: compress_hyper_4_4_chunk._ts_meta_count, compress_hyper_4_4_chunk.x1, compress_hyper_4_4_chunk.x2, compress_hyper_4_4_chunk.x5, compress_hyper_4_4_chunk._ts_meta_min_1, compress_hyper_4_4_chunk._ts_meta_max_1, compress_hyper_4_4_chunk."time", compress_hyper_4_4_chunk._ts_meta_min_2, compress_hyper_4_4_chunk._ts_meta_max_2, compress_hyper_4_4_chunk.x3, compress_hyper_4_4_chunk._ts_meta_min_3, compress_hyper_4_4_chunk._ts_meta_max_3, compress_hyper_4_4_chunk.x4 -- Should not be optimized :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS LAST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_5_5_chunk."time", _hyper_5_5_chunk.x1, _hyper_5_5_chunk.x2, _hyper_5_5_chunk.x3 Sort Key: _hyper_5_5_chunk.x2 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_5_chunk (actual rows=4.00 loops=1) Output: _hyper_5_5_chunk."time", _hyper_5_5_chunk.x1, _hyper_5_5_chunk.x2, _hyper_5_5_chunk.x3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_6_chunk (actual rows=2.00 loops=1) Output: compress_hyper_6_6_chunk._ts_meta_count, compress_hyper_6_6_chunk.x1, compress_hyper_6_6_chunk._ts_meta_min_2, compress_hyper_6_6_chunk._ts_meta_max_2, compress_hyper_6_6_chunk."time", compress_hyper_6_6_chunk._ts_meta_min_1, compress_hyper_6_6_chunk._ts_meta_max_1, compress_hyper_6_6_chunk.x2, compress_hyper_6_6_chunk.x3 -- Should not be optimized :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Output: _hyper_5_5_chunk."time", _hyper_5_5_chunk.x1, _hyper_5_5_chunk.x2, _hyper_5_5_chunk.x3 Sort Key: _hyper_5_5_chunk.x2 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_5_chunk (actual rows=4.00 loops=1) Output: _hyper_5_5_chunk."time", _hyper_5_5_chunk.x1, _hyper_5_5_chunk.x2, _hyper_5_5_chunk.x3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_6_chunk (actual rows=2.00 loops=1) Output: compress_hyper_6_6_chunk._ts_meta_count, compress_hyper_6_6_chunk.x1, compress_hyper_6_6_chunk._ts_meta_min_2, compress_hyper_6_6_chunk._ts_meta_max_2, compress_hyper_6_6_chunk."time", compress_hyper_6_6_chunk._ts_meta_min_1, compress_hyper_6_6_chunk._ts_meta_max_1, compress_hyper_6_6_chunk.x2, compress_hyper_6_6_chunk.x3 ------ -- Tests based on attributes ------ set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Should be optimized (some batches qualify by pushed down filter on _ts_meta_max_3) :PREFIX SELECT * FROM test1 WHERE x4 > 0 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Filter: (_hyper_1_1_chunk.x4 > 0) Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 0) -- Should be optimized (no batches qualify by pushed down filter on _ts_meta_max_3) :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Filter: (_hyper_1_1_chunk.x4 > 100) Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 100) Rows Removed by Filter: 3 -- Should be optimized :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x3, x4; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Filter: (_hyper_1_1_chunk.x4 > 100) Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC, compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_min_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 100) Rows Removed by Filter: 3 -- Should be optimized (duplicate order by attributes) :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x3, x3; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Filter: (_hyper_1_1_chunk.x4 > 100) Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC, compress_hyper_2_2_chunk._ts_meta_min_2 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 100) Rows Removed by Filter: 3 -- Should be optimized (duplicate order by attributes) :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x3, x4, x3, x4; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Filter: (_hyper_1_1_chunk.x4 > 100) Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC, compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_min_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 100) Rows Removed by Filter: 3 set timescaledb.debug_require_batch_sorted_merge to 'forbid'; -- Should not be optimized :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x4, x3; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Vectorized Filter: (_hyper_1_1_chunk.x4 > 100) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 100) Rows Removed by Filter: 3 -- Should not be optimized :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time ASC, x3, x4; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5 Vectorized Filter: (_hyper_1_1_chunk.x4 > 100) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk (actual rows=0.00 loops=1) Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Filter: (compress_hyper_2_2_chunk._ts_meta_max_3 > 100) Rows Removed by Filter: 3 ------ -- Tests based on results ------ set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Forward scan SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 -- Forward scan SELECT * FROM test2 ORDER BY time ASC; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Backward scan SELECT * FROM test1 ORDER BY time ASC NULLS LAST; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 -- Backward scan SELECT * FROM test2 ORDER BY time DESC NULLS FIRST; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 set timescaledb.debug_require_batch_sorted_merge to 'force'; -- With selection on compressed column (value larger as max value for all batches, so no batch has to be opened) SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------+----+----+----+----+---- -- With selection on compressed column (value smaller as max value for some batches, so batches are opened and filter has to be applied) SELECT * FROM test1 WHERE x4 > 2 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 -- With selection on segment_by column SELECT * FROM test1 WHERE time < '1980-01-01 00:00:00-00' ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------+----+----+----+----+---- SELECT * FROM test1 WHERE time > '1980-01-01 00:00:00-00' ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 -- With selection on segment_by and compressed column SELECT * FROM test1 WHERE time > '1980-01-01 00:00:00-00' ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 SELECT * FROM test1 WHERE time > '1980-01-01 00:00:00-00' AND x4 > 100 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------+----+----+----+----+---- -- Without projection SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 -- With projection on time SELECT time FROM test1 ORDER BY time DESC; time ------------------------------ Fri Dec 31 19:00:00 1999 PST Fri Dec 31 18:00:00 1999 PST Fri Dec 31 17:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST -- With projection on x3 SELECT x3 FROM test1 ORDER BY time DESC; x3 ---- 4 3 2 1 -- With projection on x3 and time SELECT x3,time FROM test1 ORDER BY time DESC; x3 | time ----+------------------------------ 4 | Fri Dec 31 19:00:00 1999 PST 3 | Fri Dec 31 18:00:00 1999 PST 2 | Fri Dec 31 17:00:00 1999 PST 1 | Fri Dec 31 16:00:00 1999 PST -- With projection on time and x3 SELECT time,x3 FROM test1 ORDER BY time DESC; time | x3 ------------------------------+---- Fri Dec 31 19:00:00 1999 PST | 4 Fri Dec 31 18:00:00 1999 PST | 3 Fri Dec 31 17:00:00 1999 PST | 2 Fri Dec 31 16:00:00 1999 PST | 1 -- Test with projection and constants EXPLAIN (verbose, buffers off, costs off) SELECT 1 as one, 2 as two, 3 as three, time, x2 FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Result Output: 1, 2, 3, _hyper_1_1_chunk."time", _hyper_1_1_chunk.x2 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x2 Batch Sorted Merge: true -> Sort Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 SELECT 1 as one, 2 as two, 3 as three, time, x2 FROM test1 ORDER BY time DESC; one | two | three | time | x2 -----+-----+-------+------------------------------+---- 1 | 2 | 3 | Fri Dec 31 19:00:00 1999 PST | 2 1 | 2 | 3 | Fri Dec 31 18:00:00 1999 PST | 1 1 | 2 | 3 | Fri Dec 31 17:00:00 1999 PST | 3 1 | 2 | 3 | Fri Dec 31 16:00:00 1999 PST | 2 -- Test with projection and constants EXPLAIN (verbose, buffers off, costs off) SELECT 1 as one, 2 as two, 3 as three, x2, time FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Result Output: 1, 2, 3, _hyper_1_1_chunk.x2, _hyper_1_1_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.x2, _hyper_1_1_chunk."time" Batch Sorted Merge: true -> Sort Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 Sort Key: compress_hyper_2_2_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_2_2_chunk Output: compress_hyper_2_2_chunk._ts_meta_count, compress_hyper_2_2_chunk.x1, compress_hyper_2_2_chunk.x2, compress_hyper_2_2_chunk.x5, compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1, compress_hyper_2_2_chunk."time", compress_hyper_2_2_chunk._ts_meta_min_2, compress_hyper_2_2_chunk._ts_meta_max_2, compress_hyper_2_2_chunk.x3, compress_hyper_2_2_chunk._ts_meta_min_3, compress_hyper_2_2_chunk._ts_meta_max_3, compress_hyper_2_2_chunk.x4 SELECT 1 as one, 2 as two, 3 as three, x2, time FROM test1 ORDER BY time DESC; one | two | three | x2 | time -----+-----+-------+----+------------------------------ 1 | 2 | 3 | 2 | Fri Dec 31 19:00:00 1999 PST 1 | 2 | 3 | 1 | Fri Dec 31 18:00:00 1999 PST 1 | 2 | 3 | 3 | Fri Dec 31 17:00:00 1999 PST 1 | 2 | 3 | 2 | Fri Dec 31 16:00:00 1999 PST -- With projection and selection on compressed column (value smaller as max value for some batches, so batches are opened and filter has to be applied) SELECT x4 FROM test1 WHERE x4 > 2 ORDER BY time DESC; x4 ---- 4 3 set timescaledb.debug_require_batch_sorted_merge to 'forbid'; -- Aggregation with count SELECT count(*) FROM test1; count ------- 4 -- Test with default values ALTER TABLE test1 ADD COLUMN c1 int; ALTER TABLE test1 ADD COLUMN c2 int NOT NULL DEFAULT 42; set timescaledb.debug_require_batch_sorted_merge to 'force'; SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 | c1 | c2 ------------------------------+----+----+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 | | 42 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 | | 42 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 | | 42 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 | | 42 -- Recompress SELECT decompress_chunk(i) FROM show_chunks('test1') i; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk(i) FROM show_chunks('test1') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk ANALYZE test1; -- Test with a changed physical layout -- build_physical_tlist() can not be used for the scan on the compressed chunk anymore SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 | c1 | c2 ------------------------------+----+----+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 | | 42 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 | | 42 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 | | 42 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 | | 42 ALTER TABLE test1 DROP COLUMN c2; SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 | c1 ------------------------------+----+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 | Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 | Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 | Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 | -- Test with a re-created column ALTER TABLE test1 ADD COLUMN c2 int NOT NULL DEFAULT 43; SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 | c1 | c2 ------------------------------+----+----+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 | | 43 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 | | 43 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 | | 43 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 | | 43 -- Test with the recreated column :PREFIX SELECT * FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5, _hyper_1_1_chunk.c1, _hyper_1_1_chunk.c2 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x3, compress_hyper_2_7_chunk._ts_meta_min_2, compress_hyper_2_7_chunk._ts_meta_max_2, compress_hyper_2_7_chunk.x4, compress_hyper_2_7_chunk._ts_meta_min_3, compress_hyper_2_7_chunk._ts_meta_max_3, compress_hyper_2_7_chunk.x5, compress_hyper_2_7_chunk.c1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x3, compress_hyper_2_7_chunk._ts_meta_min_2, compress_hyper_2_7_chunk._ts_meta_max_2, compress_hyper_2_7_chunk.x4, compress_hyper_2_7_chunk._ts_meta_min_3, compress_hyper_2_7_chunk._ts_meta_max_3, compress_hyper_2_7_chunk.x5, compress_hyper_2_7_chunk.c1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count SELECT * FROM test1 ORDER BY time DESC; time | x1 | x2 | x3 | x4 | x5 | c1 | c2 ------------------------------+----+----+----+----+----+----+---- Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 | | 43 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 | | 43 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 | | 43 Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 | | 43 -- Test with projection and recreated column :PREFIX SELECT time, x2, x1, c2 FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x1, _hyper_1_1_chunk.c2 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count SELECT time, x2, x1, c2 FROM test1 ORDER BY time DESC; time | x2 | x1 | c2 ------------------------------+----+----+---- Fri Dec 31 19:00:00 1999 PST | 2 | 1 | 43 Fri Dec 31 18:00:00 1999 PST | 1 | 2 | 43 Fri Dec 31 17:00:00 1999 PST | 3 | 1 | 43 Fri Dec 31 16:00:00 1999 PST | 2 | 1 | 43 -- Test with projection and recreated column :PREFIX SELECT x2, x1, c2, time FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x1, _hyper_1_1_chunk.c2, _hyper_1_1_chunk."time" Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk._ts_meta_count Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk._ts_meta_count SELECT x2, x1, c2, time FROM test1 ORDER BY time DESC; x2 | x1 | c2 | time ----+----+----+------------------------------ 2 | 1 | 43 | Fri Dec 31 19:00:00 1999 PST 1 | 2 | 43 | Fri Dec 31 18:00:00 1999 PST 3 | 1 | 43 | Fri Dec 31 17:00:00 1999 PST 2 | 1 | 43 | Fri Dec 31 16:00:00 1999 PST -- Test with projection, constants and recreated column :PREFIX SELECT 1 as one, 2 as two, 3 as three, x2, x1, c2, time FROM test1 ORDER BY time DESC; --- QUERY PLAN --- Result (actual rows=4.00 loops=1) Output: 1, 2, 3, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x1, _hyper_1_1_chunk.c2, _hyper_1_1_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x1, _hyper_1_1_chunk.c2, _hyper_1_1_chunk."time" Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk._ts_meta_count Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk._ts_meta_count SELECT 1 as one, 2 as two, 3 as three, x2, x1, c2, time FROM test1 ORDER BY time DESC; one | two | three | x2 | x1 | c2 | time -----+-----+-------+----+----+----+------------------------------ 1 | 2 | 3 | 2 | 1 | 43 | Fri Dec 31 19:00:00 1999 PST 1 | 2 | 3 | 1 | 2 | 43 | Fri Dec 31 18:00:00 1999 PST 1 | 2 | 3 | 3 | 1 | 43 | Fri Dec 31 17:00:00 1999 PST 1 | 2 | 3 | 2 | 1 | 43 | Fri Dec 31 16:00:00 1999 PST -- Test with null values SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS FIRST; time | x1 | x2 | x3 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | 2 | | Sat Jan 01 00:00:00 2000 PST | 1 | | Sat Jan 01 00:00:00 2000 PST | 1 | 1 | Sat Jan 01 00:00:00 2000 PST | 1 | 2 | SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS LAST; time | x1 | x2 | x3 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | 2 | Sat Jan 01 00:00:00 2000 PST | 1 | 1 | Sat Jan 01 00:00:00 2000 PST | 1 | | Sat Jan 01 00:00:00 2000 PST | 2 | | set timescaledb.debug_require_batch_sorted_merge to 'forbid'; SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS LAST; time | x1 | x2 | x3 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | 1 | Sat Jan 01 00:00:00 2000 PST | 1 | 2 | Sat Jan 01 00:00:00 2000 PST | 1 | | Sat Jan 01 00:00:00 2000 PST | 2 | | SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS FIRST; time | x1 | x2 | x3 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | Sat Jan 01 00:00:00 2000 PST | 2 | | Sat Jan 01 00:00:00 2000 PST | 1 | 2 | Sat Jan 01 00:00:00 2000 PST | 1 | 1 | ------ -- Tests based on compressed chunk state ------ -- Should be optimized set timescaledb.debug_require_batch_sorted_merge to 'force'; :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5, _hyper_1_1_chunk.c1, _hyper_1_1_chunk.c2 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x3, compress_hyper_2_7_chunk._ts_meta_min_2, compress_hyper_2_7_chunk._ts_meta_max_2, compress_hyper_2_7_chunk.x4, compress_hyper_2_7_chunk._ts_meta_min_3, compress_hyper_2_7_chunk._ts_meta_max_3, compress_hyper_2_7_chunk.x5, compress_hyper_2_7_chunk.c1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x3, compress_hyper_2_7_chunk._ts_meta_min_2, compress_hyper_2_7_chunk._ts_meta_max_2, compress_hyper_2_7_chunk.x4, compress_hyper_2_7_chunk._ts_meta_min_3, compress_hyper_2_7_chunk._ts_meta_max_3, compress_hyper_2_7_chunk.x5, compress_hyper_2_7_chunk.c1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count BEGIN TRANSACTION; INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:01:00-00', 10, 20, 30, 40, 50); -- Should be optimized using a merge append path between the compressed and uncompressed part of the chunk :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.test1 (actual rows=5.00 loops=1) Output: test1."time", test1.x1, test1.x2, test1.x3, test1.x4, test1.x5, test1.c1, test1.c2 Order: test1."time" Startup Exclusion: false Runtime Exclusion: false -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=4.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5, _hyper_1_1_chunk.c1, _hyper_1_1_chunk.c2 Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x3, compress_hyper_2_7_chunk._ts_meta_min_2, compress_hyper_2_7_chunk._ts_meta_max_2, compress_hyper_2_7_chunk.x4, compress_hyper_2_7_chunk._ts_meta_min_3, compress_hyper_2_7_chunk._ts_meta_max_3, compress_hyper_2_7_chunk.x5, compress_hyper_2_7_chunk.c1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_2_7_chunk (actual rows=3.00 loops=1) Output: compress_hyper_2_7_chunk."time", compress_hyper_2_7_chunk._ts_meta_min_1, compress_hyper_2_7_chunk._ts_meta_max_1, compress_hyper_2_7_chunk.x1, compress_hyper_2_7_chunk.x2, compress_hyper_2_7_chunk.x3, compress_hyper_2_7_chunk._ts_meta_min_2, compress_hyper_2_7_chunk._ts_meta_max_2, compress_hyper_2_7_chunk.x4, compress_hyper_2_7_chunk._ts_meta_min_3, compress_hyper_2_7_chunk._ts_meta_max_3, compress_hyper_2_7_chunk.x5, compress_hyper_2_7_chunk.c1, compress_hyper_2_7_chunk.c2, compress_hyper_2_7_chunk._ts_meta_count -> Index Scan Backward using _hyper_1_1_chunk_test1_time_idx on _timescaledb_internal._hyper_1_1_chunk (actual rows=1.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.x1, _hyper_1_1_chunk.x2, _hyper_1_1_chunk.x3, _hyper_1_1_chunk.x4, _hyper_1_1_chunk.x5, _hyper_1_1_chunk.c1, _hyper_1_1_chunk.c2 -- The inserted value should be visible SELECT * FROM test1 ORDER BY time ASC NULLS LAST; time | x1 | x2 | x3 | x4 | x5 | c1 | c2 ------------------------------+----+----+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 | | 43 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 | | 43 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 | | 43 Fri Dec 31 18:01:00 1999 PST | 10 | 20 | 30 | 40 | 50 | | 43 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 | | 43 ROLLBACK; ------ -- Tests on a larger relation ------ set timescaledb.debug_require_batch_sorted_merge to 'allow'; CREATE TABLE sensor_data ( time timestamptz NOT NULL, sensor_id integer NOT NULL, cpu double precision NULL, temperature double precision NULL); SELECT FROM create_hypertable('sensor_data','time'); -- INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random() * 100 AS temperature FROM generate_series('1980-01-01 00:00:00-00', '1980-02-01 00:00:00-00', INTERVAL '10 minute') AS g1(time), generate_series(1, 100, 1 ) AS g2(sensor_id) ORDER BY time; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby='sensor_id', timescaledb.compress_orderby = 'time DESC'); SELECT add_compression_policy('sensor_data','1 minute'::INTERVAL); add_compression_policy ------------------------ 1000 SELECT compress_chunk(i) FROM show_chunks('sensor_data') i; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_8_chunk _timescaledb_internal._hyper_7_9_chunk _timescaledb_internal._hyper_7_10_chunk _timescaledb_internal._hyper_7_11_chunk _timescaledb_internal._hyper_7_12_chunk _timescaledb_internal._hyper_7_13_chunk VACUUM ANALYZE sensor_data; -- Ensure the optimization is used for queries on this table :PREFIX SELECT * FROM sensor_data ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) Output: sensor_data."time", sensor_data.sensor_id, sensor_data.cpu, sensor_data.temperature -> Custom Scan (ChunkAppend) on public.sensor_data (actual rows=1.00 loops=1) Output: sensor_data."time", sensor_data.sensor_id, sensor_data.cpu, sensor_data.temperature Order: sensor_data."time" DESC Startup Exclusion: false Runtime Exclusion: false -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_13_chunk (actual rows=1.00 loops=1) Output: _hyper_7_13_chunk."time", _hyper_7_13_chunk.sensor_id, _hyper_7_13_chunk.cpu, _hyper_7_13_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=2.00 loops=1) Output: compress_hyper_8_19_chunk._ts_meta_count, compress_hyper_8_19_chunk.sensor_id, compress_hyper_8_19_chunk._ts_meta_min_1, compress_hyper_8_19_chunk._ts_meta_max_1, compress_hyper_8_19_chunk."time", compress_hyper_8_19_chunk.cpu, compress_hyper_8_19_chunk.temperature Sort Key: compress_hyper_8_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_8_19_chunk (actual rows=100.00 loops=1) Output: compress_hyper_8_19_chunk._ts_meta_count, compress_hyper_8_19_chunk.sensor_id, compress_hyper_8_19_chunk._ts_meta_min_1, compress_hyper_8_19_chunk._ts_meta_max_1, compress_hyper_8_19_chunk."time", compress_hyper_8_19_chunk.cpu, compress_hyper_8_19_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_12_chunk (never executed) Output: _hyper_7_12_chunk."time", _hyper_7_12_chunk.sensor_id, _hyper_7_12_chunk.cpu, _hyper_7_12_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_8_18_chunk._ts_meta_count, compress_hyper_8_18_chunk.sensor_id, compress_hyper_8_18_chunk._ts_meta_min_1, compress_hyper_8_18_chunk._ts_meta_max_1, compress_hyper_8_18_chunk."time", compress_hyper_8_18_chunk.cpu, compress_hyper_8_18_chunk.temperature Sort Key: compress_hyper_8_18_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_8_18_chunk (never executed) Output: compress_hyper_8_18_chunk._ts_meta_count, compress_hyper_8_18_chunk.sensor_id, compress_hyper_8_18_chunk._ts_meta_min_1, compress_hyper_8_18_chunk._ts_meta_max_1, compress_hyper_8_18_chunk."time", compress_hyper_8_18_chunk.cpu, compress_hyper_8_18_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_11_chunk (never executed) Output: _hyper_7_11_chunk."time", _hyper_7_11_chunk.sensor_id, _hyper_7_11_chunk.cpu, _hyper_7_11_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_8_17_chunk._ts_meta_count, compress_hyper_8_17_chunk.sensor_id, compress_hyper_8_17_chunk._ts_meta_min_1, compress_hyper_8_17_chunk._ts_meta_max_1, compress_hyper_8_17_chunk."time", compress_hyper_8_17_chunk.cpu, compress_hyper_8_17_chunk.temperature Sort Key: compress_hyper_8_17_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_8_17_chunk (never executed) Output: compress_hyper_8_17_chunk._ts_meta_count, compress_hyper_8_17_chunk.sensor_id, compress_hyper_8_17_chunk._ts_meta_min_1, compress_hyper_8_17_chunk._ts_meta_max_1, compress_hyper_8_17_chunk."time", compress_hyper_8_17_chunk.cpu, compress_hyper_8_17_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_10_chunk (never executed) Output: _hyper_7_10_chunk."time", _hyper_7_10_chunk.sensor_id, _hyper_7_10_chunk.cpu, _hyper_7_10_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_8_16_chunk._ts_meta_count, compress_hyper_8_16_chunk.sensor_id, compress_hyper_8_16_chunk._ts_meta_min_1, compress_hyper_8_16_chunk._ts_meta_max_1, compress_hyper_8_16_chunk."time", compress_hyper_8_16_chunk.cpu, compress_hyper_8_16_chunk.temperature Sort Key: compress_hyper_8_16_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_8_16_chunk (never executed) Output: compress_hyper_8_16_chunk._ts_meta_count, compress_hyper_8_16_chunk.sensor_id, compress_hyper_8_16_chunk._ts_meta_min_1, compress_hyper_8_16_chunk._ts_meta_max_1, compress_hyper_8_16_chunk."time", compress_hyper_8_16_chunk.cpu, compress_hyper_8_16_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_9_chunk (never executed) Output: _hyper_7_9_chunk."time", _hyper_7_9_chunk.sensor_id, _hyper_7_9_chunk.cpu, _hyper_7_9_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_8_15_chunk._ts_meta_count, compress_hyper_8_15_chunk.sensor_id, compress_hyper_8_15_chunk._ts_meta_min_1, compress_hyper_8_15_chunk._ts_meta_max_1, compress_hyper_8_15_chunk."time", compress_hyper_8_15_chunk.cpu, compress_hyper_8_15_chunk.temperature Sort Key: compress_hyper_8_15_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_8_15_chunk (never executed) Output: compress_hyper_8_15_chunk._ts_meta_count, compress_hyper_8_15_chunk.sensor_id, compress_hyper_8_15_chunk._ts_meta_min_1, compress_hyper_8_15_chunk._ts_meta_max_1, compress_hyper_8_15_chunk."time", compress_hyper_8_15_chunk.cpu, compress_hyper_8_15_chunk.temperature -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_7_8_chunk (never executed) Output: _hyper_7_8_chunk."time", _hyper_7_8_chunk.sensor_id, _hyper_7_8_chunk.cpu, _hyper_7_8_chunk.temperature Batch Sorted Merge: true Bulk Decompression: false -> Sort (never executed) Output: compress_hyper_8_14_chunk._ts_meta_count, compress_hyper_8_14_chunk.sensor_id, compress_hyper_8_14_chunk._ts_meta_min_1, compress_hyper_8_14_chunk._ts_meta_max_1, compress_hyper_8_14_chunk."time", compress_hyper_8_14_chunk.cpu, compress_hyper_8_14_chunk.temperature Sort Key: compress_hyper_8_14_chunk._ts_meta_max_1 DESC -> Seq Scan on _timescaledb_internal.compress_hyper_8_14_chunk (never executed) Output: compress_hyper_8_14_chunk._ts_meta_count, compress_hyper_8_14_chunk.sensor_id, compress_hyper_8_14_chunk._ts_meta_min_1, compress_hyper_8_14_chunk._ts_meta_max_1, compress_hyper_8_14_chunk."time", compress_hyper_8_14_chunk.cpu, compress_hyper_8_14_chunk.temperature -- Verify that we produce the same order without and with the optimization CREATE PROCEDURE order_test(query text) LANGUAGE plpgsql AS $$ DECLARE count integer; BEGIN SET timescaledb.enable_decompression_sorted_merge = 0; EXECUTE format('CREATE TABLE temp_data1 AS %s;', query); ALTER TABLE temp_data1 ADD COLUMN new_id SERIAL PRIMARY KEY; SET timescaledb.enable_decompression_sorted_merge = 1; EXECUTE format('CREATE TABLE temp_data2 AS %s;', query); ALTER TABLE temp_data2 ADD COLUMN new_id SERIAL PRIMARY KEY; CREATE TEMP TABLE temp_data3 AS ( SELECT * FROM temp_data1 UNION ALL SELECT * FROM temp_data2 ); count := (SELECT COUNT(*) FROM (SELECT COUNT(*) FROM temp_data3 GROUP BY time, new_id HAVING COUNT(*) != 2) AS s); IF count > 0 THEN RAISE EXCEPTION 'Detected different order with and without the optimization %', count; END IF; -- Drop old tables DROP TABLE temp_data1; DROP TABLE temp_data2; DROP TABLE temp_data3; END; $$; CALL order_test('SELECT * FROM sensor_data ORDER BY time DESC'); CALL order_test('SELECT * FROM sensor_data ORDER BY time DESC LIMIT 100'); CALL order_test('SELECT * FROM sensor_data ORDER BY time ASC NULLS FIRST'); CALL order_test('SELECT * FROM sensor_data ORDER BY time ASC NULLS FIRST LIMIT 100'); CALL order_test('SELECT * FROM test1 ORDER BY time DESC'); CALL order_test('SELECT * FROM test1 ORDER BY time ASC NULLS LAST'); ------ -- Test window functions ------ CREATE TABLE insert_test(id INT); INSERT INTO insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM insert_test AS ref_0 WHERE EXISTS ( SELECT sum(ref_0.id) OVER (partition by ref_0.id ORDER BY ref_0.id,ref_0.id,sample_0.time) FROM sensor_data AS sample_0 WHERE (1 > sample_0.temperature) ); id ---- 1 2 3 4 ------ -- Test enabling and disabling the optimization based on costs ------ CREATE TABLE test_costs ( time timestamptz NOT NULL, segment_by integer NOT NULL, x1 integer NOT NULL); SELECT FROM create_hypertable('test_costs', 'time'); -- ALTER TABLE test_costs SET (timescaledb.compress, timescaledb.compress_segmentby='segment_by', timescaledb.compress_orderby = 'time DESC, x1'); -- Create 100 segments INSERT INTO test_costs SELECT time, segment_by, random() as x1 FROM generate_series(1, 100, 1) AS g2(segment_by), generate_series('2000-01-01 02:01:00-00', '2000-01-06 00:00:00+00', interval '1 hour') time ORDER BY time; SELECT compress_chunk(i) FROM show_chunks('test_costs') i; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_20_chunk ANALYZE test_costs; -- Number of segments SELECT count(*) FROM (SELECT segment_by from test_costs group by segment_by) AS s; count ------- 100 -- Test query plan (should be optimized due to 100 different segments) :PREFIX SELECT time, segment_by, x1 FROM test_costs ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_20_chunk (actual rows=11800.00 loops=1) Output: _hyper_9_20_chunk."time", _hyper_9_20_chunk.segment_by, _hyper_9_20_chunk.x1 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=100.00 loops=1) Output: compress_hyper_10_21_chunk._ts_meta_count, compress_hyper_10_21_chunk.segment_by, compress_hyper_10_21_chunk._ts_meta_min_1, compress_hyper_10_21_chunk._ts_meta_max_1, compress_hyper_10_21_chunk."time", compress_hyper_10_21_chunk._ts_meta_min_2, compress_hyper_10_21_chunk._ts_meta_max_2, compress_hyper_10_21_chunk.x1 Sort Key: compress_hyper_10_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_10_21_chunk (actual rows=100.00 loops=1) Output: compress_hyper_10_21_chunk._ts_meta_count, compress_hyper_10_21_chunk.segment_by, compress_hyper_10_21_chunk._ts_meta_min_1, compress_hyper_10_21_chunk._ts_meta_max_1, compress_hyper_10_21_chunk."time", compress_hyper_10_21_chunk._ts_meta_min_2, compress_hyper_10_21_chunk._ts_meta_max_2, compress_hyper_10_21_chunk.x1 -- Decompress chunk SELECT decompress_chunk(i) FROM show_chunks('test_costs') i; decompress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_20_chunk -- Add 900 segments (1000 segments total) INSERT INTO test_costs SELECT time, segment_by, random() as x1 FROM generate_series(100, 1000, 1) AS g2(segment_by), generate_series('2000-01-01 02:01:00-00', '2000-01-06 00:00:00+00', interval '1 hour') time ORDER BY time; -- Recompress chunk SELECT compress_chunk(i) FROM show_chunks('test_costs') i; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_20_chunk ANALYZE test_costs; -- Number of segments SELECT count(*) FROM (SELECT segment_by from test_costs group by segment_by) AS s; count ------- 1000 -- Test query plan (should not be optimized due to 1000 different segments) set timescaledb.debug_require_batch_sorted_merge to 'forbid'; :PREFIX SELECT time, segment_by, x1 FROM test_costs ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=118118.00 loops=1) Output: _hyper_9_20_chunk."time", _hyper_9_20_chunk.segment_by, _hyper_9_20_chunk.x1 Sort Key: _hyper_9_20_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_20_chunk (actual rows=118118.00 loops=1) Output: _hyper_9_20_chunk."time", _hyper_9_20_chunk.segment_by, _hyper_9_20_chunk.x1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_10_22_chunk (actual rows=1000.00 loops=1) Output: compress_hyper_10_22_chunk._ts_meta_count, compress_hyper_10_22_chunk.segment_by, compress_hyper_10_22_chunk._ts_meta_min_1, compress_hyper_10_22_chunk._ts_meta_max_1, compress_hyper_10_22_chunk."time", compress_hyper_10_22_chunk._ts_meta_min_2, compress_hyper_10_22_chunk._ts_meta_max_2, compress_hyper_10_22_chunk.x1 -- Test query plan with predicate (query should be optimized due to ~100 segments) set timescaledb.debug_require_batch_sorted_merge to 'require'; :PREFIX SELECT time, segment_by, x1 FROM test_costs WHERE segment_by > 900 and segment_by < 999 ORDER BY time DESC; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_9_20_chunk (actual rows=11564.00 loops=1) Output: _hyper_9_20_chunk."time", _hyper_9_20_chunk.segment_by, _hyper_9_20_chunk.x1 Batch Sorted Merge: true Bulk Decompression: false -> Sort (actual rows=98.00 loops=1) Output: compress_hyper_10_22_chunk._ts_meta_count, compress_hyper_10_22_chunk.segment_by, compress_hyper_10_22_chunk._ts_meta_min_1, compress_hyper_10_22_chunk._ts_meta_max_1, compress_hyper_10_22_chunk."time", compress_hyper_10_22_chunk._ts_meta_min_2, compress_hyper_10_22_chunk._ts_meta_max_2, compress_hyper_10_22_chunk.x1 Sort Key: compress_hyper_10_22_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_10_22_chunk_segment_by__ts_meta_min_1__ts_me_idx on _timescaledb_internal.compress_hyper_10_22_chunk (actual rows=98.00 loops=1) Output: compress_hyper_10_22_chunk._ts_meta_count, compress_hyper_10_22_chunk.segment_by, compress_hyper_10_22_chunk._ts_meta_min_1, compress_hyper_10_22_chunk._ts_meta_max_1, compress_hyper_10_22_chunk."time", compress_hyper_10_22_chunk._ts_meta_min_2, compress_hyper_10_22_chunk._ts_meta_max_2, compress_hyper_10_22_chunk.x1 Index Cond: ((compress_hyper_10_22_chunk.segment_by > 900) AND (compress_hyper_10_22_chunk.segment_by < 999)) -- Target list creation - Issue 5738 CREATE TABLE bugtab( time timestamp without time zone, hin character varying(128) NOT NULL, model character varying(128) NOT NULL, block character varying(128) NOT NULL, message_name character varying(128) NOT NULL, signal_name character varying(128) NOT NULL, signal_numeric_value double precision, signal_string_value character varying(128) ); SELECT create_hypertable('bugtab', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices WARNING: column type "character varying" used for "hin" does not follow best practices WARNING: column type "character varying" used for "model" does not follow best practices WARNING: column type "character varying" used for "block" does not follow best practices WARNING: column type "character varying" used for "message_name" does not follow best practices WARNING: column type "character varying" used for "signal_name" does not follow best practices WARNING: column type "character varying" used for "signal_string_value" does not follow best practices create_hypertable ---------------------- (11,public,bugtab,t) INSERT INTO bugtab values('2020-01-01 10:00', 'hin1111', 'model111', 'blok111', 'message_here', 'signal1', 12.34, '12.34'); ALTER TABLE bugtab SET (timescaledb.compress, timescaledb.compress_segmentby = 'hin, signal_name', timescaledb.compress_orderby = 'time'); SELECT chunk_schema || '.' || chunk_name AS "chunk_table_bugtab" FROM timescaledb_information.chunks WHERE hypertable_name = 'bugtab' ORDER BY range_start LIMIT 1 \gset SELECT compress_chunk(i) FROM show_chunks('bugtab') i; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_23_chunk ANALYZE bugtab; set timescaledb.debug_require_batch_sorted_merge to 'force'; :PREFIX SELECT "time","hin"::text,"model"::text,"block"::text,"message_name"::text,"signal_name"::text,"signal_numeric_value","signal_string_value"::text FROM :chunk_table_bugtab ORDER BY "time" DESC; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) Output: _hyper_11_23_chunk."time", (_hyper_11_23_chunk.hin)::text, (_hyper_11_23_chunk.model)::text, (_hyper_11_23_chunk.block)::text, (_hyper_11_23_chunk.message_name)::text, (_hyper_11_23_chunk.signal_name)::text, _hyper_11_23_chunk.signal_numeric_value, (_hyper_11_23_chunk.signal_string_value)::text -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_11_23_chunk (actual rows=1.00 loops=1) Output: _hyper_11_23_chunk."time", _hyper_11_23_chunk.hin, _hyper_11_23_chunk.model, _hyper_11_23_chunk.block, _hyper_11_23_chunk.message_name, _hyper_11_23_chunk.signal_name, _hyper_11_23_chunk.signal_numeric_value, _hyper_11_23_chunk.signal_string_value Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_12_24_chunk._ts_meta_count, compress_hyper_12_24_chunk.hin, compress_hyper_12_24_chunk.signal_name, compress_hyper_12_24_chunk._ts_meta_min_1, compress_hyper_12_24_chunk._ts_meta_max_1, compress_hyper_12_24_chunk."time", compress_hyper_12_24_chunk.model, compress_hyper_12_24_chunk.block, compress_hyper_12_24_chunk.message_name, compress_hyper_12_24_chunk.signal_numeric_value, compress_hyper_12_24_chunk.signal_string_value Sort Key: compress_hyper_12_24_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_12_24_chunk (actual rows=1.00 loops=1) Output: compress_hyper_12_24_chunk._ts_meta_count, compress_hyper_12_24_chunk.hin, compress_hyper_12_24_chunk.signal_name, compress_hyper_12_24_chunk._ts_meta_min_1, compress_hyper_12_24_chunk._ts_meta_max_1, compress_hyper_12_24_chunk."time", compress_hyper_12_24_chunk.model, compress_hyper_12_24_chunk.block, compress_hyper_12_24_chunk.message_name, compress_hyper_12_24_chunk.signal_numeric_value, compress_hyper_12_24_chunk.signal_string_value SELECT "time","hin"::text,"model"::text,"block"::text,"message_name"::text,"signal_name"::text,"signal_numeric_value","signal_string_value"::text FROM :chunk_table_bugtab ORDER BY "time" DESC; time | hin | model | block | message_name | signal_name | signal_numeric_value | signal_string_value --------------------------+---------+----------+---------+--------------+-------------+----------------------+--------------------- Wed Jan 01 10:00:00 2020 | hin1111 | model111 | blok111 | message_here | signal1 | 12.34 | 12.34 SELECT "time","hin"::text,"model"::text,"block"::text,"message_name"::text,"signal_name"::text,"signal_numeric_value","signal_string_value"::text FROM bugtab ORDER BY "time" DESC; time | hin | model | block | message_name | signal_name | signal_numeric_value | signal_string_value --------------------------+---------+----------+---------+--------------+-------------+----------------------+--------------------- Wed Jan 01 10:00:00 2020 | hin1111 | model111 | blok111 | message_here | signal1 | 12.34 | 12.34 -- Condition that filter the first tuple of a batch - Issue 5797 CREATE TABLE test ( id bigint, dttm timestamp, otherId int, valueFk int, otherFk int, measure double precision ); SELECT create_hypertable('test', 'dttm'); WARNING: column type "timestamp without time zone" used for "dttm" does not follow best practices create_hypertable -------------------- (13,public,test,t) ALTER TABLE test SET ( timescaledb.compress, timescaledb.compress_segmentby = 'otherId,valueFk,otherFk' ); INSERT INTO public.test (id, dttm, otherid, valuefk, otherfk, measure) VALUES (109288, '2023-05-25 23:12:13.000000', 130, 14499, 13, 0.13216569884001217), (109286, '2023-05-25 23:12:13.000000', 130, 14500, 13, 0.3740651978942786), (107617, '2023-05-25 14:24:12.000000', 130, 14850, 13, 0.5978259144311195), (103864, '2023-05-25 13:30:51.000000', 130, 16760, 13, 0.4733429856616205), (104977, '2023-05-25 12:11:47.000000', 133, 14843, 13, 0.24366893909655118), (108321, '2023-05-25 18:39:07.000000', 133, 15294, 13, 0.8768629101819378), (108320, '2023-05-25 16:09:17.000000', 133, 15294, 13, 0.6185638532799445), (104987, '2023-05-25 13:27:19.000000', 133, 15294, 13, 0.9830846939109854), (104737, '2023-05-25 19:59:54.000000', 135, 14238, 13, 0.2388520055224177), (106278, '2023-05-25 19:59:54.000000', 135, 14238, 13, 0.6305156586688518), (104741, '2023-05-25 19:59:54.000000', 135, 14238, 13, 0.4990673076480263), (106277, '2023-05-25 12:53:34.000000', 135, 14238, 13, 0.46086278330000496), (97409, '2023-05-25 12:38:48.000000', 137, 14533, 13, 0.8308173375978924), (105234, '2023-05-25 12:38:45.000000', 137, 14533, 13, 0.10860962941223917), (105233, '2023-05-25 12:06:35.000000', 137, 14533, 13, 0.09058791972962155), (97434, '2023-05-25 12:39:46.000000', 137, 14657, 13, 0.023315916140422388), (108167, '2023-05-25 15:41:30.000000', 137, 14964, 13, 0.21757999385617666), (107741, '2023-05-25 14:40:37.000000', 137, 14964, 13, 0.3449447147508202), (106312, '2023-05-25 14:40:16.000000', 137, 14964, 13, 0.11890456868959376), (106134, '2023-05-25 12:56:18.000000', 137, 14964, 13, 0.8004332371337775), (103696, '2023-05-25 12:54:31.000000', 137, 14964, 13, 0.30147495793613643), (106311, '2023-05-25 12:44:22.000000', 137, 14964, 13, 0.7412968055185551), (106133, '2023-05-25 12:44:22.000000', 137, 14964, 13, 0.12940337622720932), (105711, '2023-05-25 12:43:57.000000', 137, 14964, 13, 0.1044849979830822), (105710, '2023-05-25 12:34:04.000000', 137, 14964, 13, 0.9113563410974876), (108787, '2023-05-25 17:59:35.000000', 137, 15377, 13, 0.921829256160489), (107833, '2023-05-25 14:53:08.000000', 137, 16302, 13, 0.9663117845438407), (105435, '2023-05-25 12:30:59.000000', 137, 16568, 13, 0.13774896612028797), (105434, '2023-05-25 12:29:29.000000', 137, 16568, 13, 0.3891495411502035), (108357, '2023-05-25 16:18:39.000000', 137, 16665, 13, 0.44701901843246716), (98564, '2023-05-25 17:12:43.000000', 138, 14760, 13, 0.8463114782142114), (109032, '2023-05-25 19:00:00.000000', 138, 14992, 13, 0.025578609447126865), (108800, '2023-05-25 18:43:18.000000', 138, 14992, 13, 0.5397724043221928), (108799, '2023-05-25 18:00:00.000000', 138, 14992, 13, 0.0321658507434357), (107320, '2023-05-25 14:00:01.000000', 138, 14992, 13, 0.9042941365487067), (107296, '2023-05-25 14:00:00.000000', 138, 14992, 13, 0.7821178685669885), (104700, '2023-05-25 12:36:55.000000', 138, 14992, 13, 0.6854496458178119), (105177, '2023-05-25 12:00:01.000000', 138, 14992, 13, 0.23780719110724746), (109330, '2023-05-25 23:59:13.000000', 138, 15080, 13, 0.5409015970284159), (107400, '2023-05-25 16:45:13.000000', 138, 15080, 13, 0.6233594483468217), (107399, '2023-05-25 14:03:49.000000', 138, 15080, 13, 0.8192327792045404), (105004, '2023-05-25 13:37:49.000000', 138, 15080, 13, 0.2993620446103442), (102592, '2023-05-25 13:31:48.000000', 138, 15080, 13, 0.24649704579496046), (109028, '2023-05-25 19:00:00.000000', 138, 15123, 13, 0.5442767942906279), (108794, '2023-05-25 18:43:18.000000', 138, 15123, 13, 0.29095714680616425), (108793, '2023-05-25 18:00:00.000000', 138, 15123, 13, 0.681894893772391), (107314, '2023-05-25 14:00:01.000000', 138, 15123, 13, 0.9637603904838059), (107292, '2023-05-25 14:00:00.000000', 138, 15123, 13, 0.05956707862994293), (104696, '2023-05-25 12:36:55.000000', 138, 15123, 13, 0.27039489547807705), (105171, '2023-05-25 12:00:01.000000', 138, 15123, 13, 0.1269705046788907), (106625, '2023-05-25 13:22:19.000000', 138, 15326, 13, 0.7712280764026431), (106624, '2023-05-25 13:15:49.000000', 138, 15326, 13, 0.585381418741779), (105699, '2023-05-25 12:44:33.000000', 138, 15326, 13, 0.3710994669938259), (105698, '2023-05-25 12:33:41.000000', 138, 15326, 13, 0.8992328857980105), (108514, '2023-05-25 16:47:37.000000', 138, 15620, 13, 0.40346934167556725), (102691, '2023-05-25 13:33:57.000000', 138, 15620, 13, 0.8046719989908304), (103655, '2023-05-25 13:34:39.000000', 138, 15740, 13, 0.2541099322817928), (106987, '2023-05-25 13:37:36.000000', 138, 15766, 13, 0.8407818724583045), (102180, '2023-05-25 13:37:11.000000', 138, 15766, 13, 0.19149633299917213), (102717, '2023-05-25 13:38:17.000000', 138, 15868, 13, 0.03196157886032225), (102719, '2023-05-25 13:38:42.000000', 138, 15921, 13, 0.9986438564169191), (103659, '2023-05-25 13:35:11.000000', 138, 15926, 13, 0.8549591705597201), (108796, '2023-05-25 18:43:18.000000', 138, 15932, 13, 0.6213586835883191), (108795, '2023-05-25 18:00:00.000000', 138, 15932, 13, 0.6730718577847092), (107326, '2023-05-25 14:00:01.000000', 138, 15932, 13, 0.278131899094646), (107298, '2023-05-25 14:00:00.000000', 138, 15932, 13, 0.92423751071723), (104702, '2023-05-25 12:36:55.000000', 138, 15932, 13, 0.22221315122722984), (105175, '2023-05-25 12:00:01.000000', 138, 15932, 13, 0.28839114292751233), (102736, '2023-05-25 16:15:29.000000', 138, 16052, 13, 0.431037595792759), (99163, '2023-05-25 13:47:30.000000', 138, 16419, 13, 0.5291021511946319), (102738, '2023-05-25 13:45:05.000000', 138, 16420, 13, 0.6506497895856924), (99109, '2023-05-25 13:37:49.000000', 138, 16420, 13, 0.019501542758906254), (108798, '2023-05-25 18:43:18.000000', 138, 16590, 13, 0.8990882904615916), (108797, '2023-05-25 18:00:00.000000', 138, 16590, 13, 0.8888186371755147), (107328, '2023-05-25 14:00:01.000000', 138, 16590, 13, 0.019486942610562608), (107300, '2023-05-25 14:00:00.000000', 138, 16590, 13, 0.5614292991802508), (104698, '2023-05-25 12:36:55.000000', 138, 16590, 13, 0.01866956387405594), (105173, '2023-05-25 12:00:01.000000', 138, 16590, 13, 0.25661478763909074), (107224, '2023-05-25 13:51:57.000000', 138, 16633, 13, 0.0010321723593804677), (99064, '2023-05-25 13:37:49.000000', 138, 16633, 13, 0.8675616866165861), (109225, '2023-05-25 22:13:01.000000', 138, 16669, 13, 0.1076822852142385), (109224, '2023-05-25 21:11:56.000000', 138, 16669, 13, 0.24001365186054713); SELECT compress_chunk(show_chunks('test', older_than => INTERVAL '1 week'), true); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_25_chunk SELECT t.dttm FROM test t WHERE t.dttm > '2023-05-25T14:23:12' ORDER BY t.dttm; dttm -------------------------- Thu May 25 14:24:12 2023 Thu May 25 14:40:16 2023 Thu May 25 14:40:37 2023 Thu May 25 14:53:08 2023 Thu May 25 15:41:30 2023 Thu May 25 16:09:17 2023 Thu May 25 16:15:29 2023 Thu May 25 16:18:39 2023 Thu May 25 16:45:13 2023 Thu May 25 16:47:37 2023 Thu May 25 17:12:43 2023 Thu May 25 17:59:35 2023 Thu May 25 18:00:00 2023 Thu May 25 18:00:00 2023 Thu May 25 18:00:00 2023 Thu May 25 18:00:00 2023 Thu May 25 18:39:07 2023 Thu May 25 18:43:18 2023 Thu May 25 18:43:18 2023 Thu May 25 18:43:18 2023 Thu May 25 18:43:18 2023 Thu May 25 19:00:00 2023 Thu May 25 19:00:00 2023 Thu May 25 19:59:54 2023 Thu May 25 19:59:54 2023 Thu May 25 19:59:54 2023 Thu May 25 21:11:56 2023 Thu May 25 22:13:01 2023 Thu May 25 23:12:13 2023 Thu May 25 23:12:13 2023 Thu May 25 23:59:13 2023 -- Test that the enable_sort GUC doesn't disable the batch sorted merge plan. SET enable_sort TO OFF; set timescaledb.debug_require_batch_sorted_merge = 'require'; :PREFIX SELECT t.dttm FROM test t ORDER BY t.dttm LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) Output: t.dttm -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_13_25_chunk t (actual rows=1.00 loops=1) Output: t.dttm Batch Sorted Merge: true Reverse: true Bulk Decompression: false -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_14_26_chunk._ts_meta_count, compress_hyper_14_26_chunk.otherid, compress_hyper_14_26_chunk.valuefk, compress_hyper_14_26_chunk.otherfk, compress_hyper_14_26_chunk.id, compress_hyper_14_26_chunk._ts_meta_min_1, compress_hyper_14_26_chunk._ts_meta_max_1, compress_hyper_14_26_chunk.dttm, compress_hyper_14_26_chunk.measure Sort Key: compress_hyper_14_26_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_14_26_chunk (actual rows=32.00 loops=1) Output: compress_hyper_14_26_chunk._ts_meta_count, compress_hyper_14_26_chunk.otherid, compress_hyper_14_26_chunk.valuefk, compress_hyper_14_26_chunk.otherfk, compress_hyper_14_26_chunk.id, compress_hyper_14_26_chunk._ts_meta_min_1, compress_hyper_14_26_chunk._ts_meta_max_1, compress_hyper_14_26_chunk.dttm, compress_hyper_14_26_chunk.measure RESET enable_sort; reset timescaledb.debug_require_batch_sorted_merge; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_sorted_merge_columns.out���������������������������0000664�0000000�0000000�00000017727�15100345067�0027044�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test various corner cases of sorting. create table t(x int, time timestamp, timetz timestamptz, int32 int4, int64 int8, s text); select create_hypertable('t', 'x'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------- (1,public,t,t) insert into t values (1, '2022-01-01', '2023-01-01', 5, -13, 'a'), (2, '2023-01-01', '2025-01-01', 1, -13, 'b'), (3, '2024-01-01', '2021-01-01', 3, -16, 'd'), (4, '2025-01-01', '2021-01-01', -2, 12, 'e'), (5, '2021-01-01', '2026-01-01', -2, 14, 'e'), (6, '2021-01-01', '2022-01-01', -4, 15, 'c') ; alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='time'); select compress_chunk(show_chunks('t')) \gset set enable_sort to off; set timescaledb.enable_decompression_sorted_merge to on; set timescaledb.debug_require_batch_sorted_merge to 'require'; -- set enable_sort to on; -- set timescaledb.enable_decompression_sorted_merge to off; -- set timescaledb.debug_require_batch_sorted_merge to off; select * from t order by time; x | time | timetz | int32 | int64 | s ---+--------------------------+------------------------------+-------+-------+--- 5 | Fri Jan 01 00:00:00 2021 | Thu Jan 01 00:00:00 2026 PST | -2 | 14 | e 6 | Fri Jan 01 00:00:00 2021 | Sat Jan 01 00:00:00 2022 PST | -4 | 15 | c 1 | Sat Jan 01 00:00:00 2022 | Sun Jan 01 00:00:00 2023 PST | 5 | -13 | a 2 | Sun Jan 01 00:00:00 2023 | Wed Jan 01 00:00:00 2025 PST | 1 | -13 | b 3 | Mon Jan 01 00:00:00 2024 | Fri Jan 01 00:00:00 2021 PST | 3 | -16 | d 4 | Wed Jan 01 00:00:00 2025 | Fri Jan 01 00:00:00 2021 PST | -2 | 12 | e -- Test the fix for #7975: batch sort merge over eligible OpExpr and FuncExpr select time::timestamptz + interval '1 second' from t order by time::timestamptz + interval '1 second'; ?column? ------------------------------ Fri Jan 01 00:00:01 2021 PST Fri Jan 01 00:00:01 2021 PST Sat Jan 01 00:00:01 2022 PST Sun Jan 01 00:00:01 2023 PST Mon Jan 01 00:00:01 2024 PST Wed Jan 01 00:00:01 2025 PST select time + interval '1 second' from t order by time + interval '1 second'; ?column? -------------------------- Fri Jan 01 00:00:01 2021 Fri Jan 01 00:00:01 2021 Sat Jan 01 00:00:01 2022 Sun Jan 01 00:00:01 2023 Mon Jan 01 00:00:01 2024 Wed Jan 01 00:00:01 2025 select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='timetz,time'); select compress_chunk(show_chunks('t')) \gset select * from t order by timetz, time; x | time | timetz | int32 | int64 | s ---+--------------------------+------------------------------+-------+-------+--- 3 | Mon Jan 01 00:00:00 2024 | Fri Jan 01 00:00:00 2021 PST | 3 | -16 | d 4 | Wed Jan 01 00:00:00 2025 | Fri Jan 01 00:00:00 2021 PST | -2 | 12 | e 6 | Fri Jan 01 00:00:00 2021 | Sat Jan 01 00:00:00 2022 PST | -4 | 15 | c 1 | Sat Jan 01 00:00:00 2022 | Sun Jan 01 00:00:00 2023 PST | 5 | -13 | a 2 | Sun Jan 01 00:00:00 2023 | Wed Jan 01 00:00:00 2025 PST | 1 | -13 | b 5 | Fri Jan 01 00:00:00 2021 | Thu Jan 01 00:00:00 2026 PST | -2 | 14 | e select timetz::timestamp + interval '1 second' from t order by timetz::timestamp + interval '1 second'; ?column? -------------------------- Fri Jan 01 00:00:01 2021 Fri Jan 01 00:00:01 2021 Sat Jan 01 00:00:01 2022 Sun Jan 01 00:00:01 2023 Wed Jan 01 00:00:01 2025 Thu Jan 01 00:00:01 2026 select timetz + interval '1 second' from t order by timetz + interval '1 second'; ?column? ------------------------------ Fri Jan 01 00:00:01 2021 PST Fri Jan 01 00:00:01 2021 PST Sat Jan 01 00:00:01 2022 PST Sun Jan 01 00:00:01 2023 PST Wed Jan 01 00:00:01 2025 PST Thu Jan 01 00:00:01 2026 PST select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='int32,timetz,time'); select compress_chunk(show_chunks('t')) \gset select * from t order by int32, timetz, time; x | time | timetz | int32 | int64 | s ---+--------------------------+------------------------------+-------+-------+--- 6 | Fri Jan 01 00:00:00 2021 | Sat Jan 01 00:00:00 2022 PST | -4 | 15 | c 4 | Wed Jan 01 00:00:00 2025 | Fri Jan 01 00:00:00 2021 PST | -2 | 12 | e 5 | Fri Jan 01 00:00:00 2021 | Thu Jan 01 00:00:00 2026 PST | -2 | 14 | e 2 | Sun Jan 01 00:00:00 2023 | Wed Jan 01 00:00:00 2025 PST | 1 | -13 | b 3 | Mon Jan 01 00:00:00 2024 | Fri Jan 01 00:00:00 2021 PST | 3 | -16 | d 1 | Sat Jan 01 00:00:00 2022 | Sun Jan 01 00:00:00 2023 PST | 5 | -13 | a select int32 + 1 from t order by int32 + 1; ?column? ---------- -3 -1 -1 2 4 6 -- Sort Merge not used because only last Order By expression can be sort-transformed, not both of them \set ON_ERROR_STOP 0 select int32 + 1, timetz + interval '1 second' from t order by int32 + 1, timetz + interval '1 second'; ERROR: debug: batch sorted merge is required but not possible at planning time \set ON_ERROR_STOP 1 select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='int64,int32,timetz,time'); select compress_chunk(show_chunks('t')) \gset select * from t order by int64, int32, timetz, time; x | time | timetz | int32 | int64 | s ---+--------------------------+------------------------------+-------+-------+--- 3 | Mon Jan 01 00:00:00 2024 | Fri Jan 01 00:00:00 2021 PST | 3 | -16 | d 2 | Sun Jan 01 00:00:00 2023 | Wed Jan 01 00:00:00 2025 PST | 1 | -13 | b 1 | Sat Jan 01 00:00:00 2022 | Sun Jan 01 00:00:00 2023 PST | 5 | -13 | a 4 | Wed Jan 01 00:00:00 2025 | Fri Jan 01 00:00:00 2021 PST | -2 | 12 | e 5 | Fri Jan 01 00:00:00 2021 | Thu Jan 01 00:00:00 2026 PST | -2 | 14 | e 6 | Fri Jan 01 00:00:00 2021 | Sat Jan 01 00:00:00 2022 PST | -4 | 15 | c -- Both sides of OpExpr have to be of the same type for sort_transform to work select int64 + 1 from t order by int64 + 1::int8; ?column? ---------- -15 -12 -12 13 15 16 -- Batch sort merge won't be used as sides of OpExpr are of different types (int8 vs int4) \set ON_ERROR_STOP 0 select int64 + 1 from t order by int64 + 1; ERROR: debug: batch sorted merge is required but not possible at planning time \set ON_ERROR_STOP 1 select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='s,int32,time desc'); select compress_chunk(show_chunks('t')) \gset select * from t order by s, int32, time desc; x | time | timetz | int32 | int64 | s ---+--------------------------+------------------------------+-------+-------+--- 1 | Sat Jan 01 00:00:00 2022 | Sun Jan 01 00:00:00 2023 PST | 5 | -13 | a 2 | Sun Jan 01 00:00:00 2023 | Wed Jan 01 00:00:00 2025 PST | 1 | -13 | b 6 | Fri Jan 01 00:00:00 2021 | Sat Jan 01 00:00:00 2022 PST | -4 | 15 | c 3 | Mon Jan 01 00:00:00 2024 | Fri Jan 01 00:00:00 2021 PST | 3 | -16 | d 4 | Wed Jan 01 00:00:00 2025 | Fri Jan 01 00:00:00 2021 PST | -2 | 12 | e 5 | Fri Jan 01 00:00:00 2021 | Thu Jan 01 00:00:00 2026 PST | -2 | 14 | e -- Batch sort merge won't be used as only Int and Date/Time types are allowed in OpExpr \set ON_ERROR_STOP 0 select s||'1' from t order by s||'1'; ERROR: debug: batch sorted merge is required but not possible at planning time \set ON_ERROR_STOP 1 �����������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_sorted_merge_distinct.out��������������������������0000664�0000000�0000000�00000012337�15100345067�0027175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test that the compressed batch sorted merge plan is chosen based on the -- cardinality of the segmentby columns. set max_parallel_workers_per_gather = 0; -- helper function: float -> pseudorandom float [0..1]. create or replace function mix(x float4) returns float4 as $$ select ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ language sql; create table t(ts timestamp, low_card int, high_card int, value float); select create_hypertable('t', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------- (1,public,t,t) insert into t select '2020-01-01'::timestamp + interval '1 second' * (x + 0.1 * mix(low_card + high_card + x)), low_card, high_card, 100 * mix(low_card + high_card) * sin(x / mix(low_card + high_card + 1)) from generate_series(1, 400) x, generate_series(1, 3) low_card, generate_series(1, 700) high_card; alter table t set (timescaledb.compress = true, timescaledb.compress_segmentby = 'low_card,high_card'); select count(compress_chunk(x, true)) from show_chunks('t') x; count ------- 1 analyze t; explain (buffers off, costs off) select * from t order by ts; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.ts -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Seq Scan on compress_hyper_2_2_chunk explain (buffers off, costs off) select * from t where low_card = 1 order by ts; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.ts -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: (low_card = 1) explain (buffers off, costs off) select * from t where high_card = 1 order by ts; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Sort Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: (high_card = 1) explain (buffers off, costs off) select * from t where low_card = 1 and high_card = 1 order by ts; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Sort Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1, compress_hyper_2_2_chunk._ts_meta_max_1 -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: ((low_card = 1) AND (high_card = 1)) -- Test that batch sorted merge is not disabled by enable_sort. We have another -- GUC to disable it. set enable_sort to off; explain (buffers off, costs off) select * from t where high_card = 1 order by ts; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Sort Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: (high_card = 1) reset enable_sort; -- Test that inequality conditions in WHERE also influence the estimates. explain (buffers off, costs off) select * from t where high_card < 10 order by ts; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Sort Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: (high_card < 10) explain (buffers off, costs off) select * from t where high_card < 500 order by ts; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.ts -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Seq Scan on compress_hyper_2_2_chunk Filter: (high_card < 500) -- Test that batch sorted merge respects the working memory limit. set work_mem to 64; explain (buffers off, costs off) select * from t where high_card < 10 order by ts; --- QUERY PLAN --- Sort Sort Key: _hyper_1_1_chunk.ts -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: (high_card < 10) reset work_mem; -- Test for large values of memory limit bytes that don't fit into an int. -- Note that on i386 the max value is 2GB which is not enough to trigger the -- overflow we had on 64-bit systems, so we have to use different values based -- on the architecture. select least(4194304, max_val::bigint) large_work_mem from pg_settings where name = 'work_mem' \gset set work_mem to :large_work_mem; explain (buffers off, costs off) select * from t where high_card < 10 order by ts; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Sort Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 -> Index Scan using compress_hyper_2_2_chunk_low_card_high_card__ts_meta_min_1__idx on compress_hyper_2_2_chunk Index Cond: (high_card < 10) reset work_mem; reset max_parallel_workers_per_gather; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_sorted_merge_filter.out����������������������������0000664�0000000�0000000�00000010071�15100345067�0026632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. create table batches(ts timestamp, id int); select create_hypertable('batches', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ---------------------- (1,public,batches,t) alter table batches set (timescaledb.compress, timescaledb.compress_segmentby = 'id'); insert into batches values ('2022-02-02 00:00:01', 1), ('2022-02-02 00:00:11', 1), ('2022-02-02 00:00:02', 2), ('2022-02-02 00:00:12', 2), ('2022-02-02 00:00:03', 3), ('2022-02-02 00:00:13', 3); select compress_chunk(x, true) from show_chunks('batches') x; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk analyze batches; set timescaledb.debug_require_batch_sorted_merge to 'require'; set enable_sort to off; select ts from batches where ts != '2022-02-02 00:00:02' order by ts; ts -------------------------- Wed Feb 02 00:00:01 2022 Wed Feb 02 00:00:03 2022 Wed Feb 02 00:00:11 2022 Wed Feb 02 00:00:12 2022 Wed Feb 02 00:00:13 2022 -- check that the GUC actually works \set ON_ERROR_STOP off set timescaledb.enable_decompression_sorted_merge to off; select ts from batches where ts != '2022-02-02 00:00:02' order by ts; ERROR: debug: batch sorted merge is required but not possible at planning time reset timescaledb.enable_decompression_sorted_merge; \set ON_ERROR_STOP on -- middle batch entirely filtered out truncate table batches; alter table batches add column filter bool; insert into batches values ('2022-02-02 00:00:01', 1, true), ('2022-02-02 00:00:11', 1, true), ('2022-02-02 00:00:02', 2, true), ('2022-02-02 00:00:12', 2, true), ('2022-02-02 00:00:03', 3, false), ('2022-02-02 00:00:13', 3, false); select compress_chunk(x, true) from show_chunks('batches') x; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_3_chunk analyze batches; select ts from batches where filter order by ts; ts -------------------------- Wed Feb 02 00:00:01 2022 Wed Feb 02 00:00:02 2022 Wed Feb 02 00:00:11 2022 Wed Feb 02 00:00:12 2022 -- last batch entirely filtered out truncate table batches; insert into batches values ('2022-02-02 00:00:01', 1, true), ('2022-02-02 00:00:02', 1, true), ('2022-02-02 00:00:03', 2, true), ('2022-02-02 00:00:04', 2, true), ('2022-02-02 00:00:05', 3, false), ('2022-02-02 00:00:06', 3, false); select compress_chunk(x, true) from show_chunks('batches') x; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk analyze batches; select ts from batches where filter order by ts; ts -------------------------- Wed Feb 02 00:00:01 2022 Wed Feb 02 00:00:02 2022 Wed Feb 02 00:00:03 2022 Wed Feb 02 00:00:04 2022 -- first batch entirely filtered out truncate table batches; insert into batches values ('2022-02-02 00:00:01', 1, false), ('2022-02-02 00:00:02', 1, false), ('2022-02-02 00:00:03', 2, true), ('2022-02-02 00:00:04', 2, true), ('2022-02-02 00:00:05', 3, true), ('2022-02-02 00:00:06', 3, true); select compress_chunk(x, true) from show_chunks('batches') x; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_7_chunk analyze batches; select ts from batches where filter order by ts; ts -------------------------- Wed Feb 02 00:00:03 2022 Wed Feb 02 00:00:04 2022 Wed Feb 02 00:00:05 2022 Wed Feb 02 00:00:06 2022 -- Test case for EquivalenceMember from a join rel (with multiple em_relids). select * from batches join ( select coalesce(t2.t, t1.t) t from (select now() + random() * interval '1s' t) t1 left join (select now() + random() * interval '1s' t) t2 on t1 = t2 ) t3 on batches.ts = t3.t order by ts; ts | id | filter | t ----+----+--------+--- �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_trigger.out����������������������������������������0000664�0000000�0000000�00000020213�15100345067�0024250�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This is copied from hypercore_trigger.sql set client_min_messages to warning; create table readings( metric_id serial, created_at timestamptz not null unique, location_id smallint, --segmentby attribute with index owner_id bigint, --segmentby attribute without index device_id bigint, --non-segmentby attribute temp float8, humidity float4 ); select create_hypertable('readings', by_range('created_at')); create_hypertable ------------------- (1,t) select setseed(1); setseed --------- insert into readings(created_at, location_id, device_id, owner_id, temp, humidity) select t, ceil(random()*10), ceil(random()*30), ceil(random() * 5), random()*40, random()*100 from generate_series('2022-06-01'::timestamptz, '2022-07-01', '5m') t; alter table readings set ( timescaledb.compress, timescaledb.compress_orderby = 'created_at', timescaledb.compress_segmentby = 'location_id, owner_id' ); select compress_chunk(show_chunks('readings')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk create table saved_rows (like readings, new_row bool not null, kind text); create function save_transition_table() returns trigger as $$ begin case tg_op when 'INSERT' then insert into saved_rows select n.*, true, tg_op from new_table n; when 'DELETE' then insert into saved_rows select o.*, false, tg_op from old_table o; when 'UPDATE' then insert into saved_rows select n.*, true, tg_op from new_table n; insert into saved_rows select o.*, false, tg_op from old_table o; end case; return null; end; $$ language plpgsql; create trigger save_insert_transition_table_trg after insert on readings referencing new table as new_table for each statement execute function save_transition_table(); insert into readings(created_at, location_id, device_id, owner_id, temp, humidity) values ('2022-06-01 00:01:23', 999, 666, 111, 3.14, 3.14), ('2022-06-01 00:02:23', 999, 666, 112, 3.14, 3.14); select * from saved_rows order by metric_id; metric_id | created_at | location_id | owner_id | device_id | temp | humidity | new_row | kind -----------+------------------------------+-------------+----------+-----------+------+----------+---------+-------- 8642 | Wed Jun 01 00:01:23 2022 PDT | 999 | 111 | 666 | 3.14 | 3.14 | t | INSERT 8643 | Wed Jun 01 00:02:23 2022 PDT | 999 | 112 | 666 | 3.14 | 3.14 | t | INSERT truncate saved_rows; select compress_chunk(show_chunks('readings')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk copy readings(created_at, location_id, device_id, owner_id, temp, humidity) from stdin with (format csv); select * from saved_rows order by metric_id; metric_id | created_at | location_id | owner_id | device_id | temp | humidity | new_row | kind -----------+------------------------------+-------------+----------+-----------+------+----------+---------+-------- 8644 | Wed Jun 01 00:01:35 2022 PDT | 999 | 111 | 666 | 3.14 | 3.14 | t | INSERT truncate saved_rows; select compress_chunk(show_chunks('readings')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk create trigger save_update_transition_table_trg after update on readings referencing new table as new_table old table as old_table for each statement execute function save_transition_table(); select * from readings where location_id = 999 order by metric_id; metric_id | created_at | location_id | owner_id | device_id | temp | humidity -----------+------------------------------+-------------+----------+-----------+------+---------- 8642 | Wed Jun 01 00:01:23 2022 PDT | 999 | 111 | 666 | 3.14 | 3.14 8643 | Wed Jun 01 00:02:23 2022 PDT | 999 | 112 | 666 | 3.14 | 3.14 8644 | Wed Jun 01 00:01:35 2022 PDT | 999 | 111 | 666 | 3.14 | 3.14 update readings set humidity = 99.99 where location_id = 999; select * from saved_rows order by metric_id; metric_id | created_at | location_id | owner_id | device_id | temp | humidity | new_row | kind -----------+------------------------------+-------------+----------+-----------+------+----------+---------+-------- 8642 | Wed Jun 01 00:01:23 2022 PDT | 999 | 111 | 666 | 3.14 | 99.99 | t | UPDATE 8642 | Wed Jun 01 00:01:23 2022 PDT | 999 | 111 | 666 | 3.14 | 3.14 | f | UPDATE 8643 | Wed Jun 01 00:02:23 2022 PDT | 999 | 112 | 666 | 3.14 | 99.99 | t | UPDATE 8643 | Wed Jun 01 00:02:23 2022 PDT | 999 | 112 | 666 | 3.14 | 3.14 | f | UPDATE 8644 | Wed Jun 01 00:01:35 2022 PDT | 999 | 111 | 666 | 3.14 | 99.99 | t | UPDATE 8644 | Wed Jun 01 00:01:35 2022 PDT | 999 | 111 | 666 | 3.14 | 3.14 | f | UPDATE truncate saved_rows; select compress_chunk(show_chunks('readings')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk -- This is not supported since it is possible to delete an entire -- segment without executing the trigger. \set ON_ERROR_STOP 0 create trigger save_delete_transition_table_trg after delete on readings referencing old table as old_table for each statement execute function save_transition_table(); ERROR: DELETE triggers with transition tables not supported \set ON_ERROR_STOP 1 -- Test that we get an error when enabling compression and have a -- delete trigger with a transition table. We allow transition tables -- for update and insert triggers. create table test2( created_at timestamptz not null unique, location_id bigint, temp float8 ); select create_hypertable('test2', by_range('created_at')); create_hypertable ------------------- (3,t) create trigger save_test2_insert_trg after insert on test2 referencing new table as new_table for each statement execute function save_transition_table(); create trigger save_test2_update_trg after update on test2 referencing new table as new_table old table as old_table for each statement execute function save_transition_table(); create trigger save_test2_delete_trg after delete on test2 referencing old table as old_table for each statement execute function save_transition_table(); -- This should fail \set ON_ERROR_STOP 0 alter table test2 set ( timescaledb.compress, timescaledb.compress_orderby = 'created_at', timescaledb.compress_segmentby = 'location_id' ); ERROR: DELETE triggers with transition tables not supported \set ON_ERROR_STOP 1 -- drop the delete trigger drop trigger save_test2_delete_trg on test2; -- This should now succeed. alter table test2 set ( timescaledb.compress, timescaledb.compress_orderby = 'created_at', timescaledb.compress_segmentby = 'location_id' ); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_update_delete-15.out�������������������������������0000664�0000000�0000000�00000351254�15100345067�0025650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off, timing off, summary off, analyze)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | sample_table | t \set start_date '2022-01-28 01:09:53.583252+05:30' INSERT INTO sample_table SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date'::timestamptz - INTERVAL '1 months', :'start_date'::timestamptz - INTERVAL '1 week', INTERVAL '1 hour') AS g1(time), generate_series(1, 8, 1 ) AS g2(sensor_id) ORDER BY time; \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test rows visibility BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- update 4 rows UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 ROLLBACK; -- get count of affected rows SELECT count(*) FROM sample_table WHERE cpu = 21.98 AND temperature = 33.123; count ------- 4 -- do update UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the partial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- get count of affected rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- do delete DELETE FROM sample_table WHERE name = 'updated row'; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- test for IS NULL checks -- should not UPDATE any rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test for IS NOT NULL checks -- should UPDATE all rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NOT NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; count ------- 0 -- get total count of rows which satifies the condition SELECT COUNT(*) as "total_affected_rows" FROM sample_table WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30' \gset -- perform UPDATE with < and > comparison on SEGMENTBY column UPDATE sample_table SET name = 'updated row based on < OR > comparison' WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30'; -- check chunk compression status after UPDATE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- count should be same SELECT COUNT(*) = (:total_affected_rows) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; ?column? ---------- t DROP TABLE sample_table; -- test to ensure that only required rows from compressed chunks -- are extracted if SEGMENTBY column is used in WHERE condition CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 3 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 3 | 3 | 1 10 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 1 -- delete rows with device_id = 3 DELETE FROM sample_table WHERE device_id = 3; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- -- there should 2 rows matching the conditions coming from 2 chunks SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 1 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 1 -- update rows with device_id = 1 UPDATE sample_table SET val = 200 WHERE 1 = device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 0 -- there should be 2 rows SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 200 200 DROP TABLE sample_table; CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 5 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'time, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (1, 3, 2), (11, 4, 2), (1, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_9_chunk _timescaledb_internal._hyper_5_10_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 1 | 1 | 2 1 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where time = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- delete rows with time = 1 AND val = 2 EXPLAIN (buffers off, costs off, verbose) DELETE FROM sample_table WHERE time = 1 AND 2 = val; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.sample_table Delete on _timescaledb_internal._hyper_5_9_chunk sample_table_1 -> Seq Scan on _timescaledb_internal._hyper_5_9_chunk sample_table_1 Output: sample_table_1.tableoid, sample_table_1.ctid Filter: ((sample_table_1."time" = 1) AND (2 = sample_table_1.val)) -- should delete rows from 1 of the compressed chunks DELETE FROM sample_table WHERE time = 1 AND 2 = val; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks wheretime = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- DROP TABLE sample_table; -- Test chunk compile time startup exclusion CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE TABLE sample_table(time timestamptz NOT NULL, temp float, colorid integer, attr jsonb); SELECT create_hypertable('sample_table', 'time', chunk_time_interval => 2628000000000); create_hypertable --------------------------- (7,public,sample_table,t) -- create three chunks INSERT INTO sample_table VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_segmentby = 'time'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk -- ensure all chunks are compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 1 | _hyper_7_15_chunk -- report 0 rows SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------+------+---------+------ -- update 1 row UPDATE sample_table SET colorid = 4 WHERE time > now_s() + '-1 month'; -- report 1 row SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------------------------------+------+---------+---------- Tue Aug 22 09:18:22 2017 PDT | 34.1 | 4 | {"c": 4} -- ensure that 1 chunk is partially compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 9 | _hyper_7_15_chunk DROP TABLE sample_table; -- test for NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 9 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, NULL, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_19_chunk _timescaledb_internal._hyper_9_20_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE device_id IS NULL; count ------- 4 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id IS NULL; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 9 | _hyper_9_19_chunk 9 | _hyper_9_20_chunk DROP TABLE sample_table; -- test for IS NOT NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 11 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, NULL, 1), (2, NULL, 1), (3, NULL, 1), (10, 3, 2), (11, 2, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_23_chunk _timescaledb_internal._hyper_11_24_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 0 -- UPDATE based on IS NOT NULL condition on SEGMENTBY column UPDATE sample_table SET val = 1234 WHERE device_id IS NOT NULL; -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 3 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_11_23_chunk 9 | _hyper_11_24_chunk DROP TABLE sample_table; -- test to for <= AND >= on SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 13 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); INSERT INTO sample_table VALUES (4, 3, NULL), (6, NULL, NULL), (12, NULL, NULL), (13, 4, NULL); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_27_chunk _timescaledb_internal._hyper_13_28_chunk -- test will multiple NULL/NOT NULL columns BEGIN; -- report 0 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- -- these 3 rows will be affected by below UPDATE SELECT * FROM sample_table WHERE device_id IS NULL AND val IS NOT NULL ORDER BY 1; time | device_id | val ------+-----------+----- 2 | | 1 10 | | 2 11 | | 2 -- update 3 rows UPDATE sample_table SET val = 987 WHERE device_id IS NULL AND val IS NOT NULL; -- report 3 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- 2 | | 987 10 | | 987 11 | | 987 ROLLBACK; -- test will multiple columns BEGIN; -- report 2 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- 10 | | 2 11 | | 2 -- delete 2 rows DELETE from sample_table WHERE device_id IS NULL AND val = 2; -- report 0 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- ROLLBACK; BEGIN; -- report 1 row SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- 4 | 3 | -- delete 1 rows DELETE from sample_table WHERE device_id = 3 AND val IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 5 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- get total count of SEGMENTBY column with device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM sample_table WHERE device_id >= 4 AND val <= 1; count ------- 1 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id >= 4 AND val <= 1; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_13_27_chunk 1 | _hyper_13_28_chunk -- added tests for code coverage UPDATE sample_table SET time = 21 WHERE (device_id) in ( 30, 51, 72, 53); UPDATE sample_table SET time = 21 WHERE device_id + 365 = 8765; DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table( time INT, device_id INT, val INT default 8, a INT default 10, b INT default 11, c INT default 12, d INT, e INT default 13); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 5); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 15 | public | sample_table | t INSERT INTO sample_table (time, device_id, d) VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); ALTER TABLE sample_table DROP COLUMN c; ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_31_chunk _timescaledb_internal._hyper_15_32_chunk ALTER TABLE sample_table ADD COLUMN c int default 23; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get FIRST uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- ensure segment by column index position in compressed and uncompressed -- chunk is different SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_1'::regclass, :'UNCOMPRESS_CHUNK_1'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_2'::regclass, :'UNCOMPRESS_CHUNK_2'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 1 -- get total count of SEGMENTBY column with d = 3 SELECT COUNT(*) FROM sample_table WHERE d = 3; count ------- 1 -- delete based on SEGMENTBY column DELETE FROM sample_table WHERE d = 3; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 BEGIN; -- report 0 row SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+---+---+---+---+--- -- delete 1 row UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- ensure rows are visible SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+-----+----+---+----+---- 2 | | 8 | 247 | 11 | 1 | 13 | 23 11 | | 8 | 247 | 11 | 2 | 13 | 23 10 | | 8 | 247 | 11 | 2 | 13 | 23 ROLLBACK; -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 0 -- UPDATE based on NULL values in SEGMENTBY column UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- report 3 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 3 -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table(time timestamptz, c1 text, c2 text, c3 text); SELECT create_hypertable('sample_table','time'); create_hypertable ---------------------------- (17,public,sample_table,t) INSERT INTO sample_table SELECT '2000-01-01'; ALTER TABLE sample_table DROP column c3; ALTER TABLE sample_table ADD column c4 text; INSERT INTO sample_table SELECT '2000-01-01', '1', '2', '3'; ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_35_chunk BEGIN; -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id \gset -- report 2 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 -- report 1 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 1 -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- -- report 1 row which ensure that only required row is moved and deleted SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 -- report 0 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 0 DROP TABLE sample_table; -- test filtering with ORDER BY columns CREATE TABLE sample_table(time timestamptz, c1 int, c2 int, c3 int, c4 int); SELECT create_hypertable('sample_table','time',chunk_time_interval=>'1 day'::interval); create_hypertable ---------------------------- (19,public,sample_table,t) ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4', timescaledb.compress_orderby='c1,c2,time'); INSERT INTO sample_table SELECT t, c1, c2, c3, c4 FROM generate_series(:'start_date'::timestamptz - INTERVAL '9 hours', :'start_date'::timestamptz, INTERVAL '1 hour') t, generate_series(0,9,1) c1, generate_series(0,9,1) c2, generate_series(0,9,1) c3, generate_series(0,9,1) c4; SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_37_chunk -- get FIRST chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- check that you uncompress and delete only for exact SEGMENTBY value SET timescaledb.debug_compression_path_info TO true; BEGIN; -- report 10 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 10 -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5; count ------- 10000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 \gset -- delete 10k rows DELETE FROM sample_table WHERE c4 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 < 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 < 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 < 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 < 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater and equal than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 >= 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 >= 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 >= 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 >= 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for exact ORDERBY value -- this will uncompress segments which have min <= value and max >= value BEGIN; -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c2 = 3; count ------- 10000 -- report 100 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 100 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c2 = 3 \gset -- delete 10k rows DELETE FROM sample_table WHERE c2 = 3; INFO: Number of compressed rows fetched from table scan: 100. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c2 = 3; count ------- 0 -- report 90k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 90000 -- report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less then ORDERBY value -- this will uncompress segments which have min < value BEGIN; -- report 20k rows SELECT COUNT(*) FROM sample_table WHERE c1 < 2; count ------- 20000 -- report 20 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 20 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 < 2 \gset -- delete 20k rows DELETE FROM sample_table WHERE c1 < 2; INFO: Number of compressed rows fetched from table scan: 20. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 < 2; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater or equal then ORDERBY value -- this will uncompress segments which have max >= value BEGIN; -- report 30k rows SELECT COUNT(*) FROM sample_table WHERE c1 >= 7; count ------- 30000 -- report 30 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 30 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 >= 7 \gset -- delete 30k rows DELETE FROM sample_table WHERE c1 >= 7; INFO: Number of compressed rows fetched from table scan: 30. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 >= 7; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments only contain one distinct value for -- these qualifiers, everything should be deleted that was decompressed BEGIN; -- report 1k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 1000 -- report 1 row in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 1 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 and c1 = 5 \gset -- delete 1k rows DELETE FROM sample_table WHERE c4 = 5 and c1 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 9. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments contain more than one distinct value for -- these qualifiers, not everything should be deleted that was decompressed BEGIN; -- report 4k rows SELECT COUNT(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 4000 -- report 40 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 40 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 > 5 and c2 = 5 \gset -- delete 4k rows DELETE FROM sample_table WHERE c4 > 5 and c2 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 40. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 0 -- report 36k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 36000 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers. -- no: of rows satisfying SEGMENTBY qualifiers is 10 -- no: of rows satisfying ORDERBY qualifiers is 3 -- Once both qualifiers are applied ensure that only 7 rows are present in -- compressed chunk BEGIN; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 10 compressed rows for given condition c4 = 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 10 -- report 3 compressed rows for given condition c4 = 4 and c1 >= 7 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7; count ------- 3 SELECT COUNT(*) AS "total_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 \gset SELECT COUNT(*) AS "total_affected_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7 \gset UPDATE sample_table SET c3 = c3 + 0 WHERE c4 = 4 AND c1 >= 7; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 7. -- report 7 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 7 -- ensure correct number of rows are moved from compressed chunk -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; ?column? ---------- t ROLLBACK; RESET timescaledb.debug_compression_path_info; --github issue: 5640 CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab1(time); CREATE INDEX ON tab1(device_id,time); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable -------------------- (21,public,tab1,t) ALTER TABLE tab1 DROP COLUMN filler_1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','57m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_2; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','58m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_3; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','59m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab1; -- compress chunks ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_21_39_chunk _timescaledb_internal._hyper_21_40_chunk _timescaledb_internal._hyper_21_41_chunk -- ensure there is an index scan generated for below DELETE query BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; EXPLAIN (buffers off, costs off) DELETE FROM public.tab1 WHERE public.tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Index Scan using _hyper_21_39_chunk_tab1_device_id_time_idx on _hyper_21_39_chunk tab1_1 Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- github issue 5658 -- verify that bitmap heap scans work on all the correct data and -- none of it left over after the dml command BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) DELETE FROM tab1 WHERE tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_21_39_chunk_tab1_device_id_time_idx Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- verify we can work with expression indexes and toastable types -- when the subquery returns a zero result set we used to end up -- trying to detoast a 0 value and segfaulting BEGIN; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX test ON tab1(repeat('t', device_id)); CREATE TABLE join_table AS SELECT repeat('t', d) FROM generate_series(1,3,1) d; ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on tab1 Update on _hyper_21_39_chunk tab1_1 Update on _hyper_21_40_chunk tab1_2 Update on _hyper_21_41_chunk tab1_3 -> Nested Loop -> Subquery Scan on devices -> HashAggregate Group Key: repeat -> Result One-Time Filter: false -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (repeat('t'::text, device_id) = devices.repeat) -> Bitmap Index Scan on _hyper_21_39_chunk_test Index Cond: (repeat('t'::text, device_id) = devices.repeat) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (devices.repeat = repeat('t'::text, device_id)) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (devices.repeat = repeat('t'::text, device_id)) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; ROLLBACK; -- create hypertable with space partitioning and compression CREATE TABLE tab2(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab2(time); CREATE INDEX ON tab2(device_id,time); SELECT create_hypertable('tab2','time','device_id',3,create_default_indexes:=false); create_hypertable -------------------- (23,public,tab2,t) ALTER TABLE tab2 DROP COLUMN filler_1; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','35m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_2; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','45m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_3; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','55m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab2; -- compress chunks ALTER TABLE tab2 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_23_45_chunk _timescaledb_internal._hyper_23_46_chunk _timescaledb_internal._hyper_23_47_chunk -- below test will cause chunks of tab2 to get decompressed -- without fix for issue #5460 SET timescaledb.enable_optimizations = OFF; BEGIN; DELETE FROM tab1 t1 USING tab2 t2 WHERE t1.device_id = t2.device_id AND t2.time > '2000-01-01'; ROLLBACK; --cleanup RESET timescaledb.enable_optimizations; DROP table tab1; DROP table tab2; -- test joins with UPDATE/DELETE on compression chunks CREATE TABLE join_test1(time timestamptz NOT NULL,device text, value float); CREATE TABLE join_test2(time timestamptz NOT NULL,device text, value float); CREATE VIEW chunk_status AS SELECT ht.table_name AS hypertable, ch.table_name AS chunk,ch.status from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id AND ht.table_name IN ('join_test1','join_test2') ORDER BY ht.id, ch.id; SELECT table_name FROM create_hypertable('join_test1', 'time'); table_name ------------ join_test1 SELECT table_name FROM create_hypertable('join_test2', 'time'); table_name ------------ join_test2 ALTER TABLE join_test1 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); ALTER TABLE join_test2 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO join_test1 VALUES ('2000-01-01','d1',0.1), ('2000-02-01','d1',0.1), ('2000-03-01','d1',0.1); INSERT INTO join_test2 VALUES ('2000-02-01','d1',0.1), ('2000-02-01','d2',0.1), ('2000-02-01','d3',0.1); SELECT compress_chunk(show_chunks('join_test1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_25_51_chunk _timescaledb_internal._hyper_25_52_chunk _timescaledb_internal._hyper_25_53_chunk SELECT compress_chunk(show_chunks('join_test2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_26_54_chunk SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 BEGIN; DELETE FROM join_test1 USING join_test2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test2 USING join_test1; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status change SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test2 t2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test2 t1 SET value = t1.value + 1 FROM join_test1 t2; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; DROP TABLE join_test1; DROP TABLE join_test2; -- test if index scan qualifiers are properly used CREATE TABLE index_scan_test(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('index_scan_test','time',create_default_indexes:=false); create_hypertable ------------------------------- (29,public,index_scan_test,t) INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-01 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- compress chunks ALTER TABLE index_scan_test SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('index_scan_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_59_chunk ANALYZE index_scan_test; SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper%' ORDER BY ch1.id LIMIT 1 \gset SELECT ch2.schema_name|| '.' || ch2.table_name AS "COMP_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.compressed_chunk_id = ch2.id ORDER BY ch2.id LIMIT 1 \gset INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- test index on single column BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) DELETE FROM index_scan_test WHERE device_id = 2; -- everything should be deleted SELECT count(*) FROM index_scan_test where device_id = 2; count ------- 0 -- there shouldn't be anything in the uncompressed chunk where device_id = 2 SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk from device_id = 2 SELECT count(*) FROM :COMP_CHUNK_1 where device_id = 2; count ------- 0 ROLLBACK; -- test multi column index BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id, time); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_time_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: ((index_scan_test_1.device_id = 2) AND (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone)) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test index with filter condition BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) Filter: (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled UPDATE sample_table SET c3 = NULL WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 -- make sure reseting the GUC we will be able to UPDATE/DELETE compressed chunks RESET timescaledb.enable_dml_decompression; SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE c4 = 5; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 10000 ROLLBACK; BEGIN; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 10000 DELETE FROM sample_table WHERE c4 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 ROLLBACK; -- create new uncompressed chunk INSERT INTO sample_table SELECT t, 1, 1, 1, 1 FROM generate_series('2023-05-04 00:00:00-00'::timestamptz, '2023-05-04 00:00:00-00'::timestamptz + INTERVAL '2 hours', INTERVAL '1 hour') t; -- check chunk compression status SELECT chunk_name, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_name | is_compressed --------------------+--------------- _hyper_19_37_chunk | t _hyper_19_61_chunk | f -- test for uncompressed and compressed chunks SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; BEGIN; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 3 -- delete from uncompressed chunk should work DELETE FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 0 ROLLBACK; BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 3 ROLLBACK; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled -- and both statements we're touching compressed and uncompressed chunks UPDATE sample_table SET c3 = NULL WHERE time >= '2023-03-17 00:00:00-00'::timestamptz AND c3 IS NULL; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE time >= '2023-03-17 00:00:00-00'::timestamptz; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 --github issue: 5586 --testcase with multiple indexes \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test5586; \c test5586 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable ------------------- (1,public,tab1,t) INSERT INTO tab1(filler_1, filler_2, filler_3,time,device_id,v0,v1,v2,v3) SELECT device_id, device_id+1, device_id + 2, time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id, filler_1, filler_2, filler_3'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 \gset -- create multiple indexes on compressed hypertable DROP INDEX _timescaledb_internal.compress_hyper_2_2_chunk_device_id_filler_1_filler_2_filler_idx; CREATE INDEX ON :CHUNK (_ts_meta_min_1); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_count); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_max_1, filler_1); CREATE INDEX filler_1 ON :CHUNK (filler_1); CREATE INDEX filler_2 ON :CHUNK (filler_2); CREATE INDEX filler_3 ON :CHUNK (filler_3); -- below indexes should be selected CREATE INDEX filler_1_filler_2 ON :CHUNK (filler_1, filler_2); CREATE INDEX filler_2_filler_3 ON :CHUNK (filler_2, filler_3); set timescaledb.debug_compression_path_info to on; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_3 = 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_3 = 5 AND filler_2 = 4; INFO: Index "filler_2_filler_3" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5 AND filler_2 = 4; INFO: Index "filler_1_filler_2" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; -- idealy filler_1 index should be selected, -- instead first matching index is selected BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5; count ------- 14392 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5; INFO: Index "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_fill_idx" is used for scan. INFO: Number of compressed rows fetched from index: 16. Number of compressed rows filtered by heap filters: 0. ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE tab1; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test5586 WITH (FORCE); --issue: #6024 CREATE TABLE t(a integer, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); create_hypertable ------------------- (31,public,t,t) INSERT INTO t values(1, 2); ALTER TABLE t SET (timescaledb.compress); SELECT compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_31_62_chunk -- should not crash UPDATE t SET b = 2 WHERE tableoid = 0; UPDATE t SET b = 2 WHERE tableoid is null; DROP TABLE t; -- github issue: 6367 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test6367; \c test6367 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE t6367 ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar, data jsonb ); SELECT table_name FROM create_hypertable('t6367', 'time'); table_name ------------ t6367 ALTER TABLE t6367 SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO t6367 SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT compress_chunk(c) FROM show_chunks('t6367') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK1" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 \gset SELECT format('%I.%I', schema_name, table_name) AS "CHUNK2" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 OFFSET 1 \gset DROP INDEX _timescaledb_internal.compress_hyper_2_3_chunk_source_id_label__ts_meta_min_1__ts_idx; DROP INDEX _timescaledb_internal.compress_hyper_2_4_chunk_source_id_label__ts_meta_min_1__ts_idx; -- testcase with no index, should use seq scan set timescaledb.debug_compression_path_info to on; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test case with an index which has only one -- of the segmentby filters CREATE INDEX source_id_idx1 ON :CHUNK1 (source_id); CREATE INDEX source_id_idx2 ON :CHUNK2 (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test that we are filtering NULL checks BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 ROLLBACK; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 30 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NOT NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_idx1; DROP INDEX _timescaledb_internal.source_id_idx2; -- test case with an index which has multiple same column CREATE INDEX source_id_source_id_idx ON :CHUNK1 (source_id, source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_source_id_idx" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_source_id_idx; -- test using a non-btree index -- fallback to heap scan CREATE INDEX brin_source_id_idx ON :CHUNK1 USING brin (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.brin_source_id_idx; -- test using an expression index -- should fallback to heap scans CREATE INDEX expr_source_id_idx ON :CHUNK1 (upper(source_id)); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.expr_source_id_idx; -- test using a partial index -- should fallback to heap scans CREATE INDEX partial_source_id_idx ON :CHUNK1 (source_id) WHERE _ts_meta_min_1 > '1990-01-01'::timestamptz; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE t6367; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test6367 WITH (FORCE); -- Text limitting decompressed tuple during an UPDATE or DELETE CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>10000); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 33 | public | test_limit | t INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp' ); SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; count ------- 2 SET timescaledb.max_tuples_decompressed_per_dml_transaction = 5000; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Updating or deleting everything will break the set limit. UPDATE test_limit SET id = 0; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). DELETE FROM test_limit WHERE id = 1; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; UPDATE test_limit SET id = 0; DELETE FROM test_limit WHERE id = 1; \set ON_ERROR_STOP 1 DROP TABLE test_limit; -- check partial compression with DML CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); create_hypertable ----------------------------- (35,public,test_partials,t) INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 -- check that DML causes transparent decompression and that -- data gets shifted to the uncompressed parts EXPLAIN (buffers off, costs off) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on test_partials Delete on _hyper_35_68_chunk test_partials_1 Delete on _hyper_35_69_chunk test_partials_2 Delete on _hyper_35_70_chunk test_partials_3 -> Custom Scan (ChunkAppend) on test_partials -> Seq Scan on _hyper_35_68_chunk test_partials_1 Filter: (SubPlan 1) SubPlan 1 -> Materialize -> Append -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Seq Scan on compress_hyper_36_71_chunk -> Seq Scan on _hyper_35_68_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Seq Scan on compress_hyper_36_72_chunk -> Seq Scan on _hyper_35_69_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Seq Scan on compress_hyper_36_73_chunk -> Seq Scan on _hyper_35_70_chunk -> Seq Scan on _hyper_35_69_chunk test_partials_2 Filter: (SubPlan 1) -> Seq Scan on _hyper_35_70_chunk test_partials_3 Filter: (SubPlan 1) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); VACUUM ANALYZE test_partials; -- All 3 chunks will now become partially compressed chunks EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Index Scan Backward using _hyper_35_68_chunk_test_partials_time_idx on _hyper_35_68_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Index Scan Backward using _hyper_35_69_chunk_test_partials_time_idx on _hyper_35_69_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -> Index Scan Backward using _hyper_35_70_chunk_test_partials_time_idx on _hyper_35_70_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk DROP TABLE test_partials; CREATE TABLE test_meta_filters(time timestamptz NOT NULL, device text, metric text, v1 float, v2 float); CREATE INDEX ON test_meta_filters(device, metric, v1); SELECT create_hypertable('test_meta_filters', 'time'); create_hypertable --------------------------------- (37,public,test_meta_filters,t) ALTER TABLE test_meta_filters SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='metric,time'); INSERT INTO test_meta_filters SELECT '2020-01-01'::timestamptz,'d1','m' || metric::text,v1,v2 FROM generate_series(1,3,1) metric, generate_series(1,1000,1) v1, generate_series(1,10,1) v2 ORDER BY 1,2,3,4,5; SELECT compress_chunk(show_chunks('test_meta_filters')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_37_74_chunk EXPLAIN (analyze, timing off, buffers off, costs off, summary off) DELETE FROM test_meta_filters WHERE device = 'd1' AND metric = 'm1' AND v1 < 100; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on test_meta_filters (actual rows=0.00 loops=1) Delete on _hyper_37_74_chunk test_meta_filters_1 -> Seq Scan on _hyper_37_74_chunk test_meta_filters_1 (actual rows=990.00 loops=1) Filter: ((v1 < '100'::double precision) AND (device = 'd1'::text) AND (metric = 'm1'::text)) Rows Removed by Filter: 10 -- test expression pushdown in compressed dml constraints CREATE TABLE test_pushdown(time timestamptz NOT NULL, device text); SELECT table_name FROM create_hypertable('test_pushdown', 'time'); table_name --------------- test_pushdown INSERT INTO test_pushdown SELECT '2020-01-01', 'a'; INSERT INTO test_pushdown SELECT '2020-01-01', 'b'; INSERT INTO test_pushdown SELECT '2020-01-01 05:00', 'c'; CREATE TABLE devices(device text); INSERT INTO devices VALUES ('a'), ('b'), ('c'); CREATE TABLE devices2(device text); INSERT INTO devices2 VALUES ('d'), ('e'), ('f'); CREATE TABLE devices3(device text); INSERT INTO devices3 VALUES ('b'), ('d'), ('g'); ALTER TABLE test_pushdown SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(show_chunks('test_pushdown')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_39_76_chunk -- 3 batch decompressions means pushdown is not working so we expect less than 3 for all these queries SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'a' = device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('a'::text = device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device < 'c' ; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: (device < 'c'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' > device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('c'::text > device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' >= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ('c'::text >= device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device > 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device > 'b'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = CURRENT_USER; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = CURRENT_USER) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' < device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('b'::text < device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' <= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('b'::text <= device) RESET timescaledb.enable_compressed_direct_batch_delete; -- cant pushdown OR atm BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = 'a' OR device = 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ((device = 'a'::text) OR (device = 'b'::text)) Rows Removed by Filter: 1 -- test stable function BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time = timestamptz('2020-01-01 05:00'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" = 'Wed Jan 01 05:00:00 2020 PST'::timestamp with time zone) -- test sqlvaluefunction BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = substring(CURRENT_USER,length(CURRENT_USER)+1) || 'c'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ("substring"((CURRENT_USER)::text, (length((CURRENT_USER)::text) + 1)) || 'c'::text)) -- JOIN tests -- no filtering in decompression SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- can filter in decompression even before executing join SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- test prepared statement PREPARE q1(text) AS DELETE FROM test_pushdown WHERE device = $1; SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = 'a'::text) RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'a'::text) BEGIN; :EXPLAIN EXECUTE q1('not here'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'not here'::text) -- test arrayop pushdown less than 3 decompressions are expected for successful pushdown BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a','d'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = ANY('{a,d}'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',CURRENT_USER); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, (CURRENT_USER)::text])) -- arroyop pushdown only works for segmentby columns atm so 3 decompressions are expected for now BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time IN ('2020-01-01','2020-01-02'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ("time" = ANY ('{"Wed Jan 01 00:00:00 2020 PST","Thu Jan 02 00:00:00 2020 PST"}'::timestamp with time zone[])) Rows Removed by Filter: 1 -- no pushdown for volatile functions BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = current_query(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = current_query()) Rows Removed by Filter: 3 BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',current_query()); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, current_query()])) Rows Removed by Filter: 2 -- test DELETE optimization without predicates -- should delete 3 complete batches without decompression BEGIN; :EXPLAIN DELETE FROM test_pushdown; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) -- test DELETE optimization on non-segmentby columns -- this shows optimization can be applied if in-memory filtering is enabled \set QUIET off BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK SET timescaledb.enable_dml_decompression_tuple_filtering TO OFF; SET BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK RESET timescaledb.enable_dml_decompression_tuple_filtering; RESET \set QUIET on -- github issue #6858 -- check update triggers work correctly both on uncompressed and compressed chunks CREATE TABLE update_trigger_test ( "entity_id" "uuid" NOT NULL, "effective_date_time" timestamp with time zone NOT NULL, "measurement" numeric NOT NULL, "modified_at" timestamp with time zone DEFAULT "now"() NOT NULL ); SELECT create_hypertable('update_trigger_test', 'effective_date_time'); create_hypertable ----------------------------------- (41,public,update_trigger_test,t) CREATE OR REPLACE FUNCTION update_modified_at_test() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN NEW.modified_at = NOW(); RETURN NEW; END; $$; CREATE TRIGGER update_trigger_test__before_update_sync_modified_at BEFORE UPDATE ON update_trigger_test FOR EACH ROW EXECUTE PROCEDURE update_modified_at_test(); INSERT INTO update_trigger_test SELECT 'f2ca7073-1395-5770-8378-7d0339804580', '2024-04-16 04:50:00+02', 1100.00, '2024-04-23 11:56:38.494095+02' FROM generate_series(1,2500,1) c; VACUUM FULL update_trigger_test; BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- try with default compression ALTER TABLE update_trigger_test SET (timescaledb.compress); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- lets try with segmentby SELECT decompress_chunk(show_chunks('update_trigger_test')); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk ALTER TABLE update_trigger_test SET (timescaledb.compress, timescaledb.compress_segmentby='entity_id'); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- check reporting of affected rows is correct for direct batch delete CREATE TABLE delete_counter(time timestamptz NOT NULL, device text) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'a' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'b' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'c' from generate_series(1,123); ALTER TABLE delete_counter SET (timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('delete_counter') ch; count ------- 2 INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'd' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-03-01'::timestamptz, 'e' from generate_series(1,123); \set QUIET off BEGIN; :EXPLAIN DELETE FROM delete_counter; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Append (actual rows=246.00 loops=1) -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=123.00 loops=1) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) ROLLBACK BEGIN; DELETE FROM delete_counter; ROLLBACK; BEGIN DELETE 615 ROLLBACK BEGIN; :EXPLAIN DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 369 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Custom Scan (ChunkAppend) on delete_counter (actual rows=615.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) Filter: (random() < '1'::double precision) ROLLBACK BEGIN; DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN DELETE 615 ROLLBACK -- test invalidation with direct batch delete optimizations CREATE TABLE cagg_inval(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE INSERT INTO cagg_inval SELECT '2020-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 INSERT INTO cagg_inval SELECT '2021-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 SELECT count(compress_chunk(ch)) FROM show_chunks('cagg_inval') ch; count ------- 2 SET timescaledb.enable_compressed_direct_batch_delete TO on; SET -- delete without cagg should use optimization BEGIN; BEGIN EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=0.00 loops=1) ROLLBACK; ROLLBACK CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time) FROM cagg_inval GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW -- should not use direct batch delete EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=1.00 loops=1) -- should have invalidation entry SELECT * FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 45 | 1577865600000000 | 1609488000000000 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_update_delete-16.out�������������������������������0000664�0000000�0000000�00000351254�15100345067�0025651�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off, timing off, summary off, analyze)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | sample_table | t \set start_date '2022-01-28 01:09:53.583252+05:30' INSERT INTO sample_table SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date'::timestamptz - INTERVAL '1 months', :'start_date'::timestamptz - INTERVAL '1 week', INTERVAL '1 hour') AS g1(time), generate_series(1, 8, 1 ) AS g2(sensor_id) ORDER BY time; \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test rows visibility BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- update 4 rows UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 ROLLBACK; -- get count of affected rows SELECT count(*) FROM sample_table WHERE cpu = 21.98 AND temperature = 33.123; count ------- 4 -- do update UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the partial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- get count of affected rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- do delete DELETE FROM sample_table WHERE name = 'updated row'; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- test for IS NULL checks -- should not UPDATE any rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test for IS NOT NULL checks -- should UPDATE all rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NOT NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; count ------- 0 -- get total count of rows which satifies the condition SELECT COUNT(*) as "total_affected_rows" FROM sample_table WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30' \gset -- perform UPDATE with < and > comparison on SEGMENTBY column UPDATE sample_table SET name = 'updated row based on < OR > comparison' WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30'; -- check chunk compression status after UPDATE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- count should be same SELECT COUNT(*) = (:total_affected_rows) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; ?column? ---------- t DROP TABLE sample_table; -- test to ensure that only required rows from compressed chunks -- are extracted if SEGMENTBY column is used in WHERE condition CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 3 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 3 | 3 | 1 10 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 1 -- delete rows with device_id = 3 DELETE FROM sample_table WHERE device_id = 3; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- -- there should 2 rows matching the conditions coming from 2 chunks SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 1 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 1 -- update rows with device_id = 1 UPDATE sample_table SET val = 200 WHERE 1 = device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 0 -- there should be 2 rows SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 200 200 DROP TABLE sample_table; CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 5 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'time, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (1, 3, 2), (11, 4, 2), (1, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_9_chunk _timescaledb_internal._hyper_5_10_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 1 | 1 | 2 1 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where time = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- delete rows with time = 1 AND val = 2 EXPLAIN (buffers off, costs off, verbose) DELETE FROM sample_table WHERE time = 1 AND 2 = val; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.sample_table Delete on _timescaledb_internal._hyper_5_9_chunk sample_table_1 -> Seq Scan on _timescaledb_internal._hyper_5_9_chunk sample_table_1 Output: sample_table_1.tableoid, sample_table_1.ctid Filter: ((sample_table_1."time" = 1) AND (2 = sample_table_1.val)) -- should delete rows from 1 of the compressed chunks DELETE FROM sample_table WHERE time = 1 AND 2 = val; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks wheretime = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- DROP TABLE sample_table; -- Test chunk compile time startup exclusion CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE TABLE sample_table(time timestamptz NOT NULL, temp float, colorid integer, attr jsonb); SELECT create_hypertable('sample_table', 'time', chunk_time_interval => 2628000000000); create_hypertable --------------------------- (7,public,sample_table,t) -- create three chunks INSERT INTO sample_table VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_segmentby = 'time'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk -- ensure all chunks are compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 1 | _hyper_7_15_chunk -- report 0 rows SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------+------+---------+------ -- update 1 row UPDATE sample_table SET colorid = 4 WHERE time > now_s() + '-1 month'; -- report 1 row SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------------------------------+------+---------+---------- Tue Aug 22 09:18:22 2017 PDT | 34.1 | 4 | {"c": 4} -- ensure that 1 chunk is partially compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 9 | _hyper_7_15_chunk DROP TABLE sample_table; -- test for NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 9 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, NULL, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_19_chunk _timescaledb_internal._hyper_9_20_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE device_id IS NULL; count ------- 4 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id IS NULL; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 9 | _hyper_9_19_chunk 9 | _hyper_9_20_chunk DROP TABLE sample_table; -- test for IS NOT NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 11 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, NULL, 1), (2, NULL, 1), (3, NULL, 1), (10, 3, 2), (11, 2, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_23_chunk _timescaledb_internal._hyper_11_24_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 0 -- UPDATE based on IS NOT NULL condition on SEGMENTBY column UPDATE sample_table SET val = 1234 WHERE device_id IS NOT NULL; -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 3 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_11_23_chunk 9 | _hyper_11_24_chunk DROP TABLE sample_table; -- test to for <= AND >= on SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 13 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); INSERT INTO sample_table VALUES (4, 3, NULL), (6, NULL, NULL), (12, NULL, NULL), (13, 4, NULL); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_27_chunk _timescaledb_internal._hyper_13_28_chunk -- test will multiple NULL/NOT NULL columns BEGIN; -- report 0 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- -- these 3 rows will be affected by below UPDATE SELECT * FROM sample_table WHERE device_id IS NULL AND val IS NOT NULL ORDER BY 1; time | device_id | val ------+-----------+----- 2 | | 1 10 | | 2 11 | | 2 -- update 3 rows UPDATE sample_table SET val = 987 WHERE device_id IS NULL AND val IS NOT NULL; -- report 3 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- 2 | | 987 10 | | 987 11 | | 987 ROLLBACK; -- test will multiple columns BEGIN; -- report 2 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- 10 | | 2 11 | | 2 -- delete 2 rows DELETE from sample_table WHERE device_id IS NULL AND val = 2; -- report 0 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- ROLLBACK; BEGIN; -- report 1 row SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- 4 | 3 | -- delete 1 rows DELETE from sample_table WHERE device_id = 3 AND val IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 5 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- get total count of SEGMENTBY column with device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM sample_table WHERE device_id >= 4 AND val <= 1; count ------- 1 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id >= 4 AND val <= 1; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_13_27_chunk 1 | _hyper_13_28_chunk -- added tests for code coverage UPDATE sample_table SET time = 21 WHERE (device_id) in ( 30, 51, 72, 53); UPDATE sample_table SET time = 21 WHERE device_id + 365 = 8765; DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table( time INT, device_id INT, val INT default 8, a INT default 10, b INT default 11, c INT default 12, d INT, e INT default 13); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 5); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 15 | public | sample_table | t INSERT INTO sample_table (time, device_id, d) VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); ALTER TABLE sample_table DROP COLUMN c; ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_31_chunk _timescaledb_internal._hyper_15_32_chunk ALTER TABLE sample_table ADD COLUMN c int default 23; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get FIRST uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- ensure segment by column index position in compressed and uncompressed -- chunk is different SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_1'::regclass, :'UNCOMPRESS_CHUNK_1'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_2'::regclass, :'UNCOMPRESS_CHUNK_2'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 1 -- get total count of SEGMENTBY column with d = 3 SELECT COUNT(*) FROM sample_table WHERE d = 3; count ------- 1 -- delete based on SEGMENTBY column DELETE FROM sample_table WHERE d = 3; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 BEGIN; -- report 0 row SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+---+---+---+---+--- -- delete 1 row UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- ensure rows are visible SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+-----+----+---+----+---- 2 | | 8 | 247 | 11 | 1 | 13 | 23 11 | | 8 | 247 | 11 | 2 | 13 | 23 10 | | 8 | 247 | 11 | 2 | 13 | 23 ROLLBACK; -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 0 -- UPDATE based on NULL values in SEGMENTBY column UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- report 3 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 3 -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table(time timestamptz, c1 text, c2 text, c3 text); SELECT create_hypertable('sample_table','time'); create_hypertable ---------------------------- (17,public,sample_table,t) INSERT INTO sample_table SELECT '2000-01-01'; ALTER TABLE sample_table DROP column c3; ALTER TABLE sample_table ADD column c4 text; INSERT INTO sample_table SELECT '2000-01-01', '1', '2', '3'; ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_35_chunk BEGIN; -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id \gset -- report 2 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 -- report 1 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 1 -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- -- report 1 row which ensure that only required row is moved and deleted SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 -- report 0 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 0 DROP TABLE sample_table; -- test filtering with ORDER BY columns CREATE TABLE sample_table(time timestamptz, c1 int, c2 int, c3 int, c4 int); SELECT create_hypertable('sample_table','time',chunk_time_interval=>'1 day'::interval); create_hypertable ---------------------------- (19,public,sample_table,t) ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4', timescaledb.compress_orderby='c1,c2,time'); INSERT INTO sample_table SELECT t, c1, c2, c3, c4 FROM generate_series(:'start_date'::timestamptz - INTERVAL '9 hours', :'start_date'::timestamptz, INTERVAL '1 hour') t, generate_series(0,9,1) c1, generate_series(0,9,1) c2, generate_series(0,9,1) c3, generate_series(0,9,1) c4; SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_37_chunk -- get FIRST chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- check that you uncompress and delete only for exact SEGMENTBY value SET timescaledb.debug_compression_path_info TO true; BEGIN; -- report 10 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 10 -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5; count ------- 10000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 \gset -- delete 10k rows DELETE FROM sample_table WHERE c4 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 < 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 < 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 < 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 < 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater and equal than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 >= 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 >= 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 >= 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 >= 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for exact ORDERBY value -- this will uncompress segments which have min <= value and max >= value BEGIN; -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c2 = 3; count ------- 10000 -- report 100 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 100 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c2 = 3 \gset -- delete 10k rows DELETE FROM sample_table WHERE c2 = 3; INFO: Number of compressed rows fetched from table scan: 100. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c2 = 3; count ------- 0 -- report 90k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 90000 -- report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less then ORDERBY value -- this will uncompress segments which have min < value BEGIN; -- report 20k rows SELECT COUNT(*) FROM sample_table WHERE c1 < 2; count ------- 20000 -- report 20 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 20 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 < 2 \gset -- delete 20k rows DELETE FROM sample_table WHERE c1 < 2; INFO: Number of compressed rows fetched from table scan: 20. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 < 2; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater or equal then ORDERBY value -- this will uncompress segments which have max >= value BEGIN; -- report 30k rows SELECT COUNT(*) FROM sample_table WHERE c1 >= 7; count ------- 30000 -- report 30 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 30 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 >= 7 \gset -- delete 30k rows DELETE FROM sample_table WHERE c1 >= 7; INFO: Number of compressed rows fetched from table scan: 30. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 >= 7; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments only contain one distinct value for -- these qualifiers, everything should be deleted that was decompressed BEGIN; -- report 1k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 1000 -- report 1 row in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 1 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 and c1 = 5 \gset -- delete 1k rows DELETE FROM sample_table WHERE c4 = 5 and c1 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 9. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments contain more than one distinct value for -- these qualifiers, not everything should be deleted that was decompressed BEGIN; -- report 4k rows SELECT COUNT(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 4000 -- report 40 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 40 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 > 5 and c2 = 5 \gset -- delete 4k rows DELETE FROM sample_table WHERE c4 > 5 and c2 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 40. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 0 -- report 36k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 36000 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers. -- no: of rows satisfying SEGMENTBY qualifiers is 10 -- no: of rows satisfying ORDERBY qualifiers is 3 -- Once both qualifiers are applied ensure that only 7 rows are present in -- compressed chunk BEGIN; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 10 compressed rows for given condition c4 = 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 10 -- report 3 compressed rows for given condition c4 = 4 and c1 >= 7 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7; count ------- 3 SELECT COUNT(*) AS "total_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 \gset SELECT COUNT(*) AS "total_affected_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7 \gset UPDATE sample_table SET c3 = c3 + 0 WHERE c4 = 4 AND c1 >= 7; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 7. -- report 7 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 7 -- ensure correct number of rows are moved from compressed chunk -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; ?column? ---------- t ROLLBACK; RESET timescaledb.debug_compression_path_info; --github issue: 5640 CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab1(time); CREATE INDEX ON tab1(device_id,time); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable -------------------- (21,public,tab1,t) ALTER TABLE tab1 DROP COLUMN filler_1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','57m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_2; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','58m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_3; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','59m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab1; -- compress chunks ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_21_39_chunk _timescaledb_internal._hyper_21_40_chunk _timescaledb_internal._hyper_21_41_chunk -- ensure there is an index scan generated for below DELETE query BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; EXPLAIN (buffers off, costs off) DELETE FROM public.tab1 WHERE public.tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Index Scan using _hyper_21_39_chunk_tab1_device_id_time_idx on _hyper_21_39_chunk tab1_1 Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- github issue 5658 -- verify that bitmap heap scans work on all the correct data and -- none of it left over after the dml command BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) DELETE FROM tab1 WHERE tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_21_39_chunk_tab1_device_id_time_idx Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- verify we can work with expression indexes and toastable types -- when the subquery returns a zero result set we used to end up -- trying to detoast a 0 value and segfaulting BEGIN; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX test ON tab1(repeat('t', device_id)); CREATE TABLE join_table AS SELECT repeat('t', d) FROM generate_series(1,3,1) d; ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on tab1 Update on _hyper_21_39_chunk tab1_1 Update on _hyper_21_40_chunk tab1_2 Update on _hyper_21_41_chunk tab1_3 -> Nested Loop -> Subquery Scan on devices -> HashAggregate Group Key: repeat -> Result One-Time Filter: false -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (repeat('t'::text, device_id) = devices.repeat) -> Bitmap Index Scan on _hyper_21_39_chunk_test Index Cond: (repeat('t'::text, device_id) = devices.repeat) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (devices.repeat = repeat('t'::text, device_id)) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (devices.repeat = repeat('t'::text, device_id)) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; ROLLBACK; -- create hypertable with space partitioning and compression CREATE TABLE tab2(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab2(time); CREATE INDEX ON tab2(device_id,time); SELECT create_hypertable('tab2','time','device_id',3,create_default_indexes:=false); create_hypertable -------------------- (23,public,tab2,t) ALTER TABLE tab2 DROP COLUMN filler_1; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','35m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_2; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','45m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_3; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','55m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab2; -- compress chunks ALTER TABLE tab2 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_23_45_chunk _timescaledb_internal._hyper_23_46_chunk _timescaledb_internal._hyper_23_47_chunk -- below test will cause chunks of tab2 to get decompressed -- without fix for issue #5460 SET timescaledb.enable_optimizations = OFF; BEGIN; DELETE FROM tab1 t1 USING tab2 t2 WHERE t1.device_id = t2.device_id AND t2.time > '2000-01-01'; ROLLBACK; --cleanup RESET timescaledb.enable_optimizations; DROP table tab1; DROP table tab2; -- test joins with UPDATE/DELETE on compression chunks CREATE TABLE join_test1(time timestamptz NOT NULL,device text, value float); CREATE TABLE join_test2(time timestamptz NOT NULL,device text, value float); CREATE VIEW chunk_status AS SELECT ht.table_name AS hypertable, ch.table_name AS chunk,ch.status from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id AND ht.table_name IN ('join_test1','join_test2') ORDER BY ht.id, ch.id; SELECT table_name FROM create_hypertable('join_test1', 'time'); table_name ------------ join_test1 SELECT table_name FROM create_hypertable('join_test2', 'time'); table_name ------------ join_test2 ALTER TABLE join_test1 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); ALTER TABLE join_test2 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO join_test1 VALUES ('2000-01-01','d1',0.1), ('2000-02-01','d1',0.1), ('2000-03-01','d1',0.1); INSERT INTO join_test2 VALUES ('2000-02-01','d1',0.1), ('2000-02-01','d2',0.1), ('2000-02-01','d3',0.1); SELECT compress_chunk(show_chunks('join_test1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_25_51_chunk _timescaledb_internal._hyper_25_52_chunk _timescaledb_internal._hyper_25_53_chunk SELECT compress_chunk(show_chunks('join_test2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_26_54_chunk SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 BEGIN; DELETE FROM join_test1 USING join_test2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test2 USING join_test1; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status change SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test2 t2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test2 t1 SET value = t1.value + 1 FROM join_test1 t2; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; DROP TABLE join_test1; DROP TABLE join_test2; -- test if index scan qualifiers are properly used CREATE TABLE index_scan_test(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('index_scan_test','time',create_default_indexes:=false); create_hypertable ------------------------------- (29,public,index_scan_test,t) INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-01 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- compress chunks ALTER TABLE index_scan_test SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('index_scan_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_59_chunk ANALYZE index_scan_test; SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper%' ORDER BY ch1.id LIMIT 1 \gset SELECT ch2.schema_name|| '.' || ch2.table_name AS "COMP_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.compressed_chunk_id = ch2.id ORDER BY ch2.id LIMIT 1 \gset INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- test index on single column BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) DELETE FROM index_scan_test WHERE device_id = 2; -- everything should be deleted SELECT count(*) FROM index_scan_test where device_id = 2; count ------- 0 -- there shouldn't be anything in the uncompressed chunk where device_id = 2 SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk from device_id = 2 SELECT count(*) FROM :COMP_CHUNK_1 where device_id = 2; count ------- 0 ROLLBACK; -- test multi column index BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id, time); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_time_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: ((index_scan_test_1.device_id = 2) AND (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone)) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test index with filter condition BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) Filter: (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled UPDATE sample_table SET c3 = NULL WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 -- make sure reseting the GUC we will be able to UPDATE/DELETE compressed chunks RESET timescaledb.enable_dml_decompression; SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE c4 = 5; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 10000 ROLLBACK; BEGIN; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 10000 DELETE FROM sample_table WHERE c4 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 ROLLBACK; -- create new uncompressed chunk INSERT INTO sample_table SELECT t, 1, 1, 1, 1 FROM generate_series('2023-05-04 00:00:00-00'::timestamptz, '2023-05-04 00:00:00-00'::timestamptz + INTERVAL '2 hours', INTERVAL '1 hour') t; -- check chunk compression status SELECT chunk_name, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_name | is_compressed --------------------+--------------- _hyper_19_37_chunk | t _hyper_19_61_chunk | f -- test for uncompressed and compressed chunks SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; BEGIN; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 3 -- delete from uncompressed chunk should work DELETE FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 0 ROLLBACK; BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 3 ROLLBACK; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled -- and both statements we're touching compressed and uncompressed chunks UPDATE sample_table SET c3 = NULL WHERE time >= '2023-03-17 00:00:00-00'::timestamptz AND c3 IS NULL; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE time >= '2023-03-17 00:00:00-00'::timestamptz; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 --github issue: 5586 --testcase with multiple indexes \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test5586; \c test5586 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable ------------------- (1,public,tab1,t) INSERT INTO tab1(filler_1, filler_2, filler_3,time,device_id,v0,v1,v2,v3) SELECT device_id, device_id+1, device_id + 2, time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id, filler_1, filler_2, filler_3'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 \gset -- create multiple indexes on compressed hypertable DROP INDEX _timescaledb_internal.compress_hyper_2_2_chunk_device_id_filler_1_filler_2_filler_idx; CREATE INDEX ON :CHUNK (_ts_meta_min_1); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_count); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_max_1, filler_1); CREATE INDEX filler_1 ON :CHUNK (filler_1); CREATE INDEX filler_2 ON :CHUNK (filler_2); CREATE INDEX filler_3 ON :CHUNK (filler_3); -- below indexes should be selected CREATE INDEX filler_1_filler_2 ON :CHUNK (filler_1, filler_2); CREATE INDEX filler_2_filler_3 ON :CHUNK (filler_2, filler_3); set timescaledb.debug_compression_path_info to on; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_3 = 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_3 = 5 AND filler_2 = 4; INFO: Index "filler_2_filler_3" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5 AND filler_2 = 4; INFO: Index "filler_1_filler_2" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; -- idealy filler_1 index should be selected, -- instead first matching index is selected BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5; count ------- 14392 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5; INFO: Index "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_fill_idx" is used for scan. INFO: Number of compressed rows fetched from index: 16. Number of compressed rows filtered by heap filters: 0. ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE tab1; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test5586 WITH (FORCE); --issue: #6024 CREATE TABLE t(a integer, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); create_hypertable ------------------- (31,public,t,t) INSERT INTO t values(1, 2); ALTER TABLE t SET (timescaledb.compress); SELECT compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_31_62_chunk -- should not crash UPDATE t SET b = 2 WHERE tableoid = 0; UPDATE t SET b = 2 WHERE tableoid is null; DROP TABLE t; -- github issue: 6367 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test6367; \c test6367 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE t6367 ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar, data jsonb ); SELECT table_name FROM create_hypertable('t6367', 'time'); table_name ------------ t6367 ALTER TABLE t6367 SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO t6367 SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT compress_chunk(c) FROM show_chunks('t6367') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK1" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 \gset SELECT format('%I.%I', schema_name, table_name) AS "CHUNK2" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 OFFSET 1 \gset DROP INDEX _timescaledb_internal.compress_hyper_2_3_chunk_source_id_label__ts_meta_min_1__ts_idx; DROP INDEX _timescaledb_internal.compress_hyper_2_4_chunk_source_id_label__ts_meta_min_1__ts_idx; -- testcase with no index, should use seq scan set timescaledb.debug_compression_path_info to on; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test case with an index which has only one -- of the segmentby filters CREATE INDEX source_id_idx1 ON :CHUNK1 (source_id); CREATE INDEX source_id_idx2 ON :CHUNK2 (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test that we are filtering NULL checks BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 ROLLBACK; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 30 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NOT NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_idx1; DROP INDEX _timescaledb_internal.source_id_idx2; -- test case with an index which has multiple same column CREATE INDEX source_id_source_id_idx ON :CHUNK1 (source_id, source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_source_id_idx" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_source_id_idx; -- test using a non-btree index -- fallback to heap scan CREATE INDEX brin_source_id_idx ON :CHUNK1 USING brin (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.brin_source_id_idx; -- test using an expression index -- should fallback to heap scans CREATE INDEX expr_source_id_idx ON :CHUNK1 (upper(source_id)); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.expr_source_id_idx; -- test using a partial index -- should fallback to heap scans CREATE INDEX partial_source_id_idx ON :CHUNK1 (source_id) WHERE _ts_meta_min_1 > '1990-01-01'::timestamptz; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE t6367; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test6367 WITH (FORCE); -- Text limitting decompressed tuple during an UPDATE or DELETE CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>10000); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 33 | public | test_limit | t INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp' ); SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; count ------- 2 SET timescaledb.max_tuples_decompressed_per_dml_transaction = 5000; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Updating or deleting everything will break the set limit. UPDATE test_limit SET id = 0; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). DELETE FROM test_limit WHERE id = 1; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; UPDATE test_limit SET id = 0; DELETE FROM test_limit WHERE id = 1; \set ON_ERROR_STOP 1 DROP TABLE test_limit; -- check partial compression with DML CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); create_hypertable ----------------------------- (35,public,test_partials,t) INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 -- check that DML causes transparent decompression and that -- data gets shifted to the uncompressed parts EXPLAIN (buffers off, costs off) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on test_partials Delete on _hyper_35_68_chunk test_partials_1 Delete on _hyper_35_69_chunk test_partials_2 Delete on _hyper_35_70_chunk test_partials_3 -> Custom Scan (ChunkAppend) on test_partials -> Seq Scan on _hyper_35_68_chunk test_partials_1 Filter: (SubPlan 1) SubPlan 1 -> Materialize -> Append -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Seq Scan on compress_hyper_36_71_chunk -> Seq Scan on _hyper_35_68_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Seq Scan on compress_hyper_36_72_chunk -> Seq Scan on _hyper_35_69_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Seq Scan on compress_hyper_36_73_chunk -> Seq Scan on _hyper_35_70_chunk -> Seq Scan on _hyper_35_69_chunk test_partials_2 Filter: (SubPlan 1) -> Seq Scan on _hyper_35_70_chunk test_partials_3 Filter: (SubPlan 1) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); VACUUM ANALYZE test_partials; -- All 3 chunks will now become partially compressed chunks EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Index Scan Backward using _hyper_35_68_chunk_test_partials_time_idx on _hyper_35_68_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Index Scan Backward using _hyper_35_69_chunk_test_partials_time_idx on _hyper_35_69_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -> Index Scan Backward using _hyper_35_70_chunk_test_partials_time_idx on _hyper_35_70_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk DROP TABLE test_partials; CREATE TABLE test_meta_filters(time timestamptz NOT NULL, device text, metric text, v1 float, v2 float); CREATE INDEX ON test_meta_filters(device, metric, v1); SELECT create_hypertable('test_meta_filters', 'time'); create_hypertable --------------------------------- (37,public,test_meta_filters,t) ALTER TABLE test_meta_filters SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='metric,time'); INSERT INTO test_meta_filters SELECT '2020-01-01'::timestamptz,'d1','m' || metric::text,v1,v2 FROM generate_series(1,3,1) metric, generate_series(1,1000,1) v1, generate_series(1,10,1) v2 ORDER BY 1,2,3,4,5; SELECT compress_chunk(show_chunks('test_meta_filters')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_37_74_chunk EXPLAIN (analyze, timing off, buffers off, costs off, summary off) DELETE FROM test_meta_filters WHERE device = 'd1' AND metric = 'm1' AND v1 < 100; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on test_meta_filters (actual rows=0.00 loops=1) Delete on _hyper_37_74_chunk test_meta_filters_1 -> Seq Scan on _hyper_37_74_chunk test_meta_filters_1 (actual rows=990.00 loops=1) Filter: ((v1 < '100'::double precision) AND (device = 'd1'::text) AND (metric = 'm1'::text)) Rows Removed by Filter: 10 -- test expression pushdown in compressed dml constraints CREATE TABLE test_pushdown(time timestamptz NOT NULL, device text); SELECT table_name FROM create_hypertable('test_pushdown', 'time'); table_name --------------- test_pushdown INSERT INTO test_pushdown SELECT '2020-01-01', 'a'; INSERT INTO test_pushdown SELECT '2020-01-01', 'b'; INSERT INTO test_pushdown SELECT '2020-01-01 05:00', 'c'; CREATE TABLE devices(device text); INSERT INTO devices VALUES ('a'), ('b'), ('c'); CREATE TABLE devices2(device text); INSERT INTO devices2 VALUES ('d'), ('e'), ('f'); CREATE TABLE devices3(device text); INSERT INTO devices3 VALUES ('b'), ('d'), ('g'); ALTER TABLE test_pushdown SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(show_chunks('test_pushdown')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_39_76_chunk -- 3 batch decompressions means pushdown is not working so we expect less than 3 for all these queries SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'a' = device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('a'::text = device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device < 'c' ; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: (device < 'c'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' > device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('c'::text > device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' >= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ('c'::text >= device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device > 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device > 'b'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = CURRENT_USER; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = CURRENT_USER) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' < device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('b'::text < device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' <= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('b'::text <= device) RESET timescaledb.enable_compressed_direct_batch_delete; -- cant pushdown OR atm BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = 'a' OR device = 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ((device = 'a'::text) OR (device = 'b'::text)) Rows Removed by Filter: 1 -- test stable function BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time = timestamptz('2020-01-01 05:00'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" = 'Wed Jan 01 05:00:00 2020 PST'::timestamp with time zone) -- test sqlvaluefunction BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = substring(CURRENT_USER,length(CURRENT_USER)+1) || 'c'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ("substring"((CURRENT_USER)::text, (length((CURRENT_USER)::text) + 1)) || 'c'::text)) -- JOIN tests -- no filtering in decompression SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- can filter in decompression even before executing join SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- test prepared statement PREPARE q1(text) AS DELETE FROM test_pushdown WHERE device = $1; SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = 'a'::text) RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'a'::text) BEGIN; :EXPLAIN EXECUTE q1('not here'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'not here'::text) -- test arrayop pushdown less than 3 decompressions are expected for successful pushdown BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a','d'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = ANY('{a,d}'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',CURRENT_USER); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, (CURRENT_USER)::text])) -- arroyop pushdown only works for segmentby columns atm so 3 decompressions are expected for now BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time IN ('2020-01-01','2020-01-02'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ("time" = ANY ('{"Wed Jan 01 00:00:00 2020 PST","Thu Jan 02 00:00:00 2020 PST"}'::timestamp with time zone[])) Rows Removed by Filter: 1 -- no pushdown for volatile functions BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = current_query(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = current_query()) Rows Removed by Filter: 3 BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',current_query()); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, current_query()])) Rows Removed by Filter: 2 -- test DELETE optimization without predicates -- should delete 3 complete batches without decompression BEGIN; :EXPLAIN DELETE FROM test_pushdown; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) -- test DELETE optimization on non-segmentby columns -- this shows optimization can be applied if in-memory filtering is enabled \set QUIET off BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK SET timescaledb.enable_dml_decompression_tuple_filtering TO OFF; SET BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK RESET timescaledb.enable_dml_decompression_tuple_filtering; RESET \set QUIET on -- github issue #6858 -- check update triggers work correctly both on uncompressed and compressed chunks CREATE TABLE update_trigger_test ( "entity_id" "uuid" NOT NULL, "effective_date_time" timestamp with time zone NOT NULL, "measurement" numeric NOT NULL, "modified_at" timestamp with time zone DEFAULT "now"() NOT NULL ); SELECT create_hypertable('update_trigger_test', 'effective_date_time'); create_hypertable ----------------------------------- (41,public,update_trigger_test,t) CREATE OR REPLACE FUNCTION update_modified_at_test() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN NEW.modified_at = NOW(); RETURN NEW; END; $$; CREATE TRIGGER update_trigger_test__before_update_sync_modified_at BEFORE UPDATE ON update_trigger_test FOR EACH ROW EXECUTE PROCEDURE update_modified_at_test(); INSERT INTO update_trigger_test SELECT 'f2ca7073-1395-5770-8378-7d0339804580', '2024-04-16 04:50:00+02', 1100.00, '2024-04-23 11:56:38.494095+02' FROM generate_series(1,2500,1) c; VACUUM FULL update_trigger_test; BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- try with default compression ALTER TABLE update_trigger_test SET (timescaledb.compress); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- lets try with segmentby SELECT decompress_chunk(show_chunks('update_trigger_test')); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk ALTER TABLE update_trigger_test SET (timescaledb.compress, timescaledb.compress_segmentby='entity_id'); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- check reporting of affected rows is correct for direct batch delete CREATE TABLE delete_counter(time timestamptz NOT NULL, device text) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'a' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'b' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'c' from generate_series(1,123); ALTER TABLE delete_counter SET (timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('delete_counter') ch; count ------- 2 INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'd' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-03-01'::timestamptz, 'e' from generate_series(1,123); \set QUIET off BEGIN; :EXPLAIN DELETE FROM delete_counter; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Append (actual rows=246.00 loops=1) -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=123.00 loops=1) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) ROLLBACK BEGIN; DELETE FROM delete_counter; ROLLBACK; BEGIN DELETE 615 ROLLBACK BEGIN; :EXPLAIN DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 369 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Custom Scan (ChunkAppend) on delete_counter (actual rows=615.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) Filter: (random() < '1'::double precision) ROLLBACK BEGIN; DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN DELETE 615 ROLLBACK -- test invalidation with direct batch delete optimizations CREATE TABLE cagg_inval(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE INSERT INTO cagg_inval SELECT '2020-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 INSERT INTO cagg_inval SELECT '2021-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 SELECT count(compress_chunk(ch)) FROM show_chunks('cagg_inval') ch; count ------- 2 SET timescaledb.enable_compressed_direct_batch_delete TO on; SET -- delete without cagg should use optimization BEGIN; BEGIN EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=0.00 loops=1) ROLLBACK; ROLLBACK CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time) FROM cagg_inval GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW -- should not use direct batch delete EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=1.00 loops=1) -- should have invalidation entry SELECT * FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 45 | 1577865600000000 | 1609488000000000 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_update_delete-17.out�������������������������������0000664�0000000�0000000�00000351361�15100345067�0025651�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off, timing off, summary off, analyze)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | sample_table | t \set start_date '2022-01-28 01:09:53.583252+05:30' INSERT INTO sample_table SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date'::timestamptz - INTERVAL '1 months', :'start_date'::timestamptz - INTERVAL '1 week', INTERVAL '1 hour') AS g1(time), generate_series(1, 8, 1 ) AS g2(sensor_id) ORDER BY time; \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test rows visibility BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- update 4 rows UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 ROLLBACK; -- get count of affected rows SELECT count(*) FROM sample_table WHERE cpu = 21.98 AND temperature = 33.123; count ------- 4 -- do update UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the partial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- get count of affected rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- do delete DELETE FROM sample_table WHERE name = 'updated row'; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- test for IS NULL checks -- should not UPDATE any rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test for IS NOT NULL checks -- should UPDATE all rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NOT NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; count ------- 0 -- get total count of rows which satifies the condition SELECT COUNT(*) as "total_affected_rows" FROM sample_table WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30' \gset -- perform UPDATE with < and > comparison on SEGMENTBY column UPDATE sample_table SET name = 'updated row based on < OR > comparison' WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30'; -- check chunk compression status after UPDATE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- count should be same SELECT COUNT(*) = (:total_affected_rows) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; ?column? ---------- t DROP TABLE sample_table; -- test to ensure that only required rows from compressed chunks -- are extracted if SEGMENTBY column is used in WHERE condition CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 3 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 3 | 3 | 1 10 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 1 -- delete rows with device_id = 3 DELETE FROM sample_table WHERE device_id = 3; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- -- there should 2 rows matching the conditions coming from 2 chunks SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 1 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 1 -- update rows with device_id = 1 UPDATE sample_table SET val = 200 WHERE 1 = device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 0 -- there should be 2 rows SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 200 200 DROP TABLE sample_table; CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 5 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'time, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (1, 3, 2), (11, 4, 2), (1, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_9_chunk _timescaledb_internal._hyper_5_10_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 1 | 1 | 2 1 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where time = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- delete rows with time = 1 AND val = 2 EXPLAIN (buffers off, costs off, verbose) DELETE FROM sample_table WHERE time = 1 AND 2 = val; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.sample_table Delete on _timescaledb_internal._hyper_5_9_chunk sample_table_1 -> Seq Scan on _timescaledb_internal._hyper_5_9_chunk sample_table_1 Output: sample_table_1.tableoid, sample_table_1.ctid Filter: ((sample_table_1."time" = 1) AND (2 = sample_table_1.val)) -- should delete rows from 1 of the compressed chunks DELETE FROM sample_table WHERE time = 1 AND 2 = val; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks wheretime = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- DROP TABLE sample_table; -- Test chunk compile time startup exclusion CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE TABLE sample_table(time timestamptz NOT NULL, temp float, colorid integer, attr jsonb); SELECT create_hypertable('sample_table', 'time', chunk_time_interval => 2628000000000); create_hypertable --------------------------- (7,public,sample_table,t) -- create three chunks INSERT INTO sample_table VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_segmentby = 'time'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk -- ensure all chunks are compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 1 | _hyper_7_15_chunk -- report 0 rows SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------+------+---------+------ -- update 1 row UPDATE sample_table SET colorid = 4 WHERE time > now_s() + '-1 month'; -- report 1 row SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------------------------------+------+---------+---------- Tue Aug 22 09:18:22 2017 PDT | 34.1 | 4 | {"c": 4} -- ensure that 1 chunk is partially compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 9 | _hyper_7_15_chunk DROP TABLE sample_table; -- test for NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 9 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, NULL, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_19_chunk _timescaledb_internal._hyper_9_20_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE device_id IS NULL; count ------- 4 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id IS NULL; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 9 | _hyper_9_19_chunk 9 | _hyper_9_20_chunk DROP TABLE sample_table; -- test for IS NOT NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 11 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, NULL, 1), (2, NULL, 1), (3, NULL, 1), (10, 3, 2), (11, 2, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_23_chunk _timescaledb_internal._hyper_11_24_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 0 -- UPDATE based on IS NOT NULL condition on SEGMENTBY column UPDATE sample_table SET val = 1234 WHERE device_id IS NOT NULL; -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 3 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_11_23_chunk 9 | _hyper_11_24_chunk DROP TABLE sample_table; -- test to for <= AND >= on SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 13 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); INSERT INTO sample_table VALUES (4, 3, NULL), (6, NULL, NULL), (12, NULL, NULL), (13, 4, NULL); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_27_chunk _timescaledb_internal._hyper_13_28_chunk -- test will multiple NULL/NOT NULL columns BEGIN; -- report 0 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- -- these 3 rows will be affected by below UPDATE SELECT * FROM sample_table WHERE device_id IS NULL AND val IS NOT NULL ORDER BY 1; time | device_id | val ------+-----------+----- 2 | | 1 10 | | 2 11 | | 2 -- update 3 rows UPDATE sample_table SET val = 987 WHERE device_id IS NULL AND val IS NOT NULL; -- report 3 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- 2 | | 987 10 | | 987 11 | | 987 ROLLBACK; -- test will multiple columns BEGIN; -- report 2 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- 10 | | 2 11 | | 2 -- delete 2 rows DELETE from sample_table WHERE device_id IS NULL AND val = 2; -- report 0 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- ROLLBACK; BEGIN; -- report 1 row SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- 4 | 3 | -- delete 1 rows DELETE from sample_table WHERE device_id = 3 AND val IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 5 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- get total count of SEGMENTBY column with device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM sample_table WHERE device_id >= 4 AND val <= 1; count ------- 1 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id >= 4 AND val <= 1; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_13_27_chunk 1 | _hyper_13_28_chunk -- added tests for code coverage UPDATE sample_table SET time = 21 WHERE (device_id) in ( 30, 51, 72, 53); UPDATE sample_table SET time = 21 WHERE device_id + 365 = 8765; DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table( time INT, device_id INT, val INT default 8, a INT default 10, b INT default 11, c INT default 12, d INT, e INT default 13); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 5); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 15 | public | sample_table | t INSERT INTO sample_table (time, device_id, d) VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); ALTER TABLE sample_table DROP COLUMN c; ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_31_chunk _timescaledb_internal._hyper_15_32_chunk ALTER TABLE sample_table ADD COLUMN c int default 23; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get FIRST uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- ensure segment by column index position in compressed and uncompressed -- chunk is different SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_1'::regclass, :'UNCOMPRESS_CHUNK_1'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_2'::regclass, :'UNCOMPRESS_CHUNK_2'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 1 -- get total count of SEGMENTBY column with d = 3 SELECT COUNT(*) FROM sample_table WHERE d = 3; count ------- 1 -- delete based on SEGMENTBY column DELETE FROM sample_table WHERE d = 3; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 BEGIN; -- report 0 row SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+---+---+---+---+--- -- delete 1 row UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- ensure rows are visible SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+-----+----+---+----+---- 2 | | 8 | 247 | 11 | 1 | 13 | 23 11 | | 8 | 247 | 11 | 2 | 13 | 23 10 | | 8 | 247 | 11 | 2 | 13 | 23 ROLLBACK; -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 0 -- UPDATE based on NULL values in SEGMENTBY column UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- report 3 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 3 -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table(time timestamptz, c1 text, c2 text, c3 text); SELECT create_hypertable('sample_table','time'); create_hypertable ---------------------------- (17,public,sample_table,t) INSERT INTO sample_table SELECT '2000-01-01'; ALTER TABLE sample_table DROP column c3; ALTER TABLE sample_table ADD column c4 text; INSERT INTO sample_table SELECT '2000-01-01', '1', '2', '3'; ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_35_chunk BEGIN; -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id \gset -- report 2 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 -- report 1 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 1 -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- -- report 1 row which ensure that only required row is moved and deleted SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 -- report 0 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 0 DROP TABLE sample_table; -- test filtering with ORDER BY columns CREATE TABLE sample_table(time timestamptz, c1 int, c2 int, c3 int, c4 int); SELECT create_hypertable('sample_table','time',chunk_time_interval=>'1 day'::interval); create_hypertable ---------------------------- (19,public,sample_table,t) ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4', timescaledb.compress_orderby='c1,c2,time'); INSERT INTO sample_table SELECT t, c1, c2, c3, c4 FROM generate_series(:'start_date'::timestamptz - INTERVAL '9 hours', :'start_date'::timestamptz, INTERVAL '1 hour') t, generate_series(0,9,1) c1, generate_series(0,9,1) c2, generate_series(0,9,1) c3, generate_series(0,9,1) c4; SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_37_chunk -- get FIRST chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- check that you uncompress and delete only for exact SEGMENTBY value SET timescaledb.debug_compression_path_info TO true; BEGIN; -- report 10 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 10 -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5; count ------- 10000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 \gset -- delete 10k rows DELETE FROM sample_table WHERE c4 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 < 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 < 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 < 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 < 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater and equal than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 >= 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 >= 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 >= 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 >= 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for exact ORDERBY value -- this will uncompress segments which have min <= value and max >= value BEGIN; -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c2 = 3; count ------- 10000 -- report 100 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 100 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c2 = 3 \gset -- delete 10k rows DELETE FROM sample_table WHERE c2 = 3; INFO: Number of compressed rows fetched from table scan: 100. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c2 = 3; count ------- 0 -- report 90k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 90000 -- report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less then ORDERBY value -- this will uncompress segments which have min < value BEGIN; -- report 20k rows SELECT COUNT(*) FROM sample_table WHERE c1 < 2; count ------- 20000 -- report 20 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 20 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 < 2 \gset -- delete 20k rows DELETE FROM sample_table WHERE c1 < 2; INFO: Number of compressed rows fetched from table scan: 20. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 < 2; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater or equal then ORDERBY value -- this will uncompress segments which have max >= value BEGIN; -- report 30k rows SELECT COUNT(*) FROM sample_table WHERE c1 >= 7; count ------- 30000 -- report 30 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 30 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 >= 7 \gset -- delete 30k rows DELETE FROM sample_table WHERE c1 >= 7; INFO: Number of compressed rows fetched from table scan: 30. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 >= 7; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments only contain one distinct value for -- these qualifiers, everything should be deleted that was decompressed BEGIN; -- report 1k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 1000 -- report 1 row in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 1 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 and c1 = 5 \gset -- delete 1k rows DELETE FROM sample_table WHERE c4 = 5 and c1 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 9. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments contain more than one distinct value for -- these qualifiers, not everything should be deleted that was decompressed BEGIN; -- report 4k rows SELECT COUNT(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 4000 -- report 40 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 40 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 > 5 and c2 = 5 \gset -- delete 4k rows DELETE FROM sample_table WHERE c4 > 5 and c2 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 40. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 0 -- report 36k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 36000 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers. -- no: of rows satisfying SEGMENTBY qualifiers is 10 -- no: of rows satisfying ORDERBY qualifiers is 3 -- Once both qualifiers are applied ensure that only 7 rows are present in -- compressed chunk BEGIN; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 10 compressed rows for given condition c4 = 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 10 -- report 3 compressed rows for given condition c4 = 4 and c1 >= 7 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7; count ------- 3 SELECT COUNT(*) AS "total_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 \gset SELECT COUNT(*) AS "total_affected_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7 \gset UPDATE sample_table SET c3 = c3 + 0 WHERE c4 = 4 AND c1 >= 7; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 7. -- report 7 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 7 -- ensure correct number of rows are moved from compressed chunk -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; ?column? ---------- t ROLLBACK; RESET timescaledb.debug_compression_path_info; --github issue: 5640 CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab1(time); CREATE INDEX ON tab1(device_id,time); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable -------------------- (21,public,tab1,t) ALTER TABLE tab1 DROP COLUMN filler_1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','57m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_2; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','58m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_3; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','59m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab1; -- compress chunks ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_21_39_chunk _timescaledb_internal._hyper_21_40_chunk _timescaledb_internal._hyper_21_41_chunk -- ensure there is an index scan generated for below DELETE query BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; EXPLAIN (buffers off, costs off) DELETE FROM public.tab1 WHERE public.tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Index Scan using _hyper_21_39_chunk_tab1_device_id_time_idx on _hyper_21_39_chunk tab1_1 Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- github issue 5658 -- verify that bitmap heap scans work on all the correct data and -- none of it left over after the dml command BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) DELETE FROM tab1 WHERE tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_21_39_chunk_tab1_device_id_time_idx Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- verify we can work with expression indexes and toastable types -- when the subquery returns a zero result set we used to end up -- trying to detoast a 0 value and segfaulting BEGIN; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX test ON tab1(repeat('t', device_id)); CREATE TABLE join_table AS SELECT repeat('t', d) FROM generate_series(1,3,1) d; ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on tab1 Update on _hyper_21_39_chunk tab1_1 Update on _hyper_21_40_chunk tab1_2 Update on _hyper_21_41_chunk tab1_3 -> Nested Loop -> Subquery Scan on devices -> HashAggregate Group Key: repeat -> Result One-Time Filter: false -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (repeat('t'::text, device_id) = devices.repeat) -> Bitmap Index Scan on _hyper_21_39_chunk_test Index Cond: (repeat('t'::text, device_id) = devices.repeat) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (devices.repeat = repeat('t'::text, device_id)) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (devices.repeat = repeat('t'::text, device_id)) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; ROLLBACK; -- create hypertable with space partitioning and compression CREATE TABLE tab2(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab2(time); CREATE INDEX ON tab2(device_id,time); SELECT create_hypertable('tab2','time','device_id',3,create_default_indexes:=false); create_hypertable -------------------- (23,public,tab2,t) ALTER TABLE tab2 DROP COLUMN filler_1; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','35m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_2; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','45m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_3; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','55m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab2; -- compress chunks ALTER TABLE tab2 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_23_45_chunk _timescaledb_internal._hyper_23_46_chunk _timescaledb_internal._hyper_23_47_chunk -- below test will cause chunks of tab2 to get decompressed -- without fix for issue #5460 SET timescaledb.enable_optimizations = OFF; BEGIN; DELETE FROM tab1 t1 USING tab2 t2 WHERE t1.device_id = t2.device_id AND t2.time > '2000-01-01'; ROLLBACK; --cleanup RESET timescaledb.enable_optimizations; DROP table tab1; DROP table tab2; -- test joins with UPDATE/DELETE on compression chunks CREATE TABLE join_test1(time timestamptz NOT NULL,device text, value float); CREATE TABLE join_test2(time timestamptz NOT NULL,device text, value float); CREATE VIEW chunk_status AS SELECT ht.table_name AS hypertable, ch.table_name AS chunk,ch.status from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id AND ht.table_name IN ('join_test1','join_test2') ORDER BY ht.id, ch.id; SELECT table_name FROM create_hypertable('join_test1', 'time'); table_name ------------ join_test1 SELECT table_name FROM create_hypertable('join_test2', 'time'); table_name ------------ join_test2 ALTER TABLE join_test1 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); ALTER TABLE join_test2 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO join_test1 VALUES ('2000-01-01','d1',0.1), ('2000-02-01','d1',0.1), ('2000-03-01','d1',0.1); INSERT INTO join_test2 VALUES ('2000-02-01','d1',0.1), ('2000-02-01','d2',0.1), ('2000-02-01','d3',0.1); SELECT compress_chunk(show_chunks('join_test1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_25_51_chunk _timescaledb_internal._hyper_25_52_chunk _timescaledb_internal._hyper_25_53_chunk SELECT compress_chunk(show_chunks('join_test2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_26_54_chunk SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 BEGIN; DELETE FROM join_test1 USING join_test2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test2 USING join_test1; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status change SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test2 t2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test2 t1 SET value = t1.value + 1 FROM join_test1 t2; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; DROP TABLE join_test1; DROP TABLE join_test2; -- test if index scan qualifiers are properly used CREATE TABLE index_scan_test(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('index_scan_test','time',create_default_indexes:=false); create_hypertable ------------------------------- (29,public,index_scan_test,t) INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-01 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- compress chunks ALTER TABLE index_scan_test SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('index_scan_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_59_chunk ANALYZE index_scan_test; SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper%' ORDER BY ch1.id LIMIT 1 \gset SELECT ch2.schema_name|| '.' || ch2.table_name AS "COMP_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.compressed_chunk_id = ch2.id ORDER BY ch2.id LIMIT 1 \gset INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- test index on single column BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) DELETE FROM index_scan_test WHERE device_id = 2; -- everything should be deleted SELECT count(*) FROM index_scan_test where device_id = 2; count ------- 0 -- there shouldn't be anything in the uncompressed chunk where device_id = 2 SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk from device_id = 2 SELECT count(*) FROM :COMP_CHUNK_1 where device_id = 2; count ------- 0 ROLLBACK; -- test multi column index BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id, time); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_time_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: ((index_scan_test_1.device_id = 2) AND (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone)) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test index with filter condition BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) Filter: (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled UPDATE sample_table SET c3 = NULL WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 -- make sure reseting the GUC we will be able to UPDATE/DELETE compressed chunks RESET timescaledb.enable_dml_decompression; SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE c4 = 5; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 10000 ROLLBACK; BEGIN; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 10000 DELETE FROM sample_table WHERE c4 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 ROLLBACK; -- create new uncompressed chunk INSERT INTO sample_table SELECT t, 1, 1, 1, 1 FROM generate_series('2023-05-04 00:00:00-00'::timestamptz, '2023-05-04 00:00:00-00'::timestamptz + INTERVAL '2 hours', INTERVAL '1 hour') t; -- check chunk compression status SELECT chunk_name, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_name | is_compressed --------------------+--------------- _hyper_19_37_chunk | t _hyper_19_61_chunk | f -- test for uncompressed and compressed chunks SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; BEGIN; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 3 -- delete from uncompressed chunk should work DELETE FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 0 ROLLBACK; BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 3 ROLLBACK; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled -- and both statements we're touching compressed and uncompressed chunks UPDATE sample_table SET c3 = NULL WHERE time >= '2023-03-17 00:00:00-00'::timestamptz AND c3 IS NULL; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE time >= '2023-03-17 00:00:00-00'::timestamptz; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 --github issue: 5586 --testcase with multiple indexes \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test5586; \c test5586 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable ------------------- (1,public,tab1,t) INSERT INTO tab1(filler_1, filler_2, filler_3,time,device_id,v0,v1,v2,v3) SELECT device_id, device_id+1, device_id + 2, time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id, filler_1, filler_2, filler_3'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 \gset -- create multiple indexes on compressed hypertable DROP INDEX _timescaledb_internal.compress_hyper_2_2_chunk_device_id_filler_1_filler_2_filler_idx; CREATE INDEX ON :CHUNK (_ts_meta_min_1); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_count); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_max_1, filler_1); CREATE INDEX filler_1 ON :CHUNK (filler_1); CREATE INDEX filler_2 ON :CHUNK (filler_2); CREATE INDEX filler_3 ON :CHUNK (filler_3); -- below indexes should be selected CREATE INDEX filler_1_filler_2 ON :CHUNK (filler_1, filler_2); CREATE INDEX filler_2_filler_3 ON :CHUNK (filler_2, filler_3); set timescaledb.debug_compression_path_info to on; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_3 = 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_3 = 5 AND filler_2 = 4; INFO: Index "filler_2_filler_3" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5 AND filler_2 = 4; INFO: Index "filler_1_filler_2" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; -- idealy filler_1 index should be selected, -- instead first matching index is selected BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5; count ------- 14392 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5; INFO: Index "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_fill_idx" is used for scan. INFO: Number of compressed rows fetched from index: 16. Number of compressed rows filtered by heap filters: 0. ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE tab1; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test5586 WITH (FORCE); --issue: #6024 CREATE TABLE t(a integer, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); create_hypertable ------------------- (31,public,t,t) INSERT INTO t values(1, 2); ALTER TABLE t SET (timescaledb.compress); SELECT compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_31_62_chunk -- should not crash UPDATE t SET b = 2 WHERE tableoid = 0; UPDATE t SET b = 2 WHERE tableoid is null; DROP TABLE t; -- github issue: 6367 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test6367; \c test6367 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE t6367 ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar, data jsonb ); SELECT table_name FROM create_hypertable('t6367', 'time'); table_name ------------ t6367 ALTER TABLE t6367 SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO t6367 SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT compress_chunk(c) FROM show_chunks('t6367') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK1" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 \gset SELECT format('%I.%I', schema_name, table_name) AS "CHUNK2" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 OFFSET 1 \gset DROP INDEX _timescaledb_internal.compress_hyper_2_3_chunk_source_id_label__ts_meta_min_1__ts_idx; DROP INDEX _timescaledb_internal.compress_hyper_2_4_chunk_source_id_label__ts_meta_min_1__ts_idx; -- testcase with no index, should use seq scan set timescaledb.debug_compression_path_info to on; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test case with an index which has only one -- of the segmentby filters CREATE INDEX source_id_idx1 ON :CHUNK1 (source_id); CREATE INDEX source_id_idx2 ON :CHUNK2 (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test that we are filtering NULL checks BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 ROLLBACK; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 30 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NOT NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_idx1; DROP INDEX _timescaledb_internal.source_id_idx2; -- test case with an index which has multiple same column CREATE INDEX source_id_source_id_idx ON :CHUNK1 (source_id, source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_source_id_idx" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_source_id_idx; -- test using a non-btree index -- fallback to heap scan CREATE INDEX brin_source_id_idx ON :CHUNK1 USING brin (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.brin_source_id_idx; -- test using an expression index -- should fallback to heap scans CREATE INDEX expr_source_id_idx ON :CHUNK1 (upper(source_id)); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.expr_source_id_idx; -- test using a partial index -- should fallback to heap scans CREATE INDEX partial_source_id_idx ON :CHUNK1 (source_id) WHERE _ts_meta_min_1 > '1990-01-01'::timestamptz; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE t6367; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test6367 WITH (FORCE); -- Text limitting decompressed tuple during an UPDATE or DELETE CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>10000); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 33 | public | test_limit | t INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp' ); SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; count ------- 2 SET timescaledb.max_tuples_decompressed_per_dml_transaction = 5000; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Updating or deleting everything will break the set limit. UPDATE test_limit SET id = 0; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). DELETE FROM test_limit WHERE id = 1; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; UPDATE test_limit SET id = 0; DELETE FROM test_limit WHERE id = 1; \set ON_ERROR_STOP 1 DROP TABLE test_limit; -- check partial compression with DML CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); create_hypertable ----------------------------- (35,public,test_partials,t) INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 -- check that DML causes transparent decompression and that -- data gets shifted to the uncompressed parts EXPLAIN (buffers off, costs off) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on test_partials Delete on _hyper_35_68_chunk test_partials_1 Delete on _hyper_35_69_chunk test_partials_2 Delete on _hyper_35_70_chunk test_partials_3 -> Custom Scan (ChunkAppend) on test_partials -> Seq Scan on _hyper_35_68_chunk test_partials_1 Filter: (ALL ("time" >= (SubPlan 1).col1)) SubPlan 1 -> Materialize -> Append -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Seq Scan on compress_hyper_36_71_chunk -> Seq Scan on _hyper_35_68_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Seq Scan on compress_hyper_36_72_chunk -> Seq Scan on _hyper_35_69_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Seq Scan on compress_hyper_36_73_chunk -> Seq Scan on _hyper_35_70_chunk -> Seq Scan on _hyper_35_69_chunk test_partials_2 Filter: (ALL ("time" >= (SubPlan 1).col1)) -> Seq Scan on _hyper_35_70_chunk test_partials_3 Filter: (ALL ("time" >= (SubPlan 1).col1)) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); VACUUM ANALYZE test_partials; -- All 3 chunks will now become partially compressed chunks EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Index Scan Backward using _hyper_35_68_chunk_test_partials_time_idx on _hyper_35_68_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Index Scan Backward using _hyper_35_69_chunk_test_partials_time_idx on _hyper_35_69_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -> Index Scan Backward using _hyper_35_70_chunk_test_partials_time_idx on _hyper_35_70_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk DROP TABLE test_partials; CREATE TABLE test_meta_filters(time timestamptz NOT NULL, device text, metric text, v1 float, v2 float); CREATE INDEX ON test_meta_filters(device, metric, v1); SELECT create_hypertable('test_meta_filters', 'time'); create_hypertable --------------------------------- (37,public,test_meta_filters,t) ALTER TABLE test_meta_filters SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='metric,time'); INSERT INTO test_meta_filters SELECT '2020-01-01'::timestamptz,'d1','m' || metric::text,v1,v2 FROM generate_series(1,3,1) metric, generate_series(1,1000,1) v1, generate_series(1,10,1) v2 ORDER BY 1,2,3,4,5; SELECT compress_chunk(show_chunks('test_meta_filters')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_37_74_chunk EXPLAIN (analyze, timing off, buffers off, costs off, summary off) DELETE FROM test_meta_filters WHERE device = 'd1' AND metric = 'm1' AND v1 < 100; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on test_meta_filters (actual rows=0.00 loops=1) Delete on _hyper_37_74_chunk test_meta_filters_1 -> Seq Scan on _hyper_37_74_chunk test_meta_filters_1 (actual rows=990.00 loops=1) Filter: ((v1 < '100'::double precision) AND (device = 'd1'::text) AND (metric = 'm1'::text)) Rows Removed by Filter: 10 -- test expression pushdown in compressed dml constraints CREATE TABLE test_pushdown(time timestamptz NOT NULL, device text); SELECT table_name FROM create_hypertable('test_pushdown', 'time'); table_name --------------- test_pushdown INSERT INTO test_pushdown SELECT '2020-01-01', 'a'; INSERT INTO test_pushdown SELECT '2020-01-01', 'b'; INSERT INTO test_pushdown SELECT '2020-01-01 05:00', 'c'; CREATE TABLE devices(device text); INSERT INTO devices VALUES ('a'), ('b'), ('c'); CREATE TABLE devices2(device text); INSERT INTO devices2 VALUES ('d'), ('e'), ('f'); CREATE TABLE devices3(device text); INSERT INTO devices3 VALUES ('b'), ('d'), ('g'); ALTER TABLE test_pushdown SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(show_chunks('test_pushdown')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_39_76_chunk -- 3 batch decompressions means pushdown is not working so we expect less than 3 for all these queries SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'a' = device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('a'::text = device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device < 'c' ; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: (device < 'c'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' > device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('c'::text > device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' >= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ('c'::text >= device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device > 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device > 'b'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = CURRENT_USER; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = CURRENT_USER) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' < device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('b'::text < device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' <= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('b'::text <= device) RESET timescaledb.enable_compressed_direct_batch_delete; -- cant pushdown OR atm BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = 'a' OR device = 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ((device = 'a'::text) OR (device = 'b'::text)) Rows Removed by Filter: 1 -- test stable function BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time = timestamptz('2020-01-01 05:00'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" = 'Wed Jan 01 05:00:00 2020 PST'::timestamp with time zone) -- test sqlvaluefunction BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = substring(CURRENT_USER,length(CURRENT_USER)+1) || 'c'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ("substring"((CURRENT_USER)::text, (length((CURRENT_USER)::text) + 1)) || 'c'::text)) -- JOIN tests -- no filtering in decompression SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- can filter in decompression even before executing join SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- test prepared statement PREPARE q1(text) AS DELETE FROM test_pushdown WHERE device = $1; SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = 'a'::text) RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'a'::text) BEGIN; :EXPLAIN EXECUTE q1('not here'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'not here'::text) -- test arrayop pushdown less than 3 decompressions are expected for successful pushdown BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a','d'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = ANY('{a,d}'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',CURRENT_USER); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, (CURRENT_USER)::text])) -- arroyop pushdown only works for segmentby columns atm so 3 decompressions are expected for now BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time IN ('2020-01-01','2020-01-02'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ("time" = ANY ('{"Wed Jan 01 00:00:00 2020 PST","Thu Jan 02 00:00:00 2020 PST"}'::timestamp with time zone[])) Rows Removed by Filter: 1 -- no pushdown for volatile functions BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = current_query(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = current_query()) Rows Removed by Filter: 3 BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',current_query()); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, current_query()])) Rows Removed by Filter: 2 -- test DELETE optimization without predicates -- should delete 3 complete batches without decompression BEGIN; :EXPLAIN DELETE FROM test_pushdown; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) -- test DELETE optimization on non-segmentby columns -- this shows optimization can be applied if in-memory filtering is enabled \set QUIET off BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK SET timescaledb.enable_dml_decompression_tuple_filtering TO OFF; SET BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK RESET timescaledb.enable_dml_decompression_tuple_filtering; RESET \set QUIET on -- github issue #6858 -- check update triggers work correctly both on uncompressed and compressed chunks CREATE TABLE update_trigger_test ( "entity_id" "uuid" NOT NULL, "effective_date_time" timestamp with time zone NOT NULL, "measurement" numeric NOT NULL, "modified_at" timestamp with time zone DEFAULT "now"() NOT NULL ); SELECT create_hypertable('update_trigger_test', 'effective_date_time'); create_hypertable ----------------------------------- (41,public,update_trigger_test,t) CREATE OR REPLACE FUNCTION update_modified_at_test() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN NEW.modified_at = NOW(); RETURN NEW; END; $$; CREATE TRIGGER update_trigger_test__before_update_sync_modified_at BEFORE UPDATE ON update_trigger_test FOR EACH ROW EXECUTE PROCEDURE update_modified_at_test(); INSERT INTO update_trigger_test SELECT 'f2ca7073-1395-5770-8378-7d0339804580', '2024-04-16 04:50:00+02', 1100.00, '2024-04-23 11:56:38.494095+02' FROM generate_series(1,2500,1) c; VACUUM FULL update_trigger_test; BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- try with default compression ALTER TABLE update_trigger_test SET (timescaledb.compress); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- lets try with segmentby SELECT decompress_chunk(show_chunks('update_trigger_test')); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk ALTER TABLE update_trigger_test SET (timescaledb.compress, timescaledb.compress_segmentby='entity_id'); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- check reporting of affected rows is correct for direct batch delete CREATE TABLE delete_counter(time timestamptz NOT NULL, device text) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'a' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'b' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'c' from generate_series(1,123); ALTER TABLE delete_counter SET (timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('delete_counter') ch; count ------- 2 INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'd' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-03-01'::timestamptz, 'e' from generate_series(1,123); \set QUIET off BEGIN; :EXPLAIN DELETE FROM delete_counter; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Append (actual rows=246.00 loops=1) -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=123.00 loops=1) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) ROLLBACK BEGIN; DELETE FROM delete_counter; ROLLBACK; BEGIN DELETE 615 ROLLBACK BEGIN; :EXPLAIN DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 369 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Custom Scan (ChunkAppend) on delete_counter (actual rows=615.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) Filter: (random() < '1'::double precision) ROLLBACK BEGIN; DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN DELETE 615 ROLLBACK -- test invalidation with direct batch delete optimizations CREATE TABLE cagg_inval(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE INSERT INTO cagg_inval SELECT '2020-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 INSERT INTO cagg_inval SELECT '2021-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 SELECT count(compress_chunk(ch)) FROM show_chunks('cagg_inval') ch; count ------- 2 SET timescaledb.enable_compressed_direct_batch_delete TO on; SET -- delete without cagg should use optimization BEGIN; BEGIN EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=0.00 loops=1) ROLLBACK; ROLLBACK CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time) FROM cagg_inval GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW -- should not use direct batch delete EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=1.00 loops=1) -- should have invalidation entry SELECT * FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 45 | 1577865600000000 | 1609488000000000 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_update_delete-18.out�������������������������������0000664�0000000�0000000�00000351361�15100345067�0025652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off, timing off, summary off, analyze)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); WARNING: column type "character varying" used for "name" does not follow best practices hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 1 | public | sample_table | t \set start_date '2022-01-28 01:09:53.583252+05:30' INSERT INTO sample_table SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date'::timestamptz - INTERVAL '1 months', :'start_date'::timestamptz - INTERVAL '1 week', INTERVAL '1 hour') AS g1(time), generate_series(1, 8, 1 ) AS g2(sensor_id) ORDER BY time; \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test rows visibility BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- update 4 rows UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 ROLLBACK; -- get count of affected rows SELECT count(*) FROM sample_table WHERE cpu = 21.98 AND temperature = 33.123; count ------- 4 -- do update UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the partial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- get count of affected rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 4 -- do delete DELETE FROM sample_table WHERE name = 'updated row'; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; count ------- 0 -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- test for IS NULL checks -- should not UPDATE any rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- test for IS NOT NULL checks -- should UPDATE all rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NOT NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 9 | _hyper_1_2_chunk -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 1 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; count ------- 0 -- get total count of rows which satifies the condition SELECT COUNT(*) as "total_affected_rows" FROM sample_table WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30' \gset -- perform UPDATE with < and > comparison on SEGMENTBY column UPDATE sample_table SET name = 'updated row based on < OR > comparison' WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30'; -- check chunk compression status after UPDATE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------ 9 | _hyper_1_1_chunk 1 | _hyper_1_2_chunk -- count should be same SELECT COUNT(*) = (:total_affected_rows) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; ?column? ---------- t DROP TABLE sample_table; -- test to ensure that only required rows from compressed chunks -- are extracted if SEGMENTBY column is used in WHERE condition CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 3 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 3 | 3 | 1 10 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 1 -- delete rows with device_id = 3 DELETE FROM sample_table WHERE device_id = 3; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; time | device_id | val ------+-----------+----- -- there should 2 rows matching the conditions coming from 2 chunks SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 1 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 1 -- update rows with device_id = 1 UPDATE sample_table SET val = 200 WHERE 1 = device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; count ------- 0 -- there should be 2 rows SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; val ----- 200 200 DROP TABLE sample_table; CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 5 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'time, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (1, 3, 2), (11, 4, 2), (1, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_9_chunk _timescaledb_internal._hyper_5_10_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- 1 | 1 | 2 1 | 3 | 2 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where time = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- delete rows with time = 1 AND val = 2 EXPLAIN (buffers off, costs off, verbose) DELETE FROM sample_table WHERE time = 1 AND 2 = val; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.sample_table Delete on _timescaledb_internal._hyper_5_9_chunk sample_table_1 -> Seq Scan on _timescaledb_internal._hyper_5_9_chunk sample_table_1 Output: sample_table_1.tableoid, sample_table_1.ctid Filter: ((sample_table_1."time" = 1) AND (2 = sample_table_1.val)) -- should delete rows from 1 of the compressed chunks DELETE FROM sample_table WHERE time = 1 AND 2 = val; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks wheretime = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; count ------- 0 -- there should be no rows SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; time | device_id | val ------+-----------+----- DROP TABLE sample_table; -- Test chunk compile time startup exclusion CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE TABLE sample_table(time timestamptz NOT NULL, temp float, colorid integer, attr jsonb); SELECT create_hypertable('sample_table', 'time', chunk_time_interval => 2628000000000); create_hypertable --------------------------- (7,public,sample_table,t) -- create three chunks INSERT INTO sample_table VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_segmentby = 'time'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk -- ensure all chunks are compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 1 | _hyper_7_15_chunk -- report 0 rows SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------+------+---------+------ -- update 1 row UPDATE sample_table SET colorid = 4 WHERE time > now_s() + '-1 month'; -- report 1 row SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; time | temp | colorid | attr ------------------------------+------+---------+---------- Tue Aug 22 09:18:22 2017 PDT | 34.1 | 4 | {"c": 4} -- ensure that 1 chunk is partially compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 1 | _hyper_7_13_chunk 1 | _hyper_7_14_chunk 9 | _hyper_7_15_chunk DROP TABLE sample_table; -- test for NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 9 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, NULL, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_19_chunk _timescaledb_internal._hyper_9_20_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE device_id IS NULL; count ------- 4 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id IS NULL; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+------------------- 9 | _hyper_9_19_chunk 9 | _hyper_9_20_chunk DROP TABLE sample_table; -- test for IS NOT NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 11 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, NULL, 1), (2, NULL, 1), (3, NULL, 1), (10, 3, 2), (11, 2, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_23_chunk _timescaledb_internal._hyper_11_24_chunk -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 0 -- UPDATE based on IS NOT NULL condition on SEGMENTBY column UPDATE sample_table SET val = 1234 WHERE device_id IS NOT NULL; -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE val = 1234; count ------- 3 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_11_23_chunk 9 | _hyper_11_24_chunk DROP TABLE sample_table; -- test to for <= AND >= on SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 13 | public | sample_table | t ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); INSERT INTO sample_table VALUES (4, 3, NULL), (6, NULL, NULL), (12, NULL, NULL), (13, 4, NULL); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_13_27_chunk _timescaledb_internal._hyper_13_28_chunk -- test will multiple NULL/NOT NULL columns BEGIN; -- report 0 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- -- these 3 rows will be affected by below UPDATE SELECT * FROM sample_table WHERE device_id IS NULL AND val IS NOT NULL ORDER BY 1; time | device_id | val ------+-----------+----- 2 | | 1 10 | | 2 11 | | 2 -- update 3 rows UPDATE sample_table SET val = 987 WHERE device_id IS NULL AND val IS NOT NULL; -- report 3 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; time | device_id | val ------+-----------+----- 2 | | 987 10 | | 987 11 | | 987 ROLLBACK; -- test will multiple columns BEGIN; -- report 2 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- 10 | | 2 11 | | 2 -- delete 2 rows DELETE from sample_table WHERE device_id IS NULL AND val = 2; -- report 0 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; time | device_id | val ------+-----------+----- ROLLBACK; BEGIN; -- report 1 row SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- 4 | 3 | -- delete 1 rows DELETE from sample_table WHERE device_id = 3 AND val IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; time | device_id | val ------+-----------+----- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 5 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- get total count of SEGMENTBY column with device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM sample_table WHERE device_id >= 4 AND val <= 1; count ------- 1 -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id >= 4 AND val <= 1; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 5 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_13_27_chunk 1 | _hyper_13_28_chunk -- added tests for code coverage UPDATE sample_table SET time = 21 WHERE (device_id) in ( 30, 51, 72, 53); UPDATE sample_table SET time = 21 WHERE device_id + 365 = 8765; DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table( time INT, device_id INT, val INT default 8, a INT default 10, b INT default 11, c INT default 12, d INT, e INT default 13); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 5); hypertable_id | schema_name | table_name | created ---------------+-------------+--------------+--------- 15 | public | sample_table | t INSERT INTO sample_table (time, device_id, d) VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); ALTER TABLE sample_table DROP COLUMN c; ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_15_31_chunk _timescaledb_internal._hyper_15_32_chunk ALTER TABLE sample_table ADD COLUMN c int default 23; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get FIRST uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- ensure segment by column index position in compressed and uncompressed -- chunk is different SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_1'::regclass, :'UNCOMPRESS_CHUNK_1'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_2'::regclass, :'UNCOMPRESS_CHUNK_2'::regclass) AND attname = 'd' ORDER BY attnum; attname | attnum ---------+-------- d | 3 d | 7 -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 3 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 1 -- get total count of SEGMENTBY column with d = 3 SELECT COUNT(*) FROM sample_table WHERE d = 3; count ------- 1 -- delete based on SEGMENTBY column DELETE FROM sample_table WHERE d = 3; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 2 -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; count ------- 0 -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_status | CHUNK_NAME --------------+-------------------- 1 | _hyper_15_31_chunk 1 | _hyper_15_32_chunk -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 1 BEGIN; -- report 0 row SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+---+---+---+---+--- -- delete 1 row UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- ensure rows are visible SELECT * FROM sample_table WHERE a = 247; time | device_id | val | a | b | d | e | c ------+-----------+-----+-----+----+---+----+---- 2 | | 8 | 247 | 11 | 1 | 13 | 23 11 | | 8 | 247 | 11 | 2 | 13 | 23 10 | | 8 | 247 | 11 | 2 | 13 | 23 ROLLBACK; -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 0 -- UPDATE based on NULL values in SEGMENTBY column UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- report 3 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; count ------- 3 -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; count ------- 1 -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; count ------- 0 SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; count ------- 0 DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table(time timestamptz, c1 text, c2 text, c3 text); SELECT create_hypertable('sample_table','time'); create_hypertable ---------------------------- (17,public,sample_table,t) INSERT INTO sample_table SELECT '2000-01-01'; ALTER TABLE sample_table DROP column c3; ALTER TABLE sample_table ADD column c4 text; INSERT INTO sample_table SELECT '2000-01-01', '1', '2', '3'; ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4'); SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_17_35_chunk BEGIN; -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id \gset -- report 2 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 2 -- report 1 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 1 -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------------------------------+----+----+---- Sat Jan 01 00:00:00 2000 PST | | | -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 row SELECT * FROM sample_table WHERE c4 IS NULL; time | c1 | c2 | c4 ------+----+----+---- -- report 1 row which ensure that only required row is moved and deleted SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; count ------- 1 -- report 0 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; count ------- 0 DROP TABLE sample_table; -- test filtering with ORDER BY columns CREATE TABLE sample_table(time timestamptz, c1 int, c2 int, c3 int, c4 int); SELECT create_hypertable('sample_table','time',chunk_time_interval=>'1 day'::interval); create_hypertable ---------------------------- (19,public,sample_table,t) ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4', timescaledb.compress_orderby='c1,c2,time'); INSERT INTO sample_table SELECT t, c1, c2, c3, c4 FROM generate_series(:'start_date'::timestamptz - INTERVAL '9 hours', :'start_date'::timestamptz, INTERVAL '1 hour') t, generate_series(0,9,1) c1, generate_series(0,9,1) c2, generate_series(0,9,1) c3, generate_series(0,9,1) c4; SELECT compress_chunk(show_chunks('sample_table')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_19_37_chunk -- get FIRST chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- check that you uncompress and delete only for exact SEGMENTBY value SET timescaledb.debug_compression_path_info TO true; BEGIN; -- report 10 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 10 -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5; count ------- 10000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 \gset -- delete 10k rows DELETE FROM sample_table WHERE c4 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 < 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 < 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 < 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 < 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater and equal than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 50 -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 >= 5; count ------- 50000 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 >= 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 >= 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 50. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 >= 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for exact ORDERBY value -- this will uncompress segments which have min <= value and max >= value BEGIN; -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c2 = 3; count ------- 10000 -- report 100 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 100 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c2 = 3 \gset -- delete 10k rows DELETE FROM sample_table WHERE c2 = 3; INFO: Number of compressed rows fetched from table scan: 100. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c2 = 3; count ------- 0 -- report 90k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 90000 -- report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for less then ORDERBY value -- this will uncompress segments which have min < value BEGIN; -- report 20k rows SELECT COUNT(*) FROM sample_table WHERE c1 < 2; count ------- 20000 -- report 20 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 20 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 < 2 \gset -- delete 20k rows DELETE FROM sample_table WHERE c1 < 2; INFO: Number of compressed rows fetched from table scan: 20. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 < 2; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only for greater or equal then ORDERBY value -- this will uncompress segments which have max >= value BEGIN; -- report 30k rows SELECT COUNT(*) FROM sample_table WHERE c1 >= 7; count ------- 30000 -- report 30 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 30 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 >= 7 \gset -- delete 30k rows DELETE FROM sample_table WHERE c1 >= 7; INFO: Number of compressed rows fetched from table scan: 30. Number of compressed rows filtered: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 >= 7; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments only contain one distinct value for -- these qualifiers, everything should be deleted that was decompressed BEGIN; -- report 1k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 1000 -- report 1 row in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 1 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 and c1 = 5 \gset -- delete 1k rows DELETE FROM sample_table WHERE c4 = 5 and c1 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 9. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 and c1 = 5; count ------- 0 -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments contain more than one distinct value for -- these qualifiers, not everything should be deleted that was decompressed BEGIN; -- report 4k rows SELECT COUNT(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 4000 -- report 40 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 40 -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 > 5 and c2 = 5 \gset -- delete 4k rows DELETE FROM sample_table WHERE c4 > 5 and c2 = 5; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 40. Number of compressed rows filtered by heap filters: 0. -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 > 5 and c2 = 5; count ------- 0 -- report 36k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 36000 -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; count ------- 0 -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ?column? ---------- t ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers. -- no: of rows satisfying SEGMENTBY qualifiers is 10 -- no: of rows satisfying ORDERBY qualifiers is 3 -- Once both qualifiers are applied ensure that only 7 rows are present in -- compressed chunk BEGIN; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; count ------- 0 -- report 10 compressed rows for given condition c4 = 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 10 -- report 3 compressed rows for given condition c4 = 4 and c1 >= 7 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7; count ------- 3 SELECT COUNT(*) AS "total_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 \gset SELECT COUNT(*) AS "total_affected_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7 \gset UPDATE sample_table SET c3 = c3 + 0 WHERE c4 = 4 AND c1 >= 7; INFO: Index "compress_hyper_20_38_chunk_c4__ts_meta_min_1__ts_meta_max_1_idx" is used for scan. INFO: Number of compressed rows fetched from index: 10. Number of compressed rows filtered by heap filters: 7. -- report 7 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; count ------- 7 -- ensure correct number of rows are moved from compressed chunk -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; ?column? ---------- t ROLLBACK; RESET timescaledb.debug_compression_path_info; --github issue: 5640 CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab1(time); CREATE INDEX ON tab1(device_id,time); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable -------------------- (21,public,tab1,t) ALTER TABLE tab1 DROP COLUMN filler_1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','57m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_2; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','58m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_3; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','59m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab1; -- compress chunks ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_21_39_chunk _timescaledb_internal._hyper_21_40_chunk _timescaledb_internal._hyper_21_41_chunk -- ensure there is an index scan generated for below DELETE query BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; EXPLAIN (buffers off, costs off) DELETE FROM public.tab1 WHERE public.tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Index Scan using _hyper_21_39_chunk_tab1_device_id_time_idx on _hyper_21_39_chunk tab1_1 Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- github issue 5658 -- verify that bitmap heap scans work on all the correct data and -- none of it left over after the dml command BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 472 INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 4070 ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) DELETE FROM tab1 WHERE tab1.device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on tab1 Delete on _hyper_21_39_chunk tab1_1 Delete on _hyper_21_40_chunk tab1_2 Delete on _hyper_21_41_chunk tab1_3 -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_21_39_chunk_tab1_device_id_time_idx Index Cond: (device_id = 1) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (device_id = 1) DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; count ------- 0 ROLLBACK; -- verify we can work with expression indexes and toastable types -- when the subquery returns a zero result set we used to end up -- trying to detoast a 0 value and segfaulting BEGIN; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX test ON tab1(repeat('t', device_id)); CREATE TABLE join_table AS SELECT repeat('t', d) FROM generate_series(1,3,1) d; ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on tab1 Update on _hyper_21_39_chunk tab1_1 Update on _hyper_21_40_chunk tab1_2 Update on _hyper_21_41_chunk tab1_3 -> Nested Loop -> Subquery Scan on devices -> HashAggregate Group Key: repeat -> Result One-Time Filter: false -> Append -> Bitmap Heap Scan on _hyper_21_39_chunk tab1_1 Recheck Cond: (repeat('t'::text, device_id) = devices.repeat) -> Bitmap Index Scan on _hyper_21_39_chunk_test Index Cond: (repeat('t'::text, device_id) = devices.repeat) -> Seq Scan on _hyper_21_40_chunk tab1_2 Filter: (devices.repeat = repeat('t'::text, device_id)) -> Seq Scan on _hyper_21_41_chunk tab1_3 Filter: (devices.repeat = repeat('t'::text, device_id)) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; ROLLBACK; -- create hypertable with space partitioning and compression CREATE TABLE tab2(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab2(time); CREATE INDEX ON tab2(device_id,time); SELECT create_hypertable('tab2','time','device_id',3,create_default_indexes:=false); create_hypertable -------------------- (23,public,tab2,t) ALTER TABLE tab2 DROP COLUMN filler_1; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','35m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_2; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','45m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_3; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','55m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab2; -- compress chunks ALTER TABLE tab2 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_23_45_chunk _timescaledb_internal._hyper_23_46_chunk _timescaledb_internal._hyper_23_47_chunk -- below test will cause chunks of tab2 to get decompressed -- without fix for issue #5460 SET timescaledb.enable_optimizations = OFF; BEGIN; DELETE FROM tab1 t1 USING tab2 t2 WHERE t1.device_id = t2.device_id AND t2.time > '2000-01-01'; ROLLBACK; --cleanup RESET timescaledb.enable_optimizations; DROP table tab1; DROP table tab2; -- test joins with UPDATE/DELETE on compression chunks CREATE TABLE join_test1(time timestamptz NOT NULL,device text, value float); CREATE TABLE join_test2(time timestamptz NOT NULL,device text, value float); CREATE VIEW chunk_status AS SELECT ht.table_name AS hypertable, ch.table_name AS chunk,ch.status from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id AND ht.table_name IN ('join_test1','join_test2') ORDER BY ht.id, ch.id; SELECT table_name FROM create_hypertable('join_test1', 'time'); table_name ------------ join_test1 SELECT table_name FROM create_hypertable('join_test2', 'time'); table_name ------------ join_test2 ALTER TABLE join_test1 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); ALTER TABLE join_test2 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO join_test1 VALUES ('2000-01-01','d1',0.1), ('2000-02-01','d1',0.1), ('2000-03-01','d1',0.1); INSERT INTO join_test2 VALUES ('2000-02-01','d1',0.1), ('2000-02-01','d2',0.1), ('2000-02-01','d3',0.1); SELECT compress_chunk(show_chunks('join_test1')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_25_51_chunk _timescaledb_internal._hyper_25_52_chunk _timescaledb_internal._hyper_25_53_chunk SELECT compress_chunk(show_chunks('join_test2')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_26_54_chunk SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 BEGIN; DELETE FROM join_test1 USING join_test2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test2 USING join_test1; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status change SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test2 t2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test2 t1 SET value = t1.value + 1 FROM join_test1 t2; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 1 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 9 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 1 join_test1 | _hyper_25_53_chunk | 1 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; hypertable | chunk | status ------------+--------------------+-------- join_test1 | _hyper_25_51_chunk | 9 join_test1 | _hyper_25_52_chunk | 9 join_test1 | _hyper_25_53_chunk | 9 join_test2 | _hyper_26_54_chunk | 1 ROLLBACK; DROP TABLE join_test1; DROP TABLE join_test2; -- test if index scan qualifiers are properly used CREATE TABLE index_scan_test(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('index_scan_test','time',create_default_indexes:=false); create_hypertable ------------------------------- (29,public,index_scan_test,t) INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-01 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- compress chunks ALTER TABLE index_scan_test SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('index_scan_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_29_59_chunk ANALYZE index_scan_test; SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper%' ORDER BY ch1.id LIMIT 1 \gset SELECT ch2.schema_name|| '.' || ch2.table_name AS "COMP_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.compressed_chunk_id = ch2.id ORDER BY ch2.id LIMIT 1 \gset INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- test index on single column BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) DELETE FROM index_scan_test WHERE device_id = 2; -- everything should be deleted SELECT count(*) FROM index_scan_test where device_id = 2; count ------- 0 -- there shouldn't be anything in the uncompressed chunk where device_id = 2 SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk from device_id = 2 SELECT count(*) FROM :COMP_CHUNK_1 where device_id = 2; count ------- 0 ROLLBACK; -- test multi column index BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id, time); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_time_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: ((index_scan_test_1.device_id = 2) AND (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone)) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test index with filter condition BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on public.index_scan_test Delete on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 -> Index Scan using _hyper_29_59_chunk_index_scan_test_device_id_idx on _timescaledb_internal._hyper_29_59_chunk index_scan_test_1 Output: index_scan_test_1.tableoid, index_scan_test_1.ctid Index Cond: (index_scan_test_1.device_id = 2) Filter: (index_scan_test_1."time" > 'Sun Jan 02 00:00:00 2000 PST'::timestamp with time zone) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; count ------- 0 -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; ?column? ---------- t -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; count ------- 0 ROLLBACK; -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled UPDATE sample_table SET c3 = NULL WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE c4 = 5; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 -- make sure reseting the GUC we will be able to UPDATE/DELETE compressed chunks RESET timescaledb.enable_dml_decompression; SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE c4 = 5; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; count ------- 10000 ROLLBACK; BEGIN; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 10000 DELETE FROM sample_table WHERE c4 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; count ------- 0 ROLLBACK; -- create new uncompressed chunk INSERT INTO sample_table SELECT t, 1, 1, 1, 1 FROM generate_series('2023-05-04 00:00:00-00'::timestamptz, '2023-05-04 00:00:00-00'::timestamptz + INTERVAL '2 hours', INTERVAL '1 hour') t; -- check chunk compression status SELECT chunk_name, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; chunk_name | is_compressed --------------------+--------------- _hyper_19_37_chunk | t _hyper_19_61_chunk | f -- test for uncompressed and compressed chunks SHOW timescaledb.enable_dml_decompression; timescaledb.enable_dml_decompression -------------------------------------- on SET timescaledb.enable_dml_decompression = false; BEGIN; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 3 -- delete from uncompressed chunk should work DELETE FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; count ------- 0 ROLLBACK; BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 0 UPDATE sample_table SET c3 = NULL WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; count ------- 3 ROLLBACK; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled -- and both statements we're touching compressed and uncompressed chunks UPDATE sample_table SET c3 = NULL WHERE time >= '2023-03-17 00:00:00-00'::timestamptz AND c3 IS NULL; ERROR: UPDATE/DELETE is disabled on compressed chunks DELETE FROM sample_table WHERE time >= '2023-03-17 00:00:00-00'::timestamptz; ERROR: UPDATE/DELETE is disabled on compressed chunks \set ON_ERROR_STOP 1 --github issue: 5586 --testcase with multiple indexes \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test5586; \c test5586 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('tab1','time',create_default_indexes:=false); create_hypertable ------------------- (1,public,tab1,t) INSERT INTO tab1(filler_1, filler_2, filler_3,time,device_id,v0,v1,v2,v3) SELECT device_id, device_id+1, device_id + 2, time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id, filler_1, filler_2, filler_3'); SELECT compress_chunk(show_chunks('tab1')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 \gset -- create multiple indexes on compressed hypertable DROP INDEX _timescaledb_internal.compress_hyper_2_2_chunk_device_id_filler_1_filler_2_filler_idx; CREATE INDEX ON :CHUNK (_ts_meta_min_1); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_count); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_max_1, filler_1); CREATE INDEX filler_1 ON :CHUNK (filler_1); CREATE INDEX filler_2 ON :CHUNK (filler_2); CREATE INDEX filler_3 ON :CHUNK (filler_3); -- below indexes should be selected CREATE INDEX filler_1_filler_2 ON :CHUNK (filler_1, filler_2); CREATE INDEX filler_2_filler_3 ON :CHUNK (filler_2, filler_3); set timescaledb.debug_compression_path_info to on; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_3 = 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_3 = 5 AND filler_2 = 4; INFO: Index "filler_2_filler_3" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5 AND filler_2 = 4; count ------- 3598 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5 AND filler_2 = 4; INFO: Index "filler_1_filler_2" is used for scan. INFO: Number of compressed rows fetched from index: 4. Number of compressed rows filtered by heap filters: 0. ROLLBACK; -- idealy filler_1 index should be selected, -- instead first matching index is selected BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5; count ------- 14392 UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5; INFO: Index "compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_fill_idx" is used for scan. INFO: Number of compressed rows fetched from index: 16. Number of compressed rows filtered by heap filters: 0. ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE tab1; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test5586 WITH (FORCE); --issue: #6024 CREATE TABLE t(a integer, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); create_hypertable ------------------- (31,public,t,t) INSERT INTO t values(1, 2); ALTER TABLE t SET (timescaledb.compress); SELECT compress_chunk(show_chunks('t')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_31_62_chunk -- should not crash UPDATE t SET b = 2 WHERE tableoid = 0; UPDATE t SET b = 2 WHERE tableoid is null; DROP TABLE t; -- github issue: 6367 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test6367; \c test6367 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE t6367 ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar, data jsonb ); SELECT table_name FROM create_hypertable('t6367', 'time'); table_name ------------ t6367 ALTER TABLE t6367 SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO t6367 SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT compress_chunk(c) FROM show_chunks('t6367') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk SELECT format('%I.%I', schema_name, table_name) AS "CHUNK1" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 \gset SELECT format('%I.%I', schema_name, table_name) AS "CHUNK2" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 OFFSET 1 \gset DROP INDEX _timescaledb_internal.compress_hyper_2_3_chunk_source_id_label__ts_meta_min_1__ts_idx; DROP INDEX _timescaledb_internal.compress_hyper_2_4_chunk_source_id_label__ts_meta_min_1__ts_idx; -- testcase with no index, should use seq scan set timescaledb.debug_compression_path_info to on; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test case with an index which has only one -- of the segmentby filters CREATE INDEX source_id_idx1 ON :CHUNK1 (source_id); CREATE INDEX source_id_idx2 ON :CHUNK2 (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; -- test that we are filtering NULL checks BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 3. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; count ------- 0 ROLLBACK; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 30 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NOT NULL; INFO: Index "source_id_idx1" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. INFO: Index "source_id_idx2" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_idx1; DROP INDEX _timescaledb_internal.source_id_idx2; -- test case with an index which has multiple same column CREATE INDEX source_id_source_id_idx ON :CHUNK1 (source_id, source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Index "source_id_source_id_idx" is used for scan. INFO: Number of compressed rows fetched from index: 3. Number of compressed rows filtered by heap filters: 2. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.source_id_source_id_idx; -- test using a non-btree index -- fallback to heap scan CREATE INDEX brin_source_id_idx ON :CHUNK1 USING brin (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.brin_source_id_idx; -- test using an expression index -- should fallback to heap scans CREATE INDEX expr_source_id_idx ON :CHUNK1 (upper(source_id)); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; DROP INDEX _timescaledb_internal.expr_source_id_idx; -- test using a partial index -- should fallback to heap scans CREATE INDEX partial_source_id_idx ON :CHUNK1 (source_id) WHERE _ts_meta_min_1 > '1990-01-01'::timestamptz; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 10 UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. INFO: Number of compressed rows fetched from table scan: 1. Number of compressed rows filtered: 0. SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; count ------- 0 ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE t6367; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test6367 WITH (FORCE); -- Text limitting decompressed tuple during an UPDATE or DELETE CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>10000); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 33 | public | test_limit | t INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp' ); SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; count ------- 2 SET timescaledb.max_tuples_decompressed_per_dml_transaction = 5000; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Updating or deleting everything will break the set limit. UPDATE test_limit SET id = 0; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). DELETE FROM test_limit WHERE id = 1; ERROR: tuple decompression limit exceeded by operation DETAIL: current limit: 5000, tuples decompressed: 30000 HINT: Consider increasing timescaledb.max_tuples_decompressed_per_dml_transaction or set to 0 (unlimited). -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; UPDATE test_limit SET id = 0; DELETE FROM test_limit WHERE id = 1; \set ON_ERROR_STOP 1 DROP TABLE test_limit; -- check partial compression with DML CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); create_hypertable ----------------------------- (35,public,test_partials,t) INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 Sat Jan 01 00:04:00 2022 PST | 1 | 2 -- check that DML causes transparent decompression and that -- data gets shifted to the uncompressed parts EXPLAIN (buffers off, costs off) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on test_partials Delete on _hyper_35_68_chunk test_partials_1 Delete on _hyper_35_69_chunk test_partials_2 Delete on _hyper_35_70_chunk test_partials_3 -> Custom Scan (ChunkAppend) on test_partials -> Seq Scan on _hyper_35_68_chunk test_partials_1 Filter: (ALL ("time" >= (SubPlan 1).col1)) SubPlan 1 -> Materialize -> Append -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Seq Scan on compress_hyper_36_71_chunk -> Seq Scan on _hyper_35_68_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Seq Scan on compress_hyper_36_72_chunk -> Seq Scan on _hyper_35_69_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Seq Scan on compress_hyper_36_73_chunk -> Seq Scan on _hyper_35_70_chunk -> Seq Scan on _hyper_35_69_chunk test_partials_2 Filter: (ALL ("time" >= (SubPlan 1).col1)) -> Seq Scan on _hyper_35_70_chunk test_partials_3 Filter: (ALL ("time" >= (SubPlan 1).col1)) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); VACUUM ANALYZE test_partials; -- All 3 chunks will now become partially compressed chunks EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Index Scan Backward using _hyper_35_68_chunk_test_partials_time_idx on _hyper_35_68_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Index Scan Backward using _hyper_35_69_chunk_test_partials_time_idx on _hyper_35_69_chunk -> Merge Append Sort Key: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk -> Index Scan Backward using _hyper_35_70_chunk_test_partials_time_idx on _hyper_35_70_chunk -- verify correct results SELECT * FROM test_partials ORDER BY time; time | a | b ------------------------------+---+--- Wed Jan 01 00:00:00 2020 PST | 1 | 2 Wed Jan 01 00:01:00 2020 PST | 2 | 2 Wed Jan 01 00:04:00 2020 PST | 1 | 2 Fri Jan 01 00:00:00 2021 PST | 1 | 2 Fri Jan 01 00:04:00 2021 PST | 1 | 2 Sat Jan 01 00:00:00 2022 PST | 1 | 2 SELECT compress_chunk(show_chunks('test_partials')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_35_68_chunk _timescaledb_internal._hyper_35_69_chunk _timescaledb_internal._hyper_35_70_chunk VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on test_partials Order: test_partials."time" -> Custom Scan (ColumnarScan) on _hyper_35_68_chunk -> Sort Sort Key: compress_hyper_36_71_chunk._ts_meta_min_1, compress_hyper_36_71_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_71_chunk -> Custom Scan (ColumnarScan) on _hyper_35_69_chunk -> Sort Sort Key: compress_hyper_36_72_chunk._ts_meta_min_1, compress_hyper_36_72_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_72_chunk -> Custom Scan (ColumnarScan) on _hyper_35_70_chunk -> Sort Sort Key: compress_hyper_36_73_chunk._ts_meta_min_1, compress_hyper_36_73_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_36_73_chunk DROP TABLE test_partials; CREATE TABLE test_meta_filters(time timestamptz NOT NULL, device text, metric text, v1 float, v2 float); CREATE INDEX ON test_meta_filters(device, metric, v1); SELECT create_hypertable('test_meta_filters', 'time'); create_hypertable --------------------------------- (37,public,test_meta_filters,t) ALTER TABLE test_meta_filters SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='metric,time'); INSERT INTO test_meta_filters SELECT '2020-01-01'::timestamptz,'d1','m' || metric::text,v1,v2 FROM generate_series(1,3,1) metric, generate_series(1,1000,1) v1, generate_series(1,10,1) v2 ORDER BY 1,2,3,4,5; SELECT compress_chunk(show_chunks('test_meta_filters')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_37_74_chunk EXPLAIN (analyze, timing off, buffers off, costs off, summary off) DELETE FROM test_meta_filters WHERE device = 'd1' AND metric = 'm1' AND v1 < 100; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on test_meta_filters (actual rows=0.00 loops=1) Delete on _hyper_37_74_chunk test_meta_filters_1 -> Seq Scan on _hyper_37_74_chunk test_meta_filters_1 (actual rows=990.00 loops=1) Filter: ((v1 < '100'::double precision) AND (device = 'd1'::text) AND (metric = 'm1'::text)) Rows Removed by Filter: 10 -- test expression pushdown in compressed dml constraints CREATE TABLE test_pushdown(time timestamptz NOT NULL, device text); SELECT table_name FROM create_hypertable('test_pushdown', 'time'); table_name --------------- test_pushdown INSERT INTO test_pushdown SELECT '2020-01-01', 'a'; INSERT INTO test_pushdown SELECT '2020-01-01', 'b'; INSERT INTO test_pushdown SELECT '2020-01-01 05:00', 'c'; CREATE TABLE devices(device text); INSERT INTO devices VALUES ('a'), ('b'), ('c'); CREATE TABLE devices2(device text); INSERT INTO devices2 VALUES ('d'), ('e'), ('f'); CREATE TABLE devices3(device text); INSERT INTO devices3 VALUES ('b'), ('d'), ('g'); ALTER TABLE test_pushdown SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(show_chunks('test_pushdown')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_39_76_chunk -- 3 batch decompressions means pushdown is not working so we expect less than 3 for all these queries SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'a' = device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('a'::text = device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device < 'c' ; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: (device < 'c'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' > device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('c'::text > device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' >= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ('c'::text >= device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device > 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device > 'b'::text) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = CURRENT_USER; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = CURRENT_USER) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' < device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: ('b'::text < device) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' <= device; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ('b'::text <= device) RESET timescaledb.enable_compressed_direct_batch_delete; -- cant pushdown OR atm BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = 'a' OR device = 'b'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ((device = 'a'::text) OR (device = 'b'::text)) Rows Removed by Filter: 1 -- test stable function BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time = timestamptz('2020-01-01 05:00'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" = 'Wed Jan 01 05:00:00 2020 PST'::timestamp with time zone) -- test sqlvaluefunction BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = substring(CURRENT_USER,length(CURRENT_USER)+1) || 'c'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ("substring"((CURRENT_USER)::text, (length((CURRENT_USER)::text) + 1)) || 'c'::text)) -- JOIN tests -- no filtering in decompression SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Merge Join (actual rows=1.00 loops=1) Merge Cond: (p_1.device = d.device) -> Sort (actual rows=3.00 loops=1) Sort Key: p_1.device Sort Method: quicksort -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=3.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: d.device Sort Method: quicksort -> Seq Scan on devices3 d (actual rows=3.00 loops=1) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- can filter in decompression even before executing join SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown p (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk p_1 -> Nested Loop (actual rows=1.00 loops=1) -> Seq Scan on devices d (actual rows=1.00 loops=1) Filter: (device = 'b'::text) Rows Removed by Filter: 2 -> Materialize (actual rows=1.00 loops=1) -> Seq Scan on _hyper_39_76_chunk p_1 (actual rows=1.00 loops=1) Filter: (device = 'b'::text) time | device ------------------------------+-------- Wed Jan 01 00:00:00 2020 PST | a Wed Jan 01 05:00:00 2020 PST | c -- test prepared statement PREPARE q1(text) AS DELETE FROM test_pushdown WHERE device = $1; SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = 'a'::text) RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'a'::text) BEGIN; :EXPLAIN EXECUTE q1('not here'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = 'not here'::text) -- test arrayop pushdown less than 3 decompressions are expected for successful pushdown BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a','d'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = ANY('{a,d}'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = ANY ('{a,d}'::text[])) BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',CURRENT_USER); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 1 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, (CURRENT_USER)::text])) -- arroyop pushdown only works for segmentby columns atm so 3 decompressions are expected for now BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time IN ('2020-01-01','2020-01-02'); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=2.00 loops=1) Filter: ("time" = ANY ('{"Wed Jan 01 00:00:00 2020 PST","Thu Jan 02 00:00:00 2020 PST"}'::timestamp with time zone[])) Rows Removed by Filter: 1 -- no pushdown for volatile functions BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = current_query(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=0.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: (device = current_query()) Rows Removed by Filter: 3 BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',current_query()); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Custom Scan (ChunkAppend) on test_pushdown (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=1.00 loops=1) Filter: (device = ANY (ARRAY['a'::text, current_query()])) Rows Removed by Filter: 2 -- test DELETE optimization without predicates -- should delete 3 complete batches without decompression BEGIN; :EXPLAIN DELETE FROM test_pushdown; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) -- test DELETE optimization on non-segmentby columns -- this shows optimization can be applied if in-memory filtering is enabled \set QUIET off BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=0.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK SET timescaledb.enable_dml_decompression_tuple_filtering TO OFF; SET BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 3 -> Delete on test_pushdown (actual rows=0.00 loops=1) Delete on _hyper_39_76_chunk test_pushdown_1 -> Seq Scan on _hyper_39_76_chunk test_pushdown_1 (actual rows=3.00 loops=1) Filter: ("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) ROLLBACK BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN DELETE 3 ROLLBACK RESET timescaledb.enable_dml_decompression_tuple_filtering; RESET \set QUIET on -- github issue #6858 -- check update triggers work correctly both on uncompressed and compressed chunks CREATE TABLE update_trigger_test ( "entity_id" "uuid" NOT NULL, "effective_date_time" timestamp with time zone NOT NULL, "measurement" numeric NOT NULL, "modified_at" timestamp with time zone DEFAULT "now"() NOT NULL ); SELECT create_hypertable('update_trigger_test', 'effective_date_time'); create_hypertable ----------------------------------- (41,public,update_trigger_test,t) CREATE OR REPLACE FUNCTION update_modified_at_test() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN NEW.modified_at = NOW(); RETURN NEW; END; $$; CREATE TRIGGER update_trigger_test__before_update_sync_modified_at BEFORE UPDATE ON update_trigger_test FOR EACH ROW EXECUTE PROCEDURE update_modified_at_test(); INSERT INTO update_trigger_test SELECT 'f2ca7073-1395-5770-8378-7d0339804580', '2024-04-16 04:50:00+02', 1100.00, '2024-04-23 11:56:38.494095+02' FROM generate_series(1,2500,1) c; VACUUM FULL update_trigger_test; BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- try with default compression ALTER TABLE update_trigger_test SET (timescaledb.compress); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- lets try with segmentby SELECT decompress_chunk(show_chunks('update_trigger_test')); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk ALTER TABLE update_trigger_test SET (timescaledb.compress, timescaledb.compress_segmentby='entity_id'); SELECT compress_chunk(show_chunks('update_trigger_test')); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_78_chunk BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- check reporting of affected rows is correct for direct batch delete CREATE TABLE delete_counter(time timestamptz NOT NULL, device text) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'a' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'b' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'c' from generate_series(1,123); ALTER TABLE delete_counter SET (timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('delete_counter') ch; count ------- 2 INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'd' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-03-01'::timestamptz, 'e' from generate_series(1,123); \set QUIET off BEGIN; :EXPLAIN DELETE FROM delete_counter; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 3 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Append (actual rows=246.00 loops=1) -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=123.00 loops=1) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) ROLLBACK BEGIN; DELETE FROM delete_counter; ROLLBACK; BEGIN DELETE 615 ROLLBACK BEGIN; :EXPLAIN DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 369 -> Delete on delete_counter (actual rows=0.00 loops=1) Delete on _hyper_43_81_chunk delete_counter_1 Delete on _hyper_43_82_chunk delete_counter_2 Delete on _hyper_43_85_chunk delete_counter_3 -> Custom Scan (ChunkAppend) on delete_counter (actual rows=615.00 loops=1) Chunks excluded during startup: 0 -> Seq Scan on _hyper_43_81_chunk delete_counter_1 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_82_chunk delete_counter_2 (actual rows=246.00 loops=1) Filter: (random() < '1'::double precision) -> Seq Scan on _hyper_43_85_chunk delete_counter_3 (actual rows=123.00 loops=1) Filter: (random() < '1'::double precision) ROLLBACK BEGIN; DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN DELETE 615 ROLLBACK -- test invalidation with direct batch delete optimizations CREATE TABLE cagg_inval(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE INSERT INTO cagg_inval SELECT '2020-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 INSERT INTO cagg_inval SELECT '2021-01-01'::timestamptz, 'd1', 1.0; INSERT 0 1 SELECT count(compress_chunk(ch)) FROM show_chunks('cagg_inval') ch; count ------- 2 SET timescaledb.enable_compressed_direct_batch_delete TO on; SET -- delete without cagg should use optimization BEGIN; BEGIN EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=0.00 loops=1) ROLLBACK; ROLLBACK CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time) FROM cagg_inval GROUP BY 1; NOTICE: refreshing continuous aggregate "cagg1" HINT: Use WITH NO DATA if you do not want to refresh the continuous aggregate on creation. CREATE MATERIALIZED VIEW -- should not use direct batch delete EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on cagg_inval (actual rows=0.00 loops=1) Delete on _hyper_45_86_chunk cagg_inval_1 Delete on _hyper_45_87_chunk cagg_inval_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_45_86_chunk cagg_inval_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_45_87_chunk cagg_inval_2 (actual rows=1.00 loops=1) -- should have invalidation entry SELECT * FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; hypertable_id | lowest_modified_value | greatest_modified_value ---------------+-----------------------+------------------------- 45 | 1577865600000000 | 1609488000000000 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/compression_uuid.out�������������������������������������������0000664�0000000�0000000�00000053116�15100345067�0023563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --install necessary functions for tests \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_uuid_compression = on; CREATE TABLE t (ts int, u uuid); SELECT create_hypertable('t', 'ts', chunk_time_interval => 500); create_hypertable ------------------- (1,public,t,t) ALTER TABLE t SET (timescaledb.compress, timescaledb.compress_orderby = 'ts'); INSERT INTO t SELECT g AS ts, NULL AS uuid FROM generate_series(1, 3000) g; -- The first hundred elements are generated with the Go uuid v7 routines CREATE TABLE uuids (i int, u uuid); INSERT INTO uuids (i, u) VALUES (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (18, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (19, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (20, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (21, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (22, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (23, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (24, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (25, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (26, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (27, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (28, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (29, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (30, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (31, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (32, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (33, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (34, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (35, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (36, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (37, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (38, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (39, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (40, '0197a7a9-b48c-7c96-914c-690b7930262f'), (41, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (42, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (43, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (44, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'), (45, '0197a7a9-b48c-7c9b-9319-de9dd58deeee'), (46, '0197a7a9-b48c-7c9c-a9d4-ed6f3e6a41b7'), (47, '0197a7a9-b48c-7c9d-8036-4141e0780323'), (48, '0197a7a9-b48c-7c9e-bfbe-f00eb49ed7f2'), (49, '0197a7a9-b48c-7c9f-8ffe-71cf00a0c0c0'), (50, '0197a7a9-b48c-7ca0-822f-95ced2f95702'), (51, '0197a7a9-b48c-7ca1-8c8a-66582aec95fa'), (52, '0197a7a9-b48c-7ca2-95c3-fe80362a2251'), (53, '0197a7a9-b48c-7ca3-855f-f681b254a8c8'), (54, '0197a7a9-b48c-7ca4-856b-a562eca93c3f'), (55, '0197a7a9-b48c-7ca5-a30e-37c247fb4c46'), (56, '0197a7a9-b48c-7ca6-9e78-a148d54a44ac'), (57, '0197a7a9-b48c-7ca7-badb-4b650bf5bf5f'), (58, '0197a7a9-b48c-7ca8-8275-a8590869ef13'), (59, '0197a7a9-b48c-7ca9-b328-b54c3901223c'), (60, '0197a7a9-b48c-7caa-a15d-f5564e4e552c'), (61, '0197a7a9-b48c-7cab-a4ac-017259746322'), (62, '0197a7a9-b48c-7cac-bda5-74ef12abd6b8'), (63, '0197a7a9-b48c-7cad-a3cd-0e4c93eaba80'), (64, '0197a7a9-b48c-7cae-9667-de4a226418df'), (65, '0197a7a9-b48c-7caf-8aa2-067619170f32'), (66, '0197a7a9-b48c-7cb0-ba8c-91d9e8920845'), (67, '0197a7a9-b48c-7cb1-9681-a62bfffe9237'), (68, '0197a7a9-b48c-7cb2-b78b-037e5ee26ff6'), (69, '0197a7a9-b48c-7cb3-ac27-e24382445188'), (70, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (71, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (72, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (73, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (74, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (75, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (76, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (77, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (78, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (79, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (80, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (81, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (82, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (83, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (84, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (85, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (86, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (87, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (88, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (89, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (90, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (91, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (92, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (93, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (94, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (95, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (96, '0197a7a9-b48c-7c96-914c-690b7930262f'), (97, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (98, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (99, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (100, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'); -- set data to be compressed with the uuid compressor UPDATE t SET u = (select u from uuids where i = ts) where ts <= 100; -- set data to be compressed with the dictionary compressor UPDATE t SET u = (select u from uuids where i = ts%100) where ts > 1000 and ts <= 2000; -- add random UUID v4s to the data UPDATE t SET u = gen_random_uuid() where ts > 2000; -- compress the data SELECT compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk -- decompress the data SELECT decompress_chunk(show_chunks('t')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk -- disable uuid compression and compress the data again SET timescaledb.enable_uuid_compression = off; SELECT compress_chunk(show_chunks('t')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk CREATE TABLE mixed_compressed (ts int, u uuid); SELECT create_hypertable('mixed_compressed', 'ts', chunk_time_interval => 500); create_hypertable ------------------------------- (3,public,mixed_compressed,t) ALTER TABLE mixed_compressed SET (timescaledb.compress, timescaledb.compress_orderby = 'ts'); -- the new UUID compression is OFF at this point, so we use the original method -- add the base uuids to the data and compress it INSERT INTO mixed_compressed SELECT i, u FROM uuids; INSERT INTO mixed_compressed SELECT i+100 as i, NULL as u FROM uuids; -- compress the data SELECT compress_chunk(show_chunks('mixed_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_22_chunk -- enable uuid compression and compress the data again -- and add the base uuids to the data again SET timescaledb.enable_uuid_compression = on; INSERT INTO mixed_compressed SELECT i+1000 as i, u FROM uuids; INSERT INTO mixed_compressed SELECT i+1100 as i, NULL as u FROM uuids; -- compress the data SELECT compress_chunk(show_chunks('mixed_compressed')); NOTICE: chunk "_hyper_3_22_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_22_chunk _timescaledb_internal._hyper_3_24_chunk -- now turn it off again and add the whole data twice SET timescaledb.enable_uuid_compression = off; INSERT INTO mixed_compressed SELECT i+2000, u FROM uuids; INSERT INTO mixed_compressed SELECT i+2200, u FROM uuids; INSERT INTO mixed_compressed SELECT i+2300 as i, NULL as u FROM uuids; -- compress the data again SELECT compress_chunk(show_chunks('mixed_compressed')); NOTICE: chunk "_hyper_3_22_chunk" is already converted to columnstore NOTICE: chunk "_hyper_3_24_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_22_chunk _timescaledb_internal._hyper_3_24_chunk _timescaledb_internal._hyper_3_26_chunk -- turn it on again and do the same SET timescaledb.enable_uuid_compression = off; INSERT INTO mixed_compressed SELECT i+3000, u FROM uuids; INSERT INTO mixed_compressed SELECT i+3200, u FROM uuids; INSERT INTO mixed_compressed SELECT i+3300 as i, NULL as u FROM uuids; -- compress the data again SELECT compress_chunk(show_chunks('mixed_compressed')); NOTICE: chunk "_hyper_3_22_chunk" is already converted to columnstore NOTICE: chunk "_hyper_3_24_chunk" is already converted to columnstore NOTICE: chunk "_hyper_3_26_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_22_chunk _timescaledb_internal._hyper_3_24_chunk _timescaledb_internal._hyper_3_26_chunk _timescaledb_internal._hyper_3_28_chunk -- check the compression algorithm for the compressed chunks CREATE TABLE compressed_chunks AS SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as compressed_chunk, ccs.compressed_heap_size, ccs.compressed_toast_size, ccs.compressed_index_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM show_chunks('mixed_compressed') c INNER JOIN _timescaledb_catalog.chunk cat ON (c = format('%I.%I', cat.schema_name, cat.table_name)::regclass) INNER JOIN _timescaledb_catalog.chunk comp ON (cat.compressed_chunk_id = comp.id) INNER JOIN _timescaledb_catalog.compression_chunk_size ccs ON (comp.id = ccs.compressed_chunk_id); CREATE TABLE compression_info (compressed_chunk regclass, result text, compressed_size int, num_rows int); DO $$ DECLARE table_ref regclass; BEGIN FOR table_ref IN SELECT compressed_chunk as table_ref FROM compressed_chunks LOOP EXECUTE format( 'INSERT INTO compression_info ( SELECT %L::regclass as compressed_chunk, (_timescaledb_functions.compressed_data_info(u))::text as result, sum(pg_column_size(u)::int) as compressed_size, count(*) as num_rows FROM %s GROUP BY 1,2)', table_ref, table_ref ); END LOOP; END; $$; SELECT ci.*, ccs.compressed_toast_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM compression_info ci INNER JOIN compressed_chunks ccs ON (ci.compressed_chunk = ccs.compressed_chunk) ORDER BY 1,2,3; compressed_chunk | result | compressed_size | num_rows | compressed_toast_size | numrows_pre_compression | numrows_post_compression -------------------------------------------------+----------------+-----------------+----------+-----------------------+-------------------------+-------------------------- _timescaledb_internal.compress_hyper_4_23_chunk | (DICTIONARY,t) | 1272 | 1 | 8192 | 200 | 1 _timescaledb_internal.compress_hyper_4_25_chunk | (UUID,t) | 976 | 1 | 8192 | 200 | 1 _timescaledb_internal.compress_hyper_4_27_chunk | (DICTIONARY,t) | 1352 | 1 | 8192 | 300 | 1 _timescaledb_internal.compress_hyper_4_29_chunk | (DICTIONARY,t) | 1352 | 1 | 8192 | 300 | 1 -- ------------------------------- -- Test the new UUID v7 functions -- ------------------------------- -- The next 3 items are generated with the new functions BEGIN; INSERT INTO uuids VALUES (101, to_uuidv7('2025-07-02:03:04:05'::timestamptz)); INSERT INTO uuids VALUES (102, to_uuidv7('2029-01-02:03:04:05'::timestamptz)); INSERT INTO uuids VALUES (103, to_uuidv7('2059-02-03:04:05:06'::timestamptz)); INSERT INTO uuids VALUES (104, to_uuidv7('2100-07-08:09:10:11'::timestamptz)); COMMIT; SELECT to_char(uuid_timestamp(u), 'YYYY-MM-DD:HH24:MI:SS'), uuid_version(u), count(*) FROM uuids GROUP BY 1,2 ORDER BY 1,2; to_char | uuid_version | count ---------------------+--------------+------- 2025-06-25:08:16:46 | 7 | 100 2025-07-02:03:04:05 | 7 | 1 2029-01-02:03:04:05 | 7 | 1 2059-02-03:04:05:06 | 7 | 1 2100-07-08:09:10:11 | 7 | 1 -- Add some v4 timestamps for sanity check BEGIN; INSERT INTO uuids VALUES (105, _timescaledb_functions.generate_uuid()); INSERT INTO uuids VALUES (106, _timescaledb_functions.generate_uuid()); INSERT INTO uuids VALUES (107, _timescaledb_functions.generate_uuid()); -- Add some random v7 timestamps too INSERT INTO uuids VALUES (108, generate_uuidv7()); INSERT INTO uuids VALUES (109, generate_uuidv7()); INSERT INTO uuids VALUES (110, generate_uuidv7()); COMMIT; -- There is a test flakyness that I want to debug with this: SELECT i, uuid_version(u) FROM uuids WHERE i > 100 ORDER BY 1; i | uuid_version -----+-------------- 101 | 7 102 | 7 103 | 7 104 | 7 105 | 4 106 | 4 107 | 4 108 | 7 109 | 7 110 | 7 -- The version numbers should make sense SELECT uuid_version(u), count(*) FROM uuids WHERE -- The filters are here just to test, they don't blow up with random data from v4 -- NOTE that we have v4 and v7 data in the table so the timestamp filter alone makes -- the test flaky uuid_timestamp(u) > '2000-01-01:01:01:01'::timestamptz OR uuid_version(u) >= 1 GROUP BY 1 ORDER BY 1; uuid_version | count --------------+------- 4 | 3 7 | 107 -- Filter UUIDs on timestamp part by using both zeroed UUID and -- extracted timestamp. Both methods should yield the same count. SELECT count(*) AS count_total, count(*) FILTER (WHERE u < to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_below_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) < 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_below_on_time, count(*) FILTER (WHERE u >= to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_above_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) >= 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_above_on_time FROM uuids WHERE uuid_version(u) = 7; count_total | count_below_on_uuid | count_below_on_time | count_above_on_uuid | count_above_on_time -------------+---------------------+---------------------+---------------------+--------------------- 107 | 37 | 37 | 70 | 70 -- The EXPLAIN shows how the immutable "zeroed" function can be -- constified for better performance. EXPLAIN (verbose, buffers off, costs off) SELECT count(*) AS count_total, count(*) FILTER (WHERE u < to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_below_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) < 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_below_on_time, count(*) FILTER (WHERE u >= to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_above_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) >= 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_above_on_time FROM uuids WHERE uuid_version(u) = 7; --- QUERY PLAN --- Aggregate Output: count(*), count(*) FILTER (WHERE (u < '0197a7a9-b48c-7000-8000-000000000000'::uuid)), count(*) FILTER (WHERE (uuid_timestamp(u) < 'Wed Jun 25 08:16:46.348 2025 PDT'::timestamp with time zone)), count(*) FILTER (WHERE (u >= '0197a7a9-b48c-7000-8000-000000000000'::uuid)), count(*) FILTER (WHERE (uuid_timestamp(u) >= 'Wed Jun 25 08:16:46.348 2025 PDT'::timestamp with time zone)) -> Seq Scan on public.uuids Output: i, u Filter: (uuid_version(uuids.u) = 7) -- Sub ms timestamp test: -- generate all microseconds timestamps between the two dates below and -- generate a UUID v7 based on the timestamp and -- extract the timestamp from the UUID and -- compare the timestamp to the original one -- 1 microsecond difference is allowed due to scaling of decimals to binaries -- CREATE TABLE subms AS SELECT to_uuidv7(x) u, x ts FROM generate_series('2025-01-01:00:00:00'::timestamptz, '2025-01-01:00:00:03'::timestamptz, '1 microsecond'::interval) x; SELECT u, ts, ts2 FROM ( SELECT u, ts, uuid_timestamp_micros(u) ts2 FROM subms ) x WHERE (x.ts - x.ts2) > '00:00:00.000001' OR (x.ts - x.ts2) < '-00:00:00.000001'; u | ts | ts2 ---+----+----- -- Make sure UUIDv7 compression is enabled SET timescaledb.enable_uuid_compression = true; -- Test compression on uuid partitioning column CREATE TABLE uuid_part (id uuid, value int); SELECT create_hypertable('uuid_part', by_range('id', interval '1 month')); create_hypertable ------------------- (5,t) -- Insert the static UUIDs INSERT INTO uuid_part SELECT u, i FROM uuids WHERE uuid_version(u) = 7 AND i <= 104; -- Insert some outlier values to filter for INSERT INTO uuid_part (value, id) VALUES (105, to_uuidv7('2025-08-13 03:03:04 PDT'::timestamptz)), (106, to_uuidv7('2025-08-14 03:04:05 PDT'::timestamptz)), (107, to_uuidv7('2025-08-15 04:05:06 PDT'::timestamptz)); SELECT * FROM show_chunks('uuid_part'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_30_chunk _timescaledb_internal._hyper_5_31_chunk _timescaledb_internal._hyper_5_32_chunk _timescaledb_internal._hyper_5_33_chunk _timescaledb_internal._hyper_5_34_chunk ALTER TABLE uuid_part SET (timescaledb.compress, timescaledb.compress_orderby = 'id'); -- Show how data is spread across chunks SELECT tableoid::regclass, count(*) FROM uuid_part GROUP BY tableoid ORDER BY tableoid; tableoid | count -----------------------------------------+------- _timescaledb_internal._hyper_5_30_chunk | 101 _timescaledb_internal._hyper_5_31_chunk | 1 _timescaledb_internal._hyper_5_32_chunk | 1 _timescaledb_internal._hyper_5_33_chunk | 1 _timescaledb_internal._hyper_5_34_chunk | 3 SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); count ------- 3 EXPLAIN (verbose, buffers off, costs off) SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); --- QUERY PLAN --- Aggregate Output: count(*) -> Index Only Scan using _hyper_5_34_chunk_uuid_part_id_idx on _timescaledb_internal._hyper_5_34_chunk Index Cond: ((_hyper_5_34_chunk.id >= '0198a23a-8180-7000-8000-000000000000'::uuid) AND (_hyper_5_34_chunk.id < '0198b1ad-9580-7000-8000-000000000000'::uuid)) -- Compress SELECT compress_chunk(ch) FROM show_chunks('uuid_part') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_30_chunk _timescaledb_internal._hyper_5_31_chunk _timescaledb_internal._hyper_5_32_chunk _timescaledb_internal._hyper_5_33_chunk _timescaledb_internal._hyper_5_34_chunk -- Check that chunk exclusion and filtering works as expected on -- compressed UUID data. SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); count ------- 3 -- Check that chunk exclusion still works and that filters are pushed -- down to a min-max scan on the compressed chunk. EXPLAIN (verbose, buffers off, costs off) SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); --- QUERY PLAN --- Aggregate Output: count(*) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_5_34_chunk Filter: ((_hyper_5_34_chunk.id >= '0198a23a-8180-7000-8000-000000000000'::uuid) AND (_hyper_5_34_chunk.id < '0198b1ad-9580-7000-8000-000000000000'::uuid)) -> Index Scan using compress_hyper_6_39_chunk__ts_meta_min_1__ts_meta_max_1_idx on _timescaledb_internal.compress_hyper_6_39_chunk Output: compress_hyper_6_39_chunk._ts_meta_count, compress_hyper_6_39_chunk._ts_meta_min_1, compress_hyper_6_39_chunk._ts_meta_max_1, compress_hyper_6_39_chunk.id, compress_hyper_6_39_chunk.value Index Cond: ((compress_hyper_6_39_chunk._ts_meta_min_1 < '0198b1ad-9580-7000-8000-000000000000'::uuid) AND (compress_hyper_6_39_chunk._ts_meta_max_1 >= '0198a23a-8180-7000-8000-000000000000'::uuid)) -- Cleanup DROP TABLE t; DROP TABLE subms; DROP TABLE uuids; DROP TABLE mixed_compressed; DROP TABLE compressed_chunks; DROP TABLE compression_info; DROP TABLE uuid_part; RESET timescaledb.enable_uuid_compression; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/continuous_aggs-15.out�����������������������������������������0000664�0000000�0000000�00000273120�15100345067�0023625�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.continuous_aggs_find_view(cagg REGCLASS) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_continuous_agg_find_by_view_name' LANGUAGE C; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --TEST1 --- --basic test with count create table foo (a integer, b integer, c integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo insert into foo values( 3 , 16 , 20); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select a, count(b) from foo group by time_bucket(1, a), a WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2::integer, '12 h'::interval) AS job_id \gset SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 2, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select a, count(b), time_bucket(1, a) from foo group by time_bucket(1, a) , a ; select * from mat_m1 order by a ; a | countb ---+-------- 1 | 5 2 | 3 3 | 1 --check triggers on user hypertable -- SET ROLE :ROLE_SUPERUSER; select tgname, tgtype, tgenabled , relname from pg_trigger, pg_class where tgrelid = pg_class.oid and pg_class.relname like 'foo' order by tgname; tgname | tgtype | tgenabled | relname --------+--------+-----------+--------- SET ROLE :ROLE_DEFAULT_PERM_USER; -- TEST2 --- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk SHOW enable_partitionwise_aggregate; enable_partitionwise_aggregate -------------------------------- off SET enable_partitionwise_aggregate = on; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Change `finalized` option is forbiden \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=false); ERROR: cannot alter finalized option for continuous aggregates ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=true); ERROR: cannot alter finalized option for continuous aggregates \set ON_ERROR_STOP 1 -- Materialized hypertable for mat_m1 should not be visible in the -- hypertables view: SELECT hypertable_schema, hypertable_name FROM timescaledb_information.hypertables ORDER BY 1,2; hypertable_schema | hypertable_name -------------------+----------------- public | conditions public | foo SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumt, sumh from mat_m1 order by timec; timec | minl | sumt | sumh ------------------------------+------+------+------ Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) order by 1; time_bucket | min | sum | sum ------------------------------+-----+-----+----- Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 SET enable_partitionwise_aggregate = off; -- TEST3 -- -- drop on table conditions should cascade to materialized mat_v1 drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-03 09:00:00-08', 'NYC', 45, 55); insert into conditions values ( '2010-01-05 09:00:00-08', 'SFO', 75, 100); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); insert into conditions values ( '2018-11-03 09:00:00-08', 'NYC', 35, 25); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST4 -- --materialized view with group by clause + expression in SELECT -- use previous data from conditions --drop only the view. -- apply where clause on result of mat_m1 -- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 where stddevh is not null order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST5 -- ---------test with having clause ---------------------- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects create materialized view mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null WITH NO DATA; ; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null; SET ROLE :ROLE_DEFAULT_PERM_USER; -- should have same results -- select * from mat_m1 order by sumth; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null order by sum(temperature)+sum(humidity); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 -- TEST6 -- --group by with more than 1 group column -- having clause with a mix of columns from select list + others drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp numeric NULL, highp numeric null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, 71, 28; --naming with AS clauses CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) as bucket, location as loc, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by bucket, loc having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with default names CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+------------- 1 | time_bucket 2 | location 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with view col names CREATE MATERIALIZED VIEW mat_naming(bucket, loc, sum_t_h, stdd) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity), stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sum_t_h 4 | stdd DROP MATERIALIZED VIEW mat_naming; CREATE MATERIALIZED VIEW mat_m1(timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | timec 2 | minl 3 | sumth 4 | stddevh SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec, minl; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 and avg(lowp) > 10 order by time_bucket('1week', timec), min(location); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 --check view defintion in information views select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like 'mat_m1'; view_name | view_definition -----------+----------------------------------------------------------------------------------------------------------------- mat_m1 | SELECT time_bucket('@ 7 days'::interval, conditions.timec) AS timec, + | min(conditions.location) AS minl, + | (sum(conditions.temperature) + sum(conditions.humidity)) AS sumth, + | stddev(conditions.humidity) AS stddevh + | FROM conditions + | GROUP BY (time_bucket('@ 7 days'::interval, conditions.timec)) + | HAVING ((min(conditions.location) >= 'NYC'::text) AND (avg(conditions.temperature) > (20)::double precision)); --TEST6 -- select from internal view SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select * from :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; SET ROLE :ROLE_DEFAULT_PERM_USER; --lets drop the view and check DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_24_chunk drop table conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT $$ select time_bucket('1week', timec) , min(location) as col1, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: materialized view "mat_test" does not exist, skipping ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 SELECT $$ select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by location, time_bucket('1week', timec) $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_34_chunk ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 --TEST7 -- drop tests for view and hypertable --DROP tests \set ON_ERROR_STOP 0 SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_test' \gset DROP TABLE :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; ERROR: cannot drop table _timescaledb_internal._materialized_hypertable_16 because other objects depend on it DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate DROP VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate \set ON_ERROR_STOP 1 --catalog entry still there; SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 1 --mat table, user_view, direct view and partial view all there select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 1 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = 'mat_test'; count ------- 1 DROP MATERIALIZED VIEW mat_test; NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 0 --mat table, user_view, direct view and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_test'; count ------- 0 --test dropping raw table DROP TABLE conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions --no data in hyper table on purpose so that CASCADE is not required because of chunks CREATE MATERIALIZED VIEW mat_drop_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; \set ON_ERROR_STOP 0 DROP TABLE conditions; ERROR: cannot drop table conditions because other objects depend on it \set ON_ERROR_STOP 1 --insert data now insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_drop_test' \gset SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_drop_test', NULL, NULL); --force invalidation insert into conditions select generate_series('2017-11-01 00:00'::timestamp, '2017-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 1 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 1 DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_drop_test'; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 0 SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --mat table, user_view, and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_drop_test'; count ------- 0 --TEST With options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, '5 h'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT alter_job(id, schedule_interval => '1h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1001,"@ 1 hour","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 1 hour SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1001,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test') order by indexname; indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_20_timec_idx | CREATE INDEX _materialized_hypertable_20_timec_idx ON _timescaledb_internal._materialized_hypertable_20 USING btree (timec DESC) DROP MATERIALIZED VIEW mat_with_test; --no additional indexes CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true, timescaledb.create_group_indexes=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test'); indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_21_timec_idx | CREATE INDEX _materialized_hypertable_21_timec_idx ON _timescaledb_internal._materialized_hypertable_21 USING btree (timec DESC) DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, 500::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1002,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": 500, ""start_offset"": null, ""mat_hypertable_id"": 23}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1002]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test space partitions CREATE TABLE space_table ( time BIGINT, dev BIGINT, data BIGINT ); SELECT create_hypertable( 'space_table', 'time', chunk_time_interval => 10, partitioning_column => 'dev', number_partitions => 3); create_hypertable --------------------------- (24,public,space_table,t) CREATE OR REPLACE FUNCTION integer_now_space_table() returns BIGINT LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), BIGINT '0') FROM space_table $$; SELECT set_integer_now_func('space_table', 'integer_now_space_table'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW space_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('4', time), COUNT(data) FROM space_table GROUP BY 1 WITH NO DATA; INSERT INTO space_table VALUES (0, 1, 1), (0, 2, 1), (1, 1, 1), (1, 2, 1), (10, 1, 1), (10, 2, 1), (11, 1, 1), (11, 2, 1); SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'space_view' \gset SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 4 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 4 8 | 4 INSERT INTO space_table VALUES (3, 2, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 5 8 | 4 INSERT INTO space_table VALUES (2, 3, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 6 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 6 8 | 4 DROP TABLE space_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_25_60_chunk -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, c int, d int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type % %', pg_typeof(d), pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, c int, d int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, int, int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- insert into conditions select generate_series(0, 200, 10), 'POR', 55, 75, 40, 70, NULL; CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 1, 3, 'test'::text) from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer text WARNING: type integer text WARNING: type integer text SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | DROP MATERIALIZED view mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_65_chunk CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 4, 5, bigint '123') from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer bigint WARNING: type integer bigint WARNING: type integer bigint SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | --refresh mat view test when time_bucket is not projected -- DROP MATERIALIZED VIEW mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_28_66_chunk CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); SELECT * FROM mat_refresh_test order by 1,2 ; location | max ----------+----- NYC | 75 POR | 75 POR | 75 POR | 75 -- test for bug when group by is not in project list CREATE MATERIALIZED VIEW conditions_grpby_view with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location; NOTICE: refreshing continuous aggregate "conditions_grpby_view" select * from conditions_grpby_view order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 CREATE MATERIALIZED VIEW conditions_grpby_view2 with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location having avg(temperature) > 0; NOTICE: refreshing continuous aggregate "conditions_grpby_view2" select * from conditions_grpby_view2 order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 -- Test internal functions for continuous aggregates SELECT test.continuous_aggs_find_view('mat_refresh_test'); continuous_aggs_find_view --------------------------- -- Test pseudotype/enum handling CREATE TYPE status_enum AS ENUM ( 'red', 'yellow', 'green' ); CREATE TABLE cagg_types ( time TIMESTAMPTZ NOT NULL, status status_enum, names NAME[], floats FLOAT[] ); SELECT table_name FROM create_hypertable('cagg_types', 'time'); table_name ------------ cagg_types INSERT INTO cagg_types SELECT '2000-01-01', 'yellow', '{foo,bar,baz}', '{1,2.5,3}'; CREATE MATERIALIZED VIEW mat_types WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time), min(status) AS status, max(names) AS names, min(floats) AS floats FROM cagg_types GROUP BY 1; NOTICE: refreshing continuous aggregate "mat_types" CALL refresh_continuous_aggregate('mat_types',NULL,NULL); NOTICE: continuous aggregate "mat_types" is already up-to-date SELECT * FROM mat_types; time_bucket | status | names | floats ------------------------------+--------+---------------+----------- Fri Dec 31 16:00:00 1999 PST | yellow | {foo,bar,baz} | {1,2.5,3} ------------------------------------------------------------------------------------- -- Test issue #2616 where cagg view contains an experssion with several aggregates in CREATE TABLE water_consumption ( sensor_id integer NOT NULL, timestamp timestamp(0) NOT NULL, water_index integer ); SELECT create_hypertable('water_consumption', 'timestamp', 'sensor_id', 2); WARNING: column type "timestamp without time zone" used for "timestamp" does not follow best practices create_hypertable --------------------------------- (34,public,water_consumption,t) INSERT INTO public.water_consumption (sensor_id, timestamp, water_index) VALUES (1, '2010-11-03 09:42:30', 1030), (1, '2010-11-03 09:42:40', 1032), (1, '2010-11-03 09:42:50', 1035), (1, '2010-11-03 09:43:30', 1040), (1, '2010-11-03 09:43:40', 1045), (1, '2010-11-03 09:43:50', 1050), (1, '2010-11-03 09:44:30', 1052), (1, '2010-11-03 09:44:40', 1057), (1, '2010-11-03 09:44:50', 1060), (1, '2010-11-03 09:45:30', 1063), (1, '2010-11-03 09:45:40', 1067), (1, '2010-11-03 09:45:50', 1070); -- The test with the view originally reported in the issue. CREATE MATERIALIZED VIEW water_consumption_aggregation_minute WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_minute', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_minute ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 -- Simplified test, where the view doesn't contain all group by clauses CREATE MATERIALIZED VIEW water_consumption_no_select_bucket WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_no_select_bucket', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_no_select_bucket ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 -- The test with SELECT matching GROUP BY and placing aggregate expression not the last CREATE MATERIALIZED VIEW water_consumption_aggregation_no_addition WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_no_addition', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_no_addition ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 DROP TABLE water_consumption CASCADE; NOTICE: drop cascades to 6 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_35_73_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_36_74_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_37_75_chunk ---- --- github issue 2655 --- create table raw_data(time timestamptz, search_query text, cnt integer, cnt2 integer); select create_hypertable('raw_data','time', chunk_time_interval=>'15 days'::interval); create_hypertable ------------------------ (38,public,raw_data,t) insert into raw_data select '2000-01-01','Q1'; --having has exprs that appear in select CREATE MATERIALIZED VIEW search_query_count_1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1; NOTICE: refreshing continuous aggregate "search_query_count_1m" --having has aggregates + grp by columns that appear in select CREATE MATERIALIZED VIEW search_query_count_2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1 OR ( sum(cnt) + count(cnt)) > 1 AND search_query = 'Q1'; NOTICE: refreshing continuous aggregate "search_query_count_2" CREATE MATERIALIZED VIEW search_query_count_3 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY cnt +cnt2 , bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: refreshing continuous aggregate "search_query_count_3" insert into raw_data select '2000-01-01 00:00+0','Q1', 1, 100; insert into raw_data select '2000-01-01 00:00+0','Q1', 2, 200; insert into raw_data select '2000-01-01 00:00+0','Q1', 3, 300; insert into raw_data select '2000-01-02 00:00+0','Q2', 10, 10; insert into raw_data select '2000-01-02 00:00+0','Q2', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST --only 1 of these should appear in the result insert into raw_data select '2000-01-02 00:00+0','Q3', 0, 0; insert into raw_data select '2000-01-03 00:00+0','Q4', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_2--- CALL refresh_continuous_aggregate('search_query_count_2', NULL, NULL); SELECT * FROM search_query_count_2 ORDER BY 1, 2; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 3 | 6 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | 30 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_3--- CALL refresh_continuous_aggregate('search_query_count_3', NULL, NULL); SELECT * FROM search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --- TEST enable compression on continuous aggregates CREATE VIEW cagg_compression_status as SELECT ca.mat_hypertable_id AS mat_htid, ca.user_view_name AS cagg_name , h.schema_name AS mat_schema_name, h.table_name AS mat_table_name, ca.materialized_only FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) ; SELECT mat_htid AS "MAT_HTID" , mat_schema_name || '.' || mat_table_name AS "MAT_HTNAME" , mat_table_name AS "MAT_TABLE_NAME" FROM cagg_compression_status WHERE cagg_name = 'search_query_count_3' \gset ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'true'); NOTICE: defaulting compress_segmentby to search_query NOTICE: defaulting compress_orderby to bucket SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 \x SELECT * FROM timescaledb_information.compression_settings WHERE hypertable_name = :'MAT_TABLE_NAME'; -[ RECORD 1 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | search_query segmentby_column_index | 1 orderby_column_index | orderby_asc | orderby_nullsfirst | -[ RECORD 2 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | bucket segmentby_column_index | orderby_column_index | 1 orderby_asc | t orderby_nullsfirst | f \x SELECT compress_chunk(ch) FROM show_chunks('search_query_count_3') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk SELECT * from search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST -- insert into a new region of the hypertable and then refresh the cagg -- (note we still do not support refreshes into existing regions. -- cagg chunks do not map 1-1 to hypertabl regions. They encompass -- more data -- ). insert into raw_data select '2000-05-01 00:00+0','Q3', 0, 0; -- On PG >= 14 the refresh test below will pass because we added support for UPDATE/DELETE on compressed chunks in PR #5339 \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('search_query_count_3', NULL, '2000-06-01 00:00+0'::timestamptz); CALL refresh_continuous_aggregate('search_query_count_3', '2000-05-01 00:00+0'::timestamptz, '2000-06-01 00:00+0'::timestamptz); NOTICE: continuous aggregate "search_query_count_3" is already up-to-date \set ON_ERROR_STOP 1 --insert row insert into raw_data select '2001-05-10 00:00+0','Q3', 100, 100; --this should succeed since it does not refresh any compressed regions in the cagg CALL refresh_continuous_aggregate('search_query_count_3', '2001-05-01 00:00+0'::timestamptz, '2001-06-01 00:00+0'::timestamptz); --verify watermark and check that chunks are compressed SELECT _timescaledb_functions.to_timestamp(w) FROM _timescaledb_functions.cagg_watermark(:'MAT_HTID') w; to_timestamp ------------------------------ Wed May 09 17:01:00 2001 PDT SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; chunk_name | range_start | range_end | is_compressed --------------------+------------------------------+------------------------------+--------------- _hyper_41_79_chunk | Fri Dec 24 16:00:00 1999 PST | Mon May 22 17:00:00 2000 PDT | t _hyper_41_83_chunk | Sun Mar 18 16:00:00 2001 PST | Wed Aug 15 17:00:00 2001 PDT | f SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log WHERE materialization_id = :'MAT_HTID' ORDER BY 1, 2,3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 41 | -9223372036854775808 | -210866803200000001 41 | 959817600000000 | 988675199999999 41 | 991353600000000 | 9223372036854775807 SELECT * from search_query_count_3 WHERE bucket > '2001-01-01' ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q3 | 1 | 100 | Wed May 09 17:00:00 2001 PDT --now disable compression , will error out -- \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); ERROR: cannot disable columnstore on hypertable with columnstore chunks \set ON_ERROR_STOP 1 SELECT decompress_chunk(format('%I.%I', schema_name, table_name)) FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'MAT_HTID' and status = 1; decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk --disable compression on cagg after decompressing all chunks-- ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'search_query_count_3'; view_name | materialized_only | compression_enabled ----------------------+-------------------+--------------------- search_query_count_3 | f | f -- TEST caggs on table with more columns than in the cagg view defn -- CREATE TABLE test_morecols ( time TIMESTAMPTZ NOT NULL, val1 INTEGER, val2 INTEGER, val3 INTEGER, val4 INTEGER, val5 INTEGER, val6 INTEGER, val7 INTEGER, val8 INTEGER); SELECT create_hypertable('test_morecols', 'time', chunk_time_interval=> '7 days'::interval); create_hypertable ----------------------------- (43,public,test_morecols,t) INSERT INTO test_morecols SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 55, 75, 40, 70, NULL, 100, 200, 200; CREATE MATERIALIZED VIEW test_morecols_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('30 days',time), avg(val1), count(val2) FROM test_morecols GROUP BY 1; NOTICE: refreshing continuous aggregate "test_morecols_cagg" ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT compress_chunk(ch) FROM show_chunks('test_morecols_cagg') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_44_89_chunk SELECT * FROM test_morecols_cagg ORDER BY time_bucket; time_bucket | avg | count ------------------------------+---------------------+------- Fri Nov 23 16:00:00 2018 PST | 55.0000000000000000 | 23 Sun Dec 23 16:00:00 2018 PST | 55.0000000000000000 | 8 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | f | t --should keep compressed option, modify only materialized -- ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.materialized_only='true'); SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | t | t CREATE TABLE issue3248(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON issue3248(time DESC); CREATE INDEX ON issue3248(device_id,time DESC); SELECT create_hypertable('issue3248','time',create_default_indexes:=false); create_hypertable ------------------------- (46,public,issue3248,t) ALTER TABLE issue3248 DROP COLUMN filler_1; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_2; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_3; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE issue3248; CREATE materialized view issue3248_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), device_id, min(v0), max(v1), avg(v2) FROM issue3248 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "issue3248_cagg" SELECT FROM issue3248 AS m, LATERAL(SELECT m FROM issue3248_cagg WHERE avg IS NULL LIMIT 1) AS lat; -- -- test that option create_group_indexes is taken into account CREATE TABLE test_group_idx ( time timestamptz, symbol int, value numeric ); select create_hypertable('test_group_idx', 'time'); create_hypertable ------------------------------ (48,public,test_group_idx,t) insert into test_group_idx select t, round(random()*10), random()*5 from generate_series('2020-01-01', '2020-02-25', INTERVAL '12 hours') t; create materialized view cagg_index_true with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=true) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_true" create materialized view cagg_index_false with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_false" create materialized view cagg_index_default with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_default" -- see corresponding materialization_hypertables select view_name, materialization_hypertable_name from timescaledb_information.continuous_aggregates ca where view_name like 'cagg_index_%' ORDER BY view_name; view_name | materialization_hypertable_name --------------------+--------------------------------- cagg_index_default | _materialized_hypertable_51 cagg_index_false | _materialized_hypertable_50 cagg_index_true | _materialized_hypertable_49 -- now make sure a group index has been created when explicitly asked for \x on select i.* from pg_indexes i join pg_class c on schemaname = relnamespace::regnamespace::text and tablename = relname where tablename in (select materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name like 'cagg_index_%') order by tablename, indexname; -[ RECORD 1 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (bucket DESC) -[ RECORD 2 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (symbol, bucket DESC) -[ RECORD 3 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_50 indexname | _materialized_hypertable_50_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_50_bucket_idx ON _timescaledb_internal._materialized_hypertable_50 USING btree (bucket DESC) -[ RECORD 4 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (bucket DESC) -[ RECORD 5 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (symbol, bucket DESC) \x off -- -- TESTs for removing old CAggs restrictions -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 8 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_29_67_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_30_68_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_31_69_chunk CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'timec'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-03 09:00:00-08', 'NYC', 45, 55), ('2010-01-05 09:00:00-08', 'SFO', 75, 100), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15), ('2018-11-03 09:00:00-08', 'NYC', 35, 25); -- aggregate with DISTINCT CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(DISTINCT temperature) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2, 3; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 1 | 100 Sun Dec 27 16:00:00 2009 PST | 2 | 110 Sun Dec 27 16:00:00 2009 PST | 2 | 120 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 80 -- aggregate with FILTER DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), SUM(temperature) FILTER (WHERE humidity > 60) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | sum ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 100 Sun Dec 27 16:00:00 2009 PST | Sun Dec 27 16:00:00 2009 PST | Sun Jan 03 16:00:00 2010 PST | 75 Sun Oct 28 17:00:00 2018 PDT | -- aggregate with filter in having clause DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MAX(temperature) FROM conditions GROUP BY time_bucket('1week', timec), location HAVING SUM(temperature) FILTER (WHERE humidity > 40) > 50; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | max ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 100 Sun Jan 03 16:00:00 2010 PST | 75 -- ordered set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_55_116_chunk CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MODE() WITHIN GROUP(ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | mode ------------------------------+------ Sun Dec 27 16:00:00 2009 PST | 45 Sun Jan 03 16:00:00 2010 PST | 100 Sun Oct 28 17:00:00 2018 PDT | 15 -- hypothetical-set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), RANK(60) WITHIN GROUP (ORDER BY humidity), DENSE_RANK(60) WITHIN GROUP (ORDER BY humidity), PERCENT_RANK(60) WITHIN GROUP (ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | rank | dense_rank | percent_rank ------------------------------+------+------------+-------------- Sun Dec 27 16:00:00 2009 PST | 5 | 3 | 0.8 Sun Jan 03 16:00:00 2010 PST | 1 | 1 | 0 Sun Oct 28 17:00:00 2018 PDT | 4 | 4 | 1 -- userdefined aggregate without combine function DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE AGGREGATE newavg ( sfunc = int4_avg_accum, basetype = int4, stype = _int8, finalfunc = int8_avg, initcond1 = '{0,0}' ); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT SUM(humidity), round(newavg(temperature::int4)) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; sum | round -----+------- 75 | 38 90 | 60 100 | 55 100 | 75 100 | 100 -- ORDER BY in the view definition DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(temperature) FROM conditions GROUP BY time_bucket('1week', timec) ORDER BY sum DESC; NOTICE: refreshing continuous aggregate "mat_m1" -- CAgg definition for realtime SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ( SELECT _materialized_hypertable_59.time_bucket, + _materialized_hypertable_59.count, + _materialized_hypertable_59.sum + FROM _timescaledb_internal._materialized_hypertable_59 + WHERE _materialized_hypertable_59.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone)+ ORDER BY _materialized_hypertable_59.sum DESC) + UNION ALL + ( SELECT time_bucket('@ 7 days'::interval, conditions.timec) AS time_bucket, + count(conditions.location) AS count, + sum(conditions.temperature) AS sum + FROM conditions + WHERE conditions.timec >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 7 days'::interval, conditions.timec)) + ORDER BY (sum(conditions.temperature)) DESC) + ORDER BY 3 DESC; -- Ordered result SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Insert new data and query again to make sure we produce ordered data INSERT INTO conditions VALUES ('2018-11-10 09:00:00-08', 'SFO', 10, 10); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 1 | 10 -- This new row will change the order again INSERT INTO conditions VALUES ('2018-11-11 09:00:00-08', 'SFO', 400, 400); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Change the type of cagg ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); -- CAgg definition for materialized only SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------- SELECT _materialized_hypertable_59.time_bucket, + _materialized_hypertable_59.count, + _materialized_hypertable_59.sum + FROM _timescaledb_internal._materialized_hypertable_59+ ORDER BY _materialized_hypertable_59.sum DESC; -- Now the query will show only the materialized data, without last two -- records inserted into the original hypertable (last two insers above) SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Invalidate old region and refresh again DELETE FROM conditions WHERE timec < '2010-01-05 09:00:00-08'; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); -- Querying the cagg produce ordered records as expected SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Querying direct the materialization hypertable doesn't -- produce ordered records SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Nov 04 16:00:00 2018 PST | 2 | 410 -- -- Testing the coexistence of both types of supported CAggs -- over the same raw hypertable. -- -- . finalized = true: without chunk_id and partials -- . finalized = false: with chunk_id and partials -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW conditions_summary_new(timec, minl, sumt, sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) FROM conditions GROUP BY time_bucket('1day', timec) WITH NO DATA; \x ON SELECT * FROM timescaledb_information.continuous_aggregates WHERE view_name = 'conditions_summary_new'; -[ RECORD 1 ]---------------------+--------------------------------------------------------------------- hypertable_schema | public hypertable_name | conditions view_schema | public view_name | conditions_summary_new view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_61 view_definition | SELECT time_bucket('@ 1 day'::interval, conditions.timec) AS timec,+ | min(conditions.location) AS minl, + | sum(conditions.temperature) AS sumt, + | sum(conditions.humidity) AS sumh + | FROM conditions + | GROUP BY (time_bucket('@ 1 day'::interval, conditions.timec)); finalized | t \x OFF CALL refresh_continuous_aggregate('conditions_summary_new', NULL, NULL); -- Check and compare number of returned rows SELECT count(*) FROM conditions_summary_new; count ------- 4 -- Parallel planning test for realtime Continuous Aggregate DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions SELECT t, 10 FROM generate_series('2023-01-01 00:00-03'::timestamptz, '2023-12-31 23:59-03'::timestamptz, '1 hour'::interval) AS t; CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', timec), SUM(temperature) FROM conditions GROUP BY 1 ORDER BY 2 DESC; NOTICE: refreshing continuous aggregate "conditions_daily" SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; -- Parallel planning EXPLAIN (BUFFERS OFF, COSTS OFF, TIMING OFF) SELECT * FROM conditions_daily WHERE time_bucket >= '2023-07-01'; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_63.sum DESC -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _materialized_hypertable_63.sum DESC -> Parallel Append -> Parallel Index Scan using _hyper_63_183_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_183_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_187_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_187_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_188_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_188_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Sort Sort Key: (sum(_hyper_62_182_chunk.temperature)) DESC -> HashAggregate Group Key: (time_bucket('@ 1 day'::interval, _hyper_62_182_chunk.timec)) -> Gather Workers Planned: 1 -> Result -> Parallel Index Scan Backward using _hyper_62_182_chunk_conditions_timec_idx on _hyper_62_182_chunk Index Cond: ((timec >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (timec >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, timec) >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/continuous_aggs-16.out�����������������������������������������0000664�0000000�0000000�00000272441�15100345067�0023633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.continuous_aggs_find_view(cagg REGCLASS) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_continuous_agg_find_by_view_name' LANGUAGE C; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --TEST1 --- --basic test with count create table foo (a integer, b integer, c integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo insert into foo values( 3 , 16 , 20); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select a, count(b) from foo group by time_bucket(1, a), a WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2::integer, '12 h'::interval) AS job_id \gset SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 2, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select a, count(b), time_bucket(1, a) from foo group by time_bucket(1, a) , a ; select * from mat_m1 order by a ; a | countb ---+-------- 1 | 5 2 | 3 3 | 1 --check triggers on user hypertable -- SET ROLE :ROLE_SUPERUSER; select tgname, tgtype, tgenabled , relname from pg_trigger, pg_class where tgrelid = pg_class.oid and pg_class.relname like 'foo' order by tgname; tgname | tgtype | tgenabled | relname --------+--------+-----------+--------- SET ROLE :ROLE_DEFAULT_PERM_USER; -- TEST2 --- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk SHOW enable_partitionwise_aggregate; enable_partitionwise_aggregate -------------------------------- off SET enable_partitionwise_aggregate = on; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Change `finalized` option is forbiden \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=false); ERROR: cannot alter finalized option for continuous aggregates ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=true); ERROR: cannot alter finalized option for continuous aggregates \set ON_ERROR_STOP 1 -- Materialized hypertable for mat_m1 should not be visible in the -- hypertables view: SELECT hypertable_schema, hypertable_name FROM timescaledb_information.hypertables ORDER BY 1,2; hypertable_schema | hypertable_name -------------------+----------------- public | conditions public | foo SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumt, sumh from mat_m1 order by timec; timec | minl | sumt | sumh ------------------------------+------+------+------ Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) order by 1; time_bucket | min | sum | sum ------------------------------+-----+-----+----- Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 SET enable_partitionwise_aggregate = off; -- TEST3 -- -- drop on table conditions should cascade to materialized mat_v1 drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-03 09:00:00-08', 'NYC', 45, 55); insert into conditions values ( '2010-01-05 09:00:00-08', 'SFO', 75, 100); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); insert into conditions values ( '2018-11-03 09:00:00-08', 'NYC', 35, 25); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST4 -- --materialized view with group by clause + expression in SELECT -- use previous data from conditions --drop only the view. -- apply where clause on result of mat_m1 -- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 where stddevh is not null order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST5 -- ---------test with having clause ---------------------- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects create materialized view mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null WITH NO DATA; ; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null; SET ROLE :ROLE_DEFAULT_PERM_USER; -- should have same results -- select * from mat_m1 order by sumth; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null order by sum(temperature)+sum(humidity); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 -- TEST6 -- --group by with more than 1 group column -- having clause with a mix of columns from select list + others drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp numeric NULL, highp numeric null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, 71, 28; --naming with AS clauses CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) as bucket, location as loc, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by bucket, loc having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with default names CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+------------- 1 | time_bucket 2 | location 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with view col names CREATE MATERIALIZED VIEW mat_naming(bucket, loc, sum_t_h, stdd) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity), stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sum_t_h 4 | stdd DROP MATERIALIZED VIEW mat_naming; CREATE MATERIALIZED VIEW mat_m1(timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | timec 2 | minl 3 | sumth 4 | stddevh SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec, minl; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 and avg(lowp) > 10 order by time_bucket('1week', timec), min(location); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 --check view defintion in information views select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like 'mat_m1'; view_name | view_definition -----------+------------------------------------------------------------------------------------------- mat_m1 | SELECT time_bucket('@ 7 days'::interval, timec) AS timec, + | min(location) AS minl, + | (sum(temperature) + sum(humidity)) AS sumth, + | stddev(humidity) AS stddevh + | FROM conditions + | GROUP BY (time_bucket('@ 7 days'::interval, timec)) + | HAVING ((min(location) >= 'NYC'::text) AND (avg(temperature) > (20)::double precision)); --TEST6 -- select from internal view SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select * from :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; SET ROLE :ROLE_DEFAULT_PERM_USER; --lets drop the view and check DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_24_chunk drop table conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT $$ select time_bucket('1week', timec) , min(location) as col1, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: materialized view "mat_test" does not exist, skipping ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 SELECT $$ select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by location, time_bucket('1week', timec) $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_34_chunk ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 --TEST7 -- drop tests for view and hypertable --DROP tests \set ON_ERROR_STOP 0 SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_test' \gset DROP TABLE :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; ERROR: cannot drop table _timescaledb_internal._materialized_hypertable_16 because other objects depend on it DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate DROP VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate \set ON_ERROR_STOP 1 --catalog entry still there; SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 1 --mat table, user_view, direct view and partial view all there select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 1 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = 'mat_test'; count ------- 1 DROP MATERIALIZED VIEW mat_test; NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 0 --mat table, user_view, direct view and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_test'; count ------- 0 --test dropping raw table DROP TABLE conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions --no data in hyper table on purpose so that CASCADE is not required because of chunks CREATE MATERIALIZED VIEW mat_drop_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; \set ON_ERROR_STOP 0 DROP TABLE conditions; ERROR: cannot drop table conditions because other objects depend on it \set ON_ERROR_STOP 1 --insert data now insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_drop_test' \gset SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_drop_test', NULL, NULL); --force invalidation insert into conditions select generate_series('2017-11-01 00:00'::timestamp, '2017-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 1 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 1 DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_drop_test'; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 0 SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --mat table, user_view, and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_drop_test'; count ------- 0 --TEST With options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, '5 h'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT alter_job(id, schedule_interval => '1h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1001,"@ 1 hour","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 1 hour SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1001,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test') order by indexname; indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_20_timec_idx | CREATE INDEX _materialized_hypertable_20_timec_idx ON _timescaledb_internal._materialized_hypertable_20 USING btree (timec DESC) DROP MATERIALIZED VIEW mat_with_test; --no additional indexes CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true, timescaledb.create_group_indexes=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test'); indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_21_timec_idx | CREATE INDEX _materialized_hypertable_21_timec_idx ON _timescaledb_internal._materialized_hypertable_21 USING btree (timec DESC) DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, 500::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1002,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": 500, ""start_offset"": null, ""mat_hypertable_id"": 23}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1002]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test space partitions CREATE TABLE space_table ( time BIGINT, dev BIGINT, data BIGINT ); SELECT create_hypertable( 'space_table', 'time', chunk_time_interval => 10, partitioning_column => 'dev', number_partitions => 3); create_hypertable --------------------------- (24,public,space_table,t) CREATE OR REPLACE FUNCTION integer_now_space_table() returns BIGINT LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), BIGINT '0') FROM space_table $$; SELECT set_integer_now_func('space_table', 'integer_now_space_table'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW space_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('4', time), COUNT(data) FROM space_table GROUP BY 1 WITH NO DATA; INSERT INTO space_table VALUES (0, 1, 1), (0, 2, 1), (1, 1, 1), (1, 2, 1), (10, 1, 1), (10, 2, 1), (11, 1, 1), (11, 2, 1); SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'space_view' \gset SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 4 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 4 8 | 4 INSERT INTO space_table VALUES (3, 2, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 5 8 | 4 INSERT INTO space_table VALUES (2, 3, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 6 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 6 8 | 4 DROP TABLE space_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_25_60_chunk -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, c int, d int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type % %', pg_typeof(d), pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, c int, d int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, int, int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- insert into conditions select generate_series(0, 200, 10), 'POR', 55, 75, 40, 70, NULL; CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 1, 3, 'test'::text) from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer text WARNING: type integer text WARNING: type integer text SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | DROP MATERIALIZED view mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_65_chunk CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 4, 5, bigint '123') from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer bigint WARNING: type integer bigint WARNING: type integer bigint SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | --refresh mat view test when time_bucket is not projected -- DROP MATERIALIZED VIEW mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_28_66_chunk CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); SELECT * FROM mat_refresh_test order by 1,2 ; location | max ----------+----- NYC | 75 POR | 75 POR | 75 POR | 75 -- test for bug when group by is not in project list CREATE MATERIALIZED VIEW conditions_grpby_view with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location; NOTICE: refreshing continuous aggregate "conditions_grpby_view" select * from conditions_grpby_view order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 CREATE MATERIALIZED VIEW conditions_grpby_view2 with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location having avg(temperature) > 0; NOTICE: refreshing continuous aggregate "conditions_grpby_view2" select * from conditions_grpby_view2 order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 -- Test internal functions for continuous aggregates SELECT test.continuous_aggs_find_view('mat_refresh_test'); continuous_aggs_find_view --------------------------- -- Test pseudotype/enum handling CREATE TYPE status_enum AS ENUM ( 'red', 'yellow', 'green' ); CREATE TABLE cagg_types ( time TIMESTAMPTZ NOT NULL, status status_enum, names NAME[], floats FLOAT[] ); SELECT table_name FROM create_hypertable('cagg_types', 'time'); table_name ------------ cagg_types INSERT INTO cagg_types SELECT '2000-01-01', 'yellow', '{foo,bar,baz}', '{1,2.5,3}'; CREATE MATERIALIZED VIEW mat_types WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time), min(status) AS status, max(names) AS names, min(floats) AS floats FROM cagg_types GROUP BY 1; NOTICE: refreshing continuous aggregate "mat_types" CALL refresh_continuous_aggregate('mat_types',NULL,NULL); NOTICE: continuous aggregate "mat_types" is already up-to-date SELECT * FROM mat_types; time_bucket | status | names | floats ------------------------------+--------+---------------+----------- Fri Dec 31 16:00:00 1999 PST | yellow | {foo,bar,baz} | {1,2.5,3} ------------------------------------------------------------------------------------- -- Test issue #2616 where cagg view contains an experssion with several aggregates in CREATE TABLE water_consumption ( sensor_id integer NOT NULL, timestamp timestamp(0) NOT NULL, water_index integer ); SELECT create_hypertable('water_consumption', 'timestamp', 'sensor_id', 2); WARNING: column type "timestamp without time zone" used for "timestamp" does not follow best practices create_hypertable --------------------------------- (34,public,water_consumption,t) INSERT INTO public.water_consumption (sensor_id, timestamp, water_index) VALUES (1, '2010-11-03 09:42:30', 1030), (1, '2010-11-03 09:42:40', 1032), (1, '2010-11-03 09:42:50', 1035), (1, '2010-11-03 09:43:30', 1040), (1, '2010-11-03 09:43:40', 1045), (1, '2010-11-03 09:43:50', 1050), (1, '2010-11-03 09:44:30', 1052), (1, '2010-11-03 09:44:40', 1057), (1, '2010-11-03 09:44:50', 1060), (1, '2010-11-03 09:45:30', 1063), (1, '2010-11-03 09:45:40', 1067), (1, '2010-11-03 09:45:50', 1070); -- The test with the view originally reported in the issue. CREATE MATERIALIZED VIEW water_consumption_aggregation_minute WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_minute', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_minute ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 -- Simplified test, where the view doesn't contain all group by clauses CREATE MATERIALIZED VIEW water_consumption_no_select_bucket WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_no_select_bucket', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_no_select_bucket ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 -- The test with SELECT matching GROUP BY and placing aggregate expression not the last CREATE MATERIALIZED VIEW water_consumption_aggregation_no_addition WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_no_addition', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_no_addition ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 DROP TABLE water_consumption CASCADE; NOTICE: drop cascades to 6 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_35_73_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_36_74_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_37_75_chunk ---- --- github issue 2655 --- create table raw_data(time timestamptz, search_query text, cnt integer, cnt2 integer); select create_hypertable('raw_data','time', chunk_time_interval=>'15 days'::interval); create_hypertable ------------------------ (38,public,raw_data,t) insert into raw_data select '2000-01-01','Q1'; --having has exprs that appear in select CREATE MATERIALIZED VIEW search_query_count_1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1; NOTICE: refreshing continuous aggregate "search_query_count_1m" --having has aggregates + grp by columns that appear in select CREATE MATERIALIZED VIEW search_query_count_2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1 OR ( sum(cnt) + count(cnt)) > 1 AND search_query = 'Q1'; NOTICE: refreshing continuous aggregate "search_query_count_2" CREATE MATERIALIZED VIEW search_query_count_3 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY cnt +cnt2 , bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: refreshing continuous aggregate "search_query_count_3" insert into raw_data select '2000-01-01 00:00+0','Q1', 1, 100; insert into raw_data select '2000-01-01 00:00+0','Q1', 2, 200; insert into raw_data select '2000-01-01 00:00+0','Q1', 3, 300; insert into raw_data select '2000-01-02 00:00+0','Q2', 10, 10; insert into raw_data select '2000-01-02 00:00+0','Q2', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST --only 1 of these should appear in the result insert into raw_data select '2000-01-02 00:00+0','Q3', 0, 0; insert into raw_data select '2000-01-03 00:00+0','Q4', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_2--- CALL refresh_continuous_aggregate('search_query_count_2', NULL, NULL); SELECT * FROM search_query_count_2 ORDER BY 1, 2; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 3 | 6 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | 30 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_3--- CALL refresh_continuous_aggregate('search_query_count_3', NULL, NULL); SELECT * FROM search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --- TEST enable compression on continuous aggregates CREATE VIEW cagg_compression_status as SELECT ca.mat_hypertable_id AS mat_htid, ca.user_view_name AS cagg_name , h.schema_name AS mat_schema_name, h.table_name AS mat_table_name, ca.materialized_only FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) ; SELECT mat_htid AS "MAT_HTID" , mat_schema_name || '.' || mat_table_name AS "MAT_HTNAME" , mat_table_name AS "MAT_TABLE_NAME" FROM cagg_compression_status WHERE cagg_name = 'search_query_count_3' \gset ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'true'); NOTICE: defaulting compress_segmentby to search_query NOTICE: defaulting compress_orderby to bucket SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 \x SELECT * FROM timescaledb_information.compression_settings WHERE hypertable_name = :'MAT_TABLE_NAME'; -[ RECORD 1 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | search_query segmentby_column_index | 1 orderby_column_index | orderby_asc | orderby_nullsfirst | -[ RECORD 2 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | bucket segmentby_column_index | orderby_column_index | 1 orderby_asc | t orderby_nullsfirst | f \x SELECT compress_chunk(ch) FROM show_chunks('search_query_count_3') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk SELECT * from search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST -- insert into a new region of the hypertable and then refresh the cagg -- (note we still do not support refreshes into existing regions. -- cagg chunks do not map 1-1 to hypertabl regions. They encompass -- more data -- ). insert into raw_data select '2000-05-01 00:00+0','Q3', 0, 0; -- On PG >= 14 the refresh test below will pass because we added support for UPDATE/DELETE on compressed chunks in PR #5339 \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('search_query_count_3', NULL, '2000-06-01 00:00+0'::timestamptz); CALL refresh_continuous_aggregate('search_query_count_3', '2000-05-01 00:00+0'::timestamptz, '2000-06-01 00:00+0'::timestamptz); NOTICE: continuous aggregate "search_query_count_3" is already up-to-date \set ON_ERROR_STOP 1 --insert row insert into raw_data select '2001-05-10 00:00+0','Q3', 100, 100; --this should succeed since it does not refresh any compressed regions in the cagg CALL refresh_continuous_aggregate('search_query_count_3', '2001-05-01 00:00+0'::timestamptz, '2001-06-01 00:00+0'::timestamptz); --verify watermark and check that chunks are compressed SELECT _timescaledb_functions.to_timestamp(w) FROM _timescaledb_functions.cagg_watermark(:'MAT_HTID') w; to_timestamp ------------------------------ Wed May 09 17:01:00 2001 PDT SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; chunk_name | range_start | range_end | is_compressed --------------------+------------------------------+------------------------------+--------------- _hyper_41_79_chunk | Fri Dec 24 16:00:00 1999 PST | Mon May 22 17:00:00 2000 PDT | t _hyper_41_83_chunk | Sun Mar 18 16:00:00 2001 PST | Wed Aug 15 17:00:00 2001 PDT | f SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log WHERE materialization_id = :'MAT_HTID' ORDER BY 1, 2,3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 41 | -9223372036854775808 | -210866803200000001 41 | 959817600000000 | 988675199999999 41 | 991353600000000 | 9223372036854775807 SELECT * from search_query_count_3 WHERE bucket > '2001-01-01' ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q3 | 1 | 100 | Wed May 09 17:00:00 2001 PDT --now disable compression , will error out -- \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); ERROR: cannot disable columnstore on hypertable with columnstore chunks \set ON_ERROR_STOP 1 SELECT decompress_chunk(format('%I.%I', schema_name, table_name)) FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'MAT_HTID' and status = 1; decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk --disable compression on cagg after decompressing all chunks-- ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'search_query_count_3'; view_name | materialized_only | compression_enabled ----------------------+-------------------+--------------------- search_query_count_3 | f | f -- TEST caggs on table with more columns than in the cagg view defn -- CREATE TABLE test_morecols ( time TIMESTAMPTZ NOT NULL, val1 INTEGER, val2 INTEGER, val3 INTEGER, val4 INTEGER, val5 INTEGER, val6 INTEGER, val7 INTEGER, val8 INTEGER); SELECT create_hypertable('test_morecols', 'time', chunk_time_interval=> '7 days'::interval); create_hypertable ----------------------------- (43,public,test_morecols,t) INSERT INTO test_morecols SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 55, 75, 40, 70, NULL, 100, 200, 200; CREATE MATERIALIZED VIEW test_morecols_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('30 days',time), avg(val1), count(val2) FROM test_morecols GROUP BY 1; NOTICE: refreshing continuous aggregate "test_morecols_cagg" ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT compress_chunk(ch) FROM show_chunks('test_morecols_cagg') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_44_89_chunk SELECT * FROM test_morecols_cagg ORDER BY time_bucket; time_bucket | avg | count ------------------------------+---------------------+------- Fri Nov 23 16:00:00 2018 PST | 55.0000000000000000 | 23 Sun Dec 23 16:00:00 2018 PST | 55.0000000000000000 | 8 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | f | t --should keep compressed option, modify only materialized -- ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.materialized_only='true'); SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | t | t CREATE TABLE issue3248(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON issue3248(time DESC); CREATE INDEX ON issue3248(device_id,time DESC); SELECT create_hypertable('issue3248','time',create_default_indexes:=false); create_hypertable ------------------------- (46,public,issue3248,t) ALTER TABLE issue3248 DROP COLUMN filler_1; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_2; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_3; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE issue3248; CREATE materialized view issue3248_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), device_id, min(v0), max(v1), avg(v2) FROM issue3248 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "issue3248_cagg" SELECT FROM issue3248 AS m, LATERAL(SELECT m FROM issue3248_cagg WHERE avg IS NULL LIMIT 1) AS lat; -- -- test that option create_group_indexes is taken into account CREATE TABLE test_group_idx ( time timestamptz, symbol int, value numeric ); select create_hypertable('test_group_idx', 'time'); create_hypertable ------------------------------ (48,public,test_group_idx,t) insert into test_group_idx select t, round(random()*10), random()*5 from generate_series('2020-01-01', '2020-02-25', INTERVAL '12 hours') t; create materialized view cagg_index_true with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=true) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_true" create materialized view cagg_index_false with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_false" create materialized view cagg_index_default with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_default" -- see corresponding materialization_hypertables select view_name, materialization_hypertable_name from timescaledb_information.continuous_aggregates ca where view_name like 'cagg_index_%' ORDER BY view_name; view_name | materialization_hypertable_name --------------------+--------------------------------- cagg_index_default | _materialized_hypertable_51 cagg_index_false | _materialized_hypertable_50 cagg_index_true | _materialized_hypertable_49 -- now make sure a group index has been created when explicitly asked for \x on select i.* from pg_indexes i join pg_class c on schemaname = relnamespace::regnamespace::text and tablename = relname where tablename in (select materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name like 'cagg_index_%') order by tablename, indexname; -[ RECORD 1 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (bucket DESC) -[ RECORD 2 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (symbol, bucket DESC) -[ RECORD 3 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_50 indexname | _materialized_hypertable_50_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_50_bucket_idx ON _timescaledb_internal._materialized_hypertable_50 USING btree (bucket DESC) -[ RECORD 4 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (bucket DESC) -[ RECORD 5 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (symbol, bucket DESC) \x off -- -- TESTs for removing old CAggs restrictions -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 8 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_29_67_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_30_68_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_31_69_chunk CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'timec'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-03 09:00:00-08', 'NYC', 45, 55), ('2010-01-05 09:00:00-08', 'SFO', 75, 100), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15), ('2018-11-03 09:00:00-08', 'NYC', 35, 25); -- aggregate with DISTINCT CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(DISTINCT temperature) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2, 3; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 1 | 100 Sun Dec 27 16:00:00 2009 PST | 2 | 110 Sun Dec 27 16:00:00 2009 PST | 2 | 120 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 80 -- aggregate with FILTER DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), SUM(temperature) FILTER (WHERE humidity > 60) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | sum ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 100 Sun Dec 27 16:00:00 2009 PST | Sun Dec 27 16:00:00 2009 PST | Sun Jan 03 16:00:00 2010 PST | 75 Sun Oct 28 17:00:00 2018 PDT | -- aggregate with filter in having clause DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MAX(temperature) FROM conditions GROUP BY time_bucket('1week', timec), location HAVING SUM(temperature) FILTER (WHERE humidity > 40) > 50; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | max ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 100 Sun Jan 03 16:00:00 2010 PST | 75 -- ordered set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_55_116_chunk CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MODE() WITHIN GROUP(ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | mode ------------------------------+------ Sun Dec 27 16:00:00 2009 PST | 45 Sun Jan 03 16:00:00 2010 PST | 100 Sun Oct 28 17:00:00 2018 PDT | 15 -- hypothetical-set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), RANK(60) WITHIN GROUP (ORDER BY humidity), DENSE_RANK(60) WITHIN GROUP (ORDER BY humidity), PERCENT_RANK(60) WITHIN GROUP (ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | rank | dense_rank | percent_rank ------------------------------+------+------------+-------------- Sun Dec 27 16:00:00 2009 PST | 5 | 3 | 0.8 Sun Jan 03 16:00:00 2010 PST | 1 | 1 | 0 Sun Oct 28 17:00:00 2018 PDT | 4 | 4 | 1 -- userdefined aggregate without combine function DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE AGGREGATE newavg ( sfunc = int4_avg_accum, basetype = int4, stype = _int8, finalfunc = int8_avg, initcond1 = '{0,0}' ); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT SUM(humidity), round(newavg(temperature::int4)) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; sum | round -----+------- 75 | 38 90 | 60 100 | 55 100 | 75 100 | 100 -- ORDER BY in the view definition DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(temperature) FROM conditions GROUP BY time_bucket('1week', timec) ORDER BY sum DESC; NOTICE: refreshing continuous aggregate "mat_m1" -- CAgg definition for realtime SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ( SELECT _materialized_hypertable_59.time_bucket, + _materialized_hypertable_59.count, + _materialized_hypertable_59.sum + FROM _timescaledb_internal._materialized_hypertable_59 + WHERE _materialized_hypertable_59.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone)+ ORDER BY _materialized_hypertable_59.sum DESC) + UNION ALL + ( SELECT time_bucket('@ 7 days'::interval, conditions.timec) AS time_bucket, + count(conditions.location) AS count, + sum(conditions.temperature) AS sum + FROM conditions + WHERE conditions.timec >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 7 days'::interval, conditions.timec)) + ORDER BY (sum(conditions.temperature)) DESC) + ORDER BY 3 DESC; -- Ordered result SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Insert new data and query again to make sure we produce ordered data INSERT INTO conditions VALUES ('2018-11-10 09:00:00-08', 'SFO', 10, 10); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 1 | 10 -- This new row will change the order again INSERT INTO conditions VALUES ('2018-11-11 09:00:00-08', 'SFO', 400, 400); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Change the type of cagg ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); -- CAgg definition for materialized only SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + count, + sum + FROM _timescaledb_internal._materialized_hypertable_59+ ORDER BY sum DESC; -- Now the query will show only the materialized data, without last two -- records inserted into the original hypertable (last two insers above) SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Invalidate old region and refresh again DELETE FROM conditions WHERE timec < '2010-01-05 09:00:00-08'; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); -- Querying the cagg produce ordered records as expected SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Querying direct the materialization hypertable doesn't -- produce ordered records SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Nov 04 16:00:00 2018 PST | 2 | 410 -- -- Testing the coexistence of both types of supported CAggs -- over the same raw hypertable. -- -- . finalized = true: without chunk_id and partials -- . finalized = false: with chunk_id and partials -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW conditions_summary_new(timec, minl, sumt, sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) FROM conditions GROUP BY time_bucket('1day', timec) WITH NO DATA; \x ON SELECT * FROM timescaledb_information.continuous_aggregates WHERE view_name = 'conditions_summary_new'; -[ RECORD 1 ]---------------------+---------------------------------------------------------- hypertable_schema | public hypertable_name | conditions view_schema | public view_name | conditions_summary_new view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_61 view_definition | SELECT time_bucket('@ 1 day'::interval, timec) AS timec,+ | min(location) AS minl, + | sum(temperature) AS sumt, + | sum(humidity) AS sumh + | FROM conditions + | GROUP BY (time_bucket('@ 1 day'::interval, timec)); finalized | t \x OFF CALL refresh_continuous_aggregate('conditions_summary_new', NULL, NULL); -- Check and compare number of returned rows SELECT count(*) FROM conditions_summary_new; count ------- 4 -- Parallel planning test for realtime Continuous Aggregate DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions SELECT t, 10 FROM generate_series('2023-01-01 00:00-03'::timestamptz, '2023-12-31 23:59-03'::timestamptz, '1 hour'::interval) AS t; CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', timec), SUM(temperature) FROM conditions GROUP BY 1 ORDER BY 2 DESC; NOTICE: refreshing continuous aggregate "conditions_daily" SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; -- Parallel planning EXPLAIN (BUFFERS OFF, COSTS OFF, TIMING OFF) SELECT * FROM conditions_daily WHERE time_bucket >= '2023-07-01'; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_63.sum DESC -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _materialized_hypertable_63.sum DESC -> Parallel Append -> Parallel Index Scan using _hyper_63_183_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_183_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_187_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_187_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_188_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_188_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Sort Sort Key: (sum(_hyper_62_182_chunk.temperature)) DESC -> HashAggregate Group Key: (time_bucket('@ 1 day'::interval, _hyper_62_182_chunk.timec)) -> Gather Workers Planned: 1 -> Result -> Parallel Index Scan Backward using _hyper_62_182_chunk_conditions_timec_idx on _hyper_62_182_chunk Index Cond: ((timec >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (timec >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, timec) >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/continuous_aggs-17.out�����������������������������������������0000664�0000000�0000000�00000272441�15100345067�0023634�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.continuous_aggs_find_view(cagg REGCLASS) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_continuous_agg_find_by_view_name' LANGUAGE C; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --TEST1 --- --basic test with count create table foo (a integer, b integer, c integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo insert into foo values( 3 , 16 , 20); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select a, count(b) from foo group by time_bucket(1, a), a WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2::integer, '12 h'::interval) AS job_id \gset SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 2, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select a, count(b), time_bucket(1, a) from foo group by time_bucket(1, a) , a ; select * from mat_m1 order by a ; a | countb ---+-------- 1 | 5 2 | 3 3 | 1 --check triggers on user hypertable -- SET ROLE :ROLE_SUPERUSER; select tgname, tgtype, tgenabled , relname from pg_trigger, pg_class where tgrelid = pg_class.oid and pg_class.relname like 'foo' order by tgname; tgname | tgtype | tgenabled | relname --------+--------+-----------+--------- SET ROLE :ROLE_DEFAULT_PERM_USER; -- TEST2 --- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk SHOW enable_partitionwise_aggregate; enable_partitionwise_aggregate -------------------------------- off SET enable_partitionwise_aggregate = on; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Change `finalized` option is forbiden \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=false); ERROR: cannot alter finalized option for continuous aggregates ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=true); ERROR: cannot alter finalized option for continuous aggregates \set ON_ERROR_STOP 1 -- Materialized hypertable for mat_m1 should not be visible in the -- hypertables view: SELECT hypertable_schema, hypertable_name FROM timescaledb_information.hypertables ORDER BY 1,2; hypertable_schema | hypertable_name -------------------+----------------- public | conditions public | foo SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumt, sumh from mat_m1 order by timec; timec | minl | sumt | sumh ------------------------------+------+------+------ Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) order by 1; time_bucket | min | sum | sum ------------------------------+-----+-----+----- Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 SET enable_partitionwise_aggregate = off; -- TEST3 -- -- drop on table conditions should cascade to materialized mat_v1 drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-03 09:00:00-08', 'NYC', 45, 55); insert into conditions values ( '2010-01-05 09:00:00-08', 'SFO', 75, 100); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); insert into conditions values ( '2018-11-03 09:00:00-08', 'NYC', 35, 25); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST4 -- --materialized view with group by clause + expression in SELECT -- use previous data from conditions --drop only the view. -- apply where clause on result of mat_m1 -- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 where stddevh is not null order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST5 -- ---------test with having clause ---------------------- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects create materialized view mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null WITH NO DATA; ; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null; SET ROLE :ROLE_DEFAULT_PERM_USER; -- should have same results -- select * from mat_m1 order by sumth; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null order by sum(temperature)+sum(humidity); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 -- TEST6 -- --group by with more than 1 group column -- having clause with a mix of columns from select list + others drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp numeric NULL, highp numeric null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, 71, 28; --naming with AS clauses CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) as bucket, location as loc, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by bucket, loc having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with default names CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+------------- 1 | time_bucket 2 | location 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with view col names CREATE MATERIALIZED VIEW mat_naming(bucket, loc, sum_t_h, stdd) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity), stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sum_t_h 4 | stdd DROP MATERIALIZED VIEW mat_naming; CREATE MATERIALIZED VIEW mat_m1(timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | timec 2 | minl 3 | sumth 4 | stddevh SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec, minl; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 and avg(lowp) > 10 order by time_bucket('1week', timec), min(location); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 --check view defintion in information views select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like 'mat_m1'; view_name | view_definition -----------+------------------------------------------------------------------------------------------- mat_m1 | SELECT time_bucket('@ 7 days'::interval, timec) AS timec, + | min(location) AS minl, + | (sum(temperature) + sum(humidity)) AS sumth, + | stddev(humidity) AS stddevh + | FROM conditions + | GROUP BY (time_bucket('@ 7 days'::interval, timec)) + | HAVING ((min(location) >= 'NYC'::text) AND (avg(temperature) > (20)::double precision)); --TEST6 -- select from internal view SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select * from :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; SET ROLE :ROLE_DEFAULT_PERM_USER; --lets drop the view and check DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_24_chunk drop table conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT $$ select time_bucket('1week', timec) , min(location) as col1, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: materialized view "mat_test" does not exist, skipping ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 SELECT $$ select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by location, time_bucket('1week', timec) $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_34_chunk ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 --TEST7 -- drop tests for view and hypertable --DROP tests \set ON_ERROR_STOP 0 SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_test' \gset DROP TABLE :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; ERROR: cannot drop table _timescaledb_internal._materialized_hypertable_16 because other objects depend on it DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate DROP VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate \set ON_ERROR_STOP 1 --catalog entry still there; SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 1 --mat table, user_view, direct view and partial view all there select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 1 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = 'mat_test'; count ------- 1 DROP MATERIALIZED VIEW mat_test; NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 0 --mat table, user_view, direct view and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_test'; count ------- 0 --test dropping raw table DROP TABLE conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions --no data in hyper table on purpose so that CASCADE is not required because of chunks CREATE MATERIALIZED VIEW mat_drop_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; \set ON_ERROR_STOP 0 DROP TABLE conditions; ERROR: cannot drop table conditions because other objects depend on it \set ON_ERROR_STOP 1 --insert data now insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_drop_test' \gset SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_drop_test', NULL, NULL); --force invalidation insert into conditions select generate_series('2017-11-01 00:00'::timestamp, '2017-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 1 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 1 DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_drop_test'; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 0 SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --mat table, user_view, and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_drop_test'; count ------- 0 --TEST With options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, '5 h'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT alter_job(id, schedule_interval => '1h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1001,"@ 1 hour","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 1 hour SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1001,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test') order by indexname; indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_20_timec_idx | CREATE INDEX _materialized_hypertable_20_timec_idx ON _timescaledb_internal._materialized_hypertable_20 USING btree (timec DESC) DROP MATERIALIZED VIEW mat_with_test; --no additional indexes CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true, timescaledb.create_group_indexes=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test'); indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_21_timec_idx | CREATE INDEX _materialized_hypertable_21_timec_idx ON _timescaledb_internal._materialized_hypertable_21 USING btree (timec DESC) DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, 500::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1002,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": 500, ""start_offset"": null, ""mat_hypertable_id"": 23}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1002]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test space partitions CREATE TABLE space_table ( time BIGINT, dev BIGINT, data BIGINT ); SELECT create_hypertable( 'space_table', 'time', chunk_time_interval => 10, partitioning_column => 'dev', number_partitions => 3); create_hypertable --------------------------- (24,public,space_table,t) CREATE OR REPLACE FUNCTION integer_now_space_table() returns BIGINT LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), BIGINT '0') FROM space_table $$; SELECT set_integer_now_func('space_table', 'integer_now_space_table'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW space_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('4', time), COUNT(data) FROM space_table GROUP BY 1 WITH NO DATA; INSERT INTO space_table VALUES (0, 1, 1), (0, 2, 1), (1, 1, 1), (1, 2, 1), (10, 1, 1), (10, 2, 1), (11, 1, 1), (11, 2, 1); SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'space_view' \gset SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 4 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 4 8 | 4 INSERT INTO space_table VALUES (3, 2, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 5 8 | 4 INSERT INTO space_table VALUES (2, 3, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 6 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 6 8 | 4 DROP TABLE space_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_25_60_chunk -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, c int, d int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type % %', pg_typeof(d), pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, c int, d int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, int, int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- insert into conditions select generate_series(0, 200, 10), 'POR', 55, 75, 40, 70, NULL; CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 1, 3, 'test'::text) from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer text WARNING: type integer text WARNING: type integer text SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | DROP MATERIALIZED view mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_65_chunk CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 4, 5, bigint '123') from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer bigint WARNING: type integer bigint WARNING: type integer bigint SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | --refresh mat view test when time_bucket is not projected -- DROP MATERIALIZED VIEW mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_28_66_chunk CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); SELECT * FROM mat_refresh_test order by 1,2 ; location | max ----------+----- NYC | 75 POR | 75 POR | 75 POR | 75 -- test for bug when group by is not in project list CREATE MATERIALIZED VIEW conditions_grpby_view with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location; NOTICE: refreshing continuous aggregate "conditions_grpby_view" select * from conditions_grpby_view order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 CREATE MATERIALIZED VIEW conditions_grpby_view2 with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location having avg(temperature) > 0; NOTICE: refreshing continuous aggregate "conditions_grpby_view2" select * from conditions_grpby_view2 order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 -- Test internal functions for continuous aggregates SELECT test.continuous_aggs_find_view('mat_refresh_test'); continuous_aggs_find_view --------------------------- -- Test pseudotype/enum handling CREATE TYPE status_enum AS ENUM ( 'red', 'yellow', 'green' ); CREATE TABLE cagg_types ( time TIMESTAMPTZ NOT NULL, status status_enum, names NAME[], floats FLOAT[] ); SELECT table_name FROM create_hypertable('cagg_types', 'time'); table_name ------------ cagg_types INSERT INTO cagg_types SELECT '2000-01-01', 'yellow', '{foo,bar,baz}', '{1,2.5,3}'; CREATE MATERIALIZED VIEW mat_types WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time), min(status) AS status, max(names) AS names, min(floats) AS floats FROM cagg_types GROUP BY 1; NOTICE: refreshing continuous aggregate "mat_types" CALL refresh_continuous_aggregate('mat_types',NULL,NULL); NOTICE: continuous aggregate "mat_types" is already up-to-date SELECT * FROM mat_types; time_bucket | status | names | floats ------------------------------+--------+---------------+----------- Fri Dec 31 16:00:00 1999 PST | yellow | {foo,bar,baz} | {1,2.5,3} ------------------------------------------------------------------------------------- -- Test issue #2616 where cagg view contains an experssion with several aggregates in CREATE TABLE water_consumption ( sensor_id integer NOT NULL, timestamp timestamp(0) NOT NULL, water_index integer ); SELECT create_hypertable('water_consumption', 'timestamp', 'sensor_id', 2); WARNING: column type "timestamp without time zone" used for "timestamp" does not follow best practices create_hypertable --------------------------------- (34,public,water_consumption,t) INSERT INTO public.water_consumption (sensor_id, timestamp, water_index) VALUES (1, '2010-11-03 09:42:30', 1030), (1, '2010-11-03 09:42:40', 1032), (1, '2010-11-03 09:42:50', 1035), (1, '2010-11-03 09:43:30', 1040), (1, '2010-11-03 09:43:40', 1045), (1, '2010-11-03 09:43:50', 1050), (1, '2010-11-03 09:44:30', 1052), (1, '2010-11-03 09:44:40', 1057), (1, '2010-11-03 09:44:50', 1060), (1, '2010-11-03 09:45:30', 1063), (1, '2010-11-03 09:45:40', 1067), (1, '2010-11-03 09:45:50', 1070); -- The test with the view originally reported in the issue. CREATE MATERIALIZED VIEW water_consumption_aggregation_minute WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_minute', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_minute ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 -- Simplified test, where the view doesn't contain all group by clauses CREATE MATERIALIZED VIEW water_consumption_no_select_bucket WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_no_select_bucket', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_no_select_bucket ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 -- The test with SELECT matching GROUP BY and placing aggregate expression not the last CREATE MATERIALIZED VIEW water_consumption_aggregation_no_addition WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_no_addition', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_no_addition ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 DROP TABLE water_consumption CASCADE; NOTICE: drop cascades to 6 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_35_73_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_36_74_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_37_75_chunk ---- --- github issue 2655 --- create table raw_data(time timestamptz, search_query text, cnt integer, cnt2 integer); select create_hypertable('raw_data','time', chunk_time_interval=>'15 days'::interval); create_hypertable ------------------------ (38,public,raw_data,t) insert into raw_data select '2000-01-01','Q1'; --having has exprs that appear in select CREATE MATERIALIZED VIEW search_query_count_1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1; NOTICE: refreshing continuous aggregate "search_query_count_1m" --having has aggregates + grp by columns that appear in select CREATE MATERIALIZED VIEW search_query_count_2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1 OR ( sum(cnt) + count(cnt)) > 1 AND search_query = 'Q1'; NOTICE: refreshing continuous aggregate "search_query_count_2" CREATE MATERIALIZED VIEW search_query_count_3 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY cnt +cnt2 , bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: refreshing continuous aggregate "search_query_count_3" insert into raw_data select '2000-01-01 00:00+0','Q1', 1, 100; insert into raw_data select '2000-01-01 00:00+0','Q1', 2, 200; insert into raw_data select '2000-01-01 00:00+0','Q1', 3, 300; insert into raw_data select '2000-01-02 00:00+0','Q2', 10, 10; insert into raw_data select '2000-01-02 00:00+0','Q2', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST --only 1 of these should appear in the result insert into raw_data select '2000-01-02 00:00+0','Q3', 0, 0; insert into raw_data select '2000-01-03 00:00+0','Q4', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_2--- CALL refresh_continuous_aggregate('search_query_count_2', NULL, NULL); SELECT * FROM search_query_count_2 ORDER BY 1, 2; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 3 | 6 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | 30 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_3--- CALL refresh_continuous_aggregate('search_query_count_3', NULL, NULL); SELECT * FROM search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --- TEST enable compression on continuous aggregates CREATE VIEW cagg_compression_status as SELECT ca.mat_hypertable_id AS mat_htid, ca.user_view_name AS cagg_name , h.schema_name AS mat_schema_name, h.table_name AS mat_table_name, ca.materialized_only FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) ; SELECT mat_htid AS "MAT_HTID" , mat_schema_name || '.' || mat_table_name AS "MAT_HTNAME" , mat_table_name AS "MAT_TABLE_NAME" FROM cagg_compression_status WHERE cagg_name = 'search_query_count_3' \gset ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'true'); NOTICE: defaulting compress_segmentby to search_query NOTICE: defaulting compress_orderby to bucket SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 \x SELECT * FROM timescaledb_information.compression_settings WHERE hypertable_name = :'MAT_TABLE_NAME'; -[ RECORD 1 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | search_query segmentby_column_index | 1 orderby_column_index | orderby_asc | orderby_nullsfirst | -[ RECORD 2 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | bucket segmentby_column_index | orderby_column_index | 1 orderby_asc | t orderby_nullsfirst | f \x SELECT compress_chunk(ch) FROM show_chunks('search_query_count_3') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk SELECT * from search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST -- insert into a new region of the hypertable and then refresh the cagg -- (note we still do not support refreshes into existing regions. -- cagg chunks do not map 1-1 to hypertabl regions. They encompass -- more data -- ). insert into raw_data select '2000-05-01 00:00+0','Q3', 0, 0; -- On PG >= 14 the refresh test below will pass because we added support for UPDATE/DELETE on compressed chunks in PR #5339 \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('search_query_count_3', NULL, '2000-06-01 00:00+0'::timestamptz); CALL refresh_continuous_aggregate('search_query_count_3', '2000-05-01 00:00+0'::timestamptz, '2000-06-01 00:00+0'::timestamptz); NOTICE: continuous aggregate "search_query_count_3" is already up-to-date \set ON_ERROR_STOP 1 --insert row insert into raw_data select '2001-05-10 00:00+0','Q3', 100, 100; --this should succeed since it does not refresh any compressed regions in the cagg CALL refresh_continuous_aggregate('search_query_count_3', '2001-05-01 00:00+0'::timestamptz, '2001-06-01 00:00+0'::timestamptz); --verify watermark and check that chunks are compressed SELECT _timescaledb_functions.to_timestamp(w) FROM _timescaledb_functions.cagg_watermark(:'MAT_HTID') w; to_timestamp ------------------------------ Wed May 09 17:01:00 2001 PDT SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; chunk_name | range_start | range_end | is_compressed --------------------+------------------------------+------------------------------+--------------- _hyper_41_79_chunk | Fri Dec 24 16:00:00 1999 PST | Mon May 22 17:00:00 2000 PDT | t _hyper_41_83_chunk | Sun Mar 18 16:00:00 2001 PST | Wed Aug 15 17:00:00 2001 PDT | f SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log WHERE materialization_id = :'MAT_HTID' ORDER BY 1, 2,3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 41 | -9223372036854775808 | -210866803200000001 41 | 959817600000000 | 988675199999999 41 | 991353600000000 | 9223372036854775807 SELECT * from search_query_count_3 WHERE bucket > '2001-01-01' ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q3 | 1 | 100 | Wed May 09 17:00:00 2001 PDT --now disable compression , will error out -- \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); ERROR: cannot disable columnstore on hypertable with columnstore chunks \set ON_ERROR_STOP 1 SELECT decompress_chunk(format('%I.%I', schema_name, table_name)) FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'MAT_HTID' and status = 1; decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk --disable compression on cagg after decompressing all chunks-- ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'search_query_count_3'; view_name | materialized_only | compression_enabled ----------------------+-------------------+--------------------- search_query_count_3 | f | f -- TEST caggs on table with more columns than in the cagg view defn -- CREATE TABLE test_morecols ( time TIMESTAMPTZ NOT NULL, val1 INTEGER, val2 INTEGER, val3 INTEGER, val4 INTEGER, val5 INTEGER, val6 INTEGER, val7 INTEGER, val8 INTEGER); SELECT create_hypertable('test_morecols', 'time', chunk_time_interval=> '7 days'::interval); create_hypertable ----------------------------- (43,public,test_morecols,t) INSERT INTO test_morecols SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 55, 75, 40, 70, NULL, 100, 200, 200; CREATE MATERIALIZED VIEW test_morecols_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('30 days',time), avg(val1), count(val2) FROM test_morecols GROUP BY 1; NOTICE: refreshing continuous aggregate "test_morecols_cagg" ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT compress_chunk(ch) FROM show_chunks('test_morecols_cagg') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_44_89_chunk SELECT * FROM test_morecols_cagg ORDER BY time_bucket; time_bucket | avg | count ------------------------------+---------------------+------- Fri Nov 23 16:00:00 2018 PST | 55.0000000000000000 | 23 Sun Dec 23 16:00:00 2018 PST | 55.0000000000000000 | 8 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | f | t --should keep compressed option, modify only materialized -- ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.materialized_only='true'); SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | t | t CREATE TABLE issue3248(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON issue3248(time DESC); CREATE INDEX ON issue3248(device_id,time DESC); SELECT create_hypertable('issue3248','time',create_default_indexes:=false); create_hypertable ------------------------- (46,public,issue3248,t) ALTER TABLE issue3248 DROP COLUMN filler_1; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_2; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_3; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE issue3248; CREATE materialized view issue3248_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), device_id, min(v0), max(v1), avg(v2) FROM issue3248 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "issue3248_cagg" SELECT FROM issue3248 AS m, LATERAL(SELECT m FROM issue3248_cagg WHERE avg IS NULL LIMIT 1) AS lat; -- -- test that option create_group_indexes is taken into account CREATE TABLE test_group_idx ( time timestamptz, symbol int, value numeric ); select create_hypertable('test_group_idx', 'time'); create_hypertable ------------------------------ (48,public,test_group_idx,t) insert into test_group_idx select t, round(random()*10), random()*5 from generate_series('2020-01-01', '2020-02-25', INTERVAL '12 hours') t; create materialized view cagg_index_true with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=true) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_true" create materialized view cagg_index_false with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_false" create materialized view cagg_index_default with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_default" -- see corresponding materialization_hypertables select view_name, materialization_hypertable_name from timescaledb_information.continuous_aggregates ca where view_name like 'cagg_index_%' ORDER BY view_name; view_name | materialization_hypertable_name --------------------+--------------------------------- cagg_index_default | _materialized_hypertable_51 cagg_index_false | _materialized_hypertable_50 cagg_index_true | _materialized_hypertable_49 -- now make sure a group index has been created when explicitly asked for \x on select i.* from pg_indexes i join pg_class c on schemaname = relnamespace::regnamespace::text and tablename = relname where tablename in (select materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name like 'cagg_index_%') order by tablename, indexname; -[ RECORD 1 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (bucket DESC) -[ RECORD 2 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (symbol, bucket DESC) -[ RECORD 3 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_50 indexname | _materialized_hypertable_50_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_50_bucket_idx ON _timescaledb_internal._materialized_hypertable_50 USING btree (bucket DESC) -[ RECORD 4 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (bucket DESC) -[ RECORD 5 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (symbol, bucket DESC) \x off -- -- TESTs for removing old CAggs restrictions -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 8 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_29_67_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_30_68_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_31_69_chunk CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'timec'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-03 09:00:00-08', 'NYC', 45, 55), ('2010-01-05 09:00:00-08', 'SFO', 75, 100), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15), ('2018-11-03 09:00:00-08', 'NYC', 35, 25); -- aggregate with DISTINCT CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(DISTINCT temperature) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2, 3; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 1 | 100 Sun Dec 27 16:00:00 2009 PST | 2 | 110 Sun Dec 27 16:00:00 2009 PST | 2 | 120 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 80 -- aggregate with FILTER DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), SUM(temperature) FILTER (WHERE humidity > 60) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | sum ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 100 Sun Dec 27 16:00:00 2009 PST | Sun Dec 27 16:00:00 2009 PST | Sun Jan 03 16:00:00 2010 PST | 75 Sun Oct 28 17:00:00 2018 PDT | -- aggregate with filter in having clause DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MAX(temperature) FROM conditions GROUP BY time_bucket('1week', timec), location HAVING SUM(temperature) FILTER (WHERE humidity > 40) > 50; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | max ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 100 Sun Jan 03 16:00:00 2010 PST | 75 -- ordered set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_55_116_chunk CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MODE() WITHIN GROUP(ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | mode ------------------------------+------ Sun Dec 27 16:00:00 2009 PST | 45 Sun Jan 03 16:00:00 2010 PST | 100 Sun Oct 28 17:00:00 2018 PDT | 15 -- hypothetical-set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), RANK(60) WITHIN GROUP (ORDER BY humidity), DENSE_RANK(60) WITHIN GROUP (ORDER BY humidity), PERCENT_RANK(60) WITHIN GROUP (ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | rank | dense_rank | percent_rank ------------------------------+------+------------+-------------- Sun Dec 27 16:00:00 2009 PST | 5 | 3 | 0.8 Sun Jan 03 16:00:00 2010 PST | 1 | 1 | 0 Sun Oct 28 17:00:00 2018 PDT | 4 | 4 | 1 -- userdefined aggregate without combine function DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE AGGREGATE newavg ( sfunc = int4_avg_accum, basetype = int4, stype = _int8, finalfunc = int8_avg, initcond1 = '{0,0}' ); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT SUM(humidity), round(newavg(temperature::int4)) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; sum | round -----+------- 75 | 38 90 | 60 100 | 55 100 | 75 100 | 100 -- ORDER BY in the view definition DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(temperature) FROM conditions GROUP BY time_bucket('1week', timec) ORDER BY sum DESC; NOTICE: refreshing continuous aggregate "mat_m1" -- CAgg definition for realtime SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ( SELECT _materialized_hypertable_59.time_bucket, + _materialized_hypertable_59.count, + _materialized_hypertable_59.sum + FROM _timescaledb_internal._materialized_hypertable_59 + WHERE _materialized_hypertable_59.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone)+ ORDER BY _materialized_hypertable_59.sum DESC) + UNION ALL + ( SELECT time_bucket('@ 7 days'::interval, conditions.timec) AS time_bucket, + count(conditions.location) AS count, + sum(conditions.temperature) AS sum + FROM conditions + WHERE conditions.timec >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 7 days'::interval, conditions.timec)) + ORDER BY (sum(conditions.temperature)) DESC) + ORDER BY 3 DESC; -- Ordered result SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Insert new data and query again to make sure we produce ordered data INSERT INTO conditions VALUES ('2018-11-10 09:00:00-08', 'SFO', 10, 10); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 1 | 10 -- This new row will change the order again INSERT INTO conditions VALUES ('2018-11-11 09:00:00-08', 'SFO', 400, 400); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Change the type of cagg ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); -- CAgg definition for materialized only SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + count, + sum + FROM _timescaledb_internal._materialized_hypertable_59+ ORDER BY sum DESC; -- Now the query will show only the materialized data, without last two -- records inserted into the original hypertable (last two insers above) SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Invalidate old region and refresh again DELETE FROM conditions WHERE timec < '2010-01-05 09:00:00-08'; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); -- Querying the cagg produce ordered records as expected SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Querying direct the materialization hypertable doesn't -- produce ordered records SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Nov 04 16:00:00 2018 PST | 2 | 410 -- -- Testing the coexistence of both types of supported CAggs -- over the same raw hypertable. -- -- . finalized = true: without chunk_id and partials -- . finalized = false: with chunk_id and partials -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW conditions_summary_new(timec, minl, sumt, sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) FROM conditions GROUP BY time_bucket('1day', timec) WITH NO DATA; \x ON SELECT * FROM timescaledb_information.continuous_aggregates WHERE view_name = 'conditions_summary_new'; -[ RECORD 1 ]---------------------+---------------------------------------------------------- hypertable_schema | public hypertable_name | conditions view_schema | public view_name | conditions_summary_new view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_61 view_definition | SELECT time_bucket('@ 1 day'::interval, timec) AS timec,+ | min(location) AS minl, + | sum(temperature) AS sumt, + | sum(humidity) AS sumh + | FROM conditions + | GROUP BY (time_bucket('@ 1 day'::interval, timec)); finalized | t \x OFF CALL refresh_continuous_aggregate('conditions_summary_new', NULL, NULL); -- Check and compare number of returned rows SELECT count(*) FROM conditions_summary_new; count ------- 4 -- Parallel planning test for realtime Continuous Aggregate DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions SELECT t, 10 FROM generate_series('2023-01-01 00:00-03'::timestamptz, '2023-12-31 23:59-03'::timestamptz, '1 hour'::interval) AS t; CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', timec), SUM(temperature) FROM conditions GROUP BY 1 ORDER BY 2 DESC; NOTICE: refreshing continuous aggregate "conditions_daily" SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; -- Parallel planning EXPLAIN (BUFFERS OFF, COSTS OFF, TIMING OFF) SELECT * FROM conditions_daily WHERE time_bucket >= '2023-07-01'; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_63.sum DESC -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _materialized_hypertable_63.sum DESC -> Parallel Append -> Parallel Index Scan using _hyper_63_183_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_183_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_187_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_187_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_188_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_188_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Sort Sort Key: (sum(_hyper_62_182_chunk.temperature)) DESC -> HashAggregate Group Key: (time_bucket('@ 1 day'::interval, _hyper_62_182_chunk.timec)) -> Gather Workers Planned: 1 -> Result -> Parallel Index Scan Backward using _hyper_62_182_chunk_conditions_timec_idx on _hyper_62_182_chunk Index Cond: ((timec >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (timec >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, timec) >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/continuous_aggs-18.out�����������������������������������������0000664�0000000�0000000�00000272441�15100345067�0023635�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.continuous_aggs_find_view(cagg REGCLASS) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_continuous_agg_find_by_view_name' LANGUAGE C; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --TEST1 --- --basic test with count create table foo (a integer, b integer, c integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); table_name ------------ foo insert into foo values( 3 , 16 , 20); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select a, count(b) from foo group by time_bucket(1, a), a WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2::integer, '12 h'::interval) AS job_id \gset SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+--------------------------------------------+-------------------+-------------+-------------+--------------+------------------------+-------------------------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------------+------------------------+-------------------------------------------+---------- 1000 | Refresh Continuous Aggregate Policy [1000] | @ 12 hours | @ 0 | -1 | @ 12 hours | _timescaledb_functions | policy_refresh_continuous_aggregate | default_perm_user | t | f | | 2 | {"end_offset": 2, "start_offset": null, "mat_hypertable_id": 2} | _timescaledb_functions | policy_refresh_continuous_aggregate_check | SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select a, count(b), time_bucket(1, a) from foo group by time_bucket(1, a) , a ; select * from mat_m1 order by a ; a | countb ---+-------- 1 | 5 2 | 3 3 | 1 --check triggers on user hypertable -- SET ROLE :ROLE_SUPERUSER; select tgname, tgtype, tgenabled , relname from pg_trigger, pg_class where tgrelid = pg_class.oid and pg_class.relname like 'foo' order by tgname; tgname | tgtype | tgenabled | relname --------+--------+-----------+--------- SET ROLE :ROLE_DEFAULT_PERM_USER; -- TEST2 --- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_2_2_chunk SHOW enable_partitionwise_aggregate; enable_partitionwise_aggregate -------------------------------- off SET enable_partitionwise_aggregate = on; SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Change `finalized` option is forbiden \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=false); ERROR: cannot alter finalized option for continuous aggregates ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=true); ERROR: cannot alter finalized option for continuous aggregates \set ON_ERROR_STOP 1 -- Materialized hypertable for mat_m1 should not be visible in the -- hypertables view: SELECT hypertable_schema, hypertable_name FROM timescaledb_information.hypertables ORDER BY 1,2; hypertable_schema | hypertable_name -------------------+----------------- public | conditions public | foo SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumt, sumh from mat_m1 order by timec; timec | minl | sumt | sumh ------------------------------+------+------+------ Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) order by 1; time_bucket | min | sum | sum ------------------------------+-----+-----+----- Thu Dec 31 16:00:00 2009 PST | SFO | 55 | 45 Fri Jan 01 16:00:00 2010 PST | NYC | 230 | 190 Wed Oct 31 17:00:00 2018 PDT | NYC | 45 | 35 Thu Nov 01 17:00:00 2018 PDT | NYC | 35 | 15 SET enable_partitionwise_aggregate = off; -- TEST3 -- -- drop on table conditions should cascade to materialized mat_v1 drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-03 09:00:00-08', 'NYC', 45, 55); insert into conditions values ( '2010-01-05 09:00:00-08', 'SFO', 75, 100); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); insert into conditions values ( '2018-11-03 09:00:00-08', 'NYC', 35, 25); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 Sun Jan 03 16:00:00 2010 PST | SFO | 175 | Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST4 -- --materialized view with group by clause + expression in SELECT -- use previous data from conditions --drop only the view. -- apply where clause on result of mat_m1 -- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 where stddevh is not null order by timec; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) order by time_bucket('1week', timec); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 27 16:00:00 2009 PST | NYC | 210 | 7.07106781186548 Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 -- TEST5 -- ---------test with having clause ---------------------- DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects create materialized view mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null WITH NO DATA; ; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null; SET ROLE :ROLE_DEFAULT_PERM_USER; -- should have same results -- select * from mat_m1 order by sumth; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null order by sum(temperature)+sum(humidity); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Oct 28 17:00:00 2018 PDT | NYC | 190 | 10 Sun Dec 27 16:00:00 2009 PST | NYC | 620 | 23.8746727726266 -- TEST6 -- --group by with more than 1 group column -- having clause with a mix of columns from select list + others drop table conditions cascade; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp numeric NULL, highp numeric null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, 71, 28; --naming with AS clauses CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) as bucket, location as loc, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by bucket, loc having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with default names CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+------------- 1 | time_bucket 2 | location 3 | sumth 4 | stddev DROP MATERIALIZED VIEW mat_naming; --naming with view col names CREATE MATERIALIZED VIEW mat_naming(bucket, loc, sum_t_h, stdd) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity), stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | bucket 2 | loc 3 | sum_t_h 4 | stdd DROP MATERIALIZED VIEW mat_naming; CREATE MATERIALIZED VIEW mat_m1(timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; attnum | attname --------+--------- 1 | timec 2 | minl 3 | sumth 4 | stddevh SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec, minl; timec | minl | sumth | stddevh ------------------------------+------+-------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 and avg(lowp) > 10 order by time_bucket('1week', timec), min(location); time_bucket | min | ?column? | stddev ------------------------------+-----+----------+------------------ Sun Dec 16 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 23 16:00:00 2018 PST | NYC | 1470 | 15.5662356498831 Sun Dec 30 16:00:00 2018 PST | NYC | 210 | 21.2132034355964 --check view defintion in information views select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like 'mat_m1'; view_name | view_definition -----------+------------------------------------------------------------------------------------------- mat_m1 | SELECT time_bucket('@ 7 days'::interval, timec) AS timec, + | min(location) AS minl, + | (sum(temperature) + sum(humidity)) AS sumth, + | stddev(humidity) AS stddevh + | FROM conditions + | GROUP BY (time_bucket('@ 7 days'::interval, timec)) + | HAVING ((min(location) >= 'NYC'::text) AND (avg(temperature) > (20)::double precision)); --TEST6 -- select from internal view SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select * from :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; SET ROLE :ROLE_DEFAULT_PERM_USER; --lets drop the view and check DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_13_24_chunk drop table conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT $$ select time_bucket('1week', timec) , min(location) as col1, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: materialized view "mat_test" does not exist, skipping ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 SELECT $$ select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by location, time_bucket('1week', timec) $$ AS "QUERY" \gset \set ECHO errors psql:include/cont_agg_equal.sql:8: NOTICE: drop cascades to table _timescaledb_internal._hyper_15_34_chunk ?column? | count ---------------------------------------------------------------+------- Number of rows different between view and original (expect 0) | 0 --TEST7 -- drop tests for view and hypertable --DROP tests \set ON_ERROR_STOP 0 SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_test' \gset DROP TABLE :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; ERROR: cannot drop table _timescaledb_internal._materialized_hypertable_16 because other objects depend on it DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate DROP VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME"; ERROR: cannot drop the partial/direct view because it is required by a continuous aggregate \set ON_ERROR_STOP 1 --catalog entry still there; SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 1 --mat table, user_view, direct view and partial view all there select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 1 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 1 select count(*) from pg_class where relname = 'mat_test'; count ------- 1 DROP MATERIALIZED VIEW mat_test; NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; count ------- 0 --mat table, user_view, direct view and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_test'; count ------- 0 --test dropping raw table DROP TABLE conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions --no data in hyper table on purpose so that CASCADE is not required because of chunks CREATE MATERIALIZED VIEW mat_drop_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; \set ON_ERROR_STOP 0 DROP TABLE conditions; ERROR: cannot drop table conditions because other objects depend on it \set ON_ERROR_STOP 1 --insert data now insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_drop_test' \gset SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_drop_test', NULL, NULL); --force invalidation insert into conditions select generate_series('2017-11-01 00:00'::timestamp, '2017-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 1 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 1 DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_drop_test'; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; count ------- 0 select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; count ------- 0 SELECT * FROM _timescaledb_config.bgw_job; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- --mat table, user_view, and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; count ------- 0 select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; count ------- 0 select count(*) from pg_class where relname = 'mat_drop_test'; count ------- 0 --TEST With options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); table_name ------------ conditions CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, '5 h'::interval, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1001 SELECT alter_job(id, schedule_interval => '1h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ (1001,"@ 1 hour","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 1 hour SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1001,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": ""@ 5 hours"", ""start_offset"": null, ""mat_hypertable_id"": 20}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1001]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test') order by indexname; indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_20_timec_idx | CREATE INDEX _materialized_hypertable_20_timec_idx ON _timescaledb_internal._materialized_hypertable_20 USING btree (timec DESC) DROP MATERIALIZED VIEW mat_with_test; --no additional indexes CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true, timescaledb.create_group_indexes=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test'); indexname | indexdef ---------------------------------------+---------------------------------------------------------------------------------------------------------------------------------- _materialized_hypertable_21_timec_idx | CREATE INDEX _materialized_hypertable_21_timec_idx ON _timescaledb_internal._materialized_hypertable_21 USING btree (timec DESC) DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, 500::integer, '12 h'::interval); add_continuous_aggregate_policy --------------------------------- 1002 SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; alter_job --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- (1002,"@ 2 hours","@ 0",-1,"@ 12 hours",t,"{""end_offset"": 500, ""start_offset"": null, ""mat_hypertable_id"": 23}",-infinity,_timescaledb_functions.policy_refresh_continuous_aggregate_check,f,,,"Refresh Continuous Aggregate Policy [1002]") SELECT schedule_interval FROM _timescaledb_config.bgw_job; schedule_interval ------------------- @ 2 hours DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects --test space partitions CREATE TABLE space_table ( time BIGINT, dev BIGINT, data BIGINT ); SELECT create_hypertable( 'space_table', 'time', chunk_time_interval => 10, partitioning_column => 'dev', number_partitions => 3); create_hypertable --------------------------- (24,public,space_table,t) CREATE OR REPLACE FUNCTION integer_now_space_table() returns BIGINT LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), BIGINT '0') FROM space_table $$; SELECT set_integer_now_func('space_table', 'integer_now_space_table'); set_integer_now_func ---------------------- CREATE MATERIALIZED VIEW space_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('4', time), COUNT(data) FROM space_table GROUP BY 1 WITH NO DATA; INSERT INTO space_table VALUES (0, 1, 1), (0, 2, 1), (1, 1, 1), (1, 2, 1), (10, 1, 1), (10, 2, 1), (11, 1, 1), (11, 2, 1); SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'space_view' \gset SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 4 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 4 8 | 4 INSERT INTO space_table VALUES (3, 2, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 5 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 5 8 | 4 INSERT INTO space_table VALUES (2, 3, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; time_bucket | count -------------+------- 0 | 6 8 | 4 SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; time_bucket | count -------------+------- 0 | 6 8 | 4 DROP TABLE space_table CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_25_60_chunk -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, c int, d int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type % %', pg_typeof(d), pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, c int, d int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, int, int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); table_name ------------ conditions CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); set_integer_now_func ---------------------- insert into conditions select generate_series(0, 200, 10), 'POR', 55, 75, 40, 70, NULL; CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 1, 3, 'test'::text) from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer text WARNING: type integer text WARNING: type integer text SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | DROP MATERIALIZED view mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_27_65_chunk CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 4, 5, bigint '123') from conditions group by time_bucket(100, timec); NOTICE: refreshing continuous aggregate "mat_ffunc_test" WARNING: type integer bigint WARNING: type integer bigint WARNING: type integer bigint SELECT * FROM mat_ffunc_test ORDER BY time_bucket; time_bucket | aggregate_to_test_ffunc_extra -------------+------------------------------- 0 | 100 | 200 | --refresh mat view test when time_bucket is not projected -- DROP MATERIALIZED VIEW mat_ffunc_test; NOTICE: drop cascades to table _timescaledb_internal._hyper_28_66_chunk CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); SELECT * FROM mat_refresh_test order by 1,2 ; location | max ----------+----- NYC | 75 POR | 75 POR | 75 POR | 75 -- test for bug when group by is not in project list CREATE MATERIALIZED VIEW conditions_grpby_view with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location; NOTICE: refreshing continuous aggregate "conditions_grpby_view" select * from conditions_grpby_view order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 CREATE MATERIALIZED VIEW conditions_grpby_view2 with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location having avg(temperature) > 0; NOTICE: refreshing continuous aggregate "conditions_grpby_view2" select * from conditions_grpby_view2 order by 1, 2; time_bucket | sum -------------+----- 0 | 450 0 | 750 100 | 750 200 | 75 -- Test internal functions for continuous aggregates SELECT test.continuous_aggs_find_view('mat_refresh_test'); continuous_aggs_find_view --------------------------- -- Test pseudotype/enum handling CREATE TYPE status_enum AS ENUM ( 'red', 'yellow', 'green' ); CREATE TABLE cagg_types ( time TIMESTAMPTZ NOT NULL, status status_enum, names NAME[], floats FLOAT[] ); SELECT table_name FROM create_hypertable('cagg_types', 'time'); table_name ------------ cagg_types INSERT INTO cagg_types SELECT '2000-01-01', 'yellow', '{foo,bar,baz}', '{1,2.5,3}'; CREATE MATERIALIZED VIEW mat_types WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time), min(status) AS status, max(names) AS names, min(floats) AS floats FROM cagg_types GROUP BY 1; NOTICE: refreshing continuous aggregate "mat_types" CALL refresh_continuous_aggregate('mat_types',NULL,NULL); NOTICE: continuous aggregate "mat_types" is already up-to-date SELECT * FROM mat_types; time_bucket | status | names | floats ------------------------------+--------+---------------+----------- Fri Dec 31 16:00:00 1999 PST | yellow | {foo,bar,baz} | {1,2.5,3} ------------------------------------------------------------------------------------- -- Test issue #2616 where cagg view contains an experssion with several aggregates in CREATE TABLE water_consumption ( sensor_id integer NOT NULL, timestamp timestamp(0) NOT NULL, water_index integer ); SELECT create_hypertable('water_consumption', 'timestamp', 'sensor_id', 2); WARNING: column type "timestamp without time zone" used for "timestamp" does not follow best practices create_hypertable --------------------------------- (34,public,water_consumption,t) INSERT INTO public.water_consumption (sensor_id, timestamp, water_index) VALUES (1, '2010-11-03 09:42:30', 1030), (1, '2010-11-03 09:42:40', 1032), (1, '2010-11-03 09:42:50', 1035), (1, '2010-11-03 09:43:30', 1040), (1, '2010-11-03 09:43:40', 1045), (1, '2010-11-03 09:43:50', 1050), (1, '2010-11-03 09:44:30', 1052), (1, '2010-11-03 09:44:40', 1057), (1, '2010-11-03 09:44:50', 1060), (1, '2010-11-03 09:45:30', 1063), (1, '2010-11-03 09:45:40', 1067), (1, '2010-11-03 09:45:50', 1070); -- The test with the view originally reported in the issue. CREATE MATERIALIZED VIEW water_consumption_aggregation_minute WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_minute', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_minute ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | timestamp | water_consumption -----------+--------------------------+------------------- 1 | Wed Nov 03 09:43:00 2010 | 5 1 | Wed Nov 03 09:46:00 2010 | 7 1 | Wed Nov 03 09:45:00 2010 | 8 1 | Wed Nov 03 09:44:00 2010 | 10 -- Simplified test, where the view doesn't contain all group by clauses CREATE MATERIALIZED VIEW water_consumption_no_select_bucket WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_no_select_bucket', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_no_select_bucket ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption -----------+------------------- 1 | 5 1 | 7 1 | 8 1 | 10 -- The test with SELECT matching GROUP BY and placing aggregate expression not the last CREATE MATERIALIZED VIEW water_consumption_aggregation_no_addition WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_no_addition', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_no_addition ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; sensor_id | water_consumption | timestamp -----------+-------------------+-------------------------- 1 | 5 | Wed Nov 03 09:42:00 2010 1 | 7 | Wed Nov 03 09:45:00 2010 1 | 8 | Wed Nov 03 09:44:00 2010 1 | 10 | Wed Nov 03 09:43:00 2010 DROP TABLE water_consumption CASCADE; NOTICE: drop cascades to 6 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_35_73_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_36_74_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_37_75_chunk ---- --- github issue 2655 --- create table raw_data(time timestamptz, search_query text, cnt integer, cnt2 integer); select create_hypertable('raw_data','time', chunk_time_interval=>'15 days'::interval); create_hypertable ------------------------ (38,public,raw_data,t) insert into raw_data select '2000-01-01','Q1'; --having has exprs that appear in select CREATE MATERIALIZED VIEW search_query_count_1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1; NOTICE: refreshing continuous aggregate "search_query_count_1m" --having has aggregates + grp by columns that appear in select CREATE MATERIALIZED VIEW search_query_count_2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1 OR ( sum(cnt) + count(cnt)) > 1 AND search_query = 'Q1'; NOTICE: refreshing continuous aggregate "search_query_count_2" CREATE MATERIALIZED VIEW search_query_count_3 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY cnt +cnt2 , bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; NOTICE: refreshing continuous aggregate "search_query_count_3" insert into raw_data select '2000-01-01 00:00+0','Q1', 1, 100; insert into raw_data select '2000-01-01 00:00+0','Q1', 2, 200; insert into raw_data select '2000-01-01 00:00+0','Q1', 3, 300; insert into raw_data select '2000-01-02 00:00+0','Q2', 10, 10; insert into raw_data select '2000-01-02 00:00+0','Q2', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST --only 1 of these should appear in the result insert into raw_data select '2000-01-02 00:00+0','Q3', 0, 0; insert into raw_data select '2000-01-03 00:00+0','Q4', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; search_query | count | bucket --------------+-------+------------------------------ Q1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_2--- CALL refresh_continuous_aggregate('search_query_count_2', NULL, NULL); SELECT * FROM search_query_count_2 ORDER BY 1, 2; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 3 | 6 | Fri Dec 31 16:00:00 1999 PST Q2 | 2 | 30 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --refresh search_query_count_3--- CALL refresh_continuous_aggregate('search_query_count_3', NULL, NULL); SELECT * FROM search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST --- TEST enable compression on continuous aggregates CREATE VIEW cagg_compression_status as SELECT ca.mat_hypertable_id AS mat_htid, ca.user_view_name AS cagg_name , h.schema_name AS mat_schema_name, h.table_name AS mat_table_name, ca.materialized_only FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) ; SELECT mat_htid AS "MAT_HTID" , mat_schema_name || '.' || mat_table_name AS "MAT_HTNAME" , mat_table_name AS "MAT_TABLE_NAME" FROM cagg_compression_status WHERE cagg_name = 'search_query_count_3' \gset ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'true'); NOTICE: defaulting compress_segmentby to search_query NOTICE: defaulting compress_orderby to bucket SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 \x SELECT * FROM timescaledb_information.compression_settings WHERE hypertable_name = :'MAT_TABLE_NAME'; -[ RECORD 1 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | search_query segmentby_column_index | 1 orderby_column_index | orderby_asc | orderby_nullsfirst | -[ RECORD 2 ]----------+---------------------------- hypertable_schema | _timescaledb_internal hypertable_name | _materialized_hypertable_41 attname | bucket segmentby_column_index | orderby_column_index | 1 orderby_asc | t orderby_nullsfirst | f \x SELECT compress_chunk(ch) FROM show_chunks('search_query_count_3') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk SELECT * from search_query_count_3 ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q1 | 1 | 1 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 2 | Fri Dec 31 16:00:00 1999 PST Q1 | 1 | 3 | Fri Dec 31 16:00:00 1999 PST Q2 | 1 | 10 | Sat Jan 01 16:00:00 2000 PST Q2 | 1 | 20 | Sat Jan 01 16:00:00 2000 PST Q4 | 1 | 20 | Sun Jan 02 16:00:00 2000 PST -- insert into a new region of the hypertable and then refresh the cagg -- (note we still do not support refreshes into existing regions. -- cagg chunks do not map 1-1 to hypertabl regions. They encompass -- more data -- ). insert into raw_data select '2000-05-01 00:00+0','Q3', 0, 0; -- On PG >= 14 the refresh test below will pass because we added support for UPDATE/DELETE on compressed chunks in PR #5339 \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('search_query_count_3', NULL, '2000-06-01 00:00+0'::timestamptz); CALL refresh_continuous_aggregate('search_query_count_3', '2000-05-01 00:00+0'::timestamptz, '2000-06-01 00:00+0'::timestamptz); NOTICE: continuous aggregate "search_query_count_3" is already up-to-date \set ON_ERROR_STOP 1 --insert row insert into raw_data select '2001-05-10 00:00+0','Q3', 100, 100; --this should succeed since it does not refresh any compressed regions in the cagg CALL refresh_continuous_aggregate('search_query_count_3', '2001-05-01 00:00+0'::timestamptz, '2001-06-01 00:00+0'::timestamptz); --verify watermark and check that chunks are compressed SELECT _timescaledb_functions.to_timestamp(w) FROM _timescaledb_functions.cagg_watermark(:'MAT_HTID') w; to_timestamp ------------------------------ Wed May 09 17:01:00 2001 PDT SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; chunk_name | range_start | range_end | is_compressed --------------------+------------------------------+------------------------------+--------------- _hyper_41_79_chunk | Fri Dec 24 16:00:00 1999 PST | Mon May 22 17:00:00 2000 PDT | t _hyper_41_83_chunk | Sun Mar 18 16:00:00 2001 PST | Wed Aug 15 17:00:00 2001 PDT | f SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log WHERE materialization_id = :'MAT_HTID' ORDER BY 1, 2,3; materialization_id | lowest_modified_value | greatest_modified_value --------------------+-----------------------+------------------------- 41 | -9223372036854775808 | -210866803200000001 41 | 959817600000000 | 988675199999999 41 | 991353600000000 | 9223372036854775807 SELECT * from search_query_count_3 WHERE bucket > '2001-01-01' ORDER BY 1, 2, 3; search_query | count | sum | bucket --------------+-------+-----+------------------------------ Q3 | 1 | 100 | Wed May 09 17:00:00 2001 PDT --now disable compression , will error out -- \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); ERROR: cannot disable columnstore on hypertable with columnstore chunks \set ON_ERROR_STOP 1 SELECT decompress_chunk(format('%I.%I', schema_name, table_name)) FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'MAT_HTID' and status = 1; decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_41_79_chunk --disable compression on cagg after decompressing all chunks-- ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; cagg_name | mat_table_name ----------------------+----------------------------- search_query_count_3 | _materialized_hypertable_41 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'search_query_count_3'; view_name | materialized_only | compression_enabled ----------------------+-------------------+--------------------- search_query_count_3 | f | f -- TEST caggs on table with more columns than in the cagg view defn -- CREATE TABLE test_morecols ( time TIMESTAMPTZ NOT NULL, val1 INTEGER, val2 INTEGER, val3 INTEGER, val4 INTEGER, val5 INTEGER, val6 INTEGER, val7 INTEGER, val8 INTEGER); SELECT create_hypertable('test_morecols', 'time', chunk_time_interval=> '7 days'::interval); create_hypertable ----------------------------- (43,public,test_morecols,t) INSERT INTO test_morecols SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 55, 75, 40, 70, NULL, 100, 200, 200; CREATE MATERIALIZED VIEW test_morecols_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('30 days',time), avg(val1), count(val2) FROM test_morecols GROUP BY 1; NOTICE: refreshing continuous aggregate "test_morecols_cagg" ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.compress='true'); NOTICE: defaulting compress_orderby to time_bucket SELECT compress_chunk(ch) FROM show_chunks('test_morecols_cagg') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_44_89_chunk SELECT * FROM test_morecols_cagg ORDER BY time_bucket; time_bucket | avg | count ------------------------------+---------------------+------- Fri Nov 23 16:00:00 2018 PST | 55.0000000000000000 | 23 Sun Dec 23 16:00:00 2018 PST | 55.0000000000000000 | 8 SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | f | t --should keep compressed option, modify only materialized -- ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.materialized_only='true'); SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; view_name | materialized_only | compression_enabled --------------------+-------------------+--------------------- test_morecols_cagg | t | t CREATE TABLE issue3248(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON issue3248(time DESC); CREATE INDEX ON issue3248(device_id,time DESC); SELECT create_hypertable('issue3248','time',create_default_indexes:=false); create_hypertable ------------------------- (46,public,issue3248,t) ALTER TABLE issue3248 DROP COLUMN filler_1; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_2; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_3; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE issue3248; CREATE materialized view issue3248_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), device_id, min(v0), max(v1), avg(v2) FROM issue3248 GROUP BY 1,2; NOTICE: refreshing continuous aggregate "issue3248_cagg" SELECT FROM issue3248 AS m, LATERAL(SELECT m FROM issue3248_cagg WHERE avg IS NULL LIMIT 1) AS lat; -- -- test that option create_group_indexes is taken into account CREATE TABLE test_group_idx ( time timestamptz, symbol int, value numeric ); select create_hypertable('test_group_idx', 'time'); create_hypertable ------------------------------ (48,public,test_group_idx,t) insert into test_group_idx select t, round(random()*10), random()*5 from generate_series('2020-01-01', '2020-02-25', INTERVAL '12 hours') t; create materialized view cagg_index_true with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=true) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_true" create materialized view cagg_index_false with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_false" create materialized view cagg_index_default with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; NOTICE: refreshing continuous aggregate "cagg_index_default" -- see corresponding materialization_hypertables select view_name, materialization_hypertable_name from timescaledb_information.continuous_aggregates ca where view_name like 'cagg_index_%' ORDER BY view_name; view_name | materialization_hypertable_name --------------------+--------------------------------- cagg_index_default | _materialized_hypertable_51 cagg_index_false | _materialized_hypertable_50 cagg_index_true | _materialized_hypertable_49 -- now make sure a group index has been created when explicitly asked for \x on select i.* from pg_indexes i join pg_class c on schemaname = relnamespace::regnamespace::text and tablename = relname where tablename in (select materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name like 'cagg_index_%') order by tablename, indexname; -[ RECORD 1 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (bucket DESC) -[ RECORD 2 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_49 indexname | _materialized_hypertable_49_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_49_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_49 USING btree (symbol, bucket DESC) -[ RECORD 3 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_50 indexname | _materialized_hypertable_50_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_50_bucket_idx ON _timescaledb_internal._materialized_hypertable_50 USING btree (bucket DESC) -[ RECORD 4 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (bucket DESC) -[ RECORD 5 ]------------------------------------------------------------------------------------------------------------------------------------------------- schemaname | _timescaledb_internal tablename | _materialized_hypertable_51 indexname | _materialized_hypertable_51_symbol_bucket_idx tablespace | indexdef | CREATE INDEX _materialized_hypertable_51_symbol_bucket_idx ON _timescaledb_internal._materialized_hypertable_51 USING btree (symbol, bucket DESC) \x off -- -- TESTs for removing old CAggs restrictions -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 8 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_29_67_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_30_68_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_31_69_chunk CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'timec'); create_hypertable -------------------------- (52,public,conditions,t) INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-03 09:00:00-08', 'NYC', 45, 55), ('2010-01-05 09:00:00-08', 'SFO', 75, 100), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15), ('2018-11-03 09:00:00-08', 'NYC', 35, 25); -- aggregate with DISTINCT CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(DISTINCT temperature) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2, 3; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 1 | 100 Sun Dec 27 16:00:00 2009 PST | 2 | 110 Sun Dec 27 16:00:00 2009 PST | 2 | 120 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 80 -- aggregate with FILTER DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), SUM(temperature) FILTER (WHERE humidity > 60) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | sum ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 100 Sun Dec 27 16:00:00 2009 PST | Sun Dec 27 16:00:00 2009 PST | Sun Jan 03 16:00:00 2010 PST | 75 Sun Oct 28 17:00:00 2018 PDT | -- aggregate with filter in having clause DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MAX(temperature) FROM conditions GROUP BY time_bucket('1week', timec), location HAVING SUM(temperature) FILTER (WHERE humidity > 40) > 50; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; time_bucket | max ------------------------------+----- Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 65 Sun Dec 27 16:00:00 2009 PST | 100 Sun Jan 03 16:00:00 2010 PST | 75 -- ordered set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to table _timescaledb_internal._hyper_55_116_chunk CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MODE() WITHIN GROUP(ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | mode ------------------------------+------ Sun Dec 27 16:00:00 2009 PST | 45 Sun Jan 03 16:00:00 2010 PST | 100 Sun Oct 28 17:00:00 2018 PDT | 15 -- hypothetical-set aggr DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), RANK(60) WITHIN GROUP (ORDER BY humidity), DENSE_RANK(60) WITHIN GROUP (ORDER BY humidity), PERCENT_RANK(60) WITHIN GROUP (ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1; time_bucket | rank | dense_rank | percent_rank ------------------------------+------+------------+-------------- Sun Dec 27 16:00:00 2009 PST | 5 | 3 | 0.8 Sun Jan 03 16:00:00 2010 PST | 1 | 1 | 0 Sun Oct 28 17:00:00 2018 PDT | 4 | 4 | 1 -- userdefined aggregate without combine function DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE AGGREGATE newavg ( sfunc = int4_avg_accum, basetype = int4, stype = _int8, finalfunc = int8_avg, initcond1 = '{0,0}' ); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT SUM(humidity), round(newavg(temperature::int4)) FROM conditions GROUP BY time_bucket('1week', timec), location; NOTICE: refreshing continuous aggregate "mat_m1" SELECT * FROM mat_m1 ORDER BY 1, 2; sum | round -----+------- 75 | 38 90 | 60 100 | 55 100 | 75 100 | 100 -- ORDER BY in the view definition DROP MATERIALIZED VIEW mat_m1; NOTICE: drop cascades to 2 other objects CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(temperature) FROM conditions GROUP BY time_bucket('1week', timec) ORDER BY sum DESC; NOTICE: refreshing continuous aggregate "mat_m1" -- CAgg definition for realtime SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ( SELECT _materialized_hypertable_59.time_bucket, + _materialized_hypertable_59.count, + _materialized_hypertable_59.sum + FROM _timescaledb_internal._materialized_hypertable_59 + WHERE _materialized_hypertable_59.time_bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone)+ ORDER BY _materialized_hypertable_59.sum DESC) + UNION ALL + ( SELECT time_bucket('@ 7 days'::interval, conditions.timec) AS time_bucket, + count(conditions.location) AS count, + sum(conditions.temperature) AS sum + FROM conditions + WHERE conditions.timec >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(59)), '-infinity'::timestamp with time zone) + GROUP BY (time_bucket('@ 7 days'::interval, conditions.timec)) + ORDER BY (sum(conditions.temperature)) DESC) + ORDER BY 3 DESC; -- Ordered result SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Insert new data and query again to make sure we produce ordered data INSERT INTO conditions VALUES ('2018-11-10 09:00:00-08', 'SFO', 10, 10); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 1 | 10 -- This new row will change the order again INSERT INTO conditions VALUES ('2018-11-11 09:00:00-08', 'SFO', 400, 400); SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk Index Cond: (time_bucket < 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Sort Sort Key: (sum(conditions.temperature)) DESC -> Finalize GroupAggregate Group Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Merge Append Sort Key: (time_bucket('@ 7 days'::interval, conditions.timec)) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_111_chunk.timec) -> Index Scan Backward using _hyper_52_111_chunk_conditions_timec_idx on _hyper_52_111_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 7 days'::interval, _hyper_52_125_chunk.timec) -> Index Scan Backward using _hyper_52_125_chunk_conditions_timec_idx on _hyper_52_125_chunk Index Cond: (timec >= 'Sun Nov 04 16:00:00 2018 PST'::timestamp with time zone) -- Change the type of cagg ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); -- CAgg definition for materialized only SELECT pg_get_viewdef('mat_m1',true); pg_get_viewdef ----------------------------------------------------------- SELECT time_bucket, + count, + sum + FROM _timescaledb_internal._materialized_hypertable_59+ ORDER BY sum DESC; -- Now the query will show only the materialized data, without last two -- records inserted into the original hypertable (last two insers above) SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Dec 27 16:00:00 2009 PST | 5 | 330 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Dec 27 16:00:00 2009 PST | 5 | 330 EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; --- QUERY PLAN --- Sort Sort Key: _materialized_hypertable_59.count -> Merge Append Sort Key: _materialized_hypertable_59.sum DESC -> Index Scan Backward using _hyper_59_123_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_123_chunk -> Index Scan Backward using _hyper_59_124_chunk__materialized_hypertable_59_sum_time_bucket on _hyper_59_124_chunk SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Invalidate old region and refresh again DELETE FROM conditions WHERE timec < '2010-01-05 09:00:00-08'; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); -- Querying the cagg produce ordered records as expected SELECT * FROM mat_m1; time_bucket | count | sum ------------------------------+-------+----- Sun Nov 04 16:00:00 2018 PST | 2 | 410 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Jan 03 16:00:00 2010 PST | 1 | 75 -- Querying direct the materialization hypertable doesn't -- produce ordered records SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; time_bucket | count | sum ------------------------------+-------+----- Sun Jan 03 16:00:00 2010 PST | 1 | 75 Sun Oct 28 17:00:00 2018 PDT | 3 | 115 Sun Nov 04 16:00:00 2018 PST | 2 | 410 -- -- Testing the coexistence of both types of supported CAggs -- over the same raw hypertable. -- -- . finalized = true: without chunk_id and partials -- . finalized = false: with chunk_id and partials -- DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW conditions_summary_new(timec, minl, sumt, sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) FROM conditions GROUP BY time_bucket('1day', timec) WITH NO DATA; \x ON SELECT * FROM timescaledb_information.continuous_aggregates WHERE view_name = 'conditions_summary_new'; -[ RECORD 1 ]---------------------+---------------------------------------------------------- hypertable_schema | public hypertable_name | conditions view_schema | public view_name | conditions_summary_new view_owner | default_perm_user materialized_only | t compression_enabled | f materialization_hypertable_schema | _timescaledb_internal materialization_hypertable_name | _materialized_hypertable_61 view_definition | SELECT time_bucket('@ 1 day'::interval, timec) AS timec,+ | min(location) AS minl, + | sum(temperature) AS sumt, + | sum(humidity) AS sumh + | FROM conditions + | GROUP BY (time_bucket('@ 1 day'::interval, timec)); finalized | t \x OFF CALL refresh_continuous_aggregate('conditions_summary_new', NULL, NULL); -- Check and compare number of returned rows SELECT count(*) FROM conditions_summary_new; count ------- 4 -- Parallel planning test for realtime Continuous Aggregate DROP TABLE conditions CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to 2 other objects CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); table_name ------------ conditions INSERT INTO conditions SELECT t, 10 FROM generate_series('2023-01-01 00:00-03'::timestamptz, '2023-12-31 23:59-03'::timestamptz, '1 hour'::interval) AS t; CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', timec), SUM(temperature) FROM conditions GROUP BY 1 ORDER BY 2 DESC; NOTICE: refreshing continuous aggregate "conditions_daily" SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; -- Parallel planning EXPLAIN (BUFFERS OFF, COSTS OFF, TIMING OFF) SELECT * FROM conditions_daily WHERE time_bucket >= '2023-07-01'; --- QUERY PLAN --- Merge Append Sort Key: _materialized_hypertable_63.sum DESC -> Gather Merge Workers Planned: 2 -> Sort Sort Key: _materialized_hypertable_63.sum DESC -> Parallel Append -> Parallel Index Scan using _hyper_63_183_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_183_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_187_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_187_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Parallel Index Scan using _hyper_63_188_chunk__materialized_hypertable_63_time_bucket_idx on _hyper_63_188_chunk Index Cond: ((time_bucket < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (time_bucket >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) -> Sort Sort Key: (sum(_hyper_62_182_chunk.temperature)) DESC -> HashAggregate Group Key: (time_bucket('@ 1 day'::interval, _hyper_62_182_chunk.timec)) -> Gather Workers Planned: 1 -> Result -> Parallel Index Scan Backward using _hyper_62_182_chunk_conditions_timec_idx on _hyper_62_182_chunk Index Cond: ((timec >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND (timec >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone)) Filter: (time_bucket('@ 1 day'::interval, timec) >= 'Sat Jul 01 00:00:00 2023 PDT'::timestamp with time zone) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/create_table_with.out������������������������������������������0000664�0000000�0000000�00000075506�15100345067�0023650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- our user needs permission to create schema for the schema tests \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :TEST_DBNAME TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- create table with non-tsdb option should not be affected CREATE TABLE t1(time timestamptz, device text, value float) WITH (autovacuum_enabled); DROP TABLE t1; -- test error cases \set ON_ERROR_STOP 0 CREATE TABLE t2(time float, device text, value float) WITH (tsdb.hypertable); ERROR: partition column could not be determined CREATE TABLE t2(time float, device text, value float) WITH (timescaledb.hypertable); ERROR: partition column could not be determined CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=NULL); ERROR: column "null" does not exist CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=''); ERROR: column "" does not exist CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='foo'); ERROR: column "foo" does not exist CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.partition_column='time'); ERROR: timescaledb options requires hypertable option CREATE TABLE t2(time timestamptz, device text, value float) WITH (timescaledb.partition_column='time'); ERROR: timescaledb options requires hypertable option CREATE TABLE t2(time timestamptz , device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='foo'); ERROR: invalid input syntax for type interval: "foo" CREATE TABLE t2(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); ERROR: invalid input syntax for type smallint: "3 months" CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes='time'); ERROR: invalid value for tsdb.create_default_indexes 'time' CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=2); ERROR: invalid value for tsdb.create_default_indexes '2' CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=-1); ERROR: invalid value for tsdb.create_default_indexes '-1' \set ON_ERROR_STOP 1 BEGIN; CREATE TABLE t3(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE t4(time timestamp, device text, value float) WITH (tsdb.hypertable,timescaledb.partitioning_column='time'); CREATE TABLE t5(time date, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',autovacuum_enabled); CREATE TABLE t6(time timestamptz NOT NULL, device text, value float) WITH (timescaledb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; hypertable_name ----------------- t3 t4 t5 t6 ROLLBACK; -- IF NOT EXISTS BEGIN; CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); NOTICE: relation "t7" already exists, skipping CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float); NOTICE: relation "t7" already exists, skipping SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; hypertable_name ----------------- t7 ROLLBACK; -- table won't be converted to hypertable unless it is in the initial CREATE TABLE BEGIN; CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); NOTICE: relation "t8" already exists, skipping CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); NOTICE: relation "t8" already exists, skipping SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; hypertable_name ----------------- ROLLBACK; -- chunk_interval BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='8weeks'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | time_interval -----------------+-------------+--------------------------+--------------- t9 | time | timestamp with time zone | @ 56 days ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamp NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='23 days'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | time_interval -----------------+-------------+-----------------------------+--------------- t9 | time | timestamp without time zone | @ 23 days ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time date NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | time_interval -----------------+-------------+-------------+--------------- t9 | time | date | @ 90 days ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=12); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | integer_interval -----------------+-------------+-------------+------------------ t9 | time | smallint | 12 ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int4 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=3453); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | integer_interval -----------------+-------------+-------------+------------------ t9 | time | integer | 3453 ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int8 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=32768); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; hypertable_name | column_name | column_type | integer_interval -----------------+-------------+-------------+------------------ t9 | time | bigint | 32768 ROLLBACK; -- create_default_indexes BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid -------------- t10_time_idx ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL PRIMARY KEY, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid ------------ t10_pkey ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL UNIQUE, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid -------------- t10_time_key ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=true); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid -------------- t10_time_idx ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=false); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; indexrelid ------------ ROLLBACK; -- associated_schema BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; associated_schema_name ------------------------ _timescaledb_internal ROLLBACK; BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; associated_schema_name ------------------------ abc INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; relname -------------------------------- _hyper_35_1_chunk _hyper_35_1_chunk_t11_time_idx ROLLBACK; BEGIN; CREATE SCHEMA abc2; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc2'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; associated_schema_name ------------------------ abc2 INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc2'::regnamespace ORDER BY 1; relname -------------------------------- _hyper_37_2_chunk _hyper_37_2_chunk_t11_time_idx ROLLBACK; -- associated_table_prefix BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; associated_table_prefix ------------------------- _hyper_39 ROLLBACK; BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc', tsdb.associated_table_prefix='tbl_prefix'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; associated_table_prefix ------------------------- tbl_prefix INSERT INTO t12 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; relname --------------------------------- tbl_prefix_3_chunk tbl_prefix_3_chunk_t12_time_idx ROLLBACK; -- verify compression BEGIN; CREATE TABLE t13(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t13 | t INSERT INTO t13 SELECT '2025-01-01','d1',0.1; SELECT compress_chunk(show_chunks('t13')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_43_4_chunk ROLLBACK; BEGIN; CREATE TABLE t13(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t13 | t ALTER TABLE t13 SET (tsdb.compress_segmentby='device',tsdb.compress_orderby='time DESC'); INSERT INTO t13 SELECT '2025-01-01','d1',0.1; SELECT compress_chunk(show_chunks('t13')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_45_6_chunk ROLLBACK; -- test segmentby and orderby BEGIN; CREATE TABLE t14(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.order_by='value'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+--------------+--------------+--------------------+------- t14 | | | {value,time} | {f,t} | {f,t} | ROLLBACK; BEGIN; CREATE TABLE t15(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.order_by='time'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- t15 | | | {time} | {f} | {f} | ROLLBACK; BEGIN; CREATE TABLE t16(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.segment_by='device'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- t16 | | {device} | | | | ROLLBACK; BEGIN; CREATE TABLE t17(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.segment_by='device', tsdb.order_by='time,value'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+--------------+--------------+--------------------+------- t17 | | {device} | {time,value} | {f,f} | {f,f} | ROLLBACK; BEGIN; CREATE TABLE t18(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.segmentby='device', tsdb.orderby='time,value'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+--------------+--------------+--------------------+------- t18 | | {device} | {time,value} | {f,f} | {f,f} | ROLLBACK; BEGIN; CREATE TABLE t18(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.compress_segmentby='device', tsdb.compress_orderby='time,value'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+--------------+--------------+--------------------+------- t18 | | {device} | {time,value} | {f,f} | {f,f} | ROLLBACK; -- test columnstore option BEGIN; CREATE TABLE t19(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t19 | t ROLLBACK; BEGIN; CREATE TABLE t20(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t20 | t ROLLBACK; BEGIN; CREATE TABLE t21(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t21 | t ROLLBACK; BEGIN; CREATE TABLE t22(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=false); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t22 | f ROLLBACK; BEGIN; CREATE TABLE t23(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.compress=false); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t23 | f ROLLBACK; BEGIN; CREATE TABLE t24(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.enable_columnstore=false); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; hypertable_name | compression_enabled -----------------+--------------------- t24 | f ROLLBACK; BEGIN; CREATE TABLE t25(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 't25'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- t25 | | | | | | ROLLBACK; -- test compression policy creation with columnstore BEGIN; CREATE TABLE t25_policy(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy'; hypertable_name | compression_enabled -----------------+--------------------- t25_policy | t SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy' AND proc_name = 'policy_compression'; hypertable_name | schedule_interval | next_start | config -----------------+-------------------+--------------------------------+----------------------------------------------------- t25_policy | @ 1 day | in 01 days 00 hours 00 minutes | {"hypertable_id": 70, "compress_after": "@ 7 days"} ROLLBACK; -- test compression policy creation with custom chunk interval BEGIN; CREATE TABLE t25_policy_custom(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 days',tsdb.columnstore=true); SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_custom' AND proc_name = 'policy_compression'; hypertable_name | schedule_interval | next_start | config -------------------+-------------------+--------------------------------+----------------------------------------------------- t25_policy_custom | @ 1 day | in 01 days 00 hours 00 minutes | {"hypertable_id": 72, "compress_after": "@ 3 days"} ROLLBACK; -- test compression policy creation with integer partition column (int2) BEGIN; CREATE TABLE t25_policy_int2(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=100,tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy_int2'; hypertable_name | compression_enabled -----------------+--------------------- t25_policy_int2 | t SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_int2' AND proc_name = 'policy_compression'; hypertable_name | schedule_interval | next_start | config -----------------+-------------------+--------------------------------+---------------------------------------------- t25_policy_int2 | @ 1 day | in 01 days 00 hours 00 minutes | {"hypertable_id": 74, "compress_after": 100} ROLLBACK; -- test compression policy creation with integer partition column (int4) BEGIN; CREATE TABLE t25_policy_int4(time int4 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=1000,tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy_int4'; hypertable_name | compression_enabled -----------------+--------------------- t25_policy_int4 | t SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_int4' AND proc_name = 'policy_compression'; hypertable_name | schedule_interval | next_start | config -----------------+-------------------+--------------------------------+----------------------------------------------- t25_policy_int4 | @ 1 day | in 01 days 00 hours 00 minutes | {"hypertable_id": 76, "compress_after": 1000} ROLLBACK; -- test compression policy creation with integer partition column (int8) BEGIN; CREATE TABLE t25_policy_int8(time int8 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=10000,tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy_int8'; hypertable_name | compression_enabled -----------------+--------------------- t25_policy_int8 | t SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_int8' AND proc_name = 'policy_compression'; hypertable_name | schedule_interval | next_start | config -----------------+-------------------+--------------------------------+------------------------------------------------ t25_policy_int8 | @ 1 day | in 01 days 00 hours 00 minutes | {"hypertable_id": 78, "compress_after": 10000} ROLLBACK; BEGIN; -- don't allow empty orderby \set ON_ERROR_STOP 0 CREATE TABLE t26(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby = ''); ERROR: ordering column can not be empty SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 't26'::regclass; ERROR: current transaction is aborted, commands ignored until end of transaction block ROLLBACK; \set ON_ERROR_STOP 1 -- can allow empty segmentby BEGIN; CREATE TABLE t27(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.segmentby = ''); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 't27'::regclass; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+------- t27 | | {} | | | | ROLLBACK; -- test configurable bloom and minmax BEGIN; CREATE TABLE t28(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='time', tsdb.index='bloom(value)'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------------------------------------------- t28 | | | {time} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] ROLLBACK; BEGIN; CREATE TABLE t29(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='time', tsdb.index='bloom(value),minmax(device)'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- t29 | | | {time} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "config"}, {"type": "minmax", "column": "device", "source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] ROLLBACK; --multi column BEGIN; CREATE TABLE t30(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='time',tsdb.index='bloom(value),bloom(device)'); SELECT * FROM _timescaledb_catalog.compression_settings; relid | compress_relid | segmentby | orderby | orderby_desc | orderby_nullsfirst | index -------+----------------+-----------+---------+--------------+--------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- t30 | | | {time} | {f} | {f} | [{"type": "bloom", "column": "value", "source": "config"}, {"type": "bloom", "column": "device", "source": "config"}, {"type": "minmax", "column": "time", "source": "orderby"}] ROLLBACK; --test errors \set ON_ERROR_STOP 0 -- invalid syntax BEGIN; CREATE TABLE t31(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),bloom(count(device))'); ERROR: sparse index bloom's first option must reference a valid column. ROLLBACK; BEGIN; CREATE TABLE t32(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='value,bloom(count(device))'); ERROR: unable to parse sparse index option "value,bloom(count(device))" ROLLBACK; -- duplicate column BEGIN; CREATE TABLE t33(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),minmax(value)'); ERROR: duplicate column name "value" ROLLBACK; BEGIN; CREATE TABLE t34(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),bloom(value)'); ERROR: duplicate column name "value" ROLLBACK; -- invalid column BEGIN; CREATE TABLE t35(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),bloom(foo)'); ERROR: column "foo" does not exist ROLLBACK; -- same column as orderby BEGIN; CREATE TABLE t36(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value)'); ERROR: the orderby column "value" cannot have a bloom sparse index ROLLBACK; BEGIN; CREATE TABLE t37(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='minmax(value)'); ROLLBACK; -- same column as segmentby BEGIN; CREATE TABLE t38(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.segmentby='device', tsdb.index='minmax(device)'); ERROR: the segmentby column "device" can not have sparse indexes ROLLBACK; -- guc disabled set timescaledb.enable_sparse_index_bloom to false; BEGIN; CREATE TABLE t39(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value)'); ERROR: Creating bloom sparse index is disabled ROLLBACK; --no orderby BEGIN; CREATE TABLE t40(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.index='bloom(value)'); ERROR: cannot set sparse index option without orderby option ROLLBACK; \set ON_ERROR_STOP 1 reset timescaledb.enable_sparse_index_bloom; -- test UUID partitioning + compression BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ) WITH ( tsdb.hypertable, tsdb.partition_column='event_id', tsdb.order_by='ts DESC, event_id', tsdb.segment_by='entity_id', tsdb.chunk_interval='2 hours', tsdb.compress=true ); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 'events'; hypertable_name | compression_enabled -----------------+--------------------- events | t SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 'events' AND proc_name = 'policy_compression'; hypertable_name | schedule_interval | next_start | config -----------------+-------------------+--------------------------------+------------------------------------------------------- events | @ 1 day | in 01 days 00 hours 00 minutes | {"hypertable_id": 100, "compress_after": "@ 2 hours"} ROLLBACK; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/custom_hashagg.out���������������������������������������������0000664�0000000�0000000�00000004503�15100345067�0023164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. create table foo( a integer, b timestamptz); select count(*) from create_hypertable('foo', 'b'); count ------- 1 insert into foo values (1, '2004-10-19 10:23:54'), (1, '2005-10-19 10:23:54'), (1, '2005-01-01 00:00:00+00'), (2, '2005-01-01 00:00:00+00'); -- Test that the range estimation functions estimate_max_spread_var() -- is used for custom hash aggregates and that they behave in a sane -- manner when there are errors. -- -- To trigger a call to the function, the following are required: -- -- timescaledb.enable_custom_hashagg to be true -- -- query should either date_trunc or time_bucket bucket function -- with a recognized time type -- -- an aggregation function in the result -- -- a group-by on the bucket created by the date_trunc or time_bucket -- -- statistics recorded for the variable used in the bucketing -- function set timescaledb.enable_custom_hashagg to true; analyze foo; explain (buffers off, costs off) select date_trunc('hour', b) bucket, sum(a) from foo group by bucket; --- QUERY PLAN --- Finalize HashAggregate Group Key: (date_trunc('hour'::text, foo.b)) -> Append -> Partial HashAggregate Group Key: date_trunc('hour'::text, _hyper_1_1_chunk.b) -> Seq Scan on _hyper_1_1_chunk -> Partial HashAggregate Group Key: date_trunc('hour'::text, _hyper_1_2_chunk.b) -> Seq Scan on _hyper_1_2_chunk -> Partial HashAggregate Group Key: date_trunc('hour'::text, _hyper_1_3_chunk.b) -> Seq Scan on _hyper_1_3_chunk select date_trunc('hour', b) bucket, sum(a) from foo group by bucket; bucket | sum ------------------------------+----- Fri Dec 31 16:00:00 2004 PST | 3 Tue Oct 19 10:00:00 2004 PDT | 1 Wed Oct 19 10:00:00 2005 PDT | 1 -- Inserting a very large value should trigger an error inside the -- range estimation function estimate_max_spread_var() and test that -- it works even in the presence of errors. insert into foo values (99, 'epoch'::timestamptz + '9223371331200000000'::bigint * '1 microsecond'::interval); ERROR: timestamp out of range ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/decompress_index.out�������������������������������������������0000664�0000000�0000000�00000013662�15100345067�0023531�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; CREATE TABLE ht_metrics_compressed(time timestamptz, device int, value float, tag text); ALTER TABLE ht_metrics_compressed SET (autovacuum_enabled = false); SELECT create_hypertable('ht_metrics_compressed','time',create_default_indexes:=false, chunk_time_interval => interval '100 day'); create_hypertable ------------------------------------ (1,public,ht_metrics_compressed,t) ALTER TABLE ht_metrics_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); -- helper function: float -> pseudorandom float [0..1]. CREATE OR REPLACE FUNCTION mix(x float4) RETURNS float4 AS $$ SELECT ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ LANGUAGE SQL; INSERT INTO ht_metrics_compressed SELECT '2020-05-18'::timestamptz + interval '1 second' * (x + 0.1 * mix(device + x * 10)), device, 100 * mix(device) * sin(x / 3600) + 100 * mix(device + 1) * sin(x / (3600 * 24)) + 100 * mix(device + 2) * sin(x / (3600 * 24 * 7)) + mix(device + x * 10 + 1), format('this-is-a-long-tag-#%s', x % 29) FROM generate_series(1, 3600 * 24 * 90, 100) x, generate_series(1,2) device; analyze ht_metrics_compressed; select show_chunks('ht_metrics_compressed') as "CHUNK" limit 1 \gset select count(*) from :CHUNK; count -------- 155520 select count(distinct tag) from :CHUNK; count ------- 29 select device, min(time), max(time) from :CHUNK group by 1 order by 1, 2, 3; device | min | max --------+-------------------------------------+------------------------------------ 1 | Mon May 18 00:00:01.037881 2020 PDT | Sat Aug 15 23:58:21.04471 2020 PDT 2 | Mon May 18 00:00:01.013087 2020 PDT | Sat Aug 15 23:58:21.04471 2020 PDT -- decompress with no indexes select where compress_chunk(:'CHUNK') is null; -- select where decompress_chunk(:'CHUNK') is null; -- -- decompress with one index select where compress_chunk(:'CHUNK') is null; -- create index on :CHUNK(device, time); select where decompress_chunk(:'CHUNK') is null; -- -- decompress with two indexes select where compress_chunk(:'CHUNK') is null; -- create index on :CHUNK(tag); select where decompress_chunk(:'CHUNK') is null; -- -- check the data after decompression set enable_seqscan to off; select count(*) from :CHUNK; count -------- 155520 select count(distinct tag) from :CHUNK; count ------- 29 select distinct on (device) device, time from :CHUNK order by 1, 2; device | time --------+------------------------------------- 1 | Mon May 18 00:00:01.037881 2020 PDT 2 | Mon May 18 00:00:01.013087 2020 PDT -- To avoid differences in PG15 output which doesn't support this feature SET timescaledb.enable_skipscan_for_distinct_aggregates TO false; -- check that the indexes are used explain (buffers off, costs off) select count(distinct tag) from :CHUNK; --- QUERY PLAN --- Aggregate -> Index Only Scan using _hyper_1_1_chunk_tag_idx on _hyper_1_1_chunk explain (buffers off, costs off) select distinct on (device) device, time from :CHUNK order by 1, 2; --- QUERY PLAN --- Unique -> Custom Scan (SkipScan) on _hyper_1_1_chunk -> Index Only Scan using _hyper_1_1_chunk_device_time_idx on _hyper_1_1_chunk Index Cond: (device > NULL::integer) RESET timescaledb.enable_skipscan_for_distinct_aggregates; drop table ht_metrics_compressed; -- Fix for issue #8681: IndexScan is not chosen for columnstore segmented on varchar column -- We should chose IndexScan now, and use SkipScan as well CREATE TABLE record (time timestamptz not null, data varchar); SELECT table_name FROM create_hypertable('record','time'); WARNING: column type "character varying" used for "data" does not follow best practices table_name ------------ record ALTER TABLE record SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='data'); INSERT INTO record SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); analyze record; SELECT compress_chunk(ch) FROM show_chunks('record') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk -- enable_seqscan is OFF, should see IndexScan explain (buffers off, costs off) SELECT * FROM record ORDER BY data; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_5_chunk -> Index Scan using compress_hyper_4_6_chunk_data__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_6_chunk -- SkipScan is chosen because IndexScan is chosen explain (buffers off, costs off) SELECT DISTINCT ON(data) * FROM record; --- QUERY PLAN --- Unique -> Custom Scan (SkipScan) on _hyper_3_5_chunk -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk -> Index Scan using compress_hyper_4_6_chunk_data__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_6_chunk -- (seg_col = const) condition is checked even when seg_col is coerced explain (buffers off, costs off) SELECT * FROM record WHERE data='Yes' ORDER BY data; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_5_chunk -> Index Scan using compress_hyper_4_6_chunk_data__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_6_chunk Index Cond: ((data)::text = 'Yes'::text) explain (buffers off, costs off) SELECT * FROM record WHERE 'Yes' <= data ORDER BY data; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_3_5_chunk -> Index Scan using compress_hyper_4_6_chunk_data__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_6_chunk Index Cond: ((data)::text >= 'Yes'::text) drop table record cascade; ������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/decompress_memory.out������������������������������������������0000664�0000000�0000000�00000007713�15100345067�0023732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; CREATE TABLE ht_metrics_compressed(time timestamptz, device int, value float, tag text); ALTER TABLE ht_metrics_compressed SET (autovacuum_enabled = false); SELECT create_hypertable('ht_metrics_compressed','time',create_default_indexes:=false); create_hypertable ------------------------------------ (1,public,ht_metrics_compressed,t) ALTER TABLE ht_metrics_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); -- helper function: float -> pseudorandom float [0..1]. CREATE OR REPLACE FUNCTION mix(x float4) RETURNS float4 AS $$ SELECT ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ LANGUAGE SQL; INSERT INTO ht_metrics_compressed SELECT '2020-01-08'::timestamptz + interval '1 second' * (x + 0.1 * mix(device + x * 10)), device, 100 * mix(device) * sin(x / 3600) + 100 * mix(device + 1) * sin(x / (3600 * 24)) + 100 * mix(device + 2) * sin(x / (3600 * 24 * 7)) + mix(device + x * 10 + 1), format('this-is-a-long-tag-#%s', x % 29) FROM generate_series(1, 3600 * 24 * 356, 100) x, generate_series(1,2) device; -- compress it all SELECT count(compress_chunk(c, true)) FROM show_chunks('ht_metrics_compressed') c; count ------- 52 select count(*) from ht_metrics_compressed; count -------- 615168 -- Helper function that returns the amount of memory currently allocated in a -- given memory context. create or replace function ts_debug_allocated_bytes(text = 'PortalContext') returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; -- Check that decompression doesn't leak memory. Record memory usage after each -- compressed chunk, and use linear regression to tell if memory usage grows. with log as materialized ( select rank() over (order by c) n, ts_debug_allocated_bytes() b, decompress_chunk(c, true) from show_chunks('ht_metrics_compressed') c order by c) , regression as (select regr_slope(b, n) slope, regr_intercept(b, n) intercept from log) select * from log where (select slope / intercept::float > 0.01 from regression) ; n | b | decompress_chunk ---+---+------------------ -- Same as above but for compression. with log as materialized ( select rank() over (order by c) n, ts_debug_allocated_bytes() b, compress_chunk(c, true) from show_chunks('ht_metrics_compressed') c order by c) , regression as (select regr_slope(b, n) slope, regr_intercept(b, n) intercept from log) select * from log where (select slope / intercept::float > 0.01 from regression) ; n | b | compress_chunk ---+---+---------------- -- Test recompression with small batches. select count(decompress_chunk(c, true)) from show_chunks('ht_metrics_compressed') c; count ------- 52 alter table ht_metrics_compressed set (timescaledb.compress, timescaledb.compress_segmentby='time', timescaledb.compress_orderby='value'); select count(compress_chunk(c, true)) from show_chunks('ht_metrics_compressed') c; count ------- 52 update ht_metrics_compressed set value = 0 where value < 1 and value > -1; with to_recompress as ( select tableoid::oid::regclass c, count(*) r from ht_metrics_compressed where value = 0 group by 1 ), log as materialized ( select rank() over (order by r) n, ts_debug_allocated_bytes(case when _timescaledb_functions.recompress_chunk_segmentwise(c)::text != '' then 'PortalContext' else '' end) b from show_chunks('ht_metrics_compressed') c join to_recompress using (c) order by r), regression as (select regr_slope(b, n) slope, regr_intercept(b, n) intercept from log) select * from log where (select slope / intercept::float > 0.01 from regression) ; n | b ---+--- �����������������������������������������������������timescaledb-2.23.0/tsl/test/expected/decompress_vector_qual.out�������������������������������������0000664�0000000�0000000�00000250133�15100345067�0024742�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER create function stable_abs(x int4) returns int4 as 'int4abs' language internal stable; create table vectorqual(metric1 int8, ts timestamp, metric2 int8, device int8); select create_hypertable('vectorqual', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable ------------------------- (1,public,vectorqual,t) alter table vectorqual set (timescaledb.compress, timescaledb.compress_segmentby = 'device'); insert into vectorqual(ts, device, metric1, metric2) values ('2020-01-01 00:00:00', 1, 11, 12); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; count ------- 1 alter table vectorqual drop column metric1; insert into vectorqual(ts, device, metric2) values ('2021-01-01 00:00:00', 2, 22); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore count ------- 2 alter table vectorqual add column metric3 int4 default 777; insert into vectorqual(ts, device, metric2, metric3) values ('2022-01-01 00:00:00', 3, 32, 33); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_3_chunk" is already converted to columnstore count ------- 3 alter table vectorqual add column metric4 int8; insert into vectorqual(ts, device, metric2, metric3, metric4) values ('2023-01-01 00:00:00', 4, 42, 43, 44); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_3_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_5_chunk" is already converted to columnstore count ------- 4 select * from vectorqual order by vectorqual; ts | metric2 | device | metric3 | metric4 --------------------------+---------+--------+---------+--------- Wed Jan 01 00:00:00 2020 | 12 | 1 | 777 | Fri Jan 01 00:00:00 2021 | 22 | 2 | 777 | Sat Jan 01 00:00:00 2022 | 32 | 3 | 33 | Sun Jan 01 00:00:00 2023 | 42 | 4 | 43 | 44 -- single chunk select * from vectorqual where ts between '2019-02-02' and '2020-02-02' order by vectorqual; ts | metric2 | device | metric3 | metric4 --------------------------+---------+--------+---------+--------- Wed Jan 01 00:00:00 2020 | 12 | 1 | 777 | select * from vectorqual where ts between '2020-02-02' and '2021-02-02' order by vectorqual; ts | metric2 | device | metric3 | metric4 --------------------------+---------+--------+---------+--------- Fri Jan 01 00:00:00 2021 | 22 | 2 | 777 | select * from vectorqual where ts between '2021-02-02' and '2022-02-02' order by vectorqual; ts | metric2 | device | metric3 | metric4 --------------------------+---------+--------+---------+--------- Sat Jan 01 00:00:00 2022 | 32 | 3 | 33 | select * from vectorqual where ts between '2022-02-02' and '2023-02-02' order by vectorqual; ts | metric2 | device | metric3 | metric4 --------------------------+---------+--------+---------+--------- Sun Jan 01 00:00:00 2023 | 42 | 4 | 43 | 44 set timescaledb.debug_require_vector_qual to 'require' /* all following quals must be vectorized */; select count(*) from vectorqual where ts > '1999-01-01 00:00:00'; count ------- 4 select count(*) from vectorqual where metric2 = 22; count ------- 1 select count(*) from vectorqual where 22 = metric2 /* commutators */; count ------- 1 select count(*) from vectorqual where metric3 = 33; count ------- 1 select count(*) from vectorqual where metric3 = 777 /* default value */; count ------- 2 select count(*) from vectorqual where metric4 = 44 /* column with default null */; count ------- 1 select count(*) from vectorqual where metric4 >= 0 /* nulls shouldn't pass the qual */; count ------- 1 set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where device = 1 /* can't apply vector ops to the segmentby column */; count ------- 1 -- Test various combinations of arithmetic types. create table arithmetic(ts int, a int2, b int4, c int8, d float4, e float8, ax int2, bx int4, cx int8, dx float4, ex float8); select create_hypertable('arithmetic', 'ts'); create_hypertable ------------------------- (3,public,arithmetic,t) alter table arithmetic set (timescaledb.compress); insert into arithmetic values (100, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), (101, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); select count(compress_chunk(x, true)) from show_chunks('arithmetic') x; count ------- 1 set timescaledb.debug_require_vector_qual to 'require'; select * from arithmetic where a > 1::int2 and a > 1::int4 and a > 1::int8 and b > 1::int2 and b > 1::int4 and b > 1::int8 and c > 1::int2 and c > 1::int4 and c > 1::int8 and d > 1::int2 and d > 1::int4 and d > 1::int8 and d > 1::float4 and d > 1::float8 and e > 1::int2 and e > 1::int4 and e > 1::int8 and e > 1::float4 and e > 1::float8 ; ts | a | b | c | d | e | ax | bx | cx | dx | ex -----+---+---+---+---+---+----+----+----+----+---- 101 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 -- Test columns that don't support bulk decompression. alter table vectorqual add column tag name; insert into vectorqual(ts, device, metric2, metric3, metric4, tag) values ('2025-01-01 00:00:00', 5, 52, 53, 54, 'tag5'); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_3_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_5_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_7_chunk" is already converted to columnstore count ------- 5 set timescaledb.debug_require_vector_qual to 'require'; select tag from vectorqual where metric2 > 0; tag ------ tag5 -- Can't vectorize parameterized join clauses for now. set timescaledb.debug_require_vector_qual to 'forbid'; set enable_hashjoin to off; set enable_mergejoin to off; with values(x) as materialized(select distinct metric2 from vectorqual) select x, (select metric2 from vectorqual where metric2 = x) from values order by 1; x | metric2 ----+--------- 12 | 12 22 | 22 32 | 32 42 | 42 52 | 52 reset enable_hashjoin; reset enable_mergejoin; -- Can't vectorize initplan parameters either. select count(*) from vectorqual where metric2 = (select metric2 from vectorqual order by 1 limit 1); count ------- 1 -- Can vectorize clauses with query parameters. set timescaledb.debug_require_vector_qual to 'require'; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from vectorqual where metric3 = $1; execute p(33); count ------- 1 deallocate p; -- Also try query parameter in combination with a stable function. prepare p(int4) as select count(*) from vectorqual where metric3 = stable_abs($1); execute p(33); count ------- 1 deallocate p; reset plan_cache_mode; -- Queries without aggregation. set timescaledb.debug_require_vector_qual to 'require'; select * from vectorqual where ts > '2021-01-01 00:00:00' order by vectorqual; ts | metric2 | device | metric3 | metric4 | tag --------------------------+---------+--------+---------+---------+------ Sat Jan 01 00:00:00 2022 | 32 | 3 | 33 | | Sun Jan 01 00:00:00 2023 | 42 | 4 | 43 | 44 | Wed Jan 01 00:00:00 2025 | 52 | 5 | 53 | 54 | tag5 select * from vectorqual where metric4 >= 0 order by vectorqual; ts | metric2 | device | metric3 | metric4 | tag --------------------------+---------+--------+---------+---------+------ Sun Jan 01 00:00:00 2023 | 42 | 4 | 43 | 44 | Wed Jan 01 00:00:00 2025 | 52 | 5 | 53 | 54 | tag5 -- Constraints on columns not selected. select metric4 from vectorqual where ts > '2021-01-01 00:00:00' order by 1; metric4 --------- 44 54 -- ANDed constraints on multiple columns. select * from vectorqual where ts > '2021-01-01 00:00:00' and metric3 > 40 order by vectorqual; ts | metric2 | device | metric3 | metric4 | tag --------------------------+---------+--------+---------+---------+------ Sun Jan 01 00:00:00 2023 | 42 | 4 | 43 | 44 | Wed Jan 01 00:00:00 2025 | 52 | 5 | 53 | 54 | tag5 -- ORed constrainst on multiple columns. set timescaledb.debug_require_vector_qual to 'require'; -- set timescaledb.debug_require_vector_qual to 'forbid'; -- set timescaledb.enable_bulk_decompression to off; select * from vectorqual where ts > '2021-01-01 00:00:00' or metric3 > 40 order by vectorqual; ts | metric2 | device | metric3 | metric4 | tag --------------------------+---------+--------+---------+---------+------ Wed Jan 01 00:00:00 2020 | 12 | 1 | 777 | | Fri Jan 01 00:00:00 2021 | 22 | 2 | 777 | | Sat Jan 01 00:00:00 2022 | 32 | 3 | 33 | | Sun Jan 01 00:00:00 2023 | 42 | 4 | 43 | 44 | Wed Jan 01 00:00:00 2025 | 52 | 5 | 53 | 54 | tag5 -- Some more tests for boolean operations. select count(*) from vectorqual where ts > '2021-01-01 00:00:00'; count ------- 3 select count(*) from vectorqual where 40 < metric3; count ------- 4 select count(*) from vectorqual where metric2 < 0; count ------- 0 select count(*) from vectorqual where ts > '2021-01-01 00:00:00' or 40 < metric3; count ------- 5 select count(*) from vectorqual where not (ts <= '2021-01-01 00:00:00' and 40 >= metric3); count ------- 5 -- early exit inside AND BoolExpr select count(*) from vectorqual where metric2 < 0 or (metric4 < -1 and 40 >= metric3); count ------- 0 -- early exit after OR BoolExpr select count(*) from vectorqual where metric2 < 0 or metric3 < -1; count ------- 0 -- expression evaluated to null at run time select count(*) from vectorqual where metric3 = 777 or metric3 > case when now() > now() - interval '1s' then null else 1 end; count ------- 2 reset timescaledb.enable_bulk_decompression; -- Test with unary operator. set timescaledb.debug_require_vector_qual to 'forbid'; create operator !! (function = 'bool', rightarg = int4); select count(*) from vectorqual where !!metric3; count ------- 5 select count(*) from vectorqual where not !!metric3; count ------- 0 -- Custom operator on column that supports bulk decompression is not vectorized. set timescaledb.debug_require_vector_qual to 'forbid'; create function int4eqq(int4, int4) returns bool as 'int4eq' language internal; create operator === (function = 'int4eqq', rightarg = int4, leftarg = int4); select count(*) from vectorqual where metric3 === 777; count ------- 2 select count(*) from vectorqual where metric3 === any(array[777, 888]); count ------- 2 select count(*) from vectorqual where not metric3 === 777; count ------- 3 select count(*) from vectorqual where metric3 = 777 or metric3 === 777; count ------- 2 -- Custom operator that can be vectorized but doesn't have a negator. create operator !!! (function = 'int4ne', rightarg = int4, leftarg = int4); set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric3 !!! 777; count ------- 3 select count(*) from vectorqual where metric3 !!! any(array[777, 888]); count ------- 5 select count(*) from vectorqual where metric3 !!! 777 or metric3 !!! 888; count ------- 5 select count(*) from vectorqual where metric3 !!! 666 and (metric3 !!! 777 or metric3 !!! 888); count ------- 5 select count(*) from vectorqual where metric3 !!! 666 and (metric3 !!! 777 or metric3 !!! stable_abs(888)); count ------- 5 set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where not metric3 !!! 777; count ------- 2 select count(*) from vectorqual where metric3 !!! 666 or (metric3 !!! 777 and not metric3 !!! 888); count ------- 5 select count(*) from vectorqual where metric3 !!! 666 or not (metric3 !!! 777 and not metric3 !!! 888); count ------- 5 set timescaledb.debug_require_vector_qual to 'allow'; select count(*) from vectorqual where metric3 !!! 777 or not metric3 !!! 888; count ------- 3 select count(*) from vectorqual where metric3 !!! 777 and not metric3 !!! 888; count ------- 0 select count(*) from vectorqual where not(metric3 !!! 666 or not (metric3 !!! 777 and not metric3 !!! 888)); count ------- 0 -- These operators don't have a commutator. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where 777 === metric3; count ------- 2 select count(*) from vectorqual where 777 !!! metric3; count ------- 3 -- NullTest is vectorized. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric4 is null; count ------- 3 select count(*) from vectorqual where metric4 is not null; count ------- 2 select count(*) from vectorqual where metric3 = 777 or metric4 is not null; count ------- 4 select count(*) from vectorqual where metric3 = stable_abs(777) or metric4 is null; count ------- 3 -- Can't vectorize conditions on system columns. Have to check this on a single -- chunk, otherwise the whole-row var will be masked by ConvertRowType. select show_chunks('vectorqual') chunk1 limit 1 \gset set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from :chunk1 t where t is null; count ------- 0 select count(*) from :chunk1 t where t.* is null; count ------- 0 select count(*) from :chunk1 t where tableoid is null; count ------- 0 -- Scalar array operators are vectorized if the operator is vectorizable. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric3 = any(array[777, 888]); /* default value */ count ------- 2 select count(*) from vectorqual where metric4 = any(array[44, 55]) /* default null */; count ------- 1 select count(*) from vectorqual where metric2 > any(array[-1, -2, -3]) /* any */; count ------- 5 select count(*) from vectorqual where metric2 > all(array[-1, -2, -3]) /* all */; count ------- 5 -- Also have to support null array elements, because they are impossible to -- prevent in stable expressions. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric2 = any(array[null::int]) /* any with null element */; count ------- 0 select count(*) from vectorqual where metric2 = any(array[22, null]) /* any with null element */; count ------- 1 select count(*) from vectorqual where metric2 = any(array[null, 32]) /* any with null element */; count ------- 1 select count(*) from vectorqual where metric2 = any(array[22, null, 32]) /* any with null element */; count ------- 2 select count(*) from vectorqual where metric2 = all(array[null::int]) /* all with null element */; count ------- 0 select count(*) from vectorqual where metric2 = all(array[22, null]) /* all with null element */; count ------- 0 select count(*) from vectorqual where metric2 = all(array[null, 32]) /* all with null element */; count ------- 0 select count(*) from vectorqual where metric2 = all(array[22, null, 32]) /* all with null element */; count ------- 0 select count(*) from vectorqual where metric2 = all(array[]::int[]); count ------- 5 select count(*) from vectorqual where metric2 = any(array[]::int[]); count ------- 0 select count(*) from vectorqual where metric2 = all(null::int[]); count ------- 0 select count(*) from vectorqual where metric2 = any(null::int[]); count ------- 0 -- Check early exit. reset timescaledb.debug_require_vector_qual; create table singlebatch(like vectorqual); select create_hypertable('singlebatch', 'ts'); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable -------------------------- (5,public,singlebatch,t) alter table singlebatch set (timescaledb.compress); insert into singlebatch select '2022-02-02 02:02:02', metric2, device, metric3, metric4, tag from vectorqual; select count(compress_chunk(x, true)) from show_chunks('singlebatch') x; count ------- 1 set timescaledb.debug_require_vector_qual to 'require'; -- Uncomment to generate the test reference w/o the vector optimizations. -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 22]); count ------- 1 select count(*) from singlebatch where metric2 = any(array[0, 22, 0, 0, 0]); count ------- 1 select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 0]); count ------- 0 select count(*) from singlebatch where metric2 != any(array[0, 0, 0, 0, 0]); count ------- 5 select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 0]); count ------- 0 select count(*) from singlebatch where metric2 <= all(array[12, 0, 12, 12, 12]); count ------- 0 select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 12]); count ------- 1 select count(*) from singlebatch where metric3 = 777 and metric2 = any(array[0, 0, 0, 0, 22]); count ------- 1 select count(*) from singlebatch where metric3 = 777 and metric2 = any(array[0, 22, 0, 0, 0]); count ------- 1 select count(*) from singlebatch where metric3 = 777 and metric2 = any(array[0, 0, 0, 0, 0]); count ------- 0 select count(*) from singlebatch where metric3 = 777 and metric2 != any(array[0, 0, 0, 0, 0]); count ------- 2 select count(*) from singlebatch where metric3 = 777 and metric2 <= all(array[12, 12, 12, 12, 0]); count ------- 0 select count(*) from singlebatch where metric3 = 777 and metric2 <= all(array[12, 0, 12, 12, 12]); count ------- 0 select count(*) from singlebatch where metric3 = 777 and metric2 <= all(array[12, 12, 12, 12, 12]); count ------- 1 select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 22]) and metric3 = 777; count ------- 1 select count(*) from singlebatch where metric2 = any(array[0, 22, 0, 0, 0]) and metric3 = 777; count ------- 1 select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 0]) and metric3 = 777; count ------- 0 select count(*) from singlebatch where metric2 != any(array[0, 0, 0, 0, 0]) and metric3 = 777; count ------- 2 select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 0]) and metric3 = 777; count ------- 0 select count(*) from singlebatch where metric2 <= all(array[12, 0, 12, 12, 12]) and metric3 = 777; count ------- 0 select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 12]) and metric3 = 777; count ------- 1 select count(*) from singlebatch where metric3 != 777 and metric2 = any(array[0, 0, 0, 0, 22]); count ------- 0 select count(*) from singlebatch where metric3 != 777 and metric2 = any(array[0, 22, 0, 0, 0]); count ------- 0 select count(*) from singlebatch where metric3 != 777 and metric2 = any(array[0, 0, 0, 0, 0]); count ------- 0 select count(*) from singlebatch where metric3 != 777 and metric2 != any(array[0, 0, 0, 0, 0]); count ------- 3 select count(*) from singlebatch where metric3 != 777 and metric2 <= all(array[12, 12, 12, 12, 0]); count ------- 0 select count(*) from singlebatch where metric3 != 777 and metric2 <= all(array[12, 0, 12, 12, 12]); count ------- 0 select count(*) from singlebatch where metric3 != 777 and metric2 <= all(array[12, 12, 12, 12, 12]); count ------- 0 select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 22]) and metric3 != 777; count ------- 0 select count(*) from singlebatch where metric2 = any(array[0, 22, 0, 0, 0]) and metric3 != 777; count ------- 0 select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 0]) and metric3 != 777; count ------- 0 select count(*) from singlebatch where metric2 != any(array[0, 0, 0, 0, 0]) and metric3 != 777; count ------- 3 select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 0]) and metric3 != 777; count ------- 0 select count(*) from singlebatch where metric2 <= all(array[12, 0, 12, 12, 12]) and metric3 != 777; count ------- 0 select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 12]) and metric3 != 777; count ------- 0 -- Also check early exit for AND/OR. Top-level clause must be OR, because top-level -- AND is flattened into a list. select count(*) from singlebatch where (metric2 < 20 and metric2 < 30) or metric3 = 777; count ------- 2 select count(*) from singlebatch where (metric2 < 30 and metric2 < 20) or metric3 = 777; count ------- 2 select count(*) from singlebatch where metric3 = 777 or (metric2 < 20 and metric2 < 30); count ------- 2 select count(*) from singlebatch where metric3 = 777 or (metric2 < 30 and metric2 < 20); count ------- 2 select count(*) from vectorqual where (metric2 < 20 and metric2 < 30) or metric3 = 777; count ------- 2 select count(*) from vectorqual where (metric2 < 30 and metric2 < 20) or metric3 = 777; count ------- 2 select count(*) from vectorqual where metric3 = 777 or (metric2 < 20 and metric2 < 30); count ------- 2 select count(*) from vectorqual where metric3 = 777 or (metric2 < 30 and metric2 < 20); count ------- 2 select count(*) from singlebatch where metric2 < 20 or metric3 < 50 or metric3 > 50; count ------- 5 select count(*) from singlebatch where metric2 < 20 or metric3 > 50 or metric3 < 50; count ------- 5 select count(*) from singlebatch where metric3 < 50 or metric2 < 20 or metric3 > 50; count ------- 5 select count(*) from singlebatch where metric3 > 50 or metric3 < 50 or metric2 < 20; count ------- 5 select count(*) from vectorqual where metric2 < 20 or metric3 < 50 or metric3 > 50; count ------- 5 select count(*) from vectorqual where metric2 < 20 or metric3 > 50 or metric3 < 50; count ------- 5 select count(*) from vectorqual where metric3 < 50 or metric2 < 20 or metric3 > 50; count ------- 5 select count(*) from vectorqual where metric3 > 50 or metric3 < 50 or metric2 < 20; count ------- 5 select count(*) from singlebatch where metric2 = 12 or metric3 = 888; count ------- 1 select count(*) from singlebatch where metric2 = 22 or metric3 = 888; count ------- 1 select count(*) from singlebatch where metric2 = 32 or metric3 = 888; count ------- 1 select count(*) from singlebatch where metric2 = 42 or metric3 = 888; count ------- 1 select count(*) from singlebatch where metric2 = 52 or metric3 = 888; count ------- 1 select count(*) from vectorqual where metric2 = 12 or metric3 = 888; count ------- 1 select count(*) from vectorqual where metric2 = 22 or metric3 = 888; count ------- 1 select count(*) from vectorqual where metric2 = 32 or metric3 = 888; count ------- 1 select count(*) from vectorqual where metric2 = 42 or metric3 = 888; count ------- 1 select count(*) from vectorqual where metric2 = 52 or metric3 = 888; count ------- 1 select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 777 and metric2 = 12); count ------- 1 select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 777 and metric2 = 666); count ------- 0 select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 888 and metric2 = 12); count ------- 0 select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 888 and metric2 = 666); count ------- 0 select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 777 and metric2 = 12); count ------- 2 select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 777 and metric2 = 666); count ------- 1 select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 888 and metric2 = 12); count ------- 1 select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 888 and metric2 = 666); count ------- 1 -- On versions >= 14, the Postgres planner chooses to build a hash table for -- large arrays. We currently don't vectorize in this case. select 1 from set_config('timescaledb.debug_require_vector_qual', case when current_setting('server_version_num')::int >= 140000 then 'forbid' else 'require' end, false); ?column? ---------- 1 select count(*) from singlebatch where metric2 = any(array[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 ]::int8[]); count ------- 5 reset timescaledb.enable_bulk_decompression; reset timescaledb.debug_require_vector_qual; -- Comparison with other column not vectorized. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric3 = metric4; count ------- 0 select count(*) from vectorqual where metric3 = any(array[metric4]); count ------- 0 -- Vectorized filters also work if we have only stable functions on the right -- side that can be evaluated to a constant at run time. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where ts > '2021-01-01 00:00:00'::timestamptz::timestamp; count ------- 3 select count(*) from vectorqual where ts > '2021-01-01 00:00:00'::timestamp - interval '1 day'; count ------- 4 -- Expression that evaluates to Null. select count(*) from vectorqual where ts > case when '2021-01-01'::timestamp < '2022-01-01'::timestamptz then null else '2021-01-01 00:00:00'::timestamp end; count ------- 0 select count(*) from vectorqual where ts < LOCALTIMESTAMP + '3 years'::interval; count ------- 5 -- These filters are not vectorizable as written, because the 'timestamp > timestamptz' -- operator is stable, not immutable. We will try to cast the constant to the -- same type in this case. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where ts > '2021-01-01 00:00:00'::timestamptz; count ------- 3 select count(*) from vectorqual where ts < LOCALTIMESTAMP at time zone 'UTC' + '3 years'::interval; count ------- 5 -- Can't vectorize comparison with a volatile function. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric3 > random()::int - 100; count ------- 5 select count(*) from vectorqual where ts > case when random() < 10 then null else '2021-01-01 00:00:00'::timestamp end; count ------- 0 -- Test that the vectorized quals are disabled by disabling the bulk decompression. set timescaledb.enable_bulk_decompression to off; set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric4 > null; count ------- 0 set timescaledb.enable_bulk_decompression to on; -- Test that the debug GUC works \set ON_ERROR_STOP 0 set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric4 > 4; ERROR: debug: encountered vector quals when they are disabled set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric3 === 4; ERROR: debug: encountered non-vector quals when they are disabled \set ON_ERROR_STOP 1 -- Date columns create table date_table(ts date); select create_hypertable('date_table', 'ts'); create_hypertable ------------------------- (7,public,date_table,t) alter table date_table set (timescaledb.compress); insert into date_table values ('2021-01-01'), ('2021-01-02'), ('2021-01-03'); select count(compress_chunk(x, true)) from show_chunks('date_table') x; count ------- 1 set timescaledb.debug_require_vector_qual to 'require'; select * from date_table where ts > '2021-01-02'; ts ------------ 01-03-2021 select * from date_table where ts >= '2021-01-02'; ts ------------ 01-03-2021 01-02-2021 select * from date_table where ts = '2021-01-02'; ts ------------ 01-02-2021 select * from date_table where ts <= '2021-01-02'; ts ------------ 01-02-2021 01-01-2021 select * from date_table where ts < '2021-01-02'; ts ------------ 01-01-2021 select * from date_table where ts < CURRENT_DATE; ts ------------ 01-03-2021 01-02-2021 01-01-2021 -- Text columns. create table text_table(ts int, d int); select create_hypertable('text_table', 'ts'); create_hypertable ------------------------- (9,public,text_table,t) alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = 'd'); insert into text_table select x, 0 /*, default */ from generate_series(1, 1000) x; select count(compress_chunk(x, true)) from show_chunks('text_table') x; count ------- 1 alter table text_table add column a text default 'default'; insert into text_table select x, 1, '' from generate_series(1, 1000) x; insert into text_table select x, 2, 'same' from generate_series(1, 1000) x; insert into text_table select x, 3, 'different' || x from generate_series(1, 1000) x; insert into text_table select x, 4, case when x % 2 = 0 then null else 'same-with-nulls' end from generate_series(1, 1000) x; insert into text_table select x, 5, case when x % 2 = 0 then null else 'different-with-nulls' || x end from generate_series(1, 1000) x; insert into text_table select x, 6, 'одинаковый' from generate_series(1, 1000) x; insert into text_table select x, 7, 'ç•°ãªã‚‹' || x from generate_series(1, 1000) x; -- Some text values with varying lengths in a single batch. They are all different -- to prevent dictionary compression, because we want to test particular orders -- here as well. insert into text_table select x, 8, repeat( x::text || 'a', x) from generate_series(1, 100) x; insert into text_table select x + 100, 8, repeat((101 - x)::text || 'b', (101 - x)) from generate_series(1, 100) x; insert into text_table select x + 200, 8, repeat((101 - x)::text || 'c', (101 - x)) from generate_series(1, 100) x; insert into text_table select x + 300, 8, repeat( x::text || 'd', x) from generate_series(1, 100) x; -- Use uncompressed table as reference. set timescaledb.debug_require_vector_qual to 'forbid'; select sum(length(a)) from text_table; sum -------- 118551 select count(distinct a) from text_table; count ------- 2905 select count(compress_chunk(x, true)) from show_chunks('text_table') x; count ------- 1 select compress_chunk(x) from show_chunks('text_table') x; NOTICE: chunk "_hyper_9_17_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_17_chunk -- Check result with decompression. set timescaledb.enable_bulk_decompression to on; set timescaledb.debug_require_vector_qual to 'forbid'; select sum(length(a)) from text_table; sum -------- 118551 select count(distinct a) from text_table; count ------- 2905 -- Test vectorized predicates. set timescaledb.debug_require_vector_qual to 'require'; -- -- Uncomment to generate the test reference w/o the vector optimizations. -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'default'; count | min | max | min | max -------+-----+------+-----+----- 1000 | 1 | 1000 | 0 | 0 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = ''; count | min | max | min | max -------+-----+------+-----+----- 1000 | 1 | 1000 | 1 | 1 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'same'; count | min | max | min | max -------+-----+------+-----+----- 1000 | 1 | 1000 | 2 | 2 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a != 'same'; count | min | max | min | max -------+-----+------+-----+----- 6400 | 1 | 1000 | 0 | 8 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'одинаковый'; count | min | max | min | max -------+-----+------+-----+----- 1000 | 1 | 1000 | 6 | 6 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'same-with-nulls'; count | min | max | min | max -------+-----+-----+-----+----- 500 | 1 | 999 | 4 | 4 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different1'; count | min | max | min | max -------+-----+-----+-----+----- 1 | 1 | 1 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'ç•°ãªã‚‹1'; count | min | max | min | max -------+-----+-----+-----+----- 1 | 1 | 1 | 7 | 7 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different-with-nulls1'; count | min | max | min | max -------+-----+-----+-----+----- 1 | 1 | 1 | 5 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different1000'; count | min | max | min | max -------+------+------+-----+----- 1 | 1000 | 1000 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different-with-nulls999'; count | min | max | min | max -------+-----+-----+-----+----- 1 | 999 | 999 | 5 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a in ('same', 'different500'); count | min | max | min | max -------+-----+------+-----+----- 1001 | 1 | 1000 | 2 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a in ('same-with-nulls', 'different-with-nulls499'); count | min | max | min | max -------+-----+-----+-----+----- 501 | 1 | 999 | 4 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a in ('different500', 'default'); count | min | max | min | max -------+-----+------+-----+----- 1001 | 1 | 1000 | 0 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different500' or a = 'default'; count | min | max | min | max -------+-----+------+-----+----- 1001 | 1 | 1000 | 0 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a is null; count | min | max | min | max -------+-----+------+-----+----- 1000 | 2 | 1000 | 4 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a is not null; count | min | max | min | max -------+-----+------+-----+----- 7400 | 1 | 1000 | 0 | 8 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%same%'; count | min | max | min | max -------+-----+------+-----+----- 1500 | 1 | 1000 | 2 | 4 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%одинаковый%'; count | min | max | min | max -------+-----+------+-----+----- 1000 | 1 | 1000 | 6 | 6 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%одилаковый%'; count | min | max | min | max -------+-----+-----+-----+----- 0 | | | | select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%одимаковый%'; count | min | max | min | max -------+-----+-----+-----+----- 0 | | | | select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%ç•°ãªã‚‹%'; count | min | max | min | max -------+-----+------+-----+----- 1000 | 1 | 1000 | 7 | 7 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%異オる%'; count | min | max | min | max -------+-----+-----+-----+----- 0 | | | | select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%ç•°ã«ã‚‹%'; count | min | max | min | max -------+-----+-----+-----+----- 0 | | | | select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'ç•°_ã‚‹_'; count | min | max | min | max -------+-----+-----+-----+----- 9 | 1 | 9 | 7 | 7 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%'; count | min | max | min | max -------+-----+------+-----+----- 7400 | 1 | 1000 | 0 | 8 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%different1%'; count | min | max | min | max -------+-----+------+-----+----- 112 | 1 | 1000 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%different1'; count | min | max | min | max -------+-----+-----+-----+----- 1 | 1 | 1 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%%'; count | min | max | min | max -------+-----+------+-----+----- 1500 | 1 | 1000 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%%1'; count | min | max | min | max -------+-----+-----+-----+----- 200 | 1 | 991 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%\1'; count | min | max | min | max -------+-----+-----+-----+----- 200 | 1 | 991 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%_'; count | min | max | min | max -------+-----+------+-----+----- 1500 | 1 | 1000 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%__'; count | min | max | min | max -------+-----+------+-----+----- 1491 | 1 | 1000 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%___'; count | min | max | min | max -------+-----+------+-----+----- 1401 | 1 | 1000 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%_1'; count | min | max | min | max -------+-----+-----+-----+----- 199 | 1 | 991 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%nulls_'; count | min | max | min | max -------+-----+-----+-----+----- 5 | 1 | 9 | 5 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different1%'; count | min | max | min | max -------+-----+------+-----+----- 112 | 1 | 1000 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different\%'; count | min | max | min | max -------+-----+-----+-----+----- 0 | | | | select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different\1'; count | min | max | min | max -------+-----+-----+-----+----- 1 | 1 | 1 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different_%1'; count | min | max | min | max -------+-----+-----+-----+----- 199 | 1 | 991 | 3 | 5 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different_'; count | min | max | min | max -------+-----+-----+-----+----- 9 | 1 | 9 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different_1'; count | min | max | min | max -------+-----+-----+-----+----- 9 | 11 | 91 | 3 | 3 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'same_'; count | min | max | min | max -------+-----+-----+-----+----- 0 | | | | select count(*), min(ts), max(ts), min(d), max(d) from text_table where a not like '%different1%'; count | min | max | min | max -------+-----+------+-----+----- 7288 | 1 | 1000 | 0 | 8 \set ON_ERROR_STOP 0 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different\'; ERROR: LIKE pattern must not end with escape character select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%\'; ERROR: LIKE pattern must not end with escape character \set ON_ERROR_STOP 1 -- We don't vectorize comparison operators with text because they are probably -- not very useful. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a < 'same'; count | min | max | min | max -------+-----+------+-----+----- 3900 | 1 | 1000 | 0 | 8 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a > 'same'; count | min | max | min | max -------+-----+------+-----+----- 2500 | 1 | 1000 | 4 | 7 reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bulk_decompression; -- Test the nonstandard Postgres NaN comparison that doesn't match the IEEE floats. create table nans(t int, cfloat4 float4, cfloat8 float8); select create_hypertable('nans', 't', chunk_time_interval => 1024 * 1024 * 1024); create_hypertable -------------------- (11,public,nans,t) alter table nans set (timescaledb.compress); insert into nans select pow(2, n), x, x from unnest(array[null, 0, 1, 'nan', '-inf', '+inf']::float8[]) with ordinality as x(x, n) ; select count(compress_chunk(x)) from show_chunks('nans') x; count ------- 1 set timescaledb.enable_bulk_decompression to on; set timescaledb.debug_require_vector_qual to 'require'; select format('select sum(t) from nans where %s %s %s::%s;', variable, op, value, type) from unnest(array['cfloat4', 'cfloat8']) variable, unnest(array['=', '!=', '<', '<=', '>', '>=']) op, unnest(array['null', '0', '1', '''nan''', '''-inf''', '''+inf''']) value, unnest(array['float4', 'float8', 'numeric']) type \gexec select sum(t) from nans where cfloat4 = null::float4; sum ----- select sum(t) from nans where cfloat4 = null::float8; sum ----- select sum(t) from nans where cfloat4 = null::numeric; sum ----- select sum(t) from nans where cfloat8 = null::float4; sum ----- select sum(t) from nans where cfloat8 = null::float8; sum ----- select sum(t) from nans where cfloat8 = null::numeric; sum ----- select sum(t) from nans where cfloat4 != null::float4; sum ----- select sum(t) from nans where cfloat4 != null::float8; sum ----- select sum(t) from nans where cfloat4 != null::numeric; sum ----- select sum(t) from nans where cfloat8 != null::float4; sum ----- select sum(t) from nans where cfloat8 != null::float8; sum ----- select sum(t) from nans where cfloat8 != null::numeric; sum ----- select sum(t) from nans where cfloat4 < null::float4; sum ----- select sum(t) from nans where cfloat4 < null::float8; sum ----- select sum(t) from nans where cfloat4 < null::numeric; sum ----- select sum(t) from nans where cfloat8 < null::float4; sum ----- select sum(t) from nans where cfloat8 < null::float8; sum ----- select sum(t) from nans where cfloat8 < null::numeric; sum ----- select sum(t) from nans where cfloat4 <= null::float4; sum ----- select sum(t) from nans where cfloat4 <= null::float8; sum ----- select sum(t) from nans where cfloat4 <= null::numeric; sum ----- select sum(t) from nans where cfloat8 <= null::float4; sum ----- select sum(t) from nans where cfloat8 <= null::float8; sum ----- select sum(t) from nans where cfloat8 <= null::numeric; sum ----- select sum(t) from nans where cfloat4 > null::float4; sum ----- select sum(t) from nans where cfloat4 > null::float8; sum ----- select sum(t) from nans where cfloat4 > null::numeric; sum ----- select sum(t) from nans where cfloat8 > null::float4; sum ----- select sum(t) from nans where cfloat8 > null::float8; sum ----- select sum(t) from nans where cfloat8 > null::numeric; sum ----- select sum(t) from nans where cfloat4 >= null::float4; sum ----- select sum(t) from nans where cfloat4 >= null::float8; sum ----- select sum(t) from nans where cfloat4 >= null::numeric; sum ----- select sum(t) from nans where cfloat8 >= null::float4; sum ----- select sum(t) from nans where cfloat8 >= null::float8; sum ----- select sum(t) from nans where cfloat8 >= null::numeric; sum ----- select sum(t) from nans where cfloat4 = 0::float4; sum ----- 4 select sum(t) from nans where cfloat4 = 0::float8; sum ----- 4 select sum(t) from nans where cfloat4 = 0::numeric; sum ----- 4 select sum(t) from nans where cfloat8 = 0::float4; sum ----- 4 select sum(t) from nans where cfloat8 = 0::float8; sum ----- 4 select sum(t) from nans where cfloat8 = 0::numeric; sum ----- 4 select sum(t) from nans where cfloat4 != 0::float4; sum ----- 120 select sum(t) from nans where cfloat4 != 0::float8; sum ----- 120 select sum(t) from nans where cfloat4 != 0::numeric; sum ----- 120 select sum(t) from nans where cfloat8 != 0::float4; sum ----- 120 select sum(t) from nans where cfloat8 != 0::float8; sum ----- 120 select sum(t) from nans where cfloat8 != 0::numeric; sum ----- 120 select sum(t) from nans where cfloat4 < 0::float4; sum ----- 32 select sum(t) from nans where cfloat4 < 0::float8; sum ----- 32 select sum(t) from nans where cfloat4 < 0::numeric; sum ----- 32 select sum(t) from nans where cfloat8 < 0::float4; sum ----- 32 select sum(t) from nans where cfloat8 < 0::float8; sum ----- 32 select sum(t) from nans where cfloat8 < 0::numeric; sum ----- 32 select sum(t) from nans where cfloat4 <= 0::float4; sum ----- 36 select sum(t) from nans where cfloat4 <= 0::float8; sum ----- 36 select sum(t) from nans where cfloat4 <= 0::numeric; sum ----- 36 select sum(t) from nans where cfloat8 <= 0::float4; sum ----- 36 select sum(t) from nans where cfloat8 <= 0::float8; sum ----- 36 select sum(t) from nans where cfloat8 <= 0::numeric; sum ----- 36 select sum(t) from nans where cfloat4 > 0::float4; sum ----- 88 select sum(t) from nans where cfloat4 > 0::float8; sum ----- 88 select sum(t) from nans where cfloat4 > 0::numeric; sum ----- 88 select sum(t) from nans where cfloat8 > 0::float4; sum ----- 88 select sum(t) from nans where cfloat8 > 0::float8; sum ----- 88 select sum(t) from nans where cfloat8 > 0::numeric; sum ----- 88 select sum(t) from nans where cfloat4 >= 0::float4; sum ----- 92 select sum(t) from nans where cfloat4 >= 0::float8; sum ----- 92 select sum(t) from nans where cfloat4 >= 0::numeric; sum ----- 92 select sum(t) from nans where cfloat8 >= 0::float4; sum ----- 92 select sum(t) from nans where cfloat8 >= 0::float8; sum ----- 92 select sum(t) from nans where cfloat8 >= 0::numeric; sum ----- 92 select sum(t) from nans where cfloat4 = 1::float4; sum ----- 8 select sum(t) from nans where cfloat4 = 1::float8; sum ----- 8 select sum(t) from nans where cfloat4 = 1::numeric; sum ----- 8 select sum(t) from nans where cfloat8 = 1::float4; sum ----- 8 select sum(t) from nans where cfloat8 = 1::float8; sum ----- 8 select sum(t) from nans where cfloat8 = 1::numeric; sum ----- 8 select sum(t) from nans where cfloat4 != 1::float4; sum ----- 116 select sum(t) from nans where cfloat4 != 1::float8; sum ----- 116 select sum(t) from nans where cfloat4 != 1::numeric; sum ----- 116 select sum(t) from nans where cfloat8 != 1::float4; sum ----- 116 select sum(t) from nans where cfloat8 != 1::float8; sum ----- 116 select sum(t) from nans where cfloat8 != 1::numeric; sum ----- 116 select sum(t) from nans where cfloat4 < 1::float4; sum ----- 36 select sum(t) from nans where cfloat4 < 1::float8; sum ----- 36 select sum(t) from nans where cfloat4 < 1::numeric; sum ----- 36 select sum(t) from nans where cfloat8 < 1::float4; sum ----- 36 select sum(t) from nans where cfloat8 < 1::float8; sum ----- 36 select sum(t) from nans where cfloat8 < 1::numeric; sum ----- 36 select sum(t) from nans where cfloat4 <= 1::float4; sum ----- 44 select sum(t) from nans where cfloat4 <= 1::float8; sum ----- 44 select sum(t) from nans where cfloat4 <= 1::numeric; sum ----- 44 select sum(t) from nans where cfloat8 <= 1::float4; sum ----- 44 select sum(t) from nans where cfloat8 <= 1::float8; sum ----- 44 select sum(t) from nans where cfloat8 <= 1::numeric; sum ----- 44 select sum(t) from nans where cfloat4 > 1::float4; sum ----- 80 select sum(t) from nans where cfloat4 > 1::float8; sum ----- 80 select sum(t) from nans where cfloat4 > 1::numeric; sum ----- 80 select sum(t) from nans where cfloat8 > 1::float4; sum ----- 80 select sum(t) from nans where cfloat8 > 1::float8; sum ----- 80 select sum(t) from nans where cfloat8 > 1::numeric; sum ----- 80 select sum(t) from nans where cfloat4 >= 1::float4; sum ----- 88 select sum(t) from nans where cfloat4 >= 1::float8; sum ----- 88 select sum(t) from nans where cfloat4 >= 1::numeric; sum ----- 88 select sum(t) from nans where cfloat8 >= 1::float4; sum ----- 88 select sum(t) from nans where cfloat8 >= 1::float8; sum ----- 88 select sum(t) from nans where cfloat8 >= 1::numeric; sum ----- 88 select sum(t) from nans where cfloat4 = 'nan'::float4; sum ----- 16 select sum(t) from nans where cfloat4 = 'nan'::float8; sum ----- 16 select sum(t) from nans where cfloat4 = 'nan'::numeric; sum ----- 16 select sum(t) from nans where cfloat8 = 'nan'::float4; sum ----- 16 select sum(t) from nans where cfloat8 = 'nan'::float8; sum ----- 16 select sum(t) from nans where cfloat8 = 'nan'::numeric; sum ----- 16 select sum(t) from nans where cfloat4 != 'nan'::float4; sum ----- 108 select sum(t) from nans where cfloat4 != 'nan'::float8; sum ----- 108 select sum(t) from nans where cfloat4 != 'nan'::numeric; sum ----- 108 select sum(t) from nans where cfloat8 != 'nan'::float4; sum ----- 108 select sum(t) from nans where cfloat8 != 'nan'::float8; sum ----- 108 select sum(t) from nans where cfloat8 != 'nan'::numeric; sum ----- 108 select sum(t) from nans where cfloat4 < 'nan'::float4; sum ----- 108 select sum(t) from nans where cfloat4 < 'nan'::float8; sum ----- 108 select sum(t) from nans where cfloat4 < 'nan'::numeric; sum ----- 108 select sum(t) from nans where cfloat8 < 'nan'::float4; sum ----- 108 select sum(t) from nans where cfloat8 < 'nan'::float8; sum ----- 108 select sum(t) from nans where cfloat8 < 'nan'::numeric; sum ----- 108 select sum(t) from nans where cfloat4 <= 'nan'::float4; sum ----- 124 select sum(t) from nans where cfloat4 <= 'nan'::float8; sum ----- 124 select sum(t) from nans where cfloat4 <= 'nan'::numeric; sum ----- 124 select sum(t) from nans where cfloat8 <= 'nan'::float4; sum ----- 124 select sum(t) from nans where cfloat8 <= 'nan'::float8; sum ----- 124 select sum(t) from nans where cfloat8 <= 'nan'::numeric; sum ----- 124 select sum(t) from nans where cfloat4 > 'nan'::float4; sum ----- select sum(t) from nans where cfloat4 > 'nan'::float8; sum ----- select sum(t) from nans where cfloat4 > 'nan'::numeric; sum ----- select sum(t) from nans where cfloat8 > 'nan'::float4; sum ----- select sum(t) from nans where cfloat8 > 'nan'::float8; sum ----- select sum(t) from nans where cfloat8 > 'nan'::numeric; sum ----- select sum(t) from nans where cfloat4 >= 'nan'::float4; sum ----- 16 select sum(t) from nans where cfloat4 >= 'nan'::float8; sum ----- 16 select sum(t) from nans where cfloat4 >= 'nan'::numeric; sum ----- 16 select sum(t) from nans where cfloat8 >= 'nan'::float4; sum ----- 16 select sum(t) from nans where cfloat8 >= 'nan'::float8; sum ----- 16 select sum(t) from nans where cfloat8 >= 'nan'::numeric; sum ----- 16 select sum(t) from nans where cfloat4 = '-inf'::float4; sum ----- 32 select sum(t) from nans where cfloat4 = '-inf'::float8; sum ----- 32 select sum(t) from nans where cfloat4 = '-inf'::numeric; sum ----- 32 select sum(t) from nans where cfloat8 = '-inf'::float4; sum ----- 32 select sum(t) from nans where cfloat8 = '-inf'::float8; sum ----- 32 select sum(t) from nans where cfloat8 = '-inf'::numeric; sum ----- 32 select sum(t) from nans where cfloat4 != '-inf'::float4; sum ----- 92 select sum(t) from nans where cfloat4 != '-inf'::float8; sum ----- 92 select sum(t) from nans where cfloat4 != '-inf'::numeric; sum ----- 92 select sum(t) from nans where cfloat8 != '-inf'::float4; sum ----- 92 select sum(t) from nans where cfloat8 != '-inf'::float8; sum ----- 92 select sum(t) from nans where cfloat8 != '-inf'::numeric; sum ----- 92 select sum(t) from nans where cfloat4 < '-inf'::float4; sum ----- select sum(t) from nans where cfloat4 < '-inf'::float8; sum ----- select sum(t) from nans where cfloat4 < '-inf'::numeric; sum ----- select sum(t) from nans where cfloat8 < '-inf'::float4; sum ----- select sum(t) from nans where cfloat8 < '-inf'::float8; sum ----- select sum(t) from nans where cfloat8 < '-inf'::numeric; sum ----- select sum(t) from nans where cfloat4 <= '-inf'::float4; sum ----- 32 select sum(t) from nans where cfloat4 <= '-inf'::float8; sum ----- 32 select sum(t) from nans where cfloat4 <= '-inf'::numeric; sum ----- 32 select sum(t) from nans where cfloat8 <= '-inf'::float4; sum ----- 32 select sum(t) from nans where cfloat8 <= '-inf'::float8; sum ----- 32 select sum(t) from nans where cfloat8 <= '-inf'::numeric; sum ----- 32 select sum(t) from nans where cfloat4 > '-inf'::float4; sum ----- 92 select sum(t) from nans where cfloat4 > '-inf'::float8; sum ----- 92 select sum(t) from nans where cfloat4 > '-inf'::numeric; sum ----- 92 select sum(t) from nans where cfloat8 > '-inf'::float4; sum ----- 92 select sum(t) from nans where cfloat8 > '-inf'::float8; sum ----- 92 select sum(t) from nans where cfloat8 > '-inf'::numeric; sum ----- 92 select sum(t) from nans where cfloat4 >= '-inf'::float4; sum ----- 124 select sum(t) from nans where cfloat4 >= '-inf'::float8; sum ----- 124 select sum(t) from nans where cfloat4 >= '-inf'::numeric; sum ----- 124 select sum(t) from nans where cfloat8 >= '-inf'::float4; sum ----- 124 select sum(t) from nans where cfloat8 >= '-inf'::float8; sum ----- 124 select sum(t) from nans where cfloat8 >= '-inf'::numeric; sum ----- 124 select sum(t) from nans where cfloat4 = '+inf'::float4; sum ----- 64 select sum(t) from nans where cfloat4 = '+inf'::float8; sum ----- 64 select sum(t) from nans where cfloat4 = '+inf'::numeric; sum ----- 64 select sum(t) from nans where cfloat8 = '+inf'::float4; sum ----- 64 select sum(t) from nans where cfloat8 = '+inf'::float8; sum ----- 64 select sum(t) from nans where cfloat8 = '+inf'::numeric; sum ----- 64 select sum(t) from nans where cfloat4 != '+inf'::float4; sum ----- 60 select sum(t) from nans where cfloat4 != '+inf'::float8; sum ----- 60 select sum(t) from nans where cfloat4 != '+inf'::numeric; sum ----- 60 select sum(t) from nans where cfloat8 != '+inf'::float4; sum ----- 60 select sum(t) from nans where cfloat8 != '+inf'::float8; sum ----- 60 select sum(t) from nans where cfloat8 != '+inf'::numeric; sum ----- 60 select sum(t) from nans where cfloat4 < '+inf'::float4; sum ----- 44 select sum(t) from nans where cfloat4 < '+inf'::float8; sum ----- 44 select sum(t) from nans where cfloat4 < '+inf'::numeric; sum ----- 44 select sum(t) from nans where cfloat8 < '+inf'::float4; sum ----- 44 select sum(t) from nans where cfloat8 < '+inf'::float8; sum ----- 44 select sum(t) from nans where cfloat8 < '+inf'::numeric; sum ----- 44 select sum(t) from nans where cfloat4 <= '+inf'::float4; sum ----- 108 select sum(t) from nans where cfloat4 <= '+inf'::float8; sum ----- 108 select sum(t) from nans where cfloat4 <= '+inf'::numeric; sum ----- 108 select sum(t) from nans where cfloat8 <= '+inf'::float4; sum ----- 108 select sum(t) from nans where cfloat8 <= '+inf'::float8; sum ----- 108 select sum(t) from nans where cfloat8 <= '+inf'::numeric; sum ----- 108 select sum(t) from nans where cfloat4 > '+inf'::float4; sum ----- 16 select sum(t) from nans where cfloat4 > '+inf'::float8; sum ----- 16 select sum(t) from nans where cfloat4 > '+inf'::numeric; sum ----- 16 select sum(t) from nans where cfloat8 > '+inf'::float4; sum ----- 16 select sum(t) from nans where cfloat8 > '+inf'::float8; sum ----- 16 select sum(t) from nans where cfloat8 > '+inf'::numeric; sum ----- 16 select sum(t) from nans where cfloat4 >= '+inf'::float4; sum ----- 80 select sum(t) from nans where cfloat4 >= '+inf'::float8; sum ----- 80 select sum(t) from nans where cfloat4 >= '+inf'::numeric; sum ----- 80 select sum(t) from nans where cfloat8 >= '+inf'::float4; sum ----- 80 select sum(t) from nans where cfloat8 >= '+inf'::float8; sum ----- 80 select sum(t) from nans where cfloat8 >= '+inf'::numeric; sum ----- 80 reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bulk_decompression; -- Test predicates on UUID columns can be vectorized -- if UUID compression is _disabled_. With the new changes -- vectorized decompression should be supported, regardless of -- whether the UUID compression is enabled or not. set timescaledb.enable_uuid_compression = off; -- Generate reference results with uncommenting the next two lines -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; create table uuid_table(ts int, u uuid); select count(*) from create_hypertable('uuid_table', 'ts'); count ------- 1 alter table uuid_table set (timescaledb.compress); insert into uuid_table values (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '01941f29-7c00-706a-bea9-105dad841304'), (18, '01941f2a-665f-7722-b4b5-cf4e70e666d0'), (19, NULL::uuid), (20, NULL::uuid), (21, NULL::uuid); select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; count ------- 1 -- With the new changes bulk decompression and vectorized filtering -- will be supported regardless of whether the UUID compression is -- enabled or not. set timescaledb.debug_require_vector_qual to 'require'; select * from uuid_table where u = '01941f29-7c00-706a-bea9-105dad841304'::uuid; ts | u ----+-------------------------------------- 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u in ( '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid) order by 1, 2; ts | u ----+-------------------------------------- 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u = any(array[ '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid ]) order by 1, 2; ts | u ----+-------------------------------------- 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u not in ( '0197a7a9-b48b-7c70-be05-e376afc66ee1'::uuid, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'::uuid) order by 1, 2; ts | u ----+-------------------------------------- 3 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 4 | 0197a7a9-b48b-7c73-b521-91172c2e770a 5 | 0197a7a9-b48b-7c74-a2a4-dcdbce635d11 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 7 | 0197a7a9-b48b-7c76-b616-69e64a802b5c 8 | 0197a7a9-b48b-7c77-b54f-c5f3d64d68d0 9 | 0197a7a9-b48b-7c78-ab14-78b3dd81dbbc 10 | 0197a7a9-b48b-7c79-92c7-7dde3bea6252 11 | 0197a7a9-b48b-7c7a-8d9e-5afc3bf15234 12 | 0197a7a9-b48b-7c7b-bc49-7150f16d8d63 13 | 0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8 14 | 0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9 15 | 0197a7a9-b48b-7c7e-9ebb-acf63f5b625e 16 | 0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a 17 | 01941f29-7c00-706a-bea9-105dad841304 18 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 select * from uuid_table where u is not null order by 1, 2; ts | u ----+-------------------------------------- 1 | 0197a7a9-b48b-7c70-be05-e376afc66ee1 2 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f 3 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 4 | 0197a7a9-b48b-7c73-b521-91172c2e770a 5 | 0197a7a9-b48b-7c74-a2a4-dcdbce635d11 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 7 | 0197a7a9-b48b-7c76-b616-69e64a802b5c 8 | 0197a7a9-b48b-7c77-b54f-c5f3d64d68d0 9 | 0197a7a9-b48b-7c78-ab14-78b3dd81dbbc 10 | 0197a7a9-b48b-7c79-92c7-7dde3bea6252 11 | 0197a7a9-b48b-7c7a-8d9e-5afc3bf15234 12 | 0197a7a9-b48b-7c7b-bc49-7150f16d8d63 13 | 0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8 14 | 0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9 15 | 0197a7a9-b48b-7c7e-9ebb-acf63f5b625e 16 | 0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a 17 | 01941f29-7c00-706a-bea9-105dad841304 18 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 -- Modify the data to make sure dictionary compression is used as well. update uuid_table set u = '0197a7a9-b48b-7c70-be05-e376afc66ee1' where ts in (1, 2, 3, 4); update uuid_table set u = '0197a7a9-b48b-7c71-92cb-eb724822bb0f' where ts in (5, 6, 7, 8); update uuid_table set u = '0197a7a9-b48b-7c72-bd57-49f981f064fd' where ts in (9, 10, 11, 12); update uuid_table set u = '0197a7a9-b48b-7c73-b521-91172c2e770a' where ts in (13, 14, 15, 16); select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; count ------- 1 -- Generate reference results with uncommenting the next two lines -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; select * from uuid_table where u = '01941f29-7c00-706a-bea9-105dad841304'::uuid; ts | u ----+-------------------------------------- 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u in ( '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid) order by 1, 2; ts | u ----+-------------------------------------- 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u = any(array[ '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid ]) order by 1, 2; ts | u ----+-------------------------------------- 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u not in ( '0197a7a9-b48b-7c70-be05-e376afc66ee1'::uuid, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'::uuid) order by 1, 2; ts | u ----+-------------------------------------- 9 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 10 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 11 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 12 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 13 | 0197a7a9-b48b-7c73-b521-91172c2e770a 14 | 0197a7a9-b48b-7c73-b521-91172c2e770a 15 | 0197a7a9-b48b-7c73-b521-91172c2e770a 16 | 0197a7a9-b48b-7c73-b521-91172c2e770a 17 | 01941f29-7c00-706a-bea9-105dad841304 18 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 select * from uuid_table where u is not null order by 1, 2; ts | u ----+-------------------------------------- 1 | 0197a7a9-b48b-7c70-be05-e376afc66ee1 2 | 0197a7a9-b48b-7c70-be05-e376afc66ee1 3 | 0197a7a9-b48b-7c70-be05-e376afc66ee1 4 | 0197a7a9-b48b-7c70-be05-e376afc66ee1 5 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f 6 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f 7 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f 8 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f 9 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 10 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 11 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 12 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 13 | 0197a7a9-b48b-7c73-b521-91172c2e770a 14 | 0197a7a9-b48b-7c73-b521-91172c2e770a 15 | 0197a7a9-b48b-7c73-b521-91172c2e770a 16 | 0197a7a9-b48b-7c73-b521-91172c2e770a 17 | 01941f29-7c00-706a-bea9-105dad841304 18 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 reset timescaledb.enable_bulk_decompression; reset timescaledb.debug_require_vector_qual; -- Test predicates on UUID columns can be vectorized -- if UUID compression is _enabled_ set timescaledb.enable_uuid_compression = on; -- Generate reference results with uncommenting the next two lines -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; delete from uuid_table; insert into uuid_table values (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '01941f29-7c00-706a-bea9-105dad841304'), (18, '01941f2a-665f-7722-b4b5-cf4e70e666d0'), (19, NULL::uuid), (20, NULL::uuid), (21, NULL::uuid); select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; count ------- 1 set timescaledb.debug_require_vector_qual to 'require'; select * from uuid_table where u = '01941f29-7c00-706a-bea9-105dad841304'::uuid; ts | u ----+-------------------------------------- 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u in ( '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid) order by 1, 2; ts | u ----+-------------------------------------- 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u = any(array[ '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid ]) order by 1, 2; ts | u ----+-------------------------------------- 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 17 | 01941f29-7c00-706a-bea9-105dad841304 select * from uuid_table where u not in ( '0197a7a9-b48b-7c70-be05-e376afc66ee1'::uuid, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'::uuid) order by 1, 2; ts | u ----+-------------------------------------- 3 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 4 | 0197a7a9-b48b-7c73-b521-91172c2e770a 5 | 0197a7a9-b48b-7c74-a2a4-dcdbce635d11 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 7 | 0197a7a9-b48b-7c76-b616-69e64a802b5c 8 | 0197a7a9-b48b-7c77-b54f-c5f3d64d68d0 9 | 0197a7a9-b48b-7c78-ab14-78b3dd81dbbc 10 | 0197a7a9-b48b-7c79-92c7-7dde3bea6252 11 | 0197a7a9-b48b-7c7a-8d9e-5afc3bf15234 12 | 0197a7a9-b48b-7c7b-bc49-7150f16d8d63 13 | 0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8 14 | 0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9 15 | 0197a7a9-b48b-7c7e-9ebb-acf63f5b625e 16 | 0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a 17 | 01941f29-7c00-706a-bea9-105dad841304 18 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 select * from uuid_table where u is not null order by 1, 2; ts | u ----+-------------------------------------- 1 | 0197a7a9-b48b-7c70-be05-e376afc66ee1 2 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f 3 | 0197a7a9-b48b-7c72-bd57-49f981f064fd 4 | 0197a7a9-b48b-7c73-b521-91172c2e770a 5 | 0197a7a9-b48b-7c74-a2a4-dcdbce635d11 6 | 0197a7a9-b48b-7c75-a810-8acf630e634f 7 | 0197a7a9-b48b-7c76-b616-69e64a802b5c 8 | 0197a7a9-b48b-7c77-b54f-c5f3d64d68d0 9 | 0197a7a9-b48b-7c78-ab14-78b3dd81dbbc 10 | 0197a7a9-b48b-7c79-92c7-7dde3bea6252 11 | 0197a7a9-b48b-7c7a-8d9e-5afc3bf15234 12 | 0197a7a9-b48b-7c7b-bc49-7150f16d8d63 13 | 0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8 14 | 0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9 15 | 0197a7a9-b48b-7c7e-9ebb-acf63f5b625e 16 | 0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a 17 | 01941f29-7c00-706a-bea9-105dad841304 18 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 reset timescaledb.enable_bulk_decompression; reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_uuid_compression; -- Test predicates on boolean columns can be vectorized -- with the bool compression enabled. set timescaledb.enable_bulk_decompression to on; set timescaledb.enable_bool_compression = on; create table bool_table(ts int, b bool); select count(*) from create_hypertable('bool_table', 'ts'); count ------- 1 alter table bool_table set (timescaledb.compress); insert into bool_table values (100, true), (101, false), (102, null); select count(compress_chunk(x, true)) from show_chunks('bool_table') x; count ------- 1 set timescaledb.debug_require_vector_qual to 'require'; -- BooleanTest expressions select * from bool_table where b is true order by 1; ts | b -----+--- 100 | t select * from bool_table where b is false order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not true order by 1; ts | b -----+--- 101 | f 102 | select * from bool_table where b is not false order by 1; ts | b -----+--- 100 | t 102 | select * from bool_table where b is unknown order by 1; ts | b -----+--- 102 | select * from bool_table where b is not unknown order by 1; ts | b -----+--- 100 | t 101 | f -- Combinations of nulls and bool exprs select * from bool_table where b = true order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b = false order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b = false order by 1; ts | b ----+--- select * from bool_table where b = true or b is null order by 1; ts | b -----+--- 100 | t 102 | select * from bool_table where b = true or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b is null order by 1; ts | b ----+--- select * from bool_table where b = true and b is not null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = false order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is null order by 1; ts | b -----+--- 101 | f 102 | select * from bool_table where b = false or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = false and b is null order by 1; ts | b ----+--- select * from bool_table where b = false and b is not null order by 1; ts | b -----+--- 101 | f select * from bool_table where b is null order by 1; ts | b -----+--- 102 | select * from bool_table where b is null or b is not null order by 1; ts | b -----+--- 100 | t 101 | f 102 | select * from bool_table where b is null and b is not null order by 1; ts | b ----+--- select * from bool_table where b is not null order by 1; ts | b -----+--- 100 | t 101 | f delete from bool_table where b is null; select count(compress_chunk(x, true)) from show_chunks('bool_table') x; count ------- 1 select * from bool_table where b is true order by 1; ts | b -----+--- 100 | t select * from bool_table where b is false order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not true order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not false order by 1; ts | b -----+--- 100 | t select * from bool_table where b is unknown order by 1; ts | b ----+--- select * from bool_table where b is not unknown order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b = false order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b = false order by 1; ts | b ----+--- select * from bool_table where b = true or b is null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b is null order by 1; ts | b ----+--- select * from bool_table where b = true and b is not null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = false order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is null order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = false and b is null order by 1; ts | b ----+--- select * from bool_table where b = false and b is not null order by 1; ts | b -----+--- 101 | f select * from bool_table where b is null order by 1; ts | b ----+--- select * from bool_table where b is null or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b is null and b is not null order by 1; ts | b ----+--- select * from bool_table where b is not null order by 1; ts | b -----+--- 100 | t 101 | f reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bulk_decompression; reset timescaledb.enable_bool_compression; -- Check that the bool compression changes didn't mess up the -- array compression support for the bools. delete from bool_table; set timescaledb.enable_bool_compression = off; insert into bool_table values (100, true), (101, false), (102, null); select count(compress_chunk(x, true)) from show_chunks('bool_table') x; count ------- 1 select * from bool_table where b is true order by 1; ts | b -----+--- 100 | t select * from bool_table where b is false order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not true order by 1; ts | b -----+--- 101 | f 102 | select * from bool_table where b is not false order by 1; ts | b -----+--- 100 | t 102 | select * from bool_table where b is unknown order by 1; ts | b -----+--- 102 | select * from bool_table where b is not unknown order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b = false order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b = false order by 1; ts | b ----+--- select * from bool_table where b = true or b is null order by 1; ts | b -----+--- 100 | t 102 | select * from bool_table where b = true or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b is null order by 1; ts | b ----+--- select * from bool_table where b = true and b is not null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = false order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is null order by 1; ts | b -----+--- 101 | f 102 | select * from bool_table where b = false or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = false and b is null order by 1; ts | b ----+--- select * from bool_table where b = false and b is not null order by 1; ts | b -----+--- 101 | f select * from bool_table where b is null order by 1; ts | b -----+--- 102 | select * from bool_table where b is null or b is not null order by 1; ts | b -----+--- 100 | t 101 | f 102 | select * from bool_table where b is null and b is not null order by 1; ts | b ----+--- select * from bool_table where b is not null order by 1; ts | b -----+--- 100 | t 101 | f delete from bool_table where b is null; select count(compress_chunk(x, true)) from show_chunks('bool_table') x; count ------- 1 select * from bool_table where b is true order by 1; ts | b -----+--- 100 | t select * from bool_table where b is false order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not true order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not false order by 1; ts | b -----+--- 100 | t select * from bool_table where b is unknown order by 1; ts | b ----+--- select * from bool_table where b is not unknown order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b = false order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b = false order by 1; ts | b ----+--- select * from bool_table where b = true or b is null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b is null order by 1; ts | b ----+--- select * from bool_table where b = true and b is not null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = false order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is null order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = false and b is null order by 1; ts | b ----+--- select * from bool_table where b = false and b is not null order by 1; ts | b -----+--- 101 | f select * from bool_table where b is null order by 1; ts | b ----+--- select * from bool_table where b is null or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b is null and b is not null order by 1; ts | b ----+--- select * from bool_table where b is not null order by 1; ts | b -----+--- 100 | t 101 | f -- At this point the bool data is generated as 'bool compression disabed' -- meaning, it is compressed with array compression. I try to confuse the -- executor by creating a vectorized plan and still hoping to get the right -- results. set timescaledb.debug_require_vector_qual to 'require'; set timescaledb.enable_bool_compression = on; select * from bool_table where b is true order by 1; ts | b -----+--- 100 | t select * from bool_table where b is false order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not true order by 1; ts | b -----+--- 101 | f select * from bool_table where b is not false order by 1; ts | b -----+--- 100 | t select * from bool_table where b is unknown order by 1; ts | b ----+--- select * from bool_table where b is not unknown order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b = false order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b = false order by 1; ts | b ----+--- select * from bool_table where b = true or b is null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = true or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = true and b is null order by 1; ts | b ----+--- select * from bool_table where b = true and b is not null order by 1; ts | b -----+--- 100 | t select * from bool_table where b = false order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is null order by 1; ts | b -----+--- 101 | f select * from bool_table where b = false or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b = false and b is null order by 1; ts | b ----+--- select * from bool_table where b = false and b is not null order by 1; ts | b -----+--- 101 | f select * from bool_table where b is null order by 1; ts | b ----+--- select * from bool_table where b is null or b is not null order by 1; ts | b -----+--- 100 | t 101 | f select * from bool_table where b is null and b is not null order by 1; ts | b ----+--- select * from bool_table where b is not null order by 1; ts | b -----+--- 100 | t 101 | f -- Verify that NULL compression with bools is vectorized set timescaledb.debug_require_vector_qual to 'require'; update bool_table set b = NULL; select count(compress_chunk(x, true)) from show_chunks('bool_table') x; count ------- 1 select * from bool_table where b is null order by 1; ts | b -----+--- 100 | 101 | select * from bool_table where b is not null order by 1; ts | b ----+--- select * from bool_table where b is null or b is not null order by 1; ts | b -----+--- 100 | 101 | select * from bool_table where b is null and b is not null order by 1; ts | b ----+--- select * from bool_table where b is not true order by 1; ts | b -----+--- 100 | 101 | select * from bool_table where b is not false order by 1; ts | b -----+--- 100 | 101 | select * from bool_table where b is unknown order by 1; ts | b -----+--- 100 | 101 | select * from bool_table where b is not unknown order by 1; ts | b ----+--- -- Verify that NULL compression with ints is vectorized create table int_table(ts int, b int); select count(*) from create_hypertable('int_table', 'ts'); count ------- 1 alter table int_table set (timescaledb.compress); insert into int_table values (100, NULL), (101, NULL), (102, NULL); select count(compress_chunk(x, true)) from show_chunks('int_table') x; count ------- 1 select * from int_table where b is null order by 1; ts | b -----+--- 100 | 101 | 102 | select * from int_table where b is not null order by 1; ts | b ----+--- select * from int_table where b is null or b is not null order by 1; ts | b -----+--- 100 | 101 | 102 | select * from int_table where b is null and b is not null order by 1; ts | b ----+--- -- check the compression algorithm for the compressed chunks set timescaledb.enable_transparent_decompression='off'; DO $$ DECLARE comp_regclass REGCLASS; rec RECORD; BEGIN FOR comp_regclass IN SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as comp_regclass FROM _timescaledb_catalog.chunk uncomp, _timescaledb_catalog.chunk comp, (SELECT show_chunks('bool_table') as c UNION SELECT show_chunks('int_table') as c) as x WHERE uncomp.dropped IS FALSE AND uncomp.compressed_chunk_id IS NOT NULL AND comp.id = uncomp.compressed_chunk_id AND x.c = format('%I.%I', uncomp.schema_name, uncomp.table_name)::regclass LOOP FOR rec IN EXECUTE format('SELECT b, _timescaledb_functions.compressed_data_info(b) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Compressed info results: %', rec; END LOOP; FOR rec IN EXECUTE format('SELECT b, _timescaledb_functions.compressed_data_has_nulls(b) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Has nulls results: %', rec; END LOOP; END LOOP; END; $$; NOTICE: Compressed info results: (Bg==,"(NULL,t)") NOTICE: Has nulls results: (Bg==,t) NOTICE: Compressed info results: (Bg==,"(NULL,t)") NOTICE: Has nulls results: (Bg==,t) reset timescaledb.enable_transparent_decompression; reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bool_compression; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/detach_chunk.out�����������������������������������������������0000664�0000000�0000000�00000013244�15100345067�0022612�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :"TEST_DBNAME" TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- Create test tables and hypertables CREATE TABLE devices(id int PRIMARY KEY); INSERT INTO devices VALUES (1), (2), (3); CREATE TABLE detach_test(id int, time timestamptz not null, device int, temp float); CREATE INDEX detach_test_device_idx ON detach_test (device); ALTER TABLE detach_test ADD CONSTRAINT detach_test_temp_check CHECK (temp > 0), ADD CONSTRAINT detach_test_device_fkey FOREIGN KEY (device) REFERENCES devices(id), ADD CONSTRAINT detach_test_id_time_unique UNIQUE (id, time); SELECT * FROM create_hypertable('detach_test', 'time', 'id', 2); hypertable_id | schema_name | table_name | created ---------------+-------------+-------------+--------- 1 | public | detach_test | t CREATE TABLE detach_test_ref ( id int PRIMARY KEY, ref_id int, ref_time timestamptz, FOREIGN KEY (ref_id, ref_time) REFERENCES detach_test(id, time) ); INSERT INTO detach_test VALUES (1, '2025-06-01 05:00:00-8', 1, 23.4), (2, '2025-06-15 05:00:00-8', 2, 24.5), (3, '2025-06-30 05:00:00-8', 3, 25.6); -- Get chunk information for testing SELECT chunk_id AS "CHUNK_ID", hypertable_id AS "HYPERTABLE_ID", schema_name AS "CHUNK_SCHEMA", table_name AS "CHUNK_TABLE", schema_name || '.' || table_name AS "CHUNK_NAME" FROM _timescaledb_functions.show_chunk((SELECT show_chunks('detach_test') LIMIT 1)); \gset CHUNK_ID | HYPERTABLE_ID | CHUNK_SCHEMA | CHUNK_TABLE | CHUNK_NAME ----------+---------------+-----------------------+------------------+---------------------------------------- 1 | 1 | _timescaledb_internal | _hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk -- Detach by non-owner is not allowed \set ON_ERROR_STOP 0 set role :ROLE_1; CALL detach_chunk(:'CHUNK_NAME'); ERROR: must be owner of table detach_test set role :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 SELECT count(*) AS "PREV_CHUNK_ROWS" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; \gset PREV_CHUNK_ROWS ----------------- 3 -- Test successful detach CALL detach_chunk(:'CHUNK_NAME'); -- Verify chunk is detached: SELECT count(*) = :PREV_CHUNK_ROWS-1 FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; ?column? ---------- t SELECT count(*) = 0 FROM pg_inherits WHERE inhrelid = :'CHUNK_NAME'::regclass; ?column? ---------- t -- Data should still be in the detached table SELECT count(*) > 0 FROM :CHUNK_NAME; ?column? ---------- t -- Verify catalog cleanup SELECT count(*) = 0 FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'CHUNK_ID'; ?column? ---------- t SELECT count(*) = 0 FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.chunk_constraint cc ON cc.dimension_slice_id = ds.id WHERE cc.chunk_id = :'CHUNK_ID'; ?column? ---------- t SELECT count(*) = 0 FROM pg_constraint WHERE contype = 'f' AND confrelid = :'CHUNK_NAME'::regclass::oid; ?column? ---------- t DROP TABLE detach_test_ref; -- Verify new rows do not go to the detached chunk SELECT count(*) AS "DETACHED_CHUNK_ROWS" FROM :CHUNK_NAME; \gset DETACHED_CHUNK_ROWS --------------------- 1 INSERT INTO detach_test VALUES (4, '2025-06-01 09:00:00-8', 1, 50.0); SELECT count(*) = :'DETACHED_CHUNK_ROWS' FROM :CHUNK_NAME; ?column? ---------- t -- Verify detach can rollback SELECT count(*) AS "PREV_CHUNK_ROWS" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; \gset PREV_CHUNK_ROWS ----------------- 3 BEGIN; SELECT schema_name || '.' || table_name AS "ROLLBACK_CHUNK" FROM _timescaledb_functions.show_chunk((SELECT * FROM show_chunks('detach_test') LIMIT 1)); \gset ROLLBACK_CHUNK ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk CALL detach_chunk(:'ROLLBACK_CHUNK'); ROLLBACK; SELECT count(*) = :PREV_CHUNK_ROWS FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; ?column? ---------- t -- Error cases \set ON_ERROR_STOP 0 CALL detach_chunk(98765); ERROR: hypertable not found for the chunk CALL detach_chunk(0); ERROR: invalid chunk relation OID CALL detach_chunk('detach_test'); ERROR: hypertable not found for the chunk CALL detach_chunk(NULL); ERROR: invalid chunk relation OID -- Detach a regular table CREATE TABLE regular_table(time timestamptz, temp float); CALL detach_chunk('regular_table'); ERROR: hypertable not found for the chunk -- Try to detach already detached chunk CALL detach_chunk(:'CHUNK_NAME'); ERROR: hypertable not found for the chunk \set ON_ERROR_STOP 1 -- Compressed chunks ALTER TABLE detach_test SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device' ); SELECT schema_name || '.' || table_name AS "COMPRESSED_CHUNK" FROM _timescaledb_functions.show_chunk((SELECT * FROM show_chunks('detach_test') LIMIT 1)); \gset COMPRESSED_CHUNK ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk SELECT compress_chunk(:'COMPRESSED_CHUNK'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk -- Try to detach compressed chunk (should fail) \set ON_ERROR_STOP 0 CALL detach_chunk(:'COMPRESSED_CHUNK'); ERROR: cannot detach compressed chunk "_hyper_1_2_chunk" \set ON_ERROR_STOP 1 DROP TABLE :CHUNK_NAME; DROP TABLE detach_test; DROP TABLE devices CASCADE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/direct_compress_copy.out���������������������������������������0000664�0000000�0000000�00000034720�15100345067�0024413�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser for copy from program \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE metrics (time TIMESTAMPTZ NOT NULL, device TEXT, value float) WITH (tsdb.hypertable, tsdb.partition_column = 'time', tsdb.orderby='time'); -- first try without the GUCs BEGIN; COPY metrics FROM PROGRAM 'seq 100 | xargs -II date -d "2025-01-01 + I hour" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=100.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=15.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=85.00 loops=1) ROLLBACK; SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_sort_batches = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; -- simple test with compressed copy enabled BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=3000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=959.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Wed Jan 01 00:01:00 2025 PST | Fri Jan 03 02:00:00 2025 PST ROLLBACK; -- simple test with compressed copy enabled and reversed order BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_7_chunk (actual rows=3000.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Sun Dec 29 22:00:00 2024 PST | Tue Dec 31 23:59:00 2024 PST ROLLBACK; SET timescaledb.enable_direct_compress_copy_sort_batches = false; -- simple test with compressed copy enabled and without batch sorting BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=3000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_9_chunk (actual rows=959.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_11_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_12_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Wed Jan 01 00:01:00 2025 PST | Fri Jan 03 02:00:00 2025 PST ROLLBACK; -- simple test with compressed copy enabled and reversed order and no batch sorting BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_13_chunk (actual rows=3000.00 loops=1) -> Seq Scan on compress_hyper_2_14_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Tue Dec 31 23:59:00 2024 PST | Sun Dec 29 22:00:00 2024 PST ROLLBACK; -- test compressing into uncompressed chunk RESET timescaledb.enable_direct_compress_copy; RESET timescaledb.enable_direct_compress_copy_sort_batches; RESET timescaledb.enable_direct_compress_copy_client_sorted; BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=6000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_15_chunk (actual rows=959.00 loops=1) -> Seq Scan on compress_hyper_2_17_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_15_chunk (actual rows=959.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_16_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_18_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_16_chunk (actual rows=2041.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- 9 ROLLBACK; -- simple test with compressed copy enabled and reversed order BEGIN; SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_19_chunk (actual rows=3000.00 loops=1) -> Seq Scan on compress_hyper_2_20_chunk (actual rows=3.00 loops=1) -- status should be 9 SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- 1 ROLLBACK; -- simple test with compressed copy enabled and no presorted BEGIN; SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_21_chunk (actual rows=3000.00 loops=1) -> Seq Scan on compress_hyper_2_22_chunk (actual rows=3.00 loops=1) -- status should be 11 SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- 3 ROLLBACK; -- test with segmentby BEGIN; ALTER TABLE metrics SET (tsdb.segmentby = 'device'); SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics FROM PROGRAM 'seq 0 0.2 9.8 | sed -e ''s!.[0-9]$!!'' | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,dI,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_23_chunk (actual rows=50.00 loops=1) -> Seq Scan on compress_hyper_2_24_chunk (actual rows=10.00 loops=1) SELECT format('%I.%I',schema_name,table_name) AS "COMPRESSED_CHUNK" FROM _timescaledb_catalog.chunk where compressed_chunk_id IS NULL \gset -- should have 10 batches SELECT count(*) FROM :COMPRESSED_CHUNK; count ------- 10 ROLLBACK; -- test unique constraints prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_copy = true; ALTER TABLE metrics ADD CONSTRAINT unique_time_device UNIQUE (time, device); COPY metrics FROM STDIN WITH (FORMAT CSV); WARNING: disabling direct compress because the destination table has unique constraints EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Seq Scan on _hyper_1_25_chunk (actual rows=1.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- ROLLBACK; -- test triggers prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_copy = true; CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER metrics_trigger BEFORE INSERT OR UPDATE ON metrics FOR EACH ROW EXECUTE FUNCTION test_trigger(); COPY metrics FROM STDIN WITH (FORMAT CSV); WARNING: disabling direct compress copy due to presence of triggers on the destination table EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Seq Scan on _hyper_1_26_chunk (actual rows=1.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- ROLLBACK; -- test caggs prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_copy = true; CREATE MATERIALIZED VIEW metrics_cagg WITH (tsdb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, device, avg(value) AS avg_value FROM metrics GROUP BY bucket, device WITH NO DATA; COPY metrics FROM STDIN WITH (FORMAT CSV); WARNING: disabling direct compress because the destination table has continuous aggregates EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Seq Scan on _hyper_1_27_chunk (actual rows=1.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- ROLLBACK; -- test chunk status handling CREATE TABLE metrics_status(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time'); -- normal insert should result in chunk status 0 INSERT INTO metrics_status SELECT '2025-01-01'; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {} BEGIN; -- compressed copy into uncompressed chunk should result in chunk status 11 (compressed,partial,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics_status FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text -------------------------------- {COMPRESSED,UNORDERED,PARTIAL} ROLLBACK; BEGIN; -- compressed sorted copy into uncompressed chunk should result in chunk status 9 (compressed,partial) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics_status FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ---------------------- {COMPRESSED,PARTIAL} ROLLBACK; TRUNCATE metrics_status; BEGIN; -- compressed copy into new chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics_status FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; BEGIN; -- compressed sorted copy into new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics_status FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {COMPRESSED} ROLLBACK; SET timescaledb.enable_direct_compress_copy = false; SET timescaledb.enable_direct_compress_copy_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {} SELECT compress_chunk(show_chunks('metrics_status')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_4_35_chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {COMPRESSED} BEGIN; -- compressed copy into fully compressed chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics_status FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; BEGIN; -- compressed copy new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics_status FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {COMPRESSED} ROLLBACK; SELECT tableoid::regclass AS "CHUNK" FROM metrics_status WHERE time = '2025-01-01' LIMIT 1 \gset -- repeat tests with direct reference to chunk BEGIN; -- compressed copy into fully compressed chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY :CHUNK FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(:'CHUNK'::regclass); chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; BEGIN; -- compressed copy new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY :CHUNK FROM STDIN; SELECT _timescaledb_functions.chunk_status_text(:'CHUNK'::regclass); chunk_status_text ------------------- {COMPRESSED} ROLLBACK; ������������������������������������������������timescaledb-2.23.0/tsl/test/expected/direct_compress_insert.out�������������������������������������0000664�0000000�0000000�00000051534�15100345067�0024747�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics (time TIMESTAMPTZ NOT NULL, device TEXT, value float) WITH (tsdb.hypertable, tsdb.orderby='time'); NOTICE: using column "time" as partitioning column -- first try without the GUCs BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' hour')::interval, 'd1', i::float FROM generate_series(0,100) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=101.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=16.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=85.00 loops=1) -- should have no status aka normal uncompressed chunk SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------- {} ROLLBACK; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_sort_batches = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; -- EXPLAIN with too small batch EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) INSERT INTO metrics SELECT '2025-01-01'::timestamptz, 'd1', i::float FROM generate_series(0,5) i; WARNING: disabling direct compress because of too small batch size --- QUERY PLAN --- Custom Scan (ModifyHypertable) Direct Compress: false -> Insert on metrics -> Function Scan on generate_series i -- EXPLAIN with large enough batch EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) INSERT INTO metrics SELECT '2025-01-01'::timestamptz, 'd1', i::float FROM generate_series(0,500) i; --- QUERY PLAN --- Custom Scan (ModifyHypertable) Direct Compress: true -> Insert on metrics -> Function Scan on generate_series i -- simple test with compressed insert enabled BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=3001.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Wed Jan 01 00:00:00 2025 PST | Fri Jan 03 02:00:00 2025 PST -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; -- simple test with compressed insert enabled and reversed order BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=3001.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_7_chunk (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_9_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Wed Jan 01 00:00:00 2025 PST | Fri Jan 03 02:00:00 2025 PST -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; SET timescaledb.enable_direct_compress_insert_sort_batches = false; -- simple test with compressed insert enabled and without batch sorting BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=3001.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_11_chunk (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_13_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_14_chunk (actual rows=3.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Wed Jan 01 00:00:00 2025 PST | Fri Jan 03 02:00:00 2025 PST -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; -- simple test with compressed insert enabled and reversed order and no batch sorting BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_15_chunk (actual rows=3001.00 loops=1) -> Seq Scan on compress_hyper_2_16_chunk (actual rows=4.00 loops=1) SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; first | last ------------------------------+------------------------------ Wed Jan 01 00:00:00 2025 PST | Sun Dec 29 22:00:00 2024 PST -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; -- test compressing into uncompressed chunk RESET timescaledb.enable_direct_compress_insert; RESET timescaledb.enable_direct_compress_insert_sort_batches; RESET timescaledb.enable_direct_compress_insert_client_sorted; BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=6002.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_17_chunk (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_17_chunk (actual rows=960.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_18_chunk (actual rows=2041.00 loops=1) -> Seq Scan on compress_hyper_2_20_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_18_chunk (actual rows=2041.00 loops=1) -- since the chunks are new status should be COMPRESSED, PARTIAL SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ---------------------- {COMPRESSED,PARTIAL} ROLLBACK; -- simple test with compressed insert enabled and reversed order BEGIN; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_21_chunk (actual rows=3001.00 loops=1) -> Seq Scan on compress_hyper_2_22_chunk (actual rows=4.00 loops=1) -- since the chunks are new status should be COMPRESSED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------- {COMPRESSED} ROLLBACK; -- simple test with compressed insert enabled and no presorted BEGIN; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_23_chunk (actual rows=3001.00 loops=1) -> Seq Scan on compress_hyper_2_24_chunk (actual rows=4.00 loops=1) -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; -- simple test with compressed insert enabled and no presorted and with uncompressed data BEGIN; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics SELECT '2025-01-01'::timestamptz, 'd1', 0; WARNING: disabling direct compress because of too small batch size INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Append (actual rows=3002.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_25_chunk (actual rows=3001.00 loops=1) -> Seq Scan on compress_hyper_2_26_chunk (actual rows=4.00 loops=1) -> Seq Scan on _hyper_1_25_chunk (actual rows=1.00 loops=1) -- since the chunks are new status should be COMPRESSED, UNORDERED, PARTIAL SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text -------------------------------- {COMPRESSED,UNORDERED,PARTIAL} ROLLBACK; -- test with segmentby BEGIN; ALTER TABLE metrics SET (tsdb.segmentby = 'device'); SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, floor(i), i::float FROM generate_series(0.0,9.8,0.2) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_1_27_chunk (actual rows=50.00 loops=1) -> Seq Scan on compress_hyper_2_28_chunk (actual rows=10.00 loops=1) SELECT format('%I.%I',schema_name,table_name) AS "COMPRESSED_CHUNK" FROM _timescaledb_catalog.chunk where compressed_chunk_id IS NULL \gset -- should have 10 batches SELECT count(*) FROM :COMPRESSED_CHUNK; count ------- 10 -- since the chunks are new status should be COMPRESSED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; chunk_status_text ------------------- {COMPRESSED} ROLLBACK; -- test unique constraints prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_insert = true; ALTER TABLE metrics ADD CONSTRAINT unique_time_device UNIQUE (time, device); INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,100) i; WARNING: disabling direct compress because the destination table has unique constraints EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Seq Scan on _hyper_1_29_chunk (actual rows=101.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- ROLLBACK; -- test triggers prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_insert = true; CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER metrics_trigger BEFORE INSERT OR UPDATE ON metrics FOR EACH ROW EXECUTE FUNCTION test_trigger(); INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,100) i; WARNING: disabling direct compress because the destination table has triggers EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Seq Scan on _hyper_1_30_chunk (actual rows=101.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- ROLLBACK; -- test caggs prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_insert = true; CREATE MATERIALIZED VIEW metrics_cagg WITH (tsdb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, device, avg(value) AS avg_value FROM metrics GROUP BY bucket, device WITH NO DATA; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,100) i; WARNING: disabling direct compress because the destination table has continuous aggregates EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; --- QUERY PLAN --- Seq Scan on _hyper_1_31_chunk (actual rows=101.00 loops=1) SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; status -------- ROLLBACK; -- test chunk status handling CREATE TABLE metrics_status(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO metrics_status SELECT '2025-01-01'; -- normal insert should result in chunk status 0 SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {} SET timescaledb.enable_direct_compress_insert = true; BEGIN; INSERT INTO metrics_status SELECT '2025-01-01' FROM generate_series(1,9); WARNING: disabling direct compress because of too small batch size -- small insert batches should not result in compressed chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {} ROLLBACK; BEGIN; INSERT INTO metrics_status SELECT '2025-01-01' FROM generate_series(1,10); -- status should be COMPRESSED, UNORDERED, PARTIAL since we have more than 10 rows in the chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text -------------------------------- {COMPRESSED,UNORDERED,PARTIAL} ROLLBACK; BEGIN; -- compressed sorted copy into uncompressed chunk should result in chunk status 9 (compressed,partial) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, PARTIAL SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ---------------------- {COMPRESSED,PARTIAL} ROLLBACK; TRUNCATE metrics_status; BEGIN; -- compressed insert into new chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, UNORDERED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; BEGIN; -- compressed sorted copy into new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {COMPRESSED} ROLLBACK; SET timescaledb.enable_direct_compress_insert = false; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'; -- no status aka normal uncompressed chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {} SELECT compress_chunk(show_chunks('metrics_status')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_4_39_chunk -- status should be COMPRESSED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {COMPRESSED} BEGIN; -- compressed insert into fully compressed chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, UNORDERED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------------ {COMPRESSED,UNORDERED} ROLLBACK; BEGIN; -- compressed insert new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; chunk_status_text ------------------- {COMPRESSED} ROLLBACK; -- test direct compress into chunk directly CREATE TABLE metrics_chunk(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time'); SET timescaledb.enable_direct_compress_insert = true; -- create uncompressed chunk INSERT INTO metrics_chunk SELECT '2025-01-01'; WARNING: disabling direct compress because of too small batch size -- status should be normal uncompressed chunk since it was single tuple insert SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_chunk') chunk; chunk_status_text ------------------- {} SELECT show_chunks('metrics_chunk') AS "CHUNK" \gset EXPLAIN (costs off,summary off,timing off) INSERT INTO :CHUNK SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; --- QUERY PLAN --- Custom Scan (ModifyHypertable) Direct Compress: true -> Insert on _hyper_6_41_chunk -> Function Scan on generate_series i BEGIN; INSERT INTO :CHUNK SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, UNORDERED, PARTIAL SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_chunk') chunk; chunk_status_text -------------------------------- {COMPRESSED,UNORDERED,PARTIAL} -- delete should propagate to compressed chunk SELECT count(*) FROM :CHUNK; count ------- 102 EXPLAIN (analyze,buffers off,costs off,summary off,timing off) DELETE FROM :CHUNK WHERE time > '2025-01-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 1 Tuples decompressed: 101 -> Delete on _hyper_6_41_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_6_41_chunk_metrics_chunk_time_idx on _hyper_6_41_chunk (actual rows=100.00 loops=1) Index Cond: ("time" > 'Wed Jan 01 00:00:00 2025 PST'::timestamp with time zone) SELECT count(*) FROM :CHUNK; count ------- 2 ROLLBACK; BEGIN; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO :CHUNK SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, PARTIAL SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_chunk') chunk; chunk_status_text ---------------------- {COMPRESSED,PARTIAL} ROLLBACK; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/exp_cagg_monthly.out�������������������������������������������0000664�0000000�0000000�00000120400�15100345067�0023512�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ------------------------- (1,public,conditions,t) INSERT INTO conditions (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); -- Check that buckets like '1 month 15 days' (fixed-sized + variable-sized) are not allowed \set ON_ERROR_STOP 0 -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: invalid interval specified \set ON_ERROR_STOP 1 -- Make sure it's possible to create an empty cagg (WITH NO DATA) and -- that all the information about the bucketing function will be saved -- to the TS catalog. CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT mat_hypertable_id AS cagg_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary' \gset SELECT raw_hypertable_id AS ht_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary' \gset \pset null <NULL> SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id; mat_hypertable_id | bucket_func | bucket_width | bucket_origin | bucket_offset | bucket_timezone | bucket_fixed_width -------------------+-------------------------------------------------------------------+--------------+---------------+---------------+-----------------+-------------------- 2 | timescaledb_experimental.time_bucket_ng(interval,pg_catalog.date) | @ 1 mon | <NULL> | <NULL> | <NULL> | f \pset null "" -- Check that the saved invalidation threshold is -infinity SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; to_timestamp -------------- -infinity -- Make sure truncating of the refresh window works \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('conditions_summary', '2021-07-02', '2021-07-12'); ERROR: refresh window too small \set ON_ERROR_STOP 1 -- Make sure refreshing works CALL refresh_continuous_aggregate('conditions_summary', '2021-06-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 -- Make sure larger refresh window is fine too CALL refresh_continuous_aggregate('conditions_summary', '2021-03-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 -- Special check for "invalid or missing information about the bucketing -- function" code path \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE TEMPORARY TABLE restore_table ( LIKE _timescaledb_catalog.continuous_aggs_bucket_function ); INSERT INTO restore_table SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function; DELETE FROM _timescaledb_catalog.continuous_aggs_bucket_function; \set ON_ERROR_STOP 0 -- should fail with "invalid or missing information..." CALL refresh_continuous_aggregate('conditions_summary', '2021-06-01', '2021-07-01'); ERROR: invalid or missing information about the bucketing function for cagg \set ON_ERROR_STOP 1 INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT * FROM restore_table; DROP TABLE restore_table; -- should execute successfully CALL refresh_continuous_aggregate('conditions_summary', '2021-06-01', '2021-07-01'); NOTICE: continuous aggregate "conditions_summary" is already up-to-date SET ROLE :ROLE_DEFAULT_PERM_USER; -- Check the invalidation threshold SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone -------------------------- Thu Jul 01 00:00:00 2021 -- Add some dummy data for two more months and call refresh (no invalidations test case) INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-07-01' :: date, '2021-08-31', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; -- Double check generated data SELECT to_char(day, 'YYYY-MM-DD'), city, temperature FROM conditions WHERE day >= '2021-07-01' ORDER BY city DESC, day; to_char | city | temperature ------------+--------+------------- 2021-07-01 | Moscow | 1 2021-07-02 | Moscow | 2 2021-07-03 | Moscow | 3 2021-07-04 | Moscow | 4 2021-07-05 | Moscow | 5 2021-07-06 | Moscow | 6 2021-07-07 | Moscow | 7 2021-07-08 | Moscow | 8 2021-07-09 | Moscow | 9 2021-07-10 | Moscow | 10 2021-07-11 | Moscow | 11 2021-07-12 | Moscow | 12 2021-07-13 | Moscow | 13 2021-07-14 | Moscow | 14 2021-07-15 | Moscow | 15 2021-07-16 | Moscow | 16 2021-07-17 | Moscow | 17 2021-07-18 | Moscow | 18 2021-07-19 | Moscow | 19 2021-07-20 | Moscow | 20 2021-07-21 | Moscow | 21 2021-07-22 | Moscow | 22 2021-07-23 | Moscow | 23 2021-07-24 | Moscow | 24 2021-07-25 | Moscow | 25 2021-07-26 | Moscow | 26 2021-07-27 | Moscow | 27 2021-07-28 | Moscow | 28 2021-07-29 | Moscow | 29 2021-07-30 | Moscow | 30 2021-07-31 | Moscow | 31 2021-08-01 | Moscow | 32 2021-08-02 | Moscow | 33 2021-08-03 | Moscow | 34 2021-08-04 | Moscow | 35 2021-08-05 | Moscow | 36 2021-08-06 | Moscow | 37 2021-08-07 | Moscow | 38 2021-08-08 | Moscow | 39 2021-08-09 | Moscow | 40 2021-08-10 | Moscow | 41 2021-08-11 | Moscow | 42 2021-08-12 | Moscow | 43 2021-08-13 | Moscow | 44 2021-08-14 | Moscow | 45 2021-08-15 | Moscow | 46 2021-08-16 | Moscow | 47 2021-08-17 | Moscow | 48 2021-08-18 | Moscow | 49 2021-08-19 | Moscow | 50 2021-08-20 | Moscow | 51 2021-08-21 | Moscow | 52 2021-08-22 | Moscow | 53 2021-08-23 | Moscow | 54 2021-08-24 | Moscow | 55 2021-08-25 | Moscow | 56 2021-08-26 | Moscow | 57 2021-08-27 | Moscow | 58 2021-08-28 | Moscow | 59 2021-08-29 | Moscow | 60 2021-08-30 | Moscow | 61 2021-08-31 | Moscow | 62 2021-07-01 | Berlin | 63 2021-07-02 | Berlin | 64 2021-07-03 | Berlin | 65 2021-07-04 | Berlin | 66 2021-07-05 | Berlin | 67 2021-07-06 | Berlin | 68 2021-07-07 | Berlin | 69 2021-07-08 | Berlin | 70 2021-07-09 | Berlin | 71 2021-07-10 | Berlin | 72 2021-07-11 | Berlin | 73 2021-07-12 | Berlin | 74 2021-07-13 | Berlin | 75 2021-07-14 | Berlin | 76 2021-07-15 | Berlin | 77 2021-07-16 | Berlin | 78 2021-07-17 | Berlin | 79 2021-07-18 | Berlin | 80 2021-07-19 | Berlin | 81 2021-07-20 | Berlin | 82 2021-07-21 | Berlin | 83 2021-07-22 | Berlin | 84 2021-07-23 | Berlin | 85 2021-07-24 | Berlin | 86 2021-07-25 | Berlin | 87 2021-07-26 | Berlin | 88 2021-07-27 | Berlin | 89 2021-07-28 | Berlin | 90 2021-07-29 | Berlin | 91 2021-07-30 | Berlin | 92 2021-07-31 | Berlin | 93 2021-08-01 | Berlin | 94 2021-08-02 | Berlin | 95 2021-08-03 | Berlin | 96 2021-08-04 | Berlin | 97 2021-08-05 | Berlin | 98 2021-08-06 | Berlin | 99 2021-08-07 | Berlin | 100 2021-08-08 | Berlin | 101 2021-08-09 | Berlin | 102 2021-08-10 | Berlin | 103 2021-08-11 | Berlin | 104 2021-08-12 | Berlin | 105 2021-08-13 | Berlin | 106 2021-08-14 | Berlin | 107 2021-08-15 | Berlin | 108 2021-08-16 | Berlin | 109 2021-08-17 | Berlin | 110 2021-08-18 | Berlin | 111 2021-08-19 | Berlin | 112 2021-08-20 | Berlin | 113 2021-08-21 | Berlin | 114 2021-08-22 | Berlin | 115 2021-08-23 | Berlin | 116 2021-08-24 | Berlin | 117 2021-08-25 | Berlin | 118 2021-08-26 | Berlin | 119 2021-08-27 | Berlin | 120 2021-08-28 | Berlin | 121 2021-08-29 | Berlin | 122 2021-08-30 | Berlin | 123 2021-08-31 | Berlin | 124 -- Make sure the invalidation threshold was unaffected SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone -------------------------- Thu Jul 01 00:00:00 2021 -- Make sure the invalidation log is empty SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Call refresh CALL refresh_continuous_aggregate('conditions_summary', '2021-06-15', '2021-09-15'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 -- Make sure the invalidation threshold has changed SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone -------------------------- Wed Sep 01 00:00:00 2021 -- Make sure the catalog is cleaned up when the cagg is dropped DROP MATERIALIZED VIEW conditions_summary; NOTICE: drop cascades to 3 other objects SELECT count(*) FROM _timescaledb_catalog.continuous_agg WHERE mat_hypertable_id = :cagg_id; count ------- 0 SELECT count(*) FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id; count ------- 0 -- Re-create cagg, this time WITH DATA SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; -- Make sure cagg was filled SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 -- Check the invalidation. -- Step 1/2. Insert some more data , do a refresh and make sure that the -- invalidation log is empty. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-09-01' :: date, '2021-09-15', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; CALL refresh_continuous_aggregate('conditions_summary', '2021-09-01', '2021-10-01'); SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 30 Moscow | 2021-09-01 | 1 | 15 -- Step 2/2. Add more data below the invalidation threshold, make sure that the -- invalidation log is not empty, that do a refresh. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, (CASE WHEN city = 'Moscow' THEN -40 ELSE 40 END) FROM generate_series('2021-09-16' :: date, '2021-09-30', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'UTC' AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'UTC' AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------------------------+-------------------------- Thu Sep 16 00:00:00 2021 | Thu Sep 30 00:00:00 2021 CALL refresh_continuous_aggregate('conditions_summary', '2021-09-01', '2021-10-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Create a real-time aggregate DROP MATERIALIZED VIEW conditions_summary; NOTICE: drop cascades to 4 other objects SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 -- Add some data to the hypertable and make sure they are visible in the cagg INSERT INTO conditions (day, city, temperature) VALUES ('2021-10-01', 'Moscow', 1), ('2021-10-02', 'Moscow', 2), ('2021-10-03', 'Moscow', 3), ('2021-10-04', 'Moscow', 4), ('2021-10-01', 'Berlin', 5), ('2021-10-02', 'Berlin', 6), ('2021-10-03', 'Berlin', 7), ('2021-10-04', 'Berlin', 8); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary', '2021-10-01', '2021-11-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions (day, city, temperature) VALUES ('2021-11-01', 'Moscow', 11), ('2021-11-02', 'Moscow', 12), ('2021-11-03', 'Moscow', 13), ('2021-11-04', 'Moscow', 14), ('2021-11-01', 'Berlin', 15), ('2021-11-02', 'Berlin', 16), ('2021-11-03', 'Berlin', 17), ('2021-11-04', 'Berlin', 18); ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions') AS ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_9_chunk _timescaledb_internal._hyper_1_10_chunk _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk _timescaledb_internal._hyper_1_14_chunk _timescaledb_internal._hyper_1_16_chunk _timescaledb_internal._hyper_1_17_chunk _timescaledb_internal._hyper_1_18_chunk _timescaledb_internal._hyper_1_19_chunk _timescaledb_internal._hyper_1_20_chunk _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_22_chunk _timescaledb_internal._hyper_1_23_chunk _timescaledb_internal._hyper_1_24_chunk _timescaledb_internal._hyper_1_25_chunk _timescaledb_internal._hyper_1_26_chunk _timescaledb_internal._hyper_1_27_chunk _timescaledb_internal._hyper_1_28_chunk _timescaledb_internal._hyper_1_29_chunk _timescaledb_internal._hyper_1_30_chunk _timescaledb_internal._hyper_1_31_chunk _timescaledb_internal._hyper_1_32_chunk _timescaledb_internal._hyper_1_33_chunk _timescaledb_internal._hyper_1_34_chunk _timescaledb_internal._hyper_1_35_chunk _timescaledb_internal._hyper_1_36_chunk _timescaledb_internal._hyper_1_37_chunk _timescaledb_internal._hyper_1_38_chunk _timescaledb_internal._hyper_1_39_chunk _timescaledb_internal._hyper_1_40_chunk _timescaledb_internal._hyper_1_41_chunk _timescaledb_internal._hyper_1_42_chunk _timescaledb_internal._hyper_1_43_chunk _timescaledb_internal._hyper_1_44_chunk _timescaledb_internal._hyper_1_45_chunk _timescaledb_internal._hyper_1_46_chunk _timescaledb_internal._hyper_1_47_chunk _timescaledb_internal._hyper_1_48_chunk _timescaledb_internal._hyper_1_49_chunk _timescaledb_internal._hyper_1_50_chunk _timescaledb_internal._hyper_1_51_chunk _timescaledb_internal._hyper_1_52_chunk _timescaledb_internal._hyper_1_53_chunk _timescaledb_internal._hyper_1_54_chunk _timescaledb_internal._hyper_1_55_chunk _timescaledb_internal._hyper_1_56_chunk _timescaledb_internal._hyper_1_57_chunk _timescaledb_internal._hyper_1_58_chunk _timescaledb_internal._hyper_1_59_chunk _timescaledb_internal._hyper_1_60_chunk _timescaledb_internal._hyper_1_61_chunk _timescaledb_internal._hyper_1_62_chunk _timescaledb_internal._hyper_1_63_chunk _timescaledb_internal._hyper_1_64_chunk _timescaledb_internal._hyper_1_65_chunk _timescaledb_internal._hyper_1_66_chunk _timescaledb_internal._hyper_1_67_chunk _timescaledb_internal._hyper_1_68_chunk _timescaledb_internal._hyper_1_69_chunk _timescaledb_internal._hyper_1_70_chunk _timescaledb_internal._hyper_1_71_chunk _timescaledb_internal._hyper_1_72_chunk _timescaledb_internal._hyper_1_73_chunk _timescaledb_internal._hyper_1_74_chunk _timescaledb_internal._hyper_1_75_chunk _timescaledb_internal._hyper_1_76_chunk _timescaledb_internal._hyper_1_77_chunk _timescaledb_internal._hyper_1_83_chunk _timescaledb_internal._hyper_1_84_chunk _timescaledb_internal._hyper_1_85_chunk _timescaledb_internal._hyper_1_86_chunk _timescaledb_internal._hyper_1_87_chunk _timescaledb_internal._hyper_1_88_chunk _timescaledb_internal._hyper_1_89_chunk _timescaledb_internal._hyper_1_90_chunk _timescaledb_internal._hyper_1_91_chunk _timescaledb_internal._hyper_1_92_chunk _timescaledb_internal._hyper_1_93_chunk _timescaledb_internal._hyper_1_94_chunk _timescaledb_internal._hyper_1_95_chunk _timescaledb_internal._hyper_1_96_chunk _timescaledb_internal._hyper_1_97_chunk _timescaledb_internal._hyper_1_99_chunk _timescaledb_internal._hyper_1_100_chunk _timescaledb_internal._hyper_1_101_chunk _timescaledb_internal._hyper_1_102_chunk _timescaledb_internal._hyper_1_103_chunk _timescaledb_internal._hyper_1_104_chunk _timescaledb_internal._hyper_1_105_chunk _timescaledb_internal._hyper_1_106_chunk _timescaledb_internal._hyper_1_107_chunk _timescaledb_internal._hyper_1_108_chunk _timescaledb_internal._hyper_1_109_chunk _timescaledb_internal._hyper_1_110_chunk _timescaledb_internal._hyper_1_111_chunk _timescaledb_internal._hyper_1_112_chunk _timescaledb_internal._hyper_1_113_chunk _timescaledb_internal._hyper_1_118_chunk _timescaledb_internal._hyper_1_119_chunk _timescaledb_internal._hyper_1_120_chunk _timescaledb_internal._hyper_1_121_chunk _timescaledb_internal._hyper_1_123_chunk _timescaledb_internal._hyper_1_124_chunk _timescaledb_internal._hyper_1_125_chunk _timescaledb_internal._hyper_1_126_chunk -- Data for 2021-11 is seen because the cagg is real-time SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 Berlin | 2021-11-01 | 15 | 18 Moscow | 2021-11-01 | 11 | 14 CALL refresh_continuous_aggregate('conditions_summary', '2021-11-01', '2021-12-01'); -- Data for 2021-11 is seen because the cagg was refreshed SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 Berlin | 2021-07-01 | 63 | 93 Moscow | 2021-07-01 | 1 | 31 Berlin | 2021-08-01 | 94 | 124 Moscow | 2021-08-01 | 32 | 62 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 Berlin | 2021-11-01 | 15 | 18 Moscow | 2021-11-01 | 11 | 14 -- Test N-months buckets where N in 2,3,4,5,6,12,13 on a relatively large table -- This also tests the case when a single hypertable has multiple caggs. CREATE TABLE conditions_large( day DATE NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_large', 'day', chunk_time_interval => INTERVAL '1 month' ); create_hypertable ------------------------------- (6,public,conditions_large,t) INSERT INTO conditions_large(day, temperature) SELECT ts, date_part('month', ts)*100 + date_part('day', ts) FROM generate_series('2010-01-01' :: date, '2020-01-01' :: date - interval '1 day', '1 day') as ts; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_2m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('2 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_2m" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_2m ORDER BY bucket; bucket | min | max ------------+------+------ 01-01-2010 | 101 | 228 03-01-2010 | 301 | 430 05-01-2010 | 501 | 630 07-01-2010 | 701 | 831 09-01-2010 | 901 | 1031 11-01-2010 | 1101 | 1231 01-01-2011 | 101 | 228 03-01-2011 | 301 | 430 05-01-2011 | 501 | 630 07-01-2011 | 701 | 831 09-01-2011 | 901 | 1031 11-01-2011 | 1101 | 1231 01-01-2012 | 101 | 229 03-01-2012 | 301 | 430 05-01-2012 | 501 | 630 07-01-2012 | 701 | 831 09-01-2012 | 901 | 1031 11-01-2012 | 1101 | 1231 01-01-2013 | 101 | 228 03-01-2013 | 301 | 430 05-01-2013 | 501 | 630 07-01-2013 | 701 | 831 09-01-2013 | 901 | 1031 11-01-2013 | 1101 | 1231 01-01-2014 | 101 | 228 03-01-2014 | 301 | 430 05-01-2014 | 501 | 630 07-01-2014 | 701 | 831 09-01-2014 | 901 | 1031 11-01-2014 | 1101 | 1231 01-01-2015 | 101 | 228 03-01-2015 | 301 | 430 05-01-2015 | 501 | 630 07-01-2015 | 701 | 831 09-01-2015 | 901 | 1031 11-01-2015 | 1101 | 1231 01-01-2016 | 101 | 229 03-01-2016 | 301 | 430 05-01-2016 | 501 | 630 07-01-2016 | 701 | 831 09-01-2016 | 901 | 1031 11-01-2016 | 1101 | 1231 01-01-2017 | 101 | 228 03-01-2017 | 301 | 430 05-01-2017 | 501 | 630 07-01-2017 | 701 | 831 09-01-2017 | 901 | 1031 11-01-2017 | 1101 | 1231 01-01-2018 | 101 | 228 03-01-2018 | 301 | 430 05-01-2018 | 501 | 630 07-01-2018 | 701 | 831 09-01-2018 | 901 | 1031 11-01-2018 | 1101 | 1231 01-01-2019 | 101 | 228 03-01-2019 | 301 | 430 05-01-2019 | 501 | 630 07-01-2019 | 701 | 831 09-01-2019 | 901 | 1031 11-01-2019 | 1101 | 1231 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_3m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('3 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_3m" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_3m ORDER BY bucket; bucket | min | max ------------+------+------ 01-01-2010 | 101 | 331 04-01-2010 | 401 | 630 07-01-2010 | 701 | 930 10-01-2010 | 1001 | 1231 01-01-2011 | 101 | 331 04-01-2011 | 401 | 630 07-01-2011 | 701 | 930 10-01-2011 | 1001 | 1231 01-01-2012 | 101 | 331 04-01-2012 | 401 | 630 07-01-2012 | 701 | 930 10-01-2012 | 1001 | 1231 01-01-2013 | 101 | 331 04-01-2013 | 401 | 630 07-01-2013 | 701 | 930 10-01-2013 | 1001 | 1231 01-01-2014 | 101 | 331 04-01-2014 | 401 | 630 07-01-2014 | 701 | 930 10-01-2014 | 1001 | 1231 01-01-2015 | 101 | 331 04-01-2015 | 401 | 630 07-01-2015 | 701 | 930 10-01-2015 | 1001 | 1231 01-01-2016 | 101 | 331 04-01-2016 | 401 | 630 07-01-2016 | 701 | 930 10-01-2016 | 1001 | 1231 01-01-2017 | 101 | 331 04-01-2017 | 401 | 630 07-01-2017 | 701 | 930 10-01-2017 | 1001 | 1231 01-01-2018 | 101 | 331 04-01-2018 | 401 | 630 07-01-2018 | 701 | 930 10-01-2018 | 1001 | 1231 01-01-2019 | 101 | 331 04-01-2019 | 401 | 630 07-01-2019 | 701 | 930 10-01-2019 | 1001 | 1231 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_4m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('4 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_4m" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_4m ORDER BY bucket; bucket | min | max ------------+-----+------ 01-01-2010 | 101 | 430 05-01-2010 | 501 | 831 09-01-2010 | 901 | 1231 01-01-2011 | 101 | 430 05-01-2011 | 501 | 831 09-01-2011 | 901 | 1231 01-01-2012 | 101 | 430 05-01-2012 | 501 | 831 09-01-2012 | 901 | 1231 01-01-2013 | 101 | 430 05-01-2013 | 501 | 831 09-01-2013 | 901 | 1231 01-01-2014 | 101 | 430 05-01-2014 | 501 | 831 09-01-2014 | 901 | 1231 01-01-2015 | 101 | 430 05-01-2015 | 501 | 831 09-01-2015 | 901 | 1231 01-01-2016 | 101 | 430 05-01-2016 | 501 | 831 09-01-2016 | 901 | 1231 01-01-2017 | 101 | 430 05-01-2017 | 501 | 831 09-01-2017 | 901 | 1231 01-01-2018 | 101 | 430 05-01-2018 | 501 | 831 09-01-2018 | 901 | 1231 01-01-2019 | 101 | 430 05-01-2019 | 501 | 831 09-01-2019 | 901 | 1231 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_5m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_5m" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_5m ORDER BY bucket; bucket | min | max ------------+-----+------ 01-01-2010 | 101 | 531 06-01-2010 | 601 | 1031 11-01-2010 | 101 | 1231 04-01-2011 | 401 | 831 09-01-2011 | 101 | 1231 02-01-2012 | 201 | 630 07-01-2012 | 701 | 1130 12-01-2012 | 101 | 1231 05-01-2013 | 501 | 930 10-01-2013 | 101 | 1231 03-01-2014 | 301 | 731 08-01-2014 | 801 | 1231 01-01-2015 | 101 | 531 06-01-2015 | 601 | 1031 11-01-2015 | 101 | 1231 04-01-2016 | 401 | 831 09-01-2016 | 101 | 1231 02-01-2017 | 201 | 630 07-01-2017 | 701 | 1130 12-01-2017 | 101 | 1231 05-01-2018 | 501 | 930 10-01-2018 | 101 | 1231 03-01-2019 | 301 | 731 08-01-2019 | 801 | 1231 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_6m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('6 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_6m" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_6m ORDER BY bucket; bucket | min | max ------------+-----+------ 01-01-2010 | 101 | 630 07-01-2010 | 701 | 1231 01-01-2011 | 101 | 630 07-01-2011 | 701 | 1231 01-01-2012 | 101 | 630 07-01-2012 | 701 | 1231 01-01-2013 | 101 | 630 07-01-2013 | 701 | 1231 01-01-2014 | 101 | 630 07-01-2014 | 701 | 1231 01-01-2015 | 101 | 630 07-01-2015 | 701 | 1231 01-01-2016 | 101 | 630 07-01-2016 | 701 | 1231 01-01-2017 | 101 | 630 07-01-2017 | 701 | 1231 01-01-2018 | 101 | 630 07-01-2018 | 701 | 1231 01-01-2019 | 101 | 630 07-01-2019 | 701 | 1231 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_1y WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('1 year', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_1y" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_1y ORDER BY bucket; bucket | min | max ------------+-----+------ 01-01-2010 | 101 | 1231 01-01-2011 | 101 | 1231 01-01-2012 | 101 | 1231 01-01-2013 | 101 | 1231 01-01-2014 | 101 | 1231 01-01-2015 | 101 | 1231 01-01-2016 | 101 | 1231 01-01-2017 | 101 | 1231 01-01-2018 | 101 | 1231 01-01-2019 | 101 | 1231 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_1y1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('1 year 1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_1y1m" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_1y1m ORDER BY bucket; bucket | min | max ------------+-----+------ 10-01-2009 | 101 | 1031 11-01-2010 | 101 | 1231 12-01-2011 | 101 | 1231 01-01-2013 | 101 | 1231 02-01-2014 | 101 | 1231 03-01-2015 | 101 | 1231 04-01-2016 | 101 | 1231 05-01-2017 | 101 | 1231 06-01-2018 | 101 | 1231 07-01-2019 | 701 | 1231 -- Trigger merged refresh to check corresponding code path as well DROP MATERIALIZED VIEW conditions_large_1y; NOTICE: drop cascades to 10 other objects SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_1y WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT timescaledb_experimental.time_bucket_ng('1 year', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; NOTICE: refreshing continuous aggregate "conditions_large_1y" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_1y ORDER BY bucket; bucket | min | max ------------+-----+------ 01-01-2010 | 101 | 1231 01-01-2011 | 101 | 1231 01-01-2012 | 101 | 1231 01-01-2013 | 101 | 1231 01-01-2014 | 101 | 1231 01-01-2015 | 101 | 1231 01-01-2016 | 101 | 1231 01-01-2017 | 101 | 1231 01-01-2018 | 101 | 1231 01-01-2019 | 101 | 1231 INSERT INTO conditions_large(day, temperature) SELECT ts, date_part('month', ts)*100 + date_part('day', ts) FROM generate_series('2020-01-01' :: date, '2021-01-01' :: date - interval '1 day', '1 day') as ts; CALL refresh_continuous_aggregate('conditions_large_1y', '2020-01-01', '2021-01-01'); SELECT * FROM conditions_large_1y ORDER BY bucket; bucket | min | max ------------+-----+------ 01-01-2010 | 101 | 1231 01-01-2011 | 101 | 1231 01-01-2012 | 101 | 1231 01-01-2013 | 101 | 1231 01-01-2014 | 101 | 1231 01-01-2015 | 101 | 1231 01-01-2016 | 101 | 1231 01-01-2017 | 101 | 1231 01-01-2018 | 101 | 1231 01-01-2019 | 101 | 1231 01-01-2020 | 101 | 1231 -- Test the specific code path of creating a CAGG on top of empty hypertable. CREATE TABLE conditions_empty( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_empty', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable -------------------------------- (15,public,conditions_empty,t) SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_empty WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_empty GROUP BY city, bucket; NOTICE: continuous aggregate "conditions_summary_empty" is already up-to-date RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER by month, city; city | month | min | max ------+-------+-----+----- -- The test above changes the record that gets added to the invalidation log -- for an empty table. Make sure it doesn't have any unintended side-effects -- and the refreshing works as expected. INSERT INTO conditions_empty (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); CALL refresh_continuous_aggregate('conditions_summary_empty', '2021-06-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER by month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 -- Make sure add_continuous_aggregate_policy() works CREATE TABLE conditions_policy( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_policy', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable --------------------------------- (17,public,conditions_policy,t) INSERT INTO conditions_policy (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_policy WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_policy GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_policy" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_summary_policy; city | bucket | min | max --------+------------+-----+----- Moscow | 06-01-2021 | 22 | 34 \set ON_ERROR_STOP 0 -- Check for "policy refresh window too small" error SELECT add_continuous_aggregate_policy('conditions_summary_policy', -- Historically, 1 month is just a synonym to 30 days here. -- See interval_to_int64() and interval_to_int128(). start_offset => INTERVAL '2 months', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); ERROR: policy refresh window too small \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '65 days', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour') AS job_id \gset SELECT delete_job(:job_id); delete_job ------------ SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '2 months', end_offset => INTERVAL '0 months', schedule_interval => INTERVAL '1 hour') AS job_id \gset SELECT delete_job(:job_id); delete_job ------------ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '2 months', end_offset => INTERVAL '1 months', schedule_interval => INTERVAL '1 hour'); ERROR: policy refresh window too small \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '3 months', end_offset => INTERVAL '1 months', schedule_interval => INTERVAL '1 hour'); add_continuous_aggregate_policy --------------------------------- 1002 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/exp_cagg_next_gen.out������������������������������������������0000664�0000000�0000000�00000017772�15100345067�0023650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Make sure experimental immutable function with 2 arguments can be used in caggs. -- Functions with 3 arguments and/or stable functions are currently not supported in caggs. CREATE TABLE conditions( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ------------------------- (1,public,conditions,t) INSERT INTO conditions (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_weekly" -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT to_char(bucket, 'YYYY-MM-DD'), city, min, max FROM conditions_summary_weekly ORDER BY bucket; to_char | city | min | max ------------+--------+-----+----- 2021-06-12 | Moscow | 22 | 27 2021-06-19 | Moscow | 28 | 34 2021-06-26 | Moscow | 31 | 32 DROP TABLE conditions CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 2 other objects -- Make sure seconds, minutes, and hours can be used with caggs ('origin' is not -- currently supported in caggs). CREATE TABLE conditions( tstamp TIMESTAMP NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); WARNING: column type "timestamp without time zone" used for "tstamp" does not follow best practices create_hypertable ------------------------- (3,public,conditions,t) INSERT INTO conditions (tstamp, city, temperature) VALUES ('2021-06-14 12:30:00', 'Moscow', 26), ('2021-06-14 12:30:10', 'Moscow', 22), ('2021-06-14 12:30:20', 'Moscow', 24), ('2021-06-14 12:30:30', 'Moscow', 24), ('2021-06-14 12:30:40', 'Moscow', 27), ('2021-06-14 12:30:50', 'Moscow', 28), ('2021-06-14 12:31:10', 'Moscow', 30), ('2021-06-14 12:31:20', 'Moscow', 31), ('2021-06-14 12:31:30', 'Moscow', 34), ('2021-06-14 12:31:40', 'Moscow', 34), ('2021-06-14 12:31:50', 'Moscow', 34), ('2021-06-14 12:32:00', 'Moscow', 32), ('2021-06-14 12:32:10', 'Moscow', 32), ('2021-06-14 12:32:20', 'Moscow', 31); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_30sec WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('30 seconds', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_30sec" CREATE MATERIALIZED VIEW conditions_summary_1min WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 minute', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_1min" CREATE MATERIALIZED VIEW conditions_summary_1hour WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 hour', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_1hour" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD HH:mi:ss'), min, max FROM conditions_summary_30sec ORDER BY bucket; city | to_char | min | max --------+---------------------+-----+----- Moscow | 2021-06-14 12:30:00 | 22 | 26 Moscow | 2021-06-14 12:30:30 | 24 | 28 Moscow | 2021-06-14 12:31:00 | 30 | 31 Moscow | 2021-06-14 12:31:30 | 34 | 34 Moscow | 2021-06-14 12:32:00 | 31 | 32 SELECT city, to_char(bucket, 'YYYY-MM-DD HH:mi:ss'), min, max FROM conditions_summary_1min ORDER BY bucket; city | to_char | min | max --------+---------------------+-----+----- Moscow | 2021-06-14 12:30:00 | 22 | 28 Moscow | 2021-06-14 12:31:00 | 30 | 34 Moscow | 2021-06-14 12:32:00 | 31 | 32 SELECT city, to_char(bucket, 'YYYY-MM-DD HH:mi:ss'), min, max FROM conditions_summary_1hour ORDER BY bucket; city | to_char | min | max --------+---------------------+-----+----- Moscow | 2021-06-14 12:00:00 | 22 | 34 DROP TABLE conditions CASCADE; NOTICE: drop cascades to 9 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_4_18_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_5_19_chunk NOTICE: drop cascades to table _timescaledb_internal._hyper_6_20_chunk -- Experimental functions using different schema for installation than PUBLIC \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE SCHEMA test1; SET client_min_messages TO ERROR; CREATE EXTENSION timescaledb SCHEMA test1; CREATE TABLE conditions( tstamp TIMESTAMP NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT test1.create_hypertable( 'conditions', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ------------------------- (1,public,conditions,t) SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_monthly WITH (timescaledb.continuous) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; CREATE MATERIALIZED VIEW conditions_summary_yearly WITH (timescaledb.continuous) AS SELECT city, test1.time_bucket('1 year', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function ORDER BY 1; bucket_func | bucket_width | bucket_origin | bucket_timezone | bucket_fixed_width -------------------------------------------------------------------------------+--------------+---------------+-----------------+-------------------- test1.time_bucket(interval,timestamp without time zone) | @ 1 year | | | f timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone) | @ 1 mon | | | f -- Try to toggle realtime feature on existing CAgg using timescaledb_experimental.time_bucket_ng ALTER MATERIALIZED VIEW conditions_summary_monthly SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW conditions_summary_monthly SET (timescaledb.materialized_only=true); \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE :TEST_DBNAME_2 WITH (FORCE); ������timescaledb-2.23.0/tsl/test/expected/exp_cagg_origin.out��������������������������������������������0000664�0000000�0000000�00000111436�15100345067�0023320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ------------------------- (1,public,conditions,t) INSERT INTO conditions (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); \set ON_ERROR_STOP 0 -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; -- Make sure 'infinity' can't be specified as an origin CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, 'infinity' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: invalid origin value: infinity -- Make sure buckets like '1 months 15 days" (fixed+variable-sized) are not allowed CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', day, '2021-06-01') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: invalid interval specified \set ON_ERROR_STOP 1 CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, '2000-01-03' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT to_char(bucket, 'YYYY-MM-DD'), city, min, max FROM conditions_summary_weekly ORDER BY bucket; to_char | city | min | max ---------+------+-----+----- SELECT mat_hypertable_id AS cagg_id, raw_hypertable_id AS ht_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_weekly' \gset -- Make sure truncating of the refresh window works \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('conditions_summary_weekly', '2021-06-14', '2021-06-20'); ERROR: refresh window too small \set ON_ERROR_STOP 1 -- Make sure refreshing works CALL refresh_continuous_aggregate('conditions_summary_weekly', '2021-06-14', '2021-06-21'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS week, min, max FROM conditions_summary_weekly ORDER BY week, city; city | week | min | max --------+------------+-----+----- Moscow | 2021-06-14 | 22 | 30 -- Check the invalidation threshold SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone -------------------------- Mon Jun 21 00:00:00 2021 -- Add some dummy data for two more weeks and call refresh (no invalidations test case) INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-06-28' :: date, '2021-07-11', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; -- Double check generated data SELECT to_char(day, 'YYYY-MM-DD'), city, temperature FROM conditions WHERE day >= '2021-06-28' ORDER BY city DESC, day; to_char | city | temperature ------------+--------+------------- 2021-06-28 | Moscow | 1 2021-06-29 | Moscow | 2 2021-06-30 | Moscow | 3 2021-07-01 | Moscow | 4 2021-07-02 | Moscow | 5 2021-07-03 | Moscow | 6 2021-07-04 | Moscow | 7 2021-07-05 | Moscow | 8 2021-07-06 | Moscow | 9 2021-07-07 | Moscow | 10 2021-07-08 | Moscow | 11 2021-07-09 | Moscow | 12 2021-07-10 | Moscow | 13 2021-07-11 | Moscow | 14 2021-06-28 | Berlin | 15 2021-06-29 | Berlin | 16 2021-06-30 | Berlin | 17 2021-07-01 | Berlin | 18 2021-07-02 | Berlin | 19 2021-07-03 | Berlin | 20 2021-07-04 | Berlin | 21 2021-07-05 | Berlin | 22 2021-07-06 | Berlin | 23 2021-07-07 | Berlin | 24 2021-07-08 | Berlin | 25 2021-07-09 | Berlin | 26 2021-07-10 | Berlin | 27 2021-07-11 | Berlin | 28 -- Make sure the invalidation threshold was unaffected SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone -------------------------- Mon Jun 21 00:00:00 2021 -- Make sure the invalidation log is empty SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Call refresh CALL refresh_continuous_aggregate('conditions_summary_weekly', '2021-06-28', '2021-07-12'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS week, min, max FROM conditions_summary_weekly ORDER BY week, city; city | week | min | max --------+------------+-----+----- Moscow | 2021-06-14 | 22 | 30 Berlin | 2021-06-28 | 15 | 21 Moscow | 2021-06-28 | 1 | 7 Berlin | 2021-07-05 | 22 | 28 Moscow | 2021-07-05 | 8 | 14 -- Make sure the invalidation threshold has changed SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone -------------------------- Mon Jul 12 00:00:00 2021 -- Check if CREATE MATERIALIZED VIEW ... WITH DATA works. -- Use monthly buckets this time and specify June 2000 as an origin. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_monthly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2000-06-01' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_monthly" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_monthly ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 -- Check the invalidation. -- Step 1/2. Insert some more data , do a refresh and make sure that the -- invalidation log is empty. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-09-01' :: date, '2021-09-15', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; CALL refresh_continuous_aggregate('conditions_summary_monthly', '2021-09-01', '2021-10-01'); SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_monthly ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 30 Moscow | 2021-09-01 | 1 | 15 -- Step 2/2. Add more data below the invalidation threshold, make sure that the -- invalidation log is not empty, then do a refresh. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, (CASE WHEN city = 'Moscow' THEN -40 ELSE 40 END) FROM generate_series('2021-09-16' :: date, '2021-09-30', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'UTC' AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'UTC' AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------------------------+-------------------------- Thu Sep 16 00:00:00 2021 | Thu Sep 30 00:00:00 2021 CALL refresh_continuous_aggregate('conditions_summary_monthly', '2021-09-01', '2021-10-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_monthly ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Create a real-time aggregate with custom origin - June 2000 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2000-06-01' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_rt" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 -- Add some data to the hypertable and make sure it is visible in the cagg INSERT INTO conditions (day, city, temperature) VALUES ('2021-10-01', 'Moscow', 1), ('2021-10-02', 'Moscow', 2), ('2021-10-03', 'Moscow', 3), ('2021-10-04', 'Moscow', 4), ('2021-10-01', 'Berlin', 5), ('2021-10-02', 'Berlin', 6), ('2021-10-03', 'Berlin', 7), ('2021-10-04', 'Berlin', 8); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_rt', '2021-10-01', '2021-11-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions (day, city, temperature) VALUES ('2021-11-01', 'Moscow', 11), ('2021-11-02', 'Moscow', 12), ('2021-11-03', 'Moscow', 13), ('2021-11-04', 'Moscow', 14), ('2021-11-01', 'Berlin', 15), ('2021-11-02', 'Berlin', 16), ('2021-11-03', 'Berlin', 17), ('2021-11-04', 'Berlin', 18); ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions') AS ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_9_chunk _timescaledb_internal._hyper_1_10_chunk _timescaledb_internal._hyper_1_11_chunk _timescaledb_internal._hyper_1_12_chunk _timescaledb_internal._hyper_1_13_chunk _timescaledb_internal._hyper_1_14_chunk _timescaledb_internal._hyper_1_16_chunk _timescaledb_internal._hyper_1_17_chunk _timescaledb_internal._hyper_1_18_chunk _timescaledb_internal._hyper_1_19_chunk _timescaledb_internal._hyper_1_20_chunk _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_22_chunk _timescaledb_internal._hyper_1_23_chunk _timescaledb_internal._hyper_1_24_chunk _timescaledb_internal._hyper_1_25_chunk _timescaledb_internal._hyper_1_26_chunk _timescaledb_internal._hyper_1_27_chunk _timescaledb_internal._hyper_1_28_chunk _timescaledb_internal._hyper_1_29_chunk _timescaledb_internal._hyper_1_34_chunk _timescaledb_internal._hyper_1_35_chunk _timescaledb_internal._hyper_1_36_chunk _timescaledb_internal._hyper_1_37_chunk _timescaledb_internal._hyper_1_38_chunk _timescaledb_internal._hyper_1_39_chunk _timescaledb_internal._hyper_1_40_chunk _timescaledb_internal._hyper_1_41_chunk _timescaledb_internal._hyper_1_42_chunk _timescaledb_internal._hyper_1_43_chunk _timescaledb_internal._hyper_1_44_chunk _timescaledb_internal._hyper_1_45_chunk _timescaledb_internal._hyper_1_46_chunk _timescaledb_internal._hyper_1_47_chunk _timescaledb_internal._hyper_1_48_chunk _timescaledb_internal._hyper_1_50_chunk _timescaledb_internal._hyper_1_51_chunk _timescaledb_internal._hyper_1_52_chunk _timescaledb_internal._hyper_1_53_chunk _timescaledb_internal._hyper_1_54_chunk _timescaledb_internal._hyper_1_55_chunk _timescaledb_internal._hyper_1_56_chunk _timescaledb_internal._hyper_1_57_chunk _timescaledb_internal._hyper_1_58_chunk _timescaledb_internal._hyper_1_59_chunk _timescaledb_internal._hyper_1_60_chunk _timescaledb_internal._hyper_1_61_chunk _timescaledb_internal._hyper_1_62_chunk _timescaledb_internal._hyper_1_63_chunk _timescaledb_internal._hyper_1_64_chunk _timescaledb_internal._hyper_1_68_chunk _timescaledb_internal._hyper_1_69_chunk _timescaledb_internal._hyper_1_70_chunk _timescaledb_internal._hyper_1_71_chunk _timescaledb_internal._hyper_1_73_chunk _timescaledb_internal._hyper_1_74_chunk _timescaledb_internal._hyper_1_75_chunk _timescaledb_internal._hyper_1_76_chunk -- Data for 2021-11 is seen because the cagg is real-time SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 Berlin | 2021-11-01 | 15 | 18 Moscow | 2021-11-01 | 11 | 14 CALL refresh_continuous_aggregate('conditions_summary_rt', '2021-11-01', '2021-12-01'); -- Data for 2021-11 is seen because the cagg was refreshed SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; city | month | min | max --------+------------+-----+----- Berlin | 2021-06-01 | 15 | 17 Moscow | 2021-06-01 | 1 | 34 Berlin | 2021-07-01 | 18 | 28 Moscow | 2021-07-01 | 4 | 14 Berlin | 2021-09-01 | 16 | 40 Moscow | 2021-09-01 | -40 | 15 Berlin | 2021-10-01 | 5 | 8 Moscow | 2021-10-01 | 1 | 4 Berlin | 2021-11-01 | 15 | 18 Moscow | 2021-11-01 | 11 | 14 -- Clean up DROP TABLE conditions CASCADE; NOTICE: drop cascades to 7 other objects NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to 5 other objects -- Test the specific code path of creating a CAGG on top of empty hypertable. CREATE TABLE conditions_empty( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_empty', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ------------------------------- (6,public,conditions_empty,t) SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_empty WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2005-02-01') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_empty GROUP BY city, bucket; NOTICE: continuous aggregate "conditions_summary_empty" is already up-to-date RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER BY month, city; city | month | min | max ------+-------+-----+----- -- The test above changes the record that gets added to the invalidation log -- for an empty table. Make sure it doesn't have any unintended side-effects -- and the refreshing works as expected. INSERT INTO conditions_empty (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); CALL refresh_continuous_aggregate('conditions_summary_empty', '2021-06-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER BY month, city; city | month | min | max --------+------------+-----+----- Moscow | 2021-06-01 | 22 | 34 -- Clean up DROP TABLE conditions_empty CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_7_158_chunk -- Make sure add_continuous_aggregate_policy() works CREATE TABLE conditions_policy( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_policy', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable -------------------------------- (8,public,conditions_policy,t) INSERT INTO conditions_policy (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_policy WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2005-03-01') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_policy GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_policy" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_summary_policy; city | bucket | min | max --------+------------+-----+----- Moscow | 06-01-2021 | 22 | 34 \set ON_ERROR_STOP 0 -- Check for "policy refresh window too small" error SELECT add_continuous_aggregate_policy('conditions_summary_policy', -- Historically, 1 month is just a synonym to 30 days here. -- See interval_to_int64() and interval_to_int128(). start_offset => INTERVAL '2 months', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); ERROR: policy refresh window too small \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '65 days', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); add_continuous_aggregate_policy --------------------------------- 1000 -- Clean up DROP TABLE conditions_policy CASCADE; NOTICE: drop cascades to 2 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_9_173_chunk -- Make sure CAGGs with custom origin work for timestamp type CREATE TABLE conditions_timestamp( tstamp TIMESTAMP NOT NULL, city TEXT NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_timestamp', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); WARNING: column type "timestamp without time zone" used for "tstamp" does not follow best practices create_hypertable ------------------------------------ (10,public,conditions_timestamp,t) SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('12 hours', tstamp, '2000-06-01 12:00:00') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamp GROUP BY city, bucket; NOTICE: continuous aggregate "conditions_summary_timestamp" is already up-to-date RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; city | b | min | max ------+---+-----+----- -- Add some data to the hypertable and make sure it is visible in the cagg INSERT INTO conditions_timestamp(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts)*100 + date_part('hour', ts) FROM generate_series('2010-01-01 00:00:00' :: timestamp, '2010-01-02 00:00:00' :: timestamp - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2010-01-01 00:00:00 | 10100 | 10111 Moscow | 2010-01-01 00:00:00 | 20100 | 20111 Berlin | 2010-01-01 12:00:00 | 10112 | 10123 Moscow | 2010-01-01 12:00:00 | 20112 | 20123 -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_timestamp', '2010-01-01 00:00:00', '2010-01-02 00:00:00'); SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2010-01-01 00:00:00 | 10100 | 10111 Moscow | 2010-01-01 00:00:00 | 20100 | 20111 Berlin | 2010-01-01 12:00:00 | 10112 | 10123 Moscow | 2010-01-01 12:00:00 | 20112 | 20123 -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions_timestamp(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts)*100 + date_part('hour', ts) FROM generate_series('2010-01-02 00:00:00' :: timestamp, '2010-01-03 00:00:00' :: timestamp - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; ALTER TABLE conditions_timestamp SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions_timestamp') AS ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_10_174_chunk _timescaledb_internal._hyper_10_176_chunk -- New data is seen because the cagg is real-time SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2010-01-01 00:00:00 | 10100 | 10111 Moscow | 2010-01-01 00:00:00 | 20100 | 20111 Berlin | 2010-01-01 12:00:00 | 10112 | 10123 Moscow | 2010-01-01 12:00:00 | 20112 | 20123 Berlin | 2010-01-02 00:00:00 | 10200 | 10211 Moscow | 2010-01-02 00:00:00 | 20200 | 20211 Berlin | 2010-01-02 12:00:00 | 10212 | 10223 Moscow | 2010-01-02 12:00:00 | 20212 | 20223 CALL refresh_continuous_aggregate('conditions_summary_timestamp', '2010-01-02 00:00:00', '2010-01-03 00:00:00'); -- New data is seen because the cagg was refreshed SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2010-01-01 00:00:00 | 10100 | 10111 Moscow | 2010-01-01 00:00:00 | 20100 | 20111 Berlin | 2010-01-01 12:00:00 | 10112 | 10123 Moscow | 2010-01-01 12:00:00 | 20112 | 20123 Berlin | 2010-01-02 00:00:00 | 10200 | 10211 Moscow | 2010-01-02 00:00:00 | 20200 | 20211 Berlin | 2010-01-02 12:00:00 | 10212 | 10223 Moscow | 2010-01-02 12:00:00 | 20212 | 20223 -- Add a refresh policy SELECT add_continuous_aggregate_policy('conditions_summary_timestamp', start_offset => INTERVAL '25 hours', end_offset => INTERVAL '1 hour', schedule_interval => INTERVAL '30 minutes'); add_continuous_aggregate_policy --------------------------------- 1001 -- Clean up DROP TABLE conditions_timestamp CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_11_175_chunk -- Make sure CAGGs with custom origin work for timestamptz type CREATE TABLE conditions_timestamptz( tstamp TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_timestamptz', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); create_hypertable -------------------------------------- (13,public,conditions_timestamptz,t) -- Add some data to the hypertable and make sure it is visible in the cagg INSERT INTO conditions_timestamptz(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts at time zone 'MSK')*100 + date_part('hour', ts at time zone 'MSK') FROM generate_series('2022-01-01 00:00:00 MSK' :: timestamptz, '2022-01-02 00:00:00 MSK' :: timestamptz - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; \set ON_ERROR_STOP 0 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; -- For monthly buckets origin should be the first day of the month in given timezone -- 2020-06-02 00:00:00 MSK == 2020-06-01 21:00:00 UTC CREATE MATERIALIZED VIEW conditions_summary_timestamptz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', tstamp, '2020-06-02 00:00:00 MSK', 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamptz GROUP BY city, bucket; ERROR: origin must be the first day of the month -- Make sure buckets like '1 months 15 days" (fixed+variable-sized) are not allowed CREATE MATERIALIZED VIEW conditions_summary_timestamptz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', tstamp, '2020-06-01 00:00:00 MSK', 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamptz GROUP BY city, bucket; ERROR: invalid interval specified \set ON_ERROR_STOP 1 CREATE MATERIALIZED VIEW conditions_summary_timestamptz WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('12 hours', tstamp, '2020-06-01 12:00:00 MSK', 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamptz GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_timestamptz" RESET timescaledb.debug_allow_cagg_with_deprecated_func; -- Make sure the origin is saved in the catalog table SELECT mat_hypertable_id AS cagg_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_timestamptz' \gset SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id; bucket_func | bucket_width | bucket_origin | bucket_timezone | bucket_fixed_width ---------------------------------------------------------------------------------------------------------------------+--------------+------------------------------+-----------------+-------------------- timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone,pg_catalog.text) | @ 12 hours | Mon Jun 01 02:00:00 2020 PDT | Europe/Moscow | f SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2022-01-01 00:00:00 | 10100 | 10111 Moscow | 2022-01-01 00:00:00 | 20100 | 20111 Berlin | 2022-01-01 12:00:00 | 10112 | 10123 Moscow | 2022-01-01 12:00:00 | 20112 | 20123 -- Check the data SELECT to_char(tstamp at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS ts, city, temperature FROM conditions_timestamptz ORDER BY ts, city; ts | city | temperature ---------------------+--------+------------- 2022-01-01 00:00:00 | Berlin | 10100 2022-01-01 00:00:00 | Moscow | 20100 2022-01-01 01:00:00 | Berlin | 10101 2022-01-01 01:00:00 | Moscow | 20101 2022-01-01 02:00:00 | Berlin | 10102 2022-01-01 02:00:00 | Moscow | 20102 2022-01-01 03:00:00 | Berlin | 10103 2022-01-01 03:00:00 | Moscow | 20103 2022-01-01 04:00:00 | Berlin | 10104 2022-01-01 04:00:00 | Moscow | 20104 2022-01-01 05:00:00 | Berlin | 10105 2022-01-01 05:00:00 | Moscow | 20105 2022-01-01 06:00:00 | Berlin | 10106 2022-01-01 06:00:00 | Moscow | 20106 2022-01-01 07:00:00 | Berlin | 10107 2022-01-01 07:00:00 | Moscow | 20107 2022-01-01 08:00:00 | Berlin | 10108 2022-01-01 08:00:00 | Moscow | 20108 2022-01-01 09:00:00 | Berlin | 10109 2022-01-01 09:00:00 | Moscow | 20109 2022-01-01 10:00:00 | Berlin | 10110 2022-01-01 10:00:00 | Moscow | 20110 2022-01-01 11:00:00 | Berlin | 10111 2022-01-01 11:00:00 | Moscow | 20111 2022-01-01 12:00:00 | Berlin | 10112 2022-01-01 12:00:00 | Moscow | 20112 2022-01-01 13:00:00 | Berlin | 10113 2022-01-01 13:00:00 | Moscow | 20113 2022-01-01 14:00:00 | Berlin | 10114 2022-01-01 14:00:00 | Moscow | 20114 2022-01-01 15:00:00 | Berlin | 10115 2022-01-01 15:00:00 | Moscow | 20115 2022-01-01 16:00:00 | Berlin | 10116 2022-01-01 16:00:00 | Moscow | 20116 2022-01-01 17:00:00 | Berlin | 10117 2022-01-01 17:00:00 | Moscow | 20117 2022-01-01 18:00:00 | Berlin | 10118 2022-01-01 18:00:00 | Moscow | 20118 2022-01-01 19:00:00 | Berlin | 10119 2022-01-01 19:00:00 | Moscow | 20119 2022-01-01 20:00:00 | Berlin | 10120 2022-01-01 20:00:00 | Moscow | 20120 2022-01-01 21:00:00 | Berlin | 10121 2022-01-01 21:00:00 | Moscow | 20121 2022-01-01 22:00:00 | Berlin | 10122 2022-01-01 22:00:00 | Moscow | 20122 2022-01-01 23:00:00 | Berlin | 10123 2022-01-01 23:00:00 | Moscow | 20123 SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2022-01-01 00:00:00 | 10100 | 10111 Moscow | 2022-01-01 00:00:00 | 20100 | 20111 Berlin | 2022-01-01 12:00:00 | 10112 | 10123 Moscow | 2022-01-01 12:00:00 | 20112 | 20123 -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_timestamptz', '2022-01-01 00:00:00 MSK', '2022-01-02 00:00:00 MSK'); NOTICE: continuous aggregate "conditions_summary_timestamptz" is already up-to-date SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2022-01-01 00:00:00 | 10100 | 10111 Moscow | 2022-01-01 00:00:00 | 20100 | 20111 Berlin | 2022-01-01 12:00:00 | 10112 | 10123 Moscow | 2022-01-01 12:00:00 | 20112 | 20123 -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions_timestamptz(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts at time zone 'MSK')*100 + date_part('hour', ts at time zone 'MSK') FROM generate_series('2022-01-02 00:00:00 MSK' :: timestamptz, '2022-01-03 00:00:00 MSK' :: timestamptz - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; ALTER TABLE conditions_timestamptz SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions_timestamptz') AS ch; compress_chunk ------------------------------------------- _timescaledb_internal._hyper_13_179_chunk _timescaledb_internal._hyper_13_180_chunk _timescaledb_internal._hyper_13_182_chunk -- New data is seen because the cagg is real-time SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2022-01-01 00:00:00 | 10100 | 10111 Moscow | 2022-01-01 00:00:00 | 20100 | 20111 Berlin | 2022-01-01 12:00:00 | 10112 | 10123 Moscow | 2022-01-01 12:00:00 | 20112 | 20123 Berlin | 2022-01-02 00:00:00 | 10200 | 10211 Moscow | 2022-01-02 00:00:00 | 20200 | 20211 Berlin | 2022-01-02 12:00:00 | 10212 | 10223 Moscow | 2022-01-02 12:00:00 | 20212 | 20223 CALL refresh_continuous_aggregate('conditions_summary_timestamptz', '2022-01-02 00:00:00 MSK', '2022-01-03 00:00:00 MSK'); -- New data is seen because the cagg was refreshed SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; city | b | min | max --------+---------------------+-------+------- Berlin | 2022-01-01 00:00:00 | 10100 | 10111 Moscow | 2022-01-01 00:00:00 | 20100 | 20111 Berlin | 2022-01-01 12:00:00 | 10112 | 10123 Moscow | 2022-01-01 12:00:00 | 20112 | 20123 Berlin | 2022-01-02 00:00:00 | 10200 | 10211 Moscow | 2022-01-02 00:00:00 | 20200 | 20211 Berlin | 2022-01-02 12:00:00 | 10212 | 10223 Moscow | 2022-01-02 12:00:00 | 20212 | 20223 -- Add a refresh policy SELECT add_continuous_aggregate_policy('conditions_summary_timestamptz', start_offset => INTERVAL '25 hours', end_offset => INTERVAL '1 hour', schedule_interval => INTERVAL '30 minutes'); add_continuous_aggregate_policy --------------------------------- 1002 -- Clean up DROP TABLE conditions_timestamptz CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_15_181_chunk ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/exp_cagg_timezone.out������������������������������������������0000664�0000000�0000000�00000072403�15100345067�0023663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Make sure that timezone can't be used for types other that timestamptz CREATE TABLE conditions( day timestamp NOT NULL, -- not timestamptz! city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); WARNING: column type "timestamp without time zone" used for "day" does not follow best practices create_hypertable ------------------------- (1,public,conditions,t) \set ON_ERROR_STOP 0 -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; ERROR: invalid input syntax for type timestamp: "Europe/Moscow" at character 178 -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; \set ON_ERROR_STOP 1 DROP TABLE conditions CASCADE; CREATE TABLE conditions_tz( day timestamptz NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_tz', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable ---------------------------- (2,public,conditions_tz,t) INSERT INTO conditions_tz (day, city, temperature) VALUES ('2021-06-14 00:00:00 MSK', 'Moscow', 26), ('2021-06-15 00:00:00 MSK', 'Moscow', 22), ('2021-06-16 00:00:00 MSK', 'Moscow', 24), ('2021-06-17 00:00:00 MSK', 'Moscow', 24), ('2021-06-18 00:00:00 MSK', 'Moscow', 27), ('2021-06-19 00:00:00 MSK', 'Moscow', 28), ('2021-06-20 00:00:00 MSK', 'Moscow', 30), ('2021-06-21 00:00:00 MSK', 'Moscow', 31), ('2021-06-22 00:00:00 MSK', 'Moscow', 34), ('2021-06-23 00:00:00 MSK', 'Moscow', 34), ('2021-06-24 00:00:00 MSK', 'Moscow', 34), ('2021-06-25 00:00:00 MSK', 'Moscow', 32), ('2021-06-26 00:00:00 MSK', 'Moscow', 32), ('2021-06-27 00:00:00 MSK', 'Moscow', 31); \set ON_ERROR_STOP 0 -- Check that the name of the timezone is validated SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'Europe/Ololondon') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; ERROR: invalid timezone name "Europe/Ololondon" -- Check that buckets like '1 month 15 days' (fixed-sized + variable-sized) are not allowed CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; ERROR: invalid interval specified -- Check that only immutable expressions can be used as a timezone CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 day', day, city) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; ERROR: only immutable expressions allowed in time bucket function \set ON_ERROR_STOP 1 -- Make sure it's possible to create an empty cagg (WITH NO DATA) and -- that all the information about the bucketing function will be saved -- to the TS catalog. CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT mat_hypertable_id AS cagg_id_tz, raw_hypertable_id AS ht_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_tz' \gset -- Make sure the timezone is saved in the catalog table SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id_tz; bucket_func | bucket_width | bucket_origin | bucket_timezone | bucket_fixed_width --------------------------------------------------------------------------------------------+--------------+---------------+-----------------+-------------------- timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 1 mon | | MSK | f -- Make sure that buckets with specified timezone are always treated as -- variable-sized, even if the interval is fixed (i.e. days and/or hours) SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_1w WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT mat_hypertable_id AS cagg_id_1w FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_1w' \gset -- Make sure the timezone is saved in the catalog table SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id_1w; bucket_func | bucket_width | bucket_origin | bucket_timezone | bucket_fixed_width --------------------------------------------------------------------------------------------+--------------+---------------+-----------------+-------------------- timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,pg_catalog.text) | @ 7 days | | MSK | f -- Check the invalidation threshold is -infinity SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'MSK' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; timezone ----------- -infinity -- Make sure the invalidation log is empty SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Make sure truncating of the refresh window works \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-07-02 MSK', '2021-07-12 MSK'); ERROR: refresh window too small CALL refresh_continuous_aggregate('conditions_summary_1w', '2021-07-02 MSK', '2021-07-05 MSK'); ERROR: refresh window too small \set ON_ERROR_STOP 1 -- Make sure refreshing works CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-06-01 MSK', '2021-07-01 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 -- Check the invalidation threshold SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; to_char --------------------- 2021-07-01 00:00:00 -- The default origin is Saturday. Here we do refresh only for two full weeks -- in June in order to keep the invalidation threshold as it is. CALL refresh_continuous_aggregate('conditions_summary_1w', '2021-06-12 MSK', '2021-06-26 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as week, min, max FROM conditions_summary_1w ORDER by week, city; city | week | min | max --------+---------------------+-----+----- Moscow | 2021-06-12 00:00:00 | 22 | 27 Moscow | 2021-06-19 00:00:00 | 28 | 34 -- Check the invalidation threshold SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; to_char --------------------- 2021-07-01 00:00:00 -- Make sure creating CAGGs without NO DATA works the same way SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_tz2" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz2 ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 -- Add some dummy data for two more months (no invalidations test case) INSERT INTO conditions_tz (day, city, temperature) SELECT ts, city, row_number() OVER () FROM generate_series('2021-07-01 MSK' :: timestamptz, '2021-08-31 MSK', '3 day') as ts, unnest(array['Moscow', 'Berlin']) as city; -- Double check the generated data SELECT to_char(day at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS'), city, temperature FROM conditions_tz WHERE day >= '2021-07-01 MSK' ORDER BY city DESC, day; to_char | city | temperature ---------------------+--------+------------- 2021-07-01 00:00:00 | Moscow | 1 2021-07-04 00:00:00 | Moscow | 2 2021-07-07 00:00:00 | Moscow | 3 2021-07-10 00:00:00 | Moscow | 4 2021-07-13 00:00:00 | Moscow | 5 2021-07-16 00:00:00 | Moscow | 6 2021-07-19 00:00:00 | Moscow | 7 2021-07-22 00:00:00 | Moscow | 8 2021-07-25 00:00:00 | Moscow | 9 2021-07-28 00:00:00 | Moscow | 10 2021-07-31 00:00:00 | Moscow | 11 2021-08-03 00:00:00 | Moscow | 12 2021-08-06 00:00:00 | Moscow | 13 2021-08-09 00:00:00 | Moscow | 14 2021-08-12 00:00:00 | Moscow | 15 2021-08-15 00:00:00 | Moscow | 16 2021-08-18 00:00:00 | Moscow | 17 2021-08-21 00:00:00 | Moscow | 18 2021-08-24 00:00:00 | Moscow | 19 2021-08-27 00:00:00 | Moscow | 20 2021-08-30 00:00:00 | Moscow | 21 2021-07-01 00:00:00 | Berlin | 22 2021-07-04 00:00:00 | Berlin | 23 2021-07-07 00:00:00 | Berlin | 24 2021-07-10 00:00:00 | Berlin | 25 2021-07-13 00:00:00 | Berlin | 26 2021-07-16 00:00:00 | Berlin | 27 2021-07-19 00:00:00 | Berlin | 28 2021-07-22 00:00:00 | Berlin | 29 2021-07-25 00:00:00 | Berlin | 30 2021-07-28 00:00:00 | Berlin | 31 2021-07-31 00:00:00 | Berlin | 32 2021-08-03 00:00:00 | Berlin | 33 2021-08-06 00:00:00 | Berlin | 34 2021-08-09 00:00:00 | Berlin | 35 2021-08-12 00:00:00 | Berlin | 36 2021-08-15 00:00:00 | Berlin | 37 2021-08-18 00:00:00 | Berlin | 38 2021-08-21 00:00:00 | Berlin | 39 2021-08-24 00:00:00 | Berlin | 40 2021-08-27 00:00:00 | Berlin | 41 2021-08-30 00:00:00 | Berlin | 42 -- Make sure the invalidation threshold was unaffected SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; to_char --------------------- 2021-07-01 00:00:00 -- Make sure the invalidation log is still empty SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Call refresh for two full buckets: 2021-07-01 and 2021-08-01 CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-06-15 MSK', '2021-09-15 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 42 Moscow | 2021-08-01 00:00:00 | 12 | 21 -- Make sure the invalidation threshold has changed SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; to_char --------------------- 2021-09-01 00:00:00 -- Make sure the invalidation log is still empty SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Add more data below the invalidation threshold, make sure that the -- invalidation log is not empty, then do a refresh. INSERT INTO conditions_tz (day, city, temperature) SELECT ts :: timestamptz, city, (CASE WHEN city = 'Moscow' THEN -100 ELSE 100 END) FROM generate_series('2021-08-16 MSK' :: timestamptz, '2021-08-30 MSK', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest ---------------------+--------------------- 2021-08-16 00:00:00 | 2021-08-30 00:00:00 CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-08-01 MSK', '2021-09-01 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+------+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 100 Moscow | 2021-08-01 00:00:00 | -100 | 21 SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; lowest | greatest --------+---------- -- Clean up DROP MATERIALIZED VIEW conditions_summary_tz; NOTICE: drop cascades to 3 other objects DROP MATERIALIZED VIEW conditions_summary_1w; NOTICE: drop cascades to 2 other objects -- Create a real-time aggregate SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_tz" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+------+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 100 Moscow | 2021-08-01 00:00:00 | -100 | 21 -- Add some data to the hypertable and make sure they are visible in the cagg INSERT INTO conditions_tz (day, city, temperature) VALUES ('2021-10-01 00:00:00 MSK', 'Moscow', 1), ('2021-10-02 00:00:00 MSK', 'Moscow', 2), ('2021-10-03 00:00:00 MSK', 'Moscow', 3), ('2021-10-04 00:00:00 MSK', 'Moscow', 4), ('2021-10-01 00:00:00 MSK', 'Berlin', 5), ('2021-10-02 00:00:00 MSK', 'Berlin', 6), ('2021-10-03 00:00:00 MSK', 'Berlin', 7), ('2021-10-04 00:00:00 MSK', 'Berlin', 8); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+------+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 100 Moscow | 2021-08-01 00:00:00 | -100 | 21 Berlin | 2021-10-01 00:00:00 | 5 | 8 Moscow | 2021-10-01 00:00:00 | 1 | 4 -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-10-01 00:00:00 MSK', '2021-11-01 00:00:00 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+------+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 100 Moscow | 2021-08-01 00:00:00 | -100 | 21 Berlin | 2021-10-01 00:00:00 | 5 | 8 Moscow | 2021-10-01 00:00:00 | 1 | 4 -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions_tz (day, city, temperature) VALUES ('2021-11-01 00:00:00 MSK', 'Moscow', 11), ('2021-11-02 00:00:00 MSK', 'Moscow', 12), ('2021-11-03 00:00:00 MSK', 'Moscow', 13), ('2021-11-04 00:00:00 MSK', 'Moscow', 14), ('2021-11-01 00:00:00 MSK', 'Berlin', 15), ('2021-11-02 00:00:00 MSK', 'Berlin', 16), ('2021-11-03 00:00:00 MSK', 'Berlin', 17), ('2021-11-04 00:00:00 MSK', 'Berlin', 18); ALTER TABLE conditions_tz SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions_tz') AS ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_1_chunk _timescaledb_internal._hyper_2_2_chunk _timescaledb_internal._hyper_2_3_chunk _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_7_chunk _timescaledb_internal._hyper_2_8_chunk _timescaledb_internal._hyper_2_9_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk _timescaledb_internal._hyper_2_12_chunk _timescaledb_internal._hyper_2_13_chunk _timescaledb_internal._hyper_2_14_chunk _timescaledb_internal._hyper_2_19_chunk _timescaledb_internal._hyper_2_20_chunk _timescaledb_internal._hyper_2_21_chunk _timescaledb_internal._hyper_2_22_chunk _timescaledb_internal._hyper_2_23_chunk _timescaledb_internal._hyper_2_24_chunk _timescaledb_internal._hyper_2_25_chunk _timescaledb_internal._hyper_2_26_chunk _timescaledb_internal._hyper_2_27_chunk _timescaledb_internal._hyper_2_28_chunk _timescaledb_internal._hyper_2_29_chunk _timescaledb_internal._hyper_2_30_chunk _timescaledb_internal._hyper_2_31_chunk _timescaledb_internal._hyper_2_32_chunk _timescaledb_internal._hyper_2_33_chunk _timescaledb_internal._hyper_2_34_chunk _timescaledb_internal._hyper_2_35_chunk _timescaledb_internal._hyper_2_36_chunk _timescaledb_internal._hyper_2_37_chunk _timescaledb_internal._hyper_2_38_chunk _timescaledb_internal._hyper_2_39_chunk _timescaledb_internal._hyper_2_42_chunk _timescaledb_internal._hyper_2_43_chunk _timescaledb_internal._hyper_2_44_chunk _timescaledb_internal._hyper_2_45_chunk _timescaledb_internal._hyper_2_46_chunk _timescaledb_internal._hyper_2_47_chunk _timescaledb_internal._hyper_2_48_chunk _timescaledb_internal._hyper_2_49_chunk _timescaledb_internal._hyper_2_50_chunk _timescaledb_internal._hyper_2_51_chunk _timescaledb_internal._hyper_2_55_chunk _timescaledb_internal._hyper_2_56_chunk _timescaledb_internal._hyper_2_57_chunk _timescaledb_internal._hyper_2_58_chunk _timescaledb_internal._hyper_2_60_chunk _timescaledb_internal._hyper_2_61_chunk _timescaledb_internal._hyper_2_62_chunk _timescaledb_internal._hyper_2_63_chunk -- Data for 2021-11 is seen because the cagg is real-time SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+------+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 100 Moscow | 2021-08-01 00:00:00 | -100 | 21 Berlin | 2021-10-01 00:00:00 | 5 | 8 Moscow | 2021-10-01 00:00:00 | 1 | 4 Berlin | 2021-11-01 00:00:00 | 15 | 18 Moscow | 2021-11-01 00:00:00 | 11 | 14 CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-11-01 00:00:00 MSK', '2021-12-01 00:00:00 MSK'); -- Data for 2021-11 is seen because the cagg was refreshed SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; city | month | min | max --------+---------------------+------+----- Moscow | 2021-06-01 00:00:00 | 22 | 34 Berlin | 2021-07-01 00:00:00 | 22 | 32 Moscow | 2021-07-01 00:00:00 | 1 | 11 Berlin | 2021-08-01 00:00:00 | 33 | 100 Moscow | 2021-08-01 00:00:00 | -100 | 21 Berlin | 2021-10-01 00:00:00 | 5 | 8 Moscow | 2021-10-01 00:00:00 | 1 | 4 Berlin | 2021-11-01 00:00:00 | 15 | 18 Moscow | 2021-11-01 00:00:00 | 11 | 14 -- Test for some more cases: single CAGG per HT, creating CAGG on top of an -- empty HT, buckets other than 1 month. CREATE TABLE conditions2( day timestamptz NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions2', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable -------------------------- (8,public,conditions2,t) -- Create a real-time aggregate on top of empty HT SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions2_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions2 GROUP BY city, bucket; NOTICE: continuous aggregate "conditions2_summary" is already up-to-date RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; INSERT INTO conditions2 (day, city, temperature) VALUES ('2021-06-14 00:00:00 MSK', 'Moscow', 26), ('2021-06-15 00:00:00 MSK', 'Moscow', 22), ('2021-06-16 00:00:00 MSK', 'Moscow', 24), ('2021-06-17 00:00:00 MSK', 'Moscow', 24), ('2021-06-18 00:00:00 MSK', 'Moscow', 27), ('2021-06-19 00:00:00 MSK', 'Moscow', 28), ('2021-06-20 00:00:00 MSK', 'Moscow', 30), ('2021-06-21 00:00:00 MSK', 'Moscow', 31), ('2021-06-22 00:00:00 MSK', 'Moscow', 34), ('2021-06-23 00:00:00 MSK', 'Moscow', 34), ('2021-06-24 00:00:00 MSK', 'Moscow', 34), ('2021-06-25 00:00:00 MSK', 'Moscow', 32), ('2021-06-26 00:00:00 MSK', 'Moscow', 32), ('2021-06-27 00:00:00 MSK', 'Moscow', 31); -- All data should be seen for a real-time aggregate SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions2_summary ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-12 00:00:00 | 22 | 27 Moscow | 2021-06-19 00:00:00 | 28 | 34 Moscow | 2021-06-26 00:00:00 | 31 | 32 -- Refresh should work CALL refresh_continuous_aggregate('conditions2_summary', '2021-06-12 MSK', '2021-07-03 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions2_summary ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-12 00:00:00 | 22 | 27 Moscow | 2021-06-19 00:00:00 | 28 | 34 Moscow | 2021-06-26 00:00:00 | 31 | 32 -- New data should be seen INSERT INTO conditions2 (day, city, temperature) VALUES ('2021-09-30 00:00:00 MSK', 'Moscow', 0), ('2021-10-01 00:00:00 MSK', 'Moscow', 1), ('2021-10-02 00:00:00 MSK', 'Moscow', 2), ('2021-10-03 00:00:00 MSK', 'Moscow', 3), ('2021-10-04 00:00:00 MSK', 'Moscow', 4), ('2021-09-30 00:00:00 MSK', 'Berlin', 5), ('2021-10-01 00:00:00 MSK', 'Berlin', 6), ('2021-10-02 00:00:00 MSK', 'Berlin', 7), ('2021-10-03 00:00:00 MSK', 'Berlin', 8), ('2021-10-04 00:00:00 MSK', 'Berlin', 9); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions2_summary ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-12 00:00:00 | 22 | 27 Moscow | 2021-06-19 00:00:00 | 28 | 34 Moscow | 2021-06-26 00:00:00 | 31 | 32 Berlin | 2021-09-25 00:00:00 | 5 | 6 Moscow | 2021-09-25 00:00:00 | 0 | 1 Berlin | 2021-10-02 00:00:00 | 7 | 9 Moscow | 2021-10-02 00:00:00 | 2 | 4 -- Make sure add_continuous_aggregate_policy() works CREATE TABLE conditions_policy( day TIMESTAMPTZ NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_policy', 'day', chunk_time_interval => INTERVAL '1 day' ); create_hypertable --------------------------------- (10,public,conditions_policy,t) INSERT INTO conditions_policy (day, city, temperature) VALUES ('2021-06-14 00:00:00 MSK', 'Moscow', 26), ('2021-06-14 10:00:00 MSK', 'Moscow', 22), ('2021-06-14 20:00:00 MSK', 'Moscow', 24), ('2021-06-15 00:00:00 MSK', 'Moscow', 24), ('2021-06-15 10:00:00 MSK', 'Moscow', 27), ('2021-06-15 20:00:00 MSK', 'Moscow', 28), ('2021-06-16 00:00:00 MSK', 'Moscow', 30), ('2021-06-16 10:00:00 MSK', 'Moscow', 31), ('2021-06-16 20:00:00 MSK', 'Moscow', 34), ('2021-06-17 00:00:00 MSK', 'Moscow', 34), ('2021-06-17 10:00:00 MSK', 'Moscow', 34), ('2021-06-17 20:00:00 MSK', 'Moscow', 32), ('2021-06-18 00:00:00 MSK', 'Moscow', 32), ('2021-06-18 10:00:00 MSK', 'Moscow', 31), ('2021-06-18 20:00:00 MSK', 'Moscow', 26); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_policy WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 day', day, 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_policy GROUP BY city, bucket; NOTICE: refreshing continuous aggregate "conditions_summary_policy" RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_policy ORDER by month, city; city | month | min | max --------+---------------------+-----+----- Moscow | 2021-06-14 00:00:00 | 22 | 26 Moscow | 2021-06-15 00:00:00 | 24 | 28 Moscow | 2021-06-16 00:00:00 | 30 | 34 Moscow | 2021-06-17 00:00:00 | 32 | 34 Moscow | 2021-06-18 00:00:00 | 26 | 32 \set ON_ERROR_STOP 0 -- Check for "policy refresh window too small" error SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '2 days 23 hours', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); ERROR: policy refresh window too small \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '3 days', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); add_continuous_aggregate_policy --------------------------------- 1000 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/feature_flags.out����������������������������������������������0000664�0000000�0000000�00000017216�15100345067�0023004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO 'America/Los_Angeles'; -- hypertable creation SHOW timescaledb.enable_hypertable_create; timescaledb.enable_hypertable_create -------------------------------------- on SET timescaledb.enable_hypertable_create TO off; CREATE TABLE test(time timestamptz, device int); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('test', 'time'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_create TO on; SELECT * FROM create_hypertable('test', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | test | t -- hypertable compression SHOW timescaledb.enable_hypertable_compression; timescaledb.enable_hypertable_compression ------------------------------------------- on SET timescaledb.enable_hypertable_compression TO off; INSERT INTO test SELECT t, 0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-04 1:00', '1 hour') t; SELECT * FROM show_chunks('test'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- compress_chunk \set ON_ERROR_STOP 0 SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_compression TO on; -- ensure compression cannot be enabled \set ON_ERROR_STOP 0 ALTER TABLE test SET (timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device'); \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_compression TO on; ALTER TABLE test SET (timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device'); SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SET timescaledb.enable_hypertable_compression TO off; -- cannot alter compressed table \set ON_ERROR_STOP 0 ALTER TABLE test ADD COLUMN col1 boolean DEFAULT false NOT NULL; ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_compression TO on; ALTER TABLE test ADD COLUMN col1 boolean DEFAULT false NOT NULL; SET timescaledb.enable_hypertable_compression TO off; \set ON_ERROR_STOP 0 ALTER TABLE test DROP COLUMN col1; ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 -- cagg creation SHOW timescaledb.enable_cagg_create; timescaledb.enable_cagg_create -------------------------------- on SET timescaledb.enable_cagg_create TO off; \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW contagg WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS hour, device FROM test GROUP BY hour, device; ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_create TO on; CREATE MATERIALIZED VIEW contagg WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS hour, device FROM test GROUP BY hour, device; NOTICE: refreshing continuous aggregate "contagg" SET timescaledb.enable_cagg_create TO off; \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('contagg', NULL, NULL); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_create TO on; -- policy creation SHOW timescaledb.enable_policy_create; timescaledb.enable_policy_create ---------------------------------- on SET timescaledb.enable_policy_create TO off; \set ON_ERROR_STOP 0 select add_retention_policy('test', INTERVAL '4 months', true); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ select remove_retention_policy('test'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ select add_compression_policy('test', compress_after => NULL); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT remove_compression_policy('test'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT add_continuous_aggregate_policy('contagg', '1 day'::interval, 10 , '1 h'::interval); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT remove_continuous_aggregate_policy('contagg'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ CREATE INDEX idx ON test(device); SELECT add_reorder_policy('test', 'idx'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ select remove_reorder_policy('test'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT timescaledb_experimental.add_policies('test', refresh_start_offset => 1, refresh_end_offset => 10, compress_after => 11, drop_after => 20); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT timescaledb_experimental.show_policies('test'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT timescaledb_experimental.alter_policies('test', refresh_start_offset => 11, compress_after=>13, drop_after => 25); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT timescaledb_experimental.remove_all_policies('test'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ SELECT timescaledb_experimental.remove_policies('test', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); ERROR: You are using a PostgreSQL service. This feature is only available on Time-series and analytics services. https://docs.timescale.com/use-timescale/latest/services/ \set ON_ERROR_STOP 1 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/fixed_schedules.out��������������������������������������������0000664�0000000�0000000�00000151246�15100345067�0023335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; select '2023-01-02 11:53:19.059771+02'::timestamptz as finish_time \gset select :'finish_time'::timestamptz - interval '5 sec' as start_time \gset -- years select ts_test_next_scheduled_execution_slot('1 year', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "1 yr", ts_test_next_scheduled_execution_slot('1 year', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "1 yr timezone", ts_test_next_scheduled_execution_slot('10 year', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "10 yr", ts_test_next_scheduled_execution_slot('10 year', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "10 yr timezone"; 1 yr | 1 yr timezone | 10 yr | 10 yr timezone -------------------------------------+-------------------------------------+-------------------------------------+------------------------------------- Tue Jan 02 01:53:14.059771 2024 PST | Tue Jan 02 01:53:14.059771 2024 PST | Sun Jan 02 01:53:14.059771 2033 PST | Sun Jan 02 01:53:14.059771 2033 PST -- weeks select ts_test_next_scheduled_execution_slot('1 week', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "1 week", ts_test_next_scheduled_execution_slot('1 week', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "1 week timezone", ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "2 week", ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "2 week timezone"; 1 week | 1 week timezone | 2 week | 2 week timezone -------------------------------------+-------------------------------------+-------------------------------------+------------------------------------- Mon Jan 09 01:53:14.059771 2023 PST | Mon Jan 09 01:53:14.059771 2023 PST | Mon Jan 16 01:53:14.059771 2023 PST | Mon Jan 16 01:53:14.059771 2023 PST -- months select ts_test_next_scheduled_execution_slot('1 month', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "1 month", ts_test_next_scheduled_execution_slot('1 month', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "1 month timezone", ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "2 month", ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "2 month timezone"; 1 month | 1 month timezone | 2 month | 2 month timezone -------------------------------------+-------------------------------------+-------------------------------------+------------------------------------- Thu Feb 02 01:53:14.059771 2023 PST | Thu Feb 02 01:53:14.059771 2023 PST | Thu Mar 02 01:53:14.059771 2023 PST | Thu Mar 02 01:53:14.059771 2023 PST -- timezone in Berlin changes between 1 and 2 am \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 hour\'' \set START_TIME_BEFORE_SUMMER_SWITCH 'TIMESTAMPTZ \'2022-03-27 01:00:00\'' \set FINISH_TIME_AFTER_SUMMER_SWITCH 'TIMESTAMPTZ \'2022-03-27 01:19:20\'' \set START_TIME_BEFORE_WINTER_SWITCH 'TIMESTAMPTZ \'2022-10-30 01:01:00\'' \set FINISH_TIME_AFTER_WINTER_SWITCH 'TIMESTAMPTZ \'2022-10-30 01:10:19\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Mar 27 03:00:00 2022 CEST | Sun Mar 27 03:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Mar 27 04:00:00 2022 CEST | Sun Mar 27 04:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Mar 27 05:00:00 2022 CEST | Sun Mar 27 05:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Mar 27 06:00:00 2022 CEST | Sun Mar 27 06:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Mar 27 07:00:00 2022 CEST | Sun Mar 27 07:00:00 2022 CEST --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Oct 30 02:01:00 2022 CEST | Sun Oct 30 02:01:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Oct 30 02:01:00 2022 CET | Sun Oct 30 02:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Oct 30 03:01:00 2022 CET | Sun Oct 30 03:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Oct 30 04:01:00 2022 CET | Sun Oct 30 04:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Oct 30 05:00:00 2022 CET | Sun Oct 30 05:00:00 2022 CET \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 day\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Mon Mar 28 01:00:00 2022 CEST | Mon Mar 28 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Tue Mar 29 01:00:00 2022 CEST | Tue Mar 29 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Tue Mar 29 02:00:00 2022 CEST | Wed Mar 30 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Mar 30 02:00:00 2022 CEST | Thu Mar 31 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Thu Mar 31 02:00:00 2022 CEST | Fri Apr 01 01:00:00 2022 CEST --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Mon Oct 31 01:01:00 2022 CET | Mon Oct 31 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Tue Nov 01 00:01:00 2022 CET | Tue Nov 01 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Nov 02 00:01:00 2022 CET | Wed Nov 02 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Thu Nov 03 00:01:00 2022 CET | Thu Nov 03 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Thu Nov 03 01:00:00 2022 CET | Fri Nov 04 01:00:00 2022 CET \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 week\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Apr 03 01:00:00 2022 CEST | Sun Apr 03 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Apr 10 01:00:00 2022 CEST | Sun Apr 10 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Apr 10 02:00:00 2022 CEST | Sun Apr 17 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Apr 17 02:00:00 2022 CEST | Sun Apr 24 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Apr 24 02:00:00 2022 CEST | Sun May 01 01:00:00 2022 CEST --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Nov 06 01:01:00 2022 CET | Sun Nov 06 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Nov 13 00:01:00 2022 CET | Sun Nov 13 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Nov 20 00:01:00 2022 CET | Sun Nov 20 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Nov 27 00:01:00 2022 CET | Sun Nov 27 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Nov 27 01:00:00 2022 CET | Sun Dec 04 01:00:00 2022 CET \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 month\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Apr 27 01:00:00 2022 CEST | Wed Apr 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Fri May 27 01:00:00 2022 CEST | Fri May 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Mon Jun 27 01:00:00 2022 CEST | Mon Jun 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Jul 27 01:00:00 2022 CEST | Wed Jul 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sat Aug 27 01:00:00 2022 CEST | Sat Aug 27 01:00:00 2022 CEST --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Nov 30 01:01:00 2022 CET | Wed Nov 30 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Dec 30 01:01:00 2022 CET | Fri Dec 30 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Mon Jan 30 01:01:00 2023 CET | Mon Jan 30 01:01:00 2023 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Tue Feb 28 01:01:00 2023 CET | Tue Feb 28 01:01:00 2023 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Mon Mar 27 01:00:00 2023 CEST | Mon Mar 27 01:00:00 2023 CEST \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 year\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 year\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Mon Mar 27 01:00:00 2023 CEST | Mon Mar 27 01:00:00 2023 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Mar 27 01:00:00 2024 CET | Wed Mar 27 01:00:00 2024 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Thu Mar 27 01:00:00 2025 CET | Thu Mar 27 01:00:00 2025 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Mar 27 01:00:00 2026 CET | Fri Mar 27 01:00:00 2026 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Mar 27 01:00:00 2027 CET | Sat Mar 27 01:00:00 2027 CET --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Mon Oct 30 01:01:00 2023 CET | Mon Oct 30 01:01:00 2023 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Oct 30 01:01:00 2024 CET | Wed Oct 30 01:01:00 2024 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Thu Oct 30 01:01:00 2025 CET | Thu Oct 30 01:01:00 2025 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Oct 30 01:01:00 2026 CET | Fri Oct 30 01:01:00 2026 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Mar 27 01:00:00 2027 CET | Sat Mar 27 01:00:00 2027 CET \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'2 month\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'2 month\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Fri May 27 01:00:00 2022 CEST | Fri May 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Jul 27 01:00:00 2022 CEST | Wed Jul 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Tue Sep 27 01:00:00 2022 CEST | Tue Sep 27 01:00:00 2022 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sun Nov 27 01:00:00 2022 CET | Sun Nov 27 01:00:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Jan 27 01:00:00 2023 CET | Fri Jan 27 01:00:00 2023 CET --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Dec 30 01:01:00 2022 CET | Fri Dec 30 01:01:00 2022 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Tue Feb 28 01:01:00 2023 CET | Tue Feb 28 01:01:00 2023 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Sun Apr 30 01:01:00 2023 CEST | Sun Apr 30 01:01:00 2023 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Fri Jun 30 01:01:00 2023 CEST | Fri Jun 30 01:01:00 2023 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Thu Jul 27 01:00:00 2023 CEST | Thu Jul 27 01:00:00 2023 CEST \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'2 year\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'2 year\'' \ir include/scheduler_fixed_common.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; initial_start_summer_switch | first_finish_time_summer_switch ------------------------------+--------------------------------- Sun Mar 27 01:00:00 2022 CET | Sun Mar 27 01:19:20 2022 CET select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Mar 27 01:00:00 2024 CET | Wed Mar 27 01:00:00 2024 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Mar 27 01:00:00 2026 CET | Fri Mar 27 01:00:00 2026 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Mon Mar 27 01:00:00 2028 CEST | Mon Mar 27 01:00:00 2028 CEST select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Mar 27 01:00:00 2030 CET | Wed Mar 27 01:00:00 2030 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Mar 27 01:00:00 2032 CET | Sat Mar 27 01:00:00 2032 CET --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; initial_start_winter_switch | first_finish_time_winter_switch -------------------------------+--------------------------------- Sun Oct 30 01:01:00 2022 CEST | Sun Oct 30 01:10:19 2022 CEST select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Oct 30 01:01:00 2024 CET | Wed Oct 30 01:01:00 2024 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Fri Oct 30 01:01:00 2026 CET | Fri Oct 30 01:01:00 2026 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Mon Oct 30 01:01:00 2028 CET | Mon Oct 30 01:01:00 2028 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Wed Oct 30 01:01:00 2030 CET | Wed Oct 30 01:01:00 2030 CET select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Mar 27 01:00:00 2032 CET | Sat Mar 27 01:00:00 2032 CET ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/foreign_keys_test-15.out���������������������������������������0000664�0000000�0000000�00000215336�15100345067�0024146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME foreign_keys SELECT format('include/%s.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_generic.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_GENERIC", format('%s/results/%s_results_custom.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_CUSTOM" \gset SELECT format('\! diff -u --label "Generic plan results" --label "Custom plan results" %s %s', :'TEST_RESULTS_GENERIC', :'TEST_RESULTS_CUSTOM') AS "DIFF_CMD" \gset set plan_cache_mode to force_generic_plan; \o :TEST_RESULTS_GENERIC \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o reset plan_cache_mode; \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; set plan_cache_mode to force_custom_plan; \o :TEST_RESULTS_CUSTOM \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o \c :TEST_DBNAME :ROLE_SUPERUSER reset plan_cache_mode; DROP DATABASE :TEST_DBNAME_2 WITH (force); -- compare outputs for generic vs. custom plans for FK check prepared statements :DIFF_CMD ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/foreign_keys_test-16.out���������������������������������������0000664�0000000�0000000�00000215336�15100345067�0024147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME foreign_keys SELECT format('include/%s.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_generic.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_GENERIC", format('%s/results/%s_results_custom.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_CUSTOM" \gset SELECT format('\! diff -u --label "Generic plan results" --label "Custom plan results" %s %s', :'TEST_RESULTS_GENERIC', :'TEST_RESULTS_CUSTOM') AS "DIFF_CMD" \gset set plan_cache_mode to force_generic_plan; \o :TEST_RESULTS_GENERIC \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o reset plan_cache_mode; \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; set plan_cache_mode to force_custom_plan; \o :TEST_RESULTS_CUSTOM \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o \c :TEST_DBNAME :ROLE_SUPERUSER reset plan_cache_mode; DROP DATABASE :TEST_DBNAME_2 WITH (force); -- compare outputs for generic vs. custom plans for FK check prepared statements :DIFF_CMD ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/foreign_keys_test-17.out���������������������������������������0000664�0000000�0000000�00000215336�15100345067�0024150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME foreign_keys SELECT format('include/%s.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_generic.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_GENERIC", format('%s/results/%s_results_custom.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_CUSTOM" \gset SELECT format('\! diff -u --label "Generic plan results" --label "Custom plan results" %s %s', :'TEST_RESULTS_GENERIC', :'TEST_RESULTS_CUSTOM') AS "DIFF_CMD" \gset set plan_cache_mode to force_generic_plan; \o :TEST_RESULTS_GENERIC \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o reset plan_cache_mode; \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; set plan_cache_mode to force_custom_plan; \o :TEST_RESULTS_CUSTOM \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o \c :TEST_DBNAME :ROLE_SUPERUSER reset plan_cache_mode; DROP DATABASE :TEST_DBNAME_2 WITH (force); -- compare outputs for generic vs. custom plans for FK check prepared statements :DIFF_CMD ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/foreign_keys_test-18.out���������������������������������������0000664�0000000�0000000�00000216106�15100345067�0024145�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME foreign_keys SELECT format('include/%s.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_generic.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_GENERIC", format('%s/results/%s_results_custom.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_CUSTOM" \gset SELECT format('\! diff -u --label "Generic plan results" --label "Custom plan results" %s %s', :'TEST_RESULTS_GENERIC', :'TEST_RESULTS_CUSTOM') AS "DIFF_CMD" \gset set plan_cache_mode to force_generic_plan; \o :TEST_RESULTS_GENERIC \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates RESTRICT setting of foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates RESTRICT setting of foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates RESTRICT setting of foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates RESTRICT setting of foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates RESTRICT setting of foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o reset plan_cache_mode; \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; set plan_cache_mode to force_custom_plan; \o :TEST_RESULTS_CUSTOM \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:16: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:23: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:33: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:35: ERROR: update or delete on table "_hyper_1_1_chunk" violates foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:46: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; psql:include/foreign_keys.sql:56: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:57: ERROR: cannot truncate a table referenced in a foreign key constraint TRUNCATE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:58: ERROR: cannot truncate a table referenced in a foreign key constraint DROP TABLE _timescaledb_internal._hyper_1_1_chunk; psql:include/foreign_keys.sql:59: ERROR: cannot drop table _timescaledb_internal._hyper_1_1_chunk because other objects depend on it DROP TABLE _timescaledb_internal._hyper_1_2_chunk; psql:include/foreign_keys.sql:60: ERROR: cannot drop table _timescaledb_internal._hyper_1_2_chunk because other objects depend on it SELECT drop_chunks('metrics', '1 month'::interval); psql:include/foreign_keys.sql:61: NOTICE: drop cascades to constraint event_time_fkey on table event \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:78: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:85: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:95: ERROR: update or delete on table "_hyper_2_3_chunk" violates RESTRICT setting of foreign key constraint "event_time_fkey1" on table "event" -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:97: ERROR: update or delete on table "_hyper_2_3_chunk" violates RESTRICT setting of foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); psql:include/foreign_keys.sql:108: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:130: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:137: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:173: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:180: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:216: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:223: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:260: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:267: ERROR: update or delete on table "_hyper_6_8_chunk" violates RESTRICT setting of foreign key constraint "event_time_fkey1" on table "event" \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); psql:include/foreign_keys.sql:288: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); psql:include/foreign_keys.sql:289: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:296: ERROR: update or delete on table "_hyper_7_9_chunk" violates RESTRICT setting of foreign key constraint "event_time_device_fkey" on table "event" DELETE FROM metrics WHERE device = 'd1'; psql:include/foreign_keys.sql:297: ERROR: update or delete on table "_hyper_7_9_chunk" violates RESTRICT setting of foreign key constraint "event_time_device_fkey" on table "event" \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; psql:include/foreign_keys.sql:315: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); psql:include/foreign_keys.sql:343: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; psql:include/foreign_keys.sql:350: ERROR: insert or update on table "event" violates foreign key constraint "event_time_fkey" \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); psql:include/foreign_keys.sql:383: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); psql:include/foreign_keys.sql:388: ERROR: hypertables cannot be used as foreign key references of hypertables \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); psql:include/foreign_keys.sql:422: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_14_ht_fk_no_action_fkey" -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:429: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; psql:include/foreign_keys.sql:438: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:446: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; psql:include/foreign_keys.sql:455: ERROR: update or delete on table "fk_no_action" violates foreign key constraint "ht_fk_no_action_fkey" on table "ht" ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); psql:include/foreign_keys.sql:460: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_15_ht_fk_restrict_fkey" -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:467: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; psql:include/foreign_keys.sql:476: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:484: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; psql:include/foreign_keys.sql:493: ERROR: update or delete on table "fk_restrict" violates RESTRICT setting of foreign key constraint "ht_fk_restrict_fkey" on table "ht" ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); psql:include/foreign_keys.sql:499: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_13_ht_fk_cascade_fkey" -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); psql:include/foreign_keys.sql:599: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_17_ht_fk_set_null_fkey" -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); psql:include/foreign_keys.sql:667: ERROR: insert or update on table "_hyper_13_14_chunk" violates foreign key constraint "14_16_ht_fk_set_default_fkey" -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:748: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; psql:include/foreign_keys.sql:755: ERROR: insert or update on table "converted_fk" violates foreign key constraint "converted_fk_time_id_fkey" \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; psql:include/foreign_keys.sql:761: ERROR: update or delete on table "_hyper_16_34_chunk" violates foreign key constraint "converted_fk_time_id_fkey1" on table "converted_fk" TRUNCATE converted_pk; psql:include/foreign_keys.sql:762: ERROR: cannot truncate a table referenced in a foreign key constraint \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; \o \c :TEST_DBNAME :ROLE_SUPERUSER reset plan_cache_mode; DROP DATABASE :TEST_DBNAME_2 WITH (force); -- compare outputs for generic vs. custom plans for FK check prepared statements :DIFF_CMD ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/hypertable_generalization.out����������������������������������0000664�0000000�0000000�00000044001�15100345067�0025417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE FUNCTION part_func(id TEXT) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval INTEGER; BEGIN retval := CAST(id AS INTEGER); RETURN retval; END $BODY$; -- test null handling \set ON_ERROR_STOP 0 CREATE TABLE n(); SELECT create_hypertable('n',NULL::_timescaledb_internal.dimension_info); ERROR: dimension cannot be NULL SELECT add_dimension('n',NULL::_timescaledb_internal.dimension_info); ERROR: dimension cannot be NULL \set ON_ERROR_STOP 1 SELECT by_range('id'); by_range ----------------- range//id//-//- SELECT by_range('id', partition_func => 'part_func'); by_range ------------------------- range//id//-//part_func SELECT by_range('id', '1 week'::interval); by_range ------------------------ range//id//@ 7 days//- SELECT by_range('id', '1 week'::interval, 'part_func'::regproc); by_range -------------------------------- range//id//@ 7 days//part_func SELECT by_hash('id', 3); by_hash ---------------- hash//id//3//- SELECT by_hash('id', 3, partition_func => 'part_func'); by_hash ------------------------ hash//id//3//part_func -- Check if we handle the varlength of the datatype properly SELECT * FROM by_range('id') WHERE by_range IS NOT NULL; by_range ----------------- range//id//-//- SELECT * FROM by_range('id', partition_func => 'part_func') WHERE by_range IS NOT NULL; by_range ------------------------- range//id//-//part_func SELECT * FROM by_hash('id', 3) WHERE by_hash IS NOT NULL; by_hash ---------------- hash//id//3//- SELECT * FROM by_hash('id', 3, partition_func => 'part_func') WHERE by_hash IS NOT NULL; by_hash ------------------------ hash//id//3//part_func \set ON_ERROR_STOP 0 SELECT 'hash//id//3//-'::_timescaledb_internal.dimension_info; ERROR: cannot construct type "dimension_info" from string at character 8 SELECT by_range(NULL::name); ERROR: column_name cannot be NULL SELECT by_hash(NULL::name, 3); ERROR: column_name cannot be NULL \set ON_ERROR_STOP 1 -- Validate generalized hypertable for smallint CREATE TABLE test_table_smallint(id SMALLINT, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_smallint', by_range('id')); create_hypertable ------------------- (1,t) -- default interval SELECT integer_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_smallint'; integer_interval ------------------ 10000 -- Add data with default partition (10000) INSERT INTO test_table_smallint VALUES (1, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_smallint VALUES (9999, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_smallint VALUES (10000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_smallint VALUES (20000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); -- Number of chunks SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_smallint'; count ------- 3 -- Validate generalized hypertable for int CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id')); create_hypertable ------------------- (2,t) -- Default interval SELECT integer_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_int'; integer_interval ------------------ 100000 -- Add data INSERT INTO test_table_int VALUES (1, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES (99999, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES (100000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES (200000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); -- Number of chunks SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_int'; count ------- 3 -- Validate generalized hypertable for bigint CREATE TABLE test_table_bigint(id BIGINT, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_bigint', by_range('id')); create_hypertable ------------------- (3,t) -- Default interval SELECT integer_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_bigint'; integer_interval ------------------ 1000000 -- Add data INSERT INTO test_table_bigint VALUES (1, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_bigint VALUES (999999, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_bigint VALUES (1000000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_bigint VALUES (2000000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); -- Number of chunks SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_bigint'; count ------- 3 DROP TABLE test_table_smallint; DROP TABLE test_table_int; DROP TABLE test_table_bigint; -- Create hypertable with SERIAL column CREATE TABLE jobs_serial (job_id SERIAL, device_id INTEGER, start_time TIMESTAMPTZ, end_time TIMESTAMPTZ, PRIMARY KEY (job_id)); SELECT create_hypertable('jobs_serial', by_range('job_id', partition_interval => 30)); create_hypertable ------------------- (4,t) -- Insert data INSERT INTO jobs_serial (device_id, start_time, end_time) SELECT abs(timestamp_hash(t::timestamp)) % 10, t, t + INTERVAL '1 day' FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-08 1:00':: TIMESTAMPTZ,'1 hour')t; -- Verify chunk pruning EXPLAIN VERBOSE SELECT * FROM jobs_serial WHERE job_id < 30; --- QUERY PLAN --- Index Scan using "10_1_jobs_serial_pkey" on _timescaledb_internal._hyper_4_10_chunk (cost=0.15..20.30 rows=523 width=24) Output: _hyper_4_10_chunk.job_id, _hyper_4_10_chunk.device_id, _hyper_4_10_chunk.start_time, _hyper_4_10_chunk.end_time Index Cond: (_hyper_4_10_chunk.job_id < 30) EXPLAIN VERBOSE SELECT * FROM jobs_serial WHERE job_id >= 30 AND job_id < 90; --- QUERY PLAN --- Append (cost=0.15..14.71 rows=16 width=24) -> Index Scan using "11_2_jobs_serial_pkey" on _timescaledb_internal._hyper_4_11_chunk (cost=0.15..7.31 rows=8 width=24) Output: _hyper_4_11_chunk.job_id, _hyper_4_11_chunk.device_id, _hyper_4_11_chunk.start_time, _hyper_4_11_chunk.end_time Index Cond: ((_hyper_4_11_chunk.job_id >= 30) AND (_hyper_4_11_chunk.job_id < 90)) -> Index Scan using "12_3_jobs_serial_pkey" on _timescaledb_internal._hyper_4_12_chunk (cost=0.15..7.31 rows=8 width=24) Output: _hyper_4_12_chunk.job_id, _hyper_4_12_chunk.device_id, _hyper_4_12_chunk.start_time, _hyper_4_12_chunk.end_time Index Cond: ((_hyper_4_12_chunk.job_id >= 30) AND (_hyper_4_12_chunk.job_id < 90)) EXPLAIN VERBOSE SELECT * FROM jobs_serial WHERE job_id > 90; --- QUERY PLAN --- Append (cost=0.15..45.84 rows=1046 width=24) -> Index Scan using "13_4_jobs_serial_pkey" on _timescaledb_internal._hyper_4_13_chunk (cost=0.15..20.30 rows=523 width=24) Output: _hyper_4_13_chunk.job_id, _hyper_4_13_chunk.device_id, _hyper_4_13_chunk.start_time, _hyper_4_13_chunk.end_time Index Cond: (_hyper_4_13_chunk.job_id > 90) -> Index Scan using "14_5_jobs_serial_pkey" on _timescaledb_internal._hyper_4_14_chunk (cost=0.15..20.30 rows=523 width=24) Output: _hyper_4_14_chunk.job_id, _hyper_4_14_chunk.device_id, _hyper_4_14_chunk.start_time, _hyper_4_14_chunk.end_time Index Cond: (_hyper_4_14_chunk.job_id > 90) -- Update rows UPDATE jobs_serial SET end_time = end_time + INTERVAL '1 hour' where job_id = 1; UPDATE jobs_serial SET end_time = end_time + INTERVAL '1 hour' where job_id = 30; UPDATE jobs_serial SET end_time = end_time + INTERVAL '1 hour' where job_id = 90; SELECT start_time, end_time FROM jobs_serial WHERE job_id = 1; start_time | end_time ------------------------------+------------------------------ Fri Mar 02 01:00:00 2018 PST | Sat Mar 03 02:00:00 2018 PST SELECT start_time, end_time FROM jobs_serial WHERE job_id = 30; start_time | end_time ------------------------------+------------------------------ Sat Mar 03 06:00:00 2018 PST | Sun Mar 04 07:00:00 2018 PST SELECT start_time, end_time FROM jobs_serial WHERE job_id = 90; start_time | end_time ------------------------------+------------------------------ Mon Mar 05 18:00:00 2018 PST | Tue Mar 06 19:00:00 2018 PST -- Test delete rows -- Existing tuple counts. We saves these and compare with the values -- after running the delete. CREATE TABLE counts AS SELECT (SELECT count(*) FROM jobs_serial) AS total_count, (SELECT count(*) FROM jobs_serial WHERE job_id < 10) AS remove_count; -- Perform the delete DELETE FROM jobs_serial WHERE job_id < 10; -- Ensure only the intended tuples are deleted. The two counts should be equal. SELECT (SELECT total_count FROM counts) - (SELECT count(*) FROM jobs_serial) AS total_removed, (SELECT remove_count FROM counts) - (SELECT count(*) FROM jobs_serial WHERE job_id < 10) AS matching_removed; total_removed | matching_removed ---------------+------------------ 9 | 9 DROP TABLE jobs_serial; DROP TABLE counts; -- Create and validate hypertable with BIGSERIAL column CREATE TABLE jobs_big_serial (job_id BIGSERIAL, device_id INTEGER, start_time TIMESTAMPTZ, end_time TIMESTAMPTZ, PRIMARY KEY (job_id)); SELECT create_hypertable('jobs_big_serial', by_range('job_id', 100)); create_hypertable ------------------- (5,t) -- Insert data INSERT INTO jobs_big_serial (device_id, start_time, end_time) SELECT abs(timestamp_hash(t::timestamp)) % 10, t, t + INTERVAL '1 day' FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-08 1:00'::TIMESTAMPTZ,'30 mins')t; -- Verify #chunks SELECT count(*) FROM timescaledb_information.chunks; count ------- 3 -- Get current sequence and verify updating sequence SELECT currval(pg_get_serial_sequence('jobs_big_serial', 'job_id')); currval --------- 289 -- Update sequence value to 500 SELECT setval(pg_get_serial_sequence('jobs_big_serial', 'job_id'), 500, false); setval -------- 500 -- Insert few rows and verify that the next sequence starts from 500 INSERT INTO jobs_big_serial (device_id, start_time, end_time) SELECT abs(timestamp_hash(t::timestamp)) % 10, t, t + INTERVAL '1 day' FROM generate_series('2018-03-09 1:00'::TIMESTAMPTZ, '2018-03-10 1:00'::TIMESTAMPTZ,'30 mins')t; -- No data should exist for job_id >= 290 to job_id < 500 SELECT count(*) FROM jobs_big_serial WHERE job_id >= 290 AND job_id < 500; count ------- 0 -- The new rows should be added with job_id > 500 SELECT count(*) from jobs_big_serial WHERE job_id > 500; count ------- 48 -- Verify show_chunks API SELECT show_chunks('jobs_big_serial', older_than => 100); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_15_chunk SELECT show_chunks('jobs_big_serial', newer_than => 200, older_than => 300); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_17_chunk SELECT show_chunks('jobs_big_serial', newer_than => 500); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_18_chunk -- Verify drop_chunks API SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'jobs_big_serial'; count ------- 4 SELECT drop_chunks('jobs_big_serial', newer_than => 500); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_5_18_chunk SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'jobs_big_serial'; count ------- 3 SELECT drop_chunks('jobs_big_serial', newer_than => 200, older_than => 300); drop_chunks ----------------------------------------- _timescaledb_internal._hyper_5_17_chunk SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'jobs_big_serial'; count ------- 2 DROP TABLE jobs_big_serial; -- Verify partition function CREATE TABLE test_table_int(id TEXT, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10, partition_func => 'part_func')); create_hypertable ------------------- (6,t) INSERT INTO test_table_int VALUES('1', 1, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES('10', 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES('29', 100, '01-01-2023 11:00'::TIMESTAMPTZ); SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int'; count ------- 3 DROP TABLE test_table_int; DROP FUNCTION part_func; -- Migrate data CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); INSERT INTO test_table_int SELECT t, t%10, '01-01-2023 11:00'::TIMESTAMPTZ FROM generate_series(1, 50, 1) t; SELECT create_hypertable('test_table_int', by_range('id', 10), migrate_data => true); NOTICE: migrating data to chunks create_hypertable ------------------- (7,t) -- Show default indexes created for hypertables. SELECT indexname FROM pg_indexes WHERE tablename = 'test_table_int'; indexname ----------------------- test_table_int_id_idx SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int'; count ------- 6 DROP TABLE test_table_int; -- create_hypertable without default indexes CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10), create_default_indexes => false); create_hypertable ------------------- (8,t) SELECT indexname FROM pg_indexes WHERE tablename = 'test_table_int'; indexname ----------- DROP TABLE test_table_int; -- if_not_exists CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10)); create_hypertable ------------------- (9,t) -- No error when if_not_exists => true SELECT create_hypertable('test_table_int', by_range('id', 10), if_not_exists => true); NOTICE: table "test_table_int" is already a hypertable, skipping create_hypertable ------------------- (9,f) SELECT * FROM _timescaledb_functions.get_create_command('test_table_int'); get_create_command -------------------------------------------------------------------------------------------------------------------- SELECT create_hypertable('public.test_table_int', 'id', chunk_time_interval => 10, create_default_indexes=>FALSE); \set ON_ERROR_STOP 0 -- Should throw an error when if_not_exists is not set SELECT create_hypertable('test_table_int', by_range('id', 10)); ERROR: table "test_table_int" is already a hypertable -- Should error out when hash partitioning is used as the main partitioning scheme SELECT create_hypertable('test_table_int', by_hash('device', number_partitions => 2)); ERROR: cannot partition using a closed dimension on primary column \set ON_ERROR_STOP 1 DROP TABLE test_table_int; -- Add dimension CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10), migrate_data => true); create_hypertable ------------------- (10,t) INSERT INTO test_table_int SELECT t, t%10, '01-01-2023 11:00'::TIMESTAMPTZ FROM generate_series(1, 50, 1) t; -- adding a space dimension via "by_hash" should work SELECT add_dimension('test_table_int', by_hash('device', number_partitions => 2)); add_dimension --------------- (11,t) SELECT hypertable_name, dimension_number, column_name FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_int'; hypertable_name | dimension_number | column_name -----------------+------------------+------------- test_table_int | 1 | id test_table_int | 2 | device SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_int'; count ------- 6 SELECT set_partitioning_interval('test_table_int', 5, 'id'); set_partitioning_interval --------------------------- SELECT set_number_partitions('test_table_int', 3, 'device'); set_number_partitions ----------------------- SELECT integer_interval, num_partitions FROM timescaledb_information.dimensions WHERE column_name in ('id', 'device'); integer_interval | num_partitions ------------------+---------------- 5 | | 3 DROP TABLE test_table_int; -- Hypertable with time dimension using new API CREATE TABLE test_time(time TIMESTAMP NOT NULL, device INT, temp FLOAT); SELECT create_hypertable('test_time', by_range('time')); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------- (11,t) -- Default interval SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_time'; time_interval --------------- @ 7 days INSERT INTO test_time SELECT t, (abs(timestamp_hash(t::timestamp)) % 10) + 1, 0.10 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-08 1:00', '1 hour') t; SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_time'; count ------- 2 SELECT add_dimension('test_time', by_range('device', partition_interval => 2)); add_dimension --------------- (13,t) SELECT hypertable_name, dimension_number, column_name FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_time'; hypertable_name | dimension_number | column_name -----------------+------------------+------------- test_time | 1 | time test_time | 2 | device SELECT set_partitioning_interval('test_time', INTERVAL '1 day', 'time'); set_partitioning_interval --------------------------- SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_time' AND column_name = 'time'; time_interval --------------- @ 1 day DROP TABLE test_time; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/information_view_chunk_count.out�������������������������������0000664�0000000�0000000�00000004311�15100345067�0026144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; CREATE TABLE sensor_data( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); SELECT from create_hypertable('sensor_data','time'); -- INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random() * 100 AS temperature FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') AS g1(time), generate_series(1, 100, 1 ) AS g2(sensor_id) ORDER BY time; CREATE materialized VIEW sensor_data_v WITH(timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT sensor_id, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM sensor_data GROUP BY sensor_id, bucket; NOTICE: refreshing continuous aggregate "sensor_data_v" INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2018-03-03 1:00'::TIMESTAMPTZ, '2018-03-31 1:00', '1 hour') AS g1(time), generate_series(1, 100, 1 ) AS g2(sensor_id) ORDER BY time; SELECT count(*) AS num_chunks FROM show_chunks('sensor_data'); num_chunks ------------ 5 SELECT drop_chunks('sensor_data','2018-03-28'::timestamp); drop_chunks ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk SELECT count(*) AS num_chunks from timescaledb_information.chunks where hypertable_name = 'sensor_data'; num_chunks ------------ 2 SELECT num_chunks from timescaledb_information.hypertables where hypertable_name = 'sensor_data'; num_chunks ------------ 2 SELECT count(*) AS num_chunks FROM show_chunks('sensor_data'); num_chunks ------------ 2 DROP TABLE sensor_data CASCADE; NOTICE: drop cascades to 3 other objects NOTICE: drop cascades to table _timescaledb_internal._hyper_2_5_chunk �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/insert_memory_usage.out����������������������������������������0000664�0000000�0000000�00000012542�15100345067�0024252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test that transaction memory usage with COPY doesn't grow. -- We need memory usage in PortalContext after the completion of the query, so -- we'll have to log it from a trigger that runs after the query is completed. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; create table uk_price_paid(price integer, "date" date, postcode1 text, postcode2 text, type smallint, is_new bool, duration smallint, addr1 text, addr2 text, street text, locality text, town text, district text, country text, category smallint); alter table uk_price_paid set unlogged; -- Aim to about 100 partitions, the data is from 1995 to 2022. select create_hypertable('uk_price_paid', 'date', chunk_time_interval => interval '90 day'); create_hypertable ---------------------------- (1,public,uk_price_paid,t) -- This is where we log the memory usage. create table portal_memory_log(id serial, bytes bigint); -- Returns the amount of memory currently allocated in a given -- memory context. Only works for PortalContext, and doesn't work for PG 12. create or replace function ts_debug_allocated_bytes(text) returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; -- Log current memory usage into the log table. create function log_memory() returns trigger as $$ begin insert into portal_memory_log values (default, ts_debug_allocated_bytes('PortalContext')); return new; end; $$ language plpgsql; -- Add a trigger that runs after completion of each INSERT/COPY and logs the -- current memory usage. create trigger check_update after insert on uk_price_paid for each statement execute function log_memory(); -- Memory leaks often happen on cache invalidation, so make sure they are -- invalidated often and independently (at co-prime periods). set timescaledb.max_open_chunks_per_insert = 2; set timescaledb.max_cached_chunks_per_hypertable = 3; -- Try increasingly larger data sets by concatenating the same file multiple -- times. First, INSERT into an uncompressed table. create table uk_price_paid_one(like uk_price_paid); \copy uk_price_paid_one from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz)"'; truncate uk_price_paid; insert into uk_price_paid select * from uk_price_paid_one; truncate portal_memory_log; alter sequence portal_memory_log_id_seq restart with 1; -- Don't use joins here because they might materialize a subquery which will -- lead to weird memory usage changes. insert into uk_price_paid select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; -- Use linear regression to check that the memory usage doesn't significanlty -- increase with increasing the insert size. -- Note that there's going to be some linear planning and parsing overhead for -- bigger queries, unlike the COPY. It can constitute a sizable percentage of -- the total memory usage, so we'll check the absolute value as well. \set parsing_overhead_bytes 50000 select * from portal_memory_log where ( select regr_slope(bytes, id - 1) / regr_intercept(bytes, id - 1)::float > 0.05 and regr_slope(bytes, id - 1) > :parsing_overhead_bytes from portal_memory_log ); id | bytes ----+------- -- INSERT into a compressed table. truncate uk_price_paid; insert into uk_price_paid select * from uk_price_paid_one; alter table uk_price_paid set (timescaledb.compress, timescaledb.compress_orderby = 'date'); select count(compress_chunk(chunk)) from show_chunks('uk_price_paid') chunk; count ------- 111 truncate portal_memory_log; alter sequence portal_memory_log_id_seq restart with 1; -- Don't use joins here because they might materialize a subquery which will -- lead to weird memory usage changes. insert into uk_price_paid select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; select * from portal_memory_log where ( select regr_slope(bytes, id - 1) / regr_intercept(bytes, id - 1)::float > 0.05 and regr_slope(bytes, id - 1) > :parsing_overhead_bytes from portal_memory_log ); id | bytes ----+------- ��������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/jit.out��������������������������������������������������������0000664�0000000�0000000�00000021045�15100345067�0020756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; \set TEST_BASE_NAME jit SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('include/%s_cleanup.sql', :'TEST_BASE_NAME') as "TEST_CLEANUP_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset -- enable all jit optimizations SET jit=on; SET jit_above_cost=0; SET jit_inline_above_cost=0; SET jit_optimize_above_cost=0; SET jit_tuple_deforming=on; SET enable_hashagg=off; \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE jit_test(time timestamp NOT NULL, device int, temp float); SELECT create_hypertable('jit_test', 'time'); psql:include/jit_load.sql:6: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ----------------------- (1,public,jit_test,t) ALTER TABLE jit_test DROP COLUMN device; CREATE TABLE jit_test_interval(id int NOT NULL, temp float); SELECT create_hypertable('jit_test_interval', 'id', chunk_time_interval => 10); create_hypertable -------------------------------- (2,public,jit_test_interval,t) CREATE TABLE jit_test_contagg ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('jit_test_contagg', 'observation_time'); table_name ------------------ jit_test_contagg CREATE MATERIALIZED VIEW jit_device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 hour', observation_time) as bucket, device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM jit_test_contagg GROUP BY bucket, device_id WITH NO DATA; INSERT INTO jit_test_contagg SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO jit_test_contagg SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; CALL refresh_continuous_aggregate('jit_device_summary', NULL, NULL); \set PREFIX 'EXPLAIN (VERBOSE, TIMING OFF, BUFFERS OFF, COSTS OFF, SUMMARY OFF)' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- github issue #1262 -- :PREFIX INSERT INTO jit_test VALUES('2017-01-20T09:00:01', 22.5) RETURNING *; --- QUERY PLAN --- Custom Scan (ModifyHypertable) Output: jit_test."time", jit_test.temp -> Insert on public.jit_test Output: jit_test."time", jit_test.temp -> Result Output: 'Fri Jan 20 09:00:01 2017'::timestamp without time zone, NULL::integer, '22.5'::double precision :PREFIX INSERT INTO jit_test VALUES ('2017-01-20T09:00:02', 2), ('2017-01-20T09:00:03', 5), ('2017-01-20T09:00:04', 10); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Insert on public.jit_test -> Values Scan on "*VALUES*" Output: "*VALUES*".column1, NULL::integer, "*VALUES*".column2 :PREFIX SELECT * FROM jit_test WHERE temp > 5 and temp <= 10 ORDER BY time; --- QUERY PLAN --- Sort Output: "time", temp Sort Key: jit_test."time" -> Result Output: "time", temp One-Time Filter: false -- update with iteration over chunks -- :PREFIX INSERT INTO jit_test_interval (SELECT x, x / 2.3 FROM generate_series(0, 100) x) RETURNING *; --- QUERY PLAN --- Custom Scan (ModifyHypertable) Output: jit_test_interval.id, jit_test_interval.temp -> Insert on public.jit_test_interval Output: jit_test_interval.id, jit_test_interval.temp -> Function Scan on pg_catalog.generate_series x Output: x.x, ((x.x)::numeric / 2.3) Function Call: generate_series(0, 100) :PREFIX SELECT * FROM jit_test_interval WHERE id >= 23 and id < 73 ORDER BY id; --- QUERY PLAN --- Sort Output: id, temp Sort Key: jit_test_interval.id -> Result Output: id, temp One-Time Filter: false :PREFIX UPDATE jit_test_interval SET temp = temp * 2.3 WHERE id >= 23 and id < 73; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on public.jit_test_interval -> Index Scan using jit_test_interval_id_idx on public.jit_test_interval Output: (temp * '2.3'::double precision), ctid Index Cond: ((jit_test_interval.id >= 23) AND (jit_test_interval.id < 73)) :PREFIX SELECT * FROM jit_test_interval ORDER BY id; --- QUERY PLAN --- Sort Output: id, temp Sort Key: jit_test_interval.id -> Result Output: id, temp One-Time Filter: false :PREFIX SELECT time_bucket(10, id), avg(temp) FROM jit_test_interval GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- GroupAggregate Output: (time_bucket(10, id)), avg(temp) Group Key: (time_bucket(10, jit_test_interval.id)) -> Sort Output: (time_bucket(10, id)), temp Sort Key: (time_bucket(10, jit_test_interval.id)) -> Result Output: time_bucket(10, id), temp One-Time Filter: false -- test continuous aggregates usage with forced jit (based on continuous_aggs_usage.sql) -- :PREFIX SELECT * FROM jit_device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_4_6_chunk.bucket, _hyper_4_6_chunk.device_id, _hyper_4_6_chunk.metric_avg, _hyper_4_6_chunk.metric_spread -> Sort Output: _hyper_4_6_chunk.bucket, _hyper_4_6_chunk.device_id, _hyper_4_6_chunk.metric_avg, _hyper_4_6_chunk.metric_spread Sort Key: _hyper_4_6_chunk.bucket DESC, _hyper_4_6_chunk.device_id -> Append -> Index Scan using _hyper_4_6_chunk__materialized_hypertable_4_bucket_idx on _timescaledb_internal._hyper_4_6_chunk Output: _hyper_4_6_chunk.bucket, _hyper_4_6_chunk.device_id, _hyper_4_6_chunk.metric_avg, _hyper_4_6_chunk.metric_spread Index Cond: (_hyper_4_6_chunk.bucket < 'Mon Dec 31 01:00:00 2018 PST'::timestamp with time zone) Filter: (_hyper_4_6_chunk.metric_spread = '1800'::double precision) -> GroupAggregate Output: (time_bucket('@ 1 hour'::interval, _hyper_3_5_chunk.observation_time)), _hyper_3_5_chunk.device_id, avg(_hyper_3_5_chunk.metric), (max(_hyper_3_5_chunk.metric) - min(_hyper_3_5_chunk.metric)) Group Key: (time_bucket('@ 1 hour'::interval, _hyper_3_5_chunk.observation_time)), _hyper_3_5_chunk.device_id Filter: ((max(_hyper_3_5_chunk.metric) - min(_hyper_3_5_chunk.metric)) = '1800'::double precision) -> Sort Output: (time_bucket('@ 1 hour'::interval, _hyper_3_5_chunk.observation_time)), _hyper_3_5_chunk.device_id, _hyper_3_5_chunk.metric Sort Key: (time_bucket('@ 1 hour'::interval, _hyper_3_5_chunk.observation_time)), _hyper_3_5_chunk.device_id -> Result Output: time_bucket('@ 1 hour'::interval, _hyper_3_5_chunk.observation_time), _hyper_3_5_chunk.device_id, _hyper_3_5_chunk.metric -> Index Scan using _hyper_3_5_chunk_jit_test_contagg_observation_time_idx on _timescaledb_internal._hyper_3_5_chunk Output: _hyper_3_5_chunk.observation_time, _hyper_3_5_chunk.device_id, _hyper_3_5_chunk.metric Index Cond: (_hyper_3_5_chunk.observation_time >= 'Mon Dec 31 01:00:00 2018 PST'::timestamp with time zone) -- generate the results into two different files \set ECHO errors --TEST END-- �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/license_tsl.out������������������������������������������������0000664�0000000�0000000�00000000575�15100345067�0022501�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; SHOW timescaledb.license; timescaledb.license --------------------- timescale SELECT _timescaledb_functions.tsl_loaded(); tsl_loaded ------------ t �����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/merge_append_partially_compressed.out��������������������������0000664�0000000�0000000�00000313052�15100345067�0027125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this test checks the validity of the produced plans for partially compressed chunks -- when injecting query_pathkeys on top of the append -- path that combines the uncompressed and compressed parts of a chunk. -- We're testing the MergeAppend here which is not compatible with parallel plans. set max_parallel_workers_per_gather = 0; set timescaledb.enable_decompression_sorted_merge = off; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE ht_metrics_compressed(time timestamptz, device int, value float); SELECT create_hypertable('ht_metrics_compressed','time'); create_hypertable ------------------------------------ (1,public,ht_metrics_compressed,t) ALTER TABLE ht_metrics_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); INSERT INTO ht_metrics_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02 00:00:00+00'::timestamptz,'2020-01-18 00:00:00+00'::timestamptz,'6 hour') time, generate_series(1,3) device; SELECT compress_chunk(c) FROM show_chunks('ht_metrics_compressed') c; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk -- make them partially compressed INSERT INTO ht_metrics_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02 00:00:00+00'::timestamptz,'2020-01-18 00:00:00+00'::timestamptz,'9 hour') time, generate_series(1,3) device; VACUUM ANALYZE ht_metrics_compressed; SELECT tableoid::regclass, min(time), max(time) from ht_metrics_compressed group by 1 order by 2; tableoid | min | max ----------------------------------------+------------------------------+------------------------------ _timescaledb_internal._hyper_1_1_chunk | Wed Jan 01 16:00:00 2020 PST | Wed Jan 08 10:00:00 2020 PST _timescaledb_internal._hyper_1_2_chunk | Wed Jan 08 16:00:00 2020 PST | Wed Jan 15 13:00:00 2020 PST _timescaledb_internal._hyper_1_3_chunk | Wed Jan 15 16:00:00 2020 PST | Fri Jan 17 16:00:00 2020 PST SELECT show_chunks('ht_metrics_compressed') AS "CHUNK" LIMIT 1 \gset -- test UNION with partially compressed chunks :PREFIX SELECT * FROM :CHUNK UNION ALL SELECT * FROM :CHUNK; --- QUERY PLAN --- Append (actual rows=282.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=57.00 loops=1) :PREFIX SELECT * FROM :CHUNK UNION ALL SELECT * FROM :CHUNK ORDER BY time DESC; --- QUERY PLAN --- Sort (actual rows=282.00 loops=1) Sort Key: _hyper_1_1_chunk."time" DESC Sort Method: quicksort -> Append (actual rows=282.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=57.00 loops=1) :PREFIX SELECT device FROM :CHUNK UNION ALL SELECT device FROM :CHUNK ORDER BY device DESC; --- QUERY PLAN --- Merge Append (actual rows=282.00 loops=1) Sort Key: _hyper_1_1_chunk.device DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=84.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=57.00 loops=1) Sort Key: _hyper_1_1_chunk.device DESC Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=84.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_2_4_chunk_1.device DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=57.00 loops=1) Sort Key: _hyper_1_1_chunk_1.device DESC Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=57.00 loops=1) :PREFIX SELECT value FROM :CHUNK UNION ALL SELECT value FROM :CHUNK ORDER BY value DESC; --- QUERY PLAN --- Merge Append (actual rows=282.00 loops=1) Sort Key: _hyper_1_1_chunk.value DESC -> Sort (actual rows=84.00 loops=1) Sort Key: _hyper_1_1_chunk.value DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=57.00 loops=1) Sort Key: _hyper_1_1_chunk.value DESC Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) -> Sort (actual rows=84.00 loops=1) Sort Key: _hyper_1_1_chunk_1.value DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk compress_hyper_2_4_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=57.00 loops=1) Sort Key: _hyper_1_1_chunk_1.value DESC Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=57.00 loops=1) -- chunkAppend eligible queries (from tsbench) -- sort is not pushed down :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time DESC, device LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=1.00 loops=1) Order: ht_metrics_compressed."time" DESC, ht_metrics_compressed.device -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed."time" DESC, ht_metrics_compressed.device -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device Sort Method: top-N heapsort -> Seq Scan on _hyper_1_3_chunk (actual rows=15.00 loops=1) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC, ht_metrics_compressed.device -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device -> Seq Scan on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC, ht_metrics_compressed.device -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_2_4_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device -> Seq Scan on _hyper_1_1_chunk (never executed) :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time_bucket('1d', time) DESC, device LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, ht_metrics_compressed."time")) DESC, ht_metrics_compressed.device -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.device Sort Method: top-N heapsort -> Result (actual rows=84.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_1_chunk."time")) DESC, _hyper_1_1_chunk.device Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk."time")) DESC, _hyper_1_2_chunk.device Sort Method: top-N heapsort -> Result (actual rows=84.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=84.00 loops=1) -> Seq Scan on compress_hyper_2_5_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_2_chunk."time")) DESC, _hyper_1_2_chunk.device Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=57.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_3_chunk."time")) DESC, _hyper_1_3_chunk.device Sort Method: top-N heapsort -> Result (actual rows=27.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_1_3_chunk."time")) DESC, _hyper_1_3_chunk.device Sort Method: top-N heapsort -> Seq Scan on _hyper_1_3_chunk (actual rows=15.00 loops=1) :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time desc limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=10.00 loops=1) Order: ht_metrics_compressed."time" DESC -> Merge Append (actual rows=10.00 loops=1) Sort Key: ht_metrics_compressed."time" DESC -> Sort (actual rows=7.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_ht_metrics_compressed_time_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_ht_metrics_compressed_time_idx on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_2_4_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_ht_metrics_compressed_time_idx on _hyper_1_1_chunk (never executed) :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time_bucket('2d',time) DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 2 days'::interval, ht_metrics_compressed."time") DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 2 days'::interval, ht_metrics_compressed."time")) DESC -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 2 days'::interval, _hyper_1_3_chunk."time")) DESC Sort Method: top-N heapsort -> Result (actual rows=27.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_ht_metrics_compressed_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 2 days'::interval, ht_metrics_compressed."time")) DESC -> Sort (never executed) Sort Key: (time_bucket('@ 2 days'::interval, _hyper_1_2_chunk."time")) DESC -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Seq Scan on compress_hyper_2_5_chunk (never executed) -> Index Scan using _hyper_1_2_chunk_ht_metrics_compressed_time_idx on _hyper_1_2_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 2 days'::interval, ht_metrics_compressed."time")) DESC -> Sort (never executed) Sort Key: (time_bucket('@ 2 days'::interval, _hyper_1_1_chunk."time")) DESC -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_2_4_chunk (never executed) -> Index Scan using _hyper_1_1_chunk_ht_metrics_compressed_time_idx on _hyper_1_1_chunk (never executed) :PREFIX SELECT * FROM ht_metrics_compressed WHERE device IN (1,2,3) ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=1.00 loops=1) Order: ht_metrics_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=27.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Index Scan using _hyper_1_3_chunk_ht_metrics_compressed_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Seq Scan on compress_hyper_2_5_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Index Scan using _hyper_1_2_chunk_ht_metrics_compressed_time_idx on _hyper_1_2_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Seq Scan on compress_hyper_2_4_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Index Scan using _hyper_1_1_chunk_ht_metrics_compressed_time_idx on _hyper_1_1_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT * FROM ht_metrics_compressed WHERE device IN (1,2,3) ORDER BY time, device DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=1.00 loops=1) Order: ht_metrics_compressed."time", ht_metrics_compressed.device DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed."time", ht_metrics_compressed.device DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=84.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time", ht_metrics_compressed.device DESC -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device DESC -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Seq Scan on compress_hyper_2_5_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device DESC -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time", ht_metrics_compressed.device DESC -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device DESC -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Seq Scan on compress_hyper_2_6_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device DESC -> Seq Scan on _hyper_1_3_chunk (never executed) Filter: (device = ANY ('{1,2,3}'::integer[])) -- index scan, no sort on top :PREFIX SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time DESC LIMIT 1; -- index scan, no resorting required --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=1.00 loops=1) Order: ht_metrics_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (device = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_3_chunk_ht_metrics_compressed_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) Filter: (device = 3) -> Sort (never executed) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 DESC, compress_hyper_2_5_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_5_chunk (never executed) Filter: (device = 3) -> Index Scan using _hyper_1_2_chunk_ht_metrics_compressed_time_idx on _hyper_1_2_chunk (never executed) Filter: (device = 3) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) Filter: (device = 3) -> Sort (never executed) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 DESC, compress_hyper_2_4_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_4_chunk (never executed) Filter: (device = 3) -> Index Scan using _hyper_1_1_chunk_ht_metrics_compressed_time_idx on _hyper_1_1_chunk (never executed) Filter: (device = 3) SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time DESC LIMIT 1; time | device | value ------------------------------+--------+------- Fri Jan 17 16:00:00 2020 PST | 3 | 0.3 :PREFIX SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY device, time DESC LIMIT 1; -- this uses the index and does not do sort on top --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (device = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1 DESC, compress_hyper_2_4_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_1_chunk_ht_metrics_compressed_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (device = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1 DESC, compress_hyper_2_5_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_5_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_2_chunk_ht_metrics_compressed_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (device = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Index Scan using _hyper_1_3_chunk_ht_metrics_compressed_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY device, time DESC LIMIT 1; time | device | value ------------------------------+--------+------- Fri Jan 17 16:00:00 2020 PST | 3 | 0.3 :PREFIX SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time, device DESC LIMIT 1; -- this also uses the index and does not do sort on top --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on ht_metrics_compressed (actual rows=1.00 loops=1) Order: ht_metrics_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (device = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=1.00 loops=1) Filter: (device = 3) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_1_1_chunk_ht_metrics_compressed_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (device = 3) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) Filter: (device = 3) -> Sort (never executed) Sort Key: compress_hyper_2_5_chunk._ts_meta_min_1, compress_hyper_2_5_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_2_5_chunk (never executed) Filter: (device = 3) -> Index Scan Backward using _hyper_1_2_chunk_ht_metrics_compressed_time_idx on _hyper_1_2_chunk (never executed) Filter: (device = 3) -> Merge Append (never executed) Sort Key: ht_metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (device = 3) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1, compress_hyper_2_6_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_2_6_chunk (never executed) Filter: (device = 3) -> Index Scan Backward using _hyper_1_3_chunk_ht_metrics_compressed_time_idx on _hyper_1_3_chunk (never executed) Filter: (device = 3) SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time, device DESC LIMIT 1; time | device | value ------------------------------+--------+------- Wed Jan 01 16:00:00 2020 PST | 3 | 0.3 -- not eligible for chunkAppend, but eligible for sort pushdown :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY device, time DESC LIMIT 1; -- with pushdown --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed.device, ht_metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device, compress_hyper_2_4_chunk._ts_meta_min_1 DESC, compress_hyper_2_4_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_5_chunk.device, compress_hyper_2_5_chunk._ts_meta_min_1 DESC, compress_hyper_2_5_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_5_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device, _hyper_1_2_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=57.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_6_chunk.device, compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk.device, _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_3_chunk (actual rows=15.00 loops=1) :PREFIX SELECT * FROM ht_metrics_compressed WHERE device IN (1,2,3) ORDER BY device, time DESC LIMIT 1; -- with pushdown --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: ht_metrics_compressed.device, ht_metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device, compress_hyper_2_4_chunk._ts_meta_min_1 DESC, compress_hyper_2_4_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_5_chunk.device, compress_hyper_2_5_chunk._ts_meta_min_1 DESC, compress_hyper_2_5_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_5_chunk (actual rows=3.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device, _hyper_1_2_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=57.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_6_chunk.device, compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_6_chunk (actual rows=3.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_3_chunk.device, _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_3_chunk (actual rows=15.00 loops=1) Filter: (device = ANY ('{1,2,3}'::integer[])) -- Test direct ordered select from a single partially compressed chunk select * from show_chunks('ht_metrics_compressed') chunk order by chunk limit 1 \gset :PREFIX SELECT * FROM :chunk ORDER BY device, time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk.device, _hyper_1_1_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_1_1_chunk.device, _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) SELECT * FROM :chunk ORDER BY device, time LIMIT 5; time | device | value ------------------------------+--------+------- Wed Jan 01 16:00:00 2020 PST | 1 | 0.1 Wed Jan 01 16:00:00 2020 PST | 1 | 0.1 Wed Jan 01 22:00:00 2020 PST | 1 | 0.1 Thu Jan 02 01:00:00 2020 PST | 1 | 0.1 Thu Jan 02 04:00:00 2020 PST | 1 | 0.1 :PREFIX SELECT * FROM :chunk ORDER BY device DESC, time DESC LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk.device DESC, _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_4_chunk.device DESC, compress_hyper_2_4_chunk._ts_meta_min_1 DESC, compress_hyper_2_4_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_4_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_1_1_chunk.device DESC, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_1_chunk (actual rows=57.00 loops=1) SELECT * FROM :chunk ORDER BY device DESC, time DESC LIMIT 5; time | device | value ------------------------------+--------+------- Wed Jan 08 10:00:00 2020 PST | 3 | 0.3 Wed Jan 08 10:00:00 2020 PST | 3 | 0.3 Wed Jan 08 04:00:00 2020 PST | 3 | 0.3 Wed Jan 08 01:00:00 2020 PST | 3 | 0.3 Tue Jan 07 22:00:00 2020 PST | 3 | 0.3 CREATE TABLE test1 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test1', 'time'); -- ALTER TABLE test1 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'time DESC, x3 ASC, x4 ASC'); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); -- Insert some dummy rows to inflate the cost estimates to get it to actually -- use the MergeAppend. We will filter them out using the "x4 % 11 != 0" which -- thwarts the normal selectivity estimation. INSERT INTO test1 select '2000-01-01 04:00:00-00', /* x1 = */ 0, /* x2 = */ 0, /* x3 = */ 0, /* x4 = */ 11 * (11 + x), 0 from generate_series(1, 10000) x; SELECT compress_chunk(i) FROM show_chunks('test1') i; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_7_chunk -- make all the chunks partially compressed INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:01:00-00', 10, 20, 30, 40 ,50); ANALYZE test1; -- tests that require resorting (pushdown below decompressChunk node cannot happen) -- requires resorting, no pushdown can happen :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time" DESC -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" DESC -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Index Scan using _hyper_3_7_chunk_test1_time_idx on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -- requires resorting :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time" DESC, test1.x3 -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" DESC, test1.x3 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -- all these require resorting, no pushdown can happen :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 ASC NULLS LAST LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time" DESC, test1.x3, test1.x4 -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" DESC, test1.x3, test1.x4 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 DESC NULLS FIRST LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time" DESC, test1.x3, test1.x4 DESC -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" DESC, test1.x3, test1.x4 DESC -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS LAST LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time" -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Index Scan Backward using _hyper_3_7_chunk_test1_time_idx on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time", test1.x3 DESC -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time", test1.x3 DESC -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 DESC Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST, x4 DESC NULLS FIRST LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time", test1.x3 DESC, test1.x4 DESC -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time", test1.x3 DESC, test1.x4 DESC -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 DESC, _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 DESC, _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS FIRST, x3 DESC NULLS LAST, x4 ASC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time" NULLS FIRST, test1.x3 DESC NULLS LAST, test1.x4 -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time" NULLS FIRST, test1.x3 DESC NULLS LAST, test1.x4 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time" NULLS FIRST, _hyper_3_7_chunk.x3 DESC NULLS LAST, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time" NULLS FIRST, _hyper_3_7_chunk.x3 DESC NULLS LAST, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) set enable_hashagg to off; -- different on PG13 :PREFIX SELECT x1, x2, max(time) FROM (SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time, x1, x2 LIMIT 10) t GROUP BY x1, x2, time ORDER BY time limit 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: test1."time", test1.x1, test1.x2 -> Limit (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on test1 (actual rows=5.00 loops=1) Order: test1."time", test1.x1, test1.x2 -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1."time", test1.x1, test1.x2 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) reset enable_hashagg; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1.x4, test1."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk.x4, _hyper_3_7_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk.x4, _hyper_3_7_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x4 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time", test1.x4 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x3 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time", test1.x3 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x3, x4 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time", test1.x3, test1.x4 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x4 DESC LIMIT 10; -- no pushdown because orderby does not match --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time", test1.x4 DESC -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -- queries with pushdown :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time" -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_4_8_chunk.x1, compress_hyper_4_8_chunk.x2, compress_hyper_4_8_chunk.x5, compress_hyper_4_8_chunk._ts_meta_min_1, compress_hyper_4_8_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time DESC, x3 ASC, x4 ASC LIMIT 10; -- pushdown --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time" DESC, test1.x3, test1.x4 -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_4_8_chunk.x1, compress_hyper_4_8_chunk.x2, compress_hyper_4_8_chunk.x5, compress_hyper_4_8_chunk._ts_meta_min_1 DESC, compress_hyper_4_8_chunk._ts_meta_max_1 DESC, compress_hyper_4_8_chunk._ts_meta_min_2, compress_hyper_4_8_chunk._ts_meta_max_2, compress_hyper_4_8_chunk._ts_meta_min_3, compress_hyper_4_8_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time" DESC, _hyper_3_7_chunk.x3, _hyper_3_7_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time ASC, x3 DESC, x4 DESC LIMIT 10; -- pushdown --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time", test1.x3 DESC, test1.x4 DESC -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_4_8_chunk.x1, compress_hyper_4_8_chunk.x2, compress_hyper_4_8_chunk.x5, compress_hyper_4_8_chunk._ts_meta_min_1, compress_hyper_4_8_chunk._ts_meta_max_1, compress_hyper_4_8_chunk._ts_meta_min_2 DESC, compress_hyper_4_8_chunk._ts_meta_max_2 DESC, compress_hyper_4_8_chunk._ts_meta_min_3 DESC, compress_hyper_4_8_chunk._ts_meta_max_3 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 DESC, _hyper_3_7_chunk.x4 DESC Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x3 DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: test1.x1, test1.x2, test1.x5, test1."time", test1.x3 DESC -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_4_8_chunk.x1, compress_hyper_4_8_chunk.x2, compress_hyper_4_8_chunk.x5, compress_hyper_4_8_chunk._ts_meta_min_1, compress_hyper_4_8_chunk._ts_meta_max_1, compress_hyper_4_8_chunk._ts_meta_min_2 DESC, compress_hyper_4_8_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_7_chunk.x1, _hyper_3_7_chunk.x2, _hyper_3_7_chunk.x5, _hyper_3_7_chunk."time", _hyper_3_7_chunk.x3 DESC Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -- test append with join column in orderby -- #6975 CREATE TABLE join_table ( x1 integer, y1 float); INSERT INTO join_table VALUES (1, 1.0), (2,2.0); :PREFIX SELECT * FROM test1 t1 JOIN join_table jt ON t1.x1 = jt.x1 ORDER BY t1.x1, jt.y1; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: t1.x1, jt.y1 Sort Method: quicksort -> Hash Join (actual rows=4.00 loops=1) Hash Cond: (jt.x1 = t1.x1) -> Seq Scan on join_table jt (actual rows=2.00 loops=1) -> Hash (actual rows=10005.00 loops=1) -> Append (actual rows=10005.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk t1_1 (actual rows=10004.00 loops=1) -> Seq Scan on compress_hyper_4_8_chunk (actual rows=13.00 loops=1) -> Seq Scan on _hyper_3_7_chunk t1_1 (actual rows=1.00 loops=1) --------------------------------------------------------------------------- -- test queries without ordered append, but still eligible for sort pushdown --------------------------------------------------------------------------- CREATE TABLE test2 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test2', 'time'); -- ALTER TABLE test2 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'x3 ASC, x4 ASC'); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); -- chunk 2 INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:00:00-00', 1, 2, 5, 5, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 01:00:00-00', 1, 3, 6, 6, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 02:00:00-00', 2, 1, 7, 7, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 03:00:00-00', 1, 2, 8, 8, 0); -- Insert some dummy rows to inflate the cost estimates to get it to actually -- use the MergeAppend. We will filter them out using the "x4 % 11 != 0" which -- thwarts the normal selectivity estimation. INSERT INTO test2 select unnest(array['2000-01-01 04:00:00-00', '2000-01-10 04:00:00-00']::timestamptz[]), /* x1 = */ 0, /* x2 = */ 0, /* x3 = */ 0, /* x4 = */ 11 * (11 + x), 0 from generate_series(1, 10000) x; SELECT compress_chunk(i) FROM show_chunks('test2') i; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_9_chunk _timescaledb_internal._hyper_5_10_chunk -- make them partially compressed INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:02:01-00', 1, 2, 9, 9, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:02:01-00', 1, 2, 10, 10, 0); ANALYZE test2; set enable_indexscan = off; -- queries where sort is pushed down :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test2.x1, test2.x2, test2.x5, test2.x3 -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_6_11_chunk.x1, compress_hyper_6_11_chunk.x2, compress_hyper_6_11_chunk.x5, compress_hyper_6_11_chunk._ts_meta_min_1, compress_hyper_6_11_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_6_11_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x5, _hyper_5_9_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_5_9_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_5_10_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_6_12_chunk.x1, compress_hyper_6_12_chunk.x2, compress_hyper_6_12_chunk.x5, compress_hyper_6_12_chunk._ts_meta_min_1, compress_hyper_6_12_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_6_12_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x5, _hyper_5_10_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_5_10_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test2.x1, test2.x2, test2.x5, test2.x3, test2.x4 -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_6_11_chunk.x1, compress_hyper_6_11_chunk.x2, compress_hyper_6_11_chunk.x5, compress_hyper_6_11_chunk._ts_meta_min_1, compress_hyper_6_11_chunk._ts_meta_max_1, compress_hyper_6_11_chunk._ts_meta_min_2, compress_hyper_6_11_chunk._ts_meta_max_2 Sort Method: quicksort -> Seq Scan on compress_hyper_6_11_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x5, _hyper_5_9_chunk.x3, _hyper_5_9_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_5_9_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_5_10_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=13.00 loops=1) Sort Key: compress_hyper_6_12_chunk.x1, compress_hyper_6_12_chunk.x2, compress_hyper_6_12_chunk.x5, compress_hyper_6_12_chunk._ts_meta_min_1, compress_hyper_6_12_chunk._ts_meta_max_1, compress_hyper_6_12_chunk._ts_meta_min_2, compress_hyper_6_12_chunk._ts_meta_max_2 Sort Method: quicksort -> Seq Scan on compress_hyper_6_12_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x5, _hyper_5_10_chunk.x3, _hyper_5_10_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_5_10_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 -- queries where sort is not pushed down :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test2.x1, test2.x2, test2.x3 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_6_11_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_5_9_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_10_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_6_12_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_5_10_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test2.x1, test2.x2, test2.x5, test2.x4 -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x5, _hyper_5_9_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_6_11_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x5, _hyper_5_9_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_5_9_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x5, _hyper_5_10_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_10_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_6_12_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x5, _hyper_5_10_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_5_10_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test2.x1, test2.x2, test2.x5, test2."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x5, _hyper_5_9_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_6_11_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_9_chunk.x1, _hyper_5_9_chunk.x2, _hyper_5_9_chunk.x5, _hyper_5_9_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_5_9_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x5, _hyper_5_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_10_chunk (actual rows=4.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_6_12_chunk (actual rows=13.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_10_chunk.x1, _hyper_5_10_chunk.x2, _hyper_5_10_chunk.x5, _hyper_5_10_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_5_10_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 ----------------------------- -- tests with space partitioning ----------------------------- CREATE TABLE test3 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test3', 'time'); -- SELECT add_dimension('test3', 'x1', number_partitions => 2); add_dimension ----------------------- (5,public,test3,x1,t) ALTER TABLE test3 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'x3 ASC, x4 ASC'); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); -- chunk 2 INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:00:00-00', 1, 2, 5, 5, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 01:00:00-00', 1, 3, 6, 6, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 02:00:00-00', 2, 1, 7, 7, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 03:00:00-00', 1, 2, 8, 8, 0); -- Insert some dummy rows to inflate the cost estimates to get it to actually -- use the MergeAppend. We will filter them out using the "x4 % 11 != 0" which -- thwarts the normal selectivity estimation. INSERT INTO test3 select time, x1, /* x2 = */ 0, /* x3 = */ 0, /* x4 = */ 11 * (11 + x), 0 from generate_series(1, 10000) x, unnest(array['2000-01-01 04:00:00-00', '2000-01-10 04:00:00-00']::timestamptz[]) time, unnest(array[1, 2]::int[]) x1 ; SELECT compress_chunk(i) FROM show_chunks('test3') i; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk _timescaledb_internal._hyper_7_16_chunk -- make them partially compressed INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:02:01-00', 1, 2, 9, 9, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:02:01-00', 1, 2, 10, 10, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:02:01-00', 2, 2, 9, 9, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:02:01-00', 2, 2, 10, 10, 0); ANALYZE test3; set enable_indexscan = off; -- queries where sort is pushed down :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test3.x1, test3.x2, test3.x5, test3.x3 -> Custom Scan (ColumnarScan) on _hyper_7_13_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=12.00 loops=1) Sort Key: compress_hyper_8_17_chunk.x1, compress_hyper_8_17_chunk.x2, compress_hyper_8_17_chunk.x5, compress_hyper_8_17_chunk._ts_meta_min_1, compress_hyper_8_17_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_8_17_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x5, _hyper_7_13_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_13_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_8_18_chunk.x1, compress_hyper_8_18_chunk.x2, compress_hyper_8_18_chunk.x5, compress_hyper_8_18_chunk._ts_meta_min_1, compress_hyper_8_18_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_8_18_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x5, _hyper_7_14_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_7_15_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=12.00 loops=1) Sort Key: compress_hyper_8_19_chunk.x1, compress_hyper_8_19_chunk.x2, compress_hyper_8_19_chunk.x5, compress_hyper_8_19_chunk._ts_meta_min_1, compress_hyper_8_19_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_8_19_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x5, _hyper_7_15_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_15_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_8_20_chunk.x1, compress_hyper_8_20_chunk.x2, compress_hyper_8_20_chunk.x5, compress_hyper_8_20_chunk._ts_meta_min_1, compress_hyper_8_20_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_8_20_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x5, _hyper_7_16_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test3.x1, test3.x2, test3.x5, test3.x3, test3.x4 -> Custom Scan (ColumnarScan) on _hyper_7_13_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=12.00 loops=1) Sort Key: compress_hyper_8_17_chunk.x1, compress_hyper_8_17_chunk.x2, compress_hyper_8_17_chunk.x5, compress_hyper_8_17_chunk._ts_meta_min_1, compress_hyper_8_17_chunk._ts_meta_max_1, compress_hyper_8_17_chunk._ts_meta_min_2, compress_hyper_8_17_chunk._ts_meta_max_2 Sort Method: quicksort -> Seq Scan on compress_hyper_8_17_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x5, _hyper_7_13_chunk.x3, _hyper_7_13_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_13_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_8_18_chunk.x1, compress_hyper_8_18_chunk.x2, compress_hyper_8_18_chunk.x5, compress_hyper_8_18_chunk._ts_meta_min_1, compress_hyper_8_18_chunk._ts_meta_max_1, compress_hyper_8_18_chunk._ts_meta_min_2, compress_hyper_8_18_chunk._ts_meta_max_2 Sort Method: quicksort -> Seq Scan on compress_hyper_8_18_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x5, _hyper_7_14_chunk.x3, _hyper_7_14_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_7_15_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=12.00 loops=1) Sort Key: compress_hyper_8_19_chunk.x1, compress_hyper_8_19_chunk.x2, compress_hyper_8_19_chunk.x5, compress_hyper_8_19_chunk._ts_meta_min_1, compress_hyper_8_19_chunk._ts_meta_max_1, compress_hyper_8_19_chunk._ts_meta_min_2, compress_hyper_8_19_chunk._ts_meta_max_2 Sort Method: quicksort -> Seq Scan on compress_hyper_8_19_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x5, _hyper_7_15_chunk.x3, _hyper_7_15_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_15_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Custom Scan (ColumnarScan) on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_8_20_chunk.x1, compress_hyper_8_20_chunk.x2, compress_hyper_8_20_chunk.x5, compress_hyper_8_20_chunk._ts_meta_min_1, compress_hyper_8_20_chunk._ts_meta_max_1, compress_hyper_8_20_chunk._ts_meta_min_2, compress_hyper_8_20_chunk._ts_meta_max_2 Sort Method: quicksort -> Seq Scan on compress_hyper_8_20_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x5, _hyper_7_16_chunk.x3, _hyper_7_16_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 -- queries where sort is not pushed down :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test3.x1, test3.x2, test3.x3 -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_13_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_17_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_13_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_18_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_15_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_19_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_15_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x3 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_20_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x3 Sort Method: quicksort -> Seq Scan on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test3.x1, test3.x2, test3.x5, test3.x4 -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x5, _hyper_7_13_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_13_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_17_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x5, _hyper_7_13_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_13_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x5, _hyper_7_14_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_18_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x5, _hyper_7_14_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x5, _hyper_7_15_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_15_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_19_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x5, _hyper_7_15_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_15_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x5, _hyper_7_16_chunk.x4 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_20_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x5, _hyper_7_16_chunk.x4 Sort Method: quicksort -> Seq Scan on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: test3.x1, test3.x2, test3.x5, test3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x5, _hyper_7_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_13_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_17_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_13_chunk.x1, _hyper_7_13_chunk.x2, _hyper_7_13_chunk.x5, _hyper_7_13_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_7_13_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x5, _hyper_7_14_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_18_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_14_chunk.x1, _hyper_7_14_chunk.x2, _hyper_7_14_chunk.x5, _hyper_7_14_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_7_14_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x5, _hyper_7_15_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_15_chunk (actual rows=3.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_19_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_15_chunk.x1, _hyper_7_15_chunk.x2, _hyper_7_15_chunk.x5, _hyper_7_15_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_7_15_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x5, _hyper_7_16_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) Rows Removed by Filter: 10000 -> Seq Scan on compress_hyper_8_20_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_7_16_chunk.x1, _hyper_7_16_chunk.x2, _hyper_7_16_chunk.x5, _hyper_7_16_chunk."time" Sort Method: quicksort -> Seq Scan on _hyper_7_16_chunk (actual rows=1.00 loops=1) Filter: ((x4 % 11) <> 0) SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; time | x1 | x2 | x3 | x4 | x5 ------------------------------+----+----+----+----+---- Fri Dec 31 16:00:00 1999 PST | 1 | 2 | 1 | 1 | 0 Fri Dec 31 16:02:01 1999 PST | 1 | 2 | 9 | 9 | 0 Fri Dec 31 19:00:00 1999 PST | 1 | 2 | 4 | 4 | 0 Sun Jan 09 16:00:00 2000 PST | 1 | 2 | 5 | 5 | 0 Sun Jan 09 16:02:01 2000 PST | 1 | 2 | 10 | 10 | 0 Sun Jan 09 19:00:00 2000 PST | 1 | 2 | 8 | 8 | 0 Fri Dec 31 17:00:00 1999 PST | 1 | 3 | 2 | 2 | 0 Sun Jan 09 17:00:00 2000 PST | 1 | 3 | 6 | 6 | 0 Fri Dec 31 18:00:00 1999 PST | 2 | 1 | 3 | 3 | 0 Sun Jan 09 18:00:00 2000 PST | 2 | 1 | 7 | 7 | 0 reset enable_indexscan; -- test ordering on single chunk queries CREATE TABLE test4(time timestamptz not null, device text, value float); SELECT table_name FROM create_hypertable('test4','time',chunk_time_interval:='1 year'::interval); table_name ------------ test4 ALTER TABLE test4 SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); INSERT INTO test4 SELECT '2025-01-01', NULL, 0.1; INSERT INTO test4 SELECT '2025-01-02', NULL, 0.1; INSERT INTO test4 SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('test4') ch; count ------- 1 INSERT INTO test4 SELECT '2025-01-02', 'd', 0.1; VACUUM ANALYZE test4; set enable_hashagg TO false; SELECT time, device FROM _timescaledb_internal._hyper_9_21_chunk GROUP BY time, device; time | device ------------------------------+-------- Wed Jan 01 00:00:00 2025 PST | Thu Jan 02 00:00:00 2025 PST | d Thu Jan 02 00:00:00 2025 PST | EXPLAIN (buffers off, costs off, analyze, timing off, summary off) SELECT time, device FROM _timescaledb_internal._hyper_9_21_chunk GROUP BY time, device; --- QUERY PLAN --- Group (actual rows=3.00 loops=1) Group Key: _hyper_9_21_chunk."time", _hyper_9_21_chunk.device -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_9_21_chunk."time", _hyper_9_21_chunk.device Sort Method: quicksort -> Append (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_9_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on compress_hyper_10_22_chunk (actual rows=2.00 loops=1) -> Seq Scan on _hyper_9_21_chunk (actual rows=1.00 loops=1) reset timescaledb.enable_decompression_sorted_merge; reset max_parallel_workers_per_gather; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/merge_chunks.out�����������������������������������������������0000664�0000000�0000000�00000135770�15100345067�0022655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; set role :ROLE_DEFAULT_PERM_USER; -- A limitation in the tuple routing cache can lead to routing errors -- when multi-dimensional time partitions are not aligned. Therefore, -- multi-dimensional merges are disabled by default until the routing -- is fixed. However, allow it in this test. set timescaledb.enable_merge_multidim_chunks = true; ------------------ -- Helper views -- ------------------- create view partitions as select c.table_name, d.column_name, ds.range_start, ds.range_end from _timescaledb_catalog.hypertable h join _timescaledb_catalog.chunk c on (c.hypertable_id = h.id) join _timescaledb_catalog.dimension d on (d.hypertable_id = h.id) join _timescaledb_catalog.dimension_slice ds on (d.id = ds.dimension_id) join _timescaledb_catalog.chunk_constraint cc on (cc.chunk_id = c.id and cc.dimension_slice_id = ds.id) where h.table_name = 'mergeme' order by d.id, ds.range_start, ds.range_end; create view orphaned_slices as select ds.id, cc.constraint_name from _timescaledb_catalog.dimension_slice ds left join _timescaledb_catalog.chunk_constraint cc on (ds.id = cc.dimension_slice_id) where cc.constraint_name is null; ----------------- -- Setup table -- ----------------- create table mergeme (time timestamptz not null, device int, temp float); select create_hypertable('mergeme', 'time', 'device', 3, chunk_time_interval => interval '1 day'); create_hypertable ---------------------- (1,public,mergeme,t) -- Create helper view for chunk information create view chunk_info as select relname as chunk, amname as tam, pg_get_expr(conbin, ch) checkconstraint from pg_class cl join pg_am am on (cl.relam = am.oid) join show_chunks('mergeme') ch on (cl.oid = ch) join pg_constraint con on (con.conrelid = ch) where con.contype = 'c' order by 1,2,3 desc; -- -- Insert data to create two chunks with same time ranges like this: -- _______ -- | | -- | 1 | -- |_____| -- | | -- | 2 | -- |_____| --- insert into mergeme values ('2024-01-01', 1, 1.0), ('2024-01-01', 2, 2.0); -- Show chunks and check constraints select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | ((_timescaledb_functions.get_partition_hash(device) >= 715827882) AND (_timescaledb_functions.get_partition_hash(device) < 1431655764)) _hyper_1_2_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) -- Show partition layout select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+------------------ _hyper_1_1_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_2_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_2_chunk | device | 715827882 | 1431655764 -- Now merge chunk 1 and 2: begin; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); select * from _timescaledb_internal._hyper_1_1_chunk; time | device | temp ------------------------------+--------+------ Mon Jan 01 00:00:00 2024 PST | 1 | 1 Mon Jan 01 00:00:00 2024 PST | 2 | 2 select reltuples from pg_class where oid='_timescaledb_internal._hyper_1_1_chunk'::regclass; reltuples ----------- 2 select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+------------------ _hyper_1_1_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_1_chunk | device | -9223372036854775808 | 1431655764 select count(*) as num_orphaned_slices from orphaned_slices; num_orphaned_slices --------------------- 0 select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 1431655764) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) select * from mergeme; time | device | temp ------------------------------+--------+------ Mon Jan 01 00:00:00 2024 PST | 1 | 1 Mon Jan 01 00:00:00 2024 PST | 2 | 2 rollback; -- create a new chunk as a third space partition -- _______ -- | | -- | 1 | -- |_____| -- | | -- | 2 | -- |_____| -- | | -- | 3 | -- |_____| --- insert into mergeme values ('2024-01-01', 3, 3.0); -- Test some basic error cases \set ON_ERROR_STOP 0 -- Can't merge chunk 1 and 3 call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_3_chunk'); ERROR: cannot create new chunk partition boundaries call merge_chunks(NULL); ERROR: no chunks to merge specified call merge_chunks(NULL, NULL); ERROR: invalid relation call merge_chunks(999999,999991); ERROR: chunk does not exist call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk']); ERROR: must specify at least two chunks to merge call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', NULL); ERROR: invalid relation call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', NULL]); ERROR: invalid relation call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_1_chunk'); ERROR: duplicate relation "_hyper_1_1_chunk" in merge -- Check permissions reset role; set role :ROLE_1; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); ERROR: must be owner of table _hyper_1_1_chunk reset role; set role :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 -- Show new partition select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+--------------------- _hyper_1_1_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_2_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_3_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_2_chunk | device | 715827882 | 1431655764 _hyper_1_3_chunk | device | 1431655764 | 9223372036854775807 begin; -- Should be able to merge all three chunks call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk']); select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+--------------------- _hyper_1_1_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_1_chunk | device | -9223372036854775808 | 9223372036854775807 -- Note that no space partition CHECK constraint is added because it -- now covers the entire range from -inf to +inf. select count(*) as num_orphaned_slices from orphaned_slices; num_orphaned_slices --------------------- 0 select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) select * from mergeme; time | device | temp ------------------------------+--------+------ Mon Jan 01 00:00:00 2024 PST | 1 | 1 Mon Jan 01 00:00:00 2024 PST | 2 | 2 Mon Jan 01 00:00:00 2024 PST | 3 | 3 rollback; -- create two new chunks, 4 and 5, as follows: -- _____________ _______ -- | | | | | -- | 1 | 4 | | 5 | -- |_____|_____| |_____| -- | | -- | 2 | -- |_____| -- | | -- | 3 | -- |_____| --- insert into mergeme values ('2024-01-02', 1, 4.0), ('2024-01-04', 1, 5.0); -- Show new partitions select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+--------------------- _hyper_1_1_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_3_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_2_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_4_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_5_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_5_chunk | device | -9223372036854775808 | 715827882 _hyper_1_4_chunk | device | -9223372036854775808 | 715827882 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_2_chunk | device | 715827882 | 1431655764 _hyper_1_3_chunk | device | 1431655764 | 9223372036854775807 \set ON_ERROR_STOP 0 -- can't merge 3 and 4 call merge_chunks('_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_4_chunk'); ERROR: cannot create new chunk partition boundaries -- can't merge 1 and 5 call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_5_chunk'); ERROR: cannot create new chunk partition boundaries -- can't merge 2 and 4 call merge_chunks('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_4_chunk'); ERROR: cannot create new chunk partition boundaries -- can't merge 4 and 5 call merge_chunks('_timescaledb_internal._hyper_1_5_chunk', '_timescaledb_internal._hyper_1_4_chunk'); ERROR: cannot create new chunk partition boundaries -- currently can't merge 1,2,3,4 due to limitation in how we validate the merge call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_4_chunk', '_timescaledb_internal._hyper_1_1_chunk']); ERROR: cannot create new chunk partition boundaries begin; -- Should be able to merge all three chunks 1,2,3 call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_3_chunk']); -- But merging the merged 1,2,3 chunk with 4 is currently not -- possible, although we chould do it in theory call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_4_chunk'); ERROR: cannot create new chunk partition boundaries rollback; \set ON_ERROR_STOP 1 alter table mergeme set (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='device'); select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select compress_chunk('_timescaledb_internal._hyper_1_3_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_3_chunk -- Test merging compressed chunks begin; select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | ((_timescaledb_functions.get_partition_hash(device) >= 715827882) AND (_timescaledb_functions.get_partition_hash(device) < 1431655764)) _hyper_1_2_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | (_timescaledb_functions.get_partition_hash(device) >= 1431655764) _hyper_1_3_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) select * from _timescaledb_catalog.compression_chunk_size order by chunk_id; chunk_id | compressed_chunk_id | uncompressed_heap_size | uncompressed_toast_size | uncompressed_index_size | compressed_heap_size | compressed_toast_size | compressed_index_size | numrows_pre_compression | numrows_post_compression | numrows_frozen_immediately ----------+---------------------+------------------------+-------------------------+-------------------------+----------------------+-----------------------+-----------------------+-------------------------+--------------------------+---------------------------- 1 | 6 | 8192 | 0 | 32768 | 16384 | 8192 | 16384 | 1 | 1 | 1 3 | 7 | 8192 | 0 | 32768 | 16384 | 8192 | 16384 | 1 | 1 | 1 call merge_chunks('{_timescaledb_internal._hyper_1_1_chunk, _timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from _timescaledb_catalog.compression_chunk_size order by chunk_id; chunk_id | compressed_chunk_id | uncompressed_heap_size | uncompressed_toast_size | uncompressed_index_size | compressed_heap_size | compressed_toast_size | compressed_index_size | numrows_pre_compression | numrows_post_compression | numrows_frozen_immediately ----------+---------------------+------------------------+-------------------------+-------------------------+----------------------+-----------------------+-----------------------+-------------------------+--------------------------+---------------------------- 1 | 6 | 16384 | 0 | 65536 | 32768 | 16384 | 32768 | 2 | 2 | 2 select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) select count(*) as num_orphaned_slices from orphaned_slices; num_orphaned_slices --------------------- 0 select * from mergeme; time | device | temp ------------------------------+--------+------ Mon Jan 01 00:00:00 2024 PST | 1 | 1 Mon Jan 01 00:00:00 2024 PST | 3 | 3 Mon Jan 01 00:00:00 2024 PST | 2 | 2 Tue Jan 02 00:00:00 2024 PST | 1 | 4 Thu Jan 04 00:00:00 2024 PST | 1 | 5 rollback; -- Test mixing hypercore TAM with compression without TAM select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | ((_timescaledb_functions.get_partition_hash(device) >= 715827882) AND (_timescaledb_functions.get_partition_hash(device) < 1431655764)) _hyper_1_2_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | (_timescaledb_functions.get_partition_hash(device) >= 1431655764) _hyper_1_3_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) begin; select sum(temp) from mergeme; sum ----- 15 call merge_chunks('{_timescaledb_internal._hyper_1_1_chunk, _timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) select count(*) as num_orphaned_slices from orphaned_slices; num_orphaned_slices --------------------- 0 select sum(temp) from mergeme; sum ----- 15 rollback; select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | ((_timescaledb_functions.get_partition_hash(device) >= 715827882) AND (_timescaledb_functions.get_partition_hash(device) < 1431655764)) _hyper_1_2_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | (_timescaledb_functions.get_partition_hash(device) >= 1431655764) _hyper_1_3_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) -- Only Hypercore TAM and non-compressed chunks begin; select sum(temp) from mergeme; sum ----- 15 call merge_chunks('{_timescaledb_internal._hyper_1_1_chunk, _timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) select count(*) as num_orphaned_slices from orphaned_slices; num_orphaned_slices --------------------- 0 select sum(temp) from mergeme; sum ----- 15 -- Test that indexes work after merge set timescaledb.enable_columnarscan = false; set enable_seqscan = false; analyze mergeme; explain (buffers off, costs off) select * from mergeme where device = 1; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: (device = 1) -> Index Scan using compress_hyper_2_6_chunk_device__ts_meta_min_1__ts_meta_max_idx on compress_hyper_2_6_chunk Index Cond: (device = 1) -> Index Scan using _hyper_1_1_chunk_mergeme_device_time_idx on _hyper_1_1_chunk Index Cond: (device = 1) -> Index Scan using _hyper_1_4_chunk_mergeme_device_time_idx on _hyper_1_4_chunk Index Cond: (device = 1) -> Index Scan using _hyper_1_5_chunk_mergeme_device_time_idx on _hyper_1_5_chunk Index Cond: (device = 1) select * from mergeme where device = 1; time | device | temp ------------------------------+--------+------ Mon Jan 01 00:00:00 2024 PST | 1 | 1 Tue Jan 02 00:00:00 2024 PST | 1 | 4 Thu Jan 04 00:00:00 2024 PST | 1 | 5 select * from _timescaledb_internal._hyper_1_1_chunk where device = 1; time | device | temp ------------------------------+--------+------ Mon Jan 01 00:00:00 2024 PST | 1 | 1 reset timescaledb.enable_columnarscan; reset enable_seqscan; rollback; --- --- Merge hypercore TAM into compressed chunk without TAM --- begin; select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | ((_timescaledb_functions.get_partition_hash(device) >= 715827882) AND (_timescaledb_functions.get_partition_hash(device) < 1431655764)) _hyper_1_2_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | (_timescaledb_functions.get_partition_hash(device) >= 1431655764) _hyper_1_3_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) select compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk select sum(temp) from mergeme; sum ----- 15 call merge_chunks('{_timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | (_timescaledb_functions.get_partition_hash(device) >= 715827882) _hyper_1_2_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_4_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_4_chunk | heap | (("time" >= 'Mon Jan 01 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 02 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_5_chunk | heap | (_timescaledb_functions.get_partition_hash(device) < 715827882) _hyper_1_5_chunk | heap | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) select count(*) as num_orphaned_slices from orphaned_slices; num_orphaned_slices --------------------- 0 select sum(temp) from mergeme; sum ----- 15 rollback; --- -- Test some error cases when merging chunks with non-chunks or chunks -- from other hypertables --- -- Decompress all chunks to ensure we only have non-compressed chunks select decompress_chunk(ch) from show_chunks('mergeme') ch; NOTICE: chunk "_hyper_1_2_chunk" is not converted to columnstore NOTICE: chunk "_hyper_1_4_chunk" is not converted to columnstore NOTICE: chunk "_hyper_1_5_chunk" is not converted to columnstore decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk -- Create a non-chunk table create table mergeme_too(time timestamptz not null, device int, temp float); select create_hypertable('mergeme_too', 'time', 'device', 3, chunk_time_interval => interval '1 day'); create_hypertable -------------------------- (3,public,mergeme_too,t) create table mergeme_regular(time timestamptz not null, device int, temp float); insert into mergeme_too values ('2024-01-01', 1, 1.0); insert into mergeme_regular select * from mergeme_too; create materialized view mergeme_mat as select * from mergeme_too where device=1; select * from show_chunks('mergeme_too'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_3_9_chunk \set ON_ERROR_STOP 0 -- Merge chunk and regular table call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', 'mergeme_regular'); ERROR: can only merge hypertable chunks call merge_chunks('mergeme_regular', '_timescaledb_internal._hyper_1_1_chunk'); ERROR: can only merge hypertable chunks call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', 'mergeme_mat'); ERROR: cannot merge non-table relations -- Merge chunks from different hypertables call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_3_9_chunk'); ERROR: cannot merge chunks across different hypertables -- Merge with unsupported access method alter table _timescaledb_internal._hyper_1_1_chunk set access method testam; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); ERROR: access method "testam" is not supported for merge alter table _timescaledb_internal._hyper_1_1_chunk set access method heap; -- Merge OSM chunks reset role; update _timescaledb_catalog.chunk ch set osm_chunk = true where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); ERROR: cannot merge OSM chunks reset role; update _timescaledb_catalog.chunk ch set osm_chunk = false where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; -- Merge frozen chunks select _timescaledb_functions.freeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); freeze_chunk -------------- t call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); ERROR: cannot merge frozen chunk "_timescaledb_internal._hyper_1_1_chunk" scheduled for tiering call merge_chunks('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_1_chunk'); ERROR: cannot merge frozen chunk "_timescaledb_internal._hyper_1_1_chunk" scheduled for tiering select _timescaledb_functions.unfreeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); unfreeze_chunk ---------------- t \set ON_ERROR_STOP 1 -- Set seed to consistently generate same data and same set of chunks select setseed(0.2); setseed --------- -- Test merge with bigger data set and chunks with more blocks insert into mergeme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-01'::timestamptz, '2024-01-04', '0.5s') t; -- Compress two chunks, one using access method select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- Show partitions before merge select * from partitions; table_name | column_name | range_start | range_end -------------------+-------------+----------------------+--------------------- _hyper_1_1_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_3_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_2_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_11_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_10_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_4_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_12_chunk | time | 1704240000000000 | 1704326400000000 _hyper_1_14_chunk | time | 1704240000000000 | 1704326400000000 _hyper_1_13_chunk | time | 1704240000000000 | 1704326400000000 _hyper_1_16_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_5_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_15_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_4_chunk | device | -9223372036854775808 | 715827882 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_5_chunk | device | -9223372036854775808 | 715827882 _hyper_1_12_chunk | device | -9223372036854775808 | 715827882 _hyper_1_10_chunk | device | 715827882 | 1431655764 _hyper_1_2_chunk | device | 715827882 | 1431655764 _hyper_1_15_chunk | device | 715827882 | 1431655764 _hyper_1_13_chunk | device | 715827882 | 1431655764 _hyper_1_16_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_11_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_3_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_14_chunk | device | 1431655764 | 9223372036854775807 -- Show which chunks are compressed. Their compression_chunk_size -- metadata should be merged. select chunk_name from timescaledb_information.chunks where is_compressed=true order by chunk_name; chunk_name ------------------ _hyper_1_1_chunk -- -- Check that compression_chunk_size stats are also merged when we -- merge compressed chunks. -- -- Use a view to compare merged stats against the total sum of that -- stats for all chunks. There are only two compressed chunks, 1 and -- 2. Show each chunks stats as the fraction of the total size. This -- is to make the test work across different architectures that show -- slightly different absolute disk sizes. --- select sum(ccs.uncompressed_heap_size) as total_uncompressed_heap_size, sum(ccs.uncompressed_toast_size) as total_uncompressed_toast_size, sum(ccs.uncompressed_index_size) as total_uncompressed_index_size, sum(ccs.compressed_heap_size) as total_compressed_heap_size, sum(ccs.compressed_toast_size) as total_compressed_toast_size, sum(ccs.compressed_index_size) as total_compressed_index_size, sum(ccs.numrows_pre_compression) as total_numrows_pre_compression, sum(ccs.numrows_post_compression) as total_numrows_post_compression, sum(ccs.numrows_frozen_immediately) as total_numrows_frozen_immediately from _timescaledb_catalog.compression_chunk_size ccs \gset -- View to show current chunk compression size stats as a fraction of -- the totals. create view compression_size_fraction as select ccs.chunk_id, ccs.compressed_chunk_id, round(ccs.uncompressed_heap_size::numeric / :total_uncompressed_heap_size, 1) as uncompressed_heap_size_fraction, ccs.uncompressed_toast_size::numeric as uncompressed_toast_size_fraction, round(ccs.uncompressed_index_size::numeric / :total_uncompressed_index_size, 1) as uncompressed_index_size_fraction, round(ccs.compressed_heap_size::numeric / :total_compressed_heap_size, 1) as compressed_heap_size_fraction, round(ccs.compressed_toast_size::numeric / :total_compressed_toast_size, 1) as compressed_toast_size_fraction, round(ccs.compressed_index_size::numeric / :total_compressed_index_size, 1) as compressed_index_size_fraction, round(ccs.numrows_pre_compression ::numeric/ :total_numrows_pre_compression, 1) as numrows_pre_compression_fraction, round(ccs.numrows_post_compression::numeric / :total_numrows_post_compression, 1) as numrows_post_compression_fraction, round(ccs.numrows_frozen_immediately::numeric / :total_numrows_frozen_immediately, 1) as numrows_frozen_immediately_fraction from _timescaledb_catalog.compression_chunk_size ccs order by chunk_id; \set ON_ERROR_STOP 0 -- Test blocked multi-dimensional merges set timescaledb.enable_merge_multidim_chunks = false; call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_4_chunk','_timescaledb_internal._hyper_1_5_chunk', '_timescaledb_internal._hyper_1_12_chunk']); ERROR: cannot merge chunk in multi-dimensional hypertable set timescaledb.enable_merge_multidim_chunks = true; \set ON_ERROR_STOP 1 -- -- Merge all chunks until only 1 remains. Also check that metadata is -- merged. --- select * from compression_size_fraction; chunk_id | compressed_chunk_id | uncompressed_heap_size_fraction | uncompressed_toast_size_fraction | uncompressed_index_size_fraction | compressed_heap_size_fraction | compressed_toast_size_fraction | compressed_index_size_fraction | numrows_pre_compression_fraction | numrows_post_compression_fraction | numrows_frozen_immediately_fraction ----------+---------------------+---------------------------------+----------------------------------+----------------------------------+-------------------------------+--------------------------------+--------------------------------+----------------------------------+-----------------------------------+------------------------------------- 1 | 17 | 1.0 | 0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; count | sum | round --------+---------+--------------- 518406 | 2854401 | 10373952.7510 call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_4_chunk','_timescaledb_internal._hyper_1_5_chunk', '_timescaledb_internal._hyper_1_12_chunk']); select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; count | sum | round --------+---------+--------------- 518406 | 2854401 | 10373952.7510 select * from partitions; table_name | column_name | range_start | range_end -------------------+-------------+----------------------+--------------------- _hyper_1_2_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_3_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_1_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_11_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_10_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_13_chunk | time | 1704240000000000 | 1704326400000000 _hyper_1_14_chunk | time | 1704240000000000 | 1704326400000000 _hyper_1_16_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_15_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_13_chunk | device | 715827882 | 1431655764 _hyper_1_15_chunk | device | 715827882 | 1431655764 _hyper_1_10_chunk | device | 715827882 | 1431655764 _hyper_1_2_chunk | device | 715827882 | 1431655764 _hyper_1_3_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_16_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_11_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_14_chunk | device | 1431655764 | 9223372036854775807 call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_10_chunk','_timescaledb_internal._hyper_1_13_chunk', '_timescaledb_internal._hyper_1_15_chunk']); select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; count | sum | round --------+---------+--------------- 518406 | 2854401 | 10373952.7510 select * from partitions; table_name | column_name | range_start | range_end -------------------+-------------+----------------------+--------------------- _hyper_1_3_chunk | time | 1704067200000000 | 1704153600000000 _hyper_1_1_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_2_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_11_chunk | time | 1704153600000000 | 1704240000000000 _hyper_1_14_chunk | time | 1704240000000000 | 1704326400000000 _hyper_1_16_chunk | time | 1704326400000000 | 1704412800000000 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_2_chunk | device | 715827882 | 1431655764 _hyper_1_16_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_14_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_11_chunk | device | 1431655764 | 9223372036854775807 _hyper_1_3_chunk | device | 1431655764 | 9223372036854775807 call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_11_chunk','_timescaledb_internal._hyper_1_14_chunk', '_timescaledb_internal._hyper_1_16_chunk']); -- Final merge, involving the two compressed chunks 1 and 2. The stats -- should also be merged. select * from compression_size_fraction; chunk_id | compressed_chunk_id | uncompressed_heap_size_fraction | uncompressed_toast_size_fraction | uncompressed_index_size_fraction | compressed_heap_size_fraction | compressed_toast_size_fraction | compressed_index_size_fraction | numrows_pre_compression_fraction | numrows_post_compression_fraction | numrows_frozen_immediately_fraction ----------+---------------------+---------------------------------+----------------------------------+----------------------------------+-------------------------------+--------------------------------+--------------------------------+----------------------------------+-----------------------------------+------------------------------------- 1 | 17 | 1.0 | 0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; count | sum | round --------+---------+--------------- 518406 | 2854401 | 10373952.7510 select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+--------------------- _hyper_1_1_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_2_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_3_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_1_chunk | device | -9223372036854775808 | 715827882 _hyper_1_2_chunk | device | 715827882 | 1431655764 _hyper_1_3_chunk | device | 1431655764 | 9223372036854775807 call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_2_chunk']); select * from compression_size_fraction; chunk_id | compressed_chunk_id | uncompressed_heap_size_fraction | uncompressed_toast_size_fraction | uncompressed_index_size_fraction | compressed_heap_size_fraction | compressed_toast_size_fraction | compressed_index_size_fraction | numrows_pre_compression_fraction | numrows_post_compression_fraction | numrows_frozen_immediately_fraction ----------+---------------------+---------------------------------+----------------------------------+----------------------------------+-------------------------------+--------------------------------+--------------------------------+----------------------------------+-----------------------------------+------------------------------------- 1 | 17 | 1.0 | 0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 | 1.0 select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; count | sum | round --------+---------+--------------- 518406 | 2854401 | 10373952.7510 select * from partitions; table_name | column_name | range_start | range_end ------------------+-------------+----------------------+--------------------- _hyper_1_1_chunk | time | 1704067200000000 | 1704412800000000 _hyper_1_1_chunk | device | -9223372036854775808 | 9223372036854775807 select * from chunk_info; chunk | tam | checkconstraint ------------------+------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | (("time" >= 'Sun Dec 31 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 16:00:00 2024 PST'::timestamp with time zone)) ��������timescaledb-2.23.0/tsl/test/expected/merge_compress.out���������������������������������������������0000664�0000000�0000000�00000011142�15100345067�0023177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE target ( time TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL, partition_column TIMESTAMPTZ NOT NULL ); SELECT table_name FROM create_hypertable( 'target'::regclass, 'partition_column'::name, chunk_time_interval=>interval '8 hours', create_default_indexes=> false); table_name ------------ target -- enable compression ALTER TABLE target SET ( timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'partition_column, value' ); SELECT '2022-10-10 14:33:44.1234+05:30' as start_date \gset INSERT INTO target (series_id, value, partition_column) SELECT s,1,t from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '5m') t cross join generate_series(1,3, 1) s; -- compress chunks SELECT count(compress_chunk(ch)) FROM show_chunks('target') ch; count ------- 4 CREATE TABLE source ( time TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL ); SELECT table_name FROM create_hypertable( 'source'::regclass, 'time'::name, chunk_time_interval=>interval '6 hours', create_default_indexes=> false); table_name ------------ source SELECT '2022-10-10 10:00:00.0123+05:30' as start_date \gset INSERT INTO source (time, series_id, value) SELECT t, s,1 from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '5m') t cross join generate_series(1,2, 1) s; \set ON_ERROR_STOP 0 -- Merge UPDATE on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN UPDATE SET series_id = (t.series_id * 0.123); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- Merge DELETE on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN DELETE; ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- Merge UPDATE/INSERT on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN UPDATE SET series_id = (t.series_id * 0.123) WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, '2021-11-01 00:00:05'::timestamp with time zone); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- Merge DELETE/INSERT on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, '2021-11-01 00:00:05'::timestamp with time zone); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables \set ON_ERROR_STOP 1 -- total compressed chunks SELECT count(*) AS "total compressed_chunks", is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'target' GROUP BY is_compressed; total compressed_chunks | is_compressed -------------------------+--------------- 4 | t -- Merge INSERT on compressed hypertables should work MERGE INTO target t USING source s ON t.partition_column = s.time AND t.value = s.value WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, '2021-11-01 00:00:05'::timestamp with time zone); -- you should notice 1 uncompressed chunk SELECT count(*) AS "total compressed_chunks", is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'target' GROUP BY is_compressed; total compressed_chunks | is_compressed -------------------------+--------------- 1 | f 4 | t DROP TABLE target; DROP TABLE source; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/modify_exclusion-15.out����������������������������������������0000664�0000000�0000000�00000401776�15100345067�0024010�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (ANALYZE,VERBOSE,SUMMARY OFF,TIMING OFF,BUFFERS OFF, COSTS OFF)' \i include/modify_exclusion_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics_int2(c1 int,c2 int, c3 int, c4 int, c5 int, time int2 NOT NULL, value float, data text); CREATE TABLE metrics_int4(c1 int,c2 int, c3 int, c4 int, c5 int, time int4 NOT NULL, value float, data text); CREATE TABLE metrics_int8(c1 int,c2 int, c3 int, c4 int, c5 int, time int8 NOT NULL, value float, data text); CREATE TABLE metrics_date(c1 int,c2 int, c3 int, c4 int, c5 int, time date NOT NULL, value float, data text); CREATE TABLE metrics_timestamp(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, value float, data text); CREATE TABLE metrics_timestamptz(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, value float, data text); CREATE TABLE metrics_space(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, device text, value float, data text); SELECT table_name FROM create_hypertable('metrics_int2','time',chunk_time_interval:=10); table_name -------------- metrics_int2 SELECT table_name FROM create_hypertable('metrics_int4','time',chunk_time_interval:=10); table_name -------------- metrics_int4 SELECT table_name FROM create_hypertable('metrics_int8','time',chunk_time_interval:=10); table_name -------------- metrics_int8 SELECT table_name FROM create_hypertable('metrics_date','time'); table_name -------------- metrics_date SELECT table_name FROM create_hypertable('metrics_timestamp','time'); psql:include/modify_exclusion_load.sql:17: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------------- metrics_timestamp SELECT table_name FROM create_hypertable('metrics_timestamptz','time'); table_name --------------------- metrics_timestamptz SELECT table_name FROM create_hypertable('metrics_space','time','device',4); psql:include/modify_exclusion_load.sql:19: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name --------------- metrics_space CREATE FUNCTION drop_column(text) RETURNS VOID LANGUAGE PLPGSQL AS $$ DECLARE tbl name; BEGIN FOR tbl IN SELECT 'metrics_' || unnest(ARRAY['int2','int4','int8','date','timestamp','timestamptz','space']) LOOP EXECUTE format('ALTER TABLE %I DROP COLUMN %I;', tbl, $1); END LOOP; END; $$; -- create 4 chunks each with different physical layout SELECT drop_column('c1'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (0); INSERT INTO metrics_int4(time) VALUES (0); INSERT INTO metrics_int8(time) VALUES (0); INSERT INTO metrics_date(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2000-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2000-01-01','1'),('2000-01-01','2'); SELECT drop_column('c2'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (10); INSERT INTO metrics_int4(time) VALUES (10); INSERT INTO metrics_int8(time) VALUES (10); INSERT INTO metrics_date(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2001-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2001-01-01','1'),('2001-01-01','2'); SELECT drop_column('c3'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (20); INSERT INTO metrics_int4(time) VALUES (20); INSERT INTO metrics_int8(time) VALUES (20); INSERT INTO metrics_date(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2002-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2002-01-01','1'),('2002-01-01','2'); SELECT drop_column('c4'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (30); INSERT INTO metrics_int4(time) VALUES (30); INSERT INTO metrics_int8(time) VALUES (30); INSERT INTO metrics_date(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2003-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2003-01-01','1'),('2003-01-01','2'); SELECT drop_column('c5'); drop_column ------------- CREATE TABLE metrics_compressed(time timestamptz NOT NULL, device int, value float); SELECT table_name FROM create_hypertable('metrics_compressed','time'); table_name -------------------- metrics_compressed ALTER TABLE metrics_compressed SET (timescaledb.compress); -- create first chunk and compress INSERT INTO metrics_compressed VALUES ('2000-01-01',1,0.5); SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics_compressed') chunk; count ------- 1 -- create more chunks INSERT INTO metrics_compressed VALUES ('2010-01-01',1,0.5),('2011-01-01',1,0.5),('2012-01-01',1,0.5); -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX DELETE FROM metrics_int4 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX DELETE FROM metrics_int8 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int2_1.tableoid, metrics_int2_1.ctid -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX UPDATE metrics_int4 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int4_1.tableoid, metrics_int4_1.ctid -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX UPDATE metrics_int8 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int8_1.tableoid, metrics_int8_1.ctid -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int4 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int8 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int2.value), 'update'::text, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.value, metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.value, metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int4.value), 'update'::text, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.value, metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.value, metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int8.value), 'update'::text, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.value, metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.value, metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=0.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_date_1.tableoid, metrics_date_1.ctid -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX UPDATE metrics_timestamp SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_space_1.tableoid, metrics_space_1.ctid -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Result (actual rows=2.00 loops=1) Output: '0.6'::double precision, metrics_space.tableoid, metrics_space.ctid -> Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.9 WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.9 WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.9 WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- space partitioning -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_space WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space Update on _timescaledb_internal._hyper_7_16_chunk metrics_space Update on _timescaledb_internal._hyper_7_23_chunk metrics_space Update on _timescaledb_internal._hyper_7_24_chunk metrics_space Update on _timescaledb_internal._hyper_7_31_chunk metrics_space Update on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Result (actual rows=1.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Update on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Update on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Update on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Update on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Update on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Result (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Delete on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Delete on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Delete on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.2 WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Update on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.2 WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Update on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.2 WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Update on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- subselects -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; -- join -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; -- cte -- should all have chunkappend nodes BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) SELECT * FROM d; --- QUERY PLAN --- CTE Scan on d (actual rows=4.00 loops=1) Output: d."time" CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version())) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) SELECT * FROM u; --- QUERY PLAN --- CTE Scan on u (actual rows=4.00 loops=1) Output: u."time" CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update 1' WHERE m4.time < length(version())) UPDATE metrics_int2 m2 SET data = 'cte update 2' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 1'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 2'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) UPDATE metrics_int2 m2 SET data = 'cte update' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; -- test interaction with compression -- with chunk exclusion for compressed chunks operations that would -- error because they hit compressed chunks before can succeed now -- if those chunks get excluded -- delete from uncompressed chunks with non-immutable constraints BEGIN; :PREFIX DELETE FROM metrics_compressed WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_compressed (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Delete on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Delete on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Delete on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- update uncompressed chunks with non-immutable constraints BEGIN; :PREFIX UPDATE metrics_compressed SET value = 2 * value WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_compressed (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Update on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Update on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Update on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Result (actual rows=3.00 loops=1) Output: ('2'::double precision * metrics_compressed.value), metrics_compressed.tableoid, metrics_compressed.ctid -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Output: metrics_compressed.value, metrics_compressed.tableoid, metrics_compressed.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.value, metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.value, metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.value, metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; ��timescaledb-2.23.0/tsl/test/expected/modify_exclusion-16.out����������������������������������������0000664�0000000�0000000�00000401776�15100345067�0024011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (ANALYZE,VERBOSE,SUMMARY OFF,TIMING OFF,BUFFERS OFF, COSTS OFF)' \i include/modify_exclusion_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics_int2(c1 int,c2 int, c3 int, c4 int, c5 int, time int2 NOT NULL, value float, data text); CREATE TABLE metrics_int4(c1 int,c2 int, c3 int, c4 int, c5 int, time int4 NOT NULL, value float, data text); CREATE TABLE metrics_int8(c1 int,c2 int, c3 int, c4 int, c5 int, time int8 NOT NULL, value float, data text); CREATE TABLE metrics_date(c1 int,c2 int, c3 int, c4 int, c5 int, time date NOT NULL, value float, data text); CREATE TABLE metrics_timestamp(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, value float, data text); CREATE TABLE metrics_timestamptz(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, value float, data text); CREATE TABLE metrics_space(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, device text, value float, data text); SELECT table_name FROM create_hypertable('metrics_int2','time',chunk_time_interval:=10); table_name -------------- metrics_int2 SELECT table_name FROM create_hypertable('metrics_int4','time',chunk_time_interval:=10); table_name -------------- metrics_int4 SELECT table_name FROM create_hypertable('metrics_int8','time',chunk_time_interval:=10); table_name -------------- metrics_int8 SELECT table_name FROM create_hypertable('metrics_date','time'); table_name -------------- metrics_date SELECT table_name FROM create_hypertable('metrics_timestamp','time'); psql:include/modify_exclusion_load.sql:17: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------------- metrics_timestamp SELECT table_name FROM create_hypertable('metrics_timestamptz','time'); table_name --------------------- metrics_timestamptz SELECT table_name FROM create_hypertable('metrics_space','time','device',4); psql:include/modify_exclusion_load.sql:19: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name --------------- metrics_space CREATE FUNCTION drop_column(text) RETURNS VOID LANGUAGE PLPGSQL AS $$ DECLARE tbl name; BEGIN FOR tbl IN SELECT 'metrics_' || unnest(ARRAY['int2','int4','int8','date','timestamp','timestamptz','space']) LOOP EXECUTE format('ALTER TABLE %I DROP COLUMN %I;', tbl, $1); END LOOP; END; $$; -- create 4 chunks each with different physical layout SELECT drop_column('c1'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (0); INSERT INTO metrics_int4(time) VALUES (0); INSERT INTO metrics_int8(time) VALUES (0); INSERT INTO metrics_date(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2000-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2000-01-01','1'),('2000-01-01','2'); SELECT drop_column('c2'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (10); INSERT INTO metrics_int4(time) VALUES (10); INSERT INTO metrics_int8(time) VALUES (10); INSERT INTO metrics_date(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2001-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2001-01-01','1'),('2001-01-01','2'); SELECT drop_column('c3'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (20); INSERT INTO metrics_int4(time) VALUES (20); INSERT INTO metrics_int8(time) VALUES (20); INSERT INTO metrics_date(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2002-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2002-01-01','1'),('2002-01-01','2'); SELECT drop_column('c4'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (30); INSERT INTO metrics_int4(time) VALUES (30); INSERT INTO metrics_int8(time) VALUES (30); INSERT INTO metrics_date(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2003-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2003-01-01','1'),('2003-01-01','2'); SELECT drop_column('c5'); drop_column ------------- CREATE TABLE metrics_compressed(time timestamptz NOT NULL, device int, value float); SELECT table_name FROM create_hypertable('metrics_compressed','time'); table_name -------------------- metrics_compressed ALTER TABLE metrics_compressed SET (timescaledb.compress); -- create first chunk and compress INSERT INTO metrics_compressed VALUES ('2000-01-01',1,0.5); SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics_compressed') chunk; count ------- 1 -- create more chunks INSERT INTO metrics_compressed VALUES ('2010-01-01',1,0.5),('2011-01-01',1,0.5),('2012-01-01',1,0.5); -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX DELETE FROM metrics_int4 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX DELETE FROM metrics_int8 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int2_1.tableoid, metrics_int2_1.ctid -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX UPDATE metrics_int4 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int4_1.tableoid, metrics_int4_1.ctid -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX UPDATE metrics_int8 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int8_1.tableoid, metrics_int8_1.ctid -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int4 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int8 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int2.value), 'update'::text, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.value, metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.value, metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int4.value), 'update'::text, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.value, metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.value, metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int8.value), 'update'::text, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.value, metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.value, metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=0.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_date_1.tableoid, metrics_date_1.ctid -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX UPDATE metrics_timestamp SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_space_1.tableoid, metrics_space_1.ctid -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Result (actual rows=2.00 loops=1) Output: '0.6'::double precision, metrics_space.tableoid, metrics_space.ctid -> Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.9 WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.9 WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.9 WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- space partitioning -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_space WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space Update on _timescaledb_internal._hyper_7_16_chunk metrics_space Update on _timescaledb_internal._hyper_7_23_chunk metrics_space Update on _timescaledb_internal._hyper_7_24_chunk metrics_space Update on _timescaledb_internal._hyper_7_31_chunk metrics_space Update on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Result (actual rows=1.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Update on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Update on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Update on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Update on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Update on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Result (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Delete on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Delete on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Delete on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.2 WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Update on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.2 WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Update on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.2 WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Update on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- subselects -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; -- join -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; -- cte -- should all have chunkappend nodes BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) SELECT * FROM d; --- QUERY PLAN --- CTE Scan on d (actual rows=4.00 loops=1) Output: d."time" CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version())) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) SELECT * FROM u; --- QUERY PLAN --- CTE Scan on u (actual rows=4.00 loops=1) Output: u."time" CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update 1' WHERE m4.time < length(version())) UPDATE metrics_int2 m2 SET data = 'cte update 2' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 1'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 2'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) UPDATE metrics_int2 m2 SET data = 'cte update' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; -- test interaction with compression -- with chunk exclusion for compressed chunks operations that would -- error because they hit compressed chunks before can succeed now -- if those chunks get excluded -- delete from uncompressed chunks with non-immutable constraints BEGIN; :PREFIX DELETE FROM metrics_compressed WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_compressed (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Delete on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Delete on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Delete on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- update uncompressed chunks with non-immutable constraints BEGIN; :PREFIX UPDATE metrics_compressed SET value = 2 * value WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_compressed (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Update on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Update on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Update on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Result (actual rows=3.00 loops=1) Output: ('2'::double precision * metrics_compressed.value), metrics_compressed.tableoid, metrics_compressed.ctid -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Output: metrics_compressed.value, metrics_compressed.tableoid, metrics_compressed.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.value, metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.value, metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.value, metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; ��timescaledb-2.23.0/tsl/test/expected/modify_exclusion-17.out����������������������������������������0000664�0000000�0000000�00000401776�15100345067�0024012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (ANALYZE,VERBOSE,SUMMARY OFF,TIMING OFF,BUFFERS OFF, COSTS OFF)' \i include/modify_exclusion_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics_int2(c1 int,c2 int, c3 int, c4 int, c5 int, time int2 NOT NULL, value float, data text); CREATE TABLE metrics_int4(c1 int,c2 int, c3 int, c4 int, c5 int, time int4 NOT NULL, value float, data text); CREATE TABLE metrics_int8(c1 int,c2 int, c3 int, c4 int, c5 int, time int8 NOT NULL, value float, data text); CREATE TABLE metrics_date(c1 int,c2 int, c3 int, c4 int, c5 int, time date NOT NULL, value float, data text); CREATE TABLE metrics_timestamp(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, value float, data text); CREATE TABLE metrics_timestamptz(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, value float, data text); CREATE TABLE metrics_space(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, device text, value float, data text); SELECT table_name FROM create_hypertable('metrics_int2','time',chunk_time_interval:=10); table_name -------------- metrics_int2 SELECT table_name FROM create_hypertable('metrics_int4','time',chunk_time_interval:=10); table_name -------------- metrics_int4 SELECT table_name FROM create_hypertable('metrics_int8','time',chunk_time_interval:=10); table_name -------------- metrics_int8 SELECT table_name FROM create_hypertable('metrics_date','time'); table_name -------------- metrics_date SELECT table_name FROM create_hypertable('metrics_timestamp','time'); psql:include/modify_exclusion_load.sql:17: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------------- metrics_timestamp SELECT table_name FROM create_hypertable('metrics_timestamptz','time'); table_name --------------------- metrics_timestamptz SELECT table_name FROM create_hypertable('metrics_space','time','device',4); psql:include/modify_exclusion_load.sql:19: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name --------------- metrics_space CREATE FUNCTION drop_column(text) RETURNS VOID LANGUAGE PLPGSQL AS $$ DECLARE tbl name; BEGIN FOR tbl IN SELECT 'metrics_' || unnest(ARRAY['int2','int4','int8','date','timestamp','timestamptz','space']) LOOP EXECUTE format('ALTER TABLE %I DROP COLUMN %I;', tbl, $1); END LOOP; END; $$; -- create 4 chunks each with different physical layout SELECT drop_column('c1'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (0); INSERT INTO metrics_int4(time) VALUES (0); INSERT INTO metrics_int8(time) VALUES (0); INSERT INTO metrics_date(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2000-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2000-01-01','1'),('2000-01-01','2'); SELECT drop_column('c2'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (10); INSERT INTO metrics_int4(time) VALUES (10); INSERT INTO metrics_int8(time) VALUES (10); INSERT INTO metrics_date(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2001-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2001-01-01','1'),('2001-01-01','2'); SELECT drop_column('c3'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (20); INSERT INTO metrics_int4(time) VALUES (20); INSERT INTO metrics_int8(time) VALUES (20); INSERT INTO metrics_date(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2002-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2002-01-01','1'),('2002-01-01','2'); SELECT drop_column('c4'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (30); INSERT INTO metrics_int4(time) VALUES (30); INSERT INTO metrics_int8(time) VALUES (30); INSERT INTO metrics_date(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2003-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2003-01-01','1'),('2003-01-01','2'); SELECT drop_column('c5'); drop_column ------------- CREATE TABLE metrics_compressed(time timestamptz NOT NULL, device int, value float); SELECT table_name FROM create_hypertable('metrics_compressed','time'); table_name -------------------- metrics_compressed ALTER TABLE metrics_compressed SET (timescaledb.compress); -- create first chunk and compress INSERT INTO metrics_compressed VALUES ('2000-01-01',1,0.5); SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics_compressed') chunk; count ------- 1 -- create more chunks INSERT INTO metrics_compressed VALUES ('2010-01-01',1,0.5),('2011-01-01',1,0.5),('2012-01-01',1,0.5); -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX DELETE FROM metrics_int4 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX DELETE FROM metrics_int8 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int2_1.tableoid, metrics_int2_1.ctid -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX UPDATE metrics_int4 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int4_1.tableoid, metrics_int4_1.ctid -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX UPDATE metrics_int8 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int8_1.tableoid, metrics_int8_1.ctid -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int4 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int8 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Delete on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int2.value), 'update'::text, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.value, metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.value, metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int4.value), 'update'::text, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.value, metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1.value, metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), "time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, "time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int8.value), 'update'::text, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.value, metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=1.00 loops=1) Output: metrics_int8_1.value, metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 20))) ROLLBACK; -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=0.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_date_1.tableoid, metrics_date_1.ctid -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX UPDATE metrics_timestamp SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_space_1.tableoid, metrics_space_1.ctid -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Result (actual rows=2.00 loops=1) Output: '0.6'::double precision, metrics_space.tableoid, metrics_space.ctid -> Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.9 WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.9 WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.9 WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- space partitioning -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_space WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space Update on _timescaledb_internal._hyper_7_16_chunk metrics_space Update on _timescaledb_internal._hyper_7_23_chunk metrics_space Update on _timescaledb_internal._hyper_7_24_chunk metrics_space Update on _timescaledb_internal._hyper_7_31_chunk metrics_space Update on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Result (actual rows=1.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Update on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Update on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Update on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Update on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Update on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Result (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Delete on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Delete on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Delete on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.2 WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Update on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.2 WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Update on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.2 WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Update on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- subselects -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; -- join -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; -- cte -- should all have chunkappend nodes BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) SELECT * FROM d; --- QUERY PLAN --- CTE Scan on d (actual rows=4.00 loops=1) Output: d."time" CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version())) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) SELECT * FROM u; --- QUERY PLAN --- CTE Scan on u (actual rows=4.00 loops=1) Output: u."time" CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update 1' WHERE m4.time < length(version())) UPDATE metrics_int2 m2 SET data = 'cte update 2' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 1'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 2'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) UPDATE metrics_int2 m2 SET data = 'cte update' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; -- test interaction with compression -- with chunk exclusion for compressed chunks operations that would -- error because they hit compressed chunks before can succeed now -- if those chunks get excluded -- delete from uncompressed chunks with non-immutable constraints BEGIN; :PREFIX DELETE FROM metrics_compressed WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_compressed (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Delete on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Delete on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Delete on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- update uncompressed chunks with non-immutable constraints BEGIN; :PREFIX UPDATE metrics_compressed SET value = 2 * value WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_compressed (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Update on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Update on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Update on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Result (actual rows=3.00 loops=1) Output: ('2'::double precision * metrics_compressed.value), metrics_compressed.tableoid, metrics_compressed.ctid -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Output: metrics_compressed.value, metrics_compressed.tableoid, metrics_compressed.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.value, metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.value, metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.value, metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; ��timescaledb-2.23.0/tsl/test/expected/modify_exclusion-18.out����������������������������������������0000664�0000000�0000000�00000402436�15100345067�0024005�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (ANALYZE,VERBOSE,SUMMARY OFF,TIMING OFF,BUFFERS OFF, COSTS OFF)' \i include/modify_exclusion_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics_int2(c1 int,c2 int, c3 int, c4 int, c5 int, time int2 NOT NULL, value float, data text); CREATE TABLE metrics_int4(c1 int,c2 int, c3 int, c4 int, c5 int, time int4 NOT NULL, value float, data text); CREATE TABLE metrics_int8(c1 int,c2 int, c3 int, c4 int, c5 int, time int8 NOT NULL, value float, data text); CREATE TABLE metrics_date(c1 int,c2 int, c3 int, c4 int, c5 int, time date NOT NULL, value float, data text); CREATE TABLE metrics_timestamp(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, value float, data text); CREATE TABLE metrics_timestamptz(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, value float, data text); CREATE TABLE metrics_space(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, device text, value float, data text); SELECT table_name FROM create_hypertable('metrics_int2','time',chunk_time_interval:=10); table_name -------------- metrics_int2 SELECT table_name FROM create_hypertable('metrics_int4','time',chunk_time_interval:=10); table_name -------------- metrics_int4 SELECT table_name FROM create_hypertable('metrics_int8','time',chunk_time_interval:=10); table_name -------------- metrics_int8 SELECT table_name FROM create_hypertable('metrics_date','time'); table_name -------------- metrics_date SELECT table_name FROM create_hypertable('metrics_timestamp','time'); psql:include/modify_exclusion_load.sql:17: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name ------------------- metrics_timestamp SELECT table_name FROM create_hypertable('metrics_timestamptz','time'); table_name --------------------- metrics_timestamptz SELECT table_name FROM create_hypertable('metrics_space','time','device',4); psql:include/modify_exclusion_load.sql:19: WARNING: column type "timestamp without time zone" used for "time" does not follow best practices table_name --------------- metrics_space CREATE FUNCTION drop_column(text) RETURNS VOID LANGUAGE PLPGSQL AS $$ DECLARE tbl name; BEGIN FOR tbl IN SELECT 'metrics_' || unnest(ARRAY['int2','int4','int8','date','timestamp','timestamptz','space']) LOOP EXECUTE format('ALTER TABLE %I DROP COLUMN %I;', tbl, $1); END LOOP; END; $$; -- create 4 chunks each with different physical layout SELECT drop_column('c1'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (0); INSERT INTO metrics_int4(time) VALUES (0); INSERT INTO metrics_int8(time) VALUES (0); INSERT INTO metrics_date(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2000-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2000-01-01','1'),('2000-01-01','2'); SELECT drop_column('c2'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (10); INSERT INTO metrics_int4(time) VALUES (10); INSERT INTO metrics_int8(time) VALUES (10); INSERT INTO metrics_date(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2001-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2001-01-01','1'),('2001-01-01','2'); SELECT drop_column('c3'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (20); INSERT INTO metrics_int4(time) VALUES (20); INSERT INTO metrics_int8(time) VALUES (20); INSERT INTO metrics_date(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2002-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2002-01-01','1'),('2002-01-01','2'); SELECT drop_column('c4'); drop_column ------------- INSERT INTO metrics_int2(time) VALUES (30); INSERT INTO metrics_int4(time) VALUES (30); INSERT INTO metrics_int8(time) VALUES (30); INSERT INTO metrics_date(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2003-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2003-01-01','1'),('2003-01-01','2'); SELECT drop_column('c5'); drop_column ------------- CREATE TABLE metrics_compressed(time timestamptz NOT NULL, device int, value float); SELECT table_name FROM create_hypertable('metrics_compressed','time'); table_name -------------------- metrics_compressed ALTER TABLE metrics_compressed SET (timescaledb.compress); -- create first chunk and compress INSERT INTO metrics_compressed VALUES ('2000-01-01',1,0.5); SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics_compressed') chunk; count ------- 1 -- create more chunks INSERT INTO metrics_compressed VALUES ('2010-01-01',1,0.5),('2011-01-01',1,0.5),('2012-01-01',1,0.5); -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX DELETE FROM metrics_int4 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX DELETE FROM metrics_int8 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int2_1.tableoid, metrics_int2_1.ctid -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = 15) :PREFIX UPDATE metrics_int4 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int4_1.tableoid, metrics_int4_1.ctid -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = 15) :PREFIX UPDATE metrics_int8 SET value = 0.5 WHERE time = 15; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 -> Result (actual rows=0.00 loops=1) Output: '0.5'::double precision, metrics_int8_1.tableoid, metrics_int8_1.ctid -> Index Scan using _hyper_3_11_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_11_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = 15) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int8 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=0.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_1 (actual rows=0.00 loops=1) Output: metrics_int2_1.tableoid, metrics_int2_1.ctid Index Cond: (metrics_int2_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int4 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=0.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_1 (actual rows=0.00 loops=1) Output: metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" = length("substring"(version(), 1, 23))) :PREFIX UPDATE metrics_int8 SET value = 0.3 WHERE time = length(substring(version(),1,23)); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int8 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=0.00 loops=1) Output: '0.3'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=0.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_1 (actual rows=0.00 loops=1) Output: metrics_int8_1.tableoid, metrics_int8_1.ctid Index Cond: (metrics_int8_1."time" = length("substring"(version(), 1, 23))) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int2_1."time" -> Delete on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int2_1."time" Delete on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 Delete on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Delete on _timescaledb_internal._hyper_1_17_chunk metrics_int2_2 Delete on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.tableoid, metrics_int2_2.ctid Index Cond: (metrics_int2_2."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int4_1."time" -> Delete on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" = length("substring"(version(), 1, 20))) :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int8_1."time" -> Delete on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int8_1."time" Delete on _timescaledb_internal._hyper_3_3_chunk metrics_int8_1 Delete on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Delete on _timescaledb_internal._hyper_3_19_chunk metrics_int8_2 Delete on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_2 (actual rows=1.00 loops=1) Output: metrics_int8_2.tableoid, metrics_int8_2.ctid Index Cond: (metrics_int8_2."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int2_1."time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int2_1."time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_2 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.tableoid, metrics_int2_2.ctid Index Cond: (metrics_int2_2."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int4_1."time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int8_1."time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int8_1."time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_2 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: '0.4'::double precision, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_2 (actual rows=1.00 loops=1) Output: metrics_int8_2.tableoid, metrics_int8_2.ctid Index Cond: (metrics_int8_2."time" = length("substring"(version(), 1, 20))) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int2_1."time" -> Update on public.metrics_int2 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int2_1."time" Update on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 Update on _timescaledb_internal._hyper_1_9_chunk metrics_int2 Update on _timescaledb_internal._hyper_1_17_chunk metrics_int2_2 Update on _timescaledb_internal._hyper_1_25_chunk metrics_int2 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int2.value), 'update'::text, metrics_int2.tableoid, metrics_int2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 (actual rows=1.00 loops=1) Output: metrics_int2.value, metrics_int2.tableoid, metrics_int2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.value, metrics_int2_2.tableoid, metrics_int2_2.ctid Index Cond: (metrics_int2_2."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int4 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int4_1."time" -> Update on public.metrics_int4 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int4.value), 'update'::text, metrics_int4.tableoid, metrics_int4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 (actual rows=1.00 loops=1) Output: metrics_int4.value, metrics_int4.tableoid, metrics_int4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2.value, metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" = length("substring"(version(), 1, 20))) :PREFIX UPDATE metrics_int8 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_int8_1."time" -> Update on public.metrics_int8 (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_int8_1."time" Update on _timescaledb_internal._hyper_3_3_chunk metrics_int8_1 Update on _timescaledb_internal._hyper_3_11_chunk metrics_int8 Update on _timescaledb_internal._hyper_3_19_chunk metrics_int8_2 Update on _timescaledb_internal._hyper_3_27_chunk metrics_int8 -> Result (actual rows=1.00 loops=1) Output: ('0.1'::double precision * metrics_int8.value), 'update'::text, metrics_int8.tableoid, metrics_int8.ctid -> Custom Scan (ChunkAppend) on public.metrics_int8 (actual rows=1.00 loops=1) Output: metrics_int8.value, metrics_int8.tableoid, metrics_int8.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_3_19_chunk_metrics_int8_time_idx on _timescaledb_internal._hyper_3_19_chunk metrics_int8_2 (actual rows=1.00 loops=1) Output: metrics_int8_2.value, metrics_int8_2.tableoid, metrics_int8_2.ctid Index Cond: (metrics_int8_2."time" = length("substring"(version(), 1, 20))) ROLLBACK; -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Append (actual rows=1.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=0.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_date_1.tableoid, metrics_date_1.ctid -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = '01-01-2000'::date) :PREFIX UPDATE metrics_timestamp SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01' AND device = '1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 -> Result (actual rows=1.00 loops=1) Output: '0.6'::double precision, metrics_space_1.tableoid, metrics_space_1.ctid -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = '1'::text) AND (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone)) :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 -> Result (actual rows=2.00 loops=1) Output: '0.6'::double precision, metrics_space.tableoid, metrics_space.ctid -> Append (actual rows=2.00 loops=1) -> Index Scan using _hyper_7_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) -> Index Scan using _hyper_7_8_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=1.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2."time" = 'Sat Jan 01 00:00:00 2000'::timestamp without time zone) ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_date (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamp (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_timestamptz (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.9 WHERE time = '2000-01-01'::text::date; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_date (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.9 WHERE time = '2000-01-01'::text::timestamp; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamp (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.9 WHERE time = '2000-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_timestamptz (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.9'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- space partitioning -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_space WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_space (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Delete on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Delete on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Delete on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Delete on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Delete on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Delete on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Delete on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space Update on _timescaledb_internal._hyper_7_16_chunk metrics_space Update on _timescaledb_internal._hyper_7_23_chunk metrics_space Update on _timescaledb_internal._hyper_7_24_chunk metrics_space Update on _timescaledb_internal._hyper_7_31_chunk metrics_space Update on _timescaledb_internal._hyper_7_32_chunk metrics_space -> Result (actual rows=1.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=1.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 6 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: ((metrics_space_1.device = format('1'::text)) AND (metrics_space_1."time" = ('2000-01-01'::cstring)::timestamp with time zone)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: ((metrics_space_2.device = format('1'::text)) AND (metrics_space_2."time" = ('2000-01-01'::cstring)::timestamp with time zone)) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE device = format('1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_space (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 Update on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 Update on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 Update on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 Update on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 Update on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 Update on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 Update on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 -> Result (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_space.tableoid, metrics_space.ctid -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=4.00 loops=1) Output: metrics_space.tableoid, metrics_space.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_7_7_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_7_chunk metrics_space_1 (actual rows=1.00 loops=1) Output: metrics_space_1.tableoid, metrics_space_1.ctid Index Cond: (metrics_space_1.device = format('1'::text)) -> Index Scan using _hyper_7_8_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_8_chunk metrics_space_2 (actual rows=0.00 loops=1) Output: metrics_space_2.tableoid, metrics_space_2.ctid Index Cond: (metrics_space_2.device = format('1'::text)) -> Index Scan using _hyper_7_15_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_15_chunk metrics_space_3 (actual rows=1.00 loops=1) Output: metrics_space_3.tableoid, metrics_space_3.ctid Index Cond: (metrics_space_3.device = format('1'::text)) -> Index Scan using _hyper_7_16_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_16_chunk metrics_space_4 (actual rows=0.00 loops=1) Output: metrics_space_4.tableoid, metrics_space_4.ctid Index Cond: (metrics_space_4.device = format('1'::text)) -> Index Scan using _hyper_7_23_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_23_chunk metrics_space_5 (actual rows=1.00 loops=1) Output: metrics_space_5.tableoid, metrics_space_5.ctid Index Cond: (metrics_space_5.device = format('1'::text)) -> Index Scan using _hyper_7_24_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_24_chunk metrics_space_6 (actual rows=0.00 loops=1) Output: metrics_space_6.tableoid, metrics_space_6.ctid Index Cond: (metrics_space_6.device = format('1'::text)) -> Index Scan using _hyper_7_31_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_31_chunk metrics_space_7 (actual rows=1.00 loops=1) Output: metrics_space_7.tableoid, metrics_space_7.ctid Index Cond: (metrics_space_7.device = format('1'::text)) -> Index Scan using _hyper_7_32_chunk_metrics_space_device_time_idx on _timescaledb_internal._hyper_7_32_chunk metrics_space_8 (actual rows=0.00 loops=1) Output: metrics_space_8.tableoid, metrics_space_8.ctid Index Cond: (metrics_space_8.device = format('1'::text)) ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Delete on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Delete on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Delete on _timescaledb_internal._hyper_4_12_chunk metrics_date Delete on _timescaledb_internal._hyper_4_20_chunk metrics_date Delete on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Delete on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Delete on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Delete on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Delete on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Delete on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Delete on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Delete on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Delete on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.2 WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_date_1."time" -> Update on public.metrics_date (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_date_1."time" Update on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 Update on _timescaledb_internal._hyper_4_12_chunk metrics_date Update on _timescaledb_internal._hyper_4_20_chunk metrics_date Update on _timescaledb_internal._hyper_4_28_chunk metrics_date -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_date.tableoid, metrics_date.ctid -> Custom Scan (ChunkAppend) on public.metrics_date (actual rows=1.00 loops=1) Output: metrics_date.tableoid, metrics_date.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_4_4_chunk_metrics_date_time_idx on _timescaledb_internal._hyper_4_4_chunk metrics_date_1 (actual rows=1.00 loops=1) Output: metrics_date_1.tableoid, metrics_date_1.ctid Index Cond: (metrics_date_1."time" = ('2000-01-01'::cstring)::date) :PREFIX UPDATE metrics_timestamp SET value = 0.2 WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamp_1."time" -> Update on public.metrics_timestamp (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamp_1."time" Update on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 Update on _timescaledb_internal._hyper_5_13_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_21_chunk metrics_timestamp Update on _timescaledb_internal._hyper_5_29_chunk metrics_timestamp -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamp.tableoid, metrics_timestamp.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamp (actual rows=1.00 loops=1) Output: metrics_timestamp.tableoid, metrics_timestamp.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_5_5_chunk_metrics_timestamp_time_idx on _timescaledb_internal._hyper_5_5_chunk metrics_timestamp_1 (actual rows=1.00 loops=1) Output: metrics_timestamp_1.tableoid, metrics_timestamp_1.ctid Index Cond: (metrics_timestamp_1."time" = ('2000-01-01'::cstring)::timestamp without time zone) :PREFIX UPDATE metrics_timestamptz SET value = 0.2 WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=1.00 loops=1) Output: ('returning'::text), metrics_timestamptz_1."time" -> Update on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: 'returning'::text, metrics_timestamptz_1."time" Update on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 Update on _timescaledb_internal._hyper_6_14_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_22_chunk metrics_timestamptz Update on _timescaledb_internal._hyper_6_30_chunk metrics_timestamptz -> Result (actual rows=1.00 loops=1) Output: '0.2'::double precision, metrics_timestamptz.tableoid, metrics_timestamptz.ctid -> Custom Scan (ChunkAppend) on public.metrics_timestamptz (actual rows=1.00 loops=1) Output: metrics_timestamptz.tableoid, metrics_timestamptz.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 3 -> Index Scan using _hyper_6_6_chunk_metrics_timestamptz_time_idx on _timescaledb_internal._hyper_6_6_chunk metrics_timestamptz_1 (actual rows=1.00 loops=1) Output: metrics_timestamptz_1.tableoid, metrics_timestamptz_1.ctid Index Cond: (metrics_timestamptz_1."time" = ('2000-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- subselects -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Delete on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Delete on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Delete on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 Update on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 Update on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 Update on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 -> Hash Join (actual rows=4.00 loops=1) Output: '0.1'::double precision, metrics_int2.ctid, metrics_int4.tableoid, metrics_int4.ctid, metrics_int2.tableoid Inner Unique: true Hash Cond: (metrics_int4."time" = metrics_int2."time") -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk metrics_int4_1 (actual rows=1.00 loops=1) Output: metrics_int4_1."time", metrics_int4_1.tableoid, metrics_int4_1.ctid Index Cond: (metrics_int4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk metrics_int4_2 (actual rows=1.00 loops=1) Output: metrics_int4_2."time", metrics_int4_2.tableoid, metrics_int4_2.ctid Index Cond: (metrics_int4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk metrics_int4_3 (actual rows=1.00 loops=1) Output: metrics_int4_3."time", metrics_int4_3.tableoid, metrics_int4_3.ctid Index Cond: (metrics_int4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk metrics_int4_4 (actual rows=1.00 loops=1) Output: metrics_int4_4."time", metrics_int4_4.tableoid, metrics_int4_4.ctid Index Cond: (metrics_int4_4."time" < length(version())) -> Hash (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid -> HashAggregate (actual rows=4.00 loops=1) Output: metrics_int2.ctid, metrics_int2."time", metrics_int2.tableoid Group Key: metrics_int2."time" -> Append (actual rows=4.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk metrics_int2_1 (actual rows=1.00 loops=1) Output: metrics_int2_1.ctid, metrics_int2_1."time", metrics_int2_1.tableoid Index Cond: (metrics_int2_1."time" < length(version())) -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk metrics_int2_2 (actual rows=1.00 loops=1) Output: metrics_int2_2.ctid, metrics_int2_2."time", metrics_int2_2.tableoid Index Cond: (metrics_int2_2."time" < length(version())) -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk metrics_int2_3 (actual rows=1.00 loops=1) Output: metrics_int2_3.ctid, metrics_int2_3."time", metrics_int2_3.tableoid Index Cond: (metrics_int2_3."time" < length(version())) -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk metrics_int2_4 (actual rows=1.00 loops=1) Output: metrics_int2_4.ctid, metrics_int2_4."time", metrics_int2_4.tableoid Index Cond: (metrics_int2_4."time" < length(version())) ROLLBACK; -- join -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Nested Loop (actual rows=16.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3.tableoid -> Seq Scan on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4.tableoid -> Materialize (actual rows=4.00 loops=4) Output: m4.tableoid, m4.ctid -> Append (actual rows=4.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Merge Join (actual rows=4.00 loops=1) Output: '0.15'::double precision, m2.ctid, m4.tableoid, m4.ctid, m2.tableoid Merge Cond: (m4."time" = m2."time") -> Merge Append (actual rows=4.00 loops=1) Sort Key: m4."time" -> Index Scan Backward using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1."time", m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan Backward using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2."time", m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan Backward using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3."time", m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan Backward using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4."time", m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Materialize (actual rows=4.00 loops=1) Output: m2.ctid, m2."time", m2.tableoid -> Merge Append (actual rows=4.00 loops=1) Sort Key: m2."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.ctid, m2_1."time", m2_1.tableoid -> Index Scan Backward using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.ctid, m2_2."time", m2_2.tableoid -> Index Scan Backward using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.ctid, m2_3."time", m2_3.tableoid -> Index Scan Backward using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.ctid, m2_4."time", m2_4.tableoid ROLLBACK; -- cte -- should all have chunkappend nodes BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) SELECT * FROM d; --- QUERY PLAN --- CTE Scan on d (actual rows=4.00 loops=1) Output: d."time" CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version())) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_int4 m4 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) SELECT * FROM u; --- QUERY PLAN --- CTE Scan on u (actual rows=4.00 loops=1) Output: u."time" CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update 1' WHERE m4.time < length(version())) UPDATE metrics_int2 m2 SET data = 'cte update 2' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_int4 m4 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 1'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update 2'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) UPDATE metrics_int2 m2 SET data = 'cte update' WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE d -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Delete on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Delete on _timescaledb_internal._hyper_2_2_chunk m4_1 Delete on _timescaledb_internal._hyper_2_10_chunk m4_2 Delete on _timescaledb_internal._hyper_2_18_chunk m4_3 Delete on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Update on public.metrics_int2 m2 (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_1_1_chunk m2_1 Update on _timescaledb_internal._hyper_1_9_chunk m2_2 Update on _timescaledb_internal._hyper_1_17_chunk m2_3 Update on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m2.tableoid, m2.ctid -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Output: m2.tableoid, m2.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) CTE u -> Custom Scan (ModifyHypertable) (actual rows=4.00 loops=1) Output: m4_1."time" -> Update on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4_1."time" Update on _timescaledb_internal._hyper_2_2_chunk m4_1 Update on _timescaledb_internal._hyper_2_10_chunk m4_2 Update on _timescaledb_internal._hyper_2_18_chunk m4_3 Update on _timescaledb_internal._hyper_2_26_chunk m4_4 -> Result (actual rows=4.00 loops=1) Output: 'cte update'::text, m4.tableoid, m4.ctid -> Custom Scan (ChunkAppend) on public.metrics_int4 m4 (actual rows=4.00 loops=1) Output: m4.tableoid, m4.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_2_2_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_2_chunk m4_1 (actual rows=1.00 loops=1) Output: m4_1.tableoid, m4_1.ctid Index Cond: (m4_1."time" < length(version())) -> Index Scan using _hyper_2_10_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_10_chunk m4_2 (actual rows=1.00 loops=1) Output: m4_2.tableoid, m4_2.ctid Index Cond: (m4_2."time" < length(version())) -> Index Scan using _hyper_2_18_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_18_chunk m4_3 (actual rows=1.00 loops=1) Output: m4_3.tableoid, m4_3.ctid Index Cond: (m4_3."time" < length(version())) -> Index Scan using _hyper_2_26_chunk_metrics_int4_time_idx on _timescaledb_internal._hyper_2_26_chunk m4_4 (actual rows=1.00 loops=1) Output: m4_4.tableoid, m4_4.ctid Index Cond: (m4_4."time" < length(version())) -> Delete on public.metrics_int2 m2 (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_1_1_chunk m2_1 Delete on _timescaledb_internal._hyper_1_9_chunk m2_2 Delete on _timescaledb_internal._hyper_1_17_chunk m2_3 Delete on _timescaledb_internal._hyper_1_25_chunk m2_4 -> Custom Scan (ChunkAppend) on public.metrics_int2 m2 (actual rows=4.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 0 -> Index Scan using _hyper_1_1_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_1_chunk m2_1 (actual rows=1.00 loops=1) Output: m2_1.tableoid, m2_1.ctid Index Cond: (m2_1."time" < length(version())) -> Index Scan using _hyper_1_9_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_9_chunk m2_2 (actual rows=1.00 loops=1) Output: m2_2.tableoid, m2_2.ctid Index Cond: (m2_2."time" < length(version())) -> Index Scan using _hyper_1_17_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_17_chunk m2_3 (actual rows=1.00 loops=1) Output: m2_3.tableoid, m2_3.ctid Index Cond: (m2_3."time" < length(version())) -> Index Scan using _hyper_1_25_chunk_metrics_int2_time_idx on _timescaledb_internal._hyper_1_25_chunk m2_4 (actual rows=1.00 loops=1) Output: m2_4.tableoid, m2_4.ctid Index Cond: (m2_4."time" < length(version())) ROLLBACK; -- test interaction with compression -- with chunk exclusion for compressed chunks operations that would -- error because they hit compressed chunks before can succeed now -- if those chunks get excluded -- delete from uncompressed chunks with non-immutable constraints BEGIN; :PREFIX DELETE FROM metrics_compressed WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on public.metrics_compressed (actual rows=0.00 loops=1) Delete on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Delete on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Delete on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Delete on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; -- update uncompressed chunks with non-immutable constraints BEGIN; :PREFIX UPDATE metrics_compressed SET value = 2 * value WHERE time > '2005-01-01'::text::timestamptz; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on public.metrics_compressed (actual rows=0.00 loops=1) Update on _timescaledb_internal._hyper_8_33_chunk metrics_compressed Update on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 Update on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 Update on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 -> Result (actual rows=3.00 loops=1) Output: ('2'::double precision * metrics_compressed.value), metrics_compressed.tableoid, metrics_compressed.ctid -> Custom Scan (ChunkAppend) on public.metrics_compressed (actual rows=3.00 loops=1) Output: metrics_compressed.value, metrics_compressed.tableoid, metrics_compressed.ctid Startup Exclusion: true Runtime Exclusion: false Chunks excluded during startup: 1 -> Index Scan using _hyper_8_35_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_35_chunk metrics_compressed_1 (actual rows=1.00 loops=1) Output: metrics_compressed_1.value, metrics_compressed_1.tableoid, metrics_compressed_1.ctid Index Cond: (metrics_compressed_1."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_36_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_36_chunk metrics_compressed_2 (actual rows=1.00 loops=1) Output: metrics_compressed_2.value, metrics_compressed_2.tableoid, metrics_compressed_2.ctid Index Cond: (metrics_compressed_2."time" > ('2005-01-01'::cstring)::timestamp with time zone) -> Index Scan using _hyper_8_37_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_8_37_chunk metrics_compressed_3 (actual rows=1.00 loops=1) Output: metrics_compressed_3.value, metrics_compressed_3.tableoid, metrics_compressed_3.ctid Index Cond: (metrics_compressed_3."time" > ('2005-01-01'::cstring)::timestamp with time zone) ROLLBACK; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/move.out�������������������������������������������������������0000664�0000000�0000000�00000066243�15100345067�0021147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; DROP TABLESPACE IF EXISTS tablespace3; SET client_min_messages = NOTICE; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER_2 LOCATION :TEST_TABLESPACE2_PATH; --Running some of the same tests as we do for reorder/cluster because that's how move is implemented \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 1 \ir include/cluster_test_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE cluster_test(time INTEGER, temp float, location int, value TEXT); SELECT create_hypertable('cluster_test', 'time', chunk_time_interval => 5); create_hypertable --------------------------- (1,public,cluster_test,t) CREATE INDEX on cluster_test (location); CREATE OR REPLACE FUNCTION ensure_scans_work(table_name TEXT, should_output REGCLASS=NULL, seqscan BOOLEAN=FALSE, indexscan BOOLEAN=FALSE, bitmapscan BOOLEAN=FALSE) RETURNS TABLE (a TEXT, b TEXT) LANGUAGE SQL STABLE AS $BODY$ SELECT format($INNER$ SET LOCAL enable_seqscan=%1$s; SET LOCAL enable_indexscan=%2$s; SET LOCAL enable_bitmapscan=%3$s; EXPLAIN (buffers off, costs off) SELECT * FROM %4$I WHERE time=7 $INNER$, seqscan, indexscan, bitmapscan, table_name) as a, format($INNER$ WITH T1 as (SELECT * FROM %1$I WHERE time=7), T2 as (SELECT * FROM %2$I WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL $INNER$, table_name, should_output) as b; $BODY$; CREATE OR REPLACE FUNCTION ensure_scans_work_no_val(table_name TEXT, should_output REGCLASS=NULL, seqscan BOOLEAN=FALSE, indexscan BOOLEAN=FALSE, bitmapscan BOOLEAN=FALSE) RETURNS TABLE (a TEXT, b TEXT) LANGUAGE SQL STABLE AS $BODY$ SELECT format($INNER$ SET LOCAL enable_seqscan=%1$s; SET LOCAL enable_indexscan=%2$s; SET LOCAL enable_bitmapscan=%3$s; EXPLAIN (buffers off, costs off) SELECT * FROM %4$I WHERE time=6 $INNER$, seqscan, indexscan, bitmapscan, table_name) as a, format($INNER$ WITH T1 as (SELECT * FROM %1$I WHERE time=7), T2 as (SELECT * FROM %2$I WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL $INNER$, table_name, should_output) as b; $BODY$; -- Show default indexes SELECT * FROM test.show_indexes('cluster_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------------------+------------+------+--------+---------+-----------+------------ cluster_test_location_idx | {location} | | f | f | f | cluster_test_time_idx | {time} | | f | f | f | -- Show clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered ------------+---------------- -- Create two chunks INSERT INTO cluster_test VALUES ( 0, 18.9, 3, 'a'), ( 8, 13.3, 7, 'b'), ( 3, 19.4, 3, 'c'), ( 6, 27.3, 9, 'd'), ( 5, 25.4, 1, 'e'), ( 4, 18.3, 2, 'f'), ( 2, 12.4, 8, 'g'), ( 7, 20.3, 4, repeat('xyzzy', 100000)), -- toasted value ( 9, 11.4, 1, 'h'), ( 1, 23.4, 5, 'i'); CREATE TABLE expected AS SELECT * FROM cluster_test; -- original results to be compared against SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+-----------+-------- (0,1) | 0 | 18.9 | 3 | a | 1 (0,2) | 3 | 19.4 | 3 | c | 1 (0,3) | 4 | 18.3 | 2 | f | 1 (0,4) | 2 | 12.4 | 8 | g | 1 (0,5) | 1 | 23.4 | 5 | i | 1 SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+--------------------------------+-------- (0,1) | 8 | 13.3 | 7 | b | 1 (0,2) | 6 | 27.3 | 9 | d | 1 (0,3) | 5 | 25.4 | 1 | e | 1 (0,4) | 7 | 20.3 | 4 | xyzzyxyzzyxyzzyxyzzyxyzzyxyzzy | 500000 (0,5) | 9 | 11.4 | 1 | h | 1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- Show chunk indexes SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------+------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_2_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------+------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | \set ON_ERROR_STOP 0 -- cannot move a chunk with no reorder index on first call SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1'); ERROR: there is no previously clustered index for table "_hyper_1_2_chunk" -- cannot move a chunk without a destination tablespace set SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>NULL, index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: valid chunk, destination_tablespace, and index_destination_tablespaces are required -- cannot move a chunk without an index_destination_tablespace set SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: valid chunk, destination_tablespace, and index_destination_tablespaces are required -- cannot move a chunk or an index to a tablespace we do not have create permissions on SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace2', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: permission denied for tablespace "tablespace2" SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: permission denied for tablespace "tablespace2" -- cannot move to a nonexistent tablespace SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace3', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: tablespace "tablespace3" does not exist SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace3', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: tablespace "tablespace3" does not exist -- cannot move a hypertable (must specify a chunk) SELECT move_chunk(chunk=>'cluster_test', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: "cluster_test" is not a chunk -- cannot move a NULL chunk SELECT move_chunk(chunk=>NULL, destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: valid chunk, destination_tablespace, and index_destination_tablespaces are required -- cannot move within a transaction BEGIN; SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); ERROR: move cannot run inside a transaction block END; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- must be hypertable owner to move a chunk SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace2', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); ERROR: must be owner of hypertable "cluster_test" \set ON_ERROR_STOP 1 -- grant create permissions on tablespace2 so we can use it later. SET client_min_messages TO error; GRANT CREATE ON TABLESPACE tablespace2 TO :ROLE_DEFAULT_PERM_USER; RESET client_min_messages; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- move with chunk index for reorder SELECT FROM move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- SELECT * FROM test.show_subtables('cluster_test'); Child | Tablespace ----------------------------------------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | tablespace1 SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------+------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | tablespace1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; SET enable_seqscan=Default; SET enable_indexscan=Default; SET enable_bitmapscan=Default; -- check that move puts things in the correct order, as it also reorders SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+-----------+-------- (0,1) | 0 | 18.9 | 3 | a | 1 (0,2) | 3 | 19.4 | 3 | c | 1 (0,3) | 4 | 18.3 | 2 | f | 1 (0,4) | 2 | 12.4 | 8 | g | 1 (0,5) | 1 | 23.4 | 5 | i | 1 SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+--------------------------------+-------- (0,1) | 9 | 11.4 | 1 | h | 1 (0,2) | 8 | 13.3 | 7 | b | 1 (0,3) | 7 | 20.3 | 4 | xyzzyxyzzyxyzzyxyzzyxyzzyxyzzy | 500000 (0,4) | 6 | 27.3 | 9 | d | 1 (0,5) | 5 | 25.4 | 1 | e | 1 -- move back to pg_default SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'pg_default', index_destination_tablespace=>'pg_default', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); INFO: reordering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort move_chunk ------------ SELECT * FROM test.show_subtables('cluster_test'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------+------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | -- move chunk and indexes to different tablespaces SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); INFO: reordering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort move_chunk ------------ SELECT * FROM test.show_subtables('cluster_test'); Child | Tablespace ----------------------------------------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | tablespace1 SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------+------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | tablespace2 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | tablespace2 -- keep chunk in same space and move index tablespace SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'pg_default', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); INFO: reordering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort move_chunk ------------ SELECT * FROM test.show_subtables('cluster_test'); Child | Tablespace ----------------------------------------+------------ _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------+------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | tablespace2 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | tablespace2 --TEST with compression bug 4000 --compress chunk and then move chunk and index to different tablespaces ALTER TABLE cluster_test SET (timescaledb.compress, timescaledb.compress_segmentby = 'location'); SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk') as ch; ch ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk SELECT true INTO move_chunk_compressed FROM move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace2', index_destination_tablespace=>'tablespace1', verbose=>TRUE); SELECT * FROM test.show_subtables('cluster_test'); Child | Tablespace ----------------------------------------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_2_chunk | tablespace2 SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ----------------------------------------+------------------------------------------------------------------+------------+------+--------+---------+-----------+------------- _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk | _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | tablespace1 _timescaledb_internal._hyper_1_2_chunk | _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | tablespace1 SELECT * FROM test.show_indexesp('_timescaledb_internal.compress_hyper%_chunk'); Table | Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------+---------------------------------------------------------------------------------------+------------------------------------------+------+--------+---------+-----------+------------- _timescaledb_internal.compress_hyper_2_3_chunk | _timescaledb_internal.compress_hyper_2_3_chunk_location__ts_meta_min_1__ts_meta_m_idx | {location,_ts_meta_min_1,_ts_meta_max_1} | | f | f | f | tablespace1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/ordered_append-15.out������������������������������������������0000664�0000000�0000000�00001130432�15100345067�0023370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create normal hypertable with dropped columns, each chunk will have different attribute numbers CREATE TABLE metrics(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics','time',create_default_indexes:=false); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics(time DESC); CREATE INDEX ON metrics(device_id,time DESC); ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space','time','device_id',3,create_default_indexes:=false); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space(time); CREATE INDEX ON metrics_space(device_id,time); ANALYZE metrics_space; -- create hypertable with compression CREATE TABLE metrics_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_compressed','time',create_default_indexes:=false); create_hypertable --------------------------------- (3,public,metrics_compressed,t) ALTER TABLE metrics_compressed DROP COLUMN filler_1; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_2; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_3; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_compressed(time); CREATE INDEX ON metrics_compressed(device_id,time); ANALYZE metrics_compressed; -- compress chunks ALTER TABLE metrics_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_13_chunk _timescaledb_internal._hyper_3_14_chunk _timescaledb_internal._hyper_3_15_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_4; -- create hypertable with space partitioning and compression CREATE TABLE metrics_space_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space_compressed','time','device_id',3,create_default_indexes:=false); create_hypertable --------------------------------------- (5,public,metrics_space_compressed,t) ALTER TABLE metrics_space_compressed DROP COLUMN filler_1; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_2; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_3; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space_compressed(time); CREATE INDEX ON metrics_space_compressed(device_id,time); ANALYZE metrics_space_compressed; -- compress chunks ALTER TABLE metrics_space_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_space_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_19_chunk _timescaledb_internal._hyper_5_20_chunk _timescaledb_internal._hyper_5_21_chunk _timescaledb_internal._hyper_5_22_chunk _timescaledb_internal._hyper_5_23_chunk _timescaledb_internal._hyper_5_24_chunk _timescaledb_internal._hyper_5_25_chunk _timescaledb_internal._hyper_5_26_chunk _timescaledb_internal._hyper_5_27_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_6; -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Incremental Sort (actual rows=1.00 loops=1) Sort Key: metrics.device_id, metrics."time" Presorted Key: metrics.device_id Full-sort Groups: 1 Sort Method: top-N heapsort Pre-sorted Groups: 1 Sort Method: top-N heapsort -> Merge Append (actual rows=13675.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3599.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=56853.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 10794 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 723 -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=13674.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=4.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_device_id_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=56853.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 7196 -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3598 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 482 -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 241 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=13674.00 loops=1) Order: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1.00 loops=1) Order: metrics_space_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk _hyper_2_12_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk _hyper_2_11_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk _hyper_2_10_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk _hyper_2_9_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk _hyper_2_8_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk _hyper_2_7_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk _hyper_2_6_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk _hyper_2_5_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk _hyper_2_4_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Merge Append (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=4.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_16_chunk.device_id, compress_hyper_4_16_chunk._ts_meta_min_1, compress_hyper_4_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_17_chunk.device_id, compress_hyper_4_17_chunk._ts_meta_min_1, compress_hyper_4_17_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_18_chunk.device_id, compress_hyper_4_18_chunk._ts_meta_min_1, compress_hyper_4_18_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=56853.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=7196.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=24467.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 609 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=27.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=25190.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=20385.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 4615 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=16785.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3215 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 10 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=7195.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 7805 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=15.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=3595.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 6405 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 20 -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=100.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=13674.00 loops=1) Order: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed metrics_compressed_1 (actual rows=1.00 loops=1) Order: metrics_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk _hyper_3_15_chunk_1 (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk compress_hyper_4_18_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk _hyper_3_14_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk compress_hyper_4_17_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk _hyper_3_13_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk compress_hyper_4_16_chunk_1 (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Filter: ("time" = $1) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Filter: ("time" = $1) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 4995 -> Seq Scan on compress_hyper_4_18_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 25 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=4.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_30_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_30_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_33_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_33_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_36_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_28_chunk.device_id, compress_hyper_6_28_chunk._ts_meta_min_1, compress_hyper_6_28_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_29_chunk.device_id, compress_hyper_6_29_chunk._ts_meta_min_1, compress_hyper_6_29_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_31_chunk.device_id, compress_hyper_6_31_chunk._ts_meta_min_1, compress_hyper_6_31_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_32_chunk.device_id, compress_hyper_6_32_chunk._ts_meta_min_1, compress_hyper_6_32_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_34_chunk.device_id, compress_hyper_6_34_chunk._ts_meta_min_1, compress_hyper_6_34_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_35_chunk.device_id, compress_hyper_6_35_chunk._ts_meta_min_1, compress_hyper_6_35_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=56853.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 8 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=14632.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 406 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=16.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 2 -> Sort (actual rows=4797.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 203 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 1 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=15114.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=12231.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 2769 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=15.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=10071.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1929 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 6 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=4317.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4683 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=9.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 9 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=2157.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3843 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=13674.00 loops=1) Order: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=5.00 loops=1) InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed metrics_space_compressed_1 (actual rows=1.00 loops=1) Order: metrics_space_compressed_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk _hyper_5_27_chunk_1 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk compress_hyper_6_36_chunk_1 (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk _hyper_5_26_chunk_1 (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk compress_hyper_6_35_chunk_1 (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk _hyper_5_25_chunk_1 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk compress_hyper_6_34_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk _hyper_5_24_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk compress_hyper_6_33_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk _hyper_5_23_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk compress_hyper_6_32_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk _hyper_5_22_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk compress_hyper_6_31_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk _hyper_5_21_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk compress_hyper_6_30_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk _hyper_5_20_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk compress_hyper_6_29_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk _hyper_5_19_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk compress_hyper_6_28_chunk_1 (never executed) -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Merge Append (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=3.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Seq Scan on compress_hyper_6_35_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=4.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/ordered_append-16.out������������������������������������������0000664�0000000�0000000�00001130432�15100345067�0023371�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create normal hypertable with dropped columns, each chunk will have different attribute numbers CREATE TABLE metrics(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics','time',create_default_indexes:=false); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics(time DESC); CREATE INDEX ON metrics(device_id,time DESC); ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space','time','device_id',3,create_default_indexes:=false); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space(time); CREATE INDEX ON metrics_space(device_id,time); ANALYZE metrics_space; -- create hypertable with compression CREATE TABLE metrics_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_compressed','time',create_default_indexes:=false); create_hypertable --------------------------------- (3,public,metrics_compressed,t) ALTER TABLE metrics_compressed DROP COLUMN filler_1; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_2; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_3; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_compressed(time); CREATE INDEX ON metrics_compressed(device_id,time); ANALYZE metrics_compressed; -- compress chunks ALTER TABLE metrics_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_13_chunk _timescaledb_internal._hyper_3_14_chunk _timescaledb_internal._hyper_3_15_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_4; -- create hypertable with space partitioning and compression CREATE TABLE metrics_space_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space_compressed','time','device_id',3,create_default_indexes:=false); create_hypertable --------------------------------------- (5,public,metrics_space_compressed,t) ALTER TABLE metrics_space_compressed DROP COLUMN filler_1; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_2; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_3; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space_compressed(time); CREATE INDEX ON metrics_space_compressed(device_id,time); ANALYZE metrics_space_compressed; -- compress chunks ALTER TABLE metrics_space_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_space_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_19_chunk _timescaledb_internal._hyper_5_20_chunk _timescaledb_internal._hyper_5_21_chunk _timescaledb_internal._hyper_5_22_chunk _timescaledb_internal._hyper_5_23_chunk _timescaledb_internal._hyper_5_24_chunk _timescaledb_internal._hyper_5_25_chunk _timescaledb_internal._hyper_5_26_chunk _timescaledb_internal._hyper_5_27_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_6; -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Incremental Sort (actual rows=1.00 loops=1) Sort Key: metrics.device_id, metrics."time" Presorted Key: metrics.device_id Full-sort Groups: 1 Sort Method: top-N heapsort Pre-sorted Groups: 1 Sort Method: top-N heapsort -> Merge Append (actual rows=13675.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3599.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=56853.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 10794 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 723 -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=13674.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=4.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_device_id_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=56853.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 7196 -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3598 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 482 -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 241 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" IS NOT NULL) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=13674.00 loops=1) Order: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1.00 loops=1) Order: metrics_space_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk _hyper_2_12_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk _hyper_2_11_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk _hyper_2_10_chunk_1 (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk _hyper_2_9_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk _hyper_2_8_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk _hyper_2_7_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk _hyper_2_6_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk _hyper_2_5_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk _hyper_2_4_chunk_1 (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Merge Append (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=4.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_16_chunk.device_id, compress_hyper_4_16_chunk._ts_meta_min_1, compress_hyper_4_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_17_chunk.device_id, compress_hyper_4_17_chunk._ts_meta_min_1, compress_hyper_4_17_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_18_chunk.device_id, compress_hyper_4_18_chunk._ts_meta_min_1, compress_hyper_4_18_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=56853.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=7196.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=24467.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 609 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=27.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=25190.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=20385.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 4615 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=16785.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3215 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 10 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=7195.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 7805 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=15.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=3595.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 6405 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 20 -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=100.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=13674.00 loops=1) Order: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed metrics_compressed_1 (actual rows=1.00 loops=1) Order: metrics_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk _hyper_3_15_chunk_1 (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_18_chunk compress_hyper_4_18_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk _hyper_3_14_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_17_chunk compress_hyper_4_17_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk _hyper_3_13_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_4_16_chunk compress_hyper_4_16_chunk_1 (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Filter: ("time" = $1) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Filter: ("time" = $1) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 4995 -> Seq Scan on compress_hyper_4_18_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 25 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=4.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_30_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_30_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_33_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_33_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_36_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_28_chunk.device_id, compress_hyper_6_28_chunk._ts_meta_min_1, compress_hyper_6_28_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_29_chunk.device_id, compress_hyper_6_29_chunk._ts_meta_min_1, compress_hyper_6_29_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_31_chunk.device_id, compress_hyper_6_31_chunk._ts_meta_min_1, compress_hyper_6_31_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_32_chunk.device_id, compress_hyper_6_32_chunk._ts_meta_min_1, compress_hyper_6_32_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_34_chunk.device_id, compress_hyper_6_34_chunk._ts_meta_min_1, compress_hyper_6_34_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_35_chunk.device_id, compress_hyper_6_35_chunk._ts_meta_min_1, compress_hyper_6_35_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=56853.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 8 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=14632.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 406 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=16.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 2 -> Sort (actual rows=4797.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 203 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 1 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=15114.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=12231.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 2769 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=15.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=10071.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1929 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 6 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=4317.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4683 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=9.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 9 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=2157.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3843 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=13674.00 loops=1) Order: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=5.00 loops=1) InitPlan 2 (returns $1) -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed metrics_space_compressed_1 (actual rows=1.00 loops=1) Order: metrics_space_compressed_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk _hyper_5_27_chunk_1 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_36_chunk compress_hyper_6_36_chunk_1 (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk _hyper_5_26_chunk_1 (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_35_chunk compress_hyper_6_35_chunk_1 (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk _hyper_5_25_chunk_1 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_34_chunk compress_hyper_6_34_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk _hyper_5_24_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_33_chunk compress_hyper_6_33_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk _hyper_5_23_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_32_chunk compress_hyper_6_32_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk _hyper_5_22_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_31_chunk compress_hyper_6_31_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk _hyper_5_21_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_30_chunk compress_hyper_6_30_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk _hyper_5_20_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_29_chunk compress_hyper_6_29_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk _hyper_5_19_chunk_1 (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_6_28_chunk compress_hyper_6_28_chunk_1 (never executed) -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=0.00 loops=1) Filter: ("time" = $1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Merge Append (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=3.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Seq Scan on compress_hyper_6_35_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) Filter: ("time" = $1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 (returns $0) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=4.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/ordered_append-17.out������������������������������������������0000664�0000000�0000000�00001114016�15100345067�0023372�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create normal hypertable with dropped columns, each chunk will have different attribute numbers CREATE TABLE metrics(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics','time',create_default_indexes:=false); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics(time DESC); CREATE INDEX ON metrics(device_id,time DESC); ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space','time','device_id',3,create_default_indexes:=false); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space(time); CREATE INDEX ON metrics_space(device_id,time); ANALYZE metrics_space; -- create hypertable with compression CREATE TABLE metrics_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_compressed','time',create_default_indexes:=false); create_hypertable --------------------------------- (3,public,metrics_compressed,t) ALTER TABLE metrics_compressed DROP COLUMN filler_1; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_2; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_3; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_compressed(time); CREATE INDEX ON metrics_compressed(device_id,time); ANALYZE metrics_compressed; -- compress chunks ALTER TABLE metrics_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_13_chunk _timescaledb_internal._hyper_3_14_chunk _timescaledb_internal._hyper_3_15_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_4; -- create hypertable with space partitioning and compression CREATE TABLE metrics_space_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space_compressed','time','device_id',3,create_default_indexes:=false); create_hypertable --------------------------------------- (5,public,metrics_space_compressed,t) ALTER TABLE metrics_space_compressed DROP COLUMN filler_1; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_2; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_3; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space_compressed(time); CREATE INDEX ON metrics_space_compressed(device_id,time); ANALYZE metrics_space_compressed; -- compress chunks ALTER TABLE metrics_space_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_space_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_19_chunk _timescaledb_internal._hyper_5_20_chunk _timescaledb_internal._hyper_5_21_chunk _timescaledb_internal._hyper_5_22_chunk _timescaledb_internal._hyper_5_23_chunk _timescaledb_internal._hyper_5_24_chunk _timescaledb_internal._hyper_5_25_chunk _timescaledb_internal._hyper_5_26_chunk _timescaledb_internal._hyper_5_27_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_6; -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Incremental Sort (actual rows=1.00 loops=1) Sort Key: metrics.device_id, metrics."time" Presorted Key: metrics.device_id Full-sort Groups: 1 Sort Method: top-N heapsort Pre-sorted Groups: 1 Sort Method: top-N heapsort -> Merge Append (actual rows=13675.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3599.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=56853.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 10794 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 723 -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=13674.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=4.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_device_id_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=56853.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 7196 -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3598 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 482 -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 241 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=13674.00 loops=1) Order: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1.00 loops=1) Order: metrics_space_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk _hyper_2_12_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk _hyper_2_11_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk _hyper_2_10_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk _hyper_2_9_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk _hyper_2_8_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk _hyper_2_7_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk _hyper_2_6_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk _hyper_2_5_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk _hyper_2_4_chunk_1 (never executed) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Merge Append (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=4.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_16_chunk.device_id, compress_hyper_4_16_chunk._ts_meta_min_1, compress_hyper_4_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_17_chunk.device_id, compress_hyper_4_17_chunk._ts_meta_min_1, compress_hyper_4_17_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_18_chunk.device_id, compress_hyper_4_18_chunk._ts_meta_min_1, compress_hyper_4_18_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=56853.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=7196.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=24467.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 609 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=27.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=25190.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=20385.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 4615 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=16785.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3215 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 10 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=7195.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 7805 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=15.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=3595.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 6405 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 20 -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=100.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=13674.00 loops=1) Order: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed metrics_compressed_1 (actual rows=1.00 loops=1) Order: metrics_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk _hyper_3_15_chunk_1 (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk compress_hyper_4_18_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk _hyper_3_14_chunk_1 (never executed) -> Seq Scan on compress_hyper_4_17_chunk compress_hyper_4_17_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk _hyper_3_13_chunk_1 (never executed) -> Seq Scan on compress_hyper_4_16_chunk compress_hyper_4_16_chunk_1 (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 4995 -> Seq Scan on compress_hyper_4_18_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 25 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=4.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_30_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_30_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_33_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_33_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_36_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_28_chunk.device_id, compress_hyper_6_28_chunk._ts_meta_min_1, compress_hyper_6_28_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_29_chunk.device_id, compress_hyper_6_29_chunk._ts_meta_min_1, compress_hyper_6_29_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_31_chunk.device_id, compress_hyper_6_31_chunk._ts_meta_min_1, compress_hyper_6_31_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_32_chunk.device_id, compress_hyper_6_32_chunk._ts_meta_min_1, compress_hyper_6_32_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_34_chunk.device_id, compress_hyper_6_34_chunk._ts_meta_min_1, compress_hyper_6_34_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_35_chunk.device_id, compress_hyper_6_35_chunk._ts_meta_min_1, compress_hyper_6_35_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=56853.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 8 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=14632.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 406 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=16.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 2 -> Sort (actual rows=4797.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 203 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 1 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=15114.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=12231.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 2769 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=15.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=10071.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1929 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 6 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=4317.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4683 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=9.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 9 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=2157.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3843 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=13674.00 loops=1) Order: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=5.00 loops=1) InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed metrics_space_compressed_1 (actual rows=1.00 loops=1) Order: metrics_space_compressed_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk _hyper_5_27_chunk_1 (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk compress_hyper_6_36_chunk_1 (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk _hyper_5_26_chunk_1 (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk compress_hyper_6_35_chunk_1 (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk _hyper_5_25_chunk_1 (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk compress_hyper_6_34_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk _hyper_5_24_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_33_chunk compress_hyper_6_33_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk _hyper_5_23_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_32_chunk compress_hyper_6_32_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk _hyper_5_22_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_31_chunk compress_hyper_6_31_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk _hyper_5_21_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_30_chunk compress_hyper_6_30_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk _hyper_5_20_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_29_chunk compress_hyper_6_29_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk _hyper_5_19_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_28_chunk compress_hyper_6_28_chunk_1 (never executed) -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 4 -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 6 -> Merge Append (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=3.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 2997 -> Seq Scan on compress_hyper_6_35_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 5 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=4.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/ordered_append-18.out������������������������������������������0000664�0000000�0000000�00001114016�15100345067�0023373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create normal hypertable with dropped columns, each chunk will have different attribute numbers CREATE TABLE metrics(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics','time',create_default_indexes:=false); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics(time DESC); CREATE INDEX ON metrics(device_id,time DESC); ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space','time','device_id',3,create_default_indexes:=false); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space(time); CREATE INDEX ON metrics_space(device_id,time); ANALYZE metrics_space; -- create hypertable with compression CREATE TABLE metrics_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_compressed','time',create_default_indexes:=false); create_hypertable --------------------------------- (3,public,metrics_compressed,t) ALTER TABLE metrics_compressed DROP COLUMN filler_1; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_2; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_3; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_compressed(time); CREATE INDEX ON metrics_compressed(device_id,time); ANALYZE metrics_compressed; -- compress chunks ALTER TABLE metrics_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_3_13_chunk _timescaledb_internal._hyper_3_14_chunk _timescaledb_internal._hyper_3_15_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_4; -- create hypertable with space partitioning and compression CREATE TABLE metrics_space_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space_compressed','time','device_id',3,create_default_indexes:=false); create_hypertable --------------------------------------- (5,public,metrics_space_compressed,t) ALTER TABLE metrics_space_compressed DROP COLUMN filler_1; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_2; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_3; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space_compressed(time); CREATE INDEX ON metrics_space_compressed(device_id,time); ANALYZE metrics_space_compressed; -- compress chunks ALTER TABLE metrics_space_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_space_compressed')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_19_chunk _timescaledb_internal._hyper_5_20_chunk _timescaledb_internal._hyper_5_21_chunk _timescaledb_internal._hyper_5_22_chunk _timescaledb_internal._hyper_5_23_chunk _timescaledb_internal._hyper_5_24_chunk _timescaledb_internal._hyper_5_25_chunk _timescaledb_internal._hyper_5_26_chunk _timescaledb_internal._hyper_5_27_chunk -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_6; -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Incremental Sort (actual rows=1.00 loops=1) Sort Key: metrics.device_id, metrics."time" Presorted Key: metrics.device_id Full-sort Groups: 1 Sort Method: top-N heapsort Pre-sorted Groups: 1 Sort Method: top-N heapsort -> Merge Append (actual rows=13675.00 loops=1) Sort Key: metrics.device_id -> Index Only Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3599.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5039.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=56853.00 loops=1) Order: metrics."time" -> Index Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 10794 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 723 -> Index Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics."time") -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics."time")), metrics.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Index Scan using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=7196.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=10076.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" DESC Chunks excluded during startup: 0 -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=13674.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_device_id_time_idx on _hyper_1_1_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_device_id_time_idx on _hyper_1_2_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_device_id_time_idx on _hyper_1_3_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1.00 loops=1) Order: metrics_1."time" DESC -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (never executed) -> Index Only Scan using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=4.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3.00 loops=1) Order: metrics."time" -> Index Only Scan Backward using _hyper_1_1_chunk_metrics_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Index Only Scan Backward using _hyper_1_3_chunk_metrics_time_idx on _hyper_1_3_chunk (never executed) \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Filter: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_device_id_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=56853.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 7196 -> Index Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3598 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 482 -> Index Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 241 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space."time" -> Index Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" > ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Index Cond: (("time" < ('2000-01-08'::cstring)::timestamp with time zone) AND ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space."time")) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space."time")), metrics_space.device_id Sort Method: top-N heapsort -> Result (actual rows=27348.00 loops=1) -> Append (actual rows=27348.00 loops=1) -> Seq Scan on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_5_chunk_metrics_space_device_id_time_idx on _hyper_2_5_chunk (actual rows=3598.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_11_chunk_metrics_space_device_id_time_idx on _hyper_2_11_chunk (actual rows=5038.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Index Cond: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (never executed) Index Cond: ("time" < now()) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (never executed) Index Cond: ("time" < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=13674.00 loops=1) Order: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_device_id_time_idx on _hyper_2_4_chunk (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_device_id_time_idx on _hyper_2_10_chunk (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1.00 loops=1) Order: metrics_space_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk _hyper_2_12_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk _hyper_2_11_chunk_1 (actual rows=1.00 loops=1) -> Index Only Scan Backward using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk _hyper_2_10_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk _hyper_2_9_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk _hyper_2_8_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk _hyper_2_7_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_1."time" DESC -> Index Only Scan Backward using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk _hyper_2_6_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk _hyper_2_5_chunk_1 (never executed) -> Index Only Scan Backward using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk _hyper_2_4_chunk_1 (never executed) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Merge Append (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Merge Append (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = (InitPlan 2).col1) -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=4.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_4_chunk_metrics_space_time_idx on _hyper_2_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_5_chunk_metrics_space_time_idx on _hyper_2_5_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_2_6_chunk_metrics_space_time_idx on _hyper_2_6_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_2_10_chunk_metrics_space_time_idx on _hyper_2_10_chunk (never executed) -> Index Only Scan using _hyper_2_11_chunk_metrics_space_time_idx on _hyper_2_11_chunk (never executed) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_16_chunk.device_id, compress_hyper_4_16_chunk._ts_meta_min_1, compress_hyper_4_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_17_chunk.device_id, compress_hyper_4_17_chunk._ts_meta_min_1, compress_hyper_4_17_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_18_chunk.device_id, compress_hyper_4_18_chunk._ts_meta_min_1, compress_hyper_4_18_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=56853.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=7196.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=24467.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=24467.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 609 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=27.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=25190.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=20385.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 4615 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 5 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=16785.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3215 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 10 -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_18_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=7195.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 7805 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=15.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 15 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=3595.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 6405 -> Seq Scan on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 20 -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) -> Seq Scan on compress_hyper_4_16_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_compressed."time") -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_compressed."time")), metrics_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_13_chunk."time")), _hyper_3_13_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=7196.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=8.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_14_chunk."time")), _hyper_3_14_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_3_15_chunk."time")), _hyper_3_15_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=10076.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=10076.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=12.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 18 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" DESC Chunks excluded during startup: 0 -> Sort (actual rows=100.00 loops=1) Sort Key: _hyper_3_15_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_3_13_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=13674.00 loops=1) Order: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_16_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_16_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_17_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_17_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_4_18_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_4_18_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_compressed (actual rows=5.00 loops=1) Chunks excluded during runtime: 2 InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed metrics_compressed_1 (actual rows=1.00 loops=1) Order: metrics_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk _hyper_3_15_chunk_1 (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk compress_hyper_4_18_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk _hyper_3_14_chunk_1 (never executed) -> Seq Scan on compress_hyper_4_17_chunk compress_hyper_4_17_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_3_13_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk _hyper_3_13_chunk_1 (never executed) -> Seq Scan on compress_hyper_4_16_chunk compress_hyper_4_16_chunk_1 (never executed) -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (never executed) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_4_16_chunk (never executed) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_4_17_chunk (never executed) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=5.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 4995 -> Seq Scan on compress_hyper_4_18_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 25 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=4.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_14_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_17_chunk (actual rows=30.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_3_15_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=30.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=3.00 loops=1) Order: metrics_compressed."time" -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_3_13_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_13_chunk (actual rows=17990.00 loops=1) -> Seq Scan on compress_hyper_4_16_chunk (actual rows=20.00 loops=1) -> Sort (never executed) Sort Key: _hyper_3_14_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_14_chunk (never executed) -> Seq Scan on compress_hyper_4_17_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_3_15_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_3_15_chunk (never executed) -> Seq Scan on compress_hyper_4_18_chunk (never executed) \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (never executed) Index Cond: (device_id = 1) -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_30_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_30_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_33_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_33_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_36_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_28_chunk.device_id, compress_hyper_6_28_chunk._ts_meta_min_1, compress_hyper_6_28_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_29_chunk.device_id, compress_hyper_6_29_chunk._ts_meta_min_1, compress_hyper_6_29_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_29_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_31_chunk.device_id, compress_hyper_6_31_chunk._ts_meta_min_1, compress_hyper_6_31_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_32_chunk.device_id, compress_hyper_6_32_chunk._ts_meta_min_1, compress_hyper_6_32_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_32_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_34_chunk.device_id, compress_hyper_6_34_chunk._ts_meta_min_1, compress_hyper_6_34_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_35_chunk.device_id, compress_hyper_6_35_chunk._ts_meta_min_1, compress_hyper_6_35_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_6_35_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=56853.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=7196.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 8 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=24467.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=14632.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=14632.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 406 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=16.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 2 -> Sort (actual rows=4797.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4797.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 203 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 1 -> Merge Append (actual rows=25190.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=15114.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Sort (actual rows=5038.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR ("time" > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: ((device_id = ANY ('{1,2}'::integer[])) OR (_ts_meta_max_1 > 'Thu Jan 06 00:00:00 2000 PST'::timestamp with time zone)) -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=12231.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 2769 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=15.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=4077.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 923 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=10071.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1929 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 6 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=3357.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 643 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone) :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone) -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=4317.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4683 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=9.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 9 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=1439.00 loops=1) Vectorized Filter: (("time" < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND ("time" > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1561 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 < 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3 :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_31_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=2157.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 3843 -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=719.00 loops=1) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 1281 -> Seq Scan on compress_hyper_6_33_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) Rows Removed by Filter: 4 -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_34_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_35_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) Vectorized Filter: (("time" > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND ("time" < ('2000-01-08'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_6_36_chunk (never executed) Filter: ((_ts_meta_max_1 > 'Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-08'::cstring)::timestamp with time zone)) -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) :PREFIX SELECT min(time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) :PREFIX SELECT last(time, time) FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) -> Seq Scan on compress_hyper_6_30_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) -> Seq Scan on compress_hyper_6_29_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) -> Seq Scan on compress_hyper_6_28_chunk (never executed) -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: time_bucket('@ 1 day'::interval, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: date_trunc('day'::text, metrics_space_compressed."time") -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=10794.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_21_chunk."time")) Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_24_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: (date_trunc('day'::text, _hyper_5_27_chunk."time")) -> Result (never executed) -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, metrics_space_compressed."time")), metrics_space_compressed.device_id -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_19_chunk."time")), _hyper_5_19_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_20_chunk."time")), _hyper_5_20_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=4.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 8 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_22_chunk."time")), _hyper_5_22_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_23_chunk."time")), _hyper_5_23_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_25_chunk."time")), _hyper_5_25_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=1.00 loops=1) Sort Key: (date_trunc('day'::text, _hyper_5_26_chunk."time")), _hyper_5_26_chunk.device_id Sort Method: top-N heapsort -> Result (actual rows=5038.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < (now() + '@ 1 mon'::interval)) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < (now() + '@ 1 mon'::interval)) -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_27_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_5_26_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_5_25_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_33_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_32_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_31_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_30_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_20_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_29_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -> Sort (never executed) Sort Key: _hyper_5_19_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_28_chunk (never executed) Filter: (_ts_meta_min_1 < now()) -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=13674.00 loops=1) Order: metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_28_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_31_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_6_34_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=5.00 loops=1) InitPlan 2 -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed metrics_space_compressed_1 (actual rows=1.00 loops=1) Order: metrics_space_compressed_1."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk _hyper_5_27_chunk_1 (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk compress_hyper_6_36_chunk_1 (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk _hyper_5_26_chunk_1 (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk compress_hyper_6_35_chunk_1 (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk_1."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk _hyper_5_25_chunk_1 (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk compress_hyper_6_34_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_24_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk _hyper_5_24_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_33_chunk compress_hyper_6_33_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk _hyper_5_23_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_32_chunk compress_hyper_6_32_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_22_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk _hyper_5_22_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_31_chunk compress_hyper_6_31_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed_1."time" DESC -> Sort (never executed) Sort Key: _hyper_5_21_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk _hyper_5_21_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_30_chunk compress_hyper_6_30_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_20_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk _hyper_5_20_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_29_chunk compress_hyper_6_29_chunk_1 (never executed) -> Sort (never executed) Sort Key: _hyper_5_19_chunk_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk _hyper_5_19_chunk_1 (never executed) -> Seq Scan on compress_hyper_6_28_chunk compress_hyper_6_28_chunk_1 (never executed) -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 4 -> Merge Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=0.00 loops=1) Filter: ("time" = (InitPlan 2).col1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 6 -> Merge Append (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=1.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_34_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=3.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 2997 -> Seq Scan on compress_hyper_6_35_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=1.00 loops=1) Filter: ("time" = (InitPlan 2).col1) Rows Removed by Filter: 999 -> Seq Scan on compress_hyper_6_36_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= (InitPlan 2).col1) AND (_ts_meta_max_1 >= (InitPlan 2).col1)) Rows Removed by Filter: 5 -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); --- QUERY PLAN --- Limit (actual rows=4.00 loops=1) InitPlan 1 -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=4.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=4.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_22_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_31_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_23_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_32_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_24_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_33_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_25_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_34_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_26_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_6_35_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_27_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_6_36_chunk (actual rows=6.00 loops=1) RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=3.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=3.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_19_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_19_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_28_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_5_20_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_20_chunk (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_6_29_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_5_21_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_5_21_chunk (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_6_30_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_22_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_22_chunk (never executed) -> Seq Scan on compress_hyper_6_31_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_23_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_23_chunk (never executed) -> Seq Scan on compress_hyper_6_32_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_24_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_24_chunk (never executed) -> Seq Scan on compress_hyper_6_33_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_5_25_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_25_chunk (never executed) -> Seq Scan on compress_hyper_6_34_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_26_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_26_chunk (never executed) -> Seq Scan on compress_hyper_6_35_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_5_27_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_5_27_chunk (never executed) -> Seq Scan on compress_hyper_6_36_chunk (never executed) -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/partialize_finalize.out����������������������������������������0000664�0000000�0000000�00000225107�15100345067�0024222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST1 count with integers SHOW enable_partitionwise_aggregate; enable_partitionwise_aggregate -------------------------------- off SET enable_partitionwise_aggregate = on; create table foo (a integer, b integer, c integer); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); insert into foo values( 3 , 16 , 20); create or replace view v1(a , partial) as SELECT a, _timescaledb_functions.partialize_agg( count(b)) from foo group by a; create table t1 as select * from v1; select a, _timescaledb_functions.finalize_agg( 'count("any")', null, null, null, partial, cast('1' as int8) ) from t1 group by a order by a ; a | finalize_agg ---+-------------- 1 | 5 2 | 3 3 | 1 insert into t1 select * from t1; select a, _timescaledb_functions.finalize_agg( 'count("any")', null, null, null, partial, cast('1' as int8) ) from t1 group by a order by a ; a | finalize_agg ---+-------------- 1 | 10 2 | 6 3 | 2 --TEST2 sum numeric and min on float-- drop table t1; drop view v1; drop table foo; create table foo (a integer, b numeric , c float); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 20 , 19); insert into foo values( 1 , 30 , 11.0); insert into foo values( 1 , 40 , 200); insert into foo values( 1 , 50 , -10); insert into foo values( 2 , 10 , 20); insert into foo values( 2 , 20 , 20); insert into foo values( 2 , 30 , 20); insert into foo values( 3 , 40 , 0); create or replace view v1(a , partialb, partialminc) as SELECT a, _timescaledb_functions.partialize_agg( sum(b)) , _timescaledb_functions.partialize_agg( min(c)) from foo group by a; create table t1 as select * from v1; select a, _timescaledb_functions.finalize_agg( 'sum(numeric)', null, null, null, partialb, cast('1' as numeric) ) sumb, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; a | sumb | minc ---+------+------ 1 | 150 | -10 2 | 60 | 20 3 | 40 | 0 insert into foo values( 3, 0, -1); insert into foo values( 5, 40, 10); insert into foo values( 5, 40, 0); --note that rows for 3 get added all over again + new row --sum aggfnoid 2114, min aggfnoid is 2136 oid numeric is 1700 insert into t1 select * from v1 where ( a = 3 ) or a = 5; select a, _timescaledb_functions.finalize_agg( 'sum(numeric)', null, null, null, partialb, cast('1' as numeric) ) sumb, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; a | sumb | minc ---+------+------ 1 | 150 | -10 2 | 60 | 20 3 | 80 | -1 5 | 80 | 0 SET enable_partitionwise_aggregate = off; --TEST3 sum with expressions drop table t1; drop view v1; drop table foo; create table foo (a integer, b numeric , c float); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 20 , 19); insert into foo values( 1 , 30 , 11.0); insert into foo values( 1 , 40 , 200); insert into foo values( 1 , 50 , -10); insert into foo values( 2 , 10 , 20); insert into foo values( 2 , 20 , 20); insert into foo values( 2 , 30 , 20); insert into foo values( 3 , 40 , 0); insert into foo values(10, NULL, NULL); insert into foo values(11, NULL, NULL); insert into foo values(11, NULL, NULL); insert into foo values(12, NULL, NULL); create or replace view v1(a , b, partialb, partialminc) as SELECT a, b, _timescaledb_functions.partialize_agg( sum(b+c)) , _timescaledb_functions.partialize_agg( min(c)) from foo group by a, b ; create table t1 as select * from v1; insert into foo values( 3, 0, -1); insert into foo values( 5, 40, 10); insert into foo values( 5, 40, 0); insert into foo values(12, 10, 20); insert into t1 select * from v1 where ( a = 3 and b = 0 ) or a = 5 or (a = 12 and b = 10) ; --results should match query: select a, sum(b+c), min(c) from foo group by a order by a; --sum aggfnoid 2111 for float8, min aggfnoid is 2136 oid numeric is 1700 select a, _timescaledb_functions.finalize_agg( 'sum(double precision)', null, null, null, partialb, null::float8 ) sumcd, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; a | sumcd | minc ----+-------+------ 1 | 390 | -10 2 | 120 | 20 3 | 39 | -1 5 | 90 | 0 10 | | 11 | | 12 | 30 | 20 insert into t1 select * from v1; select a, _timescaledb_functions.finalize_agg( 'sum(double precision)', null, null, null, partialb, null::float8 ) sumcd, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; a | sumcd | minc ----+-------+------ 1 | 780 | -10 2 | 240 | 20 3 | 78 | -1 5 | 180 | 0 10 | | 11 | | 12 | 60 | 20 -- TEST4 with collation (text), NULLS and timestamp -- drop table t1; drop view v1; drop table foo; create table foo (a integer, b numeric , c text, d timestamptz, e bigint); insert into foo values( 1 , 10 , 'hello', '2010-01-01 09:00:00-08', 10); insert into foo values( 1 , 20 , 'abc', '2010-01-02 09:00:00-08', 20); insert into foo values( 1 , 30 , 'abcd', '2010-01-03 09:00:00-08', 30); insert into foo values( 1 , 40 , 'abcde', NULL, 40); insert into foo values( 1 , 50 , NULL, '2010-01-01 09:00:00-08', 50); --group with all values for c and d same insert into foo values( 2 , 10 , 'hello', '2010-01-01 09:00:00-08', 10); insert into foo values( 2 , 20 , 'hello', '2010-01-01 09:00:00-08', 20); insert into foo values( 2 , 30 , 'hello', '2010-01-01 09:00:00-08', 30); --group with all values for c and d NULL insert into foo values( 3 , 40 , NULL, NULL, 40); insert into foo values( 3 , 50 , NULL, NULL, 50); insert into foo values(11, NULL, NULL, NULL, NULL); insert into foo values(11, NULL, 'hello', '2010-01-02 09:00:00-05', NULL); --group with all values for c and d NULL and later add non-null. insert into foo values(12, NULL, NULL, NULL, NULL); create or replace view v1(a , b, partialb, partialc, partiald, partiale, partialf) as SELECT a, b, _timescaledb_functions.partialize_agg(sum(b)) , _timescaledb_functions.partialize_agg(min(c)) , _timescaledb_functions.partialize_agg(max(d)) , _timescaledb_functions.partialize_agg(stddev(b)) , _timescaledb_functions.partialize_agg(stddev(e)) from foo group by a, b ; create table saved_partials as select * from v1; create table t1 as select * from v1; --sum 2114, collid 0, min(text) 2145, collid 100, max(ts) 2127 insert into foo values(12, 10, 'hello', '2010-01-02 09:00:00-05', 10); insert into t1 select * from v1 where (a = 12 and b = 10) ; --select a, sum(b), min(c) , max(d), stddev(b), stddev(e) from foo group by a order by a; --results should match above query CREATE OR REPLACE VIEW vfinal(a , sumb, minc, maxd, stddevb, stddeve) AS select a, _timescaledb_functions.finalize_agg( 'sum(numeric)', null, null, null, partialb, null::numeric ) sumb , _timescaledb_functions.finalize_agg( 'min(text)', 'pg_catalog', 'default', null, partialc, null::text ) minc , _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partiald, null::timestamptz ) maxd , _timescaledb_functions.finalize_agg( 'stddev(numeric)', null, null, null, partiale, null::numeric ) stddevb , _timescaledb_functions.finalize_agg( 'stddev(int8)', null, null, null, partialf, null::numeric ) stddeve from t1 group by a order by a ; SELECT * FROM vfinal; a | sumb | minc | maxd | stddevb | stddeve ----+------+-------+------------------------------+---------------------+--------------------- 1 | 150 | abc | Sun Jan 03 09:00:00 2010 PST | 15.8113883008418967 | 15.8113883008418967 2 | 60 | hello | Fri Jan 01 09:00:00 2010 PST | 10.0000000000000000 | 10.0000000000000000 3 | 90 | | | 7.0710678118654752 | 7.0710678118654752 11 | | hello | Sat Jan 02 06:00:00 2010 PST | | 12 | 10 | hello | Sat Jan 02 06:00:00 2010 PST | | CREATE TABLE vfinal_res AS SELECT * FROM vfinal; --with having clause -- select a, b , _timescaledb_functions.finalize_agg( 'min(text)', 'pg_catalog', 'default', null, partialc, null::text ) minc, _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partiald, null::timestamptz ) maxd from t1 where b is not null group by a, b having _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partiald, null::timestamptz ) is not null order by a, b; a | b | minc | maxd ----+----+-------+------------------------------ 1 | 10 | hello | Fri Jan 01 09:00:00 2010 PST 1 | 20 | abc | Sat Jan 02 09:00:00 2010 PST 1 | 30 | abcd | Sun Jan 03 09:00:00 2010 PST 1 | 50 | | Fri Jan 01 09:00:00 2010 PST 2 | 10 | hello | Fri Jan 01 09:00:00 2010 PST 2 | 20 | hello | Fri Jan 01 09:00:00 2010 PST 2 | 30 | hello | Fri Jan 01 09:00:00 2010 PST 12 | 10 | hello | Sat Jan 02 06:00:00 2010 PST --TEST5 test with TOAST data drop view vfinal; drop table t1; drop view v1; drop table foo; create table foo( a integer, b timestamptz, toastval TEXT); -- Set storage type to EXTERNAL to prevent PostgreSQL from compressing my -- easily compressable string and instead store it with TOAST ALTER TABLE foo ALTER COLUMN toastval SET STORAGE EXTERNAL; SELECT count(*) FROM create_hypertable('foo', 'b'); count ------- 1 INSERT INTO foo VALUES( 1, '2004-10-19 10:23:54', repeat('this must be over 2k. ', 1100)); INSERT INTO foo VALUES(1, '2005-10-19 10:23:54', repeat('I am a tall big giraffe in the zoo. ', 1100)); INSERT INTO foo values( 1, '2005-01-01 00:00:00+00', NULL); INSERT INTO foo values( 2, '2005-01-01 00:00:00+00', NULL); create or replace view v1(a, partialb, partialtv) as select a, _timescaledb_functions.partialize_agg( max(b) ), _timescaledb_functions.partialize_agg( min(toastval)) from foo group by a; EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF) create table t1 as select * from v1; --- QUERY PLAN --- Partial HashAggregate Output: foo.a, _timescaledb_functions.partialize_agg(PARTIAL max(foo.b)), _timescaledb_functions.partialize_agg(PARTIAL min(foo.toastval)) Group Key: foo.a -> Append -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.a, _hyper_1_1_chunk.b, _hyper_1_1_chunk.toastval -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.a, _hyper_1_2_chunk.b, _hyper_1_2_chunk.toastval -> Seq Scan on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.a, _hyper_1_3_chunk.b, _hyper_1_3_chunk.toastval create table t1 as select * from v1; insert into t1 select * from v1; select a, _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partialb, null::timestamptz ) maxb, _timescaledb_functions.finalize_agg( 'min(text)', 'pg_catalog', 'default', null, partialtv, null::text ) = repeat('I am a tall big giraffe in the zoo. ', 1100) mintv_equal from t1 group by a order by a; a | maxb | mintv_equal ---+------------------------------+------------- 1 | Wed Oct 19 10:23:54 2005 PDT | t 2 | Fri Dec 31 16:00:00 2004 PST | --non top-level partials with cte as ( select a, _timescaledb_functions.partialize_agg(min(toastval)) tp from foo group by a ) select length(tp) from cte; length -------- 40700 select length(_timescaledb_functions.partialize_agg( min(toastval))) from foo group by a; length -------- 40700 select length(_timescaledb_functions.partialize_agg(min(a+1))) from foo; length -------- 4 \set ON_ERROR_STOP 0 select length(_timescaledb_functions.partialize_agg(1+min(a))) from foo; ERROR: the input to partialize must be an aggregate select length(_timescaledb_functions.partialize_agg(min(a)+min(a))) from foo; ERROR: the input to partialize must be an aggregate --non-trivial HAVING clause not allowed with partialize_agg select time_bucket('1 hour', b) as b, _timescaledb_functions.partialize_agg(avg(a)) from foo group by 1 having avg(a) > 3; ERROR: cannot partialize aggregate with HAVING clause --mixing partialized and non-partialized aggs is not allowed select time_bucket('1 hour', b) as b, _timescaledb_functions.partialize_agg(avg(a)), sum(a) from foo group by 1; ERROR: cannot mix partialized and non-partialized aggregates in the same statement \set ON_ERROR_STOP 1 --partializing works with HAVING when the planner can effectively --reduce it. In this case to a simple filter. select time_bucket('1 hour', b) as b, toastval, _timescaledb_functions.partialize_agg(avg(a)) from foo group by b, toastval having toastval LIKE 'does not exist'; b | toastval | partialize_agg ---+----------+---------------- -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type %', pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); select aggregate_to_test_ffunc_extra(8, 'name'::text); WARNING: type text aggregate_to_test_ffunc_extra ------------------------------- \set ON_ERROR_STOP 0 --errors on wrong input type array with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, null, part, null::text) from cte; ERROR: cannot pass null input_type with FINALFUNC_EXTRA aggregates with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['a'::name, 'b'::name, 'c'::name]], part, null::text) from cte; ERROR: invalid input type array: expecting slices of size 2 with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array[]::name[]]::name[], part, null::text) from cte; ERROR: invalid input type array: wrong number of dimensions with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[]::name[], part, null::text) from cte; ERROR: invalid input type array: wrong number of dimensions with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['public'::name, 'int'::name], array['public', 'text']], part, null::text) from cte; ERROR: invalid input type: public.int with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['public'::name, 'int4'::name], array['public', 'text']], part, null::text) from cte; ERROR: invalid input type: public.int4 with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['pg_catalog'::name, 'int4'::name], array['pg_catalog', 'text'], array['pg_catalog', 'text']], part, null::text) from cte; ERROR: invalid number of input types select _timescaledb_functions.finalize_agg(NULL::text,NULL::name,NULL::name,NULL::_name,NULL::bytea,a) over () from foo; ERROR: finalize_agg_sfunc called in non-aggregate context \set ON_ERROR_STOP 1 --make sure right type in warning and is null returns true with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['pg_catalog'::name, 'int4'::name], array['pg_catalog', 'text']], part, null::text) is null from cte; WARNING: type text ?column? ---------- t with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 1::bigint)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['pg_catalog'::name, 'int4'::name], array['pg_catalog', 'int8']], part, null::text) is null from cte; WARNING: type bigint ?column? ---------- t -- Issue 4922 CREATE TABLE issue4922 ( time TIMESTAMPTZ NOT NULL, value INTEGER ); SELECT create_hypertable('issue4922', 'time'); create_hypertable ------------------------ (2,public,issue4922,t) -- helper function: integer -> pseudorandom integer [0..100]. CREATE OR REPLACE FUNCTION mix(x INTEGER) RETURNS INTEGER AS $$ SELECT (((hashint4(x) / (pow(2, 31) - 1) + 1) / 2) * 100)::INTEGER $$ LANGUAGE SQL; INSERT INTO issue4922 (time, value) SELECT '2022-01-01 00:00:00-03'::timestamptz + interval '1 year' * mix(x), mix(x) FROM generate_series(1, 100000) x(x); SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on SET parallel_setup_cost = 0; -- Materialize partials from execution of parallel query plan EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF) SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; --- QUERY PLAN --- Partial Aggregate Output: _timescaledb_functions.partialize_agg(PARTIAL sum(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL avg(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL min(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL max(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL count(*)) -> Gather Output: (PARTIAL sum(issue4922.value)), (PARTIAL avg(issue4922.value)), (PARTIAL min(issue4922.value)), (PARTIAL max(issue4922.value)), (PARTIAL count(*)) Workers Planned: 2 -> Parallel Append -> Partial Aggregate Output: PARTIAL sum(_hyper_2_4_chunk.value), PARTIAL avg(_hyper_2_4_chunk.value), PARTIAL min(_hyper_2_4_chunk.value), PARTIAL max(_hyper_2_4_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_5_chunk.value), PARTIAL avg(_hyper_2_5_chunk.value), PARTIAL min(_hyper_2_5_chunk.value), PARTIAL max(_hyper_2_5_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_6_chunk.value), PARTIAL avg(_hyper_2_6_chunk.value), PARTIAL min(_hyper_2_6_chunk.value), PARTIAL max(_hyper_2_6_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_6_chunk Output: _hyper_2_6_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_7_chunk.value), PARTIAL avg(_hyper_2_7_chunk.value), PARTIAL min(_hyper_2_7_chunk.value), PARTIAL max(_hyper_2_7_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_7_chunk Output: _hyper_2_7_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_8_chunk.value), PARTIAL avg(_hyper_2_8_chunk.value), PARTIAL min(_hyper_2_8_chunk.value), PARTIAL max(_hyper_2_8_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_8_chunk Output: _hyper_2_8_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_9_chunk.value), PARTIAL avg(_hyper_2_9_chunk.value), PARTIAL min(_hyper_2_9_chunk.value), PARTIAL max(_hyper_2_9_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_9_chunk Output: _hyper_2_9_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_10_chunk.value), PARTIAL avg(_hyper_2_10_chunk.value), PARTIAL min(_hyper_2_10_chunk.value), PARTIAL max(_hyper_2_10_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_10_chunk Output: _hyper_2_10_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_11_chunk.value), PARTIAL avg(_hyper_2_11_chunk.value), PARTIAL min(_hyper_2_11_chunk.value), PARTIAL max(_hyper_2_11_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_11_chunk Output: _hyper_2_11_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_12_chunk.value), PARTIAL avg(_hyper_2_12_chunk.value), PARTIAL min(_hyper_2_12_chunk.value), PARTIAL max(_hyper_2_12_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_12_chunk Output: _hyper_2_12_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_13_chunk.value), PARTIAL avg(_hyper_2_13_chunk.value), PARTIAL min(_hyper_2_13_chunk.value), PARTIAL max(_hyper_2_13_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_13_chunk Output: _hyper_2_13_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_14_chunk.value), PARTIAL avg(_hyper_2_14_chunk.value), PARTIAL min(_hyper_2_14_chunk.value), PARTIAL max(_hyper_2_14_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_14_chunk Output: _hyper_2_14_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_15_chunk.value), PARTIAL avg(_hyper_2_15_chunk.value), PARTIAL min(_hyper_2_15_chunk.value), PARTIAL max(_hyper_2_15_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_15_chunk Output: _hyper_2_15_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_16_chunk.value), PARTIAL avg(_hyper_2_16_chunk.value), PARTIAL min(_hyper_2_16_chunk.value), PARTIAL max(_hyper_2_16_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_16_chunk Output: _hyper_2_16_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_17_chunk.value), PARTIAL avg(_hyper_2_17_chunk.value), PARTIAL min(_hyper_2_17_chunk.value), PARTIAL max(_hyper_2_17_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_17_chunk Output: _hyper_2_17_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_18_chunk.value), PARTIAL avg(_hyper_2_18_chunk.value), PARTIAL min(_hyper_2_18_chunk.value), PARTIAL max(_hyper_2_18_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_18_chunk Output: _hyper_2_18_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_19_chunk.value), PARTIAL avg(_hyper_2_19_chunk.value), PARTIAL min(_hyper_2_19_chunk.value), PARTIAL max(_hyper_2_19_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_19_chunk Output: _hyper_2_19_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_20_chunk.value), PARTIAL avg(_hyper_2_20_chunk.value), PARTIAL min(_hyper_2_20_chunk.value), PARTIAL max(_hyper_2_20_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_20_chunk Output: _hyper_2_20_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_21_chunk.value), PARTIAL avg(_hyper_2_21_chunk.value), PARTIAL min(_hyper_2_21_chunk.value), PARTIAL max(_hyper_2_21_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_21_chunk Output: _hyper_2_21_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_22_chunk.value), PARTIAL avg(_hyper_2_22_chunk.value), PARTIAL min(_hyper_2_22_chunk.value), PARTIAL max(_hyper_2_22_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_22_chunk Output: _hyper_2_22_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_23_chunk.value), PARTIAL avg(_hyper_2_23_chunk.value), PARTIAL min(_hyper_2_23_chunk.value), PARTIAL max(_hyper_2_23_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_23_chunk Output: _hyper_2_23_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_24_chunk.value), PARTIAL avg(_hyper_2_24_chunk.value), PARTIAL min(_hyper_2_24_chunk.value), PARTIAL max(_hyper_2_24_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_24_chunk Output: _hyper_2_24_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_25_chunk.value), PARTIAL avg(_hyper_2_25_chunk.value), PARTIAL min(_hyper_2_25_chunk.value), PARTIAL max(_hyper_2_25_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_25_chunk Output: _hyper_2_25_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_26_chunk.value), PARTIAL avg(_hyper_2_26_chunk.value), PARTIAL min(_hyper_2_26_chunk.value), PARTIAL max(_hyper_2_26_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_26_chunk Output: _hyper_2_26_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_27_chunk.value), PARTIAL avg(_hyper_2_27_chunk.value), PARTIAL min(_hyper_2_27_chunk.value), PARTIAL max(_hyper_2_27_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_27_chunk Output: _hyper_2_27_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_28_chunk.value), PARTIAL avg(_hyper_2_28_chunk.value), PARTIAL min(_hyper_2_28_chunk.value), PARTIAL max(_hyper_2_28_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_28_chunk Output: _hyper_2_28_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_29_chunk.value), PARTIAL avg(_hyper_2_29_chunk.value), PARTIAL min(_hyper_2_29_chunk.value), PARTIAL max(_hyper_2_29_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_29_chunk Output: _hyper_2_29_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_30_chunk.value), PARTIAL avg(_hyper_2_30_chunk.value), PARTIAL min(_hyper_2_30_chunk.value), PARTIAL max(_hyper_2_30_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_30_chunk Output: _hyper_2_30_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_31_chunk.value), PARTIAL avg(_hyper_2_31_chunk.value), PARTIAL min(_hyper_2_31_chunk.value), PARTIAL max(_hyper_2_31_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_31_chunk Output: _hyper_2_31_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_32_chunk.value), PARTIAL avg(_hyper_2_32_chunk.value), PARTIAL min(_hyper_2_32_chunk.value), PARTIAL max(_hyper_2_32_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_32_chunk Output: _hyper_2_32_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_33_chunk.value), PARTIAL avg(_hyper_2_33_chunk.value), PARTIAL min(_hyper_2_33_chunk.value), PARTIAL max(_hyper_2_33_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_33_chunk Output: _hyper_2_33_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_34_chunk.value), PARTIAL avg(_hyper_2_34_chunk.value), PARTIAL min(_hyper_2_34_chunk.value), PARTIAL max(_hyper_2_34_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_34_chunk Output: _hyper_2_34_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_35_chunk.value), PARTIAL avg(_hyper_2_35_chunk.value), PARTIAL min(_hyper_2_35_chunk.value), PARTIAL max(_hyper_2_35_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_35_chunk Output: _hyper_2_35_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_36_chunk.value), PARTIAL avg(_hyper_2_36_chunk.value), PARTIAL min(_hyper_2_36_chunk.value), PARTIAL max(_hyper_2_36_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_36_chunk Output: _hyper_2_36_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_37_chunk.value), PARTIAL avg(_hyper_2_37_chunk.value), PARTIAL min(_hyper_2_37_chunk.value), PARTIAL max(_hyper_2_37_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_37_chunk Output: _hyper_2_37_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_38_chunk.value), PARTIAL avg(_hyper_2_38_chunk.value), PARTIAL min(_hyper_2_38_chunk.value), PARTIAL max(_hyper_2_38_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_38_chunk Output: _hyper_2_38_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_39_chunk.value), PARTIAL avg(_hyper_2_39_chunk.value), PARTIAL min(_hyper_2_39_chunk.value), PARTIAL max(_hyper_2_39_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_39_chunk Output: _hyper_2_39_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_40_chunk.value), PARTIAL avg(_hyper_2_40_chunk.value), PARTIAL min(_hyper_2_40_chunk.value), PARTIAL max(_hyper_2_40_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_40_chunk Output: _hyper_2_40_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_41_chunk.value), PARTIAL avg(_hyper_2_41_chunk.value), PARTIAL min(_hyper_2_41_chunk.value), PARTIAL max(_hyper_2_41_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_41_chunk Output: _hyper_2_41_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_42_chunk.value), PARTIAL avg(_hyper_2_42_chunk.value), PARTIAL min(_hyper_2_42_chunk.value), PARTIAL max(_hyper_2_42_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_42_chunk Output: _hyper_2_42_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_43_chunk.value), PARTIAL avg(_hyper_2_43_chunk.value), PARTIAL min(_hyper_2_43_chunk.value), PARTIAL max(_hyper_2_43_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_43_chunk Output: _hyper_2_43_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_44_chunk.value), PARTIAL avg(_hyper_2_44_chunk.value), PARTIAL min(_hyper_2_44_chunk.value), PARTIAL max(_hyper_2_44_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_44_chunk Output: _hyper_2_44_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_45_chunk.value), PARTIAL avg(_hyper_2_45_chunk.value), PARTIAL min(_hyper_2_45_chunk.value), PARTIAL max(_hyper_2_45_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_45_chunk Output: _hyper_2_45_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_46_chunk.value), PARTIAL avg(_hyper_2_46_chunk.value), PARTIAL min(_hyper_2_46_chunk.value), PARTIAL max(_hyper_2_46_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_46_chunk Output: _hyper_2_46_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_47_chunk.value), PARTIAL avg(_hyper_2_47_chunk.value), PARTIAL min(_hyper_2_47_chunk.value), PARTIAL max(_hyper_2_47_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_47_chunk Output: _hyper_2_47_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_48_chunk.value), PARTIAL avg(_hyper_2_48_chunk.value), PARTIAL min(_hyper_2_48_chunk.value), PARTIAL max(_hyper_2_48_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_48_chunk Output: _hyper_2_48_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_49_chunk.value), PARTIAL avg(_hyper_2_49_chunk.value), PARTIAL min(_hyper_2_49_chunk.value), PARTIAL max(_hyper_2_49_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_49_chunk Output: _hyper_2_49_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_50_chunk.value), PARTIAL avg(_hyper_2_50_chunk.value), PARTIAL min(_hyper_2_50_chunk.value), PARTIAL max(_hyper_2_50_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_50_chunk Output: _hyper_2_50_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_51_chunk.value), PARTIAL avg(_hyper_2_51_chunk.value), PARTIAL min(_hyper_2_51_chunk.value), PARTIAL max(_hyper_2_51_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_51_chunk Output: _hyper_2_51_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_52_chunk.value), PARTIAL avg(_hyper_2_52_chunk.value), PARTIAL min(_hyper_2_52_chunk.value), PARTIAL max(_hyper_2_52_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_52_chunk Output: _hyper_2_52_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_53_chunk.value), PARTIAL avg(_hyper_2_53_chunk.value), PARTIAL min(_hyper_2_53_chunk.value), PARTIAL max(_hyper_2_53_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_53_chunk Output: _hyper_2_53_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_54_chunk.value), PARTIAL avg(_hyper_2_54_chunk.value), PARTIAL min(_hyper_2_54_chunk.value), PARTIAL max(_hyper_2_54_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_54_chunk Output: _hyper_2_54_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_55_chunk.value), PARTIAL avg(_hyper_2_55_chunk.value), PARTIAL min(_hyper_2_55_chunk.value), PARTIAL max(_hyper_2_55_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_55_chunk Output: _hyper_2_55_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_56_chunk.value), PARTIAL avg(_hyper_2_56_chunk.value), PARTIAL min(_hyper_2_56_chunk.value), PARTIAL max(_hyper_2_56_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_56_chunk Output: _hyper_2_56_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_57_chunk.value), PARTIAL avg(_hyper_2_57_chunk.value), PARTIAL min(_hyper_2_57_chunk.value), PARTIAL max(_hyper_2_57_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_57_chunk Output: _hyper_2_57_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_58_chunk.value), PARTIAL avg(_hyper_2_58_chunk.value), PARTIAL min(_hyper_2_58_chunk.value), PARTIAL max(_hyper_2_58_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_58_chunk Output: _hyper_2_58_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_59_chunk.value), PARTIAL avg(_hyper_2_59_chunk.value), PARTIAL min(_hyper_2_59_chunk.value), PARTIAL max(_hyper_2_59_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_59_chunk Output: _hyper_2_59_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_60_chunk.value), PARTIAL avg(_hyper_2_60_chunk.value), PARTIAL min(_hyper_2_60_chunk.value), PARTIAL max(_hyper_2_60_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_60_chunk Output: _hyper_2_60_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_61_chunk.value), PARTIAL avg(_hyper_2_61_chunk.value), PARTIAL min(_hyper_2_61_chunk.value), PARTIAL max(_hyper_2_61_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_61_chunk Output: _hyper_2_61_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_62_chunk.value), PARTIAL avg(_hyper_2_62_chunk.value), PARTIAL min(_hyper_2_62_chunk.value), PARTIAL max(_hyper_2_62_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_62_chunk Output: _hyper_2_62_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_63_chunk.value), PARTIAL avg(_hyper_2_63_chunk.value), PARTIAL min(_hyper_2_63_chunk.value), PARTIAL max(_hyper_2_63_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_63_chunk Output: _hyper_2_63_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_64_chunk.value), PARTIAL avg(_hyper_2_64_chunk.value), PARTIAL min(_hyper_2_64_chunk.value), PARTIAL max(_hyper_2_64_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_64_chunk Output: _hyper_2_64_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_65_chunk.value), PARTIAL avg(_hyper_2_65_chunk.value), PARTIAL min(_hyper_2_65_chunk.value), PARTIAL max(_hyper_2_65_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_65_chunk Output: _hyper_2_65_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_66_chunk.value), PARTIAL avg(_hyper_2_66_chunk.value), PARTIAL min(_hyper_2_66_chunk.value), PARTIAL max(_hyper_2_66_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_66_chunk Output: _hyper_2_66_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_67_chunk.value), PARTIAL avg(_hyper_2_67_chunk.value), PARTIAL min(_hyper_2_67_chunk.value), PARTIAL max(_hyper_2_67_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_67_chunk Output: _hyper_2_67_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_68_chunk.value), PARTIAL avg(_hyper_2_68_chunk.value), PARTIAL min(_hyper_2_68_chunk.value), PARTIAL max(_hyper_2_68_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_68_chunk Output: _hyper_2_68_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_69_chunk.value), PARTIAL avg(_hyper_2_69_chunk.value), PARTIAL min(_hyper_2_69_chunk.value), PARTIAL max(_hyper_2_69_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_69_chunk Output: _hyper_2_69_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_70_chunk.value), PARTIAL avg(_hyper_2_70_chunk.value), PARTIAL min(_hyper_2_70_chunk.value), PARTIAL max(_hyper_2_70_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_70_chunk Output: _hyper_2_70_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_71_chunk.value), PARTIAL avg(_hyper_2_71_chunk.value), PARTIAL min(_hyper_2_71_chunk.value), PARTIAL max(_hyper_2_71_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_71_chunk Output: _hyper_2_71_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_72_chunk.value), PARTIAL avg(_hyper_2_72_chunk.value), PARTIAL min(_hyper_2_72_chunk.value), PARTIAL max(_hyper_2_72_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_72_chunk Output: _hyper_2_72_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_73_chunk.value), PARTIAL avg(_hyper_2_73_chunk.value), PARTIAL min(_hyper_2_73_chunk.value), PARTIAL max(_hyper_2_73_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_73_chunk Output: _hyper_2_73_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_74_chunk.value), PARTIAL avg(_hyper_2_74_chunk.value), PARTIAL min(_hyper_2_74_chunk.value), PARTIAL max(_hyper_2_74_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_74_chunk Output: _hyper_2_74_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_75_chunk.value), PARTIAL avg(_hyper_2_75_chunk.value), PARTIAL min(_hyper_2_75_chunk.value), PARTIAL max(_hyper_2_75_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_75_chunk Output: _hyper_2_75_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_76_chunk.value), PARTIAL avg(_hyper_2_76_chunk.value), PARTIAL min(_hyper_2_76_chunk.value), PARTIAL max(_hyper_2_76_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_76_chunk Output: _hyper_2_76_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_77_chunk.value), PARTIAL avg(_hyper_2_77_chunk.value), PARTIAL min(_hyper_2_77_chunk.value), PARTIAL max(_hyper_2_77_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_77_chunk Output: _hyper_2_77_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_78_chunk.value), PARTIAL avg(_hyper_2_78_chunk.value), PARTIAL min(_hyper_2_78_chunk.value), PARTIAL max(_hyper_2_78_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_78_chunk Output: _hyper_2_78_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_79_chunk.value), PARTIAL avg(_hyper_2_79_chunk.value), PARTIAL min(_hyper_2_79_chunk.value), PARTIAL max(_hyper_2_79_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_79_chunk Output: _hyper_2_79_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_80_chunk.value), PARTIAL avg(_hyper_2_80_chunk.value), PARTIAL min(_hyper_2_80_chunk.value), PARTIAL max(_hyper_2_80_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_80_chunk Output: _hyper_2_80_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_81_chunk.value), PARTIAL avg(_hyper_2_81_chunk.value), PARTIAL min(_hyper_2_81_chunk.value), PARTIAL max(_hyper_2_81_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_81_chunk Output: _hyper_2_81_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_82_chunk.value), PARTIAL avg(_hyper_2_82_chunk.value), PARTIAL min(_hyper_2_82_chunk.value), PARTIAL max(_hyper_2_82_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_82_chunk Output: _hyper_2_82_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_83_chunk.value), PARTIAL avg(_hyper_2_83_chunk.value), PARTIAL min(_hyper_2_83_chunk.value), PARTIAL max(_hyper_2_83_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_83_chunk Output: _hyper_2_83_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_84_chunk.value), PARTIAL avg(_hyper_2_84_chunk.value), PARTIAL min(_hyper_2_84_chunk.value), PARTIAL max(_hyper_2_84_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_84_chunk Output: _hyper_2_84_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_85_chunk.value), PARTIAL avg(_hyper_2_85_chunk.value), PARTIAL min(_hyper_2_85_chunk.value), PARTIAL max(_hyper_2_85_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_85_chunk Output: _hyper_2_85_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_86_chunk.value), PARTIAL avg(_hyper_2_86_chunk.value), PARTIAL min(_hyper_2_86_chunk.value), PARTIAL max(_hyper_2_86_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_86_chunk Output: _hyper_2_86_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_87_chunk.value), PARTIAL avg(_hyper_2_87_chunk.value), PARTIAL min(_hyper_2_87_chunk.value), PARTIAL max(_hyper_2_87_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_87_chunk Output: _hyper_2_87_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_88_chunk.value), PARTIAL avg(_hyper_2_88_chunk.value), PARTIAL min(_hyper_2_88_chunk.value), PARTIAL max(_hyper_2_88_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_88_chunk Output: _hyper_2_88_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_89_chunk.value), PARTIAL avg(_hyper_2_89_chunk.value), PARTIAL min(_hyper_2_89_chunk.value), PARTIAL max(_hyper_2_89_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_89_chunk Output: _hyper_2_89_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_90_chunk.value), PARTIAL avg(_hyper_2_90_chunk.value), PARTIAL min(_hyper_2_90_chunk.value), PARTIAL max(_hyper_2_90_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_90_chunk Output: _hyper_2_90_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_91_chunk.value), PARTIAL avg(_hyper_2_91_chunk.value), PARTIAL min(_hyper_2_91_chunk.value), PARTIAL max(_hyper_2_91_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_91_chunk Output: _hyper_2_91_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_92_chunk.value), PARTIAL avg(_hyper_2_92_chunk.value), PARTIAL min(_hyper_2_92_chunk.value), PARTIAL max(_hyper_2_92_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_92_chunk Output: _hyper_2_92_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_93_chunk.value), PARTIAL avg(_hyper_2_93_chunk.value), PARTIAL min(_hyper_2_93_chunk.value), PARTIAL max(_hyper_2_93_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_93_chunk Output: _hyper_2_93_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_94_chunk.value), PARTIAL avg(_hyper_2_94_chunk.value), PARTIAL min(_hyper_2_94_chunk.value), PARTIAL max(_hyper_2_94_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_94_chunk Output: _hyper_2_94_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_95_chunk.value), PARTIAL avg(_hyper_2_95_chunk.value), PARTIAL min(_hyper_2_95_chunk.value), PARTIAL max(_hyper_2_95_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_95_chunk Output: _hyper_2_95_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_96_chunk.value), PARTIAL avg(_hyper_2_96_chunk.value), PARTIAL min(_hyper_2_96_chunk.value), PARTIAL max(_hyper_2_96_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_96_chunk Output: _hyper_2_96_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_97_chunk.value), PARTIAL avg(_hyper_2_97_chunk.value), PARTIAL min(_hyper_2_97_chunk.value), PARTIAL max(_hyper_2_97_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_97_chunk Output: _hyper_2_97_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_98_chunk.value), PARTIAL avg(_hyper_2_98_chunk.value), PARTIAL min(_hyper_2_98_chunk.value), PARTIAL max(_hyper_2_98_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_98_chunk Output: _hyper_2_98_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_99_chunk.value), PARTIAL avg(_hyper_2_99_chunk.value), PARTIAL min(_hyper_2_99_chunk.value), PARTIAL max(_hyper_2_99_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_99_chunk Output: _hyper_2_99_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_100_chunk.value), PARTIAL avg(_hyper_2_100_chunk.value), PARTIAL min(_hyper_2_100_chunk.value), PARTIAL max(_hyper_2_100_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_100_chunk Output: _hyper_2_100_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_101_chunk.value), PARTIAL avg(_hyper_2_101_chunk.value), PARTIAL min(_hyper_2_101_chunk.value), PARTIAL max(_hyper_2_101_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_101_chunk Output: _hyper_2_101_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_102_chunk.value), PARTIAL avg(_hyper_2_102_chunk.value), PARTIAL min(_hyper_2_102_chunk.value), PARTIAL max(_hyper_2_102_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_102_chunk Output: _hyper_2_102_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_103_chunk.value), PARTIAL avg(_hyper_2_103_chunk.value), PARTIAL min(_hyper_2_103_chunk.value), PARTIAL max(_hyper_2_103_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_103_chunk Output: _hyper_2_103_chunk.value -> Partial Aggregate Output: PARTIAL sum(_hyper_2_104_chunk.value), PARTIAL avg(_hyper_2_104_chunk.value), PARTIAL min(_hyper_2_104_chunk.value), PARTIAL max(_hyper_2_104_chunk.value), PARTIAL count(*) -> Parallel Seq Scan on _timescaledb_internal._hyper_2_104_chunk Output: _hyper_2_104_chunk.value CREATE MATERIALIZED VIEW issue4922_partials_parallel AS SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; -- Materialize partials from execution of non-parallel query plan SET max_parallel_workers_per_gather = 0; EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF) SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; --- QUERY PLAN --- Partial Aggregate Output: _timescaledb_functions.partialize_agg(PARTIAL sum(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL avg(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL min(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL max(issue4922.value)), _timescaledb_functions.partialize_agg(PARTIAL count(*)) -> Append -> Seq Scan on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_6_chunk Output: _hyper_2_6_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk Output: _hyper_2_7_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk Output: _hyper_2_8_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk Output: _hyper_2_9_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_10_chunk Output: _hyper_2_10_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_11_chunk Output: _hyper_2_11_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk Output: _hyper_2_12_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_13_chunk Output: _hyper_2_13_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_14_chunk Output: _hyper_2_14_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_15_chunk Output: _hyper_2_15_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_16_chunk Output: _hyper_2_16_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_17_chunk Output: _hyper_2_17_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_18_chunk Output: _hyper_2_18_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_19_chunk Output: _hyper_2_19_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_20_chunk Output: _hyper_2_20_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_21_chunk Output: _hyper_2_21_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_22_chunk Output: _hyper_2_22_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_23_chunk Output: _hyper_2_23_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_24_chunk Output: _hyper_2_24_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_25_chunk Output: _hyper_2_25_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_26_chunk Output: _hyper_2_26_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_27_chunk Output: _hyper_2_27_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_28_chunk Output: _hyper_2_28_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_29_chunk Output: _hyper_2_29_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_30_chunk Output: _hyper_2_30_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_31_chunk Output: _hyper_2_31_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_32_chunk Output: _hyper_2_32_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_33_chunk Output: _hyper_2_33_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_34_chunk Output: _hyper_2_34_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_35_chunk Output: _hyper_2_35_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_36_chunk Output: _hyper_2_36_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_37_chunk Output: _hyper_2_37_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_38_chunk Output: _hyper_2_38_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_39_chunk Output: _hyper_2_39_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_40_chunk Output: _hyper_2_40_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_41_chunk Output: _hyper_2_41_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_42_chunk Output: _hyper_2_42_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_43_chunk Output: _hyper_2_43_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_44_chunk Output: _hyper_2_44_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_45_chunk Output: _hyper_2_45_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_46_chunk Output: _hyper_2_46_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_47_chunk Output: _hyper_2_47_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_48_chunk Output: _hyper_2_48_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_49_chunk Output: _hyper_2_49_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_50_chunk Output: _hyper_2_50_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_51_chunk Output: _hyper_2_51_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_52_chunk Output: _hyper_2_52_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_53_chunk Output: _hyper_2_53_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_54_chunk Output: _hyper_2_54_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_55_chunk Output: _hyper_2_55_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_56_chunk Output: _hyper_2_56_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_57_chunk Output: _hyper_2_57_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_58_chunk Output: _hyper_2_58_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_59_chunk Output: _hyper_2_59_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_60_chunk Output: _hyper_2_60_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_61_chunk Output: _hyper_2_61_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_62_chunk Output: _hyper_2_62_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_63_chunk Output: _hyper_2_63_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_64_chunk Output: _hyper_2_64_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_65_chunk Output: _hyper_2_65_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_66_chunk Output: _hyper_2_66_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_67_chunk Output: _hyper_2_67_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_68_chunk Output: _hyper_2_68_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_69_chunk Output: _hyper_2_69_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_70_chunk Output: _hyper_2_70_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_71_chunk Output: _hyper_2_71_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_72_chunk Output: _hyper_2_72_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_73_chunk Output: _hyper_2_73_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_74_chunk Output: _hyper_2_74_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_75_chunk Output: _hyper_2_75_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_76_chunk Output: _hyper_2_76_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_77_chunk Output: _hyper_2_77_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_78_chunk Output: _hyper_2_78_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_79_chunk Output: _hyper_2_79_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_80_chunk Output: _hyper_2_80_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_81_chunk Output: _hyper_2_81_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_82_chunk Output: _hyper_2_82_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_83_chunk Output: _hyper_2_83_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_84_chunk Output: _hyper_2_84_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_85_chunk Output: _hyper_2_85_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_86_chunk Output: _hyper_2_86_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_87_chunk Output: _hyper_2_87_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_88_chunk Output: _hyper_2_88_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_89_chunk Output: _hyper_2_89_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_90_chunk Output: _hyper_2_90_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_91_chunk Output: _hyper_2_91_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_92_chunk Output: _hyper_2_92_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_93_chunk Output: _hyper_2_93_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_94_chunk Output: _hyper_2_94_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_95_chunk Output: _hyper_2_95_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_96_chunk Output: _hyper_2_96_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_97_chunk Output: _hyper_2_97_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_98_chunk Output: _hyper_2_98_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_99_chunk Output: _hyper_2_99_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_100_chunk Output: _hyper_2_100_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_101_chunk Output: _hyper_2_101_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_102_chunk Output: _hyper_2_102_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_103_chunk Output: _hyper_2_103_chunk.value -> Seq Scan on _timescaledb_internal._hyper_2_104_chunk Output: _hyper_2_104_chunk.value CREATE MATERIALIZED VIEW issue4922_partials_non_parallel AS SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; RESET max_parallel_workers_per_gather; -- partials should be the same in both parallel and non-parallel execution SELECT * FROM issue4922_partials_parallel; partial_sum | partial_avg | partial_min | partial_max | partial_count --------------------+--------------------------------------------------------------------------------------------+-------------+-------------+-------------------- \x00000000004c4fa9 | \x00000001000000000000001400000002000000010000000800000000000186a00000000800000000004c4fa9 | \x00000000 | \x00000064 | \x00000000000186a0 SELECT * FROM issue4922_partials_non_parallel; partial_sum | partial_avg | partial_min | partial_max | partial_count --------------------+--------------------------------------------------------------------------------------------+-------------+-------------+-------------------- \x00000000004c4fa9 | \x00000001000000000000001400000002000000010000000800000000000186a00000000800000000004c4fa9 | \x00000000 | \x00000064 | \x00000000000186a0 -- Compare results from partial and non-partial query execution SELECT sum(value), avg(value), min(value), max(value), count(*) FROM issue4922; sum | avg | min | max | count ---------+---------------------+-----+-----+-------- 5001129 | 50.0112900000000000 | 0 | 100 | 100000 -- The results should be the EQUAL TO the previous query SELECT _timescaledb_functions.finalize_agg('pg_catalog.sum(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_sum, NULL::bigint) AS sum, _timescaledb_functions.finalize_agg('pg_catalog.avg(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_avg, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.min(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_min, NULL::integer) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_max, NULL::integer) AS max, _timescaledb_functions.finalize_agg('pg_catalog.count()'::text, NULL::name, NULL::name, '{}'::name[], partial_count, NULL::bigint) AS count FROM issue4922_partials_parallel; sum | avg | min | max | count ---------+---------------------+-----+-----+-------- 5001129 | 50.0112900000000000 | 0 | 100 | 100000 -- Test that a "soft" error causes an attempt to repair the row -- We don't care about the result here (but it is the sum of the b -- column where a = 1 in table "foo" above), just that it should -- attempt a repair, do the repair, and then not fail. -- -- Do this by reading the partial numeric format and drop bytes from -- the end of it (16 bytes, meaning 32 characters). This is what we -- know how to repair. Next, attempt to decode the partial and check -- that it attempt a repair and actually does the repair (zero-filling -- the end). SET client_min_messages TO debug2; \set VERBOSITY default WITH sample AS (SELECT encode(partialb, 'hex') part FROM saved_partials WHERE a = 1), broken AS (SELECT decode(left(part, -32), 'hex') partialb FROM sample) SELECT _timescaledb_functions.finalize_agg('sum(numeric)', null, null, null, broken.partialb, null::numeric) sumb FROM broken; LOG: statement: WITH sample AS (SELECT encode(partialb, 'hex') part FROM saved_partials WHERE a = 1), broken AS (SELECT decode(left(part, -32), 'hex') partialb FROM sample) SELECT _timescaledb_functions.finalize_agg('sum(numeric)', null, null, null, broken.partialb, null::numeric) sumb FROM broken; DEBUG: inner_agg_deserialize - deserializing partial DETAIL: mcxt: ExprContext DEBUG: inner_agg_deserialize - attempting repair of serialized partial DETAIL: mcxt: ExprContext DEBUG: sanitize_serialized_partial - zero-filling serialized numeric type DEBUG: inner_agg_deserialize - deserializing partial DETAIL: mcxt: ExprContext DEBUG: inner_agg_deserialize - attempting repair of serialized partial DETAIL: mcxt: ExprContext DEBUG: sanitize_serialized_partial - zero-filling serialized numeric type DEBUG: inner_agg_deserialize - deserializing partial DETAIL: mcxt: ExprContext DEBUG: inner_agg_deserialize - attempting repair of serialized partial DETAIL: mcxt: ExprContext DEBUG: sanitize_serialized_partial - zero-filling serialized numeric type DEBUG: inner_agg_deserialize - deserializing partial DETAIL: mcxt: ExprContext DEBUG: inner_agg_deserialize - attempting repair of serialized partial DETAIL: mcxt: ExprContext DEBUG: sanitize_serialized_partial - zero-filling serialized numeric type DEBUG: inner_agg_deserialize - deserializing partial DETAIL: mcxt: ExprContext DEBUG: inner_agg_deserialize - attempting repair of serialized partial DETAIL: mcxt: ExprContext DEBUG: sanitize_serialized_partial - zero-filling serialized numeric type sumb ------ 150 RESET client_min_messages; LOG: statement: RESET client_min_messages; \set VERBOSITY terse DROP TABLE saved_partials; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan-15.out������������������������������������������0000664�0000000�0000000�00002101055�15100345067�0023401�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: dev_name -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 10022 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 10011 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 10021 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 20 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on skip_scan_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 100 RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val, 'q1_9'::text -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10021.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10021.00 loops=1) Group Key: dev, "time", 'q1_10'::text -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=102.00 loops=1) Group Key: time_bucket(10, "time"), 'q1_12'::text -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=4.00 loops=1) Group Key: length(dev_name), 'q1_13'::text -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1002.00 loops=1) Group Key: (3 * "time"), 'q1_14'::text -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=12.00 loops=1) Group Key: ('Device '::text || dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, "time" Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10022.00 loops=1) Group Key: skip_scan.* -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1001.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=0.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 12 -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=7.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 3022 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) -> Unique (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan.dev, (max(skip_scan.val) OVER (?)) Sort Method: quicksort -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: (false AND false) -> Seq Scan on skip_scan (never executed) -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=19.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=19.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=19.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=833.00 loops=12) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: (dev = skip_scan.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Sort (actual rows=20002.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" Sort Method: quicksort -> Append (actual rows=20002.00 loops=1) -> Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 -> Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan skip_scan_1 (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_2 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_2 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_dname on skip_scan (actual rows=20.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=20.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 10002 DROP INDEX skip_scan_idx_time_dev_dname; \set TABLE skip_scan_ht \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: skip_scan_ht.dev_name -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (skip_scan_ht.dev % 3) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 2494 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 2504 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 101 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val, 'q1_9'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", 'q1_10'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=100.00 loops=1) Group Key: time_bucket(10, skip_scan_ht."time"), 'q1_12'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=3.00 loops=1) Group Key: length(skip_scan_ht.dev_name), 'q1_13'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1000.00 loops=1) Group Key: (3 * skip_scan_ht."time"), 'q1_14'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_ht.*)::skip_scan_ht) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=10020.00 loops=1) Order: skip_scan_ht."time" -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Result (actual rows=1000.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev, max(skip_scan_ht.val) OVER (?) -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=20.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=20.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=909.00 loops=11) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Sort (actual rows=20000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" Sort Method: quicksort -> Append (actual rows=20000.00 loops=1) -> Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht_1.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_2."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_dname on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_time_dev_dname on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_time_dev_dname on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_time_dev_dname on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 DROP INDEX skip_scan_idx_time_dev_dname; \ir include/skip_scan_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- SkipScan with ordered append :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE ORDER BY time; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- compression doesnt prevent skipscan SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT 1 FROM pg_rewrite; --- QUERY PLAN --- Unique -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_htc (actual rows=1000.00 loops=1) Order: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 1492 -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc.dev_name DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_22_chunk.dev, compress_hyper_4_22_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_23_chunk.dev, compress_hyper_4_23_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_24_chunk.dev, compress_hyper_4_24_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_25_chunk.dev, compress_hyper_4_25_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val, 'q1_9'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", 'q1_10'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: (skip_scan_htc.dev + 1), 'q1_13'::text -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_htc.*)::skip_scan_htc) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_htc.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) Rows Removed by Filter: 61 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1106 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2.00 loops=11) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Sort (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val Sort Method: quicksort -> Append (actual rows=40.00 loops=1) -> Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc_1.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_2.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) Filter: (a."time" > 5) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; -- try one query with EXPLAIN only for coverage EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan; --- QUERY PLAN --- Unique -> Custom Scan (SkipScan) on skip_scan -> Index Only Scan using skip_scan_dev_name_idx on skip_scan Index Cond: (dev_name > NULL::text) EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan_ht; --- QUERY PLAN --- Unique -> Merge Append Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk Index Cond: (dev_name > NULL::text) -- #3629 skipscan with constant skipscan column in where clause CREATE TABLE i3629(a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('i3629', 'time'); table_name ------------ i3629 INSERT INTO i3629 SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; EXPLAIN (SUMMARY OFF, BUFFERS OFF, COSTS OFF) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; --- QUERY PLAN --- Unique -> Sort Sort Key: i3629."time" DESC -> Append -> Seq Scan on _hyper_7_42_chunk Filter: (a = 2) -> Seq Scan on _hyper_7_43_chunk Filter: (a = 2) -> Seq Scan on _hyper_7_44_chunk Filter: (a = 2) -> Seq Scan on _hyper_7_45_chunk Filter: (a = 2) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; a | time ---+------------------------------ 2 | Fri Mar 20 00:00:00 2020 PDT -- #3720 skipscan not being used on varchar column CREATE TABLE i3720(time timestamptz not null,data varchar); SELECT table_name FROM create_hypertable('i3720','time'); WARNING: column type "character varying" used for "data" does not follow best practices table_name ------------ i3720 INSERT INTO i3720 SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); CREATE INDEX ON i3720(data, time); ANALYZE i3720; :PREFIX SELECT DISTINCT ON(data) * FROM i3720; --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_8_46_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_8_46_chunk_i3720_data_time_idx on _hyper_8_46_chunk (actual rows=3.00 loops=1) Index Cond: (data > NULL::text) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan-16.out������������������������������������������0000664�0000000�0000000�00002076352�15100345067�0023415�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: dev_name -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 10022 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 10011 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 10021 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 20 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on skip_scan_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 100 RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10021.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10021.00 loops=1) Group Key: dev, "time" -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=102.00 loops=1) Group Key: time_bucket(10, "time") -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=4.00 loops=1) Group Key: length(dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1002.00 loops=1) Group Key: (3 * "time") -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=12.00 loops=1) Group Key: ('Device '::text || dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, "time" Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10022.00 loops=1) Group Key: skip_scan.* -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1001.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=0.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 12 -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=7.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 3022 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) -> Limit (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Incremental Sort (actual rows=0.00 loops=1) Sort Key: skip_scan.dev, (max(skip_scan.val) OVER (?)) Presorted Key: skip_scan.dev Full-sort Groups: 1 Sort Method: quicksort -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: (false AND false) -> Seq Scan on skip_scan (never executed) -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=19.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=19.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=19.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=833.00 loops=12) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: (dev = skip_scan.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Sort (actual rows=20002.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" Sort Method: quicksort -> Append (actual rows=20002.00 loops=1) -> Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 -> Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan skip_scan_1 (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_2 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_2 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_dname on skip_scan (actual rows=20.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=20.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 10002 DROP INDEX skip_scan_idx_time_dev_dname; \set TABLE skip_scan_ht \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: skip_scan_ht.dev_name -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (skip_scan_ht.dev % 3) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 2494 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 2504 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 101 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time" -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=100.00 loops=1) Group Key: time_bucket(10, skip_scan_ht."time") -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=3.00 loops=1) Group Key: length(skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1000.00 loops=1) Group Key: (3 * skip_scan_ht."time") -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_ht.*)::skip_scan_ht) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=10020.00 loops=1) Order: skip_scan_ht."time" -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_ht."time" DESC -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev, max(skip_scan_ht.val) OVER (?) -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=20.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=20.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=909.00 loops=11) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Sort (actual rows=20000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" Sort Method: quicksort -> Append (actual rows=20000.00 loops=1) -> Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht_1.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_2."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_dname on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_time_dev_dname on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_time_dev_dname on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_time_dev_dname on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 DROP INDEX skip_scan_idx_time_dev_dname; \ir include/skip_scan_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- SkipScan with ordered append :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE ORDER BY time; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- compression doesnt prevent skipscan SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT 1 FROM pg_rewrite; --- QUERY PLAN --- Limit -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_htc (actual rows=1000.00 loops=1) Order: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 1492 -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc.dev_name DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_22_chunk.dev, compress_hyper_4_22_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_23_chunk.dev, compress_hyper_4_23_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_24_chunk.dev, compress_hyper_4_24_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_25_chunk.dev, compress_hyper_4_25_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time" -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: (skip_scan_htc.dev + 1) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_htc.*)::skip_scan_htc) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_htc.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) Rows Removed by Filter: 61 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1106 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2.00 loops=11) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Sort (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val Sort Method: quicksort -> Append (actual rows=40.00 loops=1) -> Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc_1.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_2.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) Filter: (a."time" > 5) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_htcl."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; -- try one query with EXPLAIN only for coverage EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan; --- QUERY PLAN --- Unique -> Custom Scan (SkipScan) on skip_scan -> Index Only Scan using skip_scan_dev_name_idx on skip_scan Index Cond: (dev_name > NULL::text) EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan_ht; --- QUERY PLAN --- Unique -> Merge Append Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk Index Cond: (dev_name > NULL::text) -- #3629 skipscan with constant skipscan column in where clause CREATE TABLE i3629(a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('i3629', 'time'); table_name ------------ i3629 INSERT INTO i3629 SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; EXPLAIN (SUMMARY OFF, BUFFERS OFF, COSTS OFF) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; --- QUERY PLAN --- Limit -> Merge Append Sort Key: i3629."time" DESC -> Index Scan using _hyper_7_42_chunk_i3629_time_idx on _hyper_7_42_chunk Filter: (a = 2) -> Index Scan using _hyper_7_43_chunk_i3629_time_idx on _hyper_7_43_chunk Filter: (a = 2) -> Index Scan using _hyper_7_44_chunk_i3629_time_idx on _hyper_7_44_chunk Filter: (a = 2) -> Index Scan using _hyper_7_45_chunk_i3629_time_idx on _hyper_7_45_chunk Filter: (a = 2) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; a | time ---+------------------------------ 2 | Fri Mar 20 00:00:00 2020 PDT -- #3720 skipscan not being used on varchar column CREATE TABLE i3720(time timestamptz not null,data varchar); SELECT table_name FROM create_hypertable('i3720','time'); WARNING: column type "character varying" used for "data" does not follow best practices table_name ------------ i3720 INSERT INTO i3720 SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); CREATE INDEX ON i3720(data, time); ANALYZE i3720; :PREFIX SELECT DISTINCT ON(data) * FROM i3720; --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_8_46_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_8_46_chunk_i3720_data_time_idx on _hyper_8_46_chunk (actual rows=3.00 loops=1) Index Cond: (data > NULL::text) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan-17.out������������������������������������������0000664�0000000�0000000�00002075777�15100345067�0023430�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: dev_name -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 10022 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 10011 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 10021 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 20 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on skip_scan_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 100 RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10021.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10021.00 loops=1) Group Key: dev, "time" -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=102.00 loops=1) Group Key: time_bucket(10, "time") -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=4.00 loops=1) Group Key: length(dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1002.00 loops=1) Group Key: (3 * "time") -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=12.00 loops=1) Group Key: ('Device '::text || dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, "time" Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10022.00 loops=1) Group Key: skip_scan.* -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1001.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=0.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 12 -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=7.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 3022 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Result (actual rows=1.00 loops=1) -> Limit (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan.dev, max(skip_scan.val) OVER (?) -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=19.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=19.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=19.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=833.00 loops=12) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: (dev = skip_scan.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Merge Append (actual rows=20002.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" -> Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 -> Sort (actual rows=10001.00 loops=1) Sort Key: skip_scan_2.dev, skip_scan_2."time" Sort Method: quicksort -> Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan skip_scan_1 (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_2 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_2 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_dname on skip_scan (actual rows=20.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=20.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 10002 DROP INDEX skip_scan_idx_time_dev_dname; \set TABLE skip_scan_ht \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: skip_scan_ht.dev_name -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (skip_scan_ht.dev % 3) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 2494 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 2504 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 101 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time" -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=100.00 loops=1) Group Key: time_bucket(10, skip_scan_ht."time") -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=3.00 loops=1) Group Key: length(skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1000.00 loops=1) Group Key: (3 * skip_scan_ht."time") -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_ht.*)::skip_scan_ht) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=10020.00 loops=1) Order: skip_scan_ht."time" -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_ht."time" DESC -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev, max(skip_scan_ht.val) OVER (?) -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=20.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=20.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=909.00 loops=11) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: (dev = skip_scan_ht.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=20000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Sort (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht_2.dev, skip_scan_ht_2."time" Sort Method: quicksort -> Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht_1.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_2."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_dname on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_time_dev_dname on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_time_dev_dname on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_time_dev_dname on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 DROP INDEX skip_scan_idx_time_dev_dname; \ir include/skip_scan_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- SkipScan with ordered append :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE ORDER BY time; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- compression doesnt prevent skipscan SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT 1 FROM pg_rewrite; --- QUERY PLAN --- Limit -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_htc (actual rows=1000.00 loops=1) Order: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 1492 -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc.dev_name DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_22_chunk.dev, compress_hyper_4_22_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_23_chunk.dev, compress_hyper_4_23_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_24_chunk.dev, compress_hyper_4_24_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_25_chunk.dev, compress_hyper_4_25_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time" -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: (skip_scan_htc.dev + 1) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_htc.*)::skip_scan_htc) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_htc.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) Rows Removed by Filter: 61 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1106 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2.00 loops=11) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Sort (actual rows=20.00 loops=1) Sort Key: skip_scan_htc_2.dev, skip_scan_htc_2.val Sort Method: quicksort -> Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc_1.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=11.00 loops=1) -> Unique (actual rows=2.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_2.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_2 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) Filter: (a."time" > 5) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_htcl."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; -- try one query with EXPLAIN only for coverage EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan; --- QUERY PLAN --- Unique -> Custom Scan (SkipScan) on skip_scan -> Index Only Scan using skip_scan_dev_name_idx on skip_scan Index Cond: (dev_name > NULL::text) EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan_ht; --- QUERY PLAN --- Unique -> Merge Append Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk Index Cond: (dev_name > NULL::text) -- #3629 skipscan with constant skipscan column in where clause CREATE TABLE i3629(a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('i3629', 'time'); table_name ------------ i3629 INSERT INTO i3629 SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; EXPLAIN (SUMMARY OFF, BUFFERS OFF, COSTS OFF) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; --- QUERY PLAN --- Limit -> Merge Append Sort Key: i3629."time" DESC -> Index Scan using _hyper_7_42_chunk_i3629_time_idx on _hyper_7_42_chunk Filter: (a = 2) -> Index Scan using _hyper_7_43_chunk_i3629_time_idx on _hyper_7_43_chunk Filter: (a = 2) -> Index Scan using _hyper_7_44_chunk_i3629_time_idx on _hyper_7_44_chunk Filter: (a = 2) -> Index Scan using _hyper_7_45_chunk_i3629_time_idx on _hyper_7_45_chunk Filter: (a = 2) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; a | time ---+------------------------------ 2 | Fri Mar 20 00:00:00 2020 PDT -- #3720 skipscan not being used on varchar column CREATE TABLE i3720(time timestamptz not null,data varchar); SELECT table_name FROM create_hypertable('i3720','time'); WARNING: column type "character varying" used for "data" does not follow best practices table_name ------------ i3720 INSERT INTO i3720 SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); CREATE INDEX ON i3720(data, time); ANALYZE i3720; :PREFIX SELECT DISTINCT ON(data) * FROM i3720; --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_8_46_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_8_46_chunk_i3720_data_time_idx on _hyper_8_46_chunk (actual rows=3.00 loops=1) Index Cond: (data > NULL::text) �timescaledb-2.23.0/tsl/test/expected/plan_skip_scan-18.out������������������������������������������0000664�0000000�0000000�00002075624�15100345067�0023420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: dev_name -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 10022 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 10011 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 10021 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 20 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on skip_scan_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 100 RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10022.00 loops=1) Group Key: dev, "time", dev_name, val -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10021.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=10021.00 loops=1) Group Key: dev, "time" -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=102.00 loops=1) Group Key: time_bucket(10, "time") -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=4.00 loops=1) Group Key: length(dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1002.00 loops=1) Group Key: (3 * "time") -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=12.00 loops=1) Group Key: ('Device '::text || dev_name) -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, "time" Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10022.00 loops=1) Group Key: skip_scan.* -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1001.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=12.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=0.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 12 -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=7.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 3022 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=6.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" = 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Scan Backward using skip_scan_dev_time_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan.dev, max(skip_scan.val) OVER w1 -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" = 100)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=19.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=19.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=19.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=10.00 loops=2) -> Unique (actual rows=10.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.50 loops=2) -> Unique (actual rows=9.50 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.50 loops=2) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=833.42 loops=12) -> Unique (actual rows=833.42 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.42 loops=12) -> Index Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.42 loops=12) Index Cond: (dev = skip_scan.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.42 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.42 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.42 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.42 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.42 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.42 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10001.00 loops=1) -> Merge Append (actual rows=20002.00 loops=1) Sort Key: skip_scan.dev, skip_scan."time" -> Unique (actual rows=10001.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=10001.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 21 -> Sort (actual rows=10001.00 loops=1) Sort Key: skip_scan_2.dev, skip_scan_2."time" Sort Method: quicksort -> Nested Loop (actual rows=10001.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan skip_scan_1 (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=833.42 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_2 (actual rows=833.42 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_2 (actual rows=833.42 loops=12) Index Cond: ((dev = skip_scan_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> Result (actual rows=12.00 loops=1) -> Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_dname on skip_scan (actual rows=20.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=20.00 loops=1) -> Index Scan using skip_scan_time_dev_idx on skip_scan (actual rows=20.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 10002 DROP INDEX skip_scan_idx_time_dev_dname; \set TABLE skip_scan_ht \ir include/skip_scan_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; enable_skipscan ----------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> HashAggregate (actual rows=2.00 loops=1) Group Key: skip_scan_ht.dev_name -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Sort (actual rows=4.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) Sort Method: quicksort -> HashAggregate (actual rows=4.00 loops=1) Group Key: (skip_scan_ht.dev % 3) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -> Seq Scan on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: (val < 0) Rows Removed by Filter: 2505 -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=11.00 loops=1) Filter: ("time" = 100) Rows Removed by Filter: 2494 -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.dev_name Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (("time" = 100) AND (dev = 1)) Rows Removed by Filter: 2504 -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev_name IS NULL) Filter: (dev = 1) Rows Removed by Filter: 5 CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 101 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (dev >= 5) Filter: (ROW(dev, "time") > ROW(5, 100)) RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time", skip_scan_ht.dev_name, skip_scan_ht.val -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht."time" -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=100.00 loops=1) Group Key: time_bucket(10, skip_scan_ht."time") -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=3.00 loops=1) Group Key: length(skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=1000.00 loops=1) Group Key: (3 * skip_scan_ht."time") -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_ht.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_ht.*)::skip_scan_ht) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev < NULL::integer) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT * FROM :TABLE ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=10020.00 loops=1) Order: skip_scan_ht."time" -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC, skip_scan_ht."time" DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ("time" > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=7.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=6.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=6.00 loops=1) Index Cond: (ROW(dev, "time") > ROW(5, 100)) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" = 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_ht."time" DESC -> Index Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Index Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (("time" = 100) AND (dev = 1)) :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Append (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (never executed) Index Cond: (dev_name = 'device_1'::text) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; --- QUERY PLAN --- HashAggregate (actual rows=0.00 loops=1) Group Key: skip_scan_ht.dev, max(skip_scan_ht.val) OVER w1 -> WindowAgg (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" = 100)) :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (val = 100)) :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ("time" = 100) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=20.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=20.00 loops=1) Index Cond: ((dev = 1) AND ("time" > NULL::integer) AND ("time" < 20)) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.50 loops=2) -> Unique (actual rows=9.50 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.50 loops=2) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.50 loops=2) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.50 loops=2) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.50 loops=2) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Result (actual rows=909.09 loops=11) -> Unique (actual rows=909.09 loops=11) -> Merge Append (actual rows=909.09 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) Index Cond: (dev = skip_scan_ht.dev) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) Index Cond: (dev = skip_scan_ht.dev) :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.09 loops=11) -> Merge Append (actual rows=909.09 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.09 loops=11) -> Merge Append (actual rows=909.09 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht."time", skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=20000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Unique (actual rows=10000.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht."time" -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=2500.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) >= 0) Rows Removed by Filter: 5 -> Sort (actual rows=10000.00 loops=1) Sort Key: skip_scan_ht_2.dev, skip_scan_ht_2."time" Sort Method: quicksort -> Nested Loop (actual rows=10000.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht_1.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Unique (actual rows=909.09 loops=11) -> Merge Append (actual rows=909.09 loops=11) Sort Key: skip_scan_ht_2."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_2 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_2 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_2 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_2 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht_1.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_dname on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_time_dev_dname on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_time_dev_dname on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_time_dev_dname on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (("time" > NULL::integer) AND (dev_name IS NULL)) DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=20.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (dev_name IS NULL) Rows Removed by Filter: 2500 DROP INDEX skip_scan_idx_time_dev_dname; \ir include/skip_scan_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- SkipScan with ordered append :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE ORDER BY time; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- compression doesnt prevent skipscan SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT 1 FROM pg_rewrite; --- QUERY PLAN --- Limit -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev DESC, compress_hyper_4_18_chunk._ts_meta_min_1 DESC, compress_hyper_4_18_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev DESC, compress_hyper_4_19_chunk._ts_meta_min_1 DESC, compress_hyper_4_19_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev DESC, compress_hyper_4_20_chunk._ts_meta_min_1 DESC, compress_hyper_4_20_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev DESC, compress_hyper_4_21_chunk._ts_meta_min_1 DESC, compress_hyper_4_21_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; --- QUERY PLAN --- Unique (actual rows=1000.00 loops=1) -> Custom Scan (ChunkAppend) on skip_scan_htc (actual rows=1000.00 loops=1) Order: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 1492 -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc.dev_name DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.dev_name DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_22_chunk.dev, compress_hyper_4_22_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_23_chunk.dev, compress_hyper_4_23_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_24_chunk.dev, compress_hyper_4_24_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_25_chunk.dev, compress_hyper_4_25_chunk.dev_name DESC Sort Method: quicksort -> Seq Scan on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time", skip_scan_htc.dev_name, skip_scan_htc.val -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=10020.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc."time" -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: (skip_scan_htc.dev + 1) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) Vectorized Filter: (dev_name IS NOT NULL) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=10020.00 loops=1) Group Key: ((skip_scan_htc.*)::skip_scan_htc) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, (length(md5((random())::text))) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; --- QUERY PLAN --- HashAggregate (actual rows=11.00 loops=1) Group Key: ('Device '::text || skip_scan_htc.dev_name) -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc."time" -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC, skip_scan_htc."time" DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) Rows Removed by Filter: 61 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=7.00 loops=1) Filter: (a."time" > 5) Rows Removed by Filter: 4 -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1106 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_htc."time" DESC -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.50 loops=2) -> Unique (actual rows=9.50 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Result (actual rows=1.82 loops=11) -> Unique (actual rows=1.82 loops=11) -> Merge Append (actual rows=7.27 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=1.82 loops=11) -> Merge Append (actual rows=7.27 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Unique (actual rows=1.82 loops=11) -> Merge Append (actual rows=7.27 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Unique (actual rows=20.00 loops=1) -> Merge Append (actual rows=10000.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.val -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2500.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=20.00 loops=1) Index Cond: (dev IS NOT NULL) -> Sort (actual rows=20.00 loops=1) Sort Key: skip_scan_htc_2.dev, skip_scan_htc_2.val Sort Method: quicksort -> Nested Loop (actual rows=20.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc_1.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=11.00 loops=1) -> Unique (actual rows=1.82 loops=11) -> Merge Append (actual rows=7.27 loops=11) Sort Key: skip_scan_htc_2.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_2 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_2 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_2 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_2 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_2 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_2 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_2 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_2 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc_1.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; --- QUERY PLAN --- Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho DISTINCT with wholerow var DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=9.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev, skip_scan_htcl."time" DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC, skip_scan_htcl."time" -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 5) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 5) :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) Filter: (a."time" > 5) -> Result (actual rows=11.00 loops=1) -> Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> Result (actual rows=5.00 loops=1) -> Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Result (actual rows=9.00 loops=1) -> Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Result (actual rows=8.00 loops=1) -> Unique (actual rows=8.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Unique (actual rows=7.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); --- QUERY PLAN --- Unique (actual rows=6.00 loops=1) -> Merge Append (actual rows=24.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=6.00 loops=1) Filter: (ROW(dev, "time") > ROW(5, 100)) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Merge Append (actual rows=1.00 loops=1) Sort Key: skip_scan_htcl."time" DESC -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=18.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.00 loops=2) -> Unique (actual rows=9.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Result (actual rows=9.50 loops=2) -> Unique (actual rows=9.50 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; -- try one query with EXPLAIN only for coverage EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan; --- QUERY PLAN --- Unique -> Custom Scan (SkipScan) on skip_scan -> Index Only Scan using skip_scan_dev_name_idx on skip_scan Index Cond: (dev_name > NULL::text) EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan_ht; --- QUERY PLAN --- Unique -> Merge Append Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk Index Cond: (dev_name > NULL::text) -- #3629 skipscan with constant skipscan column in where clause CREATE TABLE i3629(a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('i3629', 'time'); table_name ------------ i3629 INSERT INTO i3629 SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; EXPLAIN (SUMMARY OFF, BUFFERS OFF, COSTS OFF) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; --- QUERY PLAN --- Limit -> Merge Append Sort Key: i3629."time" DESC -> Index Scan using _hyper_7_42_chunk_i3629_time_idx on _hyper_7_42_chunk Filter: (a = 2) -> Index Scan using _hyper_7_43_chunk_i3629_time_idx on _hyper_7_43_chunk Filter: (a = 2) -> Index Scan using _hyper_7_44_chunk_i3629_time_idx on _hyper_7_44_chunk Filter: (a = 2) -> Index Scan using _hyper_7_45_chunk_i3629_time_idx on _hyper_7_45_chunk Filter: (a = 2) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; a | time ---+------------------------------ 2 | Fri Mar 20 00:00:00 2020 PDT -- #3720 skipscan not being used on varchar column CREATE TABLE i3720(time timestamptz not null,data varchar); SELECT table_name FROM create_hypertable('i3720','time'); WARNING: column type "character varying" used for "data" does not follow best practices table_name ------------ i3720 INSERT INTO i3720 SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); CREATE INDEX ON i3720(data, time); ANALYZE i3720; :PREFIX SELECT DISTINCT ON(data) * FROM i3720; --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on _hyper_8_46_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_8_46_chunk_i3720_data_time_idx on _hyper_8_46_chunk (actual rows=3.00 loops=1) Index Cond: (data > NULL::text) ������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan_dagg-15.out�������������������������������������0000664�0000000�0000000�00001551335�15100345067�0024374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev, count(DISTINCT dev) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (time_bucket(10, "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (length(dev_name)) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: ((3 * "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: ((dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1002.00 loops=1) Group Key: "time" -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 9022 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1001.00 loops=1) Group Key: "time" -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \set TABLE skip_scan_ht \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: ((skip_scan_ht.dev % 3)) -> Result (actual rows=10020.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev, count(DISTINCT skip_scan_ht.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.dev Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (time_bucket(10, skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_ht.dev_name)) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((3 * skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_ht.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht."time", skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_4_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \ir include/skip_scan_dagg_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT count(DISTINCT 1) FROM pg_rewrite; --- QUERY PLAN --- Aggregate -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where dev=1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- SkipScan with ordered append :PREFIX SELECT count(DISTINCT time), time FROM :TABLE GROUP BY time ORDER BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk doesnt prevent skipscan on other chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk will prevent skipscan if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 2494 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_2_17_chunk.dev Sort Method: quicksort -> Seq Scan on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) Filter: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- skipscan will be applied on decompressed chunk if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx1; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_time_idx; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_1_1_chunk.dev Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_dagg_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev, count(DISTINCT skip_scan_htc.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_htc."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc."time", skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk."time", _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk."time", _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk."time", _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_8_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_htc.dev_name)) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_5_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_6_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_7_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_8_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_dagg_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htcl -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Incremental Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htcl.dev, (count(DISTINCT skip_scan_htcl.dev)) Presorted Key: skip_scan_htcl.dev Full-sort Groups: 1 Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htcl.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_13_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htcl."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan_dagg-16.out�������������������������������������0000664�0000000�0000000�00001551335�15100345067�0024375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev, count(DISTINCT dev) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (time_bucket(10, "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (length(dev_name)) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: ((3 * "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: ((dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1002.00 loops=1) Group Key: "time" -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 9022 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1001.00 loops=1) Group Key: "time" -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \set TABLE skip_scan_ht \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: ((skip_scan_ht.dev % 3)) -> Result (actual rows=10020.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev, count(DISTINCT skip_scan_ht.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.dev Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (time_bucket(10, skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_ht.dev_name)) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((3 * skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_ht.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht."time", skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_4_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \ir include/skip_scan_dagg_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT count(DISTINCT 1) FROM pg_rewrite; --- QUERY PLAN --- Aggregate -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where dev=1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- SkipScan with ordered append :PREFIX SELECT count(DISTINCT time), time FROM :TABLE GROUP BY time ORDER BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk doesnt prevent skipscan on other chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk will prevent skipscan if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 2494 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_2_17_chunk.dev Sort Method: quicksort -> Seq Scan on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) Filter: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- skipscan will be applied on decompressed chunk if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx1; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_time_idx; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_1_1_chunk.dev Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_dagg_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev, count(DISTINCT skip_scan_htc.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_htc."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc."time", skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk."time", _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk."time", _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk."time", _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_8_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_htc.dev_name)) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_5_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_6_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_7_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_8_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_dagg_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htcl -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Incremental Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htcl.dev, (count(DISTINCT skip_scan_htcl.dev)) Presorted Key: skip_scan_htcl.dev Full-sort Groups: 1 Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htcl.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_13_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htcl."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan_dagg-17.out�������������������������������������0000664�0000000�0000000�00001551335�15100345067�0024376�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev, count(DISTINCT dev) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (time_bucket(10, "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (length(dev_name)) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: ((3 * "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: ((dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1002.00 loops=1) Group Key: "time" -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 9022 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1001.00 loops=1) Group Key: "time" -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \set TABLE skip_scan_ht \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: ((skip_scan_ht.dev % 3)) -> Result (actual rows=10020.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev, count(DISTINCT skip_scan_ht.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.dev Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (time_bucket(10, skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_ht.dev_name)) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((3 * skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_ht.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht."time", skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_4_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \ir include/skip_scan_dagg_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT count(DISTINCT 1) FROM pg_rewrite; --- QUERY PLAN --- Aggregate -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where dev=1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- SkipScan with ordered append :PREFIX SELECT count(DISTINCT time), time FROM :TABLE GROUP BY time ORDER BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk doesnt prevent skipscan on other chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk will prevent skipscan if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 2494 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_2_17_chunk.dev Sort Method: quicksort -> Seq Scan on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) Filter: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- skipscan will be applied on decompressed chunk if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx1; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_time_idx; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_1_1_chunk.dev Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_dagg_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev, count(DISTINCT skip_scan_htc.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_htc."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc."time", skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk."time", _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk."time", _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk."time", _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_8_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_htc.dev_name)) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_5_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_6_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_7_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_8_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_dagg_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htcl -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Incremental Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htcl.dev, (count(DISTINCT skip_scan_htcl.dev)) Presorted Key: skip_scan_htcl.dev Full-sort Groups: 1 Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htcl.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_13_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htcl."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan_dagg-18.out�������������������������������������0000664�0000000�0000000�00001551275�15100345067�0024402�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev, count(DISTINCT dev) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (time_bucket(10, "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (length(dev_name)) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: ((3 * "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: ((dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1002.00 loops=1) Group Key: "time" -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 9022 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1001.00 loops=1) Group Key: "time" -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" = 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.50 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=9.50 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.42 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.42 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \set TABLE skip_scan_ht \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: ((skip_scan_ht.dev % 3)) -> Result (actual rows=10020.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev, count(DISTINCT skip_scan_ht.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.dev Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (time_bucket(10, skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_ht.dev_name)) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((3 * skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_ht.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht."time", skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_4_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" = 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.50 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.50 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.50 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.50 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.50 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.50 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.50 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.50 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=909.09 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.27 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \ir include/skip_scan_dagg_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT count(DISTINCT 1) FROM pg_rewrite; --- QUERY PLAN --- Aggregate -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where dev=1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- SkipScan with ordered append :PREFIX SELECT count(DISTINCT time), time FROM :TABLE GROUP BY time ORDER BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk doesnt prevent skipscan on other chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk will prevent skipscan if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 2494 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_2_17_chunk.dev Sort Method: quicksort -> Seq Scan on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) Filter: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- skipscan will be applied on decompressed chunk if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" = 100)) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx1; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_time_idx; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_1_1_chunk.dev Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_dagg_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev, count(DISTINCT skip_scan_htc.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_htc."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc."time", skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk."time", _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk."time", _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk."time", _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_8_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_htc.dev_name)) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_5_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_6_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_7_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_8_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=7.27 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=1.82 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=1.82 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_dagg_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htcl -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Incremental Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htcl.dev, (count(DISTINCT skip_scan_htcl.dev)) Presorted Key: skip_scan_htcl.dev Full-sort Groups: 1 Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htcl.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_13_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htcl."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.50 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.50 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.50 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan_dagg.out����������������������������������������0000664�0000000�0000000�00001551335�15100345067�0024151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_nulls_last on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_nulls_first on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan Backward using skip_scan_idx_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_idx_time_dev_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: dev_name Sort Method: quicksort -> Bitmap Heap Scan on skip_scan (actual rows=2000.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=13 -> Bitmap Index Scan on skip_scan_idx_hash (actual rows=2000.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: (dev % 3) -> Index Scan using skip_scan_expr_idx on skip_scan (actual rows=10022.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: dev Sort Method: quicksort -> HashAggregate (actual rows=12.00 loops=1) Group Key: dev, count(DISTINCT dev) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, dev Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (time_bucket(10, "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: (length(dev_name)) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10022.00 loops=1) Sort Key: ((3 * "time")) Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=12.00 loops=1) Sort Key: ((dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1002.00 loops=1) Group Key: "time" -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=10022.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: dev_name, tableoid -> Sort (actual rows=10022.00 loops=1) Sort Key: dev_name, tableoid Sort Method: quicksort -> Seq Scan on skip_scan (actual rows=10022.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: dev_name -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 9022 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1001.00 loops=1) Group Key: "time" -> Custom Scan (SkipScan) on skip_scan (actual rows=1001.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan (actual rows=1001.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan.dev Filter: (sum(DISTINCT skip_scan.dev) > 2) Rows Removed by Filter: 4 -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 7022 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_time_dev_val_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) Rows Removed by Filter: 1000 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: dev -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Scan using skip_scan_dev_time_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=1000.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_name_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20022.00 loops=1) Join Filter: (skip_scan."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 22 -> Index Scan using skip_scan_dev_idx on skip_scan (actual rows=10022.00 loops=1) -> Materialize (actual rows=2.00 loops=10022) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1000 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=2) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) -> Index Only Scan using skip_scan_time_dev_idx on skip_scan skip_scan_1 (actual rows=1002.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=12) -> Custom Scan (SkipScan) on skip_scan skip_scan_1 (actual rows=833.00 loops=12) -> Index Only Scan using skip_scan_dev_time_idx on skip_scan skip_scan_1 (actual rows=833.00 loops=12) Index Cond: ((dev = skip_scan.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=12.00 loops=1) -> GroupAggregate (actual rows=12.00 loops=1) Group Key: skip_scan.dev -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \set TABLE skip_scan_ht \ir include/skip_scan_dagg_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; enable_dagg_skipscan ---------------------- on -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_last on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev NULLS FIRST -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_nulls_first on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_idx_dev_time_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_idx_dev_time_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_idx_dev_time_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_idx_dev_time_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev < NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_idx_time_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev IS NOT NULL)) DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=2000.00 loops=1) Sort Key: skip_scan_ht.dev_name Sort Method: quicksort -> Append (actual rows=2000.00 loops=1) -> Bitmap Heap Scan on _hyper_1_1_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_1_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_2_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_2_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_3_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_3_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) -> Bitmap Heap Scan on _hyper_1_4_chunk (actual rows=500.00 loops=1) Recheck Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) Heap Blocks: exact=4 -> Bitmap Index Scan on _hyper_1_4_chunk_skip_scan_idx_hash (actual rows=500.00 loops=1) Index Cond: (dev_name = ANY ('{device_1,device_2}'::text[])) DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; --- QUERY PLAN --- GroupAggregate (actual rows=4.00 loops=1) Group Key: ((skip_scan_ht.dev % 3)) -> Result (actual rows=10020.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_ht.dev % 3)) -> Index Scan using _hyper_1_1_chunk_skip_scan_expr_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_expr_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_expr_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_expr_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_ht -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev, count(DISTINCT skip_scan_ht.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.dev Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (time_bucket(10, skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_ht.dev_name)) Sort Method: quicksort -> Result (actual rows=10020.00 loops=1) -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((3 * skip_scan_ht."time")) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_ht.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht."time", skip_scan_ht.dev -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NOT NULL)) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid -> Sort (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev_name, skip_scan_ht.tableoid Sort Method: quicksort -> Append (actual rows=10020.00 loops=1) -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Seq Scan on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_ht.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Filter: (dev = 1) Rows Removed by Filter: 2255 \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=4.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=4.00 loops=1) Index Cond: (dev < NULL::integer) \qecho range queries on :TABLE range queries on skip_scan_ht :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" >= 100) AND ("time" <= 300)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" < 200)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_1_4_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND ("time" > 800)) \qecho ordered append on :TABLE ordered append on skip_scan_ht :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" >= 0) AND ("time" <= 5000)) \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_ht :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_ht.dev Filter: (sum(DISTINCT skip_scan_ht.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 1)) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > int_func_stable())) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY (inta_func_stable()))) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_ht Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 20)) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer) AND (dev > 5)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 5) AND ("time" > 200)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) Filter: ("time" > 200) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_1_1_chunk.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND ("time" > 100) AND ("time" < 200)) Filter: ((val > 10) AND (val < 10000)) Rows Removed by Filter: 396 :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev_name > NULL::text) AND (dev_name IS NULL)) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_name_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_name_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_name_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_name_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev_name > NULL::text) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_ht."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_ht.dev -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=2505.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=2505.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=9.00 loops=2) Index Cond: (dev > NULL::integer) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 250 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=2) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=10.00 loops=2) Index Cond: ((dev > NULL::integer) AND (dev >= "*VALUES*".column1)) -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_dev_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_dev_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_dev_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=909.00 loops=11) Sort Key: skip_scan_ht_1."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_time_idx on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_time_idx on _hyper_1_4_chunk _hyper_1_4_chunk_1 (actual rows=227.00 loops=11) Index Cond: ((dev = skip_scan_ht.dev) AND ("time" > NULL::integer)) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_ht.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=1.00 loops=1) Index Cond: ("time" > NULL::integer) -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nulls (actual rows=0.00 loops=1) -> Index Only Scan using skip_scan_nulls_time_idx on skip_scan_nulls (actual rows=0.00 loops=1) Index Cond: (("time" > NULL::integer) AND ("time" IS NOT NULL)) \ir include/skip_scan_dagg_query_ht.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT count(DISTINCT 1) FROM pg_rewrite; --- QUERY PLAN --- Aggregate -> Index Only Scan using pg_rewrite_rel_rulename_index on pg_rewrite :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where dev=1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: (dev = 1) -- SkipScan with ordered append :PREFIX SELECT count(DISTINCT time), time FROM :TABLE GROUP BY time ORDER BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_ht."time" -> Custom Scan (ChunkAppend) on skip_scan_ht (actual rows=1000.00 loops=1) Order: skip_scan_ht."time" -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_idx on _hyper_1_1_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_time_idx on _hyper_1_2_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_time_idx on _hyper_1_3_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=250.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_time_idx on _hyper_1_4_chunk (actual rows=250.00 loops=1) Index Cond: ("time" > NULL::integer) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk doesnt prevent skipscan on other chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_2_17_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- compression on one chunk will prevent skipscan if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 2494 -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_2_17_chunk.dev Sort Method: quicksort -> Seq Scan on compress_hyper_2_17_chunk (actual rows=11.00 loops=1) Filter: ((_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- skipscan will be applied on decompressed chunk if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_time_dev_val_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (("time" = 100) AND (dev > NULL::integer)) --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_idx1 on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx1; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_time_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_time_idx; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=2538.00 loops=1) Sort Key: skip_scan_ht.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_1_1_chunk.dev Sort Method: quicksort -> Seq Scan on _hyper_1_1_chunk (actual rows=2505.00 loops=1) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_idx1 on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_idx1 on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_idx1 on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) RESET timescaledb.enable_compressed_skipscan; -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_dagg_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_21_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_21_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev NULLS FIRST -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_18_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_19_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_20_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Sort (actual rows=11.00 loops=1) Sort Key: compress_hyper_4_21_chunk.dev NULLS FIRST Sort Method: quicksort -> Seq Scan on compress_hyper_4_21_chunk (actual rows=11.00 loops=1) -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan Backward using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name = 'device_1'::text) -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=1000.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_22_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_22_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_23_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_23_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_24_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_24_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_25_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_25_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htc -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev Sort Method: quicksort -> HashAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev, count(DISTINCT skip_scan_htc.dev) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htc.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; --- QUERY PLAN --- GroupAggregate (actual rows=1000.00 loops=1) Group Key: skip_scan_htc."time" -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc."time", skip_scan_htc.dev -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk."time", _hyper_3_5_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk."time", _hyper_3_6_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk."time", _hyper_3_7_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk."time", _hyper_3_8_chunk.dev Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_28_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_28_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htc :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_4_27_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_27_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_4_26_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_26_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_3_8_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_4_29_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_29_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htc :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=1.00 loops=1) Index Cond: (dev_name IS NULL) -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=10020.00 loops=1) Sort Key: (length(skip_scan_htc.dev_name)) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_5_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_6_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_7_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: (length(_hyper_3_8_chunk.dev_name)) Sort Method: quicksort -> Result (actual rows=2505.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=10.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=10.00 loops=1) Index Cond: (dev_name IS NOT NULL) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; --- QUERY PLAN --- GroupAggregate (actual rows=44.00 loops=1) Group Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev_name, skip_scan_htc.tableoid -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_5_chunk.dev_name, _hyper_3_5_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_6_chunk.dev_name, _hyper_3_6_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_7_chunk.dev_name, _hyper_3_7_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Sort (actual rows=2505.00 loops=1) Sort Key: _hyper_3_8_chunk.dev_name, _hyper_3_8_chunk.tableoid Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Seq Scan on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: skip_scan_htc.dev_name -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_30_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_31_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_32_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_32_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) Vectorized Filter: (dev = 1) Rows Removed by Filter: 2255 -> Index Scan using compress_hyper_4_33_chunk_dev_name__ts_meta_min_1__ts_meta__idx on compress_hyper_4_33_chunk (actual rows=11.00 loops=1) -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htc :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htc.dev Filter: (sum(DISTINCT skip_scan_htc.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htc Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 500 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) Rows Removed by Filter: 1005 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_3_5_chunk.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) -> Append (actual rows=1000.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=250.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=1.00 loops=1) Index Cond: (dev = 1) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htc."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_34_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_34_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_35_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_35_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_36_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_36_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_4_37_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_4_37_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; --- QUERY PLAN --- Append (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=1) Index Cond: (dev = 1) :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; --- QUERY PLAN --- Nested Loop (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -> Aggregate (actual rows=1.00 loops=11) -> Merge Append (actual rows=7.00 loops=11) Sort Key: skip_scan_htc_1.val -> Custom Scan (SkipScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk _hyper_3_5_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk compress_hyper_4_38_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk _hyper_3_6_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk compress_hyper_4_39_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk _hyper_3_7_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk compress_hyper_4_40_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -> Custom Scan (SkipScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk _hyper_3_8_chunk_1 (actual rows=2.00 loops=11) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk compress_hyper_4_41_chunk_1 (actual rows=2.00 loops=11) Index Cond: (dev = skip_scan_htc.dev) -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Insert on skip_scan_insert (actual rows=0.00 loops=1) -> Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htc.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); set_config ------------ on :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=11.00 loops=1) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); set_config ------------ off TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=1.00 loops=1) Index Cond: (val IS NULL) -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_38_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_38_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_39_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_39_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_40_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_40_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_4_41_chunk_dev_val__ts_meta_min_1__ts_meta_m_idx on compress_hyper_4_41_chunk (actual rows=0.00 loops=1) Index Cond: ((dev > 100) AND (val IS NULL)) SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_dagg_load_comp_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; enable_compressed_skipscan ---------------------------- on -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho basic DISTINCT queries on :TABLE basic DISTINCT queries on skip_scan_htcl -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Incremental Sort (actual rows=11.00 loops=1) Sort Key: skip_scan_htcl.dev, (count(DISTINCT skip_scan_htcl.dev)) Presorted Key: skip_scan_htcl.dev Full-sort Groups: 1 Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho stable expression in targetlist on :TABLE stable expression in targetlist on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; --- QUERY PLAN --- Sort (actual rows=11.00 loops=1) Sort Key: ((skip_scan_htcl.dev + 1)) Sort Method: quicksort -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho LIMIT queries on :TABLE LIMIT queries on skip_scan_htcl :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; --- QUERY PLAN --- Limit (actual rows=3.00 loops=1) -> GroupAggregate (actual rows=3.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=13.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=4.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=4.00 loops=1) \qecho range queries on :TABLE range queries on skip_scan_htcl set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=22.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) Vectorized Filter: (("time" >= 100) AND ("time" <= 300)) Rows Removed by Filter: 1993 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) Index Cond: ((_ts_meta_min_1 <= 300) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" < 200) Rows Removed by Filter: 501 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_min_1 < 200) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: _hyper_5_13_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) Vectorized Filter: ("time" > 800) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) Index Cond: (_ts_meta_max_1 > 800) reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE SUBSELECTS on skip_scan_htcl :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) \qecho ORDER BY ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=11.00 loops=1) -> GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev DESC -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; --- QUERY PLAN --- Subquery Scan on a (actual rows=5.00 loops=1) -> GroupAggregate (actual rows=5.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: (dev > 5) :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --- QUERY PLAN --- Subquery Scan on a (actual rows=8.00 loops=1) -> GroupAggregate (actual rows=8.00 loops=1) Group Key: skip_scan_htcl.dev Filter: (sum(DISTINCT skip_scan_htcl.dev) > 2) Rows Removed by Filter: 3 -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=1) Index Cond: (dev > 1) --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=32.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=8.00 loops=1) Index Cond: (dev > int_func_stable()) --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=28.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=28.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=7.00 loops=1) Filter: (dev > int_func_volatile()) Rows Removed by Filter: 755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY (inta_func_stable())) :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=12.00 loops=1) Hypertable: skip_scan_htcl Chunks excluded during startup: 0 -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=3.00 loops=1) Filter: (dev = ANY (inta_func_volatile())) Rows Removed by Filter: 1755 -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: dev Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=0.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=0.00 loops=1) Index Cond: (dev > 20) -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 100) Rows Removed by Filter: 745 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_min_1 <= 100) AND (_ts_meta_max_1 >= 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" > 200) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > 5) AND (_ts_meta_max_1 > 200)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=8.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=2.00 loops=1) Index Cond: ((dev >= 5) AND (dev < 7) AND (dev >= 2)) :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=0.00 loops=1) Group Key: _hyper_5_9_chunk.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 100) AND ("time" < 200) AND (val > 10) AND (val < 10000)) Rows Removed by Filter: 1000 -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=4.00 loops=1) Index Cond: ((dev > 2) AND (dev < 7) AND (_ts_meta_min_1 < 200) AND (_ts_meta_max_1 > 100)) :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; --- QUERY PLAN --- GroupAggregate (actual rows=11.00 loops=1) Group Key: skip_scan_htcl.dev -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; --- QUERY PLAN --- Subquery Scan on a (actual rows=1.00 loops=1) -> Aggregate (actual rows=1.00 loops=1) -> Nested Loop (actual rows=20020.00 loops=1) Join Filter: (skip_scan_htcl."time" <> "*VALUES*".column1) Rows Removed by Join Filter: 20 -> Merge Append (actual rows=10020.00 loops=1) Sort Key: skip_scan_htcl.dev -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=2505.00 loops=1) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=11.00 loops=1) -> Materialize (actual rows=2.00 loops=10020) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=36.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=9.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=9.00 loops=2) Filter: (dev <> "*VALUES*".column1) Rows Removed by Filter: 1 -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; --- QUERY PLAN --- Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Aggregate (actual rows=1.00 loops=2) -> Merge Append (actual rows=38.00 loops=2) Sort Key: skip_scan_htcl.dev -> Custom Scan (SkipScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_9_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_10_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_10_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_11_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_14_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_14_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_12_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_15_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_15_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) -> Custom Scan (SkipScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_5_13_chunk (actual rows=10.00 loops=2) -> Index Scan using compress_hyper_6_16_chunk_dev__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_6_16_chunk (actual rows=10.00 loops=2) Index Cond: (dev >= "*VALUES*".column1) RESET max_parallel_workers_per_gather; RESET enable_seqscan; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/plan_skip_scan_notnull.out�������������������������������������0000664�0000000�0000000�00000422264�15100345067�0024737�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' -- test SkipScan NOT NULL mode -- also sets up "skip_scan_b" table with a bool column and a not null column \ir include/skip_scan_notnull_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test 2-key index "(dev,dev_name)" where index qual may not be on a skip col -- Make sure it's the only index to be used for "dev" skipscan key -- skip_scan table CREATE INDEX skip_scan_dev_devname_idx ON skip_scan(dev,dev_name); -- skip_scan_ht table CREATE INDEX skip_scan_ht_dev_devname_idx ON skip_scan_ht(dev,dev_name); -- skip_scan_htc table ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk _timescaledb_internal._hyper_3_6_chunk _timescaledb_internal._hyper_3_7_chunk _timescaledb_internal._hyper_3_8_chunk -- table with a bool column CREATE TABLE skip_scan_b as select dev, coalesce(time,100) time, nullif(dev%3,2)::boolean as b from skip_scan; CREATE INDEX skip_scan_b_idx ON skip_scan_b(b); --table with not null constraint CREATE TABLE skip_scan_nn as select coalesce(dev,0) dev, coalesce(time,100) time from skip_scan; ALTER TABLE skip_scan_nn ALTER COLUMN dev SET NOT NULL; CREATE INDEX skip_scan_nn_idx ON skip_scan_nn(dev); SET timescaledb.debug_skip_scan_info TO true; \set TABLE skip_scan \ir include/skip_scan_notnull.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Base queries with regular NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE; psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE order by dev DESC; psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS FIRST) --- QUERY PLAN --- Unique (actual rows=12.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=12.00 loops=1) -> Index Only Scan Backward using skip_scan_dev_devname_idx on skip_scan (actual rows=12.00 loops=1) Index Cond: (dev < NULL::integer) -- Index quals except IS NULL discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL; psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev > 2; psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=8.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2)) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev BETWEEN 1 AND 5; psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=5.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 1) AND (dev <= 5)) -- next two filters produce small output for which we may select seqscan, don't want it set enable_seqscan=0; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev in (1,2,3); psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=3.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NULL; psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -- PG is smart enough to convert negation of IS NOT NULL to IS NULL index condition :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE (dev IS NOT NULL) = false; psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -- Complex expressions over IS NOT NULL are non-strict filters :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE ((dev is null) = false)::int + 1 > 1; psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 21 reset enable_seqscan; -- Strict Index filters discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev * 2 < 8; psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=4.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=4.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev * 2) < 8) Rows Removed by Filter: 7000 -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev < 2 OR dev > 0; psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 21 -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,-1) < 1; psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=2.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 10000 -- Strict non-index filters on relation discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100; psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=10.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 1 -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100 OR dev > 0; psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 22 -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100; psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=11.00 loops=1) -> Index Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=11.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 1 -- If at least one filter is strict then it filters out NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100 and dev + time < 100; psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=10.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 1 -- Index qual on a non-skip key: skip key can be NULL :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1'; psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev_name > 'device_1'::text)) -- Index quals on several keys including skip key :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1' and dev > 2; psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=8.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=8.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2) AND (dev_name > 'device_1'::text)) -- Index qual row comparison will filter out NULLs in skip key when skip key is a leading column -- But for compressed chunks ROW is not pushed into index quals, it is treated as a filter and is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev,dev_name) > row(1,'device_1'); psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev, dev_name) > ROW(1, 'device_1'::text))) -- Satisfying (dev_name>'device_1') may allow NULLs into dev :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev_name,dev) > row('device_1',1); psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=9.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev_name, dev) > ROW('device_1'::text, 1))) -- Non-index qual row comparison: row comparison in general is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev+1,dev_name) > row(1,'device_1'); psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on skip_scan_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=10.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 22 -- Different SkipScan column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev=1 and dev_name IS NOT NULL; psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on skip_scan_dev_devname_idx(dev_name NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_dev_devname_idx on skip_scan (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name > NULL::text) AND (dev_name IS NOT NULL)) -- Boolean and NOT NULL constraint tests -- Boolean column index qual is strict :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b; psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on skip_scan_b_idx(b NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_b (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_b_idx on skip_scan_b (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = true)) :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b != true; psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on skip_scan_b_idx(b NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_b (actual rows=1.00 loops=1) -> Index Only Scan using skip_scan_b_idx on skip_scan_b (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = false)) -- Boolean column predicates could be non-strict filters, below filter can accept NULLs :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b IS NOT true; psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on skip_scan_b_idx(b NULLS LAST) --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_b (actual rows=2.00 loops=1) -> Index Only Scan using skip_scan_b_idx on skip_scan_b (actual rows=2.00 loops=1) Index Cond: (b > NULL::boolean) Filter: (b IS NOT TRUE) Rows Removed by Filter: 4000 -- dev is declared NOT NULL :PREFIX SELECT DISTINCT dev FROM skip_scan_nn; psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on skip_scan_nn_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on skip_scan_nn (actual rows=11.00 loops=1) -> Index Only Scan using skip_scan_nn_idx on skip_scan_nn (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -- Set up hypertable with bool column SELECT create_hypertable('skip_scan_b', 'time', chunk_time_interval => 500, create_default_indexes => false, migrate_data => true); NOTICE: migrating data to chunks create_hypertable -------------------------- (7,public,skip_scan_b,t) -- Set up hypertable with not null column SELECT create_hypertable('skip_scan_nn', 'time', chunk_time_interval => 500, create_default_indexes => false, migrate_data => true); NOTICE: migrating data to chunks create_hypertable --------------------------- (8,public,skip_scan_nn,t) \set TABLE skip_scan_ht \ir include/skip_scan_notnull.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Base queries with regular NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE; psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) :PREFIX SELECT DISTINCT dev FROM :TABLE order by dev DESC; psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS FIRST) psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS FIRST) psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS FIRST) psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS FIRST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_ht.dev DESC -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=11.00 loops=1) -> Index Only Scan Backward using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=11.00 loops=1) Index Cond: (dev < NULL::integer) -- Index quals except IS NULL discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL; psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NOT NULL)) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev > 2; psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=8.00 loops=1) -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2)) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev BETWEEN 1 AND 5; psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 1) AND (dev <= 5)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 1) AND (dev <= 5)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 1) AND (dev <= 5)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=5.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev >= 1) AND (dev <= 5)) -- next two filters produce small output for which we may select seqscan, don't want it set enable_seqscan=0; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev in (1,2,3); psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev = ANY ('{1,2,3}'::integer[]))) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NULL; psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -- PG is smart enough to convert negation of IS NOT NULL to IS NULL index condition :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE (dev IS NOT NULL) = false; psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev IS NULL)) -- Complex expressions over IS NOT NULL are non-strict filters :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE ((dev is null) = false)::int + 1 > 1; psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 5 reset enable_seqscan; -- Strict Index filters discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev * 2 < 8; psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev * 2) < 8) Rows Removed by Filter: 1750 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev * 2) < 8) Rows Removed by Filter: 1750 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev * 2) < 8) Rows Removed by Filter: 1750 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=3.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev * 2) < 8) Rows Removed by Filter: 1750 -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev < 2 OR dev > 0; psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 5 -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,-1) < 1; psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -- Strict non-index filters on relation discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100; psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Filter: ((dev + "time") < 100) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 2500 -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100 OR dev > 0; psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100; psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=11.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=11.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=11.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 2505 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 2505 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 2505 -- If at least one filter is strict then it filters out NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100 and dev + time < 100; psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 2500 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Index Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=0.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 2500 -- Index qual on a non-skip key: skip key can be NULL :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1'; psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev_name > 'device_1'::text)) -- Index quals on several keys including skip key :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1' and dev > 2; psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=8.00 loops=1) -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=8.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > NULL::integer) AND (dev > 2) AND (dev_name > 'device_1'::text)) -- Index qual row comparison will filter out NULLs in skip key when skip key is a leading column -- But for compressed chunks ROW is not pushed into index quals, it is treated as a filter and is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev,dev_name) > row(1,'device_1'); psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev, dev_name) > ROW(1, 'device_1'::text))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev, dev_name) > ROW(1, 'device_1'::text))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev, dev_name) > ROW(1, 'device_1'::text))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev, dev_name) > ROW(1, 'device_1'::text))) -- Satisfying (dev_name>'device_1') may allow NULLs into dev :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev_name,dev) > row('device_1',1); psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev_name, dev) > ROW('device_1'::text, 1))) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev_name, dev) > ROW('device_1'::text, 1))) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev_name, dev) > ROW('device_1'::text, 1))) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=9.00 loops=1) Index Cond: ((dev > NULL::integer) AND (ROW(dev_name, dev) > ROW('device_1'::text, 1))) -- Non-index qual row comparison: row comparison in general is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev+1,dev_name) > row(1,'device_1'); psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_ht.dev -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -- Different SkipScan column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev=1 and dev_name IS NOT NULL; psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx(dev_name NOT NULL) psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx(dev_name NOT NULL) psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx(dev_name NOT NULL) psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx(dev_name NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_ht.dev_name -> Custom Scan (SkipScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_1_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_1_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_2_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_2_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_3_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_3_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_3_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name > NULL::text) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_1_4_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_1_4_chunk_skip_scan_ht_dev_devname_idx on _hyper_1_4_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name > NULL::text) AND (dev_name IS NOT NULL)) -- Boolean and NOT NULL constraint tests -- Boolean column index qual is strict :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b; psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on _hyper_7_21_chunk_skip_scan_b_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on _hyper_7_22_chunk_skip_scan_b_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on _hyper_7_23_chunk_skip_scan_b_idx(b NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: skip_scan_b.b -> Custom Scan (SkipScan) on _hyper_7_21_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_7_21_chunk_skip_scan_b_idx on _hyper_7_21_chunk (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = true)) -> Custom Scan (SkipScan) on _hyper_7_22_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_7_22_chunk_skip_scan_b_idx on _hyper_7_22_chunk (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = true)) -> Custom Scan (SkipScan) on _hyper_7_23_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_7_23_chunk_skip_scan_b_idx on _hyper_7_23_chunk (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = true)) :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b != true; psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on _hyper_7_21_chunk_skip_scan_b_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on _hyper_7_22_chunk_skip_scan_b_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on _hyper_7_23_chunk_skip_scan_b_idx(b NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: skip_scan_b.b -> Custom Scan (SkipScan) on _hyper_7_21_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_7_21_chunk_skip_scan_b_idx on _hyper_7_21_chunk (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = false)) -> Custom Scan (SkipScan) on _hyper_7_22_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_7_22_chunk_skip_scan_b_idx on _hyper_7_22_chunk (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = false)) -> Custom Scan (SkipScan) on _hyper_7_23_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_7_23_chunk_skip_scan_b_idx on _hyper_7_23_chunk (actual rows=1.00 loops=1) Index Cond: ((b > NULL::boolean) AND (b = false)) -- Boolean column predicates could be non-strict filters, below filter can accept NULLs :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b IS NOT true; psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on _hyper_7_21_chunk_skip_scan_b_idx(b NULLS LAST) psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on _hyper_7_22_chunk_skip_scan_b_idx(b NULLS LAST) psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on _hyper_7_23_chunk_skip_scan_b_idx(b NULLS LAST) --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=6.00 loops=1) Sort Key: skip_scan_b.b -> Custom Scan (SkipScan) on _hyper_7_21_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_7_21_chunk_skip_scan_b_idx on _hyper_7_21_chunk (actual rows=2.00 loops=1) Index Cond: (b > NULL::boolean) Filter: (b IS NOT TRUE) Rows Removed by Filter: 1996 -> Custom Scan (SkipScan) on _hyper_7_22_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_7_22_chunk_skip_scan_b_idx on _hyper_7_22_chunk (actual rows=2.00 loops=1) Index Cond: (b > NULL::boolean) Filter: (b IS NOT TRUE) Rows Removed by Filter: 2000 -> Custom Scan (SkipScan) on _hyper_7_23_chunk (actual rows=2.00 loops=1) -> Index Only Scan using _hyper_7_23_chunk_skip_scan_b_idx on _hyper_7_23_chunk (actual rows=2.00 loops=1) Index Cond: (b > NULL::boolean) Filter: (b IS NOT TRUE) Rows Removed by Filter: 4 -- dev is declared NOT NULL :PREFIX SELECT DISTINCT dev FROM skip_scan_nn; psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on _hyper_8_24_chunk_skip_scan_nn_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on _hyper_8_25_chunk_skip_scan_nn_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on _hyper_8_26_chunk_skip_scan_nn_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_nn.dev -> Custom Scan (SkipScan) on _hyper_8_24_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_8_24_chunk_skip_scan_nn_idx on _hyper_8_24_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_8_25_chunk (actual rows=11.00 loops=1) -> Index Only Scan using _hyper_8_25_chunk_skip_scan_nn_idx on _hyper_8_25_chunk (actual rows=11.00 loops=1) Index Cond: (dev > NULL::integer) -> Custom Scan (SkipScan) on _hyper_8_26_chunk (actual rows=10.00 loops=1) -> Index Only Scan using _hyper_8_26_chunk_skip_scan_nn_idx on _hyper_8_26_chunk (actual rows=10.00 loops=1) Index Cond: (dev > NULL::integer) -- Compress on bool column ALTER TABLE skip_scan_b SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='b'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_b') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_21_chunk _timescaledb_internal._hyper_7_22_chunk _timescaledb_internal._hyper_7_23_chunk -- Compress on not null column ALTER TABLE skip_scan_nn SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_nn') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_8_24_chunk _timescaledb_internal._hyper_8_25_chunk _timescaledb_internal._hyper_8_26_chunk \set TABLE skip_scan_htc \ir include/skip_scan_notnull.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Base queries with regular NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE; psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:6: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) :PREFIX SELECT DISTINCT dev FROM :TABLE order by dev DESC; psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS FIRST) psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS FIRST) psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS FIRST) psql:include/skip_scan_notnull.sql:8: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS FIRST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=44.00 loops=1) Sort Key: skip_scan_htc.dev DESC -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=11.00 loops=1) -> Index Scan Backward using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- Index quals except IS NULL discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL; psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:11: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Index Cond: (dev IS NOT NULL) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev > 2; psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:13: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=8.00 loops=1) -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=8.00 loops=1) Index Cond: (dev > 2) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=8.00 loops=1) Index Cond: (dev > 2) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=8.00 loops=1) Index Cond: (dev > 2) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=8.00 loops=1) Index Cond: (dev > 2) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev BETWEEN 1 AND 5; psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:15: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=5.00 loops=1) -> Merge Append (actual rows=20.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=5.00 loops=1) Index Cond: ((dev >= 1) AND (dev <= 5)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=5.00 loops=1) Index Cond: ((dev >= 1) AND (dev <= 5)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=5.00 loops=1) Index Cond: ((dev >= 1) AND (dev <= 5)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=5.00 loops=1) Index Cond: ((dev >= 1) AND (dev <= 5)) -- next two filters produce small output for which we may select seqscan, don't want it set enable_seqscan=0; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev in (1,2,3); psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:19: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=3.00 loops=1) Index Cond: (dev = ANY ('{1,2,3}'::integer[])) :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NULL; psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:21: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- PG is smart enough to convert negation of IS NOT NULL to IS NULL index condition :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE (dev IS NOT NULL) = false; psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:24: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: (dev IS NULL) -- Complex expressions over IS NOT NULL are non-strict filters :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE ((dev is null) = false)::int + 1 > 1; psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:27: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Filter: ((((dev IS NOT NULL))::integer + 1) > 1) Rows Removed by Filter: 1 reset enable_seqscan; -- Strict Index filters discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev * 2 < 8; psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:31: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=3.00 loops=1) -> Merge Append (actual rows=12.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=3.00 loops=1) Filter: ((dev * 2) < 8) Rows Removed by Filter: 7 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=3.00 loops=1) Filter: ((dev * 2) < 8) Rows Removed by Filter: 7 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=3.00 loops=1) Filter: ((dev * 2) < 8) Rows Removed by Filter: 7 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=3.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=3.00 loops=1) Filter: ((dev * 2) < 8) Rows Removed by Filter: 7 -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev < 2 OR dev > 0; psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:34: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 1 -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) Filter: ((dev < 2) OR (dev > 0)) Rows Removed by Filter: 1 -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,-1) < 1; psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:36: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) Filter: (COALESCE(dev, '-1'::integer) < 1) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- Strict non-index filters on relation discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100; psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:39: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 1555 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) Filter: ((dev + "time") < 100) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100 OR dev > 0; psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:42: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) Filter: (((dev + "time") < 100) OR (dev > 0)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100; psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:44: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=11.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=11.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 1558 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 2505 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 2505 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) Filter: ((COALESCE(dev, 20) + "time") < 100) Rows Removed by Filter: 2505 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- If at least one filter is strict then it filters out NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100 and dev + time < 100; psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:47: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 1555 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=0.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=0.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=10.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=0.00 loops=1) Filter: (((COALESCE(dev, 20) + "time") < 100) AND ((dev + "time") < 100)) Rows Removed by Filter: 2500 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=10.00 loops=1) -- Index qual on a non-skip key: skip key can be NULL :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1'; psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:50: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=9.00 loops=1) Index Cond: (dev_name > 'device_1'::text) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=9.00 loops=1) Index Cond: (dev_name > 'device_1'::text) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=9.00 loops=1) Index Cond: (dev_name > 'device_1'::text) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=9.00 loops=1) Index Cond: (dev_name > 'device_1'::text) -- Index quals on several keys including skip key :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1' and dev > 2; psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:53: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=8.00 loops=1) -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > 2) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > 2) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > 2) AND (dev_name > 'device_1'::text)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=8.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=8.00 loops=1) Index Cond: ((dev > 2) AND (dev_name > 'device_1'::text)) -- Index qual row comparison will filter out NULLs in skip key when skip key is a leading column -- But for compressed chunks ROW is not pushed into index quals, it is treated as a filter and is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev,dev_name) > row(1,'device_1'); psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:57: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev, dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev, dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev, dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev, dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- Satisfying (dev_name>'device_1') may allow NULLs into dev :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev_name,dev) > row('device_1',1); psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:60: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=9.00 loops=1) -> Merge Append (actual rows=36.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev_name, dev) > ROW('device_1'::text, 1)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev_name, dev) > ROW('device_1'::text, 1)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev_name, dev) > ROW('device_1'::text, 1)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=9.00 loops=1) Filter: (ROW(dev_name, dev) > ROW('device_1'::text, 1)) Rows Removed by Filter: 255 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- Non-index qual row comparison: row comparison in general is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev+1,dev_name) > row(1,'device_1'); psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) psql:include/skip_scan_notnull.sql:63: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev NULLS LAST) --- QUERY PLAN --- Unique (actual rows=10.00 loops=1) -> Merge Append (actual rows=40.00 loops=1) Sort Key: skip_scan_htc.dev -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=10.00 loops=1) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=10.00 loops=1) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=10.00 loops=1) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=10.00 loops=1) Filter: (ROW((dev + 1), dev_name) > ROW(1, 'device_1'::text)) Rows Removed by Filter: 5 -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=11.00 loops=1) -- Different SkipScan column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev=1 and dev_name IS NOT NULL; psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev_name NOT NULL) psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev_name NOT NULL) psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev_name NOT NULL) psql:include/skip_scan_notnull.sql:66: INFO: SkipScan used on compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx(dev_name NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=4.00 loops=1) Sort Key: skip_scan_htc.dev_name -> Custom Scan (SkipScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_17_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_17_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_6_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_18_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_18_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_7_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_19_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_19_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -> Custom Scan (SkipScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_8_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_4_20_chunk_dev_dev_name__ts_meta_min_1__ts_m_idx on compress_hyper_4_20_chunk (actual rows=1.00 loops=1) Index Cond: ((dev = 1) AND (dev_name IS NOT NULL)) -- Boolean and NOT NULL constraint tests -- Boolean column index qual is strict :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b; psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on compress_hyper_9_27_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on compress_hyper_9_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:71: INFO: SkipScan used on compress_hyper_9_29_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: skip_scan_b.b -> Custom Scan (SkipScan) on _hyper_7_21_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_21_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_9_27_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_27_chunk (actual rows=1.00 loops=1) Index Cond: (b = true) -> Custom Scan (SkipScan) on _hyper_7_22_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_22_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_9_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_28_chunk (actual rows=1.00 loops=1) Index Cond: (b = true) -> Custom Scan (SkipScan) on _hyper_7_23_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_23_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_9_29_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_29_chunk (actual rows=1.00 loops=1) Index Cond: (b = true) :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b != true; psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on compress_hyper_9_27_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on compress_hyper_9_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NOT NULL) psql:include/skip_scan_notnull.sql:72: INFO: SkipScan used on compress_hyper_9_29_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NOT NULL) --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: skip_scan_b.b -> Custom Scan (SkipScan) on _hyper_7_21_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_21_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_9_27_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_27_chunk (actual rows=1.00 loops=1) Index Cond: (b = false) -> Custom Scan (SkipScan) on _hyper_7_22_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_22_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_9_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_28_chunk (actual rows=1.00 loops=1) Index Cond: (b = false) -> Custom Scan (SkipScan) on _hyper_7_23_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_23_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_9_29_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_29_chunk (actual rows=1.00 loops=1) Index Cond: (b = false) -- Boolean column predicates could be non-strict filters, below filter can accept NULLs :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b IS NOT true; psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on compress_hyper_9_27_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NULLS LAST) psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on compress_hyper_9_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NULLS LAST) psql:include/skip_scan_notnull.sql:74: INFO: SkipScan used on compress_hyper_9_29_chunk_b__ts_meta_min_1__ts_meta_max_1_idx(b NULLS LAST) --- QUERY PLAN --- Unique (actual rows=2.00 loops=1) -> Merge Append (actual rows=6.00 loops=1) Sort Key: skip_scan_b.b -> Custom Scan (SkipScan) on _hyper_7_21_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_21_chunk (actual rows=2.00 loops=1) Filter: (b IS NOT TRUE) Rows Removed by Filter: 1996 -> Index Scan using compress_hyper_9_27_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_27_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_7_22_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_22_chunk (actual rows=2.00 loops=1) Filter: (b IS NOT TRUE) Rows Removed by Filter: 2000 -> Index Scan using compress_hyper_9_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_28_chunk (actual rows=4.00 loops=1) -> Custom Scan (SkipScan) on _hyper_7_23_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_7_23_chunk (actual rows=2.00 loops=1) Filter: (b IS NOT TRUE) Rows Removed by Filter: 4 -> Index Scan using compress_hyper_9_29_chunk_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_9_29_chunk (actual rows=3.00 loops=1) -- dev is declared NOT NULL :PREFIX SELECT DISTINCT dev FROM skip_scan_nn; psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on compress_hyper_10_30_chunk_dev__ts_meta_min_1__ts_meta_max__idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on compress_hyper_10_31_chunk_dev__ts_meta_min_1__ts_meta_max__idx(dev NOT NULL) psql:include/skip_scan_notnull.sql:77: INFO: SkipScan used on compress_hyper_10_32_chunk_dev__ts_meta_min_1__ts_meta_max__idx(dev NOT NULL) --- QUERY PLAN --- Unique (actual rows=11.00 loops=1) -> Merge Append (actual rows=32.00 loops=1) Sort Key: skip_scan_nn.dev -> Custom Scan (SkipScan) on _hyper_8_24_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_8_24_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_10_30_chunk_dev__ts_meta_min_1__ts_meta_max__idx on compress_hyper_10_30_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_8_25_chunk (actual rows=11.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_8_25_chunk (actual rows=11.00 loops=1) -> Index Scan using compress_hyper_10_31_chunk_dev__ts_meta_min_1__ts_meta_max__idx on compress_hyper_10_31_chunk (actual rows=11.00 loops=1) -> Custom Scan (SkipScan) on _hyper_8_26_chunk (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_8_26_chunk (actual rows=10.00 loops=1) -> Index Scan using compress_hyper_10_32_chunk_dev__ts_meta_min_1__ts_meta_max__idx on compress_hyper_10_32_chunk (actual rows=10.00 loops=1) RESET timescaledb.debug_skip_scan_info; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/policy_generalization.out��������������������������������������0000664�0000000�0000000�00000013220�15100345067�0024556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Validate utility functions and policies for INTEGER columns -- using chunk creation time metadata. This allows to specify -- INTERVAL boundary for INTEGER type columns. DROP TABLE IF EXISTS test; NOTICE: table "test" does not exist, skipping CREATE TABLE test(time INTEGER, device INTEGER, temp FLOAT); SELECT create_hypertable('test', 'time', chunk_time_interval => 10); create_hypertable ------------------- (1,public,test,t) INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; select count(*) from timescaledb_information.chunks where hypertable_name='test'; count ------- 11 -- Validate that show_chunks/drop chunks doesn't work with existing arguments \set ON_ERROR_STOP 0 SELECT count(*) from show_chunks('test', newer_than => INTERVAL '1 hour'); ERROR: invalid time argument type "interval" SELECT count(*) from show_chunks('test', older_than => now()); ERROR: invalid time argument type "timestamp with time zone" SELECT count(*) from drop_chunks('test', older_than => now()); ERROR: invalid time argument type "timestamp with time zone" \set ON_ERROR_STOP 1 SELECT count(*) from show_chunks('test', created_after => INTERVAL '1 hour'); count ------- 11 SELECT count(*) from show_chunks('test', created_before => now()); count ------- 11 SELECT count(*) from drop_chunks('test', created_before => now()); count ------- 11 select count(*) from timescaledb_information.chunks where hypertable_name='test'; count ------- 0 INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; select count(*) from timescaledb_information.chunks where hypertable_name='test'; count ------- 11 SELECT count(*) from drop_chunks('test', created_after => INTERVAL '1 hour'); count ------- 11 select count(*) from timescaledb_information.chunks where hypertable_name='test'; count ------- 0 -- retention policy INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; \set ON_ERROR_STOP 0 -- interval input for "drop_after" for INTEGER partitioning errors out SELECT add_retention_policy('test', INTERVAL '5 seconds', true); ERROR: invalid value for parameter drop_after -- integer input for "drop_after" for INTEGER partitioning without valid -- integer_now function errors out SELECT add_retention_policy('test', 2000, true); ERROR: invalid value for parameter drop_after -- both drop_created_before and drop_after should error out SELECT add_retention_policy('test', drop_after => INTERVAL '5 seconds', drop_created_before => INTERVAL '2 seconds'); ERROR: need to specify one of "drop_after" or "drop_created_before" \set ON_ERROR_STOP 1 SELECT add_retention_policy('test', drop_created_before => INTERVAL '2 seconds', if_not_exists => true) as drop_chunks_job_id \gset CALL run_job(:drop_chunks_job_id); select count(*) from timescaledb_information.chunks where hypertable_name='test'; count ------- 11 SELECT pg_sleep(3); pg_sleep ---------- CALL run_job(:drop_chunks_job_id); select count(*) from timescaledb_information.chunks where hypertable_name='test'; count ------- 0 -- check for WARNING/NOTICE if policy already exists SELECT add_retention_policy('test', drop_created_before => INTERVAL '2 seconds', if_not_exists => true); NOTICE: retention policy already exists for hypertable "test", skipping add_retention_policy ---------------------- -1 SELECT add_retention_policy('test', drop_created_before => INTERVAL '20 seconds', if_not_exists => true); WARNING: retention policy already exists for hypertable "test" add_retention_policy ---------------------- -1 SELECT remove_retention_policy('test'); remove_retention_policy ------------------------- -- compression policy ALTER TABLE test SET (timescaledb.compress); INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; -- Chunk compression status SELECT DISTINCT compression_status FROM _timescaledb_internal.compressed_chunk_stats; compression_status -------------------- Uncompressed -- Compression policy SELECT add_compression_policy('test', compress_created_before => INTERVAL '1 hour') AS compress_chunks_job_id \gset SELECT pg_sleep(3); pg_sleep ---------- CALL run_job(:compress_chunks_job_id); -- Chunk compression status SELECT DISTINCT compression_status FROM _timescaledb_internal.compressed_chunk_stats; compression_status -------------------- Uncompressed SELECT remove_compression_policy('test'); remove_compression_policy --------------------------- t SELECT add_compression_policy('test', compress_created_before => INTERVAL '2 seconds') AS compress_chunks_job_id \gset CALL run_job(:compress_chunks_job_id); -- Chunk compression status SELECT DISTINCT compression_status FROM _timescaledb_internal.compressed_chunk_stats; compression_status -------------------- Compressed -- check for WARNING/NOTICE if policy already exists SELECT add_compression_policy('test', compress_created_before => INTERVAL '2 seconds', if_not_exists => true); NOTICE: columnstore policy already exists for hypertable "test", skipping add_compression_policy ------------------------ -1 SELECT add_compression_policy('test', compress_created_before => INTERVAL '20 seconds', if_not_exists => true); WARNING: columnstore policy already exists for hypertable "test" add_compression_policy ------------------------ -1 SELECT remove_compression_policy('test'); remove_compression_policy --------------------------- t DROP TABLE test; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/privilege_maintain.out�����������������������������������������0000664�0000000�0000000�00000020076�15100345067�0024041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE r_maintain; CREATE TABLE metrics(time timestamptz, device text, value float); SELECT create_hypertable('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) INSERT INTO metrics SELECT generate_series('2020-01-01'::timestamptz, '2020-01-09'::timestamptz, '3 day'::interval); \dp metrics Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+---------+-------+-------------------+-------------------+---------- public | metrics | table | | | \dp _timescaledb_internal._hyper_* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+-------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | | | _timescaledb_internal | _hyper_1_2_chunk | table | | | GRANT MAINTAIN ON TABLE metrics TO r_maintain; -- check privilege is present on all the chunks \dp metrics Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+---------+-------+--------------------------------+-------------------+---------- public | metrics | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | \dp _timescaledb_internal._hyper_* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | REVOKE MAINTAIN ON TABLE metrics FROM r_maintain; -- check privilege got removed from all the chunks \dp metrics Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+---------+-------+--------------------------------+-------------------+---------- public | metrics | table | super_user=arwdDxtm/super_user | | \dp _timescaledb_internal._hyper_* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user | | ALTER TABLE metrics SET (timescaledb.compress); SELECT compress_chunk(chunk) FROM show_chunks('metrics') chunk; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk GRANT MAINTAIN ON TABLE metrics TO r_maintain; -- check privilege is present on all the chunks \dp metrics Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+---------+-------+--------------------------------+-------------------+---------- public | metrics | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | \dp _timescaledb_internal._hyper_* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | \dp _timescaledb_internal.*compress* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+--------------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _compressed_hypertable_2 | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | _timescaledb_internal | compress_hyper_2_3_chunk | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | _timescaledb_internal | compress_hyper_2_4_chunk | table | super_user=arwdDxtm/super_user+| | | | | r_maintain=m/super_user | | _timescaledb_internal | compressed_chunk_stats | view | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | REVOKE MAINTAIN ON TABLE metrics FROM r_maintain; -- check privilege got removed from all the chunks \dp metrics Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies --------+---------+-------+--------------------------------+-------------------+---------- public | metrics | table | super_user=arwdDxtm/super_user | | \dp _timescaledb_internal._hyper_* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _hyper_1_1_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | _hyper_1_2_chunk | table | super_user=arwdDxtm/super_user | | \dp _timescaledb_internal.*compress* Access privileges Schema | Name | Type | Access privileges | Column privileges | Policies -----------------------+--------------------------+-------+--------------------------------+-------------------+---------- _timescaledb_internal | _compressed_hypertable_2 | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | compress_hyper_2_3_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | compress_hyper_2_4_chunk | table | super_user=arwdDxtm/super_user | | _timescaledb_internal | compressed_chunk_stats | view | super_user=arwdDxtm/super_user+| | | | | =r/super_user | | ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/read_only.out��������������������������������������������������0000664�0000000�0000000�00000025345�15100345067�0022153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; -- Following tests checks that API functions which modify data (including catalog) -- properly recognize read-only transaction state -- -- create_hypertable() -- CREATE TABLE test_table(time bigint NOT NULL, device int); -- EXPLAIN should work in read-only mode, when enabling in transaction. START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM test_table; --- QUERY PLAN --- Seq Scan on test_table ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) SELECT * FROM test_table; --- QUERY PLAN --- Seq Scan on test_table (actual rows=0.00 loops=1) ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO test_table VALUES (1, 1); --- QUERY PLAN --- Insert on test_table -> Result ROLLBACK; -- This should give an error since we are using ANALYZE and a DML. The -- read-only is checked when executing the actual INSERT statement, -- not inside our code. \set ON_ERROR_STOP 0 START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) INSERT INTO test_table VALUES (1, 1); ERROR: cannot execute INSERT in a read-only transaction ROLLBACK; \set ON_ERROR_STOP 1 SET default_transaction_read_only TO on; -- EXPLAIN should work in read-only mode, even when using the default. START TRANSACTION; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM test_table; --- QUERY PLAN --- Seq Scan on test_table ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) SELECT * FROM test_table; --- QUERY PLAN --- Seq Scan on test_table (actual rows=0.00 loops=1) ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO test_table VALUES (1, 1); --- QUERY PLAN --- Insert on test_table -> Result ROLLBACK; -- This should give an error since we are using ANALYZE and a DML. The -- read-only is checked when executing the actual INSERT statement, -- not inside our code. \set ON_ERROR_STOP 0 START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) INSERT INTO test_table VALUES (1, 1); ERROR: cannot execute INSERT in a read-only transaction ROLLBACK; \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('test_table', 'time'); ERROR: cannot execute create_hypertable() in a read-only transaction \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; SELECT * FROM create_hypertable('test_table', 'time', chunk_time_interval => 1000000::bigint); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | test_table | t SET default_transaction_read_only TO on; \set ON_ERROR_STOP 0 -- set_chunk_time_interval() -- SELECT * FROM set_chunk_time_interval('test_table', 2000000000::bigint); ERROR: cannot execute set_chunk_time_interval() in a read-only transaction -- set_number_partitions() -- SELECT * FROM set_number_partitions('test_table', 2); ERROR: cannot execute set_number_partitions() in a read-only transaction -- set_adaptive_chunking() -- SELECT * FROM set_adaptive_chunking('test_table', '2MB'); ERROR: cannot execute set_adaptive_chunking() in a read-only transaction -- drop_chunks() -- SELECT * FROM drop_chunks('test_table', older_than => 10); ERROR: cannot execute drop_chunks() in a read-only transaction -- add_dimension() -- SELECT * FROM add_dimension('test_table', 'device', chunk_time_interval => 100); ERROR: cannot execute add_dimension() in a read-only transaction \set ON_ERROR_STOP 1 -- tablespaces -- SET default_transaction_read_only TO off; SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_CLUSTER_SUPERUSER LOCATION :TEST_TABLESPACE1_PATH; SET default_transaction_read_only TO on; -- attach_tablespace() -- \set ON_ERROR_STOP 0 SELECT * FROM attach_tablespace('tablespace1', 'test_table'); ERROR: cannot execute attach_tablespace() in a read-only transaction \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; SELECT * FROM attach_tablespace('tablespace1', 'test_table'); attach_tablespace ------------------- -- detach_tablespace() -- SET default_transaction_read_only TO on; \set ON_ERROR_STOP 0 SELECT * FROM detach_tablespace('tablespace1', 'test_table'); ERROR: cannot execute detach_tablespace() in a read-only transaction \set ON_ERROR_STOP 1 -- detach_tablespaces() -- \set ON_ERROR_STOP 0 SELECT * FROM detach_tablespaces('test_table'); ERROR: cannot execute detach_tablespaces() in a read-only transaction \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; SELECT * FROM detach_tablespaces('test_table'); detach_tablespaces -------------------- 1 DROP TABLESPACE tablespace1; -- drop hypertable -- SET default_transaction_read_only TO on; \set ON_ERROR_STOP 0 DROP TABLE test_table; ERROR: cannot execute DROP TABLE in a read-only transaction \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; DROP TABLE test_table; -- Test some read-only cases of DDL operations -- CREATE TABLE test_table(time bigint NOT NULL, device int); SELECT * FROM create_hypertable('test_table', 'time', chunk_time_interval => 1000000::bigint); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 2 | public | test_table | t INSERT INTO test_table VALUES (0, 1), (1, 1), (2, 2); SET default_transaction_read_only TO on; -- CREATE INDEX -- \set ON_ERROR_STOP 0 CREATE INDEX test_table_device_idx ON test_table(device); ERROR: cannot execute CREATE INDEX in a read-only transaction \set ON_ERROR_STOP 1 -- TRUNCATE -- \set ON_ERROR_STOP 0 TRUNCATE test_table; ERROR: cannot execute TRUNCATE TABLE in a read-only transaction \set ON_ERROR_STOP 1 -- ALTER TABLE -- \set ON_ERROR_STOP 0 ALTER TABLE test_table DROP COLUMN device; ERROR: cannot execute ALTER TABLE in a read-only transaction ALTER TABLE test_table ADD CONSTRAINT device_check CHECK (device > 0); ERROR: cannot execute ALTER TABLE in a read-only transaction \set ON_ERROR_STOP 1 -- VACUUM -- \set ON_ERROR_STOP 0 VACUUM test_table; ERROR: cannot execute VACUUM in a read-only transaction \set ON_ERROR_STOP 1 -- CLUSTER -- \set ON_ERROR_STOP 0 CLUSTER test_table USING test_table_time_idx; ERROR: cannot execute CLUSTER in a read-only transaction \set ON_ERROR_STOP 1 -- COPY FROM -- \set ON_ERROR_STOP 0 COPY test_table (time, device) FROM STDIN DELIMITER ','; ERROR: cannot execute COPY FROM in a read-only transaction \set ON_ERROR_STOP 1 -- COPY TO (expect to be working in read-only mode) -- COPY (SELECT * FROM test_Table ORDER BY time) TO STDOUT; 0 1 1 1 2 2 -- Test Continuous Aggregates -- SET default_transaction_read_only TO off; CREATE TABLE test_contagg ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT create_hypertable('test_contagg', 'observation_time'); create_hypertable --------------------------- (3,public,test_contagg,t) SET default_transaction_read_only TO on; -- CREATE VIEW -- \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW test_contagg_view WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', observation_time) as bucket, device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM test_contagg GROUP BY bucket, device_id WITH NO DATA; ERROR: cannot execute CREATE MATERIALIZED VIEW in a read-only transaction -- policy API -- compression policy will not throw an error, as it is expected to continue -- with next chunks SET default_transaction_read_only TO off; CREATE TABLE test_table_int(time bigint NOT NULL, device int); SELECt create_hypertable('test_table_int', 'time', chunk_time_interval=>'1'::bigint); create_hypertable ----------------------------- (4,public,test_table_int,t) create or replace function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 5::BIGINT'; select set_integer_now_func('test_table_int', 'dummy_now'); set_integer_now_func ---------------------- ALTER TABLE test_table_int SET (timescaledb.compress); INSERT INTO test_table_int VALUES (0, 1), (10,10); SELECT add_compression_policy('test_table_int', '1'::integer) as comp_job_id \gset SELECT config as comp_job_config FROM _timescaledb_config.bgw_job WHERE id = :comp_job_id \gset SET default_transaction_read_only TO on; CALL _timescaledb_functions.policy_compression(:comp_job_id, :'comp_job_config'); WARNING: converting chunk "_timescaledb_internal._hyper_4_2_chunk" to columnstore failed when recompress columnstore policy is executed ERROR: columnstore policy failure SET default_transaction_read_only TO off; --verify chunks are not compressed SELECT count(*) , count(*) FILTER ( WHERE is_compressed is true) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int'; count | count -------+------- 2 | 0 --cleanup DROP TABLE test_table_int; SET default_transaction_read_only TO on; CALL _timescaledb_functions.policy_refresh_continuous_aggregate(1,'{}'); ERROR: cannot execute policy_refresh_continuous_aggregate() in a read-only transaction CALL _timescaledb_functions.policy_reorder(1,'{}'); ERROR: cannot execute policy_reorder() in a read-only transaction CALL _timescaledb_functions.policy_retention(1,'{}'); ERROR: cannot execute policy_retention() in a read-only transaction SELECT add_compression_policy('test_table', '1w'); ERROR: cannot execute add_compression_policy() in a read-only transaction SELECT remove_compression_policy('test_table'); ERROR: cannot execute remove_compression_policy() in a read-only transaction SELECT add_reorder_policy('test_table', 'test_table_time_idx'); ERROR: cannot execute add_reorder_policy() in a read-only transaction SELECT remove_reorder_policy('test_table'); ERROR: cannot execute remove_reorder_policy() in a read-only transaction SELECT add_retention_policy('test_table', '1w'); ERROR: cannot execute add_retention_policy() in a read-only transaction SELECT remove_retention_policy('test_table'); ERROR: cannot execute remove_retention_policy() in a read-only transaction SELECT add_job('now','12h'); ERROR: cannot execute add_job() in a read-only transaction SELECT alter_job(1,scheduled:=false); ERROR: cannot execute alter_job() in a read-only transaction SELECT delete_job(1); ERROR: cannot execute delete_job() in a read-only transaction �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/recompress_chunk_segmentwise.out�������������������������������0000664�0000000�0000000�00000126353�15100345067�0026164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name, c.id as chunk_id FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE OR REPLACE VIEW compression_rowcnt_view AS select ccs.numrows_pre_compression, ccs.numrows_post_compression, (v.chunk_schema || '.' || v.chunk_name) as chunk_name, v.chunk_id as chunk_id from _timescaledb_catalog.compression_chunk_size ccs join compressed_chunk_info_view v on ccs.chunk_id = v.chunk_id; -- enable GUC to ensure correct index is being used during recompression SET timescaledb.debug_compression_path_info TO ON; ------------- only one segment exists and only one segment affected --------- create table mytab_oneseg (time timestamptz not null, a int, b int, c int); SELECT create_hypertable('mytab_oneseg', 'time', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (1,public,mytab_oneseg,t) insert into mytab_oneseg values ('2023-01-01 21:56:20.048355+02'::timestamptz, 2, NULL, 2), ('2023-01-01 21:56:10.048355+02'::timestamptz, 2, NULL, 2); --same chunk same segment alter table mytab_oneseg set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select show_chunks as chunk_to_compress_1 from show_chunks('mytab_oneseg') limit 1 \gset select compress_chunk(:'chunk_to_compress_1'); INFO: using tuplesort to scan rows from "_hyper_1_1_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk SELECT compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name_1 from compressed_chunk_info_view where hypertable_name = 'mytab_oneseg' \gset SELECT ctid, * FROM :compressed_chunk_name_1; ctid | _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b -------+----------------+---+---+-------------------------------------+-------------------------------------+----------------------------------------------------------------------+------ (0,1) | 2 | 2 | 2 | Sun Jan 01 11:56:10.048355 2023 PST | Sun Jan 01 11:56:20.048355 2023 PST | BAAAApQ3/qlnY///////Z2mAAAAAAgAAAAIAAAAAAAAA7gAFKG/+g/vGAAUob/+1KMU= | Bg== -- after compressing the chunk select numrows_pre_compression, numrows_post_compression from _timescaledb_catalog.compression_chunk_size; numrows_pre_compression | numrows_post_compression -------------------------+-------------------------- 2 | 1 insert into mytab_oneseg values ('2023-01-01 19:56:20.048355+02'::timestamptz, 2, NULL, 2); -- after inserting new row in compressed chunk select numrows_pre_compression, numrows_post_compression from _timescaledb_catalog.compression_chunk_size; numrows_pre_compression | numrows_post_compression -------------------------+-------------------------- 2 | 1 select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_1'); INFO: Using index "compress_hyper_2_2_chunk_a_c__ts_meta_min_1__ts_meta_max_1_idx" for recompression recompress_chunk_segmentwise ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- check the ctid of the rows in the recompressed chunk to verify that we've written new data SELECT ctid, * FROM :compressed_chunk_name_1; ctid | _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b -------+----------------+---+---+-------------------------------------+-------------------------------------+----------------------------------------------------------------------+------ (0,1) | 2 | 2 | 2 | Sun Jan 01 11:56:10.048355 2023 PST | Sun Jan 01 11:56:20.048355 2023 PST | BAAAApQ3/qlnY///////Z2mAAAAAAgAAAAIAAAAAAAAA7gAFKG/+g/vGAAUob/+1KMU= | Bg== (0,2) | 1 | 2 | 2 | Sun Jan 01 09:56:20.048355 2023 PST | Sun Jan 01 09:56:20.048355 2023 PST | BAAAApQ2Uhq14wAClDZSGrXjAAAAAQAAAAEAAAAAAAAADgAFKGykNWvG | Bg== -- after recompressing chunk select numrows_pre_compression, numrows_post_compression from _timescaledb_catalog.compression_chunk_size; numrows_pre_compression | numrows_post_compression -------------------------+-------------------------- 2 | 1 insert into mytab_oneseg values ('2023-01-01 19:56:20.048355+02'::timestamptz, 2, NULL, 2); select chunk_id from compressed_chunk_info_view where hypertable_name = 'mytab_oneseg' \gset -- check we are handling unexpected chunk status (partially compressed but not compressed) update _timescaledb_catalog.chunk set status = 8 where id = :chunk_id; \set ON_ERROR_STOP 0 select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_1'); ERROR: unexpected chunk status 8 in chunk _timescaledb_internal._hyper_1_1_chunk \set ON_ERROR_STOP 1 ---------------- test1: one affected segment, one unaffected -------------- -- unaffected segment will still be recompressed in a future PR we want to avoid doing this create table mytab_twoseg (time timestamptz not null, a int, b int, c int); SELECT create_hypertable('mytab_twoseg', 'time', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (3,public,mytab_twoseg,t) insert into mytab_twoseg values ('2023-01-01 21:56:20.048355+02'::timestamptz, 2, NULL, 2), ('2023-01-01 21:56:20.048355+02'::timestamptz, 3, NULL, 3), --same chunk diff segment ('2023-01-01 21:57:20.048355+02'::timestamptz, 3, NULL, 3); alter table mytab_twoseg set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select show_chunks as chunk_to_compress_2 from show_chunks('mytab_twoseg') limit 1 \gset select compress_chunk(:'chunk_to_compress_2'); INFO: using tuplesort to scan rows from "_hyper_3_3_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_3_chunk -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; numrows_pre_compression | numrows_post_compression | chunk_name | chunk_id -------------------------+--------------------------+----------------------------------------+---------- 3 | 2 | _timescaledb_internal._hyper_3_3_chunk | 3 insert into mytab_twoseg values ('2023-01-01 19:56:20.048355+02'::timestamptz, 2, NULL, 2); select * from :chunk_to_compress_2 ORDER BY a, c, time DESC; time | a | b | c -------------------------------------+---+---+--- Sun Jan 01 11:56:20.048355 2023 PST | 2 | | 2 Sun Jan 01 09:56:20.048355 2023 PST | 2 | | 2 Sun Jan 01 11:57:20.048355 2023 PST | 3 | | 3 Sun Jan 01 11:56:20.048355 2023 PST | 3 | | 3 SELECT compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name_2 from compressed_chunk_info_view where hypertable_name = 'mytab_twoseg' \gset select ctid, * from :compressed_chunk_name_2; ctid | _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b -------+----------------+---+---+-------------------------------------+-------------------------------------+----------------------------------------------------------------------+------ (0,1) | 1 | 2 | 2 | Sun Jan 01 11:56:20.048355 2023 PST | Sun Jan 01 11:56:20.048355 2023 PST | BAAAApQ3/0H94wAClDf/Qf3jAAAAAQAAAAEAAAAAAAAADgAFKG/+g/vG | Bg== (0,2) | 2 | 3 | 3 | Sun Jan 01 11:56:20.048355 2023 PST | Sun Jan 01 11:57:20.048355 2023 PST | BAAAApQ3/0H94//////8bHkAAAAAAgAAAAIAAAAAAAAA7gAFKHAFqwnGAAUocAzSF8U= | Bg== select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_2'); INFO: Using index "compress_hyper_4_4_chunk_a_c__ts_meta_min_1__ts_meta_max_1_idx" for recompression recompress_chunk_segmentwise ---------------------------------------- _timescaledb_internal._hyper_3_3_chunk -- verify that metadata count looks good select ctid, * from :compressed_chunk_name_2; ctid | _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b -------+----------------+---+---+-------------------------------------+-------------------------------------+----------------------------------------------------------------------+------ (0,1) | 1 | 2 | 2 | Sun Jan 01 11:56:20.048355 2023 PST | Sun Jan 01 11:56:20.048355 2023 PST | BAAAApQ3/0H94wAClDf/Qf3jAAAAAQAAAAEAAAAAAAAADgAFKG/+g/vG | Bg== (0,2) | 2 | 3 | 3 | Sun Jan 01 11:56:20.048355 2023 PST | Sun Jan 01 11:57:20.048355 2023 PST | BAAAApQ3/0H94//////8bHkAAAAAAgAAAAIAAAAAAAAA7gAFKHAFqwnGAAUocAzSF8U= | Bg== (0,3) | 1 | 2 | 2 | Sun Jan 01 09:56:20.048355 2023 PST | Sun Jan 01 09:56:20.048355 2023 PST | BAAAApQ2Uhq14wAClDZSGrXjAAAAAQAAAAEAAAAAAAAADgAFKGykNWvG | Bg== -- verify that initial data is returned as expected select * from :chunk_to_compress_2 ORDER BY a, c, time DESC; time | a | b | c -------------------------------------+---+---+--- Sun Jan 01 11:56:20.048355 2023 PST | 2 | | 2 Sun Jan 01 09:56:20.048355 2023 PST | 2 | | 2 Sun Jan 01 11:57:20.048355 2023 PST | 3 | | 3 Sun Jan 01 11:56:20.048355 2023 PST | 3 | | 3 -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; numrows_pre_compression | numrows_post_compression | chunk_name | chunk_id -------------------------+--------------------------+----------------------------------------+---------- 3 | 2 | _timescaledb_internal._hyper_3_3_chunk | 3 ----------------- more than one batch per segment ---------------------- -- test that metadata sequence number is correct create table mytab2(time timestamptz not null, a int, b int, c int); select create_hypertable('mytab2', 'time', chunk_time_interval => interval '1 week'); create_hypertable --------------------- (5,public,mytab2,t) insert into mytab2 (time, a, c) select t,s,s from generate_series('2023-01-01 00:00:00+00'::timestamptz, '2023-01-01 00:00:00+00'::timestamptz + interval '1 day', interval '30 sec') t cross join generate_series(0,2, 1) s; alter table mytab2 set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select compress_chunk(c) from show_chunks('mytab2') c; INFO: using tuplesort to scan rows from "_hyper_5_5_chunk" for converting to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_5_chunk SELECT compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name_2 from compressed_chunk_info_view where hypertable_name = 'mytab2' and compressed_chunk_name is not null limit 1 \gset insert into mytab2 values ('2023-01-01 00:00:02+00'::timestamptz, 0, NULL, 0); -- goes into the uncompressed chunk select show_chunks('mytab2') as chunk_to_compress_2 \gset select ctid, * from :compressed_chunk_name_2; ctid | _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b -------+----------------+---+---+------------------------------+------------------------------+----------------------------------------------------------------------------------+------ (0,1) | 1000 | 0 | 0 | Sun Jan 01 07:40:30 2023 PST | Sun Jan 01 16:00:00 2023 PST | BAAAApQ0bFLXgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKHbNWYAAAAUodtDtBv8AAD5gAAAAAA== | Bg== (0,2) | 1000 | 0 | 0 | Sat Dec 31 23:20:30 2022 PST | Sun Jan 01 07:40:00 2023 PST | BAAAApQtcC8rgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKGjVEigAAAUoaNilrv8AAD5gAAAAAA== | Bg== (0,3) | 881 | 0 | 0 | Sat Dec 31 16:00:00 2022 PST | Sat Dec 31 23:20:00 2022 PST | BAAAApQnSNVgAP/////+NjyAAAADcQAAAAMAAAAAAAAP7gAFKFrcytAAAAUoWuBeVv8AADbwAAAAAA== | Bg== (0,4) | 1000 | 1 | 1 | Sun Jan 01 07:40:30 2023 PST | Sun Jan 01 16:00:00 2023 PST | BAAAApQ0bFLXgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKHbNWYAAAAUodtDtBv8AAD5gAAAAAA== | Bg== (0,5) | 1000 | 1 | 1 | Sat Dec 31 23:20:30 2022 PST | Sun Jan 01 07:40:00 2023 PST | BAAAApQtcC8rgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKGjVEigAAAUoaNilrv8AAD5gAAAAAA== | Bg== (0,6) | 881 | 1 | 1 | Sat Dec 31 16:00:00 2022 PST | Sat Dec 31 23:20:00 2022 PST | BAAAApQnSNVgAP/////+NjyAAAADcQAAAAMAAAAAAAAP7gAFKFrcytAAAAUoWuBeVv8AADbwAAAAAA== | Bg== (0,7) | 1000 | 2 | 2 | Sun Jan 01 07:40:30 2023 PST | Sun Jan 01 16:00:00 2023 PST | BAAAApQ0bFLXgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKHbNWYAAAAUodtDtBv8AAD5gAAAAAA== | Bg== (0,8) | 1000 | 2 | 2 | Sat Dec 31 23:20:30 2022 PST | Sun Jan 01 07:40:00 2023 PST | BAAAApQtcC8rgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKGjVEigAAAUoaNilrv8AAD5gAAAAAA== | Bg== (0,9) | 881 | 2 | 2 | Sat Dec 31 16:00:00 2022 PST | Sat Dec 31 23:20:00 2022 PST | BAAAApQnSNVgAP/////+NjyAAAADcQAAAAMAAAAAAAAP7gAFKFrcytAAAAUoWuBeVv8AADbwAAAAAA== | Bg== -- after compression -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; numrows_pre_compression | numrows_post_compression | chunk_name | chunk_id -------------------------+--------------------------+----------------------------------------+---------- 8643 | 9 | _timescaledb_internal._hyper_5_5_chunk | 5 select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_2'); INFO: Using index "compress_hyper_6_6_chunk_a_c__ts_meta_min_1__ts_meta_max_1_idx" for recompression recompress_chunk_segmentwise ---------------------------------------- _timescaledb_internal._hyper_5_5_chunk select ctid, * from :compressed_chunk_name_2; ctid | _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b --------+----------------+---+---+------------------------------+------------------------------+------------------------------------------------------------------------------------------+------ (0,1) | 1000 | 0 | 0 | Sun Jan 01 07:40:30 2023 PST | Sun Jan 01 16:00:00 2023 PST | BAAAApQ0bFLXgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKHbNWYAAAAUodtDtBv8AAD5gAAAAAA== | Bg== (0,2) | 1000 | 0 | 0 | Sat Dec 31 23:20:30 2022 PST | Sun Jan 01 07:40:00 2023 PST | BAAAApQtcC8rgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKGjVEigAAAUoaNilrv8AAD5gAAAAAA== | Bg== (0,4) | 1000 | 1 | 1 | Sun Jan 01 07:40:30 2023 PST | Sun Jan 01 16:00:00 2023 PST | BAAAApQ0bFLXgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKHbNWYAAAAUodtDtBv8AAD5gAAAAAA== | Bg== (0,5) | 1000 | 1 | 1 | Sat Dec 31 23:20:30 2022 PST | Sun Jan 01 07:40:00 2023 PST | BAAAApQtcC8rgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKGjVEigAAAUoaNilrv8AAD5gAAAAAA== | Bg== (0,6) | 881 | 1 | 1 | Sat Dec 31 16:00:00 2022 PST | Sat Dec 31 23:20:00 2022 PST | BAAAApQnSNVgAP/////+NjyAAAADcQAAAAMAAAAAAAAP7gAFKFrcytAAAAUoWuBeVv8AADbwAAAAAA== | Bg== (0,7) | 1000 | 2 | 2 | Sun Jan 01 07:40:30 2023 PST | Sun Jan 01 16:00:00 2023 PST | BAAAApQ0bFLXgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKHbNWYAAAAUodtDtBv8AAD5gAAAAAA== | Bg== (0,8) | 1000 | 2 | 2 | Sat Dec 31 23:20:30 2022 PST | Sun Jan 01 07:40:00 2023 PST | BAAAApQtcC8rgP/////+NjyAAAAD6AAAAAMAAAAAAAAP7gAFKGjVEigAAAUoaNilrv8AAD5gAAAAAA== | Bg== (0,9) | 881 | 2 | 2 | Sat Dec 31 16:00:00 2022 PST | Sat Dec 31 23:20:00 2022 PST | BAAAApQnSNVgAP/////+NjyAAAADcQAAAAMAAAAAAAAP7gAFKFrcytAAAAUoWuBeVv8AADbwAAAAAA== | Bg== (0,10) | 882 | 0 | 0 | Sat Dec 31 16:00:00 2022 PST | Sat Dec 31 23:20:00 2022 PST | BAAAApQnSNVgAP//////4XuAAAADcgAAAAQAAAAAAADf7gAFKFrcytAAAAUoWuBeVv8AADbgAAAAAAMZdQAAPQkA | Bg== -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; numrows_pre_compression | numrows_post_compression | chunk_name | chunk_id -------------------------+--------------------------+----------------------------------------+---------- 8643 | 9 | _timescaledb_internal._hyper_5_5_chunk | 5 -- failing test from compression_ddl CREATE TABLE test_defaults(time timestamptz NOT NULL, device_id int); SELECT create_hypertable('test_defaults','time'); create_hypertable ---------------------------- (7,public,test_defaults,t) ALTER TABLE test_defaults SET (timescaledb.compress,timescaledb.compress_segmentby='device_id'); -- create 2 chunks INSERT INTO test_defaults SELECT '2000-01-01', 1; INSERT INTO test_defaults SELECT '2001-01-01', 1; SELECT compress_chunk(show_chunks) AS "compressed_chunk" FROM show_chunks('test_defaults') ORDER BY show_chunks::text LIMIT 1 \gset INFO: using tuplesort to scan rows from "_hyper_7_7_chunk" for converting to columnstore -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'compressed_chunk'; numrows_pre_compression | numrows_post_compression | chunk_name | chunk_id -------------------------+--------------------------+----------------------------------------+---------- 1 | 1 | _timescaledb_internal._hyper_7_7_chunk | 7 SELECT * FROM test_defaults ORDER BY 1; time | device_id ------------------------------+----------- Sat Jan 01 00:00:00 2000 PST | 1 Mon Jan 01 00:00:00 2001 PST | 1 ALTER TABLE test_defaults ADD COLUMN c1 int; ALTER TABLE test_defaults ADD COLUMN c2 int NOT NULL DEFAULT 42; SELECT * FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 ------------------------------+-----------+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 Mon Jan 01 00:00:00 2001 PST | 1 | | 42 INSERT INTO test_defaults SELECT '2000-01-01', 2; SELECT * FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 ------------------------------+-----------+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 Sat Jan 01 00:00:00 2000 PST | 2 | | 42 Mon Jan 01 00:00:00 2001 PST | 1 | | 42 SELECT compress_chunk(:'compressed_chunk'); INFO: Using index "compress_hyper_8_9_chunk_device_id__ts_meta_min_1__ts_meta__idx" for recompression compress_chunk ---------------------------------------- _timescaledb_internal._hyper_7_7_chunk SELECT * FROM test_defaults ORDER BY 1,2; time | device_id | c1 | c2 ------------------------------+-----------+----+---- Sat Jan 01 00:00:00 2000 PST | 1 | | 42 Sat Jan 01 00:00:00 2000 PST | 2 | | 42 Mon Jan 01 00:00:00 2001 PST | 1 | | 42 -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'compressed_chunk'; numrows_pre_compression | numrows_post_compression | chunk_name | chunk_id -------------------------+--------------------------+----------------------------------------+---------- 1 | 1 | _timescaledb_internal._hyper_7_7_chunk | 7 -- test prepared statements -- PREPRE A SELECT before recompress and perform it after recompress CREATE TABLE mytab_prep (time timestamptz, a int, b int, c int); SELECT create_hypertable('mytab_prep', 'time'); create_hypertable ------------------------- (9,public,mytab_prep,t) INSERT INTO mytab_prep VALUES ('2023-01-01'::timestamptz, 2, NULL, 2), ('2023-01-01'::timestamptz, 2, NULL, 2); alter table mytab_prep set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); PREPARE p1 AS SELECT * FROM mytab_prep ORDER BY a, c, time DESC; select show_chunks as chunk_to_compress_prep from show_chunks('mytab_prep') limit 1 \gset SELECT compress_chunk(:'chunk_to_compress_prep'); -- the output of the prepared plan would change before and after compress INFO: using tuplesort to scan rows from "_hyper_9_10_chunk" for converting to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_10_chunk INSERT INTO mytab_prep VALUES ('2023-01-01'::timestamptz, 2, 3, 2); VACUUM ANALYZE mytab_prep; -- plan should be invalidated to return results from the uncompressed chunk also set enable_sort to off; /* penalize MergeAppend for predictable plans on PG < 17. */ EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; --- QUERY PLAN --- Sort Sort Key: mytab_prep.a, mytab_prep.c, mytab_prep."time" DESC -> Append -> Custom Scan (ColumnarScan) on _hyper_9_10_chunk -> Seq Scan on compress_hyper_10_11_chunk -> Seq Scan on _hyper_9_10_chunk EXECUTE p1; time | a | b | c ------------------------------+---+---+--- Sun Jan 01 00:00:00 2023 PST | 2 | | 2 Sun Jan 01 00:00:00 2023 PST | 2 | | 2 Sun Jan 01 00:00:00 2023 PST | 2 | 3 | 2 reset enable_sort; -- check plan again after recompression SELECT compress_chunk(:'chunk_to_compress_prep'); INFO: Using index "compress_hyper_10_11_chunk_a_c__ts_meta_min_1__ts_meta_max__idx" for recompression compress_chunk ----------------------------------------- _timescaledb_internal._hyper_9_10_chunk VACUUM ANALYZE mytab_prep; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_9_10_chunk -> Sort Sort Key: compress_hyper_10_11_chunk.a, compress_hyper_10_11_chunk.c, compress_hyper_10_11_chunk._ts_meta_min_1 DESC, compress_hyper_10_11_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_10_11_chunk EXECUTE p1; time | a | b | c ------------------------------+---+---+--- Sun Jan 01 00:00:00 2023 PST | 2 | | 2 Sun Jan 01 00:00:00 2023 PST | 2 | | 2 Sun Jan 01 00:00:00 2023 PST | 2 | 3 | 2 -- verify segmentwise recompression when index exists, decompress + compress otherwise -- we verify by checking the compressed chunk after recompression in both cases. -- in the first case, it is the same before and after -- in the second case, a new compressed chunk is created CREATE TABLE mytab (time timestamptz, a int, b int, c int); SELECT create_hypertable('mytab', 'time'); create_hypertable --------------------- (11,public,mytab,t) INSERT INTO mytab VALUES ('2023-01-01'::timestamptz, 2, NULL, 2), ('2023-01-01'::timestamptz, 2, NULL, 2); select show_chunks as chunk_to_compress_mytab from show_chunks('mytab') limit 1 \gset -- index exists, recompression should happen segment by segment so expect a debug message alter table mytab set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select compress_chunk(show_chunks('mytab')); INFO: using tuplesort to scan rows from "_hyper_11_12_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk select compressed_chunk_name as compressed_chunk_name_before_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset INSERT INTO mytab VALUES ('2023-01-01'::timestamptz, 2, 3, 2); -- segmentwise recompression should not create a new compressed chunk, so verify compressed chunk is the same after recompression SELECT compress_chunk(:'chunk_to_compress_mytab'); INFO: Using index "compress_hyper_12_13_chunk_a_c__ts_meta_min_1__ts_meta_max__idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk select compressed_chunk_name as compressed_chunk_name_after_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset select :'compressed_chunk_name_before_recompression' as before_segmentwise_recompression, :'compressed_chunk_name_after_recompression' as after_segmentwise_recompression; before_segmentwise_recompression | after_segmentwise_recompression ----------------------------------+--------------------------------- compress_hyper_12_13_chunk | compress_hyper_12_13_chunk INSERT INTO mytab SELECT t, a, 3, 2 FROM generate_series('2023-01-01'::timestamptz, '2023-01-02'::timestamptz, '1 hour'::interval) t CROSS JOIN generate_series(1, 10, 1) a; -- recompress will insert newly inserted tuples into compressed chunk along with inserting into the compressed chunk index SELECT compress_chunk(:'chunk_to_compress_mytab'); INFO: Using index "compress_hyper_12_13_chunk_a_c__ts_meta_min_1__ts_meta_max__idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk VACUUM ANALYZE mytab; -- make sure we are hitting the index and that the index contains the tuples SET enable_seqscan TO off; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT count(*) FROM mytab where a = 2; --- QUERY PLAN --- Aggregate -> Custom Scan (ColumnarScan) on _hyper_11_12_chunk -> Index Scan using compress_hyper_12_13_chunk_a_c__ts_meta_min_1__ts_meta_max__idx on compress_hyper_12_13_chunk Index Cond: (a = 2) SELECT count(*) FROM mytab where a = 2; count ------- 28 RESET enable_seqscan; SELECT decompress_chunk(show_chunks('mytab')); decompress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk alter table mytab set (timescaledb.compress = false); alter table mytab set (timescaledb.compress); select compress_chunk(show_chunks('mytab')); INFO: using tuplesort to scan rows from "_hyper_11_12_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk select compressed_chunk_name as compressed_chunk_name_before_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset INSERT INTO mytab VALUES ('2023-01-01'::timestamptz, 2, 3, 2); -- expect to see same chunk after recompression SELECT compress_chunk(:'chunk_to_compress_mytab'); INFO: Using index "compress_hyper_13_14_chunk__ts_meta_min_1__ts_meta_max_1_idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_11_12_chunk select compressed_chunk_name as compressed_chunk_name_after_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset select :'compressed_chunk_name_before_recompression' as before_recompression, :'compressed_chunk_name_after_recompression' as after_recompression; before_recompression | after_recompression ----------------------------+---------------------------- compress_hyper_13_14_chunk | compress_hyper_13_14_chunk -- check behavior with NULL values in segmentby columns select '2022-01-01 09:00:00+00' as start_time \gset create table nullseg_one (time timestamptz, a int, b int); select create_hypertable('nullseg_one', 'time'); create_hypertable --------------------------- (14,public,nullseg_one,t) insert into nullseg_one values (:'start_time', 1, 1), (:'start_time', 1, 2), (:'start_time', 2,2), (:'start_time', 2,3); alter table nullseg_one set (timescaledb.compress, timescaledb.compress_segmentby= 'a'); select compress_chunk(show_chunks('nullseg_one')); INFO: using tuplesort to scan rows from "_hyper_14_15_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_15_chunk insert into nullseg_one values (:'start_time', NULL, 4); select show_chunks as chunk_to_compress from show_chunks('nullseg_one') limit 1 \gset select compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name from compressed_chunk_info_view where hypertable_name = 'nullseg_one' \gset SELECT compress_chunk(:'chunk_to_compress'); INFO: Using index "compress_hyper_15_16_chunk_a__ts_meta_min_1__ts_meta_max_1_idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_15_chunk select * from :compressed_chunk_name; _ts_meta_count | a | _ts_meta_min_1 | _ts_meta_max_1 | time | b ----------------+---+------------------------------+------------------------------+----------------------------------------------------------------------+---------------------------------------------------------- 2 | 1 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAAAAAAAAAAAAgAAAAAAAAABAAAAAgAAAAEAAAAAAAAAAgAAAAAAAAAC 2 | 2 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAAAAAAAAAAAAwAAAAAAAAABAAAAAgAAAAEAAAAAAAAAAwAAAAAAAAAM 1 | | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAABAAAAAAAAAAEAAAAAQAAAAEAAAAAAAAABAAAAAAAAAAI -- insert again, check both index insertion works and NULL values properly handled insert into nullseg_one values (:'start_time', NULL, 4); SELECT compress_chunk(:'chunk_to_compress'); INFO: Using index "compress_hyper_15_16_chunk_a__ts_meta_min_1__ts_meta_max_1_idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_14_15_chunk select * from :compressed_chunk_name; _ts_meta_count | a | _ts_meta_min_1 | _ts_meta_max_1 | time | b ----------------+---+------------------------------+------------------------------+----------------------------------------------------------------------+---------------------------------------------------------- 2 | 1 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAAAAAAAAAAAAgAAAAAAAAABAAAAAgAAAAEAAAAAAAAAAgAAAAAAAAAC 2 | 2 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAAAAAAAAAAAAwAAAAAAAAABAAAAAgAAAAEAAAAAAAAAAwAAAAAAAAAM 2 | | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAAAAAAAAAAABAAAAAAAAAAAAAAAAgAAAAEAAAAAAAAABAAAAAAAAAB4 -- test multiple NULL segmentby columns create table nullseg_many (time timestamptz, a int, b int, c int); select create_hypertable('nullseg_many', 'time'); create_hypertable ---------------------------- (16,public,nullseg_many,t) insert into nullseg_many values (:'start_time', 1, 1, 1), (:'start_time', 1, 2, 2), (:'start_time', 2,2, 2), (:'start_time', 2,3, 3), (:'start_time', 2, NULL, 3); alter table nullseg_many set (timescaledb.compress, timescaledb.compress_segmentby= 'a, c'); select compress_chunk(show_chunks('nullseg_many')); INFO: using tuplesort to scan rows from "_hyper_16_17_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_16_17_chunk -- new segment (1, NULL) insert into nullseg_many values (:'start_time', 1, 4, NULL); select show_chunks as chunk_to_compress from show_chunks('nullseg_many') limit 1 \gset select compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name from compressed_chunk_info_view where hypertable_name = 'nullseg_many' \gset SELECT compress_chunk(:'chunk_to_compress'); INFO: Using index "compress_hyper_17_18_chunk_a_c__ts_meta_min_1__ts_meta_max__idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_16_17_chunk select * from :compressed_chunk_name; _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b ----------------+---+---+------------------------------+------------------------------+----------------------------------------------------------------------+------------------------------------------------------------------------------------------ 1 | 1 | 1 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAAAQAAAAAAAAABAAAAAQAAAAEAAAAAAAAAAgAAAAAAAAAC 1 | 1 | 2 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAAAgAAAAAAAAACAAAAAQAAAAEAAAAAAAAAAwAAAAAAAAAE 1 | 2 | 2 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAAAgAAAAAAAAACAAAAAQAAAAEAAAAAAAAAAwAAAAAAAAAE 2 | 2 | 3 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAEAAAAAAAAAAwAAAAAAAAADAAAAAQAAAAEAAAAAAAAAAwAAAAAAAAAGAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAAC 1 | 1 | | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAABAAAAAAAAAAEAAAAAQAAAAEAAAAAAAAABAAAAAAAAAAI -- insert again, check both index insertion works and NULL values properly handled -- should match existing segment (1, NULL) insert into nullseg_many values (:'start_time', 1, NULL, NULL); SELECT compress_chunk(:'chunk_to_compress'); INFO: Using index "compress_hyper_17_18_chunk_a_c__ts_meta_min_1__ts_meta_max__idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_16_17_chunk select * from :compressed_chunk_name; _ts_meta_count | a | c | _ts_meta_min_1 | _ts_meta_max_1 | time | b ----------------+---+---+------------------------------+------------------------------+----------------------------------------------------------------------+------------------------------------------------------------------------------------------ 1 | 1 | 1 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAAAQAAAAAAAAABAAAAAQAAAAEAAAAAAAAAAgAAAAAAAAAC 1 | 1 | 2 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAAAgAAAAAAAAACAAAAAQAAAAEAAAAAAAAAAwAAAAAAAAAE 1 | 2 | 2 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAACd4BH8kQAAAAAAQAAAAEAAAAAAAAADgAE7wCP5IgA | BAAAAAAAAAAAAgAAAAAAAAACAAAAAQAAAAEAAAAAAAAAAwAAAAAAAAAE 2 | 2 | 3 | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAEAAAAAAAAAAwAAAAAAAAADAAAAAQAAAAEAAAAAAAAAAwAAAAAAAAAGAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAAC 2 | 1 | | Sat Jan 01 01:00:00 2022 PST | Sat Jan 01 01:00:00 2022 PST | BAAAAneAR/JEAAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA7gAE7wCP5IgAAATvAI/kh/8= | BAEAAAAAAAAABAAAAAAAAAAEAAAAAQAAAAEAAAAAAAAABAAAAAAAAAAIAAAAAgAAAAEAAAAAAAAAAQAAAAAAAAAC -- Test behaviour when no segmentby columns are present CREATE TABLE noseg(time timestamptz, a int, b int, c int); SELECT create_hypertable('noseg', by_range('time', INTERVAL '1 day')); create_hypertable ------------------- (18,t) ALTER TABLE noseg set (timescaledb.compress, timescaledb.compress_segmentby = ''); INSERT INTO noseg VALUES ('2025-01-24 09:54:27.323421-07'::timestamptz, 1, 1, 1); SELECT show_chunks as chunk_to_compress FROM show_chunks('noseg') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); INFO: using tuplesort to scan rows from "_hyper_18_19_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_18_19_chunk INSERT INTO noseg VALUES ('2025-01-24 10:54:27.323421-07'::timestamptz, 1, 1, 2); -- should recompress chunk using the default index SELECT compress_chunk(:'chunk_to_compress'); INFO: Using index "compress_hyper_19_20_chunk__ts_meta_min_1__ts_meta_max_1_idx" for recompression compress_chunk ------------------------------------------ _timescaledb_internal._hyper_18_19_chunk -- Test behaviour when default order by is empty: should not segmentwise-recompress in this case CREATE TABLE no_oby(ts int, c1 int); SELECT create_hypertable('no_oby','ts'); create_hypertable ---------------------- (20,public,no_oby,t) \set VERBOSITY default ALTER TABLE no_oby SET (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); \set VERBOSITY terse INSERT INTO no_oby (ts,c1) VALUES (6,6); SELECT show_chunks as chunk_to_compress FROM show_chunks('no_oby') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); INFO: using tuplesort to scan rows from "_hyper_20_21_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_20_21_chunk INSERT INTO no_oby (ts,c1) VALUES (7,7); -- Direct segmentwise-recompress request: throw an error \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); ERROR: segmentwise recompression cannot be applied for compression with no order by \set ON_ERROR_STOP 1 -- Compress wrapper: do full recompress instead of by segment SELECT compress_chunk(:'chunk_to_compress'); NOTICE: segmentwise recompression is disabled due to no order by, performing full recompression on chunk "_timescaledb_internal._hyper_20_21_chunk" INFO: using tuplesort to scan rows from "_hyper_20_21_chunk" for converting to columnstore compress_chunk ------------------------------------------ _timescaledb_internal._hyper_20_21_chunk RESET timescaledb.debug_compression_path_info; --- Test behaviour when enable_segmentwise_recompression GUC if OFF CREATE TABLE guc_test(time timestamptz not null, a int, b int, c int); SELECT create_hypertable('guc_test', by_range('time', INTERVAL '1 day')); create_hypertable ------------------- (22,t) ALTER TABLE guc_test set (timescaledb.compress, timescaledb.compress_segmentby = 'a, b'); INSERT INTO guc_test VALUES ('2024-10-30 14:04:00.501519-06'::timestamptz, 1, 1, 1); SELECT show_chunks as chunk_to_compress FROM show_chunks('guc_test') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_22_24_chunk INSERT INTO guc_test VALUES ('2024-10-30 14:14:00.501519-06'::timestamptz, 1, 1, 2); -- When GUC is OFF, recompress function should throw an error SET timescaledb.enable_segmentwise_recompression TO OFF; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); ERROR: segmentwise recompression functionality disabled, enable it by first setting timescaledb.enable_segmentwise_recompression to on \set ON_ERROR_STOP 1 -- When GUC is OFF, entire chunk should be fully uncompressed and compressed instead SELECT compress_chunk(:'chunk_to_compress'); NOTICE: segmentwise recompression is disabled, performing full recompression on chunk "_timescaledb_internal._hyper_22_24_chunk" compress_chunk ------------------------------------------ _timescaledb_internal._hyper_22_24_chunk RESET timescaledb.enable_segmentwise_recompression; --- Test behaviour of enable_exclusive_locking_recompression GUC CREATE TABLE exclusive_test(time timestamptz not null, a int, b int, c int); SELECT create_hypertable('exclusive_test', by_range('time', INTERVAL '1 day')); create_hypertable ------------------- (24,t) ALTER TABLE guc_test set (timescaledb.compress, timescaledb.compress_segmentby = 'a, b'); INSERT INTO guc_test VALUES ('2024-10-30 14:04:00.501519-06'::timestamptz, 1, 1, 1); SELECT show_chunks as chunk_to_compress FROM show_chunks('guc_test') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); compress_chunk ------------------------------------------ _timescaledb_internal._hyper_22_24_chunk INSERT INTO guc_test VALUES ('2024-10-30 14:14:00.501519-06'::timestamptz, 1, 1, 2); -- Default behavior will try to get exclusive lock at the end of operation -- in order to change the chunk status. Here it will succeed since there -- isn't any concurrent operations. RESET timescaledb.enable_exclusive_locking_recompression; BEGIN; SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); recompress_chunk_segmentwise ------------------------------------------ _timescaledb_internal._hyper_22_24_chunk SELECT c.relname FROM pg_locks l INNER JOIN pg_class c ON c.oid = l.relation WHERE locktype = 'relation' AND mode = 'ExclusiveLock' ORDER BY 1; relname -------------------- _hyper_22_24_chunk ROLLBACK; -- If we enable this GUC, it should get exclusive locks on 3 relations: -- uncompressed chunk table, compressed chunk table, and compressed chunk index. -- This is done so that we keep locking consistency to legacy way of locking. SET timescaledb.enable_exclusive_locking_recompression TO ON; BEGIN; SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); recompress_chunk_segmentwise ------------------------------------------ _timescaledb_internal._hyper_22_24_chunk SELECT c.relname FROM pg_locks l INNER JOIN pg_class c ON c.oid = l.relation WHERE locktype = 'relation' AND mode = 'ExclusiveLock' ORDER BY 1; relname ----------------------------------------------------------------- _hyper_22_24_chunk compress_hyper_23_26_chunk compress_hyper_23_26_chunk_a_b__ts_meta_min_1__ts_meta_max__idx ROLLBACK; RESET timescaledb.enable_exclusive_locking_recompression; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/reorder.out����������������������������������������������������0000664�0000000�0000000�00000150741�15100345067�0021640�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/cluster_test_setup.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE cluster_test(time INTEGER, temp float, location int, value TEXT); SELECT create_hypertable('cluster_test', 'time', chunk_time_interval => 5); create_hypertable --------------------------- (1,public,cluster_test,t) CREATE INDEX on cluster_test (location); CREATE OR REPLACE FUNCTION ensure_scans_work(table_name TEXT, should_output REGCLASS=NULL, seqscan BOOLEAN=FALSE, indexscan BOOLEAN=FALSE, bitmapscan BOOLEAN=FALSE) RETURNS TABLE (a TEXT, b TEXT) LANGUAGE SQL STABLE AS $BODY$ SELECT format($INNER$ SET LOCAL enable_seqscan=%1$s; SET LOCAL enable_indexscan=%2$s; SET LOCAL enable_bitmapscan=%3$s; EXPLAIN (buffers off, costs off) SELECT * FROM %4$I WHERE time=7 $INNER$, seqscan, indexscan, bitmapscan, table_name) as a, format($INNER$ WITH T1 as (SELECT * FROM %1$I WHERE time=7), T2 as (SELECT * FROM %2$I WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL $INNER$, table_name, should_output) as b; $BODY$; CREATE OR REPLACE FUNCTION ensure_scans_work_no_val(table_name TEXT, should_output REGCLASS=NULL, seqscan BOOLEAN=FALSE, indexscan BOOLEAN=FALSE, bitmapscan BOOLEAN=FALSE) RETURNS TABLE (a TEXT, b TEXT) LANGUAGE SQL STABLE AS $BODY$ SELECT format($INNER$ SET LOCAL enable_seqscan=%1$s; SET LOCAL enable_indexscan=%2$s; SET LOCAL enable_bitmapscan=%3$s; EXPLAIN (buffers off, costs off) SELECT * FROM %4$I WHERE time=6 $INNER$, seqscan, indexscan, bitmapscan, table_name) as a, format($INNER$ WITH T1 as (SELECT * FROM %1$I WHERE time=7), T2 as (SELECT * FROM %2$I WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL $INNER$, table_name, should_output) as b; $BODY$; -- Show default indexes SELECT * FROM test.show_indexes('cluster_test'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ---------------------------+------------+------+--------+---------+-----------+------------ cluster_test_location_idx | {location} | | f | f | f | cluster_test_time_idx | {time} | | f | f | f | -- Show clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered ------------+---------------- -- Create two chunks INSERT INTO cluster_test VALUES ( 0, 18.9, 3, 'a'), ( 8, 13.3, 7, 'b'), ( 3, 19.4, 3, 'c'), ( 6, 27.3, 9, 'd'), ( 5, 25.4, 1, 'e'), ( 4, 18.3, 2, 'f'), ( 2, 12.4, 8, 'g'), ( 7, 20.3, 4, repeat('xyzzy', 100000)), -- toasted value ( 9, 11.4, 1, 'h'), ( 1, 23.4, 5, 'i'); CREATE TABLE expected AS SELECT * FROM cluster_test; -- original results to be compared against SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+-----------+-------- (0,1) | 0 | 18.9 | 3 | a | 1 (0,2) | 3 | 19.4 | 3 | c | 1 (0,3) | 4 | 18.3 | 2 | f | 1 (0,4) | 2 | 12.4 | 8 | g | 1 (0,5) | 1 | 23.4 | 5 | i | 1 SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+--------------------------------+-------- (0,1) | 8 | 13.3 | 7 | b | 1 (0,2) | 6 | 27.3 | 9 | d | 1 (0,3) | 5 | 25.4 | 1 | e | 1 (0,4) | 7 | 20.3 | 4 | xyzzyxyzzyxyzzyxyzzyxyzzyxyzzy | 500000 (0,5) | 9 | 11.4 | 1 | h | 1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- Show chunk indexes SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------+------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_1_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | {time} | | f | f | f | SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_2_chunk'); Index | Columns | Expr | Unique | Primary | Exclusion | Tablespace ------------------------------------------------------------------+------------+------+--------+---------+-----------+------------ _timescaledb_internal._hyper_1_2_chunk_cluster_test_location_idx | {location} | | f | f | f | _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | {time} | | f | f | f | \set ON_ERROR_STOP 0 -- cannot reorder a if with no index of the first call SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', verbose => TRUE); ERROR: there is no previously clustered index for table "_hyper_1_2_chunk" \set ON_ERROR_STOP 1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- reorder a chunk directly with an chunk index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', TRUE); INFO: reordering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- reorder a chunk without an index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- reorder a chunk directly with a hypertable index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', 'cluster_test_time_idx', TRUE); INFO: reordering "_timescaledb_internal._hyper_1_2_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; \set ON_ERROR_STOP 0 -- other chunks in the hypertable are still not clustered SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); ERROR: there is no previously clustered index for table "_hyper_1_1_chunk" -- cannot cluster using another chunk's index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx', TRUE); ERROR: "_hyper_1_1_chunk_cluster_test_time_idx" is not a valid clustering index for table "_hyper_1_2_chunk" -- cannot reorder a hypertable SELECT reorder_chunk('cluster_test', 'cluster_test_time_idx', TRUE); ERROR: "cluster_test" is not a chunk -- cannot reorder NULL SELECT reorder_chunk(NULL, verbose => TRUE); ERROR: must provide a valid chunk to cluster -- cannot reorder within a transaction BEGIN; SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', verbose => TRUE); ERROR: reorder cannot run inside a transaction block END; \set ON_ERROR_STOP 1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- reorder puts things in the correct order SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+-----------+-------- (0,1) | 0 | 18.9 | 3 | a | 1 (0,2) | 3 | 19.4 | 3 | c | 1 (0,3) | 4 | 18.3 | 2 | f | 1 (0,4) | 2 | 12.4 | 8 | g | 1 (0,5) | 1 | 23.4 | 5 | i | 1 SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+--------------------------------+-------- (0,1) | 9 | 11.4 | 1 | h | 1 (0,2) | 8 | 13.3 | 7 | b | 1 (0,3) | 7 | 20.3 | 4 | xyzzyxyzzyxyzzyxyzzyxyzzyxyzzy | 500000 (0,4) | 6 | 27.3 | 9 | d | 1 (0,5) | 5 | 25.4 | 1 | e | 1 -- can perform first reorder using a hypertable index (also test non-toast) SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', 'cluster_test_time_idx', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- and this sets the clustered index correctly SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=7 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 7) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 7) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location | substring | substring | length | length ------+------+------+------+----------+----------+-----------+-----------+--------+-------- COMMIT; -- reorder puts things in the correct order SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+-----------+-------- (0,1) | 4 | 18.3 | 2 | f | 1 (0,2) | 3 | 19.4 | 3 | c | 1 (0,3) | 2 | 12.4 | 8 | g | 1 (0,4) | 1 | 23.4 | 5 | i | 1 (0,5) | 0 | 18.9 | 3 | a | 1 SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ctid | time | temp | location | substring | length -------+------+------+----------+--------------------------------+-------- (0,1) | 9 | 11.4 | 1 | h | 1 (0,2) | 8 | 13.3 | 7 | b | 1 (0,3) | 7 | 20.3 | 4 | xyzzyxyzzyxyzzyxyzzyxyzzyxyzzy | 500000 (0,4) | 6 | 27.3 | 9 | d | 1 (0,5) | 5 | 25.4 | 1 | e | 1 -- can still use other index BEGIN; SET LOCAL enable_seqscan=false; SET LOCAL enable_indexscan=true; SET LOCAL enable_bitmapscan=false; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE location < 6; --- QUERY PLAN --- Append -> Index Scan using _hyper_1_1_chunk_cluster_test_location_idx on _hyper_1_1_chunk Index Cond: (location < 6) -> Index Scan using _hyper_1_2_chunk_cluster_test_location_idx on _hyper_1_2_chunk Index Cond: (location < 6) SELECT time, temp, location, substring(value for 30), length(value) FROM cluster_test where location < 6 ORDER BY time; time | temp | location | substring | length ------+------+----------+--------------------------------+-------- 0 | 18.9 | 3 | a | 1 1 | 23.4 | 5 | i | 1 3 | 19.4 | 3 | c | 1 4 | 18.3 | 2 | f | 1 5 | 25.4 | 1 | e | 1 7 | 20.3 | 4 | xyzzyxyzzyxyzzyxyzzyxyzzyxyzzy | 500000 9 | 11.4 | 1 | h | 1 COMMIT; -- drop toast column ALTER TABLE cluster_test DROP COLUMN value; ALTER TABLE expected DROP COLUMN value; BEGIN; SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 6) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- COMMIT; SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 6) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- COMMIT; -- reorder puts things in the correct order SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; ctid | time | temp | location -------+------+------+---------- (0,1) | 4 | 18.3 | 2 (0,2) | 3 | 19.4 | 3 (0,3) | 2 | 12.4 | 8 (0,4) | 1 | 23.4 | 5 (0,5) | 0 | 18.9 | 3 SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ctid | time | temp | location -------+------+------+---------- (0,1) | 9 | 11.4 | 1 (0,2) | 8 | 13.3 | 7 (0,3) | 7 | 20.3 | 4 (0,4) | 6 | 27.3 | 9 (0,5) | 5 | 25.4 | 1 -- force an indexscan SET enable_seqscan=false; SET enable_indexscan=true; SET enable_bitmapscan=false; SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_1_1_chunk" using sequential scan and sort reorder_chunk --------------- BEGIN; SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', seqscan => true) \gexec SET LOCAL enable_seqscan=t; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Seq Scan on _hyper_1_2_chunk Filter: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', indexscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=t; SET LOCAL enable_bitmapscan=f; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Index Scan using _hyper_1_2_chunk_cluster_test_time_idx on _hyper_1_2_chunk Index Cond: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', bitmapscan => true) \gexec SET LOCAL enable_seqscan=f; SET LOCAL enable_indexscan=f; SET LOCAL enable_bitmapscan=t; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE time=6 --- QUERY PLAN --- Bitmap Heap Scan on _hyper_1_2_chunk Recheck Cond: ("time" = 6) -> Bitmap Index Scan on _hyper_1_2_chunk_cluster_test_time_idx Index Cond: ("time" = 6) WITH T1 as (SELECT * FROM cluster_test WHERE time=7), T2 as (SELECT * FROM expected WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL time | time | temp | temp | location | location ------+------+------+------+----------+---------- COMMIT; SET enable_seqscan=Default; SET enable_indexscan=Default; SET enable_bitmapscan=Default; -- reorder puts things in the correct order SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY time; ctid | time | temp | location -------+------+------+---------- (0,5) | 0 | 18.9 | 3 (0,4) | 1 | 23.4 | 5 (0,3) | 2 | 12.4 | 8 (0,2) | 3 | 19.4 | 3 (0,1) | 4 | 18.3 | 2 SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY time; ctid | time | temp | location -------+------+------+---------- (0,5) | 5 | 25.4 | 1 (0,4) | 6 | 27.3 | 9 (0,3) | 7 | 20.3 | 4 (0,2) | 8 | 13.3 | 7 (0,1) | 9 | 11.4 | 1 CREATE TABLE ct2(time INTEGER, val BIGINT); SELECT create_hypertable('ct2', 'time', chunk_time_interval => 5); create_hypertable ------------------- (2,public,ct2,t) INSERT INTO ct2 VALUES (10, 0), ( 2, 12), ( 0, 10), (14, 4), (11, 1), (12, 2), ( 3, 13), ( 1, 11), ( 4, 14), (13, 13); select show_chunks('ct2'); show_chunks ---------------------------------------- _timescaledb_internal._hyper_2_3_chunk _timescaledb_internal._hyper_2_4_chunk -- if we use someone elses index error \set ON_ERROR_STOP 0 SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', 'cluster_test_time_idx', verbose => TRUE); ERROR: "cluster_test_time_idx" is not a valid clustering index for table "_hyper_2_3_chunk" SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', '_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose => TRUE); ERROR: "_hyper_1_2_chunk_cluster_test_time_idx" is not a valid clustering index for table "_hyper_2_3_chunk" \set ON_ERROR_STOP 1 -- if the hypertable has a CLUSTERed index we can use it CLUSTER ct2 USING ct2_time_idx; SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_2_3_chunk" using sequential scan and sort reorder_chunk --------------- -- if we drop a CLUSTERed index we still fail correctly DROP INDEX ct2_time_idx; \set ON_ERROR_STOP 0 SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); ERROR: there is no previously clustered index for table "_hyper_2_3_chunk" \set ON_ERROR_STOP 1 -- but re-create for future tests CREATE INDEX ct2_time_idx ON ct2(time DESC); CLUSTER ct2 USING ct2_time_idx; -- deleted chunks are removed correctly DELETE FROM ct2 where time < 2 OR val < 2; VACUUM ct2; SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); INFO: reordering "_timescaledb_internal._hyper_2_3_chunk" using sequential scan and sort reorder_chunk --------------- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_3_chunk ORDER BY time; ctid | time | val -------+------+----- (0,3) | 12 | 2 (0,2) | 13 | 13 (0,1) | 14 | 4 SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_4_chunk ORDER BY time; ctid | time | val -------+------+----- (0,3) | 2 | 12 (0,2) | 3 | 13 (0,1) | 4 | 14 -- There's a special case when a tuple is deleted, but that deletion isn't committed -- But we disallow reorder within transactions for now, if we enable it, we should -- enable the test -- BEGIN; -- DELETE FROM ct2 where time = 2 OR val = 2; -- SELECT reorder_chunk('_timescaledb_internal._hyper_2_4_chunk', verbose => TRUE); -- COMMIT; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_3_chunk ORDER BY time; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_4_chunk ORDER BY time; -- There's a special case when a tuple is inserted earlier in the same txn -- NOTE: this reorder vaccums the one deleted in the previous test -- But we disallow reorder within transactions for now, if we enable it, we should -- enable the test -- BEGIN; -- INSERT INTO ct2 VALUES (12, 2), ( 2, 12); -- SELECT reorder_chunk('_timescaledb_internal._hyper_2_4_chunk', verbose => TRUE); -- COMMIT; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_3_chunk ORDER BY time; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_4_chunk ORDER BY time; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; indexrelid | indisclustered --------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx | t _timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx | t ct2_time_idx | t _timescaledb_internal._hyper_2_3_chunk_ct2_time_idx | t _timescaledb_internal._hyper_2_4_chunk_ct2_time_idx | t \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); ERROR: must be owner of hypertable "ct2" \set ON_ERROR_STOP 1 -- #3651 incorrect index attribute mapping in reorder_chunk CREATE TABLE i3651(c1 timestamptz NOT NULL,c2 text, c3 text, c4 text); SELECT table_name FROM create_hypertable('i3651','c1'); table_name ------------ i3651 ALTER TABLE i3651 drop column c2; CREATE UNIQUE INDEX i3651_attmap ON i3651(c1,c4); INSERT INTO i3651 VALUES('2000-01-01','foo','foo'),('2000-01-01','foo','bar'); SELECT reorder_chunk(chunk,'i3651_attmap') from show_chunks('i3651') chunk; reorder_chunk --------------- -- test error handling when trying to create on internal hypertable CREATE TABLE comp_ht_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('comp_ht_test','time'); table_name -------------- comp_ht_test ALTER TABLE comp_ht_test SET (timescaledb.compress); SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "INTERNALTABLE" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'comp_ht_test') \gset \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 SELECT add_reorder_policy(:'INTERNALTABLE','internal_idx'); ERROR: cannot add reorder policy to compressed hypertable "_compressed_hypertable_5" \set ON_ERROR_STOP 1 �������������������������������timescaledb-2.23.0/tsl/test/expected/scheduler_fixed.out��������������������������������������������0000664�0000000�0000000�00000025507�15100345067�0023334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup for testing bgw jobs --- -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- follow exactly cagg_bgw_drop_chunks -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job; TRUNCATE _timescaledb_internal.bgw_job_stat; create or replace procedure job_20(jobid int, config jsonb) language plpgsql as $$ begin perform pg_sleep(5); end $$; create or replace procedure job_5(jobid int, config jsonb) language plpgsql as $$ begin perform pg_sleep(1); end $$; select * from _timescaledb_internal.bgw_job_stat; job_id | last_start | last_finish | next_start | last_successful_finish | last_run_success | total_runs | total_duration | total_duration_failures | total_successes | total_failures | total_crashes | consecutive_failures | consecutive_crashes | flags --------+------------+-------------+------------+------------------------+------------------+------------+----------------+-------------------------+-----------------+----------------+---------------+----------------------+---------------------+------- -- add job that has a runtime well under the schedule interval select now() as initial_start \gset select add_job('job_5', schedule_interval => INTERVAL '15 seconds', initial_start => :'initial_start'::timestamptz) as short_job_fixed \gset select add_job('job_5', schedule_interval => INTERVAL '15 seconds', initial_start => :'initial_start'::timestamptz, fixed_schedule => false) as short_job_drifting \gset SELECT _timescaledb_functions.start_background_workers(); start_background_workers -------------------------- t select initial_start as initial_start_given from timescaledb_information.jobs where job_id = :short_job_fixed \gset -- wait for the job to run SELECT test.wait_for_job_to_run(:short_job_fixed, 1); wait_for_job_to_run --------------------- t SELECT test.wait_for_job_to_run(:short_job_drifting, 1); wait_for_job_to_run --------------------- t -- select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(15000); select next_start as next_start_short from timescaledb_information.job_stats where job_id = :short_job_fixed \gset -- verify the next_start is 15 seconds after the initial_start for the fixed schedule job select :'next_start_short'::timestamptz - :'initial_start_given'::timestamptz as schedule_diff; schedule_diff --------------- @ 15 secs -- test job that runs for longer than the schedule interval select add_job('job_20', schedule_interval => INTERVAL '15 seconds', initial_start => now()) as long_job_fixed \gset select test.wait_for_job_to_run(:long_job_fixed, 1); wait_for_job_to_run --------------------- t select initial_start as initial_start_long from timescaledb_information.jobs where job_id = :long_job_fixed \gset select next_start as next_start_long from timescaledb_information.job_stats where job_id = :long_job_fixed \gset select :'next_start_long'::timestamptz - :'initial_start_long'::timestamptz as schedule_diff; schedule_diff --------------- @ 15 secs -- test some possible schedule_interval, finish_time, initial_start combinations SET timezone = 'UTC'; -- want to execute on the 15th of the month select ts_test_next_scheduled_execution_slot('1 month', '2022-09-16 13:21:34+00'::timestamptz, '2022-09-15 19:00:00+00'::timestamptz); ts_test_next_scheduled_execution_slot --------------------------------------- Sat Oct 15 19:00:00 2022 UTC -- ..or the first of the month select ts_test_next_scheduled_execution_slot('1 month', '2022-09-01 19:21:34+00'::timestamptz, '2022-09-01 19:00:00+00'::timestamptz); ts_test_next_scheduled_execution_slot --------------------------------------- Sat Oct 01 19:00:00 2022 UTC -- want to execute on Sundays (2022-09-04 is a Sunday) select extract(dow from date '2022-09-04') = 0; ?column? ---------- t select ts_test_next_scheduled_execution_slot('1 week', '2022-09-22 13:21:34+00'::timestamptz, '2022-09-04 19:00:00+00'::timestamptz); ts_test_next_scheduled_execution_slot --------------------------------------- Sun Sep 25 19:00:00 2022 UTC -- want to execute at 6am every day select ts_test_next_scheduled_execution_slot('1d', '2022-09-21 13:21:34+00'::timestamptz, '2022-09-21 06:00:00+00'::timestamptz); ts_test_next_scheduled_execution_slot --------------------------------------- Thu Sep 22 06:00:00 2022 UTC -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022 select ts_test_next_scheduled_execution_slot('1 week', '2022-03-23 09:21:34 CET'::timestamptz, '2022-03-23 09:00:00 CET'::timestamptz) as t1 \gset select ts_test_next_scheduled_execution_slot('1 week', '2022-03-23 09:21:34 CET'::timestamptz, '2022-03-23 09:00:00 CET'::timestamptz, timezone => 'Europe/Berlin') as t1_tz \gset select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Mar 30 09:00:00 2022 CEST | Wed Mar 30 09:00:00 2022 CEST select ts_test_next_scheduled_execution_slot('1 week', :'t1'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz) as t2 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t1_tz'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Apr 06 09:00:00 2022 CEST | Wed Apr 06 09:00:00 2022 CEST select ts_test_next_scheduled_execution_slot('1 week', :'t2'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz) as t3 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t2_tz'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone -------------------------------+------------------------------- Wed Apr 06 10:00:00 2022 CEST | Wed Apr 13 09:00:00 2022 CEST -- go from +2 to +1 -- DST switch on October 30th 2022 select ts_test_next_scheduled_execution_slot('1 week', '2022-10-29 09:21:34+02'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz) as t1 \gset select ts_test_next_scheduled_execution_slot('1 week', '2022-10-29 09:21:34+02'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz, 'Europe/Berlin') as t1_tz \gset select :'t1' as without_timezone, :'t1_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Nov 05 09:00:00 2022 CET | Sat Nov 05 09:00:00 2022 CET select ts_test_next_scheduled_execution_slot('1 week', :'t1'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz) as t2 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t1_tz'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz, 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Nov 12 08:00:00 2022 CET | Sat Nov 12 09:00:00 2022 CET select ts_test_next_scheduled_execution_slot('1 week', :'t2'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz) as t3 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t2_tz'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz, 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; without_timezone | with_timezone ------------------------------+------------------------------ Sat Nov 19 08:00:00 2022 CET | Sat Nov 19 09:00:00 2022 CET \set ON_ERROR_STOP 0 -- test some unacceptable values for schedule interval select add_job('job_5', schedule_interval => interval '1 month 1week', initial_start => :'initial_start'::timestamptz); ERROR: month intervals cannot have day or time component \set client_min_messages = DEBUG; select '2023-01-02 11:53:19.059771+02'::timestamptz as finish_time \gset -- years select ts_test_next_scheduled_execution_slot('1 year', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Tue Jan 02 10:53:16.059771 2024 CET select ts_test_next_scheduled_execution_slot('2 year', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Thu Jan 02 10:53:16.059771 2025 CET select ts_test_next_scheduled_execution_slot('10 year', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Sun Jan 02 10:53:16.059771 2033 CET -- weeks select ts_test_next_scheduled_execution_slot('1 week', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Mon Jan 09 10:53:16.059771 2023 CET select ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Mon Jan 16 10:53:16.059771 2023 CET select ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Mon Jan 16 10:53:16.059771 2023 CET -- months select ts_test_next_scheduled_execution_slot('10 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Thu Nov 02 10:53:16.059771 2023 CET select ts_test_next_scheduled_execution_slot('10 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec', 'Europe/Athens'); ts_test_next_scheduled_execution_slot --------------------------------------- Thu Nov 02 10:53:16.059771 2023 CET select ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); ts_test_next_scheduled_execution_slot --------------------------------------- Thu Mar 02 10:53:16.059771 2023 CET select ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec', 'Europe/Athens'); ts_test_next_scheduled_execution_slot --------------------------------------- Thu Mar 02 10:53:16.059771 2023 CET �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/size_utils_tsl.out���������������������������������������������0000664�0000000�0000000�00000010370�15100345067�0023243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; -- Prepare test data for continuous aggregate size function tests CREATE TABLE hypersize(time timestamptz, device int); SELECT * FROM create_hypertable('hypersize', 'time'); hypertable_id | schema_name | table_name | created ---------------+-------------+------------+--------- 1 | public | hypersize | t INSERT INTO hypersize VALUES('2021-02-25', 1); -- Test size functions on empty continuous aggregate CREATE MATERIALIZED VIEW hypersize_cagg WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', "time") AS bucket, AVG(device) AS value FROM hypersize GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', h.schema_name, h.table_name) AS "MAT_HYPERTABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'hypersize_cagg' \gset SELECT * FROM hypertable_size(:'MAT_HYPERTABLE_NAME'); hypertable_size ----------------- 16384 SELECT * FROM hypertable_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 0 | 8192 | 8192 | 16384 | SELECT * FROM chunks_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM hypertable_size('hypersize_cagg'); hypertable_size ----------------- 16384 SELECT * FROM hypertable_detailed_size('hypersize_cagg') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 0 | 8192 | 8192 | 16384 | SELECT * FROM chunks_detailed_size('hypersize_cagg') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name --------------+------------+-------------+-------------+-------------+-------------+----------- SELECT * FROM approximate_row_count('hypersize_cagg'); approximate_row_count ----------------------- 0 -- Test size functions on non-empty countinuous aggregate CALL refresh_continuous_aggregate('hypersize_cagg', NULL, NULL); SELECT * FROM hypertable_size('hypersize_cagg'); hypertable_size ----------------- 49152 SELECT * FROM hypertable_detailed_size('hypersize_cagg') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 8192 | 24576 | 16384 | 49152 | SELECT * FROM chunks_detailed_size('hypersize_cagg') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_2_2_chunk | 8192 | 16384 | 8192 | 32768 | SELECT * FROM hypertable_size(:'MAT_HYPERTABLE_NAME'); hypertable_size ----------------- 49152 SELECT * FROM hypertable_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; table_bytes | index_bytes | toast_bytes | total_bytes | node_name -------------+-------------+-------------+-------------+----------- 8192 | 24576 | 16384 | 49152 | SELECT * FROM chunks_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; chunk_schema | chunk_name | table_bytes | index_bytes | toast_bytes | total_bytes | node_name -----------------------+------------------+-------------+-------------+-------------+-------------+----------- _timescaledb_internal | _hyper_2_2_chunk | 8192 | 16384 | 8192 | 32768 | ANALYZE :MAT_HYPERTABLE_NAME; SELECT * FROM approximate_row_count('hypersize_cagg'); approximate_row_count ----------------------- 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/skip_scan.out��������������������������������������������������0000664�0000000�0000000�00000614742�15100345067�0022156�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to adjust statistics in load script \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME skip_scan SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_multi_load.sql', :'TEST_BASE_NAME') AS "TEST_MULTI_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNOPTIMIZED", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- run tests on normal table and diff results \set TABLE skip_scan \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on skip_scan_dev_idx(dev NOT NULL) RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; \qecho ordered append on :TABLE :PREFIX SELECT * FROM :TABLE ORDER BY time; :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; \o SET timescaledb.enable_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; \qecho ordered append on :TABLE :PREFIX SELECT * FROM :TABLE ORDER BY time; :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; \o RESET timescaledb.enable_skipscan; -- compare SkipScan results on normal table :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_skipscan ----------------- - off + on dev -- run tests on hypertable and diff results \set TABLE skip_scan_ht \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_1_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_2_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_3_chunk_skip_scan_ht_dev_idx(dev NOT NULL) psql:include/skip_scan_query.sql:74: INFO: SkipScan used on _hyper_1_4_chunk_skip_scan_ht_dev_idx(dev NOT NULL) RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; \qecho ordered append on :TABLE :PREFIX SELECT * FROM :TABLE ORDER BY time; :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; \o SET timescaledb.enable_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; \qecho ordered append on :TABLE :PREFIX SELECT * FROM :TABLE ORDER BY time; :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; \o RESET timescaledb.enable_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_skipscan ----------------- - off + on dev -- run tests on compressed hypertable with different compression settings and diff results SELECT format('include/%s_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htc \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on compressed hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_compressed_skipscan ---------------------------- - off + on compress_chunk -- run tests on compressed hypertable with different layouts of compressed chunks SELECT format('include/%s_load_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htcl \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; \qecho range queries on :TABLE set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; RESET max_parallel_workers_per_gather; RESET enable_seqscan; \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; \qecho range queries on :TABLE set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; RESET max_parallel_workers_per_gather; RESET enable_seqscan; \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on compressed hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_compressed_skipscan ---------------------------- - off + on dev -- run tests on compressed hypertable with different layouts of compressed chunks SELECT format('include/%s_multi_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset -- run multikey SkipScan tests \ir :TEST_MULTI_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Create tables with 4 not-null index columns (ASC, DESC, ASC, ASC) to test various multikey SkipScan scenarios -- Not-null scenarios are tested separately in skip_scan_notnull.sql, here we are testing multi-keys specifically CREATE TABLE mskip_scan(time int not null, status int not null, region text not null, dev int not null, dev_name text not null, val int); -- Status: (1,2), region: (reg1..reg4), dev: (1..5), dev_name same as dev, 4000 timestamps divided into 4 chunks tied to status, 80K rows total -- We want to test both (1 distinct, N distinct) and (N distinct, 1 distinct) scenarios, -- (status,*) where time<100 will do for the former, (dev, dev_name) will do for the latter INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(0, 999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(1000, 1999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(2000, 2999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(3000, 3999) t, generate_series(1, 4) r, generate_series(1, 5) d; CREATE INDEX on mskip_scan(status, region, dev, dev_name); -- To test reverse column orders CREATE INDEX on mskip_scan(status, region DESC, dev); ANALYZE mskip_scan; -- Same with a hypertable CREATE TABLE mskip_scan_ht(time int not null, status int not null, region text not null, dev int not null, dev_name text not null, val int); SELECT create_hypertable('mskip_scan_ht', 'time', chunk_time_interval => 1000, create_default_indexes => false); create_hypertable ---------------------------- (7,public,mskip_scan_ht,t) INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(0, 999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(1000, 1999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(2000, 2999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(3000, 3999) t, generate_series(1, 4) r, generate_series(1, 5) d; CREATE INDEX on mskip_scan_ht(status, region, dev, dev_name); -- To test reverse column orders CREATE INDEX on mskip_scan_ht(status, region DESC, dev); ANALYZE mskip_scan_ht; -- Same with columnar CREATE TABLE mskip_scan_htc(time int not null, status int not null, region text not null, dev int not null, dev_name text not null, val int); SELECT create_hypertable('mskip_scan_htc', 'time', chunk_time_interval => 1000, create_default_indexes => false); create_hypertable ----------------------------- (8,public,mskip_scan_htc,t) -- Cannot have reverse orders on segmented columns in columnar index, so it won't be tested for columnar table ALTER TABLE mskip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='status,region,dev,dev_name'); INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(0, 999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(1000, 1999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(2000, 2999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(3000, 3999) t, generate_series(1, 4) r, generate_series(1, 5) d; SELECT compress_chunk(ch) FROM show_chunks('mskip_scan_htc') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_8_69_chunk _timescaledb_internal._hyper_8_70_chunk _timescaledb_internal._hyper_8_71_chunk _timescaledb_internal._hyper_8_72_chunk ANALYZE mskip_scan_htc; alter table mskip_scan set (autovacuum_enabled = off); alter table mskip_scan_ht set (autovacuum_enabled = off); alter table mskip_scan_htc set (autovacuum_enabled = off); \set PREFIX '' -- make sure multikey SkipScan results are correct \set TABLE mskip_scan \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o SET timescaledb.enable_multikey_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o RESET timescaledb.enable_multikey_skipscan; -- compare SkipScan results on table :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_multikey_skipscan -------------------------- - off + on time | status | region | dev | dev_name | val \set TABLE mskip_scan_ht \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o SET timescaledb.enable_multikey_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o RESET timescaledb.enable_multikey_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_multikey_skipscan -------------------------- - off + on time | status | region | dev | dev_name | val \set TABLE mskip_scan_htc \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o SET timescaledb.enable_multikey_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o RESET timescaledb.enable_multikey_skipscan; -- compare SkipScan results on compressed hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_multikey_skipscan -------------------------- - off + on time | status | region | dev | dev_name | val -- make sure multikey SkipScan is applied correctly SET timescaledb.debug_skip_scan_info TO true; \set TABLE mskip_scan \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; psql:include/skip_scan_multi_query.sql:13: INFO: SkipScan used on mskip_scan_status_region_dev_idx(status NOT NULL, region NOT NULL, dev NOT NULL) :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; psql:include/skip_scan_multi_query.sql:14: INFO: SkipScan used on mskip_scan_status_region_dev_idx(region NOT NULL, dev NOT NULL) set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; psql:include/skip_scan_multi_query.sql:18: INFO: SkipScan used on mskip_scan_status_region_dev_idx(status NOT NULL, dev NOT NULL) -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(dev NOT NULL, dev_name NOT NULL) -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); psql:include/skip_scan_multi_query.sql:47: INFO: SkipScan used on mskip_scan_status_region_dev_idx(status NOT NULL, dev NOT NULL) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; psql:include/skip_scan_multi_query.sql:51: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on mskip_scan_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o \set TABLE mskip_scan_ht \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; psql:include/skip_scan_multi_query.sql:13: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:13: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:13: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:13: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, region NOT NULL, dev NOT NULL) :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; psql:include/skip_scan_multi_query.sql:14: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:14: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:14: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:14: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_idx(region NOT NULL, dev NOT NULL) set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; psql:include/skip_scan_multi_query.sql:18: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, dev NOT NULL) -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(dev NOT NULL, dev_name NOT NULL) -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); psql:include/skip_scan_multi_query.sql:47: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:47: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:47: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:47: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_idx(status NOT NULL, dev NOT NULL) -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; psql:include/skip_scan_multi_query.sql:51: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:51: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:51: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:51: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on _hyper_7_65_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on _hyper_7_66_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on _hyper_7_67_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on _hyper_7_68_chunk_mskip_scan_ht_status_region_dev_dev_name_idx(status NOT NULL, region NOT NULL, dev NOT NULL) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o \set TABLE mskip_scan_htc \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:9: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:10: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; psql:include/skip_scan_multi_query.sql:18: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, dev NOT NULL) -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:21: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(dev NOT NULL, dev_name NOT NULL) -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:24: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, dev NOT NULL, dev_name NOT NULL) reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:28: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:31: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:32: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:33: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:34: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:37: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:40: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:41: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:44: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:54: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:64: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:69: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL) -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) psql:include/skip_scan_multi_query.sql:73: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(region NOT NULL, dev NOT NULL, dev_name NOT NULL) :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:86: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:91: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on compress_hyper_9_73_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on compress_hyper_9_74_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on compress_hyper_9_75_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) psql:include/skip_scan_multi_query.sql:96: INFO: SkipScan used on compress_hyper_9_76_chunk_status_region_dev_dev_name__ts_me_idx(status NOT NULL, region NOT NULL, dev NOT NULL) SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); \o RESET timescaledb.debug_skip_scan_info; ������������������������������timescaledb-2.23.0/tsl/test/expected/skip_scan_dagg.out���������������������������������������������0000664�0000000�0000000�00000315314�15100345067�0023131�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to adjust statistics in load script \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME skip_scan SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_dagg_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_dagg_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNOPTIMIZED", format('%s/results/%s_dagg_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable --------------------------- (1,public,skip_scan_ht,t) INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ---------------------------- (3,public,skip_scan_htc,t) ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); create_hypertable ----------------------------- (5,public,skip_scan_htcl,t) ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_5_9_chunk ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk _timescaledb_internal._hyper_5_12_chunk _timescaledb_internal._hyper_5_11_chunk ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); -- run tests on normal table and diff results \set TABLE skip_scan \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; \qecho ordered append on :TABLE :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; \o SET timescaledb.enable_skipscan_for_distinct_aggregates TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; \qecho ordered append on :TABLE :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; \o RESET timescaledb.enable_skipscan_for_distinct_aggregates; -- compare SkipScan results on normal table :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_dagg_skipscan ---------------------- - off + on count -- run tests on hypertable and diff results \set TABLE skip_scan_ht \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; \qecho ordered append on :TABLE :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; \o SET timescaledb.enable_skipscan_for_distinct_aggregates TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; \qecho ordered append on :TABLE :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; \o RESET timescaledb.enable_skipscan_for_distinct_aggregates; -- compare SkipScan results on hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_dagg_skipscan ---------------------- - off + on count -- run tests on compressed hypertable and diff results SELECT format('include/%s_dagg_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htc \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_compressed_skipscan ---------------------------- - off + on compress_chunk -- run tests on compressed hypertable with different layouts of compressed chunks SELECT format('include/%s_dagg_load_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htcl \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; RESET max_parallel_workers_per_gather; RESET enable_seqscan; \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; RESET max_parallel_workers_per_gather; RESET enable_seqscan; \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD --- Unoptimized results +++ Optimized results @@ -1,6 +1,6 @@ enable_compressed_skipscan ---------------------------- - off + on count ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/split_chunk.out������������������������������������������������0000664�0000000�0000000�00000200600�15100345067�0022507�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; set role :ROLE_DEFAULT_PERM_USER; -- Test utility wrapper around split_chunk() to validate the split. It -- automatically performs some basic checks to validate that the split -- is OK. create or replace procedure split_chunk_validate(chunk regclass, split_at timestamptz = null) as $$ declare chunk_stats_before _timescaledb_catalog.compression_chunk_size; uncompressed_heap_size_sum bigint; compressed_heap_size_sum bigint; hypertable regclass; new_chunk regclass; children regclass[]; stats_are_equal boolean; count_before bigint; count_after1 bigint; count_after2 bigint; chunk_reltuples float8; new_chunk_reltuples float8; begin -- Get the chunk size stats if compressed or it will be null select * into chunk_stats_before from _timescaledb_catalog.compression_chunk_size ccs join _timescaledb_catalog.chunk c on (c.id = ccs.chunk_id) join pg_class cl on (cl.relname = c.table_name) join pg_namespace ns on (ns.oid = cl.relnamespace and c.schema_name = ns.nspname) where cl.oid = chunk; -- Compare chunk children before and after split to get new chunk select inhparent into hypertable from pg_inherits where inhrelid = chunk; select array_agg(inhrelid) into children from pg_inherits where inhparent = hypertable; execute format('select count(*) from %s ch', chunk) into count_before; call split_chunk(chunk, split_at); with arr_diff as ( select inhrelid as rel from pg_inherits where inhparent = hypertable except select unnest(children) ) select rel into new_chunk from arr_diff; -- Add up the counts for the two result chunks. Would normally do -- a UNION ALL query across the two chunks but it doesn't work for -- compressed chunks. execute format('select count(*) from %s ch', chunk) into count_after1; execute format('select count(*) from %s ch', new_chunk) into count_after2; if count_before != (count_after1 + count_after2) then raise exception 'count before split is different from count after: % vs % (% + %)', count_before, count_after1 + count_after2, count_after1, count_after2; end if; execute format('select reltuples from pg_class where oid=%s', chunk::oid) into chunk_reltuples; execute format('select reltuples from pg_class where oid=%s', new_chunk::oid) into new_chunk_reltuples; raise notice 'chunks after split are % (reltuples %) and % (reltuples %)', chunk, chunk_reltuples, new_chunk, new_chunk_reltuples; if chunk_stats_before is not null then select sum(uncompressed_heap_size), sum(compressed_heap_size) into uncompressed_heap_size_sum, compressed_heap_size_sum from _timescaledb_catalog.compression_chunk_size ccs join _timescaledb_catalog.chunk c on (c.id = ccs.chunk_id) join pg_class cl on (cl.relname = c.table_name) where cl.oid in (chunk, new_chunk); if chunk_stats_before.uncompressed_heap_size = uncompressed_heap_size_sum and chunk_stats_before.compressed_heap_size = compressed_heap_size_sum then raise notice 'compression size stats are OK'; else raise exception 'compression size stats are different after split: ' 'uncompressed size % vs % and compressed size % vs %', chunk_stats_before.uncompressed_heap_size, uncompressed_heap_size_sum, chunk_stats_before.compressed_heap_size, compressed_heap_size_sum; end if; end if; end; $$ language plpgsql; create view chunk_slices as select h.table_name as hypertable_name, c.table_name as chunk_name, _timescaledb_functions.to_timestamp(ds.range_start) as range_start, _timescaledb_functions.to_timestamp(ds.range_end) as range_end from _timescaledb_catalog.chunk c join _timescaledb_catalog.chunk_constraint cc on (cc.chunk_id = c.id) join _timescaledb_catalog.dimension_slice ds on (ds.id = cc.dimension_slice_id) join _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) order by range_start, range_end; create table splitme (time timestamptz not null, device int, location int, temp float, comment text); select create_hypertable('splitme', 'time', chunk_time_interval => interval '1 week', create_default_indexes => false); create_hypertable ---------------------- (1,public,splitme,t) alter table splitme set (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='device'); -- Create information view for test create view chunk_info as select relname as chunk, amname as tam, reltuples, con.conname, pg_get_expr(conbin, ch) checkconstraint from pg_class cl join pg_am am on (cl.relam = am.oid) join show_chunks('splitme') ch on (cl.oid = ch) join pg_constraint con on (con.conrelid = ch) where con.contype = 'c' order by 1,2,3 desc; -- -- Insert data to create two chunks with time ranges like this: -- _____________ -- | | | -- | 1 | 2 | -- |_____|_____| --- --- Make sure we have a long text value to create toast table insert into splitme values ('2024-01-03 22:00', 1, 1, 1.0, 'foo'), ('2024-01-09 15:00', 1, 2, 2.0, 'barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar'); -- Remove a column to ensure that split can handle it alter table splitme drop column location; -- All data in single chunk select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST select time, device, temp from _timescaledb_internal._hyper_1_1_chunk order by time; time | device | temp ------------------------------+--------+------ Wed Jan 03 22:00:00 2024 PST | 1 | 1 Tue Jan 09 15:00:00 2024 PST | 1 | 2 select * from chunk_slices where hypertable_name = 'splitme'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+------------------------------+------------------------------ splitme | _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST \set ON_ERROR_STOP 0 call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 1); ERROR: invalid type 'integer' for split_at argument call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 1::int); ERROR: invalid type 'integer' for split_at argument call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => '2024-01-04 00:00'::timestamp); ERROR: invalid type 'timestamp without time zone' for split_at argument -- Split at start of chunk range call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 'Wed Jan 03 16:00:00 2024 PST'); ERROR: cannot split chunk at Wed Jan 03 16:00:00 2024 PST -- Split at end of chunk range call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 'Wed Jan 10 16:00:00 2024 PST'); ERROR: cannot split chunk at Wed Jan 10 16:00:00 2024 PST -- Split at multiple points. Not supported yet. call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => '{ 2024-01-04 10:00, 2024-01-07 12:00 }'::timestamptz[]); ERROR: invalid type 'timestamp with time zone[]' for split_at argument -- Try to split something which is not a chunk call split_chunk('splitme'); ERROR: chunk not found -- Split a chunk with unsupported access method alter table _timescaledb_internal._hyper_1_1_chunk set access method testam; call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); ERROR: access method "testam" is not supported for split alter table _timescaledb_internal._hyper_1_1_chunk set access method heap; -- Split an OSM chunk is not supported reset role; update _timescaledb_catalog.chunk ch set osm_chunk = true where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); ERROR: cannot split OSM chunks reset role; update _timescaledb_catalog.chunk ch set osm_chunk = false where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; -- Split a frozen chunk is not supported select _timescaledb_functions.freeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); freeze_chunk -------------- t call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); ERROR: cannot split frozen chunk "_timescaledb_internal._hyper_1_1_chunk" scheduled for tiering select _timescaledb_functions.unfreeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); unfreeze_chunk ---------------- t -- Split by non-owner is not allowed set role :ROLE_1; call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); ERROR: must be owner of table _hyper_1_1_chunk set role :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+--------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | -1 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) call split_chunk_validate('_timescaledb_internal._hyper_1_1_chunk', split_at => '2024-01-04 00:00'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_1_chunk (reltuples 1) and _timescaledb_internal._hyper_1_2_chunk (reltuples 1) select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+--------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | 1 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 1 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST select * from chunk_slices where hypertable_name = 'splitme'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+------------------------------+------------------------------ splitme | _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST splitme | _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST -- Show that the two tuples ended up in different chunks select time, device, temp from _timescaledb_internal._hyper_1_1_chunk order by time; time | device | temp ------------------------------+--------+------ Wed Jan 03 22:00:00 2024 PST | 1 | 1 select time, device, temp from _timescaledb_internal._hyper_1_2_chunk order by time; time | device | temp ------------------------------+--------+------ Tue Jan 09 15:00:00 2024 PST | 1 | 2 select setseed(0.2); setseed --------- -- Test split with bigger data set and chunks with more blocks insert into splitme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-03 23:00'::timestamptz, '2024-01-09 01:00:00 PST', '10s') t; select count(*) from splitme; count ------- 43923 -- Add back location just to make things more difficult alter table splitme add column location int default 1; -- Update stats vacuum analyze splitme; -- There are two space partitions (device), so several chunks will -- have the same time ranges select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST -- Split chunk 2. Save count to compare after split. select count(*) from _timescaledb_internal._hyper_1_2_chunk; count ------- 43562 select count(*) orig_count from _timescaledb_internal._hyper_1_2_chunk \gset -- Generate some garbage so that we can see that it gets cleaned up -- during split update _timescaledb_internal._hyper_1_2_chunk set temp = temp+1 where temp > 10; -- Add an index create index on splitme (time); -- Generate a garbage tuple insert into _timescaledb_internal._hyper_1_2_chunk (time, device, location, temp) values ('2024-01-04 23:00', 1, 1, 1.12); delete from _timescaledb_internal._hyper_1_2_chunk where time = '2024-01-04 23:00' and device = 1 and location = 1; -- This will split in two equal size chunks select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+--------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | 361 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 43562 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) call split_chunk_validate('_timescaledb_internal._hyper_1_2_chunk'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_2_chunk (reltuples 28800) and _timescaledb_internal._hyper_1_3_chunk (reltuples 14762) select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+--------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | 361 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 28800 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 14762 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; chunk_name | range_start | range_end ------------------+------------------------------+------------------------------ _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Sun Jan 07 08:00:00 2024 PST _hyper_1_3_chunk | Sun Jan 07 08:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST -- Check that the counts in the two result partitions is the same as -- in the original partition and that the tuple counts are roughly the -- same across the partitions. with counts as ( select (select count(*) from _timescaledb_internal._hyper_1_2_chunk) count1, (select count(*) from _timescaledb_internal._hyper_1_3_chunk) count2 ) select c.count1, c.count2, c.count1 + c.count2 as total_count, (c.count1 + c.count2) = :orig_count as is_same_count from counts c; count1 | count2 | total_count | is_same_count --------+--------+-------------+--------------- 28800 | 14762 | 43562 | t -- Check that both rels return proper data and no columns are messed -- up select time, device, location, temp from _timescaledb_internal._hyper_1_2_chunk order by time, device limit 3; time | device | location | temp ------------------------------+--------+----------+------------------ Thu Jan 04 00:00:00 2024 PST | 2 | 1 | 25.6730424335366 Thu Jan 04 00:00:10 2024 PST | 6 | 1 | 15.0341761730165 Thu Jan 04 00:00:20 2024 PST | 6 | 1 | 27.5663547962209 select time, device, location, temp from _timescaledb_internal._hyper_1_3_chunk order by time, device limit 3; time | device | location | temp ------------------------------+--------+----------+------------------ Sun Jan 07 08:00:00 2024 PST | 10 | 1 | 4.03503358112434 Sun Jan 07 08:00:10 2024 PST | 8 | 1 | 17.726969596003 Sun Jan 07 08:00:20 2024 PST | 6 | 1 | 9.63191118430237 -- -- Test split with integer time -- create table splitme_int (time int not null, device int, temp float); select create_hypertable('splitme_int', 'time', chunk_time_interval => 10::int); create_hypertable -------------------------- (3,public,splitme_int,t) insert into splitme_int values (1, 1, 1.0), (8, 8, 8.0); select ch as int_chunk from show_chunks('splitme_int') ch order by ch limit 1 \gset select * from chunk_slices where hypertable_name = 'splitme_int'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+------------------------------+------------------------------------ splitme_int | _hyper_3_4_chunk | Wed Dec 31 16:00:00 1969 PST | Wed Dec 31 16:00:00.00001 1969 PST \set ON_ERROR_STOP 0 call split_chunk(:'int_chunk', split_at => 0); ERROR: cannot split chunk at 0 call split_chunk(:'int_chunk', split_at => 10); ERROR: cannot split chunk at 10 \set ON_ERROR_STOP 1 call split_chunk(:'int_chunk', split_at => '5'); select * from chunk_slices where hypertable_name = 'splitme_int'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+-------------------------------------+------------------------------------- splitme_int | _hyper_3_4_chunk | Wed Dec 31 16:00:00 1969 PST | Wed Dec 31 16:00:00.000005 1969 PST splitme_int | _hyper_3_5_chunk | Wed Dec 31 16:00:00.000005 1969 PST | Wed Dec 31 16:00:00.00001 1969 PST select * from :int_chunk order by time; time | device | temp ------+--------+------ 1 | 1 | 1 select * from splitme_int order by time; time | device | temp ------+--------+------ 1 | 1 | 1 8 | 8 | 8 -- Split with one empty chunk call split_chunk(:'int_chunk', split_at => 3); select * from chunk_slices where hypertable_name = 'splitme_int'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+-------------------------------------+------------------------------------- splitme_int | _hyper_3_4_chunk | Wed Dec 31 16:00:00 1969 PST | Wed Dec 31 16:00:00.000003 1969 PST splitme_int | _hyper_3_6_chunk | Wed Dec 31 16:00:00.000003 1969 PST | Wed Dec 31 16:00:00.000005 1969 PST splitme_int | _hyper_3_5_chunk | Wed Dec 31 16:00:00.000005 1969 PST | Wed Dec 31 16:00:00.00001 1969 PST select * from :int_chunk order by time; time | device | temp ------+--------+------ 1 | 1 | 1 select ch as int_chunk from show_chunks('splitme_int') ch order by ch limit 1 offset 2 \gset \echo :int_chunk _timescaledb_internal._hyper_3_6_chunk select * from :int_chunk order by time; time | device | temp ------+--------+------ -- Insert data into the empty chunk insert into splitme_int values (4, 4, 4.0); select * from :int_chunk order by time; time | device | temp ------+--------+------ 4 | 4 | 4 -- -- Try with more data after split -- -- Remove comment column to generate dropped column alter table splitme drop column comment; select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+--------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | 361 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 28800 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 14762 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) \c :TEST_DBNAME :ROLE_SUPERUSER set role :ROLE_DEFAULT_PERM_USER; select setseed(0.2); setseed --------- select * from chunk_slices where hypertable_name = 'splitme'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+------------------------------+------------------------------ splitme | _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST splitme | _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Sun Jan 07 08:00:00 2024 PST splitme | _hyper_1_3_chunk | Sun Jan 07 08:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST insert into splitme (time, device, location, temp) select t, ceil(random()*10), ceil(random()*20), random()*40 from generate_series('2024-01-03'::timestamptz, '2024-01-09 01:00:00 PST', '10s') t; -- Make sure stats are up-to-date before split vacuum analyze splitme; select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | 3241 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 57600 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 29523 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_7_chunk | heap | 5760 | constraint_11 | (("time" >= 'Wed Dec 27 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone)) call split_chunk_validate('_timescaledb_internal._hyper_1_2_chunk'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_2_chunk (reltuples 28800) and _timescaledb_internal._hyper_1_8_chunk (reltuples 28800) select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint ------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_1_chunk | heap | 3241 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 28800 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 29523 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_7_chunk | heap | 5760 | constraint_11 | (("time" >= 'Wed Dec 27 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_8_chunk | heap | 28800 | constraint_13 | (("time" >= 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) -- -- Test multi-dimensional hypertable -- -- Currently not supported because the subspace cache cannot handle -- tuple routing when there are two overlapping primary dimension -- ranges. This can happen when the "time" range is split in one space -- partition but not the other. -- create table splitme_md (time timestamptz not null, device int, location int, temp float); select create_hypertable('splitme_md', 'time', 'device', 2, chunk_time_interval => interval '1 week'); create_hypertable ------------------------- (4,public,splitme_md,t) insert into splitme_md values ('2024-01-03 22:00', 1, 1, 1.0), ('2024-01-09 14:00', 1, 2, 2.0); select ch as chunk_md from show_chunks('splitme_md') ch limit 1 \gset select * from chunk_slices where hypertable_name = 'splitme_md'; hypertable_name | chunk_name | range_start | range_end -----------------+------------------+------------------------------+------------------------------------- splitme_md | _hyper_4_9_chunk | -infinity | Wed Dec 31 16:17:53.741823 1969 PST splitme_md | _hyper_4_9_chunk | Wed Jan 03 16:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST \set ON_ERROR_STOP 0 -- Currently can't split multi-dimensional chunks due to bug/limitation in subspace store. call split_chunk_validate(:'chunk_md'); ERROR: cannot split chunk in multi-dimensional hypertable \set ON_ERROR_STOP 1 -- Split when insert in progress begin; insert into splitme values ('2024-01-04 22:00', 20, 20, 20.0); call split_chunk_validate('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_1_chunk (reltuples 1440) and _timescaledb_internal._hyper_1_10_chunk (reltuples 1801) rollback; -- Split when delete in progress begin; delete from splitme where device = 1; call split_chunk_validate('_timescaledb_internal._hyper_1_1_chunk'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_1_chunk (reltuples 1440) and _timescaledb_internal._hyper_1_11_chunk (reltuples 1801) rollback; ------------------------------------------- ------------------------------------------- --- Split a compressed/columnstore chunk ------------------------------------------- ------------------------------------------- -- Convert one chunk to columnstore call convert_to_columnstore('_timescaledb_internal._hyper_1_2_chunk'); -- Compute aggregations to compare with after split create table chunk_summary_before_split as select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_2_chunk; -- Split the columnstore chunk, fully compressed select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_2_chunk'::regclass \gset -- All data should be in the (internal) compressed chunk select count(*) from only _timescaledb_internal._hyper_1_2_chunk; count ------- 0 select count(*) from :compress_relid; count ------- 30 -- Use split point Thu Jan 04 13:40:30 2024 PST which should be within -- some segments select 'Thu Jan 04 13:40:30 2024 PST'::timestamptz as split_point \gset select _ts_meta_count, device, _ts_meta_min_1, _ts_meta_max_1 from :compress_relid where _ts_meta_min_1 <= :'split_point' and _ts_meta_max_1 >= :'split_point'; _ts_meta_count | device | _ts_meta_min_1 | _ts_meta_max_1 ----------------+--------+------------------------------+------------------------------ 1000 | 1 | Thu Jan 04 13:29:30 2024 PST | Fri Jan 05 03:13:30 2024 PST 1000 | 2 | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 14:06:30 2024 PST 1000 | 3 | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 13:41:50 2024 PST 1000 | 4 | Thu Jan 04 00:01:30 2024 PST | Thu Jan 04 13:50:40 2024 PST 1000 | 5 | Thu Jan 04 00:00:10 2024 PST | Thu Jan 04 13:53:40 2024 PST 1000 | 6 | Thu Jan 04 00:00:10 2024 PST | Thu Jan 04 13:54:40 2024 PST 1000 | 7 | Thu Jan 04 00:00:50 2024 PST | Thu Jan 04 14:15:50 2024 PST 1000 | 8 | Thu Jan 04 00:00:30 2024 PST | Thu Jan 04 14:20:10 2024 PST 1000 | 9 | Thu Jan 04 00:01:10 2024 PST | Thu Jan 04 13:59:00 2024 PST 1000 | 10 | Thu Jan 04 13:13:30 2024 PST | Fri Jan 05 03:09:40 2024 PST call split_chunk_validate('_timescaledb_internal._hyper_1_2_chunk', split_at => :'split_point'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_2_chunk (reltuples 0) and _timescaledb_internal._hyper_1_13_chunk (reltuples 0) NOTICE: compression size stats are OK select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint -------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_13_chunk | heap | 0 | constraint_21 | (("time" >= 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_1_chunk | heap | 3241 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 0 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 29523 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_7_chunk | heap | 5760 | constraint_11 | (("time" >= 'Wed Dec 27 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_8_chunk | heap | 28800 | constraint_13 | (("time" >= 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) select * from chunk_slices where hypertable_name = 'splitme'; hypertable_name | chunk_name | range_start | range_end -----------------+-------------------+------------------------------+------------------------------ splitme | _hyper_1_7_chunk | Wed Dec 27 16:00:00 2023 PST | Wed Jan 03 16:00:00 2024 PST splitme | _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST splitme | _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 13:40:30 2024 PST splitme | _hyper_1_13_chunk | Thu Jan 04 13:40:30 2024 PST | Fri Jan 05 16:00:00 2024 PST splitme | _hyper_1_8_chunk | Fri Jan 05 16:00:00 2024 PST | Sun Jan 07 08:00:00 2024 PST splitme | _hyper_1_3_chunk | Sun Jan 07 08:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST select show_chunks('splitme'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_13_chunk -- Still no data in non-compressed relations after split. select * from only _timescaledb_internal._hyper_1_2_chunk; time | device | temp | location ------+--------+------+---------- select * from only _timescaledb_internal._hyper_1_13_chunk; time | device | temp | location ------+--------+------+---------- -- Show how compressed segments are split across the resulting -- compressed chunks select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_2_chunk'::regclass \gset select _ts_meta_count, device, _ts_meta_min_1, _ts_meta_max_1 from :compress_relid; _ts_meta_count | device | _ts_meta_min_1 | _ts_meta_max_1 ----------------+--------+------------------------------+------------------------------ 1000 | 1 | Thu Jan 04 00:01:00 2024 PST | Thu Jan 04 13:29:10 2024 PST 11 | 1 | Thu Jan 04 13:29:30 2024 PST | Thu Jan 04 13:40:10 2024 PST 965 | 2 | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 13:38:20 2024 PST 999 | 3 | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 13:40:20 2024 PST 988 | 4 | Thu Jan 04 00:01:30 2024 PST | Thu Jan 04 13:39:50 2024 PST 984 | 5 | Thu Jan 04 00:00:10 2024 PST | Thu Jan 04 13:38:40 2024 PST 984 | 6 | Thu Jan 04 00:00:10 2024 PST | Thu Jan 04 13:40:00 2024 PST 960 | 7 | Thu Jan 04 00:00:50 2024 PST | Thu Jan 04 13:40:20 2024 PST 955 | 8 | Thu Jan 04 00:00:30 2024 PST | Thu Jan 04 13:38:10 2024 PST 971 | 9 | Thu Jan 04 00:01:10 2024 PST | Thu Jan 04 13:39:30 2024 PST 1000 | 10 | Thu Jan 04 00:01:00 2024 PST | Thu Jan 04 13:12:50 2024 PST 29 | 10 | Thu Jan 04 13:13:30 2024 PST | Thu Jan 04 13:39:40 2024 PST select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_13_chunk'::regclass \gset select _ts_meta_count, device, _ts_meta_min_1, _ts_meta_max_1 from :compress_relid; _ts_meta_count | device | _ts_meta_min_1 | _ts_meta_max_1 ----------------+--------+------------------------------+------------------------------ 989 | 1 | Thu Jan 04 13:41:00 2024 PST | Fri Jan 05 03:13:30 2024 PST 949 | 1 | Fri Jan 05 03:14:40 2024 PST | Fri Jan 05 15:59:40 2024 PST 35 | 2 | Thu Jan 04 13:40:40 2024 PST | Thu Jan 04 14:06:30 2024 PST 1000 | 2 | Thu Jan 04 14:06:40 2024 PST | Fri Jan 05 03:31:40 2024 PST 936 | 2 | Fri Jan 05 03:31:50 2024 PST | Fri Jan 05 15:59:50 2024 PST 1 | 3 | Thu Jan 04 13:41:50 2024 PST | Thu Jan 04 13:41:50 2024 PST 1000 | 3 | Thu Jan 04 13:43:20 2024 PST | Fri Jan 05 04:23:30 2024 PST 847 | 3 | Fri Jan 05 04:23:50 2024 PST | Fri Jan 05 15:59:20 2024 PST 12 | 4 | Thu Jan 04 13:41:40 2024 PST | Thu Jan 04 13:50:40 2024 PST 1000 | 4 | Thu Jan 04 13:51:30 2024 PST | Fri Jan 05 03:41:20 2024 PST 905 | 4 | Fri Jan 05 03:42:30 2024 PST | Fri Jan 05 15:59:30 2024 PST 16 | 5 | Thu Jan 04 13:40:30 2024 PST | Thu Jan 04 13:53:40 2024 PST 1000 | 5 | Thu Jan 04 13:54:30 2024 PST | Fri Jan 05 03:34:30 2024 PST 923 | 5 | Fri Jan 05 03:36:00 2024 PST | Fri Jan 05 15:59:00 2024 PST 16 | 6 | Thu Jan 04 13:41:20 2024 PST | Thu Jan 04 13:54:40 2024 PST 1000 | 6 | Thu Jan 04 13:55:00 2024 PST | Fri Jan 05 03:51:00 2024 PST 872 | 6 | Fri Jan 05 03:51:20 2024 PST | Fri Jan 05 15:59:40 2024 PST 40 | 7 | Thu Jan 04 13:41:00 2024 PST | Thu Jan 04 14:15:50 2024 PST 1000 | 7 | Thu Jan 04 14:17:30 2024 PST | Fri Jan 05 04:15:10 2024 PST 809 | 7 | Fri Jan 05 04:15:30 2024 PST | Fri Jan 05 15:59:00 2024 PST 45 | 8 | Thu Jan 04 13:40:50 2024 PST | Thu Jan 04 14:20:10 2024 PST 1000 | 8 | Thu Jan 04 14:20:30 2024 PST | Fri Jan 05 04:15:40 2024 PST 842 | 8 | Fri Jan 05 04:16:30 2024 PST | Fri Jan 05 15:59:30 2024 PST 29 | 9 | Thu Jan 04 13:40:30 2024 PST | Thu Jan 04 13:59:00 2024 PST 1000 | 9 | Thu Jan 04 14:00:20 2024 PST | Fri Jan 05 04:10:20 2024 PST 857 | 9 | Fri Jan 05 04:11:50 2024 PST | Fri Jan 05 15:58:40 2024 PST 971 | 10 | Thu Jan 04 13:40:40 2024 PST | Fri Jan 05 03:09:40 2024 PST 860 | 10 | Fri Jan 05 03:09:50 2024 PST | Fri Jan 05 15:59:50 2024 PST -- Would normally do a UNION ALL between the chunks, but it is broken -- on compressed chunks create table chunk_data_after_split as select * from _timescaledb_internal._hyper_1_2_chunk; insert into chunk_data_after_split select * from _timescaledb_internal._hyper_1_13_chunk; -- All data should be compressed so these queries should not return -- anything select * from only _timescaledb_internal._hyper_1_2_chunk; time | device | temp | location ------+--------+------+---------- select * from only _timescaledb_internal._hyper_1_13_chunk; time | device | temp | location ------+--------+------+---------- create table chunk_summary_after_split as select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from chunk_data_after_split; select * from chunk_summary_before_split; count | device_sum | location_sum | temp_sum -------+------------+--------------+-------------- 28800 | 157541 | 164543 | 586290.39395 select * from chunk_summary_after_split; count | device_sum | location_sum | temp_sum -------+------------+--------------+-------------- 28800 | 157541 | 164543 | 586290.39395 -- Split a columnstore chunk CALL convert_to_columnstore('_timescaledb_internal._hyper_1_3_chunk'); -- Add some non-compressed data. One tuple in each partition after -- split. insert into _timescaledb_internal._hyper_1_3_chunk values ('2024-01-07 09:03:11', 1, 21, 21.0), ('2024-01-10 02:04:12', 1, 17, 32.0); select * from ONLY _timescaledb_internal._hyper_1_3_chunk order by time; time | device | temp | location ------------------------------+--------+------+---------- Sun Jan 07 09:03:11 2024 PST | 1 | 21 | 21 Wed Jan 10 02:04:12 2024 PST | 1 | 17 | 32 select table_name, dropped, status, compressed_chunk_id from _timescaledb_catalog.chunk where table_name = '_hyper_1_3_chunk'; table_name | dropped | status | compressed_chunk_id ------------------+---------+--------+--------------------- _hyper_1_3_chunk | f | 9 | 15 truncate chunk_summary_before_split; insert into chunk_summary_before_split select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_3_chunk; select * from chunk_summary_before_split; count | device_sum | location_sum | temp_sum -------+------------+--------------+-------------- 29525 | 162733 | 169511 | 604005.96562 select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint -------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_13_chunk | heap | 0 | constraint_21 | (("time" >= 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_1_chunk | heap | 3241 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 0 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | -1 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_7_chunk | heap | 5760 | constraint_11 | (("time" >= 'Wed Dec 27 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_8_chunk | heap | 28800 | constraint_13 | (("time" >= 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) call split_chunk('_timescaledb_internal._hyper_1_3_chunk'); -- Check that the resulting chunks look OK and have the right access method select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint -------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_13_chunk | heap | 0 | constraint_21 | (("time" >= 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_16_chunk | heap | 1 | constraint_23 | (("time" >= 'Tue Jan 09 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_1_chunk | heap | 3241 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 0 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 1 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 09 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_7_chunk | heap | 5760 | constraint_11 | (("time" >= 'Wed Dec 27 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_8_chunk | heap | 28800 | constraint_13 | (("time" >= 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) select table_name, dropped, status, compressed_chunk_id from _timescaledb_catalog.chunk where table_name in ('_hyper_1_3_chunk', '_hyper_1_16_chunk'); table_name | dropped | status | compressed_chunk_id -------------------+---------+--------+--------------------- _hyper_1_16_chunk | f | 9 | 17 _hyper_1_3_chunk | f | 9 | 15 -- Check that the non-compressed data rows ended up in separate partitions select * from ONLY _timescaledb_internal._hyper_1_3_chunk order by time; time | device | temp | location ------------------------------+--------+------+---------- Sun Jan 07 09:03:11 2024 PST | 1 | 21 | 21 select * from ONLY _timescaledb_internal._hyper_1_16_chunk order by time; time | device | temp | location ------------------------------+--------+------+---------- Wed Jan 10 02:04:12 2024 PST | 1 | 17 | 32 -- Show aggregate summary. Should be equal to summary before split truncate chunk_data_after_split; insert into chunk_data_after_split select * from _timescaledb_internal._hyper_1_3_chunk; insert into chunk_data_after_split select * from _timescaledb_internal._hyper_1_16_chunk; truncate chunk_summary_after_split; insert into chunk_summary_after_split select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from chunk_data_after_split; -- Compare summaries before and after split select * from chunk_summary_before_split; count | device_sum | location_sum | temp_sum -------+------------+--------------+-------------- 29525 | 162733 | 169511 | 604005.96562 select * from chunk_summary_after_split; count | device_sum | location_sum | temp_sum -------+------------+--------------+-------------- 29525 | 162733 | 169511 | 604005.96562 -- Show the summary for each new chunk select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_3_chunk; count | device_sum | location_sum | temp_sum -------+------------+--------------+-------------- 28801 | 158662 | 165240 | 589129.85016 select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_16_chunk; count | device_sum | location_sum | temp_sum -------+------------+--------------+------------- 724 | 4071 | 4271 | 14876.11546 select chunk_name, range_start, range_end, is_compressed from timescaledb_information.chunks where hypertable_name = 'splitme' order by chunk_name, range_start, range_end; chunk_name | range_start | range_end | is_compressed -------------------+------------------------------+------------------------------+--------------- _hyper_1_13_chunk | Thu Jan 04 13:40:30 2024 PST | Fri Jan 05 16:00:00 2024 PST | t _hyper_1_16_chunk | Tue Jan 09 00:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST | t _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST | f _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 13:40:30 2024 PST | t _hyper_1_3_chunk | Sun Jan 07 08:00:00 2024 PST | Tue Jan 09 00:00:00 2024 PST | t _hyper_1_7_chunk | Wed Dec 27 16:00:00 2023 PST | Wed Jan 03 16:00:00 2024 PST | f _hyper_1_8_chunk | Fri Jan 05 16:00:00 2024 PST | Sun Jan 07 08:00:00 2024 PST | f select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_16_chunk'::regclass \gset select count(*) from :compress_relid; count ------- 11 -------------------------------------------------------------------- -------------------------------------------------------------------- -- Split compressed chunk in a way that leaves no compressed data in -- one of the chunks -------------------------------------------------------------------- -------------------------------------------------------------------- call convert_to_columnstore('_timescaledb_internal._hyper_1_8_chunk'); select max(time) as split_point from _timescaledb_internal._hyper_1_8_chunk \gset select :'split_point'; ?column? ------------------------------ Sun Jan 07 07:59:50 2024 PST call split_chunk_validate('_timescaledb_internal._hyper_1_8_chunk', split_at => :'split_point'::timestamptz + interval '1 second'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_8_chunk (reltuples 0) and _timescaledb_internal._hyper_1_19_chunk (reltuples 0) NOTICE: compression size stats are OK -- -- Show new chunk ranges. Note that, because the original chunk was -- compressed, both result chunks are also "compressed" even though -- one of them has no compressed data. -- -- The chunk without compressed data could have been marked -- "uncompressed" and the compressed relation removed. But this is not -- how things work currently. -- select chunk_name, range_start, range_end, is_compressed from timescaledb_information.chunks where hypertable_name = 'splitme' order by chunk_name, range_start, range_end; chunk_name | range_start | range_end | is_compressed -------------------+------------------------------+------------------------------+--------------- _hyper_1_13_chunk | Thu Jan 04 13:40:30 2024 PST | Fri Jan 05 16:00:00 2024 PST | t _hyper_1_16_chunk | Tue Jan 09 00:00:00 2024 PST | Wed Jan 10 16:00:00 2024 PST | t _hyper_1_19_chunk | Sun Jan 07 07:59:51 2024 PST | Sun Jan 07 08:00:00 2024 PST | t _hyper_1_1_chunk | Wed Jan 03 16:00:00 2024 PST | Thu Jan 04 00:00:00 2024 PST | f _hyper_1_2_chunk | Thu Jan 04 00:00:00 2024 PST | Thu Jan 04 13:40:30 2024 PST | t _hyper_1_3_chunk | Sun Jan 07 08:00:00 2024 PST | Tue Jan 09 00:00:00 2024 PST | t _hyper_1_7_chunk | Wed Dec 27 16:00:00 2023 PST | Wed Jan 03 16:00:00 2024 PST | f _hyper_1_8_chunk | Fri Jan 05 16:00:00 2024 PST | Sun Jan 07 07:59:51 2024 PST | t select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_8_chunk'::regclass \gset select count(*) from :compress_relid; count ------- 30 select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_19_chunk'::regclass \gset select count(*) from :compress_relid; count ------- 0 select count(*) from _timescaledb_internal._hyper_1_8_chunk; count ------- 28800 select count(*) from _timescaledb_internal._hyper_1_19_chunk; count ------- 0 -------------------------------------------------------------------- -------------------------------------------------------------------- --- Test split points at time min and max values of compressed --- segment. We'd like to check that these values end up in the --- "right" result chunk after split. The split point should end up in --- the "right" result chunk, i.e., it should be a min value in a new --- segment. -------------------------------------------------------------------- -------------------------------------------------------------------- select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_13_chunk'::regclass \gset select sum(_ts_meta_count) as original_count_sum from :compress_relid \gset select _ts_meta_count as meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max, _ts_meta_min_1 as split_point_min, _ts_meta_max_1 as split_point_max from :compress_relid order by meta_min limit 1 offset 2 \gset -- Show metadata from the segment to be split. There might be other -- segments split too, but we are only intrested in this one segment -- for the test. select :'meta_count' as meta_count, :'split_point_min' as split_point_min, :'split_point_max' as split_point_max; meta_count | split_point_min | split_point_max ------------+------------------------------+------------------------------ 35 | Thu Jan 04 13:40:40 2024 PST | Thu Jan 04 14:06:30 2024 PST -- Split with a split point at min value call split_chunk_validate('_timescaledb_internal._hyper_1_13_chunk', split_at => :'split_point_min'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_13_chunk (reltuples 0) and _timescaledb_internal._hyper_1_21_chunk (reltuples 0) NOTICE: compression size stats are OK select compress_relid as compress_relid2 from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_21_chunk'::regclass \gset -- The segment should remain intact, and be completely in the "new" -- chunk (to the "right side" of the split) select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid where _ts_meta_min_1 = :'split_point_min' and _ts_meta_count = :'meta_count' order by meta_min; _ts_meta_count | meta_min | meta_max ----------------+----------+---------- select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid2 where _ts_meta_min_1 = :'split_point_min' and _ts_meta_count = :'meta_count' order by meta_min; _ts_meta_count | meta_min | meta_max ----------------+------------------------------+------------------------------ 35 | Thu Jan 04 13:40:40 2024 PST | Thu Jan 04 14:06:30 2024 PST -- The sum of the counts should match up with the original sum before -- split select :'original_count_sum' = ((select sum(_ts_meta_count) from :compress_relid) + (select sum(_ts_meta_count) from :compress_relid2)); ?column? ---------- t -- Use a split point at end of a segment (its max value). The segment -- should be split with the max value ending up as the only value in a -- new segment to the "right side" of the split (i.e., in the new -- chunk) select sum(_ts_meta_count) as original_count_sum from :compress_relid2 \gset call split_chunk_validate('_timescaledb_internal._hyper_1_21_chunk', split_at => :'split_point_max'); NOTICE: chunks after split are _timescaledb_internal._hyper_1_21_chunk (reltuples 0) and _timescaledb_internal._hyper_1_23_chunk (reltuples 0) NOTICE: compression size stats are OK select compress_relid as compress_relid3 from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_23_chunk'::regclass \gset select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid2 where _ts_meta_min_1 = :'split_point_min' and _ts_meta_count = (:'meta_count' - 1) order by meta_min; _ts_meta_count | meta_min | meta_max ----------------+------------------------------+------------------------------ 34 | Thu Jan 04 13:40:40 2024 PST | Thu Jan 04 14:06:20 2024 PST select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid3 where _ts_meta_min_1 = :'split_point_max' and _ts_meta_count = 1 order by meta_min; _ts_meta_count | meta_min | meta_max ----------------+------------------------------+------------------------------ 1 | Thu Jan 04 14:06:30 2024 PST | Thu Jan 04 14:06:30 2024 PST -- The sums of the counts should match up select :'original_count_sum' = ((select sum(_ts_meta_count) from :compress_relid2) + (select sum(_ts_meta_count) from :compress_relid3)); ?column? ---------- t select * from chunk_info; chunk | tam | reltuples | conname | checkconstraint -------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_13_chunk | heap | 0 | constraint_21 | (("time" >= 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 13:40:40 2024 PST'::timestamp with time zone)) _hyper_1_16_chunk | heap | 1 | constraint_23 | (("time" >= 'Tue Jan 09 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_19_chunk | heap | 0 | constraint_25 | (("time" >= 'Sun Jan 07 07:59:51 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone)) _hyper_1_1_chunk | heap | 3241 | constraint_1 | (("time" >= 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_21_chunk | heap | 0 | constraint_27 | (("time" >= 'Thu Jan 04 13:40:40 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 14:06:30 2024 PST'::timestamp with time zone)) _hyper_1_23_chunk | heap | 0 | constraint_29 | (("time" >= 'Thu Jan 04 14:06:30 2024 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_2_chunk | heap | 0 | constraint_3 | (("time" >= 'Thu Jan 04 00:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 04 13:40:30 2024 PST'::timestamp with time zone)) _hyper_1_3_chunk | heap | 1 | constraint_5 | (("time" >= 'Sun Jan 07 08:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Tue Jan 09 00:00:00 2024 PST'::timestamp with time zone)) _hyper_1_7_chunk | heap | 5760 | constraint_11 | (("time" >= 'Wed Dec 27 16:00:00 2023 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 03 16:00:00 2024 PST'::timestamp with time zone)) _hyper_1_8_chunk | heap | 0 | constraint_13 | (("time" >= 'Fri Jan 05 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Sun Jan 07 07:59:51 2024 PST'::timestamp with time zone)) select count(*), min(time), max(time) from _timescaledb_internal._hyper_1_23_chunk; count | min | max -------+------------------------------+------------------------------ 18642 | Thu Jan 04 14:06:30 2024 PST | Fri Jan 05 15:59:50 2024 PST select max(time) as max_time from _timescaledb_internal._hyper_1_23_chunk \gset -------------------------------------------------------- -------------------------------------------------------- -- Split a partial chunk so that the compressed data ends up in one -- chunk and the non-compressed data in the other. -------------------------------------------------------- -------------------------------------------------------- -- Create a new chunk insert into splitme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-10 23:00'::timestamptz, '2024-01-12 22:00:00 PST', '10s') t; call convert_to_columnstore('_timescaledb_internal._hyper_1_25_chunk'); select * from chunk_info where chunk = '_hyper_1_25_chunk'; chunk | tam | reltuples | conname | checkconstraint -------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_25_chunk | heap | -1 | constraint_30 | (("time" >= 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 17 16:00:00 2024 PST'::timestamp with time zone)) -- Check that all data is compressed select compress_relid as compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_25_chunk'::regclass \gset select count(*) from only _timescaledb_internal._hyper_1_25_chunk; count ------- 0 select count(*) from :compress_relid; count ------- 20 -- Insert non-compressed data insert into splitme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-12 23:00'::timestamptz, '2024-01-16 22:00:00 PST', '10s') t; select count(*) from only _timescaledb_internal._hyper_1_25_chunk; count ------- 34201 select count(*) from :compress_relid; count ------- 20 -- Split at a point between the compressed and non-compressed data call split_chunk_validate('_timescaledb_internal._hyper_1_25_chunk', split_at => '2024-01-12 22:30'::timestamptz); NOTICE: chunks after split are _timescaledb_internal._hyper_1_25_chunk (reltuples 0) and _timescaledb_internal._hyper_1_27_chunk (reltuples 34201) NOTICE: compression size stats are OK select * from chunk_info where chunk in ('_hyper_1_25_chunk', '_hyper_1_27_chunk'); chunk | tam | reltuples | conname | checkconstraint -------------------+------+-----------+---------------+------------------------------------------------------------------------------------------------------------------------------------------------ _hyper_1_25_chunk | heap | 0 | constraint_30 | (("time" >= 'Wed Jan 10 16:00:00 2024 PST'::timestamp with time zone) AND ("time" < 'Fri Jan 12 22:30:00 2024 PST'::timestamp with time zone)) _hyper_1_27_chunk | heap | 34201 | constraint_32 | (("time" >= 'Fri Jan 12 22:30:00 2024 PST'::timestamp with time zone) AND ("time" < 'Wed Jan 17 16:00:00 2024 PST'::timestamp with time zone)) -- Check that the distribution of data is such that one chunk has only -- compressed data and the other only non-compressed data. select compress_relid as compress_relid2 from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_27_chunk'::regclass \gset select count(*) from only _timescaledb_internal._hyper_1_25_chunk; count ------- 0 select count(*) from :compress_relid; count ------- 20 select count(*) from only _timescaledb_internal._hyper_1_27_chunk; count ------- 34201 select count(*) from :compress_relid2; count ------- 0 --- --- Test splitting chunks that are using a time partitioning function --- -- There are multiple versions of to_timestamp() so need to find the -- Oid of the one we want. select p.oid as time_funcid from pg_proc p join pg_namespace n on (p.pronamespace = n.oid) where proname = 'to_timestamp' and provolatile = 'i' and n.nspname = 'pg_catalog' \gset create table time_part_func (time float8, temp float); select create_hypertable('time_part_func', 'time', time_partitioning_func => :'time_funcid', create_default_indexes => false, chunk_time_interval => interval '1 month'); create_hypertable ----------------------------- (5,public,time_part_func,t) alter table time_part_func set (tsdb.orderby = 'time'); insert into time_part_func values (1734714800, 10.0), (1736220400, 11.0), (1736420400, 12.0); select ch as chunk_to_split from show_chunks('time_part_func') ch \gset call split_chunk(:'chunk_to_split'); select ch as chunk1 from show_chunks('time_part_func') ch limit 1 \gset select ch as chunk2 from show_chunks('time_part_func') ch limit 1 offset 1 \gset select to_timestamp(time), * from :chunk1; to_timestamp | time | temp ------------------------------+------------+------ Fri Dec 20 09:13:20 2024 PST | 1734714800 | 10 select to_timestamp(time), * from :chunk2; to_timestamp | time | temp ------------------------------+------------+------ Mon Jan 06 19:26:40 2025 PST | 1736220400 | 11 Thu Jan 09 03:00:00 2025 PST | 1736420400 | 12 -- Split a compressed chunk using time partitioning func call convert_to_columnstore(:'chunk2'); select * from show_chunks('time_part_func'); show_chunks ----------------------------------------- _timescaledb_internal._hyper_5_29_chunk _timescaledb_internal._hyper_5_30_chunk select to_timestamp(1736320400::float8); to_timestamp ------------------------------ Tue Jan 07 23:13:20 2025 PST call split_chunk(:'chunk2', split_at => 1736320400::float8); select ch as chunk1 from show_chunks('time_part_func') ch limit 1 \gset select ch as chunk2 from show_chunks('time_part_func') ch limit 1 offset 1 \gset select ch as chunk3 from show_chunks('time_part_func') ch limit 1 offset 2 \gset select to_timestamp(time), * from :chunk1; to_timestamp | time | temp ------------------------------+------------+------ Fri Dec 20 09:13:20 2024 PST | 1734714800 | 10 select to_timestamp(time), * from :chunk2; to_timestamp | time | temp ------------------------------+------------+------ Mon Jan 06 19:26:40 2025 PST | 1736220400 | 11 select to_timestamp(time), * from :chunk3; to_timestamp | time | temp ------------------------------+------------+------ Thu Jan 09 03:00:00 2025 PST | 1736420400 | 12 ��������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/telemetry_stats.out��������������������������������������������0000664�0000000�0000000�00000071261�15100345067�0023425�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --telemetry tests that require a community license \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; SET timezone TO 'America/Los_Angeles'; -- function call info size is too variable for this test, so disable it SET timescaledb.telemetry_level='no_functions'; SELECT setseed(1); setseed --------- -- Create a materialized view from the telemetry report so that we -- don't regenerate telemetry for every query. Filter heap_size for -- materialized views since PG14 reports a different heap size for -- them compared to earlier PG versions. CREATE MATERIALIZED VIEW telemetry_report AS SELECT (r #- '{relations,materialized_views,heap_size}') AS r FROM get_telemetry_report() r; CREATE VIEW relations AS SELECT r -> 'relations' AS rels FROM telemetry_report; SELECT rels -> 'continuous_aggregates' -> 'num_relations' AS num_continuous_aggs, rels -> 'hypertables' -> 'num_relations' AS num_hypertables FROM relations; num_continuous_aggs | num_hypertables ---------------------+----------------- 0 | 0 -- check telemetry picks up flagged content from metadata SELECT r -> 'db_metadata' AS db_metadata FROM telemetry_report; db_metadata ------------- {} -- check timescaledb_telemetry.cloud SELECT r -> 'instance_metadata' AS instance_metadata FROM telemetry_report r; instance_metadata ------------------- {"cloud": "ci"} CREATE TABLE normal (time timestamptz NOT NULL, device int, temp float); CREATE TABLE part (time timestamptz NOT NULL, device int, temp float) PARTITION BY RANGE (time); CREATE TABLE part_t1 PARTITION OF part FOR VALUES FROM ('2018-01-01') TO ('2018-02-01') PARTITION BY HASH (device); CREATE TABLE part_t2 PARTITION OF part FOR VALUES FROM ('2018-02-01') TO ('2018-03-01') PARTITION BY HASH (device); CREATE TABLE part_t1_d1 PARTITION OF part_t1 FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE part_t1_d2 PARTITION OF part_t1 FOR VALUES WITH (MODULUS 2, REMAINDER 1); CREATE TABLE part_t2_d1 PARTITION OF part_t2 FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE part_t2_d2 PARTITION OF part_t2 FOR VALUES WITH (MODULUS 2, REMAINDER 1); CREATE TABLE hyper (LIKE normal); SELECT table_name FROM create_hypertable('hyper', 'time'); table_name ------------ hyper CREATE MATERIALIZED VIEW contagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 hour', time) AS hour, device, min(time) FROM hyper GROUP BY hour, device; NOTICE: continuous aggregate "contagg" is already up-to-date -- Create another view (already have the "relations" view) CREATE VIEW devices AS SELECT DISTINCT ON (device) device FROM hyper; -- Show relations with no data REFRESH MATERIALIZED VIEW telemetry_report; SELECT jsonb_pretty(rels) AS relations FROM relations; relations ---------------------------------------------------------- { + "views": { + "num_relations": 4 + }, + "tables": { + "heap_size": 0, + "toast_size": 8192, + "indexes_size": 0, + "num_relations": 2, + "num_reltuples": 0 + }, + "hypertables": { + "heap_size": 0, + "toast_size": 0, + "compression": { + "compressed_heap_size": 0, + "compressed_row_count": 0, + "compressed_toast_size": 0, + "num_compressed_chunks": 0, + "uncompressed_heap_size": 0, + "uncompressed_row_count": 0, + "compressed_indexes_size": 0, + "uncompressed_toast_size": 0, + "uncompressed_indexes_size": 0, + "num_compressed_hypertables": 0, + "compressed_row_count_frozen_immediately": 0+ }, + "indexes_size": 24576, + "num_children": 0, + "num_relations": 2, + "num_reltuples": 0 + }, + "materialized_views": { + "toast_size": 8192, + "indexes_size": 0, + "num_relations": 1, + "num_reltuples": 0 + }, + "partitioned_tables": { + "heap_size": 0, + "toast_size": 0, + "indexes_size": 0, + "num_children": 6, + "num_relations": 1, + "num_reltuples": 0 + }, + "continuous_aggregates": { + "heap_size": 0, + "toast_size": 0, + "compression": { + "compressed_heap_size": 0, + "compressed_row_count": 0, + "num_compressed_caggs": 0, + "compressed_toast_size": 0, + "num_compressed_chunks": 0, + "uncompressed_heap_size": 0, + "uncompressed_row_count": 0, + "compressed_indexes_size": 0, + "uncompressed_toast_size": 0, + "uncompressed_indexes_size": 0, + "compressed_row_count_frozen_immediately": 0+ }, + "indexes_size": 0, + "num_children": 0, + "num_relations": 1, + "num_reltuples": 0, + "num_caggs_nested": 0, + "num_caggs_finalized": 1, + "num_caggs_using_real_time_aggregation": 1 + } + } -- Insert data INSERT INTO normal SELECT t, ceil(random() * 10)::int, random() * 30 FROM generate_series('2018-01-01'::timestamptz, '2018-02-28', '2h') t; INSERT INTO hyper SELECT * FROM normal; INSERT INTO part SELECT * FROM normal; CALL refresh_continuous_aggregate('contagg', NULL, NULL); -- Reindex to avoid the dependency on the way the index is built (e.g. the caggs -- might get their rows inserted in different order during the refresh based on -- the underlying aggregation plan, and the index will be built differently, -- which can influence its size). REINDEX DATABASE :TEST_DBNAME; -- ANALYZE to get updated reltuples stats VACUUM ANALYZE; SELECT count(c) FROM show_chunks('hyper') c; count ------- 9 SELECT count(c) FROM show_chunks('contagg') c; count ------- 2 -- Update and show the telemetry report REFRESH MATERIALIZED VIEW telemetry_report; SELECT jsonb_pretty(rels) AS relations FROM relations; relations ---------------------------------------------------------- { + "views": { + "num_relations": 4 + }, + "tables": { + "heap_size": 73728, + "toast_size": 8192, + "indexes_size": 0, + "num_relations": 2, + "num_reltuples": 697 + }, + "hypertables": { + "heap_size": 475136, + "toast_size": 0, + "compression": { + "compressed_heap_size": 0, + "compressed_row_count": 0, + "compressed_toast_size": 0, + "num_compressed_chunks": 0, + "uncompressed_heap_size": 0, + "uncompressed_row_count": 0, + "compressed_indexes_size": 0, + "uncompressed_toast_size": 0, + "uncompressed_indexes_size": 0, + "num_compressed_hypertables": 0, + "compressed_row_count_frozen_immediately": 0+ }, + "indexes_size": 270336, + "num_children": 11, + "num_relations": 2, + "num_reltuples": 1394 + }, + "materialized_views": { + "toast_size": 8192, + "indexes_size": 0, + "num_relations": 1, + "num_reltuples": 1 + }, + "partitioned_tables": { + "heap_size": 180224, + "toast_size": 0, + "indexes_size": 0, + "num_children": 6, + "num_relations": 1, + "num_reltuples": 697 + }, + "continuous_aggregates": { + "heap_size": 0, + "toast_size": 0, + "compression": { + "compressed_heap_size": 0, + "compressed_row_count": 0, + "num_compressed_caggs": 0, + "compressed_toast_size": 0, + "num_compressed_chunks": 0, + "uncompressed_heap_size": 0, + "uncompressed_row_count": 0, + "compressed_indexes_size": 0, + "uncompressed_toast_size": 0, + "uncompressed_indexes_size": 0, + "compressed_row_count_frozen_immediately": 0+ }, + "indexes_size": 0, + "num_children": 0, + "num_relations": 1, + "num_reltuples": 0, + "num_caggs_nested": 0, + "num_caggs_finalized": 1, + "num_caggs_using_real_time_aggregation": 1 + } + } -- Actual row count should be the same as reltuples stats for all tables SELECT (SELECT count(*) FROM normal) num_inserted_rows, (SELECT rels -> 'tables' -> 'num_reltuples' FROM relations) normal_reltuples, (SELECT rels -> 'hypertables' -> 'num_reltuples' FROM relations) hyper_reltuples, (SELECT rels -> 'partitioned_tables' -> 'num_reltuples' FROM relations) part_reltuples; num_inserted_rows | normal_reltuples | hyper_reltuples | part_reltuples -------------------+------------------+-----------------+---------------- 697 | 697 | 1394 | 697 -- Add compression ALTER TABLE hyper SET (timescaledb.compress); SELECT compress_chunk(c) FROM show_chunks('hyper') c ORDER BY c LIMIT 4; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk ALTER MATERIALIZED VIEW contagg SET (timescaledb.compress); NOTICE: defaulting compress_segmentby to device NOTICE: defaulting compress_orderby to hour SELECT compress_chunk(c) FROM show_chunks('contagg') c ORDER BY c LIMIT 1; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_10_chunk -- Turn of real-time aggregation ALTER MATERIALIZED VIEW contagg SET (timescaledb.materialized_only = true); -- Reindex to avoid the dependency on the way the index is built (e.g. the caggs -- might get their rows inserted in different order during the refresh based on -- the underlying aggregation plan, and the index will be built differently, -- which can influence its size). REINDEX DATABASE :TEST_DBNAME; -- ANALYZE to get updated reltuples stats VACUUM ANALYZE; REFRESH MATERIALIZED VIEW telemetry_report; SELECT jsonb_pretty(rels) AS relations FROM relations; relations ----------------------------------------------------------- { + "views": { + "num_relations": 4 + }, + "tables": { + "heap_size": 73728, + "toast_size": 8192, + "indexes_size": 0, + "num_relations": 2, + "num_reltuples": 697 + }, + "hypertables": { + "heap_size": 368640, + "toast_size": 40960, + "compression": { + "compressed_heap_size": 114688, + "compressed_row_count": 49, + "compressed_toast_size": 40960, + "num_compressed_chunks": 5, + "uncompressed_heap_size": 221184, + "uncompressed_row_count": 736, + "compressed_indexes_size": 81920, + "uncompressed_toast_size": 0, + "uncompressed_indexes_size": 131072, + "num_compressed_hypertables": 2, + "compressed_row_count_frozen_immediately": 49+ }, + "indexes_size": 270336, + "num_children": 11, + "num_relations": 2, + "num_reltuples": 658 + }, + "materialized_views": { + "toast_size": 8192, + "indexes_size": 0, + "num_relations": 1, + "num_reltuples": 1 + }, + "partitioned_tables": { + "heap_size": 180224, + "toast_size": 0, + "indexes_size": 0, + "num_children": 6, + "num_relations": 1, + "num_reltuples": 697 + }, + "continuous_aggregates": { + "heap_size": 0, + "toast_size": 0, + "compression": { + "compressed_heap_size": 0, + "compressed_row_count": 0, + "num_compressed_caggs": 1, + "compressed_toast_size": 0, + "num_compressed_chunks": 0, + "uncompressed_heap_size": 0, + "uncompressed_row_count": 0, + "compressed_indexes_size": 0, + "uncompressed_toast_size": 0, + "uncompressed_indexes_size": 0, + "compressed_row_count_frozen_immediately": 0 + }, + "indexes_size": 0, + "num_children": 0, + "num_relations": 1, + "num_reltuples": 0, + "num_caggs_nested": 0, + "num_caggs_finalized": 1, + "num_caggs_using_real_time_aggregation": 0 + } + } -- check telemetry for fixed schedule jobs works create or replace procedure job_test_fixed(jobid int, config jsonb) language plpgsql as $$ begin raise log 'this is job_test_fixed'; end $$; create or replace procedure job_test_drifting(jobid int, config jsonb) language plpgsql as $$ begin raise log 'this is job_test_drifting'; end $$; -- before adding the jobs select get_telemetry_report()->'num_user_defined_actions_fixed'; ?column? ---------- 0 select get_telemetry_report()->'num_user_defined_actions'; ?column? ---------- 0 select add_job('job_test_fixed', '1 week'); add_job --------- 1000 select add_job('job_test_drifting', '1 week', fixed_schedule => false); add_job --------- 1001 -- add continuous aggregate refresh policy for contagg select add_continuous_aggregate_policy('contagg', interval '3 weeks', NULL, interval '3 weeks'); -- drifting add_continuous_aggregate_policy --------------------------------- 1002 -- add retention policy, fixed select add_retention_policy('hyper', interval '1 year', initial_start => now()); add_retention_policy ---------------------- 1003 -- add compression policy select add_compression_policy('hyper', interval '3 weeks', initial_start => now()); add_compression_policy ------------------------ 1004 select r->'num_user_defined_actions_fixed' as UDA_fixed, r->'num_user_defined_actions' AS UDA_drifting FROM get_telemetry_report() r; uda_fixed | uda_drifting -----------+-------------- 1 | 1 select r->'num_continuous_aggs_policies_fixed' as contagg_fixed, r->'num_continuous_aggs_policies' as contagg_drifting FROM get_telemetry_report() r; contagg_fixed | contagg_drifting ---------------+------------------ 0 | 1 select r->'num_compression_policies_fixed' as compress_fixed, r->'num_retention_policies_fixed' as retention_fixed FROM get_telemetry_report() r; compress_fixed | retention_fixed ----------------+----------------- 1 | 1 DELETE FROM _timescaledb_config.bgw_job WHERE id = 2; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- create some "errors" for testing INSERT INTO _timescaledb_config.bgw_job(id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name) VALUES (2000, 'User-Defined Action [2000]', interval '3 days', interval '1 hour', 5, interval '5 min', 'public', 'custom_action_1'), (2001, 'User-Defined Action [2001]', interval '3 days', interval '1 hour', 5, interval '5 min', 'public', 'custom_action_2'), (2002, 'Compression Policy [2002]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_compression'), (2003, 'Retention Policy [2003]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_retention'), (2004, 'Refresh Continuous Aggregate Policy [2004]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_refresh_continuous_aggregate'), -- user decided to define a custom action in the _timescaledb_functions schema, we group it with the User-defined actions (2005, 'User-Defined Action [2005]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_refresh_continuous_aggregate'); -- create some errors for them INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) values (2000, 12345, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema":"public", "proc_name": "custom_action_1"}}'), (2000, 23456, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"ABCDE"}, "job": {"proc_schema": "public", "proc_name": "custom_action_1"}}'), (2001, 54321, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "public", "proc_name": "custom_action_2"}}'), (2002, 23443, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"JF009"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_compression"}}'), (2003, 14567, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_retention"}}'), (2004, 78907, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_refresh_continuous_aggregate"}}'), (2005, 45757, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_refresh_continuous_aggregate"}}'); -- we have 3 error records for user-defined actions, and three for policies, so we expect 4 types of jobs SELECT jsonb_pretty(get_telemetry_report() -> 'errors_by_sqlerrcode'); jsonb_pretty ---------------------------------------------- { + "policy_retention": { + "P0001": 1 + }, + "policy_compression": { + "JF009": 1 + }, + "user_defined_action": { + "ABCDE": 1, + "P0001": 2 + }, + "policy_refresh_continuous_aggregate": {+ "P0001": 2 + } + } -- for job statistics, insert some records into bgw_job_stats INSERT INTO _timescaledb_internal.bgw_job_stat values (2000, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2001, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2002, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2003, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2004, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2005, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0); SELECT jsonb_pretty(get_telemetry_report() -> 'stats_by_job_type'); jsonb_pretty ------------------------------------------------ { + "policy_retention": { + "total_runs": 1, + "total_crashes": 0, + "total_duration": "@ 0", + "total_failures": 1, + "total_successes": 0, + "max_consecutive_crashes": 0, + "total_duration_failures": "@ 2 secs",+ "max_consecutive_failures": 1 + }, + "policy_compression": { + "total_runs": 1, + "total_crashes": 0, + "total_duration": "@ 0", + "total_failures": 1, + "total_successes": 0, + "max_consecutive_crashes": 0, + "total_duration_failures": "@ 2 secs",+ "max_consecutive_failures": 1 + }, + "user_defined_action": { + "total_runs": 2, + "total_crashes": 0, + "total_duration": "@ 0", + "total_failures": 2, + "total_successes": 0, + "max_consecutive_crashes": 0, + "total_duration_failures": "@ 4 secs",+ "max_consecutive_failures": 1 + }, + "policy_refresh_continuous_aggregate": { + "total_runs": 2, + "total_crashes": 0, + "total_duration": "@ 0", + "total_failures": 2, + "total_successes": 0, + "max_consecutive_crashes": 0, + "total_duration_failures": "@ 4 secs",+ "max_consecutive_failures": 1 + } + } -- create nested continuous aggregates - copied from cagg_on_cagg_common CREATE TABLE conditions ( time timestamptz NOT NULL, temperature int ); SELECT create_hypertable('conditions', 'time'); create_hypertable ------------------------- (5,public,conditions,t) CREATE MATERIALIZED VIEW conditions_summary_hourly_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', "time") AS bucket, SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW conditions_summary_daily_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', "bucket") AS bucket, SUM(temperature) AS temperature FROM conditions_summary_hourly_1 GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW conditions_summary_weekly_3 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 week', "bucket") AS bucket, SUM(temperature) AS temperature FROM conditions_summary_daily_2 GROUP BY 1 WITH NO DATA; SELECT jsonb_pretty(get_telemetry_report() -> 'relations' -> 'continuous_aggregates' -> 'num_caggs_nested'); jsonb_pretty -------------- 2 DROP VIEW relations; DROP MATERIALIZED VIEW telemetry_report; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression-15.out�������������������������������0000664�0000000�0000000�00002313521�15100345067�0025713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset SET work_mem TO '50MB'; SET enable_incremental_sort TO off; SET timezone TO 'America/Los_Angeles'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; CREATE TABLE metrics ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable ('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; \set INTERVAL 30m INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id - 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('metrics_space', 'time', 'device_id', 3); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics_space; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none -- compress first and last chunk on the hypertable ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics') x) t where n in (1, 3) ; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk VACUUM ANALYZE metrics; -- compress some chunks on space partitioned hypertable -- we compress all chunks of first time slice, none of second, and 2 of the last time slice ALTER TABLE metrics_space SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics_space') x) t where n in (1, 2, 3, 7, 8) ; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics' \gset SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_SPACE_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics_space' \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Index created using query saved in variable used because there was -- no standard way to create an index on a compressed table. -- Once a standard way exists, modify this test to use that method. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE INDEX ON metrics_space (device_id, device_id_peer, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id, device_id_peer DESC, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id DESC, device_id_peer DESC, v0, v1 DESC, time); VACUUM ANALYZE metrics_space; SET enable_incremental_sort TO off; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; -- get explain for queries on hypertable with compression \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Sort (actual rows=3456.00 loops=1) Sort Key: metrics."time", metrics.device_id Sort Method: quicksort -> Result (actual rows=3456.00 loops=1) -> Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_2_chunk (actual rows=1344.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2016 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=672.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time", metrics.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3600 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1680 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 3) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3595 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3570 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=35.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3565 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3570.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 30 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 2688 -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < 1) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) Filter: (v0 < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3600 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 1680 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=713.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: ((compress_hyper_5_15_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_15_chunk.device_id = 1)) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Index Cond: (_hyper_1_2_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: ((compress_hyper_5_16_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_16_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3572.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 28 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC, metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics.device_id, metrics."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device_id, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time", metrics.device_id Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk."time" Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0 -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time", metrics.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1 DESC, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 1 -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=8640.00 loops=1) Order: metrics."time" -> Sort (actual rows=3600.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics."time" = metrics_1."time") -> Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1728.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Order: metrics."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=5.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Index Only Scan using _hyper_1_2_chunk_tmp_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id_peer = 1) Rows Removed by Filter: 5 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id_peer = 1) Rows Removed by Filter: 5 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Output: metrics.device_id_peer Join Filter: (metrics.device_id_peer = "*VALUES*".column1) Rows Removed by Join Filter: 17280 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=3456.00 loops=1) Output: metrics.device_id_peer -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=1728.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=2) Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=2) Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_1_2_chunk.device_id) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=2) Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = "*VALUES*".column1) RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join Output: metrics.device_id_peer Hash Cond: (metrics.device_id = "*VALUES*".column1) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -> Hash Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=3456.00 loops=1) Output: metrics.device_id_peer -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=1728.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=2) Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=2) Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_1_2_chunk.device_id) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=2) Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = "*VALUES*".column1) -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: m3_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m3_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 38 -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=48.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=11.00 loops=1) Order: m2."time" -> Sort (actual rows=11.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Sort (actual rows=3456.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Result (actual rows=3456.00 loops=1) -> Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Vectorized Filter: (_hyper_2_5_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2160 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Vectorized Filter: (_hyper_2_6_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2016 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1008 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (never executed) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 3 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2157 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=18.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2142 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=21.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2139 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2142.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 18 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id < v0) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id < v0) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 336 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2160 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 1008 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=713.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: ((compress_hyper_6_17_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_17_chunk.device_id = 1)) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: ((compress_hyper_6_20_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_20_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=9.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC, metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_12_chunk."time" DESC, _hyper_2_12_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC, _hyper_2_11_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC, _hyper_2_10_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time" DESC, _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time" DESC, _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time" DESC, _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC, _hyper_2_6_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC, _hyper_2_5_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC, _hyper_2_4_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_4_chunk.device_id, _hyper_2_4_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_5_chunk.device_id, _hyper_2_5_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk.device_id, _hyper_2_6_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk."time" Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk."time" Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk."time" Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk."time" Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk."time" Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk."time" Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time", metrics_space.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _hyper_2_9_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=3915.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (actual rows=2235.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1341.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=8640.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3600.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=2160.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=3360.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics_space."time" = metrics_space_1."time") -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1728.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=5.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics_space), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics_space), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan using _hyper_2_7_chunk_tmp_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id -> Index Only Scan using _hyper_2_8_chunk_tmp_idx on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id -> Index Only Scan using _hyper_2_9_chunk_tmp_idx on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan using _hyper_2_12_chunk_tmp_idx on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Filter: (compress_hyper_6_19_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Filter: (_hyper_2_12_chunk.device_id_peer = 1) Rows Removed by Filter: 336 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Output: metrics_space.device_id_peer Join Filter: (metrics_space.device_id_peer = "*VALUES*".column1) Rows Removed by Join Filter: 17280 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=3456.00 loops=1) Output: metrics_space.device_id_peer Join Filter: (metrics_space.device_id = "*VALUES*".column1) Rows Removed by Join Filter: 12096 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join Output: metrics_space.device_id_peer Hash Cond: (metrics_space.device_id = "*VALUES*".column1) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Hash Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join (actual rows=3456.00 loops=1) Output: metrics_space.device_id_peer Hash Cond: (metrics_space.device_id = "*VALUES*".column1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Hash (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m3_3 (actual rows=1.00 loops=1) Filter: (device_id = 3) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 39 -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=49.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=11.00 loops=1) Order: m2."time" -> Merge Append (actual rows=11.00 loops=1) Sort Key: m2."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=7.00 loops=1) Sort Key: m2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m2_4 (never executed) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m2_5 (never executed) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time" -> Sort (never executed) Sort Key: m2_7."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 7 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_18_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_19_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m1_5 (never executed) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m1_6 (never executed) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m1_9 (never executed) Index Cond: ("time" = g."time") -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 1) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 2) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \ir include/transparent_decompression_ordered.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column CREATE TABLE metrics_ordered(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_ordered','time'); create_hypertable ------------------------------- (11,public,metrics_ordered,t) ALTER TABLE metrics_ordered SET (timescaledb.compress, timescaledb.compress_orderby='time DESC',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered SELECT * FROM metrics; CREATE INDEX ON metrics_ordered(device_id,device_id_peer,time); CREATE INDEX ON metrics_ordered(device_id,time); CREATE INDEX ON metrics_ordered(device_id_peer,time); -- compress all chunks SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered') ch; count ------- 3 VACUUM ANALYZE metrics_ordered; -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM metrics_ordered ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=10.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_30_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_29_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_29_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered WHERE device_id = 1 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=0.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_min_1 DESC, compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_30_chunk._ts_meta_min_1 DESC, compress_hyper_12_30_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_29_chunk._ts_meta_min_1 DESC, compress_hyper_12_29_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered d INNER JOIN LATERAL (SELECT * FROM metrics_ordered m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON true; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Nested Loop (actual rows=0.00 loops=1) -> Merge Append (actual rows=8640.00 loops=1) Sort Key: d.device_id -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk d_1 (actual rows=3600.00 loops=1) -> Index Scan using compress_hyper_12_29_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_29_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk d_2 (actual rows=3360.00 loops=1) -> Index Scan using compress_hyper_12_30_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_30_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk d_3 (actual rows=1680.00 loops=1) -> Index Scan using compress_hyper_12_31_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Limit (actual rows=0.00 loops=8640) -> Custom Scan (ChunkAppend) on metrics_ordered m (actual rows=0.00 loops=8640) Order: m."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk m_1 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_31_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_31_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk compress_hyper_12_31_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk m_2 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_30_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_30_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk compress_hyper_12_30_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk m_3 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_29_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_29_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk compress_hyper_12_29_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 \ir include/transparent_decompression_systemcolumns.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_TABLE 'metrics' -- test system columns -- all system columns except for tableoid should error \set ON_ERROR_STOP 0 SELECT xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:10: ERROR: transparent decompression only supports tableoid system column SELECT cmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:11: ERROR: transparent decompression only supports tableoid system column SELECT xmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:12: ERROR: transparent decompression only supports tableoid system column SELECT cmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:13: ERROR: transparent decompression only supports tableoid system column SELECT ctid FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:14: ERROR: transparent decompression only supports tableoid system column -- test system columns in WHERE and ORDER BY clause SELECT tableoid, xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:17: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE ORDER BY cmin::text; psql:include/transparent_decompression_systemcolumns.sql:18: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE WHERE cmin IS NOT NULL; psql:include/transparent_decompression_systemcolumns.sql:19: ERROR: transparent decompression only supports tableoid system column \set ON_ERROR_STOP 1 -- test tableoid in different parts of query SELECT pg_typeof(tableoid) FROM :TEST_TABLE ORDER BY time LIMIT 1; pg_typeof ----------- oid SELECT FROM :TEST_TABLE ORDER BY tableoid LIMIT 1; -- SELECT FROM :TEST_TABLE WHERE tableoid::int > 0 LIMIT 1; -- SELECT tableoid::regclass FROM :TEST_TABLE GROUP BY tableoid ORDER BY 1; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk SELECT count(distinct tableoid) FROM :TEST_TABLE WHERE device_id=1 AND time < now(); count ------- 3 -- test prepared statement PREPARE tableoid_prep AS SELECT tableoid::regclass FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 1; :PREFIX EXECUTE tableoid_prep; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk DEALLOCATE tableoid_prep; \ir include/transparent_decompression_undiffed.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test planning regression with many chunks CREATE TABLE tags(id SERIAL PRIMARY KEY, name TEXT, fleet TEXT); INSERT INTO tags (name, fleet) VALUES('n1', 'f1'); CREATE TABLE readings (time timestamptz, tags_id integer, fuel_consumption DOUBLE PRECISION); CREATE INDEX ON readings(tags_id, "time" DESC); CREATE INDEX ON readings("time" DESC); SELECT create_hypertable('readings', 'time', partitioning_column => 'tags_id', number_partitions => 1, chunk_time_interval => 43200000000, create_default_indexes=>false); create_hypertable ------------------------ (13,public,readings,t) ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'tags_id', timescaledb.compress_orderby = 'time desc'); INSERT into readings select g, 1, 1.3 from generate_series('2001-03-01 01:01:01', '2003-02-01 01:01:01', '1 day'::interval) g; SELECT count(compress_chunk(ch)) FROM show_chunks('readings') ch; count ------- 703 VACUUM ANALYZE readings; EXPLAIN (buffers off, costs off) SELECT t.fleet as fleet, min(r.fuel_consumption) AS avg_fuel_consumption FROM tags t INNER JOIN LATERAL(SELECT tags_id, fuel_consumption FROM readings r WHERE r.tags_id = t.id ) r ON true GROUP BY fleet; --- QUERY PLAN --- HashAggregate Group Key: t.fleet -> Hash Join Hash Cond: (r.tags_id = t.id) -> Append -> Custom Scan (ColumnarScan) on _hyper_13_32_chunk r_1 -> Seq Scan on compress_hyper_14_735_chunk -> Custom Scan (ColumnarScan) on _hyper_13_33_chunk r_2 -> Seq Scan on compress_hyper_14_736_chunk -> Custom Scan (ColumnarScan) on _hyper_13_34_chunk r_3 -> Seq Scan on compress_hyper_14_737_chunk -> Custom Scan (ColumnarScan) on _hyper_13_35_chunk r_4 -> Seq Scan on compress_hyper_14_738_chunk -> Custom Scan (ColumnarScan) on _hyper_13_36_chunk r_5 -> Seq Scan on compress_hyper_14_739_chunk -> Custom Scan (ColumnarScan) on _hyper_13_37_chunk r_6 -> Seq Scan on compress_hyper_14_740_chunk -> Custom Scan (ColumnarScan) on _hyper_13_38_chunk r_7 -> Seq Scan on compress_hyper_14_741_chunk -> Custom Scan (ColumnarScan) on _hyper_13_39_chunk r_8 -> Seq Scan on compress_hyper_14_742_chunk -> Custom Scan (ColumnarScan) on _hyper_13_40_chunk r_9 -> Seq Scan on compress_hyper_14_743_chunk -> Custom Scan (ColumnarScan) on _hyper_13_41_chunk r_10 -> Seq Scan on compress_hyper_14_744_chunk -> Custom Scan (ColumnarScan) on _hyper_13_42_chunk r_11 -> Seq Scan on compress_hyper_14_745_chunk -> Custom Scan (ColumnarScan) on _hyper_13_43_chunk r_12 -> Seq Scan on compress_hyper_14_746_chunk -> Custom Scan (ColumnarScan) on _hyper_13_44_chunk r_13 -> Seq Scan on compress_hyper_14_747_chunk -> Custom Scan (ColumnarScan) on _hyper_13_45_chunk r_14 -> Seq Scan on compress_hyper_14_748_chunk -> Custom Scan (ColumnarScan) on _hyper_13_46_chunk r_15 -> Seq Scan on compress_hyper_14_749_chunk -> Custom Scan (ColumnarScan) on _hyper_13_47_chunk r_16 -> Seq Scan on compress_hyper_14_750_chunk -> Custom Scan (ColumnarScan) on _hyper_13_48_chunk r_17 -> Seq Scan on compress_hyper_14_751_chunk -> Custom Scan (ColumnarScan) on _hyper_13_49_chunk r_18 -> Seq Scan on compress_hyper_14_752_chunk -> Custom Scan (ColumnarScan) on _hyper_13_50_chunk r_19 -> Seq Scan on compress_hyper_14_753_chunk -> Custom Scan (ColumnarScan) on _hyper_13_51_chunk r_20 -> Seq Scan on compress_hyper_14_754_chunk -> Custom Scan (ColumnarScan) on _hyper_13_52_chunk r_21 -> Seq Scan on compress_hyper_14_755_chunk -> Custom Scan (ColumnarScan) on _hyper_13_53_chunk r_22 -> Seq Scan on compress_hyper_14_756_chunk -> Custom Scan (ColumnarScan) on _hyper_13_54_chunk r_23 -> Seq Scan on compress_hyper_14_757_chunk -> Custom Scan (ColumnarScan) on _hyper_13_55_chunk r_24 -> Seq Scan on compress_hyper_14_758_chunk -> Custom Scan (ColumnarScan) on _hyper_13_56_chunk r_25 -> Seq Scan on compress_hyper_14_759_chunk -> Custom Scan (ColumnarScan) on _hyper_13_57_chunk r_26 -> Seq Scan on compress_hyper_14_760_chunk -> Custom Scan (ColumnarScan) on _hyper_13_58_chunk r_27 -> Seq Scan on compress_hyper_14_761_chunk -> Custom Scan (ColumnarScan) on _hyper_13_59_chunk r_28 -> Seq Scan on compress_hyper_14_762_chunk -> Custom Scan (ColumnarScan) on _hyper_13_60_chunk r_29 -> Seq Scan on compress_hyper_14_763_chunk -> Custom Scan (ColumnarScan) on _hyper_13_61_chunk r_30 -> Seq Scan on compress_hyper_14_764_chunk -> Custom Scan (ColumnarScan) on _hyper_13_62_chunk r_31 -> Seq Scan on compress_hyper_14_765_chunk -> Custom Scan (ColumnarScan) on _hyper_13_63_chunk r_32 -> Seq Scan on compress_hyper_14_766_chunk -> Custom Scan (ColumnarScan) on _hyper_13_64_chunk r_33 -> Seq Scan on compress_hyper_14_767_chunk -> Custom Scan (ColumnarScan) on _hyper_13_65_chunk r_34 -> Seq Scan on compress_hyper_14_768_chunk -> Custom Scan (ColumnarScan) on _hyper_13_66_chunk r_35 -> Seq Scan on compress_hyper_14_769_chunk -> Custom Scan (ColumnarScan) on _hyper_13_67_chunk r_36 -> Seq Scan on compress_hyper_14_770_chunk -> Custom Scan (ColumnarScan) on _hyper_13_68_chunk r_37 -> Seq Scan on compress_hyper_14_771_chunk -> Custom Scan (ColumnarScan) on _hyper_13_69_chunk r_38 -> Seq Scan on compress_hyper_14_772_chunk -> Custom Scan (ColumnarScan) on _hyper_13_70_chunk r_39 -> Seq Scan on compress_hyper_14_773_chunk -> Custom Scan (ColumnarScan) on _hyper_13_71_chunk r_40 -> Seq Scan on compress_hyper_14_774_chunk -> Custom Scan (ColumnarScan) on _hyper_13_72_chunk r_41 -> Seq Scan on compress_hyper_14_775_chunk -> Custom Scan (ColumnarScan) on _hyper_13_73_chunk r_42 -> Seq Scan on compress_hyper_14_776_chunk -> Custom Scan (ColumnarScan) on _hyper_13_74_chunk r_43 -> Seq Scan on compress_hyper_14_777_chunk -> Custom Scan (ColumnarScan) on _hyper_13_75_chunk r_44 -> Seq Scan on compress_hyper_14_778_chunk -> Custom Scan (ColumnarScan) on _hyper_13_76_chunk r_45 -> Seq Scan on compress_hyper_14_779_chunk -> Custom Scan (ColumnarScan) on _hyper_13_77_chunk r_46 -> Seq Scan on compress_hyper_14_780_chunk -> Custom Scan (ColumnarScan) on _hyper_13_78_chunk r_47 -> Seq Scan on compress_hyper_14_781_chunk -> Custom Scan (ColumnarScan) on _hyper_13_79_chunk r_48 -> Seq Scan on compress_hyper_14_782_chunk -> Custom Scan (ColumnarScan) on _hyper_13_80_chunk r_49 -> Seq Scan on compress_hyper_14_783_chunk -> Custom Scan (ColumnarScan) on _hyper_13_81_chunk r_50 -> Seq Scan on compress_hyper_14_784_chunk -> Custom Scan (ColumnarScan) on _hyper_13_82_chunk r_51 -> Seq Scan on compress_hyper_14_785_chunk -> Custom Scan (ColumnarScan) on _hyper_13_83_chunk r_52 -> Seq Scan on compress_hyper_14_786_chunk -> Custom Scan (ColumnarScan) on _hyper_13_84_chunk r_53 -> Seq Scan on compress_hyper_14_787_chunk -> Custom Scan (ColumnarScan) on _hyper_13_85_chunk r_54 -> Seq Scan on compress_hyper_14_788_chunk -> Custom Scan (ColumnarScan) on _hyper_13_86_chunk r_55 -> Seq Scan on compress_hyper_14_789_chunk -> Custom Scan (ColumnarScan) on _hyper_13_87_chunk r_56 -> Seq Scan on compress_hyper_14_790_chunk -> Custom Scan (ColumnarScan) on _hyper_13_88_chunk r_57 -> Seq Scan on compress_hyper_14_791_chunk -> Custom Scan (ColumnarScan) on _hyper_13_89_chunk r_58 -> Seq Scan on compress_hyper_14_792_chunk -> Custom Scan (ColumnarScan) on _hyper_13_90_chunk r_59 -> Seq Scan on compress_hyper_14_793_chunk -> Custom Scan (ColumnarScan) on _hyper_13_91_chunk r_60 -> Seq Scan on compress_hyper_14_794_chunk -> Custom Scan (ColumnarScan) on _hyper_13_92_chunk r_61 -> Seq Scan on compress_hyper_14_795_chunk -> Custom Scan (ColumnarScan) on _hyper_13_93_chunk r_62 -> Seq Scan on compress_hyper_14_796_chunk -> Custom Scan (ColumnarScan) on _hyper_13_94_chunk r_63 -> Seq Scan on compress_hyper_14_797_chunk -> Custom Scan (ColumnarScan) on _hyper_13_95_chunk r_64 -> Seq Scan on compress_hyper_14_798_chunk -> Custom Scan (ColumnarScan) on _hyper_13_96_chunk r_65 -> Seq Scan on compress_hyper_14_799_chunk -> Custom Scan (ColumnarScan) on _hyper_13_97_chunk r_66 -> Seq Scan on compress_hyper_14_800_chunk -> Custom Scan (ColumnarScan) on _hyper_13_98_chunk r_67 -> Seq Scan on compress_hyper_14_801_chunk -> Custom Scan (ColumnarScan) on _hyper_13_99_chunk r_68 -> Seq Scan on compress_hyper_14_802_chunk -> Custom Scan (ColumnarScan) on _hyper_13_100_chunk r_69 -> Seq Scan on compress_hyper_14_803_chunk -> Custom Scan (ColumnarScan) on _hyper_13_101_chunk r_70 -> Seq Scan on compress_hyper_14_804_chunk -> Custom Scan (ColumnarScan) on _hyper_13_102_chunk r_71 -> Seq Scan on compress_hyper_14_805_chunk -> Custom Scan (ColumnarScan) on _hyper_13_103_chunk r_72 -> Seq Scan on compress_hyper_14_806_chunk -> Custom Scan (ColumnarScan) on _hyper_13_104_chunk r_73 -> Seq Scan on compress_hyper_14_807_chunk -> Custom Scan (ColumnarScan) on _hyper_13_105_chunk r_74 -> Seq Scan on compress_hyper_14_808_chunk -> Custom Scan (ColumnarScan) on _hyper_13_106_chunk r_75 -> Seq Scan on compress_hyper_14_809_chunk -> Custom Scan (ColumnarScan) on _hyper_13_107_chunk r_76 -> Seq Scan on compress_hyper_14_810_chunk -> Custom Scan (ColumnarScan) on _hyper_13_108_chunk r_77 -> Seq Scan on compress_hyper_14_811_chunk -> Custom Scan (ColumnarScan) on _hyper_13_109_chunk r_78 -> Seq Scan on compress_hyper_14_812_chunk -> Custom Scan (ColumnarScan) on _hyper_13_110_chunk r_79 -> Seq Scan on compress_hyper_14_813_chunk -> Custom Scan (ColumnarScan) on _hyper_13_111_chunk r_80 -> Seq Scan on compress_hyper_14_814_chunk -> Custom Scan (ColumnarScan) on _hyper_13_112_chunk r_81 -> Seq Scan on compress_hyper_14_815_chunk -> Custom Scan (ColumnarScan) on _hyper_13_113_chunk r_82 -> Seq Scan on compress_hyper_14_816_chunk -> Custom Scan (ColumnarScan) on _hyper_13_114_chunk r_83 -> Seq Scan on compress_hyper_14_817_chunk -> Custom Scan (ColumnarScan) on _hyper_13_115_chunk r_84 -> Seq Scan on compress_hyper_14_818_chunk -> Custom Scan (ColumnarScan) on _hyper_13_116_chunk r_85 -> Seq Scan on compress_hyper_14_819_chunk -> Custom Scan (ColumnarScan) on _hyper_13_117_chunk r_86 -> Seq Scan on compress_hyper_14_820_chunk -> Custom Scan (ColumnarScan) on _hyper_13_118_chunk r_87 -> Seq Scan on compress_hyper_14_821_chunk -> Custom Scan (ColumnarScan) on _hyper_13_119_chunk r_88 -> Seq Scan on compress_hyper_14_822_chunk -> Custom Scan (ColumnarScan) on _hyper_13_120_chunk r_89 -> Seq Scan on compress_hyper_14_823_chunk -> Custom Scan (ColumnarScan) on _hyper_13_121_chunk r_90 -> Seq Scan on compress_hyper_14_824_chunk -> Custom Scan (ColumnarScan) on _hyper_13_122_chunk r_91 -> Seq Scan on compress_hyper_14_825_chunk -> Custom Scan (ColumnarScan) on _hyper_13_123_chunk r_92 -> Seq Scan on compress_hyper_14_826_chunk -> Custom Scan (ColumnarScan) on _hyper_13_124_chunk r_93 -> Seq Scan on compress_hyper_14_827_chunk -> Custom Scan (ColumnarScan) on _hyper_13_125_chunk r_94 -> Seq Scan on compress_hyper_14_828_chunk -> Custom Scan (ColumnarScan) on _hyper_13_126_chunk r_95 -> Seq Scan on compress_hyper_14_829_chunk -> Custom Scan (ColumnarScan) on _hyper_13_127_chunk r_96 -> Seq Scan on compress_hyper_14_830_chunk -> Custom Scan (ColumnarScan) on _hyper_13_128_chunk r_97 -> Seq Scan on compress_hyper_14_831_chunk -> Custom Scan (ColumnarScan) on _hyper_13_129_chunk r_98 -> Seq Scan on compress_hyper_14_832_chunk -> Custom Scan (ColumnarScan) on _hyper_13_130_chunk r_99 -> Seq Scan on compress_hyper_14_833_chunk -> Custom Scan (ColumnarScan) on _hyper_13_131_chunk r_100 -> Seq Scan on compress_hyper_14_834_chunk -> Custom Scan (ColumnarScan) on _hyper_13_132_chunk r_101 -> Seq Scan on compress_hyper_14_835_chunk -> Custom Scan (ColumnarScan) on _hyper_13_133_chunk r_102 -> Seq Scan on compress_hyper_14_836_chunk -> Custom Scan (ColumnarScan) on _hyper_13_134_chunk r_103 -> Seq Scan on compress_hyper_14_837_chunk -> Custom Scan (ColumnarScan) on _hyper_13_135_chunk r_104 -> Seq Scan on compress_hyper_14_838_chunk -> Custom Scan (ColumnarScan) on _hyper_13_136_chunk r_105 -> Seq Scan on compress_hyper_14_839_chunk -> Custom Scan (ColumnarScan) on _hyper_13_137_chunk r_106 -> Seq Scan on compress_hyper_14_840_chunk -> Custom Scan (ColumnarScan) on _hyper_13_138_chunk r_107 -> Seq Scan on compress_hyper_14_841_chunk -> Custom Scan (ColumnarScan) on _hyper_13_139_chunk r_108 -> Seq Scan on compress_hyper_14_842_chunk -> Custom Scan (ColumnarScan) on _hyper_13_140_chunk r_109 -> Seq Scan on compress_hyper_14_843_chunk -> Custom Scan (ColumnarScan) on _hyper_13_141_chunk r_110 -> Seq Scan on compress_hyper_14_844_chunk -> Custom Scan (ColumnarScan) on _hyper_13_142_chunk r_111 -> Seq Scan on compress_hyper_14_845_chunk -> Custom Scan (ColumnarScan) on _hyper_13_143_chunk r_112 -> Seq Scan on compress_hyper_14_846_chunk -> Custom Scan (ColumnarScan) on _hyper_13_144_chunk r_113 -> Seq Scan on compress_hyper_14_847_chunk -> Custom Scan (ColumnarScan) on _hyper_13_145_chunk r_114 -> Seq Scan on compress_hyper_14_848_chunk -> Custom Scan (ColumnarScan) on _hyper_13_146_chunk r_115 -> Seq Scan on compress_hyper_14_849_chunk -> Custom Scan (ColumnarScan) on _hyper_13_147_chunk r_116 -> Seq Scan on compress_hyper_14_850_chunk -> Custom Scan (ColumnarScan) on _hyper_13_148_chunk r_117 -> Seq Scan on compress_hyper_14_851_chunk -> Custom Scan (ColumnarScan) on _hyper_13_149_chunk r_118 -> Seq Scan on compress_hyper_14_852_chunk -> Custom Scan (ColumnarScan) on _hyper_13_150_chunk r_119 -> Seq Scan on compress_hyper_14_853_chunk -> Custom Scan (ColumnarScan) on _hyper_13_151_chunk r_120 -> Seq Scan on compress_hyper_14_854_chunk -> Custom Scan (ColumnarScan) on _hyper_13_152_chunk r_121 -> Seq Scan on compress_hyper_14_855_chunk -> Custom Scan (ColumnarScan) on _hyper_13_153_chunk r_122 -> Seq Scan on compress_hyper_14_856_chunk -> Custom Scan (ColumnarScan) on _hyper_13_154_chunk r_123 -> Seq Scan on compress_hyper_14_857_chunk -> Custom Scan (ColumnarScan) on _hyper_13_155_chunk r_124 -> Seq Scan on compress_hyper_14_858_chunk -> Custom Scan (ColumnarScan) on _hyper_13_156_chunk r_125 -> Seq Scan on compress_hyper_14_859_chunk -> Custom Scan (ColumnarScan) on _hyper_13_157_chunk r_126 -> Seq Scan on compress_hyper_14_860_chunk -> Custom Scan (ColumnarScan) on _hyper_13_158_chunk r_127 -> Seq Scan on compress_hyper_14_861_chunk -> Custom Scan (ColumnarScan) on _hyper_13_159_chunk r_128 -> Seq Scan on compress_hyper_14_862_chunk -> Custom Scan (ColumnarScan) on _hyper_13_160_chunk r_129 -> Seq Scan on compress_hyper_14_863_chunk -> Custom Scan (ColumnarScan) on _hyper_13_161_chunk r_130 -> Seq Scan on compress_hyper_14_864_chunk -> Custom Scan (ColumnarScan) on _hyper_13_162_chunk r_131 -> Seq Scan on compress_hyper_14_865_chunk -> Custom Scan (ColumnarScan) on _hyper_13_163_chunk r_132 -> Seq Scan on compress_hyper_14_866_chunk -> Custom Scan (ColumnarScan) on _hyper_13_164_chunk r_133 -> Seq Scan on compress_hyper_14_867_chunk -> Custom Scan (ColumnarScan) on _hyper_13_165_chunk r_134 -> Seq Scan on compress_hyper_14_868_chunk -> Custom Scan (ColumnarScan) on _hyper_13_166_chunk r_135 -> Seq Scan on compress_hyper_14_869_chunk -> Custom Scan (ColumnarScan) on _hyper_13_167_chunk r_136 -> Seq Scan on compress_hyper_14_870_chunk -> Custom Scan (ColumnarScan) on _hyper_13_168_chunk r_137 -> Seq Scan on compress_hyper_14_871_chunk -> Custom Scan (ColumnarScan) on _hyper_13_169_chunk r_138 -> Seq Scan on compress_hyper_14_872_chunk -> Custom Scan (ColumnarScan) on _hyper_13_170_chunk r_139 -> Seq Scan on compress_hyper_14_873_chunk -> Custom Scan (ColumnarScan) on _hyper_13_171_chunk r_140 -> Seq Scan on compress_hyper_14_874_chunk -> Custom Scan (ColumnarScan) on _hyper_13_172_chunk r_141 -> Seq Scan on compress_hyper_14_875_chunk -> Custom Scan (ColumnarScan) on _hyper_13_173_chunk r_142 -> Seq Scan on compress_hyper_14_876_chunk -> Custom Scan (ColumnarScan) on _hyper_13_174_chunk r_143 -> Seq Scan on compress_hyper_14_877_chunk -> Custom Scan (ColumnarScan) on _hyper_13_175_chunk r_144 -> Seq Scan on compress_hyper_14_878_chunk -> Custom Scan (ColumnarScan) on _hyper_13_176_chunk r_145 -> Seq Scan on compress_hyper_14_879_chunk -> Custom Scan (ColumnarScan) on _hyper_13_177_chunk r_146 -> Seq Scan on compress_hyper_14_880_chunk -> Custom Scan (ColumnarScan) on _hyper_13_178_chunk r_147 -> Seq Scan on compress_hyper_14_881_chunk -> Custom Scan (ColumnarScan) on _hyper_13_179_chunk r_148 -> Seq Scan on compress_hyper_14_882_chunk -> Custom Scan (ColumnarScan) on _hyper_13_180_chunk r_149 -> Seq Scan on compress_hyper_14_883_chunk -> Custom Scan (ColumnarScan) on _hyper_13_181_chunk r_150 -> Seq Scan on compress_hyper_14_884_chunk -> Custom Scan (ColumnarScan) on _hyper_13_182_chunk r_151 -> Seq Scan on compress_hyper_14_885_chunk -> Custom Scan (ColumnarScan) on _hyper_13_183_chunk r_152 -> Seq Scan on compress_hyper_14_886_chunk -> Custom Scan (ColumnarScan) on _hyper_13_184_chunk r_153 -> Seq Scan on compress_hyper_14_887_chunk -> Custom Scan (ColumnarScan) on _hyper_13_185_chunk r_154 -> Seq Scan on compress_hyper_14_888_chunk -> Custom Scan (ColumnarScan) on _hyper_13_186_chunk r_155 -> Seq Scan on compress_hyper_14_889_chunk -> Custom Scan (ColumnarScan) on _hyper_13_187_chunk r_156 -> Seq Scan on compress_hyper_14_890_chunk -> Custom Scan (ColumnarScan) on _hyper_13_188_chunk r_157 -> Seq Scan on compress_hyper_14_891_chunk -> Custom Scan (ColumnarScan) on _hyper_13_189_chunk r_158 -> Seq Scan on compress_hyper_14_892_chunk -> Custom Scan (ColumnarScan) on _hyper_13_190_chunk r_159 -> Seq Scan on compress_hyper_14_893_chunk -> Custom Scan (ColumnarScan) on _hyper_13_191_chunk r_160 -> Seq Scan on compress_hyper_14_894_chunk -> Custom Scan (ColumnarScan) on _hyper_13_192_chunk r_161 -> Seq Scan on compress_hyper_14_895_chunk -> Custom Scan (ColumnarScan) on _hyper_13_193_chunk r_162 -> Seq Scan on compress_hyper_14_896_chunk -> Custom Scan (ColumnarScan) on _hyper_13_194_chunk r_163 -> Seq Scan on compress_hyper_14_897_chunk -> Custom Scan (ColumnarScan) on _hyper_13_195_chunk r_164 -> Seq Scan on compress_hyper_14_898_chunk -> Custom Scan (ColumnarScan) on _hyper_13_196_chunk r_165 -> Seq Scan on compress_hyper_14_899_chunk -> Custom Scan (ColumnarScan) on _hyper_13_197_chunk r_166 -> Seq Scan on compress_hyper_14_900_chunk -> Custom Scan (ColumnarScan) on _hyper_13_198_chunk r_167 -> Seq Scan on compress_hyper_14_901_chunk -> Custom Scan (ColumnarScan) on _hyper_13_199_chunk r_168 -> Seq Scan on compress_hyper_14_902_chunk -> Custom Scan (ColumnarScan) on _hyper_13_200_chunk r_169 -> Seq Scan on compress_hyper_14_903_chunk -> Custom Scan (ColumnarScan) on _hyper_13_201_chunk r_170 -> Seq Scan on compress_hyper_14_904_chunk -> Custom Scan (ColumnarScan) on _hyper_13_202_chunk r_171 -> Seq Scan on compress_hyper_14_905_chunk -> Custom Scan (ColumnarScan) on _hyper_13_203_chunk r_172 -> Seq Scan on compress_hyper_14_906_chunk -> Custom Scan (ColumnarScan) on _hyper_13_204_chunk r_173 -> Seq Scan on compress_hyper_14_907_chunk -> Custom Scan (ColumnarScan) on _hyper_13_205_chunk r_174 -> Seq Scan on compress_hyper_14_908_chunk -> Custom Scan (ColumnarScan) on _hyper_13_206_chunk r_175 -> Seq Scan on compress_hyper_14_909_chunk -> Custom Scan (ColumnarScan) on _hyper_13_207_chunk r_176 -> Seq Scan on compress_hyper_14_910_chunk -> Custom Scan (ColumnarScan) on _hyper_13_208_chunk r_177 -> Seq Scan on compress_hyper_14_911_chunk -> Custom Scan (ColumnarScan) on _hyper_13_209_chunk r_178 -> Seq Scan on compress_hyper_14_912_chunk -> Custom Scan (ColumnarScan) on _hyper_13_210_chunk r_179 -> Seq Scan on compress_hyper_14_913_chunk -> Custom Scan (ColumnarScan) on _hyper_13_211_chunk r_180 -> Seq Scan on compress_hyper_14_914_chunk -> Custom Scan (ColumnarScan) on _hyper_13_212_chunk r_181 -> Seq Scan on compress_hyper_14_915_chunk -> Custom Scan (ColumnarScan) on _hyper_13_213_chunk r_182 -> Seq Scan on compress_hyper_14_916_chunk -> Custom Scan (ColumnarScan) on _hyper_13_214_chunk r_183 -> Seq Scan on compress_hyper_14_917_chunk -> Custom Scan (ColumnarScan) on _hyper_13_215_chunk r_184 -> Seq Scan on compress_hyper_14_918_chunk -> Custom Scan (ColumnarScan) on _hyper_13_216_chunk r_185 -> Seq Scan on compress_hyper_14_919_chunk -> Custom Scan (ColumnarScan) on _hyper_13_217_chunk r_186 -> Seq Scan on compress_hyper_14_920_chunk -> Custom Scan (ColumnarScan) on _hyper_13_218_chunk r_187 -> Seq Scan on compress_hyper_14_921_chunk -> Custom Scan (ColumnarScan) on _hyper_13_219_chunk r_188 -> Seq Scan on compress_hyper_14_922_chunk -> Custom Scan (ColumnarScan) on _hyper_13_220_chunk r_189 -> Seq Scan on compress_hyper_14_923_chunk -> Custom Scan (ColumnarScan) on _hyper_13_221_chunk r_190 -> Seq Scan on compress_hyper_14_924_chunk -> Custom Scan (ColumnarScan) on _hyper_13_222_chunk r_191 -> Seq Scan on compress_hyper_14_925_chunk -> Custom Scan (ColumnarScan) on _hyper_13_223_chunk r_192 -> Seq Scan on compress_hyper_14_926_chunk -> Custom Scan (ColumnarScan) on _hyper_13_224_chunk r_193 -> Seq Scan on compress_hyper_14_927_chunk -> Custom Scan (ColumnarScan) on _hyper_13_225_chunk r_194 -> Seq Scan on compress_hyper_14_928_chunk -> Custom Scan (ColumnarScan) on _hyper_13_226_chunk r_195 -> Seq Scan on compress_hyper_14_929_chunk -> Custom Scan (ColumnarScan) on _hyper_13_227_chunk r_196 -> Seq Scan on compress_hyper_14_930_chunk -> Custom Scan (ColumnarScan) on _hyper_13_228_chunk r_197 -> Seq Scan on compress_hyper_14_931_chunk -> Custom Scan (ColumnarScan) on _hyper_13_229_chunk r_198 -> Seq Scan on compress_hyper_14_932_chunk -> Custom Scan (ColumnarScan) on _hyper_13_230_chunk r_199 -> Seq Scan on compress_hyper_14_933_chunk -> Custom Scan (ColumnarScan) on _hyper_13_231_chunk r_200 -> Seq Scan on compress_hyper_14_934_chunk -> Custom Scan (ColumnarScan) on _hyper_13_232_chunk r_201 -> Seq Scan on compress_hyper_14_935_chunk -> Custom Scan (ColumnarScan) on _hyper_13_233_chunk r_202 -> Seq Scan on compress_hyper_14_936_chunk -> Custom Scan (ColumnarScan) on _hyper_13_234_chunk r_203 -> Seq Scan on compress_hyper_14_937_chunk -> Custom Scan (ColumnarScan) on _hyper_13_235_chunk r_204 -> Seq Scan on compress_hyper_14_938_chunk -> Custom Scan (ColumnarScan) on _hyper_13_236_chunk r_205 -> Seq Scan on compress_hyper_14_939_chunk -> Custom Scan (ColumnarScan) on _hyper_13_237_chunk r_206 -> Seq Scan on compress_hyper_14_940_chunk -> Custom Scan (ColumnarScan) on _hyper_13_238_chunk r_207 -> Seq Scan on compress_hyper_14_941_chunk -> Custom Scan (ColumnarScan) on _hyper_13_239_chunk r_208 -> Seq Scan on compress_hyper_14_942_chunk -> Custom Scan (ColumnarScan) on _hyper_13_240_chunk r_209 -> Seq Scan on compress_hyper_14_943_chunk -> Custom Scan (ColumnarScan) on _hyper_13_241_chunk r_210 -> Seq Scan on compress_hyper_14_944_chunk -> Custom Scan (ColumnarScan) on _hyper_13_242_chunk r_211 -> Seq Scan on compress_hyper_14_945_chunk -> Custom Scan (ColumnarScan) on _hyper_13_243_chunk r_212 -> Seq Scan on compress_hyper_14_946_chunk -> Custom Scan (ColumnarScan) on _hyper_13_244_chunk r_213 -> Seq Scan on compress_hyper_14_947_chunk -> Custom Scan (ColumnarScan) on _hyper_13_245_chunk r_214 -> Seq Scan on compress_hyper_14_948_chunk -> Custom Scan (ColumnarScan) on _hyper_13_246_chunk r_215 -> Seq Scan on compress_hyper_14_949_chunk -> Custom Scan (ColumnarScan) on _hyper_13_247_chunk r_216 -> Seq Scan on compress_hyper_14_950_chunk -> Custom Scan (ColumnarScan) on _hyper_13_248_chunk r_217 -> Seq Scan on compress_hyper_14_951_chunk -> Custom Scan (ColumnarScan) on _hyper_13_249_chunk r_218 -> Seq Scan on compress_hyper_14_952_chunk -> Custom Scan (ColumnarScan) on _hyper_13_250_chunk r_219 -> Seq Scan on compress_hyper_14_953_chunk -> Custom Scan (ColumnarScan) on _hyper_13_251_chunk r_220 -> Seq Scan on compress_hyper_14_954_chunk -> Custom Scan (ColumnarScan) on _hyper_13_252_chunk r_221 -> Seq Scan on compress_hyper_14_955_chunk -> Custom Scan (ColumnarScan) on _hyper_13_253_chunk r_222 -> Seq Scan on compress_hyper_14_956_chunk -> Custom Scan (ColumnarScan) on _hyper_13_254_chunk r_223 -> Seq Scan on compress_hyper_14_957_chunk -> Custom Scan (ColumnarScan) on _hyper_13_255_chunk r_224 -> Seq Scan on compress_hyper_14_958_chunk -> Custom Scan (ColumnarScan) on _hyper_13_256_chunk r_225 -> Seq Scan on compress_hyper_14_959_chunk -> Custom Scan (ColumnarScan) on _hyper_13_257_chunk r_226 -> Seq Scan on compress_hyper_14_960_chunk -> Custom Scan (ColumnarScan) on _hyper_13_258_chunk r_227 -> Seq Scan on compress_hyper_14_961_chunk -> Custom Scan (ColumnarScan) on _hyper_13_259_chunk r_228 -> Seq Scan on compress_hyper_14_962_chunk -> Custom Scan (ColumnarScan) on _hyper_13_260_chunk r_229 -> Seq Scan on compress_hyper_14_963_chunk -> Custom Scan (ColumnarScan) on _hyper_13_261_chunk r_230 -> Seq Scan on compress_hyper_14_964_chunk -> Custom Scan (ColumnarScan) on _hyper_13_262_chunk r_231 -> Seq Scan on compress_hyper_14_965_chunk -> Custom Scan (ColumnarScan) on _hyper_13_263_chunk r_232 -> Seq Scan on compress_hyper_14_966_chunk -> Custom Scan (ColumnarScan) on _hyper_13_264_chunk r_233 -> Seq Scan on compress_hyper_14_967_chunk -> Custom Scan (ColumnarScan) on _hyper_13_265_chunk r_234 -> Seq Scan on compress_hyper_14_968_chunk -> Custom Scan (ColumnarScan) on _hyper_13_266_chunk r_235 -> Seq Scan on compress_hyper_14_969_chunk -> Custom Scan (ColumnarScan) on _hyper_13_267_chunk r_236 -> Seq Scan on compress_hyper_14_970_chunk -> Custom Scan (ColumnarScan) on _hyper_13_268_chunk r_237 -> Seq Scan on compress_hyper_14_971_chunk -> Custom Scan (ColumnarScan) on _hyper_13_269_chunk r_238 -> Seq Scan on compress_hyper_14_972_chunk -> Custom Scan (ColumnarScan) on _hyper_13_270_chunk r_239 -> Seq Scan on compress_hyper_14_973_chunk -> Custom Scan (ColumnarScan) on _hyper_13_271_chunk r_240 -> Seq Scan on compress_hyper_14_974_chunk -> Custom Scan (ColumnarScan) on _hyper_13_272_chunk r_241 -> Seq Scan on compress_hyper_14_975_chunk -> Custom Scan (ColumnarScan) on _hyper_13_273_chunk r_242 -> Seq Scan on compress_hyper_14_976_chunk -> Custom Scan (ColumnarScan) on _hyper_13_274_chunk r_243 -> Seq Scan on compress_hyper_14_977_chunk -> Custom Scan (ColumnarScan) on _hyper_13_275_chunk r_244 -> Seq Scan on compress_hyper_14_978_chunk -> Custom Scan (ColumnarScan) on _hyper_13_276_chunk r_245 -> Seq Scan on compress_hyper_14_979_chunk -> Custom Scan (ColumnarScan) on _hyper_13_277_chunk r_246 -> Seq Scan on compress_hyper_14_980_chunk -> Custom Scan (ColumnarScan) on _hyper_13_278_chunk r_247 -> Seq Scan on compress_hyper_14_981_chunk -> Custom Scan (ColumnarScan) on _hyper_13_279_chunk r_248 -> Seq Scan on compress_hyper_14_982_chunk -> Custom Scan (ColumnarScan) on _hyper_13_280_chunk r_249 -> Seq Scan on compress_hyper_14_983_chunk -> Custom Scan (ColumnarScan) on _hyper_13_281_chunk r_250 -> Seq Scan on compress_hyper_14_984_chunk -> Custom Scan (ColumnarScan) on _hyper_13_282_chunk r_251 -> Seq Scan on compress_hyper_14_985_chunk -> Custom Scan (ColumnarScan) on _hyper_13_283_chunk r_252 -> Seq Scan on compress_hyper_14_986_chunk -> Custom Scan (ColumnarScan) on _hyper_13_284_chunk r_253 -> Seq Scan on compress_hyper_14_987_chunk -> Custom Scan (ColumnarScan) on _hyper_13_285_chunk r_254 -> Seq Scan on compress_hyper_14_988_chunk -> Custom Scan (ColumnarScan) on _hyper_13_286_chunk r_255 -> Seq Scan on compress_hyper_14_989_chunk -> Custom Scan (ColumnarScan) on _hyper_13_287_chunk r_256 -> Seq Scan on compress_hyper_14_990_chunk -> Custom Scan (ColumnarScan) on _hyper_13_288_chunk r_257 -> Seq Scan on compress_hyper_14_991_chunk -> Custom Scan (ColumnarScan) on _hyper_13_289_chunk r_258 -> Seq Scan on compress_hyper_14_992_chunk -> Custom Scan (ColumnarScan) on _hyper_13_290_chunk r_259 -> Seq Scan on compress_hyper_14_993_chunk -> Custom Scan (ColumnarScan) on _hyper_13_291_chunk r_260 -> Seq Scan on compress_hyper_14_994_chunk -> Custom Scan (ColumnarScan) on _hyper_13_292_chunk r_261 -> Seq Scan on compress_hyper_14_995_chunk -> Custom Scan (ColumnarScan) on _hyper_13_293_chunk r_262 -> Seq Scan on compress_hyper_14_996_chunk -> Custom Scan (ColumnarScan) on _hyper_13_294_chunk r_263 -> Seq Scan on compress_hyper_14_997_chunk -> Custom Scan (ColumnarScan) on _hyper_13_295_chunk r_264 -> Seq Scan on compress_hyper_14_998_chunk -> Custom Scan (ColumnarScan) on _hyper_13_296_chunk r_265 -> Seq Scan on compress_hyper_14_999_chunk -> Custom Scan (ColumnarScan) on _hyper_13_297_chunk r_266 -> Seq Scan on compress_hyper_14_1000_chunk -> Custom Scan (ColumnarScan) on _hyper_13_298_chunk r_267 -> Seq Scan on compress_hyper_14_1001_chunk -> Custom Scan (ColumnarScan) on _hyper_13_299_chunk r_268 -> Seq Scan on compress_hyper_14_1002_chunk -> Custom Scan (ColumnarScan) on _hyper_13_300_chunk r_269 -> Seq Scan on compress_hyper_14_1003_chunk -> Custom Scan (ColumnarScan) on _hyper_13_301_chunk r_270 -> Seq Scan on compress_hyper_14_1004_chunk -> Custom Scan (ColumnarScan) on _hyper_13_302_chunk r_271 -> Seq Scan on compress_hyper_14_1005_chunk -> Custom Scan (ColumnarScan) on _hyper_13_303_chunk r_272 -> Seq Scan on compress_hyper_14_1006_chunk -> Custom Scan (ColumnarScan) on _hyper_13_304_chunk r_273 -> Seq Scan on compress_hyper_14_1007_chunk -> Custom Scan (ColumnarScan) on _hyper_13_305_chunk r_274 -> Seq Scan on compress_hyper_14_1008_chunk -> Custom Scan (ColumnarScan) on _hyper_13_306_chunk r_275 -> Seq Scan on compress_hyper_14_1009_chunk -> Custom Scan (ColumnarScan) on _hyper_13_307_chunk r_276 -> Seq Scan on compress_hyper_14_1010_chunk -> Custom Scan (ColumnarScan) on _hyper_13_308_chunk r_277 -> Seq Scan on compress_hyper_14_1011_chunk -> Custom Scan (ColumnarScan) on _hyper_13_309_chunk r_278 -> Seq Scan on compress_hyper_14_1012_chunk -> Custom Scan (ColumnarScan) on _hyper_13_310_chunk r_279 -> Seq Scan on compress_hyper_14_1013_chunk -> Custom Scan (ColumnarScan) on _hyper_13_311_chunk r_280 -> Seq Scan on compress_hyper_14_1014_chunk -> Custom Scan (ColumnarScan) on _hyper_13_312_chunk r_281 -> Seq Scan on compress_hyper_14_1015_chunk -> Custom Scan (ColumnarScan) on _hyper_13_313_chunk r_282 -> Seq Scan on compress_hyper_14_1016_chunk -> Custom Scan (ColumnarScan) on _hyper_13_314_chunk r_283 -> Seq Scan on compress_hyper_14_1017_chunk -> Custom Scan (ColumnarScan) on _hyper_13_315_chunk r_284 -> Seq Scan on compress_hyper_14_1018_chunk -> Custom Scan (ColumnarScan) on _hyper_13_316_chunk r_285 -> Seq Scan on compress_hyper_14_1019_chunk -> Custom Scan (ColumnarScan) on _hyper_13_317_chunk r_286 -> Seq Scan on compress_hyper_14_1020_chunk -> Custom Scan (ColumnarScan) on _hyper_13_318_chunk r_287 -> Seq Scan on compress_hyper_14_1021_chunk -> Custom Scan (ColumnarScan) on _hyper_13_319_chunk r_288 -> Seq Scan on compress_hyper_14_1022_chunk -> Custom Scan (ColumnarScan) on _hyper_13_320_chunk r_289 -> Seq Scan on compress_hyper_14_1023_chunk -> Custom Scan (ColumnarScan) on _hyper_13_321_chunk r_290 -> Seq Scan on compress_hyper_14_1024_chunk -> Custom Scan (ColumnarScan) on _hyper_13_322_chunk r_291 -> Seq Scan on compress_hyper_14_1025_chunk -> Custom Scan (ColumnarScan) on _hyper_13_323_chunk r_292 -> Seq Scan on compress_hyper_14_1026_chunk -> Custom Scan (ColumnarScan) on _hyper_13_324_chunk r_293 -> Seq Scan on compress_hyper_14_1027_chunk -> Custom Scan (ColumnarScan) on _hyper_13_325_chunk r_294 -> Seq Scan on compress_hyper_14_1028_chunk -> Custom Scan (ColumnarScan) on _hyper_13_326_chunk r_295 -> Seq Scan on compress_hyper_14_1029_chunk -> Custom Scan (ColumnarScan) on _hyper_13_327_chunk r_296 -> Seq Scan on compress_hyper_14_1030_chunk -> Custom Scan (ColumnarScan) on _hyper_13_328_chunk r_297 -> Seq Scan on compress_hyper_14_1031_chunk -> Custom Scan (ColumnarScan) on _hyper_13_329_chunk r_298 -> Seq Scan on compress_hyper_14_1032_chunk -> Custom Scan (ColumnarScan) on _hyper_13_330_chunk r_299 -> Seq Scan on compress_hyper_14_1033_chunk -> Custom Scan (ColumnarScan) on _hyper_13_331_chunk r_300 -> Seq Scan on compress_hyper_14_1034_chunk -> Custom Scan (ColumnarScan) on _hyper_13_332_chunk r_301 -> Seq Scan on compress_hyper_14_1035_chunk -> Custom Scan (ColumnarScan) on _hyper_13_333_chunk r_302 -> Seq Scan on compress_hyper_14_1036_chunk -> Custom Scan (ColumnarScan) on _hyper_13_334_chunk r_303 -> Seq Scan on compress_hyper_14_1037_chunk -> Custom Scan (ColumnarScan) on _hyper_13_335_chunk r_304 -> Seq Scan on compress_hyper_14_1038_chunk -> Custom Scan (ColumnarScan) on _hyper_13_336_chunk r_305 -> Seq Scan on compress_hyper_14_1039_chunk -> Custom Scan (ColumnarScan) on _hyper_13_337_chunk r_306 -> Seq Scan on compress_hyper_14_1040_chunk -> Custom Scan (ColumnarScan) on _hyper_13_338_chunk r_307 -> Seq Scan on compress_hyper_14_1041_chunk -> Custom Scan (ColumnarScan) on _hyper_13_339_chunk r_308 -> Seq Scan on compress_hyper_14_1042_chunk -> Custom Scan (ColumnarScan) on _hyper_13_340_chunk r_309 -> Seq Scan on compress_hyper_14_1043_chunk -> Custom Scan (ColumnarScan) on _hyper_13_341_chunk r_310 -> Seq Scan on compress_hyper_14_1044_chunk -> Custom Scan (ColumnarScan) on _hyper_13_342_chunk r_311 -> Seq Scan on compress_hyper_14_1045_chunk -> Custom Scan (ColumnarScan) on _hyper_13_343_chunk r_312 -> Seq Scan on compress_hyper_14_1046_chunk -> Custom Scan (ColumnarScan) on _hyper_13_344_chunk r_313 -> Seq Scan on compress_hyper_14_1047_chunk -> Custom Scan (ColumnarScan) on _hyper_13_345_chunk r_314 -> Seq Scan on compress_hyper_14_1048_chunk -> Custom Scan (ColumnarScan) on _hyper_13_346_chunk r_315 -> Seq Scan on compress_hyper_14_1049_chunk -> Custom Scan (ColumnarScan) on _hyper_13_347_chunk r_316 -> Seq Scan on compress_hyper_14_1050_chunk -> Custom Scan (ColumnarScan) on _hyper_13_348_chunk r_317 -> Seq Scan on compress_hyper_14_1051_chunk -> Custom Scan (ColumnarScan) on _hyper_13_349_chunk r_318 -> Seq Scan on compress_hyper_14_1052_chunk -> Custom Scan (ColumnarScan) on _hyper_13_350_chunk r_319 -> Seq Scan on compress_hyper_14_1053_chunk -> Custom Scan (ColumnarScan) on _hyper_13_351_chunk r_320 -> Seq Scan on compress_hyper_14_1054_chunk -> Custom Scan (ColumnarScan) on _hyper_13_352_chunk r_321 -> Seq Scan on compress_hyper_14_1055_chunk -> Custom Scan (ColumnarScan) on _hyper_13_353_chunk r_322 -> Seq Scan on compress_hyper_14_1056_chunk -> Custom Scan (ColumnarScan) on _hyper_13_354_chunk r_323 -> Seq Scan on compress_hyper_14_1057_chunk -> Custom Scan (ColumnarScan) on _hyper_13_355_chunk r_324 -> Seq Scan on compress_hyper_14_1058_chunk -> Custom Scan (ColumnarScan) on _hyper_13_356_chunk r_325 -> Seq Scan on compress_hyper_14_1059_chunk -> Custom Scan (ColumnarScan) on _hyper_13_357_chunk r_326 -> Seq Scan on compress_hyper_14_1060_chunk -> Custom Scan (ColumnarScan) on _hyper_13_358_chunk r_327 -> Seq Scan on compress_hyper_14_1061_chunk -> Custom Scan (ColumnarScan) on _hyper_13_359_chunk r_328 -> Seq Scan on compress_hyper_14_1062_chunk -> Custom Scan (ColumnarScan) on _hyper_13_360_chunk r_329 -> Seq Scan on compress_hyper_14_1063_chunk -> Custom Scan (ColumnarScan) on _hyper_13_361_chunk r_330 -> Seq Scan on compress_hyper_14_1064_chunk -> Custom Scan (ColumnarScan) on _hyper_13_362_chunk r_331 -> Seq Scan on compress_hyper_14_1065_chunk -> Custom Scan (ColumnarScan) on _hyper_13_363_chunk r_332 -> Seq Scan on compress_hyper_14_1066_chunk -> Custom Scan (ColumnarScan) on _hyper_13_364_chunk r_333 -> Seq Scan on compress_hyper_14_1067_chunk -> Custom Scan (ColumnarScan) on _hyper_13_365_chunk r_334 -> Seq Scan on compress_hyper_14_1068_chunk -> Custom Scan (ColumnarScan) on _hyper_13_366_chunk r_335 -> Seq Scan on compress_hyper_14_1069_chunk -> Custom Scan (ColumnarScan) on _hyper_13_367_chunk r_336 -> Seq Scan on compress_hyper_14_1070_chunk -> Custom Scan (ColumnarScan) on _hyper_13_368_chunk r_337 -> Seq Scan on compress_hyper_14_1071_chunk -> Custom Scan (ColumnarScan) on _hyper_13_369_chunk r_338 -> Seq Scan on compress_hyper_14_1072_chunk -> Custom Scan (ColumnarScan) on _hyper_13_370_chunk r_339 -> Seq Scan on compress_hyper_14_1073_chunk -> Custom Scan (ColumnarScan) on _hyper_13_371_chunk r_340 -> Seq Scan on compress_hyper_14_1074_chunk -> Custom Scan (ColumnarScan) on _hyper_13_372_chunk r_341 -> Seq Scan on compress_hyper_14_1075_chunk -> Custom Scan (ColumnarScan) on _hyper_13_373_chunk r_342 -> Seq Scan on compress_hyper_14_1076_chunk -> Custom Scan (ColumnarScan) on _hyper_13_374_chunk r_343 -> Seq Scan on compress_hyper_14_1077_chunk -> Custom Scan (ColumnarScan) on _hyper_13_375_chunk r_344 -> Seq Scan on compress_hyper_14_1078_chunk -> Custom Scan (ColumnarScan) on _hyper_13_376_chunk r_345 -> Seq Scan on compress_hyper_14_1079_chunk -> Custom Scan (ColumnarScan) on _hyper_13_377_chunk r_346 -> Seq Scan on compress_hyper_14_1080_chunk -> Custom Scan (ColumnarScan) on _hyper_13_378_chunk r_347 -> Seq Scan on compress_hyper_14_1081_chunk -> Custom Scan (ColumnarScan) on _hyper_13_379_chunk r_348 -> Seq Scan on compress_hyper_14_1082_chunk -> Custom Scan (ColumnarScan) on _hyper_13_380_chunk r_349 -> Seq Scan on compress_hyper_14_1083_chunk -> Custom Scan (ColumnarScan) on _hyper_13_381_chunk r_350 -> Seq Scan on compress_hyper_14_1084_chunk -> Custom Scan (ColumnarScan) on _hyper_13_382_chunk r_351 -> Seq Scan on compress_hyper_14_1085_chunk -> Custom Scan (ColumnarScan) on _hyper_13_383_chunk r_352 -> Seq Scan on compress_hyper_14_1086_chunk -> Custom Scan (ColumnarScan) on _hyper_13_384_chunk r_353 -> Seq Scan on compress_hyper_14_1087_chunk -> Custom Scan (ColumnarScan) on _hyper_13_385_chunk r_354 -> Seq Scan on compress_hyper_14_1088_chunk -> Custom Scan (ColumnarScan) on _hyper_13_386_chunk r_355 -> Seq Scan on compress_hyper_14_1089_chunk -> Custom Scan (ColumnarScan) on _hyper_13_387_chunk r_356 -> Seq Scan on compress_hyper_14_1090_chunk -> Custom Scan (ColumnarScan) on _hyper_13_388_chunk r_357 -> Seq Scan on compress_hyper_14_1091_chunk -> Custom Scan (ColumnarScan) on _hyper_13_389_chunk r_358 -> Seq Scan on compress_hyper_14_1092_chunk -> Custom Scan (ColumnarScan) on _hyper_13_390_chunk r_359 -> Seq Scan on compress_hyper_14_1093_chunk -> Custom Scan (ColumnarScan) on _hyper_13_391_chunk r_360 -> Seq Scan on compress_hyper_14_1094_chunk -> Custom Scan (ColumnarScan) on _hyper_13_392_chunk r_361 -> Seq Scan on compress_hyper_14_1095_chunk -> Custom Scan (ColumnarScan) on _hyper_13_393_chunk r_362 -> Seq Scan on compress_hyper_14_1096_chunk -> Custom Scan (ColumnarScan) on _hyper_13_394_chunk r_363 -> Seq Scan on compress_hyper_14_1097_chunk -> Custom Scan (ColumnarScan) on _hyper_13_395_chunk r_364 -> Seq Scan on compress_hyper_14_1098_chunk -> Custom Scan (ColumnarScan) on _hyper_13_396_chunk r_365 -> Seq Scan on compress_hyper_14_1099_chunk -> Custom Scan (ColumnarScan) on _hyper_13_397_chunk r_366 -> Seq Scan on compress_hyper_14_1100_chunk -> Custom Scan (ColumnarScan) on _hyper_13_398_chunk r_367 -> Seq Scan on compress_hyper_14_1101_chunk -> Custom Scan (ColumnarScan) on _hyper_13_399_chunk r_368 -> Seq Scan on compress_hyper_14_1102_chunk -> Custom Scan (ColumnarScan) on _hyper_13_400_chunk r_369 -> Seq Scan on compress_hyper_14_1103_chunk -> Custom Scan (ColumnarScan) on _hyper_13_401_chunk r_370 -> Seq Scan on compress_hyper_14_1104_chunk -> Custom Scan (ColumnarScan) on _hyper_13_402_chunk r_371 -> Seq Scan on compress_hyper_14_1105_chunk -> Custom Scan (ColumnarScan) on _hyper_13_403_chunk r_372 -> Seq Scan on compress_hyper_14_1106_chunk -> Custom Scan (ColumnarScan) on _hyper_13_404_chunk r_373 -> Seq Scan on compress_hyper_14_1107_chunk -> Custom Scan (ColumnarScan) on _hyper_13_405_chunk r_374 -> Seq Scan on compress_hyper_14_1108_chunk -> Custom Scan (ColumnarScan) on _hyper_13_406_chunk r_375 -> Seq Scan on compress_hyper_14_1109_chunk -> Custom Scan (ColumnarScan) on _hyper_13_407_chunk r_376 -> Seq Scan on compress_hyper_14_1110_chunk -> Custom Scan (ColumnarScan) on _hyper_13_408_chunk r_377 -> Seq Scan on compress_hyper_14_1111_chunk -> Custom Scan (ColumnarScan) on _hyper_13_409_chunk r_378 -> Seq Scan on compress_hyper_14_1112_chunk -> Custom Scan (ColumnarScan) on _hyper_13_410_chunk r_379 -> Seq Scan on compress_hyper_14_1113_chunk -> Custom Scan (ColumnarScan) on _hyper_13_411_chunk r_380 -> Seq Scan on compress_hyper_14_1114_chunk -> Custom Scan (ColumnarScan) on _hyper_13_412_chunk r_381 -> Seq Scan on compress_hyper_14_1115_chunk -> Custom Scan (ColumnarScan) on _hyper_13_413_chunk r_382 -> Seq Scan on compress_hyper_14_1116_chunk -> Custom Scan (ColumnarScan) on _hyper_13_414_chunk r_383 -> Seq Scan on compress_hyper_14_1117_chunk -> Custom Scan (ColumnarScan) on _hyper_13_415_chunk r_384 -> Seq Scan on compress_hyper_14_1118_chunk -> Custom Scan (ColumnarScan) on _hyper_13_416_chunk r_385 -> Seq Scan on compress_hyper_14_1119_chunk -> Custom Scan (ColumnarScan) on _hyper_13_417_chunk r_386 -> Seq Scan on compress_hyper_14_1120_chunk -> Custom Scan (ColumnarScan) on _hyper_13_418_chunk r_387 -> Seq Scan on compress_hyper_14_1121_chunk -> Custom Scan (ColumnarScan) on _hyper_13_419_chunk r_388 -> Seq Scan on compress_hyper_14_1122_chunk -> Custom Scan (ColumnarScan) on _hyper_13_420_chunk r_389 -> Seq Scan on compress_hyper_14_1123_chunk -> Custom Scan (ColumnarScan) on _hyper_13_421_chunk r_390 -> Seq Scan on compress_hyper_14_1124_chunk -> Custom Scan (ColumnarScan) on _hyper_13_422_chunk r_391 -> Seq Scan on compress_hyper_14_1125_chunk -> Custom Scan (ColumnarScan) on _hyper_13_423_chunk r_392 -> Seq Scan on compress_hyper_14_1126_chunk -> Custom Scan (ColumnarScan) on _hyper_13_424_chunk r_393 -> Seq Scan on compress_hyper_14_1127_chunk -> Custom Scan (ColumnarScan) on _hyper_13_425_chunk r_394 -> Seq Scan on compress_hyper_14_1128_chunk -> Custom Scan (ColumnarScan) on _hyper_13_426_chunk r_395 -> Seq Scan on compress_hyper_14_1129_chunk -> Custom Scan (ColumnarScan) on _hyper_13_427_chunk r_396 -> Seq Scan on compress_hyper_14_1130_chunk -> Custom Scan (ColumnarScan) on _hyper_13_428_chunk r_397 -> Seq Scan on compress_hyper_14_1131_chunk -> Custom Scan (ColumnarScan) on _hyper_13_429_chunk r_398 -> Seq Scan on compress_hyper_14_1132_chunk -> Custom Scan (ColumnarScan) on _hyper_13_430_chunk r_399 -> Seq Scan on compress_hyper_14_1133_chunk -> Custom Scan (ColumnarScan) on _hyper_13_431_chunk r_400 -> Seq Scan on compress_hyper_14_1134_chunk -> Custom Scan (ColumnarScan) on _hyper_13_432_chunk r_401 -> Seq Scan on compress_hyper_14_1135_chunk -> Custom Scan (ColumnarScan) on _hyper_13_433_chunk r_402 -> Seq Scan on compress_hyper_14_1136_chunk -> Custom Scan (ColumnarScan) on _hyper_13_434_chunk r_403 -> Seq Scan on compress_hyper_14_1137_chunk -> Custom Scan (ColumnarScan) on _hyper_13_435_chunk r_404 -> Seq Scan on compress_hyper_14_1138_chunk -> Custom Scan (ColumnarScan) on _hyper_13_436_chunk r_405 -> Seq Scan on compress_hyper_14_1139_chunk -> Custom Scan (ColumnarScan) on _hyper_13_437_chunk r_406 -> Seq Scan on compress_hyper_14_1140_chunk -> Custom Scan (ColumnarScan) on _hyper_13_438_chunk r_407 -> Seq Scan on compress_hyper_14_1141_chunk -> Custom Scan (ColumnarScan) on _hyper_13_439_chunk r_408 -> Seq Scan on compress_hyper_14_1142_chunk -> Custom Scan (ColumnarScan) on _hyper_13_440_chunk r_409 -> Seq Scan on compress_hyper_14_1143_chunk -> Custom Scan (ColumnarScan) on _hyper_13_441_chunk r_410 -> Seq Scan on compress_hyper_14_1144_chunk -> Custom Scan (ColumnarScan) on _hyper_13_442_chunk r_411 -> Seq Scan on compress_hyper_14_1145_chunk -> Custom Scan (ColumnarScan) on _hyper_13_443_chunk r_412 -> Seq Scan on compress_hyper_14_1146_chunk -> Custom Scan (ColumnarScan) on _hyper_13_444_chunk r_413 -> Seq Scan on compress_hyper_14_1147_chunk -> Custom Scan (ColumnarScan) on _hyper_13_445_chunk r_414 -> Seq Scan on compress_hyper_14_1148_chunk -> Custom Scan (ColumnarScan) on _hyper_13_446_chunk r_415 -> Seq Scan on compress_hyper_14_1149_chunk -> Custom Scan (ColumnarScan) on _hyper_13_447_chunk r_416 -> Seq Scan on compress_hyper_14_1150_chunk -> Custom Scan (ColumnarScan) on _hyper_13_448_chunk r_417 -> Seq Scan on compress_hyper_14_1151_chunk -> Custom Scan (ColumnarScan) on _hyper_13_449_chunk r_418 -> Seq Scan on compress_hyper_14_1152_chunk -> Custom Scan (ColumnarScan) on _hyper_13_450_chunk r_419 -> Seq Scan on compress_hyper_14_1153_chunk -> Custom Scan (ColumnarScan) on _hyper_13_451_chunk r_420 -> Seq Scan on compress_hyper_14_1154_chunk -> Custom Scan (ColumnarScan) on _hyper_13_452_chunk r_421 -> Seq Scan on compress_hyper_14_1155_chunk -> Custom Scan (ColumnarScan) on _hyper_13_453_chunk r_422 -> Seq Scan on compress_hyper_14_1156_chunk -> Custom Scan (ColumnarScan) on _hyper_13_454_chunk r_423 -> Seq Scan on compress_hyper_14_1157_chunk -> Custom Scan (ColumnarScan) on _hyper_13_455_chunk r_424 -> Seq Scan on compress_hyper_14_1158_chunk -> Custom Scan (ColumnarScan) on _hyper_13_456_chunk r_425 -> Seq Scan on compress_hyper_14_1159_chunk -> Custom Scan (ColumnarScan) on _hyper_13_457_chunk r_426 -> Seq Scan on compress_hyper_14_1160_chunk -> Custom Scan (ColumnarScan) on _hyper_13_458_chunk r_427 -> Seq Scan on compress_hyper_14_1161_chunk -> Custom Scan (ColumnarScan) on _hyper_13_459_chunk r_428 -> Seq Scan on compress_hyper_14_1162_chunk -> Custom Scan (ColumnarScan) on _hyper_13_460_chunk r_429 -> Seq Scan on compress_hyper_14_1163_chunk -> Custom Scan (ColumnarScan) on _hyper_13_461_chunk r_430 -> Seq Scan on compress_hyper_14_1164_chunk -> Custom Scan (ColumnarScan) on _hyper_13_462_chunk r_431 -> Seq Scan on compress_hyper_14_1165_chunk -> Custom Scan (ColumnarScan) on _hyper_13_463_chunk r_432 -> Seq Scan on compress_hyper_14_1166_chunk -> Custom Scan (ColumnarScan) on _hyper_13_464_chunk r_433 -> Seq Scan on compress_hyper_14_1167_chunk -> Custom Scan (ColumnarScan) on _hyper_13_465_chunk r_434 -> Seq Scan on compress_hyper_14_1168_chunk -> Custom Scan (ColumnarScan) on _hyper_13_466_chunk r_435 -> Seq Scan on compress_hyper_14_1169_chunk -> Custom Scan (ColumnarScan) on _hyper_13_467_chunk r_436 -> Seq Scan on compress_hyper_14_1170_chunk -> Custom Scan (ColumnarScan) on _hyper_13_468_chunk r_437 -> Seq Scan on compress_hyper_14_1171_chunk -> Custom Scan (ColumnarScan) on _hyper_13_469_chunk r_438 -> Seq Scan on compress_hyper_14_1172_chunk -> Custom Scan (ColumnarScan) on _hyper_13_470_chunk r_439 -> Seq Scan on compress_hyper_14_1173_chunk -> Custom Scan (ColumnarScan) on _hyper_13_471_chunk r_440 -> Seq Scan on compress_hyper_14_1174_chunk -> Custom Scan (ColumnarScan) on _hyper_13_472_chunk r_441 -> Seq Scan on compress_hyper_14_1175_chunk -> Custom Scan (ColumnarScan) on _hyper_13_473_chunk r_442 -> Seq Scan on compress_hyper_14_1176_chunk -> Custom Scan (ColumnarScan) on _hyper_13_474_chunk r_443 -> Seq Scan on compress_hyper_14_1177_chunk -> Custom Scan (ColumnarScan) on _hyper_13_475_chunk r_444 -> Seq Scan on compress_hyper_14_1178_chunk -> Custom Scan (ColumnarScan) on _hyper_13_476_chunk r_445 -> Seq Scan on compress_hyper_14_1179_chunk -> Custom Scan (ColumnarScan) on _hyper_13_477_chunk r_446 -> Seq Scan on compress_hyper_14_1180_chunk -> Custom Scan (ColumnarScan) on _hyper_13_478_chunk r_447 -> Seq Scan on compress_hyper_14_1181_chunk -> Custom Scan (ColumnarScan) on _hyper_13_479_chunk r_448 -> Seq Scan on compress_hyper_14_1182_chunk -> Custom Scan (ColumnarScan) on _hyper_13_480_chunk r_449 -> Seq Scan on compress_hyper_14_1183_chunk -> Custom Scan (ColumnarScan) on _hyper_13_481_chunk r_450 -> Seq Scan on compress_hyper_14_1184_chunk -> Custom Scan (ColumnarScan) on _hyper_13_482_chunk r_451 -> Seq Scan on compress_hyper_14_1185_chunk -> Custom Scan (ColumnarScan) on _hyper_13_483_chunk r_452 -> Seq Scan on compress_hyper_14_1186_chunk -> Custom Scan (ColumnarScan) on _hyper_13_484_chunk r_453 -> Seq Scan on compress_hyper_14_1187_chunk -> Custom Scan (ColumnarScan) on _hyper_13_485_chunk r_454 -> Seq Scan on compress_hyper_14_1188_chunk -> Custom Scan (ColumnarScan) on _hyper_13_486_chunk r_455 -> Seq Scan on compress_hyper_14_1189_chunk -> Custom Scan (ColumnarScan) on _hyper_13_487_chunk r_456 -> Seq Scan on compress_hyper_14_1190_chunk -> Custom Scan (ColumnarScan) on _hyper_13_488_chunk r_457 -> Seq Scan on compress_hyper_14_1191_chunk -> Custom Scan (ColumnarScan) on _hyper_13_489_chunk r_458 -> Seq Scan on compress_hyper_14_1192_chunk -> Custom Scan (ColumnarScan) on _hyper_13_490_chunk r_459 -> Seq Scan on compress_hyper_14_1193_chunk -> Custom Scan (ColumnarScan) on _hyper_13_491_chunk r_460 -> Seq Scan on compress_hyper_14_1194_chunk -> Custom Scan (ColumnarScan) on _hyper_13_492_chunk r_461 -> Seq Scan on compress_hyper_14_1195_chunk -> Custom Scan (ColumnarScan) on _hyper_13_493_chunk r_462 -> Seq Scan on compress_hyper_14_1196_chunk -> Custom Scan (ColumnarScan) on _hyper_13_494_chunk r_463 -> Seq Scan on compress_hyper_14_1197_chunk -> Custom Scan (ColumnarScan) on _hyper_13_495_chunk r_464 -> Seq Scan on compress_hyper_14_1198_chunk -> Custom Scan (ColumnarScan) on _hyper_13_496_chunk r_465 -> Seq Scan on compress_hyper_14_1199_chunk -> Custom Scan (ColumnarScan) on _hyper_13_497_chunk r_466 -> Seq Scan on compress_hyper_14_1200_chunk -> Custom Scan (ColumnarScan) on _hyper_13_498_chunk r_467 -> Seq Scan on compress_hyper_14_1201_chunk -> Custom Scan (ColumnarScan) on _hyper_13_499_chunk r_468 -> Seq Scan on compress_hyper_14_1202_chunk -> Custom Scan (ColumnarScan) on _hyper_13_500_chunk r_469 -> Seq Scan on compress_hyper_14_1203_chunk -> Custom Scan (ColumnarScan) on _hyper_13_501_chunk r_470 -> Seq Scan on compress_hyper_14_1204_chunk -> Custom Scan (ColumnarScan) on _hyper_13_502_chunk r_471 -> Seq Scan on compress_hyper_14_1205_chunk -> Custom Scan (ColumnarScan) on _hyper_13_503_chunk r_472 -> Seq Scan on compress_hyper_14_1206_chunk -> Custom Scan (ColumnarScan) on _hyper_13_504_chunk r_473 -> Seq Scan on compress_hyper_14_1207_chunk -> Custom Scan (ColumnarScan) on _hyper_13_505_chunk r_474 -> Seq Scan on compress_hyper_14_1208_chunk -> Custom Scan (ColumnarScan) on _hyper_13_506_chunk r_475 -> Seq Scan on compress_hyper_14_1209_chunk -> Custom Scan (ColumnarScan) on _hyper_13_507_chunk r_476 -> Seq Scan on compress_hyper_14_1210_chunk -> Custom Scan (ColumnarScan) on _hyper_13_508_chunk r_477 -> Seq Scan on compress_hyper_14_1211_chunk -> Custom Scan (ColumnarScan) on _hyper_13_509_chunk r_478 -> Seq Scan on compress_hyper_14_1212_chunk -> Custom Scan (ColumnarScan) on _hyper_13_510_chunk r_479 -> Seq Scan on compress_hyper_14_1213_chunk -> Custom Scan (ColumnarScan) on _hyper_13_511_chunk r_480 -> Seq Scan on compress_hyper_14_1214_chunk -> Custom Scan (ColumnarScan) on _hyper_13_512_chunk r_481 -> Seq Scan on compress_hyper_14_1215_chunk -> Custom Scan (ColumnarScan) on _hyper_13_513_chunk r_482 -> Seq Scan on compress_hyper_14_1216_chunk -> Custom Scan (ColumnarScan) on _hyper_13_514_chunk r_483 -> Seq Scan on compress_hyper_14_1217_chunk -> Custom Scan (ColumnarScan) on _hyper_13_515_chunk r_484 -> Seq Scan on compress_hyper_14_1218_chunk -> Custom Scan (ColumnarScan) on _hyper_13_516_chunk r_485 -> Seq Scan on compress_hyper_14_1219_chunk -> Custom Scan (ColumnarScan) on _hyper_13_517_chunk r_486 -> Seq Scan on compress_hyper_14_1220_chunk -> Custom Scan (ColumnarScan) on _hyper_13_518_chunk r_487 -> Seq Scan on compress_hyper_14_1221_chunk -> Custom Scan (ColumnarScan) on _hyper_13_519_chunk r_488 -> Seq Scan on compress_hyper_14_1222_chunk -> Custom Scan (ColumnarScan) on _hyper_13_520_chunk r_489 -> Seq Scan on compress_hyper_14_1223_chunk -> Custom Scan (ColumnarScan) on _hyper_13_521_chunk r_490 -> Seq Scan on compress_hyper_14_1224_chunk -> Custom Scan (ColumnarScan) on _hyper_13_522_chunk r_491 -> Seq Scan on compress_hyper_14_1225_chunk -> Custom Scan (ColumnarScan) on _hyper_13_523_chunk r_492 -> Seq Scan on compress_hyper_14_1226_chunk -> Custom Scan (ColumnarScan) on _hyper_13_524_chunk r_493 -> Seq Scan on compress_hyper_14_1227_chunk -> Custom Scan (ColumnarScan) on _hyper_13_525_chunk r_494 -> Seq Scan on compress_hyper_14_1228_chunk -> Custom Scan (ColumnarScan) on _hyper_13_526_chunk r_495 -> Seq Scan on compress_hyper_14_1229_chunk -> Custom Scan (ColumnarScan) on _hyper_13_527_chunk r_496 -> Seq Scan on compress_hyper_14_1230_chunk -> Custom Scan (ColumnarScan) on _hyper_13_528_chunk r_497 -> Seq Scan on compress_hyper_14_1231_chunk -> Custom Scan (ColumnarScan) on _hyper_13_529_chunk r_498 -> Seq Scan on compress_hyper_14_1232_chunk -> Custom Scan (ColumnarScan) on _hyper_13_530_chunk r_499 -> Seq Scan on compress_hyper_14_1233_chunk -> Custom Scan (ColumnarScan) on _hyper_13_531_chunk r_500 -> Seq Scan on compress_hyper_14_1234_chunk -> Custom Scan (ColumnarScan) on _hyper_13_532_chunk r_501 -> Seq Scan on compress_hyper_14_1235_chunk -> Custom Scan (ColumnarScan) on _hyper_13_533_chunk r_502 -> Seq Scan on compress_hyper_14_1236_chunk -> Custom Scan (ColumnarScan) on _hyper_13_534_chunk r_503 -> Seq Scan on compress_hyper_14_1237_chunk -> Custom Scan (ColumnarScan) on _hyper_13_535_chunk r_504 -> Seq Scan on compress_hyper_14_1238_chunk -> Custom Scan (ColumnarScan) on _hyper_13_536_chunk r_505 -> Seq Scan on compress_hyper_14_1239_chunk -> Custom Scan (ColumnarScan) on _hyper_13_537_chunk r_506 -> Seq Scan on compress_hyper_14_1240_chunk -> Custom Scan (ColumnarScan) on _hyper_13_538_chunk r_507 -> Seq Scan on compress_hyper_14_1241_chunk -> Custom Scan (ColumnarScan) on _hyper_13_539_chunk r_508 -> Seq Scan on compress_hyper_14_1242_chunk -> Custom Scan (ColumnarScan) on _hyper_13_540_chunk r_509 -> Seq Scan on compress_hyper_14_1243_chunk -> Custom Scan (ColumnarScan) on _hyper_13_541_chunk r_510 -> Seq Scan on compress_hyper_14_1244_chunk -> Custom Scan (ColumnarScan) on _hyper_13_542_chunk r_511 -> Seq Scan on compress_hyper_14_1245_chunk -> Custom Scan (ColumnarScan) on _hyper_13_543_chunk r_512 -> Seq Scan on compress_hyper_14_1246_chunk -> Custom Scan (ColumnarScan) on _hyper_13_544_chunk r_513 -> Seq Scan on compress_hyper_14_1247_chunk -> Custom Scan (ColumnarScan) on _hyper_13_545_chunk r_514 -> Seq Scan on compress_hyper_14_1248_chunk -> Custom Scan (ColumnarScan) on _hyper_13_546_chunk r_515 -> Seq Scan on compress_hyper_14_1249_chunk -> Custom Scan (ColumnarScan) on _hyper_13_547_chunk r_516 -> Seq Scan on compress_hyper_14_1250_chunk -> Custom Scan (ColumnarScan) on _hyper_13_548_chunk r_517 -> Seq Scan on compress_hyper_14_1251_chunk -> Custom Scan (ColumnarScan) on _hyper_13_549_chunk r_518 -> Seq Scan on compress_hyper_14_1252_chunk -> Custom Scan (ColumnarScan) on _hyper_13_550_chunk r_519 -> Seq Scan on compress_hyper_14_1253_chunk -> Custom Scan (ColumnarScan) on _hyper_13_551_chunk r_520 -> Seq Scan on compress_hyper_14_1254_chunk -> Custom Scan (ColumnarScan) on _hyper_13_552_chunk r_521 -> Seq Scan on compress_hyper_14_1255_chunk -> Custom Scan (ColumnarScan) on _hyper_13_553_chunk r_522 -> Seq Scan on compress_hyper_14_1256_chunk -> Custom Scan (ColumnarScan) on _hyper_13_554_chunk r_523 -> Seq Scan on compress_hyper_14_1257_chunk -> Custom Scan (ColumnarScan) on _hyper_13_555_chunk r_524 -> Seq Scan on compress_hyper_14_1258_chunk -> Custom Scan (ColumnarScan) on _hyper_13_556_chunk r_525 -> Seq Scan on compress_hyper_14_1259_chunk -> Custom Scan (ColumnarScan) on _hyper_13_557_chunk r_526 -> Seq Scan on compress_hyper_14_1260_chunk -> Custom Scan (ColumnarScan) on _hyper_13_558_chunk r_527 -> Seq Scan on compress_hyper_14_1261_chunk -> Custom Scan (ColumnarScan) on _hyper_13_559_chunk r_528 -> Seq Scan on compress_hyper_14_1262_chunk -> Custom Scan (ColumnarScan) on _hyper_13_560_chunk r_529 -> Seq Scan on compress_hyper_14_1263_chunk -> Custom Scan (ColumnarScan) on _hyper_13_561_chunk r_530 -> Seq Scan on compress_hyper_14_1264_chunk -> Custom Scan (ColumnarScan) on _hyper_13_562_chunk r_531 -> Seq Scan on compress_hyper_14_1265_chunk -> Custom Scan (ColumnarScan) on _hyper_13_563_chunk r_532 -> Seq Scan on compress_hyper_14_1266_chunk -> Custom Scan (ColumnarScan) on _hyper_13_564_chunk r_533 -> Seq Scan on compress_hyper_14_1267_chunk -> Custom Scan (ColumnarScan) on _hyper_13_565_chunk r_534 -> Seq Scan on compress_hyper_14_1268_chunk -> Custom Scan (ColumnarScan) on _hyper_13_566_chunk r_535 -> Seq Scan on compress_hyper_14_1269_chunk -> Custom Scan (ColumnarScan) on _hyper_13_567_chunk r_536 -> Seq Scan on compress_hyper_14_1270_chunk -> Custom Scan (ColumnarScan) on _hyper_13_568_chunk r_537 -> Seq Scan on compress_hyper_14_1271_chunk -> Custom Scan (ColumnarScan) on _hyper_13_569_chunk r_538 -> Seq Scan on compress_hyper_14_1272_chunk -> Custom Scan (ColumnarScan) on _hyper_13_570_chunk r_539 -> Seq Scan on compress_hyper_14_1273_chunk -> Custom Scan (ColumnarScan) on _hyper_13_571_chunk r_540 -> Seq Scan on compress_hyper_14_1274_chunk -> Custom Scan (ColumnarScan) on _hyper_13_572_chunk r_541 -> Seq Scan on compress_hyper_14_1275_chunk -> Custom Scan (ColumnarScan) on _hyper_13_573_chunk r_542 -> Seq Scan on compress_hyper_14_1276_chunk -> Custom Scan (ColumnarScan) on _hyper_13_574_chunk r_543 -> Seq Scan on compress_hyper_14_1277_chunk -> Custom Scan (ColumnarScan) on _hyper_13_575_chunk r_544 -> Seq Scan on compress_hyper_14_1278_chunk -> Custom Scan (ColumnarScan) on _hyper_13_576_chunk r_545 -> Seq Scan on compress_hyper_14_1279_chunk -> Custom Scan (ColumnarScan) on _hyper_13_577_chunk r_546 -> Seq Scan on compress_hyper_14_1280_chunk -> Custom Scan (ColumnarScan) on _hyper_13_578_chunk r_547 -> Seq Scan on compress_hyper_14_1281_chunk -> Custom Scan (ColumnarScan) on _hyper_13_579_chunk r_548 -> Seq Scan on compress_hyper_14_1282_chunk -> Custom Scan (ColumnarScan) on _hyper_13_580_chunk r_549 -> Seq Scan on compress_hyper_14_1283_chunk -> Custom Scan (ColumnarScan) on _hyper_13_581_chunk r_550 -> Seq Scan on compress_hyper_14_1284_chunk -> Custom Scan (ColumnarScan) on _hyper_13_582_chunk r_551 -> Seq Scan on compress_hyper_14_1285_chunk -> Custom Scan (ColumnarScan) on _hyper_13_583_chunk r_552 -> Seq Scan on compress_hyper_14_1286_chunk -> Custom Scan (ColumnarScan) on _hyper_13_584_chunk r_553 -> Seq Scan on compress_hyper_14_1287_chunk -> Custom Scan (ColumnarScan) on _hyper_13_585_chunk r_554 -> Seq Scan on compress_hyper_14_1288_chunk -> Custom Scan (ColumnarScan) on _hyper_13_586_chunk r_555 -> Seq Scan on compress_hyper_14_1289_chunk -> Custom Scan (ColumnarScan) on _hyper_13_587_chunk r_556 -> Seq Scan on compress_hyper_14_1290_chunk -> Custom Scan (ColumnarScan) on _hyper_13_588_chunk r_557 -> Seq Scan on compress_hyper_14_1291_chunk -> Custom Scan (ColumnarScan) on _hyper_13_589_chunk r_558 -> Seq Scan on compress_hyper_14_1292_chunk -> Custom Scan (ColumnarScan) on _hyper_13_590_chunk r_559 -> Seq Scan on compress_hyper_14_1293_chunk -> Custom Scan (ColumnarScan) on _hyper_13_591_chunk r_560 -> Seq Scan on compress_hyper_14_1294_chunk -> Custom Scan (ColumnarScan) on _hyper_13_592_chunk r_561 -> Seq Scan on compress_hyper_14_1295_chunk -> Custom Scan (ColumnarScan) on _hyper_13_593_chunk r_562 -> Seq Scan on compress_hyper_14_1296_chunk -> Custom Scan (ColumnarScan) on _hyper_13_594_chunk r_563 -> Seq Scan on compress_hyper_14_1297_chunk -> Custom Scan (ColumnarScan) on _hyper_13_595_chunk r_564 -> Seq Scan on compress_hyper_14_1298_chunk -> Custom Scan (ColumnarScan) on _hyper_13_596_chunk r_565 -> Seq Scan on compress_hyper_14_1299_chunk -> Custom Scan (ColumnarScan) on _hyper_13_597_chunk r_566 -> Seq Scan on compress_hyper_14_1300_chunk -> Custom Scan (ColumnarScan) on _hyper_13_598_chunk r_567 -> Seq Scan on compress_hyper_14_1301_chunk -> Custom Scan (ColumnarScan) on _hyper_13_599_chunk r_568 -> Seq Scan on compress_hyper_14_1302_chunk -> Custom Scan (ColumnarScan) on _hyper_13_600_chunk r_569 -> Seq Scan on compress_hyper_14_1303_chunk -> Custom Scan (ColumnarScan) on _hyper_13_601_chunk r_570 -> Seq Scan on compress_hyper_14_1304_chunk -> Custom Scan (ColumnarScan) on _hyper_13_602_chunk r_571 -> Seq Scan on compress_hyper_14_1305_chunk -> Custom Scan (ColumnarScan) on _hyper_13_603_chunk r_572 -> Seq Scan on compress_hyper_14_1306_chunk -> Custom Scan (ColumnarScan) on _hyper_13_604_chunk r_573 -> Seq Scan on compress_hyper_14_1307_chunk -> Custom Scan (ColumnarScan) on _hyper_13_605_chunk r_574 -> Seq Scan on compress_hyper_14_1308_chunk -> Custom Scan (ColumnarScan) on _hyper_13_606_chunk r_575 -> Seq Scan on compress_hyper_14_1309_chunk -> Custom Scan (ColumnarScan) on _hyper_13_607_chunk r_576 -> Seq Scan on compress_hyper_14_1310_chunk -> Custom Scan (ColumnarScan) on _hyper_13_608_chunk r_577 -> Seq Scan on compress_hyper_14_1311_chunk -> Custom Scan (ColumnarScan) on _hyper_13_609_chunk r_578 -> Seq Scan on compress_hyper_14_1312_chunk -> Custom Scan (ColumnarScan) on _hyper_13_610_chunk r_579 -> Seq Scan on compress_hyper_14_1313_chunk -> Custom Scan (ColumnarScan) on _hyper_13_611_chunk r_580 -> Seq Scan on compress_hyper_14_1314_chunk -> Custom Scan (ColumnarScan) on _hyper_13_612_chunk r_581 -> Seq Scan on compress_hyper_14_1315_chunk -> Custom Scan (ColumnarScan) on _hyper_13_613_chunk r_582 -> Seq Scan on compress_hyper_14_1316_chunk -> Custom Scan (ColumnarScan) on _hyper_13_614_chunk r_583 -> Seq Scan on compress_hyper_14_1317_chunk -> Custom Scan (ColumnarScan) on _hyper_13_615_chunk r_584 -> Seq Scan on compress_hyper_14_1318_chunk -> Custom Scan (ColumnarScan) on _hyper_13_616_chunk r_585 -> Seq Scan on compress_hyper_14_1319_chunk -> Custom Scan (ColumnarScan) on _hyper_13_617_chunk r_586 -> Seq Scan on compress_hyper_14_1320_chunk -> Custom Scan (ColumnarScan) on _hyper_13_618_chunk r_587 -> Seq Scan on compress_hyper_14_1321_chunk -> Custom Scan (ColumnarScan) on _hyper_13_619_chunk r_588 -> Seq Scan on compress_hyper_14_1322_chunk -> Custom Scan (ColumnarScan) on _hyper_13_620_chunk r_589 -> Seq Scan on compress_hyper_14_1323_chunk -> Custom Scan (ColumnarScan) on _hyper_13_621_chunk r_590 -> Seq Scan on compress_hyper_14_1324_chunk -> Custom Scan (ColumnarScan) on _hyper_13_622_chunk r_591 -> Seq Scan on compress_hyper_14_1325_chunk -> Custom Scan (ColumnarScan) on _hyper_13_623_chunk r_592 -> Seq Scan on compress_hyper_14_1326_chunk -> Custom Scan (ColumnarScan) on _hyper_13_624_chunk r_593 -> Seq Scan on compress_hyper_14_1327_chunk -> Custom Scan (ColumnarScan) on _hyper_13_625_chunk r_594 -> Seq Scan on compress_hyper_14_1328_chunk -> Custom Scan (ColumnarScan) on _hyper_13_626_chunk r_595 -> Seq Scan on compress_hyper_14_1329_chunk -> Custom Scan (ColumnarScan) on _hyper_13_627_chunk r_596 -> Seq Scan on compress_hyper_14_1330_chunk -> Custom Scan (ColumnarScan) on _hyper_13_628_chunk r_597 -> Seq Scan on compress_hyper_14_1331_chunk -> Custom Scan (ColumnarScan) on _hyper_13_629_chunk r_598 -> Seq Scan on compress_hyper_14_1332_chunk -> Custom Scan (ColumnarScan) on _hyper_13_630_chunk r_599 -> Seq Scan on compress_hyper_14_1333_chunk -> Custom Scan (ColumnarScan) on _hyper_13_631_chunk r_600 -> Seq Scan on compress_hyper_14_1334_chunk -> Custom Scan (ColumnarScan) on _hyper_13_632_chunk r_601 -> Seq Scan on compress_hyper_14_1335_chunk -> Custom Scan (ColumnarScan) on _hyper_13_633_chunk r_602 -> Seq Scan on compress_hyper_14_1336_chunk -> Custom Scan (ColumnarScan) on _hyper_13_634_chunk r_603 -> Seq Scan on compress_hyper_14_1337_chunk -> Custom Scan (ColumnarScan) on _hyper_13_635_chunk r_604 -> Seq Scan on compress_hyper_14_1338_chunk -> Custom Scan (ColumnarScan) on _hyper_13_636_chunk r_605 -> Seq Scan on compress_hyper_14_1339_chunk -> Custom Scan (ColumnarScan) on _hyper_13_637_chunk r_606 -> Seq Scan on compress_hyper_14_1340_chunk -> Custom Scan (ColumnarScan) on _hyper_13_638_chunk r_607 -> Seq Scan on compress_hyper_14_1341_chunk -> Custom Scan (ColumnarScan) on _hyper_13_639_chunk r_608 -> Seq Scan on compress_hyper_14_1342_chunk -> Custom Scan (ColumnarScan) on _hyper_13_640_chunk r_609 -> Seq Scan on compress_hyper_14_1343_chunk -> Custom Scan (ColumnarScan) on _hyper_13_641_chunk r_610 -> Seq Scan on compress_hyper_14_1344_chunk -> Custom Scan (ColumnarScan) on _hyper_13_642_chunk r_611 -> Seq Scan on compress_hyper_14_1345_chunk -> Custom Scan (ColumnarScan) on _hyper_13_643_chunk r_612 -> Seq Scan on compress_hyper_14_1346_chunk -> Custom Scan (ColumnarScan) on _hyper_13_644_chunk r_613 -> Seq Scan on compress_hyper_14_1347_chunk -> Custom Scan (ColumnarScan) on _hyper_13_645_chunk r_614 -> Seq Scan on compress_hyper_14_1348_chunk -> Custom Scan (ColumnarScan) on _hyper_13_646_chunk r_615 -> Seq Scan on compress_hyper_14_1349_chunk -> Custom Scan (ColumnarScan) on _hyper_13_647_chunk r_616 -> Seq Scan on compress_hyper_14_1350_chunk -> Custom Scan (ColumnarScan) on _hyper_13_648_chunk r_617 -> Seq Scan on compress_hyper_14_1351_chunk -> Custom Scan (ColumnarScan) on _hyper_13_649_chunk r_618 -> Seq Scan on compress_hyper_14_1352_chunk -> Custom Scan (ColumnarScan) on _hyper_13_650_chunk r_619 -> Seq Scan on compress_hyper_14_1353_chunk -> Custom Scan (ColumnarScan) on _hyper_13_651_chunk r_620 -> Seq Scan on compress_hyper_14_1354_chunk -> Custom Scan (ColumnarScan) on _hyper_13_652_chunk r_621 -> Seq Scan on compress_hyper_14_1355_chunk -> Custom Scan (ColumnarScan) on _hyper_13_653_chunk r_622 -> Seq Scan on compress_hyper_14_1356_chunk -> Custom Scan (ColumnarScan) on _hyper_13_654_chunk r_623 -> Seq Scan on compress_hyper_14_1357_chunk -> Custom Scan (ColumnarScan) on _hyper_13_655_chunk r_624 -> Seq Scan on compress_hyper_14_1358_chunk -> Custom Scan (ColumnarScan) on _hyper_13_656_chunk r_625 -> Seq Scan on compress_hyper_14_1359_chunk -> Custom Scan (ColumnarScan) on _hyper_13_657_chunk r_626 -> Seq Scan on compress_hyper_14_1360_chunk -> Custom Scan (ColumnarScan) on _hyper_13_658_chunk r_627 -> Seq Scan on compress_hyper_14_1361_chunk -> Custom Scan (ColumnarScan) on _hyper_13_659_chunk r_628 -> Seq Scan on compress_hyper_14_1362_chunk -> Custom Scan (ColumnarScan) on _hyper_13_660_chunk r_629 -> Seq Scan on compress_hyper_14_1363_chunk -> Custom Scan (ColumnarScan) on _hyper_13_661_chunk r_630 -> Seq Scan on compress_hyper_14_1364_chunk -> Custom Scan (ColumnarScan) on _hyper_13_662_chunk r_631 -> Seq Scan on compress_hyper_14_1365_chunk -> Custom Scan (ColumnarScan) on _hyper_13_663_chunk r_632 -> Seq Scan on compress_hyper_14_1366_chunk -> Custom Scan (ColumnarScan) on _hyper_13_664_chunk r_633 -> Seq Scan on compress_hyper_14_1367_chunk -> Custom Scan (ColumnarScan) on _hyper_13_665_chunk r_634 -> Seq Scan on compress_hyper_14_1368_chunk -> Custom Scan (ColumnarScan) on _hyper_13_666_chunk r_635 -> Seq Scan on compress_hyper_14_1369_chunk -> Custom Scan (ColumnarScan) on _hyper_13_667_chunk r_636 -> Seq Scan on compress_hyper_14_1370_chunk -> Custom Scan (ColumnarScan) on _hyper_13_668_chunk r_637 -> Seq Scan on compress_hyper_14_1371_chunk -> Custom Scan (ColumnarScan) on _hyper_13_669_chunk r_638 -> Seq Scan on compress_hyper_14_1372_chunk -> Custom Scan (ColumnarScan) on _hyper_13_670_chunk r_639 -> Seq Scan on compress_hyper_14_1373_chunk -> Custom Scan (ColumnarScan) on _hyper_13_671_chunk r_640 -> Seq Scan on compress_hyper_14_1374_chunk -> Custom Scan (ColumnarScan) on _hyper_13_672_chunk r_641 -> Seq Scan on compress_hyper_14_1375_chunk -> Custom Scan (ColumnarScan) on _hyper_13_673_chunk r_642 -> Seq Scan on compress_hyper_14_1376_chunk -> Custom Scan (ColumnarScan) on _hyper_13_674_chunk r_643 -> Seq Scan on compress_hyper_14_1377_chunk -> Custom Scan (ColumnarScan) on _hyper_13_675_chunk r_644 -> Seq Scan on compress_hyper_14_1378_chunk -> Custom Scan (ColumnarScan) on _hyper_13_676_chunk r_645 -> Seq Scan on compress_hyper_14_1379_chunk -> Custom Scan (ColumnarScan) on _hyper_13_677_chunk r_646 -> Seq Scan on compress_hyper_14_1380_chunk -> Custom Scan (ColumnarScan) on _hyper_13_678_chunk r_647 -> Seq Scan on compress_hyper_14_1381_chunk -> Custom Scan (ColumnarScan) on _hyper_13_679_chunk r_648 -> Seq Scan on compress_hyper_14_1382_chunk -> Custom Scan (ColumnarScan) on _hyper_13_680_chunk r_649 -> Seq Scan on compress_hyper_14_1383_chunk -> Custom Scan (ColumnarScan) on _hyper_13_681_chunk r_650 -> Seq Scan on compress_hyper_14_1384_chunk -> Custom Scan (ColumnarScan) on _hyper_13_682_chunk r_651 -> Seq Scan on compress_hyper_14_1385_chunk -> Custom Scan (ColumnarScan) on _hyper_13_683_chunk r_652 -> Seq Scan on compress_hyper_14_1386_chunk -> Custom Scan (ColumnarScan) on _hyper_13_684_chunk r_653 -> Seq Scan on compress_hyper_14_1387_chunk -> Custom Scan (ColumnarScan) on _hyper_13_685_chunk r_654 -> Seq Scan on compress_hyper_14_1388_chunk -> Custom Scan (ColumnarScan) on _hyper_13_686_chunk r_655 -> Seq Scan on compress_hyper_14_1389_chunk -> Custom Scan (ColumnarScan) on _hyper_13_687_chunk r_656 -> Seq Scan on compress_hyper_14_1390_chunk -> Custom Scan (ColumnarScan) on _hyper_13_688_chunk r_657 -> Seq Scan on compress_hyper_14_1391_chunk -> Custom Scan (ColumnarScan) on _hyper_13_689_chunk r_658 -> Seq Scan on compress_hyper_14_1392_chunk -> Custom Scan (ColumnarScan) on _hyper_13_690_chunk r_659 -> Seq Scan on compress_hyper_14_1393_chunk -> Custom Scan (ColumnarScan) on _hyper_13_691_chunk r_660 -> Seq Scan on compress_hyper_14_1394_chunk -> Custom Scan (ColumnarScan) on _hyper_13_692_chunk r_661 -> Seq Scan on compress_hyper_14_1395_chunk -> Custom Scan (ColumnarScan) on _hyper_13_693_chunk r_662 -> Seq Scan on compress_hyper_14_1396_chunk -> Custom Scan (ColumnarScan) on _hyper_13_694_chunk r_663 -> Seq Scan on compress_hyper_14_1397_chunk -> Custom Scan (ColumnarScan) on _hyper_13_695_chunk r_664 -> Seq Scan on compress_hyper_14_1398_chunk -> Custom Scan (ColumnarScan) on _hyper_13_696_chunk r_665 -> Seq Scan on compress_hyper_14_1399_chunk -> Custom Scan (ColumnarScan) on _hyper_13_697_chunk r_666 -> Seq Scan on compress_hyper_14_1400_chunk -> Custom Scan (ColumnarScan) on _hyper_13_698_chunk r_667 -> Seq Scan on compress_hyper_14_1401_chunk -> Custom Scan (ColumnarScan) on _hyper_13_699_chunk r_668 -> Seq Scan on compress_hyper_14_1402_chunk -> Custom Scan (ColumnarScan) on _hyper_13_700_chunk r_669 -> Seq Scan on compress_hyper_14_1403_chunk -> Custom Scan (ColumnarScan) on _hyper_13_701_chunk r_670 -> Seq Scan on compress_hyper_14_1404_chunk -> Custom Scan (ColumnarScan) on _hyper_13_702_chunk r_671 -> Seq Scan on compress_hyper_14_1405_chunk -> Custom Scan (ColumnarScan) on _hyper_13_703_chunk r_672 -> Seq Scan on compress_hyper_14_1406_chunk -> Custom Scan (ColumnarScan) on _hyper_13_704_chunk r_673 -> Seq Scan on compress_hyper_14_1407_chunk -> Custom Scan (ColumnarScan) on _hyper_13_705_chunk r_674 -> Seq Scan on compress_hyper_14_1408_chunk -> Custom Scan (ColumnarScan) on _hyper_13_706_chunk r_675 -> Seq Scan on compress_hyper_14_1409_chunk -> Custom Scan (ColumnarScan) on _hyper_13_707_chunk r_676 -> Seq Scan on compress_hyper_14_1410_chunk -> Custom Scan (ColumnarScan) on _hyper_13_708_chunk r_677 -> Seq Scan on compress_hyper_14_1411_chunk -> Custom Scan (ColumnarScan) on _hyper_13_709_chunk r_678 -> Seq Scan on compress_hyper_14_1412_chunk -> Custom Scan (ColumnarScan) on _hyper_13_710_chunk r_679 -> Seq Scan on compress_hyper_14_1413_chunk -> Custom Scan (ColumnarScan) on _hyper_13_711_chunk r_680 -> Seq Scan on compress_hyper_14_1414_chunk -> Custom Scan (ColumnarScan) on _hyper_13_712_chunk r_681 -> Seq Scan on compress_hyper_14_1415_chunk -> Custom Scan (ColumnarScan) on _hyper_13_713_chunk r_682 -> Seq Scan on compress_hyper_14_1416_chunk -> Custom Scan (ColumnarScan) on _hyper_13_714_chunk r_683 -> Seq Scan on compress_hyper_14_1417_chunk -> Custom Scan (ColumnarScan) on _hyper_13_715_chunk r_684 -> Seq Scan on compress_hyper_14_1418_chunk -> Custom Scan (ColumnarScan) on _hyper_13_716_chunk r_685 -> Seq Scan on compress_hyper_14_1419_chunk -> Custom Scan (ColumnarScan) on _hyper_13_717_chunk r_686 -> Seq Scan on compress_hyper_14_1420_chunk -> Custom Scan (ColumnarScan) on _hyper_13_718_chunk r_687 -> Seq Scan on compress_hyper_14_1421_chunk -> Custom Scan (ColumnarScan) on _hyper_13_719_chunk r_688 -> Seq Scan on compress_hyper_14_1422_chunk -> Custom Scan (ColumnarScan) on _hyper_13_720_chunk r_689 -> Seq Scan on compress_hyper_14_1423_chunk -> Custom Scan (ColumnarScan) on _hyper_13_721_chunk r_690 -> Seq Scan on compress_hyper_14_1424_chunk -> Custom Scan (ColumnarScan) on _hyper_13_722_chunk r_691 -> Seq Scan on compress_hyper_14_1425_chunk -> Custom Scan (ColumnarScan) on _hyper_13_723_chunk r_692 -> Seq Scan on compress_hyper_14_1426_chunk -> Custom Scan (ColumnarScan) on _hyper_13_724_chunk r_693 -> Seq Scan on compress_hyper_14_1427_chunk -> Custom Scan (ColumnarScan) on _hyper_13_725_chunk r_694 -> Seq Scan on compress_hyper_14_1428_chunk -> Custom Scan (ColumnarScan) on _hyper_13_726_chunk r_695 -> Seq Scan on compress_hyper_14_1429_chunk -> Custom Scan (ColumnarScan) on _hyper_13_727_chunk r_696 -> Seq Scan on compress_hyper_14_1430_chunk -> Custom Scan (ColumnarScan) on _hyper_13_728_chunk r_697 -> Seq Scan on compress_hyper_14_1431_chunk -> Custom Scan (ColumnarScan) on _hyper_13_729_chunk r_698 -> Seq Scan on compress_hyper_14_1432_chunk -> Custom Scan (ColumnarScan) on _hyper_13_730_chunk r_699 -> Seq Scan on compress_hyper_14_1433_chunk -> Custom Scan (ColumnarScan) on _hyper_13_731_chunk r_700 -> Seq Scan on compress_hyper_14_1434_chunk -> Custom Scan (ColumnarScan) on _hyper_13_732_chunk r_701 -> Seq Scan on compress_hyper_14_1435_chunk -> Custom Scan (ColumnarScan) on _hyper_13_733_chunk r_702 -> Seq Scan on compress_hyper_14_1436_chunk -> Custom Scan (ColumnarScan) on _hyper_13_734_chunk r_703 -> Seq Scan on compress_hyper_14_1437_chunk -> Hash -> Seq Scan on tags t -- run query with parallel enabled to ensure nothing is preventing parallel execution -- this is just a sanity check, the result queries dont run with parallel disabled SET max_parallel_workers_per_gather TO 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SET min_parallel_table_scan_size TO '0'; EXPLAIN (buffers off, costs off) SELECT * FROM metrics ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 3 -> Sort Sort Key: metrics."time", metrics.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT time_bucket('10 minutes', time) bucket, avg(v0) avg_v0 FROM metrics GROUP BY bucket; --- QUERY PLAN --- Finalize HashAggregate Group Key: (time_bucket('@ 10 mins'::interval, metrics."time")) -> Gather Workers Planned: 3 -> Parallel Append -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_2_chunk."time") -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: metrics_space."time", metrics_space.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk -> Parallel Seq Scan on compress_hyper_6_17_chunk -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk -> Parallel Seq Scan on compress_hyper_6_19_chunk -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk -> Parallel Seq Scan on compress_hyper_6_20_chunk -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk -> Parallel Seq Scan on compress_hyper_6_18_chunk -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk -> Parallel Seq Scan on compress_hyper_6_21_chunk -> Parallel Seq Scan on _hyper_2_8_chunk -> Parallel Seq Scan on _hyper_2_7_chunk -> Parallel Seq Scan on _hyper_2_9_chunk -> Parallel Seq Scan on _hyper_2_12_chunk RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; SET enable_seqscan TO false; -- should order compressed chunks using index -- (we only EXPLAIN here b/c the resulting order is too inconsistent) EXPLAIN (buffers off, costs off) SELECT * FROM metrics WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics.device_id -> Sort Sort Key: _hyper_1_2_chunk.device_id -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics_space.device_id -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) SET enable_seqscan TO true; -- diff compressed and uncompressed results :DIFF_CMD -- check hypertable detection in views CREATE VIEW ht_view AS SELECT *, 0 AS res FROM metrics UNION ALL SELECT *, 1 AS res FROM metrics; CREATE FUNCTION ht_func() RETURNS SETOF metrics LANGUAGE SQL STABLE AS $sql$ SELECT time, device_id, device_id_peer, v0, v1, v2, v3 FROM ht_view WHERE res = 0; $sql$; -- should have decompresschunk node :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) \c SET enable_incremental_sort TO off; -- plan should be identical to previous plan in fresh session :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- repro for core dump related to total_table_pages setting that get -- adjusted during decompress path. CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE motion_table( id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass) , datalogger_id bigint , vessel_id bigint , bus_id smallint , src_id smallint , dataloggertime timestamp with time zone , interval_s real ); CREATE INDEX motion_table_t2_datalogger_id_idx on motion_table (datalogger_id); CREATE INDEX motion_table_t2_dataloggertime_idx on motion_table(dataloggertime DESC); CREATE INDEX motion_table_t2_vessel_id_idx on motion_table(vessel_id); SELECT create_hypertable( 'motion_table', 'dataloggertime', chunk_time_interval=> '7 days'::interval); create_hypertable ---------------------------- (15,public,motion_table,t) --- do not modify the data. We need atleast this volume to reproduce issues with pages/tuple counts etc. --- INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), random() , random() , generate_series( '2020-01-02 10:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), 2, 3, generate_series( '2020-01-10 8:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; ALTER TABLE motion_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'vessel_id, datalogger_id, bus_id, src_id' , timescaledb.compress_orderby = 'dataloggertime' ); --have 2 chunks -- SELECT COUNT(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table'; count ------- 2 -- compress only the first one --- SELECT compress_chunk( chunk_table) FROM ( SELECT chunk_schema || '.' || chunk_name as chunk_table FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table' ORDER BY range_start limit 1 ) q; compress_chunk -------------------------------------------- _timescaledb_internal._hyper_15_1438_chunk --call to decompress chunk on 1 of the chunks SELECT count(*) from motion_table; count ------- 11642 --END of test for page settings CREATE TABLE repro(time timestamptz NOT NULL, device_id text, room_id text NOT NULL, score_type int NOT NULL, algorithm_version text NOT NULL, adjusted_score float NOT NULL); SELECT create_hypertable('repro','time'); create_hypertable --------------------- (17,public,repro,t) ALTER TABLE repro SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, room_id, score_type, algorithm_version', timescaledb.compress_orderby='"time" DESC' ); SELECT _timescaledb_functions.create_chunk('repro','{"time": [1717632000000000,1718236800000000]}'); create_chunk ------------------------------------------------------------------------------------------------------------- (1441,17,_timescaledb_internal,_hyper_17_1441_chunk,r,"{""time"": [1717632000000000, 1718236800000000]}",t) select compress_chunk(show_chunks('repro')); compress_chunk -------------------------------------------- _timescaledb_internal._hyper_17_1441_chunk select from repro where room_id = 'foo' order by device_id, algorithm_version, score_type, time desc; -- �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression-16.out�������������������������������0000664�0000000�0000000�00002313430�15100345067�0025713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset SET work_mem TO '50MB'; SET enable_incremental_sort TO off; SET timezone TO 'America/Los_Angeles'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; CREATE TABLE metrics ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable ('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; \set INTERVAL 30m INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id - 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('metrics_space', 'time', 'device_id', 3); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics_space; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none -- compress first and last chunk on the hypertable ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics') x) t where n in (1, 3) ; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk VACUUM ANALYZE metrics; -- compress some chunks on space partitioned hypertable -- we compress all chunks of first time slice, none of second, and 2 of the last time slice ALTER TABLE metrics_space SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics_space') x) t where n in (1, 2, 3, 7, 8) ; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics' \gset SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_SPACE_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics_space' \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Index created using query saved in variable used because there was -- no standard way to create an index on a compressed table. -- Once a standard way exists, modify this test to use that method. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE INDEX ON metrics_space (device_id, device_id_peer, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id, device_id_peer DESC, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id DESC, device_id_peer DESC, v0, v1 DESC, time); VACUUM ANALYZE metrics_space; SET enable_incremental_sort TO off; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; -- get explain for queries on hypertable with compression \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Sort (actual rows=3456.00 loops=1) Sort Key: metrics."time", metrics.device_id Sort Method: quicksort -> Result (actual rows=3456.00 loops=1) -> Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_2_chunk (actual rows=1344.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2016 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=672.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time", metrics.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3600 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1680 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 3) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3595 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3570 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=35.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3565 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3570.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 30 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 2688 -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < 1) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) Filter: (v0 < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3600 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 1680 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=713.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: ((compress_hyper_5_15_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_15_chunk.device_id = 1)) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Index Cond: (_hyper_1_2_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: ((compress_hyper_5_16_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_16_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3572.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 28 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC, metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics.device_id, metrics."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device_id, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time", metrics.device_id Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk."time" Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0 -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time", metrics.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1 DESC, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 1 -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=8640.00 loops=1) Order: metrics."time" -> Sort (actual rows=3600.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics."time" = metrics_1."time") -> Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1728.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Order: metrics."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=5.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Index Only Scan using _hyper_1_2_chunk_tmp_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id_peer = 1) Rows Removed by Filter: 5 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id_peer = 1) Rows Removed by Filter: 5 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Output: metrics.device_id_peer Join Filter: (metrics.device_id_peer = "*VALUES*".column1) Rows Removed by Join Filter: 17280 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=3456.00 loops=1) Output: metrics.device_id_peer -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=1728.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=2) Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=2) Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_1_2_chunk.device_id) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=2) Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = "*VALUES*".column1) RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join Output: metrics.device_id_peer Hash Cond: (metrics.device_id = "*VALUES*".column1) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -> Hash Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=3456.00 loops=1) Output: metrics.device_id_peer -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=1728.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=2) Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=2) Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_1_2_chunk.device_id) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=2) Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = "*VALUES*".column1) -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: m3_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m3_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 38 -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=48.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=11.00 loops=1) Order: m2."time" -> Sort (actual rows=11.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Sort (actual rows=3456.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Result (actual rows=3456.00 loops=1) -> Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Vectorized Filter: (_hyper_2_5_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2160 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Vectorized Filter: (_hyper_2_6_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2016 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1008 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (never executed) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 3 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2157 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=18.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2142 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=21.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2139 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2142.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 18 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id < v0) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id < v0) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 336 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2160 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 1008 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=713.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: ((compress_hyper_6_17_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_17_chunk.device_id = 1)) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: ((compress_hyper_6_20_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_20_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=9.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC, metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_12_chunk."time" DESC, _hyper_2_12_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC, _hyper_2_11_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC, _hyper_2_10_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time" DESC, _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time" DESC, _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time" DESC, _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC, _hyper_2_6_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC, _hyper_2_5_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC, _hyper_2_4_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_4_chunk.device_id, _hyper_2_4_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_5_chunk.device_id, _hyper_2_5_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk.device_id, _hyper_2_6_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk."time" Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk."time" Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk."time" Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk."time" Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk."time" Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk."time" Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time", metrics_space.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _hyper_2_9_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=3915.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (actual rows=2235.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1341.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=8640.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3600.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=2160.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=3360.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics_space."time" = metrics_space_1."time") -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1728.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=5.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics_space), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics_space), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan using _hyper_2_7_chunk_tmp_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id -> Index Only Scan using _hyper_2_8_chunk_tmp_idx on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id -> Index Only Scan using _hyper_2_9_chunk_tmp_idx on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan using _hyper_2_12_chunk_tmp_idx on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Filter: (compress_hyper_6_19_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Filter: (_hyper_2_12_chunk.device_id_peer = 1) Rows Removed by Filter: 336 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Output: metrics_space.device_id_peer Join Filter: (metrics_space.device_id_peer = "*VALUES*".column1) Rows Removed by Join Filter: 17280 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=3456.00 loops=1) Output: metrics_space.device_id_peer Join Filter: (metrics_space.device_id = "*VALUES*".column1) Rows Removed by Join Filter: 12096 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join Output: metrics_space.device_id_peer Hash Cond: (metrics_space.device_id = "*VALUES*".column1) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Hash Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join (actual rows=3456.00 loops=1) Output: metrics_space.device_id_peer Hash Cond: (metrics_space.device_id = "*VALUES*".column1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Hash (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m3_3 (actual rows=1.00 loops=1) Filter: (device_id = 3) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 39 -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=49.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=11.00 loops=1) Order: m2."time" -> Merge Append (actual rows=11.00 loops=1) Sort Key: m2."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=7.00 loops=1) Sort Key: m2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m2_4 (never executed) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m2_5 (never executed) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time" -> Sort (never executed) Sort Key: m2_7."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 7 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_18_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_19_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m1_5 (never executed) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m1_6 (never executed) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m1_9 (never executed) Index Cond: ("time" = g."time") -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 1) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 2) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \ir include/transparent_decompression_ordered.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column CREATE TABLE metrics_ordered(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_ordered','time'); create_hypertable ------------------------------- (11,public,metrics_ordered,t) ALTER TABLE metrics_ordered SET (timescaledb.compress, timescaledb.compress_orderby='time DESC',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered SELECT * FROM metrics; CREATE INDEX ON metrics_ordered(device_id,device_id_peer,time); CREATE INDEX ON metrics_ordered(device_id,time); CREATE INDEX ON metrics_ordered(device_id_peer,time); -- compress all chunks SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered') ch; count ------- 3 VACUUM ANALYZE metrics_ordered; -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM metrics_ordered ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=10.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_30_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_29_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_29_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered WHERE device_id = 1 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=0.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_min_1 DESC, compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_30_chunk._ts_meta_min_1 DESC, compress_hyper_12_30_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_29_chunk._ts_meta_min_1 DESC, compress_hyper_12_29_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered d INNER JOIN LATERAL (SELECT * FROM metrics_ordered m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON true; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Nested Loop (actual rows=0.00 loops=1) -> Merge Append (actual rows=8640.00 loops=1) Sort Key: d.device_id -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk d_1 (actual rows=3600.00 loops=1) -> Index Scan using compress_hyper_12_29_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_29_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk d_2 (actual rows=3360.00 loops=1) -> Index Scan using compress_hyper_12_30_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_30_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk d_3 (actual rows=1680.00 loops=1) -> Index Scan using compress_hyper_12_31_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Limit (actual rows=0.00 loops=8640) -> Custom Scan (ChunkAppend) on metrics_ordered m (actual rows=0.00 loops=8640) Order: m."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk m_1 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_31_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_31_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk compress_hyper_12_31_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk m_2 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_30_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_30_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk compress_hyper_12_30_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk m_3 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_29_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_29_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk compress_hyper_12_29_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 \ir include/transparent_decompression_systemcolumns.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_TABLE 'metrics' -- test system columns -- all system columns except for tableoid should error \set ON_ERROR_STOP 0 SELECT xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:10: ERROR: transparent decompression only supports tableoid system column SELECT cmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:11: ERROR: transparent decompression only supports tableoid system column SELECT xmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:12: ERROR: transparent decompression only supports tableoid system column SELECT cmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:13: ERROR: transparent decompression only supports tableoid system column SELECT ctid FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:14: ERROR: transparent decompression only supports tableoid system column -- test system columns in WHERE and ORDER BY clause SELECT tableoid, xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:17: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE ORDER BY cmin::text; psql:include/transparent_decompression_systemcolumns.sql:18: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE WHERE cmin IS NOT NULL; psql:include/transparent_decompression_systemcolumns.sql:19: ERROR: transparent decompression only supports tableoid system column \set ON_ERROR_STOP 1 -- test tableoid in different parts of query SELECT pg_typeof(tableoid) FROM :TEST_TABLE ORDER BY time LIMIT 1; pg_typeof ----------- oid SELECT FROM :TEST_TABLE ORDER BY tableoid LIMIT 1; -- SELECT FROM :TEST_TABLE WHERE tableoid::int > 0 LIMIT 1; -- SELECT tableoid::regclass FROM :TEST_TABLE GROUP BY tableoid ORDER BY 1; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk SELECT count(distinct tableoid) FROM :TEST_TABLE WHERE device_id=1 AND time < now(); count ------- 3 -- test prepared statement PREPARE tableoid_prep AS SELECT tableoid::regclass FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 1; :PREFIX EXECUTE tableoid_prep; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk DEALLOCATE tableoid_prep; \ir include/transparent_decompression_undiffed.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test planning regression with many chunks CREATE TABLE tags(id SERIAL PRIMARY KEY, name TEXT, fleet TEXT); INSERT INTO tags (name, fleet) VALUES('n1', 'f1'); CREATE TABLE readings (time timestamptz, tags_id integer, fuel_consumption DOUBLE PRECISION); CREATE INDEX ON readings(tags_id, "time" DESC); CREATE INDEX ON readings("time" DESC); SELECT create_hypertable('readings', 'time', partitioning_column => 'tags_id', number_partitions => 1, chunk_time_interval => 43200000000, create_default_indexes=>false); create_hypertable ------------------------ (13,public,readings,t) ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'tags_id', timescaledb.compress_orderby = 'time desc'); INSERT into readings select g, 1, 1.3 from generate_series('2001-03-01 01:01:01', '2003-02-01 01:01:01', '1 day'::interval) g; SELECT count(compress_chunk(ch)) FROM show_chunks('readings') ch; count ------- 703 VACUUM ANALYZE readings; EXPLAIN (buffers off, costs off) SELECT t.fleet as fleet, min(r.fuel_consumption) AS avg_fuel_consumption FROM tags t INNER JOIN LATERAL(SELECT tags_id, fuel_consumption FROM readings r WHERE r.tags_id = t.id ) r ON true GROUP BY fleet; --- QUERY PLAN --- HashAggregate Group Key: t.fleet -> Hash Join Hash Cond: (r.tags_id = t.id) -> Append -> Custom Scan (ColumnarScan) on _hyper_13_32_chunk r_1 -> Seq Scan on compress_hyper_14_735_chunk -> Custom Scan (ColumnarScan) on _hyper_13_33_chunk r_2 -> Seq Scan on compress_hyper_14_736_chunk -> Custom Scan (ColumnarScan) on _hyper_13_34_chunk r_3 -> Seq Scan on compress_hyper_14_737_chunk -> Custom Scan (ColumnarScan) on _hyper_13_35_chunk r_4 -> Seq Scan on compress_hyper_14_738_chunk -> Custom Scan (ColumnarScan) on _hyper_13_36_chunk r_5 -> Seq Scan on compress_hyper_14_739_chunk -> Custom Scan (ColumnarScan) on _hyper_13_37_chunk r_6 -> Seq Scan on compress_hyper_14_740_chunk -> Custom Scan (ColumnarScan) on _hyper_13_38_chunk r_7 -> Seq Scan on compress_hyper_14_741_chunk -> Custom Scan (ColumnarScan) on _hyper_13_39_chunk r_8 -> Seq Scan on compress_hyper_14_742_chunk -> Custom Scan (ColumnarScan) on _hyper_13_40_chunk r_9 -> Seq Scan on compress_hyper_14_743_chunk -> Custom Scan (ColumnarScan) on _hyper_13_41_chunk r_10 -> Seq Scan on compress_hyper_14_744_chunk -> Custom Scan (ColumnarScan) on _hyper_13_42_chunk r_11 -> Seq Scan on compress_hyper_14_745_chunk -> Custom Scan (ColumnarScan) on _hyper_13_43_chunk r_12 -> Seq Scan on compress_hyper_14_746_chunk -> Custom Scan (ColumnarScan) on _hyper_13_44_chunk r_13 -> Seq Scan on compress_hyper_14_747_chunk -> Custom Scan (ColumnarScan) on _hyper_13_45_chunk r_14 -> Seq Scan on compress_hyper_14_748_chunk -> Custom Scan (ColumnarScan) on _hyper_13_46_chunk r_15 -> Seq Scan on compress_hyper_14_749_chunk -> Custom Scan (ColumnarScan) on _hyper_13_47_chunk r_16 -> Seq Scan on compress_hyper_14_750_chunk -> Custom Scan (ColumnarScan) on _hyper_13_48_chunk r_17 -> Seq Scan on compress_hyper_14_751_chunk -> Custom Scan (ColumnarScan) on _hyper_13_49_chunk r_18 -> Seq Scan on compress_hyper_14_752_chunk -> Custom Scan (ColumnarScan) on _hyper_13_50_chunk r_19 -> Seq Scan on compress_hyper_14_753_chunk -> Custom Scan (ColumnarScan) on _hyper_13_51_chunk r_20 -> Seq Scan on compress_hyper_14_754_chunk -> Custom Scan (ColumnarScan) on _hyper_13_52_chunk r_21 -> Seq Scan on compress_hyper_14_755_chunk -> Custom Scan (ColumnarScan) on _hyper_13_53_chunk r_22 -> Seq Scan on compress_hyper_14_756_chunk -> Custom Scan (ColumnarScan) on _hyper_13_54_chunk r_23 -> Seq Scan on compress_hyper_14_757_chunk -> Custom Scan (ColumnarScan) on _hyper_13_55_chunk r_24 -> Seq Scan on compress_hyper_14_758_chunk -> Custom Scan (ColumnarScan) on _hyper_13_56_chunk r_25 -> Seq Scan on compress_hyper_14_759_chunk -> Custom Scan (ColumnarScan) on _hyper_13_57_chunk r_26 -> Seq Scan on compress_hyper_14_760_chunk -> Custom Scan (ColumnarScan) on _hyper_13_58_chunk r_27 -> Seq Scan on compress_hyper_14_761_chunk -> Custom Scan (ColumnarScan) on _hyper_13_59_chunk r_28 -> Seq Scan on compress_hyper_14_762_chunk -> Custom Scan (ColumnarScan) on _hyper_13_60_chunk r_29 -> Seq Scan on compress_hyper_14_763_chunk -> Custom Scan (ColumnarScan) on _hyper_13_61_chunk r_30 -> Seq Scan on compress_hyper_14_764_chunk -> Custom Scan (ColumnarScan) on _hyper_13_62_chunk r_31 -> Seq Scan on compress_hyper_14_765_chunk -> Custom Scan (ColumnarScan) on _hyper_13_63_chunk r_32 -> Seq Scan on compress_hyper_14_766_chunk -> Custom Scan (ColumnarScan) on _hyper_13_64_chunk r_33 -> Seq Scan on compress_hyper_14_767_chunk -> Custom Scan (ColumnarScan) on _hyper_13_65_chunk r_34 -> Seq Scan on compress_hyper_14_768_chunk -> Custom Scan (ColumnarScan) on _hyper_13_66_chunk r_35 -> Seq Scan on compress_hyper_14_769_chunk -> Custom Scan (ColumnarScan) on _hyper_13_67_chunk r_36 -> Seq Scan on compress_hyper_14_770_chunk -> Custom Scan (ColumnarScan) on _hyper_13_68_chunk r_37 -> Seq Scan on compress_hyper_14_771_chunk -> Custom Scan (ColumnarScan) on _hyper_13_69_chunk r_38 -> Seq Scan on compress_hyper_14_772_chunk -> Custom Scan (ColumnarScan) on _hyper_13_70_chunk r_39 -> Seq Scan on compress_hyper_14_773_chunk -> Custom Scan (ColumnarScan) on _hyper_13_71_chunk r_40 -> Seq Scan on compress_hyper_14_774_chunk -> Custom Scan (ColumnarScan) on _hyper_13_72_chunk r_41 -> Seq Scan on compress_hyper_14_775_chunk -> Custom Scan (ColumnarScan) on _hyper_13_73_chunk r_42 -> Seq Scan on compress_hyper_14_776_chunk -> Custom Scan (ColumnarScan) on _hyper_13_74_chunk r_43 -> Seq Scan on compress_hyper_14_777_chunk -> Custom Scan (ColumnarScan) on _hyper_13_75_chunk r_44 -> Seq Scan on compress_hyper_14_778_chunk -> Custom Scan (ColumnarScan) on _hyper_13_76_chunk r_45 -> Seq Scan on compress_hyper_14_779_chunk -> Custom Scan (ColumnarScan) on _hyper_13_77_chunk r_46 -> Seq Scan on compress_hyper_14_780_chunk -> Custom Scan (ColumnarScan) on _hyper_13_78_chunk r_47 -> Seq Scan on compress_hyper_14_781_chunk -> Custom Scan (ColumnarScan) on _hyper_13_79_chunk r_48 -> Seq Scan on compress_hyper_14_782_chunk -> Custom Scan (ColumnarScan) on _hyper_13_80_chunk r_49 -> Seq Scan on compress_hyper_14_783_chunk -> Custom Scan (ColumnarScan) on _hyper_13_81_chunk r_50 -> Seq Scan on compress_hyper_14_784_chunk -> Custom Scan (ColumnarScan) on _hyper_13_82_chunk r_51 -> Seq Scan on compress_hyper_14_785_chunk -> Custom Scan (ColumnarScan) on _hyper_13_83_chunk r_52 -> Seq Scan on compress_hyper_14_786_chunk -> Custom Scan (ColumnarScan) on _hyper_13_84_chunk r_53 -> Seq Scan on compress_hyper_14_787_chunk -> Custom Scan (ColumnarScan) on _hyper_13_85_chunk r_54 -> Seq Scan on compress_hyper_14_788_chunk -> Custom Scan (ColumnarScan) on _hyper_13_86_chunk r_55 -> Seq Scan on compress_hyper_14_789_chunk -> Custom Scan (ColumnarScan) on _hyper_13_87_chunk r_56 -> Seq Scan on compress_hyper_14_790_chunk -> Custom Scan (ColumnarScan) on _hyper_13_88_chunk r_57 -> Seq Scan on compress_hyper_14_791_chunk -> Custom Scan (ColumnarScan) on _hyper_13_89_chunk r_58 -> Seq Scan on compress_hyper_14_792_chunk -> Custom Scan (ColumnarScan) on _hyper_13_90_chunk r_59 -> Seq Scan on compress_hyper_14_793_chunk -> Custom Scan (ColumnarScan) on _hyper_13_91_chunk r_60 -> Seq Scan on compress_hyper_14_794_chunk -> Custom Scan (ColumnarScan) on _hyper_13_92_chunk r_61 -> Seq Scan on compress_hyper_14_795_chunk -> Custom Scan (ColumnarScan) on _hyper_13_93_chunk r_62 -> Seq Scan on compress_hyper_14_796_chunk -> Custom Scan (ColumnarScan) on _hyper_13_94_chunk r_63 -> Seq Scan on compress_hyper_14_797_chunk -> Custom Scan (ColumnarScan) on _hyper_13_95_chunk r_64 -> Seq Scan on compress_hyper_14_798_chunk -> Custom Scan (ColumnarScan) on _hyper_13_96_chunk r_65 -> Seq Scan on compress_hyper_14_799_chunk -> Custom Scan (ColumnarScan) on _hyper_13_97_chunk r_66 -> Seq Scan on compress_hyper_14_800_chunk -> Custom Scan (ColumnarScan) on _hyper_13_98_chunk r_67 -> Seq Scan on compress_hyper_14_801_chunk -> Custom Scan (ColumnarScan) on _hyper_13_99_chunk r_68 -> Seq Scan on compress_hyper_14_802_chunk -> Custom Scan (ColumnarScan) on _hyper_13_100_chunk r_69 -> Seq Scan on compress_hyper_14_803_chunk -> Custom Scan (ColumnarScan) on _hyper_13_101_chunk r_70 -> Seq Scan on compress_hyper_14_804_chunk -> Custom Scan (ColumnarScan) on _hyper_13_102_chunk r_71 -> Seq Scan on compress_hyper_14_805_chunk -> Custom Scan (ColumnarScan) on _hyper_13_103_chunk r_72 -> Seq Scan on compress_hyper_14_806_chunk -> Custom Scan (ColumnarScan) on _hyper_13_104_chunk r_73 -> Seq Scan on compress_hyper_14_807_chunk -> Custom Scan (ColumnarScan) on _hyper_13_105_chunk r_74 -> Seq Scan on compress_hyper_14_808_chunk -> Custom Scan (ColumnarScan) on _hyper_13_106_chunk r_75 -> Seq Scan on compress_hyper_14_809_chunk -> Custom Scan (ColumnarScan) on _hyper_13_107_chunk r_76 -> Seq Scan on compress_hyper_14_810_chunk -> Custom Scan (ColumnarScan) on _hyper_13_108_chunk r_77 -> Seq Scan on compress_hyper_14_811_chunk -> Custom Scan (ColumnarScan) on _hyper_13_109_chunk r_78 -> Seq Scan on compress_hyper_14_812_chunk -> Custom Scan (ColumnarScan) on _hyper_13_110_chunk r_79 -> Seq Scan on compress_hyper_14_813_chunk -> Custom Scan (ColumnarScan) on _hyper_13_111_chunk r_80 -> Seq Scan on compress_hyper_14_814_chunk -> Custom Scan (ColumnarScan) on _hyper_13_112_chunk r_81 -> Seq Scan on compress_hyper_14_815_chunk -> Custom Scan (ColumnarScan) on _hyper_13_113_chunk r_82 -> Seq Scan on compress_hyper_14_816_chunk -> Custom Scan (ColumnarScan) on _hyper_13_114_chunk r_83 -> Seq Scan on compress_hyper_14_817_chunk -> Custom Scan (ColumnarScan) on _hyper_13_115_chunk r_84 -> Seq Scan on compress_hyper_14_818_chunk -> Custom Scan (ColumnarScan) on _hyper_13_116_chunk r_85 -> Seq Scan on compress_hyper_14_819_chunk -> Custom Scan (ColumnarScan) on _hyper_13_117_chunk r_86 -> Seq Scan on compress_hyper_14_820_chunk -> Custom Scan (ColumnarScan) on _hyper_13_118_chunk r_87 -> Seq Scan on compress_hyper_14_821_chunk -> Custom Scan (ColumnarScan) on _hyper_13_119_chunk r_88 -> Seq Scan on compress_hyper_14_822_chunk -> Custom Scan (ColumnarScan) on _hyper_13_120_chunk r_89 -> Seq Scan on compress_hyper_14_823_chunk -> Custom Scan (ColumnarScan) on _hyper_13_121_chunk r_90 -> Seq Scan on compress_hyper_14_824_chunk -> Custom Scan (ColumnarScan) on _hyper_13_122_chunk r_91 -> Seq Scan on compress_hyper_14_825_chunk -> Custom Scan (ColumnarScan) on _hyper_13_123_chunk r_92 -> Seq Scan on compress_hyper_14_826_chunk -> Custom Scan (ColumnarScan) on _hyper_13_124_chunk r_93 -> Seq Scan on compress_hyper_14_827_chunk -> Custom Scan (ColumnarScan) on _hyper_13_125_chunk r_94 -> Seq Scan on compress_hyper_14_828_chunk -> Custom Scan (ColumnarScan) on _hyper_13_126_chunk r_95 -> Seq Scan on compress_hyper_14_829_chunk -> Custom Scan (ColumnarScan) on _hyper_13_127_chunk r_96 -> Seq Scan on compress_hyper_14_830_chunk -> Custom Scan (ColumnarScan) on _hyper_13_128_chunk r_97 -> Seq Scan on compress_hyper_14_831_chunk -> Custom Scan (ColumnarScan) on _hyper_13_129_chunk r_98 -> Seq Scan on compress_hyper_14_832_chunk -> Custom Scan (ColumnarScan) on _hyper_13_130_chunk r_99 -> Seq Scan on compress_hyper_14_833_chunk -> Custom Scan (ColumnarScan) on _hyper_13_131_chunk r_100 -> Seq Scan on compress_hyper_14_834_chunk -> Custom Scan (ColumnarScan) on _hyper_13_132_chunk r_101 -> Seq Scan on compress_hyper_14_835_chunk -> Custom Scan (ColumnarScan) on _hyper_13_133_chunk r_102 -> Seq Scan on compress_hyper_14_836_chunk -> Custom Scan (ColumnarScan) on _hyper_13_134_chunk r_103 -> Seq Scan on compress_hyper_14_837_chunk -> Custom Scan (ColumnarScan) on _hyper_13_135_chunk r_104 -> Seq Scan on compress_hyper_14_838_chunk -> Custom Scan (ColumnarScan) on _hyper_13_136_chunk r_105 -> Seq Scan on compress_hyper_14_839_chunk -> Custom Scan (ColumnarScan) on _hyper_13_137_chunk r_106 -> Seq Scan on compress_hyper_14_840_chunk -> Custom Scan (ColumnarScan) on _hyper_13_138_chunk r_107 -> Seq Scan on compress_hyper_14_841_chunk -> Custom Scan (ColumnarScan) on _hyper_13_139_chunk r_108 -> Seq Scan on compress_hyper_14_842_chunk -> Custom Scan (ColumnarScan) on _hyper_13_140_chunk r_109 -> Seq Scan on compress_hyper_14_843_chunk -> Custom Scan (ColumnarScan) on _hyper_13_141_chunk r_110 -> Seq Scan on compress_hyper_14_844_chunk -> Custom Scan (ColumnarScan) on _hyper_13_142_chunk r_111 -> Seq Scan on compress_hyper_14_845_chunk -> Custom Scan (ColumnarScan) on _hyper_13_143_chunk r_112 -> Seq Scan on compress_hyper_14_846_chunk -> Custom Scan (ColumnarScan) on _hyper_13_144_chunk r_113 -> Seq Scan on compress_hyper_14_847_chunk -> Custom Scan (ColumnarScan) on _hyper_13_145_chunk r_114 -> Seq Scan on compress_hyper_14_848_chunk -> Custom Scan (ColumnarScan) on _hyper_13_146_chunk r_115 -> Seq Scan on compress_hyper_14_849_chunk -> Custom Scan (ColumnarScan) on _hyper_13_147_chunk r_116 -> Seq Scan on compress_hyper_14_850_chunk -> Custom Scan (ColumnarScan) on _hyper_13_148_chunk r_117 -> Seq Scan on compress_hyper_14_851_chunk -> Custom Scan (ColumnarScan) on _hyper_13_149_chunk r_118 -> Seq Scan on compress_hyper_14_852_chunk -> Custom Scan (ColumnarScan) on _hyper_13_150_chunk r_119 -> Seq Scan on compress_hyper_14_853_chunk -> Custom Scan (ColumnarScan) on _hyper_13_151_chunk r_120 -> Seq Scan on compress_hyper_14_854_chunk -> Custom Scan (ColumnarScan) on _hyper_13_152_chunk r_121 -> Seq Scan on compress_hyper_14_855_chunk -> Custom Scan (ColumnarScan) on _hyper_13_153_chunk r_122 -> Seq Scan on compress_hyper_14_856_chunk -> Custom Scan (ColumnarScan) on _hyper_13_154_chunk r_123 -> Seq Scan on compress_hyper_14_857_chunk -> Custom Scan (ColumnarScan) on _hyper_13_155_chunk r_124 -> Seq Scan on compress_hyper_14_858_chunk -> Custom Scan (ColumnarScan) on _hyper_13_156_chunk r_125 -> Seq Scan on compress_hyper_14_859_chunk -> Custom Scan (ColumnarScan) on _hyper_13_157_chunk r_126 -> Seq Scan on compress_hyper_14_860_chunk -> Custom Scan (ColumnarScan) on _hyper_13_158_chunk r_127 -> Seq Scan on compress_hyper_14_861_chunk -> Custom Scan (ColumnarScan) on _hyper_13_159_chunk r_128 -> Seq Scan on compress_hyper_14_862_chunk -> Custom Scan (ColumnarScan) on _hyper_13_160_chunk r_129 -> Seq Scan on compress_hyper_14_863_chunk -> Custom Scan (ColumnarScan) on _hyper_13_161_chunk r_130 -> Seq Scan on compress_hyper_14_864_chunk -> Custom Scan (ColumnarScan) on _hyper_13_162_chunk r_131 -> Seq Scan on compress_hyper_14_865_chunk -> Custom Scan (ColumnarScan) on _hyper_13_163_chunk r_132 -> Seq Scan on compress_hyper_14_866_chunk -> Custom Scan (ColumnarScan) on _hyper_13_164_chunk r_133 -> Seq Scan on compress_hyper_14_867_chunk -> Custom Scan (ColumnarScan) on _hyper_13_165_chunk r_134 -> Seq Scan on compress_hyper_14_868_chunk -> Custom Scan (ColumnarScan) on _hyper_13_166_chunk r_135 -> Seq Scan on compress_hyper_14_869_chunk -> Custom Scan (ColumnarScan) on _hyper_13_167_chunk r_136 -> Seq Scan on compress_hyper_14_870_chunk -> Custom Scan (ColumnarScan) on _hyper_13_168_chunk r_137 -> Seq Scan on compress_hyper_14_871_chunk -> Custom Scan (ColumnarScan) on _hyper_13_169_chunk r_138 -> Seq Scan on compress_hyper_14_872_chunk -> Custom Scan (ColumnarScan) on _hyper_13_170_chunk r_139 -> Seq Scan on compress_hyper_14_873_chunk -> Custom Scan (ColumnarScan) on _hyper_13_171_chunk r_140 -> Seq Scan on compress_hyper_14_874_chunk -> Custom Scan (ColumnarScan) on _hyper_13_172_chunk r_141 -> Seq Scan on compress_hyper_14_875_chunk -> Custom Scan (ColumnarScan) on _hyper_13_173_chunk r_142 -> Seq Scan on compress_hyper_14_876_chunk -> Custom Scan (ColumnarScan) on _hyper_13_174_chunk r_143 -> Seq Scan on compress_hyper_14_877_chunk -> Custom Scan (ColumnarScan) on _hyper_13_175_chunk r_144 -> Seq Scan on compress_hyper_14_878_chunk -> Custom Scan (ColumnarScan) on _hyper_13_176_chunk r_145 -> Seq Scan on compress_hyper_14_879_chunk -> Custom Scan (ColumnarScan) on _hyper_13_177_chunk r_146 -> Seq Scan on compress_hyper_14_880_chunk -> Custom Scan (ColumnarScan) on _hyper_13_178_chunk r_147 -> Seq Scan on compress_hyper_14_881_chunk -> Custom Scan (ColumnarScan) on _hyper_13_179_chunk r_148 -> Seq Scan on compress_hyper_14_882_chunk -> Custom Scan (ColumnarScan) on _hyper_13_180_chunk r_149 -> Seq Scan on compress_hyper_14_883_chunk -> Custom Scan (ColumnarScan) on _hyper_13_181_chunk r_150 -> Seq Scan on compress_hyper_14_884_chunk -> Custom Scan (ColumnarScan) on _hyper_13_182_chunk r_151 -> Seq Scan on compress_hyper_14_885_chunk -> Custom Scan (ColumnarScan) on _hyper_13_183_chunk r_152 -> Seq Scan on compress_hyper_14_886_chunk -> Custom Scan (ColumnarScan) on _hyper_13_184_chunk r_153 -> Seq Scan on compress_hyper_14_887_chunk -> Custom Scan (ColumnarScan) on _hyper_13_185_chunk r_154 -> Seq Scan on compress_hyper_14_888_chunk -> Custom Scan (ColumnarScan) on _hyper_13_186_chunk r_155 -> Seq Scan on compress_hyper_14_889_chunk -> Custom Scan (ColumnarScan) on _hyper_13_187_chunk r_156 -> Seq Scan on compress_hyper_14_890_chunk -> Custom Scan (ColumnarScan) on _hyper_13_188_chunk r_157 -> Seq Scan on compress_hyper_14_891_chunk -> Custom Scan (ColumnarScan) on _hyper_13_189_chunk r_158 -> Seq Scan on compress_hyper_14_892_chunk -> Custom Scan (ColumnarScan) on _hyper_13_190_chunk r_159 -> Seq Scan on compress_hyper_14_893_chunk -> Custom Scan (ColumnarScan) on _hyper_13_191_chunk r_160 -> Seq Scan on compress_hyper_14_894_chunk -> Custom Scan (ColumnarScan) on _hyper_13_192_chunk r_161 -> Seq Scan on compress_hyper_14_895_chunk -> Custom Scan (ColumnarScan) on _hyper_13_193_chunk r_162 -> Seq Scan on compress_hyper_14_896_chunk -> Custom Scan (ColumnarScan) on _hyper_13_194_chunk r_163 -> Seq Scan on compress_hyper_14_897_chunk -> Custom Scan (ColumnarScan) on _hyper_13_195_chunk r_164 -> Seq Scan on compress_hyper_14_898_chunk -> Custom Scan (ColumnarScan) on _hyper_13_196_chunk r_165 -> Seq Scan on compress_hyper_14_899_chunk -> Custom Scan (ColumnarScan) on _hyper_13_197_chunk r_166 -> Seq Scan on compress_hyper_14_900_chunk -> Custom Scan (ColumnarScan) on _hyper_13_198_chunk r_167 -> Seq Scan on compress_hyper_14_901_chunk -> Custom Scan (ColumnarScan) on _hyper_13_199_chunk r_168 -> Seq Scan on compress_hyper_14_902_chunk -> Custom Scan (ColumnarScan) on _hyper_13_200_chunk r_169 -> Seq Scan on compress_hyper_14_903_chunk -> Custom Scan (ColumnarScan) on _hyper_13_201_chunk r_170 -> Seq Scan on compress_hyper_14_904_chunk -> Custom Scan (ColumnarScan) on _hyper_13_202_chunk r_171 -> Seq Scan on compress_hyper_14_905_chunk -> Custom Scan (ColumnarScan) on _hyper_13_203_chunk r_172 -> Seq Scan on compress_hyper_14_906_chunk -> Custom Scan (ColumnarScan) on _hyper_13_204_chunk r_173 -> Seq Scan on compress_hyper_14_907_chunk -> Custom Scan (ColumnarScan) on _hyper_13_205_chunk r_174 -> Seq Scan on compress_hyper_14_908_chunk -> Custom Scan (ColumnarScan) on _hyper_13_206_chunk r_175 -> Seq Scan on compress_hyper_14_909_chunk -> Custom Scan (ColumnarScan) on _hyper_13_207_chunk r_176 -> Seq Scan on compress_hyper_14_910_chunk -> Custom Scan (ColumnarScan) on _hyper_13_208_chunk r_177 -> Seq Scan on compress_hyper_14_911_chunk -> Custom Scan (ColumnarScan) on _hyper_13_209_chunk r_178 -> Seq Scan on compress_hyper_14_912_chunk -> Custom Scan (ColumnarScan) on _hyper_13_210_chunk r_179 -> Seq Scan on compress_hyper_14_913_chunk -> Custom Scan (ColumnarScan) on _hyper_13_211_chunk r_180 -> Seq Scan on compress_hyper_14_914_chunk -> Custom Scan (ColumnarScan) on _hyper_13_212_chunk r_181 -> Seq Scan on compress_hyper_14_915_chunk -> Custom Scan (ColumnarScan) on _hyper_13_213_chunk r_182 -> Seq Scan on compress_hyper_14_916_chunk -> Custom Scan (ColumnarScan) on _hyper_13_214_chunk r_183 -> Seq Scan on compress_hyper_14_917_chunk -> Custom Scan (ColumnarScan) on _hyper_13_215_chunk r_184 -> Seq Scan on compress_hyper_14_918_chunk -> Custom Scan (ColumnarScan) on _hyper_13_216_chunk r_185 -> Seq Scan on compress_hyper_14_919_chunk -> Custom Scan (ColumnarScan) on _hyper_13_217_chunk r_186 -> Seq Scan on compress_hyper_14_920_chunk -> Custom Scan (ColumnarScan) on _hyper_13_218_chunk r_187 -> Seq Scan on compress_hyper_14_921_chunk -> Custom Scan (ColumnarScan) on _hyper_13_219_chunk r_188 -> Seq Scan on compress_hyper_14_922_chunk -> Custom Scan (ColumnarScan) on _hyper_13_220_chunk r_189 -> Seq Scan on compress_hyper_14_923_chunk -> Custom Scan (ColumnarScan) on _hyper_13_221_chunk r_190 -> Seq Scan on compress_hyper_14_924_chunk -> Custom Scan (ColumnarScan) on _hyper_13_222_chunk r_191 -> Seq Scan on compress_hyper_14_925_chunk -> Custom Scan (ColumnarScan) on _hyper_13_223_chunk r_192 -> Seq Scan on compress_hyper_14_926_chunk -> Custom Scan (ColumnarScan) on _hyper_13_224_chunk r_193 -> Seq Scan on compress_hyper_14_927_chunk -> Custom Scan (ColumnarScan) on _hyper_13_225_chunk r_194 -> Seq Scan on compress_hyper_14_928_chunk -> Custom Scan (ColumnarScan) on _hyper_13_226_chunk r_195 -> Seq Scan on compress_hyper_14_929_chunk -> Custom Scan (ColumnarScan) on _hyper_13_227_chunk r_196 -> Seq Scan on compress_hyper_14_930_chunk -> Custom Scan (ColumnarScan) on _hyper_13_228_chunk r_197 -> Seq Scan on compress_hyper_14_931_chunk -> Custom Scan (ColumnarScan) on _hyper_13_229_chunk r_198 -> Seq Scan on compress_hyper_14_932_chunk -> Custom Scan (ColumnarScan) on _hyper_13_230_chunk r_199 -> Seq Scan on compress_hyper_14_933_chunk -> Custom Scan (ColumnarScan) on _hyper_13_231_chunk r_200 -> Seq Scan on compress_hyper_14_934_chunk -> Custom Scan (ColumnarScan) on _hyper_13_232_chunk r_201 -> Seq Scan on compress_hyper_14_935_chunk -> Custom Scan (ColumnarScan) on _hyper_13_233_chunk r_202 -> Seq Scan on compress_hyper_14_936_chunk -> Custom Scan (ColumnarScan) on _hyper_13_234_chunk r_203 -> Seq Scan on compress_hyper_14_937_chunk -> Custom Scan (ColumnarScan) on _hyper_13_235_chunk r_204 -> Seq Scan on compress_hyper_14_938_chunk -> Custom Scan (ColumnarScan) on _hyper_13_236_chunk r_205 -> Seq Scan on compress_hyper_14_939_chunk -> Custom Scan (ColumnarScan) on _hyper_13_237_chunk r_206 -> Seq Scan on compress_hyper_14_940_chunk -> Custom Scan (ColumnarScan) on _hyper_13_238_chunk r_207 -> Seq Scan on compress_hyper_14_941_chunk -> Custom Scan (ColumnarScan) on _hyper_13_239_chunk r_208 -> Seq Scan on compress_hyper_14_942_chunk -> Custom Scan (ColumnarScan) on _hyper_13_240_chunk r_209 -> Seq Scan on compress_hyper_14_943_chunk -> Custom Scan (ColumnarScan) on _hyper_13_241_chunk r_210 -> Seq Scan on compress_hyper_14_944_chunk -> Custom Scan (ColumnarScan) on _hyper_13_242_chunk r_211 -> Seq Scan on compress_hyper_14_945_chunk -> Custom Scan (ColumnarScan) on _hyper_13_243_chunk r_212 -> Seq Scan on compress_hyper_14_946_chunk -> Custom Scan (ColumnarScan) on _hyper_13_244_chunk r_213 -> Seq Scan on compress_hyper_14_947_chunk -> Custom Scan (ColumnarScan) on _hyper_13_245_chunk r_214 -> Seq Scan on compress_hyper_14_948_chunk -> Custom Scan (ColumnarScan) on _hyper_13_246_chunk r_215 -> Seq Scan on compress_hyper_14_949_chunk -> Custom Scan (ColumnarScan) on _hyper_13_247_chunk r_216 -> Seq Scan on compress_hyper_14_950_chunk -> Custom Scan (ColumnarScan) on _hyper_13_248_chunk r_217 -> Seq Scan on compress_hyper_14_951_chunk -> Custom Scan (ColumnarScan) on _hyper_13_249_chunk r_218 -> Seq Scan on compress_hyper_14_952_chunk -> Custom Scan (ColumnarScan) on _hyper_13_250_chunk r_219 -> Seq Scan on compress_hyper_14_953_chunk -> Custom Scan (ColumnarScan) on _hyper_13_251_chunk r_220 -> Seq Scan on compress_hyper_14_954_chunk -> Custom Scan (ColumnarScan) on _hyper_13_252_chunk r_221 -> Seq Scan on compress_hyper_14_955_chunk -> Custom Scan (ColumnarScan) on _hyper_13_253_chunk r_222 -> Seq Scan on compress_hyper_14_956_chunk -> Custom Scan (ColumnarScan) on _hyper_13_254_chunk r_223 -> Seq Scan on compress_hyper_14_957_chunk -> Custom Scan (ColumnarScan) on _hyper_13_255_chunk r_224 -> Seq Scan on compress_hyper_14_958_chunk -> Custom Scan (ColumnarScan) on _hyper_13_256_chunk r_225 -> Seq Scan on compress_hyper_14_959_chunk -> Custom Scan (ColumnarScan) on _hyper_13_257_chunk r_226 -> Seq Scan on compress_hyper_14_960_chunk -> Custom Scan (ColumnarScan) on _hyper_13_258_chunk r_227 -> Seq Scan on compress_hyper_14_961_chunk -> Custom Scan (ColumnarScan) on _hyper_13_259_chunk r_228 -> Seq Scan on compress_hyper_14_962_chunk -> Custom Scan (ColumnarScan) on _hyper_13_260_chunk r_229 -> Seq Scan on compress_hyper_14_963_chunk -> Custom Scan (ColumnarScan) on _hyper_13_261_chunk r_230 -> Seq Scan on compress_hyper_14_964_chunk -> Custom Scan (ColumnarScan) on _hyper_13_262_chunk r_231 -> Seq Scan on compress_hyper_14_965_chunk -> Custom Scan (ColumnarScan) on _hyper_13_263_chunk r_232 -> Seq Scan on compress_hyper_14_966_chunk -> Custom Scan (ColumnarScan) on _hyper_13_264_chunk r_233 -> Seq Scan on compress_hyper_14_967_chunk -> Custom Scan (ColumnarScan) on _hyper_13_265_chunk r_234 -> Seq Scan on compress_hyper_14_968_chunk -> Custom Scan (ColumnarScan) on _hyper_13_266_chunk r_235 -> Seq Scan on compress_hyper_14_969_chunk -> Custom Scan (ColumnarScan) on _hyper_13_267_chunk r_236 -> Seq Scan on compress_hyper_14_970_chunk -> Custom Scan (ColumnarScan) on _hyper_13_268_chunk r_237 -> Seq Scan on compress_hyper_14_971_chunk -> Custom Scan (ColumnarScan) on _hyper_13_269_chunk r_238 -> Seq Scan on compress_hyper_14_972_chunk -> Custom Scan (ColumnarScan) on _hyper_13_270_chunk r_239 -> Seq Scan on compress_hyper_14_973_chunk -> Custom Scan (ColumnarScan) on _hyper_13_271_chunk r_240 -> Seq Scan on compress_hyper_14_974_chunk -> Custom Scan (ColumnarScan) on _hyper_13_272_chunk r_241 -> Seq Scan on compress_hyper_14_975_chunk -> Custom Scan (ColumnarScan) on _hyper_13_273_chunk r_242 -> Seq Scan on compress_hyper_14_976_chunk -> Custom Scan (ColumnarScan) on _hyper_13_274_chunk r_243 -> Seq Scan on compress_hyper_14_977_chunk -> Custom Scan (ColumnarScan) on _hyper_13_275_chunk r_244 -> Seq Scan on compress_hyper_14_978_chunk -> Custom Scan (ColumnarScan) on _hyper_13_276_chunk r_245 -> Seq Scan on compress_hyper_14_979_chunk -> Custom Scan (ColumnarScan) on _hyper_13_277_chunk r_246 -> Seq Scan on compress_hyper_14_980_chunk -> Custom Scan (ColumnarScan) on _hyper_13_278_chunk r_247 -> Seq Scan on compress_hyper_14_981_chunk -> Custom Scan (ColumnarScan) on _hyper_13_279_chunk r_248 -> Seq Scan on compress_hyper_14_982_chunk -> Custom Scan (ColumnarScan) on _hyper_13_280_chunk r_249 -> Seq Scan on compress_hyper_14_983_chunk -> Custom Scan (ColumnarScan) on _hyper_13_281_chunk r_250 -> Seq Scan on compress_hyper_14_984_chunk -> Custom Scan (ColumnarScan) on _hyper_13_282_chunk r_251 -> Seq Scan on compress_hyper_14_985_chunk -> Custom Scan (ColumnarScan) on _hyper_13_283_chunk r_252 -> Seq Scan on compress_hyper_14_986_chunk -> Custom Scan (ColumnarScan) on _hyper_13_284_chunk r_253 -> Seq Scan on compress_hyper_14_987_chunk -> Custom Scan (ColumnarScan) on _hyper_13_285_chunk r_254 -> Seq Scan on compress_hyper_14_988_chunk -> Custom Scan (ColumnarScan) on _hyper_13_286_chunk r_255 -> Seq Scan on compress_hyper_14_989_chunk -> Custom Scan (ColumnarScan) on _hyper_13_287_chunk r_256 -> Seq Scan on compress_hyper_14_990_chunk -> Custom Scan (ColumnarScan) on _hyper_13_288_chunk r_257 -> Seq Scan on compress_hyper_14_991_chunk -> Custom Scan (ColumnarScan) on _hyper_13_289_chunk r_258 -> Seq Scan on compress_hyper_14_992_chunk -> Custom Scan (ColumnarScan) on _hyper_13_290_chunk r_259 -> Seq Scan on compress_hyper_14_993_chunk -> Custom Scan (ColumnarScan) on _hyper_13_291_chunk r_260 -> Seq Scan on compress_hyper_14_994_chunk -> Custom Scan (ColumnarScan) on _hyper_13_292_chunk r_261 -> Seq Scan on compress_hyper_14_995_chunk -> Custom Scan (ColumnarScan) on _hyper_13_293_chunk r_262 -> Seq Scan on compress_hyper_14_996_chunk -> Custom Scan (ColumnarScan) on _hyper_13_294_chunk r_263 -> Seq Scan on compress_hyper_14_997_chunk -> Custom Scan (ColumnarScan) on _hyper_13_295_chunk r_264 -> Seq Scan on compress_hyper_14_998_chunk -> Custom Scan (ColumnarScan) on _hyper_13_296_chunk r_265 -> Seq Scan on compress_hyper_14_999_chunk -> Custom Scan (ColumnarScan) on _hyper_13_297_chunk r_266 -> Seq Scan on compress_hyper_14_1000_chunk -> Custom Scan (ColumnarScan) on _hyper_13_298_chunk r_267 -> Seq Scan on compress_hyper_14_1001_chunk -> Custom Scan (ColumnarScan) on _hyper_13_299_chunk r_268 -> Seq Scan on compress_hyper_14_1002_chunk -> Custom Scan (ColumnarScan) on _hyper_13_300_chunk r_269 -> Seq Scan on compress_hyper_14_1003_chunk -> Custom Scan (ColumnarScan) on _hyper_13_301_chunk r_270 -> Seq Scan on compress_hyper_14_1004_chunk -> Custom Scan (ColumnarScan) on _hyper_13_302_chunk r_271 -> Seq Scan on compress_hyper_14_1005_chunk -> Custom Scan (ColumnarScan) on _hyper_13_303_chunk r_272 -> Seq Scan on compress_hyper_14_1006_chunk -> Custom Scan (ColumnarScan) on _hyper_13_304_chunk r_273 -> Seq Scan on compress_hyper_14_1007_chunk -> Custom Scan (ColumnarScan) on _hyper_13_305_chunk r_274 -> Seq Scan on compress_hyper_14_1008_chunk -> Custom Scan (ColumnarScan) on _hyper_13_306_chunk r_275 -> Seq Scan on compress_hyper_14_1009_chunk -> Custom Scan (ColumnarScan) on _hyper_13_307_chunk r_276 -> Seq Scan on compress_hyper_14_1010_chunk -> Custom Scan (ColumnarScan) on _hyper_13_308_chunk r_277 -> Seq Scan on compress_hyper_14_1011_chunk -> Custom Scan (ColumnarScan) on _hyper_13_309_chunk r_278 -> Seq Scan on compress_hyper_14_1012_chunk -> Custom Scan (ColumnarScan) on _hyper_13_310_chunk r_279 -> Seq Scan on compress_hyper_14_1013_chunk -> Custom Scan (ColumnarScan) on _hyper_13_311_chunk r_280 -> Seq Scan on compress_hyper_14_1014_chunk -> Custom Scan (ColumnarScan) on _hyper_13_312_chunk r_281 -> Seq Scan on compress_hyper_14_1015_chunk -> Custom Scan (ColumnarScan) on _hyper_13_313_chunk r_282 -> Seq Scan on compress_hyper_14_1016_chunk -> Custom Scan (ColumnarScan) on _hyper_13_314_chunk r_283 -> Seq Scan on compress_hyper_14_1017_chunk -> Custom Scan (ColumnarScan) on _hyper_13_315_chunk r_284 -> Seq Scan on compress_hyper_14_1018_chunk -> Custom Scan (ColumnarScan) on _hyper_13_316_chunk r_285 -> Seq Scan on compress_hyper_14_1019_chunk -> Custom Scan (ColumnarScan) on _hyper_13_317_chunk r_286 -> Seq Scan on compress_hyper_14_1020_chunk -> Custom Scan (ColumnarScan) on _hyper_13_318_chunk r_287 -> Seq Scan on compress_hyper_14_1021_chunk -> Custom Scan (ColumnarScan) on _hyper_13_319_chunk r_288 -> Seq Scan on compress_hyper_14_1022_chunk -> Custom Scan (ColumnarScan) on _hyper_13_320_chunk r_289 -> Seq Scan on compress_hyper_14_1023_chunk -> Custom Scan (ColumnarScan) on _hyper_13_321_chunk r_290 -> Seq Scan on compress_hyper_14_1024_chunk -> Custom Scan (ColumnarScan) on _hyper_13_322_chunk r_291 -> Seq Scan on compress_hyper_14_1025_chunk -> Custom Scan (ColumnarScan) on _hyper_13_323_chunk r_292 -> Seq Scan on compress_hyper_14_1026_chunk -> Custom Scan (ColumnarScan) on _hyper_13_324_chunk r_293 -> Seq Scan on compress_hyper_14_1027_chunk -> Custom Scan (ColumnarScan) on _hyper_13_325_chunk r_294 -> Seq Scan on compress_hyper_14_1028_chunk -> Custom Scan (ColumnarScan) on _hyper_13_326_chunk r_295 -> Seq Scan on compress_hyper_14_1029_chunk -> Custom Scan (ColumnarScan) on _hyper_13_327_chunk r_296 -> Seq Scan on compress_hyper_14_1030_chunk -> Custom Scan (ColumnarScan) on _hyper_13_328_chunk r_297 -> Seq Scan on compress_hyper_14_1031_chunk -> Custom Scan (ColumnarScan) on _hyper_13_329_chunk r_298 -> Seq Scan on compress_hyper_14_1032_chunk -> Custom Scan (ColumnarScan) on _hyper_13_330_chunk r_299 -> Seq Scan on compress_hyper_14_1033_chunk -> Custom Scan (ColumnarScan) on _hyper_13_331_chunk r_300 -> Seq Scan on compress_hyper_14_1034_chunk -> Custom Scan (ColumnarScan) on _hyper_13_332_chunk r_301 -> Seq Scan on compress_hyper_14_1035_chunk -> Custom Scan (ColumnarScan) on _hyper_13_333_chunk r_302 -> Seq Scan on compress_hyper_14_1036_chunk -> Custom Scan (ColumnarScan) on _hyper_13_334_chunk r_303 -> Seq Scan on compress_hyper_14_1037_chunk -> Custom Scan (ColumnarScan) on _hyper_13_335_chunk r_304 -> Seq Scan on compress_hyper_14_1038_chunk -> Custom Scan (ColumnarScan) on _hyper_13_336_chunk r_305 -> Seq Scan on compress_hyper_14_1039_chunk -> Custom Scan (ColumnarScan) on _hyper_13_337_chunk r_306 -> Seq Scan on compress_hyper_14_1040_chunk -> Custom Scan (ColumnarScan) on _hyper_13_338_chunk r_307 -> Seq Scan on compress_hyper_14_1041_chunk -> Custom Scan (ColumnarScan) on _hyper_13_339_chunk r_308 -> Seq Scan on compress_hyper_14_1042_chunk -> Custom Scan (ColumnarScan) on _hyper_13_340_chunk r_309 -> Seq Scan on compress_hyper_14_1043_chunk -> Custom Scan (ColumnarScan) on _hyper_13_341_chunk r_310 -> Seq Scan on compress_hyper_14_1044_chunk -> Custom Scan (ColumnarScan) on _hyper_13_342_chunk r_311 -> Seq Scan on compress_hyper_14_1045_chunk -> Custom Scan (ColumnarScan) on _hyper_13_343_chunk r_312 -> Seq Scan on compress_hyper_14_1046_chunk -> Custom Scan (ColumnarScan) on _hyper_13_344_chunk r_313 -> Seq Scan on compress_hyper_14_1047_chunk -> Custom Scan (ColumnarScan) on _hyper_13_345_chunk r_314 -> Seq Scan on compress_hyper_14_1048_chunk -> Custom Scan (ColumnarScan) on _hyper_13_346_chunk r_315 -> Seq Scan on compress_hyper_14_1049_chunk -> Custom Scan (ColumnarScan) on _hyper_13_347_chunk r_316 -> Seq Scan on compress_hyper_14_1050_chunk -> Custom Scan (ColumnarScan) on _hyper_13_348_chunk r_317 -> Seq Scan on compress_hyper_14_1051_chunk -> Custom Scan (ColumnarScan) on _hyper_13_349_chunk r_318 -> Seq Scan on compress_hyper_14_1052_chunk -> Custom Scan (ColumnarScan) on _hyper_13_350_chunk r_319 -> Seq Scan on compress_hyper_14_1053_chunk -> Custom Scan (ColumnarScan) on _hyper_13_351_chunk r_320 -> Seq Scan on compress_hyper_14_1054_chunk -> Custom Scan (ColumnarScan) on _hyper_13_352_chunk r_321 -> Seq Scan on compress_hyper_14_1055_chunk -> Custom Scan (ColumnarScan) on _hyper_13_353_chunk r_322 -> Seq Scan on compress_hyper_14_1056_chunk -> Custom Scan (ColumnarScan) on _hyper_13_354_chunk r_323 -> Seq Scan on compress_hyper_14_1057_chunk -> Custom Scan (ColumnarScan) on _hyper_13_355_chunk r_324 -> Seq Scan on compress_hyper_14_1058_chunk -> Custom Scan (ColumnarScan) on _hyper_13_356_chunk r_325 -> Seq Scan on compress_hyper_14_1059_chunk -> Custom Scan (ColumnarScan) on _hyper_13_357_chunk r_326 -> Seq Scan on compress_hyper_14_1060_chunk -> Custom Scan (ColumnarScan) on _hyper_13_358_chunk r_327 -> Seq Scan on compress_hyper_14_1061_chunk -> Custom Scan (ColumnarScan) on _hyper_13_359_chunk r_328 -> Seq Scan on compress_hyper_14_1062_chunk -> Custom Scan (ColumnarScan) on _hyper_13_360_chunk r_329 -> Seq Scan on compress_hyper_14_1063_chunk -> Custom Scan (ColumnarScan) on _hyper_13_361_chunk r_330 -> Seq Scan on compress_hyper_14_1064_chunk -> Custom Scan (ColumnarScan) on _hyper_13_362_chunk r_331 -> Seq Scan on compress_hyper_14_1065_chunk -> Custom Scan (ColumnarScan) on _hyper_13_363_chunk r_332 -> Seq Scan on compress_hyper_14_1066_chunk -> Custom Scan (ColumnarScan) on _hyper_13_364_chunk r_333 -> Seq Scan on compress_hyper_14_1067_chunk -> Custom Scan (ColumnarScan) on _hyper_13_365_chunk r_334 -> Seq Scan on compress_hyper_14_1068_chunk -> Custom Scan (ColumnarScan) on _hyper_13_366_chunk r_335 -> Seq Scan on compress_hyper_14_1069_chunk -> Custom Scan (ColumnarScan) on _hyper_13_367_chunk r_336 -> Seq Scan on compress_hyper_14_1070_chunk -> Custom Scan (ColumnarScan) on _hyper_13_368_chunk r_337 -> Seq Scan on compress_hyper_14_1071_chunk -> Custom Scan (ColumnarScan) on _hyper_13_369_chunk r_338 -> Seq Scan on compress_hyper_14_1072_chunk -> Custom Scan (ColumnarScan) on _hyper_13_370_chunk r_339 -> Seq Scan on compress_hyper_14_1073_chunk -> Custom Scan (ColumnarScan) on _hyper_13_371_chunk r_340 -> Seq Scan on compress_hyper_14_1074_chunk -> Custom Scan (ColumnarScan) on _hyper_13_372_chunk r_341 -> Seq Scan on compress_hyper_14_1075_chunk -> Custom Scan (ColumnarScan) on _hyper_13_373_chunk r_342 -> Seq Scan on compress_hyper_14_1076_chunk -> Custom Scan (ColumnarScan) on _hyper_13_374_chunk r_343 -> Seq Scan on compress_hyper_14_1077_chunk -> Custom Scan (ColumnarScan) on _hyper_13_375_chunk r_344 -> Seq Scan on compress_hyper_14_1078_chunk -> Custom Scan (ColumnarScan) on _hyper_13_376_chunk r_345 -> Seq Scan on compress_hyper_14_1079_chunk -> Custom Scan (ColumnarScan) on _hyper_13_377_chunk r_346 -> Seq Scan on compress_hyper_14_1080_chunk -> Custom Scan (ColumnarScan) on _hyper_13_378_chunk r_347 -> Seq Scan on compress_hyper_14_1081_chunk -> Custom Scan (ColumnarScan) on _hyper_13_379_chunk r_348 -> Seq Scan on compress_hyper_14_1082_chunk -> Custom Scan (ColumnarScan) on _hyper_13_380_chunk r_349 -> Seq Scan on compress_hyper_14_1083_chunk -> Custom Scan (ColumnarScan) on _hyper_13_381_chunk r_350 -> Seq Scan on compress_hyper_14_1084_chunk -> Custom Scan (ColumnarScan) on _hyper_13_382_chunk r_351 -> Seq Scan on compress_hyper_14_1085_chunk -> Custom Scan (ColumnarScan) on _hyper_13_383_chunk r_352 -> Seq Scan on compress_hyper_14_1086_chunk -> Custom Scan (ColumnarScan) on _hyper_13_384_chunk r_353 -> Seq Scan on compress_hyper_14_1087_chunk -> Custom Scan (ColumnarScan) on _hyper_13_385_chunk r_354 -> Seq Scan on compress_hyper_14_1088_chunk -> Custom Scan (ColumnarScan) on _hyper_13_386_chunk r_355 -> Seq Scan on compress_hyper_14_1089_chunk -> Custom Scan (ColumnarScan) on _hyper_13_387_chunk r_356 -> Seq Scan on compress_hyper_14_1090_chunk -> Custom Scan (ColumnarScan) on _hyper_13_388_chunk r_357 -> Seq Scan on compress_hyper_14_1091_chunk -> Custom Scan (ColumnarScan) on _hyper_13_389_chunk r_358 -> Seq Scan on compress_hyper_14_1092_chunk -> Custom Scan (ColumnarScan) on _hyper_13_390_chunk r_359 -> Seq Scan on compress_hyper_14_1093_chunk -> Custom Scan (ColumnarScan) on _hyper_13_391_chunk r_360 -> Seq Scan on compress_hyper_14_1094_chunk -> Custom Scan (ColumnarScan) on _hyper_13_392_chunk r_361 -> Seq Scan on compress_hyper_14_1095_chunk -> Custom Scan (ColumnarScan) on _hyper_13_393_chunk r_362 -> Seq Scan on compress_hyper_14_1096_chunk -> Custom Scan (ColumnarScan) on _hyper_13_394_chunk r_363 -> Seq Scan on compress_hyper_14_1097_chunk -> Custom Scan (ColumnarScan) on _hyper_13_395_chunk r_364 -> Seq Scan on compress_hyper_14_1098_chunk -> Custom Scan (ColumnarScan) on _hyper_13_396_chunk r_365 -> Seq Scan on compress_hyper_14_1099_chunk -> Custom Scan (ColumnarScan) on _hyper_13_397_chunk r_366 -> Seq Scan on compress_hyper_14_1100_chunk -> Custom Scan (ColumnarScan) on _hyper_13_398_chunk r_367 -> Seq Scan on compress_hyper_14_1101_chunk -> Custom Scan (ColumnarScan) on _hyper_13_399_chunk r_368 -> Seq Scan on compress_hyper_14_1102_chunk -> Custom Scan (ColumnarScan) on _hyper_13_400_chunk r_369 -> Seq Scan on compress_hyper_14_1103_chunk -> Custom Scan (ColumnarScan) on _hyper_13_401_chunk r_370 -> Seq Scan on compress_hyper_14_1104_chunk -> Custom Scan (ColumnarScan) on _hyper_13_402_chunk r_371 -> Seq Scan on compress_hyper_14_1105_chunk -> Custom Scan (ColumnarScan) on _hyper_13_403_chunk r_372 -> Seq Scan on compress_hyper_14_1106_chunk -> Custom Scan (ColumnarScan) on _hyper_13_404_chunk r_373 -> Seq Scan on compress_hyper_14_1107_chunk -> Custom Scan (ColumnarScan) on _hyper_13_405_chunk r_374 -> Seq Scan on compress_hyper_14_1108_chunk -> Custom Scan (ColumnarScan) on _hyper_13_406_chunk r_375 -> Seq Scan on compress_hyper_14_1109_chunk -> Custom Scan (ColumnarScan) on _hyper_13_407_chunk r_376 -> Seq Scan on compress_hyper_14_1110_chunk -> Custom Scan (ColumnarScan) on _hyper_13_408_chunk r_377 -> Seq Scan on compress_hyper_14_1111_chunk -> Custom Scan (ColumnarScan) on _hyper_13_409_chunk r_378 -> Seq Scan on compress_hyper_14_1112_chunk -> Custom Scan (ColumnarScan) on _hyper_13_410_chunk r_379 -> Seq Scan on compress_hyper_14_1113_chunk -> Custom Scan (ColumnarScan) on _hyper_13_411_chunk r_380 -> Seq Scan on compress_hyper_14_1114_chunk -> Custom Scan (ColumnarScan) on _hyper_13_412_chunk r_381 -> Seq Scan on compress_hyper_14_1115_chunk -> Custom Scan (ColumnarScan) on _hyper_13_413_chunk r_382 -> Seq Scan on compress_hyper_14_1116_chunk -> Custom Scan (ColumnarScan) on _hyper_13_414_chunk r_383 -> Seq Scan on compress_hyper_14_1117_chunk -> Custom Scan (ColumnarScan) on _hyper_13_415_chunk r_384 -> Seq Scan on compress_hyper_14_1118_chunk -> Custom Scan (ColumnarScan) on _hyper_13_416_chunk r_385 -> Seq Scan on compress_hyper_14_1119_chunk -> Custom Scan (ColumnarScan) on _hyper_13_417_chunk r_386 -> Seq Scan on compress_hyper_14_1120_chunk -> Custom Scan (ColumnarScan) on _hyper_13_418_chunk r_387 -> Seq Scan on compress_hyper_14_1121_chunk -> Custom Scan (ColumnarScan) on _hyper_13_419_chunk r_388 -> Seq Scan on compress_hyper_14_1122_chunk -> Custom Scan (ColumnarScan) on _hyper_13_420_chunk r_389 -> Seq Scan on compress_hyper_14_1123_chunk -> Custom Scan (ColumnarScan) on _hyper_13_421_chunk r_390 -> Seq Scan on compress_hyper_14_1124_chunk -> Custom Scan (ColumnarScan) on _hyper_13_422_chunk r_391 -> Seq Scan on compress_hyper_14_1125_chunk -> Custom Scan (ColumnarScan) on _hyper_13_423_chunk r_392 -> Seq Scan on compress_hyper_14_1126_chunk -> Custom Scan (ColumnarScan) on _hyper_13_424_chunk r_393 -> Seq Scan on compress_hyper_14_1127_chunk -> Custom Scan (ColumnarScan) on _hyper_13_425_chunk r_394 -> Seq Scan on compress_hyper_14_1128_chunk -> Custom Scan (ColumnarScan) on _hyper_13_426_chunk r_395 -> Seq Scan on compress_hyper_14_1129_chunk -> Custom Scan (ColumnarScan) on _hyper_13_427_chunk r_396 -> Seq Scan on compress_hyper_14_1130_chunk -> Custom Scan (ColumnarScan) on _hyper_13_428_chunk r_397 -> Seq Scan on compress_hyper_14_1131_chunk -> Custom Scan (ColumnarScan) on _hyper_13_429_chunk r_398 -> Seq Scan on compress_hyper_14_1132_chunk -> Custom Scan (ColumnarScan) on _hyper_13_430_chunk r_399 -> Seq Scan on compress_hyper_14_1133_chunk -> Custom Scan (ColumnarScan) on _hyper_13_431_chunk r_400 -> Seq Scan on compress_hyper_14_1134_chunk -> Custom Scan (ColumnarScan) on _hyper_13_432_chunk r_401 -> Seq Scan on compress_hyper_14_1135_chunk -> Custom Scan (ColumnarScan) on _hyper_13_433_chunk r_402 -> Seq Scan on compress_hyper_14_1136_chunk -> Custom Scan (ColumnarScan) on _hyper_13_434_chunk r_403 -> Seq Scan on compress_hyper_14_1137_chunk -> Custom Scan (ColumnarScan) on _hyper_13_435_chunk r_404 -> Seq Scan on compress_hyper_14_1138_chunk -> Custom Scan (ColumnarScan) on _hyper_13_436_chunk r_405 -> Seq Scan on compress_hyper_14_1139_chunk -> Custom Scan (ColumnarScan) on _hyper_13_437_chunk r_406 -> Seq Scan on compress_hyper_14_1140_chunk -> Custom Scan (ColumnarScan) on _hyper_13_438_chunk r_407 -> Seq Scan on compress_hyper_14_1141_chunk -> Custom Scan (ColumnarScan) on _hyper_13_439_chunk r_408 -> Seq Scan on compress_hyper_14_1142_chunk -> Custom Scan (ColumnarScan) on _hyper_13_440_chunk r_409 -> Seq Scan on compress_hyper_14_1143_chunk -> Custom Scan (ColumnarScan) on _hyper_13_441_chunk r_410 -> Seq Scan on compress_hyper_14_1144_chunk -> Custom Scan (ColumnarScan) on _hyper_13_442_chunk r_411 -> Seq Scan on compress_hyper_14_1145_chunk -> Custom Scan (ColumnarScan) on _hyper_13_443_chunk r_412 -> Seq Scan on compress_hyper_14_1146_chunk -> Custom Scan (ColumnarScan) on _hyper_13_444_chunk r_413 -> Seq Scan on compress_hyper_14_1147_chunk -> Custom Scan (ColumnarScan) on _hyper_13_445_chunk r_414 -> Seq Scan on compress_hyper_14_1148_chunk -> Custom Scan (ColumnarScan) on _hyper_13_446_chunk r_415 -> Seq Scan on compress_hyper_14_1149_chunk -> Custom Scan (ColumnarScan) on _hyper_13_447_chunk r_416 -> Seq Scan on compress_hyper_14_1150_chunk -> Custom Scan (ColumnarScan) on _hyper_13_448_chunk r_417 -> Seq Scan on compress_hyper_14_1151_chunk -> Custom Scan (ColumnarScan) on _hyper_13_449_chunk r_418 -> Seq Scan on compress_hyper_14_1152_chunk -> Custom Scan (ColumnarScan) on _hyper_13_450_chunk r_419 -> Seq Scan on compress_hyper_14_1153_chunk -> Custom Scan (ColumnarScan) on _hyper_13_451_chunk r_420 -> Seq Scan on compress_hyper_14_1154_chunk -> Custom Scan (ColumnarScan) on _hyper_13_452_chunk r_421 -> Seq Scan on compress_hyper_14_1155_chunk -> Custom Scan (ColumnarScan) on _hyper_13_453_chunk r_422 -> Seq Scan on compress_hyper_14_1156_chunk -> Custom Scan (ColumnarScan) on _hyper_13_454_chunk r_423 -> Seq Scan on compress_hyper_14_1157_chunk -> Custom Scan (ColumnarScan) on _hyper_13_455_chunk r_424 -> Seq Scan on compress_hyper_14_1158_chunk -> Custom Scan (ColumnarScan) on _hyper_13_456_chunk r_425 -> Seq Scan on compress_hyper_14_1159_chunk -> Custom Scan (ColumnarScan) on _hyper_13_457_chunk r_426 -> Seq Scan on compress_hyper_14_1160_chunk -> Custom Scan (ColumnarScan) on _hyper_13_458_chunk r_427 -> Seq Scan on compress_hyper_14_1161_chunk -> Custom Scan (ColumnarScan) on _hyper_13_459_chunk r_428 -> Seq Scan on compress_hyper_14_1162_chunk -> Custom Scan (ColumnarScan) on _hyper_13_460_chunk r_429 -> Seq Scan on compress_hyper_14_1163_chunk -> Custom Scan (ColumnarScan) on _hyper_13_461_chunk r_430 -> Seq Scan on compress_hyper_14_1164_chunk -> Custom Scan (ColumnarScan) on _hyper_13_462_chunk r_431 -> Seq Scan on compress_hyper_14_1165_chunk -> Custom Scan (ColumnarScan) on _hyper_13_463_chunk r_432 -> Seq Scan on compress_hyper_14_1166_chunk -> Custom Scan (ColumnarScan) on _hyper_13_464_chunk r_433 -> Seq Scan on compress_hyper_14_1167_chunk -> Custom Scan (ColumnarScan) on _hyper_13_465_chunk r_434 -> Seq Scan on compress_hyper_14_1168_chunk -> Custom Scan (ColumnarScan) on _hyper_13_466_chunk r_435 -> Seq Scan on compress_hyper_14_1169_chunk -> Custom Scan (ColumnarScan) on _hyper_13_467_chunk r_436 -> Seq Scan on compress_hyper_14_1170_chunk -> Custom Scan (ColumnarScan) on _hyper_13_468_chunk r_437 -> Seq Scan on compress_hyper_14_1171_chunk -> Custom Scan (ColumnarScan) on _hyper_13_469_chunk r_438 -> Seq Scan on compress_hyper_14_1172_chunk -> Custom Scan (ColumnarScan) on _hyper_13_470_chunk r_439 -> Seq Scan on compress_hyper_14_1173_chunk -> Custom Scan (ColumnarScan) on _hyper_13_471_chunk r_440 -> Seq Scan on compress_hyper_14_1174_chunk -> Custom Scan (ColumnarScan) on _hyper_13_472_chunk r_441 -> Seq Scan on compress_hyper_14_1175_chunk -> Custom Scan (ColumnarScan) on _hyper_13_473_chunk r_442 -> Seq Scan on compress_hyper_14_1176_chunk -> Custom Scan (ColumnarScan) on _hyper_13_474_chunk r_443 -> Seq Scan on compress_hyper_14_1177_chunk -> Custom Scan (ColumnarScan) on _hyper_13_475_chunk r_444 -> Seq Scan on compress_hyper_14_1178_chunk -> Custom Scan (ColumnarScan) on _hyper_13_476_chunk r_445 -> Seq Scan on compress_hyper_14_1179_chunk -> Custom Scan (ColumnarScan) on _hyper_13_477_chunk r_446 -> Seq Scan on compress_hyper_14_1180_chunk -> Custom Scan (ColumnarScan) on _hyper_13_478_chunk r_447 -> Seq Scan on compress_hyper_14_1181_chunk -> Custom Scan (ColumnarScan) on _hyper_13_479_chunk r_448 -> Seq Scan on compress_hyper_14_1182_chunk -> Custom Scan (ColumnarScan) on _hyper_13_480_chunk r_449 -> Seq Scan on compress_hyper_14_1183_chunk -> Custom Scan (ColumnarScan) on _hyper_13_481_chunk r_450 -> Seq Scan on compress_hyper_14_1184_chunk -> Custom Scan (ColumnarScan) on _hyper_13_482_chunk r_451 -> Seq Scan on compress_hyper_14_1185_chunk -> Custom Scan (ColumnarScan) on _hyper_13_483_chunk r_452 -> Seq Scan on compress_hyper_14_1186_chunk -> Custom Scan (ColumnarScan) on _hyper_13_484_chunk r_453 -> Seq Scan on compress_hyper_14_1187_chunk -> Custom Scan (ColumnarScan) on _hyper_13_485_chunk r_454 -> Seq Scan on compress_hyper_14_1188_chunk -> Custom Scan (ColumnarScan) on _hyper_13_486_chunk r_455 -> Seq Scan on compress_hyper_14_1189_chunk -> Custom Scan (ColumnarScan) on _hyper_13_487_chunk r_456 -> Seq Scan on compress_hyper_14_1190_chunk -> Custom Scan (ColumnarScan) on _hyper_13_488_chunk r_457 -> Seq Scan on compress_hyper_14_1191_chunk -> Custom Scan (ColumnarScan) on _hyper_13_489_chunk r_458 -> Seq Scan on compress_hyper_14_1192_chunk -> Custom Scan (ColumnarScan) on _hyper_13_490_chunk r_459 -> Seq Scan on compress_hyper_14_1193_chunk -> Custom Scan (ColumnarScan) on _hyper_13_491_chunk r_460 -> Seq Scan on compress_hyper_14_1194_chunk -> Custom Scan (ColumnarScan) on _hyper_13_492_chunk r_461 -> Seq Scan on compress_hyper_14_1195_chunk -> Custom Scan (ColumnarScan) on _hyper_13_493_chunk r_462 -> Seq Scan on compress_hyper_14_1196_chunk -> Custom Scan (ColumnarScan) on _hyper_13_494_chunk r_463 -> Seq Scan on compress_hyper_14_1197_chunk -> Custom Scan (ColumnarScan) on _hyper_13_495_chunk r_464 -> Seq Scan on compress_hyper_14_1198_chunk -> Custom Scan (ColumnarScan) on _hyper_13_496_chunk r_465 -> Seq Scan on compress_hyper_14_1199_chunk -> Custom Scan (ColumnarScan) on _hyper_13_497_chunk r_466 -> Seq Scan on compress_hyper_14_1200_chunk -> Custom Scan (ColumnarScan) on _hyper_13_498_chunk r_467 -> Seq Scan on compress_hyper_14_1201_chunk -> Custom Scan (ColumnarScan) on _hyper_13_499_chunk r_468 -> Seq Scan on compress_hyper_14_1202_chunk -> Custom Scan (ColumnarScan) on _hyper_13_500_chunk r_469 -> Seq Scan on compress_hyper_14_1203_chunk -> Custom Scan (ColumnarScan) on _hyper_13_501_chunk r_470 -> Seq Scan on compress_hyper_14_1204_chunk -> Custom Scan (ColumnarScan) on _hyper_13_502_chunk r_471 -> Seq Scan on compress_hyper_14_1205_chunk -> Custom Scan (ColumnarScan) on _hyper_13_503_chunk r_472 -> Seq Scan on compress_hyper_14_1206_chunk -> Custom Scan (ColumnarScan) on _hyper_13_504_chunk r_473 -> Seq Scan on compress_hyper_14_1207_chunk -> Custom Scan (ColumnarScan) on _hyper_13_505_chunk r_474 -> Seq Scan on compress_hyper_14_1208_chunk -> Custom Scan (ColumnarScan) on _hyper_13_506_chunk r_475 -> Seq Scan on compress_hyper_14_1209_chunk -> Custom Scan (ColumnarScan) on _hyper_13_507_chunk r_476 -> Seq Scan on compress_hyper_14_1210_chunk -> Custom Scan (ColumnarScan) on _hyper_13_508_chunk r_477 -> Seq Scan on compress_hyper_14_1211_chunk -> Custom Scan (ColumnarScan) on _hyper_13_509_chunk r_478 -> Seq Scan on compress_hyper_14_1212_chunk -> Custom Scan (ColumnarScan) on _hyper_13_510_chunk r_479 -> Seq Scan on compress_hyper_14_1213_chunk -> Custom Scan (ColumnarScan) on _hyper_13_511_chunk r_480 -> Seq Scan on compress_hyper_14_1214_chunk -> Custom Scan (ColumnarScan) on _hyper_13_512_chunk r_481 -> Seq Scan on compress_hyper_14_1215_chunk -> Custom Scan (ColumnarScan) on _hyper_13_513_chunk r_482 -> Seq Scan on compress_hyper_14_1216_chunk -> Custom Scan (ColumnarScan) on _hyper_13_514_chunk r_483 -> Seq Scan on compress_hyper_14_1217_chunk -> Custom Scan (ColumnarScan) on _hyper_13_515_chunk r_484 -> Seq Scan on compress_hyper_14_1218_chunk -> Custom Scan (ColumnarScan) on _hyper_13_516_chunk r_485 -> Seq Scan on compress_hyper_14_1219_chunk -> Custom Scan (ColumnarScan) on _hyper_13_517_chunk r_486 -> Seq Scan on compress_hyper_14_1220_chunk -> Custom Scan (ColumnarScan) on _hyper_13_518_chunk r_487 -> Seq Scan on compress_hyper_14_1221_chunk -> Custom Scan (ColumnarScan) on _hyper_13_519_chunk r_488 -> Seq Scan on compress_hyper_14_1222_chunk -> Custom Scan (ColumnarScan) on _hyper_13_520_chunk r_489 -> Seq Scan on compress_hyper_14_1223_chunk -> Custom Scan (ColumnarScan) on _hyper_13_521_chunk r_490 -> Seq Scan on compress_hyper_14_1224_chunk -> Custom Scan (ColumnarScan) on _hyper_13_522_chunk r_491 -> Seq Scan on compress_hyper_14_1225_chunk -> Custom Scan (ColumnarScan) on _hyper_13_523_chunk r_492 -> Seq Scan on compress_hyper_14_1226_chunk -> Custom Scan (ColumnarScan) on _hyper_13_524_chunk r_493 -> Seq Scan on compress_hyper_14_1227_chunk -> Custom Scan (ColumnarScan) on _hyper_13_525_chunk r_494 -> Seq Scan on compress_hyper_14_1228_chunk -> Custom Scan (ColumnarScan) on _hyper_13_526_chunk r_495 -> Seq Scan on compress_hyper_14_1229_chunk -> Custom Scan (ColumnarScan) on _hyper_13_527_chunk r_496 -> Seq Scan on compress_hyper_14_1230_chunk -> Custom Scan (ColumnarScan) on _hyper_13_528_chunk r_497 -> Seq Scan on compress_hyper_14_1231_chunk -> Custom Scan (ColumnarScan) on _hyper_13_529_chunk r_498 -> Seq Scan on compress_hyper_14_1232_chunk -> Custom Scan (ColumnarScan) on _hyper_13_530_chunk r_499 -> Seq Scan on compress_hyper_14_1233_chunk -> Custom Scan (ColumnarScan) on _hyper_13_531_chunk r_500 -> Seq Scan on compress_hyper_14_1234_chunk -> Custom Scan (ColumnarScan) on _hyper_13_532_chunk r_501 -> Seq Scan on compress_hyper_14_1235_chunk -> Custom Scan (ColumnarScan) on _hyper_13_533_chunk r_502 -> Seq Scan on compress_hyper_14_1236_chunk -> Custom Scan (ColumnarScan) on _hyper_13_534_chunk r_503 -> Seq Scan on compress_hyper_14_1237_chunk -> Custom Scan (ColumnarScan) on _hyper_13_535_chunk r_504 -> Seq Scan on compress_hyper_14_1238_chunk -> Custom Scan (ColumnarScan) on _hyper_13_536_chunk r_505 -> Seq Scan on compress_hyper_14_1239_chunk -> Custom Scan (ColumnarScan) on _hyper_13_537_chunk r_506 -> Seq Scan on compress_hyper_14_1240_chunk -> Custom Scan (ColumnarScan) on _hyper_13_538_chunk r_507 -> Seq Scan on compress_hyper_14_1241_chunk -> Custom Scan (ColumnarScan) on _hyper_13_539_chunk r_508 -> Seq Scan on compress_hyper_14_1242_chunk -> Custom Scan (ColumnarScan) on _hyper_13_540_chunk r_509 -> Seq Scan on compress_hyper_14_1243_chunk -> Custom Scan (ColumnarScan) on _hyper_13_541_chunk r_510 -> Seq Scan on compress_hyper_14_1244_chunk -> Custom Scan (ColumnarScan) on _hyper_13_542_chunk r_511 -> Seq Scan on compress_hyper_14_1245_chunk -> Custom Scan (ColumnarScan) on _hyper_13_543_chunk r_512 -> Seq Scan on compress_hyper_14_1246_chunk -> Custom Scan (ColumnarScan) on _hyper_13_544_chunk r_513 -> Seq Scan on compress_hyper_14_1247_chunk -> Custom Scan (ColumnarScan) on _hyper_13_545_chunk r_514 -> Seq Scan on compress_hyper_14_1248_chunk -> Custom Scan (ColumnarScan) on _hyper_13_546_chunk r_515 -> Seq Scan on compress_hyper_14_1249_chunk -> Custom Scan (ColumnarScan) on _hyper_13_547_chunk r_516 -> Seq Scan on compress_hyper_14_1250_chunk -> Custom Scan (ColumnarScan) on _hyper_13_548_chunk r_517 -> Seq Scan on compress_hyper_14_1251_chunk -> Custom Scan (ColumnarScan) on _hyper_13_549_chunk r_518 -> Seq Scan on compress_hyper_14_1252_chunk -> Custom Scan (ColumnarScan) on _hyper_13_550_chunk r_519 -> Seq Scan on compress_hyper_14_1253_chunk -> Custom Scan (ColumnarScan) on _hyper_13_551_chunk r_520 -> Seq Scan on compress_hyper_14_1254_chunk -> Custom Scan (ColumnarScan) on _hyper_13_552_chunk r_521 -> Seq Scan on compress_hyper_14_1255_chunk -> Custom Scan (ColumnarScan) on _hyper_13_553_chunk r_522 -> Seq Scan on compress_hyper_14_1256_chunk -> Custom Scan (ColumnarScan) on _hyper_13_554_chunk r_523 -> Seq Scan on compress_hyper_14_1257_chunk -> Custom Scan (ColumnarScan) on _hyper_13_555_chunk r_524 -> Seq Scan on compress_hyper_14_1258_chunk -> Custom Scan (ColumnarScan) on _hyper_13_556_chunk r_525 -> Seq Scan on compress_hyper_14_1259_chunk -> Custom Scan (ColumnarScan) on _hyper_13_557_chunk r_526 -> Seq Scan on compress_hyper_14_1260_chunk -> Custom Scan (ColumnarScan) on _hyper_13_558_chunk r_527 -> Seq Scan on compress_hyper_14_1261_chunk -> Custom Scan (ColumnarScan) on _hyper_13_559_chunk r_528 -> Seq Scan on compress_hyper_14_1262_chunk -> Custom Scan (ColumnarScan) on _hyper_13_560_chunk r_529 -> Seq Scan on compress_hyper_14_1263_chunk -> Custom Scan (ColumnarScan) on _hyper_13_561_chunk r_530 -> Seq Scan on compress_hyper_14_1264_chunk -> Custom Scan (ColumnarScan) on _hyper_13_562_chunk r_531 -> Seq Scan on compress_hyper_14_1265_chunk -> Custom Scan (ColumnarScan) on _hyper_13_563_chunk r_532 -> Seq Scan on compress_hyper_14_1266_chunk -> Custom Scan (ColumnarScan) on _hyper_13_564_chunk r_533 -> Seq Scan on compress_hyper_14_1267_chunk -> Custom Scan (ColumnarScan) on _hyper_13_565_chunk r_534 -> Seq Scan on compress_hyper_14_1268_chunk -> Custom Scan (ColumnarScan) on _hyper_13_566_chunk r_535 -> Seq Scan on compress_hyper_14_1269_chunk -> Custom Scan (ColumnarScan) on _hyper_13_567_chunk r_536 -> Seq Scan on compress_hyper_14_1270_chunk -> Custom Scan (ColumnarScan) on _hyper_13_568_chunk r_537 -> Seq Scan on compress_hyper_14_1271_chunk -> Custom Scan (ColumnarScan) on _hyper_13_569_chunk r_538 -> Seq Scan on compress_hyper_14_1272_chunk -> Custom Scan (ColumnarScan) on _hyper_13_570_chunk r_539 -> Seq Scan on compress_hyper_14_1273_chunk -> Custom Scan (ColumnarScan) on _hyper_13_571_chunk r_540 -> Seq Scan on compress_hyper_14_1274_chunk -> Custom Scan (ColumnarScan) on _hyper_13_572_chunk r_541 -> Seq Scan on compress_hyper_14_1275_chunk -> Custom Scan (ColumnarScan) on _hyper_13_573_chunk r_542 -> Seq Scan on compress_hyper_14_1276_chunk -> Custom Scan (ColumnarScan) on _hyper_13_574_chunk r_543 -> Seq Scan on compress_hyper_14_1277_chunk -> Custom Scan (ColumnarScan) on _hyper_13_575_chunk r_544 -> Seq Scan on compress_hyper_14_1278_chunk -> Custom Scan (ColumnarScan) on _hyper_13_576_chunk r_545 -> Seq Scan on compress_hyper_14_1279_chunk -> Custom Scan (ColumnarScan) on _hyper_13_577_chunk r_546 -> Seq Scan on compress_hyper_14_1280_chunk -> Custom Scan (ColumnarScan) on _hyper_13_578_chunk r_547 -> Seq Scan on compress_hyper_14_1281_chunk -> Custom Scan (ColumnarScan) on _hyper_13_579_chunk r_548 -> Seq Scan on compress_hyper_14_1282_chunk -> Custom Scan (ColumnarScan) on _hyper_13_580_chunk r_549 -> Seq Scan on compress_hyper_14_1283_chunk -> Custom Scan (ColumnarScan) on _hyper_13_581_chunk r_550 -> Seq Scan on compress_hyper_14_1284_chunk -> Custom Scan (ColumnarScan) on _hyper_13_582_chunk r_551 -> Seq Scan on compress_hyper_14_1285_chunk -> Custom Scan (ColumnarScan) on _hyper_13_583_chunk r_552 -> Seq Scan on compress_hyper_14_1286_chunk -> Custom Scan (ColumnarScan) on _hyper_13_584_chunk r_553 -> Seq Scan on compress_hyper_14_1287_chunk -> Custom Scan (ColumnarScan) on _hyper_13_585_chunk r_554 -> Seq Scan on compress_hyper_14_1288_chunk -> Custom Scan (ColumnarScan) on _hyper_13_586_chunk r_555 -> Seq Scan on compress_hyper_14_1289_chunk -> Custom Scan (ColumnarScan) on _hyper_13_587_chunk r_556 -> Seq Scan on compress_hyper_14_1290_chunk -> Custom Scan (ColumnarScan) on _hyper_13_588_chunk r_557 -> Seq Scan on compress_hyper_14_1291_chunk -> Custom Scan (ColumnarScan) on _hyper_13_589_chunk r_558 -> Seq Scan on compress_hyper_14_1292_chunk -> Custom Scan (ColumnarScan) on _hyper_13_590_chunk r_559 -> Seq Scan on compress_hyper_14_1293_chunk -> Custom Scan (ColumnarScan) on _hyper_13_591_chunk r_560 -> Seq Scan on compress_hyper_14_1294_chunk -> Custom Scan (ColumnarScan) on _hyper_13_592_chunk r_561 -> Seq Scan on compress_hyper_14_1295_chunk -> Custom Scan (ColumnarScan) on _hyper_13_593_chunk r_562 -> Seq Scan on compress_hyper_14_1296_chunk -> Custom Scan (ColumnarScan) on _hyper_13_594_chunk r_563 -> Seq Scan on compress_hyper_14_1297_chunk -> Custom Scan (ColumnarScan) on _hyper_13_595_chunk r_564 -> Seq Scan on compress_hyper_14_1298_chunk -> Custom Scan (ColumnarScan) on _hyper_13_596_chunk r_565 -> Seq Scan on compress_hyper_14_1299_chunk -> Custom Scan (ColumnarScan) on _hyper_13_597_chunk r_566 -> Seq Scan on compress_hyper_14_1300_chunk -> Custom Scan (ColumnarScan) on _hyper_13_598_chunk r_567 -> Seq Scan on compress_hyper_14_1301_chunk -> Custom Scan (ColumnarScan) on _hyper_13_599_chunk r_568 -> Seq Scan on compress_hyper_14_1302_chunk -> Custom Scan (ColumnarScan) on _hyper_13_600_chunk r_569 -> Seq Scan on compress_hyper_14_1303_chunk -> Custom Scan (ColumnarScan) on _hyper_13_601_chunk r_570 -> Seq Scan on compress_hyper_14_1304_chunk -> Custom Scan (ColumnarScan) on _hyper_13_602_chunk r_571 -> Seq Scan on compress_hyper_14_1305_chunk -> Custom Scan (ColumnarScan) on _hyper_13_603_chunk r_572 -> Seq Scan on compress_hyper_14_1306_chunk -> Custom Scan (ColumnarScan) on _hyper_13_604_chunk r_573 -> Seq Scan on compress_hyper_14_1307_chunk -> Custom Scan (ColumnarScan) on _hyper_13_605_chunk r_574 -> Seq Scan on compress_hyper_14_1308_chunk -> Custom Scan (ColumnarScan) on _hyper_13_606_chunk r_575 -> Seq Scan on compress_hyper_14_1309_chunk -> Custom Scan (ColumnarScan) on _hyper_13_607_chunk r_576 -> Seq Scan on compress_hyper_14_1310_chunk -> Custom Scan (ColumnarScan) on _hyper_13_608_chunk r_577 -> Seq Scan on compress_hyper_14_1311_chunk -> Custom Scan (ColumnarScan) on _hyper_13_609_chunk r_578 -> Seq Scan on compress_hyper_14_1312_chunk -> Custom Scan (ColumnarScan) on _hyper_13_610_chunk r_579 -> Seq Scan on compress_hyper_14_1313_chunk -> Custom Scan (ColumnarScan) on _hyper_13_611_chunk r_580 -> Seq Scan on compress_hyper_14_1314_chunk -> Custom Scan (ColumnarScan) on _hyper_13_612_chunk r_581 -> Seq Scan on compress_hyper_14_1315_chunk -> Custom Scan (ColumnarScan) on _hyper_13_613_chunk r_582 -> Seq Scan on compress_hyper_14_1316_chunk -> Custom Scan (ColumnarScan) on _hyper_13_614_chunk r_583 -> Seq Scan on compress_hyper_14_1317_chunk -> Custom Scan (ColumnarScan) on _hyper_13_615_chunk r_584 -> Seq Scan on compress_hyper_14_1318_chunk -> Custom Scan (ColumnarScan) on _hyper_13_616_chunk r_585 -> Seq Scan on compress_hyper_14_1319_chunk -> Custom Scan (ColumnarScan) on _hyper_13_617_chunk r_586 -> Seq Scan on compress_hyper_14_1320_chunk -> Custom Scan (ColumnarScan) on _hyper_13_618_chunk r_587 -> Seq Scan on compress_hyper_14_1321_chunk -> Custom Scan (ColumnarScan) on _hyper_13_619_chunk r_588 -> Seq Scan on compress_hyper_14_1322_chunk -> Custom Scan (ColumnarScan) on _hyper_13_620_chunk r_589 -> Seq Scan on compress_hyper_14_1323_chunk -> Custom Scan (ColumnarScan) on _hyper_13_621_chunk r_590 -> Seq Scan on compress_hyper_14_1324_chunk -> Custom Scan (ColumnarScan) on _hyper_13_622_chunk r_591 -> Seq Scan on compress_hyper_14_1325_chunk -> Custom Scan (ColumnarScan) on _hyper_13_623_chunk r_592 -> Seq Scan on compress_hyper_14_1326_chunk -> Custom Scan (ColumnarScan) on _hyper_13_624_chunk r_593 -> Seq Scan on compress_hyper_14_1327_chunk -> Custom Scan (ColumnarScan) on _hyper_13_625_chunk r_594 -> Seq Scan on compress_hyper_14_1328_chunk -> Custom Scan (ColumnarScan) on _hyper_13_626_chunk r_595 -> Seq Scan on compress_hyper_14_1329_chunk -> Custom Scan (ColumnarScan) on _hyper_13_627_chunk r_596 -> Seq Scan on compress_hyper_14_1330_chunk -> Custom Scan (ColumnarScan) on _hyper_13_628_chunk r_597 -> Seq Scan on compress_hyper_14_1331_chunk -> Custom Scan (ColumnarScan) on _hyper_13_629_chunk r_598 -> Seq Scan on compress_hyper_14_1332_chunk -> Custom Scan (ColumnarScan) on _hyper_13_630_chunk r_599 -> Seq Scan on compress_hyper_14_1333_chunk -> Custom Scan (ColumnarScan) on _hyper_13_631_chunk r_600 -> Seq Scan on compress_hyper_14_1334_chunk -> Custom Scan (ColumnarScan) on _hyper_13_632_chunk r_601 -> Seq Scan on compress_hyper_14_1335_chunk -> Custom Scan (ColumnarScan) on _hyper_13_633_chunk r_602 -> Seq Scan on compress_hyper_14_1336_chunk -> Custom Scan (ColumnarScan) on _hyper_13_634_chunk r_603 -> Seq Scan on compress_hyper_14_1337_chunk -> Custom Scan (ColumnarScan) on _hyper_13_635_chunk r_604 -> Seq Scan on compress_hyper_14_1338_chunk -> Custom Scan (ColumnarScan) on _hyper_13_636_chunk r_605 -> Seq Scan on compress_hyper_14_1339_chunk -> Custom Scan (ColumnarScan) on _hyper_13_637_chunk r_606 -> Seq Scan on compress_hyper_14_1340_chunk -> Custom Scan (ColumnarScan) on _hyper_13_638_chunk r_607 -> Seq Scan on compress_hyper_14_1341_chunk -> Custom Scan (ColumnarScan) on _hyper_13_639_chunk r_608 -> Seq Scan on compress_hyper_14_1342_chunk -> Custom Scan (ColumnarScan) on _hyper_13_640_chunk r_609 -> Seq Scan on compress_hyper_14_1343_chunk -> Custom Scan (ColumnarScan) on _hyper_13_641_chunk r_610 -> Seq Scan on compress_hyper_14_1344_chunk -> Custom Scan (ColumnarScan) on _hyper_13_642_chunk r_611 -> Seq Scan on compress_hyper_14_1345_chunk -> Custom Scan (ColumnarScan) on _hyper_13_643_chunk r_612 -> Seq Scan on compress_hyper_14_1346_chunk -> Custom Scan (ColumnarScan) on _hyper_13_644_chunk r_613 -> Seq Scan on compress_hyper_14_1347_chunk -> Custom Scan (ColumnarScan) on _hyper_13_645_chunk r_614 -> Seq Scan on compress_hyper_14_1348_chunk -> Custom Scan (ColumnarScan) on _hyper_13_646_chunk r_615 -> Seq Scan on compress_hyper_14_1349_chunk -> Custom Scan (ColumnarScan) on _hyper_13_647_chunk r_616 -> Seq Scan on compress_hyper_14_1350_chunk -> Custom Scan (ColumnarScan) on _hyper_13_648_chunk r_617 -> Seq Scan on compress_hyper_14_1351_chunk -> Custom Scan (ColumnarScan) on _hyper_13_649_chunk r_618 -> Seq Scan on compress_hyper_14_1352_chunk -> Custom Scan (ColumnarScan) on _hyper_13_650_chunk r_619 -> Seq Scan on compress_hyper_14_1353_chunk -> Custom Scan (ColumnarScan) on _hyper_13_651_chunk r_620 -> Seq Scan on compress_hyper_14_1354_chunk -> Custom Scan (ColumnarScan) on _hyper_13_652_chunk r_621 -> Seq Scan on compress_hyper_14_1355_chunk -> Custom Scan (ColumnarScan) on _hyper_13_653_chunk r_622 -> Seq Scan on compress_hyper_14_1356_chunk -> Custom Scan (ColumnarScan) on _hyper_13_654_chunk r_623 -> Seq Scan on compress_hyper_14_1357_chunk -> Custom Scan (ColumnarScan) on _hyper_13_655_chunk r_624 -> Seq Scan on compress_hyper_14_1358_chunk -> Custom Scan (ColumnarScan) on _hyper_13_656_chunk r_625 -> Seq Scan on compress_hyper_14_1359_chunk -> Custom Scan (ColumnarScan) on _hyper_13_657_chunk r_626 -> Seq Scan on compress_hyper_14_1360_chunk -> Custom Scan (ColumnarScan) on _hyper_13_658_chunk r_627 -> Seq Scan on compress_hyper_14_1361_chunk -> Custom Scan (ColumnarScan) on _hyper_13_659_chunk r_628 -> Seq Scan on compress_hyper_14_1362_chunk -> Custom Scan (ColumnarScan) on _hyper_13_660_chunk r_629 -> Seq Scan on compress_hyper_14_1363_chunk -> Custom Scan (ColumnarScan) on _hyper_13_661_chunk r_630 -> Seq Scan on compress_hyper_14_1364_chunk -> Custom Scan (ColumnarScan) on _hyper_13_662_chunk r_631 -> Seq Scan on compress_hyper_14_1365_chunk -> Custom Scan (ColumnarScan) on _hyper_13_663_chunk r_632 -> Seq Scan on compress_hyper_14_1366_chunk -> Custom Scan (ColumnarScan) on _hyper_13_664_chunk r_633 -> Seq Scan on compress_hyper_14_1367_chunk -> Custom Scan (ColumnarScan) on _hyper_13_665_chunk r_634 -> Seq Scan on compress_hyper_14_1368_chunk -> Custom Scan (ColumnarScan) on _hyper_13_666_chunk r_635 -> Seq Scan on compress_hyper_14_1369_chunk -> Custom Scan (ColumnarScan) on _hyper_13_667_chunk r_636 -> Seq Scan on compress_hyper_14_1370_chunk -> Custom Scan (ColumnarScan) on _hyper_13_668_chunk r_637 -> Seq Scan on compress_hyper_14_1371_chunk -> Custom Scan (ColumnarScan) on _hyper_13_669_chunk r_638 -> Seq Scan on compress_hyper_14_1372_chunk -> Custom Scan (ColumnarScan) on _hyper_13_670_chunk r_639 -> Seq Scan on compress_hyper_14_1373_chunk -> Custom Scan (ColumnarScan) on _hyper_13_671_chunk r_640 -> Seq Scan on compress_hyper_14_1374_chunk -> Custom Scan (ColumnarScan) on _hyper_13_672_chunk r_641 -> Seq Scan on compress_hyper_14_1375_chunk -> Custom Scan (ColumnarScan) on _hyper_13_673_chunk r_642 -> Seq Scan on compress_hyper_14_1376_chunk -> Custom Scan (ColumnarScan) on _hyper_13_674_chunk r_643 -> Seq Scan on compress_hyper_14_1377_chunk -> Custom Scan (ColumnarScan) on _hyper_13_675_chunk r_644 -> Seq Scan on compress_hyper_14_1378_chunk -> Custom Scan (ColumnarScan) on _hyper_13_676_chunk r_645 -> Seq Scan on compress_hyper_14_1379_chunk -> Custom Scan (ColumnarScan) on _hyper_13_677_chunk r_646 -> Seq Scan on compress_hyper_14_1380_chunk -> Custom Scan (ColumnarScan) on _hyper_13_678_chunk r_647 -> Seq Scan on compress_hyper_14_1381_chunk -> Custom Scan (ColumnarScan) on _hyper_13_679_chunk r_648 -> Seq Scan on compress_hyper_14_1382_chunk -> Custom Scan (ColumnarScan) on _hyper_13_680_chunk r_649 -> Seq Scan on compress_hyper_14_1383_chunk -> Custom Scan (ColumnarScan) on _hyper_13_681_chunk r_650 -> Seq Scan on compress_hyper_14_1384_chunk -> Custom Scan (ColumnarScan) on _hyper_13_682_chunk r_651 -> Seq Scan on compress_hyper_14_1385_chunk -> Custom Scan (ColumnarScan) on _hyper_13_683_chunk r_652 -> Seq Scan on compress_hyper_14_1386_chunk -> Custom Scan (ColumnarScan) on _hyper_13_684_chunk r_653 -> Seq Scan on compress_hyper_14_1387_chunk -> Custom Scan (ColumnarScan) on _hyper_13_685_chunk r_654 -> Seq Scan on compress_hyper_14_1388_chunk -> Custom Scan (ColumnarScan) on _hyper_13_686_chunk r_655 -> Seq Scan on compress_hyper_14_1389_chunk -> Custom Scan (ColumnarScan) on _hyper_13_687_chunk r_656 -> Seq Scan on compress_hyper_14_1390_chunk -> Custom Scan (ColumnarScan) on _hyper_13_688_chunk r_657 -> Seq Scan on compress_hyper_14_1391_chunk -> Custom Scan (ColumnarScan) on _hyper_13_689_chunk r_658 -> Seq Scan on compress_hyper_14_1392_chunk -> Custom Scan (ColumnarScan) on _hyper_13_690_chunk r_659 -> Seq Scan on compress_hyper_14_1393_chunk -> Custom Scan (ColumnarScan) on _hyper_13_691_chunk r_660 -> Seq Scan on compress_hyper_14_1394_chunk -> Custom Scan (ColumnarScan) on _hyper_13_692_chunk r_661 -> Seq Scan on compress_hyper_14_1395_chunk -> Custom Scan (ColumnarScan) on _hyper_13_693_chunk r_662 -> Seq Scan on compress_hyper_14_1396_chunk -> Custom Scan (ColumnarScan) on _hyper_13_694_chunk r_663 -> Seq Scan on compress_hyper_14_1397_chunk -> Custom Scan (ColumnarScan) on _hyper_13_695_chunk r_664 -> Seq Scan on compress_hyper_14_1398_chunk -> Custom Scan (ColumnarScan) on _hyper_13_696_chunk r_665 -> Seq Scan on compress_hyper_14_1399_chunk -> Custom Scan (ColumnarScan) on _hyper_13_697_chunk r_666 -> Seq Scan on compress_hyper_14_1400_chunk -> Custom Scan (ColumnarScan) on _hyper_13_698_chunk r_667 -> Seq Scan on compress_hyper_14_1401_chunk -> Custom Scan (ColumnarScan) on _hyper_13_699_chunk r_668 -> Seq Scan on compress_hyper_14_1402_chunk -> Custom Scan (ColumnarScan) on _hyper_13_700_chunk r_669 -> Seq Scan on compress_hyper_14_1403_chunk -> Custom Scan (ColumnarScan) on _hyper_13_701_chunk r_670 -> Seq Scan on compress_hyper_14_1404_chunk -> Custom Scan (ColumnarScan) on _hyper_13_702_chunk r_671 -> Seq Scan on compress_hyper_14_1405_chunk -> Custom Scan (ColumnarScan) on _hyper_13_703_chunk r_672 -> Seq Scan on compress_hyper_14_1406_chunk -> Custom Scan (ColumnarScan) on _hyper_13_704_chunk r_673 -> Seq Scan on compress_hyper_14_1407_chunk -> Custom Scan (ColumnarScan) on _hyper_13_705_chunk r_674 -> Seq Scan on compress_hyper_14_1408_chunk -> Custom Scan (ColumnarScan) on _hyper_13_706_chunk r_675 -> Seq Scan on compress_hyper_14_1409_chunk -> Custom Scan (ColumnarScan) on _hyper_13_707_chunk r_676 -> Seq Scan on compress_hyper_14_1410_chunk -> Custom Scan (ColumnarScan) on _hyper_13_708_chunk r_677 -> Seq Scan on compress_hyper_14_1411_chunk -> Custom Scan (ColumnarScan) on _hyper_13_709_chunk r_678 -> Seq Scan on compress_hyper_14_1412_chunk -> Custom Scan (ColumnarScan) on _hyper_13_710_chunk r_679 -> Seq Scan on compress_hyper_14_1413_chunk -> Custom Scan (ColumnarScan) on _hyper_13_711_chunk r_680 -> Seq Scan on compress_hyper_14_1414_chunk -> Custom Scan (ColumnarScan) on _hyper_13_712_chunk r_681 -> Seq Scan on compress_hyper_14_1415_chunk -> Custom Scan (ColumnarScan) on _hyper_13_713_chunk r_682 -> Seq Scan on compress_hyper_14_1416_chunk -> Custom Scan (ColumnarScan) on _hyper_13_714_chunk r_683 -> Seq Scan on compress_hyper_14_1417_chunk -> Custom Scan (ColumnarScan) on _hyper_13_715_chunk r_684 -> Seq Scan on compress_hyper_14_1418_chunk -> Custom Scan (ColumnarScan) on _hyper_13_716_chunk r_685 -> Seq Scan on compress_hyper_14_1419_chunk -> Custom Scan (ColumnarScan) on _hyper_13_717_chunk r_686 -> Seq Scan on compress_hyper_14_1420_chunk -> Custom Scan (ColumnarScan) on _hyper_13_718_chunk r_687 -> Seq Scan on compress_hyper_14_1421_chunk -> Custom Scan (ColumnarScan) on _hyper_13_719_chunk r_688 -> Seq Scan on compress_hyper_14_1422_chunk -> Custom Scan (ColumnarScan) on _hyper_13_720_chunk r_689 -> Seq Scan on compress_hyper_14_1423_chunk -> Custom Scan (ColumnarScan) on _hyper_13_721_chunk r_690 -> Seq Scan on compress_hyper_14_1424_chunk -> Custom Scan (ColumnarScan) on _hyper_13_722_chunk r_691 -> Seq Scan on compress_hyper_14_1425_chunk -> Custom Scan (ColumnarScan) on _hyper_13_723_chunk r_692 -> Seq Scan on compress_hyper_14_1426_chunk -> Custom Scan (ColumnarScan) on _hyper_13_724_chunk r_693 -> Seq Scan on compress_hyper_14_1427_chunk -> Custom Scan (ColumnarScan) on _hyper_13_725_chunk r_694 -> Seq Scan on compress_hyper_14_1428_chunk -> Custom Scan (ColumnarScan) on _hyper_13_726_chunk r_695 -> Seq Scan on compress_hyper_14_1429_chunk -> Custom Scan (ColumnarScan) on _hyper_13_727_chunk r_696 -> Seq Scan on compress_hyper_14_1430_chunk -> Custom Scan (ColumnarScan) on _hyper_13_728_chunk r_697 -> Seq Scan on compress_hyper_14_1431_chunk -> Custom Scan (ColumnarScan) on _hyper_13_729_chunk r_698 -> Seq Scan on compress_hyper_14_1432_chunk -> Custom Scan (ColumnarScan) on _hyper_13_730_chunk r_699 -> Seq Scan on compress_hyper_14_1433_chunk -> Custom Scan (ColumnarScan) on _hyper_13_731_chunk r_700 -> Seq Scan on compress_hyper_14_1434_chunk -> Custom Scan (ColumnarScan) on _hyper_13_732_chunk r_701 -> Seq Scan on compress_hyper_14_1435_chunk -> Custom Scan (ColumnarScan) on _hyper_13_733_chunk r_702 -> Seq Scan on compress_hyper_14_1436_chunk -> Custom Scan (ColumnarScan) on _hyper_13_734_chunk r_703 -> Seq Scan on compress_hyper_14_1437_chunk -> Hash -> Seq Scan on tags t -- run query with parallel enabled to ensure nothing is preventing parallel execution -- this is just a sanity check, the result queries dont run with parallel disabled SET max_parallel_workers_per_gather TO 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SET min_parallel_table_scan_size TO '0'; EXPLAIN (buffers off, costs off) SELECT * FROM metrics ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 3 -> Sort Sort Key: metrics."time", metrics.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT time_bucket('10 minutes', time) bucket, avg(v0) avg_v0 FROM metrics GROUP BY bucket; --- QUERY PLAN --- Finalize HashAggregate Group Key: (time_bucket('@ 10 mins'::interval, metrics."time")) -> Gather Workers Planned: 3 -> Parallel Append -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_2_chunk."time") -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: metrics_space."time", metrics_space.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk -> Parallel Seq Scan on compress_hyper_6_17_chunk -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk -> Parallel Seq Scan on compress_hyper_6_19_chunk -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk -> Parallel Seq Scan on compress_hyper_6_20_chunk -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk -> Parallel Seq Scan on compress_hyper_6_18_chunk -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk -> Parallel Seq Scan on compress_hyper_6_21_chunk -> Parallel Seq Scan on _hyper_2_8_chunk -> Parallel Seq Scan on _hyper_2_7_chunk -> Parallel Seq Scan on _hyper_2_9_chunk -> Parallel Seq Scan on _hyper_2_12_chunk RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; SET enable_seqscan TO false; -- should order compressed chunks using index -- (we only EXPLAIN here b/c the resulting order is too inconsistent) EXPLAIN (buffers off, costs off) SELECT * FROM metrics WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics.device_id -> Sort Sort Key: _hyper_1_2_chunk.device_id -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics_space.device_id -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) SET enable_seqscan TO true; -- diff compressed and uncompressed results :DIFF_CMD -- check hypertable detection in views CREATE VIEW ht_view AS SELECT *, 0 AS res FROM metrics UNION ALL SELECT *, 1 AS res FROM metrics; CREATE FUNCTION ht_func() RETURNS SETOF metrics LANGUAGE SQL STABLE AS $sql$ SELECT time, device_id, device_id_peer, v0, v1, v2, v3 FROM ht_view WHERE res = 0; $sql$; -- should have decompresschunk node :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) \c SET enable_incremental_sort TO off; -- plan should be identical to previous plan in fresh session :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- repro for core dump related to total_table_pages setting that get -- adjusted during decompress path. CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE motion_table( id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass) , datalogger_id bigint , vessel_id bigint , bus_id smallint , src_id smallint , dataloggertime timestamp with time zone , interval_s real ); CREATE INDEX motion_table_t2_datalogger_id_idx on motion_table (datalogger_id); CREATE INDEX motion_table_t2_dataloggertime_idx on motion_table(dataloggertime DESC); CREATE INDEX motion_table_t2_vessel_id_idx on motion_table(vessel_id); SELECT create_hypertable( 'motion_table', 'dataloggertime', chunk_time_interval=> '7 days'::interval); create_hypertable ---------------------------- (15,public,motion_table,t) --- do not modify the data. We need atleast this volume to reproduce issues with pages/tuple counts etc. --- INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), random() , random() , generate_series( '2020-01-02 10:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), 2, 3, generate_series( '2020-01-10 8:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; ALTER TABLE motion_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'vessel_id, datalogger_id, bus_id, src_id' , timescaledb.compress_orderby = 'dataloggertime' ); --have 2 chunks -- SELECT COUNT(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table'; count ------- 2 -- compress only the first one --- SELECT compress_chunk( chunk_table) FROM ( SELECT chunk_schema || '.' || chunk_name as chunk_table FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table' ORDER BY range_start limit 1 ) q; compress_chunk -------------------------------------------- _timescaledb_internal._hyper_15_1438_chunk --call to decompress chunk on 1 of the chunks SELECT count(*) from motion_table; count ------- 11642 --END of test for page settings CREATE TABLE repro(time timestamptz NOT NULL, device_id text, room_id text NOT NULL, score_type int NOT NULL, algorithm_version text NOT NULL, adjusted_score float NOT NULL); SELECT create_hypertable('repro','time'); create_hypertable --------------------- (17,public,repro,t) ALTER TABLE repro SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, room_id, score_type, algorithm_version', timescaledb.compress_orderby='"time" DESC' ); SELECT _timescaledb_functions.create_chunk('repro','{"time": [1717632000000000,1718236800000000]}'); create_chunk ------------------------------------------------------------------------------------------------------------- (1441,17,_timescaledb_internal,_hyper_17_1441_chunk,r,"{""time"": [1717632000000000, 1718236800000000]}",t) select compress_chunk(show_chunks('repro')); compress_chunk -------------------------------------------- _timescaledb_internal._hyper_17_1441_chunk select from repro where room_id = 'foo' order by device_id, algorithm_version, score_type, time desc; -- ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression-17.out�������������������������������0000664�0000000�0000000�00002313430�15100345067�0025714�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset SET work_mem TO '50MB'; SET enable_incremental_sort TO off; SET timezone TO 'America/Los_Angeles'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; CREATE TABLE metrics ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable ('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; \set INTERVAL 30m INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id - 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('metrics_space', 'time', 'device_id', 3); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics_space; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none -- compress first and last chunk on the hypertable ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics') x) t where n in (1, 3) ; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk VACUUM ANALYZE metrics; -- compress some chunks on space partitioned hypertable -- we compress all chunks of first time slice, none of second, and 2 of the last time slice ALTER TABLE metrics_space SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics_space') x) t where n in (1, 2, 3, 7, 8) ; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics' \gset SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_SPACE_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics_space' \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Index created using query saved in variable used because there was -- no standard way to create an index on a compressed table. -- Once a standard way exists, modify this test to use that method. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE INDEX ON metrics_space (device_id, device_id_peer, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id, device_id_peer DESC, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id DESC, device_id_peer DESC, v0, v1 DESC, time); VACUUM ANALYZE metrics_space; SET enable_incremental_sort TO off; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; -- get explain for queries on hypertable with compression \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Sort (actual rows=3456.00 loops=1) Sort Key: metrics."time", metrics.device_id Sort Method: quicksort -> Result (actual rows=3456.00 loops=1) -> Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Seq Scan on _hyper_1_2_chunk (actual rows=1344.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2016 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=672.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time", metrics.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3600 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1680 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 3) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3595 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3570 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=35.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3565 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3570.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 30 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 2688 -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < 1) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) Filter: (v0 < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3600 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 1680 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=713.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: ((compress_hyper_5_15_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_15_chunk.device_id = 1)) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Index Cond: (_hyper_1_2_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: ((compress_hyper_5_16_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_16_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3572.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 28 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC, metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics.device_id, metrics."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device_id, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time", metrics.device_id Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk."time" Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0 -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time", metrics.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1 DESC, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 1 -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=8640.00 loops=1) Order: metrics."time" -> Sort (actual rows=3600.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics."time" = metrics_1."time") -> Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1728.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Order: metrics."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=5.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Index Only Scan using _hyper_1_2_chunk_tmp_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id_peer = 1) Rows Removed by Filter: 5 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id_peer = 1) Rows Removed by Filter: 5 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Output: metrics.device_id_peer Join Filter: (metrics.device_id_peer = "*VALUES*".column1) Rows Removed by Join Filter: 17280 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=3456.00 loops=1) Output: metrics.device_id_peer -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=1728.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=2) Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=2) Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_1_2_chunk.device_id) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=2) Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = "*VALUES*".column1) RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join Output: metrics.device_id_peer Hash Cond: (metrics.device_id = "*VALUES*".column1) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -> Hash Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=3456.00 loops=1) Output: metrics.device_id_peer -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=1728.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=2) Output: _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=2) Output: _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_1_2_chunk.device_id) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=2) Output: _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=2) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = "*VALUES*".column1) -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: m3_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m3_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 38 -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=48.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=11.00 loops=1) Order: m2."time" -> Sort (actual rows=11.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Sort (actual rows=3456.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Result (actual rows=3456.00 loops=1) -> Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Vectorized Filter: (_hyper_2_5_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2160 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Vectorized Filter: (_hyper_2_6_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2016 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1008 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (never executed) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 3 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2157 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=18.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2142 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=21.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2139 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2142.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 18 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id < v0) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id < v0) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 336 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2160 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 1008 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=713.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: ((compress_hyper_6_17_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_17_chunk.device_id = 1)) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: ((compress_hyper_6_20_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_20_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=9.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC, metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_12_chunk."time" DESC, _hyper_2_12_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC, _hyper_2_11_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC, _hyper_2_10_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time" DESC, _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time" DESC, _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time" DESC, _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC, _hyper_2_6_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC, _hyper_2_5_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC, _hyper_2_4_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_4_chunk.device_id, _hyper_2_4_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_5_chunk.device_id, _hyper_2_5_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk.device_id, _hyper_2_6_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk."time" Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk."time" Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk."time" Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk."time" Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk."time" Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk."time" Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time", metrics_space.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _hyper_2_9_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=3915.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (actual rows=2235.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1341.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=8640.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3600.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=2160.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=3360.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics_space."time" = metrics_space_1."time") -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1728.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=5.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics_space), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics_space), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan using _hyper_2_7_chunk_tmp_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id -> Index Only Scan using _hyper_2_8_chunk_tmp_idx on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id -> Index Only Scan using _hyper_2_9_chunk_tmp_idx on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan using _hyper_2_12_chunk_tmp_idx on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Filter: (compress_hyper_6_19_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Filter: (_hyper_2_12_chunk.device_id_peer = 1) Rows Removed by Filter: 336 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=0.00 loops=1) Output: metrics_space.device_id_peer Join Filter: (metrics_space.device_id_peer = "*VALUES*".column1) Rows Removed by Join Filter: 17280 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Semi Join (actual rows=3456.00 loops=1) Output: metrics_space.device_id_peer Join Filter: (metrics_space.device_id = "*VALUES*".column1) Rows Removed by Join Filter: 12096 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Materialize (actual rows=2.00 loops=8640) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join Output: metrics_space.device_id_peer Hash Cond: (metrics_space.device_id = "*VALUES*".column1) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Hash Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join (actual rows=3456.00 loops=1) Output: metrics_space.device_id_peer Hash Cond: (metrics_space.device_id = "*VALUES*".column1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.device_id -> Hash (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m3_3 (actual rows=1.00 loops=1) Filter: (device_id = 3) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 39 -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=49.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=11.00 loops=1) Order: m2."time" -> Merge Append (actual rows=11.00 loops=1) Sort Key: m2."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=7.00 loops=1) Sort Key: m2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m2_4 (never executed) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m2_5 (never executed) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time" -> Sort (never executed) Sort Key: m2_7."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 7 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_18_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_19_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m1_5 (never executed) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m1_6 (never executed) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m1_9 (never executed) Index Cond: ("time" = g."time") -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 1) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=1.00 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=1.00 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 2) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \ir include/transparent_decompression_ordered.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column CREATE TABLE metrics_ordered(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_ordered','time'); create_hypertable ------------------------------- (11,public,metrics_ordered,t) ALTER TABLE metrics_ordered SET (timescaledb.compress, timescaledb.compress_orderby='time DESC',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered SELECT * FROM metrics; CREATE INDEX ON metrics_ordered(device_id,device_id_peer,time); CREATE INDEX ON metrics_ordered(device_id,time); CREATE INDEX ON metrics_ordered(device_id_peer,time); -- compress all chunks SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered') ch; count ------- 3 VACUUM ANALYZE metrics_ordered; -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM metrics_ordered ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=10.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_30_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_29_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_29_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered WHERE device_id = 1 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=0.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_min_1 DESC, compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_30_chunk._ts_meta_min_1 DESC, compress_hyper_12_30_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_29_chunk._ts_meta_min_1 DESC, compress_hyper_12_29_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered d INNER JOIN LATERAL (SELECT * FROM metrics_ordered m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON true; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Nested Loop (actual rows=0.00 loops=1) -> Merge Append (actual rows=8640.00 loops=1) Sort Key: d.device_id -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk d_1 (actual rows=3600.00 loops=1) -> Index Scan using compress_hyper_12_29_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_29_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk d_2 (actual rows=3360.00 loops=1) -> Index Scan using compress_hyper_12_30_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_30_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk d_3 (actual rows=1680.00 loops=1) -> Index Scan using compress_hyper_12_31_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Limit (actual rows=0.00 loops=8640) -> Custom Scan (ChunkAppend) on metrics_ordered m (actual rows=0.00 loops=8640) Order: m."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk m_1 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_31_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_31_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk compress_hyper_12_31_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk m_2 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_30_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_30_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk compress_hyper_12_30_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk m_3 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_29_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_29_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk compress_hyper_12_29_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 \ir include/transparent_decompression_systemcolumns.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_TABLE 'metrics' -- test system columns -- all system columns except for tableoid should error \set ON_ERROR_STOP 0 SELECT xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:10: ERROR: transparent decompression only supports tableoid system column SELECT cmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:11: ERROR: transparent decompression only supports tableoid system column SELECT xmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:12: ERROR: transparent decompression only supports tableoid system column SELECT cmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:13: ERROR: transparent decompression only supports tableoid system column SELECT ctid FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:14: ERROR: transparent decompression only supports tableoid system column -- test system columns in WHERE and ORDER BY clause SELECT tableoid, xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:17: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE ORDER BY cmin::text; psql:include/transparent_decompression_systemcolumns.sql:18: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE WHERE cmin IS NOT NULL; psql:include/transparent_decompression_systemcolumns.sql:19: ERROR: transparent decompression only supports tableoid system column \set ON_ERROR_STOP 1 -- test tableoid in different parts of query SELECT pg_typeof(tableoid) FROM :TEST_TABLE ORDER BY time LIMIT 1; pg_typeof ----------- oid SELECT FROM :TEST_TABLE ORDER BY tableoid LIMIT 1; -- SELECT FROM :TEST_TABLE WHERE tableoid::int > 0 LIMIT 1; -- SELECT tableoid::regclass FROM :TEST_TABLE GROUP BY tableoid ORDER BY 1; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk SELECT count(distinct tableoid) FROM :TEST_TABLE WHERE device_id=1 AND time < now(); count ------- 3 -- test prepared statement PREPARE tableoid_prep AS SELECT tableoid::regclass FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 1; :PREFIX EXECUTE tableoid_prep; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk DEALLOCATE tableoid_prep; \ir include/transparent_decompression_undiffed.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test planning regression with many chunks CREATE TABLE tags(id SERIAL PRIMARY KEY, name TEXT, fleet TEXT); INSERT INTO tags (name, fleet) VALUES('n1', 'f1'); CREATE TABLE readings (time timestamptz, tags_id integer, fuel_consumption DOUBLE PRECISION); CREATE INDEX ON readings(tags_id, "time" DESC); CREATE INDEX ON readings("time" DESC); SELECT create_hypertable('readings', 'time', partitioning_column => 'tags_id', number_partitions => 1, chunk_time_interval => 43200000000, create_default_indexes=>false); create_hypertable ------------------------ (13,public,readings,t) ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'tags_id', timescaledb.compress_orderby = 'time desc'); INSERT into readings select g, 1, 1.3 from generate_series('2001-03-01 01:01:01', '2003-02-01 01:01:01', '1 day'::interval) g; SELECT count(compress_chunk(ch)) FROM show_chunks('readings') ch; count ------- 703 VACUUM ANALYZE readings; EXPLAIN (buffers off, costs off) SELECT t.fleet as fleet, min(r.fuel_consumption) AS avg_fuel_consumption FROM tags t INNER JOIN LATERAL(SELECT tags_id, fuel_consumption FROM readings r WHERE r.tags_id = t.id ) r ON true GROUP BY fleet; --- QUERY PLAN --- HashAggregate Group Key: t.fleet -> Hash Join Hash Cond: (r.tags_id = t.id) -> Append -> Custom Scan (ColumnarScan) on _hyper_13_32_chunk r_1 -> Seq Scan on compress_hyper_14_735_chunk -> Custom Scan (ColumnarScan) on _hyper_13_33_chunk r_2 -> Seq Scan on compress_hyper_14_736_chunk -> Custom Scan (ColumnarScan) on _hyper_13_34_chunk r_3 -> Seq Scan on compress_hyper_14_737_chunk -> Custom Scan (ColumnarScan) on _hyper_13_35_chunk r_4 -> Seq Scan on compress_hyper_14_738_chunk -> Custom Scan (ColumnarScan) on _hyper_13_36_chunk r_5 -> Seq Scan on compress_hyper_14_739_chunk -> Custom Scan (ColumnarScan) on _hyper_13_37_chunk r_6 -> Seq Scan on compress_hyper_14_740_chunk -> Custom Scan (ColumnarScan) on _hyper_13_38_chunk r_7 -> Seq Scan on compress_hyper_14_741_chunk -> Custom Scan (ColumnarScan) on _hyper_13_39_chunk r_8 -> Seq Scan on compress_hyper_14_742_chunk -> Custom Scan (ColumnarScan) on _hyper_13_40_chunk r_9 -> Seq Scan on compress_hyper_14_743_chunk -> Custom Scan (ColumnarScan) on _hyper_13_41_chunk r_10 -> Seq Scan on compress_hyper_14_744_chunk -> Custom Scan (ColumnarScan) on _hyper_13_42_chunk r_11 -> Seq Scan on compress_hyper_14_745_chunk -> Custom Scan (ColumnarScan) on _hyper_13_43_chunk r_12 -> Seq Scan on compress_hyper_14_746_chunk -> Custom Scan (ColumnarScan) on _hyper_13_44_chunk r_13 -> Seq Scan on compress_hyper_14_747_chunk -> Custom Scan (ColumnarScan) on _hyper_13_45_chunk r_14 -> Seq Scan on compress_hyper_14_748_chunk -> Custom Scan (ColumnarScan) on _hyper_13_46_chunk r_15 -> Seq Scan on compress_hyper_14_749_chunk -> Custom Scan (ColumnarScan) on _hyper_13_47_chunk r_16 -> Seq Scan on compress_hyper_14_750_chunk -> Custom Scan (ColumnarScan) on _hyper_13_48_chunk r_17 -> Seq Scan on compress_hyper_14_751_chunk -> Custom Scan (ColumnarScan) on _hyper_13_49_chunk r_18 -> Seq Scan on compress_hyper_14_752_chunk -> Custom Scan (ColumnarScan) on _hyper_13_50_chunk r_19 -> Seq Scan on compress_hyper_14_753_chunk -> Custom Scan (ColumnarScan) on _hyper_13_51_chunk r_20 -> Seq Scan on compress_hyper_14_754_chunk -> Custom Scan (ColumnarScan) on _hyper_13_52_chunk r_21 -> Seq Scan on compress_hyper_14_755_chunk -> Custom Scan (ColumnarScan) on _hyper_13_53_chunk r_22 -> Seq Scan on compress_hyper_14_756_chunk -> Custom Scan (ColumnarScan) on _hyper_13_54_chunk r_23 -> Seq Scan on compress_hyper_14_757_chunk -> Custom Scan (ColumnarScan) on _hyper_13_55_chunk r_24 -> Seq Scan on compress_hyper_14_758_chunk -> Custom Scan (ColumnarScan) on _hyper_13_56_chunk r_25 -> Seq Scan on compress_hyper_14_759_chunk -> Custom Scan (ColumnarScan) on _hyper_13_57_chunk r_26 -> Seq Scan on compress_hyper_14_760_chunk -> Custom Scan (ColumnarScan) on _hyper_13_58_chunk r_27 -> Seq Scan on compress_hyper_14_761_chunk -> Custom Scan (ColumnarScan) on _hyper_13_59_chunk r_28 -> Seq Scan on compress_hyper_14_762_chunk -> Custom Scan (ColumnarScan) on _hyper_13_60_chunk r_29 -> Seq Scan on compress_hyper_14_763_chunk -> Custom Scan (ColumnarScan) on _hyper_13_61_chunk r_30 -> Seq Scan on compress_hyper_14_764_chunk -> Custom Scan (ColumnarScan) on _hyper_13_62_chunk r_31 -> Seq Scan on compress_hyper_14_765_chunk -> Custom Scan (ColumnarScan) on _hyper_13_63_chunk r_32 -> Seq Scan on compress_hyper_14_766_chunk -> Custom Scan (ColumnarScan) on _hyper_13_64_chunk r_33 -> Seq Scan on compress_hyper_14_767_chunk -> Custom Scan (ColumnarScan) on _hyper_13_65_chunk r_34 -> Seq Scan on compress_hyper_14_768_chunk -> Custom Scan (ColumnarScan) on _hyper_13_66_chunk r_35 -> Seq Scan on compress_hyper_14_769_chunk -> Custom Scan (ColumnarScan) on _hyper_13_67_chunk r_36 -> Seq Scan on compress_hyper_14_770_chunk -> Custom Scan (ColumnarScan) on _hyper_13_68_chunk r_37 -> Seq Scan on compress_hyper_14_771_chunk -> Custom Scan (ColumnarScan) on _hyper_13_69_chunk r_38 -> Seq Scan on compress_hyper_14_772_chunk -> Custom Scan (ColumnarScan) on _hyper_13_70_chunk r_39 -> Seq Scan on compress_hyper_14_773_chunk -> Custom Scan (ColumnarScan) on _hyper_13_71_chunk r_40 -> Seq Scan on compress_hyper_14_774_chunk -> Custom Scan (ColumnarScan) on _hyper_13_72_chunk r_41 -> Seq Scan on compress_hyper_14_775_chunk -> Custom Scan (ColumnarScan) on _hyper_13_73_chunk r_42 -> Seq Scan on compress_hyper_14_776_chunk -> Custom Scan (ColumnarScan) on _hyper_13_74_chunk r_43 -> Seq Scan on compress_hyper_14_777_chunk -> Custom Scan (ColumnarScan) on _hyper_13_75_chunk r_44 -> Seq Scan on compress_hyper_14_778_chunk -> Custom Scan (ColumnarScan) on _hyper_13_76_chunk r_45 -> Seq Scan on compress_hyper_14_779_chunk -> Custom Scan (ColumnarScan) on _hyper_13_77_chunk r_46 -> Seq Scan on compress_hyper_14_780_chunk -> Custom Scan (ColumnarScan) on _hyper_13_78_chunk r_47 -> Seq Scan on compress_hyper_14_781_chunk -> Custom Scan (ColumnarScan) on _hyper_13_79_chunk r_48 -> Seq Scan on compress_hyper_14_782_chunk -> Custom Scan (ColumnarScan) on _hyper_13_80_chunk r_49 -> Seq Scan on compress_hyper_14_783_chunk -> Custom Scan (ColumnarScan) on _hyper_13_81_chunk r_50 -> Seq Scan on compress_hyper_14_784_chunk -> Custom Scan (ColumnarScan) on _hyper_13_82_chunk r_51 -> Seq Scan on compress_hyper_14_785_chunk -> Custom Scan (ColumnarScan) on _hyper_13_83_chunk r_52 -> Seq Scan on compress_hyper_14_786_chunk -> Custom Scan (ColumnarScan) on _hyper_13_84_chunk r_53 -> Seq Scan on compress_hyper_14_787_chunk -> Custom Scan (ColumnarScan) on _hyper_13_85_chunk r_54 -> Seq Scan on compress_hyper_14_788_chunk -> Custom Scan (ColumnarScan) on _hyper_13_86_chunk r_55 -> Seq Scan on compress_hyper_14_789_chunk -> Custom Scan (ColumnarScan) on _hyper_13_87_chunk r_56 -> Seq Scan on compress_hyper_14_790_chunk -> Custom Scan (ColumnarScan) on _hyper_13_88_chunk r_57 -> Seq Scan on compress_hyper_14_791_chunk -> Custom Scan (ColumnarScan) on _hyper_13_89_chunk r_58 -> Seq Scan on compress_hyper_14_792_chunk -> Custom Scan (ColumnarScan) on _hyper_13_90_chunk r_59 -> Seq Scan on compress_hyper_14_793_chunk -> Custom Scan (ColumnarScan) on _hyper_13_91_chunk r_60 -> Seq Scan on compress_hyper_14_794_chunk -> Custom Scan (ColumnarScan) on _hyper_13_92_chunk r_61 -> Seq Scan on compress_hyper_14_795_chunk -> Custom Scan (ColumnarScan) on _hyper_13_93_chunk r_62 -> Seq Scan on compress_hyper_14_796_chunk -> Custom Scan (ColumnarScan) on _hyper_13_94_chunk r_63 -> Seq Scan on compress_hyper_14_797_chunk -> Custom Scan (ColumnarScan) on _hyper_13_95_chunk r_64 -> Seq Scan on compress_hyper_14_798_chunk -> Custom Scan (ColumnarScan) on _hyper_13_96_chunk r_65 -> Seq Scan on compress_hyper_14_799_chunk -> Custom Scan (ColumnarScan) on _hyper_13_97_chunk r_66 -> Seq Scan on compress_hyper_14_800_chunk -> Custom Scan (ColumnarScan) on _hyper_13_98_chunk r_67 -> Seq Scan on compress_hyper_14_801_chunk -> Custom Scan (ColumnarScan) on _hyper_13_99_chunk r_68 -> Seq Scan on compress_hyper_14_802_chunk -> Custom Scan (ColumnarScan) on _hyper_13_100_chunk r_69 -> Seq Scan on compress_hyper_14_803_chunk -> Custom Scan (ColumnarScan) on _hyper_13_101_chunk r_70 -> Seq Scan on compress_hyper_14_804_chunk -> Custom Scan (ColumnarScan) on _hyper_13_102_chunk r_71 -> Seq Scan on compress_hyper_14_805_chunk -> Custom Scan (ColumnarScan) on _hyper_13_103_chunk r_72 -> Seq Scan on compress_hyper_14_806_chunk -> Custom Scan (ColumnarScan) on _hyper_13_104_chunk r_73 -> Seq Scan on compress_hyper_14_807_chunk -> Custom Scan (ColumnarScan) on _hyper_13_105_chunk r_74 -> Seq Scan on compress_hyper_14_808_chunk -> Custom Scan (ColumnarScan) on _hyper_13_106_chunk r_75 -> Seq Scan on compress_hyper_14_809_chunk -> Custom Scan (ColumnarScan) on _hyper_13_107_chunk r_76 -> Seq Scan on compress_hyper_14_810_chunk -> Custom Scan (ColumnarScan) on _hyper_13_108_chunk r_77 -> Seq Scan on compress_hyper_14_811_chunk -> Custom Scan (ColumnarScan) on _hyper_13_109_chunk r_78 -> Seq Scan on compress_hyper_14_812_chunk -> Custom Scan (ColumnarScan) on _hyper_13_110_chunk r_79 -> Seq Scan on compress_hyper_14_813_chunk -> Custom Scan (ColumnarScan) on _hyper_13_111_chunk r_80 -> Seq Scan on compress_hyper_14_814_chunk -> Custom Scan (ColumnarScan) on _hyper_13_112_chunk r_81 -> Seq Scan on compress_hyper_14_815_chunk -> Custom Scan (ColumnarScan) on _hyper_13_113_chunk r_82 -> Seq Scan on compress_hyper_14_816_chunk -> Custom Scan (ColumnarScan) on _hyper_13_114_chunk r_83 -> Seq Scan on compress_hyper_14_817_chunk -> Custom Scan (ColumnarScan) on _hyper_13_115_chunk r_84 -> Seq Scan on compress_hyper_14_818_chunk -> Custom Scan (ColumnarScan) on _hyper_13_116_chunk r_85 -> Seq Scan on compress_hyper_14_819_chunk -> Custom Scan (ColumnarScan) on _hyper_13_117_chunk r_86 -> Seq Scan on compress_hyper_14_820_chunk -> Custom Scan (ColumnarScan) on _hyper_13_118_chunk r_87 -> Seq Scan on compress_hyper_14_821_chunk -> Custom Scan (ColumnarScan) on _hyper_13_119_chunk r_88 -> Seq Scan on compress_hyper_14_822_chunk -> Custom Scan (ColumnarScan) on _hyper_13_120_chunk r_89 -> Seq Scan on compress_hyper_14_823_chunk -> Custom Scan (ColumnarScan) on _hyper_13_121_chunk r_90 -> Seq Scan on compress_hyper_14_824_chunk -> Custom Scan (ColumnarScan) on _hyper_13_122_chunk r_91 -> Seq Scan on compress_hyper_14_825_chunk -> Custom Scan (ColumnarScan) on _hyper_13_123_chunk r_92 -> Seq Scan on compress_hyper_14_826_chunk -> Custom Scan (ColumnarScan) on _hyper_13_124_chunk r_93 -> Seq Scan on compress_hyper_14_827_chunk -> Custom Scan (ColumnarScan) on _hyper_13_125_chunk r_94 -> Seq Scan on compress_hyper_14_828_chunk -> Custom Scan (ColumnarScan) on _hyper_13_126_chunk r_95 -> Seq Scan on compress_hyper_14_829_chunk -> Custom Scan (ColumnarScan) on _hyper_13_127_chunk r_96 -> Seq Scan on compress_hyper_14_830_chunk -> Custom Scan (ColumnarScan) on _hyper_13_128_chunk r_97 -> Seq Scan on compress_hyper_14_831_chunk -> Custom Scan (ColumnarScan) on _hyper_13_129_chunk r_98 -> Seq Scan on compress_hyper_14_832_chunk -> Custom Scan (ColumnarScan) on _hyper_13_130_chunk r_99 -> Seq Scan on compress_hyper_14_833_chunk -> Custom Scan (ColumnarScan) on _hyper_13_131_chunk r_100 -> Seq Scan on compress_hyper_14_834_chunk -> Custom Scan (ColumnarScan) on _hyper_13_132_chunk r_101 -> Seq Scan on compress_hyper_14_835_chunk -> Custom Scan (ColumnarScan) on _hyper_13_133_chunk r_102 -> Seq Scan on compress_hyper_14_836_chunk -> Custom Scan (ColumnarScan) on _hyper_13_134_chunk r_103 -> Seq Scan on compress_hyper_14_837_chunk -> Custom Scan (ColumnarScan) on _hyper_13_135_chunk r_104 -> Seq Scan on compress_hyper_14_838_chunk -> Custom Scan (ColumnarScan) on _hyper_13_136_chunk r_105 -> Seq Scan on compress_hyper_14_839_chunk -> Custom Scan (ColumnarScan) on _hyper_13_137_chunk r_106 -> Seq Scan on compress_hyper_14_840_chunk -> Custom Scan (ColumnarScan) on _hyper_13_138_chunk r_107 -> Seq Scan on compress_hyper_14_841_chunk -> Custom Scan (ColumnarScan) on _hyper_13_139_chunk r_108 -> Seq Scan on compress_hyper_14_842_chunk -> Custom Scan (ColumnarScan) on _hyper_13_140_chunk r_109 -> Seq Scan on compress_hyper_14_843_chunk -> Custom Scan (ColumnarScan) on _hyper_13_141_chunk r_110 -> Seq Scan on compress_hyper_14_844_chunk -> Custom Scan (ColumnarScan) on _hyper_13_142_chunk r_111 -> Seq Scan on compress_hyper_14_845_chunk -> Custom Scan (ColumnarScan) on _hyper_13_143_chunk r_112 -> Seq Scan on compress_hyper_14_846_chunk -> Custom Scan (ColumnarScan) on _hyper_13_144_chunk r_113 -> Seq Scan on compress_hyper_14_847_chunk -> Custom Scan (ColumnarScan) on _hyper_13_145_chunk r_114 -> Seq Scan on compress_hyper_14_848_chunk -> Custom Scan (ColumnarScan) on _hyper_13_146_chunk r_115 -> Seq Scan on compress_hyper_14_849_chunk -> Custom Scan (ColumnarScan) on _hyper_13_147_chunk r_116 -> Seq Scan on compress_hyper_14_850_chunk -> Custom Scan (ColumnarScan) on _hyper_13_148_chunk r_117 -> Seq Scan on compress_hyper_14_851_chunk -> Custom Scan (ColumnarScan) on _hyper_13_149_chunk r_118 -> Seq Scan on compress_hyper_14_852_chunk -> Custom Scan (ColumnarScan) on _hyper_13_150_chunk r_119 -> Seq Scan on compress_hyper_14_853_chunk -> Custom Scan (ColumnarScan) on _hyper_13_151_chunk r_120 -> Seq Scan on compress_hyper_14_854_chunk -> Custom Scan (ColumnarScan) on _hyper_13_152_chunk r_121 -> Seq Scan on compress_hyper_14_855_chunk -> Custom Scan (ColumnarScan) on _hyper_13_153_chunk r_122 -> Seq Scan on compress_hyper_14_856_chunk -> Custom Scan (ColumnarScan) on _hyper_13_154_chunk r_123 -> Seq Scan on compress_hyper_14_857_chunk -> Custom Scan (ColumnarScan) on _hyper_13_155_chunk r_124 -> Seq Scan on compress_hyper_14_858_chunk -> Custom Scan (ColumnarScan) on _hyper_13_156_chunk r_125 -> Seq Scan on compress_hyper_14_859_chunk -> Custom Scan (ColumnarScan) on _hyper_13_157_chunk r_126 -> Seq Scan on compress_hyper_14_860_chunk -> Custom Scan (ColumnarScan) on _hyper_13_158_chunk r_127 -> Seq Scan on compress_hyper_14_861_chunk -> Custom Scan (ColumnarScan) on _hyper_13_159_chunk r_128 -> Seq Scan on compress_hyper_14_862_chunk -> Custom Scan (ColumnarScan) on _hyper_13_160_chunk r_129 -> Seq Scan on compress_hyper_14_863_chunk -> Custom Scan (ColumnarScan) on _hyper_13_161_chunk r_130 -> Seq Scan on compress_hyper_14_864_chunk -> Custom Scan (ColumnarScan) on _hyper_13_162_chunk r_131 -> Seq Scan on compress_hyper_14_865_chunk -> Custom Scan (ColumnarScan) on _hyper_13_163_chunk r_132 -> Seq Scan on compress_hyper_14_866_chunk -> Custom Scan (ColumnarScan) on _hyper_13_164_chunk r_133 -> Seq Scan on compress_hyper_14_867_chunk -> Custom Scan (ColumnarScan) on _hyper_13_165_chunk r_134 -> Seq Scan on compress_hyper_14_868_chunk -> Custom Scan (ColumnarScan) on _hyper_13_166_chunk r_135 -> Seq Scan on compress_hyper_14_869_chunk -> Custom Scan (ColumnarScan) on _hyper_13_167_chunk r_136 -> Seq Scan on compress_hyper_14_870_chunk -> Custom Scan (ColumnarScan) on _hyper_13_168_chunk r_137 -> Seq Scan on compress_hyper_14_871_chunk -> Custom Scan (ColumnarScan) on _hyper_13_169_chunk r_138 -> Seq Scan on compress_hyper_14_872_chunk -> Custom Scan (ColumnarScan) on _hyper_13_170_chunk r_139 -> Seq Scan on compress_hyper_14_873_chunk -> Custom Scan (ColumnarScan) on _hyper_13_171_chunk r_140 -> Seq Scan on compress_hyper_14_874_chunk -> Custom Scan (ColumnarScan) on _hyper_13_172_chunk r_141 -> Seq Scan on compress_hyper_14_875_chunk -> Custom Scan (ColumnarScan) on _hyper_13_173_chunk r_142 -> Seq Scan on compress_hyper_14_876_chunk -> Custom Scan (ColumnarScan) on _hyper_13_174_chunk r_143 -> Seq Scan on compress_hyper_14_877_chunk -> Custom Scan (ColumnarScan) on _hyper_13_175_chunk r_144 -> Seq Scan on compress_hyper_14_878_chunk -> Custom Scan (ColumnarScan) on _hyper_13_176_chunk r_145 -> Seq Scan on compress_hyper_14_879_chunk -> Custom Scan (ColumnarScan) on _hyper_13_177_chunk r_146 -> Seq Scan on compress_hyper_14_880_chunk -> Custom Scan (ColumnarScan) on _hyper_13_178_chunk r_147 -> Seq Scan on compress_hyper_14_881_chunk -> Custom Scan (ColumnarScan) on _hyper_13_179_chunk r_148 -> Seq Scan on compress_hyper_14_882_chunk -> Custom Scan (ColumnarScan) on _hyper_13_180_chunk r_149 -> Seq Scan on compress_hyper_14_883_chunk -> Custom Scan (ColumnarScan) on _hyper_13_181_chunk r_150 -> Seq Scan on compress_hyper_14_884_chunk -> Custom Scan (ColumnarScan) on _hyper_13_182_chunk r_151 -> Seq Scan on compress_hyper_14_885_chunk -> Custom Scan (ColumnarScan) on _hyper_13_183_chunk r_152 -> Seq Scan on compress_hyper_14_886_chunk -> Custom Scan (ColumnarScan) on _hyper_13_184_chunk r_153 -> Seq Scan on compress_hyper_14_887_chunk -> Custom Scan (ColumnarScan) on _hyper_13_185_chunk r_154 -> Seq Scan on compress_hyper_14_888_chunk -> Custom Scan (ColumnarScan) on _hyper_13_186_chunk r_155 -> Seq Scan on compress_hyper_14_889_chunk -> Custom Scan (ColumnarScan) on _hyper_13_187_chunk r_156 -> Seq Scan on compress_hyper_14_890_chunk -> Custom Scan (ColumnarScan) on _hyper_13_188_chunk r_157 -> Seq Scan on compress_hyper_14_891_chunk -> Custom Scan (ColumnarScan) on _hyper_13_189_chunk r_158 -> Seq Scan on compress_hyper_14_892_chunk -> Custom Scan (ColumnarScan) on _hyper_13_190_chunk r_159 -> Seq Scan on compress_hyper_14_893_chunk -> Custom Scan (ColumnarScan) on _hyper_13_191_chunk r_160 -> Seq Scan on compress_hyper_14_894_chunk -> Custom Scan (ColumnarScan) on _hyper_13_192_chunk r_161 -> Seq Scan on compress_hyper_14_895_chunk -> Custom Scan (ColumnarScan) on _hyper_13_193_chunk r_162 -> Seq Scan on compress_hyper_14_896_chunk -> Custom Scan (ColumnarScan) on _hyper_13_194_chunk r_163 -> Seq Scan on compress_hyper_14_897_chunk -> Custom Scan (ColumnarScan) on _hyper_13_195_chunk r_164 -> Seq Scan on compress_hyper_14_898_chunk -> Custom Scan (ColumnarScan) on _hyper_13_196_chunk r_165 -> Seq Scan on compress_hyper_14_899_chunk -> Custom Scan (ColumnarScan) on _hyper_13_197_chunk r_166 -> Seq Scan on compress_hyper_14_900_chunk -> Custom Scan (ColumnarScan) on _hyper_13_198_chunk r_167 -> Seq Scan on compress_hyper_14_901_chunk -> Custom Scan (ColumnarScan) on _hyper_13_199_chunk r_168 -> Seq Scan on compress_hyper_14_902_chunk -> Custom Scan (ColumnarScan) on _hyper_13_200_chunk r_169 -> Seq Scan on compress_hyper_14_903_chunk -> Custom Scan (ColumnarScan) on _hyper_13_201_chunk r_170 -> Seq Scan on compress_hyper_14_904_chunk -> Custom Scan (ColumnarScan) on _hyper_13_202_chunk r_171 -> Seq Scan on compress_hyper_14_905_chunk -> Custom Scan (ColumnarScan) on _hyper_13_203_chunk r_172 -> Seq Scan on compress_hyper_14_906_chunk -> Custom Scan (ColumnarScan) on _hyper_13_204_chunk r_173 -> Seq Scan on compress_hyper_14_907_chunk -> Custom Scan (ColumnarScan) on _hyper_13_205_chunk r_174 -> Seq Scan on compress_hyper_14_908_chunk -> Custom Scan (ColumnarScan) on _hyper_13_206_chunk r_175 -> Seq Scan on compress_hyper_14_909_chunk -> Custom Scan (ColumnarScan) on _hyper_13_207_chunk r_176 -> Seq Scan on compress_hyper_14_910_chunk -> Custom Scan (ColumnarScan) on _hyper_13_208_chunk r_177 -> Seq Scan on compress_hyper_14_911_chunk -> Custom Scan (ColumnarScan) on _hyper_13_209_chunk r_178 -> Seq Scan on compress_hyper_14_912_chunk -> Custom Scan (ColumnarScan) on _hyper_13_210_chunk r_179 -> Seq Scan on compress_hyper_14_913_chunk -> Custom Scan (ColumnarScan) on _hyper_13_211_chunk r_180 -> Seq Scan on compress_hyper_14_914_chunk -> Custom Scan (ColumnarScan) on _hyper_13_212_chunk r_181 -> Seq Scan on compress_hyper_14_915_chunk -> Custom Scan (ColumnarScan) on _hyper_13_213_chunk r_182 -> Seq Scan on compress_hyper_14_916_chunk -> Custom Scan (ColumnarScan) on _hyper_13_214_chunk r_183 -> Seq Scan on compress_hyper_14_917_chunk -> Custom Scan (ColumnarScan) on _hyper_13_215_chunk r_184 -> Seq Scan on compress_hyper_14_918_chunk -> Custom Scan (ColumnarScan) on _hyper_13_216_chunk r_185 -> Seq Scan on compress_hyper_14_919_chunk -> Custom Scan (ColumnarScan) on _hyper_13_217_chunk r_186 -> Seq Scan on compress_hyper_14_920_chunk -> Custom Scan (ColumnarScan) on _hyper_13_218_chunk r_187 -> Seq Scan on compress_hyper_14_921_chunk -> Custom Scan (ColumnarScan) on _hyper_13_219_chunk r_188 -> Seq Scan on compress_hyper_14_922_chunk -> Custom Scan (ColumnarScan) on _hyper_13_220_chunk r_189 -> Seq Scan on compress_hyper_14_923_chunk -> Custom Scan (ColumnarScan) on _hyper_13_221_chunk r_190 -> Seq Scan on compress_hyper_14_924_chunk -> Custom Scan (ColumnarScan) on _hyper_13_222_chunk r_191 -> Seq Scan on compress_hyper_14_925_chunk -> Custom Scan (ColumnarScan) on _hyper_13_223_chunk r_192 -> Seq Scan on compress_hyper_14_926_chunk -> Custom Scan (ColumnarScan) on _hyper_13_224_chunk r_193 -> Seq Scan on compress_hyper_14_927_chunk -> Custom Scan (ColumnarScan) on _hyper_13_225_chunk r_194 -> Seq Scan on compress_hyper_14_928_chunk -> Custom Scan (ColumnarScan) on _hyper_13_226_chunk r_195 -> Seq Scan on compress_hyper_14_929_chunk -> Custom Scan (ColumnarScan) on _hyper_13_227_chunk r_196 -> Seq Scan on compress_hyper_14_930_chunk -> Custom Scan (ColumnarScan) on _hyper_13_228_chunk r_197 -> Seq Scan on compress_hyper_14_931_chunk -> Custom Scan (ColumnarScan) on _hyper_13_229_chunk r_198 -> Seq Scan on compress_hyper_14_932_chunk -> Custom Scan (ColumnarScan) on _hyper_13_230_chunk r_199 -> Seq Scan on compress_hyper_14_933_chunk -> Custom Scan (ColumnarScan) on _hyper_13_231_chunk r_200 -> Seq Scan on compress_hyper_14_934_chunk -> Custom Scan (ColumnarScan) on _hyper_13_232_chunk r_201 -> Seq Scan on compress_hyper_14_935_chunk -> Custom Scan (ColumnarScan) on _hyper_13_233_chunk r_202 -> Seq Scan on compress_hyper_14_936_chunk -> Custom Scan (ColumnarScan) on _hyper_13_234_chunk r_203 -> Seq Scan on compress_hyper_14_937_chunk -> Custom Scan (ColumnarScan) on _hyper_13_235_chunk r_204 -> Seq Scan on compress_hyper_14_938_chunk -> Custom Scan (ColumnarScan) on _hyper_13_236_chunk r_205 -> Seq Scan on compress_hyper_14_939_chunk -> Custom Scan (ColumnarScan) on _hyper_13_237_chunk r_206 -> Seq Scan on compress_hyper_14_940_chunk -> Custom Scan (ColumnarScan) on _hyper_13_238_chunk r_207 -> Seq Scan on compress_hyper_14_941_chunk -> Custom Scan (ColumnarScan) on _hyper_13_239_chunk r_208 -> Seq Scan on compress_hyper_14_942_chunk -> Custom Scan (ColumnarScan) on _hyper_13_240_chunk r_209 -> Seq Scan on compress_hyper_14_943_chunk -> Custom Scan (ColumnarScan) on _hyper_13_241_chunk r_210 -> Seq Scan on compress_hyper_14_944_chunk -> Custom Scan (ColumnarScan) on _hyper_13_242_chunk r_211 -> Seq Scan on compress_hyper_14_945_chunk -> Custom Scan (ColumnarScan) on _hyper_13_243_chunk r_212 -> Seq Scan on compress_hyper_14_946_chunk -> Custom Scan (ColumnarScan) on _hyper_13_244_chunk r_213 -> Seq Scan on compress_hyper_14_947_chunk -> Custom Scan (ColumnarScan) on _hyper_13_245_chunk r_214 -> Seq Scan on compress_hyper_14_948_chunk -> Custom Scan (ColumnarScan) on _hyper_13_246_chunk r_215 -> Seq Scan on compress_hyper_14_949_chunk -> Custom Scan (ColumnarScan) on _hyper_13_247_chunk r_216 -> Seq Scan on compress_hyper_14_950_chunk -> Custom Scan (ColumnarScan) on _hyper_13_248_chunk r_217 -> Seq Scan on compress_hyper_14_951_chunk -> Custom Scan (ColumnarScan) on _hyper_13_249_chunk r_218 -> Seq Scan on compress_hyper_14_952_chunk -> Custom Scan (ColumnarScan) on _hyper_13_250_chunk r_219 -> Seq Scan on compress_hyper_14_953_chunk -> Custom Scan (ColumnarScan) on _hyper_13_251_chunk r_220 -> Seq Scan on compress_hyper_14_954_chunk -> Custom Scan (ColumnarScan) on _hyper_13_252_chunk r_221 -> Seq Scan on compress_hyper_14_955_chunk -> Custom Scan (ColumnarScan) on _hyper_13_253_chunk r_222 -> Seq Scan on compress_hyper_14_956_chunk -> Custom Scan (ColumnarScan) on _hyper_13_254_chunk r_223 -> Seq Scan on compress_hyper_14_957_chunk -> Custom Scan (ColumnarScan) on _hyper_13_255_chunk r_224 -> Seq Scan on compress_hyper_14_958_chunk -> Custom Scan (ColumnarScan) on _hyper_13_256_chunk r_225 -> Seq Scan on compress_hyper_14_959_chunk -> Custom Scan (ColumnarScan) on _hyper_13_257_chunk r_226 -> Seq Scan on compress_hyper_14_960_chunk -> Custom Scan (ColumnarScan) on _hyper_13_258_chunk r_227 -> Seq Scan on compress_hyper_14_961_chunk -> Custom Scan (ColumnarScan) on _hyper_13_259_chunk r_228 -> Seq Scan on compress_hyper_14_962_chunk -> Custom Scan (ColumnarScan) on _hyper_13_260_chunk r_229 -> Seq Scan on compress_hyper_14_963_chunk -> Custom Scan (ColumnarScan) on _hyper_13_261_chunk r_230 -> Seq Scan on compress_hyper_14_964_chunk -> Custom Scan (ColumnarScan) on _hyper_13_262_chunk r_231 -> Seq Scan on compress_hyper_14_965_chunk -> Custom Scan (ColumnarScan) on _hyper_13_263_chunk r_232 -> Seq Scan on compress_hyper_14_966_chunk -> Custom Scan (ColumnarScan) on _hyper_13_264_chunk r_233 -> Seq Scan on compress_hyper_14_967_chunk -> Custom Scan (ColumnarScan) on _hyper_13_265_chunk r_234 -> Seq Scan on compress_hyper_14_968_chunk -> Custom Scan (ColumnarScan) on _hyper_13_266_chunk r_235 -> Seq Scan on compress_hyper_14_969_chunk -> Custom Scan (ColumnarScan) on _hyper_13_267_chunk r_236 -> Seq Scan on compress_hyper_14_970_chunk -> Custom Scan (ColumnarScan) on _hyper_13_268_chunk r_237 -> Seq Scan on compress_hyper_14_971_chunk -> Custom Scan (ColumnarScan) on _hyper_13_269_chunk r_238 -> Seq Scan on compress_hyper_14_972_chunk -> Custom Scan (ColumnarScan) on _hyper_13_270_chunk r_239 -> Seq Scan on compress_hyper_14_973_chunk -> Custom Scan (ColumnarScan) on _hyper_13_271_chunk r_240 -> Seq Scan on compress_hyper_14_974_chunk -> Custom Scan (ColumnarScan) on _hyper_13_272_chunk r_241 -> Seq Scan on compress_hyper_14_975_chunk -> Custom Scan (ColumnarScan) on _hyper_13_273_chunk r_242 -> Seq Scan on compress_hyper_14_976_chunk -> Custom Scan (ColumnarScan) on _hyper_13_274_chunk r_243 -> Seq Scan on compress_hyper_14_977_chunk -> Custom Scan (ColumnarScan) on _hyper_13_275_chunk r_244 -> Seq Scan on compress_hyper_14_978_chunk -> Custom Scan (ColumnarScan) on _hyper_13_276_chunk r_245 -> Seq Scan on compress_hyper_14_979_chunk -> Custom Scan (ColumnarScan) on _hyper_13_277_chunk r_246 -> Seq Scan on compress_hyper_14_980_chunk -> Custom Scan (ColumnarScan) on _hyper_13_278_chunk r_247 -> Seq Scan on compress_hyper_14_981_chunk -> Custom Scan (ColumnarScan) on _hyper_13_279_chunk r_248 -> Seq Scan on compress_hyper_14_982_chunk -> Custom Scan (ColumnarScan) on _hyper_13_280_chunk r_249 -> Seq Scan on compress_hyper_14_983_chunk -> Custom Scan (ColumnarScan) on _hyper_13_281_chunk r_250 -> Seq Scan on compress_hyper_14_984_chunk -> Custom Scan (ColumnarScan) on _hyper_13_282_chunk r_251 -> Seq Scan on compress_hyper_14_985_chunk -> Custom Scan (ColumnarScan) on _hyper_13_283_chunk r_252 -> Seq Scan on compress_hyper_14_986_chunk -> Custom Scan (ColumnarScan) on _hyper_13_284_chunk r_253 -> Seq Scan on compress_hyper_14_987_chunk -> Custom Scan (ColumnarScan) on _hyper_13_285_chunk r_254 -> Seq Scan on compress_hyper_14_988_chunk -> Custom Scan (ColumnarScan) on _hyper_13_286_chunk r_255 -> Seq Scan on compress_hyper_14_989_chunk -> Custom Scan (ColumnarScan) on _hyper_13_287_chunk r_256 -> Seq Scan on compress_hyper_14_990_chunk -> Custom Scan (ColumnarScan) on _hyper_13_288_chunk r_257 -> Seq Scan on compress_hyper_14_991_chunk -> Custom Scan (ColumnarScan) on _hyper_13_289_chunk r_258 -> Seq Scan on compress_hyper_14_992_chunk -> Custom Scan (ColumnarScan) on _hyper_13_290_chunk r_259 -> Seq Scan on compress_hyper_14_993_chunk -> Custom Scan (ColumnarScan) on _hyper_13_291_chunk r_260 -> Seq Scan on compress_hyper_14_994_chunk -> Custom Scan (ColumnarScan) on _hyper_13_292_chunk r_261 -> Seq Scan on compress_hyper_14_995_chunk -> Custom Scan (ColumnarScan) on _hyper_13_293_chunk r_262 -> Seq Scan on compress_hyper_14_996_chunk -> Custom Scan (ColumnarScan) on _hyper_13_294_chunk r_263 -> Seq Scan on compress_hyper_14_997_chunk -> Custom Scan (ColumnarScan) on _hyper_13_295_chunk r_264 -> Seq Scan on compress_hyper_14_998_chunk -> Custom Scan (ColumnarScan) on _hyper_13_296_chunk r_265 -> Seq Scan on compress_hyper_14_999_chunk -> Custom Scan (ColumnarScan) on _hyper_13_297_chunk r_266 -> Seq Scan on compress_hyper_14_1000_chunk -> Custom Scan (ColumnarScan) on _hyper_13_298_chunk r_267 -> Seq Scan on compress_hyper_14_1001_chunk -> Custom Scan (ColumnarScan) on _hyper_13_299_chunk r_268 -> Seq Scan on compress_hyper_14_1002_chunk -> Custom Scan (ColumnarScan) on _hyper_13_300_chunk r_269 -> Seq Scan on compress_hyper_14_1003_chunk -> Custom Scan (ColumnarScan) on _hyper_13_301_chunk r_270 -> Seq Scan on compress_hyper_14_1004_chunk -> Custom Scan (ColumnarScan) on _hyper_13_302_chunk r_271 -> Seq Scan on compress_hyper_14_1005_chunk -> Custom Scan (ColumnarScan) on _hyper_13_303_chunk r_272 -> Seq Scan on compress_hyper_14_1006_chunk -> Custom Scan (ColumnarScan) on _hyper_13_304_chunk r_273 -> Seq Scan on compress_hyper_14_1007_chunk -> Custom Scan (ColumnarScan) on _hyper_13_305_chunk r_274 -> Seq Scan on compress_hyper_14_1008_chunk -> Custom Scan (ColumnarScan) on _hyper_13_306_chunk r_275 -> Seq Scan on compress_hyper_14_1009_chunk -> Custom Scan (ColumnarScan) on _hyper_13_307_chunk r_276 -> Seq Scan on compress_hyper_14_1010_chunk -> Custom Scan (ColumnarScan) on _hyper_13_308_chunk r_277 -> Seq Scan on compress_hyper_14_1011_chunk -> Custom Scan (ColumnarScan) on _hyper_13_309_chunk r_278 -> Seq Scan on compress_hyper_14_1012_chunk -> Custom Scan (ColumnarScan) on _hyper_13_310_chunk r_279 -> Seq Scan on compress_hyper_14_1013_chunk -> Custom Scan (ColumnarScan) on _hyper_13_311_chunk r_280 -> Seq Scan on compress_hyper_14_1014_chunk -> Custom Scan (ColumnarScan) on _hyper_13_312_chunk r_281 -> Seq Scan on compress_hyper_14_1015_chunk -> Custom Scan (ColumnarScan) on _hyper_13_313_chunk r_282 -> Seq Scan on compress_hyper_14_1016_chunk -> Custom Scan (ColumnarScan) on _hyper_13_314_chunk r_283 -> Seq Scan on compress_hyper_14_1017_chunk -> Custom Scan (ColumnarScan) on _hyper_13_315_chunk r_284 -> Seq Scan on compress_hyper_14_1018_chunk -> Custom Scan (ColumnarScan) on _hyper_13_316_chunk r_285 -> Seq Scan on compress_hyper_14_1019_chunk -> Custom Scan (ColumnarScan) on _hyper_13_317_chunk r_286 -> Seq Scan on compress_hyper_14_1020_chunk -> Custom Scan (ColumnarScan) on _hyper_13_318_chunk r_287 -> Seq Scan on compress_hyper_14_1021_chunk -> Custom Scan (ColumnarScan) on _hyper_13_319_chunk r_288 -> Seq Scan on compress_hyper_14_1022_chunk -> Custom Scan (ColumnarScan) on _hyper_13_320_chunk r_289 -> Seq Scan on compress_hyper_14_1023_chunk -> Custom Scan (ColumnarScan) on _hyper_13_321_chunk r_290 -> Seq Scan on compress_hyper_14_1024_chunk -> Custom Scan (ColumnarScan) on _hyper_13_322_chunk r_291 -> Seq Scan on compress_hyper_14_1025_chunk -> Custom Scan (ColumnarScan) on _hyper_13_323_chunk r_292 -> Seq Scan on compress_hyper_14_1026_chunk -> Custom Scan (ColumnarScan) on _hyper_13_324_chunk r_293 -> Seq Scan on compress_hyper_14_1027_chunk -> Custom Scan (ColumnarScan) on _hyper_13_325_chunk r_294 -> Seq Scan on compress_hyper_14_1028_chunk -> Custom Scan (ColumnarScan) on _hyper_13_326_chunk r_295 -> Seq Scan on compress_hyper_14_1029_chunk -> Custom Scan (ColumnarScan) on _hyper_13_327_chunk r_296 -> Seq Scan on compress_hyper_14_1030_chunk -> Custom Scan (ColumnarScan) on _hyper_13_328_chunk r_297 -> Seq Scan on compress_hyper_14_1031_chunk -> Custom Scan (ColumnarScan) on _hyper_13_329_chunk r_298 -> Seq Scan on compress_hyper_14_1032_chunk -> Custom Scan (ColumnarScan) on _hyper_13_330_chunk r_299 -> Seq Scan on compress_hyper_14_1033_chunk -> Custom Scan (ColumnarScan) on _hyper_13_331_chunk r_300 -> Seq Scan on compress_hyper_14_1034_chunk -> Custom Scan (ColumnarScan) on _hyper_13_332_chunk r_301 -> Seq Scan on compress_hyper_14_1035_chunk -> Custom Scan (ColumnarScan) on _hyper_13_333_chunk r_302 -> Seq Scan on compress_hyper_14_1036_chunk -> Custom Scan (ColumnarScan) on _hyper_13_334_chunk r_303 -> Seq Scan on compress_hyper_14_1037_chunk -> Custom Scan (ColumnarScan) on _hyper_13_335_chunk r_304 -> Seq Scan on compress_hyper_14_1038_chunk -> Custom Scan (ColumnarScan) on _hyper_13_336_chunk r_305 -> Seq Scan on compress_hyper_14_1039_chunk -> Custom Scan (ColumnarScan) on _hyper_13_337_chunk r_306 -> Seq Scan on compress_hyper_14_1040_chunk -> Custom Scan (ColumnarScan) on _hyper_13_338_chunk r_307 -> Seq Scan on compress_hyper_14_1041_chunk -> Custom Scan (ColumnarScan) on _hyper_13_339_chunk r_308 -> Seq Scan on compress_hyper_14_1042_chunk -> Custom Scan (ColumnarScan) on _hyper_13_340_chunk r_309 -> Seq Scan on compress_hyper_14_1043_chunk -> Custom Scan (ColumnarScan) on _hyper_13_341_chunk r_310 -> Seq Scan on compress_hyper_14_1044_chunk -> Custom Scan (ColumnarScan) on _hyper_13_342_chunk r_311 -> Seq Scan on compress_hyper_14_1045_chunk -> Custom Scan (ColumnarScan) on _hyper_13_343_chunk r_312 -> Seq Scan on compress_hyper_14_1046_chunk -> Custom Scan (ColumnarScan) on _hyper_13_344_chunk r_313 -> Seq Scan on compress_hyper_14_1047_chunk -> Custom Scan (ColumnarScan) on _hyper_13_345_chunk r_314 -> Seq Scan on compress_hyper_14_1048_chunk -> Custom Scan (ColumnarScan) on _hyper_13_346_chunk r_315 -> Seq Scan on compress_hyper_14_1049_chunk -> Custom Scan (ColumnarScan) on _hyper_13_347_chunk r_316 -> Seq Scan on compress_hyper_14_1050_chunk -> Custom Scan (ColumnarScan) on _hyper_13_348_chunk r_317 -> Seq Scan on compress_hyper_14_1051_chunk -> Custom Scan (ColumnarScan) on _hyper_13_349_chunk r_318 -> Seq Scan on compress_hyper_14_1052_chunk -> Custom Scan (ColumnarScan) on _hyper_13_350_chunk r_319 -> Seq Scan on compress_hyper_14_1053_chunk -> Custom Scan (ColumnarScan) on _hyper_13_351_chunk r_320 -> Seq Scan on compress_hyper_14_1054_chunk -> Custom Scan (ColumnarScan) on _hyper_13_352_chunk r_321 -> Seq Scan on compress_hyper_14_1055_chunk -> Custom Scan (ColumnarScan) on _hyper_13_353_chunk r_322 -> Seq Scan on compress_hyper_14_1056_chunk -> Custom Scan (ColumnarScan) on _hyper_13_354_chunk r_323 -> Seq Scan on compress_hyper_14_1057_chunk -> Custom Scan (ColumnarScan) on _hyper_13_355_chunk r_324 -> Seq Scan on compress_hyper_14_1058_chunk -> Custom Scan (ColumnarScan) on _hyper_13_356_chunk r_325 -> Seq Scan on compress_hyper_14_1059_chunk -> Custom Scan (ColumnarScan) on _hyper_13_357_chunk r_326 -> Seq Scan on compress_hyper_14_1060_chunk -> Custom Scan (ColumnarScan) on _hyper_13_358_chunk r_327 -> Seq Scan on compress_hyper_14_1061_chunk -> Custom Scan (ColumnarScan) on _hyper_13_359_chunk r_328 -> Seq Scan on compress_hyper_14_1062_chunk -> Custom Scan (ColumnarScan) on _hyper_13_360_chunk r_329 -> Seq Scan on compress_hyper_14_1063_chunk -> Custom Scan (ColumnarScan) on _hyper_13_361_chunk r_330 -> Seq Scan on compress_hyper_14_1064_chunk -> Custom Scan (ColumnarScan) on _hyper_13_362_chunk r_331 -> Seq Scan on compress_hyper_14_1065_chunk -> Custom Scan (ColumnarScan) on _hyper_13_363_chunk r_332 -> Seq Scan on compress_hyper_14_1066_chunk -> Custom Scan (ColumnarScan) on _hyper_13_364_chunk r_333 -> Seq Scan on compress_hyper_14_1067_chunk -> Custom Scan (ColumnarScan) on _hyper_13_365_chunk r_334 -> Seq Scan on compress_hyper_14_1068_chunk -> Custom Scan (ColumnarScan) on _hyper_13_366_chunk r_335 -> Seq Scan on compress_hyper_14_1069_chunk -> Custom Scan (ColumnarScan) on _hyper_13_367_chunk r_336 -> Seq Scan on compress_hyper_14_1070_chunk -> Custom Scan (ColumnarScan) on _hyper_13_368_chunk r_337 -> Seq Scan on compress_hyper_14_1071_chunk -> Custom Scan (ColumnarScan) on _hyper_13_369_chunk r_338 -> Seq Scan on compress_hyper_14_1072_chunk -> Custom Scan (ColumnarScan) on _hyper_13_370_chunk r_339 -> Seq Scan on compress_hyper_14_1073_chunk -> Custom Scan (ColumnarScan) on _hyper_13_371_chunk r_340 -> Seq Scan on compress_hyper_14_1074_chunk -> Custom Scan (ColumnarScan) on _hyper_13_372_chunk r_341 -> Seq Scan on compress_hyper_14_1075_chunk -> Custom Scan (ColumnarScan) on _hyper_13_373_chunk r_342 -> Seq Scan on compress_hyper_14_1076_chunk -> Custom Scan (ColumnarScan) on _hyper_13_374_chunk r_343 -> Seq Scan on compress_hyper_14_1077_chunk -> Custom Scan (ColumnarScan) on _hyper_13_375_chunk r_344 -> Seq Scan on compress_hyper_14_1078_chunk -> Custom Scan (ColumnarScan) on _hyper_13_376_chunk r_345 -> Seq Scan on compress_hyper_14_1079_chunk -> Custom Scan (ColumnarScan) on _hyper_13_377_chunk r_346 -> Seq Scan on compress_hyper_14_1080_chunk -> Custom Scan (ColumnarScan) on _hyper_13_378_chunk r_347 -> Seq Scan on compress_hyper_14_1081_chunk -> Custom Scan (ColumnarScan) on _hyper_13_379_chunk r_348 -> Seq Scan on compress_hyper_14_1082_chunk -> Custom Scan (ColumnarScan) on _hyper_13_380_chunk r_349 -> Seq Scan on compress_hyper_14_1083_chunk -> Custom Scan (ColumnarScan) on _hyper_13_381_chunk r_350 -> Seq Scan on compress_hyper_14_1084_chunk -> Custom Scan (ColumnarScan) on _hyper_13_382_chunk r_351 -> Seq Scan on compress_hyper_14_1085_chunk -> Custom Scan (ColumnarScan) on _hyper_13_383_chunk r_352 -> Seq Scan on compress_hyper_14_1086_chunk -> Custom Scan (ColumnarScan) on _hyper_13_384_chunk r_353 -> Seq Scan on compress_hyper_14_1087_chunk -> Custom Scan (ColumnarScan) on _hyper_13_385_chunk r_354 -> Seq Scan on compress_hyper_14_1088_chunk -> Custom Scan (ColumnarScan) on _hyper_13_386_chunk r_355 -> Seq Scan on compress_hyper_14_1089_chunk -> Custom Scan (ColumnarScan) on _hyper_13_387_chunk r_356 -> Seq Scan on compress_hyper_14_1090_chunk -> Custom Scan (ColumnarScan) on _hyper_13_388_chunk r_357 -> Seq Scan on compress_hyper_14_1091_chunk -> Custom Scan (ColumnarScan) on _hyper_13_389_chunk r_358 -> Seq Scan on compress_hyper_14_1092_chunk -> Custom Scan (ColumnarScan) on _hyper_13_390_chunk r_359 -> Seq Scan on compress_hyper_14_1093_chunk -> Custom Scan (ColumnarScan) on _hyper_13_391_chunk r_360 -> Seq Scan on compress_hyper_14_1094_chunk -> Custom Scan (ColumnarScan) on _hyper_13_392_chunk r_361 -> Seq Scan on compress_hyper_14_1095_chunk -> Custom Scan (ColumnarScan) on _hyper_13_393_chunk r_362 -> Seq Scan on compress_hyper_14_1096_chunk -> Custom Scan (ColumnarScan) on _hyper_13_394_chunk r_363 -> Seq Scan on compress_hyper_14_1097_chunk -> Custom Scan (ColumnarScan) on _hyper_13_395_chunk r_364 -> Seq Scan on compress_hyper_14_1098_chunk -> Custom Scan (ColumnarScan) on _hyper_13_396_chunk r_365 -> Seq Scan on compress_hyper_14_1099_chunk -> Custom Scan (ColumnarScan) on _hyper_13_397_chunk r_366 -> Seq Scan on compress_hyper_14_1100_chunk -> Custom Scan (ColumnarScan) on _hyper_13_398_chunk r_367 -> Seq Scan on compress_hyper_14_1101_chunk -> Custom Scan (ColumnarScan) on _hyper_13_399_chunk r_368 -> Seq Scan on compress_hyper_14_1102_chunk -> Custom Scan (ColumnarScan) on _hyper_13_400_chunk r_369 -> Seq Scan on compress_hyper_14_1103_chunk -> Custom Scan (ColumnarScan) on _hyper_13_401_chunk r_370 -> Seq Scan on compress_hyper_14_1104_chunk -> Custom Scan (ColumnarScan) on _hyper_13_402_chunk r_371 -> Seq Scan on compress_hyper_14_1105_chunk -> Custom Scan (ColumnarScan) on _hyper_13_403_chunk r_372 -> Seq Scan on compress_hyper_14_1106_chunk -> Custom Scan (ColumnarScan) on _hyper_13_404_chunk r_373 -> Seq Scan on compress_hyper_14_1107_chunk -> Custom Scan (ColumnarScan) on _hyper_13_405_chunk r_374 -> Seq Scan on compress_hyper_14_1108_chunk -> Custom Scan (ColumnarScan) on _hyper_13_406_chunk r_375 -> Seq Scan on compress_hyper_14_1109_chunk -> Custom Scan (ColumnarScan) on _hyper_13_407_chunk r_376 -> Seq Scan on compress_hyper_14_1110_chunk -> Custom Scan (ColumnarScan) on _hyper_13_408_chunk r_377 -> Seq Scan on compress_hyper_14_1111_chunk -> Custom Scan (ColumnarScan) on _hyper_13_409_chunk r_378 -> Seq Scan on compress_hyper_14_1112_chunk -> Custom Scan (ColumnarScan) on _hyper_13_410_chunk r_379 -> Seq Scan on compress_hyper_14_1113_chunk -> Custom Scan (ColumnarScan) on _hyper_13_411_chunk r_380 -> Seq Scan on compress_hyper_14_1114_chunk -> Custom Scan (ColumnarScan) on _hyper_13_412_chunk r_381 -> Seq Scan on compress_hyper_14_1115_chunk -> Custom Scan (ColumnarScan) on _hyper_13_413_chunk r_382 -> Seq Scan on compress_hyper_14_1116_chunk -> Custom Scan (ColumnarScan) on _hyper_13_414_chunk r_383 -> Seq Scan on compress_hyper_14_1117_chunk -> Custom Scan (ColumnarScan) on _hyper_13_415_chunk r_384 -> Seq Scan on compress_hyper_14_1118_chunk -> Custom Scan (ColumnarScan) on _hyper_13_416_chunk r_385 -> Seq Scan on compress_hyper_14_1119_chunk -> Custom Scan (ColumnarScan) on _hyper_13_417_chunk r_386 -> Seq Scan on compress_hyper_14_1120_chunk -> Custom Scan (ColumnarScan) on _hyper_13_418_chunk r_387 -> Seq Scan on compress_hyper_14_1121_chunk -> Custom Scan (ColumnarScan) on _hyper_13_419_chunk r_388 -> Seq Scan on compress_hyper_14_1122_chunk -> Custom Scan (ColumnarScan) on _hyper_13_420_chunk r_389 -> Seq Scan on compress_hyper_14_1123_chunk -> Custom Scan (ColumnarScan) on _hyper_13_421_chunk r_390 -> Seq Scan on compress_hyper_14_1124_chunk -> Custom Scan (ColumnarScan) on _hyper_13_422_chunk r_391 -> Seq Scan on compress_hyper_14_1125_chunk -> Custom Scan (ColumnarScan) on _hyper_13_423_chunk r_392 -> Seq Scan on compress_hyper_14_1126_chunk -> Custom Scan (ColumnarScan) on _hyper_13_424_chunk r_393 -> Seq Scan on compress_hyper_14_1127_chunk -> Custom Scan (ColumnarScan) on _hyper_13_425_chunk r_394 -> Seq Scan on compress_hyper_14_1128_chunk -> Custom Scan (ColumnarScan) on _hyper_13_426_chunk r_395 -> Seq Scan on compress_hyper_14_1129_chunk -> Custom Scan (ColumnarScan) on _hyper_13_427_chunk r_396 -> Seq Scan on compress_hyper_14_1130_chunk -> Custom Scan (ColumnarScan) on _hyper_13_428_chunk r_397 -> Seq Scan on compress_hyper_14_1131_chunk -> Custom Scan (ColumnarScan) on _hyper_13_429_chunk r_398 -> Seq Scan on compress_hyper_14_1132_chunk -> Custom Scan (ColumnarScan) on _hyper_13_430_chunk r_399 -> Seq Scan on compress_hyper_14_1133_chunk -> Custom Scan (ColumnarScan) on _hyper_13_431_chunk r_400 -> Seq Scan on compress_hyper_14_1134_chunk -> Custom Scan (ColumnarScan) on _hyper_13_432_chunk r_401 -> Seq Scan on compress_hyper_14_1135_chunk -> Custom Scan (ColumnarScan) on _hyper_13_433_chunk r_402 -> Seq Scan on compress_hyper_14_1136_chunk -> Custom Scan (ColumnarScan) on _hyper_13_434_chunk r_403 -> Seq Scan on compress_hyper_14_1137_chunk -> Custom Scan (ColumnarScan) on _hyper_13_435_chunk r_404 -> Seq Scan on compress_hyper_14_1138_chunk -> Custom Scan (ColumnarScan) on _hyper_13_436_chunk r_405 -> Seq Scan on compress_hyper_14_1139_chunk -> Custom Scan (ColumnarScan) on _hyper_13_437_chunk r_406 -> Seq Scan on compress_hyper_14_1140_chunk -> Custom Scan (ColumnarScan) on _hyper_13_438_chunk r_407 -> Seq Scan on compress_hyper_14_1141_chunk -> Custom Scan (ColumnarScan) on _hyper_13_439_chunk r_408 -> Seq Scan on compress_hyper_14_1142_chunk -> Custom Scan (ColumnarScan) on _hyper_13_440_chunk r_409 -> Seq Scan on compress_hyper_14_1143_chunk -> Custom Scan (ColumnarScan) on _hyper_13_441_chunk r_410 -> Seq Scan on compress_hyper_14_1144_chunk -> Custom Scan (ColumnarScan) on _hyper_13_442_chunk r_411 -> Seq Scan on compress_hyper_14_1145_chunk -> Custom Scan (ColumnarScan) on _hyper_13_443_chunk r_412 -> Seq Scan on compress_hyper_14_1146_chunk -> Custom Scan (ColumnarScan) on _hyper_13_444_chunk r_413 -> Seq Scan on compress_hyper_14_1147_chunk -> Custom Scan (ColumnarScan) on _hyper_13_445_chunk r_414 -> Seq Scan on compress_hyper_14_1148_chunk -> Custom Scan (ColumnarScan) on _hyper_13_446_chunk r_415 -> Seq Scan on compress_hyper_14_1149_chunk -> Custom Scan (ColumnarScan) on _hyper_13_447_chunk r_416 -> Seq Scan on compress_hyper_14_1150_chunk -> Custom Scan (ColumnarScan) on _hyper_13_448_chunk r_417 -> Seq Scan on compress_hyper_14_1151_chunk -> Custom Scan (ColumnarScan) on _hyper_13_449_chunk r_418 -> Seq Scan on compress_hyper_14_1152_chunk -> Custom Scan (ColumnarScan) on _hyper_13_450_chunk r_419 -> Seq Scan on compress_hyper_14_1153_chunk -> Custom Scan (ColumnarScan) on _hyper_13_451_chunk r_420 -> Seq Scan on compress_hyper_14_1154_chunk -> Custom Scan (ColumnarScan) on _hyper_13_452_chunk r_421 -> Seq Scan on compress_hyper_14_1155_chunk -> Custom Scan (ColumnarScan) on _hyper_13_453_chunk r_422 -> Seq Scan on compress_hyper_14_1156_chunk -> Custom Scan (ColumnarScan) on _hyper_13_454_chunk r_423 -> Seq Scan on compress_hyper_14_1157_chunk -> Custom Scan (ColumnarScan) on _hyper_13_455_chunk r_424 -> Seq Scan on compress_hyper_14_1158_chunk -> Custom Scan (ColumnarScan) on _hyper_13_456_chunk r_425 -> Seq Scan on compress_hyper_14_1159_chunk -> Custom Scan (ColumnarScan) on _hyper_13_457_chunk r_426 -> Seq Scan on compress_hyper_14_1160_chunk -> Custom Scan (ColumnarScan) on _hyper_13_458_chunk r_427 -> Seq Scan on compress_hyper_14_1161_chunk -> Custom Scan (ColumnarScan) on _hyper_13_459_chunk r_428 -> Seq Scan on compress_hyper_14_1162_chunk -> Custom Scan (ColumnarScan) on _hyper_13_460_chunk r_429 -> Seq Scan on compress_hyper_14_1163_chunk -> Custom Scan (ColumnarScan) on _hyper_13_461_chunk r_430 -> Seq Scan on compress_hyper_14_1164_chunk -> Custom Scan (ColumnarScan) on _hyper_13_462_chunk r_431 -> Seq Scan on compress_hyper_14_1165_chunk -> Custom Scan (ColumnarScan) on _hyper_13_463_chunk r_432 -> Seq Scan on compress_hyper_14_1166_chunk -> Custom Scan (ColumnarScan) on _hyper_13_464_chunk r_433 -> Seq Scan on compress_hyper_14_1167_chunk -> Custom Scan (ColumnarScan) on _hyper_13_465_chunk r_434 -> Seq Scan on compress_hyper_14_1168_chunk -> Custom Scan (ColumnarScan) on _hyper_13_466_chunk r_435 -> Seq Scan on compress_hyper_14_1169_chunk -> Custom Scan (ColumnarScan) on _hyper_13_467_chunk r_436 -> Seq Scan on compress_hyper_14_1170_chunk -> Custom Scan (ColumnarScan) on _hyper_13_468_chunk r_437 -> Seq Scan on compress_hyper_14_1171_chunk -> Custom Scan (ColumnarScan) on _hyper_13_469_chunk r_438 -> Seq Scan on compress_hyper_14_1172_chunk -> Custom Scan (ColumnarScan) on _hyper_13_470_chunk r_439 -> Seq Scan on compress_hyper_14_1173_chunk -> Custom Scan (ColumnarScan) on _hyper_13_471_chunk r_440 -> Seq Scan on compress_hyper_14_1174_chunk -> Custom Scan (ColumnarScan) on _hyper_13_472_chunk r_441 -> Seq Scan on compress_hyper_14_1175_chunk -> Custom Scan (ColumnarScan) on _hyper_13_473_chunk r_442 -> Seq Scan on compress_hyper_14_1176_chunk -> Custom Scan (ColumnarScan) on _hyper_13_474_chunk r_443 -> Seq Scan on compress_hyper_14_1177_chunk -> Custom Scan (ColumnarScan) on _hyper_13_475_chunk r_444 -> Seq Scan on compress_hyper_14_1178_chunk -> Custom Scan (ColumnarScan) on _hyper_13_476_chunk r_445 -> Seq Scan on compress_hyper_14_1179_chunk -> Custom Scan (ColumnarScan) on _hyper_13_477_chunk r_446 -> Seq Scan on compress_hyper_14_1180_chunk -> Custom Scan (ColumnarScan) on _hyper_13_478_chunk r_447 -> Seq Scan on compress_hyper_14_1181_chunk -> Custom Scan (ColumnarScan) on _hyper_13_479_chunk r_448 -> Seq Scan on compress_hyper_14_1182_chunk -> Custom Scan (ColumnarScan) on _hyper_13_480_chunk r_449 -> Seq Scan on compress_hyper_14_1183_chunk -> Custom Scan (ColumnarScan) on _hyper_13_481_chunk r_450 -> Seq Scan on compress_hyper_14_1184_chunk -> Custom Scan (ColumnarScan) on _hyper_13_482_chunk r_451 -> Seq Scan on compress_hyper_14_1185_chunk -> Custom Scan (ColumnarScan) on _hyper_13_483_chunk r_452 -> Seq Scan on compress_hyper_14_1186_chunk -> Custom Scan (ColumnarScan) on _hyper_13_484_chunk r_453 -> Seq Scan on compress_hyper_14_1187_chunk -> Custom Scan (ColumnarScan) on _hyper_13_485_chunk r_454 -> Seq Scan on compress_hyper_14_1188_chunk -> Custom Scan (ColumnarScan) on _hyper_13_486_chunk r_455 -> Seq Scan on compress_hyper_14_1189_chunk -> Custom Scan (ColumnarScan) on _hyper_13_487_chunk r_456 -> Seq Scan on compress_hyper_14_1190_chunk -> Custom Scan (ColumnarScan) on _hyper_13_488_chunk r_457 -> Seq Scan on compress_hyper_14_1191_chunk -> Custom Scan (ColumnarScan) on _hyper_13_489_chunk r_458 -> Seq Scan on compress_hyper_14_1192_chunk -> Custom Scan (ColumnarScan) on _hyper_13_490_chunk r_459 -> Seq Scan on compress_hyper_14_1193_chunk -> Custom Scan (ColumnarScan) on _hyper_13_491_chunk r_460 -> Seq Scan on compress_hyper_14_1194_chunk -> Custom Scan (ColumnarScan) on _hyper_13_492_chunk r_461 -> Seq Scan on compress_hyper_14_1195_chunk -> Custom Scan (ColumnarScan) on _hyper_13_493_chunk r_462 -> Seq Scan on compress_hyper_14_1196_chunk -> Custom Scan (ColumnarScan) on _hyper_13_494_chunk r_463 -> Seq Scan on compress_hyper_14_1197_chunk -> Custom Scan (ColumnarScan) on _hyper_13_495_chunk r_464 -> Seq Scan on compress_hyper_14_1198_chunk -> Custom Scan (ColumnarScan) on _hyper_13_496_chunk r_465 -> Seq Scan on compress_hyper_14_1199_chunk -> Custom Scan (ColumnarScan) on _hyper_13_497_chunk r_466 -> Seq Scan on compress_hyper_14_1200_chunk -> Custom Scan (ColumnarScan) on _hyper_13_498_chunk r_467 -> Seq Scan on compress_hyper_14_1201_chunk -> Custom Scan (ColumnarScan) on _hyper_13_499_chunk r_468 -> Seq Scan on compress_hyper_14_1202_chunk -> Custom Scan (ColumnarScan) on _hyper_13_500_chunk r_469 -> Seq Scan on compress_hyper_14_1203_chunk -> Custom Scan (ColumnarScan) on _hyper_13_501_chunk r_470 -> Seq Scan on compress_hyper_14_1204_chunk -> Custom Scan (ColumnarScan) on _hyper_13_502_chunk r_471 -> Seq Scan on compress_hyper_14_1205_chunk -> Custom Scan (ColumnarScan) on _hyper_13_503_chunk r_472 -> Seq Scan on compress_hyper_14_1206_chunk -> Custom Scan (ColumnarScan) on _hyper_13_504_chunk r_473 -> Seq Scan on compress_hyper_14_1207_chunk -> Custom Scan (ColumnarScan) on _hyper_13_505_chunk r_474 -> Seq Scan on compress_hyper_14_1208_chunk -> Custom Scan (ColumnarScan) on _hyper_13_506_chunk r_475 -> Seq Scan on compress_hyper_14_1209_chunk -> Custom Scan (ColumnarScan) on _hyper_13_507_chunk r_476 -> Seq Scan on compress_hyper_14_1210_chunk -> Custom Scan (ColumnarScan) on _hyper_13_508_chunk r_477 -> Seq Scan on compress_hyper_14_1211_chunk -> Custom Scan (ColumnarScan) on _hyper_13_509_chunk r_478 -> Seq Scan on compress_hyper_14_1212_chunk -> Custom Scan (ColumnarScan) on _hyper_13_510_chunk r_479 -> Seq Scan on compress_hyper_14_1213_chunk -> Custom Scan (ColumnarScan) on _hyper_13_511_chunk r_480 -> Seq Scan on compress_hyper_14_1214_chunk -> Custom Scan (ColumnarScan) on _hyper_13_512_chunk r_481 -> Seq Scan on compress_hyper_14_1215_chunk -> Custom Scan (ColumnarScan) on _hyper_13_513_chunk r_482 -> Seq Scan on compress_hyper_14_1216_chunk -> Custom Scan (ColumnarScan) on _hyper_13_514_chunk r_483 -> Seq Scan on compress_hyper_14_1217_chunk -> Custom Scan (ColumnarScan) on _hyper_13_515_chunk r_484 -> Seq Scan on compress_hyper_14_1218_chunk -> Custom Scan (ColumnarScan) on _hyper_13_516_chunk r_485 -> Seq Scan on compress_hyper_14_1219_chunk -> Custom Scan (ColumnarScan) on _hyper_13_517_chunk r_486 -> Seq Scan on compress_hyper_14_1220_chunk -> Custom Scan (ColumnarScan) on _hyper_13_518_chunk r_487 -> Seq Scan on compress_hyper_14_1221_chunk -> Custom Scan (ColumnarScan) on _hyper_13_519_chunk r_488 -> Seq Scan on compress_hyper_14_1222_chunk -> Custom Scan (ColumnarScan) on _hyper_13_520_chunk r_489 -> Seq Scan on compress_hyper_14_1223_chunk -> Custom Scan (ColumnarScan) on _hyper_13_521_chunk r_490 -> Seq Scan on compress_hyper_14_1224_chunk -> Custom Scan (ColumnarScan) on _hyper_13_522_chunk r_491 -> Seq Scan on compress_hyper_14_1225_chunk -> Custom Scan (ColumnarScan) on _hyper_13_523_chunk r_492 -> Seq Scan on compress_hyper_14_1226_chunk -> Custom Scan (ColumnarScan) on _hyper_13_524_chunk r_493 -> Seq Scan on compress_hyper_14_1227_chunk -> Custom Scan (ColumnarScan) on _hyper_13_525_chunk r_494 -> Seq Scan on compress_hyper_14_1228_chunk -> Custom Scan (ColumnarScan) on _hyper_13_526_chunk r_495 -> Seq Scan on compress_hyper_14_1229_chunk -> Custom Scan (ColumnarScan) on _hyper_13_527_chunk r_496 -> Seq Scan on compress_hyper_14_1230_chunk -> Custom Scan (ColumnarScan) on _hyper_13_528_chunk r_497 -> Seq Scan on compress_hyper_14_1231_chunk -> Custom Scan (ColumnarScan) on _hyper_13_529_chunk r_498 -> Seq Scan on compress_hyper_14_1232_chunk -> Custom Scan (ColumnarScan) on _hyper_13_530_chunk r_499 -> Seq Scan on compress_hyper_14_1233_chunk -> Custom Scan (ColumnarScan) on _hyper_13_531_chunk r_500 -> Seq Scan on compress_hyper_14_1234_chunk -> Custom Scan (ColumnarScan) on _hyper_13_532_chunk r_501 -> Seq Scan on compress_hyper_14_1235_chunk -> Custom Scan (ColumnarScan) on _hyper_13_533_chunk r_502 -> Seq Scan on compress_hyper_14_1236_chunk -> Custom Scan (ColumnarScan) on _hyper_13_534_chunk r_503 -> Seq Scan on compress_hyper_14_1237_chunk -> Custom Scan (ColumnarScan) on _hyper_13_535_chunk r_504 -> Seq Scan on compress_hyper_14_1238_chunk -> Custom Scan (ColumnarScan) on _hyper_13_536_chunk r_505 -> Seq Scan on compress_hyper_14_1239_chunk -> Custom Scan (ColumnarScan) on _hyper_13_537_chunk r_506 -> Seq Scan on compress_hyper_14_1240_chunk -> Custom Scan (ColumnarScan) on _hyper_13_538_chunk r_507 -> Seq Scan on compress_hyper_14_1241_chunk -> Custom Scan (ColumnarScan) on _hyper_13_539_chunk r_508 -> Seq Scan on compress_hyper_14_1242_chunk -> Custom Scan (ColumnarScan) on _hyper_13_540_chunk r_509 -> Seq Scan on compress_hyper_14_1243_chunk -> Custom Scan (ColumnarScan) on _hyper_13_541_chunk r_510 -> Seq Scan on compress_hyper_14_1244_chunk -> Custom Scan (ColumnarScan) on _hyper_13_542_chunk r_511 -> Seq Scan on compress_hyper_14_1245_chunk -> Custom Scan (ColumnarScan) on _hyper_13_543_chunk r_512 -> Seq Scan on compress_hyper_14_1246_chunk -> Custom Scan (ColumnarScan) on _hyper_13_544_chunk r_513 -> Seq Scan on compress_hyper_14_1247_chunk -> Custom Scan (ColumnarScan) on _hyper_13_545_chunk r_514 -> Seq Scan on compress_hyper_14_1248_chunk -> Custom Scan (ColumnarScan) on _hyper_13_546_chunk r_515 -> Seq Scan on compress_hyper_14_1249_chunk -> Custom Scan (ColumnarScan) on _hyper_13_547_chunk r_516 -> Seq Scan on compress_hyper_14_1250_chunk -> Custom Scan (ColumnarScan) on _hyper_13_548_chunk r_517 -> Seq Scan on compress_hyper_14_1251_chunk -> Custom Scan (ColumnarScan) on _hyper_13_549_chunk r_518 -> Seq Scan on compress_hyper_14_1252_chunk -> Custom Scan (ColumnarScan) on _hyper_13_550_chunk r_519 -> Seq Scan on compress_hyper_14_1253_chunk -> Custom Scan (ColumnarScan) on _hyper_13_551_chunk r_520 -> Seq Scan on compress_hyper_14_1254_chunk -> Custom Scan (ColumnarScan) on _hyper_13_552_chunk r_521 -> Seq Scan on compress_hyper_14_1255_chunk -> Custom Scan (ColumnarScan) on _hyper_13_553_chunk r_522 -> Seq Scan on compress_hyper_14_1256_chunk -> Custom Scan (ColumnarScan) on _hyper_13_554_chunk r_523 -> Seq Scan on compress_hyper_14_1257_chunk -> Custom Scan (ColumnarScan) on _hyper_13_555_chunk r_524 -> Seq Scan on compress_hyper_14_1258_chunk -> Custom Scan (ColumnarScan) on _hyper_13_556_chunk r_525 -> Seq Scan on compress_hyper_14_1259_chunk -> Custom Scan (ColumnarScan) on _hyper_13_557_chunk r_526 -> Seq Scan on compress_hyper_14_1260_chunk -> Custom Scan (ColumnarScan) on _hyper_13_558_chunk r_527 -> Seq Scan on compress_hyper_14_1261_chunk -> Custom Scan (ColumnarScan) on _hyper_13_559_chunk r_528 -> Seq Scan on compress_hyper_14_1262_chunk -> Custom Scan (ColumnarScan) on _hyper_13_560_chunk r_529 -> Seq Scan on compress_hyper_14_1263_chunk -> Custom Scan (ColumnarScan) on _hyper_13_561_chunk r_530 -> Seq Scan on compress_hyper_14_1264_chunk -> Custom Scan (ColumnarScan) on _hyper_13_562_chunk r_531 -> Seq Scan on compress_hyper_14_1265_chunk -> Custom Scan (ColumnarScan) on _hyper_13_563_chunk r_532 -> Seq Scan on compress_hyper_14_1266_chunk -> Custom Scan (ColumnarScan) on _hyper_13_564_chunk r_533 -> Seq Scan on compress_hyper_14_1267_chunk -> Custom Scan (ColumnarScan) on _hyper_13_565_chunk r_534 -> Seq Scan on compress_hyper_14_1268_chunk -> Custom Scan (ColumnarScan) on _hyper_13_566_chunk r_535 -> Seq Scan on compress_hyper_14_1269_chunk -> Custom Scan (ColumnarScan) on _hyper_13_567_chunk r_536 -> Seq Scan on compress_hyper_14_1270_chunk -> Custom Scan (ColumnarScan) on _hyper_13_568_chunk r_537 -> Seq Scan on compress_hyper_14_1271_chunk -> Custom Scan (ColumnarScan) on _hyper_13_569_chunk r_538 -> Seq Scan on compress_hyper_14_1272_chunk -> Custom Scan (ColumnarScan) on _hyper_13_570_chunk r_539 -> Seq Scan on compress_hyper_14_1273_chunk -> Custom Scan (ColumnarScan) on _hyper_13_571_chunk r_540 -> Seq Scan on compress_hyper_14_1274_chunk -> Custom Scan (ColumnarScan) on _hyper_13_572_chunk r_541 -> Seq Scan on compress_hyper_14_1275_chunk -> Custom Scan (ColumnarScan) on _hyper_13_573_chunk r_542 -> Seq Scan on compress_hyper_14_1276_chunk -> Custom Scan (ColumnarScan) on _hyper_13_574_chunk r_543 -> Seq Scan on compress_hyper_14_1277_chunk -> Custom Scan (ColumnarScan) on _hyper_13_575_chunk r_544 -> Seq Scan on compress_hyper_14_1278_chunk -> Custom Scan (ColumnarScan) on _hyper_13_576_chunk r_545 -> Seq Scan on compress_hyper_14_1279_chunk -> Custom Scan (ColumnarScan) on _hyper_13_577_chunk r_546 -> Seq Scan on compress_hyper_14_1280_chunk -> Custom Scan (ColumnarScan) on _hyper_13_578_chunk r_547 -> Seq Scan on compress_hyper_14_1281_chunk -> Custom Scan (ColumnarScan) on _hyper_13_579_chunk r_548 -> Seq Scan on compress_hyper_14_1282_chunk -> Custom Scan (ColumnarScan) on _hyper_13_580_chunk r_549 -> Seq Scan on compress_hyper_14_1283_chunk -> Custom Scan (ColumnarScan) on _hyper_13_581_chunk r_550 -> Seq Scan on compress_hyper_14_1284_chunk -> Custom Scan (ColumnarScan) on _hyper_13_582_chunk r_551 -> Seq Scan on compress_hyper_14_1285_chunk -> Custom Scan (ColumnarScan) on _hyper_13_583_chunk r_552 -> Seq Scan on compress_hyper_14_1286_chunk -> Custom Scan (ColumnarScan) on _hyper_13_584_chunk r_553 -> Seq Scan on compress_hyper_14_1287_chunk -> Custom Scan (ColumnarScan) on _hyper_13_585_chunk r_554 -> Seq Scan on compress_hyper_14_1288_chunk -> Custom Scan (ColumnarScan) on _hyper_13_586_chunk r_555 -> Seq Scan on compress_hyper_14_1289_chunk -> Custom Scan (ColumnarScan) on _hyper_13_587_chunk r_556 -> Seq Scan on compress_hyper_14_1290_chunk -> Custom Scan (ColumnarScan) on _hyper_13_588_chunk r_557 -> Seq Scan on compress_hyper_14_1291_chunk -> Custom Scan (ColumnarScan) on _hyper_13_589_chunk r_558 -> Seq Scan on compress_hyper_14_1292_chunk -> Custom Scan (ColumnarScan) on _hyper_13_590_chunk r_559 -> Seq Scan on compress_hyper_14_1293_chunk -> Custom Scan (ColumnarScan) on _hyper_13_591_chunk r_560 -> Seq Scan on compress_hyper_14_1294_chunk -> Custom Scan (ColumnarScan) on _hyper_13_592_chunk r_561 -> Seq Scan on compress_hyper_14_1295_chunk -> Custom Scan (ColumnarScan) on _hyper_13_593_chunk r_562 -> Seq Scan on compress_hyper_14_1296_chunk -> Custom Scan (ColumnarScan) on _hyper_13_594_chunk r_563 -> Seq Scan on compress_hyper_14_1297_chunk -> Custom Scan (ColumnarScan) on _hyper_13_595_chunk r_564 -> Seq Scan on compress_hyper_14_1298_chunk -> Custom Scan (ColumnarScan) on _hyper_13_596_chunk r_565 -> Seq Scan on compress_hyper_14_1299_chunk -> Custom Scan (ColumnarScan) on _hyper_13_597_chunk r_566 -> Seq Scan on compress_hyper_14_1300_chunk -> Custom Scan (ColumnarScan) on _hyper_13_598_chunk r_567 -> Seq Scan on compress_hyper_14_1301_chunk -> Custom Scan (ColumnarScan) on _hyper_13_599_chunk r_568 -> Seq Scan on compress_hyper_14_1302_chunk -> Custom Scan (ColumnarScan) on _hyper_13_600_chunk r_569 -> Seq Scan on compress_hyper_14_1303_chunk -> Custom Scan (ColumnarScan) on _hyper_13_601_chunk r_570 -> Seq Scan on compress_hyper_14_1304_chunk -> Custom Scan (ColumnarScan) on _hyper_13_602_chunk r_571 -> Seq Scan on compress_hyper_14_1305_chunk -> Custom Scan (ColumnarScan) on _hyper_13_603_chunk r_572 -> Seq Scan on compress_hyper_14_1306_chunk -> Custom Scan (ColumnarScan) on _hyper_13_604_chunk r_573 -> Seq Scan on compress_hyper_14_1307_chunk -> Custom Scan (ColumnarScan) on _hyper_13_605_chunk r_574 -> Seq Scan on compress_hyper_14_1308_chunk -> Custom Scan (ColumnarScan) on _hyper_13_606_chunk r_575 -> Seq Scan on compress_hyper_14_1309_chunk -> Custom Scan (ColumnarScan) on _hyper_13_607_chunk r_576 -> Seq Scan on compress_hyper_14_1310_chunk -> Custom Scan (ColumnarScan) on _hyper_13_608_chunk r_577 -> Seq Scan on compress_hyper_14_1311_chunk -> Custom Scan (ColumnarScan) on _hyper_13_609_chunk r_578 -> Seq Scan on compress_hyper_14_1312_chunk -> Custom Scan (ColumnarScan) on _hyper_13_610_chunk r_579 -> Seq Scan on compress_hyper_14_1313_chunk -> Custom Scan (ColumnarScan) on _hyper_13_611_chunk r_580 -> Seq Scan on compress_hyper_14_1314_chunk -> Custom Scan (ColumnarScan) on _hyper_13_612_chunk r_581 -> Seq Scan on compress_hyper_14_1315_chunk -> Custom Scan (ColumnarScan) on _hyper_13_613_chunk r_582 -> Seq Scan on compress_hyper_14_1316_chunk -> Custom Scan (ColumnarScan) on _hyper_13_614_chunk r_583 -> Seq Scan on compress_hyper_14_1317_chunk -> Custom Scan (ColumnarScan) on _hyper_13_615_chunk r_584 -> Seq Scan on compress_hyper_14_1318_chunk -> Custom Scan (ColumnarScan) on _hyper_13_616_chunk r_585 -> Seq Scan on compress_hyper_14_1319_chunk -> Custom Scan (ColumnarScan) on _hyper_13_617_chunk r_586 -> Seq Scan on compress_hyper_14_1320_chunk -> Custom Scan (ColumnarScan) on _hyper_13_618_chunk r_587 -> Seq Scan on compress_hyper_14_1321_chunk -> Custom Scan (ColumnarScan) on _hyper_13_619_chunk r_588 -> Seq Scan on compress_hyper_14_1322_chunk -> Custom Scan (ColumnarScan) on _hyper_13_620_chunk r_589 -> Seq Scan on compress_hyper_14_1323_chunk -> Custom Scan (ColumnarScan) on _hyper_13_621_chunk r_590 -> Seq Scan on compress_hyper_14_1324_chunk -> Custom Scan (ColumnarScan) on _hyper_13_622_chunk r_591 -> Seq Scan on compress_hyper_14_1325_chunk -> Custom Scan (ColumnarScan) on _hyper_13_623_chunk r_592 -> Seq Scan on compress_hyper_14_1326_chunk -> Custom Scan (ColumnarScan) on _hyper_13_624_chunk r_593 -> Seq Scan on compress_hyper_14_1327_chunk -> Custom Scan (ColumnarScan) on _hyper_13_625_chunk r_594 -> Seq Scan on compress_hyper_14_1328_chunk -> Custom Scan (ColumnarScan) on _hyper_13_626_chunk r_595 -> Seq Scan on compress_hyper_14_1329_chunk -> Custom Scan (ColumnarScan) on _hyper_13_627_chunk r_596 -> Seq Scan on compress_hyper_14_1330_chunk -> Custom Scan (ColumnarScan) on _hyper_13_628_chunk r_597 -> Seq Scan on compress_hyper_14_1331_chunk -> Custom Scan (ColumnarScan) on _hyper_13_629_chunk r_598 -> Seq Scan on compress_hyper_14_1332_chunk -> Custom Scan (ColumnarScan) on _hyper_13_630_chunk r_599 -> Seq Scan on compress_hyper_14_1333_chunk -> Custom Scan (ColumnarScan) on _hyper_13_631_chunk r_600 -> Seq Scan on compress_hyper_14_1334_chunk -> Custom Scan (ColumnarScan) on _hyper_13_632_chunk r_601 -> Seq Scan on compress_hyper_14_1335_chunk -> Custom Scan (ColumnarScan) on _hyper_13_633_chunk r_602 -> Seq Scan on compress_hyper_14_1336_chunk -> Custom Scan (ColumnarScan) on _hyper_13_634_chunk r_603 -> Seq Scan on compress_hyper_14_1337_chunk -> Custom Scan (ColumnarScan) on _hyper_13_635_chunk r_604 -> Seq Scan on compress_hyper_14_1338_chunk -> Custom Scan (ColumnarScan) on _hyper_13_636_chunk r_605 -> Seq Scan on compress_hyper_14_1339_chunk -> Custom Scan (ColumnarScan) on _hyper_13_637_chunk r_606 -> Seq Scan on compress_hyper_14_1340_chunk -> Custom Scan (ColumnarScan) on _hyper_13_638_chunk r_607 -> Seq Scan on compress_hyper_14_1341_chunk -> Custom Scan (ColumnarScan) on _hyper_13_639_chunk r_608 -> Seq Scan on compress_hyper_14_1342_chunk -> Custom Scan (ColumnarScan) on _hyper_13_640_chunk r_609 -> Seq Scan on compress_hyper_14_1343_chunk -> Custom Scan (ColumnarScan) on _hyper_13_641_chunk r_610 -> Seq Scan on compress_hyper_14_1344_chunk -> Custom Scan (ColumnarScan) on _hyper_13_642_chunk r_611 -> Seq Scan on compress_hyper_14_1345_chunk -> Custom Scan (ColumnarScan) on _hyper_13_643_chunk r_612 -> Seq Scan on compress_hyper_14_1346_chunk -> Custom Scan (ColumnarScan) on _hyper_13_644_chunk r_613 -> Seq Scan on compress_hyper_14_1347_chunk -> Custom Scan (ColumnarScan) on _hyper_13_645_chunk r_614 -> Seq Scan on compress_hyper_14_1348_chunk -> Custom Scan (ColumnarScan) on _hyper_13_646_chunk r_615 -> Seq Scan on compress_hyper_14_1349_chunk -> Custom Scan (ColumnarScan) on _hyper_13_647_chunk r_616 -> Seq Scan on compress_hyper_14_1350_chunk -> Custom Scan (ColumnarScan) on _hyper_13_648_chunk r_617 -> Seq Scan on compress_hyper_14_1351_chunk -> Custom Scan (ColumnarScan) on _hyper_13_649_chunk r_618 -> Seq Scan on compress_hyper_14_1352_chunk -> Custom Scan (ColumnarScan) on _hyper_13_650_chunk r_619 -> Seq Scan on compress_hyper_14_1353_chunk -> Custom Scan (ColumnarScan) on _hyper_13_651_chunk r_620 -> Seq Scan on compress_hyper_14_1354_chunk -> Custom Scan (ColumnarScan) on _hyper_13_652_chunk r_621 -> Seq Scan on compress_hyper_14_1355_chunk -> Custom Scan (ColumnarScan) on _hyper_13_653_chunk r_622 -> Seq Scan on compress_hyper_14_1356_chunk -> Custom Scan (ColumnarScan) on _hyper_13_654_chunk r_623 -> Seq Scan on compress_hyper_14_1357_chunk -> Custom Scan (ColumnarScan) on _hyper_13_655_chunk r_624 -> Seq Scan on compress_hyper_14_1358_chunk -> Custom Scan (ColumnarScan) on _hyper_13_656_chunk r_625 -> Seq Scan on compress_hyper_14_1359_chunk -> Custom Scan (ColumnarScan) on _hyper_13_657_chunk r_626 -> Seq Scan on compress_hyper_14_1360_chunk -> Custom Scan (ColumnarScan) on _hyper_13_658_chunk r_627 -> Seq Scan on compress_hyper_14_1361_chunk -> Custom Scan (ColumnarScan) on _hyper_13_659_chunk r_628 -> Seq Scan on compress_hyper_14_1362_chunk -> Custom Scan (ColumnarScan) on _hyper_13_660_chunk r_629 -> Seq Scan on compress_hyper_14_1363_chunk -> Custom Scan (ColumnarScan) on _hyper_13_661_chunk r_630 -> Seq Scan on compress_hyper_14_1364_chunk -> Custom Scan (ColumnarScan) on _hyper_13_662_chunk r_631 -> Seq Scan on compress_hyper_14_1365_chunk -> Custom Scan (ColumnarScan) on _hyper_13_663_chunk r_632 -> Seq Scan on compress_hyper_14_1366_chunk -> Custom Scan (ColumnarScan) on _hyper_13_664_chunk r_633 -> Seq Scan on compress_hyper_14_1367_chunk -> Custom Scan (ColumnarScan) on _hyper_13_665_chunk r_634 -> Seq Scan on compress_hyper_14_1368_chunk -> Custom Scan (ColumnarScan) on _hyper_13_666_chunk r_635 -> Seq Scan on compress_hyper_14_1369_chunk -> Custom Scan (ColumnarScan) on _hyper_13_667_chunk r_636 -> Seq Scan on compress_hyper_14_1370_chunk -> Custom Scan (ColumnarScan) on _hyper_13_668_chunk r_637 -> Seq Scan on compress_hyper_14_1371_chunk -> Custom Scan (ColumnarScan) on _hyper_13_669_chunk r_638 -> Seq Scan on compress_hyper_14_1372_chunk -> Custom Scan (ColumnarScan) on _hyper_13_670_chunk r_639 -> Seq Scan on compress_hyper_14_1373_chunk -> Custom Scan (ColumnarScan) on _hyper_13_671_chunk r_640 -> Seq Scan on compress_hyper_14_1374_chunk -> Custom Scan (ColumnarScan) on _hyper_13_672_chunk r_641 -> Seq Scan on compress_hyper_14_1375_chunk -> Custom Scan (ColumnarScan) on _hyper_13_673_chunk r_642 -> Seq Scan on compress_hyper_14_1376_chunk -> Custom Scan (ColumnarScan) on _hyper_13_674_chunk r_643 -> Seq Scan on compress_hyper_14_1377_chunk -> Custom Scan (ColumnarScan) on _hyper_13_675_chunk r_644 -> Seq Scan on compress_hyper_14_1378_chunk -> Custom Scan (ColumnarScan) on _hyper_13_676_chunk r_645 -> Seq Scan on compress_hyper_14_1379_chunk -> Custom Scan (ColumnarScan) on _hyper_13_677_chunk r_646 -> Seq Scan on compress_hyper_14_1380_chunk -> Custom Scan (ColumnarScan) on _hyper_13_678_chunk r_647 -> Seq Scan on compress_hyper_14_1381_chunk -> Custom Scan (ColumnarScan) on _hyper_13_679_chunk r_648 -> Seq Scan on compress_hyper_14_1382_chunk -> Custom Scan (ColumnarScan) on _hyper_13_680_chunk r_649 -> Seq Scan on compress_hyper_14_1383_chunk -> Custom Scan (ColumnarScan) on _hyper_13_681_chunk r_650 -> Seq Scan on compress_hyper_14_1384_chunk -> Custom Scan (ColumnarScan) on _hyper_13_682_chunk r_651 -> Seq Scan on compress_hyper_14_1385_chunk -> Custom Scan (ColumnarScan) on _hyper_13_683_chunk r_652 -> Seq Scan on compress_hyper_14_1386_chunk -> Custom Scan (ColumnarScan) on _hyper_13_684_chunk r_653 -> Seq Scan on compress_hyper_14_1387_chunk -> Custom Scan (ColumnarScan) on _hyper_13_685_chunk r_654 -> Seq Scan on compress_hyper_14_1388_chunk -> Custom Scan (ColumnarScan) on _hyper_13_686_chunk r_655 -> Seq Scan on compress_hyper_14_1389_chunk -> Custom Scan (ColumnarScan) on _hyper_13_687_chunk r_656 -> Seq Scan on compress_hyper_14_1390_chunk -> Custom Scan (ColumnarScan) on _hyper_13_688_chunk r_657 -> Seq Scan on compress_hyper_14_1391_chunk -> Custom Scan (ColumnarScan) on _hyper_13_689_chunk r_658 -> Seq Scan on compress_hyper_14_1392_chunk -> Custom Scan (ColumnarScan) on _hyper_13_690_chunk r_659 -> Seq Scan on compress_hyper_14_1393_chunk -> Custom Scan (ColumnarScan) on _hyper_13_691_chunk r_660 -> Seq Scan on compress_hyper_14_1394_chunk -> Custom Scan (ColumnarScan) on _hyper_13_692_chunk r_661 -> Seq Scan on compress_hyper_14_1395_chunk -> Custom Scan (ColumnarScan) on _hyper_13_693_chunk r_662 -> Seq Scan on compress_hyper_14_1396_chunk -> Custom Scan (ColumnarScan) on _hyper_13_694_chunk r_663 -> Seq Scan on compress_hyper_14_1397_chunk -> Custom Scan (ColumnarScan) on _hyper_13_695_chunk r_664 -> Seq Scan on compress_hyper_14_1398_chunk -> Custom Scan (ColumnarScan) on _hyper_13_696_chunk r_665 -> Seq Scan on compress_hyper_14_1399_chunk -> Custom Scan (ColumnarScan) on _hyper_13_697_chunk r_666 -> Seq Scan on compress_hyper_14_1400_chunk -> Custom Scan (ColumnarScan) on _hyper_13_698_chunk r_667 -> Seq Scan on compress_hyper_14_1401_chunk -> Custom Scan (ColumnarScan) on _hyper_13_699_chunk r_668 -> Seq Scan on compress_hyper_14_1402_chunk -> Custom Scan (ColumnarScan) on _hyper_13_700_chunk r_669 -> Seq Scan on compress_hyper_14_1403_chunk -> Custom Scan (ColumnarScan) on _hyper_13_701_chunk r_670 -> Seq Scan on compress_hyper_14_1404_chunk -> Custom Scan (ColumnarScan) on _hyper_13_702_chunk r_671 -> Seq Scan on compress_hyper_14_1405_chunk -> Custom Scan (ColumnarScan) on _hyper_13_703_chunk r_672 -> Seq Scan on compress_hyper_14_1406_chunk -> Custom Scan (ColumnarScan) on _hyper_13_704_chunk r_673 -> Seq Scan on compress_hyper_14_1407_chunk -> Custom Scan (ColumnarScan) on _hyper_13_705_chunk r_674 -> Seq Scan on compress_hyper_14_1408_chunk -> Custom Scan (ColumnarScan) on _hyper_13_706_chunk r_675 -> Seq Scan on compress_hyper_14_1409_chunk -> Custom Scan (ColumnarScan) on _hyper_13_707_chunk r_676 -> Seq Scan on compress_hyper_14_1410_chunk -> Custom Scan (ColumnarScan) on _hyper_13_708_chunk r_677 -> Seq Scan on compress_hyper_14_1411_chunk -> Custom Scan (ColumnarScan) on _hyper_13_709_chunk r_678 -> Seq Scan on compress_hyper_14_1412_chunk -> Custom Scan (ColumnarScan) on _hyper_13_710_chunk r_679 -> Seq Scan on compress_hyper_14_1413_chunk -> Custom Scan (ColumnarScan) on _hyper_13_711_chunk r_680 -> Seq Scan on compress_hyper_14_1414_chunk -> Custom Scan (ColumnarScan) on _hyper_13_712_chunk r_681 -> Seq Scan on compress_hyper_14_1415_chunk -> Custom Scan (ColumnarScan) on _hyper_13_713_chunk r_682 -> Seq Scan on compress_hyper_14_1416_chunk -> Custom Scan (ColumnarScan) on _hyper_13_714_chunk r_683 -> Seq Scan on compress_hyper_14_1417_chunk -> Custom Scan (ColumnarScan) on _hyper_13_715_chunk r_684 -> Seq Scan on compress_hyper_14_1418_chunk -> Custom Scan (ColumnarScan) on _hyper_13_716_chunk r_685 -> Seq Scan on compress_hyper_14_1419_chunk -> Custom Scan (ColumnarScan) on _hyper_13_717_chunk r_686 -> Seq Scan on compress_hyper_14_1420_chunk -> Custom Scan (ColumnarScan) on _hyper_13_718_chunk r_687 -> Seq Scan on compress_hyper_14_1421_chunk -> Custom Scan (ColumnarScan) on _hyper_13_719_chunk r_688 -> Seq Scan on compress_hyper_14_1422_chunk -> Custom Scan (ColumnarScan) on _hyper_13_720_chunk r_689 -> Seq Scan on compress_hyper_14_1423_chunk -> Custom Scan (ColumnarScan) on _hyper_13_721_chunk r_690 -> Seq Scan on compress_hyper_14_1424_chunk -> Custom Scan (ColumnarScan) on _hyper_13_722_chunk r_691 -> Seq Scan on compress_hyper_14_1425_chunk -> Custom Scan (ColumnarScan) on _hyper_13_723_chunk r_692 -> Seq Scan on compress_hyper_14_1426_chunk -> Custom Scan (ColumnarScan) on _hyper_13_724_chunk r_693 -> Seq Scan on compress_hyper_14_1427_chunk -> Custom Scan (ColumnarScan) on _hyper_13_725_chunk r_694 -> Seq Scan on compress_hyper_14_1428_chunk -> Custom Scan (ColumnarScan) on _hyper_13_726_chunk r_695 -> Seq Scan on compress_hyper_14_1429_chunk -> Custom Scan (ColumnarScan) on _hyper_13_727_chunk r_696 -> Seq Scan on compress_hyper_14_1430_chunk -> Custom Scan (ColumnarScan) on _hyper_13_728_chunk r_697 -> Seq Scan on compress_hyper_14_1431_chunk -> Custom Scan (ColumnarScan) on _hyper_13_729_chunk r_698 -> Seq Scan on compress_hyper_14_1432_chunk -> Custom Scan (ColumnarScan) on _hyper_13_730_chunk r_699 -> Seq Scan on compress_hyper_14_1433_chunk -> Custom Scan (ColumnarScan) on _hyper_13_731_chunk r_700 -> Seq Scan on compress_hyper_14_1434_chunk -> Custom Scan (ColumnarScan) on _hyper_13_732_chunk r_701 -> Seq Scan on compress_hyper_14_1435_chunk -> Custom Scan (ColumnarScan) on _hyper_13_733_chunk r_702 -> Seq Scan on compress_hyper_14_1436_chunk -> Custom Scan (ColumnarScan) on _hyper_13_734_chunk r_703 -> Seq Scan on compress_hyper_14_1437_chunk -> Hash -> Seq Scan on tags t -- run query with parallel enabled to ensure nothing is preventing parallel execution -- this is just a sanity check, the result queries dont run with parallel disabled SET max_parallel_workers_per_gather TO 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SET min_parallel_table_scan_size TO '0'; EXPLAIN (buffers off, costs off) SELECT * FROM metrics ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 3 -> Sort Sort Key: metrics."time", metrics.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT time_bucket('10 minutes', time) bucket, avg(v0) avg_v0 FROM metrics GROUP BY bucket; --- QUERY PLAN --- Finalize HashAggregate Group Key: (time_bucket('@ 10 mins'::interval, metrics."time")) -> Gather Workers Planned: 3 -> Parallel Append -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_2_chunk."time") -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: metrics_space."time", metrics_space.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk -> Parallel Seq Scan on compress_hyper_6_17_chunk -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk -> Parallel Seq Scan on compress_hyper_6_19_chunk -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk -> Parallel Seq Scan on compress_hyper_6_20_chunk -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk -> Parallel Seq Scan on compress_hyper_6_18_chunk -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk -> Parallel Seq Scan on compress_hyper_6_21_chunk -> Parallel Seq Scan on _hyper_2_8_chunk -> Parallel Seq Scan on _hyper_2_7_chunk -> Parallel Seq Scan on _hyper_2_9_chunk -> Parallel Seq Scan on _hyper_2_12_chunk RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; SET enable_seqscan TO false; -- should order compressed chunks using index -- (we only EXPLAIN here b/c the resulting order is too inconsistent) EXPLAIN (buffers off, costs off) SELECT * FROM metrics WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics.device_id -> Sort Sort Key: _hyper_1_2_chunk.device_id -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics_space.device_id -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) SET enable_seqscan TO true; -- diff compressed and uncompressed results :DIFF_CMD -- check hypertable detection in views CREATE VIEW ht_view AS SELECT *, 0 AS res FROM metrics UNION ALL SELECT *, 1 AS res FROM metrics; CREATE FUNCTION ht_func() RETURNS SETOF metrics LANGUAGE SQL STABLE AS $sql$ SELECT time, device_id, device_id_peer, v0, v1, v2, v3 FROM ht_view WHERE res = 0; $sql$; -- should have decompresschunk node :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) \c SET enable_incremental_sort TO off; -- plan should be identical to previous plan in fresh session :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- repro for core dump related to total_table_pages setting that get -- adjusted during decompress path. CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE motion_table( id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass) , datalogger_id bigint , vessel_id bigint , bus_id smallint , src_id smallint , dataloggertime timestamp with time zone , interval_s real ); CREATE INDEX motion_table_t2_datalogger_id_idx on motion_table (datalogger_id); CREATE INDEX motion_table_t2_dataloggertime_idx on motion_table(dataloggertime DESC); CREATE INDEX motion_table_t2_vessel_id_idx on motion_table(vessel_id); SELECT create_hypertable( 'motion_table', 'dataloggertime', chunk_time_interval=> '7 days'::interval); create_hypertable ---------------------------- (15,public,motion_table,t) --- do not modify the data. We need atleast this volume to reproduce issues with pages/tuple counts etc. --- INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), random() , random() , generate_series( '2020-01-02 10:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), 2, 3, generate_series( '2020-01-10 8:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; ALTER TABLE motion_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'vessel_id, datalogger_id, bus_id, src_id' , timescaledb.compress_orderby = 'dataloggertime' ); --have 2 chunks -- SELECT COUNT(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table'; count ------- 2 -- compress only the first one --- SELECT compress_chunk( chunk_table) FROM ( SELECT chunk_schema || '.' || chunk_name as chunk_table FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table' ORDER BY range_start limit 1 ) q; compress_chunk -------------------------------------------- _timescaledb_internal._hyper_15_1438_chunk --call to decompress chunk on 1 of the chunks SELECT count(*) from motion_table; count ------- 11642 --END of test for page settings CREATE TABLE repro(time timestamptz NOT NULL, device_id text, room_id text NOT NULL, score_type int NOT NULL, algorithm_version text NOT NULL, adjusted_score float NOT NULL); SELECT create_hypertable('repro','time'); create_hypertable --------------------- (17,public,repro,t) ALTER TABLE repro SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, room_id, score_type, algorithm_version', timescaledb.compress_orderby='"time" DESC' ); SELECT _timescaledb_functions.create_chunk('repro','{"time": [1717632000000000,1718236800000000]}'); create_chunk ------------------------------------------------------------------------------------------------------------- (1441,17,_timescaledb_internal,_hyper_17_1441_chunk,r,"{""time"": [1717632000000000, 1718236800000000]}",t) select compress_chunk(show_chunks('repro')); compress_chunk -------------------------------------------- _timescaledb_internal._hyper_17_1441_chunk select from repro where room_id = 'foo' order by device_id, algorithm_version, score_type, time desc; -- ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression-18.out�������������������������������0000664�0000000�0000000�00002327145�15100345067�0025725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset SET work_mem TO '50MB'; SET enable_incremental_sort TO off; SET timezone TO 'America/Los_Angeles'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; CREATE TABLE metrics ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable ('metrics', 'time'); create_hypertable ---------------------- (1,public,metrics,t) ALTER TABLE metrics DROP COLUMN filler_1; \set INTERVAL 30m INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id - 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('metrics_space', 'time', 'device_id', 3); create_hypertable ---------------------------- (2,public,metrics_space,t) ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics_space; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none -- compress first and last chunk on the hypertable ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics') x) t where n in (1, 3) ; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk VACUUM ANALYZE metrics; -- compress some chunks on space partitioned hypertable -- we compress all chunks of first time slice, none of second, and 2 of the last time slice ALTER TABLE metrics_space SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics_space') x) t where n in (1, 2, 3, 7, 8) ; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_2_4_chunk _timescaledb_internal._hyper_2_5_chunk _timescaledb_internal._hyper_2_6_chunk _timescaledb_internal._hyper_2_10_chunk _timescaledb_internal._hyper_2_11_chunk SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics' \gset SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_SPACE_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics_space' \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Index created using query saved in variable used because there was -- no standard way to create an index on a compressed table. -- Once a standard way exists, modify this test to use that method. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE INDEX ON metrics_space (device_id, device_id_peer, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id, device_id_peer DESC, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id DESC, device_id_peer DESC, v0, v1 DESC, time); VACUUM ANALYZE metrics_space; SET enable_incremental_sort TO off; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; -- get explain for queries on hypertable with compression \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=5.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 5 -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Result (actual rows=3456.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=3456.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=1440.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Sort (actual rows=1344.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=1344.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2016 -> Sort (actual rows=672.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=672.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time", metrics.device_id Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3600 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Sort (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.v3 > '10'::double precision) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1680 Batches Removed by Filter: 5 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 5 -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1440.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 5 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 3) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3595 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=30.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3570 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=35.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 3565 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3570.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 30 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3565.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 35 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (v0 < 1) Rows Removed by Filter: 2688 -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < 1) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 5 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) Filter: (v0 < device_id) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_1 < device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v1 = device_id) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= device_id) AND (_ts_meta_max_2 >= device_id)) Rows Removed by Filter: 5 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3600 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 3360 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=1) Filter: (v0 = v1) Rows Removed by Filter: 1680 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 -> Custom Scan (ChunkAppend) on public.metrics (actual rows=10.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=713.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Vectorized Filter: (_hyper_1_1_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: ((compress_hyper_5_15_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_15_chunk.device_id = 1)) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (never executed) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Index Cond: (_hyper_1_2_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_1_2_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (never executed) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (never executed) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: ((compress_hyper_5_16_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_5_16_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3572.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 28 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 0 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC, metrics.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id -> Seq Scan on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics.device_id, metrics."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk.device_id, _hyper_1_1_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk."time" DESC Sort Method: top-N heapsort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Order: metrics."time", metrics.device_id Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time" -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC, _hyper_1_2_chunk."time" Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk."time" Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk."time" Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics.device_id, metrics.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer -> Sort (actual rows=100.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Sort Method: top-N heapsort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0 -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC -> Sort (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Sort Key: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Sort Key: compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk._ts_meta_min_2 DESC, compress_hyper_5_16_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1 DESC, metrics."time", metrics.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1 DESC, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics.device_id DESC, metrics.device_id_peer DESC, metrics.v0, metrics.v1, metrics."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=2235.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Vectorized Filter: (_hyper_1_3_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 1125 -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics (actual rows=3915.00 loops=1) Order: metrics."time", metrics.device_id Chunks excluded during startup: 1 -> Sort (actual rows=2235.00 loops=1) Sort Key: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=2235.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_15_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Partial GroupAggregate (actual rows=5.00 loops=1) Group Key: _hyper_1_2_chunk.device_id -> Sort (actual rows=3360.00 loops=1) Sort Key: _hyper_1_2_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_5_16_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=8640.00 loops=1) Order: metrics."time" -> Sort (actual rows=3600.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Sort (actual rows=1680.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics."time" = metrics_1."time") -> Custom Scan (ChunkAppend) on metrics (actual rows=1728.00 loops=1) Order: metrics."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=1728.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_1_3_chunk_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Order: metrics."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics metrics_1 (actual rows=5.00 loops=1) Order: metrics_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_1_1_chunk_1."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk _hyper_1_1_chunk_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk _hyper_1_2_chunk_1 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk _hyper_1_3_chunk_1 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Sort Key: _hyper_1_1_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Sort Key: _hyper_1_3_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) Rows Removed by Filter: 2688 -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=3600.00 loops=1) Output: _hyper_1_1_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 -> Index Only Scan using _hyper_1_2_chunk_tmp_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=3360.00 loops=1) Output: _hyper_1_2_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=1680.00 loops=1) Output: _hyper_1_3_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=5.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics."time", metrics.device_id, metrics.device_id_peer, metrics.v0, metrics.v1, metrics.v2, metrics.v3 Sort Key: metrics."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk."time", _hyper_1_1_chunk.device_id, _hyper_1_1_chunk.device_id_peer, _hyper_1_1_chunk.v0, _hyper_1_1_chunk.v1, _hyper_1_1_chunk.v2, _hyper_1_1_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk."time", _hyper_1_2_chunk.device_id, _hyper_1_2_chunk.device_id_peer, _hyper_1_2_chunk.v0, _hyper_1_2_chunk.v1, _hyper_1_2_chunk.v2, _hyper_1_2_chunk.v3 Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk."time", _hyper_1_3_chunk.device_id, _hyper_1_3_chunk.device_id_peer, _hyper_1_3_chunk.v0, _hyper_1_3_chunk.v1, _hyper_1_3_chunk.v2, _hyper_1_3_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id_peer = 1) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id_peer = 1) Rows Removed by Filter: 5 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = 1) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id_peer = 1) Rows Removed by Filter: 5 --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=0.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 5 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=0.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3360 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=0.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=0.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 5 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1440.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=1344.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2016 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=672.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=2.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.device_id_peer -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_15_chunk Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Index Cond: (compress_hyper_5_15_chunk.device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.device_id_peer -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_5_16_chunk Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Index Cond: (compress_hyper_5_16_chunk.device_id = ANY ('{1,2}'::integer[])) RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=720.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = 1) Rows Removed by Filter: 4 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=672.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = 1) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=336.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = 1) Rows Removed by Filter: 4 :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk (actual rows=1440.00 loops=1) Output: _hyper_1_1_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_15_chunk (actual rows=2.00 loops=1) Output: compress_hyper_5_15_chunk._ts_meta_count, compress_hyper_5_15_chunk.device_id, compress_hyper_5_15_chunk.device_id_peer, compress_hyper_5_15_chunk._ts_meta_min_3, compress_hyper_5_15_chunk._ts_meta_max_3, compress_hyper_5_15_chunk."time", compress_hyper_5_15_chunk._ts_meta_min_1, compress_hyper_5_15_chunk._ts_meta_max_1, compress_hyper_5_15_chunk.v0, compress_hyper_5_15_chunk._ts_meta_min_2, compress_hyper_5_15_chunk._ts_meta_max_2, compress_hyper_5_15_chunk.v1, compress_hyper_5_15_chunk.v2, compress_hyper_5_15_chunk.v3 Filter: (compress_hyper_5_15_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Seq Scan on _timescaledb_internal._hyper_1_2_chunk (actual rows=1344.00 loops=1) Output: _hyper_1_2_chunk.device_id_peer Filter: (_hyper_1_2_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2016 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk (actual rows=672.00 loops=1) Output: _hyper_1_3_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_5_16_chunk (actual rows=2.00 loops=1) Output: compress_hyper_5_16_chunk._ts_meta_count, compress_hyper_5_16_chunk.device_id, compress_hyper_5_16_chunk.device_id_peer, compress_hyper_5_16_chunk._ts_meta_min_3, compress_hyper_5_16_chunk._ts_meta_max_3, compress_hyper_5_16_chunk."time", compress_hyper_5_16_chunk._ts_meta_min_1, compress_hyper_5_16_chunk._ts_meta_max_1, compress_hyper_5_16_chunk.v0, compress_hyper_5_16_chunk._ts_meta_min_2, compress_hyper_5_16_chunk._ts_meta_max_2, compress_hyper_5_16_chunk.v1, compress_hyper_5_16_chunk.v2, compress_hyper_5_16_chunk.v3 Filter: (compress_hyper_5_16_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=10.00 loops=1) Order: metrics."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_1_3_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Seq Scan on compress_hyper_5_15_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m2_2."time", m2_2.device_id -> Seq Scan on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time", m2_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 2 -> Sort (actual rows=1.00 loops=1) Sort Key: m3_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m3_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 4 :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) Filter: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) Filter: (device_id = 2) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 38 -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Sort (actual rows=10.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Sort (never executed) Sort Key: m1_2."time", m1_2.device_id -> Seq Scan on _hyper_1_2_chunk m1_2 (never executed) -> Sort (never executed) Sort Key: m1_3."time", m1_3.device_id -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) -> Materialize (actual rows=48.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=11.00 loops=1) Order: m2."time" -> Sort (actual rows=11.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m2_2 (never executed) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=672.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2688 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 4 :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m2_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk compress_hyper_5_15_chunk_1 (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m2_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m2_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk compress_hyper_5_16_chunk_1 (actual rows=5.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.59 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=0.59 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.59 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=0.59 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.59 loops=32) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=0.59 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_5_16_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) Rows Removed by Filter: 1 EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=5.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=5.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 3 -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; --- QUERY PLAN --- Result (actual rows=3456.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=3456.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=1440.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Merge Append (actual rows=1344.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=672.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=672.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Merge Append (actual rows=672.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=1728.00 loops=1) Sort Key: metrics_space.v1 Sort Method: quicksort -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics_space (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time", metrics_space.device_id Startup Exclusion: false Runtime Exclusion: false -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Vectorized Filter: (_hyper_2_5_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2160 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Vectorized Filter: (_hyper_2_6_chunk.v3 > '10'::double precision) Rows Removed by Filter: 720 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk.v3 > '10'::double precision) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk.v3 > '10'::double precision) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 Batches Removed by Filter: 1 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk.v3 > '10'::double precision) Rows Removed by Filter: 1008 Batches Removed by Filter: 3 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Sort (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk.v3 > '10'::double precision) Rows Removed by Filter: 336 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id IS NOT NULL) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id IS NOT NULL) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (never executed) Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (device_id = device_id_peer) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (device_id_peer < device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id_peer < device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id_peer < device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id_peer < device_id) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = 3) -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) Rows Removed by Filter: 3 -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (never executed) Index Cond: (device_id = length("substring"(version(), 1, 3))) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (never executed) Filter: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2157 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 719 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=18.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2142 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=6.00 loops=1) Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 714 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=21.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 2139 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=7.00 loops=1) Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 713 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2142.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 18 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=714.00 loops=1) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 6 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < 1) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=0.00 loops=1) Index Cond: (v0 < 1) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_min_1 < device_id) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v0 < device_id) Rows Removed by Filter: 336 :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > device_id) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (device_id < v0) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (device_id < v0) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (device_id < v0) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_max_1 > device_id) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (device_id < v0) :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_2 <= (device_id)::double precision) AND (_ts_meta_max_2 >= (device_id)::double precision)) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: (v1 = (device_id)::double precision) Rows Removed by Filter: 336 --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2160 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 2016 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 672 -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 1008 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=0.00 loops=1) Filter: ((v0)::double precision = v1) Rows Removed by Filter: 336 --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 -> Custom Scan (ChunkAppend) on public.metrics_space (actual rows=10.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time" Startup Exclusion: false Runtime Exclusion: false -> Sort (actual rows=10.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=713.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Vectorized Filter: (_hyper_2_4_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Rows Removed by Filter: 7 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: ((compress_hyper_6_17_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_17_chunk.device_id = 1)) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (never executed) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (never executed) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (never executed) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: ((compress_hyper_6_20_chunk._ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_6_20_chunk.device_id = 1)) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=9.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2139.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 21 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=713.00 loops=1) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) Rows Removed by Filter: 7 -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_max_3 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_min_3 < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) Filter: ("time" < now()) -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) Filter: ("time" < now()) -> Merge Append (never executed) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (_ts_meta_min_3 < now()) -> Sort (never executed) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id -> Seq Scan on _hyper_2_12_chunk (never executed) Filter: ("time" < now()) -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (never executed) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (never executed) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC, metrics_space.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_12_chunk."time" DESC, _hyper_2_12_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_2_11_chunk."time" DESC, _hyper_2_11_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC, _hyper_2_10_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_9_chunk."time" DESC, _hyper_2_9_chunk.device_id -> Seq Scan on _hyper_2_9_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_8_chunk."time" DESC, _hyper_2_8_chunk.device_id -> Seq Scan on _hyper_2_8_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_7_chunk."time" DESC, _hyper_2_7_chunk.device_id -> Seq Scan on _hyper_2_7_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC, metrics_space.device_id -> Sort (never executed) Sort Key: _hyper_2_6_chunk."time" DESC, _hyper_2_6_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (never executed) -> Seq Scan on compress_hyper_6_19_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_5_chunk."time" DESC, _hyper_2_5_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (never executed) -> Seq Scan on compress_hyper_6_18_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC, _hyper_2_4_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_4_chunk.device_id, _hyper_2_4_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_5_chunk.device_id, _hyper_2_5_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_6_chunk.device_id, _hyper_2_6_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=1.00 loops=1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk (actual rows=1.00 loops=1) -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on public.metrics_space (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Order: metrics_space."time", metrics_space.device_id Startup Exclusion: false Runtime Exclusion: false -> Merge Append (actual rows=2235.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Sort (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Sort (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk."time" Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk."time" Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk."time" Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk."time" Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk."time" Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk."time" Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) Output: metrics_space.device_id, metrics_space.device_id_peer -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=100.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=1.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=1.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=1.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=1.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; --- QUERY PLAN --- Merge Append (actual rows=3915.00 loops=1) Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1 Index Cond: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1 Index Cond: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_t on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1 Index Cond: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Sort Key: compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk._ts_meta_min_2 DESC, compress_hyper_6_20_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Sort (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Sort Key: compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk._ts_meta_min_2 DESC, compress_hyper_6_21_chunk._ts_meta_max_2 DESC Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v1_ on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1 Index Cond: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time", metrics_space.v3 Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1 DESC, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; --- QUERY PLAN --- Sort (actual rows=3915.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space.device_id DESC, metrics_space.device_id_peer DESC, metrics_space.v0, metrics_space.v1, metrics_space."time" Sort Method: quicksort -> Append (actual rows=3915.00 loops=1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=447.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Seq Scan on _timescaledb_internal._hyper_2_8_chunk (actual rows=1341.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Filter: (_hyper_2_8_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Seq Scan on _timescaledb_internal._hyper_2_9_chunk (actual rows=447.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Filter: (_hyper_2_9_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Vectorized Filter: (_hyper_2_10_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Vectorized Filter: (_hyper_2_11_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk._ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Filter: (_hyper_2_12_chunk."time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=3915.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=2235.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_7_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Sort (actual rows=1341.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 675 -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_9_chunk (actual rows=447.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) Rows Removed by Filter: 225 -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; --- QUERY PLAN --- Custom Scan (ChunkAppend) on metrics_space (actual rows=3915.00 loops=1) Order: metrics_space."time", metrics_space.device_id -> Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 3 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) Rows Removed by Filter: 1 -> Merge Append (actual rows=2235.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1341.00 loops=1) Sort Key: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=1341.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=447.00 loops=1) Sort Key: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id Sort Method: quicksort -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=447.00 loops=1) Index Cond: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time", metrics_space.device_id -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) Vectorized Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_max_3 > ('2000-01-08'::cstring)::timestamp with time zone) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id Sort Method: quicksort -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) Filter: ("time" > ('2000-01-08'::cstring)::timestamp with time zone) -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=9.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- WindowAgg (actual rows=5.00 loops=1) -> Finalize GroupAggregate (actual rows=5.00 loops=1) Group Key: metrics_space.device_id -> Merge Append (actual rows=15.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_17_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_18_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_19_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_7_chunk.device_id -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Partial GroupAggregate (actual rows=3.00 loops=1) Group Key: _hyper_2_8_chunk.device_id -> Index Only Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_9_chunk.device_id -> Index Only Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_6_20_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_6_21_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Partial GroupAggregate (actual rows=1.00 loops=1) Group Key: _hyper_2_12_chunk.device_id -> Index Only Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=8640.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=8640.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=8640.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=3600.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=2160.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_6_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (actual rows=3360.00 loops=1) Sort Key: metrics_space."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Merge Append (actual rows=1680.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=1008.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk (actual rows=336.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=1728.00 loops=1) Merge Cond: (metrics_space."time" = metrics_space_1."time") -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1728.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_11_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Materialize (actual rows=1728.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=1728.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=720.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=336.00 loops=1) Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; --- QUERY PLAN --- Nested Loop (actual rows=25.00 loops=1) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Order: metrics_space."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_4_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_10_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=5.00 loops=5) -> Limit (actual rows=5.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space metrics_space_1 (actual rows=5.00 loops=1) Order: metrics_space_1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_2_5_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: _hyper_2_11_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk (actual rows=672.00 loops=1) Filter: (device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 EXECUTE prep; count ------- 1728 DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: metrics_space."time" -> Sort (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Sort Key: _hyper_2_4_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Filter: (_hyper_2_7_chunk.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Sort Key: _hyper_2_10_chunk."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Merge Append (actual rows=1728.00 loops=1) Sort Key: test_table."time" -> Sort (actual rows=720.00 loops=1) Output: ((test_table_1.*)::metrics_space), test_table_1.device_id, test_table_1."time" Sort Key: test_table_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk test_table_1 (actual rows=720.00 loops=1) Output: test_table_1.*, test_table_1.device_id, test_table_1."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _timescaledb_internal._hyper_2_7_chunk test_table_2 (actual rows=672.00 loops=1) Output: test_table_2.*, test_table_2.device_id, test_table_2."time" Filter: (test_table_2.device_id = 1) -> Sort (actual rows=336.00 loops=1) Output: ((test_table_3.*)::metrics_space), test_table_3.device_id, test_table_3."time" Sort Key: test_table_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk test_table_3 (actual rows=336.00 loops=1) Output: test_table_3.*, test_table_3.device_id, test_table_3."time" Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Finalize Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3.00 loops=1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = 1) -> Partial Aggregate (actual rows=1.00 loops=1) Output: PARTIAL count(*) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Index Cond: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (VectorAgg) (actual rows=1.00 loops=1) Output: (PARTIAL count(*)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = 1) -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; --- QUERY PLAN --- Merge Append (actual rows=8640.00 loops=1) Sort Key: metrics_space.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=2160.00 loops=1) Output: _hyper_2_5_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=720.00 loops=1) Output: _hyper_2_6_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 -> Index Only Scan using _hyper_2_7_chunk_tmp_idx on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id -> Index Only Scan using _hyper_2_8_chunk_tmp_idx on _timescaledb_internal._hyper_2_8_chunk (actual rows=2016.00 loops=1) Output: _hyper_2_8_chunk.device_id -> Index Only Scan using _hyper_2_9_chunk_tmp_idx on _timescaledb_internal._hyper_2_9_chunk (actual rows=672.00 loops=1) Output: _hyper_2_9_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=1008.00 loops=1) Output: _hyper_2_11_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=3.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 -> Index Only Scan using _hyper_2_12_chunk_tmp_idx on _timescaledb_internal._hyper_2_12_chunk (actual rows=336.00 loops=1) Output: _hyper_2_12_chunk.device_id DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Output: metrics_space."time", metrics_space.device_id, metrics_space.device_id_peer, metrics_space.v0, metrics_space.v1, metrics_space.v2, metrics_space.v3 Sort Key: metrics_space."time" Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk."time", _hyper_2_4_chunk.device_id, _hyper_2_4_chunk.device_id_peer, _hyper_2_4_chunk.v0, _hyper_2_4_chunk.v1, _hyper_2_4_chunk.v2, _hyper_2_4_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk."time", _hyper_2_5_chunk.device_id, _hyper_2_5_chunk.device_id_peer, _hyper_2_5_chunk.v0, _hyper_2_5_chunk.v1, _hyper_2_5_chunk.v2, _hyper_2_5_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk."time", _hyper_2_6_chunk.device_id, _hyper_2_6_chunk.device_id_peer, _hyper_2_6_chunk.v0, _hyper_2_6_chunk.v1, _hyper_2_6_chunk.v2, _hyper_2_6_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk."time", _hyper_2_7_chunk.device_id, _hyper_2_7_chunk.device_id_peer, _hyper_2_7_chunk.v0, _hyper_2_7_chunk.v1, _hyper_2_7_chunk.v2, _hyper_2_7_chunk.v3 Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk."time", _hyper_2_8_chunk.device_id, _hyper_2_8_chunk.device_id_peer, _hyper_2_8_chunk.v0, _hyper_2_8_chunk.v1, _hyper_2_8_chunk.v2, _hyper_2_8_chunk.v3 Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk."time", _hyper_2_9_chunk.device_id, _hyper_2_9_chunk.device_id_peer, _hyper_2_9_chunk.v0, _hyper_2_9_chunk.v1, _hyper_2_9_chunk.v2, _hyper_2_9_chunk.v3 Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk."time", _hyper_2_10_chunk.device_id, _hyper_2_10_chunk.device_id_peer, _hyper_2_10_chunk.v0, _hyper_2_10_chunk.v1, _hyper_2_10_chunk.v2, _hyper_2_10_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk."time", _hyper_2_11_chunk.device_id, _hyper_2_11_chunk.device_id_peer, _hyper_2_11_chunk.v0, _hyper_2_11_chunk.v1, _hyper_2_11_chunk.v2, _hyper_2_11_chunk.v3 Bulk Decompression: true -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk."time", _hyper_2_12_chunk.device_id, _hyper_2_12_chunk.device_id_peer, _hyper_2_12_chunk.v0, _hyper_2_12_chunk.v1, _hyper_2_12_chunk.v2, _hyper_2_12_chunk.v3 Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Index Cond: (compress_hyper_6_19_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Filter: (compress_hyper_6_19_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = 1) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id_peer = 1) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id_peer = 1) Rows Removed by Filter: 3 -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk.device_id_peer = 1) --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=0.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=0.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_6_chunk (actual rows=0.00 loops=1) Output: _hyper_2_6_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_19_chunk._ts_meta_count, compress_hyper_6_19_chunk.device_id, compress_hyper_6_19_chunk.device_id_peer, compress_hyper_6_19_chunk._ts_meta_min_3, compress_hyper_6_19_chunk._ts_meta_max_3, compress_hyper_6_19_chunk."time", compress_hyper_6_19_chunk._ts_meta_min_1, compress_hyper_6_19_chunk._ts_meta_max_1, compress_hyper_6_19_chunk.v0, compress_hyper_6_19_chunk._ts_meta_min_2, compress_hyper_6_19_chunk._ts_meta_max_2, compress_hyper_6_19_chunk.v1, compress_hyper_6_19_chunk.v2, compress_hyper_6_19_chunk.v3 Filter: (compress_hyper_6_19_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1 -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk (actual rows=0.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id_peer = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=0.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id_peer = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_9_chunk (actual rows=0.00 loops=1) Output: _hyper_2_9_chunk.device_id_peer Index Cond: (_hyper_2_9_chunk.device_id_peer = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=0.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=0.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=0.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id_peer = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 3 -> Index Only Scan using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _timescaledb_internal._hyper_2_12_chunk (actual rows=0.00 loops=1) Output: _hyper_2_12_chunk.device_id_peer Index Cond: (_hyper_2_12_chunk.device_id_peer = ANY ('{1,2}'::integer[])) RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=720.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=672.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=336.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk Output: _hyper_2_4_chunk.device_id_peer -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_17_chunk Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Index Cond: (compress_hyper_6_17_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk Output: _hyper_2_5_chunk.device_id_peer -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_18_chunk Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Index Cond: (compress_hyper_6_18_chunk.device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_7_chunk Output: _hyper_2_7_chunk.device_id_peer Index Cond: (_hyper_2_7_chunk.device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk Output: _hyper_2_10_chunk.device_id_peer -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_20_chunk Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Index Cond: (compress_hyper_6_20_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk Output: _hyper_2_11_chunk.device_id_peer -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on _timescaledb_internal.compress_hyper_6_21_chunk Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Index Cond: (compress_hyper_6_21_chunk.device_id = ANY ('{1,2}'::integer[])) RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = 1) -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = 1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = 1) :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=3456.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_4_chunk (actual rows=720.00 loops=1) Output: _hyper_2_4_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_17_chunk._ts_meta_count, compress_hyper_6_17_chunk.device_id, compress_hyper_6_17_chunk.device_id_peer, compress_hyper_6_17_chunk._ts_meta_min_3, compress_hyper_6_17_chunk._ts_meta_max_3, compress_hyper_6_17_chunk."time", compress_hyper_6_17_chunk._ts_meta_min_1, compress_hyper_6_17_chunk._ts_meta_max_1, compress_hyper_6_17_chunk.v0, compress_hyper_6_17_chunk._ts_meta_min_2, compress_hyper_6_17_chunk._ts_meta_max_2, compress_hyper_6_17_chunk.v1, compress_hyper_6_17_chunk.v2, compress_hyper_6_17_chunk.v3 Filter: (compress_hyper_6_17_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_5_chunk (actual rows=720.00 loops=1) Output: _hyper_2_5_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_18_chunk._ts_meta_count, compress_hyper_6_18_chunk.device_id, compress_hyper_6_18_chunk.device_id_peer, compress_hyper_6_18_chunk._ts_meta_min_3, compress_hyper_6_18_chunk._ts_meta_max_3, compress_hyper_6_18_chunk."time", compress_hyper_6_18_chunk._ts_meta_min_1, compress_hyper_6_18_chunk._ts_meta_max_1, compress_hyper_6_18_chunk.v0, compress_hyper_6_18_chunk._ts_meta_min_2, compress_hyper_6_18_chunk._ts_meta_max_2, compress_hyper_6_18_chunk.v1, compress_hyper_6_18_chunk.v2, compress_hyper_6_18_chunk.v3 Filter: (compress_hyper_6_18_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -> Seq Scan on _timescaledb_internal._hyper_2_7_chunk (actual rows=672.00 loops=1) Output: _hyper_2_7_chunk.device_id_peer Filter: (_hyper_2_7_chunk.device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _timescaledb_internal._hyper_2_8_chunk (actual rows=672.00 loops=1) Output: _hyper_2_8_chunk.device_id_peer Index Cond: (_hyper_2_8_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_10_chunk (actual rows=336.00 loops=1) Output: _hyper_2_10_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_20_chunk._ts_meta_count, compress_hyper_6_20_chunk.device_id, compress_hyper_6_20_chunk.device_id_peer, compress_hyper_6_20_chunk._ts_meta_min_3, compress_hyper_6_20_chunk._ts_meta_max_3, compress_hyper_6_20_chunk."time", compress_hyper_6_20_chunk._ts_meta_min_1, compress_hyper_6_20_chunk._ts_meta_max_1, compress_hyper_6_20_chunk.v0, compress_hyper_6_20_chunk._ts_meta_min_2, compress_hyper_6_20_chunk._ts_meta_max_2, compress_hyper_6_20_chunk.v1, compress_hyper_6_20_chunk.v2, compress_hyper_6_20_chunk.v3 Filter: (compress_hyper_6_20_chunk.device_id = ANY ('{1,2}'::integer[])) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_2_11_chunk (actual rows=336.00 loops=1) Output: _hyper_2_11_chunk.device_id_peer Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Output: compress_hyper_6_21_chunk._ts_meta_count, compress_hyper_6_21_chunk.device_id, compress_hyper_6_21_chunk.device_id_peer, compress_hyper_6_21_chunk._ts_meta_min_3, compress_hyper_6_21_chunk._ts_meta_max_3, compress_hyper_6_21_chunk."time", compress_hyper_6_21_chunk._ts_meta_min_1, compress_hyper_6_21_chunk._ts_meta_max_1, compress_hyper_6_21_chunk.v0, compress_hyper_6_21_chunk._ts_meta_min_2, compress_hyper_6_21_chunk._ts_meta_max_2, compress_hyper_6_21_chunk.v1, compress_hyper_6_21_chunk.v2, compress_hyper_6_21_chunk.v3 Filter: (compress_hyper_6_21_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 2 -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=10.00 loops=1) Order: metrics_space."time" DESC -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_2_10_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_2_4_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (never executed) -> Seq Scan on compress_hyper_6_17_chunk (never executed) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=10.00 loops=1) Order: m2."time", m2.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m2."time", m2.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time", m2_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m2_2."time", m2_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time", m2_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_4."time", m2_4.device_id -> Seq Scan on _hyper_2_7_chunk m2_4 (never executed) -> Sort (never executed) Sort Key: m2_5."time", m2_5.device_id -> Seq Scan on _hyper_2_8_chunk m2_5 (never executed) -> Sort (never executed) Sort Key: m2_6."time", m2_6.device_id -> Seq Scan on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time", m2.device_id -> Sort (never executed) Sort Key: m2_7."time", m2_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time", m2_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_9."time", m2_9.device_id -> Seq Scan on _hyper_2_12_chunk m2_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m3."time") -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=10.00 loops=1) -> Merge Append (actual rows=3.00 loops=1) Sort Key: m3."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m3_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m3_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m3_2 (actual rows=1.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m3_3 (actual rows=1.00 loops=1) Filter: (device_id = 3) :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m2."time" = m1."time") -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) Filter: (device_id = 1) :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk m1_2 (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: m1_3."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=100.00 loops=1) Order: m2."time" -> Sort (actual rows=100.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_2 (never executed) Index Cond: (device_id = 2) -> Sort (never executed) Sort Key: m2_3."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_3 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: (device_id = 2) -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Left Join (actual rows=10.00 loops=1) Merge Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = m2.device_id) Rows Removed by Join Filter: 39 -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=10.00 loops=1) Order: m1."time", m1.device_id -> Merge Append (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id -> Sort (actual rows=3.00 loops=1) Sort Key: m1_1."time", m1_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: m1_2."time", m1_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m1_3."time", m1_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_4."time", m1_4.device_id -> Seq Scan on _hyper_2_7_chunk m1_4 (never executed) -> Sort (never executed) Sort Key: m1_5."time", m1_5.device_id -> Seq Scan on _hyper_2_8_chunk m1_5 (never executed) -> Sort (never executed) Sort Key: m1_6."time", m1_6.device_id -> Seq Scan on _hyper_2_9_chunk m1_6 (never executed) -> Merge Append (never executed) Sort Key: m1."time", m1.device_id -> Sort (never executed) Sort Key: m1_7."time", m1_7.device_id -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk (never executed) -> Sort (never executed) Sort Key: m1_8."time", m1_8.device_id -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk (never executed) -> Sort (never executed) Sort Key: m1_9."time", m1_9.device_id -> Seq Scan on _hyper_2_12_chunk m1_9 (never executed) -> Materialize (actual rows=49.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=11.00 loops=1) Order: m2."time" -> Merge Append (actual rows=11.00 loops=1) Sort Key: m2."time" -> Sort (actual rows=3.00 loops=1) Sort Key: m2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Sort (actual rows=7.00 loops=1) Sort Key: m2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Sort (actual rows=3.00 loops=1) Sort Key: m2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: m2."time" -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m2_4 (never executed) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m2_5 (never executed) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m2_6 (never executed) -> Merge Append (never executed) Sort Key: m2."time" -> Sort (never executed) Sort Key: m2_7."time" -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (never executed) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (never executed) -> Sort (never executed) Sort Key: m2_8."time" -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (never executed) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (never executed) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m2_9 (never executed) :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: m1."time", m1.device_id, m2."time", m2.device_id Sort Method: top-N heapsort -> Hash Left Join (actual rows=8640.00 loops=1) Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) Rows Removed by Join Filter: 6912 -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m1_1 (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk m1_2 (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m1_3 (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1728.00 loops=1) -> Append (actual rows=1728.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m2_4 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m2_5 (actual rows=672.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk m2_6 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=0.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 2 -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk m2_9 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit (actual rows=20.00 loops=1) -> Sort (actual rows=20.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: m1."time", m1.device_id, m2.device_id Sort Method: top-N heapsort -> Hash Join (actual rows=43200.00 loops=1) Hash Cond: (m1."time" = m2."time") -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m1_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m1_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m1_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m1_9 (actual rows=336.00 loops=1) -> Hash (actual rows=8640.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m2_1 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_17_chunk compress_hyper_6_17_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m2_2 (actual rows=2160.00 loops=1) -> Seq Scan on compress_hyper_6_18_chunk compress_hyper_6_18_chunk_1 (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m2_3 (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_6_19_chunk compress_hyper_6_19_chunk_1 (actual rows=1.00 loops=1) -> Seq Scan on _hyper_2_7_chunk m2_4 (actual rows=672.00 loops=1) -> Seq Scan on _hyper_2_8_chunk m2_5 (actual rows=2016.00 loops=1) -> Seq Scan on _hyper_2_9_chunk m2_6 (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m2_7 (actual rows=336.00 loops=1) -> Seq Scan on compress_hyper_6_20_chunk compress_hyper_6_20_chunk_1 (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m2_8 (actual rows=1008.00 loops=1) -> Seq Scan on compress_hyper_6_21_chunk compress_hyper_6_21_chunk_1 (actual rows=3.00 loops=1) -> Seq Scan on _hyper_2_12_chunk m2_9 (actual rows=336.00 loops=1) :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.59 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=0.59 loops=32) Chunks excluded during runtime: 7 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_2 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_18_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk m1_3 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_19_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_time_idx on _hyper_2_7_chunk m1_4 (actual rows=1.00 loops=7) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_8_chunk_metrics_space_time_idx on _hyper_2_8_chunk m1_5 (never executed) Index Cond: ("time" = g."time") -> Index Only Scan using _hyper_2_9_chunk_metrics_space_time_idx on _hyper_2_9_chunk m1_6 (never executed) Index Cond: ("time" = g."time") -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_7 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_8 (never executed) Filter: ("time" = g."time") -> Seq Scan on compress_hyper_6_21_chunk (never executed) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time")) -> Index Only Scan using _hyper_2_12_chunk_metrics_space_time_idx on _hyper_2_12_chunk m1_9 (never executed) Index Cond: ("time" = g."time") -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.59 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=0.59 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_17_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) -> Index Only Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 1) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_20_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 1)) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=19.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.59 loops=32) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=0.59 loops=32) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk m1_1 (actual rows=1.00 loops=5) Filter: ("time" = g."time") Rows Removed by Filter: 336 -> Seq Scan on compress_hyper_6_18_chunk (actual rows=1.00 loops=5) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) -> Index Only Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk m1_2 (actual rows=1.00 loops=7) Index Cond: ((device_id = 2) AND ("time" = g."time")) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk m1_3 (actual rows=1.00 loops=7) Filter: ("time" = g."time") Rows Removed by Filter: 160 -> Seq Scan on compress_hyper_6_21_chunk (actual rows=1.00 loops=7) Filter: ((_ts_meta_min_3 <= g."time") AND (_ts_meta_max_3 >= g."time") AND (device_id = 2)) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST Thu Jan 06 00:00:00 2000 PST | Thu Jan 06 00:00:00 2000 PST Fri Jan 07 00:00:00 2000 PST | Fri Jan 07 00:00:00 2000 PST Sat Jan 08 00:00:00 2000 PST | Sat Jan 08 00:00:00 2000 PST Sun Jan 09 00:00:00 2000 PST | Sun Jan 09 00:00:00 2000 PST Mon Jan 10 00:00:00 2000 PST | Mon Jan 10 00:00:00 2000 PST Tue Jan 11 00:00:00 2000 PST | Tue Jan 11 00:00:00 2000 PST Wed Jan 12 00:00:00 2000 PST | Wed Jan 12 00:00:00 2000 PST Thu Jan 13 00:00:00 2000 PST | Thu Jan 13 00:00:00 2000 PST Fri Jan 14 00:00:00 2000 PST | Fri Jan 14 00:00:00 2000 PST Sat Jan 15 00:00:00 2000 PST | Sat Jan 15 00:00:00 2000 PST Sun Jan 16 00:00:00 2000 PST | Sun Jan 16 00:00:00 2000 PST Mon Jan 17 00:00:00 2000 PST | Mon Jan 17 00:00:00 2000 PST Tue Jan 18 00:00:00 2000 PST | Tue Jan 18 00:00:00 2000 PST Wed Jan 19 00:00:00 2000 PST | Wed Jan 19 00:00:00 2000 PST DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; time ------------------------------ Fri Dec 31 16:00:00 1999 PST DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_17_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_17_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk (actual rows=2160.00 loops=1) -> Index Scan using compress_hyper_6_18_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_18_chunk (actual rows=3.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk (actual rows=720.00 loops=1) -> Index Scan using compress_hyper_6_19_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_19_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_2_7_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_7_chunk (actual rows=672.00 loops=1) -> Index Scan Backward using _hyper_2_8_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_8_chunk (actual rows=2016.00 loops=1) -> Index Scan Backward using _hyper_2_9_chunk_metrics_space_device_id_device_id_peer_v0_v1_2 on _hyper_2_9_chunk (actual rows=672.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk (actual rows=336.00 loops=1) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk (actual rows=1008.00 loops=1) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk (actual rows=3.00 loops=1) -> Index Scan Backward using _hyper_2_12_chunk_metrics_space_device_id_device_id_peer_v0_v_2 on _hyper_2_12_chunk (actual rows=336.00 loops=1) -> Append (actual rows=0.00 loops=8640) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_5_15_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_15_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (actual rows=0.00 loops=8640) Index Cond: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Filter: (metrics_space.device_id = device_id) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=0.00 loops=8640) Filter: (("time" > metrics_space."time") AND ("time" < metrics_space."time")) Rows Removed by Filter: 336 -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk (actual rows=1.00 loops=8640) Index Cond: (device_id = metrics_space.device_id) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 \ir include/transparent_decompression_ordered.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column CREATE TABLE metrics_ordered(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_ordered','time'); create_hypertable ------------------------------- (11,public,metrics_ordered,t) ALTER TABLE metrics_ordered SET (timescaledb.compress, timescaledb.compress_orderby='time DESC',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered SELECT * FROM metrics; CREATE INDEX ON metrics_ordered(device_id,device_id_peer,time); CREATE INDEX ON metrics_ordered(device_id,time); CREATE INDEX ON metrics_ordered(device_id_peer,time); -- compress all chunks SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered') ch; count ------- 3 VACUUM ANALYZE metrics_ordered; -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM metrics_ordered ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=10.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_30_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_30_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_12_29_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_12_29_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered WHERE device_id = 1 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered (actual rows=0.00 loops=1) Order: metrics_ordered."time" DESC -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_31_chunk._ts_meta_min_1 DESC, compress_hyper_12_31_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_30_chunk._ts_meta_min_1 DESC, compress_hyper_12_30_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_12_29_chunk._ts_meta_min_1 DESC, compress_hyper_12_29_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk (actual rows=0.00 loops=1) Filter: ((device_id = 1) AND (device_id_peer = 3)) Rows Removed by Filter: 5 :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered d INNER JOIN LATERAL (SELECT * FROM metrics_ordered m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON true; --- QUERY PLAN --- Unique (actual rows=0.00 loops=1) -> Nested Loop (actual rows=0.00 loops=1) -> Merge Append (actual rows=8640.00 loops=1) Sort Key: d.device_id -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk d_1 (actual rows=3600.00 loops=1) -> Index Scan using compress_hyper_12_29_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_29_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk d_2 (actual rows=3360.00 loops=1) -> Index Scan using compress_hyper_12_30_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_30_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk d_3 (actual rows=1680.00 loops=1) -> Index Scan using compress_hyper_12_31_chunk_device_id_device_id_peer__ts_met_idx on compress_hyper_12_31_chunk (actual rows=5.00 loops=1) -> Limit (actual rows=0.00 loops=8640) -> Custom Scan (ChunkAppend) on metrics_ordered m (actual rows=0.00 loops=8640) Order: m."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_11_28_chunk m_1 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_31_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_31_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_31_chunk compress_hyper_12_31_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_27_chunk m_2 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_30_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_30_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_30_chunk compress_hyper_12_30_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_11_26_chunk m_3 (actual rows=0.00 loops=8640) -> Sort (actual rows=0.00 loops=8640) Sort Key: compress_hyper_12_29_chunk_1._ts_meta_min_1 DESC, compress_hyper_12_29_chunk_1._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_12_29_chunk compress_hyper_12_29_chunk_1 (actual rows=0.00 loops=8640) Filter: ((device_id = d.device_id) AND (device_id_peer = 3)) Rows Removed by Filter: 5 \ir include/transparent_decompression_systemcolumns.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_TABLE 'metrics' -- test system columns -- all system columns except for tableoid should error \set ON_ERROR_STOP 0 SELECT xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:10: ERROR: transparent decompression only supports tableoid system column SELECT cmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:11: ERROR: transparent decompression only supports tableoid system column SELECT xmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:12: ERROR: transparent decompression only supports tableoid system column SELECT cmax FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:13: ERROR: transparent decompression only supports tableoid system column SELECT ctid FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:14: ERROR: transparent decompression only supports tableoid system column -- test system columns in WHERE and ORDER BY clause SELECT tableoid, xmin FROM :TEST_TABLE ORDER BY time; psql:include/transparent_decompression_systemcolumns.sql:17: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE ORDER BY cmin::text; psql:include/transparent_decompression_systemcolumns.sql:18: ERROR: transparent decompression only supports tableoid system column SELECT FROM :TEST_TABLE WHERE cmin IS NOT NULL; psql:include/transparent_decompression_systemcolumns.sql:19: ERROR: transparent decompression only supports tableoid system column \set ON_ERROR_STOP 1 -- test tableoid in different parts of query SELECT pg_typeof(tableoid) FROM :TEST_TABLE ORDER BY time LIMIT 1; pg_typeof ----------- oid SELECT FROM :TEST_TABLE ORDER BY tableoid LIMIT 1; -- SELECT FROM :TEST_TABLE WHERE tableoid::int > 0 LIMIT 1; -- SELECT tableoid::regclass FROM :TEST_TABLE GROUP BY tableoid ORDER BY 1; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk SELECT count(distinct tableoid) FROM :TEST_TABLE WHERE device_id=1 AND time < now(); count ------- 3 -- test prepared statement PREPARE tableoid_prep AS SELECT tableoid::regclass FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 1; :PREFIX EXECUTE tableoid_prep; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_1_1_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=720.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 4 -> Index Scan Backward using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Seq Scan on compress_hyper_5_16_chunk (never executed) Filter: (device_id = 1) EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk EXECUTE tableoid_prep; tableoid ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk DEALLOCATE tableoid_prep; \ir include/transparent_decompression_undiffed.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test planning regression with many chunks CREATE TABLE tags(id SERIAL PRIMARY KEY, name TEXT, fleet TEXT); INSERT INTO tags (name, fleet) VALUES('n1', 'f1'); CREATE TABLE readings (time timestamptz, tags_id integer, fuel_consumption DOUBLE PRECISION); CREATE INDEX ON readings(tags_id, "time" DESC); CREATE INDEX ON readings("time" DESC); SELECT create_hypertable('readings', 'time', partitioning_column => 'tags_id', number_partitions => 1, chunk_time_interval => 43200000000, create_default_indexes=>false); create_hypertable ------------------------ (13,public,readings,t) ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'tags_id', timescaledb.compress_orderby = 'time desc'); INSERT into readings select g, 1, 1.3 from generate_series('2001-03-01 01:01:01', '2003-02-01 01:01:01', '1 day'::interval) g; SELECT count(compress_chunk(ch)) FROM show_chunks('readings') ch; count ------- 703 VACUUM ANALYZE readings; EXPLAIN (buffers off, costs off) SELECT t.fleet as fleet, min(r.fuel_consumption) AS avg_fuel_consumption FROM tags t INNER JOIN LATERAL(SELECT tags_id, fuel_consumption FROM readings r WHERE r.tags_id = t.id ) r ON true GROUP BY fleet; --- QUERY PLAN --- HashAggregate Group Key: t.fleet -> Hash Join Hash Cond: (r.tags_id = t.id) -> Append -> Custom Scan (ColumnarScan) on _hyper_13_32_chunk r_1 -> Seq Scan on compress_hyper_14_735_chunk -> Custom Scan (ColumnarScan) on _hyper_13_33_chunk r_2 -> Seq Scan on compress_hyper_14_736_chunk -> Custom Scan (ColumnarScan) on _hyper_13_34_chunk r_3 -> Seq Scan on compress_hyper_14_737_chunk -> Custom Scan (ColumnarScan) on _hyper_13_35_chunk r_4 -> Seq Scan on compress_hyper_14_738_chunk -> Custom Scan (ColumnarScan) on _hyper_13_36_chunk r_5 -> Seq Scan on compress_hyper_14_739_chunk -> Custom Scan (ColumnarScan) on _hyper_13_37_chunk r_6 -> Seq Scan on compress_hyper_14_740_chunk -> Custom Scan (ColumnarScan) on _hyper_13_38_chunk r_7 -> Seq Scan on compress_hyper_14_741_chunk -> Custom Scan (ColumnarScan) on _hyper_13_39_chunk r_8 -> Seq Scan on compress_hyper_14_742_chunk -> Custom Scan (ColumnarScan) on _hyper_13_40_chunk r_9 -> Seq Scan on compress_hyper_14_743_chunk -> Custom Scan (ColumnarScan) on _hyper_13_41_chunk r_10 -> Seq Scan on compress_hyper_14_744_chunk -> Custom Scan (ColumnarScan) on _hyper_13_42_chunk r_11 -> Seq Scan on compress_hyper_14_745_chunk -> Custom Scan (ColumnarScan) on _hyper_13_43_chunk r_12 -> Seq Scan on compress_hyper_14_746_chunk -> Custom Scan (ColumnarScan) on _hyper_13_44_chunk r_13 -> Seq Scan on compress_hyper_14_747_chunk -> Custom Scan (ColumnarScan) on _hyper_13_45_chunk r_14 -> Seq Scan on compress_hyper_14_748_chunk -> Custom Scan (ColumnarScan) on _hyper_13_46_chunk r_15 -> Seq Scan on compress_hyper_14_749_chunk -> Custom Scan (ColumnarScan) on _hyper_13_47_chunk r_16 -> Seq Scan on compress_hyper_14_750_chunk -> Custom Scan (ColumnarScan) on _hyper_13_48_chunk r_17 -> Seq Scan on compress_hyper_14_751_chunk -> Custom Scan (ColumnarScan) on _hyper_13_49_chunk r_18 -> Seq Scan on compress_hyper_14_752_chunk -> Custom Scan (ColumnarScan) on _hyper_13_50_chunk r_19 -> Seq Scan on compress_hyper_14_753_chunk -> Custom Scan (ColumnarScan) on _hyper_13_51_chunk r_20 -> Seq Scan on compress_hyper_14_754_chunk -> Custom Scan (ColumnarScan) on _hyper_13_52_chunk r_21 -> Seq Scan on compress_hyper_14_755_chunk -> Custom Scan (ColumnarScan) on _hyper_13_53_chunk r_22 -> Seq Scan on compress_hyper_14_756_chunk -> Custom Scan (ColumnarScan) on _hyper_13_54_chunk r_23 -> Seq Scan on compress_hyper_14_757_chunk -> Custom Scan (ColumnarScan) on _hyper_13_55_chunk r_24 -> Seq Scan on compress_hyper_14_758_chunk -> Custom Scan (ColumnarScan) on _hyper_13_56_chunk r_25 -> Seq Scan on compress_hyper_14_759_chunk -> Custom Scan (ColumnarScan) on _hyper_13_57_chunk r_26 -> Seq Scan on compress_hyper_14_760_chunk -> Custom Scan (ColumnarScan) on _hyper_13_58_chunk r_27 -> Seq Scan on compress_hyper_14_761_chunk -> Custom Scan (ColumnarScan) on _hyper_13_59_chunk r_28 -> Seq Scan on compress_hyper_14_762_chunk -> Custom Scan (ColumnarScan) on _hyper_13_60_chunk r_29 -> Seq Scan on compress_hyper_14_763_chunk -> Custom Scan (ColumnarScan) on _hyper_13_61_chunk r_30 -> Seq Scan on compress_hyper_14_764_chunk -> Custom Scan (ColumnarScan) on _hyper_13_62_chunk r_31 -> Seq Scan on compress_hyper_14_765_chunk -> Custom Scan (ColumnarScan) on _hyper_13_63_chunk r_32 -> Seq Scan on compress_hyper_14_766_chunk -> Custom Scan (ColumnarScan) on _hyper_13_64_chunk r_33 -> Seq Scan on compress_hyper_14_767_chunk -> Custom Scan (ColumnarScan) on _hyper_13_65_chunk r_34 -> Seq Scan on compress_hyper_14_768_chunk -> Custom Scan (ColumnarScan) on _hyper_13_66_chunk r_35 -> Seq Scan on compress_hyper_14_769_chunk -> Custom Scan (ColumnarScan) on _hyper_13_67_chunk r_36 -> Seq Scan on compress_hyper_14_770_chunk -> Custom Scan (ColumnarScan) on _hyper_13_68_chunk r_37 -> Seq Scan on compress_hyper_14_771_chunk -> Custom Scan (ColumnarScan) on _hyper_13_69_chunk r_38 -> Seq Scan on compress_hyper_14_772_chunk -> Custom Scan (ColumnarScan) on _hyper_13_70_chunk r_39 -> Seq Scan on compress_hyper_14_773_chunk -> Custom Scan (ColumnarScan) on _hyper_13_71_chunk r_40 -> Seq Scan on compress_hyper_14_774_chunk -> Custom Scan (ColumnarScan) on _hyper_13_72_chunk r_41 -> Seq Scan on compress_hyper_14_775_chunk -> Custom Scan (ColumnarScan) on _hyper_13_73_chunk r_42 -> Seq Scan on compress_hyper_14_776_chunk -> Custom Scan (ColumnarScan) on _hyper_13_74_chunk r_43 -> Seq Scan on compress_hyper_14_777_chunk -> Custom Scan (ColumnarScan) on _hyper_13_75_chunk r_44 -> Seq Scan on compress_hyper_14_778_chunk -> Custom Scan (ColumnarScan) on _hyper_13_76_chunk r_45 -> Seq Scan on compress_hyper_14_779_chunk -> Custom Scan (ColumnarScan) on _hyper_13_77_chunk r_46 -> Seq Scan on compress_hyper_14_780_chunk -> Custom Scan (ColumnarScan) on _hyper_13_78_chunk r_47 -> Seq Scan on compress_hyper_14_781_chunk -> Custom Scan (ColumnarScan) on _hyper_13_79_chunk r_48 -> Seq Scan on compress_hyper_14_782_chunk -> Custom Scan (ColumnarScan) on _hyper_13_80_chunk r_49 -> Seq Scan on compress_hyper_14_783_chunk -> Custom Scan (ColumnarScan) on _hyper_13_81_chunk r_50 -> Seq Scan on compress_hyper_14_784_chunk -> Custom Scan (ColumnarScan) on _hyper_13_82_chunk r_51 -> Seq Scan on compress_hyper_14_785_chunk -> Custom Scan (ColumnarScan) on _hyper_13_83_chunk r_52 -> Seq Scan on compress_hyper_14_786_chunk -> Custom Scan (ColumnarScan) on _hyper_13_84_chunk r_53 -> Seq Scan on compress_hyper_14_787_chunk -> Custom Scan (ColumnarScan) on _hyper_13_85_chunk r_54 -> Seq Scan on compress_hyper_14_788_chunk -> Custom Scan (ColumnarScan) on _hyper_13_86_chunk r_55 -> Seq Scan on compress_hyper_14_789_chunk -> Custom Scan (ColumnarScan) on _hyper_13_87_chunk r_56 -> Seq Scan on compress_hyper_14_790_chunk -> Custom Scan (ColumnarScan) on _hyper_13_88_chunk r_57 -> Seq Scan on compress_hyper_14_791_chunk -> Custom Scan (ColumnarScan) on _hyper_13_89_chunk r_58 -> Seq Scan on compress_hyper_14_792_chunk -> Custom Scan (ColumnarScan) on _hyper_13_90_chunk r_59 -> Seq Scan on compress_hyper_14_793_chunk -> Custom Scan (ColumnarScan) on _hyper_13_91_chunk r_60 -> Seq Scan on compress_hyper_14_794_chunk -> Custom Scan (ColumnarScan) on _hyper_13_92_chunk r_61 -> Seq Scan on compress_hyper_14_795_chunk -> Custom Scan (ColumnarScan) on _hyper_13_93_chunk r_62 -> Seq Scan on compress_hyper_14_796_chunk -> Custom Scan (ColumnarScan) on _hyper_13_94_chunk r_63 -> Seq Scan on compress_hyper_14_797_chunk -> Custom Scan (ColumnarScan) on _hyper_13_95_chunk r_64 -> Seq Scan on compress_hyper_14_798_chunk -> Custom Scan (ColumnarScan) on _hyper_13_96_chunk r_65 -> Seq Scan on compress_hyper_14_799_chunk -> Custom Scan (ColumnarScan) on _hyper_13_97_chunk r_66 -> Seq Scan on compress_hyper_14_800_chunk -> Custom Scan (ColumnarScan) on _hyper_13_98_chunk r_67 -> Seq Scan on compress_hyper_14_801_chunk -> Custom Scan (ColumnarScan) on _hyper_13_99_chunk r_68 -> Seq Scan on compress_hyper_14_802_chunk -> Custom Scan (ColumnarScan) on _hyper_13_100_chunk r_69 -> Seq Scan on compress_hyper_14_803_chunk -> Custom Scan (ColumnarScan) on _hyper_13_101_chunk r_70 -> Seq Scan on compress_hyper_14_804_chunk -> Custom Scan (ColumnarScan) on _hyper_13_102_chunk r_71 -> Seq Scan on compress_hyper_14_805_chunk -> Custom Scan (ColumnarScan) on _hyper_13_103_chunk r_72 -> Seq Scan on compress_hyper_14_806_chunk -> Custom Scan (ColumnarScan) on _hyper_13_104_chunk r_73 -> Seq Scan on compress_hyper_14_807_chunk -> Custom Scan (ColumnarScan) on _hyper_13_105_chunk r_74 -> Seq Scan on compress_hyper_14_808_chunk -> Custom Scan (ColumnarScan) on _hyper_13_106_chunk r_75 -> Seq Scan on compress_hyper_14_809_chunk -> Custom Scan (ColumnarScan) on _hyper_13_107_chunk r_76 -> Seq Scan on compress_hyper_14_810_chunk -> Custom Scan (ColumnarScan) on _hyper_13_108_chunk r_77 -> Seq Scan on compress_hyper_14_811_chunk -> Custom Scan (ColumnarScan) on _hyper_13_109_chunk r_78 -> Seq Scan on compress_hyper_14_812_chunk -> Custom Scan (ColumnarScan) on _hyper_13_110_chunk r_79 -> Seq Scan on compress_hyper_14_813_chunk -> Custom Scan (ColumnarScan) on _hyper_13_111_chunk r_80 -> Seq Scan on compress_hyper_14_814_chunk -> Custom Scan (ColumnarScan) on _hyper_13_112_chunk r_81 -> Seq Scan on compress_hyper_14_815_chunk -> Custom Scan (ColumnarScan) on _hyper_13_113_chunk r_82 -> Seq Scan on compress_hyper_14_816_chunk -> Custom Scan (ColumnarScan) on _hyper_13_114_chunk r_83 -> Seq Scan on compress_hyper_14_817_chunk -> Custom Scan (ColumnarScan) on _hyper_13_115_chunk r_84 -> Seq Scan on compress_hyper_14_818_chunk -> Custom Scan (ColumnarScan) on _hyper_13_116_chunk r_85 -> Seq Scan on compress_hyper_14_819_chunk -> Custom Scan (ColumnarScan) on _hyper_13_117_chunk r_86 -> Seq Scan on compress_hyper_14_820_chunk -> Custom Scan (ColumnarScan) on _hyper_13_118_chunk r_87 -> Seq Scan on compress_hyper_14_821_chunk -> Custom Scan (ColumnarScan) on _hyper_13_119_chunk r_88 -> Seq Scan on compress_hyper_14_822_chunk -> Custom Scan (ColumnarScan) on _hyper_13_120_chunk r_89 -> Seq Scan on compress_hyper_14_823_chunk -> Custom Scan (ColumnarScan) on _hyper_13_121_chunk r_90 -> Seq Scan on compress_hyper_14_824_chunk -> Custom Scan (ColumnarScan) on _hyper_13_122_chunk r_91 -> Seq Scan on compress_hyper_14_825_chunk -> Custom Scan (ColumnarScan) on _hyper_13_123_chunk r_92 -> Seq Scan on compress_hyper_14_826_chunk -> Custom Scan (ColumnarScan) on _hyper_13_124_chunk r_93 -> Seq Scan on compress_hyper_14_827_chunk -> Custom Scan (ColumnarScan) on _hyper_13_125_chunk r_94 -> Seq Scan on compress_hyper_14_828_chunk -> Custom Scan (ColumnarScan) on _hyper_13_126_chunk r_95 -> Seq Scan on compress_hyper_14_829_chunk -> Custom Scan (ColumnarScan) on _hyper_13_127_chunk r_96 -> Seq Scan on compress_hyper_14_830_chunk -> Custom Scan (ColumnarScan) on _hyper_13_128_chunk r_97 -> Seq Scan on compress_hyper_14_831_chunk -> Custom Scan (ColumnarScan) on _hyper_13_129_chunk r_98 -> Seq Scan on compress_hyper_14_832_chunk -> Custom Scan (ColumnarScan) on _hyper_13_130_chunk r_99 -> Seq Scan on compress_hyper_14_833_chunk -> Custom Scan (ColumnarScan) on _hyper_13_131_chunk r_100 -> Seq Scan on compress_hyper_14_834_chunk -> Custom Scan (ColumnarScan) on _hyper_13_132_chunk r_101 -> Seq Scan on compress_hyper_14_835_chunk -> Custom Scan (ColumnarScan) on _hyper_13_133_chunk r_102 -> Seq Scan on compress_hyper_14_836_chunk -> Custom Scan (ColumnarScan) on _hyper_13_134_chunk r_103 -> Seq Scan on compress_hyper_14_837_chunk -> Custom Scan (ColumnarScan) on _hyper_13_135_chunk r_104 -> Seq Scan on compress_hyper_14_838_chunk -> Custom Scan (ColumnarScan) on _hyper_13_136_chunk r_105 -> Seq Scan on compress_hyper_14_839_chunk -> Custom Scan (ColumnarScan) on _hyper_13_137_chunk r_106 -> Seq Scan on compress_hyper_14_840_chunk -> Custom Scan (ColumnarScan) on _hyper_13_138_chunk r_107 -> Seq Scan on compress_hyper_14_841_chunk -> Custom Scan (ColumnarScan) on _hyper_13_139_chunk r_108 -> Seq Scan on compress_hyper_14_842_chunk -> Custom Scan (ColumnarScan) on _hyper_13_140_chunk r_109 -> Seq Scan on compress_hyper_14_843_chunk -> Custom Scan (ColumnarScan) on _hyper_13_141_chunk r_110 -> Seq Scan on compress_hyper_14_844_chunk -> Custom Scan (ColumnarScan) on _hyper_13_142_chunk r_111 -> Seq Scan on compress_hyper_14_845_chunk -> Custom Scan (ColumnarScan) on _hyper_13_143_chunk r_112 -> Seq Scan on compress_hyper_14_846_chunk -> Custom Scan (ColumnarScan) on _hyper_13_144_chunk r_113 -> Seq Scan on compress_hyper_14_847_chunk -> Custom Scan (ColumnarScan) on _hyper_13_145_chunk r_114 -> Seq Scan on compress_hyper_14_848_chunk -> Custom Scan (ColumnarScan) on _hyper_13_146_chunk r_115 -> Seq Scan on compress_hyper_14_849_chunk -> Custom Scan (ColumnarScan) on _hyper_13_147_chunk r_116 -> Seq Scan on compress_hyper_14_850_chunk -> Custom Scan (ColumnarScan) on _hyper_13_148_chunk r_117 -> Seq Scan on compress_hyper_14_851_chunk -> Custom Scan (ColumnarScan) on _hyper_13_149_chunk r_118 -> Seq Scan on compress_hyper_14_852_chunk -> Custom Scan (ColumnarScan) on _hyper_13_150_chunk r_119 -> Seq Scan on compress_hyper_14_853_chunk -> Custom Scan (ColumnarScan) on _hyper_13_151_chunk r_120 -> Seq Scan on compress_hyper_14_854_chunk -> Custom Scan (ColumnarScan) on _hyper_13_152_chunk r_121 -> Seq Scan on compress_hyper_14_855_chunk -> Custom Scan (ColumnarScan) on _hyper_13_153_chunk r_122 -> Seq Scan on compress_hyper_14_856_chunk -> Custom Scan (ColumnarScan) on _hyper_13_154_chunk r_123 -> Seq Scan on compress_hyper_14_857_chunk -> Custom Scan (ColumnarScan) on _hyper_13_155_chunk r_124 -> Seq Scan on compress_hyper_14_858_chunk -> Custom Scan (ColumnarScan) on _hyper_13_156_chunk r_125 -> Seq Scan on compress_hyper_14_859_chunk -> Custom Scan (ColumnarScan) on _hyper_13_157_chunk r_126 -> Seq Scan on compress_hyper_14_860_chunk -> Custom Scan (ColumnarScan) on _hyper_13_158_chunk r_127 -> Seq Scan on compress_hyper_14_861_chunk -> Custom Scan (ColumnarScan) on _hyper_13_159_chunk r_128 -> Seq Scan on compress_hyper_14_862_chunk -> Custom Scan (ColumnarScan) on _hyper_13_160_chunk r_129 -> Seq Scan on compress_hyper_14_863_chunk -> Custom Scan (ColumnarScan) on _hyper_13_161_chunk r_130 -> Seq Scan on compress_hyper_14_864_chunk -> Custom Scan (ColumnarScan) on _hyper_13_162_chunk r_131 -> Seq Scan on compress_hyper_14_865_chunk -> Custom Scan (ColumnarScan) on _hyper_13_163_chunk r_132 -> Seq Scan on compress_hyper_14_866_chunk -> Custom Scan (ColumnarScan) on _hyper_13_164_chunk r_133 -> Seq Scan on compress_hyper_14_867_chunk -> Custom Scan (ColumnarScan) on _hyper_13_165_chunk r_134 -> Seq Scan on compress_hyper_14_868_chunk -> Custom Scan (ColumnarScan) on _hyper_13_166_chunk r_135 -> Seq Scan on compress_hyper_14_869_chunk -> Custom Scan (ColumnarScan) on _hyper_13_167_chunk r_136 -> Seq Scan on compress_hyper_14_870_chunk -> Custom Scan (ColumnarScan) on _hyper_13_168_chunk r_137 -> Seq Scan on compress_hyper_14_871_chunk -> Custom Scan (ColumnarScan) on _hyper_13_169_chunk r_138 -> Seq Scan on compress_hyper_14_872_chunk -> Custom Scan (ColumnarScan) on _hyper_13_170_chunk r_139 -> Seq Scan on compress_hyper_14_873_chunk -> Custom Scan (ColumnarScan) on _hyper_13_171_chunk r_140 -> Seq Scan on compress_hyper_14_874_chunk -> Custom Scan (ColumnarScan) on _hyper_13_172_chunk r_141 -> Seq Scan on compress_hyper_14_875_chunk -> Custom Scan (ColumnarScan) on _hyper_13_173_chunk r_142 -> Seq Scan on compress_hyper_14_876_chunk -> Custom Scan (ColumnarScan) on _hyper_13_174_chunk r_143 -> Seq Scan on compress_hyper_14_877_chunk -> Custom Scan (ColumnarScan) on _hyper_13_175_chunk r_144 -> Seq Scan on compress_hyper_14_878_chunk -> Custom Scan (ColumnarScan) on _hyper_13_176_chunk r_145 -> Seq Scan on compress_hyper_14_879_chunk -> Custom Scan (ColumnarScan) on _hyper_13_177_chunk r_146 -> Seq Scan on compress_hyper_14_880_chunk -> Custom Scan (ColumnarScan) on _hyper_13_178_chunk r_147 -> Seq Scan on compress_hyper_14_881_chunk -> Custom Scan (ColumnarScan) on _hyper_13_179_chunk r_148 -> Seq Scan on compress_hyper_14_882_chunk -> Custom Scan (ColumnarScan) on _hyper_13_180_chunk r_149 -> Seq Scan on compress_hyper_14_883_chunk -> Custom Scan (ColumnarScan) on _hyper_13_181_chunk r_150 -> Seq Scan on compress_hyper_14_884_chunk -> Custom Scan (ColumnarScan) on _hyper_13_182_chunk r_151 -> Seq Scan on compress_hyper_14_885_chunk -> Custom Scan (ColumnarScan) on _hyper_13_183_chunk r_152 -> Seq Scan on compress_hyper_14_886_chunk -> Custom Scan (ColumnarScan) on _hyper_13_184_chunk r_153 -> Seq Scan on compress_hyper_14_887_chunk -> Custom Scan (ColumnarScan) on _hyper_13_185_chunk r_154 -> Seq Scan on compress_hyper_14_888_chunk -> Custom Scan (ColumnarScan) on _hyper_13_186_chunk r_155 -> Seq Scan on compress_hyper_14_889_chunk -> Custom Scan (ColumnarScan) on _hyper_13_187_chunk r_156 -> Seq Scan on compress_hyper_14_890_chunk -> Custom Scan (ColumnarScan) on _hyper_13_188_chunk r_157 -> Seq Scan on compress_hyper_14_891_chunk -> Custom Scan (ColumnarScan) on _hyper_13_189_chunk r_158 -> Seq Scan on compress_hyper_14_892_chunk -> Custom Scan (ColumnarScan) on _hyper_13_190_chunk r_159 -> Seq Scan on compress_hyper_14_893_chunk -> Custom Scan (ColumnarScan) on _hyper_13_191_chunk r_160 -> Seq Scan on compress_hyper_14_894_chunk -> Custom Scan (ColumnarScan) on _hyper_13_192_chunk r_161 -> Seq Scan on compress_hyper_14_895_chunk -> Custom Scan (ColumnarScan) on _hyper_13_193_chunk r_162 -> Seq Scan on compress_hyper_14_896_chunk -> Custom Scan (ColumnarScan) on _hyper_13_194_chunk r_163 -> Seq Scan on compress_hyper_14_897_chunk -> Custom Scan (ColumnarScan) on _hyper_13_195_chunk r_164 -> Seq Scan on compress_hyper_14_898_chunk -> Custom Scan (ColumnarScan) on _hyper_13_196_chunk r_165 -> Seq Scan on compress_hyper_14_899_chunk -> Custom Scan (ColumnarScan) on _hyper_13_197_chunk r_166 -> Seq Scan on compress_hyper_14_900_chunk -> Custom Scan (ColumnarScan) on _hyper_13_198_chunk r_167 -> Seq Scan on compress_hyper_14_901_chunk -> Custom Scan (ColumnarScan) on _hyper_13_199_chunk r_168 -> Seq Scan on compress_hyper_14_902_chunk -> Custom Scan (ColumnarScan) on _hyper_13_200_chunk r_169 -> Seq Scan on compress_hyper_14_903_chunk -> Custom Scan (ColumnarScan) on _hyper_13_201_chunk r_170 -> Seq Scan on compress_hyper_14_904_chunk -> Custom Scan (ColumnarScan) on _hyper_13_202_chunk r_171 -> Seq Scan on compress_hyper_14_905_chunk -> Custom Scan (ColumnarScan) on _hyper_13_203_chunk r_172 -> Seq Scan on compress_hyper_14_906_chunk -> Custom Scan (ColumnarScan) on _hyper_13_204_chunk r_173 -> Seq Scan on compress_hyper_14_907_chunk -> Custom Scan (ColumnarScan) on _hyper_13_205_chunk r_174 -> Seq Scan on compress_hyper_14_908_chunk -> Custom Scan (ColumnarScan) on _hyper_13_206_chunk r_175 -> Seq Scan on compress_hyper_14_909_chunk -> Custom Scan (ColumnarScan) on _hyper_13_207_chunk r_176 -> Seq Scan on compress_hyper_14_910_chunk -> Custom Scan (ColumnarScan) on _hyper_13_208_chunk r_177 -> Seq Scan on compress_hyper_14_911_chunk -> Custom Scan (ColumnarScan) on _hyper_13_209_chunk r_178 -> Seq Scan on compress_hyper_14_912_chunk -> Custom Scan (ColumnarScan) on _hyper_13_210_chunk r_179 -> Seq Scan on compress_hyper_14_913_chunk -> Custom Scan (ColumnarScan) on _hyper_13_211_chunk r_180 -> Seq Scan on compress_hyper_14_914_chunk -> Custom Scan (ColumnarScan) on _hyper_13_212_chunk r_181 -> Seq Scan on compress_hyper_14_915_chunk -> Custom Scan (ColumnarScan) on _hyper_13_213_chunk r_182 -> Seq Scan on compress_hyper_14_916_chunk -> Custom Scan (ColumnarScan) on _hyper_13_214_chunk r_183 -> Seq Scan on compress_hyper_14_917_chunk -> Custom Scan (ColumnarScan) on _hyper_13_215_chunk r_184 -> Seq Scan on compress_hyper_14_918_chunk -> Custom Scan (ColumnarScan) on _hyper_13_216_chunk r_185 -> Seq Scan on compress_hyper_14_919_chunk -> Custom Scan (ColumnarScan) on _hyper_13_217_chunk r_186 -> Seq Scan on compress_hyper_14_920_chunk -> Custom Scan (ColumnarScan) on _hyper_13_218_chunk r_187 -> Seq Scan on compress_hyper_14_921_chunk -> Custom Scan (ColumnarScan) on _hyper_13_219_chunk r_188 -> Seq Scan on compress_hyper_14_922_chunk -> Custom Scan (ColumnarScan) on _hyper_13_220_chunk r_189 -> Seq Scan on compress_hyper_14_923_chunk -> Custom Scan (ColumnarScan) on _hyper_13_221_chunk r_190 -> Seq Scan on compress_hyper_14_924_chunk -> Custom Scan (ColumnarScan) on _hyper_13_222_chunk r_191 -> Seq Scan on compress_hyper_14_925_chunk -> Custom Scan (ColumnarScan) on _hyper_13_223_chunk r_192 -> Seq Scan on compress_hyper_14_926_chunk -> Custom Scan (ColumnarScan) on _hyper_13_224_chunk r_193 -> Seq Scan on compress_hyper_14_927_chunk -> Custom Scan (ColumnarScan) on _hyper_13_225_chunk r_194 -> Seq Scan on compress_hyper_14_928_chunk -> Custom Scan (ColumnarScan) on _hyper_13_226_chunk r_195 -> Seq Scan on compress_hyper_14_929_chunk -> Custom Scan (ColumnarScan) on _hyper_13_227_chunk r_196 -> Seq Scan on compress_hyper_14_930_chunk -> Custom Scan (ColumnarScan) on _hyper_13_228_chunk r_197 -> Seq Scan on compress_hyper_14_931_chunk -> Custom Scan (ColumnarScan) on _hyper_13_229_chunk r_198 -> Seq Scan on compress_hyper_14_932_chunk -> Custom Scan (ColumnarScan) on _hyper_13_230_chunk r_199 -> Seq Scan on compress_hyper_14_933_chunk -> Custom Scan (ColumnarScan) on _hyper_13_231_chunk r_200 -> Seq Scan on compress_hyper_14_934_chunk -> Custom Scan (ColumnarScan) on _hyper_13_232_chunk r_201 -> Seq Scan on compress_hyper_14_935_chunk -> Custom Scan (ColumnarScan) on _hyper_13_233_chunk r_202 -> Seq Scan on compress_hyper_14_936_chunk -> Custom Scan (ColumnarScan) on _hyper_13_234_chunk r_203 -> Seq Scan on compress_hyper_14_937_chunk -> Custom Scan (ColumnarScan) on _hyper_13_235_chunk r_204 -> Seq Scan on compress_hyper_14_938_chunk -> Custom Scan (ColumnarScan) on _hyper_13_236_chunk r_205 -> Seq Scan on compress_hyper_14_939_chunk -> Custom Scan (ColumnarScan) on _hyper_13_237_chunk r_206 -> Seq Scan on compress_hyper_14_940_chunk -> Custom Scan (ColumnarScan) on _hyper_13_238_chunk r_207 -> Seq Scan on compress_hyper_14_941_chunk -> Custom Scan (ColumnarScan) on _hyper_13_239_chunk r_208 -> Seq Scan on compress_hyper_14_942_chunk -> Custom Scan (ColumnarScan) on _hyper_13_240_chunk r_209 -> Seq Scan on compress_hyper_14_943_chunk -> Custom Scan (ColumnarScan) on _hyper_13_241_chunk r_210 -> Seq Scan on compress_hyper_14_944_chunk -> Custom Scan (ColumnarScan) on _hyper_13_242_chunk r_211 -> Seq Scan on compress_hyper_14_945_chunk -> Custom Scan (ColumnarScan) on _hyper_13_243_chunk r_212 -> Seq Scan on compress_hyper_14_946_chunk -> Custom Scan (ColumnarScan) on _hyper_13_244_chunk r_213 -> Seq Scan on compress_hyper_14_947_chunk -> Custom Scan (ColumnarScan) on _hyper_13_245_chunk r_214 -> Seq Scan on compress_hyper_14_948_chunk -> Custom Scan (ColumnarScan) on _hyper_13_246_chunk r_215 -> Seq Scan on compress_hyper_14_949_chunk -> Custom Scan (ColumnarScan) on _hyper_13_247_chunk r_216 -> Seq Scan on compress_hyper_14_950_chunk -> Custom Scan (ColumnarScan) on _hyper_13_248_chunk r_217 -> Seq Scan on compress_hyper_14_951_chunk -> Custom Scan (ColumnarScan) on _hyper_13_249_chunk r_218 -> Seq Scan on compress_hyper_14_952_chunk -> Custom Scan (ColumnarScan) on _hyper_13_250_chunk r_219 -> Seq Scan on compress_hyper_14_953_chunk -> Custom Scan (ColumnarScan) on _hyper_13_251_chunk r_220 -> Seq Scan on compress_hyper_14_954_chunk -> Custom Scan (ColumnarScan) on _hyper_13_252_chunk r_221 -> Seq Scan on compress_hyper_14_955_chunk -> Custom Scan (ColumnarScan) on _hyper_13_253_chunk r_222 -> Seq Scan on compress_hyper_14_956_chunk -> Custom Scan (ColumnarScan) on _hyper_13_254_chunk r_223 -> Seq Scan on compress_hyper_14_957_chunk -> Custom Scan (ColumnarScan) on _hyper_13_255_chunk r_224 -> Seq Scan on compress_hyper_14_958_chunk -> Custom Scan (ColumnarScan) on _hyper_13_256_chunk r_225 -> Seq Scan on compress_hyper_14_959_chunk -> Custom Scan (ColumnarScan) on _hyper_13_257_chunk r_226 -> Seq Scan on compress_hyper_14_960_chunk -> Custom Scan (ColumnarScan) on _hyper_13_258_chunk r_227 -> Seq Scan on compress_hyper_14_961_chunk -> Custom Scan (ColumnarScan) on _hyper_13_259_chunk r_228 -> Seq Scan on compress_hyper_14_962_chunk -> Custom Scan (ColumnarScan) on _hyper_13_260_chunk r_229 -> Seq Scan on compress_hyper_14_963_chunk -> Custom Scan (ColumnarScan) on _hyper_13_261_chunk r_230 -> Seq Scan on compress_hyper_14_964_chunk -> Custom Scan (ColumnarScan) on _hyper_13_262_chunk r_231 -> Seq Scan on compress_hyper_14_965_chunk -> Custom Scan (ColumnarScan) on _hyper_13_263_chunk r_232 -> Seq Scan on compress_hyper_14_966_chunk -> Custom Scan (ColumnarScan) on _hyper_13_264_chunk r_233 -> Seq Scan on compress_hyper_14_967_chunk -> Custom Scan (ColumnarScan) on _hyper_13_265_chunk r_234 -> Seq Scan on compress_hyper_14_968_chunk -> Custom Scan (ColumnarScan) on _hyper_13_266_chunk r_235 -> Seq Scan on compress_hyper_14_969_chunk -> Custom Scan (ColumnarScan) on _hyper_13_267_chunk r_236 -> Seq Scan on compress_hyper_14_970_chunk -> Custom Scan (ColumnarScan) on _hyper_13_268_chunk r_237 -> Seq Scan on compress_hyper_14_971_chunk -> Custom Scan (ColumnarScan) on _hyper_13_269_chunk r_238 -> Seq Scan on compress_hyper_14_972_chunk -> Custom Scan (ColumnarScan) on _hyper_13_270_chunk r_239 -> Seq Scan on compress_hyper_14_973_chunk -> Custom Scan (ColumnarScan) on _hyper_13_271_chunk r_240 -> Seq Scan on compress_hyper_14_974_chunk -> Custom Scan (ColumnarScan) on _hyper_13_272_chunk r_241 -> Seq Scan on compress_hyper_14_975_chunk -> Custom Scan (ColumnarScan) on _hyper_13_273_chunk r_242 -> Seq Scan on compress_hyper_14_976_chunk -> Custom Scan (ColumnarScan) on _hyper_13_274_chunk r_243 -> Seq Scan on compress_hyper_14_977_chunk -> Custom Scan (ColumnarScan) on _hyper_13_275_chunk r_244 -> Seq Scan on compress_hyper_14_978_chunk -> Custom Scan (ColumnarScan) on _hyper_13_276_chunk r_245 -> Seq Scan on compress_hyper_14_979_chunk -> Custom Scan (ColumnarScan) on _hyper_13_277_chunk r_246 -> Seq Scan on compress_hyper_14_980_chunk -> Custom Scan (ColumnarScan) on _hyper_13_278_chunk r_247 -> Seq Scan on compress_hyper_14_981_chunk -> Custom Scan (ColumnarScan) on _hyper_13_279_chunk r_248 -> Seq Scan on compress_hyper_14_982_chunk -> Custom Scan (ColumnarScan) on _hyper_13_280_chunk r_249 -> Seq Scan on compress_hyper_14_983_chunk -> Custom Scan (ColumnarScan) on _hyper_13_281_chunk r_250 -> Seq Scan on compress_hyper_14_984_chunk -> Custom Scan (ColumnarScan) on _hyper_13_282_chunk r_251 -> Seq Scan on compress_hyper_14_985_chunk -> Custom Scan (ColumnarScan) on _hyper_13_283_chunk r_252 -> Seq Scan on compress_hyper_14_986_chunk -> Custom Scan (ColumnarScan) on _hyper_13_284_chunk r_253 -> Seq Scan on compress_hyper_14_987_chunk -> Custom Scan (ColumnarScan) on _hyper_13_285_chunk r_254 -> Seq Scan on compress_hyper_14_988_chunk -> Custom Scan (ColumnarScan) on _hyper_13_286_chunk r_255 -> Seq Scan on compress_hyper_14_989_chunk -> Custom Scan (ColumnarScan) on _hyper_13_287_chunk r_256 -> Seq Scan on compress_hyper_14_990_chunk -> Custom Scan (ColumnarScan) on _hyper_13_288_chunk r_257 -> Seq Scan on compress_hyper_14_991_chunk -> Custom Scan (ColumnarScan) on _hyper_13_289_chunk r_258 -> Seq Scan on compress_hyper_14_992_chunk -> Custom Scan (ColumnarScan) on _hyper_13_290_chunk r_259 -> Seq Scan on compress_hyper_14_993_chunk -> Custom Scan (ColumnarScan) on _hyper_13_291_chunk r_260 -> Seq Scan on compress_hyper_14_994_chunk -> Custom Scan (ColumnarScan) on _hyper_13_292_chunk r_261 -> Seq Scan on compress_hyper_14_995_chunk -> Custom Scan (ColumnarScan) on _hyper_13_293_chunk r_262 -> Seq Scan on compress_hyper_14_996_chunk -> Custom Scan (ColumnarScan) on _hyper_13_294_chunk r_263 -> Seq Scan on compress_hyper_14_997_chunk -> Custom Scan (ColumnarScan) on _hyper_13_295_chunk r_264 -> Seq Scan on compress_hyper_14_998_chunk -> Custom Scan (ColumnarScan) on _hyper_13_296_chunk r_265 -> Seq Scan on compress_hyper_14_999_chunk -> Custom Scan (ColumnarScan) on _hyper_13_297_chunk r_266 -> Seq Scan on compress_hyper_14_1000_chunk -> Custom Scan (ColumnarScan) on _hyper_13_298_chunk r_267 -> Seq Scan on compress_hyper_14_1001_chunk -> Custom Scan (ColumnarScan) on _hyper_13_299_chunk r_268 -> Seq Scan on compress_hyper_14_1002_chunk -> Custom Scan (ColumnarScan) on _hyper_13_300_chunk r_269 -> Seq Scan on compress_hyper_14_1003_chunk -> Custom Scan (ColumnarScan) on _hyper_13_301_chunk r_270 -> Seq Scan on compress_hyper_14_1004_chunk -> Custom Scan (ColumnarScan) on _hyper_13_302_chunk r_271 -> Seq Scan on compress_hyper_14_1005_chunk -> Custom Scan (ColumnarScan) on _hyper_13_303_chunk r_272 -> Seq Scan on compress_hyper_14_1006_chunk -> Custom Scan (ColumnarScan) on _hyper_13_304_chunk r_273 -> Seq Scan on compress_hyper_14_1007_chunk -> Custom Scan (ColumnarScan) on _hyper_13_305_chunk r_274 -> Seq Scan on compress_hyper_14_1008_chunk -> Custom Scan (ColumnarScan) on _hyper_13_306_chunk r_275 -> Seq Scan on compress_hyper_14_1009_chunk -> Custom Scan (ColumnarScan) on _hyper_13_307_chunk r_276 -> Seq Scan on compress_hyper_14_1010_chunk -> Custom Scan (ColumnarScan) on _hyper_13_308_chunk r_277 -> Seq Scan on compress_hyper_14_1011_chunk -> Custom Scan (ColumnarScan) on _hyper_13_309_chunk r_278 -> Seq Scan on compress_hyper_14_1012_chunk -> Custom Scan (ColumnarScan) on _hyper_13_310_chunk r_279 -> Seq Scan on compress_hyper_14_1013_chunk -> Custom Scan (ColumnarScan) on _hyper_13_311_chunk r_280 -> Seq Scan on compress_hyper_14_1014_chunk -> Custom Scan (ColumnarScan) on _hyper_13_312_chunk r_281 -> Seq Scan on compress_hyper_14_1015_chunk -> Custom Scan (ColumnarScan) on _hyper_13_313_chunk r_282 -> Seq Scan on compress_hyper_14_1016_chunk -> Custom Scan (ColumnarScan) on _hyper_13_314_chunk r_283 -> Seq Scan on compress_hyper_14_1017_chunk -> Custom Scan (ColumnarScan) on _hyper_13_315_chunk r_284 -> Seq Scan on compress_hyper_14_1018_chunk -> Custom Scan (ColumnarScan) on _hyper_13_316_chunk r_285 -> Seq Scan on compress_hyper_14_1019_chunk -> Custom Scan (ColumnarScan) on _hyper_13_317_chunk r_286 -> Seq Scan on compress_hyper_14_1020_chunk -> Custom Scan (ColumnarScan) on _hyper_13_318_chunk r_287 -> Seq Scan on compress_hyper_14_1021_chunk -> Custom Scan (ColumnarScan) on _hyper_13_319_chunk r_288 -> Seq Scan on compress_hyper_14_1022_chunk -> Custom Scan (ColumnarScan) on _hyper_13_320_chunk r_289 -> Seq Scan on compress_hyper_14_1023_chunk -> Custom Scan (ColumnarScan) on _hyper_13_321_chunk r_290 -> Seq Scan on compress_hyper_14_1024_chunk -> Custom Scan (ColumnarScan) on _hyper_13_322_chunk r_291 -> Seq Scan on compress_hyper_14_1025_chunk -> Custom Scan (ColumnarScan) on _hyper_13_323_chunk r_292 -> Seq Scan on compress_hyper_14_1026_chunk -> Custom Scan (ColumnarScan) on _hyper_13_324_chunk r_293 -> Seq Scan on compress_hyper_14_1027_chunk -> Custom Scan (ColumnarScan) on _hyper_13_325_chunk r_294 -> Seq Scan on compress_hyper_14_1028_chunk -> Custom Scan (ColumnarScan) on _hyper_13_326_chunk r_295 -> Seq Scan on compress_hyper_14_1029_chunk -> Custom Scan (ColumnarScan) on _hyper_13_327_chunk r_296 -> Seq Scan on compress_hyper_14_1030_chunk -> Custom Scan (ColumnarScan) on _hyper_13_328_chunk r_297 -> Seq Scan on compress_hyper_14_1031_chunk -> Custom Scan (ColumnarScan) on _hyper_13_329_chunk r_298 -> Seq Scan on compress_hyper_14_1032_chunk -> Custom Scan (ColumnarScan) on _hyper_13_330_chunk r_299 -> Seq Scan on compress_hyper_14_1033_chunk -> Custom Scan (ColumnarScan) on _hyper_13_331_chunk r_300 -> Seq Scan on compress_hyper_14_1034_chunk -> Custom Scan (ColumnarScan) on _hyper_13_332_chunk r_301 -> Seq Scan on compress_hyper_14_1035_chunk -> Custom Scan (ColumnarScan) on _hyper_13_333_chunk r_302 -> Seq Scan on compress_hyper_14_1036_chunk -> Custom Scan (ColumnarScan) on _hyper_13_334_chunk r_303 -> Seq Scan on compress_hyper_14_1037_chunk -> Custom Scan (ColumnarScan) on _hyper_13_335_chunk r_304 -> Seq Scan on compress_hyper_14_1038_chunk -> Custom Scan (ColumnarScan) on _hyper_13_336_chunk r_305 -> Seq Scan on compress_hyper_14_1039_chunk -> Custom Scan (ColumnarScan) on _hyper_13_337_chunk r_306 -> Seq Scan on compress_hyper_14_1040_chunk -> Custom Scan (ColumnarScan) on _hyper_13_338_chunk r_307 -> Seq Scan on compress_hyper_14_1041_chunk -> Custom Scan (ColumnarScan) on _hyper_13_339_chunk r_308 -> Seq Scan on compress_hyper_14_1042_chunk -> Custom Scan (ColumnarScan) on _hyper_13_340_chunk r_309 -> Seq Scan on compress_hyper_14_1043_chunk -> Custom Scan (ColumnarScan) on _hyper_13_341_chunk r_310 -> Seq Scan on compress_hyper_14_1044_chunk -> Custom Scan (ColumnarScan) on _hyper_13_342_chunk r_311 -> Seq Scan on compress_hyper_14_1045_chunk -> Custom Scan (ColumnarScan) on _hyper_13_343_chunk r_312 -> Seq Scan on compress_hyper_14_1046_chunk -> Custom Scan (ColumnarScan) on _hyper_13_344_chunk r_313 -> Seq Scan on compress_hyper_14_1047_chunk -> Custom Scan (ColumnarScan) on _hyper_13_345_chunk r_314 -> Seq Scan on compress_hyper_14_1048_chunk -> Custom Scan (ColumnarScan) on _hyper_13_346_chunk r_315 -> Seq Scan on compress_hyper_14_1049_chunk -> Custom Scan (ColumnarScan) on _hyper_13_347_chunk r_316 -> Seq Scan on compress_hyper_14_1050_chunk -> Custom Scan (ColumnarScan) on _hyper_13_348_chunk r_317 -> Seq Scan on compress_hyper_14_1051_chunk -> Custom Scan (ColumnarScan) on _hyper_13_349_chunk r_318 -> Seq Scan on compress_hyper_14_1052_chunk -> Custom Scan (ColumnarScan) on _hyper_13_350_chunk r_319 -> Seq Scan on compress_hyper_14_1053_chunk -> Custom Scan (ColumnarScan) on _hyper_13_351_chunk r_320 -> Seq Scan on compress_hyper_14_1054_chunk -> Custom Scan (ColumnarScan) on _hyper_13_352_chunk r_321 -> Seq Scan on compress_hyper_14_1055_chunk -> Custom Scan (ColumnarScan) on _hyper_13_353_chunk r_322 -> Seq Scan on compress_hyper_14_1056_chunk -> Custom Scan (ColumnarScan) on _hyper_13_354_chunk r_323 -> Seq Scan on compress_hyper_14_1057_chunk -> Custom Scan (ColumnarScan) on _hyper_13_355_chunk r_324 -> Seq Scan on compress_hyper_14_1058_chunk -> Custom Scan (ColumnarScan) on _hyper_13_356_chunk r_325 -> Seq Scan on compress_hyper_14_1059_chunk -> Custom Scan (ColumnarScan) on _hyper_13_357_chunk r_326 -> Seq Scan on compress_hyper_14_1060_chunk -> Custom Scan (ColumnarScan) on _hyper_13_358_chunk r_327 -> Seq Scan on compress_hyper_14_1061_chunk -> Custom Scan (ColumnarScan) on _hyper_13_359_chunk r_328 -> Seq Scan on compress_hyper_14_1062_chunk -> Custom Scan (ColumnarScan) on _hyper_13_360_chunk r_329 -> Seq Scan on compress_hyper_14_1063_chunk -> Custom Scan (ColumnarScan) on _hyper_13_361_chunk r_330 -> Seq Scan on compress_hyper_14_1064_chunk -> Custom Scan (ColumnarScan) on _hyper_13_362_chunk r_331 -> Seq Scan on compress_hyper_14_1065_chunk -> Custom Scan (ColumnarScan) on _hyper_13_363_chunk r_332 -> Seq Scan on compress_hyper_14_1066_chunk -> Custom Scan (ColumnarScan) on _hyper_13_364_chunk r_333 -> Seq Scan on compress_hyper_14_1067_chunk -> Custom Scan (ColumnarScan) on _hyper_13_365_chunk r_334 -> Seq Scan on compress_hyper_14_1068_chunk -> Custom Scan (ColumnarScan) on _hyper_13_366_chunk r_335 -> Seq Scan on compress_hyper_14_1069_chunk -> Custom Scan (ColumnarScan) on _hyper_13_367_chunk r_336 -> Seq Scan on compress_hyper_14_1070_chunk -> Custom Scan (ColumnarScan) on _hyper_13_368_chunk r_337 -> Seq Scan on compress_hyper_14_1071_chunk -> Custom Scan (ColumnarScan) on _hyper_13_369_chunk r_338 -> Seq Scan on compress_hyper_14_1072_chunk -> Custom Scan (ColumnarScan) on _hyper_13_370_chunk r_339 -> Seq Scan on compress_hyper_14_1073_chunk -> Custom Scan (ColumnarScan) on _hyper_13_371_chunk r_340 -> Seq Scan on compress_hyper_14_1074_chunk -> Custom Scan (ColumnarScan) on _hyper_13_372_chunk r_341 -> Seq Scan on compress_hyper_14_1075_chunk -> Custom Scan (ColumnarScan) on _hyper_13_373_chunk r_342 -> Seq Scan on compress_hyper_14_1076_chunk -> Custom Scan (ColumnarScan) on _hyper_13_374_chunk r_343 -> Seq Scan on compress_hyper_14_1077_chunk -> Custom Scan (ColumnarScan) on _hyper_13_375_chunk r_344 -> Seq Scan on compress_hyper_14_1078_chunk -> Custom Scan (ColumnarScan) on _hyper_13_376_chunk r_345 -> Seq Scan on compress_hyper_14_1079_chunk -> Custom Scan (ColumnarScan) on _hyper_13_377_chunk r_346 -> Seq Scan on compress_hyper_14_1080_chunk -> Custom Scan (ColumnarScan) on _hyper_13_378_chunk r_347 -> Seq Scan on compress_hyper_14_1081_chunk -> Custom Scan (ColumnarScan) on _hyper_13_379_chunk r_348 -> Seq Scan on compress_hyper_14_1082_chunk -> Custom Scan (ColumnarScan) on _hyper_13_380_chunk r_349 -> Seq Scan on compress_hyper_14_1083_chunk -> Custom Scan (ColumnarScan) on _hyper_13_381_chunk r_350 -> Seq Scan on compress_hyper_14_1084_chunk -> Custom Scan (ColumnarScan) on _hyper_13_382_chunk r_351 -> Seq Scan on compress_hyper_14_1085_chunk -> Custom Scan (ColumnarScan) on _hyper_13_383_chunk r_352 -> Seq Scan on compress_hyper_14_1086_chunk -> Custom Scan (ColumnarScan) on _hyper_13_384_chunk r_353 -> Seq Scan on compress_hyper_14_1087_chunk -> Custom Scan (ColumnarScan) on _hyper_13_385_chunk r_354 -> Seq Scan on compress_hyper_14_1088_chunk -> Custom Scan (ColumnarScan) on _hyper_13_386_chunk r_355 -> Seq Scan on compress_hyper_14_1089_chunk -> Custom Scan (ColumnarScan) on _hyper_13_387_chunk r_356 -> Seq Scan on compress_hyper_14_1090_chunk -> Custom Scan (ColumnarScan) on _hyper_13_388_chunk r_357 -> Seq Scan on compress_hyper_14_1091_chunk -> Custom Scan (ColumnarScan) on _hyper_13_389_chunk r_358 -> Seq Scan on compress_hyper_14_1092_chunk -> Custom Scan (ColumnarScan) on _hyper_13_390_chunk r_359 -> Seq Scan on compress_hyper_14_1093_chunk -> Custom Scan (ColumnarScan) on _hyper_13_391_chunk r_360 -> Seq Scan on compress_hyper_14_1094_chunk -> Custom Scan (ColumnarScan) on _hyper_13_392_chunk r_361 -> Seq Scan on compress_hyper_14_1095_chunk -> Custom Scan (ColumnarScan) on _hyper_13_393_chunk r_362 -> Seq Scan on compress_hyper_14_1096_chunk -> Custom Scan (ColumnarScan) on _hyper_13_394_chunk r_363 -> Seq Scan on compress_hyper_14_1097_chunk -> Custom Scan (ColumnarScan) on _hyper_13_395_chunk r_364 -> Seq Scan on compress_hyper_14_1098_chunk -> Custom Scan (ColumnarScan) on _hyper_13_396_chunk r_365 -> Seq Scan on compress_hyper_14_1099_chunk -> Custom Scan (ColumnarScan) on _hyper_13_397_chunk r_366 -> Seq Scan on compress_hyper_14_1100_chunk -> Custom Scan (ColumnarScan) on _hyper_13_398_chunk r_367 -> Seq Scan on compress_hyper_14_1101_chunk -> Custom Scan (ColumnarScan) on _hyper_13_399_chunk r_368 -> Seq Scan on compress_hyper_14_1102_chunk -> Custom Scan (ColumnarScan) on _hyper_13_400_chunk r_369 -> Seq Scan on compress_hyper_14_1103_chunk -> Custom Scan (ColumnarScan) on _hyper_13_401_chunk r_370 -> Seq Scan on compress_hyper_14_1104_chunk -> Custom Scan (ColumnarScan) on _hyper_13_402_chunk r_371 -> Seq Scan on compress_hyper_14_1105_chunk -> Custom Scan (ColumnarScan) on _hyper_13_403_chunk r_372 -> Seq Scan on compress_hyper_14_1106_chunk -> Custom Scan (ColumnarScan) on _hyper_13_404_chunk r_373 -> Seq Scan on compress_hyper_14_1107_chunk -> Custom Scan (ColumnarScan) on _hyper_13_405_chunk r_374 -> Seq Scan on compress_hyper_14_1108_chunk -> Custom Scan (ColumnarScan) on _hyper_13_406_chunk r_375 -> Seq Scan on compress_hyper_14_1109_chunk -> Custom Scan (ColumnarScan) on _hyper_13_407_chunk r_376 -> Seq Scan on compress_hyper_14_1110_chunk -> Custom Scan (ColumnarScan) on _hyper_13_408_chunk r_377 -> Seq Scan on compress_hyper_14_1111_chunk -> Custom Scan (ColumnarScan) on _hyper_13_409_chunk r_378 -> Seq Scan on compress_hyper_14_1112_chunk -> Custom Scan (ColumnarScan) on _hyper_13_410_chunk r_379 -> Seq Scan on compress_hyper_14_1113_chunk -> Custom Scan (ColumnarScan) on _hyper_13_411_chunk r_380 -> Seq Scan on compress_hyper_14_1114_chunk -> Custom Scan (ColumnarScan) on _hyper_13_412_chunk r_381 -> Seq Scan on compress_hyper_14_1115_chunk -> Custom Scan (ColumnarScan) on _hyper_13_413_chunk r_382 -> Seq Scan on compress_hyper_14_1116_chunk -> Custom Scan (ColumnarScan) on _hyper_13_414_chunk r_383 -> Seq Scan on compress_hyper_14_1117_chunk -> Custom Scan (ColumnarScan) on _hyper_13_415_chunk r_384 -> Seq Scan on compress_hyper_14_1118_chunk -> Custom Scan (ColumnarScan) on _hyper_13_416_chunk r_385 -> Seq Scan on compress_hyper_14_1119_chunk -> Custom Scan (ColumnarScan) on _hyper_13_417_chunk r_386 -> Seq Scan on compress_hyper_14_1120_chunk -> Custom Scan (ColumnarScan) on _hyper_13_418_chunk r_387 -> Seq Scan on compress_hyper_14_1121_chunk -> Custom Scan (ColumnarScan) on _hyper_13_419_chunk r_388 -> Seq Scan on compress_hyper_14_1122_chunk -> Custom Scan (ColumnarScan) on _hyper_13_420_chunk r_389 -> Seq Scan on compress_hyper_14_1123_chunk -> Custom Scan (ColumnarScan) on _hyper_13_421_chunk r_390 -> Seq Scan on compress_hyper_14_1124_chunk -> Custom Scan (ColumnarScan) on _hyper_13_422_chunk r_391 -> Seq Scan on compress_hyper_14_1125_chunk -> Custom Scan (ColumnarScan) on _hyper_13_423_chunk r_392 -> Seq Scan on compress_hyper_14_1126_chunk -> Custom Scan (ColumnarScan) on _hyper_13_424_chunk r_393 -> Seq Scan on compress_hyper_14_1127_chunk -> Custom Scan (ColumnarScan) on _hyper_13_425_chunk r_394 -> Seq Scan on compress_hyper_14_1128_chunk -> Custom Scan (ColumnarScan) on _hyper_13_426_chunk r_395 -> Seq Scan on compress_hyper_14_1129_chunk -> Custom Scan (ColumnarScan) on _hyper_13_427_chunk r_396 -> Seq Scan on compress_hyper_14_1130_chunk -> Custom Scan (ColumnarScan) on _hyper_13_428_chunk r_397 -> Seq Scan on compress_hyper_14_1131_chunk -> Custom Scan (ColumnarScan) on _hyper_13_429_chunk r_398 -> Seq Scan on compress_hyper_14_1132_chunk -> Custom Scan (ColumnarScan) on _hyper_13_430_chunk r_399 -> Seq Scan on compress_hyper_14_1133_chunk -> Custom Scan (ColumnarScan) on _hyper_13_431_chunk r_400 -> Seq Scan on compress_hyper_14_1134_chunk -> Custom Scan (ColumnarScan) on _hyper_13_432_chunk r_401 -> Seq Scan on compress_hyper_14_1135_chunk -> Custom Scan (ColumnarScan) on _hyper_13_433_chunk r_402 -> Seq Scan on compress_hyper_14_1136_chunk -> Custom Scan (ColumnarScan) on _hyper_13_434_chunk r_403 -> Seq Scan on compress_hyper_14_1137_chunk -> Custom Scan (ColumnarScan) on _hyper_13_435_chunk r_404 -> Seq Scan on compress_hyper_14_1138_chunk -> Custom Scan (ColumnarScan) on _hyper_13_436_chunk r_405 -> Seq Scan on compress_hyper_14_1139_chunk -> Custom Scan (ColumnarScan) on _hyper_13_437_chunk r_406 -> Seq Scan on compress_hyper_14_1140_chunk -> Custom Scan (ColumnarScan) on _hyper_13_438_chunk r_407 -> Seq Scan on compress_hyper_14_1141_chunk -> Custom Scan (ColumnarScan) on _hyper_13_439_chunk r_408 -> Seq Scan on compress_hyper_14_1142_chunk -> Custom Scan (ColumnarScan) on _hyper_13_440_chunk r_409 -> Seq Scan on compress_hyper_14_1143_chunk -> Custom Scan (ColumnarScan) on _hyper_13_441_chunk r_410 -> Seq Scan on compress_hyper_14_1144_chunk -> Custom Scan (ColumnarScan) on _hyper_13_442_chunk r_411 -> Seq Scan on compress_hyper_14_1145_chunk -> Custom Scan (ColumnarScan) on _hyper_13_443_chunk r_412 -> Seq Scan on compress_hyper_14_1146_chunk -> Custom Scan (ColumnarScan) on _hyper_13_444_chunk r_413 -> Seq Scan on compress_hyper_14_1147_chunk -> Custom Scan (ColumnarScan) on _hyper_13_445_chunk r_414 -> Seq Scan on compress_hyper_14_1148_chunk -> Custom Scan (ColumnarScan) on _hyper_13_446_chunk r_415 -> Seq Scan on compress_hyper_14_1149_chunk -> Custom Scan (ColumnarScan) on _hyper_13_447_chunk r_416 -> Seq Scan on compress_hyper_14_1150_chunk -> Custom Scan (ColumnarScan) on _hyper_13_448_chunk r_417 -> Seq Scan on compress_hyper_14_1151_chunk -> Custom Scan (ColumnarScan) on _hyper_13_449_chunk r_418 -> Seq Scan on compress_hyper_14_1152_chunk -> Custom Scan (ColumnarScan) on _hyper_13_450_chunk r_419 -> Seq Scan on compress_hyper_14_1153_chunk -> Custom Scan (ColumnarScan) on _hyper_13_451_chunk r_420 -> Seq Scan on compress_hyper_14_1154_chunk -> Custom Scan (ColumnarScan) on _hyper_13_452_chunk r_421 -> Seq Scan on compress_hyper_14_1155_chunk -> Custom Scan (ColumnarScan) on _hyper_13_453_chunk r_422 -> Seq Scan on compress_hyper_14_1156_chunk -> Custom Scan (ColumnarScan) on _hyper_13_454_chunk r_423 -> Seq Scan on compress_hyper_14_1157_chunk -> Custom Scan (ColumnarScan) on _hyper_13_455_chunk r_424 -> Seq Scan on compress_hyper_14_1158_chunk -> Custom Scan (ColumnarScan) on _hyper_13_456_chunk r_425 -> Seq Scan on compress_hyper_14_1159_chunk -> Custom Scan (ColumnarScan) on _hyper_13_457_chunk r_426 -> Seq Scan on compress_hyper_14_1160_chunk -> Custom Scan (ColumnarScan) on _hyper_13_458_chunk r_427 -> Seq Scan on compress_hyper_14_1161_chunk -> Custom Scan (ColumnarScan) on _hyper_13_459_chunk r_428 -> Seq Scan on compress_hyper_14_1162_chunk -> Custom Scan (ColumnarScan) on _hyper_13_460_chunk r_429 -> Seq Scan on compress_hyper_14_1163_chunk -> Custom Scan (ColumnarScan) on _hyper_13_461_chunk r_430 -> Seq Scan on compress_hyper_14_1164_chunk -> Custom Scan (ColumnarScan) on _hyper_13_462_chunk r_431 -> Seq Scan on compress_hyper_14_1165_chunk -> Custom Scan (ColumnarScan) on _hyper_13_463_chunk r_432 -> Seq Scan on compress_hyper_14_1166_chunk -> Custom Scan (ColumnarScan) on _hyper_13_464_chunk r_433 -> Seq Scan on compress_hyper_14_1167_chunk -> Custom Scan (ColumnarScan) on _hyper_13_465_chunk r_434 -> Seq Scan on compress_hyper_14_1168_chunk -> Custom Scan (ColumnarScan) on _hyper_13_466_chunk r_435 -> Seq Scan on compress_hyper_14_1169_chunk -> Custom Scan (ColumnarScan) on _hyper_13_467_chunk r_436 -> Seq Scan on compress_hyper_14_1170_chunk -> Custom Scan (ColumnarScan) on _hyper_13_468_chunk r_437 -> Seq Scan on compress_hyper_14_1171_chunk -> Custom Scan (ColumnarScan) on _hyper_13_469_chunk r_438 -> Seq Scan on compress_hyper_14_1172_chunk -> Custom Scan (ColumnarScan) on _hyper_13_470_chunk r_439 -> Seq Scan on compress_hyper_14_1173_chunk -> Custom Scan (ColumnarScan) on _hyper_13_471_chunk r_440 -> Seq Scan on compress_hyper_14_1174_chunk -> Custom Scan (ColumnarScan) on _hyper_13_472_chunk r_441 -> Seq Scan on compress_hyper_14_1175_chunk -> Custom Scan (ColumnarScan) on _hyper_13_473_chunk r_442 -> Seq Scan on compress_hyper_14_1176_chunk -> Custom Scan (ColumnarScan) on _hyper_13_474_chunk r_443 -> Seq Scan on compress_hyper_14_1177_chunk -> Custom Scan (ColumnarScan) on _hyper_13_475_chunk r_444 -> Seq Scan on compress_hyper_14_1178_chunk -> Custom Scan (ColumnarScan) on _hyper_13_476_chunk r_445 -> Seq Scan on compress_hyper_14_1179_chunk -> Custom Scan (ColumnarScan) on _hyper_13_477_chunk r_446 -> Seq Scan on compress_hyper_14_1180_chunk -> Custom Scan (ColumnarScan) on _hyper_13_478_chunk r_447 -> Seq Scan on compress_hyper_14_1181_chunk -> Custom Scan (ColumnarScan) on _hyper_13_479_chunk r_448 -> Seq Scan on compress_hyper_14_1182_chunk -> Custom Scan (ColumnarScan) on _hyper_13_480_chunk r_449 -> Seq Scan on compress_hyper_14_1183_chunk -> Custom Scan (ColumnarScan) on _hyper_13_481_chunk r_450 -> Seq Scan on compress_hyper_14_1184_chunk -> Custom Scan (ColumnarScan) on _hyper_13_482_chunk r_451 -> Seq Scan on compress_hyper_14_1185_chunk -> Custom Scan (ColumnarScan) on _hyper_13_483_chunk r_452 -> Seq Scan on compress_hyper_14_1186_chunk -> Custom Scan (ColumnarScan) on _hyper_13_484_chunk r_453 -> Seq Scan on compress_hyper_14_1187_chunk -> Custom Scan (ColumnarScan) on _hyper_13_485_chunk r_454 -> Seq Scan on compress_hyper_14_1188_chunk -> Custom Scan (ColumnarScan) on _hyper_13_486_chunk r_455 -> Seq Scan on compress_hyper_14_1189_chunk -> Custom Scan (ColumnarScan) on _hyper_13_487_chunk r_456 -> Seq Scan on compress_hyper_14_1190_chunk -> Custom Scan (ColumnarScan) on _hyper_13_488_chunk r_457 -> Seq Scan on compress_hyper_14_1191_chunk -> Custom Scan (ColumnarScan) on _hyper_13_489_chunk r_458 -> Seq Scan on compress_hyper_14_1192_chunk -> Custom Scan (ColumnarScan) on _hyper_13_490_chunk r_459 -> Seq Scan on compress_hyper_14_1193_chunk -> Custom Scan (ColumnarScan) on _hyper_13_491_chunk r_460 -> Seq Scan on compress_hyper_14_1194_chunk -> Custom Scan (ColumnarScan) on _hyper_13_492_chunk r_461 -> Seq Scan on compress_hyper_14_1195_chunk -> Custom Scan (ColumnarScan) on _hyper_13_493_chunk r_462 -> Seq Scan on compress_hyper_14_1196_chunk -> Custom Scan (ColumnarScan) on _hyper_13_494_chunk r_463 -> Seq Scan on compress_hyper_14_1197_chunk -> Custom Scan (ColumnarScan) on _hyper_13_495_chunk r_464 -> Seq Scan on compress_hyper_14_1198_chunk -> Custom Scan (ColumnarScan) on _hyper_13_496_chunk r_465 -> Seq Scan on compress_hyper_14_1199_chunk -> Custom Scan (ColumnarScan) on _hyper_13_497_chunk r_466 -> Seq Scan on compress_hyper_14_1200_chunk -> Custom Scan (ColumnarScan) on _hyper_13_498_chunk r_467 -> Seq Scan on compress_hyper_14_1201_chunk -> Custom Scan (ColumnarScan) on _hyper_13_499_chunk r_468 -> Seq Scan on compress_hyper_14_1202_chunk -> Custom Scan (ColumnarScan) on _hyper_13_500_chunk r_469 -> Seq Scan on compress_hyper_14_1203_chunk -> Custom Scan (ColumnarScan) on _hyper_13_501_chunk r_470 -> Seq Scan on compress_hyper_14_1204_chunk -> Custom Scan (ColumnarScan) on _hyper_13_502_chunk r_471 -> Seq Scan on compress_hyper_14_1205_chunk -> Custom Scan (ColumnarScan) on _hyper_13_503_chunk r_472 -> Seq Scan on compress_hyper_14_1206_chunk -> Custom Scan (ColumnarScan) on _hyper_13_504_chunk r_473 -> Seq Scan on compress_hyper_14_1207_chunk -> Custom Scan (ColumnarScan) on _hyper_13_505_chunk r_474 -> Seq Scan on compress_hyper_14_1208_chunk -> Custom Scan (ColumnarScan) on _hyper_13_506_chunk r_475 -> Seq Scan on compress_hyper_14_1209_chunk -> Custom Scan (ColumnarScan) on _hyper_13_507_chunk r_476 -> Seq Scan on compress_hyper_14_1210_chunk -> Custom Scan (ColumnarScan) on _hyper_13_508_chunk r_477 -> Seq Scan on compress_hyper_14_1211_chunk -> Custom Scan (ColumnarScan) on _hyper_13_509_chunk r_478 -> Seq Scan on compress_hyper_14_1212_chunk -> Custom Scan (ColumnarScan) on _hyper_13_510_chunk r_479 -> Seq Scan on compress_hyper_14_1213_chunk -> Custom Scan (ColumnarScan) on _hyper_13_511_chunk r_480 -> Seq Scan on compress_hyper_14_1214_chunk -> Custom Scan (ColumnarScan) on _hyper_13_512_chunk r_481 -> Seq Scan on compress_hyper_14_1215_chunk -> Custom Scan (ColumnarScan) on _hyper_13_513_chunk r_482 -> Seq Scan on compress_hyper_14_1216_chunk -> Custom Scan (ColumnarScan) on _hyper_13_514_chunk r_483 -> Seq Scan on compress_hyper_14_1217_chunk -> Custom Scan (ColumnarScan) on _hyper_13_515_chunk r_484 -> Seq Scan on compress_hyper_14_1218_chunk -> Custom Scan (ColumnarScan) on _hyper_13_516_chunk r_485 -> Seq Scan on compress_hyper_14_1219_chunk -> Custom Scan (ColumnarScan) on _hyper_13_517_chunk r_486 -> Seq Scan on compress_hyper_14_1220_chunk -> Custom Scan (ColumnarScan) on _hyper_13_518_chunk r_487 -> Seq Scan on compress_hyper_14_1221_chunk -> Custom Scan (ColumnarScan) on _hyper_13_519_chunk r_488 -> Seq Scan on compress_hyper_14_1222_chunk -> Custom Scan (ColumnarScan) on _hyper_13_520_chunk r_489 -> Seq Scan on compress_hyper_14_1223_chunk -> Custom Scan (ColumnarScan) on _hyper_13_521_chunk r_490 -> Seq Scan on compress_hyper_14_1224_chunk -> Custom Scan (ColumnarScan) on _hyper_13_522_chunk r_491 -> Seq Scan on compress_hyper_14_1225_chunk -> Custom Scan (ColumnarScan) on _hyper_13_523_chunk r_492 -> Seq Scan on compress_hyper_14_1226_chunk -> Custom Scan (ColumnarScan) on _hyper_13_524_chunk r_493 -> Seq Scan on compress_hyper_14_1227_chunk -> Custom Scan (ColumnarScan) on _hyper_13_525_chunk r_494 -> Seq Scan on compress_hyper_14_1228_chunk -> Custom Scan (ColumnarScan) on _hyper_13_526_chunk r_495 -> Seq Scan on compress_hyper_14_1229_chunk -> Custom Scan (ColumnarScan) on _hyper_13_527_chunk r_496 -> Seq Scan on compress_hyper_14_1230_chunk -> Custom Scan (ColumnarScan) on _hyper_13_528_chunk r_497 -> Seq Scan on compress_hyper_14_1231_chunk -> Custom Scan (ColumnarScan) on _hyper_13_529_chunk r_498 -> Seq Scan on compress_hyper_14_1232_chunk -> Custom Scan (ColumnarScan) on _hyper_13_530_chunk r_499 -> Seq Scan on compress_hyper_14_1233_chunk -> Custom Scan (ColumnarScan) on _hyper_13_531_chunk r_500 -> Seq Scan on compress_hyper_14_1234_chunk -> Custom Scan (ColumnarScan) on _hyper_13_532_chunk r_501 -> Seq Scan on compress_hyper_14_1235_chunk -> Custom Scan (ColumnarScan) on _hyper_13_533_chunk r_502 -> Seq Scan on compress_hyper_14_1236_chunk -> Custom Scan (ColumnarScan) on _hyper_13_534_chunk r_503 -> Seq Scan on compress_hyper_14_1237_chunk -> Custom Scan (ColumnarScan) on _hyper_13_535_chunk r_504 -> Seq Scan on compress_hyper_14_1238_chunk -> Custom Scan (ColumnarScan) on _hyper_13_536_chunk r_505 -> Seq Scan on compress_hyper_14_1239_chunk -> Custom Scan (ColumnarScan) on _hyper_13_537_chunk r_506 -> Seq Scan on compress_hyper_14_1240_chunk -> Custom Scan (ColumnarScan) on _hyper_13_538_chunk r_507 -> Seq Scan on compress_hyper_14_1241_chunk -> Custom Scan (ColumnarScan) on _hyper_13_539_chunk r_508 -> Seq Scan on compress_hyper_14_1242_chunk -> Custom Scan (ColumnarScan) on _hyper_13_540_chunk r_509 -> Seq Scan on compress_hyper_14_1243_chunk -> Custom Scan (ColumnarScan) on _hyper_13_541_chunk r_510 -> Seq Scan on compress_hyper_14_1244_chunk -> Custom Scan (ColumnarScan) on _hyper_13_542_chunk r_511 -> Seq Scan on compress_hyper_14_1245_chunk -> Custom Scan (ColumnarScan) on _hyper_13_543_chunk r_512 -> Seq Scan on compress_hyper_14_1246_chunk -> Custom Scan (ColumnarScan) on _hyper_13_544_chunk r_513 -> Seq Scan on compress_hyper_14_1247_chunk -> Custom Scan (ColumnarScan) on _hyper_13_545_chunk r_514 -> Seq Scan on compress_hyper_14_1248_chunk -> Custom Scan (ColumnarScan) on _hyper_13_546_chunk r_515 -> Seq Scan on compress_hyper_14_1249_chunk -> Custom Scan (ColumnarScan) on _hyper_13_547_chunk r_516 -> Seq Scan on compress_hyper_14_1250_chunk -> Custom Scan (ColumnarScan) on _hyper_13_548_chunk r_517 -> Seq Scan on compress_hyper_14_1251_chunk -> Custom Scan (ColumnarScan) on _hyper_13_549_chunk r_518 -> Seq Scan on compress_hyper_14_1252_chunk -> Custom Scan (ColumnarScan) on _hyper_13_550_chunk r_519 -> Seq Scan on compress_hyper_14_1253_chunk -> Custom Scan (ColumnarScan) on _hyper_13_551_chunk r_520 -> Seq Scan on compress_hyper_14_1254_chunk -> Custom Scan (ColumnarScan) on _hyper_13_552_chunk r_521 -> Seq Scan on compress_hyper_14_1255_chunk -> Custom Scan (ColumnarScan) on _hyper_13_553_chunk r_522 -> Seq Scan on compress_hyper_14_1256_chunk -> Custom Scan (ColumnarScan) on _hyper_13_554_chunk r_523 -> Seq Scan on compress_hyper_14_1257_chunk -> Custom Scan (ColumnarScan) on _hyper_13_555_chunk r_524 -> Seq Scan on compress_hyper_14_1258_chunk -> Custom Scan (ColumnarScan) on _hyper_13_556_chunk r_525 -> Seq Scan on compress_hyper_14_1259_chunk -> Custom Scan (ColumnarScan) on _hyper_13_557_chunk r_526 -> Seq Scan on compress_hyper_14_1260_chunk -> Custom Scan (ColumnarScan) on _hyper_13_558_chunk r_527 -> Seq Scan on compress_hyper_14_1261_chunk -> Custom Scan (ColumnarScan) on _hyper_13_559_chunk r_528 -> Seq Scan on compress_hyper_14_1262_chunk -> Custom Scan (ColumnarScan) on _hyper_13_560_chunk r_529 -> Seq Scan on compress_hyper_14_1263_chunk -> Custom Scan (ColumnarScan) on _hyper_13_561_chunk r_530 -> Seq Scan on compress_hyper_14_1264_chunk -> Custom Scan (ColumnarScan) on _hyper_13_562_chunk r_531 -> Seq Scan on compress_hyper_14_1265_chunk -> Custom Scan (ColumnarScan) on _hyper_13_563_chunk r_532 -> Seq Scan on compress_hyper_14_1266_chunk -> Custom Scan (ColumnarScan) on _hyper_13_564_chunk r_533 -> Seq Scan on compress_hyper_14_1267_chunk -> Custom Scan (ColumnarScan) on _hyper_13_565_chunk r_534 -> Seq Scan on compress_hyper_14_1268_chunk -> Custom Scan (ColumnarScan) on _hyper_13_566_chunk r_535 -> Seq Scan on compress_hyper_14_1269_chunk -> Custom Scan (ColumnarScan) on _hyper_13_567_chunk r_536 -> Seq Scan on compress_hyper_14_1270_chunk -> Custom Scan (ColumnarScan) on _hyper_13_568_chunk r_537 -> Seq Scan on compress_hyper_14_1271_chunk -> Custom Scan (ColumnarScan) on _hyper_13_569_chunk r_538 -> Seq Scan on compress_hyper_14_1272_chunk -> Custom Scan (ColumnarScan) on _hyper_13_570_chunk r_539 -> Seq Scan on compress_hyper_14_1273_chunk -> Custom Scan (ColumnarScan) on _hyper_13_571_chunk r_540 -> Seq Scan on compress_hyper_14_1274_chunk -> Custom Scan (ColumnarScan) on _hyper_13_572_chunk r_541 -> Seq Scan on compress_hyper_14_1275_chunk -> Custom Scan (ColumnarScan) on _hyper_13_573_chunk r_542 -> Seq Scan on compress_hyper_14_1276_chunk -> Custom Scan (ColumnarScan) on _hyper_13_574_chunk r_543 -> Seq Scan on compress_hyper_14_1277_chunk -> Custom Scan (ColumnarScan) on _hyper_13_575_chunk r_544 -> Seq Scan on compress_hyper_14_1278_chunk -> Custom Scan (ColumnarScan) on _hyper_13_576_chunk r_545 -> Seq Scan on compress_hyper_14_1279_chunk -> Custom Scan (ColumnarScan) on _hyper_13_577_chunk r_546 -> Seq Scan on compress_hyper_14_1280_chunk -> Custom Scan (ColumnarScan) on _hyper_13_578_chunk r_547 -> Seq Scan on compress_hyper_14_1281_chunk -> Custom Scan (ColumnarScan) on _hyper_13_579_chunk r_548 -> Seq Scan on compress_hyper_14_1282_chunk -> Custom Scan (ColumnarScan) on _hyper_13_580_chunk r_549 -> Seq Scan on compress_hyper_14_1283_chunk -> Custom Scan (ColumnarScan) on _hyper_13_581_chunk r_550 -> Seq Scan on compress_hyper_14_1284_chunk -> Custom Scan (ColumnarScan) on _hyper_13_582_chunk r_551 -> Seq Scan on compress_hyper_14_1285_chunk -> Custom Scan (ColumnarScan) on _hyper_13_583_chunk r_552 -> Seq Scan on compress_hyper_14_1286_chunk -> Custom Scan (ColumnarScan) on _hyper_13_584_chunk r_553 -> Seq Scan on compress_hyper_14_1287_chunk -> Custom Scan (ColumnarScan) on _hyper_13_585_chunk r_554 -> Seq Scan on compress_hyper_14_1288_chunk -> Custom Scan (ColumnarScan) on _hyper_13_586_chunk r_555 -> Seq Scan on compress_hyper_14_1289_chunk -> Custom Scan (ColumnarScan) on _hyper_13_587_chunk r_556 -> Seq Scan on compress_hyper_14_1290_chunk -> Custom Scan (ColumnarScan) on _hyper_13_588_chunk r_557 -> Seq Scan on compress_hyper_14_1291_chunk -> Custom Scan (ColumnarScan) on _hyper_13_589_chunk r_558 -> Seq Scan on compress_hyper_14_1292_chunk -> Custom Scan (ColumnarScan) on _hyper_13_590_chunk r_559 -> Seq Scan on compress_hyper_14_1293_chunk -> Custom Scan (ColumnarScan) on _hyper_13_591_chunk r_560 -> Seq Scan on compress_hyper_14_1294_chunk -> Custom Scan (ColumnarScan) on _hyper_13_592_chunk r_561 -> Seq Scan on compress_hyper_14_1295_chunk -> Custom Scan (ColumnarScan) on _hyper_13_593_chunk r_562 -> Seq Scan on compress_hyper_14_1296_chunk -> Custom Scan (ColumnarScan) on _hyper_13_594_chunk r_563 -> Seq Scan on compress_hyper_14_1297_chunk -> Custom Scan (ColumnarScan) on _hyper_13_595_chunk r_564 -> Seq Scan on compress_hyper_14_1298_chunk -> Custom Scan (ColumnarScan) on _hyper_13_596_chunk r_565 -> Seq Scan on compress_hyper_14_1299_chunk -> Custom Scan (ColumnarScan) on _hyper_13_597_chunk r_566 -> Seq Scan on compress_hyper_14_1300_chunk -> Custom Scan (ColumnarScan) on _hyper_13_598_chunk r_567 -> Seq Scan on compress_hyper_14_1301_chunk -> Custom Scan (ColumnarScan) on _hyper_13_599_chunk r_568 -> Seq Scan on compress_hyper_14_1302_chunk -> Custom Scan (ColumnarScan) on _hyper_13_600_chunk r_569 -> Seq Scan on compress_hyper_14_1303_chunk -> Custom Scan (ColumnarScan) on _hyper_13_601_chunk r_570 -> Seq Scan on compress_hyper_14_1304_chunk -> Custom Scan (ColumnarScan) on _hyper_13_602_chunk r_571 -> Seq Scan on compress_hyper_14_1305_chunk -> Custom Scan (ColumnarScan) on _hyper_13_603_chunk r_572 -> Seq Scan on compress_hyper_14_1306_chunk -> Custom Scan (ColumnarScan) on _hyper_13_604_chunk r_573 -> Seq Scan on compress_hyper_14_1307_chunk -> Custom Scan (ColumnarScan) on _hyper_13_605_chunk r_574 -> Seq Scan on compress_hyper_14_1308_chunk -> Custom Scan (ColumnarScan) on _hyper_13_606_chunk r_575 -> Seq Scan on compress_hyper_14_1309_chunk -> Custom Scan (ColumnarScan) on _hyper_13_607_chunk r_576 -> Seq Scan on compress_hyper_14_1310_chunk -> Custom Scan (ColumnarScan) on _hyper_13_608_chunk r_577 -> Seq Scan on compress_hyper_14_1311_chunk -> Custom Scan (ColumnarScan) on _hyper_13_609_chunk r_578 -> Seq Scan on compress_hyper_14_1312_chunk -> Custom Scan (ColumnarScan) on _hyper_13_610_chunk r_579 -> Seq Scan on compress_hyper_14_1313_chunk -> Custom Scan (ColumnarScan) on _hyper_13_611_chunk r_580 -> Seq Scan on compress_hyper_14_1314_chunk -> Custom Scan (ColumnarScan) on _hyper_13_612_chunk r_581 -> Seq Scan on compress_hyper_14_1315_chunk -> Custom Scan (ColumnarScan) on _hyper_13_613_chunk r_582 -> Seq Scan on compress_hyper_14_1316_chunk -> Custom Scan (ColumnarScan) on _hyper_13_614_chunk r_583 -> Seq Scan on compress_hyper_14_1317_chunk -> Custom Scan (ColumnarScan) on _hyper_13_615_chunk r_584 -> Seq Scan on compress_hyper_14_1318_chunk -> Custom Scan (ColumnarScan) on _hyper_13_616_chunk r_585 -> Seq Scan on compress_hyper_14_1319_chunk -> Custom Scan (ColumnarScan) on _hyper_13_617_chunk r_586 -> Seq Scan on compress_hyper_14_1320_chunk -> Custom Scan (ColumnarScan) on _hyper_13_618_chunk r_587 -> Seq Scan on compress_hyper_14_1321_chunk -> Custom Scan (ColumnarScan) on _hyper_13_619_chunk r_588 -> Seq Scan on compress_hyper_14_1322_chunk -> Custom Scan (ColumnarScan) on _hyper_13_620_chunk r_589 -> Seq Scan on compress_hyper_14_1323_chunk -> Custom Scan (ColumnarScan) on _hyper_13_621_chunk r_590 -> Seq Scan on compress_hyper_14_1324_chunk -> Custom Scan (ColumnarScan) on _hyper_13_622_chunk r_591 -> Seq Scan on compress_hyper_14_1325_chunk -> Custom Scan (ColumnarScan) on _hyper_13_623_chunk r_592 -> Seq Scan on compress_hyper_14_1326_chunk -> Custom Scan (ColumnarScan) on _hyper_13_624_chunk r_593 -> Seq Scan on compress_hyper_14_1327_chunk -> Custom Scan (ColumnarScan) on _hyper_13_625_chunk r_594 -> Seq Scan on compress_hyper_14_1328_chunk -> Custom Scan (ColumnarScan) on _hyper_13_626_chunk r_595 -> Seq Scan on compress_hyper_14_1329_chunk -> Custom Scan (ColumnarScan) on _hyper_13_627_chunk r_596 -> Seq Scan on compress_hyper_14_1330_chunk -> Custom Scan (ColumnarScan) on _hyper_13_628_chunk r_597 -> Seq Scan on compress_hyper_14_1331_chunk -> Custom Scan (ColumnarScan) on _hyper_13_629_chunk r_598 -> Seq Scan on compress_hyper_14_1332_chunk -> Custom Scan (ColumnarScan) on _hyper_13_630_chunk r_599 -> Seq Scan on compress_hyper_14_1333_chunk -> Custom Scan (ColumnarScan) on _hyper_13_631_chunk r_600 -> Seq Scan on compress_hyper_14_1334_chunk -> Custom Scan (ColumnarScan) on _hyper_13_632_chunk r_601 -> Seq Scan on compress_hyper_14_1335_chunk -> Custom Scan (ColumnarScan) on _hyper_13_633_chunk r_602 -> Seq Scan on compress_hyper_14_1336_chunk -> Custom Scan (ColumnarScan) on _hyper_13_634_chunk r_603 -> Seq Scan on compress_hyper_14_1337_chunk -> Custom Scan (ColumnarScan) on _hyper_13_635_chunk r_604 -> Seq Scan on compress_hyper_14_1338_chunk -> Custom Scan (ColumnarScan) on _hyper_13_636_chunk r_605 -> Seq Scan on compress_hyper_14_1339_chunk -> Custom Scan (ColumnarScan) on _hyper_13_637_chunk r_606 -> Seq Scan on compress_hyper_14_1340_chunk -> Custom Scan (ColumnarScan) on _hyper_13_638_chunk r_607 -> Seq Scan on compress_hyper_14_1341_chunk -> Custom Scan (ColumnarScan) on _hyper_13_639_chunk r_608 -> Seq Scan on compress_hyper_14_1342_chunk -> Custom Scan (ColumnarScan) on _hyper_13_640_chunk r_609 -> Seq Scan on compress_hyper_14_1343_chunk -> Custom Scan (ColumnarScan) on _hyper_13_641_chunk r_610 -> Seq Scan on compress_hyper_14_1344_chunk -> Custom Scan (ColumnarScan) on _hyper_13_642_chunk r_611 -> Seq Scan on compress_hyper_14_1345_chunk -> Custom Scan (ColumnarScan) on _hyper_13_643_chunk r_612 -> Seq Scan on compress_hyper_14_1346_chunk -> Custom Scan (ColumnarScan) on _hyper_13_644_chunk r_613 -> Seq Scan on compress_hyper_14_1347_chunk -> Custom Scan (ColumnarScan) on _hyper_13_645_chunk r_614 -> Seq Scan on compress_hyper_14_1348_chunk -> Custom Scan (ColumnarScan) on _hyper_13_646_chunk r_615 -> Seq Scan on compress_hyper_14_1349_chunk -> Custom Scan (ColumnarScan) on _hyper_13_647_chunk r_616 -> Seq Scan on compress_hyper_14_1350_chunk -> Custom Scan (ColumnarScan) on _hyper_13_648_chunk r_617 -> Seq Scan on compress_hyper_14_1351_chunk -> Custom Scan (ColumnarScan) on _hyper_13_649_chunk r_618 -> Seq Scan on compress_hyper_14_1352_chunk -> Custom Scan (ColumnarScan) on _hyper_13_650_chunk r_619 -> Seq Scan on compress_hyper_14_1353_chunk -> Custom Scan (ColumnarScan) on _hyper_13_651_chunk r_620 -> Seq Scan on compress_hyper_14_1354_chunk -> Custom Scan (ColumnarScan) on _hyper_13_652_chunk r_621 -> Seq Scan on compress_hyper_14_1355_chunk -> Custom Scan (ColumnarScan) on _hyper_13_653_chunk r_622 -> Seq Scan on compress_hyper_14_1356_chunk -> Custom Scan (ColumnarScan) on _hyper_13_654_chunk r_623 -> Seq Scan on compress_hyper_14_1357_chunk -> Custom Scan (ColumnarScan) on _hyper_13_655_chunk r_624 -> Seq Scan on compress_hyper_14_1358_chunk -> Custom Scan (ColumnarScan) on _hyper_13_656_chunk r_625 -> Seq Scan on compress_hyper_14_1359_chunk -> Custom Scan (ColumnarScan) on _hyper_13_657_chunk r_626 -> Seq Scan on compress_hyper_14_1360_chunk -> Custom Scan (ColumnarScan) on _hyper_13_658_chunk r_627 -> Seq Scan on compress_hyper_14_1361_chunk -> Custom Scan (ColumnarScan) on _hyper_13_659_chunk r_628 -> Seq Scan on compress_hyper_14_1362_chunk -> Custom Scan (ColumnarScan) on _hyper_13_660_chunk r_629 -> Seq Scan on compress_hyper_14_1363_chunk -> Custom Scan (ColumnarScan) on _hyper_13_661_chunk r_630 -> Seq Scan on compress_hyper_14_1364_chunk -> Custom Scan (ColumnarScan) on _hyper_13_662_chunk r_631 -> Seq Scan on compress_hyper_14_1365_chunk -> Custom Scan (ColumnarScan) on _hyper_13_663_chunk r_632 -> Seq Scan on compress_hyper_14_1366_chunk -> Custom Scan (ColumnarScan) on _hyper_13_664_chunk r_633 -> Seq Scan on compress_hyper_14_1367_chunk -> Custom Scan (ColumnarScan) on _hyper_13_665_chunk r_634 -> Seq Scan on compress_hyper_14_1368_chunk -> Custom Scan (ColumnarScan) on _hyper_13_666_chunk r_635 -> Seq Scan on compress_hyper_14_1369_chunk -> Custom Scan (ColumnarScan) on _hyper_13_667_chunk r_636 -> Seq Scan on compress_hyper_14_1370_chunk -> Custom Scan (ColumnarScan) on _hyper_13_668_chunk r_637 -> Seq Scan on compress_hyper_14_1371_chunk -> Custom Scan (ColumnarScan) on _hyper_13_669_chunk r_638 -> Seq Scan on compress_hyper_14_1372_chunk -> Custom Scan (ColumnarScan) on _hyper_13_670_chunk r_639 -> Seq Scan on compress_hyper_14_1373_chunk -> Custom Scan (ColumnarScan) on _hyper_13_671_chunk r_640 -> Seq Scan on compress_hyper_14_1374_chunk -> Custom Scan (ColumnarScan) on _hyper_13_672_chunk r_641 -> Seq Scan on compress_hyper_14_1375_chunk -> Custom Scan (ColumnarScan) on _hyper_13_673_chunk r_642 -> Seq Scan on compress_hyper_14_1376_chunk -> Custom Scan (ColumnarScan) on _hyper_13_674_chunk r_643 -> Seq Scan on compress_hyper_14_1377_chunk -> Custom Scan (ColumnarScan) on _hyper_13_675_chunk r_644 -> Seq Scan on compress_hyper_14_1378_chunk -> Custom Scan (ColumnarScan) on _hyper_13_676_chunk r_645 -> Seq Scan on compress_hyper_14_1379_chunk -> Custom Scan (ColumnarScan) on _hyper_13_677_chunk r_646 -> Seq Scan on compress_hyper_14_1380_chunk -> Custom Scan (ColumnarScan) on _hyper_13_678_chunk r_647 -> Seq Scan on compress_hyper_14_1381_chunk -> Custom Scan (ColumnarScan) on _hyper_13_679_chunk r_648 -> Seq Scan on compress_hyper_14_1382_chunk -> Custom Scan (ColumnarScan) on _hyper_13_680_chunk r_649 -> Seq Scan on compress_hyper_14_1383_chunk -> Custom Scan (ColumnarScan) on _hyper_13_681_chunk r_650 -> Seq Scan on compress_hyper_14_1384_chunk -> Custom Scan (ColumnarScan) on _hyper_13_682_chunk r_651 -> Seq Scan on compress_hyper_14_1385_chunk -> Custom Scan (ColumnarScan) on _hyper_13_683_chunk r_652 -> Seq Scan on compress_hyper_14_1386_chunk -> Custom Scan (ColumnarScan) on _hyper_13_684_chunk r_653 -> Seq Scan on compress_hyper_14_1387_chunk -> Custom Scan (ColumnarScan) on _hyper_13_685_chunk r_654 -> Seq Scan on compress_hyper_14_1388_chunk -> Custom Scan (ColumnarScan) on _hyper_13_686_chunk r_655 -> Seq Scan on compress_hyper_14_1389_chunk -> Custom Scan (ColumnarScan) on _hyper_13_687_chunk r_656 -> Seq Scan on compress_hyper_14_1390_chunk -> Custom Scan (ColumnarScan) on _hyper_13_688_chunk r_657 -> Seq Scan on compress_hyper_14_1391_chunk -> Custom Scan (ColumnarScan) on _hyper_13_689_chunk r_658 -> Seq Scan on compress_hyper_14_1392_chunk -> Custom Scan (ColumnarScan) on _hyper_13_690_chunk r_659 -> Seq Scan on compress_hyper_14_1393_chunk -> Custom Scan (ColumnarScan) on _hyper_13_691_chunk r_660 -> Seq Scan on compress_hyper_14_1394_chunk -> Custom Scan (ColumnarScan) on _hyper_13_692_chunk r_661 -> Seq Scan on compress_hyper_14_1395_chunk -> Custom Scan (ColumnarScan) on _hyper_13_693_chunk r_662 -> Seq Scan on compress_hyper_14_1396_chunk -> Custom Scan (ColumnarScan) on _hyper_13_694_chunk r_663 -> Seq Scan on compress_hyper_14_1397_chunk -> Custom Scan (ColumnarScan) on _hyper_13_695_chunk r_664 -> Seq Scan on compress_hyper_14_1398_chunk -> Custom Scan (ColumnarScan) on _hyper_13_696_chunk r_665 -> Seq Scan on compress_hyper_14_1399_chunk -> Custom Scan (ColumnarScan) on _hyper_13_697_chunk r_666 -> Seq Scan on compress_hyper_14_1400_chunk -> Custom Scan (ColumnarScan) on _hyper_13_698_chunk r_667 -> Seq Scan on compress_hyper_14_1401_chunk -> Custom Scan (ColumnarScan) on _hyper_13_699_chunk r_668 -> Seq Scan on compress_hyper_14_1402_chunk -> Custom Scan (ColumnarScan) on _hyper_13_700_chunk r_669 -> Seq Scan on compress_hyper_14_1403_chunk -> Custom Scan (ColumnarScan) on _hyper_13_701_chunk r_670 -> Seq Scan on compress_hyper_14_1404_chunk -> Custom Scan (ColumnarScan) on _hyper_13_702_chunk r_671 -> Seq Scan on compress_hyper_14_1405_chunk -> Custom Scan (ColumnarScan) on _hyper_13_703_chunk r_672 -> Seq Scan on compress_hyper_14_1406_chunk -> Custom Scan (ColumnarScan) on _hyper_13_704_chunk r_673 -> Seq Scan on compress_hyper_14_1407_chunk -> Custom Scan (ColumnarScan) on _hyper_13_705_chunk r_674 -> Seq Scan on compress_hyper_14_1408_chunk -> Custom Scan (ColumnarScan) on _hyper_13_706_chunk r_675 -> Seq Scan on compress_hyper_14_1409_chunk -> Custom Scan (ColumnarScan) on _hyper_13_707_chunk r_676 -> Seq Scan on compress_hyper_14_1410_chunk -> Custom Scan (ColumnarScan) on _hyper_13_708_chunk r_677 -> Seq Scan on compress_hyper_14_1411_chunk -> Custom Scan (ColumnarScan) on _hyper_13_709_chunk r_678 -> Seq Scan on compress_hyper_14_1412_chunk -> Custom Scan (ColumnarScan) on _hyper_13_710_chunk r_679 -> Seq Scan on compress_hyper_14_1413_chunk -> Custom Scan (ColumnarScan) on _hyper_13_711_chunk r_680 -> Seq Scan on compress_hyper_14_1414_chunk -> Custom Scan (ColumnarScan) on _hyper_13_712_chunk r_681 -> Seq Scan on compress_hyper_14_1415_chunk -> Custom Scan (ColumnarScan) on _hyper_13_713_chunk r_682 -> Seq Scan on compress_hyper_14_1416_chunk -> Custom Scan (ColumnarScan) on _hyper_13_714_chunk r_683 -> Seq Scan on compress_hyper_14_1417_chunk -> Custom Scan (ColumnarScan) on _hyper_13_715_chunk r_684 -> Seq Scan on compress_hyper_14_1418_chunk -> Custom Scan (ColumnarScan) on _hyper_13_716_chunk r_685 -> Seq Scan on compress_hyper_14_1419_chunk -> Custom Scan (ColumnarScan) on _hyper_13_717_chunk r_686 -> Seq Scan on compress_hyper_14_1420_chunk -> Custom Scan (ColumnarScan) on _hyper_13_718_chunk r_687 -> Seq Scan on compress_hyper_14_1421_chunk -> Custom Scan (ColumnarScan) on _hyper_13_719_chunk r_688 -> Seq Scan on compress_hyper_14_1422_chunk -> Custom Scan (ColumnarScan) on _hyper_13_720_chunk r_689 -> Seq Scan on compress_hyper_14_1423_chunk -> Custom Scan (ColumnarScan) on _hyper_13_721_chunk r_690 -> Seq Scan on compress_hyper_14_1424_chunk -> Custom Scan (ColumnarScan) on _hyper_13_722_chunk r_691 -> Seq Scan on compress_hyper_14_1425_chunk -> Custom Scan (ColumnarScan) on _hyper_13_723_chunk r_692 -> Seq Scan on compress_hyper_14_1426_chunk -> Custom Scan (ColumnarScan) on _hyper_13_724_chunk r_693 -> Seq Scan on compress_hyper_14_1427_chunk -> Custom Scan (ColumnarScan) on _hyper_13_725_chunk r_694 -> Seq Scan on compress_hyper_14_1428_chunk -> Custom Scan (ColumnarScan) on _hyper_13_726_chunk r_695 -> Seq Scan on compress_hyper_14_1429_chunk -> Custom Scan (ColumnarScan) on _hyper_13_727_chunk r_696 -> Seq Scan on compress_hyper_14_1430_chunk -> Custom Scan (ColumnarScan) on _hyper_13_728_chunk r_697 -> Seq Scan on compress_hyper_14_1431_chunk -> Custom Scan (ColumnarScan) on _hyper_13_729_chunk r_698 -> Seq Scan on compress_hyper_14_1432_chunk -> Custom Scan (ColumnarScan) on _hyper_13_730_chunk r_699 -> Seq Scan on compress_hyper_14_1433_chunk -> Custom Scan (ColumnarScan) on _hyper_13_731_chunk r_700 -> Seq Scan on compress_hyper_14_1434_chunk -> Custom Scan (ColumnarScan) on _hyper_13_732_chunk r_701 -> Seq Scan on compress_hyper_14_1435_chunk -> Custom Scan (ColumnarScan) on _hyper_13_733_chunk r_702 -> Seq Scan on compress_hyper_14_1436_chunk -> Custom Scan (ColumnarScan) on _hyper_13_734_chunk r_703 -> Seq Scan on compress_hyper_14_1437_chunk -> Hash -> Seq Scan on tags t -- run query with parallel enabled to ensure nothing is preventing parallel execution -- this is just a sanity check, the result queries dont run with parallel disabled SET max_parallel_workers_per_gather TO 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SET min_parallel_table_scan_size TO '0'; EXPLAIN (buffers off, costs off) SELECT * FROM metrics ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 3 -> Sort Sort Key: metrics."time", metrics.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT time_bucket('10 minutes', time) bucket, avg(v0) avg_v0 FROM metrics GROUP BY bucket; --- QUERY PLAN --- Finalize HashAggregate Group Key: (time_bucket('@ 10 mins'::interval, metrics."time")) -> Gather Workers Planned: 3 -> Parallel Append -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_1_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Parallel Seq Scan on compress_hyper_5_15_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_3_chunk."time") -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Parallel Seq Scan on compress_hyper_5_16_chunk -> Partial HashAggregate Group Key: time_bucket('@ 10 mins'::interval, _hyper_1_2_chunk."time") -> Parallel Seq Scan on _hyper_1_2_chunk EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space ORDER BY time, device_id; --- QUERY PLAN --- Gather Merge Workers Planned: 4 -> Sort Sort Key: metrics_space."time", metrics_space.device_id -> Parallel Append -> Custom Scan (ColumnarScan) on _hyper_2_4_chunk -> Parallel Seq Scan on compress_hyper_6_17_chunk -> Custom Scan (ColumnarScan) on _hyper_2_6_chunk -> Parallel Seq Scan on compress_hyper_6_19_chunk -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk -> Parallel Seq Scan on compress_hyper_6_20_chunk -> Custom Scan (ColumnarScan) on _hyper_2_5_chunk -> Parallel Seq Scan on compress_hyper_6_18_chunk -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk -> Parallel Seq Scan on compress_hyper_6_21_chunk -> Parallel Seq Scan on _hyper_2_8_chunk -> Parallel Seq Scan on _hyper_2_7_chunk -> Parallel Seq Scan on _hyper_2_9_chunk -> Parallel Seq Scan on _hyper_2_12_chunk RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; SET enable_seqscan TO false; -- should order compressed chunks using index -- (we only EXPLAIN here b/c the resulting order is too inconsistent) EXPLAIN (buffers off, costs off) SELECT * FROM metrics WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics.device_id -> Sort Sort Key: _hyper_1_2_chunk.device_id -> Index Scan using _hyper_1_2_chunk_metrics_time_idx on _hyper_1_2_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_5_16_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_5_16_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space WHERE time > '2000-01-08' ORDER BY device_id; --- QUERY PLAN --- Merge Append Sort Key: metrics_space.device_id -> Index Scan using _hyper_2_7_chunk_metrics_space_device_id_time_idx on _hyper_2_7_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_8_chunk_metrics_space_device_id_time_idx on _hyper_2_8_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_9_chunk_metrics_space_device_id_time_idx on _hyper_2_9_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_10_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_20_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_20_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_2_11_chunk Vectorized Filter: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using compress_hyper_6_21_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_6_21_chunk Index Cond: (_ts_meta_max_3 > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_2_12_chunk_metrics_space_device_id_time_idx on _hyper_2_12_chunk Index Cond: ("time" > 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) SET enable_seqscan TO true; -- diff compressed and uncompressed results :DIFF_CMD -- check hypertable detection in views CREATE VIEW ht_view AS SELECT *, 0 AS res FROM metrics UNION ALL SELECT *, 1 AS res FROM metrics; CREATE FUNCTION ht_func() RETURNS SETOF metrics LANGUAGE SQL STABLE AS $sql$ SELECT time, device_id, device_id_peer, v0, v1, v2, v3 FROM ht_view WHERE res = 0; $sql$; -- should have decompresschunk node :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) \c SET enable_incremental_sort TO off; -- plan should be identical to previous plan in fresh session :PREFIX SELECT * FROM ht_func(); --- QUERY PLAN --- Append (actual rows=8640.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=3600.00 loops=1) -> Seq Scan on compress_hyper_5_15_chunk (actual rows=5.00 loops=1) -> Seq Scan on _hyper_1_2_chunk (actual rows=3360.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=1680.00 loops=1) -> Seq Scan on compress_hyper_5_16_chunk (actual rows=5.00 loops=1) -- repro for core dump related to total_table_pages setting that get -- adjusted during decompress path. CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE motion_table( id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass) , datalogger_id bigint , vessel_id bigint , bus_id smallint , src_id smallint , dataloggertime timestamp with time zone , interval_s real ); CREATE INDEX motion_table_t2_datalogger_id_idx on motion_table (datalogger_id); CREATE INDEX motion_table_t2_dataloggertime_idx on motion_table(dataloggertime DESC); CREATE INDEX motion_table_t2_vessel_id_idx on motion_table(vessel_id); SELECT create_hypertable( 'motion_table', 'dataloggertime', chunk_time_interval=> '7 days'::interval); create_hypertable ---------------------------- (15,public,motion_table,t) --- do not modify the data. We need atleast this volume to reproduce issues with pages/tuple counts etc. --- INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), random() , random() , generate_series( '2020-01-02 10:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), 2, 3, generate_series( '2020-01-10 8:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; ALTER TABLE motion_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'vessel_id, datalogger_id, bus_id, src_id' , timescaledb.compress_orderby = 'dataloggertime' ); --have 2 chunks -- SELECT COUNT(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table'; count ------- 2 -- compress only the first one --- SELECT compress_chunk( chunk_table) FROM ( SELECT chunk_schema || '.' || chunk_name as chunk_table FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table' ORDER BY range_start limit 1 ) q; compress_chunk -------------------------------------------- _timescaledb_internal._hyper_15_1438_chunk --call to decompress chunk on 1 of the chunks SELECT count(*) from motion_table; count ------- 11642 --END of test for page settings CREATE TABLE repro(time timestamptz NOT NULL, device_id text, room_id text NOT NULL, score_type int NOT NULL, algorithm_version text NOT NULL, adjusted_score float NOT NULL); SELECT create_hypertable('repro','time'); create_hypertable --------------------- (17,public,repro,t) ALTER TABLE repro SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, room_id, score_type, algorithm_version', timescaledb.compress_orderby='"time" DESC' ); SELECT _timescaledb_functions.create_chunk('repro','{"time": [1717632000000000,1718236800000000]}'); create_chunk ------------------------------------------------------------------------------------------------------------- (1441,17,_timescaledb_internal,_hyper_17_1441_chunk,r,"{""time"": [1717632000000000, 1718236800000000]}",t) select compress_chunk(show_chunks('repro')); compress_chunk -------------------------------------------- _timescaledb_internal._hyper_17_1441_chunk select from repro where room_id = 'foo' order by device_id, algorithm_version, score_type, time desc; -- ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_join_index.out�����������������������0000664�0000000�0000000�00000011216�15100345067�0027670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- github issue 5585 create table test ( time timestamptz not null, a varchar(255) not null, b int, c int ); SELECT create_hypertable('test', 'time'); WARNING: column type "character varying" used for "a" does not follow best practices create_hypertable ------------------- (1,public,test,t) insert into test values ('2020-01-01 00:00'::timestamptz, 'lat', 1, 2), ('2020-01-01 00:01'::timestamptz, 'lat', 1, 2), ('2020-01-01 00:01'::timestamptz, 'lat', 2, 2), ('2020-01-01 00:03'::timestamptz, 'lat', 1, 2), ('2020-01-01 00:01'::timestamptz, 'lon', 1, 2); create table test_copy as select * from test; -- compress the chunk alter table test set (timescaledb.compress, timescaledb.compress_segmentby='a, b'); select compress_chunk(show_chunks('test')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk -- force an index scan set enable_seqscan = 'off'; -- make some tweaks to avoid flakiness analyze test; analyze test_copy; set enable_hashagg = off; set enable_sort to off; set jit = off; set max_parallel_workers_per_gather = 0; explain (buffers off, costs off) with query_params as ( select distinct a, b from test_copy where test_copy.a IN ('lat', 'lon') and test_copy.b IN (1) ) select test.time, test.a = q.a as "this should never be false", test.a, test.b, test.c, q.* from test inner join query_params q on q.a = test.a and q.b = test.b where test.time between '2020-01-01 00:00' and '2020-01-01 00:02' order by test.time; --- QUERY PLAN --- Nested Loop Join Filter: (((_hyper_1_1_chunk.a)::text = (test_copy.a)::text) AND (_hyper_1_1_chunk.b = test_copy.b)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Filter: (("time" >= 'Wed Jan 01 00:00:00 2020 PST'::timestamp with time zone) AND ("time" <= 'Wed Jan 01 00:02:00 2020 PST'::timestamp with time zone)) -> Sort Sort Key: compress_hyper_2_2_chunk._ts_meta_min_1 -> Index Scan using compress_hyper_2_2_chunk_a_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_2_chunk Index Cond: ((_ts_meta_min_1 <= 'Wed Jan 01 00:02:00 2020 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Wed Jan 01 00:00:00 2020 PST'::timestamp with time zone)) -> Materialize -> Unique -> Sort Sort Key: test_copy.a -> Seq Scan on test_copy Filter: (((a)::text = ANY ('{lat,lon}'::text[])) AND (b = 1)) with query_params as ( select distinct a, b from test_copy where test_copy.a IN ('lat', 'lon') and test_copy.b IN (1) ) select test.time, test.a = q.a as "this should never be false", test.a, test.b, test.c, q.* from test inner join query_params q on q.a = test.a and q.b = test.b where test.time between '2020-01-01 00:00' and '2020-01-01 00:02' order by test.time; time | this should never be false | a | b | c | a | b ------------------------------+----------------------------+-----+---+---+-----+--- Wed Jan 01 00:00:00 2020 PST | t | lat | 1 | 2 | lat | 1 Wed Jan 01 00:01:00 2020 PST | t | lat | 1 | 2 | lat | 1 Wed Jan 01 00:01:00 2020 PST | t | lon | 1 | 2 | lon | 1 -- Also test outer join for better coverage of nullability handling. -- This test case generates a nullable equivalence member for test.b. explain (buffers off, costs off) with query_params as ( select distinct a, b + 1 as b from test_copy where test_copy.a IN ('lat', 'lon') ) select test.a, test.b from test full join query_params q on q.a = test.a full join query_params q2 on q2.b = test.b ; --- QUERY PLAN --- Hash Full Join Hash Cond: (_hyper_1_1_chunk.b = q2.b) CTE query_params -> Unique -> Sort Sort Key: test_copy.a, ((test_copy.b + 1)) -> Seq Scan on test_copy Filter: ((a)::text = ANY ('{lat,lon}'::text[])) -> Hash Full Join Hash Cond: ((_hyper_1_1_chunk.a)::text = (q.a)::text) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_2_chunk_a_b__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_2_chunk -> Hash -> CTE Scan on query_params q -> Hash -> CTE Scan on query_params q2 reset enable_seqscan; reset jit; drop table test; drop table test_copy; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_ordered_index-15.out�����������������0000664�0000000�0000000�00000220214�15100345067�0030600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression_ordered_index SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u -- %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- Testing Index Scan backwards ---- -- We want more than 1 segment in atleast 1 of the chunks CREATE TABLE metrics_ordered_idx ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int ); SELECT create_hypertable ('metrics_ordered_idx', 'time', chunk_time_interval => '2days'::interval); create_hypertable ---------------------------------- (1,public,metrics_ordered_idx,t) ALTER TABLE metrics_ordered_idx SET (timescaledb.compress, timescaledb.compress_orderby = 'time ASC', timescaledb.compress_segmentby = 'device_id,device_id_peer'); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT time, device_id, 0, device_id FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-15 23:55:00+0', '15m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz, '2000-01-20 11:55:00+0', '15m'), 3, 3, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2018-01-20 0:00:00+0'::timestamptz, '2018-01-20 11:55:00+0', '15m'), 4, 5, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT '2020-01-01 0:00:00+0', generate_series(4, 7, 1), 5, generate_series(1, 5, 1); -- misisng values device_id = 7 CREATE TABLE device_tbl ( device_id int, descr text ); INSERT INTO device_tbl SELECT generate_series(1, 6, 1), 'devicex'; INSERT INTO device_tbl SELECT 8, 'device8'; ANALYZE device_tbl; -- table for joins --- CREATE TABLE nodetime ( node int, start_time timestamp, stop_time timestamp ); INSERT INTO nodetime VALUES (4, '2018-01-06 00:00'::timestamp, '2018-12-02 12:00'::timestamp); VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' -- Unfortunately the ECHO cannot be redirected to the output file. \set ECHO none --compress all chunks for metrics_ordered_idx table -- SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx') ch; count ------- 5 -- reindexing compressed hypertable to update statistics DO $$ DECLARE hyper_id int; BEGIN SELECT h.compressed_hypertable_id INTO hyper_id FROM _timescaledb_catalog.hypertable h WHERE h.table_name = 'metrics_ordered_idx'; EXECUTE format('REINDEX TABLE _timescaledb_internal._compressed_hypertable_%s', hyper_id); END; $$; VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none -- diff compressed and uncompressed results :DIFF_CMD -- This is to illustrate that we have some null device_id values. This fact -- might influence the runtime chunk exclusion when doing joins on device_id. select count(*) from metrics_ordered_idx where extract(minute from time) = 0 and device_id is null ; count ------- 1 \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; SET enable_seqscan = FALSE; -- get explain for queries on hypertable with compression \ir include/transparent_decompression_ordered_indexplan.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- tests for explain plan only -- ---check index backward scans instead of seq scans ------------ CREATE TABLE metrics_ordered_idx2(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int); SELECT create_hypertable('metrics_ordered_idx2','time', chunk_time_interval=>'2days'::interval); create_hypertable ----------------------------------- (3,public,metrics_ordered_idx2,t) ALTER TABLE metrics_ordered_idx2 SET (timescaledb.compress, timescaledb.compress_orderby='time ASC, v0 desc',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered_idx2(time,device_id,device_id_peer,v0, v1) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz,'2000-01-20 11:55:00+0','10s') , 3, 3, generate_series(1,5,1) , generate_series(555,559,1); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx2') ch; count ------- 1 VACUUM ANALYZE metrics_ordered_idx2; --all queries have only prefix of compress_orderby in ORDER BY clause -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 asc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC, compress_hyper_4_12_chunk._ts_meta_min_2, compress_hyper_4_12_chunk._ts_meta_max_2 Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 desc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_3_11_chunk."time" DESC, _hyper_3_11_chunk.v0 DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=4291.00 loops=1) -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx2 d INNER JOIN LATERAL (SELECT * FROM metrics_ordered_idx2 m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON m.device_id_peer = d.device_id_peer; --- QUERY PLAN --- Nested Loop (actual rows=4291.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk d (actual rows=4291.00 loops=1) -> Seq Scan on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=1.00 loops=4291) Filter: (d.device_id_peer = m.device_id_peer) -> Limit (actual rows=1.00 loops=4291) -> Result (actual rows=1.00 loops=4291) -> Custom Scan (ChunkAppend) on metrics_ordered_idx2 m_1 (actual rows=1.00 loops=4291) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk m_2 (actual rows=1.00 loops=4291) -> Index Scan Backward using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk compress_hyper_4_12_chunk_1 (actual rows=1.00 loops=4291) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) SET enable_seqscan = FALSE; \ir include/transparent_decompression_ordered_index.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; ---Lets test for index backward scans instead of seq scans ------------ -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_8_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_8_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_7_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_6_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 DESC, compress_hyper_2_8_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 DESC, compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=12.00 loops=1) Sort Key: d.device_id Sort Method: quicksort -> Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.00 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.00 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.00 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.00 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.00 loops=389) -> Result (actual rows=0.00 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.00 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) --github issue 1558 SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT device_id, count(*) FROM ( SELECT * FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time) AS subq GROUP BY device_id; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: mt.device_id -> Nested Loop (actual rows=48.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (mt.device_id = nd.node)) Rows Removed by Join Filter: 1493 -> Merge Append (actual rows=1541.00 loops=1) Sort Key: mt.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Materialize (actual rows=1.00 loops=1541) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Nested Loop (actual rows=48.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (mt.device_id = nd.node)) Rows Removed by Join Filter: 1493 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1541.00 loops=1) Order: mt."time" -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Materialize (actual rows=1.00 loops=1541) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_mergejoin = TRUE; SET enable_hashjoin = FALSE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Merge Join (actual rows=48.00 loops=1) Merge Cond: (nd.node = mt.device_id) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Sort (actual rows=1.00 loops=1) Sort Key: nd.node Sort Method: quicksort -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -> Sort (actual rows=1250.00 loops=1) Sort Key: mt.device_id Sort Method: quicksort -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) SET enable_mergejoin = FALSE; SET enable_hashjoin = TRUE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Hash Join (actual rows=48.00 loops=1) Hash Cond: (mt.device_id = nd.node) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1.00 loops=1) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) --enable all joins after the tests SET enable_mergejoin = TRUE; SET enable_hashjoin = TRUE; --end github issue 1558 -- github issue 2673 -- nested loop join with parameterized path -- join condition has a segment by column and another column. SET enable_hashjoin = false; SET enable_mergejoin=false; SET enable_material = false; SET enable_seqscan = false; -- restrict so that we select only 1 chunk. :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.*, 'query no. 9' FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' ORDER BY v0; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: met.v0 Sort Method: quicksort -> Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=2) Filter: ("*VALUES*".column2 = v0) Rows Removed by Filter: 47 Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=2) Index Cond: ((device_id = "*VALUES*".column1) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) --add filter to segment by (device_id) and compressed attr column (v0) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time = '2000-01-19 19:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=0.00 loops=1) Vectorized Filter: ((v0 = 5) AND ("time" = 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 48 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3) AND (_ts_meta_min_1 <= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) -- lateral subquery :PREFIX WITH f1 as ( SELECT * from (values( 7, 5, 4) , (4, 5, 5) ) as lu( device_id, device_id_peer, v0) ) SELECT * FROM metrics_ordered_idx met JOIN LATERAL ( SELECT node, f1.* from nodetime , f1 WHERE node = f1.device_id) q ON met.device_id = q.node and met.device_id_peer = q.device_id_peer and met.v0 = q.v0 and met.v0 > 2 and time = '2018-01-19 20:00:00-05'; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (nodetime.node = met.device_id) -> Nested Loop (actual rows=1.00 loops=1) Join Filter: (nodetime.node = "*VALUES*".column1) Rows Removed by Join Filter: 1 -> Seq Scan on nodetime (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk met (actual rows=1.00 loops=1) Filter: ("*VALUES*".column3 = v0) Rows Removed by Filter: 47 Vectorized Filter: ((v0 > 2) AND ("time" = 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = "*VALUES*".column1) AND (device_id_peer = "*VALUES*".column2) AND (_ts_meta_min_1 <= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -- filter on compressed attr (v0) with seqscan enabled and indexscan -- disabled. filters on compressed attr should be above the seq scan. SET enable_seqscan = true; SET enable_indexscan = false; :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version and met.device_id = 3 WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (device_id = 3) AND (device_id_peer = 3)) RESET enable_hashjoin ; RESET enable_mergejoin; RESET enable_material ; RESET enable_indexscan ; --end github issue 2673 SET enable_seqscan = TRUE; \ir include/transparent_decompression_constraintaware.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --- TEST for constraint aware append ------------ --should select only newly added chunk -- SET timescaledb.enable_chunk_append TO FALSE; :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -- DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 4 AND device_id_peer = 5 AND time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 4 :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 5 AND m.time = d.time AND m.time > '2002-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz AND m.device_id_peer = d.device_id_peer GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=0.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=0.00 loops=1) Hash Cond: ((d.device_id = m.device_id) AND (d."time" = m."time")) -> Custom Scan (ConstraintAwareAppend) (actual rows=0.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 -> Hash (never executed) -> Custom Scan (ConstraintAwareAppend) (never executed) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 --query with no results -- :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.time = d.time AND m.time > '2000-01-01 0:00:00+0'::text::timestamptz GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=42.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=42.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=7321.00 loops=1) Hash Cond: (d."time" = m."time") -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Hash (actual rows=1541.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) --query with all chunks but 1 excluded at plan time -- :PREFIX SELECT d.*, m.* FROM device_tbl d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Hash Join (actual rows=0.00 loops=1) Hash Cond: (d.device_id = m.device_id) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) -> Hash (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in metrics_ordered_idx but one row in device_tbl :PREFIX SELECT d.*, m.* FROM device_tbl d LEFT OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE d.device_id = 8 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) Join Filter: (m.device_id = d.device_id) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) Filter: (device_id = 8) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (device_id = 8) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in device_tbl but 1 row in metrics_ordered_idx :PREFIX SELECT d.*, m.* FROM device_tbl d FULL OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE m.device_id = 7 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Hash Left Join (actual rows=1.00 loops=1) Hash Cond: (m.device_id = d.device_id) Join Filter: ((m."time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (m."time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 4 -> Hash (actual rows=0.00 loops=1) -> Seq Scan on device_tbl d (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 7 SET timescaledb.enable_chunk_append TO TRUE; -- github bug 2917 with UNION ALL that references compressed ht CREATE TABLE entity ( oid bigint PRIMARY KEY, type text, name text ); INSERT INTO entity values(10, 'VMEM', 'cpu'); CREATE TABLE entity_m2 ( timec timestamp with time zone NOT NULL, entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision, peak double precision ); SELECT create_hypertable('entity_m2', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (5,public,entity_m2,t) INSERT INTO entity_m2 values ( '2020-12-21 15:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); INSERT INTO entity_m2 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); ALTER TABLE entity_m2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m2') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk VACUUM FULL ANALYZE entity_m2; CREATE TABLE entity_m1 ( timec timestamp with time zone , entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision ); SELECT create_hypertable('entity_m1', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (7,public,entity_m1,t) INSERT INTO entity_m1 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 100 , 0 ); create view metric_view as SELECT m2.timec, m2.entity_oid, m2.entity_hash, m2.type, m2.current, m2.capacity, m2.utilization, m2.peak FROM entity_m2 m2 UNION ALL SELECT m1.timec, m1.entity_oid, m1.entity_hash, m1.type, m1.current, m1.capacity, m1.utilization, NULL::double precision AS peak FROM entity_m1 m1; VACUUM FULL ANALYZE entity_m1; SET enable_bitmapscan = false; SET enable_hashjoin = false; SET enable_mergejoin = false; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 --now compress the other table too and rerun the query -- ALTER TABLE entity_m1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m1') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_15_chunk VACUUM FULL ANALYZE entity_m1; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 RESET enable_bitmapscan ; RESET enable_hashjoin ; RESET enable_mergejoin; -- end github bug 2917 -- When we cannot use compression sort as query keys do not match, -- and have useful and cheap IndexScans due to selective index conditions, -- we should be able to use ChunkAppend after sorting IndexScans to desired query keys. -- Before, we would only try to sort SeqScans in such scenarios. SET enable_seqscan = false; -- IndexScan keys (device_id, device_id_peer, time) do not match query keys, can't push sort into compressed index. -- Cannot use batch sort either as have to order on (time, device_id_peer). -- IndexScan can be cheap because of (device_id>2), -- should allow ChunkAppend with LIMIT after sorting decompressed IndexScans on query keys. :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=4.00 loops=1) Index Cond: (device_id > 2) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) -- Make sure we can use ChunkAppend over sorted decompressed parametrized IndexScans and SeqScans -- Parametrized IndexScans :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (mt.device_id = nd.node)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -- Parametrized SeqScans RESET enable_seqscan; SET enable_indexscan = false; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (mt.device_id = nd.node)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Seq Scan on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = false; RESET enable_indexscan; -- When we decompress top chunk, uncompressed IndexScan is sorted on (time DESC), -- should allow ChunkAppend with LIMIT -- over (Sort(time, device_id_peer) <- IndexScan + Sort(time, device_id_peer) <- DecompressChunk ...) select show_chunks as chunk_to_decompress_1 from show_chunks('metrics_ordered_idx') order by 1 desc limit 1 \gset select decompress_chunk(:'chunk_to_decompress_1'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Index Scan using _hyper_1_5_chunk_metrics_ordered_idx_time_idx on _hyper_1_5_chunk (actual rows=4.00 loops=1) Filter: (device_id > 2) Rows Removed by Filter: 1 -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) select compress_chunk(:'chunk_to_decompress_1'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk RESET enable_seqscan; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_ordered_index-16.out�����������������0000664�0000000�0000000�00000220070�15100345067�0030601�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression_ordered_index SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u -- %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- Testing Index Scan backwards ---- -- We want more than 1 segment in atleast 1 of the chunks CREATE TABLE metrics_ordered_idx ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int ); SELECT create_hypertable ('metrics_ordered_idx', 'time', chunk_time_interval => '2days'::interval); create_hypertable ---------------------------------- (1,public,metrics_ordered_idx,t) ALTER TABLE metrics_ordered_idx SET (timescaledb.compress, timescaledb.compress_orderby = 'time ASC', timescaledb.compress_segmentby = 'device_id,device_id_peer'); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT time, device_id, 0, device_id FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-15 23:55:00+0', '15m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz, '2000-01-20 11:55:00+0', '15m'), 3, 3, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2018-01-20 0:00:00+0'::timestamptz, '2018-01-20 11:55:00+0', '15m'), 4, 5, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT '2020-01-01 0:00:00+0', generate_series(4, 7, 1), 5, generate_series(1, 5, 1); -- misisng values device_id = 7 CREATE TABLE device_tbl ( device_id int, descr text ); INSERT INTO device_tbl SELECT generate_series(1, 6, 1), 'devicex'; INSERT INTO device_tbl SELECT 8, 'device8'; ANALYZE device_tbl; -- table for joins --- CREATE TABLE nodetime ( node int, start_time timestamp, stop_time timestamp ); INSERT INTO nodetime VALUES (4, '2018-01-06 00:00'::timestamp, '2018-12-02 12:00'::timestamp); VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' -- Unfortunately the ECHO cannot be redirected to the output file. \set ECHO none --compress all chunks for metrics_ordered_idx table -- SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx') ch; count ------- 5 -- reindexing compressed hypertable to update statistics DO $$ DECLARE hyper_id int; BEGIN SELECT h.compressed_hypertable_id INTO hyper_id FROM _timescaledb_catalog.hypertable h WHERE h.table_name = 'metrics_ordered_idx'; EXECUTE format('REINDEX TABLE _timescaledb_internal._compressed_hypertable_%s', hyper_id); END; $$; VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none -- diff compressed and uncompressed results :DIFF_CMD -- This is to illustrate that we have some null device_id values. This fact -- might influence the runtime chunk exclusion when doing joins on device_id. select count(*) from metrics_ordered_idx where extract(minute from time) = 0 and device_id is null ; count ------- 1 \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; SET enable_seqscan = FALSE; -- get explain for queries on hypertable with compression \ir include/transparent_decompression_ordered_indexplan.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- tests for explain plan only -- ---check index backward scans instead of seq scans ------------ CREATE TABLE metrics_ordered_idx2(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int); SELECT create_hypertable('metrics_ordered_idx2','time', chunk_time_interval=>'2days'::interval); create_hypertable ----------------------------------- (3,public,metrics_ordered_idx2,t) ALTER TABLE metrics_ordered_idx2 SET (timescaledb.compress, timescaledb.compress_orderby='time ASC, v0 desc',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered_idx2(time,device_id,device_id_peer,v0, v1) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz,'2000-01-20 11:55:00+0','10s') , 3, 3, generate_series(1,5,1) , generate_series(555,559,1); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx2') ch; count ------- 1 VACUUM ANALYZE metrics_ordered_idx2; --all queries have only prefix of compress_orderby in ORDER BY clause -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 asc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC, compress_hyper_4_12_chunk._ts_meta_min_2, compress_hyper_4_12_chunk._ts_meta_max_2 Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 desc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_3_11_chunk."time" DESC, _hyper_3_11_chunk.v0 DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=4291.00 loops=1) -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx2 d INNER JOIN LATERAL (SELECT * FROM metrics_ordered_idx2 m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON m.device_id_peer = d.device_id_peer; --- QUERY PLAN --- Nested Loop (actual rows=4291.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk d (actual rows=4291.00 loops=1) -> Seq Scan on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=1.00 loops=4291) Filter: (d.device_id_peer = m.device_id_peer) -> Limit (actual rows=1.00 loops=4291) -> Result (actual rows=1.00 loops=4291) -> Custom Scan (ChunkAppend) on metrics_ordered_idx2 m_1 (actual rows=1.00 loops=4291) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk m_2 (actual rows=1.00 loops=4291) -> Index Scan Backward using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk compress_hyper_4_12_chunk_1 (actual rows=1.00 loops=4291) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) SET enable_seqscan = FALSE; \ir include/transparent_decompression_ordered_index.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; ---Lets test for index backward scans instead of seq scans ------------ -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_8_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_8_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_7_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_6_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 DESC, compress_hyper_2_8_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 DESC, compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=12.00 loops=1) Sort Key: d.device_id Sort Method: quicksort -> Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.00 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.00 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.00 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.00 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.00 loops=389) -> Result (actual rows=0.00 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.00 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) --github issue 1558 SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT device_id, count(*) FROM ( SELECT * FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time) AS subq GROUP BY device_id; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: mt.device_id -> Nested Loop (actual rows=48.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1493 -> Merge Append (actual rows=1541.00 loops=1) Sort Key: mt.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Materialize (actual rows=1.00 loops=1541) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Nested Loop (actual rows=48.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1493 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1541.00 loops=1) Order: mt."time" -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Materialize (actual rows=1.00 loops=1541) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_mergejoin = TRUE; SET enable_hashjoin = FALSE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Merge Join (actual rows=48.00 loops=1) Merge Cond: (nd.node = mt.device_id) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Sort (actual rows=1.00 loops=1) Sort Key: nd.node Sort Method: quicksort -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -> Sort (actual rows=1250.00 loops=1) Sort Key: mt.device_id Sort Method: quicksort -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) SET enable_mergejoin = FALSE; SET enable_hashjoin = TRUE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Hash Join (actual rows=48.00 loops=1) Hash Cond: (mt.device_id = nd.node) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1.00 loops=1) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) --enable all joins after the tests SET enable_mergejoin = TRUE; SET enable_hashjoin = TRUE; --end github issue 1558 -- github issue 2673 -- nested loop join with parameterized path -- join condition has a segment by column and another column. SET enable_hashjoin = false; SET enable_mergejoin=false; SET enable_material = false; SET enable_seqscan = false; -- restrict so that we select only 1 chunk. :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.*, 'query no. 9' FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' ORDER BY v0; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: met.v0 Sort Method: quicksort -> Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=2) Filter: ("*VALUES*".column2 = v0) Rows Removed by Filter: 47 Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=2) Index Cond: ((device_id = "*VALUES*".column1) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) --add filter to segment by (device_id) and compressed attr column (v0) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time = '2000-01-19 19:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=0.00 loops=1) Vectorized Filter: ((v0 = 5) AND ("time" = 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 48 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3) AND (_ts_meta_min_1 <= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) -- lateral subquery :PREFIX WITH f1 as ( SELECT * from (values( 7, 5, 4) , (4, 5, 5) ) as lu( device_id, device_id_peer, v0) ) SELECT * FROM metrics_ordered_idx met JOIN LATERAL ( SELECT node, f1.* from nodetime , f1 WHERE node = f1.device_id) q ON met.device_id = q.node and met.device_id_peer = q.device_id_peer and met.v0 = q.v0 and met.v0 > 2 and time = '2018-01-19 20:00:00-05'; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (met.device_id = nodetime.node) -> Nested Loop (actual rows=1.00 loops=1) Join Filter: (nodetime.node = "*VALUES*".column1) Rows Removed by Join Filter: 1 -> Seq Scan on nodetime (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk met (actual rows=1.00 loops=1) Filter: ("*VALUES*".column3 = v0) Rows Removed by Filter: 47 Vectorized Filter: ((v0 > 2) AND ("time" = 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = "*VALUES*".column1) AND (device_id_peer = "*VALUES*".column2) AND (_ts_meta_min_1 <= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -- filter on compressed attr (v0) with seqscan enabled and indexscan -- disabled. filters on compressed attr should be above the seq scan. SET enable_seqscan = true; SET enable_indexscan = false; :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version and met.device_id = 3 WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (device_id = 3) AND (device_id_peer = 3)) RESET enable_hashjoin ; RESET enable_mergejoin; RESET enable_material ; RESET enable_indexscan ; --end github issue 2673 SET enable_seqscan = TRUE; \ir include/transparent_decompression_constraintaware.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --- TEST for constraint aware append ------------ --should select only newly added chunk -- SET timescaledb.enable_chunk_append TO FALSE; :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -- DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 4 AND device_id_peer = 5 AND time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 4 :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 5 AND m.time = d.time AND m.time > '2002-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz AND m.device_id_peer = d.device_id_peer GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=0.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=0.00 loops=1) Hash Cond: ((d.device_id = m.device_id) AND (d."time" = m."time")) -> Custom Scan (ConstraintAwareAppend) (actual rows=0.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 -> Hash (never executed) -> Custom Scan (ConstraintAwareAppend) (never executed) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 --query with no results -- :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.time = d.time AND m.time > '2000-01-01 0:00:00+0'::text::timestamptz GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=42.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=42.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=7321.00 loops=1) Hash Cond: (d."time" = m."time") -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Hash (actual rows=1541.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) --query with all chunks but 1 excluded at plan time -- :PREFIX SELECT d.*, m.* FROM device_tbl d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Hash Join (actual rows=0.00 loops=1) Hash Cond: (d.device_id = m.device_id) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) -> Hash (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in metrics_ordered_idx but one row in device_tbl :PREFIX SELECT d.*, m.* FROM device_tbl d LEFT OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE d.device_id = 8 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) Filter: (device_id = 8) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (device_id = 8) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in device_tbl but 1 row in metrics_ordered_idx :PREFIX SELECT d.*, m.* FROM device_tbl d FULL OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE m.device_id = 7 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) Join Filter: ((m."time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (m."time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 4 -> Materialize (actual rows=0.00 loops=1) -> Seq Scan on device_tbl d (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 7 SET timescaledb.enable_chunk_append TO TRUE; -- github bug 2917 with UNION ALL that references compressed ht CREATE TABLE entity ( oid bigint PRIMARY KEY, type text, name text ); INSERT INTO entity values(10, 'VMEM', 'cpu'); CREATE TABLE entity_m2 ( timec timestamp with time zone NOT NULL, entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision, peak double precision ); SELECT create_hypertable('entity_m2', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (5,public,entity_m2,t) INSERT INTO entity_m2 values ( '2020-12-21 15:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); INSERT INTO entity_m2 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); ALTER TABLE entity_m2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m2') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk VACUUM FULL ANALYZE entity_m2; CREATE TABLE entity_m1 ( timec timestamp with time zone , entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision ); SELECT create_hypertable('entity_m1', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (7,public,entity_m1,t) INSERT INTO entity_m1 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 100 , 0 ); create view metric_view as SELECT m2.timec, m2.entity_oid, m2.entity_hash, m2.type, m2.current, m2.capacity, m2.utilization, m2.peak FROM entity_m2 m2 UNION ALL SELECT m1.timec, m1.entity_oid, m1.entity_hash, m1.type, m1.current, m1.capacity, m1.utilization, NULL::double precision AS peak FROM entity_m1 m1; VACUUM FULL ANALYZE entity_m1; SET enable_bitmapscan = false; SET enable_hashjoin = false; SET enable_mergejoin = false; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 --now compress the other table too and rerun the query -- ALTER TABLE entity_m1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m1') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_15_chunk VACUUM FULL ANALYZE entity_m1; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 RESET enable_bitmapscan ; RESET enable_hashjoin ; RESET enable_mergejoin; -- end github bug 2917 -- When we cannot use compression sort as query keys do not match, -- and have useful and cheap IndexScans due to selective index conditions, -- we should be able to use ChunkAppend after sorting IndexScans to desired query keys. -- Before, we would only try to sort SeqScans in such scenarios. SET enable_seqscan = false; -- IndexScan keys (device_id, device_id_peer, time) do not match query keys, can't push sort into compressed index. -- Cannot use batch sort either as have to order on (time, device_id_peer). -- IndexScan can be cheap because of (device_id>2), -- should allow ChunkAppend with LIMIT after sorting decompressed IndexScans on query keys. :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=4.00 loops=1) Index Cond: (device_id > 2) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) -- Make sure we can use ChunkAppend over sorted decompressed parametrized IndexScans and SeqScans -- Parametrized IndexScans :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -- Parametrized SeqScans RESET enable_seqscan; SET enable_indexscan = false; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Seq Scan on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = false; RESET enable_indexscan; -- When we decompress top chunk, uncompressed IndexScan is sorted on (time DESC), -- should allow ChunkAppend with LIMIT -- over (Sort(time, device_id_peer) <- IndexScan + Sort(time, device_id_peer) <- DecompressChunk ...) select show_chunks as chunk_to_decompress_1 from show_chunks('metrics_ordered_idx') order by 1 desc limit 1 \gset select decompress_chunk(:'chunk_to_decompress_1'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Index Scan using _hyper_1_5_chunk_metrics_ordered_idx_time_idx on _hyper_1_5_chunk (actual rows=4.00 loops=1) Filter: (device_id > 2) Rows Removed by Filter: 1 -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) select compress_chunk(:'chunk_to_decompress_1'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk RESET enable_seqscan; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_ordered_index-17.out�����������������0000664�0000000�0000000�00000220070�15100345067�0030602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression_ordered_index SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u -- %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- Testing Index Scan backwards ---- -- We want more than 1 segment in atleast 1 of the chunks CREATE TABLE metrics_ordered_idx ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int ); SELECT create_hypertable ('metrics_ordered_idx', 'time', chunk_time_interval => '2days'::interval); create_hypertable ---------------------------------- (1,public,metrics_ordered_idx,t) ALTER TABLE metrics_ordered_idx SET (timescaledb.compress, timescaledb.compress_orderby = 'time ASC', timescaledb.compress_segmentby = 'device_id,device_id_peer'); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT time, device_id, 0, device_id FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-15 23:55:00+0', '15m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz, '2000-01-20 11:55:00+0', '15m'), 3, 3, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2018-01-20 0:00:00+0'::timestamptz, '2018-01-20 11:55:00+0', '15m'), 4, 5, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT '2020-01-01 0:00:00+0', generate_series(4, 7, 1), 5, generate_series(1, 5, 1); -- misisng values device_id = 7 CREATE TABLE device_tbl ( device_id int, descr text ); INSERT INTO device_tbl SELECT generate_series(1, 6, 1), 'devicex'; INSERT INTO device_tbl SELECT 8, 'device8'; ANALYZE device_tbl; -- table for joins --- CREATE TABLE nodetime ( node int, start_time timestamp, stop_time timestamp ); INSERT INTO nodetime VALUES (4, '2018-01-06 00:00'::timestamp, '2018-12-02 12:00'::timestamp); VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' -- Unfortunately the ECHO cannot be redirected to the output file. \set ECHO none --compress all chunks for metrics_ordered_idx table -- SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx') ch; count ------- 5 -- reindexing compressed hypertable to update statistics DO $$ DECLARE hyper_id int; BEGIN SELECT h.compressed_hypertable_id INTO hyper_id FROM _timescaledb_catalog.hypertable h WHERE h.table_name = 'metrics_ordered_idx'; EXECUTE format('REINDEX TABLE _timescaledb_internal._compressed_hypertable_%s', hyper_id); END; $$; VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none -- diff compressed and uncompressed results :DIFF_CMD -- This is to illustrate that we have some null device_id values. This fact -- might influence the runtime chunk exclusion when doing joins on device_id. select count(*) from metrics_ordered_idx where extract(minute from time) = 0 and device_id is null ; count ------- 1 \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; SET enable_seqscan = FALSE; -- get explain for queries on hypertable with compression \ir include/transparent_decompression_ordered_indexplan.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- tests for explain plan only -- ---check index backward scans instead of seq scans ------------ CREATE TABLE metrics_ordered_idx2(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int); SELECT create_hypertable('metrics_ordered_idx2','time', chunk_time_interval=>'2days'::interval); create_hypertable ----------------------------------- (3,public,metrics_ordered_idx2,t) ALTER TABLE metrics_ordered_idx2 SET (timescaledb.compress, timescaledb.compress_orderby='time ASC, v0 desc',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered_idx2(time,device_id,device_id_peer,v0, v1) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz,'2000-01-20 11:55:00+0','10s') , 3, 3, generate_series(1,5,1) , generate_series(555,559,1); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx2') ch; count ------- 1 VACUUM ANALYZE metrics_ordered_idx2; --all queries have only prefix of compress_orderby in ORDER BY clause -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 asc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC, compress_hyper_4_12_chunk._ts_meta_min_2, compress_hyper_4_12_chunk._ts_meta_max_2 Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 desc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_3_11_chunk."time" DESC, _hyper_3_11_chunk.v0 DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=4291.00 loops=1) -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx2 d INNER JOIN LATERAL (SELECT * FROM metrics_ordered_idx2 m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON m.device_id_peer = d.device_id_peer; --- QUERY PLAN --- Nested Loop (actual rows=4291.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk d (actual rows=4291.00 loops=1) -> Seq Scan on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=1.00 loops=4291) Filter: (d.device_id_peer = m.device_id_peer) -> Limit (actual rows=1.00 loops=4291) -> Result (actual rows=1.00 loops=4291) -> Custom Scan (ChunkAppend) on metrics_ordered_idx2 m_1 (actual rows=1.00 loops=4291) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk m_2 (actual rows=1.00 loops=4291) -> Index Scan Backward using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk compress_hyper_4_12_chunk_1 (actual rows=1.00 loops=4291) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) SET enable_seqscan = FALSE; \ir include/transparent_decompression_ordered_index.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; ---Lets test for index backward scans instead of seq scans ------------ -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_8_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_8_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_7_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_6_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 DESC, compress_hyper_2_8_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 DESC, compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=12.00 loops=1) Sort Key: d.device_id Sort Method: quicksort -> Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.00 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.00 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.00 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.00 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.00 loops=389) -> Result (actual rows=0.00 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.00 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) --github issue 1558 SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT device_id, count(*) FROM ( SELECT * FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time) AS subq GROUP BY device_id; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: mt.device_id -> Nested Loop (actual rows=48.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1493 -> Merge Append (actual rows=1541.00 loops=1) Sort Key: mt.device_id -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Materialize (actual rows=1.00 loops=1541) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Nested Loop (actual rows=48.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1493 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1541.00 loops=1) Order: mt."time" -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Materialize (actual rows=1.00 loops=1541) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_mergejoin = TRUE; SET enable_hashjoin = FALSE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Merge Join (actual rows=48.00 loops=1) Merge Cond: (nd.node = mt.device_id) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Sort (actual rows=1.00 loops=1) Sort Key: nd.node Sort Method: quicksort -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -> Sort (actual rows=1250.00 loops=1) Sort Key: mt.device_id Sort Method: quicksort -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) SET enable_mergejoin = FALSE; SET enable_hashjoin = TRUE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Hash Join (actual rows=48.00 loops=1) Hash Cond: (mt.device_id = nd.node) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1.00 loops=1) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) --enable all joins after the tests SET enable_mergejoin = TRUE; SET enable_hashjoin = TRUE; --end github issue 1558 -- github issue 2673 -- nested loop join with parameterized path -- join condition has a segment by column and another column. SET enable_hashjoin = false; SET enable_mergejoin=false; SET enable_material = false; SET enable_seqscan = false; -- restrict so that we select only 1 chunk. :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.*, 'query no. 9' FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' ORDER BY v0; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: met.v0 Sort Method: quicksort -> Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=2) Filter: ("*VALUES*".column2 = v0) Rows Removed by Filter: 47 Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=2) Index Cond: ((device_id = "*VALUES*".column1) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) --add filter to segment by (device_id) and compressed attr column (v0) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time = '2000-01-19 19:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=0.00 loops=1) Vectorized Filter: ((v0 = 5) AND ("time" = 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 48 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3) AND (_ts_meta_min_1 <= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) -- lateral subquery :PREFIX WITH f1 as ( SELECT * from (values( 7, 5, 4) , (4, 5, 5) ) as lu( device_id, device_id_peer, v0) ) SELECT * FROM metrics_ordered_idx met JOIN LATERAL ( SELECT node, f1.* from nodetime , f1 WHERE node = f1.device_id) q ON met.device_id = q.node and met.device_id_peer = q.device_id_peer and met.v0 = q.v0 and met.v0 > 2 and time = '2018-01-19 20:00:00-05'; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (met.device_id = nodetime.node) -> Nested Loop (actual rows=1.00 loops=1) Join Filter: (nodetime.node = "*VALUES*".column1) Rows Removed by Join Filter: 1 -> Seq Scan on nodetime (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk met (actual rows=1.00 loops=1) Filter: ("*VALUES*".column3 = v0) Rows Removed by Filter: 47 Vectorized Filter: ((v0 > 2) AND ("time" = 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = "*VALUES*".column1) AND (device_id_peer = "*VALUES*".column2) AND (_ts_meta_min_1 <= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -- filter on compressed attr (v0) with seqscan enabled and indexscan -- disabled. filters on compressed attr should be above the seq scan. SET enable_seqscan = true; SET enable_indexscan = false; :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version and met.device_id = 3 WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (device_id = 3) AND (device_id_peer = 3)) RESET enable_hashjoin ; RESET enable_mergejoin; RESET enable_material ; RESET enable_indexscan ; --end github issue 2673 SET enable_seqscan = TRUE; \ir include/transparent_decompression_constraintaware.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --- TEST for constraint aware append ------------ --should select only newly added chunk -- SET timescaledb.enable_chunk_append TO FALSE; :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -- DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 4 AND device_id_peer = 5 AND time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 4 :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 5 AND m.time = d.time AND m.time > '2002-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz AND m.device_id_peer = d.device_id_peer GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=0.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=0.00 loops=1) Hash Cond: ((d.device_id = m.device_id) AND (d."time" = m."time")) -> Custom Scan (ConstraintAwareAppend) (actual rows=0.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 -> Hash (never executed) -> Custom Scan (ConstraintAwareAppend) (never executed) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 --query with no results -- :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.time = d.time AND m.time > '2000-01-01 0:00:00+0'::text::timestamptz GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=42.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=42.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=7321.00 loops=1) Hash Cond: (d."time" = m."time") -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Hash (actual rows=1541.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) --query with all chunks but 1 excluded at plan time -- :PREFIX SELECT d.*, m.* FROM device_tbl d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Hash Join (actual rows=0.00 loops=1) Hash Cond: (d.device_id = m.device_id) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) -> Hash (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in metrics_ordered_idx but one row in device_tbl :PREFIX SELECT d.*, m.* FROM device_tbl d LEFT OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE d.device_id = 8 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) Filter: (device_id = 8) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (device_id = 8) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in device_tbl but 1 row in metrics_ordered_idx :PREFIX SELECT d.*, m.* FROM device_tbl d FULL OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE m.device_id = 7 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) Join Filter: ((m."time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (m."time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 4 -> Materialize (actual rows=0.00 loops=1) -> Seq Scan on device_tbl d (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 7 SET timescaledb.enable_chunk_append TO TRUE; -- github bug 2917 with UNION ALL that references compressed ht CREATE TABLE entity ( oid bigint PRIMARY KEY, type text, name text ); INSERT INTO entity values(10, 'VMEM', 'cpu'); CREATE TABLE entity_m2 ( timec timestamp with time zone NOT NULL, entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision, peak double precision ); SELECT create_hypertable('entity_m2', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (5,public,entity_m2,t) INSERT INTO entity_m2 values ( '2020-12-21 15:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); INSERT INTO entity_m2 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); ALTER TABLE entity_m2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m2') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk VACUUM FULL ANALYZE entity_m2; CREATE TABLE entity_m1 ( timec timestamp with time zone , entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision ); SELECT create_hypertable('entity_m1', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (7,public,entity_m1,t) INSERT INTO entity_m1 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 100 , 0 ); create view metric_view as SELECT m2.timec, m2.entity_oid, m2.entity_hash, m2.type, m2.current, m2.capacity, m2.utilization, m2.peak FROM entity_m2 m2 UNION ALL SELECT m1.timec, m1.entity_oid, m1.entity_hash, m1.type, m1.current, m1.capacity, m1.utilization, NULL::double precision AS peak FROM entity_m1 m1; VACUUM FULL ANALYZE entity_m1; SET enable_bitmapscan = false; SET enable_hashjoin = false; SET enable_mergejoin = false; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 --now compress the other table too and rerun the query -- ALTER TABLE entity_m1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m1') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_15_chunk VACUUM FULL ANALYZE entity_m1; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 RESET enable_bitmapscan ; RESET enable_hashjoin ; RESET enable_mergejoin; -- end github bug 2917 -- When we cannot use compression sort as query keys do not match, -- and have useful and cheap IndexScans due to selective index conditions, -- we should be able to use ChunkAppend after sorting IndexScans to desired query keys. -- Before, we would only try to sort SeqScans in such scenarios. SET enable_seqscan = false; -- IndexScan keys (device_id, device_id_peer, time) do not match query keys, can't push sort into compressed index. -- Cannot use batch sort either as have to order on (time, device_id_peer). -- IndexScan can be cheap because of (device_id>2), -- should allow ChunkAppend with LIMIT after sorting decompressed IndexScans on query keys. :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=4.00 loops=1) Index Cond: (device_id > 2) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) -- Make sure we can use ChunkAppend over sorted decompressed parametrized IndexScans and SeqScans -- Parametrized IndexScans :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -- Parametrized SeqScans RESET enable_seqscan; SET enable_indexscan = false; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Seq Scan on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = false; RESET enable_indexscan; -- When we decompress top chunk, uncompressed IndexScan is sorted on (time DESC), -- should allow ChunkAppend with LIMIT -- over (Sort(time, device_id_peer) <- IndexScan + Sort(time, device_id_peer) <- DecompressChunk ...) select show_chunks as chunk_to_decompress_1 from show_chunks('metrics_ordered_idx') order by 1 desc limit 1 \gset select decompress_chunk(:'chunk_to_decompress_1'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Index Scan using _hyper_1_5_chunk_metrics_ordered_idx_time_idx on _hyper_1_5_chunk (actual rows=4.00 loops=1) Filter: (device_id > 2) Rows Removed by Filter: 1 -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) select compress_chunk(:'chunk_to_decompress_1'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk RESET enable_seqscan; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_ordered_index-18.out�����������������0000664�0000000�0000000�00000221450�15100345067�0030606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression_ordered_index SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u -- %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- Testing Index Scan backwards ---- -- We want more than 1 segment in atleast 1 of the chunks CREATE TABLE metrics_ordered_idx ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int ); SELECT create_hypertable ('metrics_ordered_idx', 'time', chunk_time_interval => '2days'::interval); create_hypertable ---------------------------------- (1,public,metrics_ordered_idx,t) ALTER TABLE metrics_ordered_idx SET (timescaledb.compress, timescaledb.compress_orderby = 'time ASC', timescaledb.compress_segmentby = 'device_id,device_id_peer'); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT time, device_id, 0, device_id FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-15 23:55:00+0', '15m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz, '2000-01-20 11:55:00+0', '15m'), 3, 3, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2018-01-20 0:00:00+0'::timestamptz, '2018-01-20 11:55:00+0', '15m'), 4, 5, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT '2020-01-01 0:00:00+0', generate_series(4, 7, 1), 5, generate_series(1, 5, 1); -- misisng values device_id = 7 CREATE TABLE device_tbl ( device_id int, descr text ); INSERT INTO device_tbl SELECT generate_series(1, 6, 1), 'devicex'; INSERT INTO device_tbl SELECT 8, 'device8'; ANALYZE device_tbl; -- table for joins --- CREATE TABLE nodetime ( node int, start_time timestamp, stop_time timestamp ); INSERT INTO nodetime VALUES (4, '2018-01-06 00:00'::timestamp, '2018-12-02 12:00'::timestamp); VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' -- Unfortunately the ECHO cannot be redirected to the output file. \set ECHO none --compress all chunks for metrics_ordered_idx table -- SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx') ch; count ------- 5 -- reindexing compressed hypertable to update statistics DO $$ DECLARE hyper_id int; BEGIN SELECT h.compressed_hypertable_id INTO hyper_id FROM _timescaledb_catalog.hypertable h WHERE h.table_name = 'metrics_ordered_idx'; EXECUTE format('REINDEX TABLE _timescaledb_internal._compressed_hypertable_%s', hyper_id); END; $$; VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none -- diff compressed and uncompressed results :DIFF_CMD -- This is to illustrate that we have some null device_id values. This fact -- might influence the runtime chunk exclusion when doing joins on device_id. select count(*) from metrics_ordered_idx where extract(minute from time) = 0 and device_id is null ; count ------- 1 \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; SET enable_seqscan = FALSE; -- get explain for queries on hypertable with compression \ir include/transparent_decompression_ordered_indexplan.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- tests for explain plan only -- ---check index backward scans instead of seq scans ------------ CREATE TABLE metrics_ordered_idx2(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int); SELECT create_hypertable('metrics_ordered_idx2','time', chunk_time_interval=>'2days'::interval); create_hypertable ----------------------------------- (3,public,metrics_ordered_idx2,t) ALTER TABLE metrics_ordered_idx2 SET (timescaledb.compress, timescaledb.compress_orderby='time ASC, v0 desc',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered_idx2(time,device_id,device_id_peer,v0, v1) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz,'2000-01-20 11:55:00+0','10s') , 3, 3, generate_series(1,5,1) , generate_series(555,559,1); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx2') ch; count ------- 1 VACUUM ANALYZE metrics_ordered_idx2; --all queries have only prefix of compress_orderby in ORDER BY clause -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 asc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_4_12_chunk._ts_meta_min_1 DESC, compress_hyper_4_12_chunk._ts_meta_max_1 DESC, compress_hyper_4_12_chunk._ts_meta_min_2, compress_hyper_4_12_chunk._ts_meta_max_2 Sort Method: quicksort -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 desc LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_3_11_chunk."time" DESC, _hyper_3_11_chunk.v0 DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk (actual rows=4291.00 loops=1) -> Index Scan using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx2 d INNER JOIN LATERAL (SELECT * FROM metrics_ordered_idx2 m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON m.device_id_peer = d.device_id_peer; --- QUERY PLAN --- Nested Loop (actual rows=4291.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk d (actual rows=4291.00 loops=1) -> Seq Scan on compress_hyper_4_12_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=1.00 loops=4291) Filter: (d.device_id_peer = m.device_id_peer) -> Limit (actual rows=1.00 loops=4291) -> Result (actual rows=1.00 loops=4291) -> Custom Scan (ChunkAppend) on metrics_ordered_idx2 m_1 (actual rows=1.00 loops=4291) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_3_11_chunk m_2 (actual rows=1.00 loops=4291) -> Index Scan Backward using compress_hyper_4_12_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_4_12_chunk compress_hyper_4_12_chunk_1 (actual rows=1.00 loops=4291) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) SET enable_seqscan = FALSE; \ir include/transparent_decompression_ordered_index.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; ---Lets test for index backward scans instead of seq scans ------------ -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_8_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_8_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_7_chunk (never executed) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_2_6_chunk (never executed) -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (actual rows=10.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_8_chunk._ts_meta_min_1 DESC, compress_hyper_2_8_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_7_chunk._ts_meta_min_1 DESC, compress_hyper_2_7_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Sort (never executed) Sort Key: compress_hyper_2_6_chunk._ts_meta_min_1 DESC, compress_hyper_2_6_chunk._ts_meta_max_1 DESC -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: ((device_id = 3) AND (device_id_peer = 3)) :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Unique (actual rows=1.00 loops=1) -> Sort (actual rows=12.00 loops=1) Sort Key: d.device_id Sort Method: quicksort -> Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.03 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.22 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.22 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.22 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.22 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --- QUERY PLAN --- Nested Loop (actual rows=12.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx d (actual rows=389.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=120.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 360 -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=240.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 720 -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=12.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) Rows Removed by Filter: 36 -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Filter: (EXTRACT(minute FROM "time") = '0'::numeric) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Subquery Scan on m (actual rows=0.03 loops=389) Filter: (d.device_id_peer = m.device_id_peer) Rows Removed by Filter: 0 -> Limit (actual rows=0.22 loops=389) -> Result (actual rows=0.22 loops=389) -> Custom Scan (ChunkAppend) on metrics_ordered_idx m_1 (actual rows=0.22 loops=389) Order: m_1."time" DESC Hypertables excluded during runtime: 0 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_2 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_3 (actual rows=0.00 loops=388) -> Index Scan Backward using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=0.00 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_4 (actual rows=0.22 loops=388) -> Index Scan Backward using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=0.22 loops=388) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_5 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_6 (actual rows=0.00 loops=304) -> Index Scan Backward using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=0.00 loops=304) Index Cond: ((device_id = d.device_id) AND (device_id_peer = 3)) --github issue 1558 SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT device_id, count(*) FROM ( SELECT * FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time) AS subq GROUP BY device_id; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: mt.device_id -> Sort (actual rows=48.00 loops=1) Sort Key: mt.device_id Sort Method: quicksort -> Nested Loop (actual rows=48.00 loops=1) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -> Append (actual rows=48.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) Rows Removed by Filter: 96 -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) Rows Removed by Filter: 192 -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) Rows Removed by Filter: 1 -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Nested Loop (actual rows=48.00 loops=1) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -> Append (actual rows=48.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) Rows Removed by Filter: 96 -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) Rows Removed by Filter: 192 -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=0.00 loops=1) Filter: (("time" > nd.start_time) AND ("time" < nd.stop_time)) Rows Removed by Filter: 1 -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = nd.node) SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_mergejoin = TRUE; SET enable_hashjoin = FALSE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Merge Join (actual rows=48.00 loops=1) Merge Cond: (nd.node = mt.device_id) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Sort (actual rows=1.00 loops=1) Sort Key: nd.node Sort Method: quicksort -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -> Sort (actual rows=1250.00 loops=1) Sort Key: mt.device_id Sort Method: quicksort -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) SET enable_mergejoin = FALSE; SET enable_hashjoin = TRUE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --- QUERY PLAN --- Sort (actual rows=48.00 loops=1) Sort Key: mt."time" Sort Method: quicksort -> Hash Join (actual rows=48.00 loops=1) Hash Cond: (mt.device_id = nd.node) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time)) Rows Removed by Join Filter: 289 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (actual rows=5.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) -> Hash (actual rows=1.00 loops=1) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) --enable all joins after the tests SET enable_mergejoin = TRUE; SET enable_hashjoin = TRUE; --end github issue 1558 -- github issue 2673 -- nested loop join with parameterized path -- join condition has a segment by column and another column. SET enable_hashjoin = false; SET enable_mergejoin=false; SET enable_material = false; SET enable_seqscan = false; -- restrict so that we select only 1 chunk. :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.*, 'query no. 9' FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' ORDER BY v0; --- QUERY PLAN --- Sort (actual rows=2.00 loops=1) Sort Key: met.v0 Sort Method: quicksort -> Nested Loop (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=2) Filter: ("*VALUES*".column2 = v0) Rows Removed by Filter: 47 Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=2) Index Cond: ((device_id = "*VALUES*".column1) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) --add filter to segment by (device_id) and compressed attr column (v0) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time = '2000-01-19 19:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=0.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=0.00 loops=1) Vectorized Filter: ((v0 = 5) AND ("time" = 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 48 -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 3) AND (device_id_peer = 3) AND (_ts_meta_min_1 <= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone)) -- lateral subquery :PREFIX WITH f1 as ( SELECT * from (values( 7, 5, 4) , (4, 5, 5) ) as lu( device_id, device_id_peer, v0) ) SELECT * FROM metrics_ordered_idx met JOIN LATERAL ( SELECT node, f1.* from nodetime , f1 WHERE node = f1.device_id) q ON met.device_id = q.node and met.device_id_peer = q.device_id_peer and met.v0 = q.v0 and met.v0 > 2 and time = '2018-01-19 20:00:00-05'; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) Join Filter: (met.device_id = nodetime.node) -> Nested Loop (actual rows=1.00 loops=1) Join Filter: (nodetime.node = "*VALUES*".column1) Rows Removed by Join Filter: 1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Seq Scan on nodetime (actual rows=1.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk met (actual rows=1.00 loops=1) Filter: ("*VALUES*".column3 = v0) Rows Removed by Filter: 47 Vectorized Filter: ((v0 > 2) AND ("time" = 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = "*VALUES*".column1) AND (device_id_peer = "*VALUES*".column2) AND (_ts_meta_min_1 <= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Jan 19 17:00:00 2018 PST'::timestamp with time zone)) -- filter on compressed attr (v0) with seqscan enabled and indexscan -- disabled. filters on compressed attr should be above the seq scan. SET enable_seqscan = true; SET enable_indexscan = false; :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version and met.device_id = 3 WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; --- QUERY PLAN --- Nested Loop (actual rows=1.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=1.00 loops=1) Filter: ((column1 = 3) AND (column2 = 5)) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk met (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND ("time" < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (v0 = 5)) Rows Removed by Filter: 47 -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Wed Jan 19 16:00:00 2000 PST'::timestamp with time zone) AND (_ts_meta_min_1 < 'Thu Jan 20 17:00:00 2000 PST'::timestamp with time zone) AND (device_id = 3) AND (device_id_peer = 3)) RESET enable_hashjoin ; RESET enable_mergejoin; RESET enable_material ; RESET enable_indexscan ; --end github issue 2673 SET enable_seqscan = TRUE; \ir include/transparent_decompression_constraintaware.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --- TEST for constraint aware append ------------ --should select only newly added chunk -- SET timescaledb.enable_chunk_append TO FALSE; :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=5.00 loops=1) Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (_ts_meta_min_1 < now())) -- DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 4 AND device_id_peer = 5 AND time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; --- QUERY PLAN --- Sort (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time", metrics_ordered_idx.device_id, metrics_ordered_idx.device_id_peer, metrics_ordered_idx.v0 Sort Method: quicksort -> Limit (actual rows=10.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=10.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Merge Append (actual rows=10.00 loops=1) Sort Key: metrics_ordered_idx."time" DESC -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=9.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_9_chunk._ts_meta_min_1 DESC, compress_hyper_2_9_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=1.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND ("time" < now())) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_2_10_chunk._ts_meta_min_1 DESC, compress_hyper_2_10_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2002 PST'::timestamp with time zone) AND (device_id = 4) AND (device_id_peer = 5) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 4 :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 5 AND m.time = d.time AND m.time > '2002-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz AND m.device_id_peer = d.device_id_peer GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=0.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=0.00 loops=1) Hash Cond: ((d.device_id = m.device_id) AND (d."time" = m."time")) -> Custom Scan (ConstraintAwareAppend) (actual rows=0.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 -> Hash (never executed) -> Custom Scan (ConstraintAwareAppend) (never executed) Hypertable: metrics_ordered_idx Chunks excluded during startup: 2 --query with no results -- :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.time = d.time AND m.time > '2000-01-01 0:00:00+0'::text::timestamptz GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --- QUERY PLAN --- Sort (actual rows=42.00 loops=1) Sort Key: m.device_id, d.v0, (count(*)) Sort Method: quicksort -> HashAggregate (actual rows=42.00 loops=1) Group Key: m.device_id, d.v0 -> Hash Join (actual rows=7321.00 loops=1) Hash Cond: (d."time" = m."time") -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk d_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk d_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk d_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk d_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk d_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Hash (actual rows=1541.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=1541.00 loops=1) Hypertable: metrics_ordered_idx Chunks excluded during startup: 0 -> Append (actual rows=1541.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=480.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_6_chunk compress_hyper_2_6_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=960.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_7_chunk compress_hyper_2_7_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_8_chunk compress_hyper_2_8_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=48.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_9_chunk compress_hyper_2_9_chunk_1 (actual rows=1.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=5.00 loops=1) Vectorized Filter: ("time" > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_2_10_chunk compress_hyper_2_10_chunk_1 (actual rows=5.00 loops=1) Filter: (_ts_meta_max_1 > ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone) --query with all chunks but 1 excluded at plan time -- :PREFIX SELECT d.*, m.* FROM device_tbl d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Hash Join (actual rows=0.00 loops=1) Hash Cond: (d.device_id = m.device_id) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) -> Hash (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in metrics_ordered_idx but one row in device_tbl :PREFIX SELECT d.*, m.* FROM device_tbl d LEFT OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE d.device_id = 8 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) -> Seq Scan on device_tbl d (actual rows=1.00 loops=1) Filter: (device_id = 8) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m (actual rows=0.00 loops=1) Vectorized Filter: (("time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND ("time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_max_1 > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (device_id = 8) AND (_ts_meta_min_1 < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) Rows Removed by Filter: 5 -- no matches in device_tbl but 1 row in metrics_ordered_idx :PREFIX SELECT d.*, m.* FROM device_tbl d FULL OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE m.device_id = 7 ORDER BY m.v0; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: m.v0 Sort Method: quicksort -> Nested Loop Left Join (actual rows=1.00 loops=1) Join Filter: ((m."time" > 'Tue Jan 01 00:00:00 2019 PST'::timestamp with time zone) AND (m."time" < ('2000-01-01 0:00:00+0'::cstring)::timestamp with time zone)) -> Append (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk m_1 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk m_2 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk m_3 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk m_4 (actual rows=0.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk m_5 (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_2_10_chunk (actual rows=1.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 4 -> Materialize (actual rows=0.00 loops=1) -> Seq Scan on device_tbl d (actual rows=0.00 loops=1) Filter: (device_id = 7) Rows Removed by Filter: 7 SET timescaledb.enable_chunk_append TO TRUE; -- github bug 2917 with UNION ALL that references compressed ht CREATE TABLE entity ( oid bigint PRIMARY KEY, type text, name text ); INSERT INTO entity values(10, 'VMEM', 'cpu'); CREATE TABLE entity_m2 ( timec timestamp with time zone NOT NULL, entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision, peak double precision ); SELECT create_hypertable('entity_m2', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (5,public,entity_m2,t) INSERT INTO entity_m2 values ( '2020-12-21 15:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); INSERT INTO entity_m2 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); ALTER TABLE entity_m2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m2') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_13_chunk VACUUM FULL ANALYZE entity_m2; CREATE TABLE entity_m1 ( timec timestamp with time zone , entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision ); SELECT create_hypertable('entity_m1', 'timec', chunk_time_interval=>'30 days'::interval); create_hypertable ------------------------ (7,public,entity_m1,t) INSERT INTO entity_m1 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 100 , 0 ); create view metric_view as SELECT m2.timec, m2.entity_oid, m2.entity_hash, m2.type, m2.current, m2.capacity, m2.utilization, m2.peak FROM entity_m2 m2 UNION ALL SELECT m1.timec, m1.entity_oid, m1.entity_hash, m1.type, m1.current, m1.capacity, m1.utilization, NULL::double precision AS peak FROM entity_m1 m1; VACUUM FULL ANALYZE entity_m1; SET enable_bitmapscan = false; SET enable_hashjoin = false; SET enable_mergejoin = false; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 --now compress the other table too and rerun the query -- ALTER TABLE entity_m1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m1') c; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_15_chunk VACUUM FULL ANALYZE entity_m1; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; timec | avg_util ----------------------------------+---------- Mon Dec 21 12:47:58.778 2020 PST | 0 Mon Dec 21 13:47:58.778 2020 PST | 0 RESET enable_bitmapscan ; RESET enable_hashjoin ; RESET enable_mergejoin; -- end github bug 2917 -- When we cannot use compression sort as query keys do not match, -- and have useful and cheap IndexScans due to selective index conditions, -- we should be able to use ChunkAppend after sorting IndexScans to desired query keys. -- Before, we would only try to sort SeqScans in such scenarios. SET enable_seqscan = false; -- IndexScan keys (device_id, device_id_peer, time) do not match query keys, can't push sort into compressed index. -- Cannot use batch sort either as have to order on (time, device_id_peer). -- IndexScan can be cheap because of (device_id>2), -- should allow ChunkAppend with LIMIT after sorting decompressed IndexScans on query keys. :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk (actual rows=4.00 loops=1) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (actual rows=4.00 loops=1) Index Cond: (device_id > 2) -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) -- Make sure we can use ChunkAppend over sorted decompressed parametrized IndexScans and SeqScans -- Parametrized IndexScans :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Index Scan using compress_hyper_2_10_chunk_device_id_device_id_peer__ts_meta_idx on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) -- Parametrized SeqScans RESET enable_seqscan; SET enable_indexscan = false; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) -> Nested Loop (actual rows=5.00 loops=1) Join Filter: ((mt."time" > nd.start_time) AND (mt."time" < nd.stop_time) AND (nd.node = mt.device_id)) Rows Removed by Join Filter: 1488 -> Custom Scan (ChunkAppend) on metrics_ordered_idx mt (actual rows=1493.00 loops=1) Order: mt."time", mt.device_id -> Sort (actual rows=480.00 loops=1) Sort Key: mt_1."time", mt_1.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk mt_1 (actual rows=480.00 loops=1) -> Seq Scan on compress_hyper_2_6_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=960.00 loops=1) Sort Key: mt_2."time", mt_2.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk mt_2 (actual rows=960.00 loops=1) -> Seq Scan on compress_hyper_2_7_chunk (actual rows=5.00 loops=1) -> Sort (actual rows=48.00 loops=1) Sort Key: mt_3."time", mt_3.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk mt_3 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_8_chunk (actual rows=1.00 loops=1) -> Sort (actual rows=5.00 loops=1) Sort Key: mt_4."time", mt_4.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk mt_4 (actual rows=48.00 loops=1) -> Seq Scan on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: mt_5."time", mt_5.device_id -> Custom Scan (ColumnarScan) on _hyper_1_5_chunk mt_5 (never executed) -> Seq Scan on compress_hyper_2_10_chunk (never executed) -> Materialize (actual rows=1.00 loops=1493) -> Seq Scan on nodetime nd (actual rows=1.00 loops=1) SET enable_seqscan = false; RESET enable_indexscan; -- When we decompress top chunk, uncompressed IndexScan is sorted on (time DESC), -- should allow ChunkAppend with LIMIT -- over (Sort(time, device_id_peer) <- IndexScan + Sort(time, device_id_peer) <- DecompressChunk ...) select show_chunks as chunk_to_decompress_1 from show_chunks('metrics_ordered_idx') order by 1 desc limit 1 \gset select decompress_chunk(:'chunk_to_decompress_1'); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_ordered_idx (actual rows=10.00 loops=1) Order: metrics_ordered_idx."time" DESC, metrics_ordered_idx.device_id_peer -> Sort (actual rows=4.00 loops=1) Sort Key: _hyper_1_5_chunk."time" DESC, _hyper_1_5_chunk.device_id_peer Sort Method: quicksort -> Index Scan using _hyper_1_5_chunk_metrics_ordered_idx_time_idx on _hyper_1_5_chunk (actual rows=4.00 loops=1) Filter: (device_id > 2) Rows Removed by Filter: 1 -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_1_4_chunk."time" DESC, _hyper_1_4_chunk.device_id_peer Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_1_4_chunk (actual rows=48.00 loops=1) -> Index Scan using compress_hyper_2_9_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_9_chunk (actual rows=1.00 loops=1) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_3_chunk."time" DESC, _hyper_1_3_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk (never executed) -> Index Scan using compress_hyper_2_8_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_8_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_2_chunk."time" DESC, _hyper_1_2_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk (never executed) -> Index Scan using compress_hyper_2_7_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_7_chunk (never executed) Index Cond: (device_id > 2) -> Sort (never executed) Sort Key: _hyper_1_1_chunk."time" DESC, _hyper_1_1_chunk.device_id_peer -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (never executed) -> Index Scan using compress_hyper_2_6_chunk_device_id_device_id_peer__ts_meta__idx on compress_hyper_2_6_chunk (never executed) Index Cond: (device_id > 2) select compress_chunk(:'chunk_to_decompress_1'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_5_chunk RESET enable_seqscan; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_queries-15.out�����������������������0000664�0000000�0000000�00000027232�15100345067�0027447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --TEST github issue 1650 character segment by column CREATE TABLE test_chartab ( job_run_id INTEGER NOT NULL, mac_id CHAR(16) NOT NULL, rtt INTEGER NOT NULL, ts TIMESTAMP(3) NOT NULL ); SELECT create_hypertable('test_chartab', 'ts', chunk_time_interval => interval '1 day', migrate_data => true); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable --------------------------- (1,public,test_chartab,t) insert into test_chartab values(8864, '0014070000006190' , 392 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '0014070000011039' , 150 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '001407000001DD2E' , 228 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8890 , '001407000001DD2E' , 228 , '2019-12-20 02:52:05.863'); ALTER TABLE test_chartab SET (timescaledb.compress, timescaledb.compress_segmentby = 'mac_id', timescaledb.compress_orderby = 'ts DESC'); select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 --compress the data and check -- SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 VACUUM ANALYZE test_chartab; -- test constraintawareappend sort node handling SET work_mem to '16MB'; SET enable_hashagg TO false; SET timescaledb.enable_chunkwise_aggregation TO false; SET max_parallel_workers_per_gather = 0; CREATE TABLE public.merge_sort (time timestamp NOT NULL, measure_id integer NOT NULL, device_id integer NOT NULL, value float); SELECT create_hypertable('merge_sort', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (3,public,merge_sort,t) ALTER TABLE merge_sort SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, measure_id'); INSERT INTO merge_sort SELECT time, 1, 1, extract(epoch from time) * 0.001 FROM generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'5 sec'::interval) g1(time); --compress first chunk SELECT compress_chunk(ch) FROM show_chunks('merge_sort') ch LIMIT 1; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk VACUUM ANALYZE merge_sort; -- this should have a MergeAppend with children wrapped in Sort nodes EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time < now() GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ConstraintAwareAppend) (actual rows=535681.00 loops=1) Hypertable: merge_sort Chunks excluded during startup: 0 -> Merge Append (actual rows=535681.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=86400.00 loops=1) Vectorized Filter: ("time" < "timestamp"(now())) -> Index Scan using compress_hyper_4_10_chunk_device_id_measure_id__ts_meta_min_idx on compress_hyper_4_10_chunk (actual rows=87.00 loops=1) Index Cond: (_ts_meta_min_1 < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_6_chunk.device_id, _hyper_3_6_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_6_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_7_chunk.device_id, _hyper_3_7_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_8_chunk.device_id, _hyper_3_8_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=86401.00 loops=1) Sort Key: _hyper_3_9_chunk.device_id, _hyper_3_9_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" < now()) -- this should exclude the decompressed chunk EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time > '2000-01-10'::text::timestamp GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Sort (actual rows=380160.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id Sort Method: external merge -> Result (actual rows=380160.00 loops=1) -> Custom Scan (ChunkAppend) on merge_sort (actual rows=380160.00 loops=1) Chunks excluded during startup: 1 -> Index Scan using _hyper_3_6_chunk_merge_sort_time_idx on _hyper_3_6_chunk (actual rows=51839.00 loops=1) Index Cond: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; RESET max_parallel_workers_per_gather; RESET work_mem; -- test if volatile function quals are applied to compressed chunks CREATE FUNCTION check_equal_228( intval INTEGER) RETURNS BOOL LANGUAGE PLPGSQL AS $BODY$ DECLARE retval BOOL; BEGIN IF intval = 228 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $BODY$; -- the function cannot be pushed down to compressed chunk -- but should be applied as a filter on decompresschunk SELECT * from test_chartab WHERE check_equal_228(rtt) ORDER BY ts; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 001407000001DD2E | 228 | Sat Dec 14 02:52:05.863 2019 8890 | 001407000001DD2E | 228 | Fri Dec 20 02:52:05.863 2019 EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * from test_chartab WHERE check_equal_228(rtt) and ts < '2019-12-15 00:00:00' order by ts; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: test_chartab.ts Sort Method: quicksort -> Custom Scan (ChunkAppend) on test_chartab (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: check_equal_228(rtt) Rows Removed by Filter: 2 Vectorized Filter: (ts < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_1 < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -- test pseudoconstant qual #3241 CREATE TABLE pseudo(time timestamptz NOT NULL); SELECT create_hypertable('pseudo','time'); create_hypertable --------------------- (5,public,pseudo,t) ALTER TABLE pseudo SET (timescaledb.compress); INSERT INTO pseudo SELECT '2000-01-01'; SELECT compress_chunk(show_chunks('pseudo')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_11_chunk SELECT * FROM pseudo WHERE now() IS NOT NULL; time ------------------------------ Sat Jan 01 00:00:00 2000 PST -- ensure needed decompression paths underneath a sort node -- are not recycled by PostgreSQL SET random_page_cost = 4.0; DROP TABLE IF EXISTS options_data; NOTICE: table "options_data" does not exist, skipping CREATE TABLE IF NOT EXISTS options_data ( date date NOT NULL, contract_code text NOT NULL, expiry_code text NOT NULL, option_type character(1) NOT NULL, strike real NOT NULL, price double precision, source text NOT NULL, meta text ); SELECT create_hypertable('options_data', 'date', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (7,public,options_data,t) INSERT INTO options_data (date, contract_code, expiry_code, option_type, strike, price, source, meta) SELECT date_series, 'CONTRACT' || date_series::text, 'EXPIRY' || date_series::text, CASE WHEN random() < 0.5 THEN 'C' ELSE 'P' END, -- Randomly choose 'C' or 'P' for option_type random() * 100, -- Random strike value between 0 and 100 random() * 100, -- Random price value between 0 and 100 'SOURCE' || date_series::text, 'META' || date_series::text FROM generate_series( '2023-12-01 00:00:00', '2023-12-05 00:00:00', INTERVAL '10 minute' ) AS date_series; ALTER TABLE options_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'contract_code, expiry_code, option_type, strike, source', timescaledb.compress_orderby = 'date DESC'); SELECT compress_chunk(ch) FROM show_chunks('options_data', older_than=> '2023-12-05') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk _timescaledb_internal._hyper_7_16_chunk VACUUM ANALYZE options_data; SELECT max(date) AS date FROM options_data WHERE contract_code='CONTRACT2023-12-03 04:00:00+01'; date ------ RESET random_page_cost; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_queries-16.out�����������������������0000664�0000000�0000000�00000027232�15100345067�0027450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --TEST github issue 1650 character segment by column CREATE TABLE test_chartab ( job_run_id INTEGER NOT NULL, mac_id CHAR(16) NOT NULL, rtt INTEGER NOT NULL, ts TIMESTAMP(3) NOT NULL ); SELECT create_hypertable('test_chartab', 'ts', chunk_time_interval => interval '1 day', migrate_data => true); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable --------------------------- (1,public,test_chartab,t) insert into test_chartab values(8864, '0014070000006190' , 392 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '0014070000011039' , 150 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '001407000001DD2E' , 228 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8890 , '001407000001DD2E' , 228 , '2019-12-20 02:52:05.863'); ALTER TABLE test_chartab SET (timescaledb.compress, timescaledb.compress_segmentby = 'mac_id', timescaledb.compress_orderby = 'ts DESC'); select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 --compress the data and check -- SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 VACUUM ANALYZE test_chartab; -- test constraintawareappend sort node handling SET work_mem to '16MB'; SET enable_hashagg TO false; SET timescaledb.enable_chunkwise_aggregation TO false; SET max_parallel_workers_per_gather = 0; CREATE TABLE public.merge_sort (time timestamp NOT NULL, measure_id integer NOT NULL, device_id integer NOT NULL, value float); SELECT create_hypertable('merge_sort', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (3,public,merge_sort,t) ALTER TABLE merge_sort SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, measure_id'); INSERT INTO merge_sort SELECT time, 1, 1, extract(epoch from time) * 0.001 FROM generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'5 sec'::interval) g1(time); --compress first chunk SELECT compress_chunk(ch) FROM show_chunks('merge_sort') ch LIMIT 1; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk VACUUM ANALYZE merge_sort; -- this should have a MergeAppend with children wrapped in Sort nodes EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time < now() GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ConstraintAwareAppend) (actual rows=535681.00 loops=1) Hypertable: merge_sort Chunks excluded during startup: 0 -> Merge Append (actual rows=535681.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=86400.00 loops=1) Vectorized Filter: ("time" < "timestamp"(now())) -> Index Scan using compress_hyper_4_10_chunk_device_id_measure_id__ts_meta_min_idx on compress_hyper_4_10_chunk (actual rows=87.00 loops=1) Index Cond: (_ts_meta_min_1 < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_6_chunk.device_id, _hyper_3_6_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_6_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_7_chunk.device_id, _hyper_3_7_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_8_chunk.device_id, _hyper_3_8_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=86401.00 loops=1) Sort Key: _hyper_3_9_chunk.device_id, _hyper_3_9_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" < now()) -- this should exclude the decompressed chunk EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time > '2000-01-10'::text::timestamp GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Sort (actual rows=380160.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id Sort Method: external merge -> Result (actual rows=380160.00 loops=1) -> Custom Scan (ChunkAppend) on merge_sort (actual rows=380160.00 loops=1) Chunks excluded during startup: 1 -> Index Scan using _hyper_3_6_chunk_merge_sort_time_idx on _hyper_3_6_chunk (actual rows=51839.00 loops=1) Index Cond: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; RESET max_parallel_workers_per_gather; RESET work_mem; -- test if volatile function quals are applied to compressed chunks CREATE FUNCTION check_equal_228( intval INTEGER) RETURNS BOOL LANGUAGE PLPGSQL AS $BODY$ DECLARE retval BOOL; BEGIN IF intval = 228 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $BODY$; -- the function cannot be pushed down to compressed chunk -- but should be applied as a filter on decompresschunk SELECT * from test_chartab WHERE check_equal_228(rtt) ORDER BY ts; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 001407000001DD2E | 228 | Sat Dec 14 02:52:05.863 2019 8890 | 001407000001DD2E | 228 | Fri Dec 20 02:52:05.863 2019 EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * from test_chartab WHERE check_equal_228(rtt) and ts < '2019-12-15 00:00:00' order by ts; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: test_chartab.ts Sort Method: quicksort -> Custom Scan (ChunkAppend) on test_chartab (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: check_equal_228(rtt) Rows Removed by Filter: 2 Vectorized Filter: (ts < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_1 < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -- test pseudoconstant qual #3241 CREATE TABLE pseudo(time timestamptz NOT NULL); SELECT create_hypertable('pseudo','time'); create_hypertable --------------------- (5,public,pseudo,t) ALTER TABLE pseudo SET (timescaledb.compress); INSERT INTO pseudo SELECT '2000-01-01'; SELECT compress_chunk(show_chunks('pseudo')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_11_chunk SELECT * FROM pseudo WHERE now() IS NOT NULL; time ------------------------------ Sat Jan 01 00:00:00 2000 PST -- ensure needed decompression paths underneath a sort node -- are not recycled by PostgreSQL SET random_page_cost = 4.0; DROP TABLE IF EXISTS options_data; NOTICE: table "options_data" does not exist, skipping CREATE TABLE IF NOT EXISTS options_data ( date date NOT NULL, contract_code text NOT NULL, expiry_code text NOT NULL, option_type character(1) NOT NULL, strike real NOT NULL, price double precision, source text NOT NULL, meta text ); SELECT create_hypertable('options_data', 'date', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (7,public,options_data,t) INSERT INTO options_data (date, contract_code, expiry_code, option_type, strike, price, source, meta) SELECT date_series, 'CONTRACT' || date_series::text, 'EXPIRY' || date_series::text, CASE WHEN random() < 0.5 THEN 'C' ELSE 'P' END, -- Randomly choose 'C' or 'P' for option_type random() * 100, -- Random strike value between 0 and 100 random() * 100, -- Random price value between 0 and 100 'SOURCE' || date_series::text, 'META' || date_series::text FROM generate_series( '2023-12-01 00:00:00', '2023-12-05 00:00:00', INTERVAL '10 minute' ) AS date_series; ALTER TABLE options_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'contract_code, expiry_code, option_type, strike, source', timescaledb.compress_orderby = 'date DESC'); SELECT compress_chunk(ch) FROM show_chunks('options_data', older_than=> '2023-12-05') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk _timescaledb_internal._hyper_7_16_chunk VACUUM ANALYZE options_data; SELECT max(date) AS date FROM options_data WHERE contract_code='CONTRACT2023-12-03 04:00:00+01'; date ------ RESET random_page_cost; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_queries-17.out�����������������������0000664�0000000�0000000�00000030506�15100345067�0027447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --TEST github issue 1650 character segment by column CREATE TABLE test_chartab ( job_run_id INTEGER NOT NULL, mac_id CHAR(16) NOT NULL, rtt INTEGER NOT NULL, ts TIMESTAMP(3) NOT NULL ); SELECT create_hypertable('test_chartab', 'ts', chunk_time_interval => interval '1 day', migrate_data => true); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable --------------------------- (1,public,test_chartab,t) insert into test_chartab values(8864, '0014070000006190' , 392 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '0014070000011039' , 150 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '001407000001DD2E' , 228 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8890 , '001407000001DD2E' , 228 , '2019-12-20 02:52:05.863'); ALTER TABLE test_chartab SET (timescaledb.compress, timescaledb.compress_segmentby = 'mac_id', timescaledb.compress_orderby = 'ts DESC'); select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 --compress the data and check -- SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 VACUUM ANALYZE test_chartab; -- test constraintawareappend sort node handling SET work_mem to '16MB'; SET enable_hashagg TO false; SET timescaledb.enable_chunkwise_aggregation TO false; SET max_parallel_workers_per_gather = 0; CREATE TABLE public.merge_sort (time timestamp NOT NULL, measure_id integer NOT NULL, device_id integer NOT NULL, value float); SELECT create_hypertable('merge_sort', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (3,public,merge_sort,t) ALTER TABLE merge_sort SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, measure_id'); INSERT INTO merge_sort SELECT time, 1, 1, extract(epoch from time) * 0.001 FROM generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'5 sec'::interval) g1(time); --compress first chunk SELECT compress_chunk(ch) FROM show_chunks('merge_sort') ch LIMIT 1; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk VACUUM ANALYZE merge_sort; -- this should have a MergeAppend with children wrapped in Sort nodes EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time < now() GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ConstraintAwareAppend) (actual rows=535681.00 loops=1) Hypertable: merge_sort Chunks excluded during startup: 0 -> Merge Append (actual rows=535681.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=86400.00 loops=1) Vectorized Filter: ("time" < "timestamp"(now())) -> Index Scan using compress_hyper_4_10_chunk_device_id_measure_id__ts_meta_min_idx on compress_hyper_4_10_chunk (actual rows=87.00 loops=1) Index Cond: (_ts_meta_min_1 < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_6_chunk.device_id, _hyper_3_6_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_6_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_7_chunk.device_id, _hyper_3_7_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_8_chunk.device_id, _hyper_3_8_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=86401.00 loops=1) Sort Key: _hyper_3_9_chunk.device_id, _hyper_3_9_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" < now()) -- this should exclude the decompressed chunk EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time > '2000-01-10'::text::timestamp GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ConstraintAwareAppend) (actual rows=380160.00 loops=1) Hypertable: merge_sort Chunks excluded during startup: 1 -> Merge Append (actual rows=380160.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id -> Sort (actual rows=51839.00 loops=1) Sort Key: _hyper_3_6_chunk.device_id, _hyper_3_6_chunk.measure_id Sort Method: quicksort -> Index Scan using _hyper_3_6_chunk_merge_sort_time_idx on _hyper_3_6_chunk (actual rows=51839.00 loops=1) Index Cond: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_7_chunk.device_id, _hyper_3_7_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_8_chunk.device_id, _hyper_3_8_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Sort (actual rows=86401.00 loops=1) Sort Key: _hyper_3_9_chunk.device_id, _hyper_3_9_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; RESET max_parallel_workers_per_gather; RESET work_mem; -- test if volatile function quals are applied to compressed chunks CREATE FUNCTION check_equal_228( intval INTEGER) RETURNS BOOL LANGUAGE PLPGSQL AS $BODY$ DECLARE retval BOOL; BEGIN IF intval = 228 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $BODY$; -- the function cannot be pushed down to compressed chunk -- but should be applied as a filter on decompresschunk SELECT * from test_chartab WHERE check_equal_228(rtt) ORDER BY ts; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 001407000001DD2E | 228 | Sat Dec 14 02:52:05.863 2019 8890 | 001407000001DD2E | 228 | Fri Dec 20 02:52:05.863 2019 EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * from test_chartab WHERE check_equal_228(rtt) and ts < '2019-12-15 00:00:00' order by ts; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: test_chartab.ts Sort Method: quicksort -> Custom Scan (ChunkAppend) on test_chartab (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: check_equal_228(rtt) Rows Removed by Filter: 2 Vectorized Filter: (ts < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_1 < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -- test pseudoconstant qual #3241 CREATE TABLE pseudo(time timestamptz NOT NULL); SELECT create_hypertable('pseudo','time'); create_hypertable --------------------- (5,public,pseudo,t) ALTER TABLE pseudo SET (timescaledb.compress); INSERT INTO pseudo SELECT '2000-01-01'; SELECT compress_chunk(show_chunks('pseudo')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_11_chunk SELECT * FROM pseudo WHERE now() IS NOT NULL; time ------------------------------ Sat Jan 01 00:00:00 2000 PST -- ensure needed decompression paths underneath a sort node -- are not recycled by PostgreSQL SET random_page_cost = 4.0; DROP TABLE IF EXISTS options_data; NOTICE: table "options_data" does not exist, skipping CREATE TABLE IF NOT EXISTS options_data ( date date NOT NULL, contract_code text NOT NULL, expiry_code text NOT NULL, option_type character(1) NOT NULL, strike real NOT NULL, price double precision, source text NOT NULL, meta text ); SELECT create_hypertable('options_data', 'date', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (7,public,options_data,t) INSERT INTO options_data (date, contract_code, expiry_code, option_type, strike, price, source, meta) SELECT date_series, 'CONTRACT' || date_series::text, 'EXPIRY' || date_series::text, CASE WHEN random() < 0.5 THEN 'C' ELSE 'P' END, -- Randomly choose 'C' or 'P' for option_type random() * 100, -- Random strike value between 0 and 100 random() * 100, -- Random price value between 0 and 100 'SOURCE' || date_series::text, 'META' || date_series::text FROM generate_series( '2023-12-01 00:00:00', '2023-12-05 00:00:00', INTERVAL '10 minute' ) AS date_series; ALTER TABLE options_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'contract_code, expiry_code, option_type, strike, source', timescaledb.compress_orderby = 'date DESC'); SELECT compress_chunk(ch) FROM show_chunks('options_data', older_than=> '2023-12-05') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk _timescaledb_internal._hyper_7_16_chunk VACUUM ANALYZE options_data; SELECT max(date) AS date FROM options_data WHERE contract_code='CONTRACT2023-12-03 04:00:00+01'; date ------ RESET random_page_cost; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/transparent_decompression_queries-18.out�����������������������0000664�0000000�0000000�00000030506�15100345067�0027450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --TEST github issue 1650 character segment by column CREATE TABLE test_chartab ( job_run_id INTEGER NOT NULL, mac_id CHAR(16) NOT NULL, rtt INTEGER NOT NULL, ts TIMESTAMP(3) NOT NULL ); SELECT create_hypertable('test_chartab', 'ts', chunk_time_interval => interval '1 day', migrate_data => true); WARNING: column type "timestamp without time zone" used for "ts" does not follow best practices create_hypertable --------------------------- (1,public,test_chartab,t) insert into test_chartab values(8864, '0014070000006190' , 392 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '0014070000011039' , 150 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '001407000001DD2E' , 228 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8890 , '001407000001DD2E' , 228 , '2019-12-20 02:52:05.863'); ALTER TABLE test_chartab SET (timescaledb.compress, timescaledb.compress_segmentby = 'mac_id', timescaledb.compress_orderby = 'ts DESC'); select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 --compress the data and check -- SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_2_chunk select * from test_chartab order by mac_id , ts limit 2; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 0014070000006190 | 392 | Sat Dec 14 02:52:05.863 2019 8864 | 0014070000011039 | 150 | Sat Dec 14 02:52:05.863 2019 VACUUM ANALYZE test_chartab; -- test constraintawareappend sort node handling SET work_mem to '16MB'; SET enable_hashagg TO false; SET timescaledb.enable_chunkwise_aggregation TO false; SET max_parallel_workers_per_gather = 0; CREATE TABLE public.merge_sort (time timestamp NOT NULL, measure_id integer NOT NULL, device_id integer NOT NULL, value float); SELECT create_hypertable('merge_sort', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices create_hypertable ------------------------- (3,public,merge_sort,t) ALTER TABLE merge_sort SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, measure_id'); INSERT INTO merge_sort SELECT time, 1, 1, extract(epoch from time) * 0.001 FROM generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'5 sec'::interval) g1(time); --compress first chunk SELECT compress_chunk(ch) FROM show_chunks('merge_sort') ch LIMIT 1; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_3_5_chunk VACUUM ANALYZE merge_sort; -- this should have a MergeAppend with children wrapped in Sort nodes EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time < now() GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ConstraintAwareAppend) (actual rows=535681.00 loops=1) Hypertable: merge_sort Chunks excluded during startup: 0 -> Merge Append (actual rows=535681.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ColumnarScan) on _hyper_3_5_chunk (actual rows=86400.00 loops=1) Vectorized Filter: ("time" < "timestamp"(now())) -> Index Scan using compress_hyper_4_10_chunk_device_id_measure_id__ts_meta_min_idx on compress_hyper_4_10_chunk (actual rows=87.00 loops=1) Index Cond: (_ts_meta_min_1 < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_6_chunk.device_id, _hyper_3_6_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_6_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_7_chunk.device_id, _hyper_3_7_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_8_chunk.device_id, _hyper_3_8_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" < now()) -> Sort (actual rows=86401.00 loops=1) Sort Key: _hyper_3_9_chunk.device_id, _hyper_3_9_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" < now()) -- this should exclude the decompressed chunk EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time > '2000-01-10'::text::timestamp GROUP BY 2, 3; --- QUERY PLAN --- GroupAggregate (actual rows=1.00 loops=1) Group Key: merge_sort.device_id, merge_sort.measure_id -> Custom Scan (ConstraintAwareAppend) (actual rows=380160.00 loops=1) Hypertable: merge_sort Chunks excluded during startup: 1 -> Merge Append (actual rows=380160.00 loops=1) Sort Key: merge_sort.device_id, merge_sort.measure_id -> Sort (actual rows=51839.00 loops=1) Sort Key: _hyper_3_6_chunk.device_id, _hyper_3_6_chunk.measure_id Sort Method: quicksort -> Index Scan using _hyper_3_6_chunk_merge_sort_time_idx on _hyper_3_6_chunk (actual rows=51839.00 loops=1) Index Cond: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_7_chunk.device_id, _hyper_3_7_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_7_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Sort (actual rows=120960.00 loops=1) Sort Key: _hyper_3_8_chunk.device_id, _hyper_3_8_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_8_chunk (actual rows=120960.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) -> Sort (actual rows=86401.00 loops=1) Sort Key: _hyper_3_9_chunk.device_id, _hyper_3_9_chunk.measure_id Sort Method: quicksort -> Seq Scan on _hyper_3_9_chunk (actual rows=86401.00 loops=1) Filter: ("time" > ('2000-01-10'::cstring)::timestamp without time zone) RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; RESET max_parallel_workers_per_gather; RESET work_mem; -- test if volatile function quals are applied to compressed chunks CREATE FUNCTION check_equal_228( intval INTEGER) RETURNS BOOL LANGUAGE PLPGSQL AS $BODY$ DECLARE retval BOOL; BEGIN IF intval = 228 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $BODY$; -- the function cannot be pushed down to compressed chunk -- but should be applied as a filter on decompresschunk SELECT * from test_chartab WHERE check_equal_228(rtt) ORDER BY ts; job_run_id | mac_id | rtt | ts ------------+------------------+-----+------------------------------ 8864 | 001407000001DD2E | 228 | Sat Dec 14 02:52:05.863 2019 8890 | 001407000001DD2E | 228 | Fri Dec 20 02:52:05.863 2019 EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * from test_chartab WHERE check_equal_228(rtt) and ts < '2019-12-15 00:00:00' order by ts; --- QUERY PLAN --- Sort (actual rows=1.00 loops=1) Sort Key: test_chartab.ts Sort Method: quicksort -> Custom Scan (ChunkAppend) on test_chartab (actual rows=1.00 loops=1) Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk (actual rows=1.00 loops=1) Filter: check_equal_228(rtt) Rows Removed by Filter: 2 Vectorized Filter: (ts < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -> Seq Scan on compress_hyper_2_3_chunk (actual rows=3.00 loops=1) Filter: (_ts_meta_min_1 < 'Sun Dec 15 00:00:00 2019'::timestamp without time zone) -- test pseudoconstant qual #3241 CREATE TABLE pseudo(time timestamptz NOT NULL); SELECT create_hypertable('pseudo','time'); create_hypertable --------------------- (5,public,pseudo,t) ALTER TABLE pseudo SET (timescaledb.compress); INSERT INTO pseudo SELECT '2000-01-01'; SELECT compress_chunk(show_chunks('pseudo')); compress_chunk ----------------------------------------- _timescaledb_internal._hyper_5_11_chunk SELECT * FROM pseudo WHERE now() IS NOT NULL; time ------------------------------ Sat Jan 01 00:00:00 2000 PST -- ensure needed decompression paths underneath a sort node -- are not recycled by PostgreSQL SET random_page_cost = 4.0; DROP TABLE IF EXISTS options_data; NOTICE: table "options_data" does not exist, skipping CREATE TABLE IF NOT EXISTS options_data ( date date NOT NULL, contract_code text NOT NULL, expiry_code text NOT NULL, option_type character(1) NOT NULL, strike real NOT NULL, price double precision, source text NOT NULL, meta text ); SELECT create_hypertable('options_data', 'date', chunk_time_interval => interval '1 day'); create_hypertable --------------------------- (7,public,options_data,t) INSERT INTO options_data (date, contract_code, expiry_code, option_type, strike, price, source, meta) SELECT date_series, 'CONTRACT' || date_series::text, 'EXPIRY' || date_series::text, CASE WHEN random() < 0.5 THEN 'C' ELSE 'P' END, -- Randomly choose 'C' or 'P' for option_type random() * 100, -- Random strike value between 0 and 100 random() * 100, -- Random price value between 0 and 100 'SOURCE' || date_series::text, 'META' || date_series::text FROM generate_series( '2023-12-01 00:00:00', '2023-12-05 00:00:00', INTERVAL '10 minute' ) AS date_series; ALTER TABLE options_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'contract_code, expiry_code, option_type, strike, source', timescaledb.compress_orderby = 'date DESC'); SELECT compress_chunk(ch) FROM show_chunks('options_data', older_than=> '2023-12-05') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_7_13_chunk _timescaledb_internal._hyper_7_14_chunk _timescaledb_internal._hyper_7_15_chunk _timescaledb_internal._hyper_7_16_chunk VACUUM ANALYZE options_data; SELECT max(date) AS date FROM options_data WHERE contract_code='CONTRACT2023-12-03 04:00:00+01'; date ------ RESET random_page_cost; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/tsl_tables.out�������������������������������������������������0000664�0000000�0000000�00000160273�15100345067�0022333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.license_key='CommunityLicense'; CREATE OR REPLACE FUNCTION ts_test_chunk_stats_insert(job_id INTEGER, chunk_id INTEGER, num_times_run INTEGER, last_time_run TIMESTAMPTZ = NULL) RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- CREATE TABLE test_table(time timestamptz, junk int); CREATE TABLE test_table_int(time bigint, junk int); SELECT create_hypertable('test_table', 'time'); create_hypertable ------------------------- (1,public,test_table,t) SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 1); create_hypertable ----------------------------- (2,public,test_table_int,t) CREATE INDEX second_index on test_table (time); CREATE INDEX third_index on test_table (time); select add_reorder_policy('test_table', 'test_table_time_idx') as job_id \gset -- Noop for duplicate policy select add_reorder_policy('test_table', 'test_table_time_idx', true); NOTICE: reorder policy already exists on hypertable "test_table", skipping add_reorder_policy -------------------- -1 select add_reorder_policy('test_table', 'second_index', true); WARNING: reorder policy already exists for hypertable "test_table" add_reorder_policy -------------------- -1 select add_reorder_policy('test_table', 'third_index', true); WARNING: reorder policy already exists for hypertable "test_table" add_reorder_policy -------------------- -1 \set ON_ERROR_STOP 0 -- Error whenever incorrect arguments are applied (must have table and index) select add_reorder_policy('test_table', 'bad_index'); ERROR: invalid reorder index select add_reorder_policy('test_table', ''); ERROR: invalid reorder index select add_reorder_policy('test_table'); ERROR: function add_reorder_policy(unknown) does not exist at character 8 select add_reorder_policy('test_table', 'second_index'); ERROR: reorder policy already exists for hypertable "test_table" select add_reorder_policy('test_table', 'third_index'); ERROR: reorder policy already exists for hypertable "test_table" select add_reorder_policy(NULL, 'third_index'); add_reorder_policy -------------------- select add_reorder_policy(2, 'third_index'); ERROR: OID 2 does not refer to a table \set ON_ERROR_STOP 1 select * from _timescaledb_config.bgw_job where id=:job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------+------------------------+----------------------+---------- 1000 | Reorder Policy [1000] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 1 | {"index_name": "test_table_time_idx", "hypertable_id": 1} | _timescaledb_functions | policy_reorder_check | -- Now check that default scheduling interval for reorder policy is calculated correctly -- Should be 1/2 default chunk interval length CREATE TABLE test_table2(time timestamptz, junk int); SELECT create_hypertable('test_table2', 'time', chunk_time_interval=>INTERVAL '1 day'); create_hypertable -------------------------- (3,public,test_table2,t) select add_reorder_policy('test_table2', 'test_table2_time_idx'); add_reorder_policy -------------------- 1001 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+------------------------------------------------------------+------------------------+----------------------+---------- 1000 | Reorder Policy [1000] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 1 | {"index_name": "test_table_time_idx", "hypertable_id": 1} | _timescaledb_functions | policy_reorder_check | 1001 | Reorder Policy [1001] | @ 12 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 3 | {"index_name": "test_table2_time_idx", "hypertable_id": 3} | _timescaledb_functions | policy_reorder_check | DROP TABLE test_table2; -- Make sure that test_table2 reorder policy gets dropped SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------+------------------------+----------------------+---------- 1000 | Reorder Policy [1000] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 1 | {"index_name": "test_table_time_idx", "hypertable_id": 1} | _timescaledb_functions | policy_reorder_check | -- Error whenever incorrect arguments are applied (must have table and interval) \set ON_ERROR_STOP 0 select add_retention_policy(); ERROR: function add_retention_policy() does not exist at character 8 select add_retention_policy('test_table'); ERROR: need to specify one of "drop_after" or "drop_created_before" select add_retention_policy(INTERVAL '3 hours'); ERROR: function add_retention_policy(interval) does not exist at character 8 select add_retention_policy('test_table', INTERVAL 'haha'); ERROR: invalid input syntax for type interval: "haha" at character 52 select add_retention_policy('test_table', 'haha'); ERROR: invalid value for parameter drop_after select add_retention_policy('test_table', 42); ERROR: invalid value for parameter drop_after select add_retention_policy('fake_table', INTERVAL '3 month'); ERROR: relation "fake_table" does not exist at character 29 \set ON_ERROR_STOP 1 select add_retention_policy('test_table', INTERVAL '3 month', true); add_retention_policy ---------------------- 1002 -- Should not add new policy with different parameters select add_retention_policy('test_table', INTERVAL '3 month', true); NOTICE: retention policy already exists for hypertable "test_table", skipping add_retention_policy ---------------------- -1 select add_retention_policy('test_table', INTERVAL '1 year', if_not_exists => true); WARNING: retention policy already exists for hypertable "test_table" add_retention_policy ---------------------- -1 select add_retention_policy('test_table', INTERVAL '3 days', if_not_exists => true); WARNING: retention policy already exists for hypertable "test_table" add_retention_policy ---------------------- -1 select add_retention_policy('test_table', INTERVAL '3 days', if_not_exists => true); WARNING: retention policy already exists for hypertable "test_table" add_retention_policy ---------------------- -1 SELECT * FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_retention' ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+------------------------------------------------+------------------------+------------------------+---------- 1002 | Retention Policy [1002] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 1 | {"drop_after": "@ 3 mons", "hypertable_id": 1} | _timescaledb_functions | policy_retention_check | \set ON_ERROR_STOP 0 select add_retention_policy('test_table', INTERVAL '1 year'); ERROR: retention policy already exists for hypertable "test_table" select add_retention_policy('test_table', INTERVAL '3 days'); ERROR: retention policy already exists for hypertable "test_table" \set ON_ERROR_STOP 1 SELECT * FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_retention' ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+------------------------------------------------+------------------------+------------------------+---------- 1002 | Retention Policy [1002] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 1 | {"drop_after": "@ 3 mons", "hypertable_id": 1} | _timescaledb_functions | policy_retention_check | select remove_retention_policy('test_table'); remove_retention_policy ------------------------- -- Test set_integer_now_func and add_retention_policy with -- hypertables that have integer time dimension select * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+--------------------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp with time zone | t | | | | 604800000000 | | | 2 | 2 | time | bigint | t | | | | 1 | | | \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_new_schema; create or replace function my_new_schema.dummy_now2() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; grant usage on SCHEMA my_new_schema to public; grant execute on ALL FUNCTIONS IN SCHEMA my_new_schema to public; select set_integer_now_func('test_table_int', 'my_new_schema.dummy_now2'); set_integer_now_func ---------------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select * from _timescaledb_catalog.dimension; id | hypertable_id | column_name | column_type | aligned | num_slices | partitioning_func_schema | partitioning_func | interval_length | compress_interval_length | integer_now_func_schema | integer_now_func ----+---------------+-------------+--------------------------+---------+------------+--------------------------+-------------------+-----------------+--------------------------+-------------------------+------------------ 1 | 1 | time | timestamp with time zone | t | | | | 604800000000 | | | 2 | 2 | time | bigint | t | | | | 1 | | my_new_schema | dummy_now2 SELECT * FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_retention' ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- select remove_reorder_policy('test_table'); remove_reorder_policy ----------------------- SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- select add_retention_policy('test_table', INTERVAL '3 month'); add_retention_policy ---------------------- 1003 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+------------------------------------------------+------------------------+------------------------+---------- 1003 | Retention Policy [1003] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 1 | {"drop_after": "@ 3 mons", "hypertable_id": 1} | _timescaledb_functions | policy_retention_check | select remove_retention_policy('test_table'); remove_retention_policy ------------------------- SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- select add_retention_policy('test_table_int', 1); add_retention_policy ---------------------- 1004 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+---------------------------------------+------------------------+------------------------+---------- 1004 | Retention Policy [1004] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 2 | {"drop_after": 1, "hypertable_id": 2} | _timescaledb_functions | policy_retention_check | -- Should not add new policy with different parameters select add_retention_policy('test_table_int', 2, true); WARNING: retention policy already exists for hypertable "test_table_int" add_retention_policy ---------------------- -1 select remove_retention_policy('test_table_int'); remove_retention_policy ------------------------- SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- Make sure remove works when there's nothing to remove select remove_retention_policy('test_table', true); NOTICE: retention policy not found for hypertable "test_table", skipping remove_retention_policy ------------------------- select remove_reorder_policy('test_table', true); NOTICE: reorder policy not found for hypertable "test_table", skipping remove_reorder_policy ----------------------- \set ON_ERROR_STOP 0 select remove_retention_policy(); ERROR: function remove_retention_policy() does not exist at character 8 select remove_retention_policy('fake_table'); ERROR: relation "fake_table" does not exist at character 32 select remove_reorder_policy(); ERROR: function remove_reorder_policy() does not exist at character 8 select remove_reorder_policy('fake_table'); ERROR: relation "fake_table" does not exist at character 30 \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 -- This should be noop select remove_reorder_policy(2, true); ERROR: OID 2 does not refer to a table -- Fail with error message select remove_reorder_policy(2); ERROR: OID 2 does not refer to a table \set ON_ERROR_STOP 1 -- Now make sure policy args have correct job deletion dependency SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- select add_retention_policy('test_table', INTERVAL '2 month') as job_id \gset select add_reorder_policy('test_table', 'third_index') as reorder_job_id \gset select count(*) from _timescaledb_config.bgw_job where id=:job_id; count ------- 1 select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; count ------- 1 select delete_job(:job_id); delete_job ------------ select count(*) from _timescaledb_config.bgw_job where id=:job_id; count ------- 0 -- Job config should still be there select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; count ------- 1 select delete_job(:reorder_job_id); delete_job ------------ select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; count ------- 0 -- Now make sure policy args have correct job deletion dependency select add_retention_policy('test_table', INTERVAL '2 month') as job_id \gset select add_reorder_policy('test_table', 'third_index') as reorder_job_id \gset select count(*) from _timescaledb_config.bgw_job where id=:job_id; count ------- 1 select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; count ------- 1 DROP TABLE test_table; select count(*) from _timescaledb_config.bgw_job where id=:job_id; count ------- 0 select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; count ------- 0 -- Check that we can't add policies on non-hypertables CREATE TABLE non_hypertable(junk int, more_junk int); CREATE INDEX non_ht_index on non_hypertable(junk); \set ON_ERROR_STOP 0 select add_retention_policy('non_hypertable', INTERVAL '2 month'); ERROR: "non_hypertable" is not a hypertable or a continuous aggregate select add_reorder_policy('non_hypertable', 'non_ht_index'); ERROR: table "non_hypertable" is not a hypertable \set ON_ERROR_STOP 1 -- Now make sure things work with multiple policies on multiple hypertables CREATE TABLE test_table(time timestamptz, junk int); SELECT create_hypertable('test_table', 'time'); create_hypertable ------------------------- (4,public,test_table,t) CREATE INDEX second_index on test_table (time); CREATE TABLE test_table2(time timestamptz, junk int); SELECT create_hypertable('test_table2', 'time'); create_hypertable -------------------------- (5,public,test_table2,t) CREATE INDEX junk_index on test_table2 (junk); select add_retention_policy('test_table', INTERVAL '2 days'); add_retention_policy ---------------------- 1009 select add_retention_policy('test_table2', INTERVAL '1 days'); add_retention_policy ---------------------- 1010 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+------------------------------------------------+------------------------+------------------------+---------- 1009 | Retention Policy [1009] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 4 | {"drop_after": "@ 2 days", "hypertable_id": 4} | _timescaledb_functions | policy_retention_check | 1010 | Retention Policy [1010] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 5 | {"drop_after": "@ 1 day", "hypertable_id": 5} | _timescaledb_functions | policy_retention_check | DROP TABLE test_table; DROP TABLE test_table_int; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------+------------------------+------------------------+---------- 1010 | Retention Policy [1010] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 5 | {"drop_after": "@ 1 day", "hypertable_id": 5} | _timescaledb_functions | policy_retention_check | DROP TABLE test_table2; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- Now test chunk_stat insertion select ts_test_chunk_stats_insert(123, 123, 45); ts_test_chunk_stats_insert ---------------------------- select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 123 | 123 | 45 \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_internal.bgw_policy_chunk_stats; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now test chunk_stat deletion is correct select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- CREATE TABLE test_table(time timestamptz, junk int); SELECT create_hypertable('test_table', 'time'); create_hypertable ------------------------- (6,public,test_table,t) CREATE INDEX second_index on test_table (time); insert into test_table values (now(), 1); insert into test_table values (now() - INTERVAL '5 weeks', 123); select c.id from _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as h where c.hypertable_id=h.id and h.table_name='test_table' ORDER BY c.id; id ---- 1 2 select c.id as chunk_id from _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as h where c.hypertable_id=h.id and h.table_name='test_table' ORDER BY c.id LIMIT 1 \gset select add_reorder_policy('test_table', 'second_index') as job_id \gset -- Simulate reorder job running and setting this stat row select ts_test_chunk_stats_insert(:job_id, :chunk_id, 1); ts_test_chunk_stats_insert ---------------------------- select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1011 | 1 | 1 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+----------------------------------------------------+------------------------+----------------------+---------- 1011 | Reorder Policy [1011] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 6 | {"index_name": "second_index", "hypertable_id": 6} | _timescaledb_functions | policy_reorder_check | -- Deleting a chunk that has nothing to do with the job should do nothing select c.table_name as other_chunk_name,c.schema_name as other_chunk_schema from _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as h where c.id != :chunk_id \gset select concat(:'other_chunk_schema','.',:'other_chunk_name') as other_chunk \gset DROP TABLE :other_chunk; select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1011 | 1 | 1 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+----------------------------------------------------+------------------------+----------------------+---------- 1011 | Reorder Policy [1011] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 6 | {"index_name": "second_index", "hypertable_id": 6} | _timescaledb_functions | policy_reorder_check | -- Dropping the hypertable should drop the chunk, which should drop the reorder policy DROP TABLE test_table; select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- Now check dropping a job will drop the chunk_stat row CREATE TABLE test_table(time timestamptz, junk int); SELECT create_hypertable('test_table', 'time'); create_hypertable ------------------------- (7,public,test_table,t) select add_reorder_policy('test_table', 'test_table_time_idx') as job_id \gset select add_retention_policy('test_table', INTERVAL '2 days', true); add_retention_policy ---------------------- 1013 select ts_test_chunk_stats_insert(:job_id, 123, 1); ts_test_chunk_stats_insert ---------------------------- select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1012 | 123 | 1 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-------------------------+-------------------+-------------+-------------+--------------+------------------------+------------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------+------------------------+------------------------+---------- 1012 | Reorder Policy [1012] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 7 | {"index_name": "test_table_time_idx", "hypertable_id": 7} | _timescaledb_functions | policy_reorder_check | 1013 | Retention Policy [1013] | @ 1 day | @ 5 mins | -1 | @ 5 mins | _timescaledb_functions | policy_retention | default_perm_user | t | f | | 7 | {"drop_after": "@ 2 days", "hypertable_id": 7} | _timescaledb_functions | policy_retention_check | -- Dropping the drop_chunks job should not affect the chunk_stats row select remove_retention_policy('test_table'); remove_retention_policy ------------------------- select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- 1012 | 123 | 1 SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------+------------------------+----------------------+---------- 1012 | Reorder Policy [1012] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 7 | {"index_name": "test_table_time_idx", "hypertable_id": 7} | _timescaledb_functions | policy_reorder_check | select remove_reorder_policy('test_table'); remove_reorder_policy ----------------------- -- Row should be gone select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; job_id | chunk_id | num_times_job_run --------+----------+------------------- SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ----+------------------+-------------------+-------------+-------------+--------------+-------------+-----------+-------+-----------+----------------+---------------+---------------+--------+--------------+------------+---------- -- Now test if alter_job works select add_reorder_policy('test_table', 'test_table_time_idx') as job_id \gset select * from _timescaledb_config.bgw_job where id=:job_id; id | application_name | schedule_interval | max_runtime | max_retries | retry_period | proc_schema | proc_name | owner | scheduled | fixed_schedule | initial_start | hypertable_id | config | check_schema | check_name | timezone ------+-----------------------+-------------------+-------------+-------------+--------------+------------------------+----------------+-------------------+-----------+----------------+---------------+---------------+-----------------------------------------------------------+------------------------+----------------------+---------- 1014 | Reorder Policy [1014] | @ 84 hours | @ 0 | -1 | @ 5 mins | _timescaledb_functions | policy_reorder | default_perm_user | t | f | | 7 | {"index_name": "test_table_time_idx", "hypertable_id": 7} | _timescaledb_functions | policy_reorder_check | -- No change select * from alter_job(:job_id); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 84 hours | @ 0 | -1 | @ 5 mins | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] -- Changes expected select * from alter_job(:job_id, INTERVAL '3 years', INTERVAL '5 min', 5, INTERVAL '123 sec'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+-----------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 3 years | @ 5 mins | 5 | @ 2 mins 3 secs | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, INTERVAL '123 years'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+-----------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 5 mins | 5 | @ 2 mins 3 secs | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, retry_period => INTERVAL '33 hours'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 5 mins | 5 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, max_runtime => INTERVAL '456 sec'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 7 mins 36 secs | 5 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, max_retries => 0); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 7 mins 36 secs | 0 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, max_retries => -1); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 7 mins 36 secs | -1 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, max_retries => 20); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] -- No change select * from alter_job(:job_id, max_runtime => NULL); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select * from alter_job(:job_id, max_retries => NULL); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 123 years | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --change schedule_interval when bgw_job_stat does not exist select * from alter_job(:job_id, schedule_interval=>'1 min'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 1 min | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] select count(*) = 0 from _timescaledb_internal.bgw_job_stat where job_id = :job_id; ?column? ---------- t --set next_start when bgw_job_stat does not exist select * from alter_job(:job_id, next_start=>'2001-01-01 01:01:01'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------------------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 1 min | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | Mon Jan 01 01:01:01 2001 PST | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --change schedule_interval when no last_finish set select * from alter_job(:job_id, schedule_interval=>'10 min'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 10 mins | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | -infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --next_start overrides any schedule_interval changes select * from alter_job(:job_id, schedule_interval=>'20 min', next_start=>'2002-01-01 01:01:01'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------------------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 20 mins | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | Tue Jan 01 01:01:01 2002 PST | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --set the last_finish manually \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_internal.bgw_job_stat SET last_finish = '2003-01-01:01:01:01' WHERE job_id = :job_id; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --not changing the interval doesn't change the next_start select * from alter_job(:job_id, schedule_interval=>'20 min'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------------------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 20 mins | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | Tue Jan 01 01:01:01 2002 PST | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --changing the interval changes next_start select * from alter_job(:job_id, schedule_interval=>'30 min'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------------------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 30 mins | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | Wed Jan 01 01:31:01 2003 PST | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --explicit next start overrides. select * from alter_job(:job_id, schedule_interval=>'40 min', next_start=>'2004-01-01 01:01:01'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------------------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 40 mins | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | Thu Jan 01 01:01:01 2004 PST | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --test pausing select * from alter_job(:job_id, next_start=>'infinity'); job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+------------------+-------------+--------------+-----------+-----------------------------------------------------------+------------+---------------------------------------------+----------------+---------------+----------+----------------------- 1014 | @ 40 mins | @ 7 mins 36 secs | 20 | @ 33 hours | t | {"index_name": "test_table_time_idx", "hypertable_id": 7} | infinity | _timescaledb_functions.policy_reorder_check | f | | | Reorder Policy [1014] --test that you can use now() to unpause select next_start = now() from alter_job(:job_id, next_start=>now()); ?column? ---------- t --test pausing/resuming via scheduled parameter select job_id from alter_job(:job_id, scheduled=>false); job_id -------- 1014 select job_status, next_start from timescaledb_information.job_stats where job_id = :job_id; job_status | next_start ------------+------------ Paused | select job_id from alter_job(:job_id, scheduled=>true); job_id -------- 1014 select job_status from timescaledb_information.job_stats where job_id = :job_id; job_status ------------ Scheduled \set ON_ERROR_STOP 0 -- negative infinity disallowed (used as special value) select * from alter_job(:job_id, next_start=>'-infinity'); ERROR: cannot set next start to -infinity -- index should exist select * from alter_job(:job_id, config => '{"index_name": "non-existent", "hypertable_id": 7}'); ERROR: reorder index not found -- index should be an index on the hypertable select * from alter_job(:job_id, config => '{"index_name": "non_ht_index", "hypertable_id": 7}'); ERROR: invalid reorder index -- hypertable should exist select * from alter_job(:job_id, config => '{"index_name": "test_table_time_idx", "hypertable_id": 47}'); ERROR: configuration hypertable id 47 not found \set ON_ERROR_STOP 1 -- Check if_exists boolean works correctly select * from alter_job(1234, if_exists => TRUE); NOTICE: job 1234 not found, skipping job_id | schedule_interval | max_runtime | max_retries | retry_period | scheduled | config | next_start | check_config | fixed_schedule | initial_start | timezone | application_name --------+-------------------+-------------+-------------+--------------+-----------+--------+------------+--------------+----------------+---------------+----------+------------------ | | | | | | | | | | | | \set ON_ERROR_STOP 0 select * from alter_job(1234); ERROR: job 1234 not found \set ON_ERROR_STOP 1 select remove_reorder_policy('test_table'); remove_reorder_policy ----------------------- \c :TEST_DBNAME :ROLE_SUPERUSER set session timescaledb.license_key='Community'; -- Test for failure cases \set ON_ERROR_STOP 0 select alter_job(12345); ERROR: job 12345 not found \set ON_ERROR_STOP 1 select add_reorder_policy('test_table', 'test_table_time_idx') as reorder_job_id \gset select add_retention_policy('test_table', INTERVAL '4 months', true) as drop_chunks_job_id \gset \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:reorder_job_id, max_runtime => NULL); ERROR: insufficient permissions to alter job 1015 select from alter_job(:drop_chunks_job_id, max_runtime => NULL); ERROR: insufficient permissions to alter job 1016 \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/unlogged.out���������������������������������������������������0000664�0000000�0000000�00000007705�15100345067�0022003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE UNLOGGED TABLE t1(time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column SELECT oid::regclass,relpersistence from pg_class where oid = 't1'::regclass; oid | relpersistence -----+---------------- t1 | u INSERT INTO t1 SELECT '2025-01-01'; SELECT count(compress_chunk(chunk)) FROM show_chunks('t1') chunk; count ------- 1 -- check that all objects related to hypertable are unlogged SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence ----------------------------------------------------------------------------------+---------------- t1 | u t1_time_idx | u _timescaledb_internal._hyper_1_1_chunk | u _timescaledb_internal._hyper_1_1_chunk_t1_time_idx | u _timescaledb_internal.compress_hyper_2_2_chunk | u _timescaledb_internal.compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_idx | u ALTER TABLE t1 SET LOGGED; SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence -----+---------------- SELECT show_chunks('t1') AS "CHUNK" \gset ALTER TABLE :CHUNK SET UNLOGGED; -- only chunk and compressed chunk should be unlogged now but not hypertable SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence ----------------------------------------------------------------------------------+---------------- _timescaledb_internal._hyper_1_1_chunk | u _timescaledb_internal._hyper_1_1_chunk_t1_time_idx | u _timescaledb_internal.compress_hyper_2_2_chunk | u _timescaledb_internal.compress_hyper_2_2_chunk__ts_meta_min_1__ts_meta_max_1_idx | u ALTER TABLE t1 SET LOGGED; -- all objects should be logged now SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence -----+---------------- DROP TABLE t1; CREATE TABLE t2(time timestamptz) WITH (tsdb.hypertable); NOTICE: using column "time" as partitioning column ALTER TABLE t2 SET UNLOGGED; SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence -------------+---------------- t2 | u t2_time_idx | u INSERT INTO t2 SELECT '2025-01-01'; -- new chunk should be unlogged SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence ----------------------------------------------------+---------------- t2 | u t2_time_idx | u _timescaledb_internal._hyper_3_3_chunk | u _timescaledb_internal._hyper_3_3_chunk_t2_time_idx | u ALTER TABLE t2 SET LOGGED; -- everything should be logged now SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; oid | relpersistence -----+---------------- �����������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_byte.out��������������������������������������������0000664�0000000�0000000�00000010340�15100345067�0023327�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Tests for grouping by single-byte data types. Only bool for now, because char -- lacks a vectorized representation. create table groupbyte(ts int, b bool, x text, i int) with (tsdb.hypertable, tsdb.partition_column = 'ts', tsdb.chunk_interval = '10', tsdb.compress, tsdb.compress_segmentby = 'b', tsdb.compress_orderby = ts); insert into groupbyte select 1, case when x % 11 = 0 then null else x % 3 = 0 end, case when x % 13 = 0 then null else 'tag' || (x % 7) end, x from generate_series(1, 1000) x; select count(compress_chunk(x)) from show_chunks('groupbyte') x; count ------- 1 alter table groupbyte set (tsdb.compress_segmentby = ''); insert into groupbyte select 11, case when x % 11 = 0 then null else x % 3 = 0 end, case when x % 13 = 0 then null else 'tag' || (x % 7) end, x from generate_series(1, 1000) x; select count(compress_chunk(x)) from show_chunks('groupbyte') x; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select format('select %s%s from groupbyte%s%s;', grouping || ', ', function, ' group by ' || grouping, ' order by ' || function || ', ' || grouping || ' limit 10') from unnest(array[ 'count(*)' , 'count(b)' , 'sum(i)' ]) function, unnest(array[ null , 'b' , 'b, x' , 'x, b' ]) with ordinality as grouping(grouping, n) order by function, grouping.n \gexec select count(*) from groupbyte; count ------- 2000 select b, count(*) from groupbyte group by b order by count(*), b limit 10; b | count ---+------- | 180 t | 606 f | 1214 select b, x, count(*) from groupbyte group by b, x order by count(*), b, x limit 10; b | x | count ---+------+------- | | 12 | tag0 | 24 | tag1 | 24 | tag2 | 24 | tag3 | 24 | tag4 | 24 | tag5 | 24 | tag6 | 24 t | | 46 t | tag1 | 78 select x, b, count(*) from groupbyte group by x, b order by count(*), x, b limit 10; x | b | count ------+---+------- | | 12 tag0 | | 24 tag1 | | 24 tag2 | | 24 tag3 | | 24 tag4 | | 24 tag5 | | 24 tag6 | | 24 | t | 46 tag1 | t | 78 select count(b) from groupbyte; count ------- 1820 select b, count(b) from groupbyte group by b order by count(b), b limit 10; b | count ---+------- | 0 t | 606 f | 1214 select b, x, count(b) from groupbyte group by b, x order by count(b), b, x limit 10; b | x | count ---+------+------- | tag0 | 0 | tag1 | 0 | tag2 | 0 | tag3 | 0 | tag4 | 0 | tag5 | 0 | tag6 | 0 | | 0 t | | 46 t | tag1 | 78 select x, b, count(b) from groupbyte group by x, b order by count(b), x, b limit 10; x | b | count ------+---+------- tag0 | | 0 tag1 | | 0 tag2 | | 0 tag3 | | 0 tag4 | | 0 tag5 | | 0 tag6 | | 0 | | 0 | t | 46 tag1 | t | 78 select sum(i) from groupbyte; sum --------- 1001000 select b, sum(i) from groupbyte group by b order by sum(i), b limit 10; b | sum ---+-------- | 90090 t | 302976 f | 607934 select b, x, sum(i) from groupbyte group by b, x order by sum(i), b, x limit 10; b | x | sum ---+------+------- | | 6006 | tag4 | 10582 | tag1 | 11154 | tag5 | 11726 | tag0 | 12012 | tag2 | 12298 | tag6 | 12870 | tag3 | 13442 t | | 22776 t | tag3 | 39342 select x, b, sum(i) from groupbyte group by x, b order by sum(i), x, b limit 10; x | b | sum ------+---+------- | | 6006 tag4 | | 10582 tag1 | | 11154 tag5 | | 11726 tag0 | | 12012 tag2 | | 12298 tag6 | | 12870 tag3 | | 13442 | t | 22776 tag3 | t | 39342 reset timescaledb.debug_require_vector_agg; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_default.out�����������������������������������������0000664�0000000�0000000�00000013245�15100345067�0024017�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Uncomment these two settings to run this test with hypercore TAM --set timescaledb.default_hypercore_use_access_method=true; --set enable_indexscan=off; create function stable_abs(x int4) returns int4 as 'int4abs' language internal stable; create table dvagg(a int, b int); select create_hypertable('dvagg', 'a', chunk_time_interval => 1000); create_hypertable -------------------- (1,public,dvagg,t) insert into dvagg select x, x % 5 from generate_series(1, 999) x; alter table dvagg set (timescaledb.compress); select compress_chunk(show_chunks('dvagg')); compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk alter table dvagg add column c int default 7; insert into dvagg select x, x % 5, 11 from generate_series(1001, 1999) x; select compress_chunk(show_chunks('dvagg')); NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk vacuum analyze dvagg; -- Just the most basic vectorized aggregation query on a table with default -- compressed column. explain (buffers off, costs off) select sum(c) from dvagg; --- QUERY PLAN --- Finalize Aggregate -> Append -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Seq Scan on compress_hyper_2_2_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Seq Scan on compress_hyper_2_4_chunk select sum(c) from dvagg; sum ------- 17982 set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference --set timescaledb.debug_require_vector_agg = 'forbid'; --set timescaledb.enable_vectorized_aggregation to off; -- Vectorized aggregation should work with vectorized filters. select sum(c) from dvagg where b >= 0; sum ------- 17982 select sum(c) from dvagg where b = 0; sum ------ 3582 select sum(c) from dvagg where b in (0, 1); sum ------ 7182 select sum(c) from dvagg where b in (0, 1, 3); sum ------- 10782 select sum(c) from dvagg where b > 10; sum ----- select count(*) from dvagg where b >= 0; count ------- 1998 select count(*) from dvagg where b = 0; count ------- 398 select count(*) from dvagg where b in (0, 1); count ------- 798 select count(*) from dvagg where b in (0, 1, 3); count ------- 1198 select count(*) from dvagg where b > 10; count ------- 0 explain (buffers off, costs off) select sum(c) from dvagg where b in (0, 1, 3); --- QUERY PLAN --- Finalize Aggregate -> Append -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (b = ANY ('{0,1,3}'::integer[])) -> Seq Scan on compress_hyper_2_2_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk Vectorized Filter: (b = ANY ('{0,1,3}'::integer[])) -> Seq Scan on compress_hyper_2_4_chunk select sum(a), sum(b), sum(c) from dvagg where b in (0, 1, 3); sum | sum | sum ---------+------+------- 1197600 | 1600 | 10782 explain (buffers off, costs off) select sum(a), sum(b), sum(c) from dvagg where b in (0, 1, 3); --- QUERY PLAN --- Finalize Aggregate -> Append -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (b = ANY ('{0,1,3}'::integer[])) -> Seq Scan on compress_hyper_2_2_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk Vectorized Filter: (b = ANY ('{0,1,3}'::integer[])) -> Seq Scan on compress_hyper_2_4_chunk reset timescaledb.enable_vectorized_aggregation; -- The runtime chunk exclusion should work. explain (buffers off, costs off) select sum(c) from dvagg where a < stable_abs(1000); --- QUERY PLAN --- Finalize Aggregate -> Custom Scan (ChunkAppend) on dvagg Chunks excluded during startup: 1 -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: (a < stable_abs(1000)) -> Seq Scan on compress_hyper_2_2_chunk Filter: (_ts_meta_min_1 < stable_abs(1000)) -- The case with HAVING can still be vectorized because it is applied after -- final aggregation. select sum(c) from dvagg having sum(c) > 0; sum ------- 17982 -- Some negative cases. set timescaledb.debug_require_vector_agg to 'forbid'; explain (buffers off, costs off) select sum(c) from dvagg group by grouping sets ((), (a)); --- QUERY PLAN --- MixedAggregate Hash Key: dvagg.a Group Key: () -> Append -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Seq Scan on compress_hyper_2_2_chunk -> Custom Scan (ColumnarScan) on _hyper_1_3_chunk -> Seq Scan on compress_hyper_2_4_chunk -- As a reference, the result on decompressed table. select decompress_chunk(show_chunks('dvagg')); decompress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_3_chunk select sum(c) from dvagg; sum ------- 17982 drop table dvagg; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_filter.out������������������������������������������0000664�0000000�0000000�00000142643�15100345067�0023665�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; -- non-vectorizable equality operator create operator === (function = 'int4eq', rightarg = int4, leftarg = int4); -- an abs() function that is stable not immutable create function stable_abs(x int4) returns int4 as 'int4abs' language internal stable; \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table aggfilter(t int, s int, cint2 int2, dropped int4, cint4 int4); select create_hypertable('aggfilter', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create_hypertable ------------------------ (1,public,aggfilter,t) create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, 1 as dropped, (mix(s + t * 1021) * 32767)::int4 as cint4 from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into aggfilter select * from source where s = 1; alter table aggfilter set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('aggfilter') x; count ------- 1 alter table aggfilter add column ss int default 11; alter table aggfilter drop column dropped; insert into aggfilter select t, s, cint2, cint4, case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1053 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss from source where s != 1 ; -- print a few reference values before compression select count(ss) from aggfilter; count -------- 179981 select count(ss) filter (where cint2 < 0) from aggfilter; count ------- 90014 select count(ss) filter (where cint4 > 0) from aggfilter; count ------- 90142 select count(ss) filter (where s != 5) from aggfilter; count -------- 159981 select s, count(ss) from aggfilter group by s having s=2 order by count(ss), s limit 10; s | count ---+------- 2 | 0 select s, count(ss) filter (where cint2 < 0) from aggfilter group by s having s=2 order by count(ss), s limit 10; s | count ---+------- 2 | 0 select s, count(ss) filter (where ss > 1000) from aggfilter group by s having s=2 order by count(ss), s limit 10; s | count ---+------- 2 | 0 select s, count(ss) filter (where cint4 > 0) from aggfilter group by s having s=2 order by count(ss), s limit 10; s | count ---+------- 2 | 0 select count(compress_chunk(x)) from show_chunks('aggfilter') x; count ------- 2 vacuum freeze analyze aggfilter; set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; set max_parallel_workers_per_gather = 0; select format('%sselect %s%s(%s)%s from aggfilter%s%s%s;', explain, grouping || ', ', function, variable, ' filter (where ' || agg_filter || ')', ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 's', 'ss', 'cint2', 'cint4', '*']) variable, unnest(array[ 'min', 'count']) function, unnest(array[ null, 'cint2 > 0', 'cint2 is null']) with ordinality as condition(condition, n), unnest(array[ null, 's']) with ordinality as grouping(grouping, n), unnest(array[ null, 'cint2 < 0', 'ss > 1000', 'cint4 > 0', 's != 5']) with ordinality as agg_filter(agg_filter, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') order by explain, condition.n, variable, function, grouping.n, agg_filter.n \gexec select count(*) from aggfilter; count -------- 200000 select count(*) filter (where cint2 < 0) from aggfilter; count -------- 100139 select count(*) filter (where ss > 1000) from aggfilter; count ------- 0 select count(*) filter (where cint4 > 0) from aggfilter; count -------- 100038 select count(*) filter (where s != 5) from aggfilter; count -------- 180000 select s, count(*) from aggfilter group by s order by count(*), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select s, count(*) filter (where cint2 < 0) from aggfilter group by s order by count(*), s limit 10; s | count ---+------- 0 | 9968 1 | 9885 2 | 10113 3 | 10088 4 | 10074 5 | 9871 6 | 10089 7 | 10008 8 | 10082 9 | 9961 select s, count(*) filter (where ss > 1000) from aggfilter group by s order by count(*), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(*) filter (where cint4 > 0) from aggfilter group by s order by count(*), s limit 10; s | count ---+------- 0 | 10002 1 | 10046 2 | 9885 3 | 10063 4 | 9995 5 | 10106 6 | 9977 7 | 9983 8 | 10020 9 | 9961 select s, count(*) filter (where s != 5) from aggfilter group by s order by count(*), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 0 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select count(cint2) from aggfilter; count -------- 199810 select count(cint2) filter (where cint2 < 0) from aggfilter; count -------- 100139 select count(cint2) filter (where ss > 1000) from aggfilter; count ------- 0 select count(cint2) filter (where cint4 > 0) from aggfilter; count ------- 99946 select count(cint2) filter (where s != 5) from aggfilter; count -------- 179829 select s, count(cint2) from aggfilter group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 19981 1 | 19981 2 | 19981 3 | 19981 4 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 select s, count(cint2) filter (where cint2 < 0) from aggfilter group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 9968 1 | 9885 2 | 10113 3 | 10088 4 | 10074 5 | 9871 6 | 10089 7 | 10008 8 | 10082 9 | 9961 select s, count(cint2) filter (where ss > 1000) from aggfilter group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint2) filter (where cint4 > 0) from aggfilter group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 9993 1 | 10034 2 | 9876 3 | 10052 4 | 9990 5 | 10095 6 | 9968 7 | 9976 8 | 10010 9 | 9952 select s, count(cint2) filter (where s != 5) from aggfilter group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 19981 1 | 19981 2 | 19981 3 | 19981 4 | 19981 5 | 0 6 | 19981 7 | 19981 8 | 19981 9 | 19981 select min(cint2) from aggfilter; min -------- -16383 select min(cint2) filter (where cint2 < 0) from aggfilter; min -------- -16383 select min(cint2) filter (where ss > 1000) from aggfilter; min ----- select min(cint2) filter (where cint4 > 0) from aggfilter; min -------- -16383 select min(cint2) filter (where s != 5) from aggfilter; min -------- -16383 select s, min(cint2) from aggfilter group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 2 | -16382 7 | -16382 8 | -16382 3 | -16381 1 | -16378 9 | -16375 select s, min(cint2) filter (where cint2 < 0) from aggfilter group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 2 | -16382 7 | -16382 8 | -16382 3 | -16381 1 | -16378 9 | -16375 select s, min(cint2) filter (where ss > 1000) from aggfilter group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 4 | 5 | 6 | 2 | 7 | 8 | 3 | 1 | 9 | select s, min(cint2) filter (where cint4 > 0) from aggfilter group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16380 4 | -16381 5 | -16383 6 | -16379 2 | -16382 7 | -16382 8 | -16382 3 | -16380 1 | -16378 9 | -16375 select s, min(cint2) filter (where s != 5) from aggfilter group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 4 | -16383 5 | 6 | -16383 2 | -16382 7 | -16382 8 | -16382 3 | -16381 1 | -16378 9 | -16375 select count(cint4) from aggfilter; count -------- 200000 select count(cint4) filter (where cint2 < 0) from aggfilter; count -------- 100139 select count(cint4) filter (where ss > 1000) from aggfilter; count ------- 0 select count(cint4) filter (where cint4 > 0) from aggfilter; count -------- 100038 select count(cint4) filter (where s != 5) from aggfilter; count -------- 180000 select s, count(cint4) from aggfilter group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select s, count(cint4) filter (where cint2 < 0) from aggfilter group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 9968 1 | 9885 2 | 10113 3 | 10088 4 | 10074 5 | 9871 6 | 10089 7 | 10008 8 | 10082 9 | 9961 select s, count(cint4) filter (where ss > 1000) from aggfilter group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint4) filter (where cint4 > 0) from aggfilter group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 10002 1 | 10046 2 | 9885 3 | 10063 4 | 9995 5 | 10106 6 | 9977 7 | 9983 8 | 10020 9 | 9961 select s, count(cint4) filter (where s != 5) from aggfilter group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 0 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select min(cint4) from aggfilter; min -------- -16383 select min(cint4) filter (where cint2 < 0) from aggfilter; min -------- -16383 select min(cint4) filter (where ss > 1000) from aggfilter; min ----- select min(cint4) filter (where cint4 > 0) from aggfilter; min ----- 1 select min(cint4) filter (where s != 5) from aggfilter; min -------- -16383 select s, min(cint4) from aggfilter group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 2 | -16383 7 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16382 5 | -16380 select s, min(cint4) filter (where cint2 < 0) from aggfilter group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16382 2 | -16383 7 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16381 8 | -16382 9 | -16381 5 | -16380 select s, min(cint4) filter (where ss > 1000) from aggfilter group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 2 | 7 | 1 | 3 | 4 | 6 | 8 | 9 | 5 | select s, min(cint4) filter (where cint4 > 0) from aggfilter group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 1 2 | 2 7 | 1 1 | 3 3 | 2 4 | 2 6 | 2 8 | 2 9 | 2 5 | 2 select s, min(cint4) filter (where s != 5) from aggfilter group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 2 | -16383 7 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16382 5 | select count(s) from aggfilter; count -------- 200000 select count(s) filter (where cint2 < 0) from aggfilter; count -------- 100139 select count(s) filter (where ss > 1000) from aggfilter; count ------- 0 select count(s) filter (where cint4 > 0) from aggfilter; count -------- 100038 select count(s) filter (where s != 5) from aggfilter; count -------- 180000 select s, count(s) from aggfilter group by s order by count(s), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select s, count(s) filter (where cint2 < 0) from aggfilter group by s order by count(s), s limit 10; s | count ---+------- 0 | 9968 1 | 9885 2 | 10113 3 | 10088 4 | 10074 5 | 9871 6 | 10089 7 | 10008 8 | 10082 9 | 9961 select s, count(s) filter (where ss > 1000) from aggfilter group by s order by count(s), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(s) filter (where cint4 > 0) from aggfilter group by s order by count(s), s limit 10; s | count ---+------- 0 | 10002 1 | 10046 2 | 9885 3 | 10063 4 | 9995 5 | 10106 6 | 9977 7 | 9983 8 | 10020 9 | 9961 select s, count(s) filter (where s != 5) from aggfilter group by s order by count(s), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 0 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select min(s) from aggfilter; min ----- 0 select min(s) filter (where cint2 < 0) from aggfilter; min ----- 0 select min(s) filter (where ss > 1000) from aggfilter; min ----- select min(s) filter (where cint4 > 0) from aggfilter; min ----- 0 select min(s) filter (where s != 5) from aggfilter; min ----- 0 select s, min(s) from aggfilter group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where cint2 < 0) from aggfilter group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where ss > 1000) from aggfilter group by s order by min(s), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(s) filter (where cint4 > 0) from aggfilter group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where s != 5) from aggfilter group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 6 | 6 7 | 7 8 | 8 9 | 9 select count(ss) from aggfilter; count -------- 179981 select count(ss) filter (where cint2 < 0) from aggfilter; count ------- 90014 select count(ss) filter (where ss > 1000) from aggfilter; count ------- 0 select count(ss) filter (where cint4 > 0) from aggfilter; count ------- 90142 select count(ss) filter (where s != 5) from aggfilter; count -------- 159981 select s, count(ss) from aggfilter group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 19981 0 | 20000 1 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select s, count(ss) filter (where cint2 < 0) from aggfilter group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 10076 0 | 9968 1 | 9885 4 | 10074 5 | 9871 6 | 10089 7 | 10008 8 | 10082 9 | 9961 select s, count(ss) filter (where ss > 1000) from aggfilter group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 0 0 | 0 1 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(ss) filter (where cint4 > 0) from aggfilter group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 10052 0 | 10002 1 | 10046 4 | 9995 5 | 10106 6 | 9977 7 | 9983 8 | 10020 9 | 9961 select s, count(ss) filter (where s != 5) from aggfilter group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 19981 0 | 20000 1 | 20000 4 | 20000 5 | 0 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select min(ss) from aggfilter; min ----- 0 select min(ss) filter (where cint2 < 0) from aggfilter; min ----- 0 select min(ss) filter (where ss > 1000) from aggfilter; min ----- select min(ss) filter (where cint4 > 0) from aggfilter; min ----- 0 select min(ss) filter (where s != 5) from aggfilter; min ----- 0 select s, min(ss) from aggfilter group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where cint2 < 0) from aggfilter group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where ss > 1000) from aggfilter group by s order by min(ss), s limit 10; s | min ---+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 2 | select s, min(ss) filter (where cint4 > 0) from aggfilter group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where s != 5) from aggfilter group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select count(*) from aggfilter where cint2 > 0; count ------- 99664 select count(*) filter (where cint2 < 0) from aggfilter where cint2 > 0; count ------- 0 select count(*) filter (where ss > 1000) from aggfilter where cint2 > 0; count ------- 0 select count(*) filter (where cint4 > 0) from aggfilter where cint2 > 0; count ------- 49817 select count(*) filter (where s != 5) from aggfilter where cint2 > 0; count ------- 89554 select s, count(*) from aggfilter where cint2 > 0 group by s order by count(*), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 10110 select s, count(*) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by count(*), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(*) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by count(*), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(*) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by count(*), s limit 10; s | count ---+------- 2 | 4923 6 | 4911 3 | 4972 8 | 4929 4 | 4944 7 | 4990 0 | 4963 9 | 4951 1 | 5067 5 | 5167 select s, count(*) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by count(*), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 0 select count(cint2) from aggfilter where cint2 > 0; count ------- 99664 select count(cint2) filter (where cint2 < 0) from aggfilter where cint2 > 0; count ------- 0 select count(cint2) filter (where ss > 1000) from aggfilter where cint2 > 0; count ------- 0 select count(cint2) filter (where cint4 > 0) from aggfilter where cint2 > 0; count ------- 49817 select count(cint2) filter (where s != 5) from aggfilter where cint2 > 0; count ------- 89554 select s, count(cint2) from aggfilter where cint2 > 0 group by s order by count(cint2), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 10110 select s, count(cint2) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by count(cint2), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(cint2) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by count(cint2), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(cint2) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by count(cint2), s limit 10; s | count ---+------- 2 | 4923 6 | 4911 3 | 4972 8 | 4929 4 | 4944 7 | 4990 0 | 4963 9 | 4951 1 | 5067 5 | 5167 select s, count(cint2) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by count(cint2), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 0 select min(cint2) from aggfilter where cint2 > 0; min ----- 1 select min(cint2) filter (where cint2 < 0) from aggfilter where cint2 > 0; min ----- select min(cint2) filter (where ss > 1000) from aggfilter where cint2 > 0; min ----- select min(cint2) filter (where cint4 > 0) from aggfilter where cint2 > 0; min ----- 1 select min(cint2) filter (where s != 5) from aggfilter where cint2 > 0; min ----- 1 select s, min(cint2) from aggfilter where cint2 > 0 group by s order by min(cint2), s limit 10; s | min ---+----- 1 | 1 2 | 1 3 | 1 5 | 1 7 | 1 8 | 1 9 | 2 6 | 3 0 | 4 4 | 4 select s, min(cint2) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by min(cint2), s limit 10; s | min ---+----- 1 | 2 | 3 | 5 | 7 | 8 | 9 | 6 | 0 | 4 | select s, min(cint2) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by min(cint2), s limit 10; s | min ---+----- 1 | 2 | 3 | 5 | 7 | 8 | 9 | 6 | 0 | 4 | select s, min(cint2) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by min(cint2), s limit 10; s | min ---+----- 1 | 4 2 | 4 3 | 1 5 | 1 7 | 1 8 | 1 9 | 6 6 | 3 0 | 6 4 | 4 select s, min(cint2) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by min(cint2), s limit 10; s | min ---+----- 1 | 1 2 | 1 3 | 1 5 | 7 | 1 8 | 1 9 | 2 6 | 3 0 | 4 4 | 4 select count(cint4) from aggfilter where cint2 > 0; count ------- 99664 select count(cint4) filter (where cint2 < 0) from aggfilter where cint2 > 0; count ------- 0 select count(cint4) filter (where ss > 1000) from aggfilter where cint2 > 0; count ------- 0 select count(cint4) filter (where cint4 > 0) from aggfilter where cint2 > 0; count ------- 49817 select count(cint4) filter (where s != 5) from aggfilter where cint2 > 0; count ------- 89554 select s, count(cint4) from aggfilter where cint2 > 0 group by s order by count(cint4), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 10110 select s, count(cint4) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by count(cint4), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(cint4) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by count(cint4), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(cint4) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by count(cint4), s limit 10; s | count ---+------- 2 | 4923 6 | 4911 3 | 4972 8 | 4929 4 | 4944 7 | 4990 0 | 4963 9 | 4951 1 | 5067 5 | 5167 select s, count(cint4) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by count(cint4), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 0 select min(cint4) from aggfilter where cint2 > 0; min -------- -16383 select min(cint4) filter (where cint2 < 0) from aggfilter where cint2 > 0; min ----- select min(cint4) filter (where ss > 1000) from aggfilter where cint2 > 0; min ----- select min(cint4) filter (where cint4 > 0) from aggfilter where cint2 > 0; min ----- 1 select min(cint4) filter (where s != 5) from aggfilter where cint2 > 0; min -------- -16383 select s, min(cint4) from aggfilter where cint2 > 0 group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16382 7 | -16382 9 | -16382 2 | -16377 8 | -16377 5 | -16375 select s, min(cint4) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 1 | 3 | 4 | 6 | 7 | 9 | 2 | 8 | 5 | select s, min(cint4) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 1 | 3 | 4 | 6 | 7 | 9 | 2 | 8 | 5 | select s, min(cint4) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 1 1 | 7 3 | 2 4 | 5 6 | 2 7 | 1 9 | 2 2 | 2 8 | 5 5 | 2 select s, min(cint4) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16382 7 | -16382 9 | -16382 2 | -16377 8 | -16377 5 | select count(s) from aggfilter where cint2 > 0; count ------- 99664 select count(s) filter (where cint2 < 0) from aggfilter where cint2 > 0; count ------- 0 select count(s) filter (where ss > 1000) from aggfilter where cint2 > 0; count ------- 0 select count(s) filter (where cint4 > 0) from aggfilter where cint2 > 0; count ------- 49817 select count(s) filter (where s != 5) from aggfilter where cint2 > 0; count ------- 89554 select s, count(s) from aggfilter where cint2 > 0 group by s order by count(s), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 10110 select s, count(s) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by count(s), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(s) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by count(s), s limit 10; s | count ---+------- 2 | 0 6 | 0 3 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(s) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by count(s), s limit 10; s | count ---+------- 2 | 4923 6 | 4911 3 | 4972 8 | 4929 4 | 4944 7 | 4990 0 | 4963 9 | 4951 1 | 5067 5 | 5167 select s, count(s) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by count(s), s limit 10; s | count ---+------- 2 | 9868 6 | 9890 3 | 9893 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 0 select min(s) from aggfilter where cint2 > 0; min ----- 0 select min(s) filter (where cint2 < 0) from aggfilter where cint2 > 0; min ----- select min(s) filter (where ss > 1000) from aggfilter where cint2 > 0; min ----- select min(s) filter (where cint4 > 0) from aggfilter where cint2 > 0; min ----- 0 select min(s) filter (where s != 5) from aggfilter where cint2 > 0; min ----- 0 select s, min(s) from aggfilter where cint2 > 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(s) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(s) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 6 | 6 7 | 7 8 | 8 9 | 9 select count(ss) from aggfilter where cint2 > 0; count ------- 89789 select count(ss) filter (where cint2 < 0) from aggfilter where cint2 > 0; count ------- 0 select count(ss) filter (where ss > 1000) from aggfilter where cint2 > 0; count ------- 0 select count(ss) filter (where cint4 > 0) from aggfilter where cint2 > 0; count ------- 44890 select count(ss) filter (where s != 5) from aggfilter where cint2 > 0; count ------- 79679 select s, count(ss) from aggfilter where cint2 > 0 group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 9886 6 | 9890 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 10110 select s, count(ss) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 0 6 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(ss) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 0 6 | 0 8 | 0 4 | 0 7 | 0 0 | 0 9 | 0 1 | 0 5 | 0 select s, count(ss) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 4968 6 | 4911 8 | 4929 4 | 4944 7 | 4990 0 | 4963 9 | 4951 1 | 5067 5 | 5167 select s, count(ss) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 3 | 9886 6 | 9890 8 | 9898 4 | 9906 7 | 9973 0 | 10012 9 | 10018 1 | 10096 5 | 0 select min(ss) from aggfilter where cint2 > 0; min ----- 0 select min(ss) filter (where cint2 < 0) from aggfilter where cint2 > 0; min ----- select min(ss) filter (where ss > 1000) from aggfilter where cint2 > 0; min ----- select min(ss) filter (where cint4 > 0) from aggfilter where cint2 > 0; min ----- 0 select min(ss) filter (where s != 5) from aggfilter where cint2 > 0; min ----- 0 select s, min(ss) from aggfilter where cint2 > 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where cint2 < 0) from aggfilter where cint2 > 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 2 | select s, min(ss) filter (where ss > 1000) from aggfilter where cint2 > 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 2 | select s, min(ss) filter (where cint4 > 0) from aggfilter where cint2 > 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where s != 5) from aggfilter where cint2 > 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select count(*) from aggfilter where cint2 is null; count ------- 190 select count(*) filter (where cint2 < 0) from aggfilter where cint2 is null; count ------- 0 select count(*) filter (where ss > 1000) from aggfilter where cint2 is null; count ------- 0 select count(*) filter (where cint4 > 0) from aggfilter where cint2 is null; count ------- 92 select count(*) filter (where s != 5) from aggfilter where cint2 is null; count ------- 171 select s, count(*) from aggfilter where cint2 is null group by s order by count(*), s limit 10; s | count ---+------- 0 | 19 1 | 19 2 | 19 3 | 19 4 | 19 5 | 19 6 | 19 7 | 19 8 | 19 9 | 19 select s, count(*) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by count(*), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(*) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by count(*), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(*) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by count(*), s limit 10; s | count ---+------- 0 | 9 1 | 12 2 | 9 3 | 11 4 | 5 5 | 11 6 | 9 7 | 7 8 | 10 9 | 9 select s, count(*) filter (where s != 5) from aggfilter where cint2 is null group by s order by count(*), s limit 10; s | count ---+------- 0 | 19 1 | 19 2 | 19 3 | 19 4 | 19 5 | 0 6 | 19 7 | 19 8 | 19 9 | 19 select count(cint2) from aggfilter where cint2 is null; count ------- 0 select count(cint2) filter (where cint2 < 0) from aggfilter where cint2 is null; count ------- 0 select count(cint2) filter (where ss > 1000) from aggfilter where cint2 is null; count ------- 0 select count(cint2) filter (where cint4 > 0) from aggfilter where cint2 is null; count ------- 0 select count(cint2) filter (where s != 5) from aggfilter where cint2 is null; count ------- 0 select s, count(cint2) from aggfilter where cint2 is null group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint2) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint2) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint2) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint2) filter (where s != 5) from aggfilter where cint2 is null group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select min(cint2) from aggfilter where cint2 is null; min ----- select min(cint2) filter (where cint2 < 0) from aggfilter where cint2 is null; min ----- select min(cint2) filter (where ss > 1000) from aggfilter where cint2 is null; min ----- select min(cint2) filter (where cint4 > 0) from aggfilter where cint2 is null; min ----- select min(cint2) filter (where s != 5) from aggfilter where cint2 is null; min ----- select s, min(cint2) from aggfilter where cint2 is null group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(cint2) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(cint2) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(cint2) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(cint2) filter (where s != 5) from aggfilter where cint2 is null group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select count(cint4) from aggfilter where cint2 is null; count ------- 190 select count(cint4) filter (where cint2 < 0) from aggfilter where cint2 is null; count ------- 0 select count(cint4) filter (where ss > 1000) from aggfilter where cint2 is null; count ------- 0 select count(cint4) filter (where cint4 > 0) from aggfilter where cint2 is null; count ------- 92 select count(cint4) filter (where s != 5) from aggfilter where cint2 is null; count ------- 171 select s, count(cint4) from aggfilter where cint2 is null group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 19 1 | 19 2 | 19 3 | 19 4 | 19 5 | 19 6 | 19 7 | 19 8 | 19 9 | 19 select s, count(cint4) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint4) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(cint4) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 9 1 | 12 2 | 9 3 | 11 4 | 5 5 | 11 6 | 9 7 | 7 8 | 10 9 | 9 select s, count(cint4) filter (where s != 5) from aggfilter where cint2 is null group by s order by count(cint4), s limit 10; s | count ---+------- 0 | 19 1 | 19 2 | 19 3 | 19 4 | 19 5 | 0 6 | 19 7 | 19 8 | 19 9 | 19 select min(cint4) from aggfilter where cint2 is null; min -------- -16291 select min(cint4) filter (where cint2 < 0) from aggfilter where cint2 is null; min ----- select min(cint4) filter (where ss > 1000) from aggfilter where cint2 is null; min ----- select min(cint4) filter (where cint4 > 0) from aggfilter where cint2 is null; min ----- 473 select min(cint4) filter (where s != 5) from aggfilter where cint2 is null; min -------- -16291 select s, min(cint4) from aggfilter where cint2 is null group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16291 7 | -16091 4 | -15724 5 | -15279 2 | -15063 6 | -14998 9 | -14699 8 | -14214 1 | -12217 3 | -9908 select s, min(cint4) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 7 | 4 | 5 | 2 | 6 | 9 | 8 | 1 | 3 | select s, min(cint4) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by min(cint4), s limit 10; s | min ---+----- 0 | 7 | 4 | 5 | 2 | 6 | 9 | 8 | 1 | 3 | select s, min(cint4) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by min(cint4), s limit 10; s | min ---+------ 0 | 701 7 | 1695 4 | 1821 5 | 587 2 | 2876 6 | 1003 9 | 2489 8 | 1334 1 | 2034 3 | 473 select s, min(cint4) filter (where s != 5) from aggfilter where cint2 is null group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16291 7 | -16091 4 | -15724 5 | 2 | -15063 6 | -14998 9 | -14699 8 | -14214 1 | -12217 3 | -9908 select count(s) from aggfilter where cint2 is null; count ------- 190 select count(s) filter (where cint2 < 0) from aggfilter where cint2 is null; count ------- 0 select count(s) filter (where ss > 1000) from aggfilter where cint2 is null; count ------- 0 select count(s) filter (where cint4 > 0) from aggfilter where cint2 is null; count ------- 92 select count(s) filter (where s != 5) from aggfilter where cint2 is null; count ------- 171 select s, count(s) from aggfilter where cint2 is null group by s order by count(s), s limit 10; s | count ---+------- 0 | 19 1 | 19 2 | 19 3 | 19 4 | 19 5 | 19 6 | 19 7 | 19 8 | 19 9 | 19 select s, count(s) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by count(s), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(s) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by count(s), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(s) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by count(s), s limit 10; s | count ---+------- 0 | 9 1 | 12 2 | 9 3 | 11 4 | 5 5 | 11 6 | 9 7 | 7 8 | 10 9 | 9 select s, count(s) filter (where s != 5) from aggfilter where cint2 is null group by s order by count(s), s limit 10; s | count ---+------- 0 | 19 1 | 19 2 | 19 3 | 19 4 | 19 5 | 0 6 | 19 7 | 19 8 | 19 9 | 19 select min(s) from aggfilter where cint2 is null; min ----- 0 select min(s) filter (where cint2 < 0) from aggfilter where cint2 is null; min ----- select min(s) filter (where ss > 1000) from aggfilter where cint2 is null; min ----- select min(s) filter (where cint4 > 0) from aggfilter where cint2 is null; min ----- 0 select min(s) filter (where s != 5) from aggfilter where cint2 is null; min ----- 0 select s, min(s) from aggfilter where cint2 is null group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by min(s), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(s) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by min(s), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select s, min(s) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select s, min(s) filter (where s != 5) from aggfilter where cint2 is null group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 6 | 6 7 | 7 8 | 8 9 | 9 select count(ss) from aggfilter where cint2 is null; count ------- 171 select count(ss) filter (where cint2 < 0) from aggfilter where cint2 is null; count ------- 0 select count(ss) filter (where ss > 1000) from aggfilter where cint2 is null; count ------- 0 select count(ss) filter (where cint4 > 0) from aggfilter where cint2 is null; count ------- 83 select count(ss) filter (where s != 5) from aggfilter where cint2 is null; count ------- 152 select s, count(ss) from aggfilter where cint2 is null group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 0 | 19 1 | 19 3 | 19 4 | 19 5 | 19 6 | 19 7 | 19 8 | 19 9 | 19 select s, count(ss) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 0 | 0 1 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(ss) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 0 | 0 1 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select s, count(ss) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 0 | 9 1 | 12 3 | 11 4 | 5 5 | 11 6 | 9 7 | 7 8 | 10 9 | 9 select s, count(ss) filter (where s != 5) from aggfilter where cint2 is null group by s order by count(ss), s limit 10; s | count ---+------- 2 | 0 0 | 19 1 | 19 3 | 19 4 | 19 5 | 0 6 | 19 7 | 19 8 | 19 9 | 19 select min(ss) from aggfilter where cint2 is null; min ----- 0 select min(ss) filter (where cint2 < 0) from aggfilter where cint2 is null; min ----- select min(ss) filter (where ss > 1000) from aggfilter where cint2 is null; min ----- select min(ss) filter (where cint4 > 0) from aggfilter where cint2 is null; min ----- 0 select min(ss) filter (where s != 5) from aggfilter where cint2 is null; min ----- 0 select s, min(ss) from aggfilter where cint2 is null group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where cint2 < 0) from aggfilter where cint2 is null group by s order by min(ss), s limit 10; s | min ---+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 2 | select s, min(ss) filter (where ss > 1000) from aggfilter where cint2 is null group by s order by min(ss), s limit 10; s | min ---+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 2 | select s, min(ss) filter (where cint4 > 0) from aggfilter where cint2 is null group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select s, min(ss) filter (where s != 5) from aggfilter where cint2 is null group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | reset timescaledb.debug_require_vector_agg; -- FILTER that is not vectorizable set timescaledb.debug_require_vector_agg = 'forbid'; select count(*) filter (where cint2 === 0) from aggfilter; count ------- 7 -- FILTER with stable function set timescaledb.debug_require_vector_agg = 'require'; select count(*) filter (where cint2 = stable_abs(0)) from aggfilter; count ------- 7 -- With hash grouping select ss, count(*) filter (where s != 5), count(*) filter (where cint2 < 0) from aggfilter group by ss order by 2, 3; ss | count | count ----+-------+------- 5 | 0 | 9871 4 | 19981 | 10064 3 | 19981 | 10076 9 | 20000 | 9961 0 | 20000 | 9968 7 | 20000 | 10008 8 | 20000 | 10082 6 | 20000 | 10089 11 | 20019 | 9895 | 20019 | 10125 reset timescaledb.debug_require_vector_agg; -- Grouping with a scalar UUID column (segmentby or default). create table uuid_default(ts int, value int4) with (tsdb.hypertable, tsdb.partition_column = 'ts', tsdb.compress, tsdb.chunk_interval = 1000); insert into uuid_default select generate_series(0, 999), 1; select count(compress_chunk(x)) from show_chunks('uuid_default') x; count ------- 1 alter table uuid_default add column id uuid default '842ab294-923a-4f50-be7d-af6c51903a5f'; alter table uuid_default set (tsdb.compress_segmentby = 'id'); insert into uuid_default select generate_series(1000, 1999), 2, '5dd0565f-1ddf-4a6c-9e96-9b2b8c8c3993'; select count(compress_chunk(x)) from show_chunks('uuid_default') x; NOTICE: chunk "_hyper_3_5_chunk" is already converted to columnstore count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; select id, sum(value) from uuid_default group by id; id | sum --------------------------------------+------ 5dd0565f-1ddf-4a6c-9e96-9b2b8c8c3993 | 2000 842ab294-923a-4f50-be7d-af6c51903a5f | 1000 select sum(value) filter (where id = '5dd0565f-1ddf-4a6c-9e96-9b2b8c8c3993') from uuid_default; sum ------ 2000 select sum(value) filter (where id = '842ab294-923a-4f50-be7d-af6c51903a5f') from uuid_default; sum ------ 1000 reset timescaledb.debug_require_vector_agg; reset max_parallel_workers_per_gather; ���������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_functions.out���������������������������������������0000664�0000000�0000000�00000464520�15100345067�0024411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table aggfns(t int, s int, cint2 int2, cint4 int4, cint8 int8, cfloat4 float4, cts timestamp, ctstz timestamptz, cdate date); select create_hypertable('aggfns', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); WARNING: column type "timestamp without time zone" used for "cts" does not follow best practices create_hypertable --------------------- (1,public,aggfns,t) create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, (mix(s + t * 1021) * 32767)::int4 as cint4, (mix(s + t * 1031) * 32767)::int8 as cint8, case when s = 1 and t = 1061 then 'nan'::float4 when s = 2 and t = 1061 then '+inf'::float4 when s = 3 and t = 1061 then '-inf'::float4 else (mix(s + t * 1033) * 100::int)::float4 end as cfloat4, '2021-01-01 01:01:01'::timestamp + interval '1 second' * (s * 10000) as cts, '2021-01-01 01:01:01'::timestamptz + interval '1 second' * (s * 10000) as ctstz, '2021-01-01'::date + interval '1 day' * (s * 10000) as cdate from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into aggfns select * from source where s = 1; alter table aggfns set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('aggfns') x; count ------- 1 alter table aggfns add column ss int default 11; alter table aggfns add column cfloat8 float8 default '13'; alter table aggfns add column x text default '11'; insert into aggfns select *, ss::text as x from ( select * , case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1053 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss , (mix(s + t * 1039) * 100)::float8 as cfloat8 from source where s != 1 ) t ; -- print some reference results before compression select ss, count(*) from aggfns group by ss having (ss=11 or ss is null) order by count(*), ss limit 10; ss | count ----+------- 11 | 20019 | 20019 select ss, min(cdate) from aggfns group by ss having (ss is null) order by min(cdate), ss limit 10; ss | min ----+------------ | 10-05-2075 select ss, avg(cfloat4) from aggfns group by ss having (ss is null) order by avg(cfloat4), ss limit 10; ss | avg ----+---------- | Infinity select ss, max(cfloat4) from aggfns group by ss having (ss=11 or ss is null) order by max(cfloat4), ss limit 10; ss | max ----+---------- | Infinity 11 | NaN select ss, min(cfloat4) from aggfns group by ss having (ss=11 or ss is null) order by min(cfloat4), ss limit 10; ss | min ----+---------- | -49.9991 11 | -49.9974 select ss, stddev(cfloat4) from aggfns group by ss having (ss is null) order by stddev(cfloat4), ss limit 10; ss | stddev ----+-------- | NaN select ss, avg(cfloat8) from aggfns group by ss having (ss is null or ss=11) order by avg(cfloat8), ss limit 10; ss | avg ----+------------------- | 0.203097089119745 11 | 12.9913492471038 select ss, max(cfloat8) from aggfns group by ss having (ss is null or ss=11) order by max(cfloat8), ss limit 10; ss | max ----+------------------ 11 | 42.8941954858601 | 49.9975695507601 select count(compress_chunk(x)) from show_chunks('aggfns') x; count ------- 2 vacuum freeze analyze aggfns; create table edges(t int, s int, ss int, f1 int); select create_hypertable('edges', 't', chunk_time_interval => 100000); create_hypertable -------------------- (3,public,edges,t) alter table edges set (timescaledb.compress, timescaledb.compress_segmentby='s'); insert into edges select s * 1000 + f1 as t, s, s, f1 from generate_series(0, 12) s, lateral generate_series(0, 60 + s + (s / 5::int) * 64 + (s / 10::int) * 2048) f1 ; insert into edges select 200000 t, 111 s, 111 ss, 1 f1; select count(compress_chunk(x)) from show_chunks('edges') x; count ------- 2 vacuum freeze analyze edges; -- We can't vectorize some aggregate functions on platforms withouth int128 -- support. Just relax the test requirements for them. I don't want to disable -- this test in release builds, and don't want to have the guc in release builds, -- so we'll assume we have int128 in all release builds. select case when setting::bool then 'require' else 'allow' end guc_value from pg_settings where name = 'timescaledb.debug_have_int128' union all select 'require' guc_value limit 1 \gset set timescaledb.debug_require_vector_agg = :'guc_value'; ---- Uncomment to generate reference. Note that there are minor discrepancies ---- on float4 due to different numeric stability in our and PG implementations. --set timescaledb.enable_chunkwise_aggregation to off; set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'forbid'; set max_parallel_workers_per_gather = 0; -- Disable sorting to force vectorized agg plans for min and max, -- which otherwise can produce a non-vectorized init-plan that does a -- sort with limit 1. set enable_sort = false; select format('%sselect %s%s(%s) from aggfns%s%s%s;', explain, grouping || ', ', function, variable, ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 't', 's', 'ss', 'cint2', 'cint4', 'cint8', 'cfloat4', 'cfloat8', 'cts', 'ctstz', 'cdate', '*']) variable, unnest(array[ 'min', 'max', 'sum', 'avg', 'stddev', 'count']) function, unnest(array[ null, 'cfloat8 > 0', 'cfloat8 <= 0', 'cfloat8 < 1000' /* vectorized qual is true for all rows */, 'cfloat8 > 1000' /* vectorized qual is false for all rows */, 'cint2 is null']) with ordinality as condition(condition, n), unnest(array[ null, 's', 'ss']) with ordinality as grouping(grouping, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') and (variable not in ('t', 'cts', 'ctstz', 'cdate') or function in ('min', 'max')) -- This is not vectorized yet and (variable != 'cint8' or function != 'stddev') and (function != 'count' or variable in ('cint2', 's', '*')) and (condition is distinct from 'cint2 is null' or variable = 'cint2') order by explain, condition.n, variable, function, grouping.n \gexec select count(*) from aggfns; count -------- 200000 select s, count(*) from aggfns group by s order by count(*), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select ss, count(*) from aggfns group by ss order by count(*), ss limit 10; ss | count ----+------- 3 | 19981 4 | 19981 0 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 11 | 20019 | 20019 select max(cdate) from aggfns; max ------------ 06-01-2267 select s, max(cdate) from aggfns group by s order by max(cdate), s limit 10; s | max ---+------------ 0 | 01-01-2021 1 | 05-19-2048 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, max(cdate) from aggfns group by ss order by max(cdate), ss limit 10; ss | max ----+------------ 0 | 01-01-2021 3 | 02-21-2103 | 02-21-2103 4 | 07-09-2130 11 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select min(cdate) from aggfns; min ------------ 01-01-2021 select s, min(cdate) from aggfns group by s order by min(cdate), s limit 10; s | min ---+------------ 0 | 01-01-2021 1 | 05-19-2048 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, min(cdate) from aggfns group by ss order by min(cdate), ss limit 10; ss | min ----+------------ 0 | 01-01-2021 11 | 05-19-2048 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select avg(cfloat4) from aggfns; avg ----- NaN select s, avg(cfloat4) from aggfns group by s order by avg(cfloat4), s limit 10; s | avg ---+---------------------- 3 | -Infinity 9 | -0.292700759558938 4 | -0.177721596086072 6 | -0.00610964622725733 5 | 0.0107821527590975 0 | 0.0862269837114494 7 | 0.19168354413514 8 | 0.456703752867272 2 | Infinity 1 | NaN select ss, avg(cfloat4) from aggfns group by ss order by avg(cfloat4), ss limit 10; ss | avg ----+---------------------- 3 | -Infinity 9 | -0.292700759558938 4 | -0.169252917487522 6 | -0.00610964622725733 5 | 0.0107821527590975 0 | 0.0862269837114494 7 | 0.19168354413514 8 | 0.456703752867272 | Infinity 11 | NaN select max(cfloat4) from aggfns; max ----- NaN select s, max(cfloat4) from aggfns group by s order by max(cfloat4), s limit 10; s | max ---+---------- 9 | 49.9899 4 | 49.9946 6 | 49.9956 7 | 49.9969 3 | 49.9979 5 | 49.9992 0 | 49.9995 8 | 49.9997 2 | Infinity 1 | NaN select ss, max(cfloat4) from aggfns group by ss order by max(cfloat4), ss limit 10; ss | max ----+---------- 9 | 49.9899 4 | 49.9946 6 | 49.9956 7 | 49.9969 3 | 49.9979 5 | 49.9992 0 | 49.9995 8 | 49.9997 | Infinity 11 | NaN select min(cfloat4) from aggfns; min ----------- -Infinity select s, min(cfloat4) from aggfns group by s order by min(cfloat4), s limit 10; s | min ---+----------- 3 | -Infinity 4 | -49.9999 6 | -49.9995 2 | -49.9991 7 | -49.9984 1 | -49.9974 8 | -49.9969 0 | -49.9949 5 | -49.9942 9 | -49.9911 select ss, min(cfloat4) from aggfns group by ss order by min(cfloat4), ss limit 10; ss | min ----+----------- 3 | -Infinity 4 | -49.9999 6 | -49.9995 | -49.9991 7 | -49.9984 11 | -49.9974 8 | -49.9969 0 | -49.9949 5 | -49.9942 9 | -49.9911 select stddev(cfloat4) from aggfns; stddev -------- NaN select s, stddev(cfloat4) from aggfns group by s order by stddev(cfloat4), s limit 10; s | stddev ---+------------------ 0 | 28.7274163912974 7 | 28.7892027644317 4 | 28.8273136003882 9 | 28.8426424990846 6 | 28.9190577543738 8 | 29.0040125904064 5 | 29.0213532270615 1 | NaN 2 | NaN 3 | NaN select ss, stddev(cfloat4) from aggfns group by ss order by stddev(cfloat4), ss limit 10; ss | stddev ----+------------------ 0 | 28.7274163912974 7 | 28.7892027644318 4 | 28.8220943927954 9 | 28.8426424990846 6 | 28.9190577543738 8 | 29.0040125904064 5 | 29.0213532270614 3 | NaN 11 | NaN | NaN select sum(cfloat4) from aggfns; sum ----- NaN select s, sum(cfloat4) from aggfns group by s order by sum(cfloat4), s limit 10; s | sum ---+----------- 3 | -Infinity 9 | -5854.02 4 | -3554.43 6 | -122.193 5 | 215.643 0 | 1724.54 7 | 3833.67 8 | 9134.08 2 | Infinity 1 | NaN select ss, sum(cfloat4) from aggfns group by ss order by sum(cfloat4), ss limit 10; ss | sum ----+----------- 3 | -Infinity 9 | -5854.02 4 | -3381.84 6 | -122.193 5 | 215.643 0 | 1724.54 7 | 3833.67 8 | 9134.08 | Infinity 11 | NaN select avg(cfloat8) from aggfns; avg ----------------- 1.2289014329263 select s, avg(cfloat8) from aggfns group by s order by avg(cfloat8), s limit 10; s | avg ---+-------------------- 0 | -0.306925132697215 8 | -0.268692900155438 4 | -0.220256273869891 3 | -0.14819676399231 9 | -0.114842409039848 7 | -0.063637967283139 5 | 0.0438265096326359 6 | 0.169599099685438 2 | 0.198140166982776 1 | 13 select ss, avg(cfloat8) from aggfns group by ss order by avg(cfloat8), ss limit 10; ss | avg ----+-------------------- 0 | -0.306925132697215 8 | -0.268692900155438 4 | -0.224160255000712 3 | -0.153492446187821 9 | -0.114842409039848 7 | -0.063637967283139 5 | 0.0438265096326359 6 | 0.169599099685438 | 0.203097089119745 11 | 12.9913492471038 select max(cfloat8) from aggfns; max ------------------ 49.9995574122295 select s, max(cfloat8) from aggfns group by s order by max(cfloat8), s limit 10; s | max ---+------------------ 1 | 13 5 | 49.9874341068789 3 | 49.9890822684392 6 | 49.9939429108053 8 | 49.9963666079566 0 | 49.9965498689562 7 | 49.9973275698721 2 | 49.9975695507601 4 | 49.9978997278959 9 | 49.9995574122295 select ss, max(cfloat8) from aggfns group by ss order by max(cfloat8), ss limit 10; ss | max ----+------------------ 11 | 42.8941954858601 5 | 49.9874341068789 3 | 49.9890822684392 6 | 49.9939429108053 8 | 49.9963666079566 0 | 49.9965498689562 7 | 49.9973275698721 | 49.9975695507601 4 | 49.9978997278959 9 | 49.9995574122295 select min(cfloat8) from aggfns; min ------------------- -49.9994775978848 select s, min(cfloat8) from aggfns group by s order by min(cfloat8), s limit 10; s | min ---+------------------- 0 | -49.9994775978848 2 | -49.9985320260748 4 | -49.9983572866768 3 | -49.9977725092322 6 | -49.9967515002936 9 | -49.992344272323 5 | -49.9921301845461 7 | -49.99003498815 8 | -49.9897602945566 1 | 13 select ss, min(cfloat8) from aggfns group by ss order by min(cfloat8), ss limit 10; ss | min ----+------------------- 0 | -49.9994775978848 | -49.9985320260748 4 | -49.9983572866768 3 | -49.9977725092322 6 | -49.9967515002936 9 | -49.992344272323 5 | -49.9921301845461 7 | -49.99003498815 8 | -49.9897602945566 11 | -46.2087355088443 select stddev(cfloat8) from aggfns; stddev ------------------ 27.6606134001179 select s, stddev(cfloat8) from aggfns group by s order by stddev(cfloat8), s limit 10; s | stddev ---+------------------ 1 | 0 2 | 28.7611066711723 9 | 28.7642081921344 4 | 28.77864036235 5 | 28.7843925303698 6 | 28.8543767497509 3 | 28.9210796983077 8 | 28.96331707256 0 | 28.965342556856 7 | 28.9656492103737 select ss, stddev(cfloat8) from aggfns group by ss order by stddev(cfloat8), ss limit 10; ss | stddev ----+------------------- 11 | 0.998497915010093 | 28.7561000172161 9 | 28.7642081921344 4 | 28.7760615445521 5 | 28.7843925303698 6 | 28.8543767497508 3 | 28.926156595386 8 | 28.96331707256 0 | 28.9653425568561 7 | 28.9656492103736 select sum(cfloat8) from aggfns; sum ----------------- 245780.28658526 select s, sum(cfloat8) from aggfns group by s order by sum(cfloat8), s limit 10; s | sum ---+------------------- 0 | -6138.50265394431 8 | -5373.85800310876 4 | -4405.12547739781 3 | -2963.93527984619 9 | -2296.84818079695 7 | -1272.75934566278 5 | 876.530192652717 6 | 3391.98199370876 2 | 3962.80333965551 1 | 260000 select ss, sum(cfloat8) from aggfns group by ss order by sum(cfloat8), ss limit 10; ss | sum ----+------------------- 0 | -6138.50265394431 8 | -5373.85800310876 4 | -4478.94605516922 3 | -3066.93256727885 9 | -2296.84818079695 7 | -1272.75934566278 5 | 876.530192652717 6 | 3391.98199370876 | 4065.80062708817 11 | 260073.820577771 select avg(cint2) from aggfns; avg ---------------------- -33.1461788699264301 select s, avg(cint2) from aggfns group by s order by avg(cint2), s limit 10; s | avg ---+----------------------- 2 | -158.3178019118162254 8 | -129.4959711726139833 3 | -95.7656773935238477 6 | -61.0756218407487113 7 | -55.8695260497472599 4 | -28.7127771382813673 9 | -21.7994594865121866 0 | 17.5951654071367799 1 | 91.9493518842900756 5 | 110.0305290025524248 select ss, avg(cint2) from aggfns group by ss order by avg(cint2), ss limit 10; ss | avg ----+----------------------- | -159.4671500000000000 8 | -129.4959711726139833 3 | -94.5546037471195271 6 | -61.0756218407487113 7 | -55.8695260497472599 4 | -27.5652740206392145 9 | -21.7994594865121866 0 | 17.5951654071367799 11 | 90.6894000000000000 5 | 110.0305290025524248 select count(cint2) from aggfns; count -------- 199810 select s, count(cint2) from aggfns group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 19981 1 | 19981 2 | 19981 3 | 19981 4 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 select ss, count(cint2) from aggfns group by ss order by count(cint2), ss limit 10; ss | count ----+------- 3 | 19962 4 | 19962 0 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 11 | 20000 | 20000 select max(cint2) from aggfns; max ------- 16383 select s, max(cint2) from aggfns group by s order by max(cint2), s limit 10; s | max ---+------- 3 | 16380 2 | 16381 5 | 16381 7 | 16381 8 | 16382 0 | 16383 1 | 16383 4 | 16383 6 | 16383 9 | 16383 select ss, max(cint2) from aggfns group by ss order by max(cint2), ss limit 10; ss | max ----+------- 3 | 16380 5 | 16381 7 | 16381 | 16381 8 | 16382 0 | 16383 4 | 16383 6 | 16383 9 | 16383 11 | 16383 select min(cint2) from aggfns; min -------- -16383 select s, min(cint2) from aggfns group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 2 | -16382 7 | -16382 8 | -16382 3 | -16381 1 | -16378 9 | -16375 select ss, min(cint2) from aggfns group by ss order by min(cint2), ss limit 10; ss | min ----+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 7 | -16382 8 | -16382 | -16382 3 | -16381 11 | -16378 9 | -16375 select stddev(cint2) from aggfns; stddev ------------------- 9475.597346265432 select s, stddev(cint2) from aggfns group by s order by stddev(cint2), s limit 10; s | stddev ---+------------------- 9 | 9450.322790943425 2 | 9458.737760855119 7 | 9462.161209850735 6 | 9467.569674984571 5 | 9467.776835158782 3 | 9473.424234931108 8 | 9477.586839536066 4 | 9483.720025499142 0 | 9484.907423282680 1 | 9528.039076724276 select ss, stddev(cint2) from aggfns group by ss order by stddev(cint2), ss limit 10; ss | stddev ----+------------------- 9 | 9450.322790943425 | 9457.685918593809 7 | 9462.161209850735 6 | 9467.569674984571 5 | 9467.776835158782 3 | 9474.482349111595 8 | 9477.586839536066 4 | 9483.611454519949 0 | 9484.907423282680 11 | 9528.120007675789 select sum(cint2) from aggfns; sum ---------- -6622938 select s, sum(cint2) from aggfns group by s order by sum(cint2), s limit 10; s | sum ---+---------- 2 | -3163348 8 | -2587459 3 | -1913494 6 | -1220352 7 | -1116329 4 | -573710 9 | -435575 0 | 351569 1 | 1837240 5 | 2198520 select ss, sum(cint2) from aggfns group by ss order by sum(cint2), ss limit 10; ss | sum ----+---------- | -3189343 8 | -2587459 3 | -1887499 6 | -1220352 7 | -1116329 4 | -550258 9 | -435575 0 | 351569 11 | 1813788 5 | 2198520 select avg(cint4) from aggfns; avg --------------------- -4.9369150000000000 select s, avg(cint4) from aggfns group by s order by avg(cint4), s limit 10; s | avg ---+----------------------- 9 | -102.4283000000000000 2 | -101.3952000000000000 6 | -53.1566500000000000 7 | -42.6121500000000000 8 | -29.2615500000000000 4 | 6.6530500000000000 0 | 27.7536500000000000 3 | 70.4102500000000000 1 | 71.5608500000000000 5 | 103.1069000000000000 select ss, avg(cint4) from aggfns group by ss order by avg(cint4), ss limit 10; ss | avg ----+----------------------- 9 | -102.4283000000000000 | -99.2131475098656277 6 | -53.1566500000000000 7 | -42.6121500000000000 8 | -29.2615500000000000 4 | 9.6930584054852110 0 | 27.7536500000000000 3 | 68.3874180471447875 11 | 68.4650082421699386 5 | 103.1069000000000000 select max(cint4) from aggfns; max ------- 16383 select s, max(cint4) from aggfns group by s order by max(cint4), s limit 10; s | max ---+------- 3 | 16379 5 | 16379 7 | 16379 2 | 16381 0 | 16383 1 | 16383 4 | 16383 6 | 16383 8 | 16383 9 | 16383 select ss, max(cint4) from aggfns group by ss order by max(cint4), ss limit 10; ss | max ----+------- 3 | 16379 5 | 16379 7 | 16379 | 16381 0 | 16383 4 | 16383 6 | 16383 8 | 16383 9 | 16383 11 | 16383 select min(cint4) from aggfns; min -------- -16383 select s, min(cint4) from aggfns group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 2 | -16383 7 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16382 5 | -16380 select ss, min(cint4) from aggfns group by ss order by min(cint4), ss limit 10; ss | min ----+-------- 0 | -16383 7 | -16383 | -16383 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16382 11 | -16382 5 | -16380 select stddev(cint4) from aggfns; stddev ------------------- 9450.334382392243 select s, stddev(cint4) from aggfns group by s order by stddev(cint4), s limit 10; s | stddev ---+------------------- 0 | 9406.815855797801 6 | 9410.397911988306 9 | 9426.452583637956 2 | 9440.675087350597 4 | 9443.098516157448 8 | 9450.281544631633 1 | 9459.538662433945 3 | 9474.762271621918 7 | 9485.765898279180 5 | 9504.684751625578 select ss, stddev(cint4) from aggfns group by ss order by stddev(cint4), ss limit 10; ss | stddev ----+------------------- 0 | 9406.815855797801 6 | 9410.397911988306 9 | 9426.452583637956 | 9440.633682496139 4 | 9442.480718256247 8 | 9450.281544631633 11 | 9460.158622933231 3 | 9474.873657491443 7 | 9485.765898279180 5 | 9504.684751625578 select sum(cint4) from aggfns; sum --------- -987383 select s, sum(cint4) from aggfns group by s order by sum(cint4), s limit 10; s | sum ---+---------- 9 | -2048566 2 | -2027904 6 | -1063133 7 | -852243 8 | -585231 4 | 133061 0 | 555073 3 | 1408205 1 | 1431217 5 | 2062138 select ss, sum(cint4) from aggfns group by ss order by sum(cint4), ss limit 10; ss | sum ----+---------- 9 | -2048566 | -1986148 6 | -1063133 7 | -852243 8 | -585231 4 | 193677 0 | 555073 3 | 1366449 11 | 1370601 5 | 2062138 select avg(cint8) from aggfns; avg ---------------------- -12.1026800000000000 select s, avg(cint8) from aggfns group by s order by avg(cint8), s limit 10; s | avg ---+----------------------- 8 | -118.4870000000000000 5 | -81.6955500000000000 1 | -25.4401500000000000 4 | -19.5071500000000000 2 | -2.4691500000000000 7 | -2.3563500000000000 6 | 11.9056500000000000 0 | 15.3018000000000000 3 | 39.9743500000000000 9 | 61.7467500000000000 select ss, avg(cint8) from aggfns group by ss order by avg(cint8), ss limit 10; ss | avg ----+------------------------- 8 | -118.4870000000000000 5 | -81.6955500000000000 11 | -27.8558869074379340 4 | -17.0811771182623492 7 | -2.3563500000000000 | -0.12513112543084070133 6 | 11.9056500000000000 0 | 15.3018000000000000 3 | 37.6662329212752115 9 | 61.7467500000000000 select max(cint8) from aggfns; max ------- 16383 select s, max(cint8) from aggfns group by s order by max(cint8), s limit 10; s | max ---+------- 2 | 16379 6 | 16380 7 | 16380 8 | 16380 3 | 16382 9 | 16382 0 | 16383 1 | 16383 4 | 16383 5 | 16383 select ss, max(cint8) from aggfns group by ss order by max(cint8), ss limit 10; ss | max ----+------- | 16379 6 | 16380 7 | 16380 8 | 16380 3 | 16382 9 | 16382 0 | 16383 4 | 16383 5 | 16383 11 | 16383 select min(cint8) from aggfns; min -------- -16383 select s, min(cint8) from aggfns group by s order by min(cint8), s limit 10; s | min ---+-------- 0 | -16383 1 | -16383 6 | -16383 7 | -16383 8 | -16383 5 | -16382 4 | -16381 9 | -16380 2 | -16379 3 | -16378 select ss, min(cint8) from aggfns group by ss order by min(cint8), ss limit 10; ss | min ----+-------- 0 | -16383 6 | -16383 7 | -16383 8 | -16383 11 | -16383 5 | -16382 4 | -16381 9 | -16380 | -16379 3 | -16378 select sum(cint8) from aggfns; sum ---------- -2420536 select s, sum(cint8) from aggfns group by s order by sum(cint8), s limit 10; s | sum ---+---------- 8 | -2369740 5 | -1633911 1 | -508803 4 | -390143 2 | -49383 7 | -47127 6 | 238113 0 | 306036 3 | 799487 9 | 1234935 select ss, sum(cint8) from aggfns group by ss order by sum(cint8), ss limit 10; ss | sum ----+---------- 8 | -2369740 5 | -1633911 11 | -557647 4 | -341299 7 | -47127 | -2505 6 | 238113 0 | 306036 3 | 752609 9 | 1234935 select max(cts) from aggfns; max -------------------------- Sat Jan 02 02:01:01 2021 select s, max(cts) from aggfns group by s order by max(cts), s limit 10; s | max ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 1 | Fri Jan 01 03:47:41 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, max(cts) from aggfns group by ss order by max(cts), ss limit 10; ss | max ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 3 | Fri Jan 01 09:21:01 2021 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 11 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select min(cts) from aggfns; min -------------------------- Fri Jan 01 01:01:01 2021 select s, min(cts) from aggfns group by s order by min(cts), s limit 10; s | min ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 1 | Fri Jan 01 03:47:41 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, min(cts) from aggfns group by ss order by min(cts), ss limit 10; ss | min ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 11 | Fri Jan 01 03:47:41 2021 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select max(ctstz) from aggfns; max ------------------------------ Sat Jan 02 02:01:01 2021 PST select s, max(ctstz) from aggfns group by s order by max(ctstz), s limit 10; s | max ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 1 | Fri Jan 01 03:47:41 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, max(ctstz) from aggfns group by ss order by max(ctstz), ss limit 10; ss | max ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 11 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select min(ctstz) from aggfns; min ------------------------------ Fri Jan 01 01:01:01 2021 PST select s, min(ctstz) from aggfns group by s order by min(ctstz), s limit 10; s | min ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 1 | Fri Jan 01 03:47:41 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, min(ctstz) from aggfns group by ss order by min(ctstz), ss limit 10; ss | min ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 11 | Fri Jan 01 03:47:41 2021 PST | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select avg(s) from aggfns; avg -------------------- 4.5000000000000000 select s, avg(s) from aggfns group by s order by avg(s), s limit 10; s | avg ---+---------------------------- 0 | 0.000000000000000000000000 1 | 1.00000000000000000000 2 | 2.0000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select ss, avg(s) from aggfns group by ss order by avg(s), ss limit 10; ss | avg ----+---------------------------- 0 | 0.000000000000000000000000 11 | 1.00284729506968380039 | 2.0009490983565613 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select count(s) from aggfns; count -------- 200000 select s, count(s) from aggfns group by s order by count(s), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select ss, count(s) from aggfns group by ss order by count(s), ss limit 10; ss | count ----+------- 3 | 19981 4 | 19981 0 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 11 | 20019 | 20019 select max(s) from aggfns; max ----- 9 select s, max(s) from aggfns group by s order by max(s), s limit 10; s | max ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, max(s) from aggfns group by ss order by max(s), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 | 3 4 | 4 11 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select min(s) from aggfns; min ----- 0 select s, min(s) from aggfns group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, min(s) from aggfns group by ss order by min(s), ss limit 10; ss | min ----+----- 0 | 0 11 | 1 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select stddev(s) from aggfns; stddev -------------------- 2.8722885039992502 select s, stddev(s) from aggfns group by s order by stddev(s), s limit 10; s | stddev ---+-------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select ss, stddev(s) from aggfns group by ss order by stddev(s), ss limit 10; ss | stddev ----+------------------------ 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 | 0.03079358595744834506 11 | 0.09238075787234503528 select sum(s) from aggfns; sum -------- 900000 select s, sum(s) from aggfns group by s order by sum(s), s limit 10; s | sum ---+-------- 0 | 0 1 | 20000 2 | 40000 3 | 60000 4 | 80000 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 select ss, sum(s) from aggfns group by ss order by sum(s), ss limit 10; ss | sum ----+-------- 0 | 0 11 | 20076 | 40057 3 | 59943 4 | 79924 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 select avg(ss) from aggfns; avg -------------------- 5.8899328262427701 select s, avg(ss) from aggfns group by s order by avg(ss), s limit 10; s | avg ---+---------------------------- 0 | 0.000000000000000000000000 3 | 3.0000000000000000 4 | 4.0066500000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 1 | 11.0000000000000000 2 | select ss, avg(ss) from aggfns group by ss order by avg(ss), ss limit 10; ss | avg ----+---------------------------- 0 | 0.000000000000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 11 | 11.0000000000000000 | select max(ss) from aggfns; max ----- 11 select s, max(ss) from aggfns group by s order by max(ss), s limit 10; s | max ---+----- 0 | 0 3 | 3 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 4 | 11 2 | select ss, max(ss) from aggfns group by ss order by max(ss), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select min(ss) from aggfns; min ----- 0 select s, min(ss) from aggfns group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select ss, min(ss) from aggfns group by ss order by min(ss), ss limit 10; ss | min ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select stddev(ss) from aggfns; stddev -------------------- 3.1431098825513430 select s, stddev(ss) from aggfns group by s order by stddev(ss), s limit 10; s | stddev ---+------------------------ 0 | 0 1 | 0 3 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 4 | 0.21565737387148452722 2 | select ss, stddev(ss) from aggfns group by ss order by stddev(ss), ss limit 10; ss | stddev ----+-------- 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 11 | 0 | select sum(ss) from aggfns; sum --------- 1060076 select s, sum(ss) from aggfns group by s order by sum(ss), s limit 10; s | sum ---+-------- 0 | 0 3 | 59943 4 | 80133 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 1 | 220000 2 | select ss, sum(ss) from aggfns group by ss order by sum(ss), ss limit 10; ss | sum ----+-------- 0 | 0 3 | 59943 4 | 79924 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 11 | 220209 | select max(t) from aggfns; max -------- 110000 select s, max(t) from aggfns group by s order by max(t), s limit 10; s | max ---+-------- 0 | 20000 1 | 30000 2 | 40000 3 | 50000 4 | 60000 5 | 70000 6 | 80000 7 | 90000 8 | 100000 9 | 110000 select ss, max(t) from aggfns group by ss order by max(t), ss limit 10; ss | max ----+-------- 0 | 20000 | 49491 3 | 50000 11 | 59192 4 | 60000 5 | 70000 6 | 80000 7 | 90000 8 | 100000 9 | 110000 select min(t) from aggfns; min ----- 1 select s, min(t) from aggfns group by s order by min(t), s limit 10; s | min ---+------- 0 | 1 1 | 10001 2 | 20001 3 | 30001 4 | 40001 5 | 50001 6 | 60001 7 | 70001 8 | 80001 9 | 90001 select ss, min(t) from aggfns group by ss order by min(t), ss limit 10; ss | min ----+------- 0 | 1 11 | 10001 | 20001 3 | 30001 4 | 40001 5 | 50001 6 | 60001 7 | 70001 8 | 80001 9 | 90001 select count(*) from aggfns where cfloat8 > 0; count -------- 109785 select s, count(*) from aggfns where cfloat8 > 0 group by s order by count(*), s limit 10; s | count ---+------- 0 | 9881 4 | 9882 9 | 9945 8 | 9950 3 | 9963 5 | 9972 7 | 10021 2 | 10074 6 | 10097 1 | 20000 select ss, count(*) from aggfns where cfloat8 > 0 group by ss order by count(*), ss limit 10; ss | count ----+------- 4 | 9872 0 | 9881 9 | 9945 3 | 9950 8 | 9950 5 | 9972 7 | 10021 | 10087 6 | 10097 11 | 20010 select max(cdate) from aggfns where cfloat8 > 0; max ------------ 06-01-2267 select s, max(cdate) from aggfns where cfloat8 > 0 group by s order by max(cdate), s limit 10; s | max ---+------------ 0 | 01-01-2021 1 | 05-19-2048 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, max(cdate) from aggfns where cfloat8 > 0 group by ss order by max(cdate), ss limit 10; ss | max ----+------------ 0 | 01-01-2021 3 | 02-21-2103 | 02-21-2103 4 | 07-09-2130 11 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select min(cdate) from aggfns where cfloat8 > 0; min ------------ 01-01-2021 select s, min(cdate) from aggfns where cfloat8 > 0 group by s order by min(cdate), s limit 10; s | min ---+------------ 0 | 01-01-2021 1 | 05-19-2048 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, min(cdate) from aggfns where cfloat8 > 0 group by ss order by min(cdate), ss limit 10; ss | min ----+------------ 0 | 01-01-2021 11 | 05-19-2048 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select avg(cfloat4) from aggfns where cfloat8 > 0; avg ----- NaN select s, avg(cfloat4) from aggfns where cfloat8 > 0 group by s order by avg(cfloat4), s limit 10; s | avg ---+-------------------- 3 | -Infinity 4 | -0.462286033119876 0 | -0.334856044433109 2 | -0.219086657095562 9 | -0.208302219537011 6 | 0.199537611181853 7 | 0.313851696029514 5 | 0.374879026647364 8 | 0.606801085094336 1 | NaN select ss, avg(cfloat4) from aggfns where cfloat8 > 0 group by ss order by avg(cfloat4), ss limit 10; ss | avg ----+-------------------- 3 | -Infinity 4 | -0.458554823065329 0 | -0.334856044433109 | -0.216905626765383 9 | -0.208302219537011 6 | 0.199537611181853 7 | 0.313851696029514 5 | 0.374879026647364 8 | 0.606801085094336 11 | NaN select max(cfloat4) from aggfns where cfloat8 > 0; max ----- NaN select s, max(cfloat4) from aggfns where cfloat8 > 0 group by s order by max(cfloat4), s limit 10; s | max ---+--------- 9 | 49.9744 3 | 49.9744 0 | 49.9863 2 | 49.988 8 | 49.9923 4 | 49.9928 6 | 49.9956 7 | 49.9969 5 | 49.9992 1 | NaN select ss, max(cfloat4) from aggfns where cfloat8 > 0 group by ss order by max(cfloat4), ss limit 10; ss | max ----+--------- 9 | 49.9744 3 | 49.9744 0 | 49.9863 | 49.988 8 | 49.9923 4 | 49.9928 6 | 49.9956 7 | 49.9969 5 | 49.9992 11 | NaN select min(cfloat4) from aggfns where cfloat8 > 0; min ----------- -Infinity select s, min(cfloat4) from aggfns where cfloat8 > 0 group by s order by min(cfloat4), s limit 10; s | min ---+----------- 3 | -Infinity 4 | -49.9993 1 | -49.9974 8 | -49.9969 7 | -49.9969 2 | -49.9928 0 | -49.9915 9 | -49.9911 5 | -49.9892 6 | -49.9891 select ss, min(cfloat4) from aggfns where cfloat8 > 0 group by ss order by min(cfloat4), ss limit 10; ss | min ----+----------- 3 | -Infinity 4 | -49.9993 11 | -49.9974 8 | -49.9969 7 | -49.9969 | -49.9928 0 | -49.9915 9 | -49.9911 5 | -49.9892 6 | -49.9891 select stddev(cfloat4) from aggfns where cfloat8 > 0; stddev -------- NaN select s, stddev(cfloat4) from aggfns where cfloat8 > 0 group by s order by stddev(cfloat4), s limit 10; s | stddev ---+------------------ 7 | 28.7246858657947 0 | 28.7315562731003 9 | 28.7729261590403 2 | 28.8508703679162 4 | 28.8548902125459 5 | 28.9107809470208 6 | 28.9388387251543 8 | 29.1042713834566 1 | NaN 3 | NaN select ss, stddev(cfloat4) from aggfns where cfloat8 > 0 group by ss order by stddev(cfloat4), ss limit 10; ss | stddev ----+------------------ 7 | 28.7246858657947 0 | 28.7315562731003 9 | 28.7729261590403 4 | 28.8497176060195 | 28.8503326655456 5 | 28.9107809470208 6 | 28.9388387251543 8 | 29.1042713834566 3 | NaN 11 | NaN select sum(cfloat4) from aggfns where cfloat8 > 0; sum ----- NaN select s, sum(cfloat4) from aggfns where cfloat8 > 0 group by s order by sum(cfloat4), s limit 10; s | sum ---+----------- 3 | -Infinity 4 | -4568.31 0 | -3308.71 2 | -2207.08 9 | -2071.57 6 | 2014.73 7 | 3145.11 5 | 3738.29 8 | 6037.67 1 | NaN select ss, sum(cfloat4) from aggfns where cfloat8 > 0 group by ss order by sum(cfloat4), ss limit 10; ss | sum ----+----------- 3 | -Infinity 4 | -4526.85 0 | -3308.71 | -2187.93 9 | -2071.57 6 | 2014.73 7 | 3145.11 5 | 3738.29 8 | 6037.67 11 | NaN select avg(cfloat8) from aggfns where cfloat8 > 0; avg ------------------ 22.7931225354662 select s, avg(cfloat8) from aggfns where cfloat8 > 0 group by s order by avg(cfloat8), s limit 10; s | avg ---+------------------ 1 | 13 2 | 24.886472568415 6 | 24.9229571834467 9 | 24.933601739557 8 | 24.9404756362227 4 | 24.9773553659677 7 | 24.9965050319499 5 | 25.0141908239782 3 | 25.0243032089187 0 | 25.0776526587937 select ss, avg(cfloat8) from aggfns where cfloat8 > 0 group by ss order by avg(cfloat8), ss limit 10; ss | avg ----+------------------ 11 | 13.0086523265127 | 24.8758840206794 6 | 24.9229571834467 9 | 24.933601739557 8 | 24.9404756362227 4 | 24.9719502302445 7 | 24.9965050319499 5 | 25.0141908239782 3 | 25.0352176289523 0 | 25.0776526587937 select max(cfloat8) from aggfns where cfloat8 > 0; max ------------------ 49.9995574122295 select s, max(cfloat8) from aggfns where cfloat8 > 0 group by s order by max(cfloat8), s limit 10; s | max ---+------------------ 1 | 13 5 | 49.9874341068789 3 | 49.9890822684392 6 | 49.9939429108053 8 | 49.9963666079566 0 | 49.9965498689562 7 | 49.9973275698721 2 | 49.9975695507601 4 | 49.9978997278959 9 | 49.9995574122295 select ss, max(cfloat8) from aggfns where cfloat8 > 0 group by ss order by max(cfloat8), ss limit 10; ss | max ----+------------------ 11 | 42.8941954858601 5 | 49.9874341068789 3 | 49.9890822684392 6 | 49.9939429108053 8 | 49.9963666079566 0 | 49.9965498689562 7 | 49.9973275698721 | 49.9975695507601 4 | 49.9978997278959 9 | 49.9995574122295 select min(cfloat8) from aggfns where cfloat8 > 0; min ---------------------- 0.000765081495046616 select s, min(cfloat8) from aggfns where cfloat8 > 0 group by s order by min(cfloat8), s limit 10; s | min ---+---------------------- 4 | 0.000765081495046616 7 | 0.000956561416387558 6 | 0.00179046764969826 0 | 0.00247885473072529 2 | 0.00441970769315958 3 | 0.00545482616871595 5 | 0.00628724228590727 9 | 0.0187294092029333 8 | 0.0195798231288791 1 | 13 select ss, min(cfloat8) from aggfns where cfloat8 > 0 group by ss order by min(cfloat8), ss limit 10; ss | min ----+---------------------- 4 | 0.000765081495046616 7 | 0.000956561416387558 6 | 0.00179046764969826 0 | 0.00247885473072529 | 0.00441970769315958 3 | 0.00545482616871595 5 | 0.00628724228590727 9 | 0.0187294092029333 8 | 0.0195798231288791 11 | 0.362602039240301 select stddev(cfloat8) from aggfns where cfloat8 > 0; stddev ------------------ 13.8427996018819 select s, stddev(cfloat8) from aggfns where cfloat8 > 0 group by s order by stddev(cfloat8), s limit 10; s | stddev ---+------------------ 1 | 0 9 | 14.3145979997847 3 | 14.3699970235247 4 | 14.4155254530971 6 | 14.4175557556356 5 | 14.4400766885504 0 | 14.4509605112521 7 | 14.4643374353136 2 | 14.4807945816176 8 | 14.507225286092 select ss, stddev(cfloat8) from aggfns where cfloat8 > 0 group by ss order by stddev(cfloat8), ss limit 10; ss | stddev ----+------------------- 11 | 0.484009165262532 9 | 14.3145979997847 3 | 14.3656116060957 4 | 14.4158826742614 6 | 14.4175557556357 5 | 14.4400766885504 0 | 14.4509605112521 7 | 14.4643374353136 | 14.4848342833185 8 | 14.507225286092 select sum(cfloat8) from aggfns where cfloat8 > 0; sum ------------------ 2502342.95755615 select s, sum(cfloat8) from aggfns where cfloat8 > 0 group by s order by sum(cfloat8), s limit 10; s | sum ---+------------------ 4 | 246826.225726493 0 | 247792.285921541 9 | 247964.669299894 8 | 248157.732580416 3 | 249317.132870457 5 | 249441.510896711 7 | 250489.97692517 2 | 250706.324654212 6 | 251647.098681261 1 | 260000 select ss, sum(cfloat8) from aggfns where cfloat8 > 0 group by ss order by sum(cfloat8), ss limit 10; ss | sum ----+------------------ 4 | 246523.092672974 0 | 247792.285921541 9 | 247964.669299894 8 | 248157.732580416 3 | 249100.415408076 5 | 249441.510896711 7 | 250489.97692517 | 250923.042116594 6 | 251647.098681261 11 | 260303.133053519 select avg(cint2) from aggfns where cfloat8 > 0; avg ---------------------- -46.3563347281860533 select s, avg(cint2) from aggfns where cfloat8 > 0 group by s order by avg(cint2), s limit 10; s | avg ---+----------------------- 9 | -192.8237544036235531 3 | -159.9071729957805907 2 | -156.9086662691313854 7 | -142.7671027664036752 4 | -122.8676723701528804 6 | -98.2421689135606661 8 | -1.6297525648762824 0 | 28.7771364925070879 1 | 91.9493518842900756 5 | 153.6364822808954924 select ss, avg(cint2) from aggfns where cfloat8 > 0 group by ss order by avg(cint2), ss limit 10; ss | avg ----+----------------------- 9 | -192.8237544036235531 | -159.8433746898263027 3 | -156.9368272809576501 7 | -142.7671027664036752 4 | -119.1966149792236749 6 | -98.2421689135606661 8 | -1.6297525648762824 0 | 28.7771364925070879 11 | 90.0299634835676054 5 | 153.6364822808954924 select count(cint2) from aggfns where cfloat8 > 0; count -------- 109689 select s, count(cint2) from aggfns where cfloat8 > 0 group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 9876 4 | 9877 9 | 9935 8 | 9942 3 | 9954 5 | 9961 7 | 10013 2 | 10062 6 | 10088 1 | 19981 select ss, count(cint2) from aggfns where cfloat8 > 0 group by ss order by count(cint2), ss limit 10; ss | count ----+------- 4 | 9867 0 | 9876 9 | 9935 3 | 9941 8 | 9942 5 | 9961 7 | 10013 | 10075 6 | 10088 11 | 19991 select max(cint2) from aggfns where cfloat8 > 0; max ------- 16383 select s, max(cint2) from aggfns where cfloat8 > 0 group by s order by max(cint2), s limit 10; s | max ---+------- 2 | 16379 3 | 16380 8 | 16380 5 | 16381 6 | 16381 7 | 16381 0 | 16383 1 | 16383 4 | 16383 9 | 16383 select ss, max(cint2) from aggfns where cfloat8 > 0 group by ss order by max(cint2), ss limit 10; ss | max ----+------- | 16379 3 | 16380 8 | 16380 5 | 16381 6 | 16381 7 | 16381 0 | 16383 4 | 16383 9 | 16383 11 | 16383 select min(cint2) from aggfns where cfloat8 > 0; min -------- -16383 select s, min(cint2) from aggfns where cfloat8 > 0 group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 4 | -16383 6 | -16383 8 | -16382 5 | -16381 7 | -16380 1 | -16378 3 | -16378 2 | -16377 9 | -16375 select ss, min(cint2) from aggfns where cfloat8 > 0 group by ss order by min(cint2), ss limit 10; ss | min ----+-------- 0 | -16383 4 | -16383 6 | -16383 8 | -16382 5 | -16381 7 | -16380 3 | -16378 11 | -16378 | -16377 9 | -16375 select stddev(cint2) from aggfns where cfloat8 > 0; stddev ------------------- 9465.641930658310 select s, stddev(cint2) from aggfns where cfloat8 > 0 group by s order by stddev(cint2), s limit 10; s | stddev ---+------------------- 2 | 9406.991269284247 5 | 9422.095841513016 6 | 9433.502305093184 9 | 9441.945023643920 4 | 9449.079857205037 7 | 9460.956887483220 3 | 9461.502298006280 8 | 9466.374225763893 0 | 9519.824544774386 1 | 9528.039076724276 select ss, stddev(cint2) from aggfns where cfloat8 > 0 group by ss order by stddev(cint2), ss limit 10; ss | stddev ----+------------------- | 9405.087937792723 5 | 9422.095841513016 6 | 9433.502305093184 9 | 9441.945023643920 4 | 9447.849754018911 7 | 9460.956887483220 3 | 9463.490872675688 8 | 9466.374225763893 0 | 9519.824544774386 11 | 9528.643287409910 select sum(cint2) from aggfns where cfloat8 > 0; sum ---------- -5084780 select s, sum(cint2) from aggfns where cfloat8 > 0 group by s order by sum(cint2), s limit 10; s | sum ---+---------- 9 | -1915704 3 | -1591716 2 | -1578815 7 | -1429527 4 | -1213564 6 | -991067 8 | -16203 0 | 284203 5 | 1530373 1 | 1837240 select ss, sum(cint2) from aggfns where cfloat8 > 0 group by ss order by sum(cint2), ss limit 10; ss | sum ----+---------- 9 | -1915704 | -1610422 3 | -1560109 7 | -1429527 4 | -1176113 6 | -991067 8 | -16203 0 | 284203 5 | 1530373 11 | 1799789 select avg(cint4) from aggfns where cfloat8 > 0; avg --------------------- -3.1503210821150430 select s, avg(cint4) from aggfns where cfloat8 > 0 group by s order by avg(cint4), s limit 10; s | avg ---+----------------------- 9 | -227.0452488687782805 2 | -152.6957514393488187 6 | -94.7697335842329405 4 | -42.9105444242056264 7 | -7.9618800518910288 8 | 30.7776884422110553 5 | 70.0002005615724027 1 | 71.5608500000000000 0 | 78.5152312518975812 3 | 170.6088527551942186 select ss, avg(cint4) from aggfns where cfloat8 > 0 group by ss order by avg(cint4), ss limit 10; ss | avg ----+----------------------- 9 | -227.0452488687782805 | -151.3793992267274710 6 | -94.7697335842329405 4 | -40.9285858995137763 7 | -7.9618800518910288 8 | 30.7776884422110553 5 | 70.0002005615724027 11 | 70.5258370814592704 0 | 78.5152312518975812 3 | 169.6967839195979899 select max(cint4) from aggfns where cfloat8 > 0; max ------- 16383 select s, max(cint4) from aggfns where cfloat8 > 0 group by s order by max(cint4), s limit 10; s | max ---+------- 3 | 16379 5 | 16379 7 | 16379 0 | 16380 6 | 16380 2 | 16381 9 | 16381 4 | 16382 8 | 16382 1 | 16383 select ss, max(cint4) from aggfns where cfloat8 > 0 group by ss order by max(cint4), ss limit 10; ss | max ----+------- 3 | 16379 5 | 16379 7 | 16379 0 | 16380 6 | 16380 9 | 16381 | 16381 4 | 16382 8 | 16382 11 | 16383 select min(cint4) from aggfns where cfloat8 > 0; min -------- -16383 select s, min(cint4) from aggfns where cfloat8 > 0 group by s order by min(cint4), s limit 10; s | min ---+-------- 2 | -16383 7 | -16383 0 | -16382 1 | -16382 9 | -16382 5 | -16380 3 | -16379 4 | -16378 6 | -16378 8 | -16377 select ss, min(cint4) from aggfns where cfloat8 > 0 group by ss order by min(cint4), ss limit 10; ss | min ----+-------- 7 | -16383 | -16383 0 | -16382 9 | -16382 11 | -16382 5 | -16380 3 | -16379 4 | -16378 6 | -16378 8 | -16377 select stddev(cint4) from aggfns where cfloat8 > 0; stddev ------------------- 9447.836798758010 select s, stddev(cint4) from aggfns where cfloat8 > 0 group by s order by stddev(cint4), s limit 10; s | stddev ---+------------------- 0 | 9368.404782340758 6 | 9385.470128440942 8 | 9411.536015886790 4 | 9416.523033700832 1 | 9459.538662433945 2 | 9460.302598725572 9 | 9474.284943213442 5 | 9475.929892556881 7 | 9500.872262505529 3 | 9509.065450373130 select ss, stddev(cint4) from aggfns where cfloat8 > 0 group by ss order by stddev(cint4), ss limit 10; ss | stddev ----+------------------- 0 | 9368.404782340758 6 | 9385.470128440942 8 | 9411.536015886790 4 | 9416.391322858156 | 9459.354319355396 11 | 9459.593914000701 9 | 9474.284943213442 5 | 9475.929892556881 7 | 9500.872262505529 3 | 9510.123363067463 select sum(cint4) from aggfns where cfloat8 > 0; sum --------- -345858 select s, sum(cint4) from aggfns where cfloat8 > 0 group by s order by sum(cint4), s limit 10; s | sum ---+---------- 9 | -2257965 2 | -1538257 6 | -956890 4 | -424042 7 | -79786 8 | 306238 5 | 698042 0 | 775809 1 | 1431217 3 | 1699776 select ss, sum(cint4) from aggfns where cfloat8 > 0 group by ss order by sum(cint4), ss limit 10; ss | sum ----+---------- 9 | -2257965 | -1526964 6 | -956890 4 | -404047 7 | -79786 8 | 306238 5 | 698042 0 | 775809 11 | 1411222 3 | 1688483 select avg(cint8) from aggfns where cfloat8 > 0; avg --------------------- -3.7972582775424694 select s, avg(cint8) from aggfns where cfloat8 > 0 group by s order by avg(cint8), s limit 10; s | avg ---+------------------------ 8 | -166.4501507537688442 5 | -78.9197753710389089 4 | -61.2938676381299332 6 | -32.8705556105773992 1 | -25.4401500000000000 7 | 1.15707015267937331604 0 | 42.9815808116587390 9 | 44.5682252388134741 3 | 109.7175549533273111 2 | 148.9026206075044669 select ss, avg(cint8) from aggfns where cfloat8 > 0 group by ss order by avg(cint8), ss limit 10; ss | avg ----+------------------------ 8 | -166.4501507537688442 5 | -78.9197753710389089 4 | -61.5197528363047002 6 | -32.8705556105773992 11 | -25.3466266866566717 7 | 1.15707015267937331604 0 | 42.9815808116587390 9 | 44.5682252388134741 3 | 106.1022110552763819 | 152.4183602656885100 select max(cint8) from aggfns where cfloat8 > 0; max ------- 16383 select s, max(cint8) from aggfns where cfloat8 > 0 group by s order by max(cint8), s limit 10; s | max ---+------- 2 | 16373 7 | 16378 6 | 16379 0 | 16380 8 | 16380 3 | 16381 4 | 16382 9 | 16382 1 | 16383 5 | 16383 select ss, max(cint8) from aggfns where cfloat8 > 0 group by ss order by max(cint8), ss limit 10; ss | max ----+------- | 16373 7 | 16378 6 | 16379 0 | 16380 8 | 16380 3 | 16381 4 | 16382 9 | 16382 5 | 16383 11 | 16383 select min(cint8) from aggfns where cfloat8 > 0; min -------- -16383 select s, min(cint8) from aggfns where cfloat8 > 0 group by s order by min(cint8), s limit 10; s | min ---+-------- 1 | -16383 7 | -16383 8 | -16383 5 | -16382 4 | -16381 6 | -16381 9 | -16380 0 | -16379 2 | -16379 3 | -16378 select ss, min(cint8) from aggfns where cfloat8 > 0 group by ss order by min(cint8), ss limit 10; ss | min ----+-------- 7 | -16383 8 | -16383 11 | -16383 5 | -16382 4 | -16381 6 | -16381 9 | -16380 0 | -16379 | -16379 3 | -16378 select sum(cint8) from aggfns where cfloat8 > 0; sum --------- -416882 select s, sum(cint8) from aggfns where cfloat8 > 0 group by s order by sum(cint8), s limit 10; s | sum ---+---------- 8 | -1656179 5 | -786988 4 | -605706 1 | -508803 6 | -331894 7 | 11595 0 | 424701 9 | 443231 3 | 1093116 2 | 1500045 select ss, sum(cint8) from aggfns where cfloat8 > 0 group by ss order by sum(cint8), ss limit 10; ss | sum ----+---------- 8 | -1656179 5 | -786988 4 | -607323 11 | -507186 6 | -331894 7 | 11595 0 | 424701 9 | 443231 3 | 1055717 | 1537444 select max(cts) from aggfns where cfloat8 > 0; max -------------------------- Sat Jan 02 02:01:01 2021 select s, max(cts) from aggfns where cfloat8 > 0 group by s order by max(cts), s limit 10; s | max ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 1 | Fri Jan 01 03:47:41 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, max(cts) from aggfns where cfloat8 > 0 group by ss order by max(cts), ss limit 10; ss | max ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 3 | Fri Jan 01 09:21:01 2021 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 11 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select min(cts) from aggfns where cfloat8 > 0; min -------------------------- Fri Jan 01 01:01:01 2021 select s, min(cts) from aggfns where cfloat8 > 0 group by s order by min(cts), s limit 10; s | min ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 1 | Fri Jan 01 03:47:41 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, min(cts) from aggfns where cfloat8 > 0 group by ss order by min(cts), ss limit 10; ss | min ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 11 | Fri Jan 01 03:47:41 2021 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select max(ctstz) from aggfns where cfloat8 > 0; max ------------------------------ Sat Jan 02 02:01:01 2021 PST select s, max(ctstz) from aggfns where cfloat8 > 0 group by s order by max(ctstz), s limit 10; s | max ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 1 | Fri Jan 01 03:47:41 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, max(ctstz) from aggfns where cfloat8 > 0 group by ss order by max(ctstz), ss limit 10; ss | max ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 11 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select min(ctstz) from aggfns where cfloat8 > 0; min ------------------------------ Fri Jan 01 01:01:01 2021 PST select s, min(ctstz) from aggfns where cfloat8 > 0 group by s order by min(ctstz), s limit 10; s | min ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 1 | Fri Jan 01 03:47:41 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, min(ctstz) from aggfns where cfloat8 > 0 group by ss order by min(ctstz), ss limit 10; ss | min ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 11 | Fri Jan 01 03:47:41 2021 PST | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select avg(s) from aggfns where cfloat8 > 0; avg -------------------- 4.1832581864553445 select s, avg(s) from aggfns where cfloat8 > 0 group by s order by avg(s), s limit 10; s | avg ---+------------------------ 0 | 0.00000000000000000000 1 | 1.00000000000000000000 2 | 2.0000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select ss, avg(s) from aggfns where cfloat8 > 0 group by ss order by avg(s), ss limit 10; ss | avg ----+------------------------ 0 | 0.00000000000000000000 11 | 1.00149925037481259370 | 2.0012887875483295 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select count(s) from aggfns where cfloat8 > 0; count -------- 109785 select s, count(s) from aggfns where cfloat8 > 0 group by s order by count(s), s limit 10; s | count ---+------- 0 | 9881 4 | 9882 9 | 9945 8 | 9950 3 | 9963 5 | 9972 7 | 10021 2 | 10074 6 | 10097 1 | 20000 select ss, count(s) from aggfns where cfloat8 > 0 group by ss order by count(s), ss limit 10; ss | count ----+------- 4 | 9872 0 | 9881 9 | 9945 3 | 9950 8 | 9950 5 | 9972 7 | 10021 | 10087 6 | 10097 11 | 20010 select max(s) from aggfns where cfloat8 > 0; max ----- 9 select s, max(s) from aggfns where cfloat8 > 0 group by s order by max(s), s limit 10; s | max ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, max(s) from aggfns where cfloat8 > 0 group by ss order by max(s), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 | 3 4 | 4 11 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select min(s) from aggfns where cfloat8 > 0; min ----- 0 select s, min(s) from aggfns where cfloat8 > 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, min(s) from aggfns where cfloat8 > 0 group by ss order by min(s), ss limit 10; ss | min ----+----- 0 | 0 11 | 1 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select stddev(s) from aggfns where cfloat8 > 0; stddev -------------------- 2.9152854040352282 select s, stddev(s) from aggfns where cfloat8 > 0 group by s order by stddev(s), s limit 10; s | stddev ---+-------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select ss, stddev(s) from aggfns where cfloat8 > 0 group by ss order by stddev(s), ss limit 10; ss | stddev ----+------------------------ 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 | 0.03587832479578534559 11 | 0.06705019050544684015 select sum(s) from aggfns where cfloat8 > 0; sum -------- 459259 select s, sum(s) from aggfns where cfloat8 > 0 group by s order by sum(s), s limit 10; s | sum ---+------- 0 | 0 1 | 20000 2 | 20148 3 | 29889 4 | 39528 5 | 49860 6 | 60582 7 | 70147 8 | 79600 9 | 89505 select ss, sum(s) from aggfns where cfloat8 > 0 group by ss order by sum(s), ss limit 10; ss | sum ----+------- 0 | 0 11 | 20040 | 20187 3 | 29850 4 | 39488 5 | 49860 6 | 60582 7 | 70147 8 | 79600 9 | 89505 select avg(ss) from aggfns where cfloat8 > 0; avg -------------------- 6.4107805572829946 select s, avg(ss) from aggfns where cfloat8 > 0 group by s order by avg(ss), s limit 10; s | avg ---+------------------------ 0 | 0.00000000000000000000 3 | 3.0000000000000000 4 | 4.0070835863185590 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 1 | 11.0000000000000000 2 | select ss, avg(ss) from aggfns where cfloat8 > 0 group by ss order by avg(ss), ss limit 10; ss | avg ----+------------------------ 0 | 0.00000000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 11 | 11.0000000000000000 | select max(ss) from aggfns where cfloat8 > 0; max ----- 11 select s, max(ss) from aggfns where cfloat8 > 0 group by s order by max(ss), s limit 10; s | max ---+----- 0 | 0 3 | 3 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 4 | 11 2 | select ss, max(ss) from aggfns where cfloat8 > 0 group by ss order by max(ss), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select min(ss) from aggfns where cfloat8 > 0; min ----- 0 select s, min(ss) from aggfns where cfloat8 > 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select ss, min(ss) from aggfns where cfloat8 > 0 group by ss order by min(ss), ss limit 10; ss | min ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select stddev(ss) from aggfns where cfloat8 > 0; stddev -------------------- 3.3479473483697611 select s, stddev(ss) from aggfns where cfloat8 > 0 group by s order by stddev(ss), s limit 10; s | stddev ---+------------------------ 0 | 0 1 | 0 3 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 4 | 0.22257569540261848080 2 | select ss, stddev(ss) from aggfns where cfloat8 > 0 group by ss order by stddev(ss), ss limit 10; ss | stddev ----+-------- 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 11 | 0 | select sum(ss) from aggfns where cfloat8 > 0; sum -------- 639142 select s, sum(ss) from aggfns where cfloat8 > 0 group by s order by sum(ss), s limit 10; s | sum ---+-------- 0 | 0 3 | 29850 4 | 39598 5 | 49860 6 | 60582 7 | 70147 8 | 79600 9 | 89505 1 | 220000 2 | select ss, sum(ss) from aggfns where cfloat8 > 0 group by ss order by sum(ss), ss limit 10; ss | sum ----+-------- 0 | 0 3 | 29850 4 | 39488 5 | 49860 6 | 60582 7 | 70147 8 | 79600 9 | 89505 11 | 220110 | select max(t) from aggfns where cfloat8 > 0; max -------- 110000 select s, max(t) from aggfns where cfloat8 > 0 group by s order by max(t), s limit 10; s | max ---+-------- 0 | 19999 1 | 30000 2 | 39999 3 | 49999 4 | 60000 5 | 70000 6 | 79998 7 | 89995 8 | 99997 9 | 110000 select ss, max(t) from aggfns where cfloat8 > 0 group by ss order by max(t), ss limit 10; ss | max ----+-------- 0 | 19999 | 49491 3 | 49999 11 | 59192 4 | 60000 5 | 70000 6 | 79998 7 | 89995 8 | 99997 9 | 110000 select min(t) from aggfns where cfloat8 > 0; min ----- 1 select s, min(t) from aggfns where cfloat8 > 0 group by s order by min(t), s limit 10; s | min ---+------- 0 | 1 1 | 10001 2 | 20001 3 | 30001 4 | 40003 5 | 50001 6 | 60002 7 | 70001 8 | 80003 9 | 90002 select ss, min(t) from aggfns where cfloat8 > 0 group by ss order by min(t), ss limit 10; ss | min ----+------- 0 | 1 11 | 10001 | 20001 3 | 30001 4 | 40003 5 | 50001 6 | 60002 7 | 70001 8 | 80003 9 | 90002 select count(*) from aggfns where cfloat8 <= 0; count ------- 90215 select s, count(*) from aggfns where cfloat8 <= 0 group by s order by count(*), s limit 10; s | count ---+------- 6 | 9903 2 | 9926 7 | 9979 5 | 10028 3 | 10037 8 | 10050 9 | 10055 4 | 10118 0 | 10119 select ss, count(*) from aggfns where cfloat8 <= 0 group by ss order by count(*), ss limit 10; ss | count ----+------- 11 | 9 6 | 9903 | 9932 7 | 9979 5 | 10028 3 | 10031 8 | 10050 9 | 10055 4 | 10109 0 | 10119 select max(cdate) from aggfns where cfloat8 <= 0; max ------------ 06-01-2267 select s, max(cdate) from aggfns where cfloat8 <= 0 group by s order by max(cdate), s limit 10; s | max ---+------------ 0 | 01-01-2021 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, max(cdate) from aggfns where cfloat8 <= 0 group by ss order by max(cdate), ss limit 10; ss | max ----+------------ 0 | 01-01-2021 3 | 02-21-2103 | 02-21-2103 4 | 07-09-2130 11 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select min(cdate) from aggfns where cfloat8 <= 0; min ------------ 01-01-2021 select s, min(cdate) from aggfns where cfloat8 <= 0 group by s order by min(cdate), s limit 10; s | min ---+------------ 0 | 01-01-2021 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, min(cdate) from aggfns where cfloat8 <= 0 group by ss order by min(cdate), ss limit 10; ss | min ----+------------ 0 | 01-01-2021 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 11 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select avg(cfloat4) from aggfns where cfloat8 <= 0; avg ---------- Infinity select s, avg(cfloat4) from aggfns where cfloat8 <= 0 group by s order by avg(cfloat4), s limit 10; s | avg ---+-------------------- 9 | -0.376175993822296 5 | -0.351281471733702 3 | -0.328033180425701 6 | -0.215785538185229 7 | 0.0690012062121504 4 | 0.100205441546667 8 | 0.308099926433512 0 | 0.497406092427368 2 | Infinity select ss, avg(cfloat4) from aggfns where cfloat8 <= 0 group by ss order by avg(cfloat4), ss limit 10; ss | avg ----+-------------------- 11 | -14.5702234903971 9 | -0.376175993822296 5 | -0.351281471733702 3 | -0.323676224863234 6 | -0.215785538185229 7 | 0.0690012062121504 4 | 0.113266462457489 8 | 0.308099926433512 0 | 0.497406092427368 | Infinity select max(cfloat4) from aggfns where cfloat8 <= 0; max ---------- Infinity select s, max(cfloat4) from aggfns where cfloat8 <= 0 group by s order by max(cfloat4), s limit 10; s | max ---+---------- 5 | 49.9753 9 | 49.9899 7 | 49.992 6 | 49.9938 4 | 49.9946 3 | 49.9979 0 | 49.9995 8 | 49.9997 2 | Infinity select ss, max(cfloat4) from aggfns where cfloat8 <= 0 group by ss order by max(cfloat4), ss limit 10; ss | max ----+---------- 11 | 33.4543 5 | 49.9753 9 | 49.9899 7 | 49.992 6 | 49.9938 4 | 49.9946 3 | 49.9979 0 | 49.9995 8 | 49.9997 | Infinity select min(cfloat4) from aggfns where cfloat8 <= 0; min ---------- -49.9999 select s, min(cfloat4) from aggfns where cfloat8 <= 0 group by s order by min(cfloat4), s limit 10; s | min ---+---------- 4 | -49.9999 6 | -49.9995 2 | -49.9991 7 | -49.9984 0 | -49.9949 5 | -49.9942 9 | -49.9874 8 | -49.9853 3 | -49.974 select ss, min(cfloat4) from aggfns where cfloat8 <= 0 group by ss order by min(cfloat4), ss limit 10; ss | min ----+---------- 4 | -49.9999 6 | -49.9995 | -49.9991 7 | -49.9984 0 | -49.9949 5 | -49.9942 9 | -49.9874 8 | -49.9853 3 | -49.974 11 | -49.5659 select stddev(cfloat4) from aggfns where cfloat8 <= 0; stddev -------- NaN select s, stddev(cfloat4) from aggfns where cfloat8 <= 0 group by s order by stddev(cfloat4), s limit 10; s | stddev ---+------------------ 0 | 28.7188352112159 3 | 28.7589901880779 4 | 28.7990664583532 7 | 28.8547648614793 6 | 28.89882973622 8 | 28.9050890855561 9 | 28.9126192916065 5 | 29.1278202173096 2 | NaN select ss, stddev(cfloat4) from aggfns where cfloat8 <= 0 group by ss order by stddev(cfloat4), ss limit 10; ss | stddev ----+------------------ 0 | 28.7188352112159 3 | 28.7564997868619 4 | 28.7937148382071 7 | 28.8547648614793 6 | 28.89882973622 8 | 28.9050890855561 9 | 28.9126192916064 5 | 29.1278202173095 11 | 32.8656208490092 | NaN select sum(cfloat4) from aggfns where cfloat8 <= 0; sum ---------- Infinity select s, sum(cfloat4) from aggfns where cfloat8 <= 0 group by s order by sum(cfloat4), s limit 10; s | sum ---+---------- 9 | -3782.45 5 | -3522.65 3 | -3292.47 6 | -2136.92 7 | 688.563 4 | 1013.88 8 | 3096.4 0 | 5033.25 2 | Infinity select ss, sum(cfloat4) from aggfns where cfloat8 <= 0 group by ss order by sum(cfloat4), ss limit 10; ss | sum ----+---------- 9 | -3782.45 5 | -3522.65 3 | -3246.8 6 | -2136.92 11 | -131.132 7 | 688.563 4 | 1145.01 8 | 3096.4 0 | 5033.25 | Infinity select avg(cfloat8) from aggfns where cfloat8 <= 0; avg ------------------- -25.0131648946505 select s, avg(cfloat8) from aggfns where cfloat8 <= 0 group by s order by avg(cfloat8), s limit 10; s | avg ---+------------------- 7 | -25.229255062715 8 | -25.2270239386592 3 | -25.1351069194284 0 | -25.0944548448943 6 | -25.0686778438405 9 | -24.8892608135943 2 | -24.8583035779324 4 | -24.8301394745889 5 | -24.7870942066272 select ss, avg(cfloat8) from aggfns where cfloat8 <= 0 group by ss order by avg(cfloat8), ss limit 10; ss | avg ----+------------------- 11 | -25.4791639719365 7 | -25.229255062715 8 | -25.2270239386592 3 | -25.1388045035744 0 | -25.0944548448943 6 | -25.0686778438405 9 | -24.8892608135943 | -24.8547363561725 4 | -24.8295616508204 5 | -24.7870942066272 select max(cfloat8) from aggfns where cfloat8 <= 0; max ---------------------- -0.00172397121787071 select s, max(cfloat8) from aggfns where cfloat8 <= 0 group by s order by max(cfloat8), s limit 10; s | max ---+---------------------- 0 | -0.00547224190086126 9 | -0.00466627534478903 4 | -0.0041270861402154 6 | -0.00408347696065903 7 | -0.00273226760327816 3 | -0.00268903095275164 5 | -0.00228420831263065 8 | -0.00182925723493099 2 | -0.00172397121787071 select ss, max(cfloat8) from aggfns where cfloat8 <= 0 group by ss order by max(cfloat8), ss limit 10; ss | max ----+---------------------- 11 | -6.9206316024065 0 | -0.00547224190086126 9 | -0.00466627534478903 4 | -0.0041270861402154 6 | -0.00408347696065903 7 | -0.00273226760327816 3 | -0.00268903095275164 5 | -0.00228420831263065 8 | -0.00182925723493099 | -0.00172397121787071 select min(cfloat8) from aggfns where cfloat8 <= 0; min ------------------- -49.9994775978848 select s, min(cfloat8) from aggfns where cfloat8 <= 0 group by s order by min(cfloat8), s limit 10; s | min ---+------------------- 0 | -49.9994775978848 2 | -49.9985320260748 4 | -49.9983572866768 3 | -49.9977725092322 6 | -49.9967515002936 9 | -49.992344272323 5 | -49.9921301845461 7 | -49.99003498815 8 | -49.9897602945566 select ss, min(cfloat8) from aggfns where cfloat8 <= 0 group by ss order by min(cfloat8), ss limit 10; ss | min ----+------------------- 0 | -49.9994775978848 | -49.9985320260748 4 | -49.9983572866768 3 | -49.9977725092322 6 | -49.9967515002936 9 | -49.992344272323 5 | -49.9921301845461 7 | -49.99003498815 8 | -49.9897602945566 11 | -46.2087355088443 select stddev(cfloat8) from aggfns where cfloat8 <= 0; stddev ------------------ 14.4381579706012 select s, stddev(cfloat8) from aggfns where cfloat8 <= 0 group by s order by stddev(cfloat8), s limit 10; s | stddev ---+------------------ 7 | 14.4030112329564 2 | 14.4030502020858 6 | 14.4144870413512 4 | 14.4341540067486 3 | 14.4341919321977 5 | 14.4378475427373 9 | 14.445355480345 8 | 14.4532419971748 0 | 14.5136612753879 select ss, stddev(cfloat8) from aggfns where cfloat8 <= 0 group by ss order by stddev(cfloat8), ss limit 10; ss | stddev ----+------------------ 7 | 14.4030112329563 | 14.4036067581472 6 | 14.4144870413512 3 | 14.4335904065982 4 | 14.4339025361113 5 | 14.4378475427373 9 | 14.445355480345 8 | 14.4532419971748 0 | 14.5136612753879 11 | 15.5912132906587 select sum(cfloat8) from aggfns where cfloat8 <= 0; sum ------------------- -2256562.67097089 select s, sum(cfloat8) from aggfns where cfloat8 <= 0 group by s order by sum(cfloat8), s limit 10; s | sum ---+------------------- 0 | -253930.788575485 8 | -253531.590583525 3 | -252281.068150303 7 | -251762.736270833 4 | -251231.351203891 9 | -250261.517480691 5 | -248564.980704058 6 | -248255.116687552 2 | -246743.521314557 select ss, sum(cfloat8) from aggfns where cfloat8 <= 0 group by ss order by sum(cfloat8), ss limit 10; ss | sum ----+------------------- 0 | -253930.788575485 8 | -253531.590583525 3 | -252167.347975355 7 | -251762.736270833 4 | -251002.038728143 9 | -250261.517480691 5 | -248564.980704058 6 | -248255.116687552 | -246857.241489505 11 | -229.312475747429 select avg(cint2) from aggfns where cfloat8 <= 0; avg ---------------------- -17.0676978728598218 select s, avg(cint2) from aggfns where cfloat8 <= 0 group by s order by avg(cint2), s limit 10; s | avg ---+----------------------- 8 | -256.1267058471959359 2 | -159.7472527472527473 3 | -32.0911538845118181 6 | -23.1764884261599110 0 | 6.6666006927263731 7 | 31.4203451043338684 4 | 63.3268012668250198 5 | 66.6813373253493014 9 | 147.3351582719490344 select ss, avg(cint2) from aggfns where cfloat8 <= 0 group by ss order by avg(cint2), ss limit 10; ss | avg ----+----------------------- 8 | -256.1267058471959359 | -159.0852392947103275 3 | -32.6703921764294981 6 | -23.1764884261599110 0 | 6.6666006927263731 7 | 31.4203451043338684 4 | 61.9965329370975731 5 | 66.6813373253493014 9 | 147.3351582719490344 11 | 1555.4444444444444444 select count(cint2) from aggfns where cfloat8 <= 0; count ------- 90121 select s, count(cint2) from aggfns where cfloat8 <= 0 group by s order by count(cint2), s limit 10; s | count ---+------- 6 | 9893 2 | 9919 7 | 9968 5 | 10020 3 | 10027 8 | 10039 9 | 10046 4 | 10104 0 | 10105 select ss, count(cint2) from aggfns where cfloat8 <= 0 group by ss order by count(cint2), ss limit 10; ss | count ----+------- 11 | 9 6 | 9893 | 9925 7 | 9968 5 | 10020 3 | 10021 8 | 10039 9 | 10046 4 | 10095 0 | 10105 select max(cint2) from aggfns where cfloat8 <= 0; max ------- 16383 select s, max(cint2) from aggfns where cfloat8 <= 0 group by s order by max(cint2), s limit 10; s | max ---+------- 7 | 16376 9 | 16376 3 | 16378 0 | 16381 2 | 16381 5 | 16381 8 | 16382 4 | 16383 6 | 16383 select ss, max(cint2) from aggfns where cfloat8 <= 0 group by ss order by max(cint2), ss limit 10; ss | max ----+------- 11 | 16032 7 | 16376 9 | 16376 3 | 16378 0 | 16381 5 | 16381 | 16381 8 | 16382 4 | 16383 6 | 16383 select min(cint2) from aggfns where cfloat8 <= 0; min -------- -16383 select s, min(cint2) from aggfns where cfloat8 <= 0 group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 5 | -16383 6 | -16383 2 | -16382 7 | -16382 8 | -16382 3 | -16381 4 | -16379 9 | -16374 select ss, min(cint2) from aggfns where cfloat8 <= 0 group by ss order by min(cint2), ss limit 10; ss | min ----+-------- 0 | -16383 5 | -16383 6 | -16383 7 | -16382 8 | -16382 | -16382 3 | -16381 4 | -16379 9 | -16374 11 | -9975 select stddev(cint2) from aggfns where cfloat8 <= 0; stddev ------------------- 9487.728001026379 select s, stddev(cint2) from aggfns where cfloat8 <= 0 group by s order by stddev(cint2), s limit 10; s | stddev ---+------------------- 0 | 9451.115288155243 9 | 9456.028731464701 7 | 9463.041992703462 3 | 9485.287342318946 8 | 9487.451140540082 6 | 9502.509922580216 2 | 9511.416697071789 5 | 9513.243501566793 4 | 9517.027301293118 select ss, stddev(cint2) from aggfns where cfloat8 <= 0 group by ss order by stddev(cint2), ss limit 10; ss | stddev ----+------------------- 11 | 8648.748017937497 0 | 9451.115288155243 9 | 9456.028731464701 7 | 9463.041992703462 3 | 9485.440311868001 8 | 9487.451140540082 6 | 9502.509922580216 | 9511.255220707033 5 | 9513.243501566793 4 | 9518.051043653511 select sum(cint2) from aggfns where cfloat8 <= 0; sum ---------- -1538158 select s, sum(cint2) from aggfns where cfloat8 <= 0 group by s order by sum(cint2), s limit 10; s | sum ---+---------- 8 | -2571256 2 | -1584533 3 | -321778 6 | -229285 0 | 67366 7 | 313198 4 | 639854 5 | 668147 9 | 1480129 select ss, sum(cint2) from aggfns where cfloat8 <= 0 group by ss order by sum(cint2), ss limit 10; ss | sum ----+---------- 8 | -2571256 | -1578921 3 | -327390 6 | -229285 11 | 13999 0 | 67366 7 | 313198 4 | 625855 5 | 668147 9 | 1480129 select avg(cint4) from aggfns where cfloat8 <= 0; avg --------------------- -7.1110680042121598 select s, avg(cint4) from aggfns where cfloat8 <= 0 group by s order by avg(cint4), s limit 10; s | avg ---+---------------------- 8 | -88.7033830845771144 7 | -77.4082573404148712 2 | -49.3297400765665928 3 | -29.0496164192487795 0 | -21.8140132424152584 6 | -10.7283651418761991 9 | 20.8253605171556440 4 | 55.0605850958687488 5 | 136.0287195851615477 select ss, avg(cint4) from aggfns where cfloat8 <= 0 group by ss order by avg(cint4), ss limit 10; ss | avg ----+------------------------ 11 | -4513.4444444444444444 8 | -88.7033830845771144 7 | -77.4082573404148712 | -46.2327829238824003 3 | -32.1038779782673711 0 | -21.8140132424152584 6 | -10.7283651418761991 9 | 20.8253605171556440 4 | 59.1279058264912454 5 | 136.0287195851615477 select max(cint4) from aggfns where cfloat8 <= 0; max ------- 16383 select s, max(cint4) from aggfns where cfloat8 <= 0 group by s order by max(cint4), s limit 10; s | max ---+------- 5 | 16364 7 | 16378 3 | 16379 2 | 16381 0 | 16383 4 | 16383 6 | 16383 8 | 16383 9 | 16383 select ss, max(cint4) from aggfns where cfloat8 <= 0 group by ss order by max(cint4), ss limit 10; ss | max ----+------- 11 | 12631 5 | 16364 7 | 16378 3 | 16379 | 16381 0 | 16383 4 | 16383 6 | 16383 8 | 16383 9 | 16383 select min(cint4) from aggfns where cfloat8 <= 0; min -------- -16383 select s, min(cint4) from aggfns where cfloat8 <= 0 group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16381 7 | -16379 2 | -16377 5 | -16374 select ss, min(cint4) from aggfns where cfloat8 <= 0 group by ss order by min(cint4), ss limit 10; ss | min ----+-------- 0 | -16383 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16381 7 | -16379 | -16377 5 | -16374 11 | -14100 select stddev(cint4) from aggfns where cfloat8 <= 0; stddev ------------------- 9453.424778209057 select s, stddev(cint4) from aggfns where cfloat8 <= 0 group by s order by stddev(cint4), s limit 10; s | stddev ---+------------------- 9 | 9377.745829196558 2 | 9420.904023095068 6 | 9436.031206307503 3 | 9440.010647812753 0 | 9444.372352979574 4 | 9469.197040523380 7 | 9470.920199125109 8 | 9488.579674823607 5 | 9533.551517829360 select ss, stddev(cint4) from aggfns where cfloat8 <= 0 group by ss order by stddev(cint4), ss limit 10; ss | stddev ----+------------------- 9 | 9377.745829196558 | 9421.763392134212 6 | 9436.031206307503 3 | 9439.178404000439 0 | 9444.372352979574 4 | 9468.093604068949 7 | 9470.920199125109 8 | 9488.579674823607 5 | 9533.551517829360 11 | 10187.00521634 select sum(cint4) from aggfns where cfloat8 <= 0; sum --------- -641525 select s, sum(cint4) from aggfns where cfloat8 <= 0 group by s order by sum(cint4), s limit 10; s | sum ---+--------- 8 | -891469 7 | -772457 2 | -489647 3 | -291571 0 | -220736 6 | -106243 9 | 209399 4 | 557103 5 | 1364096 select ss, sum(cint4) from aggfns where cfloat8 <= 0 group by ss order by sum(cint4), ss limit 10; ss | sum ----+--------- 8 | -891469 7 | -772457 | -459184 3 | -322034 0 | -220736 6 | -106243 11 | -40621 9 | 209399 4 | 597724 5 | 1364096 select avg(cint8) from aggfns where cfloat8 <= 0; avg ---------------------- -22.2097655600509893 select s, avg(cint8) from aggfns where cfloat8 <= 0 group by s order by avg(cint8), s limit 10; s | avg ---+----------------------- 2 | -156.0979246423534153 5 | -84.4558236936577583 8 | -71.0010945273631841 3 | -29.2546577662648202 0 | -11.7269493032908390 7 | -5.8845575708988877 4 | 21.3049021545760032 6 | 57.5590225184287590 9 | 78.7373446046742914 select ss, avg(cint8) from aggfns where cfloat8 <= 0 group by ss order by avg(cint8), ss limit 10; ss | avg ----+------------------------ 11 | -5606.7777777777777778 | -155.0492347966169956 5 | -84.4558236936577583 8 | -71.0010945273631841 3 | -30.2171269065895723 0 | -11.7269493032908390 7 | -5.8845575708988877 4 | 26.3155603917301415 6 | 57.5590225184287590 9 | 78.7373446046742914 select max(cint8) from aggfns where cfloat8 <= 0; max ------- 16383 select s, max(cint8) from aggfns where cfloat8 <= 0 group by s order by max(cint8), s limit 10; s | max ---+------- 2 | 16379 8 | 16379 6 | 16380 7 | 16380 5 | 16381 9 | 16381 3 | 16382 0 | 16383 4 | 16383 select ss, max(cint8) from aggfns where cfloat8 <= 0 group by ss order by max(cint8), ss limit 10; ss | max ----+------- 11 | 11372 8 | 16379 | 16379 6 | 16380 7 | 16380 5 | 16381 9 | 16381 3 | 16382 0 | 16383 4 | 16383 select min(cint8) from aggfns where cfloat8 <= 0; min -------- -16383 select s, min(cint8) from aggfns where cfloat8 <= 0 group by s order by min(cint8), s limit 10; s | min ---+-------- 0 | -16383 6 | -16383 8 | -16383 5 | -16382 4 | -16381 7 | -16381 2 | -16375 3 | -16375 9 | -16372 select ss, min(cint8) from aggfns where cfloat8 <= 0 group by ss order by min(cint8), ss limit 10; ss | min ----+-------- 0 | -16383 6 | -16383 8 | -16383 5 | -16382 4 | -16381 7 | -16381 3 | -16375 | -16375 9 | -16372 11 | -14502 select sum(cint8) from aggfns where cfloat8 <= 0; sum ---------- -2003654 select s, sum(cint8) from aggfns where cfloat8 <= 0 group by s order by sum(cint8), s limit 10; s | sum ---+---------- 2 | -1549428 5 | -846923 8 | -713561 3 | -293629 0 | -118665 7 | -58722 4 | 215563 6 | 570007 9 | 791704 select ss, sum(cint8) from aggfns where cfloat8 <= 0 group by ss order by sum(cint8), ss limit 10; ss | sum ----+---------- | -1539949 5 | -846923 8 | -713561 3 | -303108 0 | -118665 7 | -58722 11 | -50461 4 | 266024 6 | 570007 9 | 791704 select max(cts) from aggfns where cfloat8 <= 0; max -------------------------- Sat Jan 02 02:01:01 2021 select s, max(cts) from aggfns where cfloat8 <= 0 group by s order by max(cts), s limit 10; s | max ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, max(cts) from aggfns where cfloat8 <= 0 group by ss order by max(cts), ss limit 10; ss | max ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 3 | Fri Jan 01 09:21:01 2021 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 11 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select min(cts) from aggfns where cfloat8 <= 0; min -------------------------- Fri Jan 01 01:01:01 2021 select s, min(cts) from aggfns where cfloat8 <= 0 group by s order by min(cts), s limit 10; s | min ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, min(cts) from aggfns where cfloat8 <= 0 group by ss order by min(cts), ss limit 10; ss | min ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 11 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select max(ctstz) from aggfns where cfloat8 <= 0; max ------------------------------ Sat Jan 02 02:01:01 2021 PST select s, max(ctstz) from aggfns where cfloat8 <= 0 group by s order by max(ctstz), s limit 10; s | max ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, max(ctstz) from aggfns where cfloat8 <= 0 group by ss order by max(ctstz), ss limit 10; ss | max ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 11 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select min(ctstz) from aggfns where cfloat8 <= 0; min ------------------------------ Fri Jan 01 01:01:01 2021 PST select s, min(ctstz) from aggfns where cfloat8 <= 0 group by s order by min(ctstz), s limit 10; s | min ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, min(ctstz) from aggfns where cfloat8 <= 0 group by ss order by min(ctstz), ss limit 10; ss | min ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 11 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select avg(s) from aggfns where cfloat8 <= 0; avg -------------------- 4.8854514216039461 select s, avg(s) from aggfns where cfloat8 <= 0 group by s order by avg(s), s limit 10; s | avg ---+---------------------------- 0 | 0.000000000000000000000000 2 | 2.0000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select ss, avg(s) from aggfns where cfloat8 <= 0 group by ss order by avg(s), ss limit 10; ss | avg ----+---------------------------- 0 | 0.000000000000000000000000 | 2.0006041079339509 3 | 3.0000000000000000 4 | 4.0000000000000000 11 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select count(s) from aggfns where cfloat8 <= 0; count ------- 90215 select s, count(s) from aggfns where cfloat8 <= 0 group by s order by count(s), s limit 10; s | count ---+------- 6 | 9903 2 | 9926 7 | 9979 5 | 10028 3 | 10037 8 | 10050 9 | 10055 4 | 10118 0 | 10119 select ss, count(s) from aggfns where cfloat8 <= 0 group by ss order by count(s), ss limit 10; ss | count ----+------- 11 | 9 6 | 9903 | 9932 7 | 9979 5 | 10028 3 | 10031 8 | 10050 9 | 10055 4 | 10109 0 | 10119 select max(s) from aggfns where cfloat8 <= 0; max ----- 9 select s, max(s) from aggfns where cfloat8 <= 0 group by s order by max(s), s limit 10; s | max ---+----- 0 | 0 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, max(s) from aggfns where cfloat8 <= 0 group by ss order by max(s), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 | 3 4 | 4 11 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select min(s) from aggfns where cfloat8 <= 0; min ----- 0 select s, min(s) from aggfns where cfloat8 <= 0 group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, min(s) from aggfns where cfloat8 <= 0 group by ss order by min(s), ss limit 10; ss | min ----+----- 0 | 0 | 2 3 | 3 4 | 4 11 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select stddev(s) from aggfns where cfloat8 <= 0; stddev -------------------- 2.7706747160155654 select s, stddev(s) from aggfns where cfloat8 <= 0 group by s order by stddev(s), s limit 10; s | stddev ---+-------- 0 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select ss, stddev(s) from aggfns where cfloat8 <= 0 group by ss order by stddev(s), ss limit 10; ss | stddev ----+------------------------ 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 11 | 0 | 0.02457241911841021973 select sum(s) from aggfns where cfloat8 <= 0; sum -------- 440741 select s, sum(s) from aggfns where cfloat8 <= 0 group by s order by sum(s), s limit 10; s | sum ---+------- 0 | 0 2 | 19852 3 | 30111 4 | 40472 5 | 50140 6 | 59418 7 | 69853 8 | 80400 9 | 90495 select ss, sum(s) from aggfns where cfloat8 <= 0 group by ss order by sum(s), ss limit 10; ss | sum ----+------- 0 | 0 11 | 36 | 19870 3 | 30093 4 | 40436 5 | 50140 6 | 59418 7 | 69853 8 | 80400 9 | 90495 select avg(ss) from aggfns where cfloat8 <= 0; avg -------------------- 5.2431274366926996 select s, avg(ss) from aggfns where cfloat8 <= 0 group by s order by avg(ss), s limit 10; s | avg ---+---------------------------- 0 | 0.000000000000000000000000 3 | 3.0000000000000000 4 | 4.0062265269816169 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 2 | select ss, avg(ss) from aggfns where cfloat8 <= 0 group by ss order by avg(ss), ss limit 10; ss | avg ----+---------------------------- 0 | 0.000000000000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 11 | 11.0000000000000000 | select max(ss) from aggfns where cfloat8 <= 0; max ----- 11 select s, max(ss) from aggfns where cfloat8 <= 0 group by s order by max(ss), s limit 10; s | max ---+----- 0 | 0 3 | 3 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 4 | 11 2 | select ss, max(ss) from aggfns where cfloat8 <= 0 group by ss order by max(ss), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select min(ss) from aggfns where cfloat8 <= 0; min ----- 0 select s, min(ss) from aggfns where cfloat8 <= 0 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 2 | select ss, min(ss) from aggfns where cfloat8 <= 0 group by ss order by min(ss), ss limit 10; ss | min ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select stddev(ss) from aggfns where cfloat8 <= 0; stddev -------------------- 2.7336515224169933 select s, stddev(ss) from aggfns where cfloat8 <= 0 group by s order by stddev(ss), s limit 10; s | stddev ---+------------------------ 0 | 0 3 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 4 | 0.20868929911309143893 2 | select ss, stddev(ss) from aggfns where cfloat8 <= 0 group by ss order by stddev(ss), ss limit 10; ss | stddev ----+-------- 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 11 | 0 | select sum(ss) from aggfns where cfloat8 <= 0; sum -------- 420934 select s, sum(ss) from aggfns where cfloat8 <= 0 group by s order by sum(ss), s limit 10; s | sum ---+------- 0 | 0 3 | 30093 4 | 40535 5 | 50140 6 | 59418 7 | 69853 8 | 80400 9 | 90495 2 | select ss, sum(ss) from aggfns where cfloat8 <= 0 group by ss order by sum(ss), ss limit 10; ss | sum ----+------- 0 | 0 11 | 99 3 | 30093 4 | 40436 5 | 50140 6 | 59418 7 | 69853 8 | 80400 9 | 90495 | select max(t) from aggfns where cfloat8 <= 0; max -------- 109998 select s, max(t) from aggfns where cfloat8 <= 0 group by s order by max(t), s limit 10; s | max ---+-------- 0 | 20000 2 | 40000 3 | 50000 4 | 59998 5 | 69999 6 | 80000 7 | 90000 8 | 100000 9 | 109998 select ss, max(t) from aggfns where cfloat8 <= 0 group by ss order by max(t), ss limit 10; ss | max ----+-------- 0 | 20000 | 48438 3 | 50000 11 | 58135 4 | 59998 5 | 69999 6 | 80000 7 | 90000 8 | 100000 9 | 109998 select min(t) from aggfns where cfloat8 <= 0; min ----- 8 select s, min(t) from aggfns where cfloat8 <= 0 group by s order by min(t), s limit 10; s | min ---+------- 0 | 8 2 | 20003 3 | 30002 4 | 40001 5 | 50004 6 | 60001 7 | 70002 8 | 80001 9 | 90001 select ss, min(t) from aggfns where cfloat8 <= 0 group by ss order by min(t), ss limit 10; ss | min ----+------- 0 | 8 | 20003 3 | 30002 4 | 40001 11 | 41223 5 | 50004 6 | 60001 7 | 70002 8 | 80001 9 | 90001 select count(*) from aggfns where cfloat8 < 1000; count -------- 200000 select s, count(*) from aggfns where cfloat8 < 1000 group by s order by count(*), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select ss, count(*) from aggfns where cfloat8 < 1000 group by ss order by count(*), ss limit 10; ss | count ----+------- 3 | 19981 4 | 19981 0 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 11 | 20019 | 20019 select max(cdate) from aggfns where cfloat8 < 1000; max ------------ 06-01-2267 select s, max(cdate) from aggfns where cfloat8 < 1000 group by s order by max(cdate), s limit 10; s | max ---+------------ 0 | 01-01-2021 1 | 05-19-2048 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, max(cdate) from aggfns where cfloat8 < 1000 group by ss order by max(cdate), ss limit 10; ss | max ----+------------ 0 | 01-01-2021 3 | 02-21-2103 | 02-21-2103 4 | 07-09-2130 11 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select min(cdate) from aggfns where cfloat8 < 1000; min ------------ 01-01-2021 select s, min(cdate) from aggfns where cfloat8 < 1000 group by s order by min(cdate), s limit 10; s | min ---+------------ 0 | 01-01-2021 1 | 05-19-2048 2 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select ss, min(cdate) from aggfns where cfloat8 < 1000 group by ss order by min(cdate), ss limit 10; ss | min ----+------------ 0 | 01-01-2021 11 | 05-19-2048 | 10-05-2075 3 | 02-21-2103 4 | 07-09-2130 5 | 11-24-2157 6 | 04-11-2185 7 | 08-28-2212 8 | 01-14-2240 9 | 06-01-2267 select avg(cfloat4) from aggfns where cfloat8 < 1000; avg ----- NaN select s, avg(cfloat4) from aggfns where cfloat8 < 1000 group by s order by avg(cfloat4), s limit 10; s | avg ---+---------------------- 3 | -Infinity 9 | -0.292700759558938 4 | -0.177721596086072 6 | -0.00610964622725733 5 | 0.0107821527590975 0 | 0.0862269837114494 7 | 0.19168354413514 8 | 0.456703752867272 2 | Infinity 1 | NaN select ss, avg(cfloat4) from aggfns where cfloat8 < 1000 group by ss order by avg(cfloat4), ss limit 10; ss | avg ----+---------------------- 3 | -Infinity 9 | -0.292700759558938 4 | -0.169252917487522 6 | -0.00610964622725733 5 | 0.0107821527590975 0 | 0.0862269837114494 7 | 0.19168354413514 8 | 0.456703752867272 | Infinity 11 | NaN select max(cfloat4) from aggfns where cfloat8 < 1000; max ----- NaN select s, max(cfloat4) from aggfns where cfloat8 < 1000 group by s order by max(cfloat4), s limit 10; s | max ---+---------- 9 | 49.9899 4 | 49.9946 6 | 49.9956 7 | 49.9969 3 | 49.9979 5 | 49.9992 0 | 49.9995 8 | 49.9997 2 | Infinity 1 | NaN select ss, max(cfloat4) from aggfns where cfloat8 < 1000 group by ss order by max(cfloat4), ss limit 10; ss | max ----+---------- 9 | 49.9899 4 | 49.9946 6 | 49.9956 7 | 49.9969 3 | 49.9979 5 | 49.9992 0 | 49.9995 8 | 49.9997 | Infinity 11 | NaN select min(cfloat4) from aggfns where cfloat8 < 1000; min ----------- -Infinity select s, min(cfloat4) from aggfns where cfloat8 < 1000 group by s order by min(cfloat4), s limit 10; s | min ---+----------- 3 | -Infinity 4 | -49.9999 6 | -49.9995 2 | -49.9991 7 | -49.9984 1 | -49.9974 8 | -49.9969 0 | -49.9949 5 | -49.9942 9 | -49.9911 select ss, min(cfloat4) from aggfns where cfloat8 < 1000 group by ss order by min(cfloat4), ss limit 10; ss | min ----+----------- 3 | -Infinity 4 | -49.9999 6 | -49.9995 | -49.9991 7 | -49.9984 11 | -49.9974 8 | -49.9969 0 | -49.9949 5 | -49.9942 9 | -49.9911 select stddev(cfloat4) from aggfns where cfloat8 < 1000; stddev -------- NaN select s, stddev(cfloat4) from aggfns where cfloat8 < 1000 group by s order by stddev(cfloat4), s limit 10; s | stddev ---+------------------ 0 | 28.7274163912974 7 | 28.7892027644317 4 | 28.8273136003882 9 | 28.8426424990846 6 | 28.9190577543738 8 | 29.0040125904064 5 | 29.0213532270615 1 | NaN 2 | NaN 3 | NaN select ss, stddev(cfloat4) from aggfns where cfloat8 < 1000 group by ss order by stddev(cfloat4), ss limit 10; ss | stddev ----+------------------ 0 | 28.7274163912974 7 | 28.7892027644318 4 | 28.8220943927954 9 | 28.8426424990846 6 | 28.9190577543738 8 | 29.0040125904064 5 | 29.0213532270614 3 | NaN 11 | NaN | NaN select sum(cfloat4) from aggfns where cfloat8 < 1000; sum ----- NaN select s, sum(cfloat4) from aggfns where cfloat8 < 1000 group by s order by sum(cfloat4), s limit 10; s | sum ---+----------- 3 | -Infinity 9 | -5854.02 4 | -3554.43 6 | -122.193 5 | 215.643 0 | 1724.54 7 | 3833.67 8 | 9134.08 2 | Infinity 1 | NaN select ss, sum(cfloat4) from aggfns where cfloat8 < 1000 group by ss order by sum(cfloat4), ss limit 10; ss | sum ----+----------- 3 | -Infinity 9 | -5854.02 4 | -3381.84 6 | -122.193 5 | 215.643 0 | 1724.54 7 | 3833.67 8 | 9134.08 | Infinity 11 | NaN select avg(cfloat8) from aggfns where cfloat8 < 1000; avg ----------------- 1.2289014329263 select s, avg(cfloat8) from aggfns where cfloat8 < 1000 group by s order by avg(cfloat8), s limit 10; s | avg ---+-------------------- 0 | -0.306925132697215 8 | -0.268692900155438 4 | -0.220256273869891 3 | -0.14819676399231 9 | -0.114842409039848 7 | -0.063637967283139 5 | 0.0438265096326359 6 | 0.169599099685438 2 | 0.198140166982776 1 | 13 select ss, avg(cfloat8) from aggfns where cfloat8 < 1000 group by ss order by avg(cfloat8), ss limit 10; ss | avg ----+-------------------- 0 | -0.306925132697215 8 | -0.268692900155438 4 | -0.224160255000712 3 | -0.153492446187821 9 | -0.114842409039848 7 | -0.063637967283139 5 | 0.0438265096326359 6 | 0.169599099685438 | 0.203097089119745 11 | 12.9913492471038 select max(cfloat8) from aggfns where cfloat8 < 1000; max ------------------ 49.9995574122295 select s, max(cfloat8) from aggfns where cfloat8 < 1000 group by s order by max(cfloat8), s limit 10; s | max ---+------------------ 1 | 13 5 | 49.9874341068789 3 | 49.9890822684392 6 | 49.9939429108053 8 | 49.9963666079566 0 | 49.9965498689562 7 | 49.9973275698721 2 | 49.9975695507601 4 | 49.9978997278959 9 | 49.9995574122295 select ss, max(cfloat8) from aggfns where cfloat8 < 1000 group by ss order by max(cfloat8), ss limit 10; ss | max ----+------------------ 11 | 42.8941954858601 5 | 49.9874341068789 3 | 49.9890822684392 6 | 49.9939429108053 8 | 49.9963666079566 0 | 49.9965498689562 7 | 49.9973275698721 | 49.9975695507601 4 | 49.9978997278959 9 | 49.9995574122295 select min(cfloat8) from aggfns where cfloat8 < 1000; min ------------------- -49.9994775978848 select s, min(cfloat8) from aggfns where cfloat8 < 1000 group by s order by min(cfloat8), s limit 10; s | min ---+------------------- 0 | -49.9994775978848 2 | -49.9985320260748 4 | -49.9983572866768 3 | -49.9977725092322 6 | -49.9967515002936 9 | -49.992344272323 5 | -49.9921301845461 7 | -49.99003498815 8 | -49.9897602945566 1 | 13 select ss, min(cfloat8) from aggfns where cfloat8 < 1000 group by ss order by min(cfloat8), ss limit 10; ss | min ----+------------------- 0 | -49.9994775978848 | -49.9985320260748 4 | -49.9983572866768 3 | -49.9977725092322 6 | -49.9967515002936 9 | -49.992344272323 5 | -49.9921301845461 7 | -49.99003498815 8 | -49.9897602945566 11 | -46.2087355088443 select stddev(cfloat8) from aggfns where cfloat8 < 1000; stddev ------------------ 27.6606134001179 select s, stddev(cfloat8) from aggfns where cfloat8 < 1000 group by s order by stddev(cfloat8), s limit 10; s | stddev ---+------------------ 1 | 0 2 | 28.7611066711723 9 | 28.7642081921344 4 | 28.77864036235 5 | 28.7843925303698 6 | 28.8543767497509 3 | 28.9210796983077 8 | 28.96331707256 0 | 28.965342556856 7 | 28.9656492103737 select ss, stddev(cfloat8) from aggfns where cfloat8 < 1000 group by ss order by stddev(cfloat8), ss limit 10; ss | stddev ----+------------------- 11 | 0.998497915010093 | 28.7561000172161 9 | 28.7642081921344 4 | 28.7760615445521 5 | 28.7843925303698 6 | 28.8543767497508 3 | 28.926156595386 8 | 28.96331707256 0 | 28.9653425568561 7 | 28.9656492103736 select sum(cfloat8) from aggfns where cfloat8 < 1000; sum ----------------- 245780.28658526 select s, sum(cfloat8) from aggfns where cfloat8 < 1000 group by s order by sum(cfloat8), s limit 10; s | sum ---+------------------- 0 | -6138.50265394431 8 | -5373.85800310876 4 | -4405.12547739781 3 | -2963.93527984619 9 | -2296.84818079695 7 | -1272.75934566278 5 | 876.530192652717 6 | 3391.98199370876 2 | 3962.80333965551 1 | 260000 select ss, sum(cfloat8) from aggfns where cfloat8 < 1000 group by ss order by sum(cfloat8), ss limit 10; ss | sum ----+------------------- 0 | -6138.50265394431 8 | -5373.85800310876 4 | -4478.94605516922 3 | -3066.93256727885 9 | -2296.84818079695 7 | -1272.75934566278 5 | 876.530192652717 6 | 3391.98199370876 | 4065.80062708817 11 | 260073.820577771 select avg(cint2) from aggfns where cfloat8 < 1000; avg ---------------------- -33.1461788699264301 select s, avg(cint2) from aggfns where cfloat8 < 1000 group by s order by avg(cint2), s limit 10; s | avg ---+----------------------- 2 | -158.3178019118162254 8 | -129.4959711726139833 3 | -95.7656773935238477 6 | -61.0756218407487113 7 | -55.8695260497472599 4 | -28.7127771382813673 9 | -21.7994594865121866 0 | 17.5951654071367799 1 | 91.9493518842900756 5 | 110.0305290025524248 select ss, avg(cint2) from aggfns where cfloat8 < 1000 group by ss order by avg(cint2), ss limit 10; ss | avg ----+----------------------- | -159.4671500000000000 8 | -129.4959711726139833 3 | -94.5546037471195271 6 | -61.0756218407487113 7 | -55.8695260497472599 4 | -27.5652740206392145 9 | -21.7994594865121866 0 | 17.5951654071367799 11 | 90.6894000000000000 5 | 110.0305290025524248 select count(cint2) from aggfns where cfloat8 < 1000; count -------- 199810 select s, count(cint2) from aggfns where cfloat8 < 1000 group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 19981 1 | 19981 2 | 19981 3 | 19981 4 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 select ss, count(cint2) from aggfns where cfloat8 < 1000 group by ss order by count(cint2), ss limit 10; ss | count ----+------- 3 | 19962 4 | 19962 0 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 11 | 20000 | 20000 select max(cint2) from aggfns where cfloat8 < 1000; max ------- 16383 select s, max(cint2) from aggfns where cfloat8 < 1000 group by s order by max(cint2), s limit 10; s | max ---+------- 3 | 16380 2 | 16381 5 | 16381 7 | 16381 8 | 16382 0 | 16383 1 | 16383 4 | 16383 6 | 16383 9 | 16383 select ss, max(cint2) from aggfns where cfloat8 < 1000 group by ss order by max(cint2), ss limit 10; ss | max ----+------- 3 | 16380 5 | 16381 7 | 16381 | 16381 8 | 16382 0 | 16383 4 | 16383 6 | 16383 9 | 16383 11 | 16383 select min(cint2) from aggfns where cfloat8 < 1000; min -------- -16383 select s, min(cint2) from aggfns where cfloat8 < 1000 group by s order by min(cint2), s limit 10; s | min ---+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 2 | -16382 7 | -16382 8 | -16382 3 | -16381 1 | -16378 9 | -16375 select ss, min(cint2) from aggfns where cfloat8 < 1000 group by ss order by min(cint2), ss limit 10; ss | min ----+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 7 | -16382 8 | -16382 | -16382 3 | -16381 11 | -16378 9 | -16375 select stddev(cint2) from aggfns where cfloat8 < 1000; stddev ------------------- 9475.597346265432 select s, stddev(cint2) from aggfns where cfloat8 < 1000 group by s order by stddev(cint2), s limit 10; s | stddev ---+------------------- 9 | 9450.322790943425 2 | 9458.737760855119 7 | 9462.161209850735 6 | 9467.569674984571 5 | 9467.776835158782 3 | 9473.424234931108 8 | 9477.586839536066 4 | 9483.720025499142 0 | 9484.907423282680 1 | 9528.039076724276 select ss, stddev(cint2) from aggfns where cfloat8 < 1000 group by ss order by stddev(cint2), ss limit 10; ss | stddev ----+------------------- 9 | 9450.322790943425 | 9457.685918593809 7 | 9462.161209850735 6 | 9467.569674984571 5 | 9467.776835158782 3 | 9474.482349111595 8 | 9477.586839536066 4 | 9483.611454519949 0 | 9484.907423282680 11 | 9528.120007675789 select sum(cint2) from aggfns where cfloat8 < 1000; sum ---------- -6622938 select s, sum(cint2) from aggfns where cfloat8 < 1000 group by s order by sum(cint2), s limit 10; s | sum ---+---------- 2 | -3163348 8 | -2587459 3 | -1913494 6 | -1220352 7 | -1116329 4 | -573710 9 | -435575 0 | 351569 1 | 1837240 5 | 2198520 select ss, sum(cint2) from aggfns where cfloat8 < 1000 group by ss order by sum(cint2), ss limit 10; ss | sum ----+---------- | -3189343 8 | -2587459 3 | -1887499 6 | -1220352 7 | -1116329 4 | -550258 9 | -435575 0 | 351569 11 | 1813788 5 | 2198520 select avg(cint4) from aggfns where cfloat8 < 1000; avg --------------------- -4.9369150000000000 select s, avg(cint4) from aggfns where cfloat8 < 1000 group by s order by avg(cint4), s limit 10; s | avg ---+----------------------- 9 | -102.4283000000000000 2 | -101.3952000000000000 6 | -53.1566500000000000 7 | -42.6121500000000000 8 | -29.2615500000000000 4 | 6.6530500000000000 0 | 27.7536500000000000 3 | 70.4102500000000000 1 | 71.5608500000000000 5 | 103.1069000000000000 select ss, avg(cint4) from aggfns where cfloat8 < 1000 group by ss order by avg(cint4), ss limit 10; ss | avg ----+----------------------- 9 | -102.4283000000000000 | -99.2131475098656277 6 | -53.1566500000000000 7 | -42.6121500000000000 8 | -29.2615500000000000 4 | 9.6930584054852110 0 | 27.7536500000000000 3 | 68.3874180471447875 11 | 68.4650082421699386 5 | 103.1069000000000000 select max(cint4) from aggfns where cfloat8 < 1000; max ------- 16383 select s, max(cint4) from aggfns where cfloat8 < 1000 group by s order by max(cint4), s limit 10; s | max ---+------- 3 | 16379 5 | 16379 7 | 16379 2 | 16381 0 | 16383 1 | 16383 4 | 16383 6 | 16383 8 | 16383 9 | 16383 select ss, max(cint4) from aggfns where cfloat8 < 1000 group by ss order by max(cint4), ss limit 10; ss | max ----+------- 3 | 16379 5 | 16379 7 | 16379 | 16381 0 | 16383 4 | 16383 6 | 16383 8 | 16383 9 | 16383 11 | 16383 select min(cint4) from aggfns where cfloat8 < 1000; min -------- -16383 select s, min(cint4) from aggfns where cfloat8 < 1000 group by s order by min(cint4), s limit 10; s | min ---+-------- 0 | -16383 2 | -16383 7 | -16383 1 | -16382 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16382 5 | -16380 select ss, min(cint4) from aggfns where cfloat8 < 1000 group by ss order by min(cint4), ss limit 10; ss | min ----+-------- 0 | -16383 7 | -16383 | -16383 3 | -16382 4 | -16382 6 | -16382 8 | -16382 9 | -16382 11 | -16382 5 | -16380 select stddev(cint4) from aggfns where cfloat8 < 1000; stddev ------------------- 9450.334382392243 select s, stddev(cint4) from aggfns where cfloat8 < 1000 group by s order by stddev(cint4), s limit 10; s | stddev ---+------------------- 0 | 9406.815855797801 6 | 9410.397911988306 9 | 9426.452583637956 2 | 9440.675087350597 4 | 9443.098516157448 8 | 9450.281544631633 1 | 9459.538662433945 3 | 9474.762271621918 7 | 9485.765898279180 5 | 9504.684751625578 select ss, stddev(cint4) from aggfns where cfloat8 < 1000 group by ss order by stddev(cint4), ss limit 10; ss | stddev ----+------------------- 0 | 9406.815855797801 6 | 9410.397911988306 9 | 9426.452583637956 | 9440.633682496139 4 | 9442.480718256247 8 | 9450.281544631633 11 | 9460.158622933231 3 | 9474.873657491443 7 | 9485.765898279180 5 | 9504.684751625578 select sum(cint4) from aggfns where cfloat8 < 1000; sum --------- -987383 select s, sum(cint4) from aggfns where cfloat8 < 1000 group by s order by sum(cint4), s limit 10; s | sum ---+---------- 9 | -2048566 2 | -2027904 6 | -1063133 7 | -852243 8 | -585231 4 | 133061 0 | 555073 3 | 1408205 1 | 1431217 5 | 2062138 select ss, sum(cint4) from aggfns where cfloat8 < 1000 group by ss order by sum(cint4), ss limit 10; ss | sum ----+---------- 9 | -2048566 | -1986148 6 | -1063133 7 | -852243 8 | -585231 4 | 193677 0 | 555073 3 | 1366449 11 | 1370601 5 | 2062138 select avg(cint8) from aggfns where cfloat8 < 1000; avg ---------------------- -12.1026800000000000 select s, avg(cint8) from aggfns where cfloat8 < 1000 group by s order by avg(cint8), s limit 10; s | avg ---+----------------------- 8 | -118.4870000000000000 5 | -81.6955500000000000 1 | -25.4401500000000000 4 | -19.5071500000000000 2 | -2.4691500000000000 7 | -2.3563500000000000 6 | 11.9056500000000000 0 | 15.3018000000000000 3 | 39.9743500000000000 9 | 61.7467500000000000 select ss, avg(cint8) from aggfns where cfloat8 < 1000 group by ss order by avg(cint8), ss limit 10; ss | avg ----+------------------------- 8 | -118.4870000000000000 5 | -81.6955500000000000 11 | -27.8558869074379340 4 | -17.0811771182623492 7 | -2.3563500000000000 | -0.12513112543084070133 6 | 11.9056500000000000 0 | 15.3018000000000000 3 | 37.6662329212752115 9 | 61.7467500000000000 select max(cint8) from aggfns where cfloat8 < 1000; max ------- 16383 select s, max(cint8) from aggfns where cfloat8 < 1000 group by s order by max(cint8), s limit 10; s | max ---+------- 2 | 16379 6 | 16380 7 | 16380 8 | 16380 3 | 16382 9 | 16382 0 | 16383 1 | 16383 4 | 16383 5 | 16383 select ss, max(cint8) from aggfns where cfloat8 < 1000 group by ss order by max(cint8), ss limit 10; ss | max ----+------- | 16379 6 | 16380 7 | 16380 8 | 16380 3 | 16382 9 | 16382 0 | 16383 4 | 16383 5 | 16383 11 | 16383 select min(cint8) from aggfns where cfloat8 < 1000; min -------- -16383 select s, min(cint8) from aggfns where cfloat8 < 1000 group by s order by min(cint8), s limit 10; s | min ---+-------- 0 | -16383 1 | -16383 6 | -16383 7 | -16383 8 | -16383 5 | -16382 4 | -16381 9 | -16380 2 | -16379 3 | -16378 select ss, min(cint8) from aggfns where cfloat8 < 1000 group by ss order by min(cint8), ss limit 10; ss | min ----+-------- 0 | -16383 6 | -16383 7 | -16383 8 | -16383 11 | -16383 5 | -16382 4 | -16381 9 | -16380 | -16379 3 | -16378 select sum(cint8) from aggfns where cfloat8 < 1000; sum ---------- -2420536 select s, sum(cint8) from aggfns where cfloat8 < 1000 group by s order by sum(cint8), s limit 10; s | sum ---+---------- 8 | -2369740 5 | -1633911 1 | -508803 4 | -390143 2 | -49383 7 | -47127 6 | 238113 0 | 306036 3 | 799487 9 | 1234935 select ss, sum(cint8) from aggfns where cfloat8 < 1000 group by ss order by sum(cint8), ss limit 10; ss | sum ----+---------- 8 | -2369740 5 | -1633911 11 | -557647 4 | -341299 7 | -47127 | -2505 6 | 238113 0 | 306036 3 | 752609 9 | 1234935 select max(cts) from aggfns where cfloat8 < 1000; max -------------------------- Sat Jan 02 02:01:01 2021 select s, max(cts) from aggfns where cfloat8 < 1000 group by s order by max(cts), s limit 10; s | max ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 1 | Fri Jan 01 03:47:41 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, max(cts) from aggfns where cfloat8 < 1000 group by ss order by max(cts), ss limit 10; ss | max ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 3 | Fri Jan 01 09:21:01 2021 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 11 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select min(cts) from aggfns where cfloat8 < 1000; min -------------------------- Fri Jan 01 01:01:01 2021 select s, min(cts) from aggfns where cfloat8 < 1000 group by s order by min(cts), s limit 10; s | min ---+-------------------------- 0 | Fri Jan 01 01:01:01 2021 1 | Fri Jan 01 03:47:41 2021 2 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select ss, min(cts) from aggfns where cfloat8 < 1000 group by ss order by min(cts), ss limit 10; ss | min ----+-------------------------- 0 | Fri Jan 01 01:01:01 2021 11 | Fri Jan 01 03:47:41 2021 | Fri Jan 01 06:34:21 2021 3 | Fri Jan 01 09:21:01 2021 4 | Fri Jan 01 12:07:41 2021 5 | Fri Jan 01 14:54:21 2021 6 | Fri Jan 01 17:41:01 2021 7 | Fri Jan 01 20:27:41 2021 8 | Fri Jan 01 23:14:21 2021 9 | Sat Jan 02 02:01:01 2021 select max(ctstz) from aggfns where cfloat8 < 1000; max ------------------------------ Sat Jan 02 02:01:01 2021 PST select s, max(ctstz) from aggfns where cfloat8 < 1000 group by s order by max(ctstz), s limit 10; s | max ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 1 | Fri Jan 01 03:47:41 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, max(ctstz) from aggfns where cfloat8 < 1000 group by ss order by max(ctstz), ss limit 10; ss | max ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 11 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select min(ctstz) from aggfns where cfloat8 < 1000; min ------------------------------ Fri Jan 01 01:01:01 2021 PST select s, min(ctstz) from aggfns where cfloat8 < 1000 group by s order by min(ctstz), s limit 10; s | min ---+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 1 | Fri Jan 01 03:47:41 2021 PST 2 | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select ss, min(ctstz) from aggfns where cfloat8 < 1000 group by ss order by min(ctstz), ss limit 10; ss | min ----+------------------------------ 0 | Fri Jan 01 01:01:01 2021 PST 11 | Fri Jan 01 03:47:41 2021 PST | Fri Jan 01 06:34:21 2021 PST 3 | Fri Jan 01 09:21:01 2021 PST 4 | Fri Jan 01 12:07:41 2021 PST 5 | Fri Jan 01 14:54:21 2021 PST 6 | Fri Jan 01 17:41:01 2021 PST 7 | Fri Jan 01 20:27:41 2021 PST 8 | Fri Jan 01 23:14:21 2021 PST 9 | Sat Jan 02 02:01:01 2021 PST select avg(s) from aggfns where cfloat8 < 1000; avg -------------------- 4.5000000000000000 select s, avg(s) from aggfns where cfloat8 < 1000 group by s order by avg(s), s limit 10; s | avg ---+---------------------------- 0 | 0.000000000000000000000000 1 | 1.00000000000000000000 2 | 2.0000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select ss, avg(s) from aggfns where cfloat8 < 1000 group by ss order by avg(s), ss limit 10; ss | avg ----+---------------------------- 0 | 0.000000000000000000000000 11 | 1.00284729506968380039 | 2.0009490983565613 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 select count(s) from aggfns where cfloat8 < 1000; count -------- 200000 select s, count(s) from aggfns where cfloat8 < 1000 group by s order by count(s), s limit 10; s | count ---+------- 0 | 20000 1 | 20000 2 | 20000 3 | 20000 4 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 select ss, count(s) from aggfns where cfloat8 < 1000 group by ss order by count(s), ss limit 10; ss | count ----+------- 3 | 19981 4 | 19981 0 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 11 | 20019 | 20019 select max(s) from aggfns where cfloat8 < 1000; max ----- 9 select s, max(s) from aggfns where cfloat8 < 1000 group by s order by max(s), s limit 10; s | max ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, max(s) from aggfns where cfloat8 < 1000 group by ss order by max(s), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 | 3 4 | 4 11 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select min(s) from aggfns where cfloat8 < 1000; min ----- 0 select s, min(s) from aggfns where cfloat8 < 1000 group by s order by min(s), s limit 10; s | min ---+----- 0 | 0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select ss, min(s) from aggfns where cfloat8 < 1000 group by ss order by min(s), ss limit 10; ss | min ----+----- 0 | 0 11 | 1 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 select stddev(s) from aggfns where cfloat8 < 1000; stddev -------------------- 2.8722885039992502 select s, stddev(s) from aggfns where cfloat8 < 1000 group by s order by stddev(s), s limit 10; s | stddev ---+-------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select ss, stddev(s) from aggfns where cfloat8 < 1000 group by ss order by stddev(s), ss limit 10; ss | stddev ----+------------------------ 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 | 0.03079358595744834506 11 | 0.09238075787234503528 select sum(s) from aggfns where cfloat8 < 1000; sum -------- 900000 select s, sum(s) from aggfns where cfloat8 < 1000 group by s order by sum(s), s limit 10; s | sum ---+-------- 0 | 0 1 | 20000 2 | 40000 3 | 60000 4 | 80000 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 select ss, sum(s) from aggfns where cfloat8 < 1000 group by ss order by sum(s), ss limit 10; ss | sum ----+-------- 0 | 0 11 | 20076 | 40057 3 | 59943 4 | 79924 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 select avg(ss) from aggfns where cfloat8 < 1000; avg -------------------- 5.8899328262427701 select s, avg(ss) from aggfns where cfloat8 < 1000 group by s order by avg(ss), s limit 10; s | avg ---+---------------------------- 0 | 0.000000000000000000000000 3 | 3.0000000000000000 4 | 4.0066500000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 1 | 11.0000000000000000 2 | select ss, avg(ss) from aggfns where cfloat8 < 1000 group by ss order by avg(ss), ss limit 10; ss | avg ----+---------------------------- 0 | 0.000000000000000000000000 3 | 3.0000000000000000 4 | 4.0000000000000000 5 | 5.0000000000000000 6 | 6.0000000000000000 7 | 7.0000000000000000 8 | 8.0000000000000000 9 | 9.0000000000000000 11 | 11.0000000000000000 | select max(ss) from aggfns where cfloat8 < 1000; max ----- 11 select s, max(ss) from aggfns where cfloat8 < 1000 group by s order by max(ss), s limit 10; s | max ---+----- 0 | 0 3 | 3 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 4 | 11 2 | select ss, max(ss) from aggfns where cfloat8 < 1000 group by ss order by max(ss), ss limit 10; ss | max ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select min(ss) from aggfns where cfloat8 < 1000; min ----- 0 select s, min(ss) from aggfns where cfloat8 < 1000 group by s order by min(ss), s limit 10; s | min ---+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 1 | 11 2 | select ss, min(ss) from aggfns where cfloat8 < 1000 group by ss order by min(ss), ss limit 10; ss | min ----+----- 0 | 0 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 11 | 11 | select stddev(ss) from aggfns where cfloat8 < 1000; stddev -------------------- 3.1431098825513430 select s, stddev(ss) from aggfns where cfloat8 < 1000 group by s order by stddev(ss), s limit 10; s | stddev ---+------------------------ 0 | 0 1 | 0 3 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 4 | 0.21565737387148452722 2 | select ss, stddev(ss) from aggfns where cfloat8 < 1000 group by ss order by stddev(ss), ss limit 10; ss | stddev ----+-------- 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 11 | 0 | select sum(ss) from aggfns where cfloat8 < 1000; sum --------- 1060076 select s, sum(ss) from aggfns where cfloat8 < 1000 group by s order by sum(ss), s limit 10; s | sum ---+-------- 0 | 0 3 | 59943 4 | 80133 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 1 | 220000 2 | select ss, sum(ss) from aggfns where cfloat8 < 1000 group by ss order by sum(ss), ss limit 10; ss | sum ----+-------- 0 | 0 3 | 59943 4 | 79924 5 | 100000 6 | 120000 7 | 140000 8 | 160000 9 | 180000 11 | 220209 | select max(t) from aggfns where cfloat8 < 1000; max -------- 110000 select s, max(t) from aggfns where cfloat8 < 1000 group by s order by max(t), s limit 10; s | max ---+-------- 0 | 20000 1 | 30000 2 | 40000 3 | 50000 4 | 60000 5 | 70000 6 | 80000 7 | 90000 8 | 100000 9 | 110000 select ss, max(t) from aggfns where cfloat8 < 1000 group by ss order by max(t), ss limit 10; ss | max ----+-------- 0 | 20000 | 49491 3 | 50000 11 | 59192 4 | 60000 5 | 70000 6 | 80000 7 | 90000 8 | 100000 9 | 110000 select min(t) from aggfns where cfloat8 < 1000; min ----- 1 select s, min(t) from aggfns where cfloat8 < 1000 group by s order by min(t), s limit 10; s | min ---+------- 0 | 1 1 | 10001 2 | 20001 3 | 30001 4 | 40001 5 | 50001 6 | 60001 7 | 70001 8 | 80001 9 | 90001 select ss, min(t) from aggfns where cfloat8 < 1000 group by ss order by min(t), ss limit 10; ss | min ----+------- 0 | 1 11 | 10001 | 20001 3 | 30001 4 | 40001 5 | 50001 6 | 60001 7 | 70001 8 | 80001 9 | 90001 select count(*) from aggfns where cfloat8 > 1000; count ------- 0 select s, count(*) from aggfns where cfloat8 > 1000 group by s order by count(*), s limit 10; s | count ---+------- select ss, count(*) from aggfns where cfloat8 > 1000 group by ss order by count(*), ss limit 10; ss | count ----+------- select max(cdate) from aggfns where cfloat8 > 1000; max ----- select s, max(cdate) from aggfns where cfloat8 > 1000 group by s order by max(cdate), s limit 10; s | max ---+----- select ss, max(cdate) from aggfns where cfloat8 > 1000 group by ss order by max(cdate), ss limit 10; ss | max ----+----- select min(cdate) from aggfns where cfloat8 > 1000; min ----- select s, min(cdate) from aggfns where cfloat8 > 1000 group by s order by min(cdate), s limit 10; s | min ---+----- select ss, min(cdate) from aggfns where cfloat8 > 1000 group by ss order by min(cdate), ss limit 10; ss | min ----+----- select avg(cfloat4) from aggfns where cfloat8 > 1000; avg ----- select s, avg(cfloat4) from aggfns where cfloat8 > 1000 group by s order by avg(cfloat4), s limit 10; s | avg ---+----- select ss, avg(cfloat4) from aggfns where cfloat8 > 1000 group by ss order by avg(cfloat4), ss limit 10; ss | avg ----+----- select max(cfloat4) from aggfns where cfloat8 > 1000; max ----- select s, max(cfloat4) from aggfns where cfloat8 > 1000 group by s order by max(cfloat4), s limit 10; s | max ---+----- select ss, max(cfloat4) from aggfns where cfloat8 > 1000 group by ss order by max(cfloat4), ss limit 10; ss | max ----+----- select min(cfloat4) from aggfns where cfloat8 > 1000; min ----- select s, min(cfloat4) from aggfns where cfloat8 > 1000 group by s order by min(cfloat4), s limit 10; s | min ---+----- select ss, min(cfloat4) from aggfns where cfloat8 > 1000 group by ss order by min(cfloat4), ss limit 10; ss | min ----+----- select stddev(cfloat4) from aggfns where cfloat8 > 1000; stddev -------- select s, stddev(cfloat4) from aggfns where cfloat8 > 1000 group by s order by stddev(cfloat4), s limit 10; s | stddev ---+-------- select ss, stddev(cfloat4) from aggfns where cfloat8 > 1000 group by ss order by stddev(cfloat4), ss limit 10; ss | stddev ----+-------- select sum(cfloat4) from aggfns where cfloat8 > 1000; sum ----- select s, sum(cfloat4) from aggfns where cfloat8 > 1000 group by s order by sum(cfloat4), s limit 10; s | sum ---+----- select ss, sum(cfloat4) from aggfns where cfloat8 > 1000 group by ss order by sum(cfloat4), ss limit 10; ss | sum ----+----- select avg(cfloat8) from aggfns where cfloat8 > 1000; avg ----- select s, avg(cfloat8) from aggfns where cfloat8 > 1000 group by s order by avg(cfloat8), s limit 10; s | avg ---+----- select ss, avg(cfloat8) from aggfns where cfloat8 > 1000 group by ss order by avg(cfloat8), ss limit 10; ss | avg ----+----- select max(cfloat8) from aggfns where cfloat8 > 1000; max ----- select s, max(cfloat8) from aggfns where cfloat8 > 1000 group by s order by max(cfloat8), s limit 10; s | max ---+----- select ss, max(cfloat8) from aggfns where cfloat8 > 1000 group by ss order by max(cfloat8), ss limit 10; ss | max ----+----- select min(cfloat8) from aggfns where cfloat8 > 1000; min ----- select s, min(cfloat8) from aggfns where cfloat8 > 1000 group by s order by min(cfloat8), s limit 10; s | min ---+----- select ss, min(cfloat8) from aggfns where cfloat8 > 1000 group by ss order by min(cfloat8), ss limit 10; ss | min ----+----- select stddev(cfloat8) from aggfns where cfloat8 > 1000; stddev -------- select s, stddev(cfloat8) from aggfns where cfloat8 > 1000 group by s order by stddev(cfloat8), s limit 10; s | stddev ---+-------- select ss, stddev(cfloat8) from aggfns where cfloat8 > 1000 group by ss order by stddev(cfloat8), ss limit 10; ss | stddev ----+-------- select sum(cfloat8) from aggfns where cfloat8 > 1000; sum ----- select s, sum(cfloat8) from aggfns where cfloat8 > 1000 group by s order by sum(cfloat8), s limit 10; s | sum ---+----- select ss, sum(cfloat8) from aggfns where cfloat8 > 1000 group by ss order by sum(cfloat8), ss limit 10; ss | sum ----+----- select avg(cint2) from aggfns where cfloat8 > 1000; avg ----- select s, avg(cint2) from aggfns where cfloat8 > 1000 group by s order by avg(cint2), s limit 10; s | avg ---+----- select ss, avg(cint2) from aggfns where cfloat8 > 1000 group by ss order by avg(cint2), ss limit 10; ss | avg ----+----- select count(cint2) from aggfns where cfloat8 > 1000; count ------- 0 select s, count(cint2) from aggfns where cfloat8 > 1000 group by s order by count(cint2), s limit 10; s | count ---+------- select ss, count(cint2) from aggfns where cfloat8 > 1000 group by ss order by count(cint2), ss limit 10; ss | count ----+------- select max(cint2) from aggfns where cfloat8 > 1000; max ----- select s, max(cint2) from aggfns where cfloat8 > 1000 group by s order by max(cint2), s limit 10; s | max ---+----- select ss, max(cint2) from aggfns where cfloat8 > 1000 group by ss order by max(cint2), ss limit 10; ss | max ----+----- select min(cint2) from aggfns where cfloat8 > 1000; min ----- select s, min(cint2) from aggfns where cfloat8 > 1000 group by s order by min(cint2), s limit 10; s | min ---+----- select ss, min(cint2) from aggfns where cfloat8 > 1000 group by ss order by min(cint2), ss limit 10; ss | min ----+----- select stddev(cint2) from aggfns where cfloat8 > 1000; stddev -------- select s, stddev(cint2) from aggfns where cfloat8 > 1000 group by s order by stddev(cint2), s limit 10; s | stddev ---+-------- select ss, stddev(cint2) from aggfns where cfloat8 > 1000 group by ss order by stddev(cint2), ss limit 10; ss | stddev ----+-------- select sum(cint2) from aggfns where cfloat8 > 1000; sum ----- select s, sum(cint2) from aggfns where cfloat8 > 1000 group by s order by sum(cint2), s limit 10; s | sum ---+----- select ss, sum(cint2) from aggfns where cfloat8 > 1000 group by ss order by sum(cint2), ss limit 10; ss | sum ----+----- select avg(cint4) from aggfns where cfloat8 > 1000; avg ----- select s, avg(cint4) from aggfns where cfloat8 > 1000 group by s order by avg(cint4), s limit 10; s | avg ---+----- select ss, avg(cint4) from aggfns where cfloat8 > 1000 group by ss order by avg(cint4), ss limit 10; ss | avg ----+----- select max(cint4) from aggfns where cfloat8 > 1000; max ----- select s, max(cint4) from aggfns where cfloat8 > 1000 group by s order by max(cint4), s limit 10; s | max ---+----- select ss, max(cint4) from aggfns where cfloat8 > 1000 group by ss order by max(cint4), ss limit 10; ss | max ----+----- select min(cint4) from aggfns where cfloat8 > 1000; min ----- select s, min(cint4) from aggfns where cfloat8 > 1000 group by s order by min(cint4), s limit 10; s | min ---+----- select ss, min(cint4) from aggfns where cfloat8 > 1000 group by ss order by min(cint4), ss limit 10; ss | min ----+----- select stddev(cint4) from aggfns where cfloat8 > 1000; stddev -------- select s, stddev(cint4) from aggfns where cfloat8 > 1000 group by s order by stddev(cint4), s limit 10; s | stddev ---+-------- select ss, stddev(cint4) from aggfns where cfloat8 > 1000 group by ss order by stddev(cint4), ss limit 10; ss | stddev ----+-------- select sum(cint4) from aggfns where cfloat8 > 1000; sum ----- select s, sum(cint4) from aggfns where cfloat8 > 1000 group by s order by sum(cint4), s limit 10; s | sum ---+----- select ss, sum(cint4) from aggfns where cfloat8 > 1000 group by ss order by sum(cint4), ss limit 10; ss | sum ----+----- select avg(cint8) from aggfns where cfloat8 > 1000; avg ----- select s, avg(cint8) from aggfns where cfloat8 > 1000 group by s order by avg(cint8), s limit 10; s | avg ---+----- select ss, avg(cint8) from aggfns where cfloat8 > 1000 group by ss order by avg(cint8), ss limit 10; ss | avg ----+----- select max(cint8) from aggfns where cfloat8 > 1000; max ----- select s, max(cint8) from aggfns where cfloat8 > 1000 group by s order by max(cint8), s limit 10; s | max ---+----- select ss, max(cint8) from aggfns where cfloat8 > 1000 group by ss order by max(cint8), ss limit 10; ss | max ----+----- select min(cint8) from aggfns where cfloat8 > 1000; min ----- select s, min(cint8) from aggfns where cfloat8 > 1000 group by s order by min(cint8), s limit 10; s | min ---+----- select ss, min(cint8) from aggfns where cfloat8 > 1000 group by ss order by min(cint8), ss limit 10; ss | min ----+----- select sum(cint8) from aggfns where cfloat8 > 1000; sum ----- select s, sum(cint8) from aggfns where cfloat8 > 1000 group by s order by sum(cint8), s limit 10; s | sum ---+----- select ss, sum(cint8) from aggfns where cfloat8 > 1000 group by ss order by sum(cint8), ss limit 10; ss | sum ----+----- select max(cts) from aggfns where cfloat8 > 1000; max ----- select s, max(cts) from aggfns where cfloat8 > 1000 group by s order by max(cts), s limit 10; s | max ---+----- select ss, max(cts) from aggfns where cfloat8 > 1000 group by ss order by max(cts), ss limit 10; ss | max ----+----- select min(cts) from aggfns where cfloat8 > 1000; min ----- select s, min(cts) from aggfns where cfloat8 > 1000 group by s order by min(cts), s limit 10; s | min ---+----- select ss, min(cts) from aggfns where cfloat8 > 1000 group by ss order by min(cts), ss limit 10; ss | min ----+----- select max(ctstz) from aggfns where cfloat8 > 1000; max ----- select s, max(ctstz) from aggfns where cfloat8 > 1000 group by s order by max(ctstz), s limit 10; s | max ---+----- select ss, max(ctstz) from aggfns where cfloat8 > 1000 group by ss order by max(ctstz), ss limit 10; ss | max ----+----- select min(ctstz) from aggfns where cfloat8 > 1000; min ----- select s, min(ctstz) from aggfns where cfloat8 > 1000 group by s order by min(ctstz), s limit 10; s | min ---+----- select ss, min(ctstz) from aggfns where cfloat8 > 1000 group by ss order by min(ctstz), ss limit 10; ss | min ----+----- select avg(s) from aggfns where cfloat8 > 1000; avg ----- select s, avg(s) from aggfns where cfloat8 > 1000 group by s order by avg(s), s limit 10; s | avg ---+----- select ss, avg(s) from aggfns where cfloat8 > 1000 group by ss order by avg(s), ss limit 10; ss | avg ----+----- select count(s) from aggfns where cfloat8 > 1000; count ------- 0 select s, count(s) from aggfns where cfloat8 > 1000 group by s order by count(s), s limit 10; s | count ---+------- select ss, count(s) from aggfns where cfloat8 > 1000 group by ss order by count(s), ss limit 10; ss | count ----+------- select max(s) from aggfns where cfloat8 > 1000; max ----- select s, max(s) from aggfns where cfloat8 > 1000 group by s order by max(s), s limit 10; s | max ---+----- select ss, max(s) from aggfns where cfloat8 > 1000 group by ss order by max(s), ss limit 10; ss | max ----+----- select min(s) from aggfns where cfloat8 > 1000; min ----- select s, min(s) from aggfns where cfloat8 > 1000 group by s order by min(s), s limit 10; s | min ---+----- select ss, min(s) from aggfns where cfloat8 > 1000 group by ss order by min(s), ss limit 10; ss | min ----+----- select stddev(s) from aggfns where cfloat8 > 1000; stddev -------- select s, stddev(s) from aggfns where cfloat8 > 1000 group by s order by stddev(s), s limit 10; s | stddev ---+-------- select ss, stddev(s) from aggfns where cfloat8 > 1000 group by ss order by stddev(s), ss limit 10; ss | stddev ----+-------- select sum(s) from aggfns where cfloat8 > 1000; sum ----- select s, sum(s) from aggfns where cfloat8 > 1000 group by s order by sum(s), s limit 10; s | sum ---+----- select ss, sum(s) from aggfns where cfloat8 > 1000 group by ss order by sum(s), ss limit 10; ss | sum ----+----- select avg(ss) from aggfns where cfloat8 > 1000; avg ----- select s, avg(ss) from aggfns where cfloat8 > 1000 group by s order by avg(ss), s limit 10; s | avg ---+----- select ss, avg(ss) from aggfns where cfloat8 > 1000 group by ss order by avg(ss), ss limit 10; ss | avg ----+----- select max(ss) from aggfns where cfloat8 > 1000; max ----- select s, max(ss) from aggfns where cfloat8 > 1000 group by s order by max(ss), s limit 10; s | max ---+----- select ss, max(ss) from aggfns where cfloat8 > 1000 group by ss order by max(ss), ss limit 10; ss | max ----+----- select min(ss) from aggfns where cfloat8 > 1000; min ----- select s, min(ss) from aggfns where cfloat8 > 1000 group by s order by min(ss), s limit 10; s | min ---+----- select ss, min(ss) from aggfns where cfloat8 > 1000 group by ss order by min(ss), ss limit 10; ss | min ----+----- select stddev(ss) from aggfns where cfloat8 > 1000; stddev -------- select s, stddev(ss) from aggfns where cfloat8 > 1000 group by s order by stddev(ss), s limit 10; s | stddev ---+-------- select ss, stddev(ss) from aggfns where cfloat8 > 1000 group by ss order by stddev(ss), ss limit 10; ss | stddev ----+-------- select sum(ss) from aggfns where cfloat8 > 1000; sum ----- select s, sum(ss) from aggfns where cfloat8 > 1000 group by s order by sum(ss), s limit 10; s | sum ---+----- select ss, sum(ss) from aggfns where cfloat8 > 1000 group by ss order by sum(ss), ss limit 10; ss | sum ----+----- select max(t) from aggfns where cfloat8 > 1000; max ----- select s, max(t) from aggfns where cfloat8 > 1000 group by s order by max(t), s limit 10; s | max ---+----- select ss, max(t) from aggfns where cfloat8 > 1000 group by ss order by max(t), ss limit 10; ss | max ----+----- select min(t) from aggfns where cfloat8 > 1000; min ----- select s, min(t) from aggfns where cfloat8 > 1000 group by s order by min(t), s limit 10; s | min ---+----- select ss, min(t) from aggfns where cfloat8 > 1000 group by ss order by min(t), ss limit 10; ss | min ----+----- select avg(cint2) from aggfns where cint2 is null; avg ----- select s, avg(cint2) from aggfns where cint2 is null group by s order by avg(cint2), s limit 10; s | avg ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select ss, avg(cint2) from aggfns where cint2 is null group by ss order by avg(cint2), ss limit 10; ss | avg ----+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | | select count(cint2) from aggfns where cint2 is null; count ------- 0 select s, count(cint2) from aggfns where cint2 is null group by s order by count(cint2), s limit 10; s | count ---+------- 0 | 0 1 | 0 2 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 select ss, count(cint2) from aggfns where cint2 is null group by ss order by count(cint2), ss limit 10; ss | count ----+------- 0 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 11 | 0 | 0 select max(cint2) from aggfns where cint2 is null; max ----- select s, max(cint2) from aggfns where cint2 is null group by s order by max(cint2), s limit 10; s | max ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select ss, max(cint2) from aggfns where cint2 is null group by ss order by max(cint2), ss limit 10; ss | max ----+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | | select min(cint2) from aggfns where cint2 is null; min ----- select s, min(cint2) from aggfns where cint2 is null group by s order by min(cint2), s limit 10; s | min ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select ss, min(cint2) from aggfns where cint2 is null group by ss order by min(cint2), ss limit 10; ss | min ----+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | | select stddev(cint2) from aggfns where cint2 is null; stddev -------- select s, stddev(cint2) from aggfns where cint2 is null group by s order by stddev(cint2), s limit 10; s | stddev ---+-------- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select ss, stddev(cint2) from aggfns where cint2 is null group by ss order by stddev(cint2), ss limit 10; ss | stddev ----+-------- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | | select sum(cint2) from aggfns where cint2 is null; sum ----- select s, sum(cint2) from aggfns where cint2 is null group by s order by sum(cint2), s limit 10; s | sum ---+----- 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | select ss, sum(cint2) from aggfns where cint2 is null group by ss order by sum(cint2), ss limit 10; ss | sum ----+----- 0 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | | -- Test multiple aggregate functions as well. select count(*), count(cint2), min(cfloat4), cint2 from aggfns group by cint2 order by count(*) desc, cint2 limit 10 ; count | count | min | cint2 -------+-------+----------+-------- 190 | 0 | -49.6644 | 19 | 19 | -49.5299 | -8743 17 | 17 | -48.5497 | -12921 17 | 17 | -48.5697 | -701 17 | 17 | -47.2641 | 525 16 | 16 | -42.41 | -10234 16 | 16 | -47.2083 | -4609 16 | 16 | -49.9555 | -4261 16 | 16 | -35.1643 | -296 16 | 16 | -45.4426 | 1373 -- Test edge cases for various batch sizes and the filter matching around batch -- end. select count(*) from edges; count ------- 7720 select s, count(*) from edges group by 1 order by 1; s | count -----+------- 0 | 61 1 | 62 2 | 63 3 | 64 4 | 65 5 | 130 6 | 131 7 | 132 8 | 133 9 | 134 10 | 2247 11 | 2248 12 | 2249 111 | 1 select s, count(*), min(f1) from edges where f1 = 63 group by 1 order by 1; s | count | min ----+-------+----- 3 | 1 | 63 4 | 1 | 63 5 | 1 | 63 6 | 1 | 63 7 | 1 | 63 8 | 1 | 63 9 | 1 | 63 10 | 1 | 63 11 | 1 | 63 12 | 1 | 63 select s, count(*), min(f1) from edges where f1 = 64 group by 1 order by 1; s | count | min ----+-------+----- 4 | 1 | 64 5 | 1 | 64 6 | 1 | 64 7 | 1 | 64 8 | 1 | 64 9 | 1 | 64 10 | 1 | 64 11 | 1 | 64 12 | 1 | 64 select s, count(*), min(f1) from edges where f1 = 65 group by 1 order by 1; s | count | min ----+-------+----- 5 | 1 | 65 6 | 1 | 65 7 | 1 | 65 8 | 1 | 65 9 | 1 | 65 10 | 1 | 65 11 | 1 | 65 12 | 1 | 65 select ss, count(*), min(f1) from edges where f1 = 63 group by 1 order by 1; ss | count | min ----+-------+----- 3 | 1 | 63 4 | 1 | 63 5 | 1 | 63 6 | 1 | 63 7 | 1 | 63 8 | 1 | 63 9 | 1 | 63 10 | 1 | 63 11 | 1 | 63 12 | 1 | 63 select ss, count(*), min(f1) from edges where f1 = 64 group by 1 order by 1; ss | count | min ----+-------+----- 4 | 1 | 64 5 | 1 | 64 6 | 1 | 64 7 | 1 | 64 8 | 1 | 64 9 | 1 | 64 10 | 1 | 64 11 | 1 | 64 12 | 1 | 64 select ss, count(*), min(f1) from edges where f1 = 65 group by 1 order by 1; ss | count | min ----+-------+----- 5 | 1 | 65 6 | 1 | 65 7 | 1 | 65 8 | 1 | 65 9 | 1 | 65 10 | 1 | 65 11 | 1 | 65 12 | 1 | 65 reset max_parallel_workers_per_gather; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_groupagg.out����������������������������������������0000664�0000000�0000000�00000015507�15100345067�0024211�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Check that the vectorized aggregation works properly in the GroupAggregate -- mode. \pset null $ set max_parallel_workers_per_gather = 0; set enable_hashagg to off; --set timescaledb.enable_vectorized_aggregation to off; --set timescaledb.debug_require_vector_agg to 'forbid'; create table groupagg(t int, s int, value int); select create_hypertable('groupagg', 't', chunk_time_interval => 10000); create_hypertable ----------------------- (1,public,groupagg,t) insert into groupagg select xslow * 10, case when xfast = 13 then null else xfast end, xfast * 7 + xslow * 3 from generate_series(10, 99) xfast, generate_series(1, 1487) xslow ; alter table groupagg set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 's'); select count(compress_chunk(x)) from show_chunks('groupagg') x; count ------- 2 vacuum analyze groupagg; set timescaledb.debug_require_vector_agg to 'require'; select s, sum(value) from groupagg group by s order by s limit 10; s | sum ----+--------- 10 | 3423074 11 | 3433483 12 | 3443892 14 | 3464710 15 | 3475119 16 | 3485528 17 | 3495937 18 | 3506346 19 | 3516755 20 | 3527164 -- The hash grouping policies do not support the GroupAggregate mode in the -- reverse order. set timescaledb.debug_require_vector_agg to 'forbid'; select s, sum(value) from groupagg group by s order by s desc limit 10; s | sum ----+--------- $ | 3454301 99 | 4349475 98 | 4339066 97 | 4328657 96 | 4318248 95 | 4307839 94 | 4297430 93 | 4287021 92 | 4276612 91 | 4266203 reset timescaledb.debug_require_vector_agg; -- Also test the NULLS FIRST order. select count(decompress_chunk(x)) from show_chunks('groupagg') x; count ------- 2 alter table groupagg set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 's nulls first'); select count(compress_chunk(x)) from show_chunks('groupagg') x; count ------- 2 vacuum analyze groupagg; set timescaledb.debug_require_vector_agg to 'require'; select s, sum(value) from groupagg group by s order by s nulls first limit 10; s | sum ----+--------- $ | 3454301 10 | 3423074 11 | 3433483 12 | 3443892 14 | 3464710 15 | 3475119 16 | 3485528 17 | 3495937 18 | 3506346 19 | 3516755 reset timescaledb.debug_require_vector_agg; -- More tests for dictionary encoding. create table text_table(ts int, a text); select create_hypertable('text_table', 'ts', chunk_time_interval => 3); create_hypertable ------------------------- (3,public,text_table,t) alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = 'a'); insert into text_table select -1, 'scalar' from generate_series(1, 1000) x; select count(compress_chunk(x)) from show_chunks('text_table') x; count ------- 1 insert into text_table select 1, '' from generate_series(1, 1000) x; insert into text_table select 2, 'same' from generate_series(1, 1000) x; insert into text_table select 3, 'different' || x from generate_series(1, 1000) x; insert into text_table select 4, case when x % 2 = 0 then null else 'samewithnulls' end from generate_series(1, 1000) x; insert into text_table select 5, case when x % 2 = 0 then null else 'differentwithnulls' || x end from generate_series(1, 1000) x; alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'a'); select count(compress_chunk(x)) from show_chunks('text_table') x; NOTICE: chunk "_hyper_3_7_chunk" is already converted to columnstore count ------- 3 vacuum analyze text_table; set timescaledb.debug_require_vector_agg to 'require'; select a, count(*) from text_table group by a order by count(*) desc, a limit 10; a | count ---------------+------- | 1000 same | 1000 scalar | 1000 $ | 1000 samewithnulls | 500 different1 | 1 different10 | 1 different100 | 1 different1000 | 1 different101 | 1 -- The hash grouping policies do not support the GroupAggregate mode in the -- reverse order. We have to filter out the chunk where 'a' is segmentby. set timescaledb.debug_require_vector_agg to 'forbid'; select a, count(*) from text_table where ts >= 0 group by a order by a desc limit 10; a | count -----------------------+------- $ | 1000 samewithnulls | 500 same | 1000 differentwithnulls999 | 1 differentwithnulls997 | 1 differentwithnulls995 | 1 differentwithnulls993 | 1 differentwithnulls991 | 1 differentwithnulls99 | 1 differentwithnulls989 | 1 reset timescaledb.debug_require_vector_agg; reset enable_sort; -- with NULLS FIRST select count(decompress_chunk(x)) from show_chunks('text_table') x; count ------- 3 alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'a nulls first'); select count(compress_chunk(x)) from show_chunks('text_table') x; count ------- 3 set timescaledb.debug_require_vector_agg to 'require'; select a, count(*) from text_table group by a order by a nulls first limit 10; a | count ---------------+------- $ | 1000 | 1000 different1 | 1 different10 | 1 different100 | 1 different1000 | 1 different101 | 1 different102 | 1 different103 | 1 different104 | 1 reset timescaledb.debug_require_vector_agg; -- TODO verify that this works with the serialized hash grouping strategy set timescaledb.debug_require_vector_agg to 'forbid'; select ts, a, count(*) from text_table group by ts, a order by ts, a limit 10; ts | a | count ----+---------------+------- -1 | scalar | 1000 1 | | 1000 2 | same | 1000 3 | different1 | 1 3 | different10 | 1 3 | different100 | 1 3 | different1000 | 1 3 | different101 | 1 3 | different102 | 1 3 | different103 | 1 select a, ts, count(*) from text_table group by a, ts order by a desc, ts desc limit 10; a | ts | count -----------------------+----+------- $ | 5 | 500 $ | 4 | 500 scalar | -1 | 1000 samewithnulls | 4 | 500 same | 2 | 1000 differentwithnulls999 | 5 | 1 differentwithnulls997 | 5 | 1 differentwithnulls995 | 5 | 1 differentwithnulls993 | 5 | 1 differentwithnulls991 | 5 | 1 reset timescaledb.debug_require_vector_agg; reset max_parallel_workers_per_gather; reset timescaledb.debug_require_vector_agg; reset enable_hashagg; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_grouping.out����������������������������������������0000664�0000000�0000000�00000162722�15100345067�0024232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; -- To not confuse null with empty strings in the test reference \pset null $ \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table agggroup(t int, s int, cint2 int2, cint4 int4, cint8 int8); select create_hypertable('agggroup', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create_hypertable ----------------------- (1,public,agggroup,t) create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, (mix(s + t * 1021) * 32767)::int4 as cint4, (mix(s + t * 1031) * 32767)::int8 as cint8 from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into agggroup select * from source where s = 1; alter table agggroup set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('agggroup') x; count ------- 1 alter table agggroup add column ss int default 11; alter table agggroup add column x text default '11'; insert into agggroup select *, ss::text as x from ( select *, case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1051 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss from source where s != 1 ) t ; select count(compress_chunk(x)) from show_chunks('agggroup') x; count ------- 2 vacuum freeze analyze agggroup; set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. Note that there are minor discrepancies -- on float4 due to different numeric stability in our and PG implementations. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select format('%sselect %s%s(%s) from agggroup%s%s%s;', explain, grouping || ', ', function, variable, ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 'cint2', '*']) variable, unnest(array[ 'min', 'count']) function, unnest(array[ null, 'cint2 > 0', 'cint2 is null', 'cint2 is null and x is null']) with ordinality as condition(condition, n), unnest(array[ 'cint4, cint2', 'cint4, cint8', 'cint2, cint4, cint8', 's, cint2', 's, ss', 's, x', 'ss, cint2, x', 'ss, s', 'ss, x, cint2', 't, s, ss, x, cint4, cint8, cint2', 'x']) with ordinality as grouping(grouping, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') order by explain, condition.n, variable, function, grouping.n \gexec select cint4, cint2, count(*) from agggroup group by cint4, cint2 order by count(*), cint4, cint2 limit 10; cint4 | cint2 | count --------+--------+------- -16383 | -4883 | 1 -16383 | -1995 | 1 -16383 | 607 | 1 -16382 | -12462 | 1 -16382 | -10682 | 1 -16382 | -10538 | 1 -16382 | -10164 | 1 -16382 | -6061 | 1 -16382 | -4558 | 1 -16382 | -3173 | 1 select cint4, cint8, count(*) from agggroup group by cint4, cint8 order by count(*), cint4, cint8 limit 10; cint4 | cint8 | count --------+-------+------- -16383 | 4889 | 1 -16383 | 7417 | 1 -16383 | 8953 | 1 -16382 | -8851 | 1 -16382 | -8612 | 1 -16382 | -5254 | 1 -16382 | -4489 | 1 -16382 | -470 | 1 -16382 | 411 | 1 -16382 | 899 | 1 select cint2, cint4, cint8, count(*) from agggroup group by cint2, cint4, cint8 order by count(*), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count --------+--------+--------+------- -16383 | -16190 | 13646 | 1 -16383 | -13372 | 11094 | 1 -16383 | -10318 | 6326 | 1 -16383 | -9008 | 4390 | 1 -16383 | -3043 | -1794 | 1 -16383 | 6729 | 6717 | 1 -16382 | -14012 | -9888 | 1 -16382 | -8606 | -10357 | 1 -16382 | -3080 | -15609 | 1 -16382 | 2223 | 9035 | 1 select s, cint2, count(*) from agggroup group by s, cint2 order by count(*), s, cint2 limit 10; s | cint2 | count ---+--------+------- 0 | -16377 | 1 0 | -16376 | 1 0 | -16375 | 1 0 | -16373 | 1 0 | -16372 | 1 0 | -16371 | 1 0 | -16370 | 1 0 | -16369 | 1 0 | -16368 | 1 0 | -16367 | 1 select s, ss, count(*) from agggroup group by s, ss order by count(*), s, ss limit 10; s | ss | count ---+----+------- 3 | $ | 19 4 | 11 | 19 3 | 3 | 19981 4 | 4 | 19981 0 | 0 | 20000 1 | 11 | 20000 2 | $ | 20000 5 | 5 | 20000 6 | 6 | 20000 7 | 7 | 20000 select s, x, count(*) from agggroup group by s, x order by count(*), s, x limit 10; s | x | count ---+----+------- 3 | $ | 19 4 | 11 | 19 3 | 3 | 19981 4 | 4 | 19981 0 | 0 | 20000 1 | 11 | 20000 2 | $ | 20000 5 | 5 | 20000 6 | 6 | 20000 7 | 7 | 20000 select ss, cint2, x, count(*) from agggroup group by ss, cint2, x order by count(*), ss, cint2, x limit 10; ss | cint2 | x | count ----+--------+---+------- 0 | -16377 | 0 | 1 0 | -16376 | 0 | 1 0 | -16375 | 0 | 1 0 | -16373 | 0 | 1 0 | -16372 | 0 | 1 0 | -16371 | 0 | 1 0 | -16370 | 0 | 1 0 | -16369 | 0 | 1 0 | -16368 | 0 | 1 0 | -16367 | 0 | 1 select ss, s, count(*) from agggroup group by ss, s order by count(*), ss, s limit 10; ss | s | count ----+---+------- 11 | 4 | 19 $ | 3 | 19 3 | 3 | 19981 4 | 4 | 19981 0 | 0 | 20000 5 | 5 | 20000 6 | 6 | 20000 7 | 7 | 20000 8 | 8 | 20000 9 | 9 | 20000 select ss, x, cint2, count(*) from agggroup group by ss, x, cint2 order by count(*), ss, x, cint2 limit 10; ss | x | cint2 | count ----+---+--------+------- 0 | 0 | -16377 | 1 0 | 0 | -16376 | 1 0 | 0 | -16375 | 1 0 | 0 | -16373 | 1 0 | 0 | -16372 | 1 0 | 0 | -16371 | 1 0 | 0 | -16370 | 1 0 | 0 | -16369 | 1 0 | 0 | -16368 | 1 0 | 0 | -16367 | 1 select t, s, ss, x, cint4, cint8, cint2, count(*) from agggroup group by t, s, ss, x, cint4, cint8, cint2 order by count(*), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count ----+---+----+---+--------+-------+--------+------- 1 | 0 | 0 | 0 | -15736 | 12910 | 3398 | 1 2 | 0 | 0 | 0 | 1096 | -6638 | -5373 | 1 3 | 0 | 0 | 0 | -15920 | 13672 | -7109 | 1 4 | 0 | 0 | 0 | 14299 | -8187 | -4927 | 1 5 | 0 | 0 | 0 | 9267 | 6436 | 4859 | 1 6 | 0 | 0 | 0 | -5203 | 9870 | 12177 | 1 7 | 0 | 0 | 0 | 6620 | -781 | 5174 | 1 8 | 0 | 0 | 0 | -10427 | 876 | -12705 | 1 9 | 0 | 0 | 0 | -14954 | -1593 | 2257 | 1 10 | 0 | 0 | 0 | 10047 | -7626 | 3923 | 1 select x, count(*) from agggroup group by x order by count(*), x limit 10; x | count ----+------- 3 | 19981 4 | 19981 0 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 11 | 20019 $ | 20019 select cint4, cint2, count(cint2) from agggroup group by cint4, cint2 order by count(cint2), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -16291 | $ | 0 -16091 | $ | 0 -15799 | $ | 0 -15724 | $ | 0 -15328 | $ | 0 -15279 | $ | 0 -15063 | $ | 0 -14998 | $ | 0 -14949 | $ | 0 -14848 | $ | 0 select cint4, cint8, count(cint2) from agggroup group by cint4, cint8 order by count(cint2), cint4, cint8 limit 10; cint4 | cint8 | count --------+--------+------- -16291 | 113 | 0 -16091 | -4084 | 0 -15799 | 12603 | 0 -15724 | 15426 | 0 -15328 | -6092 | 0 -15279 | -3475 | 0 -15063 | 3990 | 0 -14998 | 14464 | 0 -14949 | -10395 | 0 -14848 | 3110 | 0 select cint2, cint4, cint8, count(cint2) from agggroup group by cint2, cint4, cint8 order by count(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- $ | -16291 | 113 | 0 $ | -16091 | -4084 | 0 $ | -15799 | 12603 | 0 $ | -15724 | 15426 | 0 $ | -15328 | -6092 | 0 $ | -15279 | -3475 | 0 $ | -15063 | 3990 | 0 $ | -14998 | 14464 | 0 $ | -14949 | -10395 | 0 $ | -14848 | 3110 | 0 select s, cint2, count(cint2) from agggroup group by s, cint2 order by count(cint2), s, cint2 limit 10; s | cint2 | count ---+-------+------- 0 | $ | 0 1 | $ | 0 2 | $ | 0 3 | $ | 0 4 | $ | 0 5 | $ | 0 6 | $ | 0 7 | $ | 0 8 | $ | 0 9 | $ | 0 select s, ss, count(cint2) from agggroup group by s, ss order by count(cint2), s, ss limit 10; s | ss | count ---+----+------- 3 | $ | 19 4 | 11 | 19 3 | 3 | 19962 4 | 4 | 19962 0 | 0 | 19981 1 | 11 | 19981 2 | $ | 19981 5 | 5 | 19981 6 | 6 | 19981 7 | 7 | 19981 select s, x, count(cint2) from agggroup group by s, x order by count(cint2), s, x limit 10; s | x | count ---+----+------- 3 | $ | 19 4 | 11 | 19 3 | 3 | 19962 4 | 4 | 19962 0 | 0 | 19981 1 | 11 | 19981 2 | $ | 19981 5 | 5 | 19981 6 | 6 | 19981 7 | 7 | 19981 select ss, cint2, x, count(cint2) from agggroup group by ss, cint2, x order by count(cint2), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+----+------- 0 | $ | 0 | 0 3 | $ | 3 | 0 4 | $ | 4 | 0 5 | $ | 5 | 0 6 | $ | 6 | 0 7 | $ | 7 | 0 8 | $ | 8 | 0 9 | $ | 9 | 0 11 | $ | 11 | 0 $ | $ | $ | 0 select ss, s, count(cint2) from agggroup group by ss, s order by count(cint2), ss, s limit 10; ss | s | count ----+---+------- 11 | 4 | 19 $ | 3 | 19 3 | 3 | 19962 4 | 4 | 19962 0 | 0 | 19981 5 | 5 | 19981 6 | 6 | 19981 7 | 7 | 19981 8 | 8 | 19981 9 | 9 | 19981 select ss, x, cint2, count(cint2) from agggroup group by ss, x, cint2 order by count(cint2), ss, x, cint2 limit 10; ss | x | cint2 | count ----+----+-------+------- 0 | 0 | $ | 0 3 | 3 | $ | 0 4 | 4 | $ | 0 5 | 5 | $ | 0 6 | 6 | $ | 0 7 | 7 | $ | 0 8 | 8 | $ | 0 9 | 9 | $ | 0 11 | 11 | $ | 0 $ | $ | $ | 0 select t, s, ss, x, cint4, cint8, cint2, count(cint2) from agggroup group by t, s, ss, x, cint4, cint8, cint2 order by count(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count -------+---+----+---+--------+--------+-------+------- 1051 | 0 | 0 | 0 | -8612 | 14327 | $ | 0 2102 | 0 | 0 | 0 | 11069 | 16047 | $ | 0 3153 | 0 | 0 | 0 | 6192 | 12700 | $ | 0 4204 | 0 | 0 | 0 | 4165 | -10102 | $ | 0 5255 | 0 | 0 | 0 | 16314 | 13418 | $ | 0 6306 | 0 | 0 | 0 | 701 | -3029 | $ | 0 7357 | 0 | 0 | 0 | 1115 | 4913 | $ | 0 8408 | 0 | 0 | 0 | 15553 | 1743 | $ | 0 9459 | 0 | 0 | 0 | -14640 | 11933 | $ | 0 10510 | 0 | 0 | 0 | -14725 | 6531 | $ | 0 select x, count(cint2) from agggroup group by x order by count(cint2), x limit 10; x | count ----+------- 3 | 19962 4 | 19962 0 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 11 | 20000 $ | 20000 select cint4, cint2, min(cint2) from agggroup group by cint4, cint2 order by min(cint2), cint4, cint2 limit 10; cint4 | cint2 | min --------+--------+-------- -16190 | -16383 | -16383 -13372 | -16383 | -16383 -10318 | -16383 | -16383 -9008 | -16383 | -16383 -3043 | -16383 | -16383 6729 | -16383 | -16383 -14012 | -16382 | -16382 -8606 | -16382 | -16382 -3080 | -16382 | -16382 2223 | -16382 | -16382 select cint4, cint8, min(cint2) from agggroup group by cint4, cint8 order by min(cint2), cint4, cint8 limit 10; cint4 | cint8 | min --------+--------+-------- -16190 | 13646 | -16383 -13372 | 11094 | -16383 -10318 | 6326 | -16383 -9008 | 4390 | -16383 -3043 | -1794 | -16383 6729 | 6717 | -16383 -14012 | -9888 | -16382 -8606 | -10357 | -16382 -3080 | -15609 | -16382 2223 | 9035 | -16382 select cint2, cint4, cint8, min(cint2) from agggroup group by cint2, cint4, cint8 order by min(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | min --------+--------+--------+-------- -16383 | -16190 | 13646 | -16383 -16383 | -13372 | 11094 | -16383 -16383 | -10318 | 6326 | -16383 -16383 | -9008 | 4390 | -16383 -16383 | -3043 | -1794 | -16383 -16383 | 6729 | 6717 | -16383 -16382 | -14012 | -9888 | -16382 -16382 | -8606 | -10357 | -16382 -16382 | -3080 | -15609 | -16382 -16382 | 2223 | 9035 | -16382 select s, cint2, min(cint2) from agggroup group by s, cint2 order by min(cint2), s, cint2 limit 10; s | cint2 | min ---+--------+-------- 0 | -16383 | -16383 4 | -16383 | -16383 5 | -16383 | -16383 6 | -16383 | -16383 2 | -16382 | -16382 7 | -16382 | -16382 8 | -16382 | -16382 2 | -16381 | -16381 3 | -16381 | -16381 4 | -16381 | -16381 select s, ss, min(cint2) from agggroup group by s, ss order by min(cint2), s, ss limit 10; s | ss | min ---+----+-------- 0 | 0 | -16383 4 | 4 | -16383 5 | 5 | -16383 6 | 6 | -16383 2 | $ | -16382 7 | 7 | -16382 8 | 8 | -16382 3 | 3 | -16381 1 | 11 | -16378 9 | 9 | -16375 select s, x, min(cint2) from agggroup group by s, x order by min(cint2), s, x limit 10; s | x | min ---+----+-------- 0 | 0 | -16383 4 | 4 | -16383 5 | 5 | -16383 6 | 6 | -16383 2 | $ | -16382 7 | 7 | -16382 8 | 8 | -16382 3 | 3 | -16381 1 | 11 | -16378 9 | 9 | -16375 select ss, cint2, x, min(cint2) from agggroup group by ss, cint2, x order by min(cint2), ss, cint2, x limit 10; ss | cint2 | x | min ----+--------+---+-------- 0 | -16383 | 0 | -16383 4 | -16383 | 4 | -16383 5 | -16383 | 5 | -16383 6 | -16383 | 6 | -16383 7 | -16382 | 7 | -16382 8 | -16382 | 8 | -16382 $ | -16382 | $ | -16382 3 | -16381 | 3 | -16381 4 | -16381 | 4 | -16381 5 | -16381 | 5 | -16381 select ss, s, min(cint2) from agggroup group by ss, s order by min(cint2), ss, s limit 10; ss | s | min ----+---+-------- 0 | 0 | -16383 4 | 4 | -16383 5 | 5 | -16383 6 | 6 | -16383 7 | 7 | -16382 8 | 8 | -16382 $ | 2 | -16382 3 | 3 | -16381 11 | 1 | -16378 9 | 9 | -16375 select ss, x, cint2, min(cint2) from agggroup group by ss, x, cint2 order by min(cint2), ss, x, cint2 limit 10; ss | x | cint2 | min ----+---+--------+-------- 0 | 0 | -16383 | -16383 4 | 4 | -16383 | -16383 5 | 5 | -16383 | -16383 6 | 6 | -16383 | -16383 7 | 7 | -16382 | -16382 8 | 8 | -16382 | -16382 $ | $ | -16382 | -16382 3 | 3 | -16381 | -16381 4 | 4 | -16381 | -16381 5 | 5 | -16381 | -16381 select t, s, ss, x, cint4, cint8, cint2, min(cint2) from agggroup group by t, s, ss, x, cint4, cint8, cint2 order by min(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | min -------+---+----+---+--------+--------+--------+-------- 6194 | 0 | 0 | 0 | -13372 | 11094 | -16383 | -16383 17044 | 0 | 0 | 0 | -10318 | 6326 | -16383 | -16383 53843 | 4 | 4 | 4 | -9008 | 4390 | -16383 | -16383 60530 | 5 | 5 | 5 | 6729 | 6717 | -16383 | -16383 73208 | 6 | 6 | 6 | -3043 | -1794 | -16383 | -16383 74870 | 6 | 6 | 6 | -16190 | 13646 | -16383 | -16383 22836 | 2 | $ | $ | -3080 | -15609 | -16382 | -16382 29858 | 2 | $ | $ | -14012 | -9888 | -16382 | -16382 31516 | 2 | $ | $ | 6193 | 206 | -16382 | -16382 76781 | 7 | 7 | 7 | 9938 | 6519 | -16382 | -16382 select x, min(cint2) from agggroup group by x order by min(cint2), x limit 10; x | min ----+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 7 | -16382 8 | -16382 $ | -16382 3 | -16381 11 | -16378 9 | -16375 select cint4, cint2, count(*) from agggroup where cint2 > 0 group by cint4, cint2 order by count(*), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -16383 | 607 | 1 -16382 | 94 | 1 -16382 | 569 | 1 -16382 | 1891 | 1 -16382 | 4679 | 1 -16382 | 10118 | 1 -16382 | 14467 | 1 -16382 | 15369 | 1 -16380 | 448 | 1 -16379 | 390 | 1 select cint4, cint8, count(*) from agggroup where cint2 > 0 group by cint4, cint8 order by count(*), cint4, cint8 limit 10; cint4 | cint8 | count --------+-------+------- -16383 | 4889 | 1 -16382 | -8851 | 1 -16382 | -4489 | 1 -16382 | -470 | 1 -16382 | 411 | 1 -16382 | 8377 | 1 -16382 | 8832 | 1 -16382 | 15709 | 1 -16380 | 1449 | 1 -16379 | 1234 | 1 select cint2, cint4, cint8, count(*) from agggroup where cint2 > 0 group by cint2, cint4, cint8 order by count(*), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- 1 | -12025 | -2210 | 1 1 | -10344 | -13684 | 1 1 | -4190 | -2827 | 1 1 | -1493 | -1043 | 1 1 | 1863 | 7650 | 1 1 | 9242 | -9798 | 1 1 | 11189 | -5168 | 1 1 | 14078 | 9929 | 1 1 | 15656 | 12597 | 1 2 | -11410 | 6033 | 1 select s, cint2, count(*) from agggroup where cint2 > 0 group by s, cint2 order by count(*), s, cint2 limit 10; s | cint2 | count ---+-------+------- 0 | 4 | 1 0 | 7 | 1 0 | 8 | 1 0 | 9 | 1 0 | 10 | 1 0 | 11 | 1 0 | 18 | 1 0 | 24 | 1 0 | 28 | 1 0 | 31 | 1 select s, ss, count(*) from agggroup where cint2 > 0 group by s, ss order by count(*), s, ss limit 10; s | ss | count ---+----+------- 3 | $ | 9 4 | 11 | 9 2 | $ | 9868 3 | 3 | 9884 6 | 6 | 9890 4 | 4 | 9897 8 | 8 | 9898 7 | 7 | 9973 0 | 0 | 10012 9 | 9 | 10018 select s, x, count(*) from agggroup where cint2 > 0 group by s, x order by count(*), s, x limit 10; s | x | count ---+----+------- 3 | $ | 9 4 | 11 | 9 2 | $ | 9868 3 | 3 | 9884 6 | 6 | 9890 4 | 4 | 9897 8 | 8 | 9898 7 | 7 | 9973 0 | 0 | 10012 9 | 9 | 10018 select ss, cint2, x, count(*) from agggroup where cint2 > 0 group by ss, cint2, x order by count(*), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+---+------- 0 | 4 | 0 | 1 0 | 7 | 0 | 1 0 | 8 | 0 | 1 0 | 9 | 0 | 1 0 | 10 | 0 | 1 0 | 11 | 0 | 1 0 | 18 | 0 | 1 0 | 24 | 0 | 1 0 | 28 | 0 | 1 0 | 31 | 0 | 1 select ss, s, count(*) from agggroup where cint2 > 0 group by ss, s order by count(*), ss, s limit 10; ss | s | count ----+---+------- 11 | 4 | 9 $ | 3 | 9 $ | 2 | 9868 3 | 3 | 9884 6 | 6 | 9890 4 | 4 | 9897 8 | 8 | 9898 7 | 7 | 9973 0 | 0 | 10012 9 | 9 | 10018 select ss, x, cint2, count(*) from agggroup where cint2 > 0 group by ss, x, cint2 order by count(*), ss, x, cint2 limit 10; ss | x | cint2 | count ----+---+-------+------- 0 | 0 | 4 | 1 0 | 0 | 7 | 1 0 | 0 | 8 | 1 0 | 0 | 9 | 1 0 | 0 | 10 | 1 0 | 0 | 11 | 1 0 | 0 | 18 | 1 0 | 0 | 24 | 1 0 | 0 | 28 | 1 0 | 0 | 31 | 1 select t, s, ss, x, cint4, cint8, cint2, count(*) from agggroup where cint2 > 0 group by t, s, ss, x, cint4, cint8, cint2 order by count(*), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count ----+---+----+---+--------+-------+-------+------- 1 | 0 | 0 | 0 | -15736 | 12910 | 3398 | 1 5 | 0 | 0 | 0 | 9267 | 6436 | 4859 | 1 6 | 0 | 0 | 0 | -5203 | 9870 | 12177 | 1 7 | 0 | 0 | 0 | 6620 | -781 | 5174 | 1 9 | 0 | 0 | 0 | -14954 | -1593 | 2257 | 1 10 | 0 | 0 | 0 | 10047 | -7626 | 3923 | 1 14 | 0 | 0 | 0 | -13766 | -398 | 4669 | 1 15 | 0 | 0 | 0 | -13009 | 14045 | 15101 | 1 19 | 0 | 0 | 0 | -16257 | 4566 | 7684 | 1 22 | 0 | 0 | 0 | -6345 | -8658 | 11755 | 1 select x, count(*) from agggroup where cint2 > 0 group by x order by count(*), x limit 10; x | count ----+------- $ | 9877 3 | 9884 6 | 9890 4 | 9897 8 | 9898 7 | 9973 0 | 10012 9 | 10018 11 | 10105 5 | 10110 select cint4, cint2, count(cint2) from agggroup where cint2 > 0 group by cint4, cint2 order by count(cint2), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -16383 | 607 | 1 -16382 | 94 | 1 -16382 | 569 | 1 -16382 | 1891 | 1 -16382 | 4679 | 1 -16382 | 10118 | 1 -16382 | 14467 | 1 -16382 | 15369 | 1 -16380 | 448 | 1 -16379 | 390 | 1 select cint4, cint8, count(cint2) from agggroup where cint2 > 0 group by cint4, cint8 order by count(cint2), cint4, cint8 limit 10; cint4 | cint8 | count --------+-------+------- -16383 | 4889 | 1 -16382 | -8851 | 1 -16382 | -4489 | 1 -16382 | -470 | 1 -16382 | 411 | 1 -16382 | 8377 | 1 -16382 | 8832 | 1 -16382 | 15709 | 1 -16380 | 1449 | 1 -16379 | 1234 | 1 select cint2, cint4, cint8, count(cint2) from agggroup where cint2 > 0 group by cint2, cint4, cint8 order by count(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- 1 | -12025 | -2210 | 1 1 | -10344 | -13684 | 1 1 | -4190 | -2827 | 1 1 | -1493 | -1043 | 1 1 | 1863 | 7650 | 1 1 | 9242 | -9798 | 1 1 | 11189 | -5168 | 1 1 | 14078 | 9929 | 1 1 | 15656 | 12597 | 1 2 | -11410 | 6033 | 1 select s, cint2, count(cint2) from agggroup where cint2 > 0 group by s, cint2 order by count(cint2), s, cint2 limit 10; s | cint2 | count ---+-------+------- 0 | 4 | 1 0 | 7 | 1 0 | 8 | 1 0 | 9 | 1 0 | 10 | 1 0 | 11 | 1 0 | 18 | 1 0 | 24 | 1 0 | 28 | 1 0 | 31 | 1 select s, ss, count(cint2) from agggroup where cint2 > 0 group by s, ss order by count(cint2), s, ss limit 10; s | ss | count ---+----+------- 3 | $ | 9 4 | 11 | 9 2 | $ | 9868 3 | 3 | 9884 6 | 6 | 9890 4 | 4 | 9897 8 | 8 | 9898 7 | 7 | 9973 0 | 0 | 10012 9 | 9 | 10018 select s, x, count(cint2) from agggroup where cint2 > 0 group by s, x order by count(cint2), s, x limit 10; s | x | count ---+----+------- 3 | $ | 9 4 | 11 | 9 2 | $ | 9868 3 | 3 | 9884 6 | 6 | 9890 4 | 4 | 9897 8 | 8 | 9898 7 | 7 | 9973 0 | 0 | 10012 9 | 9 | 10018 select ss, cint2, x, count(cint2) from agggroup where cint2 > 0 group by ss, cint2, x order by count(cint2), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+---+------- 0 | 4 | 0 | 1 0 | 7 | 0 | 1 0 | 8 | 0 | 1 0 | 9 | 0 | 1 0 | 10 | 0 | 1 0 | 11 | 0 | 1 0 | 18 | 0 | 1 0 | 24 | 0 | 1 0 | 28 | 0 | 1 0 | 31 | 0 | 1 select ss, s, count(cint2) from agggroup where cint2 > 0 group by ss, s order by count(cint2), ss, s limit 10; ss | s | count ----+---+------- 11 | 4 | 9 $ | 3 | 9 $ | 2 | 9868 3 | 3 | 9884 6 | 6 | 9890 4 | 4 | 9897 8 | 8 | 9898 7 | 7 | 9973 0 | 0 | 10012 9 | 9 | 10018 select ss, x, cint2, count(cint2) from agggroup where cint2 > 0 group by ss, x, cint2 order by count(cint2), ss, x, cint2 limit 10; ss | x | cint2 | count ----+---+-------+------- 0 | 0 | 4 | 1 0 | 0 | 7 | 1 0 | 0 | 8 | 1 0 | 0 | 9 | 1 0 | 0 | 10 | 1 0 | 0 | 11 | 1 0 | 0 | 18 | 1 0 | 0 | 24 | 1 0 | 0 | 28 | 1 0 | 0 | 31 | 1 select t, s, ss, x, cint4, cint8, cint2, count(cint2) from agggroup where cint2 > 0 group by t, s, ss, x, cint4, cint8, cint2 order by count(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count ----+---+----+---+--------+-------+-------+------- 1 | 0 | 0 | 0 | -15736 | 12910 | 3398 | 1 5 | 0 | 0 | 0 | 9267 | 6436 | 4859 | 1 6 | 0 | 0 | 0 | -5203 | 9870 | 12177 | 1 7 | 0 | 0 | 0 | 6620 | -781 | 5174 | 1 9 | 0 | 0 | 0 | -14954 | -1593 | 2257 | 1 10 | 0 | 0 | 0 | 10047 | -7626 | 3923 | 1 14 | 0 | 0 | 0 | -13766 | -398 | 4669 | 1 15 | 0 | 0 | 0 | -13009 | 14045 | 15101 | 1 19 | 0 | 0 | 0 | -16257 | 4566 | 7684 | 1 22 | 0 | 0 | 0 | -6345 | -8658 | 11755 | 1 select x, count(cint2) from agggroup where cint2 > 0 group by x order by count(cint2), x limit 10; x | count ----+------- $ | 9877 3 | 9884 6 | 9890 4 | 9897 8 | 9898 7 | 9973 0 | 10012 9 | 10018 11 | 10105 5 | 10110 select cint4, cint2, min(cint2) from agggroup where cint2 > 0 group by cint4, cint2 order by min(cint2), cint4, cint2 limit 10; cint4 | cint2 | min --------+-------+----- -12025 | 1 | 1 -10344 | 1 | 1 -4190 | 1 | 1 -1493 | 1 | 1 1863 | 1 | 1 9242 | 1 | 1 11189 | 1 | 1 14078 | 1 | 1 15656 | 1 | 1 -11410 | 2 | 2 select cint4, cint8, min(cint2) from agggroup where cint2 > 0 group by cint4, cint8 order by min(cint2), cint4, cint8 limit 10; cint4 | cint8 | min --------+--------+----- -12025 | -2210 | 1 -10344 | -13684 | 1 -4190 | -2827 | 1 -1493 | -1043 | 1 1863 | 7650 | 1 9242 | -9798 | 1 11189 | -5168 | 1 14078 | 9929 | 1 15656 | 12597 | 1 -11410 | 6033 | 2 select cint2, cint4, cint8, min(cint2) from agggroup where cint2 > 0 group by cint2, cint4, cint8 order by min(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | min -------+--------+--------+----- 1 | -12025 | -2210 | 1 1 | -10344 | -13684 | 1 1 | -4190 | -2827 | 1 1 | -1493 | -1043 | 1 1 | 1863 | 7650 | 1 1 | 9242 | -9798 | 1 1 | 11189 | -5168 | 1 1 | 14078 | 9929 | 1 1 | 15656 | 12597 | 1 2 | -11410 | 6033 | 2 select s, cint2, min(cint2) from agggroup where cint2 > 0 group by s, cint2 order by min(cint2), s, cint2 limit 10; s | cint2 | min ---+-------+----- 1 | 1 | 1 2 | 1 | 1 3 | 1 | 1 5 | 1 | 1 7 | 1 | 1 8 | 1 | 1 1 | 2 | 2 3 | 2 | 2 7 | 2 | 2 9 | 2 | 2 select s, ss, min(cint2) from agggroup where cint2 > 0 group by s, ss order by min(cint2), s, ss limit 10; s | ss | min ---+----+----- 1 | 11 | 1 2 | $ | 1 3 | 3 | 1 5 | 5 | 1 7 | 7 | 1 8 | 8 | 1 9 | 9 | 2 6 | 6 | 3 0 | 0 | 4 4 | 4 | 4 select s, x, min(cint2) from agggroup where cint2 > 0 group by s, x order by min(cint2), s, x limit 10; s | x | min ---+----+----- 1 | 11 | 1 2 | $ | 1 3 | 3 | 1 5 | 5 | 1 7 | 7 | 1 8 | 8 | 1 9 | 9 | 2 6 | 6 | 3 0 | 0 | 4 4 | 4 | 4 select ss, cint2, x, min(cint2) from agggroup where cint2 > 0 group by ss, cint2, x order by min(cint2), ss, cint2, x limit 10; ss | cint2 | x | min ----+-------+----+----- 3 | 1 | 3 | 1 5 | 1 | 5 | 1 7 | 1 | 7 | 1 8 | 1 | 8 | 1 11 | 1 | 11 | 1 $ | 1 | $ | 1 3 | 2 | 3 | 2 7 | 2 | 7 | 2 9 | 2 | 9 | 2 11 | 2 | 11 | 2 select ss, s, min(cint2) from agggroup where cint2 > 0 group by ss, s order by min(cint2), ss, s limit 10; ss | s | min ----+---+----- 3 | 3 | 1 5 | 5 | 1 7 | 7 | 1 8 | 8 | 1 11 | 1 | 1 $ | 2 | 1 9 | 9 | 2 6 | 6 | 3 0 | 0 | 4 4 | 4 | 4 select ss, x, cint2, min(cint2) from agggroup where cint2 > 0 group by ss, x, cint2 order by min(cint2), ss, x, cint2 limit 10; ss | x | cint2 | min ----+----+-------+----- 3 | 3 | 1 | 1 5 | 5 | 1 | 1 7 | 7 | 1 | 1 8 | 8 | 1 | 1 11 | 11 | 1 | 1 $ | $ | 1 | 1 3 | 3 | 2 | 2 7 | 7 | 2 | 2 9 | 9 | 2 | 2 11 | 11 | 2 | 2 select t, s, ss, x, cint4, cint8, cint2, min(cint2) from agggroup where cint2 > 0 group by t, s, ss, x, cint4, cint8, cint2 order by min(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | min -------+---+----+----+--------+--------+-------+----- 11611 | 1 | 11 | 11 | -12025 | -2210 | 1 | 1 28649 | 2 | $ | $ | -1493 | -1043 | 1 | 1 28786 | 1 | 11 | 11 | -4190 | -2827 | 1 | 1 41774 | 3 | 3 | 3 | 1863 | 7650 | 1 | 1 41779 | 3 | 3 | 3 | 14078 | 9929 | 1 | 1 51152 | 5 | 5 | 5 | 9242 | -9798 | 1 | 1 70932 | 7 | 7 | 7 | -10344 | -13684 | 1 | 1 86957 | 7 | 7 | 7 | 15656 | 12597 | 1 | 1 89689 | 8 | 8 | 8 | 11189 | -5168 | 1 | 1 22147 | 1 | 11 | 11 | -9569 | 9760 | 2 | 2 select x, min(cint2) from agggroup where cint2 > 0 group by x order by min(cint2), x limit 10; x | min ----+----- 11 | 1 3 | 1 5 | 1 7 | 1 8 | 1 $ | 1 9 | 2 6 | 3 0 | 4 4 | 4 select cint4, cint2, count(*) from agggroup where cint2 is null group by cint4, cint2 order by count(*), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -16291 | $ | 1 -16091 | $ | 1 -15799 | $ | 1 -15724 | $ | 1 -15328 | $ | 1 -15279 | $ | 1 -15063 | $ | 1 -14998 | $ | 1 -14949 | $ | 1 -14848 | $ | 1 select cint4, cint8, count(*) from agggroup where cint2 is null group by cint4, cint8 order by count(*), cint4, cint8 limit 10; cint4 | cint8 | count --------+--------+------- -16291 | 113 | 1 -16091 | -4084 | 1 -15799 | 12603 | 1 -15724 | 15426 | 1 -15328 | -6092 | 1 -15279 | -3475 | 1 -15063 | 3990 | 1 -14998 | 14464 | 1 -14949 | -10395 | 1 -14848 | 3110 | 1 select cint2, cint4, cint8, count(*) from agggroup where cint2 is null group by cint2, cint4, cint8 order by count(*), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- $ | -16291 | 113 | 1 $ | -16091 | -4084 | 1 $ | -15799 | 12603 | 1 $ | -15724 | 15426 | 1 $ | -15328 | -6092 | 1 $ | -15279 | -3475 | 1 $ | -15063 | 3990 | 1 $ | -14998 | 14464 | 1 $ | -14949 | -10395 | 1 $ | -14848 | 3110 | 1 select s, cint2, count(*) from agggroup where cint2 is null group by s, cint2 order by count(*), s, cint2 limit 10; s | cint2 | count ---+-------+------- 0 | $ | 19 1 | $ | 19 2 | $ | 19 3 | $ | 19 4 | $ | 19 5 | $ | 19 6 | $ | 19 7 | $ | 19 8 | $ | 19 9 | $ | 19 select s, ss, count(*) from agggroup where cint2 is null group by s, ss order by count(*), s, ss limit 10; s | ss | count ---+----+------- 0 | 0 | 19 1 | 11 | 19 2 | $ | 19 3 | 3 | 19 4 | 4 | 19 5 | 5 | 19 6 | 6 | 19 7 | 7 | 19 8 | 8 | 19 9 | 9 | 19 select s, x, count(*) from agggroup where cint2 is null group by s, x order by count(*), s, x limit 10; s | x | count ---+----+------- 0 | 0 | 19 1 | 11 | 19 2 | $ | 19 3 | 3 | 19 4 | 4 | 19 5 | 5 | 19 6 | 6 | 19 7 | 7 | 19 8 | 8 | 19 9 | 9 | 19 select ss, cint2, x, count(*) from agggroup where cint2 is null group by ss, cint2, x order by count(*), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+----+------- 0 | $ | 0 | 19 3 | $ | 3 | 19 4 | $ | 4 | 19 5 | $ | 5 | 19 6 | $ | 6 | 19 7 | $ | 7 | 19 8 | $ | 8 | 19 9 | $ | 9 | 19 11 | $ | 11 | 19 $ | $ | $ | 19 select ss, s, count(*) from agggroup where cint2 is null group by ss, s order by count(*), ss, s limit 10; ss | s | count ----+---+------- 0 | 0 | 19 3 | 3 | 19 4 | 4 | 19 5 | 5 | 19 6 | 6 | 19 7 | 7 | 19 8 | 8 | 19 9 | 9 | 19 11 | 1 | 19 $ | 2 | 19 select ss, x, cint2, count(*) from agggroup where cint2 is null group by ss, x, cint2 order by count(*), ss, x, cint2 limit 10; ss | x | cint2 | count ----+----+-------+------- 0 | 0 | $ | 19 3 | 3 | $ | 19 4 | 4 | $ | 19 5 | 5 | $ | 19 6 | 6 | $ | 19 7 | 7 | $ | 19 8 | 8 | $ | 19 9 | 9 | $ | 19 11 | 11 | $ | 19 $ | $ | $ | 19 select t, s, ss, x, cint4, cint8, cint2, count(*) from agggroup where cint2 is null group by t, s, ss, x, cint4, cint8, cint2 order by count(*), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count -------+---+----+---+--------+--------+-------+------- 1051 | 0 | 0 | 0 | -8612 | 14327 | $ | 1 2102 | 0 | 0 | 0 | 11069 | 16047 | $ | 1 3153 | 0 | 0 | 0 | 6192 | 12700 | $ | 1 4204 | 0 | 0 | 0 | 4165 | -10102 | $ | 1 5255 | 0 | 0 | 0 | 16314 | 13418 | $ | 1 6306 | 0 | 0 | 0 | 701 | -3029 | $ | 1 7357 | 0 | 0 | 0 | 1115 | 4913 | $ | 1 8408 | 0 | 0 | 0 | 15553 | 1743 | $ | 1 9459 | 0 | 0 | 0 | -14640 | 11933 | $ | 1 10510 | 0 | 0 | 0 | -14725 | 6531 | $ | 1 select x, count(*) from agggroup where cint2 is null group by x order by count(*), x limit 10; x | count ----+------- 0 | 19 11 | 19 3 | 19 4 | 19 5 | 19 6 | 19 7 | 19 8 | 19 9 | 19 $ | 19 select cint4, cint2, count(cint2) from agggroup where cint2 is null group by cint4, cint2 order by count(cint2), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -16291 | $ | 0 -16091 | $ | 0 -15799 | $ | 0 -15724 | $ | 0 -15328 | $ | 0 -15279 | $ | 0 -15063 | $ | 0 -14998 | $ | 0 -14949 | $ | 0 -14848 | $ | 0 select cint4, cint8, count(cint2) from agggroup where cint2 is null group by cint4, cint8 order by count(cint2), cint4, cint8 limit 10; cint4 | cint8 | count --------+--------+------- -16291 | 113 | 0 -16091 | -4084 | 0 -15799 | 12603 | 0 -15724 | 15426 | 0 -15328 | -6092 | 0 -15279 | -3475 | 0 -15063 | 3990 | 0 -14998 | 14464 | 0 -14949 | -10395 | 0 -14848 | 3110 | 0 select cint2, cint4, cint8, count(cint2) from agggroup where cint2 is null group by cint2, cint4, cint8 order by count(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- $ | -16291 | 113 | 0 $ | -16091 | -4084 | 0 $ | -15799 | 12603 | 0 $ | -15724 | 15426 | 0 $ | -15328 | -6092 | 0 $ | -15279 | -3475 | 0 $ | -15063 | 3990 | 0 $ | -14998 | 14464 | 0 $ | -14949 | -10395 | 0 $ | -14848 | 3110 | 0 select s, cint2, count(cint2) from agggroup where cint2 is null group by s, cint2 order by count(cint2), s, cint2 limit 10; s | cint2 | count ---+-------+------- 0 | $ | 0 1 | $ | 0 2 | $ | 0 3 | $ | 0 4 | $ | 0 5 | $ | 0 6 | $ | 0 7 | $ | 0 8 | $ | 0 9 | $ | 0 select s, ss, count(cint2) from agggroup where cint2 is null group by s, ss order by count(cint2), s, ss limit 10; s | ss | count ---+----+------- 0 | 0 | 0 1 | 11 | 0 2 | $ | 0 3 | 3 | 0 4 | 4 | 0 5 | 5 | 0 6 | 6 | 0 7 | 7 | 0 8 | 8 | 0 9 | 9 | 0 select s, x, count(cint2) from agggroup where cint2 is null group by s, x order by count(cint2), s, x limit 10; s | x | count ---+----+------- 0 | 0 | 0 1 | 11 | 0 2 | $ | 0 3 | 3 | 0 4 | 4 | 0 5 | 5 | 0 6 | 6 | 0 7 | 7 | 0 8 | 8 | 0 9 | 9 | 0 select ss, cint2, x, count(cint2) from agggroup where cint2 is null group by ss, cint2, x order by count(cint2), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+----+------- 0 | $ | 0 | 0 3 | $ | 3 | 0 4 | $ | 4 | 0 5 | $ | 5 | 0 6 | $ | 6 | 0 7 | $ | 7 | 0 8 | $ | 8 | 0 9 | $ | 9 | 0 11 | $ | 11 | 0 $ | $ | $ | 0 select ss, s, count(cint2) from agggroup where cint2 is null group by ss, s order by count(cint2), ss, s limit 10; ss | s | count ----+---+------- 0 | 0 | 0 3 | 3 | 0 4 | 4 | 0 5 | 5 | 0 6 | 6 | 0 7 | 7 | 0 8 | 8 | 0 9 | 9 | 0 11 | 1 | 0 $ | 2 | 0 select ss, x, cint2, count(cint2) from agggroup where cint2 is null group by ss, x, cint2 order by count(cint2), ss, x, cint2 limit 10; ss | x | cint2 | count ----+----+-------+------- 0 | 0 | $ | 0 3 | 3 | $ | 0 4 | 4 | $ | 0 5 | 5 | $ | 0 6 | 6 | $ | 0 7 | 7 | $ | 0 8 | 8 | $ | 0 9 | 9 | $ | 0 11 | 11 | $ | 0 $ | $ | $ | 0 select t, s, ss, x, cint4, cint8, cint2, count(cint2) from agggroup where cint2 is null group by t, s, ss, x, cint4, cint8, cint2 order by count(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count -------+---+----+---+--------+--------+-------+------- 1051 | 0 | 0 | 0 | -8612 | 14327 | $ | 0 2102 | 0 | 0 | 0 | 11069 | 16047 | $ | 0 3153 | 0 | 0 | 0 | 6192 | 12700 | $ | 0 4204 | 0 | 0 | 0 | 4165 | -10102 | $ | 0 5255 | 0 | 0 | 0 | 16314 | 13418 | $ | 0 6306 | 0 | 0 | 0 | 701 | -3029 | $ | 0 7357 | 0 | 0 | 0 | 1115 | 4913 | $ | 0 8408 | 0 | 0 | 0 | 15553 | 1743 | $ | 0 9459 | 0 | 0 | 0 | -14640 | 11933 | $ | 0 10510 | 0 | 0 | 0 | -14725 | 6531 | $ | 0 select x, count(cint2) from agggroup where cint2 is null group by x order by count(cint2), x limit 10; x | count ----+------- 0 | 0 11 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 $ | 0 select cint4, cint2, min(cint2) from agggroup where cint2 is null group by cint4, cint2 order by min(cint2), cint4, cint2 limit 10; cint4 | cint2 | min --------+-------+----- -16291 | $ | $ -16091 | $ | $ -15799 | $ | $ -15724 | $ | $ -15328 | $ | $ -15279 | $ | $ -15063 | $ | $ -14998 | $ | $ -14949 | $ | $ -14848 | $ | $ select cint4, cint8, min(cint2) from agggroup where cint2 is null group by cint4, cint8 order by min(cint2), cint4, cint8 limit 10; cint4 | cint8 | min --------+--------+----- -16291 | 113 | $ -16091 | -4084 | $ -15799 | 12603 | $ -15724 | 15426 | $ -15328 | -6092 | $ -15279 | -3475 | $ -15063 | 3990 | $ -14998 | 14464 | $ -14949 | -10395 | $ -14848 | 3110 | $ select cint2, cint4, cint8, min(cint2) from agggroup where cint2 is null group by cint2, cint4, cint8 order by min(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | min -------+--------+--------+----- $ | -16291 | 113 | $ $ | -16091 | -4084 | $ $ | -15799 | 12603 | $ $ | -15724 | 15426 | $ $ | -15328 | -6092 | $ $ | -15279 | -3475 | $ $ | -15063 | 3990 | $ $ | -14998 | 14464 | $ $ | -14949 | -10395 | $ $ | -14848 | 3110 | $ select s, cint2, min(cint2) from agggroup where cint2 is null group by s, cint2 order by min(cint2), s, cint2 limit 10; s | cint2 | min ---+-------+----- 0 | $ | $ 1 | $ | $ 2 | $ | $ 3 | $ | $ 4 | $ | $ 5 | $ | $ 6 | $ | $ 7 | $ | $ 8 | $ | $ 9 | $ | $ select s, ss, min(cint2) from agggroup where cint2 is null group by s, ss order by min(cint2), s, ss limit 10; s | ss | min ---+----+----- 0 | 0 | $ 1 | 11 | $ 2 | $ | $ 3 | 3 | $ 4 | 4 | $ 5 | 5 | $ 6 | 6 | $ 7 | 7 | $ 8 | 8 | $ 9 | 9 | $ select s, x, min(cint2) from agggroup where cint2 is null group by s, x order by min(cint2), s, x limit 10; s | x | min ---+----+----- 0 | 0 | $ 1 | 11 | $ 2 | $ | $ 3 | 3 | $ 4 | 4 | $ 5 | 5 | $ 6 | 6 | $ 7 | 7 | $ 8 | 8 | $ 9 | 9 | $ select ss, cint2, x, min(cint2) from agggroup where cint2 is null group by ss, cint2, x order by min(cint2), ss, cint2, x limit 10; ss | cint2 | x | min ----+-------+----+----- 0 | $ | 0 | $ 3 | $ | 3 | $ 4 | $ | 4 | $ 5 | $ | 5 | $ 6 | $ | 6 | $ 7 | $ | 7 | $ 8 | $ | 8 | $ 9 | $ | 9 | $ 11 | $ | 11 | $ $ | $ | $ | $ select ss, s, min(cint2) from agggroup where cint2 is null group by ss, s order by min(cint2), ss, s limit 10; ss | s | min ----+---+----- 0 | 0 | $ 3 | 3 | $ 4 | 4 | $ 5 | 5 | $ 6 | 6 | $ 7 | 7 | $ 8 | 8 | $ 9 | 9 | $ 11 | 1 | $ $ | 2 | $ select ss, x, cint2, min(cint2) from agggroup where cint2 is null group by ss, x, cint2 order by min(cint2), ss, x, cint2 limit 10; ss | x | cint2 | min ----+----+-------+----- 0 | 0 | $ | $ 3 | 3 | $ | $ 4 | 4 | $ | $ 5 | 5 | $ | $ 6 | 6 | $ | $ 7 | 7 | $ | $ 8 | 8 | $ | $ 9 | 9 | $ | $ 11 | 11 | $ | $ $ | $ | $ | $ select t, s, ss, x, cint4, cint8, cint2, min(cint2) from agggroup where cint2 is null group by t, s, ss, x, cint4, cint8, cint2 order by min(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | min -------+---+----+---+--------+--------+-------+----- 1051 | 0 | 0 | 0 | -8612 | 14327 | $ | $ 2102 | 0 | 0 | 0 | 11069 | 16047 | $ | $ 3153 | 0 | 0 | 0 | 6192 | 12700 | $ | $ 4204 | 0 | 0 | 0 | 4165 | -10102 | $ | $ 5255 | 0 | 0 | 0 | 16314 | 13418 | $ | $ 6306 | 0 | 0 | 0 | 701 | -3029 | $ | $ 7357 | 0 | 0 | 0 | 1115 | 4913 | $ | $ 8408 | 0 | 0 | 0 | 15553 | 1743 | $ | $ 9459 | 0 | 0 | 0 | -14640 | 11933 | $ | $ 10510 | 0 | 0 | 0 | -14725 | 6531 | $ | $ select x, min(cint2) from agggroup where cint2 is null group by x order by min(cint2), x limit 10; x | min ----+----- 0 | $ 11 | $ 3 | $ 4 | $ 5 | $ 6 | $ 7 | $ 8 | $ 9 | $ $ | $ select cint4, cint2, count(*) from agggroup where cint2 is null and x is null group by cint4, cint2 order by count(*), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -15063 | $ | 1 -14949 | $ | 1 -14443 | $ | 1 -11240 | $ | 1 -8873 | $ | 1 -7170 | $ | 1 -4740 | $ | 1 -1217 | $ | 1 -166 | $ | 1 -119 | $ | 1 select cint4, cint8, count(*) from agggroup where cint2 is null and x is null group by cint4, cint8 order by count(*), cint4, cint8 limit 10; cint4 | cint8 | count --------+--------+------- -15063 | 3990 | 1 -14949 | -10395 | 1 -14443 | -12710 | 1 -11240 | -8825 | 1 -8873 | -12094 | 1 -7170 | 7723 | 1 -4740 | 7720 | 1 -1217 | 6383 | 1 -166 | -10858 | 1 -119 | -231 | 1 select cint2, cint4, cint8, count(*) from agggroup where cint2 is null and x is null group by cint2, cint4, cint8 order by count(*), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- $ | -15063 | 3990 | 1 $ | -14949 | -10395 | 1 $ | -14443 | -12710 | 1 $ | -11240 | -8825 | 1 $ | -8873 | -12094 | 1 $ | -7170 | 7723 | 1 $ | -4740 | 7720 | 1 $ | -1217 | 6383 | 1 $ | -166 | -10858 | 1 $ | -119 | -231 | 1 select s, cint2, count(*) from agggroup where cint2 is null and x is null group by s, cint2 order by count(*), s, cint2 limit 10; s | cint2 | count ---+-------+------- 2 | $ | 19 select s, ss, count(*) from agggroup where cint2 is null and x is null group by s, ss order by count(*), s, ss limit 10; s | ss | count ---+----+------- 2 | $ | 19 select s, x, count(*) from agggroup where cint2 is null and x is null group by s, x order by count(*), s, x limit 10; s | x | count ---+---+------- 2 | $ | 19 select ss, cint2, x, count(*) from agggroup where cint2 is null and x is null group by ss, cint2, x order by count(*), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+---+------- $ | $ | $ | 19 select ss, s, count(*) from agggroup where cint2 is null and x is null group by ss, s order by count(*), ss, s limit 10; ss | s | count ----+---+------- $ | 2 | 19 select ss, x, cint2, count(*) from agggroup where cint2 is null and x is null group by ss, x, cint2 order by count(*), ss, x, cint2 limit 10; ss | x | cint2 | count ----+---+-------+------- $ | $ | $ | 19 select t, s, ss, x, cint4, cint8, cint2, count(*) from agggroup where cint2 is null and x is null group by t, s, ss, x, cint4, cint8, cint2 order by count(*), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count -------+---+----+---+--------+--------+-------+------- 21051 | 2 | $ | $ | 14385 | -587 | $ | 1 22102 | 2 | $ | $ | 13826 | -5912 | $ | 1 23153 | 2 | $ | $ | 11182 | 4556 | $ | 1 24204 | 2 | $ | $ | -15063 | 3990 | $ | 1 25255 | 2 | $ | $ | 2876 | 5568 | $ | 1 26306 | 2 | $ | $ | -119 | -231 | $ | 1 27357 | 2 | $ | $ | 9448 | -312 | $ | 1 28408 | 2 | $ | $ | -7170 | 7723 | $ | 1 29459 | 2 | $ | $ | -14443 | -12710 | $ | 1 30510 | 2 | $ | $ | 12536 | 8350 | $ | 1 select x, count(*) from agggroup where cint2 is null and x is null group by x order by count(*), x limit 10; x | count ---+------- $ | 19 select cint4, cint2, count(cint2) from agggroup where cint2 is null and x is null group by cint4, cint2 order by count(cint2), cint4, cint2 limit 10; cint4 | cint2 | count --------+-------+------- -15063 | $ | 0 -14949 | $ | 0 -14443 | $ | 0 -11240 | $ | 0 -8873 | $ | 0 -7170 | $ | 0 -4740 | $ | 0 -1217 | $ | 0 -166 | $ | 0 -119 | $ | 0 select cint4, cint8, count(cint2) from agggroup where cint2 is null and x is null group by cint4, cint8 order by count(cint2), cint4, cint8 limit 10; cint4 | cint8 | count --------+--------+------- -15063 | 3990 | 0 -14949 | -10395 | 0 -14443 | -12710 | 0 -11240 | -8825 | 0 -8873 | -12094 | 0 -7170 | 7723 | 0 -4740 | 7720 | 0 -1217 | 6383 | 0 -166 | -10858 | 0 -119 | -231 | 0 select cint2, cint4, cint8, count(cint2) from agggroup where cint2 is null and x is null group by cint2, cint4, cint8 order by count(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | count -------+--------+--------+------- $ | -15063 | 3990 | 0 $ | -14949 | -10395 | 0 $ | -14443 | -12710 | 0 $ | -11240 | -8825 | 0 $ | -8873 | -12094 | 0 $ | -7170 | 7723 | 0 $ | -4740 | 7720 | 0 $ | -1217 | 6383 | 0 $ | -166 | -10858 | 0 $ | -119 | -231 | 0 select s, cint2, count(cint2) from agggroup where cint2 is null and x is null group by s, cint2 order by count(cint2), s, cint2 limit 10; s | cint2 | count ---+-------+------- 2 | $ | 0 select s, ss, count(cint2) from agggroup where cint2 is null and x is null group by s, ss order by count(cint2), s, ss limit 10; s | ss | count ---+----+------- 2 | $ | 0 select s, x, count(cint2) from agggroup where cint2 is null and x is null group by s, x order by count(cint2), s, x limit 10; s | x | count ---+---+------- 2 | $ | 0 select ss, cint2, x, count(cint2) from agggroup where cint2 is null and x is null group by ss, cint2, x order by count(cint2), ss, cint2, x limit 10; ss | cint2 | x | count ----+-------+---+------- $ | $ | $ | 0 select ss, s, count(cint2) from agggroup where cint2 is null and x is null group by ss, s order by count(cint2), ss, s limit 10; ss | s | count ----+---+------- $ | 2 | 0 select ss, x, cint2, count(cint2) from agggroup where cint2 is null and x is null group by ss, x, cint2 order by count(cint2), ss, x, cint2 limit 10; ss | x | cint2 | count ----+---+-------+------- $ | $ | $ | 0 select t, s, ss, x, cint4, cint8, cint2, count(cint2) from agggroup where cint2 is null and x is null group by t, s, ss, x, cint4, cint8, cint2 order by count(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | count -------+---+----+---+--------+--------+-------+------- 21051 | 2 | $ | $ | 14385 | -587 | $ | 0 22102 | 2 | $ | $ | 13826 | -5912 | $ | 0 23153 | 2 | $ | $ | 11182 | 4556 | $ | 0 24204 | 2 | $ | $ | -15063 | 3990 | $ | 0 25255 | 2 | $ | $ | 2876 | 5568 | $ | 0 26306 | 2 | $ | $ | -119 | -231 | $ | 0 27357 | 2 | $ | $ | 9448 | -312 | $ | 0 28408 | 2 | $ | $ | -7170 | 7723 | $ | 0 29459 | 2 | $ | $ | -14443 | -12710 | $ | 0 30510 | 2 | $ | $ | 12536 | 8350 | $ | 0 select x, count(cint2) from agggroup where cint2 is null and x is null group by x order by count(cint2), x limit 10; x | count ---+------- $ | 0 select cint4, cint2, min(cint2) from agggroup where cint2 is null and x is null group by cint4, cint2 order by min(cint2), cint4, cint2 limit 10; cint4 | cint2 | min --------+-------+----- -15063 | $ | $ -14949 | $ | $ -14443 | $ | $ -11240 | $ | $ -8873 | $ | $ -7170 | $ | $ -4740 | $ | $ -1217 | $ | $ -166 | $ | $ -119 | $ | $ select cint4, cint8, min(cint2) from agggroup where cint2 is null and x is null group by cint4, cint8 order by min(cint2), cint4, cint8 limit 10; cint4 | cint8 | min --------+--------+----- -15063 | 3990 | $ -14949 | -10395 | $ -14443 | -12710 | $ -11240 | -8825 | $ -8873 | -12094 | $ -7170 | 7723 | $ -4740 | 7720 | $ -1217 | 6383 | $ -166 | -10858 | $ -119 | -231 | $ select cint2, cint4, cint8, min(cint2) from agggroup where cint2 is null and x is null group by cint2, cint4, cint8 order by min(cint2), cint2, cint4, cint8 limit 10; cint2 | cint4 | cint8 | min -------+--------+--------+----- $ | -15063 | 3990 | $ $ | -14949 | -10395 | $ $ | -14443 | -12710 | $ $ | -11240 | -8825 | $ $ | -8873 | -12094 | $ $ | -7170 | 7723 | $ $ | -4740 | 7720 | $ $ | -1217 | 6383 | $ $ | -166 | -10858 | $ $ | -119 | -231 | $ select s, cint2, min(cint2) from agggroup where cint2 is null and x is null group by s, cint2 order by min(cint2), s, cint2 limit 10; s | cint2 | min ---+-------+----- 2 | $ | $ select s, ss, min(cint2) from agggroup where cint2 is null and x is null group by s, ss order by min(cint2), s, ss limit 10; s | ss | min ---+----+----- 2 | $ | $ select s, x, min(cint2) from agggroup where cint2 is null and x is null group by s, x order by min(cint2), s, x limit 10; s | x | min ---+---+----- 2 | $ | $ select ss, cint2, x, min(cint2) from agggroup where cint2 is null and x is null group by ss, cint2, x order by min(cint2), ss, cint2, x limit 10; ss | cint2 | x | min ----+-------+---+----- $ | $ | $ | $ select ss, s, min(cint2) from agggroup where cint2 is null and x is null group by ss, s order by min(cint2), ss, s limit 10; ss | s | min ----+---+----- $ | 2 | $ select ss, x, cint2, min(cint2) from agggroup where cint2 is null and x is null group by ss, x, cint2 order by min(cint2), ss, x, cint2 limit 10; ss | x | cint2 | min ----+---+-------+----- $ | $ | $ | $ select t, s, ss, x, cint4, cint8, cint2, min(cint2) from agggroup where cint2 is null and x is null group by t, s, ss, x, cint4, cint8, cint2 order by min(cint2), t, s, ss, x, cint4, cint8, cint2 limit 10; t | s | ss | x | cint4 | cint8 | cint2 | min -------+---+----+---+--------+--------+-------+----- 21051 | 2 | $ | $ | 14385 | -587 | $ | $ 22102 | 2 | $ | $ | 13826 | -5912 | $ | $ 23153 | 2 | $ | $ | 11182 | 4556 | $ | $ 24204 | 2 | $ | $ | -15063 | 3990 | $ | $ 25255 | 2 | $ | $ | 2876 | 5568 | $ | $ 26306 | 2 | $ | $ | -119 | -231 | $ | $ 27357 | 2 | $ | $ | 9448 | -312 | $ | $ 28408 | 2 | $ | $ | -7170 | 7723 | $ | $ 29459 | 2 | $ | $ | -14443 | -12710 | $ | $ 30510 | 2 | $ | $ | 12536 | 8350 | $ | $ select x, min(cint2) from agggroup where cint2 is null and x is null group by x order by min(cint2), x limit 10; x | min ---+----- $ | $ reset timescaledb.debug_require_vector_agg; -- Test long text columns. Also make one of them a segmentby, so that we can -- test the long scalar values. create table long(t int, a text, b text, c text, d text); select create_hypertable('long', 't'); create_hypertable ------------------- (3,public,long,t) insert into long select n, a, x, x, x from ( select n, 'short' || m a, repeat('1', 100 * 4 + n) x from generate_series(1, 4) n, generate_series(1, 4) m) t ; insert into long values (-1, 'a', 'b', 'c', 'd'); insert into long values (-2, repeat('long', 1000), 'b', 'c', 'd'); alter table long set (timescaledb.compress, timescaledb.compress_segmentby = 'a', timescaledb.compress_orderby = 't desc'); select count(compress_chunk(x)) from show_chunks('long') x; count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; -- Various placements of long scalar column select sum(t) from long group by a, b, c, d order by 1 limit 10; sum ----- -2 -1 1 1 1 1 2 2 2 2 select sum(t) from long group by d, b, c, a order by 1 limit 10; sum ----- -2 -1 1 1 1 1 2 2 2 2 select sum(t) from long group by d, b, a, c order by 1 limit 10; sum ----- -2 -1 1 1 1 1 2 2 2 2 -- Just the scalar column select sum(t) from long group by a order by 1; sum ----- -2 -1 10 10 10 10 -- No scalar columns select sum(t) from long group by b, c, d order by 1 limit 10; sum ----- -3 4 8 12 16 reset timescaledb.debug_require_vector_agg; -- Test various serialized key lengths. We want to touch the transition from short -- to long varlena header for the serialized key. create table keylength(t int, a text, b text); select create_hypertable('keylength', 't'); create_hypertable ------------------------ (5,public,keylength,t) insert into keylength select t, 'a', repeat('b', t) from generate_series(1, 1000) t; insert into keylength values (-1, '', ''); -- second chunk alter table keylength set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 't desc'); select count(compress_chunk(x)) from show_chunks('keylength') x; count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select sum(t) from keylength group by a, b order by 1 desc limit 10; sum ------ 1000 999 998 997 996 995 994 993 992 991 select sum(t) from keylength group by b, a order by 1 desc limit 10; sum ------ 1000 999 998 997 996 995 994 993 992 991 reset timescaledb.debug_require_vector_agg; -- Add a very simple test for NULLs. We also have some null values in the general -- grouping test above. create table groupnull(t int, a text, b text); select create_hypertable('groupnull', 't'); create_hypertable ------------------------ (7,public,groupnull,t) insert into groupnull values (1, '1', null), (2, null, '2'), (3000000, '3', '3'); alter table groupnull set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 't desc'); select count(compress_chunk(x)) from show_chunks('groupnull') x; count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select sum(t), a, b from groupnull group by a, b order by 1; sum | a | b ---------+---+--- 1 | 1 | $ 2 | $ | 2 3000000 | 3 | 3 select sum(t), a, b from groupnull group by b, a order by 1; sum | a | b ---------+---+--- 1 | 1 | $ 2 | $ | 2 3000000 | 3 | 3 reset timescaledb.debug_require_vector_agg; ����������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_memory.out������������������������������������������0000664�0000000�0000000�00000011715�15100345067�0023703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER --set enable_indexscan=false; -- Helper function that returns the amount of memory currently allocated in a -- given memory context. create or replace function ts_debug_allocated_bytes(text = 'PortalContext') returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; create table mvagg (t int, s0 int, s1 int); select create_hypertable('mvagg', 't', chunk_time_interval => pow(10, 9)::int); create_hypertable -------------------- (1,public,mvagg,t) insert into mvagg select generate_series(1, 2 * pow(10, 6)::int) t, 1 s0, 1 s1; -- Need two segmentbys to prevent compressed index scans to force hash aggregation. -- Otherwise we might get GroupAggregate with Sort which uses linear memory in -- the number of compressed batches. alter table mvagg set (timescaledb.compress, timescaledb.compress_segmentby='s0, s1'); -- Need to inflate the estimated cardinalities of segmentby columns, again to -- force the hash aggregation. insert into mvagg select -1 - x t, -x s0, -x s1 from generate_series(1, 1000) x; -- Need two chunks for chunkwise aggregation. insert into mvagg select -1 t, 1 s0, 1 s1; select count(compress_chunk(x)) from show_chunks('mvagg') x; count ------- 2 vacuum analyze mvagg; -- We are going to log memory usage as a function of number of aggregated elements -- here. create table log(n int, bytes int, a bigint, b bigint, c bigint, d bigint, e bigint, f bigint); -- First, ensure that the underlying decompression has constant memory usage. explain (buffers off, costs off) select distinct on (s0, s1) ts_debug_allocated_bytes() bytes, s0, s1, t from mvagg where t >= -1 and t < 1000000 order by s0, s1, t desc; --- QUERY PLAN --- Result -> Unique -> Merge Append Sort Key: mvagg.s0, mvagg.s1, mvagg.t DESC -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: ((t >= '-1'::integer) AND (t < 1000000)) -> Index Scan using compress_hyper_2_3_chunk_s0_s1__ts_meta_min_1__ts_meta_max__idx on compress_hyper_2_3_chunk Index Cond: ((_ts_meta_min_1 < 1000000) AND (_ts_meta_max_1 >= '-1'::integer)) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk Vectorized Filter: ((t >= '-1'::integer) AND (t < 1000000)) -> Index Scan using compress_hyper_2_4_chunk_s0_s1__ts_meta_min_1__ts_meta_max__idx on compress_hyper_2_4_chunk Index Cond: ((_ts_meta_min_1 < 1000000) AND (_ts_meta_max_1 >= '-1'::integer)) truncate log; \set ECHO none select * from log where ( -- Ideally the memory usage should be constant, but we have to allow for -- small spurious changes to make this test more robust. select regr_slope(bytes, n) > 1/65536 from log ); n | bytes | a | b | c | d | e | f ---+-------+---+---+---+---+---+--- -- Test the vectorized aggregation with grouping by segmentby with various number -- of input row. We expect approximately constant memory usage. truncate log; set max_parallel_workers_per_gather = 0; set timescaledb.debug_require_vector_agg = 'require'; set enable_sort to off; set enable_indexscan to off; set enable_bitmapscan to off; -- We should reliably see HashAggregate here because of the tweaks we made above. explain (buffers off, costs off) select ts_debug_allocated_bytes() bytes, count(*) a, count(t) b, sum(t) c, avg(t) d, min(t) e, max(t) f from mvagg where t >= -1 and t < 1000000 group by s1; --- QUERY PLAN --- Finalize HashAggregate Group Key: mvagg.s1 -> Append -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk Vectorized Filter: ((t >= '-1'::integer) AND (t < 1000000)) -> Seq Scan on compress_hyper_2_3_chunk Filter: ((_ts_meta_max_1 >= '-1'::integer) AND (_ts_meta_min_1 < 1000000)) -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk Vectorized Filter: ((t >= '-1'::integer) AND (t < 1000000)) -> Seq Scan on compress_hyper_2_4_chunk Filter: ((_ts_meta_max_1 >= '-1'::integer) AND (_ts_meta_min_1 < 1000000)) \set ECHO none reset timescaledb.debug_require_vector_agg; reset max_parallel_workers_per_gather; reset work_mem; reset enable_sort; select * from log where ( -- For aggregation by segmentby, memory usage should be constant regardless -- of the number of tuples. Still, we have to allow for small variations -- that can be caused by other reasons. select regr_slope(bytes, n) > 0.01 from log ); n | bytes | a | b | c | d | e | f ---+-------+---+---+---+---+---+--- reset timescaledb.debug_require_vector_agg; ���������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_param.out�������������������������������������������0000664�0000000�0000000�00000011754�15100345067�0023476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test parameterized vector aggregation plans. create table pvagg(s int, a int); select create_hypertable('pvagg', 'a', chunk_time_interval => 1000); create_hypertable -------------------- (1,public,pvagg,t) insert into pvagg select 1, generate_series(1, 999); insert into pvagg select 2, generate_series(1001, 1999); alter table pvagg set (timescaledb.compress, timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('pvagg') x; count ------- 2 analyze pvagg; -- The reference for this test is generated using the standard Postgres -- aggregation. When you change this test, recheck the results against the -- Postgres aggregation by uncommenting the below GUC. -- set timescaledb.enable_vectorized_aggregation to off; explain (verbose, buffers off, costs off) select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a) from pvagg where s = x) xx; --- QUERY PLAN --- Nested Loop Output: x.x, (sum(pvagg.a)) -> Function Scan on pg_catalog.unnest x Output: x.x Function Call: unnest('{0,1,2}'::integer[]) -> Finalize Aggregate Output: sum(pvagg.a) -> Custom Scan (ChunkAppend) on public.pvagg Output: (PARTIAL sum(pvagg.a)) Startup Exclusion: false Runtime Exclusion: true -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.a)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.a -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.s, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk.a Filter: (compress_hyper_2_3_chunk.s = x.x) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.a)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.a -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.s, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk.a Filter: (compress_hyper_2_4_chunk.s = x.x) select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a) from pvagg where s = x) xx; x | sum ---+--------- 0 | 1 | 499500 2 | 1498500 explain (verbose, buffers off, costs off) select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a + x) from pvagg) xx; --- QUERY PLAN --- Nested Loop Output: x.x, (sum((pvagg.a + x.x))) -> Function Scan on pg_catalog.unnest x Output: x.x Function Call: unnest('{0,1,2}'::integer[]) -> Finalize Aggregate Output: sum((pvagg.a + x.x)) -> Append -> Partial Aggregate Output: PARTIAL sum((_hyper_1_1_chunk.a + x.x)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.a -> Seq Scan on _timescaledb_internal.compress_hyper_2_3_chunk Output: compress_hyper_2_3_chunk._ts_meta_count, compress_hyper_2_3_chunk.s, compress_hyper_2_3_chunk._ts_meta_min_1, compress_hyper_2_3_chunk._ts_meta_max_1, compress_hyper_2_3_chunk.a -> Partial Aggregate Output: PARTIAL sum((_hyper_1_2_chunk.a + x.x)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.a -> Seq Scan on _timescaledb_internal.compress_hyper_2_4_chunk Output: compress_hyper_2_4_chunk._ts_meta_count, compress_hyper_2_4_chunk.s, compress_hyper_2_4_chunk._ts_meta_min_1, compress_hyper_2_4_chunk._ts_meta_max_1, compress_hyper_2_4_chunk.a select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a + x) from pvagg) xx; x | sum ---+--------- 0 | 1998000 1 | 1999998 2 | 2001996 -- The plan for this query differs after PG16, x is not used as grouping key but -- just added into the output targetlist of partial aggregation nodes. select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a) from pvagg group by x) xx; x | sum ---+--------- 0 | 1998000 1 | 1998000 2 | 1998000 drop table pvagg; ��������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_segmentby.out���������������������������������������0000664�0000000�0000000�00000017102�15100345067�0024364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table svagg(t int, f int, s int); select create_hypertable('svagg', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create_hypertable -------------------- (1,public,svagg,t) insert into svagg select s * 10000::int + t, (s + t) % 7::int, s from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, -- (values (1), (10)) s(s) generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; alter table svagg set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('svagg') x; count ------- 2 analyze svagg; set max_parallel_workers_per_gather = 0; -- Check that the debug GUC actually works. \set ON_ERROR_STOP 0 set timescaledb.debug_require_vector_agg = 'require'; set timescaledb.enable_vectorized_aggregation to off; select sum(t) from svagg; ERROR: postgres partial aggregation nodes inconsistent with debug_require_vector_agg GUC set timescaledb.debug_require_vector_agg = 'forbid'; set timescaledb.enable_vectorized_aggregation to off; select sum(t) from svagg; sum ------------- 11000100000 set timescaledb.debug_require_vector_agg = 'forbid'; set timescaledb.enable_vectorized_aggregation to on; select sum(t) from svagg; ERROR: vectorized partial aggregation nodes inconsistent with debug_require_vector_agg GUC set timescaledb.debug_require_vector_agg = 'require'; set timescaledb.enable_vectorized_aggregation to on; select sum(t) from svagg; sum ------------- 11000100000 set timescaledb.debug_require_vector_agg = 'allow'; set timescaledb.enable_vectorized_aggregation to on; select sum(t) from svagg; sum ------------- 11000100000 \set ON_ERROR_STOP 1 set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference --set timescaledb.debug_require_vector_agg = 'forbid'; --set timescaledb.enable_vectorized_aggregation to off; select s, sum(t), count(*) from svagg where f >= 0 group by s order by s; s | sum | count ---+------------+------- 0 | 200010000 | 20000 1 | 400010000 | 20000 2 | 600010000 | 20000 3 | 800010000 | 20000 4 | 1000010000 | 20000 5 | 1200010000 | 20000 6 | 1400010000 | 20000 7 | 1600010000 | 20000 8 | 1800010000 | 20000 9 | 2000010000 | 20000 select s, sum(t), count(*) from svagg where f = 0 group by s order by s; s | sum | count ---+-----------+------- 0 | 28578571 | 2857 1 | 57145714 | 2857 2 | 85712857 | 2857 3 | 114280000 | 2857 4 | 142847143 | 2857 5 | 171414286 | 2857 6 | 200061429 | 2858 7 | 228568571 | 2857 8 | 257135714 | 2857 9 | 285702857 | 2857 select s, sum(t), count(*) from svagg where f in (0, 1) group by s order by s; s | sum | count ---+-----------+------- 0 | 57160000 | 5715 1 | 114294285 | 5714 2 | 171428571 | 5714 3 | 228562857 | 5714 4 | 285697143 | 5714 5 | 342831429 | 5714 6 | 400045715 | 5715 7 | 457210000 | 5715 8 | 514274285 | 5714 9 | 571408571 | 5714 select s, sum(t), count(*) from svagg where f in (0, 1, 3) group by s order by s; s | sum | count ---+-----------+------- 0 | 85727143 | 8572 1 | 171428571 | 8571 2 | 257170000 | 8572 3 | 342851428 | 8571 4 | 428552857 | 8571 5 | 514254286 | 8571 6 | 600035715 | 8572 7 | 685767143 | 8572 8 | 771398571 | 8571 9 | 857210000 | 8572 select s, sum(t), count(*) from svagg where f > 10 group by s order by s; s | sum | count ---+-----+------- select s, sum(t), count(*) from svagg group by s order by s; s | sum | count ---+------------+------- 0 | 200010000 | 20000 1 | 400010000 | 20000 2 | 600010000 | 20000 3 | 800010000 | 20000 4 | 1000010000 | 20000 5 | 1200010000 | 20000 6 | 1400010000 | 20000 7 | 1600010000 | 20000 8 | 1800010000 | 20000 9 | 2000010000 | 20000 -- another example that we used not to vectorize because of the projection. explain (buffers off, costs off) select sum(t), s, count(*) from svagg group by s order by s; --- QUERY PLAN --- Finalize GroupAggregate Group Key: svagg.s -> Custom Scan (ChunkAppend) on svagg Order: svagg.s -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_1_chunk -> Index Scan using compress_hyper_2_3_chunk_s__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_3_chunk -> Custom Scan (VectorAgg) -> Custom Scan (ColumnarScan) on _hyper_1_2_chunk -> Index Scan using compress_hyper_2_4_chunk_s__ts_meta_min_1__ts_meta_max_1_idx on compress_hyper_2_4_chunk select sum(t) from svagg group by s order by 1; sum ------------ 200010000 400010000 600010000 800010000 1000010000 1200010000 1400010000 1600010000 1800010000 2000010000 reset timescaledb.debug_require_vector_agg; -- text segmentby column select count(decompress_chunk(x)) from show_chunks('svagg') x; count ------- 2 alter table svagg set (timescaledb.compress = false); alter table svagg add column x text; update svagg set x = repeat(s::text, 100); alter table svagg set (timescaledb.compress, timescaledb.compress_segmentby = 'x'); select count(compress_chunk(x)) from show_chunks('svagg') x; count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference --set timescaledb.debug_require_vector_agg = 'forbid'; --set timescaledb.enable_vectorized_aggregation to off; select substr(x, 1, 2), sum(t), count(*) from svagg where f >= 0 group by x order by x; substr | sum | count --------+------------+------- 00 | 200010000 | 20000 11 | 400010000 | 20000 22 | 600010000 | 20000 33 | 800010000 | 20000 44 | 1000010000 | 20000 55 | 1200010000 | 20000 66 | 1400010000 | 20000 77 | 1600010000 | 20000 88 | 1800010000 | 20000 99 | 2000010000 | 20000 select substr(x, 1, 2), sum(t), count(*) from svagg where f = 0 group by x order by x; substr | sum | count --------+-----------+------- 00 | 28578571 | 2857 11 | 57145714 | 2857 22 | 85712857 | 2857 33 | 114280000 | 2857 44 | 142847143 | 2857 55 | 171414286 | 2857 66 | 200061429 | 2858 77 | 228568571 | 2857 88 | 257135714 | 2857 99 | 285702857 | 2857 select substr(x, 1, 2), sum(t), count(*) from svagg where f in (0, 1) group by x order by x; substr | sum | count --------+-----------+------- 00 | 57160000 | 5715 11 | 114294285 | 5714 22 | 171428571 | 5714 33 | 228562857 | 5714 44 | 285697143 | 5714 55 | 342831429 | 5714 66 | 400045715 | 5715 77 | 457210000 | 5715 88 | 514274285 | 5714 99 | 571408571 | 5714 select substr(x, 1, 2), sum(t), count(*) from svagg where f in (0, 1, 3) group by x order by x; substr | sum | count --------+-----------+------- 00 | 85727143 | 8572 11 | 171428571 | 8571 22 | 257170000 | 8572 33 | 342851428 | 8571 44 | 428552857 | 8571 55 | 514254286 | 8571 66 | 600035715 | 8572 77 | 685767143 | 8572 88 | 771398571 | 8571 99 | 857210000 | 8572 select substr(x, 1, 2), sum(t), count(*) from svagg where f > 10 group by x order by x; substr | sum | count --------+-----+------- reset timescaledb.debug_require_vector_agg; drop table svagg; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_text.out��������������������������������������������0000664�0000000�0000000�00000020437�15100345067�0023360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table agggroup(t int, s int, cint2 int2, cint4 int4, cint8 int8); select create_hypertable('agggroup', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create_hypertable ----------------------- (1,public,agggroup,t) create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, (mix(s + t * 1021) * 32767)::int4 as cint4, (mix(s + t * 1031) * 32767)::int8 as cint8 from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into agggroup select * from source where s = 1; alter table agggroup set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('agggroup') x; count ------- 1 alter table agggroup add column ss int default 11; alter table agggroup add column x text default '11'; insert into agggroup select *, ss::text as x from ( select *, case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1051 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss from source where s != 1 ) t ; -- print a few reference values before compression select x, count(*) from agggroup group by x having (x='11' or x is null) order by count(*), x limit 10; x | count ----+------- 11 | 20019 | 20019 select x, count(cint2) from agggroup group by x having (x='11' or x is null) order by count(cint2), x limit 10; x | count ----+------- 11 | 20000 | 20000 select x, min(cint2) from agggroup group by x having (x='11' or x is null) order by min(cint2), x limit 10; x | min ----+-------- | -16382 11 | -16378 select x, count(*) from agggroup where cint2 > 0 group by x having (x='11' or x is null) order by count(*), x limit 10; x | count ----+------- | 9877 11 | 10105 select x, count(cint2) from agggroup where cint2 > 0 group by x having (x='11' or x is null) order by count(cint2), x limit 10; x | count ----+------- | 9877 11 | 10105 select x, min(cint2) from agggroup where cint2 > 0 group by x order by min(cint2), x limit 10; x | min ----+----- 11 | 1 3 | 1 5 | 1 7 | 1 8 | 1 | 1 9 | 2 6 | 3 0 | 4 4 | 4 select x, count(*) from agggroup where cint2 is null group by x having (x='11') order by count(*), x limit 10; x | count ----+------- 11 | 19 select x, count(cint2) from agggroup where cint2 is null group by x having (x is null) order by count(cint2), x limit 10; x | count ---+------- | 0 select x, count(*) from agggroup where cint2 is null and x is null group by x order by count(*), x limit 10; x | count ---+------- | 19 select x, count(cint2) from agggroup where cint2 is null and x is null group by x order by count(cint2), x limit 10; x | count ---+------- | 0 select x, min(cint2) from agggroup where cint2 is null and x is null group by x order by min(cint2), x limit 10; x | min ---+----- | select count(compress_chunk(x)) from show_chunks('agggroup') x; count ------- 2 vacuum freeze analyze agggroup; -- Long strings create table long(t int, a text, b text, c text, d text); select create_hypertable('long', 't'); create_hypertable ------------------- (3,public,long,t) insert into long select n, x, x, x, x from ( select n, repeat('1', 100 * 4 + n) x from generate_series(1, 4) n) t ; insert into long values (-1, 'a', 'b', 'c', 'd'); alter table long set (timescaledb.compress); select count(compress_chunk(x)) from show_chunks('long') x; count ------- 2 set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference. Note that there are minor discrepancies ---- on float4 due to different numeric stability in our and PG implementations. --set timescaledb.enable_chunkwise_aggregation to off; set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'forbid'; select format('%sselect %s%s(%s) from agggroup%s%s%s;', explain, grouping || ', ', function, variable, ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 'cint2', '*']) variable, unnest(array[ 'min', 'count']) function, unnest(array[ null, 'cint2 > 0', 'cint2 is null', 'cint2 is null and x is null']) with ordinality as condition(condition, n), unnest(array['x']) with ordinality as grouping(grouping, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') order by explain, condition.n, variable, function, grouping.n \gexec select x, count(*) from agggroup group by x order by count(*), x limit 10; x | count ----+------- 3 | 19981 4 | 19981 0 | 20000 5 | 20000 6 | 20000 7 | 20000 8 | 20000 9 | 20000 11 | 20019 | 20019 select x, count(cint2) from agggroup group by x order by count(cint2), x limit 10; x | count ----+------- 3 | 19962 4 | 19962 0 | 19981 5 | 19981 6 | 19981 7 | 19981 8 | 19981 9 | 19981 11 | 20000 | 20000 select x, min(cint2) from agggroup group by x order by min(cint2), x limit 10; x | min ----+-------- 0 | -16383 4 | -16383 5 | -16383 6 | -16383 7 | -16382 8 | -16382 | -16382 3 | -16381 11 | -16378 9 | -16375 select x, count(*) from agggroup where cint2 > 0 group by x order by count(*), x limit 10; x | count ----+------- | 9877 3 | 9884 6 | 9890 4 | 9897 8 | 9898 7 | 9973 0 | 10012 9 | 10018 11 | 10105 5 | 10110 select x, count(cint2) from agggroup where cint2 > 0 group by x order by count(cint2), x limit 10; x | count ----+------- | 9877 3 | 9884 6 | 9890 4 | 9897 8 | 9898 7 | 9973 0 | 10012 9 | 10018 11 | 10105 5 | 10110 select x, min(cint2) from agggroup where cint2 > 0 group by x order by min(cint2), x limit 10; x | min ----+----- 11 | 1 3 | 1 5 | 1 7 | 1 8 | 1 | 1 9 | 2 6 | 3 0 | 4 4 | 4 select x, count(*) from agggroup where cint2 is null group by x order by count(*), x limit 10; x | count ----+------- 0 | 19 11 | 19 3 | 19 4 | 19 5 | 19 6 | 19 7 | 19 8 | 19 9 | 19 | 19 select x, count(cint2) from agggroup where cint2 is null group by x order by count(cint2), x limit 10; x | count ----+------- 0 | 0 11 | 0 3 | 0 4 | 0 5 | 0 6 | 0 7 | 0 8 | 0 9 | 0 | 0 select x, min(cint2) from agggroup where cint2 is null group by x order by min(cint2), x limit 10; x | min ----+----- 0 | 11 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | | select x, count(*) from agggroup where cint2 is null and x is null group by x order by count(*), x limit 10; x | count ---+------- | 19 select x, count(cint2) from agggroup where cint2 is null and x is null group by x order by count(cint2), x limit 10; x | count ---+------- | 0 select x, min(cint2) from agggroup where cint2 is null and x is null group by x order by min(cint2), x limit 10; x | min ---+----- | -- Test grouping by long strings select count(*) from long group by a order by 1 limit 10; count ------- 1 1 1 1 1 reset timescaledb.debug_require_vector_agg; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vector_agg_uuid.out��������������������������������������������0000664�0000000�0000000�00000013546�15100345067�0023345�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test grouping by uuid segmentby column (scalar by-reference fixed-width column). CREATE TABLE public.plan_plus( "time" timestamp with time zone NOT NULL, device uuid NOT NULL, field text NOT NULL, value_numeric double precision, value_bool boolean, value_string text, value_geo point, created timestamp with time zone DEFAULT now() ); CREATE INDEX plan_plus_device_time_idx ON public.plan_plus USING btree (device, "time" DESC); CREATE INDEX plan_plus_time_idx ON public.plan_plus USING btree ("time" DESC); SELECT public.create_hypertable( relation => 'public.plan_plus', time_column_name => 'time', create_default_indexes => false ); create_hypertable ------------------------ (1,public,plan_plus,t) ALTER TABLE public.plan_plus SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device', timescaledb.compress_orderby='"time" DESC' ); INSERT INTO plan_plus WITH devices AS ( select gen_random_uuid() AS device from generate_series(1, 10) ), fields AS ( select 'field '||f AS field from generate_series(1,100) AS f ) SELECT t, device, field, 10, true, 'value', null, '2025-04-15 00:00:00'::timestamptz FROM generate_series('2025-04-15 00:00:00'::timestamptz - interval '1 month', '2025-04-15 00:00:00'::timestamptz, interval '12 hour') AS t, devices, fields; -- Compress data SELECT count(compress_chunk(c)) FROM show_chunks('plan_plus') AS c; count ------- 5 -- Get one of the UUIDs SELECT device FROM plan_plus LIMIT 1 \gset SET timescaledb.debug_require_vector_agg = 'require'; -- Used to segfault SELECT device = :'device'::uuid, field, SUM(value_numeric) AS value FROM plan_plus WHERE device=:'device'::uuid AND field='field 1' AND time > '2024-03-31T00:00:00+00:00'::timestamptz AND time < '2025-04-01T00:01:00+00:00'::timestamptz GROUP BY device, field LIMIT 1; ?column? | field | value ----------+---------+------- t | field 1 | 340 SELECT device = :'device'::uuid, SUM(value_numeric) AS value FROM plan_plus WHERE device=:'device'::uuid AND field='field 1' AND time > '2024-03-31T00:00:00+00:00'::timestamptz AND time < '2025-04-01T00:01:00+00:00'::timestamptz GROUP BY device LIMIT 1; ?column? | value ----------+------- t | 340 RESET timescaledb.debug_require_vector_agg; SELECT count(*) FROM (SELECT device FROM plan_plus GROUP BY device) t; count ------- 10 SELECT count(*) FROM (SELECT device, field FROM plan_plus GROUP BY device, field) t; count ------- 1000 -- UUID groupping create table uuid_table(ts int, u uuid); select count(*) from create_hypertable('uuid_table', 'ts', chunk_time_interval => 6); count ------- 1 alter table uuid_table set (timescaledb.compress); insert into uuid_table values (1, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (4, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (5, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '01941f29-7c00-706a-bea9-105dad841304'), (18, '01941f2a-665f-7722-b4b5-cf4e70e666d0'), (19, NULL::uuid), (20, NULL::uuid), (21, NULL::uuid); -- add a few derived columns alter table uuid_table add column ver int; alter table uuid_table add column uuid_ts timestamptz; update uuid_table set ver = uuid_version(u) , uuid_ts = uuid_timestamp_micros(u) where u is not null; select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; count ------- 4 SET timescaledb.debug_require_vector_agg = 'require'; SELECT ver, u, ts, uuid_ts from uuid_table where uuid_ts < '2025-06-25 16:16:46.347779+01' and ver = 7 order by 1,2; ver | u | ts | uuid_ts -----+--------------------------------------+----+------------------------------------- 7 | 01941f29-7c00-706a-bea9-105dad841304 | 17 | Tue Dec 31 16:00:00.000025 2024 PST 7 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 | 18 | Tue Dec 31 16:00:59.999445 2024 PST 7 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f | 4 | Wed Jun 25 08:16:46.347777 2025 PDT 7 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f | 3 | Wed Jun 25 08:16:46.347777 2025 PDT 7 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f | 2 | Wed Jun 25 08:16:46.347777 2025 PDT 7 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f | 1 | Wed Jun 25 08:16:46.347777 2025 PDT 7 | 0197a7a9-b48b-7c75-a810-8acf630e634f | 5 | Wed Jun 25 08:16:46.347778 2025 PDT 7 | 0197a7a9-b48b-7c75-a810-8acf630e634f | 6 | Wed Jun 25 08:16:46.347778 2025 PDT 7 | 0197a7a9-b48b-7c76-b616-69e64a802b5c | 7 | Wed Jun 25 08:16:46.347778 2025 PDT SELECT ver, u, count(*), sum(ts) from uuid_table where uuid_ts < '2025-06-25 16:16:46.347779+01' and ver = 7 group by 1,2 order by 1,2; ver | u | count | sum -----+--------------------------------------+-------+----- 7 | 01941f29-7c00-706a-bea9-105dad841304 | 1 | 17 7 | 01941f2a-665f-7722-b4b5-cf4e70e666d0 | 1 | 18 7 | 0197a7a9-b48b-7c71-92cb-eb724822bb0f | 4 | 10 7 | 0197a7a9-b48b-7c75-a810-8acf630e634f | 2 | 11 7 | 0197a7a9-b48b-7c76-b616-69e64a802b5c | 1 | 7 RESET timescaledb.debug_require_vector_agg; ����������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/expected/vectorized_aggregation.out�������������������������������������0000664�0000000�0000000�00001023517�15100345067�0024724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' CREATE TABLE testtable ( time timestamptz NOT NULL, segment_by_value integer, int_value integer, float_value double precision); SELECT FROM create_hypertable(relation=>'testtable', time_column_name=> 'time'); -- ALTER TABLE testtable SET (timescaledb.compress, timescaledb.compress_segmentby='segment_by_value'); INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(-10, 100, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; sum | sum | sum --------+--------+-------- 304695 | 304695 | 304695 -- -- Enable this GUC to run this test with Hypercore TAM. The EXPLAINs -- will differ, but the results should not. -- --SET timescaledb.default_hypercore_use_access_method = true; --- -- Tests with some chunks compressed --- SELECT compress_chunk(ch) FROM show_chunks('testtable') ch LIMIT 3; compress_chunk ---------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk VACUUM ANALYZE testtable; -- Vectorized aggregation possible SELECT sum(segment_by_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value -- Vectorization possible - filter on segment_by :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE segment_by_value > 0; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value Filter: (compress_hyper_2_11_chunk.segment_by_value > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value Filter: (compress_hyper_2_12_chunk.segment_by_value > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value Filter: (compress_hyper_2_13_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value Filter: (_hyper_1_4_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value Filter: (_hyper_1_5_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value Filter: (_hyper_1_6_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value Filter: (_hyper_1_7_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value Filter: (_hyper_1_8_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value Filter: (_hyper_1_9_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value Filter: (_hyper_1_10_chunk.segment_by_value > 0) -- Vectorization with filter on compressed columns :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE segment_by_value > 0 AND int_value > 0; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value Vectorized Filter: (_hyper_1_1_chunk.int_value > 0) -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value Filter: (compress_hyper_2_11_chunk.segment_by_value > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value Vectorized Filter: (_hyper_1_2_chunk.int_value > 0) -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value Filter: (compress_hyper_2_12_chunk.segment_by_value > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value Vectorized Filter: (_hyper_1_3_chunk.int_value > 0) -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value Filter: (compress_hyper_2_13_chunk.segment_by_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value Filter: ((_hyper_1_4_chunk.segment_by_value > 0) AND (_hyper_1_4_chunk.int_value > 0)) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value Filter: ((_hyper_1_5_chunk.segment_by_value > 0) AND (_hyper_1_5_chunk.int_value > 0)) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value Filter: ((_hyper_1_6_chunk.segment_by_value > 0) AND (_hyper_1_6_chunk.int_value > 0)) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value Filter: ((_hyper_1_7_chunk.segment_by_value > 0) AND (_hyper_1_7_chunk.int_value > 0)) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value Filter: ((_hyper_1_8_chunk.segment_by_value > 0) AND (_hyper_1_8_chunk.int_value > 0)) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value Filter: ((_hyper_1_9_chunk.segment_by_value > 0) AND (_hyper_1_9_chunk.int_value > 0)) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value Filter: ((_hyper_1_10_chunk.segment_by_value > 0) AND (_hyper_1_10_chunk.int_value > 0)) :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE int_value > 0; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value Vectorized Filter: (_hyper_1_1_chunk.int_value > 0) -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value Vectorized Filter: (_hyper_1_2_chunk.int_value > 0) -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value Vectorized Filter: (_hyper_1_3_chunk.int_value > 0) -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value Filter: (_hyper_1_4_chunk.int_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value Filter: (_hyper_1_5_chunk.int_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value Filter: (_hyper_1_6_chunk.int_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value Filter: (_hyper_1_7_chunk.int_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value Filter: (_hyper_1_8_chunk.int_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value Filter: (_hyper_1_9_chunk.int_value > 0) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value Filter: (_hyper_1_10_chunk.int_value > 0) :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE float_value > 0; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value Vectorized Filter: (_hyper_1_1_chunk.float_value > '0'::double precision) -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value Vectorized Filter: (_hyper_1_2_chunk.float_value > '0'::double precision) -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value Vectorized Filter: (_hyper_1_3_chunk.float_value > '0'::double precision) -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value Filter: (_hyper_1_4_chunk.float_value > '0'::double precision) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value Filter: (_hyper_1_5_chunk.float_value > '0'::double precision) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value Filter: (_hyper_1_6_chunk.float_value > '0'::double precision) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value Filter: (_hyper_1_7_chunk.float_value > '0'::double precision) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value Filter: (_hyper_1_8_chunk.float_value > '0'::double precision) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value Filter: (_hyper_1_9_chunk.float_value > '0'::double precision) -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value Filter: (_hyper_1_10_chunk.float_value > '0'::double precision) -- Vectorization possible with grouping by one fixed-size column :EXPLAIN SELECT sum(segment_by_value) FROM testtable GROUP BY float_value; --- QUERY PLAN --- Finalize HashAggregate Output: sum(testtable.segment_by_value), testtable.float_value Group Key: testtable.float_value -> Append -> Custom Scan (VectorAgg) Output: _hyper_1_1_chunk.float_value, (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: hashed with single 8-byte key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.float_value, _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_2_chunk.float_value, (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: hashed with single 8-byte key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.float_value, _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_3_chunk.float_value, (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: hashed with single 8-byte key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.float_value, _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial HashAggregate Output: _hyper_1_4_chunk.float_value, PARTIAL sum(_hyper_1_4_chunk.segment_by_value) Group Key: _hyper_1_4_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.float_value, _hyper_1_4_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_5_chunk.float_value, PARTIAL sum(_hyper_1_5_chunk.segment_by_value) Group Key: _hyper_1_5_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.float_value, _hyper_1_5_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_6_chunk.float_value, PARTIAL sum(_hyper_1_6_chunk.segment_by_value) Group Key: _hyper_1_6_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.float_value, _hyper_1_6_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_7_chunk.float_value, PARTIAL sum(_hyper_1_7_chunk.segment_by_value) Group Key: _hyper_1_7_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.float_value, _hyper_1_7_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_8_chunk.float_value, PARTIAL sum(_hyper_1_8_chunk.segment_by_value) Group Key: _hyper_1_8_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.float_value, _hyper_1_8_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_9_chunk.float_value, PARTIAL sum(_hyper_1_9_chunk.segment_by_value) Group Key: _hyper_1_9_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.float_value, _hyper_1_9_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_10_chunk.float_value, PARTIAL sum(_hyper_1_10_chunk.segment_by_value) Group Key: _hyper_1_10_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.float_value, _hyper_1_10_chunk.segment_by_value :EXPLAIN SELECT sum(segment_by_value) FROM testtable GROUP BY int_value; --- QUERY PLAN --- Finalize HashAggregate Output: sum(testtable.segment_by_value), testtable.int_value Group Key: testtable.int_value -> Append -> Custom Scan (VectorAgg) Output: _hyper_1_1_chunk.int_value, (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: hashed with single 4-byte key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value, _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_2_chunk.int_value, (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: hashed with single 4-byte key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value, _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_3_chunk.int_value, (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: hashed with single 4-byte key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value, _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial HashAggregate Output: _hyper_1_4_chunk.int_value, PARTIAL sum(_hyper_1_4_chunk.segment_by_value) Group Key: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value, _hyper_1_4_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_5_chunk.int_value, PARTIAL sum(_hyper_1_5_chunk.segment_by_value) Group Key: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value, _hyper_1_5_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_6_chunk.int_value, PARTIAL sum(_hyper_1_6_chunk.segment_by_value) Group Key: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value, _hyper_1_6_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_7_chunk.int_value, PARTIAL sum(_hyper_1_7_chunk.segment_by_value) Group Key: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value, _hyper_1_7_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_8_chunk.int_value, PARTIAL sum(_hyper_1_8_chunk.segment_by_value) Group Key: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value, _hyper_1_8_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_9_chunk.int_value, PARTIAL sum(_hyper_1_9_chunk.segment_by_value) Group Key: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value, _hyper_1_9_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_10_chunk.int_value, PARTIAL sum(_hyper_1_10_chunk.segment_by_value) Group Key: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value, _hyper_1_10_chunk.segment_by_value -- Vectorization possible with grouping by multiple columns :EXPLAIN SELECT sum(segment_by_value) FROM testtable GROUP BY int_value, float_value; --- QUERY PLAN --- Finalize HashAggregate Output: sum(testtable.segment_by_value), testtable.int_value, testtable.float_value Group Key: testtable.int_value, testtable.float_value -> Append -> Custom Scan (VectorAgg) Output: _hyper_1_1_chunk.int_value, _hyper_1_1_chunk.float_value, (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: hashed with serialized key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value, _hyper_1_1_chunk.float_value, _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_2_chunk.int_value, _hyper_1_2_chunk.float_value, (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: hashed with serialized key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value, _hyper_1_2_chunk.float_value, _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_3_chunk.int_value, _hyper_1_3_chunk.float_value, (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: hashed with serialized key -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value, _hyper_1_3_chunk.float_value, _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial HashAggregate Output: _hyper_1_4_chunk.int_value, _hyper_1_4_chunk.float_value, PARTIAL sum(_hyper_1_4_chunk.segment_by_value) Group Key: _hyper_1_4_chunk.int_value, _hyper_1_4_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value, _hyper_1_4_chunk.float_value, _hyper_1_4_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_5_chunk.int_value, _hyper_1_5_chunk.float_value, PARTIAL sum(_hyper_1_5_chunk.segment_by_value) Group Key: _hyper_1_5_chunk.int_value, _hyper_1_5_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value, _hyper_1_5_chunk.float_value, _hyper_1_5_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_6_chunk.int_value, _hyper_1_6_chunk.float_value, PARTIAL sum(_hyper_1_6_chunk.segment_by_value) Group Key: _hyper_1_6_chunk.int_value, _hyper_1_6_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value, _hyper_1_6_chunk.float_value, _hyper_1_6_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_7_chunk.int_value, _hyper_1_7_chunk.float_value, PARTIAL sum(_hyper_1_7_chunk.segment_by_value) Group Key: _hyper_1_7_chunk.int_value, _hyper_1_7_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value, _hyper_1_7_chunk.float_value, _hyper_1_7_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_8_chunk.int_value, _hyper_1_8_chunk.float_value, PARTIAL sum(_hyper_1_8_chunk.segment_by_value) Group Key: _hyper_1_8_chunk.int_value, _hyper_1_8_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value, _hyper_1_8_chunk.float_value, _hyper_1_8_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_9_chunk.int_value, _hyper_1_9_chunk.float_value, PARTIAL sum(_hyper_1_9_chunk.segment_by_value) Group Key: _hyper_1_9_chunk.int_value, _hyper_1_9_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value, _hyper_1_9_chunk.float_value, _hyper_1_9_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_10_chunk.int_value, _hyper_1_10_chunk.float_value, PARTIAL sum(_hyper_1_10_chunk.segment_by_value) Group Key: _hyper_1_10_chunk.int_value, _hyper_1_10_chunk.float_value -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value, _hyper_1_10_chunk.float_value, _hyper_1_10_chunk.segment_by_value -- Vectorization possible with grouping by a segmentby column. :EXPLAIN SELECT sum(int_value) FROM testtable GROUP BY segment_by_value; --- QUERY PLAN --- Finalize HashAggregate Output: sum(testtable.int_value), testtable.segment_by_value Group Key: testtable.segment_by_value -> Append -> Custom Scan (VectorAgg) Output: _hyper_1_1_chunk.segment_by_value, (PARTIAL sum(_hyper_1_1_chunk.int_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value, _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_2_chunk.segment_by_value, (PARTIAL sum(_hyper_1_2_chunk.int_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value, _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_3_chunk.segment_by_value, (PARTIAL sum(_hyper_1_3_chunk.int_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value, _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial HashAggregate Output: _hyper_1_4_chunk.segment_by_value, PARTIAL sum(_hyper_1_4_chunk.int_value) Group Key: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value, _hyper_1_4_chunk.int_value -> Partial HashAggregate Output: _hyper_1_5_chunk.segment_by_value, PARTIAL sum(_hyper_1_5_chunk.int_value) Group Key: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value, _hyper_1_5_chunk.int_value -> Partial HashAggregate Output: _hyper_1_6_chunk.segment_by_value, PARTIAL sum(_hyper_1_6_chunk.int_value) Group Key: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value, _hyper_1_6_chunk.int_value -> Partial HashAggregate Output: _hyper_1_7_chunk.segment_by_value, PARTIAL sum(_hyper_1_7_chunk.int_value) Group Key: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value, _hyper_1_7_chunk.int_value -> Partial HashAggregate Output: _hyper_1_8_chunk.segment_by_value, PARTIAL sum(_hyper_1_8_chunk.int_value) Group Key: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value, _hyper_1_8_chunk.int_value -> Partial HashAggregate Output: _hyper_1_9_chunk.segment_by_value, PARTIAL sum(_hyper_1_9_chunk.int_value) Group Key: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value, _hyper_1_9_chunk.int_value -> Partial HashAggregate Output: _hyper_1_10_chunk.segment_by_value, PARTIAL sum(_hyper_1_10_chunk.int_value) Group Key: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value, _hyper_1_10_chunk.int_value :EXPLAIN SELECT sum(segment_by_value), segment_by_value FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: (sum(testtable.segment_by_value)), testtable.segment_by_value Sort Key: (sum(testtable.segment_by_value)), testtable.segment_by_value -> Finalize HashAggregate Output: sum(testtable.segment_by_value), testtable.segment_by_value Group Key: testtable.segment_by_value -> Append -> Custom Scan (VectorAgg) Output: _hyper_1_1_chunk.segment_by_value, (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_2_chunk.segment_by_value, (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_3_chunk.segment_by_value, (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial HashAggregate Output: _hyper_1_4_chunk.segment_by_value, PARTIAL sum(_hyper_1_4_chunk.segment_by_value) Group Key: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_5_chunk.segment_by_value, PARTIAL sum(_hyper_1_5_chunk.segment_by_value) Group Key: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_6_chunk.segment_by_value, PARTIAL sum(_hyper_1_6_chunk.segment_by_value) Group Key: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_7_chunk.segment_by_value, PARTIAL sum(_hyper_1_7_chunk.segment_by_value) Group Key: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_8_chunk.segment_by_value, PARTIAL sum(_hyper_1_8_chunk.segment_by_value) Group Key: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_9_chunk.segment_by_value, PARTIAL sum(_hyper_1_9_chunk.segment_by_value) Group Key: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_10_chunk.segment_by_value, PARTIAL sum(_hyper_1_10_chunk.segment_by_value) Group Key: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value SELECT sum(segment_by_value), segment_by_value FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; sum | segment_by_value ------+------------------ -610 | -10 -549 | -9 -488 | -8 -427 | -7 -366 | -6 -305 | -5 -244 | -4 -183 | -3 -122 | -2 -61 | -1 0 | 0 61 | 1 122 | 2 183 | 3 244 | 4 305 | 5 366 | 6 427 | 7 488 | 8 549 | 9 610 | 10 671 | 11 732 | 12 793 | 13 854 | 14 915 | 15 976 | 16 1037 | 17 1098 | 18 1159 | 19 1220 | 20 1281 | 21 1342 | 22 1403 | 23 1464 | 24 1525 | 25 1586 | 26 1647 | 27 1708 | 28 1769 | 29 1830 | 30 1891 | 31 1952 | 32 2013 | 33 2074 | 34 2135 | 35 2196 | 36 2257 | 37 2318 | 38 2379 | 39 2440 | 40 2501 | 41 2562 | 42 2623 | 43 2684 | 44 2745 | 45 2806 | 46 2867 | 47 2928 | 48 2989 | 49 3050 | 50 3111 | 51 3172 | 52 3233 | 53 3294 | 54 3355 | 55 3416 | 56 3477 | 57 3538 | 58 3599 | 59 3660 | 60 3721 | 61 3782 | 62 3843 | 63 3904 | 64 3965 | 65 4026 | 66 4087 | 67 4148 | 68 4209 | 69 4270 | 70 4331 | 71 4392 | 72 4453 | 73 4514 | 74 4575 | 75 4636 | 76 4697 | 77 4758 | 78 4819 | 79 4880 | 80 4941 | 81 5002 | 82 5063 | 83 5124 | 84 5185 | 85 5246 | 86 5307 | 87 5368 | 88 5429 | 89 5490 | 90 5551 | 91 5612 | 92 5673 | 93 5734 | 94 5795 | 95 5856 | 96 5917 | 97 5978 | 98 6039 | 99 6100 | 100 :EXPLAIN SELECT segment_by_value, sum(segment_by_value) FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; --- QUERY PLAN --- Sort Output: testtable.segment_by_value, (sum(testtable.segment_by_value)) Sort Key: testtable.segment_by_value, (sum(testtable.segment_by_value)) -> Finalize HashAggregate Output: testtable.segment_by_value, sum(testtable.segment_by_value) Group Key: testtable.segment_by_value -> Append -> Custom Scan (VectorAgg) Output: _hyper_1_1_chunk.segment_by_value, (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_2_chunk.segment_by_value, (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: _hyper_1_3_chunk.segment_by_value, (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: per compressed batch -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial HashAggregate Output: _hyper_1_4_chunk.segment_by_value, PARTIAL sum(_hyper_1_4_chunk.segment_by_value) Group Key: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_5_chunk.segment_by_value, PARTIAL sum(_hyper_1_5_chunk.segment_by_value) Group Key: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_6_chunk.segment_by_value, PARTIAL sum(_hyper_1_6_chunk.segment_by_value) Group Key: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_7_chunk.segment_by_value, PARTIAL sum(_hyper_1_7_chunk.segment_by_value) Group Key: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_8_chunk.segment_by_value, PARTIAL sum(_hyper_1_8_chunk.segment_by_value) Group Key: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_9_chunk.segment_by_value, PARTIAL sum(_hyper_1_9_chunk.segment_by_value) Group Key: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Partial HashAggregate Output: _hyper_1_10_chunk.segment_by_value, PARTIAL sum(_hyper_1_10_chunk.segment_by_value) Group Key: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value SELECT segment_by_value, sum(segment_by_value) FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; segment_by_value | sum ------------------+------ -10 | -610 -9 | -549 -8 | -488 -7 | -427 -6 | -366 -5 | -305 -4 | -244 -3 | -183 -2 | -122 -1 | -61 0 | 0 1 | 61 2 | 122 3 | 183 4 | 244 5 | 305 6 | 366 7 | 427 8 | 488 9 | 549 10 | 610 11 | 671 12 | 732 13 | 793 14 | 854 15 | 915 16 | 976 17 | 1037 18 | 1098 19 | 1159 20 | 1220 21 | 1281 22 | 1342 23 | 1403 24 | 1464 25 | 1525 26 | 1586 27 | 1647 28 | 1708 29 | 1769 30 | 1830 31 | 1891 32 | 1952 33 | 2013 34 | 2074 35 | 2135 36 | 2196 37 | 2257 38 | 2318 39 | 2379 40 | 2440 41 | 2501 42 | 2562 43 | 2623 44 | 2684 45 | 2745 46 | 2806 47 | 2867 48 | 2928 49 | 2989 50 | 3050 51 | 3111 52 | 3172 53 | 3233 54 | 3294 55 | 3355 56 | 3416 57 | 3477 58 | 3538 59 | 3599 60 | 3660 61 | 3721 62 | 3782 63 | 3843 64 | 3904 65 | 3965 66 | 4026 67 | 4087 68 | 4148 69 | 4209 70 | 4270 71 | 4331 72 | 4392 73 | 4453 74 | 4514 75 | 4575 76 | 4636 77 | 4697 78 | 4758 79 | 4819 80 | 4880 81 | 4941 82 | 5002 83 | 5063 84 | 5124 85 | 5185 86 | 5246 87 | 5307 88 | 5368 89 | 5429 90 | 5490 91 | 5551 92 | 5612 93 | 5673 94 | 5734 95 | 5795 96 | 5856 97 | 5917 98 | 5978 99 | 6039 100 | 6100 -- Vectorized aggregation possible SELECT sum(int_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -- Vectorized aggregation possible SELECT sum(float_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(float_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.float_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.float_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.float_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.float_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.float_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.float_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.float_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.float_value) -> Seq Scan on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.float_value --- -- Tests with all chunks compressed --- SELECT compress_chunk(ch, if_not_compressed => true) FROM show_chunks('testtable') ch; NOTICE: chunk "_hyper_1_1_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_2_chunk" is already converted to columnstore NOTICE: chunk "_hyper_1_3_chunk" is already converted to columnstore compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_1_chunk _timescaledb_internal._hyper_1_2_chunk _timescaledb_internal._hyper_1_3_chunk _timescaledb_internal._hyper_1_4_chunk _timescaledb_internal._hyper_1_5_chunk _timescaledb_internal._hyper_1_6_chunk _timescaledb_internal._hyper_1_7_chunk _timescaledb_internal._hyper_1_8_chunk _timescaledb_internal._hyper_1_9_chunk _timescaledb_internal._hyper_1_10_chunk VACUUM ANALYZE testtable; -- Vectorized aggregation possible SELECT sum(segment_by_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value -- Vectorized aggregation possible SELECT sum(int_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value --- -- Tests with some chunks are partially compressed --- INSERT INTO testtable (time, segment_by_value, int_value, float_value) VALUES ('1980-01-02 01:00:00-00', 0, 0, 0); -- Vectorized aggregation possible SELECT sum(segment_by_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value -- Vectorized aggregation possible SELECT sum(int_value) FROM testtable; sum -------- 304695 :EXPLAIN SELECT sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value --Vectorized aggregation not possible for expression SELECT sum(abs(int_value)) FROM testtable; sum -------- 311405 :EXPLAIN SELECT sum(abs(int_value)) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(abs(testtable.int_value)) -> Append -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_1_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_1_chunk.int_value)) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_2_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_3_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_4_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_5_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_6_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_7_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_8_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_9_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(abs(_hyper_1_10_chunk.int_value)) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value -- Vectorized aggregation NOT possible SET timescaledb.enable_vectorized_aggregation = OFF; :EXPLAIN SELECT sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Append -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_2_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_3_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value RESET timescaledb.enable_vectorized_aggregation; -- Vectorized aggregation without bulk decompression only possible for -- segmentby columns. SET timescaledb.enable_bulk_decompression = OFF; :EXPLAIN SELECT sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Append -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_2_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_3_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value :EXPLAIN SELECT sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value SELECT sum(segment_by_value) FROM testtable; sum -------- 304695 RESET timescaledb.enable_bulk_decompression; -- Using the same sum function multiple times is supported by vectorization :EXPLAIN SELECT sum(int_value), sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value), sum(testtable.int_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value -- Using the same sum function multiple times is supported by vectorization :EXPLAIN SELECT sum(segment_by_value), sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value), sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value -- Performing a sum on multiple columns is supported. :EXPLAIN SELECT sum(int_value), sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value), sum(testtable.segment_by_value) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_1_chunk.int_value)), (PARTIAL sum(_hyper_1_1_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value, _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value), PARTIAL sum(_hyper_1_1_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value, _hyper_1_1_chunk.segment_by_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_2_chunk.int_value)), (PARTIAL sum(_hyper_1_2_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value, _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_3_chunk.int_value)), (PARTIAL sum(_hyper_1_3_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value, _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_4_chunk.int_value)), (PARTIAL sum(_hyper_1_4_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value, _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_5_chunk.int_value)), (PARTIAL sum(_hyper_1_5_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value, _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_6_chunk.int_value)), (PARTIAL sum(_hyper_1_6_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value, _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_7_chunk.int_value)), (PARTIAL sum(_hyper_1_7_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value, _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_8_chunk.int_value)), (PARTIAL sum(_hyper_1_8_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value, _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_9_chunk.int_value)), (PARTIAL sum(_hyper_1_9_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value, _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_10_chunk.int_value)), (PARTIAL sum(_hyper_1_10_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value, _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value SELECT sum(int_value), sum(segment_by_value) FROM testtable; sum | sum --------+-------- 304695 | 304695 -- Using the sum function together with another non-vector capable aggregate is not supported :EXPLAIN SELECT sum(int_value), bit_or(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value), bit_or(testtable.int_value) -> Append -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value), PARTIAL bit_or(_hyper_1_1_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.int_value), PARTIAL bit_or(_hyper_1_1_chunk.int_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.int_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_2_chunk.int_value), PARTIAL bit_or(_hyper_1_2_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_3_chunk.int_value), PARTIAL bit_or(_hyper_1_3_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.int_value), PARTIAL bit_or(_hyper_1_4_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.int_value), PARTIAL bit_or(_hyper_1_5_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.int_value), PARTIAL bit_or(_hyper_1_6_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.int_value), PARTIAL bit_or(_hyper_1_7_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.int_value), PARTIAL bit_or(_hyper_1_8_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.int_value), PARTIAL bit_or(_hyper_1_9_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.int_value), PARTIAL bit_or(_hyper_1_10_chunk.int_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.int_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value -- Using the sum function together with another non-vector capable aggregate is not supported :EXPLAIN SELECT sum(segment_by_value), bit_or(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value), bit_or(testtable.segment_by_value) -> Append -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_1_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_11_chunk Output: compress_hyper_2_11_chunk._ts_meta_count, compress_hyper_2_11_chunk.segment_by_value, compress_hyper_2_11_chunk._ts_meta_min_1, compress_hyper_2_11_chunk._ts_meta_max_1, compress_hyper_2_11_chunk."time", compress_hyper_2_11_chunk.int_value, compress_hyper_2_11_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_1_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_1_chunk.segment_by_value) -> Seq Scan on _timescaledb_internal._hyper_1_1_chunk Output: _hyper_1_1_chunk.segment_by_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_2_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_2_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_2_chunk Output: _hyper_1_2_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_12_chunk Output: compress_hyper_2_12_chunk._ts_meta_count, compress_hyper_2_12_chunk.segment_by_value, compress_hyper_2_12_chunk._ts_meta_min_1, compress_hyper_2_12_chunk._ts_meta_max_1, compress_hyper_2_12_chunk."time", compress_hyper_2_12_chunk.int_value, compress_hyper_2_12_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_3_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_3_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_3_chunk Output: _hyper_1_3_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_13_chunk Output: compress_hyper_2_13_chunk._ts_meta_count, compress_hyper_2_13_chunk.segment_by_value, compress_hyper_2_13_chunk._ts_meta_min_1, compress_hyper_2_13_chunk._ts_meta_max_1, compress_hyper_2_13_chunk."time", compress_hyper_2_13_chunk.int_value, compress_hyper_2_13_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_4_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_4_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_4_chunk Output: _hyper_1_4_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_14_chunk Output: compress_hyper_2_14_chunk._ts_meta_count, compress_hyper_2_14_chunk.segment_by_value, compress_hyper_2_14_chunk._ts_meta_min_1, compress_hyper_2_14_chunk._ts_meta_max_1, compress_hyper_2_14_chunk."time", compress_hyper_2_14_chunk.int_value, compress_hyper_2_14_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_5_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_5_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_5_chunk Output: _hyper_1_5_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_15_chunk Output: compress_hyper_2_15_chunk._ts_meta_count, compress_hyper_2_15_chunk.segment_by_value, compress_hyper_2_15_chunk._ts_meta_min_1, compress_hyper_2_15_chunk._ts_meta_max_1, compress_hyper_2_15_chunk."time", compress_hyper_2_15_chunk.int_value, compress_hyper_2_15_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_6_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_6_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_6_chunk Output: _hyper_1_6_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_16_chunk Output: compress_hyper_2_16_chunk._ts_meta_count, compress_hyper_2_16_chunk.segment_by_value, compress_hyper_2_16_chunk._ts_meta_min_1, compress_hyper_2_16_chunk._ts_meta_max_1, compress_hyper_2_16_chunk."time", compress_hyper_2_16_chunk.int_value, compress_hyper_2_16_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_7_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_7_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_7_chunk Output: _hyper_1_7_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_17_chunk Output: compress_hyper_2_17_chunk._ts_meta_count, compress_hyper_2_17_chunk.segment_by_value, compress_hyper_2_17_chunk._ts_meta_min_1, compress_hyper_2_17_chunk._ts_meta_max_1, compress_hyper_2_17_chunk."time", compress_hyper_2_17_chunk.int_value, compress_hyper_2_17_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_8_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_8_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_8_chunk Output: _hyper_1_8_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_18_chunk Output: compress_hyper_2_18_chunk._ts_meta_count, compress_hyper_2_18_chunk.segment_by_value, compress_hyper_2_18_chunk._ts_meta_min_1, compress_hyper_2_18_chunk._ts_meta_max_1, compress_hyper_2_18_chunk."time", compress_hyper_2_18_chunk.int_value, compress_hyper_2_18_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_9_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_9_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_9_chunk Output: _hyper_1_9_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_19_chunk Output: compress_hyper_2_19_chunk._ts_meta_count, compress_hyper_2_19_chunk.segment_by_value, compress_hyper_2_19_chunk._ts_meta_min_1, compress_hyper_2_19_chunk._ts_meta_max_1, compress_hyper_2_19_chunk."time", compress_hyper_2_19_chunk.int_value, compress_hyper_2_19_chunk.float_value -> Partial Aggregate Output: PARTIAL sum(_hyper_1_10_chunk.segment_by_value), PARTIAL bit_or(_hyper_1_10_chunk.segment_by_value) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_10_chunk Output: _hyper_1_10_chunk.segment_by_value -> Seq Scan on _timescaledb_internal.compress_hyper_2_20_chunk Output: compress_hyper_2_20_chunk._ts_meta_count, compress_hyper_2_20_chunk.segment_by_value, compress_hyper_2_20_chunk._ts_meta_min_1, compress_hyper_2_20_chunk._ts_meta_max_1, compress_hyper_2_20_chunk."time", compress_hyper_2_20_chunk.int_value, compress_hyper_2_20_chunk.float_value --- -- Tests with only negative values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(-10, 0, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; sum | sum | sum -------+-------+------- -3355 | -3355 | -3355 SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_21_chunk _timescaledb_internal._hyper_1_22_chunk _timescaledb_internal._hyper_1_23_chunk _timescaledb_internal._hyper_1_24_chunk _timescaledb_internal._hyper_1_25_chunk _timescaledb_internal._hyper_1_26_chunk _timescaledb_internal._hyper_1_27_chunk _timescaledb_internal._hyper_1_28_chunk _timescaledb_internal._hyper_1_29_chunk _timescaledb_internal._hyper_1_30_chunk -- Aggregation with vectorization SELECT sum(segment_by_value) FROM testtable; sum ------- -3355 SELECT sum(int_value) FROM testtable; sum ------- -3355 --- -- Tests with only positive values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 10, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; sum | sum | sum ------+------+------ 3355 | 3355 | 3355 SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_41_chunk _timescaledb_internal._hyper_1_42_chunk _timescaledb_internal._hyper_1_43_chunk _timescaledb_internal._hyper_1_44_chunk _timescaledb_internal._hyper_1_45_chunk _timescaledb_internal._hyper_1_46_chunk _timescaledb_internal._hyper_1_47_chunk _timescaledb_internal._hyper_1_48_chunk _timescaledb_internal._hyper_1_49_chunk _timescaledb_internal._hyper_1_50_chunk -- Aggregation with vectorization SELECT sum(segment_by_value) FROM testtable; sum ------ 3355 SELECT sum(int_value) FROM testtable; sum ------ 3355 -- Vectorization possible - filter on segment_by :EXPLAIN SELECT sum(int_value) FROM testtable WHERE segment_by_value > 5; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Gather Output: (PARTIAL sum(testtable.int_value)) Workers Planned: 2 -> Parallel Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_41_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_41_chunk Output: _hyper_1_41_chunk.int_value -> Parallel Index Scan using compress_hyper_2_51_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_51_chunk Output: compress_hyper_2_51_chunk._ts_meta_count, compress_hyper_2_51_chunk.segment_by_value, compress_hyper_2_51_chunk._ts_meta_min_1, compress_hyper_2_51_chunk._ts_meta_max_1, compress_hyper_2_51_chunk."time", compress_hyper_2_51_chunk.int_value, compress_hyper_2_51_chunk.float_value Index Cond: (compress_hyper_2_51_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_42_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_42_chunk Output: _hyper_1_42_chunk.int_value -> Parallel Index Scan using compress_hyper_2_52_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_52_chunk Output: compress_hyper_2_52_chunk._ts_meta_count, compress_hyper_2_52_chunk.segment_by_value, compress_hyper_2_52_chunk._ts_meta_min_1, compress_hyper_2_52_chunk._ts_meta_max_1, compress_hyper_2_52_chunk."time", compress_hyper_2_52_chunk.int_value, compress_hyper_2_52_chunk.float_value Index Cond: (compress_hyper_2_52_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_43_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_43_chunk Output: _hyper_1_43_chunk.int_value -> Parallel Index Scan using compress_hyper_2_53_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_53_chunk Output: compress_hyper_2_53_chunk._ts_meta_count, compress_hyper_2_53_chunk.segment_by_value, compress_hyper_2_53_chunk._ts_meta_min_1, compress_hyper_2_53_chunk._ts_meta_max_1, compress_hyper_2_53_chunk."time", compress_hyper_2_53_chunk.int_value, compress_hyper_2_53_chunk.float_value Index Cond: (compress_hyper_2_53_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_44_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_44_chunk Output: _hyper_1_44_chunk.int_value -> Parallel Index Scan using compress_hyper_2_54_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_54_chunk Output: compress_hyper_2_54_chunk._ts_meta_count, compress_hyper_2_54_chunk.segment_by_value, compress_hyper_2_54_chunk._ts_meta_min_1, compress_hyper_2_54_chunk._ts_meta_max_1, compress_hyper_2_54_chunk."time", compress_hyper_2_54_chunk.int_value, compress_hyper_2_54_chunk.float_value Index Cond: (compress_hyper_2_54_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_45_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_45_chunk Output: _hyper_1_45_chunk.int_value -> Parallel Index Scan using compress_hyper_2_55_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_55_chunk Output: compress_hyper_2_55_chunk._ts_meta_count, compress_hyper_2_55_chunk.segment_by_value, compress_hyper_2_55_chunk._ts_meta_min_1, compress_hyper_2_55_chunk._ts_meta_max_1, compress_hyper_2_55_chunk."time", compress_hyper_2_55_chunk.int_value, compress_hyper_2_55_chunk.float_value Index Cond: (compress_hyper_2_55_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_46_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_46_chunk Output: _hyper_1_46_chunk.int_value -> Parallel Index Scan using compress_hyper_2_56_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_56_chunk Output: compress_hyper_2_56_chunk._ts_meta_count, compress_hyper_2_56_chunk.segment_by_value, compress_hyper_2_56_chunk._ts_meta_min_1, compress_hyper_2_56_chunk._ts_meta_max_1, compress_hyper_2_56_chunk."time", compress_hyper_2_56_chunk.int_value, compress_hyper_2_56_chunk.float_value Index Cond: (compress_hyper_2_56_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_47_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_47_chunk Output: _hyper_1_47_chunk.int_value -> Parallel Index Scan using compress_hyper_2_57_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_57_chunk Output: compress_hyper_2_57_chunk._ts_meta_count, compress_hyper_2_57_chunk.segment_by_value, compress_hyper_2_57_chunk._ts_meta_min_1, compress_hyper_2_57_chunk._ts_meta_max_1, compress_hyper_2_57_chunk."time", compress_hyper_2_57_chunk.int_value, compress_hyper_2_57_chunk.float_value Index Cond: (compress_hyper_2_57_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_48_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_48_chunk Output: _hyper_1_48_chunk.int_value -> Parallel Index Scan using compress_hyper_2_58_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_58_chunk Output: compress_hyper_2_58_chunk._ts_meta_count, compress_hyper_2_58_chunk.segment_by_value, compress_hyper_2_58_chunk._ts_meta_min_1, compress_hyper_2_58_chunk._ts_meta_max_1, compress_hyper_2_58_chunk."time", compress_hyper_2_58_chunk.int_value, compress_hyper_2_58_chunk.float_value Index Cond: (compress_hyper_2_58_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_49_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_49_chunk Output: _hyper_1_49_chunk.int_value -> Parallel Index Scan using compress_hyper_2_59_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_59_chunk Output: compress_hyper_2_59_chunk._ts_meta_count, compress_hyper_2_59_chunk.segment_by_value, compress_hyper_2_59_chunk._ts_meta_min_1, compress_hyper_2_59_chunk._ts_meta_max_1, compress_hyper_2_59_chunk."time", compress_hyper_2_59_chunk.int_value, compress_hyper_2_59_chunk.float_value Index Cond: (compress_hyper_2_59_chunk.segment_by_value > 5) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_50_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_50_chunk Output: _hyper_1_50_chunk.int_value -> Parallel Index Scan using compress_hyper_2_60_chunk_segment_by_value__ts_meta_min_1___idx on _timescaledb_internal.compress_hyper_2_60_chunk Output: compress_hyper_2_60_chunk._ts_meta_count, compress_hyper_2_60_chunk.segment_by_value, compress_hyper_2_60_chunk._ts_meta_min_1, compress_hyper_2_60_chunk._ts_meta_max_1, compress_hyper_2_60_chunk."time", compress_hyper_2_60_chunk.int_value, compress_hyper_2_60_chunk.float_value Index Cond: (compress_hyper_2_60_chunk.segment_by_value > 5) SELECT sum(int_value) FROM testtable WHERE segment_by_value > 5; sum ------ 2440 SET timescaledb.enable_vectorized_aggregation = OFF; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 5; sum ------ 2440 RESET timescaledb.enable_vectorized_aggregation; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 10; sum ----- SET timescaledb.enable_vectorized_aggregation = OFF; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 10; sum ----- RESET timescaledb.enable_vectorized_aggregation; --- -- Tests with parallel plans --- SET parallel_leader_participation = off; SET min_parallel_table_scan_size = 0; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; :EXPLAIN SELECT sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Gather Output: (PARTIAL sum(testtable.segment_by_value)) Workers Planned: 2 -> Parallel Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_41_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_41_chunk Output: _hyper_1_41_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_51_chunk Output: compress_hyper_2_51_chunk._ts_meta_count, compress_hyper_2_51_chunk.segment_by_value, compress_hyper_2_51_chunk._ts_meta_min_1, compress_hyper_2_51_chunk._ts_meta_max_1, compress_hyper_2_51_chunk."time", compress_hyper_2_51_chunk.int_value, compress_hyper_2_51_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_42_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_42_chunk Output: _hyper_1_42_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_52_chunk Output: compress_hyper_2_52_chunk._ts_meta_count, compress_hyper_2_52_chunk.segment_by_value, compress_hyper_2_52_chunk._ts_meta_min_1, compress_hyper_2_52_chunk._ts_meta_max_1, compress_hyper_2_52_chunk."time", compress_hyper_2_52_chunk.int_value, compress_hyper_2_52_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_43_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_43_chunk Output: _hyper_1_43_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_53_chunk Output: compress_hyper_2_53_chunk._ts_meta_count, compress_hyper_2_53_chunk.segment_by_value, compress_hyper_2_53_chunk._ts_meta_min_1, compress_hyper_2_53_chunk._ts_meta_max_1, compress_hyper_2_53_chunk."time", compress_hyper_2_53_chunk.int_value, compress_hyper_2_53_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_44_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_44_chunk Output: _hyper_1_44_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_54_chunk Output: compress_hyper_2_54_chunk._ts_meta_count, compress_hyper_2_54_chunk.segment_by_value, compress_hyper_2_54_chunk._ts_meta_min_1, compress_hyper_2_54_chunk._ts_meta_max_1, compress_hyper_2_54_chunk."time", compress_hyper_2_54_chunk.int_value, compress_hyper_2_54_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_45_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_45_chunk Output: _hyper_1_45_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_55_chunk Output: compress_hyper_2_55_chunk._ts_meta_count, compress_hyper_2_55_chunk.segment_by_value, compress_hyper_2_55_chunk._ts_meta_min_1, compress_hyper_2_55_chunk._ts_meta_max_1, compress_hyper_2_55_chunk."time", compress_hyper_2_55_chunk.int_value, compress_hyper_2_55_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_46_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_46_chunk Output: _hyper_1_46_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_56_chunk Output: compress_hyper_2_56_chunk._ts_meta_count, compress_hyper_2_56_chunk.segment_by_value, compress_hyper_2_56_chunk._ts_meta_min_1, compress_hyper_2_56_chunk._ts_meta_max_1, compress_hyper_2_56_chunk."time", compress_hyper_2_56_chunk.int_value, compress_hyper_2_56_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_47_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_47_chunk Output: _hyper_1_47_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_57_chunk Output: compress_hyper_2_57_chunk._ts_meta_count, compress_hyper_2_57_chunk.segment_by_value, compress_hyper_2_57_chunk._ts_meta_min_1, compress_hyper_2_57_chunk._ts_meta_max_1, compress_hyper_2_57_chunk."time", compress_hyper_2_57_chunk.int_value, compress_hyper_2_57_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_48_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_48_chunk Output: _hyper_1_48_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_58_chunk Output: compress_hyper_2_58_chunk._ts_meta_count, compress_hyper_2_58_chunk.segment_by_value, compress_hyper_2_58_chunk._ts_meta_min_1, compress_hyper_2_58_chunk._ts_meta_max_1, compress_hyper_2_58_chunk."time", compress_hyper_2_58_chunk.int_value, compress_hyper_2_58_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_49_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_49_chunk Output: _hyper_1_49_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_59_chunk Output: compress_hyper_2_59_chunk._ts_meta_count, compress_hyper_2_59_chunk.segment_by_value, compress_hyper_2_59_chunk._ts_meta_min_1, compress_hyper_2_59_chunk._ts_meta_max_1, compress_hyper_2_59_chunk."time", compress_hyper_2_59_chunk.int_value, compress_hyper_2_59_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_50_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_50_chunk Output: _hyper_1_50_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_60_chunk Output: compress_hyper_2_60_chunk._ts_meta_count, compress_hyper_2_60_chunk.segment_by_value, compress_hyper_2_60_chunk._ts_meta_min_1, compress_hyper_2_60_chunk._ts_meta_max_1, compress_hyper_2_60_chunk."time", compress_hyper_2_60_chunk.int_value, compress_hyper_2_60_chunk.float_value SELECT sum(segment_by_value) FROM testtable; sum ------ 3355 RESET parallel_leader_participation; RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; --- -- Tests with only zero values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, 0 AS segment_by_value, 0 AS int_value, 0 AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; sum | sum | sum -----+-----+----- 0 | 0 | 0 SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_61_chunk _timescaledb_internal._hyper_1_62_chunk _timescaledb_internal._hyper_1_63_chunk _timescaledb_internal._hyper_1_64_chunk _timescaledb_internal._hyper_1_65_chunk _timescaledb_internal._hyper_1_66_chunk _timescaledb_internal._hyper_1_67_chunk _timescaledb_internal._hyper_1_68_chunk _timescaledb_internal._hyper_1_69_chunk _timescaledb_internal._hyper_1_70_chunk -- Aggregation with vectorization SELECT sum(segment_by_value) FROM testtable; sum ----- 0 SELECT sum(int_value) FROM testtable; sum ----- 0 --- -- Tests with null values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 10, 1) AS g2(value) ORDER BY time; -- NULL values for compressed data INSERT INTO testtable SELECT time AS time, value AS segment_by_value, NULL AS int_value, NULL AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 5, 1) AS g2(value) ORDER BY time; -- NULL values for segment_by INSERT INTO testtable SELECT time AS time, NULL AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 2, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; sum | sum | sum ------+------+------ 4270 | 3538 | 3538 SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; compress_chunk ----------------------------------------- _timescaledb_internal._hyper_1_81_chunk _timescaledb_internal._hyper_1_82_chunk _timescaledb_internal._hyper_1_83_chunk _timescaledb_internal._hyper_1_84_chunk _timescaledb_internal._hyper_1_85_chunk _timescaledb_internal._hyper_1_86_chunk _timescaledb_internal._hyper_1_87_chunk _timescaledb_internal._hyper_1_88_chunk _timescaledb_internal._hyper_1_89_chunk _timescaledb_internal._hyper_1_90_chunk -- Aggregation with vectorization :EXPLAIN SELECT sum(segment_by_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) -> Gather Output: (PARTIAL sum(testtable.segment_by_value)) Workers Planned: 2 -> Parallel Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_81_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_81_chunk Output: _hyper_1_81_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_91_chunk Output: compress_hyper_2_91_chunk._ts_meta_count, compress_hyper_2_91_chunk.segment_by_value, compress_hyper_2_91_chunk._ts_meta_min_1, compress_hyper_2_91_chunk._ts_meta_max_1, compress_hyper_2_91_chunk."time", compress_hyper_2_91_chunk.int_value, compress_hyper_2_91_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_82_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_82_chunk Output: _hyper_1_82_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_92_chunk Output: compress_hyper_2_92_chunk._ts_meta_count, compress_hyper_2_92_chunk.segment_by_value, compress_hyper_2_92_chunk._ts_meta_min_1, compress_hyper_2_92_chunk._ts_meta_max_1, compress_hyper_2_92_chunk."time", compress_hyper_2_92_chunk.int_value, compress_hyper_2_92_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_83_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_83_chunk Output: _hyper_1_83_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_93_chunk Output: compress_hyper_2_93_chunk._ts_meta_count, compress_hyper_2_93_chunk.segment_by_value, compress_hyper_2_93_chunk._ts_meta_min_1, compress_hyper_2_93_chunk._ts_meta_max_1, compress_hyper_2_93_chunk."time", compress_hyper_2_93_chunk.int_value, compress_hyper_2_93_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_84_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_84_chunk Output: _hyper_1_84_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_94_chunk Output: compress_hyper_2_94_chunk._ts_meta_count, compress_hyper_2_94_chunk.segment_by_value, compress_hyper_2_94_chunk._ts_meta_min_1, compress_hyper_2_94_chunk._ts_meta_max_1, compress_hyper_2_94_chunk."time", compress_hyper_2_94_chunk.int_value, compress_hyper_2_94_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_85_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_85_chunk Output: _hyper_1_85_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_95_chunk Output: compress_hyper_2_95_chunk._ts_meta_count, compress_hyper_2_95_chunk.segment_by_value, compress_hyper_2_95_chunk._ts_meta_min_1, compress_hyper_2_95_chunk._ts_meta_max_1, compress_hyper_2_95_chunk."time", compress_hyper_2_95_chunk.int_value, compress_hyper_2_95_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_86_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_86_chunk Output: _hyper_1_86_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_96_chunk Output: compress_hyper_2_96_chunk._ts_meta_count, compress_hyper_2_96_chunk.segment_by_value, compress_hyper_2_96_chunk._ts_meta_min_1, compress_hyper_2_96_chunk._ts_meta_max_1, compress_hyper_2_96_chunk."time", compress_hyper_2_96_chunk.int_value, compress_hyper_2_96_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_87_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_87_chunk Output: _hyper_1_87_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_97_chunk Output: compress_hyper_2_97_chunk._ts_meta_count, compress_hyper_2_97_chunk.segment_by_value, compress_hyper_2_97_chunk._ts_meta_min_1, compress_hyper_2_97_chunk._ts_meta_max_1, compress_hyper_2_97_chunk."time", compress_hyper_2_97_chunk.int_value, compress_hyper_2_97_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_88_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_88_chunk Output: _hyper_1_88_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_98_chunk Output: compress_hyper_2_98_chunk._ts_meta_count, compress_hyper_2_98_chunk.segment_by_value, compress_hyper_2_98_chunk._ts_meta_min_1, compress_hyper_2_98_chunk._ts_meta_max_1, compress_hyper_2_98_chunk."time", compress_hyper_2_98_chunk.int_value, compress_hyper_2_98_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_89_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_89_chunk Output: _hyper_1_89_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_99_chunk Output: compress_hyper_2_99_chunk._ts_meta_count, compress_hyper_2_99_chunk.segment_by_value, compress_hyper_2_99_chunk._ts_meta_min_1, compress_hyper_2_99_chunk._ts_meta_max_1, compress_hyper_2_99_chunk."time", compress_hyper_2_99_chunk.int_value, compress_hyper_2_99_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_90_chunk.segment_by_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_90_chunk Output: _hyper_1_90_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_100_chunk Output: compress_hyper_2_100_chunk._ts_meta_count, compress_hyper_2_100_chunk.segment_by_value, compress_hyper_2_100_chunk._ts_meta_min_1, compress_hyper_2_100_chunk._ts_meta_max_1, compress_hyper_2_100_chunk."time", compress_hyper_2_100_chunk.int_value, compress_hyper_2_100_chunk.float_value :EXPLAIN SELECT sum(int_value) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.int_value) -> Gather Output: (PARTIAL sum(testtable.int_value)) Workers Planned: 2 -> Parallel Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_81_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_81_chunk Output: _hyper_1_81_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_91_chunk Output: compress_hyper_2_91_chunk._ts_meta_count, compress_hyper_2_91_chunk.segment_by_value, compress_hyper_2_91_chunk._ts_meta_min_1, compress_hyper_2_91_chunk._ts_meta_max_1, compress_hyper_2_91_chunk."time", compress_hyper_2_91_chunk.int_value, compress_hyper_2_91_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_82_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_82_chunk Output: _hyper_1_82_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_92_chunk Output: compress_hyper_2_92_chunk._ts_meta_count, compress_hyper_2_92_chunk.segment_by_value, compress_hyper_2_92_chunk._ts_meta_min_1, compress_hyper_2_92_chunk._ts_meta_max_1, compress_hyper_2_92_chunk."time", compress_hyper_2_92_chunk.int_value, compress_hyper_2_92_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_83_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_83_chunk Output: _hyper_1_83_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_93_chunk Output: compress_hyper_2_93_chunk._ts_meta_count, compress_hyper_2_93_chunk.segment_by_value, compress_hyper_2_93_chunk._ts_meta_min_1, compress_hyper_2_93_chunk._ts_meta_max_1, compress_hyper_2_93_chunk."time", compress_hyper_2_93_chunk.int_value, compress_hyper_2_93_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_84_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_84_chunk Output: _hyper_1_84_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_94_chunk Output: compress_hyper_2_94_chunk._ts_meta_count, compress_hyper_2_94_chunk.segment_by_value, compress_hyper_2_94_chunk._ts_meta_min_1, compress_hyper_2_94_chunk._ts_meta_max_1, compress_hyper_2_94_chunk."time", compress_hyper_2_94_chunk.int_value, compress_hyper_2_94_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_85_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_85_chunk Output: _hyper_1_85_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_95_chunk Output: compress_hyper_2_95_chunk._ts_meta_count, compress_hyper_2_95_chunk.segment_by_value, compress_hyper_2_95_chunk._ts_meta_min_1, compress_hyper_2_95_chunk._ts_meta_max_1, compress_hyper_2_95_chunk."time", compress_hyper_2_95_chunk.int_value, compress_hyper_2_95_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_86_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_86_chunk Output: _hyper_1_86_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_96_chunk Output: compress_hyper_2_96_chunk._ts_meta_count, compress_hyper_2_96_chunk.segment_by_value, compress_hyper_2_96_chunk._ts_meta_min_1, compress_hyper_2_96_chunk._ts_meta_max_1, compress_hyper_2_96_chunk."time", compress_hyper_2_96_chunk.int_value, compress_hyper_2_96_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_87_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_87_chunk Output: _hyper_1_87_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_97_chunk Output: compress_hyper_2_97_chunk._ts_meta_count, compress_hyper_2_97_chunk.segment_by_value, compress_hyper_2_97_chunk._ts_meta_min_1, compress_hyper_2_97_chunk._ts_meta_max_1, compress_hyper_2_97_chunk."time", compress_hyper_2_97_chunk.int_value, compress_hyper_2_97_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_88_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_88_chunk Output: _hyper_1_88_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_98_chunk Output: compress_hyper_2_98_chunk._ts_meta_count, compress_hyper_2_98_chunk.segment_by_value, compress_hyper_2_98_chunk._ts_meta_min_1, compress_hyper_2_98_chunk._ts_meta_max_1, compress_hyper_2_98_chunk."time", compress_hyper_2_98_chunk.int_value, compress_hyper_2_98_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_89_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_89_chunk Output: _hyper_1_89_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_99_chunk Output: compress_hyper_2_99_chunk._ts_meta_count, compress_hyper_2_99_chunk.segment_by_value, compress_hyper_2_99_chunk._ts_meta_min_1, compress_hyper_2_99_chunk._ts_meta_max_1, compress_hyper_2_99_chunk."time", compress_hyper_2_99_chunk.int_value, compress_hyper_2_99_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_90_chunk.int_value)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_90_chunk Output: _hyper_1_90_chunk.int_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_100_chunk Output: compress_hyper_2_100_chunk._ts_meta_count, compress_hyper_2_100_chunk.segment_by_value, compress_hyper_2_100_chunk._ts_meta_min_1, compress_hyper_2_100_chunk._ts_meta_max_1, compress_hyper_2_100_chunk."time", compress_hyper_2_100_chunk.int_value, compress_hyper_2_100_chunk.float_value SELECT sum(segment_by_value) FROM testtable; sum ------ 4270 SELECT sum(int_value) FROM testtable; sum ------ 3538 -- Vectorizable aggregation filters are supported :EXPLAIN SELECT sum(segment_by_value) FILTER (WHERE segment_by_value > 99999) FROM testtable; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable.segment_by_value) FILTER (WHERE (testtable.segment_by_value > 99999)) -> Gather Output: (PARTIAL sum(testtable.segment_by_value) FILTER (WHERE (testtable.segment_by_value > 99999))) Workers Planned: 2 -> Parallel Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_81_chunk.segment_by_value) FILTER (WHERE (_hyper_1_81_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_81_chunk Output: _hyper_1_81_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_91_chunk Output: compress_hyper_2_91_chunk._ts_meta_count, compress_hyper_2_91_chunk.segment_by_value, compress_hyper_2_91_chunk._ts_meta_min_1, compress_hyper_2_91_chunk._ts_meta_max_1, compress_hyper_2_91_chunk."time", compress_hyper_2_91_chunk.int_value, compress_hyper_2_91_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_82_chunk.segment_by_value) FILTER (WHERE (_hyper_1_82_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_82_chunk Output: _hyper_1_82_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_92_chunk Output: compress_hyper_2_92_chunk._ts_meta_count, compress_hyper_2_92_chunk.segment_by_value, compress_hyper_2_92_chunk._ts_meta_min_1, compress_hyper_2_92_chunk._ts_meta_max_1, compress_hyper_2_92_chunk."time", compress_hyper_2_92_chunk.int_value, compress_hyper_2_92_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_83_chunk.segment_by_value) FILTER (WHERE (_hyper_1_83_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_83_chunk Output: _hyper_1_83_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_93_chunk Output: compress_hyper_2_93_chunk._ts_meta_count, compress_hyper_2_93_chunk.segment_by_value, compress_hyper_2_93_chunk._ts_meta_min_1, compress_hyper_2_93_chunk._ts_meta_max_1, compress_hyper_2_93_chunk."time", compress_hyper_2_93_chunk.int_value, compress_hyper_2_93_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_84_chunk.segment_by_value) FILTER (WHERE (_hyper_1_84_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_84_chunk Output: _hyper_1_84_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_94_chunk Output: compress_hyper_2_94_chunk._ts_meta_count, compress_hyper_2_94_chunk.segment_by_value, compress_hyper_2_94_chunk._ts_meta_min_1, compress_hyper_2_94_chunk._ts_meta_max_1, compress_hyper_2_94_chunk."time", compress_hyper_2_94_chunk.int_value, compress_hyper_2_94_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_85_chunk.segment_by_value) FILTER (WHERE (_hyper_1_85_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_85_chunk Output: _hyper_1_85_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_95_chunk Output: compress_hyper_2_95_chunk._ts_meta_count, compress_hyper_2_95_chunk.segment_by_value, compress_hyper_2_95_chunk._ts_meta_min_1, compress_hyper_2_95_chunk._ts_meta_max_1, compress_hyper_2_95_chunk."time", compress_hyper_2_95_chunk.int_value, compress_hyper_2_95_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_86_chunk.segment_by_value) FILTER (WHERE (_hyper_1_86_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_86_chunk Output: _hyper_1_86_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_96_chunk Output: compress_hyper_2_96_chunk._ts_meta_count, compress_hyper_2_96_chunk.segment_by_value, compress_hyper_2_96_chunk._ts_meta_min_1, compress_hyper_2_96_chunk._ts_meta_max_1, compress_hyper_2_96_chunk."time", compress_hyper_2_96_chunk.int_value, compress_hyper_2_96_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_87_chunk.segment_by_value) FILTER (WHERE (_hyper_1_87_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_87_chunk Output: _hyper_1_87_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_97_chunk Output: compress_hyper_2_97_chunk._ts_meta_count, compress_hyper_2_97_chunk.segment_by_value, compress_hyper_2_97_chunk._ts_meta_min_1, compress_hyper_2_97_chunk._ts_meta_max_1, compress_hyper_2_97_chunk."time", compress_hyper_2_97_chunk.int_value, compress_hyper_2_97_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_88_chunk.segment_by_value) FILTER (WHERE (_hyper_1_88_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_88_chunk Output: _hyper_1_88_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_98_chunk Output: compress_hyper_2_98_chunk._ts_meta_count, compress_hyper_2_98_chunk.segment_by_value, compress_hyper_2_98_chunk._ts_meta_min_1, compress_hyper_2_98_chunk._ts_meta_max_1, compress_hyper_2_98_chunk."time", compress_hyper_2_98_chunk.int_value, compress_hyper_2_98_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_89_chunk.segment_by_value) FILTER (WHERE (_hyper_1_89_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_89_chunk Output: _hyper_1_89_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_99_chunk Output: compress_hyper_2_99_chunk._ts_meta_count, compress_hyper_2_99_chunk.segment_by_value, compress_hyper_2_99_chunk._ts_meta_min_1, compress_hyper_2_99_chunk._ts_meta_max_1, compress_hyper_2_99_chunk."time", compress_hyper_2_99_chunk.int_value, compress_hyper_2_99_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_1_90_chunk.segment_by_value) FILTER (WHERE (_hyper_1_90_chunk.segment_by_value > 99999))) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_1_90_chunk Output: _hyper_1_90_chunk.segment_by_value -> Parallel Seq Scan on _timescaledb_internal.compress_hyper_2_100_chunk Output: compress_hyper_2_100_chunk._ts_meta_count, compress_hyper_2_100_chunk.segment_by_value, compress_hyper_2_100_chunk._ts_meta_min_1, compress_hyper_2_100_chunk._ts_meta_max_1, compress_hyper_2_100_chunk."time", compress_hyper_2_100_chunk.int_value, compress_hyper_2_100_chunk.float_value SET timescaledb.enable_vectorized_aggregation = OFF; SELECT sum(segment_by_value) FILTER (WHERE segment_by_value > 99999) FROM testtable; sum ----- RESET timescaledb.enable_vectorized_aggregation; SELECT sum(segment_by_value) FILTER (WHERE segment_by_value > 99999) FROM testtable; sum ----- --- -- Tests with multiple segment by values --- CREATE TABLE testtable2 ( time timestamptz NOT NULL, segment_by_value1 integer NOT NULL, segment_by_value2 integer NOT NULL, int_value integer NOT NULL, float_value double precision NOT NULL); SELECT FROM create_hypertable(relation=>'testtable2', time_column_name=> 'time'); -- ALTER TABLE testtable2 SET (timescaledb.compress, timescaledb.compress_segmentby='segment_by_value1, segment_by_value2'); INSERT INTO testtable2 SELECT time AS time, value1 AS segment_by_value1, value2 AS segment_by_value2, value1 AS int_value, value1 AS float_value FROM generate_series('1980-01-03 00:00:00-00', '1980-03-04 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(-10, 25, 1) AS g2(value1), generate_series(-30, 20, 1) AS g3(value2) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value1), sum(segment_by_value2) FROM testtable2; sum | sum --------+--------- 853740 | -569160 SELECT compress_chunk(ch) FROM show_chunks('testtable2') ch; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_3_101_chunk _timescaledb_internal._hyper_3_102_chunk _timescaledb_internal._hyper_3_103_chunk _timescaledb_internal._hyper_3_104_chunk _timescaledb_internal._hyper_3_105_chunk _timescaledb_internal._hyper_3_106_chunk _timescaledb_internal._hyper_3_107_chunk _timescaledb_internal._hyper_3_108_chunk _timescaledb_internal._hyper_3_109_chunk ANALYZE testtable2; :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable2.segment_by_value1) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_101_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_101_chunk Output: _hyper_3_101_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_110_chunk Output: compress_hyper_4_110_chunk._ts_meta_count, compress_hyper_4_110_chunk.segment_by_value1, compress_hyper_4_110_chunk.segment_by_value2, compress_hyper_4_110_chunk._ts_meta_min_1, compress_hyper_4_110_chunk._ts_meta_max_1, compress_hyper_4_110_chunk."time", compress_hyper_4_110_chunk.int_value, compress_hyper_4_110_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_102_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_102_chunk Output: _hyper_3_102_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_111_chunk Output: compress_hyper_4_111_chunk._ts_meta_count, compress_hyper_4_111_chunk.segment_by_value1, compress_hyper_4_111_chunk.segment_by_value2, compress_hyper_4_111_chunk._ts_meta_min_1, compress_hyper_4_111_chunk._ts_meta_max_1, compress_hyper_4_111_chunk."time", compress_hyper_4_111_chunk.int_value, compress_hyper_4_111_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_103_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_103_chunk Output: _hyper_3_103_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_112_chunk Output: compress_hyper_4_112_chunk._ts_meta_count, compress_hyper_4_112_chunk.segment_by_value1, compress_hyper_4_112_chunk.segment_by_value2, compress_hyper_4_112_chunk._ts_meta_min_1, compress_hyper_4_112_chunk._ts_meta_max_1, compress_hyper_4_112_chunk."time", compress_hyper_4_112_chunk.int_value, compress_hyper_4_112_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_104_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_104_chunk Output: _hyper_3_104_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_113_chunk Output: compress_hyper_4_113_chunk._ts_meta_count, compress_hyper_4_113_chunk.segment_by_value1, compress_hyper_4_113_chunk.segment_by_value2, compress_hyper_4_113_chunk._ts_meta_min_1, compress_hyper_4_113_chunk._ts_meta_max_1, compress_hyper_4_113_chunk."time", compress_hyper_4_113_chunk.int_value, compress_hyper_4_113_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_105_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_105_chunk Output: _hyper_3_105_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_114_chunk Output: compress_hyper_4_114_chunk._ts_meta_count, compress_hyper_4_114_chunk.segment_by_value1, compress_hyper_4_114_chunk.segment_by_value2, compress_hyper_4_114_chunk._ts_meta_min_1, compress_hyper_4_114_chunk._ts_meta_max_1, compress_hyper_4_114_chunk."time", compress_hyper_4_114_chunk.int_value, compress_hyper_4_114_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_106_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_106_chunk Output: _hyper_3_106_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_115_chunk Output: compress_hyper_4_115_chunk._ts_meta_count, compress_hyper_4_115_chunk.segment_by_value1, compress_hyper_4_115_chunk.segment_by_value2, compress_hyper_4_115_chunk._ts_meta_min_1, compress_hyper_4_115_chunk._ts_meta_max_1, compress_hyper_4_115_chunk."time", compress_hyper_4_115_chunk.int_value, compress_hyper_4_115_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_107_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_107_chunk Output: _hyper_3_107_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_116_chunk Output: compress_hyper_4_116_chunk._ts_meta_count, compress_hyper_4_116_chunk.segment_by_value1, compress_hyper_4_116_chunk.segment_by_value2, compress_hyper_4_116_chunk._ts_meta_min_1, compress_hyper_4_116_chunk._ts_meta_max_1, compress_hyper_4_116_chunk."time", compress_hyper_4_116_chunk.int_value, compress_hyper_4_116_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_108_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_108_chunk Output: _hyper_3_108_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_117_chunk Output: compress_hyper_4_117_chunk._ts_meta_count, compress_hyper_4_117_chunk.segment_by_value1, compress_hyper_4_117_chunk.segment_by_value2, compress_hyper_4_117_chunk._ts_meta_min_1, compress_hyper_4_117_chunk._ts_meta_max_1, compress_hyper_4_117_chunk."time", compress_hyper_4_117_chunk.int_value, compress_hyper_4_117_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_109_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_109_chunk Output: _hyper_3_109_chunk.segment_by_value1 -> Seq Scan on _timescaledb_internal.compress_hyper_4_118_chunk Output: compress_hyper_4_118_chunk._ts_meta_count, compress_hyper_4_118_chunk.segment_by_value1, compress_hyper_4_118_chunk.segment_by_value2, compress_hyper_4_118_chunk._ts_meta_min_1, compress_hyper_4_118_chunk._ts_meta_max_1, compress_hyper_4_118_chunk."time", compress_hyper_4_118_chunk.int_value, compress_hyper_4_118_chunk.float_value SELECT sum(segment_by_value1) FROM testtable2; sum -------- 853740 :EXPLAIN SELECT sum(segment_by_value2) FROM testtable2; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable2.segment_by_value2) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_101_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_101_chunk Output: _hyper_3_101_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_110_chunk Output: compress_hyper_4_110_chunk._ts_meta_count, compress_hyper_4_110_chunk.segment_by_value1, compress_hyper_4_110_chunk.segment_by_value2, compress_hyper_4_110_chunk._ts_meta_min_1, compress_hyper_4_110_chunk._ts_meta_max_1, compress_hyper_4_110_chunk."time", compress_hyper_4_110_chunk.int_value, compress_hyper_4_110_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_102_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_102_chunk Output: _hyper_3_102_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_111_chunk Output: compress_hyper_4_111_chunk._ts_meta_count, compress_hyper_4_111_chunk.segment_by_value1, compress_hyper_4_111_chunk.segment_by_value2, compress_hyper_4_111_chunk._ts_meta_min_1, compress_hyper_4_111_chunk._ts_meta_max_1, compress_hyper_4_111_chunk."time", compress_hyper_4_111_chunk.int_value, compress_hyper_4_111_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_103_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_103_chunk Output: _hyper_3_103_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_112_chunk Output: compress_hyper_4_112_chunk._ts_meta_count, compress_hyper_4_112_chunk.segment_by_value1, compress_hyper_4_112_chunk.segment_by_value2, compress_hyper_4_112_chunk._ts_meta_min_1, compress_hyper_4_112_chunk._ts_meta_max_1, compress_hyper_4_112_chunk."time", compress_hyper_4_112_chunk.int_value, compress_hyper_4_112_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_104_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_104_chunk Output: _hyper_3_104_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_113_chunk Output: compress_hyper_4_113_chunk._ts_meta_count, compress_hyper_4_113_chunk.segment_by_value1, compress_hyper_4_113_chunk.segment_by_value2, compress_hyper_4_113_chunk._ts_meta_min_1, compress_hyper_4_113_chunk._ts_meta_max_1, compress_hyper_4_113_chunk."time", compress_hyper_4_113_chunk.int_value, compress_hyper_4_113_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_105_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_105_chunk Output: _hyper_3_105_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_114_chunk Output: compress_hyper_4_114_chunk._ts_meta_count, compress_hyper_4_114_chunk.segment_by_value1, compress_hyper_4_114_chunk.segment_by_value2, compress_hyper_4_114_chunk._ts_meta_min_1, compress_hyper_4_114_chunk._ts_meta_max_1, compress_hyper_4_114_chunk."time", compress_hyper_4_114_chunk.int_value, compress_hyper_4_114_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_106_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_106_chunk Output: _hyper_3_106_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_115_chunk Output: compress_hyper_4_115_chunk._ts_meta_count, compress_hyper_4_115_chunk.segment_by_value1, compress_hyper_4_115_chunk.segment_by_value2, compress_hyper_4_115_chunk._ts_meta_min_1, compress_hyper_4_115_chunk._ts_meta_max_1, compress_hyper_4_115_chunk."time", compress_hyper_4_115_chunk.int_value, compress_hyper_4_115_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_107_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_107_chunk Output: _hyper_3_107_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_116_chunk Output: compress_hyper_4_116_chunk._ts_meta_count, compress_hyper_4_116_chunk.segment_by_value1, compress_hyper_4_116_chunk.segment_by_value2, compress_hyper_4_116_chunk._ts_meta_min_1, compress_hyper_4_116_chunk._ts_meta_max_1, compress_hyper_4_116_chunk."time", compress_hyper_4_116_chunk.int_value, compress_hyper_4_116_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_108_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_108_chunk Output: _hyper_3_108_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_117_chunk Output: compress_hyper_4_117_chunk._ts_meta_count, compress_hyper_4_117_chunk.segment_by_value1, compress_hyper_4_117_chunk.segment_by_value2, compress_hyper_4_117_chunk._ts_meta_min_1, compress_hyper_4_117_chunk._ts_meta_max_1, compress_hyper_4_117_chunk."time", compress_hyper_4_117_chunk.int_value, compress_hyper_4_117_chunk.float_value -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_109_chunk.segment_by_value2)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_109_chunk Output: _hyper_3_109_chunk.segment_by_value2 -> Seq Scan on _timescaledb_internal.compress_hyper_4_118_chunk Output: compress_hyper_4_118_chunk._ts_meta_count, compress_hyper_4_118_chunk.segment_by_value1, compress_hyper_4_118_chunk.segment_by_value2, compress_hyper_4_118_chunk._ts_meta_min_1, compress_hyper_4_118_chunk._ts_meta_max_1, compress_hyper_4_118_chunk."time", compress_hyper_4_118_chunk.int_value, compress_hyper_4_118_chunk.float_value SELECT sum(segment_by_value2) FROM testtable2; sum --------- -569160 -- Vectorization possible - filter on segment_by :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 0; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable2.segment_by_value1) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_101_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_101_chunk Output: _hyper_3_101_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_110_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_110_chunk Output: compress_hyper_4_110_chunk._ts_meta_count, compress_hyper_4_110_chunk.segment_by_value1, compress_hyper_4_110_chunk.segment_by_value2, compress_hyper_4_110_chunk._ts_meta_min_1, compress_hyper_4_110_chunk._ts_meta_max_1, compress_hyper_4_110_chunk."time", compress_hyper_4_110_chunk.int_value, compress_hyper_4_110_chunk.float_value Index Cond: (compress_hyper_4_110_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_102_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_102_chunk Output: _hyper_3_102_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_111_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_111_chunk Output: compress_hyper_4_111_chunk._ts_meta_count, compress_hyper_4_111_chunk.segment_by_value1, compress_hyper_4_111_chunk.segment_by_value2, compress_hyper_4_111_chunk._ts_meta_min_1, compress_hyper_4_111_chunk._ts_meta_max_1, compress_hyper_4_111_chunk."time", compress_hyper_4_111_chunk.int_value, compress_hyper_4_111_chunk.float_value Index Cond: (compress_hyper_4_111_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_103_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_103_chunk Output: _hyper_3_103_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_112_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_112_chunk Output: compress_hyper_4_112_chunk._ts_meta_count, compress_hyper_4_112_chunk.segment_by_value1, compress_hyper_4_112_chunk.segment_by_value2, compress_hyper_4_112_chunk._ts_meta_min_1, compress_hyper_4_112_chunk._ts_meta_max_1, compress_hyper_4_112_chunk."time", compress_hyper_4_112_chunk.int_value, compress_hyper_4_112_chunk.float_value Index Cond: (compress_hyper_4_112_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_104_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_104_chunk Output: _hyper_3_104_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_113_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_113_chunk Output: compress_hyper_4_113_chunk._ts_meta_count, compress_hyper_4_113_chunk.segment_by_value1, compress_hyper_4_113_chunk.segment_by_value2, compress_hyper_4_113_chunk._ts_meta_min_1, compress_hyper_4_113_chunk._ts_meta_max_1, compress_hyper_4_113_chunk."time", compress_hyper_4_113_chunk.int_value, compress_hyper_4_113_chunk.float_value Index Cond: (compress_hyper_4_113_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_105_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_105_chunk Output: _hyper_3_105_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_114_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_114_chunk Output: compress_hyper_4_114_chunk._ts_meta_count, compress_hyper_4_114_chunk.segment_by_value1, compress_hyper_4_114_chunk.segment_by_value2, compress_hyper_4_114_chunk._ts_meta_min_1, compress_hyper_4_114_chunk._ts_meta_max_1, compress_hyper_4_114_chunk."time", compress_hyper_4_114_chunk.int_value, compress_hyper_4_114_chunk.float_value Index Cond: (compress_hyper_4_114_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_106_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_106_chunk Output: _hyper_3_106_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_115_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_115_chunk Output: compress_hyper_4_115_chunk._ts_meta_count, compress_hyper_4_115_chunk.segment_by_value1, compress_hyper_4_115_chunk.segment_by_value2, compress_hyper_4_115_chunk._ts_meta_min_1, compress_hyper_4_115_chunk._ts_meta_max_1, compress_hyper_4_115_chunk."time", compress_hyper_4_115_chunk.int_value, compress_hyper_4_115_chunk.float_value Index Cond: (compress_hyper_4_115_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_107_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_107_chunk Output: _hyper_3_107_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_116_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_116_chunk Output: compress_hyper_4_116_chunk._ts_meta_count, compress_hyper_4_116_chunk.segment_by_value1, compress_hyper_4_116_chunk.segment_by_value2, compress_hyper_4_116_chunk._ts_meta_min_1, compress_hyper_4_116_chunk._ts_meta_max_1, compress_hyper_4_116_chunk."time", compress_hyper_4_116_chunk.int_value, compress_hyper_4_116_chunk.float_value Index Cond: (compress_hyper_4_116_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_108_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_108_chunk Output: _hyper_3_108_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_117_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_117_chunk Output: compress_hyper_4_117_chunk._ts_meta_count, compress_hyper_4_117_chunk.segment_by_value1, compress_hyper_4_117_chunk.segment_by_value2, compress_hyper_4_117_chunk._ts_meta_min_1, compress_hyper_4_117_chunk._ts_meta_max_1, compress_hyper_4_117_chunk."time", compress_hyper_4_117_chunk.int_value, compress_hyper_4_117_chunk.float_value Index Cond: (compress_hyper_4_117_chunk.segment_by_value1 > 0) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_109_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_109_chunk Output: _hyper_3_109_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_118_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_118_chunk Output: compress_hyper_4_118_chunk._ts_meta_count, compress_hyper_4_118_chunk.segment_by_value1, compress_hyper_4_118_chunk.segment_by_value2, compress_hyper_4_118_chunk._ts_meta_min_1, compress_hyper_4_118_chunk._ts_meta_max_1, compress_hyper_4_118_chunk."time", compress_hyper_4_118_chunk.int_value, compress_hyper_4_118_chunk.float_value Index Cond: (compress_hyper_4_118_chunk.segment_by_value1 > 0) :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 0 AND segment_by_value2 > 0; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable2.segment_by_value1) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_101_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_101_chunk Output: _hyper_3_101_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_110_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_110_chunk Output: compress_hyper_4_110_chunk._ts_meta_count, compress_hyper_4_110_chunk.segment_by_value1, compress_hyper_4_110_chunk.segment_by_value2, compress_hyper_4_110_chunk._ts_meta_min_1, compress_hyper_4_110_chunk._ts_meta_max_1, compress_hyper_4_110_chunk."time", compress_hyper_4_110_chunk.int_value, compress_hyper_4_110_chunk.float_value Index Cond: ((compress_hyper_4_110_chunk.segment_by_value1 > 0) AND (compress_hyper_4_110_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_102_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_102_chunk Output: _hyper_3_102_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_111_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_111_chunk Output: compress_hyper_4_111_chunk._ts_meta_count, compress_hyper_4_111_chunk.segment_by_value1, compress_hyper_4_111_chunk.segment_by_value2, compress_hyper_4_111_chunk._ts_meta_min_1, compress_hyper_4_111_chunk._ts_meta_max_1, compress_hyper_4_111_chunk."time", compress_hyper_4_111_chunk.int_value, compress_hyper_4_111_chunk.float_value Index Cond: ((compress_hyper_4_111_chunk.segment_by_value1 > 0) AND (compress_hyper_4_111_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_103_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_103_chunk Output: _hyper_3_103_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_112_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_112_chunk Output: compress_hyper_4_112_chunk._ts_meta_count, compress_hyper_4_112_chunk.segment_by_value1, compress_hyper_4_112_chunk.segment_by_value2, compress_hyper_4_112_chunk._ts_meta_min_1, compress_hyper_4_112_chunk._ts_meta_max_1, compress_hyper_4_112_chunk."time", compress_hyper_4_112_chunk.int_value, compress_hyper_4_112_chunk.float_value Index Cond: ((compress_hyper_4_112_chunk.segment_by_value1 > 0) AND (compress_hyper_4_112_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_104_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_104_chunk Output: _hyper_3_104_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_113_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_113_chunk Output: compress_hyper_4_113_chunk._ts_meta_count, compress_hyper_4_113_chunk.segment_by_value1, compress_hyper_4_113_chunk.segment_by_value2, compress_hyper_4_113_chunk._ts_meta_min_1, compress_hyper_4_113_chunk._ts_meta_max_1, compress_hyper_4_113_chunk."time", compress_hyper_4_113_chunk.int_value, compress_hyper_4_113_chunk.float_value Index Cond: ((compress_hyper_4_113_chunk.segment_by_value1 > 0) AND (compress_hyper_4_113_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_105_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_105_chunk Output: _hyper_3_105_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_114_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_114_chunk Output: compress_hyper_4_114_chunk._ts_meta_count, compress_hyper_4_114_chunk.segment_by_value1, compress_hyper_4_114_chunk.segment_by_value2, compress_hyper_4_114_chunk._ts_meta_min_1, compress_hyper_4_114_chunk._ts_meta_max_1, compress_hyper_4_114_chunk."time", compress_hyper_4_114_chunk.int_value, compress_hyper_4_114_chunk.float_value Index Cond: ((compress_hyper_4_114_chunk.segment_by_value1 > 0) AND (compress_hyper_4_114_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_106_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_106_chunk Output: _hyper_3_106_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_115_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_115_chunk Output: compress_hyper_4_115_chunk._ts_meta_count, compress_hyper_4_115_chunk.segment_by_value1, compress_hyper_4_115_chunk.segment_by_value2, compress_hyper_4_115_chunk._ts_meta_min_1, compress_hyper_4_115_chunk._ts_meta_max_1, compress_hyper_4_115_chunk."time", compress_hyper_4_115_chunk.int_value, compress_hyper_4_115_chunk.float_value Index Cond: ((compress_hyper_4_115_chunk.segment_by_value1 > 0) AND (compress_hyper_4_115_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_107_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_107_chunk Output: _hyper_3_107_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_116_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_116_chunk Output: compress_hyper_4_116_chunk._ts_meta_count, compress_hyper_4_116_chunk.segment_by_value1, compress_hyper_4_116_chunk.segment_by_value2, compress_hyper_4_116_chunk._ts_meta_min_1, compress_hyper_4_116_chunk._ts_meta_max_1, compress_hyper_4_116_chunk."time", compress_hyper_4_116_chunk.int_value, compress_hyper_4_116_chunk.float_value Index Cond: ((compress_hyper_4_116_chunk.segment_by_value1 > 0) AND (compress_hyper_4_116_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_108_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_108_chunk Output: _hyper_3_108_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_117_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_117_chunk Output: compress_hyper_4_117_chunk._ts_meta_count, compress_hyper_4_117_chunk.segment_by_value1, compress_hyper_4_117_chunk.segment_by_value2, compress_hyper_4_117_chunk._ts_meta_min_1, compress_hyper_4_117_chunk._ts_meta_max_1, compress_hyper_4_117_chunk."time", compress_hyper_4_117_chunk.int_value, compress_hyper_4_117_chunk.float_value Index Cond: ((compress_hyper_4_117_chunk.segment_by_value1 > 0) AND (compress_hyper_4_117_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_109_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_109_chunk Output: _hyper_3_109_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_118_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_118_chunk Output: compress_hyper_4_118_chunk._ts_meta_count, compress_hyper_4_118_chunk.segment_by_value1, compress_hyper_4_118_chunk.segment_by_value2, compress_hyper_4_118_chunk._ts_meta_min_1, compress_hyper_4_118_chunk._ts_meta_max_1, compress_hyper_4_118_chunk."time", compress_hyper_4_118_chunk.int_value, compress_hyper_4_118_chunk.float_value Index Cond: ((compress_hyper_4_118_chunk.segment_by_value1 > 0) AND (compress_hyper_4_118_chunk.segment_by_value2 > 0)) :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 0 AND segment_by_value2 > 0 AND 2>1; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable2.segment_by_value1) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_101_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_101_chunk Output: _hyper_3_101_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_110_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_110_chunk Output: compress_hyper_4_110_chunk._ts_meta_count, compress_hyper_4_110_chunk.segment_by_value1, compress_hyper_4_110_chunk.segment_by_value2, compress_hyper_4_110_chunk._ts_meta_min_1, compress_hyper_4_110_chunk._ts_meta_max_1, compress_hyper_4_110_chunk."time", compress_hyper_4_110_chunk.int_value, compress_hyper_4_110_chunk.float_value Index Cond: ((compress_hyper_4_110_chunk.segment_by_value1 > 0) AND (compress_hyper_4_110_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_102_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_102_chunk Output: _hyper_3_102_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_111_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_111_chunk Output: compress_hyper_4_111_chunk._ts_meta_count, compress_hyper_4_111_chunk.segment_by_value1, compress_hyper_4_111_chunk.segment_by_value2, compress_hyper_4_111_chunk._ts_meta_min_1, compress_hyper_4_111_chunk._ts_meta_max_1, compress_hyper_4_111_chunk."time", compress_hyper_4_111_chunk.int_value, compress_hyper_4_111_chunk.float_value Index Cond: ((compress_hyper_4_111_chunk.segment_by_value1 > 0) AND (compress_hyper_4_111_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_103_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_103_chunk Output: _hyper_3_103_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_112_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_112_chunk Output: compress_hyper_4_112_chunk._ts_meta_count, compress_hyper_4_112_chunk.segment_by_value1, compress_hyper_4_112_chunk.segment_by_value2, compress_hyper_4_112_chunk._ts_meta_min_1, compress_hyper_4_112_chunk._ts_meta_max_1, compress_hyper_4_112_chunk."time", compress_hyper_4_112_chunk.int_value, compress_hyper_4_112_chunk.float_value Index Cond: ((compress_hyper_4_112_chunk.segment_by_value1 > 0) AND (compress_hyper_4_112_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_104_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_104_chunk Output: _hyper_3_104_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_113_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_113_chunk Output: compress_hyper_4_113_chunk._ts_meta_count, compress_hyper_4_113_chunk.segment_by_value1, compress_hyper_4_113_chunk.segment_by_value2, compress_hyper_4_113_chunk._ts_meta_min_1, compress_hyper_4_113_chunk._ts_meta_max_1, compress_hyper_4_113_chunk."time", compress_hyper_4_113_chunk.int_value, compress_hyper_4_113_chunk.float_value Index Cond: ((compress_hyper_4_113_chunk.segment_by_value1 > 0) AND (compress_hyper_4_113_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_105_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_105_chunk Output: _hyper_3_105_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_114_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_114_chunk Output: compress_hyper_4_114_chunk._ts_meta_count, compress_hyper_4_114_chunk.segment_by_value1, compress_hyper_4_114_chunk.segment_by_value2, compress_hyper_4_114_chunk._ts_meta_min_1, compress_hyper_4_114_chunk._ts_meta_max_1, compress_hyper_4_114_chunk."time", compress_hyper_4_114_chunk.int_value, compress_hyper_4_114_chunk.float_value Index Cond: ((compress_hyper_4_114_chunk.segment_by_value1 > 0) AND (compress_hyper_4_114_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_106_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_106_chunk Output: _hyper_3_106_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_115_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_115_chunk Output: compress_hyper_4_115_chunk._ts_meta_count, compress_hyper_4_115_chunk.segment_by_value1, compress_hyper_4_115_chunk.segment_by_value2, compress_hyper_4_115_chunk._ts_meta_min_1, compress_hyper_4_115_chunk._ts_meta_max_1, compress_hyper_4_115_chunk."time", compress_hyper_4_115_chunk.int_value, compress_hyper_4_115_chunk.float_value Index Cond: ((compress_hyper_4_115_chunk.segment_by_value1 > 0) AND (compress_hyper_4_115_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_107_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_107_chunk Output: _hyper_3_107_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_116_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_116_chunk Output: compress_hyper_4_116_chunk._ts_meta_count, compress_hyper_4_116_chunk.segment_by_value1, compress_hyper_4_116_chunk.segment_by_value2, compress_hyper_4_116_chunk._ts_meta_min_1, compress_hyper_4_116_chunk._ts_meta_max_1, compress_hyper_4_116_chunk."time", compress_hyper_4_116_chunk.int_value, compress_hyper_4_116_chunk.float_value Index Cond: ((compress_hyper_4_116_chunk.segment_by_value1 > 0) AND (compress_hyper_4_116_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_108_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_108_chunk Output: _hyper_3_108_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_117_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_117_chunk Output: compress_hyper_4_117_chunk._ts_meta_count, compress_hyper_4_117_chunk.segment_by_value1, compress_hyper_4_117_chunk.segment_by_value2, compress_hyper_4_117_chunk._ts_meta_min_1, compress_hyper_4_117_chunk._ts_meta_max_1, compress_hyper_4_117_chunk."time", compress_hyper_4_117_chunk.int_value, compress_hyper_4_117_chunk.float_value Index Cond: ((compress_hyper_4_117_chunk.segment_by_value1 > 0) AND (compress_hyper_4_117_chunk.segment_by_value2 > 0)) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_109_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_109_chunk Output: _hyper_3_109_chunk.segment_by_value1 -> Index Scan using compress_hyper_4_118_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_118_chunk Output: compress_hyper_4_118_chunk._ts_meta_count, compress_hyper_4_118_chunk.segment_by_value1, compress_hyper_4_118_chunk.segment_by_value2, compress_hyper_4_118_chunk._ts_meta_min_1, compress_hyper_4_118_chunk._ts_meta_max_1, compress_hyper_4_118_chunk."time", compress_hyper_4_118_chunk.int_value, compress_hyper_4_118_chunk.float_value Index Cond: ((compress_hyper_4_118_chunk.segment_by_value1 > 0) AND (compress_hyper_4_118_chunk.segment_by_value2 > 0)) -- Vectorization not possible filter on segment_by and compressed value -- Disable parallel worker to get deterministic query plans on i386 SET max_parallel_workers_per_gather = 0; :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 1000 AND int_value > 1000; --- QUERY PLAN --- Finalize Aggregate Output: sum(testtable2.segment_by_value1) -> Append -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_101_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_101_chunk Output: _hyper_3_101_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_101_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_110_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_110_chunk Output: compress_hyper_4_110_chunk._ts_meta_count, compress_hyper_4_110_chunk.segment_by_value1, compress_hyper_4_110_chunk.segment_by_value2, compress_hyper_4_110_chunk._ts_meta_min_1, compress_hyper_4_110_chunk._ts_meta_max_1, compress_hyper_4_110_chunk."time", compress_hyper_4_110_chunk.int_value, compress_hyper_4_110_chunk.float_value Index Cond: (compress_hyper_4_110_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_102_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_102_chunk Output: _hyper_3_102_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_102_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_111_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_111_chunk Output: compress_hyper_4_111_chunk._ts_meta_count, compress_hyper_4_111_chunk.segment_by_value1, compress_hyper_4_111_chunk.segment_by_value2, compress_hyper_4_111_chunk._ts_meta_min_1, compress_hyper_4_111_chunk._ts_meta_max_1, compress_hyper_4_111_chunk."time", compress_hyper_4_111_chunk.int_value, compress_hyper_4_111_chunk.float_value Index Cond: (compress_hyper_4_111_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_103_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_103_chunk Output: _hyper_3_103_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_103_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_112_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_112_chunk Output: compress_hyper_4_112_chunk._ts_meta_count, compress_hyper_4_112_chunk.segment_by_value1, compress_hyper_4_112_chunk.segment_by_value2, compress_hyper_4_112_chunk._ts_meta_min_1, compress_hyper_4_112_chunk._ts_meta_max_1, compress_hyper_4_112_chunk."time", compress_hyper_4_112_chunk.int_value, compress_hyper_4_112_chunk.float_value Index Cond: (compress_hyper_4_112_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_104_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_104_chunk Output: _hyper_3_104_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_104_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_113_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_113_chunk Output: compress_hyper_4_113_chunk._ts_meta_count, compress_hyper_4_113_chunk.segment_by_value1, compress_hyper_4_113_chunk.segment_by_value2, compress_hyper_4_113_chunk._ts_meta_min_1, compress_hyper_4_113_chunk._ts_meta_max_1, compress_hyper_4_113_chunk."time", compress_hyper_4_113_chunk.int_value, compress_hyper_4_113_chunk.float_value Index Cond: (compress_hyper_4_113_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_105_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_105_chunk Output: _hyper_3_105_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_105_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_114_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_114_chunk Output: compress_hyper_4_114_chunk._ts_meta_count, compress_hyper_4_114_chunk.segment_by_value1, compress_hyper_4_114_chunk.segment_by_value2, compress_hyper_4_114_chunk._ts_meta_min_1, compress_hyper_4_114_chunk._ts_meta_max_1, compress_hyper_4_114_chunk."time", compress_hyper_4_114_chunk.int_value, compress_hyper_4_114_chunk.float_value Index Cond: (compress_hyper_4_114_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_106_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_106_chunk Output: _hyper_3_106_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_106_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_115_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_115_chunk Output: compress_hyper_4_115_chunk._ts_meta_count, compress_hyper_4_115_chunk.segment_by_value1, compress_hyper_4_115_chunk.segment_by_value2, compress_hyper_4_115_chunk._ts_meta_min_1, compress_hyper_4_115_chunk._ts_meta_max_1, compress_hyper_4_115_chunk."time", compress_hyper_4_115_chunk.int_value, compress_hyper_4_115_chunk.float_value Index Cond: (compress_hyper_4_115_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_107_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_107_chunk Output: _hyper_3_107_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_107_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_116_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_116_chunk Output: compress_hyper_4_116_chunk._ts_meta_count, compress_hyper_4_116_chunk.segment_by_value1, compress_hyper_4_116_chunk.segment_by_value2, compress_hyper_4_116_chunk._ts_meta_min_1, compress_hyper_4_116_chunk._ts_meta_max_1, compress_hyper_4_116_chunk."time", compress_hyper_4_116_chunk.int_value, compress_hyper_4_116_chunk.float_value Index Cond: (compress_hyper_4_116_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_108_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_108_chunk Output: _hyper_3_108_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_108_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_117_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_117_chunk Output: compress_hyper_4_117_chunk._ts_meta_count, compress_hyper_4_117_chunk.segment_by_value1, compress_hyper_4_117_chunk.segment_by_value2, compress_hyper_4_117_chunk._ts_meta_min_1, compress_hyper_4_117_chunk._ts_meta_max_1, compress_hyper_4_117_chunk."time", compress_hyper_4_117_chunk.int_value, compress_hyper_4_117_chunk.float_value Index Cond: (compress_hyper_4_117_chunk.segment_by_value1 > 1000) -> Custom Scan (VectorAgg) Output: (PARTIAL sum(_hyper_3_109_chunk.segment_by_value1)) Grouping Policy: all compressed batches -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_3_109_chunk Output: _hyper_3_109_chunk.segment_by_value1 Vectorized Filter: (_hyper_3_109_chunk.int_value > 1000) -> Index Scan using compress_hyper_4_118_chunk_segment_by_value1_segment_by_val_idx on _timescaledb_internal.compress_hyper_4_118_chunk Output: compress_hyper_4_118_chunk._ts_meta_count, compress_hyper_4_118_chunk.segment_by_value1, compress_hyper_4_118_chunk.segment_by_value2, compress_hyper_4_118_chunk._ts_meta_min_1, compress_hyper_4_118_chunk._ts_meta_max_1, compress_hyper_4_118_chunk."time", compress_hyper_4_118_chunk.int_value, compress_hyper_4_118_chunk.float_value Index Cond: (compress_hyper_4_118_chunk.segment_by_value1 > 1000) RESET max_parallel_workers_per_gather; -- Can't group by a system column SELECT sum(float_value) FROM testtable2 GROUP BY tableoid ORDER BY 1 LIMIT 1; sum ------- 82620 -- Postgres versions starting with 16 remove the grouping columns that are -- equated to a constant. Check that our planning code handles this well. SELECT sum(float_value), int_value FROM testtable2 WHERE int_value = 1 GROUP BY int_value; sum | int_value ------+----------- 3162 | 1 -- -- Test handling of Agg on top of ChunkAppend. This reproduces a crash -- in the vector agg planning code introduced in commit 947f7f400. -- CREATE TABLE testtable3 (time timestamptz, location_id int, device_id int, sensor_id int); SELECT create_hypertable('testtable3', 'time'); create_hypertable ------------------------- (5,public,testtable3,t) ALTER TABLE testtable3 SET (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='location_id'); INSERT INTO testtable3 SELECT t, ceil(random() * 20)::int, ceil(random() * 30)::int, ceil(random() * 20)::int FROM generate_series('2024-01-01'::timestamptz, '2024-01-10'::timestamptz, '1h') AS t; SELECT count(compress_chunk(ch)) FROM show_chunks('testtable3') ch; count ------- 2 VACUUM FULL ANALYZE testtable3; EXPLAIN (buffers off, costs off) SELECT (date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour')::timestamp as time, TT.location_id as location_id, TT.device_id as device_id, 0 as sensor_id, date_trunc('day', current_timestamp) as discovered_date FROM testtable3 TT WHERE time >= date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour' GROUP BY TT.location_id, TT.device_id; --- QUERY PLAN --- HashAggregate Group Key: tt.location_id, tt.device_id -> Custom Scan (ChunkAppend) on testtable3 tt Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_5_120_chunk tt_1 Vectorized Filter: ("time" >= (date_trunc('hour'::text, 'Tue Jan 09 00:00:00 2024 PST'::timestamp with time zone) - '@ 1 hour'::interval)) -> Seq Scan on compress_hyper_6_122_chunk Filter: (_ts_meta_max_1 >= (date_trunc('hour'::text, 'Tue Jan 09 00:00:00 2024 PST'::timestamp with time zone) - '@ 1 hour'::interval)) SELECT (date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour')::timestamp as time, TT.location_id as location_id, TT.device_id as device_id, 0 as sensor_id, date_trunc('day', current_timestamp) as discovered_date FROM testtable3 TT WHERE time >= date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour' GROUP BY TT.location_id, TT.device_id \g :TEST_OUTPUT_DIR/vectorized_aggregation_query_result.out ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017330�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/����������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0021671�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-bool/�����������������������������������������0000775�0000000�0000000�00000000000�15100345067�0023740�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-bool/empty������������������������������������0000664�0000000�0000000�00000000000�15100345067�0025007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/�����������������������������������������0000775�0000000�0000000�00000000000�15100345067�0023771�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/01accf1c403c681e8ccc10349c97a28ef2afbdd3�0000664�0000000�0000000�00000002026�15100345067�0031634�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����þ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/0d699bc41031c7525fa65c0ab267f34f608eef6a�0000664�0000000�0000000�00000000030�15100345067�0031343�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/0dbf553220bcd27478f10999d679d564a11632a1�0000664�0000000�0000000�00000000002�15100345067�0031044�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������e������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/0e356ba505631fbf715758bed27d503f8b260e3a�0000664�0000000�0000000�00000000002�15100345067�0031255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/0f873e20f9cc905c940207795842a8f89598bb78�0000664�0000000�0000000�00000002143�15100345067�0031042�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����è��� different1000��� diffecnt999��� different998��� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f�����������2������������������������������������������������������������������������������������1�)����������������������������������������������������������������������������catalog�text���������������������������������������������������������������������������������������������������1�)���������������������������������������������������������������������������������������������������������������f�����������2���������������������������������������������������������������������������������������������������������������������������������������?���������������������������������������������������������������f�����������2�������������������������������������������������������������������������������������������������������������������)������������������������������������������������������`�������������������������ifferent403���nt2��� different1�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/13f402104e20e5a38290bdc5fec85a46ae36bd73�0000664�0000000�0000000�00000000252�15100345067�0031332�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è���_catalog�tex differenåt8��������ÿÿÿÿ������=������������������������������������������������������1����������������with-null����������� di`��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/143a44ebe20d00b1c6bdf12487758974467b504f�0000664�0000000�0000000�00000002204�15100345067�0031124�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è���UUU���������������������������������G����������������t�����T�3���������������������������������������������������������������������������������������������������)�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)�����������������������������������������������������������������������������)�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/1641a06baa3defcf9a1b704cb94ea3387f40f2ad�0000664�0000000�0000000�00000000033�15100345067�0031625�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����0en�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/2123898ce1d45564480b9ff51cf391b87dcc5a07�0000664�0000000�0000000�00000000005�15100345067�0031223�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������p�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/22e70b0d023eac54b28a067aac0ab8e4eb75887b�0000664�0000000�0000000�00000000031�15100345067�0031461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/3862930f38ef2ac7387e3e47191234094aee7c0a�0000664�0000000�0000000�00000000051�15100345067�0031140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����7®���������������•����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/3f82cf837a5f3fae26f7cbb25ed3d903eed71687�0000664�0000000�0000000�00000002217�15100345067�0031620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����ò��� diffe���d����������������������������������!�����������������������������������������������������������������������������������������������������������������������������������)������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ ����������������������������������������������������������������������������������������������?��������������������������������������������$��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������?��������������������������������������������$���������������������������������������������������������)���d��������������������������������������������������������������������������������������������������������������������������������������������������������������������������9���[ifferent-wit h�����������������������]���������������������i`fffer��� f��������������������������p������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/428361124252a8847f1182747c936696bc43543b�0000664�0000000�0000000�00000000125�15100345067�0030505�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿßÿÿ�����ÿÿÿÿÿÿÿÿÿÿ#ÿÿ�xt��–=�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/4cd1b3841a01a3abc7f1cec6325130fd109dee84�0000664�0000000�0000000�00000000030�15100345067�0031451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text��ff��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/513033f491e3f9ae4cf779c239158c9063f2af4d�0000664�0000000�0000000�00000001401�15100345067�0031226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text����M���:ÿÿÿÿÿÿÿÿÿ¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥ÿÿÿÿÿÿÿlÿ�����ÿÿÿÿÿopg_catalog�text���Y���åÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿ��.���������+��������a��������nt-with-nulls80���different-Žwith-nulls83���different-with-nulls70���different-with-nulls47���different-differen����������������������������������������������������������������������������� ��� ���������������������������1111108)7�fferent475��� different474��� differen73�/�� different4?72 �� di`fferen@�������467��=t�72-��� +���������erent4����� dif��������]��������Û���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/58420143cbcd2fe40fd1409948b6a78d3bf14a32�0000664�0000000�0000000�00000000016�15100345067�0031257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/592e2bafa4637d9786e9d14c5f1ca512e0076940�0000664�0000000�0000000�00000000033�15100345067�0031217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�N�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/5ba93c9db0cff93f52b521d7420e43f6eda2784f�0000664�0000000�0000000�00000000001�15100345067�0031510�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/5d1be7e9dda1ee8896be5b7e34a85ee16452a7b4�0000664�0000000�0000000�00000000001�15100345067�0031604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/6a126964d691ada7de1d25c976c4e7b481858665�0000664�0000000�0000000�00000000044�15100345067�0031163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����������UUUU��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/6c0295b5f6b25ca492bafd609ba5c9494785651f�0000664�0000000�0000000�00000002030�15100345067�0031305�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/76023b236d960f02d7fb41c7a1fa4d28dafa7c2d�0000664�0000000�0000000�00000002033�15100345067�0031474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)����������������������������������������������������������������������������������������������������������������������������������������������������)�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/9159cb8bcee7fcb95582f140960cdae72788d326�0000664�0000000�0000000�00000000002�15100345067�0031374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/98e49024fd7e15859ec345ee83a01fec0656ad94�0000664�0000000�0000000�00000000302�15100345067�0031315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text������'������������������$#m L# dif�����������*����������ft������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/a24f8ad32bdadaee87b839765599bc63dfcbd62a�0000664�0000000�0000000�00000000060�15100345067�0031744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è�������p��¿�����;��™T™T-��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/a3d453f14af5370aae60089101d659fb12c3aff4�0000664�0000000�0000000�00000000016�15100345067�0031327�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_attalog��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/a42c6cf1de3abfdea9b95f34687cbbe92b9a7383�0000664�0000000�0000000�00000000001�15100345067�0031736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/array1�����������������������������������0000664�0000000�0000000�00000037055�15100345067�0025125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text����è��� different1000��� different999��� different998��� different997��� different996��� different995��� different994��� different993��� different992��� different991��� different990��� different989��� different988��� different987��� different986��� different985��� different984��� different983��� different982��� different981��� different980��� different979��� different978��� different977��� different976��� different975��� different974��� different973��� different972��� different971��� different970��� different969��� different968��� different967��� different966��� different965��� different964��� different963��� different962��� different961��� different960��� different959��� different958��� different957��� different956��� different955��� different954��� different953��� different952��� different951��� different950��� different949��� different948��� different947��� different946��� different945��� different944��� different943��� different942��� different941��� different940��� different939��� different938��� different937��� different936��� different935��� different934��� different933��� different932��� different931��� different930��� different929��� different928��� different927��� different926��� different925��� different924��� different923��� different922��� different921��� different920��� different919��� different918��� different917��� different916��� different915��� different914��� different913��� different912��� different911��� different910��� different909��� different908��� different907��� different906��� different905��� different904��� different903��� different902��� different901��� different900��� different899��� different898��� different897��� different896��� different895��� different894��� different893��� different892��� different891��� different890��� different889��� different888��� different887��� different886��� different885��� different884��� different883��� different882��� different881��� different880��� different879��� different878��� different877��� different876��� different875��� different874��� different873��� different872��� different871��� different870��� different869��� different868��� different867��� different866��� different865��� different864��� different863��� different862��� different861��� different860��� different859��� different858��� different857��� different856��� different855��� different854��� different853��� different852��� different851��� different850��� different849��� different848��� different847��� different846��� different845��� different844��� different843��� different842��� different841��� different840��� different839��� different838��� different837��� different836��� different835��� different834��� different833��� different832��� different831��� different830��� different829��� different828��� different827��� different826��� different825��� different824��� different823��� different822��� different821��� different820��� different819��� different818��� different817��� different816��� different815��� different814��� different813��� different812��� different811��� different810��� different809��� different808��� different807��� different806��� different805��� different804��� different803��� different802��� different801��� different800��� different799��� different798��� different797��� different796��� different795��� different794��� different793��� different792��� different791��� different790��� different789��� different788��� different787��� different786��� different785��� different784��� different783��� different782��� different781��� different780��� different779��� different778��� different777��� different776��� different775��� different774��� different773��� different772��� different771��� different770��� different769��� different768��� different767��� different766��� different765��� different764��� different763��� different762��� different761��� different760��� different759��� different758��� different757��� different756��� different755��� different754��� different753��� different752��� different751��� different750��� different749��� different748��� different747��� different746��� different745��� different744��� different743��� different742��� different741��� different740��� different739��� different738��� different737��� different736��� different735��� different734��� different733��� different732��� different731��� different730��� different729��� different728��� different727��� different726��� different725��� different724��� different723��� different722��� different721��� different720��� different719��� different718��� different717��� different716��� different715��� different714��� different713��� different712��� different711��� different710��� different709��� different708��� different707��� different706��� different705��� different704��� different703��� different702��� different701��� different700��� different699��� different698��� different697��� different696��� different695��� different694��� different693��� different692��� different691��� different690��� different689��� different688��� different687��� different686��� different685��� different684��� different683��� different682��� different681��� different680��� different679��� different678��� different677��� different676��� different675��� different674��� different673��� different672��� different671��� different670��� different669��� different668��� different667��� different666��� different665��� different664��� different663��� different662��� different661��� different660��� different659��� different658��� different657��� different656��� different655��� different654��� different653��� different652��� different651��� different650��� different649��� different648��� different647��� different646��� different645��� different644��� different643��� different642��� different641��� different640��� different639��� different638��� different637��� different636��� different635��� different634��� different633��� different632��� different631��� different630��� different629��� different628��� different627��� different626��� different625��� different624��� different623��� different622��� different621��� different620��� different619��� different618��� different617��� different616��� different615��� different614��� different613��� different612��� different611��� different610��� different609��� different608��� different607��� different606��� different605��� different604��� different603��� different602��� different601��� different600��� different599��� different598��� different597��� different596��� different595��� different594��� different593��� different592��� different591��� different590��� different589��� different588��� different587��� different586��� different585��� different584��� different583��� different582��� different581��� different580��� different579��� different578��� different577��� different576��� different575��� different574��� different573��� different572��� different571��� different570��� different569��� different568��� different567��� different566��� different565��� different564��� different563��� different562��� different561��� different560��� different559��� different558��� different557��� different556��� different555��� different554��� different553��� different552��� different551��� different550��� different549��� different548��� different547��� different546��� different545��� different544��� different543��� different542��� different541��� different540��� different539��� different538��� different537��� different536��� different535��� different534��� different533��� different532��� different531��� different530��� different529��� different528��� different527��� different526��� different525��� different524��� different523��� different522��� different521��� different520��� different519��� different518��� different517��� different516��� different515��� different514��� different513��� different512��� different511��� different510��� different509��� different508��� different507��� different506��� different505��� different504��� different503��� different502��� different501��� different500��� different499��� different498��� different497��� different496��� different495��� different494��� different493��� different492��� different491��� different490��� different489��� different488��� different487��� different486��� different485��� different484��� different483��� different482��� different481��� different480��� different479��� different478��� different477��� different476��� different475��� different474��� different473��� different472��� different471��� different470��� different469��� different468��� different467��� different466��� different465��� different464��� different463��� different462��� different461��� different460��� different459��� different458��� different457��� different456��� different455��� different454��� different453��� different452��� different451��� different450��� different449��� different448��� different447��� different446��� different445��� different444��� different443��� different442��� different441��� different440��� different439��� different438��� different437��� different436��� different435��� different434��� different433��� different432��� different431��� different430��� different429��� different428��� different427��� different426��� different425��� different424��� different423��� different422��� different421��� different420��� different419��� different418��� different417��� different416��� different415��� different414��� different413��� different412��� different411��� different410��� different409��� different408��� different407��� different406��� different405��� different404��� different403��� different402��� different401��� different400��� different399��� different398��� different397��� different396��� different395��� different394��� different393��� different392��� different391��� different390��� different389��� different388��� different387��� different386��� different385��� different384��� different383��� different382��� different381��� different380��� different379��� different378��� different377��� different376��� different375��� different374��� different373��� different372��� different371��� different370��� different369��� different368��� different367��� different366��� different365��� different364��� different363��� different362��� different361��� different360��� different359��� different358��� different357��� different356��� different355��� different354��� different353��� different352��� different351��� different350��� different349��� different348��� different347��� different346��� different345��� different344��� different343��� different342��� different341��� different340��� different339��� different338��� different337��� different336��� different335��� different334��� different333��� different332��� different331��� different330��� different329��� different328��� different327��� different326��� different325��� different324��� different323��� different322��� different321��� different320��� different319��� different318��� different317��� different316��� different315��� different314��� different313��� different312��� different311��� different310��� different309��� different308��� different307��� different306��� different305��� different304��� different303��� different302��� different301��� different300��� different299��� different298��� different297��� different296��� different295��� different294��� different293��� different292��� different291��� different290��� different289��� different288��� different287��� different286��� different285��� different284��� different283��� different282��� different281��� different280��� different279��� different278��� different277��� different276��� different275��� different274��� different273��� different272��� different271��� different270��� different269��� different268��� different267��� different266��� different265��� different264��� different263��� different262��� different261��� different260��� different259��� different258��� different257��� different256��� different255��� different254��� different253��� different252��� different251��� different250��� different249��� different248��� different247��� different246��� different245��� different244��� different243��� different242��� different241��� different240��� different239��� different238��� different237��� different236��� different235��� different234��� different233��� different232��� different231��� different230��� different229��� different228��� different227��� different226��� different225��� different224��� different223��� different222��� different221��� different220��� different219��� different218��� different217��� different216��� different215��� different214��� different213��� different212��� different211��� different210��� different209��� different208��� different207��� different206��� different205��� different204��� different203��� different202��� different201��� different200��� different199��� different198��� different197��� different196��� different195��� different194��� different193��� different192��� different191��� different190��� different189��� different188��� different187��� different186��� different185��� different184��� different183��� different182��� different181��� different180��� different179��� different178��� different177��� different176��� different175��� different174��� different173��� different172��� different171��� different170��� different169��� different168��� different167��� different166��� different165��� different164��� different163��� different162��� different161��� different160��� different159��� different158��� different157��� different156��� different155��� different154��� different153��� different152��� different151��� different150��� different149��� different148��� different147��� different146��� different145��� different144��� different143��� different142��� different141��� different140��� different139��� different138��� different137��� different136��� different135��� different134��� different133��� different132��� different131��� different130��� different129��� different128��� different127��� different126��� different125��� different124��� different123��� different122��� different121��� different120��� different119��� different118��� different117��� different116��� different115��� different114��� different113��� different112��� different111��� different110��� different109��� different108��� different107��� different106��� different105��� different104��� different103��� different102��� different101��� different100��� different99��� different98��� different97��� different96��� different95��� different94��� different93��� different92��� different91��� different90��� different89��� different88��� different87��� different86��� different85��� different84��� different83��� different82��� different81��� different80��� different79��� different78��� different77��� different76��� different75��� different74��� different73��� different72��� different71��� different70��� different69��� different68��� different67��� different66��� different65��� different64��� different63��� different62��� different61��� different60��� different59��� different58��� different57��� different56��� different55��� different54��� different53��� different52��� different51��� different50��� different49��� different48��� different47��� different46��� different45��� different44��� different43��� different42��� different41��� different40��� different39��� different38��� different37��� different36��� different35��� different34��� different33��� different32��� different31��� different30��� different29��� different28��� different27��� different26��� different25��� different24��� different23��� different22��� different21��� different20��� different19��� different18��� different17��� different16��� different15��� different14��� different13��� different12��� different11��� different10��� different9��� different8��� different7��� different6��� different5��� different4��� different3��� different2��� different1�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/b6f695dd09d681d144c71e52ebe565a2567a23f9�0000664�0000000�0000000�00000000064�15100345067�0031313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è���è���log�tex ²/----p?��-����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/b71fa13e7c2fee50d39a87fc927c31256f8c4af3�0000664�0000000�0000000�00000002041�15100345067�0031521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����è������������@�������������������������������������������������������������������������������������������������������������������������������������������@��f������������������������������������������������������������������������������������������������������������������������������)h����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f������������������������������������������������������������������������������������������������������������������������������)h������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������t2��� different1�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/bc6960f7ed1b4b216c5cbc2721ea5136ffb80aae�0000664�0000000�0000000�00000002071�15100345067�0031633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����è��� different1000��� different999���9�����t�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������J�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)���f����������������������������������������������������������������������������������������������������������������������������������������������������������������������J�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)���f����������������������������������������������������������������������������������������������������)������������?��+���������������������������������������ifferent1�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/c13eaced24e2a5039d3fbeef655fc3cf827a2be7�0000664�0000000�0000000�00000000040�15100345067�0032003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text��������en������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/c2588a11e70caad0b9c91272f81d48348b94f938�0000664�0000000�0000000�00000002353�15100345067�0031232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����ò��� diffe���d����������������������������������!�������� ���������������������������������������������������������������������������������������������������������������������������9���different-wit h�����������������������]���������������������i`fffer��� f����������������g���txet����T�3����xt�Ate������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������?��������������pg_catalog�tex0������e47+��i����������������������������������������pg_catalog�text������e47+��i�����������������������������������������������t5l��������������������������������������������������m����� diffe���d��������������������������������������������������������WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW����������������������������������������������8��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/c88b988789743b6aad8ef68278fc383847a37ddf�0000664�0000000�0000000�00000000027�15100345067�0031361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�n���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-1ac67d1b8ebedeb93c515b5244f6e60613c1af0b������������������������������������������������������0000664�0000000�0000000�00000000670�15100345067�0032576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text��������������������������������������������������������������������������������������������������������������pg_catalog�text������fferent475��� different474��� different473��� different4?72��� di`fferent471��� different471��� different469��� different468��� different467��� different466��� different465��� different464��� ffer�����������������������������������������������������������������������������������������������diftn������������������������������������������������������������������������crash-b6cfa8632a8bf28e90198ec167f3f63258880f77������������������������������������������������������0000664�0000000�0000000�00000000736�15100345067�0032301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text��������������������������������������������������������������������������������������������������������������pg_catalog�text���������è��� differeddddddddddddddddddddddddddddddddddddddddddddddddrent832��� different831��� different830��� different829��� different��'�� different827��� diferent826��� different825��� different824��� different823��� different822��� different821��� different820��� different819��� different818��� different817��� different816��� different815��� different814��� different813��� differ different5��� different4��� different3��� different2��� different1����������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/d57ef126bce1cf2bb5a63addf172a9cf9bedb7da�0000664�0000000�0000000�00000002066�15100345067�0032232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����è��� diffe��������������������������������������������������������������f�����������1�������������������������������������������������������������������������������������������������������@����������������������������������������������������������������1�)���������������������������������������������������������������������������������������������������������������f�����������2�����������������������������������������������������������������������������������������������������������f�����������2�������������������������������������������������������?���������������������������������������������������������������f�����������1����������������������������������������������������������������������������������������������������������������������?������������������������������������������������������������f�����������1�����������������������������������������������������������������������������������������������������������������)������������������������������������������������������`�������������������������ifferent403���nt2��� different1��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/ebddebf24b791e82c4ac007197581ec4fa2886ee�0000664�0000000�0000000�00000000243�15100345067�0031604�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text������ ���'������####$ dif���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/ec536d9d30f08137531d4bfe676a545d897ae98b�0000664�0000000�0000000�00000002203�15100345067�0031320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����ò��� diffe����������������������������������������������������������������������������������������������������������������������������������������������������������������9���different-wit h�����������������������]���������������������i`fffer��� f�����������������g�t�xet����T�3����xt�Ate����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������@�)�������������������������������������������������������������������������������������������������������)���������+����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� differe��������������pg_�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/ede4129ca9c4d8dbd649aa6f2d5c0038e1537716�0000664�0000000�0000000�00000000040�15100345067�0031432�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text����������UU������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/ef519c31ea5d415293021b0ca83dd655701d2c13�0000664�0000000�0000000�00000100113�15100345067�0031160�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text�����€������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������$��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������%��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������$��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������%��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������)�h���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/f2f014ef49bdaf4ff29d4a7116feff81e7015283�0000664�0000000�0000000�00000000060�15100345067�0031521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è���������p��¿�����;��™T-��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/f41f46df995dd4c7690f27978152ead25ccd5c75�0000664�0000000�0000000�00000000060�15100345067�0031406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è�����.�ÿÿÿ�������÷����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/length-saw�������������������������������0000664�0000000�0000000�00000171754�15100345067�0026004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text������100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d100d��)99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d99d��&98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d98d��#97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d97d�� 96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d96d��95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d95d��94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d94d��93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d93d��92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d92d��91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d91d��90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d90d�� 89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d89d��88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d88d��87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d87d��86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d86d���ÿ85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d85d���ü84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d84d���ù83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d83d���ö82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d82d���ó81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d81d���ð80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d80d���í79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d79d���ê78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d78d���ç77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d77d���ä76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d76d���á75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d75d���Þ74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d74d���Û73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d73d���Ø72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d72d���Õ71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d71d���Ò70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d70d���Ï69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d69d���Ì68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d68d���É67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d67d���Æ66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d66d���Ã65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d65d���À64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d64d���½63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d63d���º62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d62d���·61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d61d���´60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d60d���±59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d59d���®58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d58d���«57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d57d���¨56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d56d���¥55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d55d���¢54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d54d���Ÿ53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d53d���œ52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d52d���™51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d51d���–50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d50d���“49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d49d���48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d48d���47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d47d���Š46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d46d���‡45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d45d���„44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d44d���43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d43d���~42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d42d���{41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d41d���x40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d40d���u39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d39d���r38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d38d���o37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d37d���l36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d36d���i35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d35d���f34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d34d���c33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d33d���`32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d32d���]31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d31d���Z30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d30d���W29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d29d���T28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d28d���Q27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d27d���N26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d26d���K25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d25d���H24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d24d���E23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d23d���B22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d22d���?21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d21d���<20d20d20d20d20d20d20d20d20d20d20d20d20d20d20d20d20d20d20d20d���919d19d19d19d19d19d19d19d19d19d19d19d19d19d19d19d19d19d19d���618d18d18d18d18d18d18d18d18d18d18d18d18d18d18d18d18d18d���317d17d17d17d17d17d17d17d17d17d17d17d17d17d17d17d17d���016d16d16d16d16d16d16d16d16d16d16d16d16d16d16d16d���-15d15d15d15d15d15d15d15d15d15d15d15d15d15d15d���*14d14d14d14d14d14d14d14d14d14d14d14d14d14d���'13d13d13d13d13d13d13d13d13d13d13d13d13d���$12d12d12d12d12d12d12d12d12d12d12d12d���!11d11d11d11d11d11d11d11d11d11d11d���10d10d10d10d10d10d10d10d10d10d���9d9d9d9d9d9d9d9d9d���8d8d8d8d8d8d8d8d���7d7d7d7d7d7d7d��� 6d6d6d6d6d6d��� 5d5d5d5d5d���4d4d4d4d���3d3d3d���2d2d���1d���1c���2c2c���3c3c3c���4c4c4c4c��� 5c5c5c5c5c��� 6c6c6c6c6c6c���7c7c7c7c7c7c7c���8c8c8c8c8c8c8c8c���9c9c9c9c9c9c9c9c9c���10c10c10c10c10c10c10c10c10c10c���!11c11c11c11c11c11c11c11c11c11c11c���$12c12c12c12c12c12c12c12c12c12c12c12c���'13c13c13c13c13c13c13c13c13c13c13c13c13c���*14c14c14c14c14c14c14c14c14c14c14c14c14c14c���-15c15c15c15c15c15c15c15c15c15c15c15c15c15c15c���016c16c16c16c16c16c16c16c16c16c16c16c16c16c16c16c���317c17c17c17c17c17c17c17c17c17c17c17c17c17c17c17c17c���618c18c18c18c18c18c18c18c18c18c18c18c18c18c18c18c18c18c���919c19c19c19c19c19c19c19c19c19c19c19c19c19c19c19c19c19c19c���<20c20c20c20c20c20c20c20c20c20c20c20c20c20c20c20c20c20c20c20c���?21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c21c���B22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c22c���E23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c23c���H24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c24c���K25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c25c���N26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c26c���Q27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c27c���T28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c28c���W29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c29c���Z30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c30c���]31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c31c���`32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c32c���c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c33c���f34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c34c���i35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c35c���l36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c36c���o37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c37c���r38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c38c���u39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c39c���x40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c40c���{41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c41c���~42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c42c���43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c43c���„44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c44c���‡45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c45c���Š46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c46c���47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c47c���48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c48c���“49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c49c���–50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c50c���™51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c51c���œ52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c52c���Ÿ53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c53c���¢54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c54c���¥55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c55c���¨56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c56c���«57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c57c���®58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c58c���±59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c59c���´60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c60c���·61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c61c���º62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c62c���½63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c63c���À64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c64c���Ã65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c65c���Æ66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c66c���É67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c67c���Ì68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c68c���Ï69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c69c���Ò70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c70c���Õ71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c71c���Ø72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c72c���Û73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c73c���Þ74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c74c���á75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c75c���ä76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c76c���ç77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c77c���ê78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c78c���í79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c79c���ð80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c80c���ó81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c81c���ö82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c82c���ù83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c83c���ü84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c84c���ÿ85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c85c��86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c86c��87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c87c��88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c88c�� 89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c89c��90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c90c��91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c91c��92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c92c��93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c93c��94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c94c��95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c95c�� 96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c96c��#97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c97c��&98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c98c��)99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c99c��100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c100c���1b���2b2b���3b3b3b���4b4b4b4b��� 5b5b5b5b5b��� 6b6b6b6b6b6b���7b7b7b7b7b7b7b���8b8b8b8b8b8b8b8b���9b9b9b9b9b9b9b9b9b���10b10b10b10b10b10b10b10b10b10b���!11b11b11b11b11b11b11b11b11b11b11b���$12b12b12b12b12b12b12b12b12b12b12b12b���'13b13b13b13b13b13b13b13b13b13b13b13b13b���*14b14b14b14b14b14b14b14b14b14b14b14b14b14b���-15b15b15b15b15b15b15b15b15b15b15b15b15b15b15b���016b16b16b16b16b16b16b16b16b16b16b16b16b16b16b16b���317b17b17b17b17b17b17b17b17b17b17b17b17b17b17b17b17b���618b18b18b18b18b18b18b18b18b18b18b18b18b18b18b18b18b18b���919b19b19b19b19b19b19b19b19b19b19b19b19b19b19b19b19b19b19b���<20b20b20b20b20b20b20b20b20b20b20b20b20b20b20b20b20b20b20b20b���?21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b21b���B22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b22b���E23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b23b���H24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b24b���K25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b25b���N26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b26b���Q27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b27b���T28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b28b���W29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b29b���Z30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b30b���]31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b31b���`32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b32b���c33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b33b���f34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b34b���i35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b35b���l36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b36b���o37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b37b���r38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b38b���u39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b39b���x40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b40b���{41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b41b���~42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b42b���43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b43b���„44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b44b���‡45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b45b���Š46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b46b���47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b47b���48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b48b���“49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b49b���–50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b50b���™51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b51b���œ52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b52b���Ÿ53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b53b���¢54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b54b���¥55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b55b���¨56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b56b���«57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b57b���®58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b58b���±59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b59b���´60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b60b���·61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b61b���º62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b62b���½63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b63b���À64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b64b���Ã65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b65b���Æ66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b66b���É67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b67b���Ì68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b68b���Ï69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b69b���Ò70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b70b���Õ71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b71b���Ø72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b72b���Û73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b73b���Þ74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b74b���á75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b75b���ä76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b76b���ç77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b77b���ê78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b78b���í79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b79b���ð80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b80b���ó81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b81b���ö82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b82b���ù83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b83b���ü84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b84b���ÿ85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b85b��86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b86b��87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b87b��88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b88b�� 89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b89b��90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b90b��91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b91b��92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b92b��93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b93b��94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b94b��95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b95b�� 96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b96b��#97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b97b��&98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b98b��)99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b99b��100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b100b��100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a100a��)99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a99a��&98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a98a��#97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a97a�� 96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a96a��95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a95a��94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a94a��93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a93a��92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a92a��91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a91a��90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a90a�� 89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a89a��88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a88a��87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a87a��86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a86a���ÿ85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a85a���ü84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a84a���ù83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a83a���ö82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a82a���ó81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a81a���ð80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a80a���í79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a79a���ê78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a78a���ç77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a77a���ä76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a76a���á75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a75a���Þ74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a74a���Û73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a73a���Ø72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a72a���Õ71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a71a���Ò70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a70a���Ï69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a69a���Ì68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a68a���É67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a67a���Æ66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a66a���Ã65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a65a���À64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a64a���½63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a63a���º62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a62a���·61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a61a���´60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a60a���±59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a59a���®58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a58a���«57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a57a���¨56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a56a���¥55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a55a���¢54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a54a���Ÿ53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a53a���œ52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a52a���™51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a51a���–50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a50a���“49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a49a���48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a48a���47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a47a���Š46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a46a���‡45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a45a���„44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a44a���43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a43a���~42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a42a���{41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a41a���x40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a40a���u39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a39a���r38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a38a���o37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a37a���l36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a36a���i35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a35a���f34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a34a���c33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a33a���`32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a32a���]31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a31a���Z30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a30a���W29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a29a���T28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a28a���Q27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a27a���N26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a26a���K25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a25a���H24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a24a���E23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a23a���B22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a22a���?21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a21a���<20a20a20a20a20a20a20a20a20a20a20a20a20a20a20a20a20a20a20a20a���919a19a19a19a19a19a19a19a19a19a19a19a19a19a19a19a19a19a19a���618a18a18a18a18a18a18a18a18a18a18a18a18a18a18a18a18a18a���317a17a17a17a17a17a17a17a17a17a17a17a17a17a17a17a17a���016a16a16a16a16a16a16a16a16a16a16a16a16a16a16a16a���-15a15a15a15a15a15a15a15a15a15a15a15a15a15a15a���*14a14a14a14a14a14a14a14a14a14a14a14a14a14a���'13a13a13a13a13a13a13a13a13a13a13a13a13a���$12a12a12a12a12a12a12a12a12a12a12a12a���!11a11a11a11a11a11a11a11a11a11a11a���10a10a10a10a10a10a10a10a10a10a���9a9a9a9a9a9a9a9a9a���8a8a8a8a8a8a8a8a���7a7a7a7a7a7a7a��� 6a6a6a6a6a6a��� 5a5a5a5a5a���4a4a4a4a���3a3a3a���2a2a���1a��������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-text/with-nulls�������������������������������0000664�0000000�0000000�00000032455�15100345067�0026033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è���UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU���UUUUU��ô���different-with-nulls1���different-with-nulls3���different-with-nulls5���different-with-nulls7���different-with-nulls9���different-with-nulls11���different-with-nulls13���different-with-nulls15���different-with-nulls17���different-with-nulls19���different-with-nulls21���different-with-nulls23���different-with-nulls25���different-with-nulls27���different-with-nulls29���different-with-nulls31���different-with-nulls33���different-with-nulls35���different-with-nulls37���different-with-nulls39���different-with-nulls41���different-with-nulls43���different-with-nulls45���different-with-nulls47���different-with-nulls49���different-with-nulls51���different-with-nulls53���different-with-nulls55���different-with-nulls57���different-with-nulls59���different-with-nulls61���different-with-nulls63���different-with-nulls65���different-with-nulls67���different-with-nulls69���different-with-nulls71���different-with-nulls73���different-with-nulls75���different-with-nulls77���different-with-nulls79���different-with-nulls81���different-with-nulls83���different-with-nulls85���different-with-nulls87���different-with-nulls89���different-with-nulls91���different-with-nulls93���different-with-nulls95���different-with-nulls97���different-with-nulls99���different-with-nulls101���different-with-nulls103���different-with-nulls105���different-with-nulls107���different-with-nulls109���different-with-nulls111���different-with-nulls113���different-with-nulls115���different-with-nulls117���different-with-nulls119���different-with-nulls121���different-with-nulls123���different-with-nulls125���different-with-nulls127���different-with-nulls129���different-with-nulls131���different-with-nulls133���different-with-nulls135���different-with-nulls137���different-with-nulls139���different-with-nulls141���different-with-nulls143���different-with-nulls145���different-with-nulls147���different-with-nulls149���different-with-nulls151���different-with-nulls153���different-with-nulls155���different-with-nulls157���different-with-nulls159���different-with-nulls161���different-with-nulls163���different-with-nulls165���different-with-nulls167���different-with-nulls169���different-with-nulls171���different-with-nulls173���different-with-nulls175���different-with-nulls177���different-with-nulls179���different-with-nulls181���different-with-nulls183���different-with-nulls185���different-with-nulls187���different-with-nulls189���different-with-nulls191���different-with-nulls193���different-with-nulls195���different-with-nulls197���different-with-nulls199���different-with-nulls201���different-with-nulls203���different-with-nulls205���different-with-nulls207���different-with-nulls209���different-with-nulls211���different-with-nulls213���different-with-nulls215���different-with-nulls217���different-with-nulls219���different-with-nulls221���different-with-nulls223���different-with-nulls225���different-with-nulls227���different-with-nulls229���different-with-nulls231���different-with-nulls233���different-with-nulls235���different-with-nulls237���different-with-nulls239���different-with-nulls241���different-with-nulls243���different-with-nulls245���different-with-nulls247���different-with-nulls249���different-with-nulls251���different-with-nulls253���different-with-nulls255���different-with-nulls257���different-with-nulls259���different-with-nulls261���different-with-nulls263���different-with-nulls265���different-with-nulls267���different-with-nulls269���different-with-nulls271���different-with-nulls273���different-with-nulls275���different-with-nulls277���different-with-nulls279���different-with-nulls281���different-with-nulls283���different-with-nulls285���different-with-nulls287���different-with-nulls289���different-with-nulls291���different-with-nulls293���different-with-nulls295���different-with-nulls297���different-with-nulls299���different-with-nulls301���different-with-nulls303���different-with-nulls305���different-with-nulls307���different-with-nulls309���different-with-nulls311���different-with-nulls313���different-with-nulls315���different-with-nulls317���different-with-nulls319���different-with-nulls321���different-with-nulls323���different-with-nulls325���different-with-nulls327���different-with-nulls329���different-with-nulls331���different-with-nulls333���different-with-nulls335���different-with-nulls337���different-with-nulls339���different-with-nulls341���different-with-nulls343���different-with-nulls345���different-with-nulls347���different-with-nulls349���different-with-nulls351���different-with-nulls353���different-with-nulls355���different-with-nulls357���different-with-nulls359���different-with-nulls361���different-with-nulls363���different-with-nulls365���different-with-nulls367���different-with-nulls369���different-with-nulls371���different-with-nulls373���different-with-nulls375���different-with-nulls377���different-with-nulls379���different-with-nulls381���different-with-nulls383���different-with-nulls385���different-with-nulls387���different-with-nulls389���different-with-nulls391���different-with-nulls393���different-with-nulls395���different-with-nulls397���different-with-nulls399���different-with-nulls401���different-with-nulls403���different-with-nulls405���different-with-nulls407���different-with-nulls409���different-with-nulls411���different-with-nulls413���different-with-nulls415���different-with-nulls417���different-with-nulls419���different-with-nulls421���different-with-nulls423���different-with-nulls425���different-with-nulls427���different-with-nulls429���different-with-nulls431���different-with-nulls433���different-with-nulls435���different-with-nulls437���different-with-nulls439���different-with-nulls441���different-with-nulls443���different-with-nulls445���different-with-nulls447���different-with-nulls449���different-with-nulls451���different-with-nulls453���different-with-nulls455���different-with-nulls457���different-with-nulls459���different-with-nulls461���different-with-nulls463���different-with-nulls465���different-with-nulls467���different-with-nulls469���different-with-nulls471���different-with-nulls473���different-with-nulls475���different-with-nulls477���different-with-nulls479���different-with-nulls481���different-with-nulls483���different-with-nulls485���different-with-nulls487���different-with-nulls489���different-with-nulls491���different-with-nulls493���different-with-nulls495���different-with-nulls497���different-with-nulls499���different-with-nulls501���different-with-nulls503���different-with-nulls505���different-with-nulls507���different-with-nulls509���different-with-nulls511���different-with-nulls513���different-with-nulls515���different-with-nulls517���different-with-nulls519���different-with-nulls521���different-with-nulls523���different-with-nulls525���different-with-nulls527���different-with-nulls529���different-with-nulls531���different-with-nulls533���different-with-nulls535���different-with-nulls537���different-with-nulls539���different-with-nulls541���different-with-nulls543���different-with-nulls545���different-with-nulls547���different-with-nulls549���different-with-nulls551���different-with-nulls553���different-with-nulls555���different-with-nulls557���different-with-nulls559���different-with-nulls561���different-with-nulls563���different-with-nulls565���different-with-nulls567���different-with-nulls569���different-with-nulls571���different-with-nulls573���different-with-nulls575���different-with-nulls577���different-with-nulls579���different-with-nulls581���different-with-nulls583���different-with-nulls585���different-with-nulls587���different-with-nulls589���different-with-nulls591���different-with-nulls593���different-with-nulls595���different-with-nulls597���different-with-nulls599���different-with-nulls601���different-with-nulls603���different-with-nulls605���different-with-nulls607���different-with-nulls609���different-with-nulls611���different-with-nulls613���different-with-nulls615���different-with-nulls617���different-with-nulls619���different-with-nulls621���different-with-nulls623���different-with-nulls625���different-with-nulls627���different-with-nulls629���different-with-nulls631���different-with-nulls633���different-with-nulls635���different-with-nulls637���different-with-nulls639���different-with-nulls641���different-with-nulls643���different-with-nulls645���different-with-nulls647���different-with-nulls649���different-with-nulls651���different-with-nulls653���different-with-nulls655���different-with-nulls657���different-with-nulls659���different-with-nulls661���different-with-nulls663���different-with-nulls665���different-with-nulls667���different-with-nulls669���different-with-nulls671���different-with-nulls673���different-with-nulls675���different-with-nulls677���different-with-nulls679���different-with-nulls681���different-with-nulls683���different-with-nulls685���different-with-nulls687���different-with-nulls689���different-with-nulls691���different-with-nulls693���different-with-nulls695���different-with-nulls697���different-with-nulls699���different-with-nulls701���different-with-nulls703���different-with-nulls705���different-with-nulls707���different-with-nulls709���different-with-nulls711���different-with-nulls713���different-with-nulls715���different-with-nulls717���different-with-nulls719���different-with-nulls721���different-with-nulls723���different-with-nulls725���different-with-nulls727���different-with-nulls729���different-with-nulls731���different-with-nulls733���different-with-nulls735���different-with-nulls737���different-with-nulls739���different-with-nulls741���different-with-nulls743���different-with-nulls745���different-with-nulls747���different-with-nulls749���different-with-nulls751���different-with-nulls753���different-with-nulls755���different-with-nulls757���different-with-nulls759���different-with-nulls761���different-with-nulls763���different-with-nulls765���different-with-nulls767���different-with-nulls769���different-with-nulls771���different-with-nulls773���different-with-nulls775���different-with-nulls777���different-with-nulls779���different-with-nulls781���different-with-nulls783���different-with-nulls785���different-with-nulls787���different-with-nulls789���different-with-nulls791���different-with-nulls793���different-with-nulls795���different-with-nulls797���different-with-nulls799���different-with-nulls801���different-with-nulls803���different-with-nulls805���different-with-nulls807���different-with-nulls809���different-with-nulls811���different-with-nulls813���different-with-nulls815���different-with-nulls817���different-with-nulls819���different-with-nulls821���different-with-nulls823���different-with-nulls825���different-with-nulls827���different-with-nulls829���different-with-nulls831���different-with-nulls833���different-with-nulls835���different-with-nulls837���different-with-nulls839���different-with-nulls841���different-with-nulls843���different-with-nulls845���different-with-nulls847���different-with-nulls849���different-with-nulls851���different-with-nulls853���different-with-nulls855���different-with-nulls857���different-with-nulls859���different-with-nulls861���different-with-nulls863���different-with-nulls865���different-with-nulls867���different-with-nulls869���different-with-nulls871���different-with-nulls873���different-with-nulls875���different-with-nulls877���different-with-nulls879���different-with-nulls881���different-with-nulls883���different-with-nulls885���different-with-nulls887���different-with-nulls889���different-with-nulls891���different-with-nulls893���different-with-nulls895���different-with-nulls897���different-with-nulls899���different-with-nulls901���different-with-nulls903���different-with-nulls905���different-with-nulls907���different-with-nulls909���different-with-nulls911���different-with-nulls913���different-with-nulls915���different-with-nulls917���different-with-nulls919���different-with-nulls921���different-with-nulls923���different-with-nulls925���different-with-nulls927���different-with-nulls929���different-with-nulls931���different-with-nulls933���different-with-nulls935���different-with-nulls937���different-with-nulls939���different-with-nulls941���different-with-nulls943���different-with-nulls945���different-with-nulls947���different-with-nulls949���different-with-nulls951���different-with-nulls953���different-with-nulls955���different-with-nulls957���different-with-nulls959���different-with-nulls961���different-with-nulls963���different-with-nulls965���different-with-nulls967���different-with-nulls969���different-with-nulls971���different-with-nulls973���different-with-nulls975���different-with-nulls977���different-with-nulls979���different-with-nulls981���different-with-nulls983���different-with-nulls985���different-with-nulls987���different-with-nulls989���different-with-nulls991���different-with-nulls993���different-with-nulls995���different-with-nulls997���different-with-nulls999�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-uuid/�����������������������������������������0000775�0000000�0000000�00000000000�15100345067�0023753�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/array-uuid/empty������������������������������������0000664�0000000�0000000�00000000000�15100345067�0025022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0023555�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/0187ae825e656c01623dd6d982ab50d490c0c417��0000664�0000000�0000000�00000000012�15100345067�0030702�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/03fa95c77415b6c8691a0dc1d13e195ccd1b897c��0000664�0000000�0000000�00000000002�15100345067�0031132�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/050a6450bd7d5dfb7504532cee17be1b973174bc��0000664�0000000�0000000�00000000032�15100345067�0031116�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������(��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/0699e368418710fc791c8301af3df8895bcfb10e��0000664�0000000�0000000�00000000032�15100345067�0031013�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000���������������������������������������������������������������������������������������������������������������������������������������������������������������������������T������!��ªÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/0bcdbd74d4c3526b71a46282bcfecd7554e70cd9��0000664�0000000�0000000�00000000042�15100345067�0031351�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000����������������������������������������������������������������������������������������������������������������������������������������������������������������������������3���,ôÿÛ��ƒ)�ÿôÿ"ÿÿÿÿÿÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/11f4de6b8b45cf8051b1d17fa4cde9ad935cea41��0000664�0000000�0000000�00000000001�15100345067�0031420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/168bf1eed49508508684c0f0f00b3bca3ed1de9c��0000664�0000000�0000000�00000000042�15100345067�0031266�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ÿÿÿÿÿ�ªªª������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/1957b4d9af53d57c71ce03fe726f3dd55cc5e495��0000664�0000000�0000000�00000000012�15100345067�0031235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000����������������������������������������������������������������������������������������������������������������������������������������������������������������������������Í��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/1f3a7fa8e785a9db380099f29b52ef4598eade72��0000664�0000000�0000000�00000000032�15100345067�0031250�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9�ÿ����ªªª������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/34a3bedc4867e71ae61074746c225378159130b2��0000664�0000000�0000000�00000000032�15100345067�0030547�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������qq%£ŽŽŽŽ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/3542b3da299b536e44e55dca08549bb5ae401461��0000664�0000000�0000000�00000000032�15100345067�0030763�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ü��ù���ü������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/3e8a424e6e48bde8488851a191893d2aab7fa962��0000664�0000000�0000000�00000000032�15100345067�0031077�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������;�ùÿ��@�ªª������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/50f65669e0378f3764acc65e9ec8664db7b77a63��0000664�0000000�0000000�00000000062�15100345067�0031040�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������@����������������������@@�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/5ba93c9db0cff93f52b521d7420e43f6eda2784f��0000664�0000000�0000000�00000000001�15100345067�0031274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/5e1dbb627121d05e51a038be3425414bc3d463f7��0000664�0000000�0000000�00000000032�15100345067�0030744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������;�ÿ���%�ƒƒ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/6326b8e4ed85d653f9a043fca18c638dd4df6d43��0000664�0000000�0000000�00000000002�15100345067�0031230�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/662b18f40ac12457327499dbe84ad32e1a995540��0000664�0000000�0000000�00000000006�15100345067�0030637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/8dc00598417d4eb788a77ac6ccef3cb484905d8b��0000664�0000000�0000000�00000000001�15100345067�0031233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/96ddb4dc6bf60a475735388b8da21dc601275c4c��0000664�0000000�0000000�00000000006�15100345067�0031136�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������$��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/a26c1d3763601a41dc1e36869238eb2986cd1972��0000664�0000000�0000000�00000000032�15100345067�0030637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������‹����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/ac6f615983f527a43aff8bbf3edebef8cc881c33��0000664�0000000�0000000�00000000062�15100345067�0031536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000���������������������������������������������������������������������������������������������������������������������������������������������������������������������������;���;�������0���������������© �������ý�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/e287fdeb24184e2c2f8e162ba90b1fe2dec90dcc��0000664�0000000�0000000�00000000072�15100345067�0031513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿ���!�êÿ������������������ �����!!����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/bool-bool/empty�������������������������������������0000664�0000000�0000000�00000000000�15100345067�0024624�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8/������������������������������������0000775�0000000�0000000�00000000000�15100345067�0024654�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������000226b14bbb5e685204e626484dba42d8996992������������������������������������������������������������0000664�0000000�0000000�00000000432�15100345067�0031600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è����:˜��ï���™™µ]Ú~‰ˆ$Hˆ1ù˜•†ˆ��-�������€³˜ïë������:���ï��� ™™µ]Ú~‰ˆ•���€³˜ïï�����:��˜��ï���Ú‰*•ˆÌH™˜ù˜•}ˆ��fκÕ��fÄ` ‹˜ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿß���€³˜ïï������:˜��µ]Ú~ˆ•ˆ4îH™˜ù˜•†ˆ��fÎÄÕ��fÄ`!X‰‚â���uÇ��Ê���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0005721f2bceba264a5cd791cf6a1e36aaed780e������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€ï³˜ï�è#��:˜��÷�������[½ï$ÿÿ~ù‰����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������001edd3c9db1c2fe30c9f9d446a0b42b58569ddd������������������������������������������������������������0000664�0000000�0000000�00000000032�15100345067�0032366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������=³˜ïï������:˜���ÿÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������002007b1d394a27c4332710e3af9c00dae04aac5������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!aR � ����ñ���ûûÖvqÿÿÿ���b��(���%}`�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0043fbabf9a4d188fb2b4654914a2da5db3d7485������������������������������������������������������������0000664�0000000�0000000�00000000026�15100345067�0032227�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�������������������������������������������������������������������������������������������������������������ÿˆ(‰&ü˜˜‰QAFÿ’ÿF����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������005c46a47f8bf11c68af4134ce6eb0c22db620ee������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032266�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿåÿß¡ÿ���ÿ�È����1����€�� ö��������ú���?���ûö!��ÿÿÿPÿÿÿÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00617fee7e086d32d20dd281ddafa8a726646744������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032071�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������\ÿÿÿMø^����ÿ�È����0����È��ÿö������ú���?���ûö!���¦Îúúúúúúÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00742699a5aad2ead456e90d61c5f9faba0293a6������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032223�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ������?���������������ÿö'�����������������ÿö'���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0076eef47ad215c435ecdb57e2494af0f55fd81a������������������������������������������������������������0000664�0000000�0000000�00000000622�15100345067�0032320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���,™˜‰ˆÇÇÇ»»ÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇLj2îH™˜y˜lywÿ�‰‚âu�Åœœœœœœœœœœœœœœœœœœœœœœœ��� €"!à u� €"!à2€����‚ÈÈÇÄÅÆ� �'�5�« �Y+ �wÿ�‰‚âu�ÅÈØ�&ÁÄÇ�ÊŠ��†‘P�Ì3ÿ+ �Y+ ����--------------------------------------------------------------------------------------------------�ÿÿI�æqÿ���w�����������������������������������������������������������������������������������������������������������������008110c25d8a3a8a8170b7d3ba621cf06d4853c0������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031760�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������_‘‘‘‘‘‘‘‘‘‘ÿ‘ÿ���ñ��������öqÿ��&���ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0081a9f0f585a9b67b2103220cc60d36e2dbbd03������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032035�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿþÿÿÿåÿÿÿÿÿÿÿÿþ��� ���������b���������.����€��ÿö���ÿÿÿÿÿ/��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0088c8e6e015602ba5e40a90986019b4ad512f65������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0031643�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿ@ÿÿÿÿÿÿÿÿÿÿÿÿþ��� ����������������*���ö���€�����ÿ��0������5����:˜�u�4����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������009ffc43f38a56a761e7b83b0f2c8bd026a563bb������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿåßÿÿ@ÿÿÿþ��� ����������bÿÿö������6����€��ÿö��Ûÿÿÿÿ/��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00a2eb7a7e3fdc3bfcac0045554586d5fb5502f3������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032270�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜��� ������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[C������2��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00d5f2c9add73bceda87ef3acd392122d8adb3e4������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³hÿÿÿÿö�:˜������€Þ�Ç�Ê��`� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00f85251b4c47fb81acc131a198a1bc98ca779a1������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� �\���������������ºÿ�ö! �������ñ����������ñ���õ����&����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������015c684cdef94cdf964d0800d325c6849d014324������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0031733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������d������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������016dd5961834fbbcc799ffa91004247e868e2781������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0031762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³˜éþ��[���;`���Ã������R�������z����/�������]�@�������:˜���Ø������������:�������HÁ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������01e3938a0dcce30f75133d8ad80220d2d613f008������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0031760�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ��� �������`���?���������õ�������ÿö'����*³��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������01ec3391b4d39420ac8414c675fc1269955e3c57������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0031660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������� €³˜ïï�����:˜�������™µ]UUUU���� ÿÿÿ%ÿ��øþLgÿ�����:˜����J/�ö!aR �� ���ñ����"�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������02484d2db80b46ff0ae20eafddb5dc45a53140b6������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032345�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ƒÿÿø���V���˜���(���Ñ��™l††ä†Ž†ˆˆˆˆˆˆ���������†lA����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0270028dc334db0bd34fca6e6abbcb9ecdfac57a������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜������€��€³˜ïï��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������029aaf2ff41035a0bf05a6f97fb68d6a62e32974������������������������������������������������������������0000664�0000000�0000000�00000000262�15100345067�0032157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜�ï��ï���:˜���(���&™­]Ú~‰ˆ•ˆzîHß™˜ÿÿ���Ôù˜•†ˆ$í��Ófÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿ�Ž(��::::::ˆzîHß™˜::::::::::::::ÜÜÜÜÜÜÜÜÜÜ�j€��÷�ÿý�#¿��������«. �hhhhÿÿA������·����B�jj�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������02cabee9534673ed1f5b4ce6dc957952166cbe1b������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿ�Bÿ�Cÿþ��������������������*�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������02d459bcf9a9e071c18db18c808245c16833ca09������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������K€³�������ï:š���a���ÃvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvÃ&·2������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������02eb701fa0ab34abda28be9fbba19582790432ad������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0032343�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������{�PPP§ÚÿR � ����ñ���ÁÁÁ��.ÿÿÿ�ÿÎõ����������������[·��ÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁ� 0ÁÁÁÁÁÁÁÁÁ�ÁÁÁÁ���� ����������b��������%��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������03607062b7b4b60f979bdd121981128b7002a561������������������������������������������������������������0000664�0000000�0000000�00000000042�15100345067�0031474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#���:˜������í�� €³˜�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������039c250391321f58181a4cf10a804f6e529eb57e������������������������������������������������������������0000664�0000000�0000000�00000002152�15100345067�0031652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�#è���:˜��v���~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ™™µ]ÿ‚‚‚����������~~~~~~~~~~~~ïþ $/­h\����GGGGGGGGG�������������������GGGGGGGGGGGGGGGGGGGGGGGGGGG•ˆ1îH™$������‚���€"!à� ÇÊ �����������������������������������������������������������������������������  ßÞ ÑØ�,������và  �(�p(�,.í A’–§œ�  �����‚ÈÇÄÅÆ� ù˜•�� ™™µ]  ßÞ ÑØ�,������v���€³˜ïï�è#���:˜��v���v~~~~~~~~~~~~~~~~~~nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~���€³�ï��ï˜���:˜���ï���]Ú~‰ˆ•ˆ4ïH™˜ù˜•†ˆ��fÎÄ@@@˜@@@@@@@@@@@@@@€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€„€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€€ˆ€€€ööööööööööÃÎ  �(�p(�,.A’í– §œ�  ����³ï��� ÇÊ �  ßÞ ÑØ�,������vÃÎ  �(öööööööööö³öööööööööööööööööö�€"!à� ÇÊ �  ß××××××××××××××××Ù××××××××××××××××ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××Þ ÑØ�,������vÃÎ  �(�p(�,.A’í– §œ�  ����p(�,��.í A’–����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������03f6be1bf6529592f3e57d28e1e8ad46953f7c51������������������������������������������������������������0000664�0000000�0000000�00000000022�15100345067�0032117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€�����ÿ�¼ù€ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������04096d38044e4074f2b0541b455ed0ecc9a059fe������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032001�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿþÿÿÿÿÿÿÿÿÿÿÿþ��� ����������������*������€�����ÿ��0������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������041ef2e92911ab4633fbc16bf5457fe25d723ae8������������������������������������������������������������0000664�0000000�0000000�00000000312�15100345067�0032152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ�X�î?�)�‹����������������taR � ����ñ���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿø¹ÿ�ÿÿ�������������������������������������������������������������������������������[������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ8ÿÊ÷�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������044d5359fc697f71c9f1cd7ab773f025f38ccae6������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿåÿßÿÿÿ�����=���9������ÿö�B������]���@������ÿö�B����]����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0459cc74fd756782cfb3c84c956abf1df632d453������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032177�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������_-‘‘‘‘‘2���������ñ�����º�ÿöqÿ���A��ÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������04826e1568e927a9de9d23e013fac8f4704d230e������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������!€)˜ïï�è���:˜��ï����ÉÉÉÉûýþÿ€���ýü ��?�¿�ÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������048b8752a6490e051d3b4a9ac3c6279953cc8279������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0031670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜��� �����[{[[[[(������r����˜���[[[Û[[[[[[[[[[[[[[[[������ï[ÿÿ�X�î��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������04bdfef2ca95152c9a0525bee938b2ed74c316e9������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X � ���������������ø��! ��� ����ñ���ÿÎÎÏ��!ñ���ÿÿÿ+��0Y€Œö!ÿ � ��¤��¸ÿ���ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������04f3abff8e30697834380a3c2f0e238cab099e2b������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿ[ß*����Á��������� @?ÿõ�����������0���� @?ÿõ ÿÿÿÿAÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������05f24e5eb37b55471dd9eae8c4194b4f65e25067������������������������������������������������������������0000664�0000000�0000000�00000000032�15100345067�0032107�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ�1�îƒvõ‹������(����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������05fb4342fad4ba26e0e2d21742bc65fe70cf3ff5������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032354�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùþ����� X���������������ºÿ�ö!���� ����ñ���ÿÎÎÎ��ñ���ÿÿ����:����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06033906c750496425efa6b85c31caa8b7781f34������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0031653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿåÿß¡ÿ���ÿ�����0����€��ÿõ������������2���€�� ÿÿ�� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������063e248ade3d6d40b6cf4c96ef4ff0164c099f7c������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032325�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������A€³˜ïï������:˜���(���ö�p�-™™"""ö�p�™""""þÿÿÿ����""""""""+"��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06449ffa405bcd2cf8652e4fc82f93fb701f053c������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0032242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜�ï��ï���:˜���(���2™­]Ú~‰ˆ•ˆzîHß™˜ÿÿÿ���Ôù˜•†ˆ$í��ÓfÿÿÿÿÿG���ÿÿÿÿÿýÿ�Ž(���ÿÿÿÔr` ‚âuÇ�Ê�Á������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0663f93bee6cc22be2a74ffd2719d6296e74334d������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0032173�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€²˜ïï������:˜���ï���......................................�‚�����������������������.....����Ñi� �YPÇæÅÊ��ÃÆ���‚�������������������������c��I��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0688f3c387bbd17d82c2b3f7dadf3042f768887b������������������������������������������������������������0000664�0000000�0000000�00000000202�15100345067�0032176�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³˜éþ������;`���Ã��� ÿÿþ/ÿÿåÿß¡ÿ���ÿü�0�������������������������������¸íƒ�����*�fù˜•ÿö��� ý ��†ˆ��-����HÁ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06905c0515b1cc8f21c39c69adf954607aa1ef97������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������K€³������ï:š���a����_‘‘‘‘‘‘‘‘����������€����%��vvv���D4��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06f2e370b0e257bc75726698ff4b05d31fbc82ca������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X������������������ºÿ�ö!���� �������ÿÎFÁÁÁÁ*��ÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁ����ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������070b4ae2222399e9432f58f67029a7794526a992������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0031461�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� ����������������ºÿ�ö!�%�ü�������ñ���@�~ÿÎÿ/ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0720f498d7a2de389fee84f09d7d5f8decfa76bd������������������������������������������������������������0000664�0000000�0000000�00000000162�15100345067�0032520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ÿÿÿÿøÿ�ÿ'���:˜���(��� ™™µ]Ú+++++++++$���++++��������@��++++++++++++++++++++0++++++++++++++++++++++ÿÿÿjj���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0761d21c1bed0dc463b92f5c114d170293f17735������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0031714�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���(���¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤KKKKKKKKKKKKKKKKKKKKMMMMMM� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������078dd3d695a19d89d78ca5ce6cb5ad394b72800f������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032260�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿþ���������þÿÿ|��*��ÿÿ ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07946f273216738b476a364fedf5eaae34c08ecc������������������������������������������������������������0000664�0000000�0000000�00000000202�15100345067�0032164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�€�:�˜�������� ™™±‰~Ú•]gˆzî���ÿÿÿÿÿÿÿÿÿÿÿÿ%ÿÿÿÿÿÿÿÿ�������Hÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�ÿÿÿÿ�ÿÿxŠ���j�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07c4739c2e79966c2678d5189115d31469f6cfa6������������������������������������������������������������0000664�0000000�0000000�00000000232�15100345067�0031637�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€²˜ïï������:˜���ï���.............'��/b���.......................�‚��������.....����Qi� �YPÇæÅÊ��ÃÆ���‚���������;����������������c��I����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07d34e1cb03d70ba8e83a11c1cddad7fcb083855������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€���$��:=��÷���X���„` 4ÊÊÿÿÿÿÿÿÿÿÿÿÿ�����A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07ddb4cff1428ceb1fc0edb6dc8ad7bfadcb8233������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0033021�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€²ïï������:˜���ï���..;ÒÑÑÑÑÑÑÈ��ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����l�������.....�Ñi� �������c��I������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07e310a31ea039330c339d6a5140c067dee5b44f������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0031764�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜������ÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅ���@���ÅÅÅÅÅÅÅÅÅÅÅÅ��ÿ��-�UUUUUUUUUUU¸ÿÿÿÿÿÿÿ½x#w——wÿÿbf]��f��x ������jjj���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������081e0108c111c717c98f33c9af02b536eaf50349������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������<»ÿ�ö! öÿ���������€!���ç���ÿÿÿþ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������083014d7487b279086470af22a3716c7bfc00630������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0031503�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�������������������������������������������������������������������������������������������������������������:=���X���¹=���X���¹ÙµˆˆÚ~3™Ê����ïï���ß*r�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������08e95e19e9ff57fc53b0959896df624e02fdf75f������������������������������������������������������������0000664�0000000�0000000�00000001062�15100345067�0032236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������������è#���:˜��v���?MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMqqqqqqqqqqqqqqMMMMMMMM�¤¤¤¤¤¤¤¤�������Š���ÿÿÿÿ÷ÿÀ‰‚ßÞ ��€³˜ïï������Æh�����ÑÿØ ,�����vÃÎ� (.~~–§œ�‡�  �ÿ���‚ÈA’]ÿ‚‚‚��� ,�����vÃÎ� (.~~–§œ�‡�  �ÿ���‚ÈA’]ÿ‚‚‚����������������  ßÞFFu��FFµ\€ö1”F�€³˜ïï������:˜�;���€¯�ïï������:˜;;;­­­­­���ï���8X-�ú���8X-?���������@¯¯Ô¯¯¯¯¯¯¯¯­­­­­)€³˜ïïÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�è#���:�˜¯¯¯�:˜�...������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������090a8933ed1391740a094bb7a19e913db10ca6c9������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0031776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿíÿß¡ÿ���ÿ�È����2����€��ÿö��������ú���@���ö!���P1�PPPP�z��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������094f5fdd281c4a9d67f1fac1179708a0753071b3������������������������������������������������������������0000664�0000000�0000000�00000000472�15100345067�0032024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���!ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ���b/��(���ÿÿÿ�����,����������������������Q��������������vqÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€���€³[[[[â������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������09808f60497dfc988e43f40c8dcfc864b46e4c23������������������������������������������������������������0000664�0000000�0000000�00000000642�15100345067�0032140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���.ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���å[���ÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ���b/��(���ÿÿÿ�����,����������������������Q��������������vqÿÿÿ���b)��(���ÿÿÿÿ¿���å�À��[qÿÿÿ���b/��(���ÿÿûÿ¿���b/��(���ÿÿÿÿ¿���å[���ÿÿÿÿÿ���b/��(���ÿÿÿÿ(���ÿÿûÿ¿���b/��(���ÿÿÿÿ¿���å[���ÿÿÿÿÿ���b/��(���ÿÿÿÿ¿[[[[[[ââ����������������������������������������������������������������������������������������������09c504d74d0697ff4bb25681dbd5f9bbe603154b������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032160�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������ÿÿ�X�î��R� ���Ñ���ÿÿöaÿÿÛAð��S����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0a1054b55fab3e07cb841de17cf76a14937f2d49������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032142�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ��� �����������?����������������ÿö'ü���ÿÿ³��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0a4e527b4885a1a89b1f7b899282c09023184075������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���7���€çÿÿÿFAµ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0a606eef286c1a80546c24253468898684b711f4������������������������������������������������������������0000664�0000000�0000000�00000000552�15100345067�0031537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���à���'™™˜ššššš“ššššššššš@šššššš���DDDDDDDD|UÃÈ)Î���É1Œ5™?�(�Ê�'™™˜ššššš“ššššššššš@šššššš����������������z����������������õ����5Ž(r`N-X‰‚����������������‰��;`���������������������õ����5Ž(r`-X‰‚���������ÿÎÎÎ��ÁŸ‚��‰�`�����ï��¯�����¿ÿÿÿÿÿ/333n�jy���7777777777777777777777777777��€³˜é`0Ž(]Y�������������������������������������������������������������������������������������������������������������������������������������������������������0aa2ce83cc47ebd7457452ee44eec44ef5ae8945������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï���:��˜�������‘™±]‰ÿÿfÿ•~Ú���������ü�2������€������5������8�ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b4693f634921fc1aff558120380550054c7dc79������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0031572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!áR � ����ñ���ûÖvqÿÿÿ��žÿÿ(���âÿÿÿÿ��žÿÿ(���/�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b4c9c405bc395ee2064a3790820618c62af22eb������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032000�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������<»ÿ Þÿa÷�:� ���þ���a÷�� öøÔÛÿ02F��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b8493a4edb47558fa3dfa9cb3b3ca0d3af16971������������������������������������������������������������0000664�0000000�0000000�00000000522�15100345067�0032372�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������/ÿÿåÿß¡ÿ��B�������0����€��ÿõ��R$� ����ñ���!ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������������������������������������������������������������·��������������������������������������)�����������������ÿ�����a������������������������������������`����������������������������ÿ��������aaèèAAAAAAAA��'��­­­:J/VVVVVVVVVV[VV­z�Àâßÿÿ@ÿÿÿþ��� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b9dbabf75544aeaeb4301aa3e3b367681eee4bd������������������������������������������������������������0000664�0000000�0000000�00000000042�15100345067�0032513�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ ���� �������ø����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0bb58d3d928b75d5bbbb534d8fbcc02e7cec61b7������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032526�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X ������������������ºÿ�ö! ��� ����ñ����Î��!��ñ��ÿÿÿ��:€Œö������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0c1bf5358361ad43e3718d79b16153c848257dbc������������������������������������������������������������0000664�0000000�0000000�00000000032�15100345067�0031735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�~���:���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0c2cf9c105698a12da9f7c1de00897a6039adbd9������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ��� ��������C������¿����ø���€�����ÿ�� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0ceae4f10fc61a7f91b69b3481882a5ce5e57c38������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032244�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï����� ˜������„î ™™µ]• ÉÆÎË32��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0d48d19aef5682445e6b8724da523f6ad334d5c8������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032112�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ì�#˜�è�:���ñ���ûÖvr�ÿÿ���� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0d87d016d0e51c749adb95b1192d3cbdacd8ff96������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032377�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������� €³˜ïï €³˜ïï���ï���ï���ÉÉý¿��ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0da96dc1d241308ec033b9628a519fda371defc6������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032223�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïá���:�$:˜���X��� ™˜‰ˆÇÇÇ��ÿÿÿ’�����[������³€ÿÿÿÿÿ’��������� ]�z�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0dc7fd92992bdf76b8a7edf1819ebfbb1a7b6382������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������Ð/��Ñ���������B�����ûÖvqÿÿ�b/��(�ÿÿÿ¿��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0e039859b8723df22cb8f4cf0831efd10f7df2d3������������������������������������������������������������0000664�0000000�0000000�00000002032�15100345067�0032243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#���:˜��v���z~~~~~~~~~~~~~~~~~~nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnˆfnn���nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ µ]Ú~~~~~~~~~~~~~~~~~öööööööööööööööööööööööööööööö³öööööööööööööööööö�€"!/à� Ç#Ê �  ß××××××××××××××××Ù×××××××××××××××××××××××××××××××××××××××××Þ~~~~~~~~~~~~ööööööööööööööööööööööööööööö!³öööööööö�€"!à� ÇÊ �  ß××××××××××××××××Ù××××××××××××××××××××××××××××ííííííííííííííííííííííííí××××××××××××××××××××××××××××��,€³˜éþ������;`���Ã���…ˆˆ†¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸××××××××××××��,€³˜éþ������;`���Ã���…ˆˆ†¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸××××××××Þ ÑØ�,������vÿÿÿ  �(�p(�,.A’í– §œ�  �����‚ÈÇÄÅÆ� ù˜•�� ™™µ]!‚‚‚‚‚‚‚‚•†ˆ��� ������w™™µ]Ú~‰ˆ•ˆ2îH™$��¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸0ÿÿÿ½x#s�������€"!à� ÇÊ —�� ¸¸¸¸¸¸¸¸¸¸0ÿÿÿ½x#s—������ ßÞ Ñ‚‚‚‚•†ˆ��� ��������€³�����Àÿßÿߘ¹îúÿÿÿÿÿÿÿÿÿÿ��������ÿ™™µ]Ú~‰ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ`ÿÿÿÿ���€³�����Àÿßÿߘ¹îúÿÿÿÿÿÿÿÿÿÿ�������ÿÿ`ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0e6947636358abbcaf4704335de9ce6bf1b3bb37������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0032237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ï-�‚����:˜���(���øhR}ÇÇÇÇÇÇ�����ÿÿÿÿ[[[[[[[��âÿ€€³˜ïÔ�è���:˜������€�-ÿð�˜��ÇÇÇÇÇ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0ea3cbbe4df13a9c00137579b048da07ac4620da������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������Äüÿf`œÿÿ��:˜���(���:ÿR™™­]H�ÿú™­]H;•ÿÿÈ�¶����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0f069ba7b764acb518096d549c272968ef139baf������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032112�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�z ������������������!���� ����Ñ���ÿÎÎÎ��ñ���ÿÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0f24070fee9fd323f32004b8a19e19e4899669c5������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031755�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ï¯�~����:˜��������������˜é(`‰���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0f5b129fcbfde4a2b74de973536594536a702b17������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿß*����Á������0������:õ����������������������ÿÿÿÿÁ����;ïÿÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0f6b55a491e86c632769c11bcd0e401e8d736c17������������������������������������������������������������0000664�0000000�0000000�00000000552�15100345067�0032023�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������/ÿÿåÿß¡ÿ��B�������0����€��ÿõ��R � ����ñ���$ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������������������������������������Š��������������������������������������öÿ�����a�����������������������������L��,�����������������������Q����������������������������������������������������������������������������������������������C����������������������������������������������@��������������������������������������������������������������������������������������������������������������������������������������������������������0fbc8b98efd055002d0a9b1f1585c16e1bcafbf5������������������������������������������������������������0000664�0000000�0000000�00000000272�15100345067�0032444�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ�X�î?�)�‹����������������taR � ����ñ���ÿÿÿ:ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿÿÿÿýÿýÿÿÿÿÿÿÿ$ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿÿÿÿßÿÿÿÿÿ������!��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0fe403cf9e514edaba7624592e57dedd44d8f974������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿßÿÿÜÿ����@=���6�����ÿö�B�����y]�������7A�ÿö���������ÁÁÁ�]��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������10cb10b75109d9f5a51df8cc25e5922ab9304486������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032001�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€2šÊÿ����;�:˜���)���ÿüG�]µÝÚ~|ƒƒƒƒƒƒƒƒƒƒƒƒ332f��ƒ�b���€ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1234967d87289b5476e82e03a5fdaddfb2d89f5d������������������������������������������������������������0000664�0000000�0000000�00000000662�15100345067�0032217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���0™™˜‰ˆÇÇÇ»»»»»»»»»»»»»»»»ÿÿÿÿÿÿÿÿÿÿ0000000000000000000ÿÿÿÿÿÿÿÿÿÿÿÿÿ0000000000000000000000000000000000000000000000»»»»»»ÿ�������ÿÿÿÿcccccccccccccccccccÿÿ�»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ»»»»»œœœœœœœœœÈØ�ÁÄÿÿÿÇ�Ê��ÿ�ÿÿÿÿÿÿ×�D,„ÍÎ ~Š���������€"!à4€����‚ywÈÿ�‰‚âu�ÅÈØ�&ÁÄÇÿÿ�ÊŠ���±�����I������������������������������������������������������������������������������12429bc13e7a80e8566e6355325baba779106594������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0031577�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿß*����Á������0���� @?ÿõ������������8����������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿç������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������12af146da39094e9e46dd07e119ef8104840a0d8������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���(���*�*�ccczîH:Çuß�Ê������Å�³˜-ïzîHÇ�ÅÈü������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������13197c60bcdca232644653ced7bea29b141dc3d0������������������������������������������������������������0000664�0000000�0000000�00000000522�15100345067�0032210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���$6™™˜‰ˆÇÇœœœœœœœœœ�ùœœœœœœœœœœœœÈØ�Ç»»»»»»:»»»»»������������������������������(������������������������������������������»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»» «««««««««««««««««««ÑÿÿÀ««««««««««««««««««««««««««Ü³˜éÞuÂÂÂÂÂÂvÂÂÂ������œœ�������taR � ���ñ���.ÿÿÿÿÿÿÿœœœœ���œœœÈØ�?8ÿÿÿ�ÿÿÇ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������133c2effbe5ad58905ac393dfdd16ca1fa2c7eb7������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!aR � ����ñ���ùûÖvqÿÿÿ���b��(�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������134b9385f7a8269fa53a25d14207c72ec1088f81������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0031660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜��� ����{_$$$$$$[-[������ï[ÿ���{[$$$$$$[[����Xaî������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������13f9787e9557c5d37424143c6bb87a34a91dc233������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031672�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������ÿÿÿÿÝ*����Á���������?@ÿõ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������14259b5a7c8b7095dd40e602ce8fdc4d208c00a3������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������z�€%���óïï���:˜������^���³ïï�����bÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������14964c2e5d120c7acf5fca81233b916b3b3016fc������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032130�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ï ������:˜��� �����[{_[[[(���T����ø��ø�r�����Fÿÿÿ��/�����ÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1573858c8eb6d027bbdaa303eaf5d57c978b3465������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032166�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������Æh������€î��� ™™µ��™�˜x��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1669aab7adfb7e65162eda52612d49e0f252d270������������������������������������������������������������0000664�0000000�0000000�00000001072�15100345067�0032151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���@âââââââââââââââââââââââââââââââââââÿÿÿÿÿÿ/������������������������������������������áááá'áááááî�ÁÄ��ï����³ïï˜ÿÿÿÿÿÿ¿ÿ“hh~h»»»»»»»»»»»»»»»»»»»�ÿ�4�ÿ»ÿÔr` —!ÿÿÿ:�ÿ�:��ÿhÚí������fù˜]•†ˆ��-�������€�ñ���câââââââââââââââââââââââââââââââââââÿÿÿÿÿÿÿÿÿÿ�����A–�ÿÿÿ�ö!a��ÿ�&������H���ûÿÿÿàöÿÿÿÿ[ÿÿSSSSSSSSSÁÁ������������������������Ç������������� ™™`)�����ð��=====ÁÁÁÁ�������������������������������������������������������������������������������/Á===èèèèèèèèèèøøøøøøøø»»»»»»»»»»»»»3���ÿÿÿÔr` —!ÿÿÿ:�ÿÁøøøÁ���:��ÿ�ÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1697392b1fb9f4b49c80030d6b3017d72d4ede4c������������������������������������������������������������0000664�0000000�0000000�00000000312�15100345067�0032074�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ü€³˜ïï�Õ����:˜��ß���#######:#ý���L�2�_�������-���########p######™™µ]Ú~‰ˆ�������##########################Ý™$ùl�-�������€³]Ú~‰ˆ•���€³˜ïï������:˜��ï���™™µ]Ú~‰¹Ð�]�Aµ�Í�Sx����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������176236dd152ebf4fa259212b539fbc49d9dd1799������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032116�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8������������������������������������������������������������������������������������������������������������������A:����˜���(������™"™""�""�ï�:˜™"™"ÿÿÿ���""˜����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������17896100eabd31d729b38a703da3f31e57fdf4b8������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������*�€³˜ïï������:˜���(���™î­]ÚDv‰ˆzîc|¶ÿÿÿÿ.�� 1Ž�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������17e00a1df1c9b937d50a5a890562587f1196b646������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0031656�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ��� ����������������*��� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������18c4bd81a648ee9d7db0dc68c4615a22ffd4cd72������������������������������������������������������������0000664�0000000�0000000�00000001142�15100345067�0032404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���Dâââââââââââââââââââââââââââââââââââÿÿÿÿÿÿÿÿÿÿ�������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����âââââââââââââââââââ��‹ââââââ�âââ�ùÿ�èÇÆÿÿÿ�€³˜����ù�ùÿ�X���������������ºÿ�ö!ÿ���� ����q������Î�ñ���ÿÿ/��.�:˜���ï��� ™™`­’~~~~~~:�nnnnnnnnnnnlnnnnnnnnnnnnnnÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùÿ�X�� ���������������ºÿ�ö!ÿ���� ����ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿnnnnnnnnÏ�������nnn­­­­­­ÿÿ�S��ÿü���?�¿��������«�ÿ�ö!q���Î�ñ���ÿÿ/��a��&����~~~~~~~��===ÿ�X � ������+�����=====èèèèèèèèèèø.����øøøøøøøøøø�(������Á���J/�ö!������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������19308702d029cceef2220db8c57fbae88ef17f44������������������������������������������������������������0000664�0000000�0000000�00000000152�15100345067�0032242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������€³˜ïï�ÿÿü+:�$:˜���X��� ™˜‰ˆÇÇÇl»»³³³³³³³÷����������Qá;���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿö�������÷������� !�]������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1937ed2d8de2d8577fc48a407ded56d272e40096������������������������������������������������������������0000664�0000000�0000000�00000001222�15100345067�0032121�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�����:˜��v���JnnnnnnnnŒ‘‘‘nnnnnn+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn~~~~~~~~~~~~~~~~~������������������³³³³³³������u³nnnnnnnn~³³³³³³³³³³³³³³³³³³³³³³³³³CL³³³³³³³³³³³³³³³³³³³³³³³³³³³³����������������������������������������������³�������������������������(�,!aR � ���.A’QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ��QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ5Ž(r6h!X‰‚Å����;`�:�ÿ�:�¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬���ï�����������“““““  �(�,ŽÒìÉh““““““““  ��������������(�,.A’QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ��QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQªQ��fÄ` ��ÿÿÿÿÿ��*ÿÿ¾–|U¥�������Í������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1a8f7f5dd5f42e1ae89b55a47e1fa45cab816e62������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ�X�î?�)�‹������������� ����€€³ˆ!ïåR �ÿî������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1b110f70f70d47d01b6f55110d5719e3dd19d893������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0031721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������”�J/ö!aR �������B���ûÖvqÿÿÿ���b/��(���ÿ÷ÿÿ¿���å�[����ö“ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1b1f4b7a41866daf1fd4f2aaeb6aaecea3bea926������������������������������������������������������������0000664�0000000�0000000�00000004522�15100345067�0032740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ��èèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèêèèèèèèèèèèèèèèèèèèèèîèèèzèèèèèè­­­­­­­­­ÎÎÎÎÎÎÎÎÎÎΤÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwòwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwέ­­­­­­­­­­­­­­­­­­­(�,.1 A’–§œ�  �A�/���‚ÈÇÄÅÆ� ù˜•ÿü���~~~~~~~~~~~~~~~~~~���¢³�ï��ï˜���:~~~~­­­­­ÿÿÿ)Ù�­­­­­~~~~~~~~~~~~ÃÎ  �(�p(�,.í A’–§œ�  ��/���‚ÈÇÄÅÆ� ù˜•ÿü���?�¿��������«�.ÿ�ö!a��&������H���ûÿÿÿàöqÿÿ��`����Ø�� ����ïïïïïïïï­­­­Ù�­Q­­­~~~~~~‰�� ™™µ]  ßÞ Ø ,�î™$ù˜ÿÿ�X�î�@Š�‹������������»ÿ�aR �•�!Xb!��hhhhhhhhhÿÿ�X�î��)�‹������������ºÿ�ö!aR � ����ñ���ÿÿÿÿÎÎÎÎÎÎÿÿ�X�î��)�‹��ÿÿÿÿÿÿÿ������ ™™µ]Ú~‰ˆbˆzîH( ™R � ����ñ���÷ÿÿÿ�������ÎÎÎÎÎhhhhhhhhhh~hnhhhhhhhhh~hhÚí������fù˜•†ˆ��-�������€³˜ïï������:˜���ï��� ™™`������ð��============================���~~~�����������������������������€³˜ïï�è#���:˜��v���X�î»»»»»»»»»��������?����������������������������������������'��­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ÑÑÑÑ����ÑÑÑÑ�ââââââââââââââââââââââââââââââ°âââââââââââââââââââââââââââââââââââââââââââââ�ùÿ�èÇÆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­­­­­­­­­­­­­­­­’~~~~~~:�nnnnnnnnnnntnnnnnnnnnnnnnnnn�������nnnnnnnnnnnnnnnnnnnnnnN­­­­­­­­­­­­­­ÿ˜���o���üÿÿ€�ÑÑÑÑÑ����ÑÑÑÑ�ââââââââââââââââââââââââââââââ°âââââââââââââââââââââââââââââââââââââââââââââ�ùÿ�èÇÆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­­­­­­­­­­­­­­­­’~~~~~~:�nnnnnnnnnnntââââââââââââââââââââââââââââ°âââââââââââââââââââââââââââââââââââââââââââââ�ùÿ�èÇÆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­­­­­­­­­­­­­­­­’~~~~~~:�nnnnnnnnnnntnnnnnnnnnnnnnnnn�������nnnnnnnnnnnnnnnnnnnnnnNnYYYYYYYY­­­­­­­��������������������­­­­­­­­­­ÿÿ�S��ÿü���?�¿��������«�.ÿ�!öa��&������H���ûÿÿÿàöÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ­­­­­­­­­­­­­­­­’~~~~~~:�nnnnnnnnnnntnnnnnnnnnnnnnnnn�������nnnnnnnnnnnnnnnnnnnnnnN­­­­­­­­=���~~~�����������������������������€³˜ïï�è#���:˜��������� ���€³˜�������»»»»»»»»»��������?�������������������������������������������­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­� ����­­­­­­­­­­­ÿ˜���o���üÿÿ€�ÑÑÑÑÑ����ÑÑÑÑ�âââââââââââââââââââââââââââââââââââââââââââââââââ�ââââââââââ�ââââââââ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1b2d9c2d949b251a2ca3eecd2d8f29cf96334611������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������ÿÿ�X�î��R€ˆ���������ÿÿ�X�‹�����ä����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1b53e293c41a7b6bd041098fa91aab2e5ef4ab16������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032270�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������<»ÿ�ö! öÿ���������€!��çÿ���~ÿÿÿþ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1ba5cd685ecccdac9caa92377346315ce6d6c293������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³˜éþ������;`���Ã���/ÿÿå���J/�ö!aR ��Á���������%}`�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1bc1d2f6da12c6cd0eaab779fe69b872c1b427b0������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032433�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ��������������������*���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1c66535a7d66622db6aac4ee1df14b1db1369b41������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032216�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!aR � ����ñ���ùûÖvqÿÿÿ��b��(���,��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1d1ae6b78379f1aea79abee08338cd4762ebab3c������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿ%ßÿÿ@ÿÿÿþ��� ����������bB���������0����€�ö�ÿ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1d2e73934349bc80d13e3c1581eb915d7e658666������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031674�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������J���Á�*���������������““ ÿÿÿÿÿç��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1d7c3373fc113bbe6f4eb12600fddde935ec69bb������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032441�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������/ÿÿåÿß¡ÿ���ÿ�����0����€��ÿõ������������3���€��ÿö��� � �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1dbe1fffa3a5edddbc95ecf5e496236386b1b928������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032551�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³˜!���� ����ñ����Î@øÿ��������%}`���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1e783d97191cec0a7095c81805cc5de7a5d1355c������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������ÿ�/ÿî�Š@‹�)����ð���ÿÿv'ÿÿÿ��?�bå��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1ea298a60f91377c5e8852dab8a10cdbc66a7702������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032160�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ��� """""""""""""""""""""""""""""""""""""#"""""""""aR �# ����ñ���"""""""""""""""""""""""""/ÿÿåÿß¡ÿ���ÿ�����0����€��ÿõ������������3���€��ÿö���""""""""""""¢"EêâââââââââââÛââââââââââââ+âââââââââþâÿÿÿÿÿÿÿÿÿÿÿÿ �����������:˜�ùÿ����� X �����(��� � �����Á����J/�ö!����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1fce78dca10eecad74006cda5b0619c1530a90dd������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�R���:˜������™!££££vvvvvvv''''''��q%}`�ÆÆoÆÆÆÆ�������������‡��D,„����þÿ�h���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������21d3312341b1626ba6bfd29568e2ef50c60538d8������������������������������������������������������������0000664�0000000�0000000�00000000272�15100345067�0031730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���™DDDDDDDDDDDDDDDDØ���!™DDDDDDDDDDDDDDDDDDDDD|UÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������������������������������������������D”0=+�þÿ�å���€ÅD� ���X��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2263ed26b47e2066384bab5c098b26f13faf5ee1������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������Ð/�ö!aR �������B���ýûÖvqÿÿÿ���b/��(���ÿå[����—öa�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2344a89366d1eee87d8bb3e54b620b02c68abc96������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8������������������������������������������������������������������������������������������������������������³ï�����:˜������€çÿÿÿFAµ��™�˜x��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������237df2b50d5437a256391b6efde8d6ced3a006e4������������������������������������������������������������0000664�0000000�0000000�00000001072�15100345067�0032235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������ÿ�€³˜ïï�è#���:˜��v���@WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW†††††!aR � ����ñ���ûÖvqÿÿÿ���/�  �����‚ÈLj3îH™$€€­’~~~~~~~~~~~~~�OOO�ÿÿÿÿùùùùùùù��˜€ï�³��å[:����€³˜�ï��ï��� �����‚ÈLj0îH™$€€€=======���­­’~~~~~~~~~~~~~�OOO�ÿÿÿÿùùùùùùù��˜€ï�³ÿÿÿÿÿÿ�����A–�ÿÿÿ�ö!a��ÿ�&������H���ûÿ·����B�jj���Ø���!�ùŠ��ÿÿàöÿÿÿÿ[ÿÿSSSSSSSSSÁÁ������������������������Ç������������� ™™`)�����ð��=====ÁÁÁÁ������������������������������������������/Á===èèèèèèèøøøø��øøøø»»ÿÿÔr` —!ÿÿÿ:�ÿ�ÁøøøÁ���:³˜ïï������:˜������nJÿÿÿÿÿ·ÿÿÿ·ÿÿ€ÿjjj°��ÿ�ÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2453ff3b056ab95e17a1d7dd99c82defc2b597d0������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032323�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!aR � ����ñ���ûÖvqÿÿÿ���b��(���7������������%}`�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2477ff336402e5de52445520eb15e8704343ed00������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0031565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�����:˜���ï���FFFFFFFFFFFFÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿFFFFFFFFFÿFFFFÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿFFFFFFFFFÿ�������z910924 33ÍÌÌÌÌÌÌÒ3333ÕÎ�˜ÇÇÇ333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������24b6413c3745f8b7b2f729bae89ee399b0641beb������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032171�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:$�����������¤¤¤��ÿÿ�x��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������24e6190084fd40e44ff278c02fb4e43c8cd29836������������������������������������������������������������0000664�0000000�0000000�00000000162�15100345067�0032030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³˜éþ������;`���@��� FFFFFFFFFFFFFF…ˆˆ†«�.ÿ�ö!a��&�aÿÿÿ��ûÿ/�w——wÿÿúfÿÿ���aÿÿÿ��ûÿ/�w——w#ÿÿúfÿÿ�fÄHÁ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������269f91653f9bbac218dfe0884c8c43ebbeccbcaf������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032627�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�����˜:����(������] ™™����ÿÿÿ.��ÿÿÿÿ�]”����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2723b24f11843b73282f94931b3f3ed696963ee2������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0031612�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ � �� X���������������J/�ö!aË � g���ñ���ûÖvr�ÿÿ����������/����ã������}����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������275315c1e29d2d7fb15810a3d66953d5d68d8d62������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0031751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������� €³˜%ï�Þ�#�:˜��ï������ÉÉBþþÿ€��ÿýü���ûýþÿýÿÿ?����'����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2b20144d0f616bd4695c236e15ebaded83f5b598������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������”�J/ö!aR �������B���ûÕvqÿÿÿ���šÐÿÿ(���ÿ÷ÿÿ¿���å�[����ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2b40483bd9238d7036d56fa6dcd735fc52fbe195������������������������������������������������������������0000664�0000000�0000000�00000001302�15100345067�0032164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���PSln””””””””””””””””””””””””æ””””””””èèèèèèèèèèèèèèèè!è»»»»»»»»»»„»»»»»›»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­òñññ?ÿÿÿÿ���M³˜€ì�è#�:��˜��ý�����������*����� ™™�1ö!aÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ����2���������������������J�������� ������R � ��������������������ÿ�����€ï³˜B€ì�è#´´´´´´´´´´´´´´´´´´´´´´´´´´´´»»»­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­òñññ?���M€ì�è#�:��˜��ý���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������*�NNNè#���:˜��v��RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRv‰��ˆ•ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2c6bd6e0bb02871d00ea542c1702fd81a0a86d21������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0032113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜�ï��ï���:˜���(���ººººººººººº��� ÿÔrp���b�������#���:���������ÿ4���������.������ ��ñññññññññññññññññññññó������� �������´�������ÿ4�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2cbd4f4b339c999597a58fc5af53e4bfffc2b78c������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032512�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������� �ÿÿÿåß�$�~�������@����€��]q4ÿ�³˜��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2cf2b0ae879c5a9120263a5ecb793425def7a8b0������������������������������������������������������������0000664�0000000�0000000�00000000532�15100345067�0032233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ÿÿ�?ï�è#���:˜��v���%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@»»»»»»»»A»»»»»»ååååååååååååååååååååå­­­­����­­­=­­­­­­­­­­­­­­­­­­­­­�������­’~~~~~~~~~~~~~~~~ô~~~~åååååååååååååå­­­­­­­­­ü����ÿÿÿÿÿÿÿÿ���:���������™˜‰ˆx4îH™˜y˜•†ˆ��fÄÕÎ��fÄ`ÿÿ5Ž(rÿÿÿÿÿÿ`����������������������������������������������������������������������������������������������������������������������������������������������������������������������2d9c2be54686acf5d5b2755384dd52ff4d19ee02������������������������������������������������������������0000664�0000000�0000000�00000001062�15100345067�0032253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#���:˜��v���?MMMMMMMMMMMMMMMM¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤~~~~ù˜•�� ™™µ]  KKKKKKKKKKKKKR®KKKKKKKKKKK�î���‚ÈÇÄÅÆ� µ]  É���0³˜ïï������:˜���ï�����������;;;;;;;;;;;;;;™µ]Ú~‰*•ˆÌ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤~~~~–§œ�  �Áÿ���‚ÈÇÄÅÆ� ù˜•�� ™™µ]  KKKKKKKKK/KKKRKKKKKKKKKKKKKKKKKKKKKK�K�ÿ���‚ÈÇÄÅÆ� µ]  É��0€³˜ïï������:˜���ï�����������;;;;;;;;;;;;;;™µ]Ú~‰*•ˆÌH™˜ù˜•}‚X‰âußÞ ÑÿØ ,�����vÃÎ� (.~~–§œ�‡�  �ÿKKKKKKKKÑÿØ ,�����vÃÎ� (.~~–§œ�‡�  �ÿ���‚ÈA’]ÿ‚‚‚����������������³˜ïï������:˜�;;;;;;;;;;;;€³˜ïï�è#���˜������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2dc8f286c1ea4f3dbdabc059f3a1243080cd62f8������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿýÿÿÿÿÿÿÿþ��������������������J�������� ���������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2e18a24e3c46167c0f3d368b75760abdf8fac401������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,`³˜`þ��ˆ�#����Ã���ö…��ˆˆ@éþ�����Ã����Ã�����Ïÿt����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������307ea4e260815f6a9e8b129307a38452976b692b������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0031610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� �����������������ºÿ�ö!����ê����ñ������ ÿÎFr ���������ÁÁÁÁÁ+Á�ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������311f3dceb49012061d4b72a831e347133c92bcdb������������������������������������������������������������0000664�0000000�0000000�00000000222�15100345067�0032041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���(���™hR]Úv‰ˆ•ˆzîß™˜ÿÿÿ2ù;•–ˆÎí���€ÿÿÿÿÿÿŽ(»»»»»»»»»»»»»»»»»»»»»»@»»»»»»»»»»%»»»»»»»»»»»»»»»»»»»4���ÿÿÿÔr` ÿÿ�:��ÿ�ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������313644ec39dc8694c470ab757ba111838ee53b1c������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ � �X� ��������������'/�ö!aË`� g���ñ���ûÖvqÿÿÿ���������/������!������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������31ae44f31abd373f0ff481806d3157f85ccae710������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿ�S�ÿ�ÿü���?�¿�������÷�.ÿ�ö!a�`��ÿ¯ï��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������324102241d71e8c8a37d543dea5cb99ac7ae7c8d������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� �� ��������������ºÿ�ö!������ ��ñ���ÿÎÎÎ��ÿñ���[��������@���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������324ec9cb002617a880a56eb07f49657fc4483505������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0031662�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿ%ßÿÿ@ÿ��������bB������1����ÿö���$ÿÿûÿ/������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3493fcabf43e379422d876938aefff76d611ab95������������������������������������������������������������0000664�0000000�0000000�00000000472�15100345067�0032215�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���!ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ���b/��(���ÿÿÿ�����,����������������������Q��������������öqÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:Ø��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���[[[[â������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������349cbb7c3e3812603d102a39ed82b0bdac61410c������������������������������������������������������������0000664�0000000�0000000�00000000512�15100345067�0032117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#���:���õ���#137331333333333333333333333333Ë3333333333333333333333333333333ÿÿÿÿå3333333²333333-3333333333333 ™qµÞÚ~‰ˆ•ˆ2îH™$ù˜•†ˆ����ÿÿ��!X‰‚ù˜ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ•†ˆ�ÿÿÿÿÿì£� �€³(r&hòòò���������������������������������������ïï�����€��ÿö��������ú����PPÿÿÿÿÿÿÿÿPP����Ç���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������350699ee4c96235151a3b75fdf0d54d482f71218������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0031667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€i˜ïï������:˜���(���†††††††††Æ†ÒÒÒ6ÒÒÒÒÒÒÒÒÒÒÒÒÖÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒÒ!ö�ÿ��÷��³³³³³³³³³³³������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3625c8ad48799bd41b23ff6bc8a3c487702b3f00������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� �����������������ºÿ�ö!���� ����?���ÿÎÎÎ��ñ���ÿÿÿþ��� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������39764a75e150887f1b3d6c15ff2883112bce78d0������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è��÷�:˜������ � ���O���-#Í��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������39d95b1ac8f9a92f57162e173e809bfd24dc38d8������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032206�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ƒ»˜ïï���V���˜���(���†ˆ���†ˆ�†�£�ˆ��²� †††������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3a2fa560af8026b2342777bf91ccd155a71af6d4������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032143�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������ïï�aR � ����ñ���ùûÖvqÿÿÿ��������*�¤h������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3c3b7a908a6b8303cc2ced4cdc2c548cedbb760f������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï���?��:ê���(��� ý ™z­]Ú~È;Á?�ß��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3c81c456a004ec4ccd7c80fe2eea2f0ef7ab7473������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������J/�ö!aR � ����ñ������vqÿÿÿ��žÿÿ(���/ÿÿÿÿÿ��žÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3cd038948d733c0b49ba6c78452cbd03186c69bb������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032102�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������€�€÷��������:˜��ö������€½ïï�{›Bÿø���ddddddd�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3d657fe063550eb5f8d8ef40b55590b321aa20f4������������������������������������������������������������0000664�0000000�0000000�00000000526�15100345067�0032076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���"ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��/���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���bè��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:������������vqÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[q��(���ÿÿÿÿ���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ��� �À��[q��(���ÿÿÿÿ���å[���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������ââ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������3da8fb2b32486ad7c716c76458668a6acfdf5f0e������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0032334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������9����taR� � ���å���G�ÿÿÿÿÿÿ���b/��(���€³˜������$����b/��(���ÿÿÿÿ¿���å[���€³�:˜��� ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3e30f3f570dfee8350064c138494bd670d2fc795������������������������������������������������������������0000664�0000000�0000000�00000000262�15100345067�0032032�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ���ñ���ÿÿÿÿÿÿÿÿÿÿÿÿÀ��[qÿÿÿ���b/��8���ÿÿÿÿ����å[���€[���€³0�(���ÿÿÿ�������������Q������€`�0��'���¿���å[���€[ÿÿÿÿÿÿ���€³­­­­��€³�2�ŽŽqqqqq�Àââ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3e8153e9034c230c77afe71a541d4f85ef1aefb8������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€�ïï������:˜���ï������¯U,¯¯¯¯¯¯ÿÿÿÿÿ���¯¯¯¯¯¯¯�����ÿ#ÿÿÿÿÿþÿÿ��#:˜ÿÿÿÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3f8b816713d67daeb3c9a6dfd6a1fa9e651c96e7������������������������������������������������������������0000664�0000000�0000000�00000000262�15100345067�0032424�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ì#è#�:��˜��ý���ÿÿÿQWý���! A’–�§œ  �����‚Èÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþÿ¯ � ���@�������� Ù™˜™ŒxÕî������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������40c238a192c1a36484f359cbf87e4a3c4cea8bd3������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ � �X�� ��������������J/�ö!=Ë@� g���ñ���������ÿ����}��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������416d8c8f3c970b609e07c225a93db937ab8fd7a0������������������������������������������������������������0000664�0000000�0000000�00000000522�15100345067�0032170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������/ÿÿåÿß¡ÿ��B�������0����€��ÿõ��R$� ����ñ���!ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������ø�����������������������������*�� [��� ���������������������?���������������ñ���D����6 ™qµÞÚ~‰ˆ•ˆ2îH™$ù˜•ÿÿÿ�ÿÿÿÿ��!�� ��������������öÿ����&�������������aaaaaaaèèVVVVÿèèAAAAAAAAAAA��'��­VV]VVVVVVVVVVVV­­­­­z�Àâßÿÿ@ÿÿÿþ��� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������41ebd242b789740786e3ece0d4117dcadbf6a37e������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������!€)˜ïï�è���:˜��ï�����:˜Éûýþ�ýü ��?ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������421c2d863ad0ae5d339f9a18293a38bc4b24d0fb������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032215�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ � �X�� ��������������J/�ö!aË@� g���ñ���ûÖvqÿÿÿ���������}�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������444dc80536559d07351b2d3616cb40c3c1a9dcbd������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032052�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� �����������������º!�ö!�����������2���€�� ÿÿ���[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������445df2c7e19680732514c77c9b4e8554dfd58a69������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031773�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������:J/�öaaR �����ñ���øœ��ÿ�� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4815d6ffa9e96eac844fc31289df2d00932c95c1������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032172�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿ'����:˜���(���™™µ]-vw•ˆ™�ù˜ÿÿÿÔù†ˆÎí�;���D���jj���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������487e4c6fb01756b58d769ca4a0015b5cb1017b7b������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿþÿÿÿåßÿÿ@ÿÿÿþ�������������b���������2����/€��•�ü¾ÿþüÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������48843aedaa180a1bb3b5106e8b55352276d0c586������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0031777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������ÿö�B���=���9������ÿö�B�è���]���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������492d805d4c8fdbc70e597d8d6e601238a3be324e������������������������������������������������������������0000664�0000000�0000000�00000000342�15100345067�0032171�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ�?���)�‹�������������^�taR� ����ñ���ñÿ³ÿÿÿÿÿÿÿÿÿôÿÿÿÿÿÿÿÿÿ$ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������ÿÿ2ÿÿïÿÿÿÿÿ_ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������úÿ�����������������������������������������AAAA÷�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4b81c48b8d565a4dcecfe7d694ea47a69deec3fa������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032643�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!aR � ����ñ���ýûÖvqÿÿÿ���b �(���/ÿÿÿÿ¿���å�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4c06c923331191aff0ec6cd7c19536e311be6d59������������������������������������������������������������0000664�0000000�0000000�00000002132�15100345067�0032072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#���:˜��v���€»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­I­­­­­­’~~~~~~~~~~Î  �(�p(�,.í A’–§œ�  �����‚ÈÇÄÅÆ� ù˜•�� ™™µ] ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­I­­­­­­’~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~­­­­­­­­~~~~~ÿÿÿÿ–§œ�  #�����‚ÈÇÄÅÆ� ù˜•�� ™™µ]  ßÞ ÑØ ,������vÃ����‚ÈÇÄÅÆ� ù˜•� � ™™µ]  ßÞ ÑØ ,��€€€€€ €����€€€€€  (��p(�,.í A’–§œ� �@���~~~~~~~~~~~~~~~~~~~~~~~~²€����~~~~~~~~~~­­­­­­­­­­­­­­­­~�~~~~~š~~ÿÿÿÿÿÿ�÷~~~~ÃÎ  �(|�������,.í A’–§œ�  �����‚ÈÇÄÅÆ� ù˜•�� ™™µ] ­­­­­­Ã����‚ÈÇÄÅÆ� ù˜•� � ™™µ]  ßÞ ÑØ ,������vÃÎ  �(�p(�,.A’]ÿ‚‚‚����)����(€€€€€€€€���w§œ�ù˜•� � ™™µ] €���� ßÞ ������������������������������������������������������������������������������ÑØ ,������vÃÎ  �(�p(�,.A’]ÿ‚‚‚����)����(€€€€€€€€���w§œ�  �����‚ÈLj0îH™$€€€=======���€³˜ïï�è#���:˜��÷������™™ùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùù•†ˆ��»ÿ�ö!aR����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4c5b635d4e0e7685b5b3b3fe67fe1ead7aa8cb87������������������������������������������������������������0000664�0000000�0000000�00000001262�15100345067�0032474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#���:˜��v���N»»»»»»»­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­I­­­­’~~~~~~~~~~~~~~~~ 4Ju¸�4$°�~~~~~ÇÄÅÆ� ù˜•�� ™+µ] ­­­­­­­­­­(­­­­­­­­­­­­­ ù˜•� � ™™µ]  ßÞ ÑØ­­­’~~�������~~~~~~ 4Ju¸�4$°�~~~~~ÇÄÅÆ� ù˜•�� ™™µ] ­­­­­­­­­­(­­­­­­­­­­­­­ ù˜•� � ™™µ]  ßÞ ÑØ ,������vÃÎ   �(�p(�,.A)’]ÿ‚‚‚��œ�  �����‚ÈÇÄÅ­­­­­­­­­­­­­­­­­­­­¿­­­­­­­­­­­­­­­­­I­­­­­­’~~~~~ééé�•[[[[[[��ÿ��‹����ñ��éééééééé�c‡�Í�Îÿÿ��������z��0�¥��/€�~•Á��ÍÎùþŠ�»ÿ���������/€�~•­­­­­­­­­­­­­­’~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~­­­­­­­­­­'­­­­­­~����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4c92c44bdf911e127f98b1f741a9429a416404b7������������������������������������������������������������0000664�0000000�0000000�00000000212�15100345067�0031737�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜%ï������Ϙ������ ™™µ]UUUU�����˜UUUUUUU������ÿõ������������3���€��ÿöÿÿÿÿÿÉ���0í������€³’nÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4cd9c9085b3974be6114e9c96b385fd5928169b3������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������€�€ë˜ïï�è#���:˜��v��� ------------------ñ���$ÿÿïÿÿÿÿÿÿ³þ�xxxxxxxxxxxxxx�����³³������u³nnnnn³³³³³û³³³³ó³£³³³á³³³ó3³³³³³³³³³³³³³³³³³³³³³³ML�������L‘ÿÿÿÿ…ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������Hÿÿÿÿÿÿÿ‘‘’nq³³³������³³³³³³³³³³³³³³³ML�������L‘ÿÿÿÿÿÿÿÿÿÿq����������³³³/������³³�ÿÿÿÿÿÿ�����uÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4d56d33e33ce1f0d3a6e3e5582bd28665e3fa65a������������������������������������������������������������0000664�0000000�0000000�00000000351�15100345067�0032240�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���å���G�ÿÿÿÿÿÿ���b/��(���€³˜ïï�����:˜��� ��$����b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€���ù:ÿ��˜��ø���™™‘‘‘‘‘‘‘"�‘‘‘‘‘ÅÅÅÅÅÅÅÅÅÅÅÅÅøÿ�����[���ÿÿÿÿÿ¿���å[���÷LÿÅgÿÿ� [��ââ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4d80df18bb50e97b97b10fe7ff50065944df7973������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���;���€çÿÿÿFAµ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4e22436534f7ddda6023610945ad3fb84b08d5f2������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0032002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4ed47503b5d6a6a97de63384162805adf4cc1a58������������������������������������������������������������0000664�0000000�0000000�00000000532�15100345067�0032103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���%ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�����������������������������ø����������������������������������������������öÿ�����a���������������������������������,�������������������������������������������������������������������������������;�����������������������������������������������������������������������,�������������­­�z�Àââââ����������������������������������������������������������������������������������������������������������������������������������������������������������������������4ed96db01a061c6cf9f3236f9254989d12f65315������������������������������������������������������������0000664�0000000�0000000�00000000142�15100345067�0031753�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������ܳ˜ÿÿÿÿÿÿÿÿ:˜��ø���1ÿÿÿÿÿÿßÿÿÿºÿÿÿÿÿÿÿÿ'�¿¿ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¿¿�ÿÿÿÿÿÿÿÿÿ¿¿��ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������527d035f3b7718f9a3fc2ea09e79803d5169fc0a������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032105�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������;ÿ � �X��Z��������������J/�ö! � �� g���ñ���ûÖ”ÿ/Jÿ���������/����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������53157896277c12aaf92e63bd6eba876823c53644������������������������������������������������������������0000664�0000000�0000000�00000000472�15100345067�0031704�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���š���!™™˜‰ˆx4îH™˜y˜•†ˆ��fÄÕÎ��fÄ`5Ž(r`!X‰u‚â�ÅÈØ�ÁÄÿ8ÿÊ�����D,„ÍΊ���������€"!à����DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD|UÃÈ)Î���É1Œ5™?�(�Ê����D”2€ÅÆ� ��0‘������Ø�½.€bY����‚ÈÈÇÄÅÆ� ��0‘P�Ì3��½.€bY+ �ÇÈ��46t�I������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5369e602a569f72fb2398c3dfa65806f870a4330������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0031673�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³�=���éþ��;`���Ã������R¸¸¸¸€³�=���éþ��;`���Ã���R¸¸¸¸¸¸­­­­­­­­­­­­­­­­¸¸���Á��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������54acea7c142b7d17006615be6d40591bfdf6280c������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ƒ»˜ïï���V���˜���(����™l††††††Ž†ˆˆˆˆ������Øïù��™l†$††�� †††��'��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������54f997c30666b3519baabf15d055a8468795076a������������������������������������������������������������0000664�0000000�0000000�00000000172�15100345067�0031701�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³*�ï��ï'��:˜���(��� ™™­AÚ~‰ˆ•ÿåß ���Ð�³ïï�™ÛÛÛÛÛÛÛÛÛÛÛÛÛÛ���™™­AÚ~‰ˆ•ÿåß ���Ð�³ïï�jj�������l#j��������l+Û�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������55eb87d57c0f0f7fd3ea9d63c1eac58ee00199dd������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032466�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ�������B����ÿÿ�����*�������������å�ÿ�� ]��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5958b905c02f53a22cdfabb51cd2823d13650241������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0031762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5af121503212bc786fef31e2e3a51ce2031b1b84������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032037�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������Ð/�ö!*R �������B���ñ���ûqÿÿ� ���;��/���Æ���aa ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5ba93c9db0cff93f52b521d7420e43f6eda2784f������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0032314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5de1bb11c456a3b400a4fd2b3c419ca129f099c5������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø��� ™™˜ÇÇÇÇ.ÇÇÇÇÌÌÌ̘ÇÇÇÇ.ÇÌÌÌÌ������54337<166ÿÿÿ[ß*����Á��������� @?ÿõ�"™™˜ÇÇÇÇ.ÇÇÇÇÌÌÌ̘ÇÇÇÇ.ÇÇÇÇÌÌÌÌ4336<1666FAµÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÿÿöÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇ��›�„ÍΊ���������€���'˜ïï�è ���*:˜��ø��€61ŠÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿŠŠt�I����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������62bad82a78a7694bf9f72575622d90eae3c1cba8������������������������������������������������������������0000664�0000000�0000000�00000002222�15100345067�0032251�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���†Ž™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™~~~~~~~‚ò���¢³�ï��ï˜���:~~~~­ÿÿþ)Ù�­­­­­~~~~~~~‹ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ~ÃvvvvvvvvvvvvŽvvvvv ���ÿÿÿÿÿÿ™˜ßhÿ×ט���(���™™µ–Ú~‰ˆkzÿÿÿÿ ™™™™™™™™™™™™™™¢³�ï��ï˜�J/�ö!aR � ����ñ���ùûÖvqÿÿÿ��b��(���,���:~~~~­ÿÿþ)Ù�­ÿÿ~Ãvvvvvvvvvvvvÿÿÿvvv ���ÿÿÿÿÿÿ™˜ßhÿ×ט���(���™™µ–Ú~‰ˆkzÿÿÿÿ âââââââââââââÎâââââââââââââââ���b/K€³����������������&�����taR � ���ñ���.ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿÿå[���ÿÿÿÿÿ���b/��(���ÿ»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­�����������������������������������������­­­­­­­­­­­­ÿÿÿÿÿÿ%ßÿÿ@ÿÿÿþ��� ����������������������taR � ���ñ�(���ÿÿÿÿå[���ÿÿÿÿÿ���b/��(���ÿ»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­I­­­­­­’~~~~~~~~~~Î  �(�p(�,.í A’–§œ�  ����Ú�‚ÈÇÄÅÆ� ù˜•�� ™™µ] ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­ÿÿ@­­­­­­­­­­­­­­­­­I­­­­�b/��(���ÿÿÿÿ¿���å[���ÿÿÿ%ôÿÿ×ÿÿßÿÿAÿÿ­­­­­­­­­­­������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������62dc4d708eb260cf29f94e5a9c65f89f6dd3fa43������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� ����������������ºÿ�ö!���� ����ñ���ÿÎø@����A»@ÿ€!ÿÿÿ ¯ÿú�Í����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������640126de1ef49506804ad2af892b39fe0af37aa6������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€5˜ïï������:˜���)��� <™™µ]µ]ÿÿÿÿÿÿÿÿÿÚ‰ˆ•ˆ[[[[[[[[[`E���DDDDÎ[³ïï����� ��j�ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6565683c7f1f07d7cfa27c84426e1c386425a931������������������������������������������������������������0000664�0000000�0000000�00000000472�15100345067�0031703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���!ÿÿÿÿÿÿÿÿÿÿûÿÿÿÿÿÿÿÿÿÿÿ�����������������������������������������������������������������������������,�����������������������Q�������������������������������������������������������������������ÿÿ�������������������Î�������������������� �~�����������������������ââââB���=���6������ÿâââ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6629278a4f5b5143bac025355a79df241d0d32db������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032000�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� �����Ô�����������ºÿ�ö!���� �I��ñ������Î��ÿñ��ÿÿÿÿ��������#�������“�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������673be270a1d5f97382728953dcbc1a749b8191fb������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������L���˜ïï �º����˜���(�������"�""��"™:™"�˜ïÿÿÿÿÿ~ÿÿÿÿ�����D"""˜��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������67871c4d2cfe8eb0807cc8fc7c2b423d2c4be5d2������������������������������������������������������������0000664�0000000�0000000�00000002132�15100345067�0032400�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����{���€ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÿÿÿÿ����ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌùÿhhhhhhhh~h��Îgÿÿý‰ÿÿ�BMMMMMMMMMMMMMMMM¤¤¤¤¤¤¤„„„„„„„„„„¤¤¤¤¤¤¤¤¤¤~¤¤~�:ƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒ{ƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒ˜���ï�����������;;;;;;;;;;;;;;™µ]Ú~‰*•ˆÌH™˜ù˜•}‚X‰âu$ù˜•†~‰*•ˆÌH™˜ù•}‚X‰âu$ù˜•†ˆ�:˜���ï�����������;;;;;;;;;;;;;;™µ]Ú~‰*•ˆÌH™˜ù˜•}‚X‰âußÞ­­­­­­­­­­­­­­­’~~~~~~~~~~~~~~~~~~~~~~~~~~~~€³˜ïï.~����:˜���~~~~~~~~~~~~~~~~~~~~~~~���¢³�ï��ï����:~~����������������������������~~��ø­­­­­­~~~~~~~~~~~~~~~~~~ñ���ÿÿÿÿÿÿÁÁÿÿÿÿBBBBBBBBBBBBBBBBBgÿÿý‰ÿÿ�BMMMMMMMMMMMMMMMM¤¤¤¤¤¤¤„„„„„„„„„„¤¤¤BBBBBBBBBBBBBBBBBBBBBB�BBBBBBBBBBBBBBBBBBbBBBBBBBBBBBBBBBBBBBBBBBBBJBBBBBBBBBBBBBBBBBBBB¾½BB­­­­­­­Ù�­­­­­]Ú~‰%•ˆÌH™˜ù˜•}‚X‰âußÞ­­­­­­­­­­­­­­­’~~~~~~~~~~~~~~~~~~~~~~~~~~~~€³˜ïï.~����:˜���~~~~~~~~~~~~~~~~~~~~~~~���¢³�ï��ï����:~~����������������������������~~��ø­­­­­­~~~~~~~~~~~~~~~~~~ñ���ÿÿÿÿÿÿÁÁÿÿÿÿBBBBBBBBBBBBBBBBBgÿÿý‰ÿÿ�BMMMMMMMMMMMMMMMM¤¤¤¤¤¤¤„„„„„„„„„„¤¤¤BBBBBBBBBBBBBBBBBBBBBB�BBBBBBBBBBBBBBBBBBbBBBBBBBB‚ÈÈÇ<:: ��0 �ÇÈ��46t�I �B��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6bd8cd832b15cf0d5e3eea310d97b737faf8ee43������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������€J/�ö�aR � ����ñ���ùûÖvqÿÿÿ���9b��(������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6c7b212dd6e420cc250464ab9517d2168e6c5edf������������������������������������������������������������0000664�0000000�0000000�00000000502�15100345067�0032147�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���")™™˜ÇÇÇ3333ÌÌÌÌÌÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇAÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇ����������������������p‘�lllllllllllll������������������������������������������������������������������������������������������llllllllllllllllllllllllllllll����������­ppp���„ÍQQQÇppp���„ÍÎÿÿÿŠ���b��(���!ÿÿÿÿÿÿ+����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6ddcfcba54e660ad5fca1bfc91670823cb71f1d2������������������������������������������������������������0000664�0000000�0000000�00000000262�15100345067�0032524�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������;€³˜ïï�#è��:˜��õ���7ÿÿÿÿ÷þ��ÿÿÿÿÿÿÿþ�@� ������‚���������*��� ������ �������••••••••qj�€³˜ïï�#è�:˜��õ���8���� �������••••• ���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿããŸããããããããŸÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6f0935dd5c60572c57d7bb0f5896da83cf4657a9������������������������������������������������������������0000664�0000000�0000000�00000000402�15100345067�0032125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿÿ�X�î?�������������������taR � ����ñ���ñÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ% ���������dÿÿÿÿÿ`ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���������0�����������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6f21d6eb06123ef2835d168b44b7574c39b06fc6������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032016�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������¯�ïï������:˜���ï���8X-�ú�%�8X-?��������¯¯Ô���ÿÿÿÿÿÿ™˜������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6fb7b33d08c092caa76e11decfc4e9431ace8d32������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø��� ™˜‰ˆÇ»]]]]]]]]]],]]]]]3nÿÿJÿÿÿ·ú�:˜���Ø��� ™˜‰ˆÇ»]]]]]]]]]],]]]]]3nÿÿJÿÿÿ·úÿÿ·ÿÿ€ÿ�è#��X�???5���??G????????ÿÿÿåÿßÿÿÿ���������2����#���:˜��í���™™??ÿÿ·ÿÿ€ÿ�è#��X�???5���??G????????ÿÿÿåÿßÿÿÿ���������2����#���:˜��í���™™????ùÿ�X�?????????G?ÿÿÿåÿßÿ!������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������75deb85a67a4c6b8a087733ba3a0cd938e63a41f������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032234�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ÿ@ÿÿÿÿÿÿÿÿÿÿÿÿþ��� ����`�����������*���ö���€�����ÿ��0������5����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������79b7cb1655367697a866f041f8d7bca70b87ea5f������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032125�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������€�ï‘���ü�������ñ���@��ÿÎÿÿÿÿÿßÿÿ/»¹»»»»»»»»»»»»»»»»»».��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7ca47c2e3eecc2acf0c7a0655af7c51546bde6d5������������������������������������������������������������0000664�0000000�0000000�00000000222�15100345067�0032525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������Ü'˜ïï�è ���:˜��ø���™™‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘ÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÿÿ.ÿÿ�ÿ³ÅÅÅÅÅÅÅÅÅ‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘‘õõõõõõ‘‘‘‘‘‘‘‘‘‘‘‘‘‘���ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7d197122c22bef9423f360691dcb78dedd2c0c99������������������������������������������������������������0000664�0000000�0000000�00000000432�15100345067�0032167�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���1™›˜‰ˆ²»»»»»»z»»»»»»�U���«»�ééééé���ÿÿÿÿééééééé�•[[[[[[��ÿ��‹����ñ��éééééééé�•‡��ÍÎÿÿ��������z��0�¥��/€�~•Á��ÍÎùþŠ�»ÿ���������/€�~•Á��ÍΊ�ÿ@ÿÿÿþ��� ����������bB���������0����€�ö�ÿ�������ñ�ÿI��ûÖ”ÿ/Jÿ���������/������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7d1aebf64a30affed22e9f885a0af617ef5bd572������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032540�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���(�������cccccc™ccccc~‰ˆzîuÇ�J'�€�€�?ÿõ������³˜-ïÅÈ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7d2b0e79c750d7a3fa52f27aefb85a165b4b7133������������������������������������������������������������0000664�0000000�0000000�00000000642�15100345067�0032236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���.tˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ++++++++++++++++++++++++++++++++++++++++++++++�+++ñ���ÿÎø@������€³˜ïï�++++ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���€³˜ïï�è��÷�:˜��ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ`ÿÿ� ��0‘������Ø�½.€bY���DD””””””””Ê |UÃÈ)Î� èèèèèèè��:˜������ÅŸû����:˜���Ø���!™™˜‰ˆzDDDDD‹�)����ð���ÿÿv'ÿÿÿ�DDDDDDDDD� ���O��âu�ÅÈ�46-#tÍ�I����������������������������������������������������������������������������������������������7dd097f27180debdc68621b74e84cc448102d92e������������������������������������������������������������0000664�0000000�0000000�00000000353�15100345067�0032113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ������ÿÿÿÿ¿���å\���ÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���é[���€³�:˜���b-��(���ÿÿÿ¿���å[���€ä""���*ÿÿÿU"""""""-�����/�"Ü��ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ[���b/��ÿÿ��€³�:˜��� ��âÀ�â�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7e38e6f71b4a050f3fecdc08d51e3d1418f3fb0f������������������������������������������������������������0000664�0000000�0000000�00000003062�15100345067�0032375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taÿÿÿ ����ñ���·Øèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèè興ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèè¨èèèèèèèèèèèèèèèèèèèèèèèèèèèèèè � g���ñ���ûÖvqÿÿÿ���b��(��������������ÁzzzzzzzzzzziiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiyiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiizzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzèèèèèèèèèèèèèèèèèØ ,�î™$ù˜ÿÿ�X�î�@zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzèèèèèèèèèèèèèèèèèØ ,�î™$ù˜ÿÿ�X�î�@$:����ê���ÙL!X‰‚ù˜•†ˆ���~�@@:˜à�������»�ö!aR � ����õ���ÿûÖqÿöqÿÿÛ@ ������}€��������­­­­­­­­­ÿþ���������������������€³˜ïï�è#���:˜��v���Xÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿî�@Š�‹���������«�.ÿ�ö!a��&��������»ÿ�ö!aR � ����õ���ÿûÖqÿöqÿÿÛ»»»»à� ÇÊ Ø��»ÿ�ö!aR �� ßÞ ÑØhhh= hhh�������@@@@ï���:˜��ÿ?����³ïï���:˜@2@@@@@@�����@@@@@@@@@@@@@@@@@@@@�@@@@@@@@@@@@@+@@mmmmmmmm�mmmmmmmmm@@@@@@@@@@@@���@@@@��@@@˜ïï�������z�€=���³ï:˜����ÿÿ�X�î��R� ���ñ���$ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������������öÿ�����a������������������������€������,����������������������Q������������ï��� ™™`������5îX=======hhhhhh�������@@@@@@@@@@@@@@@@@+@@mmmmmmmm�mmmmmˆèèèèèèèèèèèè��������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������������]ÿ�����a������������������������€������,����������������������Q����������������������ÿÿÿÿÿÿú��èèèèèèèèèèèèèèèèèèèè¨èèèèèèèèèèèèèiiiiiyiiiiiiiiiiiiiiiiiiiiiiiiiiii���������iiiiiii������iiiiizzzzzzzzzzzzzzzzzzzzzzz�������z���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������80117ddd69955929af3ca5f981ba98a48012260b������������������������������������������������������������0000664�0000000�0000000�00000000602�15100345067�0031751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���*ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���å[���ÿÿÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜�� ÀJ���[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[{ÿÿ÷ÿ������€³˜ïï������:˜��� ������[qÿÿÿ���b/��(���ÿÿÿ�����b/��(���ÿÿÿÿ¿���å[���ÿÿÿÿÿ���b/��(���ÿeÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€��:˜��� ������[qÿÿÿ���b/��(���ÿÿÿ�l���,���)���$�[[â������������������������������������������������������������������������������������������������������������������������������87446dfd5404badf9eddff3d071218025166ea84������������������������������������������������������������0000664�0000000�0000000�00000000202�15100345067�0032160�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X������@�������������ºÿ�ö!ÿ³`Œ�����ñ��� ÿû��ºÿ�ö!�ö`Œ/��ïîîþîç����ñ���  ÿû�Á*ÁÁ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8a7f547660cec12461032cfda4d1caf55bb07dec������������������������������������������������������������0000664�0000000�0000000�00000000232�15100345067�0032356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ì�è#�:��˜��ý���R � v‰ˆ•3îHr`;!X‰‚8Å����ÅŸûûÜ~�À¿Ågÿ²³�����ÿÿú�2�_�������-�������� Ù™˜™ŒxÕî������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8d50f8e07c30c3521ccf5f399e3667d6da593ddf������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/�ö!áR � ����ñ���ûvÖqÿÿÿ�����������€â������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������93012fe6454ae8c2c9049e784fdc31b444f31f69������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������€�ï‘���ü�������ñ���@��ÿλ»»»»»»»»»¹»»»»»»»»»»»P�Xî��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������94e9fdedcab956cafdb52ad634cf54487d840e3e������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������œ`Äfüÿÿÿ��:˜���(����ÿú•---/b���ÿÿ@��ÿ™ú™­]Hß™�¶��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9842926af7ca0a8cca12604f945414f07b01e13d������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0031773�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������99d7208df7ea6e626fa9c888e582f7c5432b243b������������������������������������������������������������0000664�0000000�0000000�00000000572�15100345067�0032144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿ¿ÿ���å[���ÿÿÿÿÿ���b/��(���ÿÿÿÿ)���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ���b/��(���ÿÿÿ�����,����������������������Q��������������vqÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���b/��(���������������������ïï���� [[[[[[[[��ââ��������������������������������������������������������������������������������������������������������������������������������������9ff89f6c4cc178a314ac0b40ad0d823748491bd0������������������������������������������������������������0000664�0000000�0000000�00000000232�15100345067�0032153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ü€³���������:˜��ß���#########ý���L�/������������� �R � �����º����� �R � ‰ˆ•4îHr`ÅŸû��ñ###~"##������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a42c6cf1de3abfdea9b95f34687cbbe92b9a7383������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0032542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a58d0fc75ead12a9c29063a1d0db8fb80f395c31������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032307�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø��� ††¶†††††††††††††††††¦††††††††††EDDþÿ�����������������������������������������������������������������������������������ÿÿ»»»»»»»»»»»»»»»»»»¿»»»»»ýý0000000000000093800847�����ýý222222$������ÿö�B�22=���9������ÿö�,,,,,,,,,,,,,,,,,,,,B�è���:˜������€�)D *���]�22‚ywÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a7e9dc04db4e4b11302187e182dd349b563494df������������������������������������������������������������0000664�0000000�0000000�00000000112�15100345067�0032071�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜�-��ï���:˜���(���z38777!8��:�]�f�c| 5Ž(�]�������³ï:˜��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ac2f350f4fa2ff262cb01d9d97974df5a2dff0be������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è�#��:˜��v��� ................................/Rnnnn-;---------„���------³³³³³³³³³³³³³³³³³³³³³³³³³³³³³------------nnqnnnnnnnnÿÿÿÿÿÿÿÿÿÿÿQQQQQQQQQQQQQQQQQ�ÿÿ�X�î��R€ˆ����ÿÿÿÿnnnQQQQQQQQQQQ�(������ ™'™­]ÚQQQQQQQQQQQQ��X�‹�����ä��QQQQQQQÿÿÿÿÿÿÿ�QQQQªQ��fÄ` ��ÿÿÍ�����0����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������af11ea42436ef96d9d8ffe0387fb5782ddbb348a������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032417�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜������nJÿÿÿÿÿ·ÿÿÿ·ÿÿ€ÿjjj°�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b2cf8461474181d99198df332c5dca521c64de2c������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�X�� ������������������ÿÿ��‘1���������ñ�����º�ÿöqÿ���A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b461b7d5a152d72fe425d130a6181ea7b0b05f12������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032037�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è��÷�:˜������ � ���O���7ÑÎ�!��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b4f3a185d32f5ebe2b85bd678bba599d76f70a7a������������������������������������������������������������0000664�0000000�0000000�00000002212�15100345067�0032411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����I���…ªÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝ�ÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝnY�ÞYY::::::::::::::::::::::::::::::::::::YYYYY­­­­­­­­­­­­­­­­­/ÿ((((((\\\\\\\âââÝÝÝâÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝßÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝnnnnnnnnYY�ÞYY::::::::::::::::::::::::::::::::::::YYYYY­­­­­­­­­­­­­­­­­/ÿ(((((((((((((((((((((((((((((((((#(((((((((((((((((((((((((((((((((((((�:˜����������(((���(((èèèèèèèèèèèâoooooooooooooooooooooooooooooooooooooooooooooooooooÞooooooooooooooooooooooooooooooooooooâââââââââââ\\\\\\\\\\\\\\\\ââââââââââââââââââââââââââââââââââââââ�ù·�������ÿÿÿÿÿÿÿÿhhhhhhhhÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÿÿÿÿÿ×�D,„ÿÿÿþÿÿÿÿÿÿÿÿÿÿÿþ��� ����������������*������€�����ÿ�ÍΊ�“�€³˜ïï����ÿÿÿÿÿ÷ÿ/îH™˜y˜•����������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿFFFFFFFFFÿFFFFFFFFFFFFFFFFFFFF�����������ÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐ��ÐÐ����ÝÝÝÝÝÝÝÝÝÝÝÝßÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝÝn333333333ÕÝÝÝÝÝÝÝÝÝ݈ˆˆˆˆˆˆˆˆˆ•†ˆ�ÿÿÿÿÿì£� �€³(r&hòòò������������ÝÝÝÝÝnnnÝnnnnnYY�ÞYY:::::::::::::::::::­­­­h�­­)­­�­��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ba00242b72f56b5d07786b7af10b9749a59a15ba������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������ÿÿÿÿÿ™ÿ˜ßHÿ×ל���(���™™µ–Ú~ˆˆkzÿ�����%ô> ��(��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ba3d618f85780af05ad8e9ae2069603006ae9bbb������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������¥³˜ïï����:˜���Ø��� ††††††††††††††††††††††††††††††††††††ÁÄÿÿÿÇ�Ê��ëG�ÿÿÿÿÿÿÿ×�G�žÿÿÿÿÿÿÿ×�D,„ÿÿÿþÿÿÿÿÿÿÿÿÿÿÿþ��� ����������������*������€�����ÿ�ÍΊ�“�€³˜ïï�����ÿÿÿÿÿ÷ÿ/îH™˜y˜•����������€��������X�� ����PPPPPPPPPPPPPPPPPPPPPPP�������PPPPPPP� ñ�o����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������bcd8a144287c2ad0ca47a66cc3606aed7192d5ce������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032357�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8������������������������������������������������������������������������������������������������������������øïï���:��˜�������‘™±£zÿÿfÿ•~Ø������?��������������������������������Ûÿÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������bde3b51ae38da58047d42a41371a217827d31f75������������������������������������������������������������0000664�0000000�0000000�00000000152�15100345067�0032002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€G˜�������:˜��õ��� 5ÿÿÿÿûÿÿÿÿ����������������������������������������°����������������������ÿ@ÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c20513576febd09086017080392adbf18f0aabe7������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0032060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï.~����:˜������ÿö�€ÜÜÜÜÜÜÜÜÜÜæÜÜÜÜÜܳ˜éÞu������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c39a1c24b6aabfd2656ac84c5c8fed16eede528e������������������������������������������������������������0000664�0000000�0000000�00000000452�15100345067�0032623�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø��� 6™™˜‰œœœœœœœœœœÈØ�Ç»»»»�������»»�����������A�������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������������������kkkkkkkk@kkkkkÿkkkkkkkk�����ÂÂÂÂÂÂvÂÂÂ����ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��œœ�������������taR � ÿÿÿÿÿÿÿÿÿÿ��»»»»»ÿÿ�ÿÿÇ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c3b2bc6acbc107d0e9403e61661887935b73ce0c������������������������������������������������������������0000664�0000000�0000000�00000000132�15100345067�0032142�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ � �X� ���������������J/�ö!aË � g���ñ���ûÖvqÿÿÿ���������/�����������}����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c40202c42aa92830d9d7d3f2157a4fb0b53fbf11������������������������������������������������������������0000664�0000000�0000000�00000000652�15100345067�0032131�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï������:˜���Ø���/™™˜ÇÇÇÇÇÇÇÇÇÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ+3333�����������������������������������������������������������������������������������������������333ÌÌÌÌÌÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇLj1îH™˜y������������������������ppp���„ÍΊ���������€"!à2€�wy��‚�ÿ�‰‚ÅÈØ�ÁÄ �Y+ �ÈÈÇDÅ0ÿóÿþ3�+ �Y+ �ÇÈ�30ŠŠŠt�I��������������������������������������������������������������������������������������c67117cd08df138c69184b8717979f297eb3fced������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������K€³������úî:š���a���Ãvwvvvvv���vvvÄ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ce6480edc36e784863ce3125c7dbcf95f9cd20ca������������������������������������������������������������0000664�0000000�0000000�00000000442�15100345067�0032415�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������€�€ë˜ïï�è#���:˜��v���------------------ñ���$ÿÿïÿÿÿÿÿÿ³þ�xxxxxxxxxxxxxx�����³³������u³nnnnn³³³³³û³³³³ó³£³³³á³³³ó3³³³³³³³³³³³³³³³³³³³³³³ML�������L‘ÿÿÿÿ…ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������Hÿÿÿÿÿÿÿ‘‘’nq³³³�����­­­³³³³³³ML�������L‘ÿÿÿÿÿÿÿÿÿÿq����������³³³/������³³�ÿÿÿÿÿÿ�����uÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d3130220f9b81ee04247af415825ddd82fdef93e������������������������������������������������������������0000664�0000000�0000000�00000000102�15100345067�0032150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������ùÿ�����/��������������º�€!���� �������€³˜�ï��ï�����ñ()��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ddec96652840748881a1e8894c92f7fc3ada74be������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032214�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������ÿÿÿÿÿÿÿÿÿÿÿ  ����ñ���ÀûÖvqÿÿÿ���b��(���~����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������debbb602a0332ccb345fb31c8c26db33eb8755d6������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������z�€%���³}ï���:˜��� ������³ïï���”ÿõÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������defd2d06b29a1f7458ae0ee09a4d8551a7e13aec������������������������������������������������������������0000664�0000000�0000000�00000002202�15100345067�0032446�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ����ñ���„ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªª+ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªèèIèèèèèèèèè說ªªªªªªªªªªèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèêèèèèèèèèèèèèâââââ¼¼¼¼¼¼¼­��‚ÈÈ��������������ÇÄÅÆ� ��1nnnnnnnnnnnnn$n­­­­­­/ÿÿ�S��ÿü�nèèèèèèèèèèèèèèèèÿÿ�ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªª+ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªèèIèèèèèèèèè說ªªªªªªªª®ªèèèèèèèèèèèèèèèèèèèèèèèèè,èèèèèèèêèèèèèèèèèèèèââââââââââââââââââââââââââââââ�������â�ùÿ�èÇÆÿÿÿÿÿÿÿä�[ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿâââââ¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼­��‚ÈÈ��������������ÇÄÅÆ� ��1nnnnnnnnnnnnn$n­­­­­­/ÿÿ�gS��ÿü�n¢èèèèèèèèèn¢èèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèèÿvèèèèèèèèèèèèèè­­­­­­­­­­­­­­­­­­­­��‚ÈÈÇââââââââââââââââââââââââââââââââââââââââ­­­­­©­­­SRRRRRRZ­­��‚ÈÈÇÄÅÆ� �XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX�0‘P�Ì3��½.€b+· �ÇÈ��46t�gggggggggggggggggggggggggggggggg¼¼¼¼¼èèè­­­­­­­­­­­­­­­­­®­­­­­¼¼¼����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e5137c545032f0c8c5ae6cabc5bbc2ede6370b06������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������J/2� Raö�����ñ���ÿûÖvqÿúÿ��žÿÿ!a �Èe������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ed0f301384e5530814f95de4c53ac7e7301d35a5������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0032007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ïï�è#�� :˜��õ���333333333ÿ�ö! ������3Á`ÁPPòòòòòòò¼üüÁÁòòòòòòÿþÿÿÿåßÿÿ@ÿÿÿþ�������������òò�b���������2���òz�/€��•�ü¾ÿþüÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f2048a5d9e7244812355acd3308fe9758b84ef6a������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032040�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8�����������������������������������������������������������������������������������������������������������€³˜ÐÛ���������������������ÿ�0����ÿÿ$þû·´������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f2076dbdb823721d4d275ee0d63c625d4e07d6cd������������������������������������������������������������0000664�0000000�0000000�00000000242�15100345067�0032233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������,€³˜éþ��€���Ê`���Ã���…ˆˆ†$‰¸¸¸¸ü���?�¿��������«�.ÿ�ö!a��&��������������¸¸¸¸¸¸µ¸¸¸¸ÿÿÿÿÿÿ%ßÿÿ@ÿÿ]þ�ø���bB������;����€/�w——wÿ�����ÖÎ��fÄ1¸µ°��ÿHÁ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f3543673cd7f732b6680878a993b33199623cf62������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0031554�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8����������������������������������������������������������������������������������������������������������0���� @�ÚÛ�?:š���#����������ÿ���ÿÿAAAAAAAA������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f39742a8bb9ccb0675a05436d4bdb86da25a9d2b������������������������������������������������������������0000664�0000000�0000000�00000000262�15100345067�0032315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8���������������������������������������������������������������������������������������������������������������taR � ���ñ���ÿÿÿÿÿDÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/ÿý(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³��(���%ÿÿ@ÿÿÿþ��� �ö������™™�qqqqÀââââ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f8515665b1a6e5bd47075c62b27c76d612e45d8b������������������������������������������������������������0000664�0000000�0000000�00000000352�15100345067�0032031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8������������������������������������������������������������������������������������������������������������ï�ï#��è���:˜��õ������ÿÿÿÿÿÿÿÿÿÿ� ����������������*�� [��� ���������������������?�������õ������ÿÿÿÿÿÿÿÿÿÿ� ����������������*�� [��� ���������������������?���������������ÿ�ÇÇÇÃÇÇÇÇÇ���€³˜ï���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������fa0efb79a43b42c1f4ecfaed81dab190b9546bb8������������������������������������������������������������0000664�0000000�0000000�00000000562�15100345067�0032614�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/deltadelta-int8��������������������������������������������������������������������������������������������������������������taR � ���ñ���('ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���b/��(���ÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ��b/��(���ÿÿÿ�,�����������Q������€�������vqÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€³�:˜��� �À��[qÿÿÿ���b/��(���ÿÿÿÿ¿���å[���€[���€³˜ïï������:˜��� ������[qÿÿÿ���b ��(���ÿÿÿÿ¿���å[���€³����������[[[[[��ââ����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-bool/������������������������������������0000775�0000000�0000000�00000000000�15100345067�0024767�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-bool/empty�������������������������������0000664�0000000�0000000�00000000000�15100345067�0026036�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text/������������������������������������0000775�0000000�0000000�00000000000�15100345067�0025020�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������03be2aaf02e2f78738dcd55209eb660c63460f73������������������������������������������������������������0000664�0000000�0000000�00000001161�15100345067�0032237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���Ã���EEEEEE²ºººººº²EEEG¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹OOOOOOOOOOOllllllllll������1t��������������������������������ºººEEEEEEEEEEEEEEEEEEEEEEE@EEEEEE’EE!Ú�������������������pg_catalog�text���ô������������`������è������ÿÿÿ��������������������������������������������������������(��������������������������������������������������pg_c��æ�������������������!��0611��������~��Q�������������!Æ���������������ô��������atalog�text���à��������ÿüÿ���������,�ö,€�������võÿÿÿþÿÿ����ÿ������`������è������ÿÿÿ��æ��������"��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06a9bb98f465ce2136ba9c5c3b15912de9101d7b������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���à�����ÿÿÿÿü��û������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0ce9675bea488114cd61e0902df0f65bb266b414������������������������������������������������������������0000664�0000000�0000000�00000001161�15100345067�0032235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���Ã���EEEEEE²ºººººººEEEE¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹OOOOOOOOOOOllllllllllllllllllllll�pg_catalog�te�����������P������������������������������pg_catalè���û���5�ô����������ÿ����ÿÿ�ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�llllld�::::::OcatalBBBBBBBBBBBBBBBBBBBBBBBOOOOOOOOOOOOOOOOOOOllllllllllllllllllBBBBBBËB��ÿÿ�ÂÂÂÂÂBBBBBJJJJJJJJJJJJ)J��������lpg_catalog��������������������� ¬�����pg����ÿÿÿÿpg_catalog�text����ÿÿÿÿ�����ÿÿÿÿÿÿ�ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����%����������ÿ����è����|ªªªªªªª���logÿÿÿÿÿÿ������������������atgao�l����ö����pg_����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������127d1cd7df6314984a355234cad8daee2a0a6f85������������������������������������������������������������0000664�0000000�0000000�00000000131�15100345067�0032373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�ö,€���1�����è����þÿÿ+ÿ[z������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������193ff1ad23aaeaa8feafcbe7168f259e5063e715������������������������������������������������������������0000664�0000000�0000000�00000002305�15100345067�0032625�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@���=��è���hªªªªªªªª÷è���hªªªªªªªªªªVªªªŠªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªUUUUjªªª���UUUUU���P�����������������÷ÿ������%����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1a155dbc0885a4ce404a03ccad4f90e8dfb6838b������������������������������������������������������������0000664�0000000�0000000�00000000026�15100345067�0032527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1bdd8892fa9cd727ebf1b97101a04456b8ba7bc2������������������������������������������������������������0000664�0000000�0000000�00000000016�15100345067�0032456�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������20294feb1598e5893bda9b1fe7b9568ea0af237c������������������������������������������������������������0000664�0000000�0000000�00000000250�15100345067�0032422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@���=��à�����ÿÿÿÿÿÿ,öÿ�,€���[����€µÿÿ¨������ÿø��øÿ%ÿ������"����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������24a09483ef45200b6ed894e43934767755155e3d������������������������������������������������������������0000664�0000000�0000000�00000000115�15100345067�0031703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�ö,€���'���ÿÿýè����þÿÿ+þÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������27de45122a7e9da969165f24f6942fc131cb17df������������������������������������������������������������0000664�0000000�0000000�00000000070�15100345067�0032253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿ�����@@��¯�=�������me������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������29e8abf085d862cb208f5e476f628644de1c22a0������������������������������������������������������������0000664�0000000�0000000�00000000161�15100345067�0032251�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���%������������@������������@���è���ï}î/ªª`ªªªÿªª��������������������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2a0fa91e546f986d25159ed1e7507ec4793df3a4������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���å�����]��ÿ��� �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2d79b560f5c1dde8b7841ae6d77d616f26f5b3ab������������������������������������������������������������0000664�0000000�0000000�00000000221�15100345067�0032473�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@������� ��� ��ªªªªªªªªªatalogg_catalo��:g�text���:����������(@è���atalog�atalog�����ö��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2dd04d16222832a133c966eb5e9c4e7ae4d31059������������������������������������������������������������0000664�0000000�0000000�00000000163�15100345067�0032154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è��������A�žâ�>€�€;������AB������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2e10aad1b62e9ad833ea94af977cd498ba7da057������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032542�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è������������>€�8���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2ee77e4ad0a5c13eb219c48f0e8964d9f6124737������������������������������������������������������������0000664�0000000�0000000�00000000152�15100345067�0032257�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@������Ó�����ÿÿÿÿÿÿÿ,�ö,€�������€õÿÿ,ÿÿ��"�1ÿ������������s����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3716f49a4dc3a527cc3682d04ae2036204c406ce������������������������������������������������������������0000664�0000000�0000000�00000000111�15100345067�0032133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è��������ÿ��¦,�ö>€��������_“ž‹û���èt���>����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3902e1ec9e8894b6befc97144a957e69f696bc75������������������������������������������������������������0000664�0000000�0000000�00000000301�15100345067�0032313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������ð������j���ªªªªªªªªªªªªªªªªªªªª�text����������Q����pg_catalog�text����e���÷��Ú������w��it*�����+!�����������666.6h-66666���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������39e6777ccb030519cefc62205e2df23e703aa9fa������������������������������������������������������������0000664�0000000�0000000�00000000131�15100345067�0032373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���������������@������è���è�)ªªªªªªªVUUU�������Ü���[����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3b2185a90d32decad650ceb443751a4023368cdd������������������������������������������������������������0000664�0000000�0000000�00000000247�15100345067�0032302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@���=��à�����ÿÿÿÿÿÿ,öÿ�,€���[����€µÿÿ¨������ÿø��øÿ%ÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3e8223a2a8a5034ca9935ccb1a9c8f41f4dfd782������������������������������������������������������������0000664�0000000�0000000�00000000211�15100345067�0032375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text����t��� �&0�ÿÿÿÿÿÿ�Úqo_catal��������è��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3f1762bf4bdff8f21a3de2f04afe2cc9bfd538a5������������������������������������������������������������0000664�0000000�0000000�00000000251�15100345067�0032761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text������說ªCCCCCCCCCCCCCCCCCCCCCCCCCCCCCpg_catalog�text���ô������������`������è���ªªªªªª����ªªªªª�ª�ªªªªUUUpg_cat��ö��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������446dbbeac1d19ca3ac51def5be4e9fcccf97cdc6������������������������������������������������������������0000664�0000000�0000000�00000000120�15100345067�0033255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�ö,€���1�����1�����ÿÿ:ÿÿ��ð���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������44991dd092a92994af67db1b51c9ca42261c27d3������������������������������������������������������������0000664�0000000�0000000�00000000111�15100345067�0032161�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text����e���÷��Ú+!�����������666.666666��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������44dae141798a56015e84bb90b8d47f2d1d9db66e������������������������������������������������������������0000664�0000000�0000000�00000001166�15100345067�0032341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���Ã���EEEEEE²ºººººººEEEE¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹OOOOOOOOOOOllllllllllllllllllllll�pg_catalog�text���è���!�ÿÿÿÿÿÿÿoalog�te��tA������`������`��,€���0�����1�è���û���5�ô����������ÿ����ÿÿ�ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�pppp��������������������������������������P������������������������������pg_catalè���û���5�ô����������ÿ����ÿÿ�ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�llllld�::::::OcatalBBBBBBBBBBBBBBBBBBBBBBBOOOOOOOOOOOOOOOOOOOllllllllllllllllllBBBBBBËB��ÿÿ�ÂÂÂÂÂBBBBBJJJJJJJJJJJJ)J��������lpg_catalog��������������������� ¬�����pg����ÿÿÿÿÿÿÿÿ�����ÿÿÿÿÿÿ�ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������������������pg_�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������48ddda607e4778f35289784b3f6c80234660856d������������������������������������������������������������0000664�0000000�0000000�00000000110�15100345067�0031774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�ö,€���0�������ÿÿ:aÿÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4979455aba5b4c7d302af47c4fd941214e16d3a9������������������������������������������������������������0000664�0000000�0000000�00000000110�15100345067�0032235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿ���,�ö���è����+ÿÿ[z������Öÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4e4ec17ed15eab3b2aaee34c46ca44e72789f384������������������������������������������������������������0000664�0000000�0000000�00000000111�15100345067�0032536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���"������������@������À���������� �>‚�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4e8af02cd72c9425df8c3164b3a14bc1b70c6498������������������������������������������������������������0000664�0000000�0000000�00000000032�15100345067�0032312�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������559b65125ca556ff1a57f82f9ae55a86b71c6296������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0032203�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������55b0c7dbbd7470a644c43aaf8aaaa520631e3bb5������������������������������������������������������������0000664�0000000�0000000�00000000251�15100345067�0032504�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text������ªªªCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC����@����������������������pg_catalog�text����e���÷��Ú+!�����������666.666666���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������57a99548ae911ad4a20406a03b0a0ac7a9adc63a������������������������������������������������������������0000664�0000000�0000000�00000000111�15100345067�0032341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���������������@������è���������[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5a72bac420b736c0d530a9d4c861a374ad32f5a5������������������������������������������������������������0000664�0000000�0000000�00000001173�15100345067�0032277�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE@EEEEE’EE!Ú���������������������������N66665��������������������������� ¬�����pg_catalÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿpg_catÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������/��������P����������������������������������)������������=]��������������������������bbbbbbbbbbbbbbbbbbbbbbb�����þÿÿ���������������alo��������������������p�g����g�text���ô������������`������è������ÿÿÿÿ���������������������������������������������������pg_catalog�text���à�� �����ÿüÿ���������,�ö,€�������€õÿÿÿþÿÿ����ÿ������ ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5ba93c9db0cff93f52b521d7420e43f6eda2784f������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0032460�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5c9409528b92b40afa79d037eadcb73b859e94e6������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����������0>€&€���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5c99325fac6e6a77d673cf223fb3b3e62fb1e07e������������������������������������������������������������0000664�0000000�0000000�00000002323�15100345067�0032474�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@���=��è���hªªªªªªªªè���hªªªªªªªªªªVªªªŠªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªUUUUjªªª���UUUUU���P�����������������÷ÿ����������������pppp�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������o������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������o����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5e81672e813bd1e06ecba224f520328498f27ea8������������������������������������������������������������0000664�0000000�0000000�00000000241�15100345067�0032164�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text������ªªªCCCCCCCCCCCCCCCCCCCCCCCCC���catalog�text����e���÷��Ú+!�����������666.66��Ú+!�����������666.666666��%��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������626bf1b65f1a0c5fba061fac07a711f970b07a80������������������������������������������������������������0000664�0000000�0000000�00000001162�15100345067�0032352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text����K���EEEEEE²ºººººººEEEE¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹GFFFFFFCOOOOOOOOOOOllllllllllllllllllllll�pg_catalog�text���è���!�ÿÿÿÿÿÿÿoalog�te��tA������`������`��,€���0�����1�èû���5�ô����������ÿ����ÿÿ�ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂOOOOOOllllllllllllllllllBBBBBBËB��ÿÿ�ÂÂÂÂ���û���5�ô����������ÿ����ÿÿ�ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂOOOOOOllllllllllllllllllBBBBBBËB��ÿÿ�ÂÂÂÂÂBBBBBJJJJJJJJJJJJ)J��������lpg_catalog�������pg_catalog�text���è���ÿ��������������� ¬�pg%cata �������������������������������������������pg����ÿÿÿÿ`ÿÿÿ�����ÿÿÿÿÿÿ�ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������������������pg_�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������62ca0c60044ab7f33aa33d10a4ae715ee06b7748������������������������������������������������������������0000664�0000000�0000000�00000000063�15100345067�0032266�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è����ÿÿÿÿÿÿÿ ������@�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6407ff9cce2be245bacff6693615b8e382ba2a96������������������������������������������������������������0000664�0000000�0000000�00000000120�15100345067�0032470�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���à�����ÿÿÿýÿÿÿ,�ö,€�������€µÿÿÿþÿ���A����������1ÿ�,t������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������664e56319f5a1ffc9bd3e9554f2358ace5a739ca������������������������������������������������������������0000664�0000000�0000000�00000000301�15100345067�0032422�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������ð������ê���ªªªªªªªªªªªªªªªªªªªª�text����������Q����pg_catalog�text����e���÷��Ú������w��it*�����+!�����������666.6h-66666���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������687464af84370f5d43d25acba442acc7fd14beec������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������68c94392b09d47edea2a48f62808073bf83448f3������������������������������������������������������������0000664�0000000�0000000�00000000246�15100345067�0032135�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@���=��à�����ÿÿÿÿÿÿ,öÿ�,€���[����€µÿÿ¨�����ÿø��ÿ%ÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6af6e86bfe31a3941d3085227f051c05777657de������������������������������������������������������������0000664�0000000�0000000�00000000501�15100345067�0032113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���!�pc_gÿtalog�te��tx�ô����������A���������������������ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�pppp��������������������������������������P������������������������������pg_catalog�text�����������ÿÿÿÿÿÿÿ,�ö,€���1�����1�è���û0��1�ô����������ÿ����ÿÿ���è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6f04561347c9100edce326d87e065789d2d56185������������������������������������������������������������0000664�0000000�0000000�00000000110�15100345067�0031754�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�öY€���2�����ÿÿÿÿÿÿÿ,�2o����Y��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������726be829733ebbca258b51fc29a79e543de46677������������������������������������������������������������0000664�0000000�0000000�00000000301�15100345067�0032264�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ð������������@������è���ÿªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªUVªªªªªªUUUUUUUUUUUUUUUUªª¥UUUUUªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªUUUUjªªª���Ul���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������75fc076b6fc8dac4f65c31fa4fd34ad236530422������������������������������������������������������������0000664�0000000�0000000�00000000151�15100345067�0032373�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text����t����&0�ÿÿÿÿÿÿ�Úqo_catal������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������76bbc1ead78624711303acd22377969f0962736b������������������������������������������������������������0000664�0000000�0000000�00000000252�15100345067�0032031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text������說ªCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC(CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCªªªªªªªªªªªªªªªª������@����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������76fa9dc37fc42934404c72df57d296c663ee807d������������������������������������������������������������0000664�0000000�0000000�00000000301�15100345067�0032270�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@������è���þÿÿÿ����ªªªª�� ����������ª��ªª��ªªªªªªªªªªªªªªªªUVªª���ªªªªUU]UUUUUUUU]�������������pg_catalog�te��xt��������e��Q�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������79ef4a8ba594c7a2b611bc33fc8b83fe8ac14998������������������������������������������������������������0000664�0000000�0000000�00000000111�15100345067�0032477�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ó������������@������è��� ������O��>����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7bbc7585698a7c3375bea9c3bcff8838722d8f64������������������������������������������������������������0000664�0000000�0000000�00000000071�15100345067�0032366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���������ªVUUUUUUéata&ogg�ö������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7be90a9058961ac6ee07f764618805dfe8b6cfae������������������������������������������������������������0000664�0000000�0000000�00000000070�15100345067�0032432�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è��������ÿ��A,�ö>€�������èt�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8127c19b14b9a5750a4731aef2f900a72ec6d802������������������������������������������������������������0000664�0000000�0000000�00000000501�15100345067�0032145�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���!�pg_cÿtalog�te��tx�ô����������A���������������������ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�pppp��������������������������������������P������������������������������pg_catalog�text�����������ÿÿÿÿÿÿÿ,�ö,€���1�����1�è���û0��1�ô����������ÿ����ÿÿ���è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8426e28aabe6684eb7200bd032ff0dad5a5169af������������������������������������������������������������0000664�0000000�0000000�00000000071�15100345067�0032447�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���������ªVUUUUUUéata&ogg�ö������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������85e53271e14006f0265921d02d4d736cdc580b0b������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0031772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������ÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8a5c3216797d7a54adeafc86b708b942a9894b2f������������������������������������������������������������0000664�0000000�0000000�00000000141�15100345067�0032345�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text��������%����������ÿ����è����|ªªªªªªª���log�atgao�l����ö��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8c92cd8b3e908dad0b490baa09ee984fdf224b21������������������������������������������������������������0000664�0000000�0000000�00000000124�15100345067�0032541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�ö,€���1�����1�����ÿÿ:ÿÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8f1eab4f75b343ac81f12c926a077aaa572cd002������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032354�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����������>€�1���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������95f1a48e7e1cbe4b91461f1251416245497ff131������������������������������������������������������������0000664�0000000�0000000�00000000010�15100345067�0032015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������`l ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������994cc577406fe37f59e27ea1028a9d0a814af721������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032176�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è��� ��èt���>��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9a78211436f6d425ec38f5c4e02270801f3524f8������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0031737�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������@�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9a88a0ae40cf185ed2c9bf4ebde71b048030211d������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032436�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è����1�����@���=��"���"� ªªª���€���ÊÊʪÿÿÿÿ�����ÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9b99593353a610c4bee0d6a94a01a3296080c0fb������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0032141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a42f35cc555c689a38ef471b21fad93692f36a9c������������������������������������������������������������0000664�0000000�0000000�00000000060�15100345067�0032337�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è����������� >€���2������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a54a56388dd751dc1ea1727f8e2965b349b54800������������������������������������������������������������0000664�0000000�0000000�00000001154�15100345067�0032117�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���ªªªªªªªªªªªªªªªªªªªªªª��ô�ù7770710��������1����������������������ÿ��ÿ�������������pppp�����������������6������������������������������������������$����������������������������������������������������������BBB���������������������OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOBBBBBBBBBBzzwzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz-zzzzzzzzwwwwwwwwwwwwwwwwBwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwzzzzzzzzzzzzBBBBOOOOOOFO�������������������������������2�������������������������������������������������������������������������������������������������������������������������pg�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a707473dd0d734a745a15b98f20645839d69a660������������������������������������������������������������0000664�0000000�0000000�00000000501�15100345067�0031754�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���!�pg_cÿtal�gt�o�etx�6������������A���������������������ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�pppp��������������������������������������P������������������������������pg_catalog�text�����������ÿÿÿÿÿÿÿ,�ö,€���1�����1�è���û0��1�ô����������ÿ����ÿÿ���è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ae02ec1f395c202f6cd2965ea34d73dc35e10fdf������������������������������������������������������������0000664�0000000�0000000�00000000211�15100345067�0032525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text����ô��� �&*0�pg_catalog�text����t��� �&*0�ÿÿÿÿÿÿ�Úqo_catal�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������af094ea4a3607992332e87dbe90f1a0f0cf82e09������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���å����]��*���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������af33a704edf520f6ccc1c6c51b06d39b5a7e82f8������������������������������������������������������������0000664�0000000�0000000�00000001161�15100345067�0032535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���Ã���EEEEEE²ºººººººEEEG¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹OOOOOOOOOOOllllllllll������1t��������������������������������ºººEEEEEEEEEEEEEEEEEEEEEEE@EEEEEE’EE!Ú�������������������pg_catalog�text���ô������������`������è������ÿÿÿ��������������������������������������������������������(��������������������������������������������������pg_c��æ�������������������!��0611��������~��Q�������������!Æ���������������ô��������atalog�text���à��������ÿüÿ���������,�ö,€�������võÿÿÿþÿÿ����ÿ������`������è������ÿÿÿ��æ��������"��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b18ecac8feda2826b91131b386b8842a1fca17e5������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0032456�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô�����������@������Ó�����ÿÿÿÿÿÿÿ0#ö,€��� ����€õÿÿ,ÿ‡‡‡‡‡‡‡‡‡‡‡ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b1eb62fe7596e0f62ef933c269b429851f73853b������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0032213�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b931131d935fb27ebf7977285299dcf11bb52eb4������������������������������������������������������������0000664�0000000�0000000�00000000141�15100345067�0032254�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@������Ó�����ÿÿÿÿÿÿÿ,�ö,€������$€õÿÿÿ��"�1ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ba200d8a4886abcdba4174f4b131db56e9128785������������������������������������������������������������0000664�0000000�0000000�00000000130�15100345067�0032305�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���à�����ÿÿÿÿÿÿÿ,�ö,€�������€õÿÿÿþÿÿÿ������"��������1ÿÿ������t����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������bf8b4530d8d246dd74ac53a13471bba17941dff7������������������������������������������������������������0000664�0000000�0000000�00000000001�15100345067�0032366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c78643e37119bb0f817531ba2ff265d6ef53c64e������������������������������������������������������������0000664�0000000�0000000�00000001155�15100345067�0032256�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���ªªªªªªªªªªªªªªªªªªªªªª��ô��8770710��������1����������������������ÿ��ÿ�������������pppp�����������������6������������������������������������������$����������������������������������������������������������BBB���������������������OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOBBBBBBBBBBzzwzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz-zzzzzzzzwwwwwwwwwwwwwwwwBwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwzzzzzzzzzzzzBBBBOOOOOOFO�������������������������������2�������������������������������������������������������������������������������������������������������������������������pg���_�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c92920944247d80c842eaa65fd01efec1c84c342������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0032233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-49789ae0866d7d630f2075dc26812433f4af1db3������������������������������������������������������0000664�0000000�0000000�00000000347�15100345067�0033217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è������������>€�€������������������pg_catalBBBBBBBBBBBBBBBBBBBBBBBOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOBBBBBBBBBBBBBBBBBBBBBBBog�text���è������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-5eeac6ca5053992914dfb318e02e4c657a65c7cf������������������������������������������������������0000664�0000000�0000000�00000000256�15100345067�0033514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿÿ,�ö,€���2�����è�����ÿÿÿÿÿÿÿ�t���ext�����������������������������������������������������������������������������������������������at��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-707526606a02c72364e1c8ea82357eead6c74f60������������������������������������������������������0000664�0000000�0000000�00000000121�15100345067�0033175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è��������ÿ��A,�ö>€�������p'_“ž‹û���t���èt���>�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-b0db762535226b28c0b55ffe00d5537fd8ef7e39������������������������������������������������������0000664�0000000�0000000�00000000064�15100345067�0033430�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è����������� >€�������same����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-bd6e8aa1ebeb96cf8aa644c5ef6eb2214dee0ffc������������������������������������������������������0000664�0000000�0000000�00000000070�15100345067�0034276�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���ò����������8���������������same������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������crash-e5143387e8896dcfb0f95f8111538502cee38ce0������������������������������������������������������0000664�0000000�0000000�00000002142�15100345067�0033303�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è������������>€�€��,�����lBBBBBBBBÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿNNNNNNNNNNNNMNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNÿÿÿÿÿÿ #NNNNNNNNNNNNNNNNNNNNNNN���������������������BBBBBO�������õõõ��������������� �����������������������������������������������������������@�+���������������������������� ���������������������������������������BBBBBBlBBB/BBBB���������������������������������BBB���U���������������������������������������bBBBBOOO������������������OO���������������������������������������������������������������!�OOOO����������������������������¬¬¬¬������?������������������������BBBBBOOO���llllllllllllllllllllllllllllllllllllllllllll~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~n~~~~~~~~~~~~tttM��������ttt:tttttttttttttttttttttttttét�������������sssss���������������OO�����������������������������������BBBB���������������������������������������������� �������:��������������������������������������������������*�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d0f63f55c89c3220cd326e9395c12e2f4bd57942������������������������������������������������������������0000664�0000000�0000000�00000002511�15100345067�0032174�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���!���Ú�������������666.666666��������������������������� ��������������������~��Q�������������!���600978770710���������P�����������������������������������pppppppppppppppppppppppppppppppppppppppppppppppppp������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������(�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0��������������������������������������������@����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d421e94ef02d0e45a2f783b63f3fe6622b6776cd������������������������������������������������������������0000664�0000000�0000000�00000000110�15100345067�0032324�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è�����ÿÿÿÿÿÿ},�ö,€��%������������÷�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text/dict1�������������������������������0000664�0000000�0000000�00000000070�15100345067�0025744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���è������������>€�����������same������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e0485f22a1d04b0df70035eafa33f1278a52b8a6������������������������������������������������������������0000664�0000000�0000000�00000000252�15100345067�0032273�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���ïîî몪ªªªªªªªªªªªªªªªªªªªª��ô��8770710��������1����������������talppppppppppppppppppUU��������og�text���è������t���è��ÿÿÿR��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e5c4a84e1935991b3103fecf70bf563eb82f7936������������������������������������������������������������0000664�0000000�0000000�00000001034�15100345067�0032263�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���:���;EEEEEEEEEEEEEEEEEEEEEEEEEEEEE���� ����pg_catalog�text���à��������ÿÿÿ,�ö,€�������€õÿÿÿþÿÿÿ������"��������0t����������������������������������������������;1����������������������������������������1����ö������������������������������������t���è���ûÿÿÿ���è��������������pg_catalog��������?�����text,��å����@EEEEEEEEEEEEEEEEEEEEEEEEEEEEE�������EEEEEEEEE!Ú���������������������N66666�������������ÿÿ1����������� ¬�����pg�����ÿÿÿ,�ö,€�������€õÿÿÿþÿÿÿ������"��������������������P�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e767ec96033f7d9da306711adab0a6557fd4b71e������������������������������������������������������������0000664�0000000�0000000�00000000501�15100345067�0032403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���!�pg_cÿtal�gt�o�etx�6������������A ��������������������ÂÂÂÂÂÂÂÿÿÿÿÿÿÿÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ�pppp��������������������������������������P������������������������������pg_catalog�text�����������ÿÿÿÿÿÿÿ,�ö,€���2����]1�è���û0��1�ô����������ÿ����ÿÿ���è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������eb02ce7f9339084b7dfa707b412ee1b1f7046885������������������������������������������������������������0000664�0000000�0000000�00000000070�15100345067�0032247�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���at+alog�text���è��������è��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ecbd22c462813a437898cfe2848a46e5d6a460c5������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text����������Q�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������eddf750270b16df6744f3bbfa6ee82271961f573������������������������������������������������������������0000664�0000000�0000000�00000000032�15100345067�0032333�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���èÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������efb13296f8f471aadfdf8083380d1e7ac9a6bbc5������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032627�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���ûÿÿÿ���è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f0f2e7efda77af51c83fe7870bd04d1b93556116������������������������������������������������������������0000664�0000000�0000000�00000000114�15100345067�0032410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���à�����ÿÿÿ,�ö,€������'������������:@����������2ÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f2d42e12fb2ed451e7ba0b270a9065916a391fb1������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032275�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è���ûÿÿÿ���2�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f6377e2f32fd888f1877518c26bf6be4e24f92bd������������������������������������������������������������0000664�0000000�0000000�00000002061�15100345067�0032364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���è������������>€g3������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������fc8f69146bf6f556444c5acd8053537a292db418������������������������������������������������������������0000664�0000000�0000000�00000000061�15100345067�0032201�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���å�����]��ÿ��� �ö��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������fe56cff03603408c02ef6579df1958ba3cdbdd48������������������������������������������������������������0000664�0000000�0000000�00000000301�15100345067�0032471�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text��������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@������è���ªªªªªªªªª��Q��������������ªªªªªªªªªªªªªªªªªªªUVªª���ªªªªUU]UUUUUUUU]�������������pg_catalog�te��xt��������e��Q�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������fee17c65913f4eddcae3f69d1c2b6f318b938af2������������������������������������������������������������0000664�0000000�0000000�00000000110�15100345067�0032631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text���������������������������������������������������������������������������������������������������������pg_catalog�text���à�����ÿclaoagt�textÿ��'�����������������#���t��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-text/with-nulls��������������������������0000664�0000000�0000000�00000000323�15100345067�0027047�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������pg_catalog�text���ô������������@������è���ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªUVªªªªªªUUUUUUUUUUUUUUUUªª¥UUUUUªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªUUUUjªªª���UUUUU�������same-with-nulls�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-uuid/������������������������������������0000775�0000000�0000000�00000000000�15100345067�0025002�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/dictionary-uuid/empty�������������������������������0000664�0000000�0000000�00000000000�15100345067�0026051�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8/�������������������������������������0000775�0000000�0000000�00000000000�15100345067�0024515�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������000335f765ced2a4f901ac182723f543d684e01a������������������������������������������������������������0000664�0000000�0000000�00000000037�15100345067�0031560�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À��@�Z���������¨����ÿÿÿÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������001123a617c5cd66ad7122a7bf5a4df193fec5c5������������������������������������������������������������0000664�0000000�0000000�00000000057�15100345067�0032060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������������������� �ƒ������ÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0018f597ee9cd81341f63167e437891935ded799������������������������������������������������������������0000664�0000000�0000000�00000000324�15100345067�0031507�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A�����������������������à���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������008f5da38ab688b5013799fa2078080b87d1315a������������������������������������������������������������0000664�0000000�0000000�00000001104�15100345067�0031514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€�ý��è��������ñÿ������� �÷ÿ����������P�������0Ä ½Š,²$D’Iè������������>€�ý��è���...........................................�������.......�����ñÿ������� �÷ÿ����������P�������0Ä ½Š,²$D’IÈÒ1 ‚(‚ ,�@À�������è������������>€��ý��è��������ñÿ���)��� ��)��������:��P������� ½Š,²D’IÈÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$ÈÒ1 ‚(‚ ,��� ½Š,²D’IÈÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$ÈÒ1 ‚(‚ ,�@À�������è������������>€��ý��è��������ñÿ������� ��)��������:��P������� ½Š,²ÈD’ÒI0‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00c229a7320c63a40c31ea1268814fc13b15de90������������������������������������������������������������0000664�0000000�0000000�00000002504�15100345067�0031541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À��]���è������������>€��ý��è��������ñÿ������� �������������P�������É ½Š,²I’È$DÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ����ÀH���D��������DE���������������üÿÿÿÿÿÿ%�����>€�ý ›�{a���0áà0��³v¤P²&Ô«Šæ‹` ��������ÿÿÿÿÿÿÿ���Šæ‹` ���`Áè����ÿÿâ���@À�"�����)è������û����>€�������A���������������������@À������è��@��������>€�������A�������\����ªªª�@À�"�����è������û����>€�������A����������������������è���µªªªªªªªªªªªªªªª™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™������� �����X SSÿ�ªªªª®ªªªªªªªªªªªªªªªµµÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���ÿÿÿ���)©))))))TTT��������ÿÿÿ���¿����AA����������8���������A��������e��� ������������…���������������������������…�������@����������Ê������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�ÿÿ½���A������������������A������������������������������X ����$������������������Ê�������ÿÿ½����A����������������������������������A(‚ ,¢‚,�¿����ññññññññññññññññ��Ê������� ÿ½����A�������������···························���������������������A(‚ ,¢‚,�¿����ññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññññ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00fa51c6e24f79b0ba39dd32e9f3b68561ae2eff������������������������������������������������������������0000664�0000000�0000000�00000000016�15100345067�0032236�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������ù¥ÍÿŸÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������00ffbad9a023d169b2b1943887702b3cac8b045c������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031775�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������¿����A��������5����������A��������a��� ������?���A�������������� �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������010e7a5025e9ff7ffacf3ce3e2176bcb8c29617b������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@������������������������������������ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0189f688b66865cd51637e2f5f8347431fcc54ad������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À����Z�������.ÿÿÿÿÿÿÿÿþÿÿ ��è��� �����…³ 6Ä���������è��� ��� ���µ��˜�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������018c00c72b324da47458186f1f1527945de2b3d7������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*������� ��������Ö������B�����������úÿù����"�������������������B�������…����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������019e2ae7986441e1220e4060aeee97063e5f5f7f������������������������������������������������������������0000664�0000000�0000000�00000000264�15100345067�0031672�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������X ��������A������������������A��������������������?���A��� (278A77777777776�4444444444444444444444000000000000000000152022799��������444SSSSSSSSS���A���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������01beb9afee5bdd566eebc3e11ab9a2bf937af072������������������������������������������������������������0000664�0000000�0000000�00000000237�15100345067�0032531�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������������������A����������\����¿¿¿¿¿¿¿º¿¿¿¿¿�ÿ�?���A@�� �Pz��������à ½Š,²I$’ÈDÒ0 ‚(‚ ,‚$’Ê 5ƒM ³ ƒ�����ÀH������DE�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������01d284d9abc6f8798411204503b6e7092294497a������������������������������������������������������������0000664�0000000�0000000�00000000062�15100345067�0031367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ƒ���¤���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������01ee785469f584519839126202f99e66e0f6b62f������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À������������f%�>����ÿÿ����è�����è�������� ���������è�����àÀÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������02118691c5748861f850a0ddc6504520e9cf9d59������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031462�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���098HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))TTT���������������¿����A��������7����������A��������e��� ����������@����������������������������Ò��� ����-�������A������TT¬«ÔªTTTTT��������������������…���������������€����������:���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ44444.44444444444´4�������¿��������¿�������������������������������������������02210f01b6e9d651caacb78cbe1981c3d7d948cf������������������������������������������������������������0000664�0000000�0000000�00000000022�15100345067�0032145�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����€�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������025fa6c86875979f9890fd5821994db68b0d9e0d������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@Z�������������������A�������������������������� ����÷ÿ5A�������������� �������������?���������rrrrrrrr����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������026d5ea723c4995420f38fc8e2f41f52fdc8934f������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031764�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@Z�������������������A����������������������������������������L� �������������?���������rrrrrerr������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������02819a1d54865c2b35eb888056fa9d88d7da99a2������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031706�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������.�������������ÿn������������������������������������B�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������030401af4fb4f96e77e95d08e12261897120bfe8������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������������o���A����������������� ��?���� �������B�������������� ��@����������.�������������ÿn������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0316e3ffcaf4e49f3ce450a4681df2010192c3d8������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032005�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������032a566a41de14096cb32800aa07ea600a9dc74d������������������������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0031702�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è�������1��� ������������g���))©))))))))))))H¶�����@���������������������������������ÿÿ������þ�ø�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������032d6f047e5c6e1f3cc3816ee1b8da3c8971bcbb������������������������������������������������������������0000664�0000000�0000000�00000002324�15100345067�0032235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆAˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ@ˆˆˆˆˆˆˆˆˆˆˆˆˆ))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))TTT�� ����-�������A�@��������6�������������������--¨�������������������…������@���������;��������������ÿÿÿ�����¹��x���^^^^^^^^^^^^^^^^^^^�����������>€�������A�������������¨Ô«¥TTTT��������������������…������@���������;��������������ÿÿÿ�^^^^^^^^^^^^^^^^^^^�����������>€�������A����������������������è���333HHHHHHHHH))ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ3HHHHHHHHH))ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))TTTç�� ����-�������A�@��������6����������������������*������� �������� Ö�����?:�������������ù��������,����6��������������������:����������¿����A��»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»�TTT����������������������������…���������� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������033b463a196126041ec08b6e61b189973f1627f6������������������������������������������������������������0000664�0000000�0000000�00000002504�15100345067�0031362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�"�����è�����������>€�������A����������������������è���•ªªªªªªªª™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªª1ª�@À���������������������������������������������������������������è�����������>€�������A����������������������è…��333HHHHHHHHH))))))ÿÿÿÿÿ))))))))))))))))))))))) �����������������Ç����A��������3����������A��������e��� ������������…���������������������������:Ò��¼÷� ����-�������A�����TT¬[ªTTTTT��|�����������������…�������������ÿÿ����������������������…�������������������������������ÿÿÿ���ÿÿÿ�����@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ2 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ��������i…���������������������HHH))))))ÿÿÿÿÿÿÿÿÿÿ©ÿÿÿ)ÿ@k)))!))))))))))))))))))TTT�����������������è���µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµvµµ���Ò��¼÷��…���������������������HHH))))))ÿÿÿÿÿÿ)ÿ@)))))��������������…��������������������������������������ÿÿÿ���ÿÿÿ��ÿ�������������������…�����������������������������������������������������������������������������ÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������03b2ca74225ae7011134f9aa114040b106ec8caf������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A������������������A��������������������?���5���7638860������������������������A���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������03cda3811ac87f97a957ece7d963db8dda7aaa8d������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*������� ��������Ö �����B�����������úÿù���"�������������������UÉÉ��=�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������03e931d374e50b3e6612eb4a7b4eb6707c75f2ce������������������������������������������������������������0000664�0000000�0000000�00000000764�15100345067�0032024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A�������\��������������è���166HHHOHHHÿ/)))ÿÿÿÿÿÿÿÿÿÿ@)))))v+)))))))))©))))))TTT���������������¿����A����Í!����������A������Ê�������ÿÿ½����A������������������A�������������������������Ê�������ÿ���������A������Ê�������ÿÿ½����A������������������A�������������������������Ê�������ÿÿ½����A������A����������Ê�������ÿÿ½����A������A������������ �������������Ê�������ÿÿ½����A������������������������������������043d96b51ea12b68bbbdc1f9bbe69bc3e29163b5������������������������������������������������������������0000664�0000000�0000000�00000000122�15100345067�0032224�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������ß���������������!�����A���$��������?���A��������2������ÿ��ÿ�0���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������046d94fe08c43ec5b3ead226ef0206eb5c501e4b������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������.����������������������������������������� �������B���������B�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������04867457469f20f351b2863fa3197d79d739d20b������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/������������çøÿÿC���"������������������� �������B������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������04f6eecba790bef1c51a27366a658141f06f765f������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0032021�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A��� BBBBBBBBBBBBBB��üóÿÿÿ 7ãÎ<ýóŽÿ0ã<8ãÿ7������������A����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������055f0d536e9e4af4b9769b2fc4504d00516034f4������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031605�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è��������b��>€�������A����������������������è���083HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))!)))TÔT���������������Ç����A��������4����������A��������e��� ������������…���������������������������Ò��x� ����-�������A�����TT¬«ÔªTTTTT��|�����������������…�������������ÿÿf�����������@�������…�������ÿÿf������������…����������������� �����ÿ������þÿÿÿÿÿ���ÿÿÿÿ�������������A�����������������������������������0561d22c62592505cf5bd0a3943cf9aae716e5ae������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À������è���"��������>€�������A����������������������è�����ñ���ÿ������� ��>���� /����������� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������05a4b23a5b4806fadc1512f3962eacfd56b0b00b������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������� @��������2����������������������*������� �������� Ö�����?8�������������ù���/����������6�����������@�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������05a5a98579e2643e226e5571ba5d24339d622641������������������������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0031367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@�������������������@�������������������������� �������B������������� ������������B���Aüÿÿÿÿÿ±±±±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ1ÿÿÿÿÿÿ00�ø����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������05ad10df436f072a5bcae26764ce310ec7ce6e6b������������������������������������������������������������0000664�0000000�0000000�00000000064�15100345067�0032221�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ÿ��3��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������05e1c72278fac592cb882971bab84d568799ca57������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@������� �����������m����-������’������� �����P����������’���õÿÿ��ÿÿÿ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06498d96e93a66c56b0b5cb271fc67e7dbaefad0������������������������������������������������������������0000664�0000000�0000000�00000000404�15100345067�0032251�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù�����������������#�@���������€���������������� �������B������������� ������������à���óîÿÜÿ¿ÿÿ����������������������������� �����������à����ÿÿÿÿÿÿÿÿÿÿ��ÿü×ÿþÿÿÿûÿ�����èÿÿ���ÿÿÿÿÿÿÿÿHÿ��üÿÿÿþÿÿÿûÿ�����è����ÿÿÿÿÿÿÿÿÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06512255ce67fd4de2b6472be237c8dc9375d1b9������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031757�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���08DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDé �� ����-��������������A������T(T¬«ÔªTDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD3HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))T��������������Ç�����������A��������e��� ������������…����������������������������������ÿÿÿÿÒ���é �� ����-��������������A����������ÿÿÿ��������������������������������������������068dd3742f3f3beb0d9a00141a05ec1f16054373������������������������������������������������������������0000664�0000000�0000000�00000000422�15100345067�0031625�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����øÿ������������������������� �������B�ÿÿâ������������������������ü���B�������������������������üÿÿÿÿÿÿ[ÿ���øÿ������ ����������º��'@D€��������[������� ?��@����� ������³ûý›{a�+�0áà0���™�����0��������@À�������¨��������>€��ù����������0����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06e255ce19ca34158bb0ac82bcef108367ca3267������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0032002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³û�›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����4 5²]­I��´[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06e51dd399ecef706d99060188e41dccb79be52f������������������������������������������������������������0000664�0000000�0000000�00000000114�15100345067�0032121�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@��ö�d������������������øÿ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������06f43a625eaf0da2f2bf2fa9143a659fd5b2ff0b������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0032304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������� �������������øÿ����������������¤������� �������B������������� ��ÿÿÿÿ���?��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������070bd26d7cc8fcba32ef29da3ad625824c38d343������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0032141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������&������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07419f558bfcb7a18c7fa7598a9bda076e3bfe39������������������������������������������������������������0000664�0000000�0000000�00000000327�15100345067�0032212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ����ÀH���D��������DE������������� �����������@ ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07574d2f3e74a3bc135f59c033cd37482bd4c521������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������������@���A�������������������Á����������_�����������?���A�������������A������@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07707fa8bdb6bd86a827d7a4822dc25d8ea58f8b������������������������������������������������������������0000664�0000000�0000000�00000000474�15100345067�0032206�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@������������������#�@����������!��������������� �������B������������� ������������à���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥��������������� �������B���'���������!��������� �����������������������������������������������������B��¥¥�������ÿÿÿÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������078bb3b1836c346eb4025764c06c1c94da8aed31������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0031725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/���������������G���"������������������� �������B�����������÷��������� ���F� ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������07fcc85472883b813b69b0e4e4a795c9a9b1a3c6������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*������� ��������Ö������B�����������úÿù����"������������������UY����$����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������08bf43b8834a2a3663d2c6d287628816347eddc4������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0031612�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0B��������0����™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H ������������0áà0���“���,ÿ6÷ý¿ÿ€f��‰l¯ÿÿÿ’V¶õ‘+mµK;jI[v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������08f9d53a5a7d64f61b817786ac3acff477f8cbf7������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0032213�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A��� Ûä䪪ªª�$¨UUUUUUUUUUUUUU�����UUUUUUU����ú�����ÿ���������ï����TTTT�=�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0933cb848b5bab240adf85aa088d013c633283e5������������������������������������������������������������0000664�0000000�0000000�00000000074�15100345067�0031723�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������£����?����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0942e894b6559b62b4b52f2df1b409f4a7de53b0������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������������o���A����������������� ��?���� �������B�������������� ��@����������.�������������ÿm������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0943eafc6afd3a6ade048635011c148db8f4d8d0������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032152�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������‡���¤��������ÿÿÿ���>�������è�������gÿ����������������������� �������B���������B������@����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0982c40ef6669e243d31221b3e54e4eb58fd6609������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ������������������������ �������B������������� ��O�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0998446366e5a5f8d4d1ed817ebdf627df5bf145������������������������������������������������������������0000664�0000000�0000000�00000000067�15100345067�0032057�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A���������������A������@���ìììì������{ììì�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������09b35f10899c4282030d0fc8dfadff0a1366ed2c������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032067�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������Z������������>L�ùþÿ��™����� ���������f�������¨�����Àü��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������09f6ee62d7b28e763bc3dcddb730b233650b757a������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032102�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������€À�������¨����f��’���>€�ù���è�������������?p�����������������DE���������������ï���ÿÿþö���ÿ���À�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0a062e7146194e5149c24338b968ee5bbaafd40d������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������f@�����������������������w������*�ö����� ����������������������ù�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b0ed38d0ad51a990cf2b16c727bca9f385046e1������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032063�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������>��������+����˜ÿÿ�����������üÿ����Ú������� ����������������>€����è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b2cfbcda117da0fb38239e0bbd69149bc4be902������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������PÀ�������è������������>€��%��è�������‰�ñÿ������� ��������Ö(�����B������������������øÿ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b4534d5ccbde3ccb4ffedf6c35f1c151371b81e������������������������������������������������������������0000664�0000000�0000000�00000000052�15100345067�0032360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À������������B���%>�¹��ù����ÿÿÿÿþ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0b88c467e94529331ef6b9672a55c0917048ac36������������������������������������������������������������0000664�0000000�0000000�00000000037�15100345067�0031462�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À����Z����������è��������A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0bb1287fc41b93ec186a6cd0a4e2abbe5ac25d20������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0032262�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������Hÿÿÿÿÿÿÿ@5²]­I��´[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0bdbb69df444c03dffdf45540b123857e8d52c41������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032073�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������¿����A��������7����������A��������e��� ������?���A����������,��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0cf821743f73799451e8bd59b4493a2af6af993e������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������������]���A������������������A��������������������?���A����������åäääää;äää������@��������� ��������@���������øÚ��������$���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0dab00d8d9d07f05544561f2184043891ac024c1������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083333333¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨2���_���¨¨¨¨¨¨¨ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�WWWWW`¨¨¨¨¨¨ÿÿÿÿÿÿÿ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¥¨¨¨�@��è���40ÿ+ÿÿÿÿÿÿÿÿÿÿ��@��������@���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¨¨166;3ÈÌÌÌ33333g��� �����B�����?����������A���������������������������������������������ˆ������������������������������������ ÿÿþ����B�������������������������������������������������������������0e229390a2419e54659c91fac8fda3776c8d3597������������������������������������������������������������0000664�0000000�0000000�00000000354�15100345067�0031633�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���Y��ÿÿÿÿÿÿÿÿÿÿÿÿÿ�����öÿÿÿÿÿ����������?���A��������������������������A���������������A����������ÿÿÿý�������A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0e5a473aa26bb4611426ff7c887793ab5bb11b00������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031716�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������>���������������@������������������������ �������B���������B���T��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0ecd6dd291cd9f1ff004dbf59deeaae538be0d5e������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������� �������������øÿ�����������������$����������������������A����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0ed43cdbd0d48f987df9e39916fe6d7dca351372������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*������� ��������Ö �����B�����������úÿù���"�������������������UUUUUUUU����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������0f4095e80f0972faa28e52867819e9ad4def29cf������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032052�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������ù@�������������]��������������������������@À�������è�����øö����>€��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1013fec78493721af7513209cc4208d26ec828f2������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031516�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�Z����������÷ÿÅÿÿÿ~ÿÿû�ú��è��� �����Ç�������������������.ÿ¿ÿÿ��Ú�� �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������103541e080d45c3543c343127acae3b09e9f7947������������������������������������������������������������0000664�0000000�0000000�00000000244�15100345067�0031510�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A������������������ÿÿÿ���������ÿ�ÿÿ�ÿ�����?���A���������� �������±?���A��������������� ���ÿÿÿÿÿÿÿÿ��ÿÿø+�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������103e54b97fda4fb0ccdbb6eefb570786f8b06c3d������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032401�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������ï����������ÿ������� à�������A�������������������?���A������������ðÿÿÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1070cb122d3b0f16e90476d2756732c5faef9180������������������������������������������������������������0000664�0000000�0000000�00000000654�15100345067�0031574�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���)33HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))TT�������T���������������Ç����A����üÿÿÿ7�����ÿÿ�J�A��������e��� ������������…���������������������������Ò��èèèèñ��������� ����-�������A������TT¬«ÔªTT������TTT����|��������������…������ÿÿÿ�������÷…�������������������������������������������������������������������������������������������������������10cbc61c2d50941b8ee84950485330b51020b8ca������������������������������������������������������������0000664�0000000�0000000�00000000354�15100345067�0031553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����&�����>€�������A�����������������A������]���A����������-�����è����@�������>€��ý��è¾����ñ���ÿ������� ��X ��������A������������������A��������������������� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������112faf041b40f005bf544dfad5f108aebfe9932c������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A�������������������J��������������À������?���A��������������>€����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������113bd1949f408fed9ee1bf839de2e7f7a93c841f������������������������������������������������������������0000664�0000000�0000000�00000001434�15100345067�0032214�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���T332HHHHHHuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuH÷ÿÿÿÿÿ@)))))))))))))))))))))))TTT���������������Ç���A��������/7�����������Ò��������������������Ò��� ����-������þA���ÿÿÿÿ������TT¬«ÔªTTTTT��|��������…�������������ÿÿf������A������������������������������� ����-�������A������TT¬«ÔªTTTTT��|�����������������…�������������ÿÿf��������������������…������������������������������]���������������������������������������z����������������x�������������¿��������¿�������������x�������������¿��������¿����A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������114fd66ac1f1853ed91e1cf08abb64b9cf24ba24������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A�������������������?���A�����������A����������������A��������UUUUUUUU�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������125897cf81e066dcf7a848a33d66e32c65aeb5ad������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))!)))TTT���������������Ç����A��������4����������A��������e��� ������������…���������������������������Ò��x� ����-�������A�����TT¬«ÔªTTTTT��|�����������������…�������������ÿÿf�����������@�������…�������ÿÿf�������������…����������������� �����ÿ�������þÿÿÿÿÿ���ÿÿÿÿ�������������A����������������������������������125b7489711c008100163278833976214efd3c06������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0031133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������ï����������ÿ������� à�������A������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿà�������ÿÿÿÿÿÿÿÿÿÿÿÿ�������?���A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������129c9ac9ab87801820904a3b64bd6754e7de31cf������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031743�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������ù@��������������@���������������������������������5�������������ú� � �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������12da17d3510e43fa87404a6cc4e89590b7ab7b6f������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0032014�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������ï����������ÿ������� à�������A������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÑû�����ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������?���A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������12f2a8f93e7fdd944afbee2fbd14575db669d350������������������������������������������������������������0000664�0000000�0000000�00000000264�15100345067�0032261�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A��� (44444444444444444444444444444444SSSSSS���A����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1326a4ac09a56678f346f2b1d6370f73b4a6391d������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031575�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������¿����A��������5����������A��������e��� ������?���A������������öÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������13fbb8bb9ace2fee070b0a57cc23297e3929a2e3������������������������������������������������������������0000664�0000000�0000000�00000000054�15100345067�0032227�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����€������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������14f5a764478056056709a1adf56bf1c4f844be46������������������������������������������������������������0000664�0000000�0000000�00000000072�15100345067�0031611�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8������������������������������������������������������������������������������������������������������������@���������������������øÿ�����������������å:B������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������14fa52c7a0e0f2dac186cc477b8590bd7ed5d5de������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032321�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@��������������������A�������������������������� �������B�������������� �������������������������A��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������150d861d63105edb32e1c8b9962228c6f0471bfc������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0031653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/������������€������"������������������� ������B���������������&��������9F�ÿ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������156ef15ae5a6999bdd7672a6659f1733e74fd268������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À��]���è������������>€��ý��è��������ñÿ��ð����� ��������[����P������������A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������158c9040ac3b2284eddb47727edb1ad8e64aaee2������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032230�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D„ÿ�������ƒ���¤��������1����� ������÷���������gÿ�����������������?p��������������DE�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������15d9f065256954141540c7973b69945361a1779d������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0031170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?’ÇaÎ0³ûý›��a{�0áà5���™���������ÿ��0H����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<������������(ã���D���������35���������35��������H �����4 5"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������161f9d06c9fbad0fdcd36f26d39872902081bd7c������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032111�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@Z�������������������A�������������������������� �������B������������L� �������������?���������rrrrrerr����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1632c0af768ebd94edd01ed87e4e6a22d38b9443������������������������������������������������������������0000664�0000000�0000000�00000001024�15100345067�0032104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è��������5���>��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ1 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 4ƒM ³ ƒ�����ÀH���D��������DE������@À��������������������â>-�������))))))))))))))))[)))TTT���������������¿����A��������7����������A��������e��� ������@���…����@��������6����������������������������ù��������������6��������������6���7777777�����������üÿÿÿÿÀ�������¨����f=������>€�ù���è�������������?p����������E���������������ï������ö���444444444444444444444<4������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������16e7bd9816834e5b609f45262f76eab1b6ec40b9������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031755�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������¿����A��������0����������A��������e��� ������?��¿�������������1 ����+������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������17a72a1d905026efdf6c6323d9f006002ab85980������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0031563�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A������������������A��������������������?���5���77979139(44444H44444444-------------------@---------����úÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������17a9a0cda279f524a28f5f30e851116e072418d4������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031572�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@�����������������������������*������� ����������������������ù�:��Ó������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������180e4be371f1056fc2144de0c0bf19805e4d608d������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0031724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������� �������������øÿ����������������¤������� �������B������������� ��ÿÿÿÿ���?��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������189dcbb43b973255710dde7497763ea8a046ac16������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031672�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������� ����>€��ý��è��������ñÿ������� �������������P�������������� ��;���B�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1910a16a432c3dcc21d2646244678b93756aa1a0������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������\�¿����A��������6����������A��������e��� ������?���A����ÿÿÿ�������l����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������19167267fdc1593d4be0c4cb3b601932c3f3adfc������������������������������������������������������������0000664�0000000�0000000�00000000324�15100345067�0032067�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35������������������������������������ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1acda981777221e8e6eaea2c496c7f876519d564������������������������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0031772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è����‰‰‰žžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžbd–žžžžžžžžžž�ÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿïïÿÿÿÿÿÿÿÿÿÿÿ����…���������������������������� ÿ��A��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1aff404a6311174ae5eccd28a1aa2ad2d738e866������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032143�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���024HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)())))),)))))))))))))))))))))©)))))))))))))))))))))))))))))))HHHHH@�����A����A�� Ö�����?8�������������ù��:�����ÿÿè�������6����������������������������øÿ�����������������������������Ö�����?8�������������ù��:������������6����������������������������øÿ���������������������������������������[��������������������� /������� ����������������������������1b0af5886bcea028cd013ace38242c2a09614ec0������������������������������������������������������������0000664�0000000�0000000�00000000304�15100345067�0032040�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²$D’IÈz1 ‚(‚ ,�@À�������è������������>€��ý��è��������ñÿ������� �������������P������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1b211d33180b5e5cda190ecd00168bb4948f4ea8������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@��������1����������������������*������� �������� Ö�����I:�������������ù��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1b7bd0d9995cd6c889dfa823565c6d490ec5be8e������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032217�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ÷��������ö������������� �������B�������������A���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1c66f09df9136cbf6cd9c0e9c85f4fe1e12700d1������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032172�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A����������� ������A��������������������?������@175777777780�-444444444����@�������ÿ��A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1cb6ea9ed7ae98362e6fa46cbd0bb0e977fb24db������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032473�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���024HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)())))),)))))))))))))))))))))©)))))))))))))))))))))))))))))))HHHHH@������A����A����������øÿ���ÿ�@��������3�����2����������������*������� �������� Ö�����?8���������:������������6����������������������������øÿ�����������������������������������������[������������������� /������� ����������������������������1cd4b5622701839c902ccc031af388cf995f863b������������������������������������������������������������0000664�0000000�0000000�00000000534�15100345067�0031671�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�������������������������������������������������������������������������������������������������������������ùÿ�ÿþ���A������������������A������������������ �@À����]�è������������>€��ý��è��������ñÿ������� �������������P������(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ�@�����������������������øÿ����������ÀH������D�����D�@���������>��������+����˜ÿÿ�����������üÿ����Ú������� �@����������@������������ÿÿÿÿÿ�è�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1d172fbc7ae373610545d1436e0a17dcccc5e055������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������À~@������è��������O��>€�������A����������������������è���083HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))))))))©))))))))))))))))))))))))())))))HHHHH@������A����A��A��������������� ����������t�����ÿ÷� à�������A������������������ÿÿÿÿ������������.ÿÿ��x�/������������/è��������������������������������������������������������1e809f15bc387deff02d07edd0b9b3011a172d3d������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������@������������������������������������� �������B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1ebe7bc218890b4a5419154c4f8042d35c760ccb������������������������������������������������������������0000664�0000000�0000000�00000000764�15100345067�0031737�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A�������\��������������è���166HHHOHHHÿ/))))))ÿÿÿÿÿÿÿ@))))))+)))))))))©))))))TTT��������������)����A��������7�1��������A��������e��� ������������…���������������������������Í!� ����…������������������Ê�������ÿÿ½����A������������������A������Ê�������ÿÿ½����A������������������A�������������������������Ê�������ÿÿ½����A������������������������������������1ec71769042da0bfbad6967d3a9af3d5637966bd������������������������������������������������������������0000664�0000000�0000000�00000000042�15100345067�0032110�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@=������õ�����:+��������€�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1f09f12d930daae8e5fd34e11e7b2303e1705b2e������������������������������������������������������������0000664�0000000�0000000�00000000764�15100345067�0032066�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A�������\��������������è���166HHHOHHHÿ/))))))ÿÿÿÿÿÿÿ@)))))v+)))))))))©))))))TTT���������������¿����A��������7���������A��������e���Í!� ����…������������������Ê�������ÿÿ½����A������������������A������Ê�������ÿÿ½����A������������������A�������������������������Ê�������ÿÿ½����A������A�������������������������Ê�������ÿÿ½����A�����������������������������������1f3237efa553f6f82174223a1c5df78475ef25a0������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031665�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������‡���¤��������ÿÿÿ���>�������è�������gÿ������������������&��������������B������@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1f6810f6f160b2e7d5f27822be00fccda2c0d9ce������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032224�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ������������������������� �������B������������� ��� ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1fadee5ce81d5a4ede3b8d2d508eada6aa3e5fdc������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0032750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����0 5²]­I��´[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������20149c9075b835532b9903e2d838432de7c4c82b������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0031450�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/�������������!�����"������������������� ������é����������������������2{ ���@��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������207f681dda06e17d6fb16b89274720956e5315b8������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€€������ð���ÿÿÿô ��� ������������������������������������� ��� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������208964be3ec654f18b77217d9d5dc908ef8eff6e������������������������������������������������������������0000664�0000000�0000000�00000000604�15100345067�0032144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������Ò��������è�����������>€�������A����������������������è���$)ÿÿffffffff˜ffffffffffff�������,������������������������ffffnfff¡™fffffffffffš™™™fffffffÿÿÿÿÿ@)õ)))))A��)))))))))))))T)T)T))2���������E�������¿����A����� 7���������7�„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„„���ÿ@)õ)))))A��)))))))))))))T)T)T))�����������������?���A������ ����A����~���=�������������������������������������������������������������������������������������������������������������������������������������20bec61757d2a6e9ccf5674424f23d8dd4c59821������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���087HHHHHHH7777777777777777777777777777777777777777777777777777777������������A������������������A��������������������?��A��� 7·791ÿ39(44444�44444444ÿ44444444c4à�����������������������7777777777777777777777777777777777HH))))))ÿÿÿÿÿÿ))))))))))))qqqqqqq�������������ø������������������� ���������� �����������������������������������!���ÿø���������Ÿ���x�������������¿��������&¿����A�����������������������������������������213bd18eb8b9792f5ba8d6453e7b0b74f0d2a12c������������������������������������������������������������0000664�0000000�0000000�00000000037�15100345067�0032073�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������À���������������������������.�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������217bf330784989cf4c3e21bcbe0d1adeed7dec2e������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083HHHHHfffffffffffffffffff���@�������������������fffffffffffÿÿÿÿÿ@)õ)))))A��))))))))))TT)))))T))���������������¿����A��������7����������A��������e��� �����������…�������������������ÿ��c�����ý� ����-����������A���������TTTT+TTTTTT����������������ÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ�������������A������������ÿÿÿ����ï����TTTT�=�������������������������������������224b4677ce8e3065a8be0e661b5d3be49602680e������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������� ���������������������A����������������� �������� �������B�����������������@�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������224d47f68da20713449bf600b84a3d750d495ed6������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0031573�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������,������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������229389eeb6f917a0db71fcadbc97cf3432357ba6������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ����������������������� ������øB������������� ����ù����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2397935ec2daeeea90cc7530afb1bfa490d21607������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/������������ÿ çÿÿ���"������������������� �������B������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������239d654fb97da7931b992a93b3c51be8912cdc0d������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/������������ÿ&çÿÿ���"������������������� �������B������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������23a46cbb1893e9284d06e72558317d95ecee8e74������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0031706�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A������������������A��������������������?���5���7638860�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������23c3074517a019bd7edd8d8b71fb159980a10ec0������������������������������������������������������������0000664�0000000�0000000�00000001174�15100345067�0031733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À��]���è������������>€��ý��è��������ñÿ������� �������������P�������É ½Š,²I’È$DÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ����ÀH���D��������DE�����������1���üÿÿÿÿÿÿ%�����>€�ý ��è���693HHHOHHHHH))))))ÿÿÿÿÿÿ@)))))Ô)))))))��è���µªªªªªªªªªªªªªªªªªªªªª�@À�"��B��������������è������û����>€�������A��������������������è���µªªªªªªªªªªªªE�ªªª™™™����A���4.44444)))))������B������������� ������������B���A����.���A��������e��� ������������…��������������������������������������������Ê� �����ÿÿ½����A�����������������������ÿ15������������A(‚ ,¢‚,�¿����ñ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������24c3c3a4c50155712005e5fa934a99a3ec803318������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������������:��� ��>€�������¸����������E���ÑÑÑ�������E���ÑÑÑÑÑ/ÑÑÑÑÑÑÑ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������24f67fc225eeebfcd06f121effe46d26251e785e������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032255�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�������������������ÿÿÿ������*��@���� ��������Ö������B�����������úÿù����"������������������UY����B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������26338cbc8a2c58872d0df57b1231785ba53c5128������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������ð���A������������������A��������������������?���A���796844ÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������276129fc7c40928aa2743aff77c15bfac126c00d������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������ƒ@��-��������������������������*����g�� ��������Ö �����B�����������úÿù���"�������������������UUUUUUUÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������27fff07708997c5e6e07a0f83406683a7d36daa9������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031710�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A������������������������@���&�UU`UUU UUU��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2839e34ab20fb0105de4ebec1a25a807ba7642c9������������������������������������������������������������0000664�0000000�0000000�00000002022�15100345067�0032050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À?ÿÿÿ�������è�����������>€�������A������������R���������������ÿÿÿ����������ô��@������aaaa����������������������������������������������������������������aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaiaaaaaaaaaaaaa������fB�������w�è���333HHHHHHHHH))))))ÿÿÿÿÿÿÿ@))))))))©))))))))))))))))))))))))))))))HHHHHHHHHHHHHHîHHHHHHHHHHHHHHTTTTTTTTT+TTTTTT��������ö?D€��������ð���������ÿÿÿ��@�� ����-�������A������TTTT+TTTTTT��0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿzüóÿüóÿÿÿã 7���������������������ÿÿÿ���������x������/����������� ���������������������ð������� ���@���?›ÇaÎ0³ûý›{a��0áà0���™������������ÿ��0������������…����������?��A��� 5358278(4444444444444���ñÿ���@À�������è�����������>€�������A������������RB���������è���3HH33HHHHHHH))))))ÿÿÿÿÿÿÿ@))))))))))))))))ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D��������ü^ÿÿÿQN��ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�¨��������H ))��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������28ac5313c590ed2b28e1ed0fc22f2bd1eab0df51������������������������������������������������������������0000664�0000000�0000000�00000002404�15100345067�0032265�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À��]���è������������>€��ý��è��������ñÿ������� �������������P�������É ½Š,²I’È$DÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ����ÀH���D��������DE���������������üÿÿÿÿÿÿ%�����������{a���‡0áàZ��³v¤P²&Ô«Šæ‹` ��������ÿÿÿÿÿÿÿŠæ‹` ���`���������������è���µªªªªªªªªªªªªªªª™™™™™™™™™™™™™��X SSÿ�ªªªª®ªªªªªªªªªªªªªªªµµÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����������������������ˆ���2� ��������-���ùþÿÿ�A������³TTT+TTTTTT�������������5���ÿÿÿ@��� ��������º�����e;�� ���������������…�������@����������Ê�����ÿ�ªªªª®ªªªªªªªªªªªªªªªµµÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������������������������������������������������������������������ˆ���2� ��������-�������A������TTTT+TTTTTT�������������5���ÿÿÿ@��� ��������º�����e;�� ���������������…����?��@����������Ê�������ÿÿ½���A���������������������Í!�����@A������������…��������������!���������������������������A������������������������������������������Ê�������ÿÿ½����A��������������������ññññññññññññññññññññññññññññññññññññññññññññññ�@�����������������������������*���ññññññññññ���� ����ñññ�������������������ù��������������@���&�����ÿÿÿÿÿÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������28e31c10ef08fdecf629dd265116e0f833cd57cd������������������������������������������������������������0000664�0000000�0000000�00000000042�15100345067�0032157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������?����2�������������? ÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������29b15bb9cb49218df433c4fe27794615c3a4451b������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031661�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������������������d��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2a221a24ad464e8da7ee51105400f1670b4320a1������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������[������� ?��@����� ������³ûý›{a�+�0áà0���™�����0��������@À�������¨����f������>€��ù�����0������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2a86bc754e5703e9d6101f64eb5e06ccbd261952������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0031737�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8����������(ã���D���������35��������H �����4 5²]­I��´[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµKþjI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2ad4a333d74699bc03523cba5cb3c108a2bc9527������������������������������������������������������������0000664�0000000�0000000�00000000244�15100345067�0031774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A������������������ÿÿÿ���������ÿ�ÿÿ�ÿ�����?���A���������� �������±?���A������������������ÿÿÿÿÿÿÿÿ��ÿÿø+�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2bf57e68f7436d449f0486a2c1ae3a281458bdcd������������������������������������������������������������0000664�0000000�0000000�00000000047�15100345067�0032033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A����������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2c0d33ffce3a3e585c845cf7c6aebd5f4917fddc������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032472�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������¿����A��������6����������A��������e��� ������?���A������������ö����,��±ÿÿÿ�ÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2d0ff967eccc17e5d165712c758681ef3fe51caf������������������������������������������������������������0000664�0000000�0000000�00000000764�15100345067�0032210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���166HHHHHHHHH))))))ÿÿÿÿÿÿÿ@))))))))))��;����)))))))))))))TTT���������������¿����A��������7����������A��.�'���e��� �����������…���������������������������Ò�������������������������������������������>€�������A�������������������HHHH))))))ÿÿÿÿÿÿÿ@))))))))))))))))))) ))))TTT��������¿7����������������ö�������������������������������2d3db2cf9bcfec159f6bccf801d74a1ce610013f������������������������������������������������������������0000664�0000000�0000000�00000000404�15100345067�0032360�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@������������������#�@����������!��������������� �������B������������� ������������à���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥¥¥¥ÿÿÿÿÿÿÿÿÿÿïÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2e29d5f8ccf89cf55a1876623bbbc0a2a0e76032������������������������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0032100�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À������è�����������>€�������A����������������������è���))))))))))H@HHHHHOOOOOOOOOOOOOOOOOOOOOOŠˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ�@���������� �������������øÿ��������� ��ÿÿÿÿ�������))?��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2e485e5fe51b9824721a41a67dfc1fd9ab8eb3f1������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032165�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������������������ÿÿ� ��������ö����������������������������A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2e64ef301925f827368cf80e67a858f9c1906b44������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031553�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@ ������������������@�������������������������� ���~���B������������� ������������&����ü^ÿÿÿ±±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������2eb732cc04c8a4259763abb8c02b633c484aa08b������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?������544444444445�-44444444444444%44444444�����í�������1�ÿ�����A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3000a8aa02ef08fd7105151982b709ca87702b2a������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������>�������������øÿ������������������������� �������B���������B������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������30b30fb9ab1f1031139fc72d478b5cf6fde75f70������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032101�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À������è�����������>€�������A�������\��������������è���028HHHOHHHHH))))))ÿÿÿÿÿÿÿ@)×ÖÖÖÖÔÖØ)))))))©))))))TTT��������ÿÿÿ���¿����A��������7���������A��������e���������������Í�����…�������@����������Ê�������ÿÿ½���A������������������A����������������������������5������…�������@����������Ê�������ÿÿ½���A������������������A������������������������Ê�������ÿÿ½����A����������O�������������������������������������������������30cb23ea8ce282a984424ba74cf9e692a0ea95c2������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A������������������A��������������������?���5��������������úÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������322398e8d8eec282d54ecf8270285109012daafa������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*���������������Ö������B�����������úÿù����"�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3488d3837745952ffee80820a15f98f3f39bacbd������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083HHHHHHHXH))))))ÿÿÿÿÿÿÿ@))))))))�������)))))))))))))©)))))))))))))))))))))�����������������������������è���510HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))))))))©))))!))))))))))))[))))��������������������…�������������������������������íëÿÿÿÿÿÿÿÿÿ��������������������������*������� ��������Ö������B������"���������������������è�����������������0��A:����x������� /����������� ����������������������������35551262d560ddd52f1b8ba9039b0ac05932e7f3������������������������������������������������������������0000664�0000000�0000000�00000000654�15100345067�0031653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���)25HHHTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT��ù…���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ������������������������Ò��²²²²²²²²²²²²²²²²²²�����������…��%ÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕÕ��ííííííííííííííííííííííí2íííííííííííÿÿÿ��������A�����������������������������������������������������������������������������������������������3579bff2e768d34cc21071a22ca286c84bdeb0be������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������� @�������2�������€��������������*������� �������� ö�����?1�������������ù��������������6�������������*������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������35cdca75d22e73fa72051421f170698c4c526838������������������������������������������������������������0000664�0000000�0000000�00000000474�15100345067�0031527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@������������������#�@����������!��������������� �������B������������� ������������à���ÿÿÿÿÿÿÿÿÿÿÿÿ¥ÿÿÿÿÿ¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥������������������ùÿ ��������������� �������B������������� ����������ÿÿ��������à���ÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������360ce4c914f52af71a7f1f165b579b263aef7224������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0031741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A��� 7679138(�������x4444444444444444�4444444´44444.44444llllllllllllllll444444´44��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3612694abd743a7e55e65aa65263520ad36fab1d������������������������������������������������������������0000664�0000000�0000000�00000001524�15100345067�0031730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���[333HHHHHHH••••••••••••••••••••••••••••••••••••••••••••ííííííííííííííííííííííííííííííííííííííííííííííííííííííííííííííííííí••••••••••••••••••••••••‘••••hj••••••••••••••��������������A������������������A������������������ÿÿÿ����������������������������������������.�����������������������������������������������������������������������������������������������������.��������������������������������~€�������A���������������������������������������������������������������������������������ï���������A��������������������������������������������������~€�������A�����������������������������������������������“����@��������@������������������������������������� �������B��������������€�������A���:����x��������� /�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3661b2541a41109436af57eed8cd81f2b077dc64������������������������������������������������������������0000664�0000000�0000000�00000000424�15100345067�0031655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���34HHHHHHHH‰‰‰‰‰‰‰‰¥‰‰‰‰‰žžžžžžžžžžžžžžžžš—žžž���@ýÿÿÿÿÿÿÿ------------------------------������������������������A����������������������è���34HHHHHÿÿ��������������…�������������������������…����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������36a015ecabd510fc11470a8ee201f74c98a752cb������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A������������/ÿÿu������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������378b0717ae8bca467ed4ee58212ca50ceae5ec7d������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A������������������A��������������������?���5���7979139(44444H44444444-------------------@----���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������384e73c939df5029d4a47e7446f57a279e0f4e6d������������������������������������������������������������0000664�0000000�0000000�00000000474�15100345067�0031726�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@�����������������#�@����������!��������������� �������B������������� ������������à���ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥��������������� �������B���'���������!��������������� �����������������������ÿÿÿÿÿÿÿÿÿÿÿÿ¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥�������ÿÿÿÿÿÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3890191defea00490c16ad251b95f9e07b4c74c9������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031742�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A����������ªUU�UUU����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������38a0feff4559737aeed5f72ee302a3a0ed8629bb������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0032245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@��������������������@�������������������������� �������B������������� �‘�����������B���øüÿ'ÿÿ±±±±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������38cc6d4e011e8685c88b2f60ae85df9b6edf06d4������������������������������������������������������������0000664�0000000�0000000�00000000374�15100345067�0032210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������X ��������A������������������A��������������������?���A���4444444444444444ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ44444444444444444444444444444¾444��������444SSSSSSSSS���A���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������39e5a474f4810a8abd8b966bdf6a407e20501b25������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0031733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 6ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ���8�ã�(ã���D���������35��������H �����4 5²]Sí¶ÿÿüK£!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿHV¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������39fbdcdb86bc1205438c1a8327ec6668ff0bc009������������������������������������������������������������0000664�0000000�0000000�00000000204�15100345067�0032074�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@T€��������ð������� ���@���?›ÇaÎ0³ûý�›�{a�0áà0���™���������þÿ��0����� ��������@����������.�������������ÿn6��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3a56ebf0102f26bc48241309d90eedb53bc5599b������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032007�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?������177777777780�-44444444444444%44444444�����@���������1�ÿ�����A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3bfafbcc633c3b157ca48d686020d806a9238d9a������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���ÛäðªUUUÿÿÛªUUUUYUUUUU���ÿ�������������ú�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3c2a06759b1f89f8e8bf0d01162558169ccfcdb0������������������������������������������������������������0000664�0000000�0000000�00000000204�15100345067�0032022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A�����������������A��������������������?���5���7979193(4444H44444444----------------------������úÿ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3c4845d3eab256e1cd051b0e02c954e9feb5d689������������������������������������������������������������0000664�0000000�0000000�00000000554�15100345067�0032107�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���!33HHHHHHHH‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰@�������‰‰‰žžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžžž������‰‰‰‰‰‰‰‰���1A��������7����������A������� ����Vÿÿÿ��������������…��������)����������������� ÿÿý������A���������������������������������������������������������������������������������������������������������������������������������������������������������������3dd30028e1743600a71c84026e90af3f7bb3181e������������������������������������������������������������0000664�0000000�0000000�00000002264�15100345067�0031561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�"�����è�����������>€�������A����������������������è���„ªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªªµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ´µµµµµµµµµpµµµµµµµµµµµµµµµµµµµµµµµµ½µµµµµ33ÿÿÿ�������������������…������))))ÿÿÿÿÿÿ)ÿ@)))))))))))))))))))))))TTT���������������¿����ŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸ/ŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸ�������Ÿ���ÿÿÿ���A��������e��� ����������������HHH))))))ÿÿÿÿÿÿ)ÿ@)))))))))))))))))))))))TTT����������@D€�������������¿����ŸŸŸŸŸ�@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0����������� ���ÿÿÿÿÿÿÿÁÿ0ÿüÿ��å��� ���@���?›ÇaÎ0³ûý›{a��0áà0���™���ÿÿÿÿÿÿÁîÿÿÿúþÿûÿÿÿ ���@�����ÿ�0���­I�´����������������Ò������������������������������������������������ŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸ�@������@�����������ŸŸ/ŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸ��������������ŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸŸ�������Ÿ���ßÿÿÿ���A��������e��� ��������������������������������� �����è���µµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµµ��µµµµµµ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������3e1105e64284eed8dc2bccbe18ec3e6de2a082a0������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032277�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������@������������������������������������� �������B���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������42805756addc26eff319d88bf58e37887339eb41������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031717�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������>�������������øÿ������������������������������������B��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4463475e7855ef5ca2229888df0624efd85493c8������������������������������������������������������������0000664�0000000�0000000�00000000244�15100345067�0031567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@�������������������@������������������������� �������B������������� ������������B���Aüÿÿÿÿÿ±±ÿ±±ÿÿÿÿÿÿÿÿ����B���������������0ø��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������44dadbb9d63786197f95408954423a2490e54a72������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������4�������������������������*���� ������� Ö����B�ó������������üÿÿý�(�����3����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������45e5d985b27fb2210ba470b892756eaf053194e4������������������������������������������������������������0000664�0000000�0000000�00000000460�15100345067�0031605�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I’È$DÒ1 ‚(‚ ,¢‚,ƒ‚H ‹ ‚Ë$’Ê 5ƒM ³ ƒ����ÀH���D��������DE��������C����2�üÿÿÿ0ÿÿ%�����>€��ýûý›{a��� 0áà0���™�è�����ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿñ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������46945e0bf54f1dc350c0d9ec9b670cf687445be0������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������.�������������ÿn������������������������� �������B���������B�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4780df7420a24ebae8d9bcacf6c62c27e0c2e811������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A��������ù���������A�����ù��������������?���A���(nÍÿ‡8�����������������������������������������������ÿÿÿÿÿÿÿ'������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������47f3c798199bb53546b443fba5dc925d08d37718������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0031626�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������Y������A������������������A��������������������?���5���319997744(H44444444444-------------------@---------������úÿ�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4957a6bc77cc14caae8682e4499cafca63ac12b4������������������������������������������������������������0000664�0000000�0000000�00000001005�15100345067�0032237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ1 ‚(‚,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ�����Àh���D��������DE������@À������è�����������â>€�������'1�A����������������������è���ÍÌÌHHHHHHHHH44444444444ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ�¿��è��������������������P�������à ½Š,²I$’ÈDÒ1 ‚(‚,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ���������â>€�������'0�A��������������ÿÿ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������498988babdc605e5d03ed9448af24a714ff69e72������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032055�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@\€��������ƒ����¤�������*����� ������÷���������gÿ���������������������� �������B���������B��€���@����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4a5a4312137e693b8122b4426d54fc6444cefb4d������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031646�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A�������������������A��������������������?���A������� �����A��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4a81750c78f1acc88612777149b7d47b27d1d58d������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ����������������������� ������øB������������� ����ù����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4bc7279fedba6ac6deb9be39476e43dce7d69525������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032350�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A�������������������A��������������������?���A������� ���U�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4be8eb811a92f7221820a72185b76e32ab95edf4������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031737�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���������=���ÿÿÍ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4bea5a628cf732e42825e3bcfb0d0f63819c37a8������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032100�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������@������������������������������������� ÿÿþ����B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4ca579f0ff4d06f56eebb6b94c1303de1ea289b4������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032246�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������ÿÿâ��������������������������*���������������Ö �����B�����������úÿù���"�������������������Yµªªªªªª����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4ca93515d0cb2e30ac9a09bc6917cf2f4041e309������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@������������������������������������ ���������� �������B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4dbe572a6b29c977ba4f132bf27330f5bce8bbb4������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������;���������������������������� ���������� �������,����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4e452a93754eec25673cc41def71f43e12d6ad44������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ������������������������� �������B�����������������º�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4edbe8bce1dd60b4447731e0183305889971ce1c������������������������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0031745�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ2 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM Mì ƒ�����ÀH���D��������DE������À�������������:������>�����������*:�þÿÿ����@������$������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4ef3a46a40596d12420c9acc7827a7956b93eff2������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031751�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?������/544442617942�-44444444444444%44444444�����í�������1�ÿ�����A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4f039fecd3612031008b5ac1ec016a9db9a0afe2������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032124�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������X ��������A������������������A��������;�����������?���A���(111111111Ê111104�44����444@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4f1ee2f2a2b9499943d866a11c5eb73dbb5578a6������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032036�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������������������øÿ� ��������ö������������� �������B�������������A���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������4fcb4525eae80e58e4c0dafcad5dbf9bd6ed8800������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032541�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������ï����������ÿ������� à�������A�������������������?���A����������è���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������514e88c8fedf058601f8c1a3857405a72bafd346������������������������������������������������������������0000664�0000000�0000000�00000000077�15100345067�0031756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������������������������A�������A��������B��������������ü�'��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������51628c735c1dfa273dd79264ffdff1de023ded3b������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032251�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))!)))TTT���������������Ç����A��������4�����������������A��������e���������������…���������i�����������������Ò��x� ����-�������A�����TT¬«ÔªTTTTT��|�����������������…�������������ÿÿf�����������@�������…�������ÿÿf�����������ò�������…����������������� �����ÿ�������þÿÿÿÿÿ���ÿÿÿÿ������������A�����������������������������������5181e1d782cae994672eb604f0b88720d4171a6b������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A�������������������J������������6��������?���A��������������>€����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5593e1771829808b4c1c17a151f5807590c87060������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������¿����A��������6����������A��������e���� �����?���A������������öÿÿ/����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������56152748eafa8a23aca552d2c63aefd328ef9d1c������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032234�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������8�������������������������������������� �������B�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������583bd88280acbe57634a229531e50afea8977c5e������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0031760�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���22|222221,˜˜˜˜˜��ûÿ����ÔÔÔÔÔÔÔÔÔÔÔÔÔÔ��P�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5b989097db45b584bfdfd0ea0eeb6e484b04ffa4������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0032335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�������������������������������������������������������������������������������������������������������������ùÿ�ÿþ���A������������������A��������������������?��A���´·79134444ð4444����ö���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5b9f71ff1bb5eb987287e97e9223ad2ee384d043������������������������������������������������������������0000664�0000000�0000000�00000000335�15100345067�0032052�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€����r���ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������3!��������������������� �������� ������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5bcb10fcf0de7e1f1eea8b2a6c97b9f2efb38cfe������������������������������������������������������������0000664�0000000�0000000�00000000047�15100345067�0032704�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������@����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5bdb91298fe95bcd0fd59b077e9b03708352adc0������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���Ûä䪪ªª�$UUUUUUUUUUUUUUUUUUU������UUUUUUU��������ï����TTTT�=������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5bf5ba2025d12dff0f8cf646bc0a67e512781a78������������������������������������������������������������0000664�0000000�0000000�00000000264�15100345067�0032076�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�ÿÿ�J��è������������>€��ý��è��������ñÿ������� �������������P�������à �Š,²$D’IÈÒ1���� ���@���?›ÇaÎ5���ã{a���0áà0���™���ÿÿÿý��ÿ��0�����0�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5cbe78de4aa4595bfd13dfc8f9d88bc740bda660������������������������������������������������������������0000664�0000000�0000000�00000000074�15100345067�0032420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@���������� �������������� ��� �������������� ����� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5d53743f0f6877c631ba1b78a2546351ffd945a5������������������������������������������������������������0000664�0000000�0000000�00000000437�15100345067�0031620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������¿������A�������A�������A������$�¿����A�ÿÿÿÿÿÿÿÿÿÿÿ�����������HHHHHHHHHHHHHHHHHHHHHHHHHHHH�������������ÿ��ÿ��ÿ �@ù%�����ÿ0ã<8ÿ7ãÎ8ã����������(ã���D��¿����A������������HHHHHHHHHHHHHHHHHHHXHHHHHHHH�������������ÿ��ÿ��ÿ �@ù%�����ÿ0ã<8ÿ7ãÎ8ã����������(ã���D����+����ÿÿ�!���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������5ddb48bfb461a6f541ea5263c124fafc84228405������������������������������������������������������������0000664�0000000�0000000�00000000534�15100345067�0032012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è��� 85HHHHHHHHH)ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ����@��������A��I����]���A����������������è������������>€��ý��è�����ñ���ÿ������� �������?ÿÿÿ������P�������à ½Š,²I4’ÈDÒ1 ‚(‚ ,¢‚,ƒH ��������ÀH���D��������DE�������x������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������5fcca6becd914f5a66441e491bb460cc0d399798������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������¿����A�������5����������A��������e���-������?���A�������������@�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������61b0a7eb4b781e6e980620119029784028b0dd02������������������������������������������������������������0000664�0000000�0000000�00000000604�15100345067�0031426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���$333HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))TTT��������������Ç����A���������7��������������������������Ò�� ����-�������A������TT¬«ÔªTTTTT��|�����������������…������ÿÿÿ�€�����������������…����������������������¿������������¿A�������������������������������������������������������������������������������������������������������������������������������������638ee93f6f582a08b54e2d904b6e703e975fb779������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031731�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083HHHHHHHHH))))))ÿÿ÷ÿÿÿÿ@)))))))�@�����������}������������øÿ��������������ÿ��������� �ø���:������������������������))))) ))))))))))))))))©)))))))))))))))))))))óóóóóóóóóóóóóóóóóóóó�����������$����������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��@��������������*A��]���A�����������������A������������������@��� ��������@��������TTT+TTTT���ú���`��ø�����������A����� ����������������������������63ddefed7ec1d06bb8e65ef0446fd66247ad9e5f������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032423�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è����[������>€�������A��� ÿ����������û���������A������������A���������:������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������640783010f7d68e0dd208d742c0ae5dcc35bca18������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À��]���è������������>€��ý��è����!���ñÿ��ð������������������?H����������A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6409f517d99779cf628cec89e0ea781800ec1673������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031642�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������þ�����������A������������������ÿÿÿ���������ÿ�ÿÿ�ÿ�����?���A���������� �������±?���A������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6472b46069dcd29079a739cd9f4d043d77b9db2b������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0031771�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@Àÿÿÿ0���è�����������>€�������A����������������������è���083HHHHHHHH')ÿÿÿÿÿÿÿÿÿÿÿÿÿÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÿÿÿÿÿ��������@�������@ÿÿÿA������]���A����������������è����@�������è�����������>€�������A����������������������HH)ÿÿÿ�@�����������������������øÿ������������������������� �������B�������ÿÿÿÿÿÿÿp�������ÿÿÿÐÐÔÿÿÿÿÿ������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ���úÿù����"�������+����������������º�����������������������������������64e26698d0ae69059a828a29619dbb220834ce0b������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0031610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������ï����������ÿ������� à�������A������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������?���A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������64ec1601cf03b88a5c1032569dc861d156d706ec������������������������������������������������������������0000664�0000000�0000000�00000000574�15100345067�0031660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���#33333333333333333��������������������è���#33333333333333333333333333333� ����-���ÿÿ@))u))))))))))))����#33333333333333333333333333333� À������è��OOOO��"����������A����TTTTT+TTTT������������������@���������������������������� ��������������ø������ �ø���:B������������������������������������������������������������������������������������������������������������������������������������������������������������65440ab3f4518a75309ca81383e9f4e6a60bbd6c������������������������������������������������������������0000664�0000000�0000000�00000000344�15100345067�0031741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@�������������������@�������������������������� �������B������������� ������������B���Aüÿÿÿÿÿ±±±±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ00�ø����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������669710a353b5b72bcf14eb140b57b0a6be809e7b������������������������������������������������������������0000664�0000000�0000000�00000000244�15100345067�0032004�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A��� 7·79139(44444444444444ÿ44444444c4à������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������683ee9ae1a3ddbdbee2336af93e7f408f5cc42b5������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0032403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8������������������������������������������������������������������������������������������������������������&�������A������������������A��������������������?������272222222222�4444%44444444�����íø����úÿÿÿ1�ÿ�����A����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������688934845f22049cb14668832efa33d45013b6b9������������������������������������������������������������0000664�0000000�0000000�00000000002�15100345067�0031367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������68cdb6aea2466f9256dc371bdcd482b139d28d1c������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0032163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@��� ÇaÎ0³ûý›{a���0áà0���‘���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýó+ÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����4 5²]­I�� !"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������68f451a137e92f09cfd5eb88a04dbd0b8798bb92������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032124�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*������� ��������Ö������B�����������úÿù����"������������������Uâââââââ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������69bb7cec8b07da9cb2bd3d0aba9f55b0f41f65cc������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032527�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A�������������������?���A���(23333`3Í333333333.3333333����3333333333333333333�44�������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6b0165838e17a7309a523a909b6f83de6b46f51c������������������������������������������������������������0000664�0000000�0000000�00000000414�15100345067�0031610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³û�›{a���0áà0���¹���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����8 5²]­Iüÿ*[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[³v¤P²&Ô«Šæ‹` ý���`Á ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6b49f3fa96695a790faa6eb4f051e5cf2c471209������������������������������������������������������������0000664�0000000�0000000�00000000022�15100345067�0032027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ÿ�ÿ��������ï™™���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6b85b749998063c521ffdb3faf1823f20e85d5e7������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���ÛäUUUUÿÛUU�������UUUUUUU����;ú������ÿ���������ï����TTTT�=�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������6f924d014dc9bc839ea89f3b98217f262b27c231������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0031675�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������X ��������A������������������A��������������������?���A��� (555511111111104�44444444444444444444444444444�����444SSSSSSSSS���A���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������71c2d79e816ce7ffee8d3ac90eedb3159dea7fac������������������������������������������������������������0000664�0000000�0000000�00000000574�15100345067�0032571�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À]������è�����������>€�������A������������������$*����è���333HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))�@�����������������������øÿ��������������ÿ��������� �ø���:B������������������������)))))))))))))))1))))))©)))))))))))))))))))))))))0))))))©)))))))))))))))))))))������������������4������ÿ�@�����������������������������*������� ��������� ������������������������������������������������������������������������������������������������������������������������������������735de4ce401995f6a6e4c47039ac8940bdc1ec8b������������������������������������������������������������0000664�0000000�0000000�00000000304�15100345067�0032110�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������������¿����A��������5����������A��������a��� ����� ���a�� ��������������A��������e��� �����?���A��������?��ü�������A�������?���A�����?���?���A��������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������778c71afaf6c5a1d3b1c045788d668189adbf96e������������������������������������������������������������0000664�0000000�0000000�00000000374�15100345067�0032133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüó“üóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����4 5²Ý­I��´[!"“���,ÿ<ãÿ7ãÎã����¶õ‘+m«Ô&PŠæ‹` �����`Á ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������77a4c5e5039c7180b2217342711f214970bea74a������������������������������������������������������������0000664�0000000�0000000�00000000137�15100345067�0031426�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������+����¼����í���������������2��������Aë��ÿÿÿÿÿÿ����ÿÿ���������'�������ÿÿÿÿÙ@������ÿÿ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������781835ce31e3ba1b697c5a40b8447f6b7f7a0144������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031660�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A����������������������������������������?���A��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������78d4981a356b7e21562982b8cd64af8d7f9ff62b������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032001�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������������:������>€�������¸����Ã��������:�@À�������$������è����è����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������79f08f3117e3d9c49e1e12727b5bc72692a41bad������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A�����������ÿÿÿu������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7c5f32cd666fb03e67aa75a34b889236b40a0eb6������������������������������������������������������������0000664�0000000�0000000�00000000734�15100345067�0032024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è��� ��������>€�������A����������������������ª���/333HHHHHHHHH))333HHHHHHHHH))))))ÿÿÿÿÿÿÿ@))))))))))))�����öïÿÿÿÿÿÿ�Ò�ùè�����������…��%����ÿÿÿ�������������������…��’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’’“’’’’’’’’’’’’’’’’¸’’’’’’’’’’’’’’’’’’�����UU������������������������ÿÿÿÿÿÿ�Ò�ùè��������������������������������������������������������������������������������x��������������������������������������������������7c6d18a6fc69526d5c30f4cbd24725fea7423515������������������������������������������������������������0000664�0000000�0000000�00000000354�15100345067�0031750�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è���þÿÿÿ�����>€�������A����������������������è���33333333333;����W���ÿ�¿è�����������>€�������A�����������������������������ÿÿÿÿÿÿÿ@������¿����B��������z����44ö���_����ú�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7e6f7bfb1169a82fc31aa11c760b1b1699d7b3a4������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032070�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������/������������çøÿÿú���"������������������� �������B������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������7ee8badf61cd2a56bcd4c5fdafe9395eb733e22a������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032547�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A����7·(97914444444444444ÿ44�������ú�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������869028f499a7faea4cf993eb867ea9fd1c3f58e6������������������������������������������������������������0000664�0000000�0000000�00000000254�15100345067�0032237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A�����£������������A��������������������?���A��� º(445(4444444��44ö4A�4B��� �ó���������������������������������������������������������2����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������87330cfd941fe956757bce61baa636e6a6b7a0ad������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032165�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������øÿ�����������������������������������‚�ç���ÿß������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8887779003e7ccbdbc95ba305c34aa75fb255d69������������������������������������������������������������0000664�0000000�0000000�00000000032�15100345067�0032031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������.������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8bec4981ecd6533ecadf49b978e34e2cdea28e67������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������;���������������������������� ���������� �������B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������8c08c6739ba900dd00089e5eb7e15c43b5d76e91������������������������������������������������������������0000664�0000000�0000000�00000000667�15100345067�0031761�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A�������������������������*83HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))))))))©)))))))))))))))))))))��������������������…������������������������©������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��@�������A������]���A������������������A�������������A����������A����������åÄäää������@���������?p�������++++ +++++++;+U�������è������� �������������������������������������������������������������������������94972df24f18202ef83823f34daf4225cac60c13������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031657�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A�����€��������������?���A���&ä䪪VUUU������������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������95873ef906927ff752a0f48e4fbed36b15003e14������������������������������������������������������������0000664�0000000�0000000�00000000047�15100345067�0031702�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@������������������������@ÿÿÿÿ?��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9881ea067ad96598ca5de7dd0ddfb41a629f776e������������������������������������������������������������0000664�0000000�0000000�00000000764�15100345067�0032225�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€������A�������\��������������è���166HHHOHHHÿ/)))ÿÿÿÿÿÿÿÿÿÿ@)))))v+)))))))))©))))))T��A�������������������������Ê�������ÿÿ½���A���÷���������������A������Ê�������ÿÿ½����A������������������A�������������������������Ê�������ÿÿ½����A������A������������ �������������Ê�������ÿÿ½����A�����������A�������������������������Ê�������ÿÿ½����A������A������������ �������������Ê�������ÿÿ½����A������������������������������������9c479051463aa32bdf5fe7ff36258586ea5606d4������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0031702�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@��������?��������������������������������������� �������B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������9c5eba1b6a51edabf204e3c2c3e5358604f04c74������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032145�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À������è�����������>€�������A�������\��������������è���083HHHOHHHHH))))))ÿÿÿÿÿÿÿ@))))))+)))))))))©))))))TTT��������ÿÿÿ���¿����A��������7���������A�������e���HH@))))))+))))×Ó)))©))))))TTT��������ÿÿÿ���¿����A��������8���������A��������e��� ��������� ����-�������A������TTTT+TTTTTT�������������5������…�������@����������Ê������ÿÿ½���A������������������A������������������������Ê������ÿ½������������­��������x���������������������������������9dbe4a4d6f17605da53c17dcb26c3e5ee30b442b������������������������������������������������������������0000664�0000000�0000000�00000000734�15100345067�0032230�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è��������5���>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ1 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ�����ÀH���D��������DE�������À�������è�����������â>€�������" ½Š,²I$’ÈDÒ1 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ�����D��������DE�������À�������è�����������â>€�������"�������$���ú�)))))))))))))))))))))\é)))))))))))@)))))445���0�����44444444��¥]'45���444�444)))))))))))))))))\é)))))))))))@)))))44���������� �B�����444�444<4������������������������������������9f10b850126a00b70b0c7389754b3af7a78efd78������������������������������������������������������������0000664�0000000�0000000�00000000534�15100345067�0031665�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�"�����è�����������>€�������A���������������������è��� """""""""""""""""))ÿÿÿûÿÿÿÿÿÿ)ÿ@))))),,��A�������������A���ãã��������?ãããããããããããããããããããããããããããããããããããããããã������±?��,,,,,ÿ˜,,������������A�������|�����������������…���������ÿ�?��ð��ÿÿø,,,,)))TT����…���������������������������¿��������¿���+�A��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a636879bbc41a43a4748f1aec41c5b8535f95ffb������������������������������������������������������������0000664�0000000�0000000�00000000354�15100345067�0032114�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����4 5²]­I��´[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl���`Á ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a95439dceaaf041214315966c319d4bd99fad3b8������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0032022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������!����A������������������A�����0��������������?���A���)))))))))))))))))))))6@�ù������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������a9fd565873b81f9bc753ef9ffb01279e58b8e995������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032102�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A���������������������è�����ÿ��ÿ������� �������%����P������� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������aa2fc4a7eb7ef7b4db1d14abba054bf82bc99708������������������������������������������������������������0000664�0000000�0000000�00000000214�15100345067�0032443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A������������������������ç���AAAAAAAQAAAAAAAAAAAAAA?AA������������������������883��������á������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������abfe928debc5210e137f2ccb2e35afba1fba01f4������������������������������������������������������������0000664�0000000�0000000�00000000744�15100345067�0032512�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���083HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))))))))))©)))))))))))))))))))))��������������������…���������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��@��������A������]���A��€���������������A��������������������?���A�������������������¸���������E���ÑÑÑ�������E���ÑÑÑÑÑ�������û�������������?p�������U�������è�������������� /����������� ����������������������������ad3f5bbed8a7c1aa1b1d37d9274e51f04ad9d793������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0032313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������ï����������ÿ������� à�������A������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������ï����������ÿ������� à�������A���A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������af5fe18bf35c2ce1542515dfd0a2187a912efed8������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������@������������������������������������������������ �������B����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b1951c3ecea275b55530cd1a7dee87896cba3af8������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@ ������������������@�������������������������� ���~���B������������� �����������������ü^ÿÿÿ±±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b32871f39219d46cc598467522717179035628a2������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0031162�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���4167661(�����4.44444444444´444404444444444444544444��ú�à������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b5af72dc2bcef16a9533f28db6764b41e1dec249������������������������������������������������������������0000664�0000000�0000000�00000000264�15100345067�0032243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������@��ù�����������������@�������������������������� �������B������������� ������������B����Aüÿÿÿÿÿ±±±ÿÿÿÿÿ@�������������@��������ÿÿÿÿÿú�ÿÿÿ00�ø�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������b71d21118459e909a1d13dd39c98bf324746204c������������������������������������������������������������0000664�0000000�0000000�00000000644�15100345067�0031525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���(66HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))©)))))))))))))))))))))))))))))))HHHHH@��*����A����lÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ� ����-�������À���«¥TT�������������������������������������������������������������������������������������������������������������������������� ��������������������������������������������������������������������������������������������b961201e6499ce99d9809e6c45e2d3cb6c25368c������������������������������������������������������������0000664�0000000�0000000�00000000314�15100345067�0031712�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ1 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ�����ÀH���D��������DE�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������bbcd55dd0ecf9385e265652b46670796cfb06866������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031770�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���� Ûä䨪VUÿÛªªª£UUU�����ï����TTTT�=���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������bbe1e29361b5d285b1e3a796d9ea7a6ad330679d������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8�����������������������������������������������������������������������������������������������������������X ��������A������������������A�����������������������A���(ÿ44SSSSSSSSS���‰‰‰‰‰‰ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������bdd340d8b3d28bbd6352fe82bc946b8b662707f6������������������������������������������������������������0000664�0000000�0000000�00000000204�15100345067�0032105�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���UUUUaaaUUUUUU����ú������������A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c1240cef7cf639125a64e8471db1fb7977d2f090������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0031746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������������������øÿ����������������������������������������+�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c4ddbbe3d51294ee8e9ad9476b74cea7024b928a������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032252�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?������088888888890�-44444444444444%44444444�����í�������1�ÿ�����A�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c5bd074e83ef42d118f9508c5fd5de1ecc77eb7f������������������������������������������������������������0000664�0000000�0000000�00000000274�15100345067�0032345�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@������������������#�@�������������������������� �������B������������� ������������à��� ÿÿÿÿÿÿÿÿÿÿÿ��������������*������� ���Èÿÿÿÿÿÿÿÿÿÿÿÿÿÿûÿÿÿ�ÿÿÿÿÿ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c7470bb0cba41502153de8ba1dccfcb415ec37bf������������������������������������������������������������0000664�0000000�0000000�00000000674�15100345067�0032351�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è����—������>€�������A����������������������è���+334HHHvvvvvvvvvvvvvvvvvvvvŠ‰‰Švvvvvyvvvv]vvvvvvvvvvvvvvvvvvvHHHHHH))))))ÿÿÿïë� ����Ô������A������TTTT+TTTTTT�������������������…��������������������������������ÿÿÿ����������������…����������� ����������������yù�������������������������������€����x���������¿����������¿����A����������������������������������������������������������������������������c87f1ba99e627af168ddd46ec94d7f7c08a05c07������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0032207�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���Û~ªªª�$UUUU�������ï����TTT�=���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������c90fb91bdb14d13df37727cf0af752161786f9ee������������������������������������������������������������0000664�0000000�0000000�00000000405�15100345067�0032112�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����4 5²]­I��´[!"“���,ÿ6÷ý¿ÿ€‰%ìÉl¯ÿÿÿ’V¶�������I[³v¤P²&Ô«Šæ���Á �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������cafcf0638aa1531c76b3da2ee1f7a3ce9a22c0cc������������������������������������������������������������0000664�0000000�0000000�00000000564�15100345067�0032434�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À@������è��������5���>€��ý��è��������ñÿ������� �������������P�������à ½Š,²I$’ÈDÒ1 ‚(‚ ,¢‚,ƒH ‚‹Ë‚ $’Ê 5ƒM ³ ƒ�����ÀH���D��������DE������@À������������������â>��-�����À�������¨����f=������>€�ù���è�������������?p��������ÿ>€��ý�������������������¤¤¤¤¤¤���������������è��������ñ�����ÿÿÿÿ6�444454444444444444444444444<4��������������������������������������������������������������������������������������������������������������������������������������������cbf49a84c11c6c588ae0d298407c77c05775e303������������������������������������������������������������0000664�0000000�0000000�00000000154�15100345067�0031672�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A����������������������&�������������@���UUUUUUUU��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������cd4e9ead434c68f2162aace95bb32d69bcd441f3������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032315�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������4���������������d���¬������*���� ���������������������üÿÿý�������3������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d1f6b7119295f8823e331ad4f26e8272b6b608e2������������������������������������������������������������0000664�0000000�0000000�00000000404�15100345067�0031610�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@D€��������ð������� ���@���?›ÇaÎ0³ûý›{a���0áà0���™���������ÿ��0�����0��������������ÿÿÿÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿÿã 7ãÎ<ýóŽÿ0ã<8ãÿ7ãÎ8ã�����(ã���D���������35��������H �����4 5²Ý­��[!"“���,ÿ6÷ÿ€‰ìÉl¯ÿÿÿ’V¶õ‘+mµK;jI[¤P²&Ô«` ���`Á ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d2860d9b6b66d6fc1515ee7e73432da15a2e3d6d������������������������������������������������������������0000664�0000000�0000000�00000000144�15100345067�0032102�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@����������:�������������øÿ������������������������� �������B���������B������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d325fb86fbb09b1410f4d2d7d2e9552206bbe4f1������������������������������������������������������������0000664�0000000�0000000�00000002057�15100345067�0032072�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�����������������A�������������RB�����ù��è���333HHHHHHHHH))))))ÿÿÿÿÿÿÿ@))))))))))))))%))))))))))))))©)))))))))))))))))))))))))))))§))HHHA��� 0716555(4444444444444���ñÿ��@�À�������è�����������>€�������A������������RB���������è���333HHHHHHHHH))))))ÿÿÿÿÿÿÿ@)))))))))))))))))))))HHHHHHHHHHHHHHîHHHHHHHHHHHhHHTTTTTTTTT+TTTTTT��������������������…��������������������������������5�����������������ÿÿÿ���������HOHHHÿ/))))))ÿÿÿÿÿÿÿ@))))))+)))))))))©))))))TTT���������������¿����A��������7���������A��������e��� ������������…���������������������������Í!� ����…������������������Ê�������ÿÿ������ÿÿ½����A���������������������������û������?p�������U�������è��������9�@À��]���è������������>€��ý��è��������ñÿ��ð����� �������������P�������É àBuÓEþ¶uÈ$DÒ0 ‚(‚ ,¢‚,ƒH ‚‹‚Ë$’Ê 5ƒM ³ 1ƒ����ÀH���D������������?���A�F����������������������A:�����x�����ÿÿ����� /��������ÿ��ÿ�ÿ� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d36ce05a4a02233c33f3c5deb7559e0816b4b10b������������������������������������������������������������0000664�0000000�0000000�00000000604�15100345067�0031770�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�@�����è�����������>€�������A����������������������è���$ªªªªªªªªªªªªªªªªªªªªªªªªªª���@������A����ªªªªªªªªªªªªªªªªª�@ª��������è���+ªªªªªªªªªªªªªªªªªCªªªªªªªªªªªª((((((((((((((((((((((((((((((((((((((((((ˆ�������(((((��������ï����������������ú����™™����������������������A�����������������������?������Ž757776w7780�-2222222222222 2%4444444�@����������������������������������������������������������������������������������������������������������������������������������������d3708428e4607ba37bfb13ee8ba2dd236755adbd������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032151�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A������������������A��������������������?���A���(218888ÈÇ788888�44�������� ��������������ë�������������A������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d71949b44c5e54a1c86336f522a28b281860397f������������������������������������������������������������0000664�0000000�0000000�00000000314�15100345067�0031455�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€��ý��è��������ñÿ������� �������������P�������à ½’$Š,I²ÈDÒ1 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$’Ê 5ƒM ³ ƒ�����ÀH���D��������DE����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������d834d51078ec5d4319c520766d35faae90554491������������������������������������������������������������0000664�0000000�0000000�00000001264�15100345067�0031534�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���HHHHHÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��å�������������������������Ò�������������������������������������������������������%�.��������������������*��������������������������������������������������������������������������������.�������������������������������������������������.����������������������������������������������������������������� �����������������������������������������������������������.��������������������������������ï�@�����������������������øÿ���������ö����������������t������üÿÿÿÿÿÿÒ��ÿ�����…�����������������?��“““�������€�A:����x������� ������/�������A��Aù��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dbbfd75cb69ba487c576d62261849af7fee58b61������������������������������������������������������������0000664�0000000�0000000�00000000746�15100345067�0032222�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A���������������������è���0583HHHHHHHHÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�����������33HHH���������������� ��1g��������������Þ������������� ��ÿg������Þ�������å�������������o�������H�����������@�������������������������� ���~���B������������� ����������^ÿÿÿ±±ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ��������������������������������������������������������������������������������������������������������ƒ����������������������������� �����������������������������������dc17f72fa3dc031b3e2059844d774fc889ad9f93������������������������������������������������������������0000664�0000000�0000000�00000000174�15100345067�0032047�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������*������� ��������Ö������B�����������úÿù����"������������������UY��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������dc288af0c1589727824c9f9014b81fbc800f97c0������������������������������������������������������������0000664�0000000�0000000�00000000234�15100345067�0031676�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8��������������������������������������������������������������������������������������������������������������������ï����������ÿ�������*à�������A������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ�������?���A�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e1e6fecdf18b3a1375531bbf5a103c2d8f56cdf0������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A�����������������A��������������������?���A���hhhhhhhhhh ������Ç2222223222Þ44444�44�B4�ù����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e229b64d990b03a9f44cbd00e71d3d8baa4319ab������������������������������������������������������������0000664�0000000�0000000�00000000134�15100345067�0032140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������������������A�������������������A��������������������?���A���������������>€����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������e7b835e207feecbece96967fc8a45c3c8484c99e������������������������������������������������������������0000664�0000000�0000000�00000000224�15100345067�0032307�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@�������������������@�������������������������� �������B������������� �����������B���Aÿüÿÿÿ±±±±ÿ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ea35f5785fb9f197b4f308eb0e33bf2e51ed3853������������������������������������������������������������0000664�0000000�0000000�00000000013�15100345067�0032111�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f0da90d63a403203967ac12b90eb9d63f0f4ceeb������������������������������������������������������������0000664�0000000�0000000�00000000554�15100345067�0032146�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���!)))))))))))))))))HH��������������������������������������������������������üÿÿÿGHH;@�/������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ������������������������������������������������������HHH;@�/���������������������ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ������� ������������������ ���������������������������������������������������������������������������������������������������������������������������������������������������������f0ecab55d82b763c44cf359fcc00e191a96d70e7������������������������������������������������������������0000664�0000000�0000000�00000000654�15100345067�0032170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���))ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ2�������ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ7����ˆˆˆˆˆˆˆˆˆˆˆwˆˆ�������������������������*����ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ���������������������*������� ��������Ö �����Bÿÿÿ�����������úÿù���"�������������������UUUUUUUÿ��!T�������TTT+TTTTTT������������������…%����������:�����������������������������������������������������������������������������������������������f29494e8b1819543bd357029a0de41a3eda2d451������������������������������������������������������������0000664�0000000�0000000�00000000404�15100345067�0031653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�@�����è�����������>€�������A����������������������è���Iþÿÿÿ‹��������A������¬«ST%ªTTT���ø������������������������������è���Iþÿÿÿ‹��������A����T%ªTTT���ø����������������������������������ß�������Ë�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f3c4c54e20e1b109c2211ea1c75e448fca92d94b������������������������������������������������������������0000664�0000000�0000000�00000001324�15100345067�0032061�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è������������>€�ý��è�������ñÿ������� �÷ÿ����������P�������=0@Ä ½Š,²$DA’Iè������������>€þÿÿÿ�è���...................n......ÿÿÿÿÿÿÿ@........................�þÿÿÿ�ÿÿ����� �÷ÿ��������çÿÿé°������5Ä ½Š,²$D’IÈÒ1 ‚(‚ ,�@À�������è������������>€��ý��è��������ñÿ���)��� ��)�������KKKKKKKKKKKKKKKKKKKKKKKKKKº´KKKKKKËKKKKKKKKKKKKK�AKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKÿÿÿKKKKKK�:��P������� ½Š,²D’IÈÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$ÈÒ1 ‚`‚ ,���õ½Š,²D’IÈÒ0 ‚(‚ ,¢‚,ƒH ‚‹ ‚Ë$ÈÒŽ ‚(‚ ,�@À�������è������������>€��ý��è��������ñÿ������� ��)�������:��P������� ½Š,²$D’I������>€�ý�è�����������>€�������������A�����������������è���333HHHO��HHHH���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f41088954ca36155c47d16133b8c7c472a50a211������������������������������������������������������������0000664�0000000�0000000�00000000164�15100345067�0031425�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@�����������������������ø������������������������� ������������������������������ ������� ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f6dde08a505b30f15b89ff107fffe86418e107c3������������������������������������������������������������0000664�0000000�0000000�00000000304�15100345067�0032106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8���������������������������������������������������������������������������������������������������������ù@�������������������@�������������������������� �������B������������� �����������B��� Aÿüÿÿÿÿ±±±±ÿ����������������������ÿþÿ‰ÿÿÿÿÿÿÿ�@���������������2�ÿ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f79f35266d31ad7f640363bdd2965e714625ac2d������������������������������������������������������������0000664�0000000�0000000�00000000314�15100345067�0031670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è�����g���))©))))))))))))H¶���������@�����������������������������ÿÿ������þ�ø�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������f8bf4cc7cb83512b86997321687281890693f5dd������������������������������������������������������������0000664�0000000�0000000�00000001334�15100345067�0031565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000�timescaledb-2.23.0/tsl/test/fuzzing/compression/gorilla-float8����������������������������������������������������������������������������������������������������������@À�������è�����������>€�������A����������������������è���Miiiii…………………………………………………………………………………………©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©……………������������������>€�������A�������…���uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu�����‡�%���������������@����Ð����uu����������������������� ���@����������ÿÿÿÿÿ�����ÿÿÿÿÿÿÿ����ÿÿÿÿÁÿÿÿÿÿÿÿÿüóÿüóÿÿ��������øÿ���������ö����µ�������������A������������������A��������������������?������001979992048�-44444444444444%44444444�����í�������1�ÿ�����A���������ÿÿÿ����� ����c����(�����������������������������������x�������¿��������¿����A����A������A������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/uuid-uuid/������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0023603�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/fuzzing/compression/uuid-uuid/empty�������������������������������������0000664�0000000�0000000�00000000000�15100345067�0024652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/��������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017635�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/CMakeLists.txt������������������������������������������������0000664�0000000�0000000�00000000126�15100345067�0022374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# dummy file to ensure isolation output is created correctly add_subdirectory(specs) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/�����������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0021436�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/attach_chunk_isolation.out���������������������������0000664�0000000�0000000�00000027135�15100345067�0026714�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 4 sessions starting permutation: s3_wait_before_lock s1b s1_attach s4_insert s3_release_lock s1c s3_show_num_chunks step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s4_insert: INSERT INTO attach_test VALUES ('2025-06-03 00:15', 1, 31.5); step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> ERROR: chunk creation failed due to collision step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 starting permutation: s1b s1_attach s3_show_num_rows s4_insert s1c s3_show_num_chunks s3_show_num_rows step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s3_show_num_rows: SELECT count(*) FROM attach_test; count ----- 0 step s4_insert: INSERT INTO attach_test VALUES ('2025-06-03 00:15', 1, 31.5); <waiting ...> step s1c: COMMIT; step s4_insert: <... completed> step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 step s3_show_num_rows: SELECT count(*) FROM attach_test; count ----- 1 starting permutation: s3_wait_before_lock s1b s1_attach s3_show_chunk_rows s4_violate s3_release_lock s1c s3_show_num_chunks s3_show_chunk_rows step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s3_show_chunk_rows: SELECT count(*) FROM chunk_to_attach; count ----- 0 step s4_violate: INSERT INTO chunk_to_attach VALUES ('2025-08-01 20:00', 1, 34); step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> ERROR: dimension constraint for column "time" violated by some row step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s3_show_chunk_rows: SELECT count(*) FROM chunk_to_attach; count ----- 1 starting permutation: s1b s3_show_num_chunks s1_attach s4_violate s1c s3_show_num_chunks s3_show_chunk_rows step s1b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s4_violate: INSERT INTO chunk_to_attach VALUES ('2025-08-01 20:00', 1, 34); <waiting ...> step s1c: COMMIT; step s4_violate: <... completed> ERROR: new row for relation "chunk_to_attach" violates chunk constraint step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 step s3_show_chunk_rows: SELECT count(*) FROM chunk_to_attach; count ----- 0 starting permutation: s3_wait_before_lock s1b s1_attach s4_drop s3_release_lock s1c step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s4_drop: DROP TABLE chunk_to_attach; step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> ERROR: relation with OID X does not exist step s1c: COMMIT; starting permutation: s1b s3_show_num_chunks s1_attach s4_drop s1c s3_show_num_chunks s3_show_chunk_rows step s1b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s4_drop: DROP TABLE chunk_to_attach; <waiting ...> step s1c: COMMIT; step s4_drop: <... completed> step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s3_show_chunk_rows: SELECT count(*) FROM chunk_to_attach; ERROR: relation "chunk_to_attach" does not exist starting permutation: s3_wait_before_lock s1b s1_attach s4_truncate s3_release_lock s1c s3_show_num_chunks step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s4_truncate: TRUNCATE TABLE attach_test; step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 starting permutation: s1b s3_show_num_chunks s1_attach s4_truncate s1c s3_show_num_chunks s3_show_chunk_rows step s1b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s4_truncate: TRUNCATE TABLE attach_test; <waiting ...> step s1c: COMMIT; step s4_truncate: <... completed> step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s3_show_chunk_rows: SELECT count(*) FROM chunk_to_attach; ERROR: relation "chunk_to_attach" does not exist starting permutation: s3_wait_before_lock s1b s1_attach s4_compress s3_release_lock s1c s3_show_num_chunks step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s4_compress: CALL convert_to_columnstore('chunk_to_attach'); ERROR: chunk not found step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 starting permutation: s1b s3_show_num_chunks s1_attach s4_compress s1c s3_show_num_chunks s3_show_chunk_rows step s1b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s4_compress: CALL convert_to_columnstore('chunk_to_attach'); ERROR: chunk not found step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 step s3_show_chunk_rows: SELECT count(*) FROM chunk_to_attach; count ----- 0 starting permutation: s2_attach s3_wait_before_lock s1b s1_attach s2_compress s3_release_lock s1c step s2_attach: CALL attach_chunk('attach_test', 'temp_chunk', jsonb_build_object('time', jsonb_build_array('2025-05-01', '2025-05-11'))); step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s2_compress: CALL convert_to_columnstore('temp_chunk'); step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> step s1c: COMMIT; starting permutation: s1b s2b s3_show_num_chunks s1_attach s2_attach s1c s2c s3_show_num_chunks step s1b: BEGIN; step s2b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s2_attach: CALL attach_chunk('attach_test', 'temp_chunk', jsonb_build_object('time', jsonb_build_array('2025-05-01', '2025-05-11'))); <waiting ...> step s1c: COMMIT; step s2_attach: <... completed> step s2c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 2 starting permutation: s1b s2b s3_show_num_chunks s1_attach s2_attach_same s1c s2c s3_show_num_chunks step s1b: BEGIN; step s2b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s2_attach_same: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s1c: COMMIT; step s2_attach_same: <... completed> ERROR: cannot attach chunk that is already a child of another table step s2c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 starting permutation: s3_wait_before_detach s1b s3_show_num_chunks s1_attach s4_detach s3_release_detach s1c s3_show_num_chunks step s3_wait_before_detach: SELECT debug_waitpoint_enable('chunk_detach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 0 step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); step s4_detach: CALL detach_chunk('chunk_to_attach'); <waiting ...> step s3_release_detach: SELECT debug_waitpoint_release('chunk_detach_before_lock'); debug_waitpoint_release ----------------------- step s4_detach: <... completed> ERROR: hypertable not found for the chunk step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 starting permutation: s2_attach s3_wait_before_lock s1b s1_attach s2_detach s3_release_lock s1c s3_show_num_chunks step s2_attach: CALL attach_chunk('attach_test', 'temp_chunk', jsonb_build_object('time', jsonb_build_array('2025-05-01', '2025-05-11'))); step s3_wait_before_lock: SELECT debug_waitpoint_enable('chunk_attach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_attach: CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); <waiting ...> step s2_detach: CALL detach_chunk('temp_chunk'); step s3_release_lock: SELECT debug_waitpoint_release('chunk_attach_before_lock'); debug_waitpoint_release ----------------------- step s1_attach: <... completed> step s1c: COMMIT; step s3_show_num_chunks: SELECT count(*) FROM show_chunks('attach_test'); count ----- 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/bgw_job_stat_history_retention_isolation.out���������0000664�0000000�0000000�00000002344�15100345067�0032567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s2_begin s2_insert s2_count s1_retention s2_commit expected_count -------------- 4 step s2_begin: BEGIN; step s2_insert: INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish) VALUES (201, 2001, true, now() - interval '1 week', now() - interval '1 week' + interval '5 minutes'); step s2_count: SELECT count(*) as s2_count FROM _timescaledb_internal.bgw_job_stat_history; s2_count -------- 10 step s1_retention: CALL run_job(3); SELECT count(*) as s1_count FROM _timescaledb_internal.bgw_job_stat_history; <waiting ...> step s2_commit: COMMIT; step s1_retention: <... completed> s1_count -------- 5 starting permutation: s2_lock_table s1_retention s2_unlock_table expected_count -------------- 4 step s2_lock_table: BEGIN; LOCK TABLE _timescaledb_internal.bgw_job_stat_history IN ACCESS SHARE MODE; step s1_retention: CALL run_job(3); SELECT count(*) as s1_count FROM _timescaledb_internal.bgw_job_stat_history; <waiting ...> step s2_unlock_table: ROLLBACK; step s1_retention: <... completed> s1_count -------- 4 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_concurrent_invalidation.out���������������������0000664�0000000�0000000�00000004352�15100345067�0030077�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s3_lock_invalidation s1_run_update s2_run_update s3_release_invalidation s3_check_watermarks step s3_lock_invalidation: SELECT debug_waitpoint_enable('invalidation_threshold_scan_update_enter'); debug_waitpoint_enable ---------------------- step s1_run_update: CALL refresh_continuous_aggregate('cagg_1', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); <waiting ...> step s2_run_update: CALL refresh_continuous_aggregate('cagg_2', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); <waiting ...> step s3_release_invalidation: SELECT debug_waitpoint_release('invalidation_threshold_scan_update_enter'); debug_waitpoint_release ----------------------- step s1_run_update: <... completed> step s2_run_update: <... completed> step s3_check_watermarks: SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark ORDER BY mat_hypertable_id; to_timestamp ---------------------------- Wed Jan 01 16:00:00 2020 PST Wed Jan 01 16:00:00 2020 PST starting permutation: s2_insert_new_data_2022 s3_lock_invalidation_tuple_found s2_insert_new_data_2023 s1_run_update s3_release_invalidation_tuple_found step s2_insert_new_data_2022: INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2022-01-01 0:00:00+0'::timestamptz, '2022-01-01 23:59:59+0','1m') time; step s3_lock_invalidation_tuple_found: SELECT debug_waitpoint_enable('invalidation_tuple_found_done'); debug_waitpoint_enable ---------------------- step s2_insert_new_data_2023: INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2023-01-01 0:00:00+0'::timestamptz, '2023-01-01 23:59:59+0','1m') time; <waiting ...> step s1_run_update: CALL refresh_continuous_aggregate('cagg_1', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); step s3_release_invalidation_tuple_found: SELECT debug_waitpoint_release('invalidation_tuple_found_done'); debug_waitpoint_release ----------------------- step s2_insert_new_data_2023: <... completed> ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_concurrent_move.out�����������������������������0000664�0000000�0000000�00000004474�15100345067�0026371�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 4 sessions starting permutation: s4_show_thresholds s4_before s1_refresh s2_refresh s3_process s4_release s4_after step s4_show_thresholds: SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, _timescaledb_functions.to_timestamp(watermark) AS watermark FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1; hypertable |watermark -----------+---------------------------- temperature|Wed Jan 01 00:00:00 2025 PST step s4_before: START TRANSACTION; SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest_modified_value, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1, 2, 3 FOR UPDATE; hypertable |lowest_modified_value |greatest_modified_value -----------+----------------------------+---------------------------- temperature|Sat Dec 31 16:00:00 2022 PST|Sun Jan 01 15:59:00 2023 PST step s1_refresh: CALL refresh_continuous_aggregate('cagg_1', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); <waiting ...> step s2_refresh: CALL refresh_continuous_aggregate('cagg_2', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); <waiting ...> step s3_process: CALL _timescaledb_functions.process_hypertable_invalidations('temperature'); <waiting ...> step s4_release: ROLLBACK; step s1_refresh: <... completed> step s2_refresh: <... completed> step s3_process: <... completed> step s4_after: SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest_modified_value, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1, 2, 3; hypertable|lowest_modified_value|greatest_modified_value ----------+---------------------+----------------------- ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_concurrent_process_wal.out����������������������0000664�0000000�0000000�00000002634�15100345067�0027740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: lock_enable s1_refresh s2_refresh lock_show lock_release step lock_enable: SELECT debug_waitpoint_enable('multi_invalidation_process_invalidations'); debug_waitpoint_enable ---------------------- step s1_refresh: CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['temperature']); <waiting ...> step s2_refresh: CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['temperature']); <waiting ...> step lock_show: SELECT locktype, granted, application_name, objtyp, objid FROM my_locks WHERE locktype in ('object', 'advisory'); locktype|granted|application_name|objtyp |objid --------+-------+----------------+--------+--------------------------------------------------------------------- advisory|f |s1 |- |1465306080 object |t |s1 |pg_class|_timescaledb_catalog.continuous_aggs_materialization_invalidation_log object |f |s2 |pg_class|_timescaledb_catalog.continuous_aggs_materialization_invalidation_log step lock_release: SELECT debug_waitpoint_release('multi_invalidation_process_invalidations'); debug_waitpoint_release ----------------------- step s1_refresh: <... completed> step s2_refresh: <... completed> ����������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_concurrent_refresh.out��������������������������0000664�0000000�0000000�00000047421�15100345067�0027060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 16 sessions starting permutation: R1_refresh S1_select R3_refresh S1_select L2_read_unlock_threshold_table L3_unlock_cagg_table L1_unlock_threshold_table step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 cagg_bucket_count ----------------- 7 hypertable | threshold -----------+----------- conditions | 70 conditions2|-2147483648 step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 10 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 step L2_read_unlock_threshold_table: ROLLBACK; step L3_unlock_cagg_table: ROLLBACK; step L1_unlock_threshold_table: ROLLBACK; starting permutation: L2_read_lock_threshold_table R3_refresh L2_read_unlock_threshold_table S1_select L3_unlock_cagg_table L1_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step L2_read_lock_threshold_table: LOCK _timescaledb_catalog.continuous_aggs_invalidation_threshold IN ACCESS SHARE MODE; step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); step L2_read_unlock_threshold_table: ROLLBACK; step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 6 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 step L3_unlock_cagg_table: ROLLBACK; step L1_unlock_threshold_table: ROLLBACK; starting permutation: R1_refresh L2_read_lock_threshold_table R3_refresh L2_read_unlock_threshold_table S1_select L3_unlock_cagg_table L1_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); step L2_read_lock_threshold_table: LOCK _timescaledb_catalog.continuous_aggs_invalidation_threshold IN ACCESS SHARE MODE; step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); step L2_read_unlock_threshold_table: ROLLBACK; step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 10 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 step L3_unlock_cagg_table: ROLLBACK; step L1_unlock_threshold_table: ROLLBACK; starting permutation: R3_refresh L2_read_lock_threshold_table R1_refresh L2_read_unlock_threshold_table S1_select L3_unlock_cagg_table L1_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); step L2_read_lock_threshold_table: LOCK _timescaledb_catalog.continuous_aggs_invalidation_threshold IN ACCESS SHARE MODE; step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); step L2_read_unlock_threshold_table: ROLLBACK; step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 10 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 step L3_unlock_cagg_table: ROLLBACK; step L1_unlock_threshold_table: ROLLBACK; starting permutation: L3_lock_cagg_table R1_refresh L3_unlock_cagg_table S1_select L1_unlock_threshold_table L2_read_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step L3_lock_cagg_table: SELECT lock_cagg('cond_10'); lock_cagg --------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step L3_unlock_cagg_table: ROLLBACK; step R1_refresh: <... completed> step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 cagg_bucket_count ----------------- 7 hypertable | threshold -----------+----------- conditions | 70 conditions2|-2147483648 step L1_unlock_threshold_table: ROLLBACK; step L2_read_unlock_threshold_table: ROLLBACK; starting permutation: L3_lock_cagg_table R1_refresh R2_refresh L3_unlock_cagg_table S1_select L1_unlock_threshold_table L2_read_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step L3_lock_cagg_table: SELECT lock_cagg('cond_10'); lock_cagg --------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step R2_refresh: CALL refresh_continuous_aggregate('cond_10', 35, 62); <waiting ...> step L3_unlock_cagg_table: ROLLBACK; step R1_refresh: <... completed> step R2_refresh: <... completed> step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 cagg_bucket_count ----------------- 7 hypertable | threshold -----------+----------- conditions | 70 conditions2|-2147483648 step L1_unlock_threshold_table: ROLLBACK; step L2_read_unlock_threshold_table: ROLLBACK; starting permutation: L3_lock_cagg_table R1_refresh R3_refresh L3_unlock_cagg_table S1_select L1_unlock_threshold_table L2_read_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step L3_lock_cagg_table: SELECT lock_cagg('cond_10'); lock_cagg --------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); <waiting ...> step L3_unlock_cagg_table: ROLLBACK; step R1_refresh: <... completed> step R3_refresh: <... completed> step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 10 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 step L1_unlock_threshold_table: ROLLBACK; step L2_read_unlock_threshold_table: ROLLBACK; starting permutation: L3_lock_cagg_table R3_refresh R4_refresh L3_unlock_cagg_table S1_select L1_unlock_threshold_table L2_read_unlock_threshold_table R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step L3_lock_cagg_table: SELECT lock_cagg('cond_10'); lock_cagg --------- step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); <waiting ...> step R4_refresh: CALL refresh_continuous_aggregate('cond_20', 39, 84); step L3_unlock_cagg_table: ROLLBACK; step R3_refresh: <... completed> step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 6 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 step L1_unlock_threshold_table: ROLLBACK; step L2_read_unlock_threshold_table: ROLLBACK; starting permutation: R1_refresh R12_refresh R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); step R12_refresh: CALL refresh_continuous_aggregate('cond2_10', 25, 70); starting permutation: WP_after_enable R1_refresh R6_pending_materialization_ranges R5_refresh R6_pending_materialization_ranges WP_after_release R6_pending_materialization_ranges S1_select R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; L1: WARNING: there is already a transaction in progress L2: WARNING: there is already a transaction in progress L3: WARNING: there is already a transaction in progress step WP_after_enable: SELECT debug_waitpoint_enable('after_process_cagg_invalidations_for_refresh_lock'); debug_waitpoint_enable ---------------------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step R6_pending_materialization_ranges: SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; user_view_name|lowest_modified_value|greatest_modified_value --------------+---------------------+----------------------- cond_10 | 30| 70 R5: LOG: statement: CALL refresh_continuous_aggregate('cond_10', 70, 107); step R5_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); <waiting ...> step R6_pending_materialization_ranges: SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; user_view_name|lowest_modified_value|greatest_modified_value --------------+---------------------+----------------------- cond_10 | 30| 70 cond_10 | 70| 100 step WP_after_release: SELECT debug_waitpoint_release('after_process_cagg_invalidations_for_refresh_lock'); debug_waitpoint_release ----------------------- step R1_refresh: <... completed> R5: DEBUG: continuous aggregate refresh (individual invalidation) on "cond_10" in window [ 70, 100 ] R5: LOG: deleted 0 row(s) from materialization table "_timescaledb_internal._materialized_hypertable_X" R5: LOG: inserted 3 row(s) into materialization table "_timescaledb_internal._materialized_hypertable_X" step R5_refresh: <... completed> step R6_pending_materialization_ranges: SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; user_view_name|lowest_modified_value|greatest_modified_value --------------+---------------------+----------------------- step S1_select: SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; bucket| avg_temp ------+---------------- 0|15.8888888888889 10| 14.2 20| 13.4 30| 18.3 40|16.0909090909091 50| 26.9 60| 18.9 70| 24.6 80| 23.6 90| 21.3 cagg_bucket_count ----------------- 10 hypertable | threshold -----------+----------- conditions | 100 conditions2|-2147483648 starting permutation: WP_after_enable R6_pending_materialization_ranges R1_refresh R3_refresh K1_cancelpid R6_pending_materialization_ranges WP_after_release R13_refresh R6_pending_materialization_ranges R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; L1: WARNING: there is already a transaction in progress L2: WARNING: there is already a transaction in progress L3: WARNING: there is already a transaction in progress step WP_after_enable: SELECT debug_waitpoint_enable('after_process_cagg_invalidations_for_refresh_lock'); debug_waitpoint_enable ---------------------- step R6_pending_materialization_ranges: SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; user_view_name|lowest_modified_value|greatest_modified_value --------------+---------------------+----------------------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); <waiting ...> step K1_cancelpid: CALL cancelpids(); <waiting ...> step R1_refresh: <... completed> ERROR: canceling statement due to user request step R6_pending_materialization_ranges: SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; user_view_name|lowest_modified_value|greatest_modified_value --------------+---------------------+----------------------- cond_10 | 30| 70 cond_10 | 70| 100 step K1_cancelpid: <... completed> step WP_after_release: SELECT debug_waitpoint_release('after_process_cagg_invalidations_for_refresh_lock'); debug_waitpoint_release ----------------------- step R3_refresh: <... completed> step R13_refresh: CALL refresh_continuous_aggregate('cond_10', 65, 100); step R6_pending_materialization_ranges: SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; user_view_name|lowest_modified_value|greatest_modified_value --------------+---------------------+----------------------- starting permutation: WP_before_enable R1_refresh R3_refresh WP_before_release R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; L1: WARNING: there is already a transaction in progress L2: WARNING: there is already a transaction in progress L3: WARNING: there is already a transaction in progress step WP_before_enable: SELECT debug_waitpoint_enable('before_process_cagg_invalidations_for_refresh_lock'); debug_waitpoint_enable ---------------------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); <waiting ...> step WP_before_release: SELECT debug_waitpoint_release('before_process_cagg_invalidations_for_refresh_lock'); debug_waitpoint_release ----------------------- step R1_refresh: <... completed> step R3_refresh: <... completed> starting permutation: WP_after_materialization_enable R1_refresh WP_after_materialization_release R3_refresh R5: LOG: statement: SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; L1: WARNING: there is already a transaction in progress L2: WARNING: there is already a transaction in progress L3: WARNING: there is already a transaction in progress step WP_after_materialization_enable: SELECT debug_waitpoint_enable('after_process_cagg_materializations'); debug_waitpoint_enable ---------------------- step R1_refresh: CALL refresh_continuous_aggregate('cond_10', 25, 70); <waiting ...> step WP_after_materialization_release: SELECT debug_waitpoint_release('after_process_cagg_materializations'); debug_waitpoint_release ----------------------- step R1_refresh: <... completed> step R3_refresh: CALL refresh_continuous_aggregate('cond_10', 70, 107); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_insert.out��������������������������������������0000664�0000000�0000000�00000024744�15100345067�0024467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 17 sessions starting permutation: LockInvalThrEx Refresh Refresh2 Refresh3 UnlockInvalThrEx step LockInvalThrEx: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ; step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Refresh2: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Refresh3: CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); <waiting ...> step UnlockInvalThrEx: ROLLBACK; step Refresh: <... completed> step Refresh2: <... completed> step Refresh3: <... completed> starting permutation: Ib LockCagg1 I1 Refresh Ic UnLockCagg1 step Ib: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockCagg1: BEGIN; SELECT lock_cagg('continuous_view_1'); lock_cagg --------- step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Ic: COMMIT; step UnLockCagg1: ROLLBACK; step Refresh: <... completed> starting permutation: Ib LockCagg1 Refresh I1 Ic UnLockCagg1 step Ib: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockCagg1: BEGIN; SELECT lock_cagg('continuous_view_1'); lock_cagg --------- step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Ic: COMMIT; step UnLockCagg1: ROLLBACK; step Refresh: <... completed> starting permutation: I2b LockCagg2 I21 Refresh Refresh3 I2c UnLockCagg2 step I2b: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockCagg2: BEGIN; SELECT lock_cagg('continuous_view_2'); lock_cagg --------- step I21: INSERT INTO ts_continuous_test_2 VALUES (1, 1); step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step Refresh3: CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); <waiting ...> step I2c: COMMIT; step UnLockCagg2: ROLLBACK; step Refresh3: <... completed> starting permutation: I2b LockCagg2 Refresh3 Refresh I21 I2c UnLockCagg2 step I2b: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockCagg2: BEGIN; SELECT lock_cagg('continuous_view_2'); lock_cagg --------- step Refresh3: CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); <waiting ...> step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step I21: INSERT INTO ts_continuous_test_2 VALUES (1, 1); step I2c: COMMIT; step UnLockCagg2: ROLLBACK; step Refresh3: <... completed> step Refresh: <... completed> starting permutation: Sb LockCagg1 Refresh S1 Sc UnLockCagg1 step Sb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockCagg1: BEGIN; SELECT lock_cagg('continuous_view_1'); lock_cagg --------- step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step S1: SELECT count(*) FROM ts_continuous_test_1; count ----- 30 step Sc: COMMIT; step UnLockCagg1: ROLLBACK; step Refresh: <... completed> starting permutation: Sb LockCagg1 S1 Refresh Sc UnLockCagg1 step Sb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockCagg1: BEGIN; SELECT lock_cagg('continuous_view_1'); lock_cagg --------- step S1: SELECT count(*) FROM ts_continuous_test_1; count ----- 30 step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Sc: COMMIT; step UnLockCagg1: ROLLBACK; step Refresh: <... completed> starting permutation: Ib LockInvalThr Refresh I1 Ic UnlockInvalThr step Ib: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockInvalThr: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold IN SHARE MODE; step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Ic: COMMIT; step UnlockInvalThr: ROLLBACK; step Refresh: <... completed> starting permutation: Ib LockInvalThr I1 Refresh Ic UnlockInvalThr step Ib: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockInvalThr: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold IN SHARE MODE; step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Ic: COMMIT; step UnlockInvalThr: ROLLBACK; step Refresh: <... completed> starting permutation: Ib LockInval I1 Ic Refresh UnlockInval step Ib: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Ic: COMMIT; step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step UnlockInval: ROLLBACK; step Refresh: <... completed> starting permutation: Ipb LockInval Refresh Ip1 Ipc UnlockInval step Ipb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Ip1: INSERT INTO ts_continuous_test_1 VALUES (29, 29); step Ipc: COMMIT; step UnlockInval: ROLLBACK; step Refresh: <... completed> starting permutation: Ipb LockInval Ip1 Refresh Ipc UnlockInval step Ipb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; step Ip1: INSERT INTO ts_continuous_test_1 VALUES (29, 29); step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Ipc: COMMIT; step UnlockInval: ROLLBACK; step Refresh: <... completed> starting permutation: Ipb LockInval Ip1 Ipc Refresh UnlockInval step Ipb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step LockInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; step Ip1: INSERT INTO ts_continuous_test_1 VALUES (29, 29); step Ipc: COMMIT; step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step UnlockInval: ROLLBACK; step Refresh: <... completed> starting permutation: Refresh SV1 LockMatInval Refresh1 Ib I1 LockInvalThrEx Ic UnlockMatInval UnlockInvalThrEx SV1 step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step SV1: SELECT * FROM continuous_view_1 ORDER BY 1; time_bucket|count -----------+----- 0| 5 5| 5 10| 5 step LockMatInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Ib: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step LockInvalThrEx: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ; <waiting ...> step Ic: COMMIT; <waiting ...> step UnlockMatInval: ROLLBACK; step Refresh1: <... completed> step LockInvalThrEx: <... completed> step UnlockInvalThrEx: ROLLBACK; step Ic: <... completed> step SV1: SELECT * FROM continuous_view_1 ORDER BY 1; time_bucket|count -----------+----- 0| 5 5| 5 10| 5 starting permutation: I1 Refresh LockInval Refresh Sb S1 Sc UnlockInval step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step LockInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Sb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step S1: SELECT count(*) FROM ts_continuous_test_1; count ----- 31 step Sc: COMMIT; step UnlockInval: ROLLBACK; step Refresh: <... completed> starting permutation: I1 Refresh LockInval Sb S1 Refresh Sc UnlockInval step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step LockInval: BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; step Sb: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step S1: SELECT count(*) FROM ts_continuous_test_1; count ----- 31 step Refresh: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); <waiting ...> step Sc: COMMIT; step UnlockInval: ROLLBACK; step Refresh: <... completed> starting permutation: I1 I21 Refresh1 Refresh2 Refresh3 step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step I21: INSERT INTO ts_continuous_test_2 VALUES (1, 1); step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step Refresh2: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step Refresh3: CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); starting permutation: I1 I2b I21 Refresh2 Refresh3 I2c Refresh3 step I1: INSERT INTO ts_continuous_test_1 VALUES (1, 1); step I2b: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; step I21: INSERT INTO ts_continuous_test_2 VALUES (1, 1); step Refresh2: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); step Refresh3: CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); step I2c: COMMIT; step Refresh3: CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); starting permutation: CreateMatView1_Begin CreateMatView2_Begin CreateMatView1_Commit CreateMatView2_Commit step CreateMatView1_Begin: BEGIN; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test_1 GROUP BY 1 WITH NO DATA; step CreateMatView2_Begin: BEGIN; CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test_1 GROUP BY 1 WITH NO DATA; <waiting ...> step CreateMatView1_Commit: COMMIT; step CreateMatView2_Begin: <... completed> step CreateMatView2_Commit: COMMIT; ����������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_multi_iso.out�����������������������������������0000664�0000000�0000000�00000016262�15100345067�0025163�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 9 sessions starting permutation: Setup2 LockMat1 Refresh1 Refresh2 UnlockMat1 step Setup2: CREATE MATERIALIZED VIEW continuous_view_1( bkt, cnt) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), COUNT(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW continuous_view_2(bkt, maxl) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), max(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE FUNCTION lock_mattable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s', name); END; $$ LANGUAGE plpgsql; step LockMat1: BEGIN; select lock_mattable(tab) FROM ( SELECT format('%I.%I',materialization_hypertable_schema, materialization_hypertable_name) as tab from timescaledb_information.continuous_aggregates where view_name::text like 'continuous_view_1') q ; lock_mattable ------------- step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); <waiting ...> step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); step UnlockMat1: ROLLBACK; step Refresh1: <... completed> starting permutation: Setup2 Refresh1 Refresh2 LockMat1 I1 Refresh1 Refresh2 UnlockMat1 Refresh1_sel Refresh2_sel step Setup2: CREATE MATERIALIZED VIEW continuous_view_1( bkt, cnt) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), COUNT(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW continuous_view_2(bkt, maxl) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), max(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE FUNCTION lock_mattable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s', name); END; $$ LANGUAGE plpgsql; step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); step LockMat1: BEGIN; select lock_mattable(tab) FROM ( SELECT format('%I.%I',materialization_hypertable_schema, materialization_hypertable_name) as tab from timescaledb_information.continuous_aggregates where view_name::text like 'continuous_view_1') q ; lock_mattable ------------- step I1: INSERT INTO ts_continuous_test SELECT 0, i*10 FROM (SELECT generate_series(0, 10) AS i) AS i; step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); <waiting ...> step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); step UnlockMat1: ROLLBACK; step Refresh1: <... completed> step Refresh1_sel: select * from continuous_view_1 where bkt = 0 or bkt > 30 bkt|cnt ---+--- 0| 16 step Refresh2_sel: select * from continuous_view_2 where bkt = 0 or bkt > 30 order by bkt; bkt|maxl ---+---- 0| 100 starting permutation: Setup2 Refresh1 Refresh2 Refresh1_sel Refresh2_sel LockMat1 I2 Refresh1 Refresh2 UnlockMat1 Refresh1_sel Refresh2_sel step Setup2: CREATE MATERIALIZED VIEW continuous_view_1( bkt, cnt) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), COUNT(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW continuous_view_2(bkt, maxl) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), max(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE FUNCTION lock_mattable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s', name); END; $$ LANGUAGE plpgsql; step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); step Refresh1_sel: select * from continuous_view_1 where bkt = 0 or bkt > 30 bkt|cnt ---+--- 0| 5 step Refresh2_sel: select * from continuous_view_2 where bkt = 0 or bkt > 30 order by bkt; bkt|maxl ---+---- 0| 4 step LockMat1: BEGIN; select lock_mattable(tab) FROM ( SELECT format('%I.%I',materialization_hypertable_schema, materialization_hypertable_name) as tab from timescaledb_information.continuous_aggregates where view_name::text like 'continuous_view_1') q ; lock_mattable ------------- step I2: INSERT INTO ts_continuous_test SELECT 40, 1000 ; step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); <waiting ...> step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); step UnlockMat1: ROLLBACK; R1: NOTICE: continuous aggregate "continuous_view_1" is already up-to-date step Refresh1: <... completed> step Refresh1_sel: select * from continuous_view_1 where bkt = 0 or bkt > 30 bkt|cnt ---+--- 0| 5 step Refresh2_sel: select * from continuous_view_2 where bkt = 0 or bkt > 30 order by bkt; bkt|maxl ---+---- 0| 4 40|1000 starting permutation: Setup2 Refresh1 Refresh2 Refresh1_sel Refresh2_sel U1 U2 LInvRow Refresh1 Refresh2 UnlockInvRow Refresh1_sel Refresh2_sel step Setup2: CREATE MATERIALIZED VIEW continuous_view_1( bkt, cnt) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), COUNT(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW continuous_view_2(bkt, maxl) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), max(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE FUNCTION lock_mattable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s', name); END; $$ LANGUAGE plpgsql; step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); step Refresh1_sel: select * from continuous_view_1 where bkt = 0 or bkt > 30 bkt|cnt ---+--- 0| 5 step Refresh2_sel: select * from continuous_view_2 where bkt = 0 or bkt > 30 order by bkt; bkt|maxl ---+---- 0| 4 step U1: update ts_continuous_test SET val = 5555 where time < 10; step U2: update ts_continuous_test SET val = 5 where time > 15 and time < 25; step LInvRow: BEGIN; update _timescaledb_catalog.continuous_aggs_invalidation_threshold set watermark = 20 where hypertable_id in ( select raw_hypertable_id from _timescaledb_catalog.continuous_agg where user_view_name like 'continuous_view_1' ); step Refresh1: CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); <waiting ...> step Refresh2: CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); <waiting ...> step UnlockInvRow: ROLLBACK; step Refresh1: <... completed> step Refresh2: <... completed> step Refresh1_sel: select * from continuous_view_1 where bkt = 0 or bkt > 30 bkt|cnt ---+--- 0| 5 step Refresh2_sel: select * from continuous_view_2 where bkt = 0 or bkt > 30 order by bkt; bkt|maxl ---+---- 0|5555 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_watermark_concurrent_update.out�����������������0000664�0000000�0000000�00000046324�15100345067�0030762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s1_prepare s2_prepare s3_lock_invalidation s2_select s1_run_update s2_select s3_release_invalidation s2_select s1_select step s1_prepare: PREPARE pstmt AS SELECT * FROM cagg; step s2_prepare: PREPARE pstmt AS SELECT * FROM cagg; step s3_lock_invalidation: SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_enable ---------------------- (1 row) step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Finalize HashAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Append -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) (19 rows) step s1_run_update: CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); <waiting ...> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Finalize HashAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Append -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) (19 rows) step s3_release_invalidation: SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_release ----------------------- (1 row) step s1_run_update: <... completed> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, "time")) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, "time")) -> Result One-Time Filter: false (14 rows) step s1_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, "time")) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, "time")) -> Result One-Time Filter: false (14 rows) starting permutation: s3_lock_invalidation s2_select s1_run_update s2_select s3_release_invalidation s3_lock_invalidation s1_insert_more_data s1_run_update s2_select s3_release_invalidation s2_select step s3_lock_invalidation: SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_enable ---------------------- (1 row) step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Finalize HashAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Append -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) (19 rows) step s1_run_update: CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); <waiting ...> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Finalize HashAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Append -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial HashAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) (19 rows) step s3_release_invalidation: SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_release ----------------------- (1 row) step s1_run_update: <... completed> step s3_lock_invalidation: SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_enable ---------------------- (1 row) step s1_insert_more_data: INSERT INTO temperature VALUES('2020-01-02 23:59:59+0', 22); step s1_run_update: CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); <waiting ...> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Result -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) (13 rows) step s3_release_invalidation: SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_release ----------------------- (1 row) step s1_run_update: <... completed> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Thu Jan 02 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Thu Jan 02 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Result -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Thu Jan 02 16:00:00 2020 PST'::timestamp with time zone) (13 rows) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/cagg_watermark_concurrent_update_1.out���������������0000664�0000000�0000000�00000044254�15100345067�0031202�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s1_prepare s2_prepare s3_lock_invalidation s2_select s1_run_update s2_select s3_release_invalidation s2_select s1_select step s1_prepare: PREPARE pstmt AS SELECT * FROM cagg; step s2_prepare: PREPARE pstmt AS SELECT * FROM cagg; step s3_lock_invalidation: SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_enable ---------------------- step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Finalize GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, temperature."time")) -> Custom Scan (ChunkAppend) on temperature Order: time_bucket('@ 4 hours'::interval, temperature."time") -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) step s1_run_update: CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); <waiting ...> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Finalize GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, temperature."time")) -> Custom Scan (ChunkAppend) on temperature Order: time_bucket('@ 4 hours'::interval, temperature."time") -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) step s3_release_invalidation: SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_release ----------------------- step s1_run_update: <... completed> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, "time")) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, "time")) -> Result One-Time Filter: false step s1_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, "time")) -> Sort Sort Key: (time_bucket('@ 4 hours'::interval, "time")) -> Result One-Time Filter: false starting permutation: s3_lock_invalidation s2_select s1_run_update s2_select s3_release_invalidation s3_lock_invalidation s1_insert_more_data s1_run_update s2_select s3_release_invalidation s2_select step s3_lock_invalidation: SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_enable ---------------------- step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Finalize GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, temperature."time")) -> Custom Scan (ChunkAppend) on temperature Order: time_bucket('@ 4 hours'::interval, temperature."time") -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) step s1_run_update: CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); <waiting ...> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN ----------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _hyper_X_X_chunk.time_bucket -> Sort Sort Key: _hyper_X_X_chunk.time_bucket -> Seq Scan on _hyper_X_X_chunk Filter: (time_bucket < 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Finalize GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, temperature."time")) -> Custom Scan (ChunkAppend) on temperature Order: time_bucket('@ 4 hours'::interval, temperature."time") -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) -> Partial GroupAggregate Group Key: time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time") -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Sat Jan 01 16:00:00 2000 PST'::timestamp with time zone) step s3_release_invalidation: SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_release ----------------------- step s1_run_update: <... completed> step s3_lock_invalidation: SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_enable ---------------------- step s1_insert_more_data: INSERT INTO temperature VALUES('2020-01-02 23:59:59+0', 22); step s1_run_update: CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); <waiting ...> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Result -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Wed Jan 01 16:00:00 2020 PST'::timestamp with time zone) step s3_release_invalidation: SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); debug_waitpoint_release ----------------------- step s1_run_update: <... completed> step s2_select: EXPLAIN (COSTS OFF) EXECUTE pstmt; QUERY PLAN --------------------------------------------------------------------------------------------------------------------- Merge Append Sort Key: _materialized_hypertable_X.time_bucket -> Custom Scan (ChunkAppend) on _materialized_hypertable_X Order: _materialized_hypertable_X.time_bucket -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Thu Jan 02 16:00:00 2020 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk__materialized_hypertable_X_time_bucket_idx on _hyper_X_X_chunk Index Cond: (time_bucket < 'Thu Jan 02 16:00:00 2020 PST'::timestamp with time zone) -> GroupAggregate Group Key: (time_bucket('@ 4 hours'::interval, _hyper_X_X_chunk."time")) -> Result -> Index Scan Backward using _hyper_X_X_chunk_temperature_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= 'Thu Jan 02 16:00:00 2020 PST'::timestamp with time zone) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_chunk_race.out���������������������������0000664�0000000�0000000�00000010110�15100345067�0026703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s3_lock_compression s3_lock_decompression s1_compress s2_compress s3_unlock_compression s1_decompress s2_decompress s3_unlock_decompression step s3_lock_compression: SELECT debug_waitpoint_enable('compress_chunk_impl_start'); debug_waitpoint_enable ---------------------- step s3_lock_decompression: SELECT debug_waitpoint_enable('decompress_chunk_impl_start'); debug_waitpoint_enable ---------------------- step s1_compress: SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; <waiting ...> step s2_compress: SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; RESET client_min_messages; <waiting ...> step s3_unlock_compression: -- Ensure that we are waiting on our debug waitpoint and one chunk -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- compress_chunk_impl_start = 3379597659. -- 'SELECT relation::regclass, ....' can not be used, because it returns a field with a variable length SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND (locktype = 'advisory' or relation::regclass::text LIKE '%chunk') ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compress_chunk_impl_start'); locktype|mode |granted| objid --------+-------------+-------+---------- relation|ExclusiveLock|f | advisory|ShareLock |f |3379597659 debug_waitpoint_release ----------------------- step s1_compress: <... completed> compression_status ------------------ Uncompressed Uncompressed count ----- 2 compression_status ------------------ Compressed Compressed count ------- 1008050 step s2_compress: <... completed> compression_status ------------------ Uncompressed Uncompressed ERROR: chunk "_hyper_X_X_chunk" is already compressed step s1_decompress: SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; <waiting ...> step s2_decompress: SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; RESET client_min_messages; <waiting ...> step s3_unlock_decompression: -- Ensure that we are waiting on our debug waitpoint and one chunk -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- decompress_chunk_impl_start = 2415054640. -- 'SELECT relation::regclass, ....' can not be used, because it returns a field with a variable length SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND (locktype = 'advisory' or relation::regclass::text LIKE '%chunk') ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('decompress_chunk_impl_start'); locktype|mode |granted| objid --------+-------------+-------+---------- relation|ExclusiveLock|f | advisory|ShareLock |f |2415054640 debug_waitpoint_release ----------------------- step s1_decompress: <... completed> count ----- 2 compression_status ------------------ Uncompressed Uncompressed count ------- 1008050 step s2_decompress: <... completed> ERROR: chunk "_hyper_X_X_chunk" is already decompressed ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_conflicts_iso.out������������������������0000664�0000000�0000000�00000254146�15100345067�0027462�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 10 sessions starting permutation: LockChunk1 IB I1 C1 UnlockChunk Ic Cc SC1 S1 SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IB: BEGIN; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step S1: SELECT count(*) from ts_device_table; count ----- 10 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 starting permutation: LockChunk1 IBRR I1 C1 UnlockChunk Ic Cc SC1 S1 SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step S1: SELECT count(*) from ts_device_table; count ----- 10 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 starting permutation: LockChunk1 IBS I1 C1 UnlockChunk Ic Cc SC1 S1 SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step S1: SELECT count(*) from ts_device_table; count ----- 10 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 starting permutation: LockChunk1 IB Iu1 C1 UnlockChunk Ic Cc SC1 S1 SU SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IB: BEGIN; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step S1: SELECT count(*) from ts_device_table; count ----- 10 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 starting permutation: LockChunk1 IBRR Iu1 C1 UnlockChunk Ic Cc SC1 S1 SU SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step S1: SELECT count(*) from ts_device_table; count ----- 10 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 starting permutation: LockChunk1 IBS Iu1 C1 UnlockChunk Ic Cc SC1 S1 SU SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step S1: SELECT count(*) from ts_device_table; count ----- 10 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 starting permutation: LockChunk1 C1 IB I1 UnlockChunk Cc Ic SC1 SA SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step IB: BEGIN; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step I1: <... completed> step Ic: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: LockChunk1 C1 IBRR I1 UnlockChunk Cc Ic SC1 SA SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step I1: <... completed> step Ic: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: LockChunk1 C1 IBS I1 UnlockChunk Cc Ic SC1 SA SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step I1: <... completed> step Ic: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 0 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: LockChunk1 C1 IB Iu1 UnlockChunk Cc Ic SC1 SA SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step IB: BEGIN; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step Iu1: <... completed> step Ic: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 10 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: LockChunk1 C1 IBRR Iu1 UnlockChunk Cc Ic SC1 SA SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step Iu1: <... completed> step Ic: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 10 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: LockChunk1 C1 IBS Iu1 UnlockChunk Cc Ic SC1 SA SChunkStat step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step Iu1: <... completed> step Ic: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; count(*)|count(*) only --------+------------- 10| 10 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: C1 Cc LockChunkTuple IB I1 IN1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IB: BEGIN; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 starting permutation: C1 Cc LockChunkTuple IBRR I1 IN1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 starting permutation: C1 Cc LockChunkTuple IBS I1 IN1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 starting permutation: C1 Cc LockChunkTuple IB I1 INu1 UnlockChunkTuple Ic INc SChunkStat SU SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IB: BEGIN; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step INu1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 99 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 starting permutation: C1 Cc LockChunkTuple IBRR I1 INu1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step INu1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 starting permutation: C1 Cc LockChunkTuple IBS I1 INu1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step INu1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 starting permutation: C1 Cc LockChunkTuple IB Iu1 IN1 UnlockChunkTuple Ic INc SChunkStat SU SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IB: BEGIN; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunkTuple: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 starting permutation: C1 Cc LockChunkTuple IBRR Iu1 IN1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunkTuple: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 starting permutation: C1 Cc LockChunkTuple IBS Iu1 IN1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunkTuple: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 starting permutation: C1 Cc LockChunkTuple IB Iu1 INu1 UnlockChunkTuple Ic INc SChunkStat SU SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IB: BEGIN; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunkTuple: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step INu1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 99 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 starting permutation: C1 Cc LockChunkTuple IBRR Iu1 INu1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunkTuple: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step INu1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 starting permutation: C1 Cc LockChunkTuple IBS Iu1 INu1 UnlockChunkTuple Ic INc SChunkStat SA step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunkTuple: ROLLBACK; step Iu1: <... completed> step Ic: COMMIT; step INu1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IB I1 UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IB: BEGIN; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step I1: <... completed> step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IBRR I1 UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step I1: <... completed> step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IBS I1 UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step I1: <... completed> step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IB Iu1 UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IB: BEGIN; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Iu1: <... completed> step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IBRR Iu1 UnlockChunk Ic SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Iu1: <... completed> step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IBS Iu1 UnlockChunk Ic SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Iu1: <... completed> step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC IN1 UnlockChunk INc SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step IN1: <... completed> step INc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 RC INu1 UnlockChunk INc SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step UnlockChunk: ROLLBACK; step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step INu1: <... completed> step INc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 99 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IB I1 RC UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IB: BEGIN; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IBRR I1 RC UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IBS I1 RC UnlockChunk Ic SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IB Iu1 RC UnlockChunk Ic SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IB: BEGIN; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step Iu1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IBRR Iu1 RC UnlockChunk Ic SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBRR: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step Iu1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IBS Iu1 RC UnlockChunk Ic SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IBS: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step Iu1: INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step Iu1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 98 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 98 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 IN1 RC UnlockChunk INc SH SA SChunkStat step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step IN1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step INc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 SChunkStat LockChunk1 INu1 RC UnlockChunk INc SH SA SChunkStat SU step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step I1: INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step INu1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; <waiting ...> step RC: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step INu1: <... completed> step RC: <... completed> ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step INc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 1| 1 step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 1| 1| 100| 99 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step SU: SELECT * FROM ts_device_table WHERE value IN (98,99); time|device|location|value ----+------+--------+----- 1| 1| 100| 99 starting permutation: CA1 CAc LockChunkTuple DA1 SA SF UnlockChunkTuple DAc step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t step CAc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step DA1: BEGIN; SELECT CASE WHEN decompress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; <waiting ...> step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SF: step UnlockChunkTuple: ROLLBACK; step DA1: <... completed> compress -------- t step DAc: COMMIT; starting permutation: SB SA CA1 SA SF SR CAc step SB: BEGIN; step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; <waiting ...> step SA: SELECT * FROM ts_device_table; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 step SF: step SR: ROLLBACK; step CA1: <... completed> compress -------- t step CAc: COMMIT; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_ddl_iso.out������������������������������0000664�0000000�0000000�00000046037�15100345067�0026237�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 12 sessions starting permutation: LockChunk1 I1 C1 UnlockChunk Ic Cc SC1 S1 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; step SC1: SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text LIMIT 1; count(*)|count(*) only --------+------------- 11| 0 step S1: SELECT count(*) from ts_device_table; count ----- 31 starting permutation: LockChunk1 C1 I1 UnlockChunk Cc Ic step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); <waiting ...> step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step I1: <... completed> step Ic: COMMIT; starting permutation: LockChunk1 A1 C1 UnlockChunk Cc A2 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step A1: BEGIN; ALTER TABLE ts_device_table SET ( fillfactor = 80); <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step A1: <... completed> step C1: <... completed> ERROR: canceling statement due to lock timeout step Cc: COMMIT; step A2: COMMIT; starting permutation: LockChunk1 A1 C1 UnlockChunk A2 Cc step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step A1: BEGIN; ALTER TABLE ts_device_table SET ( fillfactor = 80); <waiting ...> step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step UnlockChunk: ROLLBACK; step A1: <... completed> step A2: COMMIT; step C1: <... completed> compress -------- t step Cc: COMMIT; starting permutation: LockChunk1 C1 D1 UnlockChunk Cc Dc step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step D1: BEGIN; SET LOCAL client_min_messages TO WARNING; SELECT decompress_chunk(ch) IS NOT NULL AS decompress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text LIMIT 1; decompress ---------- f step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step Dc: COMMIT; starting permutation: LockChunk1 C1 S1 UnlockChunk Cc SH step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step S1: SELECT count(*) from ts_device_table; count ----- 30 step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step Cc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 1 starting permutation: LockChunk1 C1 S1 UnlockChunk SH Cc step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; <waiting ...> step S1: SELECT count(*) from ts_device_table; count ----- 30 step UnlockChunk: ROLLBACK; step C1: <... completed> compress -------- t step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 0 step Cc: COMMIT; starting permutation: C1 Cc LockChunkTuple I1 IN1 UnlockChunkTuple Ic INc SChunkStat step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); <waiting ...> step UnlockChunkTuple: ROLLBACK; step I1: <... completed> step Ic: COMMIT; step IN1: <... completed> step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: C1 Cc I1 Ic LockChunkTuple I1 IN1 UnlockChunkTuple INc Ic SChunkStat step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step Ic: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 9 step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step UnlockChunkTuple: ROLLBACK; step INc: COMMIT; step Ic: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: C1 Cc LockChunkTuple IR1 INR1 UnlockChunkTuple Ic INc SChunkStat step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 1 step IR1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100) RETURNING *; <waiting ...> step INR1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) RETURNING *; <waiting ...> step UnlockChunkTuple: ROLLBACK; step IR1: <... completed> time|device|location|value ----+------+--------+----- 1| 1| 100| 100 step Ic: COMMIT; step INR1: <... completed> time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step INc: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: C1 Cc I1 Ic LockChunkTuple IR1 INR1 UnlockChunkTuple INc Ic SChunkStat step C1: BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; compress -------- t step Cc: COMMIT; step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step Ic: COMMIT; step LockChunkTuple: BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; chunk_status ------------ 9 step IR1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100) RETURNING *; time|device|location|value ----+------+--------+----- 1| 1| 100| 100 step INR1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) RETURNING *; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UnlockChunkTuple: ROLLBACK; step INc: COMMIT; step Ic: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 Ic SChunkStat LockChunk1 RC1 IN1 UnlockChunk INc SH SA SChunkStat step CA1: BEGIN; SELECT compress_chunk(ch) IS NOT NULL AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step Ic: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC1: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); <waiting ...> step UnlockChunk: ROLLBACK; step RC1: <... completed> step IN1: <... completed> step INc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SA: SELECT * FROM ts_device_table t ORDER BY t; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 1| 1| 100| 100 1| 1| 200| 100 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 10| 1| 100| 20 11| 1| 100| 20 12| 1| 100| 20 13| 1| 100| 20 14| 1| 100| 20 15| 1| 100| 20 16| 1| 100| 20 17| 1| 100| 20 18| 1| 100| 20 19| 1| 100| 20 20| 1| 100| 20 21| 1| 100| 20 22| 1| 100| 20 23| 1| 100| 20 24| 1| 100| 20 25| 1| 100| 20 26| 1| 100| 20 27| 1| 100| 20 28| 1| 100| 20 29| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 starting permutation: CA1 CAc I1 Ic SChunkStat LockChunk1 RC1 RC2 UnlockChunk SH SA SChunkStat step CA1: BEGIN; SELECT compress_chunk(ch) IS NOT NULL AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step Ic: COMMIT; step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 9 step LockChunk1: BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step RC1: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; <waiting ...> step RC2: DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name, false); END LOOP; END; $$; <waiting ...> step UnlockChunk: ROLLBACK; step RC1: <... completed> step RC2: <... completed> step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SA: SELECT * FROM ts_device_table t ORDER BY t; time|device|location|value ----+------+--------+----- 0| 1| 100| 20 1| 1| 100| 20 1| 1| 100| 100 2| 1| 100| 20 3| 1| 100| 20 4| 1| 100| 20 5| 1| 100| 20 6| 1| 100| 20 7| 1| 100| 20 8| 1| 100| 20 9| 1| 100| 20 10| 1| 100| 20 11| 1| 100| 20 12| 1| 100| 20 13| 1| 100| 20 14| 1| 100| 20 15| 1| 100| 20 16| 1| 100| 20 17| 1| 100| 20 18| 1| 100| 20 19| 1| 100| 20 20| 1| 100| 20 21| 1| 100| 20 22| 1| 100| 20 23| 1| 100| 20 24| 1| 100| 20 25| 1| 100| 20 26| 1| 100| 20 27| 1| 100| 20 28| 1| 100| 20 29| 1| 100| 20 step SChunkStat: SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); status ------ 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_dml_iso.out������������������������������0000664�0000000�0000000�00000051424�15100345067�0026244�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������unused step name: S1 unused step name: SA unused step name: SC1 unused step name: SChunkStat Parsed test spec with 7 sessions starting permutation: CA1 CAc SH I1 Ic SH UPD1 UPDc SH DEL1 DELc SH UPD1 UPDc SH step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 starting permutation: IN1 INc CA1 CAc SH SS DEL1 UPD1 DELc UPDc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; <waiting ...> step DELc: COMMIT; step UPD1: <... completed> step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: IN1 INc CA1 CAc SH SS UPD1 DEL1 UPDc DELc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; <waiting ...> step UPDc: COMMIT; step DEL1: <... completed> step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: NOS CA1 CAc SH I1 Ic SH UPD1 UPDc SH DEL1 DELc SH UPD1 UPDc SH step NOS: ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_orderby='time'); step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step I1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); step Ic: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 starting permutation: NOS IN1 INc CA1 CAc SH SS DEL1 UPD1 DELc UPDc SH SS step NOS: ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_orderby='time'); step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; <waiting ...> step DELc: COMMIT; step UPD1: <... completed> step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: NOS IN1 INc CA1 CAc SH SS UPD1 DEL1 UPDc DELc SH SS step NOS: ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_orderby='time'); step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; <waiting ...> step UPDc: COMMIT; step DEL1: <... completed> step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: IN1 INc CA1 CAc SH SS DEL1 UPDrr DELc UPDc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step DEL1: BEGIN; DELETE from ts_device_table WHERE location = 200; step UPDrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; UPDATE ts_device_table SET value = 4 WHERE location = 200; <waiting ...> step DELc: COMMIT; step UPDrr: <... completed> ERROR: could not serialize access due to concurrent update step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: IN1 INc CA1 CAc SH SS UPD1 DELrr UPDc DELc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UPD1: BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; step DELrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; DELETE from ts_device_table WHERE location = 200; <waiting ...> step UPDc: COMMIT; step DELrr: <... completed> ERROR: could not serialize access due to concurrent update step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 4 starting permutation: IN1 INc CA1 CAc SH SS DELrr UPDrr DELc UPDc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step DELrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; DELETE from ts_device_table WHERE location = 200; step UPDrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; UPDATE ts_device_table SET value = 4 WHERE location = 200; <waiting ...> step DELc: COMMIT; step UPDrr: <... completed> ERROR: could not serialize access due to concurrent update step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: IN1 INc CA1 CAc SH SS UPDrr DELrr UPDc DELc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UPDrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; UPDATE ts_device_table SET value = 4 WHERE location = 200; step DELrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; DELETE from ts_device_table WHERE location = 200; <waiting ...> step UPDc: COMMIT; step DELrr: <... completed> ERROR: could not serialize access due to concurrent update step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 4 starting permutation: IN1 INc CA1 CAc SH SS DELrr UPDs DELc UPDc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step DELrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; DELETE from ts_device_table WHERE location = 200; step UPDs: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; UPDATE ts_device_table SET value = 4 WHERE location = 200; <waiting ...> step DELc: COMMIT; step UPDs: <... completed> ERROR: could not serialize access due to concurrent update step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: IN1 INc CA1 CAc SH SS UPDrr DELs UPDc DELc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UPDrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; UPDATE ts_device_table SET value = 4 WHERE location = 200; step DELs: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; DELETE from ts_device_table WHERE location = 200; <waiting ...> step UPDc: COMMIT; step DELs: <... completed> ERROR: could not serialize access due to concurrent update step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 4 starting permutation: IN1 INc CA1 CAc SH SS DELs UPDrr DELc UPDc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step DELs: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; DELETE from ts_device_table WHERE location = 200; step UPDrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; UPDATE ts_device_table SET value = 4 WHERE location = 200; <waiting ...> step DELc: COMMIT; step UPDrr: <... completed> ERROR: could not serialize access due to concurrent update step UPDc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- starting permutation: IN1 INc CA1 CAc SH SS UPDs DELrr UPDc DELc SH SS step IN1: BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); step INc: COMMIT; step CA1: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; compress -------- t t t step CAc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 100 step UPDs: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; UPDATE ts_device_table SET value = 4 WHERE location = 200; step DELrr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; DELETE from ts_device_table WHERE location = 200; <waiting ...> step UPDc: COMMIT; step DELrr: <... completed> ERROR: could not serialize access due to concurrent update step DELc: COMMIT; step SH: SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); total_chunks|number_compressed_chunks ------------+------------------------ 3| 3 step SS: SELECT * FROM ts_device_table WHERE location = 200; time|device|location|value ----+------+--------+----- 1| 1| 200| 4 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_freeze.out�������������������������������0000664�0000000�0000000�00000020562�15100345067�0026075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1_select_count s2_select_count_and_stats step s1_select_count: SELECT count(*) FROM sensor_data; count ----- 16850 step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 starting permutation: s1_select_count s1_compress s1_select_count s2_select_count_and_stats step s1_select_count: SELECT count(*) FROM sensor_data; count ----- 16850 step s1_compress: SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; count ----- 2 step s1_select_count: SELECT count(*) FROM sensor_data; count ----- 16850 step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Compressed | 2 starting permutation: s2_lock_compression s2_select_count_and_stats s1_compress s2_select_count_and_stats s2_unlock_compression s2_select_count_and_stats step s2_lock_compression: SELECT debug_waitpoint_enable('compression_done_before_truncate_uncompressed'); debug_waitpoint_enable ---------------------- step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 step s1_compress: SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; <waiting ...> step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 step s2_unlock_compression: SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND (locktype = 'advisory' or relation::regclass::text LIKE '%chunk') ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_before_truncate_uncompressed'); locktype|mode |granted| objid --------+---------+-------+--------- advisory|ShareLock|f |113732026 debug_waitpoint_release ----------------------- step s1_compress: <... completed> count ----- 2 step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Compressed | 2 starting permutation: s2_lock_compression_after_truncate s2_select_count_and_stats s1_compress s2_unlock_compression_after_truncate s2_select_count_and_stats step s2_lock_compression_after_truncate: SELECT debug_waitpoint_enable('compression_done_after_truncate_uncompressed'); debug_waitpoint_enable ---------------------- step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 step s1_compress: SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; <waiting ...> step s2_unlock_compression_after_truncate: SELECT locktype, mode, granted, objid FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_after_truncate_uncompressed'); locktype|mode |granted|objid --------+-------------------+-------+----- relation|AccessExclusiveLock|t | relation|ExclusiveLock |t | relation|ShareLock |t | debug_waitpoint_release ----------------------- step s1_compress: <... completed> count ----- 2 step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Compressed | 2 starting permutation: s2_lock_compression_after_delete s2_select_count_and_stats s1_compress_delete s2_select_count_and_stats s2_unlock_compression_after_delete s2_select_count_and_stats step s2_lock_compression_after_delete: SELECT debug_waitpoint_enable('compression_done_after_delete_uncompressed'); debug_waitpoint_enable ---------------------- step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 step s1_compress_delete: SET timescaledb.compress_truncate_behaviour TO truncate_disabled; SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; <waiting ...> step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 step s2_unlock_compression_after_delete: SELECT locktype, mode, granted, objid FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_after_delete_uncompressed'); locktype|mode |granted|objid --------+----------------+-------+----- relation|ExclusiveLock |t | relation|RowExclusiveLock|t | debug_waitpoint_release ----------------------- step s1_compress_delete: <... completed> count ----- 2 step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Compressed | 2 starting permutation: s2_lock_compression_after_truncate_or_delete s2_select_count_and_stats s1_compress_truncate_or_delete s2_unlock_compression_after_truncate_or_delete s2_select_count_and_stats step s2_lock_compression_after_truncate_or_delete: SELECT debug_waitpoint_enable('compression_done_after_truncate_or_delete_uncompressed'); debug_waitpoint_enable ---------------------- step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Uncompressed | 2 step s1_compress_truncate_or_delete: SET timescaledb.compress_truncate_behaviour TO truncate_or_delete; SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; <waiting ...> step s2_unlock_compression_after_truncate_or_delete: SELECT locktype, mode, granted, objid FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_after_truncate_or_delete_uncompressed'); locktype|mode |granted|objid --------+-------------------+-------+----- relation|AccessExclusiveLock|t | relation|ExclusiveLock |t | relation|ShareLock |t | debug_waitpoint_release ----------------------- step s1_compress_truncate_or_delete: <... completed> count ----- 2 step s2_select_count_and_stats: SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; count ----- 16850 compression_status|count ------------------+----- Compressed | 2 ����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_merge_race.out���������������������������0000664�0000000�0000000�00000010367�15100345067�0026710�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s3_count_chunks_pre_compression s3_lock_compression s1_compress_first_half_of_chunks s2_compress_second_half_of_chunks s3_unlock_compression s3_count_chunks_post_compression step s3_count_chunks_pre_compression: select count(*), 48 as expected from show_chunks('sensor_data'); count|expected -----+-------- 48| 48 step s3_lock_compression: SELECT debug_waitpoint_enable('compress_chunk_impl_start'); debug_waitpoint_enable ---------------------- step s1_compress_first_half_of_chunks: call compress_chunks_in_individual_transactions( $$ select show_chunks('sensor_data') limit 24 $$ ); <waiting ...> step s2_compress_second_half_of_chunks: call compress_chunks_in_individual_transactions($$select show_chunks('sensor_data') i offset 24$$); <waiting ...> step s3_unlock_compression: SELECT debug_waitpoint_release('compress_chunk_impl_start'); <waiting ...> step s1_compress_first_half_of_chunks: <... completed> step s2_compress_second_half_of_chunks: <... completed> step s3_unlock_compression: <... completed> debug_waitpoint_release ----------------------- step s3_count_chunks_post_compression: select count(*), 24 as expected from show_chunks('sensor_data'); count|expected -----+-------- 24| 24 starting permutation: s3_count_chunks_pre_compression s3_lock_compression s1_compress_first_two_by_two s2_compress_second_two_by_two s3_unlock_compression s3_count_chunks_post_compression step s3_count_chunks_pre_compression: select count(*), 48 as expected from show_chunks('sensor_data'); count|expected -----+-------- 48| 48 step s3_lock_compression: SELECT debug_waitpoint_enable('compress_chunk_impl_start'); debug_waitpoint_enable ---------------------- step s1_compress_first_two_by_two: call compress_chunks_in_individual_transactions( $$ select i.show_chunks from ( select row_number() over () as row_number, i as show_chunks from show_chunks('sensor_data') i ) i where i.row_number%4 in (1,2) $$); <waiting ...> step s2_compress_second_two_by_two: call compress_chunks_in_individual_transactions( $$ select i.show_chunks from ( select row_number() over () as row_number, i as show_chunks from show_chunks('sensor_data') i ) i where i.row_number%4 in (3,0) $$); <waiting ...> step s3_unlock_compression: SELECT debug_waitpoint_release('compress_chunk_impl_start'); <waiting ...> step s1_compress_first_two_by_two: <... completed> step s2_compress_second_two_by_two: <... completed> step s3_unlock_compression: <... completed> debug_waitpoint_release ----------------------- step s3_count_chunks_post_compression: select count(*), 24 as expected from show_chunks('sensor_data'); count|expected -----+-------- 24| 24 starting permutation: s1_compress_single_chunk s1_compress_all_chunks_single_transaction s3_select_on_compressed_chunk s3_wait_for_finish s1_compress_finish step s1_compress_single_chunk: select compress_chunk(c, true) from show_chunks('sensor_data') c limit 1; compress_chunk ------------------------------------------ _timescaledb_internal._hyper_X_X_chunk step s1_compress_all_chunks_single_transaction: BEGIN; select count(compress_chunk(c, true)) from show_chunks('sensor_data') c; s1: NOTICE: chunk "_hyper_X_X_chunk" is already converted to columnstore count ----- 48 step s3_select_on_compressed_chunk: DO $$ DECLARE hyper_id int; chunk_id int; BEGIN SELECT h.compressed_hypertable_id, c.compressed_chunk_id INTO hyper_id, chunk_id FROM _timescaledb_catalog.hypertable h INNER JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id WHERE h.table_name = 'sensor_data' AND c.compressed_chunk_id IS NOT NULL; EXECUTE format('SELECT * FROM _timescaledb_internal.compress_hyper_%s_%s_chunk WHERE sensor_id = 40 AND temperature IS NOT NULL;', hyper_id, chunk_id); END; $$; step s3_wait_for_finish: step s1_compress_finish: COMMIT; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/compression_recompress.out���������������������������0000664�0000000�0000000�00000124651�15100345067�0027003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s1_begin s1_recompress_chunk s2_select_from_compressed_chunk s2_wait_for_finish s1_rollback step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_select_from_compressed_chunk: SELECT sum(temperature) > 1 FROM sensor_data WHERE sensor_id = 2; ?column? -------- t step s2_wait_for_finish: step s1_rollback: ROLLBACK; starting permutation: s1_compress s3_block_chunk_insert s2_insert_do_nothing s1_decompress s1_compress s3_release_chunk_insert step s1_compress: SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; compression_status ------------------ Compressed count ----- 1 compression_status ------------------ Compressed count ----- 15840 step s3_block_chunk_insert: SELECT debug_waitpoint_enable('chunk_insert_before_lock'); debug_waitpoint_enable ---------------------- step s2_insert_do_nothing: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; <waiting ...> step s1_decompress: SELECT count(*) FROM (SELECT decompress_chunk(i) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; count ----- 1 compression_status ------------------ Uncompressed count ----- 15840 step s1_compress: SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; compression_status ------------------ Uncompressed count ----- 1 compression_status ------------------ Compressed count ----- 15840 step s3_release_chunk_insert: SELECT debug_waitpoint_release('chunk_insert_before_lock'); debug_waitpoint_release ----------------------- step s2_insert_do_nothing: <... completed> starting permutation: s1_show_chunk_state s2_begin s2_insert_do_nothing s1_begin s1_recompress_chunk s2_insert_do_nothing s2_wait_for_finish s2_commit s1_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_insert_do_nothing: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_insert_do_nothing: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; step s2_wait_for_finish: step s2_commit: COMMIT; step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 starting permutation: s1_show_chunk_state s2_begin s2_insert_do_nothing s1_begin s1_recompress_chunk s2_insert_existing_do_nothing s2_wait_for_finish s2_commit s1_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_insert_do_nothing: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_insert_existing_do_nothing: INSERT INTO sensor_data SELECT time, sensor_id, 1.0, 1.0 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO NOTHING; step s2_wait_for_finish: step s2_commit: COMMIT; step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 starting permutation: s1_show_chunk_state s2_begin s2_insert_do_nothing s1_recompress_chunk s2_wait_for_finish s2_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_insert_do_nothing: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_wait_for_finish: step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 starting permutation: s1_show_chunk_state s2_begin s2_insert_existing_do_nothing s1_recompress_chunk s2_wait_for_finish s2_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_insert_existing_do_nothing: INSERT INTO sensor_data SELECT time, sensor_id, 1.0, 1.0 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO NOTHING; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_wait_for_finish: step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 starting permutation: s1_recompress_chunk s1_show_chunk_state s1_insert_for_recompression s1_show_chunk_state s2_begin s2_insert_existing_do_nothing s1_recompress_chunk s2_wait_for_finish s2_commit s1_show_chunk_state step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 1 count ----- 15840 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_begin: BEGIN; step s2_insert_existing_do_nothing: INSERT INTO sensor_data SELECT time, sensor_id, 1.0, 1.0 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO NOTHING; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_wait_for_finish: step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 starting permutation: s1_show_chunk_state s1_begin s1_recompress_chunk s2_upsert s1_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_upsert: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 100, 9999, 9999), ('2022-01-01 21:00'::timestamptz, 101, 9999, 9999) ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; <waiting ...> step s1_commit: COMMIT; step s2_upsert: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 2 starting permutation: s1_show_chunk_state s1_begin s1_recompress_chunk s2_upsert_existing s1_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_upsert_existing: INSERT INTO sensor_data SELECT time, sensor_id, 9999, 9999 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; <waiting ...> step s1_commit: COMMIT; step s2_upsert_existing: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1 starting permutation: s1_show_chunk_state s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_upsert s2_wait_for_finish s1_commit s1_show_chunk_state s2_show_updated_count s3_release_exclusive_lock step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_upsert: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 100, 9999, 9999), ('2022-01-01 21:00'::timestamptz, 101, 9999, 9999) ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; step s2_wait_for_finish: step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 2 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_show_chunk_state s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_upsert_existing s2_wait_for_finish s1_commit s1_show_chunk_state s2_show_updated_count s3_release_exclusive_lock step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_upsert_existing: INSERT INTO sensor_data SELECT time, sensor_id, 9999, 9999 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; step s2_wait_for_finish: step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_show_chunk_state s2_begin s2_upsert s1_recompress_chunk s2_wait_for_finish s2_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_upsert: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 100, 9999, 9999), ('2022-01-01 21:00'::timestamptz, 101, 9999, 9999) ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_wait_for_finish: step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 2 starting permutation: s1_show_chunk_state s2_begin s2_upsert_existing s1_recompress_chunk s2_wait_for_finish s2_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_upsert_existing: INSERT INTO sensor_data SELECT time, sensor_id, 9999, 9999 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_wait_for_finish: step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1 starting permutation: s1_recompress_chunk s1_insert_for_recompression s1_show_chunk_state s2_begin s2_upsert_existing s1_recompress_chunk s2_wait_for_finish s2_commit s1_show_chunk_state s2_show_updated_count step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_begin: BEGIN; step s2_upsert_existing: INSERT INTO sensor_data SELECT time, sensor_id, 9999, 9999 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_wait_for_finish: step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1 starting permutation: s1_show_chunk_state s3_begin s1_begin s3_delete_uncompressed s1_recompress_chunk s2_insert_do_nothing s3_rollback s1_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_begin: BEGIN; step s1_begin: BEGIN; step s3_delete_uncompressed: DELETE FROM sensor_data WHERE sensor_id = 11; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; <waiting ...> step s2_insert_do_nothing: INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; step s3_rollback: ROLLBACK; step s1_recompress_chunk: <... completed> recompress ---------- 1 step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15842 starting permutation: s1_show_chunk_state s1_begin s1_recompress_chunk s2_delete_compressed s1_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_delete_compressed: DELETE FROM sensor_data WHERE sensor_id = 1; <waiting ...> step s1_commit: COMMIT; step s2_delete_compressed: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 1 count ----- 14400 starting permutation: s1_show_chunk_state s1_begin s1_recompress_chunk s2_delete_uncompressed s1_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_delete_uncompressed: DELETE FROM sensor_data WHERE sensor_id = 11; <waiting ...> step s1_commit: COMMIT; step s2_delete_uncompressed: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 1 count ----- 14400 starting permutation: s1_recompress_chunk s1_insert_for_recompression s1_show_chunk_state s1_begin s1_recompress_chunk s2_delete_recompressed s1_commit s1_show_chunk_state step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_delete_recompressed: DELETE FROM sensor_data WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; <waiting ...> step s1_commit: COMMIT; step s2_delete_recompressed: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14520 starting permutation: s1_show_chunk_state s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_delete_compressed s2_wait_for_finish s1_commit s1_show_chunk_state s3_release_exclusive_lock step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_delete_compressed: DELETE FROM sensor_data WHERE sensor_id = 1; step s2_wait_for_finish: step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14400 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_show_chunk_state s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_delete_uncompressed s1_commit s1_show_chunk_state s3_release_exclusive_lock step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_delete_uncompressed: DELETE FROM sensor_data WHERE sensor_id = 11; step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14400 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_recompress_chunk s3_block_exclusive_lock s1_insert_for_recompression s1_show_chunk_state s1_begin s1_recompress_chunk s2_delete_recompressed s1_commit s1_show_chunk_state s3_release_exclusive_lock step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_delete_recompressed: DELETE FROM sensor_data WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14520 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_show_chunk_state s2_begin s2_delete_uncompressed s1_recompress_chunk s2_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_delete_uncompressed: DELETE FROM sensor_data WHERE sensor_id = 11; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; <waiting ...> step s2_commit: COMMIT; step s1_recompress_chunk: <... completed> ERROR: aborting recompression due to concurrent updates on uncompressed data, retrying with next policy run step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14400 starting permutation: s1_show_chunk_state s2_begin s2_delete_compressed s1_recompress_chunk s2_commit s1_show_chunk_state step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_delete_compressed: DELETE FROM sensor_data WHERE sensor_id = 1; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14400 starting permutation: s1_recompress_chunk s1_insert_for_recompression s1_show_chunk_state s2_begin s2_delete_recompressed s1_recompress_chunk s2_commit s1_show_chunk_state step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_begin: BEGIN; step s2_delete_recompressed: DELETE FROM sensor_data WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; <waiting ...> step s2_commit: COMMIT; step s1_recompress_chunk: <... completed> ERROR: aborting recompression due to concurrent updates on compressed data, retrying with next policy run step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 14520 starting permutation: s1_show_chunk_state s1_begin s1_recompress_chunk s2_update_compressed s1_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_update_compressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 1; <waiting ...> step s1_commit: COMMIT; step s2_update_compressed: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1440 starting permutation: s1_show_chunk_state s1_begin s1_recompress_chunk s2_update_uncompressed s1_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_update_uncompressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 11; <waiting ...> step s1_commit: COMMIT; step s2_update_uncompressed: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1440 starting permutation: s1_recompress_chunk s1_insert_for_recompression s1_begin s1_recompress_chunk s2_update_recompressed s1_commit s1_show_chunk_state s2_show_updated_count step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s2_update_recompressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; <waiting ...> step s1_commit: COMMIT; step s2_update_recompressed: <... completed> step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1380 starting permutation: s1_show_chunk_state s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_update_compressed s2_wait_for_finish s1_commit s1_show_chunk_state s2_show_updated_count s3_release_exclusive_lock step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_update_compressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 1; step s2_wait_for_finish: step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1440 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_show_chunk_state s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_update_uncompressed s1_commit s1_show_chunk_state s2_show_updated_count s3_release_exclusive_lock step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_update_uncompressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 11; step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1440 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_recompress_chunk s1_insert_for_recompression s3_block_exclusive_lock s1_begin s1_recompress_chunk s2_update_recompressed s1_commit s1_show_chunk_state s2_show_updated_count s3_release_exclusive_lock step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s3_block_exclusive_lock: BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; step s1_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_update_recompressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; step s1_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1380 step s3_release_exclusive_lock: ROLLBACK; starting permutation: s1_show_chunk_state s2_begin s2_update_uncompressed s1_recompress_chunk s2_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_update_uncompressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 11; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; <waiting ...> step s2_commit: COMMIT; step s1_recompress_chunk: <... completed> ERROR: aborting recompression due to concurrent updates on uncompressed data, retrying with next policy run step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1440 starting permutation: s1_show_chunk_state s2_begin s2_update_compressed s1_recompress_chunk s2_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_begin: BEGIN; step s2_update_compressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 1; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; ERROR: aborting recompression due to concurrent DML on uncompressed data, retrying with next policy run step s2_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1440 starting permutation: s1_recompress_chunk s1_insert_for_recompression s1_show_chunk_state s2_begin s2_update_recompressed s1_recompress_chunk s2_commit s1_show_chunk_state s2_show_updated_count step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s1_insert_for_recompression: INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_begin: BEGIN; step s2_update_recompressed: UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; <waiting ...> step s2_commit: COMMIT; step s1_recompress_chunk: <... completed> ERROR: aborting recompression due to concurrent updates on compressed data, retrying with next policy run step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15900 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 1380 starting permutation: s1_show_chunk_state s1_begin s3_begin s1_recompress_chunk s3_recompress_chunk s1_commit s3_commit s1_show_chunk_state s2_show_updated_count step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 9 count ----- 15840 step s1_begin: BEGIN; step s3_begin: BEGIN; step s1_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; recompress ---------- 1 step s3_recompress_chunk: SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; <waiting ...> step s1_commit: COMMIT; step s3_recompress_chunk: <... completed> recompress ---------- 1 step s3_commit: COMMIT; step s1_show_chunk_state: SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; status ------ 1 count ----- 15840 step s2_show_updated_count: SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; count ----- 0 ���������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/concurrent_decompress_update.out���������������������0000664�0000000�0000000�00000001541�15100345067�0030140�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s2_explain_update s1_begin s1_decompress s2_explain_update s1_commit s2_explain_update compression_status ------------------ Compressed step s2_explain_update: UPDATE sensor_data SET cpu = cpu + 1 WHERE cpu = 0.1111111; step s1_begin: BEGIN; step s1_decompress: SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); count ----- 1 compression_status ------------------ Uncompressed step s2_explain_update: UPDATE sensor_data SET cpu = cpu + 1 WHERE cpu = 0.1111111; <waiting ...> step s1_commit: COMMIT; step s2_explain_update: <... completed> step s2_explain_update: UPDATE sensor_data SET cpu = cpu + 1 WHERE cpu = 0.1111111; ���������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/deadlock_drop_chunks_compress.out��������������������0000664�0000000�0000000�00000015431�15100345067�0030253�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1_drop s1_commit s2_compress_chunk_1 s2_compress_chunk_2 s2_commit step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); count ----- 2 step s1_commit: COMMIT; step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; ERROR: chunk not found step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; ERROR: current transaction is aborted, commands ignored until end of transaction block step s2_commit: COMMIT; starting permutation: s1_drop s2_compress_chunk_1 s1_commit s2_compress_chunk_2 s2_commit step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); count ----- 2 step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; <waiting ...> step s1_commit: COMMIT; step s2_compress_chunk_1: <... completed> ERROR: chunk deleted by other transaction step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; ERROR: current transaction is aborted, commands ignored until end of transaction block step s2_commit: COMMIT; starting permutation: s1_drop s2_compress_chunk_1 s2_compress_chunk_2 s1_commit s2_commit step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); count ----- 2 step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; <waiting ...> step s2_compress_chunk_1: <... completed> ERROR: canceling statement due to lock timeout step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; ERROR: current transaction is aborted, commands ignored until end of transaction block step s1_commit: COMMIT; step s2_commit: COMMIT; starting permutation: s1_drop s2_compress_chunk_1 s2_compress_chunk_2 s2_commit s1_commit step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); count ----- 2 step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; <waiting ...> step s2_compress_chunk_1: <... completed> ERROR: canceling statement due to lock timeout step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; ERROR: current transaction is aborted, commands ignored until end of transaction block step s2_commit: COMMIT; step s1_commit: COMMIT; starting permutation: s2_compress_chunk_1 s1_drop s1_commit s2_compress_chunk_2 s2_commit step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; count ----- 1 step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); <waiting ...> step s1_drop: <... completed> ERROR: some chunks could not be read since they are being concurrently updated step s1_commit: COMMIT; step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; count ----- 1 step s2_commit: COMMIT; starting permutation: s2_compress_chunk_1 s1_drop s2_compress_chunk_2 s1_commit s2_commit step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; count ----- 1 step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); <waiting ...> step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; count ----- 1 step s1_drop: <... completed> ERROR: some chunks could not be read since they are being concurrently updated step s1_commit: COMMIT; step s2_commit: COMMIT; starting permutation: s2_compress_chunk_1 s1_drop s2_compress_chunk_2 s2_commit s1_commit step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; count ----- 1 step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); <waiting ...> step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; count ----- 1 step s2_commit: COMMIT; step s1_drop: <... completed> count ----- 2 step s1_commit: COMMIT; starting permutation: s2_compress_chunk_1 s2_compress_chunk_2 s1_drop s1_commit s2_commit step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; count ----- 1 step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; count ----- 1 step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); <waiting ...> step s1_drop: <... completed> ERROR: some chunks could not be read since they are being concurrently updated step s1_commit: COMMIT; step s2_commit: COMMIT; starting permutation: s2_compress_chunk_1 s2_compress_chunk_2 s1_drop s2_commit s1_commit step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; count ----- 1 step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; count ----- 1 step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); <waiting ...> step s2_commit: COMMIT; step s1_drop: <... completed> count ----- 2 step s1_commit: COMMIT; starting permutation: s2_compress_chunk_1 s2_compress_chunk_2 s2_commit s1_drop s1_commit step s2_compress_chunk_1: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; count ----- 1 step s2_compress_chunk_2: SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; count ----- 1 step s2_commit: COMMIT; step s1_drop: SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); count ----- 2 step s1_commit: COMMIT; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/deadlock_drop_index_vacuum.out�����������������������0000664�0000000�0000000�00000001204�15100345067�0027525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 4 sessions starting permutation: S1_lock S3_vacuum S2_lock S1_commit S4_drop_index S2_commit step S1_lock: LOCK TABLE _timescaledb_internal.metrics_chunk_2 IN ACCESS EXCLUSIVE MODE; step S3_vacuum: VACUUM ANALYZE _timescaledb_internal.metrics_chunk_2; <waiting ...> step S2_lock: LOCK TABLE _timescaledb_internal.metrics_chunk_2 IN ACCESS EXCLUSIVE MODE; <waiting ...> step S1_commit: COMMIT; step S2_lock: <... completed> step S4_drop_index: DROP INDEX metrics_device_time_idx; <waiting ...> step S2_commit: COMMIT; step S3_vacuum: <... completed> step S4_drop_index: <... completed> ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/deadlock_recompress_chunk.out������������������������0000664�0000000�0000000�00000002333�15100345067�0027370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: recompress_insert_rows lock_after_decompress recompress_chunks_start query_start unlock_after_decompress count ----- 1 step recompress_insert_rows: INSERT INTO hyper SELECT to_timestamp(ser), ser, ser+100 FROM generate_series(0,100) ser; step lock_after_decompress: SELECT count(*) FROM show_chunks('hyper'); DO $$ DECLARE chunk regclass; BEGIN SELECT format('%I.%I', c.schema_name, c.table_name)::regclass INTO chunk FROM show_chunks('hyper'), _timescaledb_catalog.chunk p, _timescaledb_catalog.chunk c WHERE p.compressed_chunk_id = c.id AND format('%I.%I', p.schema_name, p.table_name)::regclass = show_chunks; EXECUTE format('LOCK TABLE %s IN EXCLUSIVE MODE', chunk); END; $$; count ----- 1 step recompress_chunks_start: DO $$ DECLARE chunk regclass; BEGIN SELECT show_chunks('hyper') INTO chunk; PERFORM compress_chunk(chunk); END; $$; <waiting ...> step query_start: SELECT count(*) FROM hyper; <waiting ...> step unlock_after_decompress: ROLLBACK; step recompress_chunks_start: <... completed> step query_start: <... completed> count ----- 1102 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/decompression_chunk_and_parallel_query.out�����������0000664�0000000�0000000�00000002217�15100345067�0032156�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s2_read_sensor_data s1_begin s1_decompress s2_read_sensor_data s1_commit s2_read_sensor_data compression_status ------------------ Compressed step s2_read_sensor_data: SELECT FROM sensor_data; SELECT compression_status FROM chunk_compression_stats('sensor_data'); compression_status ------------------ Compressed step s1_begin: BEGIN; step s1_decompress: SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); count ----- 1 compression_status ------------------ Uncompressed step s2_read_sensor_data: SELECT FROM sensor_data; SELECT compression_status FROM chunk_compression_stats('sensor_data'); <waiting ...> step s1_commit: COMMIT; step s2_read_sensor_data: <... completed> compression_status ------------------ Uncompressed step s2_read_sensor_data: SELECT FROM sensor_data; SELECT compression_status FROM chunk_compression_stats('sensor_data'); compression_status ------------------ Uncompressed ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/decompression_chunk_and_parallel_query_wo_idx.out����0000664�0000000�0000000�00000005203�15100345067�0033525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s3_lock_decompression_locks s2_read_sensor_data s1_decompress s2_read_sensor_data s3_unlock_decompression_before_reindex_lock s2_read_sensor_data s3_unlock_decompression_after_reindex_lock s2_read_sensor_data compression_status ------------------ Compressed step s3_lock_decompression_locks: -- This waitpoint is defined before the decompressed chunk is re-indexed. Up to this -- point parallel SELECTs should be possible. SELECT debug_waitpoint_enable('decompress_chunk_impl_before_reindex'); -- This waitpoint is defined after all locks for the decompression and the deletion -- of the compressed chunk are requested. SELECT debug_waitpoint_enable('decompress_chunk_impl_after_reindex'); debug_waitpoint_enable ---------------------- debug_waitpoint_enable ---------------------- step s2_read_sensor_data: SELECT FROM sensor_data; step s1_decompress: SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); count ----- 1 compression_status ------------------ Uncompressed step s2_read_sensor_data: SELECT FROM sensor_data; step s3_unlock_decompression_before_reindex_lock: -- Ensure that we are waiting on our debug waitpoint -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- decompress_chunk_impl_before_reindex = 3966149665. SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND locktype = 'advisory' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('decompress_chunk_impl_before_reindex'); locktype|mode|granted|objid --------+----+-------+----- debug_waitpoint_release ----------------------- step s2_read_sensor_data: SELECT FROM sensor_data; step s3_unlock_decompression_after_reindex_lock: -- Ensure that we are waiting on our debug waitpoint -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- decompress_chunk_impl_after_reindex = 1858017383. SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND locktype = 'advisory' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('decompress_chunk_impl_after_reindex'); locktype|mode|granted|objid --------+----+-------+----- debug_waitpoint_release ----------------------- step s2_read_sensor_data: SELECT FROM sensor_data; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/detach_chunk_isolation.out���������������������������0000664�0000000�0000000�00000012160�15100345067�0026670�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 4 sessions starting permutation: s2_wait_before_lock s1b s1_detach s2_show_num_rows s3_insert s2_show_num_rows s2_release_lock s3_insert s1c s2_show_num_rows s2_show_num_chunks s2_show_chunk_rows step s2_wait_before_lock: SELECT debug_waitpoint_enable('chunk_detach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_detach: CALL detach_chunk('chunk_to_detach'); <waiting ...> step s2_show_num_rows: SELECT count(*) FROM detach_test; count ----- 1 step s3_insert: INSERT INTO detach_test VALUES ('2025-06-02 10:30', 1, 31.5); step s2_show_num_rows: SELECT count(*) FROM detach_test; count ----- 2 step s2_release_lock: SELECT debug_waitpoint_release('chunk_detach_before_lock'); debug_waitpoint_release ----------------------- step s1_detach: <... completed> step s3_insert: INSERT INTO detach_test VALUES ('2025-06-02 10:30', 1, 31.5); <waiting ...> step s1c: COMMIT; step s3_insert: <... completed> ERROR: chunk not found step s2_show_num_rows: SELECT count(*) FROM detach_test; count ----- 0 step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 0 step s2_show_chunk_rows: SELECT count(*) FROM chunk_to_detach; count ----- 2 starting permutation: s2_wait_before_lock s1b s1_detach s2_show_num_rows s2_show_num_chunks s3_truncate s2_release_lock s1c s2_show_num_chunks s2_show_chunk_rows step s2_wait_before_lock: SELECT debug_waitpoint_enable('chunk_detach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_detach: CALL detach_chunk('chunk_to_detach'); <waiting ...> step s2_show_num_rows: SELECT count(*) FROM detach_test; count ----- 1 step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 1 step s3_truncate: TRUNCATE TABLE detach_test; step s2_release_lock: SELECT debug_waitpoint_release('chunk_detach_before_lock'); debug_waitpoint_release ----------------------- step s1_detach: <... completed> ERROR: hypertable not found for the chunk step s1c: COMMIT; step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 0 step s2_show_chunk_rows: SELECT count(*) FROM chunk_to_detach; ERROR: relation "chunk_to_detach" does not exist starting permutation: s1b s2_show_num_chunks s2_show_num_rows s1_detach s3_truncate s1c s2_show_num_chunks s2_show_chunk_rows step s1b: BEGIN; step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 1 step s2_show_num_rows: SELECT count(*) FROM detach_test; count ----- 1 step s1_detach: CALL detach_chunk('chunk_to_detach'); step s3_truncate: TRUNCATE TABLE detach_test; <waiting ...> step s1c: COMMIT; step s3_truncate: <... completed> step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 0 step s2_show_chunk_rows: SELECT count(*) FROM chunk_to_detach; count ----- 1 starting permutation: s2_wait_before_lock s1b s1_detach s2_show_num_chunks s3_drop_chunk s2_show_num_chunks s2_release_lock s1c s2_show_num_chunks s2_show_chunk_rows step s2_wait_before_lock: SELECT debug_waitpoint_enable('chunk_detach_before_lock'); debug_waitpoint_enable ---------------------- step s1b: BEGIN; step s1_detach: CALL detach_chunk('chunk_to_detach'); <waiting ...> step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 1 step s3_drop_chunk: SELECT count(*) FROM drop_chunks('detach_test', TIMESTAMPTZ '2025-07-01'); count ----- 1 step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 0 step s2_release_lock: SELECT debug_waitpoint_release('chunk_detach_before_lock'); debug_waitpoint_release ----------------------- step s1_detach: <... completed> ERROR: hypertable not found for the chunk step s1c: COMMIT; step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 0 step s2_show_chunk_rows: SELECT count(*) FROM chunk_to_detach; ERROR: relation "chunk_to_detach" does not exist starting permutation: s1b s1_detach s2_show_num_chunks s3_drop_chunk s2_show_num_chunks s1c s2_show_num_chunks s2_show_chunk_rows step s1b: BEGIN; step s1_detach: CALL detach_chunk('chunk_to_detach'); step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 1 step s3_drop_chunk: SELECT count(*) FROM drop_chunks('detach_test', TIMESTAMPTZ '2025-07-01'); <waiting ...> step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 1 step s1c: COMMIT; step s3_drop_chunk: <... completed> count ----- 0 step s2_show_num_chunks: SELECT count(*) FROM show_chunks('detach_test'); count ----- 0 step s2_show_chunk_rows: SELECT count(*) FROM chunk_to_detach; count ----- 1 starting permutation: s1b s4b s1_detach s4_detach s1c s4c step s1b: BEGIN; step s4b: BEGIN; step s1_detach: CALL detach_chunk('chunk_to_detach'); step s4_detach: CALL detach_chunk('chunk_to_detach'); <waiting ...> step s1c: COMMIT; step s4_detach: <... completed> ERROR: chunk not found step s4c: COMMIT; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/direct_compress_copy.out�����������������������������0000664�0000000�0000000�00000005277�15100345067�0026421�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s3_compress_and_insert s1_begin s2_begin s1_copy s2_copy s2_commit s1_commit step s3_compress_and_insert: SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics') chunk; INSERT INTO metrics (time, device, value) VALUES ('2025-02-01 00:00:00', 'd1', 0.1); INSERT INTO metrics (time, device, value) VALUES ('2025-03-01 00:00:00', 'd1', 0.1); count ----- 1 step s1_begin: BEGIN; step s2_begin: BEGIN; step s1_copy: COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-01-01 0:00:00,d1,0.5' WITH (FORMAT CSV); step s2_copy: COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-01-01 0:00:00,d1,0.5' WITH (FORMAT CSV); step s2_commit: COMMIT; step s1_commit: COMMIT; starting permutation: s3_compress_and_insert s1_begin s2_begin s1_copy_february s2_copy_march s2_commit s1_commit step s3_compress_and_insert: SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics') chunk; INSERT INTO metrics (time, device, value) VALUES ('2025-02-01 00:00:00', 'd1', 0.1); INSERT INTO metrics (time, device, value) VALUES ('2025-03-01 00:00:00', 'd1', 0.1); count ----- 1 step s1_begin: BEGIN; step s2_begin: BEGIN; step s1_copy_february: COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-02-01 0:00:00,d1,0.5' WITH (FORMAT CSV); step s2_copy_march: COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-03-01 0:00:00,d1,0.5' WITH (FORMAT CSV); step s2_commit: COMMIT; step s1_commit: COMMIT; starting permutation: s3_wp_on s3_count s3_show_compressed s1_copy s2_copy s3_wp_off s2_empty s3_show_compressed s3_count step s3_wp_on: SELECT debug_waitpoint_enable('insert_create_compressed'); debug_waitpoint_enable ---------------------- step s3_count: SELECT count(*) FROM metrics; count ----- 1 step s3_show_compressed: SELECT is_compressed FROM timescaledb_information.chunks WHERE hypertable_name='metrics'; is_compressed ------------- f step s1_copy: COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-01-01 0:00:00,d1,0.5' WITH (FORMAT CSV); <waiting ...> step s2_copy: COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-01-01 0:00:00,d1,0.5' WITH (FORMAT CSV); <waiting ...> step s3_wp_off: SELECT debug_waitpoint_release('insert_create_compressed'); debug_waitpoint_release ----------------------- step s1_copy: <... completed> step s2_copy: <... completed> step s2_empty: step s3_show_compressed: SELECT is_compressed FROM timescaledb_information.chunks WHERE hypertable_name='metrics'; is_compressed ------------- t step s3_count: SELECT count(*) FROM metrics; count ----- 21 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/freeze_chunk.out�������������������������������������0000664�0000000�0000000�00000040644�15100345067�0024647�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 8 sessions starting permutation: s2_wp_enable ins_s2_insert s2_wp_release s1_freeze ins_s2_commit ins_s2_query s1_status step s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step ins_s2_insert: BEGIN ; INSERT INTO measurements values('2020-01-03 12:30', 2, 2.0 ); step s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step ins_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step ins_s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 2 Fri Jan 03 12:30:00 2020 PST| 2| 2 step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 4 starting permutation: comp_s2_compress comp_s2_commit s2_wp_enable ins_s2_insert s2_wp_release s1_freeze ins_s2_commit ins_s2_query s1_status step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; col ------- Success step comp_s2_commit: COMMIT; step s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step ins_s2_insert: BEGIN ; INSERT INTO measurements values('2020-01-03 12:30', 2, 2.0 ); step s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step ins_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step ins_s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 2 Fri Jan 03 12:30:00 2020 PST| 2| 2 step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 13 starting permutation: upd_s2_wp_enable upd_s2_update upd_s2_wp_release s1_freeze upd_s2_commit upd_s2_query s1_status step upd_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step upd_s2_update: BEGIN ; UPDATE measurements SET temp = 200 WHERE device = 2; step upd_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step upd_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step upd_s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 200 step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 4 starting permutation: comp_s2_compress comp_s2_commit upd_s2_wp_enable upd_s2_update upd_s2_wp_release s1_freeze upd_s2_commit upd_s2_query s1_status step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; col ------- Success step comp_s2_commit: COMMIT; step upd_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step upd_s2_update: BEGIN ; UPDATE measurements SET temp = 200 WHERE device = 2; step upd_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step upd_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step upd_s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 200 step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 13 starting permutation: del_s2_wp_enable del_s2_delete del_s2_wp_release s1_freeze del_s2_commit del_s2_query s1_status step del_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step del_s2_delete: BEGIN ; DELETE FROM measurements WHERE device = 2; step del_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step del_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step del_s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 4 starting permutation: comp_s2_compress comp_s2_commit del_s2_wp_enable del_s2_delete del_s2_wp_release s1_freeze del_s2_commit del_s2_query s1_status step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; col ------- Success step comp_s2_commit: COMMIT; step del_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step del_s2_delete: BEGIN ; DELETE FROM measurements WHERE device = 2; step del_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step del_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step del_s2_query: SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 13 starting permutation: sel_s2_wp_enable sel_s2_query sel_s2_wp_release s1_freeze sel_s2_commit s1_status step sel_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step sel_s2_query: BEGIN; SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 2 step sel_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; freeze_chunk ------------ t step sel_s2_commit: COMMIT; step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 4 starting permutation: comp_s2_compress comp_s2_commit sel_s2_wp_enable sel_s2_query sel_s2_wp_release s1_freeze sel_s2_commit s1_status step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; col ------- Success step comp_s2_commit: COMMIT; step sel_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step sel_s2_query: BEGIN; SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 2 step sel_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; freeze_chunk ------------ t step sel_s2_commit: COMMIT; step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 5 starting permutation: BeginLock LockChunk1 comp_s2_compress s1_freeze Unlock comp_s2_commit s1_status step BeginLock: BEGIN; step LockChunk1: SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'measurements' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step Unlock: ROLLBACK; step comp_s2_compress: <... completed> col ------- Success step comp_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 5 starting permutation: comp_s2_compress comp_s2_commit BeginLock LockChunk1 decomp_s2_decompress s1_freeze Unlock decomp_s2_commit s1_status step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; col ------- Success step comp_s2_commit: COMMIT; step BeginLock: BEGIN; step LockChunk1: SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'measurements' ORDER BY ch.id LIMIT 1; lock_chunktable --------------- step decomp_s2_decompress: BEGIN; SELECT CASE WHEN decompress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step Unlock: ROLLBACK; step decomp_s2_decompress: <... completed> col ------- Success step decomp_s2_commit: COMMIT; step s1_freeze: <... completed> freeze_chunk ------------ t step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 4 starting permutation: BeginLock s1_begin_rr UpdateCatalogTupleStatus s1_freeze CommitUpdate s1_rollback step BeginLock: BEGIN; step s1_begin_rr: BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; step UpdateCatalogTupleStatus: UPDATE _timescaledb_catalog.chunk SET status = 4 WHERE true; step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step CommitUpdate: COMMIT; step s1_freeze: <... completed> ERROR: could not serialize access due to concurrent update step s1_rollback: ROLLBACK; starting permutation: BeginLock s1_begin_s UpdateCatalogTupleStatus s1_freeze CommitUpdate s1_rollback step BeginLock: BEGIN; step s1_begin_s: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; step UpdateCatalogTupleStatus: UPDATE _timescaledb_catalog.chunk SET status = 4 WHERE true; step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; <waiting ...> step CommitUpdate: COMMIT; step s1_freeze: <... completed> ERROR: could not serialize access due to concurrent update step s1_rollback: ROLLBACK; starting permutation: s1_freeze sel_s2_wp_enable sel_s2_query sel_s2_wp_release s1_unfreeze sel_s2_commit s1_status step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; freeze_chunk ------------ t step sel_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step sel_s2_query: BEGIN; SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 2 step sel_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_unfreeze: SELECT _timescaledb_functions.unfreeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; unfreeze_chunk -------------- t step sel_s2_commit: COMMIT; step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 0 starting permutation: comp_s2_compress comp_s2_commit s1_freeze sel_s2_wp_enable sel_s2_query sel_s2_wp_release s1_unfreeze sel_s2_commit s1_status step comp_s2_compress: BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; col ------- Success step comp_s2_commit: COMMIT; step s1_freeze: SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; freeze_chunk ------------ t step sel_s2_wp_enable: SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); debug_waitpoint_enable ---------------------- step sel_s2_query: BEGIN; SELECT * FROM measurements ORDER BY 1; time |device|temp ----------------------------+------+---- Fri Jan 03 10:30:00 2020 PST| 1| 1 Fri Jan 03 11:30:00 2020 PST| 2| 2 step sel_s2_wp_release: SELECT debug_waitpoint_release('freeze_chunk_before_lock'); debug_waitpoint_release ----------------------- step s1_unfreeze: SELECT _timescaledb_functions.unfreeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; unfreeze_chunk -------------- t step sel_s2_commit: COMMIT; step s1_status: SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); status ------ 1 ��������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/merge_chunks_concurrent.out��������������������������0000664�0000000�0000000�00000042322�15100345067�0027106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 4 sessions starting permutation: s2_show_chunks s3_show_data s1_begin s3_begin s4_modify s2_merge_chunks s1_show_chunks s3_show_chunks s1_show_data s3_show_data s1_commit s1_show_data s3_commit step s2_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 step s3_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_class; ?column? -------- t step s3_begin: start transaction isolation level read committed; select count(*) > 0 from pg_class; ?column? -------- t step s4_modify: delete from readings where device=1; insert into readings values ('2024-01-01 01:05', 5, 5.0); step s2_merge_chunks: call merge_all_chunks('readings'); step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 step s3_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s3_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:05:00 2024 PST| 5| 5 Mon Jan 01 01:01:00 2024 PST| 2| 2 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 0| 1 step s1_commit: commit; step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:05:00 2024 PST| 5| 5 Mon Jan 01 01:01:00 2024 PST| 2| 2 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 0| 1 step s3_commit: commit; starting permutation: s2_show_chunks s1_begin s1_show_data s2_merge_chunks s1_show_data s1_commit s1_show_data s1_show_chunks step s2_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_class; ?column? -------- t step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s2_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_commit: commit; step s2_merge_chunks: <... completed> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 starting permutation: s2_set_lock_upgrade s2_show_chunks s1_begin s1_show_data s2_merge_chunks s1_show_data s1_commit s1_show_data s1_show_chunks step s2_set_lock_upgrade: set timescaledb.merge_chunks_lock_upgrade_mode='upgrade'; step s2_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_class; ?column? -------- t step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s2_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_commit: commit; step s2_merge_chunks: <... completed> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 starting permutation: s4_wp_enable s2_show_chunks s1_begin s1_show_data s2_merge_chunks s1_show_data s1_row_exclusive_lock s4_wp_release s1_commit s1_show_data s1_show_chunks step s4_wp_enable: SELECT debug_waitpoint_enable('merge_chunks_before_heap_swap'); debug_waitpoint_enable ---------------------- step s2_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_class; ?column? -------- t step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s2_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_row_exclusive_lock: call lock_one_chunk('readings'); step s4_wp_release: SELECT debug_waitpoint_release('merge_chunks_before_heap_swap'); debug_waitpoint_release ----------------------- step s1_commit: commit; step s2_merge_chunks: <... completed> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 starting permutation: s4_wp_enable s2_show_chunks s1_begin s2_merge_chunks s1_show_data s4_wp_release s1_commit s1_show_data s1_show_chunks step s4_wp_enable: SELECT debug_waitpoint_enable('merge_chunks_before_heap_swap'); debug_waitpoint_enable ---------------------- step s2_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_class; ?column? -------- t step s2_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; <waiting ...> step s4_wp_release: SELECT debug_waitpoint_release('merge_chunks_before_heap_swap'); debug_waitpoint_release ----------------------- step s2_merge_chunks: <... completed> step s1_show_data: <... completed> time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_commit: commit; step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 starting permutation: s2_set_lock_upgrade_conditional s4_wp_enable s2_show_chunks s1_begin s1_show_data s2_merge_chunks s1_show_data s1_row_exclusive_lock s4_wp_release s1_commit s1_show_data s1_show_chunks step s2_set_lock_upgrade_conditional: set timescaledb.merge_chunks_lock_upgrade_mode='conditional'; step s4_wp_enable: SELECT debug_waitpoint_enable('merge_chunks_before_heap_swap'); debug_waitpoint_enable ---------------------- step s2_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_class; ?column? -------- t step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s2_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_row_exclusive_lock: call lock_one_chunk('readings'); <waiting ...> step s4_wp_release: SELECT debug_waitpoint_release('merge_chunks_before_heap_swap'); debug_waitpoint_release ----------------------- step s2_merge_chunks: <... completed> ERROR: could not lock relation "_hyper_X_X_chunk" for merge step s1_row_exclusive_lock: <... completed> step s1_commit: commit; step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 2 starting permutation: s4_wp_enable s2_merge_chunks s3_merge_chunks s4_wp_release s1_show_data s1_show_chunks step s4_wp_enable: SELECT debug_waitpoint_enable('merge_chunks_before_heap_swap'); debug_waitpoint_enable ---------------------- step s2_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s3_merge_chunks: call merge_all_chunks('readings'); <waiting ...> step s4_wp_release: SELECT debug_waitpoint_release('merge_chunks_before_heap_swap'); debug_waitpoint_release ----------------------- step s2_merge_chunks: <... completed> step s3_merge_chunks: <... completed> ERROR: chunk does not exist step s1_show_data: select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; time |device|temp ----------------------------+------+---- Mon Jan 01 02:00:00 2024 PST| 3| 3 Mon Jan 01 02:00:00 2024 PST| 4| 4 Mon Jan 01 01:01:00 2024 PST| 2| 2 Mon Jan 01 01:00:00 2024 PST| 1| 1 num_device_all|num_device_1|num_device_5 --------------+------------+------------ 4| 1| 0 step s1_show_chunks: select count(*) from show_chunks('readings'); count ----- 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/osm_range_updates_iso.out����������������������������0000664�0000000�0000000�00000015647�15100345067�0026555�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 10 sessions starting permutation: LockDimSliceTuple UR1b UR1u UR2b UR2u UnlockDimSliceTuple UR1c UR2c step LockDimSliceTuple: BEGIN; SELECT range_start, range_end FROM _timescaledb_catalog.dimension_slice WHERE id IN ( SELECT ds.id FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds, _timescaledb_catalog.hypertable ht WHERE ht.table_name like 'osm_test' AND cc.chunk_id = ch.id AND ht.id = ch.hypertable_id AND ds.id = cc.dimension_slice_id AND ch.osm_chunk = true ) FOR UPDATE; range_start| range_end -------------------+------------------- 9223372036854775806|9223372036854775807 step UR1b: BEGIN; step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); <waiting ...> step UR2b: BEGIN; step UR2u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); <waiting ...> step UnlockDimSliceTuple: ROLLBACK; step UR1u: <... completed> hypertable_osm_range_update --------------------------- f step UR1c: COMMIT; step UR2u: <... completed> hypertable_osm_range_update --------------------------- f step UR2c: COMMIT; starting permutation: LockDimSliceTuple DTb UR1b DropOsmChunk UR1u UnlockDimSliceTuple DTc UR1c step LockDimSliceTuple: BEGIN; SELECT range_start, range_end FROM _timescaledb_catalog.dimension_slice WHERE id IN ( SELECT ds.id FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds, _timescaledb_catalog.hypertable ht WHERE ht.table_name like 'osm_test' AND cc.chunk_id = ch.id AND ht.id = ch.hypertable_id AND ds.id = cc.dimension_slice_id AND ch.osm_chunk = true ) FOR UPDATE; range_start| range_end -------------------+------------------- 9223372036854775806|9223372036854775807 step DTb: BEGIN; step UR1b: BEGIN; step DropOsmChunk: SELECT _timescaledb_functions.drop_chunk(chunk_table::regclass) FROM ( SELECT format('%I.%I', c.schema_name, c.table_name) as chunk_table FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.hypertable ht WHERE ht.id = c.hypertable_id AND ht.table_name = 'osm_test' ) sq; <waiting ...> step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); <waiting ...> step UnlockDimSliceTuple: ROLLBACK; step DropOsmChunk: <... completed> drop_chunk ---------- t step DTc: COMMIT; step UR1u: <... completed> ERROR: chunk deleted by other transaction step UR1c: COMMIT; starting permutation: LockDimSliceTuple DTb UR1b UR1u DropOsmChunk UnlockDimSliceTuple UR1c DTc step LockDimSliceTuple: BEGIN; SELECT range_start, range_end FROM _timescaledb_catalog.dimension_slice WHERE id IN ( SELECT ds.id FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds, _timescaledb_catalog.hypertable ht WHERE ht.table_name like 'osm_test' AND cc.chunk_id = ch.id AND ht.id = ch.hypertable_id AND ds.id = cc.dimension_slice_id AND ch.osm_chunk = true ) FOR UPDATE; range_start| range_end -------------------+------------------- 9223372036854775806|9223372036854775807 step DTb: BEGIN; step UR1b: BEGIN; step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); <waiting ...> step DropOsmChunk: SELECT _timescaledb_functions.drop_chunk(chunk_table::regclass) FROM ( SELECT format('%I.%I', c.schema_name, c.table_name) as chunk_table FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.hypertable ht WHERE ht.id = c.hypertable_id AND ht.table_name = 'osm_test' ) sq; <waiting ...> step UnlockDimSliceTuple: ROLLBACK; step UR1u: <... completed> hypertable_osm_range_update --------------------------- f step UR1c: COMMIT; step DropOsmChunk: <... completed> drop_chunk ---------- t step DTc: COMMIT; starting permutation: LHTb LockHypertableTuple Cb UR1b Cenable UR1u UnlockHypertableTuple Ccommit UR1c step LHTb: BEGIN; step LockHypertableTuple: SELECT table_name, compression_state, compressed_hypertable_id, status FROM _timescaledb_catalog.hypertable WHERE table_name = 'osm_test' FOR UPDATE; table_name|compression_state|compressed_hypertable_id|status ----------+-----------------+------------------------+------ osm_test | 0| | 3 step Cb: BEGIN; step UR1b: BEGIN; step Cenable: ALTER TABLE osm_test set (timescaledb.compress); <waiting ...> step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); <waiting ...> step UnlockHypertableTuple: ROLLBACK; step Cenable: <... completed> step Ccommit: COMMIT; step UR1u: <... completed> hypertable_osm_range_update --------------------------- f step UR1c: COMMIT; starting permutation: Ab UR1b UR1u Aadd UR1c Ac step Ab: BEGIN; step UR1b: BEGIN; step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); hypertable_osm_range_update --------------------------- f step Aadd: ALTER TABLE osm_test ADD COLUMN b INTEGER; step UR1c: COMMIT; step Ac: COMMIT; starting permutation: Ab UR1b Aadd UR1u UR1c Ac step Ab: BEGIN; step UR1b: BEGIN; step Aadd: ALTER TABLE osm_test ADD COLUMN b INTEGER; step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); hypertable_osm_range_update --------------------------- f step UR1c: COMMIT; step Ac: COMMIT; starting permutation: LHTb Utest2b UR1b LockHypertableTuple UR1u Utest2u Utest2c UnlockHypertableTuple UR1c step LHTb: BEGIN; step Utest2b: BEGIN; step UR1b: BEGIN; step LockHypertableTuple: SELECT table_name, compression_state, compressed_hypertable_id, status FROM _timescaledb_catalog.hypertable WHERE table_name = 'osm_test' FOR UPDATE; table_name|compression_state|compressed_hypertable_id|status ----------+-----------------+------------------------+------ osm_test | 0| | 3 step UR1u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); <waiting ...> step Utest2u: SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test2', 0, 20); hypertable_osm_range_update --------------------------- f step Utest2c: COMMIT; step UnlockHypertableTuple: ROLLBACK; step UR1u: <... completed> hypertable_osm_range_update --------------------------- f step UR1c: COMMIT; starting permutation: DR1b DR2b DR1drop DR2drop DR1c DR2c step DR1b: BEGIN; step DR2b: BEGIN; step DR1drop: SELECT _timescaledb_functions.drop_osm_chunk('test_drop'); drop_osm_chunk -------------- t step DR2drop: SELECT _timescaledb_functions.drop_osm_chunk('test_drop'); <waiting ...> step DR1c: COMMIT; step DR2drop: <... completed> ERROR: chunk deleted by other transaction step DR2c: COMMIT; �����������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/parallel_compression.out�����������������������������0000664�0000000�0000000�00000006664�15100345067�0026420�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: s1_begin s2_begin s1_compress s2_compress s2_commit s1_commit step s1_begin: BEGIN; step s2_begin: BEGIN; step s1_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; compress -------- t step s2_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; compress -------- t step s2_commit: COMMIT; step s1_commit: COMMIT; starting permutation: s1_begin s2_begin s1_compress s2_compress s2_decompress s1_decompress s2_commit s1_commit step s1_begin: BEGIN; step s2_begin: BEGIN; step s1_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; compress -------- t step s2_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; compress -------- t step s2_decompress: SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; decompress ---------- t step s1_decompress: SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; decompress ---------- t step s2_commit: COMMIT; step s1_commit: COMMIT; starting permutation: s1_begin s2_begin s1_compress s2_compress s2_commit s2_begin s2_decompress s1_decompress s2_commit s1_commit step s1_begin: BEGIN; step s2_begin: BEGIN; step s1_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; compress -------- t step s2_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; compress -------- t step s2_commit: COMMIT; step s2_begin: BEGIN; step s2_decompress: SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; decompress ---------- t step s1_decompress: SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; decompress ---------- t step s2_commit: COMMIT; step s1_commit: COMMIT; starting permutation: s1_begin s2_begin s1_compress s2_compress s1_commit s1_begin s2_decompress s1_decompress s2_commit s1_commit step s1_begin: BEGIN; step s2_begin: BEGIN; step s1_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; compress -------- t step s2_compress: SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; compress -------- t step s1_commit: COMMIT; step s1_begin: BEGIN; step s2_decompress: SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; decompress ---------- t step s1_decompress: SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; decompress ---------- t step s2_commit: COMMIT; step s1_commit: COMMIT; ����������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/reorder_deadlock.out���������������������������������0000664�0000000�0000000�00000002113�15100345067�0025454�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: S1 R1 Bc S2 Rc Sc step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Bc: ROLLBACK; step S2: INSERT INTO ts_reorder_test VALUES (1, 23.4, 1); ERROR: deadlock detected step R1: <... completed> reorder_chunk_i --------------- step Rc: COMMIT; step Sc: COMMIT; starting permutation: S1 R1 Bc S2 Sc Rc step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Bc: ROLLBACK; step S2: INSERT INTO ts_reorder_test VALUES (1, 23.4, 1); ERROR: deadlock detected step R1: <... completed> reorder_chunk_i --------------- step Sc: COMMIT; step Rc: COMMIT; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/reorder_vs_insert.out��������������������������������0000664�0000000�0000000�00000006454�15100345067�0025736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: Bc I1 Ic R1 Rc step Bc: COMMIT; step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); step Ic: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step Rc: COMMIT; starting permutation: Bc I1 R1 Ic Rc step Bc: COMMIT; step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Ic: COMMIT; step R1: <... completed> reorder_chunk_i --------------- step Rc: COMMIT; starting permutation: Bc I1 R1 Rc Ic step Bc: COMMIT; step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step R1: <... completed> ERROR: canceling statement due to lock timeout step Rc: COMMIT; step Ic: COMMIT; starting permutation: Bc R1 Rc I1 Ic step Bc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step Rc: COMMIT; step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); step Ic: COMMIT; starting permutation: Bc R1 I1 Rc Ic step Bc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); <waiting ...> step Rc: COMMIT; step I1: <... completed> step Ic: COMMIT; starting permutation: Bc R1 I1 Ic Rc step Bc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); <waiting ...> step I1: <... completed> ERROR: canceling statement due to lock timeout step Ic: COMMIT; step Rc: COMMIT; starting permutation: R1 I1 Ic Bc Rc step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); <waiting ...> step R1: <... completed> ERROR: canceling statement due to lock timeout step I1: <... completed> step Ic: COMMIT; step Bc: COMMIT; step Rc: COMMIT; starting permutation: R1 I1 Bc Rc Ic step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); <waiting ...> step Bc: COMMIT; step R1: <... completed> reorder_chunk_i --------------- step Rc: COMMIT; step I1: <... completed> step Ic: COMMIT; starting permutation: I1 R1 Bc Rc Ic step I1: INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Bc: COMMIT; step R1: <... completed> ERROR: canceling statement due to lock timeout step Rc: COMMIT; step Ic: COMMIT; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/reorder_vs_insert_other_chunk.out��������������������0000664�0000000�0000000�00000003333�15100345067�0030320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 2 sessions starting permutation: I1 Ic R1 Rc step I1: INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); step Ic: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); reorder_chunk_i --------------- step Rc: COMMIT; starting permutation: I1 R1 Ic Rc step I1: INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); reorder_chunk_i --------------- step Ic: COMMIT; step Rc: COMMIT; starting permutation: I1 R1 Rc Ic step I1: INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); reorder_chunk_i --------------- step Rc: COMMIT; step Ic: COMMIT; starting permutation: R1 I1 Ic Rc step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); reorder_chunk_i --------------- step I1: INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); step Ic: COMMIT; step Rc: COMMIT; starting permutation: R1 I1 Rc Ic step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); reorder_chunk_i --------------- step I1: INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); step Rc: COMMIT; step Ic: COMMIT; starting permutation: R1 Rc I1 Ic step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); reorder_chunk_i --------------- step Rc: COMMIT; step I1: INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); step Ic: COMMIT; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/reorder_vs_select.out��������������������������������0000664�0000000�0000000�00000010370�15100345067�0025701�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: Bc S1 Sc R1 Rc step Bc: COMMIT; step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step Sc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step Rc: COMMIT; starting permutation: Bc S1 R1 Sc Rc step Bc: COMMIT; step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Sc: COMMIT; step R1: <... completed> reorder_chunk_i --------------- step Rc: COMMIT; starting permutation: Bc S1 R1 Rc Sc step Bc: COMMIT; step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step R1: <... completed> ERROR: canceling statement due to lock timeout step Rc: COMMIT; step Sc: COMMIT; starting permutation: Bc R1 Rc S1 Sc step Bc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step Rc: COMMIT; step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step Sc: COMMIT; starting permutation: Bc R1 S1 Rc Sc step Bc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step S1: SELECT * FROM ts_reorder_test; <waiting ...> step Rc: COMMIT; step S1: <... completed> time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step Sc: COMMIT; starting permutation: Bc R1 S1 Sc Rc step Bc: COMMIT; step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); reorder_chunk_i --------------- step S1: SELECT * FROM ts_reorder_test; <waiting ...> step S1: <... completed> ERROR: canceling statement due to lock timeout step Sc: COMMIT; step Rc: COMMIT; starting permutation: R1 S1 Bc Rc Sc step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step Bc: COMMIT; step R1: <... completed> ERROR: canceling statement due to lock timeout step Rc: COMMIT; step Sc: COMMIT; starting permutation: S1 R1 Bc Rc Sc step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Bc: COMMIT; step R1: <... completed> ERROR: canceling statement due to lock timeout step Rc: COMMIT; step Sc: COMMIT; starting permutation: R1 S1 Sc Bc Rc step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step Sc: COMMIT; step Bc: COMMIT; step R1: <... completed> reorder_chunk_i --------------- step Rc: COMMIT; starting permutation: S1 R1 Sc Bc Rc step S1: SELECT * FROM ts_reorder_test; time|temp|location ----+----+-------- 1|23.4| 1 11|21.3| 2 21|19.5| 3 step R1: SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); <waiting ...> step Sc: COMMIT; step Bc: COMMIT; step R1: <... completed> reorder_chunk_i --------------- step Rc: COMMIT; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/expected/split_chunk_concurrent.out���������������������������0000664�0000000�0000000�00000056427�15100345067�0026772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Parsed test spec with 3 sessions starting permutation: s3_query_data s3_wp_at_end_on s2_split_chunk s1_insert_into_existing_chunk s3_wp_at_end_off s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s3_wp_at_end_on: select debug_waitpoint_enable('split_chunk_at_end'); debug_waitpoint_enable ---------------------- step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_insert_into_existing_chunk: insert into readings values ('2024-01-12 01:05', 12, 12.0); step s3_wp_at_end_off: select debug_waitpoint_release('split_chunk_at_end'); debug_waitpoint_release ----------------------- step s2_split_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ("Fri Jan 12 01:05:00 2024 PST",12,12) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s3_wp_before_routing_on s2_split_chunk s1_insert_into_existing_chunk s3_wp_before_routing_off s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s3_wp_before_routing_on: select debug_waitpoint_enable('split_chunk_before_tuple_routing'); debug_waitpoint_enable ---------------------- step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_insert_into_existing_chunk: insert into readings values ('2024-01-12 01:05', 12, 12.0); step s3_wp_before_routing_off: select debug_waitpoint_release('split_chunk_before_tuple_routing'); debug_waitpoint_release ----------------------- step s2_split_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ("Fri Jan 12 01:05:00 2024 PST",12,12) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s3_wp_at_end_on s2_split_chunk s1_insert_into_new_chunk s3_wp_at_end_off s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s3_wp_at_end_on: select debug_waitpoint_enable('split_chunk_at_end'); debug_waitpoint_enable ---------------------- step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_insert_into_new_chunk: insert into readings values ('2024-01-18 10:00', 13, 13.0); <waiting ...> step s3_wp_at_end_off: select debug_waitpoint_release('split_chunk_at_end'); debug_waitpoint_release ----------------------- step s2_split_chunk: <... completed> step s1_insert_into_new_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 3 [ Wed Jan 17 16:00:00 2024 PST : Wed Jan 24 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 18 10:00:00 2024 PST",13,13) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s3_wp_before_routing_on s2_split_chunk s1_insert_into_new_chunk s3_wp_before_routing_off s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s3_wp_before_routing_on: select debug_waitpoint_enable('split_chunk_before_tuple_routing'); debug_waitpoint_enable ---------------------- step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_insert_into_new_chunk: insert into readings values ('2024-01-18 10:00', 13, 13.0); <waiting ...> step s3_wp_before_routing_off: select debug_waitpoint_release('split_chunk_before_tuple_routing'); debug_waitpoint_release ----------------------- step s2_split_chunk: <... completed> step s1_insert_into_new_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 3 [ Wed Jan 17 16:00:00 2024 PST : Wed Jan 24 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 18 10:00:00 2024 PST",13,13) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s3_wp_at_end_on s2_split_chunk s1_insert_into_splitting_chunk s3_wp_at_end_off s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s3_wp_at_end_on: select debug_waitpoint_enable('split_chunk_at_end'); debug_waitpoint_enable ---------------------- step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_insert_into_splitting_chunk: insert into readings values ('2024-01-05 01:05', 10, 10.0), ('2024-01-09 01:05', 11, 11.0); <waiting ...> step s3_wp_at_end_off: select debug_waitpoint_release('split_chunk_at_end'); debug_waitpoint_release ----------------------- step s2_split_chunk: <... completed> step s1_insert_into_splitting_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Fri Jan 05 01:05:00 2024 PST",10,10) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ("Tue Jan 09 01:05:00 2024 PST",11,11) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s3_wp_before_routing_on s2_split_chunk s1_insert_into_splitting_chunk s3_wp_before_routing_off s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s3_wp_before_routing_on: select debug_waitpoint_enable('split_chunk_before_tuple_routing'); debug_waitpoint_enable ---------------------- step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_insert_into_splitting_chunk: insert into readings values ('2024-01-05 01:05', 10, 10.0), ('2024-01-09 01:05', 11, 11.0); <waiting ...> step s3_wp_before_routing_off: select debug_waitpoint_release('split_chunk_before_tuple_routing'); debug_waitpoint_release ----------------------- step s2_split_chunk: <... completed> step s1_insert_into_splitting_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Fri Jan 05 01:05:00 2024 PST",10,10) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ("Tue Jan 09 01:05:00 2024 PST",11,11) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s1_begin s1_insert_into_splitting_chunk s2_split_chunk s1_commit s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t step s1_insert_into_splitting_chunk: insert into readings values ('2024-01-05 01:05', 10, 10.0), ('2024-01-09 01:05', 11, 11.0); step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_commit: commit; step s2_split_chunk: <... completed> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Fri Jan 05 01:05:00 2024 PST",10,10) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ("Tue Jan 09 01:05:00 2024 PST",11,11) step s3_query_data: call show_all_chunks('readings'); starting permutation: s4_begin s3_query_data s1_begin s1_delete_from_splitting_chunk s2_split_chunk s1_commit s3_query_data s4_query s4_commit s4_query step s4_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s1_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t step s1_delete_from_splitting_chunk: delete from readings where device = 1; step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> step s1_commit: commit; s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Thu Jan 04 01:00:00 2024 PST| 1| 1 Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 step s4_commit: commit; step s2_split_chunk: <... completed> step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 starting permutation: s4_begin s3_query_data s1_delete_from_splitting_chunk s2_split_chunk s3_query_data s4_query s4_commit s4_query step s4_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s1_delete_from_splitting_chunk: delete from readings where device = 1; step s2_split_chunk: call split_first_chunk('readings'); <waiting ...> s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Thu Jan 04 01:00:00 2024 PST| 1| 1 Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 step s4_commit: commit; step s2_split_chunk: <... completed> step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 starting permutation: s3_query_data s4_begin s1_delete_from_splitting_chunk s2_split_chunk s3_query_data s4_query s4_commit s4_query s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s4_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t step s1_delete_from_splitting_chunk: delete from readings where device = 1; step s2_split_chunk: call split_first_chunk('readings'); s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Thu Jan 04 01:00:00 2024 PST| 1| 1 Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 step s4_commit: commit; step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) step s3_query_data: call show_all_chunks('readings'); starting permutation: s3_query_data s4_begin s1_update_splitting_chunk s2_split_chunk s3_query_data s4_query s4_commit s4_query s3_query_data s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s4_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t step s1_update_splitting_chunk: update readings set device = 1 where device = 2; step s2_split_chunk: call split_first_chunk('readings'); s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: call show_all_chunks('readings'); step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Thu Jan 04 01:00:00 2024 PST| 1| 1 Fri Jan 05 02:00:00 2024 PST| 2| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 step s4_commit: commit; step s4_query: select * from readings order by time, device; time |device|temp ----------------------------+------+---- Thu Jan 04 01:00:00 2024 PST| 1| 1 Fri Jan 05 02:00:00 2024 PST| 1| 2 Mon Jan 08 02:00:00 2024 PST| 3| 3 Thu Jan 11 01:01:00 2024 PST| 4| 4 Mon Jan 15 02:00:00 2024 PST| 5| 5 s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Sun Jan 07 04:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",1,2) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) s3: NOTICE: ---- chunk 2 [ Sun Jan 07 04:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] s3: NOTICE: ("Mon Jan 08 02:00:00 2024 PST",3,3) step s3_query_data: call show_all_chunks('readings'); starting permutation: s2_begin s2_insert_into_splitting_chunk s2_split_chunk s3_query_data s2_commit step s2_begin: start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; ?column? -------- t step s2_insert_into_splitting_chunk: insert into readings values ('2024-01-05 01:05', 15, 15.0); step s2_split_chunk: call split_first_chunk('readings'); s3: NOTICE: ---- chunk 0 [ Wed Jan 03 16:00:00 2024 PST : Wed Jan 10 16:00:00 2024 PST ] step s3_query_data: call show_all_chunks('readings'); <waiting ...> step s2_commit: commit; s3: NOTICE: ("Thu Jan 04 01:00:00 2024 PST",1,1) s3: NOTICE: ("Fri Jan 05 02:00:00 2024 PST",2,2) s3: NOTICE: ("Fri Jan 05 01:05:00 2024 PST",15,15) s3: NOTICE: ---- chunk 1 [ Wed Jan 10 16:00:00 2024 PST : Wed Jan 17 16:00:00 2024 PST ] s3: NOTICE: ("Thu Jan 11 01:01:00 2024 PST",4,4) s3: NOTICE: ("Mon Jan 15 02:00:00 2024 PST",5,5) step s3_query_data: <... completed> �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/��������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020752�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/.gitignore����������������������������������������������0000664�0000000�0000000�00000000153�15100345067�0022741�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/reorder_deadlock.spec /reorder_vs_insert_other_chunk.spec /reorder_vs_insert.spec /reorder_vs_select.spec ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/CMakeLists.txt������������������������������������������0000664�0000000�0000000�00000005066�15100345067�0023521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# these tests need MODULE_NAME and cannot be added as is to TEST_FILES set(TEST_TEMPLATES_MODULE reorder_deadlock.spec.in reorder_vs_insert_other_chunk.spec.in) set(TEST_TEMPLATES_MODULE_DEBUG reorder_vs_insert.spec.in reorder_vs_select.spec.in decompression_chunk_and_parallel_query.in) # This one must go first because it is very dependent on chunk IDs in EXPLAIN. if(CMAKE_BUILD_TYPE MATCHES Debug) set(TEST_FILES cagg_watermark_concurrent_update.spec) endif() list( APPEND TEST_FILES compression_ddl_iso.spec compression_conflicts_iso.spec cagg_insert.spec cagg_multi_iso.spec deadlock_drop_chunks_compress.spec deadlock_drop_index_vacuum.spec parallel_compression.spec osm_range_updates_iso.spec concurrent_decompress_update.spec bgw_job_stat_history_retention_isolation.spec) if(CMAKE_BUILD_TYPE MATCHES Debug) list(APPEND TEST_TEMPLATES_MODULE ${TEST_TEMPLATES_MODULE_DEBUG}) list( APPEND TEST_FILES cagg_concurrent_move.spec cagg_concurrent_process_wal.spec cagg_concurrent_invalidation.spec cagg_concurrent_refresh.spec compression_chunk_race.spec direct_compress_copy.spec compression_freeze.spec compression_merge_race.spec compression_recompress.spec decompression_chunk_and_parallel_query_wo_idx.spec merge_chunks_concurrent.spec split_chunk_concurrent.spec freeze_chunk.spec compression_dml_iso.spec # These tests are using markers for the isolation tests (to avoid race # conditions causing differing output), which were added after 13.3 and in # all later major versions. deadlock_recompress_chunk.spec detach_chunk_isolation.spec attach_chunk_isolation.spec) endif(CMAKE_BUILD_TYPE MATCHES Debug) # need to generate MODULE name for the .spec files foreach(TEMP_FILE ${TEST_TEMPLATES_MODULE}) get_filename_component(TEMPLATE ${TEMP_FILE} NAME_WE) set(TEST_FILE ${TEMPLATE}.spec) configure_file(${TEMP_FILE} ${TEST_FILE}) list(APPEND TEST_FILES "${TEST_FILE}") endforeach(TEMP_FILE) # generate PG version specific .spec file foreach(TEMPLATE_FILE ${TEST_TEMPLATES}) get_filename_component(TEMPLATE ${TEMPLATE_FILE} NAME_WE) set(TEST_FILE ${TEMPLATE}-${TEST_VERSION_SUFFIX}.spec) configure_file(${TEMPLATE_FILE} ${TEST_FILE}) list(APPEND TEST_FILES "${TEST_FILE}") endforeach(TEMPLATE_FILE) file(REMOVE ${ISOLATION_TEST_SCHEDULE}) foreach(TEST_FILE ${TEST_FILES}) string(REGEX REPLACE "(.+)\.spec" "\\1" TESTS_TO_RUN ${TEST_FILE}) file(APPEND ${ISOLATION_TEST_SCHEDULE} "test: ${TESTS_TO_RUN}\n") endforeach(TEST_FILE) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/attach_chunk_isolation.spec�����������������������������0000664�0000000�0000000�00000011414�15100345067�0026344�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { DROP TABLE IF EXISTS attach_test; DROP TABLE IF EXISTS chunk_to_attach; CREATE TABLE attach_test (time timestamptz, device int, temp float); SELECT create_hypertable('attach_test', 'time'); ALTER TABLE attach_test SET (timescaledb.enable_columnstore = true, timescaledb.orderby = 'time', timescaledb.segmentby = 'device'); CREATE TABLE chunk_to_attach(time timestamptz NOT NULL, device int, temp float); CREATE TABLE temp_chunk(time timestamptz NOT NULL, device int, temp float); } teardown { DROP TABLE IF EXISTS chunk_to_attach; DROP TABLE IF EXISTS temp_chunk; DROP TABLE attach_test; } session "s1" step "s1b" { BEGIN; } step "s1_attach" { CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); } step "s1c" { COMMIT; } session "s2" step "s2b" { BEGIN; } step "s2_attach" { CALL attach_chunk('attach_test', 'temp_chunk', jsonb_build_object('time', jsonb_build_array('2025-05-01', '2025-05-11'))); } step "s2_attach_same" { CALL attach_chunk('attach_test', 'chunk_to_attach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); } step "s2_detach" { CALL detach_chunk('temp_chunk'); } step "s2_compress" { CALL convert_to_columnstore('temp_chunk'); } step "s2c" { COMMIT; } session "s3" step "s3_wait_before_lock" { SELECT debug_waitpoint_enable('chunk_attach_before_lock'); } step "s3_release_lock" { SELECT debug_waitpoint_release('chunk_attach_before_lock'); } step "s3_show_num_chunks" { SELECT count(*) FROM show_chunks('attach_test'); } step "s3_show_num_rows" { SELECT count(*) FROM attach_test; } step "s3_show_chunk_rows" { SELECT count(*) FROM chunk_to_attach; } step "s3_wait_before_detach" { SELECT debug_waitpoint_enable('chunk_detach_before_lock'); } step "s3_release_detach" { SELECT debug_waitpoint_release('chunk_detach_before_lock'); } session "s4" step "s4_insert" { INSERT INTO attach_test VALUES ('2025-06-03 00:15', 1, 31.5); } step "s4_truncate" { TRUNCATE TABLE attach_test; } step "s4_compress" { CALL convert_to_columnstore('chunk_to_attach'); } step "s4_detach" { CALL detach_chunk('chunk_to_attach'); } step "s4_drop" { DROP TABLE chunk_to_attach; } step "s4_violate" { INSERT INTO chunk_to_attach VALUES ('2025-08-01 20:00', 1, 34); } # Create another chunk with overlaping slices before attach takes locks so attach fails permutation "s3_wait_before_lock" "s1b" "s1_attach" "s4_insert" "s3_release_lock" "s1c" "s3_show_num_chunks" # Attach takes locks before trying to insert permutation "s1b" "s1_attach" "s3_show_num_rows" "s4_insert" "s1c" "s3_show_num_chunks" "s3_show_num_rows" # Insert row that violates chunk constraints into the chunk during attach permutation "s3_wait_before_lock" "s1b" "s1_attach" "s3_show_chunk_rows" "s4_violate" "s3_release_lock" "s1c" "s3_show_num_chunks" "s3_show_chunk_rows" # Attach takes locks first before trying to insert permutation "s1b" "s3_show_num_chunks" "s1_attach" "s4_violate" "s1c" "s3_show_num_chunks" "s3_show_chunk_rows" # Test dropping the chunk before and after attach_chunk takes locks permutation "s3_wait_before_lock" "s1b" "s1_attach" "s4_drop" "s3_release_lock" "s1c" permutation "s1b" "s3_show_num_chunks" "s1_attach" "s4_drop" "s1c" "s3_show_num_chunks" "s3_show_chunk_rows" # Test truncating the hypertable before and after attach_chunk takes locks permutation "s3_wait_before_lock" "s1b" "s1_attach" "s4_truncate" "s3_release_lock" "s1c" "s3_show_num_chunks" permutation "s1b" "s3_show_num_chunks" "s1_attach" "s4_truncate" "s1c" "s3_show_num_chunks" "s3_show_chunk_rows" # Compress the chunk during attach permutation "s3_wait_before_lock" "s1b" "s1_attach" "s4_compress" "s3_release_lock" "s1c" "s3_show_num_chunks" permutation "s1b" "s3_show_num_chunks" "s1_attach" "s4_compress" "s1c" "s3_show_num_chunks" "s3_show_chunk_rows" # Try to compress another chunk during attach permutation "s2_attach" "s3_wait_before_lock" "s1b" "s1_attach" "s2_compress" "s3_release_lock" "s1c" # Attach two chunks at the same time permutation "s1b" "s2b" "s3_show_num_chunks" "s1_attach" "s2_attach" "s1c" "s2c" "s3_show_num_chunks" # Two sessions attaching the same chunk permutation "s1b" "s2b" "s3_show_num_chunks" "s1_attach" "s2_attach_same" "s1c" "s2c" "s3_show_num_chunks" # Both detach and attach the same chunk. Detach fails since the attaching transaction has not committed yet. permutation "s3_wait_before_detach" "s1b" "s3_show_num_chunks" "s1_attach" "s4_detach" "s3_release_detach" "s1c" "s3_show_num_chunks" # Detach another chunk permutation "s2_attach" "s3_wait_before_lock" "s1b" "s1_attach" "s2_detach" "s3_release_lock" "s1c" "s3_show_num_chunks" ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/bgw_job_stat_history_retention_isolation.spec�����������0000664�0000000�0000000�00000003605�15100345067�0032227�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # # This test verifies the behavior of the job stat history retention policy # when there are concurrent inserts into the job stat history table. # setup { INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish) SELECT 100 as job_id, 12345 as pid, true as succeeded, ts as execution_start, ts + interval '5 minutes' as execution_finish FROM generate_series(now() - interval '2 months', now(), interval '1 week') as ts; -- Verify # of rows that should be kept SELECT count(*) as expected_count FROM _timescaledb_internal.bgw_job_stat_history WHERE execution_finish > now() - interval '1 month'; } teardown { TRUNCATE _timescaledb_internal.bgw_job_stat_history; } session "s1" step "s1_retention" { CALL run_job(3); SELECT count(*) as s1_count FROM _timescaledb_internal.bgw_job_stat_history; } session "s2" step "s2_insert" { INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish) VALUES (201, 2001, true, now() - interval '1 week', now() - interval '1 week' + interval '5 minutes'); } step "s2_begin" { BEGIN; } step "s2_commit" { COMMIT; } step "s2_count" { SELECT count(*) as s2_count FROM _timescaledb_internal.bgw_job_stat_history; } step "s2_lock_table" { BEGIN; LOCK TABLE _timescaledb_internal.bgw_job_stat_history IN ACCESS SHARE MODE; } step "s2_unlock_table" { ROLLBACK; } # Retention policy blocked by insert, inserted data shuold not be deleted permutation "s2_begin" "s2_insert" "s2_count" "s1_retention" "s2_commit" # Retention policy blocked by table lock permutation "s2_lock_table" "s1_retention" "s2_unlock_table" ���������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_concurrent_invalidation.spec�����������������������0000664�0000000�0000000�00000010626�15100345067�0027537�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # # Test concurrent CAgg refreshes and invalidation threshold updates. This isolation test # checks that we don't skip CAgg updates when two sessions are trying to modify the # invalidation threshold at the same time. # setup { SET timezone TO PST8PDT; CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW cagg_1 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW cagg_2 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; } # Refresh CAGGs in separate transactions setup { CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); } setup { CALL refresh_continuous_aggregate('cagg_2', NULL, NULL); } # Add new data to hypertable. This time in the year 2020 instead of 2000 as we # did for the setup of the CAgg. setup { INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') time; } teardown { DROP TABLE temperature CASCADE; } session "S1" step "s1_run_update" { CALL refresh_continuous_aggregate('cagg_1', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); } session "S2" step "s2_run_update" { CALL refresh_continuous_aggregate('cagg_2', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); } step "s2_insert_new_data_2022" { INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2022-01-01 0:00:00+0'::timestamptz, '2022-01-01 23:59:59+0','1m') time; } step "s2_insert_new_data_2023" { INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2023-01-01 0:00:00+0'::timestamptz, '2023-01-01 23:59:59+0','1m') time; } session "S3" step "s3_lock_invalidation" { SELECT debug_waitpoint_enable('invalidation_threshold_scan_update_enter'); } step "s3_release_invalidation" { SELECT debug_waitpoint_release('invalidation_threshold_scan_update_enter'); } step "s3_lock_invalidation_tuple_found" { SELECT debug_waitpoint_enable('invalidation_tuple_found_done'); } step "s3_release_invalidation_tuple_found" { SELECT debug_waitpoint_release('invalidation_tuple_found_done'); } # Check that both CAggs have a watermark in 2020 after the updates are executed. # mat_hypertable_id is not included in the query to make the test independent of the # actual hypertable ids. step "s3_check_watermarks" { SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark ORDER BY mat_hypertable_id; } # Check that all watermarks in all sessions are up to date after running an update permutation "s3_lock_invalidation" "s1_run_update" "s2_run_update" "s3_release_invalidation" "s3_check_watermarks"("s1_run_update", "s2_run_update") ### # Check that we don't leak the old AND the new value of the invalidation watermark during an update into another session ### # (1) Session 2 - Inserts new data of the year 2022 to give the CAgg refresh job some work to do. # (2) Session 3 - Blocks the invalidation watermark scanner after reading the first watermark for the hypertable. # (3) Session 2 - Inserts new data of the year 2023, during the commit it reads the current invalidation watermark and blocks due to (2). # (4) Session 1 - Refreshes a CAgg on this hypertable. During the update the invalidation watermark is deleted and a new one is written. # (5) Session 3 - Unblocks the scanner of session 2. # (6) Session 2 - Continues the scan. The new inserted invalidation watermark should not be seen since the transaction was started after s2 has started the scan in (3). permutation "s2_insert_new_data_2022" "s3_lock_invalidation_tuple_found" "s2_insert_new_data_2023" "s1_run_update" "s3_release_invalidation_tuple_found" ����������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_concurrent_move.spec�������������������������������0000664�0000000�0000000�00000007540�15100345067�0026025�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # Test concurrent move and refresh to make sure that they do not cause # issues that can lead to deadlocks. # # We check this by blocking the processing of the hypertable # invalidation log by locking all the rows of the hypertable # invalidation log. This will allow the functions to take locks on the # table but block on reading the rows. setup { SET timezone TO PST8PDT; CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW cagg_1 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW cagg_2 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; } # Refresh in separate transactions setup {CALL refresh_continuous_aggregate('cagg_1', '2020-01-01'::timestamptz, '2025-01-01');} setup {CALL refresh_continuous_aggregate('cagg_2', '2020-01-01'::timestamptz, '2025-01-01');} # Create some invalidations setup { INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2023-01-01 0:00:00+0'::timestamptz, '2023-01-01 23:59:59+0','1m') time; } teardown { DROP TABLE temperature CASCADE; } session "S1" step "s1_refresh" { CALL refresh_continuous_aggregate('cagg_1', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); } session "S2" step "s2_refresh" { CALL refresh_continuous_aggregate('cagg_2', '2020-01-01 00:00:00', '2025-01-01 00:00:00'); } session "S3" # This will generate an error since the refreshes above already # processed the hypertable invalidation log. This can happen also for # two concurrent refreshes. step "s3_process" { CALL _timescaledb_functions.process_hypertable_invalidations('temperature'); } session "S4" # Show thresholds just so that we know that they are correctly set. step s4_show_thresholds { SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, _timescaledb_functions.to_timestamp(watermark) AS watermark FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1; } step s4_before { START TRANSACTION; SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest_modified_value, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1, 2, 3 FOR UPDATE; } step s4_release { ROLLBACK; } step "s4_after" { SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest_modified_value, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1, 2, 3; } # Check that processing the hypertable and refreshing the associated # continuous aggerates do not lead to deadlock. permutation s4_show_thresholds s4_before s1_refresh s2_refresh s3_process s4_release s4_after ����������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_concurrent_process_wal.spec������������������������0000664�0000000�0000000�00000005662�15100345067�0027403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # Test concurrent hypertable invalidation processing when using # WAL-based hypertable invalidations. # # If two refresh procedures are executing at the same time, the second # one should wait for the first one to complete before dealing with # materializations. setup { SET timezone TO PST8PDT; SET timescaledb.enable_cagg_wal_based_invalidation TO true; CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); CREATE VIEW my_locks AS SELECT locktype, relation::regclass AS relname, classid::regclass AS objtyp, objid::regclass, mode, granted, application_name FROM pg_locks JOIN pg_stat_activity USING (pid) WHERE database = (SELECT oid FROM pg_database WHERE current_database() = datname) AND pid != pg_backend_pid() ORDER BY locktype, application_name, objtyp, objid; SELECT create_hypertable('temperature', 'time'); INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') time; } # All the below need to be in separate transactions. setup { CREATE MATERIALIZED VIEW cagg_1 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; } setup { CREATE MATERIALIZED VIEW cagg_2 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; } setup { CALL refresh_continuous_aggregate('cagg_1', '2020-01-01'::timestamptz, '2025-01-01'); } setup { CALL refresh_continuous_aggregate('cagg_2', '2020-01-01'::timestamptz, '2025-01-01'); } # Create some invalidations setup { INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2023-01-01'::timestamptz, '2023-01-02', '1m') time; } teardown { DROP VIEW my_locks; DROP MATERIALIZED VIEW cagg_2; DROP MATERIALIZED VIEW cagg_1; DROP TABLE temperature CASCADE; } session "s1" setup { set application_name = 's1'; } step s1_refresh {CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['temperature']);} session "s2" setup { set application_name = 's2'; } step s2_refresh {CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['temperature']);} session "locking" step lock_enable {SELECT debug_waitpoint_enable('multi_invalidation_process_invalidations');} step lock_show {SELECT locktype, granted, application_name, objtyp, objid FROM my_locks WHERE locktype in ('object', 'advisory');} step lock_release {SELECT debug_waitpoint_release('multi_invalidation_process_invalidations');} permutation lock_enable s1_refresh s2_refresh lock_show lock_release ������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_concurrent_refresh.spec����������������������������0000664�0000000�0000000�00000034075�15100345067�0026520�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # # Setup prior to every permutation. # # We define a function 'cagg_bucket_count' to get the number of # buckets in a continuous aggregate. We use it to verify that there # aren't any duplicate buckets/rows inserted into the materialization # hypertable after concurrent refreshes. Duplicate buckets are # possible since there is no unique constraint on the GROUP BY keys in # the materialized hypertable. # setup { SELECT _timescaledb_functions.stop_background_workers(); CREATE TABLE conditions(time int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 20); INSERT INTO conditions SELECT t, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION cond_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'cond_now'); CREATE MATERIALIZED VIEW cond_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, avg(temp) AS avg_temp FROM conditions GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW cond_20 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(20, time) AS bucket, avg(temp) AS avg_temp FROM conditions GROUP BY 1 WITH NO DATA; CREATE TABLE conditions2(time int, temp float); SELECT create_hypertable('conditions2', 'time', chunk_time_interval => 20); INSERT INTO conditions2 SELECT t, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION cond2_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions2 $$; SELECT set_integer_now_func('conditions2', 'cond2_now'); CREATE MATERIALIZED VIEW cond2_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, avg(temp) AS avg_temp FROM conditions2 GROUP BY 1 WITH NO DATA; CREATE OR REPLACE FUNCTION cagg_bucket_count(cagg regclass) RETURNS int AS $$ DECLARE cagg_schema name; cagg_name name; cagg_hyper_schema name; cagg_hyper_name name; cagg_hyper_relid regclass; result int; BEGIN SELECT nspname, relname INTO cagg_schema, cagg_name FROM pg_class c, pg_namespace n WHERE c.oid = cagg AND c.relnamespace = n.oid; SELECT format('%I.%I', h.schema_name, h.table_name)::regclass, h.schema_name, h.table_name INTO cagg_hyper_relid, cagg_hyper_schema, cagg_hyper_name FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE ca.user_view_name = cagg_name AND ca.user_view_schema = cagg_schema AND ca.mat_hypertable_id = h.id; EXECUTE format('SELECT count(*) FROM %I.%I', quote_ident(cagg_hyper_schema), quote_ident(cagg_hyper_name)) INTO result; RETURN result; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION lock_cagg(cagg name) RETURNS void AS $$ DECLARE mattable text; BEGIN SELECT format('%I.%I', user_view_schema, user_view_name) FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = cagg INTO mattable; EXECUTE format('LOCK table %s IN SHARE UPDATE EXCLUSIVE MODE', mattable); END; $$ LANGUAGE plpgsql; CREATE TABLE cancelpid ( pid INTEGER NOT NULL PRIMARY KEY ); CREATE OR REPLACE PROCEDURE cancelpids() AS $$ BEGIN PERFORM pg_cancel_backend(pid) FROM cancelpid; WHILE EXISTS (SELECT FROM pg_stat_activity WHERE pid IN (SELECT pid FROM cancelpid) AND state = 'active') LOOP PERFORM pg_sleep(0.01); END LOOP; DELETE FROM cancelpid; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE VIEW pending_materialization_ranges AS SELECT c.user_view_name, m.lowest_modified_value, m.greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_materialization_ranges m JOIN _timescaledb_catalog.continuous_agg c on c.mat_hypertable_id = m.materialization_id ORDER BY 1, 2, 3; } # Move the invalidation threshold so that we can generate some # invalidations. This must be done in its own setup block since # refreshing can't be done in a transaction block. setup { CALL refresh_continuous_aggregate('cond_10', 0, 30); } # Generate some invalidations. Must be done in separate transcations # or otherwise there will be only one invalidation. setup { BEGIN; INSERT INTO conditions SELECT t, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 10, 1) t; COMMIT; BEGIN; INSERT INTO conditions SELECT t, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(10, 20, 1) t; COMMIT; BEGIN; INSERT INTO conditions SELECT t, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(15, 40, 1) t; COMMIT; } teardown { DROP TABLE conditions CASCADE; DROP TABLE conditions2 CASCADE; DROP TABLE cancelpid; } # Waitpoint for cagg invalidation logs session "WP_after" step "WP_after_enable" { SELECT debug_waitpoint_enable('after_process_cagg_invalidations_for_refresh_lock'); } step "WP_after_release" { SELECT debug_waitpoint_release('after_process_cagg_invalidations_for_refresh_lock'); } session "WP_before" step "WP_before_enable" { SELECT debug_waitpoint_enable('before_process_cagg_invalidations_for_refresh_lock'); } step "WP_before_release" { SELECT debug_waitpoint_release('before_process_cagg_invalidations_for_refresh_lock'); } session "WP_after_materialization" step "WP_after_materialization_enable" { SELECT debug_waitpoint_enable('after_process_cagg_materializations'); } step "WP_after_materialization_release" { SELECT debug_waitpoint_release('after_process_cagg_materializations'); } # Session to refresh the cond_10 continuous aggregate session "R1" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; INSERT INTO cancelpid VALUES (pg_backend_pid()) ON CONFLICT (pid) DO NOTHING; } step "R1_refresh" { CALL refresh_continuous_aggregate('cond_10', 25, 70); } session "R12" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "R12_refresh" { CALL refresh_continuous_aggregate('cond2_10', 25, 70); } session "R13" step "R13_refresh" { CALL refresh_continuous_aggregate('cond_10', 65, 100); } # Refresh that overlaps with R1 session "R2" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "R2_refresh" { CALL refresh_continuous_aggregate('cond_10', 35, 62); } # Refresh on same aggregate (cond_10) that doesn't overlap with R1 and R2 session "R3" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "R3_refresh" { CALL refresh_continuous_aggregate('cond_10', 70, 107); } # Overlapping refresh on another continuous aggregate (cond_20) session "R4" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "R4_refresh" { CALL refresh_continuous_aggregate('cond_20', 39, 84); } # Refresh on same aggregate (cond_10) that doesn't overlap with R1 and R2 # with DEBUG1 enabled session "R5" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; SET SESSION client_min_messages = 'DEBUG1'; } step "R5_refresh" { CALL refresh_continuous_aggregate('cond_10', 70, 107); } # Check for pending materialization ranges session "R6" step "R6_pending_materialization_ranges" { SELECT * FROM pending_materialization_ranges WHERE user_view_name = 'cond_10'; } # Define a number of lock sessions to simulate concurrent refreshes # by selectively grabbing the locks we use to handle concurrency. # The "L1" session exclusively locks the invalidation threshold # table. This simulates an ongoing update of the invalidation # threshold, which has not yet finished. session "L1" setup { BEGIN; SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "L1_unlock_threshold_table" { ROLLBACK; } # The "L2" session takes an access share lock on the invalidation # threshold table. This simulates a reader, which has not yet finished # (e.g., and insert into the hypertable, or a refresh that has not yet # grabbed the exclusive lock). session "L2" setup { BEGIN; SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "L2_read_lock_threshold_table" { LOCK _timescaledb_catalog.continuous_aggs_invalidation_threshold IN ACCESS SHARE MODE; } step "L2_read_unlock_threshold_table" { ROLLBACK; } # The "L3" session locks the cagg table. This simulates an ongoing # refresh that has not yet completed and released the lock on the cagg # materialization table. # session "L3" setup { BEGIN; SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "L3_lock_cagg_table" { SELECT lock_cagg('cond_10'); } step "L3_unlock_cagg_table" { ROLLBACK; } # Session to view the contents of a cagg after materialization. It # also prints the bucket count (number of rows in the materialization # hypertable) and the invalidation threshold. The bucket count should # match the number of rows in the query if there are no duplicate # buckets/rows. session "S1" setup { SET SESSION lock_timeout = '500ms'; SET SESSION deadlock_timeout = '500ms'; } step "S1_select" { SELECT bucket, avg_temp FROM cond_10 ORDER BY 1; SELECT * FROM cagg_bucket_count('cond_10'); SELECT h.table_name AS hypertable, it.watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold it, _timescaledb_catalog.hypertable h WHERE it.hypertable_id = h.id ORDER BY 1; } session "K1" step "K1_cancelpid" { CALL cancelpids(); } #################################################################### # # Tests for concurrent updates to the invalidation threshold (first # transaction of a refresh). # #################################################################### # Run single transaction refresh to get some reference output. The # result of a query on the aggregate should always look like this # example (when refreshed with the same window). permutation "R1_refresh" "S1_select" "R3_refresh" "S1_select" "L2_read_unlock_threshold_table" "L3_unlock_cagg_table" "L1_unlock_threshold_table" # A threshold reader (insert) should block a refresh if the threshold # does not exist yet (insert of new threshold) permutation "L2_read_lock_threshold_table" "R3_refresh" "L2_read_unlock_threshold_table" "S1_select" "L3_unlock_cagg_table" "L1_unlock_threshold_table" # A threshold reader (insert) should block a refresh if the threshold # needs an update permutation "R1_refresh" "L2_read_lock_threshold_table" "R3_refresh" "L2_read_unlock_threshold_table" "S1_select" "L3_unlock_cagg_table" "L1_unlock_threshold_table" # A threshold reader (insert) blocks a refresh even if the threshold # doesn't need an update (could be improved) permutation "R3_refresh" "L2_read_lock_threshold_table" "R1_refresh" "L2_read_unlock_threshold_table" "S1_select" "L3_unlock_cagg_table" "L1_unlock_threshold_table" ################################################################## # # Tests for concurrent refreshes of continuous aggregates (second # and third transactions of a refresh). # ################################################################## # Interleave two refreshes that are overlapping (one simulated) permutation "L3_lock_cagg_table" "R1_refresh" "L3_unlock_cagg_table" "S1_select" "L1_unlock_threshold_table" "L2_read_unlock_threshold_table" # R1 and R2 queued to refresh permutation "L3_lock_cagg_table" "R1_refresh" "R2_refresh" "L3_unlock_cagg_table" "S1_select" "L1_unlock_threshold_table" "L2_read_unlock_threshold_table" # R1 and R3 don't have overlapping refresh windows, but should serialize # anyway cause we're locking the cagg hypertable permutation "L3_lock_cagg_table" "R1_refresh" "R3_refresh" "L3_unlock_cagg_table" "S1_select" "L1_unlock_threshold_table" "L2_read_unlock_threshold_table" # Concurrent refreshing across two different aggregates on same # hypertable does not block permutation "L3_lock_cagg_table" "R3_refresh" "R4_refresh" "L3_unlock_cagg_table" "S1_select" "L1_unlock_threshold_table" "L2_read_unlock_threshold_table" # Concurrent refresh of caggs on different hypertables should not # block each other permutation "R1_refresh" "R12_refresh" # CAgg invalidation logs processing in a separated transaction and the materialization # transaction can be executed concurrently permutation "WP_after_enable" "R1_refresh"("WP_after_enable") "R6_pending_materialization_ranges" "R5_refresh"("WP_after_enable") "R6_pending_materialization_ranges" "WP_after_release" "R6_pending_materialization_ranges" "S1_select" # CAgg materialization phase (third trasaction of the refresh procedure) terminated by another session and then # refreshing again and make sure the pending ranges will be processed permutation "WP_after_enable" "R6_pending_materialization_ranges" "R1_refresh"("WP_after_enable") "R3_refresh"("WP_after_enable") "K1_cancelpid"("R1_refresh") "R6_pending_materialization_ranges" "WP_after_release" "R13_refresh"("K1_cancelpid") "R6_pending_materialization_ranges" # R3 should wait for R1 to finish because there are cagg invalidation rows locked permutation "WP_before_enable" "R1_refresh"("WP_before_enable") "R3_refresh" "WP_before_release" # Concurrent refresh of caggs on non-overlapping ranges should not # block each other in the third transaction (materialization) permutation "WP_after_materialization_enable" "R1_refresh"("WP_after_materialization_enable") "WP_after_materialization_release" "R3_refresh" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_insert.spec����������������������������������������0000664�0000000�0000000�00000017405�15100345067�0024122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { SELECT _timescaledb_functions.stop_background_workers(); CREATE TABLE ts_continuous_test_1(time INTEGER, location INTEGER); SELECT create_hypertable('ts_continuous_test_1', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_test_1() RETURNS INTEGER LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM ts_continuous_test_1 $$; SELECT set_integer_now_func('ts_continuous_test_1', 'integer_now_test_1'); INSERT INTO ts_continuous_test_1 SELECT i, i FROM generate_series(0, 29) AS i; CREATE MATERIALIZED VIEW continuous_view_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test_1 GROUP BY 1 WITH NO DATA; CREATE TABLE ts_continuous_test_2(time INTEGER, location INTEGER); SELECT create_hypertable('ts_continuous_test_2', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_test_2() RETURNS INTEGER LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM ts_continuous_test_2 $$; SELECT set_integer_now_func('ts_continuous_test_2', 'integer_now_test_2'); INSERT INTO ts_continuous_test_2 SELECT i, i FROM generate_series(0, 29) AS i; CREATE MATERIALIZED VIEW continuous_view_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test_2 GROUP BY 1 WITH NO DATA; CREATE OR REPLACE FUNCTION lock_cagg(cagg name) RETURNS void AS $$ DECLARE mattable text; BEGIN SELECT format('%I.%I', user_view_schema, user_view_name) FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = cagg INTO mattable; EXECUTE format('LOCK TABLE %s IN EXCLUSIVE MODE', mattable); END; $$ LANGUAGE plpgsql; } teardown { DROP TABLE ts_continuous_test_1 CASCADE; DROP TABLE ts_continuous_test_2 CASCADE; } session "I" step "Ib" { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "I1" { INSERT INTO ts_continuous_test_1 VALUES (1, 1); } step "Ic" { COMMIT; } session "Ip" step "Ipb" { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "Ip1" { INSERT INTO ts_continuous_test_1 VALUES (29, 29); } step "Ipc" { COMMIT; } session "I2" step "I2b" { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "I21" { INSERT INTO ts_continuous_test_2 VALUES (1, 1); } step "I2c" { COMMIT; } session "S" step "Sb" { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "S1" { SELECT count(*) FROM ts_continuous_test_1; } step "Sc" { COMMIT; } session "SV" step "SV1" { SELECT * FROM continuous_view_1 ORDER BY 1; } session "R" setup { SET client_min_messages TO WARNING; } step "Refresh" { CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); } session "R1" setup { SET client_min_messages TO WARNING; } step "Refresh1" { CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); } session "R2" setup { SET client_min_messages TO WARNING; } step "Refresh2" { CALL refresh_continuous_aggregate('continuous_view_1', NULL, 15); } session "R3" setup { SET client_min_messages TO WARNING; } step "Refresh3" { CALL refresh_continuous_aggregate('continuous_view_2', NULL, 15); } # the invalidation log is copied in the first materialization transaction session "L" step "LockInval" { BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; } step "UnlockInval" { ROLLBACK; } # the invalidation threshold lock will NOT block INSERT and REFRESH session "LI" step "LockInvalThr" { BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold IN SHARE MODE; } step "UnlockInvalThr" { ROLLBACK; } # the invalidation threshold lock will block both INSERT and REFRESH session "LIE" step "LockInvalThrEx" { BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_invalidation_threshold ; } step "UnlockInvalThrEx" { ROLLBACK; } # locking a cagg's materialized hypertable will block the REFRESH in # the second transaction, but not INSERTs. session "LC1" step "LockCagg1" { BEGIN; SELECT lock_cagg('continuous_view_1'); } step "UnLockCagg1" { ROLLBACK; } session "LC2" step "LockCagg2" { BEGIN; SELECT lock_cagg('continuous_view_2'); } step "UnLockCagg2" { ROLLBACK; } # the materialization invalidation log session "LM" step "LockMatInval" { BEGIN; LOCK TABLE _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; } step "UnlockMatInval" { ROLLBACK; } # check for race condition creating triggers on the original hypertable session "CM1" step "CreateMatView1_Begin" { BEGIN; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test_1 GROUP BY 1 WITH NO DATA; } step "CreateMatView1_Commit" { COMMIT; } session "CM2" step "CreateMatView2_Begin" { BEGIN; CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test_1 GROUP BY 1 WITH NO DATA; } step "CreateMatView2_Commit" { COMMIT; } #only one refresh permutation "LockInvalThrEx" "Refresh" "Refresh2" (Refresh) "Refresh3" (Refresh, Refresh2) "UnlockInvalThrEx" #refresh and insert do not block each other once refresh is out of the #first transaction where it moves the invalidation threshold permutation "Ib" "LockCagg1" "I1" "Refresh" "Ic" "UnLockCagg1" permutation "Ib" "LockCagg1" "Refresh" "I1" "Ic" "UnLockCagg1" permutation "I2b" "LockCagg2" "I21" Refresh Refresh3(Refresh) "I2c" "UnLockCagg2" permutation "I2b" "LockCagg2" Refresh3 Refresh(*,Refresh3) "I21" "I2c" "UnLockCagg2" #refresh and select can run concurrently. Refresh blocked only by lock on # cagg's materialized hypertable. Needs RowExclusive for 2nd txn. permutation "Sb" "LockCagg1" "Refresh" "S1" "Sc" "UnLockCagg1" permutation "Sb" "LockCagg1" "S1" "Refresh" "Sc" "UnLockCagg1" #refresh will see new invalidations permutation "Ib" "LockInvalThr" "Refresh" "I1" "Ic" "UnlockInvalThr" permutation "Ib" "LockInvalThr" "I1" "Refresh" "Ic" "UnlockInvalThr" #with no invalidation threshold, inserts will not write to the invalidation log permutation "Ib" "LockInval" "I1" "Ic" "Refresh" "UnlockInval" #inserts beyond the invalidation will not write to the log, but since #the refresh currently takes an exclusive lock on the invalidation #threshold table (even if not updating the threshold) it will block #inserts in the first transaction of the refresh permutation "Ipb" "LockInval" "Refresh" "Ip1" "Ipc" "UnlockInval" permutation "Ipb" "LockInval" "Ip1" "Refresh" "Ipc" "UnlockInval" permutation "Ipb" "LockInval" "Ip1" "Ipc" "Refresh" "UnlockInval" #refresh and insert/select do not block each other #refresh1 is blocked on LockMatInval, insert is blocked on invalidation threshold. so refresh1 does not see the insert from I1 permutation "Refresh" "SV1" "LockMatInval" "Refresh1" "Ib" "I1" "LockInvalThrEx" "Ic" "UnlockMatInval" "UnlockInvalThrEx" "SV1" permutation "I1" "Refresh" "LockInval" "Refresh" "Sb" "S1" "Sc" "UnlockInval" permutation "I1" "Refresh" "LockInval" "Sb" "S1" "Refresh" "Sc" "UnlockInval" permutation "I1" "I21" Refresh1 Refresh2(Refresh1) Refresh3(Refresh1,Refresh2) permutation "I1" "I2b" "I21" Refresh2 Refresh3(Refresh2) "I2c" Refresh3(Refresh2) # check for race condition creating triggers on the original hypertable by concurrent create matviews permutation "CreateMatView1_Begin" "CreateMatView2_Begin" "CreateMatView1_Commit" "CreateMatView2_Commit" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_multi_iso.spec�������������������������������������0000664�0000000�0000000�00000010275�15100345067�0024620�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { SELECT _timescaledb_functions.stop_background_workers(); CREATE TABLE ts_continuous_test(time INTEGER, val INTEGER); SELECT create_hypertable('ts_continuous_test', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_test() returns INT LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM ts_continuous_test $$; SELECT set_integer_now_func('ts_continuous_test', 'integer_now_test'); INSERT INTO ts_continuous_test SELECT i, i FROM (SELECT generate_series(0, 29) AS i) AS i; } teardown { DROP FUNCTION lock_mattable( text ); DROP TABLE ts_continuous_test CASCADE; } #needed to avoid "SQL step too long" error in setup session "SetupContinue" step "Setup2" { CREATE MATERIALIZED VIEW continuous_view_1( bkt, cnt) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), COUNT(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW continuous_view_2(bkt, maxl) WITH ( timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('5', time), max(val) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; CREATE FUNCTION lock_mattable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s', name); END; $$ LANGUAGE plpgsql; } session "I" step "I1" { INSERT INTO ts_continuous_test SELECT 0, i*10 FROM (SELECT generate_series(0, 10) AS i) AS i; } step "I2" { INSERT INTO ts_continuous_test SELECT 40, 1000 ; } session "R1" setup { SET client_min_messages TO NOTICE; } step "Refresh1" { CALL refresh_continuous_aggregate('continuous_view_1', NULL, 30); } session "R1_sel" step "Refresh1_sel" { select * from continuous_view_1 where bkt = 0 or bkt > 30 } session "R2" setup { SET client_min_messages TO NOTICE; } step "Refresh2" { CALL refresh_continuous_aggregate('continuous_view_2', NULL, NULL); } session "R2_sel" step "Refresh2_sel" { select * from continuous_view_2 where bkt = 0 or bkt > 30 order by bkt; } #locking the materialized table will block refresh1 session "LM1" step "LockMat1" { BEGIN; select lock_mattable(tab) FROM ( SELECT format('%I.%I',materialization_hypertable_schema, materialization_hypertable_name) as tab from timescaledb_information.continuous_aggregates where view_name::text like 'continuous_view_1') q ; } step "UnlockMat1" { ROLLBACK; } #update the hypertable session "Upd" step "U1" { update ts_continuous_test SET val = 5555 where time < 10; } step "U2" { update ts_continuous_test SET val = 5 where time > 15 and time < 25; } #simulate an update to the invalidation threshold table that would lock the hypertable row #this would block refresh that needs to get a row lock for the hypertable session "LInv" step "LInvRow" { BEGIN; update _timescaledb_catalog.continuous_aggs_invalidation_threshold set watermark = 20 where hypertable_id in ( select raw_hypertable_id from _timescaledb_catalog.continuous_agg where user_view_name like 'continuous_view_1' ); } step "UnlockInvRow" { ROLLBACK; } #refresh1, refresh2 can run concurrently permutation "Setup2" "LockMat1" "Refresh1" "Refresh2" "UnlockMat1" #refresh1 and refresh2 run concurrently and see the correct invalidation #test1 - both see the same invalidation permutation "Setup2" "Refresh1" "Refresh2" "LockMat1" "I1" "Refresh1" "Refresh2" "UnlockMat1" "Refresh1_sel" "Refresh2_sel" ##test2 - continuous_view_2 should see results from insert but not the other one. ## Refresh2 will complete first due to LockMat1 and write the invalidation logs out. permutation "Setup2" "Refresh1" "Refresh2" "Refresh1_sel" "Refresh2_sel" "LockMat1" "I2" "Refresh1" "Refresh2" "UnlockMat1" "Refresh1_sel" "Refresh2_sel" #test3 - both see the updates i.e. the invalidations ##Refresh1 and Refresh2 are blocked by LockInvRow, when that is unlocked, they should complete serially permutation "Setup2" "Refresh1" "Refresh2" "Refresh1_sel" "Refresh2_sel" "U1" "U2" "LInvRow" "Refresh1" "Refresh2" "UnlockInvRow" "Refresh1_sel" "Refresh2_sel" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/cagg_watermark_concurrent_update.spec�������������������0000664�0000000�0000000�00000005421�15100345067�0030412�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # # Test concurrent CAgg refreshes and invalidation threshold updates. This isolation test # checks that we don't skip CAgg updates when two sessions are trying to modify the # invalidation threshold at the same time. # setup { SET timezone TO PST8PDT; CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW cagg WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), avg(value) FROM temperature GROUP BY 1 ORDER BY 1 WITH NO DATA; } # Refresh CAGG in separate transaction setup { CALL refresh_continuous_aggregate('cagg', NULL, NULL); } # Add new data to hypertable. This time in the year 2020 instead of 2000 as we # did for the setup of the CAgg. setup { INSERT INTO temperature SELECT time, ceil(random() * 100)::int FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') time; } setup { VACUUM ANALYZE; } teardown { DROP TABLE temperature CASCADE; } session "S1" step "s1_run_update" { CALL refresh_continuous_aggregate('cagg', '2020-01-01 00:00:00', '2021-01-01 00:00:00'); } step "s1_insert_more_data" { INSERT INTO temperature VALUES('2020-01-02 23:59:59+0', 22); } step "s1_prepare" { PREPARE pstmt AS SELECT * FROM cagg; } step "s1_select" { EXPLAIN (COSTS OFF) EXECUTE pstmt; } session "S2" step "s2_prepare" { PREPARE pstmt AS SELECT * FROM cagg; } step "s2_select" { EXPLAIN (COSTS OFF) EXECUTE pstmt; } session "S3" step "s3_lock_invalidation" { SELECT debug_waitpoint_enable('cagg_watermark_update_internal_before_refresh'); } step "s3_release_invalidation" { SELECT debug_waitpoint_release('cagg_watermark_update_internal_before_refresh'); } # Updated watermark (01-01-2020) should be seen by s2_select after s3_release_invalidation completes permutation "s1_prepare" "s2_prepare" "s3_lock_invalidation" "s2_select" "s1_run_update" "s2_select" "s3_release_invalidation" "s2_select" "s1_select" # Updated watermark (02-01-2020) should be seen by s2_select after second s3_release_invalidation completes permutation "s3_lock_invalidation" "s2_select" "s1_run_update" "s2_select" "s3_release_invalidation" "s3_lock_invalidation"("s1_run_update") "s1_insert_more_data" "s1_run_update" "s2_select" "s3_release_invalidation" "s2_select" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/compression_chunk_race.spec�����������������������������0000664�0000000�0000000�00000010160�15100345067�0026347�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # Test the execution of two compression jobs in parallel ### setup { CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); -- Create large chunks that take a long time to compress SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '14 days'); INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-15', INTERVAL '1 minute') AS g1(time), generate_series(1, 50, 1) AS g2(sensor_id) ORDER BY time; SELECT count(*) FROM sensor_data; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id'); } teardown { DROP TABLE sensor_data; } session "s1" setup { SET client_min_messages=ERROR; -- Suppress chunk "_hyper_XXX_chunk" is not compressed messages } step "s1_compress" { SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; } step "s1_decompress" { SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; } session "s2" setup { SET client_min_messages=ERROR; -- Suppress chunk "_hyper_XXX_chunk" is not compressed messages } step "s2_compress" { SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; RESET client_min_messages; } step "s2_decompress" { SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; RESET client_min_messages; } session "s3" step "s3_lock_compression" { SELECT debug_waitpoint_enable('compress_chunk_impl_start'); } step "s3_lock_decompression" { SELECT debug_waitpoint_enable('decompress_chunk_impl_start'); } step "s3_unlock_compression" { -- Ensure that we are waiting on our debug waitpoint and one chunk -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- compress_chunk_impl_start = 3379597659. -- 'SELECT relation::regclass, ....' can not be used, because it returns a field with a variable length SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND (locktype = 'advisory' or relation::regclass::text LIKE '%chunk') ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compress_chunk_impl_start'); } step "s3_unlock_decompression" { -- Ensure that we are waiting on our debug waitpoint and one chunk -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- decompress_chunk_impl_start = 2415054640. -- 'SELECT relation::regclass, ....' can not be used, because it returns a field with a variable length SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND (locktype = 'advisory' or relation::regclass::text LIKE '%chunk') ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('decompress_chunk_impl_start'); } permutation "s3_lock_compression" "s3_lock_decompression" "s1_compress" "s2_compress" (s1_compress) "s3_unlock_compression" "s1_decompress" "s2_decompress" (s1_decompress) "s3_unlock_decompression" ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/compression_conflicts_iso.spec��������������������������0000664�0000000�0000000�00000023173�15100345067�0027113�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { CREATE TABLE ts_device_table(time INTEGER, device INTEGER, location INTEGER, value INTEGER); CREATE UNIQUE INDEX device_time_idx on ts_device_table(time, device); SELECT create_hypertable('ts_device_table', 'time', chunk_time_interval => 10); INSERT INTO ts_device_table SELECT generate_series(0,9,1), 1, 100, 20; ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_segmentby='location', timescaledb.compress_orderby='time'); CREATE OR REPLACE FUNCTION lock_chunktable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s IN SHARE MODE', name); END; $$ LANGUAGE plpgsql; CREATE FUNCTION count_chunktable(tbl regclass) RETURNS TABLE("count(*)" int, "count(*) only" int) AS $$ DECLARE c int;c_only int; BEGIN EXECUTE format('SELECT count(*) FROM %s', tbl) INTO c; EXECUTE format('SELECT count(*) FROM ONLY %s', tbl) INTO c_only; RETURN QUERY SELECT c,c_only; END; $$ LANGUAGE plpgsql; } teardown { DROP TABLE ts_device_table cascade; DROP FUNCTION lock_chunktable; DROP FUNCTION count_chunktable; } session "I" step "IB" { BEGIN; } step "IBRR" { BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; } step "IBS" { BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; } step "I1" { INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; } step "Iu1" { INSERT INTO ts_device_table VALUES (1, 1, 100, 98) ON CONFLICT(time, device) DO UPDATE SET value = 98; } step "Ic" { COMMIT; } session "IN" step "IN1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) ON CONFLICT DO NOTHING; } step "INu1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 99) ON CONFLICT(time, device) DO UPDATE SET value = 99; } step "INc" { COMMIT; } session "SI" step "SChunkStat" { SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); } session "S" step "SB" { BEGIN; } step "SR" { ROLLBACK; } step "S1" { SELECT count(*) from ts_device_table; } step "SC1" { SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch LIMIT 1; } step "SH" { SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); } step "SA" { SELECT * FROM ts_device_table; } step "SU" { SELECT * FROM ts_device_table WHERE value IN (98,99); } # Step to confirm previous step finished step "SF" {} session "LCT" step "LockChunkTuple" { BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; } step "UnlockChunkTuple" { ROLLBACK; } session "LC" step "LockChunk1" { BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; } step "UnlockChunk" {ROLLBACK;} session "C" step "C1" { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT CASE WHEN compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL THEN true ELSE false END AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; } step "Cc" { COMMIT; } session "CompressAll" step "CA1" { BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; } step "CAc" { COMMIT; } session "DecompressAll" step "DA1" { BEGIN; SELECT CASE WHEN decompress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; } step "DAc" { COMMIT; } session "RecompressChunk" step "RC" { DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; } #If insert is in progress, compression is blocked. permutation "LockChunk1" "IB" "I1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" "SChunkStat" permutation "LockChunk1" "IBRR" "I1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" "SChunkStat" permutation "LockChunk1" "IBS" "I1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" "SChunkStat" permutation "LockChunk1" "IB" "Iu1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" "SU" "SChunkStat" permutation "LockChunk1" "IBRR" "Iu1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" "SU" "SChunkStat" permutation "LockChunk1" "IBS" "Iu1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" "SU" "SChunkStat" #Compress in progress, insert is blocked permutation "LockChunk1" "C1" "IB" "I1" "UnlockChunk" "Cc" "Ic" "SC1" "SA" "SChunkStat" permutation "LockChunk1" "C1" "IBRR" "I1" "UnlockChunk" "Cc" "Ic" "SC1" "SA" "SChunkStat" permutation "LockChunk1" "C1" "IBS" "I1" "UnlockChunk" "Cc" "Ic" "SC1" "SA" "SChunkStat" permutation "LockChunk1" "C1" "IB" "Iu1" "UnlockChunk" "Cc" "Ic" "SC1" "SA" "SChunkStat" permutation "LockChunk1" "C1" "IBRR" "Iu1" "UnlockChunk" "Cc" "Ic" "SC1" "SA" "SChunkStat" permutation "LockChunk1" "C1" "IBS" "Iu1" "UnlockChunk" "Cc" "Ic" "SC1" "SA" "SChunkStat" # Concurrent inserts into compressed chunk will update chunk status and not error out. permutation "C1" "Cc" "LockChunkTuple" "IB" "I1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBRR" "I1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBS" "I1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IB" "I1" "INu1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SU" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBRR" "I1" "INu1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBS" "I1" "INu1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IB" "Iu1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SU" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBRR" "Iu1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBS" "Iu1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IB" "Iu1" "INu1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SU" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBRR" "Iu1" "INu1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" permutation "C1" "Cc" "LockChunkTuple" "IBS" "Iu1" "INu1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" "SA" # Testing concurrent recompress and insert. # Insert will succeed after first phase of recompress completes. # - First compress chunk and insert into chunk # - Then start concurrent processes both recompress_chunk and insert # - Wait for lock on the chunk. permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IB" "I1" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IBRR" "I1" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IBS" "I1" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IB" "Iu1" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IBRR" "Iu1" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" "SU" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IBS" "Iu1" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" "SU" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "IN1" "UnlockChunk" "INc" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "RC" "INu1" "UnlockChunk" "INc" "SH" "SA" "SChunkStat" "SU" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IB" "I1" "RC" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IBRR" "I1" "RC" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IBS" "I1" "RC" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IB" "Iu1" "RC" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" "SU" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IBRR" "Iu1" "RC" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" "SU" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IBS" "Iu1" "RC" "UnlockChunk" "Ic" "SH" "SA" "SChunkStat" "SU" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "IN1" "RC" "UnlockChunk" "INc" "SH" "SA" "SChunkStat" permutation "CA1" "CAc" "I1" "SChunkStat" "LockChunk1" "INu1" "RC" "UnlockChunk" "INc" "SH" "SA" "SChunkStat" "SU" # Decompressing a chunk should not stop any reads # until the end when we drop the compressed chunk # which happens after updates to the chunk catalog tuple permutation "CA1" "CAc" "LockChunkTuple" "DA1" "SA" "SF" "UnlockChunkTuple" "DAc" # Compressing a chunk should not stop any reads # Truncating the uncompressed chunk (which happens at the end # of the operations along with catalog updates) does not block # It falls back to deleting the tuples row-by-row if lock upgrade does not go through permutation "SB" "SA" "CA1" "SA" "SF" "SR" "CAc" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/compression_ddl_iso.spec��������������������������������0000664�0000000�0000000�00000014323�15100345067�0025667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { CREATE TABLE ts_device_table(time INTEGER, device INTEGER, location INTEGER, value INTEGER); SELECT create_hypertable('ts_device_table', 'time', chunk_time_interval => 10); INSERT INTO ts_device_table SELECT generate_series(0,29,1), 1, 100, 20; ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_segmentby='location', timescaledb.compress_orderby='time'); CREATE OR REPLACE FUNCTION lock_chunktable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s IN SHARE MODE', name); END; $$ LANGUAGE plpgsql; CREATE FUNCTION count_chunktable(tbl regclass) RETURNS TABLE("count(*)" int, "count(*) only" int) AS $$ DECLARE c int;c_only int; BEGIN EXECUTE format('SELECT count(*) FROM %s', tbl) INTO c; EXECUTE format('SELECT count(*) FROM ONLY %s', tbl) INTO c_only; RETURN QUERY SELECT c,c_only; END; $$ LANGUAGE plpgsql; } teardown { DROP TABLE ts_device_table cascade; DROP FUNCTION lock_chunktable; DROP FUNCTION count_chunktable; } session "I" step "I1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); } step "IR1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100) RETURNING *; } step "Ic" { COMMIT; } session "IN" step "IN1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); } step "INR1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100) RETURNING *; } step "INc" { COMMIT; } session "SI" step "SChunkStat" { SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); } session "S" step "S1" { SELECT count(*) from ts_device_table; } step "SC1" { SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text LIMIT 1; } step "SH" { SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); } step "SA" { SELECT * FROM ts_device_table t ORDER BY t; } session "LCT" step "LockChunkTuple" { BEGIN; SELECT status as chunk_status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table') FOR UPDATE; } step "UnlockChunkTuple" { ROLLBACK; } session "LC" step "LockChunk1" { BEGIN; SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; } step "UnlockChunk" {ROLLBACK;} session "C" step "C1" { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; SELECT compress_chunk(format('%I.%I',ch.schema_name, ch.table_name)) IS NOT NULL AS compress FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table' ORDER BY ch.id LIMIT 1; } step "Cc" { COMMIT; } session "A" step "A1" { BEGIN; ALTER TABLE ts_device_table SET ( fillfactor = 80); } step "A2" { COMMIT; } session "D" step "D1" { BEGIN; SET LOCAL client_min_messages TO WARNING; SELECT decompress_chunk(ch) IS NOT NULL AS decompress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text LIMIT 1; } step "Dc" { COMMIT; } session "CompressAll" step "CA1" { BEGIN; SELECT compress_chunk(ch) IS NOT NULL AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; } step "CAc" { COMMIT; } session "RecompressChunk1" step "RC1" { DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch LIMIT 1 LOOP PERFORM compress_chunk(chunk_name); END LOOP; END; $$; } session "RecompressChunk2" step "RC2" { DO $$ DECLARE chunk_name text; BEGIN FOR chunk_name IN SELECT ch FROM show_chunks('ts_device_table') ch ORDER BY ch::text LIMIT 1 LOOP PERFORM compress_chunk(chunk_name, false); END LOOP; END; $$; } #if insert in progress, compress is blocked permutation "LockChunk1" "I1" "C1" "UnlockChunk" "Ic" "Cc" "SC1" "S1" #Compress in progress, insert is blocked permutation "LockChunk1" "C1" "I1" "UnlockChunk" "Cc" "Ic" #if ddl in progress, compress_chunk blocked permutation "LockChunk1" "A1" "C1" "UnlockChunk" "Cc" "A2" permutation "LockChunk1" "A1" "C1" "UnlockChunk" "A2" "Cc" #concurrent compress/decompress on same chunk errors permutation "LockChunk1" "C1" "D1" "UnlockChunk" "Cc" "Dc" #concurrent compress and select should execute concurrently permutation "LockChunk1" "C1" "S1" "UnlockChunk" "Cc" "SH" permutation "LockChunk1" "C1" "S1" "UnlockChunk" "SH" "Cc" # concurrent inserts into compressed chunk will wait to update chunk status # and not error out. permutation "C1" "Cc" "LockChunkTuple" "I1" "IN1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" #concurrent inserts don't need to wait for each other if inserting into a partially compressed chunk #commit order should not matter in that case permutation "C1" "Cc" "I1" "Ic" "LockChunkTuple" "I1" "IN1" "UnlockChunkTuple" "INc" "Ic" "SChunkStat" #concurrent inserts into compressed chunk with RETURNING clause should behave the same permutation "C1" "Cc" "LockChunkTuple" "IR1" "INR1" "UnlockChunkTuple" "Ic" "INc" "SChunkStat" permutation "C1" "Cc" "I1" "Ic" "LockChunkTuple" "IR1" "INR1" "UnlockChunkTuple" "INc" "Ic" "SChunkStat" # Testing concurrent recompress and insert. # Insert will succeed after first phase of recompress completes. # - First compress chunk and insert into chunk # - Then start concurrent processes both recompress_chunk and insert # - Wait for lock on the chunk. permutation "CA1" "CAc" "I1" "Ic" "SChunkStat" "LockChunk1" "RC1" "IN1" "UnlockChunk" "INc" "SH" "SA" "SChunkStat" # Test concurrent recompress operations permutation "CA1" "CAc" "I1" "Ic" "SChunkStat" "LockChunk1" "RC1" "RC2" "UnlockChunk" "SH" "SA" "SChunkStat" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/compression_dml_iso.spec��������������������������������0000664�0000000�0000000�00000010771�15100345067�0025703�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { CREATE TABLE ts_device_table(time INTEGER, device INTEGER, location INTEGER, value INTEGER); SELECT create_hypertable('ts_device_table', 'time', chunk_time_interval => 10); INSERT INTO ts_device_table SELECT generate_series(0,29,1), 1, 100, 20; ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_segmentby='location', timescaledb.compress_orderby='time'); CREATE OR REPLACE FUNCTION lock_chunktable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s IN SHARE MODE', name); END; $$ LANGUAGE plpgsql; CREATE FUNCTION count_chunktable(tbl regclass) RETURNS TABLE("count(*)" int, "count(*) only" int) AS $$ DECLARE c int;c_only int; BEGIN EXECUTE format('SELECT count(*) FROM %s', tbl) INTO c; EXECUTE format('SELECT count(*) FROM ONLY %s', tbl) INTO c_only; RETURN QUERY SELECT c,c_only; END; $$ LANGUAGE plpgsql; } teardown { DROP TABLE ts_device_table cascade; DROP FUNCTION lock_chunktable; DROP FUNCTION count_chunktable; } session "I" step "I1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 100, 100); } step "Ic" { COMMIT; } session "IN" step "IN1" { BEGIN; INSERT INTO ts_device_table VALUES (1, 1, 200, 100); } step "INc" { COMMIT; } session "DEL" step "DEL1" { BEGIN; DELETE from ts_device_table WHERE location = 200; } step "DELrr" { BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; DELETE from ts_device_table WHERE location = 200; } step "DELs" { BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; DELETE from ts_device_table WHERE location = 200; } step "DELc" { COMMIT; } session "UPD" step "UPD1" { BEGIN; UPDATE ts_device_table SET value = 4 WHERE location = 200; } step "UPDrr" { BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; UPDATE ts_device_table SET value = 4 WHERE location = 200; } step "UPDs" { BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; UPDATE ts_device_table SET value = 4 WHERE location = 200; } step "UPDc" { COMMIT; } session "SI" step "SChunkStat" { SELECT status from _timescaledb_catalog.chunk WHERE id = ( select min(ch.id) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'ts_device_table'); } session "S" step "S1" { SELECT count(*) from ts_device_table; } step "SC1" { SELECT (count_chunktable(ch)).* FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text LIMIT 1; } step "SH" { SELECT total_chunks, number_compressed_chunks from hypertable_compression_stats('ts_device_table'); } step "SA" { SELECT * FROM ts_device_table; } step "SS" { SELECT * FROM ts_device_table WHERE location = 200; } session "CompressAll" step "CA1" { BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN true ELSE false END AS compress FROM show_chunks('ts_device_table') AS ch ORDER BY ch::text; } step "NOS" { ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_orderby='time'); } step "CAc" { COMMIT; } # Test concurrent update/delete operations permutation "CA1" "CAc" "SH" "I1" "Ic" "SH" "UPD1" "UPDc" "SH" "DEL1" "DELc" "SH" "UPD1" "UPDc" "SH" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "DEL1" "UPD1" "DELc" "UPDc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "UPD1" "DEL1" "UPDc" "DELc" "SH" "SS" # Test same operations with no segmentby columns (no index scanning) permutation "NOS" "CA1" "CAc" "SH" "I1" "Ic" "SH" "UPD1" "UPDc" "SH" "DEL1" "DELc" "SH" "UPD1" "UPDc" "SH" permutation "NOS" "IN1" "INc" "CA1" "CAc" "SH" "SS" "DEL1" "UPD1" "DELc" "UPDc" "SH" "SS" permutation "NOS" "IN1" "INc" "CA1" "CAc" "SH" "SS" "UPD1" "DEL1" "UPDc" "DELc" "SH" "SS" #Test interaction with upper isolation levels permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "DEL1" "UPDrr" "DELc" "UPDc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "UPD1" "DELrr" "UPDc" "DELc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "DELrr" "UPDrr" "DELc" "UPDc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "UPDrr" "DELrr" "UPDc" "DELc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "DELrr" "UPDs" "DELc" "UPDc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "UPDrr" "DELs" "UPDc" "DELc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "DELs" "UPDrr" "DELc" "UPDc" "SH" "SS" permutation "IN1" "INc" "CA1" "CAc" "SH" "SS" "UPDs" "DELrr" "UPDc" "DELc" "SH" "SS" �������timescaledb-2.23.0/tsl/test/isolation/specs/compression_freeze.spec���������������������������������0000664�0000000�0000000�00000011777�15100345067�0025544�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # This test verifies if the compressed and uncompressed data are seen in parallel. Since # we freeze the compressed data immediately, it becomes visible to all transactions # that are running concurrently. However, parallel transactions should not be able to # see the compressed hypertable in the catalog and query the data two times. ### setup { CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); -- Create large chunks that take a long time to compress SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '14 days'); INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-15', INTERVAL '1 hour') AS g1(time), generate_series(1, 50, 1) AS g2(sensor_id) ORDER BY time; SELECT count(*) FROM sensor_data; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id'); } teardown { DROP TABLE sensor_data; } session "s1" step "s1_compress" { SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; } step "s1_compress_delete" { SET timescaledb.compress_truncate_behaviour TO truncate_disabled; SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; } step "s1_compress_truncate_or_delete" { SET timescaledb.compress_truncate_behaviour TO truncate_or_delete; SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; } step "s1_select_count" { SELECT count(*) FROM sensor_data; } session "s2" step "s2_select_count_and_stats" { SELECT count(*) FROM sensor_data; SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2; } step "s2_lock_compression" { SELECT debug_waitpoint_enable('compression_done_before_truncate_uncompressed'); } step "s2_lock_compression_after_truncate" { SELECT debug_waitpoint_enable('compression_done_after_truncate_uncompressed'); } step "s2_lock_compression_after_delete" { SELECT debug_waitpoint_enable('compression_done_after_delete_uncompressed'); } step "s2_lock_compression_after_truncate_or_delete" { SELECT debug_waitpoint_enable('compression_done_after_truncate_or_delete_uncompressed'); } step "s2_unlock_compression" { SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND (locktype = 'advisory' or relation::regclass::text LIKE '%chunk') ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_before_truncate_uncompressed'); } step "s2_unlock_compression_after_truncate" { SELECT locktype, mode, granted, objid FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_after_truncate_uncompressed'); } step "s2_unlock_compression_after_delete" { SELECT locktype, mode, granted, objid FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_after_delete_uncompressed'); } step "s2_unlock_compression_after_truncate_or_delete" { SELECT locktype, mode, granted, objid FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('compression_done_after_truncate_or_delete_uncompressed'); } permutation "s1_select_count" "s2_select_count_and_stats" permutation "s1_select_count" "s1_compress" "s1_select_count" "s2_select_count_and_stats" permutation "s2_lock_compression" "s2_select_count_and_stats" "s1_compress" "s2_select_count_and_stats" "s2_unlock_compression" "s2_select_count_and_stats" # Check after TRUNCATE permutation "s2_lock_compression_after_truncate" "s2_select_count_and_stats" "s1_compress" "s2_unlock_compression_after_truncate" "s2_select_count_and_stats" # Check after DELETE permutation "s2_lock_compression_after_delete" "s2_select_count_and_stats" "s1_compress_delete" "s2_select_count_and_stats" "s2_unlock_compression_after_delete" "s2_select_count_and_stats" # Check after TRUNCATE OR DELETE # Ideally, we want s2 to be a transaction, so that we can test the spin-lock that is triggered here. # However, spin locks don't play well with isolation tests, so that is tesed in a TAP test instead `tsl/test/t/004_truncate_or_delete_spin_lock_test.pl` permutation "s2_lock_compression_after_truncate_or_delete" "s2_select_count_and_stats" "s1_compress_truncate_or_delete" "s2_unlock_compression_after_truncate_or_delete" "s2_select_count_and_stats" �timescaledb-2.23.0/tsl/test/isolation/specs/compression_merge_race.spec�����������������������������0000664�0000000�0000000�00000012446�15100345067�0026347�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # Test the execution of two merge compression jobs in parallel ### setup { -- Compressing a lot of chunks from a single hypertable in a single transaction can -- cause deadlocks due to locking the compressed hypertable when creating compressed chunks. -- Hence we compress them in their individual transactions, similar how the compression -- policies work. CREATE OR REPLACE PROCEDURE compress_chunks_in_individual_transactions(query text) LANGUAGE plpgsql AS $$ DECLARE chunk regclass; BEGIN FOR chunk in execute query LOOP PERFORM public.compress_chunk(chunk); COMMIT; END LOOP; END; $$; CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); -- Create large chunks that take a long time to compress SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '1 hour', create_default_indexes => false); INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-02 23:59:59', INTERVAL '1 minute') AS g1(time), generate_series(1, 50, 1) AS g2(sensor_id) ORDER BY time; ALTER TABLE sensor_data SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id', timescaledb.compress_orderby = 'time', timescaledb.compress_chunk_time_interval = '2 hours'); } teardown { DROP TABLE sensor_data; } session "s1" step "s1_compress_first_half_of_chunks" { call compress_chunks_in_individual_transactions( $$ select show_chunks('sensor_data') limit 24 $$ ); } step "s1_compress_all_chunks_single_transaction" { BEGIN; select count(compress_chunk(c, true)) from show_chunks('sensor_data') c; } step "s1_compress_finish" { COMMIT; } step "s1_compress_single_chunk" { select compress_chunk(c, true) from show_chunks('sensor_data') c limit 1; } # Compress first two chunks, skip two and compress next two etc. step "s1_compress_first_two_by_two" { call compress_chunks_in_individual_transactions( $$ select i.show_chunks from ( select row_number() over () as row_number, i as show_chunks from show_chunks('sensor_data') i ) i where i.row_number%4 in (1,2) $$); } session "s2" step "s2_compress_second_half_of_chunks" { call compress_chunks_in_individual_transactions($$select show_chunks('sensor_data') i offset 24$$); } # Compress second two chunks, skip two and compress next two etc. step "s2_compress_second_two_by_two" { call compress_chunks_in_individual_transactions( $$ select i.show_chunks from ( select row_number() over () as row_number, i as show_chunks from show_chunks('sensor_data') i ) i where i.row_number%4 in (3,0) $$); } session "s3" step "s3_lock_compression" { SELECT debug_waitpoint_enable('compress_chunk_impl_start'); } step "s3_unlock_compression" { SELECT debug_waitpoint_release('compress_chunk_impl_start'); } step "s3_count_chunks_pre_compression" { select count(*), 48 as expected from show_chunks('sensor_data'); } step "s3_count_chunks_post_compression" { select count(*), 24 as expected from show_chunks('sensor_data'); } step "s3_select_on_compressed_chunk" { DO $$ DECLARE hyper_id int; chunk_id int; BEGIN SELECT h.compressed_hypertable_id, c.compressed_chunk_id INTO hyper_id, chunk_id FROM _timescaledb_catalog.hypertable h INNER JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id WHERE h.table_name = 'sensor_data' AND c.compressed_chunk_id IS NOT NULL; EXECUTE format('SELECT * FROM _timescaledb_internal.compress_hyper_%s_%s_chunk WHERE sensor_id = 40 AND temperature IS NOT NULL;', hyper_id, chunk_id); END; $$; } step "s3_wait_for_finish" { } # Check that we produce 24 chunks out of 48 chunks by merging two 1hour chunks # into 2 hour chunks from two different sessions. First session will run until # it hits an already compressed chunk. permutation "s3_count_chunks_pre_compression" "s3_lock_compression" "s1_compress_first_half_of_chunks" "s2_compress_second_half_of_chunks" (s1_compress_first_half_of_chunks) "s3_unlock_compression" (s2_compress_second_half_of_chunks, s1_compress_first_half_of_chunks) "s3_count_chunks_post_compression" permutation "s3_count_chunks_pre_compression" "s3_lock_compression" "s1_compress_first_two_by_two" "s2_compress_second_two_by_two" (s1_compress_first_two_by_two) "s3_unlock_compression" (s2_compress_second_two_by_two, s1_compress_first_two_by_two) "s3_count_chunks_post_compression" # Check that we can read existing compressed data during chunk compression when merging. # The query uses an index scan to verify we are not blocked on using it during compression. permutation "s1_compress_single_chunk" "s1_compress_all_chunks_single_transaction" "s3_select_on_compressed_chunk" "s3_wait_for_finish" "s1_compress_finish" ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/compression_recompress.spec�����������������������������0000664�0000000�0000000�00000030125�15100345067�0026432�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # Test recompression doesn't block (or deadlock with) read operations ### setup { CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); SELECT FROM create_hypertable('sensor_data','time', create_default_indexes => false); INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 23:59:59', INTERVAL '1 minute') AS g1(time), generate_series(1, 5, 1) AS g2(sensor_id) ORDER BY time; CREATE UNIQUE INDEX ON sensor_data (time, sensor_id); ALTER TABLE sensor_data SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id', timescaledb.compress_orderby = 'time'); SELECT compress_chunk(show_chunks('sensor_data')); -- Create partially compressed chunk that we can recompress using segmentwise INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 23:59:59', INTERVAL '1 minute') AS g1(time), generate_series(10, 15, 1) AS g2(sensor_id) ORDER BY time; } teardown { DROP TABLE sensor_data; } session "s1" step "s1_begin" { BEGIN; } step "s1_recompress_chunk" { SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; } step "s1_commit" { COMMIT; } step "s1_rollback" { ROLLBACK; } step "s1_compress" { SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; } step "s1_decompress" { SELECT count(*) FROM (SELECT decompress_chunk(i) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); SELECT count(*) FROM sensor_data; } step "s1_show_chunk_state" { SELECT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; SELECT count(*) FROM sensor_data; } step "s1_insert_for_recompression" { INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, 5 as sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01 00:00:00', '2022-01-01 00:59:59', INTERVAL '1 minute') AS g1(time) ORDER BY time; } session "s2" step "s2_begin" { BEGIN; } step "s2_commit" { COMMIT; } step "s2_select_from_compressed_chunk" { SELECT sum(temperature) > 1 FROM sensor_data WHERE sensor_id = 2; } ## select should not be blocked by the recompress_chunk_segmentwise in progress step "s2_wait_for_finish" { } step "s2_insert_do_nothing" { INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 1, 1.0, 1.0), ('2022-01-01 21:00'::timestamptz, 2, 2.0, 2.0) ON CONFLICT (time, sensor_id) DO NOTHING; } step "s2_insert_existing_do_nothing" { INSERT INTO sensor_data SELECT time, sensor_id, 1.0, 1.0 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO NOTHING; } step "s2_upsert" { INSERT INTO sensor_data VALUES ('2022-01-01 20:00'::timestamptz, 100, 9999, 9999), ('2022-01-01 21:00'::timestamptz, 101, 9999, 9999) ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; } step "s2_upsert_existing" { INSERT INTO sensor_data SELECT time, sensor_id, 9999, 9999 FROM sensor_data WHERE sensor_id = 4 LIMIT 1 ON CONFLICT (time, sensor_id) DO UPDATE SET cpu = EXCLUDED.cpu, temperature = EXCLUDED.temperature; } step "s2_delete_compressed" { DELETE FROM sensor_data WHERE sensor_id = 1; } step "s2_delete_uncompressed" { DELETE FROM sensor_data WHERE sensor_id = 11; } step "s2_delete_recompressed" { DELETE FROM sensor_data WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; } step "s2_update_compressed" { UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 1; } step "s2_update_uncompressed" { UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 11; } step "s2_update_recompressed" { UPDATE sensor_data SET cpu = 9999 WHERE sensor_id = 5 AND time > '2022-01-01 01:00'::timestamptz; } step "s2_show_updated_count" { SELECT COUNT(*) FROM sensor_data WHERE cpu = 9999; } session "s3" step "s3_block_chunk_insert" { SELECT debug_waitpoint_enable('chunk_insert_before_lock'); } step "s3_release_chunk_insert" { SELECT debug_waitpoint_release('chunk_insert_before_lock'); } step "s3_block_exclusive_lock" { BEGIN; LOCK TABLE sensor_data IN ROW EXCLUSIVE MODE; } step "s3_release_exclusive_lock" { ROLLBACK; } step "s3_begin" { BEGIN; } step "s3_commit" { COMMIT; } step "s3_rollback" { ROLLBACK; } step "s3_delete_uncompressed" { DELETE FROM sensor_data WHERE sensor_id = 11; } step "s3_recompress_chunk" { SELECT count(_timescaledb_functions.recompress_chunk_segmentwise(i)) AS recompress FROM show_chunks('sensor_data') i LIMIT 1; } permutation "s1_begin" "s1_recompress_chunk" "s2_select_from_compressed_chunk" "s2_wait_for_finish" "s1_rollback" permutation "s1_compress" "s3_block_chunk_insert" "s2_insert_do_nothing" "s1_decompress" "s1_compress" "s3_release_chunk_insert" ## test inserts and recompression permutation "s1_show_chunk_state" "s2_begin" "s2_insert_do_nothing" "s1_begin" "s1_recompress_chunk" "s2_insert_do_nothing" "s2_wait_for_finish" "s2_commit" "s1_commit" "s1_show_chunk_state" permutation "s1_show_chunk_state" "s2_begin" "s2_insert_do_nothing" "s1_begin" "s1_recompress_chunk" "s2_insert_existing_do_nothing" "s2_wait_for_finish" "s2_commit" "s1_commit" "s1_show_chunk_state" permutation "s1_show_chunk_state" "s2_begin" "s2_insert_do_nothing" "s1_recompress_chunk" "s2_wait_for_finish" "s2_commit" "s1_show_chunk_state" permutation "s1_show_chunk_state" "s2_begin" "s2_insert_existing_do_nothing" "s1_recompress_chunk" "s2_wait_for_finish" "s2_commit" "s1_show_chunk_state" permutation "s1_recompress_chunk" "s1_show_chunk_state" "s1_insert_for_recompression" "s1_show_chunk_state" "s2_begin" "s2_insert_existing_do_nothing" "s1_recompress_chunk" "s2_wait_for_finish" "s2_commit" "s1_show_chunk_state" ## recompression can block inserts if its able to get the ExclusiveLock to update ## chunk status, it should be quick to release it permutation "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_upsert" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_upsert_existing" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" ## if recompression cannot update the status, there is no blocking permutation "s1_show_chunk_state" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_upsert" "s2_wait_for_finish" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" "s3_release_exclusive_lock" permutation "s1_show_chunk_state" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_upsert_existing" "s2_wait_for_finish" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" "s3_release_exclusive_lock" permutation "s1_show_chunk_state" "s2_begin" "s2_upsert" "s1_recompress_chunk" "s2_wait_for_finish" "s2_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_show_chunk_state" "s2_begin" "s2_upsert_existing" "s1_recompress_chunk" "s2_wait_for_finish" "s2_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_recompress_chunk" "s1_insert_for_recompression" "s1_show_chunk_state" "s2_begin" "s2_upsert_existing" "s1_recompress_chunk" "s2_wait_for_finish" "s2_commit" "s1_show_chunk_state" "s2_show_updated_count" # test that we don't update chunk status to fully compressed if there were concurrent inserts to uncompressed chunk permutation "s1_show_chunk_state" "s3_begin" "s1_begin" "s3_delete_uncompressed" "s1_recompress_chunk" "s2_insert_do_nothing" "s3_rollback" "s1_commit" "s1_show_chunk_state" ## test delete and recompression ## recompression can block deletes if its able to get the ExclusiveLock to update ## chunk status, it should be quick to release it permutation "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_delete_compressed" "s1_commit" "s1_show_chunk_state" permutation "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_delete_uncompressed" "s1_commit" "s1_show_chunk_state" permutation "s1_recompress_chunk" "s1_insert_for_recompression" "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_delete_recompressed" "s1_commit" "s1_show_chunk_state" ## if recompression cannot update the status, there is no blocking permutation "s1_show_chunk_state" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_delete_compressed" "s2_wait_for_finish" "s1_commit" "s1_show_chunk_state" "s3_release_exclusive_lock" ## unless they block each other on tuple level permutation "s1_show_chunk_state" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_delete_uncompressed" "s1_commit" "s1_show_chunk_state" "s3_release_exclusive_lock" permutation "s1_recompress_chunk" "s3_block_exclusive_lock" "s1_insert_for_recompression" "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_delete_recompressed" "s1_commit" "s1_show_chunk_state" "s3_release_exclusive_lock" permutation "s1_show_chunk_state" "s2_begin" "s2_delete_uncompressed" "s1_recompress_chunk" "s2_commit" "s1_show_chunk_state" permutation "s1_show_chunk_state" "s2_begin" "s2_delete_compressed" "s1_recompress_chunk" "s2_commit" "s1_show_chunk_state" permutation "s1_recompress_chunk" "s1_insert_for_recompression" "s1_show_chunk_state" "s2_begin" "s2_delete_recompressed" "s1_recompress_chunk" "s2_commit" "s1_show_chunk_state" ##test update and recompression ## recompression can block deletes if its able to get the ExclusiveLock to update ## chunk status, it should be quick to release it permutation "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_update_compressed" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_show_chunk_state" "s1_begin" "s1_recompress_chunk" "s2_update_uncompressed" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_recompress_chunk" "s1_insert_for_recompression" "s1_begin" "s1_recompress_chunk" "s2_update_recompressed" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" ## if recompression cannot update the status, there is no blocking permutation "s1_show_chunk_state" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_update_compressed" "s2_wait_for_finish" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" "s3_release_exclusive_lock" ## unless they block each other on tuple level permutation "s1_show_chunk_state" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_update_uncompressed" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" "s3_release_exclusive_lock" permutation "s1_recompress_chunk" "s1_insert_for_recompression" "s3_block_exclusive_lock" "s1_begin" "s1_recompress_chunk" "s2_update_recompressed" "s1_commit" "s1_show_chunk_state" "s2_show_updated_count" "s3_release_exclusive_lock" permutation "s1_show_chunk_state" "s2_begin" "s2_update_uncompressed" "s1_recompress_chunk" "s2_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_show_chunk_state" "s2_begin" "s2_update_compressed" "s1_recompress_chunk" "s2_commit" "s1_show_chunk_state" "s2_show_updated_count" permutation "s1_recompress_chunk" "s1_insert_for_recompression" "s1_show_chunk_state" "s2_begin" "s2_update_recompressed" "s1_recompress_chunk" "s2_commit" "s1_show_chunk_state" "s2_show_updated_count" ## test multiple recompressions running at same time ## blocking each other since they acquire ShareUpdateExclusive locks on the chunk permutation "s1_show_chunk_state" "s1_begin" "s3_begin" "s1_recompress_chunk" "s3_recompress_chunk" "s1_commit" "s3_commit" "s1_show_chunk_state" "s2_show_updated_count" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/concurrent_decompress_update.spec�����������������������0000664�0000000�0000000�00000005252�15100345067�0027602�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # This isolation test checks that SELECT queries can be performed in parallel to # chunk decompression operations. This version of the isolation tests creates the # default index on the time column. See the decompression_chunk_and_parallel_query_wo_idx # test for a version without any index. ### setup { CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); -- Create the hypertable SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '60 days'); -- SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '60 days', create_default_indexes => FALSE); -- All generated data is part of one chunk. Only one chunk is used because 'compress_chunk' is -- used in this isolation test. In contrast to 'policy_compression_execute' all decompression -- operations are executed in one transaction. So, processing more than one chunk with 'compress_chunk' -- could lead to deadlocks that do not occur real-world scenarios (due to locks hold on a completely -- decompressed chunk). INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-15', INTERVAL '5 minute') AS g1(time), generate_series(1, 10, 1) AS g2(sensor_id) ORDER BY time; SELECT count(*) FROM sensor_data; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } teardown { DROP TABLE sensor_data; } session "s1" step "s1_begin" { BEGIN; } step "s1_decompress" { SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } step "s1_commit" { COMMIT; } session "s2" step "s2_explain_update" { UPDATE sensor_data SET cpu = cpu + 1 WHERE cpu = 0.1111111; } # UPDATE/DELETE queries don't use TimescaleDB hypertable expansion, and use the # Postgres expansion code, which might have different locking behavior. Test it # as well. permutation "s2_explain_update" "s1_begin" "s1_decompress" "s2_explain_update" "s1_commit" "s2_explain_update" ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/deadlock_drop_chunks_compress.spec����������������������0000664�0000000�0000000�00000003222�15100345067�0027705�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # Test concurrent drop_chunks and compress_chunk # # Create three chunks setup { CREATE TABLE conditions (time timestamptz, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => interval '1 day'); INSERT INTO conditions SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-03 00:00','1 hour'), random() * 100; ALTER TABLE conditions SET (timescaledb.compress = true); } teardown { DROP TABLE conditions; } session "s1" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '300ms'; } # Drop two chunks step "s1_drop" { SELECT count (*) FROM drop_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz); } step "s1_commit" { COMMIT; } session "s2" setup { BEGIN; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '300ms'; CREATE TEMPORARY TABLE IF NOT EXISTS chunks_to_compress ON COMMIT DROP AS SELECT chunk FROM show_chunks('conditions', older_than => '2018-12-03 00:00'::timestamptz) chunk ORDER BY 1 LIMIT 2; } # Compress same two chunks as are being dropped step "s2_compress_chunk_1" { SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 ASC LIMIT 1) AS chunk; } step "s2_compress_chunk_2" { SELECT count(compress_chunk(chunk)) FROM (SELECT chunk FROM chunks_to_compress ORDER BY 1 DESC LIMIT 1) AS chunk; } step "s2_commit" { COMMIT; } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/deadlock_drop_index_vacuum.spec�������������������������0000664�0000000�0000000�00000007474�15100345067�0027203�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # Order of locks in drop index and vacuum analyze was wrong, and DROP # INDEX took the locks in order index-table, while VACUUM ANALYZE took # them in order table-index. # # Create deadlock if the locking order is wrong. Problem here is that # vacuum takes two locks. First one to read a table and then one to do # the actual vacuum. For this reason we need two processes that end up # in the deadlock (VACUUM ANALYZE and DROP INDEX respectively) and # then two extra sessions working in lock-step to create the deadlock. # # It can be illustrated with this sequence, where we have a chunk # table and a chunk index. The sessions between the brackets ([]) is # the lock queue and session holding the lock is in angle brackets # (<>) is the session that holds the lock on the object in question: # # S1: Lock chunk from hypertable # index: [] # table: <S1> [] # S3: Start VACUUM ANALYZE, will attempt to lock chunk table, but get queued. # index: [] # table: <S1> [S3] # S2: Lock chunk table from hypertable, which will be queued # index: [] # table: <S1> [S3 S2] # S1: Unlock chunk table # index: [] # table: [S3 S2] # S3: VACUUM ANALYZE continues and takes the lock on the chunk table. # index: [] # table: <S3> [S2] # S3: VACUUM ANALYZE will release the lock on the chunk table. # index: [] # table: [S2] # S3: VACUUM ANALYZE will attempt to lock the chunk table again # index: [] # table: [S2 S3] # S2: The LOCK statement gets the lock and VACUUM will wait # index: [] # table: <S2> [S3] # S4: DROP INDEX starts and takes lock in index first and then is # queued for the chunk table # index: <S4> [] # table: <S2> [S3 S4] # S2: Release lock on chunk table # index: <S4> [] # table: [S3 S4] # S3: VACUUM continues and takes table lock and then tries index lock # index: <S4> [S3] # table: <S3> [S4] # Deadlock setup { CREATE TABLE metrics (time timestamptz, device_id integer, temp float); SELECT create_hypertable('metrics', 'time', chunk_time_interval => interval '1 day'); INSERT INTO metrics SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-03 00:00', '1 hour'), (random()*30)::int, random()*80 - 40; CREATE INDEX metrics_device_time_idx ON metrics(device_id, time NULLS FIRST); -- Rename chunks so that we have known names. We cannot execute -- VACUUM in a function block. DO $$ DECLARE chunk regclass; count int = 1; BEGIN FOR chunk IN SELECT ch FROM show_chunks('metrics') ch LOOP EXECUTE format('ALTER TABLE %s RENAME TO metrics_chunk_%s', chunk, count); count = count + 1; END LOOP; END $$; } teardown { DROP TABLE metrics; } session "S1" setup { START TRANSACTION; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '300ms'; } step "S1_lock" { LOCK TABLE _timescaledb_internal.metrics_chunk_2 IN ACCESS EXCLUSIVE MODE; } step "S1_commit" { COMMIT; } session "S2" setup { START TRANSACTION; SET TRANSACTION ISOLATION LEVEL READ COMMITTED; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '300ms'; } step "S2_lock" { LOCK TABLE _timescaledb_internal.metrics_chunk_2 IN ACCESS EXCLUSIVE MODE; } step "S2_commit" { COMMIT; } session "S3" step "S3_vacuum" { VACUUM ANALYZE _timescaledb_internal.metrics_chunk_2; } session "S4" step "S4_drop_index" { DROP INDEX metrics_device_time_idx; } permutation S1_lock S3_vacuum S2_lock S1_commit S4_drop_index S2_commit ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/deadlock_recompress_chunk.spec��������������������������0000664�0000000�0000000�00000006223�15100345067�0027031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # Test that concurrent queries and recompress_chunk cannot # deadlock. # # This can occur if recompressing since a recompress will first do a # decompression of the compressed chunk into the uncompressed chunk. # # We should only have a single chunk here, otherwise we cannot lock # the right chunk. # # We have fetched the actual recompress procedure from the policy and # re-implement it here to be able to test that it works as # expected. Please check policy_internal.sql to see the code it is # based on. # setup { CREATE TABLE hyper (time TIMESTAMP NOT NULL, a DOUBLE PRECISION NULL, b DOUBLE PRECISION NULL); CREATE INDEX "time_plain" ON hyper(time DESC, a); SELECT * FROM create_hypertable('hyper', 'time'); INSERT INTO hyper SELECT to_timestamp(ser), ser, ser+10000 FROM generate_series(0,1000) ser; ALTER TABLE hyper SET (timescaledb.compress = true); SELECT count(*) FROM (SELECT compress_chunk(show_chunks('hyper'))) i; } teardown { DROP TABLE hyper; } # We are not using a debug point when locking inside recompress_chunk # after decompress since it is an PL/SQL procedure. Instead we lock # the compressed chunk, which will block the actual drop in the # recompress procedure at the right point (before the commit), and we # can then start the query, which will queue after the others. session "locks" setup { BEGIN; } step "lock_after_decompress" { SELECT count(*) FROM show_chunks('hyper'); DO $$ DECLARE chunk regclass; BEGIN SELECT format('%I.%I', c.schema_name, c.table_name)::regclass INTO chunk FROM show_chunks('hyper'), _timescaledb_catalog.chunk p, _timescaledb_catalog.chunk c WHERE p.compressed_chunk_id = c.id AND format('%I.%I', p.schema_name, p.table_name)::regclass = show_chunks; EXECUTE format('LOCK TABLE %s IN EXCLUSIVE MODE', chunk); END; $$; } step "unlock_after_decompress" { ROLLBACK; } # When building a simple relation for the query (using # `build_simple_rel`), it first takes a lock on the relation, and then # on any indexes for the relation, if they exist (inside # `get_relation_info`, to get statistics for the relation). session "query" step "query_start" { SELECT count(*) FROM hyper; } # This session will compress all chunks. We should only have a single # one in this case, so that we block just before reindexing the chunk. session "recompress" step "recompress_insert_rows" { INSERT INTO hyper SELECT to_timestamp(ser), ser, ser+100 FROM generate_series(0,100) ser; } step "recompress_chunks_start" { DO $$ DECLARE chunk regclass; BEGIN SELECT show_chunks('hyper') INTO chunk; PERFORM compress_chunk(chunk); END; $$; } # Since the locking order is different, we locking before reindex we should one one lock on the index and # one lock on the chunk from different processes. permutation recompress_insert_rows lock_after_decompress recompress_chunks_start query_start(recompress_chunks_start) unlock_after_decompress �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/decompression_chunk_and_parallel_query.in���������������0000664�0000000�0000000�00000005055�15100345067�0031274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # This isolation test checks that SELECT queries can be performed in parallel to # chunk decompression operations. This version of the isolation tests creates the # default index on the time column. See the decompression_chunk_and_parallel_query_wo_idx # test for a version without any index. ### setup { CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); -- Create the hypertable SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '60 days'); -- SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '60 days', create_default_indexes => FALSE); -- All generated data is part of one chunk. Only one chunk is used because 'compress_chunk' is -- used in this isolation test. In contrast to 'policy_compression_execute' all decompression -- operations are executed in one transaction. So, processing more than one chunk with 'compress_chunk' -- could lead to deadlocks that do not occur real-world scenarios (due to locks hold on a completely -- decompressed chunk). INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-15', INTERVAL '5 minute') AS g1(time), generate_series(1, 10, 1) AS g2(sensor_id) ORDER BY time; SELECT count(*) FROM sensor_data; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } teardown { DROP TABLE sensor_data; } session "s1" step "s1_begin" { BEGIN; } step "s1_decompress" { SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } step "s1_commit" { COMMIT; } session "s2" step "s2_read_sensor_data" { SELECT FROM sensor_data; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } permutation "s2_read_sensor_data" "s1_begin" "s1_decompress" "s2_read_sensor_data" "s1_commit" "s2_read_sensor_data" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/decompression_chunk_and_parallel_query_wo_idx.spec������0000664�0000000�0000000�00000011456�15100345067�0033173�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # This isolation test checks that SELECT queries can be performed in parallel to # chunk decompression operations. This version of the isolation test creates a # hypertable without any index. So, no locks on the index can be creates which # leads to a different level of concurrency. ### setup { CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); -- Create the hypertable without an index on the hypertable SELECT FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '60 days', create_default_indexes => FALSE); -- All generated data is part of one chunk. Only one chunk is used because 'compress_chunk' is -- used in this isolation test. In contrast to 'policy_compression_execute' all decompression -- operations are executed in one transaction. So, processing more than one chunk with 'compress_chunk' -- could lead to deadlocks that do not occur real-world scenarios (due to locks hold on a completely -- decompressed chunk). INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-15', INTERVAL '1 minute') AS g1(time), generate_series(1, 50, 1) AS g2(sensor_id) ORDER BY time; SELECT count(*) FROM sensor_data; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id'); SELECT count(*) FROM (SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } teardown { DROP TABLE sensor_data; } session "s1" step "s1_decompress" { SELECT count(*) FROM (SELECT decompress_chunk(i, if_compressed => true) FROM show_chunks('sensor_data') i) i; SELECT compression_status FROM chunk_compression_stats('sensor_data'); } session "s2" step "s2_read_sensor_data" { SELECT FROM sensor_data; } session "s3" step "s3_lock_decompression_locks" { -- This waitpoint is defined before the decompressed chunk is re-indexed. Up to this -- point parallel SELECTs should be possible. SELECT debug_waitpoint_enable('decompress_chunk_impl_before_reindex'); -- This waitpoint is defined after all locks for the decompression and the deletion -- of the compressed chunk are requested. SELECT debug_waitpoint_enable('decompress_chunk_impl_after_reindex'); } step "s3_unlock_decompression_before_reindex_lock" { -- Ensure that we are waiting on our debug waitpoint -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- decompress_chunk_impl_before_reindex = 3966149665. SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND locktype = 'advisory' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('decompress_chunk_impl_before_reindex'); } step "s3_unlock_decompression_after_reindex_lock" { -- Ensure that we are waiting on our debug waitpoint -- Note: The OIDs of the advisory locks are based on the hash value of the lock name (see debug_point_init()) -- decompress_chunk_impl_after_reindex = 1858017383. SELECT locktype, mode, granted, objid FROM pg_locks WHERE not granted AND locktype = 'advisory' ORDER BY relation, locktype, mode, granted; SELECT debug_waitpoint_release('decompress_chunk_impl_after_reindex'); } # Desired execution (no locks should be performed in s2_read_sensor_data): # s3_lock_decompression_locks - Locks the decompression waitpoints. # s2_read_sensor_data - Read the compressed chunk. This should be executed without blocking. # s1_decompress - Start the decompression and block on the first waitpoint. # s2_read_sensor_data - Read the compressed chunk again. This should be still possible without blocking. # s3_unlock_decompression_before_reindex_lock - Releases the decompress_chunk_impl_before_reindex waitpoint. # s1_decompress continues - No reindex is performed due to no existing indexes # s2_read_sensor_data - Read the chunk without any lock. # s3_unlock_decompression_after_reindex_lock - Releases the decompress_chunk_impl_after_compressed_chunk_lock. # s1_decompress continues - Finishes the decompression operation and releases the locks. # s2_read_sensor_data - Read the chunk without any lock. permutation "s3_lock_decompression_locks" "s2_read_sensor_data" "s1_decompress" "s2_read_sensor_data" "s3_unlock_decompression_before_reindex_lock" "s2_read_sensor_data" "s3_unlock_decompression_after_reindex_lock" "s2_read_sensor_data" ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/detach_chunk_isolation.spec�����������������������������0000664�0000000�0000000�00000005515�15100345067�0026335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { DROP TABLE IF EXISTS detach_test; DROP TABLE IF EXISTS chunk_to_detach; CREATE TABLE detach_test (time timestamptz, device int, temp float); SELECT create_hypertable('detach_test', 'time'); CREATE TABLE chunk_to_detach(time timestamptz NOT NULL, device int, temp float); CALL attach_chunk('detach_test', 'chunk_to_detach', jsonb_build_object('time', jsonb_build_array('2025-06-01', '2025-06-11'))); INSERT INTO detach_test VALUES ('2025-06-02 10:30', 1, 31.5); } teardown { DROP TABLE IF EXISTS chunk_to_detach; DROP TABLE detach_test; } session "s1" step "s1b" { BEGIN; } step "s1_detach" { CALL detach_chunk('chunk_to_detach'); } step "s1c" { COMMIT; } session "s2" step "s2_wait_before_lock" { SELECT debug_waitpoint_enable('chunk_detach_before_lock'); } step "s2_release_lock" { SELECT debug_waitpoint_release('chunk_detach_before_lock'); } step "s2_show_num_chunks" { SELECT count(*) FROM show_chunks('detach_test'); } step "s2_show_num_rows" { SELECT count(*) FROM detach_test; } step "s2_show_chunk_rows" { SELECT count(*) FROM chunk_to_detach; } session "s3" step "s3_insert" { INSERT INTO detach_test VALUES ('2025-06-02 10:30', 1, 31.5); } step "s3_truncate" { TRUNCATE TABLE detach_test; } step "s3_drop_chunk" { SELECT count(*) FROM drop_chunks('detach_test', TIMESTAMPTZ '2025-07-01'); } session "s4" step "s4b" { BEGIN; } step "s4_detach" { CALL detach_chunk('chunk_to_detach'); } step "s4c" { COMMIT; } # Insert rows into the chunk before detach_chunk takes locks, also try to insert after locks but before detach commits. permutation "s2_wait_before_lock" "s1b" "s1_detach" "s2_show_num_rows" "s3_insert" "s2_show_num_rows" "s2_release_lock" "s3_insert" "s1c" "s2_show_num_rows" "s2_show_num_chunks" "s2_show_chunk_rows" # Truncate the hypertable before detach_chunk takes locks permutation "s2_wait_before_lock" "s1b" "s1_detach" "s2_show_num_rows" "s2_show_num_chunks" "s3_truncate" "s2_release_lock" "s1c" "s2_show_num_chunks" "s2_show_chunk_rows" # Truncate the hypertable after detach_chunk takes locks permutation "s1b" "s2_show_num_chunks" "s2_show_num_rows" "s1_detach" "s3_truncate" "s1c" "s2_show_num_chunks" "s2_show_chunk_rows" # Drop the chunk before detach_chunk takes locks permutation "s2_wait_before_lock" "s1b" "s1_detach" "s2_show_num_chunks" "s3_drop_chunk" "s2_show_num_chunks" "s2_release_lock" "s1c" "s2_show_num_chunks" "s2_show_chunk_rows" # Drop the chunk after detach_chunk takes locks permutation "s1b" "s1_detach" "s2_show_num_chunks" "s3_drop_chunk" "s2_show_num_chunks" "s1c" "s2_show_num_chunks" "s2_show_chunk_rows" # Two sessions detaching the same chunk permutation "s1b" "s4b" "s1_detach" "s4_detach" "s1c" "s4c" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/direct_compress_copy.spec�������������������������������0000664�0000000�0000000�00000005305�15100345067�0026050�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { CREATE TABLE metrics (time timestamptz not null, device text, value float) WITH (tsdb.hypertable, tsdb.partition_column = 'time'); INSERT INTO metrics (time, device, value) VALUES ('2025-01-01 00:00:00', 'd1', 0.1); } teardown { DROP TABLE metrics; } session "s1" setup { SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; } step "s1_begin" { BEGIN; } step "s1_copy" { COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-01-01 0:00:00,d1,0.5' WITH (FORMAT CSV); } step "s1_copy_february" { COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-02-01 0:00:00,d1,0.5' WITH (FORMAT CSV); } step "s1_commit" { COMMIT; } session "s2" setup { SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; } step "s2_begin" { BEGIN; } step "s2_copy" { COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-01-01 0:00:00,d1,0.5' WITH (FORMAT CSV); } step "s2_copy_march" { COPY metrics FROM PROGRAM 'seq 10 | xargs -II echo 2025-03-01 0:00:00,d1,0.5' WITH (FORMAT CSV); } # Empty step used to stabilize test (see isolationcheck README) step "s2_empty" {} step "s2_commit" { COMMIT; } session "s3" step "s3_compress_and_insert" { SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics') chunk; INSERT INTO metrics (time, device, value) VALUES ('2025-02-01 00:00:00', 'd1', 0.1); INSERT INTO metrics (time, device, value) VALUES ('2025-03-01 00:00:00', 'd1', 0.1); } step "s3_wp_on" { SELECT debug_waitpoint_enable('insert_create_compressed'); } step "s3_wp_off" { SELECT debug_waitpoint_release('insert_create_compressed'); } step "s3_show_compressed" { SELECT is_compressed FROM timescaledb_information.chunks WHERE hypertable_name='metrics'; } step "s3_count" { SELECT count(*) FROM metrics; } # test parallel insertions with direct compress copy in the same chunk # chunk has to be precreated in this scenario otherwise there will be locking permutation "s3_compress_and_insert" "s1_begin" "s2_begin" "s1_copy" "s2_copy" "s2_commit" "s1_commit" # test parallel insertions into distinct chunks with direct compress copy permutation "s3_compress_and_insert" "s1_begin" "s2_begin" "s1_copy_february" "s2_copy_march" "s2_commit" "s1_commit" # test that two concurrent compressed copy processes synchronize on creating a compressed chunk permutation "s3_wp_on" "s3_count" "s3_show_compressed" "s1_copy" "s2_copy" ("s1_copy") "s3_wp_off" "s2_empty" "s3_show_compressed" "s3_count" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/freeze_chunk.spec���������������������������������������0000664�0000000�0000000�00000015331�15100345067�0024301�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. #check concurrent operations with freeze_chunk and unfreeze_chunk setup { DROP TABLE IF EXISTS measurements; CREATE TABLE measurements (time timestamptz, device int , temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval=>'7 days'::interval); INSERT INTO measurements VALUES ('2020-01-03 10:30', 1, 1.0), ('2020-01-03 11:30', 2, 2.0); ALTER TABLE measurements SET (timescaledb.compress); CREATE OR REPLACE FUNCTION lock_chunktable( name text) RETURNS void AS $$ BEGIN EXECUTE format( 'lock table %s IN SHARE MODE', name); END; $$ LANGUAGE plpgsql; } teardown { DROP TABLE measurements; DROP FUNCTION lock_chunktable; } # Test concurrent DML and freeze chunk. The wait point happens # before a lock is acquired for freezing the chunk. session "s1" step "s1_begin_rr" { BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; } step "s1_begin_s" { BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; } step "s1_freeze" { SELECT _timescaledb_functions.freeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; } step "s1_unfreeze" { SELECT _timescaledb_functions.unfreeze_chunk(ch) FROM (SELECT show_chunks('measurements') ch ) q; } step "s1_status" { SELECT ch.status FROM _timescaledb_catalog.chunk ch WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'measurements'); } step "s1_rollback" { ROLLBACK; } session "ins_S2" step "s2_wp_enable" { SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); } step "ins_s2_insert" { BEGIN ; INSERT INTO measurements values('2020-01-03 12:30', 2, 2.0 ); } step "ins_s2_commit" { COMMIT; } step "ins_s2_query" { SELECT * FROM measurements ORDER BY 1; } step "s2_wp_release" { SELECT debug_waitpoint_release('freeze_chunk_before_lock'); } session "upd_s2" step "upd_s2_wp_enable" { SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); } step "upd_s2_update" { BEGIN ; UPDATE measurements SET temp = 200 WHERE device = 2; } step "upd_s2_commit" { COMMIT; } step "upd_s2_query" { SELECT * FROM measurements ORDER BY 1; } step "upd_s2_wp_release" { SELECT debug_waitpoint_release('freeze_chunk_before_lock'); } session "del_s2" step "del_s2_wp_enable" { SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); } step "del_s2_delete" { BEGIN ; DELETE FROM measurements WHERE device = 2; } step "del_s2_commit" { COMMIT; } step "del_s2_query" { SELECT * FROM measurements ORDER BY 1; } step "del_s2_wp_release" { SELECT debug_waitpoint_release('freeze_chunk_before_lock'); } session "sel_S2" step "sel_s2_wp_enable" {SELECT debug_waitpoint_enable('freeze_chunk_before_lock'); } step "sel_s2_commit" { COMMIT; } step "sel_s2_query" { BEGIN; SELECT * FROM measurements ORDER BY 1; } step "sel_s2_wp_release" { SELECT debug_waitpoint_release('freeze_chunk_before_lock'); } session "LC" step "BeginLock" { BEGIN; } step "LockChunk1" { SELECT lock_chunktable(format('%I.%I',ch.schema_name, ch.table_name)) FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = ht.id AND ht.table_name like 'measurements' ORDER BY ch.id LIMIT 1; } step "UpdateCatalogTupleStatus" { UPDATE _timescaledb_catalog.chunk SET status = 4 WHERE true; } step "Unlock" {ROLLBACK;} step "CommitUpdate" {COMMIT;} session "comp_s2" step "comp_s2_compress" { BEGIN; SELECT CASE WHEN compress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; } step "comp_s2_commit" { COMMIT; } session "decomp_s2" step "decomp_s2_decompress" { BEGIN; SELECT CASE WHEN decompress_chunk(ch) IS NOT NULL THEN 'Success' ELSE 'Failed' END as COL FROM (SELECT show_chunks('measurements') ch ) q; } step "decomp_s2_commit" { COMMIT; } #### freeze_chunk #### ###freeze_chunk waits for pending insert txns to complete, uncompressed and compressed variant ###transactions are serialized when they try to lock the chunk tuple entry in the catalog table. (see chunk.c) permutation "s2_wp_enable" "ins_s2_insert" "s2_wp_release" "s1_freeze" "ins_s2_commit" "ins_s2_query" "s1_status" permutation "comp_s2_compress" "comp_s2_commit" "s2_wp_enable" "ins_s2_insert" "s2_wp_release" "s1_freeze" "ins_s2_commit" "ins_s2_query" "s1_status" ###freeze_chunk waits for pending update txns to complete, uncompressed and compressed variant ###transactions are serialized when they try to lock the chunk tuple entry in the catalog table. (see chunk.c) permutation "upd_s2_wp_enable" "upd_s2_update" "upd_s2_wp_release" "s1_freeze" "upd_s2_commit" "upd_s2_query" "s1_status" permutation "comp_s2_compress" "comp_s2_commit" "upd_s2_wp_enable" "upd_s2_update" "upd_s2_wp_release" "s1_freeze" "upd_s2_commit" "upd_s2_query" "s1_status" ###freeze_chunk waits for pending delete txns to complete, uncompressed and compressed variant ###transactions are serialized when they try to lock the chunk tuple entry in the catalog table. (see chunk.c) permutation "del_s2_wp_enable" "del_s2_delete" "del_s2_wp_release" "s1_freeze" "del_s2_commit" "del_s2_query" "s1_status" permutation "comp_s2_compress" "comp_s2_commit" "del_s2_wp_enable" "del_s2_delete" "del_s2_wp_release" "s1_freeze" "del_s2_commit" "del_s2_query" "s1_status" ###freeze_chunk and select do not block each other, uncompressed and compressed variant permutation "sel_s2_wp_enable" "sel_s2_query" "sel_s2_wp_release" "s1_freeze" "sel_s2_commit" "s1_status" permutation "comp_s2_compress" "comp_s2_commit" "sel_s2_wp_enable" "sel_s2_query" "sel_s2_wp_release" "s1_freeze" "sel_s2_commit" "s1_status" ##if compress_chunk is in progress, freeze_chunk is blocked permutation "BeginLock" "LockChunk1" "comp_s2_compress" "s1_freeze" "Unlock" "comp_s2_commit" "s1_status" ##if decompress_chunk is in progress, freeze_chunk is blocked permutation "comp_s2_compress" "comp_s2_commit" "BeginLock" "LockChunk1" "decomp_s2_decompress" "s1_freeze" "Unlock" "decomp_s2_commit" "s1_status" #### check higher isolation levels #### permutation "BeginLock" "s1_begin_rr" "UpdateCatalogTupleStatus" "s1_freeze" "CommitUpdate" "s1_rollback" permutation "BeginLock" "s1_begin_s" "UpdateCatalogTupleStatus" "s1_freeze" "CommitUpdate" "s1_rollback" #### unfreeze_chunk #### ###unfreeze_chunk and select do not block each other, uncompressed and compressed variant permutation "s1_freeze" "sel_s2_wp_enable" "sel_s2_query" "sel_s2_wp_release" "s1_unfreeze" "sel_s2_commit" "s1_status" permutation "comp_s2_compress" "comp_s2_commit" "s1_freeze" "sel_s2_wp_enable" "sel_s2_query" "sel_s2_wp_release" "s1_unfreeze" "sel_s2_commit" "s1_status" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/merge_chunks_concurrent.spec����������������������������0000664�0000000�0000000�00000016650�15100345067�0026552�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { create table readings (time timestamptz, device int, temp float); select create_hypertable('readings', 'time', chunk_time_interval => interval '1 hour'); insert into readings values ('2024-01-01 01:00', 1, 1.0), ('2024-01-01 01:01', 2, 2.0), ('2024-01-01 02:00', 3, 3.0), ('2024-01-01 02:00', 4, 4.0); alter table readings set (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='device'); create or replace procedure merge_all_chunks(hypertable regclass) as $$ declare chunks_arr regclass[]; begin select array_agg(cl.oid) into chunks_arr from pg_class cl join pg_inherits inh on (cl.oid = inh.inhrelid) where inh.inhparent = hypertable; call merge_chunks(variadic chunks_arr); end; $$ LANGUAGE plpgsql; create or replace procedure drop_one_chunk(hypertable regclass) as $$ declare chunk regclass; begin select cl.oid into chunk from pg_class cl join pg_inherits inh on (cl.oid = inh.inhrelid) where inh.inhparent = hypertable limit 1; execute format('drop table %s cascade', chunk); end; $$ LANGUAGE plpgsql; create or replace procedure lock_one_chunk(hypertable regclass) as $$ declare chunk regclass; begin select ch into chunk from show_chunks(hypertable) ch offset 1 limit 1; execute format('lock %s in row exclusive mode', chunk); end; $$ LANGUAGE plpgsql; reset timescaledb.merge_chunks_lock_upgrade_mode; } teardown { drop table readings; } session "s1" setup { set local lock_timeout = '5000ms'; set local deadlock_timeout = '10ms'; } # The transaction will not "pick" a snapshot until the first query, so # do a simple select on pg_class to pick one for the transaction. We # don't want to query any tables involved in the test since that will # grab locks on them. step "s1_begin" { start transaction isolation level repeatable read; select count(*) > 0 from pg_class; } step "s1_show_chunks" { select count(*) from show_chunks('readings'); } step "s1_show_data" { select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; } step "s1_row_exclusive_lock" { call lock_one_chunk('readings'); } step "s1_commit" { commit; } session "s2" setup { set local lock_timeout = '500ms'; set local deadlock_timeout = '100ms'; reset timescaledb.merge_chunks_lock_upgrade_mode; } step "s2_show_chunks" { select count(*) from show_chunks('readings'); } step "s2_merge_chunks" { call merge_all_chunks('readings'); } step "s2_set_lock_upgrade" { set timescaledb.merge_chunks_lock_upgrade_mode='upgrade'; } step "s2_set_lock_upgrade_conditional" { set timescaledb.merge_chunks_lock_upgrade_mode='conditional'; } session "s3" setup { set local lock_timeout = '500ms'; set local deadlock_timeout = '100ms'; } step "s3_begin" { start transaction isolation level read committed; select count(*) > 0 from pg_class; } step "s3_show_data" { select * from readings order by time desc, device; select count(*) as num_device_all, count(*) filter (where device=1) as num_device_1, count(*) filter (where device=5) as num_device_5 from readings; } step "s3_show_chunks" { select count(*) from show_chunks('readings'); } step "s3_merge_chunks" { call merge_all_chunks('readings'); } #step "s3_compress_chunks" { # select compress_chunk(show_chunks('readings')); #} #step "s3_drop_chunks" { # call drop_one_chunk('readings'); #} step "s3_commit" { commit; } session "s4" setup { set local lock_timeout = '500ms'; set local deadlock_timeout = '100ms'; } step "s4_modify" { delete from readings where device=1; insert into readings values ('2024-01-01 01:05', 5, 5.0); } step "s4_wp_enable" { SELECT debug_waitpoint_enable('merge_chunks_before_heap_swap'); } step "s4_wp_release" { SELECT debug_waitpoint_release('merge_chunks_before_heap_swap'); } # Run 4 backends: # # s1: will read data in REPEATABLE READ (should not see changes after merge) # s2: will merge chunks # s3: will read data in READ COMMITTED (should see changes immediately after merge) # s4: will modify data during TX s1 and s3 but before merge # # Expectation: s1 should see the original data as it was before s4 # modifications and merge while s3 should see the changes permutation "s2_show_chunks" "s3_show_data" "s1_begin" "s3_begin" "s4_modify" "s2_merge_chunks" "s1_show_chunks" "s3_show_chunks" "s1_show_data" "s3_show_data" "s1_commit" "s1_show_data" "s3_commit" # Merge chunks with AccessExclusiveLock (default). s2_merge_chunks # need to wait for readers to finish before even starting merge permutation "s2_show_chunks" "s1_begin" "s1_show_data" "s2_merge_chunks" "s1_show_data" "s1_commit" "s1_show_data" "s1_show_chunks" # Merge chunks with lock upgrade. s2_merge_chunks can merge # concurrently with readers but need to wait for readers to finish # before doing the heap swap. permutation "s2_set_lock_upgrade" "s2_show_chunks" "s1_begin" "s1_show_data" "s2_merge_chunks" "s1_show_data" "s1_commit" "s1_show_data" "s1_show_chunks" # Same as the above, but it will deadlock because a reader upgrades # from a read to a write lock. Since the permutation deadlocks, the # output can be non-deterministic (on which process is killed) so it # is not run by default. #permutation "s2_set_lock_upgrade" "s4_wp_enable" "s2_show_chunks" "s1_begin" "s1_show_data" "s2_merge_chunks" "s1_show_data" "s1_row_exclusive_lock" "s4_wp_release" "s1_commit" "s1_show_data" "s1_show_chunks" # Same as above but without lock upgrade. No deadlocks, but the merge # blocks until the reader/writer is finished. permutation "s4_wp_enable" "s2_show_chunks" "s1_begin" "s1_show_data" "s2_merge_chunks" "s1_show_data" "s1_row_exclusive_lock" "s4_wp_release" "s1_commit" "s1_show_data" "s1_show_chunks" # Same as above, but the merger takes locks before the reader/writer # so the reader/writer has to wait. permutation "s4_wp_enable" "s2_show_chunks" "s1_begin" "s2_merge_chunks" "s1_show_data" "s4_wp_release" "s1_commit" "s1_show_data" "s1_show_chunks" # Same as above but with a conditional lock. The merge process should # fail with an error saying it can't take the lock needed for the # merge. permutation "s2_set_lock_upgrade_conditional" "s4_wp_enable" "s2_show_chunks" "s1_begin" "s1_show_data" "s2_merge_chunks" "s1_show_data" "s1_row_exclusive_lock" "s4_wp_release" "s1_commit" "s1_show_data" "s1_show_chunks" # Test concurrent merges permutation "s4_wp_enable" "s2_merge_chunks" "s3_merge_chunks" "s4_wp_release" "s1_show_data" "s1_show_chunks" # Test concurrent compress_chunk(). This will deadlock because # compress_chunks takes chunk locks in a different order. The test is # disabled because with a deadlock the output can be non-deterministic. #permutation "s4_wp_enable" "s2_merge_chunks" "s3_compress_chunks" "s4_wp_release" "s1_show_data" "s1_show_chunks" # Test concurrent DROP TABLE on chunk (currently deadlocks because of locks on parent table) #permutation "s4_wp_enable" "s2_merge_chunks" "s3_drop_chunks" "s4_wp_release" "s1_show_data" "s1_show_chunks" ����������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/osm_range_updates_iso.spec������������������������������0000664�0000000�0000000�00000012565�15100345067�0026210�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { CREATE TABLE osm_test (time INTEGER, a INTEGER); SELECT create_hypertable('osm_test', 'time', chunk_time_interval => 10); CREATE TABLE osm_test2 (time INTEGER, a INTEGER); SELECT create_hypertable('osm_test2', 'time', chunk_time_interval => 10); INSERT INTO osm_test VALUES (1, 111); INSERT INTO osm_test2 VALUES (2, 211); UPDATE _timescaledb_catalog.hypertable set status = 3 WHERE table_name IN ('osm_test', 'osm_test2'); UPDATE _timescaledb_catalog.chunk set osm_chunk = true WHERE hypertable_id IN (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name IN ('osm_test', 'osm_test2')); UPDATE _timescaledb_catalog.dimension_slice set range_start = 9223372036854775806, range_end = 9223372036854775807 WHERE id IN (SELECT cc.dimension_slice_id FROM _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.id = ch.hypertable_id AND cc.chunk_id = ch.id AND ht.table_name IN ('osm_test', 'osm_test2')); CREATE TABLE test_drop(time INTEGER, a INTEGER); SELECT create_hypertable('test_drop', 'time', chunk_time_interval => 10); INSERT INTO test_drop(time, a) VALUES (1,1); UPDATE _timescaledb_catalog.hypertable set status = 1 WHERE table_name = 'test_drop'; UPDATE _timescaledb_catalog.chunk set osm_chunk = true WHERE hypertable_id IN (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'test_drop'); INSERT INTO test_drop VALUES (11, 11), (22, 22); } teardown { DROP TABLE osm_test; DROP TABLE osm_test2; DROP TABLE test_drop; } session "UR1" step "UR1b" { BEGIN; } step "UR1u" { SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); } step "UR1c" { COMMIT; } session "UR2" step "UR2b" { BEGIN; } step "UR2u" { SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test', 0, 10); } step "UR2c" { COMMIT; } # lock dimension_slice tuple session "LDST" step "LockDimSliceTuple" { BEGIN; SELECT range_start, range_end FROM _timescaledb_catalog.dimension_slice WHERE id IN ( SELECT ds.id FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds, _timescaledb_catalog.hypertable ht WHERE ht.table_name like 'osm_test' AND cc.chunk_id = ch.id AND ht.id = ch.hypertable_id AND ds.id = cc.dimension_slice_id AND ch.osm_chunk = true ) FOR UPDATE; } step "UnlockDimSliceTuple" { ROLLBACK; } session "DT" step "DTb" { BEGIN; } step "DropOsmChunk" { SELECT _timescaledb_functions.drop_chunk(chunk_table::regclass) FROM ( SELECT format('%I.%I', c.schema_name, c.table_name) as chunk_table FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.hypertable ht WHERE ht.id = c.hypertable_id AND ht.table_name = 'osm_test' ) sq; } step "DTc" { COMMIT; } session "LHT" step "LHTb" { BEGIN; } step "LockHypertableTuple" { SELECT table_name, compression_state, compressed_hypertable_id, status FROM _timescaledb_catalog.hypertable WHERE table_name = 'osm_test' FOR UPDATE; } step "UnlockHypertableTuple" { ROLLBACK; } session "C" step "Cb" { BEGIN; } step "Cenable" { ALTER TABLE osm_test set (timescaledb.compress); } step "Ccommit" { COMMIT; } session "AlterSchema" step "Ab" { BEGIN; } step "Aadd" { ALTER TABLE osm_test ADD COLUMN b INTEGER; } step "Ac" { COMMIT; } session "U2" step "Utest2b" { BEGIN; } step "Utest2u" { SELECT _timescaledb_functions.hypertable_osm_range_update('osm_test2', 0, 20); } step "Utest2c" { COMMIT; } session "DR1" step DR1b { BEGIN; } step DR1drop { SELECT _timescaledb_functions.drop_osm_chunk('test_drop'); } step DR1c { COMMIT; } session "DR2" step DR2b { BEGIN; } step DR2drop { SELECT _timescaledb_functions.drop_osm_chunk('test_drop'); } step DR2c { COMMIT; } # Concurrent updates will block one another # this previously deadlocked one of the two transactions permutation "LockDimSliceTuple" "UR1b" "UR1u" "UR2b" "UR2u" "UnlockDimSliceTuple" "UR1c" "UR2c" # test concurrent delete of a chunk and range update. This should not be a valid scenario for # an OSM chunk because it is maintained even if all its data is dropped/untiered, and its range # is simply updated to reflect the fact it might be empty. # However, it doesn't hurt to have a test for this, in case we decide to change this behavior in # the future. permutation "LockDimSliceTuple" "DTb" "UR1b" "DropOsmChunk" "UR1u" "UnlockDimSliceTuple" "DTc" "UR1c" permutation "LockDimSliceTuple" "DTb" "UR1b" "UR1u" "DropOsmChunk" "UnlockDimSliceTuple" "UR1c" "DTc" # one session enables compression -> thus changing the hypertable status permutation "LHTb" "LockHypertableTuple" "Cb" "UR1b" "Cenable" "UR1u" "UnlockHypertableTuple" "Ccommit" "UR1c" # schema changes to the table would propagate to the OSM chunk # one session updates the range while the other updates the schema permutation "Ab" "UR1b" "UR1u" "Aadd" "UR1c" "Ac" permutation "Ab" "UR1b" "Aadd" "UR1u" "UR1c" "Ac" # test with two hypertables both having osm chunks. Should not block one another. So once tuple of hypertable1 is unlocked, permutation "LHTb" "Utest2b" "UR1b" "LockHypertableTuple" "UR1u" "Utest2u" "Utest2c" "UnlockHypertableTuple" "UR1c" # test two sessions concurrently dropping the OSM chunk permutation "DR1b" "DR2b" "DR1drop" "DR2drop" "DR1c" "DR2c" �������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/parallel_compression.spec�������������������������������0000664�0000000�0000000�00000004467�15100345067�0026056�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. ### # Test parallel operations on distinct chunks of the same hypertable ### setup { CREATE TABLE metrics (time timestamptz not null, device text, value float); SELECT FROM create_hypertable('metrics','time'); ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_segmentby = 'device'); INSERT INTO metrics SELECT '2000-01-01', 'device1', random() FROM generate_series(1,20000); INSERT INTO metrics SELECT '2001-01-01', 'device2', random() FROM generate_series(1,20000); CREATE VIEW chunks_to_compress AS SELECT ch.id, format('%I.%I',ch.schema_name,ch.table_name) AS name from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id AND ht.table_name='metrics' ORDER BY ch.id; } teardown { DROP TABLE metrics; DROP VIEW chunks_to_compress; } session "s1" setup { SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '300ms'; } step "s1_begin" { BEGIN; } step "s1_compress" { SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; } step "s1_decompress" { SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 0) ch; } step "s1_commit" { COMMIT; } session "s2" setup { SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '300ms'; } step "s2_begin" { BEGIN; } step "s2_commit" { COMMIT; } step "s2_compress" { SELECT compress_chunk(name) IS NOT NULL AS compress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; } step "s2_decompress" { SELECT decompress_chunk(name) IS NOT NULL AS decompress FROM (SELECT name FROM chunks_to_compress ORDER BY id LIMIT 1 OFFSET 1) ch; } permutation s1_begin s2_begin s1_compress s2_compress s2_commit s1_commit permutation s1_begin s2_begin s1_compress s2_compress s2_decompress s1_decompress s2_commit s1_commit permutation s1_begin s2_begin s1_compress s2_compress s2_commit s2_begin s2_decompress s1_decompress s2_commit s1_commit permutation s1_begin s2_begin s1_compress s2_compress s1_commit s1_begin s2_decompress s1_decompress s2_commit s1_commit ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/reorder_deadlock.spec.in��������������������������������0000664�0000000�0000000�00000003017�15100345067�0025524�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # reorder should win the deadlock detector setup { CREATE TABLE ts_reorder_test(time int, temp float, location int); SELECT create_hypertable('ts_reorder_test', 'time', chunk_time_interval => 10); INSERT INTO ts_reorder_test VALUES (1, 23.4, 1), (11, 21.3, 2), (21, 19.5, 3); CREATE TABLE waiter(i INTEGER); CREATE OR REPLACE FUNCTION reorder_chunk_i( chunk REGCLASS, index REGCLASS=NULL, verbose BOOLEAN=FALSE, wait_on REGCLASS=NULL ) RETURNS VOID AS '@TS_MODULE_PATHNAME@', 'ts_reorder_chunk' LANGUAGE C VOLATILE; } teardown { DROP TABLE ts_reorder_test; DROP TABLE waiter; } session "S" setup { BEGIN; } step "S1" { SELECT * FROM ts_reorder_test; } step "S2" { INSERT INTO ts_reorder_test VALUES (1, 23.4, 1); } step "Sc" { COMMIT; } session "R" setup { BEGIN; } step "R1" { SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); } step "Rc" { COMMIT; } session "B" setup { BEGIN; LOCK TABLE waiter; } step "Bc" { ROLLBACK; } # This fails in an unexpected manner, but isn't critical since this barrier is only ever used in tests, and shouldn't exist in real code #permutation "S1" "R1" "S2" "Bc" "Rc" "Sc" #upgrade deadlocks should favor reorder permutation "S1" "R1" "Bc" "S2" "Rc" "Sc" permutation "S1" "R1" "Bc" "S2" "Sc" "Rc" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/reorder_vs_insert.spec.in�������������������������������0000664�0000000�0000000�00000003553�15100345067�0025777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # reorder should be fully blocked by an insert into the chunk being reordered setup { CREATE TABLE ts_reorder_test(time int, temp float, location int); SELECT create_hypertable('ts_reorder_test', 'time', chunk_time_interval => 10); INSERT INTO ts_reorder_test VALUES (1, 23.4, 1), (11, 21.3, 2), (21, 19.5, 3); CREATE TABLE waiter(i INTEGER); -- like recluster_chunk except that it will attempt to grab and release an ACCESS EXCLUSIVE -- lock on wait_on before swapping the tables. This allows us to control interleaving more. CREATE OR REPLACE FUNCTION reorder_chunk_i( chunk REGCLASS, index REGCLASS=NULL, verbose BOOLEAN=FALSE, wait_on REGCLASS=NULL ) RETURNS VOID AS '@TS_MODULE_PATHNAME@', 'ts_reorder_chunk' LANGUAGE C VOLATILE; } teardown { DROP TABLE ts_reorder_test; DROP TABLE waiter; } session "I" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "I1" { INSERT INTO ts_reorder_test VALUES (1, 19.5, 3); } step "Ic" { COMMIT; } session "R" setup { BEGIN; SET LOCAL lock_timeout = '250ms'; SET LOCAL deadlock_timeout = '10ms'; } step "R1" { SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); } step "Rc" { COMMIT; } session "B" setup { BEGIN; LOCK TABLE waiter; } step "Bc" { COMMIT; } permutation "Bc" "I1" "Ic" "R1" "Rc" permutation "Bc" "I1" "R1" "Ic" "Rc" permutation "Bc" "I1" "R1"(*) "Rc" "Ic" permutation "Bc" "R1" "Rc" "I1" "Ic" permutation "Bc" "R1" "I1" "Rc" "Ic" permutation "Bc" "R1" "I1" "Ic" "Rc" permutation "R1" "I1"(R1) "Ic" "Bc" "Rc" permutation "R1" "I1" "Bc" "Rc" "Ic" permutation "I1" "R1" "Bc" "Rc" "Ic" �����������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/reorder_vs_insert_other_chunk.spec.in�������������������0000664�0000000�0000000�00000002521�15100345067�0030362�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # reorder should not be blocked by an insert into another chunk setup { CREATE TABLE ts_reorder_test(time int, temp float, location int); SELECT create_hypertable('ts_reorder_test', 'time', chunk_time_interval => 10); INSERT INTO ts_reorder_test VALUES (1, 23.4, 1), (11, 21.3, 2), (21, 19.5, 3); -- we need to use the waiting variant of reorder in order to work in a tranaction CREATE TABLE waiter(i INTEGER); CREATE OR REPLACE FUNCTION reorder_chunk_i( chunk REGCLASS, index REGCLASS=NULL, verbose BOOLEAN=FALSE, wait_on REGCLASS='waiter' ) RETURNS VOID AS '@TS_MODULE_PATHNAME@', 'ts_reorder_chunk' LANGUAGE C VOLATILE; } teardown { DROP TABLE ts_reorder_test; DROP TABLE waiter CASCADE; } session "I" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "I1" { INSERT INTO ts_reorder_test VALUES (11, 19.5, 3); } step "Ic" { COMMIT; } session "R" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "R1" { SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx'); } step "Rc" { COMMIT; } �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/reorder_vs_select.spec.in�������������������������������0000664�0000000�0000000�00000003716�15100345067�0025753�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # reorder should only be blocked by select for the final table swap setup { CREATE TABLE ts_reorder_test(time int, temp float, location int); SELECT create_hypertable('ts_reorder_test', 'time', chunk_time_interval => 10); INSERT INTO ts_reorder_test VALUES (1, 23.4, 1), (11, 21.3, 2), (21, 19.5, 3); CREATE TABLE waiter(i INTEGER); -- like reluster_chunk execpt that it'll attempt to grab an release a ACCESS EXCLUSIVE -- lock on wait_on before swapping the tables. This allows us to control interleaving more. CREATE OR REPLACE FUNCTION reorder_chunk_i( chunk REGCLASS, index REGCLASS=NULL, verbose BOOLEAN=FALSE, wait_on REGCLASS=NULL ) RETURNS VOID AS '@TS_MODULE_PATHNAME@', 'ts_reorder_chunk' LANGUAGE C VOLATILE; } teardown { DROP TABLE ts_reorder_test; DROP TABLE waiter; } session "S" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms';} step "S1" { SELECT * FROM ts_reorder_test; } step "Sc" { COMMIT; } session "R" setup { BEGIN; SET LOCAL lock_timeout = '500ms'; SET LOCAL deadlock_timeout = '10ms'; } step "R1" { SELECT reorder_chunk_i((SELECT show_chunks('ts_reorder_test') LIMIT 1), 'ts_reorder_test_time_idx', wait_on => 'waiter'); } step "Rc" { COMMIT; } session "B" setup { BEGIN; LOCK TABLE waiter; } step "Bc" { COMMIT; } permutation "Bc" "S1" "Sc" "R1" "Rc" permutation "Bc" "S1" "R1" "Sc" "Rc" permutation "Bc" "S1" "R1" "Rc" "Sc" permutation "Bc" "R1" "Rc" "S1" "Sc" permutation "Bc" "R1" "S1" "Rc" "Sc" permutation "Bc" "R1" "S1" "Sc" "Rc" #cannot work, select still holds the lock at Bc permutation "R1" "S1" "Bc" "Rc" "Sc" permutation "S1" "R1" "Bc" "Rc" "Sc" #should work, R does not yet have the read-lock at S1 permutation "R1" "S1" "Sc" "Bc" "Rc" permutation "S1" "R1" "Sc" "Bc" "Rc" ��������������������������������������������������timescaledb-2.23.0/tsl/test/isolation/specs/split_chunk_concurrent.spec�����������������������������0000664�0000000�0000000�00000016105�15100345067�0026416�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. setup { create table readings (time timestamptz, device int, temp float) with (fillfactor = 30); select create_hypertable('readings', 'time', chunk_time_interval => interval '1 week'); insert into readings values ('2024-01-04 01:00', 1, 1.0), ('2024-01-05 02:00', 2, 2.0), ('2024-01-08 02:00', 3, 3.0), ('2024-01-11 01:01', 4, 4.0), ('2024-01-15 02:00', 5, 5.0); alter table readings set (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='device'); create index on readings (device); create or replace procedure drop_one_chunk(hypertable regclass) as $$ declare chunk regclass; begin select cl.oid into chunk from pg_class cl join pg_inherits inh on (cl.oid = inh.inhrelid) where inh.inhparent = hypertable limit 1; execute format('drop table %s cascade', chunk); end; $$ LANGUAGE plpgsql; create or replace procedure split_first_chunk(hypertable regclass) as $$ declare chunk regclass; begin select cl.oid into chunk from pg_class cl join pg_inherits inh on (cl.oid = inh.inhrelid) where inh.inhparent = hypertable limit 1; execute format('call split_chunk(%L)', chunk); end; $$ LANGUAGE plpgsql; create or replace procedure show_all_chunks(hypertable regclass) as $$ declare chunk regclass; chunk_info timescaledb_information.chunks; n int = 0; row record; begin for chunk_info in select * from timescaledb_information.chunks where format('%I.%I', hypertable_schema, hypertable_name)::regclass = hypertable loop raise notice '---- chunk % [ % : % ]', n, chunk_info.range_start, chunk_info.range_end; for row in execute format('select * from %I.%I', chunk_info.chunk_schema, chunk_info.chunk_name) loop raise notice '%', row; end loop; n = n + 1; end loop; end; $$ LANGUAGE plpgsql; } teardown { drop table readings; } session "s1" setup { set local lock_timeout = '5000ms'; set local deadlock_timeout = '10ms'; } # The transaction will not "pick" a snapshot until the first query, so # do a simple select on pg_class to pick one for the transaction. We # don't want to query any tables involved in the test since that will # grab locks on them. step "s1_begin" { start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; } step "s1_commit" { commit; } # Insert two tuples that each go into different parts of the split chunk step "s1_insert_into_splitting_chunk" { insert into readings values ('2024-01-05 01:05', 10, 10.0), ('2024-01-09 01:05', 11, 11.0); } step "s1_insert_into_existing_chunk" { insert into readings values ('2024-01-12 01:05', 12, 12.0); } step "s1_insert_into_new_chunk" { insert into readings values ('2024-01-18 10:00', 13, 13.0); } step "s1_update_splitting_chunk" { update readings set device = 1 where device = 2; } step "s1_delete_from_splitting_chunk" { delete from readings where device = 1; } session "s2" setup { set local lock_timeout = '500ms'; set local deadlock_timeout = '100ms'; } step "s2_begin" { start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; } step "s2_commit" { commit; } step "s2_split_chunk" { call split_first_chunk('readings'); } step "s2_insert_into_splitting_chunk" { insert into readings values ('2024-01-05 01:05', 15, 15.0); } session "s3" setup { set local lock_timeout = '500ms'; set local deadlock_timeout = '100ms'; } step "s3_query_data" { call show_all_chunks('readings'); } step "s3_wp_before_routing_on" { select debug_waitpoint_enable('split_chunk_before_tuple_routing'); } step "s3_wp_before_routing_off" { select debug_waitpoint_release('split_chunk_before_tuple_routing'); } step "s3_wp_at_end_on" { select debug_waitpoint_enable('split_chunk_at_end'); } step "s3_wp_at_end_off" { select debug_waitpoint_release('split_chunk_at_end'); } step "s4_begin" { start transaction isolation level repeatable read; select count(*) > 0 from pg_stat_activity; } step "s4_query" { select * from readings order by time, device; } step "s4_commit" { commit; } # Concurrent insert into existing chunk while another chunk is being # split. The inserting process should not be blocked. permutation "s3_query_data" "s3_wp_at_end_on" "s2_split_chunk" "s1_insert_into_existing_chunk" "s3_wp_at_end_off" "s3_query_data" permutation "s3_query_data" "s3_wp_before_routing_on" "s2_split_chunk" "s1_insert_into_existing_chunk" "s3_wp_before_routing_off" "s3_query_data" # Concurrent insert into new chunk while another chunk is being # split. The inserting process is blocked because the split process # takes ShareUpdateExclusive lock on the hypertable root to attach the # new chunk from the split. permutation "s3_query_data" "s3_wp_at_end_on" "s2_split_chunk" "s1_insert_into_new_chunk" "s3_wp_at_end_off" "s3_query_data" permutation "s3_query_data" "s3_wp_before_routing_on" "s2_split_chunk" "s1_insert_into_new_chunk" "s3_wp_before_routing_off" "s3_query_data" # Concurrent insert into chunk being split. The inserting process # should be blocked and the two inserted tuples should end up in their # corresponding parts of the split chunk. permutation "s3_query_data" "s3_wp_at_end_on" "s2_split_chunk" "s1_insert_into_splitting_chunk" "s3_wp_at_end_off" "s3_query_data" permutation "s3_query_data" "s3_wp_before_routing_on" "s2_split_chunk" "s1_insert_into_splitting_chunk" "s3_wp_before_routing_off" "s3_query_data" # Concurrent insert into chunk being split. The inserting process # locks the chunk first so the split should be blocked. permutation "s3_query_data" "s1_begin" "s1_insert_into_splitting_chunk" "s2_split_chunk" "s1_commit" "s3_query_data" # Delete from splitting chunk permutation "s4_begin" "s3_query_data" "s1_begin" "s1_delete_from_splitting_chunk" "s2_split_chunk" "s1_commit" "s3_query_data" "s4_query" "s4_commit" "s4_query" permutation "s4_begin" "s3_query_data" "s1_delete_from_splitting_chunk" "s2_split_chunk" "s3_query_data" "s4_query" "s4_commit" "s4_query" # Delete and update on splitting chunk and concurrent query in # repeatable read. The querying process should see the old data after # split (including deleted tuple). After commit it sees the update/delete. permutation "s3_query_data" "s4_begin" "s1_delete_from_splitting_chunk" "s2_split_chunk" "s3_query_data" "s4_query" "s4_commit" "s4_query" "s3_query_data" permutation "s3_query_data" "s4_begin" "s1_update_splitting_chunk" "s2_split_chunk" "s3_query_data" "s4_query" "s4_commit" "s4_query" "s3_query_data" # Insert into splitting chunk by splitting process permutation "s2_begin" "s2_insert_into_splitting_chunk" "s2_split_chunk" "s3_query_data" "s2_commit" �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/postgresql.conf.in������������������������������������������������������0000664�0000000�0000000�00000002452�15100345067�0021316�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This section has to be equivalent to test/postgresql.conf jit=off autovacuum=true datestyle='Postgres, MDY' hba_file='@TEST_PG_HBA_FILE@' log_destination='jsonlog,stderr' log_directory='@TEST_PG_LOG_DIRECTORY@' log_filename='postmaster.log' log_line_prefix='%m: %u [%p] %d ' logging_collector=true max_worker_processes=24 random_page_cost=1.0 shared_preload_libraries=timescaledb timescaledb.last_tuned='1971-02-03 04:05:06.789012 -0300' timescaledb.last_tuned_version='0.0.1' timescaledb.passfile='@TEST_PASSFILE@' timescaledb_telemetry.cloud='ci' timezone='US/Pacific' # Set extra_float_digits=0 to retain the pre PG12 rounding behaviour # of floating point numbers, which are needed to make our tests work. extra_float_digits=0 @TELEMETRY_DEFAULT_SETTING@ # This section adds additional options required by TSL. timescaledb.license='timescale' max_connections=200 log_error_verbosity='VERBOSE' log_min_messages='INFO' # This breaks isolation tests, not sure why the statements end in # the isolation tester output. log_statement='all' # Some tests use logical entries in WAL wal_level = logical # It is necessary to have at least 2 more workers than `max_worker_processes` # in order to test failures starting bgworkers. timescaledb.max_background_workers=26 timescaledb.enable_compression_ratio_warnings=false ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/�����������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017102�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/CMakeLists.txt���������������������������������������������������0000664�0000000�0000000�00000000026�15100345067�0021640�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������add_subdirectory(sql) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/��������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020703�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/build_info.out������������������������������������������0000664�0000000�0000000�00000002154�15100345067�0023550�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Check what get_git_commit returns SELECT pg_typeof(commit_tag) AS commit_tag_type, pg_typeof(commit_hash) AS commit_hash_type, length(commit_hash) AS commit_hash_length, pg_typeof(commit_time) AS commit_time_type FROM _timescaledb_functions.get_git_commit(); commit_tag_type | commit_hash_type | commit_hash_length | commit_time_type -----------------+------------------+--------------------+-------------------------- text | text | 40 | timestamp with time zone SELECT extname, obj_description(oid, 'pg_extension') FROM pg_extension WHERE extname = 'timescaledb'; extname | obj_description -------------+--------------------------------------------------------------------------------------- timescaledb | Enables scalable inserts and complex queries for time-series data (Community Edition) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/cagg_compression.out������������������������������������0000664�0000000�0000000�00000045174�15100345067�0024771�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; SELECT format('include/%s_setup.sql', :'TEST_BASE_NAME') as "TEST_SETUP_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_source.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_SOURCE", format('%s/shared/results/%s_results_target.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TARGET" \gset SELECT format('\! diff -u --label "Source results" --label "Target results" %s %s', :'TEST_RESULTS_SOURCE', :'TEST_RESULTS_TARGET') as "DIFF_CMD" \gset -- Setup \ir :TEST_SETUP_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE extra_devices(device_id INT, name TEXT); INSERT INTO extra_devices VALUES (4,'Device 4'),(5,'Device 5'); --add a device id that is not in metrics or metrics_compressed -- need this for outer joins INSERT INTO extra_devices VALUES ( 333,'Device New 333'); CREATE VIEW all_devices AS SELECT * FROM devices UNION SELECT * FROM extra_devices; -- Compressed CAgg + Compressed Hypertable CREATE MATERIALIZED VIEW metrics_compressed_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT device_id, time_bucket(INTERVAL '1 week', time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics_compressed GROUP BY device_id, bucket WITH NO DATA; -- Force more than one chunk in the materialized hypertable SELECT set_chunk_time_interval( format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name), '1 week'::interval ) FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_compressed_summary'; set_chunk_time_interval ------------------------- ALTER MATERIALIZED VIEW metrics_compressed_summary SET (timescaledb.compress); psql:include/cagg_compression_setup.sql:42: NOTICE: defaulting compress_segmentby to device_id psql:include/cagg_compression_setup.sql:42: NOTICE: defaulting compress_orderby to bucket CALL refresh_continuous_aggregate('metrics_compressed_summary', NULL, '2000-01-15 23:55:00+0'); SELECT CASE WHEN res is NULL THEN NULL ELSE 'compressed' END as comp FROM ( SELECT compress_chunk(show_chunks('metrics_compressed_summary')) res ) q; comp ------------ compressed compressed -- Check for realtime caggs SELECT count(*) FROM metrics_compressed_summary WHERE bucket > _timescaledb_functions.to_timestamp( _timescaledb_functions.cagg_watermark( (SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'metrics_compressed_summary') ) ); count ------- 5 -- Compressed CAgg + Uncompressed Hypertable CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT device_id, time_bucket(INTERVAL '1 week', time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics GROUP BY device_id, bucket WITH NO DATA; -- Force more than one chunk in the materialized hypertable SELECT set_chunk_time_interval( format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name), '1 week'::interval ) FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_summary'; set_chunk_time_interval ------------------------- ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.compress); psql:include/cagg_compression_setup.sql:94: NOTICE: defaulting compress_segmentby to device_id psql:include/cagg_compression_setup.sql:94: NOTICE: defaulting compress_orderby to bucket CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-15 23:55:00+0'); SELECT CASE WHEN res is NULL THEN NULL ELSE 'compressed' END as comp FROM ( SELECT compress_chunk(show_chunks('metrics_summary')) res ) q; comp ------------ compressed compressed -- Check for realtime caggs SELECT count(*) FROM metrics_summary WHERE bucket > _timescaledb_functions.to_timestamp( _timescaledb_functions.cagg_watermark( (SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'metrics_summary') ) ); count ------- 5 \o :TEST_RESULTS_SOURCE \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \o \o :TEST_RESULTS_TARGET \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \o -- Compare results of CAgg over Compressed and Uncompressed hypertables :DIFF_CMD \o :TEST_RESULTS_SOURCE \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \o \o :TEST_RESULTS_TARGET \set TEST_TABLE1 '(SELECT device_id, time_bucket(INTERVAL $$1 week$$, time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics_compressed GROUP BY device_id, bucket)' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \set TEST_TABLE1 '(SELECT device_id, time_bucket(INTERVAL $$1 week$$, time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics_compressed GROUP BY device_id, bucket)' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \o -- Compare results between CAggs and Original View (to check PG and TSDB machinery) :DIFF_CMD -- Decompres 1 chunk from cagg SELECT CASE WHEN res is NULL THEN NULL ELSE 'decompress' END as dec FROM ( SELECT decompress_chunk(ch) res FROM show_chunks('metrics_compressed_summary') ch ORDER BY ch LIMIT 1) q; dec ------------ decompress -- Run tests and compare results \o :TEST_RESULTS_SOURCE \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \o \o :TEST_RESULTS_TARGET \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; \o -- Compare results of CAgg (partial compressed) over Compressed hypertables :DIFF_CMD -- Teardown DROP MATERIALIZED VIEW metrics_compressed_summary; NOTICE: drop cascades to 2 other objects DROP MATERIALIZED VIEW metrics_summary; NOTICE: drop cascades to 2 other objects DROP VIEW all_devices; DROP TABLE extra_devices; -- test enabling compression on cagg after column rename CREATE TABLE comp_rename(time timestamptz); SELECT table_name FROM create_hypertable('comp_rename', 'time'); table_name ------------- comp_rename CREATE MATERIALIZED VIEW comp_rename_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 week', time) AS bucket FROM comp_rename GROUP BY 1; NOTICE: continuous aggregate "comp_rename_cagg" is already up-to-date ALTER MATERIALIZED VIEW comp_rename_cagg RENAME COLUMN bucket to "time"; SET client_min_messages TO WARNING; ALTER MATERIALIZED VIEW comp_rename_cagg SET ( timescaledb.compress='true'); RESET client_min_messages; DROP TABLE comp_rename CASCADE; NOTICE: drop cascades to 3 other objects ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/chunkwise_agg_gather_sort.out���������������������������0000664�0000000�0000000�00000004455�15100345067�0026663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Exercise the GatherMerge -> Sort -> Append -> Partial Aggregate plan. \set prefix 'explain (buffers off, costs off, timing off, summary off)' set parallel_setup_cost = 0; set parallel_tuple_cost = 0; set max_parallel_workers_per_gather = 2; set parallel_leader_participation = off; set enable_hashagg to off; :prefix select count(*) from metrics group by v0; --- QUERY PLAN --- Finalize GroupAggregate Group Key: metrics.v0 -> Gather Merge Workers Planned: 2 -> Sort Sort Key: metrics.v0 -> Parallel Append -> Partial GroupAggregate Group Key: _hyper_X_X_chunk.v0 -> Sort Sort Key: _hyper_X_X_chunk.v0 -> Seq Scan on _hyper_X_X_chunk -> Partial GroupAggregate Group Key: _hyper_X_X_chunk.v0 -> Sort Sort Key: _hyper_X_X_chunk.v0 -> Seq Scan on _hyper_X_X_chunk -> Partial GroupAggregate Group Key: _hyper_X_X_chunk.v0 -> Sort Sort Key: _hyper_X_X_chunk.v0 -> Seq Scan on _hyper_X_X_chunk reset enable_hashagg; :prefix select count(*) from metrics group by v0; --- QUERY PLAN --- Finalize HashAggregate Group Key: metrics.v0 -> Gather Workers Planned: 2 -> Parallel Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk.v0 -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk.v0 -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk.v0 -> Seq Scan on _hyper_X_X_chunk reset parallel_setup_cost; reset parallel_tuple_cost; reset max_parallel_workers_per_gather; reset parallel_leader_participation; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/classify_relation.out�����������������������������������0000664�0000000�0000000�00000001112�15100345067�0025141�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test the case where the chunk is present both as a separate table and as a -- child of a hypertable. #4708 select show_chunks('metrics_compressed') chunk order by 1 limit 1 \gset select * from metrics_compressed inner join :chunk on (false); time | device_id | v0 | v1 | v2 | v3 | time | device_id | v0 | v1 | v2 | v3 ------+-----------+----+----+----+----+------+-----------+----+----+----+---- ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/compat.out����������������������������������������������0000664�0000000�0000000�00000054420�15100345067�0022724�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; \set ON_ERROR_STOP 0 SELECT _timescaledb_internal.alter_job_set_hypertable_id(0,0); WARNING: function _timescaledb_internal.alter_job_set_hypertable_id(integer,regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: job 0 not found SELECT _timescaledb_internal.attach_osm_table_chunk(0,0); WARNING: function _timescaledb_internal.attach_osm_table_chunk(regclass,regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.cagg_migrate_plan_exists(0); WARNING: function _timescaledb_internal.cagg_migrate_plan_exists(integer) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. cagg_migrate_plan_exists -------------------------- f SELECT _timescaledb_internal.cagg_migrate_pre_validation(NULL,NULL,NULL); WARNING: function _timescaledb_internal.cagg_migrate_pre_validation(text,text,text) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: continuous aggregate "<NULL>.<NULL>" does not exist SELECT _timescaledb_internal.cagg_watermark(0); WARNING: function _timescaledb_internal.cagg_watermark(integer) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid materialized hypertable ID: 0 SELECT _timescaledb_internal.cagg_watermark_materialized(0); WARNING: function _timescaledb_internal.cagg_watermark_materialized(integer) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid materialized hypertable ID: 0 SELECT _timescaledb_internal.calculate_chunk_interval(0,0,0); WARNING: function _timescaledb_internal.calculate_chunk_interval(integer,bigint,bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: could not find a matching hypertable for dimension 0 SELECT _timescaledb_internal.chunk_constraint_add_table_constraint(NULL); WARNING: function _timescaledb_internal.chunk_constraint_add_table_constraint(_timescaledb_catalog.chunk_constraint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: query returned no rows SELECT _timescaledb_internal.chunk_id_from_relid(0); WARNING: function _timescaledb_internal.chunk_id_from_relid(oid) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. chunk_id_from_relid --------------------- 0 SELECT _timescaledb_internal.chunk_status(0); WARNING: function _timescaledb_internal.chunk_status(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.chunks_local_size(NULL,NULL); WARNING: function _timescaledb_internal.chunks_local_size(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. chunks_local_size ------------------- SELECT _timescaledb_internal.compressed_chunk_local_stats(NULL,NULL); WARNING: function _timescaledb_internal.compressed_chunk_local_stats(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. compressed_chunk_local_stats ------------------------------ SELECT _timescaledb_internal.create_chunk(0,NULL,NULL,NULL,0); WARNING: function _timescaledb_internal.create_chunk(regclass,jsonb,name,name,regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.create_chunk_table(0,NULL,NULL,NULL); ERROR: function _timescaledb_internal.create_chunk_table(integer, unknown, unknown, unknown) does not exist at character 8 SELECT _timescaledb_internal.create_compressed_chunk(0,0,0,0,0,0,0,0,0,0); WARNING: function _timescaledb_internal.create_compressed_chunk(regclass,regclass,bigint,bigint,bigint,bigint,bigint,bigint,bigint,bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.drop_chunk(0); WARNING: function _timescaledb_internal.drop_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: chunk not found SELECT _timescaledb_internal.freeze_chunk(0); WARNING: function _timescaledb_internal.freeze_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT FROM _timescaledb_internal.generate_uuid(); WARNING: function _timescaledb_internal.generate_uuid() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. -- SELECT _timescaledb_internal.get_approx_row_count(0); WARNING: function _timescaledb_internal.get_approx_row_count(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. get_approx_row_count ---------------------- 0 SELECT _timescaledb_internal.get_compressed_chunk_index_for_recompression(0); WARNING: function _timescaledb_internal.get_compressed_chunk_index_for_recompression(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.get_create_command(NULL); WARNING: function _timescaledb_internal.get_create_command(name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: hypertable "<NULL>" not found SELECT pg_typeof(_timescaledb_internal.get_git_commit()); WARNING: function _timescaledb_internal.get_git_commit() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. pg_typeof ----------- record SELECT pg_typeof(_timescaledb_internal.get_os_info()); WARNING: function _timescaledb_internal.get_os_info() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. pg_typeof ----------- record SELECT _timescaledb_internal.get_partition_for_key(NULL::text); WARNING: function _timescaledb_internal.get_partition_for_key(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. get_partition_for_key ----------------------- SELECT _timescaledb_internal.get_partition_hash(NULL::text); WARNING: function _timescaledb_internal.get_partition_hash(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. get_partition_hash -------------------- SELECT _timescaledb_internal.hypertable_local_size(NULL,NULL); WARNING: function _timescaledb_internal.hypertable_local_size(name,name) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. hypertable_local_size ----------------------- SELECT _timescaledb_internal.interval_to_usec(NULL); WARNING: function _timescaledb_internal.interval_to_usec(interval) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. interval_to_usec ------------------ SELECT _timescaledb_internal.partialize_agg(NULL::text); WARNING: function _timescaledb_internal.partialize_agg(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. partialize_agg ---------------- SELECT _timescaledb_internal.policy_compression_check(NULL); WARNING: function _timescaledb_internal.policy_compression_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: config must not be NULL SELECT _timescaledb_internal.policy_job_stat_history_retention(0,NULL); WARNING: function _timescaledb_internal.policy_job_stat_history_retention(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: permission denied for table bgw_job_stat_history SELECT _timescaledb_internal.policy_job_stat_history_retention_check(NULL); WARNING: function _timescaledb_internal.policy_job_stat_history_retention_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: config cannot be NULL, and must contain drop_after SELECT _timescaledb_internal.policy_refresh_continuous_aggregate_check(NULL); WARNING: function _timescaledb_internal.policy_refresh_continuous_aggregate_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: config must not be NULL SELECT _timescaledb_internal.policy_reorder_check(NULL); WARNING: function _timescaledb_internal.policy_reorder_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: config must not be NULL SELECT _timescaledb_internal.policy_retention_check(NULL); WARNING: function _timescaledb_internal.policy_retention_check(jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: config must not be NULL SELECT _timescaledb_internal.range_value_to_pretty(0,0); WARNING: function _timescaledb_internal.range_value_to_pretty(bigint,regtype) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. range_value_to_pretty ----------------------- 0 SELECT _timescaledb_internal.recompress_chunk_segmentwise(0,true); WARNING: function _timescaledb_internal.recompress_chunk_segmentwise(regclass,boolean) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.relation_size(0); WARNING: function _timescaledb_internal.relation_size(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. relation_size --------------- (,,,) SELECT _timescaledb_internal.restart_background_workers(); WARNING: function _timescaledb_internal.restart_background_workers() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: must be superuser to restart background workers SELECT _timescaledb_internal.show_chunk(0); WARNING: function _timescaledb_internal.show_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.start_background_workers(); WARNING: function _timescaledb_internal.start_background_workers() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: must be superuser to start background workers SELECT _timescaledb_internal.stop_background_workers(); WARNING: function _timescaledb_internal.stop_background_workers() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: must be superuser to stop background workers SELECT _timescaledb_internal.subtract_integer_from_now(0,0); WARNING: function _timescaledb_internal.subtract_integer_from_now(regclass,bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid SELECT _timescaledb_internal.time_to_internal(NULL::timestamptz); WARNING: function _timescaledb_internal.time_to_internal(anyelement) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. time_to_internal ------------------ SELECT _timescaledb_internal.to_date(0); WARNING: function _timescaledb_internal.to_date(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. to_date ------------ 01-01-1970 SELECT _timescaledb_internal.to_interval(0); WARNING: function _timescaledb_internal.to_interval(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. to_interval ------------- @ 0 SELECT _timescaledb_internal.to_timestamp(0); WARNING: function _timescaledb_internal.to_timestamp(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. to_timestamp ------------------------------ Wed Dec 31 16:00:00 1969 PST SELECT _timescaledb_internal.to_timestamp_without_timezone(0); WARNING: function _timescaledb_internal.to_timestamp_without_timezone(bigint) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. to_timestamp_without_timezone ------------------------------- Thu Jan 01 00:00:00 1970 SELECT _timescaledb_internal.to_unix_microseconds(NULL); WARNING: function _timescaledb_internal.to_unix_microseconds(timestamp with time zone) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. to_unix_microseconds ---------------------- SELECT _timescaledb_internal.tsl_loaded(); WARNING: function _timescaledb_internal.tsl_loaded() is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. tsl_loaded ------------ t SELECT _timescaledb_internal.unfreeze_chunk(0); WARNING: function _timescaledb_internal.unfreeze_chunk(regclass) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: invalid Oid CALL _timescaledb_internal.cagg_migrate_create_plan(NULL,NULL,true,true); WARNING: procedure _timescaledb_internal.cagg_migrate_create_plan(_timescaledb_catalog.continuous_agg,text,boolean,boolean) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: permission denied for table continuous_agg_migrate_plan CALL _timescaledb_internal.cagg_migrate_execute_copy_data(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_copy_data(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: null values cannot be formatted as an SQL identifier CALL _timescaledb_internal.cagg_migrate_execute_copy_policies(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_copy_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.cagg_migrate_execute_create_new_cagg(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_create_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: null values cannot be formatted as an SQL identifier CALL _timescaledb_internal.cagg_migrate_execute_disable_policies(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_disable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.cagg_migrate_execute_enable_policies(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_enable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.cagg_migrate_execute_override_cagg(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_override_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: null values cannot be formatted as an SQL identifier CALL _timescaledb_internal.cagg_migrate_execute_plan(NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_plan(_timescaledb_catalog.continuous_agg) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(NULL,NULL); WARNING: procedure _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: null value in column "mat_hypertable_id" of relation "continuous_aggs_watermark" violates not-null constraint CALL _timescaledb_internal.policy_compression(0,NULL); WARNING: procedure _timescaledb_internal.policy_compression(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. ERROR: job 0 has null config CALL _timescaledb_internal.policy_recompression(0,NULL); WARNING: procedure _timescaledb_internal.policy_recompression(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.policy_refresh_continuous_aggregate(0,NULL); WARNING: procedure _timescaledb_internal.policy_refresh_continuous_aggregate(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.policy_reorder(0,NULL); WARNING: procedure _timescaledb_internal.policy_reorder(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL _timescaledb_internal.policy_retention(0,NULL); WARNING: procedure _timescaledb_internal.policy_retention(integer,jsonb) is deprecated and has been moved to _timescaledb_functions schema. this compatibility function will be removed in a future version. CALL public.recompress_chunk(0); WARNING: procedure public.recompress_chunk(regclass,boolean) is deprecated and the functionality is now included in public.compress_chunk. this compatibility function will be removed in a future version. ERROR: invalid Oid \set ON_ERROR_STOP 1 -- tests for the cagg invalidation trigger on the deprecated schema CREATE TABLE sensor_data ( time TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT hypertable_id FROM create_hypertable('sensor_data','time') \gset CREATE MATERIALIZED VIEW sensor_data_hourly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 hour', time), min(time), max(time) FROM sensor_data GROUP BY 1 WITH DATA; NOTICE: continuous aggregate "sensor_data_hourly" is already up-to-date INSERT INTO sensor_data values('1980-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('sensor_data_hourly', NULL, NULL); -- should not return rows because there's old invalid regions SELECT lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :'hypertable_id'; lowest_modified_value | greatest_modified_value -----------------------+------------------------- -- insert old data to create invalidation log INSERT INTO sensor_data values('1979-12-31 00:00:00-00', 1); -- should return the invalidation log generated by previous insert SELECT lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :'hypertable_id'; lowest_modified_value | greatest_modified_value -----------------------+------------------------- 315446400000000 | 315446400000000 DROP MATERIALIZED VIEW sensor_data_hourly; NOTICE: drop cascades to table _timescaledb_internal._hyper_X_X_chunk DROP TABLE sensor_data CASCADE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/compress_bloom_sparse_compat.out������������������������0000664�0000000�0000000�00000001036�15100345067�0027377�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test binary compatibility. The hash values might change if the UMASH custom -- hashing is not built on this platform, we had this problem before. select _timescaledb_functions.bloom1_contains( '\xd098c885f08468eb8916751d947f248ed2843a88c02b1dea6228591c588b8068'::_timescaledb_internal.bloom1, '1y.yield'::text) ; bloom1_contains ----------------- t ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/compress_unique_index.out�������������������������������0000664�0000000�0000000�00000005211�15100345067�0026043�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test unique expression indexes CREATE TABLE compress_unique(offset_timestamp timestamptz not null, meter_id text, meter_channel_id text, timestamp timestamptz); SELECT table_name FROM create_hypertable('compress_unique','offset_timestamp'); table_name ----------------- compress_unique CREATE UNIQUE INDEX uniq_expr ON compress_unique USING btree (lower((meter_id)::text), meter_channel_id, offset_timestamp, "timestamp"); ALTER TABLE compress_unique SET (timescaledb.compress,timescaledb.compress_segmentby='meter_id,meter_channel_id', timescaledb.compress_orderby='offset_timestamp desc'); WARNING: column "timestamp" should be used for segmenting or ordering INSERT INTO compress_unique VALUES ('2000-01-01','m1','c1','2000-01-01'); INSERT INTO compress_unique VALUES ('2000-01-01','m1','c2','2000-01-01'); SELECT compress_chunk(show_chunks('compress_unique')) IS NOT NULL AS compress; compress ---------- t -- should fail \set ON_ERROR_STOP 0 INSERT INTO compress_unique VALUES ('2000-01-01','m1','c2','2000-01-01'); ERROR: duplicate key value violates unique constraint "_hyper_X_X_chunk_uniq_expr" \set ON_ERROR_STOP 1 -- should only decompress 1 batch EXPLAIN (analyze,buffers off, costs off,summary off,timing off) INSERT INTO compress_unique VALUES ('2000-01-01','m1','c2','2000-01-02'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 1 -> Insert on compress_unique (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) -- should decompress no batches EXPLAIN (analyze,buffers off, costs off,summary off,timing off) INSERT INTO compress_unique VALUES ('2000-01-01','m1','c3','2000-01-02'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on compress_unique (actual rows=0.00 loops=1) -> Result (actual rows=1.00 loops=1) SELECT * FROM compress_unique ORDER BY compress_unique; offset_timestamp | meter_id | meter_channel_id | timestamp ------------------------------+----------+------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | m1 | c1 | Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST | m1 | c2 | Sat Jan 01 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST | m1 | c2 | Sun Jan 02 00:00:00 2000 PST Sat Jan 01 00:00:00 2000 PST | m1 | c3 | Sun Jan 02 00:00:00 2000 PST DROP TABLE compress_unique; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/compression_dml.out�������������������������������������0000664�0000000�0000000�00000114023�15100345067�0024632�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ANALYZE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' -- test constraint exclusion with prepared statements and generic plans CREATE TABLE i3719 (time timestamptz NOT NULL,data text); SELECT table_name FROM create_hypertable('i3719', 'time'); table_name ------------ i3719 ALTER TABLE i3719 SET (timescaledb.compress); INSERT INTO i3719 VALUES('2021-01-01 00:00:00', 'chunk 1'); SELECT count(compress_chunk(c)) FROM show_chunks('i3719') c; count ------- 1 INSERT INTO i3719 VALUES('2021-02-22 08:00:00', 'chunk 2'); SET plan_cache_mode TO force_generic_plan; PREPARE p1(timestamptz) AS UPDATE i3719 SET data = 'x' WHERE time=$1; PREPARE p2(timestamptz) AS DELETE FROM i3719 WHERE time=$1; EXECUTE p1('2021-02-22T08:00:00+00'); EXECUTE p2('2021-02-22T08:00:00+00'); DEALLOCATE p1; DEALLOCATE p2; DROP TABLE i3719; -- github issue 4778 CREATE TABLE metric_5m ( time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL ); SELECT table_name FROM create_hypertable( 'metric_5m'::regclass, 'time'::name, chunk_time_interval=>interval '5m', create_default_indexes=> false); table_name ------------ metric_5m -- enable compression ALTER TABLE metric_5m SET ( timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time, value' ); SET work_mem TO '64kB'; SELECT '2022-10-10 14:33:44.1234+05:30' as start_date \gset -- populate hypertable INSERT INTO metric_5m (time, series_id, value) SELECT t, s,1 from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '10s') t cross join generate_series(1,10, 1) s; -- manually compress all chunks SELECT count(compress_chunk(c)) FROM show_chunks('metric_5m') c; count ------- 289 -- populate into compressed hypertable, this should not crash INSERT INTO metric_5m (time, series_id, value) SELECT t, s,1 from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '10s') t cross join generate_series(1,10, 1) s; -- clean up RESET work_mem; DROP TABLE metric_5m; -- github issue 5134 CREATE TABLE mytab (time TIMESTAMPTZ NOT NULL, a INT, b INT, c INT); SELECT table_name FROM create_hypertable('mytab', 'time', chunk_time_interval => interval '1 day'); table_name ------------ mytab INSERT INTO mytab SELECT time, CASE WHEN (:'start_date'::timestamptz - time < interval '1 days') THEN 1 WHEN (:'start_date'::timestamptz - time < interval '2 days') THEN 2 WHEN (:'start_date'::timestamptz - time < interval '3 days') THEN 3 ELSE 4 END as a from generate_series(:'start_date'::timestamptz - interval '3 days', :'start_date'::timestamptz, interval '5 sec') as g1(time); -- enable compression ALTER TABLE mytab SET ( timescaledb.compress, timescaledb.compress_segmentby = 'a, c' ); -- get first chunk name SELECT chunk_schema || '.' || chunk_name as "chunk_table" FROM timescaledb_information.chunks WHERE hypertable_name = 'mytab' ORDER BY range_start limit 1 \gset -- compress only the first chunk SELECT count(compress_chunk(:'chunk_table')); count ------- 1 -- insert a row into first compressed chunk INSERT INTO mytab SELECT '2022-10-07 05:30:10+05:30'::timestamp with time zone, 3, 3; -- should not crash EXPLAIN (buffers off, costs off) SELECT * FROM :chunk_table; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk DROP TABLE mytab CASCADE; -- test varchar segmentby CREATE TABLE comp_seg_varchar ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar NOT NULL, data jsonb ); SELECT table_name FROM create_hypertable('comp_seg_varchar', 'time'); WARNING: column type "character varying" used for "source_id" does not follow best practices WARNING: column type "character varying" used for "label" does not follow best practices table_name ------------------ comp_seg_varchar CREATE UNIQUE INDEX ON comp_seg_varchar(source_id, label, "time" DESC); ALTER TABLE comp_seg_varchar SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO comp_seg_varchar SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT count(compress_chunk(c)) FROM show_chunks('comp_seg_varchar') c; count ------- 2 -- all tuples should come from compressed chunks EXPLAIN (analyze,buffers off, costs off, timing off, summary off) SELECT * FROM comp_seg_varchar; --- QUERY PLAN --- Append (actual rows=90.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=9.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=63.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=9.00 loops=1) INSERT INTO comp_seg_varchar(time, source_id, label, data) VALUES ('1990-01-02 00:00:00+00', 'test', 'test', '{}'::jsonb) ON CONFLICT (source_id, label, time) DO UPDATE SET data = '{"update": true}'; -- no tuples should be moved into uncompressed EXPLAIN (analyze,buffers off, costs off, timing off, summary off) SELECT * FROM comp_seg_varchar; --- QUERY PLAN --- Append (actual rows=91.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=9.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=63.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=9.00 loops=1) INSERT INTO comp_seg_varchar(time, source_id, label, data) VALUES ('1990-01-02 00:00:00+00', '1', '2', '{}'::jsonb) ON CONFLICT (source_id, label, time) DO UPDATE SET data = '{"update": true}'; -- 1 batch should be moved into uncompressed EXPLAIN (analyze,buffers off, costs off, timing off, summary off) SELECT * FROM comp_seg_varchar; --- QUERY PLAN --- Append (actual rows=92.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=27.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=9.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=63.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=9.00 loops=1) DROP TABLE comp_seg_varchar; -- test row locks for compressed tuples are blocked CREATE TABLE row_locks(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('row_locks', 'time'); table_name ------------ row_locks ALTER TABLE row_locks SET (timescaledb.compress); INSERT INTO row_locks VALUES('2021-01-01 00:00:00'); SELECT count(compress_chunk(c)) FROM show_chunks('row_locks') c; count ------- 1 -- should succeed cause no compressed tuples are returned SELECT FROM row_locks WHERE time < '2021-01-01 00:00:00' FOR UPDATE; -- -- should be blocked \set ON_ERROR_STOP 0 SELECT FROM row_locks FOR UPDATE; ERROR: locking compressed tuples is not supported SELECT FROM row_locks FOR NO KEY UPDATE; ERROR: locking compressed tuples is not supported SELECT FROM row_locks FOR SHARE; ERROR: locking compressed tuples is not supported SELECT FROM row_locks FOR KEY SHARE; ERROR: locking compressed tuples is not supported \set ON_ERROR_STOP 1 DROP TABLE row_locks; CREATE TABLE lazy_decompress(time timestamptz not null, device text, value float, primary key (device,time)); SELECT table_name FROM create_hypertable('lazy_decompress', 'time'); table_name ----------------- lazy_decompress ALTER TABLE lazy_decompress SET (timescaledb.compress, timescaledb.compress_segmentby = 'device'); INSERT INTO lazy_decompress SELECT '2024-01-01'::timestamptz + format('%s',i)::interval, 'd1', i FROM generate_series(1,6000) g(i); SELECT count(compress_chunk(c)) FROM show_chunks('lazy_decompress') c; count ------- 1 -- no decompression cause no match in batch BEGIN; :ANALYZE INSERT INTO lazy_decompress SELECT '2024-01-01 0:00:00.5','d1',random() ON CONFLICT DO NOTHING; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on lazy_decompress (actual rows=0.00 loops=1) Conflict Resolution: NOTHING Tuples Inserted: 1 Conflicting Tuples: 0 -> Subquery Scan on "*SELECT*" (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) BEGIN; :ANALYZE INSERT INTO lazy_decompress SELECT '2024-01-01 0:00:00.5','d1',random() ON CONFLICT(time,device) DO UPDATE SET value=EXCLUDED.value; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on lazy_decompress (actual rows=0.00 loops=1) Conflict Resolution: UPDATE Conflict Arbiter Indexes: lazy_decompress_pkey Tuples Inserted: 1 Conflicting Tuples: 0 -> Subquery Scan on "*SELECT*" (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -- should decompress 1 batch cause there is match BEGIN; :ANALYZE INSERT INTO lazy_decompress SELECT '2024-01-01 0:00:01','d1',random() ON CONFLICT DO NOTHING; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on lazy_decompress (actual rows=0.00 loops=1) Conflict Resolution: NOTHING Tuples Inserted: 0 Conflicting Tuples: 1 -> Subquery Scan on "*SELECT*" (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) -- no decompression cause no match in batch BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 0; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 6 -> Update on lazy_decompress (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk lazy_decompress_1 -> Result (actual rows=0.00 loops=1) -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=0.00 loops=1) Filter: (value = '0'::double precision) BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 0 AND device='d1'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 6 -> Update on lazy_decompress (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk lazy_decompress_1 -> Result (actual rows=0.00 loops=1) -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=0.00 loops=1) Filter: ((value = '0'::double precision) AND (device = 'd1'::text)) -- 1 batch decompression BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 2300; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 5 Batches decompressed: 1 Tuples decompressed: 1000 -> Update on lazy_decompress (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk lazy_decompress_1 -> Result (actual rows=1.00 loops=1) -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=1.00 loops=1) Filter: (value = '2300'::double precision) Rows Removed by Filter: 999 BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value > 3100 AND value < 3200; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 5 Batches decompressed: 1 Tuples decompressed: 1000 -> Update on lazy_decompress (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk lazy_decompress_1 -> Result (actual rows=99.00 loops=1) -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=99.00 loops=1) Filter: ((value > '3100'::double precision) AND (value < '3200'::double precision)) Rows Removed by Filter: 901 BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value BETWEEN 3100 AND 3200; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 5 Batches decompressed: 1 Tuples decompressed: 1000 -> Update on lazy_decompress (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk lazy_decompress_1 -> Result (actual rows=101.00 loops=1) -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=101.00 loops=1) Filter: ((value >= '3100'::double precision) AND (value <= '3200'::double precision)) Rows Removed by Filter: 899 -- check GUC is working, should be 6 batches and 6000 tuples decompresed SET timescaledb.enable_dml_decompression_tuple_filtering TO off; BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 0 AND device='d1'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 6000 -> Update on lazy_decompress (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk lazy_decompress_1 -> Result (actual rows=0.00 loops=1) -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=0.00 loops=1) Filter: ((value = '0'::double precision) AND (device = 'd1'::text)) Rows Removed by Filter: 6000 RESET timescaledb.enable_dml_decompression_tuple_filtering; -- no decompression cause no match in batch BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 0; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 6 -> Delete on lazy_decompress (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk lazy_decompress_1 -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=0.00 loops=1) Filter: (value = '0'::double precision) BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 0 AND device='d1'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 6 -> Delete on lazy_decompress (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk lazy_decompress_1 -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=0.00 loops=1) Filter: ((value = '0'::double precision) AND (device = 'd1'::text)) -- 1 batch decompression BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 2300; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 5 Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on lazy_decompress (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk lazy_decompress_1 -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=1.00 loops=1) Filter: (value = '2300'::double precision) Rows Removed by Filter: 999 BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value > 3100 AND value < 3200; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 5 Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on lazy_decompress (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk lazy_decompress_1 -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=99.00 loops=1) Filter: ((value > '3100'::double precision) AND (value < '3200'::double precision)) Rows Removed by Filter: 901 BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value BETWEEN 3100 AND 3200; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 5 Batches decompressed: 1 Tuples decompressed: 1000 -> Delete on lazy_decompress (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk lazy_decompress_1 -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=101.00 loops=1) Filter: ((value >= '3100'::double precision) AND (value <= '3200'::double precision)) Rows Removed by Filter: 899 -- check GUC is working, should be 6 batches and 6000 tuples decompresed SET timescaledb.enable_dml_decompression_tuple_filtering TO off; BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 0 AND device='d1'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 6000 -> Delete on lazy_decompress (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk lazy_decompress_1 -> Seq Scan on _hyper_X_X_chunk lazy_decompress_1 (actual rows=0.00 loops=1) Filter: ((value = '0'::double precision) AND (device = 'd1'::text)) Rows Removed by Filter: 6000 RESET timescaledb.enable_dml_decompression_tuple_filtering; DROP TABLE lazy_decompress; CREATE FUNCTION trigger_function() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN RAISE WARNING 'Trigger fired'; RETURN NEW; END; $$; -- test direct delete on compressed hypertable CREATE TABLE direct_delete(time timestamptz not null, device text, reading text, value float); SELECT table_name FROM create_hypertable('direct_delete', 'time'); table_name --------------- direct_delete ALTER TABLE direct_delete SET (timescaledb.compress, timescaledb.compress_segmentby = 'device, reading'); INSERT INTO direct_delete VALUES ('2021-01-01', 'd1', 'r1', 1.0), ('2021-01-01', 'd1', 'r2', 1.0), ('2021-01-01', 'd1', 'r3', 1.0), ('2021-01-01', 'd1', NULL, 1.0), ('2021-01-01', 'd2', 'r1', 1.0), ('2021-01-01', 'd2', 'r2', 1.0), ('2021-01-01', 'd2', 'r3', 1.0), ('2021-01-01', 'd2', NULL, 1.0); SELECT count(compress_chunk(c)) FROM show_chunks('direct_delete') c; count ------- 1 BEGIN; -- should be 3 batches directly deleted :ANALYZE DELETE FROM direct_delete WHERE device='d1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: (device = 'd1'::text) -- double check its actually deleted SELECT count(*) FROM direct_delete WHERE device='d1'; count ------- 0 ROLLBACK; BEGIN; -- should be 2 batches directly deleted :ANALYZE DELETE FROM direct_delete WHERE reading='r2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: (reading = 'r2'::text) -- double check its actually deleted SELECT count(*) FROM direct_delete WHERE reading='r2'; count ------- 0 ROLLBACK; -- issue #7644 -- make sure non-btree operators don't delete unrelated batches BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading <> 'r2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: (reading <> 'r2'::text) -- 4 tuples should still be there SELECT count(*) FROM direct_delete; count ------- 4 ROLLBACK; -- test IS NULL BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading IS NULL; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 2 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=2.00 loops=1) Filter: (reading IS NULL) -- 6 tuples should still be there SELECT count(*) FROM direct_delete; count ------- 6 ROLLBACK; -- test IS NOT NULL BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading IS NOT NULL; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 6 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=6.00 loops=1) Filter: (reading IS NOT NULL) -- 2 tuples should still be there SELECT count(*) FROM direct_delete; count ------- 2 ROLLBACK; -- test IN BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading IN ('r1','r2'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: (reading = ANY ('{r1,r2}'::text[])) -- 4 tuples should still be there SELECT count(*) FROM direct_delete; count ------- 4 ROLLBACK; -- test IN BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading NOT IN ('r1'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: (reading <> 'r1'::text) -- 4 tuples should still be there SELECT count(*) FROM direct_delete; count ------- 4 ROLLBACK; -- combining constraints on segmentby columns should work BEGIN; -- should be 1 batches directly deleted :ANALYZE DELETE FROM direct_delete WHERE device='d1' AND reading='r2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: ((device = 'd1'::text) AND (reading = 'r2'::text)) -- double check its actually deleted SELECT count(*) FROM direct_delete WHERE device='d1' AND reading='r2'; count ------- 0 ROLLBACK; -- constraints involving non-segmentby columns should not directly delete BEGIN; :ANALYZE DELETE FROM direct_delete WHERE value = '1.0'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 8 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: (value = '1'::double precision) BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd1' AND value = '1.0'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: ((device = 'd1'::text) AND (value = '1'::double precision)) BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading = 'r1' AND value = '1.0'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: ((reading = 'r1'::text) AND (value = '1'::double precision)) BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd2' AND reading = 'r3' AND value = '1.0'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 1 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=0.00 loops=1) Filter: ((device = 'd2'::text) AND (reading = 'r3'::text) AND (value = '1'::double precision)) -- presence of trigger should prevent direct delete CREATE TRIGGER direct_delete_trigger BEFORE DELETE ON direct_delete FOR EACH ROW EXECUTE FUNCTION trigger_function(); BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd1'; ROLLBACK; WARNING: Trigger fired WARNING: Trigger fired WARNING: Trigger fired WARNING: Trigger fired --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 4 Tuples decompressed: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=4.00 loops=1) Filter: (device = 'd1'::text) Trigger direct_delete_trigger on _hyper_X_X_chunk: calls=4 DROP TRIGGER direct_delete_trigger ON direct_delete; CREATE TRIGGER direct_delete_trigger AFTER DELETE ON direct_delete FOR EACH ROW EXECUTE FUNCTION trigger_function(); BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd1'; ROLLBACK; WARNING: Trigger fired WARNING: Trigger fired WARNING: Trigger fired WARNING: Trigger fired --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 4 Tuples decompressed: 4 -> Delete on direct_delete (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk direct_delete_1 -> Seq Scan on _hyper_X_X_chunk direct_delete_1 (actual rows=4.00 loops=1) Filter: (device = 'd1'::text) Trigger direct_delete_trigger on _hyper_X_X_chunk: calls=4 DROP TRIGGER direct_delete_trigger ON direct_delete; DROP TABLE direct_delete; DROP FUNCTION trigger_function; -- test DML on metadata columns CREATE TABLE compress_dml(time timestamptz NOT NULL, device text, reading text, value float); SELECT table_name FROM create_hypertable('compress_dml', 'time'); table_name -------------- compress_dml ALTER TABLE compress_dml SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time DESC, reading'); INSERT INTO compress_dml VALUES ('2025-01-01','d1','r1',0.01), ('2025-01-01','d2','r2',0.01), ('2025-01-01','d3','r1',0.01), ('2025-01-01','d3','r2',0.01), ('2025-01-01','d4','r1',0.01), ('2025-01-01','d4',NULL,0.01), ('2025-01-01','d5','r2',0.01), ('2025-01-01','d5',NULL,0.01), ('2025-01-01','d6','r1',0.01), ('2025-01-01','d6','r2',0.01), ('2025-01-01','d6',NULL,0.01); SELECT count(compress_chunk(ch)) FROM show_chunks('compress_dml') ch; count ------- 1 BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading = 'r1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 3 Tuples decompressed: 7 Batches deleted: 1 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=3.00 loops=1) Filter: (reading = 'r1'::text) Rows Removed by Filter: 4 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d2 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading <> 'r1'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 2 Batches decompressed: 3 Tuples decompressed: 7 Batches deleted: 1 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=3.00 loops=1) Filter: (reading <> 'r1'::text) Rows Removed by Filter: 4 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d1 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading IS NULL; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 11 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=3.00 loops=1) Filter: (reading IS NULL) Rows Removed by Filter: 8 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d1 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d2 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r2 | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading IS NOT NULL; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 11 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=8.00 loops=1) Filter: (reading IS NOT NULL) Rows Removed by Filter: 3 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading IN ('r2','r3'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 11 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=4.00 loops=1) Filter: (reading = ANY ('{r2,r3}'::text[])) Rows Removed by Filter: 7 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d1 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading = ANY('{r2,r3}'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 11 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=4.00 loops=1) Filter: (reading = ANY ('{r2,r3}'::text[])) Rows Removed by Filter: 7 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d1 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r1 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading NOT IN ('r2','r3'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 11 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=4.00 loops=1) Filter: (reading <> ALL ('{r2,r3}'::text[])) Rows Removed by Filter: 7 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d2 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading <> ALL('{r2,r3}'); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 6 Tuples decompressed: 11 -> Delete on compress_dml (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk compress_dml_1 -> Seq Scan on _hyper_X_X_chunk compress_dml_1 (actual rows=4.00 loops=1) Filter: (reading <> ALL ('{r2,r3}'::text[])) Rows Removed by Filter: 7 SELECT * FROM compress_dml t ORDER BY t; time | device | reading | value ------------------------------+--------+---------+------- Wed Jan 01 00:00:00 2025 PST | d2 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d3 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d4 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d5 | | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | r2 | 0.01 Wed Jan 01 00:00:00 2025 PST | d6 | | 0.01 ROLLBACK; DROP TABLE compress_dml; -- Test issue #8241: invalidate generic plans for prepared statements -- when partial chunk is created from compressed chunk via UPDATE/DELETE CREATE TABLE t8241(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('t8241', 'time'); table_name ------------ t8241 INSERT INTO t8241(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO t8241(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE t8241 SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('t8241') ch; count ------- 1 PREPARE prep AS SELECT * FROM t8241; -- Should only see compressed chunk in the plan, this generic plan is now cached EXECUTE prep; time | device | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | d1 | 1 Wed Jan 01 00:00:00 2020 PST | d1 | 1 EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -- Test Update BEGIN; -- This will add decompressed row to the compressed chunk UPDATE t8241 SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; -- generic plan created for compressed chunk should be invalidated even though we didn't commit -- we should get correct result and the plan should have both compressed and decompressed parts EXECUTE prep; time | device | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | d1 | 1 Wed Jan 01 00:30:00 2020 PST | d1 | 1 EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk ROLLBACK; -- Should see the compressed chunk only EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -- Test Insert BEGIN; -- This will add decompressed row to the compressed chunk INSERT INTO t8241(time, device, value) VALUES ('2020-01-01 00:30:00', 'd1', 1.0); -- generic plan created for compressed chunk should be invalidated even though we didn't commit -- we should get correct result and the plan should have both compressed and decompressed parts EXECUTE prep; time | device | value ------------------------------+--------+------- Wed Jan 01 01:00:00 2020 PST | d1 | 1 Wed Jan 01 00:00:00 2020 PST | d1 | 1 Wed Jan 01 00:30:00 2020 PST | d1 | 1 EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk ROLLBACK; DEALLOCATE prep; DROP TABLE t8241 cascade; RESET plan_cache_mode; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/compression_nulls_not_distinct.out����������������������0000664�0000000�0000000�00000004631�15100345067�0027777�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test NULL NOT DISTINCT unique constraint -- this test is run only on PG15 since support for NULL NOT DISTINCT -- only exists since then. once we drop support for PG14, this test -- can be moved to non-shared compression_conflicts test set timescaledb.debug_compression_path_info to on; CREATE TABLE nulls_not_distinct(time timestamptz not null, device text, label text, value float); CREATE UNIQUE INDEX ON nulls_not_distinct (time, device, label) NULLS NOT DISTINCT; SELECT table_name FROM create_hypertable('nulls_not_distinct', 'time'); table_name -------------------- nulls_not_distinct ALTER TABLE nulls_not_distinct SET (timescaledb.compress, timescaledb.compress_segmentby = 'device'); INSERT INTO nulls_not_distinct SELECT '2024-01-01'::timestamptz + format('%s',i)::interval, 'd1', 'l1', i FROM generate_series(1,6000) g(i); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', NULL, 'l1', 1); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', 'd2', NULL, 1); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.10', 'd2', 'l1', 1); SELECT count(compress_chunk(c)) FROM show_chunks('nulls_not_distinct') c; INFO: using tuplesort to scan rows from "_hyper_X_X_chunk" for converting to columnstore count ------- 1 -- shouldn't succeed because nulls are not distinct \set ON_ERROR_STOP 0 INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', NULL, 'l1', 1); INFO: Using index scan with scan keys: index 1, heap 4, memory 2. ERROR: duplicate key value violates unique constraint "_hyper_X_X_chunk_nulls_not_distinct_time_device_label_idx" INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', 'd2', NULL, 1); INFO: Using index scan with scan keys: index 1, heap 2, memory 2. ERROR: duplicate key value violates unique constraint "_hyper_X_X_chunk_nulls_not_distinct_time_device_label_idx" \set ON_ERROR_STOP 1 -- should insert without error, no conflict INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', 'd2', 'l1', 1); INFO: Using index scan with scan keys: index 1, heap 4, memory 2. INFO: Number of compressed rows fetched from index: 1. Number of compressed rows filtered by heap filters: 0. RESET timescaledb.debug_compression_path_info; DROP TABLE nulls_not_distinct; �������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_now-15.out�������������������������������������0000664�0000000�0000000�00000104722�15100345067�0024406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- create a test table -- any query with successful now_constify will have 1 chunk while -- others will have 2 chunks in plan CREATE TABLE const_now(time timestamptz, time2 timestamptz, device_id int, value float); SELECT table_name FROM create_hypertable('const_now','time'); table_name ------------ const_now INSERT INTO const_now SELECT '1000-01-01','1000-01-01',1,0.5; INSERT INTO const_now SELECT '1000-01-01','1000-01-01',2,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',1,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',2,0.5; -- test valid variants we are optimizing -- all of these should have a constified value as filter -- none of these initial tests will actually exclude chunks -- because we want to see the constified now expression in -- EXPLAIN output :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time >= now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time > now() - '24h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '2d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '3d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1week'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1month'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '24h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP - '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '2d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '3d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1week'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -- test bitmapheapscan SET enable_indexscan TO false; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: ("time" > ts_now_mock()) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > ts_now_mock()) RESET enable_indexscan; -- test multiple constraints :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND device_id = 2; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: (device_id = 2) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND (device_id = 2 OR device_id = 3); --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: ((device_id = 2) OR (device_id = 3)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: (("time" >= (ts_now_mock() + '@ 10 mins'::interval)) AND ("time" >= (ts_now_mock() - '@ 10 mins'::interval))) -- variants we don't optimize :PREFIX SELECT FROM const_now WHERE time > now()::date; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) :PREFIX SELECT FROM const_now WHERE round(EXTRACT(EPOCH FROM now())) > 0.5; --- QUERY PLAN --- Append -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -- we only modify top-level ANDed now() expressions :PREFIX SELECT FROM const_now WHERE time > now() - '1m'::interval OR time > now() + '1m'::interval; --- QUERY PLAN --- Append -> Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: (("time" > (ts_now_mock() - '@ 1 min'::interval)) OR ("time" > (ts_now_mock() + '@ 1 min'::interval))) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() - '@ 1 min'::interval)) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() + '@ 1 min'::interval)) -> Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: (("time" > (ts_now_mock() - '@ 1 min'::interval)) OR ("time" > (ts_now_mock() + '@ 1 min'::interval))) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() - '@ 1 min'::interval)) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() + '@ 1 min'::interval)) :PREFIX SELECT FROM const_now WHERE device_id = 2 OR (time > now() - '1m'::interval AND time > now() + '1m'::interval); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -- CTE :PREFIX WITH q1 AS ( SELECT * FROM const_now WHERE time > now() ) SELECT FROM q1; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX WITH q1 AS ( SELECT * FROM const_now ) SELECT FROM q1 WHERE time > now(); --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- JOIN :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 -> Seq Scan on _hyper_X_X_chunk m1_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now() AND m2.time > now(); --- QUERY PLAN --- Nested Loop -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- only top-level constraints in WHERE clause are constified :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()) WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- test UPDATE :PREFIX UPDATE const_now SET value = EXTRACT(EPOCH FROM now()) WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on const_now Update on _hyper_X_X_chunk const_now_1 -> Result -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test DELETE :PREFIX DELETE FROM const_now WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on const_now Delete on _hyper_X_X_chunk const_now_1 -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test chunks actually get excluded -- should exclude all SET timescaledb.current_timestamp_mock TO '2010-01-01'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should exclude all but 1 chunk SET timescaledb.current_timestamp_mock TO '2000-01-14'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should have one time filter false :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- no constification because it's not partitioning column :PREFIX SELECT FROM const_now WHERE time2 > now(); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) DROP TABLE const_now; -- test prepared statements CREATE TABLE prep_const_now(time timestamptz, device int, value float); SELECT table_name FROM create_hypertable('prep_const_now', 'time'); table_name ---------------- prep_const_now INSERT INTO prep_const_now SELECT '3000-01-02', 1, 0.2; INSERT INTO prep_const_now SELECT '3001-01-02', 2, 0.3; INSERT INTO prep_const_now SELECT '3002-01-02', 3, 0.4; SET timescaledb.current_timestamp_mock TO '3001-01-01'; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- -- same test with ChunkAppend enabled set timescaledb.enable_chunk_append = on; set timescaledb.enable_constraint_aware_append = on; DEALLOCATE p1; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); set timescaledb.current_timestamp_mock TO '3001-01-01'; :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 0 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 1 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; DROP TABLE prep_const_now; -- test outer var references dont trip up constify_now -- no optimization is done in this case :PREFIX SELECT * FROM metrics_tstz m1 INNER JOIN metrics_tstz as m2 on (true) WHERE EXISTS (SELECT * FROM metrics_tstz AS m3 WHERE m2.time > now()); --- QUERY PLAN --- Nested Loop -> Seq Scan on _hyper_X_X_chunk m1 -> Materialize -> Nested Loop Semi Join -> Index Scan using _hyper_X_X_chunk_metrics_tstz_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Seq Scan on _hyper_X_X_chunk m3 -- test dst interaction with day intervals SET timezone TO 'Europe/Berlin'; CREATE TABLE const_now_dst(time timestamptz not null); SELECT table_name FROM create_hypertable('const_now_dst','time',chunk_time_interval:='30minutes'::interval); table_name --------------- const_now_dst -- create 2 chunks INSERT INTO const_now_dst SELECT '2022-03-27 03:15:00+02'; INSERT INTO const_now_dst SELECT '2022-03-27 03:45:00+02'; SELECT * FROM const_now_dst WHERE time >= '2022-03-28 0:45+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:45:00 2022 CEST SELECT * FROM const_now_dst WHERE time >= '2022-03-28 1:15+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:15:00 2022 CEST Sun Mar 27 03:45:00 2022 CEST SET timescaledb.current_timestamp_mock TO '2022-03-28 0:45+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) SET timescaledb.current_timestamp_mock TO '2022-03-28 1:15+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) TRUNCATE const_now_dst; SELECT set_chunk_time_interval('const_now_dst','1 day'::interval, 'time'); set_chunk_time_interval ------------------------- -- test month calculation safety buffer SET timescaledb.current_timestamp_mock TO '2001-03-1 0:30:00+00'; INSERT INTO const_now_dst SELECT generate_series('2001-01-28'::timestamptz, '2001-02-01', '1day'::interval); set timezone to 'utc+1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) set timezone to 'utc-1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) DROP TABLE const_now_dst; -- test now constification with VIEWs SET timescaledb.current_timestamp_mock TO '2003-01-01 0:30:00+00'; CREATE TABLE now_view_test(time timestamptz,device text, value float); SELECT table_name FROM create_hypertable('now_view_test','time'); table_name --------------- now_view_test -- create 5 chunks INSERT INTO now_view_test SELECT generate_series('2000-01-01'::timestamptz,'2004-01-01'::timestamptz,'1year'::interval), 'a', 0.5; CREATE VIEW now_view AS SELECT time, device, avg(value) from now_view_test GROUP BY 1,2; -- should have all 5 chunks in EXPLAIN :PREFIX SELECT * FROM now_view; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -- should have 2 chunks in EXPLAIN :PREFIX SELECT * FROM now_view WHERE time > now() - '168h'::interval; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) DROP TABLE now_view_test CASCADE; NOTICE: drop cascades to view now_view -- #4709 -- test queries with constraints involving columns from different nesting levels SELECT * FROM (SELECT * FROM metrics m1 LIMIT 1) m1 INNER JOIN (SELECT * FROM metrics m2 LIMIT 1) m2 ON true, LATERAL (SELECT m2.time FROM devices LIMIT 1) as subq_1 WHERE subq_1.time > m1.time; time | device_id | v0 | v1 | v2 | v3 | time | device_id | v0 | v1 | v2 | v3 | time ------+-----------+----+----+----+----+------+-----------+----+----+----+----+------ CREATE TABLE logged_data ( rawtag_id INTEGER, timestamp TIMESTAMP WITH TIME ZONE NOT NULL, value REAL, site_id INTEGER ); SELECT table_name FROM create_hypertable('logged_data', 'timestamp'); table_name ------------- logged_data INSERT INTO logged_data (rawtag_id, timestamp, value, site_id) VALUES (1, '2023-01-01'::timestamptz, 13, 1), (1, '2023-01-07'::timestamptz, 13, 1), (1, '2023-01-10'::timestamptz, 13, 1), (1, '2023-01-15'::timestamptz, 13, 1), (1, '2023-01-20'::timestamptz, 15, 1), (2, '2023-01-01'::timestamptz, 90, 1), (3, '2023-01-07'::timestamptz, 2, 1), (4, '2023-01-10'::timestamptz, 13, 3), (2, '2023-01-15'::timestamptz, 13, 4), (5, '2023-01-20'::timestamptz, 13, 1); -- four chunks, all of them should be excluded at plantime SELECT row_number() OVER (), range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_schema = 'public' AND hypertable_name = 'logged_data' ORDER BY 2,3; row_number | range_start | range_end ------------+------------------------------+------------------------------ 1 | Thu Dec 29 01:00:00 2022 UTC | Thu Jan 05 01:00:00 2023 UTC 2 | Thu Jan 05 01:00:00 2023 UTC | Thu Jan 12 01:00:00 2023 UTC 3 | Thu Jan 12 01:00:00 2023 UTC | Thu Jan 19 01:00:00 2023 UTC 4 | Thu Jan 19 01:00:00 2023 UTC | Thu Jan 26 01:00:00 2023 UTC SET timescaledb.current_timestamp_mock TO '2024-01-01 0:30:00+00'; SET timescaledb.enable_chunk_append TO true; SET timescaledb.enable_constraint_aware_append TO true; -- for all the queries below, exclusion should be happening at plantime EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '1 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- mock_now() in the middle of the table SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 1 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 3 EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; -- repeat without ChunkAppend set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; DROP TABLE logged_data; ����������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_now-16.out�������������������������������������0000664�0000000�0000000�00000104722�15100345067�0024407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- create a test table -- any query with successful now_constify will have 1 chunk while -- others will have 2 chunks in plan CREATE TABLE const_now(time timestamptz, time2 timestamptz, device_id int, value float); SELECT table_name FROM create_hypertable('const_now','time'); table_name ------------ const_now INSERT INTO const_now SELECT '1000-01-01','1000-01-01',1,0.5; INSERT INTO const_now SELECT '1000-01-01','1000-01-01',2,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',1,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',2,0.5; -- test valid variants we are optimizing -- all of these should have a constified value as filter -- none of these initial tests will actually exclude chunks -- because we want to see the constified now expression in -- EXPLAIN output :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time >= now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time > now() - '24h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '2d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '3d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1week'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1month'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '24h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP - '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '2d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '3d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1week'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -- test bitmapheapscan SET enable_indexscan TO false; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: ("time" > ts_now_mock()) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > ts_now_mock()) RESET enable_indexscan; -- test multiple constraints :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND device_id = 2; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: (device_id = 2) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND (device_id = 2 OR device_id = 3); --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: ((device_id = 2) OR (device_id = 3)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: (("time" >= (ts_now_mock() + '@ 10 mins'::interval)) AND ("time" >= (ts_now_mock() - '@ 10 mins'::interval))) -- variants we don't optimize :PREFIX SELECT FROM const_now WHERE time > now()::date; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) :PREFIX SELECT FROM const_now WHERE round(EXTRACT(EPOCH FROM now())) > 0.5; --- QUERY PLAN --- Append -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -- we only modify top-level ANDed now() expressions :PREFIX SELECT FROM const_now WHERE time > now() - '1m'::interval OR time > now() + '1m'::interval; --- QUERY PLAN --- Append -> Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: (("time" > (ts_now_mock() - '@ 1 min'::interval)) OR ("time" > (ts_now_mock() + '@ 1 min'::interval))) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() - '@ 1 min'::interval)) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() + '@ 1 min'::interval)) -> Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: (("time" > (ts_now_mock() - '@ 1 min'::interval)) OR ("time" > (ts_now_mock() + '@ 1 min'::interval))) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() - '@ 1 min'::interval)) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() + '@ 1 min'::interval)) :PREFIX SELECT FROM const_now WHERE device_id = 2 OR (time > now() - '1m'::interval AND time > now() + '1m'::interval); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -- CTE :PREFIX WITH q1 AS ( SELECT * FROM const_now WHERE time > now() ) SELECT FROM q1; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX WITH q1 AS ( SELECT * FROM const_now ) SELECT FROM q1 WHERE time > now(); --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- JOIN :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 -> Seq Scan on _hyper_X_X_chunk m1_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now() AND m2.time > now(); --- QUERY PLAN --- Nested Loop -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- only top-level constraints in WHERE clause are constified :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()) WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- test UPDATE :PREFIX UPDATE const_now SET value = EXTRACT(EPOCH FROM now()) WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on const_now Update on _hyper_X_X_chunk const_now_1 -> Result -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test DELETE :PREFIX DELETE FROM const_now WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on const_now Delete on _hyper_X_X_chunk const_now_1 -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test chunks actually get excluded -- should exclude all SET timescaledb.current_timestamp_mock TO '2010-01-01'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should exclude all but 1 chunk SET timescaledb.current_timestamp_mock TO '2000-01-14'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should have one time filter false :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- no constification because it's not partitioning column :PREFIX SELECT FROM const_now WHERE time2 > now(); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) DROP TABLE const_now; -- test prepared statements CREATE TABLE prep_const_now(time timestamptz, device int, value float); SELECT table_name FROM create_hypertable('prep_const_now', 'time'); table_name ---------------- prep_const_now INSERT INTO prep_const_now SELECT '3000-01-02', 1, 0.2; INSERT INTO prep_const_now SELECT '3001-01-02', 2, 0.3; INSERT INTO prep_const_now SELECT '3002-01-02', 3, 0.4; SET timescaledb.current_timestamp_mock TO '3001-01-01'; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- -- same test with ChunkAppend enabled set timescaledb.enable_chunk_append = on; set timescaledb.enable_constraint_aware_append = on; DEALLOCATE p1; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); set timescaledb.current_timestamp_mock TO '3001-01-01'; :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 0 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 1 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; DROP TABLE prep_const_now; -- test outer var references dont trip up constify_now -- no optimization is done in this case :PREFIX SELECT * FROM metrics_tstz m1 INNER JOIN metrics_tstz as m2 on (true) WHERE EXISTS (SELECT * FROM metrics_tstz AS m3 WHERE m2.time > now()); --- QUERY PLAN --- Nested Loop -> Seq Scan on _hyper_X_X_chunk m1 -> Materialize -> Nested Loop Semi Join -> Index Scan using _hyper_X_X_chunk_metrics_tstz_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Seq Scan on _hyper_X_X_chunk m3 -- test dst interaction with day intervals SET timezone TO 'Europe/Berlin'; CREATE TABLE const_now_dst(time timestamptz not null); SELECT table_name FROM create_hypertable('const_now_dst','time',chunk_time_interval:='30minutes'::interval); table_name --------------- const_now_dst -- create 2 chunks INSERT INTO const_now_dst SELECT '2022-03-27 03:15:00+02'; INSERT INTO const_now_dst SELECT '2022-03-27 03:45:00+02'; SELECT * FROM const_now_dst WHERE time >= '2022-03-28 0:45+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:45:00 2022 CEST SELECT * FROM const_now_dst WHERE time >= '2022-03-28 1:15+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:15:00 2022 CEST Sun Mar 27 03:45:00 2022 CEST SET timescaledb.current_timestamp_mock TO '2022-03-28 0:45+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) SET timescaledb.current_timestamp_mock TO '2022-03-28 1:15+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) TRUNCATE const_now_dst; SELECT set_chunk_time_interval('const_now_dst','1 day'::interval, 'time'); set_chunk_time_interval ------------------------- -- test month calculation safety buffer SET timescaledb.current_timestamp_mock TO '2001-03-1 0:30:00+00'; INSERT INTO const_now_dst SELECT generate_series('2001-01-28'::timestamptz, '2001-02-01', '1day'::interval); set timezone to 'utc+1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) set timezone to 'utc-1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) DROP TABLE const_now_dst; -- test now constification with VIEWs SET timescaledb.current_timestamp_mock TO '2003-01-01 0:30:00+00'; CREATE TABLE now_view_test(time timestamptz,device text, value float); SELECT table_name FROM create_hypertable('now_view_test','time'); table_name --------------- now_view_test -- create 5 chunks INSERT INTO now_view_test SELECT generate_series('2000-01-01'::timestamptz,'2004-01-01'::timestamptz,'1year'::interval), 'a', 0.5; CREATE VIEW now_view AS SELECT time, device, avg(value) from now_view_test GROUP BY 1,2; -- should have all 5 chunks in EXPLAIN :PREFIX SELECT * FROM now_view; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -- should have 2 chunks in EXPLAIN :PREFIX SELECT * FROM now_view WHERE time > now() - '168h'::interval; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) DROP TABLE now_view_test CASCADE; NOTICE: drop cascades to view now_view -- #4709 -- test queries with constraints involving columns from different nesting levels SELECT * FROM (SELECT * FROM metrics m1 LIMIT 1) m1 INNER JOIN (SELECT * FROM metrics m2 LIMIT 1) m2 ON true, LATERAL (SELECT m2.time FROM devices LIMIT 1) as subq_1 WHERE subq_1.time > m1.time; time | device_id | v0 | v1 | v2 | v3 | time | device_id | v0 | v1 | v2 | v3 | time ------+-----------+----+----+----+----+------+-----------+----+----+----+----+------ CREATE TABLE logged_data ( rawtag_id INTEGER, timestamp TIMESTAMP WITH TIME ZONE NOT NULL, value REAL, site_id INTEGER ); SELECT table_name FROM create_hypertable('logged_data', 'timestamp'); table_name ------------- logged_data INSERT INTO logged_data (rawtag_id, timestamp, value, site_id) VALUES (1, '2023-01-01'::timestamptz, 13, 1), (1, '2023-01-07'::timestamptz, 13, 1), (1, '2023-01-10'::timestamptz, 13, 1), (1, '2023-01-15'::timestamptz, 13, 1), (1, '2023-01-20'::timestamptz, 15, 1), (2, '2023-01-01'::timestamptz, 90, 1), (3, '2023-01-07'::timestamptz, 2, 1), (4, '2023-01-10'::timestamptz, 13, 3), (2, '2023-01-15'::timestamptz, 13, 4), (5, '2023-01-20'::timestamptz, 13, 1); -- four chunks, all of them should be excluded at plantime SELECT row_number() OVER (), range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_schema = 'public' AND hypertable_name = 'logged_data' ORDER BY 2,3; row_number | range_start | range_end ------------+------------------------------+------------------------------ 1 | Thu Dec 29 01:00:00 2022 UTC | Thu Jan 05 01:00:00 2023 UTC 2 | Thu Jan 05 01:00:00 2023 UTC | Thu Jan 12 01:00:00 2023 UTC 3 | Thu Jan 12 01:00:00 2023 UTC | Thu Jan 19 01:00:00 2023 UTC 4 | Thu Jan 19 01:00:00 2023 UTC | Thu Jan 26 01:00:00 2023 UTC SET timescaledb.current_timestamp_mock TO '2024-01-01 0:30:00+00'; SET timescaledb.enable_chunk_append TO true; SET timescaledb.enable_constraint_aware_append TO true; -- for all the queries below, exclusion should be happening at plantime EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '1 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- mock_now() in the middle of the table SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 1 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 3 EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; -- repeat without ChunkAppend set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; DROP TABLE logged_data; ����������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_now-17.out�������������������������������������0000664�0000000�0000000�00000104722�15100345067�0024410�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- create a test table -- any query with successful now_constify will have 1 chunk while -- others will have 2 chunks in plan CREATE TABLE const_now(time timestamptz, time2 timestamptz, device_id int, value float); SELECT table_name FROM create_hypertable('const_now','time'); table_name ------------ const_now INSERT INTO const_now SELECT '1000-01-01','1000-01-01',1,0.5; INSERT INTO const_now SELECT '1000-01-01','1000-01-01',2,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',1,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',2,0.5; -- test valid variants we are optimizing -- all of these should have a constified value as filter -- none of these initial tests will actually exclude chunks -- because we want to see the constified now expression in -- EXPLAIN output :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time >= now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time > now() - '24h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '2d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '3d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1week'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1month'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '24h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP - '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '2d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '3d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1week'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -- test bitmapheapscan SET enable_indexscan TO false; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: ("time" > ts_now_mock()) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > ts_now_mock()) RESET enable_indexscan; -- test multiple constraints :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND device_id = 2; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: (device_id = 2) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND (device_id = 2 OR device_id = 3); --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: ((device_id = 2) OR (device_id = 3)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: (("time" >= (ts_now_mock() + '@ 10 mins'::interval)) AND ("time" >= (ts_now_mock() - '@ 10 mins'::interval))) -- variants we don't optimize :PREFIX SELECT FROM const_now WHERE time > now()::date; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) :PREFIX SELECT FROM const_now WHERE round(EXTRACT(EPOCH FROM now())) > 0.5; --- QUERY PLAN --- Append -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -- we only modify top-level ANDed now() expressions :PREFIX SELECT FROM const_now WHERE time > now() - '1m'::interval OR time > now() + '1m'::interval; --- QUERY PLAN --- Append -> Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: (("time" > (ts_now_mock() - '@ 1 min'::interval)) OR ("time" > (ts_now_mock() + '@ 1 min'::interval))) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() - '@ 1 min'::interval)) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() + '@ 1 min'::interval)) -> Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: (("time" > (ts_now_mock() - '@ 1 min'::interval)) OR ("time" > (ts_now_mock() + '@ 1 min'::interval))) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() - '@ 1 min'::interval)) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > (ts_now_mock() + '@ 1 min'::interval)) :PREFIX SELECT FROM const_now WHERE device_id = 2 OR (time > now() - '1m'::interval AND time > now() + '1m'::interval); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -- CTE :PREFIX WITH q1 AS ( SELECT * FROM const_now WHERE time > now() ) SELECT FROM q1; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX WITH q1 AS ( SELECT * FROM const_now ) SELECT FROM q1 WHERE time > now(); --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- JOIN :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 -> Seq Scan on _hyper_X_X_chunk m1_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now() AND m2.time > now(); --- QUERY PLAN --- Nested Loop -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- only top-level constraints in WHERE clause are constified :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()) WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- test UPDATE :PREFIX UPDATE const_now SET value = EXTRACT(EPOCH FROM now()) WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on const_now Update on _hyper_X_X_chunk const_now_1 -> Result -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test DELETE :PREFIX DELETE FROM const_now WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on const_now Delete on _hyper_X_X_chunk const_now_1 -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test chunks actually get excluded -- should exclude all SET timescaledb.current_timestamp_mock TO '2010-01-01'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should exclude all but 1 chunk SET timescaledb.current_timestamp_mock TO '2000-01-14'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should have one time filter false :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- no constification because it's not partitioning column :PREFIX SELECT FROM const_now WHERE time2 > now(); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) DROP TABLE const_now; -- test prepared statements CREATE TABLE prep_const_now(time timestamptz, device int, value float); SELECT table_name FROM create_hypertable('prep_const_now', 'time'); table_name ---------------- prep_const_now INSERT INTO prep_const_now SELECT '3000-01-02', 1, 0.2; INSERT INTO prep_const_now SELECT '3001-01-02', 2, 0.3; INSERT INTO prep_const_now SELECT '3002-01-02', 3, 0.4; SET timescaledb.current_timestamp_mock TO '3001-01-01'; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- -- same test with ChunkAppend enabled set timescaledb.enable_chunk_append = on; set timescaledb.enable_constraint_aware_append = on; DEALLOCATE p1; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); set timescaledb.current_timestamp_mock TO '3001-01-01'; :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 0 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 1 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; DROP TABLE prep_const_now; -- test outer var references dont trip up constify_now -- no optimization is done in this case :PREFIX SELECT * FROM metrics_tstz m1 INNER JOIN metrics_tstz as m2 on (true) WHERE EXISTS (SELECT * FROM metrics_tstz AS m3 WHERE m2.time > now()); --- QUERY PLAN --- Nested Loop -> Seq Scan on _hyper_X_X_chunk m1 -> Materialize -> Nested Loop Semi Join -> Index Scan using _hyper_X_X_chunk_metrics_tstz_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Seq Scan on _hyper_X_X_chunk m3 -- test dst interaction with day intervals SET timezone TO 'Europe/Berlin'; CREATE TABLE const_now_dst(time timestamptz not null); SELECT table_name FROM create_hypertable('const_now_dst','time',chunk_time_interval:='30minutes'::interval); table_name --------------- const_now_dst -- create 2 chunks INSERT INTO const_now_dst SELECT '2022-03-27 03:15:00+02'; INSERT INTO const_now_dst SELECT '2022-03-27 03:45:00+02'; SELECT * FROM const_now_dst WHERE time >= '2022-03-28 0:45+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:45:00 2022 CEST SELECT * FROM const_now_dst WHERE time >= '2022-03-28 1:15+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:15:00 2022 CEST Sun Mar 27 03:45:00 2022 CEST SET timescaledb.current_timestamp_mock TO '2022-03-28 0:45+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) SET timescaledb.current_timestamp_mock TO '2022-03-28 1:15+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) TRUNCATE const_now_dst; SELECT set_chunk_time_interval('const_now_dst','1 day'::interval, 'time'); set_chunk_time_interval ------------------------- -- test month calculation safety buffer SET timescaledb.current_timestamp_mock TO '2001-03-1 0:30:00+00'; INSERT INTO const_now_dst SELECT generate_series('2001-01-28'::timestamptz, '2001-02-01', '1day'::interval); set timezone to 'utc+1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) set timezone to 'utc-1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) DROP TABLE const_now_dst; -- test now constification with VIEWs SET timescaledb.current_timestamp_mock TO '2003-01-01 0:30:00+00'; CREATE TABLE now_view_test(time timestamptz,device text, value float); SELECT table_name FROM create_hypertable('now_view_test','time'); table_name --------------- now_view_test -- create 5 chunks INSERT INTO now_view_test SELECT generate_series('2000-01-01'::timestamptz,'2004-01-01'::timestamptz,'1year'::interval), 'a', 0.5; CREATE VIEW now_view AS SELECT time, device, avg(value) from now_view_test GROUP BY 1,2; -- should have all 5 chunks in EXPLAIN :PREFIX SELECT * FROM now_view; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -- should have 2 chunks in EXPLAIN :PREFIX SELECT * FROM now_view WHERE time > now() - '168h'::interval; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) DROP TABLE now_view_test CASCADE; NOTICE: drop cascades to view now_view -- #4709 -- test queries with constraints involving columns from different nesting levels SELECT * FROM (SELECT * FROM metrics m1 LIMIT 1) m1 INNER JOIN (SELECT * FROM metrics m2 LIMIT 1) m2 ON true, LATERAL (SELECT m2.time FROM devices LIMIT 1) as subq_1 WHERE subq_1.time > m1.time; time | device_id | v0 | v1 | v2 | v3 | time | device_id | v0 | v1 | v2 | v3 | time ------+-----------+----+----+----+----+------+-----------+----+----+----+----+------ CREATE TABLE logged_data ( rawtag_id INTEGER, timestamp TIMESTAMP WITH TIME ZONE NOT NULL, value REAL, site_id INTEGER ); SELECT table_name FROM create_hypertable('logged_data', 'timestamp'); table_name ------------- logged_data INSERT INTO logged_data (rawtag_id, timestamp, value, site_id) VALUES (1, '2023-01-01'::timestamptz, 13, 1), (1, '2023-01-07'::timestamptz, 13, 1), (1, '2023-01-10'::timestamptz, 13, 1), (1, '2023-01-15'::timestamptz, 13, 1), (1, '2023-01-20'::timestamptz, 15, 1), (2, '2023-01-01'::timestamptz, 90, 1), (3, '2023-01-07'::timestamptz, 2, 1), (4, '2023-01-10'::timestamptz, 13, 3), (2, '2023-01-15'::timestamptz, 13, 4), (5, '2023-01-20'::timestamptz, 13, 1); -- four chunks, all of them should be excluded at plantime SELECT row_number() OVER (), range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_schema = 'public' AND hypertable_name = 'logged_data' ORDER BY 2,3; row_number | range_start | range_end ------------+------------------------------+------------------------------ 1 | Thu Dec 29 01:00:00 2022 UTC | Thu Jan 05 01:00:00 2023 UTC 2 | Thu Jan 05 01:00:00 2023 UTC | Thu Jan 12 01:00:00 2023 UTC 3 | Thu Jan 12 01:00:00 2023 UTC | Thu Jan 19 01:00:00 2023 UTC 4 | Thu Jan 19 01:00:00 2023 UTC | Thu Jan 26 01:00:00 2023 UTC SET timescaledb.current_timestamp_mock TO '2024-01-01 0:30:00+00'; SET timescaledb.enable_chunk_append TO true; SET timescaledb.enable_constraint_aware_append TO true; -- for all the queries below, exclusion should be happening at plantime EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '1 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- mock_now() in the middle of the table SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 1 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 3 EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; -- repeat without ChunkAppend set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; DROP TABLE logged_data; ����������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_now-18.out�������������������������������������0000664�0000000�0000000�00000103570�15100345067�0024411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- create a test table -- any query with successful now_constify will have 1 chunk while -- others will have 2 chunks in plan CREATE TABLE const_now(time timestamptz, time2 timestamptz, device_id int, value float); SELECT table_name FROM create_hypertable('const_now','time'); table_name ------------ const_now INSERT INTO const_now SELECT '1000-01-01','1000-01-01',1,0.5; INSERT INTO const_now SELECT '1000-01-01','1000-01-01',2,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',1,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',2,0.5; -- test valid variants we are optimizing -- all of these should have a constified value as filter -- none of these initial tests will actually exclude chunks -- because we want to see the constified now expression in -- EXPLAIN output :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time >= now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= ts_now_mock()) :PREFIX SELECT FROM const_now WHERE time > now() - '24h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '2d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() + '3d'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1week'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > now() - '1month'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= CURRENT_TIMESTAMP) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '24h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 24 hours'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP - '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP - '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP + '10m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (CURRENT_TIMESTAMP + '@ 10 mins'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '2d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 2 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '3d'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP + '@ 3 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1week'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 7 days'::interval)) :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (CURRENT_TIMESTAMP - '@ 1 mon'::interval)) -- test bitmapheapscan SET enable_indexscan TO false; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Bitmap Heap Scan on _hyper_X_X_chunk Recheck Cond: ("time" > ts_now_mock()) -> Bitmap Index Scan on _hyper_X_X_chunk_const_now_time_idx Index Cond: ("time" > ts_now_mock()) RESET enable_indexscan; -- test multiple constraints :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND device_id = 2; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: (device_id = 2) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND (device_id = 2 OR device_id = 3); --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" >= (ts_now_mock() + '@ 10 mins'::interval)) Filter: ((device_id = 2) OR (device_id = 3)) :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND time >= now() - '10m'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: (("time" >= (ts_now_mock() + '@ 10 mins'::interval)) AND ("time" >= (ts_now_mock() - '@ 10 mins'::interval))) -- variants we don't optimize :PREFIX SELECT FROM const_now WHERE time > now()::date; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now())::date) :PREFIX SELECT FROM const_now WHERE round(EXTRACT(EPOCH FROM now())) > 0.5; --- QUERY PLAN --- Append -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -> Result One-Time Filter: (round(EXTRACT(epoch FROM now()), 0) > 0.5) -> Seq Scan on _hyper_X_X_chunk -- we only modify top-level ANDed now() expressions :PREFIX SELECT FROM const_now WHERE time > now() - '1m'::interval OR time > now() + '1m'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ANY (ARRAY[(ts_now_mock() - '@ 1 min'::interval), (ts_now_mock() + '@ 1 min'::interval)])) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ANY (ARRAY[(ts_now_mock() - '@ 1 min'::interval), (ts_now_mock() + '@ 1 min'::interval)])) :PREFIX SELECT FROM const_now WHERE device_id = 2 OR (time > now() - '1m'::interval AND time > now() + '1m'::interval); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -> Seq Scan on _hyper_X_X_chunk Filter: ((device_id = 2) OR (("time" > (ts_now_mock() - '@ 1 min'::interval)) AND ("time" > (ts_now_mock() + '@ 1 min'::interval)))) -- CTE :PREFIX WITH q1 AS ( SELECT * FROM const_now WHERE time > now() ) SELECT FROM q1; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) :PREFIX WITH q1 AS ( SELECT * FROM const_now ) SELECT FROM q1 WHERE time > now(); --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- JOIN :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 -> Seq Scan on _hyper_X_X_chunk m1_2 -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now() AND m2.time > now(); --- QUERY PLAN --- Nested Loop -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- only top-level constraints in WHERE clause are constified :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()); --- QUERY PLAN --- Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 -> Seq Scan on _hyper_X_X_chunk m2_2 -> Materialize -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()) WHERE m2.time > now(); --- QUERY PLAN --- Nested Loop -> Append -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_1 Index Cond: ("time" > now()) -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m1_2 Index Cond: ("time" > now()) -> Materialize -> Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -- test UPDATE :PREFIX UPDATE const_now SET value = EXTRACT(EPOCH FROM now()) WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on const_now Update on _hyper_X_X_chunk const_now_1 -> Result -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test DELETE :PREFIX DELETE FROM const_now WHERE time > now(); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on const_now Delete on _hyper_X_X_chunk const_now_1 -> Index Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk const_now_1 Index Cond: ("time" > ts_now_mock()) -- test chunks actually get excluded -- should exclude all SET timescaledb.current_timestamp_mock TO '2010-01-01'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should exclude all but 1 chunk SET timescaledb.current_timestamp_mock TO '2000-01-14'; :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- should have one time filter false :PREFIX SELECT FROM const_now WHERE time > now(); --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -- no constification because it's not partitioning column :PREFIX SELECT FROM const_now WHERE time2 > now(); --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) -> Seq Scan on _hyper_X_X_chunk Filter: (time2 > ts_now_mock()) DROP TABLE const_now; -- test prepared statements CREATE TABLE prep_const_now(time timestamptz, device int, value float); SELECT table_name FROM create_hypertable('prep_const_now', 'time'); table_name ---------------- prep_const_now INSERT INTO prep_const_now SELECT '3000-01-02', 1, 0.2; INSERT INTO prep_const_now SELECT '3001-01-02', 2, 0.3; INSERT INTO prep_const_now SELECT '3002-01-02', 3, 0.4; SET timescaledb.current_timestamp_mock TO '3001-01-01'; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- -- same test with ChunkAppend enabled set timescaledb.enable_chunk_append = on; set timescaledb.enable_constraint_aware_append = on; DEALLOCATE p1; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); set timescaledb.current_timestamp_mock TO '3001-01-01'; :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 0 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; --- QUERY PLAN --- Custom Scan (ChunkAppend) on prep_const_now Chunks excluded during startup: 1 -> Index Only Scan using _hyper_X_X_chunk_prep_const_now_time_idx on _hyper_X_X_chunk Index Cond: ("time" > ts_now_mock()) EXECUTE p1; -- set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; DROP TABLE prep_const_now; -- test outer var references dont trip up constify_now -- no optimization is done in this case :PREFIX SELECT * FROM metrics_tstz m1 INNER JOIN metrics_tstz as m2 on (true) WHERE EXISTS (SELECT * FROM metrics_tstz AS m3 WHERE m2.time > now()); --- QUERY PLAN --- Nested Loop -> Seq Scan on _hyper_X_X_chunk m1 -> Materialize -> Nested Loop Semi Join -> Index Scan using _hyper_X_X_chunk_metrics_tstz_time_idx on _hyper_X_X_chunk m2 Index Cond: ("time" > ts_now_mock()) -> Materialize -> Seq Scan on _hyper_X_X_chunk m3 -- test dst interaction with day intervals SET timezone TO 'Europe/Berlin'; CREATE TABLE const_now_dst(time timestamptz not null); SELECT table_name FROM create_hypertable('const_now_dst','time',chunk_time_interval:='30minutes'::interval); table_name --------------- const_now_dst -- create 2 chunks INSERT INTO const_now_dst SELECT '2022-03-27 03:15:00+02'; INSERT INTO const_now_dst SELECT '2022-03-27 03:45:00+02'; SELECT * FROM const_now_dst WHERE time >= '2022-03-28 0:45+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:45:00 2022 CEST SELECT * FROM const_now_dst WHERE time >= '2022-03-28 1:15+0'::timestamptz - '1d'::interval; time ------------------------------- Sun Mar 27 03:15:00 2022 CEST Sun Mar 27 03:45:00 2022 CEST SET timescaledb.current_timestamp_mock TO '2022-03-28 0:45+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) SET timescaledb.current_timestamp_mock TO '2022-03-28 1:15+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 day'::interval)) TRUNCATE const_now_dst; SELECT set_chunk_time_interval('const_now_dst','1 day'::interval, 'time'); set_chunk_time_interval ------------------------- -- test month calculation safety buffer SET timescaledb.current_timestamp_mock TO '2001-03-1 0:30:00+00'; INSERT INTO const_now_dst SELECT generate_series('2001-01-28'::timestamptz, '2001-02-01', '1day'::interval); set timezone to 'utc+1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) set timezone to 'utc-1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_const_now_dst_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 1 mon'::interval)) DROP TABLE const_now_dst; -- test now constification with VIEWs SET timescaledb.current_timestamp_mock TO '2003-01-01 0:30:00+00'; CREATE TABLE now_view_test(time timestamptz,device text, value float); SELECT table_name FROM create_hypertable('now_view_test','time'); table_name --------------- now_view_test -- create 5 chunks INSERT INTO now_view_test SELECT generate_series('2000-01-01'::timestamptz,'2004-01-01'::timestamptz,'1year'::interval), 'a', 0.5; CREATE VIEW now_view AS SELECT time, device, avg(value) from now_view_test GROUP BY 1,2; -- should have all 5 chunks in EXPLAIN :PREFIX SELECT * FROM now_view; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Seq Scan on _hyper_X_X_chunk -- should have 2 chunks in EXPLAIN :PREFIX SELECT * FROM now_view WHERE time > now() - '168h'::interval; --- QUERY PLAN --- Finalize HashAggregate Group Key: now_view_test."time", now_view_test.device -> Append -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) -> Partial HashAggregate Group Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device -> Index Scan Backward using _hyper_X_X_chunk_now_view_test_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (ts_now_mock() - '@ 168 hours'::interval)) DROP TABLE now_view_test CASCADE; NOTICE: drop cascades to view now_view -- #4709 -- test queries with constraints involving columns from different nesting levels SELECT * FROM (SELECT * FROM metrics m1 LIMIT 1) m1 INNER JOIN (SELECT * FROM metrics m2 LIMIT 1) m2 ON true, LATERAL (SELECT m2.time FROM devices LIMIT 1) as subq_1 WHERE subq_1.time > m1.time; time | device_id | v0 | v1 | v2 | v3 | time | device_id | v0 | v1 | v2 | v3 | time ------+-----------+----+----+----+----+------+-----------+----+----+----+----+------ CREATE TABLE logged_data ( rawtag_id INTEGER, timestamp TIMESTAMP WITH TIME ZONE NOT NULL, value REAL, site_id INTEGER ); SELECT table_name FROM create_hypertable('logged_data', 'timestamp'); table_name ------------- logged_data INSERT INTO logged_data (rawtag_id, timestamp, value, site_id) VALUES (1, '2023-01-01'::timestamptz, 13, 1), (1, '2023-01-07'::timestamptz, 13, 1), (1, '2023-01-10'::timestamptz, 13, 1), (1, '2023-01-15'::timestamptz, 13, 1), (1, '2023-01-20'::timestamptz, 15, 1), (2, '2023-01-01'::timestamptz, 90, 1), (3, '2023-01-07'::timestamptz, 2, 1), (4, '2023-01-10'::timestamptz, 13, 3), (2, '2023-01-15'::timestamptz, 13, 4), (5, '2023-01-20'::timestamptz, 13, 1); -- four chunks, all of them should be excluded at plantime SELECT row_number() OVER (), range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_schema = 'public' AND hypertable_name = 'logged_data' ORDER BY 2,3; row_number | range_start | range_end ------------+------------------------------+------------------------------ 1 | Thu Dec 29 01:00:00 2022 UTC | Thu Jan 05 01:00:00 2023 UTC 2 | Thu Jan 05 01:00:00 2023 UTC | Thu Jan 12 01:00:00 2023 UTC 3 | Thu Jan 12 01:00:00 2023 UTC | Thu Jan 19 01:00:00 2023 UTC 4 | Thu Jan 19 01:00:00 2023 UTC | Thu Jan 26 01:00:00 2023 UTC SET timescaledb.current_timestamp_mock TO '2024-01-01 0:30:00+00'; SET timescaledb.enable_chunk_append TO true; SET timescaledb.enable_constraint_aware_append TO true; -- for all the queries below, exclusion should be happening at plantime EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '1 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' AND rawtag_id = 1 ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' ORDER BY "timestamp" ASC; --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: "timestamp" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- mock_now() in the middle of the table SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 2 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 1 -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Custom Scan (ChunkAppend) on logged_data Order: logged_data."timestamp" Chunks excluded during startup: 3 EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; -- repeat without ChunkAppend set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Sat Jan 07 00:00:00 2023 UTC | 13 | 1 1 | Tue Jan 10 00:00:00 2023 UTC | 13 | 1 -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+------------------------------+-------+--------- 1 | Fri Jan 20 00:00:00 2023 UTC | 15 | 1 -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; --- QUERY PLAN --- Merge Append Sort Key: logged_data."timestamp" -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_logged_data_timestamp_idx on _hyper_X_X_chunk Index Cond: (("timestamp" >= (ts_now_mock() - '@ 5 days'::interval)) AND ("timestamp" <= ts_now_mock())) Filter: (rawtag_id = 1) EXECUTE pbtw; rawtag_id | timestamp | value | site_id -----------+-----------+-------+--------- DEALLOCATE pbtw; DROP TABLE logged_data; ����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_timestamptz_op_interval-15.out�����������������0000664�0000000�0000000�00000027564�15100345067�0030576�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off)' -- we disable ChunkAppend and ConstraintAwareAppend here to make the exclusion easier to spot -- otherwise those would remove the chunks from the plan during execution SET timescaledb.enable_chunk_append TO FALSE; SET timescaledb.enable_constraint_aware_append TO FALSE; SET timescaledb.enable_now_constify TO FALSE; -- plan query on complete hypertable to get a list of the chunks :PREFIX SELECT time FROM metrics; --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- all of these should have all chunk exclusion happening at plan time :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '6h'::interval + '2000-01-01'::timestamptz; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-07'::timestamptz - '7 day 8 seconds'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days 8 secs'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-03-01'::timestamptz - '60 day'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test Var on right side of expression :PREFIX SELECT time FROM metrics WHERE '2000-01-01'::timestamptz - '6h'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-01-07'::timestamptz - '7 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-03-01'::timestamptz - '60 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test multiple constraints :PREFIX SELECT time FROM metrics WHERE time > '2000-01-10'::timestamptz - '6h'::interval AND time < '2000-01-10'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: (("time" > ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) AND ("time" < ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval))) -- test on space-partitioned hypertable :PREFIX SELECT time FROM metrics_space WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) Filter: (device_id = 1) -- test on compressed hypertable :PREFIX SELECT time FROM metrics_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -- test on space-partitioned compressed hypertable :PREFIX SELECT time FROM metrics_space_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval))) -- month/year intervals are not constified :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month - 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month + 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-02-01'::timestamptz - '1 year'::interval > time; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -- nested expressions are not constified :PREFIX SELECT time FROM metrics WHERE time < '1 day' + '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -- non-Const expressions are not constified :PREFIX SELECT time FROM metrics WHERE time > now() - '6h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -- test NULL values :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false :PREFIX SELECT time FROM metrics WHERE time < NULL::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false -- test timezone changes in prepared statements CREATE TABLE dst_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('dst_test','time',chunk_time_interval:=interval '30 minutes'); table_name ------------ dst_test INSERT INTO dst_test SELECT generate_series('2022-03-27 22:00:00+01'::timestamptz,'2022-03-28 02:00:00+01'::timestamptz,'30min'::interval); SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 8 DEALLOCATE p1; -- do same tests with var on wrong side SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; count ------- 8 DEALLOCATE p1; DROP TABLE dst_test; ��������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_timestamptz_op_interval-16.out�����������������0000664�0000000�0000000�00000027564�15100345067�0030577�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off)' -- we disable ChunkAppend and ConstraintAwareAppend here to make the exclusion easier to spot -- otherwise those would remove the chunks from the plan during execution SET timescaledb.enable_chunk_append TO FALSE; SET timescaledb.enable_constraint_aware_append TO FALSE; SET timescaledb.enable_now_constify TO FALSE; -- plan query on complete hypertable to get a list of the chunks :PREFIX SELECT time FROM metrics; --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- all of these should have all chunk exclusion happening at plan time :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '6h'::interval + '2000-01-01'::timestamptz; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-07'::timestamptz - '7 day 8 seconds'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days 8 secs'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-03-01'::timestamptz - '60 day'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test Var on right side of expression :PREFIX SELECT time FROM metrics WHERE '2000-01-01'::timestamptz - '6h'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-01-07'::timestamptz - '7 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-03-01'::timestamptz - '60 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test multiple constraints :PREFIX SELECT time FROM metrics WHERE time > '2000-01-10'::timestamptz - '6h'::interval AND time < '2000-01-10'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: (("time" > ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) AND ("time" < ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval))) -- test on space-partitioned hypertable :PREFIX SELECT time FROM metrics_space WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) Filter: (device_id = 1) -- test on compressed hypertable :PREFIX SELECT time FROM metrics_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -- test on space-partitioned compressed hypertable :PREFIX SELECT time FROM metrics_space_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval))) -- month/year intervals are not constified :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month - 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month + 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-02-01'::timestamptz - '1 year'::interval > time; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -- nested expressions are not constified :PREFIX SELECT time FROM metrics WHERE time < '1 day' + '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -- non-Const expressions are not constified :PREFIX SELECT time FROM metrics WHERE time > now() - '6h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -- test NULL values :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false :PREFIX SELECT time FROM metrics WHERE time < NULL::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false -- test timezone changes in prepared statements CREATE TABLE dst_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('dst_test','time',chunk_time_interval:=interval '30 minutes'); table_name ------------ dst_test INSERT INTO dst_test SELECT generate_series('2022-03-27 22:00:00+01'::timestamptz,'2022-03-28 02:00:00+01'::timestamptz,'30min'::interval); SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 8 DEALLOCATE p1; -- do same tests with var on wrong side SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; count ------- 8 DEALLOCATE p1; DROP TABLE dst_test; ��������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_timestamptz_op_interval-17.out�����������������0000664�0000000�0000000�00000027564�15100345067�0030600�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off)' -- we disable ChunkAppend and ConstraintAwareAppend here to make the exclusion easier to spot -- otherwise those would remove the chunks from the plan during execution SET timescaledb.enable_chunk_append TO FALSE; SET timescaledb.enable_constraint_aware_append TO FALSE; SET timescaledb.enable_now_constify TO FALSE; -- plan query on complete hypertable to get a list of the chunks :PREFIX SELECT time FROM metrics; --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- all of these should have all chunk exclusion happening at plan time :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '6h'::interval + '2000-01-01'::timestamptz; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-07'::timestamptz - '7 day 8 seconds'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days 8 secs'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-03-01'::timestamptz - '60 day'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test Var on right side of expression :PREFIX SELECT time FROM metrics WHERE '2000-01-01'::timestamptz - '6h'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-01-07'::timestamptz - '7 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-03-01'::timestamptz - '60 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test multiple constraints :PREFIX SELECT time FROM metrics WHERE time > '2000-01-10'::timestamptz - '6h'::interval AND time < '2000-01-10'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: (("time" > ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) AND ("time" < ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval))) -- test on space-partitioned hypertable :PREFIX SELECT time FROM metrics_space WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) Filter: (device_id = 1) -- test on compressed hypertable :PREFIX SELECT time FROM metrics_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -- test on space-partitioned compressed hypertable :PREFIX SELECT time FROM metrics_space_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval))) -- month/year intervals are not constified :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month - 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month + 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-02-01'::timestamptz - '1 year'::interval > time; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -- nested expressions are not constified :PREFIX SELECT time FROM metrics WHERE time < '1 day' + '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -- non-Const expressions are not constified :PREFIX SELECT time FROM metrics WHERE time > now() - '6h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -- test NULL values :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false :PREFIX SELECT time FROM metrics WHERE time < NULL::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false -- test timezone changes in prepared statements CREATE TABLE dst_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('dst_test','time',chunk_time_interval:=interval '30 minutes'); table_name ------------ dst_test INSERT INTO dst_test SELECT generate_series('2022-03-27 22:00:00+01'::timestamptz,'2022-03-28 02:00:00+01'::timestamptz,'30min'::interval); SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 8 DEALLOCATE p1; -- do same tests with var on wrong side SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; count ------- 8 DEALLOCATE p1; DROP TABLE dst_test; ��������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constify_timestamptz_op_interval-18.out�����������������0000664�0000000�0000000�00000027730�15100345067�0030574�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off)' -- we disable ChunkAppend and ConstraintAwareAppend here to make the exclusion easier to spot -- otherwise those would remove the chunks from the plan during execution SET timescaledb.enable_chunk_append TO FALSE; SET timescaledb.enable_constraint_aware_append TO FALSE; SET timescaledb.enable_now_constify TO FALSE; -- plan query on complete hypertable to get a list of the chunks :PREFIX SELECT time FROM metrics; --- QUERY PLAN --- Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- all of these should have all chunk exclusion happening at plan time :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '6h'::interval + '2000-01-01'::timestamptz; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-01-07'::timestamptz - '7 day 8 seconds'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days 8 secs'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-03-01'::timestamptz - '60 day'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test Var on right side of expression :PREFIX SELECT time FROM metrics WHERE '2000-01-01'::timestamptz - '6h'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-01-07'::timestamptz - '7 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Fri Jan 07 00:00:00 2000 PST'::timestamp with time zone - '@ 7 days'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-03-01'::timestamptz - '60 day'::interval > time; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Wed Mar 01 00:00:00 2000 PST'::timestamp with time zone - '@ 60 days'::interval)) -- test multiple constraints :PREFIX SELECT time FROM metrics WHERE time > '2000-01-10'::timestamptz - '6h'::interval AND time < '2000-01-10'::timestamptz + '6h'::interval; --- QUERY PLAN --- Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: (("time" > ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) AND ("time" < ('Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone + '@ 6 hours'::interval))) -- test on space-partitioned hypertable :PREFIX SELECT time FROM metrics_space WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) Filter: (device_id = 1) -- test on compressed hypertable :PREFIX SELECT time FROM metrics_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -- test on space-partitioned compressed hypertable :PREFIX SELECT time FROM metrics_space_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; --- QUERY PLAN --- Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval)) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone - '@ 6 hours'::interval))) -- month/year intervals are not constified :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month - 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon -1 days'::interval)) :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month + 1 day'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 mon 1 day'::interval)) :PREFIX SELECT time FROM metrics WHERE '2000-02-01'::timestamptz - '1 year'::interval > time; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < ('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone - '@ 1 year'::interval)) -- nested expressions are not constified :PREFIX SELECT time FROM metrics WHERE time < '1 day' + '2000-02-01'::timestamptz - '1 month'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" < (('Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone + '@ 1 day'::interval) - '@ 1 mon'::interval)) -- non-Const expressions are not constified :PREFIX SELECT time FROM metrics WHERE time > now() - '6h'::interval; --- QUERY PLAN --- Append -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk Index Cond: ("time" > (now() - '@ 6 hours'::interval)) -- test NULL values :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false :PREFIX SELECT time FROM metrics WHERE time < NULL::timestamptz - NULL::interval; --- QUERY PLAN --- Result One-Time Filter: false -- test timezone changes in prepared statements CREATE TABLE dst_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('dst_test','time',chunk_time_interval:=interval '30 minutes'); table_name ------------ dst_test INSERT INTO dst_test SELECT generate_series('2022-03-27 22:00:00+01'::timestamptz,'2022-03-28 02:00:00+01'::timestamptz,'30min'::interval); SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; count ------- 8 DEALLOCATE p1; -- do same tests with var on wrong side SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; EXECUTE p1; count ------- 2 set timezone TO 'Europe/Berlin'; EXECUTE p1; count ------- 4 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; count ------- 4 DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; EXECUTE p1; count ------- 6 set timezone TO 'Africa/Casablanca'; EXECUTE p1; count ------- 8 SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; count ------- 8 DEALLOCATE p1; DROP TABLE dst_test; ����������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constraint_aware_append.out�����������������������������0000664�0000000�0000000�00000002051�15100345067�0026324�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test handling of ConstraintAwareAppend -> Sort -> Result -> Scan -- issue 5739 CREATE TABLE ca_append_result(time timestamptz NULL, device text, value float); SELECT table_name FROM create_hypertable('ca_append_result', 'time'); table_name ------------------ ca_append_result ALTER TABLE ca_append_result SET (timescaledb.compress); INSERT INTO ca_append_result SELECT '2000-01-03','d1',0.3; SELECT count(compress_chunk(ch)) AS compressed FROM show_chunks('ca_append_result') ch; compressed ------------ 1 INSERT INTO ca_append_result SELECT '2000-01-13','d1',0.6; SET enable_seqscan TO FALSE; SELECT time_bucket('20d',time) AS day from ca_append_result WHERE time > '1900-01-01'::text::timestamp GROUP BY day; day ------------------------------ Sun Jan 02 16:00:00 2000 PST RESET enable_seqscan; DROP TABLE ca_append_result; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constraint_exclusion_prepared-15.out��������������������0000664�0000000�0000000�00000731017�15100345067�0030027�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' SET work_mem TO '64MB'; -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge TO 'off'; SET max_parallel_workers_per_gather TO '0'; -- disable incremental sort to avoid flaky results SET enable_incremental_sort TO 'off'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during startup: 3 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 9 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=4.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 3996 -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 14 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 4995 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 25 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 9 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 DEALLOCATE prep; RESET plan_cache_mode; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constraint_exclusion_prepared-16.out��������������������0000664�0000000�0000000�00000731017�15100345067�0030030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' SET work_mem TO '64MB'; -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge TO 'off'; SET max_parallel_workers_per_gather TO '0'; -- disable incremental sort to avoid flaky results SET enable_incremental_sort TO 'off'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during startup: 3 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 9 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=4.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 3996 -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 14 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 4995 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 25 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 9 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 DEALLOCATE prep; RESET plan_cache_mode; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constraint_exclusion_prepared-17.out��������������������0000664�0000000�0000000�00000731017�15100345067�0030031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' SET work_mem TO '64MB'; -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge TO 'off'; SET max_parallel_workers_per_gather TO '0'; -- disable incremental sort to avoid flaky results SET enable_incremental_sort TO 'off'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during startup: 3 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 9 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=4.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 3996 -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 14 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 4995 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 25 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 9 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 DEALLOCATE prep; RESET plan_cache_mode; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/constraint_exclusion_prepared-18.out��������������������0000664�0000000�0000000�00000731132�15100345067�0030030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' SET work_mem TO '64MB'; -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge TO 'off'; SET max_parallel_workers_per_gather TO '0'; -- disable incremental sort to avoid flaky results SET enable_incremental_sort TO 'off'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 0 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=100.00 loops=1) Order: metrics."time" Chunks excluded during startup: 1 -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Sort (actual rows=100.00 loops=1) Sort Key: metrics.device_id, metrics."time" Sort Method: top-N heapsort -> Custom Scan (ConstraintAwareAppend) (actual rows=33590.00 loops=1) Hypertable: metrics Chunks excluded during startup: 1 -> Append (actual rows=33590.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=17990.00 loops=1) Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=15600.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=5.00 loops=1) Chunks excluded during startup: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics (actual rows=0.00 loops=1) Chunks excluded during startup: 3 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 0 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < now()) Filter: (device_id = 1) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" Chunks excluded during startup: 1 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) Filter: (device_id = 1) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=100.00 loops=1) Order: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 (never executed) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=100.00 loops=1) Order: metrics_space."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=60.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space.device_id, metrics_space."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Sort (actual rows=5.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=5.00 loops=1) Chunks excluded during startup: 6 -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=3.00 loops=1) Index Cond: ("time" = $1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Sort (actual rows=0.00 loops=1) Sort Key: metrics_space.device_id Sort Method: quicksort -> Custom Scan (ChunkAppend) on metrics_space (actual rows=0.00 loops=1) Chunks excluded during startup: 9 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 0 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < now()) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=100.00 loops=1) Order: metrics_compressed."time" Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed."time" -> Sort (actual rows=80.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=21.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_compressed Chunks excluded during startup: 1 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_compressed.device_id, metrics_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=100.00 loops=1) Index Cond: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=25.00 loops=1) Filter: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) Rows Removed by Filter: 5 DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=4.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 3996 -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 14 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 4995 -> Sort (actual rows=5.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 25 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: ("time" = $1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 30 DEALLOCATE prep; RESET plan_cache_mode; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 0 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < now()) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < now())) DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" Chunks excluded during startup: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone)) DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop Left Join (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=100.00 loops=1) Order: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Limit (actual rows=1.00 loops=100) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=100) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=100) Filter: (m1."time" = "time") Rows Removed by Filter: 548 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=100) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=100.00 loops=1) Order: metrics_space_compressed."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed."time" -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=60.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=21.00 loops=1) Sort Key: _hyper_X_X_chunk."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) :PREFIX EXECUTE prep; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Custom Scan (ConstraintAwareAppend) (actual rows=100.00 loops=1) Hypertable: metrics_space_compressed Chunks excluded during startup: 3 -> Merge Append (actual rows=100.00 loops=1) Sort Key: metrics_space_compressed.device_id, metrics_space_compressed."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=100.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=15.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" < ('2000-01-10'::cstring)::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=1) Index Cond: (_ts_meta_min_1 < ('2000-01-10'::cstring)::timestamp with time zone) DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 9 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 3 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep('2000-01-10 23:42'); --- QUERY PLAN --- Merge Append (actual rows=5.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 2997 -> Sort (actual rows=3.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=3.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 15 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Vectorized Filter: ("time" = $1) Rows Removed by Filter: 999 -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 5 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 :PREFIX EXECUTE prep(now()); --- QUERY PLAN --- Merge Append (actual rows=0.00 loops=1) Sort Key: metrics_space_compressed.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 12 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 4 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 18 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Vectorized Filter: ("time" = $1) -> Sort (actual rows=0.00 loops=1) Sort Key: compress_hyper_X_X_chunk.device_id Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: ((_ts_meta_min_1 <= $1) AND (_ts_meta_max_1 >= $1)) Rows Removed by Filter: 6 DEALLOCATE prep; RESET plan_cache_mode; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/decompress_join.out�������������������������������������0000664�0000000�0000000�00000006362�15100345067�0024626�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET enable_memoize TO false; SET enable_indexscan TO false; SET max_parallel_workers_per_gather = 0; -- test join on compressed time column -- #3079, #4465 CREATE TABLE compressed_join_temp AS SELECT * FROM metrics ORDER BY time DESC LIMIT 10; ANALYZE compressed_join_temp; EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * FROM compressed_join_temp t INNER JOIN metrics_compressed m ON t.time = m.time AND t.device_id = m.device_id LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Hash Join (actual rows=1.00 loops=1) Hash Cond: ((m."time" = t."time") AND (m.device_id = t.device_id)) -> Append (actual rows=43181.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m_1 (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk m_1 (actual rows=1598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m_2 (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m_3 (actual rows=1.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) -> Hash (actual rows=10.00 loops=1) -> Seq Scan on compressed_join_temp t (actual rows=10.00 loops=1) DROP TABLE compressed_join_temp; -- test join with partially compressed chunks CREATE TABLE partial_join(time timestamptz,device text); SELECT table_name FROM create_hypertable('partial_join','time'); table_name -------------- partial_join ALTER TABLE partial_join set(timescaledb.compress,timescaledb.compress_segmentby='device'); INSERT INTO partial_join SELECT '2000-01-01','d1'; SELECT count(*) FROM (SELECT compress_chunk(show_chunks('partial_join'),true)) compress; count ------- 1 -- make chunk partially compressed INSERT INTO partial_join SELECT '2000-01-01','d1'; SELECT * FROM partial_join m1 INNER JOIN partial_join m2 ON m1.device = m2.device; time | device | time | device ------------------------------+--------+------------------------------+-------- Sat Jan 01 00:00:00 2000 PST | d1 | Sat Jan 01 00:00:00 2000 PST | d1 Sat Jan 01 00:00:00 2000 PST | d1 | Sat Jan 01 00:00:00 2000 PST | d1 Sat Jan 01 00:00:00 2000 PST | d1 | Sat Jan 01 00:00:00 2000 PST | d1 Sat Jan 01 00:00:00 2000 PST | d1 | Sat Jan 01 00:00:00 2000 PST | d1 DROP TABLE partial_join; -- This resulted in a recursion in the join planner code on PG16 SELECT * FROM metrics_tstz as m INNER JOIN metrics_space as ms on (true) INNER JOIN metrics_space_compressed as msc on (true) WHERE CASE WHEN m.device_id is not NULL and ms.v2 is not NULL THEN NULL::int2 end = msc.device_id; time | device_id | v1 | v2 | time | device_id | v0 | v1 | v2 | v3 | time | device_id | v0 | v1 | v2 | v3 ------+-----------+----+----+------+-----------+----+----+----+----+------+-----------+----+----+----+---- ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/decompress_placeholdervar.out���������������������������0000664�0000000�0000000�00000017727�15100345067�0026671�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test handling of PlaceHolderVar in DecompressChunk -- https://github.com/timescale/timescaledb/issues/1981 CREATE TABLE decompress_phv_device ( device_id integer NOT NULL, decompress_phv_device_name varchar(128) NOT NULL, network_id integer ); CREATE TABLE decompress_phv_ping ( id integer NOT NULL, device_id integer NOT NULL, pkt_rx integer NOT NULL, rtt_avg float, insert_ts timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL ); SELECT table_name FROM create_hypertable('decompress_phv_ping', 'insert_ts', chunk_time_interval => interval '1 day'); WARNING: column type "timestamp without time zone" used for "insert_ts" does not follow best practices table_name --------------------- decompress_phv_ping INSERT INTO decompress_phv_device VALUES (41040, 'MB10010013', 240), (65101, 'BR100103ca', 240), (65103, 'BR100103cb', 240), (65105, 'BR100103cc', 240), (65107, 'BR100103cd', 240), (41041, 'MB11000000', 241), (65201, 'BR11000014', 241), (65203, 'BR11000015', 241), (65205, 'BR11000016', 241), (65207, 'BR11000017', 241); INSERT INTO decompress_phv_ping VALUES (1, 41040, 3, 243.333333333333, '2019-03-21 02:30:48.007'), (1, 41040, 3, 300.333333333333, '2019-03-21 02:00:19.957'), (1, 41040, 3, 265.333333333333, '2019-03-21 01:28:50.669'), (1, 41040, 3, 174, '2019-03-21 00:57:09.733'), (1, 41040, 3, 552.666666666667, '2019-03-21 00:21:02.305'), (1, 41041, 3, 330.333333333333, '2019-03-21 02:30:44.984'), (1, 41041, 3, 753, '2019-03-21 02:00:38.062'), (1, 41041, 3, 260, '2019-03-21 01:30:10.21'), (1, 41041, 3, 357.333333333333, '2019-03-21 00:59:10.768'), (1, 41041, 3, 474.666666666667, '2019-03-21 00:20:54.272'), (1, 65101, 3, 17.5200004577637, '2019-03-21 02:36:50.606'), (1, 65101, 3, 17.5200004577637, '2019-03-21 02:06:43.631'), (1, 65101, 3, 31.8933359781901, '2019-03-21 01:34:56.56'), (1, 65101, 3, 17.5200004577637, '2019-03-21 01:03:10.913'), (1, 65101, 3, 17.5200004577637, '2019-03-21 00:33:53.707'), (1, 65201, 3, 17.5200004577637, '2019-03-21 02:31:58.444'), (1, 65201, 3, 17.5200004577637, '2019-03-21 02:01:53.565'), (1, 65201, 3, 17.5200004577637, '2019-03-21 01:30:16.261'), (1, 65201, 2, 17.5200004577637, '2019-03-21 00:59:34.953'), (1, 65201, 3, 17.5200004577637, '2019-03-21 00:27:19.228'), (1, 41040, 3, 31.6666666666667, '2019-03-22 03:29:45.404'), (1, 41040, 3, 128, '2019-03-22 03:01:36.323'), (1, 41040, 3, 50, '2019-03-22 02:31:20.107'), (1, 41040, 3, 149.666666666667, '2019-03-22 02:01:07.201'), (1, 41040, 3, 502, '2019-03-22 01:28:27.129'), (1, 41041, 3, 355, '2019-03-22 03:30:50.844'), (1, 41041, 3, 53, '2019-03-22 03:01:40.348'), (1, 41041, 3, 121.333333333333, '2019-03-22 02:32:04.392'), (1, 41041, 3, 325.333333333333, '2019-03-22 02:02:06.968'), (1, 41041, 3, 576.666666666667, '2019-03-22 01:30:04.821'), (1, 65101, 3, 17.5200004577637, '2019-03-22 03:08:33.227'), (1, 65101, 3, 17.5200004577637, '2019-03-22 02:37:29.96'), (1, 65101, 3, 17.5200004577637, '2019-03-22 02:07:14.805'), (1, 65101, 3, 17.5200004577637, '2019-03-22 01:34:25.055'), (1, 65101, 3, 17.5200004577637, '2019-03-22 01:03:40.405'), (1, 65201, 3, 17.5200004577637, '2019-03-22 03:30:56.885'), (1, 65201, 3, 17.5200004577637, '2019-03-22 03:03:40.243'), (1, 65201, 3, 17.5200004577637, '2019-03-22 02:32:38.625'), (1, 65201, 3, 17.5200004577637, '2019-03-22 02:02:20.05'), (1, 65201, 3, 17.5200004577637, '2019-03-22 01:30:09.863'); ALTER TABLE decompress_phv_ping SET (timescaledb.compress, timescaledb.compress_orderby = 'device_id, insert_ts DESC'); SELECT count(*) AS compressed FROM ( select compress_chunk(i) FROM show_chunks('decompress_phv_ping') i ) q; compressed ------------ 2 SELECT from_ts, insert_ts, network_id, pkt_loss, rtt_avg FROM generate_series('2019-03-21 01:00:00'::timestamp, '2019-03-23 13:00:00'::timestamp, '12h'::interval) ts_bucket (from_ts) LEFT JOIN ( SELECT d.network_id, CASE WHEN p.pkt_rx = 0 THEN 1 ELSE 0 END AS pkt_loss, p.rtt_avg, p.insert_ts FROM decompress_phv_device d INNER JOIN decompress_phv_ping p ON p.device_id = d.device_id WHERE d.network_id = 240) data ON data.insert_ts BETWEEN from_ts AND from_ts + '12h'::interval ORDER BY 1,2; from_ts | insert_ts | network_id | pkt_loss | rtt_avg --------------------------+------------------------------+------------+----------+------------------ Thu Mar 21 01:00:00 2019 | Thu Mar 21 01:03:10.913 2019 | 240 | 0 | 17.5200004577637 Thu Mar 21 01:00:00 2019 | Thu Mar 21 01:28:50.669 2019 | 240 | 0 | 265.333333333333 Thu Mar 21 01:00:00 2019 | Thu Mar 21 01:34:56.56 2019 | 240 | 0 | 31.8933359781901 Thu Mar 21 01:00:00 2019 | Thu Mar 21 02:00:19.957 2019 | 240 | 0 | 300.333333333333 Thu Mar 21 01:00:00 2019 | Thu Mar 21 02:06:43.631 2019 | 240 | 0 | 17.5200004577637 Thu Mar 21 01:00:00 2019 | Thu Mar 21 02:30:48.007 2019 | 240 | 0 | 243.333333333333 Thu Mar 21 01:00:00 2019 | Thu Mar 21 02:36:50.606 2019 | 240 | 0 | 17.5200004577637 Thu Mar 21 13:00:00 2019 | | | | Fri Mar 22 01:00:00 2019 | Fri Mar 22 01:03:40.405 2019 | 240 | 0 | 17.5200004577637 Fri Mar 22 01:00:00 2019 | Fri Mar 22 01:28:27.129 2019 | 240 | 0 | 502 Fri Mar 22 01:00:00 2019 | Fri Mar 22 01:34:25.055 2019 | 240 | 0 | 17.5200004577637 Fri Mar 22 01:00:00 2019 | Fri Mar 22 02:01:07.201 2019 | 240 | 0 | 149.666666666667 Fri Mar 22 01:00:00 2019 | Fri Mar 22 02:07:14.805 2019 | 240 | 0 | 17.5200004577637 Fri Mar 22 01:00:00 2019 | Fri Mar 22 02:31:20.107 2019 | 240 | 0 | 50 Fri Mar 22 01:00:00 2019 | Fri Mar 22 02:37:29.96 2019 | 240 | 0 | 17.5200004577637 Fri Mar 22 01:00:00 2019 | Fri Mar 22 03:01:36.323 2019 | 240 | 0 | 128 Fri Mar 22 01:00:00 2019 | Fri Mar 22 03:08:33.227 2019 | 240 | 0 | 17.5200004577637 Fri Mar 22 01:00:00 2019 | Fri Mar 22 03:29:45.404 2019 | 240 | 0 | 31.6666666666667 Fri Mar 22 13:00:00 2019 | | | | Sat Mar 23 01:00:00 2019 | | | | Sat Mar 23 13:00:00 2019 | | | | DROP TABLE decompress_phv_ping; DROP TABLE decompress_phv_device; -- test assertion failure in bitmapheapscan path creation -- GH Issue #2211 CREATE TABLE tickers ( time TIMESTAMPTZ, microseconds INT, fk_exchange SMALLINT, fk_trade_pair SMALLINT ); CREATE INDEX ON tickers (fk_exchange, fk_trade_pair, time DESC, microseconds DESC); SELECT table_name FROM create_hypertable('tickers', 'time'); table_name ------------ tickers ALTER TABLE tickers SET (timescaledb.compress, timescaledb.compress_segmentby = 'fk_exchange, fk_trade_pair', timescaledb.compress_orderby = 'time DESC, microseconds DESC'); INSERT INTO tickers SELECT '2000-01-01', 0, i, j FROM generate_series(1, 20) i, generate_series(1, 40) j; SELECT substr(compress_chunk(tableoid::REGCLASS)::TEXT, 1, 29) FROM tickers GROUP BY tableoid; substr ------------------------------- _timescaledb_internal._hyper_ SELECT * FROM tickers WHERE time >= '2000-01-01' AND time < '2020-08-02T00:00Z' AND fk_exchange = 4 AND fk_trade_pair = 29 ORDER BY time DESC, microseconds DESC; time | microseconds | fk_exchange | fk_trade_pair ------------------------------+--------------+-------------+--------------- Sat Jan 01 00:00:00 2000 PST | 0 | 4 | 29 DROP TABLE tickers; �����������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/decompress_tracking.out���������������������������������0000664�0000000�0000000�00000021417�15100345067�0025467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off,timing off,summary off)' \set EXPLAIN_ANALYZE 'EXPLAIN (analyze,buffers off, costs off,timing off,summary off)' CREATE TABLE decompress_tracking(time timestamptz not null, device text, value float, primary key(time, device)); SELECT table_name FROM create_hypertable('decompress_tracking','time'); table_name --------------------- decompress_tracking ALTER TABLE decompress_tracking SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO decompress_tracking SELECT '2020-01-01'::timestamptz + format('%s hour', g)::interval, 'd1', random() FROM generate_series(1,10) g; INSERT INTO decompress_tracking SELECT '2020-01-01'::timestamptz + format('%s hour', g)::interval, 'd2', random() FROM generate_series(1,20) g; INSERT INTO decompress_tracking SELECT '2020-01-01'::timestamptz + format('%s hour', g)::interval, 'd3', random() FROM generate_series(1,30) g; SELECT count(compress_chunk(ch)) FROM show_chunks('decompress_tracking') ch; count ------- 2 ANALYZE decompress_tracking; -- no tracking without analyze :EXPLAIN UPDATE decompress_tracking SET value = value + 3; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on decompress_tracking Update on _hyper_X_X_chunk decompress_tracking_1 Update on _hyper_X_X_chunk decompress_tracking_2 -> Result -> Append -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 BEGIN; :EXPLAIN_ANALYZE UPDATE decompress_tracking SET value = value + 3; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 5 Tuples decompressed: 60 -> Update on decompress_tracking (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk decompress_tracking_1 Update on _hyper_X_X_chunk decompress_tracking_2 -> Result (actual rows=60.00 loops=1) -> Append (actual rows=60.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 (actual rows=40.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 (actual rows=20.00 loops=1) BEGIN; :EXPLAIN_ANALYZE UPDATE decompress_tracking SET value = value + 3 WHERE device = 'd2'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 20 -> Update on decompress_tracking (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk decompress_tracking_1 Update on _hyper_X_X_chunk decompress_tracking_2 -> Result (actual rows=20.00 loops=1) -> Append (actual rows=20.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 (actual rows=15.00 loops=1) Filter: (device = 'd2'::text) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 (actual rows=5.00 loops=1) Filter: (device = 'd2'::text) SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 5 Tuples decompressed: 60 -> Delete on decompress_tracking (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk decompress_tracking_1 Delete on _hyper_X_X_chunk decompress_tracking_2 -> Append (actual rows=60.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 (actual rows=40.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 (actual rows=20.00 loops=1) BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking WHERE device = 'd3'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches decompressed: 2 Tuples decompressed: 30 -> Delete on decompress_tracking (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk decompress_tracking_1 Delete on _hyper_X_X_chunk decompress_tracking_2 -> Append (actual rows=30.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 (actual rows=15.00 loops=1) Filter: (device = 'd3'::text) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 (actual rows=15.00 loops=1) Filter: (device = 'd3'::text) RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 5 -> Delete on decompress_tracking (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk decompress_tracking_1 Delete on _hyper_X_X_chunk decompress_tracking_2 -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 (actual rows=0.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 (actual rows=0.00 loops=1) BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking WHERE device = 'd3'; ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches deleted: 2 -> Delete on decompress_tracking (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk decompress_tracking_1 Delete on _hyper_X_X_chunk decompress_tracking_2 -> Append (actual rows=0.00 loops=1) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 (actual rows=0.00 loops=1) Filter: (device = 'd3'::text) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 (actual rows=0.00 loops=1) Filter: (device = 'd3'::text) BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking SELECT '2020-01-01 1:30','d1',random(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 1 -> Insert on decompress_tracking (actual rows=0.00 loops=1) -> Subquery Scan on "*SELECT*" (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking SELECT '2020-01-01','d2',random(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on decompress_tracking (actual rows=0.00 loops=1) -> Subquery Scan on "*SELECT*" (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking SELECT '2020-01-01','d4',random(); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Insert on decompress_tracking (actual rows=0.00 loops=1) -> Subquery Scan on "*SELECT*" (actual rows=1.00 loops=1) -> Result (actual rows=1.00 loops=1) BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking (VALUES ('2020-01-01 1:30','d1',random()),('2020-01-01 1:30','d2',random())); ROLLBACK; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) Batches filtered: 2 -> Insert on decompress_tracking (actual rows=0.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test prepared statements EXPLAIN still works after execution SET plan_cache_mode TO force_generic_plan; PREPARE p1 AS UPDATE decompress_tracking SET value = value + 3 WHERE device = 'd1'; BEGIN; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on decompress_tracking Update on _hyper_X_X_chunk decompress_tracking_1 Update on _hyper_X_X_chunk decompress_tracking_2 -> Result -> Append -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 Filter: (device = 'd1'::text) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 Filter: (device = 'd1'::text) EXECUTE p1; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on decompress_tracking Update on _hyper_X_X_chunk decompress_tracking_1 Update on _hyper_X_X_chunk decompress_tracking_2 -> Result -> Append -> Seq Scan on _hyper_X_X_chunk decompress_tracking_1 Filter: (device = 'd1'::text) -> Seq Scan on _hyper_X_X_chunk decompress_tracking_2 Filter: (device = 'd1'::text) ROLLBACK; DROP TABLE decompress_tracking; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/extension.out�������������������������������������������0000664�0000000�0000000�00000051322�15100345067�0023453�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \pset tuples_only on -- list all extension functions -- any change in the output of this query requires adjustments -- in the update and downgrade scripts -- get_telemetry_report is excluded as it will not be present -- when built with telemetry disabled SELECT p.oid::regprocedure::text FROM pg_proc p JOIN pg_depend d ON d.objid = p.oid AND d.deptype = 'e' AND d.refclassid = 'pg_extension'::regclass AND d.classid = 'pg_proc'::regclass JOIN pg_extension e ON e.extname = 'timescaledb' AND e.oid = d.refobjid WHERE proname <> 'get_telemetry_report' ORDER BY pronamespace::regnamespace::text COLLATE "C", p.oid::regprocedure::text COLLATE "C"; _timescaledb_debug.extension_state() _timescaledb_functions.accept_hypertable_invalidations(regclass,text) _timescaledb_functions.add_materialization_invalidations(regclass,tsrange) _timescaledb_functions.add_materialization_invalidations(regclass,tstzrange) _timescaledb_functions.align_to_bucket(interval,anyrange) _timescaledb_functions.alter_job_set_hypertable_id(integer,regclass) _timescaledb_functions.attach_osm_table_chunk(regclass,regclass) _timescaledb_functions.bloom1_contains(_timescaledb_internal.bloom1,anyelement) _timescaledb_functions.bloom1in(cstring) _timescaledb_functions.bloom1out(_timescaledb_internal.bloom1) _timescaledb_functions.bookend_deserializefunc(bytea,internal) _timescaledb_functions.bookend_finalfunc(internal,anyelement,"any") _timescaledb_functions.bookend_serializefunc(internal) _timescaledb_functions.cagg_get_bucket_function_info(integer) _timescaledb_functions.cagg_migrate_create_plan(_timescaledb_catalog.continuous_agg,text,boolean,boolean) _timescaledb_functions.cagg_migrate_execute_copy_data(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_copy_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_create_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_disable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_drop_old_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_enable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_override_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_execute_plan(_timescaledb_catalog.continuous_agg) _timescaledb_functions.cagg_migrate_execute_refresh_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_functions.cagg_migrate_plan_exists(integer) _timescaledb_functions.cagg_migrate_pre_validation(text,text,text) _timescaledb_functions.cagg_migrate_to_time_bucket(regclass) _timescaledb_functions.cagg_migrate_update_watermark(integer) _timescaledb_functions.cagg_parse_invalidation_record(bytea) _timescaledb_functions.cagg_validate_query(text) _timescaledb_functions.cagg_watermark(integer) _timescaledb_functions.cagg_watermark_materialized(integer) _timescaledb_functions.calculate_chunk_interval(integer,bigint,bigint) _timescaledb_functions.chunk_constraint_add_table_constraint(_timescaledb_catalog.chunk_constraint) _timescaledb_functions.chunk_id_from_relid(oid) _timescaledb_functions.chunk_status(regclass) _timescaledb_functions.chunk_status_text(integer) _timescaledb_functions.chunk_status_text(regclass) _timescaledb_functions.chunks_local_size(name,name) _timescaledb_functions.compressed_chunk_local_stats(name,name) _timescaledb_functions.compressed_data_has_nulls(_timescaledb_internal.compressed_data) _timescaledb_functions.compressed_data_in(cstring) _timescaledb_functions.compressed_data_info(_timescaledb_internal.compressed_data) _timescaledb_functions.compressed_data_out(_timescaledb_internal.compressed_data) _timescaledb_functions.compressed_data_recv(internal) _timescaledb_functions.compressed_data_send(_timescaledb_internal.compressed_data) _timescaledb_functions.constraint_clone(oid,regclass) _timescaledb_functions.create_chunk(regclass,jsonb,name,name,regclass) _timescaledb_functions.create_compressed_chunk(regclass,regclass,bigint,bigint,bigint,bigint,bigint,bigint,bigint,bigint) _timescaledb_functions.dimension_info_in(cstring) _timescaledb_functions.dimension_info_out(_timescaledb_internal.dimension_info) _timescaledb_functions.drop_chunk(regclass) _timescaledb_functions.drop_osm_chunk(regclass) _timescaledb_functions.finalize_agg(text,name,name,name[],bytea,anyelement) _timescaledb_functions.finalize_agg_ffunc(internal,text,name,name,name[],bytea,anyelement) _timescaledb_functions.finalize_agg_sfunc(internal,text,name,name,name[],bytea,anyelement) _timescaledb_functions.first_combinefunc(internal,internal) _timescaledb_functions.first_sfunc(internal,anyelement,"any") _timescaledb_functions.freeze_chunk(regclass) _timescaledb_functions.generate_uuid() _timescaledb_functions.get_approx_row_count(regclass) _timescaledb_functions.get_compressed_chunk_index_for_recompression(regclass) _timescaledb_functions.get_create_command(name) _timescaledb_functions.get_git_commit() _timescaledb_functions.get_hypertable_id(regclass,regtype) _timescaledb_functions.get_hypertable_invalidations(regclass,timestamp with time zone,interval[]) _timescaledb_functions.get_hypertable_invalidations(regclass,timestamp without time zone,interval[]) _timescaledb_functions.get_internal_time_max(regtype) _timescaledb_functions.get_internal_time_min(regtype) _timescaledb_functions.get_materialization_info(regclass) _timescaledb_functions.get_materialization_invalidations(regclass,tsrange) _timescaledb_functions.get_materialization_invalidations(regclass,tstzrange) _timescaledb_functions.get_orderby_defaults(regclass,text[]) _timescaledb_functions.get_os_info() _timescaledb_functions.get_partition_for_key(anyelement) _timescaledb_functions.get_partition_hash(anyelement) _timescaledb_functions.get_raw_materialization_ranges(regtype) _timescaledb_functions.get_segmentby_defaults(regclass) _timescaledb_functions.hist_combinefunc(internal,internal) _timescaledb_functions.hist_deserializefunc(bytea,internal) _timescaledb_functions.hist_finalfunc(internal,double precision,double precision,double precision,integer) _timescaledb_functions.hist_serializefunc(internal) _timescaledb_functions.hist_sfunc(internal,double precision,double precision,double precision,integer) _timescaledb_functions.hypertable_local_size(name,name) _timescaledb_functions.hypertable_osm_range_update(regclass,anyelement,anyelement,boolean) _timescaledb_functions.index_matches(regclass,regclass) _timescaledb_functions.interval_to_usec(interval) _timescaledb_functions.invalidation_plugin_name() _timescaledb_functions.job_history_bsearch(timestamp with time zone) _timescaledb_functions.jsonb_get_matching_index_entry(jsonb,text,text) _timescaledb_functions.last_combinefunc(internal,internal) _timescaledb_functions.last_sfunc(internal,anyelement,"any") _timescaledb_functions.make_multirange_from_internal_time(tsrange,bigint,bigint) _timescaledb_functions.make_multirange_from_internal_time(tstzrange,bigint,bigint) _timescaledb_functions.make_range_from_internal_time(anyrange,anyelement,anyelement) _timescaledb_functions.makeaclitem(regrole,regrole,text,boolean) _timescaledb_functions.metadata_insert_trigger() _timescaledb_functions.partialize_agg(anyelement) _timescaledb_functions.policy_compression(integer,jsonb) _timescaledb_functions.policy_compression_check(jsonb) _timescaledb_functions.policy_compression_execute(integer,integer,anyelement,integer,boolean,boolean,boolean,boolean) _timescaledb_functions.policy_job_stat_history_retention(integer,jsonb) _timescaledb_functions.policy_job_stat_history_retention_check(jsonb) _timescaledb_functions.policy_process_hypertable_invalidations(integer,jsonb) _timescaledb_functions.policy_process_hypertable_invalidations_check(jsonb) _timescaledb_functions.policy_recompression(integer,jsonb) _timescaledb_functions.policy_refresh_continuous_aggregate(integer,jsonb) _timescaledb_functions.policy_refresh_continuous_aggregate_check(jsonb) _timescaledb_functions.policy_reorder(integer,jsonb) _timescaledb_functions.policy_reorder_check(jsonb) _timescaledb_functions.policy_retention(integer,jsonb) _timescaledb_functions.policy_retention_check(jsonb) _timescaledb_functions.process_ddl_event() _timescaledb_functions.process_hypertable_invalidations(name) _timescaledb_functions.process_hypertable_invalidations(regclass) _timescaledb_functions.process_hypertable_invalidations(regclass[]) _timescaledb_functions.range_value_to_pretty(bigint,regtype) _timescaledb_functions.recompress_chunk_segmentwise(regclass,boolean) _timescaledb_functions.relation_approximate_size(regclass) _timescaledb_functions.relation_size(regclass) _timescaledb_functions.remove_dropped_chunk_metadata(integer) _timescaledb_functions.repair_relation_acls() _timescaledb_functions.restart_background_workers() _timescaledb_functions.show_chunk(regclass) _timescaledb_functions.start_background_workers() _timescaledb_functions.stop_background_workers() _timescaledb_functions.subtract_integer_from_now(regclass,bigint) _timescaledb_functions.time_to_internal(anyelement) _timescaledb_functions.to_date(bigint) _timescaledb_functions.to_interval(bigint) _timescaledb_functions.to_timestamp(bigint) _timescaledb_functions.to_timestamp_without_timezone(bigint) _timescaledb_functions.to_unix_microseconds(timestamp with time zone) _timescaledb_functions.tsl_loaded() _timescaledb_functions.unfreeze_chunk(regclass) _timescaledb_internal.alter_job_set_hypertable_id(integer,regclass) _timescaledb_internal.attach_osm_table_chunk(regclass,regclass) _timescaledb_internal.cagg_migrate_create_plan(_timescaledb_catalog.continuous_agg,text,boolean,boolean) _timescaledb_internal.cagg_migrate_execute_copy_data(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_copy_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_create_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_disable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_enable_policies(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_override_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_execute_plan(_timescaledb_catalog.continuous_agg) _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(_timescaledb_catalog.continuous_agg,_timescaledb_catalog.continuous_agg_migrate_plan_step) _timescaledb_internal.cagg_migrate_plan_exists(integer) _timescaledb_internal.cagg_migrate_pre_validation(text,text,text) _timescaledb_internal.cagg_watermark(integer) _timescaledb_internal.cagg_watermark_materialized(integer) _timescaledb_internal.calculate_chunk_interval(integer,bigint,bigint) _timescaledb_internal.chunk_constraint_add_table_constraint(_timescaledb_catalog.chunk_constraint) _timescaledb_internal.chunk_id_from_relid(oid) _timescaledb_internal.chunk_status(regclass) _timescaledb_internal.chunks_local_size(name,name) _timescaledb_internal.compressed_chunk_local_stats(name,name) _timescaledb_internal.compressed_chunk_remote_stats(name,name) _timescaledb_internal.create_chunk(regclass,jsonb,name,name,regclass) _timescaledb_internal.create_compressed_chunk(regclass,regclass,bigint,bigint,bigint,bigint,bigint,bigint,bigint,bigint) _timescaledb_internal.drop_chunk(regclass) _timescaledb_internal.finalize_agg(text,name,name,name[],bytea,anyelement) _timescaledb_internal.finalize_agg_ffunc(internal,text,name,name,name[],bytea,anyelement) _timescaledb_internal.finalize_agg_sfunc(internal,text,name,name,name[],bytea,anyelement) _timescaledb_internal.freeze_chunk(regclass) _timescaledb_internal.generate_uuid() _timescaledb_internal.get_approx_row_count(regclass) _timescaledb_internal.get_compressed_chunk_index_for_recompression(regclass) _timescaledb_internal.get_create_command(name) _timescaledb_internal.get_git_commit() _timescaledb_internal.get_os_info() _timescaledb_internal.get_partition_for_key(anyelement) _timescaledb_internal.get_partition_hash(anyelement) _timescaledb_internal.hypertable_local_size(name,name) _timescaledb_internal.interval_to_usec(interval) _timescaledb_internal.partialize_agg(anyelement) _timescaledb_internal.policy_compression(integer,jsonb) _timescaledb_internal.policy_compression_check(jsonb) _timescaledb_internal.policy_job_stat_history_retention(integer,jsonb) _timescaledb_internal.policy_job_stat_history_retention_check(jsonb) _timescaledb_internal.policy_recompression(integer,jsonb) _timescaledb_internal.policy_refresh_continuous_aggregate(integer,jsonb) _timescaledb_internal.policy_refresh_continuous_aggregate_check(jsonb) _timescaledb_internal.policy_reorder(integer,jsonb) _timescaledb_internal.policy_reorder_check(jsonb) _timescaledb_internal.policy_retention(integer,jsonb) _timescaledb_internal.policy_retention_check(jsonb) _timescaledb_internal.process_ddl_event() _timescaledb_internal.range_value_to_pretty(bigint,regtype) _timescaledb_internal.recompress_chunk_segmentwise(regclass,boolean) _timescaledb_internal.relation_size(regclass) _timescaledb_internal.restart_background_workers() _timescaledb_internal.show_chunk(regclass) _timescaledb_internal.start_background_workers() _timescaledb_internal.stop_background_workers() _timescaledb_internal.subtract_integer_from_now(regclass,bigint) _timescaledb_internal.time_to_internal(anyelement) _timescaledb_internal.to_date(bigint) _timescaledb_internal.to_interval(bigint) _timescaledb_internal.to_timestamp(bigint) _timescaledb_internal.to_timestamp_without_timezone(bigint) _timescaledb_internal.to_unix_microseconds(timestamp with time zone) _timescaledb_internal.tsl_loaded() _timescaledb_internal.unfreeze_chunk(regclass) debug_waitpoint_enable(text) debug_waitpoint_id(text) debug_waitpoint_release(text) ts_now_mock() add_columnstore_policy(regclass,"any",boolean,interval,timestamp with time zone,text,interval) add_compression_policy(regclass,"any",boolean,interval,timestamp with time zone,text,interval) add_continuous_aggregate_policy(regclass,"any","any",interval,boolean,timestamp with time zone,text,boolean,integer,integer,boolean) add_dimension(regclass,_timescaledb_internal.dimension_info,boolean) add_dimension(regclass,name,integer,anyelement,regproc,boolean) add_job(regproc,interval,jsonb,timestamp with time zone,boolean,regproc,boolean,text,text) add_process_hypertable_invalidations_policy(regclass,interval,boolean,timestamp with time zone,text) add_reorder_policy(regclass,name,boolean,timestamp with time zone,text) add_retention_policy(regclass,"any",boolean,interval,timestamp with time zone,text,interval) alter_job(integer,interval,interval,integer,interval,boolean,jsonb,timestamp with time zone,boolean,regproc,boolean,timestamp with time zone,text,text) approximate_row_count(regclass) attach_chunk(regclass,regclass,jsonb) attach_tablespace(name,regclass,boolean) by_hash(name,integer,regproc) by_range(name,anyelement,regproc) cagg_migrate(regclass,boolean,boolean) chunk_columnstore_stats(regclass) chunk_compression_stats(regclass) chunks_detailed_size(regclass) compress_chunk(regclass,boolean,boolean) convert_to_columnstore(regclass,boolean,boolean) convert_to_rowstore(regclass,boolean) create_hypertable(regclass,_timescaledb_internal.dimension_info,boolean,boolean,boolean) create_hypertable(regclass,name,name,integer,name,name,anyelement,boolean,boolean,regproc,boolean,text,regproc,regproc) decompress_chunk(regclass,boolean) delete_job(integer) detach_chunk(regclass) detach_tablespace(name,regclass,boolean) detach_tablespaces(regclass) disable_chunk_skipping(regclass,name,boolean) drop_chunks(regclass,"any","any",boolean,"any","any") enable_chunk_skipping(regclass,name,boolean) first(anyelement,"any") generate_uuidv7() histogram(double precision,double precision,double precision,integer) hypertable_approximate_detailed_size(regclass) hypertable_approximate_size(regclass) hypertable_columnstore_stats(regclass) hypertable_compression_stats(regclass) hypertable_detailed_size(regclass) hypertable_index_size(regclass) hypertable_size(regclass) interpolate(bigint,record,record) interpolate(double precision,record,record) interpolate(integer,record,record) interpolate(real,record,record) interpolate(smallint,record,record) last(anyelement,"any") locf(anyelement,anyelement,boolean) merge_chunks(regclass,regclass) merge_chunks(regclass[]) move_chunk(regclass,name,name,regclass,boolean) recompress_chunk(regclass,boolean) refresh_continuous_aggregate(regclass,"any","any",boolean,jsonb) remove_columnstore_policy(regclass,boolean) remove_compression_policy(regclass,boolean) remove_continuous_aggregate_policy(regclass,boolean,boolean) remove_process_hypertable_invalidations_policy(regclass,boolean) remove_reorder_policy(regclass,boolean) remove_retention_policy(regclass,boolean) reorder_chunk(regclass,regclass,boolean) run_job(integer) set_adaptive_chunking(regclass,text,regproc) set_chunk_time_interval(regclass,anyelement,name) set_integer_now_func(regclass,regproc,boolean) set_number_partitions(regclass,integer,name) set_partitioning_interval(regclass,anyelement,name) show_chunks(regclass,"any","any","any","any") show_tablespaces(regclass) split_chunk(regclass,"any") time_bucket(bigint,bigint) time_bucket(bigint,bigint,bigint) time_bucket(integer,integer) time_bucket(integer,integer,integer) time_bucket(interval,date) time_bucket(interval,date,date) time_bucket(interval,date,interval) time_bucket(interval,timestamp with time zone) time_bucket(interval,timestamp with time zone,interval) time_bucket(interval,timestamp with time zone,text,timestamp with time zone,interval) time_bucket(interval,timestamp with time zone,timestamp with time zone) time_bucket(interval,timestamp without time zone) time_bucket(interval,timestamp without time zone,interval) time_bucket(interval,timestamp without time zone,timestamp without time zone) time_bucket(smallint,smallint) time_bucket(smallint,smallint,smallint) time_bucket_gapfill(bigint,bigint,bigint,bigint) time_bucket_gapfill(integer,integer,integer,integer) time_bucket_gapfill(interval,date,date,date) time_bucket_gapfill(interval,timestamp with time zone,text,timestamp with time zone,timestamp with time zone) time_bucket_gapfill(interval,timestamp with time zone,timestamp with time zone,timestamp with time zone) time_bucket_gapfill(interval,timestamp without time zone,timestamp without time zone,timestamp without time zone) time_bucket_gapfill(smallint,smallint,smallint,smallint) timescaledb_post_restore() timescaledb_pre_restore() to_uuidv7(timestamp with time zone) to_uuidv7_boundary(timestamp with time zone) uuid_timestamp(uuid) uuid_timestamp_micros(uuid) uuid_version(uuid) timescaledb_experimental.add_policies(regclass,boolean,"any","any","any","any") timescaledb_experimental.alter_policies(regclass,boolean,"any","any","any","any") timescaledb_experimental.remove_all_policies(regclass,boolean) timescaledb_experimental.remove_policies(regclass,boolean,text[]) timescaledb_experimental.show_policies(regclass) timescaledb_experimental.time_bucket_ng(interval,date) timescaledb_experimental.time_bucket_ng(interval,date,date) timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone) timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,text) timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone) timescaledb_experimental.time_bucket_ng(interval,timestamp with time zone,timestamp with time zone,text) timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone) timescaledb_experimental.time_bucket_ng(interval,timestamp without time zone,timestamp without time zone) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/gapfill-15.out������������������������������������������0000664�0000000�0000000�00000602043�15100345067�0023302�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' -- we want to see error details in the output \set VERBOSITY default CREATE TABLE gapfill_plan_test(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('gapfill_plan_test','time',chunk_time_interval=>'4 weeks'::interval); table_name ------------------- gapfill_plan_test INSERT INTO gapfill_plan_test SELECT generate_series('2018-01-01'::timestamptz,'2018-04-01'::timestamptz,'1m'::interval), 1.0; -- simple example :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sorting :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sort direction :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1 DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) DESC -> Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) NULLS FIRST -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now()) -> Values Scan on "*VALUES*" -- test order by aggregate function :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2,1; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)), (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test query without order by :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test parallel query :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), avg(value) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- make sure we can run gapfill in parallel workers -- ensure this plan runs in parallel :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; --- QUERY PLAN --- Limit -> Sort Sort Key: (interpolate(avg(gapfill_plan_test.value), NULL::record, NULL::record)) -> Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- actually run a parallel gapfill SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; time_bucket_gapfill | interpolate ------------------------------+------------- Mon Jan 01 00:00:00 2018 PST | 1 -- test sort optimizations -- test sort optimization with single member order by, -- should use index scan (no GapFill node for this one since we're not gapfilling) :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk SET max_parallel_workers_per_gather TO 0; -- test sort optimizations with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimizations with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk RESET max_parallel_workers_per_gather; CREATE INDEX gapfill_plan_test_indx ON gapfill_plan_test(value, time); -- test sort optimization with ordering by multiple columns and time_bucket_gapfill not last, -- must not use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)), gapfill_plan_test.value -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimization with ordering by multiple columns and time_bucket as last member, -- should use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 2,1; --- QUERY PLAN --- Sort Sort Key: gapfill_plan_test.value, (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk DROP TABLE gapfill_plan_test; \set METRICS metrics_int -- All test against table :METRICS first \set ON_ERROR_STOP 0 -- inverse of previous test query to confirm an error is actually thrown SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time = 5 GROUP BY 1,2,3 ORDER BY 2,3,1; ERROR: division by zero -- test window functions with multiple column references SELECT time_bucket_gapfill(1,time,1,2), first(min(time),min(time)) OVER () FROM :METRICS GROUP BY 1; ERROR: window functions with multiple column references not supported -- test with unsupported operator SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time =0 AND time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test with 2 tables and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test inner join and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time WHERE m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test outer join with constraints in join condition -- not usable as start/stop SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 LEFT OUTER JOIN :METRICS m2 ON m1.time=m2.time AND m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 \ir include/gapfill_metrics_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test locf lookup query does not trigger when not needed -- -- 1/(SELECT 0) will throw an error in the lookup query but in order to not -- always trigger evaluation it needs to be correlated otherwise postgres will -- always run it once even if the value is never used SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | locf3 ------+-----------+-----------+------- 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 -- test locf with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value)::int,23) AS locf1, locf(min(value)::int,(SELECT 42)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 1 | | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and "wrong order" SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value),23::float) AS locf1, locf(min(value),(SELECT 42::float)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 1,2,3; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 1 | | 5 | 5 | 5 | 5 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and window functions SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)), sum(locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1))) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3; time | device_id | sensor_id | locf | sum ------+-----------+-----------+------+------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 5 | 10 10 | 1 | 1 | 5 | 10 0 | 1 | 2 | -100 | -100 5 | 1 | 2 | 10 | -90 10 | 1 | 2 | 10 | 20 -- test JOINs SELECT time_bucket_gapfill(1,time,0,5) as time, device_id, d.name, sensor_id, s.name, avg(m.value) FROM :METRICS m INNER JOIN devices d USING(device_id) INNER JOIN sensors s USING(sensor_id) WHERE time BETWEEN 0 AND 5 GROUP BY 1,2,3,4,5; time | device_id | name | sensor_id | name | avg ------+-----------+----------+-----------+----------+----- 0 | 1 | Device 1 | 1 | Sensor 1 | 5 1 | 1 | Device 1 | 1 | Sensor 1 | 2 | 1 | Device 1 | 1 | Sensor 1 | 3 | 1 | Device 1 | 1 | Sensor 1 | 4 | 1 | Device 1 | 1 | Sensor 1 | 0 | 1 | Device 1 | 2 | Sensor 2 | 1 | 1 | Device 1 | 2 | Sensor 2 | 2 | 1 | Device 1 | 2 | Sensor 2 | 3 | 1 | Device 1 | 2 | Sensor 2 | 4 | 1 | Device 1 | 2 | Sensor 2 | 5 | 1 | Device 1 | 2 | Sensor 2 | 10 -- test interpolate with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), interpolate(min(value)) AS ip, interpolate(min(value),(-5,-5.0::float),(15,20.0::float)) AS ip1, interpolate(min(value),(SELECT (-10,-10.0::float)),(SELECT (15,20.0::float))) AS ip2, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) AS ip3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | ip | ip1 | ip2 | ip3 ------+-----------+-----------+-----+----+-----+------------------+------------------ 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | | 10 | 10 | 4.75 10 | 1 | 1 | | | 15 | 15 | 4.5 0 | 1 | 2 | | | 2.5 | 3.33333333333333 | 4.76190476190476 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | | 15 | 15 | 4.21052631578947 -- test interpolate with correlated subquery and window function SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ), sum(interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) )) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | interpolate | sum ------+-----------+-----------+------------------+------------------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 4.75 | 9.75 10 | 1 | 1 | 4.5 | 9.25 0 | 1 | 2 | 4.76190476190476 | 4.76190476190476 5 | 1 | 2 | 10 | 14.7619047619048 10 | 1 | 2 | 4.21052631578947 | 14.2105263157895 -- test subqueries -- subqueries will alter the shape of the plan and top-level constraints -- might not end up in top-level of jointree SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 WHERE m1.time >=0 AND m1.time < 2 AND device_id IN (SELECT device_id FROM :METRICS) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test inner join with constraints in join condition SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time AND m2.time >=0 AND m2.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test actual table SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time >=0 AND time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with table alias SELECT time_bucket_gapfill(1,time) FROM :METRICS m WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with 2 tables SELECT time_bucket_gapfill(1,m.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test prepared statement with locf with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 DEALLOCATE prep_gapfill; -- test prepared statement with interpolate with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 DEALLOCATE prep_gapfill; -- test prepared statement with variable gapfill arguments PREPARE prep_gapfill(int,int,int) AS SELECT time_bucket_gapfill($1,time,$2,$3) AS time, device_id, sensor_id, min(value) FROM :METRICS m1 WHERE time >= $2 AND time < $3 AND device_id=1 AND sensor_id=1 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | DEALLOCATE prep_gapfill; -- Tests without tables -- test locf and interpolate call without gapfill SELECT locf(1); locf ------ 1 SELECT interpolate(1); interpolate ------------- 1 -- test locf and interpolate call with NULL input SELECT locf(NULL::int); locf ------ SELECT interpolate(NULL::bigint); interpolate ------------- \set ON_ERROR_STOP 0 -- test time_bucket_gapfill not top level function call SELECT 1 + time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: no top level time_bucket_gapfill in group by clause -- test locf with treat_null_as_missing not BOOL SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=1) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function locf(integer, treat_null_as_missing => integer) does not exist LINE 3: locf(min(time),treat_null_as_missing:=1) ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test locf with treat_null_as_missing not literal SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=random()>0) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid locf argument: treat_null_as_missing must be a BOOL literal -- test interpolate lookup query with 1 element in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT ROW(10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT ROW(10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with 3 elements in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with mismatching time datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10::float,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10::float,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate lookup query with mismatching value datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10::float))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10::float))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate with unsupported datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(text 'text') FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function interpolate(text) does not exist LINE 3: interpolate(text 'text') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. SELECT time_bucket_gapfill(1,time,1,11), interpolate(interval '1d') FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: function interpolate(interval) does not exist LINE 3: interpolate(interval '1d') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test multiple time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time,1,11),time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time_bucket_gapfill(1,time,1,11),1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested locf calls SELECT time_bucket_gapfill(1,time,1,11), locf(locf(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test nested interpolate calls SELECT time_bucket_gapfill(1,time,1,11), interpolate(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test mixed locf/interpolate calls SELECT time_bucket_gapfill(1,time,1,11), locf(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test window function inside locf SELECT time_bucket_gapfill(1,time,1,11), locf(avg(min(time)) OVER ()) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window functions must not be below locf -- test nested window functions -- prevented by postgres SELECT time_bucket_gapfill(1,time,1,11), avg(avg(min(time)) OVER ()) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window function calls cannot be nested LINE 3: avg(avg(min(time)) OVER ()) OVER () ^ -- test multiple window functions in single column SELECT time_bucket_gapfill(1,time,1,11), avg(min(time)) OVER () + avg(min(time)) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple window function calls per column not supported -- test locf not toplevel SELECT time_bucket_gapfill(1,time,1,11), 1 + locf(min(time)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: locf must be toplevel function call -- test locf inside aggregate SELECT time_bucket_gapfill(1,time,1,11), min(min(locf(time))) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: aggregate functions must be below locf -- test NULL args SELECT time_bucket_gapfill(NULL,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill(1,NULL,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill(1,time,NULL,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(1,time,1,NULL) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(NULL,time,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill('1day',NULL,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill('1day',time,NULL,'2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: timezone cannot be NULL -- test 0 bucket_width SELECT time_bucket_gapfill(0,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test negative bucket_width SELECT time_bucket_gapfill(-1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test subqueries as interval, start and stop (not supported atm) SELECT time_bucket_gapfill((SELECT 1),time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression SELECT time_bucket_gapfill(1,time,(SELECT 1),11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression SELECT time_bucket_gapfill(1,time,1,(SELECT 11)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression \set ON_ERROR_STOP 1 -- test time_bucket_gapfill without aggregation -- this will not trigger gapfilling SELECT time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time); time_bucket_gapfill --------------------- 1 2 SELECT time_bucket_gapfill(1,time,1,11), avg(time) OVER () FROM (VALUES (1),(2)) v(time); time_bucket_gapfill | avg ---------------------+-------------------- 1 | 1.5000000000000000 2 | 1.5000000000000000 -- test int int2/4/8 SELECT time_bucket_gapfill(1::int2,time::int2,0::int2,6::int2) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int4,time::int4,0::int4,6::int4) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int8,time::int8,0::int8,6::int8) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 -- test non-aligned bucket start SELECT time_bucket_gapfill(10,time,5,40) FROM (VALUES (11),(22)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 10 20 30 -- simple gapfill query SELECT time_bucket_gapfill(10,time,0,50) AS time, min(value) AS value FROM (values (-10,1),(10,2),(11,3),(12,4),(22,5),(30,6),(66,7)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- -10 | 1 0 | 10 | 2 20 | 5 30 | 6 40 | 60 | 7 -- test references to different columns SELECT time_bucket_gapfill(1,t,0,5) as t, min(t),max(t),min(v),max(v) FROM(VALUES (1,3),(2,5)) tb(t,v) GROUP BY 1 ORDER BY 1; t | min | max | min | max ---+-----+-----+-----+----- 0 | | | | 1 | 1 | 1 | 3 | 3 2 | 2 | 2 | 5 | 5 3 | | | | 4 | | | | -- test passing of values outside boundaries SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (-1),(1),(3),(6)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- -1 | -1 0 | 1 | 1 2 | 3 | 3 4 | 6 | 6 -- test gap fill before first row and after last row SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 1 2 | 2 3 | 3 4 | -- test gap fill without rows in resultset SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) WHERE false GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 2 | 3 | 4 | -- test coalesce SELECT time_bucket_gapfill(1,time,0,5), coalesce(min(time),0), coalesce(min(value),0), coalesce(min(value),7) FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | coalesce | coalesce | coalesce ---------------------+----------+----------+---------- 0 | 0 | 0 | 7 1 | 1 | 1 | 1 2 | 2 | 2 | 2 3 | 3 | 3 | 3 4 | 0 | 0 | 7 -- test case SELECT time_bucket_gapfill(1,time,0,5), min(time), CASE WHEN min(time) IS NOT NULL THEN min(time) ELSE -1 END, CASE WHEN min(time) IS NOT NULL THEN min(time) + 7 ELSE 0 END, CASE WHEN 1 = 1 THEN 1 ELSE 0 END FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | case | case | case ---------------------+-----+------+------+------ 0 | | -1 | 0 | 1 1 | 1 | 1 | 8 | 1 2 | 2 | 2 | 9 | 1 3 | 3 | 3 | 10 | 1 4 | | -1 | 0 | 1 -- test constants SELECT time_bucket_gapfill(1,time,0,5), min(time), min(time), 4 as c FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | min | c ---------------------+-----+-----+--- 0 | | | 4 1 | 1 | 1 | 4 2 | 2 | 2 | 4 3 | 3 | 3 | 4 4 | | | 4 -- test column reordering SELECT 1 as c1, '2' as c2, time_bucket_gapfill(1,time,0,5), 3.0 as c3, min(time), min(time), 4 as c4 FROM (VALUES (1),(2),(3)) v(time) GROUP BY 3 ORDER BY 3; c1 | c2 | time_bucket_gapfill | c3 | min | min | c4 ----+----+---------------------+-----+-----+-----+---- 1 | 2 | 0 | 3.0 | | | 4 1 | 2 | 1 | 3.0 | 1 | 1 | 4 1 | 2 | 2 | 3.0 | 2 | 2 | 4 1 | 2 | 3 | 3.0 | 3 | 3 | 4 1 | 2 | 4 | 3.0 | | | 4 -- test timestamptz SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMPTZ '2000-01-01',TIMESTAMPTZ '2000-01-02'), min(time) FROM (VALUES (TIMESTAMPTZ '2000-01-01 9:00:00'),(TIMESTAMPTZ '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ------------------------------+------------------------------ Fri Dec 31 22:00:00 1999 PST | Sat Jan 01 04:00:00 2000 PST | Sat Jan 01 09:00:00 2000 PST Sat Jan 01 10:00:00 2000 PST | Sat Jan 01 16:00:00 2000 PST | Sat Jan 01 18:00:00 2000 PST Sat Jan 01 22:00:00 2000 PST | -- test timestamp SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMP '2000-01-01',TIMESTAMP '2000-01-02'), min(time) FROM (VALUES (TIMESTAMP '2000-01-01 9:00:00'),(TIMESTAMP '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min --------------------------+-------------------------- Sat Jan 01 00:00:00 2000 | Sat Jan 01 06:00:00 2000 | Sat Jan 01 09:00:00 2000 Sat Jan 01 12:00:00 2000 | Sat Jan 01 18:00:00 2000 | Sat Jan 01 18:00:00 2000 -- test date SELECT time_bucket_gapfill(INTERVAL '1w',time,DATE '2000-01-01',DATE '2000-02-10'), min(time) FROM (VALUES (DATE '2000-01-08'),(DATE '2000-01-22')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+------------ 12-27-1999 | 01-03-2000 | 01-08-2000 01-10-2000 | 01-17-2000 | 01-22-2000 01-24-2000 | 01-31-2000 | 02-07-2000 | -- test grouping by non-time columns SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test grouping by non-time columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) WHERE false GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- -- test duplicate columns in GROUP BY SELECT time_bucket_gapfill(1,time,0,5) as time, id, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,2,3 ORDER BY 2,1; time | id | id | m ------+----+----+--- 0 | 1 | 1 | 1 | 1 | 1 | 1 2 | 1 | 1 | 3 | 1 | 1 | 4 | 1 | 1 | 0 | 2 | 2 | 1 | 2 | 2 | 2 | 2 | 2 | 2 3 | 2 | 2 | 4 | 2 | 2 | -- test grouping by columns not in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY id,1; time | m ------+--- 0 | 1 | 1 2 | 3 | 4 | 0 | 1 | 2 | 2 3 | 4 | -- test grouping by non-time columns with text columns SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 1 | blue | 1 2 | blue | 3 | blue | 4 | blue | 0 | red | 1 | red | 2 | red | 2 3 | red | 4 | red | -- test grouping by non-time columns with text columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) WHERE false GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- --- test insert into SELECT CREATE TABLE gapfill_insert_test(id INT); INSERT INTO gapfill_insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM gapfill_insert_test; id ---- 1 2 3 4 DROP TABLE gapfill_insert_test; -- test join SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'red',1),(2,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | m | m ------+-------+---+--- 0 | blue | | 1 | blue | | 2 | blue | 2 | 3 | blue | | 4 | blue | | 2 0 | red | | 1 | red | 1 | 2 | red | | 3 | red | | 1 4 | red | | -- test join with locf SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as locf FROM (VALUES (0,'red',1),(0,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | locf | m ------+-------+------+--- 0 | blue | 2 | 1 | blue | 2 | 2 | blue | 2 | 3 | blue | 2 | 4 | blue | 2 | 2 0 | red | 1 | 1 | red | 1 | 2 | red | 1 | 3 | red | 1 | 1 4 | red | 1 | 1 -- test locf SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in resultset SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=NULL) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 -- test locf with NULLs in resultset and treat_null_as_missing SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in first row of resultset and treat_null_as_missing with lookup query SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false, prev := (SELECT 100)) AS v1, locf(min(value),treat_null_as_missing:=true, prev := (SELECT 100)) AS v2 FROM (values (0,NULL),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | v1 | v2 ------+----+----- 0 | | 100 10 | | 100 20 | | 100 30 | | 100 40 | | 100 50 | 6 | 6 -- test locf with NULLs in resultset and treat_null_as_missing with resort SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1 DESC; time | value ------+------- 50 | 6 40 | 3 30 | 3 20 | 3 10 | 9 0 | -- test locf with constants SELECT time_bucket_gapfill(1,time,0,5), 2, locf(min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | ?column? | locf ---------------------+----------+------ 0 | 2 | 1 1 | 2 | 1 2 | 2 | 1 3 | 2 | 1 4 | 2 | 2 -- test expressions inside locf SELECT time_bucket_gapfill(1,time,0,5), locf(min(value)), locf(4), locf(4 + min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | locf | locf | locf ---------------------+------+------+------ 0 | 1 | 4 | 5 1 | 1 | 4 | 5 2 | 1 | 4 | 5 3 | 1 | 4 | 5 4 | 2 | 4 | 6 -- test locf with out of boundary lookup SELECT time_bucket_gapfill(10,time,0,70) AS time, locf(min(value),(SELECT 100)) AS value FROM (values (20,9),(40,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 100 10 | 100 20 | 9 30 | 9 40 | 6 50 | 6 60 | 6 -- test locf with different datatypes SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1)) AS text, locf(min(v2)) AS "int[]", locf(min(v3)) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test locf with different datatypes and treat_null_as_missing SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1),treat_null_as_missing:=true) AS text, locf(min(v2),treat_null_as_missing:=true) AS "int[]", locf(min(v3),treat_null_as_missing:=true) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (2,NULL,NULL,NULL), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test interpolate SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(value)) AS value FROM (values (0,1),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 1 10 | 2 20 | 3 30 | 4 40 | 5 50 | 6 -- test interpolate with NULL values SELECT time_bucket_gapfill(1,time,0,5) AS time, interpolate(avg(temp)) AS temp FROM (VALUES (0,0),(2,NULL),(5,5)) v(time,temp) GROUP BY 1; time | temp ------+------ 0 | 0 1 | 2 | 3 | 4 | 5 | 5 -- test interpolate datatypes SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (0,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(50,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- 0 | -3 | -3 | -3 | -3 | -3 10 | -2 | -2 | -2 | -1.8 | -1.8 20 | -1 | -1 | -1 | -0.6 | -0.6 30 | 1 | 1 | 1 | 0.6 | 0.6 40 | 2 | 2 | 2 | 1.8 | 1.8 50 | 3 | 3 | 3 | 3 | 3 -- test interpolate datatypes with negative time SELECT time_bucket_gapfill(10,time,-40,30) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (-40,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(20,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- -40 | -3 | -3 | -3 | -3 | -3 -30 | -2 | -2 | -2 | -2 | -2 -20 | -1 | -1 | -1 | -1 | -1 -10 | 0 | 0 | 0 | 0 | 0 0 | 1 | 1 | 1 | 1 | 1 10 | 2 | 2 | 2 | 2 | 2 20 | 3 | 3 | 3 | 3 | 3 -- test interpolate with multiple groupings SELECT time_bucket_gapfill(5,time,0,11), device, interpolate(min(v1),(SELECT (-10,-10)),(SELECT (20,10))) FROM (VALUES (5,1,0),(5,2,0)) as v(time,device,v1) GROUP BY 1,2 ORDER BY 2,1; time_bucket_gapfill | device | interpolate ---------------------+--------+------------- 0 | 1 | -3 5 | 1 | 0 10 | 1 | 3 0 | 2 | -3 5 | 2 | 0 10 | 2 | 3 -- test cte with gap filling in outer query WITH data AS ( SELECT * FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) ) SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM data GROUP BY 1,id; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test cte with gap filling in inner query WITH gapfill AS ( SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ) SELECT * FROM gapfill; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test window functions SELECT time_bucket_gapfill(10,time,0,60), interpolate(min(time)), lag(min(time)) OVER () FROM (VALUES (0),(50)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | lag ---------------------+-------------+----- 0 | 0 | 10 | 10 | 0 20 | 20 | 30 | 30 | 40 | 40 | 50 | 50 | -- test window functions with multiple windows SELECT time_bucket_gapfill(1,time,0,10), interpolate(min(time)), row_number() OVER (), locf(min(time)), sum(interpolate(min(time))) OVER (ROWS 1 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 2 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 3 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 4 PRECEDING) FROM (VALUES (0),(9)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | row_number | locf | sum | sum | sum | sum ---------------------+-------------+------------+------+-----+-----+-----+----- 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 1 | 1 | 2 | 0 | 1 | 1 | 1 | 1 2 | 2 | 3 | 0 | 3 | 3 | 3 | 3 3 | 3 | 4 | 0 | 5 | 6 | 6 | 6 4 | 4 | 5 | 0 | 7 | 9 | 10 | 10 5 | 5 | 6 | 0 | 9 | 12 | 14 | 15 6 | 6 | 7 | 0 | 11 | 15 | 18 | 20 7 | 7 | 8 | 0 | 13 | 18 | 22 | 25 8 | 8 | 9 | 0 | 15 | 21 | 26 | 30 9 | 9 | 10 | 9 | 17 | 24 | 30 | 35 -- test window functions with constants SELECT time_bucket_gapfill(1,time,0,5), min(time), 4 as c, lag(min(time)) OVER () FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | c | lag ---------------------+-----+---+----- 0 | | 4 | 1 | 1 | 4 | 2 | 2 | 4 | 1 3 | 3 | 4 | 2 4 | | 4 | 3 --test window functions with locf SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, locf(min(time)) AS locf, lag(locf(min(time))) over () AS lag_locf, lead(locf(min(time))) over () AS lead_locf FROM (VALUES (1),(2)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | locf | lag_locf | lead_locf ---------------------+-----+---------+----------+------+----------+----------- 0 | | | 1 | | | 1 1 | 1 | | 2 | 1 | | 2 2 | 2 | 1 | | 2 | 1 | 2 3 | | 2 | | 2 | 2 | 2 4 | | | | 2 | 2 | --test window functions with interpolate SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, lead(interpolate(min(time))) over () AS lead_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | interpolate | lag_interpolate | lead_interpolate ---------------------+-----+---------+----------+-------------+-----------------+------------------ 0 | | | 1 | | | 1 1 | 1 | | | 1 | | 2 2 | | 1 | 3 | 2 | 1 | 3 3 | 3 | | | 3 | 2 | 4 | | 3 | | | 3 | --test window functions with expressions SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, 1 + lag(min(time)) over () AS lag_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, 1 + lag(interpolate(min(time))) over () AS lag_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lag_min | interpolate | lag_interpolate | lag_interpolate ---------------------+-----+---------+---------+-------------+-----------------+----------------- 0 | | | | | | 1 | 1 | | | 1 | | 2 | | 1 | 2 | 2 | 1 | 2 3 | 3 | | | 3 | 2 | 3 4 | | 3 | 4 | | 3 | 4 --test row_number/rank/percent_rank/... window functions with gapfill reference SELECT time_bucket_gapfill(1,time,0,5), ntile(2) OVER () AS ntile_2, ntile(3) OVER () AS ntile_3, ntile(5) OVER () AS ntile_5, row_number() OVER (), cume_dist() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), rank() OVER (), rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), percent_rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)) FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | ntile_2 | ntile_3 | ntile_5 | row_number | cume_dist | rank | rank | percent_rank ---------------------+---------+---------+---------+------------+-----------+------+------+-------------- 0 | 1 | 1 | 1 | 1 | 0.2 | 1 | 1 | 0 1 | 1 | 1 | 2 | 2 | 0.4 | 1 | 2 | 0.25 2 | 1 | 2 | 3 | 3 | 0.6 | 1 | 3 | 0.5 3 | 2 | 2 | 4 | 4 | 0.8 | 1 | 4 | 0.75 4 | 2 | 3 | 5 | 5 | 1 | 1 | 5 | 1 -- test first_value/last_value/nth_value SELECT time_bucket_gapfill(1,time,0,5), first_value(min(time)) OVER (), nth_value(min(time),3) OVER (), last_value(min(time)) OVER () FROM (VALUES (0),(2),(5)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | nth_value | last_value ---------------------+-------------+-----------+------------ 0 | 0 | 2 | 5 1 | 0 | 2 | 5 2 | 0 | 2 | 5 3 | 0 | 2 | 5 4 | 0 | 2 | 5 5 | 0 | 2 | 5 -- test window functions with PARTITION BY SELECT time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (), row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | row_number | row_number ------+-------+------------+------------ 0 | blue | 1 | 1 1 | blue | 2 | 2 2 | blue | 3 | 3 3 | blue | 4 | 4 4 | blue | 5 | 5 0 | red | 6 | 1 1 | red | 7 | 2 2 | red | 8 | 3 3 | red | 9 | 4 4 | red | 10 | 5 -- test multiple windows \set ON_ERROR_STOP 0 SELECT time_bucket_gapfill(1,time,0,11), first_value(interpolate(min(time))) OVER (ROWS 1 PRECEDING), interpolate(min(time)), last_value(interpolate(min(time))) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM (VALUES (0),(10)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | interpolate | last_value ---------------------+-------------+-------------+------------ 0 | 0 | 0 | 1 1 | 0 | 1 | 2 2 | 1 | 2 | 3 3 | 2 | 3 | 4 4 | 3 | 4 | 5 5 | 4 | 5 | 6 6 | 5 | 6 | 7 7 | 6 | 7 | 8 8 | 7 | 8 | 9 9 | 8 | 9 | 10 10 | 9 | 10 | 10 -- test reorder SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 1,id; time | id | m ------+----+--- 0 | 1 | 0 | 2 | 1 | 1 | 1 1 | 2 | 2 | 1 | 2 | 2 | 2 3 | 1 | 3 | 2 | 4 | 1 | 4 | 2 | -- test order by locf SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | locf ---------------------+------ 2 | 2 3 | 3 4 | 3 5 | 3 1 | -- test order by interpolate SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | interpolate ---------------------+------------- 4 | 5 | 1 | 1 2 | 2 3 | 3 SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | -- test queries on hypertable -- test locf and interpolate together SELECT time_bucket_gapfill(interval '1h',time,timestamptz '2018-01-01 05:00:00-8', timestamptz '2018-01-01 07:00:00-8'), device_id, locf(avg(v1)) AS locf_v1, locf(min(v2)) AS locf_v2, interpolate(avg(v1)) AS interpolate_v1, interpolate(avg(v2)) AS interpolate_v2 FROM metrics_tstz GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | locf_v1 | locf_v2 | interpolate_v1 | interpolate_v2 ------------------------------+-----------+---------+---------+----------------+---------------- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 06:00:00 2018 PST | 1 | 0.5 | 10 | 0.25 | 5 Mon Jan 01 06:00:00 2018 PST | 2 | 0.7 | 20 | 1.05 | 30 Mon Jan 01 06:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz) < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 -- interpolation with correlated subquery lookup before interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 3:00 PST'::timestamptz, '2018-01-01 8:00 PST'::timestamptz), device_id, interpolate( avg(v1), (SELECT (time,0.5::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time DESC LIMIT 1) ), avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 03:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 04:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 -- interpolation with correlated subquery lookup after interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 5:00 PST'::timestamptz, '2018-01-01 9:00 PST'::timestamptz), device_id, interpolate( avg(v1), next=>(SELECT (time,v2::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time LIMIT 1) ),avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 08:00:00 2018 PST | 1 | -5 | \set ON_ERROR_STOP 0 -- bucket_width non simple expression SELECT time_bucket_gapfill(t,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression -- no start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- no start and no usable time constraints SELECT time_bucket_gapfill(1,t,finish:=1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression -- NULL start and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression -- no finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with column reference on right side SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > t AND t < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with cast SELECT time_bucket_gapfill(1,t1::int8) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 >= 1 AND t1 <= 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with multiple column references SELECT time_bucket_gapfill(1,t1+t2) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 1 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL start in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END AND t1 < 4 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL finish in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as start argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as finish argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,NULL,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- time_bucket_gapfill with constraints ORed SELECT time_bucket_gapfill(1::int8,t::int8) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 OR t < 3 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 -- int32 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- same query with less or equal as finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t <= 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 3 -- int32 time_bucket_gapfill with start column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE -1 < t AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 -- int32 time_bucket_gapfill with finish column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= 0 AND 3 >= t GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 -- int16 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int2,t) FROM (VALUES (1::int2),(2::int2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- int64 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int8,t) FROM (VALUES (1::int8),(2::int8)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- date time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('1d'::interval,t) FROM (VALUES ('1999-12-30'::date),('2000-01-01'::date)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill --------------------- 12-29-1999 12-30-1999 12-31-1999 01-01-2000 01-02-2000 -- timestamp time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamp),('2000-01-01'::timestamp)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill -------------------------- Wed Dec 29 00:00:00 1999 Wed Dec 29 12:00:00 1999 Thu Dec 30 00:00:00 1999 Thu Dec 30 12:00:00 1999 Fri Dec 31 00:00:00 1999 Fri Dec 31 12:00:00 1999 Sat Jan 01 00:00:00 2000 Sat Jan 01 12:00:00 2000 Sun Jan 02 00:00:00 2000 Sun Jan 02 12:00:00 2000 -- timestamptz time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Tue Dec 28 16:00:00 1999 PST Wed Dec 29 04:00:00 1999 PST Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with more complex expression SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with different datatype in finish constraint SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03'::date GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- time_bucket_gapfill with now() as start SELECT time_bucket_gapfill('1h'::interval,t) FROM (VALUES (now()),(now())) v(t) WHERE t >= now() AND t < now() - '1h'::interval GROUP BY 1; time_bucket_gapfill --------------------- -- time_bucket_gapfill with multiple constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 and t>1 AND t <=4 AND length(version()) > 0 GROUP BY 1; time_bucket_gapfill --------------------- 2 -- int32 time_bucket_gapfill with greater for start SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > -2 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- test DISTINCT SELECT DISTINCT ON (color) time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 0 | red | -- test DISTINCT with window functions SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER () FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 6 1 | red | 7 2 | red | 8 3 | red | 9 4 | red | 10 -- test DISTINCT with window functions and PARTITION BY SELECT DISTINCT ON (color,row_number() OVER (PARTITION BY color)) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test DISTINCT with window functions not in targetlist SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test column references SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test with Nested Loop SELECT l.id, bucket, data_value FROM (VALUES (1), (2), (3), (4)) a(id) INNER JOIN LATERAL ( SELECT b.id id, time_bucket_gapfill('1'::int, time, start=>'1'::int, finish=> '5'::int) bucket, locf(last(data, time)) data_value FROM (VALUES (1, 1, 1), (1, 4, 4), (2, 1, -1), (2, 4, -4)) b(id, time, data) WHERE a.id = b.id GROUP BY b.id, bucket ) as l on (true); id | bucket | data_value ----+--------+------------ 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 1 | 4 | 4 2 | 1 | -1 2 | 2 | -1 2 | 3 | -1 2 | 4 | -4 -- test prepared statement PREPARE prep_gapfill AS SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(value)) FROM (VALUES (1,1),(2,2)) v(time,value) GROUP BY 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 DEALLOCATE prep_gapfill; -- test column references with TIME_COLUMN last SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test expressions on GROUP BY columns SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, length(color), time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,5; row_number | locf | color | length | time ------------+------+-------+--------+------ 1 | | blue | 4 | 0 2 | 1 | blue | 4 | 1 3 | 1 | blue | 4 | 2 4 | 1 | blue | 4 | 3 5 | 1 | blue | 4 | 4 1 | | red | 3 | 0 2 | | red | 3 | 1 3 | 2 | red | 3 | 2 4 | 2 | red | 3 | 3 5 | 2 | red | 3 | 4 -- test columns derived from GROUP BY columns with cast SELECT time_bucket_gapfill(1,time,0,5) as time, device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | device_id ------+----------- 0 | 1 1 | 1 2 | 1 3 | 1 4 | 1 0 | 2 1 | 2 2 | 2 3 | 2 4 | 2 -- test columns derived from GROUP BY columns with expression SELECT time_bucket_gapfill(1,time,0,5) as time, 'Device ' || device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | ?column? ------+---------- 0 | Device 1 1 | Device 1 2 | Device 1 3 | Device 1 4 | Device 1 0 | Device 2 1 | Device 2 2 | Device 2 3 | Device 2 4 | Device 2 --test interpolation with big differences in values (test overflows in calculations) --we use the biggest possible difference in time(x) and the value(y). --For bigints we also test values of smaller than bigintmax/min to avoid --the symmetry where x=y (which catches more errors) SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset SELECT time_bucket_gapfill(1,time,0,1) AS time, interpolate(min(s)) AS "smallint", interpolate(min(i)) AS "int", interpolate(min(b)) AS "bigint", interpolate(min(b2)) AS "bigint2", interpolate(min(d)) AS "double" FROM (values (:big_int_min,(-32768)::smallint,(-2147483648)::int,:big_int_min,-2147483648::bigint, '-Infinity'::double precision), (:big_int_max, 32767::smallint, 2147483647::int,:big_int_max, 2147483647::bigint, 'Infinity'::double precision)) v(time,s,i,b,b2,d) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | bigint2 | double ----------------------+----------+-------------+----------------------+-------------+----------- -9223372036854775808 | -32768 | -2147483648 | -9223372036854775808 | -2147483648 | -Infinity 0 | 0 | 0 | 0 | 0 | Infinity 9223372036854775807 | 32767 | 2147483647 | 9223372036854775807 | 2147483647 | Infinity -- issue #2232: This query used to trigger error "could not find -- pathkey item to sort" due to a corrupt query plan SELECT time_bucket_gapfill('1 h', time) AS time, locf(sum(v1)) AS v1_sum, interpolate(sum(v2)) AS v2_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v2_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 06:00:00 2018 PST | 2.1 | 65 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 Mon Jan 01 04:00:00 2018 PST | | -- query without gapfill: SELECT time_bucket('1 h', time) AS time, sum(v1) AS v1_sum, sum(v2) AS v1_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v1_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 -- query to show original data SELECT * FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' ORDER BY 1 DESC, 2; time | device_id | v1 | v2 ------------------------------+-----------+-----+---- Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 -- issue #3048 -- test gapfill/hashagg planner interaction -- this used to produce a plan without gapfill node EXPLAIN (buffers off, costs off) SELECT time_bucket_gapfill('52w', time, start:='2000-01-01', finish:='2000-01-10') AS time, sum(v1) AS v1_sum FROM metrics GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- issue #3834 -- test projection handling in gapfill CREATE TABLE i3834(time timestamptz NOT NULL, ship_id int, value float); SELECT table_name FROM create_hypertable('i3834','time'); table_name ------------ i3834 INSERT INTO i3834 VALUES ('2020-12-01 14:05:00+01',1,3.123), ('2020-12-01 14:05:00+01',2,4.123), ('2020-12-01 14:05:00+01',3,5.123); SELECT time_bucket_gapfill('30000 ms'::interval, time) AS time, ship_id, interpolate (avg(value)), 'speedlog' AS source FROM i3834 WHERE ship_id IN (1, 2) AND time >= '2020-12-01 14:05:00+01' AND time < '2020-12-01 14:10:00+01' GROUP BY 1,2; time | ship_id | interpolate | source ------------------------------+---------+-------------+---------- Tue Dec 01 05:05:00 2020 PST | 1 | 3.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 1 | | speedlog Tue Dec 01 05:06:00 2020 PST | 1 | | speedlog Tue Dec 01 05:06:30 2020 PST | 1 | | speedlog Tue Dec 01 05:07:00 2020 PST | 1 | | speedlog Tue Dec 01 05:07:30 2020 PST | 1 | | speedlog Tue Dec 01 05:08:00 2020 PST | 1 | | speedlog Tue Dec 01 05:08:30 2020 PST | 1 | | speedlog Tue Dec 01 05:09:00 2020 PST | 1 | | speedlog Tue Dec 01 05:09:30 2020 PST | 1 | | speedlog Tue Dec 01 05:05:00 2020 PST | 2 | 4.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 2 | | speedlog Tue Dec 01 05:06:00 2020 PST | 2 | | speedlog Tue Dec 01 05:06:30 2020 PST | 2 | | speedlog Tue Dec 01 05:07:00 2020 PST | 2 | | speedlog Tue Dec 01 05:07:30 2020 PST | 2 | | speedlog Tue Dec 01 05:08:00 2020 PST | 2 | | speedlog Tue Dec 01 05:08:30 2020 PST | 2 | | speedlog Tue Dec 01 05:09:00 2020 PST | 2 | | speedlog Tue Dec 01 05:09:30 2020 PST | 2 | | speedlog DROP TABLE i3834; -- issue #1528 -- test float rounding for certain float values when start and end are identical SELECT time_bucket_gapfill('1min'::interval, ts::timestamptz, start:='2019-11-05 2:20', finish:='2019-11-05 2:30'), interpolate(avg(20266.959547::float4)) AS float4, interpolate(avg(20266.959547::float8)) AS float8 FROM (VALUES ('2019-11-05 2:20'), ('2019-11-05 2:30')) v (ts) GROUP BY 1; time_bucket_gapfill | float4 | float8 ------------------------------+-----------------+-------------- Tue Nov 05 02:20:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:21:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:22:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:23:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:24:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:25:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:26:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:27:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:28:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:29:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:30:00 2019 PST | 20266.958984375 | 20266.959547 -- check gapfill group change detection with TOASTed values CREATE TABLE gapfill_group_toast(time timestamptz NOT NULL, device text, value float); SELECT table_name FROM create_hypertable('gapfill_group_toast', 'time'); table_name --------------------- gapfill_group_toast INSERT INTO gapfill_group_toast SELECT generate_series('2022-06-01'::timestamptz, '2022-06-03'::timestamptz, '1min'::interval), '4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43', random(); ALTER TABLE gapfill_group_toast SET(timescaledb.compress, timescaledb.compress_segmentby = 'device'); SELECT count(compress_chunk(c)) FROM show_chunks('gapfill_group_toast') c; count ------- 2 SELECT time_bucket_gapfill('1 day', time), device FROM gapfill_group_toast WHERE time >= '2022-06-01' AND time <= '2022-06-02' GROUP BY 1,2; time_bucket_gapfill | device ------------------------------+------------------------------------------------------------------ Tue May 31 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 Wed Jun 01 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 DROP TABLE gapfill_group_toast; -- test bucketing by month SELECT time_bucket_gapfill('2 month'::interval, ts, '2000-01-01'::timestamptz,'2001-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SELECT time_bucket_gapfill('1 year'::interval, ts, '2000-01-01'::timestamptz,'2003-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Sun Dec 31 16:00:00 2000 PST Mon Dec 31 16:00:00 2001 PST Tue Dec 31 16:00:00 2002 PST SELECT time_bucket_gapfill('1 century'::interval, ts, '1900-01-01'::timestamptz,'2103-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sun Dec 31 16:00:00 1899 PST Fri Dec 31 16:00:00 1999 PST Thu Dec 31 16:00:00 2099 PST -- test bucketing with timezone SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 15:00:00 1999 PST Tue Feb 29 15:00:00 2000 PST Sun Apr 30 15:00:00 2000 PDT Fri Jun 30 15:00:00 2000 PDT Thu Aug 31 15:00:00 2000 PDT Tue Oct 31 15:00:00 2000 PST Sun Dec 31 15:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, current_setting('timezone'), '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sat Jan 01 00:00:00 2000 PST Wed Mar 01 00:00:00 2000 PST Mon May 01 00:00:00 2000 PDT Sat Jul 01 00:00:00 2000 PDT Fri Sep 01 00:00:00 2000 PDT Wed Nov 01 00:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, 'UTC', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SET timezone TO 'Europe/Berlin'; SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------- Sat Jan 01 00:00:00 2000 CET Wed Mar 01 00:00:00 2000 CET Mon May 01 00:00:00 2000 CEST Sat Jul 01 00:00:00 2000 CEST Fri Sep 01 00:00:00 2000 CEST Wed Nov 01 00:00:00 2000 CET RESET timezone; -- Test gapfill with arrays (#5981) SELECT time_bucket_gapfill(5, ts, 1, 100) as ts, int_arr, locf(last(value, ts)) FROM ( SELECT ARRAY[1,2,3,4]::int[] as int_arr, x as ts, x+500000 as value FROM generate_series(1, 10, 100) as x ) t GROUP BY 1, 2; ts | int_arr | locf ----+-----------+-------- 0 | {1,2,3,4} | 500001 5 | {1,2,3,4} | 500001 10 | {1,2,3,4} | 500001 15 | {1,2,3,4} | 500001 20 | {1,2,3,4} | 500001 25 | {1,2,3,4} | 500001 30 | {1,2,3,4} | 500001 35 | {1,2,3,4} | 500001 40 | {1,2,3,4} | 500001 45 | {1,2,3,4} | 500001 50 | {1,2,3,4} | 500001 55 | {1,2,3,4} | 500001 60 | {1,2,3,4} | 500001 65 | {1,2,3,4} | 500001 70 | {1,2,3,4} | 500001 75 | {1,2,3,4} | 500001 80 | {1,2,3,4} | 500001 85 | {1,2,3,4} | 500001 90 | {1,2,3,4} | 500001 95 | {1,2,3,4} | 500001 -- Test gapfill is aligned with non-gapfill time_bucket -- when using different timezones and month bucketing CREATE TABLE month_timezone(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('month_timezone','time'); table_name ---------------- month_timezone INSERT INTO month_timezone VALUES ('2023-03-01 14:05:00+01', 3.123), ('2023-04-01 14:05:00+01',4.123), ('2023-05-01 14:05:00+01', 5.123); SELECT time_bucket_gapfill('1 month'::interval, time, 'Europe/Berlin', '2023-01-01', '2023-07-01') AS time, sum(value) FROM month_timezone GROUP BY 1; time | sum ------------------------------+------- Sat Dec 31 15:00:00 2022 PST | Tue Jan 31 15:00:00 2023 PST | Tue Feb 28 15:00:00 2023 PST | 3.123 Fri Mar 31 15:00:00 2023 PDT | 4.123 Sun Apr 30 15:00:00 2023 PDT | 5.123 Wed May 31 15:00:00 2023 PDT | Fri Jun 30 15:00:00 2023 PDT | -- Test gapfill respects DST changes when generating timestamps (#6344) SELECT time_bucket_gapfill('1 month', time, 'awst','2023-01-01', '2023-07-01' ) AS month, sum(value) AS sum FROM month_timezone GROUP BY 1; month | sum ------------------------------+------- Sat Dec 31 08:00:00 2022 PST | Tue Jan 31 08:00:00 2023 PST | Tue Feb 28 08:00:00 2023 PST | 3.123 Fri Mar 31 09:00:00 2023 PDT | 4.123 Sun Apr 30 09:00:00 2023 PDT | 5.123 Wed May 31 09:00:00 2023 PDT | Fri Jun 30 09:00:00 2023 PDT | DROP TABLE month_timezone; -- Test gapfill with additional group pathkeys added for optimization (#6396) CREATE TABLE stocks_real_time ( time TIMESTAMPTZ NOT NULL, symbol TEXT NOT NULL, price DOUBLE PRECISION NULL, day_volume INT NULL ); INSERT INTO stocks_real_time VALUES (NOW(), 's1', 70.0, 50), (NOW(), 's2', 66.5, 60), (NOW(), 's3', 77.0, 65); SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1; day | symbol_count ------------------------------+-------------- Thu Nov 30 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Sat Dec 09 16:00:00 2023 PST | SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1 ORDER BY 1 DESC; day | symbol_count ------------------------------+-------------- Sat Dec 09 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Thu Nov 30 16:00:00 2023 PST | DROP TABLE stocks_real_time; SET timezone TO 'Europe/Berlin'; -- check dst switching is handled correctly #6788 SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 03:00:00 2024 CEST SELECT time_bucket_gapfill('30 minutes', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 01:30:00 2024 CET Sun Mar 31 03:00:00 2024 CEST Sun Mar 31 03:30:00 2024 CEST SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-10-26T23:00Z', '2024-10-27T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Oct 27 01:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CET RESET timezone; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/gapfill-16.out������������������������������������������0000664�0000000�0000000�00000602544�15100345067�0023311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' -- we want to see error details in the output \set VERBOSITY default CREATE TABLE gapfill_plan_test(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('gapfill_plan_test','time',chunk_time_interval=>'4 weeks'::interval); table_name ------------------- gapfill_plan_test INSERT INTO gapfill_plan_test SELECT generate_series('2018-01-01'::timestamptz,'2018-04-01'::timestamptz,'1m'::interval), 1.0; -- simple example :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sorting :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sort direction :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1 DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) DESC -> Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) NULLS FIRST -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now()) -> Values Scan on "*VALUES*" -- test order by aggregate function :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2,1; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)), (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test query without order by :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test parallel query :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), avg(value) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- make sure we can run gapfill in parallel workers -- ensure this plan runs in parallel :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; --- QUERY PLAN --- Limit -> Sort Sort Key: (interpolate(avg(gapfill_plan_test.value), NULL::record, NULL::record)) -> Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- actually run a parallel gapfill SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; time_bucket_gapfill | interpolate ------------------------------+------------- Mon Jan 01 00:00:00 2018 PST | 1 -- test sort optimizations -- test sort optimization with single member order by, -- should use index scan (no GapFill node for this one since we're not gapfilling) :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk SET max_parallel_workers_per_gather TO 0; -- test sort optimizations with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimizations with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk RESET max_parallel_workers_per_gather; CREATE INDEX gapfill_plan_test_indx ON gapfill_plan_test(value, time); -- test sort optimization with ordering by multiple columns and time_bucket_gapfill not last, -- must not use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)), gapfill_plan_test.value -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimization with ordering by multiple columns and time_bucket as last member, -- should use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 2,1; --- QUERY PLAN --- Incremental Sort Sort Key: gapfill_plan_test.value, (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) Presorted Key: gapfill_plan_test.value -> Result -> Merge Append Sort Key: gapfill_plan_test.value -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk DROP TABLE gapfill_plan_test; \set METRICS metrics_int -- All test against table :METRICS first \set ON_ERROR_STOP 0 -- inverse of previous test query to confirm an error is actually thrown SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time = 5 GROUP BY 1,2,3 ORDER BY 2,3,1; ERROR: division by zero -- test window functions with multiple column references SELECT time_bucket_gapfill(1,time,1,2), first(min(time),min(time)) OVER () FROM :METRICS GROUP BY 1; ERROR: window functions with multiple column references not supported -- test with unsupported operator SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time =0 AND time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test with 2 tables and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test inner join and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time WHERE m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test outer join with constraints in join condition -- not usable as start/stop SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 LEFT OUTER JOIN :METRICS m2 ON m1.time=m2.time AND m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 \ir include/gapfill_metrics_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test locf lookup query does not trigger when not needed -- -- 1/(SELECT 0) will throw an error in the lookup query but in order to not -- always trigger evaluation it needs to be correlated otherwise postgres will -- always run it once even if the value is never used SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | locf3 ------+-----------+-----------+------- 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 -- test locf with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value)::int,23) AS locf1, locf(min(value)::int,(SELECT 42)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 1 | | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and "wrong order" SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value),23::float) AS locf1, locf(min(value),(SELECT 42::float)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 1,2,3; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 1 | | 5 | 5 | 5 | 5 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and window functions SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)), sum(locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1))) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3; time | device_id | sensor_id | locf | sum ------+-----------+-----------+------+------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 5 | 10 10 | 1 | 1 | 5 | 10 0 | 1 | 2 | -100 | -100 5 | 1 | 2 | 10 | -90 10 | 1 | 2 | 10 | 20 -- test JOINs SELECT time_bucket_gapfill(1,time,0,5) as time, device_id, d.name, sensor_id, s.name, avg(m.value) FROM :METRICS m INNER JOIN devices d USING(device_id) INNER JOIN sensors s USING(sensor_id) WHERE time BETWEEN 0 AND 5 GROUP BY 1,2,3,4,5; time | device_id | name | sensor_id | name | avg ------+-----------+----------+-----------+----------+----- 0 | 1 | Device 1 | 1 | Sensor 1 | 5 1 | 1 | Device 1 | 1 | Sensor 1 | 2 | 1 | Device 1 | 1 | Sensor 1 | 3 | 1 | Device 1 | 1 | Sensor 1 | 4 | 1 | Device 1 | 1 | Sensor 1 | 0 | 1 | Device 1 | 2 | Sensor 2 | 1 | 1 | Device 1 | 2 | Sensor 2 | 2 | 1 | Device 1 | 2 | Sensor 2 | 3 | 1 | Device 1 | 2 | Sensor 2 | 4 | 1 | Device 1 | 2 | Sensor 2 | 5 | 1 | Device 1 | 2 | Sensor 2 | 10 -- test interpolate with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), interpolate(min(value)) AS ip, interpolate(min(value),(-5,-5.0::float),(15,20.0::float)) AS ip1, interpolate(min(value),(SELECT (-10,-10.0::float)),(SELECT (15,20.0::float))) AS ip2, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) AS ip3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | ip | ip1 | ip2 | ip3 ------+-----------+-----------+-----+----+-----+------------------+------------------ 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | | 10 | 10 | 4.75 10 | 1 | 1 | | | 15 | 15 | 4.5 0 | 1 | 2 | | | 2.5 | 3.33333333333333 | 4.76190476190476 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | | 15 | 15 | 4.21052631578947 -- test interpolate with correlated subquery and window function SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ), sum(interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) )) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | interpolate | sum ------+-----------+-----------+------------------+------------------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 4.75 | 9.75 10 | 1 | 1 | 4.5 | 9.25 0 | 1 | 2 | 4.76190476190476 | 4.76190476190476 5 | 1 | 2 | 10 | 14.7619047619048 10 | 1 | 2 | 4.21052631578947 | 14.2105263157895 -- test subqueries -- subqueries will alter the shape of the plan and top-level constraints -- might not end up in top-level of jointree SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 WHERE m1.time >=0 AND m1.time < 2 AND device_id IN (SELECT device_id FROM :METRICS) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test inner join with constraints in join condition SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time AND m2.time >=0 AND m2.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test actual table SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time >=0 AND time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with table alias SELECT time_bucket_gapfill(1,time) FROM :METRICS m WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with 2 tables SELECT time_bucket_gapfill(1,m.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test prepared statement with locf with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 DEALLOCATE prep_gapfill; -- test prepared statement with interpolate with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 DEALLOCATE prep_gapfill; -- test prepared statement with variable gapfill arguments PREPARE prep_gapfill(int,int,int) AS SELECT time_bucket_gapfill($1,time,$2,$3) AS time, device_id, sensor_id, min(value) FROM :METRICS m1 WHERE time >= $2 AND time < $3 AND device_id=1 AND sensor_id=1 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | DEALLOCATE prep_gapfill; -- Tests without tables -- test locf and interpolate call without gapfill SELECT locf(1); locf ------ 1 SELECT interpolate(1); interpolate ------------- 1 -- test locf and interpolate call with NULL input SELECT locf(NULL::int); locf ------ SELECT interpolate(NULL::bigint); interpolate ------------- \set ON_ERROR_STOP 0 -- test time_bucket_gapfill not top level function call SELECT 1 + time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: no top level time_bucket_gapfill in group by clause -- test locf with treat_null_as_missing not BOOL SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=1) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function locf(integer, treat_null_as_missing => integer) does not exist LINE 3: locf(min(time),treat_null_as_missing:=1) ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test locf with treat_null_as_missing not literal SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=random()>0) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid locf argument: treat_null_as_missing must be a BOOL literal -- test interpolate lookup query with 1 element in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT ROW(10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT ROW(10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with 3 elements in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with mismatching time datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10::float,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10::float,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate lookup query with mismatching value datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10::float))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10::float))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate with unsupported datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(text 'text') FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function interpolate(text) does not exist LINE 3: interpolate(text 'text') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. SELECT time_bucket_gapfill(1,time,1,11), interpolate(interval '1d') FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: function interpolate(interval) does not exist LINE 3: interpolate(interval '1d') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test multiple time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time,1,11),time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time_bucket_gapfill(1,time,1,11),1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested locf calls SELECT time_bucket_gapfill(1,time,1,11), locf(locf(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test nested interpolate calls SELECT time_bucket_gapfill(1,time,1,11), interpolate(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test mixed locf/interpolate calls SELECT time_bucket_gapfill(1,time,1,11), locf(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test window function inside locf SELECT time_bucket_gapfill(1,time,1,11), locf(avg(min(time)) OVER ()) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window functions must not be below locf -- test nested window functions -- prevented by postgres SELECT time_bucket_gapfill(1,time,1,11), avg(avg(min(time)) OVER ()) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window function calls cannot be nested LINE 3: avg(avg(min(time)) OVER ()) OVER () ^ -- test multiple window functions in single column SELECT time_bucket_gapfill(1,time,1,11), avg(min(time)) OVER () + avg(min(time)) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple window function calls per column not supported -- test locf not toplevel SELECT time_bucket_gapfill(1,time,1,11), 1 + locf(min(time)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: locf must be toplevel function call -- test locf inside aggregate SELECT time_bucket_gapfill(1,time,1,11), min(min(locf(time))) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: aggregate functions must be below locf -- test NULL args SELECT time_bucket_gapfill(NULL,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill(1,NULL,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill(1,time,NULL,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(1,time,1,NULL) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(NULL,time,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill('1day',NULL,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill('1day',time,NULL,'2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: timezone cannot be NULL -- test 0 bucket_width SELECT time_bucket_gapfill(0,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test negative bucket_width SELECT time_bucket_gapfill(-1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test subqueries as interval, start and stop (not supported atm) SELECT time_bucket_gapfill((SELECT 1),time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression SELECT time_bucket_gapfill(1,time,(SELECT 1),11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression SELECT time_bucket_gapfill(1,time,1,(SELECT 11)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression \set ON_ERROR_STOP 1 -- test time_bucket_gapfill without aggregation -- this will not trigger gapfilling SELECT time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time); time_bucket_gapfill --------------------- 1 2 SELECT time_bucket_gapfill(1,time,1,11), avg(time) OVER () FROM (VALUES (1),(2)) v(time); time_bucket_gapfill | avg ---------------------+-------------------- 1 | 1.5000000000000000 2 | 1.5000000000000000 -- test int int2/4/8 SELECT time_bucket_gapfill(1::int2,time::int2,0::int2,6::int2) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int4,time::int4,0::int4,6::int4) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int8,time::int8,0::int8,6::int8) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 -- test non-aligned bucket start SELECT time_bucket_gapfill(10,time,5,40) FROM (VALUES (11),(22)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 10 20 30 -- simple gapfill query SELECT time_bucket_gapfill(10,time,0,50) AS time, min(value) AS value FROM (values (-10,1),(10,2),(11,3),(12,4),(22,5),(30,6),(66,7)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- -10 | 1 0 | 10 | 2 20 | 5 30 | 6 40 | 60 | 7 -- test references to different columns SELECT time_bucket_gapfill(1,t,0,5) as t, min(t),max(t),min(v),max(v) FROM(VALUES (1,3),(2,5)) tb(t,v) GROUP BY 1 ORDER BY 1; t | min | max | min | max ---+-----+-----+-----+----- 0 | | | | 1 | 1 | 1 | 3 | 3 2 | 2 | 2 | 5 | 5 3 | | | | 4 | | | | -- test passing of values outside boundaries SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (-1),(1),(3),(6)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- -1 | -1 0 | 1 | 1 2 | 3 | 3 4 | 6 | 6 -- test gap fill before first row and after last row SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 1 2 | 2 3 | 3 4 | -- test gap fill without rows in resultset SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) WHERE false GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 2 | 3 | 4 | -- test coalesce SELECT time_bucket_gapfill(1,time,0,5), coalesce(min(time),0), coalesce(min(value),0), coalesce(min(value),7) FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | coalesce | coalesce | coalesce ---------------------+----------+----------+---------- 0 | 0 | 0 | 7 1 | 1 | 1 | 1 2 | 2 | 2 | 2 3 | 3 | 3 | 3 4 | 0 | 0 | 7 -- test case SELECT time_bucket_gapfill(1,time,0,5), min(time), CASE WHEN min(time) IS NOT NULL THEN min(time) ELSE -1 END, CASE WHEN min(time) IS NOT NULL THEN min(time) + 7 ELSE 0 END, CASE WHEN 1 = 1 THEN 1 ELSE 0 END FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | case | case | case ---------------------+-----+------+------+------ 0 | | -1 | 0 | 1 1 | 1 | 1 | 8 | 1 2 | 2 | 2 | 9 | 1 3 | 3 | 3 | 10 | 1 4 | | -1 | 0 | 1 -- test constants SELECT time_bucket_gapfill(1,time,0,5), min(time), min(time), 4 as c FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | min | c ---------------------+-----+-----+--- 0 | | | 4 1 | 1 | 1 | 4 2 | 2 | 2 | 4 3 | 3 | 3 | 4 4 | | | 4 -- test column reordering SELECT 1 as c1, '2' as c2, time_bucket_gapfill(1,time,0,5), 3.0 as c3, min(time), min(time), 4 as c4 FROM (VALUES (1),(2),(3)) v(time) GROUP BY 3 ORDER BY 3; c1 | c2 | time_bucket_gapfill | c3 | min | min | c4 ----+----+---------------------+-----+-----+-----+---- 1 | 2 | 0 | 3.0 | | | 4 1 | 2 | 1 | 3.0 | 1 | 1 | 4 1 | 2 | 2 | 3.0 | 2 | 2 | 4 1 | 2 | 3 | 3.0 | 3 | 3 | 4 1 | 2 | 4 | 3.0 | | | 4 -- test timestamptz SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMPTZ '2000-01-01',TIMESTAMPTZ '2000-01-02'), min(time) FROM (VALUES (TIMESTAMPTZ '2000-01-01 9:00:00'),(TIMESTAMPTZ '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ------------------------------+------------------------------ Fri Dec 31 22:00:00 1999 PST | Sat Jan 01 04:00:00 2000 PST | Sat Jan 01 09:00:00 2000 PST Sat Jan 01 10:00:00 2000 PST | Sat Jan 01 16:00:00 2000 PST | Sat Jan 01 18:00:00 2000 PST Sat Jan 01 22:00:00 2000 PST | -- test timestamp SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMP '2000-01-01',TIMESTAMP '2000-01-02'), min(time) FROM (VALUES (TIMESTAMP '2000-01-01 9:00:00'),(TIMESTAMP '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min --------------------------+-------------------------- Sat Jan 01 00:00:00 2000 | Sat Jan 01 06:00:00 2000 | Sat Jan 01 09:00:00 2000 Sat Jan 01 12:00:00 2000 | Sat Jan 01 18:00:00 2000 | Sat Jan 01 18:00:00 2000 -- test date SELECT time_bucket_gapfill(INTERVAL '1w',time,DATE '2000-01-01',DATE '2000-02-10'), min(time) FROM (VALUES (DATE '2000-01-08'),(DATE '2000-01-22')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+------------ 12-27-1999 | 01-03-2000 | 01-08-2000 01-10-2000 | 01-17-2000 | 01-22-2000 01-24-2000 | 01-31-2000 | 02-07-2000 | -- test grouping by non-time columns SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test grouping by non-time columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) WHERE false GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- -- test duplicate columns in GROUP BY SELECT time_bucket_gapfill(1,time,0,5) as time, id, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,2,3 ORDER BY 2,1; time | id | id | m ------+----+----+--- 0 | 1 | 1 | 1 | 1 | 1 | 1 2 | 1 | 1 | 3 | 1 | 1 | 4 | 1 | 1 | 0 | 2 | 2 | 1 | 2 | 2 | 2 | 2 | 2 | 2 3 | 2 | 2 | 4 | 2 | 2 | -- test grouping by columns not in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY id,1; time | m ------+--- 0 | 1 | 1 2 | 3 | 4 | 0 | 1 | 2 | 2 3 | 4 | -- test grouping by non-time columns with text columns SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 1 | blue | 1 2 | blue | 3 | blue | 4 | blue | 0 | red | 1 | red | 2 | red | 2 3 | red | 4 | red | -- test grouping by non-time columns with text columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) WHERE false GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- --- test insert into SELECT CREATE TABLE gapfill_insert_test(id INT); INSERT INTO gapfill_insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM gapfill_insert_test; id ---- 1 2 3 4 DROP TABLE gapfill_insert_test; -- test join SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'red',1),(2,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | m | m ------+-------+---+--- 0 | blue | | 1 | blue | | 2 | blue | 2 | 3 | blue | | 4 | blue | | 2 0 | red | | 1 | red | 1 | 2 | red | | 3 | red | | 1 4 | red | | -- test join with locf SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as locf FROM (VALUES (0,'red',1),(0,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | locf | m ------+-------+------+--- 0 | blue | 2 | 1 | blue | 2 | 2 | blue | 2 | 3 | blue | 2 | 4 | blue | 2 | 2 0 | red | 1 | 1 | red | 1 | 2 | red | 1 | 3 | red | 1 | 1 4 | red | 1 | 1 -- test locf SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in resultset SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=NULL) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 -- test locf with NULLs in resultset and treat_null_as_missing SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in first row of resultset and treat_null_as_missing with lookup query SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false, prev := (SELECT 100)) AS v1, locf(min(value),treat_null_as_missing:=true, prev := (SELECT 100)) AS v2 FROM (values (0,NULL),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | v1 | v2 ------+----+----- 0 | | 100 10 | | 100 20 | | 100 30 | | 100 40 | | 100 50 | 6 | 6 -- test locf with NULLs in resultset and treat_null_as_missing with resort SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1 DESC; time | value ------+------- 50 | 6 40 | 3 30 | 3 20 | 3 10 | 9 0 | -- test locf with constants SELECT time_bucket_gapfill(1,time,0,5), 2, locf(min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | ?column? | locf ---------------------+----------+------ 0 | 2 | 1 1 | 2 | 1 2 | 2 | 1 3 | 2 | 1 4 | 2 | 2 -- test expressions inside locf SELECT time_bucket_gapfill(1,time,0,5), locf(min(value)), locf(4), locf(4 + min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | locf | locf | locf ---------------------+------+------+------ 0 | 1 | 4 | 5 1 | 1 | 4 | 5 2 | 1 | 4 | 5 3 | 1 | 4 | 5 4 | 2 | 4 | 6 -- test locf with out of boundary lookup SELECT time_bucket_gapfill(10,time,0,70) AS time, locf(min(value),(SELECT 100)) AS value FROM (values (20,9),(40,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 100 10 | 100 20 | 9 30 | 9 40 | 6 50 | 6 60 | 6 -- test locf with different datatypes SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1)) AS text, locf(min(v2)) AS "int[]", locf(min(v3)) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test locf with different datatypes and treat_null_as_missing SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1),treat_null_as_missing:=true) AS text, locf(min(v2),treat_null_as_missing:=true) AS "int[]", locf(min(v3),treat_null_as_missing:=true) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (2,NULL,NULL,NULL), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test interpolate SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(value)) AS value FROM (values (0,1),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 1 10 | 2 20 | 3 30 | 4 40 | 5 50 | 6 -- test interpolate with NULL values SELECT time_bucket_gapfill(1,time,0,5) AS time, interpolate(avg(temp)) AS temp FROM (VALUES (0,0),(2,NULL),(5,5)) v(time,temp) GROUP BY 1; time | temp ------+------ 0 | 0 1 | 2 | 3 | 4 | 5 | 5 -- test interpolate datatypes SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (0,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(50,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- 0 | -3 | -3 | -3 | -3 | -3 10 | -2 | -2 | -2 | -1.8 | -1.8 20 | -1 | -1 | -1 | -0.6 | -0.6 30 | 1 | 1 | 1 | 0.6 | 0.6 40 | 2 | 2 | 2 | 1.8 | 1.8 50 | 3 | 3 | 3 | 3 | 3 -- test interpolate datatypes with negative time SELECT time_bucket_gapfill(10,time,-40,30) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (-40,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(20,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- -40 | -3 | -3 | -3 | -3 | -3 -30 | -2 | -2 | -2 | -2 | -2 -20 | -1 | -1 | -1 | -1 | -1 -10 | 0 | 0 | 0 | 0 | 0 0 | 1 | 1 | 1 | 1 | 1 10 | 2 | 2 | 2 | 2 | 2 20 | 3 | 3 | 3 | 3 | 3 -- test interpolate with multiple groupings SELECT time_bucket_gapfill(5,time,0,11), device, interpolate(min(v1),(SELECT (-10,-10)),(SELECT (20,10))) FROM (VALUES (5,1,0),(5,2,0)) as v(time,device,v1) GROUP BY 1,2 ORDER BY 2,1; time_bucket_gapfill | device | interpolate ---------------------+--------+------------- 0 | 1 | -3 5 | 1 | 0 10 | 1 | 3 0 | 2 | -3 5 | 2 | 0 10 | 2 | 3 -- test cte with gap filling in outer query WITH data AS ( SELECT * FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) ) SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM data GROUP BY 1,id; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test cte with gap filling in inner query WITH gapfill AS ( SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ) SELECT * FROM gapfill; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test window functions SELECT time_bucket_gapfill(10,time,0,60), interpolate(min(time)), lag(min(time)) OVER () FROM (VALUES (0),(50)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | lag ---------------------+-------------+----- 0 | 0 | 10 | 10 | 0 20 | 20 | 30 | 30 | 40 | 40 | 50 | 50 | -- test window functions with multiple windows SELECT time_bucket_gapfill(1,time,0,10), interpolate(min(time)), row_number() OVER (), locf(min(time)), sum(interpolate(min(time))) OVER (ROWS 1 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 2 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 3 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 4 PRECEDING) FROM (VALUES (0),(9)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | row_number | locf | sum | sum | sum | sum ---------------------+-------------+------------+------+-----+-----+-----+----- 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 1 | 1 | 2 | 0 | 1 | 1 | 1 | 1 2 | 2 | 3 | 0 | 3 | 3 | 3 | 3 3 | 3 | 4 | 0 | 5 | 6 | 6 | 6 4 | 4 | 5 | 0 | 7 | 9 | 10 | 10 5 | 5 | 6 | 0 | 9 | 12 | 14 | 15 6 | 6 | 7 | 0 | 11 | 15 | 18 | 20 7 | 7 | 8 | 0 | 13 | 18 | 22 | 25 8 | 8 | 9 | 0 | 15 | 21 | 26 | 30 9 | 9 | 10 | 9 | 17 | 24 | 30 | 35 -- test window functions with constants SELECT time_bucket_gapfill(1,time,0,5), min(time), 4 as c, lag(min(time)) OVER () FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | c | lag ---------------------+-----+---+----- 0 | | 4 | 1 | 1 | 4 | 2 | 2 | 4 | 1 3 | 3 | 4 | 2 4 | | 4 | 3 --test window functions with locf SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, locf(min(time)) AS locf, lag(locf(min(time))) over () AS lag_locf, lead(locf(min(time))) over () AS lead_locf FROM (VALUES (1),(2)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | locf | lag_locf | lead_locf ---------------------+-----+---------+----------+------+----------+----------- 0 | | | 1 | | | 1 1 | 1 | | 2 | 1 | | 2 2 | 2 | 1 | | 2 | 1 | 2 3 | | 2 | | 2 | 2 | 2 4 | | | | 2 | 2 | --test window functions with interpolate SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, lead(interpolate(min(time))) over () AS lead_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | interpolate | lag_interpolate | lead_interpolate ---------------------+-----+---------+----------+-------------+-----------------+------------------ 0 | | | 1 | | | 1 1 | 1 | | | 1 | | 2 2 | | 1 | 3 | 2 | 1 | 3 3 | 3 | | | 3 | 2 | 4 | | 3 | | | 3 | --test window functions with expressions SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, 1 + lag(min(time)) over () AS lag_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, 1 + lag(interpolate(min(time))) over () AS lag_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lag_min | interpolate | lag_interpolate | lag_interpolate ---------------------+-----+---------+---------+-------------+-----------------+----------------- 0 | | | | | | 1 | 1 | | | 1 | | 2 | | 1 | 2 | 2 | 1 | 2 3 | 3 | | | 3 | 2 | 3 4 | | 3 | 4 | | 3 | 4 --test row_number/rank/percent_rank/... window functions with gapfill reference SELECT time_bucket_gapfill(1,time,0,5), ntile(2) OVER () AS ntile_2, ntile(3) OVER () AS ntile_3, ntile(5) OVER () AS ntile_5, row_number() OVER (), cume_dist() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), rank() OVER (), rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), percent_rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)) FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | ntile_2 | ntile_3 | ntile_5 | row_number | cume_dist | rank | rank | percent_rank ---------------------+---------+---------+---------+------------+-----------+------+------+-------------- 0 | 1 | 1 | 1 | 1 | 0.2 | 1 | 1 | 0 1 | 1 | 1 | 2 | 2 | 0.4 | 1 | 2 | 0.25 2 | 1 | 2 | 3 | 3 | 0.6 | 1 | 3 | 0.5 3 | 2 | 2 | 4 | 4 | 0.8 | 1 | 4 | 0.75 4 | 2 | 3 | 5 | 5 | 1 | 1 | 5 | 1 -- test first_value/last_value/nth_value SELECT time_bucket_gapfill(1,time,0,5), first_value(min(time)) OVER (), nth_value(min(time),3) OVER (), last_value(min(time)) OVER () FROM (VALUES (0),(2),(5)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | nth_value | last_value ---------------------+-------------+-----------+------------ 0 | 0 | 2 | 5 1 | 0 | 2 | 5 2 | 0 | 2 | 5 3 | 0 | 2 | 5 4 | 0 | 2 | 5 5 | 0 | 2 | 5 -- test window functions with PARTITION BY SELECT time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (), row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | row_number | row_number ------+-------+------------+------------ 0 | blue | 1 | 1 1 | blue | 2 | 2 2 | blue | 3 | 3 3 | blue | 4 | 4 4 | blue | 5 | 5 0 | red | 6 | 1 1 | red | 7 | 2 2 | red | 8 | 3 3 | red | 9 | 4 4 | red | 10 | 5 -- test multiple windows \set ON_ERROR_STOP 0 SELECT time_bucket_gapfill(1,time,0,11), first_value(interpolate(min(time))) OVER (ROWS 1 PRECEDING), interpolate(min(time)), last_value(interpolate(min(time))) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM (VALUES (0),(10)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | interpolate | last_value ---------------------+-------------+-------------+------------ 0 | 0 | 0 | 1 1 | 0 | 1 | 2 2 | 1 | 2 | 3 3 | 2 | 3 | 4 4 | 3 | 4 | 5 5 | 4 | 5 | 6 6 | 5 | 6 | 7 7 | 6 | 7 | 8 8 | 7 | 8 | 9 9 | 8 | 9 | 10 10 | 9 | 10 | 10 -- test reorder SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 1,id; time | id | m ------+----+--- 0 | 1 | 0 | 2 | 1 | 1 | 1 1 | 2 | 2 | 1 | 2 | 2 | 2 3 | 1 | 3 | 2 | 4 | 1 | 4 | 2 | -- test order by locf SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | locf ---------------------+------ 2 | 2 3 | 3 4 | 3 5 | 3 1 | -- test order by interpolate SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | interpolate ---------------------+------------- 4 | 5 | 1 | 1 2 | 2 3 | 3 SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | -- test queries on hypertable -- test locf and interpolate together SELECT time_bucket_gapfill(interval '1h',time,timestamptz '2018-01-01 05:00:00-8', timestamptz '2018-01-01 07:00:00-8'), device_id, locf(avg(v1)) AS locf_v1, locf(min(v2)) AS locf_v2, interpolate(avg(v1)) AS interpolate_v1, interpolate(avg(v2)) AS interpolate_v2 FROM metrics_tstz GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | locf_v1 | locf_v2 | interpolate_v1 | interpolate_v2 ------------------------------+-----------+---------+---------+----------------+---------------- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 06:00:00 2018 PST | 1 | 0.5 | 10 | 0.25 | 5 Mon Jan 01 06:00:00 2018 PST | 2 | 0.7 | 20 | 1.05 | 30 Mon Jan 01 06:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz) < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 -- interpolation with correlated subquery lookup before interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 3:00 PST'::timestamptz, '2018-01-01 8:00 PST'::timestamptz), device_id, interpolate( avg(v1), (SELECT (time,0.5::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time DESC LIMIT 1) ), avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 03:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 04:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 -- interpolation with correlated subquery lookup after interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 5:00 PST'::timestamptz, '2018-01-01 9:00 PST'::timestamptz), device_id, interpolate( avg(v1), next=>(SELECT (time,v2::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time LIMIT 1) ),avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 08:00:00 2018 PST | 1 | -5 | \set ON_ERROR_STOP 0 -- bucket_width non simple expression SELECT time_bucket_gapfill(t,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression -- no start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- no start and no usable time constraints SELECT time_bucket_gapfill(1,t,finish:=1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression -- NULL start and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression -- no finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with column reference on right side SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > t AND t < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with cast SELECT time_bucket_gapfill(1,t1::int8) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 >= 1 AND t1 <= 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with multiple column references SELECT time_bucket_gapfill(1,t1+t2) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 1 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL start in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END AND t1 < 4 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL finish in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as start argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as finish argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,NULL,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- time_bucket_gapfill with constraints ORed SELECT time_bucket_gapfill(1::int8,t::int8) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 OR t < 3 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 -- int32 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- same query with less or equal as finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t <= 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 3 -- int32 time_bucket_gapfill with start column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE -1 < t AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 -- int32 time_bucket_gapfill with finish column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= 0 AND 3 >= t GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 -- int16 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int2,t) FROM (VALUES (1::int2),(2::int2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- int64 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int8,t) FROM (VALUES (1::int8),(2::int8)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- date time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('1d'::interval,t) FROM (VALUES ('1999-12-30'::date),('2000-01-01'::date)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill --------------------- 12-29-1999 12-30-1999 12-31-1999 01-01-2000 01-02-2000 -- timestamp time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamp),('2000-01-01'::timestamp)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill -------------------------- Wed Dec 29 00:00:00 1999 Wed Dec 29 12:00:00 1999 Thu Dec 30 00:00:00 1999 Thu Dec 30 12:00:00 1999 Fri Dec 31 00:00:00 1999 Fri Dec 31 12:00:00 1999 Sat Jan 01 00:00:00 2000 Sat Jan 01 12:00:00 2000 Sun Jan 02 00:00:00 2000 Sun Jan 02 12:00:00 2000 -- timestamptz time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Tue Dec 28 16:00:00 1999 PST Wed Dec 29 04:00:00 1999 PST Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with more complex expression SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with different datatype in finish constraint SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03'::date GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- time_bucket_gapfill with now() as start SELECT time_bucket_gapfill('1h'::interval,t) FROM (VALUES (now()),(now())) v(t) WHERE t >= now() AND t < now() - '1h'::interval GROUP BY 1; time_bucket_gapfill --------------------- -- time_bucket_gapfill with multiple constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 and t>1 AND t <=4 AND length(version()) > 0 GROUP BY 1; time_bucket_gapfill --------------------- 2 -- int32 time_bucket_gapfill with greater for start SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > -2 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- test DISTINCT SELECT DISTINCT ON (color) time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 0 | red | -- test DISTINCT with window functions SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER () FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 6 1 | red | 7 2 | red | 8 3 | red | 9 4 | red | 10 -- test DISTINCT with window functions and PARTITION BY SELECT DISTINCT ON (color,row_number() OVER (PARTITION BY color)) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test DISTINCT with window functions not in targetlist SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test column references SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test with Nested Loop SELECT l.id, bucket, data_value FROM (VALUES (1), (2), (3), (4)) a(id) INNER JOIN LATERAL ( SELECT b.id id, time_bucket_gapfill('1'::int, time, start=>'1'::int, finish=> '5'::int) bucket, locf(last(data, time)) data_value FROM (VALUES (1, 1, 1), (1, 4, 4), (2, 1, -1), (2, 4, -4)) b(id, time, data) WHERE a.id = b.id GROUP BY b.id, bucket ) as l on (true); id | bucket | data_value ----+--------+------------ 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 1 | 4 | 4 2 | 1 | -1 2 | 2 | -1 2 | 3 | -1 2 | 4 | -4 -- test prepared statement PREPARE prep_gapfill AS SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(value)) FROM (VALUES (1,1),(2,2)) v(time,value) GROUP BY 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 DEALLOCATE prep_gapfill; -- test column references with TIME_COLUMN last SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test expressions on GROUP BY columns SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, length(color), time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,5; row_number | locf | color | length | time ------------+------+-------+--------+------ 1 | | blue | 4 | 0 2 | 1 | blue | 4 | 1 3 | 1 | blue | 4 | 2 4 | 1 | blue | 4 | 3 5 | 1 | blue | 4 | 4 1 | | red | 3 | 0 2 | | red | 3 | 1 3 | 2 | red | 3 | 2 4 | 2 | red | 3 | 3 5 | 2 | red | 3 | 4 -- test columns derived from GROUP BY columns with cast SELECT time_bucket_gapfill(1,time,0,5) as time, device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | device_id ------+----------- 0 | 1 1 | 1 2 | 1 3 | 1 4 | 1 0 | 2 1 | 2 2 | 2 3 | 2 4 | 2 -- test columns derived from GROUP BY columns with expression SELECT time_bucket_gapfill(1,time,0,5) as time, 'Device ' || device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | ?column? ------+---------- 0 | Device 1 1 | Device 1 2 | Device 1 3 | Device 1 4 | Device 1 0 | Device 2 1 | Device 2 2 | Device 2 3 | Device 2 4 | Device 2 --test interpolation with big differences in values (test overflows in calculations) --we use the biggest possible difference in time(x) and the value(y). --For bigints we also test values of smaller than bigintmax/min to avoid --the symmetry where x=y (which catches more errors) SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset SELECT time_bucket_gapfill(1,time,0,1) AS time, interpolate(min(s)) AS "smallint", interpolate(min(i)) AS "int", interpolate(min(b)) AS "bigint", interpolate(min(b2)) AS "bigint2", interpolate(min(d)) AS "double" FROM (values (:big_int_min,(-32768)::smallint,(-2147483648)::int,:big_int_min,-2147483648::bigint, '-Infinity'::double precision), (:big_int_max, 32767::smallint, 2147483647::int,:big_int_max, 2147483647::bigint, 'Infinity'::double precision)) v(time,s,i,b,b2,d) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | bigint2 | double ----------------------+----------+-------------+----------------------+-------------+----------- -9223372036854775808 | -32768 | -2147483648 | -9223372036854775808 | -2147483648 | -Infinity 0 | 0 | 0 | 0 | 0 | Infinity 9223372036854775807 | 32767 | 2147483647 | 9223372036854775807 | 2147483647 | Infinity -- issue #2232: This query used to trigger error "could not find -- pathkey item to sort" due to a corrupt query plan SELECT time_bucket_gapfill('1 h', time) AS time, locf(sum(v1)) AS v1_sum, interpolate(sum(v2)) AS v2_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v2_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 06:00:00 2018 PST | 2.1 | 65 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 Mon Jan 01 04:00:00 2018 PST | | -- query without gapfill: SELECT time_bucket('1 h', time) AS time, sum(v1) AS v1_sum, sum(v2) AS v1_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v1_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 -- query to show original data SELECT * FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' ORDER BY 1 DESC, 2; time | device_id | v1 | v2 ------------------------------+-----------+-----+---- Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 -- issue #3048 -- test gapfill/hashagg planner interaction -- this used to produce a plan without gapfill node EXPLAIN (buffers off, costs off) SELECT time_bucket_gapfill('52w', time, start:='2000-01-01', finish:='2000-01-10') AS time, sum(v1) AS v1_sum FROM metrics GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- issue #3834 -- test projection handling in gapfill CREATE TABLE i3834(time timestamptz NOT NULL, ship_id int, value float); SELECT table_name FROM create_hypertable('i3834','time'); table_name ------------ i3834 INSERT INTO i3834 VALUES ('2020-12-01 14:05:00+01',1,3.123), ('2020-12-01 14:05:00+01',2,4.123), ('2020-12-01 14:05:00+01',3,5.123); SELECT time_bucket_gapfill('30000 ms'::interval, time) AS time, ship_id, interpolate (avg(value)), 'speedlog' AS source FROM i3834 WHERE ship_id IN (1, 2) AND time >= '2020-12-01 14:05:00+01' AND time < '2020-12-01 14:10:00+01' GROUP BY 1,2; time | ship_id | interpolate | source ------------------------------+---------+-------------+---------- Tue Dec 01 05:05:00 2020 PST | 1 | 3.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 1 | | speedlog Tue Dec 01 05:06:00 2020 PST | 1 | | speedlog Tue Dec 01 05:06:30 2020 PST | 1 | | speedlog Tue Dec 01 05:07:00 2020 PST | 1 | | speedlog Tue Dec 01 05:07:30 2020 PST | 1 | | speedlog Tue Dec 01 05:08:00 2020 PST | 1 | | speedlog Tue Dec 01 05:08:30 2020 PST | 1 | | speedlog Tue Dec 01 05:09:00 2020 PST | 1 | | speedlog Tue Dec 01 05:09:30 2020 PST | 1 | | speedlog Tue Dec 01 05:05:00 2020 PST | 2 | 4.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 2 | | speedlog Tue Dec 01 05:06:00 2020 PST | 2 | | speedlog Tue Dec 01 05:06:30 2020 PST | 2 | | speedlog Tue Dec 01 05:07:00 2020 PST | 2 | | speedlog Tue Dec 01 05:07:30 2020 PST | 2 | | speedlog Tue Dec 01 05:08:00 2020 PST | 2 | | speedlog Tue Dec 01 05:08:30 2020 PST | 2 | | speedlog Tue Dec 01 05:09:00 2020 PST | 2 | | speedlog Tue Dec 01 05:09:30 2020 PST | 2 | | speedlog DROP TABLE i3834; -- issue #1528 -- test float rounding for certain float values when start and end are identical SELECT time_bucket_gapfill('1min'::interval, ts::timestamptz, start:='2019-11-05 2:20', finish:='2019-11-05 2:30'), interpolate(avg(20266.959547::float4)) AS float4, interpolate(avg(20266.959547::float8)) AS float8 FROM (VALUES ('2019-11-05 2:20'), ('2019-11-05 2:30')) v (ts) GROUP BY 1; time_bucket_gapfill | float4 | float8 ------------------------------+-----------------+-------------- Tue Nov 05 02:20:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:21:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:22:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:23:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:24:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:25:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:26:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:27:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:28:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:29:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:30:00 2019 PST | 20266.958984375 | 20266.959547 -- check gapfill group change detection with TOASTed values CREATE TABLE gapfill_group_toast(time timestamptz NOT NULL, device text, value float); SELECT table_name FROM create_hypertable('gapfill_group_toast', 'time'); table_name --------------------- gapfill_group_toast INSERT INTO gapfill_group_toast SELECT generate_series('2022-06-01'::timestamptz, '2022-06-03'::timestamptz, '1min'::interval), '4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43', random(); ALTER TABLE gapfill_group_toast SET(timescaledb.compress, timescaledb.compress_segmentby = 'device'); SELECT count(compress_chunk(c)) FROM show_chunks('gapfill_group_toast') c; count ------- 2 SELECT time_bucket_gapfill('1 day', time), device FROM gapfill_group_toast WHERE time >= '2022-06-01' AND time <= '2022-06-02' GROUP BY 1,2; time_bucket_gapfill | device ------------------------------+------------------------------------------------------------------ Tue May 31 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 Wed Jun 01 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 DROP TABLE gapfill_group_toast; -- test bucketing by month SELECT time_bucket_gapfill('2 month'::interval, ts, '2000-01-01'::timestamptz,'2001-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SELECT time_bucket_gapfill('1 year'::interval, ts, '2000-01-01'::timestamptz,'2003-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Sun Dec 31 16:00:00 2000 PST Mon Dec 31 16:00:00 2001 PST Tue Dec 31 16:00:00 2002 PST SELECT time_bucket_gapfill('1 century'::interval, ts, '1900-01-01'::timestamptz,'2103-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sun Dec 31 16:00:00 1899 PST Fri Dec 31 16:00:00 1999 PST Thu Dec 31 16:00:00 2099 PST -- test bucketing with timezone SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 15:00:00 1999 PST Tue Feb 29 15:00:00 2000 PST Sun Apr 30 15:00:00 2000 PDT Fri Jun 30 15:00:00 2000 PDT Thu Aug 31 15:00:00 2000 PDT Tue Oct 31 15:00:00 2000 PST Sun Dec 31 15:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, current_setting('timezone'), '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sat Jan 01 00:00:00 2000 PST Wed Mar 01 00:00:00 2000 PST Mon May 01 00:00:00 2000 PDT Sat Jul 01 00:00:00 2000 PDT Fri Sep 01 00:00:00 2000 PDT Wed Nov 01 00:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, 'UTC', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SET timezone TO 'Europe/Berlin'; SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------- Sat Jan 01 00:00:00 2000 CET Wed Mar 01 00:00:00 2000 CET Mon May 01 00:00:00 2000 CEST Sat Jul 01 00:00:00 2000 CEST Fri Sep 01 00:00:00 2000 CEST Wed Nov 01 00:00:00 2000 CET RESET timezone; -- Test gapfill with arrays (#5981) SELECT time_bucket_gapfill(5, ts, 1, 100) as ts, int_arr, locf(last(value, ts)) FROM ( SELECT ARRAY[1,2,3,4]::int[] as int_arr, x as ts, x+500000 as value FROM generate_series(1, 10, 100) as x ) t GROUP BY 1, 2; ts | int_arr | locf ----+-----------+-------- 0 | {1,2,3,4} | 500001 5 | {1,2,3,4} | 500001 10 | {1,2,3,4} | 500001 15 | {1,2,3,4} | 500001 20 | {1,2,3,4} | 500001 25 | {1,2,3,4} | 500001 30 | {1,2,3,4} | 500001 35 | {1,2,3,4} | 500001 40 | {1,2,3,4} | 500001 45 | {1,2,3,4} | 500001 50 | {1,2,3,4} | 500001 55 | {1,2,3,4} | 500001 60 | {1,2,3,4} | 500001 65 | {1,2,3,4} | 500001 70 | {1,2,3,4} | 500001 75 | {1,2,3,4} | 500001 80 | {1,2,3,4} | 500001 85 | {1,2,3,4} | 500001 90 | {1,2,3,4} | 500001 95 | {1,2,3,4} | 500001 -- Test gapfill is aligned with non-gapfill time_bucket -- when using different timezones and month bucketing CREATE TABLE month_timezone(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('month_timezone','time'); table_name ---------------- month_timezone INSERT INTO month_timezone VALUES ('2023-03-01 14:05:00+01', 3.123), ('2023-04-01 14:05:00+01',4.123), ('2023-05-01 14:05:00+01', 5.123); SELECT time_bucket_gapfill('1 month'::interval, time, 'Europe/Berlin', '2023-01-01', '2023-07-01') AS time, sum(value) FROM month_timezone GROUP BY 1; time | sum ------------------------------+------- Sat Dec 31 15:00:00 2022 PST | Tue Jan 31 15:00:00 2023 PST | Tue Feb 28 15:00:00 2023 PST | 3.123 Fri Mar 31 15:00:00 2023 PDT | 4.123 Sun Apr 30 15:00:00 2023 PDT | 5.123 Wed May 31 15:00:00 2023 PDT | Fri Jun 30 15:00:00 2023 PDT | -- Test gapfill respects DST changes when generating timestamps (#6344) SELECT time_bucket_gapfill('1 month', time, 'awst','2023-01-01', '2023-07-01' ) AS month, sum(value) AS sum FROM month_timezone GROUP BY 1; month | sum ------------------------------+------- Sat Dec 31 08:00:00 2022 PST | Tue Jan 31 08:00:00 2023 PST | Tue Feb 28 08:00:00 2023 PST | 3.123 Fri Mar 31 09:00:00 2023 PDT | 4.123 Sun Apr 30 09:00:00 2023 PDT | 5.123 Wed May 31 09:00:00 2023 PDT | Fri Jun 30 09:00:00 2023 PDT | DROP TABLE month_timezone; -- Test gapfill with additional group pathkeys added for optimization (#6396) CREATE TABLE stocks_real_time ( time TIMESTAMPTZ NOT NULL, symbol TEXT NOT NULL, price DOUBLE PRECISION NULL, day_volume INT NULL ); INSERT INTO stocks_real_time VALUES (NOW(), 's1', 70.0, 50), (NOW(), 's2', 66.5, 60), (NOW(), 's3', 77.0, 65); SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1; day | symbol_count ------------------------------+-------------- Thu Nov 30 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Sat Dec 09 16:00:00 2023 PST | SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1 ORDER BY 1 DESC; day | symbol_count ------------------------------+-------------- Sat Dec 09 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Thu Nov 30 16:00:00 2023 PST | DROP TABLE stocks_real_time; SET timezone TO 'Europe/Berlin'; -- check dst switching is handled correctly #6788 SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 03:00:00 2024 CEST SELECT time_bucket_gapfill('30 minutes', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 01:30:00 2024 CET Sun Mar 31 03:00:00 2024 CEST Sun Mar 31 03:30:00 2024 CEST SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-10-26T23:00Z', '2024-10-27T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Oct 27 01:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CET RESET timezone; ������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/gapfill-17.out������������������������������������������0000664�0000000�0000000�00000602544�15100345067�0023312�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' -- we want to see error details in the output \set VERBOSITY default CREATE TABLE gapfill_plan_test(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('gapfill_plan_test','time',chunk_time_interval=>'4 weeks'::interval); table_name ------------------- gapfill_plan_test INSERT INTO gapfill_plan_test SELECT generate_series('2018-01-01'::timestamptz,'2018-04-01'::timestamptz,'1m'::interval), 1.0; -- simple example :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sorting :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sort direction :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1 DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) DESC -> Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) NULLS FIRST -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now()) -> Values Scan on "*VALUES*" -- test order by aggregate function :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2,1; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)), (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test query without order by :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test parallel query :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), avg(value) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- make sure we can run gapfill in parallel workers -- ensure this plan runs in parallel :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; --- QUERY PLAN --- Limit -> Sort Sort Key: (interpolate(avg(gapfill_plan_test.value), NULL::record, NULL::record)) -> Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- actually run a parallel gapfill SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; time_bucket_gapfill | interpolate ------------------------------+------------- Mon Jan 01 00:00:00 2018 PST | 1 -- test sort optimizations -- test sort optimization with single member order by, -- should use index scan (no GapFill node for this one since we're not gapfilling) :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk SET max_parallel_workers_per_gather TO 0; -- test sort optimizations with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimizations with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk RESET max_parallel_workers_per_gather; CREATE INDEX gapfill_plan_test_indx ON gapfill_plan_test(value, time); -- test sort optimization with ordering by multiple columns and time_bucket_gapfill not last, -- must not use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)), gapfill_plan_test.value -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimization with ordering by multiple columns and time_bucket as last member, -- should use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 2,1; --- QUERY PLAN --- Incremental Sort Sort Key: gapfill_plan_test.value, (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) Presorted Key: gapfill_plan_test.value -> Result -> Merge Append Sort Key: gapfill_plan_test.value -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk DROP TABLE gapfill_plan_test; \set METRICS metrics_int -- All test against table :METRICS first \set ON_ERROR_STOP 0 -- inverse of previous test query to confirm an error is actually thrown SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time = 5 GROUP BY 1,2,3 ORDER BY 2,3,1; ERROR: division by zero -- test window functions with multiple column references SELECT time_bucket_gapfill(1,time,1,2), first(min(time),min(time)) OVER () FROM :METRICS GROUP BY 1; ERROR: window functions with multiple column references not supported -- test with unsupported operator SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time =0 AND time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test with 2 tables and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test inner join and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time WHERE m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test outer join with constraints in join condition -- not usable as start/stop SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 LEFT OUTER JOIN :METRICS m2 ON m1.time=m2.time AND m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 \ir include/gapfill_metrics_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test locf lookup query does not trigger when not needed -- -- 1/(SELECT 0) will throw an error in the lookup query but in order to not -- always trigger evaluation it needs to be correlated otherwise postgres will -- always run it once even if the value is never used SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | locf3 ------+-----------+-----------+------- 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 -- test locf with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value)::int,23) AS locf1, locf(min(value)::int,(SELECT 42)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 1 | | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and "wrong order" SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value),23::float) AS locf1, locf(min(value),(SELECT 42::float)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 1,2,3; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 1 | | 5 | 5 | 5 | 5 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and window functions SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)), sum(locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1))) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3; time | device_id | sensor_id | locf | sum ------+-----------+-----------+------+------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 5 | 10 10 | 1 | 1 | 5 | 10 0 | 1 | 2 | -100 | -100 5 | 1 | 2 | 10 | -90 10 | 1 | 2 | 10 | 20 -- test JOINs SELECT time_bucket_gapfill(1,time,0,5) as time, device_id, d.name, sensor_id, s.name, avg(m.value) FROM :METRICS m INNER JOIN devices d USING(device_id) INNER JOIN sensors s USING(sensor_id) WHERE time BETWEEN 0 AND 5 GROUP BY 1,2,3,4,5; time | device_id | name | sensor_id | name | avg ------+-----------+----------+-----------+----------+----- 0 | 1 | Device 1 | 1 | Sensor 1 | 5 1 | 1 | Device 1 | 1 | Sensor 1 | 2 | 1 | Device 1 | 1 | Sensor 1 | 3 | 1 | Device 1 | 1 | Sensor 1 | 4 | 1 | Device 1 | 1 | Sensor 1 | 0 | 1 | Device 1 | 2 | Sensor 2 | 1 | 1 | Device 1 | 2 | Sensor 2 | 2 | 1 | Device 1 | 2 | Sensor 2 | 3 | 1 | Device 1 | 2 | Sensor 2 | 4 | 1 | Device 1 | 2 | Sensor 2 | 5 | 1 | Device 1 | 2 | Sensor 2 | 10 -- test interpolate with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), interpolate(min(value)) AS ip, interpolate(min(value),(-5,-5.0::float),(15,20.0::float)) AS ip1, interpolate(min(value),(SELECT (-10,-10.0::float)),(SELECT (15,20.0::float))) AS ip2, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) AS ip3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | ip | ip1 | ip2 | ip3 ------+-----------+-----------+-----+----+-----+------------------+------------------ 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | | 10 | 10 | 4.75 10 | 1 | 1 | | | 15 | 15 | 4.5 0 | 1 | 2 | | | 2.5 | 3.33333333333333 | 4.76190476190476 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | | 15 | 15 | 4.21052631578947 -- test interpolate with correlated subquery and window function SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ), sum(interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) )) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | interpolate | sum ------+-----------+-----------+------------------+------------------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 4.75 | 9.75 10 | 1 | 1 | 4.5 | 9.25 0 | 1 | 2 | 4.76190476190476 | 4.76190476190476 5 | 1 | 2 | 10 | 14.7619047619048 10 | 1 | 2 | 4.21052631578947 | 14.2105263157895 -- test subqueries -- subqueries will alter the shape of the plan and top-level constraints -- might not end up in top-level of jointree SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 WHERE m1.time >=0 AND m1.time < 2 AND device_id IN (SELECT device_id FROM :METRICS) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test inner join with constraints in join condition SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time AND m2.time >=0 AND m2.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test actual table SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time >=0 AND time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with table alias SELECT time_bucket_gapfill(1,time) FROM :METRICS m WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with 2 tables SELECT time_bucket_gapfill(1,m.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test prepared statement with locf with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 DEALLOCATE prep_gapfill; -- test prepared statement with interpolate with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 DEALLOCATE prep_gapfill; -- test prepared statement with variable gapfill arguments PREPARE prep_gapfill(int,int,int) AS SELECT time_bucket_gapfill($1,time,$2,$3) AS time, device_id, sensor_id, min(value) FROM :METRICS m1 WHERE time >= $2 AND time < $3 AND device_id=1 AND sensor_id=1 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | DEALLOCATE prep_gapfill; -- Tests without tables -- test locf and interpolate call without gapfill SELECT locf(1); locf ------ 1 SELECT interpolate(1); interpolate ------------- 1 -- test locf and interpolate call with NULL input SELECT locf(NULL::int); locf ------ SELECT interpolate(NULL::bigint); interpolate ------------- \set ON_ERROR_STOP 0 -- test time_bucket_gapfill not top level function call SELECT 1 + time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: no top level time_bucket_gapfill in group by clause -- test locf with treat_null_as_missing not BOOL SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=1) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function locf(integer, treat_null_as_missing => integer) does not exist LINE 3: locf(min(time),treat_null_as_missing:=1) ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test locf with treat_null_as_missing not literal SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=random()>0) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid locf argument: treat_null_as_missing must be a BOOL literal -- test interpolate lookup query with 1 element in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT ROW(10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT ROW(10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with 3 elements in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with mismatching time datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10::float,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10::float,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate lookup query with mismatching value datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10::float))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10::float))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate with unsupported datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(text 'text') FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function interpolate(text) does not exist LINE 3: interpolate(text 'text') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. SELECT time_bucket_gapfill(1,time,1,11), interpolate(interval '1d') FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: function interpolate(interval) does not exist LINE 3: interpolate(interval '1d') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test multiple time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time,1,11),time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time_bucket_gapfill(1,time,1,11),1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested locf calls SELECT time_bucket_gapfill(1,time,1,11), locf(locf(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test nested interpolate calls SELECT time_bucket_gapfill(1,time,1,11), interpolate(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test mixed locf/interpolate calls SELECT time_bucket_gapfill(1,time,1,11), locf(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test window function inside locf SELECT time_bucket_gapfill(1,time,1,11), locf(avg(min(time)) OVER ()) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window functions must not be below locf -- test nested window functions -- prevented by postgres SELECT time_bucket_gapfill(1,time,1,11), avg(avg(min(time)) OVER ()) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window function calls cannot be nested LINE 3: avg(avg(min(time)) OVER ()) OVER () ^ -- test multiple window functions in single column SELECT time_bucket_gapfill(1,time,1,11), avg(min(time)) OVER () + avg(min(time)) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple window function calls per column not supported -- test locf not toplevel SELECT time_bucket_gapfill(1,time,1,11), 1 + locf(min(time)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: locf must be toplevel function call -- test locf inside aggregate SELECT time_bucket_gapfill(1,time,1,11), min(min(locf(time))) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: aggregate functions must be below locf -- test NULL args SELECT time_bucket_gapfill(NULL,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill(1,NULL,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill(1,time,NULL,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(1,time,1,NULL) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(NULL,time,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill('1day',NULL,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill('1day',time,NULL,'2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: timezone cannot be NULL -- test 0 bucket_width SELECT time_bucket_gapfill(0,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test negative bucket_width SELECT time_bucket_gapfill(-1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test subqueries as interval, start and stop (not supported atm) SELECT time_bucket_gapfill((SELECT 1),time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression SELECT time_bucket_gapfill(1,time,(SELECT 1),11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression SELECT time_bucket_gapfill(1,time,1,(SELECT 11)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression \set ON_ERROR_STOP 1 -- test time_bucket_gapfill without aggregation -- this will not trigger gapfilling SELECT time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time); time_bucket_gapfill --------------------- 1 2 SELECT time_bucket_gapfill(1,time,1,11), avg(time) OVER () FROM (VALUES (1),(2)) v(time); time_bucket_gapfill | avg ---------------------+-------------------- 1 | 1.5000000000000000 2 | 1.5000000000000000 -- test int int2/4/8 SELECT time_bucket_gapfill(1::int2,time::int2,0::int2,6::int2) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int4,time::int4,0::int4,6::int4) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int8,time::int8,0::int8,6::int8) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 -- test non-aligned bucket start SELECT time_bucket_gapfill(10,time,5,40) FROM (VALUES (11),(22)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 10 20 30 -- simple gapfill query SELECT time_bucket_gapfill(10,time,0,50) AS time, min(value) AS value FROM (values (-10,1),(10,2),(11,3),(12,4),(22,5),(30,6),(66,7)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- -10 | 1 0 | 10 | 2 20 | 5 30 | 6 40 | 60 | 7 -- test references to different columns SELECT time_bucket_gapfill(1,t,0,5) as t, min(t),max(t),min(v),max(v) FROM(VALUES (1,3),(2,5)) tb(t,v) GROUP BY 1 ORDER BY 1; t | min | max | min | max ---+-----+-----+-----+----- 0 | | | | 1 | 1 | 1 | 3 | 3 2 | 2 | 2 | 5 | 5 3 | | | | 4 | | | | -- test passing of values outside boundaries SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (-1),(1),(3),(6)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- -1 | -1 0 | 1 | 1 2 | 3 | 3 4 | 6 | 6 -- test gap fill before first row and after last row SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 1 2 | 2 3 | 3 4 | -- test gap fill without rows in resultset SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) WHERE false GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 2 | 3 | 4 | -- test coalesce SELECT time_bucket_gapfill(1,time,0,5), coalesce(min(time),0), coalesce(min(value),0), coalesce(min(value),7) FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | coalesce | coalesce | coalesce ---------------------+----------+----------+---------- 0 | 0 | 0 | 7 1 | 1 | 1 | 1 2 | 2 | 2 | 2 3 | 3 | 3 | 3 4 | 0 | 0 | 7 -- test case SELECT time_bucket_gapfill(1,time,0,5), min(time), CASE WHEN min(time) IS NOT NULL THEN min(time) ELSE -1 END, CASE WHEN min(time) IS NOT NULL THEN min(time) + 7 ELSE 0 END, CASE WHEN 1 = 1 THEN 1 ELSE 0 END FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | case | case | case ---------------------+-----+------+------+------ 0 | | -1 | 0 | 1 1 | 1 | 1 | 8 | 1 2 | 2 | 2 | 9 | 1 3 | 3 | 3 | 10 | 1 4 | | -1 | 0 | 1 -- test constants SELECT time_bucket_gapfill(1,time,0,5), min(time), min(time), 4 as c FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | min | c ---------------------+-----+-----+--- 0 | | | 4 1 | 1 | 1 | 4 2 | 2 | 2 | 4 3 | 3 | 3 | 4 4 | | | 4 -- test column reordering SELECT 1 as c1, '2' as c2, time_bucket_gapfill(1,time,0,5), 3.0 as c3, min(time), min(time), 4 as c4 FROM (VALUES (1),(2),(3)) v(time) GROUP BY 3 ORDER BY 3; c1 | c2 | time_bucket_gapfill | c3 | min | min | c4 ----+----+---------------------+-----+-----+-----+---- 1 | 2 | 0 | 3.0 | | | 4 1 | 2 | 1 | 3.0 | 1 | 1 | 4 1 | 2 | 2 | 3.0 | 2 | 2 | 4 1 | 2 | 3 | 3.0 | 3 | 3 | 4 1 | 2 | 4 | 3.0 | | | 4 -- test timestamptz SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMPTZ '2000-01-01',TIMESTAMPTZ '2000-01-02'), min(time) FROM (VALUES (TIMESTAMPTZ '2000-01-01 9:00:00'),(TIMESTAMPTZ '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ------------------------------+------------------------------ Fri Dec 31 22:00:00 1999 PST | Sat Jan 01 04:00:00 2000 PST | Sat Jan 01 09:00:00 2000 PST Sat Jan 01 10:00:00 2000 PST | Sat Jan 01 16:00:00 2000 PST | Sat Jan 01 18:00:00 2000 PST Sat Jan 01 22:00:00 2000 PST | -- test timestamp SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMP '2000-01-01',TIMESTAMP '2000-01-02'), min(time) FROM (VALUES (TIMESTAMP '2000-01-01 9:00:00'),(TIMESTAMP '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min --------------------------+-------------------------- Sat Jan 01 00:00:00 2000 | Sat Jan 01 06:00:00 2000 | Sat Jan 01 09:00:00 2000 Sat Jan 01 12:00:00 2000 | Sat Jan 01 18:00:00 2000 | Sat Jan 01 18:00:00 2000 -- test date SELECT time_bucket_gapfill(INTERVAL '1w',time,DATE '2000-01-01',DATE '2000-02-10'), min(time) FROM (VALUES (DATE '2000-01-08'),(DATE '2000-01-22')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+------------ 12-27-1999 | 01-03-2000 | 01-08-2000 01-10-2000 | 01-17-2000 | 01-22-2000 01-24-2000 | 01-31-2000 | 02-07-2000 | -- test grouping by non-time columns SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test grouping by non-time columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) WHERE false GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- -- test duplicate columns in GROUP BY SELECT time_bucket_gapfill(1,time,0,5) as time, id, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,2,3 ORDER BY 2,1; time | id | id | m ------+----+----+--- 0 | 1 | 1 | 1 | 1 | 1 | 1 2 | 1 | 1 | 3 | 1 | 1 | 4 | 1 | 1 | 0 | 2 | 2 | 1 | 2 | 2 | 2 | 2 | 2 | 2 3 | 2 | 2 | 4 | 2 | 2 | -- test grouping by columns not in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY id,1; time | m ------+--- 0 | 1 | 1 2 | 3 | 4 | 0 | 1 | 2 | 2 3 | 4 | -- test grouping by non-time columns with text columns SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 1 | blue | 1 2 | blue | 3 | blue | 4 | blue | 0 | red | 1 | red | 2 | red | 2 3 | red | 4 | red | -- test grouping by non-time columns with text columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) WHERE false GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- --- test insert into SELECT CREATE TABLE gapfill_insert_test(id INT); INSERT INTO gapfill_insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM gapfill_insert_test; id ---- 1 2 3 4 DROP TABLE gapfill_insert_test; -- test join SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'red',1),(2,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | m | m ------+-------+---+--- 0 | blue | | 1 | blue | | 2 | blue | 2 | 3 | blue | | 4 | blue | | 2 0 | red | | 1 | red | 1 | 2 | red | | 3 | red | | 1 4 | red | | -- test join with locf SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as locf FROM (VALUES (0,'red',1),(0,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | locf | m ------+-------+------+--- 0 | blue | 2 | 1 | blue | 2 | 2 | blue | 2 | 3 | blue | 2 | 4 | blue | 2 | 2 0 | red | 1 | 1 | red | 1 | 2 | red | 1 | 3 | red | 1 | 1 4 | red | 1 | 1 -- test locf SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in resultset SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=NULL) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 -- test locf with NULLs in resultset and treat_null_as_missing SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in first row of resultset and treat_null_as_missing with lookup query SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false, prev := (SELECT 100)) AS v1, locf(min(value),treat_null_as_missing:=true, prev := (SELECT 100)) AS v2 FROM (values (0,NULL),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | v1 | v2 ------+----+----- 0 | | 100 10 | | 100 20 | | 100 30 | | 100 40 | | 100 50 | 6 | 6 -- test locf with NULLs in resultset and treat_null_as_missing with resort SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1 DESC; time | value ------+------- 50 | 6 40 | 3 30 | 3 20 | 3 10 | 9 0 | -- test locf with constants SELECT time_bucket_gapfill(1,time,0,5), 2, locf(min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | ?column? | locf ---------------------+----------+------ 0 | 2 | 1 1 | 2 | 1 2 | 2 | 1 3 | 2 | 1 4 | 2 | 2 -- test expressions inside locf SELECT time_bucket_gapfill(1,time,0,5), locf(min(value)), locf(4), locf(4 + min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | locf | locf | locf ---------------------+------+------+------ 0 | 1 | 4 | 5 1 | 1 | 4 | 5 2 | 1 | 4 | 5 3 | 1 | 4 | 5 4 | 2 | 4 | 6 -- test locf with out of boundary lookup SELECT time_bucket_gapfill(10,time,0,70) AS time, locf(min(value),(SELECT 100)) AS value FROM (values (20,9),(40,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 100 10 | 100 20 | 9 30 | 9 40 | 6 50 | 6 60 | 6 -- test locf with different datatypes SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1)) AS text, locf(min(v2)) AS "int[]", locf(min(v3)) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test locf with different datatypes and treat_null_as_missing SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1),treat_null_as_missing:=true) AS text, locf(min(v2),treat_null_as_missing:=true) AS "int[]", locf(min(v3),treat_null_as_missing:=true) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (2,NULL,NULL,NULL), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test interpolate SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(value)) AS value FROM (values (0,1),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 1 10 | 2 20 | 3 30 | 4 40 | 5 50 | 6 -- test interpolate with NULL values SELECT time_bucket_gapfill(1,time,0,5) AS time, interpolate(avg(temp)) AS temp FROM (VALUES (0,0),(2,NULL),(5,5)) v(time,temp) GROUP BY 1; time | temp ------+------ 0 | 0 1 | 2 | 3 | 4 | 5 | 5 -- test interpolate datatypes SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (0,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(50,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- 0 | -3 | -3 | -3 | -3 | -3 10 | -2 | -2 | -2 | -1.8 | -1.8 20 | -1 | -1 | -1 | -0.6 | -0.6 30 | 1 | 1 | 1 | 0.6 | 0.6 40 | 2 | 2 | 2 | 1.8 | 1.8 50 | 3 | 3 | 3 | 3 | 3 -- test interpolate datatypes with negative time SELECT time_bucket_gapfill(10,time,-40,30) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (-40,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(20,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- -40 | -3 | -3 | -3 | -3 | -3 -30 | -2 | -2 | -2 | -2 | -2 -20 | -1 | -1 | -1 | -1 | -1 -10 | 0 | 0 | 0 | 0 | 0 0 | 1 | 1 | 1 | 1 | 1 10 | 2 | 2 | 2 | 2 | 2 20 | 3 | 3 | 3 | 3 | 3 -- test interpolate with multiple groupings SELECT time_bucket_gapfill(5,time,0,11), device, interpolate(min(v1),(SELECT (-10,-10)),(SELECT (20,10))) FROM (VALUES (5,1,0),(5,2,0)) as v(time,device,v1) GROUP BY 1,2 ORDER BY 2,1; time_bucket_gapfill | device | interpolate ---------------------+--------+------------- 0 | 1 | -3 5 | 1 | 0 10 | 1 | 3 0 | 2 | -3 5 | 2 | 0 10 | 2 | 3 -- test cte with gap filling in outer query WITH data AS ( SELECT * FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) ) SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM data GROUP BY 1,id; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test cte with gap filling in inner query WITH gapfill AS ( SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ) SELECT * FROM gapfill; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test window functions SELECT time_bucket_gapfill(10,time,0,60), interpolate(min(time)), lag(min(time)) OVER () FROM (VALUES (0),(50)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | lag ---------------------+-------------+----- 0 | 0 | 10 | 10 | 0 20 | 20 | 30 | 30 | 40 | 40 | 50 | 50 | -- test window functions with multiple windows SELECT time_bucket_gapfill(1,time,0,10), interpolate(min(time)), row_number() OVER (), locf(min(time)), sum(interpolate(min(time))) OVER (ROWS 1 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 2 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 3 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 4 PRECEDING) FROM (VALUES (0),(9)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | row_number | locf | sum | sum | sum | sum ---------------------+-------------+------------+------+-----+-----+-----+----- 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 1 | 1 | 2 | 0 | 1 | 1 | 1 | 1 2 | 2 | 3 | 0 | 3 | 3 | 3 | 3 3 | 3 | 4 | 0 | 5 | 6 | 6 | 6 4 | 4 | 5 | 0 | 7 | 9 | 10 | 10 5 | 5 | 6 | 0 | 9 | 12 | 14 | 15 6 | 6 | 7 | 0 | 11 | 15 | 18 | 20 7 | 7 | 8 | 0 | 13 | 18 | 22 | 25 8 | 8 | 9 | 0 | 15 | 21 | 26 | 30 9 | 9 | 10 | 9 | 17 | 24 | 30 | 35 -- test window functions with constants SELECT time_bucket_gapfill(1,time,0,5), min(time), 4 as c, lag(min(time)) OVER () FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | c | lag ---------------------+-----+---+----- 0 | | 4 | 1 | 1 | 4 | 2 | 2 | 4 | 1 3 | 3 | 4 | 2 4 | | 4 | 3 --test window functions with locf SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, locf(min(time)) AS locf, lag(locf(min(time))) over () AS lag_locf, lead(locf(min(time))) over () AS lead_locf FROM (VALUES (1),(2)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | locf | lag_locf | lead_locf ---------------------+-----+---------+----------+------+----------+----------- 0 | | | 1 | | | 1 1 | 1 | | 2 | 1 | | 2 2 | 2 | 1 | | 2 | 1 | 2 3 | | 2 | | 2 | 2 | 2 4 | | | | 2 | 2 | --test window functions with interpolate SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, lead(interpolate(min(time))) over () AS lead_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | interpolate | lag_interpolate | lead_interpolate ---------------------+-----+---------+----------+-------------+-----------------+------------------ 0 | | | 1 | | | 1 1 | 1 | | | 1 | | 2 2 | | 1 | 3 | 2 | 1 | 3 3 | 3 | | | 3 | 2 | 4 | | 3 | | | 3 | --test window functions with expressions SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, 1 + lag(min(time)) over () AS lag_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, 1 + lag(interpolate(min(time))) over () AS lag_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lag_min | interpolate | lag_interpolate | lag_interpolate ---------------------+-----+---------+---------+-------------+-----------------+----------------- 0 | | | | | | 1 | 1 | | | 1 | | 2 | | 1 | 2 | 2 | 1 | 2 3 | 3 | | | 3 | 2 | 3 4 | | 3 | 4 | | 3 | 4 --test row_number/rank/percent_rank/... window functions with gapfill reference SELECT time_bucket_gapfill(1,time,0,5), ntile(2) OVER () AS ntile_2, ntile(3) OVER () AS ntile_3, ntile(5) OVER () AS ntile_5, row_number() OVER (), cume_dist() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), rank() OVER (), rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), percent_rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)) FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | ntile_2 | ntile_3 | ntile_5 | row_number | cume_dist | rank | rank | percent_rank ---------------------+---------+---------+---------+------------+-----------+------+------+-------------- 0 | 1 | 1 | 1 | 1 | 0.2 | 1 | 1 | 0 1 | 1 | 1 | 2 | 2 | 0.4 | 1 | 2 | 0.25 2 | 1 | 2 | 3 | 3 | 0.6 | 1 | 3 | 0.5 3 | 2 | 2 | 4 | 4 | 0.8 | 1 | 4 | 0.75 4 | 2 | 3 | 5 | 5 | 1 | 1 | 5 | 1 -- test first_value/last_value/nth_value SELECT time_bucket_gapfill(1,time,0,5), first_value(min(time)) OVER (), nth_value(min(time),3) OVER (), last_value(min(time)) OVER () FROM (VALUES (0),(2),(5)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | nth_value | last_value ---------------------+-------------+-----------+------------ 0 | 0 | 2 | 5 1 | 0 | 2 | 5 2 | 0 | 2 | 5 3 | 0 | 2 | 5 4 | 0 | 2 | 5 5 | 0 | 2 | 5 -- test window functions with PARTITION BY SELECT time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (), row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | row_number | row_number ------+-------+------------+------------ 0 | blue | 1 | 1 1 | blue | 2 | 2 2 | blue | 3 | 3 3 | blue | 4 | 4 4 | blue | 5 | 5 0 | red | 6 | 1 1 | red | 7 | 2 2 | red | 8 | 3 3 | red | 9 | 4 4 | red | 10 | 5 -- test multiple windows \set ON_ERROR_STOP 0 SELECT time_bucket_gapfill(1,time,0,11), first_value(interpolate(min(time))) OVER (ROWS 1 PRECEDING), interpolate(min(time)), last_value(interpolate(min(time))) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM (VALUES (0),(10)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | interpolate | last_value ---------------------+-------------+-------------+------------ 0 | 0 | 0 | 1 1 | 0 | 1 | 2 2 | 1 | 2 | 3 3 | 2 | 3 | 4 4 | 3 | 4 | 5 5 | 4 | 5 | 6 6 | 5 | 6 | 7 7 | 6 | 7 | 8 8 | 7 | 8 | 9 9 | 8 | 9 | 10 10 | 9 | 10 | 10 -- test reorder SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 1,id; time | id | m ------+----+--- 0 | 1 | 0 | 2 | 1 | 1 | 1 1 | 2 | 2 | 1 | 2 | 2 | 2 3 | 1 | 3 | 2 | 4 | 1 | 4 | 2 | -- test order by locf SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | locf ---------------------+------ 2 | 2 3 | 3 4 | 3 5 | 3 1 | -- test order by interpolate SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | interpolate ---------------------+------------- 4 | 5 | 1 | 1 2 | 2 3 | 3 SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | -- test queries on hypertable -- test locf and interpolate together SELECT time_bucket_gapfill(interval '1h',time,timestamptz '2018-01-01 05:00:00-8', timestamptz '2018-01-01 07:00:00-8'), device_id, locf(avg(v1)) AS locf_v1, locf(min(v2)) AS locf_v2, interpolate(avg(v1)) AS interpolate_v1, interpolate(avg(v2)) AS interpolate_v2 FROM metrics_tstz GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | locf_v1 | locf_v2 | interpolate_v1 | interpolate_v2 ------------------------------+-----------+---------+---------+----------------+---------------- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 06:00:00 2018 PST | 1 | 0.5 | 10 | 0.25 | 5 Mon Jan 01 06:00:00 2018 PST | 2 | 0.7 | 20 | 1.05 | 30 Mon Jan 01 06:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz) < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 -- interpolation with correlated subquery lookup before interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 3:00 PST'::timestamptz, '2018-01-01 8:00 PST'::timestamptz), device_id, interpolate( avg(v1), (SELECT (time,0.5::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time DESC LIMIT 1) ), avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 03:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 04:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 -- interpolation with correlated subquery lookup after interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 5:00 PST'::timestamptz, '2018-01-01 9:00 PST'::timestamptz), device_id, interpolate( avg(v1), next=>(SELECT (time,v2::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time LIMIT 1) ),avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 08:00:00 2018 PST | 1 | -5 | \set ON_ERROR_STOP 0 -- bucket_width non simple expression SELECT time_bucket_gapfill(t,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression -- no start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- no start and no usable time constraints SELECT time_bucket_gapfill(1,t,finish:=1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression -- NULL start and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression -- no finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with column reference on right side SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > t AND t < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with cast SELECT time_bucket_gapfill(1,t1::int8) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 >= 1 AND t1 <= 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with multiple column references SELECT time_bucket_gapfill(1,t1+t2) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 1 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL start in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END AND t1 < 4 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL finish in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as start argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as finish argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,NULL,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- time_bucket_gapfill with constraints ORed SELECT time_bucket_gapfill(1::int8,t::int8) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 OR t < 3 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 -- int32 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- same query with less or equal as finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t <= 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 3 -- int32 time_bucket_gapfill with start column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE -1 < t AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 -- int32 time_bucket_gapfill with finish column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= 0 AND 3 >= t GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 -- int16 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int2,t) FROM (VALUES (1::int2),(2::int2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- int64 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int8,t) FROM (VALUES (1::int8),(2::int8)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- date time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('1d'::interval,t) FROM (VALUES ('1999-12-30'::date),('2000-01-01'::date)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill --------------------- 12-29-1999 12-30-1999 12-31-1999 01-01-2000 01-02-2000 -- timestamp time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamp),('2000-01-01'::timestamp)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill -------------------------- Wed Dec 29 00:00:00 1999 Wed Dec 29 12:00:00 1999 Thu Dec 30 00:00:00 1999 Thu Dec 30 12:00:00 1999 Fri Dec 31 00:00:00 1999 Fri Dec 31 12:00:00 1999 Sat Jan 01 00:00:00 2000 Sat Jan 01 12:00:00 2000 Sun Jan 02 00:00:00 2000 Sun Jan 02 12:00:00 2000 -- timestamptz time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Tue Dec 28 16:00:00 1999 PST Wed Dec 29 04:00:00 1999 PST Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with more complex expression SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with different datatype in finish constraint SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03'::date GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- time_bucket_gapfill with now() as start SELECT time_bucket_gapfill('1h'::interval,t) FROM (VALUES (now()),(now())) v(t) WHERE t >= now() AND t < now() - '1h'::interval GROUP BY 1; time_bucket_gapfill --------------------- -- time_bucket_gapfill with multiple constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 and t>1 AND t <=4 AND length(version()) > 0 GROUP BY 1; time_bucket_gapfill --------------------- 2 -- int32 time_bucket_gapfill with greater for start SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > -2 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- test DISTINCT SELECT DISTINCT ON (color) time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 0 | red | -- test DISTINCT with window functions SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER () FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 6 1 | red | 7 2 | red | 8 3 | red | 9 4 | red | 10 -- test DISTINCT with window functions and PARTITION BY SELECT DISTINCT ON (color,row_number() OVER (PARTITION BY color)) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test DISTINCT with window functions not in targetlist SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test column references SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test with Nested Loop SELECT l.id, bucket, data_value FROM (VALUES (1), (2), (3), (4)) a(id) INNER JOIN LATERAL ( SELECT b.id id, time_bucket_gapfill('1'::int, time, start=>'1'::int, finish=> '5'::int) bucket, locf(last(data, time)) data_value FROM (VALUES (1, 1, 1), (1, 4, 4), (2, 1, -1), (2, 4, -4)) b(id, time, data) WHERE a.id = b.id GROUP BY b.id, bucket ) as l on (true); id | bucket | data_value ----+--------+------------ 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 1 | 4 | 4 2 | 1 | -1 2 | 2 | -1 2 | 3 | -1 2 | 4 | -4 -- test prepared statement PREPARE prep_gapfill AS SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(value)) FROM (VALUES (1,1),(2,2)) v(time,value) GROUP BY 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 DEALLOCATE prep_gapfill; -- test column references with TIME_COLUMN last SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test expressions on GROUP BY columns SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, length(color), time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,5; row_number | locf | color | length | time ------------+------+-------+--------+------ 1 | | blue | 4 | 0 2 | 1 | blue | 4 | 1 3 | 1 | blue | 4 | 2 4 | 1 | blue | 4 | 3 5 | 1 | blue | 4 | 4 1 | | red | 3 | 0 2 | | red | 3 | 1 3 | 2 | red | 3 | 2 4 | 2 | red | 3 | 3 5 | 2 | red | 3 | 4 -- test columns derived from GROUP BY columns with cast SELECT time_bucket_gapfill(1,time,0,5) as time, device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | device_id ------+----------- 0 | 1 1 | 1 2 | 1 3 | 1 4 | 1 0 | 2 1 | 2 2 | 2 3 | 2 4 | 2 -- test columns derived from GROUP BY columns with expression SELECT time_bucket_gapfill(1,time,0,5) as time, 'Device ' || device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | ?column? ------+---------- 0 | Device 1 1 | Device 1 2 | Device 1 3 | Device 1 4 | Device 1 0 | Device 2 1 | Device 2 2 | Device 2 3 | Device 2 4 | Device 2 --test interpolation with big differences in values (test overflows in calculations) --we use the biggest possible difference in time(x) and the value(y). --For bigints we also test values of smaller than bigintmax/min to avoid --the symmetry where x=y (which catches more errors) SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset SELECT time_bucket_gapfill(1,time,0,1) AS time, interpolate(min(s)) AS "smallint", interpolate(min(i)) AS "int", interpolate(min(b)) AS "bigint", interpolate(min(b2)) AS "bigint2", interpolate(min(d)) AS "double" FROM (values (:big_int_min,(-32768)::smallint,(-2147483648)::int,:big_int_min,-2147483648::bigint, '-Infinity'::double precision), (:big_int_max, 32767::smallint, 2147483647::int,:big_int_max, 2147483647::bigint, 'Infinity'::double precision)) v(time,s,i,b,b2,d) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | bigint2 | double ----------------------+----------+-------------+----------------------+-------------+----------- -9223372036854775808 | -32768 | -2147483648 | -9223372036854775808 | -2147483648 | -Infinity 0 | 0 | 0 | 0 | 0 | Infinity 9223372036854775807 | 32767 | 2147483647 | 9223372036854775807 | 2147483647 | Infinity -- issue #2232: This query used to trigger error "could not find -- pathkey item to sort" due to a corrupt query plan SELECT time_bucket_gapfill('1 h', time) AS time, locf(sum(v1)) AS v1_sum, interpolate(sum(v2)) AS v2_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v2_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 06:00:00 2018 PST | 2.1 | 65 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 Mon Jan 01 04:00:00 2018 PST | | -- query without gapfill: SELECT time_bucket('1 h', time) AS time, sum(v1) AS v1_sum, sum(v2) AS v1_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v1_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 -- query to show original data SELECT * FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' ORDER BY 1 DESC, 2; time | device_id | v1 | v2 ------------------------------+-----------+-----+---- Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 -- issue #3048 -- test gapfill/hashagg planner interaction -- this used to produce a plan without gapfill node EXPLAIN (buffers off, costs off) SELECT time_bucket_gapfill('52w', time, start:='2000-01-01', finish:='2000-01-10') AS time, sum(v1) AS v1_sum FROM metrics GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- issue #3834 -- test projection handling in gapfill CREATE TABLE i3834(time timestamptz NOT NULL, ship_id int, value float); SELECT table_name FROM create_hypertable('i3834','time'); table_name ------------ i3834 INSERT INTO i3834 VALUES ('2020-12-01 14:05:00+01',1,3.123), ('2020-12-01 14:05:00+01',2,4.123), ('2020-12-01 14:05:00+01',3,5.123); SELECT time_bucket_gapfill('30000 ms'::interval, time) AS time, ship_id, interpolate (avg(value)), 'speedlog' AS source FROM i3834 WHERE ship_id IN (1, 2) AND time >= '2020-12-01 14:05:00+01' AND time < '2020-12-01 14:10:00+01' GROUP BY 1,2; time | ship_id | interpolate | source ------------------------------+---------+-------------+---------- Tue Dec 01 05:05:00 2020 PST | 1 | 3.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 1 | | speedlog Tue Dec 01 05:06:00 2020 PST | 1 | | speedlog Tue Dec 01 05:06:30 2020 PST | 1 | | speedlog Tue Dec 01 05:07:00 2020 PST | 1 | | speedlog Tue Dec 01 05:07:30 2020 PST | 1 | | speedlog Tue Dec 01 05:08:00 2020 PST | 1 | | speedlog Tue Dec 01 05:08:30 2020 PST | 1 | | speedlog Tue Dec 01 05:09:00 2020 PST | 1 | | speedlog Tue Dec 01 05:09:30 2020 PST | 1 | | speedlog Tue Dec 01 05:05:00 2020 PST | 2 | 4.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 2 | | speedlog Tue Dec 01 05:06:00 2020 PST | 2 | | speedlog Tue Dec 01 05:06:30 2020 PST | 2 | | speedlog Tue Dec 01 05:07:00 2020 PST | 2 | | speedlog Tue Dec 01 05:07:30 2020 PST | 2 | | speedlog Tue Dec 01 05:08:00 2020 PST | 2 | | speedlog Tue Dec 01 05:08:30 2020 PST | 2 | | speedlog Tue Dec 01 05:09:00 2020 PST | 2 | | speedlog Tue Dec 01 05:09:30 2020 PST | 2 | | speedlog DROP TABLE i3834; -- issue #1528 -- test float rounding for certain float values when start and end are identical SELECT time_bucket_gapfill('1min'::interval, ts::timestamptz, start:='2019-11-05 2:20', finish:='2019-11-05 2:30'), interpolate(avg(20266.959547::float4)) AS float4, interpolate(avg(20266.959547::float8)) AS float8 FROM (VALUES ('2019-11-05 2:20'), ('2019-11-05 2:30')) v (ts) GROUP BY 1; time_bucket_gapfill | float4 | float8 ------------------------------+-----------------+-------------- Tue Nov 05 02:20:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:21:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:22:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:23:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:24:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:25:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:26:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:27:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:28:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:29:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:30:00 2019 PST | 20266.958984375 | 20266.959547 -- check gapfill group change detection with TOASTed values CREATE TABLE gapfill_group_toast(time timestamptz NOT NULL, device text, value float); SELECT table_name FROM create_hypertable('gapfill_group_toast', 'time'); table_name --------------------- gapfill_group_toast INSERT INTO gapfill_group_toast SELECT generate_series('2022-06-01'::timestamptz, '2022-06-03'::timestamptz, '1min'::interval), '4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43', random(); ALTER TABLE gapfill_group_toast SET(timescaledb.compress, timescaledb.compress_segmentby = 'device'); SELECT count(compress_chunk(c)) FROM show_chunks('gapfill_group_toast') c; count ------- 2 SELECT time_bucket_gapfill('1 day', time), device FROM gapfill_group_toast WHERE time >= '2022-06-01' AND time <= '2022-06-02' GROUP BY 1,2; time_bucket_gapfill | device ------------------------------+------------------------------------------------------------------ Tue May 31 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 Wed Jun 01 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 DROP TABLE gapfill_group_toast; -- test bucketing by month SELECT time_bucket_gapfill('2 month'::interval, ts, '2000-01-01'::timestamptz,'2001-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SELECT time_bucket_gapfill('1 year'::interval, ts, '2000-01-01'::timestamptz,'2003-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Sun Dec 31 16:00:00 2000 PST Mon Dec 31 16:00:00 2001 PST Tue Dec 31 16:00:00 2002 PST SELECT time_bucket_gapfill('1 century'::interval, ts, '1900-01-01'::timestamptz,'2103-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sun Dec 31 16:00:00 1899 PST Fri Dec 31 16:00:00 1999 PST Thu Dec 31 16:00:00 2099 PST -- test bucketing with timezone SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 15:00:00 1999 PST Tue Feb 29 15:00:00 2000 PST Sun Apr 30 15:00:00 2000 PDT Fri Jun 30 15:00:00 2000 PDT Thu Aug 31 15:00:00 2000 PDT Tue Oct 31 15:00:00 2000 PST Sun Dec 31 15:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, current_setting('timezone'), '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sat Jan 01 00:00:00 2000 PST Wed Mar 01 00:00:00 2000 PST Mon May 01 00:00:00 2000 PDT Sat Jul 01 00:00:00 2000 PDT Fri Sep 01 00:00:00 2000 PDT Wed Nov 01 00:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, 'UTC', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SET timezone TO 'Europe/Berlin'; SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------- Sat Jan 01 00:00:00 2000 CET Wed Mar 01 00:00:00 2000 CET Mon May 01 00:00:00 2000 CEST Sat Jul 01 00:00:00 2000 CEST Fri Sep 01 00:00:00 2000 CEST Wed Nov 01 00:00:00 2000 CET RESET timezone; -- Test gapfill with arrays (#5981) SELECT time_bucket_gapfill(5, ts, 1, 100) as ts, int_arr, locf(last(value, ts)) FROM ( SELECT ARRAY[1,2,3,4]::int[] as int_arr, x as ts, x+500000 as value FROM generate_series(1, 10, 100) as x ) t GROUP BY 1, 2; ts | int_arr | locf ----+-----------+-------- 0 | {1,2,3,4} | 500001 5 | {1,2,3,4} | 500001 10 | {1,2,3,4} | 500001 15 | {1,2,3,4} | 500001 20 | {1,2,3,4} | 500001 25 | {1,2,3,4} | 500001 30 | {1,2,3,4} | 500001 35 | {1,2,3,4} | 500001 40 | {1,2,3,4} | 500001 45 | {1,2,3,4} | 500001 50 | {1,2,3,4} | 500001 55 | {1,2,3,4} | 500001 60 | {1,2,3,4} | 500001 65 | {1,2,3,4} | 500001 70 | {1,2,3,4} | 500001 75 | {1,2,3,4} | 500001 80 | {1,2,3,4} | 500001 85 | {1,2,3,4} | 500001 90 | {1,2,3,4} | 500001 95 | {1,2,3,4} | 500001 -- Test gapfill is aligned with non-gapfill time_bucket -- when using different timezones and month bucketing CREATE TABLE month_timezone(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('month_timezone','time'); table_name ---------------- month_timezone INSERT INTO month_timezone VALUES ('2023-03-01 14:05:00+01', 3.123), ('2023-04-01 14:05:00+01',4.123), ('2023-05-01 14:05:00+01', 5.123); SELECT time_bucket_gapfill('1 month'::interval, time, 'Europe/Berlin', '2023-01-01', '2023-07-01') AS time, sum(value) FROM month_timezone GROUP BY 1; time | sum ------------------------------+------- Sat Dec 31 15:00:00 2022 PST | Tue Jan 31 15:00:00 2023 PST | Tue Feb 28 15:00:00 2023 PST | 3.123 Fri Mar 31 15:00:00 2023 PDT | 4.123 Sun Apr 30 15:00:00 2023 PDT | 5.123 Wed May 31 15:00:00 2023 PDT | Fri Jun 30 15:00:00 2023 PDT | -- Test gapfill respects DST changes when generating timestamps (#6344) SELECT time_bucket_gapfill('1 month', time, 'awst','2023-01-01', '2023-07-01' ) AS month, sum(value) AS sum FROM month_timezone GROUP BY 1; month | sum ------------------------------+------- Sat Dec 31 08:00:00 2022 PST | Tue Jan 31 08:00:00 2023 PST | Tue Feb 28 08:00:00 2023 PST | 3.123 Fri Mar 31 09:00:00 2023 PDT | 4.123 Sun Apr 30 09:00:00 2023 PDT | 5.123 Wed May 31 09:00:00 2023 PDT | Fri Jun 30 09:00:00 2023 PDT | DROP TABLE month_timezone; -- Test gapfill with additional group pathkeys added for optimization (#6396) CREATE TABLE stocks_real_time ( time TIMESTAMPTZ NOT NULL, symbol TEXT NOT NULL, price DOUBLE PRECISION NULL, day_volume INT NULL ); INSERT INTO stocks_real_time VALUES (NOW(), 's1', 70.0, 50), (NOW(), 's2', 66.5, 60), (NOW(), 's3', 77.0, 65); SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1; day | symbol_count ------------------------------+-------------- Thu Nov 30 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Sat Dec 09 16:00:00 2023 PST | SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1 ORDER BY 1 DESC; day | symbol_count ------------------------------+-------------- Sat Dec 09 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Thu Nov 30 16:00:00 2023 PST | DROP TABLE stocks_real_time; SET timezone TO 'Europe/Berlin'; -- check dst switching is handled correctly #6788 SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 03:00:00 2024 CEST SELECT time_bucket_gapfill('30 minutes', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 01:30:00 2024 CET Sun Mar 31 03:00:00 2024 CEST Sun Mar 31 03:30:00 2024 CEST SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-10-26T23:00Z', '2024-10-27T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Oct 27 01:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CET RESET timezone; ������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/gapfill-18.out������������������������������������������0000664�0000000�0000000�00000602544�15100345067�0023313�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' -- we want to see error details in the output \set VERBOSITY default CREATE TABLE gapfill_plan_test(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('gapfill_plan_test','time',chunk_time_interval=>'4 weeks'::interval); table_name ------------------- gapfill_plan_test INSERT INTO gapfill_plan_test SELECT generate_series('2018-01-01'::timestamptz,'2018-04-01'::timestamptz,'1m'::interval), 1.0; -- simple example :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sorting :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test sort direction :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1 DESC; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) DESC -> Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) NULLS FIRST -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now()) -> Values Scan on "*VALUES*" -- test order by aggregate function :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2,1; --- QUERY PLAN --- Sort Sort Key: (avg("*VALUES*".column2)), (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test query without order by :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, "*VALUES*".column1, now(), now())) -> Values Scan on "*VALUES*" -- test parallel query :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), avg(value) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- test parallel query with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- make sure we can run gapfill in parallel workers -- ensure this plan runs in parallel :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; --- QUERY PLAN --- Limit -> Sort Sort Key: (interpolate(avg(gapfill_plan_test.value), NULL::record, NULL::record)) -> Custom Scan (GapFill) -> Finalize GroupAggregate Group Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Gather Merge Workers Planned: 2 -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> Partial HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Parallel Append -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -> Parallel Seq Scan on _hyper_X_X_chunk -- actually run a parallel gapfill SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; time_bucket_gapfill | interpolate ------------------------------+------------- Mon Jan 01 00:00:00 2018 PST | 1 -- test sort optimizations -- test sort optimization with single member order by, -- should use index scan (no GapFill node for this one since we're not gapfilling) :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk SET max_parallel_workers_per_gather TO 0; -- test sort optimizations with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimizations with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone, 'Wed Dec 31 16:00:00 1969 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk RESET max_parallel_workers_per_gather; CREATE INDEX gapfill_plan_test_indx ON gapfill_plan_test(value, time); -- test sort optimization with ordering by multiple columns and time_bucket_gapfill not last, -- must not use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1,2; --- QUERY PLAN --- Sort Sort Key: (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)), gapfill_plan_test.value -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- test sort optimization with ordering by multiple columns and time_bucket as last member, -- should use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 2,1; --- QUERY PLAN --- Incremental Sort Sort Key: gapfill_plan_test.value, (time_bucket_gapfill('@ 5 mins'::interval, gapfill_plan_test."time", NULL::timestamp with time zone, NULL::timestamp with time zone)) Presorted Key: gapfill_plan_test.value -> Result -> Merge Append Sort Key: gapfill_plan_test.value -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk -> Index Only Scan using _hyper_X_X_chunk_gapfill_plan_test_indx on _hyper_X_X_chunk DROP TABLE gapfill_plan_test; \set METRICS metrics_int -- All test against table :METRICS first \set ON_ERROR_STOP 0 -- inverse of previous test query to confirm an error is actually thrown SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time = 5 GROUP BY 1,2,3 ORDER BY 2,3,1; ERROR: division by zero -- test window functions with multiple column references SELECT time_bucket_gapfill(1,time,1,2), first(min(time),min(time)) OVER () FROM :METRICS GROUP BY 1; ERROR: window functions with multiple column references not supported -- test with unsupported operator SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time =0 AND time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test with 2 tables and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test inner join and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time WHERE m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- test outer join with constraints in join condition -- not usable as start/stop SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 LEFT OUTER JOIN :METRICS m2 ON m1.time=m2.time AND m1.time >=0 AND m1.time < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 \ir include/gapfill_metrics_query.sql -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test locf lookup query does not trigger when not needed -- -- 1/(SELECT 0) will throw an error in the lookup query but in order to not -- always trigger evaluation it needs to be correlated otherwise postgres will -- always run it once even if the value is never used SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | locf3 ------+-----------+-----------+------- 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 -- test locf with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value)::int,23) AS locf1, locf(min(value)::int,(SELECT 42)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 1 | | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and "wrong order" SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value),23::float) AS locf1, locf(min(value),(SELECT 42::float)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 1,2,3; time | device_id | sensor_id | avg | locf | locf1 | locf2 | locf3 ------+-----------+-----------+-----+------+-------+-------+------- 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 0 | 1 | 2 | | | 23 | 42 | -100 5 | 1 | 1 | | 5 | 5 | 5 | 5 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 1 | | 5 | 5 | 5 | 5 10 | 1 | 2 | | 10 | 10 | 10 | 10 -- test locf with correlated subquery and window functions SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)), sum(locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1))) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3; time | device_id | sensor_id | locf | sum ------+-----------+-----------+------+------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 5 | 10 10 | 1 | 1 | 5 | 10 0 | 1 | 2 | -100 | -100 5 | 1 | 2 | 10 | -90 10 | 1 | 2 | 10 | 20 -- test JOINs SELECT time_bucket_gapfill(1,time,0,5) as time, device_id, d.name, sensor_id, s.name, avg(m.value) FROM :METRICS m INNER JOIN devices d USING(device_id) INNER JOIN sensors s USING(sensor_id) WHERE time BETWEEN 0 AND 5 GROUP BY 1,2,3,4,5; time | device_id | name | sensor_id | name | avg ------+-----------+----------+-----------+----------+----- 0 | 1 | Device 1 | 1 | Sensor 1 | 5 1 | 1 | Device 1 | 1 | Sensor 1 | 2 | 1 | Device 1 | 1 | Sensor 1 | 3 | 1 | Device 1 | 1 | Sensor 1 | 4 | 1 | Device 1 | 1 | Sensor 1 | 0 | 1 | Device 1 | 2 | Sensor 2 | 1 | 1 | Device 1 | 2 | Sensor 2 | 2 | 1 | Device 1 | 2 | Sensor 2 | 3 | 1 | Device 1 | 2 | Sensor 2 | 4 | 1 | Device 1 | 2 | Sensor 2 | 5 | 1 | Device 1 | 2 | Sensor 2 | 10 -- test interpolate with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), interpolate(min(value)) AS ip, interpolate(min(value),(-5,-5.0::float),(15,20.0::float)) AS ip1, interpolate(min(value),(SELECT (-10,-10.0::float)),(SELECT (15,20.0::float))) AS ip2, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) AS ip3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | avg | ip | ip1 | ip2 | ip3 ------+-----------+-----------+-----+----+-----+------------------+------------------ 0 | 1 | 1 | 5 | 5 | 5 | 5 | 5 5 | 1 | 1 | | | 10 | 10 | 4.75 10 | 1 | 1 | | | 15 | 15 | 4.5 0 | 1 | 2 | | | 2.5 | 3.33333333333333 | 4.76190476190476 5 | 1 | 2 | 10 | 10 | 10 | 10 | 10 10 | 1 | 2 | | | 15 | 15 | 4.21052631578947 -- test interpolate with correlated subquery and window function SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ), sum(interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) )) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; time | device_id | sensor_id | interpolate | sum ------+-----------+-----------+------------------+------------------ 0 | 1 | 1 | 5 | 5 5 | 1 | 1 | 4.75 | 9.75 10 | 1 | 1 | 4.5 | 9.25 0 | 1 | 2 | 4.76190476190476 | 4.76190476190476 5 | 1 | 2 | 10 | 14.7619047619048 10 | 1 | 2 | 4.21052631578947 | 14.2105263157895 -- test subqueries -- subqueries will alter the shape of the plan and top-level constraints -- might not end up in top-level of jointree SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 WHERE m1.time >=0 AND m1.time < 2 AND device_id IN (SELECT device_id FROM :METRICS) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test inner join with constraints in join condition SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time AND m2.time >=0 AND m2.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test actual table SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time >=0 AND time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with table alias SELECT time_bucket_gapfill(1,time) FROM :METRICS m WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test with 2 tables SELECT time_bucket_gapfill(1,m.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 -- test prepared statement with locf with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 EXECUTE prep_gapfill; time | device_id | sensor_id | locf ------+-----------+-----------+------ 0 | 1 | 1 | 5 5 | 1 | 1 | 5 10 | 1 | 1 | 5 DEALLOCATE prep_gapfill; -- test prepared statement with interpolate with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 EXECUTE prep_gapfill; time | device_id | sensor_id | interpolate ------+-----------+-----------+------------------ 0 | 1 | 1 | 5 5 | 1 | 1 | 4.75 10 | 1 | 1 | 4.5 0 | 1 | 2 | 4.76190476190476 5 | 1 | 2 | 10 10 | 1 | 2 | 4.21052631578947 DEALLOCATE prep_gapfill; -- test prepared statement with variable gapfill arguments PREPARE prep_gapfill(int,int,int) AS SELECT time_bucket_gapfill($1,time,$2,$3) AS time, device_id, sensor_id, min(value) FROM :METRICS m1 WHERE time >= $2 AND time < $3 AND device_id=1 AND sensor_id=1 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | EXECUTE prep_gapfill(5,0,10); time | device_id | sensor_id | min ------+-----------+-----------+----- 0 | 1 | 1 | 5 5 | 1 | 1 | EXECUTE prep_gapfill(4,100,110); time | device_id | sensor_id | min ------+-----------+-----------+----- 100 | 1 | 1 | 0 104 | 1 | 1 | 108 | 1 | 1 | DEALLOCATE prep_gapfill; -- Tests without tables -- test locf and interpolate call without gapfill SELECT locf(1); locf ------ 1 SELECT interpolate(1); interpolate ------------- 1 -- test locf and interpolate call with NULL input SELECT locf(NULL::int); locf ------ SELECT interpolate(NULL::bigint); interpolate ------------- \set ON_ERROR_STOP 0 -- test time_bucket_gapfill not top level function call SELECT 1 + time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: no top level time_bucket_gapfill in group by clause -- test locf with treat_null_as_missing not BOOL SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=1) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function locf(integer, treat_null_as_missing => integer) does not exist LINE 3: locf(min(time),treat_null_as_missing:=1) ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test locf with treat_null_as_missing not literal SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=random()>0) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid locf argument: treat_null_as_missing must be a BOOL literal -- test interpolate lookup query with 1 element in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT ROW(10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT ROW(10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with 3 elements in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: interpolate RECORD arguments must have 2 elements -- test interpolate lookup query with mismatching time datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10::float,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10::float,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: first argument of interpolate returned record must match used timestamp datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate lookup query with mismatching value datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10::float))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10::float))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: second argument of interpolate returned record must match used interpolate datatype DETAIL: Returned type double precision does not match expected type integer. -- test interpolate with unsupported datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(text 'text') FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: function interpolate(text) does not exist LINE 3: interpolate(text 'text') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. SELECT time_bucket_gapfill(1,time,1,11), interpolate(interval '1d') FROM (VALUES (2),(3)) v(time) GROUP BY 1; ERROR: function interpolate(interval) does not exist LINE 3: interpolate(interval '1d') ^ HINT: No function matches the given name and argument types. You might need to add explicit type casts. -- test multiple time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time,1,11),time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time_bucket_gapfill(1,time,1,11),1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple time_bucket_gapfill calls not allowed -- test nested locf calls SELECT time_bucket_gapfill(1,time,1,11), locf(locf(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test nested interpolate calls SELECT time_bucket_gapfill(1,time,1,11), interpolate(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test mixed locf/interpolate calls SELECT time_bucket_gapfill(1,time,1,11), locf(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple interpolate/locf function calls per resultset column not supported -- test window function inside locf SELECT time_bucket_gapfill(1,time,1,11), locf(avg(min(time)) OVER ()) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window functions must not be below locf -- test nested window functions -- prevented by postgres SELECT time_bucket_gapfill(1,time,1,11), avg(avg(min(time)) OVER ()) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: window function calls cannot be nested LINE 3: avg(avg(min(time)) OVER ()) OVER () ^ -- test multiple window functions in single column SELECT time_bucket_gapfill(1,time,1,11), avg(min(time)) OVER () + avg(min(time)) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: multiple window function calls per column not supported -- test locf not toplevel SELECT time_bucket_gapfill(1,time,1,11), 1 + locf(min(time)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: locf must be toplevel function call -- test locf inside aggregate SELECT time_bucket_gapfill(1,time,1,11), min(min(locf(time))) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: aggregate functions must be below locf -- test NULL args SELECT time_bucket_gapfill(NULL,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill(1,NULL,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill(1,time,NULL,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(1,time,1,NULL) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. SELECT time_bucket_gapfill(NULL,time,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width cannot be NULL SELECT time_bucket_gapfill('1day',NULL,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts cannot be NULL SELECT time_bucket_gapfill('1day',time,NULL,'2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: timezone cannot be NULL -- test 0 bucket_width SELECT time_bucket_gapfill(0,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test negative bucket_width SELECT time_bucket_gapfill(-1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be greater than 0 -- test subqueries as interval, start and stop (not supported atm) SELECT time_bucket_gapfill((SELECT 1),time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression SELECT time_bucket_gapfill(1,time,(SELECT 1),11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression SELECT time_bucket_gapfill(1,time,1,(SELECT 11)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression \set ON_ERROR_STOP 1 -- test time_bucket_gapfill without aggregation -- this will not trigger gapfilling SELECT time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time); time_bucket_gapfill --------------------- 1 2 SELECT time_bucket_gapfill(1,time,1,11), avg(time) OVER () FROM (VALUES (1),(2)) v(time); time_bucket_gapfill | avg ---------------------+-------------------- 1 | 1.5000000000000000 2 | 1.5000000000000000 -- test int int2/4/8 SELECT time_bucket_gapfill(1::int2,time::int2,0::int2,6::int2) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int4,time::int4,0::int4,6::int4) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 SELECT time_bucket_gapfill(1::int8,time::int8,0::int8,6::int8) FROM (VALUES (1),(4)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 4 5 -- test non-aligned bucket start SELECT time_bucket_gapfill(10,time,5,40) FROM (VALUES (11),(22)) v(time) GROUP BY 1; time_bucket_gapfill --------------------- 0 10 20 30 -- simple gapfill query SELECT time_bucket_gapfill(10,time,0,50) AS time, min(value) AS value FROM (values (-10,1),(10,2),(11,3),(12,4),(22,5),(30,6),(66,7)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- -10 | 1 0 | 10 | 2 20 | 5 30 | 6 40 | 60 | 7 -- test references to different columns SELECT time_bucket_gapfill(1,t,0,5) as t, min(t),max(t),min(v),max(v) FROM(VALUES (1,3),(2,5)) tb(t,v) GROUP BY 1 ORDER BY 1; t | min | max | min | max ---+-----+-----+-----+----- 0 | | | | 1 | 1 | 1 | 3 | 3 2 | 2 | 2 | 5 | 5 3 | | | | 4 | | | | -- test passing of values outside boundaries SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (-1),(1),(3),(6)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- -1 | -1 0 | 1 | 1 2 | 3 | 3 4 | 6 | 6 -- test gap fill before first row and after last row SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 1 2 | 2 3 | 3 4 | -- test gap fill without rows in resultset SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) WHERE false GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+----- 0 | 1 | 2 | 3 | 4 | -- test coalesce SELECT time_bucket_gapfill(1,time,0,5), coalesce(min(time),0), coalesce(min(value),0), coalesce(min(value),7) FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | coalesce | coalesce | coalesce ---------------------+----------+----------+---------- 0 | 0 | 0 | 7 1 | 1 | 1 | 1 2 | 2 | 2 | 2 3 | 3 | 3 | 3 4 | 0 | 0 | 7 -- test case SELECT time_bucket_gapfill(1,time,0,5), min(time), CASE WHEN min(time) IS NOT NULL THEN min(time) ELSE -1 END, CASE WHEN min(time) IS NOT NULL THEN min(time) + 7 ELSE 0 END, CASE WHEN 1 = 1 THEN 1 ELSE 0 END FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | case | case | case ---------------------+-----+------+------+------ 0 | | -1 | 0 | 1 1 | 1 | 1 | 8 | 1 2 | 2 | 2 | 9 | 1 3 | 3 | 3 | 10 | 1 4 | | -1 | 0 | 1 -- test constants SELECT time_bucket_gapfill(1,time,0,5), min(time), min(time), 4 as c FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min | min | c ---------------------+-----+-----+--- 0 | | | 4 1 | 1 | 1 | 4 2 | 2 | 2 | 4 3 | 3 | 3 | 4 4 | | | 4 -- test column reordering SELECT 1 as c1, '2' as c2, time_bucket_gapfill(1,time,0,5), 3.0 as c3, min(time), min(time), 4 as c4 FROM (VALUES (1),(2),(3)) v(time) GROUP BY 3 ORDER BY 3; c1 | c2 | time_bucket_gapfill | c3 | min | min | c4 ----+----+---------------------+-----+-----+-----+---- 1 | 2 | 0 | 3.0 | | | 4 1 | 2 | 1 | 3.0 | 1 | 1 | 4 1 | 2 | 2 | 3.0 | 2 | 2 | 4 1 | 2 | 3 | 3.0 | 3 | 3 | 4 1 | 2 | 4 | 3.0 | | | 4 -- test timestamptz SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMPTZ '2000-01-01',TIMESTAMPTZ '2000-01-02'), min(time) FROM (VALUES (TIMESTAMPTZ '2000-01-01 9:00:00'),(TIMESTAMPTZ '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ------------------------------+------------------------------ Fri Dec 31 22:00:00 1999 PST | Sat Jan 01 04:00:00 2000 PST | Sat Jan 01 09:00:00 2000 PST Sat Jan 01 10:00:00 2000 PST | Sat Jan 01 16:00:00 2000 PST | Sat Jan 01 18:00:00 2000 PST Sat Jan 01 22:00:00 2000 PST | -- test timestamp SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMP '2000-01-01',TIMESTAMP '2000-01-02'), min(time) FROM (VALUES (TIMESTAMP '2000-01-01 9:00:00'),(TIMESTAMP '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min --------------------------+-------------------------- Sat Jan 01 00:00:00 2000 | Sat Jan 01 06:00:00 2000 | Sat Jan 01 09:00:00 2000 Sat Jan 01 12:00:00 2000 | Sat Jan 01 18:00:00 2000 | Sat Jan 01 18:00:00 2000 -- test date SELECT time_bucket_gapfill(INTERVAL '1w',time,DATE '2000-01-01',DATE '2000-02-10'), min(time) FROM (VALUES (DATE '2000-01-08'),(DATE '2000-01-22')) v(time) GROUP BY 1 ORDER BY 1; time_bucket_gapfill | min ---------------------+------------ 12-27-1999 | 01-03-2000 | 01-08-2000 01-10-2000 | 01-17-2000 | 01-22-2000 01-24-2000 | 01-31-2000 | 02-07-2000 | -- test grouping by non-time columns SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test grouping by non-time columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) WHERE false GROUP BY 1,id ORDER BY 2,1; time | id | m ------+----+--- -- test duplicate columns in GROUP BY SELECT time_bucket_gapfill(1,time,0,5) as time, id, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,2,3 ORDER BY 2,1; time | id | id | m ------+----+----+--- 0 | 1 | 1 | 1 | 1 | 1 | 1 2 | 1 | 1 | 3 | 1 | 1 | 4 | 1 | 1 | 0 | 2 | 2 | 1 | 2 | 2 | 2 | 2 | 2 | 2 3 | 2 | 2 | 4 | 2 | 2 | -- test grouping by columns not in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY id,1; time | m ------+--- 0 | 1 | 1 2 | 3 | 4 | 0 | 1 | 2 | 2 3 | 4 | -- test grouping by non-time columns with text columns SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 1 | blue | 1 2 | blue | 3 | blue | 4 | blue | 0 | red | 1 | red | 2 | red | 2 3 | red | 4 | red | -- test grouping by non-time columns with text columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) WHERE false GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- --- test insert into SELECT CREATE TABLE gapfill_insert_test(id INT); INSERT INTO gapfill_insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM gapfill_insert_test; id ---- 1 2 3 4 DROP TABLE gapfill_insert_test; -- test join SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'red',1),(2,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | m | m ------+-------+---+--- 0 | blue | | 1 | blue | | 2 | blue | 2 | 3 | blue | | 4 | blue | | 2 0 | red | | 1 | red | 1 | 2 | red | | 3 | red | | 1 4 | red | | -- test join with locf SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as locf FROM (VALUES (0,'red',1),(0,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; time | color | locf | m ------+-------+------+--- 0 | blue | 2 | 1 | blue | 2 | 2 | blue | 2 | 3 | blue | 2 | 4 | blue | 2 | 2 0 | red | 1 | 1 | red | 1 | 2 | red | 1 | 3 | red | 1 | 1 4 | red | 1 | 1 -- test locf SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in resultset SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=NULL) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 40 | 50 | 6 -- test locf with NULLs in resultset and treat_null_as_missing SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 10 | 9 20 | 3 30 | 3 40 | 3 50 | 6 -- test locf with NULLs in first row of resultset and treat_null_as_missing with lookup query SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false, prev := (SELECT 100)) AS v1, locf(min(value),treat_null_as_missing:=true, prev := (SELECT 100)) AS v2 FROM (values (0,NULL),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | v1 | v2 ------+----+----- 0 | | 100 10 | | 100 20 | | 100 30 | | 100 40 | | 100 50 | 6 | 6 -- test locf with NULLs in resultset and treat_null_as_missing with resort SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1 DESC; time | value ------+------- 50 | 6 40 | 3 30 | 3 20 | 3 10 | 9 0 | -- test locf with constants SELECT time_bucket_gapfill(1,time,0,5), 2, locf(min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | ?column? | locf ---------------------+----------+------ 0 | 2 | 1 1 | 2 | 1 2 | 2 | 1 3 | 2 | 1 4 | 2 | 2 -- test expressions inside locf SELECT time_bucket_gapfill(1,time,0,5), locf(min(value)), locf(4), locf(4 + min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; time_bucket_gapfill | locf | locf | locf ---------------------+------+------+------ 0 | 1 | 4 | 5 1 | 1 | 4 | 5 2 | 1 | 4 | 5 3 | 1 | 4 | 5 4 | 2 | 4 | 6 -- test locf with out of boundary lookup SELECT time_bucket_gapfill(10,time,0,70) AS time, locf(min(value),(SELECT 100)) AS value FROM (values (20,9),(40,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 100 10 | 100 20 | 9 30 | 9 40 | 6 50 | 6 60 | 6 -- test locf with different datatypes SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1)) AS text, locf(min(v2)) AS "int[]", locf(min(v3)) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test locf with different datatypes and treat_null_as_missing SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1),treat_null_as_missing:=true) AS text, locf(min(v2),treat_null_as_missing:=true) AS "int[]", locf(min(v3),treat_null_as_missing:=true) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (2,NULL,NULL,NULL), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; time | text | int[] | text 4/8k ------+------+---------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | | | 1 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 2 | foo | {1,2,3} | 4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k4k 3 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k 4 | bar | {3,4,5} | 8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k8k -- test interpolate SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(value)) AS value FROM (values (0,1),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; time | value ------+------- 0 | 1 10 | 2 20 | 3 30 | 4 40 | 5 50 | 6 -- test interpolate with NULL values SELECT time_bucket_gapfill(1,time,0,5) AS time, interpolate(avg(temp)) AS temp FROM (VALUES (0,0),(2,NULL),(5,5)) v(time,temp) GROUP BY 1; time | temp ------+------ 0 | 0 1 | 2 | 3 | 4 | 5 | 5 -- test interpolate datatypes SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (0,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(50,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- 0 | -3 | -3 | -3 | -3 | -3 10 | -2 | -2 | -2 | -1.8 | -1.8 20 | -1 | -1 | -1 | -0.6 | -0.6 30 | 1 | 1 | 1 | 0.6 | 0.6 40 | 2 | 2 | 2 | 1.8 | 1.8 50 | 3 | 3 | 3 | 3 | 3 -- test interpolate datatypes with negative time SELECT time_bucket_gapfill(10,time,-40,30) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (-40,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(20,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | float4 | float8 ------+----------+-----+--------+--------+-------- -40 | -3 | -3 | -3 | -3 | -3 -30 | -2 | -2 | -2 | -2 | -2 -20 | -1 | -1 | -1 | -1 | -1 -10 | 0 | 0 | 0 | 0 | 0 0 | 1 | 1 | 1 | 1 | 1 10 | 2 | 2 | 2 | 2 | 2 20 | 3 | 3 | 3 | 3 | 3 -- test interpolate with multiple groupings SELECT time_bucket_gapfill(5,time,0,11), device, interpolate(min(v1),(SELECT (-10,-10)),(SELECT (20,10))) FROM (VALUES (5,1,0),(5,2,0)) as v(time,device,v1) GROUP BY 1,2 ORDER BY 2,1; time_bucket_gapfill | device | interpolate ---------------------+--------+------------- 0 | 1 | -3 5 | 1 | 0 10 | 1 | 3 0 | 2 | -3 5 | 2 | 0 10 | 2 | 3 -- test cte with gap filling in outer query WITH data AS ( SELECT * FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) ) SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM data GROUP BY 1,id; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test cte with gap filling in inner query WITH gapfill AS ( SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ) SELECT * FROM gapfill; time | id | m ------+----+--- 0 | 1 | 1 | 1 | 1 2 | 1 | 3 | 1 | 4 | 1 | 0 | 2 | 1 | 2 | 2 | 2 | 2 3 | 2 | 4 | 2 | -- test window functions SELECT time_bucket_gapfill(10,time,0,60), interpolate(min(time)), lag(min(time)) OVER () FROM (VALUES (0),(50)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | lag ---------------------+-------------+----- 0 | 0 | 10 | 10 | 0 20 | 20 | 30 | 30 | 40 | 40 | 50 | 50 | -- test window functions with multiple windows SELECT time_bucket_gapfill(1,time,0,10), interpolate(min(time)), row_number() OVER (), locf(min(time)), sum(interpolate(min(time))) OVER (ROWS 1 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 2 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 3 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 4 PRECEDING) FROM (VALUES (0),(9)) v(time) GROUP BY 1; time_bucket_gapfill | interpolate | row_number | locf | sum | sum | sum | sum ---------------------+-------------+------------+------+-----+-----+-----+----- 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 1 | 1 | 2 | 0 | 1 | 1 | 1 | 1 2 | 2 | 3 | 0 | 3 | 3 | 3 | 3 3 | 3 | 4 | 0 | 5 | 6 | 6 | 6 4 | 4 | 5 | 0 | 7 | 9 | 10 | 10 5 | 5 | 6 | 0 | 9 | 12 | 14 | 15 6 | 6 | 7 | 0 | 11 | 15 | 18 | 20 7 | 7 | 8 | 0 | 13 | 18 | 22 | 25 8 | 8 | 9 | 0 | 15 | 21 | 26 | 30 9 | 9 | 10 | 9 | 17 | 24 | 30 | 35 -- test window functions with constants SELECT time_bucket_gapfill(1,time,0,5), min(time), 4 as c, lag(min(time)) OVER () FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | c | lag ---------------------+-----+---+----- 0 | | 4 | 1 | 1 | 4 | 2 | 2 | 4 | 1 3 | 3 | 4 | 2 4 | | 4 | 3 --test window functions with locf SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, locf(min(time)) AS locf, lag(locf(min(time))) over () AS lag_locf, lead(locf(min(time))) over () AS lead_locf FROM (VALUES (1),(2)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | locf | lag_locf | lead_locf ---------------------+-----+---------+----------+------+----------+----------- 0 | | | 1 | | | 1 1 | 1 | | 2 | 1 | | 2 2 | 2 | 1 | | 2 | 1 | 2 3 | | 2 | | 2 | 2 | 2 4 | | | | 2 | 2 | --test window functions with interpolate SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, lead(interpolate(min(time))) over () AS lead_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lead_min | interpolate | lag_interpolate | lead_interpolate ---------------------+-----+---------+----------+-------------+-----------------+------------------ 0 | | | 1 | | | 1 1 | 1 | | | 1 | | 2 2 | | 1 | 3 | 2 | 1 | 3 3 | 3 | | | 3 | 2 | 4 | | 3 | | | 3 | --test window functions with expressions SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, 1 + lag(min(time)) over () AS lag_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, 1 + lag(interpolate(min(time))) over () AS lag_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | min | lag_min | lag_min | interpolate | lag_interpolate | lag_interpolate ---------------------+-----+---------+---------+-------------+-----------------+----------------- 0 | | | | | | 1 | 1 | | | 1 | | 2 | | 1 | 2 | 2 | 1 | 2 3 | 3 | | | 3 | 2 | 3 4 | | 3 | 4 | | 3 | 4 --test row_number/rank/percent_rank/... window functions with gapfill reference SELECT time_bucket_gapfill(1,time,0,5), ntile(2) OVER () AS ntile_2, ntile(3) OVER () AS ntile_3, ntile(5) OVER () AS ntile_5, row_number() OVER (), cume_dist() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), rank() OVER (), rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), percent_rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)) FROM (VALUES (1),(3)) v(time) GROUP BY 1; time_bucket_gapfill | ntile_2 | ntile_3 | ntile_5 | row_number | cume_dist | rank | rank | percent_rank ---------------------+---------+---------+---------+------------+-----------+------+------+-------------- 0 | 1 | 1 | 1 | 1 | 0.2 | 1 | 1 | 0 1 | 1 | 1 | 2 | 2 | 0.4 | 1 | 2 | 0.25 2 | 1 | 2 | 3 | 3 | 0.6 | 1 | 3 | 0.5 3 | 2 | 2 | 4 | 4 | 0.8 | 1 | 4 | 0.75 4 | 2 | 3 | 5 | 5 | 1 | 1 | 5 | 1 -- test first_value/last_value/nth_value SELECT time_bucket_gapfill(1,time,0,5), first_value(min(time)) OVER (), nth_value(min(time),3) OVER (), last_value(min(time)) OVER () FROM (VALUES (0),(2),(5)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | nth_value | last_value ---------------------+-------------+-----------+------------ 0 | 0 | 2 | 5 1 | 0 | 2 | 5 2 | 0 | 2 | 5 3 | 0 | 2 | 5 4 | 0 | 2 | 5 5 | 0 | 2 | 5 -- test window functions with PARTITION BY SELECT time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (), row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | row_number | row_number ------+-------+------------+------------ 0 | blue | 1 | 1 1 | blue | 2 | 2 2 | blue | 3 | 3 3 | blue | 4 | 4 4 | blue | 5 | 5 0 | red | 6 | 1 1 | red | 7 | 2 2 | red | 8 | 3 3 | red | 9 | 4 4 | red | 10 | 5 -- test multiple windows \set ON_ERROR_STOP 0 SELECT time_bucket_gapfill(1,time,0,11), first_value(interpolate(min(time))) OVER (ROWS 1 PRECEDING), interpolate(min(time)), last_value(interpolate(min(time))) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM (VALUES (0),(10)) v(time) GROUP BY 1; time_bucket_gapfill | first_value | interpolate | last_value ---------------------+-------------+-------------+------------ 0 | 0 | 0 | 1 1 | 0 | 1 | 2 2 | 1 | 2 | 3 3 | 2 | 3 | 4 4 | 3 | 4 | 5 5 | 4 | 5 | 6 6 | 5 | 6 | 7 7 | 6 | 7 | 8 8 | 7 | 8 | 9 9 | 8 | 9 | 10 10 | 9 | 10 | 10 -- test reorder SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 1,id; time | id | m ------+----+--- 0 | 1 | 0 | 2 | 1 | 1 | 1 1 | 2 | 2 | 1 | 2 | 2 | 2 3 | 1 | 3 | 2 | 4 | 1 | 4 | 2 | -- test order by locf SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | locf ---------------------+------ 1 | 2 | 2 3 | 3 4 | 3 5 | 3 SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | locf ---------------------+------ 2 | 2 3 | 3 4 | 3 5 | 3 1 | -- test order by interpolate SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; time_bucket_gapfill | interpolate ---------------------+------------- 4 | 5 | 1 | 1 2 | 2 3 | 3 SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; time_bucket_gapfill | interpolate ---------------------+------------- 1 | 1 2 | 2 3 | 3 4 | 5 | -- test queries on hypertable -- test locf and interpolate together SELECT time_bucket_gapfill(interval '1h',time,timestamptz '2018-01-01 05:00:00-8', timestamptz '2018-01-01 07:00:00-8'), device_id, locf(avg(v1)) AS locf_v1, locf(min(v2)) AS locf_v2, interpolate(avg(v1)) AS interpolate_v1, interpolate(avg(v2)) AS interpolate_v2 FROM metrics_tstz GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | locf_v1 | locf_v2 | interpolate_v1 | interpolate_v2 ------------------------------+-----------+---------+---------+----------------+---------------- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 06:00:00 2018 PST | 1 | 0.5 | 10 | 0.25 | 5 Mon Jan 01 06:00:00 2018 PST | 2 | 0.7 | 20 | 1.05 | 30 Mon Jan 01 06:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 | 0.9 | 30 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz) < '2017-01-01' GROUP BY 1; time_bucket_gapfill | interpolate ------------------------------+------------------- Sat Dec 31 16:00:00 2016 PST | 0.666666666666667 Sun Jan 01 04:00:00 2017 PST | 1.16666666666667 Sun Jan 01 16:00:00 2017 PST | 1.66666666666667 -- interpolation with correlated subquery lookup before interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 3:00 PST'::timestamptz, '2018-01-01 8:00 PST'::timestamptz), device_id, interpolate( avg(v1), (SELECT (time,0.5::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time DESC LIMIT 1) ), avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 03:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 04:00:00 2018 PST | 1 | 0.5 | Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 -- interpolation with correlated subquery lookup after interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 5:00 PST'::timestamptz, '2018-01-01 9:00 PST'::timestamptz), device_id, interpolate( avg(v1), next=>(SELECT (time,v2::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time LIMIT 1) ),avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; time_bucket_gapfill | device_id | interpolate | avg ------------------------------+-----------+-------------+----- Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 0.5 Mon Jan 01 06:00:00 2018 PST | 1 | 0.25 | Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 08:00:00 2018 PST | 1 | -5 | \set ON_ERROR_STOP 0 -- bucket_width non simple expression SELECT time_bucket_gapfill(t,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: bucket_width must be a simple expression -- no start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- no start and no usable time constraints SELECT time_bucket_gapfill(1,t,finish:=1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start must be a simple expression -- NULL start and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- unsupported finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish must be a simple expression -- no finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- NULL finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer finish from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with column reference on right side SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > t AND t < 2 GROUP BY 1; ERROR: missing time_bucket_gapfill argument: could not infer start from WHERE clause HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with cast SELECT time_bucket_gapfill(1,t1::int8) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 >= 1 AND t1 <= 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with multiple column references SELECT time_bucket_gapfill(1,t1+t2) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 1 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL start in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END AND t1 < 4 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- expression with NULL finish in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as start argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: start cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- non-Const NULL as finish argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,NULL,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: finish cannot be NULL HINT: Specify start and finish as arguments or in the WHERE clause. -- time_bucket_gapfill with constraints ORed SELECT time_bucket_gapfill(1::int8,t::int8) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 OR t < 3 GROUP BY 1; ERROR: invalid time_bucket_gapfill argument: ts needs to refer to a single column if no start or finish is supplied HINT: Specify start and finish as arguments or in the WHERE clause. \set ON_ERROR_STOP 1 -- int32 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- same query with less or equal as finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t <= 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 3 -- int32 time_bucket_gapfill with start column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE -1 < t AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 -- int32 time_bucket_gapfill with finish column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= 0 AND 3 >= t GROUP BY 1; time_bucket_gapfill --------------------- 0 1 2 3 -- int16 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int2,t) FROM (VALUES (1::int2),(2::int2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- int64 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int8,t) FROM (VALUES (1::int8),(2::int8)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- date time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('1d'::interval,t) FROM (VALUES ('1999-12-30'::date),('2000-01-01'::date)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill --------------------- 12-29-1999 12-30-1999 12-31-1999 01-01-2000 01-02-2000 -- timestamp time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamp),('2000-01-01'::timestamp)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill -------------------------- Wed Dec 29 00:00:00 1999 Wed Dec 29 12:00:00 1999 Thu Dec 30 00:00:00 1999 Thu Dec 30 12:00:00 1999 Fri Dec 31 00:00:00 1999 Fri Dec 31 12:00:00 1999 Sat Jan 01 00:00:00 2000 Sat Jan 01 12:00:00 2000 Sun Jan 02 00:00:00 2000 Sun Jan 02 12:00:00 2000 -- timestamptz time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Tue Dec 28 16:00:00 1999 PST Wed Dec 29 04:00:00 1999 PST Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with more complex expression SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03' GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- timestamptz time_bucket_gapfill with different datatype in finish constraint SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03'::date GROUP BY 1; time_bucket_gapfill ------------------------------ Wed Dec 29 16:00:00 1999 PST Thu Dec 30 04:00:00 1999 PST Thu Dec 30 16:00:00 1999 PST Fri Dec 31 04:00:00 1999 PST Fri Dec 31 16:00:00 1999 PST Sat Jan 01 04:00:00 2000 PST Sat Jan 01 16:00:00 2000 PST Sun Jan 02 04:00:00 2000 PST Sun Jan 02 16:00:00 2000 PST -- time_bucket_gapfill with now() as start SELECT time_bucket_gapfill('1h'::interval,t) FROM (VALUES (now()),(now())) v(t) WHERE t >= now() AND t < now() - '1h'::interval GROUP BY 1; time_bucket_gapfill --------------------- -- time_bucket_gapfill with multiple constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 and t>1 AND t <=4 AND length(version()) > 0 GROUP BY 1; time_bucket_gapfill --------------------- 2 -- int32 time_bucket_gapfill with greater for start SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > -2 AND t < 3 GROUP BY 1; time_bucket_gapfill --------------------- -1 0 1 2 -- test DISTINCT SELECT DISTINCT ON (color) time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; time | color | m ------+-------+--- 0 | blue | 0 | red | -- test DISTINCT with window functions SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER () FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 6 1 | red | 7 2 | red | 8 3 | red | 9 4 | red | 10 -- test DISTINCT with window functions and PARTITION BY SELECT DISTINCT ON (color,row_number() OVER (PARTITION BY color)) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test DISTINCT with window functions not in targetlist SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; time | color | row_number ------+-------+------------ 0 | blue | 1 1 | blue | 2 2 | blue | 3 3 | blue | 4 4 | blue | 5 0 | red | 1 1 | red | 2 2 | red | 3 3 | red | 4 4 | red | 5 -- test column references SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test with Nested Loop SELECT l.id, bucket, data_value FROM (VALUES (1), (2), (3), (4)) a(id) INNER JOIN LATERAL ( SELECT b.id id, time_bucket_gapfill('1'::int, time, start=>'1'::int, finish=> '5'::int) bucket, locf(last(data, time)) data_value FROM (VALUES (1, 1, 1), (1, 4, 4), (2, 1, -1), (2, 4, -4)) b(id, time, data) WHERE a.id = b.id GROUP BY b.id, bucket ) as l on (true); id | bucket | data_value ----+--------+------------ 1 | 1 | 1 1 | 2 | 1 1 | 3 | 1 1 | 4 | 4 2 | 1 | -1 2 | 2 | -1 2 | 3 | -1 2 | 4 | -4 -- test prepared statement PREPARE prep_gapfill AS SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(value)) FROM (VALUES (1,1),(2,2)) v(time,value) GROUP BY 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 EXECUTE prep_gapfill; time | locf ------+------ 0 | 1 | 1 2 | 2 3 | 2 4 | 2 DEALLOCATE prep_gapfill; -- test column references with TIME_COLUMN last SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; row_number | locf | color | time ------------+------+-------+------ 1 | | blue | 0 2 | 1 | blue | 1 3 | 1 | blue | 2 4 | 1 | blue | 3 5 | 1 | blue | 4 1 | | red | 0 2 | | red | 1 3 | 2 | red | 2 4 | 2 | red | 3 5 | 2 | red | 4 -- test expressions on GROUP BY columns SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, length(color), time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,5; row_number | locf | color | length | time ------------+------+-------+--------+------ 1 | | blue | 4 | 0 2 | 1 | blue | 4 | 1 3 | 1 | blue | 4 | 2 4 | 1 | blue | 4 | 3 5 | 1 | blue | 4 | 4 1 | | red | 3 | 0 2 | | red | 3 | 1 3 | 2 | red | 3 | 2 4 | 2 | red | 3 | 3 5 | 2 | red | 3 | 4 -- test columns derived from GROUP BY columns with cast SELECT time_bucket_gapfill(1,time,0,5) as time, device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | device_id ------+----------- 0 | 1 1 | 1 2 | 1 3 | 1 4 | 1 0 | 2 1 | 2 2 | 2 3 | 2 4 | 2 -- test columns derived from GROUP BY columns with expression SELECT time_bucket_gapfill(1,time,0,5) as time, 'Device ' || device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; time | ?column? ------+---------- 0 | Device 1 1 | Device 1 2 | Device 1 3 | Device 1 4 | Device 1 0 | Device 2 1 | Device 2 2 | Device 2 3 | Device 2 4 | Device 2 --test interpolation with big differences in values (test overflows in calculations) --we use the biggest possible difference in time(x) and the value(y). --For bigints we also test values of smaller than bigintmax/min to avoid --the symmetry where x=y (which catches more errors) SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset SELECT time_bucket_gapfill(1,time,0,1) AS time, interpolate(min(s)) AS "smallint", interpolate(min(i)) AS "int", interpolate(min(b)) AS "bigint", interpolate(min(b2)) AS "bigint2", interpolate(min(d)) AS "double" FROM (values (:big_int_min,(-32768)::smallint,(-2147483648)::int,:big_int_min,-2147483648::bigint, '-Infinity'::double precision), (:big_int_max, 32767::smallint, 2147483647::int,:big_int_max, 2147483647::bigint, 'Infinity'::double precision)) v(time,s,i,b,b2,d) GROUP BY 1 ORDER BY 1; time | smallint | int | bigint | bigint2 | double ----------------------+----------+-------------+----------------------+-------------+----------- -9223372036854775808 | -32768 | -2147483648 | -9223372036854775808 | -2147483648 | -Infinity 0 | 0 | 0 | 0 | 0 | Infinity 9223372036854775807 | 32767 | 2147483647 | 9223372036854775807 | 2147483647 | Infinity -- issue #2232: This query used to trigger error "could not find -- pathkey item to sort" due to a corrupt query plan SELECT time_bucket_gapfill('1 h', time) AS time, locf(sum(v1)) AS v1_sum, interpolate(sum(v2)) AS v2_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v2_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 06:00:00 2018 PST | 2.1 | 65 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 Mon Jan 01 04:00:00 2018 PST | | -- query without gapfill: SELECT time_bucket('1 h', time) AS time, sum(v1) AS v1_sum, sum(v2) AS v1_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; time | v1_sum | v1_sum ------------------------------+--------+-------- Mon Jan 01 07:00:00 2018 PST | 2.3 | 70 Mon Jan 01 05:00:00 2018 PST | 2.1 | 60 -- query to show original data SELECT * FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' ORDER BY 1 DESC, 2; time | device_id | v1 | v2 ------------------------------+-----------+-----+---- Mon Jan 01 07:00:00 2018 PST | 1 | 0 | 0 Mon Jan 01 07:00:00 2018 PST | 2 | 1.4 | 40 Mon Jan 01 07:00:00 2018 PST | 3 | 0.9 | 30 Mon Jan 01 05:00:00 2018 PST | 1 | 0.5 | 10 Mon Jan 01 05:00:00 2018 PST | 2 | 0.7 | 20 Mon Jan 01 05:00:00 2018 PST | 3 | 0.9 | 30 -- issue #3048 -- test gapfill/hashagg planner interaction -- this used to produce a plan without gapfill node EXPLAIN (buffers off, costs off) SELECT time_bucket_gapfill('52w', time, start:='2000-01-01', finish:='2000-01-10') AS time, sum(v1) AS v1_sum FROM metrics GROUP BY 1; --- QUERY PLAN --- Custom Scan (GapFill) -> Sort Sort Key: (time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone)) -> HashAggregate Group Key: time_bucket_gapfill('@ 364 days'::interval, metrics."time", 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone, 'Mon Jan 10 00:00:00 2000 PST'::timestamp with time zone) -> Result -> Append -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -- issue #3834 -- test projection handling in gapfill CREATE TABLE i3834(time timestamptz NOT NULL, ship_id int, value float); SELECT table_name FROM create_hypertable('i3834','time'); table_name ------------ i3834 INSERT INTO i3834 VALUES ('2020-12-01 14:05:00+01',1,3.123), ('2020-12-01 14:05:00+01',2,4.123), ('2020-12-01 14:05:00+01',3,5.123); SELECT time_bucket_gapfill('30000 ms'::interval, time) AS time, ship_id, interpolate (avg(value)), 'speedlog' AS source FROM i3834 WHERE ship_id IN (1, 2) AND time >= '2020-12-01 14:05:00+01' AND time < '2020-12-01 14:10:00+01' GROUP BY 1,2; time | ship_id | interpolate | source ------------------------------+---------+-------------+---------- Tue Dec 01 05:05:00 2020 PST | 1 | 3.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 1 | | speedlog Tue Dec 01 05:06:00 2020 PST | 1 | | speedlog Tue Dec 01 05:06:30 2020 PST | 1 | | speedlog Tue Dec 01 05:07:00 2020 PST | 1 | | speedlog Tue Dec 01 05:07:30 2020 PST | 1 | | speedlog Tue Dec 01 05:08:00 2020 PST | 1 | | speedlog Tue Dec 01 05:08:30 2020 PST | 1 | | speedlog Tue Dec 01 05:09:00 2020 PST | 1 | | speedlog Tue Dec 01 05:09:30 2020 PST | 1 | | speedlog Tue Dec 01 05:05:00 2020 PST | 2 | 4.123 | speedlog Tue Dec 01 05:05:30 2020 PST | 2 | | speedlog Tue Dec 01 05:06:00 2020 PST | 2 | | speedlog Tue Dec 01 05:06:30 2020 PST | 2 | | speedlog Tue Dec 01 05:07:00 2020 PST | 2 | | speedlog Tue Dec 01 05:07:30 2020 PST | 2 | | speedlog Tue Dec 01 05:08:00 2020 PST | 2 | | speedlog Tue Dec 01 05:08:30 2020 PST | 2 | | speedlog Tue Dec 01 05:09:00 2020 PST | 2 | | speedlog Tue Dec 01 05:09:30 2020 PST | 2 | | speedlog DROP TABLE i3834; -- issue #1528 -- test float rounding for certain float values when start and end are identical SELECT time_bucket_gapfill('1min'::interval, ts::timestamptz, start:='2019-11-05 2:20', finish:='2019-11-05 2:30'), interpolate(avg(20266.959547::float4)) AS float4, interpolate(avg(20266.959547::float8)) AS float8 FROM (VALUES ('2019-11-05 2:20'), ('2019-11-05 2:30')) v (ts) GROUP BY 1; time_bucket_gapfill | float4 | float8 ------------------------------+-----------------+-------------- Tue Nov 05 02:20:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:21:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:22:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:23:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:24:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:25:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:26:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:27:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:28:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:29:00 2019 PST | 20266.958984375 | 20266.959547 Tue Nov 05 02:30:00 2019 PST | 20266.958984375 | 20266.959547 -- check gapfill group change detection with TOASTed values CREATE TABLE gapfill_group_toast(time timestamptz NOT NULL, device text, value float); SELECT table_name FROM create_hypertable('gapfill_group_toast', 'time'); table_name --------------------- gapfill_group_toast INSERT INTO gapfill_group_toast SELECT generate_series('2022-06-01'::timestamptz, '2022-06-03'::timestamptz, '1min'::interval), '4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43', random(); ALTER TABLE gapfill_group_toast SET(timescaledb.compress, timescaledb.compress_segmentby = 'device'); SELECT count(compress_chunk(c)) FROM show_chunks('gapfill_group_toast') c; count ------- 2 SELECT time_bucket_gapfill('1 day', time), device FROM gapfill_group_toast WHERE time >= '2022-06-01' AND time <= '2022-06-02' GROUP BY 1,2; time_bucket_gapfill | device ------------------------------+------------------------------------------------------------------ Tue May 31 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 Wed Jun 01 17:00:00 2022 PDT | 4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43 DROP TABLE gapfill_group_toast; -- test bucketing by month SELECT time_bucket_gapfill('2 month'::interval, ts, '2000-01-01'::timestamptz,'2001-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SELECT time_bucket_gapfill('1 year'::interval, ts, '2000-01-01'::timestamptz,'2003-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Sun Dec 31 16:00:00 2000 PST Mon Dec 31 16:00:00 2001 PST Tue Dec 31 16:00:00 2002 PST SELECT time_bucket_gapfill('1 century'::interval, ts, '1900-01-01'::timestamptz,'2103-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sun Dec 31 16:00:00 1899 PST Fri Dec 31 16:00:00 1999 PST Thu Dec 31 16:00:00 2099 PST -- test bucketing with timezone SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 15:00:00 1999 PST Tue Feb 29 15:00:00 2000 PST Sun Apr 30 15:00:00 2000 PDT Fri Jun 30 15:00:00 2000 PDT Thu Aug 31 15:00:00 2000 PDT Tue Oct 31 15:00:00 2000 PST Sun Dec 31 15:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, current_setting('timezone'), '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Sat Jan 01 00:00:00 2000 PST Wed Mar 01 00:00:00 2000 PST Mon May 01 00:00:00 2000 PDT Sat Jul 01 00:00:00 2000 PDT Fri Sep 01 00:00:00 2000 PDT Wed Nov 01 00:00:00 2000 PST SELECT time_bucket_gapfill('2 month'::interval, ts, 'UTC', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------ Fri Dec 31 16:00:00 1999 PST Tue Feb 29 16:00:00 2000 PST Sun Apr 30 17:00:00 2000 PDT Fri Jun 30 17:00:00 2000 PDT Thu Aug 31 17:00:00 2000 PDT Tue Oct 31 16:00:00 2000 PST Sun Dec 31 16:00:00 2000 PST SET timezone TO 'Europe/Berlin'; SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; time_bucket_gapfill ------------------------------- Sat Jan 01 00:00:00 2000 CET Wed Mar 01 00:00:00 2000 CET Mon May 01 00:00:00 2000 CEST Sat Jul 01 00:00:00 2000 CEST Fri Sep 01 00:00:00 2000 CEST Wed Nov 01 00:00:00 2000 CET RESET timezone; -- Test gapfill with arrays (#5981) SELECT time_bucket_gapfill(5, ts, 1, 100) as ts, int_arr, locf(last(value, ts)) FROM ( SELECT ARRAY[1,2,3,4]::int[] as int_arr, x as ts, x+500000 as value FROM generate_series(1, 10, 100) as x ) t GROUP BY 1, 2; ts | int_arr | locf ----+-----------+-------- 0 | {1,2,3,4} | 500001 5 | {1,2,3,4} | 500001 10 | {1,2,3,4} | 500001 15 | {1,2,3,4} | 500001 20 | {1,2,3,4} | 500001 25 | {1,2,3,4} | 500001 30 | {1,2,3,4} | 500001 35 | {1,2,3,4} | 500001 40 | {1,2,3,4} | 500001 45 | {1,2,3,4} | 500001 50 | {1,2,3,4} | 500001 55 | {1,2,3,4} | 500001 60 | {1,2,3,4} | 500001 65 | {1,2,3,4} | 500001 70 | {1,2,3,4} | 500001 75 | {1,2,3,4} | 500001 80 | {1,2,3,4} | 500001 85 | {1,2,3,4} | 500001 90 | {1,2,3,4} | 500001 95 | {1,2,3,4} | 500001 -- Test gapfill is aligned with non-gapfill time_bucket -- when using different timezones and month bucketing CREATE TABLE month_timezone(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('month_timezone','time'); table_name ---------------- month_timezone INSERT INTO month_timezone VALUES ('2023-03-01 14:05:00+01', 3.123), ('2023-04-01 14:05:00+01',4.123), ('2023-05-01 14:05:00+01', 5.123); SELECT time_bucket_gapfill('1 month'::interval, time, 'Europe/Berlin', '2023-01-01', '2023-07-01') AS time, sum(value) FROM month_timezone GROUP BY 1; time | sum ------------------------------+------- Sat Dec 31 15:00:00 2022 PST | Tue Jan 31 15:00:00 2023 PST | Tue Feb 28 15:00:00 2023 PST | 3.123 Fri Mar 31 15:00:00 2023 PDT | 4.123 Sun Apr 30 15:00:00 2023 PDT | 5.123 Wed May 31 15:00:00 2023 PDT | Fri Jun 30 15:00:00 2023 PDT | -- Test gapfill respects DST changes when generating timestamps (#6344) SELECT time_bucket_gapfill('1 month', time, 'awst','2023-01-01', '2023-07-01' ) AS month, sum(value) AS sum FROM month_timezone GROUP BY 1; month | sum ------------------------------+------- Sat Dec 31 08:00:00 2022 PST | Tue Jan 31 08:00:00 2023 PST | Tue Feb 28 08:00:00 2023 PST | 3.123 Fri Mar 31 09:00:00 2023 PDT | 4.123 Sun Apr 30 09:00:00 2023 PDT | 5.123 Wed May 31 09:00:00 2023 PDT | Fri Jun 30 09:00:00 2023 PDT | DROP TABLE month_timezone; -- Test gapfill with additional group pathkeys added for optimization (#6396) CREATE TABLE stocks_real_time ( time TIMESTAMPTZ NOT NULL, symbol TEXT NOT NULL, price DOUBLE PRECISION NULL, day_volume INT NULL ); INSERT INTO stocks_real_time VALUES (NOW(), 's1', 70.0, 50), (NOW(), 's2', 66.5, 60), (NOW(), 's3', 77.0, 65); SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1; day | symbol_count ------------------------------+-------------- Thu Nov 30 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Sat Dec 09 16:00:00 2023 PST | SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1 ORDER BY 1 DESC; day | symbol_count ------------------------------+-------------- Sat Dec 09 16:00:00 2023 PST | Fri Dec 08 16:00:00 2023 PST | Thu Dec 07 16:00:00 2023 PST | Wed Dec 06 16:00:00 2023 PST | Tue Dec 05 16:00:00 2023 PST | Mon Dec 04 16:00:00 2023 PST | Sun Dec 03 16:00:00 2023 PST | Sat Dec 02 16:00:00 2023 PST | Fri Dec 01 16:00:00 2023 PST | Thu Nov 30 16:00:00 2023 PST | DROP TABLE stocks_real_time; SET timezone TO 'Europe/Berlin'; -- check dst switching is handled correctly #6788 SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 03:00:00 2024 CEST SELECT time_bucket_gapfill('30 minutes', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Mar 31 01:00:00 2024 CET Sun Mar 31 01:30:00 2024 CET Sun Mar 31 03:00:00 2024 CEST Sun Mar 31 03:30:00 2024 CEST SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-10-26T23:00Z', '2024-10-27T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; time_bucket_gapfill ------------------------------- Sun Oct 27 01:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CEST Sun Oct 27 02:00:00 2024 CET RESET timezone; ������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/gapfill_bug.out�����������������������������������������0000664�0000000�0000000�00000063113�15100345067�0023713�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Fix for issue #6078: crash in "time_bucket_gapfil" -- with "locf" using NULL value and NULLs treated as missing. create table tw(id varchar, time timestamp, value float); insert into tw values ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400); SET timezone TO 'Europe/Berlin'; -- Losf lookup query being a SubPlan as it has a predicate over correlated variable -- We call Locf calculation for a "gapfill_start" tuple retrived from the input to override its NULL value, -- rather than for a tuple generated to fill the gaps. -- We used to crash in this scenario due to pointing to a wrong tuple slot. Should work OK now. SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM tw AS p WHERE p.id = tw.id ORDER BY 1 LIMIT 1), true) AS value FROM tw GROUP BY 1,2; id | bucket | value ------+--------------------------+-------- uuid | Fri Sep 15 12:00:00 2023 | uuid | Fri Sep 15 12:50:00 2023 | 147673 -- Should return same result for simpler Losf lookup query SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM tw AS p ORDER BY 1 LIMIT 1), true) AS value FROM tw GROUP BY 1,2; id | bucket | value ------+--------------------------+-------- uuid | Fri Sep 15 12:00:00 2023 | uuid | Fri Sep 15 12:50:00 2023 | 147673 -- Should return same result when using CTE instead of input table WITH data (id, time, value) AS ( VALUES ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400) ) SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM data AS p WHERE p.id = data.id ORDER BY 1 LIMIT 1), true) AS value FROM data GROUP BY 1,2; id | bucket | value ------+--------------------------+-------- uuid | Fri Sep 15 12:00:00 2023 | uuid | Fri Sep 15 12:50:00 2023 | 147673 -- Pick an average value instead of min WITH data (id, time, value) AS ( VALUES ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400) ) SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT avg(p.value) FROM data AS p WHERE p.id = data.id), true) AS value FROM data GROUP BY 1,2; id | bucket | value ------+--------------------------+---------- uuid | Fri Sep 15 12:00:00 2023 | uuid | Fri Sep 15 12:50:00 2023 | 148536.5 -- Call Locf both for filling gaps and setting the non-NULL value for "gapfill_start" tuple WITH data (id, time, value) AS ( VALUES ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400) ) SELECT id, time_bucket_gapfill('1min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT avg(p.value) FROM data AS p WHERE p.id = data.id), true) AS value FROM data GROUP BY 1,2; id | bucket | value ------+--------------------------+---------- uuid | Fri Sep 15 12:00:00 2023 | uuid | Fri Sep 15 12:50:00 2023 | 148536.5 uuid | Fri Sep 15 12:51:00 2023 | 148536.5 uuid | Fri Sep 15 12:52:00 2023 | 148536.5 -- Use Locf lookup for multiple groupby values, use 2nd groupby column as a correlation var in the lookup -- Make sure correlation var is obtained from correct tuple passed to Locf lookup expression WITH data (id, gr, time, value) AS ( VALUES ('uuid', 12, '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', 14, '2023-09-15 12:52', 149400) ) SELECT id, gr, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM data AS p where p.gr = data.gr ORDER BY 1 desc LIMIT 1), true) AS value FROM data GROUP BY 1,2,3 ORDER BY 1,2,3; id | gr | bucket | value ------+----+--------------------------+-------- uuid | 12 | Fri Sep 15 12:00:00 2023 | uuid | 12 | Fri Sep 15 12:50:00 2023 | 147673 uuid | 14 | Fri Sep 15 12:50:00 2023 | 149400 -- Same but use two correlation vars in Locf lookup WITH data (id, gr, time, value) AS ( VALUES ('uuid', 12, '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', 14, '2023-09-15 12:52', 149400) ) SELECT id, gr, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM data AS p where p.gr = data.gr and p.id = data.id ORDER BY 1 desc LIMIT 1), true) AS value FROM data GROUP BY 1,2,3 ORDER BY 1,2,3; id | gr | bucket | value ------+----+--------------------------+-------- uuid | 12 | Fri Sep 15 12:00:00 2023 | uuid | 12 | Fri Sep 15 12:50:00 2023 | 147673 uuid | 14 | Fri Sep 15 12:50:00 2023 | 149400 drop table tw cascade; RESET timezone; -- Fix for 2nd issue reported in #4894: "time_bucket_gapfil" with "locf/interpolate" -- using out-of-order and repeated columns, resulting in below error: -- ERROR: attribute 5 of type record has wrong type -- Should return correct data with no error WITH el_data(time,position_id,measurement_value,measurement_type,src_mac_id,stream_index,delta) AS( VALUES ('2025-07-05 23:57:19.000000 +00:00'::timestamptz,'2da82d12-5ceb-4470-b60b-9660b755d052'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:12:19.000000 +00:00'::timestamptz,'2da82d12-5ceb-4470-b60b-9660b755d052'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-901), ('2025-07-06 00:27:20.000000 +00:00'::timestamptz,'2da82d12-5ceb-4470-b60b-9660b755d052'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110560), ('2025-07-06 00:06:12.000000 +00:00'::timestamptz,'9f2e566b-8c26-4ead-ad24-12841c79a932'::uuid,25.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:21:12.000000 +00:00'::timestamptz,'9f2e566b-8c26-4ead-ad24-12841c79a932'::uuid,25.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110928), ('2025-07-06 00:02:57.000000 +00:00'::timestamptz,'09ca0d92-1eb5-4d07-adbc-2bb500817cc7'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-901), ('2025-07-06 00:17:58.000000 +00:00'::timestamptz,'09ca0d92-1eb5-4d07-adbc-2bb500817cc7'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3111122), ('2025-07-06 00:06:02.000000 +00:00'::timestamptz,'e0145b95-6faa-4eb3-815d-5d0a91ba909c'::uuid,24::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:21:02.000000 +00:00'::timestamptz,'e0145b95-6faa-4eb3-815d-5d0a91ba909c'::uuid,24::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110938), ('2025-07-06 00:04:48.000000 +00:00'::timestamptz,'d439a8fc-7285-4d32-82bc-2105c9ed2d52'::uuid,24::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:19:48.000000 +00:00'::timestamptz,'d439a8fc-7285-4d32-82bc-2105c9ed2d52'::uuid,24.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3111012), ('2025-07-06 00:07:00.000000 +00:00'::timestamptz,'4aa9b368-b9c4-4b15-bfcc-c67b1931dd11'::uuid,25::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:22:00.000000 +00:00'::timestamptz,'4aa9b368-b9c4-4b15-bfcc-c67b1931dd11'::uuid,24.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110880), ('2025-07-06 00:08:03.000000 +00:00'::timestamptz,'64dc15d6-3988-4320-8f18-16ef8512990e'::uuid,30.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:23:03.000000 +00:00'::timestamptz,'64dc15d6-3988-4320-8f18-16ef8512990e'::uuid,30.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110817), ('2025-07-05 23:57:13.000000 +00:00'::timestamptz,'bb044d29-c136-412d-a193-354f090dafcb'::uuid,23::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-300), ('2025-07-06 00:02:13.000000 +00:00'::timestamptz,'bb044d29-c136-412d-a193-354f090dafcb'::uuid,23::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-300), ('2025-07-06 00:07:13.000000 +00:00'::timestamptz,'bb044d29-c136-412d-a193-354f090dafcb'::uuid,23::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-300) ) , el_nodes_data(time,src_mac_id,stream_index,position_id,measurement_type,measurement_value) as( VALUES ('2025-07-05 23:42:20.000000 +00:00'::timestamptz,'FFFF000D6F4DA7B2',3,'2da82d12-5ceb-4470-b60b-9660b755d052','temperature_ambient',26::numeric), ('2025-07-06 00:51:09.000000 +00:00'::timestamptz,'FFFF000D6F4DA7B2',3,'2da82d12-5ceb-4470-b60b-9660b755d052','temperature_ambient',26::numeric) ) SELECT time_bucket_gapfill('5 minutes', m.time, start := '2025-07-05 23:55:00+00:00'::timestamptz, finish := '2025-07-06 00:30:00+00:00'::timestamptz) AS intervals, m.position_id, m.src_mac_id, m.stream_index, m.measurement_type, m.stream_index, locf(last(m.measurement_value, m.time) , (SELECT d2.measurement_value FROM el_nodes_data d2 WHERE d2.measurement_type = m.measurement_type AND d2.src_mac_id = m.src_mac_id AND d2.stream_index = m.stream_index AND d2.time < '2025-07-05 23:55:00+00:00' AND d2.time > '2025-07-05 23:55:00+00:00'::timestamptz - INTERVAL '30 minutes' ORDER BY d2.time DESC LIMIT 1) ) AS locf_measurement_value FROM el_data m GROUP BY time_bucket_gapfill('5 minutes', m.time, start := '2025-07-05 23:55:00+00:00'::timestamptz, finish := '2025-07-06 00:30:00+00:00'::timestamptz), -- avoid alias here m.position_id,m.src_mac_id, m.stream_index, m.measurement_type ORDER BY time_bucket_gapfill('5 minutes', m.time, start := '2025-07-05 23:55:00+00:00'::timestamptz, finish := '2025-07-06 00:30:00+00:00'::timestamptz), -- avoid alias here m.position_id,m.src_mac_id, m.stream_index, m.measurement_type; intervals | position_id | src_mac_id | stream_index | measurement_type | stream_index | locf_measurement_value ------------------------------+--------------------------------------+------------------+--------------+---------------------+--------------+------------------------ Sat Jul 05 16:55:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 16:55:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 16:55:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 16:55:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 16:55:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 16:55:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 16:55:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 16:55:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 17:00:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:00:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:00:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 17:00:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 17:00:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 17:00:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 17:00:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:00:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26 Sat Jul 05 17:05:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:05:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:05:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25 Sat Jul 05 17:05:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 30.5 Sat Jul 05 17:05:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25.5 Sat Jul 05 17:05:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 17:05:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:05:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:10:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:10:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:10:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25 Sat Jul 05 17:10:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 30.5 Sat Jul 05 17:10:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25.5 Sat Jul 05 17:10:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 17:10:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:10:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:15:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:15:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:15:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25 Sat Jul 05 17:15:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 30.5 Sat Jul 05 17:15:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25.5 Sat Jul 05 17:15:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 17:15:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24.5 Sat Jul 05 17:15:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:20:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:20:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:20:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24.5 Sat Jul 05 17:20:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 30.5 Sat Jul 05 17:20:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25.5 Sat Jul 05 17:20:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 17:20:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24.5 Sat Jul 05 17:20:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 Sat Jul 05 17:25:00 2025 PDT | 09ca0d92-1eb5-4d07-adbc-2bb500817cc7 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:25:00 2025 PDT | 2da82d12-5ceb-4470-b60b-9660b755d052 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 26.5 Sat Jul 05 17:25:00 2025 PDT | 4aa9b368-b9c4-4b15-bfcc-c67b1931dd11 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24.5 Sat Jul 05 17:25:00 2025 PDT | 64dc15d6-3988-4320-8f18-16ef8512990e | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 30.5 Sat Jul 05 17:25:00 2025 PDT | 9f2e566b-8c26-4ead-ad24-12841c79a932 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 25.5 Sat Jul 05 17:25:00 2025 PDT | bb044d29-c136-412d-a193-354f090dafcb | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 23 Sat Jul 05 17:25:00 2025 PDT | d439a8fc-7285-4d32-82bc-2105c9ed2d52 | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24.5 Sat Jul 05 17:25:00 2025 PDT | e0145b95-6faa-4eb3-815d-5d0a91ba909c | FFFF000D6F4DA7B2 | 3 | temperature_ambient | 3 | 24 -- Fix for #4894: gapfill error over aggregates in expressions with groupby columns and columns out of order CREATE TABLE hourly ( time timestamptz NOT NULL, signal smallint NOT NULL, value real, level_a integer, level_b smallint, level_c smallint, agg smallint ); INSERT into hourly(time, signal,value, level_a, level_b, level_c, agg) values ('2022-10-01T00:00:00Z', 2, 685, 1, -1, -1, 2 ), ('2022-10-01T00:00:00Z', 2, 686, 1, -1, -1, 3 ), ('2022-10-01T02:00:00Z', 2, 686, 1, -1, -3, 2 ), ('2022-10-01T02:00:00Z', 2, 687, 1, -1, -1, 3 ), ('2022-10-01T03:00:00Z', 2, 687, 1, -1, -3, 2 ), ('2022-10-01T03:00:00Z', 2, 688, 1, -1, -1, 3 ); -- Expression over 1 aggregate and 1 groupby column SELECT time_bucket_gapfill('1 hour', time) as time, CASE WHEN agg in (0,3) THEN max(value) ELSE null END as max, CASE WHEN agg in (0,2) THEN min(value) ELSE null END as min FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b >= -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg order by 1,2,3; time | max | min ------------------------------+-----+----- Fri Sep 30 17:00:00 2022 PDT | 686 | Fri Sep 30 17:00:00 2022 PDT | | 685 Fri Sep 30 18:00:00 2022 PDT | | Fri Sep 30 18:00:00 2022 PDT | | Fri Sep 30 19:00:00 2022 PDT | 687 | Fri Sep 30 19:00:00 2022 PDT | | 686 Fri Sep 30 20:00:00 2022 PDT | 688 | Fri Sep 30 20:00:00 2022 PDT | | 687 Fri Sep 30 21:00:00 2022 PDT | | Fri Sep 30 21:00:00 2022 PDT | | Fri Sep 30 22:00:00 2022 PDT | | Fri Sep 30 22:00:00 2022 PDT | | -- Expression over 2 aggregates and 1 groupby column SELECT time_bucket_gapfill('1 hour', time) as time, CASE WHEN agg in (0,3) THEN max(value) ELSE min(level_c) END as maxmin FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg order by 1,2; time | maxmin ------------------------------+-------- Fri Sep 30 17:00:00 2022 PDT | -1 Fri Sep 30 17:00:00 2022 PDT | 686 Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 19:00:00 2022 PDT | -3 Fri Sep 30 19:00:00 2022 PDT | 687 Fri Sep 30 20:00:00 2022 PDT | -3 Fri Sep 30 20:00:00 2022 PDT | 688 Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | -- Expression over 2 aggregates and 2 groupby columns SELECT time_bucket_gapfill('1 hour', time) as time, CASE WHEN agg in (0,3) THEN max(value) ELSE min(level_c)+signal END as maxmin FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg, signal order by 1,2; time | maxmin ------------------------------+-------- Fri Sep 30 17:00:00 2022 PDT | 1 Fri Sep 30 17:00:00 2022 PDT | 686 Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 19:00:00 2022 PDT | -1 Fri Sep 30 19:00:00 2022 PDT | 687 Fri Sep 30 20:00:00 2022 PDT | -1 Fri Sep 30 20:00:00 2022 PDT | 688 Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | -- Expressions over aggregates and complex groupby expressions SELECT time_bucket_gapfill('1 hour', time) as time, max(value)+(agg+1) FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg+1 order by 1,2; time | ?column? ------------------------------+---------- Fri Sep 30 17:00:00 2022 PDT | 688 Fri Sep 30 17:00:00 2022 PDT | 690 Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 19:00:00 2022 PDT | 689 Fri Sep 30 19:00:00 2022 PDT | 691 Fri Sep 30 20:00:00 2022 PDT | 690 Fri Sep 30 20:00:00 2022 PDT | 692 Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | SELECT time_bucket_gapfill('1 hour', time) as time, max(value)+(agg+1)+(agg+1+1) FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg+1, agg+1+1 order by 1,2; time | ?column? ------------------------------+---------- Fri Sep 30 17:00:00 2022 PDT | 692 Fri Sep 30 17:00:00 2022 PDT | 695 Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 18:00:00 2022 PDT | Fri Sep 30 19:00:00 2022 PDT | 693 Fri Sep 30 19:00:00 2022 PDT | 696 Fri Sep 30 20:00:00 2022 PDT | 694 Fri Sep 30 20:00:00 2022 PDT | 697 Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 21:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | Fri Sep 30 22:00:00 2022 PDT | SELECT time_bucket_gapfill('1 hour', time) as time, max(value) + (agg+signal) maxv, min(value) - (agg+signal) minv, agg+signal FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg+signal order by 1,2,3; time | maxv | minv | ?column? ------------------------------+------+------+---------- Fri Sep 30 17:00:00 2022 PDT | 689 | 681 | 4 Fri Sep 30 17:00:00 2022 PDT | 691 | 681 | 5 Fri Sep 30 18:00:00 2022 PDT | | | 4 Fri Sep 30 18:00:00 2022 PDT | | | 5 Fri Sep 30 19:00:00 2022 PDT | 690 | 682 | 4 Fri Sep 30 19:00:00 2022 PDT | 692 | 682 | 5 Fri Sep 30 20:00:00 2022 PDT | 691 | 683 | 4 Fri Sep 30 20:00:00 2022 PDT | 693 | 683 | 5 Fri Sep 30 21:00:00 2022 PDT | | | 4 Fri Sep 30 21:00:00 2022 PDT | | | 5 Fri Sep 30 22:00:00 2022 PDT | | | 4 Fri Sep 30 22:00:00 2022 PDT | | | 5 drop table hourly cascade; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/generated_columns.out�����������������������������������0000664�0000000�0000000�00000004124�15100345067�0025133�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE gencol_tab ( a INT NOT NULL, b INT, c INT GENERATED ALWAYS AS (a + b) STORED ); SELECT table_name FROM create_hypertable('gencol_tab', 'a', chunk_time_interval=>10); table_name ------------ gencol_tab INSERT INTO gencol_tab(a, b) VALUES(1, 2); INSERT INTO gencol_tab(a, b) VALUES(2, 3); -- Ensure generated column cannot be updated \set ON_ERROR_STOP 0 INSERT INTO gencol_tab VALUES(3, 5, 8); ERROR: cannot insert a non-DEFAULT value into column "c" \set ON_ERROR_STOP 1 SELECT * FROM gencol_tab ORDER BY a; a | b | c ---+---+--- 1 | 2 | 3 2 | 3 | 5 DROP TABLE gencol_tab; -- Ensure that generated column cannot be used for partitioning -- Generated as expression CREATE TABLE gencol_test ( a INT NOT NULL, b INT GENERATED ALWAYS AS (a + 123) STORED ); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('gencol_test', 'a', 'b', 2, chunk_time_interval=>10); ERROR: invalid partitioning column \set ON_ERROR_STOP 1 -- check if default generated expression can be dropped (works on >= PG13) SELECT table_name FROM create_hypertable('gencol_test', 'a', chunk_time_interval=>10); table_name ------------- gencol_test SELECT attname, atthasdef, attidentity, attgenerated, attnotnull FROM pg_attribute where attname = 'b' and attrelid = 'gencol_test'::regclass; attname | atthasdef | attidentity | attgenerated | attnotnull ---------+-----------+-------------+--------------+------------ b | t | | s | f \set ON_ERROR_STOP 0 ALTER TABLE gencol_test ALTER COLUMN b DROP EXPRESSION; \set ON_ERROR_STOP 1 SELECT attname, atthasdef, attidentity, attgenerated, attnotnull FROM pg_attribute where attname = 'b' and attrelid = 'gencol_test'::regclass; attname | atthasdef | attidentity | attgenerated | attnotnull ---------+-----------+-------------+--------------+------------ b | f | | | f DROP TABLE gencol_test; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/memoize.out���������������������������������������������0000664�0000000�0000000�00000047646�15100345067�0023122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unmemoized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNMEMOIZED", format('%s/shared/results/%s_results_memoized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_MEMOIZED" \gset SELECT format('\! diff -u --label "Unmemoized results" --label "Memoized results" %s %s', :'TEST_RESULTS_UNMEMOIZED', :'TEST_RESULTS_MEMOIZED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' SET work_mem TO '64MB'; SET enable_memoize TO on; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW enable_memoize; enable_memoize ---------------- on :PREFIX SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL (SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=68370.00 loops=1) -> Custom Scan (ChunkAppend) on metrics m1 (actual rows=68370.00 loops=1) Order: m1."time" -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m1_1 (actual rows=17990.00 loops=1) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m1_2 (actual rows=25190.00 loops=1) -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m1_3 (actual rows=25190.00 loops=1) -> Memoize (actual rows=1.00 loops=68370) Cache Key: m1."time" Cache Mode: binary Hits: 54696 Misses: 13674 Evictions: 0 Overflows: 0 -> Limit (actual rows=1.00 loops=13674) -> Custom Scan (ChunkAppend) on metrics m2 (actual rows=1.00 loops=13674) Chunks excluded during runtime: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=3598) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_2 (actual rows=1.00 loops=5038) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk m2_3 (actual rows=1.00 loops=5038) Index Cond: ("time" = m1."time") \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW enable_memoize; enable_memoize ---------------- on :PREFIX SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL (SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=68370.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space m1 (actual rows=68370.00 loops=1) Order: m1."time" -> Merge Append (actual rows=17990.00 loops=1) Sort Key: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_1 (actual rows=3598.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_2 (actual rows=10794.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_3 (actual rows=3598.00 loops=1) -> Merge Append (actual rows=25190.00 loops=1) Sort Key: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_4 (actual rows=5038.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_5 (actual rows=15114.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_6 (actual rows=5038.00 loops=1) -> Merge Append (actual rows=25190.00 loops=1) Sort Key: m1."time" -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_7 (actual rows=5038.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_8 (actual rows=15114.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m1_9 (actual rows=5038.00 loops=1) -> Memoize (actual rows=1.00 loops=68370) Cache Key: m1."time" Cache Mode: binary Hits: 54696 Misses: 13674 Evictions: 0 Overflows: 0 -> Limit (actual rows=1.00 loops=13674) -> Custom Scan (ChunkAppend) on metrics_space m2 (actual rows=1.00 loops=13674) Chunks excluded during runtime: 6 -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=3598) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_2 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_3 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_4 (actual rows=1.00 loops=5038) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_5 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_6 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_7 (actual rows=1.00 loops=5038) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_8 (never executed) Index Cond: ("time" = m1."time") -> Index Only Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk m2_9 (never executed) Index Cond: ("time" = m1."time") \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW enable_memoize; enable_memoize ---------------- on :PREFIX SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL (SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=68370.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed m1 (actual rows=68370.00 loops=1) Order: m1."time" -> Merge Append (actual rows=17990.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=16392.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1_1 (actual rows=1598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (actual rows=25190.00 loops=1) -> Sort (actual rows=30.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (actual rows=25190.00 loops=1) -> Sort (actual rows=30.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Memoize (actual rows=1.00 loops=68370) Cache Key: m1."time" Cache Mode: binary Hits: 54696 Misses: 13674 Evictions: 0 Overflows: 0 -> Limit (actual rows=1.00 loops=13674) -> Custom Scan (ChunkAppend) on metrics_compressed m2 (actual rows=1.00 loops=13674) Chunks excluded during runtime: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=3598) Filter: (m1."time" = "time") Rows Removed by Filter: 466 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=3598) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) Rows Removed by Filter: 2 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m2_1 (never executed) Index Cond: ("time" = m1."time") -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (actual rows=1.00 loops=5038) Filter: (m1."time" = "time") Rows Removed by Filter: 496 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=5038) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (actual rows=1.00 loops=5038) Filter: (m1."time" = "time") Rows Removed by Filter: 496 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=5038) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) Rows Removed by Filter: 2 \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW enable_memoize; enable_memoize ---------------- on :PREFIX SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL (SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; --- QUERY PLAN --- Nested Loop Left Join (actual rows=68370.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed m1 (actual rows=68370.00 loops=1) Order: m1."time" -> Merge Append (actual rows=17990.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_1 (actual rows=3598.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_2 (actual rows=10794.00 loops=1) -> Sort (actual rows=12.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_3 (actual rows=3598.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Merge Append (actual rows=25190.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_4 (actual rows=5038.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_5 (actual rows=15114.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_6 (actual rows=5038.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (actual rows=25190.00 loops=1) Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_7 (actual rows=5038.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_8 (actual rows=15114.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1_9 (actual rows=5038.00 loops=1) -> Sort (actual rows=6.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Memoize (actual rows=1.00 loops=68370) Cache Key: m1."time" Cache Mode: binary Hits: 54696 Misses: 13674 Evictions: 0 Overflows: 0 -> Limit (actual rows=1.00 loops=13674) -> Custom Scan (ChunkAppend) on metrics_space_compressed m2 (actual rows=1.00 loops=13674) Chunks excluded during runtime: 6 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_1 (actual rows=1.00 loops=3598) Filter: (m1."time" = "time") Rows Removed by Filter: 466 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=3598) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) Rows Removed by Filter: 1 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_2 (never executed) Filter: (m1."time" = "time") -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_3 (never executed) Filter: (m1."time" = "time") -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_4 (actual rows=1.00 loops=5038) Filter: (m1."time" = "time") Rows Removed by Filter: 496 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=5038) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_5 (never executed) Filter: (m1."time" = "time") -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_6 (never executed) Filter: (m1."time" = "time") -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_7 (actual rows=1.00 loops=5038) Filter: (m1."time" = "time") Rows Removed by Filter: 496 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=5038) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) Rows Removed by Filter: 2 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_8 (never executed) Filter: (m1."time" = "time") -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2_9 (never executed) Filter: (m1."time" = "time") -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Filter: ((_ts_meta_min_1 <= m1."time") AND (_ts_meta_max_1 >= m1."time")) -- get results for all the queries -- run queries with and without memoize \set PREFIX '' \set ECHO none --- Unmemoized results +++ Memoized results @@ -1,6 +1,6 @@ enable_memoize ---------------- - off + on time | time @@ -68379,7 +68379,7 @@ enable_memoize ---------------- - off + on time | time @@ -136758,7 +136758,7 @@ enable_memoize ---------------- - off + on time | time @@ -205137,7 +205137,7 @@ enable_memoize ---------------- - off + on time | time ������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/merge_dml.out�������������������������������������������0000664�0000000�0000000�00000024477�15100345067�0023405�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create source table CREATE TABLE source ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int ); INSERT INTO source (time, device_id, filler_2, filler_3, filler_1) SELECT time, device_id, device_id + 134, device_id + 209, device_id + 0.50127 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); -- create corresponding PG tables to compare against hypertables CREATE table metrics_pg as SELECT * FROM metrics; CREATE table metrics_space_pg as SELECT * FROM metrics_space; CREATE table metrics_compressed_pg as SELECT * FROM metrics_compressed; CREATE table metrics_space_compressed_pg as SELECT * FROM metrics_space_compressed; -- MERGE UDPATE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); -- MERGE UDPATE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; result -------- same -- MERGE DELETE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- MERGE DELETE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; result -------- same -- MERGE INSERT/DELETE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- MERGE INSERT/DELETE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; result -------- same -- MERGE INSERT/DELETE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- MERGE INSERT/DELETE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; result -------- same -- MERGE UDPATE matched rows for normal PG tables MERGE INTO metrics_space_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); -- MERGE UDPATE matched rows for space partitioned hypertable MERGE INTO metrics_space t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics_space EXCEPT TABLE metrics_space_pg) OR EXISTS (TABLE metrics_space_pg EXCEPT TABLE metrics_space) THEN 'different' ELSE 'same' END AS result; result -------- same -- MERGE DELETE matched rows for normal PG tables MERGE INTO metrics_space_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- MERGE DELETE matched rows for space partitioned hypertable MERGE INTO metrics_space t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics_space EXCEPT TABLE metrics_space_pg) OR EXISTS (TABLE metrics_space_pg EXCEPT TABLE metrics_space) THEN 'different' ELSE 'same' END AS result; result -------- same -- MERGE INSERT matched rows for normal PG tables MERGE INTO metrics_space_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- MERGE INSERT matched rows for space partitioned hypertable MERGE INTO metrics_space t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics_space EXCEPT TABLE metrics_space_pg) OR EXISTS (TABLE metrics_space_pg EXCEPT TABLE metrics_space) THEN 'different' ELSE 'same' END AS result; result -------- same \set ON_ERROR_STOP 0 -- MERGE UDPATE matched rows for compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE DELETE matched rows for compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE UDPATE/INSERT matched rows for compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics) WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE DELETE/INSERT matched rows for compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE UDPATE matched rows for space partitioned compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE DELETE matched rows for space partitioned compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE UDPATE/INSERT matched rows for space partitioned compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics) WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables -- MERGE DELETE/INSERT matched rows for space partitioned compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); ERROR: The MERGE command with UPDATE/DELETE merge actions is not support on compressed hypertables \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/ordered_append_join-15.out������������������������������0000664�0000000�0000000�00001022000�15100345067�0025644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_now_constify TO FALSE; -- We disable index only scans to avoid some flakiness. It is not -- needed for the tests and it is only important which index is -- picked. SET enable_indexonlyscan TO FALSE; SELECT format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=2.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=2) Order: o."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 3 -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=2.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=6.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=6.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_3 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=101.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=101.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_2 (never executed) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_3 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=2.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (never executed) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=4.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=2.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=60.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_9 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=61.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_2 (never executed) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_3 (never executed) Filter: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=2.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Sort (actual rows=1.00 loops=2) Sort Key: o."time" Sort Method: top-N heapsort -> Result (actual rows=3600.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=3600.00 loops=2) Chunks excluded during startup: 0 Chunks excluded during runtime: 1 -> Merge Append (actual rows=0.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=3600.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3900 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=8.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 22 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 2 Chunks excluded during runtime: 0 -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 > now())) Rows Removed by Filter: 18 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Filter: (device_id = 2) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) Filter: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) AND (device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=2.00 loops=1) Order: o2."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=6.00 loops=1) Order: o1."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=80.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=81.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) RESET enable_seqscan; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=2.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Sort (actual rows=0.00 loops=2) Sort Key: o_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Sort (actual rows=1.00 loops=2) Sort Key: o_4."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_5."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=2160.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2340 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_6."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (never executed) Sort Key: o."time" -> Sort (never executed) Sort Key: o_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_7."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_8."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_9."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=60.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=61.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; -- Disable plain/sorted aggregation to get a deterministic test output SET timescaledb.enable_chunkwise_aggregation = OFF; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none table_name ------------ i4418_1 table_name ------------ i4418_2 --- QUERY PLAN --- Sort (actual rows=20.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, tbl1."time")) Sort Method: quicksort -> HashAggregate (actual rows=20.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, tbl1."time") -> Merge Join (actual rows=9121.00 loops=1) Merge Cond: ((tbl1.device = tbl2.device) AND (tbl1."time" = tbl2."time")) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl1.device, tbl1."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_4 (actual rows=1101.00 loops=1) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl2.device, tbl2."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_4 (actual rows=1101.00 loops=1) timescaledb-2.23.0/tsl/test/shared/expected/ordered_append_join-16.out������������������������������0000664�0000000�0000000�00001022000�15100345067�0025645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_now_constify TO FALSE; -- We disable index only scans to avoid some flakiness. It is not -- needed for the tests and it is only important which index is -- picked. SET enable_indexonlyscan TO FALSE; SELECT format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=2.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=2) Order: o."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 3 -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=2.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=6.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=6.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_3 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=101.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=101.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_2 (never executed) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_3 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=2.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (never executed) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=4.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=2.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=60.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_9 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=61.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_2 (never executed) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_3 (never executed) Filter: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=2.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Sort (actual rows=1.00 loops=2) Sort Key: o."time" Sort Method: top-N heapsort -> Result (actual rows=3600.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=3600.00 loops=2) Chunks excluded during startup: 0 Chunks excluded during runtime: 1 -> Merge Append (actual rows=0.00 loops=2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=3600.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3900 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=8.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 22 -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 2 Chunks excluded during runtime: 0 -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 > now())) Rows Removed by Filter: 18 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Filter: (device_id = 2) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) Filter: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) AND (device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=2.00 loops=1) Order: o2."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=6.00 loops=1) Order: o1."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) Index Cond: ("time" IS NOT NULL) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=80.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=81.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) RESET enable_seqscan; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=2.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Sort (actual rows=0.00 loops=2) Sort Key: o_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Sort (actual rows=1.00 loops=2) Sort Key: o_4."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_5."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=2160.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2340 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_6."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (never executed) Sort Key: o."time" -> Sort (never executed) Sort Key: o_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_7."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_8."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_9."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ($0)) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ($0) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 (returns $0) -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Vectorized Filter: ("time" IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=60.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=61.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; -- Disable plain/sorted aggregation to get a deterministic test output SET timescaledb.enable_chunkwise_aggregation = OFF; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none table_name ------------ i4418_1 table_name ------------ i4418_2 --- QUERY PLAN --- Sort (actual rows=20.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, tbl1."time")) Sort Method: quicksort -> HashAggregate (actual rows=20.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, tbl1."time") -> Merge Join (actual rows=9121.00 loops=1) Merge Cond: ((tbl1.device = tbl2.device) AND (tbl1."time" = tbl2."time")) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl1.device, tbl1."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_4 (actual rows=1101.00 loops=1) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl2.device, tbl2."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_4 (actual rows=1101.00 loops=1) timescaledb-2.23.0/tsl/test/shared/expected/ordered_append_join-17.out������������������������������0000664�0000000�0000000�00001016742�15100345067�0025666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_now_constify TO FALSE; -- We disable index only scans to avoid some flakiness. It is not -- needed for the tests and it is only important which index is -- picked. SET enable_indexonlyscan TO FALSE; SELECT format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=2.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=2) Order: o."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 3 -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=2.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=6.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=6.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_3 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=101.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=101.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_2 (never executed) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_3 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=2.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (never executed) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=4.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=2.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=60.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_9 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=61.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_2 (never executed) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_3 (never executed) Filter: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=2.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=2) Order: o."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 1 -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Sort (actual rows=0.00 loops=2) Sort Key: o_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Sort (actual rows=1.00 loops=2) Sort Key: o_2."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=3600.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3900 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=8.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 22 -> Sort (never executed) Sort Key: o_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 2 Chunks excluded during runtime: 0 -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 > now())) Rows Removed by Filter: 18 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Filter: (device_id = 2) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) Filter: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) AND (device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=2.00 loops=1) Order: o2."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=6.00 loops=1) Order: o1."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=80.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=81.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) RESET enable_seqscan; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=2.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Sort (actual rows=0.00 loops=2) Sort Key: o_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Sort (actual rows=1.00 loops=2) Sort Key: o_4."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_5."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=2160.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2340 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_6."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (never executed) Sort Key: o."time" -> Sort (never executed) Sort Key: o_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=2.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_7."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_8."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_9."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=60.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=61.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; -- Disable plain/sorted aggregation to get a deterministic test output SET timescaledb.enable_chunkwise_aggregation = OFF; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none table_name ------------ i4418_1 table_name ------------ i4418_2 --- QUERY PLAN --- Sort (actual rows=20.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, tbl1."time")) Sort Method: quicksort -> HashAggregate (actual rows=20.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, tbl1."time") -> Merge Join (actual rows=9121.00 loops=1) Merge Cond: ((tbl1.device = tbl2.device) AND (tbl1."time" = tbl2."time")) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl1.device, tbl1."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_4 (actual rows=1101.00 loops=1) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl2.device, tbl2."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_4 (actual rows=1101.00 loops=1) ������������������������������timescaledb-2.23.0/tsl/test/shared/expected/ordered_append_join-18.out������������������������������0000664�0000000�0000000�00001016742�15100345067�0025667�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_now_constify TO FALSE; -- We disable index only scans to avoid some flakiness. It is not -- needed for the tests and it is only important which index is -- picked. SET enable_indexonlyscan TO FALSE; SELECT format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=2.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=2) Order: o."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_1 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_2 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o_3 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 3 -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 1) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=2.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=6.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=6.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics (actual rows=1.00 loops=1) Order: metrics."time" DESC -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o1_3 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=101.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_1 (actual rows=101.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_time_idx on _hyper_X_X_chunk o2_3 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_2 (never executed) Index Cond: (device_id = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o3_3 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_2 (never executed) Index Cond: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o1_3 (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=2.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=2.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=1.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Merge Append (never executed) Sort Key: o."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (never executed) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=1.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=1.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=2.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=4.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=2.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space (actual rows=1.00 loops=1) Order: metrics_space."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space."time" DESC -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (actual rows=60.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_6 (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_9 (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_2 (actual rows=61.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_3 (actual rows=21.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_6 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o2_9 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=1.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space o3 (actual rows=100.00 loops=1) Order: o3."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_2 (never executed) Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o3_3 (never executed) Filter: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space o1 (actual rows=100.00 loops=1) Order: o1."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_2 (never executed) Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_time_idx on _hyper_X_X_chunk o1_3 (never executed) Filter: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space o2 (actual rows=100.00 loops=1) Order: o2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_2 (never executed) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk o2_3 (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=2.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Sort (never executed) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (device_id = 1) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) Filter: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.33 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.33 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.67 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=2) Order: o."time" Chunks excluded during startup: 0 Chunks excluded during runtime: 1 -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Sort (actual rows=0.00 loops=2) Sort Key: o_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Sort (actual rows=1.00 loops=2) Sort Key: o_2."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=3600.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3900 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.50 loops=2) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 22 -> Sort (never executed) Sort Key: o_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval))) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 0 Chunks excluded during runtime: 2 -> Sort (never executed) Sort Key: o_1."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Sort (never executed) Sort Key: o_2."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_3."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=3147.33 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 3650 Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=7.33 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now())) Rows Removed by Filter: 11 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_3 (actual rows=0.67 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" < now())) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC Chunks excluded during startup: 2 Chunks excluded during runtime: 0 -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Filter: ((_ts_meta_max_1 >= g."time") AND (_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 > now())) Rows Removed by Filter: 18 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Index Cond: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval)) AND ("time" > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Filter: (device_id = 2) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) Filter: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: ((device_id = 2) AND ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: ((_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) AND (device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Index Cond: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=2.00 loops=1) Order: o2."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=1.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=10.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=6.00 loops=1) Order: o1."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=5.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=2.00 loops=1) Index Cond: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Merge Append (actual rows=3598.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed (actual rows=1.00 loops=1) Order: metrics_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=25190.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=30.00 loops=1) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=80.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o1_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=81.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=16392.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o2_1 (actual rows=21.00 loops=1) -> Sort (never executed) Sort Key: o2_2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Merge Append (actual rows=1.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) Filter: (device_id = 3) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o3_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o2."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) Filter: (device_id = 2) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk o2_1 (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 2) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) Filter: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) RESET enable_seqscan; \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; --- QUERY PLAN --- Limit (actual rows=2.00 loops=1) -> Nested Loop (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=2.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; --- QUERY PLAN --- Nested Loop (actual rows=4.00 loops=1) -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) -> Materialize (actual rows=2.00 loops=2) -> Subquery Scan on l (actual rows=2.00 loops=1) -> Limit (actual rows=2.00 loops=1) -> Result (actual rows=2.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=2.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=2.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=2.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; --- QUERY PLAN --- Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.67 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.67 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=2.00 loops=1) -> Function Scan on generate_series g (actual rows=2.00 loops=1) -> Limit (actual rows=1.00 loops=2) -> Result (actual rows=1.00 loops=2) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=2) Order: o."time" -> Merge Append (actual rows=0.00 loops=2) Sort Key: o."time" -> Sort (actual rows=0.00 loops=2) Sort Key: o_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=2) Sort Key: o_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=2) Sort Key: o."time" -> Sort (actual rows=1.00 loops=2) Sort Key: o_4."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.50 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_5."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=2160.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2340 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.50 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=2) Sort Key: o_6."time" Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=720.00 loops=2) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 780 -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.50 loops=2) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (never executed) Sort Key: o."time" -> Sort (never executed) Sort Key: o_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -> Sort (never executed) Sort Key: o_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (never executed) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=1.00 loops=3) -> Result (actual rows=1.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=1.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Merge Append (actual rows=1.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=1.00 loops=3) Sort Key: o_7."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.67 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_8."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=2160.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 2438 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=5.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -> Sort (actual rows=1.00 loops=3) Sort Key: o_9."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=720.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Rows Removed by Filter: 813 Vectorized Filter: ("time" < now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.67 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_min_1 < now()) AND (_ts_meta_max_1 >= g."time")) -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; --- QUERY PLAN --- Nested Loop Left Join (actual rows=3.00 loops=1) -> Function Scan on generate_series g (actual rows=3.00 loops=1) -> Limit (actual rows=0.00 loops=3) -> Result (actual rows=0.00 loops=3) -> Custom Scan (ChunkAppend) on metrics_space_compressed o (actual rows=0.00 loops=3) Order: o."time" DESC -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_1."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_1 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_2."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_2 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_3."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_3 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_4."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_4 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_5."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_5 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_6."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_6 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Merge Append (actual rows=0.00 loops=3) Sort Key: o."time" DESC -> Sort (actual rows=0.00 loops=3) Sort Key: o_7."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_7 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_8."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_8 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -> Sort (actual rows=0.00 loops=3) Sort Key: o_9."time" DESC Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o_9 (actual rows=0.00 loops=3) Filter: (("time" >= g."time") AND ("time" < (g."time" + '@ 1 day'::interval))) Vectorized Filter: ("time" > now()) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=0.00 loops=3) Index Cond: ((_ts_meta_min_1 < (g."time" + '@ 1 day'::interval)) AND (_ts_meta_max_1 >= g."time") AND (_ts_meta_max_1 > now())) -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; --- QUERY PLAN --- Merge Join (actual rows=13674.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 1) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Materialize (actual rows=13674.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=13674.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=5038.00 loops=1) Vectorized Filter: ("time" < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: ((device_id = 2) AND (_ts_meta_min_1 < 'Tue Feb 01 00:00:00 2000 PST'::timestamp with time zone)) -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Join (actual rows=10.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=2.00 loops=1) Order: o1."time" -> Merge Append (actual rows=2.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (actual rows=1.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) Vectorized Filter: ("time" < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk (never executed) Filter: (_ts_meta_min_1 < 'Sat Jan 08 00:00:00 2000 PST'::timestamp with time zone) -> Materialize (actual rows=10.00 loops=1) -> Result (actual rows=6.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=6.00 loops=1) Order: o2."time" -> Merge Append (actual rows=6.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=2.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=4.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=2.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; --- QUERY PLAN --- Merge Join (actual rows=1.00 loops=1) Merge Cond: (o1."time" = ((InitPlan 1).col1)) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=13674.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=5038.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Index Cond: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: ((InitPlan 1).col1) Sort Method: quicksort -> Result (actual rows=1.00 loops=1) InitPlan 1 -> Limit (actual rows=1.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed (actual rows=1.00 loops=1) Order: metrics_space_compressed."time" DESC -> Merge Append (actual rows=1.00 loops=1) Sort Key: metrics_space_compressed."time" DESC -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=15114.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Sort (actual rows=1.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5038.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=6.00 loops=1) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: metrics_space_compressed."time" DESC -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (never executed) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: o1."time" Sort Method: quicksort -> Result (actual rows=0.00 loops=1) One-Time Filter: false -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") Join Filter: (o1.device_id = o2.device_id) Rows Removed by Join Filter: 400 -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Merge Append (actual rows=100.00 loops=1) Sort Key: o1."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o1_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Sort (actual rows=60.00 loops=1) Sort Key: o1_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o1_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Merge Append (never executed) Sort Key: o1."time" -> Sort (never executed) Sort Key: o1_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Sort (never executed) Sort Key: o1_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) -> Materialize (actual rows=500.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=101.00 loops=1) Order: o2."time" -> Merge Append (actual rows=101.00 loops=1) Sort Key: o2."time" -> Sort (actual rows=21.00 loops=1) Sort Key: o2_1."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Sort (actual rows=61.00 loops=1) Sort Key: o2_2."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (actual rows=10794.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=12.00 loops=1) -> Sort (actual rows=21.00 loops=1) Sort Key: o2_3."time" Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (actual rows=3598.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=4.00 loops=1) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_4."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_4 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_5."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_5 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_6."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_6 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Merge Append (never executed) Sort Key: o2."time" -> Sort (never executed) Sort Key: o2_7."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_7 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_8."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_8 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -> Sort (never executed) Sort Key: o2_9."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_9 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Nested Loop (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=1.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=1.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Append (actual rows=100.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (never executed) Index Cond: (device_id = 1) -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; --- QUERY PLAN --- Limit (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o3."time" = o1."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o3 (actual rows=100.00 loops=1) Order: o3."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o3_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 3) -> Materialize (actual rows=100.00 loops=1) -> Merge Join (actual rows=100.00 loops=1) Merge Cond: (o1."time" = o2."time") -> Custom Scan (ChunkAppend) on metrics_space_compressed o1 (actual rows=100.00 loops=1) Order: o1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o1_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 1) -> Materialize (actual rows=100.00 loops=1) -> Custom Scan (ChunkAppend) on metrics_space_compressed o2 (actual rows=100.00 loops=1) Order: o2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_1 (actual rows=100.00 loops=1) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (actual rows=1.00 loops=1) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_2 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk o2_3 (never executed) -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on compress_hyper_X_X_chunk (never executed) Index Cond: (device_id = 2) RESET enable_seqscan; -- Disable plain/sorted aggregation to get a deterministic test output SET timescaledb.enable_chunkwise_aggregation = OFF; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none table_name ------------ i4418_1 table_name ------------ i4418_2 --- QUERY PLAN --- Sort (actual rows=20.00 loops=1) Sort Key: (time_bucket('@ 1 day'::interval, tbl1."time")) Sort Method: quicksort -> HashAggregate (actual rows=20.00 loops=1) Group Key: time_bucket('@ 1 day'::interval, tbl1."time") -> Merge Join (actual rows=9121.00 loops=1) Merge Cond: ((tbl1.device = tbl2.device) AND (tbl1."time" = tbl2."time")) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl1.device, tbl1."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl1_4 (actual rows=1101.00 loops=1) -> Sort (actual rows=9121.00 loops=1) Sort Key: tbl2.device, tbl2."time" Sort Method: quicksort -> Append (actual rows=9121.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_1 (actual rows=1300.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_2 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_3 (actual rows=3360.00 loops=1) -> Seq Scan on _hyper_X_X_chunk tbl2_4 (actual rows=1101.00 loops=1) ������������������������������timescaledb-2.23.0/tsl/test/shared/expected/security_barrier.out������������������������������������0000664�0000000�0000000�00000004240�15100345067�0025011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE test_security_barrier (time TIMESTAMPTZ NOT NULL, tenant TEXT NOT NULL, data TEXT); SELECT FROM create_hypertable('test_security_barrier', by_range('time')); -- INSERT INTO test_security_barrier(time, tenant, data) VALUES ('2020-01-01', :'ROLE_DEFAULT_PERM_USER','data1'), ('2020-01-01', :'ROLE_DEFAULT_PERM_USER_2','data2'); CREATE VIEW test_security_barrier_view WITH (security_barrier) AS SELECT * FROM test_security_barrier WHERE tenant = current_user; GRANT SELECT ON test_security_barrier_view TO :ROLE_DEFAULT_PERM_USER; GRANT SELECT ON test_security_barrier_view TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM test_security_barrier_view; time | tenant | data ------------------------------+-------------------+------- Wed Jan 01 00:00:00 2020 PST | default_perm_user | data1 RESET ROLE; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM test_security_barrier_view; time | tenant | data ------------------------------+---------------------+------- Wed Jan 01 00:00:00 2020 PST | default_perm_user_2 | data2 RESET ROLE; ALTER TABLE test_security_barrier SET (timescaledb.compress); -- Compress the chunk SELECT compress_chunk(show_chunks('test_security_barrier')) IS NOT NULL AS compressed; compressed ------------ t SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM test_security_barrier_view; time | tenant | data ------------------------------+-------------------+------- Wed Jan 01 00:00:00 2020 PST | default_perm_user | data1 RESET ROLE; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM test_security_barrier_view; time | tenant | data ------------------------------+---------------------+------- Wed Jan 01 00:00:00 2020 PST | default_perm_user_2 | data2 RESET ROLE; DROP TABLE test_security_barrier CASCADE; NOTICE: drop cascades to view test_security_barrier_view ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/space_constraint-15.out���������������������������������0000664�0000000�0000000�00000136443�15100345067�0025231�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- test SELECT FOR UPDATE :PREFIX SELECT FROM metrics_space WHERE device_id = 1 FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1,3) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id = ANY ('{1,3}'::integer[])) -- check mismatching datatypes :PREFIX SELECT FROM metrics_space WHERE device_id = smallint '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = '2'::smallint) :PREFIX SELECT FROM metrics_space WHERE device_id = int '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = 2) :PREFIX SELECT FROM metrics_space WHERE device_id = bigint '3' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = '3'::bigint) :PREFIX SELECT FROM metrics_space WHERE device_id IN (smallint '1', smallint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (int '1', int '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (bigint '1', bigint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::bigint[])) -- test valid variants we are optimizing :PREFIX DELETE FROM metrics_space WHERE device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,3); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- test multiple constraints :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space -> Result One-Time Filter: false :PREFIX DELETE FROM metrics_space WHERE device_id = 1 OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id IN (2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE (time > '2000-01-01' OR device_id = 1) OR (time < '3000-01-01' OR device_id = 2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -- variants we don't optimize :PREFIX DELETE FROM metrics_space WHERE device_id > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_1 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_7 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id > 1) :PREFIX DELETE FROM metrics_space WHERE device_id < 10; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id < 10) -- CTE :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id ) SELECT FROM q1; --- QUERY PLAN --- CTE Scan on q1 CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id = 2 RETURNING device_id ) DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id; --- QUERY PLAN --- Custom Scan (ModifyHypertable) CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 Delete on _hyper_X_X_chunk metrics_space_10 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_10 Index Cond: (device_id = 2) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- JOIN :PREFIX DELETE FROM metrics_space m1 using metrics_space m2 WHERE m1.device_id = 1 AND m2.device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space m1 Delete on _hyper_X_X_chunk m1_1 Delete on _hyper_X_X_chunk m1_2 Delete on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_3 Filter: (device_id = 1) -> Materialize -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) :PREFIX UPDATE metrics_space m1 set v0 = 0.1 FROM metrics_space m2 WHERE m2.device_id=1 AND m1.device_id=2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on metrics_space m1 Update on _hyper_X_X_chunk m1_1 Update on _hyper_X_X_chunk m1_2 Update on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 2) -> Materialize -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_3 Filter: (device_id = 1) -- test multiple space dimensions and different datatypes CREATE TABLE space_constraint(time timestamptz, s1 text, s2 numeric, s3 int, v float); SELECT table_name FROM create_hypertable('space_constraint','time'); table_name ------------------ space_constraint SELECT column_name FROM add_dimension('space_constraint','s1',number_partitions:=3); column_name ------------- s1 SELECT column_name FROM add_dimension('space_constraint','s2',number_partitions:=3); column_name ------------- s2 SELECT column_name FROM add_dimension('space_constraint','s3',number_partitions:=3); column_name ------------- s3 INSERT INTO space_constraint SELECT t,s1,s2,s3,0.12345 FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01')) v1(t), (VALUES ('s1_1'),('s1_2')) v2(s1), (VALUES (1.23),(4.56)) v3(s2), (VALUES (1),(2)) v4(s3); \set PREFIX 'EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 Delete on _hyper_X_X_chunk space_constraint_5 Delete on _hyper_X_X_chunk space_constraint_6 Delete on _hyper_X_X_chunk space_constraint_7 Delete on _hyper_X_X_chunk space_constraint_8 -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 Update on _hyper_X_X_chunk space_constraint_5 Update on _hyper_X_X_chunk space_constraint_6 Update on _hyper_X_X_chunk space_constraint_7 Update on _hyper_X_X_chunk space_constraint_8 -> Result (actual rows=8.00 loops=1) -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; DROP TABLE space_constraint; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/space_constraint-16.out���������������������������������0000664�0000000�0000000�00000136443�15100345067�0025232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- test SELECT FOR UPDATE :PREFIX SELECT FROM metrics_space WHERE device_id = 1 FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1,3) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id = ANY ('{1,3}'::integer[])) -- check mismatching datatypes :PREFIX SELECT FROM metrics_space WHERE device_id = smallint '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = '2'::smallint) :PREFIX SELECT FROM metrics_space WHERE device_id = int '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = 2) :PREFIX SELECT FROM metrics_space WHERE device_id = bigint '3' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = '3'::bigint) :PREFIX SELECT FROM metrics_space WHERE device_id IN (smallint '1', smallint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (int '1', int '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (bigint '1', bigint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::bigint[])) -- test valid variants we are optimizing :PREFIX DELETE FROM metrics_space WHERE device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,3); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- test multiple constraints :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space -> Result One-Time Filter: false :PREFIX DELETE FROM metrics_space WHERE device_id = 1 OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id IN (2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE (time > '2000-01-01' OR device_id = 1) OR (time < '3000-01-01' OR device_id = 2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -- variants we don't optimize :PREFIX DELETE FROM metrics_space WHERE device_id > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_1 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_7 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id > 1) :PREFIX DELETE FROM metrics_space WHERE device_id < 10; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id < 10) -- CTE :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id ) SELECT FROM q1; --- QUERY PLAN --- CTE Scan on q1 CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id = 2 RETURNING device_id ) DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id; --- QUERY PLAN --- Custom Scan (ModifyHypertable) CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 Delete on _hyper_X_X_chunk metrics_space_10 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_10 Index Cond: (device_id = 2) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- JOIN :PREFIX DELETE FROM metrics_space m1 using metrics_space m2 WHERE m1.device_id = 1 AND m2.device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space m1 Delete on _hyper_X_X_chunk m1_1 Delete on _hyper_X_X_chunk m1_2 Delete on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_3 Filter: (device_id = 1) -> Materialize -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) :PREFIX UPDATE metrics_space m1 set v0 = 0.1 FROM metrics_space m2 WHERE m2.device_id=1 AND m1.device_id=2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on metrics_space m1 Update on _hyper_X_X_chunk m1_1 Update on _hyper_X_X_chunk m1_2 Update on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 2) -> Materialize -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_3 Filter: (device_id = 1) -- test multiple space dimensions and different datatypes CREATE TABLE space_constraint(time timestamptz, s1 text, s2 numeric, s3 int, v float); SELECT table_name FROM create_hypertable('space_constraint','time'); table_name ------------------ space_constraint SELECT column_name FROM add_dimension('space_constraint','s1',number_partitions:=3); column_name ------------- s1 SELECT column_name FROM add_dimension('space_constraint','s2',number_partitions:=3); column_name ------------- s2 SELECT column_name FROM add_dimension('space_constraint','s3',number_partitions:=3); column_name ------------- s3 INSERT INTO space_constraint SELECT t,s1,s2,s3,0.12345 FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01')) v1(t), (VALUES ('s1_1'),('s1_2')) v2(s1), (VALUES (1.23),(4.56)) v3(s2), (VALUES (1),(2)) v4(s3); \set PREFIX 'EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 Delete on _hyper_X_X_chunk space_constraint_5 Delete on _hyper_X_X_chunk space_constraint_6 Delete on _hyper_X_X_chunk space_constraint_7 Delete on _hyper_X_X_chunk space_constraint_8 -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 Update on _hyper_X_X_chunk space_constraint_5 Update on _hyper_X_X_chunk space_constraint_6 Update on _hyper_X_X_chunk space_constraint_7 Update on _hyper_X_X_chunk space_constraint_8 -> Result (actual rows=8.00 loops=1) -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; DROP TABLE space_constraint; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/space_constraint-17.out���������������������������������0000664�0000000�0000000�00000136443�15100345067�0025233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- test SELECT FOR UPDATE :PREFIX SELECT FROM metrics_space WHERE device_id = 1 FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1,3) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id = ANY ('{1,3}'::integer[])) -- check mismatching datatypes :PREFIX SELECT FROM metrics_space WHERE device_id = smallint '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = '2'::smallint) :PREFIX SELECT FROM metrics_space WHERE device_id = int '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = 2) :PREFIX SELECT FROM metrics_space WHERE device_id = bigint '3' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = '3'::bigint) :PREFIX SELECT FROM metrics_space WHERE device_id IN (smallint '1', smallint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (int '1', int '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (bigint '1', bigint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::bigint[])) -- test valid variants we are optimizing :PREFIX DELETE FROM metrics_space WHERE device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,3); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- test multiple constraints :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space -> Result One-Time Filter: false :PREFIX DELETE FROM metrics_space WHERE device_id = 1 OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id IN (2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_2 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_3 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_5 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_6 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_8 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) -> Bitmap Heap Scan on _hyper_X_X_chunk metrics_space_9 Recheck Cond: ((device_id = 1) OR (device_id = 2)) -> BitmapOr -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 1) -> Bitmap Index Scan on _hyper_X_X_chunk_metrics_space_device_id_time_idx Index Cond: (device_id = 2) :PREFIX DELETE FROM metrics_space WHERE (time > '2000-01-01' OR device_id = 1) OR (time < '3000-01-01' OR device_id = 2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -- variants we don't optimize :PREFIX DELETE FROM metrics_space WHERE device_id > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_1 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_7 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id > 1) :PREFIX DELETE FROM metrics_space WHERE device_id < 10; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id < 10) -- CTE :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id ) SELECT FROM q1; --- QUERY PLAN --- CTE Scan on q1 CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id = 2 RETURNING device_id ) DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id; --- QUERY PLAN --- Custom Scan (ModifyHypertable) CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 Delete on _hyper_X_X_chunk metrics_space_10 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_10 Index Cond: (device_id = 2) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- JOIN :PREFIX DELETE FROM metrics_space m1 using metrics_space m2 WHERE m1.device_id = 1 AND m2.device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space m1 Delete on _hyper_X_X_chunk m1_1 Delete on _hyper_X_X_chunk m1_2 Delete on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_3 Filter: (device_id = 1) -> Materialize -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) :PREFIX UPDATE metrics_space m1 set v0 = 0.1 FROM metrics_space m2 WHERE m2.device_id=1 AND m1.device_id=2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on metrics_space m1 Update on _hyper_X_X_chunk m1_1 Update on _hyper_X_X_chunk m1_2 Update on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 2) -> Materialize -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_3 Filter: (device_id = 1) -- test multiple space dimensions and different datatypes CREATE TABLE space_constraint(time timestamptz, s1 text, s2 numeric, s3 int, v float); SELECT table_name FROM create_hypertable('space_constraint','time'); table_name ------------------ space_constraint SELECT column_name FROM add_dimension('space_constraint','s1',number_partitions:=3); column_name ------------- s1 SELECT column_name FROM add_dimension('space_constraint','s2',number_partitions:=3); column_name ------------- s2 SELECT column_name FROM add_dimension('space_constraint','s3',number_partitions:=3); column_name ------------- s3 INSERT INTO space_constraint SELECT t,s1,s2,s3,0.12345 FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01')) v1(t), (VALUES ('s1_1'),('s1_2')) v2(s1), (VALUES (1.23),(4.56)) v3(s2), (VALUES (1),(2)) v4(s3); \set PREFIX 'EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 Delete on _hyper_X_X_chunk space_constraint_5 Delete on _hyper_X_X_chunk space_constraint_6 Delete on _hyper_X_X_chunk space_constraint_7 Delete on _hyper_X_X_chunk space_constraint_8 -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 Update on _hyper_X_X_chunk space_constraint_5 Update on _hyper_X_X_chunk space_constraint_6 Update on _hyper_X_X_chunk space_constraint_7 Update on _hyper_X_X_chunk space_constraint_8 -> Result (actual rows=8.00 loops=1) -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; DROP TABLE space_constraint; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/space_constraint-18.out���������������������������������0000664�0000000�0000000�00000123527�15100345067�0025233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- test SELECT FOR UPDATE :PREFIX SELECT FROM metrics_space WHERE device_id = 1 FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = 1) :PREFIX SELECT FROM metrics_space WHERE device_id IN (1,3) FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id = ANY ('{1,3}'::integer[])) -- check mismatching datatypes :PREFIX SELECT FROM metrics_space WHERE device_id = smallint '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = '2'::smallint) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = '2'::smallint) :PREFIX SELECT FROM metrics_space WHERE device_id = int '2' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id = 2) :PREFIX SELECT FROM metrics_space WHERE device_id = bigint '3' FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = '3'::bigint) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = '3'::bigint) :PREFIX SELECT FROM metrics_space WHERE device_id IN (smallint '1', smallint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (int '1', int '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX SELECT FROM metrics_space WHERE device_id IN (bigint '1', bigint '1') FOR UPDATE; --- QUERY PLAN --- LockRows -> Append -> Seq Scan on metrics_space metrics_space_1 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::bigint[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,1}'::bigint[])) -- test valid variants we are optimizing :PREFIX DELETE FROM metrics_space WHERE device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = 1) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,1); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,1}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,1}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,3); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- test multiple constraints :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: ((device_id = 1) AND (_timescaledb_functions.get_partition_hash(device_id) = 242423622)) :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space -> Result One-Time Filter: false :PREFIX DELETE FROM metrics_space WHERE device_id = 1 OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_5 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_6 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = ANY ('{1,2}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id IN (2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_5 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_6 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = ANY ('{1,2}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_2 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_3 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_5 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_6 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: ((device_id = 1) OR (device_id = 2)) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = ANY ('{1,2}'::integer[])) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = ANY ('{1,2}'::integer[])) :PREFIX DELETE FROM metrics_space WHERE (time > '2000-01-01' OR device_id = 1) OR (time < '3000-01-01' OR device_id = 2); --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (("time" > 'Sat Jan 01 00:00:00 2000 PST'::timestamp with time zone) OR (device_id = 1) OR ("time" < 'Wed Jan 01 00:00:00 3000 PST'::timestamp with time zone) OR (device_id = 2)) -- variants we don't optimize :PREFIX DELETE FROM metrics_space WHERE device_id > 1; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_1 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_4 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id > 1) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_7 Index Cond: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id > 1) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id > 1) :PREFIX DELETE FROM metrics_space WHERE device_id < 10; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 Delete on _hyper_X_X_chunk metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_7 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_8 Filter: (device_id < 10) -> Seq Scan on _hyper_X_X_chunk metrics_space_9 Filter: (device_id < 10) -- CTE :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id ) SELECT FROM q1; --- QUERY PLAN --- CTE Scan on q1 CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id = 2 RETURNING device_id ) DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id; --- QUERY PLAN --- Custom Scan (ModifyHypertable) CTE q1 -> Custom Scan (ModifyHypertable) -> Delete on metrics_space metrics_space_7 Delete on _hyper_X_X_chunk metrics_space_8 Delete on _hyper_X_X_chunk metrics_space_9 Delete on _hyper_X_X_chunk metrics_space_10 -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_8 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_9 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk metrics_space_10 Index Cond: (device_id = 2) -> Delete on metrics_space Delete on _hyper_X_X_chunk metrics_space_1 Delete on _hyper_X_X_chunk metrics_space_2 Delete on _hyper_X_X_chunk metrics_space_3 Delete on _hyper_X_X_chunk metrics_space_4 Delete on _hyper_X_X_chunk metrics_space_5 Delete on _hyper_X_X_chunk metrics_space_6 -> Append -> Seq Scan on _hyper_X_X_chunk metrics_space_1 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_2 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_3 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_4 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_5 Filter: (device_id = ANY ('{1,3}'::integer[])) -> Seq Scan on _hyper_X_X_chunk metrics_space_6 Filter: (device_id = ANY ('{1,3}'::integer[])) -- JOIN :PREFIX DELETE FROM metrics_space m1 using metrics_space m2 WHERE m1.device_id = 1 AND m2.device_id = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Delete on metrics_space m1 Delete on _hyper_X_X_chunk m1_1 Delete on _hyper_X_X_chunk m1_2 Delete on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Seq Scan on _hyper_X_X_chunk m1_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m1_3 Filter: (device_id = 1) -> Materialize -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) :PREFIX UPDATE metrics_space m1 set v0 = 0.1 FROM metrics_space m2 WHERE m2.device_id=1 AND m1.device_id=2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) -> Update on metrics_space m1 Update on _hyper_X_X_chunk m1_1 Update on _hyper_X_X_chunk m1_2 Update on _hyper_X_X_chunk m1_3 -> Nested Loop -> Append -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 2) -> Materialize -> Append -> Seq Scan on _hyper_X_X_chunk m2_1 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_2 Filter: (device_id = 1) -> Seq Scan on _hyper_X_X_chunk m2_3 Filter: (device_id = 1) -- test multiple space dimensions and different datatypes CREATE TABLE space_constraint(time timestamptz, s1 text, s2 numeric, s3 int, v float); SELECT table_name FROM create_hypertable('space_constraint','time'); table_name ------------------ space_constraint SELECT column_name FROM add_dimension('space_constraint','s1',number_partitions:=3); column_name ------------- s1 SELECT column_name FROM add_dimension('space_constraint','s2',number_partitions:=3); column_name ------------- s2 SELECT column_name FROM add_dimension('space_constraint','s3',number_partitions:=3); column_name ------------- s3 INSERT INTO space_constraint SELECT t,s1,s2,s3,0.12345 FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01')) v1(t), (VALUES ('s1_1'),('s1_2')) v2(s1), (VALUES (1.23),(4.56)) v3(s2), (VALUES (1),(2)) v4(s3); \set PREFIX 'EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 Delete on _hyper_X_X_chunk space_constraint_5 Delete on _hyper_X_X_chunk space_constraint_6 Delete on _hyper_X_X_chunk space_constraint_7 Delete on _hyper_X_X_chunk space_constraint_8 -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Delete on space_constraint (actual rows=0.00 loops=1) Delete on _hyper_X_X_chunk space_constraint_1 Delete on _hyper_X_X_chunk space_constraint_2 Delete on _hyper_X_X_chunk space_constraint_3 Delete on _hyper_X_X_chunk space_constraint_4 -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2'; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 Update on _hyper_X_X_chunk space_constraint_5 Update on _hyper_X_X_chunk space_constraint_6 Update on _hyper_X_X_chunk space_constraint_7 Update on _hyper_X_X_chunk space_constraint_8 -> Result (actual rows=8.00 loops=1) -> Append (actual rows=8.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_5 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_6 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_7 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) -> Seq Scan on _hyper_X_X_chunk space_constraint_8 (actual rows=1.00 loops=1) Filter: (s1 = 's1_2'::text) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 -> Result (actual rows=1.00 loops=1) -> Index Scan using _hyper_X_X_chunk_space_constraint_time_idx on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Index Cond: ("time" > 'Thu Jun 01 00:00:00 2000 PDT'::timestamp with time zone) Filter: ((s1 = 's1_2'::text) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_2,s1_2}'::text[])) AND (s2 = 1.23) AND (s3 = 2)) ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); --- QUERY PLAN --- Custom Scan (ModifyHypertable) (actual rows=0.00 loops=1) -> Update on space_constraint (actual rows=0.00 loops=1) Update on _hyper_X_X_chunk space_constraint_1 Update on _hyper_X_X_chunk space_constraint_2 Update on _hyper_X_X_chunk space_constraint_3 Update on _hyper_X_X_chunk space_constraint_4 -> Result (actual rows=2.00 loops=1) -> Append (actual rows=2.00 loops=1) -> Seq Scan on _hyper_X_X_chunk space_constraint_1 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_2 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 -> Seq Scan on _hyper_X_X_chunk space_constraint_3 (actual rows=1.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) -> Seq Scan on _hyper_X_X_chunk space_constraint_4 (actual rows=0.00 loops=1) Filter: ((s1 = ANY ('{s1_1,s1_3}'::text[])) AND (s2 = ANY ('{1.23,4.44}'::numeric[])) AND (s3 = ANY ('{1,100}'::integer[]))) Rows Removed by Filter: 1 ROLLBACK; DROP TABLE space_constraint; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/subtract_integer_from_now.out���������������������������0000664�0000000�0000000�00000006744�15100345067�0026721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test on normal table \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now('pg_class', 1); ERROR: table "pg_class" is not a hypertable \set ON_ERROR_STOP 1 -- test on hypertable with non-int time dimension \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now('metrics', 1); ERROR: hypertable has no integer partitioning dimension \set ON_ERROR_STOP 1 SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "TABLENAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'metrics_compressed') \gset -- test on hypertable without dimensions \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now(:'TABLENAME', 1); ERROR: hypertable has no open partitioning dimension \set ON_ERROR_STOP 1 -- test on hypertable without now function CREATE TABLE subtract_int_no_func(time int NOT NULL); SELECT table_name FROM create_hypertable('subtract_int_no_func','time',chunk_time_interval:=10); table_name ---------------------- subtract_int_no_func \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int_no_func', 1); ERROR: integer_now function not set \set ON_ERROR_STOP 1 CREATE OR REPLACE FUNCTION sub_int2_now() RETURNS int2 AS $$ SELECT 2::int2; $$ LANGUAGE SQL IMMUTABLE; CREATE OR REPLACE FUNCTION sub_int4_now() RETURNS int4 AS $$ SELECT 4::int4; $$ LANGUAGE SQL IMMUTABLE; CREATE OR REPLACE FUNCTION sub_int8_now() RETURNS int8 AS $$ SELECT 8::int8; $$ LANGUAGE SQL IMMUTABLE; CREATE TABLE subtract_int2(time int2 NOT NULL); CREATE TABLE subtract_int4(time int4 NOT NULL); CREATE TABLE subtract_int8(time int8 NOT NULL); SELECT table_name FROM create_hypertable('subtract_int2', 'time', chunk_time_interval:=10); table_name --------------- subtract_int2 SELECT table_name FROM create_hypertable('subtract_int4', 'time', chunk_time_interval:=10); table_name --------------- subtract_int4 SELECT table_name FROM create_hypertable('subtract_int8', 'time', chunk_time_interval:=10); table_name --------------- subtract_int8 SELECT set_integer_now_func('subtract_int2', 'sub_int2_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('subtract_int4', 'sub_int4_now'); set_integer_now_func ---------------------- SELECT set_integer_now_func('subtract_int8', 'sub_int8_now'); set_integer_now_func ---------------------- SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int2', lag) AS sub FROM (VALUES (-10),(0),(2),(4),(8)) v(lag); sub ----- 12 2 0 -2 -6 SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int4', lag) AS sub FROM (VALUES (-10),(0),(2),(4),(8)) v(lag); sub ----- 14 4 2 0 -4 SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int8', lag) AS sub FROM (VALUES (-10),(0),(2),(4),(8)) v(lag); sub ----- 18 8 6 4 0 -- test set_integer_now_func on internal table \set ON_ERROR_STOP 0 SELECT set_integer_now_func(:'TABLENAME', 'sub_int2_now'); ERROR: custom time function not supported on internal columnstore table \set ON_ERROR_STOP 1 -- cleanup DROP TABLE subtract_int_no_func; DROP TABLE subtract_int2; DROP TABLE subtract_int4; DROP TABLE subtract_int8; ����������������������������timescaledb-2.23.0/tsl/test/shared/expected/timestamp_limits.out������������������������������������0000664�0000000�0000000�00000025665�15100345067�0025036�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.min_pg_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_pg_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_pg_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_pg_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_ts_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_ts_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_min_ts_timestamptz() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamptz_internal_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_end_ts_timestamptz() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamptz_internal_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_pg_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_pg_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_pg_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_pg_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_ts_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_ts_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_min_ts_timestamp() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamp_internal_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_end_ts_timestamp() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamp_internal_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_pg_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_pg_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_pg_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_pg_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_ts_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_ts_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_min_ts_date() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_date_internal_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_end_ts_date() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_date_internal_end' LANGUAGE C VOLATILE; SET ROLE :ROLE_DEFAULT_PERM_USER; --show PG and TimescaleDB-specific time boundaries. Note that we --internally convert to UNIX epoch, which restricts the range of --supported timestamps. SET datestyle TO 'ISO,YMD'; \x --To display end timestamps (which aren't valid timestamps), we need --to be at UTC to avoid timezone conversion which would fail with --out-of-range error. Being at UTC also makes it easier to compare --TIMESTAMP and TIMESTAMP WITH TIME ZONE. SET timezone TO 'UTC'; -- MIN values (PostgreSQL). SELECT test.min_pg_timestamptz(), test.min_pg_timestamp(), test.min_pg_date(); -[ RECORD 1 ]------+-------------------------- min_pg_timestamptz | 4714-11-24 00:00:00+00 BC min_pg_timestamp | 4714-11-24 00:00:00 BC min_pg_date | 4714-11-24 BC -- MIN values (TimescaleDB). SELECT test.min_ts_timestamptz(), test.min_ts_timestamp(), test.min_ts_date(), _timescaledb_functions.to_timestamp(test.internal_min_ts_timestamptz()) AS min_ts_internal_timestamptz, _timescaledb_functions.to_timestamp_without_timezone(test.internal_min_ts_timestamp()) AS min_ts_internal_timestamp, _timescaledb_functions.to_date(test.internal_min_ts_date()) AS min_ts_internal_date; -[ RECORD 1 ]---------------+-------------------------- min_ts_timestamptz | 4714-11-24 00:00:00+00 BC min_ts_timestamp | 4714-11-24 00:00:00 BC min_ts_date | 4714-11-24 BC min_ts_internal_timestamptz | 4714-11-24 00:00:00+00 BC min_ts_internal_timestamp | 4714-11-24 00:00:00 BC min_ts_internal_date | 4714-11-24 BC -- END values (PostgreSQL). Note that and values aren't valid -- timestamps or dates (since, e.g., END_TIMESTAMP is exclusive). It -- is possible to display them at UTC since no conversion is made. SELECT test.end_pg_timestamptz(), test.end_pg_timestamp(), test.end_pg_date(); -[ RECORD 1 ]------+------------------------- end_pg_timestamptz | 294277-01-01 00:00:00+00 end_pg_timestamp | 294277-01-01 00:00:00 end_pg_date | 5874898-01-01 -- END values (TimescaleDB). Note that we convert DATE to TIMESTAMP -- internally, and that limits the end to that of timestamp. SELECT test.end_ts_timestamptz(), test.end_ts_timestamp(), test.end_ts_date(), _timescaledb_functions.to_timestamp(test.internal_end_ts_timestamptz()) AS end_ts_internal_timestamptz, _timescaledb_functions.to_timestamp_without_timezone(test.internal_end_ts_timestamp()) AS end_ts_internal_timestamp, _timescaledb_functions.to_date(test.internal_end_ts_date()) AS end_ts_internal_date; -[ RECORD 1 ]---------------+------------------------- end_ts_timestamptz | 294247-01-02 00:00:00+00 end_ts_timestamp | 294247-01-02 00:00:00 end_ts_date | 294247-01-02 end_ts_internal_timestamptz | 294247-01-02 00:00:00+00 end_ts_internal_timestamp | 294247-01-02 00:00:00 end_ts_internal_date | 294247-01-02 --Test insert of time values close to or at limits --Suitable constraints should be created on chunks CREATE TABLE smallint_table(time smallint); SELECT table_name FROM create_hypertable('smallint_table', 'time', chunk_time_interval=>10); -[ RECORD 1 ]-------------- table_name | smallint_table INSERT INTO smallint_table VALUES (-32768), (32767); SELECT pg_get_constraintdef(c.oid) FROM show_chunks('smallint_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; -[ RECORD 1 ]--------+-------------------------------------- pg_get_constraintdef | CHECK (("time" < '-32760'::smallint)) -[ RECORD 2 ]--------+-------------------------------------- pg_get_constraintdef | CHECK (("time" >= '32760'::smallint)) CREATE TABLE int_table(time int); SELECT table_name FROM create_hypertable('int_table', 'time', chunk_time_interval=>10); -[ RECORD 1 ]--------- table_name | int_table INSERT INTO int_table VALUES (-2147483648), (2147483647); SELECT pg_get_constraintdef(c.oid) FROM show_chunks('int_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; -[ RECORD 1 ]--------+------------------------------------------ pg_get_constraintdef | CHECK (("time" < '-2147483640'::integer)) -[ RECORD 2 ]--------+------------------------------------------ pg_get_constraintdef | CHECK (("time" >= 2147483640)) CREATE TABLE bigint_table(time bigint); SELECT table_name FROM create_hypertable('bigint_table', 'time', chunk_time_interval=>10); -[ RECORD 1 ]------------ table_name | bigint_table INSERT INTO bigint_table VALUES (-9223372036854775808), (9223372036854775807); SELECT pg_get_constraintdef(c.oid) FROM show_chunks('bigint_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; -[ RECORD 1 ]--------+-------------------------------------------------- pg_get_constraintdef | CHECK (("time" < '-9223372036854775800'::bigint)) -[ RECORD 2 ]--------+-------------------------------------------------- pg_get_constraintdef | CHECK (("time" >= '9223372036854775800'::bigint)) CREATE TABLE date_table(time date); SELECT table_name FROM create_hypertable('date_table', 'time'); -[ RECORD 1 ]---------- table_name | date_table INSERT INTO date_table VALUES (test.min_ts_date()), (test.end_ts_date() - INTERVAL '1 day'); -- Test out-of-range dates \set ON_ERROR_STOP 0 INSERT INTO date_table VALUES (test.min_ts_date() - INTERVAL '1 day'); ERROR: timestamp out of range INSERT INTO date_table VALUES (test.end_ts_date()); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT pg_get_constraintdef(c.oid) FROM show_chunks('date_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; -[ RECORD 1 ]--------+----------------------------------------- pg_get_constraintdef | CHECK (("time" < '4714-11-27 BC'::date)) -[ RECORD 2 ]--------+----------------------------------------- pg_get_constraintdef | CHECK (("time" >= '294246-12-31'::date)) CREATE TABLE timestamp_table(time timestamp); SELECT table_name FROM create_hypertable('timestamp_table', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices -[ RECORD 1 ]--------------- table_name | timestamp_table INSERT INTO timestamp_table VALUES (test.min_ts_timestamp()); INSERT INTO timestamp_table VALUES (test.end_ts_timestamp() - INTERVAL '1 microsecond'); -- Test out-of-range timestamps \set ON_ERROR_STOP 0 INSERT INTO timestamp_table VALUES (test.min_ts_timestamp() - INTERVAL '1 microsecond'); ERROR: timestamp out of range INSERT INTO timestamp_table VALUES (test.end_ts_timestamp()); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT pg_get_constraintdef(c.oid) FROM show_chunks('timestamp_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; -[ RECORD 1 ]--------+------------------------------------------------------------------------- pg_get_constraintdef | CHECK (("time" < '4714-11-27 00:00:00 BC'::timestamp without time zone)) -[ RECORD 2 ]--------+------------------------------------------------------------------------- pg_get_constraintdef | CHECK (("time" >= '294246-12-31 00:00:00'::timestamp without time zone)) CREATE TABLE timestamptz_table(time timestamp); SELECT table_name FROM create_hypertable('timestamptz_table', 'time'); WARNING: column type "timestamp without time zone" used for "time" does not follow best practices -[ RECORD 1 ]----------------- table_name | timestamptz_table -- Need to be at UTC for this to work for timestamp with time zone INSERT INTO timestamptz_table VALUES (test.min_ts_timestamptz()); INSERT INTO timestamptz_table VALUES (test.end_ts_timestamptz() - INTERVAL '1 microsecond'); -- Test out-of-range timestamps \set ON_ERROR_STOP 0 INSERT INTO timestamptz_table VALUES (test.min_ts_timestamptz() - INTERVAL '1 microsecond'); ERROR: timestamp out of range INSERT INTO timestamptz_table VALUES (test.end_ts_timestamptz()); ERROR: timestamp out of range \set ON_ERROR_STOP 1 SELECT pg_get_constraintdef(c.oid) FROM show_chunks('timestamptz_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; -[ RECORD 1 ]--------+------------------------------------------------------------------------- pg_get_constraintdef | CHECK (("time" < '4714-11-27 00:00:00 BC'::timestamp without time zone)) -[ RECORD 2 ]--------+------------------------------------------------------------------------- pg_get_constraintdef | CHECK (("time" >= '294246-12-31 00:00:00'::timestamp without time zone)) RESET datestyle; RESET timezone; ���������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/transparent_decompress_chunk-15.out���������������������0000664�0000000�0000000�00000214772�15100345067�0027651�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' \set PREFIX_NO_VERBOSE 'EXPLAIN (buffers off, costs off)' -- Some tweaks to get less flaky test SET parallel_leader_participation TO off; SET min_parallel_table_scan_size TO '0'; SET enable_incremental_sort TO off; SELECT show_chunks('metrics_compressed') AS "TEST_TABLE" ORDER BY 1::text LIMIT 1 \gset -- this should use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=5.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- must not use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM ONLY :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- this should use ColumnarScan node :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk _hyper_X_X_chunk_1 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE ORDER BY time; --- QUERY PLAN --- Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", t AS "RECORD" FROM :TEST_TABLE t WHERE device_id IN (1, 2) ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=7196.00 loops=1) Sort Key: t."time", t.device_id Sort Method: quicksort -> Result (actual rows=7196.00 loops=1) -> Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk t (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _hyper_X_X_chunk t (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=17990.00 loops=1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Append (actual rows=719.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=0.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Vectorized Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 16392 Batches Removed by Filter: 18 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 879 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -- test IS NULL / IS NOT NULL :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Seq Scan on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: top-N heapsort -> Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) --test var op var :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = v0) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (device_id = v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v1) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v1) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -- test function calls :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: compress_hyper_X_X_chunk.device_id -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on _hyper_X_X_chunk Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on _hyper_X_X_chunk Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < 1) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v0 < device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < device_id) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v0) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v1 = device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (v1 = device_id) --pushdown between two order by column (not pushed down) :PREFIX_NO_ANALYZE SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Vectorized Filter: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: ((compress_hyper_X_X_chunk._ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_X_X_chunk.device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Index Cond: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_X_X_chunk.device_id = 1) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions optimized as well :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < now()) -> Seq Scan on _hyper_X_X_chunk Filter: ("time" < now()) -- test sort optimization interaction :PREFIX_NO_VERBOSE SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk :PREFIX_NO_ANALYZE SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id :PREFIX_NO_VERBOSE SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Seq Scan on _hyper_X_X_chunk -- test aggregate :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Aggregate Output: count(*) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk -- test aggregate with GROUP BY :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (count(*)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> HashAggregate Output: count(*), _hyper_X_X_chunk.device_id Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test window functions with GROUP BY :PREFIX_NO_ANALYZE SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (sum((count(*))) OVER (?)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> WindowAgg Output: sum((count(*))) OVER (?), _hyper_X_X_chunk.device_id -> HashAggregate Output: _hyper_X_X_chunk.device_id, count(*) Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=17990.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=17990.00 loops=1) -> Merge Append (actual rows=17990.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=3598.00 loops=1) Merge Cond: (_hyper_X_X_chunk."time" = _hyper_X_X_chunk_1."time") -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Filter: (device_id = 2) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Materialize (actual rows=3598.00 loops=1) -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Sort Key: test_table."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=2000.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=1598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Index Cond: (_hyper_X_X_chunk.device_id = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=7196.00 loops=1) Output: _hyper_X_X_chunk.device_id -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=3598.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2799.00 loops=2) Output: _hyper_X_X_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=3.00 loops=2) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=799.00 loops=2) Output: _hyper_X_X_chunk.device_id Filter: ("*VALUES*".column1 = _hyper_X_X_chunk.device_id) Rows Removed by Filter: 799 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join (actual rows=7196.00 loops=1) Output: _hyper_X_X_chunk.device_id Hash Cond: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=16392.00 loops=1) Output: _hyper_X_X_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id -> Hash (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Output: _hyper_X_X_chunk.device_id -> Unique Output: "*VALUES*".column1 -> Sort Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) RESET seq_page_cost; -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -> Hash -> Hash Join Hash Cond: (m1."time" = m3."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m3 Filter: (device_id = 3) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m3 Index Cond: (device_id = 3) RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m2."time" = m1."time") -> Merge Append Sort Key: m2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -> Materialize -> Merge Append Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 Filter: (device_id = 1) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 Filter: (device_id = 1) :PREFIX_NO_VERBOSE SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 WHERE m1.v1 = 3 -- additional filter to force m1 as inner relation in join ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 Order: m1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Materialize -> Custom Scan (ChunkAppend) on metrics_space m2 Order: m2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) -- test OUTER JOIN SET min_parallel_table_scan_size TO '0'; -- Disable merge join to get stable tests. These queries uses hash -- joins. SET enable_mergejoin TO off; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Left Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2."time", m2.device_id -> Hash Left Join Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -- test implicit self-join :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -- test self-join with sub-query :PREFIX_NO_VERBOSE SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET enable_mergejoin; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: ("time" = g."time") Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time")) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ("time" = g."time") -- test prepared statement SET plan_cache_mode TO force_generic_plan; PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 DEALLOCATE prep; -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 50 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=29) Index Cond: ((device_id = $1) AND ("time" = g."time")) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ((device_id = $1) AND ("time" = g."time")) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST DEALLOCATE param_prep; RESET plan_cache_mode; -- test hypertable being non-toplevel equivalence member #6925 CREATE TABLE i6925_t1(observed timestamptz not null, queryid int8, total_exec_time int8); CREATE TABLE i6925_t2(LIKE i6925_t1); SELECT table_name FROM create_hypertable('i6925_t1', 'observed'); table_name ------------ i6925_t1 ALTER TABLE i6925_t1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'queryid'); INSERT INTO i6925_t1 SELECT '2020-01-01', 1, 1; SELECT count(compress_chunk(chunk_name)) FROM show_chunks('i6925_t1') chunk_name; count ------- 1 SELECT queryid, lag(total_exec_time) OVER (PARTITION BY queryid) FROM (SELECT * FROM i6925_t1 UNION ALL SELECT * FROM i6925_t2) q; queryid | lag ---------+----- 1 | DROP TABLE i6925_t1; DROP TABLE i6925_t2; ������timescaledb-2.23.0/tsl/test/shared/expected/transparent_decompress_chunk-16.out���������������������0000664�0000000�0000000�00000214772�15100345067�0027652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' \set PREFIX_NO_VERBOSE 'EXPLAIN (buffers off, costs off)' -- Some tweaks to get less flaky test SET parallel_leader_participation TO off; SET min_parallel_table_scan_size TO '0'; SET enable_incremental_sort TO off; SELECT show_chunks('metrics_compressed') AS "TEST_TABLE" ORDER BY 1::text LIMIT 1 \gset -- this should use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=5.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- must not use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM ONLY :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- this should use ColumnarScan node :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk _hyper_X_X_chunk_1 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE ORDER BY time; --- QUERY PLAN --- Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", t AS "RECORD" FROM :TEST_TABLE t WHERE device_id IN (1, 2) ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=7196.00 loops=1) Sort Key: t."time", t.device_id Sort Method: quicksort -> Result (actual rows=7196.00 loops=1) -> Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk t (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _hyper_X_X_chunk t (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=17990.00 loops=1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Append (actual rows=719.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=0.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Vectorized Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 16392 Batches Removed by Filter: 18 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 879 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -- test IS NULL / IS NOT NULL :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Seq Scan on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Sort (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: top-N heapsort -> Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) --test var op var :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = v0) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (device_id = v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v1) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v1) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -- test function calls :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: compress_hyper_X_X_chunk.device_id -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on _hyper_X_X_chunk Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on _hyper_X_X_chunk Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < 1) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v0 < device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < device_id) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v0) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v1 = device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk Filter: (v1 = device_id) --pushdown between two order by column (not pushed down) :PREFIX_NO_ANALYZE SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Vectorized Filter: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: ((compress_hyper_X_X_chunk._ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_X_X_chunk.device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Index Cond: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_X_X_chunk.device_id = 1) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions optimized as well :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < now()) -> Seq Scan on _hyper_X_X_chunk Filter: ("time" < now()) -- test sort optimization interaction :PREFIX_NO_VERBOSE SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk :PREFIX_NO_ANALYZE SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id :PREFIX_NO_VERBOSE SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Seq Scan on _hyper_X_X_chunk -- test aggregate :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Aggregate Output: count(*) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk -- test aggregate with GROUP BY :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (count(*)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> HashAggregate Output: count(*), _hyper_X_X_chunk.device_id Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test window functions with GROUP BY :PREFIX_NO_ANALYZE SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (sum((count(*))) OVER (?)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> WindowAgg Output: sum((count(*))) OVER (?), _hyper_X_X_chunk.device_id -> HashAggregate Output: _hyper_X_X_chunk.device_id, count(*) Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=17990.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=17990.00 loops=1) -> Merge Append (actual rows=17990.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=3598.00 loops=1) Merge Cond: (_hyper_X_X_chunk."time" = _hyper_X_X_chunk_1."time") -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Filter: (device_id = 2) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Materialize (actual rows=3598.00 loops=1) -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Sort Key: test_table."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=2000.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=1598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Index Cond: (_hyper_X_X_chunk.device_id = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=7196.00 loops=1) Output: _hyper_X_X_chunk.device_id -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=3598.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2799.00 loops=2) Output: _hyper_X_X_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=3.00 loops=2) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=799.00 loops=2) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) Rows Removed by Filter: 799 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join (actual rows=7196.00 loops=1) Output: _hyper_X_X_chunk.device_id Hash Cond: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=16392.00 loops=1) Output: _hyper_X_X_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id -> Hash (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Output: _hyper_X_X_chunk.device_id -> Unique Output: "*VALUES*".column1 -> Sort Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) RESET seq_page_cost; -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -> Hash -> Hash Join Hash Cond: (m1."time" = m3."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m3 Filter: (device_id = 3) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m3 Index Cond: (device_id = 3) RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m2."time" = m1."time") -> Merge Append Sort Key: m2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -> Materialize -> Merge Append Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 Filter: (device_id = 1) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 Filter: (device_id = 1) :PREFIX_NO_VERBOSE SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 WHERE m1.v1 = 3 -- additional filter to force m1 as inner relation in join ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 Order: m1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Materialize -> Custom Scan (ChunkAppend) on metrics_space m2 Order: m2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) -- test OUTER JOIN SET min_parallel_table_scan_size TO '0'; -- Disable merge join to get stable tests. These queries uses hash -- joins. SET enable_mergejoin TO off; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Left Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2."time", m2.device_id -> Hash Left Join Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -- test implicit self-join :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -- test self-join with sub-query :PREFIX_NO_VERBOSE SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET enable_mergejoin; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: ("time" = g."time") Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time")) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ("time" = g."time") -- test prepared statement SET plan_cache_mode TO force_generic_plan; PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 DEALLOCATE prep; -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 50 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=29) Index Cond: ((device_id = $1) AND ("time" = g."time")) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ((device_id = $1) AND ("time" = g."time")) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST DEALLOCATE param_prep; RESET plan_cache_mode; -- test hypertable being non-toplevel equivalence member #6925 CREATE TABLE i6925_t1(observed timestamptz not null, queryid int8, total_exec_time int8); CREATE TABLE i6925_t2(LIKE i6925_t1); SELECT table_name FROM create_hypertable('i6925_t1', 'observed'); table_name ------------ i6925_t1 ALTER TABLE i6925_t1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'queryid'); INSERT INTO i6925_t1 SELECT '2020-01-01', 1, 1; SELECT count(compress_chunk(chunk_name)) FROM show_chunks('i6925_t1') chunk_name; count ------- 1 SELECT queryid, lag(total_exec_time) OVER (PARTITION BY queryid) FROM (SELECT * FROM i6925_t1 UNION ALL SELECT * FROM i6925_t2) q; queryid | lag ---------+----- 1 | DROP TABLE i6925_t1; DROP TABLE i6925_t2; ������timescaledb-2.23.0/tsl/test/shared/expected/transparent_decompress_chunk-17.out���������������������0000664�0000000�0000000�00000224532�15100345067�0027646�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' \set PREFIX_NO_VERBOSE 'EXPLAIN (buffers off, costs off)' -- Some tweaks to get less flaky test SET parallel_leader_participation TO off; SET min_parallel_table_scan_size TO '0'; SET enable_incremental_sort TO off; SELECT show_chunks('metrics_compressed') AS "TEST_TABLE" ORDER BY 1::text LIMIT 1 \gset -- this should use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=5.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- must not use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM ONLY :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- this should use ColumnarScan node :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk _hyper_X_X_chunk_1 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE ORDER BY time; --- QUERY PLAN --- Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", t AS "RECORD" FROM :TEST_TABLE t WHERE device_id IN (1, 2) ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=7196.00 loops=1) Sort Key: t."time", t.device_id Sort Method: quicksort -> Result (actual rows=7196.00 loops=1) -> Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk t (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _hyper_X_X_chunk t (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=17990.00 loops=1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 -> Sort (actual rows=2000.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Sort (actual rows=1598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 -> Sort (actual rows=2000.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Sort (actual rows=1598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Append (actual rows=719.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=0.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Vectorized Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 16392 Batches Removed by Filter: 18 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 879 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -- test IS NULL / IS NOT NULL :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 18 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) --test var op var :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = v0) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id = v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v1) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v1) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -- test function calls :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: compress_hyper_X_X_chunk.device_id -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < 1) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v0 < device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < device_id) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v0) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v1 = device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (v1 = device_id) --pushdown between two order by column (not pushed down) :PREFIX_NO_ANALYZE SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Vectorized Filter: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: ((compress_hyper_X_X_chunk._ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_X_X_chunk.device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Index Cond: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_X_X_chunk.device_id = 1) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions optimized as well :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < now()) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ("time" < now()) -- test sort optimization interaction :PREFIX_NO_VERBOSE SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk :PREFIX_NO_ANALYZE SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Merge Append Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id :PREFIX_NO_VERBOSE SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Seq Scan on _hyper_X_X_chunk -- test aggregate :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Aggregate Output: count(*) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk -- test aggregate with GROUP BY :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (count(*)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> HashAggregate Output: count(*), _hyper_X_X_chunk.device_id Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test window functions with GROUP BY :PREFIX_NO_ANALYZE SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (sum((count(*))) OVER (?)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> WindowAgg Output: sum((count(*))) OVER (?), _hyper_X_X_chunk.device_id -> HashAggregate Output: _hyper_X_X_chunk.device_id, count(*) Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=17990.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=17990.00 loops=1) -> Merge Append (actual rows=17990.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=3598.00 loops=1) Merge Cond: (_hyper_X_X_chunk."time" = _hyper_X_X_chunk_1."time") -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Filter: (device_id = 2) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Materialize (actual rows=3598.00 loops=1) -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Sort Key: test_table."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=2000.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=1598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Index Cond: (_hyper_X_X_chunk.device_id = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Nested Loop (actual rows=7196.00 loops=1) Output: _hyper_X_X_chunk.device_id -> Unique (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Sort (actual rows=2.00 loops=1) Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 Sort Method: quicksort -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Append (actual rows=3598.00 loops=2) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2799.00 loops=2) Output: _hyper_X_X_chunk.device_id Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=3.00 loops=2) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=799.00 loops=2) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) Rows Removed by Filter: 799 RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Hash Semi Join (actual rows=7196.00 loops=1) Output: _hyper_X_X_chunk.device_id Hash Cond: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=16392.00 loops=1) Output: _hyper_X_X_chunk.device_id Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id -> Hash (actual rows=2.00 loops=1) Output: "*VALUES*".column1 -> Values Scan on "*VALUES*" (actual rows=2.00 loops=1) Output: "*VALUES*".column1 SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Nested Loop Output: _hyper_X_X_chunk.device_id -> Unique Output: "*VALUES*".column1 -> Sort Output: "*VALUES*".column1 Sort Key: "*VALUES*".column1 -> Values Scan on "*VALUES*" Output: "*VALUES*".column1 -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = "*VALUES*".column1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = "*VALUES*".column1) RESET seq_page_cost; -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -> Hash -> Hash Join Hash Cond: (m1."time" = m3."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m3 Filter: (device_id = 3) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m3 Index Cond: (device_id = 3) RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m2."time" = m1."time") -> Merge Append Sort Key: m2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -> Materialize -> Merge Append Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 Filter: (device_id = 1) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 Filter: (device_id = 1) :PREFIX_NO_VERBOSE SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 WHERE m1.v1 = 3 -- additional filter to force m1 as inner relation in join ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 Order: m1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Materialize -> Custom Scan (ChunkAppend) on metrics_space m2 Order: m2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) -- test OUTER JOIN SET min_parallel_table_scan_size TO '0'; -- Disable merge join to get stable tests. These queries uses hash -- joins. SET enable_mergejoin TO off; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Left Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2."time", m2.device_id -> Hash Left Join Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -- test implicit self-join :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -- test self-join with sub-query :PREFIX_NO_VERBOSE SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET enable_mergejoin; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: ("time" = g."time") Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time")) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ("time" = g."time") -- test prepared statement SET plan_cache_mode TO force_generic_plan; PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 DEALLOCATE prep; -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 50 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=29) Index Cond: ((device_id = $1) AND ("time" = g."time")) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.00 loops=32) -> Append (actual rows=0.00 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.00 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ((device_id = $1) AND ("time" = g."time")) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST DEALLOCATE param_prep; RESET plan_cache_mode; -- test hypertable being non-toplevel equivalence member #6925 CREATE TABLE i6925_t1(observed timestamptz not null, queryid int8, total_exec_time int8); CREATE TABLE i6925_t2(LIKE i6925_t1); SELECT table_name FROM create_hypertable('i6925_t1', 'observed'); table_name ------------ i6925_t1 ALTER TABLE i6925_t1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'queryid'); INSERT INTO i6925_t1 SELECT '2020-01-01', 1, 1; SELECT count(compress_chunk(chunk_name)) FROM show_chunks('i6925_t1') chunk_name; count ------- 1 SELECT queryid, lag(total_exec_time) OVER (PARTITION BY queryid) FROM (SELECT * FROM i6925_t1 UNION ALL SELECT * FROM i6925_t2) q; queryid | lag ---------+----- 1 | DROP TABLE i6925_t1; DROP TABLE i6925_t2; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/expected/transparent_decompress_chunk-18.out���������������������0000664�0000000�0000000�00000222760�15100345067�0027650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' \set PREFIX_NO_VERBOSE 'EXPLAIN (buffers off, costs off)' -- Some tweaks to get less flaky test SET parallel_leader_participation TO off; SET min_parallel_table_scan_size TO '0'; SET enable_incremental_sort TO off; SELECT show_chunks('metrics_compressed') AS "TEST_TABLE" ORDER BY 1::text LIMIT 1 \gset -- this should use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=5.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- must not use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM ONLY :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; --- QUERY PLAN --- Limit (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=5.00 loops=1) Output: "time", device_id, v0, v1, v2, v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- this should use ColumnarScan node :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE; --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk _hyper_X_X_chunk_1 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE ORDER BY time; --- QUERY PLAN --- Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", t AS "RECORD" FROM :TEST_TABLE t WHERE device_id IN (1, 2) ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=7196.00 loops=1) Sort Key: t."time", t.device_id Sort Method: quicksort -> Result (actual rows=7196.00 loops=1) -> Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk t (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _hyper_X_X_chunk t (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; --- QUERY PLAN --- Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; --- QUERY PLAN --- Append (actual rows=0.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id < 0) Rows Removed by Filter: 18 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id < 0) -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; --- QUERY PLAN --- Result (actual rows=17990.00 loops=1) -> Append (actual rows=17990.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 -> Sort (actual rows=2000.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Sort (actual rows=1598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; --- QUERY PLAN --- Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 -> Sort (actual rows=2000.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Sort (actual rows=1598.00 loops=1) Sort Key: _hyper_X_X_chunk.v1 Sort Method: quicksort -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; --- QUERY PLAN --- Sort (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Append (actual rows=719.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=0.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Vectorized Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 16392 Batches Removed by Filter: 18 Bulk Decompression: true -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=18.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=719.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v3 > '10'::double precision) Rows Removed by Filter: 879 -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -- test IS NULL / IS NOT NULL :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id IS NOT NULL) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id IS NOT NULL) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=0.00 loops=1) -> Merge Append (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.00 loops=1) Filter: (device_id IS NULL) Rows Removed by Filter: 18 -> Sort (actual rows=0.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: quicksort -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id IS NULL) -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort (actual rows=5.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: top-N heapsort -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=5598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Sort (actual rows=6.00 loops=1) Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Method: top-N heapsort -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = ANY ('{1,2}'::integer[])) -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) --test var op var :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = v0) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id = v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v1) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v1) -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 3) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 3) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 3) -- test function calls :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = length("substring"(version(), 1, 3))) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: (device_id = length("substring"(version(), 1, 3))) -- -- test segment meta pushdown -- -- order by column and const :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: compress_hyper_X_X_chunk.device_id -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone)) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk Index Cond: ("time" = 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" < 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk Index Cond: ("time" <= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ("time" >= 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ('Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone < "time") --pushdowns between order by and segment by columns :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: (v0 < 1) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < 1) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v0 < device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (v0 < device_id) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (device_id < v0) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (device_id < v0) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (v1 = device_id) -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (v1 = device_id) --pushdown between two order by column (not pushed down) :PREFIX_NO_ANALYZE SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.v0 = _hyper_X_X_chunk.v1) --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=1.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Vectorized Filter: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Reverse: true Bulk Decompression: true -> Sort (actual rows=1.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: ((compress_hyper_X_X_chunk._ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) AND (compress_hyper_X_X_chunk.device_id = 1)) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=10.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Index Cond: (_hyper_X_X_chunk."time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) Filter: (_hyper_X_X_chunk.device_id = 1) --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Seq Scan on compress_hyper_X_X_chunk Filter: ((_ts_meta_max_1 > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: (("time" > 'Fri Dec 31 17:00:00 1999 PST'::timestamp with time zone) OR (device_id = 1)) --functions optimized as well :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk Vectorized Filter: ("time" < now()) -> Seq Scan on compress_hyper_X_X_chunk Filter: (_ts_meta_min_1 < now()) -> Sort Sort Key: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _hyper_X_X_chunk Filter: ("time" < now()) -- test sort optimization interaction :PREFIX_NO_VERBOSE SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Index Only Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk :PREFIX_NO_ANALYZE SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; --- QUERY PLAN --- Limit Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Merge Append Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Sort Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" DESC, _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id :PREFIX_NO_VERBOSE SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; --- QUERY PLAN --- Limit -> Merge Append Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk -> Sort Sort Key: compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC -> Seq Scan on compress_hyper_X_X_chunk -> Sort Sort Key: _hyper_X_X_chunk.device_id, _hyper_X_X_chunk."time" DESC -> Seq Scan on _hyper_X_X_chunk -- test aggregate :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE; --- QUERY PLAN --- Aggregate Output: count(*) -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk -- test aggregate with GROUP BY :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (count(*)), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> HashAggregate Output: count(*), _hyper_X_X_chunk.device_id Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test window functions with GROUP BY :PREFIX_NO_ANALYZE SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; --- QUERY PLAN --- Sort Output: (sum((count(*))) OVER w1), _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk.device_id -> WindowAgg Output: sum((count(*))) OVER w1, _hyper_X_X_chunk.device_id -> HashAggregate Output: _hyper_X_X_chunk.device_id, count(*) Group Key: _hyper_X_X_chunk.device_id -> Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; --- QUERY PLAN --- Sort (actual rows=17990.00 loops=1) Sort Key: q.v1 Sort Method: quicksort -> Subquery Scan on q (actual rows=17990.00 loops=1) -> Merge Append (actual rows=17990.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=16392.00 loops=1) -> Sort (actual rows=18.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=18.00 loops=1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1598.00 loops=1) -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; --- QUERY PLAN --- Merge Join (actual rows=3598.00 loops=1) Merge Cond: (_hyper_X_X_chunk."time" = _hyper_X_X_chunk_1."time") -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=3598.00 loops=1) Filter: (device_id = 2) -> Sort (actual rows=4.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=4.00 loops=1) Filter: (device_id = 2) Rows Removed by Filter: 14 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk (actual rows=0.00 loops=1) Index Cond: (device_id = 2) -> Materialize (actual rows=3598.00 loops=1) -> Merge Append (actual rows=3598.00 loops=1) Sort Key: _hyper_X_X_chunk_1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=2.00 loops=1) Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk _hyper_X_X_chunk_1 (actual rows=1598.00 loops=1) Filter: (device_id = 1) -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Sort Key: _hyper_X_X_chunk."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk."time", _hyper_X_X_chunk.device_id, _hyper_X_X_chunk.v0, _hyper_X_X_chunk.v1, _hyper_X_X_chunk.v2, _hyper_X_X_chunk.v3 Filter: (_hyper_X_X_chunk.device_id = 1) -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; --- QUERY PLAN --- Sort (actual rows=3598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Sort Key: test_table."time" Sort Method: quicksort -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=2000.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) Reverse: true Bulk Decompression: true -> Index Scan Backward using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _timescaledb_internal._hyper_X_X_chunk test_table (actual rows=1598.00 loops=1) Output: test_table.*, test_table.device_id, test_table."time" Filter: (test_table.device_id = 1) -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = 1) :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) Output: count(*) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = 1) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Index Cond: (_hyper_X_X_chunk.device_id = 1) --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=5598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1)); --- QUERY PLAN --- Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=2000.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = 1) --with multiple values can get a semi-join or nested loop depending on seq_page_cost. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Append (actual rows=7196.00 loops=1) -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk (actual rows=5598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) Bulk Decompression: false -> Seq Scan on _timescaledb_internal.compress_hyper_X_X_chunk (actual rows=6.00 loops=1) Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Filter: (compress_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) Rows Removed by Filter: 12 -> Seq Scan on _timescaledb_internal._hyper_X_X_chunk (actual rows=1598.00 loops=1) Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); --- QUERY PLAN --- Append -> Custom Scan (ColumnarScan) on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id Filter: (_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) -> Index Scan using compress_hyper_X_X_chunk_device_id__ts_meta_min_1__ts_meta_idx on _timescaledb_internal.compress_hyper_X_X_chunk Output: compress_hyper_X_X_chunk._ts_meta_count, compress_hyper_X_X_chunk.device_id, compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1, compress_hyper_X_X_chunk."time", compress_hyper_X_X_chunk.v0, compress_hyper_X_X_chunk.v1, compress_hyper_X_X_chunk.v2, compress_hyper_X_X_chunk.v3 Index Cond: (compress_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _timescaledb_internal._hyper_X_X_chunk Output: _hyper_X_X_chunk.device_id Index Cond: (_hyper_X_X_chunk.device_id = ANY ('{1,2}'::integer[])) RESET seq_page_cost; -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; --- QUERY PLAN --- Limit (actual rows=10.00 loops=1) -> Merge Append (actual rows=10.00 loops=1) Sort Key: _hyper_X_X_chunk."time" DESC -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=10.00 loops=1) Filter: (device_id = 1) -> Sort (actual rows=1.00 loops=1) Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1 DESC, compress_hyper_X_X_chunk._ts_meta_max_1 DESC Sort Method: quicksort -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Index Scan Backward using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk (actual rows=1.00 loops=1) Filter: (device_id = 1) DROP VIEW compressed_view; -- test INNER JOIN :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Join Hash Cond: ((m2."time" = m1."time") AND (m2.device_id = m1.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -> Hash -> Hash Join Hash Cond: (m1."time" = m3."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m3 Filter: (device_id = 3) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_2 Filter: (device_id = 3) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m3 Index Cond: (device_id = 3) RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m2."time" = m1."time") -> Merge Append Sort Key: m2."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Sort Sort Key: compress_hyper_X_X_chunk_1._ts_meta_min_1, compress_hyper_X_X_chunk_1._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -> Materialize -> Merge Append Sort Key: m1."time" -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 Filter: (device_id = 1) -> Sort Sort Key: compress_hyper_X_X_chunk._ts_meta_min_1, compress_hyper_X_X_chunk._ts_meta_max_1 -> Seq Scan on compress_hyper_X_X_chunk Filter: (device_id = 1) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 Filter: (device_id = 1) :PREFIX_NO_VERBOSE SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 WHERE m1.v1 = 3 -- additional filter to force m1 as inner relation in join ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Merge Join Merge Cond: (m1."time" = m2."time") -> Custom Scan (ChunkAppend) on metrics m1 Order: m1."time" -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_1 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_2 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Index Scan Backward using _hyper_X_X_chunk_metrics_device_id_time_idx on _hyper_X_X_chunk m1_3 Index Cond: (device_id = 1) Filter: (v1 = 3) -> Materialize -> Custom Scan (ChunkAppend) on metrics_space m2 Order: m2."time" -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_1 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_2 Index Cond: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_space_device_id_time_idx on _hyper_X_X_chunk m2_3 Index Cond: (device_id = 2) -- test OUTER JOIN SET min_parallel_table_scan_size TO '0'; -- Disable merge join to get stable tests. These queries uses hash -- joins. SET enable_mergejoin TO off; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id -> Hash Left Join Hash Cond: ((m1."time" = m2."time") AND (m1.device_id = m2.device_id)) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2."time", m2.device_id -> Hash Left Join Hash Cond: (m1."time" = m2."time") Join Filter: (m1.device_id = 1) -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 Filter: (device_id = 2) -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 Filter: (device_id = 2) -> Index Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m2 Index Cond: (device_id = 2) -- test implicit self-join :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 -- test self-join with sub-query :PREFIX_NO_VERBOSE SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; --- QUERY PLAN --- Limit -> Sort Sort Key: m1."time", m1.device_id, m2.device_id -> Hash Join Hash Cond: (m1."time" = m2."time") -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 -> Seq Scan on compress_hyper_X_X_chunk -> Seq Scan on _hyper_X_X_chunk m1 -> Hash -> Append -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m2 -> Seq Scan on compress_hyper_X_X_chunk compress_hyper_X_X_chunk_1 -> Seq Scan on _hyper_X_X_chunk m2 RESET enable_mergejoin; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.16 loops=32) -> Append (actual rows=0.16 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.16 loops=32) Filter: ("time" = g."time") Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.16 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time")) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ("time" = g."time") -- test prepared statement SET plan_cache_mode TO force_generic_plan; PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; --- QUERY PLAN --- Aggregate (actual rows=1.00 loops=1) -> Append (actual rows=3598.00 loops=1) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk (actual rows=2000.00 loops=1) Filter: (device_id = 1) -> Seq Scan on compress_hyper_X_X_chunk (actual rows=2.00 loops=1) Filter: (device_id = 1) Rows Removed by Filter: 16 -> Seq Scan on _hyper_X_X_chunk (actual rows=1598.00 loops=1) Filter: (device_id = 1) EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 EXECUTE prep; count ------- 3598 DEALLOCATE prep; -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.16 loops=32) -> Append (actual rows=0.16 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.09 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 50 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.09 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.07 loops=29) Index Cond: ((device_id = $1) AND ("time" = g."time")) :PREFIX EXECUTE param_prep (2); --- QUERY PLAN --- Nested Loop (actual rows=5.00 loops=1) -> Function Scan on generate_series g (actual rows=32.00 loops=1) -> Limit (actual rows=0.16 loops=32) -> Append (actual rows=0.16 loops=32) -> Custom Scan (ColumnarScan) on _hyper_X_X_chunk m1 (actual rows=0.16 loops=32) Filter: (("time" = g."time") AND (device_id = $1)) Rows Removed by Filter: 81 -> Seq Scan on compress_hyper_X_X_chunk (actual rows=0.16 loops=32) Filter: ((_ts_meta_min_1 <= g."time") AND (_ts_meta_max_1 >= g."time") AND (device_id = $1)) Rows Removed by Filter: 16 -> Index Only Scan using _hyper_X_X_chunk_metrics_compressed_device_id_time_idx on _hyper_X_X_chunk m1 (actual rows=0.00 loops=27) Index Cond: ((device_id = $1) AND ("time" = g."time")) EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (2); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST EXECUTE param_prep (1); time | time ------------------------------+------------------------------ Sat Jan 01 00:00:00 2000 PST | Sat Jan 01 00:00:00 2000 PST Sun Jan 02 00:00:00 2000 PST | Sun Jan 02 00:00:00 2000 PST Mon Jan 03 00:00:00 2000 PST | Mon Jan 03 00:00:00 2000 PST Tue Jan 04 00:00:00 2000 PST | Tue Jan 04 00:00:00 2000 PST Wed Jan 05 00:00:00 2000 PST | Wed Jan 05 00:00:00 2000 PST DEALLOCATE param_prep; RESET plan_cache_mode; -- test hypertable being non-toplevel equivalence member #6925 CREATE TABLE i6925_t1(observed timestamptz not null, queryid int8, total_exec_time int8); CREATE TABLE i6925_t2(LIKE i6925_t1); SELECT table_name FROM create_hypertable('i6925_t1', 'observed'); table_name ------------ i6925_t1 ALTER TABLE i6925_t1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'queryid'); INSERT INTO i6925_t1 SELECT '2020-01-01', 1, 1; SELECT count(compress_chunk(chunk_name)) FROM show_chunks('i6925_t1') chunk_name; count ------- 1 SELECT queryid, lag(total_exec_time) OVER (PARTITION BY queryid) FROM (SELECT * FROM i6925_t1 UNION ALL SELECT * FROM i6925_t2) q; queryid | lag ---------+----- 1 | DROP TABLE i6925_t1; DROP TABLE i6925_t2; ����������������timescaledb-2.23.0/tsl/test/shared/expected/with_clause_parser.out����������������������������������0000664�0000000�0000000�00000046653�15100345067�0025335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- We have support for a dedicated type whos only purpose is to -- generate error. You pass in the error code you want and it will be -- raised from inside the input function. SET client_min_messages TO WARNING; CREATE TYPE sqlstate_raise; CREATE FUNCTION ts_sqlstate_raise_in(cstring) RETURNS sqlstate_raise AS :MODULE_PATHNAME LANGUAGE C STABLE STRICT; CREATE FUNCTION ts_sqlstate_raise_out(sqlstate_raise) RETURNS cstring AS :MODULE_PATHNAME LANGUAGE C STABLE STRICT; CREATE TYPE sqlstate_raise ( input = ts_sqlstate_raise_in, output = ts_sqlstate_raise_out ); SET client_min_messages TO DEFAULT; CREATE OR REPLACE FUNCTION test_with_clause_filter(with_clauses TEXT[][]) RETURNS TABLE(namespace TEXT, name TEXT, value TEXT, filtered BOOLEAN) AS :MODULE_PATHNAME, 'ts_test_with_clause_filter' LANGUAGE C VOLATILE STRICT; CREATE OR REPLACE FUNCTION test_with_clause_parse(with_clauses TEXT[][]) RETURNS TABLE(name TEXT, unimpl INT8, bool BOOLEAN, int32 INT4, def INT4, name_arg NAME, regc REGCLASS) AS :MODULE_PATHNAME, 'ts_test_with_clause_parse' LANGUAGE C VOLATILE STRICT; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM test_with_clause_filter( '{ {"baz", "bar", "foo"}, {"timescaledb", "bar", "baz"}, {"bar", "timescaledb", "baz"}, {"timescaledb", "baz", "bar"}, {"tsdb", "qux", "bar"}, {"tsdb", "quux", "bar"} }'); namespace | name | value | filtered -------------+-------------+-------+---------- timescaledb | bar | baz | t timescaledb | baz | bar | t tsdb | qux | bar | t tsdb | quux | bar | t baz | bar | foo | f bar | timescaledb | baz | f SELECT * FROM test_with_clause_filter( '{ {"baz", "bar", "foo"}, {"bar", "timescaledb", "baz"}, {"bar", "timescaledb", "baz"} }'); namespace | name | value | filtered -----------+-------------+-------+---------- baz | bar | foo | f bar | timescaledb | baz | f bar | timescaledb | baz | f SELECT * FROM test_with_clause_filter( '{ {"bar", "timescaledb"}, {"baz", "bar"}, {"timescaledb", "bar"}, {"timescaledb", "baz"} }'); namespace | name | value | filtered -------------+-------------+-------+---------- timescaledb | bar | | t timescaledb | baz | | t bar | timescaledb | | f baz | bar | | f SELECT * FROM test_with_clause_filter( '{ {"timescaledb"}, {"bar"}, {"baz"} }'); namespace | name | value | filtered -----------+-------------+-------+---------- | timescaledb | | f | bar | | f | baz | | f \set ON_ERROR_STOP 0 -- unrecognized argument SELECT * FROM test_with_clause_parse('{{"timescaledb", "fakearg", "bar"}}'); ERROR: unrecognized parameter "timescaledb.fakearg" SELECT * FROM test_with_clause_parse('{{"timescaledb", "fakearg"}}'); ERROR: unrecognized parameter "timescaledb.fakearg" -- unimplemented handled gracefully SELECT * FROM test_with_clause_parse('{{"timescaledb", "unimplemented", "bar"}}'); ERROR: argument "timescaledb.unimplemented" not implemented SELECT * FROM test_with_clause_parse('{{"timescaledb", "unimplemented", "true"}}'); ERROR: argument "timescaledb.unimplemented" not implemented SELECT * FROM test_with_clause_parse('{{"timescaledb", "unimplemented"}}'); ERROR: argument "timescaledb.unimplemented" not implemented \set ON_ERROR_STOP 1 -- bool parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "true"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | t | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "false"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | f | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "on"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | t | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "off"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | f | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "1"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | t | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "0"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | f | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | t | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | -- int32 parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "1"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | 1 | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "572"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | 572 | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "-10"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | -10 | | | default | | | | -100 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "true"}}'); ERROR: invalid value for timescaledb.int32 'true' SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "bar"}}'); ERROR: invalid value for timescaledb.int32 'bar' SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32"}}'); ERROR: parameter "timescaledb.int32" must have a value \set ON_ERROR_STOP 1 -- name parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "1"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | 1 | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "572"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | 572 | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "-10"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | -10 | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "true"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | true | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "bar"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | bar | regclass | | | | | | sqlstate_raise | | | | | | \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "name"}}'); ERROR: parameter "timescaledb.name" must have a value \set ON_ERROR_STOP 1 -- REGCLASS parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "pg_type"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+--------- unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | pg_type sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "1"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -100 | | name | | | | | | regclass | | | | | | 1 sqlstate_raise | | | | | | \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "-10"}}'); ERROR: invalid value for timescaledb.regclass '-10' SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "true"}}'); ERROR: invalid value for timescaledb.regclass 'true' SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "bar"}}'); ERROR: invalid value for timescaledb.regclass 'bar' SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass"}}'); ERROR: parameter "timescaledb.regclass" must have a value \set ON_ERROR_STOP 1 -- Test errors generated from inside the input function \set ON_ERROR_STOP 0 -- Out of memory, "hard" error. SELECT * FROM test_with_clause_parse('{{"timescaledb", "sqlstate_raise", "53200"}}'); ERROR: raised requested error code "53200" -- Division by zero, "soft" error. Shows invalid value message (with a -- strange message in this case). SELECT * FROM test_with_clause_parse('{{"timescaledb", "sqlstate_raise", "22012"}}'); ERROR: invalid value for timescaledb.sqlstate_raise '22012' \set ON_ERROR_STOP 1 -- defaults get overridden SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "1"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+-----+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | 1 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "572"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+-----+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | 572 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "-10"}}'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+-----+----------+------ unimplemented | | | | | | bool | | | | | | int32 | | | | | | default | | | | -10 | | name | | | | | | regclass | | | | | | sqlstate_raise | | | | | | \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "true"}}'); ERROR: invalid value for timescaledb.default 'true' SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "bar"}}'); ERROR: invalid value for timescaledb.default 'bar' SELECT * FROM test_with_clause_parse('{{"timescaledb", "default"}}'); ERROR: parameter "timescaledb.default" must have a value \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 -- duplicates error SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "1"}, {"timescaledb", "name", "572"}}'); ERROR: duplicate parameter "timescaledb.name" \set ON_ERROR_STOP 1 -- multiple args SELECT * FROM test_with_clause_parse('{ {"a", "bool", "true"}, {"b", "int32", "572"}, {"c", "name", "bar"}, {"d", "regclass", "pg_type"} }'); name | unimpl | bool | int32 | def | name_arg | regc ----------------+--------+------+-------+------+----------+--------- unimplemented | | | | | | bool | | t | | | | int32 | | | 572 | | | default | | | | -100 | | name | | | | | bar | regclass | | | | | | pg_type sqlstate_raise | | | | | | \c :TEST_DBNAME :ROLE_SUPERUSER DROP TYPE sqlstate_raise CASCADE; NOTICE: drop cascades to 2 other objects �������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/�������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017701�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/.gitignore���������������������������������������������������0000664�0000000�0000000�00000000403�15100345067�0021666�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/continuous_aggs_compression-*.sql /gapfill-*.sql /ordered_append_join-*.sql /remote-copy-escapes.*sv /transparent_decompress_chunk-*.sql /constify_now-*.sql /constify_timestamptz_op_interval-*.sql /constraint_exclusion_prepared-*.sql /space_constraint-*.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/CMakeLists.txt�����������������������������������������������0000664�0000000�0000000�00000005531�15100345067�0022445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(TEST_FILES_SHARED cagg_compression.sql chunkwise_agg_gather_sort.sql classify_relation.sql compat.sql compress_bloom_sparse_compat.sql compress_unique_index.sql compression_dml.sql compression_nulls_not_distinct.sql constraint_aware_append.sql decompress_join.sql decompress_placeholdervar.sql decompress_tracking.sql gapfill_bug.sql generated_columns.sql memoize.sql security_barrier.sql subtract_integer_from_now.sql) set(TEST_TEMPLATES_SHARED gapfill.sql.in ordered_append_join.sql.in constify_timestamptz_op_interval.sql.in constraint_exclusion_prepared.sql.in space_constraint.sql.in transparent_decompress_chunk.sql.in) set(SOLO_TESTS merge_dml.sql) if(CMAKE_BUILD_TYPE MATCHES Debug) list(APPEND TEST_FILES_SHARED extension.sql timestamp_limits.sql with_clause_parser.sql) list(APPEND TEST_TEMPLATES_SHARED constify_now.sql.in) endif(CMAKE_BUILD_TYPE MATCHES Debug) # Regression tests that vary with PostgreSQL version. Generated test files are # put in the original source directory since all tests must be in the same # directory. These files are updated when the template is edited, but not when # the output file is deleted. If the output is deleted either recreate it # manually, or rerun cmake on the root dir. foreach(TEMPLATE_FILE ${TEST_TEMPLATES_SHARED}) string(LENGTH ${TEMPLATE_FILE} TEMPLATE_NAME_LEN) math(EXPR TEMPLATE_NAME_LEN ${TEMPLATE_NAME_LEN}-7) string(SUBSTRING ${TEMPLATE_FILE} 0 ${TEMPLATE_NAME_LEN} TEMPLATE) set(TEST_FILE ${TEMPLATE}-${TEST_VERSION_SUFFIX}.sql) configure_file(${TEMPLATE_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/${TEST_FILE} COPYONLY) list(APPEND TEST_FILES_SHARED ${TEST_FILE}) endforeach(TEMPLATE_FILE) if(DEFINED GIT_FOUND) list(APPEND TEST_FILES_SHARED build_info.sql) endif() if(TEST_FILES_SHARED) list(SORT TEST_FILES_SHARED) endif() file(REMOVE ${TEST_SCHEDULE_SHARED}) if(NOT TEST_GROUP_SIZE) set(PARALLEL_GROUP_SIZE 20) else() set(PARALLEL_GROUP_SIZE ${TEST_GROUP_SIZE}) endif() set(GROUP_MEMBERS 0) foreach(TEST_FILE ${TEST_FILES_SHARED}) string(REGEX REPLACE "(.+)\.sql" "\\1" TESTS_TO_RUN ${TEST_FILE}) if(GROUP_MEMBERS EQUAL 0) file(APPEND ${TEST_SCHEDULE_SHARED} "\ntest: ") endif() file(APPEND ${TEST_SCHEDULE_SHARED} "${TESTS_TO_RUN} ") math(EXPR GROUP_MEMBERS "(${GROUP_MEMBERS}+1)%${PARALLEL_GROUP_SIZE}") endforeach(TEST_FILE) file(APPEND ${TEST_SCHEDULE_SHARED} "\n") set(GROUP_MEMBERS 0) foreach(TEST_FILE ${SOLO_TESTS}) string(REGEX REPLACE "(.+)\.sql" "\\1" TESTS_TO_RUN ${TEST_FILE}) if(GROUP_MEMBERS EQUAL 0) file(APPEND ${TEST_SCHEDULE_SHARED} "\ntest: ") endif() file(APPEND ${TEST_SCHEDULE_SHARED} "${TESTS_TO_RUN} ") math(EXPR GROUP_MEMBERS "(${GROUP_MEMBERS}+1)%${PARALLEL_GROUP_SIZE}") endforeach(TEST_FILE) file(APPEND ${TEST_SCHEDULE_SHARED} "\n") �����������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/build_info.sql�����������������������������������������������0000664�0000000�0000000�00000001076�15100345067�0022540�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Check what get_git_commit returns SELECT pg_typeof(commit_tag) AS commit_tag_type, pg_typeof(commit_hash) AS commit_hash_type, length(commit_hash) AS commit_hash_length, pg_typeof(commit_time) AS commit_time_type FROM _timescaledb_functions.get_git_commit(); SELECT extname, obj_description(oid, 'pg_extension') FROM pg_extension WHERE extname = 'timescaledb'; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/cagg_compression.sql�����������������������������������������0000664�0000000�0000000�00000007040�15100345067�0023745�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; SELECT format('include/%s_setup.sql', :'TEST_BASE_NAME') as "TEST_SETUP_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_source.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_SOURCE", format('%s/shared/results/%s_results_target.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TARGET" \gset SELECT format('\! diff -u --label "Source results" --label "Target results" %s %s', :'TEST_RESULTS_SOURCE', :'TEST_RESULTS_TARGET') as "DIFF_CMD" \gset -- Setup \ir :TEST_SETUP_NAME \o :TEST_RESULTS_SOURCE \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_TARGET \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME \o -- Compare results of CAgg over Compressed and Uncompressed hypertables :DIFF_CMD \o :TEST_RESULTS_SOURCE \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_TARGET \set TEST_TABLE1 '(SELECT device_id, time_bucket(INTERVAL $$1 week$$, time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics_compressed GROUP BY device_id, bucket)' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME \set TEST_TABLE1 '(SELECT device_id, time_bucket(INTERVAL $$1 week$$, time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics_compressed GROUP BY device_id, bucket)' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME \o -- Compare results between CAggs and Original View (to check PG and TSDB machinery) :DIFF_CMD -- Decompres 1 chunk from cagg SELECT CASE WHEN res is NULL THEN NULL ELSE 'decompress' END as dec FROM ( SELECT decompress_chunk(ch) res FROM show_chunks('metrics_compressed_summary') ch ORDER BY ch LIMIT 1) q; -- Run tests and compare results \o :TEST_RESULTS_SOURCE \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME \set TEST_TABLE1 'metrics_compressed_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME \o \o :TEST_RESULTS_TARGET \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'devices' \ir :TEST_QUERY_NAME \set TEST_TABLE1 'metrics_summary' \set TEST_TABLE2 'all_devices' \ir :TEST_QUERY_NAME \o -- Compare results of CAgg (partial compressed) over Compressed hypertables :DIFF_CMD -- Teardown DROP MATERIALIZED VIEW metrics_compressed_summary; DROP MATERIALIZED VIEW metrics_summary; DROP VIEW all_devices; DROP TABLE extra_devices; -- test enabling compression on cagg after column rename CREATE TABLE comp_rename(time timestamptz); SELECT table_name FROM create_hypertable('comp_rename', 'time'); CREATE MATERIALIZED VIEW comp_rename_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 week', time) AS bucket FROM comp_rename GROUP BY 1; ALTER MATERIALIZED VIEW comp_rename_cagg RENAME COLUMN bucket to "time"; SET client_min_messages TO WARNING; ALTER MATERIALIZED VIEW comp_rename_cagg SET ( timescaledb.compress='true'); RESET client_min_messages; DROP TABLE comp_rename CASCADE; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/chunkwise_agg_gather_sort.sql��������������������������������0000664�0000000�0000000�00000001364�15100345067�0025645�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Exercise the GatherMerge -> Sort -> Append -> Partial Aggregate plan. \set prefix 'explain (buffers off, costs off, timing off, summary off)' set parallel_setup_cost = 0; set parallel_tuple_cost = 0; set max_parallel_workers_per_gather = 2; set parallel_leader_participation = off; set enable_hashagg to off; :prefix select count(*) from metrics group by v0; reset enable_hashagg; :prefix select count(*) from metrics group by v0; reset parallel_setup_cost; reset parallel_tuple_cost; reset max_parallel_workers_per_gather; reset parallel_leader_participation; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/classify_relation.sql����������������������������������������0000664�0000000�0000000�00000000657�15100345067�0024144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test the case where the chunk is present both as a separate table and as a -- child of a hypertable. #4708 select show_chunks('metrics_compressed') chunk order by 1 limit 1 \gset select * from metrics_compressed inner join :chunk on (false); ���������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/compat.sql���������������������������������������������������0000664�0000000�0000000�00000012554�15100345067�0021714�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; \set ON_ERROR_STOP 0 SELECT _timescaledb_internal.alter_job_set_hypertable_id(0,0); SELECT _timescaledb_internal.attach_osm_table_chunk(0,0); SELECT _timescaledb_internal.cagg_migrate_plan_exists(0); SELECT _timescaledb_internal.cagg_migrate_pre_validation(NULL,NULL,NULL); SELECT _timescaledb_internal.cagg_watermark(0); SELECT _timescaledb_internal.cagg_watermark_materialized(0); SELECT _timescaledb_internal.calculate_chunk_interval(0,0,0); SELECT _timescaledb_internal.chunk_constraint_add_table_constraint(NULL); SELECT _timescaledb_internal.chunk_id_from_relid(0); SELECT _timescaledb_internal.chunk_status(0); SELECT _timescaledb_internal.chunks_local_size(NULL,NULL); SELECT _timescaledb_internal.compressed_chunk_local_stats(NULL,NULL); SELECT _timescaledb_internal.create_chunk(0,NULL,NULL,NULL,0); SELECT _timescaledb_internal.create_chunk_table(0,NULL,NULL,NULL); SELECT _timescaledb_internal.create_compressed_chunk(0,0,0,0,0,0,0,0,0,0); SELECT _timescaledb_internal.drop_chunk(0); SELECT _timescaledb_internal.freeze_chunk(0); SELECT FROM _timescaledb_internal.generate_uuid(); SELECT _timescaledb_internal.get_approx_row_count(0); SELECT _timescaledb_internal.get_compressed_chunk_index_for_recompression(0); SELECT _timescaledb_internal.get_create_command(NULL); SELECT pg_typeof(_timescaledb_internal.get_git_commit()); SELECT pg_typeof(_timescaledb_internal.get_os_info()); SELECT _timescaledb_internal.get_partition_for_key(NULL::text); SELECT _timescaledb_internal.get_partition_hash(NULL::text); SELECT _timescaledb_internal.hypertable_local_size(NULL,NULL); SELECT _timescaledb_internal.interval_to_usec(NULL); SELECT _timescaledb_internal.partialize_agg(NULL::text); SELECT _timescaledb_internal.policy_compression_check(NULL); SELECT _timescaledb_internal.policy_job_stat_history_retention(0,NULL); SELECT _timescaledb_internal.policy_job_stat_history_retention_check(NULL); SELECT _timescaledb_internal.policy_refresh_continuous_aggregate_check(NULL); SELECT _timescaledb_internal.policy_reorder_check(NULL); SELECT _timescaledb_internal.policy_retention_check(NULL); SELECT _timescaledb_internal.range_value_to_pretty(0,0); SELECT _timescaledb_internal.recompress_chunk_segmentwise(0,true); SELECT _timescaledb_internal.relation_size(0); SELECT _timescaledb_internal.restart_background_workers(); SELECT _timescaledb_internal.show_chunk(0); SELECT _timescaledb_internal.start_background_workers(); SELECT _timescaledb_internal.stop_background_workers(); SELECT _timescaledb_internal.subtract_integer_from_now(0,0); SELECT _timescaledb_internal.time_to_internal(NULL::timestamptz); SELECT _timescaledb_internal.to_date(0); SELECT _timescaledb_internal.to_interval(0); SELECT _timescaledb_internal.to_timestamp(0); SELECT _timescaledb_internal.to_timestamp_without_timezone(0); SELECT _timescaledb_internal.to_unix_microseconds(NULL); SELECT _timescaledb_internal.tsl_loaded(); SELECT _timescaledb_internal.unfreeze_chunk(0); CALL _timescaledb_internal.cagg_migrate_create_plan(NULL,NULL,true,true); CALL _timescaledb_internal.cagg_migrate_execute_copy_data(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_copy_policies(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_create_new_cagg(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_disable_policies(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_drop_old_cagg(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_enable_policies(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_override_cagg(NULL,NULL); CALL _timescaledb_internal.cagg_migrate_execute_plan(NULL); CALL _timescaledb_internal.cagg_migrate_execute_refresh_new_cagg(NULL,NULL); CALL _timescaledb_internal.policy_compression(0,NULL); CALL _timescaledb_internal.policy_recompression(0,NULL); CALL _timescaledb_internal.policy_refresh_continuous_aggregate(0,NULL); CALL _timescaledb_internal.policy_reorder(0,NULL); CALL _timescaledb_internal.policy_retention(0,NULL); CALL public.recompress_chunk(0); \set ON_ERROR_STOP 1 -- tests for the cagg invalidation trigger on the deprecated schema CREATE TABLE sensor_data ( time TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT hypertable_id FROM create_hypertable('sensor_data','time') \gset CREATE MATERIALIZED VIEW sensor_data_hourly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 hour', time), min(time), max(time) FROM sensor_data GROUP BY 1 WITH DATA; INSERT INTO sensor_data values('1980-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('sensor_data_hourly', NULL, NULL); -- should not return rows because there's old invalid regions SELECT lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :'hypertable_id'; -- insert old data to create invalidation log INSERT INTO sensor_data values('1979-12-31 00:00:00-00', 1); -- should return the invalidation log generated by previous insert SELECT lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :'hypertable_id'; DROP MATERIALIZED VIEW sensor_data_hourly; DROP TABLE sensor_data CASCADE; ����������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/compress_bloom_sparse_compat.sql�����������������������������0000664�0000000�0000000�00000000770�15100345067�0026371�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test binary compatibility. The hash values might change if the UMASH custom -- hashing is not built on this platform, we had this problem before. select _timescaledb_functions.bloom1_contains( '\xd098c885f08468eb8916751d947f248ed2843a88c02b1dea6228591c588b8068'::_timescaledb_internal.bloom1, '1y.yield'::text) ; ��������timescaledb-2.23.0/tsl/test/shared/sql/compress_unique_index.sql������������������������������������0000664�0000000�0000000�00000002771�15100345067�0025041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test unique expression indexes CREATE TABLE compress_unique(offset_timestamp timestamptz not null, meter_id text, meter_channel_id text, timestamp timestamptz); SELECT table_name FROM create_hypertable('compress_unique','offset_timestamp'); CREATE UNIQUE INDEX uniq_expr ON compress_unique USING btree (lower((meter_id)::text), meter_channel_id, offset_timestamp, "timestamp"); ALTER TABLE compress_unique SET (timescaledb.compress,timescaledb.compress_segmentby='meter_id,meter_channel_id', timescaledb.compress_orderby='offset_timestamp desc'); INSERT INTO compress_unique VALUES ('2000-01-01','m1','c1','2000-01-01'); INSERT INTO compress_unique VALUES ('2000-01-01','m1','c2','2000-01-01'); SELECT compress_chunk(show_chunks('compress_unique')) IS NOT NULL AS compress; -- should fail \set ON_ERROR_STOP 0 INSERT INTO compress_unique VALUES ('2000-01-01','m1','c2','2000-01-01'); \set ON_ERROR_STOP 1 -- should only decompress 1 batch EXPLAIN (analyze,buffers off, costs off,summary off,timing off) INSERT INTO compress_unique VALUES ('2000-01-01','m1','c2','2000-01-02'); -- should decompress no batches EXPLAIN (analyze,buffers off, costs off,summary off,timing off) INSERT INTO compress_unique VALUES ('2000-01-01','m1','c3','2000-01-02'); SELECT * FROM compress_unique ORDER BY compress_unique; DROP TABLE compress_unique; �������timescaledb-2.23.0/tsl/test/shared/sql/compression_dml.sql������������������������������������������0000664�0000000�0000000�00000036361�15100345067�0023630�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ANALYZE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' -- test constraint exclusion with prepared statements and generic plans CREATE TABLE i3719 (time timestamptz NOT NULL,data text); SELECT table_name FROM create_hypertable('i3719', 'time'); ALTER TABLE i3719 SET (timescaledb.compress); INSERT INTO i3719 VALUES('2021-01-01 00:00:00', 'chunk 1'); SELECT count(compress_chunk(c)) FROM show_chunks('i3719') c; INSERT INTO i3719 VALUES('2021-02-22 08:00:00', 'chunk 2'); SET plan_cache_mode TO force_generic_plan; PREPARE p1(timestamptz) AS UPDATE i3719 SET data = 'x' WHERE time=$1; PREPARE p2(timestamptz) AS DELETE FROM i3719 WHERE time=$1; EXECUTE p1('2021-02-22T08:00:00+00'); EXECUTE p2('2021-02-22T08:00:00+00'); DEALLOCATE p1; DEALLOCATE p2; DROP TABLE i3719; -- github issue 4778 CREATE TABLE metric_5m ( time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL ); SELECT table_name FROM create_hypertable( 'metric_5m'::regclass, 'time'::name, chunk_time_interval=>interval '5m', create_default_indexes=> false); -- enable compression ALTER TABLE metric_5m SET ( timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time, value' ); SET work_mem TO '64kB'; SELECT '2022-10-10 14:33:44.1234+05:30' as start_date \gset -- populate hypertable INSERT INTO metric_5m (time, series_id, value) SELECT t, s,1 from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '10s') t cross join generate_series(1,10, 1) s; -- manually compress all chunks SELECT count(compress_chunk(c)) FROM show_chunks('metric_5m') c; -- populate into compressed hypertable, this should not crash INSERT INTO metric_5m (time, series_id, value) SELECT t, s,1 from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '10s') t cross join generate_series(1,10, 1) s; -- clean up RESET work_mem; DROP TABLE metric_5m; -- github issue 5134 CREATE TABLE mytab (time TIMESTAMPTZ NOT NULL, a INT, b INT, c INT); SELECT table_name FROM create_hypertable('mytab', 'time', chunk_time_interval => interval '1 day'); INSERT INTO mytab SELECT time, CASE WHEN (:'start_date'::timestamptz - time < interval '1 days') THEN 1 WHEN (:'start_date'::timestamptz - time < interval '2 days') THEN 2 WHEN (:'start_date'::timestamptz - time < interval '3 days') THEN 3 ELSE 4 END as a from generate_series(:'start_date'::timestamptz - interval '3 days', :'start_date'::timestamptz, interval '5 sec') as g1(time); -- enable compression ALTER TABLE mytab SET ( timescaledb.compress, timescaledb.compress_segmentby = 'a, c' ); -- get first chunk name SELECT chunk_schema || '.' || chunk_name as "chunk_table" FROM timescaledb_information.chunks WHERE hypertable_name = 'mytab' ORDER BY range_start limit 1 \gset -- compress only the first chunk SELECT count(compress_chunk(:'chunk_table')); -- insert a row into first compressed chunk INSERT INTO mytab SELECT '2022-10-07 05:30:10+05:30'::timestamp with time zone, 3, 3; -- should not crash EXPLAIN (buffers off, costs off) SELECT * FROM :chunk_table; DROP TABLE mytab CASCADE; -- test varchar segmentby CREATE TABLE comp_seg_varchar ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar NOT NULL, data jsonb ); SELECT table_name FROM create_hypertable('comp_seg_varchar', 'time'); CREATE UNIQUE INDEX ON comp_seg_varchar(source_id, label, "time" DESC); ALTER TABLE comp_seg_varchar SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO comp_seg_varchar SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT count(compress_chunk(c)) FROM show_chunks('comp_seg_varchar') c; -- all tuples should come from compressed chunks EXPLAIN (analyze,buffers off, costs off, timing off, summary off) SELECT * FROM comp_seg_varchar; INSERT INTO comp_seg_varchar(time, source_id, label, data) VALUES ('1990-01-02 00:00:00+00', 'test', 'test', '{}'::jsonb) ON CONFLICT (source_id, label, time) DO UPDATE SET data = '{"update": true}'; -- no tuples should be moved into uncompressed EXPLAIN (analyze,buffers off, costs off, timing off, summary off) SELECT * FROM comp_seg_varchar; INSERT INTO comp_seg_varchar(time, source_id, label, data) VALUES ('1990-01-02 00:00:00+00', '1', '2', '{}'::jsonb) ON CONFLICT (source_id, label, time) DO UPDATE SET data = '{"update": true}'; -- 1 batch should be moved into uncompressed EXPLAIN (analyze,buffers off, costs off, timing off, summary off) SELECT * FROM comp_seg_varchar; DROP TABLE comp_seg_varchar; -- test row locks for compressed tuples are blocked CREATE TABLE row_locks(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('row_locks', 'time'); ALTER TABLE row_locks SET (timescaledb.compress); INSERT INTO row_locks VALUES('2021-01-01 00:00:00'); SELECT count(compress_chunk(c)) FROM show_chunks('row_locks') c; -- should succeed cause no compressed tuples are returned SELECT FROM row_locks WHERE time < '2021-01-01 00:00:00' FOR UPDATE; -- should be blocked \set ON_ERROR_STOP 0 SELECT FROM row_locks FOR UPDATE; SELECT FROM row_locks FOR NO KEY UPDATE; SELECT FROM row_locks FOR SHARE; SELECT FROM row_locks FOR KEY SHARE; \set ON_ERROR_STOP 1 DROP TABLE row_locks; CREATE TABLE lazy_decompress(time timestamptz not null, device text, value float, primary key (device,time)); SELECT table_name FROM create_hypertable('lazy_decompress', 'time'); ALTER TABLE lazy_decompress SET (timescaledb.compress, timescaledb.compress_segmentby = 'device'); INSERT INTO lazy_decompress SELECT '2024-01-01'::timestamptz + format('%s',i)::interval, 'd1', i FROM generate_series(1,6000) g(i); SELECT count(compress_chunk(c)) FROM show_chunks('lazy_decompress') c; -- no decompression cause no match in batch BEGIN; :ANALYZE INSERT INTO lazy_decompress SELECT '2024-01-01 0:00:00.5','d1',random() ON CONFLICT DO NOTHING; ROLLBACK; BEGIN; :ANALYZE INSERT INTO lazy_decompress SELECT '2024-01-01 0:00:00.5','d1',random() ON CONFLICT(time,device) DO UPDATE SET value=EXCLUDED.value; ROLLBACK; -- should decompress 1 batch cause there is match BEGIN; :ANALYZE INSERT INTO lazy_decompress SELECT '2024-01-01 0:00:01','d1',random() ON CONFLICT DO NOTHING; ROLLBACK; -- no decompression cause no match in batch BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 0; ROLLBACK; BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 0 AND device='d1'; ROLLBACK; -- 1 batch decompression BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 2300; ROLLBACK; BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value > 3100 AND value < 3200; ROLLBACK; BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value BETWEEN 3100 AND 3200; ROLLBACK; -- check GUC is working, should be 6 batches and 6000 tuples decompresed SET timescaledb.enable_dml_decompression_tuple_filtering TO off; BEGIN; :ANALYZE UPDATE lazy_decompress SET value = 3.14 WHERE value = 0 AND device='d1'; ROLLBACK; RESET timescaledb.enable_dml_decompression_tuple_filtering; -- no decompression cause no match in batch BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 0; ROLLBACK; BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 0 AND device='d1'; ROLLBACK; -- 1 batch decompression BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 2300; ROLLBACK; BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value > 3100 AND value < 3200; ROLLBACK; BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value BETWEEN 3100 AND 3200; ROLLBACK; -- check GUC is working, should be 6 batches and 6000 tuples decompresed SET timescaledb.enable_dml_decompression_tuple_filtering TO off; BEGIN; :ANALYZE DELETE FROM lazy_decompress WHERE value = 0 AND device='d1'; ROLLBACK; RESET timescaledb.enable_dml_decompression_tuple_filtering; DROP TABLE lazy_decompress; CREATE FUNCTION trigger_function() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN RAISE WARNING 'Trigger fired'; RETURN NEW; END; $$; -- test direct delete on compressed hypertable CREATE TABLE direct_delete(time timestamptz not null, device text, reading text, value float); SELECT table_name FROM create_hypertable('direct_delete', 'time'); ALTER TABLE direct_delete SET (timescaledb.compress, timescaledb.compress_segmentby = 'device, reading'); INSERT INTO direct_delete VALUES ('2021-01-01', 'd1', 'r1', 1.0), ('2021-01-01', 'd1', 'r2', 1.0), ('2021-01-01', 'd1', 'r3', 1.0), ('2021-01-01', 'd1', NULL, 1.0), ('2021-01-01', 'd2', 'r1', 1.0), ('2021-01-01', 'd2', 'r2', 1.0), ('2021-01-01', 'd2', 'r3', 1.0), ('2021-01-01', 'd2', NULL, 1.0); SELECT count(compress_chunk(c)) FROM show_chunks('direct_delete') c; BEGIN; -- should be 3 batches directly deleted :ANALYZE DELETE FROM direct_delete WHERE device='d1'; -- double check its actually deleted SELECT count(*) FROM direct_delete WHERE device='d1'; ROLLBACK; BEGIN; -- should be 2 batches directly deleted :ANALYZE DELETE FROM direct_delete WHERE reading='r2'; -- double check its actually deleted SELECT count(*) FROM direct_delete WHERE reading='r2'; ROLLBACK; -- issue #7644 -- make sure non-btree operators don't delete unrelated batches BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading <> 'r2'; -- 4 tuples should still be there SELECT count(*) FROM direct_delete; ROLLBACK; -- test IS NULL BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading IS NULL; -- 6 tuples should still be there SELECT count(*) FROM direct_delete; ROLLBACK; -- test IS NOT NULL BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading IS NOT NULL; -- 2 tuples should still be there SELECT count(*) FROM direct_delete; ROLLBACK; -- test IN BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading IN ('r1','r2'); -- 4 tuples should still be there SELECT count(*) FROM direct_delete; ROLLBACK; -- test IN BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading NOT IN ('r1'); -- 4 tuples should still be there SELECT count(*) FROM direct_delete; ROLLBACK; -- combining constraints on segmentby columns should work BEGIN; -- should be 1 batches directly deleted :ANALYZE DELETE FROM direct_delete WHERE device='d1' AND reading='r2'; -- double check its actually deleted SELECT count(*) FROM direct_delete WHERE device='d1' AND reading='r2'; ROLLBACK; -- constraints involving non-segmentby columns should not directly delete BEGIN; :ANALYZE DELETE FROM direct_delete WHERE value = '1.0'; ROLLBACK; BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd1' AND value = '1.0'; ROLLBACK; BEGIN; :ANALYZE DELETE FROM direct_delete WHERE reading = 'r1' AND value = '1.0'; ROLLBACK; BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd2' AND reading = 'r3' AND value = '1.0'; ROLLBACK; -- presence of trigger should prevent direct delete CREATE TRIGGER direct_delete_trigger BEFORE DELETE ON direct_delete FOR EACH ROW EXECUTE FUNCTION trigger_function(); BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd1'; ROLLBACK; DROP TRIGGER direct_delete_trigger ON direct_delete; CREATE TRIGGER direct_delete_trigger AFTER DELETE ON direct_delete FOR EACH ROW EXECUTE FUNCTION trigger_function(); BEGIN; :ANALYZE DELETE FROM direct_delete WHERE device = 'd1'; ROLLBACK; DROP TRIGGER direct_delete_trigger ON direct_delete; DROP TABLE direct_delete; DROP FUNCTION trigger_function; -- test DML on metadata columns CREATE TABLE compress_dml(time timestamptz NOT NULL, device text, reading text, value float); SELECT table_name FROM create_hypertable('compress_dml', 'time'); ALTER TABLE compress_dml SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time DESC, reading'); INSERT INTO compress_dml VALUES ('2025-01-01','d1','r1',0.01), ('2025-01-01','d2','r2',0.01), ('2025-01-01','d3','r1',0.01), ('2025-01-01','d3','r2',0.01), ('2025-01-01','d4','r1',0.01), ('2025-01-01','d4',NULL,0.01), ('2025-01-01','d5','r2',0.01), ('2025-01-01','d5',NULL,0.01), ('2025-01-01','d6','r1',0.01), ('2025-01-01','d6','r2',0.01), ('2025-01-01','d6',NULL,0.01); SELECT count(compress_chunk(ch)) FROM show_chunks('compress_dml') ch; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading = 'r1'; SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading <> 'r1'; SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading IS NULL; SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading IS NOT NULL; SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading IN ('r2','r3'); SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading = ANY('{r2,r3}'); SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading NOT IN ('r2','r3'); SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; BEGIN; :ANALYZE DELETE FROM compress_dml WHERE reading <> ALL('{r2,r3}'); SELECT * FROM compress_dml t ORDER BY t; ROLLBACK; DROP TABLE compress_dml; -- Test issue #8241: invalidate generic plans for prepared statements -- when partial chunk is created from compressed chunk via UPDATE/DELETE CREATE TABLE t8241(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('t8241', 'time'); INSERT INTO t8241(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO t8241(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE t8241 SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('t8241') ch; PREPARE prep AS SELECT * FROM t8241; -- Should only see compressed chunk in the plan, this generic plan is now cached EXECUTE prep; EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; -- Test Update BEGIN; -- This will add decompressed row to the compressed chunk UPDATE t8241 SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; -- generic plan created for compressed chunk should be invalidated even though we didn't commit -- we should get correct result and the plan should have both compressed and decompressed parts EXECUTE prep; EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; ROLLBACK; -- Should see the compressed chunk only EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; -- Test Insert BEGIN; -- This will add decompressed row to the compressed chunk INSERT INTO t8241(time, device, value) VALUES ('2020-01-01 00:30:00', 'd1', 1.0); -- generic plan created for compressed chunk should be invalidated even though we didn't commit -- we should get correct result and the plan should have both compressed and decompressed parts EXECUTE prep; EXPLAIN (buffers off, costs off, timing off, summary off) EXECUTE prep; ROLLBACK; DEALLOCATE prep; DROP TABLE t8241 cascade; RESET plan_cache_mode; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/compression_nulls_not_distinct.sql���������������������������0000664�0000000�0000000�00000003317�15100345067�0026765�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test NULL NOT DISTINCT unique constraint -- this test is run only on PG15 since support for NULL NOT DISTINCT -- only exists since then. once we drop support for PG14, this test -- can be moved to non-shared compression_conflicts test set timescaledb.debug_compression_path_info to on; CREATE TABLE nulls_not_distinct(time timestamptz not null, device text, label text, value float); CREATE UNIQUE INDEX ON nulls_not_distinct (time, device, label) NULLS NOT DISTINCT; SELECT table_name FROM create_hypertable('nulls_not_distinct', 'time'); ALTER TABLE nulls_not_distinct SET (timescaledb.compress, timescaledb.compress_segmentby = 'device'); INSERT INTO nulls_not_distinct SELECT '2024-01-01'::timestamptz + format('%s',i)::interval, 'd1', 'l1', i FROM generate_series(1,6000) g(i); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', NULL, 'l1', 1); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', 'd2', NULL, 1); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.10', 'd2', 'l1', 1); SELECT count(compress_chunk(c)) FROM show_chunks('nulls_not_distinct') c; -- shouldn't succeed because nulls are not distinct \set ON_ERROR_STOP 0 INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', NULL, 'l1', 1); INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', 'd2', NULL, 1); \set ON_ERROR_STOP 1 -- should insert without error, no conflict INSERT INTO nulls_not_distinct VALUES ('2024-01-01 0:00:00.5', 'd2', 'l1', 1); RESET timescaledb.debug_compression_path_info; DROP TABLE nulls_not_distinct; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/constify_now.sql.in������������������������������������������0000664�0000000�0000000�00000027617�15100345067�0023565�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- create a test table -- any query with successful now_constify will have 1 chunk while -- others will have 2 chunks in plan CREATE TABLE const_now(time timestamptz, time2 timestamptz, device_id int, value float); SELECT table_name FROM create_hypertable('const_now','time'); INSERT INTO const_now SELECT '1000-01-01','1000-01-01',1,0.5; INSERT INTO const_now SELECT '1000-01-01','1000-01-01',2,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',1,0.5; INSERT INTO const_now SELECT '3000-01-01','3000-01-01',2,0.5; -- test valid variants we are optimizing -- all of these should have a constified value as filter -- none of these initial tests will actually exclude chunks -- because we want to see the constified now expression in -- EXPLAIN output :PREFIX SELECT FROM const_now WHERE time > now(); :PREFIX SELECT FROM const_now WHERE time >= now(); :PREFIX SELECT FROM const_now WHERE time > now() - '24h'::interval; :PREFIX SELECT FROM const_now WHERE time > now() + '10m'::interval; :PREFIX SELECT FROM const_now WHERE time >= now() - '10m'::interval; :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval; :PREFIX SELECT FROM const_now WHERE time > now() - '2d'::interval; :PREFIX SELECT FROM const_now WHERE time > now() + '3d'::interval; :PREFIX SELECT FROM const_now WHERE time > now() - '1week'::interval; :PREFIX SELECT FROM const_now WHERE time > now() - '1month'::interval; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP; :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '24h'::interval; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '10m'::interval; :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP - '10m'::interval; :PREFIX SELECT FROM const_now WHERE time >= CURRENT_TIMESTAMP + '10m'::interval; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '2d'::interval; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP + '3d'::interval; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1week'::interval; :PREFIX SELECT FROM const_now WHERE time > CURRENT_TIMESTAMP - '1month'::interval; -- test bitmapheapscan SET enable_indexscan TO false; :PREFIX SELECT FROM const_now WHERE time > now(); RESET enable_indexscan; -- test multiple constraints :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND device_id = 2; :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND (device_id = 2 OR device_id = 3); :PREFIX SELECT FROM const_now WHERE time >= now() + '10m'::interval AND time >= now() - '10m'::interval; -- variants we don't optimize :PREFIX SELECT FROM const_now WHERE time > now()::date; :PREFIX SELECT FROM const_now WHERE round(EXTRACT(EPOCH FROM now())) > 0.5; -- we only modify top-level ANDed now() expressions :PREFIX SELECT FROM const_now WHERE time > now() - '1m'::interval OR time > now() + '1m'::interval; :PREFIX SELECT FROM const_now WHERE device_id = 2 OR (time > now() - '1m'::interval AND time > now() + '1m'::interval); -- CTE :PREFIX WITH q1 AS ( SELECT * FROM const_now WHERE time > now() ) SELECT FROM q1; :PREFIX WITH q1 AS ( SELECT * FROM const_now ) SELECT FROM q1 WHERE time > now(); -- JOIN :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now(); :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m2.time > now(); :PREFIX SELECT FROM const_now m1, const_now m2 WHERE m1.time > now() AND m2.time > now(); -- only top-level constraints in WHERE clause are constified :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()); :PREFIX SELECT FROM const_now m1 INNER JOIN const_now m2 ON (m1.time > now()) WHERE m2.time > now(); -- test UPDATE :PREFIX UPDATE const_now SET value = EXTRACT(EPOCH FROM now()) WHERE time > now(); -- test DELETE :PREFIX DELETE FROM const_now WHERE time > now(); -- test chunks actually get excluded -- should exclude all SET timescaledb.current_timestamp_mock TO '2010-01-01'; :PREFIX SELECT FROM const_now WHERE time > now(); -- should exclude all but 1 chunk SET timescaledb.current_timestamp_mock TO '2000-01-14'; :PREFIX SELECT FROM const_now WHERE time > now(); -- should have one time filter false :PREFIX SELECT FROM const_now WHERE time > now(); -- no constification because it's not partitioning column :PREFIX SELECT FROM const_now WHERE time2 > now(); DROP TABLE const_now; -- test prepared statements CREATE TABLE prep_const_now(time timestamptz, device int, value float); SELECT table_name FROM create_hypertable('prep_const_now', 'time'); INSERT INTO prep_const_now SELECT '3000-01-02', 1, 0.2; INSERT INTO prep_const_now SELECT '3001-01-02', 2, 0.3; INSERT INTO prep_const_now SELECT '3002-01-02', 3, 0.4; SET timescaledb.current_timestamp_mock TO '3001-01-01'; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); :PREFIX EXECUTE p1; EXECUTE p1; SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; EXECUTE p1; -- same test with ChunkAppend enabled set timescaledb.enable_chunk_append = on; set timescaledb.enable_constraint_aware_append = on; DEALLOCATE p1; PREPARE p1 AS SELECT FROM prep_const_now WHERE time > now(); set timescaledb.current_timestamp_mock TO '3001-01-01'; :PREFIX EXECUTE p1; EXECUTE p1; SET timescaledb.current_timestamp_mock TO '3002-01-01'; -- plan won't change cause the query didnt get replanned :PREFIX EXECUTE p1; EXECUTE p1; set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; DROP TABLE prep_const_now; -- test outer var references dont trip up constify_now -- no optimization is done in this case :PREFIX SELECT * FROM metrics_tstz m1 INNER JOIN metrics_tstz as m2 on (true) WHERE EXISTS (SELECT * FROM metrics_tstz AS m3 WHERE m2.time > now()); -- test dst interaction with day intervals SET timezone TO 'Europe/Berlin'; CREATE TABLE const_now_dst(time timestamptz not null); SELECT table_name FROM create_hypertable('const_now_dst','time',chunk_time_interval:='30minutes'::interval); -- create 2 chunks INSERT INTO const_now_dst SELECT '2022-03-27 03:15:00+02'; INSERT INTO const_now_dst SELECT '2022-03-27 03:45:00+02'; SELECT * FROM const_now_dst WHERE time >= '2022-03-28 0:45+0'::timestamptz - '1d'::interval; SELECT * FROM const_now_dst WHERE time >= '2022-03-28 1:15+0'::timestamptz - '1d'::interval; SET timescaledb.current_timestamp_mock TO '2022-03-28 0:45+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; SET timescaledb.current_timestamp_mock TO '2022-03-28 1:15+0'; -- must have 2 chunks in plan :PREFIX SELECT FROM const_now_dst WHERE time > now() - '1day'::interval; TRUNCATE const_now_dst; SELECT set_chunk_time_interval('const_now_dst','1 day'::interval, 'time'); -- test month calculation safety buffer SET timescaledb.current_timestamp_mock TO '2001-03-1 0:30:00+00'; INSERT INTO const_now_dst SELECT generate_series('2001-01-28'::timestamptz, '2001-02-01', '1day'::interval); set timezone to 'utc+1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; set timezone to 'utc-1'; -- must have 5 chunks in plan :PREFIX SELECT * FROM const_now_dst WHERE time > now() - '1 month'::interval; DROP TABLE const_now_dst; -- test now constification with VIEWs SET timescaledb.current_timestamp_mock TO '2003-01-01 0:30:00+00'; CREATE TABLE now_view_test(time timestamptz,device text, value float); SELECT table_name FROM create_hypertable('now_view_test','time'); -- create 5 chunks INSERT INTO now_view_test SELECT generate_series('2000-01-01'::timestamptz,'2004-01-01'::timestamptz,'1year'::interval), 'a', 0.5; CREATE VIEW now_view AS SELECT time, device, avg(value) from now_view_test GROUP BY 1,2; -- should have all 5 chunks in EXPLAIN :PREFIX SELECT * FROM now_view; -- should have 2 chunks in EXPLAIN :PREFIX SELECT * FROM now_view WHERE time > now() - '168h'::interval; DROP TABLE now_view_test CASCADE; -- #4709 -- test queries with constraints involving columns from different nesting levels SELECT * FROM (SELECT * FROM metrics m1 LIMIT 1) m1 INNER JOIN (SELECT * FROM metrics m2 LIMIT 1) m2 ON true, LATERAL (SELECT m2.time FROM devices LIMIT 1) as subq_1 WHERE subq_1.time > m1.time; CREATE TABLE logged_data ( rawtag_id INTEGER, timestamp TIMESTAMP WITH TIME ZONE NOT NULL, value REAL, site_id INTEGER ); SELECT table_name FROM create_hypertable('logged_data', 'timestamp'); INSERT INTO logged_data (rawtag_id, timestamp, value, site_id) VALUES (1, '2023-01-01'::timestamptz, 13, 1), (1, '2023-01-07'::timestamptz, 13, 1), (1, '2023-01-10'::timestamptz, 13, 1), (1, '2023-01-15'::timestamptz, 13, 1), (1, '2023-01-20'::timestamptz, 15, 1), (2, '2023-01-01'::timestamptz, 90, 1), (3, '2023-01-07'::timestamptz, 2, 1), (4, '2023-01-10'::timestamptz, 13, 3), (2, '2023-01-15'::timestamptz, 13, 4), (5, '2023-01-20'::timestamptz, 13, 1); -- four chunks, all of them should be excluded at plantime SELECT row_number() OVER (), range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_schema = 'public' AND hypertable_name = 'logged_data' ORDER BY 2,3; SET timescaledb.current_timestamp_mock TO '2024-01-01 0:30:00+00'; SET timescaledb.enable_chunk_append TO true; SET timescaledb.enable_constraint_aware_append TO true; -- for all the queries below, exclusion should be happening at plantime EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '1 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM logged_data WHERE timestamp <= now() AND timestamp >= now() - interval '1 day' ORDER BY "timestamp" ASC; -- mock_now() in the middle of the table SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; EXECUTE pbtw; -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; EXECUTE pbtw; -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; EXECUTE pbtw; DEALLOCATE pbtw; -- repeat without ChunkAppend set timescaledb.enable_chunk_append = off; set timescaledb.enable_constraint_aware_append = off; SET timescaledb.current_timestamp_mock TO '2023-01-11'; PREPARE pbtw AS SELECT * FROM logged_data WHERE timestamp BETWEEN now() - interval '5 day' AND now() AND rawtag_id = 1 ORDER BY "timestamp" ASC; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; EXECUTE pbtw; -- now move mock_now() to the future SET timescaledb.current_timestamp_mock TO '2023-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; EXECUTE pbtw; -- much further into the future, no rows should be returned SET timescaledb.current_timestamp_mock TO '2024-01-21 0:30:00+00'; EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) EXECUTE pbtw; EXECUTE pbtw; DEALLOCATE pbtw; DROP TABLE logged_data; �����������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/constify_timestamptz_op_interval.sql.in����������������������0000664�0000000�0000000�00000011160�15100345067�0027727�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off)' -- we disable ChunkAppend and ConstraintAwareAppend here to make the exclusion easier to spot -- otherwise those would remove the chunks from the plan during execution SET timescaledb.enable_chunk_append TO FALSE; SET timescaledb.enable_constraint_aware_append TO FALSE; SET timescaledb.enable_now_constify TO FALSE; -- plan query on complete hypertable to get a list of the chunks :PREFIX SELECT time FROM metrics; -- all of these should have all chunk exclusion happening at plan time :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz - '6h'::interval; :PREFIX SELECT time FROM metrics WHERE time < '2000-01-01'::timestamptz + '6h'::interval; :PREFIX SELECT time FROM metrics WHERE time < '6h'::interval + '2000-01-01'::timestamptz; :PREFIX SELECT time FROM metrics WHERE time < '2000-01-07'::timestamptz - '7 day 8 seconds'::interval; :PREFIX SELECT time FROM metrics WHERE time < '2000-03-01'::timestamptz - '60 day'::interval; -- test Var on right side of expression :PREFIX SELECT time FROM metrics WHERE '2000-01-01'::timestamptz - '6h'::interval > time; :PREFIX SELECT time FROM metrics WHERE '2000-01-07'::timestamptz - '7 day'::interval > time; :PREFIX SELECT time FROM metrics WHERE '2000-03-01'::timestamptz - '60 day'::interval > time; -- test multiple constraints :PREFIX SELECT time FROM metrics WHERE time > '2000-01-10'::timestamptz - '6h'::interval AND time < '2000-01-10'::timestamptz + '6h'::interval; -- test on space-partitioned hypertable :PREFIX SELECT time FROM metrics_space WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; -- test on compressed hypertable :PREFIX SELECT time FROM metrics_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval; -- test on space-partitioned compressed hypertable :PREFIX SELECT time FROM metrics_space_compressed WHERE time < '2000-01-01'::timestamptz - '6h'::interval AND device_id = 1; -- month/year intervals are not constified :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month'::interval; :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month - 1 day'::interval; :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - '1 month + 1 day'::interval; :PREFIX SELECT time FROM metrics WHERE '2000-02-01'::timestamptz - '1 year'::interval > time; -- nested expressions are not constified :PREFIX SELECT time FROM metrics WHERE time < '1 day' + '2000-02-01'::timestamptz - '1 month'::interval; -- non-Const expressions are not constified :PREFIX SELECT time FROM metrics WHERE time > now() - '6h'::interval; -- test NULL values :PREFIX SELECT time FROM metrics WHERE time < '2000-02-01'::timestamptz - NULL::interval; :PREFIX SELECT time FROM metrics WHERE time < NULL::timestamptz - NULL::interval; -- test timezone changes in prepared statements CREATE TABLE dst_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('dst_test','time',chunk_time_interval:=interval '30 minutes'); INSERT INTO dst_test SELECT generate_series('2022-03-27 22:00:00+01'::timestamptz,'2022-03-28 02:00:00+01'::timestamptz,'30min'::interval); SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; set timezone TO 'Europe/Berlin'; EXECUTE p1; SELECT count(*) FROM dst_test WHERE time > '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; EXECUTE p1; set timezone TO 'Africa/Casablanca'; EXECUTE p1; SELECT count(*) FROM dst_test WHERE time < '2022-03-27 00:00:00+00'::timestamptz + interval '1 day'; DEALLOCATE p1; -- do same tests with var on wrong side SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; EXECUTE p1; set timezone TO 'Europe/Berlin'; EXECUTE p1; SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' < time; DEALLOCATE p1; SET timezone TO UTC; PREPARE p1 AS SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; EXECUTE p1; set timezone TO 'Africa/Casablanca'; EXECUTE p1; SELECT count(*) FROM dst_test WHERE '2022-03-27 00:00:00+00'::timestamptz + interval '1 day' > time; DEALLOCATE p1; DROP TABLE dst_test; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/constraint_aware_append.sql����������������������������������0000664�0000000�0000000�00000001561�15100345067�0025317�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test handling of ConstraintAwareAppend -> Sort -> Result -> Scan -- issue 5739 CREATE TABLE ca_append_result(time timestamptz NULL, device text, value float); SELECT table_name FROM create_hypertable('ca_append_result', 'time'); ALTER TABLE ca_append_result SET (timescaledb.compress); INSERT INTO ca_append_result SELECT '2000-01-03','d1',0.3; SELECT count(compress_chunk(ch)) AS compressed FROM show_chunks('ca_append_result') ch; INSERT INTO ca_append_result SELECT '2000-01-13','d1',0.6; SET enable_seqscan TO FALSE; SELECT time_bucket('20d',time) AS day from ca_append_result WHERE time > '1900-01-01'::text::timestamp GROUP BY day; RESET enable_seqscan; DROP TABLE ca_append_result; �����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/constraint_exclusion_prepared.sql.in�������������������������0000664�0000000�0000000�00000005373�15100345067�0027176�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' SET work_mem TO '64MB'; -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge TO 'off'; SET max_parallel_workers_per_gather TO '0'; -- disable incremental sort to avoid flaky results SET enable_incremental_sort TO 'off'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none SET client_min_messages TO error; -- run queries on compressed hypertable and store result \set TEST_TABLE 'metrics' \o :TEST_RESULTS_UNCOMPRESSED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \o :TEST_RESULTS_COMPRESSED \ir :TEST_QUERY_NAME \o -- diff compressed and uncompressed results :DIFF_CMD -- do the same for space partitioned hypertable \set TEST_TABLE 'metrics_space' \o :TEST_RESULTS_UNCOMPRESSED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \o :TEST_RESULTS_COMPRESSED \ir :TEST_QUERY_NAME \o -- diff compressed and uncompressed results :DIFF_CMD ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/decompress_join.sql������������������������������������������0000664�0000000�0000000�00000003053�15100345067�0023606�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET enable_memoize TO false; SET enable_indexscan TO false; SET max_parallel_workers_per_gather = 0; -- test join on compressed time column -- #3079, #4465 CREATE TABLE compressed_join_temp AS SELECT * FROM metrics ORDER BY time DESC LIMIT 10; ANALYZE compressed_join_temp; EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * FROM compressed_join_temp t INNER JOIN metrics_compressed m ON t.time = m.time AND t.device_id = m.device_id LIMIT 1; DROP TABLE compressed_join_temp; -- test join with partially compressed chunks CREATE TABLE partial_join(time timestamptz,device text); SELECT table_name FROM create_hypertable('partial_join','time'); ALTER TABLE partial_join set(timescaledb.compress,timescaledb.compress_segmentby='device'); INSERT INTO partial_join SELECT '2000-01-01','d1'; SELECT count(*) FROM (SELECT compress_chunk(show_chunks('partial_join'),true)) compress; -- make chunk partially compressed INSERT INTO partial_join SELECT '2000-01-01','d1'; SELECT * FROM partial_join m1 INNER JOIN partial_join m2 ON m1.device = m2.device; DROP TABLE partial_join; -- This resulted in a recursion in the join planner code on PG16 SELECT * FROM metrics_tstz as m INNER JOIN metrics_space as ms on (true) INNER JOIN metrics_space_compressed as msc on (true) WHERE CASE WHEN m.device_id is not NULL and ms.v2 is not NULL THEN NULL::int2 end = msc.device_id; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/decompress_placeholdervar.sql��������������������������������0000664�0000000�0000000�00000012261�15100345067�0025643�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test handling of PlaceHolderVar in DecompressChunk -- https://github.com/timescale/timescaledb/issues/1981 CREATE TABLE decompress_phv_device ( device_id integer NOT NULL, decompress_phv_device_name varchar(128) NOT NULL, network_id integer ); CREATE TABLE decompress_phv_ping ( id integer NOT NULL, device_id integer NOT NULL, pkt_rx integer NOT NULL, rtt_avg float, insert_ts timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL ); SELECT table_name FROM create_hypertable('decompress_phv_ping', 'insert_ts', chunk_time_interval => interval '1 day'); INSERT INTO decompress_phv_device VALUES (41040, 'MB10010013', 240), (65101, 'BR100103ca', 240), (65103, 'BR100103cb', 240), (65105, 'BR100103cc', 240), (65107, 'BR100103cd', 240), (41041, 'MB11000000', 241), (65201, 'BR11000014', 241), (65203, 'BR11000015', 241), (65205, 'BR11000016', 241), (65207, 'BR11000017', 241); INSERT INTO decompress_phv_ping VALUES (1, 41040, 3, 243.333333333333, '2019-03-21 02:30:48.007'), (1, 41040, 3, 300.333333333333, '2019-03-21 02:00:19.957'), (1, 41040, 3, 265.333333333333, '2019-03-21 01:28:50.669'), (1, 41040, 3, 174, '2019-03-21 00:57:09.733'), (1, 41040, 3, 552.666666666667, '2019-03-21 00:21:02.305'), (1, 41041, 3, 330.333333333333, '2019-03-21 02:30:44.984'), (1, 41041, 3, 753, '2019-03-21 02:00:38.062'), (1, 41041, 3, 260, '2019-03-21 01:30:10.21'), (1, 41041, 3, 357.333333333333, '2019-03-21 00:59:10.768'), (1, 41041, 3, 474.666666666667, '2019-03-21 00:20:54.272'), (1, 65101, 3, 17.5200004577637, '2019-03-21 02:36:50.606'), (1, 65101, 3, 17.5200004577637, '2019-03-21 02:06:43.631'), (1, 65101, 3, 31.8933359781901, '2019-03-21 01:34:56.56'), (1, 65101, 3, 17.5200004577637, '2019-03-21 01:03:10.913'), (1, 65101, 3, 17.5200004577637, '2019-03-21 00:33:53.707'), (1, 65201, 3, 17.5200004577637, '2019-03-21 02:31:58.444'), (1, 65201, 3, 17.5200004577637, '2019-03-21 02:01:53.565'), (1, 65201, 3, 17.5200004577637, '2019-03-21 01:30:16.261'), (1, 65201, 2, 17.5200004577637, '2019-03-21 00:59:34.953'), (1, 65201, 3, 17.5200004577637, '2019-03-21 00:27:19.228'), (1, 41040, 3, 31.6666666666667, '2019-03-22 03:29:45.404'), (1, 41040, 3, 128, '2019-03-22 03:01:36.323'), (1, 41040, 3, 50, '2019-03-22 02:31:20.107'), (1, 41040, 3, 149.666666666667, '2019-03-22 02:01:07.201'), (1, 41040, 3, 502, '2019-03-22 01:28:27.129'), (1, 41041, 3, 355, '2019-03-22 03:30:50.844'), (1, 41041, 3, 53, '2019-03-22 03:01:40.348'), (1, 41041, 3, 121.333333333333, '2019-03-22 02:32:04.392'), (1, 41041, 3, 325.333333333333, '2019-03-22 02:02:06.968'), (1, 41041, 3, 576.666666666667, '2019-03-22 01:30:04.821'), (1, 65101, 3, 17.5200004577637, '2019-03-22 03:08:33.227'), (1, 65101, 3, 17.5200004577637, '2019-03-22 02:37:29.96'), (1, 65101, 3, 17.5200004577637, '2019-03-22 02:07:14.805'), (1, 65101, 3, 17.5200004577637, '2019-03-22 01:34:25.055'), (1, 65101, 3, 17.5200004577637, '2019-03-22 01:03:40.405'), (1, 65201, 3, 17.5200004577637, '2019-03-22 03:30:56.885'), (1, 65201, 3, 17.5200004577637, '2019-03-22 03:03:40.243'), (1, 65201, 3, 17.5200004577637, '2019-03-22 02:32:38.625'), (1, 65201, 3, 17.5200004577637, '2019-03-22 02:02:20.05'), (1, 65201, 3, 17.5200004577637, '2019-03-22 01:30:09.863'); ALTER TABLE decompress_phv_ping SET (timescaledb.compress, timescaledb.compress_orderby = 'device_id, insert_ts DESC'); SELECT count(*) AS compressed FROM ( select compress_chunk(i) FROM show_chunks('decompress_phv_ping') i ) q; SELECT from_ts, insert_ts, network_id, pkt_loss, rtt_avg FROM generate_series('2019-03-21 01:00:00'::timestamp, '2019-03-23 13:00:00'::timestamp, '12h'::interval) ts_bucket (from_ts) LEFT JOIN ( SELECT d.network_id, CASE WHEN p.pkt_rx = 0 THEN 1 ELSE 0 END AS pkt_loss, p.rtt_avg, p.insert_ts FROM decompress_phv_device d INNER JOIN decompress_phv_ping p ON p.device_id = d.device_id WHERE d.network_id = 240) data ON data.insert_ts BETWEEN from_ts AND from_ts + '12h'::interval ORDER BY 1,2; DROP TABLE decompress_phv_ping; DROP TABLE decompress_phv_device; -- test assertion failure in bitmapheapscan path creation -- GH Issue #2211 CREATE TABLE tickers ( time TIMESTAMPTZ, microseconds INT, fk_exchange SMALLINT, fk_trade_pair SMALLINT ); CREATE INDEX ON tickers (fk_exchange, fk_trade_pair, time DESC, microseconds DESC); SELECT table_name FROM create_hypertable('tickers', 'time'); ALTER TABLE tickers SET (timescaledb.compress, timescaledb.compress_segmentby = 'fk_exchange, fk_trade_pair', timescaledb.compress_orderby = 'time DESC, microseconds DESC'); INSERT INTO tickers SELECT '2000-01-01', 0, i, j FROM generate_series(1, 20) i, generate_series(1, 40) j; SELECT substr(compress_chunk(tableoid::REGCLASS)::TEXT, 1, 29) FROM tickers GROUP BY tableoid; SELECT * FROM tickers WHERE time >= '2000-01-01' AND time < '2020-08-02T00:00Z' AND fk_exchange = 4 AND fk_trade_pair = 29 ORDER BY time DESC, microseconds DESC; DROP TABLE tickers; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/decompress_tracking.sql��������������������������������������0000664�0000000�0000000�00000005204�15100345067�0024451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off,timing off,summary off)' \set EXPLAIN_ANALYZE 'EXPLAIN (analyze,buffers off, costs off,timing off,summary off)' CREATE TABLE decompress_tracking(time timestamptz not null, device text, value float, primary key(time, device)); SELECT table_name FROM create_hypertable('decompress_tracking','time'); ALTER TABLE decompress_tracking SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO decompress_tracking SELECT '2020-01-01'::timestamptz + format('%s hour', g)::interval, 'd1', random() FROM generate_series(1,10) g; INSERT INTO decompress_tracking SELECT '2020-01-01'::timestamptz + format('%s hour', g)::interval, 'd2', random() FROM generate_series(1,20) g; INSERT INTO decompress_tracking SELECT '2020-01-01'::timestamptz + format('%s hour', g)::interval, 'd3', random() FROM generate_series(1,30) g; SELECT count(compress_chunk(ch)) FROM show_chunks('decompress_tracking') ch; ANALYZE decompress_tracking; -- no tracking without analyze :EXPLAIN UPDATE decompress_tracking SET value = value + 3; BEGIN; :EXPLAIN_ANALYZE UPDATE decompress_tracking SET value = value + 3; ROLLBACK; BEGIN; :EXPLAIN_ANALYZE UPDATE decompress_tracking SET value = value + 3 WHERE device = 'd2'; ROLLBACK; SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking; ROLLBACK; BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking WHERE device = 'd3'; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking; ROLLBACK; BEGIN; :EXPLAIN_ANALYZE DELETE FROM decompress_tracking WHERE device = 'd3'; ROLLBACK; BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking SELECT '2020-01-01 1:30','d1',random(); ROLLBACK; BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking SELECT '2020-01-01','d2',random(); ROLLBACK; BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking SELECT '2020-01-01','d4',random(); ROLLBACK; BEGIN; :EXPLAIN_ANALYZE INSERT INTO decompress_tracking (VALUES ('2020-01-01 1:30','d1',random()),('2020-01-01 1:30','d2',random())); ROLLBACK; -- test prepared statements EXPLAIN still works after execution SET plan_cache_mode TO force_generic_plan; PREPARE p1 AS UPDATE decompress_tracking SET value = value + 3 WHERE device = 'd1'; BEGIN; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; EXECUTE p1; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; ROLLBACK; DROP TABLE decompress_tracking; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/extension.sql������������������������������������������������0000664�0000000�0000000�00000001533�15100345067�0022440�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \pset tuples_only on -- list all extension functions -- any change in the output of this query requires adjustments -- in the update and downgrade scripts -- get_telemetry_report is excluded as it will not be present -- when built with telemetry disabled SELECT p.oid::regprocedure::text FROM pg_proc p JOIN pg_depend d ON d.objid = p.oid AND d.deptype = 'e' AND d.refclassid = 'pg_extension'::regclass AND d.classid = 'pg_proc'::regclass JOIN pg_extension e ON e.extname = 'timescaledb' AND e.oid = d.refobjid WHERE proname <> 'get_telemetry_report' ORDER BY pronamespace::regnamespace::text COLLATE "C", p.oid::regprocedure::text COLLATE "C"; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/gapfill.sql.in�����������������������������������������������0000664�0000000�0000000�00000126475�15100345067�0022464�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' -- we want to see error details in the output \set VERBOSITY default CREATE TABLE gapfill_plan_test(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('gapfill_plan_test','time',chunk_time_interval=>'4 weeks'::interval); INSERT INTO gapfill_plan_test SELECT generate_series('2018-01-01'::timestamptz,'2018-04-01'::timestamptz,'1m'::interval), 1.0; -- simple example :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1; -- test sorting :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2; -- test sort direction :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 1 DESC; -- test order by aggregate function :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1 ORDER BY 2,1; -- test query without order by :EXPLAIN SELECT time_bucket_gapfill('5m',time,now(),now()), avg(c2) FROM (VALUES (now(),1),(now(),NULL),(now(),NULL)) as t(time,c2) GROUP BY 1; -- test parallel query :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), avg(value) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; -- test parallel query with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; -- test parallel query with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; -- make sure we can run gapfill in parallel workers -- ensure this plan runs in parallel :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; -- actually run a parallel gapfill SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 2 LIMIT 1; -- test sort optimizations -- test sort optimization with single member order by, -- should use index scan (no GapFill node for this one since we're not gapfilling) :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1; SET max_parallel_workers_per_gather TO 0; -- test sort optimizations with locf :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), locf(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; -- test sort optimizations with interpolate :EXPLAIN SELECT time_bucket_gapfill('5m',time,to_timestamp(0),to_timestamp(0)), interpolate(avg(value)) FROM gapfill_plan_test GROUP BY 1 ORDER BY 1; RESET max_parallel_workers_per_gather; CREATE INDEX gapfill_plan_test_indx ON gapfill_plan_test(value, time); -- test sort optimization with ordering by multiple columns and time_bucket_gapfill not last, -- must not use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 1,2; -- test sort optimization with ordering by multiple columns and time_bucket as last member, -- should use index scan :EXPLAIN SELECT time_bucket_gapfill('5m',time),value FROM gapfill_plan_test ORDER BY 2,1; DROP TABLE gapfill_plan_test; \set METRICS metrics_int -- All test against table :METRICS first \set ON_ERROR_STOP 0 -- inverse of previous test query to confirm an error is actually thrown SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time = 5 GROUP BY 1,2,3 ORDER BY 2,3,1; -- test window functions with multiple column references SELECT time_bucket_gapfill(1,time,1,2), first(min(time),min(time)) OVER () FROM :METRICS GROUP BY 1; -- test with unsupported operator SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time =0 AND time < 2 GROUP BY 1; -- test with 2 tables and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; -- test inner join and where clause doesnt match gapfill argument SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time WHERE m1.time >=0 AND m1.time < 2 GROUP BY 1; -- test outer join with constraints in join condition -- not usable as start/stop SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 LEFT OUTER JOIN :METRICS m2 ON m1.time=m2.time AND m1.time >=0 AND m1.time < 2 GROUP BY 1; \set ON_ERROR_STOP 1 \ir include/gapfill_metrics_query.sql -- Tests without tables -- test locf and interpolate call without gapfill SELECT locf(1); SELECT interpolate(1); -- test locf and interpolate call with NULL input SELECT locf(NULL::int); SELECT interpolate(NULL::bigint); \set ON_ERROR_STOP 0 -- test time_bucket_gapfill not top level function call SELECT 1 + time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test locf with treat_null_as_missing not BOOL SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=1) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test locf with treat_null_as_missing not literal SELECT time_bucket_gapfill(1,time,1,11), locf(min(time),treat_null_as_missing:=random()>0) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test interpolate lookup query with 1 element in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT ROW(10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT ROW(10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; -- test interpolate lookup query with 3 elements in record SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; -- test interpolate lookup query with mismatching time datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10::float,10))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10::float,10))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; -- test interpolate lookup query with mismatching value datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),next=>(SELECT (10,10::float))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,11), interpolate(min(time),prev=>(SELECT (10,10::float))) FROM (VALUES (2),(3)) v(time) GROUP BY 1; -- test interpolate with unsupported datatype SELECT time_bucket_gapfill(1,time,1,11), interpolate(text 'text') FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,11), interpolate(interval '1d') FROM (VALUES (2),(3)) v(time) GROUP BY 1; -- test multiple time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time,1,11),time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test nested time_bucket_gapfill calls SELECT time_bucket_gapfill(1,time_bucket_gapfill(1,time,1,11),1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test nested locf calls SELECT time_bucket_gapfill(1,time,1,11), locf(locf(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test nested interpolate calls SELECT time_bucket_gapfill(1,time,1,11), interpolate(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test mixed locf/interpolate calls SELECT time_bucket_gapfill(1,time,1,11), locf(interpolate(min(time))) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test window function inside locf SELECT time_bucket_gapfill(1,time,1,11), locf(avg(min(time)) OVER ()) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test nested window functions -- prevented by postgres SELECT time_bucket_gapfill(1,time,1,11), avg(avg(min(time)) OVER ()) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test multiple window functions in single column SELECT time_bucket_gapfill(1,time,1,11), avg(min(time)) OVER () + avg(min(time)) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test locf not toplevel SELECT time_bucket_gapfill(1,time,1,11), 1 + locf(min(time)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test locf inside aggregate SELECT time_bucket_gapfill(1,time,1,11), min(min(locf(time))) OVER () FROM (VALUES (1),(2)) v(time) GROUP BY 1; -- test NULL args SELECT time_bucket_gapfill(NULL,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,NULL,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,NULL,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,NULL) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(NULL,time,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; SELECT time_bucket_gapfill('1day',NULL,'Europe/Berlin','2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; SELECT time_bucket_gapfill('1day',time,NULL,'2000-06-01','2001-06-01') FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01'::timestamptz)) v(time) GROUP BY 1; -- test 0 bucket_width SELECT time_bucket_gapfill(0,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; SELECT time_bucket_gapfill('0d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; -- test negative bucket_width SELECT time_bucket_gapfill(-1,time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::date),('2000-02-01'::date)) v(time) GROUP BY 1; SELECT time_bucket_gapfill('-1d',time,'2000-01-01','2000-02-01') FROM (VALUES ('2000-01-01'::timestamptz),('2000-02-01'::timestamptz)) v(time) GROUP BY 1; -- test subqueries as interval, start and stop (not supported atm) SELECT time_bucket_gapfill((SELECT 1),time,1,11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,(SELECT 1),11) FROM (VALUES (1),(2)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1,time,1,(SELECT 11)) FROM (VALUES (1),(2)) v(time) GROUP BY 1; \set ON_ERROR_STOP 1 -- test time_bucket_gapfill without aggregation -- this will not trigger gapfilling SELECT time_bucket_gapfill(1,time,1,11) FROM (VALUES (1),(2)) v(time); SELECT time_bucket_gapfill(1,time,1,11), avg(time) OVER () FROM (VALUES (1),(2)) v(time); -- test int int2/4/8 SELECT time_bucket_gapfill(1::int2,time::int2,0::int2,6::int2) FROM (VALUES (1),(4)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1::int4,time::int4,0::int4,6::int4) FROM (VALUES (1),(4)) v(time) GROUP BY 1; SELECT time_bucket_gapfill(1::int8,time::int8,0::int8,6::int8) FROM (VALUES (1),(4)) v(time) GROUP BY 1; -- test non-aligned bucket start SELECT time_bucket_gapfill(10,time,5,40) FROM (VALUES (11),(22)) v(time) GROUP BY 1; -- simple gapfill query SELECT time_bucket_gapfill(10,time,0,50) AS time, min(value) AS value FROM (values (-10,1),(10,2),(11,3),(12,4),(22,5),(30,6),(66,7)) v(time,value) GROUP BY 1 ORDER BY 1; -- test references to different columns SELECT time_bucket_gapfill(1,t,0,5) as t, min(t),max(t),min(v),max(v) FROM(VALUES (1,3),(2,5)) tb(t,v) GROUP BY 1 ORDER BY 1; -- test passing of values outside boundaries SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (-1),(1),(3),(6)) v(time) GROUP BY 1 ORDER BY 1; -- test gap fill before first row and after last row SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; -- test gap fill without rows in resultset SELECT time_bucket_gapfill(1,time,0,5), min(time) FROM (VALUES (1),(2),(3)) v(time) WHERE false GROUP BY 1 ORDER BY 1; -- test coalesce SELECT time_bucket_gapfill(1,time,0,5), coalesce(min(time),0), coalesce(min(value),0), coalesce(min(value),7) FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; -- test case SELECT time_bucket_gapfill(1,time,0,5), min(time), CASE WHEN min(time) IS NOT NULL THEN min(time) ELSE -1 END, CASE WHEN min(time) IS NOT NULL THEN min(time) + 7 ELSE 0 END, CASE WHEN 1 = 1 THEN 1 ELSE 0 END FROM (VALUES (1,1),(2,2),(3,3)) v(time,value) GROUP BY 1 ORDER BY 1; -- test constants SELECT time_bucket_gapfill(1,time,0,5), min(time), min(time), 4 as c FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1 ORDER BY 1; -- test column reordering SELECT 1 as c1, '2' as c2, time_bucket_gapfill(1,time,0,5), 3.0 as c3, min(time), min(time), 4 as c4 FROM (VALUES (1),(2),(3)) v(time) GROUP BY 3 ORDER BY 3; -- test timestamptz SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMPTZ '2000-01-01',TIMESTAMPTZ '2000-01-02'), min(time) FROM (VALUES (TIMESTAMPTZ '2000-01-01 9:00:00'),(TIMESTAMPTZ '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; -- test timestamp SELECT time_bucket_gapfill(INTERVAL '6h',time,TIMESTAMP '2000-01-01',TIMESTAMP '2000-01-02'), min(time) FROM (VALUES (TIMESTAMP '2000-01-01 9:00:00'),(TIMESTAMP '2000-01-01 18:00:00')) v(time) GROUP BY 1 ORDER BY 1; -- test date SELECT time_bucket_gapfill(INTERVAL '1w',time,DATE '2000-01-01',DATE '2000-02-10'), min(time) FROM (VALUES (DATE '2000-01-08'),(DATE '2000-01-22')) v(time) GROUP BY 1 ORDER BY 1; -- test grouping by non-time columns SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 2,1; -- test grouping by non-time columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) WHERE false GROUP BY 1,id ORDER BY 2,1; -- test duplicate columns in GROUP BY SELECT time_bucket_gapfill(1,time,0,5) as time, id, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,2,3 ORDER BY 2,1; -- test grouping by columns not in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY id,1; -- test grouping by non-time columns with text columns SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; -- test grouping by non-time columns with text columns with no rows in resultset SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) WHERE false GROUP BY 1,color ORDER BY 2,1; --- test insert into SELECT CREATE TABLE gapfill_insert_test(id INT); INSERT INTO gapfill_insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM gapfill_insert_test; DROP TABLE gapfill_insert_test; -- test join SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'red',1),(2,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; -- test join with locf SELECT t1.*,t2.m FROM ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as locf FROM (VALUES (0,'red',1),(0,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t1 INNER JOIN ( SELECT time_bucket_gapfill(1,time,0,5) as time, color, locf(min(value)) as m FROM (VALUES (3,'red',1),(4,'blue',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1 ) t2 ON t1.time = t2.time AND t1.color=t2.color; -- test locf SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; -- test locf with NULLs in resultset SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value)) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=NULL) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; -- test locf with NULLs in resultset and treat_null_as_missing SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; -- test locf with NULLs in first row of resultset and treat_null_as_missing with lookup query SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=false, prev := (SELECT 100)) AS v1, locf(min(value),treat_null_as_missing:=true, prev := (SELECT 100)) AS v2 FROM (values (0,NULL),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; -- test locf with NULLs in resultset and treat_null_as_missing with resort SELECT time_bucket_gapfill(10,time,0,50) AS time, locf(min(value),treat_null_as_missing:=true) AS value FROM (values (10,9),(20,3),(30,NULL),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1 DESC; -- test locf with constants SELECT time_bucket_gapfill(1,time,0,5), 2, locf(min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; -- test expressions inside locf SELECT time_bucket_gapfill(1,time,0,5), locf(min(value)), locf(4), locf(4 + min(value)) FROM (VALUES (0,1,3),(4,2,3)) v(time,value) GROUP BY 1; -- test locf with out of boundary lookup SELECT time_bucket_gapfill(10,time,0,70) AS time, locf(min(value),(SELECT 100)) AS value FROM (values (20,9),(40,6)) v(time,value) GROUP BY 1 ORDER BY 1; -- test locf with different datatypes SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1)) AS text, locf(min(v2)) AS "int[]", locf(min(v3)) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; -- test locf with different datatypes and treat_null_as_missing SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(v1),treat_null_as_missing:=true) AS text, locf(min(v2),treat_null_as_missing:=true) AS "int[]", locf(min(v3),treat_null_as_missing:=true) AS "text 4/8k" FROM (VALUES (1,'foo',ARRAY[1,2,3],repeat('4k',2048)), (2,NULL,NULL,NULL), (3,'bar',ARRAY[3,4,5],repeat('8k',4096)) ) v(time,v1,v2,v3) GROUP BY 1; -- test interpolate SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(value)) AS value FROM (values (0,1),(50,6)) v(time,value) GROUP BY 1 ORDER BY 1; -- test interpolate with NULL values SELECT time_bucket_gapfill(1,time,0,5) AS time, interpolate(avg(temp)) AS temp FROM (VALUES (0,0),(2,NULL),(5,5)) v(time,temp) GROUP BY 1; -- test interpolate datatypes SELECT time_bucket_gapfill(10,time,0,50) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (0,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(50,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; -- test interpolate datatypes with negative time SELECT time_bucket_gapfill(10,time,-40,30) AS time, interpolate(min(v1)) AS "smallint", interpolate(min(v2)) AS "int", interpolate(min(v3)) AS "bigint", interpolate(min(v4)) AS "float4", interpolate(min(v5)) AS "float8" FROM (values (-40,-3::smallint,-3::int,-3::bigint,-3::float4,-3::float8),(20,3::smallint,3::int,3::bigint,3::float4,3::float8)) v(time,v1,v2,v3,v4,v5) GROUP BY 1 ORDER BY 1; -- test interpolate with multiple groupings SELECT time_bucket_gapfill(5,time,0,11), device, interpolate(min(v1),(SELECT (-10,-10)),(SELECT (20,10))) FROM (VALUES (5,1,0),(5,2,0)) as v(time,device,v1) GROUP BY 1,2 ORDER BY 2,1; -- test cte with gap filling in outer query WITH data AS ( SELECT * FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) ) SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM data GROUP BY 1,id; -- test cte with gap filling in inner query WITH gapfill AS ( SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ) SELECT * FROM gapfill; -- test window functions SELECT time_bucket_gapfill(10,time,0,60), interpolate(min(time)), lag(min(time)) OVER () FROM (VALUES (0),(50)) v(time) GROUP BY 1; -- test window functions with multiple windows SELECT time_bucket_gapfill(1,time,0,10), interpolate(min(time)), row_number() OVER (), locf(min(time)), sum(interpolate(min(time))) OVER (ROWS 1 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 2 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 3 PRECEDING), sum(interpolate(min(time))) OVER (ROWS 4 PRECEDING) FROM (VALUES (0),(9)) v(time) GROUP BY 1; -- test window functions with constants SELECT time_bucket_gapfill(1,time,0,5), min(time), 4 as c, lag(min(time)) OVER () FROM (VALUES (1),(2),(3)) v(time) GROUP BY 1; --test window functions with locf SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, locf(min(time)) AS locf, lag(locf(min(time))) over () AS lag_locf, lead(locf(min(time))) over () AS lead_locf FROM (VALUES (1),(2)) v(time) GROUP BY 1; --test window functions with interpolate SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, lead(min(time)) over () AS lead_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, lead(interpolate(min(time))) over () AS lead_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; --test window functions with expressions SELECT time_bucket_gapfill(1,time,0,5), min(time) AS "min", lag(min(time)) over () AS lag_min, 1 + lag(min(time)) over () AS lag_min, interpolate(min(time)) AS interpolate, lag(interpolate(min(time))) over () AS lag_interpolate, 1 + lag(interpolate(min(time))) over () AS lag_interpolate FROM (VALUES (1),(3)) v(time) GROUP BY 1; --test row_number/rank/percent_rank/... window functions with gapfill reference SELECT time_bucket_gapfill(1,time,0,5), ntile(2) OVER () AS ntile_2, ntile(3) OVER () AS ntile_3, ntile(5) OVER () AS ntile_5, row_number() OVER (), cume_dist() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), rank() OVER (), rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)), percent_rank() OVER (ORDER BY time_bucket_gapfill(1,time,0,5)) FROM (VALUES (1),(3)) v(time) GROUP BY 1; -- test first_value/last_value/nth_value SELECT time_bucket_gapfill(1,time,0,5), first_value(min(time)) OVER (), nth_value(min(time),3) OVER (), last_value(min(time)) OVER () FROM (VALUES (0),(2),(5)) v(time) GROUP BY 1; -- test window functions with PARTITION BY SELECT time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (), row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; -- test multiple windows \set ON_ERROR_STOP 0 SELECT time_bucket_gapfill(1,time,0,11), first_value(interpolate(min(time))) OVER (ROWS 1 PRECEDING), interpolate(min(time)), last_value(interpolate(min(time))) OVER (ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM (VALUES (0),(10)) v(time) GROUP BY 1; -- test reorder SELECT time_bucket_gapfill(1,time,0,5) as time, id, min(value) as m FROM (VALUES (1,1,1),(2,2,2)) v(time,id,value) GROUP BY 1,id ORDER BY 1,id; -- test order by locf SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; SELECT time_bucket_gapfill(1,time,1,6), locf(min(time)) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; -- test order by interpolate SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 1,2; SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS FIRST,1; SELECT time_bucket_gapfill(1,time,1,6), interpolate(min(time),prev:=(0,0)::record) FROM (VALUES (2),(3)) v(time) GROUP BY 1 ORDER BY 2 NULLS LAST,1; -- test queries on hypertable -- test locf and interpolate together SELECT time_bucket_gapfill(interval '1h',time,timestamptz '2018-01-01 05:00:00-8', timestamptz '2018-01-01 07:00:00-8'), device_id, locf(avg(v1)) AS locf_v1, locf(min(v2)) AS locf_v2, interpolate(avg(v1)) AS interpolate_v1, interpolate(avg(v2)) AS interpolate_v2 FROM metrics_tstz GROUP BY 1,2 ORDER BY 1,2; SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time < '2017-01-01' GROUP BY 1; SELECT time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz), interpolate( avg(v1), (SELECT ('2017-01-01'::timestamptz,1::float)), (SELECT ('2017-01-02'::timestamptz,2::float)) ) FROM metrics_tstz WHERE time_bucket_gapfill('12h'::interval,time,'2017-01-01'::timestamptz, '2017-01-02'::timestamptz) < '2017-01-01' GROUP BY 1; -- interpolation with correlated subquery lookup before interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 3:00 PST'::timestamptz, '2018-01-01 8:00 PST'::timestamptz), device_id, interpolate( avg(v1), (SELECT (time,0.5::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time DESC LIMIT 1) ), avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; -- interpolation with correlated subquery lookup after interval SELECT time_bucket_gapfill('1h'::interval,time,'2018-01-01 5:00 PST'::timestamptz, '2018-01-01 9:00 PST'::timestamptz), device_id, interpolate( avg(v1), next=>(SELECT (time,v2::float) FROM metrics_tstz m2 WHERE m1.device_id=m2.device_id ORDER BY time LIMIT 1) ),avg(v1) FROM metrics_tstz m1 WHERE device_id=1 GROUP BY 1,2 ORDER BY 1,2; \set ON_ERROR_STOP 0 -- bucket_width non simple expression SELECT time_bucket_gapfill(t,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- no start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- NULL start/finish and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- no start and no usable time constraints SELECT time_bucket_gapfill(1,t,finish:=1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- NULL start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- unsupported start expression and no usable time constraints SELECT time_bucket_gapfill(1,t,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- NULL start and no usable time constraints SELECT time_bucket_gapfill(1,t,NULL,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- NULL finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- unsupported finish expression and no usable time constraints SELECT time_bucket_gapfill(1,t,1,t) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- no finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- NULL finish and no usable time constraints SELECT time_bucket_gapfill(1,t,1,NULL) FROM (VALUES (1),(2)) v(t) WHERE true AND true GROUP BY 1; -- expression with column reference on right side SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > t AND t < 2 GROUP BY 1; -- expression with cast SELECT time_bucket_gapfill(1,t1::int8) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 >= 1 AND t1 <= 2 GROUP BY 1; -- expression with multiple column references SELECT time_bucket_gapfill(1,t1+t2) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 1 AND t1 < 2 GROUP BY 1; -- expression with NULL start in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END AND t1 < 4 GROUP BY 1; -- expression with NULL finish in WHERE clause, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < CASE WHEN length(version()) > 0 THEN NULL::int ELSE NULL::int END GROUP BY 1; -- non-Const NULL as start argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; -- non-Const NULL as finish argument, we use CASE to wrap the NULL so it doesnt get folded SELECT time_bucket_gapfill(1,t1,NULL,CASE WHEN length(version())>0 THEN NULL::int ELSE NULL::int END) FROM (VALUES (1,2),(2,2)) v(t1,t2) WHERE t1 > 0 AND t1 < 2 GROUP BY 1; -- time_bucket_gapfill with constraints ORed SELECT time_bucket_gapfill(1::int8,t::int8) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 OR t < 3 GROUP BY 1; \set ON_ERROR_STOP 1 -- int32 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; -- same query with less or equal as finish SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t <= 3 GROUP BY 1; -- int32 time_bucket_gapfill with start column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE -1 < t AND t < 3 GROUP BY 1; -- int32 time_bucket_gapfill with finish column and value switched SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= 0 AND 3 >= t GROUP BY 1; -- int16 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int2,t) FROM (VALUES (1::int2),(2::int2)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; -- int64 time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill(1::int8,t) FROM (VALUES (1::int8),(2::int8)) v(t) WHERE t >= -1 AND t < 3 GROUP BY 1; -- date time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('1d'::interval,t) FROM (VALUES ('1999-12-30'::date),('2000-01-01'::date)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; -- timestamp time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamp),('2000-01-01'::timestamp)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; -- timestamptz time_bucket_gapfill with no start/finish SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '1999-12-29' AND t < '2000-01-03' GROUP BY 1; -- timestamptz time_bucket_gapfill with more complex expression SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03' GROUP BY 1; -- timestamptz time_bucket_gapfill with different datatype in finish constraint SELECT time_bucket_gapfill('12h'::interval,t) FROM (VALUES ('1999-12-30'::timestamptz),('2000-01-01'::timestamptz)) v(t) WHERE t >= '2000-01-03'::timestamptz - '4d'::interval AND t < '2000-01-03'::date GROUP BY 1; -- time_bucket_gapfill with now() as start SELECT time_bucket_gapfill('1h'::interval,t) FROM (VALUES (now()),(now())) v(t) WHERE t >= now() AND t < now() - '1h'::interval GROUP BY 1; -- time_bucket_gapfill with multiple constraints SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t >= -1 AND t < 3 and t>1 AND t <=4 AND length(version()) > 0 GROUP BY 1; -- int32 time_bucket_gapfill with greater for start SELECT time_bucket_gapfill(1,t) FROM (VALUES (1),(2)) v(t) WHERE t > -2 AND t < 3 GROUP BY 1; -- test DISTINCT SELECT DISTINCT ON (color) time_bucket_gapfill(1,time,0,5) as time, color, min(value) as m FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color ORDER BY 2,1; -- test DISTINCT with window functions SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER () FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; -- test DISTINCT with window functions and PARTITION BY SELECT DISTINCT ON (color,row_number() OVER (PARTITION BY color)) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; -- test DISTINCT with window functions not in targetlist SELECT DISTINCT ON (row_number() OVER ()) time_bucket_gapfill(1,time,0,5) as time, color, row_number() OVER (PARTITION BY color) FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 1,color; -- test column references SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; -- test with Nested Loop SELECT l.id, bucket, data_value FROM (VALUES (1), (2), (3), (4)) a(id) INNER JOIN LATERAL ( SELECT b.id id, time_bucket_gapfill('1'::int, time, start=>'1'::int, finish=> '5'::int) bucket, locf(last(data, time)) data_value FROM (VALUES (1, 1, 1), (1, 4, 4), (2, 1, -1), (2, 4, -4)) b(id, time, data) WHERE a.id = b.id GROUP BY b.id, bucket ) as l on (true); -- test prepared statement PREPARE prep_gapfill AS SELECT time_bucket_gapfill(1,time,0,5) as time, locf(min(value)) FROM (VALUES (1,1),(2,2)) v(time,value) GROUP BY 1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; DEALLOCATE prep_gapfill; -- test column references with TIME_COLUMN last SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,4; -- test expressions on GROUP BY columns SELECT row_number() OVER (PARTITION BY color), locf(min(time)), color, length(color), time_bucket_gapfill(1,time,0,5) as time FROM (VALUES (1,'blue',1),(2,'red',2)) v(time,color,value) GROUP BY 3,5; -- test columns derived from GROUP BY columns with cast SELECT time_bucket_gapfill(1,time,0,5) as time, device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; -- test columns derived from GROUP BY columns with expression SELECT time_bucket_gapfill(1,time,0,5) as time, 'Device ' || device_id::text FROM (VALUES (1,1),(2,2)) v(time,device_id) GROUP BY 1,device_id; --test interpolation with big differences in values (test overflows in calculations) --we use the biggest possible difference in time(x) and the value(y). --For bigints we also test values of smaller than bigintmax/min to avoid --the symmetry where x=y (which catches more errors) SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset SELECT time_bucket_gapfill(1,time,0,1) AS time, interpolate(min(s)) AS "smallint", interpolate(min(i)) AS "int", interpolate(min(b)) AS "bigint", interpolate(min(b2)) AS "bigint2", interpolate(min(d)) AS "double" FROM (values (:big_int_min,(-32768)::smallint,(-2147483648)::int,:big_int_min,-2147483648::bigint, '-Infinity'::double precision), (:big_int_max, 32767::smallint, 2147483647::int,:big_int_max, 2147483647::bigint, 'Infinity'::double precision)) v(time,s,i,b,b2,d) GROUP BY 1 ORDER BY 1; -- issue #2232: This query used to trigger error "could not find -- pathkey item to sort" due to a corrupt query plan SELECT time_bucket_gapfill('1 h', time) AS time, locf(sum(v1)) AS v1_sum, interpolate(sum(v2)) AS v2_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; -- query without gapfill: SELECT time_bucket('1 h', time) AS time, sum(v1) AS v1_sum, sum(v2) AS v1_sum FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' GROUP BY 1 ORDER BY 1 DESC; -- query to show original data SELECT * FROM metrics_tstz WHERE time >= '2018-01-01 04:00' AND time < '2018-01-01 08:00' ORDER BY 1 DESC, 2; -- issue #3048 -- test gapfill/hashagg planner interaction -- this used to produce a plan without gapfill node EXPLAIN (buffers off, costs off) SELECT time_bucket_gapfill('52w', time, start:='2000-01-01', finish:='2000-01-10') AS time, sum(v1) AS v1_sum FROM metrics GROUP BY 1; -- issue #3834 -- test projection handling in gapfill CREATE TABLE i3834(time timestamptz NOT NULL, ship_id int, value float); SELECT table_name FROM create_hypertable('i3834','time'); INSERT INTO i3834 VALUES ('2020-12-01 14:05:00+01',1,3.123), ('2020-12-01 14:05:00+01',2,4.123), ('2020-12-01 14:05:00+01',3,5.123); SELECT time_bucket_gapfill('30000 ms'::interval, time) AS time, ship_id, interpolate (avg(value)), 'speedlog' AS source FROM i3834 WHERE ship_id IN (1, 2) AND time >= '2020-12-01 14:05:00+01' AND time < '2020-12-01 14:10:00+01' GROUP BY 1,2; DROP TABLE i3834; -- issue #1528 -- test float rounding for certain float values when start and end are identical SELECT time_bucket_gapfill('1min'::interval, ts::timestamptz, start:='2019-11-05 2:20', finish:='2019-11-05 2:30'), interpolate(avg(20266.959547::float4)) AS float4, interpolate(avg(20266.959547::float8)) AS float8 FROM (VALUES ('2019-11-05 2:20'), ('2019-11-05 2:30')) v (ts) GROUP BY 1; -- check gapfill group change detection with TOASTed values CREATE TABLE gapfill_group_toast(time timestamptz NOT NULL, device text, value float); SELECT table_name FROM create_hypertable('gapfill_group_toast', 'time'); INSERT INTO gapfill_group_toast SELECT generate_series('2022-06-01'::timestamptz, '2022-06-03'::timestamptz, '1min'::interval), '4e0ee04cc6a94fd40497b8dbaac2fe434e0ee04cc6a94fd40497b8dbaac2fe43', random(); ALTER TABLE gapfill_group_toast SET(timescaledb.compress, timescaledb.compress_segmentby = 'device'); SELECT count(compress_chunk(c)) FROM show_chunks('gapfill_group_toast') c; SELECT time_bucket_gapfill('1 day', time), device FROM gapfill_group_toast WHERE time >= '2022-06-01' AND time <= '2022-06-02' GROUP BY 1,2; DROP TABLE gapfill_group_toast; -- test bucketing by month SELECT time_bucket_gapfill('2 month'::interval, ts, '2000-01-01'::timestamptz,'2001-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; SELECT time_bucket_gapfill('1 year'::interval, ts, '2000-01-01'::timestamptz,'2003-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; SELECT time_bucket_gapfill('1 century'::interval, ts, '1900-01-01'::timestamptz,'2103-01-01'::timestamptz) FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; -- test bucketing with timezone SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; SELECT time_bucket_gapfill('2 month'::interval, ts, current_setting('timezone'), '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; SELECT time_bucket_gapfill('2 month'::interval, ts, 'UTC', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; SET timezone TO 'Europe/Berlin'; SELECT time_bucket_gapfill('2 month'::interval, ts, 'Europe/Berlin', '2000-01-01','2001-01-01') FROM (VALUES ('2000-03-01'::timestamptz)) v(ts) GROUP BY 1; RESET timezone; -- Test gapfill with arrays (#5981) SELECT time_bucket_gapfill(5, ts, 1, 100) as ts, int_arr, locf(last(value, ts)) FROM ( SELECT ARRAY[1,2,3,4]::int[] as int_arr, x as ts, x+500000 as value FROM generate_series(1, 10, 100) as x ) t GROUP BY 1, 2; -- Test gapfill is aligned with non-gapfill time_bucket -- when using different timezones and month bucketing CREATE TABLE month_timezone(time timestamptz NOT NULL, value float); SELECT table_name FROM create_hypertable('month_timezone','time'); INSERT INTO month_timezone VALUES ('2023-03-01 14:05:00+01', 3.123), ('2023-04-01 14:05:00+01',4.123), ('2023-05-01 14:05:00+01', 5.123); SELECT time_bucket_gapfill('1 month'::interval, time, 'Europe/Berlin', '2023-01-01', '2023-07-01') AS time, sum(value) FROM month_timezone GROUP BY 1; -- Test gapfill respects DST changes when generating timestamps (#6344) SELECT time_bucket_gapfill('1 month', time, 'awst','2023-01-01', '2023-07-01' ) AS month, sum(value) AS sum FROM month_timezone GROUP BY 1; DROP TABLE month_timezone; -- Test gapfill with additional group pathkeys added for optimization (#6396) CREATE TABLE stocks_real_time ( time TIMESTAMPTZ NOT NULL, symbol TEXT NOT NULL, price DOUBLE PRECISION NULL, day_volume INT NULL ); INSERT INTO stocks_real_time VALUES (NOW(), 's1', 70.0, 50), (NOW(), 's2', 66.5, 60), (NOW(), 's3', 77.0, 65); SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1; SELECT time_bucket_gapfill('1 day', time) AS day, COUNT(DISTINCT symbol) AS symbol_count FROM stocks_real_time WHERE time > '2023-12-01' AND time < '2023-12-10' GROUP BY 1 ORDER BY 1 DESC; DROP TABLE stocks_real_time; SET timezone TO 'Europe/Berlin'; -- check dst switching is handled correctly #6788 SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; SELECT time_bucket_gapfill('30 minutes', time, 'Europe/Berlin', '2024-03-31T0:00Z', '2024-03-31T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; SELECT time_bucket_gapfill('1h', time, 'Europe/Berlin', '2024-10-26T23:00Z', '2024-10-27T02:00Z') FROM (SELECT NULL::timestamptz AS time LIMIT 0) s GROUP BY 1; RESET timezone; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/gapfill_bug.sql����������������������������������������������0000664�0000000�0000000�00000026501�15100345067�0022701�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Fix for issue #6078: crash in "time_bucket_gapfil" -- with "locf" using NULL value and NULLs treated as missing. create table tw(id varchar, time timestamp, value float); insert into tw values ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400); SET timezone TO 'Europe/Berlin'; -- Losf lookup query being a SubPlan as it has a predicate over correlated variable -- We call Locf calculation for a "gapfill_start" tuple retrived from the input to override its NULL value, -- rather than for a tuple generated to fill the gaps. -- We used to crash in this scenario due to pointing to a wrong tuple slot. Should work OK now. SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM tw AS p WHERE p.id = tw.id ORDER BY 1 LIMIT 1), true) AS value FROM tw GROUP BY 1,2; -- Should return same result for simpler Losf lookup query SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM tw AS p ORDER BY 1 LIMIT 1), true) AS value FROM tw GROUP BY 1,2; -- Should return same result when using CTE instead of input table WITH data (id, time, value) AS ( VALUES ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400) ) SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM data AS p WHERE p.id = data.id ORDER BY 1 LIMIT 1), true) AS value FROM data GROUP BY 1,2; -- Pick an average value instead of min WITH data (id, time, value) AS ( VALUES ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400) ) SELECT id, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT avg(p.value) FROM data AS p WHERE p.id = data.id), true) AS value FROM data GROUP BY 1,2; -- Call Locf both for filling gaps and setting the non-NULL value for "gapfill_start" tuple WITH data (id, time, value) AS ( VALUES ('uuid', '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', '2023-09-15 12:52', 149400) ) SELECT id, time_bucket_gapfill('1min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT avg(p.value) FROM data AS p WHERE p.id = data.id), true) AS value FROM data GROUP BY 1,2; -- Use Locf lookup for multiple groupby values, use 2nd groupby column as a correlation var in the lookup -- Make sure correlation var is obtained from correct tuple passed to Locf lookup expression WITH data (id, gr, time, value) AS ( VALUES ('uuid', 12, '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', 14, '2023-09-15 12:52', 149400) ) SELECT id, gr, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM data AS p where p.gr = data.gr ORDER BY 1 desc LIMIT 1), true) AS value FROM data GROUP BY 1,2,3 ORDER BY 1,2,3; -- Same but use two correlation vars in Locf lookup WITH data (id, gr, time, value) AS ( VALUES ('uuid', 12, '2023-09-15 12:00'::timestamp, 147673::float), ('uuid', 14, '2023-09-15 12:52', 149400) ) SELECT id, gr, time_bucket_gapfill('10min'::interval, time, '2023-09-15 12:50', '2023-09-15 12:53') AS bucket, locf(null::float, (SELECT p.value FROM data AS p where p.gr = data.gr and p.id = data.id ORDER BY 1 desc LIMIT 1), true) AS value FROM data GROUP BY 1,2,3 ORDER BY 1,2,3; drop table tw cascade; RESET timezone; -- Fix for 2nd issue reported in #4894: "time_bucket_gapfil" with "locf/interpolate" -- using out-of-order and repeated columns, resulting in below error: -- ERROR: attribute 5 of type record has wrong type -- Should return correct data with no error WITH el_data(time,position_id,measurement_value,measurement_type,src_mac_id,stream_index,delta) AS( VALUES ('2025-07-05 23:57:19.000000 +00:00'::timestamptz,'2da82d12-5ceb-4470-b60b-9660b755d052'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:12:19.000000 +00:00'::timestamptz,'2da82d12-5ceb-4470-b60b-9660b755d052'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-901), ('2025-07-06 00:27:20.000000 +00:00'::timestamptz,'2da82d12-5ceb-4470-b60b-9660b755d052'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110560), ('2025-07-06 00:06:12.000000 +00:00'::timestamptz,'9f2e566b-8c26-4ead-ad24-12841c79a932'::uuid,25.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:21:12.000000 +00:00'::timestamptz,'9f2e566b-8c26-4ead-ad24-12841c79a932'::uuid,25.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110928), ('2025-07-06 00:02:57.000000 +00:00'::timestamptz,'09ca0d92-1eb5-4d07-adbc-2bb500817cc7'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-901), ('2025-07-06 00:17:58.000000 +00:00'::timestamptz,'09ca0d92-1eb5-4d07-adbc-2bb500817cc7'::uuid,26.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3111122), ('2025-07-06 00:06:02.000000 +00:00'::timestamptz,'e0145b95-6faa-4eb3-815d-5d0a91ba909c'::uuid,24::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:21:02.000000 +00:00'::timestamptz,'e0145b95-6faa-4eb3-815d-5d0a91ba909c'::uuid,24::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110938), ('2025-07-06 00:04:48.000000 +00:00'::timestamptz,'d439a8fc-7285-4d32-82bc-2105c9ed2d52'::uuid,24::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:19:48.000000 +00:00'::timestamptz,'d439a8fc-7285-4d32-82bc-2105c9ed2d52'::uuid,24.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3111012), ('2025-07-06 00:07:00.000000 +00:00'::timestamptz,'4aa9b368-b9c4-4b15-bfcc-c67b1931dd11'::uuid,25::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:22:00.000000 +00:00'::timestamptz,'4aa9b368-b9c4-4b15-bfcc-c67b1931dd11'::uuid,24.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110880), ('2025-07-06 00:08:03.000000 +00:00'::timestamptz,'64dc15d6-3988-4320-8f18-16ef8512990e'::uuid,30.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-900), ('2025-07-06 00:23:03.000000 +00:00'::timestamptz,'64dc15d6-3988-4320-8f18-16ef8512990e'::uuid,30.5::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-3110817), ('2025-07-05 23:57:13.000000 +00:00'::timestamptz,'bb044d29-c136-412d-a193-354f090dafcb'::uuid,23::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-300), ('2025-07-06 00:02:13.000000 +00:00'::timestamptz,'bb044d29-c136-412d-a193-354f090dafcb'::uuid,23::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-300), ('2025-07-06 00:07:13.000000 +00:00'::timestamptz,'bb044d29-c136-412d-a193-354f090dafcb'::uuid,23::numeric,'temperature_ambient','FFFF000D6F4DA7B2',3,-300) ) , el_nodes_data(time,src_mac_id,stream_index,position_id,measurement_type,measurement_value) as( VALUES ('2025-07-05 23:42:20.000000 +00:00'::timestamptz,'FFFF000D6F4DA7B2',3,'2da82d12-5ceb-4470-b60b-9660b755d052','temperature_ambient',26::numeric), ('2025-07-06 00:51:09.000000 +00:00'::timestamptz,'FFFF000D6F4DA7B2',3,'2da82d12-5ceb-4470-b60b-9660b755d052','temperature_ambient',26::numeric) ) SELECT time_bucket_gapfill('5 minutes', m.time, start := '2025-07-05 23:55:00+00:00'::timestamptz, finish := '2025-07-06 00:30:00+00:00'::timestamptz) AS intervals, m.position_id, m.src_mac_id, m.stream_index, m.measurement_type, m.stream_index, locf(last(m.measurement_value, m.time) , (SELECT d2.measurement_value FROM el_nodes_data d2 WHERE d2.measurement_type = m.measurement_type AND d2.src_mac_id = m.src_mac_id AND d2.stream_index = m.stream_index AND d2.time < '2025-07-05 23:55:00+00:00' AND d2.time > '2025-07-05 23:55:00+00:00'::timestamptz - INTERVAL '30 minutes' ORDER BY d2.time DESC LIMIT 1) ) AS locf_measurement_value FROM el_data m GROUP BY time_bucket_gapfill('5 minutes', m.time, start := '2025-07-05 23:55:00+00:00'::timestamptz, finish := '2025-07-06 00:30:00+00:00'::timestamptz), -- avoid alias here m.position_id,m.src_mac_id, m.stream_index, m.measurement_type ORDER BY time_bucket_gapfill('5 minutes', m.time, start := '2025-07-05 23:55:00+00:00'::timestamptz, finish := '2025-07-06 00:30:00+00:00'::timestamptz), -- avoid alias here m.position_id,m.src_mac_id, m.stream_index, m.measurement_type; -- Fix for #4894: gapfill error over aggregates in expressions with groupby columns and columns out of order CREATE TABLE hourly ( time timestamptz NOT NULL, signal smallint NOT NULL, value real, level_a integer, level_b smallint, level_c smallint, agg smallint ); INSERT into hourly(time, signal,value, level_a, level_b, level_c, agg) values ('2022-10-01T00:00:00Z', 2, 685, 1, -1, -1, 2 ), ('2022-10-01T00:00:00Z', 2, 686, 1, -1, -1, 3 ), ('2022-10-01T02:00:00Z', 2, 686, 1, -1, -3, 2 ), ('2022-10-01T02:00:00Z', 2, 687, 1, -1, -1, 3 ), ('2022-10-01T03:00:00Z', 2, 687, 1, -1, -3, 2 ), ('2022-10-01T03:00:00Z', 2, 688, 1, -1, -1, 3 ); -- Expression over 1 aggregate and 1 groupby column SELECT time_bucket_gapfill('1 hour', time) as time, CASE WHEN agg in (0,3) THEN max(value) ELSE null END as max, CASE WHEN agg in (0,2) THEN min(value) ELSE null END as min FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b >= -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg order by 1,2,3; -- Expression over 2 aggregates and 1 groupby column SELECT time_bucket_gapfill('1 hour', time) as time, CASE WHEN agg in (0,3) THEN max(value) ELSE min(level_c) END as maxmin FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg order by 1,2; -- Expression over 2 aggregates and 2 groupby columns SELECT time_bucket_gapfill('1 hour', time) as time, CASE WHEN agg in (0,3) THEN max(value) ELSE min(level_c)+signal END as maxmin FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg, signal order by 1,2; -- Expressions over aggregates and complex groupby expressions SELECT time_bucket_gapfill('1 hour', time) as time, max(value)+(agg+1) FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg+1 order by 1,2; SELECT time_bucket_gapfill('1 hour', time) as time, max(value)+(agg+1)+(agg+1+1) FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg+1, agg+1+1 order by 1,2; SELECT time_bucket_gapfill('1 hour', time) as time, max(value) + (agg+signal) maxv, min(value) - (agg+signal) minv, agg+signal FROM hourly WHERE agg in (0,2,3) and signal in (2) AND level_a = 1 AND level_b = -1 AND time >= '2022-10-01T00:00:00Z' AND time < '2022-10-01T05:59:59Z' GROUP BY 1, agg+signal order by 1,2,3; drop table hourly cascade; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/generated_columns.sql����������������������������������������0000664�0000000�0000000�00000003023�15100345067�0024116�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE gencol_tab ( a INT NOT NULL, b INT, c INT GENERATED ALWAYS AS (a + b) STORED ); SELECT table_name FROM create_hypertable('gencol_tab', 'a', chunk_time_interval=>10); INSERT INTO gencol_tab(a, b) VALUES(1, 2); INSERT INTO gencol_tab(a, b) VALUES(2, 3); -- Ensure generated column cannot be updated \set ON_ERROR_STOP 0 INSERT INTO gencol_tab VALUES(3, 5, 8); \set ON_ERROR_STOP 1 SELECT * FROM gencol_tab ORDER BY a; DROP TABLE gencol_tab; -- Ensure that generated column cannot be used for partitioning -- Generated as expression CREATE TABLE gencol_test ( a INT NOT NULL, b INT GENERATED ALWAYS AS (a + 123) STORED ); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('gencol_test', 'a', 'b', 2, chunk_time_interval=>10); \set ON_ERROR_STOP 1 -- check if default generated expression can be dropped (works on >= PG13) SELECT table_name FROM create_hypertable('gencol_test', 'a', chunk_time_interval=>10); SELECT attname, atthasdef, attidentity, attgenerated, attnotnull FROM pg_attribute where attname = 'b' and attrelid = 'gencol_test'::regclass; \set ON_ERROR_STOP 0 ALTER TABLE gencol_test ALTER COLUMN b DROP EXPRESSION; \set ON_ERROR_STOP 1 SELECT attname, atthasdef, attidentity, attgenerated, attnotnull FROM pg_attribute where attname = 'b' and attrelid = 'gencol_test'::regclass; DROP TABLE gencol_test; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/�����������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0021324�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/cagg_compression_query.sql���������������������������0000664�0000000�0000000�00000001664�15100345067�0026623�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT * FROM :TEST_TABLE1 m INNER JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m NATURAL JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m LEFT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m RIGHT JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m FULL JOIN :TEST_TABLE2 d USING (device_id) ORDER BY m.bucket, m.device_id; SELECT * FROM :TEST_TABLE1 m CROSS JOIN :TEST_TABLE2 d ORDER BY m.bucket, m.device_id, d.device_id; SELECT * FROM :TEST_TABLE1 m JOIN LATERAL (SELECT * FROM :TEST_TABLE2 d WHERE d.device_id = m.device_id) AS d ON true ORDER BY m.bucket, m.device_id; ����������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/cagg_compression_setup.sql���������������������������0000664�0000000�0000000�00000006326�15100345067�0026616�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE extra_devices(device_id INT, name TEXT); INSERT INTO extra_devices VALUES (4,'Device 4'),(5,'Device 5'); --add a device id that is not in metrics or metrics_compressed -- need this for outer joins INSERT INTO extra_devices VALUES ( 333,'Device New 333'); CREATE VIEW all_devices AS SELECT * FROM devices UNION SELECT * FROM extra_devices; -- Compressed CAgg + Compressed Hypertable CREATE MATERIALIZED VIEW metrics_compressed_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT device_id, time_bucket(INTERVAL '1 week', time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics_compressed GROUP BY device_id, bucket WITH NO DATA; -- Force more than one chunk in the materialized hypertable SELECT set_chunk_time_interval( format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name), '1 week'::interval ) FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_compressed_summary'; ALTER MATERIALIZED VIEW metrics_compressed_summary SET (timescaledb.compress); CALL refresh_continuous_aggregate('metrics_compressed_summary', NULL, '2000-01-15 23:55:00+0'); SELECT CASE WHEN res is NULL THEN NULL ELSE 'compressed' END as comp FROM ( SELECT compress_chunk(show_chunks('metrics_compressed_summary')) res ) q; -- Check for realtime caggs SELECT count(*) FROM metrics_compressed_summary WHERE bucket > _timescaledb_functions.to_timestamp( _timescaledb_functions.cagg_watermark( (SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'metrics_compressed_summary') ) ); -- Compressed CAgg + Uncompressed Hypertable CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT device_id, time_bucket(INTERVAL '1 week', time) AS bucket, AVG(v2), MIN(v2), MAX(v2) FROM metrics GROUP BY device_id, bucket WITH NO DATA; -- Force more than one chunk in the materialized hypertable SELECT set_chunk_time_interval( format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name), '1 week'::interval ) FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_summary'; ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.compress); CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-15 23:55:00+0'); SELECT CASE WHEN res is NULL THEN NULL ELSE 'compressed' END as comp FROM ( SELECT compress_chunk(show_chunks('metrics_summary')) res ) q; -- Check for realtime caggs SELECT count(*) FROM metrics_summary WHERE bucket > _timescaledb_functions.to_timestamp( _timescaledb_functions.cagg_watermark( (SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'metrics_summary') ) ); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/constraint_exclusion_prepared_query.sql��������������0000664�0000000�0000000�00000004612�15100345067�0031434�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test prepared statements -- executor startup exclusion with no chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < now() AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- executor startup exclusion with chunks excluded PREPARE prep AS SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz AND device_id = 1 ORDER BY time LIMIT 100; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- runtime exclusion with LATERAL and 2 hypertables SET enable_seqscan TO false; PREPARE prep AS SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL ( SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON TRUE WHERE device_id = 2 ORDER BY m1.time LIMIT 100; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; RESET enable_seqscan; -- executor startup exclusion with subquery PREPARE prep AS SELECT time FROM ( SELECT time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY time LIMIT 100) m; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- test constraint exclusion for subqueries with ConstraintAwareAppend SET timescaledb.enable_chunk_append TO FALSE; PREPARE prep AS SELECT device_id, time FROM ( SELECT device_id, time FROM :TEST_TABLE WHERE time < '2000-01-10'::text::timestamptz ORDER BY device_id, time LIMIT 100) m; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; RESET timescaledb.enable_chunk_append; -- test prepared statement with params and generic plan SET plan_cache_mode TO force_generic_plan; PREPARE prep(timestamptz) AS SELECT device_id, time FROM :TEST_TABLE WHERE time = $1 ORDER BY device_id, time; :PREFIX EXECUTE prep('2000-01-01 23:42'); :PREFIX EXECUTE prep('2000-01-10 23:42'); :PREFIX EXECUTE prep(now()); DEALLOCATE prep; RESET plan_cache_mode; ����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/gapfill_metrics_query.sql����������������������������0000664�0000000�0000000�00000016424�15100345067�0026445�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test locf lookup query does not trigger when not needed -- -- 1/(SELECT 0) will throw an error in the lookup query but in order to not -- always trigger evaluation it needs to be correlated otherwise postgres will -- always run it once even if the value is never used SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3 ORDER BY 2,3,1; -- test locf with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value)::int,23) AS locf1, locf(min(value)::int,(SELECT 42)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- test locf with correlated subquery and "wrong order" SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), locf(min(value)) AS locf, locf(min(value),23::float) AS locf1, locf(min(value),(SELECT 42::float)) AS locf2, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) AS locf3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 1,2,3; -- test locf with correlated subquery and window functions SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)), sum(locf(min(value),(SELECT value FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1))) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3; -- test JOINs SELECT time_bucket_gapfill(1,time,0,5) as time, device_id, d.name, sensor_id, s.name, avg(m.value) FROM :METRICS m INNER JOIN devices d USING(device_id) INNER JOIN sensors s USING(sensor_id) WHERE time BETWEEN 0 AND 5 GROUP BY 1,2,3,4,5; -- test interpolate with correlated subquery SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, avg(value), interpolate(min(value)) AS ip, interpolate(min(value),(-5,-5.0::float),(15,20.0::float)) AS ip1, interpolate(min(value),(SELECT (-10,-10.0::float)),(SELECT (15,20.0::float))) AS ip2, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) AS ip3 FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- test interpolate with correlated subquery and window function SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ), sum(interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) )) OVER (PARTITION BY device_id, sensor_id ROWS 1 PRECEDING) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- test subqueries -- subqueries will alter the shape of the plan and top-level constraints -- might not end up in top-level of jointree SELECT time_bucket_gapfill(1,m1.time) FROM :METRICS m1 WHERE m1.time >=0 AND m1.time < 2 AND device_id IN (SELECT device_id FROM :METRICS) GROUP BY 1; -- test inner join with constraints in join condition SELECT time_bucket_gapfill(1,m2.time) FROM :METRICS m1 INNER JOIN :METRICS m2 ON m1.time=m2.time AND m2.time >=0 AND m2.time < 2 GROUP BY 1; -- test actual table SELECT time_bucket_gapfill(1,time) FROM :METRICS WHERE time >=0 AND time < 2 GROUP BY 1; -- test with table alias SELECT time_bucket_gapfill(1,time) FROM :METRICS m WHERE m.time >=0 AND m.time < 2 GROUP BY 1; -- test with 2 tables SELECT time_bucket_gapfill(1,m.time) FROM :METRICS m, :METRICS m2 WHERE m.time >=0 AND m.time < 2 GROUP BY 1; -- test prepared statement with locf with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, locf(min(value)::int,(SELECT 1/(SELECT 0) FROM :METRICS m2 WHERE m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1)) FROM :METRICS m1 WHERE time >= 0 AND time < 5 GROUP BY 1,2,3; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; DEALLOCATE prep_gapfill; -- test prepared statement with interpolate with lookup query PREPARE prep_gapfill AS SELECT time_bucket_gapfill(5,time,0,11) AS time, device_id, sensor_id, interpolate( min(value), (SELECT (time,value) FROM :METRICS m2 WHERE time<0 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time DESC LIMIT 1), (SELECT (time,value) FROM :METRICS m2 WHERE time>10 AND m2.device_id=m1.device_id AND m2.sensor_id=m1.sensor_id ORDER BY time LIMIT 1) ) FROM :METRICS m1 WHERE time >= 0 AND time < 10 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; EXECUTE prep_gapfill; DEALLOCATE prep_gapfill; -- test prepared statement with variable gapfill arguments PREPARE prep_gapfill(int,int,int) AS SELECT time_bucket_gapfill($1,time,$2,$3) AS time, device_id, sensor_id, min(value) FROM :METRICS m1 WHERE time >= $2 AND time < $3 AND device_id=1 AND sensor_id=1 GROUP BY 1,2,3 ORDER BY 2,3,1; -- execute 10 times to make sure turning it into generic plan works EXECUTE prep_gapfill(5,0,10); EXECUTE prep_gapfill(4,100,110); EXECUTE prep_gapfill(5,0,10); EXECUTE prep_gapfill(4,100,110); EXECUTE prep_gapfill(5,0,10); EXECUTE prep_gapfill(4,100,110); EXECUTE prep_gapfill(5,0,10); EXECUTE prep_gapfill(4,100,110); EXECUTE prep_gapfill(5,0,10); EXECUTE prep_gapfill(4,100,110); DEALLOCATE prep_gapfill; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/memoize_query.sql������������������������������������0000664�0000000�0000000�00000000564�15100345067�0024744�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW enable_memoize; :PREFIX SELECT m1.time, m2.time FROM :TEST_TABLE m1 LEFT JOIN LATERAL (SELECT time FROM :TEST_TABLE m2 WHERE m1.time = m2.time LIMIT 1) m2 ON true ORDER BY m1.time; ��������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/ordered_append_join.sql������������������������������0000664�0000000�0000000�00000015570�15100345067�0026047�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; SET enable_nestloop TO on; -- test LATERAL with ordered append in the outer query :PREFIX SELECT time, pg_typeof(l) FROM :TEST_TABLE, LATERAL ( SELECT * FROM ( VALUES (1), (2)) v) l ORDER BY time DESC LIMIT 2; -- test LATERAL with ordered append in the lateral query :PREFIX SELECT time, pg_typeof(v) FROM ( VALUES (1), (2)) v, LATERAL ( SELECT * FROM :TEST_TABLE ORDER BY time DESC LIMIT 2) l; SET enable_nestloop TO off; -- test plan with best index is chosen -- this should use device_id, time index :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC LIMIT 1; -- test plan with best index is chosen -- this should use time index :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; SET enable_nestloop TO on; -- test LATERAL with correlated query -- only last chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time DESC LIMIT 1) l ON TRUE; -- test LATERAL with correlated query -- only 2nd chunk should be executed :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-10'::timestamptz, '2000-01-11', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval ORDER BY time LIMIT 1) l ON TRUE; -- test startup and runtime exclusion together :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time < now() ORDER BY time DESC LIMIT 1) l ON TRUE; -- test startup and runtime exclusion together -- all chunks should be filtered :PREFIX SELECT g.time, l.time FROM generate_series('2000-01-01'::timestamptz, '2000-01-03', '1d') AS g (time) LEFT OUTER JOIN LATERAL ( SELECT * FROM :TEST_TABLE o WHERE o.time >= g.time AND o.time < g.time + '1d'::interval AND o.time > now() ORDER BY time DESC LIMIT 1) l ON TRUE; -- test JOIN -- no exclusion on joined table because quals are not propagated yet -- With PG 14 on i368, this query uses a nested loop join. Disable the nested loop join to get the same query plan in all tests SET enable_nestloop TO off; :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.time < '2000-02-01' AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time; -- test JOIN -- last chunk of o2 should not be executed :PREFIX SELECT o1.time, o2.time FROM :TEST_TABLE o1 INNER JOIN ( SELECT * FROM :TEST_TABLE o2 ORDER BY time) o2 ON o1.time = o2.time WHERE o1.time < '2000-01-08' ORDER BY o1.time LIMIT 10; -- test join against max query -- not ChunkAppend so no chunk exclusion SET enable_hashjoin = FALSE; SET enable_hashagg = FALSE; :PREFIX SELECT o1.time, o2.* FROM :TEST_TABLE o1 INNER JOIN ( SELECT max(time) AS max_time FROM :TEST_TABLE) o2 ON o1.time = o2.max_time WHERE o1.device_id = 1 ORDER BY time; RESET enable_hashjoin; RESET enable_hashagg; SET enable_seqscan TO false; -- test JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test JOIN on time column with USING -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 USING (time) WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test NATURAL JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 NATURAL INNER JOIN :TEST_TABLE o2 WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test LEFT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 LEFT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test RIGHT JOIN on time column -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 RIGHT JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; -- test JOIN on time column with ON clause expression order switched -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o2.time = o1.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test JOIN on time column with equality condition in WHERE clause -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON TRUE WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test JOIN on time column with ORDER BY 2nd hypertable -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time WHERE o1.device_id = 1 AND o2.device_id = 2 ORDER BY o2.time LIMIT 100; -- test JOIN on time column and device_id -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id AND o1.time = o2.time ORDER BY o1.time LIMIT 100; -- test JOIN on device_id -- should not use ordered append for 2nd hypertable :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.device_id = o2.device_id WHERE o1.device_id = 1 ORDER BY o1.time LIMIT 100; -- test JOIN on time column with implicit join -- should use 2 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1, :TEST_TABLE o2 WHERE o1.time = o2.time AND o1.device_id = 1 AND o2.device_id = 2 ORDER BY o1.time LIMIT 100; -- test JOIN on time column with 3 hypertables -- should use 3 ChunkAppend :PREFIX SELECT o1.time FROM :TEST_TABLE o1 INNER JOIN :TEST_TABLE o2 ON o1.time = o2.time INNER JOIN :TEST_TABLE o3 ON o1.time = o3.time WHERE o1.device_id = 1 AND o2.device_id = 2 AND o3.device_id = 3 ORDER BY o1.time LIMIT 100; RESET enable_seqscan; ����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/include/shared_setup.sql�������������������������������������0000664�0000000�0000000�00000022674�15100345067�0024546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET client_min_messages TO ERROR; GRANT CREATE ON SCHEMA public TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- this is a noop in our regression tests but allows us to use this -- dataset more easily in other tests like the sqlsmith test SELECT current_database() AS "TEST_DBNAME" \gset CREATE SCHEMA test; -- create normal hypertable with dropped columns, each chunk will have different attribute numbers CREATE TABLE metrics(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics','time',create_default_indexes:=false); ALTER TABLE metrics DROP COLUMN filler_1; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics(time DESC); CREATE INDEX ON metrics(device_id,time DESC); ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space','time','device_id',3,create_default_indexes:=false); ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space(time); CREATE INDEX ON metrics_space(device_id,time); ANALYZE metrics_space; -- create hypertable with compression CREATE TABLE metrics_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_compressed','time',create_default_indexes:=false); ALTER TABLE metrics_compressed DROP COLUMN filler_1; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_2; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_3; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_compressed(time); CREATE INDEX ON metrics_compressed(device_id,time); -- compress chunks ALTER TABLE metrics_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_compressed')); UPDATE metrics_compressed SET v3 = 42 WHERE device_id=1 AND time > '2000-01-01' AND time < '2000-01-02'; VACUUM ANALYZE metrics_compressed; -- create hypertable with space partitioning and compression CREATE TABLE metrics_space_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space_compressed','time','device_id',3,create_default_indexes:=false); ALTER TABLE metrics_space_compressed DROP COLUMN filler_1; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_2; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_3; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space_compressed(time); CREATE INDEX ON metrics_space_compressed(device_id,time); ANALYZE metrics_space_compressed; -- compress chunks ALTER TABLE metrics_space_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_space_compressed')); -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_6; CREATE TABLE metrics_int( time int NOT NULL, device_id int, sensor_id int, value float); INSERT INTO metrics_int VALUES (-100,1,1,0.0), (-100,1,2,-100.0), (0,1,1,5.0), (5,1,2,10.0), (100,1,1,0.0), (100,1,2,-100.0); CREATE TABLE devices(device_id INT, name TEXT); INSERT INTO devices VALUES (1,'Device 1'),(2,'Device 2'),(3,'Device 3'); CREATE TABLE sensors(sensor_id INT, name TEXT); INSERT INTO sensors VALUES (1,'Sensor 1'),(2,'Sensor 2'),(3,'Sensor 3'); CREATE TABLE metrics_tstz(time timestamptz, device_id INT, v1 float, v2 int); SELECT create_hypertable('metrics_tstz','time'); INSERT INTO metrics_tstz VALUES (timestamptz '2018-01-01 05:00:00 PST', 1, 0.5, 10), (timestamptz '2018-01-01 05:00:00 PST', 2, 0.7, 20), (timestamptz '2018-01-01 05:00:00 PST', 3, 0.9, 30), (timestamptz '2018-01-01 07:00:00 PST', 1, 0.0, 0), (timestamptz '2018-01-01 07:00:00 PST', 2, 1.4, 40), (timestamptz '2018-01-01 07:00:00 PST', 3, 0.9, 30) ; -- scramble index column names -- -- index column names must never be used to match between relation columns and index columns -- to catch any such bugs, we scramble the index column names in regresscheck-shared DO $$ DECLARE i regclass; colname name; BEGIN FOR i IN SELECT c.oid FROM pg_class c WHERE c.relkind='i' AND c.relnamespace IN ( 'public'::regnamespace, '_timescaledb_internal'::regnamespace ) AND c.relname NOT IN ( 'bgw_job_stat_pkey', 'bgw_job_stat_history_pkey', 'bgw_job_stat_history_job_id_idx', 'bgw_policy_chunk_stats_job_id_chunk_id_key' ) LOOP FOR colname IN SELECT a.attname FROM pg_attribute a WHERE a.attrelid = i ORDER BY a.attnum LOOP EXECUTE format('ALTER TABLE %s RENAME COLUMN %I TO %s', i, colname, format('XyZ_%s', colname)); END LOOP; END LOOP; END$$; CREATE MATERIALIZED VIEW hourly_device_metrics WITH (tsdb.continuous) AS SELECT time_bucket('1 hour', time) AS hour, d.device_id, d.name AS device_name, AVG(v0) AS avg_v0, MAX(v1) AS max_v1, MIN(v2) AS min_v2 FROM metrics JOIN devices d ON metrics.device_id = d.device_id GROUP BY 1,2,3; CREATE MATERIALIZED VIEW daily_device_metrics WITH (tsdb.continuous) AS SELECT time_bucket('1 day', hour) AS day, device_id, device_name, AVG(avg_v0) AS avg_v0, MAX(max_v1) AS max_v1, MIN(min_v2) AS min_v2 FROM hourly_device_metrics GROUP BY 1,2,3; CREATE MATERIALIZED VIEW weekly_device_metrics WITH (tsdb.continuous) AS SELECT time_bucket('7 day', day) AS week, device_id, device_name, AVG(avg_v0) AS avg_v0, MAX(max_v1) AS max_v1, MIN(min_v2) AS min_v2 FROM daily_device_metrics GROUP BY 1,2,3; ��������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/memoize.sql��������������������������������������������������0000664�0000000�0000000�00000003465�15100345067�0022077�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_unmemoized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNMEMOIZED", format('%s/shared/results/%s_results_memoized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_MEMOIZED" \gset SELECT format('\! diff -u --label "Unmemoized results" --label "Memoized results" %s %s', :'TEST_RESULTS_UNMEMOIZED', :'TEST_RESULTS_MEMOIZED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' SET work_mem TO '64MB'; SET enable_memoize TO on; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- get results for all the queries -- run queries with and without memoize \set PREFIX '' \set ECHO none SET client_min_messages TO error; SET enable_memoize TO on; \set TEST_TABLE 'metrics' \o :TEST_RESULTS_MEMOIZED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME \o SET enable_memoize TO off; \set TEST_TABLE 'metrics' \o :TEST_RESULTS_UNMEMOIZED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME \o -- diff memoized and unmemoized results :DIFF_CMD �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/merge_dml.sql������������������������������������������������0000664�0000000�0000000�00000022622�15100345067�0022361�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create source table CREATE TABLE source ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int ); INSERT INTO source (time, device_id, filler_2, filler_3, filler_1) SELECT time, device_id, device_id + 134, device_id + 209, device_id + 0.50127 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', '20m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); -- create corresponding PG tables to compare against hypertables CREATE table metrics_pg as SELECT * FROM metrics; CREATE table metrics_space_pg as SELECT * FROM metrics_space; CREATE table metrics_compressed_pg as SELECT * FROM metrics_compressed; CREATE table metrics_space_compressed_pg as SELECT * FROM metrics_space_compressed; -- MERGE UDPATE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); -- MERGE UDPATE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; -- MERGE DELETE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- MERGE DELETE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; -- MERGE INSERT/DELETE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- MERGE INSERT/DELETE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; -- MERGE INSERT/DELETE matched rows for normal PG tables MERGE INTO metrics_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- MERGE INSERT/DELETE matched rows for hypertable MERGE INTO metrics t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics EXCEPT TABLE metrics_pg) OR EXISTS (TABLE metrics_pg EXCEPT TABLE metrics) THEN 'different' ELSE 'same' END AS result; -- MERGE UDPATE matched rows for normal PG tables MERGE INTO metrics_space_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); -- MERGE UDPATE matched rows for space partitioned hypertable MERGE INTO metrics_space t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics_pg); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics_space EXCEPT TABLE metrics_space_pg) OR EXISTS (TABLE metrics_space_pg EXCEPT TABLE metrics_space) THEN 'different' ELSE 'same' END AS result; -- MERGE DELETE matched rows for normal PG tables MERGE INTO metrics_space_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- MERGE DELETE matched rows for space partitioned hypertable MERGE INTO metrics_space t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics_space EXCEPT TABLE metrics_space_pg) OR EXISTS (TABLE metrics_space_pg EXCEPT TABLE metrics_space) THEN 'different' ELSE 'same' END AS result; -- MERGE INSERT matched rows for normal PG tables MERGE INTO metrics_space_pg t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- MERGE INSERT matched rows for space partitioned hypertable MERGE INTO metrics_space t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES (s.time, s.device_id, 1,2,3,4); -- result should be 'same' SELECT CASE WHEN EXISTS (TABLE metrics_space EXCEPT TABLE metrics_space_pg) OR EXISTS (TABLE metrics_space_pg EXCEPT TABLE metrics_space) THEN 'different' ELSE 'same' END AS result; \set ON_ERROR_STOP 0 -- MERGE UDPATE matched rows for compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics); -- MERGE DELETE matched rows for compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- MERGE UDPATE/INSERT matched rows for compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics) WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); -- MERGE DELETE/INSERT matched rows for compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); -- MERGE UDPATE matched rows for space partitioned compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics); -- MERGE DELETE matched rows for space partitioned compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE; -- MERGE UDPATE/INSERT matched rows for space partitioned compressed hypertable -- should report error as UPDATE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN UPDATE SET v1 = s.filler_1 * 1.23, v2 = (SELECT DISTINCT count(time) from metrics) WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); -- MERGE DELETE/INSERT matched rows for space partitioned compressed hypertable -- should report error as DELETE is not allowed on compressed hypertable MERGE INTO metrics_space_compressed t USING source s ON t.time = s.time AND t.device_id = s.device_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT (time, device_id, v0, v1, v2, v3) VALUES ('2021-11-01 00:00:05', 2, 1,2,3,4); \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/ordered_append_join.sql.in�����������������������������������0000664�0000000�0000000�00000006075�15100345067�0025031�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_now_constify TO FALSE; -- We disable index only scans to avoid some flakiness. It is not -- needed for the tests and it is only important which index is -- picked. SET enable_indexonlyscan TO FALSE; SELECT format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/shared/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/shared/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- Disable plain/sorted aggregation to get a deterministic test output SET timescaledb.enable_chunkwise_aggregation = OFF; -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none SET client_min_messages TO error; -- run queries on compressed hypertable and store result \set TEST_TABLE 'metrics' \o :TEST_RESULTS_UNCOMPRESSED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \o :TEST_RESULTS_COMPRESSED \ir :TEST_QUERY_NAME \o -- diff compressed and uncompressed results :DIFF_CMD -- do the same for space partitioned hypertable \set TEST_TABLE 'metrics_space' \o :TEST_RESULTS_UNCOMPRESSED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \o :TEST_RESULTS_COMPRESSED \ir :TEST_QUERY_NAME \o -- diff compressed and uncompressed results :DIFF_CMD -- #4418 -- test ordered append planning when inner join 2 hypertables on time column CREATE table i4418_1(time timestamptz, device text); CREATE table i4418_2(time timestamptz, device text); SELECT table_name FROM create_hypertable('i4418_1','time'); SELECT table_name FROM create_hypertable('i4418_2','time'); INSERT INTO i4418_1 SELECT time, 'device 1' FROM generate_series('2022-08-01'::timestamptz, '2022-08-20'::timestamptz,'3min'::interval) g(time); INSERT INTO i4418_2 SELECT * FROM i4418_1; EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT time_bucket('1d', tbl1.time), count(*) FROM i4418_1 tbl1 INNER JOIN i4418_2 tbl2 ON tbl1.device = tbl2.device AND tbl1.time = tbl2.time GROUP BY 1 ORDER BY 1; DROP TABLE i4418_1; DROP TABLE i4418_2; reset enable_nestloop; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/security_barrier.sql�����������������������������������������0000664�0000000�0000000�00000002601�15100345067�0023776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE test_security_barrier (time TIMESTAMPTZ NOT NULL, tenant TEXT NOT NULL, data TEXT); SELECT FROM create_hypertable('test_security_barrier', by_range('time')); INSERT INTO test_security_barrier(time, tenant, data) VALUES ('2020-01-01', :'ROLE_DEFAULT_PERM_USER','data1'), ('2020-01-01', :'ROLE_DEFAULT_PERM_USER_2','data2'); CREATE VIEW test_security_barrier_view WITH (security_barrier) AS SELECT * FROM test_security_barrier WHERE tenant = current_user; GRANT SELECT ON test_security_barrier_view TO :ROLE_DEFAULT_PERM_USER; GRANT SELECT ON test_security_barrier_view TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM test_security_barrier_view; RESET ROLE; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM test_security_barrier_view; RESET ROLE; ALTER TABLE test_security_barrier SET (timescaledb.compress); -- Compress the chunk SELECT compress_chunk(show_chunks('test_security_barrier')) IS NOT NULL AS compressed; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM test_security_barrier_view; RESET ROLE; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM test_security_barrier_view; RESET ROLE; DROP TABLE test_security_barrier CASCADE; �������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/space_constraint.sql.in��������������������������������������0000664�0000000�0000000�00000010621�15100345067�0024366�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_chunk_append TO false; SET timescaledb.enable_constraint_aware_append TO false; SET timescaledb.current_timestamp_mock TO '1990-01-01'; \set PREFIX 'EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' -- test SELECT FOR UPDATE :PREFIX SELECT FROM metrics_space WHERE device_id = 1 FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id IN (1) FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id IN (1,3) FOR UPDATE; -- check mismatching datatypes :PREFIX SELECT FROM metrics_space WHERE device_id = smallint '2' FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id = int '2' FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id = bigint '3' FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id IN (smallint '1', smallint '1') FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id IN (int '1', int '1') FOR UPDATE; :PREFIX SELECT FROM metrics_space WHERE device_id IN (bigint '1', bigint '1') FOR UPDATE; -- test valid variants we are optimizing :PREFIX DELETE FROM metrics_space WHERE device_id = 1; :PREFIX DELETE FROM metrics_space WHERE device_id IN (1); :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,1); :PREFIX DELETE FROM metrics_space WHERE device_id IN (1,3); -- test multiple constraints :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 1; :PREFIX DELETE FROM metrics_space WHERE device_id = 1 AND device_id = 2; :PREFIX DELETE FROM metrics_space WHERE device_id = 1 OR device_id = 2; :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id IN (2); :PREFIX DELETE FROM metrics_space WHERE device_id IN (1) OR device_id = 2; :PREFIX DELETE FROM metrics_space WHERE (time > '2000-01-01' OR device_id = 1) OR (time < '3000-01-01' OR device_id = 2); -- variants we don't optimize :PREFIX DELETE FROM metrics_space WHERE device_id > 1; :PREFIX DELETE FROM metrics_space WHERE device_id < 10; -- CTE :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id ) SELECT FROM q1; :PREFIX WITH q1 AS ( DELETE FROM metrics_space WHERE device_id = 2 RETURNING device_id ) DELETE FROM metrics_space WHERE device_id IN (1,3) RETURNING device_id; -- JOIN :PREFIX DELETE FROM metrics_space m1 using metrics_space m2 WHERE m1.device_id = 1 AND m2.device_id = 2; :PREFIX UPDATE metrics_space m1 set v0 = 0.1 FROM metrics_space m2 WHERE m2.device_id=1 AND m1.device_id=2; -- test multiple space dimensions and different datatypes CREATE TABLE space_constraint(time timestamptz, s1 text, s2 numeric, s3 int, v float); SELECT table_name FROM create_hypertable('space_constraint','time'); SELECT column_name FROM add_dimension('space_constraint','s1',number_partitions:=3); SELECT column_name FROM add_dimension('space_constraint','s2',number_partitions:=3); SELECT column_name FROM add_dimension('space_constraint','s3',number_partitions:=3); INSERT INTO space_constraint SELECT t,s1,s2,s3,0.12345 FROM (VALUES ('2000-01-01'::timestamptz),('2001-01-01')) v1(t), (VALUES ('s1_1'),('s1_2')) v2(s1), (VALUES (1.23),(4.56)) v3(s2), (VALUES (1),(2)) v4(s3); \set PREFIX 'EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF)' BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2'; ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; ROLLBACK; BEGIN; :PREFIX DELETE FROM space_constraint WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2'; ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE time > '2000-06-01' AND s1 = 's1_2' AND s2 = 1.23 AND s3 = 2; ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_2','s1_2') AND s2 = 1.23 AND s3 = 2; ROLLBACK; BEGIN; :PREFIX UPDATE space_constraint SET v=0.7 WHERE s1 IN ('s1_1','s1_3') AND s2 IN (1.23,4.44) AND s3 IN (1,100); ROLLBACK; DROP TABLE space_constraint; ���������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/subtract_integer_from_now.sql��������������������������������0000664�0000000�0000000�00000005414�15100345067�0025700�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test on normal table \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now('pg_class', 1); \set ON_ERROR_STOP 1 -- test on hypertable with non-int time dimension \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now('metrics', 1); \set ON_ERROR_STOP 1 SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "TABLENAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'metrics_compressed') \gset -- test on hypertable without dimensions \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now(:'TABLENAME', 1); \set ON_ERROR_STOP 1 -- test on hypertable without now function CREATE TABLE subtract_int_no_func(time int NOT NULL); SELECT table_name FROM create_hypertable('subtract_int_no_func','time',chunk_time_interval:=10); \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int_no_func', 1); \set ON_ERROR_STOP 1 CREATE OR REPLACE FUNCTION sub_int2_now() RETURNS int2 AS $$ SELECT 2::int2; $$ LANGUAGE SQL IMMUTABLE; CREATE OR REPLACE FUNCTION sub_int4_now() RETURNS int4 AS $$ SELECT 4::int4; $$ LANGUAGE SQL IMMUTABLE; CREATE OR REPLACE FUNCTION sub_int8_now() RETURNS int8 AS $$ SELECT 8::int8; $$ LANGUAGE SQL IMMUTABLE; CREATE TABLE subtract_int2(time int2 NOT NULL); CREATE TABLE subtract_int4(time int4 NOT NULL); CREATE TABLE subtract_int8(time int8 NOT NULL); SELECT table_name FROM create_hypertable('subtract_int2', 'time', chunk_time_interval:=10); SELECT table_name FROM create_hypertable('subtract_int4', 'time', chunk_time_interval:=10); SELECT table_name FROM create_hypertable('subtract_int8', 'time', chunk_time_interval:=10); SELECT set_integer_now_func('subtract_int2', 'sub_int2_now'); SELECT set_integer_now_func('subtract_int4', 'sub_int4_now'); SELECT set_integer_now_func('subtract_int8', 'sub_int8_now'); SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int2', lag) AS sub FROM (VALUES (-10),(0),(2),(4),(8)) v(lag); SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int4', lag) AS sub FROM (VALUES (-10),(0),(2),(4),(8)) v(lag); SELECT _timescaledb_functions.subtract_integer_from_now('subtract_int8', lag) AS sub FROM (VALUES (-10),(0),(2),(4),(8)) v(lag); -- test set_integer_now_func on internal table \set ON_ERROR_STOP 0 SELECT set_integer_now_func(:'TABLENAME', 'sub_int2_now'); \set ON_ERROR_STOP 1 -- cleanup DROP TABLE subtract_int_no_func; DROP TABLE subtract_int2; DROP TABLE subtract_int4; DROP TABLE subtract_int8; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/timestamp_limits.sql�����������������������������������������0000664�0000000�0000000�00000016730�15100345067�0024015�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION test.min_pg_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_pg_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_pg_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_pg_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_ts_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_ts_timestamptz() RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME, 'ts_timestamptz_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_min_ts_timestamptz() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamptz_internal_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_end_ts_timestamptz() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamptz_internal_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_pg_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_pg_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_pg_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_pg_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_ts_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_ts_timestamp() RETURNS TIMESTAMP AS :MODULE_PATHNAME, 'ts_timestamp_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_min_ts_timestamp() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamp_internal_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_end_ts_timestamp() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_timestamp_internal_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_pg_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_pg_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_pg_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_pg_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.min_ts_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.end_ts_date() RETURNS DATE AS :MODULE_PATHNAME, 'ts_date_end' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_min_ts_date() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_date_internal_min' LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.internal_end_ts_date() RETURNS BIGINT AS :MODULE_PATHNAME, 'ts_date_internal_end' LANGUAGE C VOLATILE; SET ROLE :ROLE_DEFAULT_PERM_USER; --show PG and TimescaleDB-specific time boundaries. Note that we --internally convert to UNIX epoch, which restricts the range of --supported timestamps. SET datestyle TO 'ISO,YMD'; \x --To display end timestamps (which aren't valid timestamps), we need --to be at UTC to avoid timezone conversion which would fail with --out-of-range error. Being at UTC also makes it easier to compare --TIMESTAMP and TIMESTAMP WITH TIME ZONE. SET timezone TO 'UTC'; -- MIN values (PostgreSQL). SELECT test.min_pg_timestamptz(), test.min_pg_timestamp(), test.min_pg_date(); -- MIN values (TimescaleDB). SELECT test.min_ts_timestamptz(), test.min_ts_timestamp(), test.min_ts_date(), _timescaledb_functions.to_timestamp(test.internal_min_ts_timestamptz()) AS min_ts_internal_timestamptz, _timescaledb_functions.to_timestamp_without_timezone(test.internal_min_ts_timestamp()) AS min_ts_internal_timestamp, _timescaledb_functions.to_date(test.internal_min_ts_date()) AS min_ts_internal_date; -- END values (PostgreSQL). Note that and values aren't valid -- timestamps or dates (since, e.g., END_TIMESTAMP is exclusive). It -- is possible to display them at UTC since no conversion is made. SELECT test.end_pg_timestamptz(), test.end_pg_timestamp(), test.end_pg_date(); -- END values (TimescaleDB). Note that we convert DATE to TIMESTAMP -- internally, and that limits the end to that of timestamp. SELECT test.end_ts_timestamptz(), test.end_ts_timestamp(), test.end_ts_date(), _timescaledb_functions.to_timestamp(test.internal_end_ts_timestamptz()) AS end_ts_internal_timestamptz, _timescaledb_functions.to_timestamp_without_timezone(test.internal_end_ts_timestamp()) AS end_ts_internal_timestamp, _timescaledb_functions.to_date(test.internal_end_ts_date()) AS end_ts_internal_date; --Test insert of time values close to or at limits --Suitable constraints should be created on chunks CREATE TABLE smallint_table(time smallint); SELECT table_name FROM create_hypertable('smallint_table', 'time', chunk_time_interval=>10); INSERT INTO smallint_table VALUES (-32768), (32767); SELECT pg_get_constraintdef(c.oid) FROM show_chunks('smallint_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; CREATE TABLE int_table(time int); SELECT table_name FROM create_hypertable('int_table', 'time', chunk_time_interval=>10); INSERT INTO int_table VALUES (-2147483648), (2147483647); SELECT pg_get_constraintdef(c.oid) FROM show_chunks('int_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; CREATE TABLE bigint_table(time bigint); SELECT table_name FROM create_hypertable('bigint_table', 'time', chunk_time_interval=>10); INSERT INTO bigint_table VALUES (-9223372036854775808), (9223372036854775807); SELECT pg_get_constraintdef(c.oid) FROM show_chunks('bigint_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; CREATE TABLE date_table(time date); SELECT table_name FROM create_hypertable('date_table', 'time'); INSERT INTO date_table VALUES (test.min_ts_date()), (test.end_ts_date() - INTERVAL '1 day'); -- Test out-of-range dates \set ON_ERROR_STOP 0 INSERT INTO date_table VALUES (test.min_ts_date() - INTERVAL '1 day'); INSERT INTO date_table VALUES (test.end_ts_date()); \set ON_ERROR_STOP 1 SELECT pg_get_constraintdef(c.oid) FROM show_chunks('date_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; CREATE TABLE timestamp_table(time timestamp); SELECT table_name FROM create_hypertable('timestamp_table', 'time'); INSERT INTO timestamp_table VALUES (test.min_ts_timestamp()); INSERT INTO timestamp_table VALUES (test.end_ts_timestamp() - INTERVAL '1 microsecond'); -- Test out-of-range timestamps \set ON_ERROR_STOP 0 INSERT INTO timestamp_table VALUES (test.min_ts_timestamp() - INTERVAL '1 microsecond'); INSERT INTO timestamp_table VALUES (test.end_ts_timestamp()); \set ON_ERROR_STOP 1 SELECT pg_get_constraintdef(c.oid) FROM show_chunks('timestamp_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; CREATE TABLE timestamptz_table(time timestamp); SELECT table_name FROM create_hypertable('timestamptz_table', 'time'); -- Need to be at UTC for this to work for timestamp with time zone INSERT INTO timestamptz_table VALUES (test.min_ts_timestamptz()); INSERT INTO timestamptz_table VALUES (test.end_ts_timestamptz() - INTERVAL '1 microsecond'); -- Test out-of-range timestamps \set ON_ERROR_STOP 0 INSERT INTO timestamptz_table VALUES (test.min_ts_timestamptz() - INTERVAL '1 microsecond'); INSERT INTO timestamptz_table VALUES (test.end_ts_timestamptz()); \set ON_ERROR_STOP 1 SELECT pg_get_constraintdef(c.oid) FROM show_chunks('timestamptz_table') chunk, pg_constraint c WHERE c.conrelid = chunk AND c.contype = 'c' ORDER BY chunk; RESET datestyle; RESET timezone; ����������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/transparent_decompress_chunk.sql.in��������������������������0000664�0000000�0000000�00000027276�15100345067�0027022�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' \set PREFIX_NO_VERBOSE 'EXPLAIN (buffers off, costs off)' -- Some tweaks to get less flaky test SET parallel_leader_participation TO off; SET min_parallel_table_scan_size TO '0'; SET enable_incremental_sort TO off; SELECT show_chunks('metrics_compressed') AS "TEST_TABLE" ORDER BY 1::text LIMIT 1 \gset -- this should use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; -- must not use ColumnarScan node :PREFIX_VERBOSE SELECT * FROM ONLY :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; -- this should use ColumnarScan node :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE UNION ALL SELECT * FROM :TEST_TABLE ORDER BY time; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", t AS "RECORD" FROM :TEST_TABLE t WHERE device_id IN (1, 2) ORDER BY time, device_id; -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; -- test IS NULL / IS NOT NULL :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --test var op var :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = v0 ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v1 ORDER BY time, device_id LIMIT 10; -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; -- test function calls :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; -- -- test segment meta pushdown -- -- order by column and const :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --pushdowns between order by and segment by columns :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --pushdown between two order by column (not pushed down) :PREFIX_NO_ANALYZE SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --functions optimized as well :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; -- test sort optimization interaction :PREFIX_NO_VERBOSE SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; :PREFIX_NO_ANALYZE SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; -- test aggregate :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE; -- test aggregate with GROUP BY :PREFIX_NO_ANALYZE SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; -- test window functions with GROUP BY :PREFIX_NO_ANALYZE SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1)); --with multiple values can get a semi-join or nested loop depending on seq_page_cost. :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id FROM :TEST_TABLE WHERE device_id IN (VALUES (1), (2)); RESET seq_page_cost; -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; DROP VIEW compressed_view; -- test INNER JOIN :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; :PREFIX_NO_VERBOSE SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 WHERE m1.v1 = 3 -- additional filter to force m1 as inner relation in join ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; -- test OUTER JOIN SET min_parallel_table_scan_size TO '0'; -- Disable merge join to get stable tests. These queries uses hash -- joins. SET enable_mergejoin TO off; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; RESET min_parallel_table_scan_size; :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; -- test implicit self-join :PREFIX_NO_VERBOSE SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; -- test self-join with sub-query :PREFIX_NO_VERBOSE SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; RESET enable_mergejoin; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; -- test prepared statement SET plan_cache_mode TO force_generic_plan; PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; DEALLOCATE prep; -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); :PREFIX EXECUTE param_prep (2); EXECUTE param_prep (1); EXECUTE param_prep (2); EXECUTE param_prep (1); EXECUTE param_prep (2); EXECUTE param_prep (1); DEALLOCATE param_prep; RESET plan_cache_mode; -- test hypertable being non-toplevel equivalence member #6925 CREATE TABLE i6925_t1(observed timestamptz not null, queryid int8, total_exec_time int8); CREATE TABLE i6925_t2(LIKE i6925_t1); SELECT table_name FROM create_hypertable('i6925_t1', 'observed'); ALTER TABLE i6925_t1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'queryid'); INSERT INTO i6925_t1 SELECT '2020-01-01', 1, 1; SELECT count(compress_chunk(chunk_name)) FROM show_chunks('i6925_t1') chunk_name; SELECT queryid, lag(total_exec_time) OVER (PARTITION BY queryid) FROM (SELECT * FROM i6925_t1 UNION ALL SELECT * FROM i6925_t2) q; DROP TABLE i6925_t1; DROP TABLE i6925_t2; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/shared/sql/with_clause_parser.sql���������������������������������������0000664�0000000�0000000�00000013703�15100345067�0024311�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- We have support for a dedicated type whos only purpose is to -- generate error. You pass in the error code you want and it will be -- raised from inside the input function. SET client_min_messages TO WARNING; CREATE TYPE sqlstate_raise; CREATE FUNCTION ts_sqlstate_raise_in(cstring) RETURNS sqlstate_raise AS :MODULE_PATHNAME LANGUAGE C STABLE STRICT; CREATE FUNCTION ts_sqlstate_raise_out(sqlstate_raise) RETURNS cstring AS :MODULE_PATHNAME LANGUAGE C STABLE STRICT; CREATE TYPE sqlstate_raise ( input = ts_sqlstate_raise_in, output = ts_sqlstate_raise_out ); SET client_min_messages TO DEFAULT; CREATE OR REPLACE FUNCTION test_with_clause_filter(with_clauses TEXT[][]) RETURNS TABLE(namespace TEXT, name TEXT, value TEXT, filtered BOOLEAN) AS :MODULE_PATHNAME, 'ts_test_with_clause_filter' LANGUAGE C VOLATILE STRICT; CREATE OR REPLACE FUNCTION test_with_clause_parse(with_clauses TEXT[][]) RETURNS TABLE(name TEXT, unimpl INT8, bool BOOLEAN, int32 INT4, def INT4, name_arg NAME, regc REGCLASS) AS :MODULE_PATHNAME, 'ts_test_with_clause_parse' LANGUAGE C VOLATILE STRICT; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM test_with_clause_filter( '{ {"baz", "bar", "foo"}, {"timescaledb", "bar", "baz"}, {"bar", "timescaledb", "baz"}, {"timescaledb", "baz", "bar"}, {"tsdb", "qux", "bar"}, {"tsdb", "quux", "bar"} }'); SELECT * FROM test_with_clause_filter( '{ {"baz", "bar", "foo"}, {"bar", "timescaledb", "baz"}, {"bar", "timescaledb", "baz"} }'); SELECT * FROM test_with_clause_filter( '{ {"bar", "timescaledb"}, {"baz", "bar"}, {"timescaledb", "bar"}, {"timescaledb", "baz"} }'); SELECT * FROM test_with_clause_filter( '{ {"timescaledb"}, {"bar"}, {"baz"} }'); \set ON_ERROR_STOP 0 -- unrecognized argument SELECT * FROM test_with_clause_parse('{{"timescaledb", "fakearg", "bar"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "fakearg"}}'); -- unimplemented handled gracefully SELECT * FROM test_with_clause_parse('{{"timescaledb", "unimplemented", "bar"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "unimplemented", "true"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "unimplemented"}}'); \set ON_ERROR_STOP 1 -- bool parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "true"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "false"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "on"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "off"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "1"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool", "0"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "bool"}}'); -- int32 parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "1"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "572"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "-10"}}'); \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "true"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32", "bar"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "int32"}}'); \set ON_ERROR_STOP 1 -- name parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "1"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "572"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "-10"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "true"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "bar"}}'); \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "name"}}'); \set ON_ERROR_STOP 1 -- REGCLASS parsing SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "pg_type"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "1"}}'); \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "-10"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "true"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass", "bar"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "regclass"}}'); \set ON_ERROR_STOP 1 -- Test errors generated from inside the input function \set ON_ERROR_STOP 0 -- Out of memory, "hard" error. SELECT * FROM test_with_clause_parse('{{"timescaledb", "sqlstate_raise", "53200"}}'); -- Division by zero, "soft" error. Shows invalid value message (with a -- strange message in this case). SELECT * FROM test_with_clause_parse('{{"timescaledb", "sqlstate_raise", "22012"}}'); \set ON_ERROR_STOP 1 -- defaults get overridden SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "1"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "572"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "-10"}}'); \set ON_ERROR_STOP 0 SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "true"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "default", "bar"}}'); SELECT * FROM test_with_clause_parse('{{"timescaledb", "default"}}'); \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 -- duplicates error SELECT * FROM test_with_clause_parse('{{"timescaledb", "name", "1"}, {"timescaledb", "name", "572"}}'); \set ON_ERROR_STOP 1 -- multiple args SELECT * FROM test_with_clause_parse('{ {"a", "bool", "true"}, {"b", "int32", "572"}, {"c", "name", "bar"}, {"d", "regclass", "pg_type"} }'); \c :TEST_DBNAME :ROLE_SUPERUSER DROP TYPE sqlstate_raise CASCADE; �������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/��������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016433�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/.gitignore����������������������������������������������������������0000664�0000000�0000000�00000000455�15100345067�0020427�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/*.pgbinary /cagg_*-1[3-9].sql /compression*-1[3-9].sql /continuous_aggs*-1[3-9].sql /ordered_append-*.sql /plan_skip_scan-*.sql /transparent_decompression*-1[3-9].sql /chunk_utils_internal-*.sql /compress_bloom_sparse-*.sql /foreign_keys_test-*.sql /modify_exclusion-*.sql /plan_skip_scan_dagg-*.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/CMakeLists.txt������������������������������������������������������0000664�0000000�0000000�00000016453�15100345067�0021204�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������include(GenerateTestSchedule) # These are the files for the 'postgresql' configuration. This is the default, # so unless you have a good reason, add new test files here. set(TEST_FILES agg_partials_pushdown.sql bgw_job_ddl.sql bgw_policy.sql bgw_security.sql cagg_api.sql cagg_config.sql cagg_deprecated_bucket_ng.sql cagg_errors.sql cagg_invalidation.sql cagg_invalidation_multi.sql cagg_policy.sql cagg_policy_move.sql cagg_policy_concurrent.sql cagg_plugin.sql cagg_refresh_using_trigger.sql cagg_refresh_using_wal.sql cagg_refresh_using_merge.sql cagg_utils.sql cagg_watermark.sql chunk_column_stats.sql columnar_scan_cost.sql columnstore_aliases.sql compress_auto_sparse_index.sql compress_bitmap_scan.sql compress_sparse_config.sql compress_default.sql compress_dml_copy.sql compress_float8_corrupt.sql compress_qualpushdown_saop.sql compress_sort_transform.sql compressed_collation.sql compressed_detoaster.sql direct_compress_insert.sql compression.sql compression_allocation.sql compression_conflicts.sql compression_constraints.sql compression_create_compressed_table.sql compression_defaults.sql compression_fks.sql compression_indexcreate.sql compression_insert.sql compression_null_dump_restore.sql compression_nulls_and_defaults.sql compression_policy.sql compression_qualpushdown.sql compression_sequence_num_removal.sql compression_settings.sql compression_sorted_merge.sql compression_sorted_merge_distinct.sql compression_uuid.sql compression_trigger.sql create_table_with.sql custom_hashagg.sql decompress_index.sql merge_chunks.sql merge_compress.sql move.sql plan_skip_scan_notnull.sql policy_generalization.sql reorder.sql size_utils_tsl.sql skip_scan.sql split_chunk.sql transparent_decompression_join_index.sql unlogged.sql vector_agg_functions.sql vector_agg_groupagg.sql vector_agg_param.sql vectorized_aggregation.sql) set(TEST_TEMPLATES cagg_query.sql.in cagg_query_using_merge.sql.in cagg_union_view.sql.in cagg_permissions.sql.in compress_bloom_sparse.sql.in compression_permissions.sql.in foreign_keys_test.sql.in modify_exclusion.sql.in ordered_append.sql.in plan_skip_scan.sql.in transparent_decompression.sql.in transparent_decompression_ordered_index.sql.in) if(USE_TELEMETRY) list(APPEND TEST_FILES bgw_telemetry.sql) endif() if(NOT APPLE) list(APPEND TEST_FILES direct_compress_copy.sql) endif() if(CMAKE_BUILD_TYPE MATCHES Debug) list( APPEND TEST_FILES attach_chunk.sql bgw_custom.sql bgw_db_scheduler.sql bgw_job_stat_history.sql bgw_job_stat_history_errors.sql bgw_job_stat_history_errors_permissions.sql bgw_db_scheduler_fixed.sql bgw_scheduler_control.sql bgw_scheduler_restart.sql bgw_reorder_drop_chunks.sql scheduler_fixed.sql cagg_policy_incremental.sql compress_bgw_reorder_drop_chunks.sql chunk_api.sql chunk_merge.sql chunk_utils_compression.sql chunk_utils_internal.sql compress_bloom_sparse_debug.sql compression_algos.sql compression_bgw.sql compression_bools.sql compression_bool_vectorized.sql compression_ddl.sql compression_errors.sql compression_hypertable.sql compression_merge.sql compression_indexscan.sql compression_segment_meta.sql compression_sorted_merge_columns.sql compression_sorted_merge_filter.sql cagg_bgw_drop_chunks.sql cagg_drop_chunks.sql cagg_dump.sql cagg_joins.sql cagg_migrate.sql cagg_multi.sql cagg_on_cagg.sql cagg_on_cagg_joins.sql cagg_tableam.sql cagg_policy_run.sql decompress_memory.sql decompress_vector_qual.sql detach_chunk.sql exp_cagg_monthly.sql exp_cagg_next_gen.sql exp_cagg_origin.sql exp_cagg_timezone.sql hypertable_generalization.sql insert_memory_usage.sql information_view_chunk_count.sql read_only.sql tsl_tables.sql license_tsl.sql fixed_schedules.sql partialize_finalize.sql recompress_chunk_segmentwise.sql feature_flags.sql vector_agg_byte.sql vector_agg_default.sql vector_agg_filter.sql vector_agg_grouping.sql vector_agg_text.sql vector_agg_memory.sql vector_agg_segmentby.sql vector_agg_uuid.sql) list( APPEND TEST_TEMPLATES cagg_bgw.sql.in cagg_ddl.sql.in cagg_migrate_function.sql.in cagg_repair.sql.in cagg_usage.sql.in compression_update_delete.sql.in continuous_aggs.sql.in transparent_decompression_queries.sql.in) if(USE_TELEMETRY) list(APPEND TEST_FILES telemetry_stats.sql) endif() endif(CMAKE_BUILD_TYPE MATCHES Debug) if((${PG_VERSION_MAJOR} GREATER_EQUAL "16")) list(APPEND TEST_FILES cagg_planning.sql skip_scan_dagg.sql) list(APPEND TEST_TEMPLATES plan_skip_scan_dagg.sql.in) endif() if((${PG_VERSION_MAJOR} GREATER_EQUAL "17")) list(APPEND TEST_FILES privilege_maintain.sql merge_append_partially_compressed.sql) endif() set(SOLO_TESTS # This interferes with other tests since it reloads the config to increase # log level. bgw_custom bgw_scheduler_control bgw_scheduler_restart bgw_db_scheduler bgw_job_stat_history_errors_permissions bgw_job_stat_history_errors bgw_job_stat_history bgw_db_scheduler_fixed bgw_reorder_drop_chunks scheduler_fixed compress_bgw_reorder_drop_chunks compression_ddl cagg_bgw cagg_ddl-${PG_VERSION_MAJOR} cagg_dump cagg_policy_incremental move reorder split_chunk telemetry_stats # These are solo tests because of a bug in PostgreSQL 17.5. A fix for it # seems to be scheduled for release with 17.6. # # See # https://github.com/postgres/postgres/commit/d87d07b7ad3b782cb74566cd771ecdb2823adf6a cagg_invalidation cagg_invalidation_multi cagg_plugin) # Check if PostgreSQL was compiled with JIT support set(PG_CONFIG_H "${PG_INCLUDEDIR}/pg_config.h") if(EXISTS ${PG_CONFIG_H}) file(STRINGS "${PG_CONFIG_H}" PG_USE_LLVM REGEX "^#[\t ]*define[\t ]+USE_LLVM[\t ]+1.*") if(PG_USE_LLVM) list(APPEND TEST_FILES jit.sql) endif() endif() # Regression tests that vary with PostgreSQL version. Generated test files are # put in the original source directory since all tests must be in the same # directory. These files are updated when the template is edited, but not when # the output file is deleted. If the output is deleted either recreate it # manually, or rerun cmake on the root dir. foreach(TEMPLATE_FILE ${TEST_TEMPLATES}) string(LENGTH ${TEMPLATE_FILE} TEMPLATE_NAME_LEN) math(EXPR TEMPLATE_NAME_LEN ${TEMPLATE_NAME_LEN}-7) string(SUBSTRING ${TEMPLATE_FILE} 0 ${TEMPLATE_NAME_LEN} TEMPLATE) set(TEST_FILE ${TEMPLATE}-${TEST_VERSION_SUFFIX}.sql) configure_file(${TEMPLATE_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/${TEST_FILE} COPYONLY) list(APPEND TEST_FILES ${TEST_FILE}) endforeach(TEMPLATE_FILE) if(NOT TEST_GROUP_SIZE) set(PARALLEL_GROUP_SIZE 10) else() set(PARALLEL_GROUP_SIZE ${TEST_GROUP_SIZE}) endif() # Generate a test schedule generate_test_schedule( ${TEST_SCHEDULE} TEST_FILES ${TEST_FILES} SOLO ${SOLO_TESTS} GROUP_SIZE ${PARALLEL_GROUP_SIZE}) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/agg_partials_pushdown.sql�������������������������������������������0000664�0000000�0000000�00000016522�15100345067�0023546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, verbose, buffers off, costs off, timing off, summary off)' -- Make parallel plans predictable SET max_parallel_workers_per_gather = 1; SET parallel_leader_participation = off; CREATE TABLE testtable(filter_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('testtable', 'time'); ALTER TABLE testtable SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); INSERT INTO testtable(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-10 23:55:00+0','1day') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(c) FROM show_chunks('testtable') c; ANALYZE testtable; -- Pushdown aggregation to the chunk level SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; -- Create partially compressed chunk INSERT INTO testtable(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-10 23:55:00+0','1day') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE testtable; -- Pushdown aggregation to the chunk level SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0' AND time <= '2000-02-01 00:00:00+0'; -- Same query using chunk append SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; -- Perform chunk append startup chunk exclusion - issue 6282 :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-09 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'::text::timestamptz; -- Force plain / sorted aggregation SET enable_hashagg = OFF; SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-01 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'; RESET enable_hashagg; -- Check chunk exclusion for index scans SET enable_seqscan = OFF; SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-09 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'::text::timestamptz; :PREFIX SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM testtable WHERE time >= '2000-01-09 00:00:00+0'::text::timestamptz AND time <= '2000-02-01 00:00:00+0'::text::timestamptz; RESET enable_seqscan; -- Check Append Node under ChunkAppend RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; CREATE TABLE testtable2 ( timecustom BIGINT NOT NULL, device_id TEXT NOT NULL, series_0 DOUBLE PRECISION NULL, series_1 DOUBLE PRECISION NULL, series_2 DOUBLE PRECISION NULL, series_bool BOOLEAN NULL ); CREATE INDEX ON testtable2 (timeCustom DESC NULLS LAST, device_id); SELECT * FROM create_hypertable('testtable2', 'timecustom', 'device_id', number_partitions => 2, chunk_time_interval=>_timescaledb_functions.interval_to_usec('1 month')); INSERT INTO testtable2 VALUES (1257894000000000000, 'dev1', 1.5, 1, 2, true), (1257894000000000000, 'dev1', 1.5, 2, NULL, NULL), (1257894000000001000, 'dev1', 2.5, 3, NULL, NULL), (1257894001000000000, 'dev1', 3.5, 4, NULL, NULL), (1257897600000000000, 'dev1', 4.5, 5, NULL, false), (1257894002000000000, 'dev1', 5.5, 6, NULL, true), (1257894002000000000, 'dev1', 5.5, 7, NULL, false); INSERT INTO testtable2(timeCustom, device_id, series_0, series_1) VALUES (1257987600000000000, 'dev1', 1.5, 1), (1257987600000000000, 'dev1', 1.5, 2), (1257894000000000000, 'dev2', 1.5, 1), (1257894002000000000, 'dev1', 2.5, 3); SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; -- Force parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; -- Test that we don't process groupingSets :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY ROLLUP(t); -- Check parallel fallback into a non-partial aggregation SET timescaledb.enable_chunkwise_aggregation = OFF; SET enable_hashagg = OFF; SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; :PREFIX SELECT timeCustom t, min(series_0) FROM PUBLIC.testtable2 GROUP BY t ORDER BY t DESC NULLS LAST limit 2; RESET timescaledb.enable_chunkwise_aggregation; RESET enable_hashagg; -- Test aggregation pushdown with MergeAppend node CREATE TABLE merge_append_test (start_time timestamptz, sensor_id int, cluster varchar (253), cost_recommendation_memory numeric); SELECT * FROM create_hypertable('merge_append_test', 'start_time'); CREATE INDEX merge_append_test_sensorid ON merge_append_test USING btree (start_time, sensor_id); INSERT INTO merge_append_test SELECT date_series, 1, 'production-1', random() * 100 FROM generate_series('2023-10-01 00:00:00', '2023-12-01 00:00:00', INTERVAL '1 hour') AS date_series ; INSERT INTO merge_append_test SELECT date_series, sensor_id, 'production-2', random() * 100 FROM generate_series('2023-10-01 00:00:00', '2023-12-01 00:00:00', INTERVAL '1 hour') AS date_series, generate_series(1, 100, 1) AS sensor_id ; ANALYZE merge_append_test; SET enable_seqscan = off; SET random_page_cost = 0; SET cpu_operator_cost = 0; SET enable_hashagg = off; RESET parallel_setup_cost; RESET parallel_tuple_cost; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END, 'off', false); :PREFIX SELECT start_time, sensor_id, SUM(cost_recommendation_memory) FROM merge_append_test WHERE start_time >= '2023-11-27 00:00:00Z' AND start_time <= '2023-12-01 00:00:00Z' AND sensor_id < 10 AND CLUSTER = 'production-2' GROUP BY 1, 2; RESET enable_seqscan; RESET random_page_cost; RESET cpu_operator_cost; RESET enable_hashagg; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/attach_chunk.sql����������������������������������������������������0000664�0000000�0000000�00000025023�15100345067�0021612�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :"TEST_DBNAME" TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- Create test tables and hypertables (reusing from detach_chunk test) CREATE TABLE devices(id int PRIMARY KEY); INSERT INTO devices VALUES (1), (2), (3); CREATE TABLE attach_test(id int, time timestamptz not null, device int, temp float); CREATE INDEX attach_test_device_idx ON attach_test (device); ALTER TABLE attach_test ADD CONSTRAINT attach_test_temp_check CHECK (temp > 0), ADD CONSTRAINT attach_test_device_fkey FOREIGN KEY (device) REFERENCES devices(id), ADD CONSTRAINT attach_test_id_time_unique UNIQUE (id, time); SELECT * FROM create_hypertable('attach_test', 'time', 'id', 2); CREATE TABLE attach_test_ref ( id int PRIMARY KEY, ref_id int, ref_time timestamptz, FOREIGN KEY (ref_id, ref_time) REFERENCES attach_test(id, time) ); INSERT INTO attach_test VALUES (1, '2025-06-01 05:00:00+3', 1, 23.4), (2, '2025-06-15 05:00:00+3', 2, 24.5), (3, '2025-06-30 05:00:00+3', 3, 25.6); -- Get chunk information for testing SELECT chunk_id AS "CHUNK_ID", hypertable_id AS "HYPERTABLE_ID", schema_name AS "CHUNK_SCHEMA", table_name AS "CHUNK_TABLE", schema_name || '.' || table_name AS "CHUNK_NAME", slices AS "CHUNK_SLICES" FROM _timescaledb_functions.show_chunk((SELECT show_chunks('attach_test') LIMIT 1)); \gset -- Successful attachment CREATE TABLE regular_table_to_attach(id int, time timestamptz not null, device int, temp float); CREATE INDEX regular_table_device_idx ON regular_table_to_attach (device); ALTER TABLE regular_table_to_attach ADD CONSTRAINT attach_test_temp_check CHECK (temp > 0), ADD CONSTRAINT pre_attach_temp_check CHECK (temp < 100), ADD CONSTRAINT pre_attach_id_time_unique UNIQUE (id, time); INSERT INTO regular_table_to_attach VALUES (10, '2025-07-05 13:00:00+3', 2, 27.8); -- Attach it as a chunk CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Verify data is accessible through the hypertable SELECT count(*) > 0 FROM attach_test WHERE time >= '2025-07-5'::timestamptz; -- Check the chunk and related metadata are set up correctly SELECT id AS "ATTACHED_CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID' AND table_name = 'regular_table_to_attach'; \gset -- Verify that each constraint/index on a auto-created chunk is also present on the attached chunk SELECT hypertable_constraint_name FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'CHUNK_ID' EXCEPT SELECT hypertable_constraint_name FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'ATTACHED_CHUNK'; SELECT * FROM test.show_indexesp('regular_table_to_attach'); SELECT * FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.chunk_constraint cc ON ds.id = cc.dimension_slice_id WHERE cc.chunk_id = :'ATTACHED_CHUNK'; -- Verify that the chunk is a child of the hypertable SELECT count(*) > 0 FROM pg_inherits WHERE inhrelid = 'regular_table_to_attach'::regclass::oid AND inhparent = 'attach_test'::regclass::oid; -- Verify foreign key references work SELECT count(*) > 0 FROM pg_constraint WHERE contype = 'f' AND confrelid = 'regular_table_to_attach'::regclass::oid; SELECT count(*) > 0 FROM pg_constraint WHERE contype = 'f' AND conrelid = 'regular_table_to_attach'::regclass::oid; -- Verify data is routed to the correct chunk SELECT count(*) FROM attach_test WHERE time > '2025-07-01'::timestamptz; INSERT INTO attach_test VALUES (5, '2025-07-4 05:00:00+3', 2, 19.5); SELECT count(*) FROM regular_table_to_attach; -- Detach and re-attach a chunk CALL detach_chunk(:'CHUNK_NAME'); CALL attach_chunk('attach_test', :'CHUNK_NAME', :'CHUNK_SLICES'); -- Store the new chunk id SELECT chunk_id AS "CHUNK_ID" FROM _timescaledb_functions.show_chunk(:'CHUNK_NAME'); \gset -- Verify it's re-attached SELECT count(*) > 0 FROM pg_inherits WHERE inhrelid = :'CHUNK_NAME'::regclass::oid; -- Verify constraints and indexes are restored SELECT * FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'CHUNK_ID'; SELECT * FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.chunk_constraint cc ON ds.id = cc.dimension_slice_id WHERE cc.chunk_id = :'CHUNK_ID'; -- Attach a chunk to another hypertable with a different dimension CALL detach_chunk('regular_table_to_attach'); CREATE TABLE hypertable_with_different_dimension(id int, time timestamptz not null, device int, temp float); SELECT * FROM create_hypertable('hypertable_with_different_dimension', 'time'); CALL attach_chunk('hypertable_with_different_dimension', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"]}'); CALL detach_chunk('regular_table_to_attach'); CREATE TABLE not_a_hypertable(id int, time timestamptz not null, device int, temp float); -- Error cases \set ON_ERROR_STOP 0 CALL attach_chunk('attach_test', 'nonexistent_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); CALL attach_chunk('not_a_hypertable', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); CALL attach_chunk('nonexistent_hypertable', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); CALL attach_chunk(98765, 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); CALL attach_chunk(0, 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- invalid json format CALL attach_chunk('attach_test', 'regular_table_to_attach', '"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]'); -- incorrect dimension information CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025123-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "incorrect_key": [-9223372036854775808, 1073741823]}'); CALL attach_chunk('attach_test', 'regular_table_to_attach', NULL); CALL attach_chunk('attach_test', 'regular_table_to_attach', :'CHUNK_SLICES'); CALL attach_chunk('attach_test', :'CHUNK_NAME', :'CHUNK_SLICES'); -- Attach a chunk of another hypertable CALL attach_chunk('hypertable_with_different_dimension', :'CHUNK_NAME', :'CHUNK_SLICES'); -- Try to attach a table that's already a child of another table CREATE TABLE parent_table(id int); CREATE TABLE child_table(time timestamptz not null, device int, temp float) INHERITS (parent_table); CALL attach_chunk('attach_test', 'child_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Try to attach a table with incompatible types CREATE TABLE incompatible_table(id int, time timestamptz not null, device text, temp float); CALL attach_chunk('attach_test', 'incompatible_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Try to attach a table with missing columns CREATE TABLE missing_col_table(id int, time timestamptz not null); CALL attach_chunk('attach_test', 'missing_col_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Try to attach a table with extra columns CREATE TABLE extra_col_table(id int, time timestamptz not null, device int, temp float, extra_col int); CALL attach_chunk('attach_test', 'extra_col_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Attach by non-owner is not allowed set role :ROLE_1; CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); set role :ROLE_DEFAULT_PERM_USER; CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-06-01 05:00:00+3", "2025-06-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); -- Attach hypertable as a chunk CALL attach_chunk('attach_test', 'hypertable_with_different_dimension', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); \set ON_ERROR_STOP 1 -- Test rollback behavior SELECT count(*) AS "PRE_ROLLBACK_CHUNKS" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; \gset BEGIN; CREATE TABLE rollback_test_table(id int, time timestamptz not null, device int, temp float); ALTER TABLE rollback_test_table ADD CONSTRAINT attach_test_temp_check CHECK (temp > 0); CALL attach_chunk('attach_test', 'rollback_test_table', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); ROLLBACK; SELECT count(*) = :'PRE_ROLLBACK_CHUNKS' FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00", "2025-07-07 05:00:00"], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01", "2025-07-07"], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["Tue July 1 05:00:00 2025 GMT+3", "Mon July 7 05:00:00 2025 GMT+3"], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": [1751356800000000, 1751875200000000], "id": [-9223372036854775808, 1073741823]}'); CALL detach_chunk('regular_table_to_attach'); -- Attach a table with rows violating chunk constraints INSERT INTO regular_table_to_attach VALUES (4, '2024-07-05 13:00:00+3', 2, 27.8); \set ON_ERROR_STOP 0 CALL attach_chunk('attach_test', 'regular_table_to_attach', '{"time": ["2025-07-01 05:00:00+3", "2025-07-07 05:00:00+3"], "id": [-9223372036854775808, 1073741823]}'); \set ON_ERROR_STOP 1 -- Clean up DROP TABLE regular_table_to_attach; DROP TABLE attach_test_ref; DROP TABLE attach_test; DROP TABLE devices CASCADE; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_custom.sql������������������������������������������������������0000664�0000000�0000000�00000065764�15100345067�0021347�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE custom_log(job_id int, args jsonb, extra text, runner NAME DEFAULT CURRENT_ROLE); CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS VOID LANGUAGE SQL AS $$ INSERT INTO custom_log VALUES($1, $2, 'custom_func'); $$; CREATE OR REPLACE FUNCTION custom_func_definer(jobid int, args jsonb) RETURNS VOID LANGUAGE SQL AS $$ INSERT INTO custom_log VALUES($1, $2, 'security definer'); $$ SECURITY DEFINER; CREATE OR REPLACE PROCEDURE custom_proc(job_id int, args jsonb) LANGUAGE SQL AS $$ INSERT INTO custom_log VALUES($1, $2, 'custom_proc'); $$; -- procedure with transaction handling CREATE OR REPLACE PROCEDURE custom_proc2(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN INSERT INTO custom_log VALUES($1, $2, 'custom_proc2 1 COMMIT ' || (args->>'type')); COMMIT; INSERT INTO custom_log VALUES($1, $2, 'custom_proc2 2 ROLLBACK ' || (args->>'type')); ROLLBACK; INSERT INTO custom_log VALUES($1, $2, 'custom_proc2 3 COMMIT ' || (args->>'type')); COMMIT; END $$; \set ON_ERROR_STOP 0 -- test bad input SELECT add_job(NULL, '1h'); SELECT add_job(0, '1h'); -- this will return an error about Oid 4294967295 -- while regproc is unsigned int postgres has an implicit cast from int to regproc SELECT add_job(-1, '1h'); SELECT add_job('invalid_func', '1h'); SELECT add_job('custom_func', NULL); SELECT add_job('custom_func', 'invalid interval'); SELECT add_job('custom_func', '1h', job_name := 'this_is_a_really_really_really_long_application_name_to_overflow'); \set ON_ERROR_STOP 1 select '2000-01-01 00:00:00+00' as time_zero \gset SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); SELECT add_job('custom_proc','1h', config:='{"type":"procedure"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); SELECT add_job('custom_proc2','1h', config:= '{"type":"procedure"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); SELECT add_job('custom_func', '1h', config:='{"type":"function"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ); SELECT add_job('custom_func_definer', '1h', config:='{"type":"function"}'::jsonb, initial_start => :'time_zero'::TIMESTAMPTZ, job_name := 'custom_job_name'); -- exclude internal jobs SELECT * FROM timescaledb_information.jobs WHERE job_id >= 1000 ORDER BY 1; SELECT count(*) FROM _timescaledb_config.bgw_job WHERE config->>'type' IN ('procedure', 'function'); \set ON_ERROR_STOP 0 -- test bad input CALL run_job(NULL); CALL run_job(-1); \set ON_ERROR_STOP 1 CALL run_job(1001); CALL run_job(1002); CALL run_job(1003); CALL run_job(1004); CALL run_job(1005); SELECT * FROM custom_log ORDER BY job_id, extra; \set ON_ERROR_STOP 0 -- test bad input SELECT delete_job(NULL); SELECT delete_job(-1); \set ON_ERROR_STOP 1 -- We keep job 1001 for some additional checks. SELECT delete_job(1002); SELECT delete_job(1003); SELECT delete_job(1004); SELECT delete_job(1005); -- check jobs got removed SELECT count(*) FROM timescaledb_information.jobs WHERE job_id >= 1002; \c :TEST_DBNAME :ROLE_SUPERUSER -- create a new job with longer id SELECT nextval('_timescaledb_config.bgw_job_id_seq') as nextval \gset SELECT setval('_timescaledb_config.bgw_job_id_seq', 2147483647, false); SELECT add_job('custom_func', '1h', config:='{"type":"function"}'::jsonb, job_name := 'custom_job_name'); \set ON_ERROR_STOP 0 -- test bad input SELECT alter_job(NULL, if_exists => false); SELECT alter_job(-1, if_exists => false); SELECT alter_job(1001, job_name => 'this_is_a_really_really_really_long_application_name_to_overflow'); SELECT alter_job(2147483647, job_name => 'this_is_a_really_really_really_long_application_name_to_overflow'); \set ON_ERROR_STOP 1 -- test bad input but don't fail SELECT alter_job(NULL, if_exists => true); SELECT alter_job(-1, if_exists => true); -- test altering job with NULL config SELECT job_id FROM alter_job(1001,scheduled:=false); SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; -- test updating job settings SELECT job_id FROM alter_job(1001,config:='{"test":"test"}'); SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; SELECT job_id FROM alter_job(1001,scheduled:=true); SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; SELECT job_id FROM alter_job(1001,scheduled:=false); SELECT scheduled, config FROM timescaledb_information.jobs WHERE job_id = 1001; -- test updating the job name SELECT job_id, application_name FROM alter_job(1001,job_name:='custom_name_2'); SELECT job_id, application_name FROM alter_job(2147483647,job_name:='short_name_to_fit'); SELECT application_name FROM timescaledb_information.jobs WHERE job_id >= 1001; -- Done with jobs now, so remove it. SELECT delete_job(1001); SELECT delete_job(2147483647); -- reset the sequence to its previous value SELECT setval('_timescaledb_config.bgw_job_id_seq', :nextval, false); --test for #2793 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- background workers are disabled, so the job will not run -- SELECT add_job( proc=>'custom_func', schedule_interval=>'1h', initial_start =>'2018-01-01 10:00:00-05') AS job_id_1 \gset SELECT job_id, next_start, scheduled, schedule_interval FROM timescaledb_information.jobs WHERE job_id > 1001; \x SELECT * FROM timescaledb_information.job_stats WHERE job_id > 1001; \x SELECT delete_job(:job_id_1); -- tests for #3545 TRUNCATE custom_log; -- Nested procedure call CREATE OR REPLACE PROCEDURE custom_proc_nested(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN INSERT INTO custom_log VALUES($1, $2, 'custom_proc_nested 1 COMMIT'); COMMIT; INSERT INTO custom_log VALUES($1, $2, 'custom_proc_nested 2 ROLLBACK'); ROLLBACK; INSERT INTO custom_log VALUES($1, $2, 'custom_proc_nested 3 COMMIT'); COMMIT; END $$; CREATE OR REPLACE PROCEDURE custom_proc3(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN CALL custom_proc_nested(job_id, args); END $$; CREATE OR REPLACE PROCEDURE custom_proc4(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN INSERT INTO custom_log VALUES($1, $2, 'custom_proc4 1 COMMIT'); COMMIT; INSERT INTO custom_log VALUES($1, $2, 'custom_proc4 2 ROLLBACK'); ROLLBACK; RAISE EXCEPTION 'forced exception'; INSERT INTO custom_log VALUES($1, $2, 'custom_proc4 3 ABORT'); COMMIT; END $$; CREATE OR REPLACE PROCEDURE custom_proc5(job_id int, args jsonb) LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('conditions_summary_daily', '2021-08-01 00:00', '2021-08-31 00:00'); END $$; -- Remove any default jobs, e.g., telemetry \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_config.bgw_job RESTART IDENTITY CASCADE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_job('custom_proc2', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_1 \gset SELECT add_job('custom_proc3', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_2 \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Start Background Workers SELECT _timescaledb_functions.start_background_workers(); -- Wait for jobs SELECT test.wait_for_job_to_run(:job_id_1, 1); SELECT test.wait_for_job_to_run(:job_id_2, 1); -- Check results SELECT * FROM custom_log ORDER BY job_id, extra; -- Delete previous jobs SELECT delete_job(:job_id_1); SELECT delete_job(:job_id_2); TRUNCATE custom_log; -- Forced Exception SELECT add_job('custom_proc4', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_3 \gset SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_3, 1); -- Check results SELECT * FROM custom_log ORDER BY job_id, extra; -- Delete previous jobs SELECT delete_job(:job_id_3); CREATE TABLE conditions ( time TIMESTAMP NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ) WITH (autovacuum_enabled = FALSE); SELECT create_hypertable('conditions', 'time', chunk_time_interval := '15 days'::interval); ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'time' ); INSERT INTO conditions SELECT generate_series('2021-08-01 00:00'::timestamp, '2021-08-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; -- Chunk compress stats SELECT * FROM _timescaledb_internal.compressed_chunk_stats ORDER BY chunk_name; -- Compression policy SELECT add_compression_policy('conditions', interval '1 day') AS job_id_4 \gset SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_4, 1); -- Chunk compress stats SELECT * FROM _timescaledb_internal.compressed_chunk_stats ORDER BY chunk_name; --TEST compression job after inserting data into previously compressed chunk INSERT INTO conditions SELECT generate_series('2021-08-01 00:00'::timestamp, '2021-08-31 00:00'::timestamp, '1 day'), 'NYC', 'nycity', 40, 40; SELECT id, table_name, status from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'conditions') order by id; --running job second time, wait for it to complete select t.schedule_interval FROM alter_job(:job_id_4, next_start=> now() ) t; SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_4, 2); SELECT id, table_name, status from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'conditions') order by id; -- Drop the compression job SELECT delete_job(:job_id_4); -- Decompress chunks before create the cagg SELECT decompress_chunk(c) FROM show_chunks('conditions') c; -- TEST Continuous Aggregate job CREATE MATERIALIZED VIEW conditions_summary_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature), MAX(temperature), MIN(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; -- Refresh Continous Aggregate by Job SELECT add_job('custom_proc5', '1h', config := '{"type":"procedure"}'::jsonb, initial_start := now()) AS job_id_5 \gset SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_5, 1); SELECT count(*) FROM conditions_summary_daily; -- TESTs for alter_job_set_hypertable_id API SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id_5, NULL); SELECT id, proc_name, hypertable_id FROM _timescaledb_config.bgw_job WHERE id = :job_id_5; -- error case, try to associate with a PG relation \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id_5, 'custom_log'); \set ON_ERROR_STOP 1 -- TEST associate the cagg with the job SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id_5, 'conditions_summary_daily'::regclass); SELECT id, proc_name, hypertable_id FROM _timescaledb_config.bgw_job WHERE id = :job_id_5; --verify that job is dropped when cagg is dropped DROP MATERIALIZED VIEW conditions_summary_daily; SELECT id, proc_name, hypertable_id FROM _timescaledb_config.bgw_job WHERE id = :job_id_5; -- Cleanup DROP TABLE conditions; DROP TABLE custom_log; -- Stop Background Workers SELECT _timescaledb_functions.stop_background_workers(); SELECT _timescaledb_functions.restart_background_workers(); \set ON_ERROR_STOP 0 -- add test for custom jobs with custom check functions -- create the functions/procedures to be used as checking functions CREATE OR REPLACE PROCEDURE test_config_check_proc(config jsonb) LANGUAGE PLPGSQL AS $$ DECLARE drop_after interval; BEGIN SELECT jsonb_object_field_text (config, 'drop_after')::interval INTO STRICT drop_after; IF drop_after IS NULL THEN RAISE EXCEPTION 'Config must be not NULL and have drop_after'; END IF ; END $$; CREATE OR REPLACE FUNCTION test_config_check_func(config jsonb) RETURNS VOID AS $$ DECLARE drop_after interval; BEGIN IF config IS NULL THEN RETURN; END IF; SELECT jsonb_object_field_text (config, 'drop_after')::interval INTO STRICT drop_after; IF drop_after IS NULL THEN RAISE EXCEPTION 'Config can be NULL but must have drop_after if not'; END IF ; END $$ LANGUAGE PLPGSQL; -- step 2, create a procedure to run as a custom job CREATE OR REPLACE PROCEDURE test_proc_with_check(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE NOTICE 'Will only print this if config passes checks, my config is %', config; END $$; -- step 3, add the job with the config check function passed as argument -- test procedures, should get an unsupported error select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_proc'::regproc); -- test functions select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func'::regproc); select add_job('test_proc_with_check', '5 secs', config => NULL, check_config => 'test_config_check_func'::regproc); select add_job('test_proc_with_check', '5 secs', config => '{"drop_after": "chicken"}', check_config => 'test_config_check_func'::regproc); select add_job('test_proc_with_check', '5 secs', config => '{"drop_after": "2 weeks"}', check_config => 'test_config_check_func'::regproc) as job_with_func_check_id \gset --- test alter_job select alter_job(:job_with_func_check_id, config => '{"drop_after":"chicken"}'); select config from alter_job(:job_with_func_check_id, config => '{"drop_after":"5 years"}'); -- test that jobs with an incorrect check function signature will not be registered -- these are all incorrect function signatures CREATE OR REPLACE FUNCTION test_config_check_func_0args() RETURNS VOID AS $$ BEGIN RAISE NOTICE 'I take no arguments and will validate anything you give me!'; END $$ LANGUAGE PLPGSQL; CREATE OR REPLACE FUNCTION test_config_check_func_2args(config jsonb, intarg int) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'I take two arguments (jsonb, int) and I should fail to run!'; END $$ LANGUAGE PLPGSQL; CREATE OR REPLACE FUNCTION test_config_check_func_intarg(config int) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'I take one argument which is an integer and I should fail to run!'; END $$ LANGUAGE PLPGSQL; -- -- this should fail, it has an incorrect check function select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_0args'::regproc); -- -- so should this select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_2args'::regproc); -- and this select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_intarg'::regproc); -- and this fails as it calls a nonexistent function select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_nonexistent_check_func'::regproc); -- when called with a valid check function and a NULL config no check should occur CREATE OR REPLACE FUNCTION test_config_check_func(config jsonb) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'This message will get printed for both NULL and not NULL config'; END $$ LANGUAGE PLPGSQL; SET client_min_messages = NOTICE; -- check done for both NULL and non-NULL config select add_job('test_proc_with_check', '5 secs', config => NULL, check_config => 'test_config_check_func'::regproc); -- check done select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func'::regproc) as job_id \gset -- check function not returning void CREATE OR REPLACE FUNCTION test_config_check_func_returns_int(config jsonb) RETURNS INT AS $$ BEGIN raise notice 'I print a message, and then I return least(1,2)'; RETURN LEAST(1, 2); END $$ LANGUAGE PLPGSQL; select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_config_check_func_returns_int'::regproc, initial_start => :'time_zero'::timestamptz) as job_id_int \gset -- rename the check function and then call alter_job to register the new name ALTER FUNCTION test_config_check_func RENAME TO renamed_func; select job_id, schedule_interval, config, check_config from alter_job(:job_id, check_config => 'renamed_func'::regproc, schedule_interval => '1 hour'); -- run alter again, should get a config check select job_id, schedule_interval, config, check_config from alter_job(:job_id, config => '{}'); -- drop the registered check function, verify that alter_job will work and print a warning that -- the check is being skipped due to the check function missing DROP FUNCTION test_config_check_func_returns_int; select job_id, schedule_interval, config, check_config from alter_job(:job_id_int, config => '{"field":"value"}'); -- do not drop the current check function but register a new one CREATE OR REPLACE FUNCTION substitute_check_func(config jsonb) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'This message is a substitute of the previously printed one'; END $$ LANGUAGE PLPGSQL; -- register the new check select job_id, schedule_interval, config, check_config from alter_job(:job_id, check_config => 'substitute_check_func'); select job_id, schedule_interval, config, check_config from alter_job(:job_id, config => '{}'); RESET client_min_messages; -- test an oid that doesn't exist select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 17424217::regproc); \c :TEST_DBNAME :ROLE_SUPERUSER -- test a function with insufficient privileges create schema test_schema; create role user_noexec with login; grant usage on schema test_schema to user_noexec; CREATE OR REPLACE FUNCTION test_schema.test_config_check_func_privileges(config jsonb) RETURNS VOID AS $$ BEGIN RAISE NOTICE 'This message will only get printed if privileges suffice'; END $$ LANGUAGE PLPGSQL; revoke execute on function test_schema.test_config_check_func_privileges from public; -- verify the user doesn't have execute permissions on the function select has_function_privilege('user_noexec', 'test_schema.test_config_check_func_privileges(jsonb)', 'execute'); \c :TEST_DBNAME user_noexec -- user_noexec should not have exec permissions on this function select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'test_schema.test_config_check_func_privileges'::regproc); \c :TEST_DBNAME :ROLE_SUPERUSER -- check that alter_job rejects a check function with invalid signature select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'renamed_func', initial_start => :'time_zero'::timestamptz) as job_id_alter \gset select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter, check_config => 'test_config_check_func_0args'); select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter); -- test that we can unregister the check function select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter, check_config => 0); -- no message printed now select job_id, schedule_interval, config, check_config from alter_job(:job_id_alter, config => '{}'); -- test the case where we have a background job that registers jobs with a check fn CREATE OR REPLACE PROCEDURE add_scheduled_jobs_with_check(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN perform add_job('test_proc_with_check', schedule_interval => '10 secs', config => '{}', check_config => 'renamed_func'); END $$; select add_job('add_scheduled_jobs_with_check', schedule_interval => '1 hour') as last_job_id \gset -- wait for enough time SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:last_job_id, 1); select total_runs, total_successes, last_run_status from timescaledb_information.job_stats where job_id = :last_job_id; -- test coverage for alter_job -- registering an invalid oid select alter_job(:job_id_alter, check_config => 123456789::regproc); -- registering a function with insufficient privileges \c :TEST_DBNAME user_noexec select * from add_job('test_proc_with_check', '5 secs', config => '{}') as job_id_owner \gset select * from alter_job(:job_id_owner, check_config => 'test_schema.test_config_check_func_privileges'::regproc); \c :TEST_DBNAME :ROLE_SUPERUSER DROP SCHEMA test_schema CASCADE; -- Delete all jobs with that owner before we can drop the user. DELETE FROM _timescaledb_config.bgw_job WHERE owner = 'user_noexec'::regrole; DROP ROLE user_noexec; -- test with aggregate check proc create function jsonb_add (j1 jsonb, j2 jsonb) returns jsonb AS $$ BEGIN RETURN j1 || j2; END $$ LANGUAGE PLPGSQL; CREATE AGGREGATE sum_jsb (jsonb) ( sfunc = jsonb_add, stype = jsonb, initcond = '{}' ); -- for test coverage, check unsupported aggregate type select add_job('test_proc_with_check', '5 secs', config => '{}', check_config => 'sum_jsb'::regproc); -- Cleanup jobs TRUNCATE _timescaledb_config.bgw_job CASCADE; -- github issue 4610 CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null ); SELECT FROM create_hypertable('sensor_data','time'); SELECT '2022-10-06 00:00:00+00' as start_date_sd \gset INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date_sd'::timestamptz - INTERVAL '1 months', :'start_date_sd'::timestamptz - INTERVAL '1 week', INTERVAL '30 minute') AS g1(time), generate_series(1, 50, 1 ) AS g2(sensor_id) ORDER BY time; -- enable compression ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); -- create new chunks INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date_sd'::timestamptz - INTERVAL '2 months', :'start_date_sd'::timestamptz - INTERVAL '2 week', INTERVAL '60 minute') AS g1(time), generate_series(1, 30, 1 ) AS g2(sensor_id) ORDER BY time; -- get the name of a new uncompressed chunk SELECT chunk_name AS new_uncompressed_chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'sensor_data' AND NOT is_compressed LIMIT 1 \gset -- change compression status so that this chunk is skipped when policy is run update _timescaledb_catalog.chunk set status=3 where table_name = :'new_uncompressed_chunk_name'; -- add new compression policy job SELECT add_compression_policy('sensor_data', INTERVAL '1' minute) AS compressjob_id \gset -- set recompress to true SELECT alter_job(id,config:=jsonb_set(config,'{recompress}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; -- verify that there are other uncompressed new chunks that need to be compressed SELECT count(*) > 1 FROM timescaledb_information.chunks WHERE hypertable_name = 'sensor_data' AND NOT is_compressed; -- disable notice/warning as the new_uncompressed_chunk_name -- is dynamic and it will be printed in those messages. SET client_min_messages TO ERROR; CALL run_job(:compressjob_id); SET client_min_messages TO NOTICE; -- check compression status is not changed for the chunk whose status was manually updated SELECT status FROM _timescaledb_catalog.chunk where table_name = :'new_uncompressed_chunk_name'; -- confirm all the other new chunks are now compressed despite -- facing an error when trying to compress :'new_uncompressed_chunk_name' SELECT count(*) = 0 FROM timescaledb_information.chunks WHERE hypertable_name = 'sensor_data' AND NOT is_compressed; -- cleanup SELECT _timescaledb_functions.stop_background_workers(); DROP TABLE sensor_data; SELECT _timescaledb_functions.restart_background_workers(); -- Github issue #5537 -- Proc that waits until the given job enters the expected state CREATE OR REPLACE PROCEDURE wait_for_job_status(job_param_id INTEGER, expected_status TEXT, spins INTEGER=:TEST_SPINWAIT_ITERS) LANGUAGE PLPGSQL AS $$ DECLARE jobstatus TEXT; BEGIN FOR i in 1..spins LOOP SELECT job_status FROM timescaledb_information.job_stats WHERE job_id = job_param_id INTO jobstatus; IF jobstatus = expected_status THEN RETURN; END IF; PERFORM pg_sleep(0.1); ROLLBACK; END LOOP; RAISE EXCEPTION 'wait_for_job_status(%): timeout after % tries', job_param_id, spins; END; $$; -- Proc that sleeps for 1m - to keep the test jobs in running state CREATE OR REPLACE PROCEDURE proc_that_sleeps(job_id INT, config JSONB) LANGUAGE PLPGSQL AS $$ BEGIN PERFORM pg_sleep(60); END $$; -- create new jobs and ensure that the second one gets scheduled -- before the first one by adjusting the initial_start values SELECT add_job('proc_that_sleeps', '1h', initial_start => now()::timestamptz + interval '2s') AS job_id_1 \gset SELECT add_job('proc_that_sleeps', '1h', initial_start => now()::timestamptz - interval '2s') AS job_id_2 \gset SELECT _timescaledb_functions.restart_background_workers(); -- wait for the jobs to start running job_2 will start running first CALL wait_for_job_status(:job_id_2, 'Running'); CALL wait_for_job_status(:job_id_1, 'Running'); -- add a new job and wait for it to start SELECT add_job('proc_that_sleeps', '1h') AS job_id_3 \gset CALL wait_for_job_status(:job_id_3, 'Running'); -- verify that none of the jobs crashed SELECT job_id, job_status, next_start, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id IN (:job_id_1, :job_id_2, :job_id_3) ORDER BY job_id; SELECT job_id, err_message FROM timescaledb_information.job_errors WHERE job_id IN (:job_id_1, :job_id_2, :job_id_3); -- cleanup SELECT _timescaledb_functions.stop_background_workers(); CALL wait_for_job_status(:job_id_1, 'Scheduled'); CALL wait_for_job_status(:job_id_2, 'Scheduled'); CALL wait_for_job_status(:job_id_3, 'Scheduled'); SELECT delete_job(:job_id_1); SELECT delete_job(:job_id_2); SELECT delete_job(:job_id_3); CREATE OR REPLACE FUNCTION ts_test_bgw_job_function_call_string(job_id INTEGER) RETURNS text AS :MODULE_PATHNAME LANGUAGE C STABLE STRICT; \set ON_ERROR_STOP 0 SELECT ts_test_bgw_job_function_call_string(999999); \set ON_ERROR_STOP 1 SELECT add_job('custom_func', '1h') AS job_func \gset SELECT add_job('custom_proc', '1h') AS job_proc \gset SELECT ts_test_bgw_job_function_call_string(:job_func); SELECT ts_test_bgw_job_function_call_string(:job_proc); SELECT delete_job(:job_func); SELECT delete_job(:job_proc); SELECT add_job('custom_func', '1h', config => '{"type":"function"}'::jsonb) AS job_func \gset SELECT add_job('custom_proc', '1h', config => '{"type":"procedure"}'::jsonb) AS job_proc \gset SELECT ts_test_bgw_job_function_call_string(:job_func); SELECT ts_test_bgw_job_function_call_string(:job_proc); -- Remove the procedure and let's check it fallingback to PROKIND_FUNCTION DROP PROCEDURE custom_proc(jobid int, args jsonb); SELECT ts_test_bgw_job_function_call_string(:job_proc); \set ON_ERROR_STOP 0 -- Mess with pg catalog to don't identify the PROKIND BEGIN; UPDATE pg_catalog.pg_proc SET prokind = 'X' WHERE oid = 'custom_func(int,jsonb)'::regprocedure; SELECT ts_test_bgw_job_function_call_string(:job_func); ROLLBACK; \set ON_ERROR_STOP 1 SELECT delete_job(:job_func); SELECT delete_job(:job_proc); ������������timescaledb-2.23.0/tsl/test/sql/bgw_db_scheduler.sql������������������������������������������������0000664�0000000�0000000�00000065560�15100345067�0022452�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_test_job_sleep(job_id INT, config JSONB) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION insert_job( application_name NAME, job_type NAME, schedule_interval INTERVAL, max_runtime INTERVAL, retry_period INTERVAL, owner regrole DEFAULT CURRENT_ROLE::regrole, scheduled BOOL DEFAULT true, fixed_schedule BOOL DEFAULT false ) RETURNS INT LANGUAGE SQL SECURITY DEFINER AS $$ INSERT INTO _timescaledb_config.bgw_job(application_name,schedule_interval,max_runtime,max_retries, retry_period,proc_name,proc_schema,owner,scheduled,fixed_schedule) VALUES($1,$3,$4,5,$5,$2,'public',$6,$7,$8) RETURNING id; $$; CREATE OR REPLACE FUNCTION test_toggle_scheduled(job_id INTEGER) RETURNS VOID LANGUAGE SQL SECURITY DEFINER AS $$ UPDATE _timescaledb_config.bgw_job SET scheduled = NOT scheduled WHERE id = $1; $$; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 \set WAIT_FOR_STANDARD_WAITLATCH 3 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION get_application_pid(app_name TEXT) RETURNS INTEGER LANGUAGE SQL AS $BODY$ SELECT pid FROM pg_stat_activity WHERE application_name = app_name; $BODY$; CREATE FUNCTION wait_application_pid(app_name TEXT, wait_for_start BOOLEAN = true) RETURNS INTEGER LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT get_application_pid(app_name) INTO r; IF (wait_for_start AND r IS NULL) OR (NOT wait_for_start AND r IS NOT NULL) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN r; END IF; END LOOP; RETURN NULL; END $BODY$; CREATE FUNCTION wait_for_logentry(job_id INTEGER) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE app_name TEXT; message TEXT; BEGIN SELECT application_name INTO app_name FROM _timescaledb_config.bgw_job WHERE id = job_id; --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT msg INTO message FROM bgw_log WHERE application_name = app_name ORDER BY msg_no DESC LIMIT 1; IF FOUND THEN RETURN message; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RETURN NULL; END $BODY$; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); -- -- Test running the scheduler with no jobs -- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); -- empty -- turn on extended display to make the many fields of the table easier to parse \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; \x off -- empty SELECT * FROM sorted_bgw_log; -- -- Test running the scheduler with a job marked as unscheduled -- TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); SELECT insert_job('unscheduled', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s',scheduled:= false); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); -- empty \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; \x off SELECT * FROM timescaledb_information.job_stats; SELECT test_toggle_scheduled(1000); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; \x off SELECT * FROM timescaledb_information.job_stats; SELECT * FROM sorted_bgw_log; SELECT delete_job(1000); -- -- test deleting job also terminates running jobs -- SELECT add_job('ts_bgw_test_job_sleep','1h') AS job_id \gset SELECT ts_bgw_db_scheduler_test_run(); SELECT wait_for_logentry(:job_id); SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; \x on SELECT job_id, job_status FROM timescaledb_information.job_stats; -- Showing non-volatile information from pg_stat_activity for -- debugging purposes. Information schema above reads from this view. SELECT datname, usename, application_name, state, query, wait_event_type, wait_event FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; \x off -- have to suppress notices here as delete_job will print pid of the running background worker processes SET client_min_messages TO WARNING; SELECT delete_job(:job_id); RESET client_min_messages; SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; -- wait for scheduler finish SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); -- -- Test running a normal job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq RESTART; SELECT ts_bgw_params_reset_time(); SELECT insert_job('test_job_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from _timescaledb_config.bgw_job; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --Tests that the scheduler start a job right away if it's the first time and there is no job_stat entry for it SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Test that the scheduler will not run job again if not enough time has passed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --After enough time has passed the scheduler will run the job again SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100, 50); SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Now it runs it one more time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(120, 100); SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- -- Test what happens when running a job that throws an error -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_2', 'bgw_test_job_2_error', INTERVAL '100ms', INTERVAL '100s', INTERVAL '100ms') AS test_job_2_id \gset \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --Run the first time and error SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; --Scheduler runs the job again, sees another error, and increases the wait time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(125); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --The job runs and fails again a few more times increasing the wait time each time. SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(225); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(425); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Once the wait time reaches 500ms it stops increasion SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(525); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- Get status of failing job `test_job_2` to check it reached `max_retries` and -- the new `job_status` now is `Paused` SELECT job_id, last_run_status, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id = :test_job_2_id; -- Alter job to be rescheduled and run it again \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT scheduled FROM alter_job(:test_job_2_id, scheduled => true) AS discard; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(525); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :test_job_2_id; SELECT * FROM sorted_bgw_log; -- -- Test timeout logic -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; --set timeout lower than job length SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '20ms', INTERVAL '50ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_params_mock_wait_returns_immediately(:IMMEDIATELY_SET_UNTIL); --Test that the scheduler kills a job that takes too long SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Check that the scheduler does not kill a job with infinite timeout \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; --set timeout to 0 SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '0', INTERVAL '10ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(550); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); -- -- Test signal handling -- --Test sending a SIGTERM to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '500ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --escalated priv needed for access to pg_stat_activity \c :TEST_DBNAME :ROLE_SUPERUSER SELECT ts_bgw_db_scheduler_test_run(300); SELECT pg_terminate_backend(wait_application_pid('test_job_3_long')); SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT * FROM sorted_bgw_log; SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; -- Test that the job is able to run again and succeed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(900); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Test sending a SIGHUP to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_STANDARD_WAITLATCH); SELECT ts_bgw_db_scheduler_test_run(-1); SHOW timescaledb.shutdown_bgw_scheduler; ALTER SYSTEM SET timescaledb.shutdown_bgw_scheduler TO 'on'; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); -- The number of scheduler restarts is not deterministic during [..]_wait_for_scheduler_finish(). -- Therefore, we filter these messages to get a deterministic test output. SELECT * FROM sorted_bgw_log WHERE msg NOT LIKE '[TESTING] Wait until%'; ALTER SYSTEM RESET timescaledb.shutdown_bgw_scheduler; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); --Test that sending SIGTERM to scheduler terminates the jobs as well \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); SELECT ts_bgw_db_scheduler_test_run(500); SELECT wait_application_pid('test_job_3_long') IS NOT NULL ; SELECT pg_terminate_backend(wait_application_pid('DB Scheduler Test')); SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT job_id, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --After a SIGTERM to scheduler and jobs, the jobs are considered crashed and there is a imposed wait of 5 min before a job can be run. --See that there is no run again because of the crash-imposed wait (not run with the 10ms retry_period) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(500); SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; --But after the 5 min period the job is again run SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(400000); SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_3_to_finish(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='After sleep job 3' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; -- -- Test starting more jobs than availlable workers -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); --Our normal limit is 8 jobs (1 already taken up by the launcher, we don't register the test scheduler) --so start 8 workers. Make the schedule_INTERVAL long and the retry period short so that the --retries happen within the scheduler run time but everything only runs once. SELECT insert_job('test_job_3_long_1', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_2', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_3', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_4', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_5', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_6', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run(25000); --quit at second 25 --the first 7 jobs will run right away, but not the last one SELECT wait_for_timer_to_run(0); SELECT wait_for_job_3_to_finish(6); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; SELECT ts_bgw_params_reset_time(30000000, true); --set to second 30, which causes a quit. SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); --should have all 8 runs, all with success runs SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; SELECT * FROM sorted_bgw_log WHERE application_name = 'DB Scheduler' ORDER BY application_name, msg_no; SELECT ts_bgw_params_destroy(); -- -- Test setting next_start time within a job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_4', 'bgw_test_job_4', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from _timescaledb_config.bgw_job; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now run and make sure next_start is 200ms away, not 100ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- Now just make sure that the job actually runs in 200ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); -- Print next_start and last_finish explicitly, instead of the difference, to make sure the times have changed -- since the last run SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- Test updating jobs list TRUNCATE bgw_log; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.stop_background_workers(); SELECT _timescaledb_functions.restart_background_workers(); SELECT _timescaledb_functions.start_background_workers(); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); CREATE OR REPLACE FUNCTION ts_test_job_refresh() RETURNS TABLE( id INTEGER, application_name NAME, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INT, retry_period INTERVAL, next_start TIMESTAMPTZ, timeout_at TIMESTAMPTZ, reserved_worker BOOLEAN, may_next_mark_end BOOLEAN ) AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION verify_refresh_correct() RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_jobs INTEGER; num_jobs_in_list INTEGER; BEGIN SELECT COUNT(*) from _timescaledb_config.bgw_job INTO num_jobs; select COUNT(*) from ts_test_job_refresh() JOIN _timescaledb_config.bgw_job USING (id,application_name,schedule_interval,max_runtime,max_retries,retry_period) INTO num_jobs_in_list; IF (num_jobs = num_jobs_in_list) THEN RETURN true; END IF; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_1_to_run(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='Execute job 1' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; select * from verify_refresh_correct(); -- Should return the same table select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job; -- Make sure jobs list is empty select count(*) from ts_test_job_refresh(); SELECT insert_job('test_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); DELETE from _timescaledb_config.bgw_job where application_name='test_2'; SELECT insert_job('test_4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_10', 'test_10', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); -- Should be idempotent select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job where application_name='another' OR application_name='another3'; SELECT insert_job('blah', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); -- Now test a real scheduler-mock running in a loop and updating the list of jobs TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); SELECT ts_bgw_db_scheduler_test_run(500); -- Wait for scheduler to start up SELECT wait_for_timer_to_run(0); SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); SELECT ts_bgw_params_reset_time(50000, true); SELECT wait_for_timer_to_run(50000); SELECT wait_for_job_1_to_run(1); SELECT ts_bgw_params_reset_time(150000, true); SELECT wait_for_timer_to_run(150000); SELECT wait_for_job_1_to_run(2); \x on select * from _timescaledb_internal.bgw_job_stat; \x off SELECT delete_job(x.id) FROM (select * from _timescaledb_config.bgw_job) x; -- test null handling in delete_job SELECT delete_job(NULL); SELECT ts_bgw_params_reset_time(200000, true); SELECT wait_for_timer_to_run(200000); -- In the next time interval, nothing should be run because scheduler should have an empty list SELECT ts_bgw_params_reset_time(300000, true); SELECT wait_for_timer_to_run(300000); -- Same for this time interval SELECT ts_bgw_params_reset_time(400000, true); SELECT wait_for_timer_to_run(400000); -- Now add a new job and make sure it gets run before the scheduler dies SELECT insert_job('new_job', 'bgw_test_job_1', INTERVAL '10ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); SELECT ts_bgw_params_reset_time(450000, true); -- New job should be run once, for a total of 3 runs of this job in the log SELECT wait_for_job_1_to_run(3); -- New job should be run again SELECT ts_bgw_params_reset_time(480000, true); SELECT wait_for_job_1_to_run(4); SELECT ts_bgw_params_reset_time(500000, true); SELECT * FROM sorted_bgw_log; \x on SELECT * FROM _timescaledb_internal.bgw_job_stat; \x off -- -- Test without retry -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); DELETE FROM _timescaledb_config.bgw_job; INSERT INTO _timescaledb_config.bgw_job(application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name) VALUES('bgw_test_job_2_error', INTERVAL '5000ms', INTERVAL '20ms', 0, INTERVAL '20ms', 'public', 'bgw_test_job_2_error') RETURNING id; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Run the first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; -- Run the second time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100, 50); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; -- We increase the mock time a lot to ensure the job does not get restarted. However, the amount of scheduler sleep/wakeup cycles -- is not deterministic. Therefore, we filter these messages to get a deterministic test output. SELECT * FROM sorted_bgw_log WHERE msg NOT LIKE '[TESTING] Wait until%'; SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; -- clean up jobs \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_db_scheduler_fixed.sql������������������������������������������0000664�0000000�0000000�00000102225�15100345067�0023617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; -- this mock_start_time doesnt seem to be used anywhere CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_test_job_sleep(job_id INT, config JSONB) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- we use insert_job instead of add_job because we want to be able to set and use max_retries, max_runtime, retry_period which are not part of the add_job api CREATE OR REPLACE FUNCTION insert_job( application_name NAME, job_type NAME, schedule_interval INTERVAL, max_runtime INTERVAL, retry_period INTERVAL, owner regrole DEFAULT pg_catalog.quote_ident(current_role)::regrole, scheduled BOOL DEFAULT true, fixed_schedule BOOL DEFAULT true ) RETURNS INT LANGUAGE SQL SECURITY DEFINER AS $$ INSERT INTO _timescaledb_config.bgw_job(application_name,schedule_interval,max_runtime,max_retries, retry_period,proc_name,proc_schema,owner,scheduled,fixed_schedule,initial_start) VALUES($1,$3,$4,5,$5,$2,'public',$6,$7,$8,'2000-01-01 00:00:00+00'::timestamptz) RETURNING id; $$; CREATE OR REPLACE FUNCTION test_toggle_scheduled(job_id INTEGER) RETURNS VOID LANGUAGE SQL SECURITY DEFINER AS $$ UPDATE _timescaledb_config.bgw_job SET scheduled = NOT scheduled WHERE id = $1; $$; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 \set WAIT_FOR_STANDARD_WAITLATCH 3 -- simply sets the wait type CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION get_application_pid(app_name TEXT) RETURNS INTEGER LANGUAGE SQL AS $BODY$ SELECT pid FROM pg_stat_activity WHERE application_name = app_name; $BODY$; CREATE FUNCTION wait_application_pid(app_name TEXT, wait_for_start BOOLEAN = true) RETURNS INTEGER LANGUAGE PLPGSQL AS $BODY$ DECLARE r INTEGER; BEGIN --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT get_application_pid(app_name) INTO r; IF (wait_for_start AND r IS NULL) OR (NOT wait_for_start AND r IS NOT NULL) THEN PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); ELSE RETURN r; END IF; END LOOP; RETURN NULL; END $BODY$; CREATE FUNCTION wait_for_logentry(job_id INTEGER) RETURNS TEXT LANGUAGE PLPGSQL AS $BODY$ DECLARE app_name TEXT; message TEXT; BEGIN SELECT application_name INTO app_name FROM _timescaledb_config.bgw_job WHERE id = job_id; --wait up to a second checking each 100ms FOR i in 1..10 LOOP SELECT msg INTO message FROM bgw_log WHERE application_name = app_name ORDER BY msg_no DESC LIMIT 1; IF FOUND THEN RETURN message; END IF; PERFORM pg_sleep(0.1); PERFORM pg_stat_clear_snapshot(); END LOOP; RETURN NULL; END $BODY$; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); -- -- Test running the scheduler with no jobs -- SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); -- empty SELECT * FROM _timescaledb_internal.bgw_job_stat; -- empty SELECT * FROM sorted_bgw_log; -- -- Test running the scheduler with a job marked as unscheduled -- TRUNCATE bgw_log; -- this function sets the counter (microseconds) that corresponds to the current time to the -- given value (defalut 0, and the default for setting the latch is false) SELECT ts_bgw_params_reset_time(); SELECT insert_job('unscheduled', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s',scheduled:= false); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); -- empty SELECT * FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM timescaledb_information.job_stats; SELECT test_toggle_scheduled(1000); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); SELECT * FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM timescaledb_information.job_stats; SELECT * FROM sorted_bgw_log; SELECT delete_job(1000); -- -- test deleting job also terminates running jobs -- SELECT add_job('ts_bgw_test_job_sleep','1h') AS job_id \gset SELECT ts_bgw_db_scheduler_test_run(); SELECT wait_for_logentry(:job_id); SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; \x on SELECT job_id, job_status FROM timescaledb_information.job_stats; -- Showing non-volatile information from pg_stat_activity for -- debugging purposes. Information schema above reads from this view. SELECT datname, usename, application_name, state, query, wait_event_type, wait_event FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; \x off -- have to suppress notices here as delete_job will print pid of the running background worker processes SET client_min_messages TO WARNING; SELECT delete_job(:job_id); RESET client_min_messages; SELECT count(*) FROM wait_for_logentry(:job_id); SELECT application_name FROM pg_stat_activity WHERE application_name LIKE 'User-Defined Action%'; -- -- Test running a normal job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; ALTER SEQUENCE _timescaledb_config.bgw_job_id_seq RESTART; SELECT ts_bgw_params_reset_time(); SELECT insert_job('test_job_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from _timescaledb_config.bgw_job; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; --Tests that the scheduler start a job right away if it's the first time and there is no job_stat entry for it SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Test that the scheduler will not run job again if not enough time has passed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --After enough time has passed the scheduler will run the job again SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100, 50); SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Now it runs it one more time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(120, 100); SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- -- Test what happens when running a job that throws an error -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; -- schedule_interval, max_runtime, retry_period SELECT insert_job('test_job_2', 'bgw_test_job_2_error', INTERVAL '800ms', INTERVAL '100s', INTERVAL '200ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; --Run the first time and error SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; SELECT last_finish, last_successful_finish, last_run_success FROM _timescaledb_internal.bgw_job_stat; -- what we aim to verify here is the following: -- 1. that the job is run again on its next scheduled slot, if the next_start calculated based -- on failure count would surpass it -- the next_start on failure is calculated by adding failure_count * retry_period to finish time -- maximum backoff is 5 * schedule interval, but for a fixed job, if we surpass the next_scheduled_slot -- for it this way, then we execute again at the next scheduled slot instead --Scheduler runs the job again, sees another error, and increases the wait time -- this retry time is before the next scheduled execution, so the job is allowed to retry before then SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(225); -- will see 2 failures now SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- as we have a job on a fixed_schedule, the next_start will not be more than the next scheduled slot -- If the calculated next_start is more than the next scheduled execution slot, then -- we will execute again at the next scheduled slot. -- again this is before the next scheduled slot so the job retries before then SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(425); -- will see 3 failures now SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- will see 4 failures now SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(625); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- will see 5 failures now because job executes again on its next scheduled slot (800ms after its initial start, which is 0) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(825); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- Get status of failing job `test_job_2` to check it reached `max_retries` and -- the new `job_status` now is `Paused` SELECT job_id, last_run_status, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id = 1001; -- Alter job to be rescheduled and run it again \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT scheduled FROM alter_job(1001, scheduled => true) AS discard; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(825); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat WHERE job_id = 1001; -- -- Test timeout logic -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; --set timeout lower than job length SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '20ms', INTERVAL '50ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_params_mock_wait_returns_immediately(:IMMEDIATELY_SET_UNTIL); --Test that the scheduler kills a job that takes too long SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Check that the scheduler does not kill a job with infinite timeout \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; --set timeout to 0 SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '0', INTERVAL '10ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(550); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); -- -- Test signal handling -- --Test sending a SIGTERM to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '500ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --escalated priv needed for access to pg_stat_activity \c :TEST_DBNAME :ROLE_SUPERUSER SELECT ts_bgw_db_scheduler_test_run(300); SELECT pg_terminate_backend(wait_application_pid('test_job_3_long')); SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT * FROM sorted_bgw_log; SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; -- Test that the job is able to run again and succeed SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(900); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --Test sending a SIGHUP to a job \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(); TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_STANDARD_WAITLATCH); SELECT ts_bgw_db_scheduler_test_run(-1); SHOW timescaledb.shutdown_bgw_scheduler; ALTER SYSTEM SET timescaledb.shutdown_bgw_scheduler TO 'on'; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT * FROM sorted_bgw_log; ALTER SYSTEM RESET timescaledb.shutdown_bgw_scheduler; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.shutdown_bgw_scheduler; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); --Test that sending SIGTERM to scheduler terminates the jobs as well \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_3_long', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); SELECT ts_bgw_db_scheduler_test_run(500); SELECT wait_application_pid('test_job_3_long') IS NOT NULL ; SELECT pg_terminate_backend(wait_application_pid('DB Scheduler Test')); SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT job_id, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; --After a SIGTERM to scheduler and jobs, the jobs are considered crashed and there is a imposed wait of 5 min before a job can be run. --See that there is no run again because of the crash-imposed wait (not run with the 10ms retry_period) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(500); SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; --But after the 5 min period the job is again run SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(400000); SELECT job_id, last_finish, next_start, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_3_to_finish(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='After sleep job 3' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; -- -- Test starting more jobs than availlable workers -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); --Our normal limit is 8 jobs (1 already taken up by the launcher, we don't register the test scheduler) --so start 8 workers. Make the schedule_INTERVAL long and the retry period short so that the --retries happen within the scheduler run time but everything only runs once. SELECT insert_job('test_job_3_long_1', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_2', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_3', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_4', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_5', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'), insert_job('test_job_3_long_6', 'bgw_test_job_3_long', INTERVAL '5000ms', INTERVAL '100s', INTERVAL '10ms'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT ts_bgw_db_scheduler_test_run(25000); --quit at second 25 --the first 7 jobs will run right away, but not the last one SELECT wait_for_timer_to_run(0); SELECT wait_for_job_3_to_finish(6); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; SELECT ts_bgw_params_reset_time(30000000, true); --set to second 30, which causes a quit. SELECT ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); --should have all 8 runs, all with success runs SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes, consecutive_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; SELECT * FROM sorted_bgw_log WHERE application_name = 'DB Scheduler' ORDER BY application_name, msg_no; SELECT ts_bgw_params_destroy(); -- -- Test setting next_start time within a job -- \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_job_4', 'bgw_test_job_4', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from _timescaledb_config.bgw_job; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now run and make sure next_start is 200ms away, not 100ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- Now just make sure that the job actually runs in 200ms SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(200); -- Print next_start and last_finish explicitly, instead of the difference, to make sure the times have changed -- since the last run SELECT job_id, next_start, last_finish, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat; SELECT * FROM sorted_bgw_log; -- Test updating jobs list TRUNCATE bgw_log; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.stop_background_workers(); SELECT _timescaledb_functions.restart_background_workers(); SELECT _timescaledb_functions.start_background_workers(); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); SET timezone TO PST8PDT; CREATE OR REPLACE FUNCTION ts_test_job_refresh() RETURNS TABLE( id INTEGER, application_name NAME, schedule_interval INTERVAL, max_runtime INTERVAL, max_retries INT, retry_period INTERVAL, next_start TIMESTAMPTZ, timeout_at TIMESTAMPTZ, reserved_worker BOOLEAN, may_next_mark_end BOOLEAN ) AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION verify_refresh_correct() RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_jobs INTEGER; num_jobs_in_list INTEGER; BEGIN SELECT COUNT(*) from _timescaledb_config.bgw_job INTO num_jobs; select COUNT(*) from ts_test_job_refresh() JOIN _timescaledb_config.bgw_job USING (id,application_name,schedule_interval,max_runtime,max_retries,retry_period) INTO num_jobs_in_list; IF (num_jobs = num_jobs_in_list) THEN RETURN true; END IF; RETURN false; END $BODY$; CREATE FUNCTION wait_for_job_1_to_run(runs INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; BEGIN FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg='Execute job 1' INTO num_runs; if (num_runs = runs) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; select * from verify_refresh_correct(); -- Should return the same table select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job; -- Make sure jobs list is empty select count(*) from ts_test_job_refresh(); SELECT insert_job('test_1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('test_3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); DELETE from _timescaledb_config.bgw_job where application_name='test_2'; SELECT insert_job('test_4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('test_10', 'test_10', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); -- Should be idempotent select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job; SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another1', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another2', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another3', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'), insert_job('another4', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); DELETE FROM _timescaledb_config.bgw_job where application_name='another' OR application_name='another3'; SELECT insert_job('blah', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s'); select * from verify_refresh_correct(); -- Now test a real scheduler-mock running in a loop and updating the list of jobs TRUNCATE _timescaledb_internal.bgw_job_stat; SELECT ts_bgw_params_reset_time(); DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); SELECT ts_bgw_db_scheduler_test_run(500); -- Wait for scheduler to start up SELECT wait_for_timer_to_run(0); SELECT insert_job('another', 'bgw_test_job_1', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); SELECT ts_bgw_params_reset_time(50000, true); SELECT wait_for_timer_to_run(50000); SELECT wait_for_job_1_to_run(1); SELECT ts_bgw_params_reset_time(150000, true); SELECT wait_for_timer_to_run(150000); SELECT wait_for_job_1_to_run(2); select * from _timescaledb_internal.bgw_job_stat; SELECT delete_job(x.id) FROM (select * from _timescaledb_config.bgw_job) x; -- test null handling in delete_job SELECT delete_job(NULL); SELECT ts_bgw_params_reset_time(200000, true); SELECT wait_for_timer_to_run(200000); -- In the next time interval, nothing should be run because scheduler should have an empty list SELECT ts_bgw_params_reset_time(300000, true); SELECT wait_for_timer_to_run(300000); -- Same for this time interval SELECT ts_bgw_params_reset_time(400000, true); SELECT wait_for_timer_to_run(400000); -- Now add a new job and make sure it gets run before the scheduler dies SELECT insert_job('new_job', 'bgw_test_job_1', INTERVAL '10ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset -- call alter_job to trigger cache invalidation SELECT alter_job(:job_id,scheduled:=true); SELECT ts_bgw_params_reset_time(450000, true); -- New job should be run once, for a total of 3 runs of this job in the log SELECT wait_for_job_1_to_run(3); -- New job should be run again SELECT ts_bgw_params_reset_time(480000, true); SELECT wait_for_job_1_to_run(4); SELECT ts_bgw_params_reset_time(500000, true); SELECT * FROM sorted_bgw_log; SELECT * FROM _timescaledb_internal.bgw_job_stat; -- clean up jobs SELECT _timescaledb_functions.stop_background_workers(); select delete_job(:job_id); -- test the new API with all its parameters: with timezone, without timezone TRUNCATE bgw_log; TRUNCATE bgw_dsm_handle_store; INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); CREATE TABLE test_table_scheduler ( time timestamptz not null, a int, b int ); select '2000-01-01 00:00:00+00' as init \gset select create_hypertable('test_table_scheduler', 'time', chunk_time_interval => interval '1 month'); INSERT INTO test_table_scheduler values (now() - interval '10 years', 1, 1), (now() - interval '8 years', 1, 1), (now() - interval '6 years', 1, 1), (now() - interval '4 years', 1, 1), (now() - interval '2 years', 1, 1), (now() - interval '1 years', 2, 2), (now() - interval '6 months', 3, 3), (now() - interval '3 months', 4, 4); CREATE MATERIALIZED VIEW cagg_scheduler(time, avg_a) WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', time), avg(a) FROM test_table_scheduler GROUP BY time_bucket('1 month', time) WITH NO DATA; SELECT set_chunk_time_interval('_timescaledb_internal._materialized_hypertable_2', interval '36500 days'); select show_chunks('test_table_scheduler'); alter table test_table_scheduler set (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); select add_retention_policy('test_table_scheduler', interval '2 year', initial_start => :'init'::timestamptz, timezone => 'Europe/Berlin'); select add_compression_policy('test_table_scheduler', interval '1 year', initial_start => :'init'::timestamptz, timezone => 'Europe/Berlin'); select add_continuous_aggregate_policy('cagg_scheduler', interval '1 year', interval '2 months', interval '3 weeks', initial_start => :'init'::timestamptz + interval '5 ms', timezone => 'Europe/Athens'); select * from _timescaledb_config.bgw_job; -- now wait for scheduler to run the policies SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * from _timescaledb_internal.bgw_job_stat; SELECT show_chunks('test_table_scheduler'); select hypertable_schema, hypertable_name, chunk_schema, chunk_name, is_compressed from timescaledb_information.chunks ; select avg_a from cagg_scheduler ORDER BY 1; -- test the API for add_job too create or replace procedure job_test_fixed(jobid int, config jsonb) language plpgsql as $$ begin raise NOTICE 'this is job_test_fixed'; end $$; \set ON_ERROR_STOP 0 select add_job('job_test_fixed', interval '7 months', initial_start => :'init'::timestamptz + interval '10 ms'); select add_job('job_test_fixed', interval '7 months', initial_start => :'init'::timestamptz + interval '10 ms', timezone => 'Europe/Athens'); -- this will fail because the timezone has a bad value select add_job('job_test_fixed', interval '8 weeks', timezone => 'EuRoPe/AmEriCa'); select add_reorder_policy('test_table_scheduler','test_table_scheduler_time_idx', initial_start => :'init'::timestamptz + interval '15 ms', timezone => 'Europe/Berlin'); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); select * from _timescaledb_config.bgw_job order by id; SELECT job_id, date_trunc('second',last_start) AS last_start, date_trunc('second',last_finish) AS last_finish, date_trunc('second',next_start) AS next_start, date_trunc('second',last_successful_finish) as last_successful_finish FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; -- test ability to switch from one type of schedule to another CREATE OR REPLACE PROCEDURE job_test(jobid int, config jsonb) language plpgsql as $$ BEGIN PERFORM pg_sleep(0.5); END $$; SELECT add_job('job_test', '8 min', fixed_schedule => false) AS jobid_drifting_1 \gset SELECT add_job('job_test', '8 min', fixed_schedule => false) AS jobid_drifting_2 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT last_finish AS finish_time_drifting_1 FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_drifting_1 \gset -- job is on fixed schedule, so changing the timezone and initial start, has no effect on its next start, -- which should be 8 min after the finish time SELECT next_start AS next_start_drifting_1 FROM alter_job(:jobid_drifting_1, schedule_interval => interval '10 min', timezone => 'Europe/Athens') \gset SELECT :'next_start_drifting_1'::timestamptz - :'finish_time_drifting_1'::timestamptz as diff_interval; -- this will print a notice about using the current time as initial start -- suppress the notice though as it will lead to flaky tests set client_min_messages = 'warning'; SELECT next_start, initial_start FROM alter_job(:jobid_drifting_1, schedule_interval => interval '10 min', fixed_schedule => true, initial_start => '-infinity') \gset -- should be 10 min SELECT :'next_start'::timestamptz - :'initial_start'::timestamptz; -- if job is not on fixed schedule, and we change it to fixed schedule, then user should also provide initial_start. -- if they don't, a notice is printed that we're using current time as initial start SELECT next_start, initial_start FROM alter_job(:jobid_drifting_2, schedule_interval => interval '10 min', fixed_schedule => true) \gset SELECT :'next_start'::timestamptz - :'initial_start'::timestamptz; reset client_min_messages; -- jobs starting with fixed schedules SELECT add_job('job_test', '1 month', initial_start => '2000-01-01 00:03') as jobid_fixed_1 \gset -- wait for the job to run, then check its next_start: (3 minutes = 180mil microseconds) SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(180000005); SELECT last_finish, next_start from _timescaledb_internal.bgw_job_stat where job_id = :jobid_fixed_1; SELECT date_part('hour',next_start)::integer, date_part('minute',next_start)::integer, date_part('second',next_start)::integer FROM alter_job(:jobid_fixed_1, initial_start => '2020-01-01 04:00'); SELECT date_part('hour',next_start)::integer, date_part('minute',next_start)::integer, date_part('second',next_start)::integer FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_fixed_1; -- go from fixed_schedule to drifting schedule SELECT ts_bgw_params_destroy(); SELECT ts_bgw_params_create(); SELECT add_job('job_test', '30 sec', initial_start => '2000-01-01 00:00:23') as jobid_fixed_2 \gset -- wait for the job to run, check the next_start, once it's finished, switch to drifting schedule and -- check the next_start again -- wait for 30 seconds to pass SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(30000025); select * from _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_fixed_2; UPDATE _timescaledb_internal.bgw_job_stat SET last_finish = last_finish + interval '10 sec', last_successful_finish = last_successful_finish + interval '10 sec' WHERE job_id = :jobid_fixed_2; -- next_start is unchanged SELECT * FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :jobid_fixed_2; -- next start is now updated SELECT alter_job(:jobid_fixed_2, fixed_schedule => false); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_job_ddl.sql�����������������������������������������������������0000664�0000000�0000000�00000010026�15100345067�0021407�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test for DDL-like functionality CREATE VIEW my_jobs AS SELECT proc_schema, proc_name, owner FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY proc_schema, proc_name, owner; GRANT SELECT ON my_jobs TO PUBLIC; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION insert_job( application_name NAME, job_type NAME, schedule_interval INTERVAL, max_runtime INTERVAL, retry_period INTERVAL, owner regrole DEFAULT CURRENT_ROLE::regrole, scheduled BOOL DEFAULT true, fixed_schedule BOOL DEFAULT false ) RETURNS INT LANGUAGE SQL SECURITY DEFINER AS $$ INSERT INTO _timescaledb_config.bgw_job(application_name,schedule_interval,max_runtime,max_retries, retry_period,proc_name,proc_schema,owner,scheduled,fixed_schedule) VALUES($1,$3,$4,5,$5,$2,'public',$6,$7,$8) RETURNING id; $$; CREATE PROCEDURE more_magic(job_id INT, config jsonb) LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'done'; END; $$; CREATE PROCEDURE some_magic(job_id INT, config jsonb) LANGUAGE plpgsql AS $$ BEGIN RAISE NOTICE 'done'; END; $$; CREATE USER another_user; SET ROLE another_user; SELECT insert_job('one_job', 'some_magic', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id_2 \gset SELECT insert_job('another_one', 'more_magic', INTERVAL '100ms', INTERVAL '100s', INTERVAL '1s') AS job_id \gset SELECT * FROM my_jobs; -- Test that reassigning to another user privileges does not work for -- a normal user. We test both users with superuser privileges and -- default permissions. \set ON_ERROR_STOP 0 REASSIGN OWNED BY another_user TO :ROLE_CLUSTER_SUPERUSER; REASSIGN OWNED BY another_user TO :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 RESET ROLE; -- Test that renaming a user changes keeps the job assigned to that user. ALTER USER another_user RENAME TO renamed_user; SELECT * FROM my_jobs; -- Test that renaming the procedure also modifies the entry in the -- jobs table. ALTER PROCEDURE more_magic RENAME TO magic; SELECT * FROM my_jobs; -- Test that modifying the schema also modifies the entry in the jobs -- table. CREATE SCHEMA frugal; ALTER PROCEDURE magic SET SCHEMA frugal; ALTER PROCEDURE some_magic SET SCHEMA frugal; SELECT * FROM my_jobs; -- Test that renaming the schema will rename the procedure schema START TRANSACTION; ALTER SCHEMA frugal RENAME TO wicked; SELECT * FROM my_jobs; ROLLBACK; \set VERBOSITY default \set ON_ERROR_STOP 0 SELECT * FROM my_jobs; -- Test that dropping a user owning a job fails. DROP USER renamed_user; -- Test that dropping the procedure fails since there is a background -- job using it. DROP PROCEDURE frugal.magic; -- Test that re-assigning objects owned by an unknown user still fails REASSIGN OWNED BY renamed_user, unknown_user TO :ROLE_DEFAULT_PERM_USER; -- Test that dropping the schema without CASCADE will error out DROP SCHEMA frugal; \set ON_ERROR_STOP 1 -- Test that reassigning the owned job actually changes the owner of -- the job. START TRANSACTION; REASSIGN OWNED BY renamed_user TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM my_jobs; ROLLBACK; -- Test that reassigning to postgres works REASSIGN OWNED BY renamed_user TO :ROLE_CLUSTER_SUPERUSER; SELECT * FROM my_jobs; -- Dropping the user now should work. DROP USER renamed_user; -- Dropping using Cascade should work and remove the background worker -- entry as well. START TRANSACTION; SELECT * FROM my_jobs; DROP PROCEDURE frugal.magic CASCADE; SELECT * FROM my_jobs; ROLLBACK; DELETE FROM _timescaledb_config.bgw_job WHERE id = :job_id; -- We should be able to drop the procedure without CASCADE now since -- it is not used by any job. DROP PROCEDURE frugal.magic; -- We should be able to drop the schema with CASCADE despite -- containing a procedure used by a background worker, but this should -- remove the job from the background worker table. SELECT * FROM my_jobs; DROP SCHEMA frugal CASCADE; SELECT * FROM my_jobs; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_job_stat_history.sql��������������������������������������������0000664�0000000�0000000�00000051324�15100345067�0023406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE PROCEDURE custom_job_ok(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE INFO 'custom_job'; END $$; CREATE PROCEDURE custom_job_error(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN PERFORM 1/0; END $$; CREATE VIEW job_history_summary AS SELECT job_id, succeeded, count(*) AS record_count FROM _timescaledb_internal.bgw_job_stat_history GROUP BY job_id, succeeded; CREATE VIEW recent_job_history_summary AS SELECT job_id, succeeded, count(*) AS record_count FROM _timescaledb_internal.bgw_job_stat_history WHERE execution_finish > now() - interval '30 days' GROUP BY job_id, succeeded; -- Do not log all jobs, only FAILED executions SHOW timescaledb.enable_job_execution_logging; SELECT add_job('custom_job_ok', schedule_interval => interval '1 hour', initial_start := now()) AS job_id_1 \gset SELECT add_job('custom_job_error', schedule_interval => interval '1 hour', initial_start := now()) AS job_id_2 \gset -- Start Background Workers SELECT _timescaledb_functions.start_background_workers(); SELECT test.wait_for_job_to_run(:job_id_1, 1); SELECT test.wait_for_job_to_run(:job_id_2, 1); -- only 1 failure SELECT count(*), succeeded FROM timescaledb_information.job_history WHERE job_id >= 1000 GROUP BY 2 ORDER BY 2; SELECT proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id >= 1000 AND succeeded IS FALSE; -- Check current jobs status SELECT job_id, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id >= 1000 ORDER BY job_id; -- Log all executions ALTER SYSTEM SET timescaledb.enable_job_execution_logging TO ON; SELECT pg_reload_conf(); -- Reconnect to make sure the GUC is set \c :TEST_DBNAME :ROLE_SUPERUSER SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); SELECT scheduled FROM alter_job(:job_id_2, next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_1, 2); SELECT test.wait_for_job_to_run(:job_id_2, 2); -- 1 succeeded 2 failures SELECT count(*), succeeded FROM timescaledb_information.job_history WHERE job_id >= 1000 GROUP BY 2 ORDER BY 2; -- Check current jobs status SELECT job_id, job_status, total_runs, total_successes, total_failures FROM timescaledb_information.job_stats WHERE job_id >= 1000 ORDER BY job_id; -- Check config changes over time SELECT scheduled FROM alter_job(:job_id_1, config => '{"foo": 1}'::jsonb); SELECT scheduled FROM alter_job(:job_id_2, config => '{"bar": 1}'::jsonb); SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); SELECT scheduled FROM alter_job(:job_id_2, next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_1, 3); SELECT test.wait_for_job_to_run(:job_id_2, 3); -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id >= 1000 ORDER BY id, job_id; -- Changing the config of one job SELECT scheduled FROM alter_job(:job_id_1, config => '{"foo": 2, "bar": 1}'::jsonb); SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_1, 4); -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id = :job_id_1 ORDER BY id; -- Change the job procedure to alter the job configuration during the execution CREATE OR REPLACE PROCEDURE custom_job_ok(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE INFO 'custom_job'; PERFORM alter_job(job_id, config => '{"config_changed_by_job_execution": 1}'::jsonb); END $$; -- Run the job SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_1, 5); -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id = :job_id_1 ORDER BY id; -- Change the job procedure to alter the job configuration during the execution CREATE OR REPLACE PROCEDURE custom_job_ok(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE INFO 'custom_job'; PERFORM alter_job(job_id, config => '{"change_not_logged": 1}'::jsonb); COMMIT; PERFORM alter_job(job_id, config => '{"only_last_change_is_logged": 1}'::jsonb); COMMIT; END $$; -- Run the job SELECT scheduled FROM alter_job(:job_id_1, next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_1, 6); -- Check job execution history SELECT job_id, pid IS NOT NULL AS pid, proc_schema, proc_name, succeeded, config, sqlerrcode, err_message FROM timescaledb_information.job_history WHERE job_id = :job_id_1 ORDER BY id; -- Alter other information about the job CREATE PROCEDURE custom_job_alter(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE LOG 'custom_job_alter'; END $$; SELECT add_job('custom_job_alter', schedule_interval => interval '1 hour', initial_start := now()) AS job_id_3 \gset SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_3, 1); SELECT timezone, fixed_schedule, config, schedule_interval FROM alter_job(:job_id_3, timezone => 'America/Sao_Paulo', fixed_schedule => false, config => '{"key": "value"}'::jsonb, schedule_interval => interval '10 min', next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(:job_id_3, 2); -- Should return two executions, the second will show the changed values SELECT job_id, succeeded, data->'job'->>'timezone' AS timezone, data->'job'->>'fixed_schedule' AS fixed_schedule, data->'job'->>'schedule_interval' AS schedule_interval, data->'job'->'config' AS config FROM _timescaledb_internal.bgw_job_stat_history WHERE job_id = :job_id_3 ORDER BY id; SELECT delete_job(:job_id_1); SELECT delete_job(:job_id_2); SELECT delete_job(:job_id_3); ALTER SYSTEM RESET timescaledb.enable_job_execution_logging; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER -- The GUC is PGC_SIGHUP context so only ALTER SYSTEM is allowed \set ON_ERROR_STOP 0 SHOW timescaledb.enable_job_execution_logging; SET timescaledb.enable_job_execution_logging TO OFF; SHOW timescaledb.enable_job_execution_logging; ALTER DATABASE :TEST_DBNAME SET timescaledb.enable_job_execution_logging TO ON; SHOW timescaledb.enable_job_execution_logging; \set ON_ERROR_STOP 1 SELECT _timescaledb_functions.stop_background_workers(); -- Test bgw_job_stat_history retention job -- Alter the drop_after interval to be fixed (30 days) to ensure tests are deterministic SELECT config AS config FROM _timescaledb_config.bgw_job WHERE id = 3 \gset SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{drop_after}', '"30 days"')); -- These configuration should fail since they are not valid. \set ON_ERROR_STOP 0 SELECT config FROM alter_job(3, config => :'config'::jsonb - 'drop_after'); SELECT config FROM alter_job(3, config => :'config'::jsonb - 'max_successes_per_job'); SELECT config FROM alter_job(3, config => :'config'::jsonb - 'max_failures_per_job'); SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_successes_per_job}', '0')); SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_failures_per_job}', '0')); SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_successes_per_job}', '"none"')); SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{max_failures_per_job}', '"none"')); \set ON_ERROR_STOP 1 -- Test 1 TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Insert test data: jobs every 15 minutes from 3 months ago to today -- Each job runs for 5 minutes (job_id=100, pid=12345) -- Fix NOW to ensure the tests are deterministic INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 100 as job_id, 12345 as pid, true as succeeded, ts as execution_start, ts + interval '5 minutes' as execution_finish, '{}'::jsonb as data FROM generate_series(now() - interval '90 days', now(), interval '15 minutes') as ts; -- Check data after insertion select * from job_history_summary; -- Test the retention job (job id 3) CALL run_job(3); -- Check data after retention SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; -- Cleanup TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 2: Empty table (no job history) CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; -- Test 3: Odd number of entries (5 entries) INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (301, 3001, true, now() - interval '60 days', now() - interval '60 days' + interval '5 minutes', '{}'), (302, 3002, true, now() - interval '6 weeks', now() - interval '6 weeks' + interval '5 minutes', '{}'), (303, 3003, true, now() - interval '30 days', now() - interval '30 days' + interval '5 minutes', '{}'), (301, 3001, true, now() - interval '2 weeks', now() - interval '2 weeks' + interval '5 minutes', '{}'), (304, 3004, true, now() - interval '1 week', now() - interval '1 week' + interval '5 minutes', '{}'); SELECT * FROM job_history_summary; CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 4: Even number of entries (6 entries) INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (401, 4001, true, now() - interval '90 days', now() - interval '90 days' + interval '5 minutes', '{}'), (402, 4002, true, now() - interval '60 days', now() - interval '60 days' + interval '5 minutes', '{}'), (403, 4003, true, now() - interval '6 weeks', now() - interval '6 weeks' + interval '5 minutes', '{}'), (401, 4001, true, now() - interval '30 days', now() - interval '30 days' + interval '5 minutes', '{}'), (404, 4004, true, now() - interval '2 weeks', now() - interval '2 weeks' + interval '5 minutes', '{}'), (402, 4002, true, now() - interval '1 week', now() - interval '1 week' + interval '5 minutes', '{}'); SELECT * FROM job_history_summary; CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 5: Missing middle job id (gaps in sequence) INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 501 + (row_number() over () % 3) as job_id, 5001 + (row_number() over () % 3) as pid, true as succeeded, ts as execution_start, ts + interval '5 minutes' as execution_finish, '{}'::jsonb as data FROM generate_series(now() - interval '60 days', now() - interval '1 week', interval '1 week') as ts; -- Delete some records to create gaps DELETE FROM _timescaledb_internal.bgw_job_stat_history WHERE id IN (SELECT id FROM _timescaledb_internal.bgw_job_stat_history ORDER BY id LIMIT 2 OFFSET 2); SELECT * FROM job_history_summary; CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 6: All records older than retention period INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (601, 6001, true, now() - interval '90 days', now() - interval '90 days' + interval '5 minutes', '{}'), (602, 6002, true, now() - interval '60 days', now() - interval '60 days' + interval '5 minutes', '{}'), (601, 6001, true, now() - interval '6 weeks', now() - interval '6 weeks' + interval '5 minutes', '{}'); SELECT * FROM job_history_summary; CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 7: No records older than retention period INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (701, 7001, true, now() - interval '1 week', now() - interval '1 week' + interval '7 minutes', '{}'), (702, 7002, true, now() - interval '6 days', now() - interval '6 days' + interval '7 minutes', '{}'), (703, 7003, true, now() - interval '7 days', now() - interval '7 days' + interval '7 minutes', '{}'), (701, 7001, true, now() - interval '4 days', now() - interval '4 days' + interval '7 minutes', '{}'); SELECT * FROM job_history_summary; CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test 8: No records older than retention period and not more than -- the expected number of successes and failures per job. SELECT config AS config FROM _timescaledb_config.bgw_job WHERE id = 3 \gset SELECT config FROM alter_job(3, config => jsonb_set(jsonb_set(:'config', '{max_failures_per_job}', '15'), '{max_successes_per_job}', '10')); INSERT INTO _timescaledb_internal.bgw_job_stat_history (job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (803, 7003, true, now() - interval '7 days', now() - interval '7 days' + interval '7 minutes', '{}'), (801, 7001, true, now() - interval '4 days', now() - interval '4 days' + interval '7 minutes', '{}'); INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 801, 7001, true, now() - format('%s hour', hours)::interval, now() - interval '1 week' + interval '7 minutes', '{}' FROM generate_series(1,20) hours; INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) SELECT 802, 7001, false, now() - format('%s minutes', hours)::interval, now() - interval '6 days' + interval '7 minutes', '{}' FROM generate_series(1,20) hours; SELECT * FROM job_history_summary; CALL run_job(3); SELECT * FROM job_history_summary; -- Verify only recent records remain SELECT * FROM recent_job_history_summary; -- Cleanup TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Test that lock_timeout can be configured SELECT config FROM alter_job(3, config => jsonb_set(:'config', '{lock_timeout}', '"1s"')); CALL run_job(3); -- Test the job_history_bsearch function directly as well -- It returns the first element where execution_finish >= search_point or NULL if no such element exists \set NOW '2025-08-15 12:34:00' -- No elements in table SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 month'); -- Single element INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 601, 6001, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'); -- Return the single element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 month'); -- Return NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 week'); TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Two elements INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 701, 7001, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (6, 702, 7002, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'); -- Returns the first element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '1 month'); -- Returns the second element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks'); -- Returns NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 days'); TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Odd number of elements INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 801, 8001, true, :'NOW'::timestamptz - interval '5 weeks', :'NOW'::timestamptz - interval '5 weeks' + interval '5 minutes', '{}'), (6, 802, 8002, true, :'NOW'::timestamptz - interval '4 weeks', :'NOW'::timestamptz - interval '4 weeks' + interval '5 minutes', '{}'), (7, 803, 8003, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (8, 804, 8004, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'), (9, 805, 8005, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'); -- Returns the first element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '6 weeks'); -- Returns the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 weeks'); -- Returns one after the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks 3 days'); -- Returns NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 days'); TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- Even number of elements INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (5, 902, 9002, true, :'NOW'::timestamptz - interval '5 weeks', :'NOW'::timestamptz - interval '5 weeks' + interval '5 minutes', '{}'), (6, 903, 9003, true, :'NOW'::timestamptz - interval '4 weeks', :'NOW'::timestamptz - interval '4 weeks' + interval '5 minutes', '{}'), (7, 904, 9004, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (8, 905, 9005, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'), (9, 906, 9006, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'), (10, 907, 9007, true, :'NOW'::timestamptz - interval '3 days', :'NOW'::timestamptz - interval '3 days' + interval '5 minutes', '{}'); -- Returns the first element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '6 weeks'); -- Returns the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 weeks'); -- Returns one after the middle element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks 3 days'); -- Returns NULL SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 days'); TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- With gaps in id INSERT INTO _timescaledb_internal.bgw_job_stat_history (id, job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (10, 1001, 10001, true, :'NOW'::timestamptz - interval '5 weeks', :'NOW'::timestamptz - interval '5 weeks' + interval '5 minutes', '{}'), (11, 1002, 10002, true, :'NOW'::timestamptz - interval '4 weeks', :'NOW'::timestamptz - interval '4 weeks' + interval '5 minutes', '{}'), (13, 1003, 10003, true, :'NOW'::timestamptz - interval '3 weeks', :'NOW'::timestamptz - interval '3 weeks' + interval '5 minutes', '{}'), (15, 1004, 10004, true, :'NOW'::timestamptz - interval '2 weeks', :'NOW'::timestamptz - interval '2 weeks' + interval '5 minutes', '{}'), (16, 1005, 10005, true, :'NOW'::timestamptz - interval '1 week', :'NOW'::timestamptz - interval '1 week' + interval '5 minutes', '{}'); -- Returns id before the gap SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '3 weeks 3 days') AS result_gap_trigger1; -- Returns id after the gap SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '2 weeks 3 days') AS result_gap_trigger2; -- Returns second element SELECT _timescaledb_functions.job_history_bsearch(:'NOW'::timestamptz - interval '4 weeks 3 days') AS result_gap_trigger3; -- Final cleanup TRUNCATE _timescaledb_internal.bgw_job_stat_history; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_job_stat_history_errors.sql�������������������������������������0000664�0000000�0000000�00000013632�15100345067�0025002�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set client_min_messages TO NOTICE; create or replace procedure job_fail(jobid int, config jsonb) language plpgsql as $$ begin perform pg_sleep(2); raise exception 'raising an exception'; end $$; -- very simple case: job that raises an exception select add_job('job_fail', '4 minutes') as jobf_id \gset -- test jobs that try to update concurrently CREATE TABLE custom_log ( a int, b int, msg text ); insert into custom_log values (0, 0, 'msg0'); ALTER SYSTEM SET DEFAULT_TRANSACTION_ISOLATION TO 'serializable'; SELECT pg_reload_conf(); -- Reconnect to make sure the GUC is set \c :TEST_DBNAME :ROLE_SUPERUSER -- test a concurrent update CREATE OR REPLACE PROCEDURE custom_proc1(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE custom_log set msg = 'msg1' where msg = 'msg0'; perform pg_sleep(5); COMMIT; END $$; CREATE OR REPLACE PROCEDURE custom_proc2(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE custom_log set msg = 'msg2' where msg = 'msg0'; COMMIT; END $$; select add_job('custom_proc1', '2 min', initial_start => now()); -- to make sure custom_log is first updated by custom_proc_1 select add_job('custom_proc2', '2 min', initial_start => now() + interval '2 seconds'); SELECT _timescaledb_functions.start_background_workers(); -- enough time to for job_fail to fail select pg_sleep(5); select job_id, data->'job'->>'proc_name' as proc_name, data->'error_data'->>'message' as err_message, data->'error_data'->>'sqlerrcode' as sqlerrcode from _timescaledb_internal.bgw_job_stat_history where job_id = :jobf_id and succeeded is false; select delete_job(:jobf_id); select pg_sleep(5); -- exclude internal jobs select job_id, data->'job'->>'proc_name' as proc_name, data->'error_data'->>'message' as err_message, data->'error_data'->>'sqlerrcode' as sqlerrcode from _timescaledb_internal.bgw_job_stat_history WHERE job_id >= 1000 and succeeded is false; ALTER SYSTEM RESET DEFAULT_TRANSACTION_ISOLATION; SELECT pg_reload_conf(); -- Reconnect to make sure the GUC is set \c :TEST_DBNAME :ROLE_SUPERUSER -- test the retention job SELECT next_start FROM alter_job(3, next_start => '2060-01-01 00:00:00+00'::timestamptz); DELETE FROM _timescaledb_internal.bgw_job_stat_history; INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (123, 12345, false, '2000-01-01 00:00:00+00'::timestamptz, '2000-01-01 00:00:10+00'::timestamptz, '{}'), (456, 45678, false, '2000-01-01 00:00:20+00'::timestamptz, '2000-01-01 00:00:40+00'::timestamptz, '{}'), -- not older than a month (123, 23456, false, '2050-01-01 00:00:00+00'::timestamptz, '2050-01-01 00:00:10+00'::timestamptz, '{}'); -- 3 rows in the table before policy runs SELECT job_id, pid, succeeded, execution_start, execution_finish, data FROM _timescaledb_internal.bgw_job_stat_history WHERE succeeded IS FALSE; -- drop all job_stats for the retention job DELETE FROM _timescaledb_internal.bgw_job_stat WHERE job_id = 3; SELECT FROM alter_job(3, next_start => now()); SELECT _timescaledb_functions.restart_background_workers(); SELECT test.wait_for_job_to_run(3, 1); -- only the last row remains SELECT job_id, pid, succeeded, execution_start, execution_finish, data FROM _timescaledb_internal.bgw_job_stat_history WHERE succeeded IS FALSE; -- test failure when starting jobs \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); -- Job didn't finish yet and Crash detected DELETE FROM _timescaledb_internal.bgw_job_stat_history; INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (1, NULL, NULL, '2000-01-01 00:00:00+00'::timestamptz, NULL, '{}'), -- Crash server detected (2, 2222, false, '2000-01-01 00:00:00+00'::timestamptz, NULL, '{}'), -- Didn't finished yet (3, 3333, false, '2000-01-01 00:00:00+00'::timestamptz, '2000-01-01 01:00:00+00'::timestamptz, '{}'), -- Finish with ERROR (4, 4444, true, '2000-01-01 00:00:00+00'::timestamptz, '2000-01-01 01:00:00+00'::timestamptz, '{}'); -- Finish with SUCCESS SELECT job_id, pid, succeeded, start_time, finish_time, config, err_message FROM timescaledb_information.job_history ORDER BY job_id; SELECT job_id, pid, start_time, finish_time, err_message FROM timescaledb_information.job_errors ORDER BY job_id; DELETE FROM _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_internal.bgw_job_stat_history; DELETE FROM _timescaledb_config.bgw_job CASCADE; SELECT _timescaledb_functions.start_background_workers(); \set VERBOSITY default -- Setup Jobs DO $TEST$ DECLARE stmt TEXT; njobs INT := 26; BEGIN RAISE INFO 'Creating % jobs', njobs; FOR stmt IN SELECT format('CREATE PROCEDURE custom_job%s(job_id int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN PERFORM pg_sleep(0.1); END; $$', i) FROM generate_series(1, njobs) AS i LOOP EXECUTE stmt; END LOOP; RAISE INFO 'Scheduling % jobs', njobs; PERFORM add_job(format('custom_job%s', i)::regproc, schedule_interval => interval '1 hour', initial_start := now()) FROM generate_series(1, njobs) AS i; END; $TEST$; SELECT _timescaledb_functions.restart_background_workers(); -- Wait for jobs to run DO $TEST$ DECLARE njobs INT := 26; BEGIN RAISE INFO 'Waiting for the % jobs to run', njobs; SET LOCAL client_min_messages TO WARNING; PERFORM test.wait_for_job_to_run_or_fail(id) FROM _timescaledb_config.bgw_job WHERE id >= 1000; END; $TEST$; SELECT count(*) > 0 FROM timescaledb_information.job_history WHERE succeeded IS FALSE AND err_message ~ 'failed to start job'; SELECT count(*) > 0 FROM timescaledb_information.job_errors WHERE err_message ~ 'failed to start job'; \set VERBOSITY terse \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); ������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_job_stat_history_errors_permissions.sql�������������������������0000664�0000000�0000000�00000006341�15100345067�0027434�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Table to update concurrently to generate error message CREATE TABLE my_table (a int, b int); INSERT INTO my_table VALUES (0, 0); GRANT ALL ON my_table TO PUBLIC; ALTER SYSTEM SET DEFAULT_TRANSACTION_ISOLATION TO 'serializable'; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE OR REPLACE PROCEDURE job_fail(jobid int, config jsonb) AS $$ BEGIN RAISE EXCEPTION 'raising an exception'; END $$ LANGUAGE plpgsql; SELECT add_job('job_fail', '4 minutes', initial_start => now()) as job_fail_id \gset CREATE OR REPLACE PROCEDURE custom_proc1(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE my_table SET b = 1 WHERE a = 0; PERFORM pg_sleep(5); COMMIT; END $$; SELECT add_job('custom_proc1', '2 min', initial_start => now()) as custom_proc1_id \gset SET ROLE :ROLE_DEFAULT_PERM_USER_2; CREATE OR REPLACE PROCEDURE custom_proc2(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN UPDATE my_table SET b = 2 WHERE a = 0; PERFORM pg_sleep(5); COMMIT; END $$; -- to make sure custom_log is first updated by custom_proc_1 select add_job('custom_proc2', '2 min', initial_start => now() + interval '1 seconds') as custom_proc2_id \gset SET ROLE :ROLE_SUPERUSER; SELECT _timescaledb_functions.start_background_workers(); SELECT pg_sleep(6); \d timescaledb_information.job_errors -- We add a few entries without a matching job id, so that we get a -- null owner. Note that the second entry does not have a message -- defined, so it will print a standardized message assuming that the -- job crashed. \set start '2000-01-01 00:00:00+00' \set finish '2000-01-01 00:00:10+00' INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) VALUES (11111, 12345, false, :'start'::timestamptz, :'finish'::timestamptz, '{"error_data": {"message": "not an error"}}'), (22222, 45678, false, :'start'::timestamptz, NULL, '{}'), -- Started and didn't finished yet (33333, NULL, NULL, :'start'::timestamptz, NULL, NULL); -- Crash detected cause not assigned an PID -- We check the log as different users and should only see what we -- have permissions to see. We only bother about jobs at 1000 or -- larger since the standard jobs are flaky. SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT job_id, proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_errors WHERE job_id >= 1000 ORDER BY job_id; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT job_id, proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_errors WHERE job_id >= 1000 ORDER BY job_id; SET ROLE :ROLE_SUPERUSER; SELECT job_id, proc_schema, proc_name, sqlerrcode, err_message FROM timescaledb_information.job_errors WHERE job_id >= 1000 ORDER BY job_id; SELECT delete_job(:custom_proc2_id); SELECT delete_job(:custom_proc1_id); SELECT delete_job(:job_fail_id); ALTER SYSTEM RESET DEFAULT_TRANSACTION_ISOLATION; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_policy.sql������������������������������������������������������0000664�0000000�0000000�00000044117�15100345067�0021321�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE FUNCTION reorder_called(chunk_id INT) RETURNS BOOL AS $$ SELECT indisclustered FROM _timescaledb_catalog.chunk ch JOIN pg_index i on indrelid = format('%I.%I',ch.schema_name,ch.table_name)::regclass WHERE ch.id = chunk_id; $$ LANGUAGE SQL; CREATE TABLE test_table(time timestamptz, chunk_id int); SELECT create_hypertable('test_table', 'time'); -- These inserts should create 5 different chunks INSERT INTO test_table VALUES (now() - INTERVAL '3 weeks', 1); INSERT INTO test_table VALUES (now(), 2); INSERT INTO test_table VALUES (now() - INTERVAL '5 months', 3); INSERT INTO test_table VALUES (now() - INTERVAL '3 months', 4); INSERT INTO test_table VALUES (now() - INTERVAL '8 months', 5); SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table'; -- Make sure reorder correctly selects chunks to reorder -- by starting with oldest chunks select add_reorder_policy('test_table', 'test_table_time_idx') as reorder_job_id \gset select * from _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; -- Make a manual calls to reorder: make sure the correct chunk is called -- Chunk 5 should be first CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; -- Confirm that reorder was called on the correct chunk Oid SELECT reorder_called(5); -- Chunk 3 is next CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT reorder_called(3); -- Chunk 4 is next CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT reorder_called(4); -- The following calls should not reorder any chunk, because they're all too new CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; INSERT INTO test_table VALUES (now() - INTERVAL '7 days', 6); -- This call should reorder chunk 1 CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT reorder_called(1); -- Should not reorder anything, because all chunks are too new CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; select remove_reorder_policy('test_table'); -- Now do drop_chunks test select add_retention_policy('test_table', INTERVAL '4 months', true) as drop_chunks_job_id \gset SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table'; -- Now simulate drop_chunks running automatically by calling it explicitly CALL run_job(:drop_chunks_job_id); -- Should have 4 chunks left SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset before_ select :before_count=4; -- Make sure this second call does nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset after_ -- Should be true select :before_count=:after_count; INSERT INTO test_table VALUES (now() - INTERVAL '2 weeks', 1); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset before_ -- This call should also do nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table' \gset after_ -- Should be true select :before_count=:after_count; select remove_retention_policy('test_table'); -- Now test reorder chunk selection when there is space partitioning TRUNCATE test_table; SELECT add_dimension('public.test_table', 'chunk_id', 2); INSERT INTO test_table VALUES (now() - INTERVAL '3 weeks', 1); INSERT INTO test_table VALUES (now(), 2); INSERT INTO test_table VALUES (now() - INTERVAL '5 months', 3); INSERT INTO test_table VALUES (now() - INTERVAL '3 months', 4); INSERT INTO test_table VALUES (now() - INTERVAL '3 months', -4); INSERT INTO test_table VALUES (now() - INTERVAL '8 months', 5); INSERT INTO test_table VALUES (now() - INTERVAL '8 months', -5); select add_reorder_policy('test_table', 'test_table_time_idx') as reorder_job_id \gset -- Should be nothing in the chunk_stats table select count(*) from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id; -- Make a manual calls to reorder: make sure the correct (oldest) chunk is called select chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; -- Confirm that reorder was called on the correct chunk Oid SELECT reorder_called(:oldest_chunk_id); -- Now run reorder again and pick the next oldest chunk select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; -- Confirm that reorder was called on the correct chunk Oid SELECT reorder_called(:oldest_chunk_id); -- Again select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; SELECT reorder_called(:oldest_chunk_id); -- Again select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; SELECT reorder_called(:oldest_chunk_id); -- Again select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; SELECT reorder_called(:oldest_chunk_id); -- Ran out of chunks, so should be a noop CALL run_job(:reorder_job_id); -- Corner case: when there are no recent-enough chunks to reorder, -- DO NOT reorder any new chunks created by space partitioning. -- We only want to reorder when new dimension_slices on time are created. INSERT INTO test_table VALUES (now() - INTERVAL '5 months', -5); INSERT INTO test_table VALUES (now() - INTERVAL '3 weeks', -5); INSERT INTO test_table VALUES (now(), -25); -- Should be noop CALL run_job(:reorder_job_id); -- But if we create a new time dimension, reorder it INSERT INTO test_table VALUES (now() - INTERVAL '1 year', 1); select cc.chunk_id from _timescaledb_catalog.dimension_slice as ds, _timescaledb_catalog.chunk_constraint as cc where ds.dimension_id=1 and ds.id=cc.dimension_slice_id and cc.chunk_id NOT IN (select chunk_id from _timescaledb_internal.bgw_policy_chunk_stats) ORDER BY ds.range_start LIMIT 1 \gset oldest_ CALL run_job(:reorder_job_id); select job_id, chunk_id, num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats where job_id=:reorder_job_id and chunk_id=:oldest_chunk_id; SELECT reorder_called(:oldest_chunk_id); -- Should be noop again CALL run_job(:reorder_job_id); CREATE TABLE test_table_int(time bigint, junk int); CREATE TABLE test_overflow_smallint(time smallint, junk int); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 1); SELECT create_hypertable('test_overflow_smallint', 'time', chunk_time_interval => 1); create or replace function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; create or replace function dummy_now2() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 2::BIGINT'; create or replace function overflow_now() returns SMALLINT LANGUAGE SQL IMMUTABLE as 'SELECT 32767::SMALLINT'; CREATE TABLE test_table_perm(time timestamp PRIMARY KEY); SELECT create_hypertable('test_table_perm', 'time', chunk_time_interval => 1); \set ON_ERROR_STOP 0 -- we cannot add a drop_chunks policy on a table whose open dimension is not time and no now_func is set select add_retention_policy('test_table_int', INTERVAL '4 months', true); \set ON_ERROR_STOP 1 INSERT INTO test_table_int VALUES (-2, -2), (-1, -1), (0,0), (1, 1), (2, 2), (3, 3); \c :TEST_DBNAME :ROLE_SUPERUSER; CREATE USER unprivileged; \c :TEST_DBNAME unprivileged -- should fail as the user has no permissions on the table \set ON_ERROR_STOP 0 select set_integer_now_func('test_table_int', 'dummy_now'); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER; DROP USER unprivileged; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select set_integer_now_func('test_table_int', 'dummy_now'); select * from test_table_int; SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int'; select add_retention_policy('test_table_int', 1, true) as drop_chunks_job_id \gset -- Now simulate drop_chunks running automatically by calling it explicitly CALL run_job(:drop_chunks_job_id); select * from test_table_int; -- Should have 4 chunks left SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset before_ select :before_count=4; -- Make sure this second call does nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ -- Should be true select :before_count=:after_count; INSERT INTO test_table_int VALUES (42, 42); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset before_ -- This call should also do nothing CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ -- Should be true select :before_count=:after_count; INSERT INTO test_table_int VALUES (-1, -1); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset add_one_ select :before_count+1=:add_one_count; CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ -- (-1,-1) was in droping range so it should be dropped by background job select :before_count=:after_count; select set_integer_now_func('test_table_int', 'dummy_now2', replace_if_exists=>true); select * from test_table_int; CALL run_job(:drop_chunks_job_id); -- added one to now() so time entry with value 0 should be dropped now SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ select :before_count=:after_count+1; select * from test_table_int; -- make the now() function invalid -- returns INT and not BIGINT drop function dummy_now2(); create or replace function dummy_now2() returns INT LANGUAGE SQL IMMUTABLE as 'SELECT 2::INT'; \set ON_ERROR_STOP 0 CALL run_job(:drop_chunks_job_id); \set ON_ERROR_STOP 1 -- test the expected use case of set_integer_now_func create function nowstamp() returns bigint language sql STABLE as 'SELECT extract(epoch from now())::BIGINT'; select set_integer_now_func('test_table_int', 'nowstamp', replace_if_exists=>true); CALL run_job(:drop_chunks_job_id); SELECT count(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_table_int' \gset after_ select :after_count=0; -- test the case when now()-interval overflows select set_integer_now_func('test_overflow_smallint', 'overflow_now'); select add_retention_policy('test_overflow_smallint', -2) as drop_chunks_job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:drop_chunks_job_id); \set ON_ERROR_STOP 1 -- test the case when partitioning function and now function are set. create table part_time_now_func(time float8, temp float8); create or replace function time_partfunc(unixtime float8) returns bigint language plpgsql immutable as $body$ declare retval bigint; begin retval := unixtime::bigint; raise notice 'time value for % is %', unixtime, retval; return retval; end $body$; create or replace function dummy_now() returns bigint language sql immutable as 'select 2::bigint'; select create_hypertable('part_time_now_func', 'time', time_partitioning_func => 'time_partfunc', chunk_time_interval=>1); insert into part_time_now_func values (1.1, 23.4), (2.2, 22.3), (3.3, 42.3); select * from part_time_now_func; select set_integer_now_func('part_time_now_func', 'dummy_now'); select add_retention_policy('part_time_now_func', 0) as drop_chunks_job_id \gset CALL run_job(:drop_chunks_job_id); select * from part_time_now_func; select remove_retention_policy('part_time_now_func'); \c :TEST_DBNAME :ROLE_SUPERUSER alter function dummy_now() rename to dummy_now_renamed; alter schema public rename to new_public; select * from _timescaledb_catalog.dimension; alter schema new_public rename to public; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- test that the behavior is strict when providing NULL required arguments create table test_strict (time timestamptz not null, a int, b int); select create_hypertable('test_strict', 'time'); \set ON_ERROR_STOP 0 select add_reorder_policy('test_table_perm', 'test_table_perm_pkey'); select remove_reorder_policy('test_table'); select add_retention_policy('test_table_perm', INTERVAL '4 months', true); select remove_retention_policy('test_table'); select add_retention_policy('test_strict', drop_after => NULL); \set ON_ERROR_STOP 1 -- Check the number of non-internal policies SELECT proc_name, count(*) FROM _timescaledb_config.bgw_job WHERE id >= 1000 GROUP BY proc_name; -- test retention with null arguments select add_retention_policy(NULL, NULL); select add_retention_policy(NULL, drop_after => interval '2 days'); -- this is an optional argument select add_retention_policy('test_strict', drop_after => interval '2 days', if_not_exists => NULL); select add_retention_policy('test_strict', interval '2 days', schedule_interval => NULL); -- test compression with null arguments alter table test_strict set (timescaledb.compress); select add_compression_policy(NULL, compress_after => NULL); select add_compression_policy('test_strict', INTERVAL '2 weeks', if_not_exists => NULL); select add_compression_policy('test_strict', INTERVAL '2 weeks', schedule_interval => NULL); -- test that we get the default schedule_interval if nothing is specified create table test_missing_schedint (time timestamptz not null, a int, b int); select create_hypertable('test_missing_schedint', 'time', chunk_time_interval=> '31days'::interval); -- we expect shedule_interval to be 1 day select add_retention_policy('test_missing_schedint', interval '2 weeks') as retenion_id_missing_schedint \gset -- we expect schedule_interval to be chunk_time_interval/2 for timestamptz time alter table test_missing_schedint set (timescaledb.compress); select add_compression_policy('test_missing_schedint', interval '60 days') as compression_id_missing_schedint \gset -- we expect schedule_interval to be 1 day for int time create table test_missing_schedint_integer (time int not null, a int, b int); -- 10 days interval select create_hypertable('test_missing_schedint_integer', 'time', chunk_time_interval => 864000000); alter table test_missing_schedint_integer set (timescaledb.compress); select add_compression_policy('test_missing_schedint_integer', BIGINT '600000') as compression_id_integer \gset select * from _timescaledb_config.bgw_job where id in (:retenion_id_missing_schedint, :compression_id_missing_schedint, :compression_id_integer); -- test policy check functions with NULL args \set ON_ERROR_STOP 0 select add_compression_policy('test_strict', compress_after => NULL); SELECT _timescaledb_functions.policy_compression_check(NULL); SELECT _timescaledb_functions.policy_refresh_continuous_aggregate_check(NULL); SELECT _timescaledb_functions.policy_reorder_check(NULL); SELECT _timescaledb_functions.policy_retention_check(NULL); \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_reorder_drop_chunks.sql�����������������������������������������0000664�0000000�0000000�00000034345�15100345067�0024065�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(CASE WHEN length(msg) > 80 THEN substring(msg, 1, 80) || '...' ELSE msg END, '(execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); SELECT * FROM _timescaledb_config.bgw_job; SELECT * FROM timescaledb_information.job_stats; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ------------------------------ -- test reorder policy runs -- ------------------------------ CREATE TABLE test_reorder_table(time int, chunk_id int); SELECT create_hypertable('test_reorder_table', 'time', chunk_time_interval => 1); -- These inserts should create 5 different chunks INSERT INTO test_reorder_table VALUES (1, 1); INSERT INTO test_reorder_table VALUES (2, 2); INSERT INTO test_reorder_table VALUES (3, 3); INSERT INTO test_reorder_table VALUES (4, 4); INSERT INTO test_reorder_table VALUES (5, 5); SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_reorder_table'; SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_reorder'; select add_reorder_policy('test_reorder_table', 'test_reorder_table_time_idx') as reorder_job_id \gset SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_reorder'; -- job was created SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; -- nothing clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; -- job ran once, successfully SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; -- first chunk reordered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- second call to scheduler should immediately run reorder again, due to catchup SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; -- two runs SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; -- two chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- third call to scheduler should immediately run reorder again, due to catchup SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50); -- job info is gone SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; SELECT * FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; -- three chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- running is a nop SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(100); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; SELECT * FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; -- still have 3 chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; --check that views work correctly SELECT * FROM timescaledb_information.job_stats; -- test deleting the policy SELECT remove_reorder_policy('test_reorder_table'); SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(125); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:reorder_job_id; -- still only 3 chunks clustered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_reset_time(); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER ----------------------------------- -- test drop chunks policy runs -- ----------------------------------- CREATE TABLE test_drop_chunks_table(time timestamptz, drop_order int); SELECT create_hypertable('test_drop_chunks_table', 'time', chunk_time_interval => INTERVAL '1 week'); -- These inserts should create 5 different chunks INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_drop_chunks_table VALUES (now(), 5); INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '8 months', 1); SELECT show_chunks('test_drop_chunks_table'); SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_drop_chunks_table'; SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; SELECT add_retention_policy('test_drop_chunks_table', INTERVAL '4 months') as drop_chunks_job_id \gset SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; SELECT alter_job(:drop_chunks_job_id, schedule_interval => INTERVAL '1 second'); SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:drop_chunks_job_id; -- all chunks are there SELECT show_chunks('test_drop_chunks_table'); -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; -- job ran once, successfully SELECT job_id, time_bucket('1m',next_start) AS next_start, time_bucket('1m',last_finish) as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:drop_chunks_job_id; -- chunks 8 and 10 dropped SELECT show_chunks('test_drop_chunks_table'); -- job doesn't run again immediately SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; -- still only 1 run SELECT job_id, time_bucket('1m',next_start) AS next_start, time_bucket('1m',last_finish) as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:drop_chunks_job_id; -- same chunks SELECT show_chunks('test_drop_chunks_table'); -- a new chunk older than the drop date will be dropped INSERT INTO test_drop_chunks_table VALUES (now() - INTERVAL '12 months', 0); SELECT show_chunks('test_drop_chunks_table'); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(10000); SELECT * FROM sorted_bgw_log; SELECT * FROM timescaledb_information.jobs WHERE job_id=:drop_chunks_job_id; -- 2 runs SELECT job_id, time_bucket('1m',next_start) AS next_start, time_bucket('1m',last_finish) as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:drop_chunks_job_id; SELECT show_chunks('test_drop_chunks_table'); --test that views work SELECT * FROM timescaledb_information.job_stats; -- Test that add_retention_policy also works with timestamp (without time zone) and date types -- and that the policy execution is being logged -- Test for date CREATE TABLE test_drop_chunks_table_date(time date, drop_order int); SELECT create_hypertable('test_drop_chunks_table_date', 'time', chunk_time_interval => INTERVAL '1 week'); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_drop_chunks_table_date VALUES (now(), 5); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_drop_chunks_table_date VALUES (now() - INTERVAL '8 months', 1); -- Clear the job stats and reset timer, this will also clear the bgw_log \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; TRUNCATE _timescaledb_internal.bgw_job_stat; DELETE FROM _timescaledb_config.bgw_job; SELECT ts_bgw_params_reset_time(); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Test for timestamp CREATE TABLE test_drop_chunks_table_tsntz(time date, drop_order int); SELECT create_hypertable('test_drop_chunks_table_tsntz', 'time', chunk_time_interval => INTERVAL '1 week'); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_drop_chunks_table_tsntz VALUES (now(), 5); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_drop_chunks_table_tsntz VALUES (now() - INTERVAL '8 months', 1); -- Add retention policies for both tables SELECT add_retention_policy('test_drop_chunks_table_date', INTERVAL '4 months') as drop_chunks_date_job_id \gset SELECT add_retention_policy('test_drop_chunks_table_tsntz', INTERVAL '4 months') as drop_chunks_tsntz_job_id \gset -- Test that retention policy is being logged SELECT alter_job(id,config:=jsonb_set(config,'{verbose_log}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :drop_chunks_date_job_id; SELECT alter_job(id,config:=jsonb_set(config,'{verbose_log}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :drop_chunks_tsntz_job_id; SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000); SELECT * FROM sorted_bgw_log; -- test the schedule_interval parameter for policies CREATE TABLE test_schedint(time timestamptz, a int, b int); select create_hypertable('test_schedint', 'time'); insert into test_schedint values (now(), 1, 2), (now() + interval '2 seconds', 2, 3); -- test the retention policy select add_retention_policy('test_schedint', interval '2 months', schedule_interval => '30 seconds') as polret_schedint \gset -- wait for a bit more than "schedule_interval" seconds, then verify the policy has run twice select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000); select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polret_schedint; select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(30000); select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polret_schedint; -- if we wait another 30s, we should see 3 runs of the job select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(30000); select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polret_schedint; -- test the compression policy alter table test_schedint set (timescaledb.compress); select add_compression_policy('test_schedint', interval '3 weeks', schedule_interval => '40 seconds') as polcomp_schedint \gset select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000); select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polcomp_schedint; select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(40000); select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polcomp_schedint; -- if we wait another 40s, we should see 3 runs of the job select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(40000); select total_runs, total_successes, total_failures from timescaledb_information.job_stats where job_id = :polcomp_schedint; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_scheduler_control.sql�������������������������������������������0000664�0000000�0000000�00000010266�15100345067�0023536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(INT, INT) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE FUNCTION ts_bgw_params_reset_time(set_time BIGINT, wait BOOLEAN) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; ALTER DATABASE :TEST_DBNAME OWNER TO :ROLE_DEFAULT_PERM_USER; GRANT EXECUTE ON FUNCTION pg_reload_conf TO :ROLE_DEFAULT_PERM_USER; GRANT ALTER SYSTEM, SET ON PARAMETER timescaledb.bgw_log_level TO :ROLE_DEFAULT_PERM_USER; -- These are needed to set up the test scheduler CREATE TABLE public.bgw_dsm_handle_store(handle BIGINT); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); -- Test scheduler automatically writes to this table by name, so -- create it. CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW cleaned_bgw_log AS SELECT msg_no, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time|database) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; -- Remove all default jobs DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; -- -- Set bgw log level and reload config. -- -- Debug messages should be in log now which it wasn't before. -- -- We change user to make sure that granting SET and ALTER SYSTEM -- privileges to the default user actually works. SET ROLE :ROLE_DEFAULT_PERM_USER; ALTER DATABASE :TEST_DBNAME SET timescaledb.bgw_log_level = 'DEBUG1'; SELECT pg_reload_conf(); RESET ROLE; SELECT ts_bgw_params_reset_time(0, false); INSERT INTO _timescaledb_config.bgw_job( application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name, owner, scheduled, fixed_schedule ) VALUES ( 'test_job_1b', --application_name INTERVAL '100ms', --schedule_interval INTERVAL '100s', --max_runtime 5, --max_retries INTERVAL '1s', --retry_period 'public', --proc_schema 'bgw_test_job_1', --proc_name CURRENT_ROLE::regrole, --owner TRUE, --scheduled FALSE --fixed_schedule ) RETURNING id AS job_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); SELECT * FROM cleaned_bgw_log; -- We test that we can set it to FATAL, which removed LOG level -- entries from the log. ALTER DATABASE :TEST_DBNAME SET timescaledb.bgw_log_level = 'FATAL'; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(0, false); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); SELECT * FROM cleaned_bgw_log; -- We test that we can set it to ERROR. ALTER DATABASE :TEST_DBNAME SET timescaledb.bgw_log_level = 'ERROR'; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(0, false); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); SELECT * FROM cleaned_bgw_log; -- Reset the log level and check that normal entries are showing up -- again. ALTER DATABASE :TEST_DBNAME RESET timescaledb.bgw_log_level; SELECT pg_reload_conf(); \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE bgw_log; SELECT ts_bgw_params_reset_time(0, false); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 0); SELECT * FROM cleaned_bgw_log; SELECT delete_job(:job_id); SET ROLE :ROLE_DEFAULT_PERM_USER; -- Make sure we can set the variable using ALTER SYSTEM using the -- previous grants. We don't bother about checking that it has an -- effect here since we already knows it works from the above code. ALTER SYSTEM SET timescaledb.bgw_log_level TO 'DEBUG2'; ALTER SYSTEM RESET timescaledb.bgw_log_level; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_scheduler_restart.sql�������������������������������������������0000664�0000000�0000000�00000012637�15100345067�0023546�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW tsdb_bgw AS SELECT datname, pid, backend_type, application_name FROM pg_stat_activity WHERE backend_type LIKE '%TimescaleDB%' ORDER BY datname, backend_type, application_name; -- Wait for at least one background worker matching pattern to have -- started. CREATE PROCEDURE wait_for_some_started( min_time double precision, timeout double precision, pattern text ) AS $$ DECLARE backend_count int; BEGIN FOR i IN 0..(timeout / min_time)::int LOOP PERFORM pg_sleep(min_time); SELECT count(*) INTO backend_count FROM tsdb_bgw WHERE backend_type LIKE pattern; IF backend_count > 0 THEN RETURN; END IF; END LOOP; RAISE EXCEPTION 'backend matching % did not start before timeout', pattern; END; $$ LANGUAGE plpgsql; -- Wait for the number of background workers matching pattern to be -- zero. CREATE PROCEDURE wait_for_all_stopped( min_time double precision, timeout double precision, pattern text ) AS $$ DECLARE backend_count int; BEGIN FOR i IN 0..(timeout / min_time)::int LOOP PERFORM pg_sleep(min_time); SELECT count(*) INTO backend_count FROM tsdb_bgw WHERE backend_type LIKE pattern; IF backend_count = 0 THEN RETURN; END IF; END LOOP; RAISE EXCEPTION 'backend matching % did not start before timeout', pattern; END; $$ LANGUAGE plpgsql; CREATE PROCEDURE ts_terminate_launcher() AS $$ SELECT pg_terminate_backend(pid) FROM tsdb_bgw WHERE backend_type LIKE '%Launcher%'; $$ LANGUAGE SQL; -- Show the default scheduler restart time SHOW timescaledb.bgw_scheduler_restart_time; -- Test that it cannot be set to something between -1 and 10 \set ON_ERROR_STOP 0 \set VERBOSITY default ALTER SYSTEM SET timescaledb.bgw_scheduler_restart_time TO '5s'; \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Set scheduler restart time to a lower value to make the test a -- little faster. ALTER SYSTEM SET timescaledb.bgw_scheduler_restart_time TO '10s'; ALTER SYSTEM SET timescaledb.debug_bgw_scheduler_exit_status TO 1; SELECT pg_reload_conf(); -- Reconnect and check the restart time to make sure that it is -- correct. \c :TEST_DBNAME :ROLE_SUPERUSER SHOW timescaledb.bgw_scheduler_restart_time; -- Launcher is running, so we need to restart it for the scheduler -- restart time to take effect. SELECT datname, application_name FROM tsdb_bgw; CALL ts_terminate_launcher(); -- It will restart automatically, but we wait for it to start. CALL wait_for_some_started(1, 50, '%Launcher%'); -- Make sure that the new value of the scheduler restart time is -- correct or the rest of the tests will fail. SHOW timescaledb.bgw_scheduler_restart_time; -- Verify that launcher is running. If it is not, the rest of the test -- will fail. SELECT datname, application_name FROM tsdb_bgw; -- Now we can start the background workers. SELECT _timescaledb_functions.start_background_workers(); -- They should start immediately, but let's wait for them to start. CALL wait_for_some_started(1, 50, '%Scheduler%'); -- Check that the schedulers are running. If they are not, the rest of -- the test is meaningless. SELECT datname, application_name FROM tsdb_bgw; -- Kill the schedulers and check that they restart. SELECT pg_terminate_backend(pid) FROM tsdb_bgw WHERE datname = :'TEST_DBNAME' AND backend_type LIKE '%Scheduler%'; -- Wait for scheduler to exit, they should exit immediately. CALL wait_for_all_stopped(1, 50, '%Scheduler%'); -- Check that the schedulers really exited. SELECT datname, application_name FROM tsdb_bgw; -- Wait for scheduler to restart. CALL wait_for_some_started(10, 100, '%Scheduler%'); -- Make sure that the launcher and schedulers are running. Otherwise -- the test will fail. SELECT datname, application_name FROM tsdb_bgw; -- Now, we had a previous bug where killing the launcher at this point -- would leave the schedulers running (because the launcher did not -- have a handle for them) and when launcher is restarting, it would -- start more schedulers, leaving two schedulers per database. -- Get the PID of the launcher to be able to compare it after the restart SELECT pid AS orig_pid FROM tsdb_bgw WHERE backend_type LIKE '%Launcher%' \gset -- Kill the launcher. Since there are new restarted schedulers, the -- handle could not be used to terminate them, and they would be left -- running. CALL ts_terminate_launcher(); -- Launcher will restart immediately, but we wait one second to give -- it a chance to start. CALL wait_for_some_started(1, 50, '%Launcher%'); -- Check that the launcher is running and that there are exactly one -- scheduler per database. Here the old schedulers are killed, so it -- will be schedulers with a different PID than the ones before the -- launcher was killed, but we are not showing this here. SELECT (pid != :orig_pid) AS different_pid, datname, application_name FROM tsdb_bgw; ALTER SYSTEM RESET timescaledb.bgw_scheduler_restart_time; ALTER SYSTEM RESET timescaledb.debug_bgw_scheduler_exit_status; SELECT pg_reload_conf(); SELECT _timescaledb_functions.stop_background_workers(); -- We need to restart the launcher as well to read the reset -- configuration or it will affect other tests. CALL ts_terminate_launcher(); �������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_security.sql����������������������������������������������������0000664�0000000�0000000�00000002357�15100345067�0021671�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ROLE_ADMIN :TEST_DBNAME _admin \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE :ROLE_ADMIN LOGIN; GRANT :ROLE_ADMIN TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE custom_log (ts integer, msg text); GRANT ALL ON custom_log TO PUBLIC; CREATE PROCEDURE custom_job(integer, jsonb) AS $$ INSERT INTO custom_log values($1, 'custom_job'); $$ LANGUAGE SQL; SET ROLE :ROLE_ADMIN; SELECT add_job('custom_job', '1h') AS job_id \gset RESET ROLE; SELECT id, proc_name, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- We should fail to execute and delete the job since we do not own it -- or belong to the group that owns it. \set ON_ERROR_STOP 0 CALL run_job(:job_id); SELECT delete_job(:job_id); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- This should succeed since the role belongs to the job owner group. CALL run_job(:job_id); -- This should succeed since we belong to the owners role. SELECT delete_job(:job_id); \c :TEST_DBNAME :ROLE_SUPERUSER DROP ROLE :ROLE_ADMIN; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/bgw_telemetry.sql���������������������������������������������������0000664�0000000�0000000�00000002430�15100345067�0022024�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Check that we can use run_job() with the telemetry job, so first -- locate the job id for it (should be 1, but who knows, and it is not -- important for this test). SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_telemetry' \gset -- It should be possible to run it twice and running it should change -- the last_finish time. Since job_stats can be empty to start with, -- we run it once first to populate job_stats. CALL run_job(:job_id); SELECT last_finish AS last_finish FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :job_id \gset SELECT pg_sleep(1); CALL run_job(:job_id); SELECT last_finish > :'last_finish' AS job_executed, last_run_success FROM _timescaledb_internal.bgw_job_stat WHERE job_id = :job_id; -- Running it as the default user should fail since they do not own -- the job. This should be the case also for the telemetry job, which -- is a little special. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 0 CALL run_job(:job_id); \set ON_ERROR_STOP 1 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_api.sql��������������������������������������������������������0000664�0000000�0000000�00000026525�15100345067�0020720�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO CET; SET datestyle TO ISO; CREATE VIEW continuous_aggregates AS SELECT mat_hypertable_id AS materialization_id, format('%I.%I', user_view_schema, user_view_name)::regclass AS continuous_aggregate FROM _timescaledb_catalog.hypertable JOIN _timescaledb_catalog.continuous_agg ON hypertable.id = continuous_agg.mat_hypertable_id; CREATE TABLE hyper_ts (time timestamp NOT NULL, value float); CREATE TABLE hyper_tstz (time timestamptz NOT NULL, value float); CREATE TABLE hyper_multi (time timestamptz NOT NULL, device int, value float); CREATE TABLE hyper_no_cagg (time timestamptz NOT NULL, device int, value float); CREATE TABLE normal_ts(time timestamp NOT NULL, value float); SELECT * FROM create_hypertable('hyper_ts', 'time'); SELECT * FROM create_hypertable('hyper_tstz', 'time'); SELECT * FROM create_hypertable('hyper_no_cagg', 'time'); SELECT * FROM create_hypertable('hyper_multi', 'time', 'device', 4); INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-01'::timestamp, '2025-01-06', '1m') time; INSERT INTO hyper_tstz SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-01'::timestamptz, '2025-01-06', '1m') time; CREATE MATERIALIZED VIEW ts_temperature_1h WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time), avg(value) FROM hyper_ts GROUP BY 1; CREATE MATERIALIZED VIEW ts_temperature_15m WITH (timescaledb.continuous) AS SELECT time_bucket('15 minutes', time), avg(value) FROM hyper_ts GROUP BY 1; CREATE MATERIALIZED VIEW tstz_temperature_1h WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time), avg(value) FROM hyper_tstz GROUP BY 1; CREATE MATERIALIZED VIEW tstz_temperature_15m WITH (timescaledb.continuous) AS SELECT time_bucket('15 minutes', time), avg(value) FROM hyper_tstz GROUP BY 1; CREATE MATERIALIZED VIEW multi_temperature_15m WITH (timescaledb.continuous) AS SELECT time_bucket('15 minutes', time), avg(value) FROM hyper_multi GROUP BY 1; SET search_path TO _timescaledb_functions, public; -- These are not part of the API, but we test them here just to make -- sure they work as expected. SELECT table_name, get_materialization_info(table_name) FROM ( VALUES ('tstz_temperature_15m'), ('multi_temperature_15m') ) t(table_name); \set ON_ERROR_STOP 0 SELECT get_materialization_info('hyper_no_cagg'); \set ON_ERROR_STOP 1 -- This is not part of the API either, but added a test here to make -- sure that it works as expected. SELECT materialization_id, to_timestamp(lowest_modified_value), to_timestamp(greatest_modified_value) FROM get_raw_materialization_ranges('timestamptz'); -- Here are tests of the API SELECT * INTO before FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; CALL _timescaledb_functions.add_materialization_invalidations( 'tstz_temperature_15m'::regclass, '["2025-04-25 11:10:00+02","2025-04-26 11:14:00+02"]'::tstzrange ); CALL _timescaledb_functions.add_materialization_invalidations( 'ts_temperature_15m'::regclass, '["2025-04-25 11:10:00+02","2025-04-26 11:14:00+02"]'::tsrange ); -- Custom refresh function that iterate over the ranges inside the -- restriction and refresh them. This is to check that the refresh -- function does the right thing with the ranges returned by the API -- function. CREATE PROCEDURE custom_refresh(cagg REGCLASS, restriction ANYRANGE) AS $body$ DECLARE inval restriction%TYPE; BEGIN FOR inval IN SELECT UNNEST(invalidations) FROM _timescaledb_functions.get_materialization_invalidations(cagg, restriction) LOOP RAISE NOTICE 'Updating range %', inval; CALL refresh_continuous_aggregate(cagg, lower(inval), upper(inval)); COMMIT; END LOOP; END $body$ LANGUAGE plpgsql; SELECT continuous_aggregate, to_timestamp(lhs.lowest_modified_value), to_timestamp(lhs.greatest_modified_value) FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log lhs JOIN continuous_aggregates USING (materialization_id) LEFT JOIN before rhs ON row(lhs.*) = row(rhs.*) WHERE lhs.materialization_id IS NULL OR rhs.materialization_id IS NULL; SELECT materialization_id, to_timestamp(lowest_modified_value), to_timestamp(greatest_modified_value) FROM get_raw_materialization_ranges('timestamptz'); SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'ts_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tsrange ); CALL custom_refresh('ts_temperature_15m', '["2025-04-25","2025-04-26"]'::tsrange); SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'ts_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tsrange ); SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'tstz_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tstzrange ); CALL custom_refresh('tstz_temperature_15m', '["2025-04-25","2025-04-26"]'::tsrange); SELECT * FROM _timescaledb_functions.get_materialization_invalidations( 'tstz_temperature_15m'::regclass, '["2025-04-25","2025-04-26"]'::tstzrange ); -- Generate some invalidations. These new values need to be before the -- invalidation threshold, which is set to end time of the insertion -- above. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-04 10:00:00'::timestamp, '2025-01-04 11:12:00', '9 minutes') time; INSERT INTO hyper_tstz SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-04 12:00:00'::timestamptz, '2025-01-04 13:12:00', '8 minutes') time; -- Check the invalidation threshold. If that is not after the -- insertions above, nothing will show up in the invalidation log. SELECT hypertable_id, _timescaledb_functions.to_timestamp_without_timezone(watermark) AS watermark FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1; -- Check that there indeed is something in the hypertable invalidation -- log. If not, this will fail anyway. We show the "raw" timestamps, -- which is in UTC if it was originally a timestamp with timezone. -- -- We ignore duplicates since those will be merged when moving -- invalidations and hence does not affect correctness and can cause -- test flakiness otherwise. SELECT DISTINCT hypertable_id, _timescaledb_functions.to_timestamp_without_timezone(lowest_modified_value) AS start, _timescaledb_functions.to_timestamp_without_timezone(greatest_modified_value) AS finish FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log ORDER BY 1; \set VERBOSITY default -- Check that we can handle hypertables with single and multiple -- dimensions. This function is not part of the official API but we -- add tests for it here. SELECT _timescaledb_functions.get_hypertable_id('hyper_ts', 'timestamp'); SELECT _timescaledb_functions.get_hypertable_id('hyper_tstz', 'timestamptz'); SELECT _timescaledb_functions.get_hypertable_id('hyper_multi', 'timestamptz'); \set ON_ERROR_STOP 0 -- Not a hypertable SELECT _timescaledb_functions.get_hypertable_id('normal_ts', 'timestamp'); SELECT _timescaledb_functions.get_hypertable_invalidations('normal_ts', null::timestamp, array['15 minutes', '1 hour']::interval[]); -- No continuous aggregate connected SELECT _timescaledb_functions.get_hypertable_id('hyper_no_cagg', 'timestamp'); SELECT _timescaledb_functions.get_hypertable_invalidations('hyper_no_cagg', null::timestamp, array['15 minutes', '1 hour']::interval[]); -- Wrong type used SELECT _timescaledb_functions.get_hypertable_id('hyper_ts', 'timestamptz'); SELECT _timescaledb_functions.get_hypertable_invalidations('hyper_ts', null::timestamptz, array['15 minutes', '1 hour']::interval[]); \set ON_ERROR_STOP 1 SELECT * INTO saved_invalidations_1 FROM _timescaledb_functions.get_hypertable_invalidations('hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[]); SELECT bucket_width, invalidations FROM saved_invalidations_1; -- Calling it twice should return same invalidations since we haven't -- inserted anything between. SELECT * INTO saved_invalidations_2 FROM _timescaledb_functions.get_hypertable_invalidations('hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[]); SELECT * FROM saved_invalidations_2 s1 FULL JOIN saved_invalidations_2 s2 ON row(s1.*) = row(s2.*) WHERE s1.token IS NULL OR s2.token IS NULL; SELECT token FROM saved_invalidations_1 LIMIT 1 \gset -- Test some error cases \set ON_ERROR_STOP 0 CALL _timescaledb_functions.accept_hypertable_invalidations('normal_ts', :'token'); CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_no_cagg', :'token'); CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_ts', 'garbage'); \set ON_ERROR_STOP 1 -- Accept the invalidations as processed by passing in the token. CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_ts', :'token'); -- This should now show no validations. SELECT bucket_width, invalidations FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ); -- Check that the invalidations associated with the token are removed -- when there are inserts in between. -- First insert some rows. All invalidations were removed above, so we -- should only see these. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-03 10:00:00'::timestamp, '2025-01-03 11:12:00', '10 minutes') time; -- Get invalidations from the hypertable, with a token. SELECT * INTO saved_3 FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ); SELECT token FROM saved_3 LIMIT 1 \gset -- Insert some more rows into the hypertable that are disjoint with -- the invalidations associated with the token above. These should be -- fully removed. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-02 10:00:00'::timestamp, '2025-01-02 11:12:00', '10 minutes') time; -- Insert some more rows into the hypertable that are inside the range -- associated with the token above. These should remain after -- accepting the token. INSERT INTO hyper_ts SELECT time, ceil(random() * 100)::int FROM generate_series('2025-01-03 10:30:00'::timestamp, '2025-01-03 10:50:00', '5 minutes') time; -- Check that we have them in the invalidation log SELECT bucket_width, unnest(invalidations) AS inval FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ) ORDER BY 1, 2; -- Accept the original invalidations CALL _timescaledb_functions.accept_hypertable_invalidations('hyper_ts', :'token'); -- Check that we only removed the ones associated with the token. SELECT bucket_width, unnest(invalidations) AS inval FROM _timescaledb_functions.get_hypertable_invalidations( 'hyper_ts', null::timestamp, array['15 minutes', '1 hour']::interval[] ) ORDER BY 1, 2; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_bgw.sql.in�����������������������������������������������������0000664�0000000�0000000�00000034642�15100345067�0021332�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_wait_for_scheduler_finish() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; --test that this all works under the community license ALTER DATABASE :TEST_DBNAME SET timescaledb.license_key='Community'; --create a function with no permissions to execute CREATE FUNCTION get_constant_no_perms() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant_no_perms() FROM PUBLIC; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 CREATE OR REPLACE FUNCTION ts_bgw_params_mock_wait_returns_immediately(new_val INTEGER) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); SELECT * FROM _timescaledb_config.bgw_job; SELECT * FROM timescaledb_information.job_stats; SELECT * FROM _timescaledb_catalog.continuous_agg; -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test_continuous_agg_table(time int, data int); SELECT create_hypertable('test_continuous_agg_table', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_test() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table $$; SELECT set_integer_now_func('test_continuous_agg_table', 'integer_now_test'); CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', NULL, 4::integer, '12 h'::interval); SELECT id as raw_table_id FROM _timescaledb_catalog.hypertable WHERE table_name='test_continuous_agg_table' \gset -- min distance from end should be 1 SELECT mat_hypertable_id, user_view_schema, user_view_name FROM _timescaledb_catalog.continuous_agg; SELECT mat_hypertable_id, bucket_width FROM _timescaledb_catalog.continuous_aggs_bucket_function; SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id \gset -- job was created SELECT * FROM _timescaledb_config.bgw_job where hypertable_id=:mat_hypertable_id; -- create 10 time buckets INSERT INTO test_continuous_agg_table SELECT i, i FROM (SELECT generate_series(0, 10) as i) AS j; -- no stats SELECT job_id, next_start, last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat ORDER BY job_id; -- no data in view SELECT * FROM test_continuous_agg_view ORDER BY 1; -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT * FROM _timescaledb_config.bgw_job where id=:job_id; -- job ran once, successfully SELECT job_id, next_start-last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; --clear log for next run of scheduler. TRUNCATE public.bgw_log; CREATE FUNCTION wait_for_timer_to_run(started_at INTEGER, spins INTEGER=:TEST_SPINWAIT_ITERS) RETURNS BOOLEAN LANGUAGE PLPGSQL AS $BODY$ DECLARE num_runs INTEGER; message TEXT; BEGIN select format('[TESTING] Wait until %%, started at %s', started_at) into message; FOR i in 1..spins LOOP SELECT COUNT(*) from bgw_log where msg LIKE message INTO num_runs; if (num_runs > 0) THEN RETURN true; ELSE PERFORM pg_sleep(0.1); END IF; END LOOP; RETURN false; END $BODY$; --make sure there is 1 job to start with SELECT test.wait_for_job_to_run(:job_id, 1); SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_FOR_OTHER_TO_ADVANCE); --start the scheduler on 0 time SELECT ts_bgw_params_reset_time(0, true); SELECT ts_bgw_db_scheduler_test_run(extract(epoch from interval '24 hour')::int * 1000, 0); SELECT wait_for_timer_to_run(0); --advance to 12:00 so that it runs one more time; now we know the --scheduler has loaded up the job with the old schedule_interval SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); SELECT test.wait_for_job_to_run(:job_id, 2); --advance clock 1us to make the scheduler realize the job is done SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+1, true); --alter the refresh interval and check if next_start is altered SELECT alter_job(:job_id, schedule_interval => '1m', retry_period => '1m'); SELECT job_id, next_start - last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id;; --advance to 12:02, job should have run at 12:01 SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute')::bigint * 1000000), true); SELECT test.wait_for_job_to_run(:job_id, 3); --next run in 1 minute SELECT job_id, next_start-last_finish as until_next, total_runs FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id; --change next run to be after 30s instead SELECT (next_start - '30s'::interval) AS "NEW_NEXT_START" FROM _timescaledb_internal.bgw_job_stat WHERE job_id=:job_id \gset SELECT alter_job(:job_id, next_start => :'NEW_NEXT_START'); SELECT ts_bgw_params_reset_time((extract(epoch from interval '12 hour')::bigint * 1000000)+(extract(epoch from interval '2 minute 30 seconds')::bigint * 1000000), true); SELECT test.wait_for_job_to_run(:job_id, 4); --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); TRUNCATE public.bgw_log; -- data before 8 SELECT * FROM test_continuous_agg_view ORDER BY 1; -- invalidations test by running job multiple times SELECT ts_bgw_params_reset_time(); DROP MATERIALIZED VIEW test_continuous_agg_view; CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg \gset SELECT id AS job_id FROM _timescaledb_config.bgw_job WHERE hypertable_id=:mat_hypertable_id \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- job ran once, successfully SELECT job_id, last_finish - next_start as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; -- should have refreshed everything we have so far SELECT * FROM test_continuous_agg_view ORDER BY 1; -- invalidate some data UPDATE test_continuous_agg_table SET data = 11 WHERE time = 6; --advance time by 12h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); SELECT * FROM sorted_bgw_log; SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; -- should have updated data for time=6 SELECT * FROM test_continuous_agg_view ORDER BY 1; \x on --check the information views -- select view_name, view_owner, materialization_hypertable_schema, materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like '%test_continuous_agg_view'; select job_status, last_run_duration from timescaledb_information.job_stats ps, timescaledb_information.continuous_aggregates cagg where cagg.view_name::text like '%test_continuous_agg_view' and cagg.materialization_hypertable_name = ps.hypertable_name; \x off -- test merged refresh (change data in two chunks) UPDATE test_continuous_agg_table SET data = 11; --advance time by 1day so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1day')::bigint * 1000000, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(50, 50); SELECT * FROM sorted_bgw_log; DROP MATERIALIZED VIEW test_continuous_agg_view; --create a view with a function that it has no permission to execute CREATE MATERIALIZED VIEW test_continuous_agg_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value, get_constant_no_perms() FROM test_continuous_agg_table GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view', 100::integer, -2::integer, '12 h'::interval); SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); -- job fails SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; DROP MATERIALIZED VIEW test_continuous_agg_view; --advance clock to quit scheduler SELECT ts_bgw_params_reset_time(extract(epoch from interval '25 hour')::bigint * 1000000, true); select ts_bgw_db_scheduler_test_wait_for_scheduler_finish(); SELECT ts_bgw_params_mock_wait_returns_immediately(:WAIT_ON_JOB); --clear log for next run of the scheduler TRUNCATE public.bgw_log; SELECT ts_bgw_params_reset_time(); -- -- Test creating continuous aggregate with a user that is the non-owner of the raw table -- CREATE TABLE test_continuous_agg_table_w_grant(time int, data int); SELECT create_hypertable('test_continuous_agg_table_w_grant', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM test_continuous_agg_table_w_grant $$; SELECT set_integer_now_func('test_continuous_agg_table_w_grant', 'integer_now_test1'); GRANT SELECT, TRIGGER ON test_continuous_agg_table_w_grant TO public; INSERT INTO test_continuous_agg_table_w_grant SELECT 1 , 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- make sure view can be created CREATE MATERIALIZED VIEW test_continuous_agg_view_user_2 WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM test_continuous_agg_table_w_grant GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test_continuous_agg_view_user_2', NULL, -2::integer, '12 h'::interval); SELECT id AS job_id FROM _timescaledb_config.bgw_job ORDER BY id desc limit 1 \gset SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT id, owner FROM _timescaledb_config.bgw_job WHERE id = :job_id ; SELECT job_id, next_start - last_finish as until_next, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; --view is populated SELECT * FROM test_continuous_agg_view_user_2 ORDER BY 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke permissions from the continuous agg view owner to select from raw table --no further updates to cont agg should happen REVOKE SELECT ON test_continuous_agg_table_w_grant FROM public; --add new data to table INSERT INTO test_continuous_agg_table_w_grant VALUES(5,1); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --advance time by 12h so that job tries to run one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '12 hour')::bigint * 1000000, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25, 25); --should show a failing execution because no longer has permissions (due to lack of permission on partial view owner's part) SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:job_id; --view was NOT updated; but the old stuff is still there SELECT * FROM test_continuous_agg_view_user_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * from sorted_bgw_log; -- Count the number of continuous aggregate policies SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_refresh_continuous_aggregate'; ����������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_bgw_drop_chunks.sql��������������������������������������������0000664�0000000�0000000�00000006662�15100345067�0023325�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup for testing bgw jobs --- -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT * FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ----------------------------------- -- test drop chunks policy runs for materialized hypertables created for -- cont. aggregates ----------------------------------- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE drop_chunks_table(time BIGINT, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 1) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT 40::bigint $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); CREATE MATERIALIZED VIEW drop_chunks_view1 WITH (timescaledb.continuous) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; --raw hypertable will have 40 chunks and the mat. hypertable will have 2 and 4 -- chunks respectively SELECT set_chunk_time_interval('_timescaledb_internal._materialized_hypertable_2', 10); \set ON_ERROR_STOP 0 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(1, 39) AS i; \set ON_ERROR_STOP 1 CALL refresh_continuous_aggregate('drop_chunks_view1', NULL, NULL); --TEST1 specify drop chunks policy on mat. hypertable by -- directly does not work \set ON_ERROR_STOP 0 SELECT add_retention_policy( '_timescaledb_internal._materialized_hypertable_2', drop_after => -50) as drop_chunks_job_id1 \gset \set ON_ERROR_STOP 1 --TEST2 specify drop chunks policy on cont. aggregate -- integer_now func on raw hypertable is used by the drop -- chunks policy SELECT hypertable_id, table_name, integer_now_func FROM _timescaledb_catalog.dimension d, _timescaledb_catalog.hypertable ht WHERE ht.id = d.hypertable_id; SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = '_materialized_hypertable_2' ORDER BY range_start_integer; SELECT add_retention_policy( 'drop_chunks_view1', drop_after => 10) as drop_chunks_job_id1 \gset SELECT alter_job(:drop_chunks_job_id1, schedule_interval => INTERVAL '1 second'); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(2000000); SELECT count(c) from show_chunks('drop_chunks_view1') as c ; SELECT remove_retention_policy('drop_chunks_view1'); \set ON_ERROR_STOP 0 SELECT remove_retention_policy('unknown'); SELECT remove_retention_policy('1'); \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_config.sql�����������������������������������������������������0000664�0000000�0000000�00000001202�15100345067�0021375�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Show the defaults SHOW timescaledb.cagg_processing_wal_batch_size; SHOW timescaledb.cagg_processing_low_work_mem; SHOW timescaledb.cagg_processing_high_work_mem; \set VERBOSITY default \set ON_ERROR_STOP 0 SET timescaledb.cagg_processing_wal_batch_size TO 100; SET timescaledb.cagg_processing_wal_batch_size TO 10000001; SET timescaledb.cagg_processing_low_work_mem TO 52428; SET timescaledb.cagg_processing_high_work_mem TO 39321; \set ON_ERROR_STOP 1 ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_ddl.sql.in�����������������������������������������������������0000664�0000000�0000000�00000156646�15100345067�0021327�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Set this variable to avoid using a hard-coded path each time query -- results are compared \set QUERY_RESULT_TEST_EQUAL_RELPATH '../../../../test/sql/include/query_result_test_equal.sql' SET ROLE :ROLE_DEFAULT_PERM_USER; --DDL commands on continuous aggregates CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); -- schema tests \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO 'UTC+8'; -- drop if the tablespace1 and/or tablespace2 exists SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; CREATE SCHEMA rename_schema; GRANT ALL ON SCHEMA rename_schema TO :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA test_schema AUTHORIZATION :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE foo(time TIMESTAMPTZ NOT NULL, data INTEGER); SELECT create_hypertable('foo', 'time'); CREATE MATERIALIZED VIEW rename_test_old WITH ( timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1week', time), COUNT(data) FROM foo GROUP BY 1 WITH NO DATA; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; ALTER TABLE rename_test_old RENAME TO rename_test; ALTER TABLE rename_test SET SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; ALTER MATERIALIZED VIEW test_schema.rename_test SET SCHEMA rename_schema; DROP SCHEMA test_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'rename_test' \gset RESET ROLE; SELECT current_user; ALTER VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; --alter direct view schema SELECT user_view_schema, user_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; RESET ROLE; SELECT current_user; ALTER VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME" SET SCHEMA public; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; RESET ROLE; SELECT current_user; ALTER SCHEMA rename_schema RENAME TO new_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; ALTER VIEW :"PART_VIEW_NAME" SET SCHEMA new_name_schema; ALTER VIEW :"DIR_VIEW_NAME" SET SCHEMA new_name_schema; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; RESET ROLE; SELECT current_user; ALTER SCHEMA new_name_schema RENAME TO foo_name_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; ALTER MATERIALIZED VIEW foo_name_schema.rename_test SET SCHEMA public; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; RESET ROLE; SELECT current_user; ALTER SCHEMA foo_name_schema RENAME TO rename_schema; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; ALTER MATERIALIZED VIEW rename_test RENAME TO rename_c_aggregate; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name FROM _timescaledb_catalog.continuous_agg; SELECT * FROM rename_c_aggregate; ALTER VIEW rename_schema.:"PART_VIEW_NAME" RENAME TO partial_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; --rename direct view ALTER VIEW rename_schema.:"DIR_VIEW_NAME" RENAME TO direct_view; SELECT user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg; -- drop_chunks tests DROP TABLE conditions CASCADE; DROP TABLE foo CASCADE; CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_id FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test'); CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), COUNT(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 29) AS i; -- Only refresh up to bucket 15 initially. Matches the old refresh -- behavior that didn't materialize everything CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; SELECT * FROM drop_chunks_view ORDER BY 1; -- cannot drop directly from the materialization table without specifying -- cont. aggregate view name explicitly \set ON_ERROR_STOP 0 SELECT drop_chunks(:'drop_chunks_mat_table', newer_than => -20, verbose => true); \set ON_ERROR_STOP 1 SELECT count(c) FROM show_chunks('drop_chunks_table') AS c; SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; SELECT * FROM drop_chunks_view ORDER BY 1; -- drop chunks when the chunksize and time_bucket aren't aligned DROP TABLE drop_chunks_table CASCADE; CREATE TABLE drop_chunks_table_u(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_u_id FROM create_hypertable('drop_chunks_table_u', 'time', chunk_time_interval => 7) \gset CREATE OR REPLACE FUNCTION integer_now_test1() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table_u $$; SELECT set_integer_now_func('drop_chunks_table_u', 'integer_now_test1'); CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('3', time), COUNT(data) FROM drop_chunks_table_u GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_table_u, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_u_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_u_id AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- create 3 chunks, with 3 time bucket INSERT INTO drop_chunks_table_u SELECT i, i FROM generate_series(0, 21) AS i; -- Refresh up to bucket 15 to match old materializer behavior CALL refresh_continuous_aggregate('drop_chunks_view', 0, 15); SELECT count(c) FROM show_chunks('drop_chunks_table_u') AS c; SELECT count(c) FROM show_chunks('drop_chunks_view') AS c; SELECT * FROM drop_chunks_view ORDER BY 1; -- TRUNCATE test -- Can truncate regular hypertables that have caggs TRUNCATE drop_chunks_table_u; \set ON_ERROR_STOP 0 -- Can't truncate materialized hypertables directly TRUNCATE :drop_chunks_mat_table_u; \set ON_ERROR_STOP 1 -- Check that we don't interfere with TRUNCATE of normal table and -- partitioned table CREATE TABLE truncate (value int); INSERT INTO truncate VALUES (1), (2); TRUNCATE truncate; SELECT * FROM truncate; CREATE TABLE truncate_partitioned (value int) PARTITION BY RANGE(value); CREATE TABLE truncate_p1 PARTITION OF truncate_partitioned FOR VALUES FROM (1) TO (3); INSERT INTO truncate_partitioned VALUES (1), (2); TRUNCATE truncate_partitioned; SELECT * FROM truncate_partitioned; -- ALTER TABLE tests \set ON_ERROR_STOP 0 -- test a variety of ALTER TABLE statements ALTER TABLE :drop_chunks_mat_table_u RENAME time_bucket TO bad_name; ALTER TABLE :drop_chunks_mat_table_u ADD UNIQUE(time_bucket); ALTER TABLE :drop_chunks_mat_table_u SET UNLOGGED; ALTER TABLE :drop_chunks_mat_table_u ENABLE ROW LEVEL SECURITY; ALTER TABLE :drop_chunks_mat_table_u ADD COLUMN fizzle INTEGER; ALTER TABLE :drop_chunks_mat_table_u DROP COLUMN time_bucket; ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket DROP NOT NULL; ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET DEFAULT 1; ALTER TABLE :drop_chunks_mat_table_u ALTER COLUMN time_bucket SET STORAGE EXTERNAL; ALTER TABLE :drop_chunks_mat_table_u DISABLE TRIGGER ALL; ALTER TABLE :drop_chunks_mat_table_u SET TABLESPACE foo; ALTER TABLE :drop_chunks_mat_table_u NOT OF; ALTER TABLE :drop_chunks_mat_table_u OWNER TO CURRENT_USER; \set ON_ERROR_STOP 1 ALTER TABLE :drop_chunks_mat_table_u SET SCHEMA public; ALTER TABLE :drop_chunks_mat_table_u_name RENAME TO new_name; SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; SELECT * FROM new_name ORDER BY 1; SELECT * FROM drop_chunks_view ORDER BY 1; \set ON_ERROR_STOP 0 -- no continuous aggregates on a continuous aggregate materialization table CREATE MATERIALIZED VIEW new_name_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('6', time_bucket), COUNT("count") FROM new_name GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 1 CREATE TABLE metrics(time timestamptz NOT NULL, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2 FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; --test materialization of invalidation before drop DROP TABLE IF EXISTS drop_chunks_table CASCADE; DROP TABLE IF EXISTS drop_chunks_table_u CASCADE; CREATE TABLE drop_chunks_table(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS drop_chunks_table_nid FROM create_hypertable('drop_chunks_table', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test2() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), bigint '0') FROM drop_chunks_table $$; SELECT set_integer_now_func('drop_chunks_table', 'integer_now_test2'); CREATE MATERIALIZED VIEW drop_chunks_view WITH ( timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('5', time), max(data) FROM drop_chunks_table GROUP BY 1 WITH NO DATA; INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --dropping chunks will process the invalidations SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(20, 35) AS i; CALL refresh_continuous_aggregate('drop_chunks_view', 10, 40); --this will be seen after the drop its within the invalidation window and will be dropped INSERT INTO drop_chunks_table VALUES (26, 100); --this will not be processed by the drop since chunk 30-39 is not dropped but will be seen after refresh --shows that the drop doesn't do more work than necessary INSERT INTO drop_chunks_table VALUES (31, 200); --move the time up to 39 INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(35, 39) AS i; --the chunks and ranges we have thus far SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table'; --the invalidation on 25 not yet seen SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; --refresh to process the invalidations and then drop CALL refresh_continuous_aggregate('drop_chunks_view', NULL, (integer_now_test2()-9)); SELECT drop_chunks('drop_chunks_table', older_than => (integer_now_test2()-9)); --new values on 25 now seen in view SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; --earliest datapoint now in table SELECT * FROM drop_chunks_table ORDER BY time ASC limit 1; --chunks are removed SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE dropped; --still see data in the view SELECT * FROM drop_chunks_view WHERE time_bucket < (integer_now_test2()-9) ORDER BY time_bucket DESC; --no data but covers dropped chunks SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; --recreate the dropped chunk INSERT INTO drop_chunks_table SELECT i, i FROM generate_series(0, 20) AS i; --see data from recreated region SELECT * FROM drop_chunks_table WHERE time < (integer_now_test2()-9) ORDER BY time DESC; --should show chunk with old name and old ranges SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY range_start_integer; --We dropped everything up to the bucket starting at 30 and then --inserted new data up to and including time 20. Therefore, the --dropped data should stay the same as long as we only refresh --buckets that have non-dropped data. CALL refresh_continuous_aggregate('drop_chunks_view', 30, 40); SELECT * FROM drop_chunks_view ORDER BY time_bucket DESC; SELECT format('%I.%I', schema_name, table_name) AS drop_chunks_mat_tablen, schema_name AS drop_chunks_mat_schema, table_name AS drop_chunks_mat_table_name FROM _timescaledb_catalog.hypertable, _timescaledb_catalog.continuous_agg WHERE _timescaledb_catalog.continuous_agg.raw_hypertable_id = :drop_chunks_table_nid AND _timescaledb_catalog.hypertable.id = _timescaledb_catalog.continuous_agg.mat_hypertable_id \gset -- TEST drop chunks from continuous aggregates by specifying view name SELECT drop_chunks('drop_chunks_view', newer_than => -20, verbose => true); -- Test that we cannot drop chunks when specifying materialized -- hypertable INSERT INTO drop_chunks_table SELECT generate_series(45, 55), 500; CALL refresh_continuous_aggregate('drop_chunks_view', 45, 55); SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = :'drop_chunks_mat_table_name' ORDER BY range_start_integer; \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT drop_chunks(:'drop_chunks_mat_tablen', older_than => 60); \set VERBOSITY terse \set ON_ERROR_STOP 1 ----------------------------------------------------------------- -- Test that refresh_continuous_aggregate on chunk will refresh, -- but only in the regions covered by the show chunks. ----------------------------------------------------------------- SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; -- Pick the second chunk as the one to drop WITH numbered_chunks AS ( SELECT row_number() OVER (ORDER BY range_start_integer), chunk_schema, chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 1 ) SELECT format('%I.%I', chunk_schema, chunk_name) AS chunk_to_drop, range_start_integer, range_end_integer FROM numbered_chunks WHERE row_number = 2 \gset -- There's data in the table for the chunk/range we will drop SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; -- Make sure there is also data in the continuous aggregate -- CARE: -- Note that this behaviour of dropping the materialization table chunks and expecting a refresh -- that overlaps that time range to NOT update those chunks is undefined. CALL refresh_continuous_aggregate('drop_chunks_view', 0, 50); SELECT * FROM drop_chunks_view ORDER BY 1; -- Drop the second chunk, to leave a gap in the data DROP TABLE :chunk_to_drop; -- Verify that the second chunk is dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; -- Data is no longer in the table but still in the view SELECT * FROM drop_chunks_table WHERE time >= :range_start_integer AND time < :range_end_integer ORDER BY 1; SELECT * FROM drop_chunks_view WHERE time_bucket >= :range_start_integer AND time_bucket < :range_end_integer ORDER BY 1; -- Insert a large value in one of the chunks that will be dropped INSERT INTO drop_chunks_table VALUES (:range_start_integer-1, 100); -- Now refresh and drop the two adjecent chunks CALL refresh_continuous_aggregate('drop_chunks_view', NULL, 30); SELECT drop_chunks('drop_chunks_table', older_than=>30); -- Verify that the chunks are dropped SELECT chunk_name, range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'drop_chunks_table' ORDER BY 2,3; -- The continuous aggregate should be refreshed in the regions covered -- by the dropped chunks, but not in the "gap" region, i.e., the -- region of the chunk that was dropped via DROP TABLE. SELECT * FROM drop_chunks_view ORDER BY 1; -- Now refresh in the region of the first two dropped chunks CALL refresh_continuous_aggregate('drop_chunks_view', 0, :range_end_integer); -- Aggregate data in the refreshed range should no longer exist since -- the underlying data was dropped. SELECT * FROM drop_chunks_view ORDER BY 1; -------------------------------------------------------------------- -- Check that we can create a materialized table in a tablespace. We -- create one with tablespace and one without and compare them. CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, pg_get_userbyid(relowner) AS user_view_owner, relname AS mat_table, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = mat_relid) AS mat_table_owner, direct_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = direct_view) AS direct_view_owner, partial_view, (SELECT pg_get_userbyid(relowner) FROM pg_class WHERE oid = partial_view) AS partial_view_owner, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; CREATE VIEW chunk_info AS SELECT ht.schema_name, ht.table_name, relname AS chunk_name, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class c, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch WHERE ch.table_name = c.relname AND ht.id = ch.hypertable_id; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset SELECT set_integer_now_func('whatever', 'integer_now_test'); CREATE MATERIALIZED VIEW whatever_view_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW whatever_view_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) TABLESPACE tablespace1 AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; CALL refresh_continuous_aggregate('whatever_view_1', NULL, NULL); CALL refresh_continuous_aggregate('whatever_view_2', NULL, NULL); SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; ALTER MATERIALIZED VIEW whatever_view_1 SET TABLESPACE tablespace2; SELECT user_view, mat_table, cagg_info.tablespace AS mat_tablespace, chunk_name, chunk_info.tablespace AS chunk_tablespace FROM cagg_info, chunk_info WHERE mat_table::text = table_name AND user_view::text LIKE 'whatever_view%'; DROP MATERIALIZED VIEW whatever_view_1; DROP MATERIALIZED VIEW whatever_view_2; -- test bucket width expressions on integer hypertables CREATE TABLE metrics_int2 ( time int2 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int4 ( time int4 NOT NULL, device_id int, v1 float, v2 float ); CREATE TABLE metrics_int8 ( time int8 NOT NULL, device_id int, v1 float, v2 float ); SELECT create_hypertable (('metrics_' || dt)::regclass, 'time', chunk_time_interval => 10) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); CREATE OR REPLACE FUNCTION int2_now () RETURNS int2 LANGUAGE SQL STABLE AS $$ SELECT 10::int2 $$; CREATE OR REPLACE FUNCTION int4_now () RETURNS int4 LANGUAGE SQL STABLE AS $$ SELECT 10::int4 $$; CREATE OR REPLACE FUNCTION int8_now () RETURNS int8 LANGUAGE SQL STABLE AS $$ SELECT 10::int8 $$; SELECT set_integer_now_func (('metrics_' || dt)::regclass, (dt || '_now')::regproc) FROM ( VALUES ('int2'), ('int4'), ('int8')) v (dt); -- width expression for int2 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint, time) FROM metrics_int2 GROUP BY 1; DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1::smallint + 2::smallint, time) FROM metrics_int2 GROUP BY 1; DROP MATERIALIZED VIEW width_expr; -- width expression for int4 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int4 GROUP BY 1; DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int4 GROUP BY 1; DROP MATERIALIZED VIEW width_expr; -- width expression for int8 hypertables CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, time) FROM metrics_int8 GROUP BY 1; DROP MATERIALIZED VIEW width_expr; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1; DROP MATERIALIZED VIEW width_expr; \set ON_ERROR_STOP 0 -- non-immutable expresions should be rejected CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::smallint, time) FROM metrics_int2 GROUP BY 1; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int4 GROUP BY 1; CREATE MATERIALIZED VIEW width_expr WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(extract(year FROM now())::int, time) FROM metrics_int8 GROUP BY 1; \set ON_ERROR_STOP 1 -- Test various ALTER MATERIALIZED VIEW statements. SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE MATERIALIZED VIEW owner_check WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1 + 2, time) FROM metrics_int8 GROUP BY 1 WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; \x off -- This should not work since the target user has the wrong role, but -- we test that the normal checks are done when changing the owner. \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; \set ON_ERROR_STOP 1 -- Superuser can always change owner SET ROLE :ROLE_CLUSTER_SUPERUSER; ALTER MATERIALIZED VIEW owner_check OWNER TO :ROLE_1; \x on SELECT * FROM cagg_info WHERE user_view::text = 'owner_check'; \x off -- -- Test drop continuous aggregate cases -- -- Issue: #2608 -- CREATE OR REPLACE FUNCTION test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE conditionsnm(time_int INT NOT NULL, device INT, value FLOAT); SELECT create_hypertable('conditionsnm', 'time_int', chunk_time_interval => 10); SELECT set_integer_now_func('conditionsnm', 'test_int_now'); INSERT INTO conditionsnm SELECT time_val, time_val % 4, 3.14 FROM generate_series(0,100,1) AS time_val; -- Case 1: DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; DROP materialized view conditionsnm_4; -- Case 2: DROP CASCADE should have similar behaviour as DROP CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; DROP materialized view conditionsnm_4 CASCADE; -- Case 3: require CASCADE in case of dependent object CREATE MATERIALIZED VIEW conditionsnm_4 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(7, time_int) as bucket, SUM(value), COUNT(value) FROM conditionsnm GROUP BY bucket WITH DATA; CREATE VIEW see_cagg as select * from conditionsnm_4; \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW conditionsnm_4; \set ON_ERROR_STOP 1 -- Case 4: DROP CASCADE with dependency DROP MATERIALIZED VIEW conditionsnm_4 CASCADE; -- Test DROP SCHEMA CASCADE with continuous aggregates -- -- Issue: #2350 -- -- Case 1: DROP SCHEMA CASCADE CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); CREATE MATERIALIZED VIEW test_schema.telemetry_1s WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'telemetry_1s'; \gset DROP SCHEMA test_schema CASCADE; SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME'; SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME'; SELECT count(*) FROM pg_class WHERE relname = 'telemetry_1s'; SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; -- Case 2: DROP SCHEMA CASCADE with multiple caggs CREATE SCHEMA test_schema; CREATE TABLE test_schema.telemetry_raw ( ts TIMESTAMP WITH TIME ZONE NOT NULL, value DOUBLE PRECISION ); SELECT create_hypertable('test_schema.telemetry_raw', 'ts'); CREATE MATERIALIZED VIEW test_schema.cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; CREATE MATERIALIZED VIEW test_schema.cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1s', ts) AS ts_1s, avg(value) FROM test_schema.telemetry_raw GROUP BY ts_1s WITH NO DATA; SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME1", partial_view_name as "PART_VIEW_NAME1", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg1'; \gset SELECT ca.raw_hypertable_id, h.schema_name, h.table_name AS "MAT_TABLE_NAME2", partial_view_name as "PART_VIEW_NAME2", partial_view_schema FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cagg2'; \gset DROP SCHEMA test_schema CASCADE; SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME1'; SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME1'; SELECT count(*) FROM pg_class WHERE relname = 'cagg1'; SELECT count(*) FROM pg_class WHERE relname = :'MAT_TABLE_NAME2'; SELECT count(*) FROM pg_class WHERE relname = :'PART_VIEW_NAME2'; SELECT count(*) FROM pg_class WHERE relname = 'cagg2'; SELECT count(*) FROM pg_namespace WHERE nspname = 'test_schema'; DROP TABLESPACE tablespace1; DROP TABLESPACE tablespace2; -- Check that we can rename a column of a materialized view and still -- rebuild it after (#3051, #3405) CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'por', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT format('%I.%I', '_timescaledb_internal', h.table_name) AS "MAT_TABLE_NAME", format('%I.%I', '_timescaledb_internal', partial_view_name) AS "PART_VIEW_NAME", format('%I.%I', '_timescaledb_internal', direct_view_name) AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_daily' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns('conditions_daily'); SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); ALTER MATERIALIZED VIEW conditions_daily RENAME COLUMN bucket to "time"; -- Show both the columns and the view definitions to see that -- references are correct in the view as well. SELECT * FROM test.show_columns(' conditions_daily'); SELECT * FROM test.show_columns(:'DIRECT_VIEW_NAME'); SELECT * FROM test.show_columns(:'PART_VIEW_NAME'); SELECT * FROM test.show_columns(:'MAT_TABLE_NAME'); -- This will rebuild the materialized view and should succeed. ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only = false); -- Refresh the continuous aggregate to check that it works after the -- rename. \set VERBOSITY verbose CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); \set VERBOSITY terse -- -- Indexes on continuous aggregate -- \set ON_ERROR_STOP 0 -- unique indexes are not supported CREATE UNIQUE INDEX index_unique_error ON conditions_daily ("time", location); -- concurrently index creation not supported CREATE INDEX CONCURRENTLY index_concurrently_avg ON conditions_daily (avg); \set ON_ERROR_STOP 1 CREATE INDEX index_avg ON conditions_daily (avg); CREATE INDEX index_avg_only ON ONLY conditions_daily (avg); CREATE INDEX index_avg_include ON conditions_daily (avg) INCLUDE (location); CREATE INDEX index_avg_expr ON conditions_daily ((avg + 1)); CREATE INDEX index_avg_location_sfo ON conditions_daily (avg) WHERE location = 'SFO'; CREATE INDEX index_avg_expr_location_sfo ON conditions_daily ((avg + 2)) WHERE location = 'SFO'; SELECT * FROM test.show_indexespred(:'MAT_TABLE_NAME'); -- #3696 assertion failure when referencing columns not present in result CREATE TABLE i3696(time timestamptz NOT NULL, search_query text, cnt integer, cnt2 integer); SELECT table_name FROM create_hypertable('i3696','time'); CREATE MATERIALIZED VIEW i3696_cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt +cnt2 , bucket, search_query; ALTER MATERIALIZED VIEW i3696_cagg1 SET (timescaledb.materialized_only = 'true'); CREATE MATERIALIZED VIEW i3696_cagg2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM i3696 GROUP BY cnt + cnt2, bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; ALTER MATERIALIZED VIEW i3696_cagg2 SET (timescaledb.materialized_only = 'true'); --TEST test with multiple settings on continuous aggregates -- -- test for materialized_only + compress combinations (real time aggs enabled initially) CREATE TABLE test_setting(time timestamptz not null, val numeric); SELECT create_hypertable('test_setting', 'time'); CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; INSERT INTO test_setting SELECT generate_series( '2020-01-10 8:00'::timestamp, '2020-01-30 10:00+00'::timestamptz, '1 day'::interval), 10.0; CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; DELETE FROM test_setting WHERE val = 20; --TEST test with multiple settings on continuous aggregates with real time aggregates turned off initially -- -- test for materialized_only + compress combinations (real time aggs enabled initially) DROP MATERIALIZED VIEW test_setting_cagg; CREATE MATERIALIZED VIEW test_setting_cagg with (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1h',time), avg(val), count(*) FROM test_setting GROUP BY 1; CALL refresh_continuous_aggregate('test_setting_cagg', NULL, '2020-05-30 10:00+00'::timestamptz); SELECT count(*) from test_setting_cagg ORDER BY 1; --this row is not in the materialized result --- INSERT INTO test_setting VALUES( '2020-11-01', 20); --try out 2 settings here -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='true'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; --now set it back to false -- ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='true'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'false', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --count should return additional data since we have real time aggs on SELECT count(*) from test_setting_cagg ORDER BY 1; ALTER MATERIALIZED VIEW test_setting_cagg SET (timescaledb.materialized_only = 'true', timescaledb.compress='false'); SELECT view_name, compression_enabled, materialized_only FROM timescaledb_information.continuous_aggregates where view_name = 'test_setting_cagg'; --real time aggs is off now , should return 20 -- SELECT count(*) from test_setting_cagg ORDER BY 1; -- END TEST with multiple settings -- Test View Target Entries that contain both aggrefs and Vars in the same expression CREATE TABLE transactions ( "time" timestamp with time zone NOT NULL, dummy1 integer, dummy2 integer, dummy3 integer, dummy4 integer, dummy5 integer, amount integer, fiat_value integer ); SELECT create_hypertable('transactions', 'time'); INSERT INTO transactions VALUES ( '2018-01-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:30:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:20:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-01-02 09:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 10:40:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 11:50:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-01 12:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-01 13:10:00-08', 0, 0, 0, 0, 0, -1, 10); INSERT INTO transactions VALUES ( '2018-11-02 09:20:00-08', 0, 0, 0, 0, 0, 1, 10); INSERT INTO transactions VALUES ( '2018-11-02 10:30:00-08', 0, 0, 0, 0, 0, -1, 10); CREATE materialized view cashflows( bucket, amount, cashflow, cashflow2 ) WITH ( timescaledb.continuous, timescaledb.materialized_only = true ) AS SELECT time_bucket ('1 day', time) AS bucket, amount, CASE WHEN amount < 0 THEN (0 - sum(fiat_value)) ELSE sum(fiat_value) END AS cashflow, amount + sum(fiat_value) FROM transactions GROUP BY bucket, amount; SELECT h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", direct_view_name AS "DIRECT_VIEW_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'cashflows' \gset -- Show both the columns and the view definitions to see that -- references are correct in the view as well. \d+ "_timescaledb_internal".:"DIRECT_VIEW_NAME" \d+ "_timescaledb_internal".:"PART_VIEW_NAME" \d+ "_timescaledb_internal".:"MAT_TABLE_NAME" \d+ 'cashflows' SELECT * FROM cashflows ORDER BY cashflows; -- test cagg creation with named arguments in time_bucket -- note that positional arguments cannot follow named arguments -- 1. test named origin -- 2. test named timezone -- 3. test named ts -- 4. test named bucket width -- named origin CREATE MATERIALIZED VIEW cagg_named_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named timezone CREATE MATERIALIZED VIEW cagg_named_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named ts CREATE MATERIALIZED VIEW cagg_named_ts_tz_origin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- named bucket width CREATE MATERIALIZED VIEW cagg_named_all WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(bucket_width => '1h', ts => time, timezone => 'UTC', origin => '2001-01-03 01:23:45') AS bucket, avg(amount) as avg_amount FROM transactions GROUP BY 1 WITH NO DATA; -- Refreshing from the beginning (NULL) of a CAGG with variable time bucket and -- using an INTERVAL for the end timestamp (issue #5534) CREATE MATERIALIZED VIEW transactions_montly WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; -- No rows SELECT * FROM transactions_montly ORDER BY bucket; -- Refresh from beginning of the CAGG for 1 month CALL refresh_continuous_aggregate('transactions_montly', NULL, INTERVAL '1 month'); SELECT * FROM transactions_montly ORDER BY bucket; TRUNCATE transactions_montly; -- Partial refresh the CAGG from beginning to an specific timestamp CALL refresh_continuous_aggregate('transactions_montly', NULL, '2018-11-01 11:50:00-08'::timestamptz); SELECT * FROM transactions_montly ORDER BY bucket; -- Full refresh the CAGG CALL refresh_continuous_aggregate('transactions_montly', NULL, NULL); SELECT * FROM transactions_montly ORDER BY bucket; -- Check set_chunk_time_interval on continuous aggregate CREATE MATERIALIZED VIEW cagg_set_chunk_time_interval WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, SUM(fiat_value), MAX(fiat_value), MIN(fiat_value) FROM transactions GROUP BY 1 WITH NO DATA; SELECT set_chunk_time_interval('cagg_set_chunk_time_interval', chunk_time_interval => interval '1 month'); CALL refresh_continuous_aggregate('cagg_set_chunk_time_interval', NULL, NULL); SELECT _timescaledb_functions.to_interval(d.interval_length) = interval '1 month' FROM _timescaledb_catalog.dimension d RIGHT JOIN _timescaledb_catalog.continuous_agg ca ON ca.user_view_name = 'cagg_set_chunk_time_interval' WHERE d.hypertable_id = ca.mat_hypertable_id; -- Since #6077 CAggs are materialized only by default DROP TABLE conditions CASCADE; CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'time'); INSERT INTO conditions VALUES ( '2018-01-01 09:20:00-08', 'SFO', 55); INSERT INTO conditions VALUES ( '2018-01-02 09:30:00-08', 'POR', 100); INSERT INTO conditions VALUES ( '2018-01-02 09:20:00-08', 'SFO', 65); INSERT INTO conditions VALUES ( '2018-01-02 09:10:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 09:20:00-08', 'NYC', 45); INSERT INTO conditions VALUES ( '2018-11-01 10:40:00-08', 'NYC', 55); INSERT INTO conditions VALUES ( '2018-11-01 11:50:00-08', 'NYC', 65); INSERT INTO conditions VALUES ( '2018-11-01 12:10:00-08', 'NYC', 75); INSERT INTO conditions VALUES ( '2018-11-01 13:10:00-08', 'NYC', 85); INSERT INTO conditions VALUES ( '2018-11-02 09:20:00-08', 'NYC', 10); INSERT INTO conditions VALUES ( '2018-11-02 10:30:00-08', 'NYC', 20); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; \d+ conditions_daily -- Should return NO ROWS SELECT * FROM conditions_daily ORDER BY bucket, location; ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=false); \d+ conditions_daily -- Should return ROWS because now it is realtime SELECT * FROM conditions_daily ORDER BY bucket, location; -- Should return ROWS because we refreshed it ALTER MATERIALIZED VIEW conditions_daily SET (timescaledb.materialized_only=true); \d+ conditions_daily CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY bucket, location; -- Test TRUNCATE over a Realtime CAgg DROP MATERIALIZED VIEW conditions_daily; CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT location, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM conditions GROUP BY location, bucket WITH NO DATA; SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_daily' \gset -- Check the current watermark for an empty CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_empty_cagg; -- Refresh the CAGG CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); -- Check the watermark after the refresh and before truncate the CAgg SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_before; -- Exists chunks before truncate the cagg (> 0) SELECT count(*) FROM show_chunks('conditions_daily'); -- Truncate the given CAgg, it should reset the watermark to the empty state TRUNCATE conditions_daily; -- No chunks remains after truncate the cagg (= 0) SELECT count(*) FROM show_chunks('conditions_daily'); -- Watermark should be reseted SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_hypertable_id)) AS watermak_after; -- Should return ROWS because the watermark was reseted by the TRUNCATE SELECT * FROM conditions_daily ORDER BY bucket, location; -- check compression settings are cleaned up when deleting a cagg with compression CREATE TABLE cagg_cleanup(time timestamptz not null); SELECT table_name FROM create_hypertable('cagg_cleanup','time'); INSERT INTO cagg_cleanup SELECT '2020-01-01'; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1h',time) FROM cagg_cleanup GROUP BY 1; ALTER MATERIALIZED VIEW cagg1 SET (timescaledb.compress); SELECT count(compress_chunk(ch)) FROM show_chunks('cagg1') ch; DROP MATERIALIZED VIEW cagg1; SELECT * FROM _timescaledb_catalog.compression_settings; -- test WITH namespace alias CREATE TABLE with_alias(time timestamptz not null); CREATE MATERIALIZED VIEW cagg_alias WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; ALTER MATERIALIZED VIEW cagg_alias SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_alias SET (tsdb.materialized_only=false); DROP MATERIALIZED VIEW cagg_alias; -- test SET chunk_time_interval CREATE MATERIALIZED VIEW cagg_set WITH (tsdb.continuous, tsdb.chunk_interval='1day') AS SELECT time_bucket(INTERVAL '1 day', time) AS cagg_interval_setter FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='23 day'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='6 month'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; ALTER MATERIALIZED VIEW cagg_set SET (tsdb.chunk_interval='1 year'); SELECT column_name, time_interval FROM timescaledb_information.dimensions WHERE column_name='cagg_interval_setter'; -- test cagg with stable functions CREATE MATERIALIZED VIEW cagg_stable WITH (tsdb.continuous) AS SELECT sum(temperature), max(time + INTERVAL '1h') FROM conditions GROUP BY time_bucket('1week', time), location; SELECT * FROM cagg_stable t ORDER BY t; --aggregate without combine function but stable function CREATE MATERIALIZED VIEW cagg_json_agg WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT json_agg(location) from conditions group by time_bucket('1week', time), location WITH NO DATA; CREATE FUNCTION test_stablefunc(int) RETURNS int LANGUAGE 'sql' STABLE AS 'SELECT $1 + 10'; CREATE MATERIALIZED VIEW cagg_stable2 WITH (tsdb.continuous) AS SELECT sum(test_stablefunc(temperature::int)), min(location) FROM conditions GROUP BY time_bucket('1week', time) WITH NO DATA; CREATE MATERIALIZED VIEW cagg_stable3 WITH (tsdb.continuous) AS SELECT sum(temperature), min(location) FROM conditions GROUP BY time_bucket('1week', time), test_stablefunc(temperature::int) WITH NO DATA; -- test window functions in caggs -- first do sanity check that we error without the GUC \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_window WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_window_functions TO on; CREATE MATERIALIZED VIEW cagg_window_1 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1; CREATE MATERIALIZED VIEW cagg_window_2 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time), location) FROM conditions GROUP BY 1, location; CREATE MATERIALIZED VIEW cagg_window_3 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER (PARTITION BY time_bucket('1 week',time)) FROM conditions GROUP BY 1, location; CREATE MATERIALIZED VIEW cagg_window_4 WITH (tsdb.continuous) AS SELECT time_bucket('1week', time), rank() OVER w FROM conditions GROUP BY 1, location WINDOW w AS (PARTITION BY time_bucket('1 week',time)); -- test setting chunk_interval on a cagg CREATE MATERIALIZED VIEW cagg_chunk_interval WITH (tsdb.continuous, tsdb.chunk_interval='1000 day') AS SELECT time_bucket('1 week', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; ALTER MATERIALIZED VIEW cagg_chunk_interval SET (tsdb.chunk_interval='110 day'); SELECT time_interval from timescaledb_information.continuous_aggregates cagg INNER JOIN timescaledb_information.dimensions dim ON cagg.materialization_hypertable_name = dim.hypertable_name WHERE view_name='cagg_chunk_interval'; -- test columnstore options CREATE MATERIALIZED VIEW columnstore_options WITH (tsdb.continuous, tsdb.chunk_interval='1 day') AS SELECT time_bucket('1 day', time) FROM conditions GROUP BY 1 WITH NO DATA; SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.columnstore, tsdb.chunk_interval='1 day', tsdb.orderby='time_bucket DESC', tsdb.compress_chunk_interval='2 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_interval='3 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; ALTER MATERIALIZED VIEW columnstore_options SET (tsdb.compress_chunk_time_interval='4 day'); SELECT column_name, compress_interval_length from _timescaledb_catalog.dimension where column_name='time_bucket' ORDER BY id DESC LIMIT 1; -- test set returning functions in caggs CREATE TABLE kpis_raw (time TIMESTAMP NOT NULL, value INTEGER, groups TEXT[]) WITH (tsdb.hypertable); INSERT INTO kpis_raw (time, value, groups) VALUES ('2025-01-01', 10, '{group1,group2,group3}'), ('2025-01-02', 20, '{group1,group4}'), ('2025-02-01', 10, '{group1,group3}'), ('2025-02-01', 20, '{group1,group4}'); CREATE MATERIALIZED VIEW kpis_cagg WITH (tsdb.continuous) AS SELECT time_bucket('7 day', time) AS bucket, count(*) AS number_of_records, avg(value) AS average, unnest(groups) AS kpi_group FROM kpis_raw GROUP BY bucket, kpi_group; SELECT * FROM kpis_cagg ORDER BY bucket, kpi_group; ������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_deprecated_bucket_ng.sql���������������������������������������0000664�0000000�0000000�00000003016�15100345067�0024256�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions( time timestamptz NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'time', chunk_time_interval => INTERVAL '1 day' ); -- Ensure no CAgg using time_bucket_ng can be created \set ON_ERROR_STOP 0 -- Regular CAgg CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', time, 'UTC') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- CAgg with origin CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', time, '2024-01-16 18:00:00+00') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- CAgg with origin and timezone CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', time, '2024-01-16 18:00:00+00', 'UTC') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; \set ON_ERROR_STOP 1 ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_drop_chunks.sql������������������������������������������������0000664�0000000�0000000�00000010216�15100345067�0022454�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; -- -- Check that drop chunks with a unique constraint works as expected. -- CREATE TABLE clients ( id SERIAL PRIMARY KEY, name TEXT NOT NULL, UNIQUE(name) ); CREATE TABLE records ( time TIMESTAMPTZ NOT NULL, clientId INT NOT NULL REFERENCES clients(id), value DOUBLE PRECISION, UNIQUE(time, clientId) ); SELECT * FROM create_hypertable('records', 'time', chunk_time_interval => INTERVAL '1h'); CREATE MATERIALIZED VIEW records_monthly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time) as bucket, clientId, avg(value) as value_avg, max(value)-min(value) as value_spread FROM records GROUP BY bucket, clientId WITH NO DATA; INSERT INTO clients(name) VALUES ('test-client'); INSERT INTO records SELECT generate_series('2000-03-01'::timestamptz,'2000-04-01','1 day'),1,3.14; SELECT * FROM records_monthly; SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'records_monthly' ORDER BY range_start; SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'records' ORDER BY range_start; CALL refresh_continuous_aggregate('records_monthly', NULL, NULL); \set VERBOSITY default SELECT drop_chunks('records', '2000-03-16'::timestamptz); \set VERBOSITY terse DROP MATERIALIZED VIEW records_monthly; DROP TABLE records; DROP TABLE clients; \set VERBOSITY default CREATE PROCEDURE refresh_cagg_by_chunk_range(_cagg REGCLASS, _hypertable REGCLASS, _older_than INTEGER) AS $$ DECLARE _r RECORD; BEGIN WITH _chunks AS ( SELECT relname, nspname FROM show_chunks(_hypertable, _older_than) AS relid JOIN pg_catalog.pg_class ON pg_class.oid = relid AND pg_class.relkind = 'r' JOIN pg_catalog.pg_namespace ON pg_namespace.oid = pg_class.relnamespace ) SELECT MIN(range_start) AS range_start, MAX(range_end) AS range_end INTO _r FROM _chunks JOIN _timescaledb_catalog.chunk ON chunk.schema_name = _chunks.nspname AND chunk.table_name = _chunks.relname JOIN _timescaledb_catalog.chunk_constraint ON chunk_id = chunk.id JOIN _timescaledb_catalog.dimension_slice ON dimension_slice.id = dimension_slice_id; RAISE INFO 'range_start=% range_end=%', _r.range_start::int, _r.range_end::int; CALL refresh_continuous_aggregate(_cagg, _r.range_start::int, _r.range_end::int + 1); END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION test_int_now() returns INT LANGUAGE SQL STABLE as $$ SELECT 125 $$; CREATE TABLE conditions(time_int INT NOT NULL, value FLOAT); SELECT create_hypertable('conditions', 'time_int', chunk_time_interval => 4); INSERT INTO conditions SELECT time_val, 1 FROM generate_series(0, 19, 1) AS time_val; SELECT set_integer_now_func('conditions', 'test_int_now'); CREATE MATERIALIZED VIEW conditions_2 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(2, time_int) as bucket, SUM(value), COUNT(value) FROM conditions GROUP BY bucket WITH DATA; SELECT * FROM conditions_2 ORDER BY bucket; UPDATE conditions SET value = 4.00 WHERE time_int = 0; UPDATE conditions SET value = 4.00 WHERE time_int = 6; CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', 4); SELECT drop_chunks('conditions', 4); SELECT * FROM conditions_2 ORDER BY bucket; CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', 8); SELECT * FROM conditions_2 ORDER BY bucket; UPDATE conditions SET value = 4.00 WHERE time_int = 19; SELECT drop_chunks('conditions', 8); CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', 12); SELECT * FROM conditions_2 ORDER BY bucket; CALL refresh_cagg_by_chunk_range('conditions_2', 'conditions', NULL); SELECT * FROM conditions_2 ORDER BY bucket; DROP PROCEDURE refresh_cagg_by_chunk_range(REGCLASS, REGCLASS, INTEGER); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_dump.sql�������������������������������������������������������0000664�0000000�0000000�00000012327�15100345067�0021107�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; CREATE TYPE custom_type AS (high int, low int); CREATE TABLE conditions_before ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null, highlow custom_type null, bit_int smallint, good_life boolean ); SELECT table_name FROM create_hypertable( 'conditions_before', 'timec'); INSERT INTO conditions_before SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO conditions_before SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO conditions_before SELECT generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL, NULL, 8, true; CREATE TABLE conditions_after (like conditions_before including all); SELECT table_name FROM create_hypertable( 'conditions_after', 'timec'); INSERT INTO conditions_after SELECT * FROM conditions_before; SELECT $$ SELECT time_bucket('1week', timec) as bucket, location, min(allnull) as min_allnull, max(temperature) as max_temp, sum(temperature)+sum(humidity) as agg_sum_expr, avg(humidity), stddev(humidity), bit_and(bit_int), bit_or(bit_int), bool_and(good_life), every(temperature > 0), bool_or(good_life), count(*) as count_rows, count(temperature) as count_temp, count(allnull) as count_zero, corr(temperature, humidity), covar_pop(temperature, humidity), covar_samp(temperature, humidity), regr_avgx(temperature, humidity), regr_avgy(temperature, humidity), regr_count(temperature, humidity), regr_intercept(temperature, humidity), regr_r2(temperature, humidity), regr_slope(temperature, humidity), regr_sxx(temperature, humidity), regr_sxy(temperature, humidity), regr_syy(temperature, humidity), stddev(temperature) as stddev_temp, stddev_pop(temperature), stddev_samp(temperature), variance(temperature), var_pop(temperature), var_samp(temperature), last(temperature, timec) as last_temp, last(highlow, timec) as last_hl, first(highlow, timec) as first_hl, histogram(temperature, 0, 100, 5) FROM TABLE GROUP BY bucket, location HAVING min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY_TEMPLATE" \gset SELECT replace(:'QUERY_TEMPLATE', 'TABLE', 'conditions_before') AS "QUERY_BEFORE", replace(:'QUERY_TEMPLATE', 'TABLE', 'conditions_after') AS "QUERY_AFTER" \gset DROP MATERIALIZED VIEW IF EXISTS mat_test; --materialize this VIEW before dump this tests --that the partial state survives the dump intact CREATE MATERIALIZED VIEW mat_before WITH (timescaledb.continuous) AS :QUERY_BEFORE WITH NO DATA; --materialize this VIEW after dump this tests --that the partialize VIEW and refresh mechanics --survives the dump intact CREATE MATERIALIZED VIEW mat_after WITH (timescaledb.continuous) AS :QUERY_AFTER WITH NO DATA; --materialize mat_before SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_before', NULL, NULL); SELECT count(*) FROM conditions_before; SELECT count(*) FROM conditions_after; SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_VIEW_name as "PART_VIEW_NAME", partial_VIEW_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_VIEW_name = 'mat_before' \gset SELECT count(*) FROM conditions_before; SELECT count(*) FROM conditions_after; --dump & restore \c postgres :ROLE_SUPERUSER \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; --\! cp dump/pg_dump.sql /tmp/dump.sql SELECT timescaledb_pre_restore(); \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql SELECT timescaledb_post_restore(); SELECT _timescaledb_functions.stop_background_workers(); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; --make sure the appropriate DROP are still blocked. \set ON_ERROR_STOP 0 DROP table :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; \set ON_ERROR_STOP 1 --materialize mat_after CALL refresh_continuous_aggregate('mat_after', NULL, NULL); SELECT count(*) FROM mat_after; --compare results SELECT count(*) FROM conditions_before; SELECT count(*) FROM conditions_after; \set VIEW_NAME mat_before \set QUERY :QUERY_BEFORE \set ECHO errors \ir include/cont_agg_test_equal.sql \set ECHO all \set VIEW_NAME mat_after \set QUERY :QUERY_AFTER \set ECHO errors \ir include/cont_agg_test_equal.sql \set ECHO all DROP MATERIALIZED VIEW mat_after; DROP MATERIALIZED VIEW mat_before; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_errors.sql�����������������������������������������������������0000664�0000000�0000000�00000047751�15100345067�0021467�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 \set VERBOSITY default SET timezone TO PST8PDT; --negative tests for query validation create table mat_t1( a integer, b integer,c TEXT); CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature integer NULL, humidity DOUBLE PRECISION NULL, timemeasure TIMESTAMPTZ, timeinterval INTERVAL ); select table_name from create_hypertable( 'conditions', 'timec'); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.myfill = 1) as select location , min(temperature) from conditions group by time_bucket('1d', timec), location WITH NO DATA; --valid PG option CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false, check_option = LOCAL ) as select * from conditions , mat_t1 WITH NO DATA; --non-hypertable CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select a, count(*) from mat_t1 group by a WITH NO DATA; -- no group by CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select count(*) from conditions WITH NO DATA; -- no time_bucket in group by CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select count(*) from conditions group by location WITH NO DATA; -- with valid query in a CTE CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS with m1 as ( Select location, count(*) from conditions group by time_bucket('1week', timec) , location) select * from m1 WITH NO DATA; --with DISTINCT ON CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select distinct on ( location ) count(*) from conditions group by location, time_bucket('1week', timec) WITH NO DATA; -- time_bucket on non partitioning column of hypertable CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket('1week', timemeasure) , location WITH NO DATA; --time_bucket on expression CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket('1week', timec+ '10 minutes'::interval) , location WITH NO DATA; --multiple time_bucket functions CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket('1week', timec) , time_bucket('1month', timec), location WITH NO DATA; --time_bucket using non-const for first argument CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select max(temperature) from conditions group by time_bucket( timeinterval, timec) , location WITH NO DATA; --window function CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select avg(temperature) over( order by humidity) from conditions WITH NO DATA; -- using subqueries CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from ( select humidity, temperature, location, timec from conditions ) q group by time_bucket('1week', timec) , location WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS select * from ( Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location ) q WITH NO DATA; --using limit /limit offset CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location limit 10 WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location offset 10 WITH NO DATA; --using FETCH CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location fetch first 10 rows only WITH NO DATA; --using locking clauses FOR clause --all should be disabled. we cannot guarntee locks on the hypertable CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR KEY SHARE WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR SHARE WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR UPDATE WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by time_bucket('1week', timec) , location FOR NO KEY UPDATE WITH NO DATA; --tablesample clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions tablesample bernoulli(0.2) group by time_bucket('1week', timec) , location WITH NO DATA; -- ONLY in from clause CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from ONLY conditions group by time_bucket('1week', timec) , location WITH NO DATA; --grouping sets and variants CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by grouping sets(time_bucket('1week', timec) , location ) WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum(humidity), avg(temperature::int4) from conditions group by rollup(time_bucket('1week', timec) , location ) WITH NO DATA; -- Should use CREATE MATERIALIZED VIEW to create continuous aggregates CREATE VIEW continuous_aggs_errors_tbl1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 week', timec) FROM conditions GROUP BY time_bucket('1 week', timec); -- invalid `bucket_width` for `time_bucket` function CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(NULL, timec), sum(temperature), min(location) FROM conditions GROUP BY 1 WITH NO DATA; -- row security on table create table rowsec_tab( a bigint, b integer, c integer); select table_name from create_hypertable( 'rowsec_tab', 'a', chunk_time_interval=>10); CREATE OR REPLACE FUNCTION integer_now_test() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0)::bigint FROM rowsec_tab $$; SELECT set_integer_now_func('rowsec_tab', 'integer_now_test'); alter table rowsec_tab ENABLE ROW LEVEL SECURITY; create policy rowsec_tab_allview ON rowsec_tab FOR SELECT USING(true); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS Select sum( b), min(c) from rowsec_tab group by time_bucket('1', a) WITH NO DATA; drop table conditions cascade; --negative tests for WITH options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test' \gset \set ON_ERROR_STOP 0 -- triggers not allowed on continuous aggregate CREATE OR REPLACE FUNCTION not_allowed() RETURNS trigger AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER not_allowed_trigger INSTEAD OF INSERT ON mat_with_test FOR EACH ROW EXECUTE FUNCTION not_allowed(); ALTER MATERIALIZED VIEW mat_with_test SET(timescaledb.create_group_indexes = 'false'); ALTER MATERIALIZED VIEW mat_with_test SET(timescaledb.create_group_indexes = 'true'); ALTER MATERIALIZED VIEW mat_with_test ALTER timec DROP default; \set ON_ERROR_STOP 1 \set VERBOSITY terse DROP TABLE conditions CASCADE; --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec SMALLINT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_test_s() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0)::smallint FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test_s'); \set ON_ERROR_STOP 0 create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; ALTER TABLE conditions ALTER timec type int; create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; \set ON_ERROR_STOP 1 DROP TABLE conditions cascade; CREATE TABLE conditions ( timec BIGINT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_test_b() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0)::bigint FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test_b'); create materialized view mat_with_test( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(BIGINT '100', timec), min(location), sum(temperature),sum(humidity) from conditions group by 1 WITH NO DATA; -- custom time partition functions are not supported with invalidations CREATE FUNCTION text_part_func(TEXT) RETURNS BIGINT AS $$ SELECT length($1)::BIGINT $$ LANGUAGE SQL IMMUTABLE; CREATE TABLE text_time(time TEXT); SELECT create_hypertable('text_time', 'time', chunk_time_interval => 10, time_partitioning_func => 'text_part_func'); \set VERBOSITY default \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW text_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', text_part_func(time)), COUNT(time) FROM text_time GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 1 -- Check that we get an error when mixing normal materialized views -- and continuous aggregates. CREATE MATERIALIZED VIEW normal_mat_view AS SELECT time_bucket('5', text_part_func(time)), COUNT(time) FROM text_time GROUP BY 1 WITH NO DATA; \set VERBOSITY terse \set ON_ERROR_STOP 0 DROP MATERIALIZED VIEW normal_mat_view, mat_with_test; \set ON_ERROR_STOP 1 DROP TABLE text_time CASCADE; CREATE TABLE measurements (time TIMESTAMPTZ NOT NULL, device INT, value FLOAT); SELECT create_hypertable('measurements', 'time'); INSERT INTO measurements VALUES ('2019-03-04 13:30', 1, 1.3); -- Add a continuous aggregate on the measurements table and a policy -- to be able to test error cases for the add_job function. CREATE MATERIALIZED VIEW measurements_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time), COUNT(time) FROM measurements GROUP BY 1 WITH NO DATA; -- First test that add_job checks the config. It is currently possible -- to add non-custom jobs using the add_job function so we need to -- test that the function actually checks the config parameters. These -- should all generate errors, for different reasons... \set ON_ERROR_STOP 0 -- ... this one because it is missing a field. SELECT add_job( '_timescaledb_functions.policy_refresh_continuous_aggregate'::regproc, '1 hour'::interval, check_config => '_timescaledb_functions.policy_refresh_continuous_aggregate_check'::regproc, config => '{"end_offset": null, "start_offset": null}'); -- ... this one because it has a bad value for start_offset SELECT add_job( '_timescaledb_functions.policy_refresh_continuous_aggregate'::regproc, '1 hour'::interval, check_config => '_timescaledb_functions.policy_refresh_continuous_aggregate_check'::regproc, config => '{"end_offset": null, "start_offset": "1 fortnight", "mat_hypertable_id": 11}'); -- ... this one because it has a bad value for end_offset SELECT add_job( '_timescaledb_functions.policy_refresh_continuous_aggregate'::regproc, '1 hour'::interval, check_config => '_timescaledb_functions.policy_refresh_continuous_aggregate_check'::regproc, config => '{"end_offset": "chicken", "start_offset": null, "mat_hypertable_id": 11}'); \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('measurements_summary', NULL, NULL, '1 h'::interval) AS job_id \gset \x on SELECT * FROM _timescaledb_config.bgw_job WHERE id = :job_id; \x off -- These are all weird values for the parameters for the continuous -- aggregate jobs and should generate an error. Since the config will -- be replaced, we will also generate error for missing arguments. \set ON_ERROR_STOP 0 SELECT alter_job(:job_id, config => '{"end_offset": "1 week", "start_offset": "2 fortnights"}'); SELECT alter_job(:job_id, config => '{"mat_hypertable_id": 11, "end_offset": "chicken", "start_offset": "1 fortnights"}'); SELECT alter_job(:job_id, config => '{"mat_hypertable_id": 11, "end_offset": "chicken", "start_offset": "1 week"}'); \set ON_ERROR_STOP 1 DROP TABLE measurements CASCADE; DROP TABLE conditions CASCADE; -- test handling of invalid mat_hypertable_id create table i2980(time timestamptz not null); select create_hypertable('i2980','time'); create materialized view i2980_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), avg(7) FROM i2980 GROUP BY 1; select add_continuous_aggregate_policy('i2980_cagg',NULL,NULL,'4h') AS job_id \gset \set ON_ERROR_STOP 0 select alter_job(:job_id,config:='{"end_offset": null, "start_offset": null, "mat_hypertable_id": 1000}'); --test creating continuous aggregate with compression enabled -- CREATE MATERIALIZED VIEW i2980_cagg2 with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.compress) AS SELECT time_bucket('1h',time), avg(7) FROM i2980 GROUP BY 1; --this one succeeds CREATE MATERIALIZED VIEW i2980_cagg2 with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time) as bucket, avg(7) FROM i2980 GROUP BY 1; --now enable compression with invalid parameters ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'bucket'); ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress, timescaledb.compress_orderby = 'bucket'); --enable compression and test re-enabling compression ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress); insert into i2980 select now(); call refresh_continuous_aggregate('i2980_cagg2', NULL, NULL); SELECT compress_chunk(ch) FROM show_chunks('i2980_cagg2') ch; ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress = 'false'); ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress = 'true'); ALTER MATERIALIZED VIEW i2980_cagg2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'bucket'); --Errors with compression policy on caggs-- select add_continuous_aggregate_policy('i2980_cagg2', interval '10 day', interval '2 day' ,'4h') AS job_id ; SELECT add_compression_policy('i2980_cagg', '8 day'::interval); ALTER MATERIALIZED VIEW i2980_cagg SET ( timescaledb.compress ); SELECT add_continuous_aggregate_policy('i2980_cagg2', '10 day'::interval, '6 day'::interval); SELECT add_compression_policy('i2980_cagg2', '3'::integer); SELECT add_compression_policy('i2980_cagg2', 13::integer); SELECT materialization_hypertable_schema || '.' || materialization_hypertable_name AS "MAT_TABLE_NAME" FROM timescaledb_information.continuous_aggregates WHERE view_name = 'i2980_cagg2' \gset SELECT add_compression_policy( :'MAT_TABLE_NAME', 13::integer); --TEST compressing cagg chunks without enabling compression SELECT count(*) FROM (select decompress_chunk(ch) FROM show_chunks('i2980_cagg2') ch ) q; ALTER MATERIALIZED VIEW i2980_cagg2 SET (timescaledb.compress = 'false'); SELECT compress_chunk(ch) FROM show_chunks('i2980_cagg2') ch; -- test error handling when trying to create cagg on internal hypertable CREATE TABLE comp_ht_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('comp_ht_test','time'); ALTER TABLE comp_ht_test SET (timescaledb.compress); SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "INTERNALTABLE" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'comp_ht_test') \gset CREATE MATERIALIZED VIEW cagg1 WITH(timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',now()) FROM :INTERNALTABLE GROUP BY 1; --TEST ht + cagg, do not enable compression on ht and try to compress chunk on ht. --Check error handling for this case SELECT compress_chunk(ch) FROM show_chunks('i2980') ch; -- cagg on normal view should error out CREATE VIEW v1 AS SELECT now() AS time; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time) FROM v1 GROUP BY 1; -- cagg on normal view should error out CREATE MATERIALIZED VIEW matv1 AS SELECT now() AS time; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time) FROM matv1 GROUP BY 1; -- No FROM clause in CAGG definition CREATE MATERIALIZED VIEW cagg1 with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT 1 GROUP BY 1 WITH NO DATA; �����������������������timescaledb-2.23.0/tsl/test/sql/cagg_invalidation.sql�����������������������������������������������0000664�0000000�0000000�00000066021�15100345067�0022623�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Disable background workers since we are testing manual refresh \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); SET ROLE :ROLE_DEFAULT_PERM_USER; SET datestyle TO 'ISO, YMD'; SET timezone TO 'UTC'; CREATE VIEW hypertable_invalidation_thresholds AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1; CREATE TABLE conditions (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 10); CREATE TABLE measurements (time int NOT NULL, device int, temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM measurements $$; SELECT set_integer_now_func('conditions', 'bigint_now'); SELECT set_integer_now_func('measurements', 'int_now'); INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE TABLE temp AS SELECT * FROM conditions; INSERT INTO measurements SELECT * FROM temp; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; -- Create two continuous aggregates on the same hypertable to test -- that invalidations are handled correctly across both of them. CREATE MATERIALIZED VIEW cond_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '10', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW cond_20 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW measure_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, device, avg(temp) AS avg_temp FROM measurements GROUP BY 1,2 WITH NO DATA; -- There should be three continuous aggregates, two on one hypertable -- and one on the other: SELECT mat_hypertable_id, raw_hypertable_id, user_view_name FROM _timescaledb_catalog.continuous_agg; -- The continuous aggregates should be empty SELECT * FROM cond_10 ORDER BY 1 DESC, 2; SELECT * FROM cond_20 ORDER BY 1 DESC, 2; SELECT * FROM measure_10 ORDER BY 1 DESC, 2; CREATE OR REPLACE FUNCTION get_hyper_invals() RETURNS TABLE ( "hyper_id" INT, "start" BIGINT, "end" BIGINT ) LANGUAGE SQL VOLATILE AS $$ SELECT hypertable_id, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log ORDER BY 1,2,3 $$; CREATE OR REPLACE FUNCTION get_cagg_invals() RETURNS TABLE ( "cagg_id" INT, "start" BIGINT, "end" BIGINT ) LANGUAGE SQL VOLATILE AS $$ SELECT materialization_id, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1,2,3 $$; CREATE VIEW hyper_invals AS SELECT * FROM get_hyper_invals(); CREATE VIEW cagg_invals AS SELECT * FROM get_cagg_invals(); -- Must refresh to move the invalidation threshold, or no -- invalidations will be generated. Initially, threshold is the -- MIN of the time dimension data type: SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; -- There should be only "infinite" invalidations in the cagg -- invalidation log: SELECT * FROM cagg_invals; -- Now refresh up to 50 without the first bucket, and the threshold should be updated accordingly: CALL refresh_continuous_aggregate('cond_10', 1, 50); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; -- Invalidations should be cleared inside the refresh window: SELECT * FROM cagg_invals; -- Refresh up to 50 from the beginning CALL refresh_continuous_aggregate('cond_10', 0, 50); SELECT * FROM cagg_invals; -- Refreshing below the threshold does not move it: CALL refresh_continuous_aggregate('cond_10', 20, 49); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; -- Nothing changes with invalidations either since the region was -- already refreshed and no new invalidations have been generated: SELECT * FROM cagg_invals; -- Refreshing measure_10 moves the threshold only for the other hypertable: CALL refresh_continuous_aggregate('measure_10', 0, 30); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; SELECT * FROM cagg_invals; -- Refresh on the second continuous aggregate, cond_20, on the first -- hypertable moves the same threshold as when refreshing cond_10: CALL refresh_continuous_aggregate('cond_20', 60, 100); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; SELECT * FROM cagg_invals; -- There should be no hypertable invalidations initially: SELECT * FROM hyper_invals; SELECT * FROM cagg_invals; -- Create invalidations across different ranges. Some of these should -- be deleted and others cut in different ways when a refresh is -- run. Note that the refresh window is inclusive in the start of the -- window but exclusive at the end. -- Entries that should be left unmodified: INSERT INTO conditions VALUES (10, 4, 23.7); INSERT INTO conditions VALUES (10, 5, 23.8), (19, 3, 23.6); INSERT INTO conditions VALUES (60, 3, 23.7), (70, 4, 23.7); -- Should see some invaliations in the hypertable invalidation log: SELECT * FROM hyper_invals; -- Generate some invalidations for the other hypertable INSERT INTO measurements VALUES (20, 4, 23.7); INSERT INTO measurements VALUES (30, 5, 23.8), (80, 3, 23.6); -- Should now see invalidations for both hypertables SELECT * FROM hyper_invals; -- First refresh a window where we don't have any invalidations. This -- allows us to see only the copying of the invalidations to the per -- cagg log without additional processing. CALL refresh_continuous_aggregate('cond_10', 20, 60); -- Invalidation threshold remains at 100: SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold ORDER BY 1,2; -- Invalidations should be moved from the hypertable invalidation log -- to the continuous aggregate log, but only for the hypertable that -- the refreshed aggregate belongs to: SELECT * FROM hyper_invals; SELECT * FROM cagg_invals; -- Now add more invalidations to test a refresh that overlaps with them. -- Entries that should be deleted: INSERT INTO conditions VALUES (30, 1, 23.4), (59, 1, 23.4); INSERT INTO conditions VALUES (20, 1, 23.4), (30, 1, 23.4); -- Entries that should be cut to the right, leaving an invalidation to -- the left of the refresh window: INSERT INTO conditions VALUES (1, 4, 23.7), (25, 1, 23.4); INSERT INTO conditions VALUES (19, 4, 23.7), (59, 1, 23.4); -- Entries that should be cut to the left and right, leaving two -- invalidation entries on each side of the refresh window: INSERT INTO conditions VALUES (2, 2, 23.5), (60, 1, 23.4); INSERT INTO conditions VALUES (3, 2, 23.5), (80, 1, 23.4); -- Entries that should be cut to the left, leaving an invalidation to -- the right of the refresh window: INSERT INTO conditions VALUES (60, 3, 23.6), (90, 3, 23.6); INSERT INTO conditions VALUES (20, 5, 23.8), (100, 3, 23.6); -- New invalidations in the hypertable invalidation log: SELECT * FROM hyper_invals; -- But nothing has yet changed in the cagg invalidation log: SELECT * FROM cagg_invals; -- Refresh to process invalidations for daily temperature: CALL refresh_continuous_aggregate('cond_10', 20, 60); -- Invalidations should be moved from the hypertable invalidation log -- to the continuous aggregate log. SELECT * FROM hyper_invals; -- Only the cond_10 cagg should have its entries cut: SELECT * FROM cagg_invals; -- Refresh also cond_20: CALL refresh_continuous_aggregate('cond_20', 20, 60); -- The cond_20 cagg should also have its entries cut: SELECT * FROM cagg_invals; -- Refresh cond_10 to completely remove an invalidation: CALL refresh_continuous_aggregate('cond_10', 0, 20); -- The 1-19 invalidation should be deleted: SELECT * FROM cagg_invals; -- Clear everything between 0 and 100 to make way for new -- invalidations CALL refresh_continuous_aggregate('cond_10', 0, 100); -- Test refreshing with non-overlapping invalidations INSERT INTO conditions VALUES (20, 1, 23.4), (25, 1, 23.4); INSERT INTO conditions VALUES (30, 1, 23.4), (46, 1, 23.4); CALL refresh_continuous_aggregate('cond_10', 1, 40); SELECT * FROM cagg_invals; -- Refresh whithout cutting (in area where there are no -- invalidations). Merging of overlapping entries should still happen: INSERT INTO conditions VALUES (15, 1, 23.4), (42, 1, 23.4); CALL refresh_continuous_aggregate('cond_10', 90, 100); SELECT * FROM cagg_invals; -- Test max refresh window CALL refresh_continuous_aggregate('cond_10', NULL, NULL); SELECT * FROM cagg_invals; SELECT * FROM hyper_invals; -- Pick the first chunk of conditions to TRUNCATE SELECT show_chunks AS chunk_to_truncate FROM show_chunks('conditions') ORDER BY 1 LIMIT 1 \gset -- Show the data before truncating one of the chunks SELECT * FROM :chunk_to_truncate ORDER BY 1; -- Truncate one chunk TRUNCATE TABLE :chunk_to_truncate; -- Should see new invalidation entries for conditions SELECT * FROM hyper_invals; -- TRUNCATE the hypertable to invalidate all its continuous aggregates TRUNCATE conditions; -- Now empty SELECT * FROM conditions; -- Should see an infinite invalidation entry for conditions SELECT * FROM hyper_invals; -- Aggregates still hold data SELECT * FROM cond_10 ORDER BY 1,2 LIMIT 5; SELECT * FROM cond_20 ORDER BY 1,2 LIMIT 5; CALL refresh_continuous_aggregate('cond_10', NULL, NULL); CALL refresh_continuous_aggregate('cond_20', NULL, NULL); -- Both should now be empty after refresh SELECT * FROM cond_10 ORDER BY 1,2; SELECT * FROM cond_20 ORDER BY 1,2; -- Insert new data again and refresh INSERT INTO conditions VALUES (1, 1, 23.4), (4, 3, 14.3), (5, 1, 13.6), (6, 2, 17.9), (12, 1, 18.3), (19, 3, 28.2), (10, 3, 22.3), (11, 2, 34.9), (15, 2, 45.6), (21, 1, 15.3), (22, 2, 12.3), (29, 3, 16.3); CALL refresh_continuous_aggregate('cond_10', NULL, NULL); CALL refresh_continuous_aggregate('cond_20', NULL, NULL); -- Should now hold data again SELECT * FROM cond_10 ORDER BY 1,2; SELECT * FROM cond_20 ORDER BY 1,2; -- Truncate one of the aggregates, but first test that we block -- TRUNCATE ONLY \set ON_ERROR_STOP 0 TRUNCATE ONLY cond_20; \set ON_ERROR_STOP 1 TRUNCATE cond_20; -- Should now be empty SELECT * FROM cond_20 ORDER BY 1,2; -- Other aggregate is not affected SELECT * FROM cond_10 ORDER BY 1,2; -- Refresh again to bring data back CALL refresh_continuous_aggregate('cond_20', NULL, NULL); -- The aggregate should be populated again SELECT * FROM cond_20 ORDER BY 1,2; ------------------------------------------------------- -- Test corner cases against a minimal bucket aggregate ------------------------------------------------------- -- First, clear the table and aggregate TRUNCATE conditions; SELECT * FROM conditions; CALL refresh_continuous_aggregate('cond_10', NULL, NULL); SELECT * FROM cond_10 ORDER BY 1,2; CREATE MATERIALIZED VIEW cond_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '1', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; SELECT mat_hypertable_id AS cond_1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'cond_1' \gset -- Test invalidations with bucket size 1 INSERT INTO conditions VALUES (0, 1, 1.0); SELECT * FROM hyper_invals; -- Refreshing around the bucket should not update the aggregate CALL refresh_continuous_aggregate('cond_1', -1, 0); SELECT * FROM cond_1 ORDER BY 1,2; CALL refresh_continuous_aggregate('cond_1', 1, 2); SELECT * FROM cond_1 ORDER BY 1,2; -- Refresh only the invalidated bucket CALL refresh_continuous_aggregate('cond_1', 0, 1); SELECT * FROM cagg_invals WHERE cagg_id = :cond_1_id; SELECT * FROM cond_1 ORDER BY 1,2; -- Refresh 1 extra bucket on the left INSERT INTO conditions VALUES (0, 1, 2.0); CALL refresh_continuous_aggregate('cond_1', -1, 1); SELECT * FROM cond_1 ORDER BY 1,2; -- Refresh 1 extra bucket on the right INSERT INTO conditions VALUES (0, 1, 3.0); CALL refresh_continuous_aggregate('cond_1', 0, 2); SELECT * FROM cond_1 ORDER BY 1,2; -- Refresh 1 extra bucket on each side INSERT INTO conditions VALUES (0, 1, 4.0); CALL refresh_continuous_aggregate('cond_1', -1, 2); SELECT * FROM cond_1 ORDER BY 1,2; -- Clear to reset aggregate TRUNCATE conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); -- Test invalidation of size 2 INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0); -- Refresh one bucket at a time CALL refresh_continuous_aggregate('cond_1', 0, 1); SELECT * FROM cond_1 ORDER BY 1,2; CALL refresh_continuous_aggregate('cond_1', 1, 2); SELECT * FROM cond_1 ORDER BY 1,2; -- Repeat the same thing but refresh the whole invalidation at once TRUNCATE conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0); CALL refresh_continuous_aggregate('cond_1', 0, 2); SELECT * FROM cond_1 ORDER BY 1,2; -- Test invalidation of size 3 TRUNCATE conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0), (2, 1, 3.0); -- Invalidation extends beyond the refresh window on both ends CALL refresh_continuous_aggregate('cond_1', 1, 2); SELECT * FROM cond_1 ORDER BY 1,2; -- Should leave one invalidation on each side of the refresh window SELECT * FROM cagg_invals WHERE cagg_id = :cond_1_id; -- Refresh the two remaining invalidations CALL refresh_continuous_aggregate('cond_1', 0, 1); SELECT * FROM cond_1 ORDER BY 1,2; CALL refresh_continuous_aggregate('cond_1', 2, 3); SELECT * FROM cond_1 ORDER BY 1,2; -- Clear and repeat but instead refresh the whole range in one go. The -- result should be the same as the three partial refreshes. Use -- DELETE instead of TRUNCATE to clear this time. DELETE FROM conditions; CALL refresh_continuous_aggregate('cond_1', NULL, NULL); INSERT INTO conditions VALUES (0, 1, 1.0), (1, 1, 2.0), (2, 1, 3.0); CALL refresh_continuous_aggregate('cond_1', 0, 3); SELECT * FROM cond_1 ORDER BY 1,2; ---------------------------------------------- -- Test that invalidation threshold is capped ---------------------------------------------- CREATE table threshold_test (time int, value int); SELECT create_hypertable('threshold_test', 'time', chunk_time_interval => 4); SELECT set_integer_now_func('threshold_test', 'int_now'); CREATE MATERIALIZED VIEW thresh_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(2, time) AS bucket, max(value) AS max FROM threshold_test GROUP BY 1 WITH NO DATA; SELECT raw_hypertable_id AS thresh_hyper_id, mat_hypertable_id AS thresh_cagg_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'thresh_2' \gset -- There's no invalidation threshold initially SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; -- Test that threshold is initilized to min value when there's no data -- and we specify an infinite end. Note that the min value may differ -- depending on time type. CALL refresh_continuous_aggregate('thresh_2', 0, NULL); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; INSERT INTO threshold_test SELECT v, v FROM generate_series(1, 10) v; CALL refresh_continuous_aggregate('thresh_2', 0, 5); -- Threshold should move to end of the last refreshed bucket, which is -- the last bucket fully included in the window, i.e., the window -- shrinks to end of previous bucket. SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; -- Refresh where both the start and end of the window is above the -- max data value CALL refresh_continuous_aggregate('thresh_2', 14, NULL); SELECT watermark AS thresh_hyper_id_watermark FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id \gset -- Refresh where we start from the current watermark to infinity CALL refresh_continuous_aggregate('thresh_2', :thresh_hyper_id_watermark, NULL); -- Now refresh with max end of the window to test that the -- invalidation threshold is capped at the last bucket of data CALL refresh_continuous_aggregate('thresh_2', 0, NULL); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; -- Should not have processed invalidations beyond the invalidation -- threshold. SELECT * FROM cagg_invals WHERE cagg_id = :thresh_cagg_id; -- Check that things are properly materialized SELECT * FROM thresh_2 ORDER BY 1; -- Delete the last data SELECT show_chunks AS chunk_to_drop FROM show_chunks('threshold_test') ORDER BY 1 DESC LIMIT 1 \gset DELETE FROM threshold_test WHERE time > 6; -- The last data in the hypertable is gone SELECT time_bucket(2, time) AS bucket, max(value) AS max FROM threshold_test GROUP BY 1 ORDER BY 1; -- The aggregate still holds data SELECT * FROM thresh_2 ORDER BY 1; -- Refresh the aggregate to bring it up-to-date CALL refresh_continuous_aggregate('thresh_2', 0, NULL); -- Data also gone from the aggregate SELECT * FROM thresh_2 ORDER BY 1; -- The invalidation threshold remains the same SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; -- Insert new data beyond the invalidation threshold to move it -- forward INSERT INTO threshold_test SELECT v, v FROM generate_series(7, 15) v; CALL refresh_continuous_aggregate('thresh_2', 0, NULL); -- Aggregate now updated to reflect newly aggregated data SELECT * FROM thresh_2 ORDER BY 1; -- The invalidation threshold should have moved forward to the end of -- the new data SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :thresh_hyper_id ORDER BY 1,2; -- The aggregate remains invalid beyond the invalidation threshold SELECT * FROM cagg_invals WHERE cagg_id = :thresh_cagg_id; ---------------------------------------------------------------------- -- Test that dropping a chunk invalidates the dropped region. First -- create another chunk so that we have two chunks. One of the chunks -- will be dropped. --------------------------------------------------------------------- INSERT INTO conditions VALUES (10, 1, 10.0); -- Chunks currently associated with the hypertable SELECT show_chunks AS chunk_to_drop FROM show_chunks('conditions'); -- Pick the first one to drop SELECT show_chunks AS chunk_to_drop FROM show_chunks('conditions') ORDER BY 1 LIMIT 1 \gset -- Show the data before dropping one of the chunks SELECT * FROM conditions ORDER BY 1,2; -- Drop one chunk DROP TABLE :chunk_to_drop; -- The chunk's data no longer exists in the hypertable SELECT * FROM conditions ORDER BY 1,2; -- Aggregate still remains in continuous aggregate, however SELECT * FROM cond_1 ORDER BY 1,2; -- Refresh the continuous aggregate to make the dropped data be -- reflected in the aggregate CALL refresh_continuous_aggregate('cond_1', NULL, NULL); -- Aggregate now up-to-date with the source hypertable SELECT * FROM cond_1 ORDER BY 1,2; -- Test that adjacent invalidations are merged INSERT INTO conditions VALUES(1, 1, 1.0), (2, 1, 2.0); INSERT INTO conditions VALUES(3, 1, 1.0); INSERT INTO conditions VALUES(4, 1, 1.0); INSERT INTO conditions VALUES(6, 1, 1.0); CALL refresh_continuous_aggregate('cond_1', 10, NULL); SELECT * FROM cagg_invals WHERE cagg_id = :cond_1_id; --------------------------------------------------------------------- -- Test that single timestamp invalidations are expanded to buckets, -- and adjacent buckets merged. --------------------------------------------------------------------- -- First clear invalidations in a range: CALL refresh_continuous_aggregate('cond_10', -20, 60); -- The following three should be merged to one range 0-29 INSERT INTO conditions VALUES (5, 1, 1.0); INSERT INTO conditions VALUES (15, 1, 1.0); INSERT INTO conditions VALUES (25, 1, 1.0); -- The last one should not merge with the others INSERT INTO conditions VALUES (40, 1, 1.0); -- Refresh to process invalidations, but outside the range of -- invalidations we inserted so that we don't clear them. CALL refresh_continuous_aggregate('cond_10', 50, 60); SELECT mat_hypertable_id AS cond_10_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'cond_10' \gset SELECT * FROM cagg_invals WHERE cagg_id = :cond_10_id; -- should trigger two individual refreshes CALL refresh_continuous_aggregate('cond_10', 0, 200); -- Insert into every second bucket INSERT INTO conditions VALUES (20, 1, 1.0); INSERT INTO conditions VALUES (40, 1, 1.0); INSERT INTO conditions VALUES (60, 1, 1.0); INSERT INTO conditions VALUES (80, 1, 1.0); INSERT INTO conditions VALUES (100, 1, 1.0); INSERT INTO conditions VALUES (120, 1, 1.0); INSERT INTO conditions VALUES (140, 1, 1.0); CALL refresh_continuous_aggregate('cond_10', 0, 200); -- Test refresh with undefined invalidation threshold and variable sized buckets CREATE TABLE timestamp_ht ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('timestamp_ht', 'time'); CREATE MATERIALIZED VIEW temperature_4h WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; -- We also treat time_buckets with an hourly interval that uses a time-zone -- as a variable see caggtimebucket_validate(). CREATE MATERIALIZED VIEW temperature_4h_2 WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, 'Europe/Berlin') AS bucket_4h, avg(value) AS average FROM timestamp_ht GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_1month WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', time), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_1month_ts WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', time, 'Europe/Berlin'), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_1month_hierarchical WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', bucket_4h), avg(average) FROM temperature_4h_2 GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_1month_hierarchical_ts WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', bucket_4h, 'Europe/Berlin'), avg(average) FROM temperature_4h_2 GROUP BY 1 ORDER BY 1; --------------------------------------------------------------------- --- Issue 5474 --------------------------------------------------------------------- CREATE TABLE i5474 ( time timestamptz NOT NULL, sensor_id integer NOT NULL, cpu double precision NOT NULL, temperature double precision NOT NULL); SELECT create_hypertable('i5474','time'); CREATE MATERIALIZED VIEW i5474_summary_daily WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, 'AWST') AS bucket, sensor_id, avg(cpu) AS avg_cpu FROM i5474 GROUP BY bucket, sensor_id; SELECT add_continuous_aggregate_policy('i5474_summary_daily', start_offset => NULL, end_offset => INTERVAL '10 MINUTES', schedule_interval => INTERVAL '1 MINUTE' ) new_job_id \gset -- Check that start_offset = NULL is handled properly by the refresh job... CALL run_job(:new_job_id); -- ...and the CAgg can be refreshed afterward CALL refresh_continuous_aggregate('i5474_summary_daily', NULL, '2023-03-21 05:00:00+00'); INSERT INTO i5474 (time, sensor_id, cpu, temperature) VALUES ('2000-01-01 05:00:00+00', 1, 1.0, 1.0); CALL refresh_continuous_aggregate('i5474_summary_daily', NULL, '2023-01-01 01:00:00+00'); -- CAgg should be up-to-date now CALL refresh_continuous_aggregate('i5474_summary_daily', NULL, '2023-01-01 01:00:00+00'); -- -- Test the invalidation move function -- -- Make sure to move the threshold for the insertions we are going to -- do. CALL refresh_continuous_aggregate('measure_10', 0, 200); SELECT * FROM hypertable_invalidation_thresholds WHERE hypertable IN ('conditions'::regclass, 'measurements'::regclass); SELECT * FROM hyper_invals; -- Save away the contents of some materialized views so that we can -- check that they are not updated when we move invalidations. SELECT * INTO saved_measure_10 FROM measure_10; SELECT * INTO saved_cond_10 FROM cond_10; -- Generate some invalidations for the hypertables INSERT INTO conditions VALUES (110, 14, 23.7); INSERT INTO conditions VALUES (110, 15, 23.8), (119, 3, 23.6); INSERT INTO conditions VALUES (160, 13, 23.7), (170, 4, 23.7); INSERT INTO measurements VALUES (120, 14, 23.7); INSERT INTO measurements VALUES (130, 15, 23.8), (180, 3, 23.6); -- Move hypertable invalidations one hypertable at a time and see that -- they are moved and that attached continuous aggregates are not -- updated. SELECT * FROM hyper_invals; CALL _timescaledb_functions.process_hypertable_invalidations('measurements'); SELECT * FROM measure_10 FULL JOIN saved_measure_10 ON row(measure_10.*) = row(saved_measure_10.*) WHERE measure_10.bucket IS NULL OR saved_measure_10.bucket IS NULL ORDER BY 1, 2; SELECT * FROM hyper_invals; CALL _timescaledb_functions.process_hypertable_invalidations('conditions'); SELECT * FROM cond_10 FULL JOIN saved_cond_10 ON row(cond_10.*) = row(saved_cond_10.*) WHERE cond_10.bucket IS NULL OR saved_cond_10.bucket IS NULL ORDER BY 1, 2; SELECT * FROM hyper_invals; -- Check that once we refresh the continuous aggregates, the changes -- are there. CALL refresh_continuous_aggregate('measure_10', NULL, NULL); SELECT * FROM measure_10 FULL JOIN saved_measure_10 ON row(measure_10.*) = row(saved_measure_10.*) WHERE measure_10.bucket IS NULL OR saved_measure_10.bucket IS NULL ORDER BY 1, 2; CALL refresh_continuous_aggregate('cond_10', NULL, NULL); SELECT * FROM cond_10 FULL JOIN saved_cond_10 ON row(cond_10.*) = row(saved_cond_10.*) WHERE cond_10.bucket IS NULL OR saved_cond_10.bucket IS NULL ORDER BY 1, 2; -- These should fail for different reasons \set ON_ERROR_STOP 0 CALL _timescaledb_functions.process_hypertable_invalidations(NULL); CALL _timescaledb_functions.process_hypertable_invalidations(0); CALL _timescaledb_functions.process_hypertable_invalidations('measure_10'); SET ROLE :ROLE_DEFAULT_PERM_USER_2; CALL _timescaledb_functions.process_hypertable_invalidations('measurements'); \set ON_ERROR_STOP 1 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_invalidation_multi.sql�����������������������������������������0000664�0000000�0000000�00000015572�15100345067�0024042�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Disable background workers since we are testing manual refresh \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); SET datestyle TO 'ISO, YMD'; SET timezone TO 'UTC'; SET timescaledb.enable_cagg_wal_based_invalidation TO true; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW hypertable_invalidation_thresholds AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id; CREATE VIEW mat_invals AS SELECT ca.user_view_name AS aggregate_name, ht.table_name, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ml ON ca.mat_hypertable_id = ml.materialization_id JOIN _timescaledb_catalog.hypertable ht ON materialization_id = ht.id; CREATE VIEW invalidation_slots AS SELECT replace(slot_name::text, dboid::text, 'DBOID') AS slot_name, slot_type, database FROM pg_replication_slots, (select oid from pg_database where current_database() = datname) t(dboid) WHERE plugin = :'plugin_name'; CREATE TABLE conditions (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 10); CREATE TABLE measurements (time int NOT NULL, device int, temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM measurements $$; SELECT set_integer_now_func('conditions', 'bigint_now'); SELECT set_integer_now_func('measurements', 'int_now'); INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE TABLE temp AS SELECT * FROM conditions; INSERT INTO measurements SELECT * FROM temp; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; SELECT * FROM invalidation_slots; -- Create two continuous aggregates on the same hypertable to test -- that invalidations are handled correctly across both of them. -- set client_min_messages to debug2; CREATE MATERIALIZED VIEW cond_10 WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(BIGINT '10', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2; CREATE MATERIALIZED VIEW cond_20 WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2; CREATE MATERIALIZED VIEW measure_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, device, avg(temp) AS avg_temp FROM measurements GROUP BY 1,2; -- We need to refresh to move the invalidation threshold, or -- invalidations will not be generated. Check initial value of -- thresholds and materialization invalidations. SELECT * FROM hypertable_invalidation_thresholds ORDER BY 1,2; SELECT * INTO saved_invals FROM mat_invals; INSERT INTO conditions VALUES (10, 4, 23.7), (10, 5, 23.8), (19, 3, 23.6), (60, 3, 23.7), (70, 4, 23.7); INSERT INTO measurements VALUES (20, 4, 23.7), (30, 5, 23.8), (80, 3, 23.6); INSERT INTO measurements VALUES (20, 4, 23.7), (140, 5, 23.8), (200, 3, 23.6); SELECT * FROM invalidation_slots; CALL _timescaledb_functions.process_hypertable_invalidations( ARRAY['measurements', 'conditions'] ); SELECT m.* FROM mat_invals m FULL JOIN saved_invals s ON row(m.*) = row(s.*) WHERE m.table_name IS NULL OR s.table_name IS NULL ORDER BY 1,2,3; DROP TABLE saved_invals; -- Insert a lot of invalidations (more than 256) to trigger the code -- that grows the ranges array and make sure that works as well. We -- need to generate separate transactions for each insert, so we do -- this using a loop rather than a single insert. SELECT * FROM hypertable_invalidation_thresholds ORDER BY 1,2; DO $$ DECLARE rec RECORD; BEGIN FOR rec IN SELECT t, d FROM generate_series(1,100) t, generate_series(1,100) d LOOP INSERT INTO conditions VALUES (rec.t, rec.d, 100.0 * random()); COMMIT; END LOOP; END $$; SELECT * INTO saved_invals FROM mat_invals; -- Peek at the WAL to check what we've got recorded. SELECT slot_name FROM pg_replication_slots WHERE slot_name LIKE 'ts%cagg' \gset SELECT count(data) FROM pg_logical_slot_peek_binary_changes(:'slot_name', NULL, 1000, variadic ARRAY['conditions', 'time']); -- We set the work memory quite low to trigger range shedding when -- running out of memory. SET timescaledb.cagg_processing_low_work_mem TO 64; SET timescaledb.cagg_processing_high_work_mem TO 96; CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions']); -- Here we should get invalidations aligned to the bucket widths based -- on the invalidation above. -- -- We collect all the ranges into a multirange to avoid flakes because -- of additional entries as a result of shedding below. The complete -- invalidated ranges should be the same regardless. SELECT m.aggregate_name, unnest(range_agg(multirange(int8range(m.lowest_modified_value, m.greatest_modified_value)))) FROM mat_invals m FULL JOIN saved_invals s ON row(m.*) = row(s.*) WHERE m.table_name IS NULL OR s.table_name IS NULL GROUP BY 1 ORDER BY 1,2; -- This should be fine but not process any tables. Odd usage, but -- nothing wrong with it. CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY[]::regclass[]); -- These should error out \set ON_ERROR_STOP 0 \set VERBOSITY default CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['cond_10']); CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY[0]); CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['cond_10', 'cond_20']); CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 'cond_20']); CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 123456]::regclass[]); CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 123456, 'cond_10']::regclass[]); CALL _timescaledb_functions.process_hypertable_invalidations(ARRAY['conditions', 123456, 'cond_10', 'cond_20']::regclass[]); \set VERBOSITY terse \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_joins.sql������������������������������������������������������0000664�0000000�0000000�00000052517�15100345067�0021271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set VERBOSITY default SET timezone TO PST8PDT; CREATE TABLE conditions( day TIMESTAMPTZ NOT NULL, city text NOT NULL, temperature INT NOT NULL, device_id int NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'day', chunk_time_interval => INTERVAL '1 day'); INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-14', 'Moscow', 26,1), ('2021-06-15', 'Berlin', 22,2), ('2021-06-16', 'Stockholm', 24,3), ('2021-06-17', 'London', 24,4), ('2021-06-18', 'London', 27,4), ('2021-06-19', 'Moscow', 28,4), ('2021-06-20', 'Moscow', 30,1), ('2021-06-21', 'Berlin', 31,1), ('2021-06-22', 'Stockholm', 34,1), ('2021-06-23', 'Stockholm', 34,2), ('2021-06-24', 'Moscow', 34,2), ('2021-06-25', 'London', 32,3), ('2021-06-26', 'Moscow', 32,3), ('2021-06-27', 'Moscow', 31,3); CREATE TABLE conditions_dup AS SELECT * FROM conditions; SELECT table_name FROM create_hypertable('conditions_dup', 'day', chunk_time_interval => INTERVAL '1 day', migrate_data => true); CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); CREATE TABLE location (location_id INTEGER, name TEXT); INSERT INTO location VALUES (1, 'Moscow'), (2, 'Berlin'), (3, 'London'), (4, 'Stockholm'); CREATE TABLE devices_dup AS SELECT * FROM devices; CREATE VIEW devices_view AS SELECT * FROM devices; -- Cagg with inner join + realtime aggregate CREATE MATERIALIZED VIEW cagg_realtime WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; \d+ cagg_realtime SELECT * FROM cagg_realtime ORDER BY bucket, name; INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-30', 'Moscow', 28, 3); SELECT * FROM cagg_realtime ORDER BY bucket, name; -- Cagg with inner join + realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_realtime_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; \d+ cagg_realtime_join SELECT * FROM cagg_realtime_join ORDER BY bucket, name; INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-30', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_join ORDER BY bucket, name; -- Cagg with inner join + realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_realtime_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING (device_id) GROUP BY name, bucket ORDER BY bucket; \d+ cagg_realtime_using SELECT * FROM cagg_realtime_using ORDER BY bucket; INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-06-30', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_using ORDER BY bucket, name; -- Reorder tables in FROM clause -- Cagg with inner join + realtime aggregate CREATE MATERIALIZED VIEW cagg_realtime_reorder WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices, conditions WHERE conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; \d+ cagg_realtime_reorder SELECT * FROM cagg_realtime_reorder ORDER BY bucket, name; INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-07-01', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_reorder ORDER BY bucket, name; -- Reorder tables in FROM clause -- Cagg with inner join + realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_realtime_reorder_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions ON conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; \d+ cagg_realtime_reorder_join SELECT * FROM cagg_realtime_reorder_join ORDER BY bucket, name; INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-07-01', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_reorder_join; -- Reorder tables in FROM clause -- Cagg with inner join + realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_realtime_reorder_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions USING (device_id) GROUP BY name, bucket ORDER BY bucket; \d+ cagg_realtime_reorder_using SELECT * FROM cagg_realtime_reorder_using ORDER BY bucket, name; INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2021-07-01', 'Moscow', 28, 3); SELECT * FROM cagg_realtime_reorder_using ORDER BY bucket, name; -- Cagg with inner joins - realtime aggregate CREATE MATERIALIZED VIEW cagg WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name, devices.device_id AS thermo_id FROM conditions, devices WHERE conditions.device_id = devices.device_id GROUP BY bucket, name, thermo_id ORDER BY bucket; SELECT * FROM cagg ORDER BY bucket, name, thermo_id; -- Cagg with inner joins - realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id GROUP BY bucket,name ORDER BY bucket; SELECT * FROM cagg_join ORDER BY bucket, name; -- Cagg with inner joins - realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING (device_id) GROUP BY name, bucket ORDER BY bucket; SELECT * FROM cagg_using; -- Reorder tables in FROM clause -- Cagg with inner joins - realtime aggregate CREATE MATERIALIZED VIEW cagg_reorder WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices, conditions WHERE conditions.device_id = devices.device_id GROUP BY bucket, name ORDER BY bucket; SELECT * FROM cagg_reorder ORDER BY bucket, name; -- Cagg with inner joins - realtime aggregate + JOIN clause CREATE MATERIALIZED VIEW cagg_reorder_join WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions ON conditions.device_id = devices.device_id GROUP BY name, bucket ORDER BY bucket; SELECT * FROM cagg_reorder_join; -- Cagg with inner joins - realtime aggregate + USING clause CREATE MATERIALIZED VIEW cagg_reorder_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM devices JOIN conditions USING (device_id) GROUP BY name, bucket ORDER BY bucket; SELECT * FROM cagg_reorder_using; -- Cagg join with another table using FROM ONLY CREATE MATERIALIZED VIEW cagg_from_only WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM ONLY devices JOIN conditions USING (device_id) GROUP BY name, bucket ORDER BY bucket; SELECT * FROM cagg_from_only; -- Create CAgg with join and additional WHERE conditions CREATE MATERIALIZED VIEW cagg_more_conds WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket; SELECT * FROM cagg_more_conds ORDER BY bucket; -- Cagg with more conditions and USING clause CREATE MATERIALIZED VIEW cagg_more_conds_using WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING (device_id) WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket; SELECT * FROM cagg_more_conds_using ORDER BY bucket; -- Hierarchical CAgg with join CREATE MATERIALIZED VIEW cagg_on_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 day', bucket) AS bucket, SUM(avg) AS temperature FROM cagg, devices WHERE devices.device_id = cagg.thermo_id GROUP BY 1; SELECT * FROM cagg_on_cagg; DROP MATERIALIZED VIEW cagg_on_cagg CASCADE; -- Nested CAgg over a CAgg with JOIN clause CREATE MATERIALIZED VIEW cagg_on_cagg_join WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 day', bucket) AS bucket, SUM(avg) AS temperature FROM cagg JOIN devices ON devices.device_id = cagg.thermo_id GROUP BY 1; SELECT * FROM cagg_on_cagg_join; DROP MATERIALIZED VIEW cagg_on_cagg_join CASCADE; -- Create CAgg with join and ORDER BY CREATE MATERIALIZED VIEW cagg_ordered WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket ORDER BY name; SELECT * FROM cagg_ordered ORDER BY bucket; CREATE MATERIALIZED VIEW cagg_ordered_2 WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket ORDER BY name DESC; SELECT * FROM cagg_ordered_2 ORDER BY bucket; CREATE MATERIALIZED VIEW cagg_ordered_3 WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket ORDER BY name, bucket; SELECT * FROM cagg_ordered_3 ORDER BY bucket; CREATE MATERIALIZED VIEW cagg_cagg WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), devices.device_id device_id, name FROM conditions, devices WHERE conditions.device_id = devices.device_id GROUP BY name, bucket, devices.device_id; --Join between cagg and normal table CREATE MATERIALIZED VIEW cagg_nested WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', cagg.bucket) AS bucket, devices.name FROM cagg_cagg cagg, devices WHERE cagg.device_id = devices.device_id GROUP BY 1,2; DROP MATERIALIZED VIEW cagg_nested CASCADE; -- CAgg with multiple join conditions without JOIN clause CREATE MATERIALIZED VIEW cagg_more_joins_conds WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), MAX(temperature), MIN(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id AND conditions.city = devices.location AND conditions.temperature > 28 GROUP BY name, bucket; -- With LATERAL multiple tables in new format CREATE TABLE mat_t1(a integer, b integer, c TEXT); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, temperature, count(*) from conditions, LATERAL (SELECT * FROM mat_t1 WHERE mat_t1.a = conditions.temperature) q GROUP BY bucket, temperature; -- Joining a hypertable and view CREATE MATERIALIZED VIEW cagg_view WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), devices_view.device_id, name FROM conditions, devices_view WHERE conditions.device_id = devices_view.device_id GROUP BY name, bucket, devices_view.device_id; CREATE TABLE cities(name text, currency text); INSERT INTO cities VALUES ('Berlin', 'EUR'), ('London', 'PND'); --Error out when FROM clause has sub selects \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN (SELECT * FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) dev ON conditions.device_id = dev.device_id GROUP BY name, bucket; --Error out when WHERE clause has sub selects CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.city IN ( SELECT location FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) AND conditions.device_id = devices.device_id GROUP BY name, bucket; CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices USING(device_id) WHERE conditions.city IN ( SELECT location FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) GROUP BY name, bucket; CREATE MATERIALIZED VIEW conditions_summary_subselect WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id WHERE conditions.city IN ( SELECT location FROM devices WHERE location in ( SELECT name FROM cities WHERE currency = 'EUR')) GROUP BY name, bucket; DROP TABLE cities CASCADE; --Error out when join is between two hypertables CREATE MATERIALIZED VIEW cagg_ht WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', conditions.day) AS bucket, AVG(conditions.temperature) FROM conditions, conditions_dup WHERE conditions.device_id = conditions_dup.device_id GROUP BY bucket; --Error out when join is between two normal tables CREATE MATERIALIZED VIEW cagg_nt WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT AVG(devices.device_id), devices.name, devices.location FROM devices, devices_dup WHERE devices.device_id = devices_dup.device_id GROUP BY devices.name, devices.location; \set ON_ERROR_STOP 1 -- JOIN with non-equality condition CREATE MATERIALIZED VIEW cagg_unequal1 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.device_id <> devices.device_id GROUP BY name, bucket; -- JOIN with non-equality condition CREATE MATERIALIZED VIEW cagg_unequal2 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions, devices WHERE conditions.device_id = devices.device_id AND conditions.city like '%cow*' GROUP BY name, bucket; -- JOIN with non-equality condition CREATE MATERIALIZED VIEW cagg_unequal3 WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions JOIN devices ON conditions.device_id = devices.device_id OR conditions.city LIKE '%cow*' GROUP BY name, bucket; -- Error out when join type is not INNER or LEFT \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_outer WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions FULL JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket; CREATE MATERIALIZED VIEW cagg_right WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions RIGHT JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket; \set ON_ERROR_STOP 1 -- LEFT JOIN is allowed CREATE MATERIALIZED VIEW cagg_left_join WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', day) AS bucket, AVG(temperature), name FROM conditions LEFT JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, bucket; -- Error out for join between cagg and hypertable \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW cagg_nested_ht WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket(INTERVAL '1 day', cagg.bucket) AS bucket, cagg.name, conditions.temperature FROM cagg_cagg cagg, conditions WHERE cagg.device_id = conditions.device_id GROUP BY 1,2,3; \set ON_ERROR_STOP 1 -- Multiple JOINS are supported CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', conditions.day) AS bucket, AVG(conditions.temperature), devices.name AS device, location.name AS location FROM conditions JOIN devices ON conditions.device_id = devices.device_id JOIN location ON location.name = devices.location GROUP BY bucket, devices.name, location.name; SELECT * FROM conditions_by_day ORDER BY bucket, device, location; ALTER MATERIALIZED VIEW conditions_by_day SET (timescaledb.materialized_only = FALSE); -- Insert one more row on conditions and check the result (should have one more row) INSERT INTO conditions (day, city, temperature, device_id) VALUES ('2024-07-01', 'Moscow', 28, 3); SELECT * FROM conditions_by_day ORDER BY bucket, device, location; -- JOIN with a foreign table \c :TEST_DBNAME :ROLE_SUPERUSER SELECT current_setting('port') AS "PGPORT", current_database() AS "PGDATABASE" \gset CREATE EXTENSION postgres_fdw; CREATE SERVER loopback FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'localhost', dbname :'PGDATABASE', port :'PGPORT'); CREATE USER MAPPING FOR :ROLE_DEFAULT_PERM_USER SERVER loopback OPTIONS (user :'ROLE_DEFAULT_PERM_USER', password 'nopassword'); ALTER USER MAPPING FOR :ROLE_DEFAULT_PERM_USER SERVER loopback OPTIONS (ADD password_required 'false'); GRANT USAGE ON FOREIGN SERVER loopback TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER; SET timezone TO PST8PDT; CREATE FOREIGN TABLE devices_fdw ( device_id int not null, name text, location text ) SERVER loopback OPTIONS (table_name 'devices'); CREATE MATERIALIZED VIEW conditions_fdw WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', conditions.day) AS bucket, AVG(conditions.temperature), devices.name AS device FROM conditions JOIN devices_fdw AS devices ON conditions.device_id = devices.device_id GROUP BY bucket, devices.name; \set VERBOSITY terse SET client_min_messages TO WARNING; DROP TABLE conditions CASCADE; DROP TABLE devices CASCADE; DROP TABLE conditions_dup CASCADE; DROP TABLE devices_dup CASCADE; RESET client_min_messages; \set VERBOSITY default -- SDC #1859 CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, value FLOAT8 NOT NULL, device_id int NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => INTERVAL '1 day'); INSERT INTO conditions (time, value, device_id) SELECT t, 1, 1 FROM generate_series('2024-01-01 00:00:00-00'::timestamptz, '2024-12-31 00:00:00-00'::timestamptz, '1 hour'::interval) AS t; CREATE TABLE devices (device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW cagg_realtime WITH (timescaledb.continuous, timescaledb.materialized_only = FALSE) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, MAX(value), MIN(value), AVG(value), devices.name, devices.location FROM conditions JOIN devices ON conditions.device_id = devices.device_id GROUP BY name, location, bucket WITH NO DATA; \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER VACUUM ANALYZE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT a.* FROM cagg_realtime a WHERE a.location = 'Moscow' ORDER BY bucket LIMIT 2; \set VERBOSITY terse SET client_min_messages TO WARNING; DROP TABLE conditions CASCADE; DROP TABLE devices CASCADE; RESET client_min_messages; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_migrate.sql����������������������������������������������������0000664�0000000�0000000�00000010434�15100345067�0021567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER -- ######################################################## -- ## INTEGER data type tests -- ######################################################## \set IS_TIME_DIMENSION FALSE \set TIME_DIMENSION_DATATYPE INTEGER \ir include/cagg_migrate_common.sql -- ######################################################## -- ## TIMESTAMP data type tests -- ######################################################## \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMP \ir include/cagg_migrate_common.sql -- ######################################################## -- ## TIMESTAMPTZ data type tests -- ######################################################## \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \ir include/cagg_migrate_common.sql -- ######################################################### -- Issue 5359 - custom timezones should not break the migration -- ######################################################### SET timezone = 'Europe/Budapest'; -- Test with timestamp \set TIME_DIMENSION_DATATYPE TIMESTAMP \ir include/cagg_migrate_custom_timezone.sql -- Test with timestamptz \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \ir include/cagg_migrate_custom_timezone.sql -- ######################################################### -- Issue 6976 - space partitioning should not cause catalog corruption -- ######################################################### CREATE TABLE space_partitioning ( time timestamptz, device_id integer, value float ); -- Updating sequence numbers so creating a hypertable doesn't mess with -- data imports used by migration tests SELECT setval('_timescaledb_catalog.hypertable_id_seq', 999, true); SELECT setval('_timescaledb_catalog.chunk_id_seq', 999, true); SELECT setval('_timescaledb_catalog.dimension_id_seq', 999, true); SELECT setval('_timescaledb_catalog.dimension_slice_id_seq', 999, true); SELECT create_hypertable('space_partitioning', 'time', chunk_time_interval=>'1 hour'::interval); SELECT add_dimension('space_partitioning', 'device_id', 3); INSERT INTO space_partitioning SELECT t, 1, 1.0 FROM generate_series('2024-01-01'::timestamptz, '2024-02-01'::timestamptz, '10 minutes'::interval) t; INSERT INTO space_partitioning SELECT t, 1000, 1.0 FROM generate_series('2024-01-01'::timestamptz, '2024-02-01'::timestamptz, '10 minutes'::interval) t; CREATE MATERIALIZED VIEW space_partitioning_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, device_id, MIN(value), MAX(value), SUM(value) FROM space_partitioning GROUP BY 1, 2 WITH NO DATA; -- setting up the state so that remove_dropped_chunk_metadata -- would run on the hypertable and trigger the catalog corruption UPDATE _timescaledb_catalog.chunk SET dropped = TRUE FROM _timescaledb_catalog.hypertable WHERE chunk.hypertable_id = hypertable.id AND hypertable.table_name = 'space_partitioning' AND chunk.id = 1000; UPDATE _timescaledb_catalog.continuous_agg SET finalized = true FROM _timescaledb_catalog.hypertable WHERE continuous_agg.raw_hypertable_id = hypertable.id AND hypertable.table_name = 'space_partitioning'; SET timescaledb.restoring TO ON; DROP TABLE _timescaledb_internal._hyper_1000_1000_chunk; SET timescaledb.restoring TO OFF; SELECT _timescaledb_functions.remove_dropped_chunk_metadata(id) FROM _timescaledb_catalog.hypertable WHERE table_name = 'space_partitioning'; -- check every chunk has as many chunk constraints as -- there are dimensions, should return empty result -- this ensures we have avoided catalog corruption WITH dimension_count as ( SELECT ht.id, count(*) FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.dimension d ON d.hypertable_id = ht.id WHERE table_name = 'space_partitioning' GROUP BY 1), chunk_constraint_count AS ( SELECT c.hypertable_id, cc.chunk_id, count(*) FROM _timescaledb_catalog.chunk_constraint cc INNER JOIN _timescaledb_catalog.chunk c ON cc.chunk_id = c.id GROUP BY 1, 2 ) SELECT * FROM dimension_count dc INNER JOIN chunk_constraint_count ccc ON ccc.hypertable_id = dc.id WHERE dc.count != ccc.count; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_migrate_function.sql.in����������������������������������������0000664�0000000�0000000�00000032565�15100345067�0024112�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Run test as non-superuser \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Prepare a hypertable with date values CREATE TABLE temperaturedate ( time date NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturedate', 'time'); INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamp values CREATE TABLE temperature ( time timestamp NOT NULL, sensor int, value float ); SELECT create_hypertable('temperature', 'time'); INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+00'::timestamptz, '2010-01-01 23:59:59+00','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Prepare a hypertable with timestamptz values CREATE TABLE temperaturetz ( time timestamptz NOT NULL, sensor int, value float ); SELECT create_hypertable('temperaturetz', 'time'); INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; --- Tests with date -- -- Tested function signatures -- -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date -- timescaledb_experimental | time_bucket_ng | date | bucket_width interval, ts date, origin date --- CREATE MATERIALIZED VIEW cagg_tempdate_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng' \ir include/cagg_run_timebucket_migration.sql CREATE MATERIALIZED VIEW cagg_tempdate_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time, '2020-01-04') as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_tempdate_ng_origin' \ir include/cagg_run_timebucket_migration.sql --- Tests with timestamp -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone -- timescaledb_experimental | time_bucket_ng | timestamp without time zone | bucket_width interval, ts timestamp without time zone, origin timestamp without time zone --- CREATE MATERIALIZED VIEW cagg_temp_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng' \ir include/cagg_run_timebucket_migration.sql CREATE MATERIALIZED VIEW cagg_temp_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-01-01 04:00:00') as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temp_ng_origin' \ir include/cagg_run_timebucket_migration.sql --- Tests with timestamptz -- -- Not tested signatures since they are not supported by CAggs -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone -- -- Tested function signatures -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, origin timestamp with time zone, timezone text -- timescaledb_experimental | time_bucket_ng | timestamp with time zone | bucket_width interval, ts timestamp with time zone, timezone text --- -- Create a CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration \set CAGG_NAME 'cagg_temptz_ng' \ir include/cagg_run_timebucket_migration.sql CREATE MATERIALIZED VIEW cagg_temptz_ng_origin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, '2020-04-01'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; -- Run the migration - special case, order of origin and timezone needs to be swapped \set CAGG_NAME 'cagg_temptz_ng_origin' \ir include/cagg_run_timebucket_migration.sql -- Test real-time CAggs as well -- Create a real-time CAgg using time_bucket_ng CREATE MATERIALIZED VIEW cagg_temptz_ng_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 minutes', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; \set CAGG_NAME 'cagg_temptz_ng_rt' \ir include/cagg_run_timebucket_migration.sql ---- -- Check bucket conversion -- timestamptz without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week; -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00+01'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week ORDER BY time, sensor; ---- -- Check bucket conversion -- timestamptz with custom origin ---- TRUNCATE temperaturetz; INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2010-01-01 0:00:00+0'::timestamptz, '2010-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); CREATE MATERIALIZED VIEW cagg_temp_ng_1week_corgin WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin') as time, sensor, avg(value) AS avg FROM temperaturetz GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); SELECT * FROM cagg_temp_ng_1week_corgin; -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturetz SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_corgin'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_corgin', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time, '2005-01-01 15:00:00'::timestamptz, 'Europe/Berlin'), sensor, avg(value) FROM temperaturetz GROUP BY 1, 2 ORDER BY 1, 2; -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_corgin ORDER BY time, sensor; ---- -- Check bucket conversion -- timestamp without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_timestamp WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperature GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_timestamp; -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperature SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_timestamp'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_timestamp', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 00:00:00'), sensor, avg(value) FROM temperature GROUP BY 1, 2 ORDER BY 1, 2; -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_timestamp ORDER BY time, sensor; ---- -- Check bucket conversion -- date without custom origin ---- CREATE MATERIALIZED VIEW cagg_temp_ng_1week_date WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('1 week', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Ensure time_bucket and time_bucket_ng create buckets with a different origin SELECT time_bucket('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; -- Test what the CAgg returns SELECT * FROM cagg_temp_ng_1week_date; -- Insert new data into the hypertable. 10 years after the data that was used during the CAgg refresh INSERT INTO temperaturedate SELECT time, sensor_id, sensor_id * sensor_id + 100 FROM generate_series('2020-01-01 0:00:00+0'::timestamptz, '2020-01-01 23:59:59+0','1m') g1(time), generate_series(1, 2, 1) AS g2(sensor_id); -- Migrate and update CAgg CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); CALL refresh_continuous_aggregate('cagg_temp_ng_1week_date', NULL, NULL); -- Get output of the time_bucket_ng SELECT timescaledb_experimental.time_bucket_ng('1 week', time), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; -- Ensure time function with added origin during migration produces the same results SELECT time_bucket('1 week', time, origin=>'2000-01-01 01:00:00+00'), sensor, avg(value) FROM temperaturedate GROUP BY 1, 2 ORDER BY 1, 2; -- Even the CAgg now uses time_bucket, we should see buckets of the same alignment SELECT * FROM cagg_temp_ng_1week_date ORDER BY time, sensor; -- Ensure we error out when the CAgg does not use a deprecated function \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_temp_ng_1week_date'); \set ON_ERROR_STOP 1 ---- -- Test migration as non-owner (should fail) ---- CREATE MATERIALIZED VIEW cagg_tempdate_ng_acl WITH (timescaledb.continuous) AS SELECT timescaledb_experimental.time_bucket_ng('7 days', time) as time, sensor, avg(value) AS avg FROM temperaturedate GROUP BY 1,2 WITH NO DATA; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 CALL _timescaledb_functions.cagg_migrate_to_time_bucket('cagg_tempdate_ng_acl'); \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_multi.sql������������������������������������������������������0000664�0000000�0000000�00000020560�15100345067�0021272�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; SET client_min_messages TO NOTICE; CREATE TABLE continuous_agg_test(timeval integer, col1 integer, col2 integer); select create_hypertable('continuous_agg_test', 'timeval', chunk_time_interval=> 2); CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timeval), 0) FROM continuous_agg_test $$; SELECT set_integer_now_func('continuous_agg_test', 'integer_now_test1'); INSERT INTO continuous_agg_test VALUES (10, - 4, 1), (11, - 3, 5), (12, - 3, 7), (13, - 3, 9), (14,-4, 11), (15, -4, 22), (16, -4, 23); -- TEST for multiple continuous aggs --- invalidations are picked up by both caggs CREATE MATERIALIZED VIEW cagg_1( timed, cnt ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket( 2, timeval), COUNT(col1) FROM continuous_agg_test GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW cagg_2( timed, grp, maxval) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(2, timeval), col1, max(col2) FROM continuous_agg_test GROUP BY 1, 2 WITH NO DATA; select view_name, view_owner, materialization_hypertable_name from timescaledb_information.continuous_aggregates ORDER BY 1; --TEST1: cagg_1 is materialized, not cagg_2. CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; SELECT time_bucket(2, timeval), COUNT(col1) as value FROM continuous_agg_test GROUP BY 1 order by 1; -- check that cagg_2 not materialized select * from cagg_2 order by 1,2; CALL refresh_continuous_aggregate('cagg_2', NULL, NULL); select * from cagg_2 order by 1,2; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; --TEST2: cagg_2 gets invalidations after cagg_1's refresh --will trigger invalidations INSERT INTO continuous_agg_test VALUES (10, -4, 10), (11, - 3, 50), (11, - 3, 70), (10, - 4, 10); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; SELECT time_bucket(2, timeval), COUNT(col1) as value FROM continuous_agg_test GROUP BY 1 order by 1; -- are the invalidations picked up here? select * from cagg_2 order by 1, 2; SELECT time_bucket(2, timeval), col1, max(col2) FROM continuous_agg_test GROUP BY 1, 2 order by 1,2 ; CALL refresh_continuous_aggregate('cagg_2', NULL, NULL); select * from cagg_2 order by 1, 2; --TEST3: invalidations left over by cagg_1 are dropped --trigger another invalidation INSERT INTO continuous_agg_test VALUES (10, -4, 1000); select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; --now drop cagg_1, should still have materialization_invalidation_log DROP MATERIALIZED VIEW cagg_1; select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; --cagg_2 still exists select view_name from timescaledb_information.continuous_aggregates; drop table continuous_agg_test cascade; select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; select view_name from timescaledb_information.continuous_aggregates; --TEST4: invalidations that are copied over by cagg1 are not deleted by cagg2 refresh if -- they do not meet materialization invalidation threshold for cagg2. CREATE TABLE continuous_agg_test(timeval integer, col1 integer, col2 integer); select create_hypertable('continuous_agg_test', 'timeval', chunk_time_interval=> 2); CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timeval), 0) FROM continuous_agg_test $$; SELECT set_integer_now_func('continuous_agg_test', 'integer_now_test1'); INSERT INTO continuous_agg_test VALUES (10, -4, 1), (11, -3, 5), (12, -3, 7), (13, -3, 9), (14, -4, 11), (15, -4, 22), (16, -4, 23); CREATE MATERIALIZED VIEW cagg_1( timed, cnt ) WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket( 2, timeval), COUNT(col1) FROM continuous_agg_test GROUP BY 1 WITH DATA; CREATE MATERIALIZED VIEW cagg_2( timed, maxval) WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket(2, timeval), max(col2) FROM continuous_agg_test GROUP BY 1 WITH NO DATA; --cagg_1 already refreshed on creation select * from cagg_1 order by 1; --partially refresh cagg_2 to 14 to test inserts that won't be seen in --one of the caggs CALL refresh_continuous_aggregate('cagg_2', NULL, 14); select * from cagg_2 order by 1; --this insert will be processed only by cagg_1 and copied over to cagg_2 insert into continuous_agg_test values( 14, -2, 100); CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; CALL refresh_continuous_aggregate('cagg_2', NULL, 14); select * from cagg_2 order by 1; SET ROLE :ROLE_SUPERUSER; select * from _timescaledb_catalog.continuous_aggs_invalidation_threshold order by 1; select * from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log order by 1; SET ROLE :ROLE_DEFAULT_PERM_USER; --this insert will be processed only by cagg_1 and cagg_2 will process the previous --one insert into continuous_agg_test values( 18, -2, 200); CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 order by 1; -- Now make changes visible up to 16 CALL refresh_continuous_aggregate('cagg_2', NULL, 16); select * from cagg_2 order by 1; --TEST5 2 inserts with the same value can be copied over to materialization invalidation log insert into continuous_agg_test values( 18, -2, 100); insert into continuous_agg_test values( 18, -2, 100); select * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log order by 1; CALL refresh_continuous_aggregate('cagg_1', NULL, NULL); select * from cagg_1 where timed = 18 ; --copied over for cagg_2 to process later? select * from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log order by 1; DROP MATERIALIZED VIEW cagg_1; DROP MATERIALIZED VIEW cagg_2; ----TEST7 multiple continuous aggregates with real time aggregates test---- create table foo (a integer, b integer, c integer); select table_name FROM create_hypertable('foo', 'a', chunk_time_interval=> 10); INSERT into foo values( 1 , 10 , 20); INSERT into foo values( 1 , 11 , 20); INSERT into foo values( 1 , 12 , 20); INSERT into foo values( 1 , 13 , 20); INSERT into foo values( 1 , 14 , 20); INSERT into foo values( 5 , 14 , 20); INSERT into foo values( 5 , 15 , 20); INSERT into foo values( 5 , 16 , 20); INSERT into foo values( 20 , 16 , 20); INSERT into foo values( 20 , 26 , 20); INSERT into foo values( 20 , 16 , 20); INSERT into foo values( 21 , 15 , 30); INSERT into foo values( 21 , 15 , 30); INSERT into foo values( 21 , 15 , 30); INSERT into foo values( 45 , 14 , 70); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10, a), count(*) FROM foo GROUP BY time_bucket(10, a) WITH NO DATA; CREATE MATERIALIZED VIEW mat_m2(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), count(*) FROM foo GROUP BY time_bucket(5, a) WITH NO DATA; select view_name, materialized_only from timescaledb_information.continuous_aggregates WHERE view_name::text like 'mat_m%' order by view_name; CALL refresh_continuous_aggregate('mat_m1', NULL, 35); CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); -- the results from the view should match the direct query SELECT * from mat_m1 order by 1; SELECT time_bucket(5, a), count(*) FROM foo GROUP BY time_bucket(5, a) ORDER BY 1; SELECT * from mat_m2 order by 1; SELECT time_bucket(10, a), count(*) FROM foo GROUP BY time_bucket(10, a) ORDER BY 1; ������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_on_cagg.sql����������������������������������������������������0000664�0000000�0000000�00000024340�15100345067�0021535�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Global test variables \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set IS_JOIN FALSE \set INTERVAL_TEST FALSE -- ######################################################## -- ## INTEGER data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION FALSE \set TIME_DIMENSION_DATATYPE INTEGER \set CAGG_NAME_1ST_LEVEL conditions_summary_1_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2_5 \set CAGG_NAME_3TH_LEVEL conditions_summary_3_10 -- -- Run common tests for INTEGER -- \set BUCKET_WIDTH_1ST 'INTEGER \'1\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set BUCKET_WIDTH_3TH 'INTEGER \'10\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- -- Validation test for non-multiple bucket sizes -- \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for equal bucket sizes -- \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for bucket size less than source -- \set BUCKET_WIDTH_1ST 'INTEGER \'4\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- ######################################################## -- ## TIMESTAMP data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMP \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMP -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- -- Validation test for variable bucket on top of fixed bucket -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for non-multiple bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for equal bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for bucket size less than source -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- ######################################################## -- ## TIMESTAMPTZ data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMPTZ -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- -- Validation test for variable bucket on top of fixed bucket -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for non-multiple bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for equal bucket sizes -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for bucket size less than source -- \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validations using time bucket with timezone (ref issue #5126) -- \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set CAGG_NAME_1ST_LEVEL conditions_summary_1_5m \set CAGG_NAME_2TH_LEVEL conditions_summary_2_1h \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'US/Pacific' \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'16 minutes\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Variable bucket size with the same timezones -- \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql --#Bugfix 5734 #1 \set INTERVAL_TEST TRUE \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql \set INTERVAL_TEST FALSE -- -- Variable bucket size with different timezones -- \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql --#Bugfix 5734 #2 \set INTERVAL_TEST TRUE \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql \set INTERVAL_TEST FALSE -- -- TZ bucket on top of non-TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql --#Bugfix 5734 #3 \set INTERVAL_TEST TRUE \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql \set INTERVAL_TEST FALSE -- -- non-TZ bucket on top of TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- test some intuitive intervals that should work but -- were not working due to unix epochs -- validation test for 1 year on top of one day -- validation test for 1 year on top of 1 month -- validation test for 1 year on top of 1 week -- bug report 5231 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 month\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql -- bug report 5277 \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE -- epoch plus cast to int would compute a bucket width of 0 for parent \set BUCKET_WIDTH_1ST 'INTERVAL \'146 ms\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1168 ms\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'9344 ms\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'74752 ms\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'74752 ms\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'598016 ms\'' \ir include/cagg_on_cagg_validations.sql -- test microseconds - should pass \set BUCKET_WIDTH_1ST 'INTERVAL \'146 usec\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1168 usec\'' \ir include/cagg_on_cagg_validations.sql -- test microseconds - SHOULD FAIL \set BUCKET_WIDTH_1ST 'INTERVAL \'146 usec\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1160 usec\'' \ir include/cagg_on_cagg_validations.sql ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_on_cagg_joins.sql����������������������������������������������0000664�0000000�0000000�00000021674�15100345067�0022746�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Global test variables \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set IS_JOIN TRUE \set INTERVAL_TEST FALSE -- ######################################################## -- ## INTEGER data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION FALSE \set TIME_DIMENSION_DATATYPE INTEGER \set CAGG_NAME_1ST_LEVEL conditions_summary_1_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2_5 \set CAGG_NAME_3TH_LEVEL conditions_summary_3_10 -- -- Run common tests for INTEGER -- \set BUCKET_WIDTH_1ST 'INTEGER \'1\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set BUCKET_WIDTH_3TH 'INTEGER \'10\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- Default tests \set ON_ERROR_STOP 0 \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- -- Validation test for non-multiple bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'5\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for equal bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTEGER \'2\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for bucket size less than source -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTEGER \'4\'' \set BUCKET_WIDTH_2TH 'INTEGER \'2\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- ######################################################## -- ## TIMESTAMP data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMP \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly \set IS_JOIN TRUE SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMP -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- Default tests \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- -- Validation test for variable bucket on top of fixed bucket -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for non-multiple bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for equal bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for bucket size less than source -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- ######################################################## -- ## TIMESTAMPTZ data type tests -- ######################################################## -- Current test variables \set IS_TIME_DIMENSION TRUE \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set CAGG_NAME_1ST_LEVEL conditions_summary_1_hourly \set CAGG_NAME_2TH_LEVEL conditions_summary_2_daily \set CAGG_NAME_3TH_LEVEL conditions_summary_3_weekly SET timezone TO 'UTC'; -- -- Run common tests for TIMESTAMPTZ -- \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_3TH 'INTERVAL \'1 week\'' -- Different order of time dimension in raw ht \set ON_ERROR_STOP 0 \set IS_DEFAULT_COLUMN_ORDER FALSE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- Default tests \set ON_ERROR_STOP 0 \set IS_DEFAULT_COLUMN_ORDER TRUE \ir include/cagg_on_cagg_setup.sql \ir include/cagg_on_cagg_common.sql -- -- Validation test for variable bucket on top of fixed bucket -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'60 days\'' \set WARNING_MESSAGE '-- SHOULD ERROR because is not allowed variable-size bucket on top of fixed-size bucket' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for non-multiple bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 hours\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for equal bucket sizes -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE 'SHOULD WORK because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validation test for bucket size less than source -- \set ON_ERROR_STOP 0 \set BUCKET_WIDTH_1ST 'INTERVAL \'2 hours\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD ERROR because new bucket should be greater than previous' \ir include/cagg_on_cagg_validations.sql -- -- Validations using time bucket with timezone (ref issue #5126) -- \set ON_ERROR_STOP 0 \set TIME_DIMENSION_DATATYPE TIMESTAMPTZ \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set CAGG_NAME_1ST_LEVEL conditions_summary_1_5m \set CAGG_NAME_2TH_LEVEL conditions_summary_2_1h \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'US/Pacific' \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 hour\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'5 minutes\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'16 minutes\'' \set WARNING_MESSAGE '-- SHOULD ERROR because non-multiple bucket sizes' \ir include/cagg_on_cagg_validations.sql -- -- Variable bucket size with the same timezones -- \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- -- Variable bucket size with different timezones -- \set BUCKET_TZNAME_1ST 'US/Pacific' \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- -- TZ bucket on top of non-TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST FALSE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH TRUE \set BUCKET_TZNAME_2TH 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- -- non-TZ bucket on top of TZ bucket -- \set IS_TIME_DIMENSION_WITH_TIMEZONE_1ST TRUE \set IS_TIME_DIMENSION_WITH_TIMEZONE_2TH FALSE \set BUCKET_TZNAME_1ST 'UTC' \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \set WARNING_MESSAGE '-- SHOULD WORK' \ir include/cagg_on_cagg_validations.sql -- test some intuitive intervals that should work but -- were not working due to unix epochs -- validation test for 1 year on top of one day -- validation test for 1 year on top of 1 month -- validation test for 1 year on top of 1 week -- bug report 5231 \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'3 month\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 year\'' \ir include/cagg_on_cagg_validations.sql \set BUCKET_WIDTH_1ST 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_2TH 'INTERVAL \'1 month\'' \ir include/cagg_on_cagg_validations.sql ��������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_permissions.sql.in���������������������������������������������0000664�0000000�0000000�00000024726�15100345067�0023130�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, (SELECT relacl FROM pg_class WHERE oid = user_view) AS user_view_perm, relname AS mat_table, (relacl) AS mat_table_perm, direct_view, (SELECT relacl FROM pg_class WHERE oid = direct_view) AS direct_view_perm, partial_view, (SELECT relacl FROM pg_class WHERE oid = partial_view) AS partial_view_perm FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; GRANT SELECT ON cagg_info TO PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_test1'); CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; -- Manually create index on CAgg CREATE INDEX cagg_idx on mat_refresh_test(location); \c :TEST_DBNAME :ROLE_SUPERUSER CREATE USER not_priv; \c :TEST_DBNAME not_priv -- A user with no ownership on the Cagg cannot create index on it. -- This should fail \set ON_ERROR_STOP 0 CREATE INDEX cagg_idx on mat_refresh_test(humidity); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER DROP USER not_priv; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT add_continuous_aggregate_policy('mat_refresh_test', NULL, -200::integer, '12 h'::interval); insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate(' mat_refresh_test', NULL, NULL); SELECT id as cagg_job_id FROM _timescaledb_config.bgw_job order by id desc limit 1 \gset SELECT format('%I.%I', materialization_hypertable_schema, materialization_hypertable_name ) as materialization_hypertable FROM timescaledb_information.continuous_aggregates WHERE view_name = 'mat_refresh_test' \gset SELECT mat_hypertable_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_refresh_test' \gset SELECT schema_name as mat_chunk_schema, table_name as mat_chunk_table FROM _timescaledb_catalog.chunk WHERE hypertable_id = :mat_hypertable_id ORDER BY id desc LIMIT 1 \gset CREATE TABLE conditions_for_perm_check ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check $$; SELECT set_integer_now_func('conditions_for_perm_check', 'integer_now_test2'); CREATE TABLE conditions_for_perm_check_w_grant ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable('conditions_for_perm_check_w_grant', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions_for_perm_check_w_grant $$; SELECT set_integer_now_func('conditions_for_perm_check_w_grant', 'integer_now_test3'); GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; insert into conditions_for_perm_check_w_grant select generate_series(0, 30, 10), 'POR', 55, 75, 40, 70, NULL; --need both select and trigger permissions to create a materialized view on top of it. GRANT SELECT, TRIGGER ON conditions_for_perm_check_w_grant TO public; \c :TEST_DBNAME :ROLE_SUPERUSER create schema custom_schema; CREATE FUNCTION get_constant() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS $BODY$ SELECT 10; $BODY$; REVOKE EXECUTE ON FUNCTION get_constant() FROM PUBLIC; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:cagg_job_id, max_runtime => NULL); --make sure that commands fail ALTER MATERIALIZED VIEW mat_refresh_test SET(timescaledb.materialized_only = true); DROP MATERIALIZED VIEW mat_refresh_test; CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); SELECT * FROM mat_refresh_test; -- Test permissions also when the watermark is not constified and the ACL checks -- in ts_continuous_agg_watermark are executed SET timescaledb.enable_cagg_watermark_constify = OFF; SELECT * FROM mat_refresh_test; RESET timescaledb.enable_cagg_watermark_constify; SELECT * FROM :materialization_hypertable; SELECT * FROM :"mat_chunk_schema".:"mat_chunk_table"; --cannot create a mat view without select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check group by time_bucket(100, timec), location WITH NO DATA; --cannot create mat view in a schema without create privileges CREATE MATERIALIZED VIEW custom_schema.mat_perm_view_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; --cannot use a function without EXECUTE privileges --you can create a VIEW but cannot refresh it CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity), get_constant() from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; --this should fail CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); DROP MATERIALIZED VIEW mat_perm_view_test; \set ON_ERROR_STOP 1 --can create a mat view on something with select and trigger grants CREATE MATERIALIZED VIEW mat_perm_view_test WITH ( timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions_for_perm_check_w_grant group by time_bucket(100, timec), location WITH NO DATA; CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); SELECT * FROM mat_perm_view_test; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --revoke select permissions from role with mat view REVOKE SELECT ON conditions_for_perm_check_w_grant FROM public; insert into conditions_for_perm_check_w_grant select generate_series(100, 130, 10), 'POR', 65, 85, 30, 90, NULL; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 --refresh mat view should now fail due to lack of permissions CALL refresh_continuous_aggregate('mat_perm_view_test', NULL, NULL); \set ON_ERROR_STOP 1 --but the old data will still be there SELECT * FROM mat_perm_view_test; \set VERBOSITY default -- Test that grants and revokes are propagated to the implementation -- objects, that is, the user view, the partial view, the direct view, -- and the materialization table. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('devices', 'time'); GRANT SELECT, TRIGGER ON devices TO :ROLE_DEFAULT_PERM_USER_2; INSERT INTO devices SELECT time, (random() * 30)::int, random() * 80 FROM generate_series('2020-02-01 00:00:00'::timestamptz, '2020-03-01 00:00:00', '1 hour') AS time; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CREATE MATERIALIZED VIEW devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM devices GROUP BY bucket, device WITH NO DATA; \x on SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; GRANT ALL ON devices_summary TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; REVOKE SELECT, UPDATE ON devices_summary FROM :ROLE_DEFAULT_PERM_USER; SELECT * FROM cagg_info WHERE user_view::text = 'devices_summary'; \x off -- Check for default privilege permissions get propagated to the materialization hypertable \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA test_default_privileges; GRANT USAGE ON SCHEMA "test_default_privileges" TO :ROLE_DEFAULT_PERM_USER; ALTER DEFAULT PRIVILEGES IN SCHEMA "test_default_privileges" GRANT SELECT ON TABLES TO :ROLE_DEFAULT_PERM_USER; CREATE TABLE test_default_privileges.devices ( time TIMESTAMPTZ NOT NULL, device INT, temp DOUBLE PRECISION NULL, PRIMARY KEY(time, device) ); SELECT create_hypertable('test_default_privileges.devices', 'time'); CREATE MATERIALIZED VIEW test_default_privileges.devices_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', time) AS bucket, device, MAX(temp) FROM test_default_privileges.devices GROUP BY bucket, device WITH NO DATA; -- check if user view perms have been propagated to the mat-ht SELECT user_view_perm IS NOT DISTINCT FROM mat_table_perm FROM cagg_info WHERE user_view = 'test_default_privileges.devices_summary'::regclass; ������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_planning.sql���������������������������������������������������0000664�0000000�0000000�00000011242�15100345067�0021743�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TEST_BASE_NAME cagg_planning SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_baseline.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_BASELINE", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED" \gset SELECT format('\! diff -u --label Baseline --label Optimized %s %s', :'TEST_RESULTS_BASELINE', :'TEST_RESULTS_OPTIMIZED') AS "DIFF_CMD" \gset SET timezone TO PST8PDT; CREATE TABLE metrics(time timestamptz, device text, metric text, value float); SELECT create_hypertable('metrics', 'time'); -- insert initial data to be in materialized part of cagg INSERT INTO metrics SELECT '2020-01-01'::timestamptz + format('%s day', i::text)::interval, 'device 1', 'metric 1', i FROM generate_series(0, 9, 1) g(i); -- cagg with grouping only by time column CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), avg(value) FROM metrics GROUP BY 1; CREATE MATERIALIZED VIEW cagg1_ordered_asc WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), avg(value) FROM metrics GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg1_ordered_desc WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), avg(value) FROM metrics GROUP BY 1 ORDER BY 1 DESC; -- cagg with grouping by device and time column CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT device, time_bucket('3 day', time), avg(value) FROM metrics GROUP BY device, 2; -- cagg with first/last CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=false) AS SELECT time_bucket('3 day', time), first(value, time), last(value, time), array_agg(value ORDER BY value) AS array_asc, array_agg(value ORDER BY value DESC) AS array_desc FROM metrics GROUP BY device, 1; -- insert more data to be in real-time part of cagg INSERT INTO metrics SELECT '2020-01-01'::timestamptz + format('%s day', i::text)::interval, 'device 1', 'metric 1', i FROM generate_series(10, 16, 1) g(i); \ir :TEST_QUERY_NAME \set ECHO none \set PREFIX '' SET timescaledb.enable_cagg_sort_pushdown TO off; \o :TEST_RESULTS_BASELINE \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_cagg_sort_pushdown; \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o \set ECHO all -- diff baseline and optimized results :DIFF_CMD --dump & restore \c postgres :ROLE_SUPERUSER \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; SELECT timescaledb_pre_restore(); \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql SELECT timescaledb_post_restore(); SELECT _timescaledb_functions.stop_background_workers(); -- Repeat tests after restore \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TEST_BASE_NAME cagg_planning SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_baseline_after_restore.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_BASELINE_AFTER_RESTORE", format('%s/results/%s_results_optimized_after_restore.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED_AFTER_RESTORE" \gset SELECT format('\! diff -u --label Baseline --label Optimized %s %s', :'TEST_RESULTS_BASELINE_AFTER_RESTORE', :'TEST_RESULTS_OPTIMIZED_AFTER_RESTORE') AS "DIFF_CMD" \gset SET timezone TO PST8PDT; \ir :TEST_QUERY_NAME \set ECHO none \set PREFIX '' SET timescaledb.enable_cagg_sort_pushdown TO off; \o :TEST_RESULTS_BASELINE_AFTER_RESTORE \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_cagg_sort_pushdown; \o :TEST_RESULTS_OPTIMIZED_AFTER_RESTORE \ir :TEST_QUERY_NAME \o \set ECHO all -- diff baseline and optimized results :DIFF_CMD -- diff baseline before and after restore SELECT format('\! diff -u --label Baseline --label Baseline_After_Restore %s %s', :'TEST_RESULTS_BASELINE', :'TEST_RESULTS_BASELINE_AFTER_RESTORE') AS "DIFF_CMD" \gset :DIFF_CMD -- diff optimized before and after restore SELECT format('\! diff -u --label Optimized --label Optimized_After_Restore %s %s', :'TEST_RESULTS_OPTIMIZED', :'TEST_RESULTS_OPTIMIZED_AFTER_RESTORE') AS "DIFF_CMD" \gset :DIFF_CMD ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_plugin.sql�����������������������������������������������������0000664�0000000�0000000�00000022370�15100345067�0021437�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Test the invalidation plugin and make sure it can return the data -- we expect. We do that by creating a hypertable and then registering -- a logical decoding slot on it and using the plugin to get the -- changes. SET timezone TO UTC; SET datestyle TO ISO; SELECT setseed(1); CREATE FUNCTION get_invalidations(slot text, hypertable name, attr name) RETURNS TABLE (hypertable_relid regclass, lowest_modified_value timestamptz, greatest_modified_value timestamptz) AS $$ WITH changes AS ( SELECT (_timescaledb_functions.cagg_parse_invalidation_record(data)).* FROM pg_logical_slot_get_binary_changes(slot, NULL, NULL, hypertable, attr)) SELECT hypertable_relid, _timescaledb_functions.to_timestamp(lowest_modified_value), _timescaledb_functions.to_timestamp(greatest_modified_value) FROM changes ORDER BY 1,2,3; $$ LANGUAGE sql; select _timescaledb_functions.invalidation_plugin_name() as plugin_name \gset -- Creating a table with a primary key since we need a replica -- identity to use logical decoding. CREATE TABLE conditions ( recorded_at timestamptz NOT NULL, device_id int, temp float, primary key (recorded_at, device_id) ); SELECT create_hypertable('conditions', 'recorded_at'); SELECT setseed(1.0); INSERT INTO conditions SELECT recorded_at, (random()*3 + 1)::int, random()*80 - 40 FROM generate_series('2025-02-01'::timestamptz, '2025-03-31'::timestamptz, '1 minute'::interval) AS recorded_at; select from pg_create_logical_replication_slot('my_slot', :'plugin_name', false, true); -- Generate a few entries in one go. This caused some problems -- initially, so check this first. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 98, 37.0); INSERT INTO conditions VALUES ('2020-05-02 12:34:56Z', 98, 37.0), ('2020-05-02 13:45:00Z', 98, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Generate a single invalidation line and check how that appears. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 99, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); INSERT INTO conditions VALUES ('2020-05-02 12:34:56Z', 99, 37.0), ('2020-05-02 13:45:00Z', 99, 37.0); -- Check that we got the invalidations SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- This should generate an invalidation including the full range since -- it is inside a transaction. INSERT INTO conditions SELECT recorded_at, 99, random()*80 - 40 FROM generate_series('2025-02-01'::timestamptz, '2025-03-31'::timestamptz, '1 minute'::interval) AS recorded_at; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); UPDATE conditions SET temp = 0.0 WHERE device_id = 99; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); DELETE FROM conditions WHERE device_id = 99; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Test that we can do multiple changes (in different transactions) in -- a suite and get the changes for that using the plugin. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 99, 37.0); INSERT INTO conditions VALUES ('2020-05-02 12:34:56Z', 99, 37.0), ('2020-05-02 13:45:00Z', 99, 37.0); INSERT INTO conditions SELECT recorded_at, 99, random()*80 - 40 FROM generate_series('2025-02-01'::timestamptz, '2025-03-31'::timestamptz, '1 minute'::interval) AS recorded_at; UPDATE conditions SET temp = 0.0 WHERE device_id = 99; DELETE FROM conditions WHERE device_id = 99; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Test that we can do multiple changes in a single transaction get -- the changes for that using the plugin. START TRANSACTION; INSERT INTO conditions VALUES ('2020-06-01 12:34:56Z', 101, 37.0); INSERT INTO conditions VALUES ('2020-06-02 12:34:56Z', 101, 37.0), ('2020-06-02 13:45:00Z', 101, 37.0); INSERT INTO conditions SELECT recorded_at, 101, random()*80 - 40 FROM generate_series('2020-06-10'::timestamptz, '2020-07-31'::timestamptz, '1 minute'::interval) AS recorded_at; UPDATE conditions SET temp = 0.0 WHERE device_id = 101; DELETE FROM conditions WHERE device_id = 101; COMMIT; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Insert some tuples, remove a column, and insert some more data, all -- inside a transaction, and check that it behaves sane even when the -- tuple format changes within a transaction. START TRANSACTION; INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 102, 37.0); ALTER TABLE conditions DROP COLUMN temp; INSERT INTO conditions VALUES ('2020-05-01 12:34:57Z', 102); ALTER TABLE conditions ADD COLUMN temp numeric; INSERT INTO conditions VALUES ('2020-05-01 12:34:58Z', 102, 38.0); COMMIT; SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Test to insert some changes and then drop the table to check that -- it behaves sane. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 103, 37.0); DROP TABLE conditions; \set ON_ERROR_STOP 0 SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); \set ON_ERROR_STOP 1 -- Create the hypertable again with the same name and see that we do -- not read bad data. CREATE TABLE conditions ( recorded_at timestamptz NOT NULL, device_id int, temp float, primary key (recorded_at, device_id) ); SELECT create_hypertable('conditions', 'recorded_at'); -- New hypertable: we should not see the ones that we inserted before -- dropping the old version of the hypertable. SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Insert some data so that we have some entries. INSERT INTO conditions VALUES ('2020-05-01 12:34:56Z', 104, 37.0); -- Check that trying to read a non-existing attribute generates an -- error. \set ON_ERROR_STOP 0 SELECT * FROM get_invalidations('my_slot', 'conditions', 'does_not_exist'); \set ON_ERROR_STOP 1 -- We should still be able to get invalidations if we provide a good -- attribute after this. (This turned out to be a problem during -- testing.) SELECT * FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Check that adding a lot of invalidations as separate transactions -- in one go reads them all from the WAL. DO $$ DECLARE rec RECORD; BEGIN FOR rec IN SELECT t, d FROM generate_series('2020-05-10'::timestamptz, '2020-05-11'::timestamptz, '1 minute'::interval) t, generate_series(1,10) d LOOP INSERT INTO conditions VALUES (rec.t, rec.d, 100.0 * random()); COMMIT; END LOOP; END $$; SELECT count(*) FROM get_invalidations('my_slot', 'conditions', 'recorded_at'); -- Test using a table without a primary key but with an index that can -- be used as replica identity. CREATE TABLE conditions_index ( captured_at TIMESTAMPTZ NOT NULL, device_id INT NOT NULL, temp FLOAT, UNIQUE (captured_at, device_id) ); ALTER TABLE conditions_index REPLICA IDENTITY USING INDEX conditions_index_captured_at_device_id_key; SELECT create_hypertable('conditions_index', 'captured_at'); INSERT INTO conditions_index VALUES ('2020-05-02 12:34:56Z', 42, 37.0), ('2020-05-02 13:45:00Z', 42, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions_index', 'captured_at'); -- Test using a table without a primary key but with a replica -- identity using full rows. CREATE TABLE conditions_full ( recorded_at TIMESTAMPTZ NOT NULL, device_id INT NOT NULL, temp FLOAT ); ALTER TABLE conditions_full REPLICA IDENTITY FULL; SELECT create_hypertable('conditions_full', 'recorded_at'); INSERT INTO conditions_full VALUES ('2020-05-02 12:34:56Z', 42, 37.0), ('2020-05-02 13:45:00Z', 42, 37.0); SELECT * FROM get_invalidations('my_slot', 'conditions_full', 'recorded_at'); -- Test getting invalidations for multiple hypertables in one go, to -- make sure that the plugin works with multiple tables as well. -- We add more invalidations to more tables than we actually fetch, -- because that should work too. INSERT INTO conditions_full VALUES ('2020-05-03 11:34:00Z', 43, 37.0), ('2020-05-03 12:45:00Z', 43, 37.0); INSERT INTO conditions_index VALUES ('2020-05-03 12:00:00Z', 43, 37.0), ('2020-05-03 13:00:00Z', 43, 37.0); INSERT INTO conditions VALUES ('2020-05-03 15:00:01Z', 43, 37.0); -- Capture only two of the three tables above, also with different -- attribute names. WITH changes AS ( SELECT (_timescaledb_functions.cagg_parse_invalidation_record(data)).* FROM pg_logical_slot_get_binary_changes('my_slot', NULL, NULL, 'conditions_full', 'recorded_at', 'conditions_index', 'captured_at')) SELECT hypertable_relid, _timescaledb_functions.to_timestamp(lowest_modified_value), _timescaledb_functions.to_timestamp(greatest_modified_value) FROM changes ORDER BY hypertable_relid; SELECT * FROM pg_drop_replication_slot('my_slot'); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_policy.sql�����������������������������������������������������0000664�0000000�0000000�00000101035�15100345067�0021434�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test add and remove refresh policy apis SET ROLE :ROLE_DEFAULT_PERM_USER; --TEST1 --- --basic test with count CREATE TABLE int_tab (a integer, b integer, c integer); SELECT table_name FROM create_hypertable('int_tab', 'a', chunk_time_interval=> 10); INSERT INTO int_tab VALUES( 3 , 16 , 20); INSERT INTO int_tab VALUES( 1 , 10 , 20); INSERT INTO int_tab VALUES( 1 , 11 , 20); INSERT INTO int_tab VALUES( 1 , 12 , 20); INSERT INTO int_tab VALUES( 1 , 13 , 20); INSERT INTO int_tab VALUES( 1 , 14 , 20); INSERT INTO int_tab VALUES( 2 , 14 , 20); INSERT INTO int_tab VALUES( 2 , 15 , 20); INSERT INTO int_tab VALUES( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_int_tab() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM int_tab $$; SELECT set_integer_now_func('int_tab', 'integer_now_int_tab'); CREATE MATERIALIZED VIEW mat_m1( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT a, count(b) FROM int_tab GROUP BY time_bucket(1, a), a WITH NO DATA; \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM _timescaledb_config.bgw_job; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for integer type buckets ALTER materialized view mat_m1 set (timescaledb.compress = true); -- No policy is added if one errors out SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 1, refresh_end_offset => 10, compress_after => 11, drop_after => 20); SELECT timescaledb_experimental.show_policies('mat_m1'); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 10, refresh_end_offset => 1, compress_after => 11, drop_after => 20); SELECT timescaledb_experimental.show_policies('mat_m1'); --Test coverage: new view for policies on CAggs SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; --Test coverage: new view for policies only shows the policies for CAggs SELECT add_retention_policy('int_tab', 20); SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; SELECT remove_retention_policy('int_tab'); -- Test for duplicated policies (issue #5492) CREATE MATERIALIZED VIEW mat_m2( a, sumb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT a, sum(b) FROM int_tab GROUP BY time_bucket(1, a), a WITH NO DATA; -- add refresh policy SELECT timescaledb_experimental.add_policies('mat_m2', refresh_start_offset => 10, refresh_end_offset => 1); SELECT timescaledb_experimental.show_policies('mat_m2'); -- check for only one refresh policy for each cagg SELECT * FROM timescaledb_experimental.policies WHERE proc_name ~ 'refresh' ORDER BY relation_name, proc_name; SELECT timescaledb_experimental.remove_all_policies('mat_m2'); DROP MATERIALIZED VIEW mat_m2; -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_m1', refresh_start_offset => 11, compress_after=>13, drop_after => 25); SELECT timescaledb_experimental.show_policies('mat_m1'); -- Remove one or more policy SELECT timescaledb_experimental.remove_policies('mat_m1', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); SELECT timescaledb_experimental.show_policies('mat_m1'); -- Add one policy SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 10, refresh_end_offset => 1); SELECT timescaledb_experimental.show_policies('mat_m1'); -- Remove all policies SELECT timescaledb_experimental.remove_policies('mat_m1', false, 'policy_refresh_continuous_aggregate', 'policy_retention'); SELECT timescaledb_experimental.show_policies('mat_m1'); --Cross policy checks --refresh and compression policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 12, refresh_end_offset => 1, compress_after=>11); --refresh and retention policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 12, refresh_end_offset => 1, drop_after=>11); --compression and retention policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', compress_after => 10, drop_after => 10); -- Alter non existent policies SELECT timescaledb_experimental.alter_policies('mat_m1', refresh_start_offset => 12, compress_after=>11, drop_after => 15); ALTER materialized view mat_m1 set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('int_tab', '1 day'::interval, 10 , '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::interval, 10 , '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::interval, 10 ); SELECT add_continuous_aggregate_policy('mat_m1', 10, '1 day'::interval, '1 h'::interval); --start_interval < end_interval SELECT add_continuous_aggregate_policy('mat_m1', 5, 10, '1h'::interval); --refresh window less than two buckets SELECT add_continuous_aggregate_policy('mat_m1', 11, 10, '1h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval) as job_id \gset --adding again should warn/error SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>false); SELECT add_continuous_aggregate_policy('mat_m1', 20, 15, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>true); -- modify config and try to add, should error out SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; SELECT hypertable_id as mat_id FROM _timescaledb_config.bgw_job where id = :job_id \gset \set VERBOSITY terse \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; UPDATE _timescaledb_config.bgw_job SET config = jsonb_build_object('mat_hypertable_id', :mat_id) WHERE id = :job_id; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>true); SELECT remove_continuous_aggregate_policy('int_tab'); SELECT remove_continuous_aggregate_policy('mat_m1'); -- add with NULL offset, readd with NULL offset SELECT add_continuous_aggregate_policy('mat_m1', 20, NULL, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', 20, NULL, '1h'::interval, if_not_exists=>true); -- same param values, so we get a NOTICE SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '1h'::interval, if_not_exists=>true); -- different values, so we get a WARNING SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 20, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 20, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '1h'::interval, if_not_exists=>true); SELECT remove_continuous_aggregate_policy('mat_m1'); --this one will fail SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT remove_continuous_aggregate_policy('mat_m1', if_not_exists=>true); --now try to add a policy as a different user than the one that created the cagg --should fail SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval) as job_id ; \set VERBOSITY terse \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW mat_m1; --- code coverage tests : add policy for timestamp and date based table --- CREATE TABLE continuous_agg_max_mat_date(time DATE); SELECT create_hypertable('continuous_agg_max_mat_date', 'time'); CREATE MATERIALIZED VIEW max_mat_view_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) FROM continuous_agg_max_mat_date GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for timestamp type buckets ALTER materialized view max_mat_view_date set (timescaledb.compress = true); -- Only works for cagg SELECT timescaledb_experimental.add_policies('continuous_agg_max_mat_date', refresh_start_offset => '1 day'::interval, refresh_end_offset => '2 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.show_policies('continuous_agg_max_mat_date'); SELECT timescaledb_experimental.alter_policies('continuous_agg_max_mat_date', compress_after=>'16 days'::interval); SELECT timescaledb_experimental.remove_policies('continuous_agg_max_mat_date', false, 'policy_refresh_continuous_aggregate'); -- No policy is added if one errors out SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '1 day'::interval, refresh_end_offset => '2 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Create open ended refresh_policy SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => '2 day'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => '2 day'::interval, refresh_start_offset=>'-infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '2 day'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '2 day'::interval, refresh_end_offset=>'infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); -- Open ended at both sides, for code coverage SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => 'infinity', refresh_start_offset => '-infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '15 days'::interval, refresh_end_offset => '1 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Alter policies SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset => '16 days'::interval, compress_after=>'26 days'::interval, drop_after => '40 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); --Alter refresh_policy to make it open ended SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_retention', 'policy_compression'); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'-infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_end_offset =>'infinity', refresh_start_offset =>'5 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); --Cross policy checks -- Refresh and compression policies overlap SELECT timescaledb_experimental.add_policies('max_mat_view_date', compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', compress_after=> '4 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Refresh and retention policies overlap SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'5 days'::interval, drop_after=> '4 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); --Do not allow refreshed data to be deleted SELECT add_retention_policy('continuous_agg_max_mat_date', '25 days'::interval); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'25 days'::interval); SELECT remove_retention_policy('continuous_agg_max_mat_date'); -- Remove one or more policy -- Code coverage: no policy names provided SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false); -- Code coverage: incorrect name of policy SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'refresh_policy'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Add one policy SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '15 day'::interval, refresh_end_offset => '1 day'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Remove all policies SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; SELECT timescaledb_experimental.remove_all_policies(NULL); -- should fail SELECT timescaledb_experimental.remove_all_policies('continuous_agg_max_mat_date'); -- should fail SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', false); SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', false); -- should fail CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS RECORD LANGUAGE SQL AS $$ VALUES($1, $2, 'custom_func'); $$; -- inject custom job SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS job_id \gset SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id, 'max_mat_view_date'::regclass); SELECT * FROM timescaledb_information.jobs WHERE job_id != 1 ORDER BY 1; SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', true); -- ignore custom job SELECT delete_job(:job_id); DROP FUNCTION custom_func; SELECT timescaledb_experimental.show_policies('max_mat_view_date'); ALTER materialized view max_mat_view_date set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('max_mat_view_date', '2 days', 10, '1 day'::interval); --start_interval < end_interval SELECT add_continuous_aggregate_policy('max_mat_view_date', '1 day'::interval, '2 days'::interval , '1 day'::interval) ; --interval less than two buckets SELECT add_continuous_aggregate_policy('max_mat_view_date', '7 days', '1 day', '1 day'::interval); SELECT add_continuous_aggregate_policy('max_mat_view_date', '14 days', '1 day', '1 day'::interval); SELECT add_continuous_aggregate_policy('max_mat_view_date', '13 days', '-10 hours', '1 day'::interval); \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Negative start offset gives two bucket window: SELECT add_continuous_aggregate_policy('max_mat_view_date', '13 days', '-1 day', '1 day'::interval); SELECT remove_continuous_aggregate_policy('max_mat_view_date'); -- Both offsets NULL: SELECT add_continuous_aggregate_policy('max_mat_view_date', NULL, NULL, '1 day'::interval); SELECT remove_continuous_aggregate_policy('max_mat_view_date'); SELECT add_continuous_aggregate_policy('max_mat_view_date', '15 days', '1 day', '1 day'::interval) as job_id \gset SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; INSERT INTO continuous_agg_max_mat_date SELECT generate_series('2019-09-01'::date, '2019-09-10'::date, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; CALL run_job(:job_id); RESET client_min_messages; DROP MATERIALIZED VIEW max_mat_view_date; CREATE TABLE continuous_agg_timestamp(time TIMESTAMP); SELECT create_hypertable('continuous_agg_timestamp', 'time'); CREATE MATERIALIZED VIEW max_mat_view_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) FROM continuous_agg_timestamp GROUP BY 1 WITH NO DATA; --the start offset overflows the smallest time value, but is capped at --the min value SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '1000000 years', '1 day' , '1 h'::interval); SELECT remove_continuous_aggregate_policy('max_mat_view_timestamp'); \set ON_ERROR_STOP 0 \set VERBOSITY default --start and end offset capped at the lowest time value, which means --zero size window SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '1000000 years', '900000 years' , '1 h'::interval); SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '301 days', '10 months' , '1 h'::interval); \set VERBOSITY terse \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 days', '1 h'::interval , '1 h'::interval) as job_id \gset --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; CALL run_job(:job_id); RESET client_min_messages ; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; UPDATE _timescaledb_config.bgw_job SET config = jsonb_build_object('mat_hypertable_id', :mat_id) WHERE id = :job_id; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 day', '1 day', '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', 'xyz', '1 day', '1h'::interval, if_not_exists=>true); \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW max_mat_view_timestamp; --smallint table CREATE TABLE smallint_tab (a smallint); SELECT table_name FROM create_hypertable('smallint_tab', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_smallint_tab() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a)::smallint, 0::smallint) FROM smallint_tab ; $$; SELECT set_integer_now_func('smallint_tab', 'integer_now_smallint_tab'); CREATE MATERIALIZED VIEW mat_smallint( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT time_bucket( SMALLINT '1', a) , count(*) FROM smallint_tab GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for smallint type buckets ALTER materialized view mat_smallint set (timescaledb.compress = true); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_smallint', refresh_start_offset => 10::smallint, refresh_end_offset => 1::smallint, compress_after => 11::smallint, drop_after => 20::smallint); SELECT timescaledb_experimental.show_policies('mat_smallint'); -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_smallint', refresh_start_offset => 11::smallint, compress_after=>13::smallint, drop_after => 25::smallint); SELECT timescaledb_experimental.show_policies('mat_smallint'); SELECT timescaledb_experimental.remove_all_policies('mat_smallint', false); ALTER materialized view mat_smallint set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('mat_smallint', 15, 0 , '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_smallint', 98898::smallint , 0::smallint, '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_smallint', 5::smallint, 10::smallint , '1 h'::interval) as job_id \gset \set VERBOSITY terse \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('mat_smallint', 15::smallint, 0::smallint , '1 h'::interval) as job_id \gset INSERT INTO smallint_tab VALUES(5); INSERT INTO smallint_tab VALUES(10); INSERT INTO smallint_tab VALUES(20); CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; --remove all the data-- TRUNCATE table smallint_tab; CALL refresh_continuous_aggregate('mat_smallint', NULL, NULL); SELECT * FROM mat_smallint ORDER BY 1; -- Case 1: overflow by subtracting from PG_INT16_MIN --overflow start_interval, end_interval [-32768, -32768) SELECT remove_continuous_aggregate_policy('mat_smallint'); INSERT INTO smallint_tab VALUES( -32768 ); SELECT integer_now_smallint_tab(); SELECT add_continuous_aggregate_policy('mat_smallint', 10::smallint, 5::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); \set ON_ERROR_STOP 1 SELECT * FROM mat_smallint ORDER BY 1; -- overflow start_interval. now this runs as range is capped [-32768, -32765) INSERT INTO smallint_tab VALUES( -32760 ); SELECT maxval, maxval - 10, maxval -5 FROM integer_now_smallint_tab() as maxval; CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; --remove all the data-- TRUNCATE table smallint_tab; CALL refresh_continuous_aggregate('mat_smallint', NULL, NULL); SELECT * FROM mat_smallint ORDER BY 1; -- Case 2: overflow by subtracting from PG_INT16_MAX --overflow start and end . will fail as range is [32767, 32767] SELECT remove_continuous_aggregate_policy('mat_smallint'); INSERT INTO smallint_tab VALUES( 32766 ); INSERT INTO smallint_tab VALUES( 32767 ); SELECT maxval, maxval - (-1), maxval - (-2) FROM integer_now_smallint_tab() as maxval; SELECT add_continuous_aggregate_policy('mat_smallint', -1::smallint, -3::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); \set ON_ERROR_STOP 1 SELECT * FROM mat_smallint ORDER BY 1; SELECT remove_continuous_aggregate_policy('mat_smallint'); --overflow end . will work range is [32765, 32767) SELECT maxval, maxval - (1), maxval - (-2) FROM integer_now_smallint_tab() as maxval; SELECT add_continuous_aggregate_policy('mat_smallint', 1::smallint, -3::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; -- tests for interval argument conversions -- \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_smallint', 15, 10, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_smallint', '15', 10, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_smallint', '15', '10', '1h'::interval, if_not_exists=>true); \set ON_ERROR_STOP 1 --bigint table CREATE TABLE bigint_tab (a bigint); SELECT table_name FROM create_hypertable('bigint_tab', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_bigint_tab() returns bigint LANGUAGE SQL STABLE as $$ SELECT 20::bigint $$; SELECT set_integer_now_func('bigint_tab', 'integer_now_bigint_tab'); CREATE MATERIALIZED VIEW mat_bigint( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT time_bucket( BIGINT '1', a) , count(*) FROM bigint_tab GROUP BY 1 WITH NO DATA; -- Test 1 step policy for bigint type buckets ALTER materialized view mat_bigint set (timescaledb.compress = true); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_bigint', refresh_start_offset => 10::bigint, refresh_end_offset => 1::bigint, compress_after => 11::bigint, drop_after => 20::bigint); SELECT timescaledb_experimental.show_policies('mat_bigint'); -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_bigint', refresh_start_offset => 11::bigint, compress_after=>13::bigint, drop_after => 25::bigint); SELECT timescaledb_experimental.show_policies('mat_bigint'); SELECT timescaledb_experimental.remove_all_policies('mat_bigint', false); ALTER materialized view mat_bigint set (timescaledb.compress = false); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_bigint', 5::bigint, 10::bigint , '1 h'::interval) ; \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('mat_bigint', 15::bigint, 0::bigint , '1 h'::interval) as job_mid \gset INSERT INTO bigint_tab VALUES(5); INSERT INTO bigint_tab VALUES(10); INSERT INTO bigint_tab VALUES(20); CALL run_job(:job_mid); SELECT * FROM mat_bigint ORDER BY 1; -- test NULL for end SELECT remove_continuous_aggregate_policy('mat_bigint'); SELECT add_continuous_aggregate_policy('mat_bigint', 1::smallint, NULL , '1 h'::interval) as job_id \gset INSERT INTO bigint_tab VALUES(500); CALL run_job(:job_id); SELECT * FROM mat_bigint WHERE a>100 ORDER BY 1; ALTER MATERIALIZED VIEW mat_bigint SET (timescaledb.compress); ALTER MATERIALIZED VIEW mat_smallint SET (timescaledb.compress); -- With immutable compressed chunks, these policies would fail by overlapping the refresh window SELECT add_compression_policy('mat_smallint', -4::smallint); SELECT remove_compression_policy('mat_smallint'); SELECT add_compression_policy('mat_bigint', 0::bigint); SELECT remove_compression_policy('mat_bigint'); -- End previous limitation tests SELECT add_compression_policy('mat_smallint', 5::smallint); SELECT add_compression_policy('mat_bigint', 20::bigint); -- end of coverage tests --TEST continuous aggregate + compression policy on caggs CREATE TABLE metrics ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable('metrics', 'time'); INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-02 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); ALTER TABLE metrics SET ( timescaledb.compress ); SELECT compress_chunk(ch) FROM show_chunks('metrics') ch; CREATE MATERIALIZED VIEW metrics_cagg WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1 day', time) as dayb, device_id, sum(v0), avg(v3) FROM metrics GROUP BY 1, 2 WITH NO DATA; -- this was previously crashing SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, NULL, '1 h'::interval, if_not_exists => true); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, '1 day'::interval, '1 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('metrics_cagg'); SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, '1 day'::interval, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, '1 day'::interval, '1h'::interval, if_not_exists=>true); -- same param values, so we get a NOTICE SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, NULL, '1h'::interval, if_not_exists=>true); -- different values, so we get a WARNING SELECT remove_continuous_aggregate_policy('metrics_cagg'); --can set compression policy only after setting up refresh policy -- SELECT add_compression_policy('metrics_cagg', '1 day'::interval); --can set compression policy only after enabling compression -- SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, '1 day'::interval, '1 h'::interval) as "REFRESH_JOB" \gset SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" ; ALTER MATERIALIZED VIEW metrics_cagg SET (timescaledb.compress); --cannot use compress_created_before with cagg SELECT add_compression_policy('metrics_cagg', compress_created_before => '8 day'::interval) AS "COMP_JOB" ; \set ON_ERROR_STOP 1 SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" ; SELECT remove_compression_policy('metrics_cagg'); SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" \gset --verify that jobs were added for the policies --- SELECT materialization_hypertable_name AS "MAT_TABLE_NAME", view_name AS "VIEW_NAME" FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_cagg' \gset SELECT count(*) FROM timescaledb_information.jobs WHERE hypertable_name = :'VIEW_NAME'; --exec the cagg compression job -- CALL refresh_continuous_aggregate('metrics_cagg', NULL, '2001-02-01 00:00:00+0'); CALL run_job(:COMP_JOB); SELECT count(*), count(*) FILTER ( WHERE is_compressed is TRUE ) FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; --add some new data into metrics_cagg so that cagg policy job has something to do INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT now() - '5 day'::interval, 102, 0, 10, 10, 10, 10; CALL run_job(:REFRESH_JOB); --now we have a new chunk and it is not compressed SELECT count(*), count(*) FILTER ( WHERE is_compressed is TRUE ) FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; --verify that both jobs are dropped when view is dropped DROP MATERIALIZED VIEW metrics_cagg; SELECT count(*) FROM timescaledb_information.jobs WHERE hypertable_name = :'VIEW_NAME'; -- add test case for issue 4252 CREATE TABLE IF NOT EXISTS sensor_data( time TIMESTAMPTZ NOT NULL, sensor_id INTEGER, temperature DOUBLE PRECISION, cpu DOUBLE PRECISION); SELECT create_hypertable('sensor_data','time'); INSERT INTO sensor_data(time, sensor_id, cpu, temperature) SELECT time, sensor_id, extract(dow from time) AS cpu, extract(doy from time) AS temperature FROM generate_series('2022-05-05'::timestamp at time zone 'UTC' - interval '6 weeks', '2022-05-05'::timestamp at time zone 'UTC', interval '5 hours') as g1(time), generate_series(1,1000,1) as g2(sensor_id); CREATE materialized view deals_best_weekly WITH (timescaledb.continuous) AS SELECT time_bucket('7 days', "time") AS bucket, avg(temperature) AS avg_temp, max(cpu) AS max_rating FROM sensor_data GROUP BY bucket WITH NO DATA; CREATE materialized view deals_best_daily WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', "time") AS bucket, avg(temperature) AS avg_temp, max(cpu) AS max_rating FROM sensor_data GROUP BY bucket WITH NO DATA; ALTER materialized view deals_best_weekly set (timescaledb.materialized_only=true); ALTER materialized view deals_best_daily set (timescaledb.materialized_only=true); -- we have data from 6 weeks before to May 5 2022 (Thu) CALL refresh_continuous_aggregate('deals_best_weekly', '2022-04-24', '2022-05-03'); SELECT * FROM deals_best_weekly ORDER BY bucket; CALL refresh_continuous_aggregate('deals_best_daily', '2022-04-20', '2022-05-04'); SELECT * FROM deals_best_daily ORDER BY bucket LIMIT 2; -- expect to get an up-to-date notice CALL refresh_continuous_aggregate('deals_best_weekly', '2022-04-24', '2022-05-05'); SELECT * FROM deals_best_weekly ORDER BY bucket; -- github issue 5907: segfault when creating 1-step policies on cagg -- whose underlying hypertable has a retention policy setup CREATE TABLE t(a integer NOT NULL, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION unix_now() returns int LANGUAGE SQL IMMUTABLE as $$ SELECT extract(epoch from now())::INT $$; SELECT set_integer_now_func('t', 'unix_now'); SELECT add_retention_policy('t', 20); CREATE MATERIALIZED VIEW cagg(a, sumb) WITH (timescaledb.continuous) AS SELECT time_bucket(1, a), sum(b) FROM t GROUP BY time_bucket(1, a); SELECT timescaledb_experimental.add_policies('cagg'); -- Issue #6902 -- Fix timestamp out of range in a refresh policy when setting `end_offset=>NULL` -- for a CAgg with variable sized bucket (i.e: using `time_bucket` with timezone) CREATE TABLE issue_6902 ( ts TIMESTAMPTZ NOT NULL, temperature NUMERIC ) WITH ( timescaledb.hypertable, timescaledb.partition_column='ts', timescaledb.chunk_interval='1 day', timescaledb.compress='off' ); INSERT INTO issue_6902 SELECT t, 1 FROM generate_series(now() - interval '3 hours', now(), interval '1 minute') AS t; CREATE MATERIALIZED VIEW issue_6902_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', ts, 'America/Sao_Paulo') AS bucket, -- using timezone MAX(temperature), MIN(temperature), COUNT(*) FROM issue_6902 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy ( 'issue_6902_by_hour', start_offset => INTERVAL '3 hours', end_offset => NULL, schedule_interval => INTERVAL '12 hour', initial_start => now() + INTERVAL '12 hour' ) AS job_id \gset -- 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; -- run again without any change, remain 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; -- change existing data UPDATE issue_6902 SET temperature = temperature + 1; -- run again without any change, remain 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; -- insert more data INSERT INTO issue_6902 SELECT t, 1 FROM generate_series(now() - interval '3 hours', now(), interval '1 minute') AS t; -- run again without and should have 362 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_policy.sql.orig������������������������������������������������0000664�0000000�0000000�00000101171�15100345067�0022374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test add and remove refresh policy apis SET ROLE :ROLE_DEFAULT_PERM_USER; --TEST1 --- --basic test with count CREATE TABLE int_tab (a integer, b integer, c integer); SELECT table_name FROM create_hypertable('int_tab', 'a', chunk_time_interval=> 10); INSERT INTO int_tab VALUES( 3 , 16 , 20); INSERT INTO int_tab VALUES( 1 , 10 , 20); INSERT INTO int_tab VALUES( 1 , 11 , 20); INSERT INTO int_tab VALUES( 1 , 12 , 20); INSERT INTO int_tab VALUES( 1 , 13 , 20); INSERT INTO int_tab VALUES( 1 , 14 , 20); INSERT INTO int_tab VALUES( 2 , 14 , 20); INSERT INTO int_tab VALUES( 2 , 15 , 20); INSERT INTO int_tab VALUES( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_int_tab() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM int_tab $$; SELECT set_integer_now_func('int_tab', 'integer_now_int_tab'); CREATE MATERIALIZED VIEW mat_m1( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT a, count(b) FROM int_tab GROUP BY time_bucket(1, a), a WITH NO DATA; \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM _timescaledb_config.bgw_job; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for integer type buckets ALTER materialized view mat_m1 set (timescaledb.compress = true); -- No policy is added if one errors out SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 1, refresh_end_offset => 10, compress_after => 11, drop_after => 20); SELECT timescaledb_experimental.show_policies('mat_m1'); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 10, refresh_end_offset => 1, compress_after => 11, drop_after => 20); SELECT timescaledb_experimental.show_policies('mat_m1'); --Test coverage: new view for policies on CAggs SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; --Test coverage: new view for policies only shows the policies for CAggs SELECT add_retention_policy('int_tab', 20); SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; SELECT remove_retention_policy('int_tab'); -- Test for duplicated policies (issue #5492) CREATE MATERIALIZED VIEW mat_m2( a, sumb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT a, sum(b) FROM int_tab GROUP BY time_bucket(1, a), a WITH NO DATA; -- add refresh policy SELECT timescaledb_experimental.add_policies('mat_m2', refresh_start_offset => 10, refresh_end_offset => 1); SELECT timescaledb_experimental.show_policies('mat_m2'); -- check for only one refresh policy for each cagg SELECT * FROM timescaledb_experimental.policies WHERE proc_name ~ 'refresh' ORDER BY relation_name, proc_name; SELECT timescaledb_experimental.remove_all_policies('mat_m2'); DROP MATERIALIZED VIEW mat_m2; -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_m1', refresh_start_offset => 11, compress_after=>13, drop_after => 25); SELECT timescaledb_experimental.show_policies('mat_m1'); -- Remove one or more policy SELECT timescaledb_experimental.remove_policies('mat_m1', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); SELECT timescaledb_experimental.show_policies('mat_m1'); -- Add one policy SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 10, refresh_end_offset => 1); SELECT timescaledb_experimental.show_policies('mat_m1'); -- Remove all policies SELECT timescaledb_experimental.remove_policies('mat_m1', false, 'policy_refresh_continuous_aggregate', 'policy_retention'); SELECT timescaledb_experimental.show_policies('mat_m1'); --Cross policy checks --refresh and compression policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 12, refresh_end_offset => 1, compress_after=>11); --refresh and retention policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', refresh_start_offset => 12, refresh_end_offset => 1, drop_after=>11); --compression and retention policy overlap SELECT timescaledb_experimental.add_policies('mat_m1', compress_after => 10, drop_after => 10); -- Alter non existent policies SELECT timescaledb_experimental.alter_policies('mat_m1', refresh_start_offset => 12, compress_after=>11, drop_after => 15); ALTER materialized view mat_m1 set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('int_tab', '1 day'::interval, 10 , '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::interval, 10 , '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 day'::interval, 10 ); SELECT add_continuous_aggregate_policy('mat_m1', 10, '1 day'::interval, '1 h'::interval); --start_interval < end_interval SELECT add_continuous_aggregate_policy('mat_m1', 5, 10, '1h'::interval); --refresh window less than two buckets SELECT add_continuous_aggregate_policy('mat_m1', 11, 10, '1h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval) as job_id \gset --adding again should warn/error SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>false); SELECT add_continuous_aggregate_policy('mat_m1', 20, 15, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>true); -- modify config and try to add, should error out SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; SELECT hypertable_id as mat_id FROM _timescaledb_config.bgw_job where id = :job_id \gset \set VERBOSITY terse \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; UPDATE _timescaledb_config.bgw_job SET config = jsonb_build_object('mat_hypertable_id', :mat_id) WHERE id = :job_id; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval, if_not_exists=>true); SELECT remove_continuous_aggregate_policy('int_tab'); SELECT remove_continuous_aggregate_policy('mat_m1'); -- add with NULL offset, readd with NULL offset SELECT add_continuous_aggregate_policy('mat_m1', 20, NULL, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', 20, NULL, '1h'::interval, if_not_exists=>true); -- same param values, so we get a NOTICE SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '1h'::interval, if_not_exists=>true); -- different values, so we get a WARNING SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 20, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 20, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '1h'::interval, if_not_exists=>true); SELECT remove_continuous_aggregate_policy('mat_m1'); --this one will fail SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT remove_continuous_aggregate_policy('mat_m1', if_not_exists=>true); --now try to add a policy as a different user than the one that created the cagg --should fail SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT add_continuous_aggregate_policy('mat_m1', 20, 10, '1h'::interval) as job_id ; \set VERBOSITY terse \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW mat_m1; --- code coverage tests : add policy for timestamp and date based table --- CREATE TABLE continuous_agg_max_mat_date(time DATE); SELECT create_hypertable('continuous_agg_max_mat_date', 'time'); CREATE MATERIALIZED VIEW max_mat_view_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) FROM continuous_agg_max_mat_date GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for timestamp type buckets ALTER materialized view max_mat_view_date set (timescaledb.compress = true); -- Only works for cagg SELECT timescaledb_experimental.add_policies('continuous_agg_max_mat_date', refresh_start_offset => '1 day'::interval, refresh_end_offset => '2 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.show_policies('continuous_agg_max_mat_date'); SELECT timescaledb_experimental.alter_policies('continuous_agg_max_mat_date', compress_after=>'16 days'::interval); SELECT timescaledb_experimental.remove_policies('continuous_agg_max_mat_date', false, 'policy_refresh_continuous_aggregate'); -- No policy is added if one errors out SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '1 day'::interval, refresh_end_offset => '2 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Create open ended refresh_policy SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => '2 day'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => '2 day'::interval, refresh_start_offset=>'-infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '2 day'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '2 day'::interval, refresh_end_offset=>'infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); -- Open ended at both sides, for code coverage SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_end_offset => 'infinity', refresh_start_offset => '-infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate'); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '15 days'::interval, refresh_end_offset => '1 day'::interval, compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Alter policies SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset => '16 days'::interval, compress_after=>'26 days'::interval, drop_after => '40 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); --Alter refresh_policy to make it open ended SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_retention', 'policy_compression'); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'-infinity'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_end_offset =>'infinity', refresh_start_offset =>'5 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); --Cross policy checks -- Refresh and compression policies overlap SELECT timescaledb_experimental.add_policies('max_mat_view_date', compress_after => '20 days'::interval, drop_after => '25 days'::interval); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', compress_after=> '4 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Refresh and retention policies overlap SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'5 days'::interval, drop_after=> '4 days'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); --Do not allow refreshed data to be deleted SELECT add_retention_policy('continuous_agg_max_mat_date', '25 days'::interval); SELECT timescaledb_experimental.alter_policies('max_mat_view_date', refresh_start_offset =>'25 days'::interval); SELECT remove_retention_policy('continuous_agg_max_mat_date'); -- Remove one or more policy -- Code coverage: no policy names provided SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false); -- Code coverage: incorrect name of policy SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'refresh_policy'); SELECT timescaledb_experimental.remove_policies('max_mat_view_date', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Add one policy SELECT timescaledb_experimental.add_policies('max_mat_view_date', refresh_start_offset => '15 day'::interval, refresh_end_offset => '1 day'::interval); SELECT timescaledb_experimental.show_policies('max_mat_view_date'); -- Remove all policies SELECT * FROM timescaledb_experimental.policies ORDER BY relation_name, proc_name; SELECT timescaledb_experimental.remove_all_policies(NULL); -- should fail SELECT timescaledb_experimental.remove_all_policies('continuous_agg_max_mat_date'); -- should fail SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', false); SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', false); -- should fail CREATE OR REPLACE FUNCTION custom_func(jobid int, args jsonb) RETURNS RECORD LANGUAGE SQL AS $$ VALUES($1, $2, 'custom_func'); $$; -- inject custom job SELECT add_job('custom_func','1h', config:='{"type":"function"}'::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS job_id \gset SELECT _timescaledb_functions.alter_job_set_hypertable_id( :job_id, 'max_mat_view_date'::regclass); SELECT * FROM timescaledb_information.jobs WHERE job_id != 1 ORDER BY 1; SELECT timescaledb_experimental.remove_all_policies('max_mat_view_date', true); -- ignore custom job SELECT delete_job(:job_id); DROP FUNCTION custom_func; SELECT timescaledb_experimental.show_policies('max_mat_view_date'); ALTER materialized view max_mat_view_date set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('max_mat_view_date', '2 days', 10, '1 day'::interval); --start_interval < end_interval SELECT add_continuous_aggregate_policy('max_mat_view_date', '1 day'::interval, '2 days'::interval , '1 day'::interval) ; --interval less than two buckets SELECT add_continuous_aggregate_policy('max_mat_view_date', '7 days', '1 day', '1 day'::interval); SELECT add_continuous_aggregate_policy('max_mat_view_date', '14 days', '1 day', '1 day'::interval); SELECT add_continuous_aggregate_policy('max_mat_view_date', '13 days', '-10 hours', '1 day'::interval); \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Negative start offset gives two bucket window: SELECT add_continuous_aggregate_policy('max_mat_view_date', '13 days', '-1 day', '1 day'::interval); SELECT remove_continuous_aggregate_policy('max_mat_view_date'); -- Both offsets NULL: SELECT add_continuous_aggregate_policy('max_mat_view_date', NULL, NULL, '1 day'::interval); SELECT remove_continuous_aggregate_policy('max_mat_view_date'); SELECT add_continuous_aggregate_policy('max_mat_view_date', '15 days', '1 day', '1 day'::interval) as job_id \gset SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; INSERT INTO continuous_agg_max_mat_date SELECT generate_series('2019-09-01'::date, '2019-09-10'::date, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; CALL run_job(:job_id); RESET client_min_messages; DROP MATERIALIZED VIEW max_mat_view_date; CREATE TABLE continuous_agg_timestamp(time TIMESTAMP); SELECT create_hypertable('continuous_agg_timestamp', 'time'); CREATE MATERIALIZED VIEW max_mat_view_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) FROM continuous_agg_timestamp GROUP BY 1 WITH NO DATA; --the start offset overflows the smallest time value, but is capped at --the min value SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '1000000 years', '1 day' , '1 h'::interval); SELECT remove_continuous_aggregate_policy('max_mat_view_timestamp'); \set ON_ERROR_STOP 0 \set VERBOSITY default --start and end offset capped at the lowest time value, which means --zero size window SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '1000000 years', '900000 years' , '1 h'::interval); SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '301 days', '10 months' , '1 h'::interval); \set VERBOSITY terse \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 days', '1 h'::interval , '1 h'::interval) as job_id \gset --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; CALL run_job(:job_id); RESET client_min_messages ; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; UPDATE _timescaledb_config.bgw_job SET config = jsonb_build_object('mat_hypertable_id', :mat_id) WHERE id = :job_id; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT config FROM _timescaledb_config.bgw_job where id = :job_id; \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 day', '1 day', '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', 'xyz', '1 day', '1h'::interval, if_not_exists=>true); \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW max_mat_view_timestamp; --smallint table CREATE TABLE smallint_tab (a smallint); SELECT table_name FROM create_hypertable('smallint_tab', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_smallint_tab() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a)::smallint, 0::smallint) FROM smallint_tab ; $$; SELECT set_integer_now_func('smallint_tab', 'integer_now_smallint_tab'); CREATE MATERIALIZED VIEW mat_smallint( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT time_bucket( SMALLINT '1', a) , count(*) FROM smallint_tab GROUP BY 1 WITH NO DATA; \set ON_ERROR_STOP 0 \set VERBOSITY default -- Test 1 step policy for smallint type buckets ALTER materialized view mat_smallint set (timescaledb.compress = true); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_smallint', refresh_start_offset => 10::smallint, refresh_end_offset => 1::smallint, compress_after => 11::smallint, drop_after => 20::smallint); SELECT timescaledb_experimental.show_policies('mat_smallint'); -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_smallint', refresh_start_offset => 11::smallint, compress_after=>13::smallint, drop_after => 25::smallint); SELECT timescaledb_experimental.show_policies('mat_smallint'); SELECT timescaledb_experimental.remove_all_policies('mat_smallint', false); ALTER materialized view mat_smallint set (timescaledb.compress = false); SELECT add_continuous_aggregate_policy('mat_smallint', 15, 0 , '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_smallint', 98898::smallint , 0::smallint, '1 h'::interval); SELECT add_continuous_aggregate_policy('mat_smallint', 5::smallint, 10::smallint , '1 h'::interval) as job_id \gset \set VERBOSITY terse \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('mat_smallint', 15::smallint, 0::smallint , '1 h'::interval) as job_id \gset INSERT INTO smallint_tab VALUES(5); INSERT INTO smallint_tab VALUES(10); INSERT INTO smallint_tab VALUES(20); CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; --remove all the data-- TRUNCATE table smallint_tab; CALL refresh_continuous_aggregate('mat_smallint', NULL, NULL); SELECT * FROM mat_smallint ORDER BY 1; -- Case 1: overflow by subtracting from PG_INT16_MIN --overflow start_interval, end_interval [-32768, -32768) SELECT remove_continuous_aggregate_policy('mat_smallint'); INSERT INTO smallint_tab VALUES( -32768 ); SELECT integer_now_smallint_tab(); SELECT add_continuous_aggregate_policy('mat_smallint', 10::smallint, 5::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); \set ON_ERROR_STOP 1 SELECT * FROM mat_smallint ORDER BY 1; -- overflow start_interval. now this runs as range is capped [-32768, -32765) INSERT INTO smallint_tab VALUES( -32760 ); SELECT maxval, maxval - 10, maxval -5 FROM integer_now_smallint_tab() as maxval; CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; --remove all the data-- TRUNCATE table smallint_tab; CALL refresh_continuous_aggregate('mat_smallint', NULL, NULL); SELECT * FROM mat_smallint ORDER BY 1; -- Case 2: overflow by subtracting from PG_INT16_MAX --overflow start and end . will fail as range is [32767, 32767] SELECT remove_continuous_aggregate_policy('mat_smallint'); INSERT INTO smallint_tab VALUES( 32766 ); INSERT INTO smallint_tab VALUES( 32767 ); SELECT maxval, maxval - (-1), maxval - (-2) FROM integer_now_smallint_tab() as maxval; SELECT add_continuous_aggregate_policy('mat_smallint', -1::smallint, -3::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); \set ON_ERROR_STOP 1 SELECT * FROM mat_smallint ORDER BY 1; SELECT remove_continuous_aggregate_policy('mat_smallint'); --overflow end . will work range is [32765, 32767) SELECT maxval, maxval - (1), maxval - (-2) FROM integer_now_smallint_tab() as maxval; SELECT add_continuous_aggregate_policy('mat_smallint', 1::smallint, -3::smallint , '1 h'::interval) as job_id \gset \set ON_ERROR_STOP 0 CALL run_job(:job_id); SELECT * FROM mat_smallint ORDER BY 1; -- tests for interval argument conversions -- \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_smallint', 15, 10, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_smallint', '15', 10, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('mat_smallint', '15', '10', '1h'::interval, if_not_exists=>true); \set ON_ERROR_STOP 1 --bigint table CREATE TABLE bigint_tab (a bigint); SELECT table_name FROM create_hypertable('bigint_tab', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_bigint_tab() returns bigint LANGUAGE SQL STABLE as $$ SELECT 20::bigint $$; SELECT set_integer_now_func('bigint_tab', 'integer_now_bigint_tab'); CREATE MATERIALIZED VIEW mat_bigint( a, countb ) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as SELECT time_bucket( BIGINT '1', a) , count(*) FROM bigint_tab GROUP BY 1 WITH NO DATA; -- Test 1 step policy for bigint type buckets ALTER materialized view mat_bigint set (timescaledb.compress = true); -- All policies are added in one step SELECT timescaledb_experimental.add_policies('mat_bigint', refresh_start_offset => 10::bigint, refresh_end_offset => 1::bigint, compress_after => 11::bigint, drop_after => 20::bigint); SELECT timescaledb_experimental.show_policies('mat_bigint'); -- Alter policies SELECT timescaledb_experimental.alter_policies('mat_bigint', refresh_start_offset => 11::bigint, compress_after=>13::bigint, drop_after => 25::bigint); SELECT timescaledb_experimental.show_policies('mat_bigint'); SELECT timescaledb_experimental.remove_all_policies('mat_bigint', false); ALTER materialized view mat_bigint set (timescaledb.compress = false); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_bigint', 5::bigint, 10::bigint , '1 h'::interval) ; \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('mat_bigint', 15::bigint, 0::bigint , '1 h'::interval) as job_mid \gset INSERT INTO bigint_tab VALUES(5); INSERT INTO bigint_tab VALUES(10); INSERT INTO bigint_tab VALUES(20); CALL run_job(:job_mid); SELECT * FROM mat_bigint ORDER BY 1; -- test NULL for end SELECT remove_continuous_aggregate_policy('mat_bigint'); SELECT add_continuous_aggregate_policy('mat_bigint', 1::smallint, NULL , '1 h'::interval) as job_id \gset INSERT INTO bigint_tab VALUES(500); CALL run_job(:job_id); SELECT * FROM mat_bigint WHERE a>100 ORDER BY 1; ALTER MATERIALIZED VIEW mat_bigint SET (timescaledb.compress); ALTER MATERIALIZED VIEW mat_smallint SET (timescaledb.compress); -- With immutable compressed chunks, these policies would fail by overlapping the refresh window SELECT add_compression_policy('mat_smallint', -4::smallint); SELECT remove_compression_policy('mat_smallint'); SELECT add_compression_policy('mat_bigint', 0::bigint); SELECT remove_compression_policy('mat_bigint'); -- End previous limitation tests SELECT add_compression_policy('mat_smallint', 5::smallint); SELECT add_compression_policy('mat_bigint', 20::bigint); -- end of coverage tests --TEST continuous aggregate + compression policy on caggs CREATE TABLE metrics ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable('metrics', 'time'); INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-02 23:55:00+0', '20m') gtime (time), generate_series(1, 2, 1) gdevice (device_id); ALTER TABLE metrics SET ( timescaledb.compress ); SELECT compress_chunk(ch) FROM show_chunks('metrics') ch; CREATE MATERIALIZED VIEW metrics_cagg WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket('1 day', time) as dayb, device_id, sum(v0), avg(v3) FROM metrics GROUP BY 1, 2 WITH NO DATA; -- this was previously crashing SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, NULL, '1 h'::interval, if_not_exists => true); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, '1 day'::interval, '1 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('metrics_cagg'); SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, '1 day'::interval, '1h'::interval, if_not_exists=>true); SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, '1 day'::interval, '1h'::interval, if_not_exists=>true); -- same param values, so we get a NOTICE SELECT add_continuous_aggregate_policy('metrics_cagg', NULL, NULL, '1h'::interval, if_not_exists=>true); -- different values, so we get a WARNING SELECT remove_continuous_aggregate_policy('metrics_cagg'); --can set compression policy only after setting up refresh policy -- SELECT add_compression_policy('metrics_cagg', '1 day'::interval); --can set compression policy only after enabling compression -- SELECT add_continuous_aggregate_policy('metrics_cagg', '7 day'::interval, '1 day'::interval, '1 h'::interval) as "REFRESH_JOB" \gset SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" ; ALTER MATERIALIZED VIEW metrics_cagg SET (timescaledb.compress); --cannot use compress_created_before with cagg SELECT add_compression_policy('metrics_cagg', compress_created_before => '8 day'::interval) AS "COMP_JOB" ; \set ON_ERROR_STOP 1 SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" ; SELECT remove_compression_policy('metrics_cagg'); SELECT add_compression_policy('metrics_cagg', '8 day'::interval) AS "COMP_JOB" \gset --verify that jobs were added for the policies --- SELECT materialization_hypertable_name AS "MAT_TABLE_NAME", view_name AS "VIEW_NAME" FROM timescaledb_information.continuous_aggregates WHERE view_name = 'metrics_cagg' \gset SELECT count(*) FROM timescaledb_information.jobs WHERE hypertable_name = :'VIEW_NAME'; --exec the cagg compression job -- CALL refresh_continuous_aggregate('metrics_cagg', NULL, '2001-02-01 00:00:00+0'); CALL run_job(:COMP_JOB); SELECT count(*), count(*) FILTER ( WHERE is_compressed is TRUE ) FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; --add some new data into metrics_cagg so that cagg policy job has something to do INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT now() - '5 day'::interval, 102, 0, 10, 10, 10, 10; CALL run_job(:REFRESH_JOB); --now we have a new chunk and it is not compressed SELECT count(*), count(*) FILTER ( WHERE is_compressed is TRUE ) FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; --verify that both jobs are dropped when view is dropped DROP MATERIALIZED VIEW metrics_cagg; SELECT count(*) FROM timescaledb_information.jobs WHERE hypertable_name = :'VIEW_NAME'; -- add test case for issue 4252 CREATE TABLE IF NOT EXISTS sensor_data( time TIMESTAMPTZ NOT NULL, sensor_id INTEGER, temperature DOUBLE PRECISION, cpu DOUBLE PRECISION); SELECT create_hypertable('sensor_data','time'); INSERT INTO sensor_data(time, sensor_id, cpu, temperature) SELECT time, sensor_id, extract(dow from time) AS cpu, extract(doy from time) AS temperature FROM generate_series('2022-05-05'::timestamp at time zone 'UTC' - interval '6 weeks', '2022-05-05'::timestamp at time zone 'UTC', interval '5 hours') as g1(time), generate_series(1,1000,1) as g2(sensor_id); CREATE materialized view deals_best_weekly WITH (timescaledb.continuous) AS SELECT time_bucket('7 days', "time") AS bucket, avg(temperature) AS avg_temp, max(cpu) AS max_rating FROM sensor_data GROUP BY bucket WITH NO DATA; CREATE materialized view deals_best_daily WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', "time") AS bucket, avg(temperature) AS avg_temp, max(cpu) AS max_rating FROM sensor_data GROUP BY bucket WITH NO DATA; ALTER materialized view deals_best_weekly set (timescaledb.materialized_only=true); ALTER materialized view deals_best_daily set (timescaledb.materialized_only=true); -- we have data from 6 weeks before to May 5 2022 (Thu) CALL refresh_continuous_aggregate('deals_best_weekly', '2022-04-24', '2022-05-03'); SELECT * FROM deals_best_weekly ORDER BY bucket; CALL refresh_continuous_aggregate('deals_best_daily', '2022-04-20', '2022-05-04'); SELECT * FROM deals_best_daily ORDER BY bucket LIMIT 2; -- expect to get an up-to-date notice CALL refresh_continuous_aggregate('deals_best_weekly', '2022-04-24', '2022-05-05'); SELECT * FROM deals_best_weekly ORDER BY bucket; -- github issue 5907: segfault when creating 1-step policies on cagg -- whose underlying hypertable has a retention policy setup CREATE TABLE t(a integer NOT NULL, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION unix_now() returns int LANGUAGE SQL IMMUTABLE as $$ SELECT extract(epoch from now())::INT $$; SELECT set_integer_now_func('t', 'unix_now'); SELECT add_retention_policy('t', 20); CREATE MATERIALIZED VIEW cagg(a, sumb) WITH (timescaledb.continuous) AS SELECT time_bucket(1, a), sum(b) FROM t GROUP BY time_bucket(1, a); SELECT timescaledb_experimental.add_policies('cagg'); -- Issue #6902 <<<<<<< HEAD -- Fix timestamp out of range in a refresh policy when setting `end_offset=>NULL` -- for a CAgg with variable sized bucket (i.e: using `time_bucket` with timezone) ======= >>>>>>> cda33125c (Fix timestamp out of range in CAgg refresh policy) CREATE TABLE issue_6902 ( ts TIMESTAMPTZ NOT NULL, temperature NUMERIC ) WITH ( timescaledb.hypertable, timescaledb.partition_column='ts', timescaledb.chunk_interval='1 day', timescaledb.compress='off' ); INSERT INTO issue_6902 SELECT t, 1 FROM generate_series(now() - interval '3 hours', now(), interval '1 minute') AS t; CREATE MATERIALIZED VIEW issue_6902_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', ts, 'America/Sao_Paulo') AS bucket, -- using timezone MAX(temperature), MIN(temperature), COUNT(*) FROM issue_6902 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy ( 'issue_6902_by_hour', start_offset => INTERVAL '3 hours', end_offset => NULL, schedule_interval => INTERVAL '12 hour', initial_start => now() + INTERVAL '12 hour' ) AS job_id \gset -- 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; -- run again without any change, remain 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; -- change existing data UPDATE issue_6902 SET temperature = temperature + 1; -- run again without any change, remain 181 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; -- insert more data INSERT INTO issue_6902 SELECT t, 1 FROM generate_series(now() - interval '3 hours', now(), interval '1 minute') AS t; -- run again without and should have 362 rows CALL run_job(:job_id); SELECT count(*) FROM issue_6902; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_policy_concurrent.sql������������������������������������������0000664�0000000�0000000�00000071535�15100345067�0023711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test creation of multiple refresh policies SET timezone TO PST8PDT; SET timescaledb.current_timestamp_mock TO '2025-06-01 0:30:00+00'; SELECT setseed(1); -- test interval checking with bigint CREATE TABLE overlap_test_bigint ( time BIGINT NOT NULL, a INTEGER, b INTEGER ); SELECT create_hypertable('overlap_test_bigint', 'time', chunk_time_interval => 100); CREATE OR REPLACE FUNCTION integer_now_overlap_test_bigint() RETURNS BIGINT LANGUAGE SQL STABLE AS $$ SELECT COALESCE(MAX(time), 0) FROM overlap_test_bigint $$; SELECT set_integer_now_func('overlap_test_bigint', 'integer_now_overlap_test_bigint'); INSERT INTO overlap_test_bigint SELECT i, (i % 5), random() * 100 FROM generate_series(1, 2000) i; CREATE MATERIALIZED VIEW mat_m1(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, count(a), sum(b) FROM overlap_test_bigint GROUP BY 1 WITH NO DATA; /* Test interval checking when multiple policies are created on the same cagg */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 1000::bigint, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Creating policies in either order should work */ SELECT add_continuous_aggregate_policy('mat_m1', 1000::bigint, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 3000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Test non-null offsets on both sides too */ SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 3000::bigint,'12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 3000::bigint, 2000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Check overlap is detected correctly */ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', 5000::bigint, 1000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 5000::bigint, 1000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, 1000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 1000::bigint, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Check behaviour when exact policy is already defined */ \set ON_ERROR_STOP 0 /*if_not_exists=false*/ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /*if_not_exists => true*/ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, 1000::bigint, '12 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, NULL, '12 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Throw an error if there is an overlap even if if_not_exists => true */ SELECT add_continuous_aggregate_policy('mat_m1', 4000::bigint, 2000::bigint, '12 h'::interval); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', 3000::bigint, 1000::bigint, '12 h'::interval, if_not_exists => true); \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); /* Test `alter_job` changing the config */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, 3000::bigint, '12 h'::interval); SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); /* Alter end offset but don't overlap */ SELECT jsonb_set(:'config', '{end_offset}', '2000') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); \set ON_ERROR_STOP 0 /* Alter end offset to overlap with another job*/ SELECT jsonb_set(:'config', '{end_offset}', '1000') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); /* Alter end offset to be null */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); /* Alter job to be identical to existing job */ SELECT jsonb_set(:'config', '{start_offset}', '2000') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', 2000::bigint, NULL, '12 h'::interval); SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', NULL, 3000::bigint, '12 h'::interval); /* Alter end offset to null but no overlap */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Test that refresh is done correctly even though multiple policies exist */ /* We do this by creating two CAggs on the same hypertable */ /* One will have a single policy while the other will have two policies with adjacent offsets */ CREATE MATERIALIZED VIEW mat_m2(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, count(a), sum(b) FROM overlap_test_bigint GROUP BY 1 WITH NO DATA; /* Create two policies on mat_m1 */ SELECT add_continuous_aggregate_policy('mat_m1', 5000::bigint, 3000::bigint, '12 h'::interval) AS agg_m1_job_1 \gset SELECT add_continuous_aggregate_policy('mat_m1', 3000::bigint, 1000::bigint, '12 h'::interval) AS agg_m1_job_2 \gset /* Create single policy on mat_m2 */ SELECT add_continuous_aggregate_policy('mat_m2', 5000::bigint, 1000::bigint, '12 h'::interval) AS agg_m2_job \gset /* Cleanup any existing data */ TRUNCATE mat_m1; TRUNCATE mat_m2; /* Refresh both continuous aggs immediately */ CALL run_job(:agg_m1_job_1); CALL run_job(:agg_m1_job_2); CALL run_job(:agg_m2_job); /* Compare both outputs */ SELECT count(*) AS exp_row_count from mat_m1 \gset SELECT count(*) AS actual_row_count from ( SELECT * from mat_m1 UNION SELECT * from mat_m2) union_q \gset /* Row counts should be the same */ SELECT :exp_row_count = :actual_row_count, :exp_row_count, :actual_row_count; SELECT * from mat_m2 EXCEPT SELECT * from mat_m1; SELECT * from mat_m1 EXCEPT SELECT * from mat_m2; DROP MATERIALIZED VIEW mat_m1; DROP MATERIALIZED VIEW mat_m2; CREATE TABLE overlap_test_timestamptz ( time timestamptz NOT NULL, a INTEGER, b INTEGER ); SELECT create_hypertable('overlap_test_timestamptz', 'time', chunk_time_interval => '1 day'::interval); INSERT INTO overlap_test_timestamptz SELECT t, (i % 5), random() * 100 FROM generate_series('2025-01-01T01:01:01+00', '2025-06-01T01:01:01+00', INTERVAL '1 days') t, generate_series(1, 10) i; CREATE MATERIALIZED VIEW mat_m1(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz GROUP BY 1 WITH NO DATA; /* Test interval checking when multiple policies are created on the same cagg */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '29 days'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Creating policies in either order should work */ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '15 days'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Test non-null offsets on both sides too */ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '20 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '10 days'::interval, '5 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '19 days'::interval, '11 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Check overlap is detected correctly */ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '45 days'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '45 days'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '10 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, '15 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, '15 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '10 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '20 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Check behaviour when exact policy is already defined */ \set ON_ERROR_STOP 0 /*if_not_exists=false*/ SELECT add_continuous_aggregate_policy('mat_m1', '45 days'::interval, '30 days', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '31 days'::interval, '15 days', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '31 days'::interval, '15 days', '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /*if_not_exists => true*/ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', '45 days', '30 days', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '15 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '15 days'::interval, '12 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Throw an error if there is an overlap even if if_not_exists => true */ SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, '10 days'::interval, '12 h'::interval); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', '15 days'::interval, NULL, '12 h'::interval); \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); /* Mixing different interval units should also work correctly*/ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '2 months'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '5 weeks'::interval, '-7 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Check overlap with negative offsets */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '-1 month'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '-2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Test `alter_job` changing the config */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); /* Alter end offset but don't overlap */ SELECT jsonb_set(:'config', '{end_offset}', '"30 days"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); \set ON_ERROR_STOP 0 /* Alter end offset to overlap with another job*/ SELECT jsonb_set(:'config', '{end_offset}', '"1 week"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); /* Alter end offset to be null */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); /* Alter job to be identical to existing job */ SELECT jsonb_set(:'config', '{start_offset}', '"2 weeks"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); /* Alter end offset to null but no overlap */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); SELECT remove_continuous_aggregate_policy('mat_m1'); CREATE MATERIALIZED VIEW mat_m2(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz GROUP BY 1 WITH NO DATA; /* Create two policies on mat_m1 */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval) AS agg_m1_job_1 \gset SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval) AS agg_m1_job_2 \gset /* Create single policy on mat_m2 */ SELECT add_continuous_aggregate_policy('mat_m2', NULL, NULL, '12 h'::interval) AS agg_m2_job \gset /* Cleanup any existing data */ TRUNCATE mat_m1; TRUNCATE mat_m2; /* Refresh both continuous aggs immediately */ CALL run_job(:agg_m1_job_1); CALL run_job(:agg_m1_job_2); CALL run_job(:agg_m2_job); /* Compare both outputs */ SELECT count(*) AS exp_row_count from mat_m1 \gset SELECT count(*) AS actual_row_count from ( SELECT * from mat_m1 UNION SELECT * from mat_m2) AS union_q \gset /* Row counts should be the same */ SELECT :exp_row_count = :actual_row_count, :exp_row_count, :actual_row_count; SELECT * from mat_m2 EXCEPT SELECT * from mat_m1; SELECT * from mat_m1 EXCEPT SELECT * from mat_m2; DROP MATERIALIZED VIEW mat_m1; DROP MATERIALIZED VIEW mat_m2; /* Test with variable sized buckets */ CREATE TABLE overlap_test_timestamptz_var ( time timestamptz NOT NULL, a INTEGER, b INTEGER ); SELECT create_hypertable('overlap_test_timestamptz_var', 'time', chunk_time_interval => '1 month'::interval); INSERT INTO overlap_test_timestamptz_var SELECT t, (i % 5), random() * 100 FROM generate_series('2024-01-01T01:01:01+00', '2025-06-01T01:01:01+00', INTERVAL '1 day') t, generate_series(1, 10) i; CREATE MATERIALIZED VIEW mat_m1(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz_var GROUP BY 1 WITH NO DATA; /* Test interval checking when multiple policies are created on the same cagg */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '3 months'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Creating policies in either order should work */ SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '3 months'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '3 months'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '2 months'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Test non-null offsets on both sides too */ SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '6 months'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '6 months'::interval, '12 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '12 weeks'::interval, '1 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); /* Check overlap is detected correctly */ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '3 months'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '6 months'::interval, '1 week'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '4 months'::interval, '2 weeks'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '4 months'::interval, '2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '6 months'::interval, '1 week'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '20 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '20 days'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Check behaviour when exact policy is already defined */ \set ON_ERROR_STOP 0 /*if_not_exists=false*/ SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '8 months', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /*if_not_exists => true*/ \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '8 months', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '8 months'::interval, '2 weeks', '12 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL::interval, NULL::interval, '12 h'::interval, if_not_exists => true); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Mixing different interval units should also work correctly*/ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '1 year'::interval, '2 months'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '8 weeks'::interval, '-7 days'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', NULL, '1 month'::interval, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Check overlap with negative offsets */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '-1 month'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('mat_m1', NULL, '-2 weeks'::interval, '12 h'::interval); SELECT add_continuous_aggregate_policy('mat_m1', '1 month'::interval, NULL, '12 h'::interval); SELECT remove_continuous_aggregate_policy('mat_m1'); \set ON_ERROR_STOP 1 /* Test `alter_job` changing the config */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); /* Alter end offset but don't overlap */ SELECT jsonb_set(:'config', '{end_offset}', '"30 days"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); \set ON_ERROR_STOP 0 /* Alter end offset to overlap with another job*/ SELECT jsonb_set(:'config', '{end_offset}', '"1 week"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); /* Alter end offset to be null */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); /* Alter job to be identical to existing job */ SELECT jsonb_set(:'config', '{start_offset}', '"2 weeks"') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); \set ON_ERROR_STOP 1 SELECT remove_continuous_aggregate_policy('mat_m1'); SELECT add_continuous_aggregate_policy('mat_m1', '2 weeks'::interval, NULL, '12 h'::interval); SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_refresh_continuous_aggregate' \gset SELECT add_continuous_aggregate_policy('mat_m1', NULL, '2 months'::interval, '12 h'::interval); /* Alter end offset to null but no overlap */ SELECT jsonb_set(:'config', '{end_offset}', 'null') AS config \gset SELECT * FROM alter_job(:job_id, config := :'config'); SELECT remove_continuous_aggregate_policy('mat_m1'); CREATE MATERIALIZED VIEW mat_m2(time, counta) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time) AS bucket, count(a), sum(b) FROM overlap_test_timestamptz_var GROUP BY 1 WITH NO DATA; /* Create two policies on mat_m1 */ SELECT add_continuous_aggregate_policy('mat_m1', NULL, '30 days'::interval, '12 h'::interval) AS agg_m1_job_1 \gset SELECT add_continuous_aggregate_policy('mat_m1', '30 days'::interval, NULL, '12 h'::interval) AS agg_m1_job_2 \gset /* Create single policy on mat_m2 */ SELECT add_continuous_aggregate_policy('mat_m2', NULL, NULL, '12 h'::interval) AS agg_m2_job \gset /* Cleanup any existing data */ TRUNCATE mat_m1; TRUNCATE mat_m2; /* Refresh both continuous aggs immediately */ CALL run_job(:agg_m1_job_1); CALL run_job(:agg_m1_job_2); CALL run_job(:agg_m2_job); /* Compare both outputs */ SELECT count(*) AS exp_row_count from mat_m1 \gset SELECT count(*) AS actual_row_count from ( SELECT * from mat_m1 UNION SELECT * from mat_m2) AS union_q \gset /* Row counts should be the same */ SELECT :exp_row_count = :actual_row_count, :exp_row_count, :actual_row_count; SELECT * from mat_m2 EXCEPT SELECT * from mat_m1; SELECT * from mat_m1 EXCEPT SELECT * from mat_m2; DROP MATERIALIZED VIEW mat_m1; DROP MATERIALIZED VIEW mat_m2; /* Concurrent policies aren't allowed on hierarchical continuous aggs */ CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS bucket, count(a) AS counta, sum(b) AS sumb FROM overlap_test_timestamptz GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW mat_m1_rollup WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', bucket) AS bucket, sum(counta) AS counta, sum(sumb) AS sumb FROM mat_m1 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1_rollup', NULL, '30 days'::interval, '12 h'::interval); \set ON_ERROR_STOP 0 -- Multiple policies on hierarchical cagg should not be allowed SELECT add_continuous_aggregate_policy('mat_m1_rollup', '29 days'::interval, NULL, '12 h'::interval); \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_policy_incremental.sql�����������������������������������������0000664�0000000�0000000�00000027735�15100345067�0024033�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1, mock_start_time INT = 0) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_destroy() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_reset_time(set_time BIGINT = 0, wait BOOLEAN = false) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- Create a user with specific timezone and mock time CREATE ROLE test_cagg_refresh_policy_user WITH LOGIN; ALTER ROLE test_cagg_refresh_policy_user SET timezone TO 'UTC'; ALTER ROLE test_cagg_refresh_policy_user SET timescaledb.current_timestamp_mock TO '2025-03-11 00:00:00+00'; GRANT ALL ON SCHEMA public TO test_cagg_refresh_policy_user; \c :TEST_DBNAME test_cagg_refresh_policy_user CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT msg_no, mock_time, application_name, regexp_replace(regexp_replace(msg, '(Wait until|started at|execution time) [0-9]+(\.[0-9]+)?', '\1 (RANDOM)', 'g'), 'background worker "[^"]+"','connection') AS msg FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); CREATE TABLE conditions ( time TIMESTAMP WITH TIME ZONE NOT NULL, device_id INTEGER, temperature NUMERIC ); SELECT FROM create_hypertable('conditions', by_range('time')); INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2025-02-05 00:00:00+00', '2025-03-05 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; CREATE MATERIALIZED VIEW conditions_by_day WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time), device_id, count(*), min(temperature), max(temperature), avg(temperature), sum(temperature) FROM conditions GROUP BY 1, 2 WITH NO DATA; SELECT add_continuous_aggregate_policy( 'conditions_by_day', start_offset => NULL, end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 10 ) AS job_id \gset SELECT config FROM timescaledb_information.jobs WHERE job_id = :'job_id' \gset SELECT ts_bgw_params_reset_time(0, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; CREATE MATERIALIZED VIEW conditions_by_day_manual_refresh WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time), device_id, count(*), min(temperature), max(temperature), avg(temperature), sum(temperature) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_day_manual_refresh', NULL, NULL); SELECT count(*) FROM conditions_by_day; SELECT count(*) FROM conditions_by_day_manual_refresh; -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; TRUNCATE bgw_log, conditions_by_day; SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{max_batches_per_execution}', '2') ); -- advance time by 1h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '1 hour')::bigint * 1000000, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT count(*) FROM conditions_by_day; SELECT count(*) FROM conditions_by_day_manual_refresh; -- Should have differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; -- advance time by 2h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '2 hour')::bigint * 1000000, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; -- Set max_batches_per_execution to 10 SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{max_batches_per_execution}', '10') ); TRUNCATE bgw_log; -- Insert data into the past INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2020-02-05 00:00:00+00', '2020-03-05 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; -- advance time by 3h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '3 hour')::bigint * 1000000, true); -- Should process all four batches in the past SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; SELECT count(*) FROM conditions_by_day; SELECT count(*) FROM conditions_by_day_manual_refresh; CALL refresh_continuous_aggregate('conditions_by_day_manual_refresh', NULL, NULL); SELECT count(*) FROM conditions_by_day; SELECT count(*) FROM conditions_by_day_manual_refresh; -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; -- Check invalid configurations \set ON_ERROR_STOP 0 \set VERBOSITY default SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{max_batches_per_execution}', '-1') ); SELECT config FROM alter_job( :'job_id', config => jsonb_set(:'config', '{buckets_per_batch}', '-1') ); \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Truncate all data from the original hypertable TRUNCATE bgw_log, conditions; -- advance time by 4h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '4 hour')::bigint * 1000000, true); -- Should fallback to single batch processing because there's no data to be refreshed on the original hypertable SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- Should return zero rows SELECT count(*) FROM conditions_by_day; -- 1 day of data INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2020-02-05 00:00:00+00', '2020-02-06 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; TRUNCATE bgw_log; -- advance time by 5h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '5 hour')::bigint * 1000000, true); -- Should fallback to single batch processing because the refresh size is too small SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- Should return 10 rows because the bucket width is `1 day` and buckets per batch is `10` SELECT count(*) FROM conditions_by_day; TRUNCATE conditions_by_day, conditions, bgw_log; -- Less than 1 day of data (smaller than the bucket width) INSERT INTO conditions VALUES ('2020-02-05 00:00:00+00', 1, 10); -- advance time by 6h so that job runs one more time SELECT ts_bgw_params_reset_time(extract(epoch from interval '6 hour')::bigint * 1000000, true); -- Should fallback to single batch processing because the refresh size is too small SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- Should return 1 row SELECT count(*) FROM conditions_by_day; SELECT delete_job(:job_id); SELECT add_continuous_aggregate_policy( 'conditions_by_day', start_offset => INTERVAL '15 days', end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 5, refresh_newest_first => true -- explicitly set to true to test the default behavior ) AS job_id \gset SELECT add_continuous_aggregate_policy( 'conditions_by_day_manual_refresh', start_offset => INTERVAL '15 days', end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 0 -- 0 means no batching, so it will refresh all buckets in one go ) AS job_id_manual \gset TRUNCATE bgw_log, conditions_by_day, conditions_by_day_manual_refresh, conditions; INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2025-03-11 00:00:00+00'::timestamptz - INTERVAL '30 days', '2025-03-11 00:00:00+00'::timestamptz, '1 hour'::interval) AS t, generate_series(1,5) AS d; SELECT ts_bgw_params_reset_time(0, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- Both continuous aggregates should have the same data SELECT count(*) FROM conditions_by_day; SELECT count(*) FROM conditions_by_day_manual_refresh; -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; -- Testing with explicit refresh_newest_first = false (from oldest to newest) SELECT delete_job(:job_id); SELECT delete_job(:job_id_manual); SELECT add_continuous_aggregate_policy( 'conditions_by_day', start_offset => INTERVAL '15 days', end_offset => NULL, schedule_interval => INTERVAL '1 h', buckets_per_batch => 5, refresh_newest_first => false ) AS job_id \gset SELECT config FROM timescaledb_information.jobs WHERE job_id = :'job_id'; TRUNCATE bgw_log, conditions_by_day; SELECT ts_bgw_params_reset_time(0, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; -- Both continuous aggregates should have the same data SELECT count(*) FROM conditions_by_day; SELECT count(*) FROM conditions_by_day_manual_refresh; -- Should have no differences SELECT count(*) > 0 AS has_diff FROM ((SELECT * FROM conditions_by_day_manual_refresh ORDER BY 1, 2) EXCEPT (SELECT * FROM conditions_by_day ORDER BY 1, 2)) AS diff; -- Tests with Variable sized bucket SELECT delete_job(:job_id); TRUNCATE conditions; INSERT INTO conditions SELECT t, d, 10 FROM generate_series( '2025-01-01 00:00:00+00', '2025-10-08 00:00:00+00', '1 hour'::interval) AS t, generate_series(1,5) AS d; CREATE MATERIALIZED VIEW conditions_by_month WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time), device_id, count(*), min(temperature), max(temperature), avg(temperature), sum(temperature) FROM conditions GROUP BY 1, 2 WITH NO DATA; SELECT add_continuous_aggregate_policy( 'conditions_by_month', start_offset => INTERVAL '600 days', end_offset => INTERVAL '7 days', schedule_interval => INTERVAL '1 day', refresh_newest_first => false ) AS job_id \gset SELECT config FROM timescaledb_information.jobs WHERE job_id = :'job_id'; TRUNCATE bgw_log, conditions_by_day; SELECT ts_bgw_params_reset_time(0, true); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT * FROM sorted_bgw_log; \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER REASSIGN OWNED BY test_cagg_refresh_policy_user TO :ROLE_CLUSTER_SUPERUSER; REVOKE ALL ON SCHEMA public FROM test_cagg_refresh_policy_user; DROP ROLE test_cagg_refresh_policy_user; �����������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_policy_move.sql������������������������������������������������0000664�0000000�0000000�00000022511�15100345067�0022463�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE VIEW hypertable_invalidation_thresholds AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, watermark AS threshold FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1; CREATE VIEW hypertable_invalidations AS SELECT format('%I.%I', ht.schema_name, ht.table_name)::regclass AS hypertable, hypertable_id, lowest_modified_value, greatest_modified_value FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log JOIN _timescaledb_catalog.hypertable ht ON hypertable_id = ht.id ORDER BY 1, 2, 3; CREATE FUNCTION get_job_id_for(REGCLASS) RETURNS INTEGER AS $$ SELECT DISTINCT job.id AS job_id FROM _timescaledb_catalog.hypertable AS ht JOIN _timescaledb_config.bgw_job AS job ON hypertable_id = ht.id WHERE format('%I.%I', schema_name, table_name)::regclass = $1 $$ LANGUAGE SQL; CREATE TABLE conditions (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time', chunk_time_interval => 10); CREATE TABLE measurements (time int NOT NULL, device int, temp float); SELECT create_hypertable('measurements', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM measurements $$; SELECT set_integer_now_func('conditions', 'bigint_now'); SELECT set_integer_now_func('measurements', 'int_now'); INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; INSERT INTO measurements SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE MATERIALIZED VIEW conditions_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '10', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2; -- Trying to add to a hypertable that does not have any continuous -- aggregates should fail. \set ON_ERROR_STOP 0 CALL add_process_hypertable_invalidations_policy('measurements', schedule_interval => '1 minute'::interval); \set ON_ERROR_STOP 1 CREATE MATERIALIZED VIEW measure_10 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10, time) AS bucket, device, avg(temp) AS avg_temp FROM measurements GROUP BY 1,2; CALL add_process_hypertable_invalidations_policy('measurements', schedule_interval => '1 minute'::interval); -- Check thresholds to make sure that what we're writing below is not -- after the threshold. SELECT * FROM hypertable_invalidation_thresholds; INSERT INTO conditions VALUES (10, 4, 23.7); INSERT INTO conditions VALUES (10, 5, 23.8), (19, 3, 23.6); INSERT INTO conditions VALUES (60, 3, 23.7), (70, 4, 23.7); INSERT INTO measurements VALUES (20, 4, 23.7); INSERT INTO measurements VALUES (30, 5, 23.8), (80, 3, 23.6); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; \set ON_ERROR_STOP 0 CALL add_process_hypertable_invalidations_policy('conditions_10', schedule_interval => '1 minute'::interval); CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, timezone => 'QQQ'); \set ON_ERROR_STOP 1 CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, initial_start => 'epoch'::timestamptz + '9223371331200000000'::bigint * '1 microsecond'::interval ); -- This should error out and print notice, respectively \set ON_ERROR_STOP 0 CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, if_not_exists => false); CALL add_process_hypertable_invalidations_policy('conditions', schedule_interval => '1 minute'::interval, if_not_exists => true); \set ON_ERROR_STOP 1 \x on SELECT application_name, owner, format('%I.%I', proc_schema, proc_name), schedule_interval, fixed_schedule, initial_start, next_start, -- to check initial start hypertable_id, config FROM _timescaledb_config.bgw_job LEFT JOIN _timescaledb_internal.bgw_job_stat ON id = job_id WHERE application_name LIKE '%Move Hypertables Invalidation Policy%'; \x off -- Get a job id and a valid configuration for testing below. SELECT id AS job_id, config AS config FROM _timescaledb_config.bgw_job WHERE application_name LIKE '%Move Hypertables Invalidation Policy%' AND hypertable_id = 1 \gset -- Test that the check function capture a bad configurations. \set ON_ERROR_STOP 0 SELECT alter_job(:job_id, config => '{"hyper_id": 1}'); -- Picking something really out of bounds to check that it triggers if -- hypertable do not exist. SELECT alter_job(:job_id, config => '{"hypertable_id": 4711}'); SELECT alter_job(:job_id, config => '{"hypertable_id": "garbage"}'); \set ON_ERROR_STOP 1 -- This is just resetting the config to the same, but is used to get -- coverage for the "good path" in the check function. \x on SELECT * FROM alter_job(:job_id, config => :'config'); \x off -- Test to run the job and check that hypertable invalidations are -- processed. SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; CALL run_job(get_job_id_for('conditions')); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; -- Running it twice should work and not change anything. CALL run_job(get_job_id_for('conditions')); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; CALL run_job(get_job_id_for('measurements')); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; \set ON_ERROR_STOP 0 CALL _timescaledb_functions.policy_process_hypertable_invalidations(NULL, NULL); CALL _timescaledb_functions.policy_process_hypertable_invalidations(1, NULL); CALL _timescaledb_functions.policy_process_hypertable_invalidations(NULL, :'config'); \set ON_ERROR_STOP 1 -- Check that a refresh with hypertable invalidation processing -- disabled does not move the invalidations. INSERT INTO measurements VALUES (40, 12, 12.3); INSERT INTO measurements VALUES (50, 13, 34.5); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; CALL refresh_continuous_aggregate('measure_10', NULL, NULL, options => '{"process_hypertable_invalidations": false}'); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; -- Check that a refresh with hypertable invalidation processing -- enabled move the invalidations. CALL refresh_continuous_aggregate('measure_10', NULL, NULL, options => '{"process_hypertable_invalidations": true}'); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; -- Check that a refresh by default moves the invalidations. INSERT INTO measurements VALUES (60, 16, 12.3); INSERT INTO measurements VALUES (61, 17, 34.5); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; CALL refresh_continuous_aggregate('measure_10', NULL, NULL); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; -- Check permissions. Only owner should be able to remove policy. \set ON_ERROR_STOP 0 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 CALL remove_process_hypertable_invalidations_policy('conditions'); \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CALL remove_process_hypertable_invalidations_policy('conditions'); \set ON_ERROR_STOP 0 CALL remove_process_hypertable_invalidations_policy('conditions_10'); CALL remove_process_hypertable_invalidations_policy('conditions', if_exists => false); CALL remove_process_hypertable_invalidations_policy('conditions', if_exists => true); \set ON_ERROR_STOP 1 -- Add a policy that has hypertable invalidations processing disabled -- and check that it does not move invalidations. SELECT add_continuous_aggregate_policy('measure_10', 100::int, 10::int, '1h'::interval) as job_id \gset SELECT jsonb_set(config, '{process_hypertable_invalidations}', 'false') AS config FROM _timescaledb_config.bgw_job WHERE id = :job_id \gset SELECT jsonb_pretty(config) FROM alter_job(:job_id, config := :'config'); INSERT INTO measurements VALUES (70, 19, 12.3), (71, 20, 34.5); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; CALL run_job(:job_id); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; -- Enable invalidations and check that it now moves invalidations SELECT jsonb_pretty(config) FROM alter_job(:job_id, config := jsonb_set(:'config', '{process_hypertable_invalidations}', 'true')); CALL run_job(:job_id); SELECT hypertable, lowest_modified_value, greatest_modified_value FROM hypertable_invalidations; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_policy_run.sql�������������������������������������������������0000664�0000000�0000000�00000004274�15100345067�0022327�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- The tests in this file use mock timestamps to test policies -- for timestamp based tables and can be run only with debug builds. SET ROLE :ROLE_DEFAULT_PERM_USER; --- code coverage tests : add policy for timestamp and date based table --- CREATE TABLE continuous_agg_max_mat_date(time DATE); SELECT create_hypertable('continuous_agg_max_mat_date', 'time'); CREATE MATERIALIZED VIEW max_mat_view_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 days', time), count(*) FROM continuous_agg_max_mat_date GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('max_mat_view_date', '3 days', '1 day', '1 day'::interval) as job_id \gset SELECT config FROM _timescaledb_config.bgw_job WHERE id = :job_id; INSERT INTO continuous_agg_max_mat_date SELECT generate_series('2019-09-01'::date, '2019-09-10'::date, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; SET timescaledb.current_timestamp_mock = '2019-09-10 00:00'; CALL run_job(:job_id); SELECT * FROM max_mat_view_date order by 1; RESET client_min_messages ; DROP MATERIALIZED VIEW max_mat_view_date; CREATE TABLE continuous_agg_timestamp(time TIMESTAMP); SELECT create_hypertable('continuous_agg_timestamp', 'time'); CREATE MATERIALIZED VIEW max_mat_view_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time), count(*) FROM continuous_agg_timestamp GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('max_mat_view_timestamp', '15 days', '1 h'::interval , '1 h'::interval) as job_id \gset INSERT INTO continuous_agg_timestamp SELECT generate_series('2019-09-01 00:00'::timestamp, '2019-09-10 00:00'::timestamp, '1 day'); --- to prevent NOTICES set message level to warning SET client_min_messages TO warning; SET timescaledb.current_timestamp_mock = '2019-09-11 00:00'; CALL run_job(:job_id); SELECT * FROM max_mat_view_timestamp; RESET client_min_messages ; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_query.sql.in���������������������������������������������������0000664�0000000�0000000�00000000655�15100345067�0021715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; \set TEST_BASE_NAME cagg_query \ir include/cagg_query_common.sql �����������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_query_using_merge.sql.in���������������������������������������0000664�0000000�0000000�00000001052�15100345067�0024271�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Connect as superuser to use SET ROLE later \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET timezone TO PST8PDT; -- Run tests with default role SET ROLE :ROLE_DEFAULT_PERM_USER; -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; \set TEST_BASE_NAME cagg_query_using_merge \ir include/cagg_query_common.sql ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_refresh_using_merge.sql����������������������������������������0000664�0000000�0000000�00000015013�15100345067�0024157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Enable MERGE statements for continuous aggregate refresh SET timescaledb.enable_merge_on_cagg_refresh TO ON; SET timezone TO PST8PDT; \ir include/cagg_refresh_common.sql -- Additional tests for MERGE refresh DROP TABLE conditions CASCADE; CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION, humidity DOUBLE PRECISION ); SELECT FROM create_hypertable( 'conditions', 'time'); INSERT INTO conditions VALUES ('2018-01-01 09:20:00-08', 'SFO', 55, 45), ('2018-01-02 09:30:00-08', 'POR', 100, 100), ('2018-01-02 09:20:00-08', 'SFO', 65, 45), ('2018-01-02 09:10:00-08', 'NYC', 65, 45), ('2018-11-01 09:20:00-08', 'NYC', 45, 30), ('2018-11-01 10:40:00-08', 'NYC', 55, 35), ('2018-11-01 11:50:00-08', 'NYC', 65, 40), ('2018-11-01 12:10:00-08', 'NYC', 75, 45), ('2018-11-01 13:10:00-08', 'NYC', 85, 50), ('2018-11-02 09:20:00-08', 'NYC', 10, 10), ('2018-11-02 10:30:00-08', 'NYC', 20, 15), ('2018-11-02 11:40:00-08', 'NYC', null, null), ('2018-11-03 09:50:00-08', 'NYC', null, null); CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, location, AVG(temperature), MAX(temperature), MIN(temperature) FROM conditions GROUP BY bucket, location WITH NO DATA; -- First refresh using MERGE should fall back to INSERT SET client_min_messages TO LOG; CALL refresh_continuous_aggregate('conditions_daily', NULL, '2018-11-01 23:59:59-08'); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; -- Second refresh using MERGE should also fall back to INSERT since there's no data in the materialization hypertable CALL refresh_continuous_aggregate('conditions_daily', '2018-11-01', NULL); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; -- All data should be in the materialization hypertable CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; -- Changing past data that is not part of the cagg UPDATE conditions SET humidity = humidity + 100 WHERE time = '2018-01-02 09:20:00-08' AND location = 'SFO'; -- Shoudn't affect the materialization hypertable (merged=0 and deleted=0) CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; -- Backfill some data in the past INSERT INTO conditions VALUES ('2017-01-01 09:20:00-08', 'GRU', 55, 45), ('2017-01-01 09:30:00-08', 'POA', 100, 100), ('2017-01-02 09:20:00-08', 'CNF', 65, 45); -- There's no data in the affected range so the refresh should fall back to INSERT CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; -- Update already materilized data in the past UPDATE conditions SET temperature = temperature + 100 WHERE time = '2018-11-02 10:30:00-08' AND location = 'NYC'; -- Should merge 1 bucket (merged=1 and deleted=0) CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; -- Delete one entire bucket DELETE FROM conditions WHERE time >= '2018-11-02' AND time < '2018-11-03' AND location = 'NYC'; -- Should not merge any bucket but delete one bucket (merged=0 and deleted=1) CALL refresh_continuous_aggregate('conditions_daily', NULL, NULL); SELECT * FROM conditions_daily ORDER BY 1, 2, 3 NULLS LAST, 4 NULLS LAST, 5 NULLS LAST; DROP TABLE conditions CASCADE; -- -- A nullable conditions test -- CREATE TABLE conditions_nullable ( time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION ); CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT, temperature DOUBLE PRECISION, humidity DOUBLE PRECISION ); SELECT FROM create_hypertable( 'conditions', 'time'); INSERT INTO conditions VALUES ('2018-01-01 09:20:00-08', 'SFO', 55), ('2018-01-02 09:30:00-08', null, 100); CREATE MATERIALIZED VIEW conditions_nullable_daily WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 day', time) AS bucket, location, AVG(temperature) FROM conditions GROUP BY bucket, location WITH NO DATA; -- First refresh using MERGE should fall back to INSERT SET client_min_messages TO LOG; CALL refresh_continuous_aggregate('conditions_nullable_daily', NULL, '2018-11-01 23:59:59-08'); RESET client_min_messages; SELECT * FROM conditions_nullable_daily ORDER BY 1, 2 NULLS LAST, 3 NULLS LAST; -- Inserting a new data should ensure we get correct results INSERT INTO conditions VALUES ('2018-01-01 19:20:00-08', 'SFO', 65), ('2018-01-02 19:30:00-08', null, 200); -- Second refresh *should* use the merge, and return correct results. SET client_min_messages TO LOG; CALL refresh_continuous_aggregate('conditions_nullable_daily', NULL, '2018-11-01 23:59:59-08'); RESET client_min_messages; SELECT * FROM conditions_nullable_daily ORDER BY 1, 2 NULLS LAST, 3 NULLS LAST; DROP MATERIALIZED VIEW conditions_nullable_daily; DROP TABLE conditions CASCADE; -- test cagg refresh with updated values CREATE TABLE metrics(time timestamptz NOT NULL, device text, value float8) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO metrics SELECT time, 'd'||device::text, 1 FROM generate_series('2025-02-05 17:00+00'::timestamptz,'2025-02-05 19:00+00'::timestamptz, '5 min'::interval) AS g(time), generate_series(1, 10) AS device; CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous) AS SELECT device, time_bucket('00:05:00'::interval, time) AS bucket, sum(value) AS value FROM metrics GROUP BY 1, 2; UPDATE metrics SET value = value - 1 WHERE device='d1' and time ='2025-02-05 17:40:00+00'; CALL refresh_continuous_aggregate('metrics_summary', '2025-02-04', '2025-02-10'); SET enable_bitmapscan TO off; SET enable_seqscan TO true; SET enable_indexscan TO false; -- should be 250 SELECT count(*) FROM metrics_summary WHERE bucket >= '2025-02-05 17:00:00+00' AND bucket < '2025-02-05 23:00:00+00'; SET enable_seqscan TO false; SET enable_indexscan TO true; -- should match the result of the previous query SELECT count(*) FROM metrics_summary WHERE bucket >= '2025-02-05 17:00:00+00' AND bucket < '2025-02-05 23:00:00+00'; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_refresh_using_trigger.sql��������������������������������������0000664�0000000�0000000�00000000367�15100345067�0024531�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; \ir include/cagg_refresh_common.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_refresh_using_wal.sql������������������������������������������0000664�0000000�0000000�00000000463�15100345067�0023646�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO PST8PDT; SET timescaledb.enable_cagg_wal_based_invalidation TO true; \ir include/cagg_refresh_common.sql �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_repair.sql.in��������������������������������������������������0000664�0000000�0000000�00000007054�15100345067�0022032�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO PST8PDT; CREATE PROCEDURE _timescaledb_internal.cagg_try_repair ( cagg_view REGCLASS, force_rebuild BOOLEAN ) AS :MODULE_PATHNAME, 'ts_cagg_try_repair' LANGUAGE C SET client_min_messages TO DEBUG1; CREATE TABLE conditions ( "time" TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INTEGER NOT NULL, device_id INTEGER NOT NULL ); SELECT table_name FROM create_hypertable('conditions', 'time'); INSERT INTO conditions ("time", city, temperature, device_id) VALUES ('2021-06-14 00:00:00-00', 'Moscow', 26,1), ('2021-06-15 00:00:00-00', 'Berlin', 22,2), ('2021-06-16 00:00:00-00', 'Stockholm', 24,3), ('2021-06-17 00:00:00-00', 'London', 24,4), ('2021-06-18 00:00:00-00', 'London', 27,4), ('2021-06-19 00:00:00-00', 'Moscow', 28,4), ('2021-06-20 00:00:00-00', 'Moscow', 30,1), ('2021-06-21 00:00:00-00', 'Berlin', 31,1), ('2021-06-22 00:00:00-00', 'Stockholm', 34,1), ('2021-06-23 00:00:00-00', 'Stockholm', 34,2), ('2021-06-24 00:00:00-00', 'Moscow', 34,2), ('2021-06-25 00:00:00-00', 'London', 32,3), ('2021-06-26 00:00:00-00', 'Moscow', 32,3), ('2021-06-27 00:00:00-00', 'Moscow', 31,3); CREATE TABLE devices ( id INTEGER NOT NULL, name TEXT, location TEXT ); INSERT INTO devices (id, name, location) VALUES (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'), (3, 'thermo_3', 'London'), (4, 'thermo_4', 'Stockholm'); CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, devices.name AS device_name, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions JOIN devices ON devices.id = conditions.device_id GROUP BY 1, 2 WITH NO DATA; \d+ conditions_summary CALL refresh_continuous_aggregate('conditions_summary', NULL, '2021-06-22 00:00:00-00'); SELECT * FROM conditions_summary ORDER BY bucket, device_name; -- Execute repair for materialized only cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); \d+ conditions_summary SELECT * FROM conditions_summary ORDER BY bucket, device_name; CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); \d+ conditions_summary SELECT * FROM conditions_summary ORDER BY bucket, device_name; -- Switch to realtime cagg ALTER MATERIALIZED VIEW conditions_summary SET (timescaledb.materialized_only=false); \d+ conditions_summary SELECT * FROM conditions_summary ORDER BY bucket, device_name; -- Execute repair for realtime cagg CALL _timescaledb_internal.cagg_try_repair('conditions_summary', FALSE); \d+ conditions_summary SELECT * FROM conditions_summary ORDER BY bucket, device_name; CALL _timescaledb_internal.cagg_try_repair('conditions_summary', TRUE); \d+ conditions_summary SELECT * FROM conditions_summary ORDER BY bucket, device_name; -- Tests without join CREATE MATERIALIZED VIEW conditions_summary_nojoin WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(INTERVAL '1 week', "time") AS bucket, MIN(temperature), MAX(temperature), SUM(temperature) FROM conditions GROUP BY 1 WITH NO DATA; CALL _timescaledb_internal.cagg_try_repair('conditions_summary_nojoin', TRUE); \d+ conditions_summary_nojoin DROP PROCEDURE _timescaledb_internal.cagg_try_repair (REGCLASS, BOOLEAN); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_tableam.sql����������������������������������������������������0000664�0000000�0000000�00000004720�15100345067�0021545�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE VIEW cagg_info AS WITH caggs AS ( SELECT format('%I.%I', user_view_schema, user_view_name)::regclass AS user_view, format('%I.%I', ht.schema_name, ht.table_name)::regclass AS mat_relid FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.continuous_agg cagg WHERE ht.id = cagg.mat_hypertable_id ) SELECT user_view, relname AS mat_table, (SELECT spcname FROM pg_tablespace WHERE oid = reltablespace) AS tablespace FROM pg_class JOIN caggs ON pg_class.oid = caggs.mat_relid; CREATE TABLE whatever(time BIGINT NOT NULL, data INTEGER); SELECT hypertable_id AS whatever_nid FROM create_hypertable('whatever', 'time', chunk_time_interval => 10) \gset CREATE OR REPLACE FUNCTION integer_now_test() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), bigint '0') FROM whatever $$; SELECT set_integer_now_func('whatever', 'integer_now_test'); INSERT INTO whatever SELECT i, i FROM generate_series(0, 29) AS i; -- Checking that the access method for the materialized hypertable is -- set to the correct access method. CREATE MATERIALIZED VIEW tableam_view USING heap2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW notableam_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('5', time), COUNT(data) FROM whatever GROUP BY 1 WITH NO DATA; SELECT user_view, mat_table, amname FROM cagg_info, LATERAL (SELECT relam FROM pg_class WHERE relname = mat_table) AS cls, LATERAL (SELECT amname FROM pg_am WHERE oid = relam) AS am WHERE user_view::text IN ('tableam_view', 'notableam_view'); -- Check that the view with the other access method actually works. SELECT * FROM notableam_view ORDER BY 1; SELECT * FROM tableam_view ORDER BY 1; CALL refresh_continuous_aggregate('notableam_view', NULL, NULL); CALL refresh_continuous_aggregate('tableam_view', NULL, NULL); SELECT * FROM notableam_view ORDER BY 1; SELECT * FROM tableam_view ORDER BY 1; DROP MATERIALIZED VIEW notableam_view; DROP MATERIALIZED VIEW tableam_view; ������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_union_view.sql.in����������������������������������������������0000664�0000000�0000000�00000047230�15100345067�0022732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- disable background workers to make results reproducible \c :TEST_DBNAME :ROLE_SUPERUSER SELECT _timescaledb_functions.stop_background_workers(); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO PST8PDT; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE metrics(f1 int, f2 int, time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('metrics','time'); ALTER TABLE metrics DROP COLUMN f1; INSERT INTO metrics(time, device_id, value) SELECT '2000-01-01'::timestamptz, device_id, 0.5 FROM generate_series(1,3) g(device_id); -- -- test switching continuous agg view between different modes -- -- check default view for new continuous aggregate CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; ALTER TABLE metrics DROP COLUMN f2; -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- upgrade view to union view again ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- try upgrade view to union view that is already union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- refresh CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); -- result should not change after refresh for union view SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); -- view should have results now after refresh SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; DROP MATERIALIZED VIEW metrics_summary; -- check default view for new continuous aggregate with materialized_only to true CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- upgrade view to union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- this should be union view SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- downgrade view to non-union view ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- this should be view without union SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; SELECT pg_get_viewdef('metrics_summary',true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; DROP MATERIALIZED VIEW metrics_summary; -- -- test queries on union view -- CREATE MATERIALIZED VIEW metrics_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1d',time), avg(value) FROM metrics GROUP BY 1 WITH NO DATA; -- should be marked as materialized_only in catalog SELECT user_view_name, materialized_only FROM _timescaledb_catalog.continuous_agg WHERE user_view_name='metrics_summary'; -- query should not have results since cagg is materialized only and no refresh has happened yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); -- after switch to union view all results should be returned SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; CALL refresh_continuous_aggregate('metrics_summary', NULL, NULL); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); -- materialized only view should return data now too because refresh has happened SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- add some more data INSERT INTO metrics(time, device_id, value) SELECT '2000-02-01'::timestamptz, device_id, device_id/10.0 FROM generate_series(1,3) g(device_id); -- materialized only view should not have new data yet SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- but union view should ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=false); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- and after refresh non union view should have new data too CALL refresh_continuous_aggregate('metrics_summary', NULL, '2000-01-30'); ALTER MATERIALIZED VIEW metrics_summary SET (timescaledb.materialized_only=true); SELECT time_bucket,avg FROM metrics_summary ORDER BY 1; -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION boundary_test_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; -- test watermark interaction with just in time aggregates CREATE TABLE boundary_test(time int, value float); SELECT create_hypertable('boundary_test','time',chunk_time_interval:=10); SELECT set_integer_now_func('boundary_test','boundary_test_int_now'); CREATE MATERIALIZED VIEW boundary_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM boundary_test GROUP BY 1 WITH NO DATA; INSERT INTO boundary_test SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); SELECT mat_hypertable_id AS boundary_view_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'boundary_view' \gset -- watermark should be NULL SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); -- first UNION child should have no rows because no materialization has happened yet and 2nd child should have 4 rows :PREFIX SELECT * FROM boundary_view; -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; -- Refresh up to 30 to leave some unmaterialized data at the head and -- thus have something to union. CALL refresh_continuous_aggregate('boundary_view', NULL, 30); -- watermark should be 30 SELECT _timescaledb_functions.cagg_watermark(:boundary_view_id); -- both sides of the UNION should return 2 rows :PREFIX SELECT * FROM boundary_view; -- result should have 4 rows SELECT * FROM boundary_view ORDER BY time_bucket; ---- TEST union view with WHERE, GROUP BY and HAVING clause ---- create table ht_intdata (a integer, b integer, c integer); select table_name FROM create_hypertable('ht_intdata', 'a', chunk_time_interval=> 10); INSERT into ht_intdata values( 3 , 16 , 20); INSERT into ht_intdata values( 1 , 10 , 20); INSERT into ht_intdata values( 1 , 11 , 20); INSERT into ht_intdata values( 1 , 12 , 20); INSERT into ht_intdata values( 1 , 13 , 20); INSERT into ht_intdata values( 1 , 14 , 20); INSERT into ht_intdata values( 2 , 14 , 20); INSERT into ht_intdata values( 2 , 15 , 20); INSERT into ht_intdata values( 2 , 16 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 20 , 26 , 20); INSERT into ht_intdata values( 20 , 16 , 20); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); INSERT into ht_intdata values( 21 , 15 , 30); CREATE OR REPLACE FUNCTION integer_now_ht_intdata() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM ht_intdata $$; SELECT set_integer_now_func('ht_intdata', 'integer_now_ht_intdata'); CREATE MATERIALIZED VIEW mat_m1(a, countb, sumbc, spreadcb, avgc) WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 WITH NO DATA; -- Do partial refresh to have something to union CALL refresh_continuous_aggregate('mat_m1', NULL, 11); --results from real time cont.agg and direct query should match SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; SELECT * FROM mat_m1 ORDER BY 1; --verify that materialized only doesn't have rows with a> 20 ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = true); SELECT * FROM mat_m1 ORDER BY 1; --again revert the view to include real time aggregates ALTER MATERIALIZED VIEW mat_m1 SET(timescaledb.materialized_only = false); INSERT into ht_intdata values( 31 , 15 , 30); INSERT into ht_intdata values( 31 , 14 , 70); --cagg was not refreshed, should include all rows SELECT * FROM mat_m1 ORDER BY 1; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); SELECT * FROM mat_m1 ORDER BY 1; --the selects against mat_m1 before and after refresh should match this query SELECT time_bucket(1, a), count(*), sum(b+c), max(c)-min(b), avg(c)::int FROM ht_intdata WHERE b < 16 GROUP BY time_bucket(1, a) HAVING sum(c) > 50 ORDER BY 1; DROP MATERIALIZED VIEW mat_m1; --- TEST union view with multiple WHERE and HAVING clauses CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 WITH NO DATA; INSERT into ht_intdata values( 42 , 15 , 80); INSERT into ht_intdata values( 42 , 15 , 18); INSERT into ht_intdata values( 41 , 18 , 21); -- Do partial refresh so that we leave data to UNION CALL refresh_continuous_aggregate('mat_m1', NULL, 25); SELECT mat_hypertable_id AS mat_m1_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'mat_m1' \gset -- Show the new watermark SELECT _timescaledb_functions.cagg_watermark(:mat_m1_id); -- Data inserted after refresh and after cagg_watermark should be -- reflected in the real-time aggregation INSERT into ht_intdata VALUES (34, 13, 65), (26, 12, 78), (28, 9, 32); --view and direct query should return same results SELECT * from mat_m1 ORDER BY 1; SELECT time_bucket(5, a), sum(b+c) FROM ht_intdata WHERE b < 16 and c > 20 GROUP BY time_bucket(5, a) HAVING sum(c) > 50 and avg(b)::int > 12 ORDER by 1; -- plan output :PREFIX SELECT * FROM mat_m1 ORDER BY 1; -- Test caggs with different time types CREATE TABLE smallint_table (time smallint, value int); CREATE TABLE int_table (time int, value int); CREATE TABLE bigint_table (time bigint, value int); CREATE TABLE date_table (time date, value int); CREATE TABLE timestamp_table (time timestamp, value int); CREATE TABLE timestamptz_table (time timestamptz, value int); SELECT create_hypertable('smallint_table', 'time', chunk_time_interval=>20); SELECT create_hypertable('int_table', 'time', chunk_time_interval=>20); SELECT create_hypertable('bigint_table', 'time', chunk_time_interval=>20); SELECT create_hypertable('date_table', 'time'); SELECT create_hypertable('timestamp_table', 'time'); SELECT create_hypertable('timestamptz_table', 'time'); CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM smallint_table $$; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM int_table $$; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM bigint_table $$; SELECT set_integer_now_func('smallint_table', 'smallint_now'); SELECT set_integer_now_func('int_table', 'int_now'); SELECT set_integer_now_func('bigint_table', 'bigint_now'); CREATE MATERIALIZED VIEW smallint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(SMALLINT '10', time) AS bucket, avg(value) FROM smallint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW int_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(5, time) AS bucket, avg(value) FROM int_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW bigint_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(BIGINT '10', time) AS bucket, avg(value) FROM bigint_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW date_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM date_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamp_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamp_table GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW timestamptz_agg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('2 days', time) AS bucket, avg(value) FROM timestamptz_table GROUP BY 1 WITH NO DATA; -- Refresh first without data CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks at min for the above caggs: SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id), _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id), _timescaledb_functions.cagg_watermark(mat_hypertable_id) = _timescaledb_functions.cagg_watermark_materialized(mat_hypertable_id) AS is_equal FROM _timescaledb_catalog.continuous_agg NATURAL JOIN _timescaledb_catalog.continuous_aggs_watermark ORDER BY 1, 2, 3; INSERT INTO smallint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO int_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO bigint_table VALUES (1, 1), (2, 2), (6, 6), (8, 8), (19, 19); INSERT INTO date_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamp_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); INSERT INTO timestamptz_table VALUES ('2020-01-01', 1), ('2020-01-02', 2), ('2020-01-06', 6), ('2020-01-08', 8); -- Refresh to move the watermarks CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks should reflect the new materializations SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; -- Test overflow of valid ranges by inserting values close to the max -- supported time values. Adding one bucket to these values overflow -- the valid time ranges so the watermark should end up at the end of -- valid range for the type. INSERT INTO smallint_table VALUES (32765, 1); INSERT INTO int_table VALUES (2147483645, 1); INSERT INTO bigint_table VALUES (9223372036854775804, 1); INSERT INTO date_table VALUES ('294247-01-01', 1); INSERT INTO timestamp_table VALUES ('294247-01-01 00:00:00-00', 1); INSERT INTO timestamptz_table VALUES ('294247-01-01 00:00:00-00', 1); CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); -- Watermarks after refresh hould be at the end of the valid range for -- the time type SELECT user_view_name, _timescaledb_functions.cagg_watermark(mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg ORDER BY 1,2; -- Querying the aggs should work even when fully materialized SELECT * FROM smallint_agg ORDER BY 1,2; SELECT * FROM int_agg ORDER BY 1,2; SELECT * FROM bigint_agg ORDER BY 1,2; SELECT * FROM date_agg ORDER BY 1,2; SELECT * FROM timestamp_agg ORDER BY 1,2; SELECT * FROM timestamptz_agg ORDER BY 1,2; \set ON_ERROR_STOP 0 ------------------------------------- -- Test invalid inputs for cagg_watermark ------------------------------------- -- Non-existing materialized hypertable SELECT _timescaledb_functions.cagg_watermark(100); -- NULL hypertable ID. Function is STRICT, so does nothing: SELECT _timescaledb_functions.cagg_watermark(NULL); \set ON_ERROR_STOP 1 -- Remove stored watermark, so query and refresh should error \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_aggs_watermark; \set ON_ERROR_STOP 0 SELECT * FROM smallint_agg ORDER BY 1,2; SELECT * FROM int_agg ORDER BY 1,2; SELECT * FROM bigint_agg ORDER BY 1,2; SELECT * FROM date_agg ORDER BY 1,2; SELECT * FROM timestamp_agg ORDER BY 1,2; SELECT * FROM timestamptz_agg ORDER BY 1,2; CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); \set ON_ERROR_STOP 1 -- Fix all continuous aggregates inserting materialized watermark into the metadata table INSERT INTO _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) SELECT a.mat_hypertable_id, _timescaledb_functions.cagg_watermark_materialized(a.mat_hypertable_id) FROM _timescaledb_catalog.continuous_agg a LEFT JOIN _timescaledb_catalog.continuous_aggs_watermark b ON b.mat_hypertable_id = a.mat_hypertable_id WHERE b.mat_hypertable_id IS NULL ORDER BY 1; SELECT * FROM smallint_agg ORDER BY 1,2; SELECT * FROM int_agg ORDER BY 1,2; SELECT * FROM bigint_agg ORDER BY 1,2; SELECT * FROM date_agg ORDER BY 1,2; SELECT * FROM timestamp_agg ORDER BY 1,2; SELECT * FROM timestamptz_agg ORDER BY 1,2; CALL refresh_continuous_aggregate('int_agg', NULL, NULL); CALL refresh_continuous_aggregate('smallint_agg', NULL, NULL); CALL refresh_continuous_aggregate('bigint_agg', NULL, NULL); CALL refresh_continuous_aggregate('date_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamp_agg', NULL, NULL); CALL refresh_continuous_aggregate('timestamptz_agg', NULL, NULL); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_usage.sql.in���������������������������������������������������0000664�0000000�0000000�00000044045�15100345067�0021655�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST SETUP -- \set ON_ERROR_STOP 0 SET client_min_messages TO NOTICE; SET work_mem TO '64MB'; SET timezone TO PST8PDT; SELECT _timescaledb_functions.invalidation_plugin_name() AS plugin_name \gset CREATE VIEW invalidation_slots AS SELECT * FROM pg_replication_slots WHERE plugin = :'plugin_name'; -- START OF USAGE TEST -- --First create your hypertable CREATE TABLE device_readings ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('device_readings', 'observation_time'); --Next, create your continuous aggregate view CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) --This flag is what makes the view continuous AS SELECT time_bucket('1 hour', observation_time) as bucket, --time_bucket is required device_id, avg(metric) as metric_avg, --We can use regular aggregates max(metric)-min(metric) as metric_spread --We can also use expressions on aggregates and constants FROM device_readings GROUP BY bucket, device_id WITH NO DATA; --We have to group by the bucket column, but can also add other group-by columns SELECT add_continuous_aggregate_policy('device_summary', NULL, '2 h'::interval, '2 h'::interval); --Next, insert some data into the raw hypertable INSERT INTO device_readings SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO device_readings SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; --Initially, it will be empty. SELECT * FROM device_summary; -- Simulate a policy that refreshes with lag, i.e., it doesn't refresh -- the entire data set. In this case up to the given date. CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-30 22:00'); --Now you can run selects over your view as normal SELECT * FROM device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; --You can view informaton about your continuous aggregates. The meaning of these fields will be explained further down. \x SELECT * FROM timescaledb_information.continuous_aggregates; \x -- Refresh interval -- -- The refresh interval determines how often the background worker -- for automatic materialization will run. The default is (2 x bucket_width) SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; -- You can change this setting with ALTER VIEW (equivalently, specify in WITH clause of CREATE VIEW) SELECT alter_job(1000, schedule_interval := '1h'); SELECT schedule_interval FROM _timescaledb_config.bgw_job WHERE id = 1000; -- -- Refresh with lag -- -- It is possible to use a policy or manual refresh with a lag, which -- means the materialization will not contain the most up-to-date -- data. SELECT max(observation_time) FROM device_readings; SELECT max(bucket) FROM device_summary; CALL refresh_continuous_aggregate('device_summary', NULL, '2018-12-31 01:00'); SELECT max(observation_time) FROM device_readings; SELECT max(bucket) FROM device_summary; -- -- Invalidations -- --Changes to the raw table, for values that have already been materialized are propagated asynchronously, after the materialization next runs. --Before update: SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; INSERT INTO device_readings VALUES ('Sun Dec 30 13:01:00 2018 PST', 'device_1', 1.0); --Change not reflected before materializer runs. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; CALL refresh_continuous_aggregate('device_summary', NULL, NULL); --But is reflected after. SELECT * FROM device_summary WHERE device_id = 'device_1' and bucket = 'Sun Dec 30 13:00:00 2018 PST'; -- -- Dealing with timezones -- -- You have three options: -- Option 1: be explicit in your timezone: DROP MATERIALIZED VIEW device_summary; CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time AT TIME ZONE 'EST') as min_time, --note the explict timezone device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; DROP MATERIALIZED VIEW device_summary; -- Option 2: Keep things as TIMESTAMPTZ in the view and convert to local time when -- querying from the view DROP MATERIALIZED VIEW device_summary; CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time) as min_time, --this is a TIMESTAMPTZ device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH DATA; SELECT min(min_time)::timestamp FROM device_summary; -- Option 3: use stable expressions in the cagg definition -- in this case it is up to the user to ensure cagg refreshes -- run with consistent values DROP MATERIALIZED VIEW device_summary; CREATE MATERIALIZED VIEW device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', observation_time) as bucket, min(observation_time::timestamp) as min_time, --note the cast to localtime device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM device_readings GROUP BY bucket, device_id WITH NO DATA; -- -- test just in time aggregate / materialization only view -- -- hardcoding now to 50 will lead to 30 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 50; $BODY$; CREATE TABLE device_readings_int(time int, value float); SELECT create_hypertable('device_readings_int','time',chunk_time_interval:=10); SELECT set_integer_now_func('device_readings_int','device_readings_int_now'); CREATE MATERIALIZED VIEW device_readings_mat_only WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW device_readings_jit WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket(10,time), avg(value) FROM device_readings_int GROUP BY 1 WITH NO DATA; INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(10,40,10) AS g(i); -- materialization only should have 0 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; -- simulate a refresh policy with lag, i.e., one that doesn't refresh -- up to the latest data. Max value is 40. CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, 30); CALL refresh_continuous_aggregate('device_readings_jit', NULL, 30); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; -- jit aggregate should have 4 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; -- add 2 more rows INSERT INTO device_readings_int SELECT i, i*10 FROM generate_series(50,60,10) AS g(i); -- materialization only should have 2 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; -- hardcoding now to 100 will lead to 80 watermark CREATE OR REPLACE FUNCTION device_readings_int_now() RETURNS INT LANGUAGE SQL STABLE AS $BODY$ SELECT 100; $BODY$; -- refresh should materialize all now CALL refresh_continuous_aggregate('device_readings_mat_only', NULL, NULL); CALL refresh_continuous_aggregate('device_readings_jit', NULL, NULL); -- materialization only should have 6 rows SELECT * FROM device_readings_mat_only ORDER BY time_bucket; -- jit aggregate should have 6 rows SELECT * FROM device_readings_jit ORDER BY time_bucket; -- START OF BASIC USAGE TESTS -- -- Check that continuous aggregate and materialized table is dropped -- together. CREATE TABLE whatever(time TIMESTAMPTZ NOT NULL, metric INTEGER); SELECT * FROM create_hypertable('whatever', 'time'); CREATE MATERIALIZED VIEW whatever_summary WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, avg(metric) FROM whatever GROUP BY bucket WITH NO DATA; SELECT (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = raw_hypertable_id) AS raw_table , (SELECT format('%1$I.%2$I', schema_name, table_name)::regclass::oid FROM _timescaledb_catalog.hypertable WHERE id = mat_hypertable_id) AS mat_table FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'whatever_summary' \gset SELECT relname FROM pg_class WHERE oid = :mat_table; ---------------------------------------------------------------- -- Should generate an error since the cagg is dependent on the table. DROP TABLE whatever; ---------------------------------------------------------------- -- Checking that a cagg cannot be dropped if there is a dependent -- object on it. CREATE VIEW whatever_summary_dependency AS SELECT * FROM whatever_summary; -- Should generate an error DROP MATERIALIZED VIEW whatever_summary; -- Dropping the dependent view so that we can do a proper drop below. DROP VIEW whatever_summary_dependency; ---------------------------------------------------------------- -- Dropping the cagg should also remove the materialized table DROP MATERIALIZED VIEW whatever_summary; SELECT relname FROM pg_class WHERE oid = :mat_table; ---------------------------------------------------------------- -- Cleanup DROP TABLE whatever; -- END OF BASIC USAGE TESTS -- CREATE TABLE metrics(time timestamptz, device TEXT, value float); SELECT table_name FROM create_hypertable('metrics','time'); INSERT INTO metrics SELECT generate_series('1999-12-20'::timestamptz,'2000-02-01'::timestamptz,'12 day'::interval), 'dev1', 0.25; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time, 'PST8PDT') FROM metrics GROUP BY 1; SELECT * FROM cagg1; CREATE MATERIALIZED VIEW cagg2 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT') FROM metrics GROUP BY 1; SELECT * FROM cagg2; -- custom origin with variable size CREATE MATERIALIZED VIEW cagg3 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', '2000-01-01'::timestamptz) FROM metrics GROUP BY 1; SELECT * FROM cagg3; -- offset with variable size CREATE MATERIALIZED VIEW cagg4 WITH (timescaledb.continuous,timescaledb.materialized_only=true) AS SELECT time_bucket('1 month', time, 'PST8PDT', "offset":= INTERVAL '15 day') FROM metrics GROUP BY 1; SELECT * FROM cagg4; -- -- drop chunks tests -- -- should return 4 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; -- all caggs in the new format (finalized=true) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; -- dropping chunk should also remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-01 00:00:00-02'::timestamptz); -- should return 3 chunks SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'metrics' ORDER BY 1; -- let's update the catalog to fake an old format cagg (finalized=false) \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_agg SET finalized=FALSE WHERE user_view_name = 'cagg1'; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- cagg1 now is a fake old format (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; -- cagg1 now is in the old format (finalized=false) -- dropping chunk should NOT remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-13 00:00:00-02'::timestamptz); -- should return 3 chunks and one of them should be marked as dropped SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; -- remove the fake old format cagg DROP MATERIALIZED VIEW cagg1; -- no more old format caggs (finalized=false) SELECT user_view_name, finalized FROM _timescaledb_catalog.continuous_agg WHERE user_view_name in ('cagg1', 'cagg2', 'cagg3', 'cagg4') ORDER BY 1; -- dropping chunk should remove the catalog data SELECT drop_chunks('metrics', older_than => '2000-01-25 00:00:00-02'::timestamptz); -- should return 2 chunks and one of them should be marked as dropped -- because we dropped chunk before when an old format cagg exists SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; \set ON_ERROR_STOP 1 SELECT count(*) FROM invalidation_slots WHERE database = current_database(); CREATE TABLE magic1(time timestamptz not null, device int, value float); CREATE TABLE magic2(time timestamptz not null, device int, value float); CREATE TABLE magic3(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('magic1','time'); SELECT table_name FROM create_hypertable('magic2','time'); SELECT table_name FROM create_hypertable('magic3','time'); INSERT INTO magic1 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic2 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); INSERT INTO magic3 SELECT generate_series('1999-12-20'::timestamptz, '2000-02-01'::timestamptz, '12 day'::interval), (100 * random())::int, 100 * random(); SELECT count(*) FROM invalidation_slots WHERE database = current_database(); -- Creating a materialized view with a failure between adding the slot -- and finishing adding the slot should not leave a slot around. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE bad(time timestamptz not null, device int, value float); SELECT table_name FROM create_hypertable('bad','time'); -- We create such an error by setting the hypertable id sequence -- number to an already existing one, which will generate an error -- when adding the new hypertable data to the catalog. select currval('_timescaledb_catalog.hypertable_id_seq') - 1 as prev_htid \gset select setval('_timescaledb_catalog.hypertable_id_seq', :prev_htid, false); \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW bad_summary_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM bad GROUP BY 1,2; \set ON_ERROR_STOP 1 -- There should be no replication slot around. SELECT count(*) FROM invalidation_slots WHERE database = current_database(); -- Advance the sequence again to consume the value we set before. SELECT FROM nextval('_timescaledb_catalog.hypertable_id_seq'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_cagg_wal_based_invalidation TO true; -- Test the option "invalidate_using". This should create the continuous -- aggregate and there should be a replication slot. CREATE MATERIALIZED VIEW magic1_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; SELECT count(*) FROM invalidation_slots WHERE database = current_database(); -- Create another continuous aggregate on the same hypertable to be -- able to check that the slot remains after one continuous aggregate -- has been dropped. CREATE MATERIALIZED VIEW magic1_summary2_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic1 GROUP BY 1,2; SELECT count(*) FROM invalidation_slots WHERE database = current_database(); -- Create another continuous aggregate on a different hypertable that -- uses WAL-based invalidation collection. This is used to check that -- the slot stays when we remove all continuous aggregates for a -- hypertable. CREATE MATERIALIZED VIEW magic2_summary1_wal WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time), device, avg(value) FROM magic2 GROUP BY 1,2; SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); DROP MATERIALIZED VIEW magic2_summary1_wal; -- Slot should be there. We have another hypertable using WAL-based -- invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); DROP MATERIALIZED VIEW magic1_summary1_wal; -- Slot should be there. We have yet another continuous aggregate for -- the hypertable using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); DROP MATERIALIZED VIEW magic1_summary2_wal; -- Now slot should be gone and we should not have any continuous -- aggregates using WAL-based invalidation collection. SELECT count(*) FROM pg_replication_slots WHERE plugin = :'plugin_name' AND database = current_database(); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/cagg_utils.sql������������������������������������������������������0000664�0000000�0000000�00000023756�15100345067�0021312�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET search_path TO public, _timescaledb_functions; SET timezone TO PST8PDT; CREATE TABLE devices ( id INTEGER, name TEXT ); CREATE TABLE metrics ( "time" TIMESTAMPTZ NOT NULL, device_id INTEGER, value FLOAT8 ); SELECT table_name FROM create_hypertable('metrics', 'time'); -- fixed bucket size CREATE MATERIALIZED VIEW metrics_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, count(*) FROM metrics GROUP BY 1 WITH NO DATA; -- variable bucket size CREATE MATERIALIZED VIEW metrics_by_month WITH (timescaledb.continuous) AS SELECT time_bucket('1 month', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 WITH NO DATA; -- -- ERRORS -- -- return NULL SELECT * FROM cagg_validate_query(NULL); -- nothing to parse SELECT * FROM cagg_validate_query(''); SELECT * FROM cagg_validate_query('--'); SELECT * FROM cagg_validate_query(';'); -- syntax error SELECT * FROM cagg_validate_query('blahh'); SELECT * FROM cagg_validate_query($$ SELECT time_bucket(blahh "time") FROM metrics GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour' "time") FROM metrics GROUP BY $$); -- multiple statements are not allowed SELECT * FROM cagg_validate_query($$ SELECT 1; SELECT 2; $$); -- only SELECT queries are allowed SELECT * FROM cagg_validate_query($$ DELETE FROM pg_catalog.pg_class $$); SELECT * FROM cagg_validate_query($$ UPDATE pg_catalog.pg_class SET relkind = 'r' $$); SELECT * FROM cagg_validate_query($$ DELETE FROM pg_catalog.pg_class $$); SELECT * FROM cagg_validate_query($$ VACUUM (ANALYZE) $$); -- invalid queries SELECT * FROM cagg_validate_query($$ SELECT 1 $$); SELECT * FROM cagg_validate_query($$ SELECT 1 FROM pg_catalog.pg_class $$); SELECT * FROM cagg_validate_query($$ SELECT relkind, count(*) FROM pg_catalog.pg_class GROUP BY 1 $$); -- time_bucket with offset is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", "offset" => '-1 minute'::interval), count(*) FROM metrics GROUP BY 1 $$); -- time_bucket with origin is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", origin => '2023-01-01'::timestamptz), count(*) FROM metrics GROUP BY 1 $$); -- time_bucket with origin is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", origin => '2023-01-01'::timestamptz), count(*) FROM metrics GROUP BY 1 $$); -- time_bucket_gapfill is not allowed SELECT * FROM cagg_validate_query($$ SELECT time_bucket_gapfill('1 hour', "time"), count(*) FROM metrics GROUP BY 1 $$); -- invalid join queries SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', a."time"), count(*) FROM metrics a, metrics b GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), count(*) FROM metrics, devices a, devices b GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics LEFT JOIN devices ON id = device_id GROUP BY 1, 2 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id = device_id AND name = 'foo' GROUP BY 1, 2 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id < device_id GROUP BY 1, 2 $$); -- invalid caggs on caggs SELECT * FROM cagg_validate_query($$ SELECT time_bucket('60 days', bucket) AS bucket, sum(count) AS count FROM metrics_by_month GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 day 33 minutes', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 $$); -- -- OK -- -- valid join queries SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id = device_id GROUP BY 1, 2 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), device_id, count(*) FROM metrics JOIN devices ON id = device_id WHERE devices.name = 'foo' GROUP BY 1, 2 $$); -- valid queries SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time"), count(*) FROM metrics GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", timezone => 'UTC'), count(*) FROM metrics GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 hour', "time", timezone => 'UTC'), count(*) FROM metrics GROUP BY 1 HAVING count(*) > 1 $$); -- caggs on caggs SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 day', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 month', bucket) AS bucket, sum(count) AS count FROM metrics_by_hour GROUP BY 1 $$); SELECT * FROM cagg_validate_query($$ SELECT time_bucket('1 year', bucket) AS bucket, sum(count) AS count FROM metrics_by_month GROUP BY 1 $$); -- -- Test bucket Oid recovery -- SET timezone TO PST8PDT; CREATE TABLE timestamp_ht ( time timestamp NOT NULL, value float ); SELECT create_hypertable('timestamp_ht', 'time'); INSERT INTO timestamp_ht SELECT time, ceil(random() * 100)::int FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW temperature_4h WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM timestamp_ht GROUP BY 1 ORDER BY 1; CREATE TABLE timestamptz_ht ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('timestamptz_ht', 'time'); INSERT INTO timestamptz_ht SELECT time, ceil(random() * 100)::int FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-01 23:59:59+0','1m') time; CREATE MATERIALIZED VIEW temperature_tz_4h WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_tz_4h_ts WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, 'Europe/Berlin'), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_tz_4h_ts_origin WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, timezone => 'Europe/Berlin', origin => '2001-01-01'::timestamptz), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW temperature_tz_4h_ts_offset WITH (timescaledb.continuous) AS SELECT time_bucket('4 hour', time, timezone => 'Europe/Berlin', "offset" => '1 hour'::interval), avg(value) FROM timestamptz_ht GROUP BY 1 ORDER BY 1; CREATE TABLE integer_ht(a integer, b integer, c integer); SELECT table_name FROM create_hypertable('integer_ht', 'a', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_integer_ht() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM integer_ht $$; SELECT set_integer_now_func('integer_ht', 'integer_now_integer_ht'); CREATE MATERIALIZED VIEW integer_ht_cagg WITH (timescaledb.continuous) AS SELECT time_bucket(1, a) AS bucket, a, count(b) FROM integer_ht GROUP BY bucket, a; CREATE MATERIALIZED VIEW integer_ht_cagg_offset WITH (timescaledb.continuous) AS SELECT time_bucket(1, a, "offset" => 10) AS bucket, a, count(b) FROM integer_ht GROUP BY bucket, a; -- Get the bucket Oids SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name IN ('temperature_4h', 'temperature_tz_4h', 'temperature_tz_4h_ts', 'temperature_tz_4h_ts_origin', 'temperature_tz_4h_ts_offset', 'integer_ht_cagg', 'integer_ht_cagg_offset') ORDER BY user_view_name; -- Get all bucket function information SELECT user_view_name, bf.* FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name IN ('temperature_4h', 'temperature_tz_4h', 'temperature_tz_4h_ts', 'temperature_tz_4h_ts_origin', 'temperature_tz_4h_ts_offset', 'integer_ht_cagg', 'integer_ht_cagg_offset') ORDER BY user_view_name; -- Valid multiple time_bucket usage on view definition CREATE MATERIALIZED VIEW temperature_tz_4h_2 WITH (timescaledb.continuous) AS SELECT (time_bucket('4 hour', time) at time zone 'utc')::date, avg(value) FROM timestamptz_ht GROUP BY time_bucket('4 hour', time) ORDER BY 1 WITH NO DATA; SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name = 'temperature_tz_4h_2' ORDER BY user_view_name; -- Corrupt the direct view definition \c :TEST_DBNAME :ROLE_SUPERUSER SELECT direct_view_schema, direct_view_name FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'temperature_tz_4h_2' \gset CREATE OR REPLACE VIEW :direct_view_schema.:direct_view_name AS SELECT NULL::date AS timezone, NULL::FLOAT8 AS avg; \set ON_ERROR_STOP 0 -- Should error because there's no time_bucket function on the view definition SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name = 'temperature_tz_4h_2' ORDER BY user_view_name; \set ON_ERROR_STOP 1 -- Group by another function to make sure it will be ignored CREATE FUNCTION skip() RETURNS INTEGER AS $$ SELECT 1; $$ IMMUTABLE LANGUAGE SQL; CREATE MATERIALIZED VIEW temperature_tz_4h_3 WITH (timescaledb.continuous) AS SELECT skip(), time_bucket('4 hour', time), avg(value) FROM timestamptz_ht GROUP BY 1, 2 ORDER BY 1 WITH NO DATA; SELECT user_view_name, bf.bucket_func FROM _timescaledb_catalog.continuous_agg, LATERAL _timescaledb_functions.cagg_get_bucket_function_info(mat_hypertable_id) AS bf WHERE user_view_name = 'temperature_tz_4h_3' ORDER BY user_view_name; ������������������timescaledb-2.23.0/tsl/test/sql/cagg_watermark.sql��������������������������������������������������0000664�0000000�0000000�00000063262�15100345067�0022143�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN_ANALYZE 'EXPLAIN (analyze,buffers off, costs off,timing off,summary off)' CREATE TABLE continuous_agg_test(time int, data int); SELECT create_hypertable('continuous_agg_test', 'time', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_test1() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM continuous_agg_test $$; SELECT set_integer_now_func('continuous_agg_test', 'integer_now_test1'); -- watermark tabels start out empty SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- inserting into a table that does not have continuous_agg_insert_trigger doesn't change the watermark INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2), (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; CREATE MATERIALIZED VIEW cagg1 WITH (tsdb.continuous, tsdb.materialized_only=false) AS SELECT time_bucket('5', time) FROM continuous_agg_test GROUP BY 1 WITH NO DATA; -- inserting into the table still doesn't change the watermark since there's no -- continuous_aggs_invalidation_threshold. We treat that case as a invalidation_watermark of -- BIG_INT_MIN, since the first run of the aggregation will need to scan the -- entire table anyway. INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2), (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- set the continuous_aggs_invalidation_threshold to 15, any insertions below that value need an invalidation \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_aggs_invalidation_threshold SET watermark = 15 WHERE hypertable_id = 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2), (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- INSERTs only above the continuous_aggs_invalidation_threshold won't change the continuous_aggs_hypertable_invalidation_log INSERT INTO continuous_agg_test VALUES (21, 3), (22, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- INSERTs only below the continuous_aggs_invalidation_threshold will change the continuous_aggs_hypertable_invalidation_log INSERT INTO continuous_agg_test VALUES (10, 1), (11, 2); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- test INSERTing other values INSERT INTO continuous_agg_test VALUES (1, 7), (12, 6), (24, 5), (51, 4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- INSERT after dropping a COLUMN ALTER TABLE continuous_agg_test DROP COLUMN data; INSERT INTO continuous_agg_test VALUES (-1), (-2), (-3), (-4); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; INSERT INTO continuous_agg_test VALUES (100); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- INSERT after adding a COLUMN ALTER TABLE continuous_agg_test ADD COLUMN d BOOLEAN; INSERT INTO continuous_agg_test VALUES (-6, true), (-7, false), (-3, true), (-4, false); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; INSERT INTO continuous_agg_test VALUES (120, false), (200, true); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; \c :TEST_DBNAME :ROLE_SUPERUSER DELETE FROM _timescaledb_catalog.continuous_agg where mat_hypertable_id = 2; DELETE FROM _timescaledb_config.bgw_job WHERE id = 2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER DROP TABLE continuous_agg_test CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; TRUNCATE _timescaledb_catalog.continuous_aggs_invalidation_threshold; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- CREATE VIEW creates the invalidation trigger correctly CREATE TABLE ca_inval_test(time int); SELECT create_hypertable('ca_inval_test', 'time', chunk_time_interval=> 10); CREATE OR REPLACE FUNCTION integer_now_test2() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM ca_inval_test $$; SELECT set_integer_now_func('ca_inval_test', 'integer_now_test2'); CREATE MATERIALIZED VIEW cit_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM ca_inval_test GROUP BY 1 WITH NO DATA; INSERT INTO ca_inval_test SELECT generate_series(0, 5); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_aggs_invalidation_threshold SET watermark = 15 WHERE hypertable_id = 3; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER INSERT INTO ca_inval_test SELECT generate_series(5, 15); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; INSERT INTO ca_inval_test SELECT generate_series(16, 20); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- updates below the threshold update both the old and new values UPDATE ca_inval_test SET time = 5 WHERE time = 6; UPDATE ca_inval_test SET time = 7 WHERE time = 5; UPDATE ca_inval_test SET time = 17 WHERE time = 14; UPDATE ca_inval_test SET time = 12 WHERE time = 16; -- updates purely above the threshold are not logged UPDATE ca_inval_test SET time = 19 WHERE time = 18; UPDATE ca_inval_test SET time = 17 WHERE time = 19; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; DROP TABLE ca_inval_test CASCADE; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; TRUNCATE _timescaledb_catalog.continuous_aggs_invalidation_threshold; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- invalidation trigger is created correctly on chunks that existed before -- the view was created CREATE TABLE ts_continuous_test(time INTEGER, location INTEGER); SELECT create_hypertable('ts_continuous_test', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_test3() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM ts_continuous_test $$; SELECT set_integer_now_func('ts_continuous_test', 'integer_now_test3'); INSERT INTO ts_continuous_test SELECT i, i FROM (SELECT generate_series(0, 29) AS i) AS i; CREATE MATERIALIZED VIEW continuous_view WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(location) FROM ts_continuous_test GROUP BY 1 WITH NO DATA; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_catalog.continuous_aggs_invalidation_threshold SET watermark = 2 WHERE hypertable_id = 5; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER INSERT INTO ts_continuous_test VALUES (1, 1); SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; -- aborts don't get written BEGIN; INSERT INTO ts_continuous_test VALUES (-20, -20); ABORT; SELECT * FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold; SELECT * from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; DROP TABLE ts_continuous_test CASCADE; ---- -- Test watermark invalidation and chunk exclusion with prepared and ad-hoc queries ---- CREATE TABLE chunks(time timestamptz, device int, value float); SELECT FROM create_hypertable('chunks','time',chunk_time_interval:='1d'::interval); CREATE MATERIALIZED VIEW chunks_1h WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 hour', time) AS bucket, device, max(value) AS max FROM chunks GROUP BY 1, 2; -- Get id of the materialization hypertable SELECT id AS "MAT_HT_ID_1H" FROM _timescaledb_catalog.hypertable WHERE table_name=( SELECT materialization_hypertable_name FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1h' ) \gset SELECT materialization_hypertable_schema || '.' || materialization_hypertable_name AS "MAT_HT_NAME_1H" FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1h' \gset -- Prepared scan on hypertable (identical to the query of a real-time CAgg) PREPARE ht_scan_realtime_1h AS SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('01:00:00'::interval, chunks."time") AS bucket, chunks.device, max(chunks.value) AS max FROM chunks WHERE chunks."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('01:00:00'::interval, chunks."time")), chunks.device; PREPARE cagg_scan_1h AS SELECT * FROM chunks_1h; :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; INSERT INTO chunks VALUES ('2000-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Compare prepared statement with ad-hoc query EXECUTE cagg_scan_1h; SELECT * FROM chunks_1h; -- Add new chunks to the non materialized part of the CAgg INSERT INTO chunks VALUES ('2001-08-01 01:01:01+01', 1, 2); :EXPLAIN_ANALYZE EXECUTE cagg_scan_1h; :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; INSERT INTO chunks VALUES ('2002-08-01 01:01:01+01', 1, 2); :EXPLAIN_ANALYZE EXECUTE cagg_scan_1h; :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; -- Materialize CAgg and check for plan time chunk exclusion CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE cagg_scan_1h; :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; -- Check plan when chunk_append and constraint_aware_append cannot be used -- There should be no plans for scans of chunks that are materialized in the CAgg -- on the underlying hypertable SET timescaledb.enable_chunk_append = OFF; SET timescaledb.enable_constraint_aware_append = OFF; :EXPLAIN_ANALYZE SELECT * FROM chunks_1h; RESET timescaledb.enable_chunk_append; RESET timescaledb.enable_constraint_aware_append; -- Insert new values and check watermark changes INSERT INTO chunks VALUES ('2003-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Compare prepared statement with ad-hoc query EXECUTE cagg_scan_1h; SELECT * FROM chunks_1h; INSERT INTO chunks VALUES ('2004-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Two invalidations without prepared statement execution between INSERT INTO chunks VALUES ('2005-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); INSERT INTO chunks VALUES ('2006-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Multiple prepared statement executions followed by one invalidation :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; INSERT INTO chunks VALUES ('2007-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Compare prepared statement with ad-hoc query EXECUTE cagg_scan_1h; SELECT * FROM chunks_1h; -- Delete data from hypertable - data is only present in cagg after this point. If the watermark in the prepared -- statement is not moved to the most-recent watermark, we would see an empty result. TRUNCATE chunks; EXECUTE cagg_scan_1h; SELECT * FROM chunks_1h; -- Refresh the CAgg CALL refresh_continuous_aggregate('chunks_1h', NULL, NULL); EXECUTE cagg_scan_1h; SELECT * FROM chunks_1h; -- Check new watermark SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Update after truncate INSERT INTO chunks VALUES ('2008-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; -- Test with CAgg on CAgg CREATE MATERIALIZED VIEW chunks_1d WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 days', bucket) AS bucket, device, max(max) AS max FROM chunks_1h GROUP BY 1, 2; SELECT id AS "MAT_HT_ID_1D" FROM _timescaledb_catalog.hypertable WHERE table_name=( SELECT materialization_hypertable_name FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1d' ) \gset SELECT materialization_hypertable_schema || '.' || materialization_hypertable_name AS "MAT_HT_NAME_1D" FROM timescaledb_information.continuous_aggregates WHERE view_name='chunks_1d' \gset -- Prepared scan on hypertable (identical to the query of a real-time CAgg) PREPARE ht_scan_realtime_1d AS SELECT bucket, device, max FROM :MAT_HT_NAME_1D WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1D)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1D)), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; PREPARE cagg_scan_1d AS SELECT * FROM chunks_1d; :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1d; INSERT INTO chunks VALUES ('2009-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); CALL refresh_continuous_aggregate('chunks_1d', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1d; INSERT INTO chunks VALUES ('2010-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); CALL refresh_continuous_aggregate('chunks_1d', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1d; -- Stored procedure - watermark CREATE FUNCTION cur_watermark_plsql(mat_table int) RETURNS timestamptz AS $$ DECLARE cur_watermark_value timestamptz; BEGIN SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(mat_table)) INTO cur_watermark_value; RETURN cur_watermark_value; END$$ LANGUAGE plpgsql; SELECT * FROM cur_watermark_plsql(:MAT_HT_ID_1H); INSERT INTO chunks VALUES ('2011-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM cur_watermark_plsql(:MAT_HT_ID_1H); INSERT INTO chunks VALUES ('2012-08-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM cur_watermark_plsql(:MAT_HT_ID_1H); -- Stored procedure - result CREATE FUNCTION cur_cagg_result_count() RETURNS int AS $$ DECLARE count_value int; BEGIN SELECT count(*) FROM chunks_1h INTO count_value; RETURN count_value; END$$ LANGUAGE plpgsql; -- Cache function value SELECT * FROM cur_cagg_result_count(); -- Add to non-materialized part INSERT INTO chunks VALUES ('2013-08-01 01:01:01+01', 1, 2); SELECT * FROM cur_cagg_result_count(); -- Materialize CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT * FROM cur_cagg_result_count(); -- Ensure all elements are materialized (i.e., watermark is moved properly) TRUNCATE chunks; SELECT * FROM cur_cagg_result_count(); SELECT count(*) FROM chunks_1h; -- Test watermark call directly PREPARE watermark_query AS SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); EXECUTE watermark_query; INSERT INTO chunks VALUES ('2013-09-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)); EXECUTE watermark_query; -- Disable constification of watermark values SET timescaledb.enable_cagg_watermark_constify = OFF; INSERT INTO chunks VALUES ('2014-01-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE EXECUTE ht_scan_realtime_1h; RESET timescaledb.enable_cagg_watermark_constify; -- Select with projection INSERT INTO chunks VALUES ('2015-01-01 01:01:01+01', 1, 2); CALL refresh_continuous_aggregate('chunks_1h', '2000-01-01', '2021-06-01'); :EXPLAIN_ANALYZE SELECT device FROM chunks_1h; -- Watermark function use other tables in WHERE condition (should not be constified) CREATE TABLE continuous_agg_test(time int, data int); :EXPLAIN_ANALYZE (SELECT * FROM continuous_agg_test AS t1) UNION ALL (SELECT * from continuous_agg_test AS t2 WHERE COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) IS NOT NULL); -- Query without COALESCE - should not be optimized :EXPLAIN_ANALYZE (SELECT * FROM chunks_1h AS t1) UNION ALL (SELECT * from chunks_1h AS t2 WHERE _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)) IS NOT NULL); -- Aggregation query over CAgg should be constified :EXPLAIN_ANALYZE SELECT max(device) from chunks_1h; -- Test with integer partitioning CREATE TABLE integer_ht(time int, data int); SELECT create_hypertable('integer_ht', 'time', chunk_time_interval => 10); CREATE FUNCTION integer_now_integer_ht() RETURNS INTEGER LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM integer_ht $$; SELECT set_integer_now_func('integer_ht', 'integer_now_integer_ht'); INSERT INTO integer_ht SELECT i, i FROM generate_series(0, 25) AS i; CREATE MATERIALIZED VIEW integer_ht_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM integer_ht GROUP BY 1; SELECT * FROM integer_ht_cagg; :EXPLAIN_ANALYZE SELECT * FROM integer_ht_cagg; -- Test with big integer partitioning CREATE TABLE big_integer_ht(time bigint, data bigint); SELECT create_hypertable('big_integer_ht', 'time', chunk_time_interval => 10); CREATE FUNCTION integer_now_big_integer_ht() RETURNS BIGINT LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM big_integer_ht $$; SELECT set_integer_now_func('big_integer_ht', 'integer_now_big_integer_ht'); INSERT INTO big_integer_ht SELECT i, i FROM generate_series(0, 25) AS i; CREATE MATERIALIZED VIEW big_integer_ht_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM big_integer_ht GROUP BY 1; SELECT * FROM big_integer_ht_cagg; :EXPLAIN_ANALYZE SELECT * FROM big_integer_ht_cagg; -- Test with small integer partitioning CREATE TABLE small_integer_ht(time bigint, data bigint); SELECT create_hypertable('small_integer_ht', 'time', chunk_time_interval => 10); CREATE FUNCTION integer_now_small_integer_ht() RETURNS BIGINT LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM small_integer_ht $$; SELECT set_integer_now_func('small_integer_ht', 'integer_now_small_integer_ht'); INSERT INTO small_integer_ht SELECT i, i FROM generate_series(0, 25) AS i; CREATE MATERIALIZED VIEW small_integer_ht_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('5', time), COUNT(time) FROM small_integer_ht GROUP BY 1; SELECT * FROM small_integer_ht_cagg; :EXPLAIN_ANALYZE SELECT * FROM small_integer_ht_cagg; -- Test handling of multiple watermark functions on integer based hypertables -- This is not a usual CAgg query. So, no constification should be done. However, -- the constification code should detect this and do nothing. SELECT id AS "MAT_HT_ID_SMALL_INTEGER" FROM _timescaledb_catalog.hypertable WHERE table_name=( SELECT materialization_hypertable_name FROM timescaledb_information.continuous_aggregates WHERE view_name='small_integer_ht_cagg' ) \gset :EXPLAIN_ANALYZE SELECT time_bucket(5, time) AS time_bucket, count(time) AS count FROM small_integer_ht WHERE small_integer_ht."time" >= COALESCE(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer, _timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer) GROUP BY (time_bucket(5, small_integer_ht."time")) UNION ALL SELECT time_bucket(5, time) AS time_bucket, count(time) AS count FROM small_integer_ht WHERE small_integer_ht."time" < COALESCE(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer, _timescaledb_functions.cagg_watermark(:MAT_HT_ID_SMALL_INTEGER)::integer) GROUP BY (time_bucket(5, small_integer_ht."time")); -- test with non constant value of the watermark function (should not be constified) :EXPLAIN_ANALYZE SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(COALESCE(:MAT_HT_ID_1H, :MAT_HT_ID_1H))), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; -- test with NULL constant value of the watermark function (should not be constified) :EXPLAIN_ANALYZE SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(COALESCE(:MAT_HT_ID_1H, :MAT_HT_ID_1H))), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; -- test with double COALESCE function (should be constified) :EXPLAIN_ANALYZE SELECT bucket, device, max FROM :MAT_HT_NAME_1H WHERE bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone) UNION ALL SELECT time_bucket('@ 1 day'::interval, chunks_1h.bucket) AS bucket, chunks_1h.device, max(chunks_1h.max) AS max FROM chunks_1h WHERE chunks_1h.bucket >= COALESCE(COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:MAT_HT_ID_1H)), '-infinity'::timestamp with time zone), '-infinity'::timestamp with time zone) GROUP BY (time_bucket('@ 1 day'::interval, chunks_1h.bucket)), chunks_1h.device; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; TRUNCATE _timescaledb_catalog.continuous_aggs_invalidation_threshold; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Issue #6722: constify cagg_watermark using window func when querying a cagg :EXPLAIN_ANALYZE SELECT time_bucket, lead(count) OVER (ORDER BY time_bucket) FROM small_integer_ht_cagg; -- SDC #1905: Using cagg on CTE should be constified :EXPLAIN_ANALYZE WITH cagg AS ( SELECT * FROM small_integer_ht_cagg ) SELECT * FROM cagg WHERE time_bucket > 10; :EXPLAIN_ANALYZE WITH cagg AS ( SELECT * FROM small_integer_ht_cagg ), other AS ( SELECT * FROM generate_series(1,10) ) SELECT * FROM cagg, other WHERE time_bucket > 10; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/chunk_api.sql�������������������������������������������������������0000664�0000000�0000000�00000030670�15100345067�0021123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :"TEST_DBNAME" TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE SCHEMA "ChunkSchema"; -- Use range types as well for columns CREATE TABLE chunkapi(time timestamptz not null, device int, temp float, rng int8range); SELECT * FROM create_hypertable('chunkapi', 'time', 'device', 2); INSERT INTO chunkapi VALUES ('2018-01-01 05:00:00-8', 1, 23.4, int8range(4, 10)); SELECT (_timescaledb_functions.show_chunk(show_chunks)).* FROM show_chunks('chunkapi') ORDER BY chunk_id; -- Creating a chunk with the constraints of an existing chunk should -- return the existing chunk SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); \set VERBOSITY default \set ON_ERROR_STOP 0 -- Modified time constraint should fail with collision SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); -- Missing dimension SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000]}'); -- Extra dimension SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "device": [-9223372036854775808, 1073741823], "time2": [1514419600000000, 1515024000000000]}'); -- Bad dimension name SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "dev": [-9223372036854775808, 1073741823]}'); -- Same dimension twice SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1514419600000000, 1515024000000000], "time": [1514419600000000, 1515024000000000]}'); -- Bad bounds value SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": ["-1514419200000000", 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); -- Bad bounds value SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": ["badtimestamp", 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); -- Bad slices format SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1515024000000000], "device": [-9223372036854775808, 1073741823]}'); -- Bad slices json SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time: [1515024000000000] "device": [-9223372036854775808, 1073741823]}'); -- Bad bound type SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [true, 1515024000000000], "device": [-9223372036854775808, 1073741823]}'); \set ON_ERROR_STOP 1 -- Test that granting insert on tables allow create_chunk to be -- called. This will also create a chunk that does not collide and has -- a custom schema and name. SET ROLE :ROLE_SUPERUSER; GRANT INSERT ON chunkapi TO :ROLE_DEFAULT_PERM_USER_2; SET ROLE :ROLE_DEFAULT_PERM_USER_2; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi',' {"time": [1515024000000000, 1519024000000000], "device": [-9223372036854775808, 1073741823]}', 'ChunkSchema', 'My_chunk_Table_name'); SET ROLE :ROLE_SUPERUSER; DROP TABLE chunkapi; -- Test creating a chunk from an existing chunk table which was not -- created via create_chunk_table and having a different name. CREATE TABLE devices (id int PRIMARY KEY); INSERT INTO devices VALUES (1); CREATE TABLE chunkapi (time timestamptz NOT NULL PRIMARY KEY, device int REFERENCES devices(id), temp float CHECK(temp > 0)); SELECT * FROM create_hypertable('chunkapi', 'time'); INSERT INTO chunkapi VALUES ('2018-01-01 05:00:00-8', 1, 23.4); SELECT chunk_schema AS "CHUNK_SCHEMA", chunk_name AS "CHUNK_NAME" FROM timescaledb_information.chunks c ORDER BY chunk_name DESC LIMIT 1 \gset SELECT slices AS "SLICES" FROM _timescaledb_functions.show_chunk(:'CHUNK_SCHEMA'||'.'||:'CHUNK_NAME') \gset TRUNCATE chunkapi; CREATE TABLE newchunk (time timestamptz NOT NULL, device int, temp float); SELECT * FROM test.show_constraints('newchunk'); INSERT INTO newchunk VALUES ('2018-01-01 05:00:00-8', 1, 23.4); \set ON_ERROR_STOP 0 -- Creating the chunk without required CHECK constraints on a table -- should fail. Currently, PostgreSQL only enforces presence of CHECK -- constraints, but not foreign key, unique, or primary key -- constraints. We should probably add checks to enforce the latter -- too or auto-create all constraints. SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', :'SLICES', :'CHUNK_SCHEMA', :'CHUNK_NAME', 'newchunk'); \set ON_ERROR_STOP 1 -- Add the missing CHECK constraint. Note that the name must be the -- same as on the parent table. ALTER TABLE newchunk ADD CONSTRAINT chunkapi_temp_check CHECK (temp > 0); CREATE TABLE newchunk2 as select * from newchunk; ALTER TABLE newchunk2 ADD CONSTRAINT chunkapi_temp_check CHECK (temp > 0); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', :'SLICES', :'CHUNK_SCHEMA', :'CHUNK_NAME', 'newchunk'); -- adding an existing table to an exiting range must fail \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', :'SLICES', :'CHUNK_SCHEMA', :'CHUNK_NAME', 'newchunk2'); \set ON_ERROR_STOP 1 -- Show the chunk and that names are what we'd expect SELECT :'CHUNK_SCHEMA' AS expected_schema, :'CHUNK_NAME' AS expected_table_name, (_timescaledb_functions.show_chunk(ch)).* FROM show_chunks('chunkapi') ch; -- The chunk should inherit the hypertable SELECT relname FROM pg_catalog.pg_inherits, pg_class WHERE inhrelid = (:'CHUNK_SCHEMA'||'.'||:'CHUNK_NAME')::regclass AND inhparent = oid; -- Test that it is possible to query the data via the hypertable SELECT * FROM chunkapi ORDER BY 1,2,3; -- Show that the chunk has all the necessary constraints. These -- include inheritable constraints and dimensional constraints, which -- are specific to the chunk. Currently, foreign key, unique, and -- primary key constraints are not inherited or auto-created. SELECT * FROM test.show_constraints(format('%I.%I', :'CHUNK_SCHEMA', :'CHUNK_NAME')::regclass); TRUNCATE chunkapi; -- Create a table with extra columns CREATE TABLE extra_col_chunk (time timestamptz NOT NULL, device int, temp float, extra int, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); -- Adding a new chunk with extra column should fail \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1514419200000000, 1515024000000000]}', NULL, NULL, 'extra_col_chunk'); \set ON_ERROR_STOP 1 -- It should succeed after dropping the extra column ALTER TABLE extra_col_chunk DROP COLUMN extra; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1514419200000000, 1515024000000000]}', NULL, NULL, 'extra_col_chunk'); -- Test creating a chunk with columns in different order CREATE TABLE reordered_chunk (device int, temp float, time timestamptz NOT NULL, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515024000000000, 1515628800000000]}', NULL, NULL, 'reordered_chunk'); -- Test creating a chunk with initially missing a column CREATE TABLE missing_col_chunk (time timestamptz NOT NULL, device int); INSERT INTO missing_col_chunk (time, device) VALUES ('2018-01-11 05:00:00-8', 1); ALTER TABLE missing_col_chunk ADD COLUMN temp float CONSTRAINT chunkapi_temp_check CHECK (temp > 0); INSERT INTO missing_col_chunk (time, device, temp) VALUES ('2018-01-12 05:00:00-8', 1, 19.5); -- This should succeed since all required columns are now present SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515628800000000, 1516233600000000]}', NULL, NULL, 'missing_col_chunk'); -- Test creating a chunk with mismatched column types CREATE TABLE wrong_type_chunk (time timestamptz NOT NULL, device text, temp float CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); -- This should fail due to type mismatch \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1516233600000000, 1516838400000000]}', NULL, NULL, 'wrong_type_chunk'); \set ON_ERROR_STOP 1 -- Test creating a chunk with binary coercible types ALTER TABLE chunkapi ADD COLUMN name varchar(10); CREATE TABLE coercible_type_chunk (time timestamptz NOT NULL, device int, temp float CONSTRAINT chunkapi_temp_check CHECK (temp > 0), name text); INSERT INTO coercible_type_chunk (time, device, temp, name) VALUES ('2018-01-20 06:00:00-8', 1, 25.1, 'device1'); \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1516233600000000, 1516838400000000]}', NULL, NULL, 'coercible_type_chunk'); \set ON_ERROR_STOP 1 ALTER TABLE chunkapi DROP COLUMN name; -- Test data routing to the successfully created chunks. Each row should go to a different chunks INSERT INTO chunkapi VALUES ('2018-01-01 05:00:00-8', 1, 23.4), ('2018-01-08 05:00:00-8', 1, 24.5), ('2018-01-15 05:00:00-8', 1, 25.6); -- Verify data was routed correctly SELECT 'SELECT * FROM ' || chunk_schema || '.' || chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'chunkapi'; \gexec TRUNCATE chunkapi; -- Test generated columns -- This should fail since generated column is not allowed in chunks if parent does not have the column as generated. CREATE TABLE generated_col_chunk (time timestamptz NOT NULL, device int, temp float GENERATED ALWAYS AS (device::float) STORED, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); \set ON_ERROR_STOP 0 SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1516838400000000, 1517443200000000]}', NULL, NULL, 'generated_col_chunk'); \set ON_ERROR_STOP 1 -- When parent has a generated column while the chunk does not have the same column as generated, it should fail too. CREATE TABLE non_generated_chunk (time timestamptz NOT NULL, device int, temp float, CONSTRAINT chunkapi_temp_check CHECK (temp > 0)); \set ON_ERROR_STOP 0 ALTER TABLE chunkapi DROP COLUMN temp; ALTER TABLE chunkapi ADD COLUMN temp float GENERATED ALWAYS AS (device::float) STORED; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1517443200000000, 1518048000000000]}', NULL, NULL, 'non_generated_chunk'); \set ON_ERROR_STOP 1 -- Generation expression cannot be different from the parent \set ON_ERROR_STOP 0 ALTER TABLE generated_col_chunk DROP COLUMN temp; ALTER TABLE generated_col_chunk ADD COLUMN temp float GENERATED ALWAYS AS ((device::float)+1) STORED; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1518048000000000, 1518652800000000]}', NULL, NULL, 'generated_col_chunk'); \set ON_ERROR_STOP 1 -- This should succeed since the generated column is now the same as in the parent ALTER TABLE generated_col_chunk DROP COLUMN temp; ALTER TABLE generated_col_chunk ADD COLUMN temp float GENERATED ALWAYS AS ((device::float)) STORED; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1518652800000000, 1519257600000000]}', NULL, NULL, 'generated_col_chunk'); INSERT INTO chunkapi VALUES ('2018-02-20 05:00:00-8', 1); SELECT 'SELECT * FROM ' || chunk_schema || '.' || chunk_name FROM timescaledb_information.chunks WHERE hypertable_name = 'chunkapi'; \gexec DROP TABLE chunkapi; -- Test the fix for Bug #8577 -- Mismatch in attnum between chunk and hypertable should not fail CREATE TABLE chunkapi(col_to_drop int, time timestamptz not null, device int); SELECT create_hypertable('chunkapi', 'time', 'device', 2); ALTER TABLE chunkapi DROP COLUMN col_to_drop; CREATE TABLE new_chunk(time timestamptz not null, device int); INSERT INTO new_chunk VALUES ('2018-01-01 05:00:00-8', 1); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1514419200000000, 1515024000000000], "device": [-9223372036854775808, 1073741823]}', NULL, NULL, 'new_chunk'); CREATE TABLE reordered_chunk(device int, time timestamptz not null); INSERT INTO reordered_chunk VALUES (1, '2018-01-08 05:00:00-8'); SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515024000000000, 1515628800000000], "device": [-9223372036854775808, 1073741823]}', NULL, NULL, 'reordered_chunk'); CREATE TABLE new_col_chunk(time timestamptz not null, temp float, device int); INSERT INTO new_col_chunk VALUES ('2018-01-15 05:00:00-8', 23.4, 1); ALTER TABLE chunkapi ADD COLUMN temp float; SELECT * FROM _timescaledb_functions.create_chunk('chunkapi', '{"time": [1515628800000000, 1516233600000000], "device": [-9223372036854775808, 1073741823]}', NULL, NULL, 'new_col_chunk'); ������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/chunk_column_stats.sql����������������������������������������������0000664�0000000�0000000�00000035156�15100345067�0023071�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (buffers off, costs off, timing off, summary off)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name || '.' || c.table_name as chunk_name, c.status as chunk_status FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); CREATE INDEX sense_idx ON sample_table (sensor_id); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); \set start_date '2022-01-28 01:09:53.583252+05:30' -- insert into chunk1 INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 2, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 3, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 8, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 121.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 117.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 121.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 9, 121.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 14, 121.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 15, 10.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 16, 14.6554, 47, 'new row3'); -- Non-int, date, timestamp cannot be specified as a min/max ranges for now -- We could expand to FLOATs, NUMERICs later \set ON_ERROR_STOP 0 -- Error if you try enabling without enabling the GUC first SELECT * FROM enable_chunk_skipping('sample_table', 'name'); -- Enable the chunk skipping GUC SET timescaledb.enable_chunk_skipping to ON; SELECT * FROM enable_chunk_skipping('sample_table', 'name'); SELECT * FROM enable_chunk_skipping('sample_table', NULL); SELECT * FROM enable_chunk_skipping(NULL, 'name'); SELECT * FROM enable_chunk_skipping('sample_table1', 'name'); CREATE TABLE plain_table(like sample_table); SELECT * FROM enable_chunk_skipping('plain_table', 'sensor_id'); DROP TABLE plain_table; \set ON_ERROR_STOP 1 -- Specify tracking of min/max ranges for a column SELECT * FROM enable_chunk_skipping('sample_table', 'sensor_id'); -- The above should add an entry with MIN/MAX int64 entries for invalid chunk id -- to indicate that ranges on this column should be calculated for chunks SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Skipping should work SELECT * FROM enable_chunk_skipping('sample_table', 'sensor_id', true); -- A query using a WHERE clause on "sensor_id" column will scan all the chunks :PREFIX SELECT * FROM sample_table WHERE sensor_id > 9; -- For the purposes of min/max range tracking, a compressed chunk is considered as a -- completed chunk. -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'sensor_id' ); -- -- compress one chunk SELECT show_chunks('sample_table') AS "CH_NAME" order by 1 limit 1 \gset SELECT compress_chunk(:'CH_NAME'); SELECT id AS "CHUNK_ID" from _timescaledb_catalog.chunk WHERE table_name = '_hyper_1_1_chunk' \gset -- There should be an entry with min/max range computed for this chunk for this -- "sensor_id" column. SELECT * from _timescaledb_catalog.chunk_column_stats where chunk_id = :'CHUNK_ID'; -- check chunk compression status SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' AND chunk_name = :'CH_NAME'; :PREFIX SELECT * FROM sample_table WHERE sensor_id > 9; -- do update, this will change the status of the chunk UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- check chunk compression status SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' AND chunk_name = :'CH_NAME'; -- There should be an entry with "valid" set to false for this chunk SELECT * from _timescaledb_catalog.chunk_column_stats WHERE chunk_id = :'CHUNK_ID'; -- A query using a WHERE clause on "sensor_id" column will go back to scanning all the chunks -- along with an expensive DECOMPRESS on the first chunk :PREFIX SELECT * FROM sample_table WHERE sensor_id > 9; -- Remove the index to check the sequential min/max calculation code as well DROP INDEX sense_idx; -- recompress the partial chunk SELECT compress_chunk(:'CH_NAME'); -- check chunk compression status SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' AND chunk_name = :'CH_NAME'; -- The chunk entry should become "valid" again SELECT min(sensor_id), max(sensor_id) FROM :CH_NAME; SELECT * from _timescaledb_catalog.chunk_column_stats WHERE chunk_id = :'CHUNK_ID'; -- A query using a WHERE clause on "sensor_id" column will scan the proper chunk -- due to chunk exclusion using min/max ranges calculated above -- First chunk has [start,end) values of [1,9), here we confirm that its being -- filtered out when we are not hitting that range. -- Query ranges outside of chunk stats, should not include first chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id < 1; :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 0; :PREFIX SELECT * FROM sample_table WHERE sensor_id > 8; :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 9; :PREFIX SELECT * FROM sample_table WHERE sensor_id = 10; -- Query intersecting ranges, should include chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id = 7; :PREFIX SELECT * FROM sample_table WHERE sensor_id < 2; :PREFIX SELECT * FROM sample_table WHERE sensor_id > 3; :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 1; :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 8; :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 8 AND sensor_id <= 10; :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 4 AND sensor_id > -5; :PREFIX SELECT * FROM sample_table WHERE sensor_id > 6 AND sensor_id < 10; :PREFIX SELECT * FROM sample_table WHERE sensor_id <= 5 AND sensor_id > -1; -- Query chunk superset ranges, should include chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id > -2; :PREFIX SELECT * FROM sample_table WHERE sensor_id < 11; :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 1 AND sensor_id <= 8; :PREFIX SELECT * FROM sample_table WHERE sensor_id > 0 AND sensor_id < 9; -- Query chunk subset ranges, should include chunk. :PREFIX SELECT * FROM sample_table WHERE sensor_id > 2 AND sensor_id < 7; :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 3 AND sensor_id <= 6; :PREFIX SELECT * FROM sample_table WHERE sensor_id > 4 AND sensor_id <= 5; :PREFIX SELECT * FROM sample_table WHERE sensor_id >= 6 AND sensor_id < 8; -- Disabling the GUC will prevent plan time chunk skipping RESET timescaledb.enable_chunk_skipping; :PREFIX SELECT * FROM sample_table WHERE sensor_id < 1; SET timescaledb.enable_chunk_skipping to ON; -- Query ranges with OR clause will not work properly due to the way -- hypertable expansion works as of now. Once we fix that, it should -- fix the issue here too. -- Should not include but it does. :PREFIX SELECT * FROM sample_table WHERE sensor_id < 1 OR sensor_id > 8; -- Executor startup time exclusion will also use these ranges appropriately :PREFIX UPDATE sample_table set sensor_id = 10 WHERE sensor_id > length(substring(version(),1,9)); :PREFIX DELETE FROM sample_table WHERE sensor_id > length(substring(version(),1,10)); :PREFIX SELECT * FROM sample_table WHERE sensor_id > length(substring(version(),1,11)); -- Scan both chunks :PREFIX SELECT * FROM sample_table WHERE sensor_id > length(substring(version(),1,6)); -- Disabling the GUC will prevent execution time chunk skipping RESET timescaledb.enable_chunk_skipping; :PREFIX UPDATE sample_table set sensor_id = 10 WHERE sensor_id > length(substring(version(),1,9)); SET timescaledb.enable_chunk_skipping to ON; -- IN/ANY is not supported for now :PREFIX SELECT * FROM sample_table WHERE sensor_id IN (9, 10, 11); :PREFIX SELECT * FROM sample_table WHERE sensor_id = ANY(ARRAY[9, 10, 11]); -- Newly added chunks should also have MIN/MAX entry \set start_date '2024-01-28 01:09:51.583252+05:30' INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 9, 78.999, 'new row4'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Check that a RENAME COLUMN works ok ALTER TABLE sample_table RENAME COLUMN sensor_id TO sense_id; -- use the disable_chunk_skipping API to remove the min/max range entries SELECT * from disable_chunk_skipping('sample_table', 'sense_id'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; SELECT * from disable_chunk_skipping('sample_table', 'sense_id', true); ALTER TABLE sample_table RENAME COLUMN sense_id TO sensor_id; \set ON_ERROR_STOP 0 SELECT * from disable_chunk_skipping('sample_table', 'sensor_id'); SELECT * from disable_chunk_skipping('sample_table', NULL); SELECT * from disable_chunk_skipping(NULL, 'sensor_id'); SELECT * from disable_chunk_skipping('sample_table1', 'sensor_id'); -- should only work on columns that have been enabled for tracking SELECT * from disable_chunk_skipping('sample_table', 'time'); SELECT * from disable_chunk_skipping('sample_table', 'cpu'); \set ON_ERROR_STOP 1 SELECT * FROM enable_chunk_skipping('sample_table', 'sensor_id'); -- Chunk was already compressed before we enabled stats. It will -- point to min/max entries till the ranges get refreshed later. SELECT decompress_chunk(:'CH_NAME'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Compressing a chunk again should calculate proper ranges SELECT compress_chunk(:'CH_NAME'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; SELECT decompress_chunk(:'CH_NAME'); -- Entry should be reset for this chunk now SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Check that truncate resets the entry in the catalog SELECT compress_chunk(:'CH_NAME'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; TRUNCATE :CH_NAME; SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Check that drop chunk also removes entries from the catalog SELECT drop_chunks('sample_table', older_than => '2022-02-28'); -- Entry should be removed for this chunk now SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- disable compression to allow dropping of the column ALTER TABLE sample_table SET ( timescaledb.compress = FALSE ); -- Check that a DROP COLUMN removes entries from catalogs as well ALTER TABLE sample_table DROP COLUMN sensor_id; SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; DROP TABLE sample_table; SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Check that empty hypertables can have enable_chunk_skipping and -- that new chunks get entries in the catalog as they get added CREATE TABLE sample_table1 ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); CREATE INDEX sense_idx ON sample_table1 (sensor_id); SELECT * FROM create_hypertable('sample_table1', 'time', chunk_time_interval => INTERVAL '2 months'); SELECT * FROM enable_chunk_skipping('sample_table1', 'sensor_id'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table1 VALUES (:'start_date'::timestamptz, 12, 21, 33.123, 'new row1'); SELECT * from _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Check that ALTER TYPE for a column on which stats are enabled only works -- in a few sub types ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE BIGINT; \set ON_ERROR_STOP 0 ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE TIMESTAMPTZ; ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE TEXT; \set ON_ERROR_STOP 1 SELECT * FROM disable_chunk_skipping('sample_table1', 'sensor_id'); ALTER TABLE sample_table1 ALTER COLUMN sensor_id TYPE TEXT; -- Check that column mapping between hypertable and chunk doesn't break when -- hypertable has dropped columns -- See: https://github.com/timescale/timescaledb/issues/7932 CREATE TABLE sample_table ( time TIMESTAMPTZ NOT NULL, sensor_id INTEGER, cpu NUMERIC, temperature BIGINT); CREATE INDEX ON sample_table (temperature); SELECT create_hypertable('sample_table', 'time', chunk_time_interval=>'7 days'::interval); ALTER TABLE sample_table DROP COLUMN sensor_id; INSERT INTO sample_table VALUES (now(), 1, 366), (now(), 2, 501); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='temperature'); set timescaledb.enable_chunk_skipping = on; SELECT enable_chunk_skipping('sample_table', 'temperature'); SELECT show_chunks('sample_table') AS "CH_NAME" order by 1 limit 1 \gset SELECT compress_chunk(:'CH_NAME'); SELECT * FROM _timescaledb_catalog.chunk_column_stats ORDER BY 1; -- Check min/max ranges for partial chunks with segmentby columns get recalculated correctly by seementwise recompression CREATE TABLE chunk_skipping(time timestamptz,device text, updated_at timestamptz) WITH (tsdb.hypertable, tsdb.partition_column='time',tsdb.segmentby='device'); SELECT enable_chunk_skipping('chunk_skipping', 'updated_at'); INSERT INTO chunk_skipping SELECT '2025-01-01', 'd1', '2025-01-01'; SELECT compress_chunk(show_chunks('chunk_skipping')); SELECT * from chunk_skipping where updated_at < '2026-01-01'; INSERT INTO chunk_skipping SELECT '2025-01-01', 'd2', '2026-01-01'; SELECT compress_chunk(show_chunks('chunk_skipping')); SELECT * from chunk_skipping where updated_at < '2026-01-01'; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/chunk_merge.sql�����������������������������������������������������0000664�0000000�0000000�00000011464�15100345067�0021451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.test_merge_chunks_on_dimension(chunk REGCLASS, merge_chunk REGCLASS, dimension_id INTEGER) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_merge_chunks_on_dimension' LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE test1 ("Time" timestamptz, i integer, value integer); SELECT table_name FROM Create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 hour'); SELECT table_name FROM add_dimension('test1', 'i', number_partitions=> 2); ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); -- This creates chunks 1 - 3 on first hypertable. INSERT INTO test1 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; -- This creates chunks 4 - 6 on first hypertable. INSERT INTO test1 SELECT t, 2, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; CREATE TABLE test2 ("Time" timestamptz, i integer, value integer); SELECT table_name FROM Create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- This creates chunks 7 - 9 on second hypertable. INSERT INTO test2 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:00', '1 minute') t; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk; \set ON_ERROR_STOP 0 -- Cannot merge chunks from different hypertables SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_3_7_chunk', 1); -- Cannot merge non-adjacent chunks SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_3_chunk', 1); -- Cannot merge same chunk to itself (its not adjacent to itself). SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_1_chunk', 1); -- Cannot merge chunks on with different partitioning schemas. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_4_chunk', 1); -- Cannot merge chunks on with non-existant dimension slice. -- NOTE: we are merging the same chunk just so they have the exact same partitioning schema and we don't hit the previous test error. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_1_chunk', 999); \set ON_ERROR_STOP 1 -- Merge on open (time) dimension. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_5_chunk','_timescaledb_internal._hyper_1_6_chunk', 1); -- Merge on closed dimension. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_4_chunk', 2); SELECT compress_chunk(i) FROM show_chunks('test1') i; \set ON_ERROR_STOP 0 -- Cannot merge chunks internal compressed chunks, no dimensions on them. SELECT _timescaledb_internal.test_merge_chunks_on_dimension('_timescaledb_internal.compress_hyper_2_10_chunk','_timescaledb_internal.compress_hyper_2_11_chunk', 1); \set ON_ERROR_STOP 1 -- This creates more data so caggs has multiple chunks. INSERT INTO test1 SELECT t, 1, 1.0 FROM generate_series('2018-03-02 3:00'::TIMESTAMPTZ, '2018-03-03 3:00', '1 minute') t; CREATE MATERIALIZED VIEW test_cagg WITH (timescaledb.continuous) AS SELECT i, time_bucket(INTERVAL '1 hour', "Time") AS bucket, AVG(value) FROM test1 GROUP BY i, bucket; -- Merging cagg chunks should also work. WITH adjacent_slices AS (SELECT S1.id AS PRIMARY, s2.id AS secondary FROM _timescaledb_catalog.dimension_slice s2 INNER JOIN _timescaledb_catalog.dimension_slice s1 ON s1.range_end = s2.range_start WHERE s1.dimension_id = 4 AND s2.dimension_id = 4 LIMIT 1), chunks AS (SELECT c1.chunk_id AS primary_chunk, c2.chunk_id AS secondary_chunk FROM adjacent_slices INNER JOIN _timescaledb_catalog.chunk_constraint c1 ON c1.dimension_slice_id = adjacent_slices.primary INNER JOIN _timescaledb_catalog.chunk_constraint c2 ON c2.dimension_slice_id = adjacent_slices.secondary) SELECT _timescaledb_internal.test_merge_chunks_on_dimension(format('_timescaledb_internal._hyper_4_%s_chunk', chunks.primary_chunk), format('_timescaledb_internal._hyper_4_%s_chunk', chunks.secondary_chunk), 4) FROM chunks; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/chunk_utils_compression.sql�����������������������������������������0000664�0000000�0000000�00000007265�15100345067�0024137�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------------------------------------------------------- -- show_chunks and drop_chunks functions on a compressed table -- (issue https://github.com/timescale/timescaledb/issues/1535) -- create a table that will not be compressed CREATE TABLE public.uncompressed_table(time date NOT NULL, temp float8, device_id text); CREATE INDEX ON public.uncompressed_table(time DESC); SELECT create_hypertable('public.uncompressed_table', 'time', chunk_time_interval => interval '1 day'); INSERT INTO public.uncompressed_table VALUES('2020-03-01', 1.0, 'dev1'); INSERT INTO public.uncompressed_table VALUES('2020-03-05', 2.0, 'dev1'); INSERT INTO public.uncompressed_table VALUES('2020-03-07', 3.0, 'dev1'); INSERT INTO public.uncompressed_table VALUES('2020-03-08', 4.0, 'dev7'); INSERT INTO public.uncompressed_table VALUES('2020-03-09', 5.0, 'dev7'); INSERT INTO public.uncompressed_table VALUES('2020-03-10', 6.0, 'dev7'); -- create next table that is going to be compressed: CREATE TABLE public.table_to_compress (time date NOT NULL, acq_id bigint, value bigint); CREATE INDEX idx_table_to_compress_acq_id ON public.table_to_compress(acq_id); SELECT create_hypertable('public.table_to_compress', 'time', chunk_time_interval => interval '1 day'); ALTER TABLE public.table_to_compress SET (timescaledb.compress, timescaledb.compress_segmentby = 'acq_id'); INSERT INTO public.table_to_compress VALUES ('2020-01-01', 1234567, 777888); INSERT INTO public.table_to_compress VALUES ('2020-02-01', 567567, 890890); INSERT INTO public.table_to_compress VALUES ('2020-02-10', 1234, 5678); SELECT show_chunks('public.uncompressed_table'); SELECT show_chunks('public.table_to_compress'); SELECT show_chunks('public.table_to_compress', older_than=>'1 day'::interval); SELECT show_chunks('public.table_to_compress', newer_than=>'1 day'::interval); -- compress all chunks of the table: SELECT compress_chunk(show_chunks('public.table_to_compress')); -- check that approx size function works. We call VACUUM to ensure all forks exist VACUUM public.table_to_compress; SELECT * FROM hypertable_approximate_size('public.table_to_compress'); SELECT * FROM hypertable_size('public.table_to_compress'); -- and run the queries again to make sure results are the same SELECT show_chunks('public.uncompressed_table'); SELECT show_chunks('public.table_to_compress'); SELECT show_chunks('public.table_to_compress', older_than=>'1 day'::interval); SELECT show_chunks('public.table_to_compress', newer_than=>'1 day'::interval); -- truncate one compressed chunk SELECT chunk_schema || '.' || chunk_name as "CHNAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'table_to_compress' and hypertable_schema = 'public' ORDER BY chunk_name LIMIT 1 \gset SELECT count(*) FROM :CHNAME; TRUNCATE TABLE :CHNAME; SELECT count(*) FROM :CHNAME; -- drop all hypertables' old chunks SELECT drop_chunks(table_name::regclass, older_than=>'1 day'::interval) FROM _timescaledb_catalog.hypertable WHERE schema_name = current_schema() ORDER BY table_name DESC; SELECT show_chunks('public.uncompressed_table'); SELECT show_chunks('public.table_to_compress'); -- test calling on internal compressed table SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "TABLENAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'table_to_compress') \gset \set ON_ERROR_STOP 0 SELECT show_chunks(:'TABLENAME'); SELECT drop_chunks(:'TABLENAME',now()); \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/chunk_utils_internal.sql��������������������������������������������0000664�0000000�0000000�00000103555�15100345067�0023411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- These tests work for PG14 or greater -- Remember to corordinate any changes to functionality with the Cloud -- Storage team. Tests for the following API: -- * freeze_chunk -- * drop_chunk -- * attach_foreign_table_chunk -- * hypertable_osm_range_update \set EXPLAIN 'EXPLAIN (BUFFERS OFF, COSTS OFF)' CREATE OR REPLACE VIEW chunk_view AS SELECT ht.table_name AS hypertable_name, srcch.schema_name AS schema_name, srcch.table_name AS chunk_name, _timescaledb_functions.to_timestamp(dimsl.range_start) AS range_start, _timescaledb_functions.to_timestamp(dimsl.range_end) AS range_end FROM _timescaledb_catalog.chunk srcch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = srcch.hypertable_id INNER JOIN _timescaledb_catalog.chunk_constraint chcons ON srcch.id = chcons.chunk_id INNER JOIN _timescaledb_catalog.dimension dim ON srcch.hypertable_id = dim.hypertable_id INNER JOIN _timescaledb_catalog.dimension_slice dimsl ON dim.id = dimsl.dimension_id AND chcons.dimension_slice_id = dimsl.id; GRANT SELECT on chunk_view TO PUBLIC; \c :TEST_DBNAME :ROLE_SUPERUSER -- fake presence of timescaledb_osm INSERT INTO pg_extension(oid,extname,extowner,extnamespace,extrelocatable,extversion) SELECT 1,'timescaledb_osm',10,11,false,'1.0'; CREATE SCHEMA test1; GRANT CREATE ON SCHEMA test1 TO :ROLE_DEFAULT_PERM_USER; GRANT USAGE ON SCHEMA test1 TO :ROLE_DEFAULT_PERM_USER; GRANT USAGE ON SCHEMA test1 TO :ROLE_4; -- mock hooks for OSM interaction with timescaledb CREATE OR REPLACE FUNCTION ts_setup_osm_hook( ) RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_undo_osm_hook( ) RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; SET ROLE :ROLE_DEFAULT_PERM_USER; CREATE TABLE test1.hyper1 (time bigint, temp float); SELECT create_hypertable('test1.hyper1', 'time', chunk_time_interval => 10); INSERT INTO test1.hyper1 VALUES (10, 0.5); INSERT INTO test1.hyper1 VALUES (30, 0.5); SELECT chunk_schema as "CHSCHEMA", chunk_name as "CHNAME", range_start_integer, range_end_integer FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name ; ----- TESTS for freeze and unfreeze chunk ------------ --TEST internal api that freezes a chunk --freeze one of the chunks SELECT chunk_schema || '.' || chunk_name as "CHNAME", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset -- Freeze SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); SELECT * from test1.hyper1 ORDER BY 1; -- TEST updates and deletes on frozen chunk should fail \set ON_ERROR_STOP 0 SELECT * from test1.hyper1 ORDER BY 1; -- Value (time = 20) does not exist UPDATE test1.hyper1 SET temp = 40 WHERE time = 20; -- Frozen chunk is affected UPDATE test1.hyper1 SET temp = 40 WHERE temp = 0.5; -- Frozen chunk is affected UPDATE test1.hyper1 SET temp = 40 WHERE time = 10; -- Frozen chunk is affected DELETE FROM test1.hyper1 WHERE time = 10; SELECT * from test1.hyper1 ORDER BY 1; BEGIN; DELETE FROM test1.hyper1 WHERE time = 20; DELETE FROM test1.hyper1 WHERE temp = 0.5; ROLLBACK; -- TEST update on unfrozen chunk should be possible BEGIN; SELECT * FROM test1.hyper1; UPDATE test1.hyper1 SET temp = 40 WHERE time = 30; SELECT * FROM test1.hyper1; ROLLBACK; -- Test with cast (chunk path pruning can not be done during query planning) BEGIN; SELECT * FROM test1.hyper1 WHERE time = 30; UPDATE test1.hyper1 SET temp = 40 WHERE time = 30::text::float; SELECT * FROM test1.hyper1 WHERE time = 30; ROLLBACK; -- TEST delete on unfrozen chunks should be possible BEGIN; SELECT * from test1.hyper1 ORDER BY 1; DELETE FROM test1.hyper1 WHERE time = 30; SELECT * from test1.hyper1 ORDER BY 1; ROLLBACK; -- Test with cast BEGIN; SELECT * FROM test1.hyper1 WHERE time = 30; DELETE FROM test1.hyper1 WHERE time = 30::text::float; SELECT * FROM test1.hyper1 WHERE time = 30; ROLLBACK; -- TEST inserts into a frozen chunk fails INSERT INTO test1.hyper1 VALUES ( 11, 11); -- Test truncating table should fail TRUNCATE :CHNAME; SELECT * from test1.hyper1 ORDER BY 1; \set ON_ERROR_STOP 1 --insert into non-frozen chunk works INSERT INTO test1.hyper1 VALUES ( 31, 31); SELECT * from test1.hyper1 ORDER BY 1; -- TEST unfreeze frozen chunk and then drop SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'CHUNK_NAME'; SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME'); SELECT tgname, tgtype FROM pg_trigger WHERE tgrelid = :'CHNAME'::regclass ORDER BY tgname, tgtype; --verify status in catalog SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'CHUNK_NAME'; -- Test update works after unfreeze UPDATE test1.hyper1 SET temp = 40; -- Test delete works after unfreeze DELETE FROM test1.hyper1; --unfreezing again works SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME'); SELECT _timescaledb_functions.drop_chunk( :'CHNAME'); -- TEST freeze_chunk api on a chunk that is compressed CREATE TABLE public.table_to_compress (time date NOT NULL, acq_id bigint, value bigint); CREATE INDEX idx_table_to_compress_acq_id ON public.table_to_compress(acq_id); SELECT create_hypertable('public.table_to_compress', 'time', chunk_time_interval => interval '1 day'); ALTER TABLE public.table_to_compress SET (timescaledb.compress, timescaledb.compress_segmentby = 'acq_id'); INSERT INTO public.table_to_compress VALUES ('2020-01-01', 1234567, 777888); INSERT INTO public.table_to_compress VALUES ('2020-02-01', 567567, 890890); INSERT INTO public.table_to_compress VALUES ('2020-02-10', 1234, 5678); SELECT show_chunks('public.table_to_compress'); SELECT chunk_schema || '.' || chunk_name as "CHNAME", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'table_to_compress' and hypertable_schema = 'public' ORDER BY chunk_name LIMIT 1 \gset SELECT compress_chunk( :'CHNAME'); SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'CHUNK_NAME'; --now chunk is frozen, cannot decompress \set ON_ERROR_STOP 0 SELECT decompress_chunk( :'CHNAME'); --insert into frozen chunk, should fail INSERT INTO public.table_to_compress VALUES ('2020-01-01 10:00', 12, 77); --touches all chunks UPDATE public.table_to_compress SET value = 3; --touches only frozen chunk DELETE FROM public.table_to_compress WHERE time < '2020-01-02'; \set ON_ERROR_STOP 1 --try to refreeze SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); --touches non-frozen chunk SELECT * from public.table_to_compress ORDER BY 1, 3; DELETE FROM public.table_to_compress WHERE time > '2020-01-02'; SELECT * from public.table_to_compress ORDER BY 1, 3; --TEST cannot drop frozen chunk, no error is reported. -- simply skips SELECT drop_chunks('table_to_compress', older_than=> '1 day'::interval); --unfreeze and drop it SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME'); SELECT _timescaledb_functions.drop_chunk( :'CHNAME'); --add a new chunk INSERT INTO public.table_to_compress VALUES ('2019-01-01', 1234567, 777888); --TEST compress a frozen chunk fails SELECT chunk_schema || '.' || chunk_name as "CHNAME", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'table_to_compress' and hypertable_schema = 'public' ORDER BY chunk_name DESC LIMIT 1 \gset SELECT _timescaledb_functions.freeze_chunk( :'CHNAME'); \set ON_ERROR_STOP 0 SELECT compress_chunk( :'CHNAME'); \set ON_ERROR_STOP 1 --TEST dropping a frozen chunk --DO NOT CHANGE this behavior --- -- frozen chunks cannot be dropped. \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.drop_chunk(:'CHNAME'); \set ON_ERROR_STOP 1 -- Prepare table for CAGG tests TRUNCATE test1.hyper1; INSERT INTO test1.hyper1(time, temp) values(30, 0.5), (31, 31); --TEST drop_chunk in the presence of caggs. Does not affect cagg data CREATE OR REPLACE FUNCTION hyper_dummy_now() RETURNS BIGINT LANGUAGE SQL IMMUTABLE AS 'SELECT 100::BIGINT'; SELECT set_integer_now_func('test1.hyper1', 'hyper_dummy_now'); CREATE MATERIALIZED VIEW hyper1_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket( 5, "time") as bucket, count(*) FROM test1.hyper1 GROUP BY 1; SELECT * FROM hyper1_cagg ORDER BY 1; --now freeze chunk and try to drop it SELECT chunk_schema || '.' || chunk_name as "CHNAME1", chunk_name as "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'hyper1' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset SELECT _timescaledb_functions.freeze_chunk( :'CHNAME1'); --cannot drop frozen chunk \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.drop_chunk( :'CHNAME1'); \set ON_ERROR_STOP 1 -- unfreeze the chunk, then drop the single chunk SELECT _timescaledb_functions.unfreeze_chunk( :'CHNAME1'); --drop the single chunk and verify that cagg is unaffected. SELECT * FROM test1.hyper1 ORDER BY 1; SELECT _timescaledb_functions.drop_chunk( :'CHNAME1'); SELECT * from test1.hyper1 ORDER BY 1; SELECT * FROM hyper1_cagg ORDER BY 1; -- check that dropping cagg triggers OSM callback SELECT ts_setup_osm_hook(); BEGIN; DROP MATERIALIZED VIEW hyper1_cagg CASCADE; DROP TABLE test1.hyper1; ROLLBACK; BEGIN; DROP TABLE test1.hyper1 CASCADE; ROLLBACK; SELECT ts_undo_osm_hook(); --TEST error case (un)freeze a non-chunk CREATE TABLE nochunk_tab( a timestamp, b integer); \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.freeze_chunk('nochunk_tab'); SELECT _timescaledb_functions.unfreeze_chunk('nochunk_tab'); \set ON_ERROR_STOP 1 ----- TESTS for attach_osm_table_chunk ------------ --TEST for attaching a foreign table as a chunk --need superuser access to create foreign data server \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE postgres_fdw_db; GRANT ALL PRIVILEGES ON DATABASE postgres_fdw_db TO :ROLE_4; \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_table( timec timestamptz NOT NULL , acq_id bigint, value bigint); INSERT INTO fdw_table VALUES( '2020-01-01 01:00', 100, 1000); --create foreign server and user mappings as superuser \c :TEST_DBNAME :ROLE_SUPERUSER SELECT current_setting('port') as "PORTNO" \gset CREATE EXTENSION postgres_fdw; CREATE SERVER s3_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS ( host 'localhost', dbname 'postgres_fdw_db', port :'PORTNO'); GRANT USAGE ON FOREIGN SERVER s3_server TO :ROLE_4; CREATE USER MAPPING FOR :ROLE_4 SERVER s3_server OPTIONS ( user :'ROLE_4' , password :'ROLE_4_PASS'); ALTER USER MAPPING FOR :ROLE_4 SERVER s3_server OPTIONS (ADD password_required 'false'); \c :TEST_DBNAME :ROLE_4; -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_fdw_table (timec timestamptz NOT NULL, acq_id bigint, value bigint) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_table'); --now attach foreign table as a chunk of the hypertable. CREATE TABLE ht_try(timec timestamptz NOT NULL, acq_id bigint, value bigint); SELECT create_hypertable('ht_try', 'timec', chunk_time_interval => interval '1 day'); INSERT INTO ht_try VALUES ('2022-05-05 01:00', 222, 222); SELECT * FROM child_fdw_table; -- test size functions on foreign table SELECT * FROM _timescaledb_functions.relation_approximate_size('child_fdw_table'); SELECT * FROM _timescaledb_functions.relation_size('child_fdw_table'); -- error should be thrown as the hypertable does not yet have an associated tiered chunk \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try','2020-01-01 01:00'::timestamptz, '2020-01-01 03:00'); \set ON_ERROR_STOP 1 SELECT _timescaledb_functions.attach_osm_table_chunk('ht_try', 'child_fdw_table'); -- check hypertable status SELECT status FROM _timescaledb_catalog.hypertable WHERE table_name = 'ht_try'; -- must also update the range since the created chunk contains data SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2020-01-01'::timestamptz, '2020-01-02'); -- OSM chunk is not visible in chunks view SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'ht_try' ORDER BY 1; SELECT chunk_name, range_start, range_end FROM chunk_view WHERE hypertable_name = 'ht_try' ORDER BY chunk_name; SELECT * FROM ht_try ORDER BY 1; -- Check that the direct select from OSM chunk doesn't lead to bad effects. SELECT * FROM child_fdw_table; SELECT relname, relowner::regrole FROM pg_class WHERE relname in ( select chunk_name FROM chunk_view WHERE hypertable_name = 'ht_try' ) ORDER BY relname; SELECT inhrelid::regclass FROM pg_inherits WHERE inhparent = 'ht_try'::regclass ORDER BY 1; --TEST chunk exclusion code does not filter out OSM chunk SELECT * from ht_try ORDER BY 1; SELECT * from ht_try WHERE timec < '2022-01-01 01:00' ORDER BY 1; SELECT * from ht_try WHERE timec = '2020-01-01 01:00' ORDER BY 1; SELECT * from ht_try WHERE timec > '2000-01-01 01:00' and timec < '2022-01-01 01:00' ORDER BY 1; SELECT * from ht_try WHERE timec > '2020-01-01 01:00' ORDER BY 1; -- test ordered append BEGIN; -- before updating the ranges :EXPLAIN SELECT * FROM ht_try ORDER BY 1; -- range before update SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.table_name = 'child_fdw_table' AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id; SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2020-01-01 01:00'::timestamptz, '2020-01-02'); SELECT id, schema_name, table_name, status FROM _timescaledb_catalog.hypertable WHERE table_name = 'ht_try'; -- verify range was updated SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.table_name = 'child_fdw_table' AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id; -- should be ordered append now :EXPLAIN SELECT * FROM ht_try ORDER BY 1; SELECT * FROM ht_try ORDER BY 1; -- test invalid range - should not be ordered append SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try'); :EXPLAIN SELECT * from ht_try ORDER BY 1; SELECT * from ht_try ORDER BY 1; ROLLBACK; \set ON_ERROR_STOP 0 -- test that error is produced when range_start < range_end SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2020-01-02 01:00'::timestamptz, '2020-01-02 00:00'); -- error when range overlaps SELECT _timescaledb_functions.hypertable_osm_range_update('ht_try', '2022-05-05 01:00'::timestamptz, '2022-05-06'); \set ON_ERROR_STOP 1 -- test that approximate size function works when a osm chunk is present SELECT * FROM hypertable_approximate_size('ht_try'); --TEST GUC variable to enable/disable OSM chunk SET timescaledb.enable_tiered_reads=false; :EXPLAIN SELECT * from ht_try; :EXPLAIN SELECT * from ht_try WHERE timec > '2022-01-01 01:00'; :EXPLAIN SELECT * from ht_try WHERE timec < '2023-01-01 01:00'; SET timescaledb.enable_tiered_reads=true; :EXPLAIN SELECT * from ht_try; -- foreign chunk contains data from Jan 2020, so it is skipped during planning :EXPLAIN SELECT * from ht_try WHERE timec > '2022-01-01 01:00'; :EXPLAIN SELECT * from ht_try WHERE timec < '2023-01-01 01:00'; -- Test forceful refreshment. Here we simulate the situation that we've seen -- with tiered data when `timescaledb.enable_tiered_reads` were disabled on the -- server level. In that case we would not see materialized tiered data and -- we wouldn't be able to re-materialize the data using a normal refresh call -- because it would skip previously materialized ranges, but it should be -- possible with `force=>true` parameter. CREATE MATERIALIZED VIEW ht_try_weekly WITH (timescaledb.continuous) AS SELECT time_bucket(interval '1 week', timec) AS ts_bucket, avg(value) FROM ht_try GROUP BY 1 WITH NO DATA; SELECT * FROM ht_try_weekly; SET timescaledb.enable_tiered_reads=false; CALL refresh_continuous_aggregate('ht_try_weekly', '2019-12-29', '2020-01-10', force=>false); SELECT * FROM ht_try_weekly; SET timescaledb.enable_tiered_reads=true; CALL refresh_continuous_aggregate('ht_try_weekly', '2019-12-29', '2020-01-10', force=>true); SELECT * FROM ht_try_weekly; DROP MATERIALIZED VIEW ht_try_weekly; -- Test refresh policy with different settings of `include_tiered_data` parameter CREATE FUNCTION create_test_cagg(include_tiered_data BOOL) RETURNS INTEGER AS $$ DECLARE cfg jsonb; job_id INTEGER; BEGIN CREATE MATERIALIZED VIEW ht_try_weekly WITH (timescaledb.continuous) AS SELECT time_bucket(interval '1 week', timec) AS ts_bucket, avg(value) FROM ht_try GROUP BY 1 WITH NO DATA; job_id := add_continuous_aggregate_policy( 'ht_try_weekly', start_offset => NULL, end_offset => INTERVAL '1 hour', schedule_interval => INTERVAL '1 hour', include_tiered_data => include_tiered_data ); cfg := config FROM _timescaledb_config.bgw_job WHERE id = job_id; RAISE NOTICE 'config: %', jsonb_pretty(cfg); RETURN job_id; END $$ LANGUAGE plpgsql; -- include tiered data SELECT create_test_cagg(true) AS job_id \gset CALL run_job(:job_id); SELECT * FROM ht_try_weekly ORDER BY 1; DROP MATERIALIZED VIEW ht_try_weekly; -- exclude tiered data SELECT create_test_cagg(false) AS job_id \gset CALL run_job(:job_id); SELECT * FROM ht_try_weekly ORDER BY 1; DROP MATERIALIZED VIEW ht_try_weekly; -- default behavior: use instance-wide GUC value SELECT create_test_cagg(null) AS job_id \gset CALL run_job(:job_id); SELECT * FROM ht_try_weekly ORDER BY 1; DROP MATERIALIZED VIEW ht_try_weekly; -- This test verifies that a bugfix regarding the way `ROWID_VAR`s are adjusted -- in the chunks' targetlists on DELETE/UPDATE works (including partially -- compressed chunks) ALTER table ht_try SET (timescaledb.compress); INSERT INTO ht_try VALUES ('2021-06-05 01:00', 10, 222); SELECT compress_chunk(show_chunks('ht_try', newer_than => '2021-01-01'::timestamptz)); INSERT INTO ht_try VALUES ('2021-06-05 01:00', 10, 222); DO $$ DECLARE r RECORD; BEGIN EXPLAIN (BUFFERS OFF, COSTS OFF) UPDATE ht_try SET value = 2 WHERE acq_id = 10 AND timec > now() - '15 years'::interval INTO r; END $$ LANGUAGE plpgsql; -- Check that the direct select from OSM chunk doesn't lead to bad effects in -- presence of compression. SELECT * FROM child_fdw_table; --TEST insert into a OSM chunk fails. actually any insert will fail. But we just need -- to mock the hook and make sure the timescaledb code works correctly. SELECT ts_setup_osm_hook(); \set ON_ERROR_STOP 0 --the mock hook returns true always. so cannot create a new chunk on the hypertable INSERT INTO ht_try VALUES ('2022-06-05 01:00', 222, 222); \set ON_ERROR_STOP 1 SELECT ts_undo_osm_hook(); -- TEST error have to be hypertable owner to attach a chunk to it \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.attach_osm_table_chunk('ht_try', 'child_fdw_table'); -- TEST error try to attach to non hypertable CREATE TABLE non_ht (time bigint, temp float); SELECT _timescaledb_functions.attach_osm_table_chunk('non_ht', 'child_fdw_table'); -- TEST drop OSM chunk \c :TEST_DBNAME :ROLE_4 -- We need the OSM chunk for other tests so we run the test in a single -- transaction so that we could roll it back in the end BEGIN; -- get OSM chunk id SELECT c.id as osm_chunk_id, c.table_name as osm_chunk_name, ds.id as osm_dimension_slice FROM _timescaledb_catalog.chunk c JOIN _timescaledb_catalog.hypertable ht ON ht.id = c.hypertable_id JOIN _timescaledb_catalog.chunk_constraint cc ON cc.chunk_id = c.id JOIN _timescaledb_catalog.dimension_slice ds ON ds.id = cc.dimension_slice_id WHERE ht.table_name = 'ht_try' AND osm_chunk = true \gset \echo :osm_chunk_id, :osm_chunk_name, :osm_dimension_slice -- drop OSM chunk SELECT _timescaledb_functions.drop_osm_chunk('ht_try'); -- status should be 0 meaning hypertable doesn't have an OSM chunk SELECT status FROM _timescaledb_catalog.hypertable WHERE table_name = 'ht_try'; -- chunk, chunk_constraint and dimension slice should have been cleaned up SELECT FROM _timescaledb_catalog.chunk WHERE id = :osm_chunk_id; SELECT FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :osm_chunk_id; SELECT FROM _timescaledb_catalog.dimension_slice WHERE id = :osm_dimension_slice; -- foreign chunk no longer appears in the inheritance hierarchy SELECT * FROM test.show_subtables('ht_try'); -- verify that still can read from the table after catalog manipulations EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) SELECT * FROM ht_try; ROLLBACK; -- TEST error out when trying to drop an OSM chunk from a hypertable that -- doesn't have it SELECT _timescaledb_functions.drop_osm_chunk('test1.hyper1'); -- TEST error out when trying to drop an OSM chunk from a regular table SELECT _timescaledb_functions.drop_osm_chunk('non_ht'); \set ON_ERROR_STOP 1 -- TEST drop the hypertable and make sure foreign chunks are dropped as well -- \c :TEST_DBNAME :ROLE_4; DROP TABLE ht_try; SELECT relname FROM pg_class WHERE relname = 'child_fdw_table'; SELECT table_name, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE hypertable_id IN (SELECT id from _timescaledb_catalog.hypertable WHERE table_name = 'ht_try') ORDER BY table_name; -- TEST can create OSM chunk if there are constraints on the hypertable \c :TEST_DBNAME :ROLE_4 CREATE TABLE measure( id integer PRIMARY KEY, mname varchar(10)); INSERT INTO measure VALUES( 1, 'temp'); INSERT INTO measure VALUES( 2, 'osmtemp'); CREATE TABLE devices( id integer PRIMARY KEY, devname varchar(10) ); INSERT INTO devices VALUES( 111, 'dev1'); INSERT INTO devices VALUES( 222, 'osmdev'); CREATE TABLE devicesref( id integer PRIMARY KEY, devname varchar(10) ); INSERT INTO devicesref VALUES( 44, 'devref'); INSERT INTO devicesref VALUES( 55, 'osmdevref'); CREATE TABLE hyper_constr ( id integer, time bigint, temp float, mid integer ,dev integer ,devref integer ,PRIMARY KEY (id, time) ,FOREIGN KEY ( mid) REFERENCES measure(id) ,FOREIGN KEY ( dev ) REFERENCES devices(id) ON DELETE CASCADE ,FOREIGN KEY ( devref ) REFERENCES devicesref(id) ON DELETE RESTRICT ,CHECK ( temp > 10) ); SELECT create_hypertable('hyper_constr', 'time', chunk_time_interval => 10); INSERT INTO hyper_constr VALUES( 10, 200, 22, 1, 111, 44); \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_hyper_constr(id integer, time bigint, temp float, mid integer, dev integer, devref integer); INSERT INTO fdw_hyper_constr VALUES( 10, 100, 33, 2, 222, 55); \c :TEST_DBNAME :ROLE_4 -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_hyper_constr ( id integer NOT NULL, time bigint NOT NULL, temp float, mid integer, dev integer, devref integer) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_hyper_constr'); --check constraints are automatically added for the foreign table SELECT _timescaledb_functions.attach_osm_table_chunk('hyper_constr', 'child_hyper_constr'); -- was attached with data, so must update the range SELECT _timescaledb_functions.hypertable_osm_range_update('hyper_constr', 100, 110); SELECT table_name, status, osm_chunk FROM _timescaledb_catalog.chunk WHERE hypertable_id IN (SELECT id from _timescaledb_catalog.hypertable WHERE table_name = 'hyper_constr') ORDER BY table_name; SELECT * FROM hyper_constr order by time; --verify the check constraint exists on the OSM chunk SELECT * FROM test.show_constraints('child_hyper_constr'); -- TEST foreign key trigger: deleting data from foreign table measure -- does not error out due to data in osm chunk \set ON_ERROR_STOP 0 BEGIN; -- only show sqlstate here to hide constraint name difference \set VERBOSITY sqlstate DELETE FROM measure where id = 1; \set VERBOSITY terse ROLLBACK; \set ON_ERROR_STOP 1 --this touches osm chunk. should succeed silently without deleting any data BEGIN; DELETE FROM measure where id = 2; SELECT * FROM measure order by id; ROLLBACK; BEGIN; DELETE FROM devices where id = 222; SELECT * FROM devices order by id; ROLLBACK; BEGIN; DELETE FROM devicesref where id = 55; SELECT * FROM devicesref order by id; ROLLBACK; --TEST retention policy is applied on OSM chunk by calling registered callback CREATE OR REPLACE FUNCTION dummy_now_smallint() RETURNS BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 500::bigint' ; SELECT set_integer_now_func('hyper_constr', 'dummy_now_smallint'); SELECT add_retention_policy('hyper_constr', 100::int) AS deljob_id \gset --add hooks for osm callbacks that are triggered when drop_chunks is invoked--- SELECT ts_setup_osm_hook(); BEGIN; SELECT drop_chunks('hyper_constr', 10::int); SELECT id, table_name FROM _timescaledb_catalog.chunk where hypertable_id = (Select id from _timescaledb_catalog.hypertable where table_name = 'hyper_constr') ORDER BY id; -- show_chunks will not show the OSM chunk which is visible via the above query SELECT show_chunks('hyper_constr'); ROLLBACK; CALL run_job(:deljob_id); CALL run_job(:deljob_id); SELECT chunk_name, range_start, range_end FROM chunk_view WHERE hypertable_name = 'hyper_constr' ORDER BY chunk_name; SELECT ts_undo_osm_hook(); ----- TESTS for copy into frozen chunk ------------ \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1.copy_test ( "time" timestamptz NOT NULL, "value" double precision NOT NULL ); SELECT create_hypertable('test1.copy_test', 'time', chunk_time_interval => interval '1 day'); COPY test1.copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. -- Freeze one of the chunks SELECT chunk_schema || '.' || chunk_name as "COPY_CHNAME", chunk_name as "COPY_CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'copy_test' and hypertable_schema = 'test1' ORDER BY chunk_name LIMIT 1 \gset SELECT _timescaledb_functions.freeze_chunk( :'COPY_CHNAME'); -- Check state SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'COPY_CHUNK_NAME'; \set ON_ERROR_STOP 0 -- Copy should fail because one of che chunks is frozen COPY test1.copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. \set ON_ERROR_STOP 1 -- Count existing rows SELECT COUNT(*) FROM test1.copy_test; -- Check state SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'COPY_CHUNK_NAME'; \set ON_ERROR_STOP 0 -- Copy should fail because one of che chunks is frozen COPY test1.copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. \set ON_ERROR_STOP 1 -- Count existing rows SELECT COUNT(*) FROM test1.copy_test; -- Check unfreeze restored chunk SELECT _timescaledb_functions.unfreeze_chunk( :'COPY_CHNAME'); -- Check state SELECT table_name, status FROM _timescaledb_catalog.chunk WHERE table_name = :'COPY_CHUNK_NAME'; -- Copy should work now COPY test1.copy_test FROM STDIN DELIMITER ','; 2020-01-01 01:10:00+01,1 2021-01-01 01:10:00+01,1 \. --Utility functions -check index creation on hypertable with OSM chunk -- Indexes are not created on OSM chunks, they are skipped as these are foreign tables \c :TEST_DBNAME :ROLE_4 CREATE INDEX hyper_constr_mid_idx ON hyper_constr( mid, time); SELECT indexname, tablename FROM pg_indexes WHERE indexname = 'hyper_constr_mid_idx'; DROP INDEX hyper_constr_mid_idx; CREATE INDEX hyper_constr_mid_idx ON hyper_constr(mid, time) WITH (timescaledb.transaction_per_chunk); SELECT indexname, tablename FROM pg_indexes WHERE indexname = 'hyper_constr_mid_idx'; DROP INDEX hyper_constr_mid_idx; \i include/chunk_utils_internal_orderedappend.sql --TEST hypertable with foreign key into it \c :TEST_DBNAME :ROLE_4 CREATE TABLE hyper_fk(ts timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('hyper_fk', 'ts'); INSERT INTO hyper_fk(ts, device, value) VALUES ('2020-01-01 00:00:00+00', 'd1', 1.0); \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_hyper_fk(ts timestamptz NOT NULL, device text, value float); INSERT INTO fdw_hyper_fk VALUES( '2021-05-05 00:00:00+00', 'd2', 2.0); \c :TEST_DBNAME :ROLE_4 -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_hyper_fk (ts timestamptz NOT NULL, device text, value float) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_hyper_fk'); SELECT _timescaledb_functions.attach_osm_table_chunk('hyper_fk', 'child_hyper_fk'); --create table with fk into hypertable CREATE TABLE event(ts timestamptz REFERENCES hyper_fk(ts) , info text); -- NOTE: current behavior is to allow inserts/deletes from PG tables when data -- references OSM table. --insert referencing OSM chunk INSERT INTO event VALUES( '2021-05-05 00:00:00+00' , 'osm_chunk_ts'); --insert referencing non-existent value \set ON_ERROR_STOP 0 INSERT INTO event VALUES( '2020-01-02 00:00:00+00' , 'does_not_exist_ts'); \set ON_ERROR_STOP 1 INSERT INTO event VALUES( '2020-01-01 00:00:00+00' , 'chunk_ts'); SELECT * FROM event ORDER BY ts; DELETE FROM event WHERE info = 'osm_chunk_ts'; DELETE FROM event WHERE info = 'chunk_ts'; SELECT * FROM event ORDER BY ts; -- event triggers on chunk creation CREATE TABLE ht_try(timec timestamptz NOT NULL, acq_id bigint, value bigint); SELECT create_hypertable('ht_try', 'timec', chunk_time_interval => interval '1 day'); -- creating event triggers requires superuser permissions \c :TEST_DBNAME :ROLE_SUPERUSER -- event trigger on ddl_start CREATE OR REPLACE FUNCTION ddl_start_trigger_func() RETURNS EVENT_TRIGGER AS $$ BEGIN RAISE NOTICE 'ddl_start_trigger_func() is invoked'; END; $$ LANGUAGE plpgsql; CREATE EVENT TRIGGER ddl_start_trigger ON ddl_command_start WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION ddl_start_trigger_func(); -- event trigger on ddl_end CREATE OR REPLACE FUNCTION ddl_end_trigger_func() RETURNS EVENT_TRIGGER AS $$ DECLARE cmd RECORD; BEGIN RAISE NOTICE 'ddl_end_trigger_func() is invoked'; FOR cmd IN SELECT * FROM pg_event_trigger_ddl_commands() LOOP RAISE NOTICE 'tag: %, object: %', cmd.command_tag, cmd.object_identity::regclass; END LOOP; END; $$ LANGUAGE plpgsql; CREATE EVENT TRIGGER ddl_end_trigger ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION ddl_end_trigger_func(); -- by default event triggers on chunk creation are disabled INSERT INTO ht_try VALUES ('2025-05-01 00:00', 1, 10); SET timescaledb.enable_event_triggers = on; INSERT INTO ht_try VALUES ('2025-05-02 00:00', 1, 10); RESET timescaledb.enable_event_triggers; DROP EVENT TRIGGER ddl_start_trigger; DROP EVENT TRIGGER ddl_end_trigger; DROP TABLE ht_try; --TEST ALTER TABLE propagation with foreign chunks \c :TEST_DBNAME :ROLE_4 CREATE TABLE ht_alter(ts timestamptz) WITH (tsdb.hypertable,tsdb.compress=false); INSERT INTO ht_alter SELECT '2025-01-01'; \c postgres_fdw_db :ROLE_4 CREATE TABLE fdw_ht_alter(ts timestamptz NOT NULL, device text, value float); INSERT INTO fdw_ht_alter SELECT '2021-05-05'; \c :TEST_DBNAME :ROLE_4 -- this is a stand-in for the OSM table CREATE FOREIGN TABLE child_ht_alter(ts timestamptz NOT NULL) SERVER s3_server OPTIONS ( schema_name 'public', table_name 'fdw_ht_alter'); SELECT _timescaledb_functions.attach_osm_table_chunk('ht_alter', 'child_ht_alter'); ALTER TABLE ht_alter SET (autovacuum_enabled = false); ALTER TABLE ht_alter RESET (autovacuum_enabled); -- test DML blocker on frozen chunks CREATE TABLE dml_blocks (time timestamptz, device text, value float) WITH (tsdb.hypertable, tsdb.segmentby='device'); -- DML on hypertable before freezing should work INSERT INTO dml_blocks VALUES ('2025-01-01','dev1',1.0); BEGIN; UPDATE dml_blocks SET value = 2.0 WHERE device = 'dev1'; DELETE FROM dml_blocks WHERE device = 'dev2'; COPY dml_blocks FROM STDIN; 2025-01-01 dev1 1.0 \. ROLLBACK; SELECT show_chunks('dml_blocks') AS "CHUNK" \gset -- DML on chunk before freezing should work BEGIN; INSERT INTO :CHUNK VALUES ('2025-01-01','dev1',1.0); UPDATE :CHUNK SET value = 2.0 WHERE device = 'dev1'; DELETE FROM :CHUNK WHERE device = 'dev2'; COPY :CHUNK FROM STDIN; 2025-01-01 dev1 1.0 \. ROLLBACK; SELECT _timescaledb_functions.freeze_chunk(:'CHUNK'); -- DML on hypertable after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO dml_blocks VALUES ('2025-01-01','dev1',1.0); UPDATE dml_blocks SET value = 2.0 WHERE device = 'dev1'; DELETE FROM dml_blocks WHERE device = 'dev2'; COPY dml_blocks FROM STDIN; 2025-01-01 dev1 1.0 \. \set ON_ERROR_STOP 1 -- DML on chunk after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2025-01-01','dev1',1.0); UPDATE :CHUNK SET value = 2.0 WHERE device = 'dev1'; DELETE FROM :CHUNK WHERE device = 'dev2'; COPY :CHUNK FROM STDIN; 2025-01-01 dev1 1.0 \. \set ON_ERROR_STOP 1 -- repeat tests with compressed chunk SELECT _timescaledb_functions.unfreeze_chunk(:'CHUNK'); SELECT compress_chunk(:'CHUNK'); SELECT _timescaledb_functions.freeze_chunk(:'CHUNK'); SELECT format('%I.%I', schema_name, table_name) AS "COMPRESSED_CHUNK" FROM _timescaledb_catalog.chunk ORDER BY id DESC LIMIT 1 \gset -- DML on hypertable after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO dml_blocks VALUES ('2025-01-01','dev1',1.0); UPDATE dml_blocks SET value = 2.0 WHERE device = 'dev1'; DELETE FROM dml_blocks WHERE device = 'dev2'; COPY dml_blocks FROM STDIN; 2025-01-01 dev1 1.0 \. \set ON_ERROR_STOP 1 -- DML on chunk after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO :CHUNK VALUES ('2025-01-01','dev1',1.0); UPDATE :CHUNK SET value = 2.0 WHERE device = 'dev1'; DELETE FROM :CHUNK WHERE device = 'dev2'; COPY :CHUNK FROM STDIN; 2025-01-01 dev1 1.0 \. \set ON_ERROR_STOP 1 -- DML on chunk after freezing should be blocked \set ON_ERROR_STOP 0 INSERT INTO :COMPRESSED_CHUNK SELECT; UPDATE :COMPRESSED_CHUNK SET device = 'dev3' WHERE device = 'dev1'; DELETE FROM :COMPRESSED_CHUNK WHERE device = 'dev1'; COPY :COMPRESSED_CHUNK FROM STDIN; \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_SUPERUSER -- clean up databases created DROP DATABASE postgres_fdw_db WITH (FORCE); ���������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/columnar_scan_cost.sql����������������������������������������������0000664�0000000�0000000�00000012245�15100345067�0023034�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Some primitive tests that show cost of DecompressChunk node so that we can -- monitor the changes. create table costtab(ts int, s text, c text, ti text, fi float); select create_hypertable('costtab', 'ts'); alter table costtab set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into costtab select ts, ts % 10, ts::text, ts::text, ts::float from generate_series(1, 10000) ts; create index on costtab(ti); create index on costtab(fi); select count(compress_chunk(x)) from show_chunks('costtab') x; vacuum freeze analyze costtab; explain (buffers off) select * from costtab; explain (buffers off) select * from costtab where s = '1'; explain (buffers off) select * from costtab where c = '100'; explain (buffers off) select * from costtab where ti = '200'; explain (buffers off) select * from costtab where fi = 200; explain (buffers off) select ts from costtab; explain (buffers off) select ts from costtab where s = '1'; explain (buffers off) select ts from costtab where c = '100'; explain (buffers off) select ts, s from costtab; explain (buffers off) select ts, s from costtab where s = '1'; explain (buffers off) select ts, s from costtab where c = '100'; explain (buffers off) select * from costtab where ts = 5000; explain (buffers off) select * from costtab where fi = 200 and ts = 5000; explain (buffers off) select * from costtab where s = '1' or (fi = 200 and ts = 5000); -- Test estimation of compressed batch size using the _ts_meta_count stats. create table estimate_count(time timestamptz, device int, value float); select create_hypertable('estimate_count','time'); alter table estimate_count set (timescaledb.compress, timescaledb.compress_segmentby = 'device', timescaledb.compress_orderby = 'time'); -- same batch sizes insert into estimate_count select t, d, 1 from generate_series('2025-01-01'::timestamptz,'2025-01-03','15 min') t, generate_series(1, 1000) d ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; -- different batch sizes truncate estimate_count; insert into estimate_count select t, d, 2 from generate_series(1, 1000) d, lateral generate_series('2025-01-01'::timestamptz,'2025-01-03', interval '15 min' * (d % 10 + 1)) t ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; -- more different batch sizes truncate estimate_count; insert into estimate_count select t, d, 2 from generate_series(1, 1000) d, lateral generate_series('2025-01-01'::timestamptz,'2025-01-03', interval '15 min' + interval '1 minute' * d) t ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; -- more different + one very frequent truncate estimate_count; insert into estimate_count select t, d, 2 from generate_series(1, 1000) d, lateral generate_series('2025-01-01'::timestamptz,'2025-01-03', case when d % 2 = 0 then interval '10 min' else interval '15 min' + interval '1 minute' * d end) t ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; -- single row. Postgres generates all-zero entry in pg_statistics in this case, -- but we want to avoid zero row counts. truncate estimate_count; insert into estimate_count select '2025-01-01', 1, 2 ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; vacuum analyze estimate_count; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; -- no statistics truncate estimate_count; vacuum analyze estimate_count; insert into estimate_count select t, d, 1 from generate_series('2025-01-01'::timestamptz,'2025-01-03','15 min') t, generate_series(1, 1000) d ; select count(compress_chunk(c)) from show_chunks('estimate_count') c; explain (analyze, timing off, summary off, buffers off) select * from estimate_count; -- Test a high-cardinality orderby column create table highcard(ts int) with (tsdb.hypertable, tsdb.partition_column = 'ts', tsdb.compress_orderby = 'ts', tsdb.chunk_interval = 10000000); insert into highcard select generate_series(1, 1000000); select count(compress_chunk(x)) from show_chunks('highcard') x; vacuum freeze analyze highcard; explain (buffers off, analyze, timing off, summary off) select * from highcard where ts > 200000 and ts < 300000; explain (buffers off, analyze, timing off, summary off) select * from highcard where ts = 500000; explain (buffers off, analyze, timing off, summary off) select * from highcard where ts < 500000; explain (buffers off, analyze, timing off, summary off) select * from highcard where ts > 500000; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/columnstore_aliases.sql���������������������������������������������0000664�0000000�0000000�00000005310�15100345067�0023226�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE PROCEDURE convert_hypertable_to_columnstore(regclass) LANGUAGE plpgsql AS $$ DECLARE chunk REGCLASS; BEGIN FOR chunk IN SELECT show_chunks($1) LOOP CALL convert_to_columnstore(chunk); END LOOP; END $$; CREATE PROCEDURE convert_hypertable_to_rowstore(regclass) LANGUAGE plpgsql AS $$ DECLARE chunk REGCLASS; BEGIN FOR chunk IN SELECT show_chunks($1) LOOP CALL convert_to_rowstore(chunk); END LOOP; END $$; -- These are mostly taken from compression_ddl.sql and are only -- intended to check that aliases work. In that sense, the actual -- result of each query is not particularly important. CREATE TABLE test1 (ts timestamptz, i integer, b bigint, t text); SELECT * FROM create_hypertable('test1', 'ts'); INSERT INTO test1 SELECT t, random(), random(), random()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test1 set ( timescaledb.enable_columnstore, timescaledb.segmentby = 'b', timescaledb.orderby = 'ts desc' ); CALL convert_hypertable_to_columnstore('test1'); CALL convert_hypertable_to_rowstore('test1'); CALL convert_hypertable_to_columnstore('test1'); -- Pick one chunk to play with and test option names. We mostly use -- default since we are only interested in that the option names are -- accepted. SELECT chunk FROM show_chunks('test1') tbl(chunk) LIMIT 1 \gset CALL convert_to_rowstore(:'chunk', if_columnstore => true); CALL convert_to_columnstore(:'chunk', if_not_columnstore => true, recompress => false); CALL add_columnstore_policy('test1', interval '1 day'); CALL remove_columnstore_policy('test1'); SELECT * FROM timescaledb_information.hypertable_columnstore_settings; SELECT * FROM timescaledb_information.chunk_columnstore_settings ORDER BY chunk; VACUUM FULL test1; -- We only care about the column names for the result. They should be -- the same as for the original function. SELECT * FROM chunk_columnstore_stats('test1') where 1 = 2 order by chunk_name; SELECT * FROM hypertable_columnstore_stats('test1') where 1 = 2; CREATE TABLE test2 (ts timestamptz, i integer, b bigint, t text); SELECT * FROM create_hypertable('test2', 'ts'); INSERT INTO test2 SELECT t, random(), random(), random()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test2 set ( timescaledb.columnstore, timescaledb.segmentby = 'b', timescaledb.orderby = 'ts desc' ); SELECT * FROM timescaledb_information.hypertables WHERE hypertable_name = 'test2'; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_auto_sparse_index.sql��������������������������������������0000664�0000000�0000000�00000005336�15100345067�0024612�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. create table sparse(ts int, value float); select create_hypertable('sparse', 'ts'); insert into sparse select x, x from generate_series(1, 10000) x; alter table sparse set (timescaledb.compress, timescaledb.order_by='ts desc'); -- When the chunks are compressed, minmax metadata are created for columns that -- have btree indexes. create index ii on sparse(value); select count(compress_chunk(x)) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; -- Should be disabled with the GUC set timescaledb.auto_sparse_indexes to off; select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; reset timescaledb.auto_sparse_indexes; select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; -- Should survive renames. alter table sparse rename column value to wert; explain (buffers off, costs off) select * from sparse where wert = 1; alter table sparse rename column wert to value; explain (buffers off, costs off) select * from sparse where value = 1; -- Not for expression indexes. drop index ii; create index ii on sparse((value + 1)); select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; -- Not for other index types. drop index ii; create index ii on sparse using hash(value); select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; -- When the chunk is recompressed without index, no sparse index is created. drop index ii; select count(compress_chunk(decompress_chunk(x))) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where value = 1; -- Long column names. select count(decompress_chunk(x)) from show_chunks('sparse') x; \set ECHO none select format('alter table sparse add column %1$s bigint; create index on sparse(%1$s);', substr('Abcdef012345678_Bbcdef012345678_Cbcdef012345678_Dbcdef012345678_', 1, x)) from generate_series(1, 63) x \gexec \set ECHO queries select count(compress_chunk(x)) from show_chunks('sparse') x; vacuum analyze sparse; explain (buffers off, costs off) select * from sparse where Abcdef012345678_Bbcdef012345678_Cbcdef012345678_Dbcdef0 = 1; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_bgw_reorder_drop_chunks.sql��������������������������������0000664�0000000�0000000�00000016111�15100345067�0025767�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(timeout INT = -1) RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job WHERE TRUE; TRUNCATE _timescaledb_internal.bgw_job_stat; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE public.bgw_log( msg_no INT, mock_time BIGINT, application_name TEXT, msg TEXT ); CREATE VIEW sorted_bgw_log AS SELECT * FROM bgw_log ORDER BY mock_time, application_name COLLATE "C", msg_no; CREATE TABLE public.bgw_dsm_handle_store( handle BIGINT ); INSERT INTO public.bgw_dsm_handle_store VALUES (0); SELECT ts_bgw_params_create(); ----------------------------------- -- test retention policy runs for compressed hypertables -- ----------------------------------- CREATE TABLE test_retention_table(time timestamptz, drop_order int); SELECT create_hypertable('test_retention_table', 'time', chunk_time_interval => INTERVAL '1 week'); -- These inserts should create 5 different chunks INSERT INTO test_retention_table VALUES (now() - INTERVAL '2 month', 4); INSERT INTO test_retention_table VALUES (now(), 5); INSERT INTO test_retention_table VALUES (now() - INTERVAL '6 months', 2); INSERT INTO test_retention_table VALUES (now() - INTERVAL '4 months', 3); INSERT INTO test_retention_table VALUES (now() - INTERVAL '8 months', 1); SELECT show_chunks('test_retention_table'); SELECT COUNT(*) FROM _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as ht where c.hypertable_id = ht.id and ht.table_name='test_retention_table'; SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; SELECT add_retention_policy('test_retention_table', INTERVAL '4 months') as retention_job_id \gset SELECT count(*) FROM _timescaledb_config.bgw_job WHERE proc_schema = '_timescaledb_functions' AND proc_name = 'policy_retention'; SELECT alter_job(:retention_job_id, schedule_interval => INTERVAL '1 second'); SELECT * FROM _timescaledb_config.bgw_job where id=:retention_job_id; --turn on compression and compress all chunks ALTER TABLE test_retention_table set (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test_retention_table') ch; --make sure same # of compressed and uncompressed chunks before policy SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test_retention_table'; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test_retention_table'; SELECT show_chunks('test_retention_table'); SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(1000000); SELECT show_chunks('test_retention_table'); --make sure same # of compressed and uncompressed chunks after policy, reduced by 2 SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test_retention_table'; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test_retention_table'; ------------------------------ -- Test reorder policy runs on compressed tables. Reorder policy job must skip compressed chunks -- (see issue https://github.com/timescale/timescaledb/issues/1810). -- More tests for reorder policy can be found at bgw_reorder_drop_chunks.sql ------------------------------ CREATE TABLE test_reorder_chunks_table(time int not null, chunk_id int); CREATE INDEX test_reorder_chunks_table_time_idx ON test_reorder_chunks_table(time); SELECT create_hypertable('test_reorder_chunks_table', 'time', chunk_time_interval => 1); -- These inserts should create 6 different chunks INSERT INTO test_reorder_chunks_table VALUES (1, 1); INSERT INTO test_reorder_chunks_table VALUES (2, 2); INSERT INTO test_reorder_chunks_table VALUES (3, 3); INSERT INTO test_reorder_chunks_table VALUES (4, 4); INSERT INTO test_reorder_chunks_table VALUES (5, 5); INSERT INTO test_reorder_chunks_table VALUES (6, 6); -- Enable compression ALTER TABLE test_reorder_chunks_table set (timescaledb.compress, timescaledb.compress_orderby = 'time DESC'); -- Compress 2 chunks: SELECT compress_chunk(show_chunks('test_reorder_chunks_table', newer_than => 2, older_than => 4)); -- make sure we have total of 6 chunks: SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test_reorder_chunks_table'; -- and 2 compressed ones: SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test_reorder_chunks_table'; -- enable reorder policy SELECT add_reorder_policy('test_reorder_chunks_table', 'test_reorder_chunks_table_time_idx') AS reorder_job_id \gset -- nothing is clustered yet SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- run first time SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; -- first chunk reordered SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- second call to scheduler SELECT ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(25); SELECT job_id, last_run_success, total_runs, total_successes, total_failures, total_crashes FROM _timescaledb_internal.bgw_job_stat where job_id=:reorder_job_id; -- two chunks clustered, skips the compressed chunks SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_bitmap_scan.sql��������������������������������������������0000664�0000000�0000000�00000004307�15100345067�0023353�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Exercise the Bitmap Heap Scan over the compressed chunk table. It requires -- big tables with high selectivity OR queries on indexed columns, so it almost -- doesn't happen in the normal tests. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; set max_parallel_workers_per_gather = 0; set enable_memoize to off; create table bscan(ts int, s int, id int, payload int); select create_hypertable('bscan', 'ts', chunk_time_interval => 500001); alter table bscan set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'id, ts'); insert into bscan select ts, ts % 239 s, ts % 111721 id, (mix(ts % 1483) * 1483)::int payload from generate_series(1, 1000000) ts; -- tweak dataset to get whole number actual row results update bscan set payload = -537, s = 1 where id in (1,2); delete from bscan where payload = -537 and id not in (1,2); create index on bscan(payload); select count(compress_chunk(x)) from show_chunks('bscan') x; vacuum full analyze bscan; -- We have many conditions here, so it's less selective and the bitmap scan -- overhead grows. This query should use Seq Scan. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from bscan where id = 1 or id = 2 or id = 3 or id = 4 or id = 5 or id = 6 or id = 7 or id = 8 ; -- This should be Bitmap Heap Scan because we have an OR of highly selective -- conditions. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from bscan where id = 1 or id = 2 ; -- Also try a join with a Bitmap Heap Scan set enable_mergejoin to off; set enable_hashjoin to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from bscan t1, bscan t2 where (t2.id = 1 or t2.id = 2) and t1.s = t2.s and t1.payload = -537; ; reset enable_mergejoin; reset enable_hashjoin; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_bloom_sparse.sql.in����������������������������������������0000664�0000000�0000000�00000036305�15100345067�0024170�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; create table bloom(x int, value text, u uuid, ts timestamp); select create_hypertable('bloom', 'x'); insert into bloom select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on bloom using brin(value text_bloom_ops); create index on bloom using brin(u uuid_bloom_ops); create index on bloom using brin(ts timestamp_minmax_ops); alter table bloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('bloom') x; select * from settings; vacuum full analyze bloom; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'bloom') limit 1) \gset \d+ :chunk explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = md5(7248::text); select count(*) from bloom where value = md5(7248::text); -- The join condition is not pushed down to the compressed scan for some reason. set enable_mergejoin to off; set enable_hashjoin to off; set enable_material to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; ; with query(value) as materialized (values (md5(3516::text)), (md5(9347::text)), (md5(5773::text))) select count(*) from bloom natural join query; ; reset enable_mergejoin; reset enable_hashjoin; reset enable_material; -- Stable expression that yields null set timescaledb.enable_chunk_append to off; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else null end ; reset timescaledb.enable_chunk_append; -- Stable expression that yields not null explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = case when now() < '1970-01-01' then md5(2345::text) else md5(5837::text) end ; -- Stable expression on minmax index explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < case when now() < '1970-01-01' then 1 else 1000 end ; -- Parameter on minmax index set timescaledb.enable_chunk_append to off; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from bloom where x < $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(1000); deallocate p; -- Parameter on bloom index prepare p as select count(*) from bloom where value = $1; explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(md5('2345')); -- Null parameter on bloom index explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p(null); reset timescaledb.enable_chunk_append; deallocate p; -- Function of parameter on bloom index prepare p as select count(*) from bloom where value = md5($1); explain (analyze, verbose, buffers off, costs off, timing off, summary off) execute p('2345'); deallocate p; reset plan_cache_mode; reset timescaledb.enable_chunk_append; -- Scalar array operations are not yet supported explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where x < any(array[1000, 2000]::int[]); explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where value = any(array[md5('1000'), md5('2000')]); -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcab'; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where u = '6c1d0998-05f3-452c-abd3-45afe72bbcac'; -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from bloom where ts between '2021-01-07' and '2021-01-14'; -- Test some corner cases create table corner(ts int, s text, c text); select create_hypertable('corner', 'ts'); alter table corner set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); -- Detoasting the second argument of "bloom filter contains" function. insert into corner values (1, repeat('long', 100), 'short'); -- Null bloom filter. insert into corner values(2, 'normal', null); -- A match and a short varlena header in the bloom filter. insert into corner values(3, 'match', 'match'); -- Long varlena header in the bloom filter. insert into corner select 4, 'longheader', generate_series(1, 1000)::text; create index on corner(c); select count(compress_chunk(x)) from show_chunks('corner') x; vacuum full analyze corner; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'; -- Cross-type equality operator. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'short'::name; -- Comparison with segmentby. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s; -- Can push down only some parts of the expression but not the others, so the -- pushdown shouldn't work in this case. explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = s or c = random()::text; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from corner where c = 'test' or c = case when now() > '1970-01-01' then 'test2' else random()::text end ; -- Unsupported operator explain (buffers off, costs off) select * from corner where c > s; -- Test a bad hash function. create type badint; create or replace function badintin(cstring) returns badint as 'int8in' language internal strict immutable parallel safe; create or replace function badintout(badint) returns cstring as 'int8out' language internal strict immutable parallel safe; create or replace function badinteq(badint, badint) returns bool as 'int8eq' language internal strict immutable parallel safe; create type badint (like = int8, input = badintin, output = badintout); create cast (bigint as badint) without function as implicit; create cast (badint as bigint) without function as implicit; create operator = (procedure = badinteq, leftarg = badint, rightarg = badint); -- The btree opfamily equality operator must be in sync with the potential hash family. -- If we don't create it explicitly, Postgres will choose the int8 family because -- it's binary compatible, and the equality operator won't match. create function badint_cmp(left badint, right badint) returns integer as 'btint8cmp' language internal immutable parallel safe strict; create function badint_lt(a badint, b badint) returns boolean as 'int8lt' language internal immutable parallel safe strict; create function badint_le(a badint, b badint) returns boolean as 'int8le' language internal immutable parallel safe strict; create function badint_gt(a badint, b badint) returns boolean as 'int8gt' language internal immutable parallel safe strict; create function badint_ge(a badint, b badint) returns boolean as 'int8ge' language internal immutable parallel safe strict; create operator < (leftarg = badint, rightarg = badint, procedure = badint_lt ); create operator <= (leftarg = badint, rightarg = badint, procedure = badint_le ); create operator >= (leftarg = badint, rightarg = badint, procedure = badint_ge ); create operator > (leftarg = badint, rightarg = badint, procedure = badint_gt ); create operator class badint_btree_ops default for type badint using btree as operator 1 <, operator 2 <=, operator 3 =, operator 4 >=, operator 5 >, function 1 badint_cmp(badint, badint) ; create table badtable(ts int, s int, b badint); select create_hypertable('badtable', 'ts'); \set ON_ERROR_STOP 0 alter table badtable set (timescaledb.compress, timescaledb.compress_orderby = '"ts" desc', timescaledb.compress_segmentby = 's', timescaledb.compress_index = 'bloom("b")'); \set ON_ERROR_STOP 1 alter table badtable set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into badtable select generate_series(1, 10000), 0, 0::int8; insert into badtable select generate_series(1, 10000), 1, 1::int8; insert into badtable select generate_series(1, 10000), -1, -1::int8; insert into badtable select x, 2, x::int8 from generate_series(1, 10000) x; insert into badtable select x, 3, (pow(2, 32) * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 4, (16834 * x)::int8 from generate_series(1, 10000) x; insert into badtable select x, 5, (4096 * x)::int8 from generate_series(1, 10000) x; create index on badtable(b); -- First, try compressing w/o the hash function. We shouldn't get a bloom filter -- index. select count(compress_chunk(x)) from show_chunks('badtable') x; vacuum full analyze badtable; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk select count(decompress_chunk(x)) from show_chunks('badtable') x; -- Then, create the hash functions. -- The simple hash is actually used for dictionary compression, so we have to -- avoid overflows there. create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select (val & ((1::bigint << 31) - 1))::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select val; $$; create operator class badint_hash_ops default for type badint using hash as operator 1 = (badint, badint), function 1 badint_identity_hash(badint), function 2 badint_identity_hash_extended(badint, bigint) ; -- Recompress after creating the hash functions select count(compress_chunk(x)) from show_chunks('badtable') x; select * from settings; vacuum full analyze badtable; -- Verify that we actually got the bloom filter index. select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'badtable') limit 1) \gset \d+ :chunk -- Check index pushdown with one value. explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; -- Check index pushdown and absence of negatives with multiple value. The query -- shape is a little weird to achieve the parameterized compressed scan, for -- joins it doesn't work at the moment due to general problem with parameterized -- DecompressChunk there. explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; ; -- Now, repeat the entire exercise with an even worse hash of constant zero. select count(decompress_chunk(x)) from show_chunks('badtable') x; create or replace function badint_identity_hash(val badint) returns int language sql immutable strict as $$ select 0::int4; $$; create or replace function badint_identity_hash_extended(val badint, seed bigint) returns bigint language sql immutable strict as $$ select 0; $$; select count(compress_chunk(x)) from show_chunks('badtable') x; vacuum full analyze badtable; explain (analyze, buffers off, costs off, timing off, summary off) select * from badtable where b = 1000::int8::badint; explain (analyze, buffers off, costs off, timing off, summary off) with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; ; with v_int(b) as (values (0), (1), (-1), (2), (4), (8), (1024), (pow(2, 32) * 2), (pow(2, 32) * 1024)), v_badint as materialized (select b::int8::badint from v_int) select exists (select * from badtable where b = v_badint.b) from v_badint; ; -- Test a non-by-value 8-byte type. create table byref(ts int, x macaddr8); select create_hypertable('byref', 'ts'); create index on byref(x); alter table byref set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'ts'); create function float8tomacaddr8(x float8) returns macaddr8 as $$ select to_hex(right(float8send(x)::text, -1)::bit(64)::bigint)::macaddr8; $$ language sql immutable parallel safe strict; insert into byref select x, float8tomacaddr8(mix(x)) from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('byref') x; vacuum analyze byref; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select * from byref where x = float8tomacaddr8(mix(1)); -- Test an array type. create table arraybloom(x int, value int[], ts timestamp); select create_hypertable('arraybloom', 'x'); insert into arraybloom select x, array[x], '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; create index on arraybloom(value); alter table arraybloom set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('arraybloom') x; vacuum full analyze arraybloom; explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from arraybloom where value = array[7248::int]; select count(*) from arraybloom where value = array[7248::int]; -- Cleanup drop table bloom; drop table corner; drop table badtable; drop table byref; drop table arraybloom; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_bloom_sparse_debug.sql�������������������������������������0000664�0000000�0000000�00000010375�15100345067�0024730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; create table test(ts int, s text, c text); select create_hypertable('test', 'ts'); alter table test set (timescaledb.compress, timescaledb.compress_segmentby = 's', timescaledb.compress_orderby = 'ts'); insert into test select ts, ts % 10 s, mix(ts)::text c from generate_series(1, 10000) ts; insert into test select ts, 10 + ts % 10 s, mix(ts % 100)::text c from generate_series(10001, 15000) ts; insert into test select ts, 20 + ts % 10 s, mix(ts % 10)::text c from generate_series(15001, 20000) ts; create index on test using brin(c text_bloom_ops); select count(compress_chunk(x)) from show_chunks('test') x; -- Test the debug function create or replace function ts_bloom1_debug_info(in _timescaledb_internal.bloom1, out toast_header int, out toasted_bytes int, out compressed_bytes int, out detoasted_bytes int, out bits_total int, out bits_set int, out estimated_elements int) as :TSL_MODULE_PATHNAME, 'ts_bloom1_debug_info' language c immutable parallel safe; select schema_name || '.' || table_name chunk, 'c' column from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test') limit 1) \gset with col as ( select _ts_meta_count rows, _ts_meta_v2_bloom1_:column f, :column cc from :chunk), blooms as ( select *, (ts_bloom1_debug_info(f)).*, pg_column_compression(f) filter_column_compression, pg_column_size(f) filter_column_size from col) select (toast_header::bit(16), bits_total, filter_column_compression) kind, avg(rows)::int rows, count(*), count(*) filter (where _timescaledb_functions.bloom1_contains(f, mix(1)::text)) h, array_agg(distinct bits_total) filter_bit_sizes, array_agg(distinct filter_column_compression) filter_compression_algorithms, round(avg(detoasted_bytes / compressed_bytes::numeric), 2) filter_compression_ratio, avg(estimated_elements)::int estimated_elements, avg(bits_set)::int bits_set, round(avg(pg_column_size(cc)) / (avg(bits_total) / 8.), 2) column_to_filter_ratio from blooms group by 1 order by min(bits_total); -- One way to inspect the IO efficiency: ratio of bytes that would have been -- read w/o the index to the sum of bytes read by the bloom filter check -- and the actual column check. with col as ( select _ts_meta_count b, _ts_meta_v2_bloom1_:column f, :column cc from :chunk) select round( sum(pg_column_size(cc))::numeric / (sum(pg_column_size(f)) + sum(pg_column_size(cc)) filter (where _timescaledb_functions.bloom1_contains(f, '0.4067781441845'::text))), 2) from col; -- Compressed bytes-per-value vs bloom filter bytes-per-value. with col as ( select _ts_meta_count rows, _ts_meta_v2_bloom1_:column f, :column cc from :chunk) select round(sum(pg_column_size(cc))::numeric / sum(rows), 2) compressed_bytes_per_row, round(sum(pg_column_size(f))::numeric / sum(rows), 2) filter_bytes_per_row from col; -- Test the debug hash function. create or replace function ts_bloom1_debug_hash(in anyelement, out int8) as :TSL_MODULE_PATHNAME, 'ts_bloom1_debug_hash' language c immutable parallel safe; select min(ts_bloom1_debug_hash(c)) from test; -- This shouldn't change compared to what was released in 2.20, not to break the -- binary compatibility. select ts_bloom1_debug_hash('test'::text); select ts_bloom1_debug_hash('test'::varchar); select ts_bloom1_debug_hash('test'::bpchar); select ts_bloom1_debug_hash('c9757a73-7632-462e-bcfa-d5d9659e498f'::uuid); select ts_bloom1_debug_hash(1::int4); select ts_bloom1_debug_hash(1::int8); select ts_bloom1_debug_hash(1::float4); select ts_bloom1_debug_hash(1::float8); select ts_bloom1_debug_hash('2025-05-05'::date); select ts_bloom1_debug_hash('2025-05-05'::timestamp); select ts_bloom1_debug_hash('2025-05-05'::timestamptz); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_default.sql������������������������������������������������0000664�0000000�0000000�00000002171�15100345067�0022514�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Use a weird compression configuration to test decompression of all-default -- batch. create table t(ts int); select create_hypertable('t', 'ts'); \set ON_ERROR_STOP 0 alter table t set(timescaledb.compress, timescaledb.compress_segmentby = 'ts', timescaledb.compress_orderby = ''); \set ON_ERROR_STOP 1 alter table t set(timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t select generate_series(1, 10000); select count(*) from t; select count(compress_chunk(x, true)) from show_chunks('t') x; select count(*) from t; select count(decompress_chunk(x, true)) from show_chunks('t') x; select count(*) from t; -- Now add a column which will be all default in the compressed chunk select count(compress_chunk(x, true)) from show_chunks('t') x; alter table t add column x int default 7; select count(*), x from t group by x; select count(decompress_chunk(x, true)) from show_chunks('t') x; select count(*), x from t group by x; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_dml_copy.sql�����������������������������������������������0000664�0000000�0000000�00000002654�15100345067�0022704�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test various cases of COPY with decompression and different chunk layouts. create table cdmlcopy(filler bigint, ts int, value float, metric text); select create_hypertable('cdmlcopy', 'ts', chunk_time_interval => 1000); alter table cdmlcopy add unique (metric, ts); alter table cdmlcopy set (timescaledb.compress, timescaledb.compress_segmentby = 'metric'); \copy cdmlcopy from stdin 0 1 1.1 'metric1' 0 1 1.2 'metric2' \. select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; alter table cdmlcopy drop column filler; \copy cdmlcopy from stdin 1001 1.1 'metric1' 1001 1.2 'metric2' \. select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; \set ON_ERROR_STOP 0 \copy cdmlcopy from stdin 1 1.1 'metric1' 1 1.2 'metric2' \. \copy cdmlcopy from stdin 1001 1.1 'metric1' 1001 1.2 'metric2' \. \set ON_ERROR_STOP 1 -- Also test the code path where the chunk insert state goes out of cache. set timescaledb.max_open_chunks_per_insert = 1; select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; \copy cdmlcopy from stdin 2 2.1 'metric1' 1002 2.2 'metric2' 2 2.2 'metric2' 1002 2.1 'metric1' \. reset timescaledb.max_open_chunks_per_insert; select count(compress_chunk(x)) from show_chunks('cdmlcopy') x; drop table cdmlcopy; ������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_float8_corrupt.sql�����������������������������������������0000664�0000000�0000000�00000121302�15100345067�0024041�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- A test for https://github.com/timescale/timescaledb/issues/6681 -- create hypertable with enabled compression CREATE TABLE corrupt_float8 ( time timestamptz NOT NULL, value double precision NULL ); SELECT create_hypertable('corrupt_float8','time'); ALTER TABLE corrupt_float8 SET (timescaledb.compress); -- insert these 1000 values INSERT INTO corrupt_float8 VALUES ('2023-09-21 01:47:02.979+00', 11510.1), ('2023-09-21 01:48:03.58+00', 11510.6), ('2023-09-21 01:49:01.92+00', 11511), ('2023-09-21 01:50:02.49+00', 11511.5), ('2023-09-21 01:51:03.057+00', 11511.9), ('2023-09-21 01:52:01.554+00', 11512.4), ('2023-09-21 01:53:02.046+00', 11512.8), ('2023-09-21 01:54:02.826+00', 11513.3), ('2023-09-21 01:55:01.146+00', 11513.7), ('2023-09-21 01:56:01.816+00', 11514.2), ('2023-09-21 01:57:02.965+00', 11514.6), ('2023-09-21 01:58:02.167+00', 11515.1), ('2023-09-21 01:59:02.156+00', 11515.5), ('2023-09-21 02:00:02.447+00', 11516), ('2023-09-21 02:01:02.417+00', 11516.4), ('2023-09-21 02:02:02.581+00', 11516.9), ('2023-09-21 02:03:02.738+00', 11517.3), ('2023-09-21 02:04:03.17+00', 11517.8), ('2023-09-21 02:05:02.911+00', 11518.2), ('2023-09-21 02:06:02.123+00', 11518.7), ('2023-09-21 02:07:02.146+00', 11519.1), ('2023-09-21 02:08:02.247+00', 11519.5), ('2023-09-21 02:09:02.487+00', 11520), ('2023-09-21 02:10:02.804+00', 11520.4), ('2023-09-21 02:11:02.74+00', 11520.9), ('2023-09-21 02:12:02.932+00', 11521.3), ('2023-09-21 02:13:03.136+00', 11521.8), ('2023-09-21 02:14:02.162+00', 11522.2), ('2023-09-21 02:15:02.095+00', 11522.7), ('2023-09-21 02:16:02.506+00', 11523.1), ('2023-09-21 02:17:02.415+00', 11523.6), ('2023-09-21 02:18:02.822+00', 11524), ('2023-09-21 02:19:02.741+00', 11524.5), ('2023-09-21 02:20:02.918+00', 11524.9), ('2023-09-21 02:20:56.717+00', 11525.4), ('2023-09-21 02:21:57.127+00', 11525.8), ('2023-09-21 02:22:55.815+00', 11526.3), ('2023-09-21 02:23:56.451+00', 11526.7), ('2023-09-21 02:24:56.807+00', 11527.2), ('2023-09-21 02:25:55.308+00', 11527.6), ('2023-09-21 02:26:56.045+00', 11528.1), ('2023-09-21 02:27:56.367+00', 11528.5), ('2023-09-21 02:28:57.977+00', 11529), ('2023-09-21 02:29:58.144+00', 11529.4), ('2023-09-21 02:30:58.068+00', 11529.9), ('2023-09-21 02:31:57.158+00', 11530.3), ('2023-09-21 02:32:57.335+00', 11530.8), ('2023-09-21 02:33:57.451+00', 11531.2), ('2023-09-21 02:34:57.638+00', 11531.7), ('2023-09-21 02:35:57.792+00', 11532.1), ('2023-09-21 02:36:58.004+00', 11532.6), ('2023-09-21 02:37:58.344+00', 11533), ('2023-09-21 02:38:58.149+00', 11533.5), ('2023-09-21 02:39:57.412+00', 11533.9), ('2023-09-21 02:40:57.304+00', 11534.4), ('2023-09-21 02:41:57.685+00', 11534.8), ('2023-09-21 02:42:57.646+00', 11535.3), ('2023-09-21 02:43:57.785+00', 11535.7), ('2023-09-21 02:44:58.146+00', 11536.2), ('2023-09-21 02:45:51.775+00', 11536.6), ('2023-09-21 02:46:58.2+00', 11537.1), ('2023-09-21 02:47:57.326+00', 11537.5), ('2023-09-21 02:48:51.291+00', 11538), ('2023-09-21 02:49:51.858+00', 11538.4), ('2023-09-21 02:50:52.619+00', 11538.9), ('2023-09-21 02:51:50.777+00', 11539.3), ('2023-09-21 02:52:51.612+00', 11539.8), ('2023-09-21 02:53:51.985+00', 11540.2), ('2023-09-21 02:54:50.686+00', 11540.7), ('2023-09-21 02:55:51.064+00', 11541.1), ('2023-09-21 02:56:49.45+00', 11541.5), ('2023-09-21 02:57:50.012+00', 11542), ('2023-09-21 02:58:50.812+00', 11542.4), ('2023-09-21 02:59:49.043+00', 11542.9), ('2023-09-21 03:00:49.771+00', 11543.3), ('2023-09-21 03:01:52.277+00', 11543.8), ('2023-09-21 03:02:53.108+00', 11544.2), ('2023-09-21 03:03:53.297+00', 11544.7), ('2023-09-21 03:04:52.198+00', 11545.1), ('2023-09-21 03:05:52.32+00', 11545.6), ('2023-09-21 03:06:52.705+00', 11546), ('2023-09-21 03:07:52.653+00', 11546.5), ('2023-09-21 03:08:53.057+00', 11546.9), ('2023-09-21 03:09:52.978+00', 11547.4), ('2023-09-21 03:10:53.347+00', 11547.8), ('2023-09-21 03:11:53.323+00', 11548.3), ('2023-09-21 03:12:52.369+00', 11548.7), ('2023-09-21 03:13:52.352+00', 11549.2), ('2023-09-21 03:14:47.077+00', 11549.6), ('2023-09-21 03:15:47.383+00', 11550.1), ('2023-09-21 03:16:45.782+00', 11550.5), ('2023-09-21 03:17:46.458+00', 11551), ('2023-09-21 03:18:47.182+00', 11551.4), ('2023-09-21 03:19:47.6+00', 11551.9), ('2023-09-21 03:20:45.985+00', 11552.3), ('2023-09-21 03:21:46.534+00', 11552.7), ('2023-09-21 03:22:44.923+00', 11553.2), ('2023-09-21 03:23:45.56+00', 11553.6), ('2023-09-21 03:24:46.298+00', 11554.1), ('2023-09-21 03:25:44.604+00', 11554.5), ('2023-09-21 03:26:45.336+00', 11555), ('2023-09-21 03:27:45.636+00', 11555.4), ('2023-09-21 03:28:44.379+00', 11555.9), ('2023-09-21 03:29:44.737+00', 11556.3), ('2023-09-21 03:30:45.456+00', 11556.8), ('2023-09-21 03:31:43.739+00', 11557.2), ('2023-09-21 03:32:44.469+00', 11557.7), ('2023-09-21 03:33:42.794+00', 11558.1), ('2023-09-21 03:34:43.601+00', 11558.6), ('2023-09-21 03:35:43.845+00', 11559), ('2023-09-21 03:36:43.557+00', 11559.5), ('2023-09-21 03:37:44.316+00', 11559.9), ('2023-09-21 03:38:43.429+00', 11560.4), ('2023-09-21 03:39:42.446+00', 11560.8), ('2023-09-21 03:40:42.807+00', 11561.3), ('2023-09-21 03:41:43.031+00', 11561.7), ('2023-09-21 03:42:43.143+00', 11562.2), ('2023-09-21 03:43:43.107+00', 11562.6), ('2023-09-21 03:44:43.412+00', 11563.1), ('2023-09-21 03:45:43.438+00', 11563.5), ('2023-09-21 03:46:43.625+00', 11564), ('2023-09-21 03:47:42.403+00', 11564.4), ('2023-09-21 03:48:42.798+00', 11564.8), ('2023-09-21 03:49:42.735+00', 11565.3), ('2023-09-21 03:50:43.084+00', 11565.7), ('2023-09-21 03:51:43.065+00', 11566.2), ('2023-09-21 03:52:43.273+00', 11566.6), ('2023-09-21 03:53:43.627+00', 11567.1), ('2023-09-21 03:54:43.503+00', 11567.5), ('2023-09-21 03:55:42.395+00', 11568), ('2023-09-21 03:56:42.804+00', 11568.4), ('2023-09-21 03:57:42.73+00', 11568.9), ('2023-09-21 03:58:42.866+00', 11569.3), ('2023-09-21 03:59:43.089+00', 11569.8), ('2023-09-21 04:00:43.191+00', 11570.2), ('2023-09-21 04:01:43.656+00', 11570.7), ('2023-09-21 04:02:43.518+00', 11571.1), ('2023-09-21 04:03:42.432+00', 11571.6), ('2023-09-21 04:04:42.773+00', 11572), ('2023-09-21 04:05:42.751+00', 11572.5), ('2023-09-21 04:06:42.883+00', 11572.9), ('2023-09-21 04:07:43.263+00', 11573.4), ('2023-09-21 04:08:37.077+00', 11573.8), ('2023-09-21 04:09:37.691+00', 11574.3), ('2023-09-21 04:10:38.38+00', 11574.7), ('2023-09-21 04:11:36.603+00', 11575.2), ('2023-09-21 04:12:37.418+00', 11575.6), ('2023-09-21 04:13:37.783+00', 11576.1), ('2023-09-21 04:14:36.29+00', 11576.5), ('2023-09-21 04:15:36.894+00', 11576.9), ('2023-09-21 04:16:35.21+00', 11577.4), ('2023-09-21 04:17:35.845+00', 11577.8), ('2023-09-21 04:18:36.612+00', 11578.3), ('2023-09-21 04:19:34.883+00', 11578.7), ('2023-09-21 04:20:35.386+00', 11579.2), ('2023-09-21 04:21:35.932+00', 11579.6), ('2023-09-21 04:22:34.707+00', 11580.1), ('2023-09-21 04:23:34.972+00', 11580.5), ('2023-09-21 04:24:35.399+00', 11581), ('2023-09-21 04:25:34.019+00', 11581.4), ('2023-09-21 04:26:34.753+00', 11581.9), ('2023-09-21 04:27:35.001+00', 11582.3), ('2023-09-21 04:28:33.671+00', 11582.8), ('2023-09-21 04:29:34.134+00', 11583.2), ('2023-09-21 04:30:32.864+00', 11583.7), ('2023-09-21 04:31:33.162+00', 11584.1), ('2023-09-21 04:32:33.664+00', 11584.6), ('2023-09-21 04:33:33.127+00', 11585), ('2023-09-21 04:34:32.725+00', 11585.5), ('2023-09-21 04:35:33.492+00', 11585.9), ('2023-09-21 04:36:33.81+00', 11586.4), ('2023-09-21 04:37:32.392+00', 11586.8), ('2023-09-21 04:38:32.822+00', 11587.3), ('2023-09-21 04:39:34.116+00', 11587.7), ('2023-09-21 04:40:31.785+00', 11588.2), ('2023-09-21 04:41:32.284+00', 11588.6), ('2023-09-21 04:42:31.139+00', 11589.1), ('2023-09-21 04:43:31.423+00', 11589.5), ('2023-09-21 04:44:31.965+00', 11590), ('2023-09-21 04:45:30.468+00', 11590.4), ('2023-09-21 04:46:30.953+00', 11590.9), ('2023-09-21 04:47:31.54+00', 11591.3), ('2023-09-21 04:48:29.913+00', 11591.8), ('2023-09-21 04:49:30.531+00', 11592.2), ('2023-09-21 04:50:28.958+00', 11592.7), ('2023-09-21 04:51:29.642+00', 11593.1), ('2023-09-21 04:52:30.051+00', 11593.6), ('2023-09-21 04:53:28.669+00', 11594), ('2023-09-21 04:54:29.338+00', 11594.5), ('2023-09-21 04:55:29.727+00', 11594.9), ('2023-09-21 04:56:28.166+00', 11595.4), ('2023-09-21 04:57:28.687+00', 11595.8), ('2023-09-21 04:58:29.489+00', 11596.3), ('2023-09-21 04:59:27.771+00', 11596.7), ('2023-09-21 05:00:28.293+00', 11597.2), ('2023-09-21 05:01:28.719+00', 11597.6), ('2023-09-21 05:02:27.536+00', 11598.1), ('2023-09-21 05:03:27.875+00', 11598.5), ('2023-09-21 05:04:28.608+00', 11599), ('2023-09-21 05:05:26.938+00', 11599.4), ('2023-09-21 05:06:27.614+00', 11599.9), ('2023-09-21 05:07:25.913+00', 11600.3), ('2023-09-21 05:08:26.482+00', 11600.8), ('2023-09-21 05:09:27.02+00', 11601.2), ('2023-09-21 05:10:25.724+00', 11601.7), ('2023-09-21 05:11:28.978+00', 11602.1), ('2023-09-21 05:12:29.345+00', 11602.6), ('2023-09-21 05:13:29.338+00', 11603), ('2023-09-21 05:14:29.482+00', 11603.5), ('2023-09-21 05:15:29.81+00', 11603.9), ('2023-09-21 05:16:29.778+00', 11604.4), ('2023-09-21 05:17:29.805+00', 11604.8), ('2023-09-21 05:18:29.015+00', 11605.3), ('2023-09-21 05:19:28.97+00', 11605.7), ('2023-09-21 05:20:29.351+00', 11606.2), ('2023-09-21 05:21:29.312+00', 11606.6), ('2023-09-21 05:22:29.46+00', 11607.1), ('2023-09-21 05:23:29.721+00', 11607.5), ('2023-09-21 05:24:22.792+00', 11608), ('2023-09-21 05:25:23.341+00', 11608.4), ('2023-09-21 05:26:28.889+00', 11608.9), ('2023-09-21 05:27:29.059+00', 11609.3), ('2023-09-21 05:28:23.166+00', 11609.8), ('2023-09-21 05:29:23.487+00', 11610.2), ('2023-09-21 05:30:21.988+00', 11610.7), ('2023-09-21 05:31:22.489+00', 11611.1), ('2023-09-21 05:32:23.127+00', 11611.6), ('2023-09-21 05:33:21.422+00', 11612), ('2023-09-21 05:34:22.057+00', 11612.5), ('2023-09-21 05:35:22.46+00', 11612.9), ('2023-09-21 05:36:21.052+00', 11613.4), ('2023-09-21 05:37:21.574+00', 11613.8), ('2023-09-21 05:38:22.161+00', 11614.3), ('2023-09-21 05:39:20.551+00', 11614.7), ('2023-09-21 05:40:23.755+00', 11615.2), ('2023-09-21 05:41:24.794+00', 11615.6), ('2023-09-21 05:42:23.801+00', 11616.1), ('2023-09-21 05:43:23.864+00', 11616.5), ('2023-09-21 05:44:24.049+00', 11617), ('2023-09-21 05:45:24.428+00', 11617.4), ('2023-09-21 05:46:24.395+00', 11617.9), ('2023-09-21 05:47:18.864+00', 11618.3), ('2023-09-21 05:48:19.389+00', 11618.8), ('2023-09-21 05:49:20.095+00', 11619.2), ('2023-09-21 05:50:18.402+00', 11619.7), ('2023-09-21 05:51:18.817+00', 11620.1), ('2023-09-21 05:52:19.442+00', 11620.6), ('2023-09-21 05:53:17.993+00', 11621), ('2023-09-21 05:54:18.579+00', 11621.5), ('2023-09-21 05:55:19.253+00', 11621.9), ('2023-09-21 05:56:17.538+00', 11622.4), ('2023-09-21 05:57:18.311+00', 11622.8), ('2023-09-21 05:58:18.536+00', 11623.3), ('2023-09-21 05:59:17.092+00', 11623.7), ('2023-09-21 06:00:17.608+00', 11624.2), ('2023-09-21 06:01:18.148+00', 11624.6), ('2023-09-21 06:02:16.704+00', 11625.1), ('2023-09-21 06:03:17.407+00', 11625.5), ('2023-09-21 06:04:15.791+00', 11626), ('2023-09-21 06:05:16.247+00', 11626.4), ('2023-09-21 06:06:16.787+00', 11626.9), ('2023-09-21 06:07:17.481+00', 11627.3), ('2023-09-21 06:08:15.829+00', 11627.8), ('2023-09-21 06:09:16.542+00', 11628.2), ('2023-09-21 06:10:14.868+00', 11628.7), ('2023-09-21 06:11:15.393+00', 11629.1), ('2023-09-21 06:12:15.852+00', 11629.6), ('2023-09-21 06:13:14.443+00', 11630.1), ('2023-09-21 06:14:16.033+00', 11630.5), ('2023-09-21 06:15:16.215+00', 11631), ('2023-09-21 06:16:16.338+00', 11631.4), ('2023-09-21 06:17:14.444+00', 11631.9), ('2023-09-21 06:18:15.135+00', 11632.3), ('2023-09-21 06:19:13.871+00', 11632.8), ('2023-09-21 06:20:14.107+00', 11633.2), ('2023-09-21 06:21:12.515+00', 11633.7), ('2023-09-21 06:22:13.252+00', 11634.1), ('2023-09-21 06:23:13.651+00', 11634.6), ('2023-09-21 06:24:14.148+00', 11635.1), ('2023-09-21 06:25:12.924+00', 11635.5), ('2023-09-21 06:26:13.286+00', 11636), ('2023-09-21 06:27:11.948+00', 11636.4), ('2023-09-21 06:28:12.262+00', 11636.9), ('2023-09-21 06:29:13.047+00', 11637.3), ('2023-09-21 06:30:11.366+00', 11637.8), ('2023-09-21 06:31:11.891+00', 11638.2), ('2023-09-21 06:32:12.416+00', 11638.7), ('2023-09-21 06:33:11.149+00', 11639.2), ('2023-09-21 06:34:11.408+00', 11639.6), ('2023-09-21 06:35:11.948+00', 11640.1), ('2023-09-21 06:36:10.468+00', 11640.5), ('2023-09-21 06:37:11.025+00', 11641), ('2023-09-21 06:38:09.54+00', 11641.4), ('2023-09-21 06:39:10.056+00', 11641.9), ('2023-09-21 06:40:10.609+00', 11642.4), ('2023-09-21 06:41:09.119+00', 11642.8), ('2023-09-21 06:42:09.584+00', 11643.3), ('2023-09-21 06:43:10.271+00', 11643.7), ('2023-09-21 06:44:08.672+00', 11644.2), ('2023-09-21 06:45:09.145+00', 11644.6), ('2023-09-21 06:46:09.605+00', 11645.1), ('2023-09-21 06:47:11.081+00', 11645.6), ('2023-09-21 06:48:11.102+00', 11646), ('2023-09-21 06:49:10.165+00', 11646.5), ('2023-09-21 06:50:10.302+00', 11646.9), ('2023-09-21 06:51:10.416+00', 11647.4), ('2023-09-21 06:52:10.651+00', 11647.8), ('2023-09-21 06:53:10.815+00', 11648.3), ('2023-09-21 06:54:11.113+00', 11648.8), ('2023-09-21 06:55:11.041+00', 11649.2), ('2023-09-21 06:56:11.373+00', 11649.7), ('2023-09-21 06:57:10.195+00', 11650.1), ('2023-09-21 06:58:10.392+00', 11650.6), ('2023-09-21 06:59:10.447+00', 11651), ('2023-09-21 07:00:10.605+00', 11651.5), ('2023-09-21 07:01:10.186+00', 11652), ('2023-09-21 07:02:10.96+00', 11652.4), ('2023-09-21 07:03:11.098+00', 11652.9), ('2023-09-21 07:04:11.103+00', 11653.3), ('2023-09-21 07:05:10.124+00', 11653.8), ('2023-09-21 07:06:10.018+00', 11654.2), ('2023-09-21 07:07:04.697+00', 11654.7), ('2023-09-21 07:08:05.308+00', 11655.2), ('2023-09-21 07:09:05.957+00', 11655.6), ('2023-09-21 07:10:05.837+00', 11656.1), ('2023-09-21 07:11:05.948+00', 11656.5), ('2023-09-21 07:12:06.985+00', 11657), ('2023-09-21 07:13:03.86+00', 11657.4), ('2023-09-21 07:14:04.378+00', 11657.9), ('2023-09-21 07:15:04.933+00', 11658.3), ('2023-09-21 07:16:03.452+00', 11658.8), ('2023-09-21 07:17:03.96+00', 11659.3), ('2023-09-21 07:18:02.426+00', 11659.7), ('2023-09-21 07:19:02.987+00', 11660.2), ('2023-09-21 07:20:03.485+00', 11660.6), ('2023-09-21 07:21:01.898+00', 11661.1), ('2023-09-21 07:22:02.569+00', 11661.5), ('2023-09-21 07:23:03.288+00', 11662), ('2023-09-21 07:24:01.604+00', 11662.5), ('2023-09-21 07:25:02.039+00', 11662.9), ('2023-09-21 07:26:02.688+00', 11663.4), ('2023-09-21 07:27:01.368+00', 11663.8), ('2023-09-21 07:28:01.709+00', 11664.3), ('2023-09-21 07:29:02.413+00', 11664.7), ('2023-09-21 07:30:03.995+00', 11665.2), ('2023-09-21 07:31:04.014+00', 11665.6), ('2023-09-21 07:32:04.187+00', 11666.1), ('2023-09-21 07:33:04.579+00', 11666.6), ('2023-09-21 07:34:04.576+00', 11667), ('2023-09-21 07:35:04.743+00', 11667.5), ('2023-09-21 07:36:04.816+00', 11667.9), ('2023-09-21 07:37:03.935+00', 11668.4), ('2023-09-21 07:38:03.944+00', 11668.8), ('2023-09-21 07:39:04.262+00', 11669.3), ('2023-09-21 07:40:04.182+00', 11669.7), ('2023-09-21 07:40:58.554+00', 11670.2), ('2023-09-21 07:41:59.049+00', 11670.6), ('2023-09-21 07:42:59.797+00', 11671.1), ('2023-09-21 07:43:58.071+00', 11671.6), ('2023-09-21 07:44:58.855+00', 11672), ('2023-09-21 07:45:59.156+00', 11672.5), ('2023-09-21 07:46:57.866+00', 11672.9), ('2023-09-21 07:47:58.175+00', 11673.4), ('2023-09-21 07:48:58.634+00', 11673.8), ('2023-09-21 07:49:57.234+00', 11674.3), ('2023-09-21 07:50:57.819+00', 11674.7), ('2023-09-21 07:51:58.313+00', 11675.2), ('2023-09-21 07:52:56.995+00', 11675.6), ('2023-09-21 07:53:57.402+00', 11676.1), ('2023-09-21 07:54:55.891+00', 11676.6), ('2023-09-21 07:55:56.369+00', 11677), ('2023-09-21 07:56:57.119+00', 11677.5), ('2023-09-21 07:57:55.453+00', 11677.9), ('2023-09-21 07:58:56.174+00', 11678.4), ('2023-09-21 07:59:56.469+00', 11678.8), ('2023-09-21 08:00:55.199+00', 11679.3), ('2023-09-21 08:01:55.557+00', 11679.7), ('2023-09-21 08:02:56.072+00', 11680.2), ('2023-09-21 08:03:54.811+00', 11680.6), ('2023-09-21 08:04:55.138+00', 11681.1), ('2023-09-21 08:05:55.696+00', 11681.6), ('2023-09-21 08:06:54.367+00', 11682),('2023-09-21 08:07:54.539+00', 11682.5), ('2023-09-21 08:08:55.395+00', 11682.9), ('2023-09-21 08:09:53.689+00', 11683.4), ('2023-09-21 08:10:54.472+00', 11683.8), ('2023-09-21 08:11:52.816+00', 11684.3),('2023-09-21 08:12:53.36+00', 11684.7), ('2023-09-21 08:13:53.873+00', 11685.2), ('2023-09-21 08:14:52.398+00', 11685.6), ('2023-09-21 08:15:53.109+00', 11686.1), ('2023-09-21 08:16:53.569+00', 11686.5), ('2023-09-21 08:17:51.902+00', 11687), ('2023-09-21 08:18:52.423+00', 11687.5), ('2023-09-21 08:19:53.196+00', 11687.9), ('2023-09-21 08:20:51.481+00', 11688.4), ('2023-09-21 08:21:52.268+00', 11688.8),('2023-09-21 08:22:53.475+00', 11689.3), ('2023-09-21 08:23:53.368+00', 11689.7), ('2023-09-21 08:24:51.489+00', 11690.2), ('2023-09-21 08:25:50.098+00', 11690.6), ('2023-09-21 08:26:50.545+00', 11691.1), ('2023-09-21 08:27:51.451+00', 11691.5), ('2023-09-21 08:28:51.869+00', 11692), ('2023-09-21 08:29:50.213+00', 11692.5), ('2023-09-21 08:30:50.808+00', 11692.9), ('2023-09-21 08:31:49.158+00', 11693.4), ('2023-09-21 08:32:49.82+00', 11693.8), ('2023-09-21 08:33:50.416+00', 11694.3), ('2023-09-21 08:34:48.849+00', 11694.7), ('2023-09-21 08:35:49.29+00', 11695.2), ('2023-09-21 08:36:49.922+00', 11695.6), ('2023-09-21 08:37:48.329+00', 11696.1), ('2023-09-21 08:38:48.988+00', 11696.6), ('2023-09-21 08:39:49.492+00', 11697), ('2023-09-21 08:40:47.935+00', 11697.5), ('2023-09-21 08:41:48.595+00', 11697.9), ('2023-09-21 08:42:47.033+00', 11698.4), ('2023-09-21 08:43:47.533+00', 11698.8), ('2023-09-21 08:44:48.1+00', 11699.3), ('2023-09-21 08:45:48.509+00', 11699.7), ('2023-09-21 08:46:47.043+00', 11700.2), ('2023-09-21 08:47:47.651+00', 11700.6), ('2023-09-21 08:48:48.275+00', 11701.1), ('2023-09-21 08:49:46.592+00', 11701.5), ('2023-09-21 08:50:47.252+00', 11702), ('2023-09-21 08:51:45.76+00', 11702.5), ('2023-09-21 08:52:46.439+00', 11702.9), ('2023-09-21 08:53:46.835+00', 11703.4), ('2023-09-21 08:54:45.358+00', 11703.8), ('2023-09-21 08:55:46.072+00', 11704.3), ('2023-09-21 08:56:46.419+00', 11704.7), ('2023-09-21 08:57:45.119+00', 11705.2), ('2023-09-21 08:58:45.536+00', 11705.6), ('2023-09-21 08:59:45.95+00', 11706.1), ('2023-09-21 09:00:44.454+00', 11706.5), ('2023-09-21 09:01:45.887+00', 11707), ('2023-09-21 09:02:45.451+00', 11707.4), ('2023-09-21 09:03:43.964+00', 11707.9), ('2023-09-21 09:04:44.669+00', 11708.4), ('2023-09-21 09:05:43.095+00', 11708.8), ('2023-09-21 09:06:43.746+00', 11709.3), ('2023-09-21 09:07:44.38+00', 11709.7), ('2023-09-21 09:08:42.674+00', 11710.2), ('2023-09-21 09:09:43.368+00', 11710.6), ('2023-09-21 09:10:43.729+00', 11711.1), ('2023-09-21 09:11:42.397+00', 11711.5), ('2023-09-21 09:12:42.799+00', 11712), ('2023-09-21 09:13:43.478+00', 11712.4), ('2023-09-21 09:14:41.831+00', 11712.9), ('2023-09-21 09:15:42.571+00', 11713.4), ('2023-09-21 09:16:42.938+00', 11713.8), ('2023-09-21 09:17:41.378+00', 11714.3), ('2023-09-21 09:18:41.944+00', 11714.7), ('2023-09-21 09:19:42.644+00', 11715.2), ('2023-09-21 09:20:40.934+00', 11715.6), ('2023-09-21 09:21:41.641+00', 11716.1), ('2023-09-21 09:22:41.987+00', 11716.5), ('2023-09-21 09:23:40.707+00', 11717), ('2023-09-21 09:24:41.053+00', 11717.5), ('2023-09-21 09:25:41.714+00', 11717.9), ('2023-09-21 09:26:40.355+00', 11718.4), ('2023-09-21 09:27:40.575+00', 11718.8), ('2023-09-21 09:28:40.676+00', 11719.3), ('2023-09-21 09:29:40.733+00', 11719.8), ('2023-09-21 09:30:40.143+00', 11720.2), ('2023-09-21 09:31:39.855+00', 11720.7), ('2023-09-21 09:32:40.03+00', 11721.2), ('2023-09-21 09:33:40.392+00', 11721.6), ('2023-09-21 09:34:40.367+00', 11722.1), ('2023-09-21 09:35:40.537+00', 11722.6), ('2023-09-21 09:36:40.654+00', 11723), ('2023-09-21 09:37:40.918+00', 11723.5), ('2023-09-21 09:38:39.712+00', 11724), ('2023-09-21 09:39:40.146+00', 11724.4), ('2023-09-21 09:40:39.999+00', 11724.9), ('2023-09-21 09:41:40.216+00', 11725.4), ('2023-09-21 09:42:40.392+00', 11725.8), ('2023-09-21 09:43:40.541+00', 11726.3), ('2023-09-21 09:44:40.68+00', 11726.8), ('2023-09-21 09:45:40.815+00', 11727.2), ('2023-09-21 09:46:40.768+00', 11727.7), ('2023-09-21 09:47:40.039+00', 11728.1), ('2023-09-21 09:48:40.001+00', 11728.6), ('2023-09-21 09:49:36.444+00', 11729.1), ('2023-09-21 09:50:36.697+00', 11729.5), ('2023-09-21 09:51:35.355+00', 11730), ('2023-09-21 09:52:35.677+00', 11730.5), ('2023-09-21 09:53:36.315+00', 11730.9), ('2023-09-21 09:54:34.723+00', 11731.4), ('2023-09-21 09:55:35.299+00', 11731.9), ('2023-09-21 09:56:35.851+00', 11732.3), ('2023-09-21 09:57:34.322+00', 11732.8), ('2023-09-21 09:58:35.417+00', 11733.2), ('2023-09-21 09:59:35.401+00', 11733.7), ('2023-09-21 10:00:35.567+00', 11734.2), ('2023-09-21 10:01:35.55+00', 11734.6), ('2023-09-21 10:02:34.606+00', 11735.1), ('2023-09-21 10:03:34.787+00', 11735.6), ('2023-09-21 10:04:35.087+00', 11736), ('2023-09-21 10:05:35.1+00', 11736.5), ('2023-09-21 10:06:35.482+00', 11737), ('2023-09-21 10:07:38.022+00', 11737.4), ('2023-09-21 10:08:32.068+00', 11737.9), ('2023-09-21 10:09:32.563+00', 11738.4), ('2023-09-21 10:10:34.745+00', 11738.8), ('2023-09-21 10:11:31.612+00', 11739.3), ('2023-09-21 10:12:32.372+00', 11739.8), ('2023-09-21 10:13:30.661+00', 11740.2), ('2023-09-21 10:14:31.241+00', 11740.7), ('2023-09-21 10:15:31.732+00', 11741.1), ('2023-09-21 10:16:30.403+00', 11741.6), ('2023-09-21 10:17:30.774+00', 11742.1), ('2023-09-21 10:18:31.534+00', 11742.5), ('2023-09-21 10:19:29.866+00', 11743), ('2023-09-21 10:20:30.35+00', 11743.5),('2023-09-21 10:21:30.874+00', 11743.9), ('2023-09-21 10:22:29.553+00', 11744.4), ('2023-09-21 10:23:29.869+00', 11744.9), ('2023-09-21 10:24:30.676+00', 11745.3), ('2023-09-21 10:25:28.967+00', 11745.8), ('2023-09-21 10:26:29.472+00', 11746.2), ('2023-09-21 10:27:29.967+00', 11746.7), ('2023-09-21 10:28:28.424+00', 11747.2), ('2023-09-21 10:29:31.324+00', 11747.6), ('2023-09-21 10:30:31.457+00', 11748.1), ('2023-09-21 10:31:30.26+00', 11748.6), ('2023-09-21 10:32:28.606+00', 11749), ('2023-09-21 10:33:29.332+00', 11749.5), ('2023-09-21 10:34:29.651+00', 11750), ('2023-09-21 10:35:29.608+00', 11750.4), ('2023-09-21 10:36:29.987+00', 11750.9), ('2023-09-21 10:37:30.03+00', 11751.3), ('2023-09-21 10:38:30.122+00', 11751.8), ('2023-09-21 10:39:28.979+00', 11752.3), ('2023-09-21 10:40:29.138+00', 11752.7), ('2023-09-21 10:41:29.347+00', 11753.2), ('2023-09-21 10:42:29.681+00', 11753.6), ('2023-09-21 10:43:29.631+00', 11754.1), ('2023-09-21 10:44:29.887+00', 11754.6), ('2023-09-21 10:45:29.97+00', 11755), ('2023-09-21 10:46:30.025+00', 11755.5), ('2023-09-21 10:47:29.226+00', 11755.9), ('2023-09-21 10:48:29.189+00', 11756.4), ('2023-09-21 10:49:29.301+00', 11756.8), ('2023-09-21 10:50:29.486+00', 11757.3), ('2023-09-21 10:51:29.688+00', 11757.8), ('2023-09-21 10:52:29.971+00', 11758.2), ('2023-09-21 10:53:29.963+00', 11758.7), ('2023-09-21 10:54:30.021+00', 11759.1), ('2023-09-21 10:55:28.991+00', 11759.6), ('2023-09-21 10:56:23.028+00', 11760), ('2023-09-21 10:57:23.685+00', 11760.5), ('2023-09-21 10:58:24.122+00', 11761), ('2023-09-21 10:59:24.993+00', 11761.4), ('2023-09-21 11:00:24.91+00', 11761.9), ('2023-09-21 11:01:28.903+00', 11762.3), ('2023-09-21 11:02:22.265+00', 11762.8), ('2023-09-21 11:03:25.233+00', 11763.2), ('2023-09-21 11:04:26.619+00', 11763.7), ('2023-09-21 11:05:26.779+00', 11764.2), ('2023-09-21 11:06:27.107+00', 11764.6), ('2023-09-21 11:07:27.037+00', 11765.1), ('2023-09-21 11:08:27.222+00', 11765.5), ('2023-09-21 11:09:27.252+00', 11766), ('2023-09-21 11:10:26.536+00', 11766.4), ('2023-09-21 11:11:21.076+00', 11766.9), ('2023-09-21 11:12:21.514+00', 11767.3), ('2023-09-21 11:13:22.228+00', 11767.8), ('2023-09-21 11:14:20.66+00', 11768.2), ('2023-09-21 11:15:21.099+00', 11768.7), ('2023-09-21 11:16:19.7+00', 11769.1), ('2023-09-21 11:17:20.101+00', 11769.6), ('2023-09-21 11:18:20.629+00', 11770.1), ('2023-09-21 11:19:19.144+00', 11770.5), ('2023-09-21 11:20:19.682+00', 11771), ('2023-09-21 11:21:20.096+00', 11771.4), ('2023-09-21 11:22:18.827+00', 11771.9), ('2023-09-21 11:23:19.092+00', 11772.3), ('2023-09-21 11:24:19.848+00', 11772.8), ('2023-09-21 11:25:18.18+00', 11773.2), ('2023-09-21 11:26:18.847+00', 11773.7), ('2023-09-21 11:27:19.375+00', 11774.1), ('2023-09-21 11:28:17.932+00', 11774.6), ('2023-09-21 11:29:18.24+00', 11775), ('2023-09-21 11:30:16.906+00', 11775.5), ('2023-09-21 11:31:17.314+00', 11775.9), ('2023-09-21 11:32:20.845+00', 11776.4), ('2023-09-21 11:33:18.501+00', 11776.9), ('2023-09-21 11:34:17.06+00', 11777.3), ('2023-09-21 11:35:17.405+00', 11777.8), ('2023-09-21 11:36:16.025+00', 11778.2), ('2023-09-21 11:37:16.534+00', 11778.7), ('2023-09-21 11:38:16.981+00', 11779.1), ('2023-09-21 11:39:15.554+00', 11779.6), ('2023-09-21 11:40:16.115+00', 11780), ('2023-09-21 11:41:16.68+00', 11780.5), ('2023-09-21 11:42:15.136+00', 11780.9), ('2023-09-21 11:43:15.916+00', 11781.4), ('2023-09-21 11:44:16.234+00', 11781.8), ('2023-09-21 11:45:14.933+00', 11782.3), ('2023-09-21 11:46:15.224+00', 11782.7), ('2023-09-21 11:47:15.665+00', 11783.2), ('2023-09-21 11:48:14.307+00', 11783.6), ('2023-09-21 11:49:14.827+00', 11784.1), ('2023-09-21 11:50:18.735+00', 11784.5), ('2023-09-21 11:51:16.13+00', 11785), ('2023-09-21 11:52:16.147+00', 11785.4), ('2023-09-21 11:53:15.412+00', 11785.9), ('2023-09-21 11:54:15.415+00', 11786.3), ('2023-09-21 11:55:15.755+00', 11786.8), ('2023-09-21 11:56:15.768+00', 11787.2), ('2023-09-21 11:57:16.069+00', 11787.7), ('2023-09-21 11:58:16.037+00', 11788.1), ('2023-09-21 11:59:16.23+00', 11788.6), ('2023-09-21 12:00:16.24+00', 11789), ('2023-09-21 12:01:12.992+00', 11789.5), ('2023-09-21 12:02:11.59+00', 11789.9), ('2023-09-21 12:03:12.348+00', 11790.4), ('2023-09-21 12:04:12.664+00', 11790.8), ('2023-09-21 12:05:11.419+00', 11791.3), ('2023-09-21 12:06:11.719+00', 11791.7), ('2023-09-21 12:07:10.443+00', 11792.2), ('2023-09-21 12:08:10.8+00', 11792.6), ('2023-09-21 12:09:11.316+00', 11793.1), ('2023-09-21 12:10:09.786+00', 11793.5), ('2023-09-21 12:11:10.404+00', 11794), ('2023-09-21 12:12:10.908+00', 11794.4), ('2023-09-21 12:13:10.951+00', 11794.9), ('2023-09-21 12:14:10.929+00', 11795.3), ('2023-09-21 12:15:11.16+00', 11795.8), ('2023-09-21 12:16:11.263+00', 11796.2), ('2023-09-21 12:17:09.518+00', 11796.6), ('2023-09-21 12:18:10.283+00', 11797.1), ('2023-09-21 12:19:10.559+00', 11797.5), ('2023-09-21 12:20:11.842+00', 11798), ('2023-09-21 12:21:09.596+00', 11798.4), ('2023-09-21 12:22:08.003+00', 11798.9), ('2023-09-21 12:23:08.591+00', 11799.3), ('2023-09-21 12:24:09.11+00', 11799.8), ('2023-09-21 12:25:07.746+00', 11800.2), ('2023-09-21 12:26:08.472+00', 11800.7), ('2023-09-21 12:27:06.725+00', 11801.1), ('2023-09-21 12:28:07.322+00', 11801.6), ('2023-09-21 12:29:07.773+00', 11802), ('2023-09-21 12:30:06.47+00', 11802.4), ('2023-09-21 12:31:06.836+00', 11802.9), ('2023-09-21 12:32:07.465+00', 11803.3), ('2023-09-21 12:33:05.827+00', 11803.8), ('2023-09-21 12:34:06.427+00', 11804.2), ('2023-09-21 12:35:06.883+00', 11804.7), ('2023-09-21 12:36:05.623+00', 11805.1), ('2023-09-21 12:37:09.441+00', 11805.6), ('2023-09-21 12:38:09.018+00', 11806), ('2023-09-21 12:39:09.77+00', 11806.5), ('2023-09-21 12:40:05.987+00', 11806.9), ('2023-09-21 12:41:06.134+00', 11807.4), ('2023-09-21 12:42:04.763+00', 11807.8), ('2023-09-21 12:43:05.215+00', 11808.3), ('2023-09-21 12:44:03.786+00', 11808.7), ('2023-09-21 12:45:06.96+00', 11809.2), ('2023-09-21 12:46:07.047+00', 11809.6), ('2023-09-21 12:47:03.313+00', 11810.1), ('2023-09-21 12:48:03.766+00', 11810.5), ('2023-09-21 12:49:04.268+00', 11811), ('2023-09-21 12:50:02.874+00', 11811.4), ('2023-09-21 12:51:03.321+00', 11811.8), ('2023-09-21 12:52:04.015+00', 11812.3), ('2023-09-21 12:53:02.348+00', 11812.7), ('2023-09-21 12:54:02.87+00', 11813.2), ('2023-09-21 12:55:03.392+00', 11813.6), ('2023-09-21 12:56:02.056+00', 11814.1), ('2023-09-21 12:57:02.546+00', 11814.5), ('2023-09-21 12:58:06.511+00', 11815), ('2023-09-21 12:59:02.926+00', 11815.4), ('2023-09-21 13:00:02.203+00', 11815.9), ('2023-09-21 13:01:00.586+00', 11816.3), ('2023-09-21 13:02:01.156+00', 11816.8), ('2023-09-21 13:03:01.737+00', 11817.2), ('2023-09-21 13:04:00.227+00', 11817.7), ('2023-09-21 13:05:00.75+00', 11818.1), ('2023-09-21 13:06:01.276+00', 11818.6), ('2023-09-21 13:07:00.013+00', 11819), ('2023-09-21 13:08:00.403+00', 11819.5), ('2023-09-21 13:09:00.719+00', 11819.9), ('2023-09-21 13:10:00.882+00', 11820.4), ('2023-09-21 13:11:03.409+00', 11820.8), ('2023-09-21 13:12:00.495+00', 11821.3), ('2023-09-21 13:12:58.86+00', 11821.7), ('2023-09-21 13:14:03.981+00', 11822.2), ('2023-09-21 13:15:00.279+00', 11822.6), ('2023-09-21 13:16:00.353+00', 11823.1), ('2023-09-21 13:17:00.498+00', 11823.5), ('2023-09-21 13:17:57.688+00', 11824), ('2023-09-21 13:18:57.933+00', 11824.4), ('2023-09-21 13:19:58.472+00', 11824.9), ('2023-09-21 13:20:57.313+00', 11825.3), ('2023-09-21 13:21:57.631+00', 11825.8), ('2023-09-21 13:22:58.245+00', 11826.2), ('2023-09-21 13:24:01.669+00', 11826.7), ('2023-09-21 13:25:02.019+00', 11827.1), ('2023-09-21 13:26:02.019+00', 11827.6), ('2023-09-21 13:26:59.552+00', 11828), ('2023-09-21 13:27:59.704+00', 11828.5), ('2023-09-21 13:28:58.61+00', 11828.9), ('2023-09-21 13:29:58.764+00', 11829.4), ('2023-09-21 13:30:58.875+00', 11829.8), ('2023-09-21 13:31:59.107+00', 11830.3), ('2023-09-21 13:33:00.545+00', 11830.7), ('2023-09-21 13:34:00.709+00', 11831.2), ('2023-09-21 13:35:00.857+00', 11831.6), ('2023-09-21 13:35:54.972+00', 11832.1), ('2023-09-21 13:36:55.494+00', 11832.5), ('2023-09-21 13:37:54.207+00', 11833), ('2023-09-21 13:38:54.571+00', 11833.4), ('2023-09-21 13:39:55.053+00', 11833.9), ('2023-09-21 13:40:53.604+00', 11834.3), ('2023-09-21 13:41:54.32+00', 11834.8), ('2023-09-21 13:42:54.624+00', 11835.2), ('2023-09-21 13:43:53.368+00', 11835.7), ('2023-09-21 13:44:53.689+00', 11836.1), ('2023-09-21 13:45:54.473+00', 11836.6), ('2023-09-21 13:46:52.757+00', 11837), ('2023-09-21 13:47:53.142+00', 11837.5), ('2023-09-21 13:48:53.979+00', 11837.9), ('2023-09-21 13:49:52.222+00', 11838.4), ('2023-09-21 13:50:52.906+00', 11838.8), ('2023-09-21 13:51:51.387+00', 11839.3), ('2023-09-21 13:52:52.112+00', 11839.7), ('2023-09-21 13:53:52.454+00', 11840.2), ('2023-09-21 13:54:51.235+00', 11840.6), ('2023-09-21 13:55:51.653+00', 11841.1), ('2023-09-21 13:56:52.024+00', 11841.5), ('2023-09-21 13:57:50.473+00', 11842), ('2023-09-21 13:58:51.15+00', 11842.4), ('2023-09-21 13:59:51.573+00', 11842.9), ('2023-09-21 14:00:50.873+00', 11843.3), ('2023-09-21 14:01:51.317+00', 11843.8), ('2023-09-21 14:02:51.287+00', 11844.2), ('2023-09-21 14:03:51.571+00', 11844.7), ('2023-09-21 14:04:50.797+00', 11845.1), ('2023-09-21 14:05:50.74+00', 11845.6), ('2023-09-21 14:06:50.578+00', 11846), ('2023-09-21 14:07:51.149+00', 11846.5), ('2023-09-21 14:08:51.828+00', 11846.9), ('2023-09-21 14:09:51.077+00', 11847.4), ('2023-09-21 14:10:52.151+00', 11847.8), ('2023-09-21 14:11:51.228+00', 11848.3), ('2023-09-21 14:12:50.821+00', 11848.7), ('2023-09-21 14:13:50.41+00', 11849.2), ('2023-09-21 14:14:50.543+00', 11849.6), ('2023-09-21 14:15:50.756+00', 11850.1), ('2023-09-21 14:16:50.795+00', 11850.5), ('2023-09-21 14:17:51.059+00', 11851), ('2023-09-21 14:18:47.501+00', 11851.4), ('2023-09-21 14:19:47.927+00', 11851.9), ('2023-09-21 14:20:46.57+00', 11852.3), ('2023-09-21 14:21:47.108+00', 11852.8), ('2023-09-21 14:22:47.755+00', 11853.2), ('2023-09-21 14:23:46.144+00', 11853.7), ('2023-09-21 14:24:46.648+00', 11854.1), ('2023-09-21 14:25:46.147+00', 11854.6), ('2023-09-21 14:26:46.139+00', 11855), ('2023-09-21 14:27:46.272+00', 11855.5), ('2023-09-21 14:28:46.812+00', 11855.9), ('2023-09-21 14:29:45.342+00', 11856.4), ('2023-09-21 14:30:45.802+00', 11856.8), ('2023-09-21 14:31:44.242+00', 11857.3), ('2023-09-21 14:32:44.867+00', 11857.7), ('2023-09-21 14:33:51.275+00', 11858.2), ('2023-09-21 14:34:43.904+00', 11858.6), ('2023-09-21 14:35:44.441+00', 11859.1), ('2023-09-21 14:36:44.998+00', 11859.5), ('2023-09-21 14:37:43.419+00', 11860), ('2023-09-21 14:38:44.052+00', 11860.4), ('2023-09-21 14:39:44.584+00', 11860.9), ('2023-09-21 14:40:43.036+00', 11861.3), ('2023-09-21 14:41:43.614+00', 11861.8), ('2023-09-21 14:42:42.136+00', 11862.2), ('2023-09-21 14:43:42.857+00', 11862.7), ('2023-09-21 14:44:43.092+00', 11863.1), ('2023-09-21 14:45:43.633+00', 11863.6), ('2023-09-21 14:46:42.493+00', 11864), ('2023-09-21 14:47:42.746+00', 11864.5), ('2023-09-21 14:48:41.239+00', 11864.9), ('2023-09-21 14:49:41.806+00', 11865.4), ('2023-09-21 14:50:42.36+00', 11865.8), ('2023-09-21 14:51:41.334+00', 11866.2), ('2023-09-21 14:52:41.364+00', 11866.7), ('2023-09-21 14:53:42.106+00', 11867.1), ('2023-09-21 14:54:41.611+00', 11867.6), ('2023-09-21 14:55:40.985+00', 11868), ('2023-09-21 14:56:41.471+00', 11868.5), ('2023-09-21 14:57:40.907+00', 11868.9), ('2023-09-21 14:58:41.05+00', 11869.4), ('2023-09-21 14:59:41.333+00', 11869.8), ('2023-09-21 15:00:41.325+00', 11870.3), ('2023-09-21 15:01:41.489+00', 11870.7), ('2023-09-21 15:02:41.82+00', 11871.2), ('2023-09-21 15:03:40.576+00', 11871.6), ('2023-09-21 15:04:41.613+00', 11872.1), ('2023-09-21 15:05:40.874+00', 11872.5), ('2023-09-21 15:06:41.058+00', 11873), ('2023-09-21 15:07:41.308+00', 11873.4), ('2023-09-21 15:08:41.305+00', 11873.9), ('2023-09-21 15:09:41.686+00', 11874.3), ('2023-09-21 15:10:41.624+00', 11874.8), ('2023-09-21 15:11:40.526+00', 11875.2), ('2023-09-21 15:12:40.874+00', 11875.7), ('2023-09-21 15:13:40.826+00', 11876.1), ('2023-09-21 15:14:41.218+00', 11876.6), ('2023-09-21 15:15:41.148+00', 11877), ('2023-09-21 15:16:41.344+00', 11877.5), ('2023-09-21 15:17:41.694+00', 11877.9), ('2023-09-21 15:18:41.597+00', 11878.4), ('2023-09-21 15:19:41.933+00', 11878.8), ('2023-09-21 15:20:40.748+00', 11879.3), ('2023-09-21 15:21:40.84+00', 11879.7), ('2023-09-21 15:22:41.175+00', 11880.2), ('2023-09-21 15:23:41.204+00', 11880.6), ('2023-09-21 15:24:41.363+00', 11881.1), ('2023-09-21 15:25:41.679+00', 11881.5), ('2023-09-21 15:26:35.239+00', 11882), ('2023-09-21 15:27:41.761+00', 11882.4), ('2023-09-21 15:28:34.231+00', 11882.9), ('2023-09-21 15:29:34.765+00', 11883.3), ('2023-09-21 15:30:35.519+00', 11883.8), ('2023-09-21 15:31:33.727+00', 11884.2), ('2023-09-21 15:32:34.382+00', 11884.7), ('2023-09-21 15:33:34.907+00', 11885.1), ('2023-09-21 15:34:33.395+00', 11885.5), ('2023-09-21 15:35:33.933+00', 11886), ('2023-09-21 15:36:32.429+00', 11886.4), ('2023-09-21 15:37:33.164+00', 11886.9), ('2023-09-21 15:38:33.509+00', 11887.3), ('2023-09-21 15:39:36.092+00', 11887.8), ('2023-09-21 15:40:36.234+00', 11888.2), ('2023-09-21 15:41:36.341+00', 11888.7), ('2023-09-21 15:42:36.51+00', 11889.1), ('2023-09-21 15:43:36.884+00', 11889.5), ('2023-09-21 15:44:36.744+00', 11890), ('2023-09-21 15:45:35.923+00', 11890.4), ('2023-09-21 15:46:35.842+00', 11890.9), ('2023-09-21 15:47:36.243+00', 11891.3), ('2023-09-21 15:48:36.188+00', 11891.8), ('2023-09-21 15:49:36.405+00', 11892.2), ('2023-09-21 15:50:36.517+00', 11892.7), ('2023-09-21 15:51:30.52+00', 11893.1), ('2023-09-21 15:52:30.82+00', 11893.5), ('2023-09-21 15:53:31.578+00', 11894), ('2023-09-21 15:54:29.937+00', 11894.4), ('2023-09-21 15:55:30.613+00', 11894.9), ('2023-09-21 15:56:30.967+00', 11895.3), ('2023-09-21 15:57:29.658+00', 11895.8), ('2023-09-21 15:58:30.028+00', 11896.2), ('2023-09-21 15:59:28.505+00', 11896.6), ('2023-09-21 16:00:29.05+00', 11897.1), ('2023-09-21 16:01:29.795+00', 11897.5), ('2023-09-21 16:02:28.036+00', 11898), ('2023-09-21 16:03:28.822+00', 11898.4), ('2023-09-21 16:04:29.125+00', 11898.9), ('2023-09-21 16:05:27.837+00', 11899.3), ('2023-09-21 16:06:28.168+00', 11899.7), ('2023-09-21 16:07:28.893+00', 11900.2), ('2023-09-21 16:08:27.245+00', 11900.6), ('2023-09-21 16:09:27.794+00', 11901.1), ('2023-09-21 16:10:28.277+00', 11901.5), ('2023-09-21 16:11:26.959+00', 11901.9), ('2023-09-21 16:12:27.303+00', 11902.4), ('2023-09-21 16:13:26.305+00', 11902.8), ('2023-09-21 16:14:26.366+00', 11903.3), ('2023-09-21 16:15:27.073+00', 11903.7), ('2023-09-21 16:16:27.427+00', 11904.1), ('2023-09-21 16:17:26.989+00', 11904.6), ('2023-09-21 16:18:26.88+00', 11905), ('2023-09-21 16:19:27.017+00', 11905.5), ('2023-09-21 16:20:25.967+00', 11905.9), ('2023-09-21 16:21:26.123+00', 11906.3), ('2023-09-21 16:22:26.513+00', 11906.8), ('2023-09-21 16:23:26.439+00', 11907.2), ('2023-09-21 16:24:26.644+00', 11907.7), ('2023-09-21 16:25:26.936+00', 11908.1), ('2023-09-21 16:26:26.902+00', 11908.5), ('2023-09-21 16:27:26.927+00', 11909), ('2023-09-21 16:28:26.127+00', 11909.4), ('2023-09-21 16:29:26.163+00', 11909.9), ('2023-09-21 16:30:26.258+00', 11910.3), ('2023-09-21 16:31:26.631+00', 11910.7), ('2023-09-21 16:32:26.61+00', 11911.2), ('2023-09-21 16:33:26.751+00', 11911.6), ('2023-09-21 16:34:27.13+00', 11912.1), ('2023-09-21 16:35:26.984+00', 11912.5), ('2023-09-21 16:36:26.009+00', 11912.9), ('2023-09-21 16:37:26.324+00', 11913.4), ('2023-09-21 16:38:26.316+00', 11913.8), ('2023-09-21 16:39:26.675+00', 11914.2), ('2023-09-21 16:40:26.586+00', 11914.7), ('2023-09-21 16:41:26.758+00', 11915.1), ('2023-09-21 16:42:27.065+00', 11915.6), ('2023-09-21 16:43:26.978+00', 11916), ('2023-09-21 16:44:25.965+00', 11916.4), ('2023-09-21 16:45:20.803+00', 11916.9), ('2023-09-21 16:46:21.124+00', 11917.3), ('2023-09-21 16:47:19.645+00', 11917.8), ('2023-09-21 16:48:20.354+00', 11918.2), ('2023-09-21 16:49:20.767+00', 11918.6), ('2023-09-21 16:50:21.993+00', 11919.1), ('2023-09-21 16:51:22.061+00', 11919.5), ('2023-09-21 16:52:22.221+00', 11920), ('2023-09-21 16:53:21.035+00', 11920.4), ('2023-09-21 16:54:21.347+00', 11920.9), ('2023-09-21 16:55:21.292+00', 11921.3), ('2023-09-21 16:56:21.666+00', 11921.7), ('2023-09-21 16:57:21.613+00', 11922.2), ('2023-09-21 16:58:22.02+00', 11922.6), ('2023-09-21 16:59:17.96+00', 11923.1), ('2023-09-21 17:00:18.735+00', 11923.5), ('2023-09-21 17:01:18.984+00', 11923.9), ('2023-09-21 17:02:17.459+00', 11924.4), ('2023-09-21 17:03:18.003+00', 11924.8), ('2023-09-21 17:04:18.805+00', 11925.3), ('2023-09-21 17:05:17.113+00', 11925.7), ('2023-09-21 17:06:17.785+00', 11926.1), ('2023-09-21 17:07:16.099+00', 11926.6), ('2023-09-21 17:08:16.856+00', 11927), ('2023-09-21 17:09:17.072+00', 11927.5), ('2023-09-21 17:10:17.863+00', 11927.9), ('2023-09-21 17:11:16.189+00', 11928.3), ('2023-09-21 17:12:16.947+00', 11928.8), ('2023-09-21 17:13:15.265+00', 11929.2), ('2023-09-21 17:14:15.981+00', 11929.7), ('2023-09-21 17:15:16.335+00', 11930.1), ('2023-09-21 17:16:15.037+00', 11930.5), ('2023-09-21 17:17:15.352+00', 11931), ('2023-09-21 17:18:16.168+00', 11931.4), ('2023-09-21 17:19:16.251+00', 11931.9), ('2023-09-21 17:20:16.588+00', 11932.3), ('2023-09-21 17:21:16.536+00', 11932.8), ('2023-09-21 17:22:16.865+00', 11933.2), ('2023-09-21 17:23:16.875+00', 11933.6), ('2023-09-21 17:24:17.176+00', 11934.1), ('2023-09-21 17:25:17.147+00', 11934.5), ('2023-09-21 17:26:16.241+00', 11935), ('2023-09-21 17:27:16.208+00', 11935.4), ('2023-09-21 17:28:16.574+00', 11935.8), ('2023-09-21 17:29:16.503+00', 11936.3), ('2023-09-21 17:30:16.863+00', 11936.7), ('2023-09-21 17:31:16.947+00', 11937.2), ('2023-09-21 17:32:17.174+00', 11937.6), ('2023-09-21 17:33:17.14+00', 11938), ('2023-09-21 17:34:17.457+00', 11938.5), ('2023-09-21 17:35:16.257+00', 11938.9), ('2023-09-21 17:36:16.535+00', 11939.4), ('2023-09-21 17:37:16.559+00', 11939.8), ('2023-09-21 17:38:16.888+00', 11940.2), ('2023-09-21 17:39:10.976+00', 11940.7), ('2023-09-21 17:40:11.642+00', 11941.1), ('2023-09-21 17:41:11.999+00', 11941.6), ('2023-09-21 17:42:10.67+00', 11942), ('2023-09-21 17:43:11.007+00', 11942.4), ('2023-09-21 17:44:09.736+00', 11942.9), ('2023-09-21 17:45:10.109+00', 11943.3), ('2023-09-21 17:46:10.56+00', 11943.8), ('2023-09-21 17:47:09.306+00', 11944.2), ('2023-09-21 17:48:09.585+00', 11944.6), ('2023-09-21 17:49:10.437+00', 11945.1), ('2023-09-21 17:50:08.653+00', 11945.5), ('2023-09-21 17:51:09.193+00', 11946), ('2023-09-21 17:52:10.222+00', 11946.4), ('2023-09-21 17:53:08.226+00', 11946.8), ('2023-09-21 17:54:09.018+00', 11947.3), ('2023-09-21 17:55:09.311+00', 11947.7), ('2023-09-21 17:56:07.987+00', 11948.2), ('2023-09-21 17:57:08.348+00', 11948.6), ('2023-09-21 17:58:07.236+00', 11949), ('2023-09-21 17:59:07.364+00', 11949.5), ('2023-09-21 18:00:08.088+00', 11949.9), ('2023-09-21 18:01:08.454+00', 11950.4), ('2023-09-21 18:02:07.135+00', 11950.8), ('2023-09-21 18:03:07.473+00', 11951.3), ('2023-09-21 18:04:08.255+00', 11951.7), ('2023-09-21 18:05:06.918+00', 11952.1), ('2023-09-21 18:06:07.268+00', 11952.6), ('2023-09-21 18:07:07.286+00', 11953), ('2023-09-21 18:08:07.574+00', 11953.5), ('2023-09-21 18:09:06.639+00', 11953.9), ('2023-09-21 18:10:06.595+00', 11954.3), ('2023-09-21 18:11:06.632+00', 11954.8), ('2023-09-21 18:12:06.986+00', 11955.2), ('2023-09-21 18:13:06.962+00', 11955.7), ('2023-09-21 18:14:07.264+00', 11956.1), ('2023-09-21 18:15:07.205+00', 11956.6), ('2023-09-21 18:16:07.619+00', 11957), ('2023-09-21 18:17:06.313+00', 11957.4), ('2023-09-21 18:18:06.624+00', 11957.9), ('2023-09-21 18:19:06.559+00', 11958.3), ('2023-09-21 18:20:07.012+00', 11958.8), ('2023-09-21 18:21:06.909+00', 11959.2), ('2023-09-21 18:22:07.287+00', 11959.6), ('2023-09-21 18:23:07.248+00', 11960.1) ; -- calculating average works when data is not compressed SELECT avg(value) FROM corrupt_float8; -- compress the chunk SELECT compress_chunk(x) FROM show_chunks('corrupt_float8') x; -- should work as well when the data is compressed SELECT avg(value) FROM corrupt_float8; SELECT extract(day from time) AS day, avg(value) FROM corrupt_float8 GROUP BY 1 ORDER BY 2; DROP TABLE corrupt_float8; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_qualpushdown_saop.sql��������������������������������������0000664�0000000�0000000�00000015772�15100345067�0024657�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Planning tests for compressed chunk table filter pushdown with scalar array -- operations. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] create or replace function mix(x anyelement) returns float8 as $$ select hashfloat8(x::float8) / pow(2, 32) $$ language sql; -- a lower() function that is stable create function stable_lower(x text) returns text as 'lower' language internal stable; -- a lower() function that is volatile create function volatile_lower(x text) returns text as 'lower' language internal volatile; set max_parallel_workers_per_gather = 0; create table saop(ts int, segmentby text, with_minmax text, with_bloom text); select create_hypertable('saop', 'ts', chunk_time_interval => 50001); alter table saop set (timescaledb.compress, timescaledb.compress_segmentby = 'segmentby', timescaledb.compress_orderby = 'with_minmax, ts'); insert into saop select ts, ts % 23 segmentby, ts % 29 with_minmax, (mix(ts % 1483) * 1483)::int::text with_bloom from generate_series(0, 100000) ts; create index on saop(with_bloom); select count(compress_chunk(x)) from show_chunks('saop') x; vacuum full analyze saop; explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = any(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_minmax = any(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_minmax < any(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_minmax < all(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[segmentby, '10']); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[segmentby, null]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[segmentby, null, with_minmax]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[stable_lower(segmentby), stable_lower('1')]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[stable_lower(segmentby), stable_lower('1'), volatile_lower('10')]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[]::text[]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[null, null]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = any(array[with_bloom, with_minmax]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = all(array[with_bloom, with_minmax]); -- If the arguments of an operator can pushed down but require recheck, combining -- them is wrong. explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (with_bloom = '1') = (with_minmax = '1'); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (with_bloom = any(array['1', '10'])) = (with_minmax = any(array['1', '10'])); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (segmentby = '1') = (segmentby = '2'); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where (segmentby = any(array['1', '2'])) = (segmentby = any(array['3', '4'])); -- Partial pushdown of AND scalar array operation. explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array[with_minmax, with_minmax]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array['1', with_minmax]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' and with_bloom = all(array['1', with_minmax]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' or with_bloom = all(array['1', with_minmax]); -- Partial pushdown with volatile functions. explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = any(array[stable_lower(segmentby), volatile_lower(segmentby)]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = stable_lower(segmentby) or with_bloom = volatile_lower(segmentby); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where with_bloom = all(array[stable_lower(segmentby), volatile_lower(segmentby)]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' or with_bloom = all(array[stable_lower('1'), volatile_lower('1')]); explain (analyze, buffers off, costs off, timing off, summary off) select * from saop where segmentby = '1' or (with_bloom = stable_lower('1') and with_bloom = volatile_lower('1')); -- Some joins. explain (analyze, buffers off, costs off, timing off, summary off) with arrays as (select array[segmentby] a from saop group by segmentby order by segmentby limit 10) select * from saop, arrays where segmentby = any(a); explain (analyze, buffers off, costs off, timing off, summary off) with arrays as (select array[segmentby] a from saop group by segmentby order by segmentby limit 10) select * from saop, arrays where with_minmax = any(a); explain (analyze, buffers off, costs off, timing off, summary off) with arrays as (select array[segmentby] a from saop group by segmentby order by segmentby limit 10) select * from saop, arrays where with_bloom = any(a); -- Array parameter of prepared statements. prepare array_param as select * from saop where with_bloom = any($1); set timescaledb.enable_chunk_append to off; -- Generic plans. set plan_cache_mode = force_generic_plan; explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array[]::text[]); -- Custom plans. set plan_cache_mode = force_custom_plan; explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array['1', '10']); explain (analyze, buffers off, costs off, timing off, summary off) execute array_param(array[]::text[]); reset timescaledb.enable_chunk_append; ������timescaledb-2.23.0/tsl/test/sql/compress_sort_transform.sql�����������������������������������������0000664�0000000�0000000�00000005630�15100345067�0024155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this test checks the validity of the produced plans for partially compressed chunks -- when injecting query_pathkeys on top of the append -- path that combines the uncompressed and compressed parts of a chunk. set work_mem to '64MB'; set enable_hashagg to off; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE ht_metrics_partially_compressed(time timestamptz, device int, value float); SELECT create_hypertable('ht_metrics_partially_compressed','time'); ALTER TABLE ht_metrics_partially_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); INSERT INTO ht_metrics_partially_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02'::timestamptz,'2020-01-18'::timestamptz,'20 minute') time, generate_series(1,3) device; SELECT compress_chunk(c) FROM show_chunks('ht_metrics_partially_compressed') c; -- make them partially compressed INSERT INTO ht_metrics_partially_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02'::timestamptz,'2020-01-18'::timestamptz,'30 minute') time, generate_series(1,3) device; VACUUM ANALYZE ht_metrics_partially_compressed; -- sort transform -- Grouping can use compressed data order. :PREFIX select device, time_bucket('1 minute', time), count(*) from ht_metrics_partially_compressed group by 1, 2 order by 1, 2 limit 1; -- Batch sorted merge. :PREFIX select time_bucket('1 minute', time), count(*) from ht_metrics_partially_compressed group by 1 order by 1 limit 1; -- Batch sorted merge with different order in SELECT list. :PREFIX select count(*), time_bucket('1 minute', time) from ht_metrics_partially_compressed group by 2 order by 2 limit 1; -- Batch sorted merge with grouping column not in SELECT list. :PREFIX select count(*) from ht_metrics_partially_compressed group by time_bucket('1 minute', time) limit 1; -- Ordering by time_bucket. :PREFIX select time_bucket('1 minute', time), * from ht_metrics_partially_compressed order by 1 limit 1; -- Ordering by time_bucket, but it's not in the SELECT list. :PREFIX select * from ht_metrics_partially_compressed order by time_bucket('1 minute', time) limit 1; -- Ordering in compressed data order. :PREFIX select * from ht_metrics_partially_compressed order by device, time_bucket('1 minute', time) limit 1; -- Test incorrect transformation into a Pathkey on different relation through -- a join EquivalenceClass. set max_parallel_workers_per_gather = 0; :PREFIX select time_bucket('1 minute', a.time) from ht_metrics_partially_compressed a join ht_metrics_partially_compressed b on a.time = b.time where b.time < '2020-01-07' group by 1 ; reset max_parallel_workers_per_gather; reset work_mem; reset enable_hashagg; ��������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compress_sparse_config.sql������������������������������������������0000664�0000000�0000000�00000030172�15100345067�0023714�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; -- Test configurable sparse indexes settings create table test_settings(x int, value text, u uuid, ts timestamp); select create_hypertable('test_settings', 'x'); -- defaults alter table test_settings set (timescaledb.compress); select * from settings; -- no custom sparse indexes alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x'); select * from settings; -- one sparse index alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u")'); select * from settings; alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'minmax("ts")'); select * from settings; --multi column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), bloom("ts")'); select * from settings; alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(u), bloom(ts)'); select * from settings; --test errors \set ON_ERROR_STOP 0 -- invalid syntax alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), bloom(count(u))'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = '"u", minmax("u")'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'foo("u")'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(public.u)'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'select count(*)'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom (ts); select count(*)'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = ';'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = ' '); -- same column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), minmax("u")'); -- multiple columns alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u,ts")'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(u,ts)'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom(u,abc)'); -- duplicate column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), bloom("u")'); -- invalid column alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"), minmax("foo")'); -- no orderby alter table test_settings reset (timescaledb.compress_orderby); alter table test_settings set (timescaledb.compress, timescaledb.compress_index = 'bloom("u"), minmax("x")'); -- guc disabled set timescaledb.enable_sparse_index_bloom to false; alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u")'); reset timescaledb.enable_sparse_index_bloom; \set ON_ERROR_STOP 1 -- empty sparse index alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'ts', timescaledb.compress_index = ''); select * from settings; -- change orderby setting (sparse index changes) alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'u'); select * from settings; -- same column as orderby should succeed since minmax alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'ts', timescaledb.compress_index = 'bloom("value"), minmax("ts")'); select * from settings; -- change orderby setting (sparse index doesn't change) alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'u'); select * from settings; alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'minmax("x")'); alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'u'); select * from settings; -- same column as orderby should fail since bloom \set ON_ERROR_STOP 0 alter table test_settings set (timescaledb.compress, timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("x"), minmax("ts")'); \set ON_ERROR_STOP 1 drop table test_settings; -- Test configurable sparse indexes functionality create table test_sparse_index(x int, value text, u uuid, ts timestamp, data jsonb); select create_hypertable('test_sparse_index', 'x'); create index gin_jsonb_idx on test_sparse_index using gin (data); insert into test_sparse_index select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x, jsonb_build_object('id', x, 'tag', case when x % 2 = 0 then 'even' else 'odd' end, 'active', x % 10 = 0) from generate_series(1, 10000) x; alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(x)) from show_chunks('test_sparse_index') x; alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'bloom("u"),minmax("ts")'); select * from settings; select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where ts between '2021-01-07' and '2021-01-14'; drop table test_sparse_index; -- Test configurable sparse index in CREATE TABLE .. WITH create table test_sparse_index(x int, value text, u uuid, ts timestamp) with ( tsdb.hypertable, tsdb.partition_column='x', tsdb.order_by='x', tsdb.index='bloom("u"),minmax("ts")'); select * from settings; insert into test_sparse_index select x, md5(x::text), case when x = 7134 then '90ec9e8e-4501-4232-9d03-6d7cf6132815' else '6c1d0998-05f3-452c-abd3-45afe72bbcab'::uuid end, '2021-01-01'::timestamp + (interval '1 hour') * x from generate_series(1, 10000) x; select count(compress_chunk(x)) from show_chunks('test_sparse_index') x; vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk -- these tests show that despite column having multiple sparse indexes, the appropriate one is selected by the planner -- UUID uses bloom explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where u = '90ec9e8e-4501-4232-9d03-6d7cf6132815'; -- Timestamp uses minmax explain (analyze, verbose, buffers off, costs off, timing off, summary off) select count(*) from test_sparse_index where ts between '2021-01-07' and '2021-01-14'; -- Test recompression when the bloom filter index is disabled by a GUC set timescaledb.enable_sparse_index_bloom to off; select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; reset timescaledb.enable_sparse_index_bloom; -- Test rename column -- change a non-sparse index column alter table test_sparse_index rename value to value_new; -- change sparse index column alter table test_sparse_index rename ts to ts_new; select * from settings; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk -- Test same minmax and orderby column alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x', timescaledb.compress_index = 'minmax("x")'); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk select * from settings; -- Test auto sparse index create index ii on test_sparse_index(value_new); alter table test_sparse_index reset (timescaledb.compress_index); alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x'); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk select * from settings; -- Test empty sparse index alter table test_sparse_index set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'x', timescaledb.compress_index = ''); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk select * from settings; -- Test default orderby without sparse index set timescaledb.enable_sparse_index_bloom to false; alter table test_sparse_index reset (timescaledb.compress_segmentby, timescaledb.compress_orderby, timescaledb.compress_index); select count(compress_chunk(decompress_chunk(x))) from show_chunks('test_sparse_index') x; vacuum full analyze test_sparse_index; select schema_name || '.' || table_name chunk from _timescaledb_catalog.chunk where id = (select compressed_chunk_id from _timescaledb_catalog.chunk where hypertable_id = (select id from _timescaledb_catalog.hypertable where table_name = 'test_sparse_index') limit 1) \gset \d+ :chunk select * from settings; reset timescaledb.enable_sparse_index_bloom; drop table test_sparse_index; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compressed_collation.sql��������������������������������������������0000664�0000000�0000000�00000003623�15100345067�0023370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- We have different collation names such as en_US, en-US-x-icu and so on, -- that are available on different platforms. with encodings as ( select -1 union all select encoding from pg_database where datname = current_database() ) , pattern(pattern, priority) as ( values ('en_us%', 2), ('en_us_utf%8%', 1) ) , collations as ( select priority, collname from pg_collation join pattern on collname ilike pattern where collencoding in (select * from encodings) order by priority, collencoding, collname ) select * from ( select 3 priority, 'C' "COLLATION" union all select * from collations ) c order by priority limit 1 \gset create table compressed_collation_ht(time timestamp, name text collate :"COLLATION", value float); select create_hypertable('compressed_collation_ht', 'time'); alter table compressed_collation_ht set (timescaledb.compress, timescaledb.compress_segmentby = 'name', timescaledb.compress_orderby = 'time'); insert into compressed_collation_ht values ('2021-01-01 01:01:01', 'á', '1'), ('2021-01-01 01:01:02', 'b', '2'), ('2021-01-01 01:01:03', 'ç', '2'); SELECT count(compress_chunk(ch)) FROM show_chunks('compressed_collation_ht') ch; vacuum analyze compressed_collation_ht; SELECT format('%I.%I',ch.schema_name, ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.compressed_hypertable_id AND ht.table_name = 'compressed_collation_ht' \gset create index on :CHUNK (name); set enable_seqscan to off; explain (buffers off, costs off) select * from compressed_collation_ht order by name; select * from compressed_collation_ht order by name; �������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compressed_detoaster.sql��������������������������������������������0000664�0000000�0000000�00000002747�15100345067�0023404�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Make a compressed table with a compressed string of varying length, to test -- the various ways the compressed data can be toasted. create table longstr(ts int default 1, s1 text); select create_hypertable('longstr', 'ts'); alter table longstr set (timescaledb.compress); -- We want to test the case for inline compression. It is technically possible, -- but very hard to hit with the usual toast_tuple_target = 128 on compressed -- chunks. So here we increase the toast_tuple_target to simplify -- testing. set timescaledb.debug_toast_tuple_target = 512; -- Now, test compression and decompression with various string lengths. create function test(repeats int, decompress bool) returns table(ns bigint) as $$ begin raise log 'repeats %', repeats; truncate longstr; insert into longstr(s1) select repeat('aaaa', repeats); perform count(compress_chunk(x, true)) from show_chunks('longstr') x; if decompress then perform decompress_chunk(x) from show_chunks('longstr') x; end if; return query select sum(length(s1)) from longstr; end; $$ language plpgsql volatile; select sum(t) from generate_series(1, 30) x, lateral test(x * x * x, false) t; -- Also test decompression which uses the detoaster as well. select sum(t) from generate_series(1, 30) x, lateral test(x * x * x, true) t; �������������������������timescaledb-2.23.0/tsl/test/sql/compression.sql�����������������������������������������������������0000664�0000000�0000000�00000151250�15100345067�0021521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timescaledb.enable_transparent_decompression to OFF; SET timezone TO 'America/Los_Angeles'; \set PREFIX 'EXPLAIN (analyze, verbose, buffers off, costs off, timing off, summary off)' \ir include/rand_generator.sql --test_collation --- --basic test with count create table foo (a integer, b integer, c integer, d integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); create unique index foo_uniq ON foo (a, b); --note that the "d" order by column is all NULL insert into foo values( 3 , 16 , 20, NULL); insert into foo values( 10 , 10 , 20, NULL); insert into foo values( 20 , 11 , 20, NULL); insert into foo values( 30 , 12 , 20, NULL); analyze foo; -- check that approximate_row_count works with a regular table SELECT approximate_row_count('foo'); SELECT count(*) from foo; alter table foo set (timescaledb.compress, timescaledb.compress_segmentby = 'a,b', timescaledb.compress_orderby = 'c desc, d asc nulls last'); --test self-refencing updates SET timescaledb.enable_transparent_decompression to ON; update foo set c = 40 where a = (SELECT max(a) FROM foo); SET timescaledb.enable_transparent_decompression to OFF; SELECT id, schema_name, table_name, compression_state as compressed, compressed_hypertable_id FROM _timescaledb_catalog.hypertable ORDER BY id; SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY relid::regclass; SELECT * FROM timescaledb_information.compression_settings ORDER BY hypertable_name; -- TEST2 compress-chunk for the chunks created earlier -- select compress_chunk( '_timescaledb_internal._hyper_1_2_chunk'); select tgname , tgtype, tgenabled , relname from pg_trigger t, pg_class rel where t.tgrelid = rel.oid and rel.relname like '_hyper_1_2_chunk' order by tgname; \x select * from chunk_compression_stats('foo') order by chunk_name limit 2; \x select compress_chunk( '_timescaledb_internal._hyper_1_1_chunk'); \x select * from _timescaledb_catalog.compression_chunk_size order by chunk_id; \x select ch1.id, ch1.schema_name, ch1.table_name , ch2.table_name as compress_table from _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2 where ch1.compressed_chunk_id = ch2.id; \set ON_ERROR_STOP 0 --cannot compress the chunk the second time around select compress_chunk( '_timescaledb_internal._hyper_1_2_chunk', false); --TEST2a try DML on a compressed chunk BEGIN; insert into foo values( 11 , 10 , 20, 120); ROLLBACK; update foo set b =20 where a = 10; delete from foo where a = 10; --TEST2b try complex DML on compressed chunk create table foo_join ( a integer, newval integer); select table_name from create_hypertable('foo_join', 'a', chunk_time_interval=> 10); insert into foo_join select generate_series(0,40, 10), 111; create table foo_join2 ( a integer, newval integer); select table_name from create_hypertable('foo_join2', 'a', chunk_time_interval=> 10); insert into foo_join select generate_series(0,40, 10), 222; update foo set b = newval from foo_join where foo.a = foo_join.a; update foo set b = newval from foo_join where foo.a = foo_join.a and foo_join.a > 10; --here the chunk gets excluded , so succeeds -- update foo set b = newval from foo_join where foo.a = foo_join.a and foo.a > 20; update foo set b = (select f1.newval from foo_join f1 left join lateral (select newval as newval2 from foo_join2 f2 where f1.a= f2.a ) subq on true limit 1); --upsert test -- insert into foo values(10, 12, 12, 12) on conflict( a, b) do update set b = excluded.b; SELECT * from foo ORDER BY a,b; --TEST2c Do DML directly on the chunk. insert into _timescaledb_internal._hyper_1_2_chunk values(10, 12, 12, 12) on conflict( a, b) do update set b = excluded.b + 12; SELECT * from foo ORDER BY a,b; update _timescaledb_internal._hyper_1_2_chunk set b = 12; delete from _timescaledb_internal._hyper_1_2_chunk; --TEST2d decompress the chunk and try DML select decompress_chunk( '_timescaledb_internal._hyper_1_2_chunk'); insert into foo values( 11 , 10 , 20, 120); update foo set b =20 where a = 10; select * from _timescaledb_internal._hyper_1_2_chunk order by a,b; delete from foo where a = 10; select * from _timescaledb_internal._hyper_1_2_chunk order by a,b; -- TEST3 check if compress data from views is accurate CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select create_hypertable( 'conditions', 'time', chunk_time_interval=> '31days'::interval); alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'time'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 'klick', 55, 75; SELECT id, schema_name, table_name, compression_state as compressed, compressed_hypertable_id FROM _timescaledb_catalog.hypertable WHERE table_name = 'conditions'; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'conditions'::regclass; select attname, attstorage, typname from pg_attribute at, pg_class cl , pg_type ty where cl.oid = at.attrelid and at.attnum > 0 and cl.relname = '_compressed_hypertable_4' and atttypid = ty.oid order by at.attnum; SELECT ch1.schema_name|| '.' || ch1.table_name as "CHUNK_NAME", ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'conditions' ORDER BY ch1.id LIMIT 1 \gset SELECT count(*) from :CHUNK_NAME; SELECT count(*) as "ORIGINAL_CHUNK_COUNT" from :CHUNK_NAME \gset select tableoid::regclass, count(*) from conditions group by tableoid order by tableoid; SELECT compress_chunk(ch) FROM show_chunks('conditions') ch LIMIT 1; --test that only one chunk was affected --note tables with 0 rows will not show up in here. select tableoid::regclass, count(*) from conditions group by tableoid order by tableoid; SELECT compress_chunk(ch, true) FROM show_chunks('conditions') ch ORDER BY ch::text DESC LIMIT 1; select tableoid::regclass, count(*) from conditions group by tableoid order by tableoid; select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset SELECT count(*) from :CHUNK_NAME; SELECT count(*) from :COMPRESSED_CHUNK_NAME; SELECT sum(_ts_meta_count) from :COMPRESSED_CHUNK_NAME; SELECT location, _ts_meta_min_1, _ts_meta_max_1 from :COMPRESSED_CHUNK_NAME ORDER BY 1,2; \x SELECT chunk_id, numrows_pre_compression, numrows_post_compression FROM _timescaledb_catalog.chunk srcch, _timescaledb_catalog.compression_chunk_size map, _timescaledb_catalog.hypertable srcht WHERE map.chunk_id = srcch.id and srcht.id = srcch.hypertable_id and srcht.table_name like 'conditions' order by chunk_id; select * from chunk_compression_stats('conditions') order by chunk_name; select * from hypertable_compression_stats('foo'); select * from hypertable_compression_stats('conditions'); vacuum full foo; vacuum full conditions; -- After vacuum, table_bytes is 0, but any associated index/toast storage is not -- completely reclaimed. Sets it at 8K (page size). So a chunk which has -- been compressed still incurs an overhead of n * 8KB (for every index + toast table) storage on the original uncompressed chunk. select pg_size_pretty(table_bytes), pg_size_pretty(index_bytes), pg_size_pretty(toast_bytes), pg_size_pretty(total_bytes) from hypertable_detailed_size('conditions'); select * from timescaledb_information.hypertables where hypertable_name like 'foo' or hypertable_name like 'conditions' order by hypertable_name; \x SELECT count(decompress_chunk(ch)) FROM show_chunks('conditions') ch; SELECT count(*), count(*) = :'ORIGINAL_CHUNK_COUNT' from :CHUNK_NAME; --check that the compressed chunk is dropped \set ON_ERROR_STOP 0 SELECT count(*) from :COMPRESSED_CHUNK_NAME; \set ON_ERROR_STOP 1 --size information is gone too select count(*) FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht, _timescaledb_catalog.compression_chunk_size map where ch1.hypertable_id = ht.id and ht.table_name like 'conditions' and map.chunk_id = ch1.id; --make sure compressed_chunk_id is reset to NULL select ch1.compressed_chunk_id IS NULL FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'conditions'; -- test plans get invalidated when chunks get compressed SET timescaledb.enable_transparent_decompression TO ON; CREATE TABLE plan_inval(time timestamptz, device_id int); SELECT create_hypertable('plan_inval','time'); ALTER TABLE plan_inval SET (timescaledb.compress,timescaledb.compress_orderby='time desc'); -- create 2 chunks INSERT INTO plan_inval SELECT * FROM (VALUES ('2000-01-01'::timestamptz,1), ('2000-01-07'::timestamptz,1)) v(time,device_id); SET max_parallel_workers_per_gather to 0; -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; PREPARE prep_plan AS SELECT count(*) FROM plan_inval; EXECUTE prep_plan; EXECUTE prep_plan; EXECUTE prep_plan; -- get name of first chunk SELECT tableoid::regclass AS "CHUNK_NAME" FROM plan_inval ORDER BY time LIMIT 1 \gset SELECT compress_chunk(:'CHUNK_NAME'); VACUUM ANALYZE plan_inval; EXECUTE prep_plan; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE prep_plan; SET enable_hashagg = ON; CREATE TABLE test_collation ( time TIMESTAMPTZ NOT NULL, device_id TEXT COLLATE "C" NULL, device_id_2 TEXT COLLATE "POSIX" NULL, val_1 TEXT COLLATE "C" NULL, val_2 TEXT COLLATE "POSIX" NULL ); --we want all the data to go into 1 chunk. so use 1 year chunk interval select create_hypertable( 'test_collation', 'time', chunk_time_interval=> '1 day'::interval); \set ON_ERROR_STOP 0 --forbid setting collation in compression ORDER BY clause. (parse error is fine) alter table test_collation set (timescaledb.compress, timescaledb.compress_segmentby='device_id, device_id_2', timescaledb.compress_orderby = 'val_1 COLLATE "POSIX", val2, time'); \set ON_ERROR_STOP 1 alter table test_collation set (timescaledb.compress, timescaledb.compress_segmentby='device_id, device_id_2', timescaledb.compress_orderby = 'val_1, val_2, time'); insert into test_collation select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_1', 'device_3', gen_rand_minstd(), gen_rand_minstd(); insert into test_collation select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_2', 'device_4', gen_rand_minstd(), gen_rand_minstd(); insert into test_collation select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), NULL, 'device_5', gen_rand_minstd(), gen_rand_minstd(); --compress 2 chunks SELECT compress_chunk(ch) FROM show_chunks('test_collation') ch LIMIT 2; VACUUM ANALYZE test_collation; --segment bys are pushed down correctly EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE device_id < 'a'; EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE device_id < 'a' COLLATE "POSIX"; \set ON_ERROR_STOP 0 EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE device_id COLLATE "POSIX" < device_id_2 COLLATE "C"; SELECT device_id < device_id_2 FROM test_collation; \set ON_ERROR_STOP 1 --segment meta on order bys pushdown --should work EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_1 < 'a'; EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_2 < 'a'; EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_1 < 'a' COLLATE "C"; EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_2 < 'a' COLLATE "POSIX"; --cannot pushdown when op collation does not match column's collation since min/max used different collation than what op needs EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_1 < 'a' COLLATE "POSIX"; EXPLAIN (buffers off, costs off) SELECT * FROM test_collation WHERE val_2 < 'a' COLLATE "C"; --test datatypes CREATE TABLE datatype_test( time timestamptz NOT NULL, int2_column int2, int4_column int4, int8_column int8, float4_column float4, float8_column float8, date_column date, timestamp_column timestamp, timestamptz_column timestamptz, interval_column interval, numeric_column numeric, decimal_column decimal, text_column text, char_column char ); SELECT create_hypertable('datatype_test','time'); ALTER TABLE datatype_test SET (timescaledb.compress, timescaledb.compress_orderby='"time" desc'); INSERT INTO datatype_test VALUES ('2000-01-01',2,4,8,4.0,8.0,'2000-01-01','2001-01-01 12:00','2001-01-01 6:00','1 week', 3.41, 4.2, 'text', 'x'); SELECT count(compress_chunk(ch)) FROM show_chunks('datatype_test') ch; select id, schema_name, table_name, compression_state as compressed, compressed_hypertable_id from _timescaledb_catalog.hypertable where table_name = 'datatype_test'; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='datatype_test'::regclass; --TEST try to compress a hypertable that has a continuous aggregate CREATE TABLE metrics(time timestamptz, device_id int, v1 float, v2 float); SELECT create_hypertable('metrics','time'); INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; -- check expressions in view definition CREATE MATERIALIZED VIEW cagg_expr WITH (timescaledb.continuous) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(metrics,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2, count(*) AS cnt FROM metrics GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('cagg_expr', NULL, NULL); SELECT * FROM cagg_expr ORDER BY time LIMIT 5; ALTER TABLE metrics set(timescaledb.compress, timescaledb.compress_orderby='"time" desc'); -- test rescan in compress chunk dml blocker CREATE TABLE rescan_test(id integer NOT NULL, t timestamptz NOT NULL, val double precision, PRIMARY KEY(id, t)); SELECT create_hypertable('rescan_test', 't', chunk_time_interval => interval '1 day'); -- compression ALTER TABLE rescan_test SET (timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby='t desc'); -- INSERT dummy data INSERT INTO rescan_test SELECT 1, time, random() FROM generate_series('2000-01-01'::timestamptz, '2000-01-05'::timestamptz, '1h'::interval) g(time); SELECT count(*) FROM rescan_test; -- compress first chunk SELECT compress_chunk(ch) FROM show_chunks('rescan_test') ch LIMIT 1; -- count should be equal to count before compression SELECT count(*) FROM rescan_test; -- single row update is fine UPDATE rescan_test SET val = val + 1 WHERE rescan_test.id = 1 AND rescan_test.t = '2000-01-03 00:00:00+00'; -- multi row update via WHERE is fine UPDATE rescan_test SET val = val + 1 WHERE rescan_test.id = 1 AND rescan_test.t > '2000-01-03 00:00:00+00'; -- single row update with FROM is allowed if no compressed chunks are hit UPDATE rescan_test SET val = tmp.val FROM (SELECT x.id, x.t, x.val FROM unnest(array[(1, '2000-01-03 00:00:00+00', 2.045)]::rescan_test[]) AS x) AS tmp WHERE rescan_test.id = tmp.id AND rescan_test.t = tmp.t AND rescan_test.t >= '2000-01-03'; -- single row update with FROM is blocked \set ON_ERROR_STOP 0 UPDATE rescan_test SET val = tmp.val FROM (SELECT x.id, x.t, x.val FROM unnest(array[(1, '2000-01-03 00:00:00+00', 2.045)]::rescan_test[]) AS x) AS tmp WHERE rescan_test.id = tmp.id AND rescan_test.t = tmp.t; -- bulk row update with FROM is blocked UPDATE rescan_test SET val = tmp.val FROM (SELECT x.id, x.t, x.val FROM unnest(array[(1, '2000-01-03 00:00:00+00', 2.045), (1, '2000-01-03 01:00:00+00', 8.045)]::rescan_test[]) AS x) AS tmp WHERE rescan_test.id = tmp.id AND rescan_test.t = tmp.t; \set ON_ERROR_STOP 1 -- Test FK constraint drop and recreate during compression and decompression on a chunk CREATE TABLE meta (device_id INT PRIMARY KEY); CREATE TABLE hyper( time INT NOT NULL, device_id INT REFERENCES meta(device_id) ON DELETE CASCADE ON UPDATE CASCADE, val INT); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO meta VALUES (1), (2), (3), (4), (5); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2); SELECT ch1.table_name AS "CHUNK_NAME", ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' ORDER BY ch1.id LIMIT 1 \gset SELECT constraint_schema, constraint_name, table_schema, table_name, constraint_type FROM information_schema.table_constraints WHERE table_name = :'CHUNK_NAME' AND constraint_type = 'FOREIGN KEY' ORDER BY constraint_name; SELECT compress_chunk(:'CHUNK_FULL_NAME'); SELECT constraint_schema, constraint_name, table_schema, table_name, constraint_type FROM information_schema.table_constraints WHERE table_name = :'CHUNK_NAME' AND constraint_type = 'FOREIGN KEY' ORDER BY constraint_name; -- Delete data from compressed chunk directly fails \set ON_ERROR_STOP 0 DELETE FROM hyper WHERE device_id = 3; \set ON_ERROR_STOP 0 -- Delete data from FK-referenced table deletes data from compressed chunk SELECT * FROM hyper ORDER BY time, device_id; DELETE FROM meta WHERE device_id = 3; SELECT * FROM hyper ORDER BY time, device_id; SELECT decompress_chunk(:'CHUNK_FULL_NAME'); SELECT constraint_schema, constraint_name, table_schema, table_name, constraint_type FROM information_schema.table_constraints WHERE table_name = :'CHUNK_NAME' AND constraint_type = 'FOREIGN KEY' ORDER BY constraint_name; -- create hypertable with 2 chunks CREATE TABLE ht5(time TIMESTAMPTZ NOT NULL); SELECT create_hypertable('ht5','time'); INSERT INTO ht5 SELECT '2000-01-01'::TIMESTAMPTZ; INSERT INTO ht5 SELECT '2001-01-01'::TIMESTAMPTZ; -- compressed chunk stats should not show dropped chunks ALTER TABLE ht5 SET (timescaledb.compress, timescaledb.orderby = '"time" desc'); SELECT compress_chunk(i) FROM show_chunks('ht5') i; SELECT drop_chunks('ht5', newer_than => '2000-01-01'::TIMESTAMPTZ); select chunk_name from chunk_compression_stats('ht5') order by chunk_name; -- Test enabling compression for a table with compound foreign key -- (Issue https://github.com/timescale/timescaledb/issues/2000) CREATE TABLE table2(col1 INT, col2 int, primary key (col1,col2)); CREATE TABLE table1(col1 INT NOT NULL, col2 INT); ALTER TABLE table1 ADD CONSTRAINT fk_table1 FOREIGN KEY (col1,col2) REFERENCES table2(col1,col2); SELECT create_hypertable('table1','col1', chunk_time_interval => 10); -- Trying to list an incomplete set of fields of the compound key ALTER TABLE table1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'col1'); -- Listing all fields of the compound key should succeed: ALTER TABLE table1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'col1,col2'); SELECT * FROM timescaledb_information.compression_settings ORDER BY hypertable_name; -- test delete/update on non-compressed tables involving hypertables with compression CREATE TABLE uncompressed_ht ( time timestamptz NOT NULL, value double precision, series_id integer ); SELECT table_name FROM create_hypertable ('uncompressed_ht', 'time'); INSERT INTO uncompressed_ht VALUES ('2020-04-20 01:01', 100, 1), ('2020-05-20 01:01', 100, 1), ('2020-04-20 01:01', 200, 2); CREATE TABLE compressed_ht ( time timestamptz NOT NULL, value double precision, series_id integer ); SELECT table_name FROM create_hypertable ('compressed_ht', 'time'); ALTER TABLE compressed_ht SET (timescaledb.compress); INSERT INTO compressed_ht VALUES ('2020-04-20 01:01', 100, 1), ('2020-05-20 01:01', 100, 1); SELECT count(compress_chunk(ch)) FROM show_chunks('compressed_ht') ch; BEGIN; WITH compressed AS ( SELECT series_id FROM compressed_ht WHERE time >= '2020-04-17 17:14:24.161989+00' ) DELETE FROM uncompressed_ht WHERE series_id IN (SELECT series_id FROM compressed); ROLLBACK; -- test delete inside CTE WITH compressed AS ( DELETE FROM compressed_ht RETURNING series_id ) SELECT * FROM uncompressed_ht WHERE series_id IN (SELECT series_id FROM compressed); -- test update inside CTE is blocked WITH compressed AS ( UPDATE compressed_ht SET value = 0.2 RETURNING * ) SELECT * FROM uncompressed_ht WHERE series_id IN (SELECT series_id FROM compressed); DROP TABLE compressed_ht; DROP TABLE uncompressed_ht; -- Test that pg_stats and pg_class stats for uncompressed chunks are correctly updated after compression. -- Note that approximate_row_count pulls from pg_class CREATE TABLE stattest(time TIMESTAMPTZ NOT NULL, c1 int); SELECT create_hypertable('stattest', 'time'); INSERT INTO stattest SELECT '2020/02/20 01:00'::TIMESTAMPTZ + ('1 hour'::interval * v), 250 * v FROM generate_series(0,25) v; SELECT table_name INTO TEMPORARY temptable FROM _timescaledb_catalog.chunk WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'stattest'); \set statchunk '(select table_name from temptable)' SELECT schemaname, tablename, attname, inherited, null_frac, avg_width, n_distinct, most_common_vals, most_common_freqs, histogram_bounds, correlation, most_common_elems, most_common_elem_freqs, elem_count_histogram FROM pg_stats WHERE tablename = :statchunk; ALTER TABLE stattest SET (timescaledb.compress); -- check that approximate_row_count works with all normal chunks SELECT approximate_row_count('stattest'); SELECT compress_chunk(c) FROM show_chunks('stattest') c; ANALYZE stattest; -- check that approximate_row_count works with all compressed chunks SELECT approximate_row_count('stattest'); -- actual count should match with the above SELECT count(*) from stattest; -- Uncompressed chunk table is empty since we just compressed the chunk and moved everything to compressed chunk table. -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE was run SELECT relpages, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END as reltuples FROM pg_class WHERE relname = :statchunk; SELECT compch.table_name as "STAT_COMP_CHUNK_NAME" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.chunk ch , _timescaledb_catalog.chunk compch WHERE ht.table_name = 'stattest' AND ch.hypertable_id = ht.id AND compch.id = ch.compressed_chunk_id AND ch.compressed_chunk_id > 0 \gset -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE was run SELECT relpages, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END as reltuples FROM pg_class WHERE relname = :'STAT_COMP_CHUNK_NAME'; -- Unfortunately, the stats on the hypertable won't find any rows to sample from the chunk ANALYZE stattest; SELECT histogram_bounds FROM pg_stats WHERE tablename = 'stattest' AND attname = 'c1'; SELECT relpages, reltuples FROM pg_class WHERE relname = :statchunk; -- verify that corresponding compressed chunk table stats is updated as well. SELECT relpages, reltuples FROM pg_class WHERE relname = :'STAT_COMP_CHUNK_NAME'; -- verify that approximate_row_count works fine on a chunk with compressed data SELECT approximate_row_count('_timescaledb_internal.' || :'STAT_COMP_CHUNK_NAME'); -- Verify partial chunk stats are handled correctly when analyzing -- for both uncompressed and compressed chunk tables INSERT INTO stattest SELECT '2020/02/20 01:00'::TIMESTAMPTZ + ('1 hour'::interval * v), 250 * v FROM generate_series(25,50) v; ANALYZE stattest; SELECT histogram_bounds FROM pg_stats WHERE tablename = :statchunk AND attname = 'c1'; -- Hypertable will now see the histogram bounds since we have data in the uncompressed chunk table. SELECT histogram_bounds FROM pg_stats WHERE tablename = 'stattest' AND attname = 'c1'; -- verify that corresponding uncompressed chunk table stats is updated as well. SELECT relpages, reltuples FROM pg_class WHERE relname = :statchunk; -- verify that corresponding compressed chunk table stats have not changed since -- we didn't compress anything new. SELECT relpages, reltuples FROM pg_class WHERE relname = :'STAT_COMP_CHUNK_NAME'; -- verify that approximate_row_count works fine on a chunk with a mix of uncompressed -- and compressed data SELECT table_name as "STAT_CHUNK_NAME" from temptable \gset SELECT approximate_row_count('_timescaledb_internal.' || :'STAT_CHUNK_NAME'); -- should match with the result via the hypertable post in-memory decompression SELECT count(*) from stattest; SELECT count(*) from show_chunks('stattest'); -- Verify that decompressing the chunk restores autoanalyze to the hypertable's setting SELECT reloptions FROM pg_class WHERE relname = :statchunk; SELECT decompress_chunk(c) FROM show_chunks('stattest') c; SELECT reloptions FROM pg_class WHERE relname = :statchunk; SELECT compress_chunk(c) FROM show_chunks('stattest') c; SELECT reloptions FROM pg_class WHERE relname = :statchunk; ALTER TABLE stattest SET (autovacuum_enabled = false); SELECT decompress_chunk(c) FROM show_chunks('stattest') c; SELECT reloptions FROM pg_class WHERE relname = :statchunk; -- Verify that even a global analyze works as well, changing message scope here -- to hide WARNINGs for skipped tables SET client_min_messages TO ERROR; ANALYZE; SET client_min_messages TO NOTICE; SELECT histogram_bounds FROM pg_stats WHERE tablename = :statchunk and attname = 'c1'; SELECT relpages, reltuples FROM pg_class WHERE relname = :statchunk; --- Test that analyze on compression internal table updates stats on original chunks CREATE TABLE stattest2(time TIMESTAMPTZ NOT NULL, c1 int, c2 int); SELECT create_hypertable('stattest2', 'time', chunk_time_interval=>'1 day'::interval); ALTER TABLE stattest2 SET (timescaledb.compress, timescaledb.compress_segmentby='c1'); INSERT INTO stattest2 SELECT '2020/06/20 01:00'::TIMESTAMPTZ ,1 , generate_series(1, 200, 1); INSERT INTO stattest2 SELECT '2020/07/20 01:00'::TIMESTAMPTZ ,1 , generate_series(1, 200, 1); SELECT compress_chunk(ch) FROM show_chunks('stattest2') ch LIMIT 1; -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE has been run SELECT relname, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END AS reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) order by relname; \c :TEST_DBNAME :ROLE_SUPERUSER --overwrite pg_class stats for the compressed chunk. UPDATE pg_class SET reltuples = 0, relpages = 0 WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id AND ch.compressed_chunk_id > 0 ); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE has been run SELECT relname, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END AS reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) order by relname; SELECT '_timescaledb_internal.' || compht.table_name as "STAT_COMP_TABLE", compht.table_name as "STAT_COMP_TABLE_NAME" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.hypertable compht WHERE ht.table_name = 'stattest2' AND ht.compressed_hypertable_id = compht.id \gset --analyze the compressed table, will update stats for the raw table. ANALYZE :STAT_COMP_TABLE; -- reltuples is initially -1 on PG14 before VACUUM/ANALYZE has been run SELECT relname, CASE WHEN reltuples > 0 THEN reltuples ELSE 0 END AS reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) ORDER BY relname; SELECT relname, reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = :'STAT_COMP_TABLE_NAME' AND ch.hypertable_id = ht.id ) ORDER BY relname; --analyze on stattest2 should not overwrite ANALYZE stattest2; SELECT relname, reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'stattest2' AND ch.hypertable_id = ht.id ) ORDER BY relname; SELECT relname, reltuples, relpages, relallvisible FROM pg_class WHERE relname in ( SELECT ch.table_name FROM _timescaledb_catalog.chunk ch, _timescaledb_catalog.hypertable ht WHERE ht.table_name = :'STAT_COMP_TABLE_NAME' AND ch.hypertable_id = ht.id ) ORDER BY relname; -- analyze on compressed hypertable should restore stats -- Test approximate_row_count() with compressed hypertable -- CREATE TABLE approx_count(time timestamptz not null, device int, temp float); SELECT create_hypertable('approx_count', 'time'); INSERT INTO approx_count SELECT t, (abs(timestamp_hash(t::timestamp)) % 10) + 1, random()*80 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-04 1:00', '1 hour') t; SELECT count(*) FROM approx_count; ALTER TABLE approx_count SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby = 'time DESC'); SELECT approximate_row_count('approx_count'); ANALYZE approx_count; SELECT approximate_row_count('approx_count'); DROP TABLE approx_count; --TEST drop_chunks from a compressed hypertable (that has caggs defined). -- chunk metadata is still retained. verify correct status for chunk SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; SELECT drop_chunks('metrics', older_than=>'1 day'::interval); SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; SELECT "time", cnt FROM cagg_expr ORDER BY time LIMIT 5; --now reload data into the dropped chunks region, then compress -- then verify chunk status/dropped column INSERT INTO metrics SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; SELECT c.table_name as chunk_name, c.status as chunk_status, c.dropped, c.compressed_chunk_id as comp_id FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id and h.table_name = 'metrics' ORDER BY 1; SELECT count(*) FROM metrics; -- TODO: remove this test in a separate PR since it introduces -- a lot of changes which hurt readability of test output -- test sequence number is local to segment by CREATE TABLE local_seq(time timestamptz, device int); SELECT table_name FROM create_hypertable('local_seq','time'); ALTER TABLE local_seq SET(timescaledb.compress,timescaledb.compress_segmentby='device'); INSERT INTO local_seq SELECT '2000-01-01',1 FROM generate_series(1,3000); INSERT INTO local_seq SELECT '2000-01-01',2 FROM generate_series(1,3500); INSERT INTO local_seq SELECT '2000-01-01',3 FROM generate_series(1,3000); INSERT INTO local_seq SELECT '2000-01-01',4 FROM generate_series(1,3000); INSERT INTO local_seq SELECT '2000-01-01', generate_series(5,8); SELECT compress_chunk(c) FROM show_chunks('local_seq') c; -- github issue 4872 -- If subplan of ConstraintAwareAppend is TidRangeScan, then SELECT on -- hypertable fails with error "invalid child of chunk append: Node (26)" CREATE TABLE tidrangescan_test(time timestamptz, device_id int, v1 float, v2 float); SELECT create_hypertable('tidrangescan_test','time'); INSERT INTO tidrangescan_test SELECT generate_series('2000-01-01'::timestamptz,'2000-01-10','1m'),1,0.25,0.75; CREATE MATERIALIZED VIEW tidrangescan_expr WITH (timescaledb.continuous) AS SELECT time_bucket('1d', time) AS time, 'Const'::text AS Const, 4.3::numeric AS "numeric", first(tidrangescan_test,time), CASE WHEN true THEN 'foo' ELSE 'bar' END, COALESCE(NULL,'coalesce'), avg(v1) + avg(v2) AS avg1, avg(v1+v2) AS avg2, count(*) AS cnt FROM tidrangescan_test WHERE ctid < '(1,1)'::tid GROUP BY 1 WITH NO DATA; CALL refresh_continuous_aggregate('tidrangescan_expr', NULL, NULL); SET timescaledb.enable_chunk_append to off; SET enable_indexscan to off; SELECT time, const, numeric,first, avg1, avg2 FROM tidrangescan_expr ORDER BY time LIMIT 5; RESET timescaledb.enable_chunk_append; RESET enable_indexscan; -- Test the number of allocated parallel workers for decompression -- Test that a parallel plan is generated -- with different number of parallel workers CREATE TABLE f_sensor_data( time timestamptz NOT NULL, sensor_id integer NOT NULL, cpu double precision NULL, temperature double precision NULL ); SELECT FROM create_hypertable('f_sensor_data','time'); SELECT set_chunk_time_interval('f_sensor_data', INTERVAL '1 year'); -- Create one chunk manually to ensure, all data is inserted into one chunk SELECT * FROM _timescaledb_functions.create_chunk('f_sensor_data',' {"time": [181900977000000, 515024000000000]}'); INSERT INTO f_sensor_data SELECT time AS time, sensor_id, 100.0, 36.6 FROM generate_series('1980-01-01 00:00'::timestamp, '1980-02-28 12:00', INTERVAL '1 day') AS g1(time), generate_series(1, 1700, 1 ) AS g2(sensor_id) ORDER BY time; ALTER TABLE f_sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby='sensor_id' ,timescaledb.compress_orderby = 'time DESC'); SELECT compress_chunk(i) FROM show_chunks('f_sensor_data') i; VACUUM ANALYZE f_sensor_data; -- Encourage use of parallel plans SET max_parallel_workers_per_gather = 4; SET min_parallel_index_scan_size = 0; SET min_parallel_table_scan_size = 0; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SHOW max_parallel_workers; \set explain 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' -- We disable enable_parallel_append here to ensure -- that we create the same query plan in all PG 14.X versions SET enable_parallel_append = false; :explain SELECT sum(cpu) FROM f_sensor_data; CREATE INDEX ON f_sensor_data (time, sensor_id); :explain SELECT * FROM f_sensor_data WHERE sensor_id > 1000; RESET enable_parallel_append; -- Test for partially compressed chunks INSERT INTO f_sensor_data SELECT time AS time, sensor_id, 100.0, 36.6 FROM generate_series('1980-01-01 00:00'::timestamp, '1980-01-30 12:00', INTERVAL '1 day') AS g1(time), generate_series(1700, 1800, 1 ) AS g2(sensor_id) ORDER BY time; VACUUM ANALYZE f_sensor_data; :explain SELECT sum(cpu) FROM f_sensor_data; :explain SELECT * FROM f_sensor_data WHERE sensor_id > 1000; -- Test non-partial paths below append are not executed multiple times CREATE TABLE ts_device_table(time INTEGER, device INTEGER, location INTEGER, value INTEGER); CREATE UNIQUE INDEX device_time_idx on ts_device_table(time, device); SELECT create_hypertable('ts_device_table', 'time', chunk_time_interval => 1000); INSERT INTO ts_device_table SELECT generate_series(0,999,1), 1, 100, 20; ALTER TABLE ts_device_table set(timescaledb.compress, timescaledb.compress_segmentby='location', timescaledb.compress_orderby='time'); SELECT compress_chunk(i) AS chunk_name FROM show_chunks('ts_device_table') i \gset VACUUM ANALYZE ts_device_table; SELECT count(*) FROM ts_device_table; SELECT count(*) FROM :chunk_name; INSERT INTO ts_device_table VALUES (1, 1, 100, 100) ON CONFLICT DO NOTHING; SELECT count(*) FROM :chunk_name; SET parallel_setup_cost TO '0'; SET parallel_tuple_cost TO '0'; SET min_parallel_table_scan_size TO '8'; SET min_parallel_index_scan_size TO '8'; SET random_page_cost TO '0'; SELECT count(*) FROM :chunk_name; ANALYZE :chunk_name; SELECT count(*) FROM :chunk_name; -- Test that parallel plans are chosen even if partial and small chunks are involved RESET min_parallel_index_scan_size; RESET min_parallel_table_scan_size; CREATE TABLE ht_metrics_partially_compressed(time timestamptz, device int, value float); SELECT create_hypertable('ht_metrics_partially_compressed','time',create_default_indexes:=false); ALTER TABLE ht_metrics_partially_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO ht_metrics_partially_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-01'::timestamptz,'2020-01-02'::timestamptz, INTERVAL '1 m') g(time), LATERAL (SELECT generate_series(1,2) AS device) g2; SELECT compress_chunk(c) FROM show_chunks('ht_metrics_partially_compressed') c; INSERT INTO ht_metrics_partially_compressed VALUES ('2020-01-01'::timestamptz, 1, 0.1); VACUUM ANALYZE ht_metrics_partially_compressed; :explain SELECT * FROM ht_metrics_partially_compressed ORDER BY time DESC, device LIMIT 1; -- Test parameter change on rescan -- issue 6069 CREATE TABLE IF NOT EXISTS i6069 ( timestamp TIMESTAMP WITHOUT TIME ZONE NOT NULL, attr_id SMALLINT NOT NULL, number_val DOUBLE PRECISION DEFAULT NULL ); SELECT table_name FROM create_hypertable( 'i6069', 'timestamp', create_default_indexes => FALSE, if_not_exists => TRUE, chunk_time_interval => INTERVAL '1 day' ); ALTER TABLE i6069 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'attr_id' ); INSERT INTO i6069 VALUES('2023-07-01', 1, 1),('2023-07-03', 2, 1),('2023-07-05', 3, 1), ('2023-07-01', 4, 1),('2023-07-03', 5, 1),('2023-07-05', 6, 1), ('2023-07-01', 7, 1),('2023-07-03', 8, 1),('2023-07-05', 9, 1), ('2023-07-01', 10, 1),('2023-07-03', 11, 1),('2023-07-05', 12, 1), ('2023-07-01', 13, 1),('2023-07-03', 14, 1),('2023-07-05', 15, 1), ('2023-07-01', 16, 1),('2023-07-03', 17, 1),('2023-07-05', 18, 1), ('2023-07-01', 19, 1),('2023-07-03', 20, 1),('2023-07-05', 21, 1), ('2023-07-01', 22, 1),('2023-07-03', 23, 1),('2023-07-05', 24, 1), ('2023-07-01', 25, 1),('2023-07-03', 26, 1),('2023-07-05', 27, 1), ('2023-07-01', 28, 1),('2023-07-03', 29, 1),('2023-07-05', 30, 1), ('2023-07-01', 31, 1),('2023-07-03', 32, 1),('2023-07-05', 33, 1), ('2023-07-01', 34, 1),('2023-07-03', 35, 1),('2023-07-05', 36, 1), ('2023-07-01', 37, 1),('2023-07-03', 38, 1),('2023-07-05', 39, 1), ('2023-07-01', 40, 1),('2023-07-03', 41, 1),('2023-07-05', 42, 1), ('2023-07-01', 43, 1),('2023-07-03', 44, 1),('2023-07-05', 45, 1), ('2023-07-01', 46, 1),('2023-07-03', 47, 1),('2023-07-05', 48, 1), ('2023-07-01', 49, 1),('2023-07-03', 50, 1),('2023-07-05', 51, 1), ('2023-07-01', 52, 1),('2023-07-03', 53, 1),('2023-07-05', 54, 1), ('2023-07-01', 55, 1),('2023-07-03', 56, 1),('2023-07-05', 57, 1), ('2023-07-01', 58, 1),('2023-07-03', 59, 1),('2023-07-05', 60, 1), ('2023-07-01', 61, 1),('2023-07-03', 62, 1),('2023-07-05', 63, 1), ('2023-07-01', 64, 1),('2023-07-03', 65, 1),('2023-07-05', 66, 1), ('2023-07-01', 67, 1),('2023-07-03', 68, 1),('2023-07-05', 69, 1), ('2023-07-01', 70, 1),('2023-07-03', 71, 1),('2023-07-05', 72, 1), ('2023-07-01', 73, 1),('2023-07-03', 74, 1),('2023-07-05', 75, 1), ('2023-07-01', 76, 1),('2023-07-03', 77, 1),('2023-07-05', 78, 1), ('2023-07-01', 79, 1),('2023-07-03', 80, 1),('2023-07-05', 81, 1), ('2023-07-01', 82, 1),('2023-07-03', 83, 1),('2023-07-05', 84, 1), ('2023-07-01', 85, 1),('2023-07-03', 86, 1),('2023-07-05', 87, 1), ('2023-07-01', 88, 1),('2023-07-03', 89, 1),('2023-07-05', 90, 1), ('2023-07-01', 91, 1),('2023-07-03', 92, 1),('2023-07-05', 93, 1), ('2023-07-01', 94, 1),('2023-07-03', 95, 1),('2023-07-05', 96, 1), ('2023-07-01', 97, 1),('2023-07-03', 98, 1),('2023-07-05', 99, 1), ('2023-07-01', 100, 1),('2023-07-03', 101, 1),('2023-07-05', 102, 1), ('2023-07-01', 103, 1),('2023-07-03', 104, 1),('2023-07-05', 105, 1), ('2023-07-01', 106, 1),('2023-07-03', 107, 1),('2023-07-05', 108, 1), ('2023-07-01', 109, 1),('2023-07-03', 110, 1),('2023-07-05', 111, 1), ('2023-07-01', 112, 1),('2023-07-03', 113, 1),('2023-07-05', 114, 1), ('2023-07-01', 115, 1),('2023-07-03', 116, 1),('2023-07-05', 117, 1), ('2023-07-01', 118, 1),('2023-07-03', 119, 1),('2023-07-05', 120, 1); SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('i6069') i; VACUUM ANALYZE i6069; SET enable_indexscan = ON; SET enable_seqscan = OFF; :explain SELECT * FROM ( VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(10) ) AS attr_ids(attr_id) INNER JOIN LATERAL ( SELECT * FROM i6069 WHERE i6069.attr_id = attr_ids.attr_id AND timestamp > '2023-06-30' AND timestamp < '2023-07-06' ORDER BY timestamp desc LIMIT 1 ) a ON true; SELECT * FROM ( VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(10) ) AS attr_ids(attr_id) INNER JOIN LATERAL ( SELECT * FROM i6069 WHERE i6069.attr_id = attr_ids.attr_id AND timestamp > '2023-06-30' AND timestamp < '2023-07-06' ORDER BY timestamp desc LIMIT 1 ) a ON true; RESET enable_indexscan; RESET enable_seqscan; -- When all chunks are compressed and a limit query is performed, only the needed -- chunks should be accessed CREATE TABLE sensor_data_compressed ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); SELECT FROM create_hypertable('sensor_data_compressed', 'time'); INSERT INTO sensor_data_compressed (time, sensor_id, cpu, temperature) VALUES ('1980-01-02 00:00:00-00', 1, 3, 12.0), ('1980-01-03 00:00:00-00', 3, 4, 15.0), ('1980-02-04 00:00:00-00', 1, 2, 17.0), ('1980-02-05 00:00:00-00', 3, 6, 11.0), ('1980-03-06 00:00:00-00', 1, 8, 13.0), ('1980-03-07 00:00:00-00', 3, 4, 4.0), ('1980-04-08 00:00:00-00', 1, 2, 1.0), ('1980-04-03 00:00:00-00', 3, 5, 33.0), ('1980-05-02 00:00:00-00', 1, 8, 41.0), ('1980-05-03 00:00:00-00', 3, 4, 22.0), ('1980-06-02 00:00:00-00', 1, 1, 45.0), ('1980-06-03 00:00:00-00', 3, 3, 44.0); ALTER TABLE sensor_data_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='sensor_id', timescaledb.compress_orderby = 'time DESC'); -- Increase work_mem slightly so that the batch sorted merge plan is not disabled. SET work_mem = '16MB'; -- Compress three of the chunks SELECT compress_chunk(ch) FROM show_chunks('sensor_data_compressed') ch LIMIT 3; VACUUM ANALYZE sensor_data_compressed; SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; -- Only the first chunks should be accessed (batch sorted merge is enabled) :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; -- Only the first chunks should be accessed (batch sorted merge is disabled) SET timescaledb.enable_decompression_sorted_merge = FALSE; :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; RESET timescaledb.enable_decompression_sorted_merge; -- Compress the remaining chunks SELECT compress_chunk(ch, if_not_compressed => true) FROM show_chunks('sensor_data_compressed') ch; VACUUM ANALYZE sensor_data_compressed; SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; -- Only the first chunks should be accessed (batch sorted merge is enabled) :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; -- Only the first chunks should be accessed (batch sorted merge is disabled) SET timescaledb.enable_decompression_sorted_merge = FALSE; :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; RESET timescaledb.enable_decompression_sorted_merge; -- Convert the last chunk into a partially compressed chunk INSERT INTO sensor_data_compressed (time, sensor_id, cpu, temperature) VALUES ('1980-01-02 01:00:00-00', 2, 4, 14.0); VACUUM ANALYZE sensor_data_compressed; -- Only the first chunks should be accessed (batch sorted merge is enabled) :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; -- Only the first chunks should be accessed (batch sorted merge is disabled) SET timescaledb.enable_decompression_sorted_merge = FALSE; :PREFIX SELECT * FROM sensor_data_compressed ORDER BY time DESC LIMIT 5; RESET timescaledb.enable_decompression_sorted_merge; -- create another chunk INSERT INTO stattest SELECT '2021/02/20 01:00'::TIMESTAMPTZ + ('1 hour'::interval * v), 250 * v FROM generate_series(125,140) v; VACUUM ANALYZE stattest; SELECT count(*) from show_chunks('stattest'); SELECT table_name INTO TEMPORARY temptable FROM _timescaledb_catalog.chunk WHERE hypertable_id = (SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'stattest') ORDER BY creation_time desc limit 1; SELECT table_name as "STAT_CHUNK2_NAME" FROM temptable \gset -- verify that approximate_row_count works ok on normal chunks SELECT approximate_row_count('_timescaledb_internal.' || :'STAT_CHUNK2_NAME'); -- verify that approximate_row_count works fine on a hypertable with a mix of uncompressed -- and compressed data SELECT approximate_row_count('stattest'); DROP TABLE stattest; -- test that all variants of compress_chunk produce a fully compressed chunk CREATE TABLE compress_chunk_test(time TIMESTAMPTZ NOT NULL, device text, value float); SELECT create_hypertable('compress_chunk_test', 'time'); INSERT INTO compress_chunk_test SELECT '2020-01-01', 'r2d2', 3.14; ALTER TABLE compress_chunk_test SET (timescaledb.compress); SELECT show_chunks('compress_chunk_test') AS "CHUNK" \gset -- initial call will compress the chunk SELECT compress_chunk(:'CHUNK'); -- subsequent calls will be noop SELECT compress_chunk(:'CHUNK'); -- unless if_not_compressed is set to false \set ON_ERROR_STOP 0 SELECT compress_chunk(:'CHUNK', false); \set ON_ERROR_STOP 1 ALTER TABLE compress_chunk_test SET (timescaledb.compress_segmentby='device'); SELECT compressed_chunk_id from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name='compress_chunk_test'; -- changing compression settings will not recompress the chunk by default SELECT compress_chunk(:'CHUNK'); -- unless we specify recompress := true SELECT compress_chunk(:'CHUNK', recompress := true); -- compressed_chunk_id should be different now SELECT compressed_chunk_id from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name='compress_chunk_test'; --test partial handling INSERT INTO compress_chunk_test SELECT '2020-01-01', 'c3po', 3.14; -- should result in merging uncompressed data into compressed chunk SELECT compress_chunk(:'CHUNK'); -- compressed_chunk_id should not have changed SELECT compressed_chunk_id from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name='compress_chunk_test'; -- should return no rows SELECT * FROM ONLY :CHUNK; ALTER TABLE compress_chunk_test SET (timescaledb.compress_segmentby=''); -- create another chunk INSERT INTO compress_chunk_test SELECT '2021-01-01', 'c3po', 3.14; SELECT show_chunks('compress_chunk_test') AS "CHUNK2" LIMIT 1 OFFSET 1 \gset SELECT compress_chunk(:'CHUNK2'); -- make it partial and compress again INSERT INTO compress_chunk_test SELECT '2021-01-01', 'r2d2', 3.14; SELECT compress_chunk(:'CHUNK2'); -- should return no rows SELECT * FROM ONLY :CHUNK2; ------ --- Test copy with a compressed table with unique index ------ CREATE TABLE compressed_table (time timestamptz, a int, b int, c int); CREATE UNIQUE INDEX compressed_table_index ON compressed_table(time, a, b, c); SELECT create_hypertable('compressed_table', 'time'); ALTER TABLE compressed_table SET (timescaledb.compress, timescaledb.compress_segmentby='a', timescaledb.compress_orderby = 'time DESC'); COPY compressed_table (time,a,b,c) FROM stdin; 2024-02-29 10:00:00.00000+01 5 1 1 2024-02-29 15:02:03.87313+01 10 2 2 \. SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('compressed_table') i; \set ON_ERROR_STOP 0 COPY compressed_table (time,a,b,c) FROM stdin; 2024-02-29 15:02:03.87313+01 10 2 2 \. \set ON_ERROR_STOP 1 COPY compressed_table (time,a,b,c) FROM stdin; 2024-02-29 15:02:03.87313+01 20 3 3 \. SELECT * FROM compressed_table ORDER BY time, a; SELECT compress_chunk(i, if_not_compressed => true) FROM show_chunks('compressed_table') i; -- Check DML decompression limit SET timescaledb.max_tuples_decompressed_per_dml_transaction = 1; \set ON_ERROR_STOP 0 COPY compressed_table (time,a,b,c) FROM stdin; 2024-02-29 15:02:03.87313+01 10 4 4 2024-02-29 15:02:03.87313+01 20 5 5 \. \set ON_ERROR_STOP 1 RESET timescaledb.max_tuples_decompressed_per_dml_transaction; -- Test decompression with DML which compares int8 to int4 CREATE TABLE hyper_84 (time timestamptz, device int8, location int8, temp float8); SELECT create_hypertable('hyper_84', 'time', create_default_indexes => false); INSERT INTO hyper_84 VALUES ('2024-01-01', 1, 1, 1.0); ALTER TABLE hyper_84 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(ch) FROM show_chunks('hyper_84') ch; -- indexscan for decompression: UPDATE UPDATE hyper_84 SET temp = 100 where device = 1; SELECT compress_chunk(ch) FROM show_chunks('hyper_84') ch; -- indexscan for decompression: DELETE DELETE FROM hyper_84 WHERE device = 1; -- Test using DELETE instead of TRUNCATE after compression CREATE TABLE hyper_delete (time timestamptz, device int, location int, temp float, t text); SELECT table_name FROM create_hypertable('hyper_delete', 'time'); INSERT INTO hyper_delete VALUES ('2024-07-10', 1, 1, 1.0, repeat('X', 10000)); ANALYZE hyper_delete; SELECT ch AS "CHUNK" FROM show_chunks('hyper_delete') ch \gset SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass; -- One uncompressed row SELECT count(*) FROM :CHUNK; ALTER TABLE hyper_delete SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SET timescaledb.enable_delete_after_compression TO true; SELECT FROM compress_chunk(:'CHUNK'); -- still have more than one tuple SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass; ANALYZE hyper_delete; -- after ANALYZE we should have no tuples SELECT relpages, reltuples::int AS reltuples FROM pg_catalog.pg_class WHERE oid = :'CHUNK'::regclass; -- One compressed row SELECT count(*) FROM :CHUNK; RESET timescaledb.enable_delete_after_compression; -- Test batch size limiting GUC CREATE TABLE hyper_85 (time timestamptz, device int8, location int8, temp float8); SELECT create_hypertable('hyper_85', 'time', create_default_indexes => false); INSERT INTO hyper_85 SELECT t, 1, 1, 1.0 FROM generate_series('2024-01-01'::timestamptz, '2024-01-02'::timestamptz, '20 sec'::interval) t; ALTER TABLE hyper_85 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); -- first without the limit BEGIN; SELECT compress_chunk(ch) FROM show_chunks('hyper_85') ch; SELECT ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'hyper_85' ORDER BY ch1.id LIMIT 1 \gset select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset SELECT _ts_meta_count FROM :COMPRESSED_CHUNK_NAME ORDER BY device, _ts_meta_min_1 DESC; ROLLBACK; -- now lets set the limit SET timescaledb.compression_batch_size_limit = 505; BEGIN; SELECT compress_chunk(ch) FROM show_chunks('hyper_85') ch; SELECT ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'hyper_85' ORDER BY ch1.id LIMIT 1 \gset select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset SELECT _ts_meta_count FROM :COMPRESSED_CHUNK_NAME ORDER BY device, _ts_meta_min_1 DESC; ROLLBACK; -- Test poor compression rate warning works as expected -- Turn GUC on SET timescaledb.enable_compression_ratio_warnings TO ON; -- Compressing a table with very few rows virtually guarantees a poor compression rate CREATE TABLE badly_compressed_ht (time timestamptz, device_id integer, a integer); SELECT create_hypertable('badly_compressed_ht', 'time'); ALTER TABLE badly_compressed_ht set (timescaledb.compress, timescaledb.compress_segmentby = 'device_id'); INSERT INTO badly_compressed_ht VALUES ('2025-04-25 00:00'::timestamp, 1, 1), ('2025-04-25 01:00'::timestamp, 2, 2), ('2025-04-25 02:00'::timestamp, 3, 3); \set VERBOSITY default SELECT compress_chunk(show_chunks('badly_compressed_ht')); \set VERBOSITY terse RESET timescaledb.enable_compression_ratio_warnings; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_algos.sql�����������������������������������������������0000664�0000000�0000000�00000063664�15100345067�0022721�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --install necessary functions for tests \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_compression() RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; \ir include/compression_utils.sql \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- helper function: float -> pseudorandom float [0..1]. create or replace function mix(x float4) returns float4 as $$ select ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ language sql; create or replace function mix(x timestamptz) returns float4 as $$ select mix(extract(epoch from x)::float4) $$ language sql; ------------------ -- C unit tests -- ------------------ SELECT ts_test_compression(); ------------------------ -- BIGINT Compression -- ------------------------ SELECT $$ select item from base_ints order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_ints \set TYPE BIGINT \set COMPRESSION_CMD _timescaledb_internal.compress_deltadelta(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::BIGINT) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::BIGINT) -- random order CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::bigint FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql DROP TABLE base_ints; -- ascending order with nulls CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::bigint FROM (SELECT generate_series(1, 1000) item) sub; INSERT INTO base_ints VALUES (0, NULL), (10, NULL), (10000, NULL); \ir include/compression_test.sql SELECT c ints_text FROM compressed; DROP TABLE base_ints; -- single element CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::bigint FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql DROP TABLE base_ints; -- really big deltas SELECT 9223372036854775807 as big_int_max \gset SELECT -9223372036854775808 as big_int_min \gset CREATE TABLE base_ints AS SELECT row_number() over () as rn, item FROM ( VALUES --big deltas (0), (:big_int_max), (:big_int_min), (:big_int_max), (:big_int_min), (0), (:big_int_min), (32), (5), (:big_int_min), (-52), (:big_int_max), (1000), --big delta_deltas (0), (:big_int_max), (:big_int_max), (:big_int_min), (:big_int_min), (:big_int_max), (:big_int_max), (0), (:big_int_max-1), (:big_int_max-1), (:big_int_min), (:big_int_min), (:big_int_max-1), (:big_int_max-1) ) as t(item); \ir include/compression_test.sql DROP TABLE base_ints; -- NULLs CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(i, 5) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql DROP TABLE base_ints; CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(i, 1) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql DROP TABLE base_ints; CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(i, 10) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql DROP TABLE base_ints; CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8) item FROM generate_series(1::BIGINT, 10) i; \ir include/compression_test.sql DROP TABLE base_ints; ------------------------ -- INT Compression -- ------------------------ CREATE TABLE base_ints AS SELECT row_number() OVER() as rn, item::int FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; SELECT $$ select item::bigint from base_ints order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_ints \set TYPE BIGINT \set COMPRESSION_CMD _timescaledb_internal.compress_deltadelta(item::bigint) \ir include/compression_test.sql DROP TABLE base_ints; ----------------------------- -- TIMESTAMPTZ Compression -- ----------------------------- SELECT $$ select item from base_time order by rn $$ AS "QUERY" \gset \set TYPE TIMESTAMPTZ \set TABLE_NAME base_time \set COMPRESSION_CMD _timescaledb_internal.compress_deltadelta(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::TIMESTAMPTZ) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::TIMESTAMPTZ) CREATE TABLE base_time AS SELECT row_number() OVER() as rn, item FROM (select sub.item from (SELECT generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql DROP TABLE base_time; ------------------------ -- FLOAT4 Compression -- ------------------------ SELECT $$ select item from base_floats order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_floats SELECT 'real' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_gorilla(item) SELECT '_timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::float4)' AS "DECOMPRESS_FORWARD_CMD" \gset SELECT '_timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::float4)' AS "DECOMPRESS_REVERSE_CMD" \gset CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, item::float4 FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql SELECT c gorilla_text FROM compressed; DROP TABLE base_floats; -- single element CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, item::float4 FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql DROP TABLE base_floats; --special values CREATE TABLE base_floats AS SELECT row_number() over () as rn, item FROM ( VALUES --special (0::float4), ('Infinity'), ('-Infinity'), ('NaN'), --big deltas (0), ('Infinity'), ('-Infinity'), ('Infinity'), ('-Infinity'), (0), ('-Infinity'), (32), (5), ('-Infinity'), (-52), ('Infinity'), (1000), --big delta_deltas (0), ('Infinity'), ('Infinity'), ('-Infinity'), ('-Infinity'), ('Infinity'), ('Infinity') ) as t(item); \ir include/compression_test.sql DROP TABLE base_floats; -- all 0s CREATE TABLE base_floats AS SELECT row_number() over () as rn, 0::float4 as item FROM (SELECT generate_series(1, 1000) ) j; \ir include/compression_test.sql DROP TABLE base_floats; -- NULLs CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_floats; CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_floats; CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_floats; CREATE TABLE base_floats AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::float4 item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_floats; ------------------------ -- DOUBLE Compression -- ------------------------ SELECT $$ select item from base_doubles order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_doubles SELECT 'DOUBLE PRECISION' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_gorilla(item) SELECT '_timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::DOUBLE PRECISION)' AS "DECOMPRESS_FORWARD_CMD" \gset SELECT '_timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::DOUBLE PRECISION)' AS "DECOMPRESS_REVERSE_CMD" \gset CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, item::double precision FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql SELECT c gorilla_text FROM compressed; DROP TABLE base_doubles; -- single element CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, item::double precision FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql DROP TABLE base_doubles; --special values CREATE TABLE base_doubles AS SELECT row_number() over () as rn, item FROM ( VALUES --special (0::double precision), ('Infinity'), ('-Infinity'), ('NaN'), --big deltas (0), ('Infinity'), ('-Infinity'), ('Infinity'), ('-Infinity'), (0), ('-Infinity'), (32), (5), ('-Infinity'), (-52), ('Infinity'), (1000), --big delta_deltas (0), ('Infinity'), ('Infinity'), ('-Infinity'), ('-Infinity'), ('Infinity'), ('Infinity') ) as t(item); \ir include/compression_test.sql DROP TABLE base_doubles; -- all 0s CREATE TABLE base_doubles AS SELECT row_number() over () as rn, 0::FLOAT(50) as item FROM (SELECT generate_series(1, 1000) ) j; \ir include/compression_test.sql DROP TABLE base_doubles; -- NULLs CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_doubles; CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_doubles; CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_doubles; CREATE TABLE base_doubles AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::DOUBLE PRECISION item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_doubles; ------------------------ -- Dictionary Compression -- ------------------------ SELECT $$ select item from base_texts order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_texts SELECT 'TEXT' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_dictionary(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::TEXT) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::TEXT) -- high cardinality CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (select sub.item from (SELECT generate_series(1, 1000) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql SELECT c from compressed; DROP TABLE base_texts; -- low cardinality CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (SELECT i as item FROM generate_series(1, 10) i, generate_series(1, 100) j ORDER BY mix(i + j)) sub; \ir include/compression_test.sql DROP TABLE base_texts; -- single element CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql DROP TABLE base_texts; -- high cardinality with toasted values CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, repeat(item::text, 100000) as item FROM (select sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY mix(item)) sub; --make sure it's toasted SELECT pg_total_relation_size(reltoastrelid) FROM pg_class c WHERE relname = 'base_texts'; \ir include/compression_test.sql DROP TABLE base_texts; -- NULLs CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::TEXT item FROM generate_series(1, 10) i, generate_series(1, 100) j; \ir include/compression_test.sql DROP TABLE base_texts; ----------------------- -- Array Compression -- ----------------------- SELECT $$ select item from base_texts order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_texts SELECT 'TEXT' as "TYPE" \gset \set COMPRESSION_CMD _timescaledb_internal.compress_array(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::TEXT) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::TEXT) --basic test CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (select sub.item from (SELECT generate_series(1, 100) item) as sub ORDER BY mix(item)) sub; \ir include/compression_test.sql SELECT c from compressed; DROP TABLE base_texts; -- single element CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, item::text FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql DROP TABLE base_texts; -- toasted values CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, repeat(item::text, 100000) as item FROM (select sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY mix(item)) sub; --make sure it's toasted SELECT pg_total_relation_size(reltoastrelid) FROM pg_class c WHERE relname = 'base_texts'; \ir include/compression_test.sql DROP TABLE base_texts; -- NULLs CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 5)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 1)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(i, 10)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT row_number() OVER() as rn, NULLIF(NULLIF(NULLIF(NULLIF(i, 2), 4), 5), 8)::TEXT item FROM generate_series(1, 10) i; \ir include/compression_test.sql DROP TABLE base_texts; ---------------------- -- Bool Compression -- ---------------------- SELECT $$ select item from base_bools order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_bools \set TYPE boolean \set COMPRESSION_CMD _timescaledb_internal.compress_bool(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::boolean) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::boolean) -- bool test, flipping values betweem true and false, no nulls CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, (item%2=0)::boolean as item FROM (SELECT generate_series(1, 1000) item) sub; \ir include/compression_test.sql DROP TABLE base_bools; -- bool test, all true values, no nulls CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, true as item FROM (SELECT generate_series(1, 1000) item) sub; \ir include/compression_test.sql DROP TABLE base_bools; -- bool test, all false, no nulls CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, false as item FROM (SELECT generate_series(1, 1000) item) sub; \ir include/compression_test.sql DROP TABLE base_bools; -- a single true element CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, true as item FROM (SELECT generate_series(1, 1) item) sub; \ir include/compression_test.sql DROP TABLE base_bools; -- all true, except every 43rd value is null CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, ((NULLIF(i, (CASE WHEN i%43=0 THEN i ELSE -1 END)))>0)::boolean item FROM generate_series(1, 1000) i; \ir include/compression_test.sql DROP TABLE base_bools; -- all false, except every 29th value is null CREATE TABLE base_bools AS SELECT row_number() OVER() as rn, ((NULLIF(i, (CASE WHEN i%29=0 THEN i ELSE -1 END)))<0)::boolean item FROM generate_series(1, 1000) i; \ir include/compression_test.sql DROP TABLE base_bools; ---------------------- -- UUID Compression -- ---------------------- CREATE TABLE uuid_set (i int, u uuid); INSERT INTO uuid_set (i, u) VALUES (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (18, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (19, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (20, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (21, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (22, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (23, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (24, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (25, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (26, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (27, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (28, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (29, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (30, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (31, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (32, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (33, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (34, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (35, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (36, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (37, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (38, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (39, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (40, '0197a7a9-b48c-7c96-914c-690b7930262f'), (41, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (42, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (43, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (44, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'), (45, '0197a7a9-b48c-7c9b-9319-de9dd58deeee'), (46, '0197a7a9-b48c-7c9c-a9d4-ed6f3e6a41b7'), (47, '0197a7a9-b48c-7c9d-8036-4141e0780323'), (48, '0197a7a9-b48c-7c9e-bfbe-f00eb49ed7f2'), (49, '0197a7a9-b48c-7c9f-8ffe-71cf00a0c0c0'), (50, '0197a7a9-b48c-7ca0-822f-95ced2f95702'), (51, '0197a7a9-b48c-7ca1-8c8a-66582aec95fa'), (52, '0197a7a9-b48c-7ca2-95c3-fe80362a2251'), (53, '0197a7a9-b48c-7ca3-855f-f681b254a8c8'), (54, '0197a7a9-b48c-7ca4-856b-a562eca93c3f'), (55, '0197a7a9-b48c-7ca5-a30e-37c247fb4c46'), (56, '0197a7a9-b48c-7ca6-9e78-a148d54a44ac'), (57, '0197a7a9-b48c-7ca7-badb-4b650bf5bf5f'), (58, '0197a7a9-b48c-7ca8-8275-a8590869ef13'), (59, '0197a7a9-b48c-7ca9-b328-b54c3901223c'), (60, '0197a7a9-b48c-7caa-a15d-f5564e4e552c'), (61, '0197a7a9-b48c-7cab-a4ac-017259746322'), (62, '0197a7a9-b48c-7cac-bda5-74ef12abd6b8'), (63, '0197a7a9-b48c-7cad-a3cd-0e4c93eaba80'), (64, '0197a7a9-b48c-7cae-9667-de4a226418df'), (65, '0197a7a9-b48c-7caf-8aa2-067619170f32'), (66, '0197a7a9-b48c-7cb0-ba8c-91d9e8920845'), (67, '0197a7a9-b48c-7cb1-9681-a62bfffe9237'), (68, '0197a7a9-b48c-7cb2-b78b-037e5ee26ff6'), (69, '0197a7a9-b48c-7cb3-ac27-e24382445188'), (70, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (71, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (72, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (73, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (74, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (75, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (76, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (77, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (78, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (79, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (80, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (81, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (82, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (83, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (84, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (85, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (86, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (87, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (88, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (89, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (90, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (91, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (92, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (93, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (94, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (95, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (96, '0197a7a9-b48c-7c96-914c-690b7930262f'), (97, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (98, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (99, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (100, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'); SELECT $$ select item from base_uuids order by rn $$ AS "QUERY" \gset \set TABLE_NAME base_uuids \set TYPE uuid \set COMPRESSION_CMD _timescaledb_internal.compress_uuid(item) \set DECOMPRESS_FORWARD_CMD _timescaledb_internal.decompress_forward(c::_timescaledb_internal.compressed_data, NULL::uuid) \set DECOMPRESS_REVERSE_CMD _timescaledb_internal.decompress_reverse(c::_timescaledb_internal.compressed_data, NULL::uuid) SET timescaledb.enable_uuid_compression = on; -- basic test, flipping values between UUID v4s, UUID v7s and NULLs CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = gen_random_uuid() WHERE rn % 4 = 0; UPDATE base_uuids SET item = (SELECT u FROM uuid_set WHERE i = rn % 100) WHERE rn % 4 = 1; UPDATE base_uuids SET item = (SELECT u FROM uuid_set WHERE i = rn % 97) WHERE rn % 4 = 2; \ir include/compression_test.sql DROP TABLE base_uuids; -- all NULLs and a single UUID v7 CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = '0197a7a9-b48b-7c74-a2a4-dcdbce635d11' WHERE rn = 1; \ir include/compression_test.sql DROP TABLE base_uuids; -- no NULLs CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = (SELECT u FROM uuid_set WHERE i = rn % 100); \ir include/compression_test.sql DROP TABLE base_uuids; -- flipping values between two UUID v7s and NULLs CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, NULL::uuid as item FROM (SELECT generate_series(1, 1000) item) sub; UPDATE base_uuids SET item = '0197a7a9-b48b-7c74-a2a4-dcdbce635d11' WHERE rn % 3 = 0; UPDATE base_uuids SET item = '0197a7a9-b48b-7c74-a2a4-dcdbce635d12' WHERE rn % 3 = 1; \ir include/compression_test.sql DROP TABLE base_uuids; -- test with a set of UUID v7s CREATE TABLE base_uuids AS SELECT row_number() OVER() as rn, u as item FROM uuid_set ORDER BY i; \ir include/compression_test.sql DROP TABLE base_uuids; RESET timescaledb.enable_uuid_compression; DROP table uuid_set; ----------------------------------------------- -- Interesting corrupt data found by fuzzing -- ----------------------------------------------- \c :TEST_DBNAME :ROLE_SUPERUSER create or replace function ts_read_compressed_data_file(cstring, regtype, cstring, bool = true) returns int as :TSL_MODULE_PATHNAME, 'ts_read_compressed_data_file' language c; \set ON_ERROR_STOP 0 select ts_read_compressed_data_file('gorilla', 'float8', '--nonexistent'); -- Just some random file that returns "compressed data is corrupt", for one-off testing. select ts_read_compressed_data_file('gorilla', 'float8', (:'TEST_INPUT_DIR' || '/fuzzing/compression/gorilla-float8/1f09f12d930daae8e5fd34e11e7b2303e1705b2e')::cstring); \set ON_ERROR_STOP 1 create or replace function ts_read_compressed_data_directory(cstring, regtype, cstring, bool) returns table(path text, bytes int, rows int, sqlstate text, location text) as :TSL_MODULE_PATHNAME, 'ts_read_compressed_data_directory' language c; \set fn 'ts_read_compressed_data_directory(:''algo'', :''type'', format(''%s/fuzzing/compression/%s-%s'', :''TEST_INPUT_DIR'', :''algo'', :''type'')::cstring, ' \set algo gorilla \set type float8 select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; \set algo deltadelta \set type int8 select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; \set algo array \set type text select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; \set algo dictionary \set type text select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; \set algo bool \set type bool select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ; \set algo uuid \set type uuid select count(*) , coalesce((bulk.rows >= 0)::text, bulk.sqlstate) bulk_result , coalesce((rowbyrow.rows >= 0)::text, rowbyrow.sqlstate) rowbyrow_result from :fn true) bulk join :fn false) rowbyrow using (path) group by 2, 3 order by 1 desc ;����������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_allocation.sql������������������������������������������0000664�0000000�0000000�00000003460�15100345067�0023725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test array compression overallocation protection CREATE TABLE vector_overalloc (time timestamptz, device int8, ord numeric, value text); SELECT create_hypertable('vector_overalloc', 'time', create_default_indexes => false); -- This will try to create an array of chars over 1GB allocation limit INSERT INTO vector_overalloc VALUES ('2025-01-01 00:00:00', 1, 1, repeat(md5(random()::text), 32*1024*200)), --200 MB value ('2025-01-01 00:00:01', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:02', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:03', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:04', 1, 1, repeat(md5(random()::text), 32*1024*200)), ('2025-01-01 00:00:05', 1, 1, repeat(md5(random()::text), 32*1024*200)); ALTER TABLE vector_overalloc SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); SET timescaledb.enable_compressor_batch_limit to true; SELECT compress_chunk(ch) FROM show_chunks('vector_overalloc') ch; SELECT ch1.id "CHUNK_ID" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'vector_overalloc' ORDER BY ch1.id LIMIT 1 \gset select compressed.schema_name|| '.' || compressed.table_name as "COMPRESSED_CHUNK_NAME" from _timescaledb_catalog.chunk uncompressed, _timescaledb_catalog.chunk compressed where uncompressed.compressed_chunk_id = compressed.id AND uncompressed.id = :'CHUNK_ID' \gset -- Confirm we have multiple batches SELECT _ts_meta_count FROM :COMPRESSED_CHUNK_NAME ORDER BY device, _ts_meta_min_1 ASC; DROP TABLE vector_overalloc; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_bgw.sql�������������������������������������������������0000664�0000000�0000000�00000040201�15100345067�0022351�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE NOLOGIN_ROLE WITH nologin noinherit; -- though user on access node has required GRANTS, this will propagate GRANTS to the connected data nodes GRANT CREATE ON SCHEMA public TO NOLOGIN_ROLE; GRANT NOLOGIN_ROLE TO :ROLE_DEFAULT_PERM_USER WITH ADMIN OPTION; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE conditions ( time TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select create_hypertable( 'conditions', 'time', chunk_time_interval=> '31days'::interval); --TEST 1-- --cannot set policy without enabling compression -- \set ON_ERROR_STOP 0 select add_compression_policy('conditions', '60d'::interval); \set ON_ERROR_STOP 1 -- TEST2 -- --add a policy to compress chunks -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'time'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; select add_compression_policy('conditions', '60d'::interval) AS compressjob_id \gset select * from _timescaledb_config.bgw_job where id = :compressjob_id; select * from alter_job(:compressjob_id, schedule_interval=>'1s'); --enable maxchunks to 1 so that only 1 chunk is compressed by the job SELECT alter_job(id,config:=jsonb_set(config,'{maxchunks_to_compress}', '1')) FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; select * from _timescaledb_config.bgw_job where id >= 1000 ORDER BY id; insert into conditions select now()::timestamp, 'TOK', 'sony', 55, 75; -- TEST3 -- --only the old chunks will get compressed when policy is executed-- CALL run_job(:compressjob_id); select chunk_name, pg_size_pretty(before_compression_total_bytes) before_total, pg_size_pretty( after_compression_total_bytes) after_total from chunk_compression_stats('conditions') where compression_status like 'Compressed' order by chunk_name; SELECT id, hypertable_id, schema_name, table_name, compressed_chunk_id, dropped, status, osm_chunk FROM _timescaledb_catalog.chunk ORDER BY id; -- TEST 4 -- --cannot set another policy \set ON_ERROR_STOP 0 select add_compression_policy('conditions', '60d'::interval, if_not_exists=>true); select add_compression_policy('conditions', '60d'::interval); select add_compression_policy('conditions', '30d'::interval, if_not_exists=>true); \set ON_ERROR_STOP 1 --TEST 5 -- -- drop the policy -- select remove_compression_policy('conditions'); select count(*) from _timescaledb_config.bgw_job WHERE id>=1000; --TEST 6 -- -- try to execute the policy after it has been dropped -- \set ON_ERROR_STOP 0 CALL run_job(:compressjob_id); --errors with bad input for add/remove compression policy create view dummyv1 as select * from conditions limit 1; select add_compression_policy( 100 , compress_after=> '1 day'::interval); select add_compression_policy( 'dummyv1', compress_after=> '1 day'::interval ); select remove_compression_policy( 100 ); \set ON_ERROR_STOP 1 -- We're done with the table, so drop it. DROP TABLE IF EXISTS conditions CASCADE; --TEST 7 --compression policy for smallint, integer or bigint based partition hypertable --smallint test CREATE TABLE test_table_smallint(time SMALLINT, val SMALLINT); SELECT create_hypertable('test_table_smallint', 'time', chunk_time_interval => 1); CREATE OR REPLACE FUNCTION dummy_now_smallint() RETURNS SMALLINT LANGUAGE SQL IMMUTABLE AS 'SELECT 5::SMALLINT'; SELECT set_integer_now_func('test_table_smallint', 'dummy_now_smallint'); INSERT INTO test_table_smallint SELECT generate_series(1,5), 10; ALTER TABLE test_table_smallint SET (timescaledb.compress); \set ON_ERROR_STOP 0 select add_compression_policy( 'test_table_smallint', compress_after=> '1 day'::interval ); \set ON_ERROR_STOP 1 SELECT add_compression_policy('test_table_smallint', 2::SMALLINT) AS compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; --will compress all chunks that need compression CALL run_job(:compressjob_id); SELECT chunk_name, before_compression_total_bytes, after_compression_total_bytes FROM chunk_compression_stats('test_table_smallint') WHERE compression_status LIKE 'Compressed' ORDER BY chunk_name; --integer tests CREATE TABLE test_table_integer(time INTEGER, val INTEGER); SELECT create_hypertable('test_table_integer', 'time', chunk_time_interval => 1); CREATE OR REPLACE FUNCTION dummy_now_integer() RETURNS INTEGER LANGUAGE SQL IMMUTABLE AS 'SELECT 5::INTEGER'; SELECT set_integer_now_func('test_table_integer', 'dummy_now_integer'); INSERT INTO test_table_integer SELECT generate_series(1,5), 10; ALTER TABLE test_table_integer SET (timescaledb.compress); SELECT add_compression_policy('test_table_integer', 2::INTEGER) AS compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; --will compress all chunks that need compression CALL run_job(:compressjob_id); SELECT chunk_name, before_compression_total_bytes, after_compression_total_bytes FROM chunk_compression_stats('test_table_integer') WHERE compression_status LIKE 'Compressed' ORDER BY chunk_name; --bigint test CREATE TABLE test_table_bigint(time BIGINT, val BIGINT); SELECT create_hypertable('test_table_bigint', 'time', chunk_time_interval => 1); CREATE OR REPLACE FUNCTION dummy_now_bigint() RETURNS BIGINT LANGUAGE SQL IMMUTABLE AS 'SELECT 5::BIGINT'; SELECT set_integer_now_func('test_table_bigint', 'dummy_now_bigint'); INSERT INTO test_table_bigint SELECT generate_series(1,5), 10; ALTER TABLE test_table_bigint SET (timescaledb.compress); SELECT add_compression_policy('test_table_bigint', 2::BIGINT) AS compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; --will compress all chunks that need compression CALL run_job(:compressjob_id); SELECT chunk_name, before_compression_total_bytes, after_compression_total_bytes FROM chunk_compression_stats('test_table_bigint') WHERE compression_status LIKE 'Compressed' ORDER BY chunk_name; --TEST 8 --hypertable owner lacks permission to start background worker SET ROLE NOLOGIN_ROLE; CREATE TABLE test_table_nologin(time bigint, val int); SELECT create_hypertable('test_table_nologin', 'time', chunk_time_interval => 1); SELECT set_integer_now_func('test_table_nologin', 'dummy_now_bigint'); ALTER TABLE test_table_nologin set (timescaledb.compress); \set ON_ERROR_STOP 0 SELECT add_compression_policy('test_table_nologin', 2::int); \set ON_ERROR_STOP 1 DROP TABLE test_table_nologin; RESET ROLE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE conditions( time TIMESTAMPTZ NOT NULL, device INTEGER, temperature FLOAT ); SELECT * FROM create_hypertable('conditions', 'time', chunk_time_interval => '1 day'::interval); INSERT INTO conditions SELECT time, (random()*30)::int, random()*80 - 40 FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous) AS SELECT device, time_bucket(INTERVAL '1 hour', "time") AS day, AVG(temperature) AS avg_temperature, MAX(temperature) AS max_temperature, MIN(temperature) AS min_temperature FROM conditions GROUP BY device, time_bucket(INTERVAL '1 hour', "time") WITH NO DATA; CALL refresh_continuous_aggregate('conditions_summary', NULL, NULL); ALTER TABLE conditions SET (timescaledb.compress); SELECT COUNT(*) AS dropped_chunks_count FROM drop_chunks('conditions', TIMESTAMPTZ '2018-12-15 00:00'); SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'conditions' and is_compressed = true; SELECT add_compression_policy AS job_id FROM add_compression_policy('conditions', INTERVAL '1 day') \gset -- job compresses only 1 chunk at a time -- SELECT alter_job(id,config:=jsonb_set(config,'{maxchunks_to_compress}', '1')) FROM _timescaledb_config.bgw_job WHERE id = :job_id; SELECT alter_job(id,config:=jsonb_set(config,'{verbose_log}', 'true')) FROM _timescaledb_config.bgw_job WHERE id = :job_id; set client_min_messages TO LOG; CALL run_job(:job_id); set client_min_messages TO NOTICE; SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'conditions' and is_compressed = true; \i include/recompress_basic.sql --TEST 7 --compression policy should ignore frozen partially compressed chunks CREATE TABLE test_table_frozen(time TIMESTAMPTZ, val SMALLINT); SELECT create_hypertable('test_table_frozen', 'time', chunk_time_interval => '1 day'::interval); INSERT INTO test_table_frozen SELECT time, (random()*10)::smallint FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; ALTER TABLE test_table_frozen SET (timescaledb.compress); select add_compression_policy( 'test_table_frozen', compress_after=> '1 day'::interval ) as compressjob_id \gset SELECT * FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; SELECT show_chunks('test_table_frozen') as first_chunk LIMIT 1 \gset --will compress all chunks that need compression CALL run_job(:compressjob_id); -- make the chunks partial INSERT INTO test_table_frozen SELECT time, (random()*10)::smallint FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; -- freeze first chunk SELECT _timescaledb_functions.freeze_chunk(:'first_chunk'); -- first chunk status is 1 (Compressed) + 8 (Partially compressed) + 4 (Frozen) = 13 SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; --should recompress all chunks except first since its frozen CALL run_job(:compressjob_id); -- first chunk status is unchanged SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; -- unfreeze first chunk SELECT _timescaledb_functions.unfreeze_chunk(:'first_chunk'); -- should be able to recompress the chunk since its unfrozen CALL run_job(:compressjob_id); -- first chunk status is Compressed (1) SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_table_frozen' ORDER BY c.id LIMIT 1; --TEST 8 --reindexing in recompression policy CREATE TABLE metrics2(time DATE NOT NULL); CREATE INDEX metrics2_index ON metrics2(time DESC); SELECT hypertable_id AS "HYPERTABLE_ID", schema_name, table_name, created FROM create_hypertable('metrics2','time') \gset ALTER TABLE metrics2 SET (timescaledb.compress); INSERT INTO metrics2 SELECT generate_series('2000-01-01'::date, '2000-02-01'::date, '5m'::interval); SELECT add_job('_timescaledb_functions.policy_compression','1w',('{"hypertable_id": '||:'HYPERTABLE_ID'||', "compress_after": "@ 7 days"}')::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS "JOB_COMPRESS" \gset -- first call should compress CALL run_job(:JOB_COMPRESS); -- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics2'; -- disable reindex in compress job SELECT alter_job(id,config:=jsonb_set(config,'{reindex}','false'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; -- do an INSERT so recompress has something to do INSERT INTO metrics2 SELECT '2000-01-01' FROM generate_series(1,3000); SELECT chunk_schema, chunk_name FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics2' AND chunk_status = 9 LIMIT 1; \gset SELECT format('%I.%I', :'chunk_schema', :'chunk_name') AS "RECOMPRESS_CHUNK_NAME"; \gset -- get size of the chunk that needs recompression VACUUM ANALYZE :RECOMPRESS_CHUNK_NAME; SELECT pg_indexes_size(:'RECOMPRESS_CHUNK_NAME') AS "SIZE_BEFORE_REINDEX"; \gset CALL run_job(:JOB_COMPRESS); -- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE chunk_schema = :'chunk_schema' AND chunk_name = :'chunk_name'; -- index size should not have decreased VACUUM ANALYZE :RECOMPRESS_CHUNK_NAME; -- index size can vary, vacuuming can even increase the size of the index -- just check that the index size hasn't decreased, this can only happen -- when running VACUUM FULL or REINDEX TABLE SELECT pg_indexes_size(:'RECOMPRESS_CHUNK_NAME') >= :SIZE_BEFORE_REINDEX as size_unchanged; -- enable reindex in compress job SELECT alter_job(id,config:=jsonb_set(config,'{reindex}','true'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; -- do an INSERT so recompress has something to do INSERT INTO metrics2 SELECT '2000-01-01'; ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE chunk_schema = :'chunk_schema' AND chunk_name = :'chunk_name'; -- should recompress CALL run_job(:JOB_COMPRESS); -- index size should decrease due to reindexing (8kB or 16kB) VACUUM ANALYZE metrics2; SELECT pg_indexes_size(:'RECOMPRESS_CHUNK_NAME') <= 16384 as size_empty; DROP TABLE metrics2; --TEST 8 --compression policy errors CREATE TABLE test_compression_policy_errors(time TIMESTAMPTZ, val SMALLINT); SELECT create_hypertable('test_compression_policy_errors', 'time', chunk_time_interval => '1 day'::interval); ALTER TABLE test_compression_policy_errors SET (timescaledb.compress, timescaledb.compress_segmentby = 'val', timescaledb.compress_orderby = 'time'); INSERT INTO test_compression_policy_errors SELECT time, (random()*10)::smallint FROM generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '10 min') AS time; SELECT add_compression_policy( 'test_compression_policy_errors', compress_after=> '1 day'::interval, initial_start => now() - interval '1 day' ) as compressjob_id \gset SELECT config AS compressjob_config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id \gset SELECT FROM alter_job(:compressjob_id, config => jsonb_set(:'compressjob_config'::jsonb, '{recompress}', 'true')); -- 31 uncompressed chunks (0 - uncompressed, 1 - compressed) SELECT c.status, count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' GROUP BY c.status ORDER BY 2 DESC; \c :TEST_DBNAME :ROLE_SUPERUSER -- Let's mess with the chunk status to for an error when executing the job WITH chunks AS ( SELECT c.id, c.status FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' ORDER BY c.id LIMIT 20 ) UPDATE _timescaledb_catalog.chunk SET status = 3 FROM chunks WHERE chunk.id = chunks.id AND chunk.status = 0; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- After the mess 20 = status 3 and 11 = status 0 SELECT c.status, count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' GROUP BY c.status ORDER BY 2 DESC; \set ON_ERROR_STOP 0 SET client_min_messages TO ERROR; \set VERBOSITY default -- This should fail with -- 20 chunks failed to compress and 11 chunks compressed successfully CALL run_job(:compressjob_id); \set VERBOSITY terse \set ON_ERROR_STOP 1 -- 31 uncompressed chunks (0 - uncompressed, 1 - compressed) SELECT c.status, count(*) FROM _timescaledb_catalog.chunk c INNER JOIN _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) WHERE h.table_name = 'test_compression_policy_errors' GROUP BY c.status ORDER BY 2 DESC; -- Teardown test \c :TEST_DBNAME :ROLE_SUPERUSER REVOKE CREATE ON SCHEMA public FROM NOLOGIN_ROLE; DROP ROLE NOLOGIN_ROLE; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_bool_vectorized.sql�������������������������������������0000664�0000000�0000000�00000002633�15100345067�0024772�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. drop table if exists t1; set timescaledb.enable_bool_compression = on; create table t1 (ts int, b bool); select create_hypertable('t1','ts'); alter table t1 set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t1 values (1, true); insert into t1 values (2, false); insert into t1 values (3, NULL); insert into t1 values (4, true); insert into t1 values (5, false); insert into t1 values (6, NULL); select compress_chunk(show_chunks('t1')); select * from t1 order by 1; select * from t1 where b is null order by 1; select * from t1 where b = true order by 1; select * from t1 where b = false order by 1; select * from t1 where ts > 3 and b is null order by 1; select * from t1 where ts > 3 and b = true order by 1; select * from t1 where ts > 3 and b = false order by 1; -- delete all null values and compress again delete from t1 where b is null; select compress_chunk(show_chunks('t1')); select * from t1 order by 1; select * from t1 where b is null order by 1; select * from t1 where b = true order by 1; select * from t1 where b = false order by 1; select * from t1 where ts > 3 and b is null order by 1; select * from t1 where ts > 3 and b = true order by 1; select * from t1 where ts > 3 and b = false order by 1; �����������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_bools.sql�����������������������������������������������0000664�0000000�0000000�00000010050�15100345067�0022707�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --install necessary functions for tests \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Create some data with NULLs and bools CREATE TABLE d (ts int, b bool); INSERT INTO d SELECT g AS ts, NULL AS b FROM generate_series(1, 5000) g; -- set b to true for even ts values and set some values to NULL UPDATE d SET b = (ts % 2 = 0); UPDATE d SET b = NULL WHERE (ts % 10 = 0); -- add some bools that can be RLE compressed INSERT INTO d SELECT g AS ts, true AS b FROM generate_series(5001, 20000) g; -- add a few bool columns CREATE TABLE t (ts int, b1 bool, b2 bool, b3 bool); SELECT create_hypertable('t', 'ts', chunk_time_interval => 5000); -- explicitly disable bool compression so the test -- doesn't depend on the default setting SET timescaledb.enable_bool_compression = off; INSERT INTO t SELECT d.ts, d.b AS b1, d.b AS b2, d.b AS b3 FROM d ORDER BY ts; SELECT max(ts) FROM t; ALTER TABLE t SET (timescaledb.compress, timescaledb.compress_orderby = 'ts'); SELECT compress_chunk(show_chunks('t')); CREATE TABLE chunks_done AS SELECT show_chunks('t') AS chunk_name; SELECT * FROM chunks_done; SELECT chunk_schema, chunk_name, compression_status, after_compression_total_bytes -- the before compression size differs on platforms, so I dont't -- display it here, and consequently the compression ratio as well FROM chunk_compression_stats('t'); -- enable bool compression and add more data, so the two compression -- methods will co-exist and we can test both, plus compare the -- compression ratio -- SET timescaledb.enable_bool_compression = on; INSERT INTO t SELECT (SELECT max(ts) FROM t)+d.ts, d.b AS b1, d.b AS b2, d.b AS b3 FROM d ORDER BY ts; SELECT max(ts) FROM t; SELECT compress_chunk(c) FROM show_chunks('t') c WHERE c NOT IN (SELECT chunk_name FROM chunks_done); SELECT chunk_schema, chunk_name, compression_status, after_compression_total_bytes -- the before compression size differs on platforms, so I dont't -- display it here, and consequently the compression ratio as well -- -- the after compression size should be smaller than it was before -- the bool compression was enabled -- FROM chunk_compression_stats('t') WHERE format('%I.%I', chunk_schema, chunk_name)::regclass NOT IN (SELECT chunk_name FROM chunks_done); -- check the compression algorithm for the compressed chunks CREATE TABLE compressed_chunks AS SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as compressed_chunk, ccs.compressed_heap_size, ccs.compressed_toast_size, ccs.compressed_index_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM show_chunks('t') c INNER JOIN _timescaledb_catalog.chunk cat ON (c = format('%I.%I', cat.schema_name, cat.table_name)::regclass) INNER JOIN _timescaledb_catalog.chunk comp ON (cat.compressed_chunk_id = comp.id) INNER JOIN _timescaledb_catalog.compression_chunk_size ccs ON (comp.id = ccs.compressed_chunk_id); CREATE TABLE compression_info (compressed_chunk regclass, result text, compressed_size int, num_rows int); DO $$ DECLARE table_ref regclass; BEGIN FOR table_ref IN SELECT compressed_chunk as table_ref FROM compressed_chunks LOOP EXECUTE format( 'INSERT INTO compression_info ( SELECT %L::regclass as compressed_chunk, (_timescaledb_functions.compressed_data_info(b1))::text as result, sum(pg_column_size(b1)::int) as compressed_size, count(*) as num_rows FROM %s GROUP BY 1,2)', table_ref, table_ref ); END LOOP; END; $$; SELECT ci.*, ccs.compressed_toast_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM compression_info ci INNER JOIN compressed_chunks ccs ON (ci.compressed_chunk = ccs.compressed_chunk) ORDER BY 1,2,3; DROP TABLE t; DROP TABLE d; DROP TABLE chunks_done; DROP TABLE compression_info; -- reset the compression setting SET timescaledb.enable_bool_compression = default; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_conflicts.sql�������������������������������������������0000664�0000000�0000000�00000051056�15100345067�0023570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test conflict handling on compressed hypertables with unique constraints set timescaledb.debug_compression_path_info to on; -- test 1: single column primary key CREATE TABLE comp_conflicts_1(time timestamptz, device text, value float, PRIMARY KEY(time)); SELECT table_name FROM create_hypertable('comp_conflicts_1','time'); ALTER TABLE comp_conflicts_1 SET (timescaledb.compress); -- implicitly create chunk INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); -- sanity check behaviour without compression -- should fail due to multiple entries with same time value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1), ('2020-01-01','d2',0.2), ('2020-01-01','d3',0.3); \set ON_ERROR_STOP 1 -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_1 VALUES ('2020-01-01 0:00:01','d1',0.1), ('2020-01-01 0:00:02','d2',0.2), ('2020-01-01 0:00:03','d3',0.3); ROLLBACK; SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_1') c \gset -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; -- repeat tests on an actual compressed chunk -- should fail due to multiple entries with same time value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1), ('2020-01-01','d2',0.2), ('2020-01-01','d3',0.3); \set ON_ERROR_STOP 1 -- no data should be in uncompressed chunk since the inserts failed and their transaction rolled back SELECT count(*) FROM ONLY :CHUNK; -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_1 VALUES ('2020-01-01 0:00:01','d1',0.1), ('2020-01-01 0:00:02','d2',0.2), ('2020-01-01 0:00:03','d3',0.3); -- no data should have moved into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1); \set ON_ERROR_STOP 1 INSERT INTO comp_conflicts_1 VALUES ('2020-01-01','d1',0.1) ON CONFLICT DO NOTHING; -- data should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; -- test 2: multi-column unique without segmentby CREATE TABLE comp_conflicts_2(time timestamptz NOT NULL, device text, value float, UNIQUE(time, device)); SELECT table_name FROM create_hypertable('comp_conflicts_2','time'); ALTER TABLE comp_conflicts_2 SET (timescaledb.compress, timescaledb.compress_segmentby=''); -- implicitly create chunk INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1); INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d2',0.2); SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_2') c \gset -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; -- should fail due to multiple entries with same time, device value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1); INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d2',0.2); INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1), ('2020-01-01','d2',0.2), ('2020-01-01','d3',0.3); \set ON_ERROR_STOP 1 -- no data should be in uncompressed chunk since the inserts failed and their transaction rolled back SELECT count(*) FROM ONLY :CHUNK; -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_2 VALUES ('2020-01-01 0:00:01','d1',0.1), ('2020-01-01 0:00:01','d2',0.2), ('2020-01-01 0:00:01','d3',0.3); -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1); \set ON_ERROR_STOP 1 INSERT INTO comp_conflicts_2 VALUES ('2020-01-01','d1',0.1) ON CONFLICT DO NOTHING; -- data should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; -- test 3: multi-column primary key with segmentby CREATE TABLE comp_conflicts_3(time timestamptz NOT NULL, device text, label text DEFAULT 'label', value float, UNIQUE(time, device, label)); SELECT table_name FROM create_hypertable('comp_conflicts_3','time'); ALTER TABLE comp_conflicts_3 SET (timescaledb.compress,timescaledb.compress_segmentby='device, label'); -- implicitly create chunk INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d2', 'label', 0.2); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01',NULL, 'label', 0.3); SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_3') c \gset -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; -- should fail due to multiple entries with same time, device value \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d2', 'label', 0.2); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1), ('2020-01-01','d2', 'label', 0.2), ('2020-01-01','d3', 'label', 0.3); -- should work the same without the index present BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d2', 'label', 0.2); ROLLBACK; BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1), ('2020-01-01','d2', 'label', 0.2), ('2020-01-01','d3', 'label', 0.3); ROLLBACK; -- using superuser to create indexes on compressed chunks \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER set timescaledb.debug_compression_path_info to on; -- ignore matching partial index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device, label, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC) WHERE label LIKE 'missing'; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; -- ignore matching covering index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX covering_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device) INCLUDE (label, _ts_meta_min_1, _ts_meta_max_1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; -- out of order segmentby index, index is still usable BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk (label, device, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; -- index with sequence number in the middle, index should be usable with single index scan key BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX covering_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device, _ts_meta_min_1 DESC, _ts_meta_max_1 DESC, label); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; -- ignore expression index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk (device, lower(label), _ts_meta_min_1 DESC, _ts_meta_max_1 DESC); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; -- ignore non-btree index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; CREATE INDEX partial_index ON _timescaledb_internal.compress_hyper_6_6_chunk USING brin (device, label, _ts_meta_min_1, _ts_meta_max_1); INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); ROLLBACK; \set ON_ERROR_STOP 1 \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER set timescaledb.debug_compression_path_info to on; -- no data should be in uncompressed chunk since the inserts failed and their transaction rolled back SELECT count(*) FROM ONLY :CHUNK; -- NULL is considered distinct from other NULL so even though the next INSERT looks -- like a conflict it is not a constraint violation (PG15 makes NULL behaviour configurable) BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01',NULL, 'label', 0.3); -- data for 1 segment (count = 1 value + 1 inserted) should be present in uncompressed chunk -- we treat NULLs as NOT DISTINCT and let the constraint configuration handle the check SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- check if NULL handling works the same with the compressed index dropped BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01',NULL, 'label', 0.3); -- data for 1 segment (count = 1 value + 1 inserted) should be present in uncompressed chunk -- we treat NULLs as NOT DISTINCT and let the constraint configuration handle the check SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1); -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- same as above but no index -- should succeed since there are no conflicts in the values BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1); -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1), ('2020-01-01 0:00:01','d2', 'label', 0.2), ('2020-01-01 0:00:01','d3', 'label', 0.3); -- no data for should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- same as above but no index BEGIN; DROP INDEX _timescaledb_internal.compress_hyper_6_6_chunk_device_label__ts_meta_min_1__ts_me_idx; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d1', 'label', 0.1), ('2020-01-01 0:00:01','d2', 'label', 0.2), ('2020-01-01 0:00:01','d3', 'label', 0.3); -- no data for should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; BEGIN; INSERT INTO comp_conflicts_3 VALUES ('2020-01-01 0:00:01','d3', 'label', 0.2); -- count = 1 since no data should have move into uncompressed chunk for conflict check since d3 is new segment SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1); \set ON_ERROR_STOP 1 INSERT INTO comp_conflicts_3 VALUES ('2020-01-01','d1', 'label', 0.1) ON CONFLICT DO NOTHING; -- data should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; -- test 4: multi-column primary key with multi-column orderby compression CREATE TABLE comp_conflicts_4(time timestamptz NOT NULL, device text, value float, UNIQUE(time, device)); SELECT table_name FROM create_hypertable('comp_conflicts_4','time'); ALTER TABLE comp_conflicts_4 SET (timescaledb.compress,timescaledb.compress_segmentby='',timescaledb.compress_orderby='time,device'); -- implicitly create chunk INSERT INTO comp_conflicts_4 SELECT generate_series('2020-01-01'::timestamp, '2020-01-01 2:00:00', '1s'), 'd1',0.1; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01','d2',0.2); INSERT INTO comp_conflicts_4 VALUES ('2020-01-01',NULL,0.3); SELECT compress_chunk(c) AS "CHUNK" FROM show_chunks('comp_conflicts_4') c \gset -- after compression no data should be in uncompressed chunk SELECT count(*) FROM ONLY :CHUNK; -- NULL is considered distinct from other NULL so even though the next INSERT looks -- like a conflict it is not a constraint violation (PG15 makes NULL behaviour configurable) BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01',NULL,0.3); -- data for 1 segment (count = 1000 values + 1 inserted) should be present in uncompressed chunk -- we treat NULLs as NOT DISTINCT and let the constraint configuration handle the check SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- should succeed since there are no conflicts in the values BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 2:00:01','d1',0.1); -- no data should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 2:00:01','d1',0.1), ('2020-01-01 2:00:01','d2',0.2), ('2020-01-01 2:00:01','d3',0.3); -- no data for should have move into uncompressed chunk for conflict check -- since we used metadata optimization to guarantee uniqueness SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; BEGIN; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 0:00:01','d3',0.2); -- count = 1 since no data should have move into uncompressed chunk for conflict check since d3 is new segment SELECT count(*) FROM ONLY :CHUNK; ROLLBACK; -- no data should be in uncompressed chunk since we did rollback SELECT count(*) FROM ONLY :CHUNK; -- should fail since it conflicts with existing row \set ON_ERROR_STOP 0 INSERT INTO comp_conflicts_4 VALUES ('2020-01-01','d1',0.1); \set ON_ERROR_STOP 1 -- data not should have move into uncompressed chunk for conflict check SELECT count(*) FROM ONLY :CHUNK; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 0:00:01','d1',0.1) ON CONFLICT DO NOTHING; INSERT INTO comp_conflicts_4 VALUES ('2020-01-01 0:30:00','d1',0.1) ON CONFLICT DO NOTHING; -- data should have move into uncompressed chunk for conflict check -- 2 segments (count = 2000) SELECT count(*) FROM ONLY :CHUNK; CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id; CREATE TABLE compressed_ht ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); CREATE UNIQUE INDEX sensor_id_time_idx on compressed_ht(time, sensor_id); SELECT * FROM create_hypertable('compressed_ht', 'time', chunk_time_interval => INTERVAL '2 months'); -- create chunk 1 INSERT INTO compressed_ht VALUES ('2017-12-28 01:10:28.192199+05:30', '1', 0.876, 4.123, 'chunk 1'); INSERT INTO compressed_ht VALUES ('2017-12-24 01:10:28.192199+05:30', '1', 0.876, 4.123, 'chunk 1'); -- create chunk 2 INSERT INTO compressed_ht VALUES ('2017-03-28 01:10:28.192199+05:30', '2', 0.876, 4.123, 'chunk 2'); INSERT INTO compressed_ht VALUES ('2017-03-12 01:10:28.192199+05:30', '3', 0.876, 4.123, 'chunk 2'); -- create chunk 3 INSERT INTO compressed_ht VALUES ('2022-01-18 01:10:28.192199+05:30', '4', 0.876, 4.123, 'chunk 3'); INSERT INTO compressed_ht VALUES ('2022-01-08 01:10:28.192199+05:30', '4', 0.876, 4.123, 'chunk 3'); INSERT INTO compressed_ht VALUES ('2022-01-11 01:10:28.192199+05:30', '5', 0.876, 4.123, 'chunk 3'); INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'chunk 3'); ALTER TABLE compressed_ht SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); SELECT COMPRESS_CHUNK(SHOW_CHUNKS('compressed_ht')); -- check compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'compressed_ht' ORDER BY chunk_name; -- should report 0 row SELECT COUNT(*) FROM compressed_ht WHERE name = 'ON CONFLICT DO UPDATE'; INSERT INTO compressed_ht VALUES ('2017-12-28 01:10:28.192199+05:30', '1', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO UPDATE SET sensor_id = excluded.sensor_id , name = 'ON CONFLICT DO UPDATE'; -- should report 1 row SELECT COUNT(*) FROM compressed_ht WHERE name = 'ON CONFLICT DO UPDATE'; -- check that chunk 1 compression status is set to partial SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'compressed_ht' ORDER BY chunk_name; INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO UPDATE SET sensor_id = excluded.sensor_id , name = 'ON CONFLICT DO UPDATE' RETURNING *; -- check that chunks 1 and 3 compression status is set to partial SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'compressed_ht' ORDER BY chunk_name; -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- Should error because we disabled the DML decompression INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO UPDATE SET sensor_id = excluded.sensor_id , name = 'ON CONFLICT DO UPDATE' RETURNING *; INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '6', 0.876, 4.123, 'new insert row') ON conflict(sensor_id, time) DO NOTHING; -- Even a regular insert will fail due to unique constrant checks for dml decompression INSERT INTO compressed_ht VALUES ('2022-01-24 01:10:28.192199+05:30', '7', 0.876, 4.123, 'new insert row'); \set ON_ERROR_STOP 1 RESET timescaledb.enable_dml_decompression; -- gh issue #7342 CREATE TABLE test_collation ( time int8 NOT NULL, device_id int4 NOT NULL, name TEXT NOT NULL, CONSTRAINT test_collation_pkey PRIMARY KEY (time, device_id, name) ); SELECT create_hypertable('test_collation', 'time', chunk_time_interval => 2419200000); ALTER TABLE test_collation SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id', timescaledb.compress_orderby = 'time DESC, name' ); INSERT INTO "test_collation" ("time", "device_id", "name") VALUES (1609477200000, 41, 'val1'), (1609478100000, 41, 'val1') ON CONFLICT DO NOTHING; SELECT compress_chunk(ch) FROM show_chunks('test_collation') ch; INSERT INTO "test_collation" ("device_id", "time", "name") VALUES (41, 1609477200000, 'val1'), (41, 1609478100000, 'val1') ON CONFLICT DO NOTHING; RESET timescaledb.debug_compression_path_info; -- gh issue #7672 -- check additional INSERTS after hitting ON CONFLICT clause still go through CREATE TABLE test_i7672(time timestamptz, device text, primary key(time,device)); SELECT create_hypertable('test_i7672', 'time'); ALTER TABLE test_i7672 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device'); INSERT INTO test_i7672 VALUES ('2025-01-01','d1'); SELECT count(*) FROM (SELECT compress_chunk(show_chunks('test_i7672'))) c; INSERT INTO test_i7672 VALUES ('2025-01-01','d1'), ('2025-01-01','d2') ON CONFLICT DO NOTHING; SELECT * FROM test_i7672 t ORDER BY t; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_constraints.sql�����������������������������������������0000664�0000000�0000000�00000032653�15100345067�0024155�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT create_hypertable('metrics','time'); ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); -- test all variations without data BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time); ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); ROLLBACK; -- test all variations with data but no conflict INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; \set ON_ERROR_STOP 0 BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ROLLBACK; BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ROLLBACK; BEGIN; CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); INSERT INTO metrics SELECT '2025-01-02', 'd1', 0.1; INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; ROLLBACK; \set ON_ERROR_STOP 0 -- test with conflict across uncompressed/compressed INSERT INTO metrics SELECT '2025-01-01', 'd1', 0.1; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); CREATE UNIQUE INDEX metrics_pk ON metrics(time); CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); \set ON_ERROR_STOP 1 -- test with conflict in compressed SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time); ALTER TABLE metrics ADD CONSTRAINT metrics_pk PRIMARY KEY(time, device); ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time); ALTER TABLE metrics ADD CONSTRAINT metrics_pk UNIQUE(time, device); CREATE UNIQUE INDEX metrics_pk ON metrics(time); CREATE UNIQUE INDEX metrics_pk ON metrics(time,device); \set ON_ERROR_STOP 1 DROP TABLE metrics; -- test NULL behaviour CREATE TABLE dist_null(time timestamptz not null, device text, value float); SELECT table_name FROM create_hypertable('dist_null','time',chunk_time_interval:='1 year'::interval); ALTER TABLE dist_null SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); -- test behaviour without compression BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; DROP INDEX dist_null_idx; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test behaviour with conflict in compressed BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; DROP INDEX dist_null_idx; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test behaviour with conflict between compressed/uncompressed BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; DROP INDEX dist_null_idx; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (full compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (full compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (partially compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test NULLs present but conflict in non-NULL tuples (partially compressed) BEGIN; INSERT INTO dist_null SELECT '2025-01-01', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', NULL, 0.1; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('dist_null') ch; INSERT INTO dist_null SELECT '2025-01-02', 'd', 0.1; \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX dist_null_idx ON dist_null(time,device) NULLS NOT DISTINCT; \set ON_ERROR_STOP 1 ROLLBACK; -- test foreign keys -- hypertable referencing plain table CREATE TABLE metrics(time timestamptz NOT NULL, device text, value float, PRIMARY KEY(device,time)); SELECT create_hypertable('metrics','time'); INSERT INTO metrics SELECT '2025-01-01','d1',0.1; INSERT INTO metrics SELECT '2025-01-01','d2',0.1; CREATE TABLE device(device TEXT PRIMARY KEY); INSERT INTO device SELECT 'd1'; CREATE TABLE events(time timestamptz, device text, data text); INSERT INTO events SELECT '2025-02-01', 'd1', ''; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); \set ON_ERROR_STOP 1 BEGIN; INSERT INTO device SELECT 'd2'; ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); INSERT INTO metrics SELECT '2025-03-01','d2',0.3; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-03-01','d3',0.3; \set ON_ERROR_STOP 1 ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-02-01','d1',0.1; ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); INSERT INTO events SELECT '2025-01-01','d1',''; \set ON_ERROR_STOP 0 INSERT INTO events SELECT '2025-03-01','d1',''; \set ON_ERROR_STOP 1 ROLLBACK; ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_orderby='device,time DESC', tsdb.compress_segmentby=''); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); \set ON_ERROR_STOP 1 BEGIN; INSERT INTO device SELECT 'd2'; ALTER TABLE metrics ADD CONSTRAINT device_fk FOREIGN KEY(device) REFERENCES device(device); INSERT INTO metrics SELECT '2025-03-01','d2',0.3; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-03-01','d3',0.3; \set ON_ERROR_STOP 1 ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-02-01','d1',0.1; ALTER TABLE events ADD CONSTRAINT events_fk FOREIGN KEY(device,time) REFERENCES metrics(device,time); INSERT INTO events SELECT '2025-01-01','d1',''; \set ON_ERROR_STOP 0 INSERT INTO events SELECT '2025-03-01','d1',''; \set ON_ERROR_STOP 1 ROLLBACK; DROP TABLE metrics CASCADE; DROP TABLE device CASCADE; DROP TABLE events CASCADE; -- test CHECK constraints CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT create_hypertable('metrics','time'); ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); INSERT INTO metrics SELECT '2025-01-01','d1',1; INSERT INTO metrics SELECT '2025-01-01','d1',NULL; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 9000); ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (time > '2026-01-01' AND value > 0); \set ON_ERROR_STOP 1 BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 0.9); ALTER TABLE metrics ADD CONSTRAINT metrics_check2 CHECK (time >= '2025-01-01' AND value > 0); INSERT INTO metrics SELECT '2025-01-01','d1',2; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',0; \set ON_ERROR_STOP 1 ROLLBACK; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 9000); ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (time > '2026-01-01' AND value > 0); \set ON_ERROR_STOP 1 BEGIN; ALTER TABLE metrics ADD CONSTRAINT metrics_check CHECK (value > 0.9); ALTER TABLE metrics ADD CONSTRAINT metrics_check2 CHECK (time >= '2025-01-01' AND value > 0); INSERT INTO metrics SELECT '2025-01-01','d1',2; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',0; \set ON_ERROR_STOP 1 ROLLBACK; DROP TABLE metrics CASCADE; -- test adding columns and constraints together CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT create_hypertable('metrics','time'); ALTER TABLE metrics SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); INSERT INTO metrics SELECT '2025-01-01','d1',1; -- should fail in validation since the new column will be NULL for existing tuples \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD COLUMN c1 int CHECK ( c1 IS NOT NULL ); \set ON_ERROR_STOP 1 BEGIN; -- should succeed since the CHECK constraint will succeed for NULL values ALTER TABLE metrics ADD COLUMN c1 int CHECK (c1 <> 42); INSERT INTO metrics SELECT '2025-01-01','d1',1,23; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',1,42; \set ON_ERROR_STOP 1 ROLLBACK; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; -- should fail in validation since the new column will be NULL for existing tuples \set ON_ERROR_STOP 0 ALTER TABLE metrics ADD COLUMN c1 int CHECK ( c1 IS NOT NULL ); \set ON_ERROR_STOP 1 BEGIN; -- should succeed since the CHECK constraint will succeed for NULL values ALTER TABLE metrics ADD COLUMN c1 int CHECK (c1 <> 42); INSERT INTO metrics SELECT '2025-01-01','d1',1,23; \set ON_ERROR_STOP 0 INSERT INTO metrics SELECT '2025-01-01','d1',1,42; \set ON_ERROR_STOP 1 ROLLBACK; -- test unique expression indexes BEGIN; -- should succeed since no conflict CREATE UNIQUE INDEX metrics_unique ON metrics(time, device, md5(value::text)); ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-01-01','d1',1; -- partially compressed chunk -- should fail because there is conflict \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX metrics_unique ON metrics(time, device, md5(value::text)); \set ON_ERROR_STOP 1 ROLLBACK; BEGIN; INSERT INTO metrics SELECT '2025-01-01','d1',1; SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; -- fully compressed chunk -- should fail because there is conflict \set ON_ERROR_STOP 0 CREATE UNIQUE INDEX metrics_unique ON metrics(time, device, md5(value::text)); \set ON_ERROR_STOP 1 ROLLBACK; �������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_create_compressed_table.sql�����������������������������0000664�0000000�0000000�00000003456�15100345067�0026443�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- create compressed hypertable CREATE TABLE "public"."metrics" ( "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ); SELECT create_hypertable('public.metrics', 'time'); ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); -- insert uncompressed row into hypertable INSERT INTO metrics (time, device_id, val) VALUES('2023-05-01T00:00:00Z'::timestamptz, 1, 1.0); SELECT count(*) FROM _timescaledb_internal._hyper_1_1_chunk; -- compress these rows, we do this to get compressed row data for the test SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); -- create custom compressed chunk table CREATE TABLE _timescaledb_internal.custom_compressed_chunk( LIKE _timescaledb_internal.compress_hyper_2_2_chunk); -- copy compressed row from compressed table into custom compressed chunk table INSERT INTO "_timescaledb_internal"."custom_compressed_chunk" SELECT * FROM "_timescaledb_internal"."compress_hyper_2_2_chunk"; -- decompress the rows, moving them back to uncompressed space SELECT decompress_chunk('"_timescaledb_internal"."_hyper_1_1_chunk"'); -- attach compressed chunk to parent chunk SELECT _timescaledb_functions.create_compressed_chunk( '"_timescaledb_internal"."_hyper_1_1_chunk"'::TEXT::REGCLASS, '"_timescaledb_internal"."custom_compressed_chunk"'::TEXT::REGCLASS, 8192, 8192, 16384, 8192, 8192, 16384, 1, 1 ); -- select total rows in chunk (should be 2) SELECT count(*) FROM "_timescaledb_internal"."_hyper_1_1_chunk"; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_ddl.sql�������������������������������������������������0000664�0000000�0000000�00000143561�15100345067�0022352�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/rand_generator.sql \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; SET client_min_messages = NOTICE; --test hypertable with tables space CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE2_PATH; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE TABLE test1 ("Time" timestamptz, i integer not null, b bigint, t text); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; VACUUM FULL ANALYZE test1; --make sure allowed ddl still work ALTER TABLE test1 CLUSTER ON "test1_Time_idx"; ALTER TABLE test1 SET WITHOUT CLUSTER; CREATE INDEX new_index ON test1(b); DROP INDEX new_index; ALTER TABLE test1 SET (fillfactor=100); ALTER TABLE test1 RESET (fillfactor); ALTER TABLE test1 ALTER COLUMN b SET STATISTICS 10; -- ensure that REPLICA IDENTITY works SELECT relreplident, count(*) FROM show_chunks('test1') ch INNER JOIN pg_class c ON (ch = c.oid) GROUP BY 1 ORDER BY 1; SELECT relreplident FROM pg_class c WHERE c.relname = 'test1'; ALTER TABLE test1 REPLICA IDENTITY FULL; SELECT relname, relreplident FROM pg_class WHERE relname = 'test1' ORDER BY relname; -- the chunk's setting should also change to FULL SELECT relreplident, count(*) FROM show_chunks('test1') ch INNER JOIN pg_class c ON (ch = c.oid) GROUP BY 1 ORDER BY 1; SELECT relreplident FROM pg_class c WHERE c.relname = 'test1'; ALTER TABLE test1 REPLICA IDENTITY DEFAULT; --test adding boolean columns with default and not null CREATE TABLE records (time timestamp NOT NULL); SELECT create_hypertable('records', 'time'); ALTER TABLE records SET (timescaledb.compress = true, timescaledb.compress_orderby='"time" DESC'); ALTER TABLE records ADD COLUMN col1 boolean DEFAULT false NOT NULL; -- NULL constraints are useless and it is safe allow adding this -- column with NULL constraint to a compressed hypertable (Issue #5151) ALTER TABLE records ADD COLUMN col2 BOOLEAN NULL; DROP table records CASCADE; -- TABLESPACES -- For tablepaces with compressed chunks the semantics are the following: -- - compressed chunks get put into the same tablespace as the -- uncompressed chunk on compression. -- - set tablespace on uncompressed hypertable cascades to compressed hypertable+chunks -- - set tablespace on all chunks is blocked (same as w/o compression) -- - move chunks on a uncompressed chunk errors -- - move chunks on compressed chunk works --In the future we will: -- - add tablespace option to compress_chunk function and policy (this will override the setting -- of the uncompressed chunk). This will allow changing tablespaces upon compression -- - Note: The current plan is to never listen to the setting on compressed hypertable. In fact, -- we will block setting tablespace on compressed hypertables SELECT count(*) as "COUNT_CHUNKS_UNCOMPRESSED" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' \gset SELECT count(*) as "COUNT_CHUNKS_COMPRESSED" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' \gset ALTER TABLE test1 SET TABLESPACE tablespace1; --all chunks + both the compressed and uncompressed hypertable moved to new tablespace SELECT count(*) = (:COUNT_CHUNKS_UNCOMPRESSED +:COUNT_CHUNKS_COMPRESSED + 2) FROM pg_tables WHERE tablespace = 'tablespace1'; ALTER TABLE test1 SET TABLESPACE tablespace2; SELECT count(*) = (:COUNT_CHUNKS_UNCOMPRESSED +:COUNT_CHUNKS_COMPRESSED + 2) FROM pg_tables WHERE tablespace = 'tablespace2'; SELECT comp_chunk.schema_name|| '.' || comp_chunk.table_name as "COMPRESSED_CHUNK_NAME", uncomp_chunk.schema_name|| '.' || uncomp_chunk.table_name as "UNCOMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk comp_chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (comp_chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) INNER JOIN _timescaledb_catalog.chunk uncomp_chunk ON (uncomp_chunk.compressed_chunk_id = comp_chunk.id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY comp_chunk.id LIMIT 1\gset -- ensure compression chunk cannot be moved directly SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; \set ON_ERROR_STOP 0 ALTER TABLE :COMPRESSED_CHUNK_NAME SET TABLESPACE tablespace1; \set ON_ERROR_STOP 1 SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; -- ensure that both compressed and uncompressed chunks moved ALTER TABLE :UNCOMPRESSED_CHUNK_NAME SET TABLESPACE tablespace1; SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; ALTER TABLE test1 SET TABLESPACE tablespace2; SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; \set ON_ERROR_STOP 0 SELECT move_chunk(chunk=>:'COMPRESSED_CHUNK_NAME', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal."compress_hyper_2_28_chunk_b__ts_meta_min_1__ts_meta_max_1_idx"'); \set ON_ERROR_STOP 1 -- ensure that both compressed and uncompressed chunks moved SELECT move_chunk(chunk=>:'UNCOMPRESSED_CHUNK_NAME', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal."_hyper_1_1_chunk_test1_Time_idx"'); SELECT tablename FROM pg_tables WHERE tablespace = 'tablespace1'; -- the compressed chunk is in here now SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; SELECT decompress_chunk(:'UNCOMPRESSED_CHUNK_NAME'); --the compresse chunk was dropped by decompression SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; SELECT move_chunk(chunk=>:'UNCOMPRESSED_CHUNK_NAME', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal."_hyper_1_1_chunk_test1_Time_idx"'); --the uncompressed chunks has now been moved SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; SELECT compress_chunk(:'UNCOMPRESSED_CHUNK_NAME'); --the compressed chunk is now in the same tablespace as the uncompressed one SELECT count(*) FROM pg_tables WHERE tablespace = 'tablespace1'; -- -- DROP CHUNKS -- SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset DROP TABLE :UNCOMPRESSED_CHUNK_NAME; --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; --make sure there are no orphaned _timescaledb_catalog.compression_chunk_size entries (should be 0) SELECT count(*) as orphaned_compression_chunk_size FROM _timescaledb_catalog.compression_chunk_size size LEFT JOIN _timescaledb_catalog.chunk chunk ON (chunk.id = size.chunk_id) WHERE chunk.id IS NULL; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; SELECT drop_chunks('test1', older_than => '2018-03-10'::TIMESTAMPTZ); --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset SELECT chunk.schema_name|| '.' || chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset \set ON_ERROR_STOP 0 DROP TABLE :COMPRESSED_CHUNK_NAME; SELECT _timescaledb_functions.drop_chunk(:'COMPRESSED_CHUNK_NAME'); \set ON_ERROR_STOP 1 SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME", comp_chunk.schema_name|| '.' || comp_chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.chunk comp_chunk ON (chunk.compressed_chunk_id = comp_chunk.id) INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset --create a dependent object on the compressed chunk to test cascade behaviour CREATE VIEW dependent_1 AS SELECT * FROM :COMPRESSED_CHUNK_NAME; \set ON_ERROR_STOP 0 --errors due to dependent objects DROP TABLE :UNCOMPRESSED_CHUNK_NAME; \set ON_ERROR_STOP 1 DROP TABLE :UNCOMPRESSED_CHUNK_NAME CASCADE; --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; SELECT chunk.schema_name|| '.' || chunk.table_name as "UNCOMPRESSED_CHUNK_NAME", comp_chunk.schema_name|| '.' || comp_chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.chunk comp_chunk ON (chunk.compressed_chunk_id = comp_chunk.id) INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset CREATE VIEW dependent_1 AS SELECT * FROM :COMPRESSED_CHUNK_NAME; \set ON_ERROR_STOP 0 \set VERBOSITY default --errors due to dependent objects SELECT drop_chunks('test1', older_than => '2018-03-28'::TIMESTAMPTZ); \set VERBOSITY terse \set ON_ERROR_STOP 1 DROP VIEW dependent_1; SELECT drop_chunks('test1', older_than => '2018-03-28'::TIMESTAMPTZ); --should decrease #chunks both compressed and decompressed SELECT count(*) as count_chunks_uncompressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable hypertable ON (chunk.hypertable_id = hypertable.id) WHERE hypertable.table_name like 'test1'; SELECT count(*) as count_chunks_compressed FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1'; --make sure there are no orphaned _timescaledb_catalog.compression_chunk_size entries (should be 0) SELECT count(*) as orphaned_compression_chunk_size FROM _timescaledb_catalog.compression_chunk_size size LEFT JOIN _timescaledb_catalog.chunk chunk ON (chunk.id = size.chunk_id) WHERE chunk.id IS NULL; -- -- DROP HYPERTABLE -- SELECT comp_hyper.schema_name|| '.' || comp_hyper.table_name as "COMPRESSED_HYPER_NAME" FROM _timescaledb_catalog.hypertable comp_hyper INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY comp_hyper.id LIMIT 1 \gset \set ON_ERROR_STOP 0 DROP TABLE :COMPRESSED_HYPER_NAME; \set ON_ERROR_STOP 1 BEGIN; SELECT hypertable.schema_name|| '.' || hypertable.table_name as "UNCOMPRESSED_HYPER_NAME" FROM _timescaledb_catalog.hypertable hypertable WHERE hypertable.table_name like 'test1' ORDER BY hypertable.id LIMIT 1 \gset --before the drop there are 2 hypertables: the compressed and uncompressed ones SELECT count(*) FROM _timescaledb_catalog.hypertable hypertable; --add policy to make sure it's dropped later select add_compression_policy(:'UNCOMPRESSED_HYPER_NAME', interval '1 day'); SELECT count(*) FROM _timescaledb_config.bgw_job WHERE id >= 1000; DROP TABLE :UNCOMPRESSED_HYPER_NAME; --verify that there are no more hypertable remaining SELECT count(*) FROM _timescaledb_catalog.hypertable hypertable; --verify that the policy is gone SELECT count(*) FROM _timescaledb_config.bgw_job WHERE id >= 1000; ROLLBACK; --create a dependent object on the compressed hypertable to test cascade behaviour CREATE VIEW dependent_1 AS SELECT * FROM :COMPRESSED_HYPER_NAME; \set ON_ERROR_STOP 0 DROP TABLE :UNCOMPRESSED_HYPER_NAME; \set ON_ERROR_STOP 1 BEGIN; DROP TABLE :UNCOMPRESSED_HYPER_NAME CASCADE; SELECT count(*) FROM _timescaledb_catalog.hypertable hypertable; ROLLBACK; DROP VIEW dependent_1; --create a cont agg view on the ht as well then the drop should nuke everything CREATE MATERIALIZED VIEW test1_cont_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', "Time"), SUM(i) FROM test1 GROUP BY 1 WITH NO DATA; SELECT add_continuous_aggregate_policy('test1_cont_view', NULL, '1 hour'::interval, '1 day'::interval); CALL refresh_continuous_aggregate('test1_cont_view', NULL, NULL); SELECT count(*) FROM test1_cont_view; \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO 'America/Los_Angeles'; SELECT chunk.schema_name|| '.' || chunk.table_name as "COMPRESSED_CHUNK_NAME" FROM _timescaledb_catalog.chunk chunk INNER JOIN _timescaledb_catalog.hypertable comp_hyper ON (chunk.hypertable_id = comp_hyper.id) INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'test1' ORDER BY chunk.id LIMIT 1 \gset ALTER TABLE test1 OWNER TO :ROLE_DEFAULT_PERM_USER_2; --make sure new owner is propagated down SELECT a.rolname from pg_class c INNER JOIN pg_authid a ON(c.relowner = a.oid) WHERE c.oid = 'test1'::regclass; SELECT a.rolname from pg_class c INNER JOIN pg_authid a ON(c.relowner = a.oid) WHERE c.oid = :'COMPRESSED_HYPER_NAME'::regclass; SELECT a.rolname from pg_class c INNER JOIN pg_authid a ON(c.relowner = a.oid) WHERE c.oid = :'COMPRESSED_CHUNK_NAME'::regclass; -- -- turn off compression -- SELECT count(decompress_chunk(ch)) FROM show_chunks('test1') ch; VACUUM FULL ANALYZE test1; select add_compression_policy('test1', interval '1 day'); \set ON_ERROR_STOP 0 ALTER table test1 set (timescaledb.compress='f'); \set ON_ERROR_STOP 1 select remove_compression_policy('test1'); ALTER table test1 set (timescaledb.compress='f'); --only one hypertable left SELECT count(*) = 1 FROM _timescaledb_catalog.hypertable hypertable; SELECT compressed_hypertable_id IS NULL FROM _timescaledb_catalog.hypertable hypertable WHERE hypertable.table_name like 'test1' ; --make sure there are no orphaned _timescaledb_catalog.compression_chunk_size entries (should be 0) SELECT count(*) as orphaned_compression_chunk_size FROM _timescaledb_catalog.compression_chunk_size size LEFT JOIN _timescaledb_catalog.chunk chunk ON (chunk.id = size.chunk_id) WHERE chunk.id IS NULL; --can turn compression back on -- this will fail because current table owner does not have permission to create compressed hypertable -- in the current tablespace, as they do not own it \set ON_ERROR_STOP 0 ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = '"Time" DESC'); -- now change the owner and repeat, should work ALTER TABLESPACE tablespace2 OWNER TO :ROLE_DEFAULT_PERM_USER_2; \set ON_ERROR_STOP 1 ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; VACUUM FULL ANALYZE test1; DROP TABLE test1 CASCADE; DROP TABLESPACE tablespace1; -- Triggers are NOT fired for compress/decompress CREATE TABLE test1 ("Time" timestamptz, i integer); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); CREATE OR REPLACE FUNCTION test1_print_func() RETURNS TRIGGER LANGUAGE PLPGSQL AS $BODY$ BEGIN RAISE NOTICE ' raise notice test1_print_trigger called '; RETURN OLD; END; $BODY$; CREATE TRIGGER test1_trigger BEFORE INSERT OR UPDATE OR DELETE OR TRUNCATE ON test1 FOR EACH STATEMENT EXECUTE FUNCTION test1_print_func(); INSERT INTO test1 SELECT generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 1:00', '1 hour') , 1 ; -- add a row trigger too -- CREATE TRIGGER test1_trigger2 BEFORE INSERT OR UPDATE OR DELETE ON test1 FOR EACH ROW EXECUTE FUNCTION test1_print_func(); INSERT INTO test1 SELECT '2018-03-02 1:05'::TIMESTAMPTZ, 2; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; SELECT count(decompress_chunk(ch)) FROM show_chunks('test1') ch; DROP TABLE test1; -- test disabling compression on hypertables with caggs and dropped chunks -- github issue 2844 CREATE TABLE i2844 (created_at timestamptz NOT NULL,c1 float); SELECT create_hypertable('i2844', 'created_at', chunk_time_interval => '6 hour'::interval); INSERT INTO i2844 SELECT generate_series('2000-01-01'::timestamptz, '2000-01-02'::timestamptz,'1h'::interval); CREATE MATERIALIZED VIEW test_agg WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', created_at) AS bucket, AVG(c1) AS avg_c1 FROM i2844 GROUP BY bucket; ALTER TABLE i2844 SET (timescaledb.compress, timescaledb.compress_orderby = 'created_at DESC'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='i2844'::regclass; SELECT compress_chunk(show_chunks) AS compressed_chunk FROM show_chunks('i2844'); SELECT drop_chunks('i2844', older_than => '2000-01-01 18:00'::timestamptz); SELECT decompress_chunk(show_chunks, if_compressed => TRUE) AS decompressed_chunks FROM show_chunks('i2844'); ALTER TABLE i2844 SET (timescaledb.compress = FALSE); -- TEST compression alter schema tests \ir include/compression_alter.sql --TEST tablespaces for compressed chunks with attach_tablespace interface -- CREATE TABLE test2 (timec timestamptz, i integer, t integer); SELECT table_name from create_hypertable('test2', 'timec', chunk_time_interval=> INTERVAL '1 day'); SELECT attach_tablespace('tablespace2', 'test2'); INSERT INTO test2 SELECT t, gen_rand_minstd(), 22 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 13:00', '1 hour') t; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = 'i', timescaledb.compress_orderby = 'timec'); -- the toast table and its index will have a different name depending on -- the order the tests run, so anonymize it SELECT regexp_replace(relname, 'pg_toast_[0-9]+', 'pg_toast_XXX') FROM pg_class WHERE reltablespace in ( SELECT oid from pg_tablespace WHERE spcname = 'tablespace2') ORDER BY 1; -- test compress_chunk() with utility statement (SELECT ... INTO) SELECT compress_chunk(ch) INTO compressed_chunks FROM show_chunks('test2') ch; SELECT decompress_chunk(ch) INTO decompressed_chunks FROM show_chunks('test2') ch; -- compress again SELECT compress_chunk(ch) FROM show_chunks('test2') ch; -- the chunk, compressed chunk + index + toast tables are in tablespace2 now . -- toast table names differ across runs. So we use count to verify the results -- instead of printing the table/index names SELECT count(*) FROM ( SELECT relname FROM pg_class WHERE reltablespace in ( SELECT oid from pg_tablespace WHERE spcname = 'tablespace2'))q; DROP TABLE test2 CASCADE; DROP TABLESPACE tablespace2; -- Create a table with a compressed table and then delete the -- compressed table and see that the drop of the hypertable does not -- generate an error. This scenario can be triggered if an extension -- is created with compressed hypertables since the tables are dropped -- as part of the drop of the extension. CREATE TABLE issue4140("time" timestamptz NOT NULL, device_id int); SELECT create_hypertable('issue4140', 'time'); ALTER TABLE issue4140 SET(timescaledb.compress); SELECT format('%I.%I', schema_name, table_name)::regclass AS ctable FROM _timescaledb_catalog.hypertable WHERE id = (SELECT compressed_hypertable_id FROM _timescaledb_catalog.hypertable WHERE table_name = 'issue4140') \gset SELECT timescaledb_pre_restore(); DROP TABLE :ctable; SELECT timescaledb_post_restore(); DROP TABLE issue4140; -- github issue 5104 CREATE TABLE metric( time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL); SELECT create_hypertable('metric', 'time', chunk_time_interval => interval '1 h', create_default_indexes => false); -- enable compression ALTER TABLE metric set(timescaledb.compress, timescaledb.compress_segmentby = 'series_id, value', timescaledb.compress_orderby = 'time' ); SELECT comp_hypertable.schema_name AS "COMP_SCHEMA_NAME", comp_hypertable.table_name AS "COMP_TABLE_NAME" FROM _timescaledb_catalog.hypertable uc_hypertable INNER JOIN _timescaledb_catalog.hypertable comp_hypertable ON (comp_hypertable.id = uc_hypertable.compressed_hypertable_id) WHERE uc_hypertable.table_name like 'metric' \gset -- get definition of compressed hypertable and notice the index \d :COMP_SCHEMA_NAME.:COMP_TABLE_NAME -- #5290 Compression can't be enabled on caggs CREATE TABLE "tEst2" ( "Id" uuid NOT NULL, "Time" timestamp with time zone NOT NULL, CONSTRAINT "test2_pkey" PRIMARY KEY ("Id", "Time") ); SELECT create_hypertable( '"tEst2"', 'Time', chunk_time_interval => INTERVAL '1 day' ); alter table "tEst2" set (timescaledb.compress=true, timescaledb.compress_segmentby='"Id"'); CREATE MATERIALIZED VIEW "tEst2_mv" WITH (timescaledb.continuous) AS SELECT "Id" as "Idd", time_bucket(INTERVAL '1 day', "Time") AS "bUcket" FROM public."tEst2" GROUP BY "Idd", "bUcket"; ALTER MATERIALIZED VIEW "tEst2_mv" SET (timescaledb.compress = true); -- #5161 segmentby param CREATE MATERIALIZED VIEW test1_cont_view2 WITH (timescaledb.continuous, timescaledb.materialized_only=true ) AS SELECT time_bucket('1 hour', "Time") as t, SUM(intcol) as sum,txtcol as "iDeA" FROM test1 GROUP BY 1,txtcol WITH NO DATA; \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true, timescaledb.compress_segmentby = 'invalid_column' ); \set ON_ERROR_STOP 1 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true ); ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true, timescaledb.compress_segmentby = '"iDeA"' ); \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = true, timescaledb.compress_orderby = '"iDeA"' ); \set ON_ERROR_STOP 1 ALTER MATERIALIZED VIEW test1_cont_view2 SET ( timescaledb.compress = false ); DROP TABLE metric CASCADE; -- inserting into compressed chunks with different physical layouts CREATE TABLE compression_insert(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON compression_insert(time); CREATE INDEX ON compression_insert(device_id,time); SELECT create_hypertable('compression_insert','time',create_default_indexes:=false); ALTER TABLE compression_insert SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); -- test without altering physical layout -- this is a baseline test to compare results with -- next series of tests which should yield identical results -- while changing the physical layouts of chunks INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-03 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(ch, true) AS "CHUNK_NAME" FROM show_chunks('compression_insert') ch ORDER BY ch DESC \gset INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-04 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-01 0:00:00+0' AND time <= '2000-01-05 23:55:00+0'; VACUUM ANALYZE compression_insert; -- force index scans to check index mapping -- this verifies that we are actually using compressed chunk index scans -- previously we could not use indexes on uncompressed chunks due to a bug: -- https://github.com/timescale/timescaledb/issues/5432 -- -- this check basically makes sure that the indexes are built properly -- and there are no issues in attribute mappings while building them SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT compress_chunk(:'CHUNK_NAME'::regclass); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-01 0:00:00+0' AND time <= '2000-01-05 23:55:00+0'; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SET enable_seqscan = default; -- 1. drop column after first insert into chunk, before compressing INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-07 0:00:00+0'::timestamptz,'2000-01-09 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE compression_insert DROP COLUMN filler_1; SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-10 0:00:00+0'::timestamptz,'2000-01-11 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-07 0:00:00+0' AND time <= '2000-01-11 23:55:00+0'; VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT compress_chunk(:'CHUNK_NAME'::regclass); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-07 0:00:00+0' AND time <= '2000-01-11 23:55:00+0'; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SET enable_seqscan = default; -- 2. drop column after compressing chunk INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-15 0:00:00+0'::timestamptz,'2000-01-17 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset ALTER TABLE compression_insert DROP COLUMN filler_2; INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-18 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-15 0:00:00+0' AND time <= '2000-01-19 23:55:00+0'; VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT compress_chunk(:'CHUNK_NAME'::regclass); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-15 0:00:00+0' AND time <= '2000-01-19 23:55:00+0'; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SET enable_seqscan = default; -- 3. add new column after first insert into chunk, before compressing INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-22 0:00:00+0'::timestamptz,'2000-01-24 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE compression_insert ADD COLUMN filler_4 int; SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-25 0:00:00+0'::timestamptz,'2000-01-26 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-22 0:00:00+0' AND time <= '2000-01-26 23:55:00+0'; VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT compress_chunk(:'CHUNK_NAME'::regclass); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-22 0:00:00+0' AND time <= '2000-01-26 23:55:00+0'; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SET enable_seqscan = default; -- 4. add new column after compressing chunk INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-28 0:00:00+0'::timestamptz,'2000-01-30 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_insert' AND NOT is_compressed ORDER BY chunk_name DESC \gset ALTER TABLE compression_insert ADD COLUMN filler_5 int; INSERT INTO compression_insert(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-31 0:00:00+0'::timestamptz,'2000-02-01 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-28 0:00:00+0' AND time <= '2000-02-01 23:55:00+0'; VACUUM ANALYZE compression_insert; -- force index scans to check index mapping SET enable_seqscan = off; EXPLAIN (buffers off, costs off) SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SELECT compress_chunk(:'CHUNK_NAME'::regclass); SELECT count(*), sum(v0), sum(v1), sum(v2), sum(v3) FROM compression_insert WHERE time >= '2000-01-28 0:00:00+0' AND time <= '2000-02-01 23:55:00+0'; SELECT device_id, count(*) FROM compression_insert GROUP BY device_id ORDER BY device_id; SET enable_seqscan = default; DROP TABLE compression_insert; -- check Chunk Append plans for partially compressed chunks -- F: fully compressed, P : partially compressed, U: uncompressed CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), ('2020-01-01 00:05'::timestamptz, 3, 1), ('2020-01-01 00:06'::timestamptz, 3, 2), ('2020-01-01 00:07'::timestamptz, 3, 3), ('2020-01-01 00:08'::timestamptz, 4, 1), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), ('2021-01-01 00:05'::timestamptz, 3, 1), ('2021-01-01 00:06'::timestamptz, 3, 2), ('2021-01-01 00:07'::timestamptz, 3, 3), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2), ('2022-01-01 00:05'::timestamptz, 3, 1); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress, timescaledb.compress_segmentby = 'a', timescaledb.compress_orderby = 'time desc'); SELECT compress_chunk(show_chunks('test_partials')); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- test P, F, F INSERT INTO test_partials VALUES ('2020-01-01 00:03', 1, 2); vacuum analyze test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- verify correct results SELECT * FROM test_partials ORDER BY time; -- make second chunk partially compressed -- P, P, F INSERT INTO test_partials VALUES ('2021-01-01 00:03', 1, 2); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- verify correct results SELECT * FROM test_partials ORDER BY time; -- third chunk partially compressed and add new chunk -- P, P, P, U INSERT INTO test_partials VALUES ('2022-01-01 00:03', 1, 2); INSERT INTO test_partials VALUES ('2023-01-01 00:03', 1, 2); INSERT INTO test_partials VALUES ('2023-01-01 00:05', 3, 1); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- F, F, P, U -- recompress all chunks DO $$ DECLARE chunk regclass; BEGIN FOR chunk IN SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk WHERE status = 9 and compressed_chunk_id IS NOT NULL AND NOT dropped ORDER BY id LOOP EXECUTE format('select decompress_chunk(''%s'');', chunk::text); EXECUTE format('select compress_chunk(''%s'');', chunk::text); END LOOP; END $$; INSERT INTO test_partials VALUES ('2022-01-01 00:02', 1, 2); VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM test_partials ORDER BY time; -- F, F, P, F, F INSERT INTO test_partials VALUES ('2024-01-01 00:02', 1, 2); SELECT compress_chunk(c) FROM show_chunks('test_partials', newer_than => '2022-01-01') c; VACUUM ANALYZE test_partials; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- verify result correctness SELECT * FROM test_partials ORDER BY time; -- Chunks must be different size for plan stability select count(*) from test_partials group by tableoid order by count(*) desc; -- add test for space partioning with partial chunks CREATE TABLE space_part (time timestamptz, a int, b int, c int); SELECT create_hypertable('space_part', 'time', chunk_time_interval => INTERVAL '1 day'); INSERT INTO space_part VALUES -- chunk1 ('2020-01-01 00:00', 1, 1, 1), ('2020-01-01 00:00', 2, 1, 1), ('2020-01-01 00:03', 1, 1, 1), ('2020-01-01 00:03', 2, 1, 1); INSERT INTO space_part values -- chunk2 ('2021-01-01 00:00', 1, 1, 1), ('2021-01-01 00:00', 2, 1, 1), ('2021-01-01 00:03', 1, 1, 1), ('2021-01-01 00:03', 2, 1, 1); -- compress them ALTER TABLE space_part SET (timescaledb.compress, timescaledb.orderby='"time" desc'); SELECT compress_chunk(show_chunks('space_part')); -- make first chunk partial INSERT INTO space_part VALUES -- chunk1 ('2020-01-01 00:01', 1, 1, 1), ('2020-01-01 00:01', 2, 1, 1); VACUUM ANALYZE space_part; -------- now enable the space partitioning, this will take effect for chunks created subsequently SELECT add_dimension('space_part', 'a', number_partitions => 5); -- plan is still the same EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; -- now add more chunks that do adhere to the new space partitioning -- chunks 3,4 INSERT INTO space_part VALUES ('2022-01-01 00:00', 1, 1, 1), ('2022-01-01 00:00', 2, 1, 1), ('2022-01-01 00:03', 1, 1, 1), ('2022-01-01 00:03', 2, 1, 1); VACUUM ANALYZE space_part; -- plan still ok EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; -- compress them SELECT compress_chunk(c, if_not_compressed=>true) FROM show_chunks('space_part') c; VACUUM ANALYZE space_part; -- plan still ok EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; -- make second one of them partial insert into space_part values ('2022-01-01 00:02', 2, 1, 1), ('2022-01-01 00:02', 2, 1, 1); VACUUM ANALYZE space_part; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; -- make other one partial too INSERT INTO space_part VALUES ('2022-01-01 00:02', 1, 1, 1); VACUUM ANALYZE space_part; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM space_part ORDER BY time; -- test creation of unique expression index does not interfere with enabling compression -- github issue 6205 create table mytab (col1 varchar(100) not null, col2 integer not null, value double precision not null default 0, arrival_ts timestamptz not null, departure_ts timestamptz not null default current_timestamp); select create_hypertable('mytab', 'departure_ts'); create unique index myidx_unique ON mytab (lower(col1::text), col2, departure_ts, arrival_ts); alter table mytab set (timescaledb.compress); -- github issue 6186 -- verify inserting into index works as expected during decompression insert into mytab (col1, col2, value, arrival_ts, departure_ts) values ('meter1', 1, 2.3, '2022-01-01'::timestamptz, '2022-01-01'::timestamptz), ('meTEr1', 2, 2.5, '2022-01-01'::timestamptz, '2022-01-01'::timestamptz), ('METEr1', 1, 2.9, '2022-01-01'::timestamptz, '2022-01-01 01:00'::timestamptz); select compress_chunk(show_chunks('mytab')); REINDEX TABLE mytab; -- should update index select decompress_chunk(show_chunks('mytab')); vacuum analyze mytab; \set EXPLAIN 'EXPLAIN (buffers off, costs off,timing off,summary off)' \set EXPLAIN_ANALYZE 'EXPLAIN (analyze,buffers off, costs off,timing off,summary off)' -- do index scan on uncompressed, should give correct results set enable_seqscan = off; set enable_indexscan = on; :EXPLAIN_ANALYZE select * from mytab where lower(col1::text) = 'meter1'; select * from mytab where lower(col1::text) = 'meter1'; -- check predicate index CREATE INDEX myidx_partial ON mytab (value) WHERE (value > 2.4 AND value < 3); select compress_chunk(show_chunks('mytab')); select decompress_chunk(show_chunks('mytab')); :EXPLAIN_ANALYZE SELECT * FROM mytab WHERE value BETWEEN 2.4 AND 2.8; -- check exclusion constraint with index - should not be supported CREATE TABLE hyper_ex ( time timestamptz, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1, canceled boolean DEFAULT false, EXCLUDE USING btree ( time WITH =, device_id WITH = ) WHERE (not canceled) ); SELECT * FROM create_hypertable('hyper_ex', 'time', chunk_time_interval=> interval '1 month'); INSERT INTO hyper_ex(time, device_id,sensor_1) VALUES ('2022-01-01', 'dev2', 11), ('2022-01-01 01:00', 'dev2', 12); \set ON_ERROR_STOP 0 ALTER TABLE hyper_ex SET (timescaledb.compress, timescaledb.compress_segmentby='device_id'); \set ON_ERROR_STOP 1 -- check deferred uniqueness CREATE TABLE hyper_unique_deferred ( time BIGINT UNIQUE DEFERRABLE INITIALLY DEFERRED, device_id TEXT NOT NULL, sensor_1 NUMERIC NULL DEFAULT 1 CHECK (sensor_1 > 10) ); SELECT * FROM create_hypertable('hyper_unique_deferred', 'time', chunk_time_interval => 10); INSERT INTO hyper_unique_deferred(time, device_id,sensor_1) VALUES (1257987700000000000, 'dev2', 11); alter table hyper_unique_deferred set (timescaledb.compress); select compress_chunk(show_chunks('hyper_unique_deferred')); -- also worked fine before 2.11.0 select decompress_chunk(show_chunks('hyper_unique_deferred')); \set ON_ERROR_STOP 0 begin; insert INTO hyper_unique_deferred values (1257987700000000000, 'dev1', 1); abort; \set ON_ERROR_STOP 1 select compress_chunk(show_chunks('hyper_unique_deferred')); \set ON_ERROR_STOP 0 begin; insert INTO hyper_unique_deferred values (1257987700000000000, 'dev1', 1); abort; \set ON_ERROR_STOP 1 -- tests chunks being compressed using different segmentby settings -- github issue #7102 CREATE TABLE compression_drop(time timestamptz NOT NULL, v0 int, v1 int); CREATE INDEX ON compression_drop(time); CREATE INDEX ON compression_drop(v0,time); SELECT create_hypertable('compression_drop','time',create_default_indexes:=false); ALTER TABLE compression_drop SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='v0'); -- insert data and compress chunk INSERT INTO compression_drop(time, v0, v1) SELECT time, v0, v0+1 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-03 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gv0(v0); SELECT compress_chunk(ch, true) AS "CHUNK_NAME" FROM show_chunks('compression_drop') ch ORDER BY ch DESC \gset -- change segmentby column ALTER TABLE compression_drop SET (timescaledb.compress_segmentby='v1'); -- insert more data and compress next chunk INSERT INTO compression_drop(time, v0, v1) SELECT time, v0, v0+1 FROM generate_series('2000-01-07 0:00:00+0'::timestamptz,'2000-01-09 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gv0(v0); SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name)) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'compression_drop' AND NOT is_compressed; -- try dropping column v0, should fail \set ON_ERROR_STOP 0 ALTER TABLE compression_drop DROP COLUMN v0; \set ON_ERROR_STOP 1 DROP TABLE compression_drop; SET client_min_messages = ERROR; CREATE TABLE test2 (ts timestamptz, i integer not null, b bigint, t text); SELECT table_name from create_hypertable('test2', 'ts', chunk_time_interval=> INTERVAL '1 day'); INSERT INTO test2 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'ts DESC' ); \set ON_ERROR_STOP 0 INSERT INTO test2(ts,b,t) VALUES ('2024-11-18 18:04:51',99,'magic'); \set ON_ERROR_STOP 1 ALTER TABLE test2 ALTER COLUMN i DROP NOT NULL; INSERT INTO test2(ts,b,t) VALUES ('2024-11-18 18:04:51',99,'magic'); SELECT count(*) FROM test2 WHERE i IS NULL; SELECT count(compress_chunk(ch)) FROM show_chunks('test2') ch; SELECT count(*) FROM test2 WHERE i IS NULL; SELECT count(decompress_chunk(ch)) FROM show_chunks('test2') ch; SELECT count(*) FROM test2 WHERE i IS NULL; SELECT count(compress_chunk(ch)) FROM show_chunks('test2') ch; SELECT count(*) FROM test2 WHERE i IS NULL; \set ON_ERROR_STOP 0 ALTER TABLE test2 ALTER COLUMN i SET NOT NULL; DELETE FROM test2 WHERE i IS NULL; SELECT count(*) FROM test2 WHERE i IS NULL; ALTER TABLE test2 ALTER COLUMN i SET NOT NULL; \set ON_ERROR_STOP 1 -- test set not null CREATE TABLE test_notnull(time timestamptz, device text, value float); SELECT create_hypertable('test_notnull','time'); ALTER TABLE test_notnull SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO test_notnull VALUES ('2025-01-01','d1',NULL); INSERT INTO test_notnull VALUES ('2025-01-01',NULL,NULL); -- should fail since we have NULL value \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; \set ON_ERROR_STOP 1 SELECT compress_chunk(show_chunks('test_notnull')); -- should fail since we have NULL value \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; \set ON_ERROR_STOP 1 UPDATE test_notnull SET value = 1; ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN value DROP NOT NULL; SELECT compress_chunk(show_chunks('test_notnull')); ALTER TABLE test_notnull ALTER COLUMN value SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN value DROP NOT NULL; -- device still has NULL \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; \set ON_ERROR_STOP 1 UPDATE test_notnull SET device = 'd1'; ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN device DROP NOT NULL; SELECT compress_chunk(show_chunks('test_notnull')); ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN device DROP NOT NULL; -- test partial compressed chunks -- NULL in uncompressed part only INSERT INTO test_notnull VALUES ('2025-01-01',NULL,NULL); \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; \set ON_ERROR_STOP 1 -- NULL in compressed part only SELECT compress_chunk(show_chunks('test_notnull')); INSERT INTO test_notnull VALUES ('2025-01-01','d1',2); \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN device SET NOT NULL; \set ON_ERROR_STOP 1 -- test added columns and defaults ALTER TABLE test_notnull ADD COLUMN c1 int; \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN c1 SET NOT NULL; \set ON_ERROR_STOP 1 ALTER TABLE test_notnull ADD COLUMN c2 int DEFAULT 42; ALTER TABLE test_notnull ALTER COLUMN c2 SET NOT NULL; ALTER TABLE test_notnull ALTER COLUMN c2 DROP NOT NULL; -- test column with default and explicit NULL UPDATE test_notnull SET c2 = NULL; \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN c2 SET NOT NULL; \set ON_ERROR_STOP 1 SELECT compress_chunk(show_chunks('test_notnull')); \set ON_ERROR_STOP 0 ALTER TABLE test_notnull ALTER COLUMN c2 SET NOT NULL; \set ON_ERROR_STOP 1 -- test alias in parameter name CREATE TABLE alias(time timestamptz NOT NULL); SELECT create_hypertable('alias','time'); ALTER TABLE alias SET (tsdb.compress, tsdb.compress_orderby='time DESC',tsdb.compress_segmentby=''); INSERT INTO alias SELECT '2025-01-01'; SELECT count(compress_chunk(ch)) FROM show_chunks('alias') ch; -- test mixing postgres and timescaledb options CREATE TABLE mix_pg_ts(time timestamptz, device text) WITH (tsdb.hypertable,tsdb.partition_column='time',fillfactor=90); SELECT reloptions FROM pg_class WHERE relname='mix_pg_ts'; SELECT * FROM timescaledb_information.hypertable_compression_settings WHERE hypertable='mix_pg_ts'::regclass; ALTER TABLE mix_pg_ts SET (timescaledb.compress, fillfactor=70, tsdb.orderby='time', timescaledb.compress_segmentby='device', autovacuum_enabled=true); SELECT reloptions FROM pg_class WHERE relname='mix_pg_ts'; SELECT * FROM timescaledb_information.hypertable_compression_settings WHERE hypertable='mix_pg_ts'::regclass; -- test resetting options ALTER TABLE mix_pg_ts RESET (fillfactor, tsdb.segmentby); SELECT reloptions FROM pg_class WHERE relname='mix_pg_ts'; SELECT * FROM timescaledb_information.hypertable_compression_settings WHERE hypertable='mix_pg_ts'::regclass; �����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_defaults.sql��������������������������������������������0000664�0000000�0000000�00000037011�15100345067�0023406�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE VIEW chunk_settings AS SELECT hypertable, count(*) as chunks, segmentby, orderby, index FROM timescaledb_information.chunk_compression_settings cs group by hypertable,segmentby,orderby, index ORDER BY 1,2,3,4,5; -- statitics on CREATE TABLE "public"."metrics" ( "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); insert into metrics SELECT t, 1, extract(epoch from t) from generate_series ( '2007-02-01'::timestamp , '2007-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 2, extract(epoch from t) from generate_series ( '2007-06-01'::timestamp , '2007-10-01'::timestamp , '1 day'::interval) t; ANALYZE metrics; --use the best-scenario unique index CREATE UNIQUE INDEX test_idx ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']); ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_segmentby = 'device_id'); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); --make sure all the GUC combinations work SET timescaledb.compression_segmentby_default_function = ''; SET timescaledb.compression_orderby_default_function = ''; ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_orderby = '"time" desc', timescaledb.compress_segmentby = ''); SELECT * FROM _timescaledb_catalog.compression_settings; ALTER TABLE metrics SET (timescaledb.compress = false); SET timescaledb.compression_segmentby_default_function = ''; RESET timescaledb.compression_orderby_default_function; ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); RESET timescaledb.compression_segmentby_default_function; SET timescaledb.compression_orderby_default_function = ''; ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); RESET timescaledb.compression_segmentby_default_function; RESET timescaledb.compression_orderby_default_function; --opposite order of columns drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(time, device_id); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']); --use a high-cardinality column in the index drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); --use a non-unique index drop index test_idx; CREATE INDEX test_idx ON metrics(device_id, time, val); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); --another non-unique index column order drop index test_idx; CREATE INDEX test_idx ON metrics(val, device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); --use a high-cardinality column in the non-unque index drop index test_idx; CREATE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); --use 2 indexes drop index test_idx; CREATE INDEX test_idx1 ON metrics(val, time); CREATE INDEX test_idx2 ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); --no indexes drop index test_idx1; drop index test_idx2; SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); -- tables with no stats -- drop table metrics; --serial case CREATE TABLE "public"."metrics" ( id serial NOT NULL, "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); --no indexes SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); --minimum index CREATE UNIQUE INDEX test_idx ON metrics(id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --index with device_id drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(device_id, id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --two indexes drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(id, time); CREATE INDEX test_idx2 ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --separate indexes drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(id); CREATE INDEX test_idx2 ON metrics(time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --make sure generated identity also works drop table metrics; CREATE TABLE "public"."metrics" ( id int GENERATED ALWAYS AS IDENTITY, "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); --minimum index CREATE UNIQUE INDEX test_idx ON metrics(id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --index with device_id drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(device_id, id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --test default indexes drop table metrics; CREATE TABLE "public"."metrics" ( id int GENERATED ALWAYS AS IDENTITY, "time" timestamp with time zone NOT NULL, "device_id" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>true); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY[]::text[]); CREATE INDEX test_idx ON metrics(device_id); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']); drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); SELECT _timescaledb_functions.get_orderby_defaults('public.metrics', ARRAY['device_id']::text[]); --test table with skewed statistics drop table metrics; CREATE TABLE "public"."metrics" ( "time" timestamp with time zone NOT NULL, "device_id" "text", "device_id2" "text", "val" double precision ) WITH (autovacuum_enabled=0); SELECT create_hypertable('public.metrics', 'time', create_default_indexes=>false); --skew device_id distribution compared to device_id2. --device_id2 will be the favourable default segmentby insert into metrics SELECT t, 1, 1, extract(epoch from t) from generate_series ( '2007-02-01'::timestamp , '2007-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 1, 2, extract(epoch from t) from generate_series ( '2008-02-01'::timestamp , '2008-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 1, 1, extract(epoch from t) from generate_series ( '2012-02-01'::timestamp , '2012-04-01'::timestamp , '1 day'::interval) t; insert into metrics SELECT t, 2, 2, extract(epoch from t) from generate_series ( '2016-02-01'::timestamp , '2016-04-01'::timestamp , '1 day'::interval) t; ANALYZE metrics; --use the best-scenario unique index (device_id2) CREATE UNIQUE INDEX test_idx ON metrics(device_id, time); CREATE UNIQUE INDEX test_idx2 ON metrics(device_id2, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --opposite order of columns drop index test_idx; drop index test_idx2; CREATE UNIQUE INDEX test_idx ON metrics(time, device_id); CREATE UNIQUE INDEX test_idx2 ON metrics(time, device_id2); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --use a high-cardinality column in the index (still choose device_id2) drop index test_idx; CREATE UNIQUE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --use a non-unique index drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(device_id, time, val); CREATE INDEX test_idx2 ON metrics(device_id2, time, val); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --another non-unique index column order (choose device_id since it is in a lower index position) drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(device_id, time, val); CREATE INDEX test_idx2 ON metrics(val, device_id2, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --use a high-cardinality column in the non-unque index (still choose device_id2) drop index test_idx; CREATE INDEX test_idx ON metrics(val, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --use 2 indexes (choose device_id since it is an indexed column) drop index test_idx; drop index test_idx2; CREATE INDEX test_idx ON metrics(val, time); CREATE INDEX test_idx2 ON metrics(device_id, time); SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); --no indexes (choose device_id2) drop index test_idx; drop index test_idx2; SELECT _timescaledb_functions.get_segmentby_defaults('public.metrics'); ALTER TABLE metrics SET (timescaledb.compress = true); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_segmentby = 'device_id'); select count(compress_chunk(x)) from show_chunks('metrics') x; select * from chunk_settings; select count(decompress_chunk(x)) from show_chunks('metrics') x; ALTER TABLE metrics SET (timescaledb.compress = false); DROP TABLE metrics; --test on an empty order_by CREATE TABLE table1(col1 INT NOT NULL, col2 INT); SELECT create_hypertable('table1','col1', chunk_time_interval => 10); SELECT _timescaledb_functions.get_orderby_defaults('table1', ARRAY['col1']::text[]); ALTER TABLE table1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'col1'); SELECT * FROM _timescaledb_catalog.compression_settings; ALTER TABLE table1 SET (timescaledb.compress = false); \set ON_ERROR_STOP 0 SET timescaledb.compression_segmentby_default_function = 'function_does_not_exist'; SET timescaledb.compression_orderby_default_function = 'function_does_not_exist'; --wrong function signatures SET timescaledb.compression_segmentby_default_function = '_timescaledb_functions.get_orderby_defaults'; SET timescaledb.compression_orderby_default_function = '_timescaledb_functions.get_segmentby_defaults'; \set ON_ERROR_STOP 1 SET timescaledb.compression_orderby_default_function = '_timescaledb_functions.get_orderby_defaults'; SET timescaledb.compression_segmentby_default_function = '_timescaledb_functions.get_segmentby_defaults'; RESET timescaledb.compression_segmentby_default_function; RESET timescaledb.compression_orderby_default_function; -- test search_path quoting SET search_path TO ''; CREATE TABLE public.t1 (time timestamptz NOT NULL, segment_value text NOT NULL); SELECT public.create_hypertable('public.t1', 'time'); ALTER TABLE public.t1 SET (timescaledb.compress, timescaledb.compress_orderby = 'segment_value'); RESET search_path; -- test same named objects in different schemas with default orderbys/segmentbys \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA schema1; CREATE SCHEMA schema2; GRANT ALL ON SCHEMA schema1, schema2 to public; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- test the case with default orderbys CREATE TABLE schema1.page_events2 ( time TIMESTAMPTZ NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema1.page_events2', 'time'); ALTER TABLE schema1.page_events2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'page' ); CREATE TABLE schema2.page_events2 ( time TIMESTAMPTZ NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema2.page_events2', 'time'); ALTER TABLE schema2.page_events2 SET ( timescaledb.compress, timescaledb.compress_segmentby = 'page' ); DROP TABLE schema1.page_events2; DROP TABLE schema2.page_events2; -- test the case with default segmentbys CREATE TABLE schema1.page_events2 ( time TIMESTAMPTZ NOT NULL, id BIGSERIAL NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema1.page_events2', 'time'); ALTER TABLE schema1.page_events2 SET ( timescaledb.compress, timescaledb.compress_orderby = 'time desc, id asc' ); CREATE TABLE schema2.page_events2 ( time TIMESTAMPTZ NOT NULL UNIQUE, id BIGSERIAL NOT NULL, page TEXT NOT NULL ); SELECT create_hypertable('schema2.page_events2', 'time'); ALTER TABLE schema2.page_events2 SET ( timescaledb.compress, timescaledb.compress_orderby = 'time desc' ); -- test default segmentby diabled when orderby is specified CREATE TABLE test_table ( ts INT NOT NULL, uuid BIGINT NOT NULL, val FLOAT ); CREATE UNIQUE INDEX test_idx ON test_table (uuid, ts); SELECT create_hypertable( 'test_table', 'ts', chunk_time_interval => 1500000 ); INSERT INTO test_table (ts, uuid, val) VALUES (1, 1001, 10.1), (2, 1002, 20.2), (3, 1003, 30.3); SELECT _timescaledb_functions.get_segmentby_defaults('public.test_table'); ALTER TABLE test_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'uuid' ); SELECT count(compress_chunk(x)) FROM show_chunks('test_table') x; select * from chunk_settings; DROP TABLE test_table; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_errors.sql����������������������������������������������0000664�0000000�0000000�00000060576�15100345067�0023127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 \set VERBOSITY default \set ECHO none \o /dev/null \ir ../../../test/sql/include/test_utils.sql \o \set ECHO all --table with special column names -- create table foo2 (a integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('foo2', 'a', chunk_time_interval=> 10); create table foo3 (a integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('foo3', 'a', chunk_time_interval=> 10); create table non_compressed (a integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('non_compressed', 'a', chunk_time_interval=> 10); insert into non_compressed values( 3 , 16 , 20, 4); ALTER TABLE foo2 set (timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'c'); ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'c'); ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'd DESC'); ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c' , timescaledb.compress_orderby = 'd'); -- this is acceptable: having previously set the default value for orderby -- and skipping orderby on a subsequent alter command create table default_skipped (a integer not null, b integer, c integer, d integer); select create_hypertable('default_skipped', 'a', chunk_time_interval=> 10); alter table default_skipped set (timescaledb.compress, timescaledb.compress_segmentby = 'c'); alter table default_skipped set (timescaledb.compress, timescaledb.compress_segmentby = 'c'); create table with_rls (a integer, b integer); ALTER TABLE with_rls ENABLE ROW LEVEL SECURITY; select table_name from create_hypertable('with_rls', 'a', chunk_time_interval=> 10); ALTER TABLE with_rls set (timescaledb.compress, timescaledb.compress_orderby='a'); --note that the time column "a" should be added to the end of the orderby list SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY relid::text; ALTER TABLE foo3 set (timescaledb.compress, timescaledb.compress_orderby='d DeSc NullS lAsT'); --shold allow alter since segment by was empty ALTER TABLE foo3 set (timescaledb.compress, timescaledb.compress_orderby='d Asc NullS lAsT'); --this is ok too ALTER TABLE foo3 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c', timescaledb.compress_orderby = 'd DeSc NullS lAsT'); -- Negative test cases --- ALTER TABLE foo2 set (timescaledb.compress, timescaledb.compress_segmentby = '"bacB toD",c'); alter table default_skipped set (timescaledb.compress, timescaledb.compress_orderby = 'a asc', timescaledb.compress_segmentby = 'c'); alter table default_skipped set (timescaledb.compress, timescaledb.compress_segmentby = 'c'); create table reserved_column_prefix (a integer, _ts_meta_foo integer, "bacB toD" integer, c integer, d integer); select table_name from create_hypertable('reserved_column_prefix', 'a', chunk_time_interval=> 10); ALTER TABLE reserved_column_prefix set (timescaledb.compress); --basic test with count create table foo (a integer, b integer, c integer, t text, p point); ALTER TABLE foo ADD CONSTRAINT chk_existing CHECK(b > 0); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); insert into foo values( 3 , 16 , 20); insert into foo values( 10 , 10 , 20); insert into foo values( 20 , 11 , 20); insert into foo values( 30 , 12 , 20); ALTER TABLE foo ALTER b SET NOT NULL; select attname, attnotnull from pg_attribute where attrelid = (select oid from pg_class where relname like 'foo') and attname like 'b'; ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'd'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = ''); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'd'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc nulls'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc nulls thirsty'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c climb nulls first'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c nulls first asC'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc nulls first asc'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c desc hurry'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c descend'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c; SELECT 1'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = '1,2'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c + 1'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'random()'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c LIMIT 1'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'c USING <'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 't COLLATE "en_US"'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c asc' , timescaledb.compress_orderby = 'c'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c nulls last'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c + 1'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'random()'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c LIMIT 1'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'c + b'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, p'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_segmentby = 'b, b'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'b, b'); --should succeed ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b'); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_segmentby=''); ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_segmentby='c'); -- test alter reset SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; ALTER TABLE foo RESET (timescaledb.compress_orderby); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; ALTER TABLE foo RESET (timescaledb.compress_segmentby); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_index = 'bloom(c)'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; ALTER TABLE foo RESET (timescaledb.compress_index); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; -- should fail ALTER TABLE foo RESET (timescaledb.compress); ALTER TABLE foo RESET (timescaledb.compress, timescaledb.compress_segmentby, timescaledb.compress_orderby); ALTER TABLE foo RESET (timescaledb.compress_segmentby = 'a', timescaledb.compress_orderby); ALTER TABLE foo RESET (timescaledb.compress_segmentby = ''); -- should succeed ALTER TABLE foo RESET (timescaledb.compress_segmentby, timescaledb.compress_orderby); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; ALTER TABLE foo SET (timescaledb.compress, timescaledb.compress_orderby = 'a, b', timescaledb.compress_segmentby=''); create table foo_fake (a integer, b integer, c integer, t text, p point); ALTER TABLE foo_fake RESET (timescaledb.compress_segmentby); select table_name from create_hypertable('foo_fake', 'a', chunk_time_interval=> 10); ALTER TABLE foo_fake RESET (timescaledb.compress_segmentby); DROP TABLE foo_fake; --ddl on ht with compression ALTER TABLE foo DROP COLUMN a; ALTER TABLE foo DROP COLUMN b; ALTER TABLE foo ALTER COLUMN t SET NOT NULL; --can add constraints as long as no data is compressed ALTER TABLE foo ADD CONSTRAINT chk CHECK(b > 0); ALTER TABLE foo ADD CONSTRAINT unq UNIQUE(a); --restore ALTER TABLE foo DROP CONSTRAINT chk; ALTER TABLE foo DROP CONSTRAINT unq; --should succeed BEGIN; ALTER TABLE foo DROP CONSTRAINT chk_existing; ROLLBACK; --note that the time column "a" should not be added to the end of the order by list again (should appear first) SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; SELECT decompress_chunk(ch, false) FROM show_chunks('foo') ch limit 1; --test changing the segment by columns ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a', timescaledb.compress_segmentby = 'b'); SELECT format('%I.%I',chunk_schema,chunk_name) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'foo' ORDER BY chunk_name LIMIT 1\gset select decompress_chunk(:'CHUNK_NAME', if_compressed=>false); select decompress_chunk(:'CHUNK_NAME'); --should succeed select compress_chunk(:'CHUNK_NAME'); select compress_chunk(:'CHUNK_NAME', if_not_compressed=>false); select compress_chunk(:'CHUNK_NAME'); SELECT compress_chunk(ch) FROM show_chunks('non_compressed') ch LIMIT 1; ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a', timescaledb.compress_segmentby = 'c'); ALTER TABLE foo set (timescaledb.compress='f'); ALTER TABLE foo reset (timescaledb.compress); SELECT decompress_chunk(ch) FROM show_chunks('non_compressed') ch LIMIT 1; --should succeed SELECT decompress_chunk(ch, true) FROM show_chunks('foo') ch; --should succeed ALTER TABLE foo set (timescaledb.compress, timescaledb.compress_orderby = 'a', timescaledb.compress_segmentby = 'b'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'foo'::regclass; SELECT comp_hyper.schema_name|| '.' || comp_hyper.table_name as "COMPRESSED_HYPER_NAME" FROM _timescaledb_catalog.hypertable comp_hyper INNER JOIN _timescaledb_catalog.hypertable uncomp_hyper ON (comp_hyper.id = uncomp_hyper.compressed_hypertable_id) WHERE uncomp_hyper.table_name like 'foo' ORDER BY comp_hyper.id LIMIT 1 \gset select add_retention_policy(:'COMPRESSED_HYPER_NAME', INTERVAL '4 months', true); --Constraint checking for compression create table fortable(col integer primary key); create table table_constr( device_id integer, timec integer , location integer , c integer constraint valid_cval check (c > 20) , d integer, primary key ( device_id, timec) ); insert into fortable values (1); select table_name from create_hypertable('table_constr', 'timec', chunk_time_interval=> 10); BEGIN; ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_segmentby = 'd'); ROLLBACK; alter table table_constr add constraint table_constr_uk unique (location, timec, device_id); BEGIN; ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_orderby = 'timec', timescaledb.compress_segmentby = 'device_id'); ROLLBACK; --exclusion constraints not allowed alter table table_constr add constraint table_constr_exclu exclude using btree (timec with = ); ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_orderby = 'timec', timescaledb.compress_segmentby = 'device_id, location, d'); alter table table_constr drop constraint table_constr_exclu ; --now it works ALTER TABLE table_constr set (timescaledb.compress, timescaledb.compress_orderby = 'timec', timescaledb.compress_segmentby = 'device_id, location, d'); -- ddl ADD column variants that are not supported ALTER TABLE table_constr ADD COLUMN newcol integer UNIQUE; ALTER TABLE table_constr ADD COLUMN newcol integer PRIMARY KEY; ALTER TABLE table_constr ADD COLUMN newcol integer NOT NULL; ALTER TABLE table_constr ADD COLUMN newcol integer DEFAULT random() + random(); ALTER TABLE table_constr ADD COLUMN IF NOT EXISTS newcol integer REFERENCES fortable(col); ALTER TABLE table_constr ADD COLUMN IF NOT EXISTS newcol integer GENERATED ALWAYS AS IDENTITY; ALTER TABLE table_constr ADD COLUMN IF NOT EXISTS newcol integer GENERATED BY DEFAULT AS IDENTITY; ALTER TABLE table_constr ADD COLUMN newcol nonexistent_type; --FK check should not error even with dropped columns (previously had a bug related to this) CREATE TABLE table_fk ( time timestamptz NOT NULL, id1 int8 NOT NULL, id2 int8 NOT NULL, value float8 NULL, CONSTRAINT fk1 FOREIGN KEY (id1) REFERENCES fortable(col), CONSTRAINT fk2 FOREIGN KEY (id2) REFERENCES fortable(col) ); SELECT create_hypertable('table_fk', 'time'); ALTER TABLE table_fk DROP COLUMN id1; ALTER TABLE table_fk SET (timescaledb.compress,timescaledb.compress_segmentby = 'id2'); -- TEST fk cascade delete behavior on compressed chunk -- insert into fortable values(10); --we want 2 chunks here -- insert into table_constr values(1000, 1, 44, 44, 1); insert into table_constr values(1000, 10, 44, 44, 10); select ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht where ch1.hypertable_id = ht.id and ht.table_name like 'table_constr' ORDER BY ch1.id limit 1 \gset -- we have 1 compressed and 1 uncompressed chunk after this. select compress_chunk(:'CHUNK_NAME'); SELECT total_chunks , number_compressed_chunks FROM hypertable_compression_stats('table_constr'); --github issue 1661 --disable compression after enabling it on a table that has fk constraints CREATE TABLE table_constr2( device_id integer, timec integer , location integer , d integer references fortable(col), primary key ( device_id, timec) ); SELECT table_name from create_hypertable('table_constr2', 'timec', chunk_time_interval=> 10); INSERT INTO fortable VALUES( 99 ); INSERT INTO table_constr2 VALUES( 1000, 10, 5, 99); ALTER TABLE table_constr2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id'); ALTER TABLE table_constr2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); --compress a chunk and try to disable compression, it should fail -- SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id and ht.table_name like 'table_constr2' \gset SELECT compress_chunk(:'CHUNK_NAME'); ALTER TABLE table_constr2 set (timescaledb.compress=false); --decompress all chunks and disable compression. SELECT decompress_chunk(:'CHUNK_NAME'); ALTER TABLE table_constr2 SET (timescaledb.compress=false); -- TEST compression policy -- modify the config to trigger errors at runtime CREATE TABLE test_table_int(time bigint, val int); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 1); CREATE OR REPLACE function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 5::BIGINT'; SELECT set_integer_now_func('test_table_int', 'dummy_now'); INSERT INTO test_table_int SELECT generate_series(1,5), 10; ALTER TABLE test_table_int set (timescaledb.compress); SELECT add_compression_policy('test_table_int', 2::int) AS compressjob_id \gset \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_config.bgw_job SET config = config - 'compress_after' WHERE id = :compressjob_id; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; --should fail CALL run_job(:compressjob_id); SELECT remove_compression_policy('test_table_int'); --again add a new policy that we'll tamper with SELECT add_compression_policy('test_table_int', 2::int) AS compressjob_id \gset UPDATE _timescaledb_config.bgw_job SET config = config - 'hypertable_id' WHERE id = :compressjob_id; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; --should fail CALL run_job(:compressjob_id); UPDATE _timescaledb_config.bgw_job SET config = NULL WHERE id = :compressjob_id; SELECT config FROM _timescaledb_config.bgw_job WHERE id = :compressjob_id; --should fail CALL run_job(:compressjob_id); -- test ADD COLUMN IF NOT EXISTS CREATE TABLE metric (time TIMESTAMPTZ NOT NULL, val FLOAT8 NOT NULL, dev_id INT4 NOT NULL); SELECT create_hypertable('metric', 'time', 'dev_id', 10); ALTER TABLE metric SET ( timescaledb.compress, timescaledb.compress_segmentby = 'dev_id', timescaledb.compress_orderby = 'time DESC' ); INSERT INTO metric(time, val, dev_id) SELECT s.*, 3.14+1, 1 FROM generate_series('2021-08-17 00:00:00'::timestamp, '2021-08-17 00:02:00'::timestamp, '1 s'::interval) s; SELECT compress_chunk(show_chunks('metric')); -- column does not exist the first time ALTER TABLE metric ADD COLUMN IF NOT EXISTS "medium" VARCHAR ; -- column already exists the second time ALTER TABLE metric ADD COLUMN IF NOT EXISTS "medium" VARCHAR ; -- also add one without IF NOT EXISTS ALTER TABLE metric ADD COLUMN "medium_1" VARCHAR ; ALTER TABLE metric ADD COLUMN "medium_1" VARCHAR ; --github issue 3481 --GROUP BY error when setting compress_segmentby with an enum column CREATE TYPE an_enum_type AS ENUM ('home', 'school'); CREATE TABLE test ( time timestamp NOT NULL, enum_col an_enum_type NOT NULL ); SELECT create_hypertable( 'test', 'time' ); INSERT INTO test VALUES ('2001-01-01 00:00', 'home'), ('2001-01-01 01:00', 'school'), ('2001-01-01 02:00', 'home'); --enable compression on enum_col ALTER TABLE test SET ( timescaledb.compress, timescaledb.compress_segmentby = 'enum_col', timescaledb.compress_orderby = 'time' ); --below queries will pass before chunks are compressed SELECT 1 FROM test GROUP BY enum_col; SELECT DISTINCT 1 FROM test; --compress chunks SELECT COMPRESS_CHUNK(X) FROM SHOW_CHUNKS('test') X; ANALYZE test; --below query should pass after chunks are compressed SELECT 1 FROM test GROUP BY enum_col; SELECT DISTINCT 1 FROM test; --github issue 4398 SELECT format('CREATE TABLE data_table AS SELECT now() AS tm, %s', array_to_string(array_agg(format('125 AS c%s',a)), ', ')) FROM generate_series(1,550)a \gexec CREATE TABLE ts_table (LIKE data_table); SELECT * FROM create_hypertable('ts_table', 'tm'); --should report a warning \set VERBOSITY terse ALTER TABLE ts_table SET(timescaledb.compress, timescaledb.compress_segmentby = 'c1', timescaledb.compress_orderby = 'tm'); INSERT INTO ts_table SELECT * FROM data_table; --cleanup tables DROP TABLE data_table cascade; DROP TABLE ts_table cascade; -- #5458 invalid reads for row expressions after column dropped on compressed tables CREATE TABLE readings( "time" TIMESTAMPTZ NOT NULL, battery_status TEXT, battery_temperature DOUBLE PRECISION ); INSERT INTO readings ("time") VALUES ('2022-11-11 11:11:11-00'); SELECT create_hypertable('readings', 'time', chunk_time_interval => interval '12 hour', migrate_data=>true); create unique index readings_uniq_idx on readings("time",battery_temperature); ALTER TABLE readings SET (timescaledb.compress,timescaledb.compress_segmentby = 'battery_temperature'); SELECT compress_chunk(show_chunks('readings')); ALTER TABLE readings DROP COLUMN battery_status; INSERT INTO readings ("time", battery_temperature) VALUES ('2022-11-11 11:11:11', 0.2); SELECT readings FROM readings; -- #5577 On-insert decompression after schema changes may not work properly SELECT decompress_chunk(show_chunks('readings'),true); SELECT compress_chunk(show_chunks('readings'),true); \set ON_ERROR_STOP 0 INSERT INTO readings ("time", battery_temperature) VALUES ('2022-11-11 11:11:11',0.2) -- same record as inserted ; \set ON_ERROR_STOP 1 SELECT * from readings; SELECT assert_equal(count(1), 2::bigint) FROM readings; -- no unique check failure during decompression SELECT decompress_chunk(show_chunks('readings'),true); -- #5553 Unique constraints are not always respected on compressed tables CREATE TABLE main_table AS SELECT '2011-11-11 11:11:11'::timestamptz AS time, 'foo' AS device_id; CREATE UNIQUE INDEX xm ON main_table(time, device_id); SELECT create_hypertable('main_table', 'time', chunk_time_interval => interval '12 hour', migrate_data => TRUE); ALTER TABLE main_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id'); SELECT compress_chunk(show_chunks('main_table')); -- insert rejected \set ON_ERROR_STOP 0 INSERT INTO main_table VALUES ('2011-11-11 11:11:11', 'foo'); -- insert rejected in case 1st row doesn't violate constraint with different segmentby INSERT INTO main_table VALUES ('2011-11-11 11:12:11', 'bar'), ('2011-11-11 11:11:11', 'foo'); \set ON_ERROR_STOP 1 SELECT assert_equal(count(1), 1::bigint) FROM main_table; -- no unique check failure during decompression SELECT decompress_chunk(show_chunks('main_table'), TRUE); DROP TABLE IF EXISTS readings; CREATE TABLE readings( "time" timestamptz NOT NULL, battery_status text, candy integer, battery_status2 text, battery_temperature text ); SELECT create_hypertable('readings', 'time', chunk_time_interval => interval '12 hour'); CREATE UNIQUE INDEX readings_uniq_idx ON readings("time", battery_temperature); ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'battery_temperature'); ALTER TABLE readings DROP COLUMN battery_status; ALTER TABLE readings DROP COLUMN battery_status2; INSERT INTO readings("time", candy, battery_temperature) VALUES ('2022-11-11 11:11:11', 88, '0.2'); SELECT compress_chunk(show_chunks('readings'), TRUE); -- no error happens INSERT INTO readings("time", candy, battery_temperature) VALUES ('2022-11-11 11:11:11', 33, 0.3) ; -- Segmentby checks should be done for unique indexes without -- constraints, so create a table without constraints and add a unique -- index and try to create a table without using the right segmentby -- column. CREATE TABLE table_unique_index( location smallint not null, device_id smallint not null, time timestamptz not null, value float8 not null ); CREATE UNIQUE index ON table_unique_index(location, device_id, time); SELECT table_name FROM create_hypertable('table_unique_index', 'time'); -- Will warn because the lack of segmentby/orderby compression options ALTER TABLE table_unique_index SET (timescaledb.compress); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'location'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_orderby = 'device_id', timescaledb.compress_segmentby = ''); ALTER TABLE table_unique_index SET (timescaledb.compress = off); -- Will enable compression without warnings ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'device_id'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'device_id,location'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby='', timescaledb.compress_orderby = 'device_id,location'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'time,location', timescaledb.compress_orderby = 'device_id'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); ALTER TABLE table_unique_index SET (timescaledb.compress, timescaledb.compress_segmentby = 'time,location,device_id'); ALTER TABLE table_unique_index SET (timescaledb.compress = off); -- try compressing osm chunk CREATE TABLE osm_table (time timestamptz NOT NULL, device_id text, value float); SELECT table_name FROM create_hypertable('osm_table', 'time'); ALTER TABLE osm_table SET (timescaledb.compress); INSERT INTO osm_table VALUES ('2022-11-11 11:11:11', 'foo', 1.0); SELECT format('%I.%I',chunk_schema,chunk_name) AS "CHUNK_NAME" FROM timescaledb_information.chunks WHERE hypertable_name = 'osm_table' ORDER BY chunk_name LIMIT 1 \gset UPDATE _timescaledb_catalog.chunk ch SET osm_chunk = true FROM _timescaledb_catalog.hypertable ht WHERE ch.hypertable_id = ht.id AND ht.table_name='osm_table'; -- show_chunks should not show any OSM chunks SELECT show_chunks('osm_table'); SELECT compress_chunk(:'CHUNK_NAME'); ����������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_fks.sql�������������������������������������������������0000664�0000000�0000000�00000002507�15100345067�0022364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test foreign key constraints with compression CREATE TABLE keys(time timestamptz unique); CREATE TABLE ht_with_fk(time timestamptz); SELECT create_hypertable('ht_with_fk','time'); ALTER TABLE ht_with_fk ADD CONSTRAINT keys FOREIGN KEY (time) REFERENCES keys(time) ON DELETE CASCADE; ALTER TABLE ht_with_fk SET (timescaledb.compress,timescaledb.compress_segmentby='time'); -- no keys added yet so any insert into ht_with_fk should fail \set ON_ERROR_STOP 0 INSERT INTO ht_with_fk SELECT '2000-01-01'; \set ON_ERROR_STOP 1 -- create a key in the referenced table INSERT INTO keys SELECT '2000-01-01'; -- now the insert should succeed INSERT INTO ht_with_fk SELECT '2000-01-01'; SELECT compress_chunk(ch) FROM show_chunks('ht_with_fk') ch; -- insert should still succeed after compression INSERT INTO ht_with_fk SELECT '2000-01-01'; -- inserting key not present in keys should fail \set ON_ERROR_STOP 0 INSERT INTO ht_with_fk SELECT '2000-01-01 0:00:01'; \set ON_ERROR_STOP 1 SELECT conrelid::regclass,conname,confrelid::regclass FROM pg_constraint WHERE contype = 'f' AND confrelid = 'keys'::regclass ORDER BY conrelid::regclass::text COLLATE "C",conname; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_hypertable.sql������������������������������������������0000664�0000000�0000000�00000025211�15100345067�0023735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/rand_generator.sql \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql CREATE TYPE customtype; SET client_min_messages TO WARNING; CREATE OR REPLACE FUNCTION customtype_in(cstring) RETURNS customtype AS :TSL_MODULE_PATHNAME, 'ts_compression_custom_type_in' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_out(customtype) RETURNS cstring AS :TSL_MODULE_PATHNAME, 'ts_compression_custom_type_out' LANGUAGE C IMMUTABLE STRICT; CREATE OR REPLACE FUNCTION customtype_eq(customtype, customtype) RETURNS BOOL AS :TSL_MODULE_PATHNAME, 'ts_compression_custom_type_eq' LANGUAGE C IMMUTABLE STRICT; SET client_min_messages TO DEFAULT; -- for testing purposes we need a fixed length pass-by-ref type, and one whose -- alignment is greater than it's size. This type serves both purposes. CREATE TYPE customtype ( INPUT = customtype_in, OUTPUT = customtype_out, INTERNALLENGTH = 2, ALIGNMENT = double, STORAGE = plain ); create operator = ( leftarg = customtype, rightarg = customtype, procedure = customtype_eq, commutator = = ); CREATE OPERATOR CLASS customtype_ops DEFAULT FOR TYPE customtype USING hash AS OPERATOR 1 =; SELECT count(delete_job(job_id)) from timescaledb_information.jobs ; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1 ("Time" timestamptz, i integer, b bigint, t text); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') t; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = '"Time" DESC'); \set QUERY 'SELECT * FROM test1' \set QUERY_ORDER 'ORDER BY "Time"' \set HYPERTABLE_NAME 'test1' \ir include/compression_test_hypertable.sql \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- check stats SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid = '_timescaledb_internal._compressed_hypertable_2'::REGCLASS AND attnum > 0 ORDER BY attname; SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid in (SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = 2) AND attnum > 0 ORDER BY attname; -- Test that the GUC to disable bulk decompression works. vacuum analyze test1; explain (analyze, verbose, timing off, buffers off, costs off, summary off) select * from _timescaledb_internal._hyper_1_10_chunk; set timescaledb.enable_bulk_decompression to false; explain (analyze, verbose, timing off, buffers off, costs off, summary off) select * from _timescaledb_internal._hyper_1_10_chunk; reset timescaledb.enable_bulk_decompression; TRUNCATE test1; /* should be no data in table */ SELECT * FROM test1; /* nor compressed table */ SELECT * FROM _timescaledb_internal._compressed_hypertable_2; /* the compressed table should not have chunks */ SELECT count(*) FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2; --add test for altered hypertable CREATE TABLE test2 ("Time" timestamptz, i integer, b bigint, t text); SELECT table_name from create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 day'); --create some chunks with the old column numbers INSERT INTO test2 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-04 1:00', '1 hour') t; ALTER TABLE test2 DROP COLUMN b; --add default a value ALTER TABLE test2 ADD COLUMN c INT DEFAULT -15; --add default NULL ALTER TABLE test2 ADD COLUMN d INT; --write to both old chunks and new chunks with different column #s INSERT INTO test2 SELECT t, gen_rand_minstd(), gen_rand_minstd()::text, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-06 1:00', '1 hour') t; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'c, "Time" DESC'); \set QUERY 'SELECT * FROM test2' \set QUERY_ORDER 'ORDER BY c,"Time"' \set HYPERTABLE_NAME 'test2' \ir include/compression_test_hypertable.sql \set TYPE int \set ORDER_BY_COL_NAME c \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_2 \set SEGMENT_META_COL_MAX _ts_meta_max_2 \ir include/compression_test_hypertable_segment_meta.sql --TEST4 create segments with > 1000 rows. CREATE TABLE test4 ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); --we want all the data to go into 1 chunk. so use 1 year chunk interval select create_hypertable( 'test4', 'timec', chunk_time_interval=> '1 year'::interval); alter table test4 set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into test4 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-31 00:00'::timestamp, '1 day'), 'NYC', 'klick', 55, 75; insert into test4 select generate_series('2018-02-01 00:00'::timestamp, '2018-02-14 00:00'::timestamp, '1 min'), 'POR', 'klick', 55, 75; select hypertable_name, num_chunks from timescaledb_information.hypertables where hypertable_name like 'test4'; select location, count(*) from test4 group by location ORDER BY location; \set QUERY 'SELECT * FROM test4' \set QUERY_ORDER 'ORDER BY timec' \set HYPERTABLE_NAME 'test4' \ir include/compression_test_hypertable.sql \set TYPE TIMESTAMPTZ \set ORDER_BY_COL_NAME timec \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql -- check stats with segmentby SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid = '_timescaledb_internal._compressed_hypertable_6'::REGCLASS AND attnum > 0 ORDER BY attname; SELECT DISTINCT attname, attstattarget FROM pg_attribute WHERE attrelid in (SELECT format('%I.%I', schema_name, table_name)::regclass FROM _timescaledb_catalog.chunk ch WHERE ch.hypertable_id = 6) AND attnum > 0 ORDER BY attname; --add hypertable with order by a non by-val type with NULLs CREATE TABLE test5 ( time TIMESTAMPTZ NOT NULL, device_id TEXT NULL, temperature DOUBLE PRECISION NULL ); --we want all the data to go into 1 chunk. so use 1 year chunk interval select create_hypertable( 'test5', 'time', chunk_time_interval=> '1 day'::interval); alter table test5 set (timescaledb.compress, timescaledb.compress_orderby = 'device_id, time'); insert into test5 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_1', gen_rand_minstd(); insert into test5 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), 'device_2', gen_rand_minstd(); insert into test5 select generate_series('2018-01-01 00:00'::timestamp, '2018-01-10 00:00'::timestamp, '2 hour'), NULL, gen_rand_minstd(); \set QUERY 'SELECT * FROM test5' \set QUERY_ORDER 'ORDER BY device_id, time' \set HYPERTABLE_NAME 'test5' \ir include/compression_test_hypertable.sql \set TYPE TEXT \set ORDER_BY_COL_NAME device_id \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql TRUNCATE test5; SELECT * FROM test5; -- test 6, test with custom type, and NULLs in the segmentby CREATE table test6( time INT NOT NULL, device_id INT, data customtype ); SELECT create_hypertable('test6', 'time', chunk_time_interval=> 50); ALTER TABLE test6 SET (timescaledb.compress, timescaledb.compress_segmentby='device_id', timescaledb.compress_orderby = 'time DESC'); INSERT INTO test6 SELECT t, d, customtype_in((t + d)::TEXT::cstring) FROM generate_series(1, 200) t, generate_series(1, 3) d; INSERT INTO test6 SELECT t, NULL, customtype_in(t::TEXT::cstring) FROM generate_series(1, 200) t; \set QUERY 'SELECT * FROM test6' \set QUERY_ORDER 'ORDER BY device_id, time' \set HYPERTABLE_NAME 'test6' \ir include/compression_test_hypertable.sql \set TYPE INT \set ORDER_BY_COL_NAME time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql DROP TABLE test6; -- test 7, compress misc types, and NULLs in dictionaries CREATE TABLE test7(time INT, c1 DATE, c2 TIMESTAMP, c3 FLOAT, n TEXT); SELECT create_hypertable('test7', 'time', chunk_time_interval=> 200); ALTER TABLE test7 SET (timescaledb.compress, timescaledb.compress_orderby = 'time DESC, c1 DESC'); INSERT INTO test7 SELECT t, d, '2019/07/07 01:00', gen_rand_minstd(), 'a' FROM generate_series(1, 10) t, generate_series('2019/02/01'::DATE, '2019/02/10', '1d') d; INSERT INTO test7 SELECT t, d, '2019/07/07 01:30', gen_rand_minstd(), NULL FROM generate_series(10, 20) t, generate_series('2019/03/01'::DATE, '2019/03/10', '1d') d; \set QUERY 'SELECT * FROM test7' \set QUERY_ORDER 'ORDER BY time, c1' \set HYPERTABLE_NAME 'test7' \ir include/compression_test_hypertable.sql \set TYPE INT \set ORDER_BY_COL_NAME time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql DROP TABLE test7; -- helper function: float -> pseudorandom float [0..1]. create or replace function mix(x float4) returns float4 as $$ select ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ language sql; -- test gorilla for float4 and deltadelta for int32 and other types create table test8(ts date, id int, value float4, valueint2 int2, valuebool bool); select create_hypertable('test8', 'ts'); alter table test8 set (timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'ts desc') ; insert into test8 select '2022-02-02 02:02:02+03'::timestamptz + interval '1 month' * mix(x), mix(x + 1.) * 20, mix(x + 2.) * 50, mix(x + 3.) * 100, mix(x + 4.) > 0.1 from generate_series(1, 10000) x(x) ; select compress_chunk(x) from show_chunks('test8') x; select distinct on (id) * from test8 order by id, ts desc, value ; drop table test8; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_indexcreate.sql�����������������������������������������0000664�0000000�0000000�00000004227�15100345067�0024075�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- force index scan to be used when possible set enable_seqscan to false; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, summary off, timing off) ' create table segind(time timestamptz, a int, b int); select create_hypertable('segind', by_range('time')); -- enable compression on hypertable with no segment by column alter table segind set (timescaledb.compress, timescaledb.compress_segmentby='', timescaledb.compress_orderby='time, b'); insert into segind values('2024-11-08 10:31:28.436014-07', 1, 1), ('2024-11-08 10:32:28.436014-07', 2, 1), ('2024-11-08 10:33:28.436014-07', 3, 1), ('2024-11-08 10:34:28.436014-07', 2, 1), ('2024-11-08 10:35:28.436014-07', 1, 2), ('2024-11-08 10:36:28.436014-07', 4, 1); -- compress chunk -- this should create an index using orderby columns select compress_chunk(show_chunks('segind')); vacuum analyze segind; -- query using orderby columns should use the index :PREFIX select * from segind where b = 1; :PREFIX select * from segind where time = '2024-11-08 10:32:28.436014-07'; :PREFIX select * from segind where b = 1 and time = '2024-11-08 10:32:28.436014-07'; -- a query on another column should perform a seq scan since there is no index on it :PREFIX select * from segind where a = 1; -- decompress the chunk to drop the index select decompress_chunk(show_chunks('segind')); -- change compression settings to use segmentby column alter table segind set (timescaledb.compress, timescaledb.compress_segmentby='a', timescaledb.compress_orderby='time, b'); -- compress chunk -- this should create an index using segmentby and orderby columns select compress_chunk(show_chunks('segind')); vacuum analyze segind; -- queries using segmentby or orderby columns should use the index :PREFIX select * from segind where b = 1; :PREFIX select * from segind where time = '2024-11-08 10:32:28.436014-07'; :PREFIX select * from segind where b = 1 and time = '2024-11-08 10:32:28.436014-07'; :PREFIX select * from segind where a = 1; -- cleanup RESET enable_seqscan; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_indexscan.sql�������������������������������������������0000664�0000000�0000000�00000030770�15100345067�0023560�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --Enable compression path info SET timescaledb.debug_compression_path_info= 'on'; --Table creation CREATE TABLE tab1 ( time timestamptz not null, id integer not null, c1 double precision null, c2 double precision null ); CREATE TABLE tab2 ( time timestamptz not null, id integer not null, c1 double precision null, c2 double precision null ); --Hypertable creation SELECT FROM create_hypertable('tab1', 'time'); SELECT FROM create_hypertable('tab2', 'time'); --Data generation INSERT INTO tab1 SELECT time + (INTERVAL '1 minute' * random()) AS time, id, random() AS c1, random()* 100 AS c2 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') AS g1(time), generate_series(1, 100, 1 ) AS g2(id) ORDER BY time; --Test with indexscan enabled SET timescaledb.enable_compression_indexscan = 'ON'; --Test Set 1.1 [ Index(ASC, Null_First), Compression(ASC, Null_First) ] CREATE INDEX idx_asc_null_first ON tab1(id, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 1.1 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 1.2 [Index(ASC, Null_First), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 1.2 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 1.3 [Index(ASC, Null_First), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 1.3 SELECT decompress_chunk(show_chunks('tab1')); --DROP INDEX idx_asc_null_last --Test Set 1.4 [Index(ASC, Null_First), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 1.4 SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_asc_null_first; --Test Set 2.1 [Index(ASC, Null_Last), Compression(ASC,Null_First)] CREATE INDEX idx_asc_null_last ON tab1(id, time); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 2.1 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 2.2 [Index(ASC, Null_Last), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 2.2 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 2.3 [Index(ASC, Null_Last), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 2.3 SELECT decompress_chunk(show_chunks('tab1')); --DROP INDEX idx_asc_null_last --Test Set 2.4 [Index(ASC, Null_Last), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 2.4 SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_asc_null_last; --Test Set 3.1 [Index(DESC, Null_First), Compression(ASC,Null_First)] CREATE INDEX idx_desc_null_first ON tab1(id, time DESC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 3.1 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 3.2 [Index(DESC, Null_First), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 3.2 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 3.3 [Index(DESC, Null_First), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 3.3 SELECT decompress_chunk(show_chunks('tab1')); --DROP INDEX idx_asc_null_last --Test Set 3.4 [Index(DESC, Null_First), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 3.4 SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_desc_null_first; --Test Set 4.1 [Index(DESC, Null_Last), Compression(ASC,Null_First)] CREATE INDEX idx_desc_null_last ON tab1(id, time DESC); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 4.1 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 4.2 [Index(DESC, Null_Last), Compression(ASC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 4.2 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 4.3 [Index(DESC, Null_Last), Compression(DESC,Null_First)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); --Cleanup 4.3 SELECT decompress_chunk(show_chunks('tab1')); --Test Set 4.4 [Index(DESC, Null_Last), Compression(DESC,Null_Last)] ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time DESC NULLS LAST'); SELECT * FROM timescaledb_information.compression_settings; SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'time'); SELECT compress_chunk(show_chunks('tab1')); --Cleanup 4.4 SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_desc_null_last; --Test Set 5 GUC SET timescaledb.enable_compression_indexscan -- Default this flag will be false. RESET timescaledb.enable_compression_indexscan; SHOW timescaledb.enable_compression_indexscan; SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); --Test with this guc enabled SET timescaledb.enable_compression_indexscan = 'ON'; SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); --Test Set 6 Compare two compression paths INSERT into tab2 SELECT * from tab1; CREATE INDEX idx_asc_null_first ON tab1(id, time ASC NULLS FIRST); CREATE INDEX idx2_asc_null_first ON tab2(id, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); ALTER TABLE tab2 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id', timescaledb.compress_orderby = 'time NULLS FIRST'); RESET timescaledb.enable_compression_indexscan; SELECT compress_chunk(show_chunks('tab1')); SET timescaledb.enable_compression_indexscan = 'ON'; SELECT compress_chunk(show_chunks('tab2')); SELECT id, time from tab1 EXCEPT SELECT id, time from tab2; SELECT decompress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab2')); DROP INDEX idx2_asc_null_first; DROP INDEX idx_asc_null_first; --Test Set 7.1 with Collation order_by \set ON_ERROR_STOP 1 CREATE TABLE tab3 ( name text, time timestamptz not null ); SELECT FROM create_hypertable('tab3', 'time'); --Data generation INSERT INTO tab3 SELECT name, time + (INTERVAL '1 minute' * random()) AS time FROM md5(random()::text) as name, generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') AS g1(time) ORDER BY time; CREATE INDEX idx_asc_null_first ON tab3(name COLLATE "C", time ASC NULLS FIRST); ALTER TABLE tab3 SET(timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'name, time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab3')); SELECT decompress_chunk(show_chunks('tab3')); CREATE INDEX idxcol_asc_null_first ON tab3(name, time ASC NULLS FIRST); SELECT compress_chunk(show_chunks('tab3')); SELECT decompress_chunk(show_chunks('tab3')); DROP INDEX idx_asc_null_first; DROP INDEX idxcol_asc_null_first; --Test Set 7.1 with Collation segment_by CREATE INDEX idx_asc_null_first ON tab3(name COLLATE "ucs_basic", time ASC NULLS FIRST); ALTER TABLE tab3 SET(timescaledb.compress, timescaledb.compress_segmentby = 'name', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab3')); SELECT decompress_chunk(show_chunks('tab3')); CREATE INDEX idxcol_asc_null_first ON tab3(name, time ASC NULLS FIRST); SELECT compress_chunk(show_chunks('tab3')); SELECT decompress_chunk(show_chunks('tab3')); DROP INDEX idx_asc_null_first; DROP INDEX idxcol_asc_null_first; --Test Set 8 with multiple segment_by CREATE INDEX idx_asc_null_first ON tab1(id, c1, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id, c1', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_asc_null_first; CREATE INDEX idx_asc_null_first ON tab1(id, c1 DESC, time ASC NULLS FIRST); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id, c1', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_asc_null_first; --Test Set 9 --Last Column mismatch CREATE INDEX idx_asc_null_first ON tab1(id, c1, c2); ALTER TABLE tab1 SET(timescaledb.compress, timescaledb.compress_segmentby = 'id, c1', timescaledb.compress_orderby = 'time NULLS FIRST'); SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_asc_null_first; --Index Column out of order CREATE INDEX idx_asc_null_first ON tab1(c1, id, time ASC NULLS FIRST); SELECT compress_chunk(show_chunks('tab1')); SELECT decompress_chunk(show_chunks('tab1')); DROP INDEX idx_asc_null_first; -- Can't use partial indexes for compression because they refer only to a subset of the table. create index predicate on tab1(id, c1, time nulls first) where c2 = 0; select count(*) from tab1; select compress_chunk(show_chunks('tab1')); select decompress_chunk(show_chunks('tab1')); select count(*) from tab1; -- Check compression progression messages SET client_min_messages TO LOG; select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); RESET client_min_messages; -- Analyze and use stats now on a larger data set INSERT INTO tab1 SELECT time + (INTERVAL '1 minute' * random()) AS time, id, random() AS c1, random()* 100 AS c2 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '5 minutes') AS g1(time), generate_series(1, 100, 1 ) AS g2(id) ORDER BY time; ANALYZE _timescaledb_internal._hyper_1_2_chunk; SET client_min_messages TO LOG; select compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); RESET client_min_messages; drop index predicate; --Tear down DROP TABLE tab1; DROP TABLE tab2; DROP TABLE tab3; SET timescaledb.debug_compression_path_info = 'off'; ��������timescaledb-2.23.0/tsl/test/sql/compression_insert.sql����������������������������������������������0000664�0000000�0000000�00000116730�15100345067�0023111�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; \set PREFIX 'EXPLAIN (buffers off, costs off, summary off, timing off) ' \set ANALYZE 'EXPLAIN (analyze, buffers off, costs off, summary off, timing off) ' CREATE TABLE test1 (timec timestamptz , i integer , b bigint, t text); SELECT table_name from create_hypertable('test1', 'timec', chunk_time_interval=> INTERVAL '7 days'); INSERT INTO test1 SELECT q, 10, 11, 'hello' FROM generate_series( '2020-01-03 10:00:00-05', '2020-01-03 12:00:00-05' , '5 min'::interval) q; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); SELECT compress_chunk(c) FROM show_chunks('test1') c; SELECT count(*) FROM test1; --we have 1 compressed row -- SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; -- single and multi row insert into the compressed chunk -- INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , 11, 16, 'new' ; SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , i, i +5, 'clay' FROM (Select generate_series(10, 20, 1) i ) q; SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; SELECT count(*) from test1; -- single row copy COPY test1 FROM STDIN DELIMITER ','; 2020-01-02 11:16:00-05,11,16,copy \. SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; -- multi row copy COPY test1 FROM STDIN DELIMITER ','; 2020-01-02 11:16:00-05,11,16,multicopy 2020-01-02 11:16:00-05,12,17,multicopy 2020-01-02 11:16:00-05,13,18,multicopy \. SELECT COUNT(*) from _timescaledb_internal.compress_hyper_2_2_chunk; --Verify that all the data went into the initial chunk SELECT count(*) FROM show_chunks('test1') c; SELECT * FROM test1 WHERE b = 11 order by i, timec ; SELECT * FROM test1 WHERE i = 11 order by 1, 2, 3, 4; -- insert nulls except for timec INSERT INTO test1 SELECT '2020-01-02 11:46:00-05' , NULL, NULL, NULL; SELECT count(*) FROM show_chunks('test1') c; -- copy NULL COPY test1 FROM STDIN DELIMITER ',' NULL 'NULL'; 2020-01-02 11:46:00-05,NULL,NULL,NULL \. SELECT count(*) FROM show_chunks('test1') c; SELECT * from test1 WHERE i is NULL; --TEST 2 now alter the table and add a new column to it ALTER TABLE test1 ADD COLUMN newtcol varchar(400); --add rows with segments that overlap some of the previous ones SELECT count(*) from _timescaledb_internal.compress_hyper_2_2_chunk; INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , 100, 101, 'prev101', 'this is the newtcol101'; INSERT INTO test1 SELECT '2020-01-02 11:16:00-05' , i, 16, 'prev16', 'this is the newtcol16' FROM (Select generate_series(11, 16, 1) i ) q; SELECT * FROM test1 WHERE b = 16 order by 1, 2, 3, 4, 5; --number of rows in the chunk SELECT count(*) from _timescaledb_internal.compress_hyper_2_2_chunk; SELECT count(*) FROM show_chunks('test1') c; COPY test1 FROM STDIN DELIMITER ','; 2020-01-02 11:16:00-05,100,101,prev101,newtcol101 \. COPY test1 FROM STDIN DELIMITER ','; 2020-01-02 11:16:00-05,11,16,prev16,newtcol16 2020-01-02 11:16:00-05,12,16,prev16,newtcol16 2020-01-02 11:16:00-05,13,16,prev16,newtcol16 \. --number of rows in the chunk SELECT count(*) from _timescaledb_internal.compress_hyper_2_2_chunk; SELECT count(*) FROM show_chunks('test1') c; SELECT * FROM test1 WHERE newtcol IS NOT NULL ORDER BY 1,2,3; DROP TABLE test1; -- TEST 3 add tests with dropped columns on hypertable -- also tests defaults CREATE TABLE test2 ( itime integer, b bigint, t text); SELECT table_name from create_hypertable('test2', 'itime', chunk_time_interval=> 10::integer); --create a chunk INSERT INTO test2 SELECT t, 10, 'first'::text FROM generate_series(1, 7) t; ALTER TABLE test2 DROP COLUMN b; ALTER TABLE test2 ADD COLUMN c INT DEFAULT -15; ALTER TABLE test2 ADD COLUMN d INT; --create a new chunk INSERT INTO test2 SELECT t, 'second'::text, 120, 1 FROM generate_series(11, 15) t; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'c, itime DESC'); SELECT count(*) from ( SELECT compress_chunk(c) FROM show_chunks('test2') c ) q; --write to both old chunks and new chunks INSERT INTO test2(itime ,t , d) SELECT 9, '9', 90 ; INSERT INTO test2(itime ,t , d) SELECT 17, '17', 1700 ; COPY test2(itime,t,d) FROM STDIN DELIMITER ','; 9,9copy,90 17,17copy,1700 \. SELECT count(*) FROM show_chunks('test2') q; SELECT * from test2 WHERE itime >= 9 and itime <= 17 ORDER BY 1,2,3; -- now add a column to the compressed hypertable -- we have dropped columns and newly added columns now ALTER TABLE test2 ADD COLUMN charcol varchar(45); INSERT INTO test2(itime ,t , d, charcol) values (2, '2', 22, 'thisis22'), (17, '17', 1701, 'thisis1700') ; COPY test2(itime,t,d,charcol) FROM STDIN DELIMITER ','; 2,2copy,22,22copy 17,17copy,1701,1700copy \. SELECT * from test2 where itime = 2 or itime =17 ORDER BY 1, 2, 3, 4, 5; DROP TABLE test2; --- TEST3 tables with defaults --- -- sequences, generated values, check constraints into compressed chunks CREATE TABLE test2 (timec timestamptz , i integer CHECK ( i > 10) , b bigint default 20 , t text NOT NULL, CONSTRAINT rowconstr CHECK ( b > i ) ); SELECT table_name from create_hypertable('test2', 'timec', chunk_time_interval=> INTERVAL '7 days'); ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); INSERT INTO test2 values('2020-01-02 11:16:00-05' , 100, 105, 'first' ); SELECT compress_chunk(c) FROM show_chunks('test2') c; -- test if default value for b is used INSERT INTO test2(timec, i, t) values('2020-01-02 10:16:00-05' , 11, 'default' ); COPY test2(timec,i,t) FROM STDIN DELIMITER ','; 2020-01-02 10:16:00-05,11,defaultcopy \. SELECT b from test2 ORDER BY 1; \set ON_ERROR_STOP 0 --null value for t, should fail INSERT INTO test2 values ( '2020-01-02 01:00:00-05', 100, 200, NULL); COPY test2 FROM STDIN DELIMITER ',' NULL 'NULL'; 2020-01-02 01:00:00-05,100,200,NULL \. -- i=1, should fail INSERT INTO test2 values ( '2020-01-02 01:00:00-05', 1, 10, 'null i'); COPY test2 FROM STDIN DELIMITER ','; 2020-01-02 01:00:00-05,1,10,null i \. -- b < i, should fail INSERT INTO test2 values ( '2020-01-02 01:00:00-05', 22, 1, 'null i'); COPY test2 FROM STDIN DELIMITER ','; 2020-01-02 01:00:00-05,22,1,null i \. \set ON_ERROR_STOP 1 --verify we are still INSERTing into the compressed chunk i.e did not --create a new chunk SELECT count(c) FROM show_chunks('test2') c; -- TEST4 with sequence . CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE vessels (timec timestamptz , id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass), i integer CHECK ( i > 10) , b bigint default 20 , t text NOT NULL, CONSTRAINT rowconstr CHECK ( b > i ) ); SELECT table_name from create_hypertable('vessels', 'timec', chunk_time_interval=> INTERVAL '7 days'); ALTER TABLE vessels set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); INSERT INTO vessels(timec, i, b, t) values('2020-01-02 11:16:00-05' , 100, 105, 'first' ); SELECT compress_chunk(c) FROM show_chunks('vessels') c; -- test if default value for b and sequence value for id is used INSERT INTO vessels(timec, i, t) values('2020-01-02 10:16:00-05' , 11, 'default' ); COPY vessels(timec,i,t )FROM STDIN DELIMITER ','; 2020-01-02 10:16:00-05,11,default copy \. SELECT timec, id, b from vessels order by 2, 1; -- TEST5 generated values CREATE table test_gen ( id int generated by default AS IDENTITY , payload text ); SELECT create_hypertable('test_gen', 'id', chunk_time_interval=>10); ALTER TABLE test_gen set (timescaledb.compress); INSERT into test_gen (payload) SELECT generate_series(1,15) ; SELECT max(id) from test_gen; SELECT compress_chunk(c) FROM show_chunks('test_gen') c; INSERT INTO test_gen (payload) values(17); SELECT * from test_gen WHERE id = (Select max(id) from test_gen); COPY test_gen(payload) FROM STDIN DELIMITER ','; 18 \. SELECT * from test_gen WHERE id = (Select max(id) from test_gen); -- TEST triggers -- insert into compressed hypertables with triggers CREATE OR REPLACE FUNCTION row_trig_value_gt_0() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; IF NEW.value <= 0 THEN RAISE NOTICE 'Skipping insert'; RETURN NULL; END IF; RETURN NEW; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION row_trig_value_mod() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; NEW.value = NEW.value + 100; RETURN NEW; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION stmt_trig_info() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; RETURN NEW; END $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION stmt_trig_error() RETURNS TRIGGER AS $$ BEGIN RAISE EXCEPTION 'Trigger % % % % on %: % %', TG_NAME, TG_WHEN, TG_OP, TG_LEVEL, TG_TABLE_NAME, NEW, OLD; RETURN NULL; END $$ LANGUAGE plpgsql; CREATE TABLE trigger_test(time timestamptz NOT NULL, device int, value int, dropcol1 int); SELECT create_hypertable('trigger_test','time'); --create chunk and compress --the first chunk is created with dropcol1 INSERT INTO trigger_test(time, device, value,dropcol1) SELECT '2000-01-01',1,1,1; -- drop the column before we compress ALTER TABLE trigger_test DROP COLUMN dropcol1; ALTER TABLE trigger_test SET (timescaledb.compress,timescaledb.compress_segmentby='device'); SELECT compress_chunk(c) FROM show_chunks('trigger_test') c; -- BEFORE ROW trigger CREATE TRIGGER t1 BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION row_trig_value_gt_0(); -- should be 1 SELECT count(*) FROM trigger_test; -- try insert that gets skipped by trigger INSERT INTO trigger_test SELECT '2000-01-01',1,0; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,0 \. -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; -- try again without being skipped BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,1; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,1 \. -- should be 3 SELECT count(*) FROM trigger_test; ROLLBACK; DROP TRIGGER t1 ON trigger_test; -- BEFORE ROW trigger that modifies tuple CREATE TRIGGER t1_mod BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION row_trig_value_mod(); BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,11; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,12 \. -- value for both new tuples should be > 100 SELECT * FROM trigger_test ORDER BY 3; ROLLBACK; DROP TRIGGER t1_mod ON trigger_test; -- BEFORE ROW conditional trigger CREATE TRIGGER t1_cond BEFORE INSERT ON trigger_test FOR EACH ROW WHEN (NEW.value > 10) EXECUTE FUNCTION row_trig_value_mod(); -- test with condition being false BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,1; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,2 \. -- value for both new tuples should not be > 100 SELECT * FROM trigger_test ORDER BY 3; ROLLBACK; -- test with condition being true BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,11; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,12 \. -- value for both new tuples should be > 100 SELECT * FROM trigger_test ORDER BY 3; ROLLBACK; DROP TRIGGER t1_cond ON trigger_test; -- BEFORE ROW error in trigger CREATE TRIGGER t1_error BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION stmt_trig_error(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,11; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,12 \. \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; DROP TRIGGER t1_error ON trigger_test; -- BEFORE STATEMENT trigger CREATE TRIGGER t2 BEFORE INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_info(); BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,0; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,0 \. -- should be 3 SELECT count(*) FROM trigger_test; ROLLBACK; DROP TRIGGER t2 ON trigger_test; -- BEFORE STATEMENT error in trigger CREATE TRIGGER t2_error BEFORE INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_error(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,11; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,12 \. \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; DROP TRIGGER t2_error ON trigger_test; -- AFTER STATEMENT trigger CREATE TRIGGER t3 AFTER INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_info(); BEGIN; INSERT INTO trigger_test SELECT '2000-01-01',1,0; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,0 \. -- should be 3 SELECT count(*) FROM trigger_test; ROLLBACK; DROP TRIGGER t3 ON trigger_test; -- AFTER STATEMENT error in trigger CREATE TRIGGER t3_error AFTER INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_error(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,11; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,12 \. \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; DROP TRIGGER t3_error ON trigger_test; -- test unsupported features are blocked -- INSTEAD OF INSERT is only supported for VIEWs \set ON_ERROR_STOP 0 CREATE TRIGGER t4_instead INSTEAD OF INSERT ON trigger_test FOR EACH STATEMENT EXECUTE FUNCTION stmt_trig_info(); \set ON_ERROR_STOP 1 -- AFTER INSERT ROW trigger not supported on compressed chunk CREATE TRIGGER t4_ar AFTER INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION stmt_trig_info(); \set ON_ERROR_STOP 0 \set VERBOSITY default INSERT INTO trigger_test SELECT '2000-01-01',1,0; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,0 \. \set VERBOSITY terse \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; BEGIN; INSERT INTO trigger_test SELECT '2001-01-01',1,0; COPY trigger_test FROM STDIN DELIMITER ','; 2001-01-01 01:00:00-05,1,0 \. -- insert into new uncompressed chunk should not be blocked SELECT count(*) FROM trigger_test; ROLLBACK; DROP TRIGGER t4_ar ON trigger_test; -- CONSTRAINT trigger not supported on compressed chunk CREATE CONSTRAINT TRIGGER t4_constraint AFTER INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION stmt_trig_info(); \set ON_ERROR_STOP 0 INSERT INTO trigger_test SELECT '2000-01-01',1,0; COPY trigger_test FROM STDIN DELIMITER ','; 2000-01-01 01:00:00-05,1,0 \. \set ON_ERROR_STOP 1 -- should not insert rows. count is 1 SELECT count(*) FROM trigger_test; DROP trigger t4_constraint ON trigger_test; -- test row triggers after adding/dropping columns -- now add a new column to the table and insert into a new chunk ALTER TABLE trigger_test ADD COLUMN addcolv varchar(10); ALTER TABLE trigger_test ADD COLUMN addcoli integer; INSERT INTO trigger_test(time, device, value, addcolv, addcoli) VALUES ( '2010-01-01', 10, 10, 'ten', 222); SELECT compress_chunk(c, true) FROM show_chunks('trigger_test') c; CREATE TRIGGER t1_mod BEFORE INSERT ON trigger_test FOR EACH ROW EXECUTE FUNCTION row_trig_value_mod(); SELECT count(*) FROM trigger_test; BEGIN; INSERT INTO trigger_test VALUES ( '2000-01-01',1,11, 'eleven', 111), ( '2010-01-01',10,10, 'ten', 222); SELECT * FROM trigger_test ORDER BY 1 ,2, 3, 5; ROLLBACK; DROP TABLE trigger_test; -- test interaction between newly inserted batches and pathkeys/ordered append -- -- The following test operates on a small relation. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following test to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; CREATE TABLE test_ordering(time int); SELECT table_name FROM create_hypertable('test_ordering','time',chunk_time_interval:=100); ALTER TABLE test_ordering SET (timescaledb.compress,timescaledb.compress_orderby='time desc'); INSERT INTO test_ordering VALUES (5),(4),(3); -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name), true) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_ordering'; VACUUM ANALYZE test_ordering; -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; INSERT INTO test_ordering SELECT 1; VACUUM ANALYZE test_ordering; -- should not be ordered append -- regression introduced by #5599: -- for the case of a single chunk, there is an additional redundant sort node below decompress chunk -- this is due to pushing down the sort node below decompress chunk. In most cases that is beneficial, -- but here a more optimal plan would have been a mergeAppend. -- It was hard to include a path without pushed down sort for consideration, as `add_path` would reject -- the path with sort pushdown, which is desirable in most cases :PREFIX SELECT * FROM test_ordering ORDER BY 1; INSERT INTO test_ordering VALUES (105),(104),(103); VACUUM ANALYZE test_ordering; -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; --insert into compressed + uncompressed chunk INSERT INTO test_ordering VALUES (21), (22),(113); SELECT count(*) FROM test_ordering; INSERT INTO test_ordering VALUES (106) RETURNING *; -- insert into compressed chunk does support RETURNING INSERT INTO test_ordering VALUES (23), (24), (115) RETURNING *; INSERT INTO test_ordering VALUES (23), (24), (115) RETURNING tableoid::regclass, *; SELECT compress_chunk(format('%I.%I',chunk_schema,chunk_name), true) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_ordering'; VACUUM ANALYZE test_ordering; -- should be ordered append :PREFIX SELECT * FROM test_ordering ORDER BY 1; SET timescaledb.enable_decompression_sorted_merge = 1; -- TEST cagg triggers with insert into compressed chunk CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name from create_hypertable( 'conditions', 'timec'); INSERT INTO conditions SELECT generate_series('2010-01-01 09:00:00-08'::timestamptz, '2010-01-03 09:00:00-08'::timestamptz, '1 day'), 55 , 45; CREATE MATERIALIZED VIEW cagg_conditions WITH (timescaledb.continuous, timescaledb.materialized_only = true) AS SELECT time_bucket( '7 days', timec) bkt, count(*) cnt, sum(temperature) sumb FROM conditions GROUP BY time_bucket('7 days', timec); SELECT * FROM cagg_conditions ORDER BY 1; ALTER TABLE conditions SET (timescaledb.compress); SELECT compress_chunk(ch) FROM show_chunks('conditions') ch; SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'conditions'; --now insert into compressed chunk INSERT INTO conditions VALUES('2010-01-01 12:00:00-08', 10, 20); INSERT INTO conditions VALUES('2010-01-01 12:00:00-08', 10, 20); --refresh cagg, should have updated info CALL refresh_continuous_aggregate('cagg_conditions', NULL, '2011-01-01 12:00:00-08' ); SELECT * FROM cagg_conditions ORDER BY 1; -- TEST cagg triggers with copy into compressed chunk COPY conditions FROM STDIN DELIMITER ','; 2010-01-01 11:16:00-05,100,100 2010-01-01 11:17:00-05,100,100 2010-01-01 11:18:00-05,100,100 \. --refresh cagg, should have updated info CALL refresh_continuous_aggregate('cagg_conditions', NULL, '2011-01-01 12:00:00-08' ); SELECT * FROM cagg_conditions ORDER BY 1; -- TEST direct insert into internal compressed hypertable should be blocked CREATE TABLE direct_insert(time timestamptz not null); SELECT table_name FROM create_hypertable('direct_insert','time'); ALTER TABLE direct_insert SET(timescaledb.compress); SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "TABLENAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'direct_insert') \gset \set ON_ERROR_STOP 0 INSERT INTO :TABLENAME SELECT; \set ON_ERROR_STOP 1 -- Test that inserting into a compressed table works even when the -- column has been dropped. CREATE TABLE test4 ( timestamp timestamp without time zone not null, ident text not null, one double precision, two double precision ); SELECT * FROM create_hypertable('test4', 'timestamp'); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2021-10-14 17:50:16.207', '2' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2021-11-14 17:50:16.207', '1' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2021-12-14 17:50:16.207', '3' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-01-14 17:50:16.207', '4' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-02-14 17:50:16.207', '5' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-03-14 17:50:16.207', '6' ); INSERT INTO test4 ( timestamp, ident ) VALUES ( '2022-04-14 17:50:16.207', '7' ); ALTER TABLE test4 SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp', timescaledb.compress_segmentby = 'ident' ); select count(compress_chunk(ch)) FROM show_chunks('test4') ch; ALTER TABLE test4 DROP COLUMN two; INSERT INTO test4 VALUES ('2021-10-14 17:50:16.207', '7', NULL); INSERT INTO test4 (timestamp, ident) VALUES ('2021-10-14 17:50:16.207', '7'); DROP TABLE test4; -- Test COPY when trying to flush an empty buffer -- In this case we send an empty slot used to -- search for compressed tuples. CREATE TABLE test_copy ( timestamp int not null, id bigint ); CREATE UNIQUE INDEX timestamp_id_idx ON test_copy(timestamp, id); SELECT * FROM create_hypertable('test_copy', 'timestamp', chunk_time_interval=>10); ALTER TABLE test_copy SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp', timescaledb.compress_segmentby = 'id' ); INSERT INTO test_copy SELECT generate_series(1,25,1), -1; SELECT count(compress_chunk(ch)) FROM show_chunks('test_copy') ch; \copy test_copy FROM data/copy_data.csv WITH CSV HEADER; -- Also test the code path where the chunk insert state goes out of cache. set timescaledb.max_open_chunks_per_insert = 1; truncate table test_copy; INSERT INTO test_copy SELECT generate_series(1,25,1), -1; SELECT count(compress_chunk(ch)) FROM show_chunks('test_copy') ch; \copy test_copy FROM data/copy_data.csv WITH CSV HEADER; reset timescaledb.max_open_chunks_per_insert; DROP TABLE test_copy; -- Text limitting decompressed tuple during an insert CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>1000); INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; CREATE UNIQUE INDEX timestamp_id_idx ON test_limit(timestamp, id); ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'timestamp' ); SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; SET timescaledb.max_tuples_decompressed_per_dml_transaction = 1; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Inserting in the same period should decompress tuples INSERT INTO test_limit SELECT t, 2 FROM generate_series(1,6000,1000) t; -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; INSERT INTO test_limit SELECT t, 2 FROM generate_series(1,6000,1000) t; \set ON_ERROR_STOP 1 DROP TABLE test_limit; RESET timescaledb.max_tuples_decompressed_per_dml_transaction; -- test multiple unique constraints CREATE TABLE multi_unique (time timestamptz NOT NULL, u1 int, u2 int, value float, unique(time, u1), unique(time, u2)); SELECT table_name FROM create_hypertable('multi_unique', 'time'); ALTER TABLE multi_unique SET (timescaledb.compress, timescaledb.compress_segmentby = 'u1, u2'); INSERT INTO multi_unique VALUES('2024-01-01', 0, 0, 1.0); SELECT count(compress_chunk(c)) FROM show_chunks('multi_unique') c; \set ON_ERROR_STOP 0 -- all INSERTS should fail with constraint violation BEGIN; INSERT INTO multi_unique VALUES('2024-01-01', 0, 0, 1.0); ROLLBACK; BEGIN; INSERT INTO multi_unique VALUES('2024-01-01', 0, 1, 1.0); ROLLBACK; BEGIN; INSERT INTO multi_unique VALUES('2024-01-01', 1, 0, 1.0); ROLLBACK; \set ON_ERROR_STOP 1 DROP TABLE multi_unique; -- test insert with unique constraints and NULLs CREATE TABLE unique_null(time timestamptz NOT NULL, u1 int, u2 int, value float, unique(time, u1, u2)); SELECT table_name FROM create_hypertable('unique_null', 'time'); ALTER TABLE unique_null SET (timescaledb.compress, timescaledb.compress_segmentby = 'u1, u2'); INSERT INTO unique_null VALUES('2024-01-01', 0, 0, 1.0); SELECT count(compress_chunk(c)) FROM show_chunks('unique_null') c; \set ON_ERROR_STOP 0 -- all INSERTS should fail with constraint violation BEGIN; INSERT INTO unique_null VALUES('2024-01-01', 0, 0, 1.0); ROLLBACK; \set ON_ERROR_STOP 1 -- neither of these should need to decompress :ANALYZE INSERT INTO unique_null VALUES('2024-01-01', NULL, 1, 1.0); SELECT count(*) FROM unique_null; :ANALYZE INSERT INTO unique_null VALUES('2024-01-01', 1, NULL, 1.0); SELECT count(*) FROM unique_null; :ANALYZE INSERT INTO unique_null VALUES('2024-01-01', NULL, NULL, 1.0); SELECT count(*) FROM unique_null; INSERT INTO unique_null VALUES('2024-01-01', NULL, NULL, 1.0); SELECT count(*) FROM unique_null; DROP TABLE unique_null; -- test insert with UNIQUE constraint and all compression algorithms set timescaledb.enable_bool_compression = on; CREATE TABLE unique_all( time timestamptz NOT NULL, device_id int, bool_type bool, numeric_type numeric, float_type float, text_type text, bigint_type bigint, jsonb_type jsonb ); -- Since we don't test uniqueness when we detect a NULL value, making the constraint -- with NULLS NOT DISTINCT CREATE UNIQUE INDEX ultimate_unique ON unique_all(time, device_id, bool_type, numeric_type, float_type, text_type, bigint_type, jsonb_type) NULLS NOT DISTINCT; SELECT table_name FROM create_hypertable('unique_all', 'time'); ALTER TABLE unique_all SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:01', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:02', 1, false, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:03', 1, true, 2.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:04', 1, true, 1.0, 2.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:05', 1, true, 1.0, 1.0, 'second', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:06', 1, true, 1.0, 1.0, 'first', 2, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:07', 1, true, 1.0, 1.0, 'first', 1, '{"second":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:08', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:09', 1, NULL, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:10', 1, true, NULL, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:11', 1, true, 1.0, NULL, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:12', 1, true, 1.0, 1.0, NULL, 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:13', 1, true, 1.0, 1.0, 'first', NULL, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:14', 1, true, 1.0, 1.0, 'first', 1, NULL); SELECT count(compress_chunk(c)) FROM show_chunks('unique_all') c; -- test duplicates \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:01', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:02', 1, false, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:03', 1, true, 2.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:04', 1, true, 1.0, 2.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:05', 1, true, 1.0, 1.0, 'second', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:06', 1, true, 1.0, 1.0, 'first', 2, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:07', 1, true, 1.0, 1.0, 'first', 1, '{"second":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:08', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:09', 1, NULL, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:10', 1, true, NULL, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:11', 1, true, 1.0, NULL, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:12', 1, true, 1.0, 1.0, NULL, 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:13', 1, true, 1.0, 1.0, 'first', NULL, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:14', 1, true, 1.0, 1.0, 'first', 1, NULL); \set ON_ERROR_STOP 1 -- test non-duplicates INSERT INTO unique_all VALUES('2024-01-01 00:01:01', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:02', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:03', 1, true, 3.0, 1.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:04', 1, true, 1.0, 3.0, 'first', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:05', 1, true, 1.0, 1.0, 'third', 1, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:06', 1, true, 1.0, 1.0, 'first', 3, '{"first":true}'); INSERT INTO unique_all VALUES('2024-01-01 00:07', 1, true, 1.0, 1.0, 'first', 1, '{"third":true}'); -- test non-duplicates with non-NULL default values ALTER TABLE unique_all ADD COLUMN added_non_null int DEFAULT 4; DROP INDEX ultimate_unique; CREATE UNIQUE INDEX ultimate_unique ON unique_all(time, device_id, bool_type, numeric_type, float_type, text_type, bigint_type, jsonb_type, added_non_null) NULLS NOT DISTINCT; \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4); \set ON_ERROR_STOP 1 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 5); -- make sure everything is correct after recompressing the chunk SELECT count(decompress_chunk(c)) FROM show_chunks('unique_all') c; SELECT count(compress_chunk(c)) FROM show_chunks('unique_all') c; \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4); \set ON_ERROR_STOP 1 -- test non-duplicates with NULL default values ALTER TABLE unique_all ADD COLUMN added_null int DEFAULT NULL; DROP INDEX ultimate_unique; CREATE UNIQUE INDEX ultimate_unique ON unique_all(time, device_id, bool_type, numeric_type, float_type, text_type, bigint_type, jsonb_type, added_non_null, added_null) NULLS NOT DISTINCT; \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4, NULL); INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 5, NULL); \set ON_ERROR_STOP 1 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 6, NULL); -- make sure everything is correct after recompressing the chunk SELECT count(decompress_chunk(c)) FROM show_chunks('unique_all') c; SELECT count(compress_chunk(c)) FROM show_chunks('unique_all') c; \set ON_ERROR_STOP 0 INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 4, NULL); INSERT INTO unique_all VALUES('2024-01-01 00:00', 1, true, 1.0, 1.0, 'first', 1, '{"first":true}', 5, NULL); \set ON_ERROR_STOP 1 DROP TABLE unique_all; -- test NULL compression algorithm CREATE TABLE unique_null( time timestamptz NOT NULL, device_id int, tag text, tag2 text, value float ); CREATE UNIQUE INDEX unique_nulls ON unique_null(time, device_id, tag, tag2) NULLS NOT DISTINCT; SELECT table_name FROM create_hypertable('unique_null', 'time'); ALTER TABLE unique_null SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); INSERT INTO unique_null VALUES ('2024-01-01 00:00', 1, NULL, '1', 1), ('2024-01-01 00:00', 1, NULL, '2', 2), ('2024-01-01 00:00', 1, NULL, '3', 3); SELECT count(compress_chunk(c)) FROM show_chunks('unique_null') c; \set ON_ERROR_STOP 0 INSERT INTO unique_null VALUES ('2024-01-01 00:00', 1, NULL, '1', 1); \set ON_ERROR_STOP 1 ALTER TABLE unique_null ADD COLUMN tag3 text DEFAULT 'default value'; DROP INDEX unique_nulls; CREATE UNIQUE INDEX unique_nulls ON unique_null(time, device_id, tag, tag2, tag3) NULLS NOT DISTINCT; \set ON_ERROR_STOP 0 INSERT INTO unique_null VALUES ('2024-01-01 00:00', 1, NULL, '1', 1, 'default value'); \set ON_ERROR_STOP 1 INSERT INTO unique_null VALUES ('2024-01-01 00:01', 1, NULL, '1', 1, 'default value'), ('2024-01-01 00:00', 2, NULL, '1', 1, 'default value'); DROP TABLE unique_null; -- test NUMERIC data type CREATE TABLE unique_numeric( time timestamptz NOT NULL, device_id numeric(6,2) NOT NULL, tag text, tag2 text, value float ); CREATE UNIQUE INDEX unique_numeric_idx ON unique_numeric(time, device_id, tag, tag2); SELECT table_name FROM create_hypertable('unique_numeric', 'time'); ALTER TABLE unique_numeric SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); INSERT INTO unique_numeric VALUES ('2024-01-01 00:00', 1.1, NULL, '1', 1), ('2024-01-01 00:00', 1.2, NULL, '2', 2), ('2024-01-01 00:00', 1.3, NULL, '3', 3); SELECT count(compress_chunk(c)) FROM show_chunks('unique_numeric') c; INSERT INTO unique_numeric VALUES ('2024-01-01 00:00', 1.4, NULL, '1', 1); DROP TABLE unique_numeric; -- test UUID data type CREATE TABLE unique_uuid( time timestamptz NOT NULL, device_id UUID NOT NULL, tag text, tag2 text, value float ); CREATE UNIQUE INDEX unique_uuid_idx ON unique_uuid(time, device_id, tag, tag2); SELECT table_name FROM create_hypertable('unique_uuid', 'time'); ALTER TABLE unique_uuid SET (tsdb.compress, tsdb.compress_segmentby = 'device_id', tsdb.compress_orderby = 'time'); INSERT INTO unique_uuid VALUES ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000000', NULL, '1', 1), ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000000', NULL, '1', 2), ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000001', NULL, '1', 1), ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000001', NULL, '1', 2); SELECT count(compress_chunk(c)) FROM show_chunks('unique_uuid') c; INSERT INTO unique_uuid VALUES ('2024-01-01 00:00', '018a0d1a-8e6a-7000-8000-000000000001', NULL, '1', 3); DROP TABLE unique_uuid; -- regression test for SDC 3006 CREATE TABLE t_1sec( "timestamp" timestamp with time zone NOT NULL, device_id text, speed double precision, derived boolean ); ALTER TABLE t_1sec ADD CONSTRAINT unique_device_timestamp_sensor_derived UNIQUE (device_id, "timestamp", derived); CREATE INDEX t_1sec_timestamp_idx ON t_1sec USING btree ("timestamp" DESC); SELECT create_hypertable( relation => 't_1sec', time_column_name => 'timestamp', chunk_time_interval => interval '06:00:00', create_default_indexes => false ); ALTER TABLE t_1sec SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id', timescaledb.compress_orderby='"timestamp"' ); insert into t_1sec ( "timestamp", device_id, speed, derived) values ( '2025-06-06 10:00:00', 'device_id_1', 100, true), ( '2025-06-06 10:01:00', 'device_id_2', 100, true), ( '2025-06-06 10:02:00', 'device_id_3', 100, true); SELECT compress_chunk(show_chunks('t_1sec')); insert into t_1sec ( "timestamp", device_id, speed, derived) values ( '2025-06-06 10:03:00', 'device_id_1', 100, true), ( '2025-06-06 10:00:00', 'device_id_1', 110, true), ( '2025-06-06 10:00:00', 'device_id_1', 110, false) ON CONFLICT DO NOTHING; DROP TABLE t_1sec; -- regression test for SDC 3210 CREATE TABLE gen_column( "timestamp" timestamp with time zone NOT NULL, device_id text, device_id_generated text GENERATED ALWAYS AS (device_id) STORED, speed double precision ); ALTER TABLE gen_column ADD CONSTRAINT unique_device_timestamp_sensor UNIQUE (device_id_generated, "timestamp"); CREATE INDEX gen_column_timestamp_idx ON gen_column USING btree ("timestamp" DESC); SELECT create_hypertable( relation => 'gen_column', time_column_name => 'timestamp', chunk_time_interval => interval '06:00:00', create_default_indexes => false ); ALTER TABLE gen_column SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id_generated', timescaledb.compress_orderby='"timestamp"' ); insert into gen_column ( "timestamp", device_id, speed) values ( '2025-06-06 10:00:00', 'device_id_1', 100), ( '2025-06-06 10:01:00', 'device_id_2', 100), ( '2025-06-06 10:02:00', 'device_id_3', 100); SELECT compress_chunk(show_chunks('gen_column')); insert into gen_column ( "timestamp", device_id, speed) values ( '2025-06-06 10:03:00', 'device_id_1', 100), ( '2025-06-06 10:00:00', 'device_id_1', 110), ( '2025-06-06 10:00:00', 'device_id_1', 110) ON CONFLICT DO NOTHING; -- should contain 2 rows for device_1 and one per any other device SELECT device_id_generated, count(*) FROM gen_column GROUP BY 1 ORDER BY 1; SELECT decompress_chunk(show_chunks('gen_column')); ALTER TABLE gen_column SET ( timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby='"timestamp"' ); SELECT compress_chunk(show_chunks('gen_column')); insert into gen_column ( "timestamp", device_id, speed) values ( '2025-06-06 10:04:00', 'device_id_1', 100), ( '2025-06-06 10:00:00', 'device_id_1', 110), ( '2025-06-06 10:00:00', 'device_id_1', 110) ON CONFLICT DO NOTHING; -- should contain 3 rows for device_1 and one per any other device SELECT device_id_generated, count(*) FROM gen_column GROUP BY 1 ORDER BY 1; DROP TABLE gen_column; -- test insert into compressed chunk directly works -- to ensure maintenance operations work unhindered we dont -- want to block direct inserts into compressed chunks CREATE TABLE direct_compressed_insert (time timestamptz) WITH (tsdb.hypertable); INSERT INTO direct_compressed_insert SELECT generate_series('2024-01-01'::timestamptz, '2024-01-01 1:00:00'::timestamptz, '1 second'); SELECT count(compress_chunk(c)) FROM show_chunks('direct_compressed_insert') c; SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ORDER BY id DESC LIMIT 1 \gset CREATE TABLE compressed_batches AS SELECT * FROM :CHUNK; SELECT _ts_meta_count, count(*) FROM :CHUNK GROUP BY _ts_meta_count ORDER BY 1 DESC; -- should have not ModifyHypertable node EXPLAIN (costs off,timing off, summary off) INSERT INTO :CHUNK SELECT * FROM compressed_batches; INSERT INTO :CHUNK SELECT * FROM compressed_batches; SELECT _ts_meta_count, count(*) FROM :CHUNK GROUP BY _ts_meta_count ORDER BY 1 DESC; ����������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_merge.sql�����������������������������������������������0000664�0000000�0000000�00000040461�15100345067�0022701�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/rand_generator.sql \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE test1 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- This will generate 24 chunks INSERT INTO test1 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); SELECT $$ SELECT * FROM test1 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test1' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql DROP TABLE test1; CREATE TABLE test2 ("Time" timestamptz, i integer, loc integer, value integer); SELECT table_name from create_hypertable('test2', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- This will generate 24 1 hour chunks. INSERT INTO test2 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Setting compression with time DESC to confirm we are don't have to recompress due to DESC order -- This is made possible by removal of sequence numbers \set VERBOSITY default ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time" DESC', timescaledb.compress_chunk_time_interval='10 hours'); \set VERBOSITY terse -- Verify we are not generating unordered chunks BEGIN; SELECT count(compress_chunk(chunk, true)) FROM show_chunks('test2') chunk; SELECT format('%I.%I',ch.schema_name,ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ch JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id JOIN _timescaledb_catalog.hypertable ht2 ON ht.id=ht2.compressed_hypertable_id AND ht2.table_name='test2' LIMIT 1 \gset -- We want to sure we are not fully recompressing them which will make -- the chunk contain multiple batches per segment group SELECT count(*) FROM :CHUNK WHERE i = 1; ROLLBACK; -- Compression is set to merge those 24 chunks into 3 chunks, two 10 hour chunks and a single 4 hour chunk. \set VERBOSITY default ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='loc,"Time"', timescaledb.compress_chunk_time_interval='10 hours'); \set VERBOSITY terse -- Verify we are fully recompressing unordered chunks BEGIN; SELECT count(compress_chunk(chunk, true)) FROM show_chunks('test2') chunk; SELECT format('%I.%I',ch.schema_name,ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ch JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id JOIN _timescaledb_catalog.hypertable ht2 ON ht.id=ht2.compressed_hypertable_id AND ht2.table_name='test2' LIMIT 1 \gset -- Not using time as first column in orderby makes the merged chunks unordered -- We want to sure we are fully recompressing them which will make only -- a single batch per segment group SELECT count(*) FROM :CHUNK WHERE i = 1; ROLLBACK; SELECT $$ SELECT * FROM test2 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test2' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql \set TYPE integer \set ORDER_BY_COL_NAME loc \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql DROP TABLE test2; CREATE TABLE test3 ("Time" timestamptz, i integer, loc integer, value integer); SELECT table_name from create_hypertable('test3', 'Time', chunk_time_interval=> INTERVAL '1 hour'); SELECT table_name from add_dimension('test3', 'i', number_partitions=> 3); -- This will generate 25 1 hour chunks with a closed space dimension. INSERT INTO test3 SELECT t, 1, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 12:59', '1 minute') t; INSERT INTO test3 SELECT t, 2, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 13:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t; INSERT INTO test3 SELECT t, 3, gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 2:00'::TIMESTAMPTZ, '2018-03-02 2:01', '1 minute') t; -- Compression is set to merge those 25 chunks into 12 2 hour chunks and a single 1 hour chunks on a different space dimensions. \set VERBOSITY default ALTER TABLE test3 set (timescaledb.compress, timescaledb.compress_orderby='loc,"Time"', timescaledb.compress_chunk_time_interval='2 hours'); \set VERBOSITY terse SELECT $$ SELECT * FROM test3 WHERE i = 1 ORDER BY "Time" $$ AS "QUERY" \gset SELECT 'test3' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql \set TYPE integer \set ORDER_BY_COL_NAME loc \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql DROP TABLE test3; CREATE TABLE test4 ("Time" timestamptz, i integer, loc integer, value integer); SELECT table_name from create_hypertable('test4', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- Setting compress_chunk_time_interval to non-multiple of chunk_time_interval should emit a warning. \set VERBOSITY default ALTER TABLE test4 set (timescaledb.compress, timescaledb.compress_orderby='loc,"Time"', timescaledb.compress_chunk_time_interval='90 minutes'); \set VERBOSITY terse DROP TABLE test4; CREATE TABLE test5 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test5', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- This will generate 24 chunks. Note that we are forcing everyting into a single segment so we use table scan to when merging chunks. INSERT INTO test5 SELECT t, 1, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t; -- Compression is set to merge those 24 chunks into 1 24 hour chunk ALTER TABLE test5 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='24 hours'); SELECT $$ SELECT * FROM test5 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT compress_chunk(i) FROM show_chunks('test5') i LIMIT 4; SELECT format('%I.%I',ch.schema_name,ch.table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk ch JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id JOIN _timescaledb_catalog.hypertable ht2 ON ht.id=ht2.compressed_hypertable_id AND ht2.table_name='test5' \gset SELECT schemaname || '.' || indexname AS "INDEXNAME" FROM pg_indexes i INNER JOIN _timescaledb_catalog.chunk cc ON i.schemaname = cc.schema_name and i.tablename = cc.table_name INNER JOIN _timescaledb_catalog.chunk c ON (cc.id = c.compressed_chunk_id) LIMIT 1 \gset DROP INDEX :INDEXNAME; -- Merging works without indexes on compressed chunks SELECT compress_chunk(i, true) FROM show_chunks('test5') i LIMIT 5; SELECT 'test5' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql DROP TABLE test5; CREATE TABLE test6 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test6', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- This will generate 24 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks. ALTER TABLE test6 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); SELECT compress_chunk(i) FROM show_chunks('test6') i; SELECT count(*) as number_of_chunks FROM show_chunks('test6'); -- This will generate another 24 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-03 1:00'::TIMESTAMPTZ, '2018-03-04 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Altering compress chunk time interval will cause us to create 6 chunks from the additional 24 chunks. ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval='4 hours'); SELECT compress_chunk(i, true) FROM show_chunks('test6') i; SELECT count(*) as number_of_chunks FROM show_chunks('test6'); -- This will generate another 3 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-04 1:00'::TIMESTAMPTZ, '2018-03-04 3:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Altering compress chunk time interval will cause us to create 3 chunks from the additional 3 chunks. -- Setting compressed chunk to anything less than chunk interval should disable merging chunks. ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval='30 minutes'); SELECT compress_chunk(i, true) FROM show_chunks('test6') i; SELECT count(*) as number_of_chunks FROM show_chunks('test6'); -- This will generate another 3 chunks INSERT INTO test6 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-04 4:00'::TIMESTAMPTZ, '2018-03-04 6:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Altering compress chunk time interval will cause us to create 3 chunks from the additional 3 chunks. -- Setting compressed chunk to anything less than chunk interval should disable merging chunks. ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval=0); SELECT compress_chunk(i, true) FROM show_chunks('test6') i; SELECT count(*) as number_of_chunks FROM show_chunks('test6'); -- Setting compress chunk time to NULL will error out. \set ON_ERROR_STOP 0 ALTER TABLE test6 set (timescaledb.compress_chunk_time_interval=NULL); \set ON_ERROR_STOP 1 DROP TABLE test6; CREATE TABLE test7 ("Time" timestamptz, i integer, j integer, k integer, value integer); SELECT table_name from create_hypertable('test7', 'Time', chunk_time_interval=> INTERVAL '1 hour'); -- This will generate 24 chunks INSERT INTO test7 SELECT t, i, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks with ordering by j column before time column, causing recompression to occur during merge. ALTER TABLE test7 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='j, "Time" desc', timescaledb.compress_chunk_time_interval='2 hours'); SELECT $$ SELECT * FROM test7 ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test7' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql DROP TABLE test7; --#5090 CREATE TABLE test8(time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL); SELECT create_hypertable('test8', 'time', chunk_time_interval => INTERVAL '1 h'); ALTER TABLE test8 set (timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time', timescaledb.compress_chunk_time_interval = '1 day'); INSERT INTO test8 (time, series_id, value) SELECT t, s, 1 FROM generate_series(NOW(), NOW()+INTERVAL'4h', INTERVAL '30s') t CROSS JOIN generate_series(0, 100, 1) s; SELECT compress_chunk(c, true) FROM show_chunks('test8') c LIMIT 4; SET enable_indexscan TO OFF; SET enable_seqscan TO OFF; SET enable_bitmapscan TO ON; SELECT count(*) FROM test8 WHERE series_id = 1; -- Verify rollup is prevented when compression settings differ CREATE TABLE test9(time TIMESTAMPTZ NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL); SELECT create_hypertable('test9', 'time', chunk_time_interval => INTERVAL '1 h'); ALTER TABLE test9 set (timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time', timescaledb.compress_chunk_time_interval = '1 day'); -- create chunk and compress INSERT INTO test9 (time, series_id, value) SELECT '2020-01-01 00:00:00'::TIMESTAMPTZ, 1, 1; SELECT compress_chunk(show_chunks('test9'), true); INSERT INTO test9 (time, series_id, value) SELECT '2020-01-01 01:00:00'::TIMESTAMPTZ, 1, 1; -- should be 2 chunk before rollup SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; SELECT compress_chunk(show_chunks('test9'), true); -- should be 1 chunk because of rollup SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; INSERT INTO test9 (time, series_id, value) SELECT '2020-01-01 02:00:00'::TIMESTAMPTZ, 1, 1; -- should be 2 chunks again SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; ALTER TABLE test9 SET (timescaledb.compress_segmentby = ''); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); -- should not be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; ROLLBACK; ALTER TABLE test9 SET (timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time DESC'); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); -- should not be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; ROLLBACK; ALTER TABLE test9 SET (timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time NULLS FIRST'); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); -- should not be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; ROLLBACK; -- reset back to original settings ALTER TABLE test9 SET (timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'time'); BEGIN; SELECT compress_chunk(show_chunks('test9'), true); -- should be rolled up SELECT hypertable_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = 'test9' ORDER BY 2; ROLLBACK; -- Test RowExclusiveLock on compressed chunk during chunk rollup using a GUC CREATE TABLE test10 ("Time" timestamptz, i integer, value integer); SELECT table_name from create_hypertable('test10', 'Time', chunk_time_interval=> INTERVAL '1 hour'); INSERT INTO test10 SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-02 3:59', '10 minutes') t CROSS JOIN generate_series(1, 3, 1) i; ALTER TABLE test10 set (timescaledb.compress, timescaledb.compress_segmentby='i', timescaledb.compress_orderby='"Time"', timescaledb.compress_chunk_time_interval='2 hours'); SHOW timescaledb.enable_rowlevel_compression_locking; SET timescaledb.enable_rowlevel_compression_locking to on; SELECT compress_chunk(show_chunks('test10')); RESET timescaledb.enable_rowlevel_compression_locking; DROP TABLE test10; RESET enable_indexscan; RESET enable_seqscan; RESET enable_bitmapscan; -- Test chunk merging with default compression settings CREATE TABLE test_defaults ("Time" timestamptz, i integer, value integer) WITH (tsdb.hypertable, tsdb.chunk_interval='1 hour'); CREATE INDEX ON test_defaults (i); ALTER TABLE test_defaults set (timescaledb.compress, timescaledb.compress_chunk_time_interval='2 hours'); SELECT delete_job(1000); -- This will generate 24 chunks INSERT INTO test_defaults SELECT t, i, gen_rand_minstd() FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-03 0:59', '1 minute') t CROSS JOIN generate_series(1, 5, 1) i; -- Compression is set to merge those 24 chunks into 12 2 hour chunks SELECT $$ SELECT * FROM test_defaults ORDER BY i, "Time" $$ AS "QUERY" \gset SELECT 'test_defaults' AS "HYPERTABLE_NAME" \gset \ir include/compression_test_merge.sql \set TYPE timestamptz \set ORDER_BY_COL_NAME Time \set SEGMENT_META_COL_MIN _ts_meta_min_1 \set SEGMENT_META_COL_MAX _ts_meta_max_1 \ir include/compression_test_hypertable_segment_meta.sql DROP TABLE test_defaults; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_null_dump_restore.sql�����������������������������������0000664�0000000�0000000�00000003362�15100345067�0025343�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This test is to verify fixing the behaviour reported in: SDC #2912 -- Create destination database \set TEST_DBNAME_3 :TEST_DBNAME _3 \c postgres :ROLE_SUPERUSER CREATE DATABASE :TEST_DBNAME_3; \c :TEST_DBNAME_3 :ROLE_SUPERUSER create extension timescaledb CASCADE; -- Create source database \set TEST_DBNAME_2 :TEST_DBNAME _2 \c postgres :ROLE_SUPERUSER CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER create extension timescaledb CASCADE; -- Create compressed table with one column having all NULL -- values, so it will be compressed with the NULL algorithm -- create table null_dump (ts int primary key, n int); select create_hypertable('null_dump', 'ts'); insert into null_dump values (1), (2), (3), (4); alter table null_dump set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); select compress_chunk(show_chunks('null_dump')); -- Dump the content of the source database \setenv TEST_DBNAME :TEST_DBNAME_2 \setenv DUMP_OPTIONS '--quote-all-identifiers --no-tablespaces --no-owner --no-privileges --exclude-schema=test' \c postgres :ROLE_SUPERUSER \! utils/pg_dump_aux_plain_dump.sh dump/null-compress-dump.sql -- Restore the data into the destination database \c :TEST_DBNAME_3 :ROLE_SUPERUSER select public.timescaledb_pre_restore(); \set ECHO none \o /dev/null SET client_min_messages = 'error'; \i dump/null-compress-dump.sql \o \set ECHO queries select public.timescaledb_post_restore(); select * from public.null_dump order by 1; \c postgres :ROLE_SUPERUSER drop database :TEST_DBNAME_2 WITH (FORCE); drop database :TEST_DBNAME_3 WITH (FORCE); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_nulls_and_defaults.sql����������������������������������0000664�0000000�0000000�00000024217�15100345067�0025451�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- test case #1: altering a compressed hypertable by adding a new column -- with a default value -- -- The point of this test is to verify the behaviour of the default value if -- the hypertable is compressed before the new column is added. -- It adds rows before and after the column is added to make sure that the -- default value is returned correctly in both cases. This is to make sure -- that changing the code related to the default value does not break the -- behaviour of the default values. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); alter table t add column a double precision default 7.1; select * from t; select compress_chunk(show_chunks('t')); select * from t; insert into t (ts,c1) values (7,7); select compress_chunk(show_chunks('t')); select * from t; set timescaledb.enable_segmentwise_recompression to on; -- test case #2: altering an uncompressed hypertable by adding a new column -- with a default value -- -- This is another test case to check that the correct behaviour is preserved -- after changing the code related to the default value. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); alter table t add column a double precision default 7.1; insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); update t set a = null; select compress_chunk(show_chunks('t')); select * from t; insert into t (ts,c1) values (7,7); update t set a = null; select compress_chunk(show_chunks('t')); select * from t; -- test case #3: altering an uncompressed hypertable by adding a new column -- with a default value -- -- This is one more testcase for establishing the correct behaviour of the -- default value after changing the code related to the default value. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); alter table t add column a double precision default 7.1; insert into t (ts,c1) values (4,4); insert into t (ts,c1) values (5,5); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); update t set a = null; select * from t; select compress_chunk(show_chunks('t')); select * from t; set timescaledb.enable_segmentwise_recompression to on; -- test case #4: altering a compressed hypertable by adding a new column -- with a default value -- -- This is one more testcase for establishing the correct behaviour of the -- default value after changing the code. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); alter table t add column a double precision default 7.1; insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); select * from t; update t set a = null; insert into t (ts,c1) values (7,7); update t set a = null; select compress_chunk(show_chunks('t')); select * from t; -- test case #5: altering an uncompressed hypertable by adding a new column -- with a default value -- -- This is the first testcase to reproduce the problem found by Sven. -- Before the fix, the default value was not returned correctly after -- compressing the hypertable. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t (ts int); select create_hypertable('t', 'ts'); alter table t set(timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t (ts) values (1); alter table t add column c1 double precision default 42.99; update t set c1 = null; select * from t; select compress_chunk(show_chunks('t')); select * from t; set timescaledb.enable_segmentwise_recompression to on; -- test case #6: altering a compressed hypertable by adding a new column -- with a default value -- -- This is the second testcase to reproduce the problem, by Alex. -- Before the fix, the default value was not returned correctly after -- compressing the hypertable the second time. -- drop table if exists t; create table t(ts int); select create_hypertable('t', 'ts'); insert into t values (1); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); select compress_chunk(show_chunks('t')); alter table t add column a double precision default 7.987; insert into t values (2, null); select * from t; select compress_chunk(show_chunks('t')); select * from t; -- test case #7: a variation of #1 where -- the default value is changed after the column is added -- -- This is a variation of the first test case where the default value is -- changed after the column is added. This is to make sure that changing the -- default value does not break the behaviour of the default values. -- set timescaledb.enable_segmentwise_recompression to off; drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); alter table t add column a double precision default 7.1; select * from t; select compress_chunk(show_chunks('t')); select * from t; alter table t alter column a set default 7.2; insert into t (ts,c1) values (7,7); select compress_chunk(show_chunks('t')); select * from t; set timescaledb.enable_segmentwise_recompression to on; -- test case #8: a variation of #5 and #7 where -- I change the default value multiple times -- -- This is a variation of the previous test cases with changing the default -- values. Before the fix the first default value was returned for all rows -- even if it was changed twice afterwards and the value was set to null. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); alter table t add column a double precision default 7.1; alter table t alter column a set default 8.2; insert into t (ts,c1) values (7,7); select * from t; select compress_chunk(show_chunks('t')); select * from t; alter table t alter column a set default 9.3; insert into t (ts,c1) values (8,8); select * from t; update t set a = null; select * from t; select compress_chunk(show_chunks('t')); select * from t; -- test case #9: a variation of the previous ones with the twist -- of updating another column which triggers decompression and -- risk of re-applying the default value for the other column. -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t (ts,c1) values (6,6); select compress_chunk(show_chunks('t')); alter table t add column a double precision default 7.1; select compress_chunk(show_chunks('t')); select * from t; update t set a = null; select compress_chunk(show_chunks('t')); select * from t; update t set c1 = 99, a = null; select * from t; select compress_chunk(show_chunks('t')); select * from t; update t set c1 = 98; select * from t; -- test case #10: adding a few columns to a compressed hypertable -- and then updating them to null and dropping them -- drop table if exists t; create table t(ts int, c1 int); select create_hypertable('t','ts'); alter table t set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into t (ts,c1) values (1,1); select compress_chunk(show_chunks('t')); alter table t add column a double precision default 3.3; insert into t (ts,c1) values (2,2); select compress_chunk(show_chunks('t')); select * from t; alter table t add column b double precision default 4.4; insert into t (ts,c1) values (3,3); select compress_chunk(show_chunks('t')); select * from t; update t set a = null; select compress_chunk(show_chunks('t')); select * from t; alter table t add column c double precision; insert into t (ts,c1) values (4,4); select compress_chunk(show_chunks('t')); select * from t; update t set b = null; select compress_chunk(show_chunks('t')); select * from t; alter table t drop column a; update t set b = null; select compress_chunk(show_chunks('t')); select * from t; alter table t drop column b; update t set c = null; select compress_chunk(show_chunks('t')); select * from t; -- this is to make codecove happy so we exercise some -- code paths that are hard to do through the unit tests drop table if exists codecov; create table codecov(ts int, c1 int); select create_hypertable('codecov','ts'); alter table codecov set (timescaledb.compress, timescaledb.compress_orderby = 'ts'); insert into codecov (ts,c1) values (1,NULL); select compress_chunk(show_chunks('codecov')); DO $$ DECLARE comp_regclass REGCLASS; rec RECORD; BEGIN FOR comp_regclass IN SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as comp_regclass FROM _timescaledb_catalog.chunk uncomp, _timescaledb_catalog.chunk comp, (SELECT show_chunks('codecov') as c) as x WHERE uncomp.dropped IS FALSE AND uncomp.compressed_chunk_id IS NOT NULL AND comp.id = uncomp.compressed_chunk_id AND x.c = format('%I.%I', uncomp.schema_name, uncomp.table_name)::regclass LOOP -- codecov to record coverage of 'tsl_compressed_data_info' FOR rec IN EXECUTE format('SELECT c1, _timescaledb_functions.compressed_data_info(c1) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Compressed info results: %', rec; END LOOP; -- codecov to record coverage of 'tsl_compressed_data_has_nulls' FOR rec IN EXECUTE format('SELECT c1, _timescaledb_functions.compressed_data_has_nulls(c1) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Has nulls results: %', rec; END LOOP; END LOOP; END; $$; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_permissions.sql.in��������������������������������������0000664�0000000�0000000�00000017315�15100345067�0024564�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 CREATE VIEW hypertable_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ct.schema_name, ct.table_name) FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed, (SELECT relacl FROM names WHERE ct.schema_name = nspname AND ct.table_name = relname) AS compressed_acl FROM _timescaledb_catalog.hypertable ht LEFT JOIN _timescaledb_catalog.hypertable ct ON ht.compressed_hypertable_id = ct.id; CREATE VIEW chunk_details AS WITH names AS (SELECT * FROM pg_class cl JOIN pg_namespace ns ON ns.oid = relnamespace) SELECT (SELECT format('%I.%I', ht.schema_name, ht.table_name) FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable, (SELECT relacl FROM names WHERE ht.schema_name = nspname AND ht.table_name = relname) AS hypertable_acl, (SELECT format('%I.%I', ch.schema_name, ch.table_name) FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk, (SELECT relacl FROM names WHERE ch.schema_name = nspname AND ch.table_name = relname) AS chunk_acl FROM _timescaledb_catalog.hypertable ht JOIN _timescaledb_catalog.chunk ch ON ch.hypertable_id = ht.id; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, location2 char(10) NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=>'1month'::interval); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --now owner tries and succeeds -- alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 'klick', 55, 75; --try modifying compress properties -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 alter table conditions set (timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'humidity'); --- compress_chunks and decompress_chunks fail without correct perm -- \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 SELECT compress_chunk(show_chunks('conditions')); SELECT decompress_chunk(show_chunks('conditions')); select add_compression_policy('conditions', '1day'::interval); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select add_compression_policy('conditions', '1day'::interval); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 --try dropping policy select remove_compression_policy('conditions', true); --Tests for GRANTS. -- as owner grant select , compress chunk and check SELECT works \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT SELECT on conditions to :ROLE_DEFAULT_PERM_USER_2; SELECT count(compress_chunk(ch)) FROM show_chunks('conditions') ch; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from conditions; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT INSERT on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 insert into conditions select '2019-04-01 00:00+0'::timestamp with time zone, 'NYC', 'klick', 55, 75; select count(*) from conditions; update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER GRANT UPDATE, DELETE on conditions to :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select location from conditions where timec = '2019-04-01 00:00+0'; --NOTE constraint exclusion excludes the other chunks here --otherwise update would fail update conditions set location = 'SFO' where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; --update expected to fail as executor touches all chunks update conditions set location = 'PNC' where location = 'SFO'; delete from conditions where timec = '2019-04-01 00:00+0'::timestamp with time zone; select location from conditions where timec = '2019-04-01 00:00+0'; CREATE VIEW v2 as select * from conditions; select count(*) from v2; --should fail after revoking permissions \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER REVOKE SELECT on conditions FROM :ROLE_DEFAULT_PERM_USER_2; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 select count(*) from v2; \c :TEST_DBNAME :ROLE_SUPERUSER DROP TABLE conditions CASCADE; -- Testing that permissions propagate to compressed hypertables and to -- compressed chunks. -- Table is created by superuser CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable( 'conditions', 'timec', chunk_time_interval => '1 week'::interval); ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'location', timescaledb.compress_orderby = 'timec' ); INSERT INTO conditions SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75; SELECT compress_chunk(show_chunks('conditions')); -- Check that ACL propagates to compressed hypertable. We could prune -- the listing by only selecting chunks where the ACL does not match -- the hypertable ACL, but for now we list all to make debugging easy. \x on SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; GRANT SELECT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT * FROM hypertable_details WHERE hypertable = 'public.conditions'; SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; -- Add some new data and compress the chunks. The chunks should get -- the permissions of the hypertable. We pick a start date to make -- sure that we are not inserting into an already compressed chunk. INSERT INTO conditions SELECT generate_series('2019-01-07 00:00'::timestamp, '2019-02-07 00:00'::timestamp, '1 day'), 'XYZ', 47, 11; SELECT compress_chunk(show_chunks('conditions', newer_than => '2019-01-01')); SELECT htd.hypertable, htd.hypertable_acl, chunk, chunk_acl FROM chunk_details chd JOIN hypertable_details htd ON chd.hypertable = htd.compressed ORDER BY hypertable, chunk; \x off --TEST user that has insert permission can insert into a compressed chunk GRANT INSERT ON conditions TO :ROLE_DEFAULT_PERM_USER; SELECT count(*) FROM conditions; SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; SET ROLE :ROLE_DEFAULT_PERM_USER; --insert into a compressed chunk -- INSERT INTO conditions VALUES( '2018-12-02 00:00'::timestamp, 'NYC', 75, 95); SELECT count(*) FROM conditions; SELECT count(*) FROM ( SELECT show_chunks('conditions'))q; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_policy.sql����������������������������������������������0000664�0000000�0000000�00000006164�15100345067�0023103�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. ---- -- Chunk interval 1 month - compression schedule interval should be 12 hours ---- CREATE TABLE sensor_data_1month( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1month', 'time', chunk_time_interval => INTERVAL '1 month'); ALTER TABLE sensor_data_1month SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1month','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; ---- -- Chunk interval 1 week - compression schedule interval should be 12 hours ---- CREATE TABLE sensor_data_1week( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1week', 'time', chunk_time_interval => INTERVAL '1 week'); ALTER TABLE sensor_data_1week SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1week','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; ---- -- Chunk interval 1 day - compression schedule interval should be 12 hours ---- CREATE TABLE sensor_data_1day( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1day', 'time', chunk_time_interval => INTERVAL '1 day'); ALTER TABLE sensor_data_1day SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1day','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; ---- -- Chunk interval 1 hour - compression schedule interval should be 30 minutes ---- CREATE TABLE sensor_data_1hour( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1hour', 'time', chunk_time_interval => INTERVAL '1 hour'); ALTER TABLE sensor_data_1hour SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1hour','7 days'::INTERVAL) as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; ---- -- Chunk interval 1 hour - compression schedule is set to a custom value ---- CREATE TABLE sensor_data_1hour_custom( time timestamptz not null, sensor_id integer not null ); SELECT FROM create_hypertable('sensor_data_1hour_custom', 'time', chunk_time_interval => INTERVAL '1 hour'); ALTER TABLE sensor_data_1hour_custom SET (timescaledb.compress); -- Add a compression policy and check the schedule interval SELECT add_compression_policy('sensor_data_1hour_custom','7 days'::INTERVAL, schedule_interval => '7 days') as compression_job \gset SELECT schedule_interval from timescaledb_information.jobs where job_id = :compression_job; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_qualpushdown.sql����������������������������������������0000664�0000000�0000000�00000025360�15100345067�0024335�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. set max_parallel_workers_per_gather = 0; -- qual pushdown tests for decompresschunk --- -- Test qual pushdown with ints CREATE TABLE meta (device_id INT PRIMARY KEY); CREATE TABLE hyper( time INT NOT NULL, device_id INT REFERENCES meta(device_id) ON DELETE CASCADE ON UPDATE CASCADE, val INT); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO meta VALUES (1), (2), (3), (4), (5); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2); SELECT ch1.table_name AS "CHUNK_NAME", ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' ORDER BY ch1.id LIMIT 1 \gset SELECT compress_chunk(:'CHUNK_FULL_NAME'); VACUUM FULL ANALYZE hyper; -- test for qual pushdown explain (buffers off, costs off, verbose) SELECT FROM hyper WHERE time > 2::bigint and time < 4; explain (buffers off, costs off, verbose) SELECT FROM hyper WHERE time = 3::bigint; SELECT * FROM hyper WHERE time > 2::bigint and time < 4; SELECT * FROM hyper WHERE time = 3::bigint; SELECT * FROM hyper where time = val + 1; -- Test some volatile and stable functions SET timescaledb.enable_chunk_append TO OFF; SET timescaledb.enable_constraint_aware_append TO OFF; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = device_id; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = random()::int; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = CASE WHEN now() > '1970-01-01' THEN random()::int ELSE device_id END; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM hyper WHERE time = CASE WHEN now() > '1970-01-01' THEN 1 ELSE device_id END; RESET timescaledb.enable_chunk_append; RESET timescaledb.enable_constraint_aware_append; --- github issue 1855 --- TESTs for meta column pushdown filters on exprs with casts. CREATE TABLE metaseg_tab ( fmid smallint, factorid smallint, start_dt timestamp without time zone, end_dt timestamp without time zone, interval_number smallint, logret double precision, knowledge_date date NOT NULL ); SELECT create_hypertable('metaseg_tab', 'end_dt', chunk_time_interval=>interval '1 month', create_default_indexes=>false); SELECT add_dimension('metaseg_tab', 'fmid', chunk_time_interval => 1); ALTER TABLE metaseg_tab SET (timescaledb.compress, timescaledb.compress_orderby= 'end_dt'); INSERT INTO metaseg_tab values (56,0,'2012-12-10 09:45:00','2012-12-10 09:50:00',1,0.1,'2012-12-10'); SELECT compress_chunk(i) from show_chunks('metaseg_tab') i; VACUUM FULL ANALYZE metaseg_tab; select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt between '2012-12-10'::date and '2012-12-11'::date order by factorid, end_dt; explain (buffers off, costs off, verbose) select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt between '2012-12-10'::date and '2012-12-11'::date order by factorid, end_dt; --no pushdown here select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date between '2012-12-10'::timestamp and '2012-12-11'::date order by factorid, end_dt; explain (buffers off, costs off, verbose) select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date between '2012-12-10'::timestamp and '2012-12-11'::date order by factorid, end_dt; --should fail \set ON_ERROR_STOP 0 select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date = 10; select factorid, end_dt, logret from metaseg_tab where fmid = 56 and end_dt::date = 'dec 2010'::date; -- test casts between different char types are pushed down CREATE TABLE pushdown_relabel(time timestamptz NOT NULL, dev_vc varchar(10), dev_c char(10)); SELECT table_name FROM create_hypertable('pushdown_relabel', 'time'); ALTER TABLE pushdown_relabel SET (timescaledb.compress, timescaledb.compress_segmentby='dev_vc,dev_c'); INSERT INTO pushdown_relabel SELECT '2000-01-01','varchar','char'; SELECT compress_chunk(i) from show_chunks('pushdown_relabel') i; VACUUM FULL ANALYZE pushdown_relabel; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_c = 'char'; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar' AND dev_c = 'char'; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'::char(10) AND dev_c = 'char'::varchar; -- test again with index scans SET enable_seqscan TO false; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_c = 'char'; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar' AND dev_c = 'char'; EXPLAIN (buffers off, costs off) SELECT * FROM pushdown_relabel WHERE dev_vc = 'varchar'::char(10) AND dev_c = 'char'::varchar; RESET enable_seqscan; -- github issue #5286 CREATE TABLE deleteme AS SELECT generate_series AS timestamp, 1 AS segment, 0 AS data FROM generate_series('2008-03-01 00:00'::timestamp with time zone, '2008-03-04 12:00', '1 second'); SELECT create_hypertable('deleteme', 'timestamp', migrate_data => true); ALTER TABLE deleteme SET ( timescaledb.compress, timescaledb.compress_segmentby = 'segment' ); SELECT compress_chunk(i) FROM show_chunks('deleteme') i; VACUUM FULL ANALYZE deleteme; EXPLAIN (buffers off, costs off) SELECT sum(data) FROM deleteme WHERE segment::text like '%4%'; EXPLAIN (buffers off, costs off) SELECT sum(data) FROM deleteme WHERE '4' = segment::text; CREATE TABLE deleteme_with_bytea(time bigint NOT NULL, bdata bytea); SELECT create_hypertable('deleteme_with_bytea', 'time', chunk_time_interval => 1000000); INSERT INTO deleteme_with_bytea(time, bdata) VALUES (1001, E'\\x'); INSERT INTO deleteme_with_bytea(time, bdata) VALUES (1001, NULL); ALTER TABLE deleteme_with_bytea SET ( timescaledb.compress, timescaledb.compress_segmentby = 'bdata' ); SELECT compress_chunk(i) FROM show_chunks('deleteme_with_bytea') i; VACUUM FULL ANALYZE deleteme_with_bytea; EXPLAIN (buffers off, costs off) SELECT '1' FROM deleteme_with_bytea WHERE bdata = E'\\x'; EXPLAIN (buffers off, costs off) SELECT '1' FROM deleteme_with_bytea WHERE bdata::text = '123'; DROP table deleteme; DROP table deleteme_with_bytea; -- test sqlvaluefunction pushdown CREATE TABLE svf_pushdown(time timestamptz, c_date date, c_time time, c_timetz timetz, c_timestamp timestamptz, c_name text, c_bool bool); SELECT table_name FROM create_hypertable('svf_pushdown', 'time'); ALTER TABLE svf_pushdown SET (timescaledb.compress,timescaledb.compress_segmentby='c_date,c_time, c_timetz,c_timestamp,c_name,c_bool'); INSERT INTO svf_pushdown SELECT '2020-01-01'; SELECT compress_chunk(show_chunks('svf_pushdown')); VACUUM FULL ANALYZE svf_pushdown; -- constraints should be pushed down into scan below decompresschunk in all cases EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_date = CURRENT_DATE; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timetz = CURRENT_TIME; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timetz = CURRENT_TIME(1); EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = CURRENT_TIMESTAMP; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = CURRENT_TIMESTAMP(1); EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_time = LOCALTIME; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_time = LOCALTIME(1); EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = LOCALTIMESTAMP; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_timestamp = LOCALTIMESTAMP(1); EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = USER; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_USER; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = SESSION_USER; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_USER OR c_name = SESSION_USER; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_CATALOG; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = CURRENT_SCHEMA; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_bool; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_bool = true; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_bool = false; EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE NOT c_bool; -- current_query() is not a sqlvaluefunction and volatile so should not be pushed down EXPLAIN (buffers off, costs off) SELECT * FROM svf_pushdown WHERE c_name = current_query(); -- test or constraints in lateral query #6912 SELECT FROM svf_pushdown m1, LATERAL( SELECT FROM svf_pushdown m2 WHERE m1.time = m2.time AND EXISTS (SELECT random()) OR EXISTS (SELECT FROM meta) LIMIT 1 ) l; DROP TABLE svf_pushdown; -- Test bool segmentby column to cover bool-returning operator deeper in the -- expression tree. create table booltab(ts int, segmentby bool, flag bool, value int); select create_hypertable('booltab', 'ts'); alter table booltab set (timescaledb.compress, timescaledb.compress_segmentby = 'segmentby', timescaledb.compress_orderby = 'ts, flag'); insert into booltab values ( 1, true, true, 1), ( 99, false, false, 99), (100, false, false, 100), (101, false, false, 101) ; select count(compress_chunk(x)) from show_chunks('booltab') x; vacuum analyze booltab; explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where segmentby = (value = 1); explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where segmentby = (ts = 1); explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where segmentby != (ts = 1); explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where (value = 1) = (ts = 1); explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where flag = (ts = 1); explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where flag = (ts = 99); explain (analyze, buffers off, costs off, timing off, summary off) select * from booltab where flag = (ts = 99); drop table booltab; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_segment_meta.sql����������������������������������������0000664�0000000�0000000�00000010250�15100345067�0024243�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION _timescaledb_internal.ts_segment_meta_min_max_append(internal, ANYELEMENT) RETURNS internal AS :TSL_MODULE_PATHNAME, 'ts_segment_meta_min_max_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.ts_segment_meta_min_max_finish_max(internal, ANYELEMENT) RETURNS anyelement AS :TSL_MODULE_PATHNAME, 'ts_segment_meta_min_max_finish_max' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.ts_segment_meta_min_max_finish_min(internal, ANYELEMENT) RETURNS anyelement AS :TSL_MODULE_PATHNAME, 'ts_segment_meta_min_max_finish_min' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE AGGREGATE _timescaledb_internal.segment_meta_min_max_agg_min(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.ts_segment_meta_min_max_append, FINALFUNC = _timescaledb_internal.ts_segment_meta_min_max_finish_min, FINALFUNC_EXTRA ); CREATE AGGREGATE _timescaledb_internal.segment_meta_min_max_agg_max(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.ts_segment_meta_min_max_append, FINALFUNC = _timescaledb_internal.ts_segment_meta_min_max_finish_max, FINALFUNC_EXTRA ); \ir include/rand_generator.sql \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER CREATE TABLE metric (i int); insert into metric select i from generate_series(1, 10) i; \set TYPE int \set TABLE metric \ir include/compression_test_segment_meta.sql ----NULL tests --First truncate metric; insert into metric select NULLIF(i,1) from generate_series(1, 10) i; \ir include/compression_test_segment_meta.sql --Last truncate metric; insert into metric select NULLIF(i,10) from generate_series(1, 10) i; \ir include/compression_test_segment_meta.sql --Middle truncate metric; insert into metric select NULLIF(i,5) from generate_series(1, 10) i; \ir include/compression_test_segment_meta.sql --All NULLS should return null object truncate metric; insert into metric select NULL from generate_series(1, 10) i; SELECT _timescaledb_internal.segment_meta_min_max_agg_min(i) is null, _timescaledb_internal.segment_meta_min_max_agg_max(i) is null FROM metric; -- --type tests -- --untoasted text CREATE TABLE base_texts AS SELECT repeat(item::text, 1) as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set TYPE text \set TABLE base_texts \ir include/compression_test_segment_meta.sql --toasted text DROP TABLE base_texts; CREATE TABLE base_texts AS SELECT repeat(item::text, 100000) as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; --make sure it's toasted SELECT pg_total_relation_size(reltoastrelid) FROM pg_class c WHERE relname = 'base_texts'; \ir include/compression_test_segment_meta.sql --name is a fixed-length pass by reference type CREATE TABLE base_name AS SELECT item::name as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set TYPE name \set TABLE base_name \ir include/compression_test_segment_meta.sql --array CREATE TABLE text_array AS SELECT array[item::text, 'abab'] as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set TYPE text[] \set TABLE text_array \ir include/compression_test_segment_meta.sql --Points doesn't have an ordering so make sure it errors CREATE TABLE points AS SELECT point '(0,1)' as i FROM (SELECT sub.item from (SELECT generate_series(1, 10) item) as sub ORDER BY gen_rand_minstd() ) sub; \set ON_ERROR_STOP 0 SELECT _timescaledb_internal.segment_meta_min_max_agg_max(i) FROM points; SELECT _timescaledb_internal.segment_meta_min_max_agg_min(i) FROM points; \set ON_ERROR_STOP 1 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_sequence_num_removal.sql��������������������������������0000664�0000000�0000000�00000022427�15100345067�0026020�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test query planning with hypertable which contains -- compressed chunks that depend on sequence number optimization -- which is removed in latest schema revision \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER SET ROLE :ROLE_DEFAULT_PERM_USER; \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' CREATE TABLE hyper( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('hyper', 'time', chunk_time_interval => 10); -- test case with segmentby ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2), (21, 2, 3), (22, 3, 3), (23, 4, 3), (30, 1, 4), (31, 3, 4), (31, 5, 4); SELECT compress_chunk(show_chunks('hyper')); VACUUM ANALYZE hyper; -- output without sequence number chunks, should match output with sequence numbers below :EXPLAIN SELECT * FROM hyper ORDER BY device_id, time; SELECT * FROM hyper ORDER BY device_id, time; -- backwards index scan :EXPLAIN SELECT * FROM hyper ORDER BY device_id DESC, time DESC; SELECT * FROM hyper ORDER BY device_id DESC, time DESC; -- modify two chunks by adding sequence number to the segments -- and rebuild the index based on that column SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id LIMIT 1 \gset SELECT schemaname || '.' || indexname AS "CHUNK_INDEX" FROM pg_indexes where tablename = :'CHUNK_NAME' LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over (partition by device_id) as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY device_id, _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; -- drop exising index DROP INDEX :CHUNK_INDEX; -- create index based on sequence numbers CREATE INDEX ON :CHUNK_FULL_NAME (device_id, _ts_meta_sequence_num); SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id OFFSET 2 LIMIT 1 \gset SELECT schemaname || '.' || indexname AS "CHUNK_INDEX" FROM pg_indexes where tablename = :'CHUNK_NAME' LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over (partition by device_id) as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY device_id, _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; -- drop exising index DROP INDEX :CHUNK_INDEX; -- create index based on sequence numbers CREATE INDEX ON :CHUNK_FULL_NAME (device_id, _ts_meta_sequence_num); SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; -- from this point, two chunks should use sequence numbers and the rest will work without them -- output with sequence number chunks, should match output without sequence numbers above :EXPLAIN SELECT * FROM hyper ORDER BY device_id, time; SELECT * FROM hyper ORDER BY device_id, time; -- backwards index scan :EXPLAIN SELECT * FROM hyper ORDER BY device_id DESC, time DESC; SELECT * FROM hyper ORDER BY device_id DESC, time DESC; -- test recompression which should do a full recompress of the chunk -- while dropping sequence numbers INSERT INTO hyper VALUES (20, 1, 1); SELECT compress_chunk(show_chunks('hyper')); VACUUM ANALYZE hyper; -- removal of sequence numbers from the chunk should be -- reflected in this plan :EXPLAIN SELECT * FROM hyper ORDER BY device_id, time; -- test case without segmentby TRUNCATE hyper; ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = ''); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2), (21, 2, 3), (22, 3, 3), (23, 4, 3), (30, 1, 4), (31, 3, 4), (31, 5, 4); SELECT compress_chunk(show_chunks('hyper')); VACUUM ANALYZE hyper; :EXPLAIN SELECT * FROM hyper ORDER BY time; -- modify two chunks by adding sequence number to the segments SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over () as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id OFFSET 3 LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SET timescaledb.restoring TO ON; -- add sequence number column and fill in the correct sequences ALTER TABLE :CHUNK_FULL_NAME ADD COLUMN _ts_meta_sequence_num int; INSERT INTO :CHUNK_FULL_NAME (device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1, _ts_meta_sequence_num) SELECT device_id, time, val, _ts_meta_count, _ts_meta_min_1, _ts_meta_max_1 , 10*row_number() over () as _ts_meta_sequence_num FROM :CHUNK_FULL_NAME ORDER BY _ts_meta_min_1, _ts_meta_max_1; DELETE FROM :CHUNK_FULL_NAME WHERE _ts_meta_sequence_num IS NULL; SET timescaledb.restoring TO OFF; SET ROLE :ROLE_DEFAULT_PERM_USER; -- from this point, two chunks should use sequence numbers and the rest will work without them :EXPLAIN SELECT * FROM hyper ORDER BY time; -- test rolling up chunks during compression -- this will not work with chunks which have sequence numbers -- since the last chunk has sequence numbers, new chunks will be only rolled up together ALTER TABLE hyper SET (timescaledb.compress_chunk_time_interval = '30'); INSERT INTO hyper VALUES (41, 1, 1), (42, 2, 1), (43, 3, 1), (50, 3, 2), (51, 4, 2), (51, 5, 2); -- compression should leave the previous 4 chunks alone -- and roll up the two new chunks into a single chunk SELECT compress_chunk(show_chunks('hyper')); -- gh issue #7384 -- modifying compressed chunk OID to over INT32_MAX -- to detect if we handle those properly TRUNCATE hyper; ALTER TABLE hyper SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO hyper VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 5, 2), (21, 2, 3), (22, 3, 3), (23, 4, 3), (30, 1, 4), (31, 3, 4), (31, 5, 4); SELECT compress_chunk(show_chunks('hyper')); VACUUM ANALYZE hyper; SELECT comp_ch.table_name AS "CHUNK_NAME", comp_ch.schema_name|| '.' || comp_ch.table_name AS "CHUNK_FULL_NAME" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk comp_ch, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ht.table_name LIKE 'hyper' AND ch1.compressed_chunk_id = comp_ch.id ORDER BY ch1.id LIMIT 1 \gset SET ROLE :ROLE_CLUSTER_SUPERUSER; SELECT :'CHUNK_FULL_NAME'::regclass::oid as "CHUNK_OID" \gset SELECT (power(2,31)+1)::bigint as "CHUNK_NEW_OID" \gset UPDATE pg_class SET oid = :CHUNK_NEW_OID WHERE oid = :CHUNK_OID; UPDATE pg_attribute SET attrelid = :CHUNK_NEW_OID WHERE attrelid = :CHUNK_OID; UPDATE _timescaledb_catalog.compression_settings SET compress_relid = :CHUNK_NEW_OID WHERE compress_relid = :CHUNK_OID; :EXPLAIN SELECT * FROM hyper WHERE device_id = 1 ORDER BY time; SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE hyper; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_settings.sql��������������������������������������������0000664�0000000�0000000�00000013106�15100345067�0023436�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO ALL CREATE VIEW settings AS SELECT * FROM _timescaledb_catalog.compression_settings ORDER BY upper(relid::text) COLLATE "C"; CREATE VIEW ht_settings AS SELECT * FROM timescaledb_information.hypertable_compression_settings ORDER BY upper(hypertable::text) COLLATE "C"; CREATE VIEW chunk_settings AS SELECT * FROM timescaledb_information.chunk_compression_settings ORDER BY upper(hypertable::text) COLLATE "C", upper(chunk::text) COLLATE "C"; CREATE TABLE metrics(time timestamptz not null, device text, value float); SELECT table_name FROM create_hypertable('metrics','time'); ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT * FROM settings; SELECT * FROM ht_settings; SELECT * FROM chunk_settings; -- create 2 chunks INSERT INTO metrics VALUES ('2000-01-01'), ('2001-01-01'); -- no change to settings SELECT * FROM settings; --Enable compression path info SET timescaledb.debug_compression_path_info= 'on'; SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); RESET timescaledb.debug_compression_path_info; SELECT * FROM settings; SELECT * FROM chunk_settings; SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); SELECT * FROM settings; SELECT * FROM chunk_settings; -- dropping chunk should remove that chunks compression settings DROP TABLE _timescaledb_internal._hyper_1_1_chunk; SELECT * FROM settings; SELECT * FROM chunk_settings; -- decompress_chunk should remove settings for that chunk SELECT decompress_chunk('_timescaledb_internal._hyper_1_2_chunk'); SELECT * FROM settings; SELECT * FROM chunk_settings; -- compress_chunk should add settings back SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); SELECT * FROM settings; SELECT * FROM chunk_settings; -- dropping hypertable should remove all settings DROP TABLE metrics; SELECT * FROM settings; SELECT * FROM ht_settings; SELECT * FROM chunk_settings; CREATE TABLE metrics(time timestamptz not null, d1 text, d2 text, value float); SELECT table_name FROM create_hypertable('metrics','time'); ALTER TABLE metrics SET (timescaledb.compress); -- hypertable should have default settings now SELECT * FROM settings; SELECT * FROM ht_settings; -- create chunk INSERT INTO metrics VALUES ('2000-01-01'); ALTER TABLE metrics SET (timescaledb.compress_segmentby='d1'); -- settings should be updated SELECT * FROM settings; SELECT * FROM ht_settings; SELECT compress_chunk(show_chunks('metrics')); -- settings for compressed chunk should be present SELECT * FROM settings; SELECT * FROM chunk_settings; -- changing settings should update settings for hypertable but not existing compressed chunks ALTER TABLE metrics SET (timescaledb.compress_segmentby='d2'); SELECT * FROM settings; SELECT * FROM ht_settings; SELECT * FROM chunk_settings; -- changing settings should update settings for hypertable but not existing compressed chunks ALTER TABLE metrics SET (timescaledb.compress_segmentby=''); SELECT * FROM settings; SELECT * FROM ht_settings; SELECT * FROM chunk_settings; -- create another chunk INSERT INTO metrics VALUES ('2000-02-01'); SELECT compress_chunk(show_chunks('metrics'), true); SELECT * FROM settings; SELECT * FROM ht_settings; SELECT * FROM chunk_settings; ALTER TABLE metrics SET (timescaledb.compress_orderby='"time" desc', timescaledb.compress_segmentby='d2', timescaledb.index='bloom(value)'); SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL ORDER BY id LIMIT 1 OFFSET 1\gset -- recompressing chunks should apply current hypertable settings SELECT compress_chunk(:'CHUNK', recompress:=true); SELECT compress_chunk(:'CHUNK', recompress:=true); ALTER TABLE metrics SET (timescaledb.compress_orderby='"time" desc', timescaledb.compress_segmentby='d2', timescaledb.index=''); SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL ORDER BY id LIMIT 1 OFFSET 1\gset SELECT compress_chunk(:'CHUNK', recompress:=true); SELECT * FROM settings; SELECT * FROM ht_settings; SELECT * FROM chunk_settings; -- test different order by flags with compression settings view CREATE TABLE metrics2(time timestamptz not null, d1 text, d2 text, value float); SELECT create_hypertable('metrics2','time'); SELECT * FROM ht_settings; ALTER TABLE metrics2 SET (timescaledb.compress_orderby='d1 NULLS FIRST, d2 NULLS LAST, time, value ASC'); SELECT * FROM ht_settings; ALTER TABLE metrics2 SET (timescaledb.compress_orderby='d1 DESC NULLS LAST, d2 ASC NULLS FIRST, value DESC, time ASC NULLS FIRST'); SELECT * FROM ht_settings; -- test decompression uses the correct settings ALTER TABLE metrics SET (timescaledb.compress_segmentby=''); SELECT compress_chunk(show_chunks('metrics'), recompress:=true); ALTER TABLE metrics SET (timescaledb.compress_segmentby='d1,d2'); SELECT * FROM chunk_settings; SELECT * FROM metrics WHERE d1 = 'foo'; SELECT * FROM settings; -- Check that TRUNCATE <hypertable> also cleans up compression -- settings for chunks that are dropped when truncating. TRUNCATE metrics; SELECT * FROM settings; SELECT * FROM chunk_settings; -- Recreate chunks INSERT INTO metrics VALUES ('2000-01-01'), ('2001-01-01'); SELECT compress_chunk(ch) FROM show_chunks('metrics') ch; SELECT * FROM settings; -- DROP TABLE with CASCADE uses a different code path for dropping -- hypertable so needs to be tested separately. DROP TABLE metrics CASCADE; SELECT * FROM settings; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_sorted_merge.sql����������������������������������������0000664�0000000�0000000�00000063641�15100345067�0024266�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Increase the working memory limit slightly, otherwise the batch sorted merge -- will be penalized for segmentby cardinalities larger than 100, where it is -- still faster than sort. SET work_mem to '16MB'; \set PREFIX 'EXPLAIN (analyze, verbose, buffers off, costs off, timing off, summary off)' CREATE TABLE test1 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test1', 'time'); ALTER TABLE test1 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'time DESC, x3 ASC, x4 ASC'); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); SELECT compress_chunk(i) FROM show_chunks('test1') i; ANALYZE test1; CREATE TABLE test2 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test2', 'time'); ALTER TABLE test2 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'time ASC, x3 DESC, x4 DESC'); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); SELECT compress_chunk(i) FROM show_chunks('test2') i; ANALYZE test2; CREATE TABLE test_with_defined_null ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer); SELECT FROM create_hypertable('test_with_defined_null','time'); ALTER TABLE test_with_defined_null SET (timescaledb.compress,timescaledb.compress_segmentby='x1', timescaledb.compress_orderby='x2 ASC NULLS FIRST'); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01', '1', NULL); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01','2', NULL); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01','1',1); INSERT INTO test_with_defined_null (time, x1, x2) values('2000-01-01','1',2); SELECT compress_chunk(i) FROM show_chunks('test_with_defined_null') i; ANALYZE test_with_defined_null; -- test1 uses compress_segmentby='x1, x2, x5' and compress_orderby = 'time DESC, x3 ASC, x4 ASC' -- test2 uses compress_segmentby='x1, x2, x5' and compress_orderby = 'time ASC, x3 DESC, x4 DESC' -- test_with_defined_null uses compress_segmentby='x1' and compress_orderby = 'x2 ASC NULLS FIRST' ------ -- Tests based on ordering ------ set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Should be optimized (implicit NULLS first) :PREFIX SELECT * FROM test1 ORDER BY time DESC; -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST; -- Should be optimized (implicit NULLS last) :PREFIX SELECT * FROM test1 ORDER BY time ASC; -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST; -- Should be optimized :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 ASC NULLS LAST; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST, x4 DESC NULLS FIRST; -- Should be optimized :PREFIX SELECT * FROM test2 ORDER BY time ASC; -- Should be optimized :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 DESC; -- Should be optimized :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 DESC, x4 DESC; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS FIRST; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 NULLS LAST; -- Should be optimized :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS FIRST; -- Should be optimized (backward scan) :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS LAST; set timescaledb.debug_require_batch_sorted_merge to 'forbid'; -- Should not be optimized (wrong order for x3 in backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS LAST, x3 DESC NULLS FIRST, x4 NULLS FIRST; -- Should not be optimized (wrong order for x3 in backward scan) :PREFIX SELECT * FROM test2 ORDER BY time DESC NULLS LAST, x3 DESC NULLS LAST, x4 NULLS FIRST; -- Should not be optimized (NULL order wrong) :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS LAST; -- Should not be optimized (NULL order wrong) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS FIRST; -- Should not be optimized (wrong order for x4) :PREFIX SELECT * FROM test1 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 DESC NULLS FIRST; -- Should not be optimized (wrong order for x4 in backward scan) :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS FIRST, x3 DESC NULLS LAST, x4 ASC; -- Should not be optimized (wrong order for x3) :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 ASC NULLS LAST, x4 DESC; -- Should not be optimized (wrong order for x3) :PREFIX SELECT * FROM test2 ORDER BY time ASC, x3 ASC NULLS FIRST, x4 DESC; -- Should not be optimized :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS LAST; -- Should not be optimized :PREFIX SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS FIRST; ------ -- Tests based on attributes ------ set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Should be optimized (some batches qualify by pushed down filter on _ts_meta_max_3) :PREFIX SELECT * FROM test1 WHERE x4 > 0 ORDER BY time DESC; -- Should be optimized (no batches qualify by pushed down filter on _ts_meta_max_3) :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC; -- Should be optimized :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x3, x4; -- Should be optimized (duplicate order by attributes) :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x3, x3; -- Should be optimized (duplicate order by attributes) :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x3, x4, x3, x4; set timescaledb.debug_require_batch_sorted_merge to 'forbid'; -- Should not be optimized :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC, x4, x3; -- Should not be optimized :PREFIX SELECT * FROM test1 WHERE x4 > 100 ORDER BY time ASC, x3, x4; ------ -- Tests based on results ------ set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Forward scan SELECT * FROM test1 ORDER BY time DESC; -- Forward scan SELECT * FROM test2 ORDER BY time ASC; set timescaledb.debug_require_batch_sorted_merge to 'force'; -- Backward scan SELECT * FROM test1 ORDER BY time ASC NULLS LAST; -- Backward scan SELECT * FROM test2 ORDER BY time DESC NULLS FIRST; set timescaledb.debug_require_batch_sorted_merge to 'force'; -- With selection on compressed column (value larger as max value for all batches, so no batch has to be opened) SELECT * FROM test1 WHERE x4 > 100 ORDER BY time DESC; -- With selection on compressed column (value smaller as max value for some batches, so batches are opened and filter has to be applied) SELECT * FROM test1 WHERE x4 > 2 ORDER BY time DESC; -- With selection on segment_by column SELECT * FROM test1 WHERE time < '1980-01-01 00:00:00-00' ORDER BY time DESC; SELECT * FROM test1 WHERE time > '1980-01-01 00:00:00-00' ORDER BY time DESC; -- With selection on segment_by and compressed column SELECT * FROM test1 WHERE time > '1980-01-01 00:00:00-00' ORDER BY time DESC; SELECT * FROM test1 WHERE time > '1980-01-01 00:00:00-00' AND x4 > 100 ORDER BY time DESC; -- Without projection SELECT * FROM test1 ORDER BY time DESC; -- With projection on time SELECT time FROM test1 ORDER BY time DESC; -- With projection on x3 SELECT x3 FROM test1 ORDER BY time DESC; -- With projection on x3 and time SELECT x3,time FROM test1 ORDER BY time DESC; -- With projection on time and x3 SELECT time,x3 FROM test1 ORDER BY time DESC; -- Test with projection and constants EXPLAIN (verbose, buffers off, costs off) SELECT 1 as one, 2 as two, 3 as three, time, x2 FROM test1 ORDER BY time DESC; SELECT 1 as one, 2 as two, 3 as three, time, x2 FROM test1 ORDER BY time DESC; -- Test with projection and constants EXPLAIN (verbose, buffers off, costs off) SELECT 1 as one, 2 as two, 3 as three, x2, time FROM test1 ORDER BY time DESC; SELECT 1 as one, 2 as two, 3 as three, x2, time FROM test1 ORDER BY time DESC; -- With projection and selection on compressed column (value smaller as max value for some batches, so batches are opened and filter has to be applied) SELECT x4 FROM test1 WHERE x4 > 2 ORDER BY time DESC; set timescaledb.debug_require_batch_sorted_merge to 'forbid'; -- Aggregation with count SELECT count(*) FROM test1; -- Test with default values ALTER TABLE test1 ADD COLUMN c1 int; ALTER TABLE test1 ADD COLUMN c2 int NOT NULL DEFAULT 42; set timescaledb.debug_require_batch_sorted_merge to 'force'; SELECT * FROM test1 ORDER BY time DESC; -- Recompress SELECT decompress_chunk(i) FROM show_chunks('test1') i; SELECT compress_chunk(i) FROM show_chunks('test1') i; ANALYZE test1; -- Test with a changed physical layout -- build_physical_tlist() can not be used for the scan on the compressed chunk anymore SELECT * FROM test1 ORDER BY time DESC; ALTER TABLE test1 DROP COLUMN c2; SELECT * FROM test1 ORDER BY time DESC; -- Test with a re-created column ALTER TABLE test1 ADD COLUMN c2 int NOT NULL DEFAULT 43; SELECT * FROM test1 ORDER BY time DESC; -- Test with the recreated column :PREFIX SELECT * FROM test1 ORDER BY time DESC; SELECT * FROM test1 ORDER BY time DESC; -- Test with projection and recreated column :PREFIX SELECT time, x2, x1, c2 FROM test1 ORDER BY time DESC; SELECT time, x2, x1, c2 FROM test1 ORDER BY time DESC; -- Test with projection and recreated column :PREFIX SELECT x2, x1, c2, time FROM test1 ORDER BY time DESC; SELECT x2, x1, c2, time FROM test1 ORDER BY time DESC; -- Test with projection, constants and recreated column :PREFIX SELECT 1 as one, 2 as two, 3 as three, x2, x1, c2, time FROM test1 ORDER BY time DESC; SELECT 1 as one, 2 as two, 3 as three, x2, x1, c2, time FROM test1 ORDER BY time DESC; -- Test with null values SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS FIRST; SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS LAST; set timescaledb.debug_require_batch_sorted_merge to 'forbid'; SELECT * FROM test_with_defined_null ORDER BY x2 ASC NULLS LAST; SELECT * FROM test_with_defined_null ORDER BY x2 DESC NULLS FIRST; ------ -- Tests based on compressed chunk state ------ -- Should be optimized set timescaledb.debug_require_batch_sorted_merge to 'force'; :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; BEGIN TRANSACTION; INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:01:00-00', 10, 20, 30, 40, 50); -- Should be optimized using a merge append path between the compressed and uncompressed part of the chunk :PREFIX SELECT * FROM test1 ORDER BY time ASC NULLS LAST; -- The inserted value should be visible SELECT * FROM test1 ORDER BY time ASC NULLS LAST; ROLLBACK; ------ -- Tests on a larger relation ------ set timescaledb.debug_require_batch_sorted_merge to 'allow'; CREATE TABLE sensor_data ( time timestamptz NOT NULL, sensor_id integer NOT NULL, cpu double precision NULL, temperature double precision NULL); SELECT FROM create_hypertable('sensor_data','time'); INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random() * 100 AS temperature FROM generate_series('1980-01-01 00:00:00-00', '1980-02-01 00:00:00-00', INTERVAL '10 minute') AS g1(time), generate_series(1, 100, 1 ) AS g2(sensor_id) ORDER BY time; ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby='sensor_id', timescaledb.compress_orderby = 'time DESC'); SELECT add_compression_policy('sensor_data','1 minute'::INTERVAL); SELECT compress_chunk(i) FROM show_chunks('sensor_data') i; VACUUM ANALYZE sensor_data; -- Ensure the optimization is used for queries on this table :PREFIX SELECT * FROM sensor_data ORDER BY time DESC LIMIT 1; -- Verify that we produce the same order without and with the optimization CREATE PROCEDURE order_test(query text) LANGUAGE plpgsql AS $$ DECLARE count integer; BEGIN SET timescaledb.enable_decompression_sorted_merge = 0; EXECUTE format('CREATE TABLE temp_data1 AS %s;', query); ALTER TABLE temp_data1 ADD COLUMN new_id SERIAL PRIMARY KEY; SET timescaledb.enable_decompression_sorted_merge = 1; EXECUTE format('CREATE TABLE temp_data2 AS %s;', query); ALTER TABLE temp_data2 ADD COLUMN new_id SERIAL PRIMARY KEY; CREATE TEMP TABLE temp_data3 AS ( SELECT * FROM temp_data1 UNION ALL SELECT * FROM temp_data2 ); count := (SELECT COUNT(*) FROM (SELECT COUNT(*) FROM temp_data3 GROUP BY time, new_id HAVING COUNT(*) != 2) AS s); IF count > 0 THEN RAISE EXCEPTION 'Detected different order with and without the optimization %', count; END IF; -- Drop old tables DROP TABLE temp_data1; DROP TABLE temp_data2; DROP TABLE temp_data3; END; $$; CALL order_test('SELECT * FROM sensor_data ORDER BY time DESC'); CALL order_test('SELECT * FROM sensor_data ORDER BY time DESC LIMIT 100'); CALL order_test('SELECT * FROM sensor_data ORDER BY time ASC NULLS FIRST'); CALL order_test('SELECT * FROM sensor_data ORDER BY time ASC NULLS FIRST LIMIT 100'); CALL order_test('SELECT * FROM test1 ORDER BY time DESC'); CALL order_test('SELECT * FROM test1 ORDER BY time ASC NULLS LAST'); ------ -- Test window functions ------ CREATE TABLE insert_test(id INT); INSERT INTO insert_test SELECT time_bucket_gapfill(1,time,1,5) FROM (VALUES (1),(2)) v(time) GROUP BY 1 ORDER BY 1; SELECT * FROM insert_test AS ref_0 WHERE EXISTS ( SELECT sum(ref_0.id) OVER (partition by ref_0.id ORDER BY ref_0.id,ref_0.id,sample_0.time) FROM sensor_data AS sample_0 WHERE (1 > sample_0.temperature) ); ------ -- Test enabling and disabling the optimization based on costs ------ CREATE TABLE test_costs ( time timestamptz NOT NULL, segment_by integer NOT NULL, x1 integer NOT NULL); SELECT FROM create_hypertable('test_costs', 'time'); ALTER TABLE test_costs SET (timescaledb.compress, timescaledb.compress_segmentby='segment_by', timescaledb.compress_orderby = 'time DESC, x1'); -- Create 100 segments INSERT INTO test_costs SELECT time, segment_by, random() as x1 FROM generate_series(1, 100, 1) AS g2(segment_by), generate_series('2000-01-01 02:01:00-00', '2000-01-06 00:00:00+00', interval '1 hour') time ORDER BY time; SELECT compress_chunk(i) FROM show_chunks('test_costs') i; ANALYZE test_costs; -- Number of segments SELECT count(*) FROM (SELECT segment_by from test_costs group by segment_by) AS s; -- Test query plan (should be optimized due to 100 different segments) :PREFIX SELECT time, segment_by, x1 FROM test_costs ORDER BY time DESC; -- Decompress chunk SELECT decompress_chunk(i) FROM show_chunks('test_costs') i; -- Add 900 segments (1000 segments total) INSERT INTO test_costs SELECT time, segment_by, random() as x1 FROM generate_series(100, 1000, 1) AS g2(segment_by), generate_series('2000-01-01 02:01:00-00', '2000-01-06 00:00:00+00', interval '1 hour') time ORDER BY time; -- Recompress chunk SELECT compress_chunk(i) FROM show_chunks('test_costs') i; ANALYZE test_costs; -- Number of segments SELECT count(*) FROM (SELECT segment_by from test_costs group by segment_by) AS s; -- Test query plan (should not be optimized due to 1000 different segments) set timescaledb.debug_require_batch_sorted_merge to 'forbid'; :PREFIX SELECT time, segment_by, x1 FROM test_costs ORDER BY time DESC; -- Test query plan with predicate (query should be optimized due to ~100 segments) set timescaledb.debug_require_batch_sorted_merge to 'require'; :PREFIX SELECT time, segment_by, x1 FROM test_costs WHERE segment_by > 900 and segment_by < 999 ORDER BY time DESC; -- Target list creation - Issue 5738 CREATE TABLE bugtab( time timestamp without time zone, hin character varying(128) NOT NULL, model character varying(128) NOT NULL, block character varying(128) NOT NULL, message_name character varying(128) NOT NULL, signal_name character varying(128) NOT NULL, signal_numeric_value double precision, signal_string_value character varying(128) ); SELECT create_hypertable('bugtab', 'time'); INSERT INTO bugtab values('2020-01-01 10:00', 'hin1111', 'model111', 'blok111', 'message_here', 'signal1', 12.34, '12.34'); ALTER TABLE bugtab SET (timescaledb.compress, timescaledb.compress_segmentby = 'hin, signal_name', timescaledb.compress_orderby = 'time'); SELECT chunk_schema || '.' || chunk_name AS "chunk_table_bugtab" FROM timescaledb_information.chunks WHERE hypertable_name = 'bugtab' ORDER BY range_start LIMIT 1 \gset SELECT compress_chunk(i) FROM show_chunks('bugtab') i; ANALYZE bugtab; set timescaledb.debug_require_batch_sorted_merge to 'force'; :PREFIX SELECT "time","hin"::text,"model"::text,"block"::text,"message_name"::text,"signal_name"::text,"signal_numeric_value","signal_string_value"::text FROM :chunk_table_bugtab ORDER BY "time" DESC; SELECT "time","hin"::text,"model"::text,"block"::text,"message_name"::text,"signal_name"::text,"signal_numeric_value","signal_string_value"::text FROM :chunk_table_bugtab ORDER BY "time" DESC; SELECT "time","hin"::text,"model"::text,"block"::text,"message_name"::text,"signal_name"::text,"signal_numeric_value","signal_string_value"::text FROM bugtab ORDER BY "time" DESC; -- Condition that filter the first tuple of a batch - Issue 5797 CREATE TABLE test ( id bigint, dttm timestamp, otherId int, valueFk int, otherFk int, measure double precision ); SELECT create_hypertable('test', 'dttm'); ALTER TABLE test SET ( timescaledb.compress, timescaledb.compress_segmentby = 'otherId,valueFk,otherFk' ); INSERT INTO public.test (id, dttm, otherid, valuefk, otherfk, measure) VALUES (109288, '2023-05-25 23:12:13.000000', 130, 14499, 13, 0.13216569884001217), (109286, '2023-05-25 23:12:13.000000', 130, 14500, 13, 0.3740651978942786), (107617, '2023-05-25 14:24:12.000000', 130, 14850, 13, 0.5978259144311195), (103864, '2023-05-25 13:30:51.000000', 130, 16760, 13, 0.4733429856616205), (104977, '2023-05-25 12:11:47.000000', 133, 14843, 13, 0.24366893909655118), (108321, '2023-05-25 18:39:07.000000', 133, 15294, 13, 0.8768629101819378), (108320, '2023-05-25 16:09:17.000000', 133, 15294, 13, 0.6185638532799445), (104987, '2023-05-25 13:27:19.000000', 133, 15294, 13, 0.9830846939109854), (104737, '2023-05-25 19:59:54.000000', 135, 14238, 13, 0.2388520055224177), (106278, '2023-05-25 19:59:54.000000', 135, 14238, 13, 0.6305156586688518), (104741, '2023-05-25 19:59:54.000000', 135, 14238, 13, 0.4990673076480263), (106277, '2023-05-25 12:53:34.000000', 135, 14238, 13, 0.46086278330000496), (97409, '2023-05-25 12:38:48.000000', 137, 14533, 13, 0.8308173375978924), (105234, '2023-05-25 12:38:45.000000', 137, 14533, 13, 0.10860962941223917), (105233, '2023-05-25 12:06:35.000000', 137, 14533, 13, 0.09058791972962155), (97434, '2023-05-25 12:39:46.000000', 137, 14657, 13, 0.023315916140422388), (108167, '2023-05-25 15:41:30.000000', 137, 14964, 13, 0.21757999385617666), (107741, '2023-05-25 14:40:37.000000', 137, 14964, 13, 0.3449447147508202), (106312, '2023-05-25 14:40:16.000000', 137, 14964, 13, 0.11890456868959376), (106134, '2023-05-25 12:56:18.000000', 137, 14964, 13, 0.8004332371337775), (103696, '2023-05-25 12:54:31.000000', 137, 14964, 13, 0.30147495793613643), (106311, '2023-05-25 12:44:22.000000', 137, 14964, 13, 0.7412968055185551), (106133, '2023-05-25 12:44:22.000000', 137, 14964, 13, 0.12940337622720932), (105711, '2023-05-25 12:43:57.000000', 137, 14964, 13, 0.1044849979830822), (105710, '2023-05-25 12:34:04.000000', 137, 14964, 13, 0.9113563410974876), (108787, '2023-05-25 17:59:35.000000', 137, 15377, 13, 0.921829256160489), (107833, '2023-05-25 14:53:08.000000', 137, 16302, 13, 0.9663117845438407), (105435, '2023-05-25 12:30:59.000000', 137, 16568, 13, 0.13774896612028797), (105434, '2023-05-25 12:29:29.000000', 137, 16568, 13, 0.3891495411502035), (108357, '2023-05-25 16:18:39.000000', 137, 16665, 13, 0.44701901843246716), (98564, '2023-05-25 17:12:43.000000', 138, 14760, 13, 0.8463114782142114), (109032, '2023-05-25 19:00:00.000000', 138, 14992, 13, 0.025578609447126865), (108800, '2023-05-25 18:43:18.000000', 138, 14992, 13, 0.5397724043221928), (108799, '2023-05-25 18:00:00.000000', 138, 14992, 13, 0.0321658507434357), (107320, '2023-05-25 14:00:01.000000', 138, 14992, 13, 0.9042941365487067), (107296, '2023-05-25 14:00:00.000000', 138, 14992, 13, 0.7821178685669885), (104700, '2023-05-25 12:36:55.000000', 138, 14992, 13, 0.6854496458178119), (105177, '2023-05-25 12:00:01.000000', 138, 14992, 13, 0.23780719110724746), (109330, '2023-05-25 23:59:13.000000', 138, 15080, 13, 0.5409015970284159), (107400, '2023-05-25 16:45:13.000000', 138, 15080, 13, 0.6233594483468217), (107399, '2023-05-25 14:03:49.000000', 138, 15080, 13, 0.8192327792045404), (105004, '2023-05-25 13:37:49.000000', 138, 15080, 13, 0.2993620446103442), (102592, '2023-05-25 13:31:48.000000', 138, 15080, 13, 0.24649704579496046), (109028, '2023-05-25 19:00:00.000000', 138, 15123, 13, 0.5442767942906279), (108794, '2023-05-25 18:43:18.000000', 138, 15123, 13, 0.29095714680616425), (108793, '2023-05-25 18:00:00.000000', 138, 15123, 13, 0.681894893772391), (107314, '2023-05-25 14:00:01.000000', 138, 15123, 13, 0.9637603904838059), (107292, '2023-05-25 14:00:00.000000', 138, 15123, 13, 0.05956707862994293), (104696, '2023-05-25 12:36:55.000000', 138, 15123, 13, 0.27039489547807705), (105171, '2023-05-25 12:00:01.000000', 138, 15123, 13, 0.1269705046788907), (106625, '2023-05-25 13:22:19.000000', 138, 15326, 13, 0.7712280764026431), (106624, '2023-05-25 13:15:49.000000', 138, 15326, 13, 0.585381418741779), (105699, '2023-05-25 12:44:33.000000', 138, 15326, 13, 0.3710994669938259), (105698, '2023-05-25 12:33:41.000000', 138, 15326, 13, 0.8992328857980105), (108514, '2023-05-25 16:47:37.000000', 138, 15620, 13, 0.40346934167556725), (102691, '2023-05-25 13:33:57.000000', 138, 15620, 13, 0.8046719989908304), (103655, '2023-05-25 13:34:39.000000', 138, 15740, 13, 0.2541099322817928), (106987, '2023-05-25 13:37:36.000000', 138, 15766, 13, 0.8407818724583045), (102180, '2023-05-25 13:37:11.000000', 138, 15766, 13, 0.19149633299917213), (102717, '2023-05-25 13:38:17.000000', 138, 15868, 13, 0.03196157886032225), (102719, '2023-05-25 13:38:42.000000', 138, 15921, 13, 0.9986438564169191), (103659, '2023-05-25 13:35:11.000000', 138, 15926, 13, 0.8549591705597201), (108796, '2023-05-25 18:43:18.000000', 138, 15932, 13, 0.6213586835883191), (108795, '2023-05-25 18:00:00.000000', 138, 15932, 13, 0.6730718577847092), (107326, '2023-05-25 14:00:01.000000', 138, 15932, 13, 0.278131899094646), (107298, '2023-05-25 14:00:00.000000', 138, 15932, 13, 0.92423751071723), (104702, '2023-05-25 12:36:55.000000', 138, 15932, 13, 0.22221315122722984), (105175, '2023-05-25 12:00:01.000000', 138, 15932, 13, 0.28839114292751233), (102736, '2023-05-25 16:15:29.000000', 138, 16052, 13, 0.431037595792759), (99163, '2023-05-25 13:47:30.000000', 138, 16419, 13, 0.5291021511946319), (102738, '2023-05-25 13:45:05.000000', 138, 16420, 13, 0.6506497895856924), (99109, '2023-05-25 13:37:49.000000', 138, 16420, 13, 0.019501542758906254), (108798, '2023-05-25 18:43:18.000000', 138, 16590, 13, 0.8990882904615916), (108797, '2023-05-25 18:00:00.000000', 138, 16590, 13, 0.8888186371755147), (107328, '2023-05-25 14:00:01.000000', 138, 16590, 13, 0.019486942610562608), (107300, '2023-05-25 14:00:00.000000', 138, 16590, 13, 0.5614292991802508), (104698, '2023-05-25 12:36:55.000000', 138, 16590, 13, 0.01866956387405594), (105173, '2023-05-25 12:00:01.000000', 138, 16590, 13, 0.25661478763909074), (107224, '2023-05-25 13:51:57.000000', 138, 16633, 13, 0.0010321723593804677), (99064, '2023-05-25 13:37:49.000000', 138, 16633, 13, 0.8675616866165861), (109225, '2023-05-25 22:13:01.000000', 138, 16669, 13, 0.1076822852142385), (109224, '2023-05-25 21:11:56.000000', 138, 16669, 13, 0.24001365186054713); SELECT compress_chunk(show_chunks('test', older_than => INTERVAL '1 week'), true); SELECT t.dttm FROM test t WHERE t.dttm > '2023-05-25T14:23:12' ORDER BY t.dttm; -- Test that the enable_sort GUC doesn't disable the batch sorted merge plan. SET enable_sort TO OFF; set timescaledb.debug_require_batch_sorted_merge = 'require'; :PREFIX SELECT t.dttm FROM test t ORDER BY t.dttm LIMIT 1; RESET enable_sort; reset timescaledb.debug_require_batch_sorted_merge; �����������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_sorted_merge_columns.sql��������������������������������0000664�0000000�0000000�00000006565�15100345067�0026030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test various corner cases of sorting. create table t(x int, time timestamp, timetz timestamptz, int32 int4, int64 int8, s text); select create_hypertable('t', 'x'); insert into t values (1, '2022-01-01', '2023-01-01', 5, -13, 'a'), (2, '2023-01-01', '2025-01-01', 1, -13, 'b'), (3, '2024-01-01', '2021-01-01', 3, -16, 'd'), (4, '2025-01-01', '2021-01-01', -2, 12, 'e'), (5, '2021-01-01', '2026-01-01', -2, 14, 'e'), (6, '2021-01-01', '2022-01-01', -4, 15, 'c') ; alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='time'); select compress_chunk(show_chunks('t')) \gset set enable_sort to off; set timescaledb.enable_decompression_sorted_merge to on; set timescaledb.debug_require_batch_sorted_merge to 'require'; -- set enable_sort to on; -- set timescaledb.enable_decompression_sorted_merge to off; -- set timescaledb.debug_require_batch_sorted_merge to off; select * from t order by time; -- Test the fix for #7975: batch sort merge over eligible OpExpr and FuncExpr select time::timestamptz + interval '1 second' from t order by time::timestamptz + interval '1 second'; select time + interval '1 second' from t order by time + interval '1 second'; select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='timetz,time'); select compress_chunk(show_chunks('t')) \gset select * from t order by timetz, time; select timetz::timestamp + interval '1 second' from t order by timetz::timestamp + interval '1 second'; select timetz + interval '1 second' from t order by timetz + interval '1 second'; select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='int32,timetz,time'); select compress_chunk(show_chunks('t')) \gset select * from t order by int32, timetz, time; select int32 + 1 from t order by int32 + 1; -- Sort Merge not used because only last Order By expression can be sort-transformed, not both of them \set ON_ERROR_STOP 0 select int32 + 1, timetz + interval '1 second' from t order by int32 + 1, timetz + interval '1 second'; \set ON_ERROR_STOP 1 select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='int64,int32,timetz,time'); select compress_chunk(show_chunks('t')) \gset select * from t order by int64, int32, timetz, time; -- Both sides of OpExpr have to be of the same type for sort_transform to work select int64 + 1 from t order by int64 + 1::int8; -- Batch sort merge won't be used as sides of OpExpr are of different types (int8 vs int4) \set ON_ERROR_STOP 0 select int64 + 1 from t order by int64 + 1; \set ON_ERROR_STOP 1 select decompress_chunk(show_chunks('t')) \gset alter table t set (timescaledb.compress, timescaledb.compress_segmentby='x', timescaledb.compress_orderby='s,int32,time desc'); select compress_chunk(show_chunks('t')) \gset select * from t order by s, int32, time desc; -- Batch sort merge won't be used as only Int and Date/Time types are allowed in OpExpr \set ON_ERROR_STOP 0 select s||'1' from t order by s||'1'; \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_sorted_merge_distinct.sql�������������������������������0000664�0000000�0000000�00000005157�15100345067�0026165�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test that the compressed batch sorted merge plan is chosen based on the -- cardinality of the segmentby columns. set max_parallel_workers_per_gather = 0; -- helper function: float -> pseudorandom float [0..1]. create or replace function mix(x float4) returns float4 as $$ select ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ language sql; create table t(ts timestamp, low_card int, high_card int, value float); select create_hypertable('t', 'ts'); insert into t select '2020-01-01'::timestamp + interval '1 second' * (x + 0.1 * mix(low_card + high_card + x)), low_card, high_card, 100 * mix(low_card + high_card) * sin(x / mix(low_card + high_card + 1)) from generate_series(1, 400) x, generate_series(1, 3) low_card, generate_series(1, 700) high_card; alter table t set (timescaledb.compress = true, timescaledb.compress_segmentby = 'low_card,high_card'); select count(compress_chunk(x, true)) from show_chunks('t') x; analyze t; explain (buffers off, costs off) select * from t order by ts; explain (buffers off, costs off) select * from t where low_card = 1 order by ts; explain (buffers off, costs off) select * from t where high_card = 1 order by ts; explain (buffers off, costs off) select * from t where low_card = 1 and high_card = 1 order by ts; -- Test that batch sorted merge is not disabled by enable_sort. We have another -- GUC to disable it. set enable_sort to off; explain (buffers off, costs off) select * from t where high_card = 1 order by ts; reset enable_sort; -- Test that inequality conditions in WHERE also influence the estimates. explain (buffers off, costs off) select * from t where high_card < 10 order by ts; explain (buffers off, costs off) select * from t where high_card < 500 order by ts; -- Test that batch sorted merge respects the working memory limit. set work_mem to 64; explain (buffers off, costs off) select * from t where high_card < 10 order by ts; reset work_mem; -- Test for large values of memory limit bytes that don't fit into an int. -- Note that on i386 the max value is 2GB which is not enough to trigger the -- overflow we had on 64-bit systems, so we have to use different values based -- on the architecture. select least(4194304, max_val::bigint) large_work_mem from pg_settings where name = 'work_mem' \gset set work_mem to :large_work_mem; explain (buffers off, costs off) select * from t where high_card < 10 order by ts; reset work_mem; reset max_parallel_workers_per_gather; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_sorted_merge_filter.sql���������������������������������0000664�0000000�0000000�00000005260�15100345067�0025624�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. create table batches(ts timestamp, id int); select create_hypertable('batches', 'ts'); alter table batches set (timescaledb.compress, timescaledb.compress_segmentby = 'id'); insert into batches values ('2022-02-02 00:00:01', 1), ('2022-02-02 00:00:11', 1), ('2022-02-02 00:00:02', 2), ('2022-02-02 00:00:12', 2), ('2022-02-02 00:00:03', 3), ('2022-02-02 00:00:13', 3); select compress_chunk(x, true) from show_chunks('batches') x; analyze batches; set timescaledb.debug_require_batch_sorted_merge to 'require'; set enable_sort to off; select ts from batches where ts != '2022-02-02 00:00:02' order by ts; -- check that the GUC actually works \set ON_ERROR_STOP off set timescaledb.enable_decompression_sorted_merge to off; select ts from batches where ts != '2022-02-02 00:00:02' order by ts; reset timescaledb.enable_decompression_sorted_merge; \set ON_ERROR_STOP on -- middle batch entirely filtered out truncate table batches; alter table batches add column filter bool; insert into batches values ('2022-02-02 00:00:01', 1, true), ('2022-02-02 00:00:11', 1, true), ('2022-02-02 00:00:02', 2, true), ('2022-02-02 00:00:12', 2, true), ('2022-02-02 00:00:03', 3, false), ('2022-02-02 00:00:13', 3, false); select compress_chunk(x, true) from show_chunks('batches') x; analyze batches; select ts from batches where filter order by ts; -- last batch entirely filtered out truncate table batches; insert into batches values ('2022-02-02 00:00:01', 1, true), ('2022-02-02 00:00:02', 1, true), ('2022-02-02 00:00:03', 2, true), ('2022-02-02 00:00:04', 2, true), ('2022-02-02 00:00:05', 3, false), ('2022-02-02 00:00:06', 3, false); select compress_chunk(x, true) from show_chunks('batches') x; analyze batches; select ts from batches where filter order by ts; -- first batch entirely filtered out truncate table batches; insert into batches values ('2022-02-02 00:00:01', 1, false), ('2022-02-02 00:00:02', 1, false), ('2022-02-02 00:00:03', 2, true), ('2022-02-02 00:00:04', 2, true), ('2022-02-02 00:00:05', 3, true), ('2022-02-02 00:00:06', 3, true); select compress_chunk(x, true) from show_chunks('batches') x; analyze batches; select ts from batches where filter order by ts; -- Test case for EquivalenceMember from a join rel (with multiple em_relids). select * from batches join ( select coalesce(t2.t, t1.t) t from (select now() + random() * interval '1s' t) t1 left join (select now() + random() * interval '1s' t) t2 on t1 = t2 ) t3 on batches.ts = t3.t order by ts; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_trigger.sql���������������������������������������������0000664�0000000�0000000�00000011041�15100345067�0023235�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This is copied from hypercore_trigger.sql set client_min_messages to warning; create table readings( metric_id serial, created_at timestamptz not null unique, location_id smallint, --segmentby attribute with index owner_id bigint, --segmentby attribute without index device_id bigint, --non-segmentby attribute temp float8, humidity float4 ); select create_hypertable('readings', by_range('created_at')); select setseed(1); insert into readings(created_at, location_id, device_id, owner_id, temp, humidity) select t, ceil(random()*10), ceil(random()*30), ceil(random() * 5), random()*40, random()*100 from generate_series('2022-06-01'::timestamptz, '2022-07-01', '5m') t; alter table readings set ( timescaledb.compress, timescaledb.compress_orderby = 'created_at', timescaledb.compress_segmentby = 'location_id, owner_id' ); select compress_chunk(show_chunks('readings')); create table saved_rows (like readings, new_row bool not null, kind text); create function save_transition_table() returns trigger as $$ begin case tg_op when 'INSERT' then insert into saved_rows select n.*, true, tg_op from new_table n; when 'DELETE' then insert into saved_rows select o.*, false, tg_op from old_table o; when 'UPDATE' then insert into saved_rows select n.*, true, tg_op from new_table n; insert into saved_rows select o.*, false, tg_op from old_table o; end case; return null; end; $$ language plpgsql; create trigger save_insert_transition_table_trg after insert on readings referencing new table as new_table for each statement execute function save_transition_table(); insert into readings(created_at, location_id, device_id, owner_id, temp, humidity) values ('2022-06-01 00:01:23', 999, 666, 111, 3.14, 3.14), ('2022-06-01 00:02:23', 999, 666, 112, 3.14, 3.14); select * from saved_rows order by metric_id; truncate saved_rows; select compress_chunk(show_chunks('readings')); copy readings(created_at, location_id, device_id, owner_id, temp, humidity) from stdin with (format csv); "2022-06-01 00:01:35",999,666,111,3.14,3.14 \. select * from saved_rows order by metric_id; truncate saved_rows; select compress_chunk(show_chunks('readings')); create trigger save_update_transition_table_trg after update on readings referencing new table as new_table old table as old_table for each statement execute function save_transition_table(); select * from readings where location_id = 999 order by metric_id; update readings set humidity = 99.99 where location_id = 999; select * from saved_rows order by metric_id; truncate saved_rows; select compress_chunk(show_chunks('readings')); -- This is not supported since it is possible to delete an entire -- segment without executing the trigger. \set ON_ERROR_STOP 0 create trigger save_delete_transition_table_trg after delete on readings referencing old table as old_table for each statement execute function save_transition_table(); \set ON_ERROR_STOP 1 -- Test that we get an error when enabling compression and have a -- delete trigger with a transition table. We allow transition tables -- for update and insert triggers. create table test2( created_at timestamptz not null unique, location_id bigint, temp float8 ); select create_hypertable('test2', by_range('created_at')); create trigger save_test2_insert_trg after insert on test2 referencing new table as new_table for each statement execute function save_transition_table(); create trigger save_test2_update_trg after update on test2 referencing new table as new_table old table as old_table for each statement execute function save_transition_table(); create trigger save_test2_delete_trg after delete on test2 referencing old table as old_table for each statement execute function save_transition_table(); -- This should fail \set ON_ERROR_STOP 0 alter table test2 set ( timescaledb.compress, timescaledb.compress_orderby = 'created_at', timescaledb.compress_segmentby = 'location_id' ); \set ON_ERROR_STOP 1 -- drop the delete trigger drop trigger save_test2_delete_trg on test2; -- This should now succeed. alter table test2 set ( timescaledb.compress, timescaledb.compress_orderby = 'created_at', timescaledb.compress_segmentby = 'location_id' ); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_update_delete.sql.in������������������������������������0000664�0000000�0000000�00000211465�15100345067�0025017�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (buffers off, costs off, timing off, summary off, analyze)' CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE sample_table ( time TIMESTAMP WITH TIME ZONE NOT NULL, sensor_id INTEGER NOT NULL, cpu double precision null, temperature double precision null, name varchar(100) default 'this is a default string value' ); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => INTERVAL '2 months'); \set start_date '2022-01-28 01:09:53.583252+05:30' INSERT INTO sample_table SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series(:'start_date'::timestamptz - INTERVAL '1 months', :'start_date'::timestamptz - INTERVAL '1 week', INTERVAL '1 hour') AS g1(time), generate_series(1, 8, 1 ) AS g2(sensor_id) ORDER BY time; \set start_date '2023-03-17 17:51:11.322998+05:30' -- insert into new chunks INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 21.98, 33.123, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 12, 17.66, 13.875, 'new row1'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 13, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 1, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 4, 21.98, 33.123, 'new row2'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 5, 0.988, 33.123, 'new row3'); INSERT INTO sample_table VALUES (:'start_date'::timestamptz, 6, 4.6554, 47, 'new row3'); -- enable compression ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id' ); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- test rows visibility BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; -- update 4 rows UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- report 0 rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; ROLLBACK; -- get count of affected rows SELECT count(*) FROM sample_table WHERE cpu = 21.98 AND temperature = 33.123; -- do update UPDATE sample_table SET name = 'updated row' WHERE cpu = 21.98 AND temperature = 33.123; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- recompress the partial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- get count of affected rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; -- do delete DELETE FROM sample_table WHERE name = 'updated row'; -- get count of updated rows SELECT count(*) FROM sample_table WHERE name = 'updated row'; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); -- test for IS NULL checks -- should not UPDATE any rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- test for IS NOT NULL checks -- should UPDATE all rows UPDATE sample_table SET temperature = 34.21 WHERE sensor_id IS NOT NULL; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- recompress the paritial chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; -- get total count of rows which satifies the condition SELECT COUNT(*) as "total_affected_rows" FROM sample_table WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30' \gset -- perform UPDATE with < and > comparison on SEGMENTBY column UPDATE sample_table SET name = 'updated row based on < OR > comparison' WHERE time > '2022-01-20 19:10:00.101514+05:30' and time < '2022-01-20 21:10:43.855297+05:30'; -- check chunk compression status after UPDATE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- count should be same SELECT COUNT(*) = (:total_affected_rows) FROM sample_table WHERE name = 'updated row based on < OR > comparison'; DROP TABLE sample_table; -- test to ensure that only required rows from compressed chunks -- are extracted if SEGMENTBY column is used in WHERE condition CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (10, 3, 2), (11, 4, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; -- delete rows with device_id = 3 DELETE FROM sample_table WHERE device_id = 3; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id = 3; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id = 3; -- there should be no rows SELECT * FROM sample_table WHERE device_id = 3 ORDER BY time, device_id; -- there should 2 rows matching the conditions coming from 2 chunks SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; -- update rows with device_id = 1 UPDATE sample_table SET val = 200 WHERE 1 = device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id = 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE 1 = device_id; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE 1 = device_id; -- there should be 2 rows SELECT val FROM sample_table WHERE 1 = device_id ORDER BY time, device_id; DROP TABLE sample_table; CREATE TABLE sample_table( time INT NOT NULL, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'time, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, 2, 1), (3, 3, 1), (1, 3, 2), (11, 4, 2), (1, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- there should 2 rows matching the conditions coming from 2 chunks SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where time = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; -- delete rows with time = 1 AND val = 2 EXPLAIN (buffers off, costs off, verbose) DELETE FROM sample_table WHERE time = 1 AND 2 = val; -- should delete rows from 1 of the compressed chunks DELETE FROM sample_table WHERE time = 1 AND 2 = val; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks wheretime = 1 AND val = 2 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE time = 1 AND val = 2; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE time = 1 AND val = 2; -- there should be no rows SELECT * FROM sample_table WHERE time = 1 AND val = 2 ORDER BY time, device_id; DROP TABLE sample_table; -- Test chunk compile time startup exclusion CREATE OR REPLACE FUNCTION now_s() RETURNS timestamptz LANGUAGE PLPGSQL STABLE AS $BODY$ BEGIN RETURN '2017-08-22T10:00:00'::timestamptz; END; $BODY$; CREATE TABLE sample_table(time timestamptz NOT NULL, temp float, colorid integer, attr jsonb); SELECT create_hypertable('sample_table', 'time', chunk_time_interval => 2628000000000); -- create three chunks INSERT INTO sample_table VALUES ('2017-03-22T09:18:22', 23.5, 1, '{"a": 1, "b": 2}'), ('2017-03-22T09:18:23', 21.5, 1, '{"a": 1, "b": 2}'), ('2017-05-22T09:18:22', 36.2, 2, '{"c": 3, "b": 2}'), ('2017-05-22T09:18:23', 15.2, 2, '{"c": 3}'), ('2017-08-22T09:18:22', 34.1, 3, '{"c": 4}'); ALTER TABLE sample_table SET (timescaledb.compress, timescaledb.compress_segmentby = 'time'); SELECT compress_chunk(show_chunks('sample_table')); -- ensure all chunks are compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- report 0 rows SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; -- update 1 row UPDATE sample_table SET colorid = 4 WHERE time > now_s() + '-1 month'; -- report 1 row SELECT * FROM sample_table WHERE time > now_s() + '-1 month' AND colorid = 4; -- ensure that 1 chunk is partially compressed SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; DROP TABLE sample_table; -- test for NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, NULL, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE device_id IS NULL; -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id IS NULL; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; DROP TABLE sample_table; -- test for IS NOT NULL values in SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO sample_table VALUES (1, NULL, 1), (2, NULL, 1), (3, NULL, 1), (10, 3, 2), (11, 2, 2), (11, 1, 2); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset SELECT COUNT(*) FROM sample_table WHERE val = 1234; -- UPDATE based on IS NOT NULL condition on SEGMENTBY column UPDATE sample_table SET val = 1234 WHERE device_id IS NOT NULL; -- get total count of SEGMENTBY column with NULL values SELECT COUNT(*) FROM sample_table WHERE val = 1234; -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; DROP TABLE sample_table; -- test to for <= AND >= on SEGMENTBY column CREATE TABLE sample_table( time INT, device_id INT, val INT); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 10); ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, val'); INSERT INTO sample_table VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); INSERT INTO sample_table VALUES (4, 3, NULL), (6, NULL, NULL), (12, NULL, NULL), (13, 4, NULL); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); -- test will multiple NULL/NOT NULL columns BEGIN; -- report 0 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; -- these 3 rows will be affected by below UPDATE SELECT * FROM sample_table WHERE device_id IS NULL AND val IS NOT NULL ORDER BY 1; -- update 3 rows UPDATE sample_table SET val = 987 WHERE device_id IS NULL AND val IS NOT NULL; -- report 3 row SELECT * FROM sample_table WHERE device_id IS NULL AND val = 987; ROLLBACK; -- test will multiple columns BEGIN; -- report 2 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; -- delete 2 rows DELETE from sample_table WHERE device_id IS NULL AND val = 2; -- report 0 rows SELECT * FROM sample_table WHERE device_id IS NULL AND val = 2; ROLLBACK; BEGIN; -- report 1 row SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; -- delete 1 rows DELETE from sample_table WHERE device_id = 3 AND val IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE device_id = 3 AND val IS NULL; ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; -- get total count of SEGMENTBY column with device_id >= 4 AND val <= 1 SELECT COUNT(*) FROM sample_table WHERE device_id >= 4 AND val <= 1; -- delete NULL values in SEGMENTBY column DELETE FROM sample_table WHERE device_id >= 4 AND val <= 1; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id >= 4 AND val <= 1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id >= 4 AND val <= 1; -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- added tests for code coverage UPDATE sample_table SET time = 21 WHERE (device_id) in ( 30, 51, 72, 53); UPDATE sample_table SET time = 21 WHERE device_id + 365 = 8765; DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table( time INT, device_id INT, val INT default 8, a INT default 10, b INT default 11, c INT default 12, d INT, e INT default 13); SELECT * FROM create_hypertable('sample_table', 'time', chunk_time_interval => 5); INSERT INTO sample_table (time, device_id, d) VALUES (1, 1, 1), (2, NULL, 1), (3, 4, 1), (10, NULL, 2), (11, NULL, 2), (11, 1, 2), (13, 5, 3); ALTER TABLE sample_table DROP COLUMN c; ALTER TABLE sample_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, d'); -- compress all chunks SELECT compress_chunk(show_chunks('sample_table')); ALTER TABLE sample_table ADD COLUMN c int default 23; -- check chunk compression status SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- get FIRST uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND uncompressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "UNCOMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- get SECOND compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_2" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id DESC LIMIT 1 \gset -- ensure segment by column index position in compressed and uncompressed -- chunk is different SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_1'::regclass, :'UNCOMPRESS_CHUNK_1'::regclass) AND attname = 'd' ORDER BY attnum; SELECT attname, attnum FROM pg_attribute WHERE attrelid IN (:'COMPRESS_CHUNK_2'::regclass, :'UNCOMPRESS_CHUNK_2'::regclass) AND attname = 'd' ORDER BY attnum; -- get total rowcount from compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; -- get total count of SEGMENTBY column with d = 3 SELECT COUNT(*) FROM sample_table WHERE d = 3; -- delete based on SEGMENTBY column DELETE FROM sample_table WHERE d = 3; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where d = 3 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE d = 3; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE d = 3; -- check chunk compression status after DELETE SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- get rowcount from compressed chunks where device_id IS NULL SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; BEGIN; -- report 0 row SELECT * FROM sample_table WHERE a = 247; -- delete 1 row UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- ensure rows are visible SELECT * FROM sample_table WHERE a = 247; ROLLBACK; -- report 0 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; -- UPDATE based on NULL values in SEGMENTBY column UPDATE sample_table SET a = 247 WHERE device_id IS NULL; -- report 3 rows SELECT COUNT(*) FROM sample_table WHERE a = 247; -- ensure that not all rows are moved to staging area -- should have few compressed rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2; -- get rowcount from compressed chunks where device_id IS NULL -- should report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE device_id IS NULL; SELECT COUNT(*) FROM :COMPRESS_CHUNK_2 WHERE device_id IS NULL; DROP TABLE sample_table; -- test with different physical layout CREATE TABLE sample_table(time timestamptz, c1 text, c2 text, c3 text); SELECT create_hypertable('sample_table','time'); INSERT INTO sample_table SELECT '2000-01-01'; ALTER TABLE sample_table DROP column c3; ALTER TABLE sample_table ADD column c4 text; INSERT INTO sample_table SELECT '2000-01-01', '1', '2', '3'; ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4'); SELECT compress_chunk(show_chunks('sample_table')); BEGIN; -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 rows SELECT * FROM sample_table WHERE c4 IS NULL; ROLLBACK; -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id \gset -- report 2 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; -- report 1 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; -- report 1 row SELECT * FROM sample_table WHERE c4 IS NULL; -- delete 1 row DELETE FROM sample_table WHERE c4 IS NULL; -- report 0 row SELECT * FROM sample_table WHERE c4 IS NULL; -- report 1 row which ensure that only required row is moved and deleted SELECT COUNT(*) FROM :COMPRESS_CHUNK_1; -- report 0 row SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 IS NULL; DROP TABLE sample_table; -- test filtering with ORDER BY columns CREATE TABLE sample_table(time timestamptz, c1 int, c2 int, c3 int, c4 int); SELECT create_hypertable('sample_table','time',chunk_time_interval=>'1 day'::interval); ALTER TABLE sample_table SET (timescaledb.compress,timescaledb.compress_segmentby='c4', timescaledb.compress_orderby='c1,c2,time'); INSERT INTO sample_table SELECT t, c1, c2, c3, c4 FROM generate_series(:'start_date'::timestamptz - INTERVAL '9 hours', :'start_date'::timestamptz, INTERVAL '1 hour') t, generate_series(0,9,1) c1, generate_series(0,9,1) c2, generate_series(0,9,1) c3, generate_series(0,9,1) c4; SELECT compress_chunk(show_chunks('sample_table')); -- get FIRST chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper_%' ORDER BY ch1.id LIMIT 1 \gset -- get FIRST compressed chunk SELECT ch1.schema_name|| '.' || ch1.table_name AS "COMPRESS_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ch1.hypertable_id = ht.id AND ch1.table_name LIKE 'compress_%' ORDER BY ch1.id LIMIT 1 \gset -- check that you uncompress and delete only for exact SEGMENTBY value SET timescaledb.debug_compression_path_info TO true; BEGIN; -- report 10 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 \gset -- delete 10k rows DELETE FROM sample_table WHERE c4 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 = 5; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only for less than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 < 5; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 < 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 < 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 < 5; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 < 5; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only for greater and equal than SEGMENTBY value BEGIN; -- report 50 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; -- report 50k rows SELECT COUNT(*) FROM sample_table WHERE c4 >= 5; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 >= 5 \gset -- delete 50k rows DELETE FROM sample_table WHERE c4 >= 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 >= 5; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 where c4 >= 5; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only for exact ORDERBY value -- this will uncompress segments which have min <= value and max >= value BEGIN; -- report 10k rows SELECT COUNT(*) FROM sample_table WHERE c2 = 3; -- report 100 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c2 = 3 \gset -- delete 10k rows DELETE FROM sample_table WHERE c2 = 3; -- report 0 rows SELECT count(*) FROM sample_table WHERE c2 = 3; -- report 90k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_2 <= 3 and _ts_meta_max_2 >= 3; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only for less then ORDERBY value -- this will uncompress segments which have min < value BEGIN; -- report 20k rows SELECT COUNT(*) FROM sample_table WHERE c1 < 2; -- report 20 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 < 2 \gset -- delete 20k rows DELETE FROM sample_table WHERE c1 < 2; -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 < 2; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunk SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_max_1 < 2; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only for greater or equal then ORDERBY value -- this will uncompress segments which have max >= value BEGIN; -- report 30k rows SELECT COUNT(*) FROM sample_table WHERE c1 >= 7; -- report 30 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c1 >= 7 \gset -- delete 30k rows DELETE FROM sample_table WHERE c1 >= 7; -- report 0 rows SELECT count(*) FROM sample_table WHERE c1 >= 7; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE _ts_meta_min_1 >= 7; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments only contain one distinct value for -- these qualifiers, everything should be deleted that was decompressed BEGIN; -- report 1k rows SELECT COUNT(*) FROM sample_table WHERE c4 = 5 and c1 = 5; -- report 1 row in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 = 5 and c1 = 5 \gset -- delete 1k rows DELETE FROM sample_table WHERE c4 = 5 and c1 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 and c1 = 5; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 5 AND _ts_meta_min_1 <= 5 and _ts_meta_max_1 >= 5; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers, segments contain more than one distinct value for -- these qualifiers, not everything should be deleted that was decompressed BEGIN; -- report 4k rows SELECT COUNT(*) FROM sample_table WHERE c4 > 5 and c2 = 5; -- report 40 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; -- fetch total and number of affected rows SELECT COUNT(*) AS "total_rows" FROM sample_table \gset SELECT COUNT(*) AS "total_affected_rows" FROM sample_table WHERE c4 > 5 and c2 = 5 \gset -- delete 4k rows DELETE FROM sample_table WHERE c4 > 5 and c2 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 > 5 and c2 = 5; -- report 36k rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 0 rows in compressed chunks SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 > 5 AND _ts_meta_min_2 <= 5 and _ts_meta_max_2 >= 5; -- validate correct number of rows was deleted -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM sample_table; ROLLBACK; -- check that you uncompress and delete only tuples which satisfy SEGMENTBY -- and ORDERBY qualifiers. -- no: of rows satisfying SEGMENTBY qualifiers is 10 -- no: of rows satisfying ORDERBY qualifiers is 3 -- Once both qualifiers are applied ensure that only 7 rows are present in -- compressed chunk BEGIN; -- report 0 rows in uncompressed chunk SELECT COUNT(*) FROM ONLY :CHUNK_1; -- report 10 compressed rows for given condition c4 = 4 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; -- report 3 compressed rows for given condition c4 = 4 and c1 >= 7 SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7; SELECT COUNT(*) AS "total_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 \gset SELECT COUNT(*) AS "total_affected_rows" FROM :COMPRESS_CHUNK_1 WHERE c4 = 4 AND _ts_meta_max_1 >= 7 \gset UPDATE sample_table SET c3 = c3 + 0 WHERE c4 = 4 AND c1 >= 7; -- report 7 rows SELECT COUNT(*) FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; -- ensure correct number of rows are moved from compressed chunk -- report true SELECT COUNT(*) = :total_rows - :total_affected_rows FROM :COMPRESS_CHUNK_1 WHERE c4 = 4; ROLLBACK; RESET timescaledb.debug_compression_path_info; --github issue: 5640 CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab1(time); CREATE INDEX ON tab1(device_id,time); SELECT create_hypertable('tab1','time',create_default_indexes:=false); ALTER TABLE tab1 DROP COLUMN filler_1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','57m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_2; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','58m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab1 DROP COLUMN filler_3; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','59m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab1; -- compress chunks ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab1')); -- ensure there is an index scan generated for below DELETE query BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; ANALYZE tab1; EXPLAIN (buffers off, costs off) DELETE FROM public.tab1 WHERE public.tab1.device_id = 1; DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; ROLLBACK; -- github issue 5658 -- verify that bitmap heap scans work on all the correct data and -- none of it left over after the dml command BEGIN; SELECT count(*) FROM tab1 WHERE device_id = 1; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); SELECT count(*) FROM tab1 WHERE device_id = 1; ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) DELETE FROM tab1 WHERE tab1.device_id = 1; DELETE FROM tab1 WHERE tab1.device_id = 1; SELECT count(*) FROM tab1 WHERE device_id = 1; ROLLBACK; -- verify we can work with expression indexes and toastable types -- when the subquery returns a zero result set we used to end up -- trying to detoast a 0 value and segfaulting BEGIN; INSERT INTO tab1(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 1000, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX test ON tab1(repeat('t', device_id)); CREATE TABLE join_table AS SELECT repeat('t', d) FROM generate_series(1,3,1) d; ANALYZE tab1; SET enable_seqscan = off; SET enable_indexscan = off; EXPLAIN (buffers off, costs off) UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; UPDATE tab1 SET v0 = 0 FROM (SELECT repeat, count(*) FROM join_table WHERE false group by 1) as devices WHERE repeat('t', device_id) = devices.repeat; ROLLBACK; -- create hypertable with space partitioning and compression CREATE TABLE tab2(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON tab2(time); CREATE INDEX ON tab2(device_id,time); SELECT create_hypertable('tab2','time','device_id',3,create_default_indexes:=false); ALTER TABLE tab2 DROP COLUMN filler_1; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','35m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_2; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','45m') gtime(time), generate_series(1,1,1) gdevice(device_id); ALTER TABLE tab2 DROP COLUMN filler_3; INSERT INTO tab2(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','55m') gtime(time), generate_series(1,1,1) gdevice(device_id); ANALYZE tab2; -- compress chunks ALTER TABLE tab2 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('tab2')); -- below test will cause chunks of tab2 to get decompressed -- without fix for issue #5460 SET timescaledb.enable_optimizations = OFF; BEGIN; DELETE FROM tab1 t1 USING tab2 t2 WHERE t1.device_id = t2.device_id AND t2.time > '2000-01-01'; ROLLBACK; --cleanup RESET timescaledb.enable_optimizations; DROP table tab1; DROP table tab2; -- test joins with UPDATE/DELETE on compression chunks CREATE TABLE join_test1(time timestamptz NOT NULL,device text, value float); CREATE TABLE join_test2(time timestamptz NOT NULL,device text, value float); CREATE VIEW chunk_status AS SELECT ht.table_name AS hypertable, ch.table_name AS chunk,ch.status from _timescaledb_catalog.chunk ch INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id=ch.hypertable_id AND ht.table_name IN ('join_test1','join_test2') ORDER BY ht.id, ch.id; SELECT table_name FROM create_hypertable('join_test1', 'time'); SELECT table_name FROM create_hypertable('join_test2', 'time'); ALTER TABLE join_test1 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); ALTER TABLE join_test2 SET (timescaledb.compress, timescaledb.compress_segmentby='device'); INSERT INTO join_test1 VALUES ('2000-01-01','d1',0.1), ('2000-02-01','d1',0.1), ('2000-03-01','d1',0.1); INSERT INTO join_test2 VALUES ('2000-02-01','d1',0.1), ('2000-02-01','d2',0.1), ('2000-02-01','d3',0.1); SELECT compress_chunk(show_chunks('join_test1')); SELECT compress_chunk(show_chunks('join_test2')); SELECT * FROM chunk_status; BEGIN; DELETE FROM join_test1 USING join_test2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; ROLLBACK; BEGIN; DELETE FROM join_test2 USING join_test1; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status change SELECT * FROM chunk_status; ROLLBACK; BEGIN; DELETE FROM join_test1 t1 USING join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test2 t2; -- only join_test1 chunks should have status 9 SELECT * FROM chunk_status; ROLLBACK; BEGIN; UPDATE join_test2 t1 SET value = t1.value + 1 FROM join_test1 t2; -- only join_test2 chunks should have status 9 SELECT * FROM chunk_status; ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t1.time = '2000-01-01'; -- only first chunk of join_test1 should have status 9 SELECT * FROM chunk_status; ROLLBACK; BEGIN; UPDATE join_test1 t1 SET value = t1.value + 1 FROM join_test1 t2 WHERE t2.time = '2000-01-01'; -- all chunks of join_test1 should have status 9 SELECT * FROM chunk_status; ROLLBACK; DROP TABLE join_test1; DROP TABLE join_test2; -- test if index scan qualifiers are properly used CREATE TABLE index_scan_test(time timestamptz NOT NULL, device_id int, value float); SELECT create_hypertable('index_scan_test','time',create_default_indexes:=false); INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-01 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- compress chunks ALTER TABLE index_scan_test SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('index_scan_test')); ANALYZE index_scan_test; SELECT ch1.schema_name|| '.' || ch1.table_name AS "CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.table_name LIKE '_hyper%' ORDER BY ch1.id LIMIT 1 \gset SELECT ch2.schema_name|| '.' || ch2.table_name AS "COMP_CHUNK_1" FROM _timescaledb_catalog.chunk ch1, _timescaledb_catalog.chunk ch2, _timescaledb_catalog.hypertable ht WHERE ht.table_name = 'index_scan_test' AND ch1.hypertable_id = ht.id AND ch1.compressed_chunk_id = ch2.id ORDER BY ch2.id LIMIT 1 \gset INSERT INTO index_scan_test(time,device_id,value) SELECT time, device_id, device_id + 0.5 FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','1m') gtime(time), generate_series(1,5,1) gdevice(device_id); -- test index on single column BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2; DELETE FROM index_scan_test WHERE device_id = 2; -- everything should be deleted SELECT count(*) FROM index_scan_test where device_id = 2; -- there shouldn't be anything in the uncompressed chunk where device_id = 2 SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; -- there shouldn't be anything in the compressed chunk from device_id = 2 SELECT count(*) FROM :COMP_CHUNK_1 where device_id = 2; ROLLBACK; -- test multi column index BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id, time); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; ROLLBACK; -- test index with filter condition BEGIN; SELECT count(*) as "UNCOMP_LEFTOVER" FROM ONLY :CHUNK_1 WHERE device_id != 2 OR time <= '2000-01-02'::timestamptz \gset CREATE INDEX ON index_scan_test(device_id); EXPLAIN (buffers off, costs off, verbose) DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; DELETE FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- everything should be deleted SELECT count(*) FROM index_scan_test WHERE device_id = 2 AND time > '2000-01-02'::timestamptz; -- there shouldn't be anything in the uncompressed chunk that matches predicates SELECT count(*) = :UNCOMP_LEFTOVER FROM ONLY :CHUNK_1; -- there shouldn't be anything in the compressed chunk that matches predicates SELECT count(*) FROM :COMP_CHUNK_1 WHERE device_id = 2 AND _ts_meta_max_1 >= '2000-01-02'::timestamptz; ROLLBACK; -- test for disabling DML decompression SHOW timescaledb.enable_dml_decompression; SET timescaledb.enable_dml_decompression = false; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled UPDATE sample_table SET c3 = NULL WHERE c4 = 5; DELETE FROM sample_table WHERE c4 = 5; \set ON_ERROR_STOP 1 -- make sure reseting the GUC we will be able to UPDATE/DELETE compressed chunks RESET timescaledb.enable_dml_decompression; SHOW timescaledb.enable_dml_decompression; BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; UPDATE sample_table SET c3 = NULL WHERE c4 = 5; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5 AND c3 IS NULL; ROLLBACK; BEGIN; -- report 10k rows SELECT count(*) FROM sample_table WHERE c4 = 5; DELETE FROM sample_table WHERE c4 = 5; -- report 0 rows SELECT count(*) FROM sample_table WHERE c4 = 5; ROLLBACK; -- create new uncompressed chunk INSERT INTO sample_table SELECT t, 1, 1, 1, 1 FROM generate_series('2023-05-04 00:00:00-00'::timestamptz, '2023-05-04 00:00:00-00'::timestamptz + INTERVAL '2 hours', INTERVAL '1 hour') t; -- check chunk compression status SELECT chunk_name, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'sample_table' ORDER BY chunk_name; -- test for uncompressed and compressed chunks SHOW timescaledb.enable_dml_decompression; SET timescaledb.enable_dml_decompression = false; BEGIN; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- delete from uncompressed chunk should work DELETE FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; ROLLBACK; BEGIN; -- report 0 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; UPDATE sample_table SET c3 = NULL WHERE time >= '2023-05-04 00:00:00-00'::timestamptz; -- report 3 rows SELECT count(*) FROM sample_table WHERE time >= '2023-05-04 00:00:00-00'::timestamptz AND c3 IS NULL; ROLLBACK; \set ON_ERROR_STOP 0 -- should ERROR both UPDATE/DELETE statements because the DML decompression is disabled -- and both statements we're touching compressed and uncompressed chunks UPDATE sample_table SET c3 = NULL WHERE time >= '2023-03-17 00:00:00-00'::timestamptz AND c3 IS NULL; DELETE FROM sample_table WHERE time >= '2023-03-17 00:00:00-00'::timestamptz; \set ON_ERROR_STOP 1 --github issue: 5586 --testcase with multiple indexes \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test5586; \c test5586 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE tab1(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('tab1','time',create_default_indexes:=false); INSERT INTO tab1(filler_1, filler_2, filler_3,time,device_id,v0,v1,v2,v3) SELECT device_id, device_id+1, device_id + 2, time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE tab1 SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id, filler_1, filler_2, filler_3'); SELECT compress_chunk(show_chunks('tab1')); SELECT format('%I.%I', schema_name, table_name) AS "CHUNK" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 \gset -- create multiple indexes on compressed hypertable DROP INDEX _timescaledb_internal.compress_hyper_2_2_chunk_device_id_filler_1_filler_2_filler_idx; CREATE INDEX ON :CHUNK (_ts_meta_min_1); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_count); CREATE INDEX ON :CHUNK (_ts_meta_min_1, _ts_meta_max_1, filler_1); CREATE INDEX filler_1 ON :CHUNK (filler_1); CREATE INDEX filler_2 ON :CHUNK (filler_2); CREATE INDEX filler_3 ON :CHUNK (filler_3); -- below indexes should be selected CREATE INDEX filler_1_filler_2 ON :CHUNK (filler_1, filler_2); CREATE INDEX filler_2_filler_3 ON :CHUNK (filler_2, filler_3); set timescaledb.debug_compression_path_info to on; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_3 = 5 AND filler_2 = 4; UPDATE tab1 SET v0 = v1 + v2 WHERE filler_3 = 5 AND filler_2 = 4; ROLLBACK; BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5 AND filler_2 = 4; UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5 AND filler_2 = 4; ROLLBACK; -- idealy filler_1 index should be selected, -- instead first matching index is selected BEGIN; SELECT COUNT(*) FROM tab1 WHERE filler_1 < 5; UPDATE tab1 SET v0 = v1 + v2 WHERE filler_1 < 5; ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE tab1; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test5586 WITH (FORCE); --issue: #6024 CREATE TABLE t(a integer, b integer); SELECT create_hypertable('t', 'a', chunk_time_interval=> 10); INSERT INTO t values(1, 2); ALTER TABLE t SET (timescaledb.compress); SELECT compress_chunk(show_chunks('t')); -- should not crash UPDATE t SET b = 2 WHERE tableoid = 0; UPDATE t SET b = 2 WHERE tableoid is null; DROP TABLE t; -- github issue: 6367 \c :TEST_DBNAME :ROLE_SUPERUSER CREATE DATABASE test6367; \c test6367 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; CREATE TABLE t6367 ( time timestamptz NOT NULL, source_id varchar(64) NOT NULL, label varchar, data jsonb ); SELECT table_name FROM create_hypertable('t6367', 'time'); ALTER TABLE t6367 SET(timescaledb.compress, timescaledb.compress_segmentby = 'source_id, label', timescaledb.compress_orderby = 'time'); INSERT INTO t6367 SELECT time, source_id, label, '{}' AS data FROM generate_series('1990-01-01'::timestamptz, '1990-01-10'::timestamptz, INTERVAL '1 day') AS g1(time), generate_series(1, 3, 1 ) AS g2(source_id), generate_series(1, 3, 1 ) AS g3(label); SELECT compress_chunk(c) FROM show_chunks('t6367') c; SELECT format('%I.%I', schema_name, table_name) AS "CHUNK1" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 \gset SELECT format('%I.%I', schema_name, table_name) AS "CHUNK2" FROM _timescaledb_catalog.chunk WHERE hypertable_id = 2 ORDER BY id LIMIT 1 OFFSET 1 \gset DROP INDEX _timescaledb_internal.compress_hyper_2_3_chunk_source_id_label__ts_meta_min_1__ts_idx; DROP INDEX _timescaledb_internal.compress_hyper_2_4_chunk_source_id_label__ts_meta_min_1__ts_idx; -- testcase with no index, should use seq scan set timescaledb.debug_compression_path_info to on; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; ROLLBACK; -- test case with an index which has only one -- of the segmentby filters CREATE INDEX source_id_idx1 ON :CHUNK1 (source_id); CREATE INDEX source_id_idx2 ON :CHUNK2 (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; ROLLBACK; -- test that we are filtering NULL checks BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NULL; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NULL; ROLLBACK; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label IS NOT NULL; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label IS NOT NULL; ROLLBACK; DROP INDEX _timescaledb_internal.source_id_idx1; DROP INDEX _timescaledb_internal.source_id_idx2; -- test case with an index which has multiple same column CREATE INDEX source_id_source_id_idx ON :CHUNK1 (source_id, source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; ROLLBACK; DROP INDEX _timescaledb_internal.source_id_source_id_idx; -- test using a non-btree index -- fallback to heap scan CREATE INDEX brin_source_id_idx ON :CHUNK1 USING brin (source_id); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; ROLLBACK; DROP INDEX _timescaledb_internal.brin_source_id_idx; -- test using an expression index -- should fallback to heap scans CREATE INDEX expr_source_id_idx ON :CHUNK1 (upper(source_id)); BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; ROLLBACK; DROP INDEX _timescaledb_internal.expr_source_id_idx; -- test using a partial index -- should fallback to heap scans CREATE INDEX partial_source_id_idx ON :CHUNK1 (source_id) WHERE _ts_meta_min_1 > '1990-01-01'::timestamptz; BEGIN; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; UPDATE t6367 SET source_id = '0' WHERE source_id = '2' AND label = '1'; SELECT count(*) FROM t6367 WHERE source_id = '2' AND label = '1'; ROLLBACK; RESET timescaledb.debug_compression_path_info; DROP TABLE t6367; \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE test6367 WITH (FORCE); -- Text limitting decompressed tuple during an UPDATE or DELETE CREATE TABLE test_limit ( timestamp int not null, id bigint ); SELECT * FROM create_hypertable('test_limit', 'timestamp', chunk_time_interval=>10000); INSERT INTO test_limit SELECT t, i FROM generate_series(1,10000,1) t CROSS JOIN generate_series(1,3,1) i; ALTER TABLE test_limit SET ( timescaledb.compress, timescaledb.compress_orderby = 'timestamp' ); SELECT count(compress_chunk(ch)) FROM show_chunks('test_limit') ch; SET timescaledb.max_tuples_decompressed_per_dml_transaction = 5000; \set VERBOSITY default \set ON_ERROR_STOP 0 -- Updating or deleting everything will break the set limit. UPDATE test_limit SET id = 0; DELETE FROM test_limit WHERE id = 1; -- Setting to 0 should remove the limit. SET timescaledb.max_tuples_decompressed_per_dml_transaction = 0; UPDATE test_limit SET id = 0; DELETE FROM test_limit WHERE id = 1; \set ON_ERROR_STOP 1 DROP TABLE test_limit; -- check partial compression with DML CREATE TABLE test_partials (time timestamptz NOT NULL, a int, b int); SELECT create_hypertable('test_partials', 'time'); INSERT INTO test_partials VALUES -- chunk1 ('2020-01-01 00:00'::timestamptz, 1, 2), ('2020-01-01 00:01'::timestamptz, 2, 2), ('2020-01-01 00:04'::timestamptz, 1, 2), -- chunk2 ('2021-01-01 00:00'::timestamptz, 1, 2), ('2021-01-01 00:04'::timestamptz, 1, 2), -- chunk3 ('2022-01-01 00:00'::timestamptz, 1, 2), ('2022-01-01 00:04'::timestamptz, 1, 2); -- enable compression, compress all chunks ALTER TABLE test_partials SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test_partials')); VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- verify correct results SELECT * FROM test_partials ORDER BY time; -- check that DML causes transparent decompression and that -- data gets shifted to the uncompressed parts EXPLAIN (buffers off, costs off) DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); DELETE FROM test_partials WHERE time >= ALL(SELECT time from test_partials); VACUUM ANALYZE test_partials; -- All 3 chunks will now become partially compressed chunks EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; -- verify correct results SELECT * FROM test_partials ORDER BY time; SELECT compress_chunk(show_chunks('test_partials')); VACUUM ANALYZE test_partials; -- fully compressed EXPLAIN (buffers off, costs off) SELECT * FROM test_partials ORDER BY time; DROP TABLE test_partials; CREATE TABLE test_meta_filters(time timestamptz NOT NULL, device text, metric text, v1 float, v2 float); CREATE INDEX ON test_meta_filters(device, metric, v1); SELECT create_hypertable('test_meta_filters', 'time'); ALTER TABLE test_meta_filters SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='metric,time'); INSERT INTO test_meta_filters SELECT '2020-01-01'::timestamptz,'d1','m' || metric::text,v1,v2 FROM generate_series(1,3,1) metric, generate_series(1,1000,1) v1, generate_series(1,10,1) v2 ORDER BY 1,2,3,4,5; SELECT compress_chunk(show_chunks('test_meta_filters')); EXPLAIN (analyze, timing off, buffers off, costs off, summary off) DELETE FROM test_meta_filters WHERE device = 'd1' AND metric = 'm1' AND v1 < 100; -- test expression pushdown in compressed dml constraints CREATE TABLE test_pushdown(time timestamptz NOT NULL, device text); SELECT table_name FROM create_hypertable('test_pushdown', 'time'); INSERT INTO test_pushdown SELECT '2020-01-01', 'a'; INSERT INTO test_pushdown SELECT '2020-01-01', 'b'; INSERT INTO test_pushdown SELECT '2020-01-01 05:00', 'c'; CREATE TABLE devices(device text); INSERT INTO devices VALUES ('a'), ('b'), ('c'); CREATE TABLE devices2(device text); INSERT INTO devices2 VALUES ('d'), ('e'), ('f'); CREATE TABLE devices3(device text); INSERT INTO devices3 VALUES ('b'), ('d'), ('g'); ALTER TABLE test_pushdown SET (timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT compress_chunk(show_chunks('test_pushdown')); -- 3 batch decompressions means pushdown is not working so we expect less than 3 for all these queries SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'a' = device; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device < 'c' ; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' > device; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'c' >= device; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device > 'b'; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = CURRENT_USER; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' < device; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE 'b' <= device; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- cant pushdown OR atm BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = 'a' OR device = 'b'; ROLLBACK; -- test stable function BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time = timestamptz('2020-01-01 05:00'); ROLLBACK; -- test sqlvaluefunction BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = substring(CURRENT_USER,length(CURRENT_USER)+1) || 'c'; ROLLBACK; -- JOIN tests -- no filtering in decompression SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices3 d WHERE p.device=d.device; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; -- can filter in decompression even before executing join SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN DELETE FROM test_pushdown p USING devices d WHERE p.device=d.device AND d.device ='b'; SELECT * FROM test_pushdown p ORDER BY p; ROLLBACK; -- test prepared statement PREPARE q1(text) AS DELETE FROM test_pushdown WHERE device = $1; SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; BEGIN; :EXPLAIN EXECUTE q1('a'); ROLLBACK; BEGIN; :EXPLAIN EXECUTE q1('not here'); ROLLBACK; -- test arrayop pushdown less than 3 decompressions are expected for successful pushdown BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a','d'); ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = ANY('{a,d}'); ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',CURRENT_USER); ROLLBACK; -- arroyop pushdown only works for segmentby columns atm so 3 decompressions are expected for now BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time IN ('2020-01-01','2020-01-02'); ROLLBACK; -- no pushdown for volatile functions BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device = current_query(); ROLLBACK; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE device IN ('a',current_query()); ROLLBACK; -- test DELETE optimization without predicates -- should delete 3 complete batches without decompression BEGIN; :EXPLAIN DELETE FROM test_pushdown; ROLLBACK; -- test DELETE optimization on non-segmentby columns -- this shows optimization can be applied if in-memory filtering is enabled \set QUIET off BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; SET timescaledb.enable_dml_decompression_tuple_filtering TO OFF; BEGIN; :EXPLAIN DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; BEGIN; DELETE FROM test_pushdown WHERE time > '2019-01-01'; ROLLBACK; RESET timescaledb.enable_dml_decompression_tuple_filtering; \set QUIET on -- github issue #6858 -- check update triggers work correctly both on uncompressed and compressed chunks CREATE TABLE update_trigger_test ( "entity_id" "uuid" NOT NULL, "effective_date_time" timestamp with time zone NOT NULL, "measurement" numeric NOT NULL, "modified_at" timestamp with time zone DEFAULT "now"() NOT NULL ); SELECT create_hypertable('update_trigger_test', 'effective_date_time'); CREATE OR REPLACE FUNCTION update_modified_at_test() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN NEW.modified_at = NOW(); RETURN NEW; END; $$; CREATE TRIGGER update_trigger_test__before_update_sync_modified_at BEFORE UPDATE ON update_trigger_test FOR EACH ROW EXECUTE PROCEDURE update_modified_at_test(); INSERT INTO update_trigger_test SELECT 'f2ca7073-1395-5770-8378-7d0339804580', '2024-04-16 04:50:00+02', 1100.00, '2024-04-23 11:56:38.494095+02' FROM generate_series(1,2500,1) c; VACUUM FULL update_trigger_test; BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- try with default compression ALTER TABLE update_trigger_test SET (timescaledb.compress); SELECT compress_chunk(show_chunks('update_trigger_test')); BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- lets try with segmentby SELECT decompress_chunk(show_chunks('update_trigger_test')); ALTER TABLE update_trigger_test SET (timescaledb.compress, timescaledb.compress_segmentby='entity_id'); SELECT compress_chunk(show_chunks('update_trigger_test')); BEGIN; UPDATE update_trigger_test SET measurement = measurement + 2 WHERE update_trigger_test.effective_date_time >= '2020-01-01T00:00:00'::timestamp AT TIME ZONE 'UTC'; ROLLBACK; -- check reporting of affected rows is correct for direct batch delete CREATE TABLE delete_counter(time timestamptz NOT NULL, device text) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'a' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-01-01'::timestamptz, 'b' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'c' from generate_series(1,123); ALTER TABLE delete_counter SET (timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('delete_counter') ch; INSERT INTO delete_counter SELECT '2020-02-01'::timestamptz, 'd' from generate_series(1,123); INSERT INTO delete_counter SELECT '2020-03-01'::timestamptz, 'e' from generate_series(1,123); \set QUIET off BEGIN; :EXPLAIN DELETE FROM delete_counter; ROLLBACK; BEGIN; DELETE FROM delete_counter; ROLLBACK; BEGIN; :EXPLAIN DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; BEGIN; DELETE FROM delete_counter WHERE random() < 1; ROLLBACK; -- test invalidation with direct batch delete optimizations CREATE TABLE cagg_inval(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO cagg_inval SELECT '2020-01-01'::timestamptz, 'd1', 1.0; INSERT INTO cagg_inval SELECT '2021-01-01'::timestamptz, 'd1', 1.0; SELECT count(compress_chunk(ch)) FROM show_chunks('cagg_inval') ch; SET timescaledb.enable_compressed_direct_batch_delete TO on; -- delete without cagg should use optimization BEGIN; EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; ROLLBACK; CREATE MATERIALIZED VIEW cagg1 WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', time) FROM cagg_inval GROUP BY 1; -- should not use direct batch delete EXPLAIN (analyze,costs off, timing off,summary off, buffers off) DELETE FROM cagg_inval; -- should have invalidation entry SELECT * FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/compression_uuid.sql������������������������������������������������0000664�0000000�0000000�00000034671�15100345067�0022556�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --install necessary functions for tests \c :TEST_DBNAME :ROLE_SUPERUSER \ir include/compression_utils.sql \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timescaledb.enable_uuid_compression = on; CREATE TABLE t (ts int, u uuid); SELECT create_hypertable('t', 'ts', chunk_time_interval => 500); ALTER TABLE t SET (timescaledb.compress, timescaledb.compress_orderby = 'ts'); INSERT INTO t SELECT g AS ts, NULL AS uuid FROM generate_series(1, 3000) g; -- The first hundred elements are generated with the Go uuid v7 routines CREATE TABLE uuids (i int, u uuid); INSERT INTO uuids (i, u) VALUES (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (18, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (19, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (20, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (21, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (22, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (23, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (24, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (25, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (26, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (27, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (28, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (29, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (30, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (31, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (32, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (33, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (34, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (35, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (36, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (37, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (38, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (39, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (40, '0197a7a9-b48c-7c96-914c-690b7930262f'), (41, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (42, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (43, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (44, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'), (45, '0197a7a9-b48c-7c9b-9319-de9dd58deeee'), (46, '0197a7a9-b48c-7c9c-a9d4-ed6f3e6a41b7'), (47, '0197a7a9-b48c-7c9d-8036-4141e0780323'), (48, '0197a7a9-b48c-7c9e-bfbe-f00eb49ed7f2'), (49, '0197a7a9-b48c-7c9f-8ffe-71cf00a0c0c0'), (50, '0197a7a9-b48c-7ca0-822f-95ced2f95702'), (51, '0197a7a9-b48c-7ca1-8c8a-66582aec95fa'), (52, '0197a7a9-b48c-7ca2-95c3-fe80362a2251'), (53, '0197a7a9-b48c-7ca3-855f-f681b254a8c8'), (54, '0197a7a9-b48c-7ca4-856b-a562eca93c3f'), (55, '0197a7a9-b48c-7ca5-a30e-37c247fb4c46'), (56, '0197a7a9-b48c-7ca6-9e78-a148d54a44ac'), (57, '0197a7a9-b48c-7ca7-badb-4b650bf5bf5f'), (58, '0197a7a9-b48c-7ca8-8275-a8590869ef13'), (59, '0197a7a9-b48c-7ca9-b328-b54c3901223c'), (60, '0197a7a9-b48c-7caa-a15d-f5564e4e552c'), (61, '0197a7a9-b48c-7cab-a4ac-017259746322'), (62, '0197a7a9-b48c-7cac-bda5-74ef12abd6b8'), (63, '0197a7a9-b48c-7cad-a3cd-0e4c93eaba80'), (64, '0197a7a9-b48c-7cae-9667-de4a226418df'), (65, '0197a7a9-b48c-7caf-8aa2-067619170f32'), (66, '0197a7a9-b48c-7cb0-ba8c-91d9e8920845'), (67, '0197a7a9-b48c-7cb1-9681-a62bfffe9237'), (68, '0197a7a9-b48c-7cb2-b78b-037e5ee26ff6'), (69, '0197a7a9-b48c-7cb3-ac27-e24382445188'), (70, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (71, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (72, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (73, '0197a7a9-b48b-7c80-a534-4eda33d89b41'), (74, '0197a7a9-b48b-7c81-abaf-e4d27888f6ea'), (75, '0197a7a9-b48b-7c82-a07c-bb5278039b67'), (76, '0197a7a9-b48b-7c83-9df3-2826632fcb42'), (77, '0197a7a9-b48b-7c84-8588-dc4e6f10a5be'), (78, '0197a7a9-b48b-7c85-98a4-5ba69598ba88'), (79, '0197a7a9-b48b-7c86-9a96-69906846edf4'), (80, '0197a7a9-b48b-7c87-843a-d0c409e538d2'), (81, '0197a7a9-b48b-7c88-a9c9-8e03283979dd'), (82, '0197a7a9-b48c-7c88-b962-5f38a5f5bb19'), (83, '0197a7a9-b48c-7c89-ad12-19c425cfe319'), (84, '0197a7a9-b48c-7c8a-9652-43b070f806b6'), (85, '0197a7a9-b48c-7c8b-8b95-2e4b27b7c359'), (86, '0197a7a9-b48c-7c8c-9230-5a1b6a126d4e'), (87, '0197a7a9-b48c-7c8d-98e9-3622fe1418ae'), (88, '0197a7a9-b48c-7c8e-b262-e91dcf84f985'), (89, '0197a7a9-b48c-7c8f-90c0-1036d19e438e'), (90, '0197a7a9-b48c-7c90-9fcb-f092518ae1e6'), (91, '0197a7a9-b48c-7c91-bf68-433e366f751d'), (92, '0197a7a9-b48c-7c92-95b6-82cb29498e5a'), (93, '0197a7a9-b48c-7c93-9397-6ebbb9d4194d'), (94, '0197a7a9-b48c-7c94-8484-f47122e2dea3'), (95, '0197a7a9-b48c-7c95-a6e5-fe8d062f4e3c'), (96, '0197a7a9-b48c-7c96-914c-690b7930262f'), (97, '0197a7a9-b48c-7c97-ac2b-473d61e0c396'), (98, '0197a7a9-b48c-7c98-93bd-ca093b30f6e8'), (99, '0197a7a9-b48c-7c99-b906-7fa2180536d3'), (100, '0197a7a9-b48c-7c9a-a090-fe01428ccefc'); -- set data to be compressed with the uuid compressor UPDATE t SET u = (select u from uuids where i = ts) where ts <= 100; -- set data to be compressed with the dictionary compressor UPDATE t SET u = (select u from uuids where i = ts%100) where ts > 1000 and ts <= 2000; -- add random UUID v4s to the data UPDATE t SET u = gen_random_uuid() where ts > 2000; -- compress the data SELECT compress_chunk(show_chunks('t')); -- decompress the data SELECT decompress_chunk(show_chunks('t')); -- disable uuid compression and compress the data again SET timescaledb.enable_uuid_compression = off; SELECT compress_chunk(show_chunks('t')); CREATE TABLE mixed_compressed (ts int, u uuid); SELECT create_hypertable('mixed_compressed', 'ts', chunk_time_interval => 500); ALTER TABLE mixed_compressed SET (timescaledb.compress, timescaledb.compress_orderby = 'ts'); -- the new UUID compression is OFF at this point, so we use the original method -- add the base uuids to the data and compress it INSERT INTO mixed_compressed SELECT i, u FROM uuids; INSERT INTO mixed_compressed SELECT i+100 as i, NULL as u FROM uuids; -- compress the data SELECT compress_chunk(show_chunks('mixed_compressed')); -- enable uuid compression and compress the data again -- and add the base uuids to the data again SET timescaledb.enable_uuid_compression = on; INSERT INTO mixed_compressed SELECT i+1000 as i, u FROM uuids; INSERT INTO mixed_compressed SELECT i+1100 as i, NULL as u FROM uuids; -- compress the data SELECT compress_chunk(show_chunks('mixed_compressed')); -- now turn it off again and add the whole data twice SET timescaledb.enable_uuid_compression = off; INSERT INTO mixed_compressed SELECT i+2000, u FROM uuids; INSERT INTO mixed_compressed SELECT i+2200, u FROM uuids; INSERT INTO mixed_compressed SELECT i+2300 as i, NULL as u FROM uuids; -- compress the data again SELECT compress_chunk(show_chunks('mixed_compressed')); -- turn it on again and do the same SET timescaledb.enable_uuid_compression = off; INSERT INTO mixed_compressed SELECT i+3000, u FROM uuids; INSERT INTO mixed_compressed SELECT i+3200, u FROM uuids; INSERT INTO mixed_compressed SELECT i+3300 as i, NULL as u FROM uuids; -- compress the data again SELECT compress_chunk(show_chunks('mixed_compressed')); -- check the compression algorithm for the compressed chunks CREATE TABLE compressed_chunks AS SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as compressed_chunk, ccs.compressed_heap_size, ccs.compressed_toast_size, ccs.compressed_index_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM show_chunks('mixed_compressed') c INNER JOIN _timescaledb_catalog.chunk cat ON (c = format('%I.%I', cat.schema_name, cat.table_name)::regclass) INNER JOIN _timescaledb_catalog.chunk comp ON (cat.compressed_chunk_id = comp.id) INNER JOIN _timescaledb_catalog.compression_chunk_size ccs ON (comp.id = ccs.compressed_chunk_id); CREATE TABLE compression_info (compressed_chunk regclass, result text, compressed_size int, num_rows int); DO $$ DECLARE table_ref regclass; BEGIN FOR table_ref IN SELECT compressed_chunk as table_ref FROM compressed_chunks LOOP EXECUTE format( 'INSERT INTO compression_info ( SELECT %L::regclass as compressed_chunk, (_timescaledb_functions.compressed_data_info(u))::text as result, sum(pg_column_size(u)::int) as compressed_size, count(*) as num_rows FROM %s GROUP BY 1,2)', table_ref, table_ref ); END LOOP; END; $$; SELECT ci.*, ccs.compressed_toast_size, ccs.numrows_pre_compression, ccs.numrows_post_compression FROM compression_info ci INNER JOIN compressed_chunks ccs ON (ci.compressed_chunk = ccs.compressed_chunk) ORDER BY 1,2,3; -- ------------------------------- -- Test the new UUID v7 functions -- ------------------------------- -- The next 3 items are generated with the new functions BEGIN; INSERT INTO uuids VALUES (101, to_uuidv7('2025-07-02:03:04:05'::timestamptz)); INSERT INTO uuids VALUES (102, to_uuidv7('2029-01-02:03:04:05'::timestamptz)); INSERT INTO uuids VALUES (103, to_uuidv7('2059-02-03:04:05:06'::timestamptz)); INSERT INTO uuids VALUES (104, to_uuidv7('2100-07-08:09:10:11'::timestamptz)); COMMIT; SELECT to_char(uuid_timestamp(u), 'YYYY-MM-DD:HH24:MI:SS'), uuid_version(u), count(*) FROM uuids GROUP BY 1,2 ORDER BY 1,2; -- Add some v4 timestamps for sanity check BEGIN; INSERT INTO uuids VALUES (105, _timescaledb_functions.generate_uuid()); INSERT INTO uuids VALUES (106, _timescaledb_functions.generate_uuid()); INSERT INTO uuids VALUES (107, _timescaledb_functions.generate_uuid()); -- Add some random v7 timestamps too INSERT INTO uuids VALUES (108, generate_uuidv7()); INSERT INTO uuids VALUES (109, generate_uuidv7()); INSERT INTO uuids VALUES (110, generate_uuidv7()); COMMIT; -- There is a test flakyness that I want to debug with this: SELECT i, uuid_version(u) FROM uuids WHERE i > 100 ORDER BY 1; -- The version numbers should make sense SELECT uuid_version(u), count(*) FROM uuids WHERE -- The filters are here just to test, they don't blow up with random data from v4 -- NOTE that we have v4 and v7 data in the table so the timestamp filter alone makes -- the test flaky uuid_timestamp(u) > '2000-01-01:01:01:01'::timestamptz OR uuid_version(u) >= 1 GROUP BY 1 ORDER BY 1; -- Filter UUIDs on timestamp part by using both zeroed UUID and -- extracted timestamp. Both methods should yield the same count. SELECT count(*) AS count_total, count(*) FILTER (WHERE u < to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_below_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) < 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_below_on_time, count(*) FILTER (WHERE u >= to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_above_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) >= 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_above_on_time FROM uuids WHERE uuid_version(u) = 7; -- The EXPLAIN shows how the immutable "zeroed" function can be -- constified for better performance. EXPLAIN (verbose, buffers off, costs off) SELECT count(*) AS count_total, count(*) FILTER (WHERE u < to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_below_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) < 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_below_on_time, count(*) FILTER (WHERE u >= to_uuidv7_boundary('Wed Jun 25 08:16:46.348 2025 PDT')) AS count_above_on_uuid, count(*) FILTER (WHERE uuid_timestamp(u) >= 'Wed Jun 25 08:16:46.348 2025 PDT') AS count_above_on_time FROM uuids WHERE uuid_version(u) = 7; -- Sub ms timestamp test: -- generate all microseconds timestamps between the two dates below and -- generate a UUID v7 based on the timestamp and -- extract the timestamp from the UUID and -- compare the timestamp to the original one -- 1 microsecond difference is allowed due to scaling of decimals to binaries -- CREATE TABLE subms AS SELECT to_uuidv7(x) u, x ts FROM generate_series('2025-01-01:00:00:00'::timestamptz, '2025-01-01:00:00:03'::timestamptz, '1 microsecond'::interval) x; SELECT u, ts, ts2 FROM ( SELECT u, ts, uuid_timestamp_micros(u) ts2 FROM subms ) x WHERE (x.ts - x.ts2) > '00:00:00.000001' OR (x.ts - x.ts2) < '-00:00:00.000001'; -- Make sure UUIDv7 compression is enabled SET timescaledb.enable_uuid_compression = true; -- Test compression on uuid partitioning column CREATE TABLE uuid_part (id uuid, value int); SELECT create_hypertable('uuid_part', by_range('id', interval '1 month')); -- Insert the static UUIDs INSERT INTO uuid_part SELECT u, i FROM uuids WHERE uuid_version(u) = 7 AND i <= 104; -- Insert some outlier values to filter for INSERT INTO uuid_part (value, id) VALUES (105, to_uuidv7('2025-08-13 03:03:04 PDT'::timestamptz)), (106, to_uuidv7('2025-08-14 03:04:05 PDT'::timestamptz)), (107, to_uuidv7('2025-08-15 04:05:06 PDT'::timestamptz)); SELECT * FROM show_chunks('uuid_part'); ALTER TABLE uuid_part SET (timescaledb.compress, timescaledb.compress_orderby = 'id'); -- Show how data is spread across chunks SELECT tableoid::regclass, count(*) FROM uuid_part GROUP BY tableoid ORDER BY tableoid; SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); EXPLAIN (verbose, buffers off, costs off) SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); -- Compress SELECT compress_chunk(ch) FROM show_chunks('uuid_part') ch; -- Check that chunk exclusion and filtering works as expected on -- compressed UUID data. SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); -- Check that chunk exclusion still works and that filters are pushed -- down to a min-max scan on the compressed chunk. EXPLAIN (verbose, buffers off, costs off) SELECT count(*) FROM uuid_part WHERE id >= to_uuidv7_boundary('Wed Aug 13 2025 PDT') AND id < to_uuidv7_boundary('Wed Aug 16 2025 PDT'); -- Cleanup DROP TABLE t; DROP TABLE subms; DROP TABLE uuids; DROP TABLE mixed_compressed; DROP TABLE compressed_chunks; DROP TABLE compression_info; DROP TABLE uuid_part; RESET timescaledb.enable_uuid_compression; �����������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/continuous_aggs.sql.in����������������������������������������������0000664�0000000�0000000�00000151025�15100345067�0022774�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- initialize the bgw mock state to prevent the materialization workers from running \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_bgw_params_create() RETURNS VOID AS :MODULE_PATHNAME LANGUAGE C VOLATILE; CREATE OR REPLACE FUNCTION test.continuous_aggs_find_view(cagg REGCLASS) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_continuous_agg_find_by_view_name' LANGUAGE C; \set WAIT_ON_JOB 0 \set IMMEDIATELY_SET_UNTIL 1 \set WAIT_FOR_OTHER_TO_ADVANCE 2 -- remove any default jobs, e.g., telemetry so bgw_job isn't polluted DELETE FROM _timescaledb_config.bgw_job; SET ROLE :ROLE_DEFAULT_PERM_USER; SELECT * FROM _timescaledb_config.bgw_job; --TEST1 --- --basic test with count create table foo (a integer, b integer, c integer); select table_name from create_hypertable('foo', 'a', chunk_time_interval=> 10); insert into foo values( 3 , 16 , 20); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); CREATE OR REPLACE FUNCTION integer_now_foo() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(a), 0) FROM foo $$; SELECT set_integer_now_func('foo', 'integer_now_foo'); CREATE MATERIALIZED VIEW mat_m1(a, countb) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select a, count(b) from foo group by time_bucket(1, a), a WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_m1', NULL, 2::integer, '12 h'::interval) AS job_id \gset SELECT * FROM _timescaledb_config.bgw_job; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select a, count(b), time_bucket(1, a) from foo group by time_bucket(1, a) , a ; select * from mat_m1 order by a ; --check triggers on user hypertable -- SET ROLE :ROLE_SUPERUSER; select tgname, tgtype, tgenabled , relname from pg_trigger, pg_class where tgrelid = pg_class.oid and pg_class.relname like 'foo' order by tgname; SET ROLE :ROLE_DEFAULT_PERM_USER; -- TEST2 --- DROP MATERIALIZED VIEW mat_m1; SHOW enable_partitionwise_aggregate; SET enable_partitionwise_aggregate = on; SELECT * FROM _timescaledb_config.bgw_job; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Change `finalized` option is forbiden \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=false); ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.finalized=true); \set ON_ERROR_STOP 1 -- Materialized hypertable for mat_m1 should not be visible in the -- hypertables view: SELECT hypertable_schema, hypertable_name FROM timescaledb_information.hypertables ORDER BY 1,2; SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumt, sumh from mat_m1 order by timec; select time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) from conditions group by time_bucket('1day', timec) order by 1; SET enable_partitionwise_aggregate = off; -- TEST3 -- -- drop on table conditions should cascade to materialized mat_v1 drop table conditions cascade; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); insert into conditions values ( '2010-01-01 09:00:00-08', 'SFO', 55, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'por', 100, 100); insert into conditions values ( '2010-01-02 09:00:00-08', 'NYC', 65, 45); insert into conditions values ( '2010-01-02 09:00:00-08', 'SFO', 65, 45); insert into conditions values ( '2010-01-03 09:00:00-08', 'NYC', 45, 55); insert into conditions values ( '2010-01-05 09:00:00-08', 'SFO', 75, 100); insert into conditions values ( '2018-11-01 09:00:00-08', 'NYC', 45, 35); insert into conditions values ( '2018-11-02 09:00:00-08', 'NYC', 35, 15); insert into conditions values ( '2018-11-03 09:00:00-08', 'NYC', 35, 25); CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec; select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) order by time_bucket('1week', timec); -- TEST4 -- --materialized view with group by clause + expression in SELECT -- use previous data from conditions --drop only the view. -- apply where clause on result of mat_m1 -- DROP MATERIALIZED VIEW mat_m1; CREATE MATERIALIZED VIEW mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) ; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 where stddevh is not null order by timec; select time_bucket('1week', timec) , min(location), sum(temperature)+ sum(humidity), stddev(humidity) from conditions where location = 'NYC' group by time_bucket('1week', timec) order by time_bucket('1week', timec); -- TEST5 -- ---------test with having clause ---------------------- DROP MATERIALIZED VIEW mat_m1; create materialized view mat_m1( timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null WITH NO DATA; ; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null; SET ROLE :ROLE_DEFAULT_PERM_USER; -- should have same results -- select * from mat_m1 order by sumth; select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having stddev(humidity) is not null order by sum(temperature)+sum(humidity); -- TEST6 -- --group by with more than 1 group column -- having clause with a mix of columns from select list + others drop table conditions cascade; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp numeric NULL, highp numeric null ); select table_name from create_hypertable( 'conditions', 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, 71, 28; --naming with AS clauses CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) as bucket, location as loc, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by bucket, loc having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; DROP MATERIALIZED VIEW mat_naming; --naming with default names CREATE MATERIALIZED VIEW mat_naming WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as sumth, stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; DROP MATERIALIZED VIEW mat_naming; --naming with view col names CREATE MATERIALIZED VIEW mat_naming(bucket, loc, sum_t_h, stdd) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec), location, sum(temperature)+sum(humidity), stddev(humidity) from conditions group by 1,2 having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_naming' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; DROP MATERIALIZED VIEW mat_naming; CREATE MATERIALIZED VIEW mat_m1(timec, minl, sumth, stddevh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 WITH NO DATA; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset select attnum , attname from pg_attribute where attnum > 0 and attrelid = (Select oid from pg_class where relname like :'MAT_TABLE_NAME') order by attnum, attname; SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select time_bucket('1week', timec), min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20; SET ROLE :ROLE_DEFAULT_PERM_USER; --should have same results -- select timec, minl, sumth, stddevh from mat_m1 order by timec, minl; select time_bucket('1week', timec) , min(location), sum(temperature)+sum(humidity), stddev(humidity) from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 and avg(lowp) > 10 order by time_bucket('1week', timec), min(location); --check view defintion in information views select view_name, view_definition from timescaledb_information.continuous_aggregates where view_name::text like 'mat_m1'; --TEST6 -- select from internal view SET ROLE :ROLE_SUPERUSER; insert into :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" select * from :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; SET ROLE :ROLE_DEFAULT_PERM_USER; --lets drop the view and check DROP MATERIALIZED VIEW mat_m1; drop table conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT $$ select time_bucket('1week', timec) , min(location) as col1, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by time_bucket('1week', timec) having min(location) >= 'NYC' and avg(temperature) > 20 $$ AS "QUERY" \gset \set ECHO errors \ir include/cont_agg_equal.sql \set ECHO all SELECT $$ select time_bucket('1week', timec), location, sum(temperature)+sum(humidity) as col2, stddev(humidity) as col3, min(allnull) as col4 from conditions group by location, time_bucket('1week', timec) $$ AS "QUERY" \gset \set ECHO errors \ir include/cont_agg_equal.sql \set ECHO all --TEST7 -- drop tests for view and hypertable --DROP tests \set ON_ERROR_STOP 0 SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_test' \gset DROP TABLE :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; DROP VIEW :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; DROP VIEW :"DIR_VIEW_SCHEMA".:"DIR_VIEW_NAME"; \set ON_ERROR_STOP 1 --catalog entry still there; SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; --mat table, user_view, direct view and partial view all there select count(*) from pg_class where relname = :'PART_VIEW_NAME'; select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; select count(*) from pg_class where relname = 'mat_test'; DROP MATERIALIZED VIEW mat_test; --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_test'; --mat table, user_view, direct view and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; select count(*) from pg_class where relname = :'DIR_VIEW_NAME'; select count(*) from pg_class where relname = 'mat_test'; --test dropping raw table DROP TABLE conditions; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); --no data in hyper table on purpose so that CASCADE is not required because of chunks CREATE MATERIALIZED VIEW mat_drop_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec) WITH NO DATA; \set ON_ERROR_STOP 0 DROP TABLE conditions; \set ON_ERROR_STOP 1 --insert data now insert into conditions select generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'POR', 55, 75, 40, 70, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 'NYC', 35, 45, 50, 40, NULL; insert into conditions select generate_series('2018-11-01 00:00'::timestamp, '2018-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; SELECT ca.raw_hypertable_id as "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_drop_test' \gset SET client_min_messages TO NOTICE; CALL refresh_continuous_aggregate('mat_drop_test', NULL, NULL); --force invalidation insert into conditions select generate_series('2017-11-01 00:00'::timestamp, '2017-12-15 00:00'::timestamp, '1 day'), 'LA', 73, 55, NULL, 28, NULL; select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; DROP TABLE conditions CASCADE; --catalog entry should be gone SELECT count(*) FROM _timescaledb_catalog.continuous_agg ca WHERE user_view_name = 'mat_drop_test'; select count(*) from _timescaledb_catalog.continuous_aggs_invalidation_threshold; select count(*) from _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log; select count(*) from _timescaledb_catalog.continuous_aggs_materialization_invalidation_log; SELECT * FROM _timescaledb_config.bgw_job; --mat table, user_view, and partial view all gone select count(*) from pg_class where relname = :'PART_VIEW_NAME'; select count(*) from pg_class where relname = :'MAT_TABLE_NAME'; select count(*) from pg_class where relname = 'mat_drop_test'; --TEST With options CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec'); CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, '5 h'::interval, '12 h'::interval); SELECT alter_job(id, schedule_interval => '1h') FROM _timescaledb_config.bgw_job; SELECT schedule_interval FROM _timescaledb_config.bgw_job; SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; SELECT schedule_interval FROM _timescaledb_config.bgw_job; select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test') order by indexname; DROP MATERIALIZED VIEW mat_with_test; --no additional indexes CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true, timescaledb.create_group_indexes=false) as select time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location, humidity, temperature WITH NO DATA; select indexname, indexdef from pg_indexes where tablename = (SELECT h.table_name FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_with_test'); DROP TABLE conditions CASCADE; --test WITH using a hypertable with an integer time dimension CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); CREATE MATERIALIZED VIEW mat_with_test(timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket(100, timec) WITH NO DATA; SELECT add_continuous_aggregate_policy('mat_with_test', NULL, 500::integer, '12 h'::interval); SELECT alter_job(id, schedule_interval => '2h') FROM _timescaledb_config.bgw_job; SELECT schedule_interval FROM _timescaledb_config.bgw_job; DROP TABLE conditions CASCADE; --test space partitions CREATE TABLE space_table ( time BIGINT, dev BIGINT, data BIGINT ); SELECT create_hypertable( 'space_table', 'time', chunk_time_interval => 10, partitioning_column => 'dev', number_partitions => 3); CREATE OR REPLACE FUNCTION integer_now_space_table() returns BIGINT LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), BIGINT '0') FROM space_table $$; SELECT set_integer_now_func('space_table', 'integer_now_space_table'); CREATE MATERIALIZED VIEW space_view WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('4', time), COUNT(data) FROM space_table GROUP BY 1 WITH NO DATA; INSERT INTO space_table VALUES (0, 1, 1), (0, 2, 1), (1, 1, 1), (1, 2, 1), (10, 1, 1), (10, 2, 1), (11, 1, 1), (11, 2, 1); SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA", direct_view_name as "DIR_VIEW_NAME", direct_view_schema as "DIR_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'space_view' \gset SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; INSERT INTO space_table VALUES (3, 2, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; INSERT INTO space_table VALUES (2, 3, 1); CALL refresh_continuous_aggregate('space_view', NULL, NULL); SELECT * FROM space_view ORDER BY 1; SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" ORDER BY time_bucket; DROP TABLE space_table CASCADE; -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, c int, d int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type % %', pg_typeof(d), pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, c int, d int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, int, int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); CREATE TABLE conditions ( timec INT NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null ); select table_name from create_hypertable( 'conditions', 'timec', chunk_time_interval=> 100); CREATE OR REPLACE FUNCTION integer_now_conditions() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(timec), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now_conditions'); insert into conditions select generate_series(0, 200, 10), 'POR', 55, 75, 40, 70, NULL; CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 1, 3, 'test'::text) from conditions group by time_bucket(100, timec); SELECT * FROM mat_ffunc_test ORDER BY time_bucket; DROP MATERIALIZED view mat_ffunc_test; CREATE MATERIALIZED VIEW mat_ffunc_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select time_bucket(100, timec), aggregate_to_test_ffunc_extra(timec, 4, 5, bigint '123') from conditions group by time_bucket(100, timec); SELECT * FROM mat_ffunc_test ORDER BY time_bucket; --refresh mat view test when time_bucket is not projected -- DROP MATERIALIZED VIEW mat_ffunc_test; CREATE MATERIALIZED VIEW mat_refresh_test WITH (timescaledb.continuous, timescaledb.materialized_only=true) as select location, max(humidity) from conditions group by time_bucket(100, timec), location WITH NO DATA; insert into conditions select generate_series(0, 50, 10), 'NYC', 55, 75, 40, 70, NULL; CALL refresh_continuous_aggregate('mat_refresh_test', NULL, NULL); SELECT * FROM mat_refresh_test order by 1,2 ; -- test for bug when group by is not in project list CREATE MATERIALIZED VIEW conditions_grpby_view with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location; select * from conditions_grpby_view order by 1, 2; CREATE MATERIALIZED VIEW conditions_grpby_view2 with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket(100, timec), sum(humidity) from conditions group by time_bucket(100, timec), location having avg(temperature) > 0; select * from conditions_grpby_view2 order by 1, 2; -- Test internal functions for continuous aggregates SELECT test.continuous_aggs_find_view('mat_refresh_test'); -- Test pseudotype/enum handling CREATE TYPE status_enum AS ENUM ( 'red', 'yellow', 'green' ); CREATE TABLE cagg_types ( time TIMESTAMPTZ NOT NULL, status status_enum, names NAME[], floats FLOAT[] ); SELECT table_name FROM create_hypertable('cagg_types', 'time'); INSERT INTO cagg_types SELECT '2000-01-01', 'yellow', '{foo,bar,baz}', '{1,2.5,3}'; CREATE MATERIALIZED VIEW mat_types WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1d', time), min(status) AS status, max(names) AS names, min(floats) AS floats FROM cagg_types GROUP BY 1; CALL refresh_continuous_aggregate('mat_types',NULL,NULL); SELECT * FROM mat_types; ------------------------------------------------------------------------------------- -- Test issue #2616 where cagg view contains an experssion with several aggregates in CREATE TABLE water_consumption ( sensor_id integer NOT NULL, timestamp timestamp(0) NOT NULL, water_index integer ); SELECT create_hypertable('water_consumption', 'timestamp', 'sensor_id', 2); INSERT INTO public.water_consumption (sensor_id, timestamp, water_index) VALUES (1, '2010-11-03 09:42:30', 1030), (1, '2010-11-03 09:42:40', 1032), (1, '2010-11-03 09:42:50', 1035), (1, '2010-11-03 09:43:30', 1040), (1, '2010-11-03 09:43:40', 1045), (1, '2010-11-03 09:43:50', 1050), (1, '2010-11-03 09:44:30', 1052), (1, '2010-11-03 09:44:40', 1057), (1, '2010-11-03 09:44:50', 1060), (1, '2010-11-03 09:45:30', 1063), (1, '2010-11-03 09:45:40', 1067), (1, '2010-11-03 09:45:50', 1070); -- The test with the view originally reported in the issue. CREATE MATERIALIZED VIEW water_consumption_aggregation_minute WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_minute', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_minute ORDER BY water_consumption; SELECT sensor_id, time_bucket(INTERVAL '1 minute', timestamp) + '1 minute' AS timestamp, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; -- Simplified test, where the view doesn't contain all group by clauses CREATE MATERIALIZED VIEW water_consumption_no_select_bucket WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_no_select_bucket', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_no_select_bucket ORDER BY water_consumption; SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; -- The test with SELECT matching GROUP BY and placing aggregate expression not the last CREATE MATERIALIZED VIEW water_consumption_aggregation_no_addition WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) WITH NO DATA; CALL refresh_continuous_aggregate('water_consumption_aggregation_no_addition', NULL, NULL); -- The results of the view and the query over hypertable should be the same SELECT * FROM water_consumption_aggregation_no_addition ORDER BY water_consumption; SELECT sensor_id, (max(water_index) - min(water_index)) AS water_consumption, time_bucket(INTERVAL '1 minute', timestamp) AS timestamp FROM water_consumption GROUP BY sensor_id, time_bucket(INTERVAL '1 minute', timestamp) ORDER BY water_consumption; DROP TABLE water_consumption CASCADE; ---- --- github issue 2655 --- create table raw_data(time timestamptz, search_query text, cnt integer, cnt2 integer); select create_hypertable('raw_data','time', chunk_time_interval=>'15 days'::interval); insert into raw_data select '2000-01-01','Q1'; --having has exprs that appear in select CREATE MATERIALIZED VIEW search_query_count_1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1; --having has aggregates + grp by columns that appear in select CREATE MATERIALIZED VIEW search_query_count_2 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY search_query, bucket HAVING count(search_query) > 3 OR sum(cnt) > 1 OR ( sum(cnt) + count(cnt)) > 1 AND search_query = 'Q1'; CREATE MATERIALIZED VIEW search_query_count_3 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT search_query,count(search_query) as count, sum(cnt), time_bucket(INTERVAL '1 minute', time) AS bucket FROM raw_data WHERE search_query is not null AND LENGTH(TRIM(both from search_query))>0 GROUP BY cnt +cnt2 , bucket, search_query HAVING cnt + cnt2 + sum(cnt) > 2 or count(cnt2) > 10; insert into raw_data select '2000-01-01 00:00+0','Q1', 1, 100; insert into raw_data select '2000-01-01 00:00+0','Q1', 2, 200; insert into raw_data select '2000-01-01 00:00+0','Q1', 3, 300; insert into raw_data select '2000-01-02 00:00+0','Q2', 10, 10; insert into raw_data select '2000-01-02 00:00+0','Q2', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; --only 1 of these should appear in the result insert into raw_data select '2000-01-02 00:00+0','Q3', 0, 0; insert into raw_data select '2000-01-03 00:00+0','Q4', 20, 20; CALL refresh_continuous_aggregate('search_query_count_1m', NULL, NULL); SELECT * FROM search_query_count_1m ORDER BY 1, 2; --refresh search_query_count_2--- CALL refresh_continuous_aggregate('search_query_count_2', NULL, NULL); SELECT * FROM search_query_count_2 ORDER BY 1, 2; --refresh search_query_count_3--- CALL refresh_continuous_aggregate('search_query_count_3', NULL, NULL); SELECT * FROM search_query_count_3 ORDER BY 1, 2, 3; --- TEST enable compression on continuous aggregates CREATE VIEW cagg_compression_status as SELECT ca.mat_hypertable_id AS mat_htid, ca.user_view_name AS cagg_name , h.schema_name AS mat_schema_name, h.table_name AS mat_table_name, ca.materialized_only FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) ; SELECT mat_htid AS "MAT_HTID" , mat_schema_name || '.' || mat_table_name AS "MAT_HTNAME" , mat_table_name AS "MAT_TABLE_NAME" FROM cagg_compression_status WHERE cagg_name = 'search_query_count_3' \gset ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'true'); SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; \x SELECT * FROM timescaledb_information.compression_settings WHERE hypertable_name = :'MAT_TABLE_NAME'; \x SELECT compress_chunk(ch) FROM show_chunks('search_query_count_3') ch; SELECT * from search_query_count_3 ORDER BY 1, 2, 3; -- insert into a new region of the hypertable and then refresh the cagg -- (note we still do not support refreshes into existing regions. -- cagg chunks do not map 1-1 to hypertabl regions. They encompass -- more data -- ). insert into raw_data select '2000-05-01 00:00+0','Q3', 0, 0; -- On PG >= 14 the refresh test below will pass because we added support for UPDATE/DELETE on compressed chunks in PR #5339 \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('search_query_count_3', NULL, '2000-06-01 00:00+0'::timestamptz); CALL refresh_continuous_aggregate('search_query_count_3', '2000-05-01 00:00+0'::timestamptz, '2000-06-01 00:00+0'::timestamptz); \set ON_ERROR_STOP 1 --insert row insert into raw_data select '2001-05-10 00:00+0','Q3', 100, 100; --this should succeed since it does not refresh any compressed regions in the cagg CALL refresh_continuous_aggregate('search_query_count_3', '2001-05-01 00:00+0'::timestamptz, '2001-06-01 00:00+0'::timestamptz); --verify watermark and check that chunks are compressed SELECT _timescaledb_functions.to_timestamp(w) FROM _timescaledb_functions.cagg_watermark(:'MAT_HTID') w; SELECT chunk_name, range_start, range_end, is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = :'MAT_TABLE_NAME' ORDER BY 1; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log WHERE materialization_id = :'MAT_HTID' ORDER BY 1, 2,3; SELECT * from search_query_count_3 WHERE bucket > '2001-01-01' ORDER BY 1, 2, 3; --now disable compression , will error out -- \set ON_ERROR_STOP 0 ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); \set ON_ERROR_STOP 1 SELECT decompress_chunk(format('%I.%I', schema_name, table_name)) FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'MAT_HTID' and status = 1; --disable compression on cagg after decompressing all chunks-- ALTER MATERIALIZED VIEW search_query_count_3 SET (timescaledb.compress = 'false'); SELECT cagg_name, mat_table_name FROM cagg_compression_status where cagg_name = 'search_query_count_3'; SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'search_query_count_3'; -- TEST caggs on table with more columns than in the cagg view defn -- CREATE TABLE test_morecols ( time TIMESTAMPTZ NOT NULL, val1 INTEGER, val2 INTEGER, val3 INTEGER, val4 INTEGER, val5 INTEGER, val6 INTEGER, val7 INTEGER, val8 INTEGER); SELECT create_hypertable('test_morecols', 'time', chunk_time_interval=> '7 days'::interval); INSERT INTO test_morecols SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '1 day'), 55, 75, 40, 70, NULL, 100, 200, 200; CREATE MATERIALIZED VIEW test_morecols_cagg with (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('30 days',time), avg(val1), count(val2) FROM test_morecols GROUP BY 1; ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.compress='true'); SELECT compress_chunk(ch) FROM show_chunks('test_morecols_cagg') ch; SELECT * FROM test_morecols_cagg ORDER BY time_bucket; SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; --should keep compressed option, modify only materialized -- ALTER MATERIALIZED VIEW test_morecols_cagg SET (timescaledb.materialized_only='true'); SELECT view_name, materialized_only, compression_enabled FROM timescaledb_information.continuous_aggregates where view_name = 'test_morecols_cagg'; CREATE TABLE issue3248(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); CREATE INDEX ON issue3248(time DESC); CREATE INDEX ON issue3248(device_id,time DESC); SELECT create_hypertable('issue3248','time',create_default_indexes:=false); ALTER TABLE issue3248 DROP COLUMN filler_1; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_2; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE issue3248 DROP COLUMN filler_3; INSERT INTO issue3248(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','8h') gtime(time), generate_series(1,5,1) gdevice(device_id); ANALYZE issue3248; CREATE materialized view issue3248_cagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1h',time), device_id, min(v0), max(v1), avg(v2) FROM issue3248 GROUP BY 1,2; SELECT FROM issue3248 AS m, LATERAL(SELECT m FROM issue3248_cagg WHERE avg IS NULL LIMIT 1) AS lat; -- test that option create_group_indexes is taken into account CREATE TABLE test_group_idx ( time timestamptz, symbol int, value numeric ); select create_hypertable('test_group_idx', 'time'); insert into test_group_idx select t, round(random()*10), random()*5 from generate_series('2020-01-01', '2020-02-25', INTERVAL '12 hours') t; create materialized view cagg_index_true with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=true) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; create materialized view cagg_index_false with (timescaledb.continuous, timescaledb.materialized_only=false, timescaledb.create_group_indexes=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; create materialized view cagg_index_default with (timescaledb.continuous, timescaledb.materialized_only=false) as select time_bucket('1 day', "time") as bucket, sum(value), symbol from test_group_idx group by bucket, symbol; -- see corresponding materialization_hypertables select view_name, materialization_hypertable_name from timescaledb_information.continuous_aggregates ca where view_name like 'cagg_index_%' ORDER BY view_name; -- now make sure a group index has been created when explicitly asked for \x on select i.* from pg_indexes i join pg_class c on schemaname = relnamespace::regnamespace::text and tablename = relname where tablename in (select materialization_hypertable_name from timescaledb_information.continuous_aggregates where view_name like 'cagg_index_%') order by tablename, indexname; \x off -- -- TESTs for removing old CAggs restrictions -- DROP TABLE conditions CASCADE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT create_hypertable('conditions', 'timec'); INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-03 09:00:00-08', 'NYC', 45, 55), ('2010-01-05 09:00:00-08', 'SFO', 75, 100), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15), ('2018-11-03 09:00:00-08', 'NYC', 35, 25); -- aggregate with DISTINCT CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(DISTINCT temperature) FROM conditions GROUP BY time_bucket('1week', timec), location; SELECT * FROM mat_m1 ORDER BY 1, 2, 3; -- aggregate with FILTER DROP MATERIALIZED VIEW mat_m1; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), SUM(temperature) FILTER (WHERE humidity > 60) FROM conditions GROUP BY time_bucket('1week', timec), location; SELECT * FROM mat_m1 ORDER BY 1, 2; -- aggregate with filter in having clause DROP MATERIALIZED VIEW mat_m1; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MAX(temperature) FROM conditions GROUP BY time_bucket('1week', timec), location HAVING SUM(temperature) FILTER (WHERE humidity > 40) > 50; SELECT * FROM mat_m1 ORDER BY 1, 2; -- ordered set aggr DROP MATERIALIZED VIEW mat_m1; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), MODE() WITHIN GROUP(ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); SELECT * FROM mat_m1 ORDER BY 1; -- hypothetical-set aggr DROP MATERIALIZED VIEW mat_m1; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), RANK(60) WITHIN GROUP (ORDER BY humidity), DENSE_RANK(60) WITHIN GROUP (ORDER BY humidity), PERCENT_RANK(60) WITHIN GROUP (ORDER BY humidity) FROM conditions GROUP BY time_bucket('1week', timec); SELECT * FROM mat_m1 ORDER BY 1; -- userdefined aggregate without combine function DROP MATERIALIZED VIEW mat_m1; CREATE AGGREGATE newavg ( sfunc = int4_avg_accum, basetype = int4, stype = _int8, finalfunc = int8_avg, initcond1 = '{0,0}' ); CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT SUM(humidity), round(newavg(temperature::int4)) FROM conditions GROUP BY time_bucket('1week', timec), location; SELECT * FROM mat_m1 ORDER BY 1, 2; -- ORDER BY in the view definition DROP MATERIALIZED VIEW mat_m1; CREATE MATERIALIZED VIEW mat_m1 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1week', timec), COUNT(location), SUM(temperature) FROM conditions GROUP BY time_bucket('1week', timec) ORDER BY sum DESC; -- CAgg definition for realtime SELECT pg_get_viewdef('mat_m1',true); -- Ordered result SELECT * FROM mat_m1; -- Insert new data and query again to make sure we produce ordered data INSERT INTO conditions VALUES ('2018-11-10 09:00:00-08', 'SFO', 10, 10); SELECT * FROM mat_m1; -- This new row will change the order again INSERT INTO conditions VALUES ('2018-11-11 09:00:00-08', 'SFO', 400, 400); SELECT * FROM mat_m1; -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; -- Change the type of cagg ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); -- CAgg definition for materialized only SELECT pg_get_viewdef('mat_m1',true); -- Now the query will show only the materialized data, without last two -- records inserted into the original hypertable (last two insers above) SELECT * FROM mat_m1; -- Merge Append EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1; -- Ordering by another column SELECT * FROM mat_m1 ORDER BY count; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM mat_m1 ORDER BY count; SELECT h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'mat_m1' \gset -- Invalidate old region and refresh again DELETE FROM conditions WHERE timec < '2010-01-05 09:00:00-08'; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); -- Querying the cagg produce ordered records as expected SELECT * FROM mat_m1; -- Querying direct the materialization hypertable doesn't -- produce ordered records SELECT * FROM :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME"; -- -- Testing the coexistence of both types of supported CAggs -- over the same raw hypertable. -- -- . finalized = true: without chunk_id and partials -- . finalized = false: with chunk_id and partials -- DROP TABLE conditions CASCADE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); INSERT INTO conditions VALUES ('2010-01-01 09:00:00-08', 'SFO', 55, 45), ('2010-01-02 09:00:00-08', 'por', 100, 100), ('2010-01-02 09:00:00-08', 'SFO', 65, 45), ('2010-01-02 09:00:00-08', 'NYC', 65, 45), ('2018-11-01 09:00:00-08', 'NYC', 45, 35), ('2018-11-02 09:00:00-08', 'NYC', 35, 15); CREATE MATERIALIZED VIEW conditions_summary_new(timec, minl, sumt, sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1day', timec), min(location), sum(temperature), sum(humidity) FROM conditions GROUP BY time_bucket('1day', timec) WITH NO DATA; \x ON SELECT * FROM timescaledb_information.continuous_aggregates WHERE view_name = 'conditions_summary_new'; \x OFF CALL refresh_continuous_aggregate('conditions_summary_new', NULL, NULL); -- Check and compare number of returned rows SELECT count(*) FROM conditions_summary_new; -- Parallel planning test for realtime Continuous Aggregate DROP TABLE conditions CASCADE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, temperature DOUBLE PRECISION NULL ); SELECT table_name FROM create_hypertable('conditions', 'timec'); INSERT INTO conditions SELECT t, 10 FROM generate_series('2023-01-01 00:00-03'::timestamptz, '2023-12-31 23:59-03'::timestamptz, '1 hour'::interval) AS t; CREATE MATERIALIZED VIEW conditions_daily WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 day', timec), SUM(temperature) FROM conditions GROUP BY 1 ORDER BY 2 DESC; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); SET max_parallel_workers_per_gather = 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; -- Parallel planning EXPLAIN (BUFFERS OFF, COSTS OFF, TIMING OFF) SELECT * FROM conditions_daily WHERE time_bucket >= '2023-07-01'; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/create_table_with.sql�����������������������������������������������0000664�0000000�0000000�00000046512�15100345067�0022631�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- our user needs permission to create schema for the schema tests \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :TEST_DBNAME TO :ROLE_DEFAULT_PERM_USER; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- create table with non-tsdb option should not be affected CREATE TABLE t1(time timestamptz, device text, value float) WITH (autovacuum_enabled); DROP TABLE t1; -- test error cases \set ON_ERROR_STOP 0 CREATE TABLE t2(time float, device text, value float) WITH (tsdb.hypertable); CREATE TABLE t2(time float, device text, value float) WITH (timescaledb.hypertable); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=NULL); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column=''); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='foo'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.partition_column='time'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (timescaledb.partition_column='time'); CREATE TABLE t2(time timestamptz , device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='foo'); CREATE TABLE t2(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes='time'); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=2); CREATE TABLE t2(time timestamptz, device text, value float) WITH (tsdb.create_default_indexes=-1); \set ON_ERROR_STOP 1 BEGIN; CREATE TABLE t3(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE t4(time timestamp, device text, value float) WITH (tsdb.hypertable,timescaledb.partitioning_column='time'); CREATE TABLE t5(time date, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',autovacuum_enabled); CREATE TABLE t6(time timestamptz NOT NULL, device text, value float) WITH (timescaledb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; ROLLBACK; -- IF NOT EXISTS BEGIN; CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t7(time timestamptz NOT NULL, device text, value float); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; ROLLBACK; -- table won't be converted to hypertable unless it is in the initial CREATE TABLE BEGIN; CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); CREATE TABLE IF NOT EXISTS t8(time timestamptz NOT NULL, device text, value float); SELECT hypertable_name FROM timescaledb_information.hypertables ORDER BY 1; ROLLBACK; -- chunk_interval BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='8weeks'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time timestamp NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='23 days'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time date NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 months'); SELECT hypertable_name, column_name, column_type, time_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=12); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int4 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=3453); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; ROLLBACK; BEGIN; CREATE TABLE IF NOT EXISTS t9(time int8 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=32768); SELECT hypertable_name, column_name, column_type, integer_interval FROM timescaledb_information.dimensions; ROLLBACK; -- create_default_indexes BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL PRIMARY KEY, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL UNIQUE, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=true); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; BEGIN; CREATE TABLE t10(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.create_default_indexes=false); SELECT indexrelid::regclass from pg_index where indrelid='t10'::regclass ORDER BY indexrelid::regclass::text; ROLLBACK; -- associated_schema BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; ROLLBACK; BEGIN; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; ROLLBACK; BEGIN; CREATE SCHEMA abc2; CREATE TABLE t11(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc2'); SELECT associated_schema_name FROM _timescaledb_catalog.hypertable WHERE table_name = 't11'; INSERT INTO t11 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc2'::regnamespace ORDER BY 1; ROLLBACK; -- associated_table_prefix BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; ROLLBACK; BEGIN; CREATE TABLE t12(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.associated_schema='abc', tsdb.associated_table_prefix='tbl_prefix'); SELECT associated_table_prefix FROM _timescaledb_catalog.hypertable WHERE table_name = 't12'; INSERT INTO t12 SELECT '2025-01-01', 'd1', 0.1; SELECT relname from pg_class where relnamespace = 'abc'::regnamespace ORDER BY 1; ROLLBACK; -- verify compression BEGIN; CREATE TABLE t13(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; INSERT INTO t13 SELECT '2025-01-01','d1',0.1; SELECT compress_chunk(show_chunks('t13')); ROLLBACK; BEGIN; CREATE TABLE t13(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ALTER TABLE t13 SET (tsdb.compress_segmentby='device',tsdb.compress_orderby='time DESC'); INSERT INTO t13 SELECT '2025-01-01','d1',0.1; SELECT compress_chunk(show_chunks('t13')); ROLLBACK; -- test segmentby and orderby BEGIN; CREATE TABLE t14(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.order_by='value'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; BEGIN; CREATE TABLE t15(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.order_by='time'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; BEGIN; CREATE TABLE t16(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.segment_by='device'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; BEGIN; CREATE TABLE t17(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.segment_by='device', tsdb.order_by='time,value'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; BEGIN; CREATE TABLE t18(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.segmentby='device', tsdb.orderby='time,value'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; BEGIN; CREATE TABLE t18(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.compress_segmentby='device', tsdb.compress_orderby='time,value'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; -- test columnstore option BEGIN; CREATE TABLE t19(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ROLLBACK; BEGIN; CREATE TABLE t20(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ROLLBACK; BEGIN; CREATE TABLE t21(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ROLLBACK; BEGIN; CREATE TABLE t22(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=false); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ROLLBACK; BEGIN; CREATE TABLE t23(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.compress=false); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ROLLBACK; BEGIN; CREATE TABLE t24(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.enable_columnstore=false); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables; ROLLBACK; BEGIN; CREATE TABLE t25(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time'); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 't25'::regclass; ROLLBACK; -- test compression policy creation with columnstore BEGIN; CREATE TABLE t25_policy(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy'; SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy' AND proc_name = 'policy_compression'; ROLLBACK; -- test compression policy creation with custom chunk interval BEGIN; CREATE TABLE t25_policy_custom(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval='3 days',tsdb.columnstore=true); SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_custom' AND proc_name = 'policy_compression'; ROLLBACK; -- test compression policy creation with integer partition column (int2) BEGIN; CREATE TABLE t25_policy_int2(time int2 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=100,tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy_int2'; SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_int2' AND proc_name = 'policy_compression'; ROLLBACK; -- test compression policy creation with integer partition column (int4) BEGIN; CREATE TABLE t25_policy_int4(time int4 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=1000,tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy_int4'; SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_int4' AND proc_name = 'policy_compression'; ROLLBACK; -- test compression policy creation with integer partition column (int8) BEGIN; CREATE TABLE t25_policy_int8(time int8 NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time',tsdb.chunk_interval=10000,tsdb.columnstore=true); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 't25_policy_int8'; SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes"') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 't25_policy_int8' AND proc_name = 'policy_compression'; ROLLBACK; BEGIN; -- don't allow empty orderby \set ON_ERROR_STOP 0 CREATE TABLE t26(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby = ''); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 't26'::regclass; ROLLBACK; \set ON_ERROR_STOP 1 -- can allow empty segmentby BEGIN; CREATE TABLE t27(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.segmentby = ''); SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 't27'::regclass; ROLLBACK; -- test configurable bloom and minmax BEGIN; CREATE TABLE t28(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='time', tsdb.index='bloom(value)'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; BEGIN; CREATE TABLE t29(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='time', tsdb.index='bloom(value),minmax(device)'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; --multi column BEGIN; CREATE TABLE t30(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='time',tsdb.index='bloom(value),bloom(device)'); SELECT * FROM _timescaledb_catalog.compression_settings; ROLLBACK; --test errors \set ON_ERROR_STOP 0 -- invalid syntax BEGIN; CREATE TABLE t31(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),bloom(count(device))'); ROLLBACK; BEGIN; CREATE TABLE t32(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='value,bloom(count(device))'); ROLLBACK; -- duplicate column BEGIN; CREATE TABLE t33(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),minmax(value)'); ROLLBACK; BEGIN; CREATE TABLE t34(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),bloom(value)'); ROLLBACK; -- invalid column BEGIN; CREATE TABLE t35(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value),bloom(foo)'); ROLLBACK; -- same column as orderby BEGIN; CREATE TABLE t36(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value)'); ROLLBACK; BEGIN; CREATE TABLE t37(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='minmax(value)'); ROLLBACK; -- same column as segmentby BEGIN; CREATE TABLE t38(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.segmentby='device', tsdb.index='minmax(device)'); ROLLBACK; -- guc disabled set timescaledb.enable_sparse_index_bloom to false; BEGIN; CREATE TABLE t39(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.orderby='value', tsdb.index='bloom(value)'); ROLLBACK; --no orderby BEGIN; CREATE TABLE t40(time timestamptz NOT NULL, device text, value float) WITH (tsdb.hypertable,tsdb.partition_column='time', tsdb.index='bloom(value)'); ROLLBACK; \set ON_ERROR_STOP 1 reset timescaledb.enable_sparse_index_bloom; -- test UUID partitioning + compression BEGIN; CREATE TABLE IF NOT EXISTS events ( event_id UUID NOT NULL, entity_id VARCHAR(100) NOT NULL, ts TIMESTAMPTZ NOT NULL, event_type VARCHAR(100) NOT NULL, metadata JSONB, PRIMARY KEY (event_id) ) WITH ( tsdb.hypertable, tsdb.partition_column='event_id', tsdb.order_by='ts DESC, event_id', tsdb.segment_by='entity_id', tsdb.chunk_interval='2 hours', tsdb.compress=true ); SELECT hypertable_name, compression_enabled FROM timescaledb_information.hypertables WHERE hypertable_name = 'events'; SELECT hypertable_name, schedule_interval, TO_CHAR(next_start - NOW(),'"in" DD "days" HH24 "hours" MI "minutes') as next_start, config FROM timescaledb_information.jobs WHERE hypertable_name = 'events' AND proc_name = 'policy_compression'; ROLLBACK; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/custom_hashagg.sql��������������������������������������������������0000664�0000000�0000000�00000003331�15100345067�0022150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. create table foo( a integer, b timestamptz); select count(*) from create_hypertable('foo', 'b'); insert into foo values (1, '2004-10-19 10:23:54'), (1, '2005-10-19 10:23:54'), (1, '2005-01-01 00:00:00+00'), (2, '2005-01-01 00:00:00+00'); -- Test that the range estimation functions estimate_max_spread_var() -- is used for custom hash aggregates and that they behave in a sane -- manner when there are errors. -- -- To trigger a call to the function, the following are required: -- -- timescaledb.enable_custom_hashagg to be true -- -- query should either date_trunc or time_bucket bucket function -- with a recognized time type -- -- an aggregation function in the result -- -- a group-by on the bucket created by the date_trunc or time_bucket -- -- statistics recorded for the variable used in the bucketing -- function set timescaledb.enable_custom_hashagg to true; analyze foo; explain (buffers off, costs off) select date_trunc('hour', b) bucket, sum(a) from foo group by bucket; select date_trunc('hour', b) bucket, sum(a) from foo group by bucket; -- Inserting a very large value should trigger an error inside the -- range estimation function estimate_max_spread_var() and test that -- it works even in the presence of errors. insert into foo values (99, 'epoch'::timestamptz + '9223371331200000000'::bigint * '1 microsecond'::interval); \set ON_ERROR_STOP 0 select date_trunc('hour', b) bucket, sum(a) from foo group by bucket; \set ON_ERROR_STOP 1 delete from foo where a = 99; reset timescaledb.enable_custom_hashagg; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/���������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0017344�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/cagg_migrate_integer.sql���������������������������������������0000664�0000000�0000000�00000024172�15100345067�0024221�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" integer NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_2 AS SELECT public.time_bucket(24, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(24, "time")); CREATE VIEW _timescaledb_internal._direct_view_3 AS SELECT public.time_bucket(24, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(24, "time")); CREATE VIEW _timescaledb_internal._direct_view_4 AS SELECT public.time_bucket(168, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(168, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_2 ( bucket integer NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_3 ( bucket integer NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_4 ( bucket integer NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_2 AS SELECT public.time_bucket(24, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket(24, "time")); CREATE VIEW _timescaledb_internal._partial_view_3 AS SELECT public.time_bucket(24, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket(24, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_4 AS SELECT public.time_bucket(168, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket(168, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_3.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_3.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_3 WHERE (_materialized_hypertable_3.bucket < COALESCE((_timescaledb_functions.cagg_watermark(3))::integer, '-2147483648'::integer)) GROUP BY _materialized_hypertable_3.bucket UNION ALL SELECT public.time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(3))::integer, '-2147483648'::integer)) GROUP BY (public.time_bucket(24, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_2.bucket, _materialized_hypertable_2.min, _materialized_hypertable_2.max, _materialized_hypertable_2.avg, _materialized_hypertable_2.sum FROM _timescaledb_internal._materialized_hypertable_2 WHERE (_materialized_hypertable_2.bucket < COALESCE((_timescaledb_functions.cagg_watermark(2))::integer, '-2147483648'::integer)) UNION ALL SELECT public.time_bucket(24, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(2))::integer, '-2147483648'::integer)) GROUP BY (public.time_bucket(24, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_4.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_4.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_4 WHERE (_materialized_hypertable_4.bucket < COALESCE((_timescaledb_functions.cagg_watermark(4))::integer, '-2147483648'::integer)) GROUP BY _materialized_hypertable_4.bucket UNION ALL SELECT public.time_bucket(168, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE((_timescaledb_functions.cagg_watermark(4))::integer, '-2147483648'::integer)) GROUP BY (public.time_bucket(168, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; 1 public conditions _timescaledb_internal _hyper_1 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 2 _timescaledb_internal _materialized_hypertable_2 _timescaledb_internal _hyper_2 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 3 _timescaledb_internal _materialized_hypertable_3 _timescaledb_internal _hyper_3 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 4 _timescaledb_internal _materialized_hypertable_4 _timescaledb_internal _hyper_4 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 \. COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; 1 1 time integer t \N \N \N 10 \N public integer_now 2 2 bucket integer t \N \N \N 100 \N \N \N 3 3 bucket integer t \N \N \N 100 \N \N \N 4 4 bucket integer t \N \N \N 100 \N \N \N \. COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; 2 1 \N public conditions_summary_daily_new _timescaledb_internal _partial_view_2 _timescaledb_internal _direct_view_2 f t 3 1 \N public conditions_summary_daily _timescaledb_internal _partial_view_3 _timescaledb_internal _direct_view_3 f f 4 1 \N public conditions_summary_weekly _timescaledb_internal _partial_view_4 _timescaledb_internal _direct_view_4 f f \. COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; 2 public.time_bucket(integer, integer) 24 t 3 public.time_bucket(integer, integer) 24 t 4 public.time_bucket(integer, integer) 168 t \. COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; 1 -2147483648 \. COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; 2 -9223372036854775808 9223372036854775807 3 -9223372036854775808 9223372036854775807 4 -9223372036854775808 9223372036854775807 \. COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; 2 -2147483648 3 -2147483648 4 -2147483648 \. SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 4, true); SELECT pg_catalog.setval('_timescaledb_catalog.hypertable_id_seq', 4, true); CREATE INDEX _materialized_hypertable_2_bucket_idx ON _timescaledb_internal._materialized_hypertable_2 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_3_bucket_idx ON _timescaledb_internal._materialized_hypertable_3 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_4_bucket_idx ON _timescaledb_internal._materialized_hypertable_4 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/cagg_migrate_timestamp.sql�������������������������������������0000664�0000000�0000000�00000026027�15100345067�0024570�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" timestamp without time zone NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_6 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_7 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_8 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_6 ( bucket timestamp without time zone NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_7 ( bucket timestamp without time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_8 ( bucket timestamp without time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_6 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._partial_view_7 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_8 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_7.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_7.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_7 WHERE (_materialized_hypertable_7.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) GROUP BY _materialized_hypertable_7.bucket UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(7)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_6.bucket, _materialized_hypertable_6.min, _materialized_hypertable_6.max, _materialized_hypertable_6.avg, _materialized_hypertable_6.sum FROM _timescaledb_internal._materialized_hypertable_6 WHERE (_materialized_hypertable_6.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp without time zone)) UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(6)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_8.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_8.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_8 WHERE (_materialized_hypertable_8.bucket < COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp without time zone)) GROUP BY _materialized_hypertable_8.bucket UNION ALL SELECT public.time_bucket('7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp_without_timezone(_timescaledb_functions.cagg_watermark(8)), '-infinity'::timestamp without time zone)) GROUP BY (public.time_bucket('7 days'::interval, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; 5 public conditions _timescaledb_internal _hyper_5 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 6 _timescaledb_internal _materialized_hypertable_6 _timescaledb_internal _hyper_6 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 7 _timescaledb_internal _materialized_hypertable_7 _timescaledb_internal _hyper_7 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 8 _timescaledb_internal _materialized_hypertable_8 _timescaledb_internal _hyper_8 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 \. COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; 5 5 time timestamp without time zone t \N \N \N 604800000000 \N \N \N 6 6 bucket timestamp without time zone t \N \N \N 6048000000000 \N \N \N 7 7 bucket timestamp without time zone t \N \N \N 6048000000000 \N \N \N 8 8 bucket timestamp without time zone t \N \N \N 6048000000000 \N \N \N \. COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; 6 5 \N public conditions_summary_daily_new _timescaledb_internal _partial_view_6 _timescaledb_internal _direct_view_6 f t 7 5 \N public conditions_summary_daily _timescaledb_internal _partial_view_7 _timescaledb_internal _direct_view_7 f f 8 5 \N public conditions_summary_weekly _timescaledb_internal _partial_view_8 _timescaledb_internal _direct_view_8 f f \. COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; 6 public.time_bucket(interval,timestamp without time zone) 1 day f 7 public.time_bucket(interval,timestamp without time zone) 1 day f 8 public.time_bucket(interval,timestamp without time zone) 10 days f \. COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; 5 -210866803200000000 \. COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; 6 -9223372036854775808 9223372036854775807 7 -9223372036854775808 9223372036854775807 8 -9223372036854775808 9223372036854775807 \. COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; 6 -210866803200000000 7 -210866803200000000 8 -210866803200000000 \. SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 8, true); SELECT pg_catalog.setval('_timescaledb_catalog.hypertable_id_seq', 8, true); CREATE INDEX _materialized_hypertable_6_bucket_idx ON _timescaledb_internal._materialized_hypertable_6 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_7_bucket_idx ON _timescaledb_internal._materialized_hypertable_7 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_8_bucket_idx ON _timescaledb_internal._materialized_hypertable_8 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/cagg_migrate_timestamptz.sql�����������������������������������0000664�0000000�0000000�00000025577�15100345067�0025157�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE public.conditions ( "time" timestamp with time zone NOT NULL, temperature numeric ); CREATE VIEW _timescaledb_internal._direct_view_10 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_11 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._direct_view_12 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")); CREATE TABLE _timescaledb_internal._materialized_hypertable_10 ( bucket timestamp with time zone NOT NULL, min numeric, max numeric, avg numeric, sum numeric ); CREATE TABLE _timescaledb_internal._materialized_hypertable_11 ( bucket timestamp with time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE TABLE _timescaledb_internal._materialized_hypertable_12 ( bucket timestamp with time zone NOT NULL, agg_2_2 bytea, agg_3_3 bytea, agg_4_4 bytea, agg_5_5 bytea, chunk_id integer ); CREATE VIEW _timescaledb_internal._partial_view_10 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, min(temperature) AS min, max(temperature) AS max, avg(temperature) AS avg, sum(temperature) AS sum FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")); CREATE VIEW _timescaledb_internal._partial_view_11 AS SELECT public.time_bucket('1 day'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('1 day'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW _timescaledb_internal._partial_view_12 AS SELECT public.time_bucket('7 days'::interval, "time") AS bucket, _timescaledb_functions.partialize_agg(min(temperature)) AS agg_2_2, _timescaledb_functions.partialize_agg(max(temperature)) AS agg_3_3, _timescaledb_functions.partialize_agg(avg(temperature)) AS agg_4_4, _timescaledb_functions.partialize_agg(sum(temperature)) AS agg_5_5, _timescaledb_functions.chunk_id_from_relid(tableoid) AS chunk_id FROM public.conditions GROUP BY (public.time_bucket('7 days'::interval, "time")), (_timescaledb_functions.chunk_id_from_relid(tableoid)); CREATE VIEW public.conditions_summary_daily AS SELECT _materialized_hypertable_11.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_11.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_11 WHERE (_materialized_hypertable_11.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) GROUP BY _materialized_hypertable_11.bucket UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(11)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_daily_new AS SELECT _materialized_hypertable_10.bucket, _materialized_hypertable_10.min, _materialized_hypertable_10.max, _materialized_hypertable_10.avg, _materialized_hypertable_10.sum FROM _timescaledb_internal._materialized_hypertable_10 WHERE (_materialized_hypertable_10.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)) UNION ALL SELECT public.time_bucket('1 day'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(10)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('1 day'::interval, conditions."time")); CREATE VIEW public.conditions_summary_weekly AS SELECT _materialized_hypertable_12.bucket, _timescaledb_functions.finalize_agg('pg_catalog.min(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_2_2, NULL::numeric) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_3_3, NULL::numeric) AS max, _timescaledb_functions.finalize_agg('pg_catalog.avg(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_4_4, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.sum(numeric)'::text, NULL::name, NULL::name, '{{pg_catalog,numeric}}'::name[], _materialized_hypertable_12.agg_5_5, NULL::numeric) AS sum FROM _timescaledb_internal._materialized_hypertable_12 WHERE (_materialized_hypertable_12.bucket < COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(12)), '-infinity'::timestamp with time zone)) GROUP BY _materialized_hypertable_12.bucket UNION ALL SELECT public.time_bucket('7 days'::interval, conditions."time") AS bucket, min(conditions.temperature) AS min, max(conditions.temperature) AS max, avg(conditions.temperature) AS avg, sum(conditions.temperature) AS sum FROM public.conditions WHERE (conditions."time" >= COALESCE(_timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(12)), '-infinity'::timestamp with time zone)) GROUP BY (public.time_bucket('7 days'::interval, conditions."time")); COPY _timescaledb_catalog.hypertable (id, schema_name, table_name, associated_schema_name, associated_table_prefix, num_dimensions, chunk_sizing_func_schema, chunk_sizing_func_name, chunk_target_size, compression_state, compressed_hypertable_id, status) FROM stdin; 9 public conditions _timescaledb_internal _hyper_9 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 10 _timescaledb_internal _materialized_hypertable_10 _timescaledb_internal _hyper_10 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 11 _timescaledb_internal _materialized_hypertable_11 _timescaledb_internal _hyper_11 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 12 _timescaledb_internal _materialized_hypertable_12 _timescaledb_internal _hyper_12 1 _timescaledb_functions calculate_chunk_interval 0 0 \N 0 \. COPY _timescaledb_catalog.dimension (id, hypertable_id, column_name, column_type, aligned, num_slices, partitioning_func_schema, partitioning_func, interval_length, compress_interval_length, integer_now_func_schema, integer_now_func) FROM stdin; 9 9 time timestamp with time zone t \N \N \N 604800000000 \N \N \N 10 10 bucket timestamp with time zone t \N \N \N 6048000000000 \N \N \N 11 11 bucket timestamp with time zone t \N \N \N 6048000000000 \N \N \N 12 12 bucket timestamp with time zone t \N \N \N 6048000000000 \N \N \N \. COPY _timescaledb_catalog.continuous_agg (mat_hypertable_id, raw_hypertable_id, parent_mat_hypertable_id, user_view_schema, user_view_name, partial_view_schema, partial_view_name, direct_view_schema, direct_view_name, materialized_only, finalized) FROM stdin; 10 9 \N public conditions_summary_daily_new _timescaledb_internal _partial_view_10 _timescaledb_internal _direct_view_10 f t 11 9 \N public conditions_summary_daily _timescaledb_internal _partial_view_11 _timescaledb_internal _direct_view_11 f f 12 9 \N public conditions_summary_weekly _timescaledb_internal _partial_view_12 _timescaledb_internal _direct_view_12 f f \. COPY _timescaledb_catalog.continuous_aggs_bucket_function (mat_hypertable_id, bucket_func, bucket_width, bucket_fixed_width) FROM stdin; 10 public.time_bucket(interval,timestamp with time zone) 1 day f 11 public.time_bucket(interval,timestamp with time zone) 1 day f 12 public.time_bucket(interval,timestamp with time zone) 10 days f \. COPY _timescaledb_catalog.continuous_aggs_invalidation_threshold (hypertable_id, watermark) FROM stdin; 9 -210866803200000000 \. COPY _timescaledb_catalog.continuous_aggs_materialization_invalidation_log (materialization_id, lowest_modified_value, greatest_modified_value) FROM stdin; 10 -9223372036854775808 9223372036854775807 11 -9223372036854775808 9223372036854775807 12 -9223372036854775808 9223372036854775807 \. COPY _timescaledb_catalog.continuous_aggs_watermark (mat_hypertable_id, watermark) FROM stdin; 10 -210866803200000000 11 -210866803200000000 12 -210866803200000000 \. SELECT pg_catalog.setval('_timescaledb_catalog.dimension_id_seq', 12, true); CREATE INDEX _materialized_hypertable_10_bucket_idx ON _timescaledb_internal._materialized_hypertable_10 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_11_bucket_idx ON _timescaledb_internal._materialized_hypertable_11 USING btree (bucket DESC); CREATE INDEX _materialized_hypertable_12_bucket_idx ON _timescaledb_internal._materialized_hypertable_12 USING btree (bucket DESC); CREATE INDEX conditions_time_idx ON public.conditions USING btree ("time" DESC); ���������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/copy_data.csv��������������������������������������������������0000664�0000000�0000000�00000015410�15100345067�0022025�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������generate_series,random 1,1 11,1 12,2 13,3 14,4 15,5 16,6 17,7 18,8 19,9 11,10 12,11 13,12 14,13 15,14 16,15 17,16 18,17 19,18 11,19 12,20 13,21 14,22 15,23 16,24 17,25 18,26 19,27 11,28 12,29 13,30 14,31 15,32 16,33 17,34 18,35 19,36 11,37 12,38 13,39 14,40 15,41 16,42 17,43 18,44 19,45 11,46 12,47 13,48 14,49 15,50 16,51 17,52 18,53 19,54 11,55 12,56 13,57 14,58 15,59 16,60 17,61 18,62 19,63 11,64 12,65 13,66 14,67 15,68 16,69 17,70 18,71 19,72 11,73 12,74 13,75 14,76 15,77 16,78 17,79 18,80 19,81 11,82 12,83 13,84 14,85 15,86 16,87 17,88 18,89 19,90 11,91 12,92 13,93 14,94 15,95 16,96 17,97 18,98 19,99 11,100 12,101 13,102 14,103 15,104 16,105 17,106 18,107 19,108 11,109 12,110 13,111 14,112 15,113 16,114 17,115 18,116 19,117 11,118 12,119 13,120 14,121 15,122 16,123 17,124 18,125 19,126 11,127 12,128 13,129 14,130 15,131 16,132 17,133 18,134 19,135 11,136 12,137 13,138 14,139 15,140 16,141 17,142 18,143 19,144 11,145 12,146 13,147 14,148 15,149 16,150 17,151 18,152 19,153 11,154 12,155 13,156 14,157 15,158 16,159 17,160 18,161 19,162 11,163 12,164 13,165 14,166 15,167 16,168 17,169 18,170 19,171 11,172 12,173 13,174 14,175 15,176 16,177 17,178 18,179 19,180 11,181 12,182 13,183 14,184 15,185 16,186 17,187 18,188 19,189 11,190 12,191 13,192 14,193 15,194 16,195 17,196 18,197 19,198 11,199 12,200 13,201 14,202 15,203 16,204 17,205 18,206 19,207 11,208 12,209 13,210 14,211 15,212 16,213 17,214 18,215 19,216 11,217 12,218 13,219 14,220 15,221 16,222 17,223 18,224 19,225 11,226 12,227 13,228 14,229 15,230 16,231 17,232 18,233 19,234 11,235 12,236 13,237 14,238 15,239 16,240 17,241 18,242 19,243 11,244 12,245 13,246 14,247 15,248 16,249 17,250 18,251 19,252 11,253 12,254 13,255 14,256 15,257 16,258 17,259 18,260 19,261 11,262 12,263 13,264 14,265 15,266 16,267 17,268 18,269 19,270 11,271 12,272 13,273 14,274 15,275 16,276 17,277 18,278 19,279 11,280 12,281 13,282 14,283 15,284 16,285 17,286 18,287 19,288 11,289 12,290 13,291 14,292 15,293 16,294 17,295 18,296 19,297 11,298 12,299 13,300 14,301 15,302 16,303 17,304 18,305 19,306 11,307 12,308 13,309 14,310 15,311 16,312 17,313 18,314 19,315 11,316 12,317 13,318 14,319 15,320 16,321 17,322 18,323 19,324 11,325 12,326 13,327 14,328 15,329 16,330 17,331 18,332 19,333 11,334 12,335 13,336 14,337 15,338 16,339 17,340 18,341 19,342 11,343 12,344 13,345 14,346 15,347 16,348 17,349 18,350 19,351 11,352 12,353 13,354 14,355 15,356 16,357 17,358 18,359 19,360 11,361 12,362 13,363 14,364 15,365 16,366 17,367 18,368 19,369 11,370 12,371 13,372 14,373 15,374 16,375 17,376 18,377 19,378 11,379 12,380 13,381 14,382 15,383 16,384 17,385 18,386 19,387 11,388 12,389 13,390 14,391 15,392 16,393 17,394 18,395 19,396 11,397 12,398 13,399 14,400 15,401 16,402 17,403 18,404 19,405 11,406 12,407 13,408 14,409 15,410 16,411 17,412 18,413 19,414 11,415 12,416 13,417 14,418 15,419 16,420 17,421 18,422 19,423 11,424 12,425 13,426 14,427 15,428 16,429 17,430 18,431 19,432 11,433 12,434 13,435 14,436 15,437 16,438 17,439 18,440 19,441 11,442 12,443 13,444 14,445 15,446 16,447 17,448 18,449 19,450 11,451 12,452 13,453 14,454 15,455 16,456 17,457 18,458 19,459 11,460 12,461 13,462 14,463 15,464 16,465 17,466 18,467 19,468 11,469 12,470 13,471 14,472 15,473 16,474 17,475 18,476 19,477 11,478 12,479 13,480 14,481 15,482 16,483 17,484 18,485 19,486 11,487 12,488 13,489 14,490 15,491 16,492 17,493 18,494 19,495 11,496 12,497 13,498 14,499 15,500 16,501 17,502 18,503 19,504 11,505 12,506 13,507 14,508 15,509 16,510 17,511 18,512 19,513 11,514 12,515 13,516 14,517 15,518 16,519 17,520 18,521 19,522 11,523 12,524 13,525 14,526 15,527 16,528 17,529 18,530 19,531 11,532 12,533 13,534 14,535 15,536 16,537 17,538 18,539 19,540 11,541 12,542 13,543 14,544 15,545 16,546 17,547 18,548 19,549 11,550 12,551 13,552 14,553 15,554 16,555 17,556 18,557 19,558 11,559 12,560 13,561 14,562 15,563 16,564 17,565 18,566 19,567 11,568 12,569 13,570 14,571 15,572 16,573 17,574 18,575 19,576 11,577 12,578 13,579 14,580 15,581 16,582 17,583 18,584 19,585 11,586 12,587 13,588 14,589 15,590 16,591 17,592 18,593 19,594 11,595 12,596 13,597 14,598 15,599 16,600 17,601 18,602 19,603 11,604 12,605 13,606 14,607 15,608 16,609 17,610 18,611 19,612 11,613 12,614 13,615 14,616 15,617 16,618 17,619 18,620 19,621 11,622 12,623 13,624 14,625 15,626 16,627 17,628 18,629 19,630 11,631 12,632 13,633 14,634 15,635 16,636 17,637 18,638 19,639 11,640 12,641 13,642 14,643 15,644 16,645 17,646 18,647 19,648 11,649 12,650 13,651 14,652 15,653 16,654 17,655 18,656 19,657 11,658 12,659 13,660 14,661 15,662 16,663 17,664 18,665 19,666 11,667 12,668 13,669 14,670 15,671 16,672 17,673 18,674 19,675 11,676 12,677 13,678 14,679 15,680 16,681 17,682 18,683 19,684 11,685 12,686 13,687 14,688 15,689 16,690 17,691 18,692 19,693 11,694 12,695 13,696 14,697 15,698 16,699 17,700 18,701 19,702 11,703 12,704 13,705 14,706 15,707 16,708 17,709 18,710 19,711 11,712 12,713 13,714 14,715 15,716 16,717 17,718 18,719 19,720 11,721 12,722 13,723 14,724 15,725 16,726 17,727 18,728 19,729 11,730 12,731 13,732 14,733 15,734 16,735 17,736 18,737 19,738 11,739 12,740 13,741 14,742 15,743 16,744 17,745 18,746 19,747 11,748 12,749 13,750 14,751 15,752 16,753 17,754 18,755 19,756 11,757 12,758 13,759 14,760 15,761 16,762 17,763 18,764 19,765 11,766 12,767 13,768 14,769 15,770 16,771 17,772 18,773 19,774 11,775 12,776 13,777 14,778 15,779 16,780 17,781 18,782 19,783 11,784 12,785 13,786 14,787 15,788 16,789 17,790 18,791 19,792 11,793 12,794 13,795 14,796 15,797 16,798 17,799 18,800 19,801 11,802 12,803 13,804 14,805 15,806 16,807 17,808 18,809 19,810 11,811 12,812 13,813 14,814 15,815 16,816 17,817 18,818 19,819 11,820 12,821 13,822 14,823 15,824 16,825 17,826 18,827 19,828 11,829 12,830 13,831 14,832 15,833 16,834 17,835 18,836 19,837 11,838 12,839 13,840 14,841 15,842 16,843 17,844 18,845 19,846 11,847 12,848 13,849 14,850 15,851 16,852 17,853 18,854 19,855 11,856 12,857 13,858 14,859 15,860 16,861 17,862 18,863 19,864 11,865 12,866 13,867 14,868 15,869 16,870 17,871 18,872 19,873 11,874 12,875 13,876 14,877 15,878 16,879 17,880 18,881 19,882 11,883 12,884 13,885 14,886 15,887 16,888 17,889 18,890 19,891 11,892 12,893 13,894 14,895 15,896 16,897 17,898 18,899 19,900 11,901 12,902 13,903 14,904 15,905 16,906 17,907 18,908 19,909 11,910 12,911 13,912 14,913 15,914 16,915 17,916 18,917 19,918 11,919 12,920 13,921 14,922 15,923 16,924 17,925 18,926 19,927 11,928 12,929 13,930 14,931 15,932 16,933 17,934 18,935 19,936 11,937 12,938 13,939 14,940 15,941 16,942 17,943 18,944 19,945 11,946 12,947 13,948 14,949 15,950 16,951 17,952 18,953 19,954 11,955 12,956 13,957 14,958 15,959 16,960 17,961 18,962 19,963 11,964 12,965 13,966 14,967 15,968 16,969 17,970 18,971 19,972 11,973 12,974 13,975 14,976 15,977 16,978 17,979 18,980 19,981 11,982 12,983 13,984 14,985 15,986 16,987 17,988 18,989 19,990 11,991 12,992 13,993 14,994 15,995 16,996 17,997 18,998 19,999 11,1000 ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/magic.csv������������������������������������������������������0000664�0000000�0000000�00000001562�15100345067�0021145�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������metric_id,created_at,device_id,temp,humidity 298,Wed Jun 01 00:49:30 2022 PDT,1,26.5904140796662,25.6517507790162 1005,Wed Jun 01 02:47:20 2022 PDT,2,32.7607481200711,0.0814742363326237 345,Wed Jun 01 00:57:20 2022 PDT,1,14.2112895008574,0.252265718039268 353,Wed Jun 01 00:58:40 2022 PDT,5,5.02598214446964,40.2435007149558 977,Wed Jun 01 02:42:40 2022 PDT,1,0.949462224935731,62.1551090171878 2298,Wed Jun 01 06:22:50 2022 PDT,6,25.1019351511395,19.2896631866349 164,Wed Jun 01 00:27:10 2022 PDT,1,22.1571424036187,95.7589111064385 511,Wed Jun 01 01:25:00 2022 PDT,1,30.5256995663874,59.3760333752531 3246,Wed Jun 01 09:00:50 2022 PDT,7,39.3508344139115,95.1677745558139 363,Wed Jun 01 01:00:20 2022 PDT,13,30.4508743614474,56.0536696009606 655,Wed Jun 01 01:49:00 2022 PDT,8,29.1506488040468,98.2462821993139 1096,Wed Jun 01 03:02:30 2022 PDT,1,16.7951263617964,76.8274813106784 ����������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/prices-100k-random-1.tsv.gz������������������������������������0000664�0000000�0000000�00013512475�15100345067�0024115�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������‹³ñjbprices-100k-random-1.tsv�¬[Û’«8²}V…ßÎËT÷Ë£�ÙPÆ@IP”wÌÿǬLI€]®Ý»;ÎtŒ‘ñ.!¥2W®¼§Aˆ(²· x‹CQ5a,’f¡ðÿXˆF ó8œô¸Ò°û›•–ÍyÔÍ>X•™O÷Q_MÛi%‚¿Â0ͳˆ¦Îß0{TŠ*“̳ҥ“Ô×^9ÉO5,˜¶Ó·n¸´òößrëþ+<$.Ê”×–´þ ¦OD2\DÄË#!Σ™•ök‡?µ¿ž0Óé&;Úš’ÍO·ƒ¿¢€žEÂ~â·(fSœéY´¡4¢ê—¡Q}jt÷‰‡HNáSžYH~àeçvõAôFoOÓ–¢œ'üBˆ[7×-Mˆ-hY+1KœFÕñ¤C¯î8½â„ –*šE“”Hø;×€„b¢S¿;ÁäÌu€L ûk¡MÖ£„4-/•önWÅì´ÿÒM†4eŠö+åû ¡Sìv†;/Zr_iÙ­Ô ZÙwgù%jÙc¹ìÕw}‰ómŦ¦(¹ÖN™õzÛ䀱PUµž>i¶ª—jËéB¢xúi$^ËK^z!&]Š¼ÕnéÖ®Gu‚VÑ™ËÜN£ž…QgH@Ü”6Êî‹æJœ né[Xˆö‰|zwË$³ªvšzZ(6¯õx‘³:ŒLß>šKæט’zA³Æ¯(‘2n‘!Ô«] ›ÃÉÌê mëjEº- "šÄ¿9ªWfe™ÒœÉ¶f¢ª`­H0eåê{ìÍŠPÂçv*ÅEËá‚ À>O«¼cᦇ 'cÔÀGxBrµôMX«Ã²„¡@« QŸChJ;{ÝK„èÇõÜ©¾q†2·Ð½ËŠè¦;Ÿ¿]¡ é>mò…bR‘(eïõ³Žº†Œ/ uY‡ñ/!¥jÔãri¿ÔòV鮹(¿ø”µO)P`åu›Pþ xRƒ©î€D C«Ì*±ðµƒbn—G)ÜÙ†)OZˆ ¡Ôrws&¤~U7œê~48‰ªRwë¥wÄ/‡~ÑE¼á¡ lg�tO_G°äzì×û`—ÌÚ'o‰æÆþ)QîT?b€:Ñ´g§N ½éfrõ¸èÙ>Œ-½†ýŸßÆáÍ(i ŠóÓwÌc ùŽô 80Cðñ Æ@XaG7@Ö¸š'íN Ü«iû¿Ò3 ÷ Þ f4+¸|ÿå¤FY-õµWÝ¥õÒqœ2É 'ÉŸ»˜;[âõ“[º¦"[¬®Â)†€`¢©}ß̪Z_-ðl#?õ ÖÚãÇA$¥µë0!¬€×î¦B¹4ηB!±®›„‚àlð·ph8ÅYõÝž°Â‡,pGýÇ%áNzÿl8Ë6˜ ‚ÌVæ>¼kJá›ph'¶‚‹hŒp«x¼¼O±¯¥%&',Û &—¦gɤ€äêÌØwí[ÛÏ| J‚ éá§@eÚK,¢õì‘žŽT7®³µ+0‡¹Eßÿ)PçñN™JZüÔÇ�"X³ÕM@7Ö¥®ÂÁ€0ªg—ºì¬äo:¶àÇ;î0sG[ß�žÉ$x&Ö Ú6JSiÀ6Ý9Œ°ù‹6ض$&0@"™:ûù`´·qÔÊÚÐMN“baã<;ÖuQ épkƒ„8}€„Pô æÕ‹wZ4}£>G‡<ø™ æø ‰F™Ã\¸çœ\ßí ¿5Þ§2‰øìÔ kå¤z«ì4<“¥ºåÊ{¯¬eYn°ý²ašexY%„©ÙÙg’‘PÇuwµ0(ÝÁ1ý¬›{i›^µÃ˜ö»©*D#ÝÌyÁ{ÐôwÛÜu¹/$Œö>4XùðèP-îB>LÒ¡Ôú’ÀͼóÄO¸4p§Õ ±yx@/”W#šÔˆfN.Ïk.2cU9Â<=þ-QŽv\ŒúÏ)ç^Î'œFË;6n˜t¦W+éôa„¿LÿÊü‹Ãq§äȇ!+ñD‡ÀqPëæÄ•jž|SCŠ?ëû+'•GéF|“7œj­ ‘JOy€ðâ2B$‘SpxrA—T¾Öã½y‰çy¾“³„4ÔܱØ÷ÞQÓ¬ðøV1+y'ÚqbBcZ­VVÇÃà 9³>áî8íªé,räÉ vñ¾I'°žÉ™³6€�å$Ûl'ÜG€ô2ØøSH̦2páé"w-‚•×ã­rX�b„môÛ•ýôé™}¼¾ $óÀ2Èã$æL”Ã/·‘IÁÁaà( ÏjD¼a¥†3¥©ÝÈ|-’ÐܱÛJJ±¡øN¨*:ä?úª#"¢•©) à­õÃO×2—.Ê Èï!fj—°QÿËã% A]4TÈ… k?¨". ^”<"Ìë4ž^ãÇ€ÑÎjÉEðìfq‡RË7voÏ„Uódäp…¾®pS8^qèñNrè@;ˆ)|Xw‚À•¬í&ë+ë‘cãuwë%lPBúüy".rC¨ÆùÅ௲<ò5œõ}„‚%­qfw–F�hy¡ˆs`ôÌn‰¤ñüA†°s" är³“'âALáqï•U¹„Äëë÷ ~�æÑ�žß=‡AÎpì1Öd:|èJ˜_/nl1—NÖpþdDÚ.–ÃêŽÃìnˆ#`%yPÇŸîyM6@ω(¢DÜ~y@J\Ë$æ¼ôÌ &‡CîúàdÂÈ)Œ<a@ø�„Ø9³§c'Äß@¡îæ;éôOß)b.c…rÄ �T,â‹vd•ÉpÛˆ[“øcY`ê§e½ùþîу몤fãäêÙžƒ\ô=(ѽ; 5öÔÁC ÷…Ò\8¿¿Z =|mé’á4ÃZŠ¤ÑŽÃN#ÂíýfaýfNœeÐêîü´#*©5÷;œò~‡2\Ð,*ùûä5 ¢»ƒWsSj5[}•`€s/×´Q!ؤB¨ID!/>ô¹ÇO°'Êø©‰70ì]8ñÖË °ž’ZåîÁJb+=N8¬Œ71·–«ñ”°âhŽÉöÑ«ÄK–¥’E´ävkX¹ì0±Îj[¯Y8%GL±xõä­Ð¯¬:÷ù…hã`dp�Ò4 Ó>ø óÚ2óß„‹+E)Öa;ê< ž‚ëË?–.ÃF¥!8y«Àm!O§ñ,Ø#QO³hR¬–QÛ~!5-öx(¢lÕ4&rÍ…— £ÎâxÚSÝväÑ΀‡ÖNJtŽd²Òsž¾A‚=­‘R]FD‹”“ÉL šYº±úŸl W°B»~@›8öÒË@h?áÀÖ®Þ=d™nD‚sà‹™ÈØx ¨4,Pí­Šº•Í?¡Q˜f[v3'&|ldëÝ_Ê®ûy‹d Å¿¢ÂÇé%™YÌ9ÍT¤«ô¡bN–ö géSÆ7îÌ{üÀ.ñññ†CŠ„Òš`¯D¯”O²„ªŠì”rí} °g(%Gñ»Ò$Áo$26º^ÌgOJbÐËiF·[4³†ƒ®ÔÄ7/³ŒX—^ßr‘jŸ“Ž€ob’ƒM Z&­e7'~9ò1n¸±œ„µÂÞÐ'Ó’L“ýíü P²öÕÕ¥@bOʼn †´\"™ƒø a.ûÕm`3ÐÇÔXY¸]wÆ=öE센àPQ5«œõÀ‡óÄ÷§$øöÁÎî@ÌȨ9ÿþGèfT¤ƒ`Ç8 Àê¬ÿrxS&D õÜÉþÔ€¾)Ðó¥WŸÒr!Ê‹Ý÷%éß ëU€4$%À~«Áí|Ä"¨¥Š6ܤZ‹œ;O PHÒV'ŽãïÙÜ iù ¸”ñmë5.¦Ìkó€w÷frñ)¡ÛqxS «»�X“bw̓˜1F|ùîñ½aM6NKDKÛr‡HÒÐäª^“øL­Ý!tËË-Û‡rÈ`®&¹Üè0¥xÉ1oþ¾ýS+)±èê\5ªðÀrö%.¸=Z )ݶ‡Vß)òÏ\9‹Ž‘§GÞfSë1#Ž Aä †Ò*›Ž«€‹æ Ý_ÉkºûJdâÍJû/æäô½v~Ný¦Ä«×Hžízdì͈lñiÅÇA*º ›ôaâDNñׯFÖ\Ž‚I˽î[’œˆ²jÝñF”7‚AtÆÁ×ÿ#GÎsòÒæbz4Wž’yS­˜2$ÕiùªÓß•ŸJ³yÐŒ†ÐÀÜ´•7“ Ò)«ÖÃçuo%3*Å•ÌíãLd‡}Z7%HQç-Yº³Ìë0®†TégF~V1¢W0‚Àøj!ň}g˜s;Ÿ ÞdaÐx™ÕèÈ�í17Rn¡€9×9ÌEø~wÏØRëð³PÛq»;ôÅRßüv%G¶$bÍEÜxæM^»^êë8ž�w{ô¡$gw¿ù§-¹K|4"ŠJŠiÚ >CN“ÖW800W†á¯iÇù0Ò‹i)Ëü€haæruDyS.® 0ï'„¬àó«ÈõÈáŠé&--eÁr’š,”fc÷öô-Ä1ZJ˜Ùô8ʼ÷Ù1ªDº*u-gìÌ·nÉ“oƒc<~´Ú(ȃCŸ =+¥®ßµ ҭ©ùŸ‡á–¬ˆ\©Ùb‚/EÃY\4 Ù)È¿…€09Td8íXðù¬]|B‘ÍÇ"µåÙT²[&¥ßn¯ïX‘m¼ãé+íq·6BVDÈ°Û ]Àg+}¬u»4–\ŠBˆâ«•InE©¨¿ ¶¢»e “ôÁ¢áÖ&E@98WM§iàxz*%pV{êTíËÒиv w^ ÿ÷ÿ߇Á‰šïiãNÃ`'¥%†„¾@Š¹ôªAÊGjLÅ(Û*P˾&cÁvÉ yâJym{ú sŸ“Y L)žý*½ ª?rTX�eZNw"q^©¨)¿ î`^öh¯-Ç„âõXŠPzÇD¹Öµífâ”�w0‹ €ÇEY7øNÛ£2ßQ³êSM”í‡Ïus÷Ã߀ýv\"µ2±çìO{kö ÊeDRéM)ŠfuRÑ#d8›ÓÚJï!8Û ¦’ÚR~½RÀLûùÀ$áSsƒ™Á(çÆC"ÅÓ ”hkjâB¦3T×½**sÏÄTÛN„¶ŽùÜ&m}B¶¼L#pz÷‘BÝKÊÿs@°ÁÕòFMìáè£ÆXÚíe¤–l3ÜŠf.€åÉ­o´p̶‚ú^Û½�Øž)™à«Â¢où¢h ƒlÜS_Çù¼÷ýœ©:�íÙúÄ6‡ú7#ldç›ÖDÌ^(Í¡Ãjé¡”<`ù™îkRÃp‡A G6¾No#Þfdär—CÁ†�,&p¹]“@Äç‹?‹½€Ì»K‚Äþž•ÕO™kJ,?6£¤Âô€âþ| f•¼c}d!ôÅ0‚½¾ixÀ`~‡n©Íàz%FØ4‰s)ÿ”ÛDW®€B õ‰BùJiI'±ÜqÖ’ø>Ëøõе m)jnõ£2UÞ3óË…äÀý­ùäÐϦî—ã3_¥_Âe–o åb=CRà]ö|i?ãJñ#†¤#LtVyUþGßzÞ²ôP Å~VS‹Ì‡g°DÚ±’[3 „2ð¹ë fhÔ7Àãçäô¤ð}l0EÄç>4–¶yjl®ê2�…/94†­cé!Ü-ªäh!Í‹L‡ J½ l¦õØLȪî6£å¬ATI`Z0¥ü!Å[ ž�ß,Þg‡:1•(Ç{ã"¬®!oé.6¢: ϽpÑîl¨JE…=œ^Ùõr…^‚ ZÒ.Ë­‹µ¹ãSÞ ÓøÁå¢ÕPÙÆç¼(© gö¼"àQ±ýûÁ†šêñˆ£cþ†Û/þ¶jƺɪíóìß:/|ÿETúšgÉrÏÄ ÷ž½YQîÁÎÁ¢€jÎ; c€{ÕÒn€ºØœ*%Áàkƒ­¤¢ûÑ}ÅÅv“º”™³</\–MoúB¬TélÔ¡1ÿØPc“ÈôÀã„œÝhUO5Ýï¬|;mæ¬Äb3áĬ–‚ªRÈ Ø¢ðáJtÒWE§1'©Z›]zÝq…»ºrcÍDéÝ÷Å%4Ò˜«(½íÎàCàL‚¶ÑúÉ^ŸŠ}êXZV9„¥WËxóK‡.¾ñÎ’Rr‹cÏç,¬:Ýj¡ Å,ë9I니 �ñÄ´×Zšïdþ#Èôœ‘VͧLI…|ö­B˜!äàÛÝþyVaëÀ(vÞG˜D9{PÎœ0Ô@Å«™9± nÛáâõïºÇ’08&ª€ïúµé?|ÙPw $òÌÁíÞ-¡³æ†c°äÖ/c÷0Í÷ر ¯5L”Ô‘Õ!9BYýÔšÝþ¾ìÀ­ZžBpÇPw)E:|9c6AŽùÏ)-Oo§,t[ˆÅ${òª;ÎQ[–u?Ü𡦉àÛ‚l÷!‹ÚÑN‘H¦ÉçÈn賡ÇÏ=ê6Ù¸ã§2eXä›ó ¹fAª{_&ÉÄ"˜÷V!®‹õãøI½Ót�`)YØL^š;ö_|xÉSØ~•ÔNæpBY(¡1ÛX‚ì—÷Ö;X¾å‘vÝ2cxÕ'¢×wFÉ6×ãÂœ+ÔÉN5R‘È_^¦?÷ôjÆ ›¹P_ÀŒX5>J·¤îT-¼÷VSx‰¦ãJn×<…iÅ£•¤ŸHÛjkïà6kü±•4¹îˆ}¾2"ïŒ3!03T Ü_Á‚dh+K†ñ–½zÝëy¾º>¾½¦…üfIú1ùÒta‹{·Æ»ãË%ÿø%“<ÝÛÄa³c®ðñ »°‘ë{$TgŠ÷ˆ¥Süp×û©Úƒ?l(má./Î4ü+JZ 2Ñ~>'/ÿ˜Z Ç•âØí8ÿä5Ž0õdÂæ J±T¹È{…G̓´•Ýª8Ž·wë Gm“ U=?c)Ÿ£¾Ê°“'òYu¶³ÏÅ4ûàÙqeÉž'¬½ÉïA…Ô_` 5¥#8[sLü,Ør@ö™(<"l¾öî.ÐÌ›Üj{¾Lé»ZŸ¾¾*\Ñ.‘Ø6aõ©Üšá¨átA¼n}‡ªëÞvÿòªžÄ¿Ÿ<Ýk5»zÓåâ'.03ÎçÎDÙ¹rǺæâúœ·bÊ�ó[�êE?J\nM›®×‹zî.>J¸ñˆûi¼»úµ›­¥B^ûfÑ�h¼H¯‘®9 „½Uç—ùšD’ä` ä à+iü‹uŠHz§+箓Ãjø-¨ÜÇíRÜ2oÀÑK)· ”°¯»xkµ9ðÛÂ/(€ÈÒÔ”G¹ŸÜ[bßÈr ?¬ÿäé¼³J; f-çþÛãNÃ8}HÈÚ·ÓXµBÛdéê&Ÿ¿?-)¼!p­—’%+‚ÑLû� µeµ'ö(öߥáÓÝ'O:žoaò?Úþd¹udÙ�Ç8_¡YM2Ÿ¡o†�6R�(ŠÛêÿ¿£|¹‡G؉ÚyËì^Ò>IQ@„‡7«Iíé$ïº:ïW”…Û#jUwãQíâ_zÀÁ06à϶/‚r½5É`YpªWÊ5’ÕÒ–[{úÝ–A<öçˤ¹´$ã[èÉÒYk¶OÛ‹–#=Ûe`æÙ'é]êÄøùèùÚ>“ôiZ€ô%Ûjv{ @w˜’…Þ Ó›¦SÏ{W/MßÑÏýSÌå¸eé#š º”*±VÑqT®>¤Žà3Ÿ®©•¾¹­//(ø4ã;G%¿) Л,<¥]C[-Ž]dÀK†IÓÏZp$sX å ¤R.�^€lö´˜ª÷ÞåP\•˜7Úœ†a7¡Vº_U+Ë`^ Æ”Ÿvh‹ÁÉPo& ZɱÈB:Só ÷´ô£÷OÍ*hMŸ-/“ÝÌ?é¸r£KÔ%EIPõ[½Ï“Û rM¶‡C`H7$÷&!Ï´ê4È pad£i`ó5¯Œº×Ð>m;Ƥî±Å(”ÒÝovE1Ì»ÀHÌ¢œwïŠIĨâ<\,�k÷ ûㆯ½ ræ´o2¦Àʶ{i< ÐqoH‹ië6áþל€;‹pU))EJƒ¤=k�˹ȸçIi@3 tûJ¸¹È˜eò~À¡wÑ¡ã+;ï5Sˆ¥Ô<3¸Ûx]²%“ÔEÅ÷r #"ºx¸Î˜4}0ÌíCž¦±( ÏŒ ƒò½·JFm 4³ØÖÓDòÄ5ËtâÝË眹ÆQ\„ÞÜšÞåÔPZÿ1 Õ‘ —nz’×Fú:5³0îNƒúîë‹i(êàÅNaê:…c ⧴µ4î †¦ÏCÇídóÞ¿&âÛ&Ÿðžèôï)û® Î4=ÀžÍ›ám¢¸6õ ¾¦ŸyPè†ylJÆ ¾b[{°‰Õ ¶ déýq;Ã,‰/š´98÷Ýž†M7:ˆÒ“)k9BQk3%tÓšo¯Pmð˜u¦º7èk µÿ¢',O™]•¼«NtK§ÖnÛ„1_ô{MèÝ¢HàU×mv´GyhMIiŽ/¨W¼ˆRsäÐè@ÌÝÙ°¶àÿÌìaFJpÊ_7!ªb䙦™pþðŠ›{8\P€á˜m4ÊåYÍQsJSkýÝ¡ÂqO7UÆ@Ö’ Û“ë2(ÐÛ–õÓrŸYÊb¾r3m)áÝô$ ïwxQÉ\7´É迦\|ù[×cÇ ‰×HªöA5¤ÿ€N—bªÝ»Î@¬ 6›õ±8ËoÀ§3£E¯Ê6˜ËJ¥:ÿI¯yž¸ µ¦3_3d+ƒíú3dÜwË%S4w CŠ`æ]µûÑÖó„ÊŶCƆ˜ÈÒk¤âøõ p"'Ùô`9lêáÁO]GI˜³tl¬jÚ­ñøîXö†=jµ4¬ê@·‘>ýô?@î·:A�dôÒƒ&è CdG½Gh”0>ÁŽ>÷“žWÓ+(Ù|ý¡¿£íiåVÃÆ%‹3ÆÔèþ{í6Êw¨ò,ÆN/¨:M‚ä{ínÓfÜýá„ؽõÉxZ]I´J™£›âs"l»þCÚtZ)Â/3Š(ªœ~‰ ]·ô÷ce&¶‰JçÕm-åIt‹¯k^ÒÍÈpÆ1½æ–ÓZ ·¿Ã-±/±BûsÜÓâ@Ÿ×6w‡€,°È•¶Þð~ã@"Žþö‡w¦@n–.DÇÕ9 ŠÆ"ÃþÉâd¥£{î0Ø"äôÖ؆°¾56óäQZ?èɸÌKy2_o“a;p0œ~ 5½Kwñ(ET‰P´ïèð7XÙë×·¶c¿{_[}ç*ðCGQô9{%ï.Õ cr Â^Ý¢mcǨ6ð–2¿kTØ]€˜ý¶[Ky÷êÌ[Úfà07'ж, 9iÂîhIÔ½é¤0)ûêÅ;£$wSµŠS¸< Êñ¨#üÝt®(Q sº‰qþå™9ô§$š=!EXé³Ø¹Ánüh.o»á ­¾^ñçgöž{è P* J›Ë 95.¤¾éògœ¾ Ï^<˜f±+Õ%Q‹iµÊ©@Ÿ¢šœNBÛv~1·µ8Ø”×`Î th%ÒBzo"eå"Òï“èÌu*åmQ”³mÁ™r{²£q«upïê¡þA\„K Å<ÒÓG¯™ØPœ?'ókæñ4Ì×øÅ0{g}æYn>8ÏÒzúØe• ßéÞŠÁØ S’à¶N‚²×s0âÜJÎì‰ÓZ&KåRv(†? >Ú,\6Þ’ˆ‡Iwô8Šü¶›j ¯:ye’WI™˜€ÈÀ0SÆÚ±¶å„TkšOù¨ŽÍe%Ð⣆fQ¡MI¼ZQ4¥äæØù—r¨Ýa_‘‹KO-‹aÙç‰~Ûиa7 6i6Ä›~·2àFë,I²Â4!2Æž^œ7ViNï¹h¼ÆŒ#7_Áº‹ƒý°u§|•ˆñ�gíyîƺ8z`|t—¡›ž~ç!%ì8—1Zé»T3×ГÓFuKÿ¡Ñ{y«•²‡¤îöå�‚ò¶µ ?nûPfǬsÃ)*¯ì¯`I‘Ǧ-uØ�ß>0ŒÛcš�tßPκzÑynl‡°\ÕÑï†$ÈNúgpøí©Ð2­l3Œ½y½|Xa4Ƈҽo€Â´ ‚ì†,”dàá7œsmål¼þ N)O9Tvá÷m<ú‡”RoÀx¸Ã¤¿ìÍyPmÅ~8Cx?¯sÊeT,‡6H` ¡ð†Öï^çOP1vËj„Øôíö:=öãŠ暉%ôTûƒ¥#‡Då»þá(úrOèŽÞX^º{KIºÕöl™œ9Ïa-gˆâ.s+(©qWwÊwÔ&Üû+è^B¤ä"}°X ¯§¾çŒ]‡Ž[:ŽxTq‡éÀì@ž®_}âăXeèCL¶Qki´:äL÷Ð8Yd~5§¨÷Mwo~T)w,6ÀÃ~Ó*0ñèŽô#µ\YÓšZtí³é²WH{cõHãçä!Mê‘)MFr‚ž¯Ñ¦keÞ5œ èa6ýé;Sí½’AŸ”Õ´ÃÓÑ"…HCPÌþÒâ¥HF_$I¶‰½_9¨¢¢ü”ÜB±Z÷n:µFÅè]Ñs ϵs#ý=ÄA¹}÷*÷þD+Æîá+ áU†¨,3?'Ƀö’ը䭬ªVÐÒ|ãù»óŽ;ÍËoÚ£ÌoRÁÂçóॠâõè¡3ŒŠ‡6ìÿ¦A–•WýÔÕšR–´U&•cÀ R LÊy|0Ò\L7ËÔ¯.dN–&×@Ìáñ”öèÈ2ëT¤ÿ6—©ŽcaÀ±kWµ fV=-4nÔÜý!ËϺU3±ˆŽxø4ŸþgšF¦ópc ÛýßÚùdEoRûþô½‚ÕËôJ'n‹ üÔô¯ ѽýC˪yíå>-;Ëü'9f‘¹c©PÔÄÀªX:oª2(>Êckèlí™9®&J»a¾UŠL(-ëM‡AѽnÃÖÉ`Éb5fªºó‡©>ÎÊsÜ”›àN‰IÍZu€Cû~jvô µL�¸²¡Ø;tωYî¡*Kôþº,ÛVuNW\ýi^+ÒË(¾­WÃ=FL^ùT ÚŒ”¦¡ øéÕÊ+ Ϙs5Ðâ³–oÅr‡ ™Ê ìϦ«‘Ó‘0­¶T IÀ;11gà*Õˆq®äð&$‹aI’-{G%­?ÚÏù¬½¯-yR*¹¤@¾5ršôéB´ÿ+š[œ¤]þq[zÒhhÐñá)ã}£LÞûð=wúõ™�…ôO*Ô§ i}ùO$Y²?)7XÈõ02„ÊS’]yZx<³„I@5“Ŷ÷@øü÷a×Ûnâ3Å«{XEèH‚ŸéªpÂO-Ó0CY‡3NIäí™ñ˜n|´rž[Uó'ónˆ  ^7tín5O^}ý5ÒöÌRí lË»¦@_ô¦@2°mðCûS‡`Qr²ºf­Ô“7©øz)¾écGß·ypÆï¸#LEon}}@/=Åd¼kLÇ2HëÎ R7õÅ@>ï‹:Üÿ¸Eè·²iáíãÊŠ#ÅÒz¦…l*ÔùB‘DXCîh=ï0“xŽ¥µ «‘¢¬¦ƒé‚ $'ýî±ÛtÃêBi!m7E‡]¿ÞIQBŸ| ÐêHL-cl¹Ðöºçñð „$Ý™Ä¢Ü ×#Ã1¢Ï[tZÎo;´Íèƒûb¨9FŠê‚·p2S—ŸwSÓQ¬y•b›z¥ mOYXLUˆ–Ī›Ütÿ¿ˆ@Y>y›œ¢©’ Î&]Ê9ßF·áËöºÀ)ã ìOÒµ‰*WFª\É SI7:…#=IÝ fžØ’Êov3;G*S ošJƒaï­Üa£ªâ]ƒúD»h‰×œgIüf¤¸á*›(Z’ Œ:¥Tkɧ±EÍÊÊ AS¤x=k"‚Á7僛±VâûDYCs ˜èh¥½Á„‘¦Ô5G1 ‹ö5=…&Êf­àîPÄÄèwàŒ4˜ T9c`èͦü7ÃÆ]ƒZ÷ P¡+ªM»ËÿÓ ƒ…ÚÑÎXPAÖ4`É~ö-&zîØa™"L ã÷VÃUÆêµ+<ûC×5ú_¬0ë8Òò# ÒõËØêû=FžBÏ ~¶D¤î\¹µûûõr$ú_•£cwA­ÞBÀpHØmiû<[ʇ„žö‚2½¢ùYDYD¡‘¯s¬+•,h‘¿èV+iËñ´ ꔄ³òYÞÝm û}±+ê ²¢oOê D²}˜1a}S%â<}ÿBó*Jâ…3º_ý ›OåÂQ¬8±•°¤GDk.g»Ú(àyW~, ½iz•ÕQMvšp Ù‰Ç¤»`nV®g-ˆâ~¢]Z6O† 9Œ*ôr{S,äÓómæʃ20ý…îJTö®°l¨ëqy$¹ES·&;ðá¬Ò`q·CÈôÌ%ö”œs/xBº;#`h³-í^R=5 ˜V/aÂjîÕ»eåá}q³'Öw›ë%9w_–OÅ#±eHGl?pøÐÇyÍàù!Ï(<î÷6÷ô�òóÖº)z.Œ˜uÙï¤äÂËT÷O”ú–„éˆe‹ 5CMCϳÂä¾Hfðÿ¦ï;6�œ4iäƒÊ­ uqƒB_ú—VîèÏ21³ÒÇ’Ò-›Ñv̶ìø)‘™g ‡üÑ:ÁNrc>PF±¥L¥ÖzÊôâ Q;%ìîÜPz°€%íÆÝ`´©½K_Õ‰ PkéË ¶m#¨Ð^ººß‹6_ò¦:ö—‡‚Ñ–Ô)…å%BÊó‹Œ ßšC­œæ_SðœJ¸ Ý6º¤ïµ• 0Ý*ðzÊëUÕ‰î‘ér\]:Ì©’Œ; fr”EÔv–xåÖ0ê­2uÝOìL¢¯×f EècNÁ˜¸TAÖXNIÆ0KÚ&0ð sˆ÷Ì—ZæyêᯰGòn‡¬ 7¨ŠÏ›á(Iýú²¼‡s’ÈbÝžö‘‡`ÈÄÝ€{Ç6¬µT6õ„Q¼ 0×{Y˜ðé®áƒ`*Cú[jž‹ PixÛ…ý]Eò1ŽOÕx«k€ÙTPUÑ)Îéùþ€âØjËÕ£œƒèP ‡S/žËñ³WHG;} }½©”\›æî8qZpýêÜA¢0÷÷(Ôp)wÊדÎ]+iïWã .¦Ú}õ:%›n I7äiÜ€J 1¿¨BFuÂcšŒécBgî“Eh5ŽlÎvÖÌð@n®™â»á^4§Û®¾Å%ÿOã…çýxD¡õ›Xó”} Gœ"[aXŠT#ž™õa2sªÏŒ·ý ÿ¼Ñ†ðtPÂã0°²î héË}]á¦Ýù… ½³<Ø©£6Œ¥‰:M§7ñK§sãƒÖ¶­úÜ£œ.Ïò˜ž(¯ø˜ó }Üú|èåïuLt›*u¹ÉWwGߪH¼‡•{Dg·øÖ>© ‡´Eúþ’eŸ’J)¼Ë%i µx;‰‡)@•µ½ lH¦í2pц,‹ø¶¼ÿÖ`û3úŽS4$>ÊÚ—´e’ùÛ2ni‡¡Q¢ÿ^„ˆl6ô4+J<)-9çiÏÄœ¦‚Uxh{ed˜ÜèWû%‰ _È‘ý±2zÀìšb$ž×=ºÃªø oU>û—·“ê( }–?7íšä¨ç~Ø~Øë™ÿ¼/Šc¿»_µ–¾$íÑ,·2Tux„¨¦Ûׇ©±ÕÍŒ¸¯™ç¶Ê÷µ¡RP°ìiUYÉ”ŒÁg^fJïÜwól_\(®Ý°f‹ÎP4ô‹Ó­®ü†>8}ÖÉS~ï¤SÔ½9ƒ-#Y’Ì}®ä»µ:àc° D}Zk¹€ãmg”ˆ„v{{x÷Òñ¬àR°æíÇ„ÅlÐéúÝŸú7ACšÁëòå¶)çN¬ 9}D¾ÊoCÇýŸNL1ƒíaß±è„ É‘lͼö5“¯eYyP\ÛJ52Åcg½D Í‹¤v2òx=[ e`ä¥@ ¯¶íãnà¨2+ýZCvxy•”W=Åí) òþâå£Çqw/ænÿ(ðç¹ -¤#ÕÛw7NF«‘¨<¼=†ª|ælPÚ —ŸÕ§¨5-méæìÐÜÜÔRî_h'I‘XO& [Èg‡B§ª~¶ N‘„hÐ\ VPùao"y½¦¢…~ó8y D%ýï ÕA]’_9ŽqÈyŒFäÛºãÚî5œªMC¢Âôºï¤ ÒO-_q§˜SãŽ1€nº· å, N‰oÖŒÄv)Öé«R Î¥åûÅEÖ±î|÷³m}æúçÂ2Î|„záG:çÚé­s5}ÞŠËÿK•åÈ“C:W³ÅYúÇãÚàÅ$dz‹˜i®f[Ü5vë±Ó E¢Ô»¯\ûZ…©«§¹¢¾ñ¦û¬ °=ͳ¤˜ëþ£»î9Û?÷_&,ÿK…÷-®1N½Á0wñ‡"(ê‹É#ëÑ ¬½H Ÿ¨æ[kH58v%žÏ^°tx@i©k:®ŽÐ9¶^šf¬~5tM«Ô)¢e|0Ž˜?«Nbrnsy8÷ât£Šü š–Áli•v+¶p}œVó[ñ–Yô)UÏɳ‰:d™"dÕARŒçÑSŠ4êvüYoäcþwžb–©Ž³Æ7ú“hÏþѱXXý~“¢ÿà�zëZitÎùmŠ¤Tù‘åÄâ7l" ѲhN;yÔï>OÐ6 «üµ¬A쉢ʸ«ª zÿvªô´78ô$IÅXEº>P¸¢°û$ò„ꂌΆÁˆþðYÈÐy„HÌöpdõoQè˜o} "L‚Sïý#°uZ¿«ŒKìz¿N¥ÎÁ&(­à^eš�bÿbUñ+Pvµõ&zâò’úd}Êà¦ÄŒ×J³[QT<õõ¼ÀñÀfzöW®Yu °‰<—˜ ö 'Ï 9•"@÷;®–`)„eù#â7w ‚0 *mlcœNœwži;ÿp@Cͼ܅4FÞȧ`Ãö>·öÓ¦Ø;³ÂÛ–ÞWÔ.Lö³ÒW¬D#qç€ ­ó¨W(U\‰d˜;Cã2o¯4®¾—`‚\U‚óºbÙA;âæn4g,VÁ#5Æ|hbÒù:wkú‡ùÚBäLÊEQö# ÊÉj¶ÀÀ¦÷Þ¯»ïZpRff4Ç‘Öz£ ÛÒTKìl¨ç•±ÞkòWÉÜøÊ>Ûè¢b‚Â*È)“)†3Ö8Ûbûx81Yþ‹~ÌN^8+péª&µöˆ�Z=£j•:ÃfWîÿB‰dho¿½‘¿S¹ð(5œ24ª£QåatO¶ÒQ1½^f/þجŽR'ï#ˆ–¾«háë]‡¶$àf/QŒ¢l}Ët¯gü¢Š±CéðßÁ½|ȉö£g$ @w7Ýä)™áý„ç‹Œ=Ó4eLÊi >óÞ Ë¡èZé™à>ÎZn¿î³Sº?€«5åèådÞÊ€m%ÇØPd«WT(N0Å=ì¡m)v_ä´”ÝÝû:[ ð%…ƒì]Ñï¢î ¥–‰Gâ1 °Ý÷1**_û§ƒY®ßMîGâ·Û‹ëª,jÞƒ½Í;è>bË÷w,ïM™{Ü\xëÄüÄ`;‡÷(Ž[ø6Љ¤ <§f'V¨¬0m€&.ƒ°9YmùÄè¹°%>¶Lw{±v‹=t[Á…-ÚEoaÙÌ“§ÿŠV‘Ð ±Õ©¢Œi–ßØ c ⹌G ]ËÁÌB5sXr™^T#ò"¯H26-䈆ÚÖÚ˜õf=˜Ë+éá3ÏÐ7óûÚ™V±™ñ–|Kà"|8Ó»^Ì·w"J^ƒí0öµ"99àí¬´h© ±]ewiÑÚÙb×Ñ1tnc_F†A8š}Lúòg›×놠ë=VøG†äóÛ†ot¹Ø_Ö£(ýˆ‹©<XÛ'Ít(CmKOã+å(¢´b[°XÊõúwž1g¨çó°¡�›uÚM“Qæã:Š×å È•0 ¦ªÈpb^²cVkÚÀ: œ“*–·Q™Ât oG–:¸/¢:žƒÆÊ5Ï|¦ª¨ ”A9žÜšª4ïæGºÀ¾ÒEàu†R¯GiŠ}tnó ô•¬+ƒn“ñbn¬N"¢Õ›ÉqR:±0áSÙjÕI’`'‰u5‚zˆg q&nôij¬öFËË¿þç­ŠMß$˜Nû½ÉR­nänèD‚µóÏ‘…1Þb`šˆÙTX‹¹ ¿¶×È"÷+f¹m`&:{¶®« N)-<¶§ÕÇ€´èEª}è¨mø¿TiÒ~íÁYš®Ã¯Zj,¸¨î#¸"‹S8\Pˆxÿô4˜�ü¸à¯)ã= ÝÙ½%àEúƒ½I¬ÐŠsnaÆ ú^�t¯7®Ã+’J·A”üÍíL4Ô¹õ†Ž×q¨Z­I{l  Ûc_ þåkEC‡™u ⥪ÓÚ²27¥ô«ß )¥*ÜoF—¹QÝ=sd?·‚—wZzÚ¥8AQn1’‘i’ú××Oð8/ܬ2Á'f¯98éY©�7V#4âÅhú—9džRÓÂegÉç§çñèÔŒÁ¹ÖÞ¾ZÌ_èXð¨‚ó*nèY[#l4é´Ñ4©Ž¬¡]ØAŠ¹åâÅs;€ T hQî}{Z"4Ýîj¶5ïË¿å<<û#"ÿ,ÌhZÈØ8?zÜlhÅVÜr¸43]+lPÖŒ”x4gõBuo'b6">îŽî#þí%¥äTû˜@Ø[µb êóN@•òò—”¾à & ë4 ’öäÙ©b7—D{ã:E‰å7/WF'š×j N¼boœ„ íÃKXož£°Œ'Åÿ‚T+Î\R¤ôÛέóƒà‹0ewý�ͳ%ˆðùÓâ]eýÜY+Áw_;Y{J~êQÁøþõ½2óÃÔ>P”4µu’n[î ©¡z¼�¶gÕL·Ë\[ɘÍöíØÕÞÕRjʯ ùww´6Ò©÷dƒëS3*•÷Ú¿OZ¼¦ùw{Ò'WæVÝ7å‡Ý»Ì¡øØÜS•…(¯æ”ª:Î;]Ä)|_Œ Šª¿L‹(”ªn ¶´CÖƒ¶&²@ÜÌÐa>Ôýô<wS[Á§PJØ÷¬p¡ :$6”û·;Êys‡Ã¶‰ ’ó*rñÍ2vf,í}„a­UJ¥Kó~Ø¢‡«[l<lÄŠ¢{â*«[µ­rn_tç6§“>{=«O¼“ÍÞ±~÷X“}7K£ä‰"óSTD–; Ó£ö d_{ËÈTÆ¡Ðħò7˜Èpa—±ïBþÙ¹,vN¾œ¨Òšô´Uš'áà¼ëͤÖ]as*ò^ëÜŽûo[:)ý#÷•n4ç:EæWŒ’^È/ïÂ),Þé…xcÖÞü16Wîèÿü¿YZÏ Þj®Ë úÔ?±Ãñèá¬äÃÙ¹YG!íÇú ¡¤¿’á*Ï$^B¹ ¸!Káup},Tr¦ŸÄGËÒM+chýõ”z’yvëtN}ß­\ÜWh0†ÚXÏ û>  å!÷ýK'¦(rW˜Ž®9 lÄ[á—8 „ÿ`K½#¬­ÞÇÌ(ŒÆÉŒ¢ÓÊ1bÅt‡)Ø0\ö]ëÑž“ÜÐÒ" ýI”8VÄ…­U–@tyA+$Nõ$W5*–dÇ<ÞF3ø»NrîzÕ>Œc=8cêÎÆ‚Q÷nNäVÛCብ¡äþÚY0Ím!'mXèᦕČpÒ")3n'û!\çŒÃ=PëfÄšxô¿÷ GzWÂШŒÍ¤6zžÆ"àËβ.mR‡}50Ï"÷§­Ð2áóaJ(³aý‡¹YgF£g–&øìï¾»¤þ<ñ8…ì¡ÚÖОÄÄ4ï¸ÐÞ"«Ó‘îç÷ÝÌ> ËÌ«Ó0&�š´.¦¬Æ:/àè7oP]¹f#€R¦�}íV@èæ*>U•x¡s£åa&£tþzXuµþJI mÙzï;8Ø{¹*cêV{zqóÇEéCýá—›†0’„rgË”ûAa4JÃ¥×ìjtøµ®§CDf^šÛlÆz·=ƒÒË‘’àöåz%±–Å¥BS ¤Ç>(®UÝðaæ?ѹn-ï—Ðpj5mžJHùö™­¤ä¡˜ÍåMùó*”ûÝ´laüà[œx›½SWkz£ÔÎ9*I ©b¹¸ã ìªË/u‡3Þ”Þ"ÓN´B/C¡ñh¥ßÈ“'|]wƒ¨ ×{©Wl¬ 3_Í8Á*£ 1(î4‚âÒ©Ç ã2 ÁHйËÛÁAd´O߉×Â|cß]мWIYñ£f_)Îb—/Žhât®Ørõ•Õúä‰Q­w£Áƒ¾àÈTäþ> ù©‚¨W«§"EþÂI2³Næê^FL¥Ê7ÉÝÔ8\JÑÌŸ)‹¹8-Ba¼i u¤]%PÛÃØPt7/"kè›Øó 2½Å7Ãw¦þÚõÿôÓØAÙd•À ‘Þ­•I\ÁûaÚžj›òR‰¼g©Ãçö\˜ðTŽ,@•vGA¸VÀè¾>ö, ¿8²žÒ«z •àœ­J "Qp2T®âÉ ñlúoXË$S¨Ð­‘2OÓK?qMä,]Tó9Üz‹ ï•Ÿ¥¶ å~å,*~¾-›ußÜ»Âó1eÔ?;Ȇ³Ö;TµÂe¤³Ñ9´ŠVí![ØÓ8Ô¹ð6†[gïY|šFã#:“K!¼î‡;[Á+€ª¶‰öÕ¸õúЙ`ß“€CŠ–‹o~ÆìÙQª­ç5+dwžÿ¤%ÆN5¥lý}»Ý /žï¤µŒj¶¨˜§ÙCœ×8µ2º„ýZNˆ™ÿ¤Ý‘ÊÑy^ˆñô¢Laþ¤Ç4ºÄ Åxä2¦É +5Šâ 99t“Pø¬¦Ì|“ 0Ú-½ÿeT5E š(ÎiHa-áî‹oæË«Y\NÛ«­]©Ã¦™ƒM§}7oÅðÀ]=êÑZ朤”ª‚êôî¼_d~‹VÕÝ‘*]ùÊŠ1‘®¢ÒŽé_R£ 5ûTî¡>î,ߢ†ƒGß ;3 -ñŽB•ª´˜¹Æ õéK4w©ÞñøÊôØõ§…ö3×ÈíF·Ë;ä_2xTtÜG·Ä¥ˆ‚Xeò›:ŒÙ½!gš;:ž£'W!U!ÿ2€E¢©Õ±W`=ÕÇg͸è%Ž-Ë ÁIX×®Fº †¢I�~-Žg m΃øSé›‘È ÎL£HÝH\ì ¢ +ƒ¤U±Àh£xSô›YmÿZ€ç¡p\:˜¬@*DZ »xedhÉþ7Q,õ!Îv N"B˜” û<k÷öÇÊ>IðZ&�Ó –Mx)ߢ 9àÞÕSÂ@áu¿˜¡ÛÀA ®lCÌ{šYÛ n?:a´ìÃÿ*‹RŸc€Ã¦¡%<Už/P€É=­Ыה\ªp¡“ÍD+¼ìŽ.îñ¼ž™/öIq[€Ù:_•?ÆþWßYº0S SÿYû`•øa —ÌÚ.¾úÛÓYÆXl“;ï޹ȈÝI! ×mŽ«vGæÔ3Q¨¤Ðìƒ~gçƒIÀµ*ä¬ÉçýQ±/.’E‹?BM·bkilÎÚIÛ*¥°Æ@U*¶¡½sá%‹,wŽ}ÍÁÜêa£ƒÂ:Ëš…úí÷âƒQž9X)”¦èO¡}j}ÑQ-¨ëù}펪þëWX”{û01: AÚN:*¸U¸o¸ùƒVð¼8×;€ bèátO<:õfŠÜ=rmÓn|Ó!Hy‹…‰1‡Ä´¢¼|¤­7Á»E3ÕÓèÆ;¥Ç,ót\Ødq{„ ÄF[nåø(g­œã›`±Âᾧ'Ùu†…Bƒ^º%cçµ/b±>¡D®rÞº{é&¯¥lPÒ¿ÚgAu´†\•Fo57>vè8Sp6õøˆs¢Zíqd'Ú!ɂƒù%lMÀŠànÉ@;–­¦À‹›w nŽ¾™KŘYÐЪJŽ³IEÓ¸*Q ÄÓ—éô Öäy¸pÛ YÚ(üÔÉqœ‹säF‰õžàÂ#I£èEêؘµøŠ 5!¨{pñδЕÍÐå¦Ei÷ºÅlZ¤qf¦Ä1xSÕ¬²OIÅ­)¤þÜÔe&Ø‹¿ž™ÏÙ ¯†Ðoï~< Ú*cõÄŒåÖòik¹ëv[3Ï¢õÇú<whXÓn{Ao-‰½ª…?f¾nýÉ‹|2›&ÿÿ¡n‹|V©46‡ }ÃVcZž7Æ ÎBµ®¬;2( OxÛ P$äk·%+r\rw¸=ê—Æ,óLc'sX1Œo[IÖ´l‡=¨ó(¯p&®¶i„VÑ·4ÄXþì(Kí¯^Ðܼr$Hq!lün™qÉd·5¶émÓ m|CƒÁ剫½üT5*2/rV¬+70{¬GÄH@…&ˆUl:Gr¼a;æEåa\Ø«¶yÙÚ^�½˜ßžS5`Ɨ㹨¾mYeZÁ 1ÿÔ44‹YowP°Å±þlŸ$¡¯¡/X¬tPH&ˆ1”;t_µùù« *?q°Ao*ÎÎ!JªÁ3/¦Aícá–çø m)™°OÙ‘ùÞj§A2n=íî3%Žo›z�Öóïüœë›’núV›ïÞ„ï4Øfˆ9`½.@pÖRÈ(Œ«T¡¿°&b»t óŒ°#¶ÌÔñw`«¨?]|–=œ†|gKFÉ’�†£² Âw=|rú”äZåë{³ròC.K.øƒ8†qÔÈb}FwÖOìöpù‹ã& 3ËW�«ZÊàrR$À¼g?c€k*þCE{º Ì–la�lÿYd¦¤ÒSs‰<逎€‚½«;R0Eêì:v9”A¶UUîÔ±¶Np%@¦Í¡…}j×Û¯w䞢¯!ØŒ6í^eI½<³ø-•Òà¡OPXoë«s_ϳØçÓ„ÝIx[†ØŽeÅJü–ü5‘Íro’Å’ùÕ²±¿&³Co‹†®w”Bý ˜õ¿f=Zµå¾¶LDáU\ÚcP´g†4\Òšâž6dG(2 D³µäxEq:öÙA…Q ù½õ4óX¡Ó2³W‡s³›_pp‘ €| ~mÄPTÉ7+4i›š\â—,„È7Åß�KŸt ï éDˆ’&ñÜÈR¤24Í¥´Ø /o³ÜìÊtíØQ’Ûírf‰Ö½ †›Ø9ã|�„´ F3”ÿù‡Ž«[Ë°¡ü#·È—Œ9MŽO‹9ŽÑèqW׉^DÇJ¼˜w rR¸Ñ:™ ÷]Ãf_ŸY èE¤8©Ê´Ðõ_Эâ:ˆ×SiØmS~Âç;Z^WM½‡IÅÔ…Ö®ø‚¤|T½†Diبs6>3Û e©¾£ÓÅ^,$‹¥Ó<Ÿ‰ôŒ]׆ßzW{L/ï0üé\,<#s>/pDN-Ô9ïn  ž‘ÑdÇ¿²HSG[±« ¸ÉƒÌ‚ñT/…ÁâÚ-ƒ2²Á4>´oIÒÆ=FÆ]É°q1 ÛüH•w ¶ÝþÈc Ÿërƒ5 —v®P±£/ÅélpßëŒ_؆£ïj„% ªòõ¹�oì™®£o¬¾è>¼ëÄtuê=ÙÁW†ûQUšÝ£+å8Bæ¤ò0!FƒÃäO¦VýŒxõºdÏá•6[7dAúnáÜ‹ßí¤Ñ#+P|ž–/w”—줜î0ÜÛZ}l¥¦ØòaÜPhÕäL#…>?¼×7æcÆÌÆkq3_µ¼*Bß kz›j«S9œàÄÙµµÚïÚ×}múb© œ(à¤=|Ó“šljŽTŠ "‡˜xÚ/VAí84öÖý@Iy=:•ñýiß\Ìz¢ç1‹1Tç;Ú±õÔ°×۔Ȥ”(‚>IXŠ×N£ÚîãCõ¢ï%ûpn_eÖïl/ö3!X”ýÅs@XÍ>Ã>x‹éÚ]¹nKËU ¶¼9pb™uÆC–?¡|Â=¾ö„nÏ€¿:^sžÓë>¯P¬ Ê6¥ŒIûŠh5Õex泫3ýõëB¿±Ê|ç ó9 ªw…Ó¤‰éòøzc&$ÚöâvË¥>€˜Õ<âñ÷¶ÌBS§ãšóœ×„e#›üò)H®gIt­ƒœj°•0ã3Qº}½2o®ìúó¤_x´@Ée'ÕÈf ÊÂaÞžë”_O@²¹ñÝKyë¤Xy"‰Q‚Ðn=o) Ú¿y†YͼŒšåµš^, LnBm'@~ÑÌ|¥I¦W3Щ<ì*Jåe31õÂZ¼8Ëõ(5°ÔCNsý·.À¹¦Ci.î¾ÂK»ÅQí�álaQc¯y©2t$Ì7×gü½ QQ8e8jƒÕšc~RQŸ<2âƒt㻇“7Á‰“¥þ0DXò o¬]xh6ÎR'\ þXözHëÖµ"*XF¹×eb!´õ;)XO H=˜Ä­:h0Æ3#_®½æqæòʦ ¦.ÖGœä{f+òTËTËîâÈn;“;þ5Í#ÃÅõh]�W«14©ý¯þ>Ô¤`úÀyÐüñðúÌ ÕšåŽ´(Ïa®¾s<HãBí¶ Êù¤“ŒqÐgt—XÆŒ §ÀªCPö™ŒIä••)/ øbYÅטMoFÝÄ�“=*þ-fœçÍõâÈ£/ðΟ>r¦°Øœy¼Ðþ¶²EèŠH;çUY§(*¬Ô¸ #JË öøˆT§¶ë?¤æÕ†H#œ©¿…ŒúqrÚU°¾AÙ}»©ÿ™JP(ê_ÆŽ\Tº+¸\Ýä S ¨”åS:‡€dÍevh™ß, Ø-M`b4oŒd³¦êoÜa2‘ÉôÖÚþE"UŸvƒg2ëêÒ—µê«ÔpS2Chß'‚¬H8ÓDAàT»eÑt|/^vÉ<„ëv6C$ïÚbj°ŠìÑÛ¿oID…… ðÀŽúžAµQ€“LÒšÁÇŒaá¸ö ¼µ ‘kÐ…hcö@ P6„BrpfUÒ—±5 +‘2oOhÔ½k£Ž¥FXŸÔ™…ÐØóo ìÔJl)Ľ.ªÑH ®wÐê0/¿Å®eÀ£'£Òi“¾*…’å„A~V©|é뾩z¹ôžƾîg–p=íÕ–Üîd*/™ŠüüúèªV¢+óXt˜Á óóÝ‘ø¹fDYÉtšhlèë#ŸáØCˆŠÁå{áQa*0‰aÖר°x>JÐ(uT¸’)èüÎ6Ÿ¦¬ï»oSÑÛÆ„.üXï ŸåPuÞ߶€ ”µº ¢e°E}6MÉ ÔÉÛÍeèëÝÄ$(,Öãá|™ÌW¯sÂÓO-ç5ôØΞ;^׳øú·B'?øXˆ0RÀ°iG”¦Ù´>Û¢Þ ‡~W m’':`¸aûb‡½ˆâlé`ÀN¯Åºuæ6f&îA P.—Ð,^“Ôâ:Ä?tðwj5¾¡â¥Xóup¶„fü³•â½ïpòšº>s_\šûªT`gÌ}Hl†ih ü‡O}øæEëi0¡FÊܾ»?ô&§¹iïŽ`*‘‹ÒyÑq! Öì:ð†çW»Y¶{»§ÿLJpï$ÊlèÛL[;Ì0ûbÊñ&ÜP`Ýî‚*™¡'* ¿Q‰T±N‚tRÍŒT˜zɧ›È“ØípýªZ¬uê¼ÎƒÈªÊä¥*EvŸØ»g„ß³ÝàéÉÀi¦ZK*¤žýΡŸ }ýÊ <ñè4wØ81êt<ÉYªäÂJJ¢x™H<K îv4´>ËoõÛ`3µ®…ô?N ò“-9ã=&ÕYçUDðýl’,“uo©¨ïuÎ|>0´t9¸/;y¦*9nÐ1~×á(øUu+¾@â>[÷«ÃL cBåCcÌhhûËo}€Qd„y6}FéÜ»5Á»ç+3/ÓÚ_€ƒñƒÖu4bG‰2ÌÌùcýNÂG¢G*zÁ@0öÐå<)žý¯ÏE³¹ŒÈ㯀ßLGàøy;`³6¼±àÈ 4ÑÙݼ{ÞNì+Ê»SšYª$ªØìz׊;ïnÇ!¥¶Š°jÏw¯›<¸÷aæÛXŸŸ²ÐÓÒ;c™ 8n~ë·0ÆÝ7Têé “Ðç®Ue#O;½mŒK [©mW4·<Ë|okTuh«”n‘.eÖe'më?]oz~¯WwyèkwS"Ø}çAñ©çC-UE uúÏE¬BXî™g[t[¤Â «/Ê—ªÓÖc½á¡Â Â)69µ¹^m%Ÿ‚ ®ÉŒ¦c­âØ×"ÙQú{–mc¦«™WÂr€ÀñüuÆœ8k/¦¡0’(ý^{�`q#r8nÑÇ0;×aˆ šÈ—E›ØÁ¶ðÀsúë(+ܶ¾¯6§¾V~ žÍYG÷a4óŠû—žÌ…¤†P#™Ê ú¶bÛhŠ°å÷ _t‚-cS«t�9²¬å{ņ>¢kN•‚¢$ÝãΞt¼òÁÿS|LY‘Yª]&lO”ÊN³Ê<3@>YõÿÙ@Åa¸p¤¥"nN­÷°o¯—ùÆKæwm¼\!T<‡AÞpˆ‹¬ `¹Ü`¨¯Cußiÿ$¾%»QµJ‚bÜxkrîö.'´"Ȩ<Í™gßq7&óðgTØmN%[Ì8=3î^t½Ê iÉbmJ6”:Î’Ì ³àÔPø¯g§v7ÒÇ•ÀoÈÖõE"(¾Ê¼÷®ªRì9Z;Ȝƛ­ß¯â©=R¨2¨Eœcbåñ¢Òi¶OC=EàE©ñžÀŸnöá'ª’ŽüÛ\þ¥ÜX8¢w~ö›D®X6Z"Z#Z±¥pª<z§ÝUÔÖÄ€è‡+#Ÿˆ_ ƒ Æ_8P|æ넬uVE«cØÂë§AZZG–Å?^:,\ã·¢ÿe©ƒ³‚à°‰ßÒO›…5÷ÝêSO¥¯1çjZŠ¯£Ž.ûTµÛ$H†ÎÁ?E©ÜfD¿§Ž³Ü3EÀ¨S̪¬Øhô1I°BiNkŒ<µ!)IH¹Nëîÿ/¯dñ°iOAÓÆßLZÇpš¬´�h5R£O§ù®‰L…~Í„tï ?Øöä£0×ë‡úd7Ð’S8RÒÇ‚ŒOÕ@£,K3÷Ä€ŒabÒ|zÐ\ZN—μ\ ¶ãÈs²ÅA =‡Öâ*Ü’Žæq†GÁX¹É`\Ó–nMoBßš›>h÷ ‰ öá„¢¯5v3þÀ€…|y1Ößj)tsNŽäkä‘Í£çH9* ½“'ŽqÆP¯9VZÀ·&÷4X€]oÆžw‚«ñx�éŒÒ¯ðÝÞ‰Œ©€8ÕÙÄD¿3sá+‡]K{2š¹Y°ÛPþÐécJ ©©ŽÃA¤id‰?Á¾Åa¶ &…Ò#îüFŸô¬ùmÝSÚô†Ñ"šŸCm§å/7ˆí I|ŒÍéW¥–%�/ †÷¥YÕ²,@F›ï8§:U뉀ÁÏ´Y¶¸lfüøUSuî$"~)\œTf#Š7‘äDÇ?΄­>¡º:êIÿa,çõˆÙ‘i ?${WKz5åòu‰ œÛýe¸' ¹…ææð®Œco¶Îd””–Cï¡ã¶2¾ÖX`f²¦u&ß=lEUd³.cTÀ^?Ÿkÿ¤ÝÉ ªAŒƒ$½ôIŪð\·f žTæR5³tÔI±Ë[móŒŽ çΠΪOýcíp&/þ¥À©•¨·ÊÐåtN7&>a —™®ÐyÏCûéGEÀÊ?ó_5å! ¶š¬Üxž"Mæкª äEØIáuc~ìrŠTýÆŠÓ3UÍNpŠnÌ»T ãÈ7äà;4ñ‰Ó¹¦sjÌ À¬Pþ¸œuÜêòÆþ¡˜2Œ�H¼ûpt:½Ö%û©³=è+MæÜeø2 =b°¿ŒÌy²oUõn=FŸ;¶¡7¤3j³›îéEÖŸ¢0Dª€Š <ªö­ʳ®^¥€à«Dí;~¸¬yÂÐG§„e°Ý ‘<yŽ1ˆ»ÝÛ×ÉÓwG mŸ‹,ó![Œ8£“³Ñ{¬÷x8öH˜váœÙUëÛ5½2ãu!ÕŬCº¡6Ëz¿6xh$¡…³Ì$èCÇŠ²Í±•ÐïyÂI+çžïUé*)I{4ý>­x3ƒ¸í‚ a�6/\Ûa@•ùºQdîuku·ò´†ÁÓ^°&Šqù קé­ë¶Ï7éŽLkYj>-®�D’ß~Ò+ÞI¸0/Ø4>œþx„,LxŽ âóaß°@Ê+Æñ¹Ç y.6Bÿv\{ãx£ÝdºZ†*ï.Î:<Ùø0^±B’ìJèeµˆ ¢Côý+&‹*mÀÛ Ä¿åšežå°‡ŠA󱕚†Ã¹áŽ¢½)ÖÄjùâYZå~A†ÖDÑúƒêv7Ô{:⎣ë7²ï^^Õß+uV({FrÄø}ë9ú(çn©"fp¢ý#Ød÷Ib²”šaÕ“©å—ë\Nz€¼¬ñظîæ,Hë£S=ï,¡˜Žf4`—¾ÝÍF¥sUÿŽ›h*~YøÒ[¡éη¶å¿Â ½7|ÈõÚ“N}ž.ü£c”>A2ž|…p ~ú™Jw\y7—IÀç/Ê: Øy|%ë„})%ÚùÐqîpô|ž#ò²¬òðØIç2ˆ6½REè—­i™lY{H¤í9ž8P¾úFÆ¥î}$+}©�(¸èÎXÖj üÄ öëËw?qÙê}e ð4óE:hi×g¯÷»‰|’µm H9¥¦yúºDüg¾¡*:3­¹¸ór(?þ‰I´îèoLm÷õ Ík Ê·H+Ê¿o5Ã"iíh?‡úÃÐ~F>Òõ•b;¨º¦C_7’ÂÊ¡‡ðÅÉs7uOIŸCµÑÓy‘)^–®ïávÏë”Öó炳±ú8¨’…2ÄÜ ¼I_¯å׊ÄbãD|v»¡¿µmmoýíß·È„§„U'g™ÍK/¿y–é$ ó‹#ƒ‚o úÜÖw—òN‘‰4¬ä '±Ñíª²§Õ,WËGýÏo„u@É7Å×Üz¹gêWêÖßd±—ܳkð0TA>­=¹Yðâg†kÀ4r-üÿ–¤Hô8”\OYæiãñ[h) RWÿšÔ—þŸ@‘«i�eëêÔ¤ìšh £k}£+4|îÚ@ˆQ‘XC哯ұ?\&ËǸ2Yx,‘8v·tmp8?Õµ08n¼Ü>Ïv‘¥½ ¹—Mi11in”!=¾ˆîŠ8�ììî]úÉ„W…NÙ60ŽÙ°µÂÿ5ªWÊA^Å7òIn‰#”°BšŸÖŒ‰`ݶ»IÏš×�¤n^WŒóš>Ý·º<•è]£º’vøkX¨"qí{n´4S¤ãoÿA6bò˜ ¿H;,[:5<¥ÇÆC­ð»»îŠ5¿~Ý¿¨ˆBχ:‘NóÔ špóµãIÔ¶¦ÓÆpö;ËdÄGt4ã…UL"NžþÿRÛÃ=´ìµÉõ½+'üZeváå,?1äAµi½YõÇîHŸÕÄ&ƒN|oI(,‹Äó¡Ï*ÈNßf«ë÷ÜÈ0ï?fLÝÌ‹4N6‹Ê'Âñ9 i\,¢»±vZeµtôõf“z.“Ň …‡lÝy’\*e¥ÁBNHÍÚ®å=éh­%©Þ$ÀráÛÁZÀ`]·õ°Ô ÿKýð<r¨§6+®Çc§ò—øßvN‘f™ã›rré ýFk=ñ€¤Æ6¯¦¼#™¶®r–ˆÁÄKÁ²é·Ë‹G^ 7ÂëMUÅ·S„K‘¥Ï+ƒü?�ŸÇh—±£�H?w7Û#v¥—¡=5008õš Â-´C'TL§WÐW¯K¤Ôó­gy:ø2¶S“ì\SeUò²@p;WBËÏÂ"ó¥.èÃOuŠ¶è·Û.Ì:á‘œvŸzz ×ÌŪ£›´Ûì0zq—¬Í’ùb‰À2£a2ù*C™úS×8(ךV ÃX´$Ð3ó…4˼–CÌÂ>èŽ*ò±]ÿaI¦Vl–¯ô|<iBa+Ð&JÛ•cªõ¸;ÐÚ3Js¾ª/'–—úÅê:I—†§l"KÑö¤£)tÇñ ؤ®i×@;:!†ãºu†YmmXÔ÷lž «¦‡5Fu|Q‰U0TmÙÍa踜ŸáæÉ=zq]椕}µ?P¼wÚe/6î”AÒ!<ðöïǽY‘ùÂlS’aý}Oúšx�Ç<7MÜ2ÿ¹™]zŒÉB€HeÛ)ȨlAì°óòó®h[/­9~‰Ü\Ï[¡3AwÝv”Áh.¾F\dxåøì;Å}ÚpM§Inʱç´Ý ‚ößAXI¾ÞÍp“j"3‹4(­ç&¶G¿Ûw8yÄ1—BÓ= ûñ¡ Æ23'K³yæÓ¢¥»T®X7e¤F±Â”´hβüKJÊ륾…ç¯ÇÄx§>œêm:e,aæËõ‘ç[ΞŠ–ærÇnÆ¢GŒ3ÝidvvÍ*cV3ÒÀí¤uû QIKÿYë:R{Öúßx Âþ‚ „i± äÉÞÝUçÆ®%Rû¤d׹ؾ#<w¶ÂÀ3ãé¶nOý• ØSêS”§>a¨» Ä·No“û,TÕZŠžô[=Rªç_ë¤Óª‰,„E,JŸ&) ¶u¤­M¢À7cÁŸÞ^߃ê&Î%– ¶ýlzŒ²}c£‰t2ÝpG¤¶W2[6„jÓê) ‚i ä´ƒ¼¥â»öDfYûbžÞ`µ¢˜ þ ч'îKÝþDî 0ìhtžå5ûzÂ&|WŠ ·Uji0Òû‰öÞBÉ%g°9%”Ë GoˆÍ@ùà(嫤¬¶^`C£Ì‡çÁ0ÒñŸ Ÿž9çX_qwºÐúœ¡~ dAÛ‰"mƒÕÇ•ÖJœ%WRjpà,êµg),«÷d”Ïdèòß|8ã|É’Lh[ÓÁüyqdƒXšªÄTÖ>ÛÍòçÔ;L:wë“lL :’ {Wn>û¸Ñª0Ð_?ø?9ÔQR }£Ð6ÿñô ( dú“làŸhI÷Älc·Ìjȇo@Õ?Ïn&°: g7ˆy}àý›èXڈʞK+%;užþ—ÈBHZb‚ƒQŠ˜ëVf`?ÁYÓÜ“Æt—Ž1€ß6ž‘.…«r¸‹uÍ™˜,ͱßq‚e™÷h¡ÿ/ ±p˜5»N¸¹´1÷gÍ ëù9V,*+÷±EMlJ2:}m;hž2šÍÍU¹ó•¿¥^eêÀyÍ¡ÚëFÇÃtìV³×›dCÿò± KåŸù,w!=¹ÏÞ›¨"kAlàP!ãÅìÎÅ*;n¹ÍÍ–Þr\è¯Õ_þy£Š"ht~Qö²}î:²¸6e°ˆÏÖˆ¦åàùzá´òåR~tNN¹-,'d„û²m« ²*g1ò̳²·‡~¿Þ!ëwWï¸ãó‹ˆ/Œ“K ‚g×–ZÕÐní/>ù°9tÀÓwãÅÆÅ¿ôDÄÙŠ²Mtáãzruj`€—eÂü¢Ÿ™ç·&Ì)gÛ^…|Éa®^K¼ß3$ªÐWÌ…êL)O»ö ÇËLð& ôž«­é§,GAQš-„0˜×U[g!Êî¨Y†´¼9I¶©ÛQlØ”py?—ºJ›a²=ÇAé4 1ºŸ88žÄ[õŒVà¨{fi*ý/ñœKå´Y`ùý ìw±½™«Èû © Z8½S|ì1_y?:~ºótƒñq0ŽÞ¥ ”ß“ŽJÊ(’ž§·b»7gAf¤…Û ]?97¯Ç“ëH»Vj5†xlµÕNzŒ%‰–"ÏÕPâ‚H£ˆ×¿TZ6Caöm{¡ÇÜ®§ÆÃÑXÿðy¸|¹á&¦^£Ç9(1U|[ÛWžt{Ò¤Õ.}{ñ9&Ïœ¸¢ Í‹Š–S뉔Lõ7íÒZo{›qú|0Ó¤úhÐif0c Å$è$¨Âó‹ Ï´´MWì„g.;aX6. fìmÂý~ áXû±ùü=虃)¥ìe¿A~~Eœ:Kø‰1Ä£÷;*ú.âÑLkA°ð¿û<9<k‡Åj:ÍØÃ0 ç÷ÁíQŽ-žýÚ‹2Ξû«0ŠXŽñ¨àžœCÇm$\; ß•bôí"xb ,}6~;èïÞd"Ý‘B 8ÄnŽ¶…ÚqÈ}Ñ>C_}#EpÀ%»Šï<rê{Âü. ¿GùÝá›nL1Ö^뀕Ï5@ -ÊC”ƒníÇÊꎂš,åYpO·¥?Yú ’ö^$“˜²¸ËÈ)ÏšLiy¶›pû?k7Dx…M#¢<m»µ™Ã¸«[˜mæ5ôƤÅÝäÝÊ6 Ü2`žÒîÌ ÒȶY¤Y‰d1©µµ¼®ÅÜqÒ”½ýûV`ozõñ+ã2{t „ükcÑBŠŽ a(dÇY¼ V°øýåu¶lRľXwŒz‡ÎÁòr2ívö>(5Æ]k†H×õŽìCvOê›ór¯ V!ˆ˜c±µË­Ó¥•Æ}‰ÎÈ«Eš± ö”‰T­:±Æ_Š="1ÖbC÷’`…Kûš=bFlý°ƒ¿=‹?ßñTPY8g4Mæ‹hìÇœÓÐìs­íæò[–©‰½C=bV°¥qOQíÀµ–ßyèãòR3UïzNóþ¥4tÖæ%ç–êV¹¤J<"7Y0~(•L<;TQkÃ8ˆE±mžuÕýÀ#¡ë×[(þÒ<æÙY·½§ÚlZ–ŒºlO£dÈçºÝës.ÝpEó‰ _ŸÎ§yŒ`õ&JÒðFŸ~Â>zïÔÑGäçaœ ãc7ü©a¼r¤ôBÇV-ã¤,*3_`ÅÜáŒv9Q‰•j©Zòh“áÀ>_Þ‘²lå4ÑÙšÚéX}¬ƒSKzBå©"ŸÎ‰éÎ@O*šO~GîĪkëS]?‰ê§¹xpsÓÄçéBuµ¦OX¿{J¶ìòqž‚44ËÈoL:X}%y6Z'§ÕŽ’΄+­2Ës¦í0§~$Xä%§>.B?ˆ@4¤TUX-}h6Ëüûá0ÿSžU……T1ί“ mµÚÊb#@öÑ¢ÚÜ÷t§/ùù´¾vs,&4ä€ùƒ¸µ‡ÐnÜr—Ý'ODîçAÐúï„%|Ý”’–fJ÷ßÎÞ¶‡cçœÑЂ­-ÿ¸ æ¶;ŠA%ÞŠíî¸0¾,^8âÎÅ°¡»”Zä@,²žŠ¬ø…J»ÙîNPj‡5ݤâ¨Õz¥bç¢à©S(ñ²ÿÁÒÞ‚ÃqX_R"‰ßb=½žö}Ǩ»çW>Ù®4Å.£Uªfãf&�R5­¿�mœæò¶Þî`RžâT²Â·R`¢’±wÛ:Iد[soaÄŠmÂÊ´lX{á‚-m-<cwks]±ÝL 0œ2Nü‡ –ˆÂñÝ&þ-¼˜G¾ì±CGÑ Š@†‰L7:Âm²Ï [ÜýÅÏ•­1Sã÷j#uPU®e}–atí™Üfû¦àÙ^l˼7lÍ(v:6@hüqÒ£ }^¸f7ØWùžƒŠ’Òá 3.;à™Ö½¦Ÿ@Q™ÿÆ<­úí&¯ð¯¹Í¡:„·<6Wð uzû£6¯sÆëÂÅÈöòú{¬gï ª CçëpQ楉˜yC-=±„l°üŒ² Ç|Ú^úákËBæ’ãJŒùF›9ñ°_<ÕZí“ ›|CÖºióÄž/¹Á™/êHZx°ó¤z/³uïÒÊ”X;_¶¥FCÙtú®}kz”Œ{äbªfYíƒJMì¼9 «ñlBWÿìR.ÓÐ;ÒzH-˜Ka¨ms\½½¯_íÒh ¤b¥ Zd-rYTØ¢Ž»IÁ1/zj8î_f$çÛ ´$̸ku8HÏ{%§´›ŸbIáŒôŒ[ìÇùÆËT1Ôð0ë/Ù³x¾ ÂsÝ£Ù©á^XíiÃ*óf7{%ÜýËû¦ryf·YÉ 7[ õÙVÄ€í±Í èd´h£dƒW¯ËåÇÆ Å‰_XNêjÈÊtð25u+c2o ¸LìÑQNñ!kmaÏ4Ô¾÷”$ÿΊ,O2§‹®m ¦öIÙ ªÊ(†™nO{ZÈLÒÙxÖàÆwÆÿ2vón&ºÏ´f«qX0²&¥¦ D{…ûmL€÷ÝB§HS1åÛ#v?EQCÒAœ!dØëÜ€¢ÍùÂðå7úz‹S)òÌŸG‹³ç1NøÂLþ/Öiì{À…y°Û ¾îm À`¢EжëƒJÎ\Üw>ÕŠB»( ¯/ewj"ïÊ7AW˜l9ôþÁ"2/Üçã¹?ë ÕCËú%Ë}¼*Æ! ï.&›¿Á;òiƒ¸ŸX³Å|¾6Ÿ*Q”[+@ì‘CdµNëbhÒ)»ÙúY½Jz i¸{i=1†µgcF¯è©¨D†—}êÃ~þ#ªsK72‘ÈGÕiÃÉÞ9CäSÔl‚dùÙuˆ?·??E¡j0W—.beiè{?â:—AõiÏë$b*“i ]+êãùfÝ“ƒ 3ADÁæDÛë;²ˆM€zÄiWD†š¨tȉÌ/®R+T亰6í`ÏK]$ÊM€láúz¬ôì[íÛó“몓›ÞAigONÖÀÖßê“Áå<WÊ#_ý›sZ\A”ŠŒ>Öý¾ÛµMbI}’Ê×2 ÜŸu)‡OOȱ»ÎªIãKR>T¦´‡Fi�ƒì"‘¬ÏˆI _WRüÚ.ÂBíãÈŒBV3ýžÔõ9##T¦ÐÜ‹1λg”- ã`;ÒI·=yp®z´ýƒvן/2üN‰ÿÝ¢Xè–ƒ6ÕÏ‹ ¢:eg)”ØmjÚ+j®ñk]….ÛJžÞú4wßôèi±È§Ï­¤ ®ÿ]=ÆNIJs^Áx=:~z=*ZüSK©¥icÿlàá@¥D ƒ#-ÑhÛXO^n*oÏTôØ›>‘µÁ{øU&µ eÌû¦<¨úÖûðŽÐ‚×ßõýi"¼î;µ¢1§ÆiØa[#®R¸†H¦Ç°æë·ÝОèïÜÕý[‡†_PpÒ !}±¥ì”ªÓØÖ7¦lÕÆÂÊàú˜}6f³=6 ›'&YY˜¥Ô¤vÔ‹¬—N5TcD<yØbš’3 6?ÿÀ—£bËêˆWô©mþÏÊV�G+sÊ»g ×ГQd„¡c…¯g Sä”Oþ@na³ùëFK¦ÙV±ýB—å¬W¡T#:ÄòÑm Ùúó§¢,ºjvPÉ[EcÛI`§ 5ó9L?2š¢H-ÄSõCçÎtkjA±ÑÏÅ‹1²2ñ Gxaè^ ‘gÌ?aôÛmÝø¹_Smaè‰û&Ðî;5” 68SP§‰Kü r§Ý8ÜCƼX5§9 BKŠY›Y`ÿ¢§¢úÞÕ¿¬‘þ/…—;ò‘'jÁùÎM‚b}1"ð’X˜XÞw°ó?£èqD …‡“• sf“þéÞ|‡(õ7íéLDzõÒ`ÜR¡œÒöIog3BŠÝÞEJ†¿°ó.'1nà 9•ŸkOãÏíú¶ë¸Ö¡_ÅÏli•ú\ôÏ!I"®ª`ÜÃ*ªóà*—þË º‡=G}¥ ‡G!­z#ÕûMäÉ*¿B•Iy$½Nú£¢6W+ž ùêÆɺ#• †Ì"ƒ {¾Ÿ¼^õ±¯§7(´m¸#Ã…—ekaÝk(ÍËmð. X^§lœ]M,°htPÊ©:lÑ&ZJ­?ÉŠ…~jŽÁXT[+Ðy%umîö ¨p†öº«‡0;ÉŠedZ E/ýl½‘èô[ãK:´W=uþÂ=!ªœŽÚ€ô;)®$¥˜¾}½50”§5‚:-ô\1¥1(ÑؘË3yÊ7IÒÌWTÇœ€Lh6nÁ:™[‹ =žé÷G»˜xäç/:ñPX\±KèW�Þv%×rõÝuŸ0-Ë<³|"LtèdÖÓwC4òJ)ióÂ6(¤î…#ÊJ<Ïí}#—sÛw:Òßp´ÜCäܼRqV)º­–å…tEÝQ½«7 }–:ÛÐ/©ZlÁÓ0 ô¸Þµý�Œ`9‡@!ßݪÁùb¼fTrŽ‚ìÒ:Ùæ)¨½5ª (rœ»¬«¢Ä{Ò2RF¶ní€ ðÔiMöN'÷q’^¦WŒçyˆõë\jƒÊ…75ÿñ\@ðŸ¬~çöU‰BêA&¹r(¸¥I]K홧ž!1†)÷�Žœ<¤Þt>bé¡ü–•gF!˜->û|ñJHýFUÚ¸[+˜>vG3ÈÁyrg¾WºÖy øŠÝÌteCßFhWLÈ—)õCü^EßyQYx|RŠ<ÇØ}sËìêåÔ0H"ª­jø:¸êQ[fô0ªÓVWsçiNøÀ3÷ÆSkßö¸¯wdn4n¼¨¸°S“ÅÖNcÊ„õÓì^<Rfÿe<1»Áˆ ¹jCBÔY¸'¾ë¬;Nj¶2"À ÛέP¿`PÎèßQrÃG|åB‡µ .‡2H‡‹7–£íÒwµÙñS×7—Å×{ŠB±›Œ1qp5ÃiTºH^kq¡½-¯º_vJlÁ!ƒÏÓ.ôØÖjjOpz:*†}Ý vÖµ›¸}²9Ë{æ•ï­ÍP>J/ 8ïAzjõ”nNß<6•®“Ž]ý±Tf³¥+!H¸?Vü©âni¤„w:üÇNÕÒëqt±£ þ/ » ú‹þ˜Þ4’\ã1¬|naÌ™Ì3p|ÐKµÿq7¥‹óܧÌÇyÐQ8>*$»¯[·Y÷Uƒ H!àófªP/ÚÆ:Œ¯ùž<w™ùjÉ…Qot9{ÞËáI­¾ ¿péÍr_ö‡~˦Ï(ö'° Å'Rf$´\Þá^ežßÏVç,(»³gKÞ…‘š¬‡™[è²èGŒÚÿtŽª¿KM�ÌBÍŸ['ÔÜ#°}PiÂ!|†ütÛ2/Æ1oÕÄ�Ôž½*˜úÎô`[OˆiÆØò—|+÷“˜VñÐQH²VC… ÎÐNÔSr¦ÿ–m!î\Ý�B*﯑ú„õlŽû‚ERû~§ ûßà5ÊÜ—¤Œ“=“ËÓÙÒ[!' ðdÖä9'äš/—£¾·E¡³´ôóÛÓD.zŒ ÜëÄìÿ™‘ÙÍîÌТbÁŒ‚ Ää3£ ÀÞHçû\pOßðS§¿æÑ÷èX›û%ež,ù©ã3 ê†Ä Ø÷u Íj•#£@éx€°ëIPбƎ‡ý°ŸK¼ Çy’®­wɾ‚îî§ \¿èí k…°µeî–Á‹"‹˜€òþBk2 =aË %Ìæš—Mk ‚3SN·g¦ˆæ8aœ¦ÊÄ$g`!‰—¢Ó%N±4clZIýM¿¨UF¯= b‹gŒ¥÷†Ý`L ~rÏJìdB«¤s ýÖÕ‘R«ƒ“ÌYe½³ c~«zìÛW‹å{«49úöÉÏü¶¯6U_i´fžw »õÐ[ž=ÆÚ6£Ëþ…&`šz¼»J¼¨)¡hUÃ(gcªAêñ2 ›]L°%™Í»üî®Ó°(”9aMN™Ù"ëÏž¦ñÑèlÅ$œùÄ — ÞÊŒÜÁ×)M™³¼ÔÏ Bç0Ú|òMôàÇ‘‡®L7Î×±åã$Ìsö8YÃiøQ’ѧ 1ˇ5çr‹ .E¾ØÙmoªB¨Èoò“î\ê Üű»£/á¬Qll×{SÈvŒ¹ûUd‡‹x•5še2âÛûakÍ5žCÞ²<[T$*’,¨êwO½ø¾IÛúîõb$)Ã…_GIy-`ŽÖø«÷ÓþèlÜE;BÚD>eçŸ7ÿ_xËJÒûÊÿ&2…¤ ‘rìkH¹ÆŽÅq5þ¦nbõˆ¶>c§A9Ä©º“!R® "p§ Y¬,.zµ“³ßõ3=kÖû󬨰¡^·®Å6­œ^Õ£ë;Òö ,£œ’ 5ͼ˜]ú…>w´ßˆ [‰aß¹<CªâÁjÞúúÇC¿ª]I¢øª{îc–o•Sˆ~¢åõ~1NœÜçÛ8e®}%jÛÙx<Š<DBn„ó€á…÷²¦A}éi;««=üZ.Pˆ¹ „—Çh ·÷”g¢ T.cJ2õ+2ôì m= Îõœ'_2#´˜Ó¸ÁÌSÄ6ï3SujoÁ37×åw<NÒü*hzú¨ýd‘õÜ d±õ Âá3Þ¡'òž@.§ô Þ’S¶udWÈ_ËN€®0:–ã¾ ¢oíSå!0Š­…$Ø!Š½x(ÃuºQ¶ÍØÎ^Ñ·:Ô •B)»¹ôÇ\Góäé‹…5ÛÛGP°}Áƒ®[mý†òèáÌÓ©†é�oÔNá꛾þeI 'Öa>wÝFhì‘ŽG’Q~çS‡¦.‚•_£PûzÜÍ»}ç+³‰Ï­0‰¤/‹ÇGyêHp t6EmG·ˆ£½Nq èñkx]â05¥{Ã6õÓ#o-[q?»ãÈ«'J×ÄCŽj˯f•U7PÙú›GüR<5Õí% R'Z0ÂRðzf­cX+Y#=€¯-åS€¶ß³HMjT°*¥ŸBÉE}‘á¤èf&d#Pnàô¼éý4¾ð_˜þǾœó«Ç-%]‘^q/£ÿ°ø…Ã7Töä+¨ÜWç*óÓDº”Ñ÷+ o]8õ¾7J®ø·WËô3^į° V眕‰¬Z³F Z&€h—ÙòFI˧~Ç‘<ê(ö:#�±ï4ô�ï½M´UFWÑýÔÏKâEC² 6œM!È´Ê8²ÿÖÚ¢Lý<@Ó5­åÔBý£ˆi1ljO!ññ ).|Š=%±ÇžVÙÖº²müÊ+‰ó<¶“˜ˆ£ ÝÜYáqIθоsŠÛ˨×wçÝtw¢Ÿ$žoÉfö´‚“­pÀ‚e|”™ù oßy†Ëa™@>¤•À®ÇUÝîjL0©š•4—‚9|r/û\Ù%VZ»ÈЧ” •”²Ìž*«?æ¡ì�¯Ôö4L<ï]ŒëxÚ4—댨¨üá"üg(k‰·>¯ˆ}7±^©ž“¿z¢Uœyœ(úßôÞÛw@Æ·$.™*Þ3zåî‹3¯rØU1UojJÇƃ®Š<øÆæ[¬§¨_8å‘äA@ÕJð|úJ‘’Às·†ª€ò4[€h¾|&Ú;,ô>|n/bâ:§âéäQsø`wB‹‚0T^sõLÓ~éK©ÐåÀÆh³€eŠ•œf”&Ç2ÿb¸/8õÿÃ÷ˆ¾Çͦçï~ßÃ`¶MæQcâò:+(ÿ")( ç'(E0‹�oÔ£:ŽL‡úpÞRb`šÿBÀyz4}@.áÏš½¿»q¬èÿè6Zw,¼P’5L`EÞAÞ—~3ŸVô¸ ý푇V5Z˜tâèaÒ3Ÿ`W¯W÷É/(24Q,´ÂTØ<´"7 âðôÀº-î[ûšƒ…eÐ ô,ŽZøC°¦wµ HTî‹PlŠ}lºýa}òÐ’=Ÿ¬(”öìºß„¹GAL Û ç#½A£¯ZʳŒHFBøP9ô>ó¤’Þ íµò½sYˆLJöo�ˆ2R`!Í©íî–õ§€„ÍÇ1 òSï¡¥¸|ê;^šÈhDHP}ˆxxóŠ+ù‚̯›˜CŽr2i›ÐN¦ˆÞ¡¢è×μÊL±c+¤A¬Çkøeׯˆ¥I‘f¦2àqrÓ¢ÍÉ`ÛÈŒ2fø0[©Mx5ƒ,Æ6IiuW­'~4pü´î¥E~WŒîG‰'#’ü³ˆ\iêYÖ—åLþˆ¬ŠACÁi:[Vø[Rü›”êWàþQ}¿µB˓̃@R¬Y1SÁÝ�˜ å}3ZB…Ž‡‹î¶ßéë­ˆ·¶·‹9Ò¯AÀD´\êqÈc�w.Ìsã+ÁJ2À~Û#%­Õ§ÎŒæ •ü°6õV±´Õ¶Ç„Glù ŒDàjDÝŠé  z·£‚|Aûî´¿—äeì·Ö D˜òÈZ¨ TàjöÒ»}=99v§Š!¦g:²½&´M‘)^š6†Â—žŠÚ"wÓªtá00Jc R'8žï(Œž%ÆÅ4›þX$!ÃàAZ³ }çÒŸlLuÈ`$çA[„ubí †óšäXkÜ5Ë%د|³ÞæºoóŸ,!«’™ÕÐé|÷~ Dòg«Eû™;°¶ÿúŸòCIA$0h\º•V¾#1 g,á±T‰zÖ±©²p ³û”çSÿ¶ŒÍ trðäùò{í9FǬ¾(Ž¦u\™¹Š`ÒòÂ^,ß1rêSLôG#… FhS:÷¯‹5Ðûæ<Ê ‡P— º‚*çOOók+Nv<¼4ô›ùÙunk—ȳlßš(äĬ ¢FOJpó™þ?¹ñmž÷Ý~+˼W®:ŽUæ‹ÓVœú,(Ö'S=±|WÞ%ÐI+ßYŸZ,R¡ù0šãÁ=6d˃aCÎfô°Þ´)¿”zÔtܽ.-ço4:îµ”Iœ9õ7Èb€Ã“wßžV‚An :}kveû Õ’()lÑläææ2(êÞG®‹v·´† †bFoîo„K‹(±²C¢†K{žrÉ­6�)£?§©7WÂpO,42„ÅH§6D%ç§.Z0À“åÓõ1°¯»¥Qšú´Iaô?B«œòm9ŠÃ‹BëX‡ªïþEvûgæuh³¤þ2,‚~*ik\<ôÎ ßKÇN6nr½Äx)C~:rƾe`þZãtt%=ýP±"ÉËÊ VRFÊ£ígaÌ^3êG`ËnÓ“Çg”Þõ3zkÈ[[-´ÊúŽÖðë§@Q:¼\ª4ž°íW²žèº"^£îî²n$ñè½>{;† �5ÝbîB²ÚòNØÿÅ=YO,%C�@]˜t —Fu°p/ÿ©2Œ|-»¨l7qP'æ8Љ8_XÖõCÏgÖžù’·?ðœÎqô"ɦäs[ÞÝF!*ýcy½RWˆ3çEo¸ÝPzòýiêMf°¾wÃpyóÝ_~û±Ë2Ít¾ÀÓ÷‰=ãNG=Á2ÜMð¿=kÅÆ NÆ4éÅO¾WQ¹È@5ì鸭.“' °êÖÃ@n-؇q]¿5�øŒ Ûî©hØ›3…ﶵ¯A9fk 0tè¼ÏV®™e¡Ì<Íi«½&™)°½A«Ë \€vPhyM/ŽÕª4ó[Á0,¤ø‘¬goÀ¼ßí“’»ƒiuLXžä¢ÿ{çGžªpiØïmO9Uͯ¤�±<Æk-üÙ_wk/ݤG°/ mۘ¢Q<ŒDu@þyŠH±Ù8J·ÏF9÷zû3³Xpx„+Mƒ´Ó°ÙŠàÑ I}”"Natø³©2 º+Å(ËÚNpÏ£ñ•ÑXçô4áLâ‹÷!mô•1Ó-M¥ô3¶ŠoÜPòNêC&¿Lo›ísœ5Ý~Ø"²àúî ´)õ?¢ÿ‰•³â3)TÏcäÇÖëYYµj7¤¢†ªùÿÁrø´oîKò”áb°ƒwŽàóêù„‚¼$¹E^ìñÐèîÏ<€™�ý~ïJYµý皪¤o›b2è~P¥qcÜ‚ö6ÕÃGÇ£ ãPðà’Bv~å¥ÐvYltZ‚†ÅD¡ù`ô×Gé™6fSù£AÁÃvˆÒTÐÛ}*ãÄ>%CÀ©5‰WÀõÅñQúÔ#úÈtÛé‰ÚtiFóõ�Í žÑ MƒHý\Ö5Ò.ý/Š=0±m%%£DŒæöÏ;†±´î›‹$Öæ'7Žc‘ZV¦.=b˜õvx™"¡•l5^×µ˜]¿.|Ò237‰YÜšãŽëÊšõÝE°ßɻߗyOœoœˆ¦nŒÕ|wÈx* °wÝ:/ MeK·:tO ؽƒÙõÌ_Á¹rún]§ú‡>¥¼Ó‚‹,’K†MÌè‡=5Âoj¢KuŸ)ü&-eùÕ}‡ÓïÓãïÀ×þñ¯†ß;aoȇÄåµ®õJ²XÕó íØ”¿2 /Þ‰9]ÓϽˆØ¦»‚Ý.Ù¥šG¯`¹¨Îº-$^;g"ûÞ•±E^}Ñ1jÈð‘§m½žM¯QÅJ‘v0.˜ÅÔäò4HÅŠ½ÒÀz |„kÕÞÔá3ŒÓã3þ^¡›ÚÁ²Ñƒ«ÔL¸y½>5Ï(¸bÀÓˆ„ø=4G´§Ì‚3;æå"©MÞÊ][º3óƒ‚zr“ ìªm§É2Ýø†`x̪ŸTÀ3Nøþ%j„8ôìlimNUŸž©,]pã5ÛÞ(²ì”o¯ É™·™äž0|Ž>};$´ƒzuLÈš%ê6XaÂÅ9Ùx¾;™ÙíÏ#¯Æ<`Z°›ý¾ð¢Cö“¢ÄÞºI Òšm˜LýØq.ú_^é’ôiPœl §Y:t©ÖRþüŒÖN2—§2Ȉ‚¼U´_•Þjq�¼O­ìÆnöÅQFžg¾7ž¤¬?½V ”yTö­Ø9÷5‹ï2Ì<ó9¢|²¬ÞDY½ÌŸv+`oÚƒúºt>²·+7³—¾¦Ïj5`@QÞiJ:µ…Iô£rx¥ÑAÌ°(­ßO;jIË'p¥Ã$Jöµ…ÝÜ0ó3ue¡G‚ñl§sθQƒä¼£³Êzׇ±^6%èý°hö;Óú^Ÿú» {DÒý†AÝ”Féb2¢Å‡¼|úÔ¦¸îSY6ê^‘áÆOô¶3ÝñŽ½_,fì'vR¥£®¡hœ¿Ê :ž½fÍâ°RNu+ñø×¼$'àPª„8DfJëa#±i:øïr´VMÀipíž¡Û«!º£xÓÃQ“‡_²µó…3x}oºé›o=Žé¦hŽ.öGB²ÃÑÍë§i+jwzÅqº0ĈéÈõ¯ó¬*üØ£Àžß:¢EYµc‰Yq"Y·^¥ŽØ~úpÇ%K¢üüYoÂJ¸çã‰Ýù­0¸è·9Ю۳q=þ¢Jwè±÷Íè§A)ž\tÃé,Kø. v5ì’ó‡èù®ÆzàiT0Ÿ“Ÿ² ¦3{KÜß#¸�4Ô{…¶ä’)÷"¤&7 Ú²Ç-÷ÌÿÚÌ÷$Ϲîš!þeõGŽ]# :ÕŒ"÷˜ÛºÚvb‡Ú¥ûxùWç¾Ý7‰f úŠVùE›ÝÓኗ=›Tl@æ>×üŠ r>ÇÜýЃe–ØFŸÇ”Ìî¸j‰ aÂ{-eisÚƒ»ßÃCÏ&¾ Ј–Ò<HqXÜϯÊ×9ýasïn”�@ ¶¶hâ;/Œ9x1Œ¸i,¦ÿÜÙ%.¯´%š–r—÷Þo\£Ýê­²ëÛ‹ÛvqCìý˜)£> ¢éjªï&/g„ŸÎ ;w%1¢Ì§¹ÐÛœšŠ•i=¯z¹%rZá?h™gŽTŒÓº±ÌÜ»<è[ú¼ãì¡»6gÚ°—ugCݼ…ØSòØ?P‹Ãù2™¯ ¦ÒÆ ¿X_rÏ£vlÀ—÷‡ÓnªÍåõÞé—kžÏ÷n²ˆÑKó%Þé¨ðiMšäef·[ TçY“y€MêÞ ¸ß{Xš ú¼k÷Æ…øÅb=Îr'< 9 F ëÉôÐÀ±ÀÄ`Æ‘{ÓËö¾€§�<]rÊ¢¿¨Ë„ıƒ KÁc ¨þÓžâ‘/˜ÂðF OªÆšà¤ð =Žº‹n0'ÏÁ'\››~3–AYkÉÄÜ]Xm—57"'£l;Ô.ŽÅ©o�M'Ǿ£âëÛ×—mÏ«yµåi›}½ÓÃM-?ŒÏWnàZw™UUG+W»C”Ë|ƒ– ߇;”Û´ ¯€±¬x‘÷ ¢2¯¦C�^ªœ;zÈÔ£8n1ËþUõ‹¤ôíÑpýL‚Ä–>¹¥s›»|¬w÷Ú‹›W/¸%”Õôy·6 Vq`A�æD²(€Ÿq᥷{Y¥ïiåä“2*­Î—a  ýâ·#â ŽÛ?¥Ž2'ý(f»:^<’²Ú_–µ¥[ýH¼bÓ1+’,Ý¡ ’ÏÉËë¦[Q@nÓæÓ[Øœl¤oÙ ŠãŽý¹ºYûó”{mùçoî¶LÅèúlOZnÎÅ,6©QÛIPv0ËPø†šyP}+úáÜØ6aÆkr/ú݉Ãì‹ZóT±aºh(£c‰Üüðº~{RÉY&t EøH™uî˜Ð´¼ã½ûº  %W•Ö…òápkUsÆwÖÎøþðj³WòqoÞë])ˆÞ4`NûíÉN;òårføhmåTŒj2¬W#Å ó<Šûmíº›¯;®V*°^éûã^Zû÷;•îS?ÿĹPÜ­”E3ë÷X³ †F:ó¦O'yG!³ešÿÙr~´8ÓÐÇoFhÒÁ–ÙâŒôê#›Ëc;¬ieƒ›@ÇNÝÏÏzhžÅ°Ѩ„%ŸY­:aW´Fè½ÝÈâ\÷EîæßXø¦3¶ ô§2p8Õ!T­Ýp_²XÔ9^Ka’Üã·2çh€Õ°…€„nL-*uqg†‰/³ K•}dïÚŒApz¬Û¡vÖobJi3§³êRìÄ`‚¹Ò ­¿ì—7nk-UÏ蛣:Ò¸zêNº.03 ³TzXÒwÆݧ^(ÖãÉ›U>팬™>®Õ‡ÇPb7ù **&.¾Íöµã6fSpù0Ý'v­û˜1äÑi»a@cÎCþôÏ[R¨µ� |›…Æf÷ºfTzñŒ÷ÙŠgwÇÚãIu|Å©3 U¥‡(I^©s!}K‰NË^FWî^Ú6à[O5ôôéÉÒšlUîúO3¼$ôfxÜåÚÓ½*6“×$….ØÄ[WdÙçOåZ-¶HÊ$ò5¸ãcï yÒÒŸWç½ç‡}LËctò=¼rîIZò”¨Ë¬™=ö]S7¦i'#Éß!/]=ÝC ÄÆ`˜@‘ž‘Œ xÛol^îߦÜßbæt?·ô�j­¬*gÖ,[˜(÷i™¢TLÄ—·ïÑXƒAýÚ /;½V,‹1‰ƒÊV–Y"Ö7E™Óxº£ö”§Ù¾±iò±ø!tŸè(k!<bkMgoCÐp³è)&?ñflXwò °­á2n0g€_Ÿ IĆøßnét}WÒ›ܵ>¹6B±¶Þïô0ƒŽsÛó+y8|ÕÆpÙðíkñ/ã(ØYdÊVÛ4 ŠAgYä²ÂÞòÌŽc'œÈýI½¾,õ¢4Q7¹RŒÚé–í>ÏŸ€öH…o(‚Ýõ+®)‹(µb³ö¡új7( î—C³,Z(¡ êò =ZËz0ìcCnÖýL.=ÎLÇÓQ§È¨ù/_,Ó¸´—§CêÈÙ¶3¿9UAø®D€BÝw&‹ >DüÕn&»‰ærqdVÝp.(ÃÕYnôšêfËXœñyâªÁGÖ4çìè¬å€°G䢿}žõÿ/2¸•7¥3†6u¤ŽnS¢´e¾˜è`êÇônF‚Þ£Žæ™oQK‹VH´Õ£á™¸<G½5 ï.ËkÑzbµg8Æ¥ÖX×tÊ15_b¦ÁÕ×õîû€.gªxGØg}Ûxp˜H`86jC·ÿ<=Š%…oI�lRO5JùY{=tÀñÞt›¬Ä¼ƒ¡rõ‰"&­â»X¹Ø& Ât…!}àÒ¶AiåÍ;Z­ÌÒ´bwþ0 6ïò8ö[Ù@º·Çé&,1 $P°©‚¬¥z½Àùª\Æ-žamWP´>*—¨€ÃÉ~U,4bè-ƒ£<Þ9¥99Å—°°[”˜ˆ©™¦0@¨rÌ,HìÖ'§a®�¡G–¹3`”åj[ùF‰?ÈÖ‡ï7µ†5Ù‘þ&ú摉BÅ‹Î6t¨lûÖdŒ›ÂcwÖ‘ ¦2^m¹æ{#• ¡Ï¸¾hhõ)»ÿ¼•—dfG¾’•žngÎâ$ßU;_Ó¼Áízipcr_ÃpEDšo~tO˜0Y˜c ŒzÍuI!;ûäAóÎFÞÝ]Ù&ËÂ+ÔÊÔ0Œ¶qT6½9Ó©çF ì+I˜‚p÷uYÌbÛ?&‹<|Îr#àÄTÛO->ñß°s4ó.;K&Xš†ýì®)1M= ;ÙVA±C± ÃrúSéÜ9°£©õà ëÚˆ#¢³ÞÛZ¶ CÏø‚tãë?Ž§¡Ò¢ÜŒp†mËfÔk¦…ìä5Ë&H]ëñb¼³ã G4œ‹Ïì gDϱïRVŒS¢)Z–_·³‘ä‡+ŸÇªÝfJ@$÷áQ"ñhà f'öD¾M2ô³ŽLÒýãEi…Xºh¯ûî1厫"ö Îùª;?-ÒˆÄK먵50?bÂÎ"��¿=ý©Qríµ˜)OðÖì1a[P/ƒÇ¹£““Pª‰JµÏÆòCÝh?÷Gæ~œz;“'‚}‡‰àôî)ß0ñO>â¡þl‰ ´ô•²ñ²X6F,›÷–ß±¹-8 ?ïú=ËqØ‹‡ò¯eÙ#ƒ=ÛX éSà«®|Ñ_Zƒj5?‘§¤ó+I1ÌM»¨?E, Úî9w¢mûïF|2ú_”剟iÄ,XDŸZÄAå¬æƒ·è¬…?ý;ž¶˜Ͼ ™m"Q„El#ëÙA©†¶ã_#V\6R»Ý† BÜu×â§GàþƒF&o<Gcs=æ±æ ©¸xŽ,»vád†l·ÿˆ�Õ®\´] U¤OºÆÝýUA« ÄHˆi°c+d'K¦Òr iC 7`v‰‡f"F½ç_:AEL# S<³—Õ†PÀ†h¼gî_Þˆ7'¾h}HÚñqP¾[¯ûLä¼éùmŠËG÷¦£Ì]ýÂSzÔdÛÞ©RU¤‚~ªLSå™—ÛÑéÛ t‹kE‚&Ì|e_×Ñû;<«q—V. Á¸‰ál­P—Œ%{Æ=ퟚBŽHuSÎÀÛο–Îy‡Çã0ªÈq“r`pÙÙ›ŸàN‡‰‚ªONøœÖôšŸØ°h~ÜíÅ…úGVF@³ûNÀdëý»f •V¤|RîEÃTjƒeâX¦©Œ‹Jõc¤k…TaÁP¡Îu€ÜÔÇŒ_rW6«òTö½ TOoY}Ú6)K— œ³ÖKí û$wªÞƬ¶¡Ú¹ÕJ  Ï Õç·zÆ©1¬í/òÿȘòhÈC_ ™•èNdïkßÞ8$Nš`r`>¹%ÑRàŽ–Ýæ2s¯÷f/üóf|Õ8pxh”G^Í©·äx9À zßx IxHWÏ@zBÜæ¥o$Ca|¢t0šuWRÉ:;˨F·ºWÕþ\˜ÕL¼X[ý¥ˆ—Û¶f*‹\,rÇFêœ!<JºR(N<¿=³@Sª­v€‹%Ië÷VÖãnx:+‰¢+ú ÑE“{ lD1Ä·^µ§Ý­ÿ�∢ÜGWƒ¹Eóîø#æ?öÿt›eáR ”ý¸+{ ¡³Ã˜#üës¸Ío\ºs_£ÉøloÚvT)6§Œþ¤?v % Þ`©É@í[­pÏ9Pô2ª…)Œ/Ûëb¾§eʧ÷·â¨÷ÆCRîIØ°èCŸÐ›Xí"öÈ�0ŠKÝ;ÌŽ©[sâw·M/Ðâ9è=tTUÐ_0¥oèCHçvX?þV숢‚§ýnšž ßM:¨/L‚áLÉ4º#½ßÜq†dZ,ËÒµÞC×èN·³È3ÍF Ç%ÊsÓѼqΈ°ÍöÐïõÄ}*0àç­²fØ=³"Õ©8õ.å¼k†.áƒV_´Øú °Áðàõï‰ÇDZÇЉÙÓ–J-æD‹¥|E‘óìö�W/rƒŠ~ ÿçÙ‰Ub;Ð Œ?µ]1Êâ*@Sãn?ÙŽàëd)Ow³´¿ zœ—E,6äDær o»ȃü‘ÝT¦(ÅÌLö·øž<bm|iSïe›‘¨,ý"•VÈ –6áiò\(ÎP}5nRôÉ'†­*cКKz•ÇU¥…C×%ÜpcŒ‰·ž',æ Cjö0oPVâPóȶ2®ÂØ›Üw×SŠšYI6Ž_ôÎV-g>´­i{ðƧ=íEäAwCGdÖêÑÂ91-c1=H!8f™~÷"¶ý쀉½š$Cè\c48[ÆàÖg1¸T¦Â(2ð¯ðËc_ZIý3ݬúSáZ¥8H­ÍßQB>xá½SÕ”ŠrÅÄA‰-šÏ8JƾrŒ0¶jPå�Ýø�èhéQdä)ö0"«[óáÑQ™àeû>/áJád~cPŽüöÕ@¶¨\Z/q¤»½PïÂlAªDú´¨-Û(Ä;ŠƒŒ¬ü—„OS¯OÎBMÇ>.‚b´#Ì=®˜iWƒ`÷FÇë´©¹e7Ý•è 3O–=VÏšB–×Uª2˜ƒOêñFúdNHK¢X}ëmiùE6©ž¥‡WZLöìç¨iiᘛUÜÖKÕÆÃ~üÄŽETE¾– H¿CŒ bí3±DKÁ`ƒæ­lÐF±Îå1Viæ“=üaö9ÖG.‹åà£ìŽÛÁÅýÐî£ù¬h¶°àmÔ”<fχv0·²¢k®6ÜÅ룊,ί®Ké÷¡ƒ[{z™ë“pýí³ARöîTÄw e&�¸ÑQYÍQZÁ×n5Æ ò¼P˜9›¼Ä0\§ yßzà@l‹’›#ŒuòEr¿§æ~1Æ!¾9а¡b4mkOРkhûýñ@I2<湎|z¬Ø¥¥/Æ`0ù4˜z½f#N'C³DXph£éÐè‡>IXe¾siœ¿ò 8©oßœ•êz”á_FËÈRDì‘]ÐgQ§e�Y)WôYD¬Œ~Á–îÒ±~`ieåÂÜ1GOç´¥;Ñ+ Ø8×a‚âÿä•Ö^b‡‚ø,pÐÅAÖmÞA¬ Þ~>Ùâ0óaÔ´Ç *[m&€HAÉÿa —g—/þEÛå”}¥“)¬~ò«oQ%,H#áß4ª•ÇŸúöÿ¼¥Ð¦g±s³ Æ7êë]Œ-a“¹*EŒðb­Î|™)EˆˆÞ‡Á¶\:OÏYá g¬†-=g–B)&[$\!Y“Ç—qÉ¡Gþ.™nŽ¦­Í%Ñg=׳Jɽҹµ¤kY{rRŒUé†#á?X*RF:øúz³u>\‹JòU>»³<X�ô´bËYU£jEŒwÚSg$¦²1nß¹ ¯(ÛlaW½_ÐTI-ú7¬;Hú­“]äA9ùC;· Ò­ÏÛê}m -1b;ŒÝü¿ôý›pCò4(ÇÎ}êõnþ£ÒæfO"+}‰oUQè¸8ÂÅ"DXE™Ð@“‡3 «ÉÎ^@9¦M+“Ó‚Vhên”t"?`ç’U³pšHb†¬ÏÙî>½²Ý4ó2ÂS[–)á“«H¹Á;Ó[tÝØ)cº"âä¡ßëǬ‹=ý¶¶‰‰fª|ã!ú#AaŠb]ï`µNDä]çðì½�tÑÁÓÐÞ¹ÿW)í+äÒ1 ¶#¨ºq¸ f 8¶åErv¾tWns„naÚº4Œ‚ó{®ýãÙw™ìC³¶z¡-~—$™ï@kKŸö ‰¾C= &ÀoÞêÏ“aö½¾ÂÊUü~䙿1¦)k5K«šåêö`U*u7ÏFËã0MøPƒ‡²csÈÔ>5®åï­ßÅä´Rò!“n<ÄE«4~¨"éÓLÙZ9±s)mÝ-r$ï`” í®ìLi›²0ËËŒh2)–Á”èµX†~ítÚýÉN€×àž]ýR9žz·=7fA9ï7GiºÁNþ¬Û{¬léI­Ötg¶öÎD3o(¼½’R¯Ý™0×À%WB…(6±qe‡lÝiñ¢ŠEZxl7$R *$[½Ã96ò¸2kau†Ý_P*t'LM0+¢£ÍÒu<1ÿ¿7ñ}šÞ Ó0Ãt<ÆÑÚÿÁƒòÉóȽŠ½d`ÀŠµU€ô?ì6µ)DoF¿é EQîA«¹ørÊ`[VÝCº2©Ñ  õÞ^N#¯|Ï™¥UžïÑõ©Œ–æ åv7]!tïžp¬’ùŽxE°;BÙt½6ÍÜ�t-—„uðÏÊ{ëÚý ÷ÁÈ Ëá œs|貦°¹Öþª¾þöÅkOãžO7¯jzîb›zéVÎa®©‚pܪèn˜yîéÖ(�à9}ÁÑuãüéH—uè¦Ì%@ÉéâŒ7àièyÒ}#¯Ö^ÂÕ·’º,”9™o¹ 3N1 ÒõIõ}6ïÝY»×@”œñÝf’oǸèí)÷z`HÛºýþ 0túçÞQA—,°Ÿþ ÑDmÌ•UÈj‘I?zêôwêþ¡ÈÜÿSxæ}9äT´gÏö“Ïé)™ mUT‘2+ã"“ö/{C?“ű¹ü‡@t H^Ö^Ç|¢“gÐaÄŽI§¾ Üö„Nƒéú[üEjôÒ†° HŸ“ýe°µÞÿ™azU,¨’%ýGYؘ›¬#œSõ÷þÛ#¯'rŒ«5�GQûÎ-´4)„ÍÝź=>&毪¬L{AØD’Y§ AŒ÷ÒK¹Þ©¿PY ¼þAï×Ù.}¢‰2/ 7¾{™eî‰ÆçÀ&®ÖËdù�Ð÷<_; ÝǾFw¦cw˜/«þ4`7´mýÆgòò¦{?òP af@30jM¬œZs8õÝJÄ3ÖäÌÒµÌnð¬jì/¬[ÓØo !‚ïHvüãÔ ÛÓ‡ól±s­ë‹§Ú˜iú”<±CF¿`£côúl€ V1DdüjUOâJÿW  £c?ã3íÁE¿([hÁÒzØÖô{‹ ¹·CËôE±Ü4D›GGož-@Y9„¥é{€°l‡™)»ƒ ©Z6º*[A!Þ´â=£ÈÞ' m;•N|_ÞfØ1¼ÖY,} bH¡îAåT¤-㲨ê»ú"¢qsÐsYÓq€Ñòs§µ"³¤*1 Ç~LÞ¿bmE1C»c÷¶áO2μn/’¶!£ìtëé>‘gCSâÓ_¶ÝãØ$qdd³f0�‚•ÒmžÓ=øÛ‹'9ÿ) 4wÜ«ûéþć=T`i»Íà uä!Ù ú›^ÿ’ñxø˜Wb–ô‹­˜ef¼Šxp§[Ü…‡Ÿ.¯}×Ŧ‡ Áf›¥íÎfêpϵ­]AWÈXâѵoŸ[˜JßbÔ'‚á2÷/™å%+w˜4w85™÷Æ3‚�Æ©¶kû68çwS½Cvj‡ÃÛûiXA¦àÞ–X‹"¶@CÖÙÇC̓ôóä WMýÑ©(QCçrJ‹´x[,¿w*i,ù€õƒB% 2;S‘m•ä‰ ‰X¿œûõ^f’¥îgÒüªÆ®®£Üø{»gûRW6›S£b#ˆ „¢Ó»R)5¨WuÛíUB€Qu¦ Îy¢û‚ &ϼî%†«¥n½êelö2¨<UŒÖú/Æž§·£,ˆz«íÌ}oL”EQì/îl˜g†Uiõ&X ͈ Ÿ#=7wô„)ÓäFL=­&ñ?1Æ×åYd›Nøí7mŸãè’/XuoØý¼¦pö»5U!ÏÜÈJqßë¦ ÂÏ­G¾4ª³ŒB àÂÕœ^=(CËhÁT¦È×­âKPÖkjðg¾q4ü‡Šh¡^PM 9°+EÍyœ·Ç²ilûº%ÿ:‘aöv¢‘pIízd’EËAè.ŸÚñ‚g`k<:QÚmTýÙõÓy™Y±‘c”d×HQÏÂò ´ï5 ó÷tTàêYì C@Ì¡€lS»ëùÉêc¸×܈ žÁ趩§"Áb…#çXm5 &õ×Õ$òò¸ý=¦h¨ìmŒTsU)È\ÒiŒ2ž·œàõâÖ$×jCcë’ñxÏt×"f¬e÷¶®äh‘3S]2ÇVß…†#æˆ~nõ®³VØÛ3 qœÐ<›äMß<´³º˜ba4)=ïj­$ Æs^(ìb£ÑV)ƒãTÎxTyT;ʃu‚sSäÇKQÑ8b"{R[Dz”çÇ_²:­T¼rÙ$µ§yå{™GÜ$}ÔxÎ<°·=Ô)ÔÂábº³Ï; &*¯‹îݶ·Šfñ¾é«}LËA‰ T çÌÑJ+¢æ�áMN ž}û’“„'ãÐÃ1=–Ï´Ï“cùÀĘ½!µÐ}~šÅq‘ùà×Ä'˜Î7Î) Þ[îƒÎœ8X»‘ðÏ6­¶bË:3/ôK†µ7=¢u6ˆâ“† 4edÑ÷´­ Æ÷T/3‰2¯AÜaŒ¢lôzÇ»¾¹LjÝòkH{z¶œPjYgìfÁ“s,YŒ‡ ´\}y¤…Z.ñêY0Ÿ+ÊÉ5Ia/FfkdV.ÞíÅPig^Q‘Q`¦÷?Ú‰h $Ò5ºd“ùì¹ójU‡›~Î�O›hþ\xýÈ€˜‰t^u‚Hë ”ß!T£8w^Œ‹œÏô%j¬b[¥bXàJYg©á^»EµàS²®ªùö|‰»¡•žíïT¶b+8—´ {WóÚ k¡Å±S=µß˜Çžze.JI9€:yÌ!6÷±C÷ÒæÞ¯”UËË!ÂBCÆ[eŸÔ†”þèÉ"0 Ãm¦>Up¤Ç°ó}ÚŽ'ñÇ{d9Y¯@UD„iC6é )ŠW~꾡ÄP[œê=£kFÆ<uÛ–AiÀYÈD’…ʤ°ø ââ“qrZ87.6o:v��ö³¹1rÈÐÿxè®x;¬%1Xwh<Õÿïÿ‡NúË0<þƤrôßÞrÇ¡O KnKÇÛÁéWà¿\26‡IºëÝVr £Øx†2íä[»ú)íô–²ª{hg¿jΓyz8œ5 ݲhZ›)g݇~ß8*<ZÞŒ�0¯ËñOâAm6lh‘–¶Å4 ×½Ýeú«6i' „{Nk- ÒqkrÅ “èÛˆn­nâ««Ì b ÇX“ÒBîu°DÏö4àcq€΢cqVÿrqCRßJ†²Ç wÞ•¸Êý8‚àŠyqWO§f¯bãâ¨XÐûŠ��žtûíÁ‡éèë/´Xï–/êTÄ h4S u…;|?Å…ýÑÚ9Ð;lÞ„k5 d»Z+ï«oq°9m@ÃÎÊ ;ê¹”… ©­¯Ãy¬7 ÔQѾtªÊå;kµ•F®`ò ^Ö?…õ*ÇžoÛ¶> ‰[Sò3jQýn4éƒØb±.‚¨µN898=çæîx„·6„Þ(˜‘TçµôŽi»ñ„ñ¼f3§aðÁkæ=Ÿ!rœñÐÚ,¨6¹=ZÓoNxô‹Yq÷†¢tgf!QÖ+[í¥BNš—N½»qÈO‡•1QºÃ<½�º‹¼Ñ ;Y®ê2(,tË8^›A§ÁriÉ]lyïòßÉ#HÎÔNA½PE¨Îª¾íü€SZàoÝ°¦€†>äTï{ÆáÑ%ÀòW¯ž¢ ƒu@'¨lÿü66ž'«B™Ä¸Ïƒús=KJŠÄ܈ =[åEê{ÂÓç?R>‘Y«$БÅb}È$À]Ý£:jÍn’Å,˜èÆC5Äž‚”ypÖÆØ´àpîÿêkÊÕqäŽQþbõ ´#¤]/­ŒÿV~"¢:` ÚLÀp§û3رIi;)ÖMXØ7‘Ÿ…?G=ÌW ÜoÎP0™køĵy}¼,}¹çú$:¸òjô¼ X¦‰”WÓÓÉg0X8«cõdÑF†h,_î‹ŒV•ËiÐâ¡[Pâù¹1øzð/ö‘ïaŸÕ¸�6}´‡ ËÛñ‰‚cíê;ö*È|FeN‘//‚¸±´|ôd”/`X/§Í¦‡A'pð‡º—°ó i´Òë9$Ì›‚ÌM5©)tBá)0˜_“¾ŸF ñ,òú{ ÔÏ'~þ!Ãâ:«¯<H­$æ×›¾Þ EÉu ŒÝ¡½¸‘e«¼¿†½G„6;è 7µˆyÛW8³KþlzeV`-½L&é†üõ-H ”ÂûÜ^è×X¸C(Ú5…4›Þ­^  ï‡ ísy~o¶\U‹pNùnE¿¸¶]„’Å6ø)ªÞþN¤0ýŽÑ;öâ†Yf™ï�—;X¥¿k?2pΓõ¤íJ’~f‰1ÁNä’ÇN%gnî•/ƒ~fÐ}ÇA¹>z½œz0 3ú·ŽÛMòbqå™W­±˜ÒtFÓ kmågÊÊÊ�?îáAB|·OFbÒ„vš¦UœRi [éL’{¤BoGÍ!sšË\¼ÕñQ§“y„c”£bSÑ-¤ª¯¦ß#Ú=¨3X"@~kÌ6 à}ªìúÑCN} €Ї³„HúÙ¹gB›Dð{¢,Qùº½Û!†s’Í…ÒÀ“ðDðFy å› Bkß-áQ»/ý+ˆÓHý?u ëÜÿ–o«õ}¸ÝŸŽ=dµ-œÕÒÐO ã2èànÔ^œš{OMŠÜ»„ yÃã{V§¡g Moßr´îFUšÒ’‘ÄÖxøþàäë%áÂï¥"tÕPÝYƒ9)ciG8ÝD¶jë I%%ùIa¦tÈc£žD…J4mÌ#@X¢º5µ¤Éà°17Íât‘<÷ZWÜyi—Efi\°ê£\"?Z¨¬áѾy¦ŒPõBÃÁŒA×ßòX;�›_<ýGz^‰O%£ã“µ‹áè›\\ès¨f±À­Í¯ ³˜a [ªTû>†n½‚E›®g �ƒ·© ìÏ—6¨il¨ˆrW³þ2ΟŠ±'ÊÒó÷Ú§]0º‰;ÿÐ&D„××á'Ш˜—¾ƒ>žn\L¾¸rfÀï¯õï‰õÝ)’[ú ÍàoÅïL»WZW¯‚ú‚?uWߨ•*Š†ÛæTÜßN z÷u±M#9ÒïYV ºnMÿ0?«:ˆWdNï#ÒÒÁjÿ³]WŒï\õø;!¾²rí¿ÔpYKã7¯zã¥ó³(x8ÈG¾wu:g~D‰¢¥7?yD(OÅ ø\¼¥ –߉{kƒO7ÔÜ4Ê|¤=ó~i3ÕŸž%…iËOÖD?óîâp-øšÁÏ-åŸõìt`ÔëÖàÙ(a@À}¼Û$v)Wï›{Ô&ìÝ`;Rø=»¥mwÞÍn¦Ì£IÎw­²ƒTúÔq¿ön U8¬!$º$›=Ñø³ßæÿ™nˆ]îLïUYŠW§ýQ¼&Aå‹”Eé*ƒ±¬‡I÷_Bÿån,iZû�x¦—ÖsumÆÃðG¡ñ ñŒ9'•9m–Õ6­è¼°`ö™¦ó}‚[sïÆ.öx uÅ>©åAíŒNiÆ­¸döƒû¡ñ0¿ Þ­”‡Îô@:í­0E\ìhD‹s—Nª‰¿ó9M6Ë3U¹õéFº¶U“ç¨öì.·Î•ôLY.hö¦ü¨>™ØÄ¢‡Žêç‚€ª5„Ó $«K»ª»ñˆ¼æâ_Ò!™[]Ä¥Tä²O½ë$Ðf˜vÅÿšZ¶³6K EyEÖ½{äd3<œØö„ÙÈoÌÖûÏùDœV™“ŒÇDtÒgéµ3UV,­:û‚VþåHoyyս螲ÚUhUHp?:uµM Ç]íóœwTIÿ´`YÅ7=HÕ©wà"(ÔÎgòê¤EͶkëQßþþeiœYTàgúøíÉì>%Òæ»z•¨6[#£ŒæßJŸÄ¾Õkijås䧭)þ³q˜þ‹Û�ÔÉèí Sö7C+˜ðãÊD!yï<##Ê¢áZŠƒL~”C0Ã)=á£<¨ñŒ¬9¦;R&Ù1ûôH«–—zu£¹-ŒÓ™(I8·˜Ì 5S+×ìeE;e- ­šÛ"(?Ï"š‡-ûôT‚‰ž¯¸v¹+ÖZŠ™ÂìæÆ#Â6/+Ùœ6RNò²Ã ì-s¤å·iµcÈ·8 <á2S¼T†˜ÌØè@¹@O´Ø®=ÎqÓ îÇ&xÝKè{œË´¢Ü3~øxøjÒ—›Sq�…5ÿ<ª‚XõÖc§ëóÍÃÑd‹w´?øôX:‰�b’`Ü ¾µÚB醫Yõª(=fÛé…PžÝ>½B_$]tëà†ƒµ×uT!‹ƒ`˜AÁƒK{q¨•Å~¶J ¡©iOÚH,ÖÍéÏí@FÖ» ?ZצR¤™Y >ú¨~YUÜ ‰óÅíšî·’FîÎbµ²`^Ó¡\5ºWÖõn¤{@aqÚ&'€n^½´bÖ%.¼f¥{´´®bß0„ .ÀNëÞã-#Ìû´ù¹6œISpq@{¹DZÙéôÁ§šÖjØXãÝ‚AV@¬õàÓ½K¨Cu¥³“³å÷Þš±JeÂÒ�€»¦2û4yô­'ý4tNò€Pj§ «ëÍ}Çp)H­?ráÿˆ¸ZŠËÓ:A|±@'*�×€LHrÅ‚° ÍéÏ4%n~`ü»օïÅ7fÙ{à:T7EYÑð\�‘]Ù.Ç`h,Ê;Sýª~ä[dCXŠÈ¾«‚’¶¥HCâ¨fı¢lwPJ£̵¬±]4XJO#›yÄ«-¸ —³ÇÏÜMýîøR%ùæIÈm!Ñ|**4 M#Ÿ+.ÓÒ¹4Øò{úIêõ(2nœ)gŽfÿÐoúÃ^ö“‡CYP©ÍìºÃ°Ç¹ÞE‚º/„0ñÞZ>ý›§L¤Ø»*[/)?^£P$g»ä>HGgJÜ|»ZÛ8éÉÙZo÷•™$L›¡¢2†6í»UBòÌ 9ÓŸ¾‡Ÿ{ý‡w²´"óP>´ˆ˜v¶¬ß’]™ö´±LM ¾=M×¼/EX-É_÷ê bƒ~‰ÉGИ‡–ð„N(EÈ ð‚£O­62fÖχ›QeHI iz–Œºg$ZzR‡¥’—æJUîþ;Þ,-\ÑÙ~R+¼!ÏÐûj!n³¥Ÿf÷׶Ó8”Ù¨¹PÁj¸õf¶Ý—eœ=vö)Ou‘&Lƒ·‹!/‡¬GöÆxç] ‚Š¥KpYæÛýÑ?•Q«!Ü@©¯\VU¸Ÿòñ®TF6ÿèÔ—[a0ÕÑÎèQ+®‘í?:Ld쌎�®¬.R}Ý|?u´%©t*a¥k¦¥˜g]´¢œ eZV@Ά¿ÊUâÓ€˜4~†Tºsý3¸DÏ"b™OQî‡cê±]¡`—é6¯©|ï§éŸUˆ8 Þƒ4Û4~ÂÊ)€B C3&”®½¤U·7ëhˆ ®wõHÈ'ñ)8ÏÈ÷tHYÿé©^¯Gåoÿó–ªÇÛƒkàòå6áŒ==ãüV#&Ë †Rû»ÈÔ3·²xÜv„¼j§âª‚×½~½“âzV~ì4”AI‰–•á_ÑÀo£çâïÞC¢’Ú :bÄm÷MK³<*It¸¯®;ßRÄÀ¯ê¬²Ù©}ªßZ¸þ‚p•=E¢düôD<ÍÔ’w+Ó-wS]¯üËÇ¿ )³¨kÒ3Ní)•„ªDÂs Æ™CÙˆØú‰ Âq)V%~ õ„dèÝÊ^FFr¤³|²:0ÆYÓ^üM)›–~~Ña0;jΞ^ùw¯w#d6¦ã®Çë3¸˜å@†æ™°»l§>Kè÷ôŸ@)”ÿ‹ÇláYò°œ×æÆÞ IWl/(Ê‹M3<v)P÷”?æì‰ …ÙÙ¢:göuÍ-úò\''®BoFf”æôœß=n}Bʾìèiè:æìvåî8ñ¡)ì±›5ŽÝ!ÃÀî“Õð¨m)�QÍ©…ÃC¼–þ;4)Í´!R˜ŠjÕÐóM8‹Ô™Ú´§‡ºh‡kÔ<K§àÓå¥UQW±:p]ÒÞªÞå�ÖÒacÛŸ1\ü:žÛªÇ1ª¾õÄÓV=-å¨.a „¾ƒù7ûºÈ'¢,Œ|äkFYýé–uã4'íÓ­NßÌsyè—%Eæ‹]”A3A÷Û©,YðU{“èŽÝø/ ?¢­[wi$}=S­s]ÂÔ6p…%Å’ˆ/ÎØÊ%\|‡¿†‘¯÷a¥w„æÌbÅÒl´‰•Ìžkºï#kÛ2\ôã!¼EŸzï q‘RuO’r+*Iç.í%¦©Ž`zg0$;8zMÀgØ »Ó^ Ëe¡t&Œmѽ‹Ž±‡-Ãzïq»ò…Ä ÆX®Q§({Ç,Ó¥ů$¶‹2ó¸ø5UP/Aéh SrÖvFÇ«ÙT<‰¹úÎÓ~«Ø ·¨- ©Ê®°?<æ$ }ZÊê†.-‚lð¡T‘šØ$+;­½Õm÷mª }ζŒzL·ø=Œ¨ÅÞ'+ÕÈr2N áÊ«áÖºA©p¹Wárî�•ýäýÝÃñS¡“°ßY&ÜC…ýÔçÑK&Ò¡q¿;âs*ÌÛèx:®<K+ÞësFá•Z‰ ì­vBË€NÒ¢ú[„}nΊPÅXv õTGµ0,ÑY>´¶YóF½~›5ªÏ‡7¢—ÔL˜ ÔšS)ÏA¼í5ñ˜Doߌ‡?ûKÏQǵÊÌ^“Üw«­8*UÏÝ0Ô¶vxûWSzÚ—'³†?¿@6|u˜qWÛ j¦$ ÊYûŒ«õÏfœgôú¹)¾Ù­ÍÈëoþÊ8Ì €1íù"(zœ‚­Ûæ0q®ý�¿Ô’›µZojÌÅûÆwü•j”ÜÞ"B‚:Ð"» LcßÑKûè#á­ ¹ÏŸqPl<RW&C#«{¯{Á1—ùó.Š|í '•.µñœÔÎõÄœÝAHôå´WܧèÿZ`W¨UVX›rƒxVu‘ªÍݸò`-?9ÊÌíS.–¬³™VÔ,½@V'PÐ1ò£âë¢Í…¡O“駊e ñâÈJ'‚,ÉÏí|f±· ^­ô½¶—¡Å0m™|åaæ «°:Ê0(>gÿPÜb A‹Ñœf‘wp¯?¸ŠF~_¹ñ¸4g 'qîì ›¾Ì@?ÁâšÎÛËHR»Þõ×ßš¶œIs™<²›è§ÔÇÚw¦Ó^P¡×™þÁHª9ŒpaTĘM¶4é[Ø3>ÁøUaÐ0lõééî2#¦ P,;Ã58ÿô@†€ÍH)|–{óz=í¦ÂË ™âìAÊ…(¡@ðqyÖ-iOs8`m˜—{I!q‚+ôþOLu1AhU´Úê@!±c¢çïêΤòGXü¢ggC_;†]?±2"ׂ‹c½ÿ`9mÍG²Êà‰¸¡QO°f~Ûœvô§,?"Î Z<ËùÔÝú^�…¹í‘Äcã\DX(EïÚpGX±¬¹Ü¢æ¢$ñ‡Ê”bÍÌ G•�âe®Ôÿ}çâ€Ìš¬ß÷©)ÂpA:Š‚í±b4axÑÿœµ] 8Š9Œ¥¢Ç ôº)ã;† ðaßÕ”×X÷hº¡Ek& A‡{âñÅæDEHi‘g‰Aôšö Õ’z¿üë‘*Cì™XØVhªdv<$(Xu_„NµÎ´!TéësæT\øM9H›„½vÀ‹(P;òi+Î׌Á³ý+9<h)M5jò ìß-�ižÎLãWIç ˜Öf Pa»û2Õe7Ðêý.sTeQæ�Ttçš>¤ S™èHåÇn^‘ŠqÐm Á¹çY |¹/Z삹k!¶ÎYäÞŒ ,ãjZ³‰Î V:<l0 ù¦•(#L¹¾óh:e$’Š #ªä­[ÊÀF•m­ìø¼çû6‰æôáÛÌron´Øê7�èûfãX—t{?&å)vÃþTåç.A©ðÉ1[¯ÚÆœ:1[Š¹ÇÔ×G#=¼œ©¿ DãdøØ<òTcËŽÎS-ÈMEòæáŸñy'g‡g¯_Y& K6V*¦…PµZb ÃõHrQ@Ûœ #s ñôñàÇN憸L_Ÿï`Éãté™L™Ù˜{켦VV¬iÇØr…ýÿ&'MìkäÛ´@o$KcïÈZã©¡gwì\æº=ôýÅÁ�9°µc}áÜì„~ZlmWÄô¸&³%qšíO½xü±0?<nBr¿Ü”^ï|i•W ßz¸kaøÿ®ÂhfïöÝÁ ÊaÖùS˜ÔŽpó6 šœö¤Pkøjáyò3Pè+”nR]÷HH,Î*‡ôe ׸¡ì¬þ4G!Ž¢æ–Tòè Æ Ê Ç3Þü½S!åj1e{•¤mSÑž’!a'íŸe`JZÕ"žùE]¿qË0b‘/ YbM|2}6è\J"ç´“#¤[Näûî_¨ûÓ8°¢vœ–©qÑ(rÐI‘l26Ì q:{~oÿ—ŠÜªGả’`ØÀ.x­¡ &‰Ç±Ûïl€ßŒõ`dÎÍ…ì¸Ðt(r¯õ(Šðªš›6\;yóóãî[ûoÝ ± ±còðµ*ƒó„Àºgæ!b¨ …¥Ïç=ÆïcìMwLôü-/Εè•Ñi™†«Ã$<*µêÖÐÕ)e;¥7ä]šðkùp ’b-€ªiÐöIPYgÖÙ;‰¶ƒkÒ=Ç\ã<LÝG/“š"§|Z1“¶Ù^|þ~a{Qä Å8”‰WúY;§D§ Ësapï¾Ê%¥P_«w‡8š©42·÷/-­¬3’‘;J©ŒÆ¸±õ Ý}½î>œ‹Ùcú¤Ô©“ª®ì)*%ݧvn Œ€¸`-Žh/ÉüÌ%-s=__Œ¡QÓà;ÞÅ^§ÕÄ}8f1§äêÕ*þIòËn^«‘²”A“_lå±ë5sTå[Îr=º›Ù4f˜¿üîáˆ?‹ü:Zít´$®“‹HËw!Í:}Ý»º#ý’‡~¹óL!ü !HÏ•6ßžõíž^­04E—Gˆð†²F·†ö~šµ½È¤Î‰"áat*Y€Ê׿™Œg¹ƒ 1¯îcßøýèŃz7ˆ‰Q²×o‰|eåÊã;Ò•iêCïBÄ`Ùù>xèuè™F¾¬aéüà|3úw~Â\¾çâ•¥ü‚`R*IEw­yõý±³íû&|¯)<yæu!·/¦®.z¯aFZmäî>ú (+Lž©&gaóips ó‘‡3s¦ŽnWŽ2º~Õ.¥öÎ Ô :»ƒ0†‹ö[Žã_Áð¢8]€²C<ù ±2²X[”öíz9•Mðª[Iš~n¸‘+íC,¬a ¿á[ ñ1³¥ìaì…æó¿ÐÔ/ǹb…ŠMï¿uœ+”Z.†#d»_ÎÜ»¼*¤…e¸õ…Näqëij¶ãªº–+Í ö|~µlu‰ÞåîH˴ضŠéA¯Ëº1O5îÆ ª¦n»§|Y9[ùÔ[˜jÉìÙæmWnÑÜåËÑ\å$Ðù¤?×Ey϶ëkaðd®Ùmö­¬®“íJ§#ûJ§‹ôÆ,½² Aqü™'ø!5ö¦Cu¬¥šf-ÝþƒYî}Ç·õÇK7ikÌrÃi¯3nª‚‡èg°¥L0¶õ«SN= [Ôxš"„|2½iÔ:ÛžhÕòø@É »\;÷ÁÈÜüŒ©Rîèœë 6œopù•ÑHäÒ.¾ÝÛSŸV‚¾²îñºIëÝU5gù˜¿~åáÒ™j ÊºF±b]Çn8Š3xUŒCµ@ÃÒœÛ# ‡&%¿oé0ª9è5Sõo1ß¾ê[ ò—L všº<HßUE¢‚#CW\Êþ*?.Š—"ÜpmŠ�(ô„Ž”q»ñ°D1€!÷NW/sG¤Ma Öµ^<;Ë=÷´ þ“;X™×r¥“ Ÿbp£l­ `%˜“¡@9üÞ@ 'AöÝ=.½XÁš1Ý7=éä\{ˆªzÅà,ÁKÓ‘ÆÁæ ¯¼<¯¤m oÀ™�G5n�ÃøÖ¨\²´’äÍ»¾Jâã®H¶Tk¢År@ѽí<]6þ’kèn£Û2ÁTt)gÕqOËtѯ¯*{$¢ΠpE9vÝ{~½øäÂh}UÑÊú:mI̾óf£œpHÎ KáѶçO®“noä'ÙRøißA©õh#4|Mùg´ Â›R0ó~‹dhl{íT%'áê$¯Êºy·Ë´—4BWÐ)‹'­¥Kº¿€vÎœS¾×¶î¡¸2ƒÀŸf˜äbMt¶Ý´ÀvÓ‰±úJ áx g•éý�ßß¾«÷šÜk_O³tY¿„,T]Öƒ«­Wp¾ždß[ ‡­þ¥zufû%œ.ЖÆ@§R{””í.P÷nú ½3³hø¤êaF}Ùz”W|ú…·óaÜOPÈ•ÐáÍì—º¶Ñb¸ÌíGÂä83©NXI-ƒÂ0ãoVþýÍ°¶ðP}¼òß CZéwPÔÝ8Ôã—>kêA&Bæ¨ –'<|/¦)U.sÕy [ÚFbÇÞF9�‡‘EÄjíŽÝï†V‘“úˆ8„í{þýéiË y~Í©:‹CôÕ5ó\e öûÂ�@AØ`tBL¬ã`Bª'!™9öK²"‰ŽbƆÓs ?* ªÙj¡æW¸sª ZVÖZþ-×Ãw{§Hkp´MI5„ŠÜ¡G4žh‘Ú<‡UÌ×{®¤Æ6Z£'Ýþs³püô*[~ªÐ—tš5õ¬O™OxûýžOêQ##‰ÎePÎG¥hT.¿»<ë±ÞI%\^㉋…–p˜ƒ(¾N1Øo‹V=ö)þ ¬A£¦êõ0ž÷3¬>,J”•ÛÃÑ—­lù['œ-„ùéËÂÚIèGSú=[Ž†Ú^ä³ÏƒšûjË?+/'ê7•qºÿHéP›m°cg7.U:#qõê+‡èDæ<VTAl½d»ëwê¦sª_vÒ«tWí ¥qŠ$}äy�œÛ2ûæóáMÛCÁû©Ùõ¾Àf]ÜÖC1t¨?&裬¾øðʲÖéiZTÞ8¯¤·§5Ú÷êåt8`tÀ¡Ž²ž…´.ÆyZ<›+x’pðÄ;óý¨(úAH+­•«D «6L¼my <yãšZ¾u‚˜ú;ªËä &ì1Ö‰_¼¤‹;TsaFü{ZbÅz24T¯mbþ¶ã¡ï£ŸtÃ^OŸ¢ÿ•I¶¬»[ø†|Ξk ª¥=š…RrVáÝ—+\6×Å”˜VfÉE¬¸×á·ÿóÁÏB íЋҶáã5­|aë03d8yAö�¥…Cëû'¨t?ø Ù•¬(>TÚéHwâ[hðÝZÅÓÚzÅÍH….嬦wž?éVôž«Oƒvî$âGš =û±Þm—·/ œ-[¡† }dï'žGWÔntѽyI¯9+ÄŒ‚¢ý½²J ˜À,ä^ nˆC<½rô6 ™Á:‰AeIÙÛî‰p tyþ‚ÈYö’ë"˜Æ˜ªêÉ«ºê?T°Ô*Mh8äžãÚýËëÁ­ÓöüR‚y ?îYÙs}®[̹u¤ it´Oˆ"uíÄ­ðĉâtôp²è-Íõ0tVÉ”²±h»—¤ë"ÌRíÄq'â0v7[W§–]íNˆ\)BÃ8µ1!Z‚@úC~=¨¼èžÊqVÿÐ%EJÁÒœNvŒ*ôô²õ<ec”‘Ù°I³>§‡2ë°DŸi âmMg,šý…ûí…">˜8‚vÇͼ Ÿ b㫨Vra”ï´ê;¦°²L&ã{õÀñʶŒ™ðKOž[ÆŸÖ>¢æÆ}ÇM{©oœX¨*£5PÖäÎuS „˜ÏoŒžèn2–¯lØ}aNËÊt¼¥òßœ°Äï¢ÝeeÏ?|œ:=Sœ.‚²Óý�›.õ–�ç¿p1ûE–d±Ë›2œôå©U£&I3zchížWî7×SÊ£ ò÷?uð"ÏKA¢äŽwéS˜cYkà[V3ho nQõC]S©FgxL´öÕs–}GEÃÔUAb›êóoûð[)ÜûBPåª4žZDZ`eQCƒ;6•6µ;¡Â«Ï6Ö=eLÆ•ŠA&æÝ?fºã£æýEð7J‹ u8ÉÈ:£’ó„G¢2ñEüã9^JÑ\¹² ÛA8•ýtôÊ«êU;ÂcÕ3bjê0KzOÞýéÞuÙ¯F­¦ù©k Hƒ§Ç”¦¨{×Ç ÕÂf“ªÇû±;éÈ}jKyëÒ�8¢3èøÃ`±~íèXS¤Ûž±œ6Ÿ¢’r¯]ÌZëýùª|ÃW”ãÒqÉgèôŠ•¢S‰* 7舶`±ÕƇ»ÆèF.ƒå¸®Å¿î¼sÊ9¾Vs¶©"ìÒÙâ• W†´ÖŠyÍ ·ÞˆßÑ)ŠcÍ™»åR`˵ ¶do3‰\·ÕÅ‹uFìr–‚Wù–~[ºÑ©6@äûzvÛBýÌnH‚R~èTå‘!¦'º§TœßM‘œDP^ã'º· ûßt|U(\VG£8P5ªé½ªwHðk*Ž“©Z‚5Œí¤æ{í,¯ÕPßcUf�Ô÷âAöæ²85?.ºßMO5Q£rñ¢à¬ÞM…›?Æ!Eaå¸1[“ÐA8(o"•™ºƒž ü^°œw®îþ–2Ê<�L¼6E[ö'îFÝ4”€ìÞ}ùW½×’Ì·i"[ÄŽ«’#l’p™–óØt÷xl,­¶ @>”ãɳ•?îV+JCd6–ŸQ÷±§l)­Å-(sµÒÎ"ÌÖ¨DÜÔ¯å;ÖÉF�ˆ´tvT—fÖ3o7"¡q,0UƒÐW§‘¡¯ NGO’ÕV7Žf¶nÐÎà u²j¹Ã ü¬*q8 õNåi‰¼Ž³ä˜ûêY´µÇÐFýo:øÖ€Ô{jàƒN•óA—=q]1Wš€_RùŒ¤*LY Ê÷ü¡ž9Ee¡[J`¬žQ«£šU·‡ŠbØ´ϸoVËí±»z_Ùv{|~+Gà/»}iwÝÊÞ^ho ‰3¿ E¢šY€zj%?ŒTÄÚŸW°RžVÁI’‡ÐŒôÎ'VZãˆH¯!h\ëÒ±êÖq´èQR5ÒŸ(׶êþ˜:nvööÑ¿23Äûê“ÔAJ)h{'JõjØÿ°?#›ñHÊ~BN Ï)þ�˜oMqTc1dœ­9yîró‹ïIÈ R(d+òÒºýJ“ÅPÒ§0k$MbV`Ã0P˜+ì'Ú¢ãµPùê€M¬–›Îeat+V ­ßMã9( +c:#pÉ´>ºÞhúüɶJV[Ck9=þÑä¹âÒÂÅC'Rt‰!Pç!½À¼=œÚ;د(‰¾Þh¶ÀHí´õPdÚ;Ñ5Ìžš§7üõ9ÚÛ[Gl I‹< ŠÑjÑ›·WÚ3¤˜²5fÖsm¦[Ïm3,Ð YŒØv²i¼E¯'au5nÍ(Þ-%Ñ„±%=ƒùè Bz±Rñ–—´Ü …8± æ!É‚ìÝWS‡dúmEÈiºs±­äÅ¢Adœ­òV÷ožj:Š»m‰?›YEVž43ím6ú¼X¸<`Š ,h½ÉÇ«F@eúò qÐà@=ÖN¸˜Jõ¾à˜©¡&Aƒbbvl<?WvæVÞï'eUåÏÕù¸¤%>|j.ŠdˆîÌÕÍ­æ¼ùWæŠYáÁäc)¤ÃTIcÁô 1†â½Â‘í 2à¿IÍNÁÁ»¶.\àl2Ç"Ѳî;bŸ$OQ<Va¬R²vÏÇ,¢ ÛƒbsØߧ)-˳oæÆ™Ÿïn„“—=OuÿDõ«LŒc{fš¢Í°‰E¯£dœº£ÙLè€ò8vmu˜þà'Ë X°¸}WÅçÑóI63ny†¢<‚ö3«“<ò:KHLƒ¡òw­ ›®>}¿ÕãìºUÿ¼E¡×qCÙ¨öÚAà\®J\ÿUW˜YÇÓÖÁ9¥ ±|³ó¹â´Þn±>ôgdn¬„,—|ÔA ²šwô‹lÛ P–§¶r¬`8À°ú[sí<ÃÇTëxPè« °î  @Ï\¼´^,`~dлÓ=6 ÇÃ7­$Zùù>³2¤¸~Ã;K½|qYé¢Í‡Œä@w&ú<ú ‡jv�s Fâü5÷ÇÊO«3ÓKIhƒ]tb\÷2kè¹ýéþy‹k¿ÓêþÝï©x~÷ÿ¼­¶hWa)†¾ü¿A¶ár^4Z9•Øv2"Žª&%ÞÌÝL¹Ã?êK%Úlr*h¤èЮ)ª˜w¶"h.¹Ì¼ûÚq&|è[n`âÌUÑMÒêõíð抚<Zo¦œ±Ïào=@LþØËt2¿âšÕwinj+Ó쬣Í*¡wggá—¢Œö‚%‚ÑVßR”Ù¾¬-ßÍÃQ\ØÙa4Zôuîú�sk 9Q°À…úÿJøÉí“z—‘€n,t]=í¦cã¹@NG®Ûå3wìŸø *`R„KϦ©¤h0m<·:äXñ8ZqøØ«›ǧ<qïÎq·ßâںȔ¬Ç Šq8ʨ ü²5w+×R´cUX@+¢ ’Fõo3ãòy$îËÐ'±PÛå¼hª¤Ý*Áóîƒ*³S6Ð/xĺ …ã“íòDÃèÐn›1öäœçú<ë©ßÐ)RÓ{Ž/š¡Gqù‚ô'ÌgZVÖ)Ë”ß%›’«#ž`y—Våé4Ãö{rÓæ=öÖ¼Þ›À™£á…¾BZf3!AWÑY….<RÆÛôVSþèAwºmT=îÖx±SÆcdÀ±§½5'§>{×jèΗֹ[7‡–Rêû hŠIB㼇\+ê´­GL 8 Âtt±/g[Qv­,dž6Ùº7pUÌèÃ`âܶ㩅 À3œ›¦q;Síò¾QuéãnêNh+t6be PÂ@w;óðn.Ì)7r’ïtÄâ(ɢ̗̺4’öèrRë™mn»R4/mî³Ü+ñø©ç,ˆNÊË Œh¦ ì<žÞè@¨Û‹)/[½«z„Þc­L+òÒ}¶m¥Î±¹(²á&YOʙ݌Žb86‚Ã|´ÎßWDu¶ÅËGµï& ¢ý`ŒQéþ;ñ(Xr•NØŽ±Œ›•ðï³—ÐÑs¶§*ý3%ØRjØ+‡Ñ¶G O•`;9ÑSNëw[£àü؈€Œ§ ÏÂôµ§hc ½kËAÏg2Cþ²ú*ƒø¨]Fn,]EàÈ‹þåx¼õ;‹Ø‘“ê—=€/Ñç·'½in''|ºí‡N“OH ³|Én�åsÝÖÒ0RQJQgë§ÓÅÌËYظJÖ¬>v«±P)µÕ¸w{d{†u‹.Ë£Ÿ£œvYwj Ë͈Ңƙ}’À$r•|Ï[vYX gpV F¹_–F™GedtB·ÉŸ@6#2΃ÃØ!£9sßžu¡Fº…;lg?…TÏB÷+ÕÿAeù³`ý¥älD‰§¿Y­œ¿(�È’vmæ®Ã_}õ å5°AŸ¾Q]áé }Â`¡Lr°�Ú=ÅÛ]â€êÃÜÚèB|DæçÓ}PÀ–‡¼ÏTö™NN+gw„~ë»9Ó~ÙÑÞBùX¨Fv§wyÆ/æÖ½U÷ôTÅÂ{8A¸UóÄþú¤F©µéglhÿC==–ñÎÃ…²ñÏ'¹åËïÐÙ,:È …Ûl<[,ULàNûàM „ýË.®QûÊŸÏ_± ÌjñykµqÛ IT_ÊìÊÆû’Ù»2ØÚ]ÿq¢ßa$ŽÌ¾"¬; lÉ V Å൩Ù8Ò8âA¯Uðô ´.,K½;Òá*_9#踌t-êÌ 4%OUfÕÐx"v �d›³W‰U™7ƒŒqb|@ 5i´Åž”õËCº~-Ê€£ÿÐ`kÞ¥â/r úÄ›Ü[.^â(( ×Ø<ŒtÖ³*ÚóCÔçæ3ÖB”å8¸þ ¬›ÅVïu1ÊÐã±e0ë¢YC§©;K{þç-­–Ù/“¥…oh&´È!ksöI§lW|¨Ub‚Òõ/–ùc¥gß]-ý¨Èݬƒ%SfèÓFÛOK×ÃÀªk0×;¤CÓ±ë €Û>¸Œ3Ï(LܺáeE^ð†‡/fk¢J7a@&æ ùÀ¬Û, I–Á´5fð(B´]à£ø¹KìÉ• |bû­fÀ�pý¤ÂÅE¼JNN<``Îô%l4ãâÛe ñoC ½=8 /È Èé@yM±ž}–ð®×技ï<ØÔýKÿHM}•eîÙ£(ˆ[í#¹›¥û`dØÁÒîA- í ­UÄIÅL·q8;´Q: 41rpƒ[ï½ÉÏ;éºÐÌ×W3åÔ,©mè·gx»AØS¼£D’¦uô~Ö•=5«¼¸ZçH0œØ2Èp&úLðq{À§¦ºed ÞñÀÕlúzO™1¥<÷jMº<G¡Ý­ót„Ìô Æ»’YÖÿêÐÙ0ciAœTMÕ>gîKYúoÜJ ~ÍzMüôS–)òíd+ëÉt`˜ä¬ ¥GßûÂljvp!åuT“ÊýÞwzòt¼~#ìUe Ìôé(ˆ„½ú1!‘û`)5YZÞÚ¼AÀ“? *âÜM ^Ø`{ö³åVÑÞ‹k¡óEnaܪc}RùHÅÎU]—z68} BWpÏߘ^â³x/*ÓV£©ûj}?«Ð¡«·2¹ä˃¢}¤ø%–2¸À”:Ò¨¨Ú{XX4ΨY®7œê~'\_WõXsÐò}ª<àw%ª9 5T5Øfx ãe¯~/~2RŸÅ³~è$Ù~ˆ ð–«ðTç‰öy:Û¦¶  ¢KÈ z:„YO¶¥«U"ÕQ=¢ÊGOþ¶~[#ºärv:¾mWÉÑXÕèÞÕÉ,OâET›ª¤ç[O¾‚ª~çOT<ò"»¶ÝÍ«­»¸a*Yú ËŸò˜ )ktç|©¢»FªFª?%^&I\8Ë$>àn>—ã剻Hƒ?†»ÂÏ}  ©ãíZfŸ ‚£1ždÞHö)4¼LÍãÎ à[¢G§LÁOŒ›åtµ’Ͻ«Er\òDpòÓÆcp¡ÃÓÎ>l‰%Nþ›:ŠÅ/WªŽ2Ð_ò§wÆ{xÚé<À°—"1YôŒh<ð@Ë™UÓ ¡§\+LŠ}ÏU¢Y–•):´µW} £(õ¡Pú‚hY¼µê�F–Áf™†7ú«“Â;‡¬~é£oµ«˜à—¬É©“7QZ«Ñ¼.)ôÉÂd j¤fíkÖã¿´ÿ¼e¹È÷P,.ë®å1Ϧ[;ïêêVéÔ+ž4RŽGV—k[%Ö¦ÂÈÄAücÇdÿrùiщť6BÕhùõ‰hY5Téèà @[Ä67»®ðÐä ­”o:Õ.f!‰½Š}UÌ·ðø#Œ~k€s†Íµ §NBn/~À¦T™/¿�u˜<ˆÖ6Ó¥ÂB<•¬{kÜM_Rèt““Ø”B,6•Ì¾1£à¹Ä †A*ë—U1\ï+1&íÕ.a§BùeR3ÝæcZ`ÖÌ&¥ßgÎN¾/Àé£[r[„å.}å觑Ÿ4G?›gÜ ´aäë=}cK¸åüÔòÀ/k‚]¨ä‡šIv¬¾(Ý^‰Oéÿv>e†÷Ñ^p¾Ôþ|¹/t¯éú±nMÙßç U¿†©rs'IæØC6ò¦ìóhg¸àêNªCg$¬þŸµñ¾ù³ø<…gœ¨cÔsû ]˳z.Ûú¸·]M×QšÄ^ïTüÍ‘ņXÝw¶¯Š¬%’Ç{úd”\ó1Ð7ÍEb°ùÉMûÒ¥×™Ý7cT=äÉ©A>–ulÂAyúSÇÛ<37† Ä±íÑUu oÎûp8ÍfÍ@gÈj³›€»¨OFs}š6{L3NIq¤íÒv¥ŒVˆ* ¨ºîK4mK[´´ža„¬ªo …_ï&ìSÓ˜<sA¬p…oˉxO¹³4÷%75 ¼y³ÎNØœ`»**ó²o¼îd;vˆ*ôƒGŸÐ'œØ]À,›ú»±·TpŽAG¥±µsŽi”€^2å+òÄç›BawûÇuÎ'™3zk[p½S#ùgßE¹†@í« œ,¶š\Vs”R+ãw_³š‚yÑV´“G¿rè‘×÷ï& ( mÛƒHm.n/îkEW‹T²„*íQÅuÛø¯/I¡J$βô%9T{Ø Æ'LŒ‚ÕÔ…RFvSs1m¨_‹)X˜³ǧ@Þ¤AiÇg¬ÁÛü yc— '‘°±˜Ê ­VyÉvTÓñ$.&«¾¾l‘çHq&ÑÓ4¯7]g¶šsÃdÀ ÐÎL‘&!A?ø¾ö¿ z9†{n¸ÊS—eg7PÃëÝb®:¹ÈjËA U›]„­mXe5æO{åË¿Ø®,"'8_°:2‹¡ó”+Õ�ÞäêOE£"7…jh�À§& òµöBV¼ÓÌäÏA6ÓŒ×wo´ø ¯ŸzöÄ܈ãêþ#¥ˆbõÑóRý\œ©eÓŸŒ»¤Ï(††VWîV©¶‰ÈCgC_¢y47¸=@Û„O͸ùúÓ{;ûi&£` é4ÞZˆ<02cHýÓ˜3Þ×í[]Dœ®!ïLi…-Å«B(vÇ ý2Fóqöæ4¯ž}{gõGÃ,b` Cë@3¬ä°ë­à¶°‚µ–ù;�ý0x,-ª$Bþ.VM“/Šú*êØå0)§©sdƒòXr4ñÞé3]&ïq¼ *=뛟GhhÖèˆÉýPeЖ¦0G„sˆ?–ò¢ ·µdÆž_ldn©,%ÄÃíŒl¸{· §›°ÎlBO,_wžIÇ´Û ³àø�µóòÓÊK'Óñ8úðúOû¼bê0X¤DÏmQÔcŒý”eácÒ¯ðéž`4ãOƒ#(Õß TÉðñ!;Á‚wÀ¼5ЦQ»@Àž[WvknS|~W!ð Ð̵»~–>¸7hD;êw‰ç?Îæ¬ÜAû´3Ã丛|TÏÏÝ3×´CF:ý6¯×ªöžÁé†4ÏŒäïÛ#¦j}6WAÞ¯=ê¥G'v€žKg}¦mÁÁÄ‚k{Së‰^ d¨ÐÈ&õ=›w-·¨LÅ!˜ã”ÝCwH®­ÃŸÚ— Êl¥é´L¦wwPÒþ¥•5è\¼é/˜ƒ¹¯Jq½ã&ûòÑ!ÄÖèD·ÙŽpèÿÇF‹[wšA s¿¼™Šiùzé“®ÂÌØ·7ÍhQ:›sÙ.¥_صÛЬ–»,9osª ¢çã×Îgå- DøIÐSnVÍÊDOSÎû´îx‘¢˜…¾'¢Î±ÑØÇß­×cí¯‘<ÄÙûÍjz(PLÍ(ªŠÄtÞnwÓÇ.†‹IPþŠx V£òh_úìIÜB)6j;/Ъûè¦#´NCjSÓ&r§öã¦sgžC8Ĩu®q†¹l8;@ ñù'G÷8u*""VÈ ’wuEwÄâÔíQú ÜHìùÃa•è~é·¥—0kªC„{á‚šW¸<wSʤð,w¸Mµƒtn¸U.÷±£ð6ÉÌB—gXæþYZ·ŠAâ¦ý5.^)Cñd9Dtv4-4yœ<xx—Úù`¼Ð�Îo†Ê¼›™EÅ7x×°ôEø‹xsÿYo¶k­f C/û®õð5‘? H™#:Òq×nÕ2Oó¯ÕÅú¿Ô…q2¶ÒÏ‚iŸé»F×B4Tù0ÐþÀÓ‡(•$õT˜&Ol¬­õPYâO(µˆ±P70*;E¥› *J‘øž£æÞK×SÛeìv6ÁH¨V½xJ¶ýIÄ?uµ¿ÞÜ�Û)¶=¶‚šÊ‘Ýxg­WµÙø¸¥5€ø0] E§ ܺD„•Rx‚¼)zj]}Za*ìÛð “’Å70wffÀC±8Õ^‹‹ŽÓtìÔu íüM²jÙh<ÀD@MEw ãcliÚ sì››]KrÇ ‰‚0çô?mÖÞH†é«Ð¤¶Ý(;[ÜIS¢$uãnNAŽ³=.= ¥ð]ãädpy(™ˆ3ÄƇ­U @Ë…ªŠ@aÔ�ü¿·zªé)»+ÚD ¥_êé}ãA›-³/è4>ª(/<ÖÏT‚]Rh÷/B›ã*÷a>À”¨âOgפÁ `€Ef ˆî‚V![ÔY<Œ]×YäS›è$h;:{¾õ126í¼³Þ›{¦x�æeLC½¯n˜Mñ42ÉM…& +Û±Û=?hlÎG uû²]TxCYféNàâMžÖö¸c¿nKexU¤Iáî¡JÈ Ýåpøã£Må­ä&ÊÊšËâëÝ_b™a5‰_רžÉˆ× æK†8ª}aÜõøßÍ-qjVÔ÷t¢]fOÐF0Æìõó>ö8B5† ½µ¢J“iÕJ¯ß1àöâ&E‰“… x_¸CÛÙ cÑvÁÿs5Õ'|l^hA¢’_G9ÓÄᦚØe“Ý)sÊñÁsD:fíöŽ »ë{¾f¬s8Í´dªãèií/lÄ Ö„Ã¿šª®ï_x3Òب„auäku½Š€ï£,õô¥Ïšúþå5ÊKÓZ>‘ù×VIr «QŽ½¹*Ûr80îN˜³³j{¦ c£{bôžÖhxn”þQyE¹1Añé«‚{œ+›1;Ú¸e³¶tm¨Øíèüd± 0…x /Wù~œg 0|œ×YÎg'€H7ær…ö9È y­±|’J ñzºáS½dea§Òvr»·÷é¿k¾T…“>3î£ÐPø>{†«iò<kF•©^6ÔчöúÞTñÂM±Òð\:yvf/ÛúzðEñ]–ýδ�קþn¿=N3‰fbe¯yШÖÚ5BsêãÒkNôwª(ó`õÌ[^í#(‹Û=\]‹ÃmÎ*ûŒ}pWv*æK‡eƱ( ²^áˆeÞ0À¤·Œzt2‚yÁB+3¿Bu.žiYŸL ]²&í`F¼Ê<8´8cÙc¨åg9w?Ø~WžlÃX‡1¡SÄÉŠáè¢ey„âËäuˆx:¶žï°òÂ×™cÁzßÌžàÌΠífỚߜ›‹E6“x$-–µj€×úì¬h`ù§ë—J÷…ž`ˆÙsȦՔürˆ ›‹ Ü¿àEù4¼ØUb|—Âàr(ƒÜâ„ø¬-u€,_øÇ5—¿2§KJ¯³Oðó6íXÇoX(¨ÙߘÆ+ßH³M]CK]ˆTæÇ?õ7ìïFUÈ™CØê´™ˆë¸Å$c(áêï^L#¾ÜW˘mk>ž&ºÿûòs¢R¢»¼â(©¹ ÀŠ jÔ D*¦#2ÙqZ Õ~pñÍ]§KÇ¡†ôÈêoG^wê1ÊånäZ˧ŠóŠÊï»±I)šþñzc´óÄUœ]=“ѼVõ¦k –ã¦ïûOsa?í󠜵oˆ‚¥ž:`³©Óà³"ÞêÀOÍö\«OÇC>P‘g¼E't‹4TæFó bªh%9Æ^”BñbùtŽ°k`²-ŹIWN§.÷·ê TÃ./{뤙ï ±V…ꓶmhÝËÍ—ôŠbJì°mÚÀ«±>sed^¯$ë<lŽŒäšŠ¶óì,¹~áÒĹ³¨$P“”c³ƒ(öã.‹’üj´Þlé—%[¿…³=œ:¡/ ôäÛ( GžHÐÞjú2HÛVµHé™~1‹ÑæÔÝÀéÅ~}2»¡ ÇÔV1‚­;MVi˜/<ši_ÖÝ`_=G{)´¨r>R‰áÆŠQ‹C­¼6Jê÷šÝ›‹§zÞÕb­PŠ¶Z—””XROæ˜)ç<[7wÊ›*/.¯$,K–I=DtG'Î%?á ÚŒvs˜¤n¾zõih‰í°”jK}NƒÂšn4Ú\^»àÔ€-U݋莸LÀザJDÇÁƒÒ¼×› +m›X¶Â¦Hšôý {/îB[3ßy‡ì0 Ã6Ú‚wa)!›î¼Œv‰ÜèG oió´Ûœ§+‰ÆØÍïÌ"/¾ßÜQl"=žÈµAˆ…‚ûK‚ J˜V¶¾àð~Zi¾ù[ùÞª°$Q‡¥\0H;mb$¬§±?öÜ’}°ßõ«q™’\Rk@_²AG©éN*Cº ¬«5×Ì ÿYÍ0ÎCƒ•L-–¼Ñ¾Âêð-ˆë™âÁl`r†2ŒiÎ?ïö'yæÏWÂjs:B4üBè{AkjH§� \: (Ÿøæ-ËóȘÁª´L@N”v@›ÎÔ´…L…YÞž©j4z–Mgüfÿ&Y̺Z åÐs¯,Þ‰Ç]\úòyÒïpž˜RQçé÷ òÖ£Ðø®¢‹Wy™za\þ”F#"öÝž½Ìžgœž5„žûºŠºÇp¢ÀEÐZG' ð3nÊSqÔYv9Žoµrdg ,a´&ÈÎËÊnûQÝÞ ÍE‘Ÿ"ÏÆGÛ…: Ç©e9ÍÅçiu÷¸zîZ-횺+ézG¿àù¨¬kÍÄ8¬~šˆˆòØ(øN§=õ&9â´Jw+WEÂʸkš%Í#òDü´aëG‡È‹Gg°ó²~ã!•×†w›S‚¹¾R±©²šÁT° —8ZÄCwp†/@lÚ j´ì~Í⦠Sj°@ùŸÎý} «ÃI/œàî(Lñ9Ò=]æ2jjD Ëç‰ÞÙ{mÜ‹ÑOv.*´ z3ëÄDK´Éx¸H1‹ÂPB°¹¸£ö®}'£œZ¡V¢Ï7kÐÂAÄȃùdÏ6='|þë¢(N}²X;ô²Ù Ä8קÁs•ø©9Ÿ¨[ˆ¼A$@±qM&ÊP.n½5¨S·”®}à× ¨>‘—›Nq’Ø:EˆÃ†ý–w–‡xÇÇGSÖ$¾¼Á=õV`á™è‚­Äĵ%doÚI­ Û5ÄLE§é7 Ú8ós€¤*ìNVQ+‘úÖêîh»A¶ñvïêµ]RúÙ^ j/~o=˜ÚÚóý ¨=�àݸAÜà&HR~ø-ˆÆ2§Sw’^\Zï½x8:3ô*¥Û—öÞHžJ]Éê–v»|yèk;ÑAÖÖ@Í5¬˜±mE øŸù˜qj_ñg,-T¸%Ý¢8¨,Ì)nõ;™¤ (~î’D¥EF•!0ì?R—––¾ʚÁ’–û^¯‘L)œö?<qZ§í€ô¹ë=àÃrawƒì™;€µÐ§Ä0gB¡™ì[×LK2{s}˜Ú µŸ5÷RÏ<‘ âæ± „pò„Oa‚<ÖßëvèΪõ•Îqß-Òo ªª_±¨ ØZ*ªêŽxAô+ªœ#BÄ©8¯t:lªGèµtêÍót¨†±]=¨z œ%QþÁ—%ÏV¤eзEu~^ûN1¡›Uméc0I{q<œ/“ùJ7¦4ñXkÐ }êzíÍãpO8QV^§Ó†º{É‘½žWìá»ÐŠòüp0ÿ úgÒi9œöÍÎ¸Ô Zfûú1Î|z.1§ei¶vÈ/úCªKçYÚ ðÆôÇ»ù\Ó^§2Åo“êGŠ/Ô5;6ÑVµ:UlOÆL‘­x’ÈÆõh¦•¢†-Èú-l‹ÝdQ±šÄpè'6pö•{{æ QÝ„µU¤ê–Y8u£Ãüè•ï¹ëi±ÊÅÇÙQçækHÝïú~u°< `/û彦¹’¾H,šÙ-';>–Ðä¥õlâóòõzÒ›{΀˜LÑϳ [oÍþÆŒt5Ó¤É(çkvÃdí3Ø*E*÷]íÅÄp"õ£õÚ¹Õ±QÅDŸ!í­ $ˆ%ˆ« û—†ng±x¯½º#œ9ûô(ñ<« ¢Ó ´§Ã‘Ó ¥Ò§›œE’½~ÑñPM$ˆ`§FGÞvT†q ›isžÈß½ôa Ê i¶àÔØ´‡£Sè×ÅdªGÊX»Õ‡‡°²g‹»$ ¹ñuãÙ|Õ§~Ñ IÊX ÝIÕÐí–lw_Ï=È?Y•™ïÐ%Š$È¿Q;`¿‡ †fȪw&n"fz­"…–]4)=È”ŒºHvgdùs2ÅØ„F l¤ÐÊB$ü¨O ÊÿOT¤"-¬!K™  *†ÌzPîpÉÃ’þ Jx¤†°ae)Í6†¨"@¡¾dWZ|žû#fPÆ{W^›÷^TÀE¼ð¿›ÓŒ›†Æ…}(´úxV‡ã‘åEž:œÆþ˜•h[@蛳§°J‡2Ê% ËÅÛë;…N˜/`fn­Ñ“U$ºÓ½Ø˜Óæ¦Ày'°[9ioÀ–*Ú›9½-…¢ü}tê:3 Â/ãPs÷ýlÏ1–•á`€]{ÏR”§ÇFý"øüìµòÕ²@9F ç8ˆ· fH)5"skˆÔY/åeþÍ3¦ù‘¾qê!Å“Ç¢b6¶bWÍø܆ªðµBéf¯j¼ë \uØì—c”Uõ{zw`U  Æ»f°·,V'@xës‡–)7ô¿×qgn̈A‹Ÿ?'%v "Ì�Lê×1\'_y^v·=ÂÄYáT~¯ºgU秇4Ú†�îƒ8Uß»º¤ÛqŒ)Ì*ƒºt!‚&ç5ßïó wý ;ŠŠEK3 ú>˘žiyEtCÖëñìÉnu' ʸ6Ôãcä“çÅP“³ßMŸQ6ßmÓ·EàÄ£Ù©HÛ21EõùæÏÄù¯=E¸1˜L½²eYùðèN}~­/ŽbE*º)[Üj+Ãøa<q¬+™©°C‚qB{UYÝ4˜)1¤ÂL²îèÔá!rf§‡t8ЩŽb÷Åð bñÕÛªlaøIñ|FC¢ó´MÅ‘N€ÓÖƒ­…9ŠQȼ )ÏŠ…«@A‡PĶ7“:=Øz÷Lpw„:”mZK»Z iK<²o9È÷bµ/ƒÈE`t$vg+2ÏÐò½¾ÜŽ]«KäB ª({ün=Dö¢øÓ8lØPž`ä#„W’e~âJ ¿î!@eÕ&Jæ’}‚#òùf|ÞÕuQyÛêVAz\/ÂÍÆ ¾¼6Ì=;ƒGwF [13À„qËY!3)ìu?\ÍVôÆûš,…Xr@\wR?€¿™Ñpšç‰A½È·Œù'•Ò>ÞÛéqäëÑi°§·->õmÑá�Þ˜¿±p–Y€VsL{]5%+è»I—5ÔT„÷4̼®-Àî `u7?ñ±¸•(_}¥|@›šúœ´Ì�)œØI¸€VÄÒ^Ü`¶Ü„¥ †T0¨-lHŽÏÎsžÛ„ç0ñƒÙD‰V§+£¹‰*8L‹¤BbD ï(**V§£¾<l .Y’e0ÐiÑk¹çä7M¯€ö1`oÓŽWǽäè¡ö|¦ÓßLQmLÎú³q¦( Å6x›zP]½R^³¨å_îø±ñ¤e醸óúM†›¡PŠÕG `[3Vþ5'Xr7Ûhȶ*Üœäl5>[yâßÈÇ& ­ºE *M7*#ö~jhM.¨Í9³e¬oïsd©Õ¿ÍŒÎfûÙçÖ“T¢ÿùÐl£Òì¿2äWH¸Î?1µ‰á/2ú ^Ô¦ÂæLXV¼$V^ì|ÚÉs—¬q¨Ã<7¯•–Xñß2Õ_;ºYöÏùÕ4g®ccé±TÃèf,2îa¬‚ÍFöÈ¡äå‘LT¬sò˜=_©Zh»‚ÖOß{J_á€Þ3Tc…­D÷Þ}gIÏ‘ÑqH¸ ƒSCùØñ‚[hAQ‚¡F"óEsÓ£Xe(Ñ8YJgåàÑñß@·eËųÓt‹½téqÞÛ¦Š/í�{—¦u¹ wO\‹ ³Fà/:måŽn/lmÖnHÖG›âd �øp8 ¤-ð’xƒƒåÅ|÷ ZKt÷Í'Ѫ?:èÙªxO; W]uøèËþ@¹[–pU+‚l£Â*¬ƒ” V0ð²–07N:e¯f½#n±[;UB©¥ÒÄÂì ‰ù‚U©ÚQ„Ö»ÿX®#/·…Qªçš–jºU VYÎNZ‡ÿïj’Ž“5ïR¯®FKçæH»@–0jüdfk¬f;@?µ‚%æ7™Ü(ë·Ú“- î›î�øAZ?RL¬Ì‚/)[üš[e¾!·¼ç¼1›Gv¾ ÔFiÅô7¼˜.-—xÊD{k§Eæ!DI0¦AÞh²9@ãJdîMʸ\S¹C¶6ë݆ˆ®q‘® ÙCÜãƒâ@Ü]<GïæômƒK»؆eD>‡TeÉ‚êV¨ ´:7U,²MÓ§¡ AçŒ=ÕÚoöû›±„7KƒŽ>lª**)-0Z¢ééÃ*›<@#¢ùTZ3÷R6hVvqÇÌŽ´BHžD÷—JþUý+ºA=;/ͯþ(=S…ËnùÐQÐí­C{,åÈŠR|±ñŒÄ¸Œ*.Cw÷g7¢Ž:üŠäæg2¯ð̃!ã›,eþþˆÞ¹ ?§B!¢­õò®D«—C®½�Àjî?U QáY}bùÕï‹ÇÑ=î>O÷Õâžh=Çn&’³±0g_N8Ä8Ò}´¬ä§ÊÞ ¤ - áeÄ­=3GxñÅ¥À»s%Oqßµh:«å…/ Ç¨H–ek%¶óÖ‡QJëØó_uˢćñƒ€éðx´Áf> 5’K »”'¨—"q4úHÒÓ2H+j.*8#ü~¯Š2ÇaåûQÁëf„ø¢c¯ê™'›06ïØmµ}LšÏ·išøÄ :#wÇ$ âAqQEæIˆHNúätÓÊ)ß&<iì±TOgW®Q¢ˆôWEE(Ý8Ñêñ¬¾­§ÇA“Á?;Ækua,åa ÒTßP Ÿ×•QRd>·­‚•<Ißö(IâÃk*´µø¦Õ€ãY^LçÊ/çã¸Xøš&Ê"®ª¯]ûܤ|MÔn!÷ÅmŽf@Ç}Öé8ÜFJ_bxòƒhN¢Ç—®´2%^ Ð(™TÞùý4쎔‰ù…pचc>åSÀ‘ª±%MJ]`o8l¼;£jþÐð×üǨŒ2:ð=v®L†8H¡>©d}éubóß™y’lÞ7Á]2qN»zP÷õ>}=íz.]_X.nbxÄÂé 5$tixÂ%o·Ÿ<Øè},´ÉgFÜýx�&c{Õ%¼PnÉÛ‚ŠFöí3À°¿:Bñ¿¥Ò¶z¯KÇÄþí‚HŽIÝÂ-»1[iÕŸ˜ m[¿­. HaWÞû‘·Ú# 59|jßÍbg¹&!=€*ŠÚÈȧ}7o¥Pzhùè.zzÍD ²<}úò"õ~gÔ(„ɱ٭M.-Ý º×Õû?徃ûP¬ 6':3zÅñ1ΖÏZìîùÕÝs® C¯FMÙëÂA«mÊ*¸á3òí0î.©Û–éaá£sŒ;4ïb1äNQïAË 6­àÑêîlÆ‚á™ýXìU¹Õb´oÜVôæ“›xµÝYžåæ`ð|öbF»1ÒG0ÎP£«Å´ÆåÀ ÐgØx^AWõûM%Ÿø^Ä•�Þ³ :餼&LÙbÀuÅHùªLÊ,ûª2+~ÜfA6ªeÈîËë“ksŸ³L“ÐHÕ½¹Õ¡žš’³`¥×05ª'U,Í„"úŠ¢¥ƒàÙM±¦ºßÉY¿ÐËð;›l’;nAýÙX-T–‡£çÀÊÒÏÌyxeY´w¯N b1ðÀÒ@o"“B%*!EgîŠ ‡/œm®÷!ÌòÖ8`Š\<U —D?Ïœ­\¥ÑZ†²*e9›ÑüÝhò‡w8CöRãÇ 8ÒNtT츱î—mé»?´Ž]Ê«`Ù¢,×–¾6-…ͤìÙíÁ�Pl†æ±7§}•3ÚÓÖéØÈ“òWÛô_Z\äñ§‹–6kÂu–0:ú”âÇb¥ÕžëÂÅEéª)I>ÓÙ0­§Ûø¾Q¹›Ð•³ï¬S ŠŠÌÙºcåèET¾ã«uRRu¤… ˆî@Oj¼ °Ü›ø´›Ï»òü-Ý$aèÒòo_?ô"Uìõ¦)ðcLLåyçL{]Œ/®M¼Ÿç¼vÒÌsÚõl•µˆ­šC»ß ¯x¥ùÕ.�ç>é½×O*Ê£^2íF ÞåÔQ€@Ñxrôi¹`Yí)fçV£ÅéØ uoAr¾æ—`÷¾c¼e…–`Ay4ämºÆsr€ýõ¡?nýoí^PB+C~�û[œñ†Ô©ÖŒØ•)\\/ ‡cN^ôõ¶ÇJªmLß#ÍíMŽ…iÒˆ8XÓ´Ú™É0«óØñ)týêÍÄD†5P 8êÑ‹†÷bîΑýØÕ«ú\ƒy/À;ŠqlZ0¨éï½…RÀÝå 9ƒóì[öIžIûf¡¯F…5É$ŒwŽ Ep'©ƒ }`ï°V=CõÇä]©ÎBcýŒ.¡\«V v×`ªà]ƒ˜mG›y]ZòpLŠ7Öø½Ý®m]ðKˤ¤Zº±C‰5–µ“V¥8Dê+{wþŒtK@xw0Ɖ#©Tøø@ÐÆŸï<Ø_ÆÝJ‡$ÿÉ¿Í!þr•ì¦¿$î|Ê|îZ«¦ý"Õ¦ˆ;W Oû„‰5ñtbûšr­yb¢W$±E¤Šð9Ч-ûµÇuÅôLÌd‘,P-¦ ;Xß-`DnCÙH™sÒþf÷èÉÉq¿B]å²é—0 ˜jea>›ûê‘$:W”šv^ãôk‡æº²I¸+ç uøÊø¼^êÞWŒ•Æ-Ãœ´T¼dsïœò¼‘”’J8©yMÁبQE",“C™2ŽVQ¾ìRƒö¸bl꟥ƒÂÊ—¤ãn(ñ­JZ˜ªt™×[›O:8³ôèOßk5\`iÓ²±cãU«ºÙQº!a¾¢¸"/’žõ̸«q÷‡ŒTpx‚V(骭‚RV”[Õ-kL³–V¯¾²ƒ¨Aµ•È!.4ª3¦ µd¾ó5o3ã‚zaèMÙ8Ó J7[ç�mF [Yú"{ÅJîWâíWßF2‹,U0aÑ„¯ÒxØ™Ö#nÞä7|VT‚²SÍBõZ6Ø2[~y‚̉õ²Nƒ¼ÿ6‰:åkØͳ?‹ †ùõˆÞ ýO¦{zuÊk‘|-ǹŽbíì¸Ät¨¢»9óåxý;êñ4\ŵig |ê›tG§–°gE—æsCQuÍLjç±tß_1ÍÚ›|Üé·šÃ$*ƒkaK¯Î™^™=Pß³6"Tµ´8fÐp5Vh<z¿:§ŠHWþ_¼é¿²š Vdѽó#_¶<7Oñ8˜HE‡Ïç 'DE‘Ö¹ Ò–6ø—;ò¨V Cl:úŽÊÿQÛ‚ŸúûãÎ"œ¾èó+*ì"¯°cùÏsK‹*íÕýjËÄY˜ÃJ&Ô¨ CÍý›*j=c‡E¹ÒÓ”ãü]s¯„YÄò€=×3Ä¿A:;ñïnø—;ZRË.Uô¿XÐpd’É0&IPUo�úKíîÛJ>tzbàp1cŠW$À{G_‚M¯ñ*Sˆû(ËŸ�—VA-7r3Ä@‡“CŸSõ¾Ç®“&{0w¢Uj_aþ¹ä’.Ì6¹ÐfwäÂueÀ™¦âMÚŒDv&èFHwê±Ïc¸Çñ@kªs>Q`ë+§Œ7C âm-ò;7R£®üÖ1D3Ä-ˆS½n¤“m†™q§ÿA=¦}^0Ò—2HšÖi(55mSÄ+<ëÕaäÒ½?µhDx÷}ùÔŠ—ùD(÷6}$Î*YRÍÚ‡ôtÑß?Aš–U4ݽ¥'}þ0~y÷€ÿeèËÓWÁq¤§Ì–ª‘|téÏ|Ð_«º[> `_¾>ωQ)Ý~È»*.£)æLXn¤Ä ô¢Ó|×y¼ßƒŒ|~gFÆ¢ÛúèÙ&ÂPÒé£òùű’½‡£ºmk*ª;ÂÖ]C¬0*îw$'M´a  ŠE›¦î™ì?ovDÖíWüý*ôQƒ|{ötÃéDê'Übe ·¼JÝëŽÙBÌ”âL×Öá[õžóWTàÜIø™ŒM ÿGŠB}ÕÕƒ"uéˆÒÇj»Œª’whcgA¸w×M,p´2€xÊ>0“§\mƒ¤?Ò-p§éj/I›•/ÊCiGÓÐzm…YàÉvx×th öÕj~l/CËËÞhá(lS»ï,ˆŽ÷†“Úq^¡Ù6„§æœ›ð¸ØÌìn§Æ¹' ÅâÿÜÙjqU%ÿ¥#’è@>3 ò™V­JuÆ ö%\)¢ZS|þ yÚ ªŠ¼ mG¶I}Ÿ½d^˜¡Ø~Ù!5*üþE] 0,šwv„þÅÿµ?[oUY¶FÑkæSønßÌñÔÅ%TØd@]ÖøÎû?lj‘‘™È’,÷¹vÑ…=Ö”%ÈŒŒ¢ôÄùœ7!÷θ轧}¼÷9úú‰¹Lb0Úšÿu¢æF”ú%ñËÒ QìÌØÌ�Ù*¸<WºŽµ>½Ž0/C?sòM/øàÐøI†›³é»ÿÔÊŒ<®ÜÐö5U$­¥.ïY»m^éä¼öÍv:æþpz A®âÌÏðK «T5XÙ+ jp‚}ŽQº}5{~\ÍVÊýôé½#f†(Â)ý5•9¬¨«wùð$©§wÅü$”Ty«s ðÚ>0ï¡ìpºO«À*ºKáHÜCчÖÞ^oK–Ê¿ON“îÏxnMÖõã_H«lõ踧e“µµ§¶¹E‘Uó«_i»§ =Šn\Á*‘Šó“vc¥"ßãhmI~T¢ΗA_9ôÍwÌÂóÌG4S*7wh‚+J ôÒì¸Â'¨{OCXo’ˆ[¡?öÝ|¨¬Ü˜›»¦ç¦ ²AE‘…Ò!¼ƒ „Ù+OÅ:‡œ¿ÔWGºmp¹c:ïTjàìÑ׊ deIvÖNŠ]·ÿÿf!£ÔLȱª na­qZT–ß2 âD qÖjG�JƘ&Û;Žƒ<ÜoòžëŸ”� é0?m¤ÓìØMÛƒ{/ •S{œ1 ‘yõY{©U‰:rXìIüÂý'ÎC±–~OÏ´¶’Ó=êdîlöß±¯H褛lµN3;$FN$=ÙfñRÅÒŸY†ÍËœíåÎkÊþj>lÜ•Ñ,¹Ì@³ÍZãCüìí©³sÝz€Ùq¸¹£÷<÷ì‰õ”o÷Ô“¤$«Vd¢TÄZO­§=5Ÿ F6ù ”Z-b 7Ӽ˶²~ç‰L‡ÝçÞ%Øvž¼�´U›§fN">áÊ °;ÊwÈ_®É¿s}5ã‘Ãï<Øé` ™„`äìU+"áœ*ãüƒ¨¥+oÇKïÝŠ=ËAŠ“íoþ$EPØ÷Œ˜”7™YŽçE4IçEºWlRë~§¿¹1™­<½Þ=²BaWkј ëç·‘î(ð~Ñ 6h ¨ltÚî.½V([È ;hl–C…®ñ¡_ —½:î/<N‹Êo×@û«Öö~B‹ð×@`�ÿÎÖ#òÚš,‚Ø IïTÀÃcÒU˜‚K&Cîõ±•6è‹¿Á¤Âåäâ‡Ö@Þ±Uy… @KgˆùcÞ‘TΊ¶”0í~Æ´°IFÊD€ï'|@'ÚÓ¤ö‡­oùó÷Ý ¿âü;jPhÚóH¬œT`  ey_„ÑÇžPGµî ²>fÓ­&™A°)±z.ÇqRG§–ø.ç¯ÍÔj3dæ  Ó]è“GJ\®­*ö²åÀ±Xóé5S=—XD3UPtsÞžåÄc:öó–Gòa>*Šý$fFU±šòÇT…¥AõyvAÙôÍ)f‰RöÿßÏì}ŸRP *‚¿ßÙ*O²Öȉ«÷4–ý±{)ÏÈÝ©"VªÍžjrg}"© ­ÚÞú5K “´èѵGVî)ç=´¶;ïðëëöúOŸÙwšDº“»x$\X•¾ï™5xýìŽÝÐœ‡]n#„Zy§jG˜GªÌ003+=VVíª8ô˜~ôt—-½ñ4;ö"U<Ëå:¨Ç¼&ÙÕÚj6mfóâ·˜ £+8Ó) xxd=‹a -`Î á±Ô_¬<¸Ä1²�0Ÿ [oœ9ã…¥3LgXßT_ÍÑGšjq:À‚Ó�¦ª~·Dšz9h)/ÈÙ#€ˆ¯ë2­™Éyå˜þ¼9Aµí¼i¾ãÛ˜˜lu:î]Y‚%<ä†D<_"IJSÉœA”íŒEã ì#ÉÝÔ&ÌؘZÙiY‚¤ß0íâ4eßýYuŸ wµz7\’”¸,HöŸÊKmi¼@„‹ãÌ3aŠØN‹vÆéjižAð>Ò©2©ÎÚ‘åƘÅuHx…\0Ò›Â5%±ø¾œI %†“‹)Å…UDíoN/¥œv`IìTðyȾ¾°†É(—ªT­2\|dÞ±"ó\…°EíÛ65æ â¼úH©˜Ûc¢77¦tò.µçtÞžgÛ¤XX bÅmy@Ê]ÙÛ±xïYïûEò²¿Æ^lÈŸsߣÿä+E{¸˜ü‰ƒt8;­rÁâs/‘g*¯(†Dž´ ÷?âŠÎƒqˆ-0CÄùiÅ#ኬ҉·ftWAvRUÕüóÂ經ÃyŽ´O|R¸8sôIPí-"ÙÍÞSßjz‰ úÒêW,œÖNYv|ºÿk vãl­î¼§ïPt–ÌÈ´x1Õ­Ž>6ÒV•×¦y•¹á ðt‰ÝQ{wЪ¡’¥µÔ ºŠw5ÓÌI±œÕ0ApnðèzV¶Æ<‡ÇlÞˆ{-Ÿ ÅeUl¤8ñF_t³ÿïEÿ,àüÔöÉ’®×51à…¾£pû©Ÿˆë±·mxžùÖ¢±xJò]p2€Ò µq*(ø´J©P?¸lµîŸZç¦ëF^ˆ:2¡ÔôÓ““Úê&æ&Pöþ§™½Uåh‚¡D·"Ø,)•ÓµËM†ú #Ûl †è„зäÝç]*+u5†‹¡fK®ŸÎTi_·­©´XÿM™¦€0Á}À”ÝóÙ. æ+.É_ŒÖ_Ÿ’×Æ©£SkÿîÁQ ±þRÛu'±ß4¥‚•}ûÜ(*‰œ�HÌ4‰œþN³óNšóé¤F*N®ûÒø/)éÆ–Ü*,Nª’/Y~Ú¶£ôgº,ÞÿûÅ,±W±ýÄ戢Ï7£BM¾?U˜ÀNtÆñ†çJ¬=S–~ Θ¯]æã$ÎœÜaJ.=ípV&„q:Q2^ ý¶Ò,.*½‰'T¸Óãª{€RÄ7ô¶ÍB9úY‰Ê@l4°�²Ô"‡ÿ¸!ót3d¾Ì ¬[¥>Zþµƒ•ÔÜ.!1ðÃèQ]ôß7ßk7¶î¥ÿdÍq¶&È!çÓ×¾Î]½ÝöŒÓr ~ç@o¼êÝ›F>æ˜ÞóH9CzÑ>`É©9m†QnVóß y|¼0}bOß¿3í�Ç¿C8—®À@ZÅúÀ…Õ…Òòퟷ(»­b¾Iÿ…fpbu ˜¯ë…ŽB|÷éÛc²ŒóÞwÛ×=íዧ9`DÌ æ…Ècrîf¤\«W¬P‘[”©é};—5ïR÷gáAªÅV„¨^A‡ybÍ"y4é@·ëgð*;Ê}©ÁŠ ;È‹|:€Ô¬:©� _l,yÄ]Q.CäÛOÕ󌀭´9 4·<ˆ*öà3¦J?;¥þ…R[·Óx²ÍÃïcª¿]%ÑŠ{2íøòӚȤ€Ôw–‚q4)ÇÓR&/WmÒ2)ΛO•ˆÙ¢îäÞ”.è´÷ƒg`^¸;f>¸Cú–UxÞyȆÏqë©‚°³à–y/4®¢¸´R‘Æ(¡£h_ït\ªÀœDg %^ƒV™¯9‰gr²Jˆ¹¢:ûÎJ/Éqºö­ŒX 0Tƒ|Qå(P_d^mSˆþÃÛË“µ½ª§ÿÑ+ß-„¾Ò"ŽÅ0Tô0Cð€2›·ëý‚‰%×y¹�Bî_o(/m»Iwé©Í‰iI˜Cƒ²­Î3©Xp£ïÃiæ A_=P©m¼Uª¿z‰*n¸ÈÓ5f÷B+ûï[dõ[Š}þSùA¼ÊR2´ ÑS¹N ªÏxäÕ‹uß7É ûÆ!–‡!4ÊwŽt®Eת2 w T†…éqíÛNÞËí¥gt€¸\aFC6>êÞk®Z's»@_ò<-#¿œ‚û°‡kãˆáƒ¿­{wÊüÔ.ÈÝdA,fæ‚5c 9‚UûíYÕ§úÈ'å®î÷мÅG {±­ÍbÓµ¿1b÷½2ùÑ6 ퟫâ›íF˜îԓЛ~=EJoí÷–º âù_ÕÈ�ªŒö: 8­y%-yz/›ŽÜ^ZÙOu!ìç,H>­VB]´›OVÂüé’…+¼rnÈ-ï5¿@t³Ôµ"È*-'¡gù‹:z+JӺɓMRéD�Ðå)[ÿ†€–å7vËÄ–“Zîmö×?P‘¾ ÅK¶¿žYE²¿+ìX•öqe‹ÅÊÂyVà·)§é`›Ô¯«”©k1 ì–¶ØÞ.Uœ˜#è¨ðÛiøøX,KÇ} Ñ÷m©Ê,›¸0ÕJKï‹k Lß.LÕ!)Ÿçt`q.Ï*±€KÎ úNjéT2DWð»žÜ8¯#ÐÓ° v=ú?‹5²4Dé-öÀÝÏqÞqèÃѧª¹n,ãÌe¡`£B®ÌlG×J/˜z'G«ý•ãôY qeҳ枒B"4ŸxÅJáÏÌD£&¹~qBáÚ:@5Ð_£hå; |HûçÎæÛ¨ª¶\õ¬>;SˆþÐƃl8è@§Áá~e÷0@};pû· ˜\‡ËzàL™¢¨Gïã�³®¬c”'Šg0%msØïUða2Û»væy2ŒKœ[‘Ð?g*OòÁZÃU+¨‡º1í…õÔvð¼x±Ù’f+f¦<¨ê½GP®Ï0?¶áMÚñ ºxˆêM+Bc(Ä®Ï�~Wßž;xWôà)©I¹s¿³xÏÙàîå÷]†…¯I‹þ2UAøyuTï¼!,›ï³9/à¹Fse²ð/Wª s O´’.¦âMášKÁ¢å²Œ¥QïÒðGF$‰ÏÂe÷»Ã‰r»¸¿|3-uêÑ'Jzq 4Ô_Ðlã§û°o”V¡?ù¦ÖÌ(ìö»/V€Å0¸ýg>Ó9ùϱ¶ô6»Jo~Ä  ²^©†ÖÇ]—Ö›¯Ów�ñÐÜüW$º¢"K­h›ÞèR퓤åFœç-¥‹ÄÉ-àÐQþwò± cß_õ¼w3lØþ^�3‰¿6;-M»”þàû¿~¥½7-\¢Ó9µvØ�¿ÒIÛ·_xbQl|.N%éɧ=sÂÐd¹f O©Áþ †ÙÜ¥A,ªâ¯ק>Ô*2˜éÅV¨ ÊƦ07Ñ‘¼‰„4'>ð’•`QHÆËE'†\r?û¿’ÑÊ4óàG”vsÞ«ͦ¯¯,?£¶”©á@@±õvFdezš7Ïåû·Œ<´W9Ë…Âïç¿ž?ªT8èÝÛÁk€hõ!wÒš>÷+R{;E‘Š…uÃIï'¾($ØF¼Ð_VÖ=4 Ž¯.BPÕÓ©JÁ™ý°-þñ‘‹sòÔ?…ÈyŒ3«òslaÚZ Qp>>X%‰ÃÊKJY®´W*�² ÚZ>¤…h«ð-eq'òZv;Q;¿Ó±‹ó( K+JïÍÎ|¿÷ÅšJ)sÃéûÕ½=*¬ý Êù x§ã±JÙŽžm„_ïN‡«.nøcíëm—¶,}ù;ô Á :«KU ;À³u4÷:9(ö`Ê쩸Ôô~‘…Z¸ëEÜÄIÖ¶ð¿—\Åjœh”÷ÄÞîò‘?hƒí1W%Ÿø¥Þõ\Æ=Hž^³7§¬¹£[oÚ1ûò,ÏãF\e¾X]*ªh­ÓYAxœ–­b½­ K“á­ÇÖ/†\ˆ?Xyúr]í†>ðA#ß+�²i+C}~¶½í;ËXóÙ®ñÔ§«U²;@#²ïê»g®°‘«=e4Ñöôžï_n™ÓM°F£¦_W_•-zóó=R€s¶T ^/åNéTèÄœÁ©RBÕéãÅÜê.r±×yIYZ¦£X·ú¹3ÉΤÌ2x¡n7tTªÛ >Ízà5Ð"¿±‰.V–ô;'š'V¥Ü§»]Ÿ\ó'×k<™`Hp…í»y[ž¥ÀéÏÒ¶ŒG˜xrø£ W{ô)VU=~PPˆö;wgè#OÛZ„å8@èØÄÄßAãÔu/Ø&b3¦Aµ|9Õ„âäÃ-A02eúé0J²~G£¢çû±Ð)\m÷N!G-vŒæ?œð&¸b67*˜Îž˜çQ!‹°øTèJå¡iæ7Ù2´ÅOÒ$ö#Râ+2M|tX«Àõqð¼Òæ+rËÚ‡øܘUòv­¡áÍ.Í·£§Ê�fŽi¤MgArͺ§I‘€­è¬üOv@QdšÕB@�ÀÚ>Ëìµ ÄþÏ2®:ÒnùŒÈj¡™¹_IïY$A<Yó–`ÿÀy¤%5-;nã«Ø=áñÃäÖëŸÖ;7¾¸™œ§ËÀ6nIÁ¬F“Îc�Q*LJ}ʬXiN”« ²ò‘�¡Ô²àœo_<¼_hZ‘Ú¼î[¨L]Íœ²0p¿¡nŒÒ}Çê­#ÉØ%³ïº{Ó½ÄA¶Jf¤÷ˆ¾'mó¤ ŽíY¼Å.£ü/3Ê7¥‚ÁAÞñÑ5¼—qèSì1›ÙÑém%œÞØ×Æ•Õ JIñ|Þ™yyHÅLwŠ¼Q­þ·9û'ŽGVÑ"=ÞÔXA¾TÖú#8R è³ZgйÁZ‚‹iAyÌd ‚ó¯ŠÛØ"ˆS3V»2·­Hö®¢¼ôªp�ŠØò­^JB¢Äá\§}œáûä©þ®íd©²Ø›Ø_œÐÁOÞ…ƒ‡‹bÀÐÑ?ù~ö’\kc®\"í쥪–ŸÒŸÈ}› ª8þÅï³Ç:¶<B]Ìø”¿‹™‡æÑÑuD7¥þ×d%¯à½80B”á[P#ºv܈’o²¦†„þÈ%ŽƒÝ9C3Ô6‡3fV,¾X5ËéÀnÛãû`«®-|¼Fh„’é4Ò)-(.€»3LVÛ·Ä+i_ì¿pœaÉkàòn~òÅ Ó¤ÜOt¸ÙÙ=`½uCïº8%(ÚÃêu«­Ý­Jà,\,H(QسR×–Î𣓺Q•¤e%bõtg²nym—\D¿¨~ëlXbÉvëè<ƒïšàL¼ÖàníæôFKMÄý/h{l­œö¼ìúF¹Í8€Ù¼ëº˜Î©0-•Ë\éµqy*K(J«oÅ …¨»ê©¨7Ž·j¸‘°™þ>3Ürþôfl;6–áûüD¿tp`YÒçm’F.©+ÕQ–¬Š•6°YKã·¥•°}éÔ=B)ÎBîA¹\ê¾Mœó•»ð Zšz)4Á|´ú˹·3ʶf³~ÖQ?LÏl{îøî®LI&z[ ùXÿ,ËÞ”DaÔ®„‹ÒI›Årߪ ~|“îǶífÑÖ+À¨ �òÛ^JâUE›3š5ºì<”aþ¢ìd|>^œ®ÐNµ6¢s J¥lˆ©…6Ýæƒö<EÈÜhð%õŒº!fÄ.áabÆî jÊ©÷pö¡¹GQfD«o´ÚŒ~抶ó¢Z7ÒÖÓ[œÎ ‚õÍ¢xì©SäÎœª@¥¶?ÑaSìO^ímß*êrçÛw®dšò]ZÁGí‹yåñ…•‰ÇUk*¼4 ¨Âu))£»·ö¤)ƒ´)aäÃ78ÿ¨•d«Ù,xpXÄ“Žx2î‘ΈÇ>¼ëQüÄ­8ò<öœ?"@Ÿ¾´Á, áã­Aey¶Ý JéÌãIvÒ©«?n4™Â2ó ŸÀ3»–Atþ´È`6T¦‚Cý•ò™  I3î‘ Zè±rÛðˆº½÷ö‡£ò¦ñÝtv¾Ö툪Ô3£½°‰³_jS Ș$K¿£/A‡ íÈÕ5%†˜â©½[–yS5(þU”‡juÞQRK'Qÿ“[ìeRŸU°i"6…·¼`Û ÌeëëËà¹/Þ»úfUjŒ’öùâùEAûhÓYÕ5F¡í×JÇî=YIu³-è­º­GmN×£&ØolÇAg¤HÊv}}'`ÀîÿÖÁ׬Àûp‚æ~ð$TÐ,urj`K‹wʆSݾ2üÎŽªå}7#}ôÏÉ4åu´äë!UίEý‰ï5{îô}òÊlÙ­¨Žh´QSˆÛSg )A ”zË¿|ºÚµ»-ýJîÇ/˜§^öVLԺƣ)YQÄ`}â½Fi$~g¶`-Ž8HΖ]žÈ=i|óM×­ì—h¬ýˆ³·¿ 1fe)¡%¯ðƒÇç5&“w¹ÁÈS ˆM•~^ÆÁtdÛ”³%—¤ŒÂ?›î²~Ü{žý ÅÑ1»óû‘—¹.\Æ¢lló°×9kž ~+6)ègõyR©(‹`4´-C³·Þhå±zÞ¼œåÒΨfwñ@ÇßYØ~Rn>µ+P«N)Úö0ózaÌÚJ ç³ç`;±èÔÄß„jN-msÝu[©ŽµÎOR:rJRÉü)å¯'”âñ d_†1Ø¡%ß 8¶AÒn0FR»±õrâ_¹óÕèˆNª¡Ë3VÝ°B ”s±è«Nhá¶EÖh8¬Gœ\@÷‹1ß(T«:²¤Nì>D tD_;×1£*z‚”Ž†ÐQˆa_›©3M-Ï00ôE"èM÷_ôi-Ï ==:ùþt’ÒHõ¿¯)!¡Ê@_7uß,Ê÷N\ššÕŸz…q?^  !gYeÈ€0ÑaÿGþÇ™owM1u>ÆAaåýcáDݹ@OžÑ2LY¦>¹¢éx1{þ[yb7Cƽ‡>öœ4£HÜJàK¬iñ¯”Ô’ØYC‰¿WKYw¼ÕN.nôì™C1_f02ìm£±ãG‰7@a䀾±“íŠÄ0j`<ÃàXòìOE¼*ÿI,<YS®Af…‡ÞçÕq(moLX©\{7"}Éý^8Œ"-à¹2÷š¾ÑS-@'·>‰IŸÔÊYQñAÐêîs²:üÏ:Þ%*Ì€€ÊÝ°éH»o¬0ÔàG÷éÃQPå‡<LÛb3SÄ+k;!MU+X J¤!A(ïó' RÛ¬I˜Z ö‚MÚŒþ…?´Ñ') ÓLÕ‚í•5]·;ïô?“ôMƒ¡âæ_Ó…ÃFw"Èi`«"¸óÕo…qÃzhHÌ[+í¼`‘…CÞŸêöÀá–=óÅÍëšr'¾Å`™”$.Ÿždû0˜Óo±b‰/âÈD[Ú¶y=xt}|p_aÑ,:<ïËq˜ûâ7Ëd£òéäNHº _ðË0VB§´Ÿ¹Ø±ãa¸»Ö›®Öyx7í"öu¾iùyú<£ûªžåªõËÓÙdýÍ^‹#Ãòa ëSç�Í`˜™Gx_¿úîå7W$‹h~î½ï\x7j“ Ò®G�9ô"*ðTy¦N¼ù7Gèˆö½74pìõV›ºÅ(Ô¬ìŅ6( M÷W°B‘°ºÀYx²nf¹fÏÒ w.÷¿0é±Ö pÚk¤ÃÉSNò;d hÖû‚ëÁe®–tRQ©RZtFØ·fžªë®çL“"òùÞ!Û P!=\<Þ%Í<u2@¨_ç w‡ÌW"aÉ©iGÙCþþ¯×³ha1zzȨ‡”áÊÔ=rFv^ZºU[íÐaæŒÂ‡iÝ"ÛêàÞB HóŸöÿÓ,ñ8#~Qè¬w.M¤ O}57i»‹´ÔS-–ÈL$ Á[¥]oI%´Ó¡¦Y -&£,ýu••™×¹¤dç�YÒ¼×Ò7âN+[´ ÑÎ…}gX¥wÒÚ•g“Ú;EªÜgŒ¢«?«Ù†¶'zöâþÖMB¯Í“}MÙ™ÍjЦ Çˆ¾Áêé9q…Á ϧ™aYøº¢€¬ƒ˜|¶£³8Üú˜y*x¤7ÇÊ«”ä8Œo¼áyñZ(Xš¸ må’!÷" ›îÊÚÁÇ™ç5I ’ݘ"ÛßÄ$–ÚQŸ‹LOtâ ýEw¦*ö•© KùA¤ÓG˜ 8ÕÔ ºX ™þ ö“”™o{FÕR »‡ZÝ›sîìMN‡b©MPýÖR¶sŒÈ©õç"k}ÈN—Ú 6ŒÉ%§QNé¢SÄ2kǸÿÚœÿý×m¿§`mÚ‰”;}µû$jùœY¼ iÍÿÜ µUâ8£÷Ôà'Žež:SÊ¢›9LŸÆ,9#öÎúû¿zh‰9£ uãýUmka2‹ £µéÞ|þÅi½U±2"iIÐ¥<݈¬D‰Ô!¦à„_kÓ¿êŒ|yÚœÇ'5=ŸZkµK áN·¹ÍQÞµ½¤ÑE>ý;æ[v¡³|Vâñ<RÅIeØÛi< Ëß4YÉ@_¥¤»»Þ΃6õþ;ß›z¡•Œ EËÀE§s‰(\™YÓª«7µñ+·ûÊìP$t6RˆØû6 ûúâ59ð¤)r‹;ÙCíËtM܃$ù® *;ÈCÿ„nɇ‡Ö†nÈìÆx?¨vGÞFIþFgYú©ü iü¢þß7Aè¿íè6ªfàÿ"K­fFôXFÐÒý¿Þ-ÃØ­÷÷¾»òÁf¾·Ý.j1L+SŠz­bÃÁ¤¥,Êf†Ž34ÚþH„ùXtë%¢K‘­8(q,ƒ¼¹X+Iç4 ¶âÞÕïŸÈ mdFx³i(N¶‹÷è»ùƒëT§²áLH~'"‡®+vX} ¡½•½¼é (;K‰`Ó a…µÅ–˜ç;¿qæ}v4›ÚõüA&<éiÍõ¤Hóû "&’±VF7Àh+4!;2|0<L¼™‡8evEX`'Óýx…Y–Yú7ô€V’T«¾õe¾~l`-U¡p­w ›0|âJfãÐxÖÜæþeøŸ<¹é,6{ZDyk‘P—ŒÜ…0½„Ôb×ʱy¸B™T´æÓ0¨Î*VÑwï|MÊ´‘�Ò"w|um®m‹!Ó#Š(ó7fÎ躗íÕƒ 7Å»îãõ~bú•?…'Žhø×£v Ò››½›ú‚ý 1;>OõÜã Ç¹ÓBŒb” ;>ýë÷©©tl‰ßĺ8/odïûrOîå+ÞÛâæc¨'ˆiy Bé†Âs}è ÀTá²j/K«}Gm¸à.Î0$£´ûb;ɱi¾ƒ`ˆVÝ!³ÝíDÆr|;[ËUû;„6¼©»[¤'ªOÝfÑq™ŒÞ¦ú8ó'^µ­”¨?d0øƒ¤ÕgÀÒ‘ÆIª>u³„ãOhß@Ëø1‰6qX…ˆ!ÌL…>;°>Ôó\Ÿ×ôƒYnÖ<!Ö¡Ó k'­Ã!‡·«éVèã5DŠkkh‰]}TÙ¿S­ ªoL* Êz?'EP~]}P9 ÆÿUº£WÜõ¿Sù‹ª¨J<Ã2Z:&Eèz°–(oçÝÆ)Â>û›ÿæÿ/ŒÿK×T%DN|ÛÁi¼ü ý'VyI~ÉÔQl²*JIaœ%Y•?ˆ}ZÓå^ŽÀT÷MM«·¹úR&=2Cw¶n£g¸iØ {¸å….„Ê×–Þè}ëڑ͙Ҵi–áÃ0IÁ’xÙß tZT±ö~eØül\_U¬§ë™|"UœÝ’H< Ýj¥–ûè:‚z´(d¦O9ÏèM}š¿ˆ$ UôäàžÏ5Û~Öt³ƒfÓª¸ãl[•ÅQ ht‚þšqÝê—Í9xƒ³ó>Üuã´ƒ)ëônêű^ÃÞU®½+%ÔfJƒ¸]¼“Ä”&*JÃÛ¾>PQ²ÔÉÄdƒû–bÕ»’œŠÂä¶ãSz6DYÿ‡'¬†µl*Ë°E%³©MìÊà„ÞŒ æ}OÇZ•ù„þFw ‡LP²÷Ä.§±9˜ÌÊ¿šb­~x¦k½|3bò¼‹nÃâÙ9¥É•Ó·¯-ðj‘d§ýD¬S” 3’<ŸnÃä|çU·Cµ‹$~ÄE_6Û *5ˆŽù×_DYñʆ-£ü*¡ÔR1v5wü²‹¥«¹ƒÍRÉÏ„ý‰ @sÄ”DA5¨1«ï_75s5åôƒ*Lÿ„=m]®)ßi¾¹8[¹Ðˆë­˜wXÔ½´f–y”}þq•±?‡xÕÙ¨¶›ê­/Çû#¨ÎVï²HÁßÀ¼´ÖI›Ã,8Sv�·€Ÿ´;*/õJX–øØ°ÝÅ3ÄäñqÀÐSœ½Ü¢•žVÊ6ŸQTû“·¤`vâÒvƺ‹/µ©�œ*Ê|Ê…Ú+å¾ic?g=üsý‡’}ÐvMدTƒŸÆËu6ÿʨÆLXFà©l×9[ðÝ }2¿¦»Z )[EBÅ=â;;_Vò²ˆš­êž%‘øt¿¯ËÁjFITzƒ&„9¾½Ö@é%è-+¬øEnSAö¥œ$ŽØô4|kXOça‘ÉO׶Øîâ[¶¬‹‚ ‘uŒ}”“Ú±Ã~[ T ´4â95."~²L”²eı\˜I7y:@|PIz·µ$½‡Jˉç¬Ëªð‹ìX£À¹ð§îyǵÝ3@yM½’}[@Ôyס~•›XÉpFÃceqåÇUSªM‹rM–ÉeëÅ_àÎ þUQV¤NÿˆOðÖm‰3ëJMš€8& _…î¡…©Ç Ï,»<ÈÞmÛ« ¾èš "éã.èÏ™JD$ü¹;lç8ažylġ¨Jªœñ%û,µ“rd½¦½å'˜ D®`°Àf›Ó‘Ñ*vÕ€BPÕ µÌCNW=Í(g;žx¯µ`ðR¹×½rpðß¡<¼ô2?FöL;Z1­V*%ô½'*לY0C;Í`ø¾<DåõP˜}ÒÐM)öž(±ÁdAª×&•õîsjÄþRº;÷ Ü‘ˆÂOD³ž�9KèÿÝ4Ô¡…Êzî/­ÊéKÕýÓÂZª¬8Ÿ¨çL{´%œ2n‚¿Ø·Øu&"Ž¢ýûº†›E•—ŠNȼ+Œ!>×á ì“|ü¨Ryó9ábgAjs$z”zj«;™¬pDu—·â(No>7‚ý•½ï[ÑSô`~ÜfšÕlíOŽœ‰ ÷N0Ö@D&Ñ®ÞÇp€Ý™û£‰¨ªdF¶ˆÖ¨Òƒa¡HõrØ©wº¯Óþ¨òîéñG i Rœz+N…ÃfÚçQá»ÍK¶ú›fÈ’¸u 3 êƒ#ÚA7Ú„ó¾å4¦+s–l¶ ÕY;'Šâ8YÓù80Òû‘Šï!UÇîŒcõnÓ˜i¨Ø¦®—ÀÐÜy?.ìwÏ’¨+~éÁ¦9ƒØÔ€`+nŠL�*{­þ§më@n ˆeУíÕ¦)a:ƒªî—é৙á/ŽÓ±¹zûÝÙK¹ò¢‚"2÷|ë[¶QQw€­Öx]ÿ1Ë^4Ï”-|gó`èòˆ†f:a›Ø¼ö¼­¯fÍéß°ÜvÚ™Û~™iE—ïÖ±‡=0+ÔÛµƒa¾ù—u?×w8QœûY Ä´@&ÛîâµBá µ‚bû~TŸŒcO’`(„Ä~åX„oXѬKG÷óØ؆‡´õ°eö†àdÜhªZiUE¼„â– S"Úé¨>gcNØ:°4l'†¿$K¤NW1êŽâ`>뮄†hd80O°h=q˜¶;Ú¡"¿Ý×—;’^ÖØMûdû–¾Á§«Õb#½Ñwõßµ‚ u»“Œ¯ .”ú†³mî³`,Ï€UÀAk‡çWö¸pR 2™º’ν“ñ+àq8¹b† •ï]}“9Œ+ÿÁúø0ëëô0Bhaì+î{íÒHî… ÍÿQ0¸)ºaéµ;“–B}IEP¶Bx:«„1<š];èÿ„'‰ãø2£º­)WÞŽ®ÁV„AÓÖÆÁ^èäÅë7‰¤Ô¢ÙšFt؈*ÁVgºE<ªÕÐý“²Z•;N“ÞN˜HµçÿLï§3¶[“§»fO©ç¯ÁV=ŠëøÝv³LÅ—æçzÇWãaà2$i,[ë{™8q¬” P*‰ºz‡n¶rh¿sžŸbOK a7 ñéL¦¶ÝaxC ÿŠ |û€Gº£ËDU_ø¹uY  º±¨Ò9A?‰‡Û§´*87\Gµ¨ŽÙ¾(bcfº¶Û &±¶æ¹uÑÉôe§•‡ÕªqTVJ›¾uB‡³)MTáŸÉò5 ÝQóQÒî×f9:Ö×BÜ,¤<¶ï~RÃ=�!Ùo&ÊN*7síÔc©¤$£Ÿ-ÀÔ?nëîGÊUâ ØžÜý¢Š±–²i’CþÝÖìE¯0§« PM÷,v(##ÓË6ˆ&šèÜ6ÿaø|ZKæ>ŽŒÖ_ßÑ“¶¸ˆ”í,i»D VÚK†qq\d¾I{&>]ƒæ€°b6æ3Ž‹GÁ°ìTÖì×®´X)ÀFh`Aö®ià®›Úö@Q½ké¶'¢­2Œô/}ÜË|ÓÄŒR×NiDªâ³1vŽ8%x:e÷ß2ñ}´†¡-S.­-k€v¦CRdã.ÝȈ¯&TÍØnäÁ1)ƒ°Ÿ<Yº3ÅÂis>é6À*Ïã•û˜*–eÛ »?Ù[%껵ul•¢“tP±ó3þÓ÷_lá²>A|¸M‰¦Ù´G›Úµ·Jþ[Û 26³ºŠZŒhZÜü=$áoº¹§9À¡i¶§´¤T°& Ä€~§5zê‹=Èëú-½Ñ³˜‰4{8²ÛZ ¾ËE¨uˆRÿ×Ï]K#y=í`=Ð}ybPû±opÁ‚z–6ÌÇÃk5ˆKëžxµ*Q°‹¡ÚXéë’±¬} rÑÓj[÷2o°t2(‡ò %q\f-ËYäך–ÒNõn@Ùœu&/ÞªÃqçWê‹çK„·¥§‡„¸)€I’Ø®äFIX®Ðe(‚t¿÷ú‰8üëéêf]• ã­vócäò¤Y̪,H—Å$)‹; ·é8VÐßÏ­¾|GŠÄiå+Š¡äA”ÖØ¿P%?P(0@e>ÜO]C_bÆ6êé½ÄœæV0 =&qŒšDŽiïávæØÉ“Ômít0qÒ]ñ¡»€s`Üz7ûá@ÏÁÛ²ì1;—ûÁ)·/•¦…S,½à>žžÖpœ%3­øל&Ž@ªO3?±£^ƒ|ýe>sAa¢g[_<³ÌUŠîÆÏÓ…(_k1‡ë² ²9áb3Ò™|§ÖûúͱÖÙöe³OcîA;œà±¾òäJ³„cüë]^TÞÜÌ]+gè&VíM‰q6ˆ‘OÁŸRuo˜¹–}¦{8V°«z¯ÂÇ°^[¦šÔ®žL òš«z™®AbX¶&Au²ÕJsïzÁ åÒWíŒ?úÙL;WÌãa¢Ã"ªot¬Ãù™—õ‘|A´GOgÜ£EÅ…71ãqd"W¾×·Ä|MœTŒU‹ýÙ‡ Kjp.ÿ ׬֘Æ*8œª št3"µ—ÒÌØwÏ°3`8ƪZ³µÝÊ-«2ïdFk‘a+×Ú;Gç ¼¢¹HcÖé–zx¹«Œd”™º=nvç–2<7Ê+­ Íãò=òoI!*Zä9¶Ž—‡*ƬûËOœú¢0^ñ‡J§´^vµŽSb¨B\™ÈÆ “· ”̽þ$ [+QE›a_îÿõÔhûÅá³aüEØ(\Ûê𢩠ÂÁð©ì*Q\1œCö{¬2ô½ùè4Tã]Dc[túAE¶Zøß #¶?ðË^|7„O‹Ò„žù�*ŸªÑ¨Žnº€X»Õˆ¯¼Pçؤ”µôÙ�‹éݳ‡ª/ìCËçÎežY0üzh•DÝÎ3üãǨÃÜyß\ÿi»úúŸ)›Øßùd_ü§n6Ôwd˜U4Õ¡ ªÔù¬sŒ…BÌéðÑyýWÑ¥”º€ƒ÷ƒšèÿè/¶­óp…g;)Ú#E­æ?ÜÕ‚vÖ¢ÔZ÷Î. è(kJ ½‰AqùqfÉáRÂÁVÕd­ô11 CÊ]Ý[¥‘ë²3’ð‚û9[ž'>Ö½îˆta'ãh{R·¥ÙZQm.é-»“g~ˆý·äª¯äI‰Žê .<ÕŠÉRýÁ¿Ä‚òŒ¿(™’ÂbD0$E¢0u|I íƒZxU"r.MVSaî)Sï:×ÎÛ×ÿv½Ø Z©Q’½ç‚êÓ|GwÐŽéË@ŸýpʃpØ›¬Ý­¥5²yNRþ#z�J…*‡ŸwFUè™Ïˆh@ÊÈR±=ê¬aÓËY¥¢Á*Ã0¢·6E¡>¥•2QæÕwŽÓhš%èeP\öΩçTÓ¹ ƒÓ™ÌÌË#Ћ=‘”…Ó³Ïû»ƒ¥È®^ ¨»=3¬Æø¦=·B„W”º"\oVY]'{ž š¯jg%Ș=;ÞA‚7á3D_0 sÿEoÛ©v~þ¦·”Mê²FAˆŠŠ—”—Ê<\jBZ¸LòAIû`ÀÓã\Q‹cßauœ –?-NW]Jb�þCÃDïúkOɹ/så¥2 CP¿Ã¢ '‘ÆJŒMQðÉ[ÅsaŸu‚VG#‹ ß* ×lÅ›æê5†ñ½¡˜kæ¸Ü© îÌäXE1ˆî À“îÖ¬0Ö*½RZÌ–îIÖ_Ա˴™¶¦L†¥Ÿð˜O§†´,ˆ«”þ(U) Ìs.קq¡ÆÂ}Lg¶q-Ú»º}¶-n }PLª‚jš\6*všØ2¼%ijýéHôŸ2—ÛÊúÒ'eŠ«úРv›Q¼BG–pþèfƒÃù­ƒz˜eëáùüaGoŠTÃÌTÝ“§ñÊL^718ÖPœ1sVO°º¥d]æˆi'» ©«ÖƒÛ!üíëCbCdôvúsTõ`ù¢ðŸ…Ôæ`-ÂÎŒïñþõ‡™©BÏMäŸZÞÂÚ@„²}¹ Ú‘ôàú»ÒTi•g®^¦›Ç­Üá][¹(Ç BǨ¬ü¢w[ÅÎ[ƒñ ›mN‡Êþì$„O ¨›ÎÌ´¥k9Á×ôWà¾ÔëW°ŒÈ,~ÕJóbXص¿Xß×Ô”qí6†çOÏWÖ·¡ÿ8`”¯¬ºõO—ëÔ)CùÛì=Ê‹Ì“™ Ãf†¿u*ŽÐi@ÔϨšN,ºÿ·šÔ‘#7Å%šÅØó&2-“œÙroL[àkôPtÿœ“çDŸè<yº ?Ï~ß®œË )“ÎRzYùø£noK͆‚c÷« e©ñ77î§ üxí²eÏc ‡¦•¹Ô­Dæbê<%B$kêAš¦V{+NiO&{dqùI«öü»–¹½‡e¿­áþré{Šˆ‡`w¡Ïضöà{{È ¢e.² ;Y6rft]Ms¡§ ØmÝ^Ü©E˜@íž"–M}gs¶ÁEZ8î2 yI6!J‹§š¾¢3³qF¶#a• yzìÓgÇLuOµM…½~ðüàõɶ۔än75rc§Ì@ç€Ò~ëÃ}k¥nœÆ„ƒÊp'ïCÀõþ. ÓWår6§{Á_ÖSÍÛŒàË¿÷¼…’äF«áRSQÚÍ¡«a-r;õ/òˆ¦ÉäRÏàÙe–­ÑvÍ\ÉçÅuÓX®û¯›žl'Æì‰x µEáÛ?oø‚–D¶ã» /¿[;_¥‘ßc<ÄfŸÓÏ‹F Àø)R ó^üw{Öiè µÑ}l)øO+6èÀ`´3ÖÚb óéѪ� ëÉs–ú‚áTÜ.Û*ˆN&Q1ë mÀy4jÙ‚\ O__9±y$¡y"ÍìôP4<RåPLÅfp/k :#³0\Gí©£Aæé“—x†ME%Þ»j©ƒ'Âÿ+q( šÜd~ëR«)O$¶ëQ­°&ÆMÑÊ3çYýUx2«8K‚iG±m<2å‰> º86=–w³6¡"Ž@ â?™ÏNM¾…:ŸJ´Íéíˆ�?(*F:·3 …$8éy0ÏŒJzòÊÙ³iÍcW”(×”¦0ûDa¸:_Ý¢¦§ÃkãÙ¨N¿R{²,%)Då¯õeŠx饬¿z÷"‚LÒWÆSõP ,. ¦â»]xLBiÂÝ—á'BMè[�1žª¤\]'=-V(³öÊž¡ý}R'ÀIJØ7fé¶õyXføo8/ú‚ë;Xr|L|ƒÇΖNQB % í¿nš[j¬aÅ‚Ý•“hyc¡áÍ-ö…NšlÐ\õ@Ï9´ÃÎrˆæÖ‹¾´HJV¬°]”ÓÕmž y ˜ÔÎ<ý‹»-²²¬ðAO5ûzwFçžrÆz¯d£EéNFÎñ`ËZûò• yÎý¡;[ÁÝQ¬¹ž<Å"ó}œ`×ÑÅ…‘G“‘fp¢óY'4=\]î ‚f±Õâ6[…N Ð|ð‘Sö±¡ï4Ú{ |ëfFF°™cðñ´á€•¦s,Õßs¼³Ð/Ò#dS´Ž¶:ÁØ2˜I=ãp¥õm5‘>DÐû‡……¾]ržš’?‹£õÀÉ©¡ñžº~uD@öN”Ž´×@Núïè»$s‰e,BîI¾ëÁ“ñI‡ Ó޿À¼eB&®#‚ÏÌWnõ<ÿÓé°ƒY†[Úíoœ¡˜ôäz¤r‚Þô¦ÎF‡}æK¨¦öwŒ©@l ðÖÜü±<­?–‘ ¸i( žz_mÍñ´[æÿòi6tƒÚ”òÙzI‹<rÆ?¥Q^á zlK·Çú ¶#«‘ùóóÊ3g5<E:ÕŽ@6…t†¾¦íö=ªŽsOR•MGaë• WMÌ4Û…èá_J¸UÖ;EË í8MÛ1* }±ª± 5ËÈÿéOîf˜±6eÄð4Á$ =<"¼¡È×2 ìGn~åY’©‹ƒâôi—ûkš,xþ<#lèª[ ¾€ÊºåŽM$##04t1ª¯½lý0·ÕÑÎëçNVÁ3åÇ()}ã^”Âaý×sèÙô—«y'CŸû;"+å®™ç½ÂÚúÀÔ7ÎÝjà´˜dÐwÝUÓ× ZÝŽ;Òj%9àDÓþäAPP÷rR2¯{ƒÍùkéÚà¼ùÐÊŠáR_dá [HÇf_P½óå±WŽ6˜E¾Ä¼\®¬'ugòVT©e–2¤ `¼ì_nûtaÃJ'&¾¿È3Ûr2jÝøÇ’\õ=·}ä®ÿh=J"_ã…­Ya\vÞº®v””%&£ZmßÂg(òÓ‚ÜU7}:¡,£×”h¹îQis?÷ÊäÎaƒPû܇8wô*ð3¶+z_T%á»äÉt¼슢4ó…k¸K?ŸþJ%Ûò?w`ÓÔ¥u±ˆ×dAe„Çã n§«-Å ÕÆ ­ªðÑ¯Û eîF»ø‚A»À ®ý×PòZBQÁ‘ôî»@TqNq §ÎGóèoéu©Œ3œ®„yoY@~À¢Ußb5hñÛ{?=^_Y¹‚&QÑ¡‡öÝÁyXèá@™ÿK4‹,ÁÝËïZ»©S¿È®VWÙhÏ¡LD9ü¹—³}¯:õÝ?ûñtçH¬Áqr¦a»òÉé;Œ1:×ãLü*M_“8ß º÷®|«p{K–äzTªBjâXÄ“Y‘\5gžêñèë ì`ïÀ‡Â5‚ý®GDTiU5ÂVžÑ3‘=¹œ¢ ¥¡Û6–åSöpgM‰~/z„MÀ)9Í‚xÐ t9Ó_QI2çƒäñy0Kd¥5ÓÁp—6êzp\nÞäÃÖƒ·Á†S|f_‘ûŠÄÿØÀ° jlʼn53NSg¥&^Ñ1v]nÉ‹ hîÑJ\l¥ ?¥Úût~ò?ŠÖøæ{ö@x/v¥¸é{çA¾Ó’Ö×.‚øüx1Æ\ó«(¼ÂÙ p‚¼tE÷:4e¨¸fŸh%Oµ Xž IGÿ)JøŠÈ‘ªµ³í×�˜P&±?0ÛSM{^0ï©2æD‡Ú¦©‚bØy»³§VÖÛGך#˜ßRªýå­káŸ+Ìm‡èICÇé2h_ã½­ÀN_?´L.ݱ¸”¼>ÀS8¥¸ÂtÔ{ª^+ëQŇðÅÀb˜µå"M‚G§µyŽA>‹>* $ePY?ÇÔà»DÄÈÖõ/.‡ÄKE\f³§m a‘×ýupJdWîa¶*rM›ý0â¾wé{@Ä\gÇÁ~—°+žmù ü1VÍgõ¸9Ñ­dËjãÍl\ŸI¹FEžf^9W@U—’©ZÄ<ílÙ=Ð@yL3öÉÅ%~Úï‡ØVºF ‚E$˜¼šù‚¶»<†U'±¯¯E'O¦P1^«“¡»Šw ;ä.(²\®æ_Ï°¾2F¾Ö—'SÆ®PÚÆj$;¿•©_åùI&U¶õÌÒaÐ:YüÀïM› WíÈ$rî�išÎ–­8©}‡ÆD±¼Ê}N4BI††{ý=ŒX×çÊ°.i‘€Ô™E’à& ”2^T{¿X«@rÃjíÓ$¬ýáh>}F7ìh¥»>™à«ªàŽáur®‚¤¹¨M>fÝuóXR×ÿ  ÂÓ²b­vɃ¬éÝLàFTå‚[Ã>åzÊ^ðƒù¦-‘¬|Å’ É« :[vRðÑáÝrøsàÀv·©UæS­zQ³5ˆÈNëøš¢m7ž†=rƒìÒå¬*\Ò:Têì Òd¡™âI¾ï<—^ú¿5{€Y |XêÅýTï–3¼|Î‚Ì 6†èåpiîâ_ÏìzÖåšUq;-iÊtÜôõÊ°»syÛÖ»zðÄh-Þ(¼…ŸD˜ZÛ3°Jk:^\¬Š÷÷®Ô#íH«±’=¥áR¡•ÿjŠý˜¹–R\þS¤k Gü¢`رÂð �Äú¾¶‚Ñ0õRëÛ!t~LséÎÄǃÿGѹ¤¤TE²¿®î¸§PÄ+çŸ ¯õÁ‹Êw£à¶`‘¦µrS1åcÍ>¦¶1¡½#¥ÑÑ0¼Àó$rh”3¦™'ÚKõÆ>§÷>9(+žâÿ ·•Çžuɺ>³]-ÈãÛQT v–ï× †·xóúýÙÕoÝ¿¸­=«ÅJªŒ"¶óñe)«Wä­²ÂØ9¼E£6ïµkÍÝŒô×ÍsIs¸²T”yï±Xã¨Ô´!7Û}È‹åH® žœ+ÅoÁ}Ö0Hˆk°oDÏÖªŸŠU»Â=¹ìù žoÃ$YÐ0Ð"+¬V„Ø ÓUEüh¡žúêÐàæÇ{X2ôsˆVÒRNæÙ%jS°Yô·«9H”ååŽ)•)ËÖSOÃIca[g£%çõÛžIÒ²H%5ƒµ0X.P4?D3bq­€Ì€Pu% JíõûäI…³MË ýìµZD}@™èVÅ*Ì,$¼¿N´'Úí¡ÿáLjÖrb€ÌJ¡à[Usö¤ZÍ°â'Ó-¹Ãð¦u„‡ïüÎçî!ƒØKJ»æËWÙ©{heiè5·ã E,N]üÊY…òHiS¯C"RóN»ÏoëßÆ8¼±�1Ã]Q;õt“å‹&⎎¨mí™@ôhD]?»&¯w_¼KMžÿÊôYFfT#Èæˈ)‰Úíf_û·ŠM‘×iÀˆžwäçÆ“  ÛG™Ü^±¥F€J›oB€s¥óªŠŽÖGFfðCäòÝÙ ÃïØušŽ0çž½i`”̆—ÃÜ`L‹'õÿûÿæ7ªŒìéÿF'•žbgiJEãÊOËyV~œ½úîý¥h5O‚눙pkö~ÁD¡kwY´$v âÀÿÞñBÉÛ6Àò æÁn fÉž ¸šî9óS]ËÊÔt3 €_ïZUÇ F-I‹ìüî¡z¹¿u `ç4,î8Ò”E¸fÒ]†˜²KËÈüfS¼? bÈ@ËgpËpo \á2Ñî{Ë–r]õ3�·¶äÿÌ› ØÓ·Hg‹ï A*—ò_‚¹Š>xý¦sc¦¡i@à Z²$jû.¼Ä0eõ=.¬ÔŠ„dëÃÌ8õTU_½7æ;R¶aÇ|÷2ùa¼0äy­*Y9½N¶«.-´®¯^+„>‰g±7Œ2Yg"˜Ñ³nÃõ¹U«„š•u.»éĵÂ)Åøcœ³-”Jˆóö¿¼â§“ånn‘#¤5tŽ…Ɵ©³ ít¦ãóújóD)ø©¹Ñ®*{ß g¼›¹N‡£P-X  sÆìZ‡šS[©IsŸ¦8¨¦/˹KÙ¥ ÓMlÏ 5x6Á1™ù‰_¬ÑYúné">€´ „2¢D»$¡éXÌt«åÝTÿLmdn£l¡d%e-5.úÒÚÐÔ¬!Rd2ø#GQäO Cm¥”´ÖÎ{<ÑŸ¦/ó3Ó\uU…JÁ± ¨…Ðóæ¢wôx'TdàeŽ4]ÿ•t§â o¾|‡¹zÃÊ0MœšQÿ .–óIÇ¿¹ME”ù–ìò@_e¶©‘!Óø½æ†<,碵›"˜!”8©aÌÂûô?‚þåÖ<ø¿˜pÆ+9¶h§Œä]?z…äwà–©#ë•Øçhâ´ð]pÐò™à|1x]÷=-Ìžî¬ ÿ¦Cöƒ ™’¡Äö¯gSªˆ ÏàÖf `Ú’~¾hêg>Üí„6Â4x¬=î°qóêo‰â(]¹…Ä”ö°"ÖâºÈÃRt¢½iêÀG×w þžfóíÀÌδæJ÷G'ìÊÔ >Dóúþ¥7ÎYx+Ú/h÷Z2t«Ôÿª"}ô¿Ï‹ˆÈKöí™çïÈ$þyG4Ð’\0§C'"t£¯æ_Ðߟû™ÏΡdz„O­ ¸Ð v3^ÓÞëÄgßý3=ô÷ßìÆ™›È~Ê‘žùLÂYôPqs2ßD<¿af4Ìÿ}K`H9�ížëL+ŠÎèÓ›HXh'x¢m¥åå…Ls_gPUîJÄB¼žè|M[íxÀl‹=÷TÌßB]0Ãø‹w¨Øž<u™ÍòÂ2@YDfàõÀÔÉȸRìëÂ`¦#ê§ÿ¯™ä|º¶–a±¨§¦ ëÒaÙi·û£ö½ŒêþjªÛ¹Ù3 -k¼}RéU̓٪f¨~?3!ý7œbRÄÓqF%ï.žVqUe!âi~™áÃcü bq¢¤2AŽHƒ¾³ Œ{W·ÓœÌ“;dÝàÃ%Ûôi«Œ]jŒø/kbŠ÷Û׊ù"òˆc<àiˆœ}*ÌXdºéãäL—ßlbÅÊ‘š¬ƒ}£â—Ž^‚= *8ôÂë/ËkªÍp»¥äí  Â×Õô|Œ¤—–IÏ&&Mç¦÷·[ÉœM3e>/FÍÊöhž4k2×zFJ¬"=eû°7ìØÜ‚ŒŒRȽßFOÄåaîZPr«@¯Œ…üGÀ7¶ ΞÌ ¹Þ­ùn^½1zšÎfÁŒˆ‹rQÔ>-°µôw(&uÛ9ûfÚÉ u'ä‹:}²öÂ^¡Çx‰èÈkö&×I½z4£ ~ê˜3t‹ÊÕÎÖˆ‚ð¾wû<;!îÍC”N|Wtù¡ ‡rˆ ÀË·õô²dCR¦®mÍp*.² qgx õVո臫¤j=Ï*Rù oø¯GÀ¼\Ö ´ÉÔkN0Ñ·»ßvYΚ=šªÅŒîߘ¦TÅ©0 ¸ÂÒ¸¼®JožÈzÂ= ']ëõðŒ°Iñ1oÕ—‡Êoiúy6íÆh3+·‰bs¾n{17@rª?ðw÷¨Ò*mmíu8‡ì/–ZpÆ8p´“íç%¿Î%cÏ÷\‹¾Ë‹ ffdp[|†ØšyÞA©šaúë^Î~!‰•¤™ÿŒ1ݘÓÒñÚM‡ ¢*ŒÃœ¬¤�H4FTdqÈJ*Yº¡ ’ë䉓YðŒ˜-âKr†yóSw:±¦œ�hU!1ÑÓQ„›ÀQü§(kË‘1í0ûRœèfè)róÓ# ‘.Ãhˆè>4;FR´óµ¤lŠF›NôK¼ËïR&¾–Cëè)ô=m`kKßDì@uLì=·”^`ÒÐ× L q–é§v¿J4z£°eM·;n´ù—<t“ñ›{•Göálm×SbÈŽl‘rü¨"§ÿûÎÊ[Ž›CÃq…ÁÒ]>Œ‘È!¼µzŽ”\}]LÐ7SGŸ°hÉ_È&öâµ”$òû{V>?õžì0º>vÖk€õÀ»—aöYâïrØ)bZ¿«e!S®ž!’?�ý6; ÿ‹N73]ÿ„vùJŽÈK„{%†PX¤Ää¼–È™º–ý7Wíz;¬˜@ñ]Üžû»÷°ÊýæDÄz[å]óÙ=…y9òÕJÔé§t 8ô@ëËcùãÔñ!d7öðÙ5NH…QC‰ÇûZ?7œ“Gë4#¥6}ƒ¶§•P´Ú§C;ˆ>}>àð÷õ©ëž,Š‚0Á>Àóa ›ZûHÜ-¸üIƒ|¨=Äå¥[uU~¤¬Ä;ÅéÀ–¡ø°÷º¦„×ÄëoFâQ–º»ÚÁ‚z¿˜“1½RÉ5µ­0æ¨w)ŽœjægËÞRý†'ºýœúJâçj,sŸèß!uêî©2XƽÌ"öK((MÒkQhµq²äGZô‡ÞØ5ÝãÁ *s&[ð‹‡šx¼mM<L˜ EÇ•…^<q:Iü¹oÿd© ¡éŽ N‚ÁŽ`(C:ÏkÖ·†ñõ&ó”ë˜LÐî¡lÁ ‘ƒ(õ‘I€o ýÑî'嶃,¿A%Óu©ëb¨zÐr¬vy2§_&ÞôÿžSës@@Å>S”¶,›²ÄvËrQƒVçìtM~ò^I#wŒr£ª™tÃvšüÁ‡È^ÀKѥܽ̈Ç#µ–^à4eÞÁéÁjIÀÝ ¶&NîÈöL^꧄‘mÛFœ¦´ôTëÕjÿz¨ýÃ3¡óF˜‹ ?éÏGÿ‰Ó¢XSh`ºÖª’ß"¬©Ãs~[_é [j¤¥R~*F% ™y=Ò¦âLÑMêî]ù­´T•™Î™Qœe£##¥ŒÊ@"'U •ŒÝÞŽ ïé¼&üÿ¸J)2üóÁjg_F|ڙûØؘ4î·t%XÀPJ!†þÈéâ¹D°c0<Üx®Iñy[c¯7Ú»´ÖìqbåÒ„4ÒC9ÚŸÌÒ©ÛãúÇÆ£±ôGÁ)P\¿j£DA®ô�(Í–g H(L©Ã–´ÂÒZj3|\¦ñbútÏŒô¬`©P*Šu”ÎÙS"³žàƒ+ߎGž&Q"Í"-4 ‡…è;ÁÓ—҃@F:¥;Hv6P0öõlÃ~Ý݃ˆï�f‘Áw_YP4_ž ?Ôž¨®àù”ív_?BA!ÀÈ¿ÑÒ8óH)”Ièà¨:Å·fND·vw>Ì"ØòTÿ,v!Q¤DRZrŸ+Fš¿[ñÃWYJup¶úáf¬ˆ…áÔ8qLÓÏÕû¿ú7`7$Kuƒõ •íúZÓ³ºÕôÍÖnI%´8é4ZήÈeL>®†î0Š“:–YäéàÿÃð9 Òål£TcÌ” hoêXókhk¼ü˜íèÆÐh‰zÊ/)[zlédLzßÍ}0Óc)Ôm½ÙóÔ䄤èúàÒ‚¿¬^2d2ÐA¶äíLòf¥Òµ´|ÒÚ$ÿÞäÓÆ¥§ÿÑávä @v® ¢ÎÔÓZ£TyÒ¢ÿÿ#Úd¼*{NQëò¹'¯ k™6R³w3é§yµ­6ØIîXCõxÚ¾;éY  XDÿï¨ ){6a0kš¹y.1ÇtnË.õüA;^n�8€t˜>ñ8ÉMTU€üOÔ’ƒ Æ•poJ•~z(-ðb]ÐèO“Ê0ZgÒsèý%‘n!ê‹=ëw€3 {vF’sV!ê´Aº{̲0\±”a\LÅìùÓÜŠx˜cöü�2XF‹tôß:íêDeÄŠ žœ'ÿö\ .Žœj–Ȇu_y›woÔiô¸#¡Ñ\^9æ·sx; 5ÉéÝ“€–Ù›'…ÈBÐœCú˜Çnê@ËZ‡Ü8LÒÌ9<‚ãÚ”p©@6Ÿ6,m $ ÕhÇSoMèͦyCc™IùKg‡ÌV3ëÇ_²(@j)ÓB©jh½/ºEÆZœˆêUg�mœ÷˜â¯"„Ó¥²›—²€Ð®¼©¼ùÿó|CI¦›ö' ÊÍÈ"Y‡¢›`IŠ?û5F¥giÌP¤¡Ki m5åÅydK¡l¦s ÅQ}EýÇ=ˆoãQSr ævkm€€H¤{±vsõÓöåßšÿÆ¿¦Ý3Ž˜t�‚üBõA­¼MîgÖÛ‹…pñ]GöV@o‹y*ÏéÂQ\ÅÎS bÁúàŽb™{p¬ûY‡Yµ*î♳Øö¸ZQ†§Ðt3hÃʧÈé61VöåÔ7òg•`9शWÉŶ'÷âfæp’Z§VŒ–Øì’#^“6éÙîê4¹þêÓI5ª‚þ,3ÕnÔÙØsdM’£›bsw:ËÛ¾¤4Eiàâ ¶¯/ö/Ì:`¤éƒÁñl[d¾Ú]H®Ø=C  „Ä:@¡]3œi›ë‘û·øK¾‰"ziÒ„Š„‹k Æ ßZ»&йëŸè9zÙ‰S€é¹GÈ7Ôž§OSó¡eËoøw™¥¼_Þ@Eúóì• KÝ7ãÿ®C’Tž 4n€r ·½ÆOˆPñS¼t ¤p;Ó¨fÆVÇ2¤;[pF…‚‹6 åRŸÇ b!£Ðÿ22Ûèz|N´µOý!;aV>:‹bUf©Ì[-,.ßgÂMÛò0sqf 0ƒ¤9z+tœ"“(C KKINÖÌžú‘Eän ”Ï=-Ûa¹HŽöþ›äå–ç´Ï‚tÿ¯ÇÏ÷1eoR-{äÎH; Æã8ööžÙ„Ç°O9×Dcâª"E¾A8л^iLdžì#ó‰ÈâwV(4ÑÆ­‚ó_Ö»UóµQâÂý&Ê“6µ ïÌÊ@®‡³Q>rW¤ý‹²ÊVG ùIO–暥Pšq03Þ=ŒÞ?¾º@ih¿8ºËOU .Dž>ÚãRÃ]¨„ÚØ+§wâè""“Ñö Ò×óšNM{0m‘#²¨Ãó‰T–Ô¢úÛôÞA²(  >»Ñ2[I³ñáï_z½AA6©¥h•8ŸâŽ˜\’Û¤CzÉo³r¬ô³œ¡ÏžN' šM̧pMÉÞ¡>&Íu¸¶í•¾ÍÔíqL L›ŽP§é•üZÿì=fãŠS²ˆ^qRdGŠ¬ãyüjµ[ ›EÐ- ƒ°×Q]ÜP8¤¤o'ÚÒ¦_ù½²®s¢ÙAéÇi¤²!r½EŸß¸j ,¯˜�ÎC±Î›Ÿ¼j¨0™¶1´Uq>¦ÊvÓÀ z#üÐÓ6öT:Ä¢¥™ã{· pž~ Åfl‹aPØÍøßû"™7ëf Æc}i4®*9oÝ°½Î¯Á±,–G£ ðli'DNÁ•Õ¯Žp·>·ÝE†ñö`Äãåï“×"\õÒ²`w¦ ÙZå+ö_΃ež£‚”nü÷–W”x<|N`Ôô_×,.¶ËÁòîŸ7–}‘¢„Å-cØèÒtaÅh¯ð ¡…lXëÞ,â±ÚìgF‚\l¨¶9Y×’B¼®•ìHYÌ”ZªÆ¿¥ç Æ•Tiä‰OH§† ²³B£€ë·!Ïé|©#ÑÛLçÔÍÚ¾¹5T¬<l?›�\GðM­Ü[œ¾¼M>ÌìŠéêÕ“7!2ôÝýÀ»`Òº¡<+vŒÃ¡¾‡¶|(g«¶e˜¬”¢OÅ{sBäA³øèï(•kÕ÷”¬B¶õ¦“~†’UØõf¸5?H¸–Þ‹ÕÍ™Y7‚W%…”°þtã±w;”«nθôâÖqý!þYncpQÐ΃dë¹`�—m懯„ì¨rúÌ‘Kb„ªm 6¨½3¤lv$ù›Ùd¢&÷QbÊRºíy×[g d¤p®uõ®U_ÚAõ"s<CE…Qã∙qr™Î™'ïŒ5iž¿Ä7æü*½[’,ÇK+èÔÑn,—>t±AÇ®Z÷Ù³w…~-æ5TGîÇÍžE¦NÊï¬Lv̺ƒËI×2Ð>Ò’¯¬Ì@Á‚:¨ø@6pN  ©VÇ@»ž=ó’ÔZ> ={³0ó¤b»$”4šgyÄ=ž-êî}æ¤tï€{ÅCTž.å‡Ú«‡øIå0Ž½ù+²P²SÒQ_;ÙÚ¡nL6r@ü G}zBJrßJXV[*Kɽu´çÍIØŒpÖ—{:æ±"Ð"FEn§x?{ÝÊé�î…}yYl'õîk‰5°?§Aþ5{Ò ZÑ�Ìÿ"±c§nÒGƒµÈ€%·¿ªvÝl¬:î‘OgŠˆÊ >Ö‡VZGdù½2¨†çtÁÓþÝoП)ãîTÁ`½Až­»XÑkQ¦Š\'ÚÊ;»© _FF2ÊCúî°Ö™kZãB»?ŒŽGðçãýÀ}üvðpÚÈÉyØX_»‹ûÀ×(ÉÃ5Jy³-è6[²PHMîE"I¹¦dv¤êlÓÓÿñDfÛÖo›ë�Œr½ÝÞû•ç­ ¡–Ëdííp¡ÎSÁüèàw)þX“÷CìÛ@›f^#¹`ý¿! r+eÉ.2èj ™áÍŽÐÊ{bs{© g‰—Š½*dá Ïýi¼o¦ƒt6H™Êý—;¡÷%–ÁJÏ0Sä^aZ½Ä¹‹ÜmýiU߈5fct­ÕKÂÂ"Ý!³£Á«,OýŠ-÷ÙP¦è¾ Tä6;Õ ÙzPó±Àäõœ»[jšéÞœö”|_ZzíÚ}$ öJ6kà+ ¾ÏÊõë·ô"ˬ=2 ©6´Z’~òT€Àf£ÕcCÁ«¤ól-õ¹ÙÒú‹­²@*Žž‡ZeîÇ®'fº«W7šm9D•Ñ…ž¡5|N£Àÿmaô £Ð“bæw… qúUÛQ|(FÁL~ž3Šro*ËÅKäN~m_ÙÄ1Ë$I ÖÁ»ê—T2u45¶¯].´j+܉.�¦Ô®3bÌìë ׌=K »Z4U”*R´Cd'E^r-^ÈÉÛŒg:u±¯ôW¯zlç¡J )×=C¬ÌÊqÅn"/¡¥¬_ܧVO‘v¡Ì÷4VAº¯]«n¹²Ô/lÚy Ô Së‹.ŒÈM v6W´<=µ­VSX¼VnºÚ"fFBŒ_TZÐÝ1+Î…f£@ vç–_­_œ/•×e¦ø¿;‹£Ý¯Î‘7Öß÷-ÀS_Ó’ ņK$Îç´æá¥pz+ža"'¬Â˜1ŽÙ½Ñé_•³ÌÄUb›)Õœœï&z:@çÓÿñyïjÁ¤+ú9Ꞻ°o<?ƒŽ%I4"åNR¡�ˆÍ3{õ8*]ÇÎEÓ1 ʺö"*!¨M„ÇëºÆ…'z—៺<(Ú/¯‡í‘÷]m¿Å”™‹‘0=DËF{ð {U^µjfªi½\ïŠrʈAC8÷~ðÄÕ¢ÜX»žãßÕÆ”uÏð€µq¾ŒÌe†:,ôqÛ{¤˜¬Š<‚Pú¥27A`èÖaê™{cp[µ”l/T2>H¢d¯z¨þu´@[3Q¦»·æ7-‘îr˜ï–ž™‡EÌù€ \k©-¾Dj‹ós«[®’ÓÿšI“m¥yž­ôOåñÉs»Ü¼Åt¤Î'sA\Çp:ÝåkŽ(.KÇÊihJƒjzw!HÜJŸ¯ÔÔ_ r¤©çT3u¤¤ý¢F™Ü>Š¢Œgl-cy­—ç{]Ån~ʼnÏá”aÓúA¦mYÈQµ5O{TúŠ *ûìäŸ-ÙùÛšŠ{K0 Í{¶í2)8í÷ñº1^œÆ=®²¼®í…–ŠVj$7ÎyL0Øh¬gÜ¿]/XÚUhsžÍå‰B=°¦·“r[!o(šûnêý¤éÔ‹yBrãà ͲýÉ»éÈíéÞ ŠŒ}zÝu:lÐ!B¸¼ÀŒgáò¶ëŸtúà'ªä•dÏ }‰#›ï‹ãHÎ ¢ ­´â­àÃœ,/ô®¯­ïË\˜0¶ÇfùÜ:ü©htÙ/e_,Ó45C­yA¹¨-ÇѶƒzŠ¯ G¿ú‘™›.º±ö,ƒ?UéÃ� ‹ÛEèŽÎØî%-3 ,S>ã=Š÷ɃÈC2té¿öýo‡-z5q;yÆ(Ÿ¾:è´fžøâ¢Î½qnºYPõ³/ÃÄ•%ó5wÝ8í4¨œýn:ç7oOŽÖîÊöDJ¯= EEJ+&ÅŽ]€7e®«CP03Û|n?Õô¯#g”$ã° Øj‘+lâ5ïÇÖ*3¾‚h~Qî§ =Å^öIÁ;ß�ÄlÔÖrj;~qçÒœûwÿ•„îÌÝþµ²Œ=ÿ�FdAvVÞæ…´¿©h–Þ‘Å 8àÀS,AêÑUÜÑÝÊ¿�•U'²Ì ÿ=NÛ‹ ·ªÈ|y)è5SaPì¯NaA0 5H—¦nw˜UŒ.8§¦£2Æê·Ç•ÏcsŒÓ,(®µÞ!ç-Huu†„à@^*f©ÏÚ^r€Ô‡¶fÁú[<»—¿½ž¦˜. TäÖ?(Šj€Ëÿ8 ^ ÜXÖ&¸'cý1{WJÓÌW|V¶ 鵺…˜V€¼W÷»z²²¿Ð¤*õÖ§‰Ò0ã|0³V ]X¯džm³¿êêUÅ®‡ú1¡š ‡ÁÏ»Qø]�f«éNl‚�Mš™‚óZ¸ý• a:žcÝE()}ûEô¿‹“!˹Ž1Ýÿ­BpB,õµ§Õ&bJ”!LcZÂ)ÊD émÝ­yø†+µ…PT|ªÁŠI–èÈàS8µÓÊþ+Ÿ8‰}pTâ@óŒwz ÃýÆúTP={Í¿÷œ®ÒØ·Œ¢ q‚ÜÍ4¹é ¤ ŒÁÍßø5G9ó,ìx%£À Ú² ÜâËâ±ß_Ôð¶ª&©áµ°’{M³t-?‚4|áÕyž”ÌÏ …ÀCVªL·Myå;ÐwØõ¸kï'×¥1ƒ7 E°ƒH þ"ÏÒ»ü^m¦ñŠ¥ Žá.[Öm4QP¦ŒL¬†Ãoy4f€îRÎäÈ õ ÃÀžA¢Ytj 9Ÿ¢™…T‹˜Â@E€€—Ø×h<uߥeîùèZª^(¦À¹2‹më‘Éèd[êͰô9Ïwø˜¿7 vÈ-í±;¤9;mP¦lÌq0‹xBÜ9 ¼ä(ríœ îT'%6¦…ywµ9¬¿wNäÿ¾cQ’ ] ¬Ìqy…VköDõ‰ôŸB×ÉEl>†{€ë)©y‹}èÜéLBMÒgå­Í.Ö ŽLhnsµlÏjKŽåŒŒ1*é ÕÝQÄìjŒ£Œyµ8ŠøuÞ+×hk&+ÈA$ãÍÜF¬aôô`û<]ÿû–„õ: œ(˜a!ÆnvâùÈŠ¥´õ ê“ Jgä|âê‹é¥è–çPÅ¢p¢Uõ"J3öØ@· Î Î]ËXWgAšûúÚÙ…˜ÓÞ#WT^CÜ\;˜fz#y!ψoý«á8¶Ù1gÿw³¢Ùžlvt©½^ÖÏ]¬8ñ¸"þŒÑ|2\S`[CÖƤ!ò_Í¿ÁjÅM{‚m7›9 ’nP¼1Ãj•„éü,­°_8{¦¾Ço¢C~½èp¸”ZŠ|·M¬ ,•%wu›k[3Qó*ƒ¦Á±×8àÓÈä$Ö Të ó»Ù‰e„K‹Ì¹hc@EùRÚêÓ«r5’’®t‰Â5óL<Û·‰S¤�úVŽÞ0–馡gší•ýq©ûá¼(¥=Gú:|—¶çž™®hÞÿ¹“oäßVøRgAÙj�É—vÒqŸo2C”˜ŽŠoÝ¿T3k›ŽI°ÛÝ—{(»±ûÓþàet®ÕÿÝz9øÂó€|zôé”!ø˜ø'gÂGyxn= ìÞqø%Þ°šBiæ#‰è„>Meu– ¥áóé„úD€¾µ&7ïAi¢ÐSÉÏ8ß@Ý“´–JæÒ R/²Ÿ”Yœk|e|.æ9‚ÑÅV¡ëX™ôÝÑQ°4?VâånÌFõ Oål^ÆA) ‰Åç¿&$UÍ+“…{ øWšÒÔ°·Bƒ¸=MTî/Z"�×àw ‹ßàEFÖbSO{$?–$Ì«ìFåw¾ÐùML±î´¼dò:BÇ6 B‡Ó?´gê/S°®5ýq6/?q,×SO© N°GªæÞ»!ÍDçÂà¬êk:Ãé,DÛàÛD Ìü°¦Ê%ü,Ðפ3ËMl‘6šQØ3Õ°Lèä…é 9$ wܵ¢Â·©‚wÝÅyñL ?8fâMÌÒbLëÉù¼8ÁN Ç.dÚa€„M§½Â¤‹gìÛPQE/¹·}j™¦¾ÔÝÌýƒ.Ø8ZéÄÊ1°©ÿØûøW5tU©,1êZÜM¨Ÿ·;DÿN_Åó™Ù1«@þÄoϹV œ[”òÜ6ö J¡y´ÀLaSµ™t¡G-QÉîsÄú»ÝõÒx_ÛЩµ2bóö¡Ä·›ÑäP(ê \òg¶¿gÝ‘‚0PR‘ V&8ƒÞƒu‘R¥õ5Cê]*NsŸ"K+lÚQ,œºyV{ø²•gnȶ8OŒSØîLRøï¿+ÞÞ0XäºR/ìŒY"¯ÝÙŒé¢û:J¾ñ8½ó©§õY9Ã3yl¥)DwÑšw¸UÏ7éðçºÊ)°Ï-xÝÍP�eª†öÃbcV»â[#_‡n²fÞåþ:´wr¯•(œ£[ŠÖ'u×Þ«'Û ÍÚýwyM;J݈B^?ÀW”A¹è(óp¤³þ JCV.xO]Q·GßÃ-‘~CÛv�<iRôYÉ\˜C#wôaGi?¯ßþgbUÙ¡(‚Í’Åòî¸ù}}ð†9Žûz+kuwieï’Ì£C}¥§ÚœU4aJQœe˜²þ$É4 ¤l¯}{s §yâëácðYÕUç²w |ˆÅ5ä`nEÐAtêÊrÄê¾(T(aã� Û«‡Yž #Apw˜o¬„‹lšrŠ»ƒkÅ‚ïúîiè#Ÿ(qá.˜ZUŸÈáÄêÈÕÜY²÷I>‘¨ŠD²@²—qÿå1Ðj‹™™Ÿ¥v¾  4ð™Îƒpž\Óc©)©0ù³±—¢ä“’ó^_Ö@q ú�kÎ ¥,”»d‹'4æÖÇó+Óü3ù¸xÊÔtôYAéœ)it°ê‰»Cïå0ð,â!)­\Ó'³àŠI|µ³ÈÒ£›e¤/ Á]à>|'ÀFÞx/ÖD¸Î[Wã°«pja½ñ”6Yé%ËEo‡D¸–Î3jèdjlÝsà–†î¼ºöx~«®Ú£ß‡"Ö¥…æT Aþ¾Ø’ˆ³c}_nˆ°øDÐt_”L‰‘\ß븩õsjœPzHc×Rµ0@ùU*šóÜ­*NB¿ÁBû¬í º´×d3ÅÇe2K<ø‰Ï6;xh¯âÞOž�¨ØHbŽ)=Ø­>bLð`¹‡£’ÈW=A)žè¡ìC5|Táô]ÊPùHM£°e|pÉOÌ’$‹µœBĆ� `Ïï4ÒÅ¥*3TJ‚Ç+âQÖjš›áe¤›kÓ%ÒwB9–ñÆ-Å/û#½N,JñªŽS”­$Ï#0ã’ Ÿ•vêzN,D0J35Hµyïp~cd» "æBQ²î$‰–*ýOš®C fŸËu0/€H&y /s7¾-E# ºQ_ÞlõÏ¡nÏ›E‡·Ï´Áž*…Y¬[¦Ãî ä­ÎêÂáKüKw„goW[²¬4'™pà «RçýÁ‚Ç› ÝëùWHâÕ1`ªÖ®&Ô÷~£Ù“ûHnúðGL±ŠObAÿ`36¼�„š°¾“û¥°ÙµÏFD`¹ÍPÕ»R]ªØ)lÊ �i [À^ÜI÷ÊjNä)$dAúî°6oÿ¼±B V¸RO·‡éÍé<õ‡î¼jã?ˆU¸òA)пøÄÍ»…,§ Zø=™¿f„D¶fHL­É­vk|†/t‚¤:´ñUrëÅf{¼ûeÞläݧO¤ëzÌÀL±yP…M½�toMž"g­"¡G,Ÿ&g‰J ЇxpÖ§½3­³”‘ŠµÒGBû4‚ß‚µÁ ؾÎR Áµ@iŒ�ç]BKêžO¾j°Á-¤¯‚rÖ¦ ò5?FbçÆ¿1§Î 9)Õ†„b,z”e‰i¼âN=<:ôåó±O°fã”~> o bu\Tôç“Y”`…¨ôÌÍÒ¿Ýgqib ÿ¨<R#4…M©êf`02ŒÙïÝ<º^û é¡ ·yª�“¯É‘1Ï}?óO¡sÿÚíº*ãµ+ -Ó$H:Õº,SįÃd”�lðÜ~6.\Á$£Ý™rø©Ý¨Á¯è³àO}²pþÓa¢ª<nÃáØáÄtËæÈòÊ×ÖŠŒcº½5lÇÑý©Ïý—ªè¼ì™§ÉJl" .YÙ†xQ¨à´ýlÿzÑÄCûNK2ß×%dT•×½åŽ:û4”háNÎÌRûÓùp„§æð»´Ñ'a"/°y7»“±Ù“#ÿúá8‰$4¾?ÅAj5ôs9¼¸uªÕ#Uùô¯q¾ý¹­7ãt>~ËKbOÚ‘-çš–å°µ~–&®;P,ÌȘÖùÝ'ßOÊ­22#´Üàµi{CcG©ªÆsêw•ÒcõòT\ÕÞÏ꬘+*‘åŠ-áÞZ«ýÂf­ÊVh^JÇœjð½>ìHŒiÍ’êꩇ¶¤–=!©.„ZÕÙÑQ£óê—°W¤Q9xCkÔ¼œÆúNYßšï·*ÏVá: Ú%²¶v•{SÜžeÙ Ž=×`á ¥WGK+¡¶×Nôûwt„Öµ½Ññ•ùÛ-Üÿ ÎwgÑÈ÷'hf*;>•}oì¥ë˜mð)œ—ÓQ‘gž=ð TŠzgÄÎpaE4V]ˆÝ/©¾\Àäü ¯r ]z÷ó:0ßß›N?×™ZINee®¥öwgÊrí ·Œuly鮢Jg& éÞ[äV1m.*¬?wpP÷³E¯³™{W÷w•ÅȈ™(í*)ï–J”æÜ0œ~…ÂYí,i7l„¬~O¦·ð>p­h=þ<µ5•7tœ±Ú)࿘÷Óxr•ÜŠ4ÆîiA¾;yÝõ±ŸÊ`LŸ_qfŽ“ÔʬJWàD7$³žJ%…PËeànŸÈy‹%ðÈÏP_×íôøVz „öëËdƒ)$¼ÜðÞLå(^¶j·"D¡vÌô™ÃwEI�aÖ\'zS&nXš-ßñ>·èDŰع.Ð5×D¼ Œµîäõ„2…¢%KÀšìOr3Ö?Q&U¹$³À1²Ù&E5­'vn úWQ)8QdlýË— ìÀRwÔi«8›hƒqtë™0¿¦©%±ŒÒcÕšjh9–'çQºÑs‘«í’PeÎó€kFi.ò0'©J˳bÅž6+Ä|ÁÓûûnõó/|w’È´J6KÆ\S¥Œœ<ÍÉýa¡¥À÷qFº½Ÿ"(z5°äãO¤Úܨ'¥Û( ž×câÐ+ØY¬tÚÁï`>›š¥âÆ+ËË~PÜšþ–Á*ê`>¿i–´xxD‡ ¨z4zÂÚÈnÏÓ¿<Ÿµv¢¸t¢•é»Ð‰[k@.A‹ÂSU•?+‰òMEÏ$Œ‚~È‚²™=MUJIûÆ™Þþ$•7¥Úø—¹ó†,RBé-åjrƒZ|¼à©ñÙý³5¦qññLçW‹Öå²sùp¸Ö§ž¤¾²¤T‡"ˆ—½‘Ôâù²ŠŒÅb©'H1V‰°a>à@£†Ö2ˆá¢‡. ¢…}׋ÈAÓŽn+ùÝW)‰Ðr&)¬vÈS‰Ò€W?Ìu½™eýþsˆ<Yõÿ¢ ÉéIóHÐCÉ4Ö“1ø™×Èоsk õ^ó¥ˆ3_Ú¶¤%NÏã]ß¹Ò†’+OÙ.ØIc ‘÷VÙâ;µ¼Yàn³ ZdFàØÅ:ýMHtïÜ=£°‹°–´%‰§+Ýÿá…¾ ›YÈ©"â쯻 WáJŠ65ÜN·¸0w”+4ÈzïÉ_ÿ­$vâR ä‡ m ƒÚábÊâíÃÎ¥¯/¸½à¸ÙŒ&`wÙ«Â,K 󆹿 ŠÈv2@øèÐ@m†æÿ¾eÀ«öÝ—ùOV!öE\pèåì¾y')'#íoãíTá©:Ý»Z› …>( #I8x&['S(< ­úöN[Q”9MûëÀÒ=M©dmýÒàp‚0‡ÉRªî¸ŒLˆD3ýzVgæ !�uíñŒûrŸœ]úV1‚ù¼Ð“·Ð^”ÞØ\ôÿ×~·N2!d‚F×ÞœŽ«E¹óIs`GžĪéŒVW×ú.µUôüzóÙ*�%|o΋¶»ÿ³^׉Œ“Þ|’]{±ÆJÝÐ^öÿª!û„ɘ!Û”5Y1†˜õµ®­çÂ7žX{þŠâ1xÛ Ü*sH.,ÇhP ¤FÕÙå™51EfˆoÌw%·Ì•i1dêË 9kÉȘ‹ôœÎ“í ¹ëGIT¸þ„€^(ïT~Ãgð i•c>,0pJŒ¤$x]ëÞEéšXR dA·³:˜:ñ„ °œV B7@“‘åÞšLE4´“íuÞÅÔQÃã§_(Z«‹î.oŒîcæÌx˜ ¯uõtTæåÀ} S·S}5}ù‡9©U›Ý|Z"W7i÷;s?; Ø@üƒV]œ­äøMû*kµbBDÕê¥(Ä@/Šµ¡¨t=t^ojå…Ë l³äž«`NÇ){€3`ƬË=S„Q;5Wßkϯ &E;4 Ò÷O£zÏžÈ=,–ñèÙÝ·?5?ó8ô·'úÐmdÓŤœØ`ÙuØdhTú·œ·ä›#£q¯,<¨ÿ¡)6o=C)| 5í 1Ѽ>ô‰’Ê¥,LŠg5ÌnÒûÀLÐ^âzƒÖÃ,•ÈhLDT{Õ§HĽêd½2ÕFXÒ˜ਠ›ÔÜx3%¾×Be€OA<¨É4Ý2à-qº"—·ìå_ ÐÄ¡GFç?åÔir‚ƒvà÷!áŒ�Ŭ´ç-”(-=x·l3"P-}¤ùªU%Y(îñ÷z|yoì®cŠçQ~Ò~ý7E¼Ù5j›¸rnüÓÑ3Í0Z>ƒs'éàÞQ¾¿e†N-Œþô¥àÚ˜Mÿš$ ‚ P!¸P%Ï õl|êݘG«Õ±ÚIøÕ¸Á}ðVèã CÇW$MÂÜ%1|{Ú¥ƒŠ§,™Íë^ÁÐ+¹¯-µÓk¹k‘Y8¢T4´Hßµß!%¿z #Ç­²Woàõ¼Ýr¯V¿Eå‘XÃpÙr¼¦Š“Â0”¢”’V቞lgPR/-¤8qi, {x~¦{ís°á tØU~˜ññòÏaøg‹·›ç;¿Ùˆj'd¦‹åÆ.¡îéȪv:˜Ê ™½3h_­u3ô†¨*£´²-Q(± °¦'O;× >+è_„G¬ÿß—ãQ­K�À(½éÔ© ­/*Caú™íâi‰ï*{x.j’¤Ìv9W$ûWÝ;ò ]<¢sûØE@Zé›ÌÎr„0»@‚Ò½žÖ·îVæóõ˜ÛFeqÊ §ëb%Üô rßô™Ûà žºOK…ÑÑe7«Ôj[ñø¢¶CAüÊ;ë'+Û:0:‚æA¹í=AÊÅ¡2±Àà º½¥«Öû=//{çéâĩÈ*oDÕ-ìZó>dQ³¶Ü½ôZ�¡JA'ŠlIÛ;p»J6ÛäB®0ºmtü <¥LãVr.;é`„GP` "ÒŠ7äB³ñÊBÁ':7Þ5Å›Q/òy¨Ê…�¿Ë$÷øvâ)¢GPæàòOh€Zº€3ƒœÆب7ï¨À>!;qvíeÙÈU àÄÊ´VDhLo”svGi÷ q¢Š>¨‡ÝQò°ž¥jSSU|S ä¥e©³| ö$•K}ç©oÓØ ye„§¥ ~²Ó<,½µG{¦£õ.;“<I¶%ðÞîÿ}«rp«(?h1¬]?¥»gw“;åvœg7¶Usžéôîþ—&C¤¹Â\É[ð3B°ßëãÆâþ‹‹v‚F÷µSkc:«ê/ûŠ•ßM<'ü*W./ëÖ´¬HçÜÕ\ªºA÷^<77¸­4ÏB0ÉrÊ’¬Š/D}è0¡Shw·ùøX !]ûeâé3v†Zy¤#­0OÒˆ~L’æqæ)ÇYp8eA¼×õŸ±ªåx¬½hN™Ϭº iZѪ±ñ¼&VšÝØ Â ù†cÒs‚q+¥ZïüÊ Æ*a³×ÐQèJ§OO ýÈ. †åVoÆccøY?3\Bg² ¨ßåR¡䥲µçmƒ'@ŸxÛ‰féw3oI4óÆ3kjÜA;Ekƨv´—1ü–½ ‡Í”¿ˆÙ´:)ã•Nجô›)mÍ}õoÚP§Î­È>²½´ ¸y2Ÿu@ònÚK8P x,L¸‘›¤ß¦Tö¤ d‘ÿNÞ[…Jž|Ï|^‰+×xæVƒþöÅ?”—þ¶£Ü㈿“XVPbN*s˜ºðMþŠ¡NÒÖ5\ÚÒ+k˜¡guwPó`,Ôœ§¡{}*…‘¾K`€YÄçÍ)ÞÑazÛtÈox u43ö¤§ ñ‰ç¿Y£©Ä¸œ¤=ÙˆÁˆœ.®ôXcœ–cíûÿŽ2X¶B©ˆð 4}Å*!�.žÝH­5²÷—Œ"þR[ºrJ/±-€¯°gVt’vÓäög q“#<>ÙqX†^??L)Î ¹§Ùë*¿]¸Ñ´Ûc€Ã>A´éøï·ÂkÆ~v„·ª[ôFG9JùÙjIi}g*J>Üÿ2X‘—§Uyžy¦l˜Í¥^ýà973)çýÚ]£kk†CÏÜr­ÂXfÌMd1€•¨•‡’Íñ*œ(qÈ{1ñ:Z¸õÙ¦FJ;Lî.QñÅßÝ6à lÁµ7²÷—XŠ¼UIRfÛîµµBæf6‰é?ú/viL«#¸P¬¯N[º±ðŸÛ|kû‹,~¼>3]à>øeŠ$[©Ö—ÀQȸó-@h&' ÖÓEêm¼èIBT»ìèíl“‚æXY ÿ@›ßèþñN‡£Vñ ús$ïÿzBzS·ãæ 3"’æssþ÷_Ø0  î)�´®Ÿp÷—ˆ¤ÚûR9PZö$»v²ìè×'”yâD@÷ÐY±'£É%àXÕò³³*uµÈ¸»‹§ªaQ¶çÀ~šè)T§Î³'n_ÎLÙ UÛ…±C!­<t–Þøü|,pÜlNzˆO&µÂw`Žu_ÈëŒ�kwšÇ£ÿ/¯ÍŽgfv¥®Í)Æ~¢O¼wš¡ÙŽÆÿì,±½®B»¬kT®æêÑ¡¸[YëĈ}1Ïía4gmÅA™û7V¬ZéÿÓŽÞ–A2,Ž2Žƒœ€ÎuÛ©Þ,þå¥þè´öM>¶Í@6. wOƒtnœ²5‡Æ#ðƒÁh(CÞ>~ë()ý’(Ú‡>²í§Åâ{Içr¥u¡ë“r(É¿ÙÌlX´c0†´=HôÝOùäóÆŽ)"ß»> òY5÷ØkžÞ»›þŒ%F[ö—¶Pô8¬íÐÓ‰”9ÅB ­¦îô+ë³2öTT.9·ï WZlÊЖÖ÷ü»˜nglŒñ¡~‘êkC*.Ù?9ìù¨(ÅWzQ––XÔf.‚²n<ýÔNƆ,ž#¼éÙ¿ FO£ÈÇ‹Ñj<RžÌE–" P ΄�P_0Ei J¯3Ò›yêݪx¼yÿ¸ 3ßB‰ôB¥XoQk�Þ\ ìhÂç/µÊÙ{Êœ‘2©àQ….„œÉ©½Vtw´Ë+`_L¼Û[©§(I};!nЧ,¹šXµX¿c:¡ÍÂ…Ú¾Ž·˜)5¨?JGÆÁZ°XœÐKÏ]ÿ6î@üÔò‹GQøH?L{Ú{ù§*ÃI³Iú‰NIܸÐúCrWæ²òºnÌEYì LMh¯°ç³6Ñ„2ÀœF�æOi=e 8âFÂ5‡?;Ï,ˆzõÅçƒbœþû–›¥L©¡{€>�] •7Úx~‹#“Zˆ¦œýµmíÊ™©kß>€ü4Ó)zÞÌâ°zqú*w'hK§Ÿ–§±Gïiù[ë{ÆWq•®4(�ÏÎvQ1˜Ü_C˜ÞÛ7±€>|™`ÿ�¨Ð“œ1b¹…LOyvš„˜<¥]q-åÀ“ÞפtÖ2Ÿ L„3³{w§½ M…ö\3p‡;’/²e2•ŸÑ6Êf‰•ÿ8®·Ãvøg@íJyv®þ¸}µh:ø²i4Ò‡‹A�”k[Í*<g•(î]­E)tripA¸9ÀL^o®þöíÑ=Y”¢È|:½ßeB-:L6 ð:Š&õüÓñÞ××Ë•n" /ÜZ0Øj+ uc_Ñ2[æp‹ÒÓÁ’®ŒÈ ¼a×äM|˜ðÑ­‰·òÁ#‡ÎÕšŸç}'F¿3<…¾ÃD‹Âï¹á´iáWÝ`žgÊŽGãøáƒjxö"ÃwµÚ¥±g+²J îñΗ3«^é48Ÿ^9Ãׯ€è­#Jå&›d‰ýõŽÖ†CØÕ"Þd^¡$®v\Ý`²q2z"]ÆÐÇ+ƒ’EÑ#㥡5”46#/7þ÷•9⦼#ò'P5΂ìSÏŠ4tÖRfoÿ¼•…šªímÛö/DŽ‹Ä͠˺!e×`ƒÀ‰-¶UÛœæu}O>–œ¾É½§AZÔÖç–*µ†½íÅÚvöR3) Ÿ_Awo_gAòÕzbÜýÕ¨¼9(›ŒôÞ}¯q^”¾ G³<ʪ[m›GG›2&‹þÜIïæ‡)=¸Q^ÚÃw}’2OÖRbÃö`æòFl ?+¹Oû 7膅7 Ü ÕþÉ M }œ —Ž·Ä%~í)&;Ì?ò;®¥¿¥!vŒ¬–çŒV»<°‡�Sýâ¡Â‚ó—ٸϤ-¢,÷…)åëhÅŸêçœÇ죊ÁË=ð-å#æ|oMy=²„Ýœ¥bõõ¡Bqn}'BÀ?›óéá™T>F+du4Zí6ôFP¿ ® S@=8ötKxFô+Lo¬ŽA±øÏÓî?AÃå½µnlqÀ¶� ÝßíßèX UOç͇/,zû³i÷š©þ— ³O彆}D%ûüæµN C’ù˜€¢»(“‹eOQö ÿGÓ|‡ŽàÎÙ–“]W£aç•ûnìߨ4«ç·Ã\oÕ†uf Çß[¯¦ÉÊ>tòÌgÇ3ån-¦ïc¸žÀ¹Ò0ów8Àg p?ÕÝ €.q?²åËÆyü¤éJO ·ê!AhEœ%çF‘Ù%&ìâ÷ ×»Õ¦¤UŸ@wÑÄÖœû$(¯:‚ˆCÎõNÐsd_¤ç³qRø:�¬8åàM÷N £ŸõzAŠäÞ9'+EÁ0 zª¢ÁŠo”²]„ï&ÛgœŽ3fòˆ½Úø†b¬Ø7apÂß'ãþ´å'Šô†C7+ì¾uݦI<3Œûw«li@Ó—Ž -w‚àÓÙaa7�›u\¢÷ èz/ ”ÿKÁ5\ŸK&óÃvc{ "Ãâ)\|ž*Ëjgó¬É= Ï.c¢|ÕŒîï¨#;ÁZ1ÌàŒ,<õJÓ7¡\%dÓ²T}¡ ô“*ø&Ý È°XLO•òpV¶73á{„DZqNcÖ]NÊ[?ÖS÷’£ùh»Y7®s`¿ñb¿Íñ …’'ÑuN·§ùrò*”yó<êü¬f«v•ó(ÿR;&6£.œF&ÇF….6g(¯éî ‚œv×]O\‡^+M™ÜÀs<NŽÉ¨lCž«©AêÏF©™—ˆ³†ÔL©k^wNfÏBݲ'þGkÁ›Åœ:œè(ÊæÖs/¥o}O'k,¨@»ï÷xVí#’Aw4˜I4:öÈŠµgI7µŠˆ~Í)tÂuœÍœ ÚÚ9ÄD׫T±Ôão|+lûV¦Û^ùýßÒòø6(ÓYãh±R¹PÈ‹U{~MàÈJGÆz³…ck#"{j¹AàÖZ”K<z¥Ä0qZà1«{ú'ÙzÖi7î:ßµkŸ‹ØZìb›†ò´G˜­?-ß�S)||ãØõQ¶Í³n¦?Îᤰ¥?´½etFV6Ô¿ÓZYÌŒ¤=~�·<èÆph­h±3:Ô7¯~wT¡hc…Aþ©Ãœ,gÓž’ åïwî'Þ¾Z{°uò¦Ás¼*Ä©>QLáSÀÂû̆ì‰0¯8ÊZ·“¤øüo¢EY™zäUx—˜p_- ù_êV«¶$+U;»û–}¡M½H¯o¥½ÿíOös•™íUñª .¡“toÌCt©P2¿5#ýqÓøY,)+WâŽ9`¶hYÏ.Ç£„àä€ø-)úó¨Ú‚l­£À ÈV�°Jý¢Ü¸àtÑæ4Ë¥×z€ÆuÝ!‚_�G¢þ©’y³‡ÉH¯tÁ,´¾Åcýá¦Oìàÿý'‹*Ñ180ˆ•WAÚéêó\Ïó¡Öã1QH-R—a²wæG/zÏ@Nr»9ŠÚzÊ"÷âEgS;+©ø@Z1ö¬Ý„"?A±X;�ä%ôÙ6Þ"Dc^ºZM-[' ½z%1X;z;+‹TÜ– ùŽ9eú¶Îý åæ§}wZõé<vÓŽ"_úÕºñö±~§ïzØع…yA$$WKšEIÊ è­\HüØ \üËŸÿŠõÕËtDÖÅAR+‰tØ=êVmRχ;W÷Ú™±õ9Sõœs“emQ´E æ}f(ù³,i{ú \»P~VQÈ´8ëœSχ‘Š£Í†#Üõ»OnœØmu&Iq‚œ–ÇpJîjms/û©–a±K‹¹†~Å™Ä6&B3 c$a-B'a¤:·Öh©kš‹1ñêk:°Îo;0Õn~Rì¯×g©‚n ›´(ZD¿¢fcO4ýmËŒ°ºiÀ‚¼ËÈMr­a*+(—Õv29fÅÄØeÖœó+¢þ~PVy¶RÖ[¶8¥Îæ �ÓÖ"UÅçâÜ{éz>–õõ2Ĭ/�0J〧´yx°V`e‰(LÍbª›G:ø No ¹Eg)i OSUÀs “„[™Òñ[¯4”‰ÆKõÖsW?ÆßFæð®]ý(|͉־뮣ÛÚÔþ_å9Ðú'Þ¶e¤È .å(e RžFF·çx˜»‰,*†>œL€‚mýèpëžþ„fléíá¹£C×J>Ð7:»ÆK=%_w̬?– §h;œ›Œ xÎFºu¥;èŒýò0©O«Âù«3zj�ì£öì`a4GÆ}œòà G®ŽØªJ)³ùì’,XÞœFáÜ÷W ,jiˆ²Ç)+&íúš!xO÷ëUª2‡†~:ë°¿§œŸág<‘·ÿŨ…kCÿG9Ÿ$ }“9�¯clM¶Ñ†³/|<ÈåÏÒ¡Çòá¾aÛQ:µ·"dÓøv%N@YÑ¡x×é»7¬¨$d^_ý&Èu «9„àþÝ€ã©f—yfôϚ˹ö„¶.hñØ°!3äW¦ÌñÚã â?P9<)c+7z Œåçví‡÷¦ºŒõã4vlƒŠOÉ% 駢úŠ\ŒDíÿʈ,)ý²~Kõ~Ø k]¿‹­5âξJ[lhÝ…9i=kèpáŒÝƒR :ÀýQ8·ÚÄûs˜v‡ýDqo~¼' S„4C"½Ó¶Ýí´Vˆ@•›;�̾ÝÔíAF1^åMIòcPq¹µ(Îû3ô]º½3[h[șп22+Cßñ‚û/U-­GŠn§ó¡åIÍü4—dEæÑ[yRVÙ»¢Q@Š9!1tî.M¦æ•toP™7¾&²)•¹ïQtöÃ-†Ê’¿º?Ex<Û}$¬ ‰0·éÚ1–¤ÊžÌ£ßüÓwÿh¿Ã–5ö®å|bòä{ãMè>Ï<"äné“Ó‚3íâËanºgýF…â%kÚÔV4n™ëiÔŽôv¤¼Í�',§è†QmðžCÝz\?ý\çžw ªù]ħOO4°¸Ù¬M'rª^GŸ¢ÄX¡÷°=99–{¤eåMk9%RæJ&î;²þí"I, â x"”ÕîwªõšŸ„ßï)ÿšÞ‰%ªïýô09­ —ñäzËГœ49…Æb·¼‰AëÜ(„`ªÞø}±ös‹e¢G*Ï w0Ï(šÍ8SþIûÞ剛zjègHâÌËÿ{£e:ßsŽâÄý%&©ËPÛ#iUüf˜§™O‡devŒžu蟅ÌÃZ˜‰-ÙòÂ%ÝCöèÆ°‡SîÞ3yl¡Û¡°è×Áh•Wú³Žj?PQ¾ÌŠˆ— ëNîƒ^:‘0*œ2L„·$…×4‹,ö4À îÁ}@¢£Q«Ø˜Q:ÿçY¼`däþïMÇ¡Æ(Ç¢-vû·SWxWkt`™øJˆ”ô€-¨¬+ŠÐÖŽ”3ÕЧ6 ÌS}Ô&–¨UâyDÚ²•d7mîvO¶¶S.ÄŽ‰„llBëÝÆ+ø ¤j{Lß=9sÚ=õÅžèÿc|O<¸ºX@ÂE'í¿Lá…Ôxü’²qx¦’ÜÐ~ î‰ws„kÙwyT“MŠÈ£®+í,5ÜÔ«u£85Ry¹(Ä֬ъåyÅÚåP™Î³º¸ý¨T°ÖSG1¡¿4ù3Zúü³í ¶´(y^ßÞÕw×Ú¨Ìü E*`õÕ·Ídòõïô¿¬Tgĵ­Îi‰Ièt‡ÃòV°Ð®´×ß:¼Ç ºtôìAï öë³ÑXiF¾=þ­Šþ“FÙJõ ÚóT•í`¥,7FæB„a qμ؄7ó˜»"Ô·Ðÿ¶½¨ÂLÛÔ,í8ië]Þ5*X©ù2Ýlè(`—{Eg¥¿ƒ_«Ûƒñi×&rÐðP§0T¤c¥Ù{š-G×ûè¸mmäÕç½È¶?„)Gq¶’&7æ¿‹Õ/ŒE÷ºÑŽ;ýuÐî_“Àn,~¿¶Œ}{è[‹×³§a#]=Mjÿ 5û¬Ð{¿’[vGZè–¤WyhÈTlK¡¼Úz©“ÏÓýAáÛy¥ˆÖeõýÎ ®S ø²JØó€çZ?ž¡ÖhÊø{V@½Òš>ygA&¼^–«y’Œ ‚Ùñ _¹F¢ æZŒhÄ#è,[c1|Š“ÚÏζ Ê \ »+í­¦Qî£)!†A²×T¼JY¿Ž5„ŒÐ"^J/x”‰i`Zø˜lšÔjˆÞÈ ÝÊ £E$�Ý`ÆÇörWh·'ùv¡š±Ó˜Ÿ‚R¾AÐßöðfõ ÏÆà7ø%dPžeëÆx|…EÞ%lïÓÈáB7F´5Z6ÓxÅ—¦±/˜WBÅ+õ,Y"`Ö!7pœ…Â){@5¼þ-/»Ä2#¸Yè{½ÿkn©lh±LóÛtéJÂÉPEžZ{2Hbâ××ðazw=}ëÕð©¹:S—oW:ÏÊWôZ l¶“ ¯B¦q¦~ŒN:Þõº8\j¥<2ºA'tCÚH&±‰yÒM {T)=)WW/·w¾(|<,”Ž-‹ë¶°”’rnÿ7ÌN®é’j/ mû¼þ²ÃU:ê}ç<Âv�ÅÎV„âíJߎq;7?ºÞc’ù^ÐT•nþ9xÅ5CQÌê=þÑ*Ê%œ°x7²#Ùú§o hZ }$êse™ï]„U¹Wá׆ýôå™jŽå ¦À.Ò“x¿XAäQ±¨Xª‡4|ÄXxÚ,¯Õ£lÿ²ÜD‚ç(_“El„ìoôsÎ%Ì�‚hµ½‘ðäø*ÙOÍ$25î‡z`Q¢gsh¬z›™…¾­"™Çkke ŒÐ»º/ý/-µL­¤ßè ìöwœO“JAK§ÈeÜOeµÊÔïd åY§Aq<³zxWs›³{:Ó¢<œ~`„«Í^6¥ÕÖN|34S1Ùeü‹Qå¡Á<:®¥fç]Ýé;AfÂœ™P©·“Ä}\S|±4ÉÜHFøúOp9ðb|¦THZF€¨ÙˆÕò™vé;÷¯NC›§ 5‚¢yƸ?3dåœk !‹¶ÕnÊ4^X ¼ÛæÇ´ÿœàì¡…ä|YIR[Ý-#J=ê‘sïêû’²@̘‘Ú´S0é·°ÅAÎ6tPbø/'ŽY”yömPœëhCXHÄߣvVýFß½£jþ¾oç6.zcŸ…5?àLP–`ÆBT×7á¸:+§õl¤Üÿä> eÔGFA}žCúûºŒ“Œ•fÚYÞy* lµR‹¾ýBŒS‡öÑÏà †¾‡8l5…³xPœ}`úšTЋ}ßÍ~º¶‚˜Ä sC;˜®ãꜗؗ¬¥êì2•Ae¿NÛa,Tsf%a´ç¥ž(;ÇÉøïOgLów®¦Ã¯ÇêÏq¡SÑñšxú7œÿƧ£z0?Û;É7õ65aaç5ÝŒ5¡Õ9•«¦„ÎW%ë€Jûw¿¸Evn«((̸ubè֑ņ– á9âN7=Ë6ï»7¨‘Ðÿdþ‚p‘ù< ‰fÄï½-`Eø”k,AîÿR·)RDÛ6p8A3o÷îa® QÔwÇÑB ÁEBÿ #Ï»–>œˆáý°‹LÞº|¹~PÄ"y¦Ë—GÀxîi½„T§^à÷ÓÕ™2€,5#¢+Ärꎌ¸²`{`§°ý¼Tù'0pŽ=´°iÝû2ŒÇVuóÁŽPtyîQjgÕóì0Ϙ#í|ß Smš FÕ?‡¨,ñpÁŒcd¸tb·5BÔ¼éÝåïºXoà3…Ïø`:õtY#†žìØ|ö¹3¸Òo–q:£Óaøº‘ÝU€³jC@Žð¬3ª6ßÜt5„ÒùP truêÀÑÖ§GpæeñŸ´÷È ]ý2HUXUÊ8\9›¾ŒÅr aéÀü’ê«àK±P°c,?èþÀ_X`Æg¢' ˆaµÞfì½e×¾$€å¬ƒsƒƒÚ4 «]ª~0¶Æÿï[jÅS56•ø%£ÝÎC5U¡‚¤¢…Û™T‘6®h@qñ¬}tþKÛ¾ÛíIýjÙµ+&´©H\œ·å©.è[Áðóä_•`MÓ5€"ÞUþ�$O:ÎxþίØÎø*£œÏF“é`éþÈÚ¡‡5ïÇa=àÅßXMF©oÙF»®Çôþà¶3a"\t/ÍÄÇéï ew„‹É0ô´[ÏÃXœ¥6¾›þ`êdŸiQó?¢] ge!úhË@¡Øv6€ê±;!ÀCúߪËó÷+ÞøдJšŒR¢ðF¹r€öpÙéUÑ“ëF`NIçû¶›&‡ÑmGóeünå98±y ßÅ°·(°Jè,j³È¨×î¹ýÙÈŠ‹:Œa)­~Bìta¶V[>©4jtŽVo7Ÿè ¬U×Τ{eà~oVg}ØÁ—îé„Ñ”yñl. ³›^˜“eˆ¥Ñ,2”®»Þ ”{{7=Ñ¢•x�¨us$ó¿ÞÄh®ÿŒW«!õK[è$¬Bg—Dqx×gAú©IP 6 -Kqv¢Sw<·7/ßiaQºò±¤˜ÕÀ30<5N@Ç;m÷Q1ª‚†y; o;z„õ0Úïa¦UÚ=¹ùÑS‹3Ä«08&´¦Þwžzì�íºÁQ§Nš9ÞAõƒ:eúFXh~LIÖŠ‰ŠþX³KŸ‰hžýí« íYú)¥Ý>ùòn›¯3p£”7²…¸0Â`©O½öÀÛ7ò¯ï(Xš¾û¥¦ÒÏæž c ¹îVažñrÛ,~,ý_f>Ä ‚˜„ ŸîÝ1±ó´_ŽB’•hZ4iä}íì»X‘MâyÝ›úÑ^°å'ž!„ÿÔ¸én.ºÄ\ÈËÀ8iðLî)OEj mž`á2¾ÁdZ8\jÎ&Pû¦Ï•ÐOßM·d¡'ò¾‰‡JVƒ8™Ñüe’ ¸Xˆºü hJqWÏ¥§ìH UI蘦]‰ÄÜr©ÇM¢m¶&gÓŸCµ>ß¡£ö"¢ø@žòQ�N®ÏMŠÎÝ@å|ž)–þ_šjz ˆÍ‡¶WŒ]­¶ýÆH�tWg¯¬¦ëÿØÿDuà­¸@Æ™SG@Öù*+–Ä�´Æõõ$Ýèá<“æÛ… A:±Âþ¶RUì^øÈ” s_µ9³¯Uýhg÷ØFßzqâò~î߈«K{ö ãA‡”™œJÓŠ£Ë3k$ •sûAš¡£³¥õÐÐŽ‡«Ì21“•!­ÃšIÏýõE|†š#Ñ“L¨”¡`ÿ¯'gÕ"ñËå‹• Í$nw¦\¥Ü{nT-vRs;ÚÓy±Æáý@y¡™*û…5Ô¶FÒÄ÷(Úõ*u†g"¡Þm?º;l3x`Ê2Ôêa=³ŽœçddÞw¾Ðò,í1Œ]0²BÛŠ1ðP§=^ƒq£©«uO£ð™¿ DÒ 3\K•:ôG6Hø¡;—¤¾9\Qk*Ú»³W´ŸFŒ¿œC@νK¨uŒ ñÒÇq‘H›K[ÑÞô(7‰¦Û|XÜ Ôé/´+-sãCG{ÅS77ã´m(Q•ÎêÞ™^%~©Ëbt8ŸƒÕ1zõ¦… ?þ¨h01'Sæ7?ÞSeñ6“°iN€Åg S*Œêlu­·_€5$wit¸o é*ô)›#Lé Ø)4€¾"±Ø9™I7ô5ÙvÅy{eø~ß´”²Ì"È-*úžïgOÏCZE&ÑÊìŒe¶ßTÒÜõhØùaÁ¸ô}çK…œ·[ ªœò@ÍecŠ4Ã(Áh… ©±´ }cT }(ñiå‡æ S¦-8«Ø'²þ‘z›y*[{¿œ4€U0·<üá “¼˜YO_ņæÎ]­¼þ0×?¨³2å‹X¨ÝyöÇ/’¨}{½=Ê¿•@ìÊ^ 6Ìš`ƒIñ-ÙÿG{öt¥ GIâ´K#¶F”D,¹’j·hç^\©ö÷'ÜïW.ƒ6>‰`V³^† eÀDN>—k‹]ð¶; ¡û½jÇ&bkNál©aܾì¬ýœq§ Êwo©ÉE8{Qø¼FL?tŽ81¾fdc+ooõŽõÁJŸÕRÿ|[í±WZ ¯Ôóüd]€±ŒÄ}e%aÞšóôŽkxãø‚s$½, ßDK £)+©øÃÉ…‰a.‰º J5%éûOÓzÄdpšJäÏ×MÍkë$ýÇ'â7Eä°Y¼J6Ç$ÈßÏد?·¢ˆFúÁu  s5VY±íoá©\]TŸVl Ÿ}Ý¢—È£î{áõç@[噇E9^ÑݶŠ¦ÏƒØÅËúïä»™Îë<:C6ƒ¢4ÜB³É£-É7Hð\¼Ùƒ¿Dehšº†y —4H¾§÷‡h}ëâAûÍüþw”V«"_ûˆy*ƒ¤©½Z–/·ÑŠ:ðøƒ×S·€ÊÖÝÓ{ˆó5ßþÂŒ3«VoÊ”ö[OQ°¯æCχ~uaéíÑÊïãÔ~Þµ•tƒ‰æA1|)eÞ·wò¬«åìwôL'õª§§:Ó '§7Ã)åž»ún혥aè·ó#Ñv‹ê½×k…üZÇ*}Ú1yYÚMåºy Rû˜Y£fLÿ“€¸¬vÒo_ïw§JwÁ�“ÝìvëÍ”ˆ91¬ƒÛÃf™m ¥Å‘5.ÞÕ]5…¼ÒƒTBØ%Í‚ê}ëM7ã -ð6Àè¦]ߘ³¶1õ]¯+±jP•gø„ï'«XWÃLjXQK Ñ€2n_ïˆÔ†ò ²!¡‚®ójkfÍ‚Pmš!l˜xE)Ïü€ t(•âH®âò/XãävÔ¥® ãÕÖŸútÿŽT&ó´IæH,Â,R3“ɉ2…Ì^äØ¿\Æå_CDÜ·ÄCv7SrwzW™lÖª/@RÜn›Áqü cyn„¥X}bŒF_J�çä0:ew8ædj\S&^˜Áò@ŸwЩ­ûùÅùZôŸÄúã)Á|©‚ð¬;”ðE”¹</ÊQ`ïz^¤ÚÇYuã´¹�0ë—³ Aô†œæÀýW”ë;1©}^~¦~»šñlãåeµf([Ø’ÑÎ߉þGô¦°Ïù˜ƒ,á„ âXeç˪X¿|#=³¢ ¢>‹î&Ýìœ]¼Vú gsêºuv£X­õ¸?BEÀu7óK1\Yí#XÙþÌS E´¿ýå ×&gâÉáDqòsñ²cxî¶Ç3:årÔóÆ ó6ÛŠZQ¯ Þ4Y[s˜:}Àë‹lv‹Ã‹4'\r*”Iš„švû[ÿ5fÕŠ¦*Ö”GVŒÔ¼­DÉi+Lvˆv©QNò/A:¹«�b¹”BÆ!¥žD¬n$_€¾,€œËfó,"ÌÍD‹™Gî‰þ0ØM«Ì’éä ô7¶b0™©Z7Ç8¨¾ìÄ(ãäçX_­7‚ŸW{—š°”Þt“Ü`’lUƒ¤ÊM+ƒc£›xÝè:<£a'‰gX“cZ'õÜÞSÐZÆ£%ãþTÄ9ùÔà„{Ld«I‡Ìhã &kJr棃ñŽõ‡ÈÀ.\{ê+zv‰#èEèû(->0MÑvk%YÚqœùž ÀãOÀ5ê=8‚o‹Hb°ÒÓÇ;MÒ¼› U…ê®)—Ÿ• g(Ì&*™Ü"­\6õ™³Öo<o ý†TJŽ¼Ûñt–ÝØ ±1e1(°-eáÔņ~CAc¬mÕ—ò‰Kž­Ðbeež¾<›VøLI¨”<G©><‘á;6»µÞ«J-ŒMß|ÌY @ÁÀ!£Ø ²FJ. $Sˆüá=-ŠÂ!V+n¢Õ)åd¶)ÒA˜TÆNÕ=ËÊ‚Ká]œÑ©Y€[ëCK3kh‹7;ƒUg>úTf/.Óùx2ñ%hdJpÅ|Ë…KhŸŠ%݆­¬íÿË Wúº2‚hË‚ü²xÜ—ã›Âb©Pð ½pƒæ#ô}ì!$EßíB;mV ¨ªBÙÖqpæ9Ž'éà YËD«˜~â‰÷"1CÆ$ÊZE@-…6Ôk¸··?Hû;]À(Z¹¼QæÖ×°4mzX(YšéÿÈÌŠ¬ua„^ÛÖWño£2&Âã±Q‡q@Ÿ˜âo__î)gWEæfÑYâ º=™¤iáiì¯;º…Hâ„èr}]I&ú:a…¡Éé{`S˦÷nû¬âŠŠ=´o_½§(�aàwð@Xj_×qZVaE—²»xa½SíSúèÏ?’ ßö¦‡]:Ê'7{HÇȃlXIÓ«—ÕÕÀvöâë=vôlOƒ7¥5ßNšJ¾öÄãÂI‰‡Lö‰12†^¯ZY@Vª85Æ-;�;8~QF uT ‘<bwîwõqK�ìB±o2Q}ÆæóRðÀ£ðÊZŽûûšêç`g”q``Q~ÿåòØÓÅM÷ÄôyìÓ ž4aŽ¸EÕ*ýßk®°f[<#]¸á^dP{sO¹ÍYgÂZQTV²53o ¨{ËÄÀ”Ï„Ryÿ×\ÄÙÊõžLÏ­sÖ¥´“»¥[˜Ú…ß­½ëŽ‡ü@S£S¼ÖƒŒÒ€Ž¾::H:3 ˜ Îvä7æŒIœ©Ì>ë ïÎUPY­¹e_/u;Ž8cåÓ-“ð9(ÔF:Ë*Äë•D9H¬û³wHQö#­VÎ'“,=v-²Ìƒ#Å„Åf­§8å/Œe#mêU‰ÎÄñtõ¹ØžÌ^ÊÉzéV"FFŸñòtþ mñû‰1¡î†’nîÎgžû^hVþµý™]TeÐ!=5” íó-Z–NÁ-uXµ'³£SLX·•è‹FíV „ù21>² lUq´`?ª¥W8ååÐÏF`Ûè‚?œwDeîÀ¼üÞ›mBÕíÞr’C†qlÞ®ðwïi™°ué~S_zïꞢ]–~¬÷"Ýûl^œÑÂq>ìüü×ìµ¢,¬y�[}Ó™šѬë'c%üúÔÙy?…µÍ ßÇ'k–;ô†È=´ Àp½Ý‰Ý@”f׳Š™¾ûµ³¤¨6£€Lï0UÊr¥IEåL·&?ic—“ÑJí›!Ê2ŽXæõÍðæ„(¢˜1Ãú'Sÿ[ª"´Òª2(ÏÁ)9|AàŠg»ÓÒ¼`׶PivßYb¥>0U†“t@½/êx˜³… œÔ"¦ð}÷Œ€õã<¤‡#ÙŠƒœ¥™'òFËg™ Ïþ dùs_÷Ú…Ôúéy¥-ûHíoŽ£w«²ŸéÜaÓÙˆ3\ß,ÈñWª±%D²¬3°Štë b‡–W½ù0P_£ºñ]èç™äBÿJåÙÝôÏÚo{×½„äWí”­s½© ªèä†j¬A„6³&—§JA ¡o¯ ˆZ‘٠ƹÖÃi …+^°²¥o|¹òÁ¦­lÓ²x >7¼u™+ÅÒWPÐzÀoºÍa¥?Ae[_6sB\GåZ—fÄg´{œˆw«ÌÖU s êÑì}ä‘“%›èĺ0æ®cràmèÈ# D¦_!Þ {õ†VS_œ*¶’ ½^;/ÜüxW˜8”S·f’¿y�v–K0ÎóÚ…yFù?…t÷{aÓw´@«PUpú<Ý܉õ¾0a„ž”tê l^V(o‹¹ø|ÏÒ-Omÿ„Օ霣#õsç�-tF^a°Y…?œäÎSðKªêê*H'­Öióï1|0úZ_ä÷õG'PÛE©¼˜*–ô r[_üâ0,þžnêãRÄÀbù,y’ºAÀ=]”½¥ï„œ=£¤3o~è?¤‹g/(]¾€-¹òq,c0.Ëz•¢€ †p’§C·ž‹ýrN–ä+?YZö`¯wVˆ¤B,§ƒÌ±´žV[‘øÇYK°ˆPJ†ªÁ3ÆGÂ#³#zt0೯¦cxWqÄS’2#Ô–÷b6ö™ÞÒ<בßF �¨Sð1 ˜Íný0QåúË_$£©×*áîfOGZÖŸ=;¡¿¹ ÷1Hθ‰-íaGÛ(<éÞ7j;è+›”k?B*ÞföGƒïÇxë5gÊ}]Ä›ej‹I±¨TøצBšdŽÃL·x°Wg NþD ¯šÖY²÷¸ÄàóÒ1ÄZ\PÝÅ}ÞR¹Ò LxÆŒNå— ÿ-Ð$¯µý„+ü‚Ü…‹p+1âÎ}µçYØ×TìO€sñBøx¹MÅÞ€X8€w&§Ú‡fÌàU›?!<meò&uU‚Ù®v…'ð“ÓöìèF›“w9ƒ šžò¬"¦4›`*8‹eÛÂ; Ê÷}¿8Ÿ TSè†ã@A·Žn¯bv×?CÕKë¹mŽ”W»«F¢7Ÿ¸é³¯/B‚@˜£í�—Ai áÅތʗºOnDI£O/áIìy¸®$q‡7ªåk‹  G;a²Ïâ¹Ðt©v–†^e‰j˜möÑ\ .`2åAyºN_çÞÕ÷ä×B> 3 ž¯`Z´Ó­ã±üèÐ6Øì¯Cß3hàBq”rQ}̲ôyð�®œ¬¸KÎÝÈÉ*ú¢ 6 鯲çl¯À¤‹ ‚c ¥ý[<NDxvqê ¯5<\`+rÌŒc6l-º¢y²½®?lèhî:¾@šŠ¬HE.{;@Rp±ƒ»*0Š'¼Vì±v¨8¢¿¡:•‘Â/ ;æ^)ËžµÝéið2Lä†ù—È$WððÁOÙáVµ¥= P©!¹2jr[*ÀQ™ˆ µk¾ÎŒÛ÷üïÍÜ4UP\;•c¥ºÑ¦Ë fÎNø…k{ËÔK ÏT”& ˆ¯ù sÅÏ-šDÕºÑ^K/;‚}é¡T3eñƒZØ9§µW9ê+=S^ð'F“ðù„ñÍT{ƘŠ^?v0<¶†å"ëöŠ¸›EÝ2›‚ùûerµÒ1c¹óL4áồç¹N”©ë­âJd±pCdú¡’έÇF›Oh!L7rÊòÿ°N¨#§al'¸âô%¦ÁëlØBvvÆwÔ§n¨Y˜yãâ±KG¢µ,xbk¨+¿—§³R<qhÀ'\üן›HäŸÄ˜îoë~TwZö§h¨QISuwúJ¨1‚ŒY¡™áì®O 6²ïª ?_Ü‚â`À(eEÁÀ79_½ =4e}$U©ïB"ëvtgÏ:£ÃàáêxÕªÜñš„‡%9 %Fì/‚°WCiÈ°È#¾1¬Y?³0~þ¥?âDîCLKà]—�ÌÀ0WmÀ(ÌV˜¢ïøùÜVUä]iÅn–2(gef¥êIÈ?“Æšèï|©/ÿgZƒTë‹Ÿ‰J›™ó„ Û¯O¯µ§àñf¨ÁŸûï¬]#«mÊ9 &®ý…®u} ZÈÇz~æuwË>E–‘i>P±…cŽ!¢íÑüÀg[2Uc/E¯÷G«$k¦Š}hÕé˜85ÕGVêÀFãïo÷zjã·÷˜ªÞÏpJ;ujkšrƒÙöûÏì.`^Ô ’eçs÷妉ïõÑÅØ+zÁíŽ2ÈúàFf§ñrÍ¿H"3OÔ‰#�SÉ»'‘Ò¾´Cf!uÅ p)7×ÏÈH|GöV5”Ù¿Ù2[ù•÷Hœ:<[S—?H‡OÛ¡?ÕU ÌÇ?œ¤38ûæ§[_­ÄóßÎñù¯ÐvM, šhK¯Ò}ýEGðw iîã)„ DkÚÂ_±äæ»i7¹ ]ìÊ®Ë?ÎÅ w,ŠûJ{`~5¯kåtr¹E7ø<aéJ¸ÞÝßÝ®çÌ·Jì T Ô®£R·x_<˜üÇõ¨`F:I𺲉?@ãø†—8öôö /ó‚Ó—ºp‡ù Ê¢"ó|à Š÷I7ï½ ¶|V¹ @òùŸ†UL¯ýÁo ×û”úèæ¦g_½¦¦×ÁÂ2¶p«ÒY²ë©£l÷ºwpL&;3‘>é$úHG†ˆÿõ¡…E¶V÷ÊûEKìáÆ .k‹†‰Ëæ#nHÐSˆ‹a¤Úm”˜/B6zôêZÓandû3–gm2¢ä[¨È¾ÎŽsª²ÉFRUZÀÚ7{ñ¬–Źú›Á)fI¹süȃ¤¶dñp¬/ :æ¯pEþ›·f¦sÚ@¹ÅiÐÆø#HQ PèÐr!¯MjŠ!|hýOÒÄYfFü¡¡CízÊï§ÉÂ;~Ï«Üå÷/W˜EßéaÿE1ökòŒ‹/õ䥓{°9ê/ûºa’/µïG§õŒÏÌÉ¿9=X@¤É);õç#›"¬»Q7M©¨X3›CV¤…c¼›}4ZV›åUQÚ¸ôž4 dz¦D¸û×Ò™Ou2Õ˜®àñÒÏÂFý•À„•Ê³¢­(J>Vrª"ª·/L'@ô[ K ê?¿»zgS_€ÛblÕsì<… ¿ ¡ yFA>–㺲‚´jµoÎ(’Û‡ŽKè$ù(гf DºÒ.jPw:/ÜL¸åoõtt>bÓhÞÏ»tÝnQþN€ª¶âÈ ¯kã’ |`@—gæ Q˜¤ŒÃ2Î!¤†¬ä¢ï[åFWÌY‘ý5µµ¬BÏ@.Œ´¼×½Ã*µhÙŽñ¯«{ëÜ3ŒM¸¡9[ĶSÉ&϶ýÓ4±¥° ÕܧAöyõr®¥¬W› €ï—ø¾è?IYd¾Oúq­ÈúË“oF›»7 %z\¾KnÛK ›ÖÒ,eæÚ‡âdO7$q3`ˆÇá ½‰7OU𷸤Ô+R*™óA…Är[s±ÆOöÁBtœ¥Áv‚Xÿôxä—”žF…ÂeÚ”-N"òƒª‰Äqü( % ÏàÞtºn~TÍ+Ð^!ÔÓÙÎ, ÓƒB–¤ûØÊ¡¾ìQ8¹nñÙìúü­-{#xËAbóÙ_6y£Ä CUhƒúöé«Bå[cãƒï5õëÂP¥Û9σbh<‹íãB%ß÷ 5¯M9¢<v24‹Ñî(AÜùÍFkQfµÌÅòÎHÛØš,c5¿Wõž\/[>ìÛ’ÂQíæA" Ãôq|F`Ô¬{×G‰©á ‹œtv½ ë(¡K¿hý!¤ƒAbêOÿ ÍCÌn.[Š%åpÒ,; Lz£F¦ k/™8K})ô˪A.­‡«ûPZ¼éwü†Ï…+Ô*KC.ö¤n*JICSÖɪ9s2l^˜Æ‘ç4œ y€*´V+4xµQVì§Ùôe)³i¤Ãë®dKÿ@˜Éb_ð€ö[ßÃeVý<nä¶o\¯=#=Ä>܃›~ÓlûO…îºÓ€Î)ô<†¥e™/ƒ„O6GARBFÎJÜIàC5“ÔË( h”S²×Y#vmè?tÍ5õ4]Í¿¿óDTOØ;)µŸ(h¾úH%ñ$OîPôŠpYß Uý ¯à鈽ÜÂ8h÷9mÚ/×÷xÏò­ù ãJß…¥Þ‚TÓÒËû™—ð± I|±ùœLo¡[¨™è|žšƒ°ÛÌÅ: `GÁ}è[„¾ ðÔÍ+?m‘«ôM=m•Þ>Gœs ˜æt«ýá«úb:ßPÉ–ž²ÅKˆ¶v͈íñ¢Öe¦†tÜ·; <Û*/ÄM:o&3Ö=ƒ)Œ|4 -Á‘+&/gåx$mËi™…ï]zªsâ„Jßؘ|Pá••ý¿oTF4%Ø l¤{g<ˆvãD™ËüDéNº PÞâ m{y)%ô¬«½k™n/ž÷â±; ñ�S¯ød9ÝIEÒZiš«úìټ˚—Õ#*yú*¨,/sv³¸ö ž3Ò[šDÁ9!UÄã¡ ˜k¥ŠGt‰…³/§ó‘¥Dùãæl5•yÍ Ú–öß6{Ì*ŒènÓëÿ7¦Ó­¹::ŠÂ H>-z“v[ÈÌ&YÌø= ˆÍ(5‚ÐÊNµ‹n2 zU?ÊéþFfhÛm¢"³äóð§mãV560†S&ôüH²ôy-);ÊB槺([ÀDŠäƒÿ¶²¾Q’þÝäH oD!˜nW >ŒNåÛ¡/†�0ãØY‘6“Pws¢.WÊ*Q­e2Ù¯žÄba–qd@r:ü8´”Ýn\ÚùW®õ*UfNp€Naúyq61èkйù†¿«DR:áf'ù~¿+*Ÿ]ËZ\IP.µ}ËÊäh¸�(• °O$œ<Zlç+†ìö,ŸVŒœ»”¸XH:5Ÿ1]åƒøþå·ú(Ë­³¯TÞuOG=¥ñž(³ÛvØ_v=]ºþrÖ/|ãÃ{ó%”’fFB`ÚåAÚ)d:xMa÷Ê;îºjò®ò^R®0£! –S?½î&³¶±îøÝù(êë¶ûud÷`ƒÒðX¶tÿ‹«5ý*Œš€z‚«ÆÝ òÞÓ:ÃQ#”Y;RjÍÊu\ÓB=óH= þ[Þ•*'þ猌t¼_Á§îøv}£óTÚ‹}ýLþ™)Òþy€þ âNf4ýäMeuj+=𓾘—0÷šo¬½lÙ C9ôŽ ò;ä²Ce–æF3³;¬kÓQ‘Ô&i“¸ñFˆ†jÒÒø™êúB<ËïJVPŒlÿWm±î¢›Ðâ½gÀQ®Ù¢QÐ ¡œOIx{Xþ¥7½zb„¯qÜüaò‰1qAQš…1‚Œ<fõcÏú2/˜ëºV»ˆ‹UÁ¥-ØAÇ ¾ªÀÈGËJ™ê¶GûT_@f�Á¾W}iì´›ñLƒë˜"tŸ¼Æ@EÌø‘þ(óÝ¿90ÊÐ〱 ¢LÔžMŒ¤²P�;l¾©ÜÄa†f!ë7æGÃb‘7¯«i|e RsF*v†}>@ר`Aä§Õj'Òú^•íŠèa¥N;'gà„ëµÛ@èj‘¢?¼"…Ï`2QÅ?%“à |&}ûç-5¿øí2öÈÝä¶qµ¢“ycD4¬ÓJ´W¾¨¨�¬ñÔy”ä |?dä#=dZÓ]0wßöÃƨfÜb¿ò¸D«BšoÑõä)JÃ%zçè±` 0ÒïÅ\µ²�gÿˆ3Û!Wαº[ÆÓü{K˜XýtŒ$Ìnc4»-ßa § O¹ù¢M2R­§ópk½åÍøYåcF߶¬ÿuÙs}¦Õ0Üx$<sÕ³Z1¹&õPɨšµŽÔ‘׳Û\¼ãz�Gø¤’f±sžËÙ±³ h4J¢@0“ð\ùÇ¿˜AÇžLyžأˆ¹áe›STí<—SDU‹B”iÕ™«gs$5u= ¤„;ø5ªð܉–øá4ßðÐ3œË\¬gÛüQš&[óè/BX­·k™-‹­±îA”eï]ù›×I ¥’Î̯"¨,êÓ V ÔÝRIw˜!9|ØéPIõ"I­œEŒû2œ( Oœº|À!ÞÙ oj�¬åIršvûê5È~š™á—åÀ …ýÃ(.ñzŸj4à=@æk"EìûRÓ­¸”èûhדú¯ó‡®îï*´¹¼fIªœÒ¶}ïÐb{JjlRŠQiêšpõHÒ3²µIex#H­²zòèο¯ŒÆYu9C¹ËµtcJÏ1è­[G´÷Þ(£¯gø#<yx>q¦�¦É)´ö[¯C?Ö¼«•Írø#²Tcßš•ûÀ§7ÊW–žP3€>Û©¦­òù¸ СGñ¥Wo‹q£!EŽ^¬"nâ!7ÑU ƒv¾¸²Frè½·hÈz…÷¥»JÃíÛ…é±L"ñf…¨t­”]¦( â¯OÏëo+kÃéìíëc××x¥Ï˜@X( ò/=826*.Ý}cÐAˆ X9ÕýÔs÷—kSº5--ͼ½z í-i’¸8}8ºíÅq‹ÐbɈ†Ïm+Ï ¤–K=Ù‰õ‹gv•¬LÌañ±úÞŽE#m©'˜k»Gßï[~§á SQzœÕ§5,ŒðÄ,cÝíe)<1 ‰J_o™ÞòÜ$”‘[oH O´`<<ʾ¾v³þûÄ¡Üv�ÍË”0eËŸøæKEèã¢CÕ‹~ÿrÃÃÆ|ÇN÷Öë$g&ª¢¤ó¥Ãï ›qà(„~,~lGBn±½xZ i-4'ë¬oÃ1îîÛ^f-£% Š¹÷°éªÖ‡ÉɊ馗§ñÚÐĹâÅf:<t)Ò�토<b™RÉœ(.tBÆâ@½—!žRÚ¾›µ'•ûàû´?CíäQ¯!òÛ©±(½£¸°Áõ_´}ò*ghLŒ:M˜ØèÂŃõS²ã=Çظ*|qS†*¢ñ´ÕBŒ{ TƒâicSrm-çÔ¯àŠe¶È¥ôÄ¡ƒ·µ"ÃS=wÓ*µdJñj’Ñ•;Ø‚ÇÑ!Ís­,üÑ9eá»>ŠV™²y.èž«ËæÀåÔ…I¼b?£»ªéì™Ò¶õŸÃbMòX¥];ëŸî”=Iá䌌ô„–gXÝz¸‚Ä×a¼Ý˜rs”£‚ï7”l|‡Ý‡ž:Þ<¸ ÐwO¡Ž½ÊÇÁ«Â¹"~(Ä ÂÂQd•OÁ²EB í²ïÎNHL(òøžZk!Ôg?š©µ ã*ƒ¾xìÝ©G¦_vôŠle•^Ââ’ÍN;z³¾˜aÂÜš‘š týÒ±²ÙÒ]>ŒûÅ÷¥”äàûö"TáBVÆŽ8Q¹2*f]ã>ˆr§ÚuJ4eÑ?]¼„áÔ ×fT»üÆ®}Þ—MV4P(î)º„íä&97g«üئ†ó./‡ ú«+¤ÈcW‰õï~¢`píšíNL©$ bZ×ÓmY~'†gjˆ’yþ] §¥wDH÷pö@„?¥8Vñ%22=À;gíbI,<nè­ÊÃOhç{Á¦\ïXÚýs„Ÿv,“ÅÌ è=$^ù z]Áf™¦ XA¶ ʺ1Í@¤Ì7z<ð+15î8¶ÒX³¿ó®n;Ø•¡O|aØ8H†½mñG<óm/×Íþæa<˜VF…kì„Œ²ç)íT˜ÄÌÏL$Êœg;+­Ú"ৠI);lÞ#â¹û÷*¼œ°ÿE°õ ²ÖèõüWœèÆ™ÃÐýé© û²ÆX<þA¬šK¬§“fÂ<ûîÕj¿YرrÞl}}Qî Ë”ÒÍñš£/›ëDkÈ-¤#-žÎöã#ÿ L¹âEeQ‰ÃíþKcŸÈNF™XB#€¾N­ZÿÝŸÚº‡Z ÛV˜/–­[~ýÓãZ'Î3O9ƒÙ•Æg•·BîMy÷'DàøuUÍ" ½¹,­¯Ó˜$A¼ÿòî´1íÚ®ôŒùŸçärÌÍô—†­yß Ð¿z±ñœ¾�;¼¹×¯rn6±¹'nŸÍ½ÒÄi2²Ì+¢§“í€Æ¾•I“è þZ=R2•qý¡Ì~—{§SĘ•3ßUuâù›Çé Q”`@yPN]\AÝèàQÓ2‘¿6C…§§nðd»C¼b¹9J“açHtËQÉñ£øÀtœV-Š~ê8ç!ÔÐ6@·~Vûá†Õ¡Ì^Ñ6�x—™±‰zµ'ø®\e^ŸVꑶFØÙ6L®“\]¼Ýf¼ò«¦i^e£Y¹Š'­Ù°7*`’4@‰k¾"CûAdÇב`vy äX²ýôv»5  r/`,1 nõ×nó¹šJÄ¡éFvÕ)³M$(c£ä‚Mw“>˜çbÚ–Ø YÖŽ¦üu»xjÝ´' Öí6Å_zǹ#¾~´Ý‡,(û­Ü §‡Gîon©FÙ ñ1IÏÁ¹ŸA;z>¦AjÞ¯1 ¯³MãÈÀ&}y þEž©"_,Ð| ¹ŸŒÿ·éÏ]Ó°£ŒP¸ñu­™…äÒÒâé=!¥o’JN,7­á}MYçüåIäÐò0txy'vƒÔ—GØV™(5j/›?U0䡽CéÓdå)�u§+m ÝP\9K8zqj嫇럴â«Nø¸Â'‚“°Œ §[°)é&JÉkÆú/X®WλJºs–A9¨ ñ 3hÊOX„jwm€ñ �qÁ®ÃŽ•eÝ¥×Ê*«škkrðÙfôI]ð[5Óüûòº�HQ+Å š¯h¢x;½{|wNT;îYu׉a—Í*�P„AÙÚíŧé »ŒËrÃo{4GÔ{"ÞÌ”b°›K>L&÷Çð¹a”¯?òÈÉ%’zÎç•LÍΔ×}Cß×a~e0‘­\»¡ÉŒÂkÑ jÃíöÅ›y–j^è2Ðâ6Y/·+«µ-J¢eúFcpeTë„VíIþ¦—•nOŽìÛ$H¿ìм*ehÎU•^ø§—é*!—¦He’öîŒádmcÁ‰ƒ×ÑËéAý¤ %újñ†9èíxmÛFLL™�|B³°ÿ¢e˜ÿ&ñò¢Zç9º•ïœc™®˜‚ÑÆ?ôÛëpm[Hf/×=Z¦{Š -×b:ˆïý `þØþ f]–E5@Û¥ÜPä¿o´r$M ÅÆŠ[ê’žýT»ÆvÄÃÝP%ô&²ÆBm#öÊ«9±ž <.Kòp•ÅÐúzHK‡p&¥þ{azy.šúû=ÿ®õ’—ÝT3ÈÊAîl>³ÚŒb•¾ íŠÇËyÓy †d^F üŸéµùrf¥L‘Ô—TnSÙhüë¯Gc¹HÇZŠ”‚›Àû}à•ÚÃxk6WsGÿI<[Jy øJ*OI@UÌ7— Úœ¬×"Ù£ADCÈ»|qêQ­llî‹ yWNʾíüÑ{ƒ_b¨>¾Æ~ér«¼K_ý/Qôç1 ²«ÚÀ¢ Žº@š\”eÑ/‚NhºI?’¼ÞQ0;—šn]¯~Ý&E§æ<ìjððƒVm§ƒè*ÔªyúàÒ£…•Qü�E(뮦鞅ìZ±9˜Ó¯/½F ª ØÀÚ s Zi/Ø~Ô߉nüW-qOÛÏF ™& ÎèÂþ}Z’”+ŸØ<8ì(iAeä¡ž»Æ°ÖŒ¹Í 7±BsTZ}©)gÛÅME/{™ø‘zå|¹«'NuY¶ –ÄÊ­ßøwð½5Þ6ÝNËÿ Že±þ‘Ñ<k†Þ°_†¯‘Íû‚˜È jôæÒ s ;Æžòà~g ¤ÍÚñçeTÅ׫9ì@_@ñwoÒ#™ÛìSÌ4[¿>Oÿz¯¶ý£Ø÷‚§3}wNBÊÛ•á²a8ŠlåŒP{Ú£vï'ûügQ%¦šÀЂGQÌz ¢k.à £oÏŽý…Õzûºf‘Xoí,¸P-×ΞæÐ|¹Tç4Ý­7}‡aîïr±Žû¢Ôœ>ó)çÍl'*3™W`ûÔø\̦z„Ž¶0DÆ` [5ÑyõV’gIÅ ³Š­œ}½nöR”}ƒ×ÄE奔 k>ÐIùµÕ\,Ç»nö3­H¤É lã¸ÒW~pßØÂwèÃÖ”þSæ4 ²³â=�õc¿ã_ε6|¼¨M™¥N{—…æ% ªaï¥.MׯdT¬&ƽ«˜üòò‚o=·x˜èJw^|¶;mVqÐ÷WNš¹Ž–Ôâe£mÊ_ÜÓN™:D0¶ÿôÒH•þý§GZäpT%¬Ð?À4XžiœGÆEÙ€¶Gd/^j!Y„fb$áömdŸš¬fIâ"L"LùÈþR=¾XÅkGµ ˆ-¨ ^ÕBrPñ@Îî^ÀiU]Ž?þŠaË`ŒýЊ܎_@”˜7õ-žÌ×ã4 =Ö˜+€$ïªP ·¶Ãû²XEǼ—Í81{mRå×ÁTËB×æ7A^ÿë&‰G:ךa#emrC3ŽÛüa<ø»R˜jŽÍäHîçÔ$øßÛ>P˜dž ÅÝ¡£ýN­§ÁCE©Ñ]0Op2ž3Ý׶y®å—úù3E?™:lã žþ`>蟥bÇF25HißæAÜ*e‡—v÷¯²ó§“2ÿ fÍW²1†¹ôÖÑçÉAnŠ†…Z ªôôú« 8 Ó7HS–øŽ€°|ìrZ}íàX0ÿvÜøQ¿‘±îç]ÉÍæÏrÓWüÖfÌs ÀÂåÓ•ŽÍE0£Óq%Öæu¿"›À”†-5÷%"ƒ'¿Æp,ƒa胻¤£Gú=òrîwº ï¿MÊ ž'“tcí»±›aæÀ¡±­Ï~;§Ä?]§Év%Œ§k³Ü*è=‡«ã)˜áû±i™­ºÌÈ-ÿ•ºu¤¾·B‚æ2˜6ëò© «I Ýoœêˆ±€Ÿ?-|!øU®´$`(Geâ¤ØeHúykÆžèM¸ÿ“¡Qœy`­’E®/iP´ãJI›oúú„Øv²éà$ºa÷—Eî‹p$ŒêDdkÁH ó˜õ›·N Ï‹2û°ŠŠºÞ+Ýßþº @¿=L‚ÃТ=)ÐZ´6cOú.ÞÏý #œ €\eS —c…h$ xéjCù'¨\l%Æ3.‰ÊàÜ S´E)|ÕhAþÑSàü¥Âzñ,þEbWªúâ'QÒ16ØÚ$—hØÂÏDû( Ì Ûd íÖ2õªÊî"gµª#çËþ ø¼ð £½Ûº *÷ÙÃè›0ºùs˾ó/ÛÚ˜á*-×"¯+CðX&:.Ó¶ótHàf×M›CÝ[ËÕ+Çìï«$*“ÐFCo¤•Rbb±A R¦î`=aý¹Ã+מ&°è/\þ$´/^žƒYœuù`o‘ù_úÜïgO‘&«Ð¡Üž™€w_¯ä" •ÕÑ[ä“ÅíÚa 8_è1­(øÏ È*gõ™³KiqÕˆÙ0u¾åßâ(yû‡þ5®ç‰Ö &êÜ,Y‡™¦iê;0»$ ’Z!;âoºÜäœq<+u0ú¥úm”¬,¼C)VBë¨GkŠõ‚ ÒàÇ2¥Ê| Á,8Mô€?µK‘±³¼˜Ìj¥k²úºBÊfåJ·Š«„ ±dÿ„ååÁý3úmŒ[à@ðŠ_©ç‡±ßáå–èÝÊ6±áá¿]¯õ“ §ïýiXɬ‚‘Þ2|w>œ¨d½í&õ¬†w¹*&­WOlNµÓHK£ìµ›ÅNLƒ:ÚÝqVìëÁ¾õê I$y» ñœÀDÁÊìlsêßN ,:'Rþf¤}Y½«¤¾µeÿHν;a¾Ó–2¥g ‘"w´´±­é{´ŽŒa2U§³GL³Áú6jûÝô›žÅÓE»K1—¿»a„W¨, t}¨\™Q+}/]¿ŸŽ6ýÿQm§sYÂß°Öük…È(]iÑÐ]æŒqð^¿³ƒŽ÷æÃUI”ôÒB[‰§?í3–!µD€+~ˆé>õźQ\œyeØ‹µ ‚+Jc3èä-Þî­$ƒi‡ZŠ‘n¹’ $EˈѴ¦ÌM³½±h7·Àƒ^x—¦Dò ß›*8÷&˜ü´ÙÆ E¾;Lj_™m¹Úî: OdÃ-×Т'•ÅAÉ"ŸÆKìýÜð¶‡Mþ¿xkâH© Š�<}ÎãGJ«bz÷$óÖHšÞMÒMúWmê( øt,ø_ú³Ù¢ê2huÒAv<·µñS©õžIæ)2 ÈŽ`‰ª_¤„€Ïa6'!Fü¢’xsòÖÓÐ-O …"5 ¿€3›¾lb’"V¡ÇVݘtXÕô˜mõ†â÷›µ¤SÃáò‡ö'åÝÖcA6c¿ùP7@#ïf+ÒF E#•¤Jïqï—>m"7F›) ÒF±°íùtª•4^èúmf÷à6ó Y¸£²\J*,&›®/ûz.­Š»•^°ÃŒb§¯À*É‘ ¶ê£ÈkbŽ‹^œ;.¦«•¤uÀ¦öªH¯ÊýÏÛqN²2pÃ¥¦¯”Y“å(™(©cP†uÆ/V&]Ò[Á£Xj‘íñf`©E²]tœ àõ¢¶{)Úo¬+mãôïàÖ‘:T³ñ‹þNúµum"¡W){C9ëö_Ñë5lUi¬^8ÅlZ¿g¯É…N¸”í_p0­:Éb^oZCùj÷!Çé"Ï1΋tçݼÂ=ý½‹Pæ˜ÆÞ”nUÔÚô­@£ð2VeµÈBv7dˆ‡}«ªÊö€tCTíìQÔ({à3Rü• ewïê›DC”Rõc h Ã2ʶ£ùbvž'=?kUršFÊ\§QJ«ý MŸ±ïLG‘1z÷¥-é›#⠾ƹ…ülb‘â¢&3¯md'K6­XáæCôµKÒy5zwÝ–âÔS ö4õP §ÔTpFçÖ¼É@ÓÐM¹a仺½÷Iäʆ˜­^û”e¬ÝPS4 vãÙÎwN½éGØEùð~Ó1RNø1ª~rÍ×TA¼¡\Àör>/÷·¶ ž˜¹á´£…X~YŽÐ̧$ÃD§©ã´žèÛwÍ©íÄ_Ç›ýF™ç!Á•$agÓÅ̲ïs$î¦È£|Á¦L2Ê1Á¯˜¥Ä¬ÛÊP/ËU­^w¢Hb¿§Ô¢¡.[O£g¾P¶íÉ„Òºÿ#rèuÒ§zï'$«žßeh°Ï%je4tcg|nëÃtEg}3šëÅ=þ›â^Ϊ2€�n±ÏUéãƒ@b‚øIÕp£’Ýä‡Û‡·ÛW·ú³ÁÍöœbÎli‚°¯@|µz€í/‰“iìcØ”:Œk¸"š<Ó-yeÕÜ €CP`¡¯¾ó$FYù“%è$ÝÞNcËM"{ñGpÉWªãx*§ ÇÓ¡(ŲF'Û<CÄGMÐÖ[«ü“1¼õ ¶™)¥NßUk4Wfv5–":SæŽÊ?ó™‚þ?ÇÚ:¡>‘F€-ƒeÎS n»,Bws õs2ís`7>=c°š®§?dU†¾ /<ñFðWƒ>gZ¾Cª9r¹Í!ì¯~fÔEšj‹D8g—šŠÀå_OÁ`^PØy~„À¯t½éÓ›«õûÆ+•s`ŠRh°nuŠšÉÍæi˜,™éLwáúª0_è¬ ЄËx$°ÃÉ c#¯æ,íEïŽ2wÁ8ÙE˜ŒZ…H¨fâýÌ­¾++!ò¿éÙf®'ç8ë¢\¶T9NxÖ€pÙ;Þž§ú_{÷ù«Ê£näøì”y†A~z÷´]Œ '`n“ÍûI§År¥F#bSSí¾{wmÏ3(sÂ2·‰³wqFFSû-£ÌhZm¶)ÕìçÞçv°²…ÿ„°¸@“îE tbUûT¼ÝÓím,Ú'cÊ+§ÎJ¯á"ãj%˜Ì1ãâZ6æÞ$^¶W ÐÞÖÛ~ļ¢×ë]:ÕÏbeÀÎÃÇ”òËDˆYŸ‡rôaøÙzœ]§+ßk`E» ‚(:–3¼ŠÑÔʽßNk><TalîuaŒÜzÀ*ö\˜{ÈBÔeMªûçÆú̘ՉðÆF7 ýì]ù‹¨©Nüè!P½Ë]Ç ›»XÔ8O3 ;Cs¢¨²³¶†l½£{€%᪹†$ñ=é6w©ç«¦và2ô8%>•ÑÆö¢S¨¿i2ƒº‚&†§ñÏaÀ5Ce™/cwéC£Ú}Qþ]´ Òª<™Û1üúKQªÜX 9U’K=ãboèadAZ[,3ƒ&ŽîŠ?»û,î^º’Íñ4d »¯éqÔWŸé‹¤‘Õ¢q(ÖNÏá'©‹â‰Û$A²W*Ò±ùÜv*øÖÖÛ¯ÊKƒi[,`:ööô·ØqåÊO¸2éw Š ÛíÁÉÿuû–g,Å7œ ¼ÓS±@Oî0ojÓvÆR6]ÜÇú~•—!°¥Æi¤YŽG‰ÖùÃÌIuçpÇü?8…kª&¶7@ŸÅAü9x²éB¬—„6g™ùûþçZ3à k÷© òÍ‹Ñ\ÄV£çˆ· ;}­*Z¦Nžy1M’U«µJa.¤Áú}UŽ8VáãÞšádÏ(!œ½ù–%…åu¦ËÙ@Àé˜Ãüf™„¾§-åj}êÍîæ#å“ý•>%«@]æ®ÿ°ìÊf.Wó/ÀnÞÛ°êéÐåAf+ ¡9-×3ý[7GM«h†æ“F"õÞ‚ôË$s¼ûóF;»þ{íª8ôŽæB,èv¥‹f/y†ÞÛP{FJK•8÷ŠCž-g÷çY!1Zzÿ ×œi?P.ô/Š¹ûrXaè‡Ñç~]Ö«¸QnhÖÃG7y’s¯b{*'¸ÏÍÇ&ÍìêLkˆåÄœ¯Þ?÷50|+Xž#ž š •byœ}øZ{&.(²»·m 8ÆŠüó¯zjY•f@$Ç<;£ØæH5jÅyy¿à-u ·¿7å¶á†%‚PüOš žÏ Úëha[åÙ'ˆÒÊ ñ¬Àô¬¬Ä =Ùá0�J%øÉÚ ×;ˆaHI·Jï)R8– ­ìXîʦ­¹g9ɤ•eH Ì¨j´(¨DÄþ›fe^Û¯-cl†Ã‰ôÍD+ŠrÇ·aÕý™>sr>{r~'ö n�CTË(h'ƒÿÕ# W¬Á„2Õ˜…¯ÌãÄ~Åß°™ÛS5p_<åŨb‚é2/f_<Ü1kê4/çöJ‡íñ­‹²NîGG"üÌÙ.—ánRTOþ¾¸ù„#ø núÚôôå1y©4…NÌU‚ÓDeÿUÁs…‘æ^A¤§ˆ¬À³ïî+¡(óÞ{vèŠRs¤¡z‚ÑñÉbx×é«5=ˆJdár¥ì¯.Ý@#w”×½Üãñ«ã ø½ti‘æ.ÓÝ)Yg+\[Œ_idŸ¾d Eôwn;Ô‹mLóöçK·óÒ•‰2$ö”äjmd»sœàSRæñ"’{v’e_õ£‘¼ÁN[bºMµçÚˆF¶U•øÞ7m¼" =1"&z.dtËè1Qvï ^šWÓT÷Vbœ—î°ÎYhrHéçiöš—€GÓs3ĦûB|WüÌÝh´š‰±n4íŸ ùtH+ºÙ×aÙjkí jÉÿbSíùfU|>‹ ®Õ7€w¸�/9{u€Ï$ nþ«1TV– /»AS\cX¤gAØv:ÀévT{y5žÄZ[¯~zî˜å‰/³”C}Öf8‡lùßn@•¤Qÿ}£§éÙH8ÿ§òöc¼£òFym:ÒzÛ)ªfAN¿R‰§øqh*ÏŽ¶”è°Ñ×;Ê X½û:ãÑj“RÌùXŠ ì.×qƒÅrå„ýÖx.ÕõêNç „ž ;ø÷P[ªuÞ˜›:ó_´;Š“ØïRÍÊ¢éuòt@šÈw“ŠQ@ÜïãÝŽÔM‹„ä¸Ùæ°¥l<µüͺ5o›ºFîÿ/TXÓšy§Û7%QJ³KG2–/¥k!ÉìŒ8ˆt;±õS’ÈK­Ò¸ô]ß!´ÚÓŸh·–5N¬®‹m2¬U>ž‰}$axÓÞÝO%E4Uiá¶:8HKE›Å’DTK߉pûsåÉXùÍâp‰‚n!£“éŸ"Õzà9#¿5ÖžôÚÁYWÁ|-ƒÈÎT+NÛ¡³âÝç�—G¾ä®"º¤{4F–ë ±£Uú/Æ”ªÌ5K¤—“™e@`²¾\u$û3L J=?16&z£e6‡ã>Œeqˆ\„ç­’ŒÛƒx¯Æ[Í­ Ö™@Gº¡“ìÕ€¡4 ËÓv%¾>;}Õ'Ñ0„‹DYL£ ¸®˜¾PE‘yâªÐÀÔZ¼1þ¨ô$$TðVÙ×m{ãÂû,ƒZ!ËYjs,‚Äæ!DÞôõ•¾Ýz_}À¤ »{劕<c«P Ö)Ußé¬^e0ÖB¿¢‡Š3¿Ö¦É½íÏ0øe¦™Xõ'`q¸8îpˆ}Çã¹/½i{iÎff||jq?]•˜ôß·\QïôfH|ý­õožrÏ´YrßN¬VŠ1½-@ÃÊc´Ç­ mھϒ ·^ËØ´ÓØÍ"“Cééåлàté{ªÁîaóÖ¾úÚ.…u SNG»EuÞXÓŒ ¾í¬›&¶ZÚö€Æ€ Ç©õ&‚§ép¹[»MwfO§ŽN-&7Ú=k‚¨?›Þ j2Q4z5ÔÄáÊÝ„ò* Ù{ã3ÅaâdÃ~¡ÇšÄqæÕ´…ê> ÊwísÆÙ kÙ Ì:¾‚*½ñ}Øœ®Ø×TÛŽ ­ëôÏVtqùœvÈp§AvR|…·=´H,bý¥&å+Ë( “$6àÐøqÑfúLäæ°¾Rî©ÂzûŽ>Š‘™HëIý|ËÙ”ù¤ÈIV:(ƒd_{òú|ÆLCM·ÉÕœ·±5g—2äþèáíÎòÍKo¾(º—8ȦÙdñ‡?´ ¬5³ÆKÜž•æÒO­G‹75s×"8~�ÆZ{^HüêÓ‰Ömßå2Bý„~3ï%ôïx+“£RåÛjy‡ã´ ¤­´Ëù÷^â•7/àÞç0Å@+Š, ŽŸžþïY_Ã=“ož«U¤M%1DÇYö . 3׬ÿ˜ÎÃÆ<¶!ÀéÍO‘órÏL"×}Ñ›{ÏäèÂB|B­mº/V;\¿Øéb楸)�ƒÍž>i±×ª= ×–Ÿ Ÿ;ldžánÈé<5mw‚ÅÙ(7¹£ü¨UrZšrd.ã†õöƒyv)¬“8™`!eÆÅ»ÎÃ\x8 ž¤3ŠõG ÐÊÍ,æÜçOd{k3ÃL“'µµî®}7cPÀø–Ó*{ñmª:Ûü”2qŠGèèËÝÖö¶6x¯6õµm}(M3÷Afž®*Uˆ­Mtß÷Záb€Ña‚aÃÑ«ù…ÓP à†Šù¬iU2•y4‹m ÀW[2/äsMÃØõï*äÖížÎâÙ×ÔqDê§/ÑJ­`MgñXâ¼LU0“•+wàALß¿ïÕã]úÛFøG}`ë`%8Ù,èg*-å›bœ|}ž¼òé#ÛÜw |àXä‘ugXF,ýÜ:§j&)Ñ"ÝÛÞ*«üüôʵßÁõw¸,JöeªÒeš ¦à ˜´v<2µC;¾©-ÀúàŒ½ë‰ ‰F¡=CÆxoyðC2‡Nf;¯é[×'Uÿ�Qábße6ƒ?‚>Ô"¡‹Ž2@]¢®Â®¾ê‹ÇÉÊEõË ñÅSï5” ë ˜ñ}fÑ…ø ܘ.é— ¶äTÇh¡±§ÿËfêÚ«žéEhu#mºñ´Äå_ÈDdG(@K¶ãú ¶ïÏ7_¤šà „/ÿÃ0U¬†fη_àÉz&‰ð;@!©í‚áQÄâKýí¡…:ïO]÷ÜSŸ­8lÖôΓŇ�òÑ—ÔîèbüfY9‚Ý,n^=±Pµ@Y äì„«`ªÜ0XAÍVúÞ &ç%^âÄT–…)ß•Ý4±è§<ÆH•% UÍŒžïéÄ|SŒñ“V¸¥Ãªàgi-Qxð'V…y«§Œ¤Y•Ÿÿî‘îräõ”*Ö›£S¦pVŽl9t áQ¹º÷\Q_k–±¯ëEÁ ¾Lg]LyÊÎ:œ–_(Ê0èÔ2ì…¦:I¾æƒÑ6«~Kÿc ™nU©é?±¶íÆŸî DKåKè·W:HêÖ³8÷ˆŽ¹|ldBpÏH‰ÿ黶׾…°Úmª²YÜÅ=ÐeïÚé@yy¬¿\›3@©r5|'þK÷ îï&݇WÿoÖDĈÌÓH¡°zw`Ò-ZkŽó“yoQ®{YÕ1²Aa%Dì.ÈÒmGºi:P¹ùTÚQÏ`ß´Ë@«ôýä>ñ|š``úÌ¡.#+c¿I]»Ø*ßw½Ÿ-ŸJ¼Ÿé¼Ä*ÛÚ×èÃ(–…qP'C8H­|_Xq\ùôo2ìÕüëÉ©ü§¶\û®æ´N>ùG'¬­[Þ„‘YÔsbɾ¥”ºþôÔ² 9E{Ntò³„»»zÆZID”à †)BÕõî‰kìë Ÿúæl¸°¥'‰öJžô÷Ò«ô(IS’JŠàÓÞ1 ¨OŸ^íñÙÆ“}}ÖÀ°Ž€2Á¦çBõÙyª¦³�CGðÂPL%_+å®ÿÉxây-ñè0ø’ +›ÜÿH+$.^JMŽÌh;ëzs“0$m÷g"ÀK›¬0e{¸-;Û5ÊeGèv˜ò®mê…Eñäå‰è^Ý9žFn_ÕW}¢¯“Øð Ùšúóöu5�Kü à¯@®-³×6¯gz×7a6^ÊÛ´¿Á8ã'ºÍöbUh9‹ªÈ0³;HtXûÒ*纊¯`˜Ö ¯gr·¬mJ8Þ.›‘*ÞNÕŒ¯÷tJhoJ£ïNï=òhöÒcŠŽïÕy²!áû<×í ã–R¿~fsŒW—DUÞ’ ãïø‘bdñâUàü2Ì££ã–%)”ÇÈ䊮ÃÝÏT‹Y‡ÓÏÃàEžK«Íñ;N 9†* By½sgµy«<o-Ne>p¤0’�7?]­ØRšù»’2µc”_;ç#Ý2ù_]PèóÔÞ¼9ùÅ>Rë]œT5¥Ã´¨;Ñ` GùÔÛuzce9… ÁÿòÔám©ûf\îüÆs”*M>ìà¦}òÐùïçÞ"ßœ„ 9lìTÈjö™ëîDÖ*ó¥XâD:ù "ž¬HhP@8嵿jÿÙy{lÎèË�W—~% ²YCJÇibÇíŸT8ÓÊ!ACΈ)I­æÁoÎzV÷4“üîË Ü%ýqÑŸ¹ã’XýèÒØfÌ3Ú/ßá½j49k§QÔñ×}þò|mjY�(½+ö…b%Uµç¾~³ˆù¿o©™~‰=Õƒ‡ý 0'+Ë)Z€‰\× ÞuÍQ„IâüE­~ïuø¬dNìfgÙ \M€¢­ M(Y|†t°µx­±¤g_ùÙªÃ{­T8Âhwò~ŒÛ—±,7¨úGÆ…Iê³,ÑÞ¨+† IÀ 1–h½ƒ´üÈŒ•g^Ó ™i7¼×VŽ¿ºªðz /Ó9‡7æ&Fp×…mL׺œ"%LÊôc××^<‚þŠ©Ò瘠Œ­÷xf+6n´KÌ¢p‰A3Ÿ'àðËLçýý¯¹Zt>õ÷&U⎶J’8~jRRðž^¬.¿pD`î†Ö¨§tõPôŠî™Å-Cùu—Ñço îfäù˜ÊÂ#œ7ˆ Õ”óÌ©ë¡îU’8Gdù1çÈåòé•'¼Ÿ@'/¼•Ì‘_H“KjsCe.Xa,QðµÕà€`ˆÈeüJë)Mc ÐÒí&hX5O&x³”V·s6‡¬[O‚¡VÞP@©]ËëòJãwTšÍÿ¼±2;,IéU3¶W“=!Ÿ—:ÿqœ9rX\þÐ'®-Ñ=dªæê惿P.4ÆVÇ ÇÄß½Ñmí)¸7Ý ¢LöÂLROãnt–9Ïu–ÁvtÚX»x6&ÛìÇQç`Š½ãòϘçÜ3hŠÃáKDå¾õ°i@´ÈÄÊ6õ÷çV §YP|x«¤, ýJùBÒð‰þ“ú0@&µ5Sd»Ö•…´±ðÀ¬_ðæC,™½«i<ö÷zÎIæhËRè’2(z=ïK` o1œ6 œ V›ŠaØË']0[°³'T­'úK±5jfK£nÚñWp(Ö>tõC3ÑwRg=³R5sT#°§e¼‹·X1‘)µôúYÆÀÎxŽÎâÑü“ÓÇ<¨Î†îÚ*.ãÌ÷¯¯‚Mc4ñL U=®šé$œøv°Î7á&ðz¿�kG¨¤™3OijüàwýK·Ùx%tKªK$õÞ–©—8:FšÇÈì×ê6Ý‚Æ¿ÿÇ÷Fó¹à9BM´S9†$ªj]ÛÛÕMŠ`ò¯üþ ™Y6R̶%qP¼ï­N‡Er›w}(›vWAÍÍâ"£¸ÏÝøääû„!)Cy§wêYÞ×DáÜ®@Õ«sŽ¸4Rû&—DÒØ¿.‘²ZàÌ^njzÓF½QcKÍ#°ýxê<ÒÄÿP7fܶ?³\|2èø¢âïg$ÄÊêÅ¿¦åš»¦«Mç!„W¶Â¡å¦¬…0ðˆr-«Mxûêì@³ÐgˆXµ+g·u§U„vü•+9VØv6sI–Qá) €Ž¢Fj-ÍÐu¸›xâ"ô͗ІI¶žÑðI‚ÒÞ&Æ‹ÝÒ@GÕ]ß(Í<¨eTÈ—Ø°_Œ•MZàÕÙQŽ|¤(c0JÓYagiwëŸõ"K3ôpZ¬jJÄjtoGkz‹6wÛÿ?k_²Ü¸’l¹F}…v½©Û†yX8H H`RLëÿÿŽöãà$J·Ìž%!ÝW DxøpîúåC^z# æÛq¬©µáýs\3œ9îªÁ³Pý§È†´Qpž*öhvØŽý¥v"tvüt(™öõêÙ¥ñâVû)áEáIzY])«Pý¯H6Ú¦ Ù(˜/pÄǵÔP`Äh¬ÏvÒ £W™]ÝÑ(’xáêš‹5mù9Z Ò8î:6Pãã¤e“Uî@)(Í^¸|ʬ¶þÒ™á&4RÖÁc<P u¦dÚù ²¬öÖXŸ^ÿâ–×?,%k@ÿm;z¬7ÏWˆ¡Ç~qUúèÔXæêù»n0–Ö8Ò¢Nk;àþžÒßÓ0b×°‰6WÆ£ôHek £A†žË^üa¤<–öÎu={ÿ·¾>‘µ€èu[þ‡‰·½Tú1ZÕG'LË;ÑÛõŽ\Y‰¡™¦%4œ¸0¿ùì5ÔÆ‘>óPÑ ¹6:† E�¥$ä¾ÈïWà éÝÀò§¦ ª­Ðùá°7&ü�svÝä?#ÂúãC—äØZ<1”ÊÈÃôÎfm·oõ‡×B0P ÆÙRA)ù‰BH嬸Bž>hß6½D÷ÁßN?·ÚÌ<cú=t<,ŽDk*Pbƒ›Ã6®NúzYGÙBD(‚­3zïvE|NÕ³˜~<%Uçiæ‰`¡†‡øöVEñ¡æ±,p5ñÕ· ÞNÎð:¨ŒI ‹®oBK¡ô%óŠRŸ¨7;5êöõ‘>oi'ó¡ÑFº;y3Lƒ6Xš%ó‚nã°û|\YU–{¸ÒÈ“bB 2{x/'Í6Ù‚ãb&öF·ø nÄòWâÐ8 ¯ö˜´5ïž´…™©ÛŽß#&zô­ÏBíB+“6h<ëp#QHrÅàXããåOxeЩ™‚e^|j‘ õ7È 3‹=FžÕt5ïžËé(P €n©Q¹áŽÿp zLÉÇB4]½éàw#ÜŸÚz[mù05‰)ɃÂr!Ðö=ÈŒ æ°¡Å N„Ýû3±šÑ'7(«)‚ž'J&ŠVÏfðwÇKÇËÑ'Ú= µô0˜kËâÌ?nN¼F:—³Ç‘å±ÑÂ&›4ú¬/ ]w’HEÏ‹ #H=Û³hhiÆËðVwTÏ/;ôíeêp»Æí¥Ç »ÑØöz? xyþÙ, 4}D›>zªÜýâ-Ê3k&Ç›»6ÈYüà1·ƒ´; N„#gÓR†õDýRÑ]úv$qìiç—ï­Ç+X±ô¬³õ}ùúm Ê…ùXº?¸½nÙ6)ìô(#aUadƒH•ê‹Ø;ö“q¬»‘úð~æõuLßc­jetGκ @8G]HwΦÄWÔˆb_н½Ý€ébqŸO™jYåîk~ì?àéqôê±Ó€û(ïüÖŠMÿ~BxpÂVAw¦ƒ9;µ*—W2pà ¨½c7|˜ñ“aŸØøì“Qnì$mŸK¬›¢`>WA¼}÷ a·ô­”ÌíÅsïè"µ®†˜I¢Ù‡Dx¶U1ÄvÃçÞŽ±Bü£¢Ÿ¤K¨)W=W?úýJÇ]Gy˜!é.‚´73�î§ÑêÄ2Gâ¸ÿ_%ÜË&aÄ=/ ÙuIšhíá<ü÷-/,¹c‡N½Ëá~Ú ‹³léó.ßw§(ßR¦ü°å›d ,mœ %†ÛV¡Æ€:žÆ7¦a˜oU3…4Áþl“ä æuá(ë‰+ç‚1XzÚ8µ“Îø!³ð³-.ªç3´Þ­.WÎMý¡¦ï¯Læ¹cí/V }iE'™Cf‰éëjm¬]hû¡ûc't¢ýÀT$)]ï¡Dl{ TEӸόYöʹx5»i{8¾Õ'óü®f>¥°XFƒ&9‘)-@­zkUiŽ¡öbÅã~‘عa:ÈÏ2ÊôH- £ÎsPf?KZvó¯ï¢)°›Ãù4ˆNŠÐÊr367u#må³™ËK Pðþ þšˆy<$”Ï^ÍøÑ_l™‘–Ú­5Jz†ÚC`2ÿ>—ÖË*Ÿ¯*¢å´\NŸìîO=@#ÎѲ “^@*¥(X­™ $ï†$ˆŸæD•a_=جsÝâ®\ýÑ9.M•‹k+Ù‚LûôeǾãÔkRQŽ¸‘L³U~iðl¨$`«"OY¤Þljòÿ½ä¢ŒãD!+,ôV;¾th‹ž¯G<¡ÛïL¯}}êïöiS•™°¶—3 Ÿ•‘9”ˆS‰qZ'ÞÃÚlY«*R:Cc‘¸jZh¿lÕ)Ë›þ€£ß,QPŒñNpz/о«Egî7[DZkŠÈt»Ï¸C5gÙôÝ×£è<w‡¤1ójS�$è‹Z! ³)±Müÿi=åE楋aÉÖ0°k”µò^_¦ƒåܧ©Z`PB(°…Ê~k“æ ƒµ*¸rZñ[', 8³Œš±kØèXk¶í‰’S6Ñr(þ;Ä€2òy€kÕi´Ÿ¾¥ =aΧ78oyü³RV~ùÅ3È^œ£ ÌU[‡Ovydég«1ö„öþDÑ·°Q™ç1Rcõ”•ù¸àîu´IbK¨Ã¤Ö¸U²¸$·Ø¼6^š¼•YaâXJ Ë£z·­œÔ$€G ð1Õ€%õõbx¼(ÂÌ9Ú±È Ul{ñ€Á0¹Q'¥©l½tS=™#•©Ç DC'¡Mßýu³;¿X\×´Ñ¥9à…Õgó÷*ò‘ˆÔdr-éÜ{»Œs–gp_&Xïýó_±…kæ õáß”Aa3¹�¸xÜ*n*K6yõã3`tèÙ–æÀC¬ÖU“ã_ÏÀ�ÊdìwÓÇn7åU^–4ý?Å#én ¯òiÙUÚê¢ö úz{Œ”ŽÁ£¸-Ë̦®HæSëüŒ¡ˆÒùÒ-®¿áèæ ;$L&0H)-™ò·€é8mg¹B]½ê ¨Å¦£”ð\9œy:¬,9~þiåÓ»=Áv¡Ì˜±c?0•Qèû€„È(é8­ö¨-ÂÌZm‘†‰ÏÈCNæå7’©²ã›Õ„†­ƒÅÌŠùaÁVeW<ÂS“³·›’5e«&-'Ó•1W]Ýß•2yz+ —<Ê´g_¬mdì‹jµys*†ûÃy¤ÐDAwØ^ÐÓžPºy Ÿ1ÓÀ¢] ÿ…#RέwYÝ;»ì¨<÷K ºímG'á\û  V³íW²}uDý7JÓs?¯¬`©LãVû<ˆìlo³kˆ Hƒ©= ûÃY_ì6*:•°çšƒ¸«m¡ 2¸çõœ°µîáìÁ†ðÿC'ªç‚å<šþÍý{9x·LG: È×Ö™ì1&¹¿ gØí/mAö3’p·3/‹ª9%Ì-Y6eN¹-÷öΪx:ª±}½±žòqã8žƒÉlü®1é,¶Å€/ÁÙq/ÌÓùLy…¬¢4´sáÿH&õ`,ܳïèñ¦ q¿vcm&X~ñÍp³Ì™ÌŸN£*µ‰¹¸øq×8³@Vdc;>¬µÕK-ã¢Ê|›.Ê3 ônÙ³1K²Q@¥Ã¶þøÑ°+Îòгu›½ Ÿ6æîÈõÐ:”›_ñ_ÞõÝ×V̆óTÏûør˜n|ha¼¢S!ßÀŽ€îû´-Ž<§xÖžØcωžç§u ¡}‘tÛ'þsׯ®UX·W .œiÓd�?åq·¢‡Ìíx[kà:™«¹Kq¯¾Àq]ýd³p¡OŸÓWLÁŠÿò stw¤E<}ž0jÄóüeãy7Žõ•Tæ1™Ejfh ‡“¦A`ãtm7Aû'`™4º'Ç ài­šÚNòºé;Ì�ZýɃtøôì§W”’˜ÚüU~¢ªï„Â8@L ƒlko˜š”ÿu£× UºÚšÈcÇí÷/±q½\4”èPñç»iŽ°zÚá`´õÌY³çÓîrßµxâæ…E&œx °âáèxýçn¨­ z¬¥)å£n/+ø­b»},_äL µÕmL«²WíLzÊ…þ1éç7jÒ±ä—<J2ÊÜ‘Azx¢Åoç(¥»Fëqù°¿#Ý‹\à¨,,¸ ’uïÁVtàÀ½Úˆõuìí ¶"ƒQ€sO¢£öUÄn4ÉÀ±‘õ[,Ë€RÕ4ºÃLX³W·c×<_@¾Ã ½P–Ú©l~é ‹Ù`FwŒ?ÅÍô°’ÏÇ7Eî¦7œÒLhc–õEgÖ¡ñd‘¬ØöOøJ­jY›Œ»ãu±c’ˆ×ª/<„<Û˜tTAeƒ756S¸IZòýÕL#¯Üà‡Ô†©¤”»”'æ[Ø Øú<qgˆ£"%hÍÈ;±IÕk¿"%Å ú|š~j{.æâüBÙ7Í¡ýc7ó8²š2~7Èó0tû[8 Ÿ2 áØr^)–—Nþ9½4§åc|ˆÌ=У6ÿvÇ#tÍÍ×ÔÕÚ[V†À×l1ây·å”ˆgÌ ¡ˆe[¾ð,"rq@Eþ³mÝà±ó–˜ ÔO,Ó¢Ì;Ålrhu.{�ÕëÜÛ›Ïv©gǦÖ`5€þÝCÊQ‚B7`o¦‘/ñ›bÏ X†Ó‘J Ûš“ ¤ºÌ^äÉ3³Ùô4š;òñßVO[ïç]Ïø3w^ª¦¿"¢ž”¡oI‹¢Ÿè;VžOFJ181|9dvƒTk;ìúé*>j6;¶@hÆÛM ãÏAÇÛ:ݶŠ¬ÜÆæ‰Ñ³7öÑ'Éš ›íÅ Þ�ã·›<er€h}ËCÌÑÛþJUÃJ_ȬŽ¦(ƒxÛ˜‰rÉïªNv´¨¹2×{éÊ©< 7’¸Æº‡aæ)0CsÌ‚rk‘Àqˆóˆéƒ¸I“ã/&‚Üȵ³ß åÍÕ—›1ZŸ¶»š§Ÿ¦ Ûîf:tvª¿–Î,#7hÝÎfJÀþz÷üÆYS ­\y’s·?²@ÚáÔÚ©û¿a9ÄvÑr'j ÉØxŸêD˩ηÅoºPh¢Cušò .^€À'áCÜ8fÖ9=ÝÅÁ$¥Ž-GÏ8³(C@™&02.¶wüöÏ[’Ôâã< ZW¿ ÷ùNÑ"à]г>ö>M€N-SŒnwr)~ì Œb¥SÁå8Ï"Rj> 2XpAÂÑiAñÿ# ©$Ï|F*èÿiÂh›ÈÖ T1GK‹ä>îæ\8µîFÆʾÜÒµ¥A¡$£)ã&£¦ŸÀØVƒNö_å§^³U£47Zk¢>)ÂålÓ]ȃ„Ô«üÃV"Š½NPg�Ëq`} ùíõ}ôšœ,ê<¯éæõ* —f€Î7k[cZA[Uz€ç±Cܼx¡÷È£t§Ê6¡L¡(®•štNtš"ŸñSÎG×ó}Í\voOÊ Ú,xq ë�ºÁ!GÊG þÿgzë/Ã`(“bÞwU¸~‘tPÓ £üª×8‰‘Oú|Ù¤ïô}9#–ßw”7:€i`š¿hÃ]]×–qY¾5Xët[œ¹166ëEa3öG`ýxhxB{ùk ÃÜaY¹F»zš<7ØÅÑœÔÔ å�£³%ßà´ôbú÷S( }8B0šxíÉÐmêiu¸8˜âïÈ”YêO?)w¡J"fíÈض,UÇl^Lÿ&Öï GJÛRQ˜B<°»c~ê­MրݞhÕGU8yfK5*÷Ø­~*<ît:ö!�ŽAPFßý§È ±æ>¤! Ê^ `pÃà×}'Ó³‹“Å8—±À†Š›‹+C@…:ã“aUá^ºvfàÖ‰zº$A9nüüŒn?§ "c°¥ð.ÙÔÝKÞ×hÿ Ñ÷¥—Ê(óxѧFUéAWø ³šÇŠføŠ¦b¬s„ˆU¯aüƒº§àȤNõ‰¾ ¾³æ›7ÔÊÁäÆ�xÚ WÐPD˨f}/Kh®ÔÕËín³„˜L}ÌÈiÚ±¢«§²ÒÜn›“É{¹’KâÈé‹ l[„c+½…º¶ÞA„H”W>ºž¶¦‘pðíO¾â´ôaYðÓã^ëQC\‘i]�Àî\÷N(ñ¶ç:m»#=ݬ¬Ó·ô†¥'ÝzíJ0¶:–‘ÑÅ¿îIG¡¶I%K®‚í†É»vò‚kM†Q0ÂÓèx¦Öa•pbQ¡cø«Ga0˜€³Ì>¸R˜¼ŽÇ*<:LÉÅȶ¬£%‰£“ ø™lnÉpâƒ:�†¦íÕ.òå¢(ƒÒ/©{'¹°e{ÀI[0¦èû¶øK“…Õ:ê‘}¤ÑöIª@ÉŸÆåðÃÀBtèAæËB½½ý«Q,66ÝVãè¬lÅÅ#™HŸKÏÚèpJ\cƒ7#2¤^_¾~ÓÅœèYÓ¾³zÎÝ*úÃÊ#2AŽRcAE—©×r (YhFÒç>5I Ú¯ŒA€m·ùcúôÛúB!âûÜ (…°“¡. r+vɪ‹jF'Ÿ˜i'3“Î/#}Ö|•eË~gS'A<ë„L*^îb×�XËÿó7ñ)¦òÏXvÿ«ª6Îò~!…[:Z+NJáI¯2/†Ø²ð-<BnOŠfd…ø>Oóïø!î´ò(¨l69EºΦ×Ä�Qa T¨¨GÈn!cW¤‹O à ݭ»w)i‰¬)ßQîÆ´²ÊAro'Ù_„Wf¾.úèiÇÁ;P­Ñµ»ÕlÝ÷OøeÆ}6ÈMÿ~äÙB[’kç þ´©,´õoíÚíŠMnDv—'iMñîx£èÖ›è|Æ«ÁÎ~xŽ–¬9ŽB‰¢u°£`U‹ ù:y»êQ ¨çè=(:­Dâaì,áñú÷ð¼¶cºŸ„§E‚Q¦T`ÜBËB®D5ª»–“ó¦Qæ@î-ä®rIT™Œ¡Ë“ Z¯2|̲‘,f–˜Óåù‰[wûÌ ª”K=ë#<†Ëtw÷¨¢JÒÐÏé3v_°ßµä/ÄU¹MÐWÌ®eT ÿ+m*ÚÍ ÐÕòá'U•yÚÑh"&Ö(1e Ú ÊÁÉú]L³ií?kŠ‡3¨AñÇIQø–ŠáZ<è×Ñ÷±pücÇ…™OJLŠòŒ²l {ŽcP]Š c ξó…ïŽI €ßišdæ]¢h•eÝ÷AäH×…ñfjú˜•Ãl;€åÍΗéÿÞ|0- C[as¢“¡Új|œw3AÊJ‡#6>Ýïå ÇùðÁÍñ³ùçšZ˜“¸Ù5 mç)“`¦ÅèêË€(iª¥”ª N{JØŽª)ù pG³óöì}»+’…Õ:D}™…³&—1'®Ãnmùyûîp”,¥Rn…\áwZñ¥þ”¤ü†,V`+uÝÿÖ¼Îê“W;f¹M2\É$2UÆñbÚ#ʲô?•~m¿ã½¸öKáEb'÷t&Š¡qóîÃï§ìcKÉ•¥e?¢Uaè Êö/˜v³'^òœ¥ALj€cJ’Ž º-÷´JïXcXÕ ˜ºì˼‘½wñ]Ø¡û,Hú|ê–t8 É5·rÇÝÄY’ö 5ÙÆyÛ­™ä/wÚøÊ€-çÿlwÑ]±ó3 */ Ï¥V(m†Ë[¶ƒçð‹@˜û~óèoÑâ˧Ú+ Vô¿ 猥KÎõð½w\””…mj\h¢òwKkŒÇW£gvVRò'¼0‘õº¢”Ñ°Vof{N6c¿"÷¼ÆõY�³Kô~`MPŸæÿk­Lìé©H ëNÿy7ïö¬z=2Kú!åB\%Çã¦ÅÌ.›ãLoÖP«œ_ Å…N<X$Ô˜½Ô}¼ÔtJˆX@_Ç5¦±?*¿Bé? #1Eßì‰ï¥Õý¿ßÊÉ&à³¹$FÑ™*»‚ywÓÿ&ÉݲÌ|ˆàv4ñàÍpˆ—AùiiL„ç  c”øW´Wr¦úYÑgÞã"¨ÚֿåæLékæ¡ûÉãÏA%jõ`µèÂ<ô-r):·—„Éʪ‰ÓˆaÏF¢´¦v{!u¶nb÷'ä«0 ¢iès÷ªfˆ†5:Ä“zC:!Ôo%Q“8óp†Lô„ãǤ"º¯[uKéGŒ;<§Ž¾9}1¸£”Ò”#7Eἤ)JÙSÛF†½[Íâæݦ?_&>Ÿ÷‡z护é\|9v´,(–ï³üÉ·¾hf‚r™ž½¥á3òæVÃÄë‘εÇù§¾"=žb¿tu†,ÈÎ'oÖ×ÑžôZ¤ç' MIYx‘‡¶j ~øµõÞ5º-YŒé)ˆ?Ó¿bÉæA_¡¥· (F'dÝ1¢]k¼× K£´Œ“ þ9}Ý)¯|·¥](®ÓâF*øìm·§:Œþ5¶¥×?·TÆŽ§ý-ò|ÉÕA÷wO±yÓ郔èžU,ö¹fxZZK©LÁ¡ -§)'Àa£ü;UÄhÛq{MuÊfcà2¹fú ûÿá ×ùRpc‚ªºÝYŠ½÷ôlOÇ#Óãã/Ë`•^’</b´Âä ès*{ZÓ‡"Ùμ¿­ß¿OV¼xÏ(Û&c1å@PÙsj»·(Ëüc=/<Wf½ë³øWé5–T™S¡5ŽœÒÓùá‹i1¨åËý1ñ¢ùÊ—±eú¡º%Ü#í´õ%1Yê2òšâ<&h¨^Ë‘ûŠðŽó±¥Ä-†oÚ ©(m`dìß ¨n²<úͲÅbbÄ\š‚ÂÜgmÎnì†3ëñ©åØ¿ÑL¢Ì3:¦†2”âØ»Œòc×Oõ®,]ù1Î\£]AèÂôÍJ˜ô zëÃzÍ:rüÖ;´`µ•µü ^MŠ6ºÀ‰c§²óŒ°˜(×܈ALj/+zqZ]ÆWTOf”kÉ ã9ˆ‡úÿ–�G¡ß¤wÞž0 ý<*Š/“¾“°±Ð”~ƒ†®LÂù½(|`P´sçÎÃÿà‘;ÅÜ"6ü¡hº¸®ÇÈ “lúSðQ9MDIÌÀŠ ÎN®~: ÆuoMÆéK6Œ‡T.¢íïüΦ¥•ñ6ØÖÒ§Õ’,9“zÞ€žó³C¾ß±ˆ¾ò6ªØfâ,I'6£_¼whÙÁøÈà<^6ztJ”ÒtÈ ¤»¶jÐWfŽÇ:è’ölú´;B_·-bo¡4H¬3Æ@‹<sg‰Xj-tõzc�…Æ}fò ˜•ÓŠa/Üåùák™¶‡y[U¹\„ÑX«uŽž¶ÕfãZ[‚|ü+k ÜW®=÷?·]€œéýyõÒóû;|¤#ÇÆ¥¸¥ó0ë7žx¶KG^N7³"si=ˆPk N©sËBw€rmÏT¡}vá  ;}À{í5N ,æ1µ_•GìôéDàºm3ªEF10„µ«º¿B}h;¡·�{iñÍZ÷à_ñ­ð.f¯Ø)ÊÔÀ‡Êj›Be,Ð#7º>Eh┪¢…\ŠCŠ½°¤Ýè"-™jZã3z7ÃNዯ=Ó¸ÊüEìsIŸ^‰˜QüöÏ[”jQHIÛ_Úü‡³œ8Éü©)åmF‹þ5pÞúšv”Ù«ôÝ£ÔÎõ÷R)‰§?Â|½ãHk³ÜÄÇ1“¯x‘R=KÝ@©Ç]Ó\£ÍK«ËMÍÙà$èÎÞó,jGÂÆ¿ÇÉÏ‹+¡°¦))ÄO•Ž«ù¼cg%À`Tÿ½‡†“¥[\‚|‚2J+ed¤P8Lµ+×WþD™/£'úYeP¶Z»"¬qtz[QÙŽÝÉÝÖ7_ýeÿ Þ§tªô èZõ>´º¿ô¿°ËíU=ר*|žÄ[픉ÏDIeËnÀPBbð %éX~ŠÞ9VÓÔ+bO±=R[¿»øH_ic‚.4$•\G©×b…ý© ½ÒûRr²x¸#ße{¸ˆâØ èqç‹]™#t)?ϬàXj´_íXZŒl²¸Fj@Ë’õ´¤´ÖvÌã§ø'ÈàµîrH¿ÒQ;¼šò·À`;dG©Éý¹3}øfòzù˼QÅuäi–g~; Lª‰ªäN%¶* y3Õý•Žý+@UÔ¡tµ¥ðÛ ^´ç4GQð=®íâÍ6ù¹Ñ–ÁñPÙÔù ö]ÏVˆnb¸­ÿÔŒ�2/^ß,ôKï°B•‘ñ—"ÁQŠòRá+ÃÙâÊuC#ÙæÌúMÍ‘…ÙRÄ÷EkuM™C‘d²ÎöOî-tÏ ïᪧlFïú—‡PÞIP°b9úÏt:vã?{ĦÛß|çoÑX·óâ"Ø\Ù_\Ün;:~![¤Z?˜O,ZÙlu:mhħwGÛ£3ußôÆ¥¢`óŽ�S¸€/Ò4žJžðbõË4(;ý3#½1ðo!Ô k¬>Ol®Ï¾e ;£öÄtgÚâw_^UFog9îÆ–˜;ý´3éaïÌñô� g>y)„‚o”Mm’;ˆ4¿ÓèÑÕð"ÀTß|õ©fˆñ”Ä’HÛ#âËÙ£HMó©i&¦È—¨÷‚«p+lÚ3›:z­g¦Ã@-núÔÖ¾²^c·gÈñ¿·ˆ| {!Ä .ù®‡» ðÀHbB ºþ+s”"oœa˜‚‘—vrKÏ/#g5,¨ªŒ“é‘E˜~ÎçÞp}§ì½cÃc‰&“Ëнü»k/+Q,F7TŸ ØÆL£' æh뜚Ûfò'ÕH²Vd@‡ªäõdf¢+Ô(c ˆ‹–¶'”ËI&1eyÄí&­¦o¥•rÇ'eÉEfo¥ ÄõncÝÏ~ÎØrL„$Ĉ3ܦkýb »Þ¯àpR 6} ±:cQIÅ~‹'‰]KiGùJ8Ÿ=“[Wð©Ç=M·lYáˆMySøW+¿v… ÉÞ¨|æŽ%~à³·—éÔSX¤jo·Ù!¹p—¬ŠXZÝãXx;Ý»ÖÜÈM U ðn FþÞò'Xôe«›Ò?ÊøxÜé(‹/V‚¹—½ì”ëIø²÷$ˆ“Ô#âÉ°ìIö¡ñÏï'vþuƒuŒZ!£ ¯P™Ö=@zÔôy7=mñ¤>{í‹3oNÅUç,Ž÷/o¢s87:8çšVNgÍ„ã”Îýi§rDk FÙåû2Þnk¡HâØ=daP¬{Ó�eq‚ÀÎP}\t#Ðíõîk?$>©”{ùˆq³âó,0<6Ý“+Ó>VÏ€'ß)¡2/à×TD:'íÐ0]Ç›OYÏÀ©æÄ ¦ Òuov"× »è}×××èÑǘö¸²=Aüô)&äõ_3‰«øì¡*CMÕºB3à`žS¤íÆ#–ÕÅ¿ôÕÄ2cl5lèó…6á}‘éCŸõƒÏ´#·ëF³3ÜM” óyËãûõ<@|§¸ß>O»aþ-7*ã(uHT±]\^™)>n,dË«ôžݼeÙ4Æß„" d÷?iÁyaåqŽ^#VŒjgñwC:ýîD´“‹Ðc‡±P «Y©…À˜w˜˜êè¾£}Ôµ/Ïi’*öKM‘AÉ‚bÒ-~ª)Ïè¡v“<‰+Vp0 ˼"=sç˜ÁYÒÖª¯R0Ñ N”þE?“4\ $è.L ¨õ_ÇèûC_߃7÷ðzxðj1!Ž9›‚²•/ó0ã´zû‡v/ÝtÍ°ÕÂþ§³õHdüÝ©]1¼9DFø xAžÖkÜñ#k‰ÆèŒòþYÇgW'e´ðpÙÒ¡ ¤uðöÝD߆Ÿ«€<­•Ãà ×g]ÈcBGøHÇM>~i4³þ²?îVž#ηGe¶¸5ôŽ TĶvŽƒs˜JîËÖ΋_œ¨ûž+ÜÊZÍôvíÖÙ-\|ù0yäµ~Kt%wG $>Í×ÏYŸªÿÕ#l l™m–¤AõÙµüÛ= ÷"÷'ˆd-¹Ö}° õÞž燆»³_ï^>få8ÑZÝûãbå³u ŽAAß{Oî{Ù 2t¦P(”’ ¨¤<¿›=tvs§žhÈÿyÜFy^ßýAÜW èõ« ‰I¸¬øÃàmƒlÖFœ'”@õèDyê¤<²`ÓÆÍ gã…vYôŸ8JÝÀl1•´syÌû褵°§—œtŠÂf„¢:7nPZ†z¡3D¤ƒÎýéÀó_mJë½—0éK".å­ørjÔù‡ mþêÔ,¬lgäçFpi¦.ò7ú:–ä½¢ë–Y¸<ä©*ʃh°^Ò¹0ƒ›ÅfçÄ«JúðüŽ7ÊÉ 2¦¶ýÐ÷9V•Ùà@…Òê@gídÍo*Ðö§þ4É„¾ºmLºK­îc=þÄ~ bÚT‡V­Õì–Hk þÑ|ØCTFâ­›…›üS1¡"\Oª M €. eh—áÒÊÆžÌTóÔô�õYwâÖ7¨Nò êG¯öᜈò�9(Ú±¾ )P0H;ÀÍkûÔk°L|ÉŠ;&ùöƒi{T• Âf΄ †[YwÅòbÑÄ.غ0çIŸHk(G8ýý_8úœ'„ùàü‡îÈQ7iÅíF+Aòc×Û®º SÇ4ŒhN'•“`P<—ÿ¹U¾IBÔo<Q³”eù¯ °¤Ò]o{¨éX~)°¸éâ8{ Š0gË7«Šöscûw˜;Q¦´žUªÕÕ¿·ÿ_5¾ˆ£Êï�Ðî:|Q9çÜ×#�!{Z|hþ™Ærc’_w;u®b–¡2ŠJ?Q==½°×ô3 îK|0FaâÐ�œÔÌŸâ­º:8hý*‹¶'Oëéµq/ ø%FV ´àh� èµÚCTS[ÞâAáL€edûtxy´&öó fôvŽŠàbÆRÿvÜ1›A HãÅo1mà7 Å”átðÀ3àÍktÏ%â'z†cG³1[¸ß %¾ý|°ÊíxØÍœ;ÑâÝJu s³Ú™Ý[­)+¬d.Æ£œãhCP%}ÐÖ¿|µ9˜Z—¦Ä¨1î}k¿\ŸXÎQ¥—½>îH=Ç.©VÛ<ÈÆÁ±”PæIÊ4ݨ€öÿ½ƒõˆòÔBŠ¡òB'ísk¨¨)KE°,KI‰˜ôà‹qóôþ'Î]Ó€qºÙ�ÎÚŒªdÞà!ì{>s 7Îå%ÂpiàÑ4Î@f xûx8ËjÜׂ¹¡…€¢Ww�kN[Q jŽ}œ1^ENÅ­:Õµeäø‰>žoGãûÒ„…׺d—ì3Ô"´ÛRæ ŸQ1¨ÌÂ2B>ä°Y©ùØ�¼š)ûÕìùÃICŒÃ)÷†üÈ/½è¢´\ˆ„R?S‘±>•´¨"p€áñF4g}OòÕHæÏ9-ò¸XVù }b lI£Ýe:M8³ÏRŠ2ž6Ú À, }É�ºYÜ÷À̸ìÔç Gƒ–*3DyÙ¼Ï0ŸzÒýH*ß@”JÃ#œ#Ö®•Œ•CwæM„-*yÇžVtÜ\Ñ×%Æïè³Ü¼f’Ï­%°#ÊTkwK¾µ˜q˜ fAÖ÷#¥¼¬sdaO�òyTTf {ß2h€¢mÖæi6ø e0ò!ô1$U8©ÿzžÓyOy96ã­ù¯ïL^3Áíg£-…÷9vJžÊü¸6µnÎv™N¥8˜ŽÝ0\€Q¢¢ƒåÍLç—?Eè™^f9fyPn´³€Ê°ïjÏéâ›ac‘š7LM§¦ÝÒyñ¥z@(ÖèÛVâUñÞâž}^¤—†˜«N ¿ü]¡)Klæô³†\žyPoP}'Z Píñü½MëË4%Lºwù ÌIðuªÜÂ-;Ájé< ÂáHÍjÛ‚Ê>¦ >EEÎJMĹá±Xž”™ ﵨìÿ*à4ž*¦<Àmþ*òðÌ«[peÌ*Êq¬{¯q�]„®«š>wÂ|’iRéç`’ƒãÔ¶ëŽoÕgK&µ­Œ¦¾:§iîëæ‰mBi›q)k»_<ÍÜÇ~ Qúf¾<‚3÷æè ßFeÝÉÝ#¹”†´82˜f o?®íªOªö$Àz9£ò”±z!Ž <R¿ù)×3‘w€\ªL©öÐ4êGï~äïFñ‰G–:ßMCRO+AÞľê}ã#°ñÛ­Ì{BoL¸×ð·eá»)0¤š‘º× ^Â`¯q¼¸F+m©–íÃW,÷Øé9fHSÇ ÅØn£d:QD6CJé/´+«¬/¦°HyÅvô8¼ôžÜX5Ùº&ª½‡|³r1ûø�£õÙ!”Z:RÅ´ePuyG ¯3ˆS.¶ï‹tçyè…-L4{Š)MïA8¶”AoÓŽmxsN½pÿùá\3ÝØ\qÚCˆ-ƒlS7ÞÚîZEÔZÓ¤’ÚW}ô³©ù,œàq¤CÎèìrá!FTßµ8ƒ¼ 6rß©bѳdɲ),çqÓÝèÁ‘%÷’ÊPÓišù>å‘òµ²€ŒøLþ)‘1*œS¶ çV{„ømëÚž˜‰ N<8”p2ã.¯õ­þ+壮 ¶#láÕ?ŠÇ°(‰´ ëõnÕihƒ}kDSÎÜò8äß·Ì)veS—øxñ’Vr’ýO¦.vˆÏ�¨}aÊ; .Q¥»÷ŽœBs_Ù²ÎìÈþpòä·Iƒxøë¹·T|Ñ#Õ:°È ãjÓµ½T”çàFLºOØ·fÍ'Ò„ïF©c&EmV‰‘Ž€\B´½Bt¥ —xäK%veãcïAæTeÏk˜ü5\¾L2¯Ý€ñ^O‡ê»³®„ÁbTmë]k̼K)È@æ»_{j:R&PµÝ³–õ@Âá9•»A|8í|#ÿgÛ J|ñF;pÙwñ¤z ÷ä–yó-…Å¡fÒÛ+œºØo3÷u^—2µy˜˜¹.[ i¶Uã±úuäi”VÌú@\:×èøp,`:éaQêý{ŒW%eèú@™×yPô[“Ùq ½h¸)à²ð”^¤Ì…–WºGanåGéóbк¯‚l;øŽ’tÄ’ŠÕf¹©´ˆSeèOÇ°ú@ŸúìÌN–>ÂxìÖÛ¯ÊÒ…gæð”ŸTU4-jã­ê@YZ¸Ð™|¿;](…/WNä„¢³ ×b™Á‹Ì0‘çz7°Ê…'$Äýv©6¬’PÚý(DT¾’©u"¦TÞï¹k¡|M”}Ë÷Š<îd ï”bßÆ2óKy`#Àîc:Ék¯Ê]TÙ/ªÆ–³™3 ’c·é†•6‰~fNhïd5*<œ°ž1jøáŽfvÁ5w®p€Yé˜Ñ‚\é¾X¬½!ŠÆFk€…æ·Õ0Ÿî«ãNҴ3âòV+bnPy¬Ï VØŠ%[ ÿ-)()} *´Æ4H>½ºgº¬jFw(áh¿ájûú@×,Š*WÕsòA 7UhçÙe®aèôÈè5Š“w®4u½ùbEzRHÌw⡵RgT°¥Í`ÄÍ--¶|Ñ 1#8\í-g7s‚û(áb0`u† IIÖ÷2-?À6|Ä_~ņMÂ2\š†ƒÆ‘êŠÖ² à¼Dãȼ6Z$ä)(",Úú"ÀÌdýM@w“·‹/Yî]F^”©¯†’ž²Ó'‘ÇÜà…ºtm‹…tçâf奓ÄxýúpRJl¶Õ•\»ãQZ ÷µ‹“*ó}€ùfÞéË‹·h»m;¥Æ½ ÂCRU©³7ê·\<êÇ–š*Œx6›z2oM*cNï]r9AyÝ¢¯ÌIÑ`¡èUÔÔs±³aÝ ³þé'i;wÆ áÓŸ<̓ö§sî+ Ònmæî€í_k~ob™yqŒÖ AgqCkÿ‘(¡@Qõ´³ŒGˆ†kæ{’øÄdöe Öª lô.ۈ‡BP¿s ‡¾¾ÝàmM‘¬Ûxù6ð0ïë »Š«—Ljb¡åÙ{ #ù]ùî…B•4yèd¬-¨×=a)x>fðO¶qŽZgôÆ I”“Y!¹`éï`”Iïþòöæeá•.ûžÕÖ/j¡øêÚö)-åú2Saú/Ý5–x/Œ¡Ï0k­HE½6i®Qn2 ¼×„YSëÄS0ôt¦?˜öGs«è,ÄߪÜRä×F¨ëj/÷:éÃÊ …¥B)aë¾}÷V¨Þi®û@éÁSêÊs·ŸØÈhŒâÝ/¼)ÐÎáï –˜Î0æÛäI '¯—¸:ì6´±´…#gé¯ô%ð#þÐ, â^°ötÇÞþìVf!ºguXF«ix.OÜ‘ƒžV =(A­,>ežo›•Éó!àèÌè—“Ô"u¹‹åmÀ7Mk%ýàè5 ›6L爾—½º/¤k‡´bòF_§Á%¢u  ÀxîÜâݵóS®gôŸ"óE#ä;¤Aa½»!J1!¯×ï°¦¬VAêþ5ƒd1%ó;•gÄHfÖ¬Š¾>½'ÃU»Œ)•àû¢`UîŠvIùÛ® Ü°ùëéîˆú­;~š±åZi>Ü'[zˆã…;ÕÁùfòÔÚ¦‹g}÷iÎx¡±ÕCRÄ #aðáSámß'¦×t9˜ÍI´­‡ªÞÜs‹Cëê'™¸¾õ]mtÚ Ãn „™o'ö¾FÔ´Èïûy\šUnâÏÌÔ#L¾²c£¸&@bâb�F÷å4+kÚ45úQ›S”óÑÜ5Z£uÓX ¸õ BRÂhÏÛf¼³bfNvþÄÙÔ|:pf¾+¶˜b‘þÀa^þ0ÓŸÐ.&ZÎ’ƒ…¥)(eË»Éu:ié|hzÁ"Ý– 2‹ˆ‚a€×fmÝãa:ö§ë/2?Ùîò0U7èÕ÷ºK¡·ð9ã:è<Ml/c_£N-XÏæ°áZ¨Û즠OÃÊqé#\(Á Dˆr¬±öô‚¡µé™{ô‹ÎssÑ¿ÞúN©îy*È;ŠÌhgôOu š{#>Ö‡ô‚åEÒ5½à#i÷¬ˆh¹�¹Ñ ¹(Ö$uíùqŽÈK3µë ää5<ɽ: eÕ)T(Ë©[!ªha=2‘ê!< ‰Rë/¯×ˆ‡kéônŸ"Wí{9÷í4Z‹Œ–4Y'”NRZ½ÛÎX×£¬ée®c\?~‡Gò”3D¦ƒAîðr2=üx`Š»õÚ„ÜWÁíYN×0i¸MÁ ¶¢¶’KH¦¼ÞÛ/IkV�0äÛF Ιö§ÿlW0&Ðdסù·æ¿±Ç }­…ƒ¦…±{ª¤§ZqïŸrgq¡LƒG»~Ïp3«½ÁÐúåO¾àclº|‚Õju’š¢ ·ûãM|—Ù欖¥D¥‡¶ôOµý´T) —k,M=Iï–îÑq¹ £C'²JƒŒÊ5É„¤Ã# Šûëùõ :9sdO wb2Ý÷*øê°NVµ;‡-°^ö ¡­+^ÔÍ‹…{Y ‚Áà¥E`a3¯UHŽ«OÉ¥ûQ3m蟾ûg{8‚)MÁFBö¿k‘¹kÓžrS ‡Žà½‰w²TtDpà?3ŒKRC·`¢PTŠäwjæxô®EÌšVBçÙyZ?Ðþ.—ŒîÔ(ü×:Dù“Ï;+ÍLá‹où‰µ´ìër¨lgú¡á¯šúBG'¥‚ F\okƒéc-pž÷r ±?å‘å~E™€sø¢}•÷ƒû#H’í+ »}ÁRyÌ>΃„…Ypc´¹…ÃsrzÞÓèVˆ»Á½Y»…}Ħ_,:ë…pYÃx îî„€‡R멳m²JãtûåѤö ±ì¹ä T>¸^ùŒµlÈ>zÿèò©Ë»bEñú\»¨PÌ'Õ²GÀŸn~Öj¾„Od¨Y�ÏPž*hòœHØ}3Ög®éÌë2²ŽJæ< Š—@`:îú ®èü`E nöÿ}Œ+÷ˆœ LؾV$¢fN0 uàöJM{“ÓÌç6Ñ™‡Áç>Dß%~&ð裵T~7Æ}~Å0[»Ž€NÏ®|o<á³:ù•ÛëE\V¦ yÞ*8öI:7ð±'Ô&® tìMnh/ óøž>W¬Z©ç?†YZ[T…óÝ`òܵCgìØ~Â9JãøªEpþ“Õç§õîä¡{ëL ôöÑ=½éŠ¶pçÁOMoËUÃï`–ÊfdN¦x^߯Þeî1î±ytïkÏ®Ë!‰&¶O2é¦~ä;å†ÍÄ"#]Ó÷¨6Þ7ÞÉJ1ê 0Ù‰·Â¦ÃàR/(?_Ì¿ìhî¶X$+(;/Öo'0j^rj2™zGuÅ-Ì�MlÉóå4+E_4ˆ„/V“/ã8bæÈ ?d˜òZS4K|ÕDØaÅÚ 9m—zÜŒ'~··Š2óü-aJ1ÓéÔøú°3”¶¢¬å•½ø®úJ]#­:[vj¶0eÚÞK‰à=­@N“ÎuËõ€5Eå'u5b¼UÁ¨XºJÃÌû»NPãx¡C(9Ú·a±–V¢:A+ó<ÂÏx° ¼ÌãF™V[7 €Aav4÷„9'ùb0B; ÊÏãµ\Š/ånºªæß”@eUdž³²†.§õâ6­Ò]v$�þ!ÃοþeU}D:”Þyùr6×þC Ï΄9+©4íÉ`ˆ�¥¶f̾A${ ®Öðæ²{…y¨rcˆ¼­©È.Ùª§@ó*•Ì&÷BJx~\Žgƒ·:Íl²µ¡Yä•wŒø}2HŽ}‰v–ÿ‚ZV[mÃ&óLqÔí¹š›qÖC7|þ,³h1 5¦ƒ Óµ\<‹Z$È�‘¸¡ã"3G­ Êí¤42–Nê<«ÉùB …€æ]¦ó$ŠKcFeíÐVÛ<±†S œ¥úá°µaÓ5*ô˜}›d^w9Ä­î;*‰_wHhµÆB«n`6þYÖôn3Ý$*OLJ•¸¦9 ŠÁºÚå‚F¯UÊ ëG?.¤n‘5³mväÖ6\×9œMiÕvt_äî/EyUKŠ¢ÙþcƒFË˸j”íBëÜ î9ñTöõ1xôŸL]xzÄzdU–]] ‡bµy¦õÉ# N¶PRE?œÉ:]ëå·MWŸú]wR¡ž¢´Š7Ǥ¹§ªÂäEÄFL0–ªs®ÿìÄØ]Ý1ÚŒã2ó%(@¤ÄìsÔ `ˆÎ"h�DÚ›ûлò@ìïEG Yïv±pcŸBXãÃ:QP|,7-y§;„eOŒ‰lìV3Å¡¼RÚ­*ˆ¾¯[&ç?]–¥CwgòXéŸt¶­8Ç“ˆ�¦)ûZúOî¾È™m©HÍI G„õÖáºyÓËâØ7 1<�GÜ‚ Äøò–ucL¯í…N`qÚBÁlœº¦|nRª\ÇÖ°±eÜ`dTBlà·9ô­1IvOdœm†ËÜ#Š'ç‰ö*DWæ2/d§Õ3`›WÓ¼-ŠÝD¤&´ºg]Š<UÁ¸Y·*·ƒ¤ºwu+¸äqri Ñ‘}9yª<ø† ´‡qº³‘‰~dÚV†~=HçÓnC;hk|asµÕA·0&¹˜„Ó2øØ)ãà&†yÃU^‘füùiI*9Ó$T†þ^;ì¼?ú,ËÞ‘ ‡‘ú±÷¦Áû€{ÎH—Ö†šd<ôÝ‹C¿T¥oÍÚɸñ†0Î^SÎÕÖÛ²y¬üyܢŒ?æO:‚úµÛ+«ñr†–õnÃÊtöâZ£!ñ?'g,k·}ªFe±Êùàñ•lC¬;僚`‹ÊÓT y”_ÓÚí¬ÍgÈÔªÚé£í†³%à¿ñ…W�‘²‰‚sK»ªuíQ|@M C;§û[Š¥Â"!Ö¼^ïš4r,&ƒß£5èàí{¢0•¾Ó@÷Ý¼ë €v­´Ð¯:£kùG#ÈFß¾5Ƶ‚yU‡ÀŸ~”�fŸhÓG_jŠÎCAq˃>}™h/¶ÂV½KÍŽâÂXÀñ ´!«ËÖŒžÊk¥¸ñ$>Yt<QMÏäS¶Þ»»>ej2˜¶…'øÏêppBƒóálŽ"wõºPŠÖ³%•R®º¾AÑZ?%Td–×kG˜” Ì<x­ÕUC>÷Ü1¸/Ç<µì½³&MV0ç猜1lqÐë6²9<Z¹è–#?ÑþÕÓ®h’…>Z&JÑ‹áËÃÚ6‡³åêLûnÞŠ‹ƒ»zè‡æÉþÉejpü9šs™hQ³–…@G~‰Ì [ƒÓŒ“9¬•.� ³XÈ;¿Èûþ†8‡=Šh±yBëÓø·óôq_­X±pépƒ†yÎ)ïWNêDÙùŸzðµŠSXb³=#÷$VE¯‚ã,¿44(V-›ŽžN1[­;¤ìdÙ«f…>òH¥—¦,HOŠ]¨„Ê:pÂgˆMƒŸ7¯rK¯ÉÂŽèÐ9‰�4 }Z[ɸ’=‹N£øb›/±çÓ€ o>ݨ¿Ed‘ñ]’¡"(M#Fsž¹ì?صõhÅÁ%•4Ê`”GFµ…›eßî4ËBOp ‚÷F¢³^ ú'NUCà‡B*Îk:‰éYá•(ÖÒL7¿é Å¡³êA†Éä ™/¶Ù2‡Ž§úø •2ŽS߂一iVΣÅZ™²Xfã²Pàæèë5ÎJ%‹™KŽûÅtñ¨Éh˜»~ÆQ5ÞéÄžO=ûÆQE[Péøî*öÕI¦Öúè4îLãü>œPœ1¦ÐKllN 8DÂZk‡"'­ð„5$p�eSpg󢦈.8·ªñD�oV»QòU\i(øš²ùtLá–X††²IY¿g¯W^tÉ…*Ië®k<ºç4Ÿ¨h·ößÓì|‹%“)j «;ÖÞ|kÄ|KwÊ=ˆÂ3ýU/)Û²á\Q«Ç4߀ǙìÀù›ÞKúgŠG›>b¯œØ™Ó[ M1h±¨¡o/;.5 Ke”ˆ0kIzÅ fÕ*`t–?ÿxÊ£®1͆ a{‚ÔQíz¦ (ØáÌXþG‚%ÿ»ÿä³Nø¨ Ó`¯<îÕ¼œ*ÊvO&“¡Ø&‰§™§IÈ–B±ÜdF³ð¿}RV*ªR¦Úð¡í7óßbÑÅ@Ç4ߟ³"aa®5²úÚRüKÓ¸5ƒÑ5•–ùwOuwôcBY^…¤e¹Å0cêŠÔB ý…„,]º§AÛ—<üsömøˆã…Í·Ý08ôúö4UP.DÌjòrë«$Ê¥DFš²¥­ºè.N¶æîÈèúc0Ÿµ¤2ì¹YN¬÷ƒWÌ5±8éýÚ×oò³$òA,öU‰%L÷ݵ«ÓqÉÁ}ÂúÉrß)âeéÑISö':&šuýÌqyNAˆ.!Ý>ÛŒ!zû ²ÍÒŸÇPM»šnäd¨ñ¶pœêþ1­5sŠÿ<®Ç¡â¬TŸ ÆÖý†R$3k:°ù´¹ñtˆXyr”Ò§Ú¦´D,4E$›zH“ØŒ"û‡åïߎ9âÌqœ¿Ï%ñçÚÉk÷lÆcy £(Þ‚� Õ?Íå s Q»–Ö“˜|õÀ$³¾Ú½_ú.P’1ú0 '²ÄµÿåêyÜiQÚHMVç2H¬YHn 'OHÚ8r4ØþÒÈ,ömRaíÐãž-:Í—zžòŒ‹(§±P—Ü“Ù0jLfä1z¾"'²­)ˆÓt8Ê÷=võÇr?ÄÖâ«2z—ó:£À®àcéàRëv/ĉG­÷4LjÛFB>p#nL+€h*Ý3O\ÞýöÅ£·Ìüî}|èP™Ô¬ x:טϙv-Ý V-€ýºš\Ái@“ŸCŸÒ¦Ö,^ß8s*Q†c4€‚}ÑVÃ’¯DY@µ,ˆ[?¬éÿÕ“pðê¥ëWí4'ž> ãøx­õ¤Nr3òç_ĦÞ@› =æ´{wÄ@¾ñû«ÝSD߸DfYí6}‡¤ŽãЕe¥ˆƒ¢§u1Ä]¾7—»ýÅ6á_ ^tiM(+‹±ñ@É(;Uþמ§éìërZ6D¯Û£ÅB/*¹xÈ>mÖœs»lËì”W…úãTû¹™ßR ˜2€ÈÕUcÍ3 üŽªï®g|©ç!ÌÈä}½=Ñs?$Ó6{¬wâjäÄû¼K‘›Ì1¬fs¢ÞèG‰5ºàB{¢Œæ%Š@@BÿÃ]/\ä{WŽ¢ýÅ(2ùò°I‚|=»q‘ôåq”ž—/ dÄQ¸ ÅçA?з9+ª3÷M­EÇùwßd=ŒE@r—éqìsZÚÇ$¼¿mx*[ƪŒaõì+e<´+,S4`gŒÔCkêŽî7Šº¥,oEç ³S½Ñ+£ÄÏ[vÇiæŒ8ã`w,‚lTã£Lø˜“ñæ<mU‘À†ñxþ$­ÇÓùpÅÁ±Oƒ|èg a]ö_¢7UùA<#ÆNQîùyq‘Ž?WW2úùÞm¥H,öTÔ0ÙáԪꥬuOëÕ)\Û›Þ¸œZ}cIe)²ô¥‚åÙ*T°[û¥7v û;½€ù +‚-„VàQÒ±óF-,{'ŒM‘dø�%Oý¡ ’zÓtªÍ¸¿Ùj®T §_ã^¿f2´p)æîÊTÓ»6³Â €9Ú¡zZÌ)>`ùwyb¶ìrCgåiëtFëËÄwÛÉÙ,ãQ¾áÙ¦‰ŽíÀ.æq‚Aë×=æ(åÕml™?° ‹þ“ö 82:þÅFsûd.ë‹’JïÜãgw;) ¡4–ÍM`ÎûdRÓŒgœr:^yÎÑHc'A•02¡È¨W¸m„^ü'ß<Yã={Ùsÿ’Ït¤ƒ›aA¡/¡ªµY[ nP‹í¢(ýöˆÊÞ•Uݶ’óqåªnI ^ôâck Ïl&‰Ð#´D h¢ï¨<MÿúyƒØ±ÃJ?ªY‹7pYÅ([Cã=©Zwµ, £p‘SVÓÃêI§¹xÎbÉŸ_ÙòÓ ¶ <â†TŸzïÏ—¡Er2èÝ/}“Éf t™0ya{àÝÄõäÍ·æйñ€ºÙŸ¾Ož©±ðÙGlrÓëW×RH‹ÌIÓÓÝœÒ"(»/­öY‡–!•}š±ñ4TC½«W—âð:RL%ôÃÿz>ò{Z l]ª£X'T65 Ÿ¾>߃¸)¸œyûŽÞmÝhÍf´*kZ¦È^0nr†ôÞµl4 /Æ>@—=›ò´…ŸfäKi‹R´ÿ@êù›AêKŠ¦‡è*Ö7v_–°yèý1íµfÅXýM-<„×)neÙÔ+CéçèxôŒÜWtXpU øïöÑ‚Qĺõóæ™Ódd2$t©=ýñ§šØ…fv|óaµµÆÍW« [³S´‰ÉVöõ †¡Ï*'×}<¨æÄcçùDfÇõr2Ot :V"¾õ®dS/íÞ8ݽo$øÊÐ!URVÉÇz´¤ègÐ+ÛÃ]Q•Çý¦(‹®(8TÔ�™ª0Ø©[³¬H>Wô‡ *ê<Q3j{˜ïËg8b1°ôɨ¹e£N× ;¥äY®lüJ'Jóò0´Ì| ' ”†”î‹cd‰§´óä§×S%þSÊH\WZmG»!þ:9…: £¨®(Gµ2Ð5MÞïýä’5£À�/æ\,(Œâ@"<oL¥M¬ïðX½•E'Ÿþ( +ù{4í´ z³°¹ 7ñ©èé5GT…^OáÜ!x©K•Ø™Ñ“©öyRd6àÕô-S瀊í]ð{;µêdÁÕÁù~ÒÇ Î÷NÁUæ»gÑÃÙŽ´œk•°�>tM;k´žª|{q_]8Ë|lZÑÇŽm¶­=R$Í$e˜ÖÜä.0_äÕ#"nûš½P¶m„}on›Ì0øÌ–ÛS‹­(Áï‰ÿbU:V#û® òÓ§Û)ÍÅײhFc†öV ÀÂn·.±»AgKÄ$T­.ôù·*È{>ÀÙKí¹»³�ljž§‹›ý“µ³ûø«z¨[Oˆi<0ø9¹Iå˜è´ÄÊ&Ž•ñ±;&TÑ;þìùB€œþ÷]»ýRßLj~OPÛvCJ#M?P®µNJcUlãVŽd æO¼¦+ß܈ɦÁª¡ãá¨5z·?âý0â®G8dZl¡íä„l¥…e"ÆŸ±}GÏ3¿ÓCñžù×ï[«î’^±Ý©ÔÔjþy&½BfÁ1]‹KIl¥øü½[ä‹ ÅÌá̃d>©—*LmPm;Á:ˆfh¾'sf 8.”�Z:¬³Æ“á7o!:Ó3š&óîÓÇî(ˆñwJ§t¡|fÐ2ÒfpâØuŠ¦ÐÙOcæ"|ÆaåÆt¼^wÇÜ'O°zG§¼AcñotŸ†áÕ4—Ž5*Æ£ÃÀ7¨™ ö‚Å ŠWÆm›2Ó‚N‘¿ÞgØ ³™ OMÊcZmYA Ȩ̈® IâßL‹ë<Èû‹7³Aù‚·Ξý—á‚ÅØãþŒ“t”ñ.\SÊ ´‚œEp ÙÕá|„:…õeÎ{½¶¥ì>½ @ÂÉQ;(ÎTFzaEs âîódÝ_C ¡ï5Haˆµ5 ‡qp<@&ÀàUœ|Æ! Û|L ~A�¥ëO¦¨w23§ä¨ý¦´òä¾YܺûJª îÎ>¶ CO}¨¡¿%‹\/$÷^hh%i¦ä¬œôQÖjŠÊns8ñ´%³ö%îÒâ¿QÄr[þá`ßs§9’3½¦»£Ñ@ðn^Ù AMŒS³øÐåàu¬Wp˜5|ê>§ã¼WR(Ÿfä*V"Ts Æ)ü•i“›W$é¦[±uÝ ƒ‹–÷§ÕÙn˜Iõ*ž*÷€l´0î‹ <_\³£?­y%ê ¨$=¡‚EU-¥Ãý’ª\`a`¶À£/Í|†Rf;—ö˜Ø?D*íí5/·_iPõuëÁ¹Ê)Vbù='sO?’"ânMùÈŠ :.?oRÇÔ‡U·IGýß~¤67¹ä6ŠËBs8ð\f$[ i« iª 4£ VÈ›�>8õ“ªÚ¡×¥/Çì“«flTT^jBpõ‡žóÆN ÿÐÖëÑÞ£€(wqãðfÏôØ„ŒfK÷>=ê1VaÂŽî°ã.ÒI‡µkàj‹¬L@â«Ç"dC'o1k)/z<°ugFœþûfÚ‹TGÚnšjo-½(tea,‚¯‚‘£²,ÉŠè È}ß™v‚ì»Ê!råKÃp1È(„ˆuÔÞ+T¨xRm˜ÍŽ„õË–_•‘Þ8:ÕÚÆ vô1ÎÏyœÇä ñPi }ƒ +B/ocuÿf€}«¦m˜;k:VŠÐïh˜—Éy{Îl{Åz¸'íg¹ÓV¡• cPt¨ñK¯âÐñÑ3ʃáL·¥úT°eŽÉÝáópÓünxÖuȳ´ð©@Ø¡·Ü*´û$¡7 ϼ}¾)¯Ðt¢j!Y‚8½‰˜$Ÿ{__–²Óë$ám”u÷Ä9Ë2¿[a“ùQoŠW~yy;ÈjHÿêÞŠ¼® ‡ Àò µÚöØŽ ëËdþ½§‰–g¾’&ÝšyWáT¹Æ«íÙ %Ÿøä‚›9ëë]9ø¨Ì}¡rJy.~Ñ DnÁ<íM¾ò@&2ñ½‚Å°. ²A¥$A•zsY8„Wö½ÊvâSGÐpµ‹Ü Q&»£/Ð+7ø´Lu‰|ŒìSxE-¹’Dì0]lÍ”žð'&“°À~˜ínõÁoÓ€ý´ ¯Dqä÷îÂ’’Š,Èß;™@(¡Üá'B)1íQ ¯'˜~™)ƒ¯V%]_…‹š!¦ ŧ÷ÁŸö³<žôçhUY‰òe«Å\r@©ÅŸÃ뺰kkãòø¸ò :)ØŽ1–óI=¥TÝ^>P[¼ˆüö! :Ïb`%˜%“õ=Õâ(žì8ÕuO¤µs5RP)dÎÄËSç@4hJv®èüw‰xì è¡¥Pç*ˆ¶G«Z˜¿ýóFqAížgî]çeí[`Ÿ(úév*™xTJ¢Â 5|�6šóÜeøz3)| b˜Q…TÑ‚¶�þ"ÆÍζÅóˆ­èµð[ª@D¥çÐ1V1²“’Søy‹fá‚”±Å$os—¤mù˜ŸÚpСs®oz÷eÞ›²ï4qe8á‹ ÷§Ó`Ë>{ã¤ý$Ÿ§…“Þˆ.â;Ÿ/«ÝËåúzkvhq,µƒôkÓÓ‰–OG&7‘YñΨäÁå="IîZ¾"=v¡ÇFš×‚TîÐ(Uzn=evÚxüîgÌR/ÑáÔOPË9Zä´a ¯Ûi»ž€æ#‚˽.<€³43ÞTéòNai%óFœÊ{ÿ’­m{jΡZ3Ô¢ÉÿìVõX» 秒õè2{þô|òŒ{Zú–BsÛÃ@Ç F$­@Ÿh)$áµy+€ùd9I{«.¥G¤Î^Á­§œA£c`J+ÆÚ|2š¾ôê⯙gCÒ< }#zÇ3íRø˜\8Ù ¾ ø“_„^Ë|³ÄÎp'ÜöŠáhŽõð  ÔÿÔiÏÃ…M=·vmÑ(ÁÓ¥§´) vq9æí ³"'à_yøƒ¾‹!gM§×E)òÐ3GDÖòsŽßiXx†[(ÌS¢*px÷ˆ±óˆb~P&K%ïE Ã<}{'þÄÖŒZº)ç;µ`¯Ç¹^dÛ& çQåÝjvF;J]}7O÷Ž¬Å¸Št§ÖºÈ(«p*´„)Š®'ù "òfÍŒ¯ gR÷I½Û]¨ïS’æÿ+ºíÓòR¯n:a meK<¦ž2£…]!ÌÆ3£UGúßZ\S‰#înàÔëf’úŽg´Ð»VÕë(ó,t8¡;ô´ñvÊH׎šf¢b9žê_䙸�9 cøbR[ÝŸ‹í²Y)]éMÒ.¼ˆ/žis˜lŠò�ÏŒg"¸õÒXa;Ž\_|iZQ€­MZ:šZajºÕ–y¶°æî/Ã`t¥¾&Ž£åm$m•m ÿ1”tþ¬»Á‚l^úÆ¥Sš‰E Ž%F:çb¯ÝÿN›Ó|äfi CÓÑ3T¥R~@ÃX¸ç ›ÿ.TyØÖ;·Iô'ÏÜMÖE£äð…üÃ4véà§ÿf¤Ïgªƒ g‚qÂͦdûÛþFÓè©öòqÓyÒÜwÍÔï_*š@‚Å ÿS殾ç·ÇDo{v2#¸m«ÅB­†è¯ìÁ•,„´ ¤¶iVÉÛO¶£·fì8´¼‚M’ʵˆ¹CÁ¶®ñœÎu?œ¬ÙäÿŽÂ&€ µ—§Ý9náÈ9µ«e™.£È{­%p_S óÈ­ŒúÎpû4ÇW¦•ÜŠn†o•õ£ . &t@ÂDùl…uýá¨ùzPäfro€s.‚Ø°bbÞŒÝ0Å=ƒ4¤XL õ�ö/LÈ••º\SYág²�hC%½³>9lÒXy̤ˆ}Ã’(²·™¡µ‡/ú Ù¦6Ã>–¤3ŸGfã2[öÀâ½ûñ¸2r‰,‰|ì« z×2 YÎþ·bÚiì-ö:7ôµ¢ºõÚÔ+:ëGC±Ø<™^Œs“Âu3d{A.´²Õ8â›é˜¹â“é¹Ó§) ]•aò®íк…x”¶uÒ+ÇÏKÄ,Ê1­:ºÛÙÒù¦�Úá‰a Ù×; _ìR2&M´5Tœ[/êÌ;Z»~P°Ú‡2yikC‹ÓáEæhjX&LS Òºñ0´pаÄ7­ÏÌë3A/{ä<ûx€®È੶Àzn§Ü´å„ÿÛy¿%—Æjªé-óvôâÈ•í=çÙ3%£ì…>÷óßx³ˆg;t¸Ñ/.û£ÉP)Œôõôß·Œ‚=¯H3µã •t~?ŸÃ¤¬€¡"(`0nªÕY�ýÆà¦|ƒùר •#!‰ÑEÚ¬ŸúÞð 1<_Ož ‚‚µjC|ëh/îËÑä˜nþ¶N‚¢ë<t +!œI7ø5PöG•±Ô’®æ»f=Tž©€Qn-­ Ö¿CxTQki/ÐÒóúÇÓHDF”´‚pûÙ±}Á‹¾Ü¨Ud êäüö´vËÅÃCyó î`*¸ônE·Î¿¬§ÝÒÕ]m_*ëï ÕogJb‰3Rùz§ï@ù — •áŽç ¹!€¬ÇÉG.Ð2nÐôŒŽ;œ¶Ÿoœ¸gÊ–iÇ2ˆl(ò÷Gƒ±X’7Êg·®;Ž‡óe2ÿšêÞ’=)>në0H?[F$Àk$„ퟬfawÐ…¾ÜŸFžô`nd«-×ò‚þ×xjÙŠ…ž¶g5|iLç@öe+¡í ¡‰ûDöŠnû—abÜÙWº9xGå0xýrP-ØÁôËÀ;²îFOs:-±ò#!¨«œ[Ý{ŸÚ¾¢9˜º`qý¸Í©ìžH„$oÜB+ðlÕ€ÿ^7X}ÒVhöõ¾?]è£�¦3}¥È༼;òêÑ2^ãc­ö̽P=ß\z•¥~R¿ÝÀzwe}äò¥[/e¡‡ Ê€ïõÌÙ¬y–8¨'a¦d¾ï‚¶P,-ÉK0£�õó,[ß-7¼‰¾Þ$nqé4¤°oP@6'oºµ¢ƒj6æ=„ˆ0QY–ðáñ—ÉåÓÙÌ7:Ô† ÑàÑPzÐΡÇ!Kò àâ¾4.t™fÞd„öN;NT•MIß"#M·Òg5•©»º-"Ó¥öZ ‚#LºÞµ³S‰¨¼1€ˆú"±;.C"øLGXù~´ NX;[ýªÅIðh=Se]eÎ" ü¨OÚ~¡¥!œ|°÷ô†c�«ÛŒÈä×Â8|nÌ™$‘/—,ò$8ô5¬�h½¡âôm‡C‚û‚Ç®‡ 6¤vcÇ…_¬£°]Cïd\»tœNaÛíöz›?LCœðÇ\«,s Š OfV÷úYÑ–©Êb6Gùf³3ãé3G6Öu{´â«Ì÷Ã`h5L[Õé^ãáÒNBrQĘÀ?6åñU¢ÌY«¸±Û oìõ«ó`#ó ó7Š3WnŠ%mðÕc+$ãbÇÔ] q¡uû(mQV˜¹TLG+ËÑ_ŽÛñ¯ÞÊåzæîFþ 6RÛp«�¿‹öø4,=ª/w;»™!"!œî’ lk›ç:Q!#&Šð}ÿ…á]éYKžjqçéíáDE™“ iÍ¢‚¾gH¯Õâxq×À?¤Y5Ú-á¡CûJÿÖöBÇÖBÚ0@“ŠúLžùŽŒ@™Õ0ýÙØ#08ýŒ¶Àe žÿyµe´:LuÝ?{ü×Îò’–?{ÔpÂáÚ†dº÷…Gã»VZ(ÖÅï™rC²À–bÛMtwJŒô—Ðiè1=ù†oZÄ7¿ˆþ“û ¹*é–UƒŽy!ðÑ]úÎѵ¿J$žð<—d«9 âw…3ð‰1èo=¥®÷¤Q—æ$adY ˜wSEqŒáA m‘°’Ža˜WÃog¯ípvUžžk Üy]qW3±•©ãzš?pâñØnM•äüì@cÉå<�˜ ¦•ŽVá I/|M;ÏÒÞò)émìÏ)J(7CeW,ö~ôdœL$Ô”ðz^ÄW?Þ +l(S÷zÈ8uµg®pO7u²»Qv{ÛÕw\È®ºέ(5Ò>Ûº ²¹7õSÌñ²ŒZ?u•Ein^ÕŽièk¾Ò×ô™'—;Í°”g6¨$š·çùCyÎŽzÓù¬3bHBÉÛž0¿hºda|‹vGlÎqcø ¶1Xpõú BëƒÈ\ÑéÎwã«E”÷‘$͹† %ã—/óàÏÊðV5æZ³¡õ†‘âK2K2Q@v†Î‚¢]{JÜžžŸî³z ìÁ“¿`[¸šÑõ$È;««€–ð¾¦ÇhD×™©ÖŶ…ýí/uR%N2,ø¹ZÓ†Gk~ˆgÔ9j!çÎÛËø6_Úõ®ÿæGh•’Ê©z°§ÇOJ…MX×7ZS ¸¶Ýz*té =D%·- Š/=ÄŠ\JFªð‡EÙá×·+ªÒ…Ûka„ÛÞÕJ L&Zµw¨QeþH¬ÍÙUgF¢¡Ÿ(³òžˆìáK6» Œü©¥^ÒBÞˆ"³§ìs;JuwõO•b-¶#ñ±Q×�ï §× Ð,ô±ÙÕ0BÓ£×Ô­¹oa<m‡‘RŽ´þ2³&‚TfiĉéÔÖTÇžwƒ¡÷ƒFßMlD/”,ñ—ºúÑÓ?õÆ|••H>ßµ!JíùFkwìÚŸOú¬,&-¸,ª)DwZÒáIó÷2�;œ[y—ïÝ’$‹¹REë ýVÅò&˜r\† É cXääò­RxìcJ˜…¶¥xÎÛ…pØn4*D”*è!&èï¨Užï-zšÐõ¡÷<{-ä´ž(•ÚS¥õuÑ@*—$Ø\Ó¶!~FÞ$üØ g¡C`+MÖŒíMæ¯ËÁ+Î.‰Œ 6•0 H‡Hc©ý,OÌûþÀÀ'”f$å2tßyZš*Š Ý*¢ú‚Ûèè0öÝ—™˜X€Õôß7Ll"Y¨w€Ç»©7½­û›t47':Í Ëž.R¶°òÿýn2÷8®Læ¥éhÒqYN*  éîoS×Sü'ŠÏ ª· ¨„¤Å¸ùr}”} ͚ΥsãÉ Æ¾\<VÙs*ƒr3šŠ;i­,O™ö%´«! ³êõž±Ö-[ÍŒµÅËÍ$dЂë.Ó‡œØÃh ÿ¥ÑÅߪÒ÷ÙèN¢^‡®]s°ÈÔ¥XôÏió³,VCŸ³,:#ù¥“ž°vZs˜ˆ–%àÿ}‹ –”(ì¤Xò¤F^¡ìÅQv%,;lh'L½ç°y„Ä‚ †lýZb—/�™fdUZe´Hì;G£Epok}7¸Š|ËTFеôÌ“aòDLðØ\H;Û…²!16Fá~݃‘^ÆŽXÄ\Ø M¢Ï£Ó½jþŸZwD Ld¹½Fd:Œ¦Ÿûݯ}†ä÷˜w¥Ai¥Z#è Hà›èDà„Ht|n‰eÝEب„ ¨ÚµîÀœG¦lU÷ÚB¨bK¸Ö)ݳ! ²Í»g+nl§µké&ö]ý·{‚°Iã+ÇО%ªÚOÏC¼fôV »¼þYcŒFaò•ß8áªØWu6Ê'I¤ö>:�>àxÑ»¦}…¸Â9÷šrnõÐ×eÉéþ$?[0|èTš©”ŽmÆ“”Æ>EúíjOG•ö†­BïµØ™1 ŠEì/\['dȃì6CÝ‹Ú÷~†¦öžl8‘+aÀú—ŸIy%Iè áQÅ4Áꢪ߽bÓcªºë½ûÓC&¦ ‹™­sD?§ÿë8‚«ó¾=œ'É-™{hZ±tÅ)ÒªîÆ#vØÅ¿4˜z—ÇF†³=ÚHL}wáî™é… ç]5Î"JÜVb!­sK9cj­—8ŎΓMœšÉ@¨æFÚ…Ry*¼çÆc—ËnBµëƒÚKÝæI¹ÅŽ®—õqÇ™Üõ{†ìšnè+†8TJˆÆ˜¶L$µ¢GHüÙ­¤š3œZ´)´±~o³D‰QRÕÌ\*ªál0Ó‰ 9²ÐïØ"9ú Ô¦ù Âp²FÔÕv?5—˪Èñ$¬À@Y]l!U -!íïf¿w~·L£ÿ.#Ýœ% ¼›>Eéä¸_Ñ&,Ó,\:Úb,öµ2cÊšÍ÷Í•'Ü£™d‚ œ5·¤¨Èôï¸Q/ƒ*løé»É§¾á' —Y˜kÁ¨)élÍÁ4¬öÂ}&€3©D~5”ɼš2JŽ…_fKŠËý´šæ¾f!˜x)ÎWÔ2JGïte|5ßäÝñX=o•øýVÖ =×9×(‘ BsB/2ëñÐrø¶†x©{_‹O}XÄ“"7ðúÉqã >ŽbMnY&ÿ®ŸIAg’ekÐÚÛÒ׈OÍø+Û“,öp|¦È™\„†á)¨y  ÝÒ ÖÞöDþ¾ü^œNf™­ §6ðÏ:·¯g k+zµ¥Ç)l¥û"7¶[[ójžAµ•9eõ·‘Á—vÿb�ŸÞØÁA 1W¥Ã£ÞzÓkzD†©'ÂFò:—ßEåb¨@ùÊåÓ§¶ÿRóyœJÒ6…?ÍE_¾QjŽ#§;‹]s–ak ž´ÖßÛáíðÿþϦ†õ•¤Eß{… Ɔ-ñįô‡S»Äa¢Á)¿ä?¾Žl}ÕAZ^¹>&« mÎqöÎÿ²¥c'â;”5—… G[›™û­ŠÂ#Kñçž ^)Óëe¬/ÜŽ4øƒ €j©ŽOßâî¯Ghüâ˜ù^Ä·X¨Š†,Õ`°Ó†B “çúçNu-«™è F;±t0TKü¸¦ÍþœHK Òà´S½l€å߬ݔ€î³kŒGÝ?÷‡©Ûe:ý\ÓFB*mU&·‡½=Ì{may—sÍjov‹D©(“ú “z:ѺÑÓ¤J‡d·9wÃÔ¤Ã0ÔÅ~¢]ÅÎ SßÃWÊäug´…¤ŠŠ¢ÄòÅéy  ˜S䧓9!(—°€TÌ~8Û”î€ùáeããÈzL Ô‰’Œ¹¦[ôU{h–€>ž¬á¸¹áOo¼½%¢ý²š)"„VÖ3%ã<ªo*cùåp^$ौæÑí”R¬j¶K’–T›f6uhQÖ»À¬1U!õ~XÄ<Ï<Û0‡¨9Ô_?½ ­"ȯËDÒt=×ÈèàD‚†ˆb¸+ó Ò$ó¥ØÃ"ØP¨ÂÂÊy Ô‚Àü&‡á"ÐR‰Šƒ|4ˆãÄ—µ …!” šÊ�'„Ïe¦FßrEµ˜©„ Ÿ[•öÞ<-´ÌIþ‚MìIÿg’“¥<Y‰ìÈÞMÿ“¤,J=û‚Š-ΘþpÔc‘Ž.ÖââØ<!ýMx­Ù^âA„¨dTÚ¶ h¤Ú¢ª¥[2{X<f^kŠv&{ò.‘fçT;d!Ý+º_iÝZGWTdõ䔧^óë°nžjáÞw9}ØÆúãaŠJUgðÚÀ_ê^ø2Æž}‹–zÅ7òÅÂ÷U�>Ô³PÝ'e¸�kI&÷£MG|eÈiÜèë/ô—L®Ã–ñ³†dF™?£ÛÓ ´ãº7TãÓ»écæëžå$5š³m×ßÓž…ížœ‰Aø GÊwJî½GfDÏÌÃXÖ&Í£×ð?yâ˜É@f= 2«ål-Î-úÙ>YÊ®Ðjk.¼ ëöt­ºœW™Ç‰b‰8(ÝYE¦°’nP²ðýaò£s’¨Y6ÛqSºM¯ {ÑxÎô”¦¾av(@ðÒL¬Ø‹XæG‡ÁØÓŸüs75w}þLXªßÜ¡‡JÜîL:û-h4öe1©.(Ð�¢káåŠ)V{‚z­÷H0ÇÉqxêÿ9å9®òŒM Ïs½Sˤµ€û¸l‘@Š-ÎÆà‹­Vd,ÆVë< Ò­¶™b4œ·âD/M=̢ͿXîJæ!NtïÿÖ,Œ®È>Æq©¬º"6nCçÄ<„Ûœ^Ú÷$L¼ápźw »£…ˆš±ýÄÂS»‘jˆ·ÓoTDž)‹Xí´Ð˜é¤Ä<¦u],XíVRéU´&¶Ý­kóÜŸÂQë{ 7q}vÕ²‡Lµ¥´ÿt'%ò>‹p¦VfE¬g¨`®½aËO;±ßŸ~…¡‡ h¡4«€uázÇþ’B¡¡"ü¼DvÃn¬µÐ`Û†n÷üÒÜc§p�þì�/&·AخŠ¸u î@nfÿ3kö´Xè#äbÔM_^:a(zdÒéôH±zŠà.c)N¡©Â/qàÖO ,ŒèV?dAõõî)#ì»Þt2Ó^ÛÉ÷‹Òp•ç•Ê1°¥¥MÚvLØӔǺÜdÃ|ƒ;D}^£œ”‘™!)NïÔÀ&|Òšù-Ì{•AµŠØ/IcKÃ]ß?ŠD9™7vš‹væ±›¬&¢dþN™Y¼VÁ®6˜A›+%I\º3F‹>ê\ƒi zçP­(_f̯)ÿÚnm^˜£]–l=ë“Àóî¡·¢™ÿú³ôžg+ó 5Óɯɼ,}ûšÇûzS»‚Õ~ªî#3Ž}§YÅφ8*H‘…†öh¬ÿz<6Le­]Ž÷¿¾yÿÏxPT ¶0´`mVUt„!pÖœt‰ ¤Ã,¸¡iŽÊ-²ÎÎJP@ÕœìËíh?õ5#¨N´¡~ÅŽ¯÷Ab;:s¤Ž·æàHÊ[¥ûßWåˆ|ÂsZ)»HƒxÖ-TH�©£f7°—¤¾þ,¿H|}>Î#´B·Ÿž¸;ú�šše„Œé=ôÿ¶b¬j/Žnt%q? t4µÐÍõýÔìúγd1m&mÕ>ÿñNÛÒ:1Ä,”Hé0ô¢^ÅT¡2´‰[ª%ÜŠ—˜ï€üHÄKØ‹õØ{gÙ~µ: Cç‘@dïÝœ¯êha÷&]¨y€ÀÁû_¯3Â@ÍŽ‚ÁdUšù”ô8‚'åânM7¢ÕV4y{ʨ¾ÙÚ¹KÁ¸ÿÍ«ÀÔ»–å òñ»ÿ¤Æ^ò X™q€æ·SíK3 ¶Þó$o$|wÆ•@7N ‚¹Æî9±MéÞEÁv¤À1h™OÛB°Ö.}}8[:’œ%’™¬ÝÌÜH%¹#P¤\Ⲏ˜5©ÜÖã~û“JJ w_ô1Õb¿Si±ØÃð•Â@Š©š³@–¨Ä †116©¥­,æEOFy±ïe“â&ñY:hÁ"2“gfc¿*yh½XíïÙ}åAy<{GŒLËc®GѶ1j¤÷ˆ ‘ïéÁbTSžñpñ„œõ‡é ˜ÎÝ꣄¼tlh¯n¢¤È|#$Œdj€z]0éšnC7`8œe6à njÙ¼­m¡ù½Ø4ó»NPÕhh£µ£gò׌„VrÓj¥5ÛËТ%u­E”»“M&±6"J¬—较LSðЋôÔQ,øžüt…kó]¨XNm®é¦Wã_7h£­ÎûBZq,�ÔŽEE¼Øv÷ædÞø æVk:Â^ñ¤ N­ñiT–nön½~øj„wLï2eµH f6ÔçšîLív?s ûãá‘¿iQƒb'¬.*÷ÀGMghÑ%š�‘$}>Kë_cÍ#ÏÙE°†‰•q¡BýƃØaÍÚbO ž˜=¿òít¤Ñ ;ø}°E�Å¡ê &ìacÇY#òS¦-pjÒ œ´G n7×eÁnë ¬ãäßg8Å0ó¬x˜jÜCÍ6ÒæySÕc:]ÎT¤Î‡ýp<÷ý¶ëwþS׶öÕ@%šG,²7 Ѽ[BbÞ -<Ï“Gÿ0»ç•k–¶2C`™å¥t?r*Áj¯¶èw=¬/šC­Þ¥b"/$™þ®’ˆZ‘Q¨Äy£¼L©æMAĬߒXü,P3ÁRꤗÐU¾Ä€`ürVé×ïn¾×Ÿ¾xÊ$þwªÍoù}iþ¼X@µª ‡×s¿Q\KQymÆ=’öùh^ô.# ¶2{Ú•Œ0þpò¯ÚH‡‹H­›»×r{Ò`7­ ͇þ7rÒÝøN<¥ xBѱpZ{0–þ²êÔþà̲QÌDÔ‹;¢e•glÁb_}R&£S¼¨¸e8âôï¸]ùP1)2ß+&D,²ZK”f¼ o´ &ÊU¸ÀÍ0ç9�o¤¿~Þ8 3Ÿ@ÍŸqoßM¨„ØÔøZ'°úª¹c¸ÈŽ©Li{ºÍ“'v/y…¹/”"ëÄâÛKºñ©‰´‰š� P_ û#5‰÷¡Ç´ºý‘6¥ô$X÷1ÓÊk 6]h_w¡À² Dc°.eÝ‘Îù— ñT·ýèÜ¡èTeBF(¬6« Ö®{qC95~Å8ˆB'Ë!Fãs–nôÄ?¸ígvŒµŽzÍOªrtûˆéö-ÔÅûìÉ”°­nc×É´y ¼óŽØôíï—î+ض)wLPz6bT+P ¦>º?ë™TeæqeT@)¿«Êc*$ä¯&u'ó"YÓ£NaéY¤GœUæôãûBæ“pQÍRIÃ~’öwyS§û/�W†m$°¥ ²¶-<”ÉÒEÇÉÄ­.üÐ\X´Ï¨îñQõ ‡²Y%ûçE.£ rJ1ÓnÄwњц÷à]Þ ›©ßøaò±Gål0ðöâ>b@~8ÖÐK0²Ò¢X0Ö¬iêN¨¤òaETs8ž.3ræ´ÆPÖÐ<l8þ>0G±ÃW–<J>`àÿ®ø~¸ ÒrÛ9ãñ]n÷/ºL�Y»R2—Ħêí¼N(²t®þZB%©32gI‹º‰öbðñ‚ýÍ-<ƒ’}E'¼PÞƒ–PGJ3ò£b”@Ƈ!}té*w§/á5I%¬¯‹»]º5"ÉÒp„™ëiëí Úþ>  ŠŽïóôdjE•oN‚C‰2tÀp‹é[9¨@¤çBEjÛê,LÅLH9Ñä£�ÆÃAý ^(_â°ôåG@º©“"·êxº¯»A3æž®×ëÃD1i€fÝ‘=ý½ƒÞ]þ„4óX“pßÓ °‰E,Úƒ8Üt`¦/Xû—×Í;‚î^LGDÌfÔ¶ q…yßë´=ŽÄE$÷;4êVMK:éG¿Í=îVöÜü�é¹¥‡s6P‚šQÅ`o ÜB>Oô¡§b†¾^ïˆt©ª!‡KdŸµÊvÐár”~•Û]›NÃ…wÝÐæܹR lð¯5³Ê0$õ”yñN[Baã6°.hOöIrä¤N¿ó¾¼#è‘xèÍ.¼PŠr¼zn+:KøäøÞƒ7«–$¯L¤^¢­µ¸“„­¡u¾VáÎWd^¢0]¤³e°ÿ ±¸|z¡ãLÁ Í ŽŒÀ×ýWçeéäòrø¢…Ö;+B¢†âÇœX¶›H§ÈÀ�ÞAܳÔó[c»Òd>žG’håûd21( âK]inr¢‘é®nÞ<úOy‰AqéHíÔ}qJª¤ z¼ Ôýä�·ŽQQú“jèe -ÖZ‚]"ï|qäæ€Þqø …ú¾o^¸µˆ1X_JZî­©„à'Èx� I¾0¡•Ç€››_¬/}ÛÝèÞg^=N¥¡š<²¶Ä9Ca»ËàäO_£Q-éðtfð*šxD“n®û]7í†9„J=F0u¢aNvPZrsbskS÷~ß+Ê6Dt#ÙÂN<"ñ]­w-tÀÿ7°Æ$q.!÷Gê8(çFAGÿÉÏÓAXÖ*z€Ü‚ûåë$"B3_­a¹Þ½æiG·.„Z2=ì›FÊLŒ˜§A9Üq̃ðx2+´b"ñŸn²}ï'É•e ªšõ”åæ]gÑ€¹5õÆŠŠ¿ˆ‰t³ÕÂÌÏ÷=ÁaòbdsšÌ¸Kšsƒ œÝÅSÍÌ%€—HF©‘=0"–e–ÿ¹TOv6uïêNdþé/{$ºõÚË¥gøÍiضŜxëùØ9šÂ{üÖÈ‹}O€’88ÿ‰üŒ)Aðÿ£P™ø ØWèLMµ¨\0¡¬†,’Ka`«x(àEwûnºïò÷šjåɈh1_-¡ºöP$«„*³Qaºé"'£‚ÙÌÀóÐÔkâ‰È&,"|mlõù1þ-ÛSÜØž6´d'ÖøÒöjÃB mC‹ê]ë¯z¼¨œy’ªäû¸;zê?ªíòTå¥ } î}£ÄhJ³15eâèx÷ÍÅ#ÔLÝzΥ׎L\WŒç± Ê“uU¡í7w{ozߎ‡4LÜÕc|@’.ŽÈ”þxÍÖ{ä¢ÞŸllìpíëµ±[™yK5‚ª>á»’68À®÷Ä pÎöݦ=“¥Îßù%ì_aÍãЩJØ7ˆëÖZ>"é7ƒ1SK|o©àÔ*#2±ÿ¨‚x­~ôø"¤&C§º­ô�é|ÄËp?BøÆaá6I*~ÎP{i´ž­ 6Må–3îêr<IyÕÃ2Ž ÄzªÓ4ÈNïFcÚ˜»âx0ÇΟ56ÂÑe:õ/èxFiê‚ +†nÛ"ÈÆiÄ1Çt«üwÒ¼=úöå~tîèÒìaÈi ƒ™øN¢ d2Ñ:b­5£¤¯Ë>EꋶBŸl¤Ïnzqô'øœ0èd]J`…0 ãÙmm!¤ØEµæMb›©òc\‘ç”óŠÇzæ“`¸Íf椭=ôüžXžèê�ä·Õa¿Ç‚ù¶•¨àV(ÞRŽŸ²µÎŠ°m²Àë׎ ÒËA  ¨Rîs…ÆÒl0H뇋¨ì9Ìœݨ€¤rlIãÚÆMí7úö¯Ãbß©„Q°«? èGÖ0'UO(+‹W«íÇt¬ÕôÚ&4Rä_”˜HÖLôV.o®ø(¦£¾ÝM&xᬌ�üK ­uq•4 òÑeoôl.ÝÁÀ½àýð[xÂUFu€¥f”Núê¥û‘ÆL9¬®°ìÌV"%ÇÞI¬¶( 9V>S·OüSºo0ø©ÿº¹L«™a³“þ»qØP£'íž±t6¥zóÎ&=ð‚€ðˆ‰¢´u„@ú»ç˜%–?ˆ¥4´C$ã9šÒ'Gþ1%"²ÚK1‡>æ+Z¢Ÿ.ÉåÏ(H¡KÊØK ²hÄD‡š6“N�rfa|·ÚþLÒ&ŠJ×Xb«Íé½¥ÞjX`æ24”°ñ�ýÊÕ\ý˽ËHÜÜÜLº Úžjöcë–¼êJj±»+û õÃÙ<qØñ@œ™Ñ‚iÚ4(ÞßÝhh5Ögn5ÚÙâ÷Jô‘’ªãØ8PC0>?~z³8ªÊÝX…qdlLÿ­`|œ† ®WÐ{9{˜MÀöDzŸþ,±la›]lNPh¨ý6£7/Ñ¿@éÍ ÈUÿÂx,9ãŸzU˜-=/ÎImבjÎ=EõîÞª{‰tw ‡ªiÍ>Z¯W,}aûÒ?ÀrW±/HÀ<yÊâ£vŽÑ 'j0Ÿ¶fÐPó*ƒÚÈAY<4Ž©1AÖJŽ’ŒyZ:?lj/{Gñ¼«Ÿ¨LãÌo³ŸÁ`W¥©›HÌ…J­_•Â–Nc„k/õj)W+H¸Ym"Ú~ySÄ>½ 2‘d alH¨’:êøs[ Ì”?Cb?v½˜‘kŸÓã]*«'­2ï˜0s¦§ñ72 ¯¨ÈÚ["ý'Žo9D&«LN TÚ­g!32b§SǾ'•Y\ør;˜<(™±~E¥Týt¬Nì¾3q2ñüV$ž\€@þ‡¡âÏ£jåUÜE™Èç5nò¢mþƒÎºuë M#vß¡—¿ö`F _”'žçVTt˜Ê ¨4þÒ<=×ÃD°ç4ÌViQ »Ol§â¨¨ªÈz€ ÷9TA´Ñ4eŽ­ßbe>—©™,øÖçæÇÐ0-“™–ý‘¼¢Óš»2z*¥_@`×þ4c ýÈðÒÖ÷FóŸª!κ~¯X²*vwåù¹í)ñäð%¨uTQ¼ÇyB­¦ë%Ä©í,%Æ´îµðâ*ô%3JJ¾¬ŒkÆ‚N<â8É>¢c‚ÍkúS©3‹¿s0ÅÓjôeÀ=sä´]àoY¼‘¯@Å%ë í°êýÝ)R ™¾2ïØñ­ìŒÞì0\h‘y®@VA:âüT=:Û/m§p:Ž«_ÿÞ¡3¶Mj!bÁ‚aþ¥¥ÆÜAÇn÷ß· ±fÓ[@ÓÐ ;¶0Áוô­ÐÊÌ'L±.+=ÈZ3RÛ辀û ¥ebÊÑò-kWûó_ùÌ~îø˜‹ ¬'—“lv›Íô¶0o¤Ú~kw¬ M?ƒ±¥Pô‘Ä"8|QY5ÿUK„˜A0#Ô¯¯pËDXV¼/ë²”xI=ÈH6z˶úè§#˜£ÂKììå^’õHœ®Èü,ðd¦ƒuNÄì%S1K·ø5ƨ[Ã:šk�ÉíÌ©3°báênØëé•SS'[8Ä7tôªqpÀ¶tÀkG 3¿àä–CZýÇçÐórA[9°VÌO6­ÍT�¿ÛÂLöà’P7,ÎÌÜ•"ƒÊ“«H²¤A<T4WôEø7/†<mÕ®YÉŽöùQiÈÒ8°~u<þCÒ!Ãsˆ`²hµ=“Àiü‘î&¹©Ô›lWµC&Gû|‰½U²-@s¨j1Ÿæ¯»àŽû1õ{ú€ïñä•^>.,Ø^ ÆŽÜøî#ÍB_˜’jðc—¤AÒ꾂ú°‚"Q°Ö̾ޠ›9ðhíÿýŸé­¿ Ë ؈¾Å->ÀYÙ0ò€B^K!/kg•H;­Qªþ¥fŸätbø6v›Ýt?ž{æ)œ¹œ rÕ‰-Ê”m Y¾ù[W~%¡ÝCqJƒãHÁâ0lœp>¾Aa•—¢¯Íi'îpçÁÊöTÕñÝ›¥›2E,ÿ+ò`š'R†©lÊj›é»Ë°M]™ ˜½¤YÒv²œiø¤Iè ÜÎ(¯{O}Ö’J¹åikðYcÒB½à5H  §¡ž,bmáóð㶞xñt5Ä…ƒµ¬V$¢wØÂÐUݎλœ$é1JRÖa-ŽM&?wܲ¼ÞÈ…‡{b–Íñ�Žãqëñ¬û±ÖO\#rO]–Û±p¦wvŒðÕ¤zcî|yÿŸ%è¹÷Lþe£ÊuÏ0{IqW‡zµ5ÆÂ<³f•ß{TFq‘ùÊë´&)Tí¬šCl}ÜùÔDä’«­ªæQBFËB鸖@"¾î±áªjl¡Ç‡iÀFMÚ°ÛñDÚ¸]þž³ž&ØÌ@¹qjÆŠMEPÐ=o/¦ôRoÀëúúxlYF™§Ž=í1ë@ŒþÖ½“¼¦Ë³â;¯Wî2¬EÀîZ+YètUA‰7êv9 ³O0K:OÖ¤’Á]ë¹óž[¡¨Þ¡lAô]æØ#3B�îP8u±i>¡Ûí™ãy—º2â…¤ }Ë-€Êñ»fIkhœÖ»¥fhäéÓY‰Š[ϼïEí2%7ç&4]\Q5³U9©ãüa-¹­8±Üûé¡é …ç£Ç„w(è· ì› Ôu0í‹aä¼^•Ï/ÃÌ€ÑwY+>e#;‡s™†]‰óVמ¹º¯cl;Ø‘\�û\Y_æظ: [úm‚Q¼ˆz¶žZajt¦VÆІƒÖ©`U™@ó@0¶H–0ÊÊl 9)´éG~V€ÖÓ“·è_“–§ òå¨ö¢¥p‡!À],”,èîdþÈ ¨ÊS+%õ2!ÔvÏi»7Áèž2Na87#w´úìÇëQÑm·‚b ÓÉuïnR·ô¼Iâ›Èw^]0q+ô¬*¡5RÈÙÌžŸV¦–Рŕ6?V¾¼ª]zc+ö`ê[¯Á¹¦[kSJÉš‹iº™ÿðÐÐ1÷Ø…ŽušU¢àÉ5=V粕9SwúÃAPMËŸîÙ;¤`¹âG‰–umHl†×SÂKïôß7ŠXÖ( ŠÆXÏÎwè[A_=k#±°O鬣BñË–¡4›Æ¿L6½}ÁçBƒ¼ýk°ËòÍ€‹fÚ¨kµá"‘¬x0ß<ö¥Ðª« @"R 8D¢ßƳz$²ø‰±YÒP.«®Üˆ¾W {‰ ÅQä Ò*67¢cPÒFzkÚQ»Éh¶þª** ” ®$x˜“YÛýuƒGäº÷¸*9ÇŽ@ÊXïiL‚dÚ8õœ¦lófåt^‹©qì(»Âõ�Ç3=n<Åö~Ïgµn‘°<‹ðÊ=aÓ£³hƒS¯`±o€9é\¾Êpp&Ë™™mç‚œÕFÏ ùí²gÕ0Pì\yÇ‹%ö ÕzÜ ã#O®¯/ÇÝ,å­9z‘.©¾×À̲…v ›2Ãœ´•N ‚²ÖÚ2×õ"—à;D<Á%Q z:ú8üø6­Íq+è¹ù¶©>O¿ñtˆ=Þ6º)˜_Q€ ?×^OnèúÉÅŽïÙ{¾O%ÚBãH:MŽþà vO'…´^ù/Ôè4 ”ð9VÔCûfÙ-r׉`ŒçôQióîëJªF±©g˜QÑÚwâ� ò}½ñ¥ªDwÐ,ÈGÝvq\Ù]²qþÆûuÿ¶ ·Üý%ž6 –ðö³™N+å‡yspîC0hFªºL&(X˜cGs0(€›d#*K1òrÌhÆ ]O¯FA¶€Ú )´¡¾y5îðÖÁCŸºòºóæÂûšNý‹‡Ræy:'óãi�y•–Q/m¢Þ°53%&—f2³ú“ÐqÚªÄ`îG O¦Òcöô5°ê!ЪLsG0ƒ£çpÔ$ >†T¤=¢Ÿ•õYé3,ÑC¡ã³´ó[$®ûS4õq›X0b‡Vî‡JŸw@É¿÷שò±„M©©ÀÙk­ +ã°hW1jÏÔ÷c׶0Ás7 ç oUà5£sPžŽ¶wbqþ­!r¯gš‰czGp«ºÎ`mæ{A…:$qPZ0*=^‚ÅÄ+Òh~lÆ[ý‚J¯ü(5#‚þTÑZ+ü- ¹Z æt*ïiÛ¹ô¯3ʤÍéï_ôL²Ó«Ôï-PX§ƒ¿QIö%›=\úÚóG9óVxSòËÜ?L=ì]Þáæ [ ‘ê‡ÚaŸj5E0+âŠÃóD±?. $2[}õ‡N'žD’è�·“ƒéÔ“?8(ì0øÈê+s –µýLy²íŽl¶> é¡Sgš/D”Ýšoô¬cßï}MÙAmL¾ã¶ºf#'5”+­àÞ—ž4{‚£ÃêD§×À›º,’E»íC«Þ{ú› ^+oLAÛ³E0~°bMS[HÜñ9Í7 +w#b™©S©U}^Tz8L Y›"¸‹Ò–jè4_BD¡¯ÜF7æðEË%ï]føq]? þÞƒÒËOE‹|á-|Êòz­<ô+ƒeX](tí7´²Ègò!ŠÄK¯hFO»I¶Ó“”Ôå6«ßšéE±ïq…•²Íi¥8“ÁÒŒÜ8Mìwp`|¤mo^´…#÷›Q\ õyø_\og¢«-Eš¼Õ: LËÍ®§Q•¾£³U…OHÚ°ŽÕøåuIÁgê­é­œoô™úYUî_>àE»*0ŠÏŠBƒJfÕ�r› Rzü+º“3ˆ!fJ1À6Ããe·:n{:�¾t~ˆ(,åM½VÂ&àUŽ�ïJ[U¶`g%Áö×€^“ݸ¨Åþ`t"œÅت?hn&Ž´!‹s53DÑcí­´ÍWî´’3ðÍ!ËèqÅ*@é¹Ì0J(]eÀd3jæu©ƒåOwìb/+dIÓÕÈšùâ=c·é€‚1vÃT›­žuŒÊÈÁj !ÃAUŸœ–�¸+ÝLx•|ŽÆL6]ªì<µn¹oeY¦þ’k/DàŒ'DQz0ñ%XrÕ­ ‚fþâöpàÜ–"%ŠM`Ŭ¾¿7ÙVÊÊí „ Ù"ž’Ĺó)кî;8szréÐôÒ—ÇÒ…vhh¾y0ŸévµÓøhvtsY¾ÀÐùTq-gÔ«hÎZ$Àá$~3öâNQž¸®8pupË­ï­;fÓ°Šà<½~12¢†æ5Ù®lxÃóz‰á¥£‹¨2mÎÅ^Ñ|9 rcÐjTÿh‡�¬½æ"eÚ7FMa0Ð3H{Eü•J l¨ØÞý5ÓD‹EÒ¤ºÞcâyÉå´lOÖvtsâÓÑEá%Sm`Wp({Éö4öÜ`Y®jÙ¤ÕLÄ1×3'CE¢vcËuûKËÖAlLŠ`šò ²N l®kzÿÁõ.2ÿt‡•Ì œžÿ‚Ú˜ËWTÎȹ(Á�™ÀY¥ô±þ¢;Ý·&+»ÉŸ²"ó8HŸzZ0e·õŒÈ:ÚäÑõ0ì`]Ÿh׳ýé° õe›r¿UÊ(¸âYÇû‰ð>¸Ñ¤åì¢é³8ï,wÎ(¹G⽞½+~ì½¾X1ÁÜÎäÐr¨7'C'¦»kÒê Ø“8\p\rèêÓiÔ 5=p;ãGenƒ¤wùX_?Í\®Æ¶yLÀí/^ÓRºSý¤8¯kþ-V‹ŒÏ¸£nÀÆæ˜,=ôfƶj8&³0¥Bbè ƒ€Ÿž0¥qÚ¬%“Ê ³^ò¬*s`õ‹3Ë­¯M;ç™í©“îEÐóh¾´“':¼¯ÊVÿZk7J¼n7»•5yƒn$ œH–*'ì;K~°¦†èpå°:¬4°ú*²U–ðº˜6Ùóèûú’ÒÕÊ6‘8çé`´²Ö¾?U5Ÿ'èqm¹ºŸ UÅG¨w¬Ú£l-äÿ¢gø™]k¶Þ˜\8”KÈ<Õ+ßgë¾H™áæDUsŒYô÷§ é¤Kã›tO(÷Z,´UÉm/á1ï³Lœ+kW09‰ü_Ìãæ-Toµ}DG7¶Ðòå>ª1 ýy0}Îsê-òTš`3Z¼?!ʼn(Ò²9¥¹WÕDfƒ:Èö…ÞG2Ã%À§rŠpÌiÙíüüôèEm×�˜·›:¹db+¦"¦ÕF{Íu¯¾:—Ê ¯UüØ*0Õ½è\ ¯@”3C ˜DQ¼RÏ ¾žÍÔâ8^€ç�!M :™4=b‚Ä9i]s9t«Yúºëµ »ÕÇÕ8÷¬1Ù až² ¬‚7ÅÚºu[R8©t$qzýúO^µ'‰#ÄÂ!ç˜6gSÕ¯.tÃ5Kåy…î¹[T4ØúÞ*:>´öŽþ“ÑÂ,‡¦^Î S È PÚ8ñ š?c!3Ø­3ŽHîõÊ{.òŒ-YÝ+tÜS<+9 •zf«ñx2² ßË+”E¶T¢ó‰bKÝ{¦ß«qw<ÚáDZ£” o8ø—÷ °¢(«¦ÚÈ¿›h™ë-¯%×Öf”ßu6ó’wYH@²ôý´,È€ ¡`ð†;cÞÒ—"‹æŠúc×™…g;]õÿ\Qz]Yå°‚‹ø=�¯=o¨–c…Æó‹"8q¦¢L"ßMQá KñÖã–sѧÎMön ƒ<íwl¹>õwiµ ʉd¹°æ@íÍ1Z5ÌsáHd»«;µGéI˜2cuu€Ïy¢òÝ7~0•=õ¸èw9Iɹ"ûò¬#}§ÍÖWTGÖÙõí‹ÊZP>LGU…ÄPçÉhìå^½ ˜¾—(zM#°…§/gõ¹,̵Чü’Væõ&L½³)}^)MèÄ6®áT{¨U“ œ¯ÚìÙ'è*%/‡œ6f­g 3xLü¡¥mLðÐpåN¾;´¸Ê¹æÉÒ0s¨Qöz£d2}¯ÍŠ<_>:æ×y`>ûKÓÌýe•L'LMÂÖÓÇc$ª<II‘¦C¿cüËíÅMšê/}Î>(U¢4¡¾Ì¢5”]‹Ì0až¡6·I•n<›,kLøå¹ÔÜÉúì%ðAô={^*µ}éÖe÷¡~òR›#ú5£mjÿØlÈzp…¹!‚®ŠïGohXStôíz¶àé•so =cú¸{ÐYæOW%£ñ@ÇÝÅtR~‰ŽþST™OvÚϘÖR€@”ƒæÎiü 7*v“‘|‚– rn½aÈzð:‘ú[tžz ïòÓÌ·Š™¤]žŒªa0u¿§<ĨX’•µIàW™a][mTög»o{4J3ú©kej]PDl*â œÝÙ Iùf,øÁ®N­ôÝ^jù6 ñÞÀ3š7®¼Y»šµý;5 /“ƪl$ÌÊooMæ⦱U9H?bg¸ ,n§+“:ÎôyÈh>+zóÓ}™gž›æ,MIwF5ÚSÆ–uüÒÅ^¦;ZF˜¯ Ž­ZG•{çU=eõ¨ulj€ÞÚ3J0ߊ`8ŸH/ÎêX ÉQ¬@Ì!Á1:½.öË]#»ë×…úQê+ðS@¡OMapç kyºÑ†ö/¹N‘ãb&#R§tÜx©“/ûKÁp^YærÓéÚ»úÑhèÚ,›>}?ÛÓÔ_Äžc4¾Ð§±g‡ìR–›¡\Mkç½ç\ïµ~§‹ÝfWŸžIc&ËPÀLdÍ_ïðØœÐñã~ž‰Ky¥×Ô–J~%þ»(AòF·){q<AÆ\k}åþŠˆ€Ïæaˆ SE¸9y}çó³ í•sEÇ•ëÙÂÞ­˜ˆs!õhc4‡53ó72#ÙŽ­5· ( €€¦yY\NÝ&Q‰'¨Å¼Q*Bä>p&šô¹ëcî;’Ì€±r”È2áGE$“Iwï |q†*åž®È<¼%u8bÓV¨L×Ë3Œ•§eQ˜ù2Z«÷f4–I±©3š°™]-›E·cg­g_TÜŒ²Ø·« ²¢.ƒä²5*84O0i·(ÍË5ÈÌ/ Œ£™!–`ö(¥ü<§ÿ¾aZnp‰Öª¢fÔݤ1b ÏÉMn$â�CãQ0°W(‘æ9 .߉Äá•Py3ÐSχ“»óS}é|¸Åñ ¥ß6]œ{‚/œä¢ùS4k·lrºšOh•š*î'-Ÿ(N\#OT†œÉ®¬îÀêë™’I<;K©ê´ðF•”>; ­)¤å.œD|PPòwœ‚³EGÁŽç2Ÿšö@ Ü!Z''6õõQágCš¬4J¹É÷¾ÿš,N07øú'fµá¹,Ÿ´2:Ÿ¢¿ÉÙ¶Òÿx£d¢¥”ˆ¡i‹×âÛº O>)5r~SËPÞ�뫸’‰¥“]‰=Ì#ϬJDÖ ÏÚ|ÌÄŠóüæÞº”¯yy"ƒYƾ³ –öïý~ñR"ÉM7ݨmD97M½Ë;-) ö{ÛMG¼3]Vµ'³ùª`n•9'Â\°¶ePµïÚº4+?5céŸÇ?'8˜yŒî+¡ÔµÓ¾GQhÏo©1C_ÚPD¯.}ú©ï Sp©ù‡ç Gºrw‡ñâD>N­äÆæB Í]»PN¼‘5®ê‘A$êì>eÙGº¡}ïëp|LôÇÇ ÄßwiÙ$- ¬çµF=÷M²…`pB‘¹ Âãäq’”íöæRU -Z{q¯WëήҰ?f°{çgS#áOh ¿3ÎÍüüY^ÎÙ; '~óζŽƒÜâ8Vp)€R™ë�Ñî?L~ËãÖüÚ<²îS¹1‚œ{aä¡’JûD¶øÚ2 p`Qôÿrz®GeæM K½MmCLžÝÑV&æ³?µÏ‹ã8óÔùè¦æµiÑ`à NÓ¶yþñKéMšø¼ I—C {gA�”ˆíØ N£ôCžlgÜ­¤±÷+zu/”Y„òŒ2ˆNŸ8ˆróÜ)`�'­JÎtýÐÍÃ#5©2_ &4dšb>ÙÅeå)þû–d…ü’ÎÚcwz¦±ž" ìi»,HÞ7¨óHw¤sh˜c=V­‹½Æ�]¨“æAì ªÄ¡ u‰9•Ö£‘TD–ÐŒŠù•R©•‰H(¸%AùÕxF ‡iªB_¼í…k[Ý91™Ïþ]Õšbr<¿ý¥´‘ks¨Å½L³·Î‚¶ý8¡xŒ×*°Äí4Ó¦£ý·ûÛMö•½çEkªL„ GÀƒÌ@Ë™ø­âçéÏ4wá0Cq=nèlɺ“«Úq�ÈÌ‚,XìvÁâCÓî\ùúH¬2NÑv{¤Œaøtž‚´Ä…Nfßõoôٻ!Þ Ô}U!&È­/ U¹Ú€(7ó{´šùÎkWý*Ýå© Ò­êº¯!)+ÖÓ8’Äý†k؈9…Œˆ”%È lÚ¹”#¯G­=¸­3t—é„̬w[…í¥V÷둥˛C? ÖßÊnÁHŸ(5Ý=ãÌYc†Î.ÞÍ´´ñ¡ ,ðNZûZ¸/J;nEL¤Ûßõæ[fRa1 –§-bþ´áÿ}ÿ߶ÉUçðÑç_ïÖ®±n/>~“Ó§ð4íä˜ö0¼'My! ¤´’λãÈ;vf]çAtÔs)N].fªPQA€£ÆS½¡4q§lp¼9Qèˆß­±hTêy…ö»P¯\ÕFØÞ$O¶‰«6§ ŒÇ€«=Z >‹þ‰î®¶0ŠšeC¿Ÿøþìkfx(¼1¶ÄvÉ*ð+èÚjϹþìzê¥û|®U½M‘Ðs ¹Ë²Ì=혜÷ÇG¤ï“cY.”VÐb¼xÜÊoX–UèA>xª>œ©ö8 †ÃÎððÙÞ~#盲ˆ5 ~À8‹þ“'N$$ÃãžFJX· ?g†º„šˆòSç¿Ä©8 H™‰…½õ‹ƒ”˜iâÝ%¢•Ê¼½°]©!Qæbw¤�\lµÞô”oP1r1ÿy‚ꈘ†Ö3kÌÛn6Ý-ÖÇÍ–Yt"Ìö2Ì1 ;ÜܱûÁ4À±iEQ*¦ì‡tžÀšJáy··^tÐnYä§ÇŠ,¥g@  ’ˆ(U[­2qüK•I'ÁŸØ€zE·ã[õ$ÓƒÐ)@ýWðö:ë_Ås‡&3ø¢eb¯ž Â:ëEÆèC¯Žæb­þ[RBõ[à%c}½¿×,¬:›!³a1•²‰µ=ÅÛ›ƒÌ¤ÖûzîÑÞÑWwj¾¡ >]é8—¹ÏÇ¢Œx¢´ »X=!üÓ7v‚^êv´ÙZ×|nZÂ~F­/$ö%J¬™p<k’½™Žá–ʳæJb+ ÊLfè<"¯ž²ê‚ãOq­Âé]9`Râ¡yÏr¦Ù¬.*DÌ…m±õæ¿íVªn_˜]Ó"ôwžCØ}[âäºI䫨ÑQÅõõY-¿` ÂŽ7>~±‰½†Þa ÷/ßj®eô±å”Ú'ÁÿÞk§—Þ(‡™Üp,L?Õµ$f³cº»~.óÓ¤t\/µ5ÈSÖaz5Ó"zÌbþ§T® wm4òØA*Lˈ¶c:ŒÎGÃ;Òôž¬{¶¸¿³fžú>OµÎkº/žCË‚T&•t(É{W7~ØQ¸ÓÄþ3ìÿŒæ‰²bJ!jU#Á÷„r´­™]Ý¿uOxì Y¹3{€,?­I33ÑôÙ’š¥ÁqËÐGO,éÕ¢£òp„LÚgß‘dý§‘Õ†T¢Ÿ1'ÿôñ.¶ŸjÊ¢'eã²­3þ^ C¥5iá`ÇÃù2™¡Uè TŽŽ«uI§È¨e5àÖm·yÛMõZÀqûº›.«3ÆŠ`®l]ûÈj…2³{éœMƒªuî¯�B²f²§ˆÈ«d3×—WÇm‘f¡çýÇ®¢ö쀜´1¶4h0ŒEf‘Ý8v¤SŸŠnôù—ä*âÐœçÖïºwC²îkU÷»æ4 »„.Ù‹g }Ž†_N·¦.©¨¼½×8ušÌé¤{àÁÆ„5|ú^¸¯Ê(¥N(eýë™âB�í` šµþ+;иôD+#ud_kÏÍ›ò•N‰—…ï“v\–.t”)„Î)e° I wBYìpø²»÷UÑÒÔî#õ©œ0£û2SaÊ (É[(K¿æåY9gT©P.ZãIc[nñÛ?o úŸŽÇ¾k8¹¡ÌŽUй»eà±m´]™K~NOAnØÐÝ-£RÌ>›ÃÉ& (Ú^Q"Ë£bº78ƒ8»º—ž‚ä7Í@…èÑ6Æ`®ÅæâÕ¿Å.£-$Âxû¿ñú¢‘UQ$;Ð&µ²c¬Ñ,PNŸE€ùsÇL 󹫥¥šÇÏÛ?|§ôuÖ¿€?À¢a¤[7¦ø·êÌd¨ÂX@WUo”§;" 1ryÒ|4SŠ?•êè8Øõ €¹ˆ3¯ƒ‹#º†®Ð¬YDÊéÊ™ç‰Ú  ºè(í…ºGã‰áKTÁˆ+É}ðuU^ÛÛ‡÷µõ ¨`tæÕ–L?4E,Ý×ÆI;°ÁÁÆUŠfhøÑuÇ`»k(g†—Žñ˾'Ûr­Ø’g¾°ݯÕLߣ<ŽÎÄõÄ8PSi´Ÿ8»_êÖZdØC Äè)Æ­¦ï´Vè”à“—²¹`¢jÚUTX d{ôz•í³£ÂjÑVYú‰ õþ˜7\I‹ò1œ+±Ð6ÑigNÇ:g@~}øÚ`ÅÅ’®?_4Ð,›Á7­á¤Ì¼ÒŠu}d£u1 QsÂûD´K òÞ ßØ®–B_€¤³Uœ)ù£±;…•A Úäø"‡ÁzŠÄæ>¬Ö07ì;Çí½·÷oê+·Pø‚JÎHéwU-¬cú�¸@ô ýèkÊÉÊ߃û;"JhÇå@O©:5baa¦êLìÊ¡tŠ›éWƒ<Ýü‚¡$§¡P_Z£¯,–çqù·º/’_˜ |ÉÓ­%>ÇšÑ\,éó‡6äå¢Èé4H7ƒÏ+òÍð×ö'Æè1@ßt¤–2[–^):¿B‘½Ž´C‘ºZ’üN[,ÏJµ]½zítчDÕ¨ø Æ B‹ˆîO—aÇŽŠ žb¯GúJ¢&{ìêïj‘aV‘©˜•\áöÝ£÷‚TÍÔ,¾ÿ—ÚÒÛ®¿GC¶¶Â¤Ï>e~™rnM…qg2Ëi>á‘R ¡Ù‘ ¥®G<ªð@‘J¢Zlq‘ydÝÚw; CmÁôv8áÎoîÑÀDZÂ{2`ÁÚ®C}µ¯g7GùP9LôåÚŽmÕ4JBÐ_µœMrv®[>ÃænyÍ Ó{ Ë™rgl’Î'a´מÑÑ„(sPÚÝcJ«Ã{1¹<ÌEm¨š¿ $ 4¦Ýä^-{­¯‡ÿ¯‡¢Ô3D/xp·­‚²¿Ø~)­~:SÔÝu… „l€ÖÍ°~nôZ;Ç„ÛF\x2PðäÉ×à?ÛîË’bÉa¢¡e6w˧ƴÁà;ˆ•‘)öcC“"Ì®R†? eiƒ‹èbÕlø}^Z 7ÓY~èéÃÃW=²¨xÓòUí¾ý®p¾¡™Íg¾½¸¯<«ÿ/YHvŒEP¼ŸÕÿˆ-c¬)ªsY†Zð—7óx—?¡HO®è6æÒæÓƒtIwøòoœ¡„lzWìñtr–GÒLæj}I ±f¬/TðVIYhntÏ †çµçf‹Þ8f“ilì AÕÀçDà÷<HSÄßÿ" M³8اTjtïfÇì,1ì&µ•šë"›”é©Á‡>7ŽÆÄ ç ~o­E+tz<Ákº¸ö“+àb)º‡ú3_‹vãæDO,µè ŒaV=DÒ­lw„&/rAÒ—Eì± íÂR a§±˜»~èyMúW¤<ñ6¥çNù’ƒ"»©õ"ü y>Š«lÉüF $µU Fë²¾ô“ß{W”EfÌ"9‡ ÌPö–©PV¬ Õ›jQ¿ ‹‹Â”êµqpäyJªV£­Ì¦ÏX±P?P5†s= ©—‚ ·<Ü•Uª¼’¥µ@²K¬V gM'£ãamÜ/^`Üy6ÇCî{ÚáéQáÏœl!שËÓù%-))/·‡I¨�¦2Žö>üpÖ}á‹Ì0f™'žoí€6IJïz¡¼²îf±ñÔêkºéÃäù±ÇÝ~„Ä®lcÀ–óà]=bn,¡ ¶fþ¹‘K58…í´\•ˆ¨ ÷MèÅHqš=ÆèØý½—›?Z˜h±:Ãaób-#Æ¡¶âÒ³áªë'çéF)`Å€~jtíµÅ"à¶2Ë×ýØÖ¦ÿß·˜Kjtg“-^¹^v•ñB^ºNU·Î§àè²oóMp¹ÒL}åš©™ß{΃öB1e8Yµ'õîcŠmïH°-|Š.W/7Â?ÙB¯6”4ŠÖêÄÄbçfnÝ¢IpÖæâ‰VTY:Ê*¿÷å€y#ûD†E“`×e’»zL’· ^Ѧuv^Sš[¯­Öôϼ®l~=óÙ~ñÆlx‚N×M þ=´3×µùìhwâ¾`¤Àm6ÃU`e°#+ôóݾÇí)#“P‹«P‚A­ÇA•ÇQƒ Š˜$ô-(àÎÍåÑÔÎíùÌáH*ËþL7¶TEüFn8\('ëëᕵ ¤M| ô ©öé'¯WDÿK‡ßMVz‚îÑR*³Ì¯¸'«? °[ã¦(ïì9¥–£ðsÁ ¨0ÓÕ£÷Ñ›³°¶äUý¦žzî#,°;ÂÄТÐÞçf„vò¦»ãÄç¾¾:æq¦•\ÄAÐŽ³²*¼ë=/b-»ÚÜúúT°¨ð¤Ÿƒ¦¨ÝŽŽDz¡%«úXp+7FìóÖ¿¿ë3_Y"® ?€iÜåFpñä6&Ú 8~õõ7­·<sð†’çãUPl/ºa#‹L´£ºŸ0¹¬?¢ENi7*ˆ_„ræ‹ ó¾û¡òëg|û¬),£ÅÛwl¥Ñ;­ŒÕá|ÔóqÚqaÌø®~:#ZZ~GjÊÄÂÌ·Š;ÖõžrL3}ñ_2ÜV*ÿ •ÈP¦HÄkk2×õCÓè¶<RÒ©”¿&Gd±Çe˜ÉêPMÚ[juʈ¶³ ÐçfìÉ‚”! Ö&Å –à)¢¶pÔ„ŸqÛ–’41‚:yn!ñ@Ú ü½�ð6n»ö20¼¯'n§*€lÅŒnP‘åÏW¨ ÆìáûÖ[MH ƒ÷À@8pý¦PF>)+„AhìÏXâ"⡈ú­t£}ÜŽÃl!W[SIoôå{ÖŠ¿¼žoÇìÈÝÜ×ç;)uQúôˆÕÄó øÜZïWžÁHÞGgÚ¯btÀ‘Z€ôý<;ûVåÂPªìÂt»VÕôãŠ;–'º§Ž4ùCÆ]® Ò0¶†1 Bž›DF°ÿàÆ\×õ¥…è_ÜY´�ZÆTÚ$An¥ 댇3÷í:š±¨×ÖÙt\pÝUáM]{˜¥W#PØJÞ2¼56®"XÈ…‰ ­V&DzqÓùö€i& Ѳ@ߧ¯=iÁ¦«Oý®;Ù®Ó-ØÕÌC•ß´x-2Ñ)òvS6ɱ@HtV ܤ§¤ý6óLÒÌ´ÓGoF:]\[… 2É ã=>¸‰]¿>6Ÿ·ÎMûˆ3£C¾[­ê˜£7|êé¿o…ïË–£³ßÿ~ˆœ«ôù¨bQ–õkÓ¡¢Ò$H¦åGµ¯9=^ÄYtfløÖ›>£“n²4Á ¡©§eéÖ?ÖƵÏn¬æ2ÁB$§Þó^ÑRÞYÀŸ@ ÊØzóËÊ*âìqrt$ZU˜¿ ļ«ùj^ï›l‡Ÿ×øýú`™Æ˜Y£;ݯÀË˲ˆ½É$¸Su”µ‚ÁSä|ÄŽ8|Ö—ž@QåK%Ýĩjž”ŸóÉIqæá‡ôþL°f™•5Ë„SÖ»VIã…Vy`-5­ ÊEôåç“Bʱ '͸lQæ¦s72QMƒ”b³ë²XŸzyv×ÓYƒ/¹ÑB,AÙuƃqÐ}Å ª)d‘[6Ì´‡êT&UÔÜFEEš…—;”ñÔ”¦…)c‰æ½V^Ì0¹ØY„é5nE¼8ØþmðÉ3_²  ¬pVHWksÔŠ64úƶ=õ5t¼ øò'™QjüÕz°\˯ޓ5÷\+wŽ‰(Ô›gUð©É¹!¤B«¯ 2Roª‚óŽýzÍ'bw¼Gý¯Øå©—ñ²ëÄlwU°vãaµ:ü÷-IT9<eP×`<v«N›_›îŘÅ~nªNëwÈþ™‡c_Ø:ÞÕÆj¾—>«5y¥- 7*ؤ¦§˜Tö:'‹CaºzþÖ:bñÓóaYššÜ# M+gÜRPÍÆNaï¥ ïx¤=O,YÅ­-}½’NŒD>ÜHýæ ”»³ùÔ 2­ú ŒFj•—eãáõá0ÉS._Qºg•›àE†V`™IL˜¶@¾rÙx$Úì·)ŽR#ædõøUWÏ.J?ÖoJªÌ3Í;Ê€tºx’ üù Ö©vž¦ø¾&Pû¥°4ï¾£x4ý5s³„ý‘.è]Iß Þ_›ñÝ»ÂÚŽÿJfͳ’Œ3ib}¡‘×Zank‹¦þÖÓ.ªd€…A7±”@ŒöâÖkuC¼ûeʯMÓÍQåÕU€kèàÍlÓ�+Žã«–õ=?àj#V·<¢¬uhwG|š¥N†)ˆóº¢4Çj•ìÃÈÚ¾Œ ’¸ÙŽLܽþQ}¾ÇƒI¼K{¬¯�tÿÑŽ³ÎF¥hðš^Tø˧î‹à)OŽKVÿ±‡©ÞKœÊ2ý‘á`™fÞ茞ĸ¡d¢d}ÃÈxºC±g­Ã!Èîà8€^à¦yc!õeïMOÏâ9b³Ç•™¥Ha7®K€ø;amݽº¡ï…E‘yåL41óŸ'¯SŒÇZ`n2õµÛoGýÜ7!¹,È,s a<kaL‰lïA„2 ;Ðy_tº¯ÚÞù5OIbßѽ¯ß=ˆŠ…‚™ÜëyÄðcGZ†¾;ÜVQÄõV 1—y¶Ì{3Ò¢Xâ«|~ã#“ÄW2§p#¥‡‘½¯Íè:[“sÎ#ã^•ÈÃÄŠ8­)yvéχNî ¼?¿š‰þ£m k;Ùä‹Ž7Îô«°Dì¿2ÏN<¡QÑäæ{>¨­<†g}×*‘Å¿¯Ñõ|ÝiÈçO1.ç8Rª6~*µŽ>/unÎ8]¡‡7‘AbË3cq²¦§àýÓK`šÃŸäƒá4‡Þ¨"ø“„%‚Ü£ú”<�¼gT (.k4P;ÌVZ“²NÁ˜þþXý%[èCsoC½8*í¡‡ã©$íyCÚ;œÙiÂkö¼Æzðµ¸}ƒ¶/ƒèÔyv1t¹pM<j¶“LÝH|i”qƒ×°žì‘{#¦iX·¬ó`%ÊÝbG4\àêQξÄ=˜îHÿÛGìt9EÝ̸±h‡°à‚ÒE9ÓÌ|¥©i•¶ [?蟾éü×£_,{¥›z7LN˜â‰!¼=fr s¾û8 Í•å z­ÑD¨ÝõwTñ´\¤,%£œªîOëÌšn–Õ¡î™ðç]‘dþBËXvc(—&eè9ÁP*ÍI_8hyÖžD_…m°ûO“Ée_œ-ÌÀ¨ »ä*ÿS9Eœ£!›(hNÞJoúS׸…©ÍùZËŸ(©‡e߱ȯ5Ñ(…/?kEBPéÊ>xöþ¦;§P¹86 ò¸¡?R6–!&®H'Ð œ >ü™vÅy¬Í^\l‚^ow .^Õ"šT´}ûY3GøQ*fçöq¤â¸E·÷Þ´£ Ð0ټ݂ՃˆÅ\†îîï–‹9Bâä0á%÷Ïô5h÷ª`:ä”´t¸ÇÖá+ƒÏªÓéßMTþóyõØկȮ¨-C—S½eyŸ!.£Ö`úþ/~§ï¿'<×Ü$š'~«5fošúTU $ùÑg—}O)¢…åäHwâÓ_:N{ey_Na�CI¡Ññ<ôRS^³–¼Ö › ¯¶)E³ùè±¼ŽÝ¾y‰šCù‰éjœV‹¶uŒÞi”ýàØ ŠkÃŒ‰l'ݶûg¢³a˜ïüfs˜·D;ЄÉ6g´þ7>/Èg¤këJ Rî_~~” !ÎCL¹R(2¸H1;é´ˆéÅq{è†Ý—lòcO‰C±Ý×sŠ¢h‘ÔexkÚÍ[=ë >Eè~Ëð‹#H¿[Ëÿc�±:] ªû$ˆÛ/MæÒ 0-Í+¾O»˜\z†t>åµ{�ÖñÁåûÁ®‘úùSîÉŠˆDOxi”öc†½®kúx+v©ÞÈZ`SÇ7m±H£ØÉLj-óúµ=?ÑÒQ‘¥6š”ñŸU«÷ŽEfo~ïÔ+Xa¹ˆ±@Ÿ@çÙúŽ©[{x°‚o»–cÃK“–N7ÄAÙ)KûõEÒ3°æ²¢b¢6§ Ôøêõ&–V‰oŒ ÷<8ôêHG1 �»¼™WrÌ9}9Y{3¡ÄäA_‚¶×IFŠi9»Ú¢(¦ÿÂfäº5f'ƒ¦€¡Í ÅæF±9[ÚŒ#÷æ]mÄ r[·í•ö`[þ½¶vR-õèSQØÙñi!Ùf7áv©ÞžèÚ.Ä�ìýí/õœ“Æ"Ÿ4ó@NT{Ž=<¦ÎØôyªG”SgjJ-žk1íÒ ÐHÉ™ÔY{CªÄO‡'&5éo,¿øÇ!*rî¿RÒo&Ú˜Éöè©–Œ‡vPòD7ШÈœ»ôr,çÐ"_JÛsOÿ£Šÿªð-4èë4HÚ£g®FFg£§üÐü(ÉÒ²rrd½‰HU°-lµzÒ}ÿ±ã•öP£ßT5jSM«êð…y“%Å3!{öð˜dÀ„ð+Ó1ΞxÕ§.ûç5©GÅÄ(‘" ƒ†0æI=Äõ)MyÉ0Ŷխìû°Ié–¨½3ú~Ó¶>;‡„€Ä3ÌDªÝ…œiðI ²ÆÂÂX 4x¯B{õ±DÉ# îȳgJÌq±>¢<Yø_ÂÊÍ<Ô᣺¡ó@�ÿzñ$W &¨C5Óù€?õ4x'GZ¾mü6Që놦3?H8ý "ž i×Ûú"")¹è1oáL"v'jŒ–âöH÷¦,šÇ|‰Ní¿Ã”gÃFÌ“bÏŒ(ƱkY[Ö쬗ô3’Ðk|g¸Ý{°f­§PÛlF)¢è5¢½¯w¢gþ\D-M+ŸéAç󹥿T8õ.ñ‡?²}–Õû=J¾^ß–"3g7ÍÈKµêó0¤>éƒOV4ðŒ²@øÈ3åg*rsýîŽÔÊÀ`7ðÊʧ÷…ÜD=lŒƒ·hÌM[#ñµ=Ì÷´Ç<“dáa®æ,ˆzýÜ æ4ž–„Iï0QŠ¹ÔQHÃ+yêaL(iu:Ë–lj)rÐ&«0»˜ò i-P‰öúB�–Y8S¡¨iî8ôܘmáa•|þõzõ«‡“S^ŸV'Ã4|]YBI†“Àa©=髪6M]rò·îž1£ғΨíH·é½rg»óÁ)ÝØéRì Ýe_9ø´ç„4F;ê˜}{[¯³Zõ†Íí8¼ˆ”W?±Š³ÅåÆÂö‹bd÷¥ãj£©&—ïïá<2,ç{uW'H‰™É›×ÊÄ_×»q%Ò¼PÆ7 µ}ë—þDîÄdz<¤vh…Ò,ÑVb¹Çfÿ~œûZ®Tôm[*϶J´E Gùä¤G$¨PDk-ñ‰1Eîù˳DÏÔ£Ð?{’Ít‚°²°1yªÌQ9;×-[æ¸2­\¤~¹Å”! ýœßZ%ÙÒ„ Ç̹o?™«b2S`éøŤ»òêɾÔ=‚Åé³[/»®§\yé^$§%¿½&öw$m#8Re­aDË}£…6Ø�0ò,ÀbNO=†jRÆ<ų&aæ³☂4egÑpv‚¯È,¡¿dÇCOIX¬å²Èì&е]TÖ@#ƒWqmú»þCðö‚ÞõŒÓb‘ªUèañè˳øI¹m¾–o_ŸYšé?F÷DåOj*òV¾ú‰UÓF÷%Æb;(X—¶±ƒù€SÕÑŠM¸[³øhè:™{¹D¿PVêøE97î¥'ÏÏæhùA>þi—;Sw"3@¬…ÔFö®Ž!hT(}ìz[‹óªø=ÌĤþå“(sŽî ‡êE<´žÆÛ­Ø« ‡vËŒfûå�S8«sS@Ão&!p ž)³%Ü?>Ý54´¨¶¦;o­LªŒ‡göl¶Ã4H_ÊHð‘ ¦cWpDKgË<Ë•YšyT¡1j8í¦~w|.ðí»{%ÜM›ª \kƒü½|›ê/ì.ó4xbßGu‹ª£šY]Ì|‡¤Sh,’ümý·ë¡Oýïè…'GËÀ¾i¦åÐë:O 2Pèæ1ÑÏÔvè{^oHr¹ ê£9Ö“™,Xh¬[ãˆ>=¿‹WD±Lþó]§Ì›SÐlÁô‚/ibÑT\ ƒ²3‘ÚÈéý"³K2ÅoU†¸ÖliûVÃìÅ¡ýBK¥Á’’c9OµEªHÁQôãªÜZÛÐû' ‘',«ªH3+È�…¼M¤ŸkS«cêD§Ö¾›>d^‰ç™)ÞÐåyôë—t¿â4^?ÏõiMµ}d›ÖroÖã¥[èÚÑIjð÷/}Êgj×ÝWRQói`B\úzh¬™0cZ~”:·‘ȾÇYg>bê² ê…uל…NN¿îK±ÈS8Wѯã‚X±Õa,˜³~ÀèmÙ[+Ô+æ_ŒË<@åÕO†3­»Š}î'„[Þä!óׂžä.Ýïή{±šdwÛÙªy›n)û‘IlX 3CŒ3­¼ºÇ$H·Vµ5ê‚¿%6µÈ´W¸‘° :« :£äbäà5Ɔ¦úÝâ`P¦Àð™@œDÎ&}>ØÑ Ñd¯ß±O7?™Œ¶\^+#¼3ÍvöcÄ`Ç\)üæÞÃÿZa=Ô ªÖ:GK¼âžŽ úŒ[ä˜'*¤úêà JÎÖXß:ö¼/as)0~ Ì•vóálÐ^îêuWÉ(ËT·oš¢TÈb‹_õ¹÷EPQáñå‚Âá\Ìo¦,ÈÛÞK¼üÛÕÕ eäï˜%±Ðëø¯þ lûôf_¹^ óVé±[¸ìÍåüÑËÚæŒa¬m?Ü·ÖßóÕî AHö{®Y¼äè}ø™njsÒ“‚?ã/Ä=£2ñ³%(î|ÑJ¬¯À2(´´òg×)h%ÑûŒ—{ÎfYdÉ¢Ò©_­xÔ=¡3ÃR®ü…¹€«â-tK†¶­ßV—Y}ì{¿R‘iGż<s$Mv²¦~:y¼¡Ïà°ŸÜ\Þ(«f ¯/ØÕÑÁ–ÕŸ–  ë¸ñÊ¡–©ãX±qßó†ÄJ¾§š˜Kã~‚�â´a¯CÇ »sþú’ ³®ÖX&k«‡Íß¹vø èPèžJ…ÆK?µ8X5yŸuu¯×XR85«àJ ûêÇè?©#œ³P(ËOçV~YùŽj,º&cùwÊÓI™-Ò-àr ó6¨(WÎà,à�#ýsjaêÑRòx_“3ŽB„hÍÅë®né(ÐÏrˆË—ˆ~‰ôa(Ãjä²m~Pf¸T¥�–_J8ß"pª ßP08ÜNsF)]¼,\Ë,G:Szºh¶B@ Ca×ïG\ºpcÅ]Q–µ®»Á¾bÊ JnbûØ/Ø$*ñ<ì¯ÌÓ¾§;ÄnµÓtºÑÍGÒ´Yäáã _IÖÝ›Á]H¬•o+öí M"£œA§l¤_ÊANDÚ üjyãy;ÖG>Œ>:m5¼ìC:2ú˜©ª(7g¥<3Rb¾•êwÇé°—yXщ`·skήlë©øʃä}´Ô06eï8½Â¸âÉ|A;íž®“Z(Ä‘9­7}Fǵe¡S€¢›#®æÊÓØ;ù z}¢´ÁŽn Ú˜ôÿ9±¸ù-%5³ÃBù{1ËÆ'k-oRcàDß Í“æò#Ç*Î|›Zæ¸åTÒi‚2¾嶞&4´oò—eÉhCéV%hŸÆß÷|én4»RfáÕ£6K¹u`^ ©Bt¡™É ÝW„ƒº©Äì¶6r³@>{KItÓî$¤Eâzlìo=u”ŒÛ†ÆÇ€:dzc9½ÿ¾-š¯tÿÏÛz\ÿ@Â./²¥ T¾Ãq¶½ÝšÇ×»3´Â“ëîÞdÓçÃTƹ ¢ãÙµaäÑïŽVK˜b[7I‡í™ l´�ÁÆ)*QÚ¦ÝÖ™–mѽ6Q™Ê6¥sRF/ó#7PÈͳg‘@K·Î /iÒS JW¬áõBD†pƒÇrc‘ÌÈ\_ôéc+Ø‘¦âd,ÑUoNt®ãU©4�ÝÌwe54uO5LM'.‹é¿o±Ò7Yq¹îÚÆÈ÷æj:p”¹¤  ä½ŸÌ:O+¶ÿ` '¯,Pëa2¦ÚfüÌÎ*×Ã0˜;+´c­g0p%"èueT -¸>L¬‘žQ¨‰ ”¥õsÅ¥»µzƒI0%µ_íà,ynkò¿lJAén/±Ûß0=¯ZzZR‰„›Þ í­‚àóÔÁŠØ¡)Ôjáöâ;†X¸AÏãÔ$t“¶¾ü$Pp©å`Cç>áOºªNÙBfT¦ÀT§}êñ‹T“³ôÿ¾a<±9LžÀOÓñòÎä×)¥&ê ¾tÞjP@®ö±§¬ÎW½GR'†*àí25­™rfuÊJÔDýÛ„pç ¨ (®>–ç®ÕV ÂTÐßØ^œ°|'æ‹b¹‘;¾Àû<þØ!ó (^öSŒ¾þ_‘Î5›$M—ΰ™ 56Wsy$ÿYæs°)qË &+ì@È~•ðº,0zOo*4Z„œìÜ”àIéCèaŽ[œ¸§ÁCZäƒ@j¨rè¾@årÎÂð‹íÖºiyÉf *B|9û‡(‰YÓ6[}ü÷­Z>ˆc=«=“Å~2Šþ“åWÅ(íŒå«šñ”Jÿ¬ b¯½¹VS»Ó°©/ŒŠUeº ‹TYíþNçAk–s+£ËW–W›ž¢æ[3Žþü]Á4”²ØÏËB’§µ†òô}'˜˜ªØ=ÒSâY+bE0_²lßY¤ÞJøe¶dQØ>’@˸<°¼dÃ…8­ÛéË8ò»›úrQ%îúžN›tþÔž4š<‡ã=ÑsÝt76þÈç™d@äÚ*UŤ€÷:¡M¹èH ö3ƒj¼Z4æ#Åù([ˆ`Ð>7•õ«¢´4ÎjV »X©RH{ü7¿ø é Š±ò5t«©µŒKŠP e&JLZb¨ü®}ýSNz 1oG”ÏÞK6Ù£TÈá@fèCnŸ–Íì8åœ|r(‹RšÓ~y‹LHjð©VNÉãÑõpj^X=ÁÈDbz÷“º¢³Ï“2,³É«Í_ì™%Ñ’¨’ˆ—}Ô ¤€2Üô+}®ÎçyWI@¤%©L¤éö¥Üæµ2t¬r6­_b§BÊ‹ë_Ù£D…¯ÙLùc¢ìåK32fHt'§ ýGÖvðþu<¸}´¨@)ý:yØt8¤iQÄÌiNP®^ýæ‚Œÿó`8Ar¼œg[«¼Áóº*¢[›{®‰ôÁš–BE;ªµHöBiÝè-W°/‹|ˆ ‡Þ#­|ïê ^EŒ‘ì¾èŸ¨U‚KRK- g÷Žxa5 >:py—ü7®j°$YPnóà<¹kΤXììw}çè*«­Ñ9³W×…#Ì¢èJ‚3†¾&.0ÕTsʧ @Ñ?¿~¶!‰Ã]YjG +l˦O¨D²ª%èa�:bšH  “Ün¢`îÎ&½#�¨ú·2¢Š}š`‘öùîyýÒQ¼‹ %{YN×ÚxÌ<À‡Xb6eRsËa¬<Ôǧ20týÄŒ[öH”zVàÂÖ_Zõg {Dˆå‚ðø`uÊ�€iqíqw ·¿Ç_œ5InšË”ÒLŽÛaª"}cÆý ý3Éf×TitCÄ-lsp—A°þt´'§Íö=k÷Îf”R<R•úÞZvU)äXßšç•™^–ûþ¹�²AÏEG3¹Q f)A¥âûÉÒƒi;B[Ve^emüTãõ¨â-‘Q=1[… ì–•H~uÀ8_E‘.¦Ü˜õßmx¦[µîz  Ћ_Ê™&F¶­ ’±UA”óÅ d<ɈL>*[3Y ÞÙˆîâªC¹ê@b ¦¤©|?ùª%l‹9z~™ ¦§ÿoîgú³‡Ø,zëtVm0)ëlåÀ¥Ý’¦sÏ @ß].ˆžVN · ’®“Ó¡ÿoŠË¶5ðó¼®Ê|;bJ¿V`½ÕjË Ìà™• M¡ÅÒ¡«3dãiCU°ü{Å¥="X!z=°øëÁ|ÍÿâM5ªÿMÐ(ÝŸ®[Ð{ÜÛgRŠwó ˆ“êàŒ'¶žâÌ„ÕÈôô¼gõ•,+è©wsc¿<òT ÉweŸo¨ˆqÖuø2ä†"¡Ç¿â>¡—÷_žéÌB!-íæ-¦à¯`óTînÛ¢¾G*[N‹ þ ñ©°NFM½S‚VË7 ø…Ñ¡‰Röô]•¥J×wÚÒ½0ÔäW)÷Lr$Ek“së‰ÁrŽêqúÜ:{Åá$ ¯LZZªEßx¢_#¾4ðúÂd¬T›HõSè¦îLá”Øè𾆠jé4H/hÔ³ÿ…WӚʓ­hÛz—ÏñTQ\øƒ2îŠë`§èå¼vŠa%Â@° ˆ¯["¡eÓƒ,èé°*S ;)3–@2Ö;Öæf½ÕÃì·m×#²/XÑÎ)4ÀœÑvX;¤õx¸L.߆¥°£“wu³ã W¼ŠQ.ÚË¿å>ºþÏÎQª~(Éå5Å…·È²_eg²YRugý5yåÍ-ʇ;ˆÚPGˆ,T œ¢ .?¨§ê”ôRÝc’^.(ûrÈ­Ç3Uœ$od5%ßðãPÓ×~\ò¼R}Øhx›˜YÔ¦D‹Tp ý»òX]–•(ÝÕíª«œT8+Ä òc ¹õœÿêv¿£oͨÀ«PÿmàÔcNT½¢ I7ÝžÙ^<Ò½8¦ÈÄ6¡[ô6ƒò8îö“êŽþ0ÝöPú¬üߟp×þút<ÿÓ™p[dk©½0#Ïð6Û:¤‡[{¦ à2ƒÒØ:¨6]ìëneT–þ  G yîw…<Eµ‘ä¤H„¨ÄMª”Y#Å(Ú~tú~*`¥¿pˆåìßÙWAÕ¨Pÿ=]S{süÐzMëîˆË©8¦’ÞìkëA[è‰àÿ™ûŒ¯©<…Úü×–óÐâ4²‘Uyâ΀f´¯'nþß $#u—¢'b Í!)ƒ|ûé裌ðúWÜß°ëî:_’¹¦’Lñh/e“z^uãûr—Âú„̧…5³Ylî„gí¯4TºnmoE¢BLõ ¨ÇùAÏ@ž¤A™º‘*™ÑªTŒQ>ü™Ø‹ÔeéD÷Œ‡7ô§ˆ*ݲnãMÃö”r˜Lü°üØ?C\\èŸhè¼DeuèÚ· %5ý%È4Ÿ/Èš»±kw›æÑîcO®•1c;ŠÎ¹íxDA YÑ@;Q¼6/ô^eq+{´dtGÀ%—ž”6:{*”Lw \fcš ¾àÒ¶‚šW?.ã™ãL¾~ý…å*-ñDi‹‘Ú“KâëQ©Ð±l½o~63Q­Ÿ¸#²=VAtT|ÇŠ’úz°'¦e.Þ:Ä­Wã‘‚7Ý |q˜û^ea|�Cø©§gT6¾˜°&+{ÉÛÙA+Ëú ш‰¡ñbKýW˜uæѳ0ÎîoS€)Ÿ¤Ò÷@f–¹*õc;Bí·ñ7wÐæîwÞÐsŒ/ÈK'ÁZ‘û „ ê›éX1Ö„ÝWÇ62‹‹â-]I“a‡õ'@&OÙtBÍ3àIôÌÉûß¿0 úö$³ªæªPÄæ&9½a¬êçË \! #“ÿ “µ^&ô°¹ø•w]þÄfW¦2ÓŒÓÙÂ6Ka�¶d:ã7‚õ·rÅÚêŠd*[g°£®ñúBÇqÇêI¢ûÆüzlÛ =–Ü»¡¤‰? ˆÁ4Žwl”­:ºGh´>HgŒÝf7ÝKÝâ*»š3œi{n7º=á·Ø÷Tˆ -˜(šÂ+Ê*ÿ?.¸1/ay¬”mhHÈãõ….ǘÍ;v'áNŒ žŒä ‡ß’#‹3„[Õ—H+‘WùÐÏ{­ËðHŸ!º˜�’2£ƒ_=“_¬_˜Þü\ì+²ž+¹ÁñÍèC”VÀµgÇev-jÝõĽ­›WuÆÊR5Rž¿OÀØhžUï>Z츤>¡œÛRî楂3*(†î‹@¡oÁŽNE³üdŽ5e©@iý8Mœ'úý?ûz¼÷£§­­Å«6ç4CGáíØŸŠq8²ª=ý]cüceï1'‰÷£½ý§ ½œšêÁüIanÒé%³ŽX÷0è/­ÇIãç©fï‰Æ½˜Þ½$peÚ”Arl½pÌÌ-+ûy˲ô„NY|>Ó£FuUH¾ÙêëzõÜÃ<J `œE†ö´£ŽC±²©îN3cí/·gkè”Yÿw:Ðç.6Ö8“Ï&ª:J<mâíH¤ñ‘* 'wµðl)<HöMŽ´2‹FÏnzæ½Rä‚ö4|ìFÅ5°›(•¥zw×ÆÙ©à,¹q±'_Î"w-ì$¢óÚ 'Rþw¶AI˜5Üû ^áò®Cœ§.žkiŽü¾þ€C§xTüRœ'Î<¦ZÌY"ãe·:&6óŠ…Ïv¬Çý/‰SWyå+?R6UQlè­fFn„q `:ô;†HÝ^ܱ£3¥SbRÍfB¸ƒŽ©@(Yã4ÑçXƒâZÿz”G¾È$ÕM§†Ò«1‚Ä} ÖeF´¥Ht°wHfÐÆ:à)ÍÜš1…f8×}·V{XËlNYKL¤Ñïgpê d´1SÆ{”ÖZ'gߥºa­j&_Azä…Oä¡}p†GŒs³VLwéf畱“^<d›w›úº`æÛ„ð»R0+‚ª=ZÒ> =§ÔCùßÑè¼Ý‰dμ¨2j"FoO*ÏŒ:¾¯[†0°82PØõ‚5ú„”Vža7£¬§>gEyœÜ|’‚?‚ Ù\צNÚô_îkª{»ˆQ}÷k¿Vá›~Bæ|ì=õ$á7¾¦DP&eÈë! ’ñèÈYîL]Ê=@å[€K;²˜Ü°Y·¶À3ÓC9Í;ÛWs|áÚMhÝÉ1Na[W´?ÓHY# úâ.´ò)HB¢ˆ lß5÷²pÑ ‡n]$“f<Aæc|êÆ?;v‰©g4\³Vñ××ð—Ç8{¸[Çæ¾£-'Om±90WŸ0Åöz9œé}/æÇ;j­Yg®gòÌ6ií(˜­Å‡KmÛL/Oi­´phžÄùO”ÎW2V²„âaõÙ{3 <ú? ÔwjªoËºëº Ë ‡‚—™í3ÛãÙNµ9h\†5ËbDÚv—ñýQÜêì!¯š¹G=[ åƒ:ºe«l9çU1÷ʹIgN¢‰²Î³È"Wq”mvýj‹£ËÉÈsáý{iVd¾¤0åçT~~(óÄ¸Þ ‡éq¶gYû2Ý6?’x æ$›·ln�¥Ûa’k£äJ¦]ŸŸu` Ó¨–_Qª¼«õ;1Õàá'A b¡z|Î…¿¯ÉÑi)¤uµÒ‰«é,¡Í,ZX³ÝV×Òãû=È3 ÿÞ/-±F K)õ˜G 6ZÕùž¡W=ˆ¸ƒ®ÑÞGó½¥…ñf– Î`VÿÒ{ú:ᣅr"Òï ps;¡FcŠ•Â²03X´Ë%œ\C® ‚[æ´œW eI§“‰3C#,MÙ{{Bï¾fú’åðš»÷œâk huú@ר§{”]¶ZrM_ûòæòŽÕ¡?_†7”MÞ%úµà]^‚ ýªk[!kfž,”Ø|ÇT8Ÿ= ˜2ûÚJwuýÇôØÝ;Í®äà?šõÎ+œ¶ú¢þÿ)~4_²~K Žm.žê´'—D{ŒÔÒ7bÁ‘ƒ™#E)™yŽ¡÷ödþÝ “…ý÷–·‘°²h8äG ŸH%¯D¦5¤K à›º9èÛË€–W°wé¬eoÇ2õ“˜èÔ”[4“Þ4þ°´˜”¤ íÄYŒ.”’ñ,ͮܺ/Z»i£Ï…êR~sÓX5»e/bÚ÷8€YâÓWè†À»'þ\ÛäMÆm½é*›ÛtåÝsÇÇ¥®m/§{÷U±æ{¢Ñš°)õ´•zÍ’NßùÕ¡kN!ŠàVgºùŽrSíÀ¥]÷ôWy¿ÑB¦÷uX­WÑrî™§Æ # ’mmº?Œ×Ø!ƒðZôÁÈ×#ü�”«ò…ÆŽBg;+0º¢%dEq_E,fá2Í9ßϱ¹§%®uÒ¿S;ÈRçƒ$~[SGõMh‰¨PÇÍ]£Ógl·0ó0¸ñ —ÇÃÑ«H)#¢ L¿ÊÇNݦ_c—_ÉfCëÊòÚÆB¦KëÛ�;Ã'µÍï¨40‘cWQ磺‘½¹ 3pï•P@ìÚŸ#è;A™s< È´nðý6šõ¶Ó7^¨(äž–ª<óY¼P¼¤eSn?¯§žb¿õ#dßóÓCë"+òaD ƒÄAeÏÑÜÈ©{G�ˆ=¿á‘øp•î=Ùw üxê\ IÿcWÃïÙvÝâä¯MÌ)²™±|e+¢˜õ¶¤ÎË}ê­}J¶>ÜÄâ–W’gKJç mÏwÃ+§m×ï'9³î^Ú̶K2Ó¥=5£R"j œ:À“'Z-R]}ï.z¡zò´|Âc{R\l¹‘‡Àˆc²ìâ×æMÕ½íù@Ú3ó5é}t˜$[«ºœd¿ä¡Lßú¶qbWŸá›†BÎ-f‹ç‘œ{x éy5VÅaæIl9S‘•ëƒTµaHŸ_©_äÙ²pÁ±¹½Ô½ï4Sª‘´ÀÂ(De¯Uµ#§ã¸;Œ=P~Ož?p ቺVNÇPä/Q…ÿz¶¸´X L³t†*_¥R—U\Ó#SþLôöz7Ñ-oèöíît¶!uËâfwäÛb; , [LaëÙQ¼èˆ©Çéã ›Fqêj‰Ñ×Ïß›˜1”ù4Ôæq¾(®_­¿HøÎù—¶t1/£ÛâP–æüß¹Êtˆ'ˆ¬ñØ]<!àº×âäZÝñVåÑi»hðØôldïä¢E|ô€Ö*û·bô/‡¤YAOé> ® Y !Jƒõ…þÄg¿è õ8L8ïGˆœ1§ñÞÎ]¯wV€fEåMPMG'Á„Ö¨O“¿v¢ÿîg3­<M—”ák`Ñ%ƒÎ·ÑGáÅg¦ 8tŽKW¸Â™MXƒiSE}ô숩ŒŸ¤¯8¡.7r r ׾¾$§YT¡ï»›Óz� ôS{ \Ÿs|á?ÏSÇsÝ·VÎWŽlS°Ë¢…÷º÷Ö”§‹%ùvÈè=}/º<óÕ#×ý/ÞÕíQ*LýiØH´o-ì¡fŒÙ³¥2öØ҂虑å3‹*+âP—±Õd°":sð÷›M›WÏî¼›îÂãr׊°â”Ò‡¶2ÐÓX‹WCÂ^ÇÒ[Èz½À˜®\— Q‚îO[¡íÀF¬×Ć»»éç­c§5' ÞL­gåJÁÒü06ðoþ7·Å.—â“HÚ)r<üà•·ídnd•DYº ¶_”Ûµ[Ožx½ûj\¯ûé~+X‘ž–GÕñ«ŠZœ¬Í4›¿ëf·^˜ýpX˜¸•è‰ÏŸiP¬¦}¬,µ·Qúðæ®wî¶-°ãMŠª°®j ÃTAV«òZw‡q?Á�àSµ·#[ 4tOâv°èƈ©Æ‚ÖÒÓKP›ÄÆ?âr@ø­7ŽŽº:œ{ß”J~æ f芿èŸ%‰×‚฽ڤÙxbò¨:4Ñ<)œŸÉÖ†~e•øzTÌ_ÍÁø=S/šRì/-k–*èHüëémbb1wXL5}¦ù‰‘U*,¡P £†2ÕÙ©¦X¾¿b½ZiÌ»Ü^”{òG™¼g3x¨(n7Žs‚9¬K•¬úèÕW§  íZ±ç4‹Ô÷…öÄ“”Å­E§3eÌ¢I} 3ÿ (²­zÀKÝMZØ/û1"[ŸúûÜë²È|…ùŠJ•<ÈÖŸf©íÞعÆFçÐÒ¢ÓÏaåT¾è?QVºV*ÔÖ—"(ŸÝ©ŽÉKÿÖ 6s–à®î™Æ>}:, Cˆûå)hÎoûî<é]ƒžw#’&îgˆŸôè§a¸ìi§¹!|♿d2¡KÊ îô¨Uí|Ö´âßè&àªcÙÏçÝŒ)J;vF9ƒ@û²D¬Å¸Ä:š0=­šÑU*Ý$b¹>LøW–²1ž9fXi¸¡0Ý»öj©26‘‡VA¥#ký*=µð1N룔*:ÙE^ÉðPÜÏí\œá¯Ž>¦ •Ê_ê˃.==hÕléO-FYæÅ g·ãÁdÞ¥Íd­%rÌÐ/†b¨Mh�(}¯éÔüC¿s¶Ûúg/"§&¡…. Ú*¤Û*wŒ—,íL@†½Í±l$<C09< 죱7¦V‹)C~°¯'7@EØÞ1%x`¶%»GŽâœ²¾Pšò(´¦fÝÚÉâã„ÂuwÜ¢¤°ˆÜïˆSæËbˆÀ…((° ÊÉ0©P¬ÿ‰iÀÿ|£…˜{“O®)©¤¨wT#“ÝŸ‹»ô%å645­6v«Ÿ™5ñBZ™rnÕ {žy®H+ìl6“ç`ö¸HjV¹AnO]ŒcBbyÍÙ7%v£…â,ÖïšþI.45CJsª }W ?ÝÙaÅÀMƒ¨”Üõ®Íª?¼Ÿ¾fŠi 2°1#úEq†»æb¶”"‡÷'Å×jÞºqÏz7ßèÇ�s‡ÝG™Þ7ë‡Íÿû?Ó[ÕDËöJ#¬ô DJ.ˆGJ3ÚÉé6½˜ýŒ<dµÜÄ:‚ÐLHåÊÙ Höt#~R•5"C«mw¤pç(®ø Û:YˆÚ¸¬<Çwnšÿ ¬Ó^£&õúnœ«Óö E¥Çé겡·÷QHIˆŠÝ®§K>+ á%=õ²ÑžR‰ÖÆ¥§%û¶©Ö—è¼_×»þ‡ÂêÎÇJ´­ h[Qam=¯# >‘‘ªìnº¬º]¿;l‚ÕyOa¸#p¥ 8LÃ`0W5_vL’B2àËú¢mÅOsa5w×wŽ÷AeŠwAo—Áv¤4£ÑúCåã�a›Xgîoø5iâýÙÒw“ÆÂ@OíÁ3c00ù'àßo"eÙ¨õÔï&ŽÌØÃ+ ðÓ¾Uá®0Fœú&W†jbS{Né÷ù|ijáY‰ºêŽ^Í}` «kø}#Eí;ΉXÞ±£¶Õ3"ÍR³’hwÿP \'¯»£Ä-¸$Z˜e°O³ |·>cYË ÂæüE•­‹ÆöŽó_m«2U…˜òh`öGaÜ×ýÞšœôŠsRy`ªâä¡¥'ÂŽöí§.ÝÐÖ”ú"u0ã9´žh¨a¬é(AºK·á9÷ÛzŒ·ì…ôóƒú Ù»¨Š[P•äŠ´Þé~ÈF8°–}]Òo\†Qcóq[ VÇ ~uèg´Ù,KÙ„ä¦pIÑôÛªòìKEU‰r®ü]ñƒ Æ7Ü_æƒ@¬N jágZgC¹ÒDkYöä®’—‰B-–vR©B4*àúQ÷ue«ûö…Þ¤•“Ï4»È#‹}‰ƒ’½äÇÃÁ“,wÅϤŠ£¸t¥’iOk �ÎÀ·‹8 ²4Š€õ`45Yúý·*—A±Ñ¡ÒTƒNéÙœaÄ{´²®*é¤$L2¯.ÃjŒ [Ö9šå@ébçí°¦?ØÆêÃišíE )Œ¥§h÷²ZC‚XEï(ߨyÝ«¸UB£Ò´§$:mTu>uõ°9Œž;ê˶l¹“l2|8Òá˜YSoF&0¶Èòb”ßx{qŸÿè„cÛêÒ ¨uþŒ>~×+-˜nœ€‰k„p.Ñ r[9±¥”ZKÜi‘$ +qÖü jÁ8ï²€?ÃÓ)7e¶>§¦³Wl†t¯ê~"0b55ra„˜_j·F¶• &=ï'xxŸN™:jÂxöýèIið-sÏåy¹­ýéM1| ÒCSë ,ÐòùÓõ—zðl «sÌ?)GòúÇ+2�0«sTçGõØÃí#æ¾n;†ªênõ?œ ÿÓ_ö·8ëÊ«ýøf¡àR]We|¶»}­It«‡äS�c‡IC” ‹® ’OÜÅ<¬èÙFN ˜ï½|u脹ètŽ„½6ºá‡A¡R0pJ×yÈ·¶²æ” cÿŒ$µL0a=¡Äìâ4Át[î;Ò.ƒmyYG¨p8AŽ>Á¶¥;Ò¬Ýü”öÇŸ©È­ßT¼h‡yæ)bQÂ3%ÛƵº—5(n`‘Ýè­ëؘ’0;˜Í´™Æ}W¥#ËaûpäMbxX ו7fCæÅC½0¢•IIA9ÈÚ*¹ðhùðaÖüý&ÛC†™íPKÎ Uú#\ZzmBd<WÔL[Ý™Mé®_ ¨¤É:î9Pé<è=(x&„=8^£ÛÐô–öü­šGêºGÌâkŠ"HדÄÛÃ;]&|s½7èý›‹f{¹0f£¯M‰$ÃýÌ~Œ—9ú˜,¡=Ç*ic×r—“]$hlR|DmW$¤'ò6”Ì'½Åîƒí¸Û¼Zd˜iX6™Ÿ4¸Ñ›Q¥)7[™Ê úT d΢NvUºËÛn2Çò'>Ž‡ÝଓÇ“šVkÀé:b€ƒ…‡+}noï÷}¼(Œ³¥ƒG Ýñ|š­äQÁ\Vw mØgTþý=^T!¾MD_¶sXaÖSÿÙ™Á%P‡štë«—lGÑ”Ç܈ìÎY4�O¹ð¢áOj€Yð?ž‰,B(ƒlÛ:º2rj®Ø Ty,¯eÝe^Iãok*¬¡Óìê‹`Áåx:î†A„ªº¢ rÄi[É ÖÚo"ì!£Èð¾pIé_XzjµNò é´±2_Þ(]ÚÖ?ŠÓ¥àöЪ>÷„ï¡uhª8û‘Kœ0DÉG+çš7xWð¬¡ß½Ìú!ä"Ë<ê^$ø ¤¿Vue/<”�F‡ß4µ= ߌµÉ/‰"Ī žsÇ:¡4Öóq´»„ŸÝê@©”vÙYZÿá…æÁ9ì$âé„‚˜ój ¹wÏ T¶àdÐ뙃o¬ëöRÁUž¿ ÿ îbW•Â«µÕKðàÛ!^ª{¶äÇŸ Þ–"3XÜÕjé¿î©……e½¥˜z`Vëÿá)Ž]”â´íx‹Ù×g~¸9©ßǤ·Þ£úÏšÖd‚E¦'H9°8äÌÆ•9¦»2K)_ /R…1u”`ϪZ‰* mQ˜ÜOÒ¡Å÷ow@äæBvÄÝRÐÍí1ŽÓVÅaÍÖ:£•x²©Ñõ25‹ÜæT‡ƒÇÊa‹oòEïi%5&!«Åì$¸‰¡9Ôhg2vãÖCàи†Gˆ9¼»³"ceb+¡uåHg³à…k0š»'Z3ñçàé²õÆ„7“z‚ßoÃØûÌžŸÇ"ˆ:E(ç�$áf9©ò3òîúFfׇùùO”vt¦O·1úF)Ü0égIŠ}úÓU›¸¹ˆ…žáE•Û¹wçì*á´Û‘r(R`hf†Ô€EÒÚ¤Ujô¢rÛ>Å–›;svÞõ F—‡í¾+õcéÌ×¥¥3³½dÌaKTnÝ6…Tî'™Ì÷9½x@Z°K‹Y:09Hè-çÉBØbÖû;¨„H A°bt˜þþÒô> sa\KÚ˜}Ùõ†Þú½ú8­jÈ}«Õª[C‘é<ç±ûâ÷¾zeª¸+ÏÙ:”-jæÎÚÀΟñUw'¬JÌSJù'Û…0pƒÛ^;ãhC?±„Êi»€@–¹;\˜¯Ô¤€(6V½Ÿ°62'óOÕqÉ@̲�ÕÉöäÉnhË û^ÞòHÚ@JZå�Cnf¢œ¥±Èý’Ñ•’™[v³ñï3¯8¿,+?$M:HÁo“ ðæc…hð[œ4[Á½!PL¦Ñ"ÍÀG×8¼bŸÙãž>nóåUvZØÓ‘XC¹b< êqÓÞ™UK¤¤S�¾Q™’‘±l¤½ñŒñ°gì¼î8zÚR:µý4h $ ëþ´ézɦvïô; Uaâ–˜\ä˜ÛAت8(. ,¢…‚CJ¾Ý£þÐò?>^AËZ,¼* Ÿ[:sã^³iƒGh}‹Šnž,d–fEªý/x¯jL[Û³g®.‡c½·VeÝ0BQ_;¶h=aW/º zºj'¶OW°x.À Ö@`»cJà¬ßÒ\ס4B;4ÂóMë5ÄÞ¡ˆT{®p¥Ã¹±ífƒèhƒ]"Ï)$eͲ<å*&²œ &æ¯q JÔEâS’¸åO=é'E-X½ó„9íñÝìØ{Ý4ÈE¼¢t‘ÞàŠeº›‰žk¼<æÔõ\Û*Ôz“ [ËüoŠšxánCÑs¦¨—Ú, ´þ²¯ •…×ZZwKR|<Ð,êµ7ë²² z7­"¢y5»L¼=ÈØ¢MŸåAeÑQ«Ã:™̇V Á¾‚^Ýn€XÝ´}æ]ì+¡Z½ó,-‚Ét:<D¯ÎW’_cècAäwa‰ßL’Êkþ kø°Ö9›ª.c´ôß7Ð’(<šdžÇø]ØŒÒlw¡C0§wÞúRúv+:Eø[ÕsùL``׆iuè¼ÖËÿÀ8¬¼àÀ®â3†'£¢œh[õüU¤ Å_=0Äevv™9yx ·×ŠEE‘ÿÐ(do2^ÜúF™(Xï©»Yšy†„”=­Fʽ§w,ݪÁ)²¡€%™j{² t%¤M9.Lu¾z½=Šï¤ >hšÂs#cíÂÁëU·’k¯únÈ®i蛘|1;Ï—§,mO˺² ûfÓö±áÅOäCv!âjÍHa¥ÿë97¶—Ëç?ŒG+½ñ­e %±RÔÑy¯òÝæ‹kËîmtW;—&ö ]’E;z„Î#9‘×�¨ YÝûéÉq¸íàõë-EÝWô(çúÏŽõ†<­óﺅ‹¹IÌÌ£1g‘µT[²Ä"«ÏÝñWî}¾àcÀIöTp»Ôhdœí«Ãù’Á7¿0º=]ëŽÃÅáòÜçÍÁõn á­²R3³w½Ôs<AVúÌøá˜Ò¥o…Js=1MúWõÊ*£´Ãø$rV©�)¹¸‹;°Ô$uzË¥QBF–«máŒáGçkX·@Œ·fœ™b_‡åÛ×ÝPŸÞ6°Ÿ¼úÉ#FG¡ÑÈ7”?{§´< c½w%תîaFò²úx+}¸àšbfƒÅFÅA .äR“Úê½Æü· ¥±;角6ƒb$ÒÌHr¬š?Û4áR7½ÍŠ9ÏäSºWP&¥ Òp%(Ü[á æ5LÞ¿N)7^˜Ó�ÌÈøipK±H‘N¥Û N¡§1¬Rbwµ‹§]$‹>éÐØŽàR‡–© ¯Ü™¼t*æ÷@k¥´4oZç<öÍ‘J#H® HºAk§³H~ÓÛy Ý꘢òhéØ¥g{üòZ{È@4iÆ‚iº¾>?…òŽ•BYÆŽ(ÍÿgíO¶[בma¸Íóî}½ï`]4I‘*lŠ’IʲÖøßÿ9þ˜�Teyí÷ž%Ú™)K$ˆbJ©E<Ú!‚Éw¡B°ˆvÇ Í]{#x_7-bJðkSˆ"õ „æ4´5çôwETF 3f¬A÷/»Y”yzDô4š¾ ÒFGÈàxöµµ*âDŽ'3?m–4G†°8`HçšGܸ£€¶r(/‹¨¯ZkéŠø¤ŒÑ¤w9[·<`Uh$ü XÊ1&Äà&5@n«iÚÖ=ôíÒ¯XÇw Da¾ÁÜ‘'"! D›Ðò×Æ)H…ãií‘ý~…FWÅ¡(5V|«:¹WÜl0µg(Ÿ‰=\û¢ 3@^[äè\q^–±mbTˆ¼ð­§Oϱ?ýáRœ_å¨ó©Þ·Xpæå¾V˜ù˜Š‰*ˆ?¯“†o)ç«´G…sÙï'T0 puë±^ÍÏFZVgˆÿ ʦ®vq‚óÈÇjWðMSö ~ˆvX-TIq” 2´d¼M2G¯Ý-›HTÉÒ þ¶¬wF'óCÕ‹q_: ¾2ÙÝKä…©“>.Ñ&9¡®ë{"A¾Ûû¹í®Ÿ~ØþKÈ\n*ÚšN¬r«‹¾ÉfÑ°·]»:õ¥é¾ûû²!¥oX‡ Z„ɨí(Z»À-´^eò;B;ø°,K2Ö*q‡õ‡^èÆ„†¬I° àUet£ÞÄË.¸vï°‚vQlL먘.‚r½ñÀ€¼ eðíÜÇ%´5‰îš×)åöl ³@–Â¥£.÷,›p8Œê„ˆQ�ýwôÅï·jò ®uÞÄZ^ö±ïŽutýEJæŸT]{¦0;õ<UAØY‰:ðlµr;S.Œ``_¯W UÜÈMÉÓ×T^Î'¯­Žö÷‰½( mU˜Y¡Ig¯¤hå‘ó’ñªH4n#'…_ÔŒ ýáÜOtnÁûa;°»ÓípNè;®|L>ö†¿¸7…Xz“ªœñß5­åµ:ƒü4-#Ï›+11×­ÅA‡©þv­Åu=² ƒ¾.è¹³ØæFÚ0H:Ý-|lÖ”÷N6ÔâÆîtxݶk#O»F$Tæ VÞÖ›/áÂ{”;k %$2Ûæç_°a—[óˆá‰ÅaB)éùdEüŒóé•+œö¿t xÉOGµ‹…3³¦oü£…Ÿ»Ñ°•·mna0çö‹Ó¯½¼cHaØDåó­õÊ®äQ§Ái°°Î§ö@W Æ8¦´$Š“†t4»/@…iwöÐÛÔéWn#¸Ê ùf˜=ü¹k<¿›Ÿi7•gûSq\ÓéX½Ÿœz°/ò~°§*zà’ºëòUÒœÏ(aë³yJ‚ª¿x:ìÓ0OKïõfxôYåJIÆìéf`YY|î+ÈÙ#cªû9õOéuº3ü’üDÚ³éQL¶Ýnoª¥ÜýÂØ«×+³1!MqõãLw˜'ˆúÐ-H[dÛ.ÃU'\#Óqí¢Úå$»’œràœ|´$Ž<îÒÉÛ}ìúA¨Éûî[!ØÏ°€U”-EN6ìãÜy¼§éHðÞúGÒùz8]¿ÜÑMuY™nq_×æl¢ ž ”õ ‘åR¹4„О>ìøîäí !ˆk3åýyÚë‚UdZÌ›m­Òj/ñŠrª¶ÓÚe=r>Êy„¨‚J×]çi¶_¸ñ´ä͈âG[f¼õ°u3‹O&££ãÕSÚuDÎ>Ô¢ËDIÍ<žÆþSˆ˜û˜g%—‘¤S)š´§;:;§Üë$yO³è„›W¼a´€’D@bfA¶ÝºÚ€”Œ8Þábq·àK…Yd>ßöá‡Hj—™Ó‰hü¨š¾”NO Ò×EE~¾Lï¸ïbøñ(Y ŠôôGçg¯ÝSqtã5÷pÁ~ˆ9Ò,`NÇ…Ñ£{'B+¿°%øtKçÆàö‡[‘.<ÚÑV£ÂùÓRÐéF 4ÿ®»X\Q•Z:~ÃA“«<¹•ÿ(ĸÐdŒ¢Ò”WÀ]ätü6Ž� ,¬¾¶Â‰2þ}Ûž€Q>§¾L<8Ãáï.°m0à2*ž¾½õ¾î»ºë–pç,ƒ>ÆkÔcäôEr˜”–nOØ*:·4Hl)[ÓR¹ äÀZ}b«ñ¨’iš™ “"êGˆF½û*Œ pÅ^#Ä|ØWyœ2µºÊ÷3O.–[Q2DÔ‘2+”&iø+d+@bø‹´°g:*§ =ÆÃ^z–ÆÕvŠÄ]Êl"¡ôØŸ&¾iI8û@ÐÁÚsÔwi =W_ñ<ˆpåJ“ù Pá­Ë i­@ÒpŸäþë=·Š¾ª&5 "¿!`¼ ¾èÎoXÂÊÏèû c¸¸Äþ|~l²½ïñ7ž29Âtaѳqy®²”vÅÛ–da�6#Ëìcâ¼ò…LcÚ0 ±ÂJ8Ũ¢sÖ-[¸ñRÜ÷Õ2^–Ψœœ±6‚ æ{ë9Y­Ëÿ+LcU£c<ûM$'úÇŒeê(2M8‡ â裎æ»ùòèׯ(XfŽýò }iq“´A¢]ƒõo[§lÿÊÙ+ÎÜ1Ũ<ÆŸ€,;wµ§™f|Øžá“-®‘í<˜^ûx9sraÄ<4]«€Ö£¸íh ØÛ9¸ùÍ¿}÷¯vúz,Ó”{gú:û%XÔÜ4d]òÏÊ’eõMw ÁöNíú´DæÇiûn¥Ð€¯<ðã}gÂR¼¡ÖôQ»ßY!õ¬§ÖéL”q+KªîÝ´=1fK¸Ã«ñ0M, ox·vœÎåŒ�û²v6i1ÞL,²£Â˜£f0¬ÙB·Bó|æ >#G¯ÿò2–Öci²\z°@sv „u|k é ¤tÿÃ9;˜‚ï�ÕHÛ”2‡¦s‘v_¯èsÕz›†í[ ÛÎÜôÐFë5¡,cå6? É 0ëeâðÃ:Æ"ŸBu¯ij*ã‹NqÎûCo\^éˆé̱>Qæ³>ÐÉré_»þ¡üëCd>‡MÏ‚ôý¤ wO{ ý÷% s´ÊgsÏ8‰ý†,îÃÕ¬ ÙĈßPŠa¸dßÒ…ñ§žÍøóä Å>En{kïp’ éŽXûЩ| ›¹Ñ”©5E6A»±‰‚ÊRÊ¡¨x"ëêóôÊ‘¿¦ 7×ú?§Á „Îy7 ;óîp­½°oçk“Í8,|LÕMÇ0+Þþ'%)Fóc„¡°L?8`â¸ï–Ä‹0ô'y@ÆWA9œ<ó#zçw ßÇít”üg¹¯óA·ür pØ&AÁغ†œæI»% ¼ØK]ß\Ì¿·|ï$r2R•~Ì´DŽZ™Wl ÜŸÞÚã`»Þú5iUíЈ¶ ;Ð}­-Ý°àtpƒ­NûòU¹íÐZXªº½@×»×vhŠOƬÍF»–Á¼_·GøY$ì™ë¯@˜z¦7µ\À$•1£c¼ž;£”ysÁÙ²V.ì$ÇRÚŒPB”¶rR5u�&¸ÂåùŸ\üÔž/´ÎPIÊ‚ÜJ¾§LÄ»€ɲ,‡¶Õ"ñ4PêÂågŒS\èà/³(û"¨6ïæŽw´B*E‹Kûö¥ÀšY`×À~Ô²¬Pšaf§TNÓVÎjÕ bª‡/@Ž\zÚ/Ž’]íÁ“öR²N‹"é°t(·òÔýθrðÐN2 üŸÇ…Be¯Co ï,·ó€aÑAë*Ofà‰â€5ÉŒäÄh!K‹O2è7Qôº+Ó¬'ä¿tÑ;†12Ä£ùyÓæÏPߺ20zï®)ú‚–¥½éQfðç Ýáä•;[pÏÒ×Bwí¤þFyº…¥g±ßœŽXÎ49K[1{–‰­¬ŠQc «×»}!ò[,[£/ÐlÕò®×±­¾ ¥°ñv7®¹‚ƒ¹97Œ©ÕØ•Ni4ô•µ­Á$ƒuKtý5z'¯Ò,7Žp¹ZSÜÍŽßJaa§îîпm�,a¶ö¯Uo# ož0qŠl!3kÞ½X4ác-:àwŠïq~¥óMÏ; ’OKm†t)ïöád©JÓÑK”+8E…_`„¥Xˆ +¦Ñhï^¸zýŸXÊg 4,ýÉÝ‘r¨YXÕLIÇa½†­«PC¶Ý—b�¯ÑDÜ…åKnÐ8@QGÞrN"cÖ[«ìXEUÞ <JMûg¤^’{¦É8~`q”ëo—,Úƒ&“ß –“ƒµ˜/^,*¯ºòb^_€6³\œTUÕ·Ž•Ë,½Qبcj|­u9lOizãÛSD§w5ìó¬ÞõtN¿)­–eáT{YœýôùÆH™±êœR ØçÚ3Øi´Ö5€ìx«3uק/.~XÚÈ\y®•PJ¡íf˜ÈXšÝf8蟸VÖ»¯°%Y¤½ìpÁÂÀ‹g»'SþWúå±J¹¬4-:ƒ¿­ûÒ:õÜÑ©#E Qµx$nÅ•£:•éÜ:ÝmÊÍD£NÛÐåO+—‹¤äTã9v:v‹(íEÔRĬ7›}ÝõF3>úß’Ç·üi©Ëó2(-狇ñ™©|…*ÜöǤUJÓ"Í<]ª-Ù‹aЮ&+¢ ‘n­Ã}Sögþ챿òY^}lo9  «O€EýÊå!Jóp‰Öm`¿šwzVâÇZÄU-Hl#xOvuÀÃÉíŲÞ9Sñ¯¤r°Šîä—Îü}=KZTm§ì~ædö€¹¬D,©Ÿ]üOs'.ð»~èV‡¹{E+)Œ¬Ý0X}%YPL'¬9Vá0–cól Q´–»~½5IÔ’æB‡Ò¨”4jØ_Řõ'r<TiW±V–ÈÀX G™CþÁ…¶·ö7ée”-Ô&**WÊ ~W± ä;c}aj ³|‘˜«»Mªð�û}j‘™‚Ök=¾8Œ­žáÔâyÄGmDTÜP�…%Îôµ,gÊé\Ež…ƈ\% ¨Èû¡”Ú4¬ï)ãê¿f.V@éxÊ{—Tz†¾[4¤º6ôgŠóÚs‹^–õÀšÖz¥ú7¿ðjÛ%<và»:¯G¾”—Ó‘Ž +éð¶•fßa¦gÍ5f³_ÜB}D šbšOB:qëàÈÚVGJô©dðð™z£ÙKå OÈÓ~ã †ÙïòÂtÜg"K¬8×0'Ü(§z}<²¡¢'ÊÙpÃnÖ ò‰ürQ¸Þ.‚i y¾k¡ #2aI-¯ïÊŸ*°§-LqTÍ•4\7¿´¬è{Mý¡ºûïƒrRSx²+:}6ÄóÇz�‘ zˆï”õÖ¥àFi®X†þÍF=ìèmµVÄÙÁà<ÂÞàlfÞL®Û÷ÃŽ­8‹‘ÜwBNƒÇƱ}ô,æo_£/ ¡Óõ¡ý_±”W1¤jÞxú²Ø¾Ô%ç¿j¯_D§»^}¯Ü‘‘$‘oŠÊó5G¼T<­iüýx8%Þl‰)#ç Ÿ¸÷TõéÁ³ ŒÕx²h¡îªI>nR 7k­ûÑÊ[–5¦ ËoP¾ôhL)þäA¸­=Ê%h¿öfj¦ÕW©¡]JŠ?GQZ¹©%Cê,ýÝzIüJ¬HB9cN&Ò¯â¥}866XET–‹Í3b‹«b¤A7XRôvtQxÖi9ø$p=ª>UqïÅõ®ÿ»jÁ)à)¾dÕ .×N²¹©ÕC­ql7Rýü6EÆ`Bf]œ2ôå“•í-Ä2}YŽGÚ<74ÝÖ«[>ÕRs+×’âúðí±TéËœè›h,\×P²êÎ&›ƒNÕªîÆ#¢ÅÅ¿DúzÑ Ôxq­•¥³ØCÓõ»É8À­êÖéñã#Ãù–f¦ErAÒU”Ç”VXDJ‚:ÐîðoÃ9Dîç?7ò©–ÒÑõx1¼û7JÈ€/Ž#’Øhçä&£•N˜¥™ aØvo¼Œt7ŒÛK{YÓýþÆ ÊÏ7˜²š³ î7žFïz7ÿ¡ìÖt›·»Ù´å½ËU=Hæ¢#ÄŸ%0ØbÜPšÐ«B4H-|– ý.€êš˧=|he¯|,{ijÄiLy8«bNÈgUeׄÖûZ™Od3müŽ U·@LLŸ.Õ‚¨ÛÕºº­©ÞÔ÷wÇÅ`Öz”pR­%*%¢ÞŠ[ÓqऄùfxÖÓÞ¥vtžÿJ³ê³ëŒ&Ê^o±¸`poA=LeÞÌX‹ÓÁú®ýøKŒa*[|ph:¤´r'…A€^ÇVfºßð^§#‹q}˜ISöÔ_ö&Z"y0gß"M#_[¸G©çˆÖTèø³«ô;23…œ¹¢R•íu>›šv.[™¨‘”®=@¬9k$ú¦ígÚdñ»V­˜FSTò,‰h%‹m6;+ë­¿÷%Ó`’íœoSË%˜ŠÚ|™|®ã_:œ ;“¶–ÆQ0²i÷Åx¾±= °Ð¸P<á£ú©²·åOÄ pÄ]*l®©wßZzwë¨}¾42kk“÷r•ÓĪ6/± ll¡jmáÎËpoÔ8†ÿÞ�±¢ö·5óð&Étl—&KÃp©»{<°ôãQ7`ÅZbÃí¥OEœ§?Í;¢c·ÙM÷è|IæQKX½ªû.ƒÔ‚H¸…8"ÉnmXºo™�ß]Ÿ¶m;bBˆh7¤°ßx`ø,›Ã`JYaÒ‡ý·¹ðm¨ÛÓ54Jcßj>f×*(>­ ±õEâ`ÛT#à |Ç ,ì0br+ ôš ŒÀ ÚÖ8‰¾$£‰~äÈY¶ìzÎk¤v½Gœ¢uuÚ7P…À¡>˜ˆõˆ}çž½'Ë>ÌôFi3»DîÈ*´ß¸UáëóÜm§ÄÕ =„ˆTµæ>¼â–1ߧGݽtºÇ=LÙ@a ƒì¨Q½¿ @Êm/hU Sê?Èô¸ÓR]ÑÏ°G„‹adK†ú "ê–f;ž!Ƨîr¥æ{0lÏC_€›vÒ°Á¸nm•3ð‡ØÑ~)Ë·¡ŒSZ}öÌíÆîL©ÞrÂÖTŘ²Ñl« ét®œcÚ~bOõ²m_-,\|ª÷û»lÒ|¨¢Çþµ[͇qg 6EŒ¼¦”"¦ U êÀíýàf\¢%�Úo°Mlú–Ál ^j7ýŠít’[¹Á.÷'Š1­aKzçš"“kñß:b«/vl½g2#8ßLiÕŠ¨%.ªö¦G磟1—ôB­ ¹á-VYTCÝ7µÁ/I“H~c£îJ™eêÄ™ZåOºe'Q‘0UýyM,×ÇB¨¤øàÔÄA6+9aq‚aD³i³, Œ‡•Õ÷YJŽrSôRp§®Õü°©‘dÁÇklÕóÌW ‹�úYi¿¶5¤.XÊæAžÁÂb»Gçëí®®0ÚMM‹aÿA!ªø´P7¶öîûœ·3�£›W Êíî=ÅïpÚXs zl‡³©¹÷ñn Èa½éµV¹ÄßÖ UüæžiÛ“Ò wí¢það˜f N:¥jܵ­ê“kÞ£7Ô‰ÀË]ÚLa?âíKd ééuã�¸ô‘h ›=ŸéÙ›uÚñ0ç_ ¥ÿåßßûÕ­™Oéu8yªLŠîNyêðåã ßÒNî†ÝFúðS}Ü> xyÛXÍËoBåRÿñL0¡àèÊýDgäµq¸Ó]£Ê8h ’ð>)z¬d…ÊÉ6 ^:–¡ï»H�¥²´\Þ®n¤S={2ÊvÇRe(Ùíi³ÙimZ8iÎeìEmÕk È ›Sþ~Ý{6.<#%Æ$¬ÎÀé„éج¹¥3’„°•ÊØ`wqêUÓ&ãf‚c,¹Iv´ËÆ¡<ÐQ|^{%Ϊ8§qÚqjèœñ—·2m¾þΞtzHÙWßÒû7G¯€ì\gy®{:4f{ñ(ç|™Ì¿x¯Ø·8…Œ& "æ’%…±{Êyߌõœ0é/œiî+îBwdB³iö=·X$©©ç÷‚K¬ j9=#%¿ÎïÿÖïôòÞ¥ïr ESZ½)À…µÀEtÓ g‰ê/3•ü­úÒn‘Ê`‘ëžî^[Ûs”:ÊW¡…7å"èn®®§¸Ö9.–6QÉ`Ê°µ°Á2õl4ç~Œ¡L£XÒEÛthÿ×[ÿ?ºK7‰ fPpÃÈ°Z‘®–Oè.L7.Ži�WŸ¬]kðI™z4n/Î\íE/;ûÖB$¤› VUº®½:¯‡çËl ÊþžBµ¨D’F9å¥íÆ8Æã>÷‡œ‡}ûè4w)©Ct!ŠÂ.$¢Ú2~såÎPæ,Î/bX=Ò6R¼”Û•ù m ä αœÔÝ/{•ygž=t®^óÆ´J@') 3d®3UDÌß׋{�S·\"`ßœ(—ζ'ïTY±±å à cw™HÓy>\תY’-¥öt ¶ÖgƒÃ/푯ڋ¾ %' 㣠fD¢¡ÞÜMO²”?‹w.ƒnHƒ²ÖëÞ â˜[’õåËõ–Ô<ؾϲ :é÷¨!— ož�ö1à]ÔÝ8Ôt‡©ä=ÓÇk[û ½Ø¹®«GcI»h£Vv9“}iãØiÐqFÒç)²tØBÈüí–î÷É—ST+œªæohÈ3Ë4Ÿœ:›PÌW{ Û–JÃ)�N0“0ZÛÛ\R/­ÊÅò>ÒgÛzmb^Ýîw#E Ë[UbZI ²™ÝX d¼PU¿ªO}}±ó?Ð×J/Ça§×#tÜl"¬kO×c¬÷ êÈ™xvh/<ý²Å‚zëf£ßz˜¬’Uº¯¼åê¡æ‰ [SM’HÿxiŒ¤–" oz<û>èx@âÌÞÄ·Þò/˜;-ÀôÚtÜP€ûœ‰YKé{ÍN€l‰Žªm;¼G˜Æ¸4våcR�mHGö÷džÒó‚æ6ÖJ3£Ž]ýqe¥QYj‚} L´à³fÜE Ž àt :£­˜á[}¥ ß]gÄQ¼hDR ÜvŠw?€ÝrH…r5k¥,÷¡m¼Å®<qcNéÛ ­ÃÜYm—¥ý¨N÷ìcž‰v–?/c§ø Ò’(s£ÝDI½¶2“Y |J!À\ÿÃc§E‰ÃH#ºÉßÖ®©2Ý.2ŸÃŒb?ÐPe¹…Åd5X%i0¸û ^ í• ³  uíƒè°h0†T–²Jo¦@·hI XwœÙ×ÇÍ‘¸ª|íPÊ:Ãmã!Îx¾—9–aú>¾t+Ïï"ó"irʤû“ßù'ãËJB™ú^ if¾ˆ(óTåèmå‚_÷ÖËöc¨ ½Ü—‰c­UœY}D0öÝ8|²Š3)ºòñüÏŒhw_š5Ì|ý ø'n0HÓT=”M!«©§ˆW£ptW79fb:æ°¢ íé­/ºhb¿[Õ"h õQlcÕ“{ätzV Hl¶pñø¼8ÃZ:;‡~êjÕß$«¹¾¼3ÍÝV–Öêñ±Æ´+j³i(áI¬²f’¶Yx8Ûcwµ»xt®D*•æVÍšµ‡©DÕÇerLÿÆ믤ìbO”š+á=…ªø4{€ Z沜tÚû ]B㤶;R–×Ú›^QvdŒ6‡öb½²%¦ziJOnIÂ…1HHÑ\¢«k¤³µˆæÿ]˾ôJà{.KWWª=¥·ñüéÍ’mýªD0<cƒÃ3.|F°õ¹Â{YÆvXbä´Ö½‹Å’ žTÖŠú0‹·ÄÝÄTz#.å`‰FgO:ŽNŽÕŠÌ{M€ªS€%ïPÊÏôÈRO⋧;»#­ø|ÖÌ×# ‘¥›tçe“G,c(3t*ÂæQ—18T\[mÚyÅÛ¿˜‘áôf±ç#=“7:*c=Ï×.Ç÷U,"§”™š¸¹Ð?@ߦ|ûo@sVÚHRˆîY©`rCfÈøPú1³C£o,Kª¡røp„ø hçÒŠ8aîºÌþ™†gÉM×sÍd =‰†(^ÆÇ-¥Ô§éªø¾ïÐ!‡ðñ /YJ#'mC[3D#+Šh1aY5—nQ9„K„²JÔkÓõ,m nžýóFE¦™ñ9‚6¥¼à–âxl™jîKªI6.:žFdYõÇYJ{4+0!±>j±OúŠ`™Ù·=ÛãÐÎÇt°ðŸHfYví8}  •Xé>¤pâ+ÅNuE¬Â†S«§BùI’:)ƒç‘ ýöÛ¡0ÇCÛÖfíÈßÜÖçî±^å•‚%NkªuaõýíUMÜÚ[Ñê·M{ØMPbpaü › êÍ·»*⣀ñ‰>µ_HUÑ°wÿö5%ÜcG“Px˜hŒMñWŒö«Ðì$w§mõ™éÆY“kp¿ž_¾ŠmOãÅ| „V>•€ÓÅí@1vlg¤ƒ!Æy(¿ÙÛ¥%·¸úѵ¦4èáËð=¤=Q£˜ PŠê¦ÿ½ý —[$±²â#ýàSs5+Ï=4Üî×2»?ô+±Ô©¾H%“P¾›{,%äÓz™R`Eç ÞìÈ¬× pO¨µœ/ôŒMœ½ÍZóè 5!UãQÓa¨6»qå°þºft"9C¿JVÌj]R´›cö~#.M=ßîkçæ¹ôšª`ÈȪt­`L©wkìÚ¨ó;·µnâЮP -l¡ËO ›‹X—½K¾jÆ ÂÎû×ñ\+_ë¶  .:`(*6–2ÐÝ\œýׯµ£ºdx 7·^¦à.‚*Mƒ‡×¥v<lL‹´I¤"ÿfhÃH^³°ÄÙ’›dlLß:|ÅB‰Áû½·^Óæ²ó¹Ä4Dø¶{÷ÄŽ…f ²Ý¹AêýDþ6NnT^jt¬T#ꔺ­÷“¡Yý„'‚KIáo¬ïpì ãi¡xeh­:Ê^ö¯a¶I^MÝÙÙæ8{êÒàÊ3@Gé‰]K›Ò¼HW‡Àû¿ŠÑÁSø¦MÌÍZTpqÑuG.Ñ—ŒÊÛK~÷ZDÔcÈÂ;™4ËNyö¯$<AFúïÜñ¢"3u¶V`sa éÎkíϹ¹µÚj@ld0Ô‡.GMzƻʮéÑÀ[Çí¯AF|΀æ/ʘÏtÝ ‚%¸éÇÞH<„JãÉDC@Ç× ŠZ:´±²|ää{’é–:§7ÞZ¨²Kª·ôÀ¦?ó&V+¬ƒŒC'êOòÈ!Øò©ƒI9ê°³Ò*Γˆn)[ë&1Õ«§bx±Óˆfç6–D ׃¼¯)Iê˜þbz†¿ÕBI²ÅéQ±\ÖÉrÜâ@„iy9é¬ó'ºnt=GjÔïÖ†°g”Í9zvó€@À¼@DÍ»¡=Ñ&ÙÕý#ü¨¬è?Xõã<1òR†Ø S´Ë6k_ZÜmäˆDý)Ç Ø›Ás°ûF*­²«kø)× -ŸˆLwßÍ¢ÿK#7Nä^ëê+’Î"�'„(I7Ö½›IŒ ½¸u@kŨm3¶½ïó,ˆ-M5WOåÄö²¦ Îõ·¶‡þÂ(]{¡Õ\ &E7¿¸Ú„Ü 9À‰+©7n6‡ó0ž€ëË°=X©[‰z7€š{6z‰7x*¨¶GÈzÿqàãi ­Uhe¯q¬²gãh 6\/ ëk §G1Üi±[ðÌáLyN›]gÒXX•*9u?ãð¶ý©Ð|èÔ³Y.¦©Ú‡µ·jY†œÊaiì°:¼0íú—¦öâö¹'™ï€TÒ(òíßÓ…Ö7c-ëÇÃÙõ�âðQ¤¯JF²Ì(}qhäŽÒÓ£NJNáÄ?×õ®µ¨à×㺊/È”ƒVð€\7±hªœgsêӄTÿïC? À—Æ/Ä�(I,V±4›’Òæf4~ܱ£ =€6»hÀ2ºh¶*5‹ød8<sh­×$ ¢„Öie`1ÜX9¯é´FŠ(=ºÉ6‰|®Çn]I¹Hk ×´…„r«½§42|M (>ñ0SøWKq^úSº¬žÎX!o³6€OôÐ%Òx퀒'îŻΠèií6Œƒ†äêÀ~O¡õ?L×c»( «ñônž(Ê8Ôï¬úÜX‹×#Ó­4�‹“jÁ:, @Nñ­Öö�èÊ#Īµ­L»¿éûv3§ºìÖëΈ‘/$É}å¹oÍX¹õ÷”‡ò;çÕCáqRýž‡Ž°y¶ì`ÜF!Ì ¦'Ìlÿf”½½'ÖŸùÞ•¼UK«¥¾kêA´#8ÒS ;6®ox£ýìGvDq¨•Š“®’jQmîÑ^u9Å:0ÿÔ”_h±Â»ögàv-]PÐ †ÌÆ¥÷½Ë¾ºy<ø�‘Ð7—\%qÀFzßúÍ Ã^,ò…©e uí,ß­oEáíÃ7e-(ý×PPnô¬X\j-‚Ò k‡ÈnjHnaµ»AwÌ‚â°òµeè¹ï£ÿTñÑþ´ßQ:èÝ.*=+Nì&œç3Ìûïìrß.r4•Îººb²õp™<t8Á*mÇžoBH $­½'€„éöál‚á|¸âê Œ�líŽòýBã†ÈÍTé¥5åÎL@Ñ°ËYgï²Ï´`Tübëà†ÃƧ¢ÿÂËÁŽEù‹XRJtütZEï´ôêÁzÎÔ<]ìw¦è]]¯ÓÒs»e”0H éd9ža¡ìqö[2â,‹"+"Oåধ÷ú<»tw¢dã J!Ïyjw=ƒ²+]´MO¡*íÖ–› AÒNézž=å´Ü{»yû§*'ž…8K)õ†²\룕‹ŽÈìíT°Ñ‰Ä÷F¨±öê– yœjà˜ëÔ :Ñû§ÜìÙtÚº¢ÜÑx¯¾õ'Ì7êÓ ¨x~5<^¯åÆÞ’fet,€Íc娸%Êâ-¼¨¦d9.}EŽ(\/g¹åÆÔ% êªí(ÄE›­vb£CåÙľÄpŽ|/+žyOÇ”•Odÿ‹²¾ipDá[à©|ÝïLcÊ^-,£½^½ÄÎf Þ®åfBœçЯß(Gù0£$tlÜÅÝ.JœœËBUBQ~{Ve½¯u>%amšæ€Ÿ½­Ç’Úm}vüm'Ä“mýUK�ˆg%r³kè(|½Ï¦›�“Hz@Ã+ijÐÅ›¸TuWK”qä‘2™Î ÕŽ¯X ]ö¸êñ†­þûýØ»]Y§ï™±æú’S&ª´Re:|ݯ°/0Š ML(®¡sƒR)ß>Z¯‚Ÿ¸­¢VËâ~Æ3BÓ�º­&‘¼­D¢Ò×7‚ ØiU­øÜ3%­ÐÛѬÙýÌl²žeü¹sO/I=ùjþØm]1w1øÿ§ŒanCÛÐtCÆ“¨î{ʲ~Ä!ia¹Æ…<«“µèÏZ©©DJÛ ª tâ˜h³õ»ï ì2ËzØ«ÊÌkµ@…~¤�z|×Û— |¡¢{ù‚ÜñŽÉö•Ùv‘ù%*¿mdíYK >�N˜eÁvµ øñ;ٮʕ]M‘øɈl=•0ïÊw@ÉØA‘À©¶2¶¯]«²vW]z¹j<Ä$ˆ“_¯º¶¶fG«-Ò ãöø}ò,óø�t|Ñòm­|§È°3Èž“ÄtÐ*KãÌÓK…2l-ªmí9BjÃX¤íáŠôÞ]É­î)ݽrî6ÚujÙ¡/–z>PÝíKe­ÝSí½ïªÂÙ¤‰kȹM‚d«BJtbÈÜýÆ'}E‰#þ”ü¸�LšŒÎتBHÿÇéÎp66BaúVPÊ)Ùï<ã÷3˜AÓs„mšº.wÉ5ý_:<p:xd#ô˜uÐHµó=¶×Z"EµXÝEÐBÃ4ªg³K©½í4t­õt;¨¯°»ºÓqQ³7é‹°—#„úõÄ:trâvV*å³zâülïèÜÓŸZAÁ'ì´ùEG†îKéa‚j‡òíÁ,÷çÑèä0ß´ó$™<wkC Å­é5gá=ÕJì]Y&^éG¶L2éý—…P°µÈ‚¶- ™G×H'€á´S iµž.KDEaB[ä‰ß®{Dˆ©*æHwiõE§dÔ«%À2ðzØþë±ïjË=Ö×?>Ð|M\ ”>¹,Ïã§÷4zžŽüv…楟^†¢‹ZŠb0KKŽ¦0gTâ’øKKs’’ÈÒ8óTû‹`B;³üî|êÓ\è-«[ÑêC�izq*²6¾rxRÆÚÒ=ȵ¹§ uÁ}5Ÿ—pƃ#¾ÍÇÒŸd«]ÞÊj ¿£#=ßI¦WT½²2¯ViZú†Ò´»oÊ·;§�Útuê÷¦CÍ ê´^ãW(Cú^ü“`|%w“VÙ‚µ‰]x<h*—äì+$åý3§pk¡(C-p_ö´:Š¦·VWà^£KK¨=8Wš]ϥǽþl–>Dîù–ʽr¸¸ZŒsbfPŒ'ä¬G¦°˜QܹSÝð@®�AÁ´õœãÙkÔ£©þ~Œœ, (-Äüµì¿=ø‘ Y½Pq ¹˜ÇYnsXLb ¡É$ŠÈ|ìí¡áCZM4q<?Ú>vÔ©2¯R†Xk•qû2DBUã\mò£¾¬ký³mI„µ›sé*æéç<kó6*ßÍ|sîvµµ®â>±»fØÜ@™QÞú€ÊÓ¤-\¨2ë΂ָšçK²ÍÞs«)¾êÆ/ÿî/;o TtÂ!ÆHÖœ÷øY“xÉ>&e‘¹óÊp¾ê^!:‚ê‰!œÂ@æ:‰e%…WViÛÕï~%_•>ã å*º áx´ ¯¤é¬É ç!í׳&Ê¡õ®4â¥?~DTqÔ(7ì.~—Þ’ 3ª†ç Æ’é¿ÛrTÞ"m?ʱgëå Œþ4öèëïdýÂ+ïf*O°@fŸ?È�UëÏۛ抱­¼?×RGL™�–5Ñ>ýVî¬fŠ@èöz ¿îï G uL¸%ž£¬?Ù†Ô :ñqšú¨^ЃHœÒeýÅq+%g–ðõ+œCc¤ÄQªêd9¸+|;9(±”¼+Ô£àø\ASÕ¯k1mJ•àÉë 4T“q_NÃÔÏ©Bâp‰HC’`µ¦4 ÙÔNï¢E[?êÝ(ñ0v$Å•q"œóF“ù4`Úuý-Ø¡¡žºæò²ï`\y\C–änœÍâ–¯wå'›†HÉ-L¹f×ì¡ ¢÷Ù·>aŸ'SLvG)#]f*û~A¹ó+O,7Õ7*û²?úž(ü7œ Ö E½¥ªEì6/ñC…mkK�Å`¶3Æmóu÷ˆ¤æ¢8~±qjY€Q1Æÿ )‘.˜Cݳ¯šweâǺŒ ¨Ö r«TëÐTXã¾ ÒîÛÓ§hÏ‹Þx(÷5\nT&~ÇrÁù“J8û ŽÉª:R¼EA·oêáƒÇnÞd}¡ Ù”Sj,2VÐÇù¢Uµm5%ÊøÐUBˆ5ein–_M]·c4$f&Ów”ݶ[Ï ÑÍ5úÁý/M<®mÅ­«ˆbn«µ-f³”1ž›•|(ä´oëÐUÜ'žlûC‚QÄ* klË hAÓƒþTw\hœvš-yóÏ`¼ uoÄ" *8‚^(º~±!í¤ÜÂy¢ÈãV3¦'V¿<âö/¥ÚY5Pèð̇6 JjÍÆRõyd¾:Tó¹ ÊO…'@.çý‚«¥öÑ[˜@­WiÊ‘º¾DÜ[ƒg"\HœV,‚Ôº¿¬€Úµ|uà¡ ÿ{/–– 5–¾Ï‚ôØÛT]LŽÒl�ÀK[} íÏÐÖÄ-´Ú�À>o6¦­‹¹g»Ò󈠻ݯ'}0„>Q$9qÞ¿;bÿžÒ:+‹D_iUÿ˜;EAѯÉ(åû”€öÊqÜuÇÚ֙èp+4㡽æLulj‰ y æfÜGã|}ñ1ÎÜ÷]*Óù “K½Wö©Ò~ömF%�d�6/½È°4Ù4Ó¡ÕŽE¿ÈÙs½cóv€ȩ̀¦hhÎ*ýõÏ[¹´áZÄṆ^É_倠¿:ñÄ{qx&Þ]Ã<#hš8Èß{Ï‘m+(L›Âúö˜žÝ»zñÜ=ú­ÇECøKŸ`�bKùïV[Λí¼~··É½±Q”a[zž:¹Õý–1Õ¾£ûiÉö™£÷™e{Ц©»ºÖ¥rZ7V±ÿ‹>fk釉äébÒ0½œc$–*(â<v‹Å…Ùʬ?9ýâ×$z2=ó9 ‘èA\׶ۆÀÜm†u^§¹ó]gnWÈã˜Éx±ó@^«7B©ŒGå¿##iÑa¥×?@k&shœ^`^\l“¼¡7½Œ³UH]zCÕ(Ð×ÔFa:¹F6bY f²¾è/�§YêzvœHåB5€ËØoa×@È 7@oÊ-ññ®>_L¤{vX”Ó†c†ÒPNÑ:ôÆ1ýÚón¡{‹AÐèí××åH«¢\ž ÖïšU«Z½€°¿ÞgñªHT9nñnߤAÜ÷Î0{<MÄß«ÓDÉ#½¯(ös¼þ…*–Ç‹ºã– >:EãGÊa ç#·€/~Ð×[(¸¦¶fØç Pp¿‚Š6bÙh'IœT4ÊN ï ƒ2Útƒ>Äž»]N1’a'ÏâÛv ×ýÀã†[½Ñ$ó]Ï`N»/‚Œe;̓á¹é¸Ûl<'û¾e`Ûô.’ösX6Ôõ§‡9Þ C–¦Ü¤ç€s»©U&ÝR>œ¯Û¦E±ð ,Ù£:ltêBé§ÞÎ4ePmçw©ƒM( ŽÖÒO΂õHÿ«jÕJ¦ÅÍH”^/øîþÒWÉJ §gºPÀêÏÞhã\Ï ‰Ñâ £Û öýßlDÑÿFyOd»…¬`·øKiº E$,%“ö:™jW÷ÜÓ‘y¢(g.2²þ0F*½{º/ÜÿÝyöbôµ¸ïøÌ8BïÂt…8¨\cŽ%(!ÀÂó…!?„#;i¤ÂXæG(È|Z'ìÄÈ•¨õ¸©ôž^¹ ÓA’YYÛ5¢ãÖeˆ&혘fåŒÝ\ïú7Ÿ0øZ¶DFEé@ðhÛ^ý–PîÆÚ Ã¬ûÀ®­Xàx¢PÉNY{s_ã_Ö_ü·s…ù«ôÙ*Ééž©¦sX`•Ùú©C‘;¡qçJêú[+ij†È3ˆ Š´ÃD®ùvJ•XˆÑO¿[3K§v ÿšùFß9«ôû4ÂZlò�‡#+€ì5¡J+…Û½f¢/'§bQ¯êÕN«[W“àuÍ0ª6‡¨„@ÑÃÒ¾øÓÿÓ¤( +#ÔÆ@’À<€†e,Õ& hAËO¶‹¹%”¯Ý9³#Ò—˜stm«âÓ£A‘mTƒ$Õ›“º_þêà¶ô‰82 ÄmKûìÀ¸BB`2¬!wCsyctæö„@?ýä}c¹zÒ€€^DIçi»/T:è°2möWô¢È~ÓÓ±4wz~døx¦w÷cûrõ‘Þ{섆Ñ$�žnÁ6…/›¥ë›óªY÷´®'æåJ ¯BxÈ’E¯? ¶n‹£ÞÿÁvô©ö¨ùá²3¸84XÈ~¢•E‡çìß!0ÖQ-ÊÉ°ÍZ®mg Eô`‰BÈÙeÙªÌÇA2ö_0ü€nS¯.¢ëJ5vi6F›ñjÇíé+Üû[Ì%Ï¢—´ÕúÝÆ›ã³ÛÑ<[3ÚÝq2ª_ôz)ž5Ÿ§ø•4á–Kégì‹[gºœº`—®Õf5#–_AÄžñt`¢óøîAÐð [ñS21ñ÷ô8ó…MPq|U”W)3 7꽦BÂ6X¯Z>óR$ì©dXlÝ`3S¥­˜K¶UɤKgr·îxD%&/ÚÐ×t6ŠBÿHÇÝi² ûÜz'š«[ ]T0Š4Ä' ú+%pm/CË-•e1–‡¾3>2ìgNVî GǤåμouùšÝL¾d%t ÐFÞ®Í}Ç혠Þ;HÑ+4gT—->ÑݵÆzqàɪÙsõÝb~°` 7ÚÎÖÎ8¯F¯ù6« »½~½“û• c–MV«­Î¬ŠœÕÌ që/û‚¸m ç3|.‚øhõ‡r3¡º‡7{ÔÌpšX‘ß´[zhFÇ ÇæäƒÛwÜí'mbK¾pgØvû{¿›x³=&Aõ®ÂTw4Œ+PM+û ±˜ÜRéÞ¿Ñ¿ç€|iëÕa<íoËŸÁ—IÆ„†h3{b/³èÀŠQ&æ×ñBàÅܾD6­¥“²ˆz}ìlóä÷{6KÒ"s Û(á<µUá˜êïÝJ´õœñ©‚QR—ºáæJ ï‡ÔµÊ“YÎ@Ê„—"ÃìRÄù!åÌP;ŠAùù×WDqÆâ\´³£…Uñ$½[ ìYýÙÜ$uŸÈ Òèì_¿[ãx‚‡;)46üÌ?ºúmÁ}'§ÅF1ü`º­íŽ†ÐÑP™ÑLS'ƒ»Wš!U‰DND Îlï Ü›»úx`ª`Eç‘ãµÉ\ÎÊÚ·ãÏp¡Û3õ ªuÛÅÜ8ïûÃlÑÉW¡äQä[ x<¼ªé”)Ï\uxT]« Gç eÖøý$2EYŽ7(öLGz¹ Ü’ÜmGåw@­—j}0B##ðßçwžœ36^$+¬Ož Žp¢„2¯*³\í¾þg¢ÈsAʘbÁ½æÓ3–‚¥4•²Öáõ×Þi¾Ì¥@5[“ÕÊ[È õðMKï¤éùÒ±Oò"}5k3+œ8 ‚ž×°Û=´‘PèLx�ÉzÜxëvë±^ÍOyÿyæ»4ÇÁp„¹_«ðÍ42êÉ&°5ãeØ×gªõ›æl«ûºêÓÛæÌ΋Ÿ$¶S•pÇsCK¿o=±îãÅýoF²Y.¿ÎfÛ±5@C7QF[Ö ’4æÌ.Ì€›_ܱ>Ž«š6.‚} ¯5ÅhdÙRöë7\ä(, Gô‰)Ã.ÞõÍ«H ×ƒïgŽÍ-ïú»?=ìšÝao\I«”îÖÔx¶´«š{M¯WÔÉÜ¢±z –PD_y>ÓlöÛëBÎyî4Iø½ç‘ž@Úm=¼$Æx‡¡ïêÍ©3¼6œ4Ý]J[–¾¢ unpô‘ÞÊ!Ú¾k/*&ýyàÛïÂÔxéz ‘¨}è.#î:îìhA�Œõ^2VPAçmà.ë dȪuÆâl g'9ZõØþÊŸ®÷UÜïœîi¸xlyР!x´yìØŠ+}`ª¦Ã™¶ôJå o “+ÿÇé@-[kn½L¹ff¶3Πl¬nŒñ‡Žg ü›”Vé†ätôz\¦qËŒ ÆpXî{I{$’R|æùõÕëh® } WÐ :ÃVb#zÓ†R©‹@[¯¸)ØQÃn6”0`En=ÃY c‹!ÏÓµÅÿ -ŒiŒ8Î}¨ÀMé±÷šc×=;s 3g¥Í_úíe¢=LÛrÕ]»ÛìP½ºKl­¤ÈœçtVé ÈkE—"âÛnœo´ýŒ§ikDOîÈ!ÄË~#e¦cDÇÞ_»Òï²¢'j¼&¯‹¢ _pË(ehhõdÍƲs¿Æ³)?׺ϢzB¨ªŒDt(R&ý;ßd‘‹ÝyY[#ñ[£‚X ¬9Þ´Þ„{ìÖ}·‚ú&e醃ä®ÇçM°1LZ,ÝG ´tшc6KͺÎs ^׸ÓJ4¾ç’êAD#Ž–ÍÕ÷Ú)PþŠ p0°·¯»Mïg#Òó”¹EB žc¡õ:„ûÐ讎yÒ 5>úVÅZ'æH@!osšt,ëãyÅÜà×îÿ«p“Hæ]îQÎÆmg› ´gÁ1AWN|ä¼P²üݳò©TÝ´ÒhŸNúÑ"òÀÔ‘U®ãì)Øîبܾ¾b£Vjíšq�É‚=…Ö¤·® a(Èàú; «Yè)oFÁnSÕ§¢ �â­Ù„� iúç­0Û >`ª9|IËG¬š3Zú'O:§;^™|¯i¡ãн{T;~úè|“ÆÕ>Š HÝÓз†*ê”å»E/³‡B}‚ ŽPÀ«Ú÷Î 13ÈØ (öYƒ5ÍŠÞLîyÕß}ñ(^Ø lÇÛL,[ñîMÊ1b„JmS•ßSO.)7¢ù?ÇO§±:¡ý¬Ø¤-øú¦ädeî»Ü¦8,}y-Z»cBæ¤fÎþ¨ ë«Hï¨CÃÏ ¦Ç"”½§> ò÷ÎÑêV‡ýÞÒš¹§ÆüSi�ýE(vµDÎm”½–›ð{=Ë\C z Ê3ϼ['Ì‘nö­óZäŽ ´õ“†–�–(Ô‘S h»�Le ®§–ïÍ/¯<öíî!3‡Ì®²Hf¹í«ñ°ž¹Õ³xÙƒoPù9RÆؽ ÐF“<P0MŽw•ïE¡¯œ#¦Ät^ Gy¤Œ8ïd²"bN»ýQ/Û¼'¾(JÊxuB;ösáýÌÕÃHUHÏOJZL°a•¹u·RŽ.±”~#%–Ñöì½ó¹níãøo)¥u¦¢G(Èêv¾Ö!ã%‰ÍkêÔ–˜to)o< :îÉ×­íýâ%³ÔªòszÌÓGIå bKY·õtD­F ˸÷bKˆX…Ý{ÀyUy¼jŠ~PïŽ<]-C3åÈVtŒ^šV‡°<tÜ ‚u’£ºÔ€9â;±j¿ú†ë›=«-ªb»ÉëåÌÂì9#S˜le ü\ý/Sp-ʬÐßP^Ô Ò&+DL"–¸¡ú¹_ɯ£ÿ³#QõIšk:÷2k~ÙÔ—7F½ ?3E™ËÐñ}ÐE¨;¸!*Qå6òÊ9§ŠÏ7ú˜ÉVGøÀd1Pˆ± |Zynÿ‡'%¾5R—f¢¯1ê@ ;Ÿ‚·díÿ¼•±'ÐSw (Œp•‘øú¸·=/d>þÚÒÑñÛsÒ<"Á“ÄþUúˆ|ì¼çbÞg jÂ:±®uð¢,€úŸ7ómb)\LZ�4Žý1žh‘G`ºÐ ­]—*9VfHÝ_Ãõˆ›û—vjàQQØʨI é;yƒ®i>Q c“ù× ÁÈ‚Ž"ÓÀ7ôuÓQÛP>3Âc×OoF¼¡ÛljQc…Ú÷£>:ÿZ¸`,£¶ð É6=Ì ¦gš¯cMŸaBÿ3O*ä7ûÄSäìd ôÉö×£ãû.ˆ]‹DXbþbÿ’Ò/âÔG¥íy´_PH°lÔÿ%£&)*_9 j¾ªžóõÅ<‹"P—/QË䨼æag~þ€4Î}RšA­ þºÁ+HÁ7ãùšØâó³¿ü›)¢´w�óÂL±…æ¸-ƒÐj…§æü”?qøž»Öü;CkÙÏ*'”Ï ”l˜˜g^D±è âΘ‰*s¿èšYÁq5J¡¨ZÑÉ°Q·²¢¾¹ù<TäÌL³@¦© ¸Ð;É ìKs†å¦ne]ÇÃnð`%Z¡FÒÁaÑ JE¿­M4XÕî±8·ß m Ç°C-�& øãÉÂóXk ¤µ¿D¹Z}°Ðh¯í?’ «Ož:#Æ‘58ƒkõvþßD·82µèªÆ¬Uš¿bT HÀ`£æÓ¦zè ¦•È£Vë2DŸŽÃM‘ålÁ_˜ˆ]Ž´|—ã–ÖE[¿­.t)3¿÷+_u"7ÞotR¥Aõ®´¢JV:Œ°:ýƒŽ&'j-0ÛŒ†A6½;½'î*Öãžç’è†p*«öf'½$ƒ—Ež49õ>fd'ïiðeðüÞþ‹rv”x#W:"KO_ž/B¨Ä³:诓‰²½­löÐ¥°áÖb•e•CÓãK hûžÚí¡ûyí‘ŽT=kš!¶æ�åxcæÆí¯ª¢èÿÒÔù£ÆÝ™íIÿ@aÝ iƒÚ®ŸDÈÇ\P2ÎzÃK{ݪôõ ÂXìDâþäYø2£KRÀÓØ0ðÿ—†"±¹’~ÊöH±¸^{¶D”-Q ´¯•¤ÖÕ«ƒR‰?ȉ Ît‡†£>ÑïäîïÞñCQd;•wªMd–eyâÚK¿».tª(ù»˜¡ß¨“!¾[Ür”³ìØ8^–GÎs�‹Å5ÝŠ¨Ï<H>­âX†xEÇ®LÕ%1u¯©}ÖY–TɆmq»¶HÌÆ ^´¼¹¥ öÌÚüëÇÝçž›£ÂphìÞH¶íì¬øL‡ûsæší k1ŒÁs¸µP"˜×Ö듚dî%áÄ…n"m‡3Ý—Êá'‚€ŽÂ-ª`¹žyF Bý»MmïÞ'^¢Æ¼ÍÌý”#¦™Å09mͳÚfëè¦ìòï&šETE‘IEÑẩÉhã¦9}v'C§‡oO[…<ÿC ê« ÜþñÂ…¸=`l  :2;z†W?>ßǪÏ(Æ{PÝVAÑø26žX0 ¢âIöåÍ I—?1©+ôª¤Óô™¿¿×ã:·rMn)*ýX\:É&šküVv€…ƒåDçŠt!ŒÂ ƒò ÿYò×ÊÁ‡¹†n¿)ݲÚtÑÄ㈽[×ßSéÍD²úïg ;¿,èûÎóªÏ2}â 7΀ÇiѯP±Ý×íaã_nÎôÄ)-ÒWO±/5ªcûŽíÅ/6DΡ_àî’rÙ™‡§}EçÕV‡ò©%¬ÒR;ôGå÷Ž»Õv€ œ¹ø! ISG_,Ø{Záy»ö(æ<¶x3Á€]¡±{žéYV¡ ¤À*,¨n8*l›(½g:·×³Ñ¢üÑÊ8ZÈý!ͬ)©/‹“AZð¼Óÿ×H´vgÆ8jªscÖ5y4ãk™¾¡>2¢Æbd²žÏî¢Ò kxøÅMs±ë·‡£Éš¯Uß~úYWTœ]¹ƒ›¢Ü›²£¨ßÌ€·øÇÀΨ·W:­»ù…Ó02¹-„À)4·³µ*oñ 3TSíA]‰?÷®Äf†¦&]}Œ¾n=Ui´b(…ÚkM:œZî˜Æ› IߺölXÉ Ö‰ÏNXy³Iƒâ¤%#ÖtÀm v˜J�‰f„|Ñfò/!.)mKæÐÇN;e·dØrÓ‘JÊɇ®ý Ží²œÈýJÀ8Êïk »Oû{hÚ‡Ý�-##µ(ÆÔÓÔˆ2±P7T½ó?gúpV´*Ï>¥gd¦ªr�«xóXú&ö,¸„æ ½õ¤×Æo Ž+¬{H@[Õ˜1þsöd9¢ðK- Ò÷o` {b·{ž[ ?tDŽâÒõÕXœeèèq†k‘!•I㶹x£�^Z€òßÏ韃“ÈM¡¯ÖgAnç´,8Ö‚B&‹æ¬½ÐSAgÍUž¸UM3”âz-ü*yZû@ÂÙ‰¥†tß×@cÕ¿(1,«;É“]hŽOäɽʼnC7§Œ™ÝNéyjí³¸N°e9Ÿ®æ_ys?Õ¾J»­9u¡òê]TñFL”å `GSCSÎË•}‘FjPýÍí D‹£G�¥:ÀùN¾¦øZ<¶Zëp„ )ÂÕ¯”•ãPÛ±ØØÓß‹7“IRºvCCÊ1}È,õþÌbò‘˜ËàÅ6 -Ù0SÑϯ"¨úÆóþBJ"õÔ‡•Í‚0¿83¡šûÂKµXªŸºoÌÞÚå•ìX:L[ÐÊÞ;Ýš+!bçìŠz¤æ5%®ÛÖ3K—O 4>ƒõƒ¹“ÉŸ¾žÇŽ¾†¾`­8º¥@ÜÇM‚¤Q‰Ôɵ˜Ñðõ«mNX Ltµé õÚõ Øé@QžÚ‰°jBÓþþ²ÓÂaΧaü[§.HOªQœ.„(B‡&ë¢ó˜¸ñ.Ö2U¥_ìêÕèà ïÙ¦šÁôw3îvçôîmëewí‰vÁà0þ;u xÍàÒ¹˜ˆ)ZÈô¶Å¤w¾,™17HÖF١涓™ܼú¤þÒpÉX 3jÔ¬ÍÄSžtÊÆû`¥_ŒÂÛù³Rg”¡GO lûÜB{ûÇCH2-¤›€G.è[oZåþ@ÌÍëMœz6·k4lèã·1¼éÍ"ÒU[‚‹Ñe„ÿÞÕ"íüAU_vGúù¸q“#øPSH¯7r{Æîâ:V0N5 EA×x(›82]±:O5…Âxþ6ÅT÷ð]1bdÍ06(ÜsQù6×=Tƒ Ÿÿ„×Na¶ùš¬Ç:Úv=Ú2&¬ëÝF¬ôb>Œ «{ò‹‡¬‹Øg™îÉù‹²»ÉÚ8¨v½HHÙϱ§~EV¶# ‹¢F·£|÷ÄÐ?OæG ¨»—ô¶ò 23ì1,.Ú&Cò[¯ØÓM^`ÍÑÍê¾¹cüàDôÌ+™€Ö…;A¼Ý£×Ó<Âݶ«é1£ë±… Q ´Ó»šuaè»Ò60Ö³”z 厨¾}¡N/ªmÄáÞ[Éá¢p#ì!„#ÛJƘ<Û—vBåY+ÞŠ¤?3VÌ ŸôAˆÂ�ê3³ŒÐûa;LZ}˜Êügîu–ynÓ©(°SˆH¨d ø¾7ÜHa3tfY{ýðaƒÂûXñ‚jááFAuRâc Á£ö°?M¢ì.!ms8õ+È÷.xðd‹<ó\€¸‰˜e£½²Rhˆð’2b ?ÀBõG™…Îë*HÞíùñ~TÝP£-”ô(Þ|t”­ŒbñHø:õMï+æ‹oAÂQØZúôV½â˜%'zåÚ†ÊBÁX’Q*†¥h1u¢ ì$iøPý‘ü…ÁÐÌ Aå>{a¾g‰|¯%ü>Íâï%/åN ,d¶“§%Êt Íß·'ø‹¸ñžBÝý¢µAUs‹‚ü¸‰á¨cECxmVõ ŽþVKðJš.Ʊ¹ Åb;7üÂ\㿸ˆÔ›WR .Æ>\ت$BT¥ŒÄœ¼šøŒüòè~ë]݆¯ÌC°Æ4$eï"Y‘ΦgR;y]øÃŽ¹ìæõN¶žÅî,e‡6’œ¾­E›tøµë9_ßéèã?ŠHùÖ;Žàšƒ÷púúxfjõ¸è—JXäò^’7[þä Y *' 6§Œö×釆�N<²!ÿÞ,!‡/Mý5Ÿ¡+8(C1ÁFºûî<nõõÅ.taÛC(Qd•†+E¸Õ‡*1<R/�J^ …® CÖô©T”Ì"­ÞqôTãÎzÇýÞâF¤ µÙAam °–~N:e†hËÙ™„…Ÿ›z–A'½–tÆ"Uà8§Psh(ç›>Œ³OŠypí3oÆ) óikWaÂ}HZ»BΣŠXFõÛîßéÐ#Ü&Ž“ =øŹ õZ'ÕôÇëC~ž4™Àó[2Xq£ñ #ØFƒ/ÛýÔß ÍN˜&ìJŒê 7@Ÿeˆ¢tq˜`67@Š¿uaž]N½ÍWï5NžšSU‹ï’ˆPAuRõkº»'Õ4/¤Ê…VÞúU웥Ð鱂þhGf’nHƒM X¨Ëá˜9Ó,vyË(ðÔêÄtÆ åðééîÓgøögW£iÁ¿hÞ•¾›�¯ø*È.Vå7‚õ1¶Ð¥SÍãF™ ªVèÞÿ‘ƒÿÍ_º÷§ ?ÏÌ̆÷¯¦@ªx;vTKŒ;öQ´5\þºïY6 UÒ{½u´ÂêÒˆ8ý bëZ(Ö¦ž¹9­é]ßØó© v†™§â½áº Ò©VÈOõ0-¹¸šn%Âylq‰¡Uß À\-Z»YäIÙ”ÈÈÇMDëwÈ4㥆]»Ul?ù5No Ç|Na¨ŠÌãRx8$E¿Ö'P,‰§áùÿÞúî0`ôÎbc Êßù¶Î¯B™îv££F»fOeØ Ï~:AùWÔëzï‹2ÉS¶¿döñ~…TwyC;•Še½³ xŸ<Ι©ƒ•…[Ëî¼Rò.Ã8<âTV³¦b\fGyÃlM|§­ižl-Jê•Í‘U–£ŒJ’–kù+í’Eu ì$ÛøõÀ ‹R»'"9:†2HvU‰|»À¡­ký£‚¾fDþ]>Y'Ý¥vGøìEkµq"ž‡þ/¤ ‹ÔÅ+nmN0KíþxR³GJ,F†ƒ¬g³Ì¯^œâ{èéý2ðd€–s¸Ñn’QWÎðî:Ô­‘Y‰Û£FžM #¡ò¢_˜1žÀÄŠ&UY¯o^ÑS ú§(MpááþêL?¶ƒ)Ƴ8¼V×E/ö¬ZÇœã(ôÒqF,MûáµÔdláQ|„ƒþy(â}VC«Ùm6}œnqýS¾Xx´ ¶PÛSñX«*+_pd•Æ‰'tEie½?ÑÁtà¨r¢ÿŠnE•ë+–˜O´@fĬ™(!úVÐõ×2—÷/KÓ¬”Sê×[(öÎ/¯˜ÉUt2¯k#AÖÁ7C³7ñÁø‹ÇæuwÅAîfß%AbE£˜õ+OƒÖε”ˆ-í }ЊÇYx=ýJ ßy•Îî퉶PåôŽSõ ·ÚZ”{Ó £ØŠ‹ª\—£=ü<(Ta¼GÈ[dã§k6°`=$ÃÅ"uªÏH{¶§a6öŽîÒ0ô±<;oÒ‰”(h/ð-i5I@lOãÁ´|?v…UÅáåO@[)Hãæë8b‰|ZËÜþ©µÓÏÏ•éÕrþ󖾃î?4xŽ×zA¹Wa²€ô|Žy.b$À*Cë®÷f`†P/–MÞåkE&»ÓY’÷ûbV«°\|$;''„kS­«×=s¹c” oN05=æã¯w£@]ƒµ4i à2^õ'# °HN¢v+0ÔEb*j~-àIÚôC*—™W¬…¤cÃxîƒ,S; ¼Þú7×tZžÿÝ ÿ®ñ8§×~ã ”¤ô="ÖœÙÐÖ)>å7ŸÚXª0B*稑¹_Ó#âTúÌB Œ½ù™Ò•y^e±¬qø@¼«þ•±ùàµÆÏ«ðЗO˜tYá Ζ¶§g”wÍ¿¬(4_&óï=ßØȶî¹4äNfIð¬v÷�¬còûæ`ë†_û¶×Ü×ضiâ:#RNo‘};kŒFS;3±ÚX…lxAã² €“ûvê%@«kgØýw®|?!K ë‚…Ž“ZÑnò;"øˆçõŒ}ïx¶Y:O0ûZ+ 2ÚØF¡ÀzV¶´¢eOQÁŒ'f^éÔ«Ñ>ºQL] â�¢:lЪxFŦ’ãÑh<joW…˜q‡êyKòd¼ŸÊ Z¿†d‚¢Q¯è»®Ì¿w€²^ã¦`Ë©‰á:•­Ü0íÚÔ@´¼{+c�îÞýÁ߈SИmw’Bæñ@mvÒ²÷k·¡‹I­8E6ÖUîê98<Jb“<)÷ €°hP@Ô·‡î8ŸÓÛð×°ek"¥s к1‰m’7ájaìÚñÄZ$#Ý©Ñ×TsXgºŽ¾Íƒ|¾xU4†ëÚê—*þ&ªvM·‚+à`Bš`¾¼‡Î�0KH8]®« ú´8Làhm­ô_Xøzsúz7¼9ˆÈÜ™‚”ü V¬I±„lGÛ›ÈxÝÀØÂ0ù=×XÏ|ÓW~ .k–/dA,ë! â®qp”*¤…™±­ÃÈ1'µÜ©N<<næržÃ+o›y¢Z3Κ%2Çh7Y?&‰¡*y•ýŸáoz5-nû‚JÃwCf$èªãE÷zžÌ2‘ \eÍ‚^¾˜·J\ó<xUN3­Ê’[1Z&P �áÈä¼4×ÔÆuÄrxRŽÀY¢¸ã9žŽò¹.Î幎]§4u¯"“Ô—«¥#øÀ“ÁŠÃ R3KHukÝ(@¼ßÑ}ƒùÏ5ÌΑX cà -rS«,ƒÇDÁ .ÿRÁ#ÒYtÐaì¼5´af•_´¬òy|?œK…óT.ÀúBYÙtñ”$lïÙ=PûPê,ô™cPmkñ?¸Œl¡îµA/îB7¯KÚF¸P²Af5P‰w¶šà)²a 9'P ;CMùö¬C;úc¤ÈYЯx@%‰rÈÐE"Öþ¶ÙÑ‹ã«iý¸›)-ƒø}ë9*Ÿ!ɪÙÀ�ê!ÅIþ¤ºT¤‹A;=¸·ê  æ­¨Ü#sTçA•1¢<VÃã?æ“·Œ•ŠúÉï8/}c ªmzœ•$!œy²‚#êpÖö_#{ê7ƒ¨Êk»³ô”Sh9E…Õñ5¬ÏÜøxõ<IÃ…Y¼ØÐ&Ý~:GW:ž@)2O”ŠÉIÉaæ’\‹9M‡¨¤\rp®P´Îê i®-þëI£óѪŒüþ¸¥œ9@-›9ª!:2Cöêõꉧٕ|l1Š¦så±öôøàý=^ ñ@ú,°l7t¬¿«Ìe,º…³¨W*Ã}ÜE e<0Vøö�tÞÜla‰òŠ¶“ŠÄ#¥ë’:´.ÿy£jSÚip'tîýÔrO‘%õâÿ¹éiàû`à¨ÈŽ§õšþô´Tþ{Yö m1Iìsi‡XO—ÈXMµ}¤/*î MÏ•-T� „û§Kµ ÔþBöH'd«£6øCX= ó8ãÑüÏÝÕcó1ÛΦ Å}¡£% Æ,™6Ù©;Ú£>«¦Š,ôqUì×ò ²®»twYû¹v&H!*~ÜAúå4p:ªw ·3º$õ@¶ ¸ìOýk#WFÈ×µŒ:sP5§?ê_äÙœ%û[Ýc5šÌ2¤rLâp0­™épJð’v×"1­˜„ò}íu}(a†ãouÿ’Ìݳˆ[,—6UÓ;íýi·?NÐýÄV`“+Ú§¼ZkFuæoÚ²©Ç=d§ð}RU¯š®Ü5?aò©Ý,spm™›ê÷å'溷;«$óŒÛšCrõÝ0†MÁ£ŸÑžs"S«º–ÇNA@…Ù>…X'†X‰à°{9ɾk´ÐÝ(A¿�¼N©†‰üdìÇqæ5o($ð£g×Y×»ñ ncfL™-Γë×Mu­£Ä¤<Â_š&öçžjÌÆp9Û{ÝÑèàQ.Ĉ+Êy+Šfž BßMýÎæ@"šhÿ¹ûŒ‹tá Cµüª¶²£°c¤�¾:ï!ÜçâsǶ0Á½2‚òð@JÏ X>v]^‹Úƒø~*y"ø±%§˜Ÿ€‘I\9_§XX|1ýÁOÍ:קqØŒ·=ÍÉõ»!TÂwbÞGiÒ•keRù>‚¾F·Å†“@1X”3èñ´íÇí¥—àp„^µq¥ð~ðUgl ¤dU[‹ASúv½"~H„‰¬„‰|\V^)(ÊÖ„Î2&ç4NNwk‡éÐï(lÜÙfÞ %\R äÑ©uí©çQ¤cÉ›(}Ÿñ%Cª"rY3û+±àg_‰e¢\Ϩ+Xä~Ù ðW<‡ÑTíñ/|ÍéÂäèó�³ Ï챯ϦDŸYœÛ+#­*E‚KÆ*X‡F9ƒÛ°‘µU®6Ì™ñÛ¬gLzñ±£Š~ò%Ÿq«8`ÿóV�ïÌϵSáùÒ˜ÆÛaò^®ºK®s"=eú2YuzˆckáV©-¢ØW9mÒW¼²ªŽýÇœåй#VP 9ô46 ƒµ/J…žœ"ÃT¶cuc}±ëÙnUò+£n>!º%ppñ¯Ÿ'Z\.C°èæQÒ›‰•x‹M5È|xëXÙOvsÒš?¾Õ'¤@qUKmK±Gwj4†VÛ"HGeH¦œX_”^ 2Ù‰€Ü$ ua.Vïž.‹Ìlkz'«üSfRÜÀfHyÍ< Ó—[»û8ôQæHö¦0(ûÎm‰Mí Gx©réd±Oغ´vý:•“¨4À˜sK÷ú¨‘±&õ¨í1z¸ßNVk¤L àmã·…–Ûx›of¹—or×8Wts6ŠµFqyø桨óTµÃzºùA;Þí3ªXw8×ގ嶌.ŒS`Ç–ºz•i! ÃÝn\âÉ4 ¦ûNÒ ú܆ƒp1EvM÷&»»Cl¥î]J»¤GaUz~ºa›©ʱVÕ½Œå,†ƒÅ¸F4êõ <ó,P˜ò:ÒŒxlñ«ínO…ï„DïlYø[Àß}À± –`‘éY!5¥âOg¨À)t&KŒÓYÌž%ÂòXÌêzÜÈ{ £4É|%>zàçUÜPhÕy{=RÉgÀ ÙÛ¿oê= G ©[®ìç5Ô¢XKc áÛ#­§£¶H!ÇF¤Ëo�_uLªE/ÈæDÅRºÕ’¼³¦œkt2ï_»q³Cq+“Ÿñ4 Êý=ÉI;È‹Œ»ä’£"9ÐÝå2Ò€½Ì ût<²º@¼, ”…vN¸ÓþÞn<¯'î~˜G}¨?ؘ^^ÆûJÚ“*ÉqV³éýqöRT|:õþ•á}–,hßðS+b¶D7Í@VAW[ß’²|Ö3sø>8MK{°æÞþ#2¯EMâ瓃8ÕìqJéãëmÆÈ÷7û¡m]E§™²Yº9F„c÷0Œ: r¨.|PÆëBŠçÒÝ•–Û£7LÃì EÍ\‹äS…Å0ÜiꉖÎ,g‰v^l^0´½Ð·úc£€Ð„Mé©øŠUçûÃÆ xbs{}¯X»¶ŽZ}%±af§›Rcš¡¼‰ ß­®Þ›Êg¢@kþ K®A$šív^ËéCí Ûž¹Ám ÍZI¯læ[-†m@ Ã,­ÕŽ L6»ãdš=;eš^é¯~¼ÓÈÏÃÌ)§\­í²<ˆkg"Ÿ#)£ÂMkª¾ÛàŽz<ëï) |¬ÚÎßp> ™rísB;X/ºb«nš\ªx0EÚk4qâ�¨œyŽGÔ2L{£èöÄäÁôŸñCí™t`¹çþ1c}\[I&A<óÄ@ÛUÝ‘"¯ÿ/g/w4Ž˜«óÁùã¡ÓMÂjÈ;S[ˆ¦ 7÷[)äËQ\Hû€aU“'±¿i-B½ÎýÎèo­OýÝÌÚ¢‰ÖÝ£¡Ë…-[Äü«ÊÚRƒ ¤Ä‚¦Ž~ÍБˆØJ>¼˜ÊÀ)7…•ö0‚u×ï¾Á5î”&C«»f׉{´™Ø^CPÙYËB…KáÉ—µ‚ÊÏ••“Ô÷fË Ø’ ^cðȺÛ2Ìýo–Uå¤kXênžò Ü´Ð ð{/|vÊ_¼2z»vU‹¿ ÛËÉï—ˆô‘¯Ç3}= ¢F+Јq ¿ÞkÀ=ã«;9ewM„ G¥°q:=/g§ðz{/öjVhò*ˆfÝ`_ݦSâ÷¼ûÚ1’ŸRƒ€ZÞÑ7 Iv…‚}:¬õp¤Gú,¦}E~‘H]V™ç(MÛk[Óû׊Ÿ‚€Pm!|röeÞï¡«¥¸}€_Ëù<­]ÄÖZ§8·5O«­Z¡ÉÿÌ™3Ü‘*+C¿°ÏƒcO±Â5F®)ý>õkU½üÚI3Ì]ñ _–fUè˘ÂÚái£þ´Ht¦Z‹‰:“Ç~»ò3¼¢(5½`µž×iÌç1˽^Ó@“lé'í Øê¤ê=v.ƒd<Zž}ª™‘pàÒùÛMÅ‹^ú¦ô™™Í±E·&F;׫ < TW?Ê(ÿšÃe™?ä;+ƒ´=y<›¶¨"6Âc7ü¡4hyÁäIßÕ4÷®˜§[¨pëðØ$ßlm6ýó–j­´÷¾Í‹X÷<»‚O@ž¬…YqÖbÑ]¼ &iyΙÑx:QNÔüñè“ÜÛÿ<¡&�ûÓ²ï|á#í¹è¡Þ"Äòl) 1ѶÈ>m×?†’Cy›–ùq’»…[!ö°QL³õDƒéxñ:å„2 Í.ÚçŽr¶ê‰Cµ”„2 ´BÇ7ºæ^qHnjŸ»Äœ”åO‘áËÔžÁíö°“"O àŸœ§F½/|>÷Ú«1ì#بð <#N°éDœ4Y,Okã¼GWj¦´­î×#ƒ¥Ô‘+¼µËf•ÍþäéêMÛwê¤%þLýç5- PÕ݈딃j›AŽtÚíQ0D—ëÄõ2…*%qëèþG£s[W¬„2bð[¶žóÓ¶þ”ûè˜ÌŽ3c‘ø¹ç™áŠ^a¦‰…’]µ‘Ñó÷À¿3Pòµ Yfms¢÷Ì.“gê VôŒJ‹È»¼O/±Ú°b8HÏ};¦AåÎÍB¼º[È1©ÒœvîhèG¹×pÁÿG ‚�µgoÛA¿YÍaYùwAŒ¼ù¼QèûUEÐ8LƒÜh\SV¸ëœ³þN`Ub3¨E‚:8e‰íxjàó+5àK±µNæ!í>6oÛŽ~{ R«'òå;·ý¿ŸáŲ LKiÛ–A8ÿñþD`£xô±?èO2ù„V›lÁï1¹…ùg¥ßc£÷Û‹Û§'[ØîhY"–o¡'j·ò|Çç’ l"䄱“…~l´T×Æ­eqUªÕ¨·D»îâÜÉX“wšým{Pñj+äÈ[™ÎÐ. ªÏ£'Öìîr§œ}€‹ÂôÊCfs¢5¶GÔÍn˜‰ÜÐóRá×^_È"&n¢/§ÕWRåñÝ«1™ÏÓN"‹U¿@e/ú?*bXÛÜØH%65í»²×^¡H,ªàŸw½iì`£ó`wÉËÇ}|ÊO”®ÇÖz‡oúNbÚÄXäÐAXßü]ˆþ[ó£k¶@wE±±&§wO©"ntߌ°÷o„XcÊè°÷¨EÍD[-ïjïDèé˜?œÕÝ2ëJt1C›ßé -<îY¿û®‚¼^Û²m7ö]mQ%µBËŽ0 ­A{½Í/õ{z§I¶˜¨gHÉiÙiEÿEÓøôDø<ÑuÝÌ&å^v.vœF˜%¸=•A56¨ ®Œ'¡OÃP {-;W?ýGˆó¾%4•ÇŽjЭ}ZÇ]?°@oJ›¡‹,~âÇ_Âò)\`ñ"ÎvãÑÊ/cÎËÁ@´™)™à2v­Y2wÚÖIìÛ jš+‚,ïz Û§pÛ¤ðíW1…£²½ÏfÎ:†a×ïj•ø©'†D}ýÑ™±¥±áïû¼V^R"þr=eTÇÓ¢÷zÄSÁÂkîçf°Ä'¾ÐvK¡\ˆÎ§¿é)uíΊå¾lËçËÌsY¾ZÇh)¿{Õþ¾†MÈ|˜¶¦˜}$ÇàÉ2Ä¥?aò2È¿O|¾>|{N+s-ɹEÁ6ø×È®ØkèsöÓÖ´+ÞÏÇÅÀŠòT»ŽÚÚÔ«öBa>ÙˆAgJ3]Z€fÞáÜk&¸±ª'úú@¡¾P+h•;ê�ßnºO‰c­ÐHiD2Šub[Z§*@ëÞzŽÞkgNACüÎ8üÒæä€æ§Zc]‚©³—­!01H«CD¶Q ÒÒ¼ë?ôW‡ ”$löú>ÍÅ(89û=Oɪâô€$V‰J«>ÔïµYÌ vp³ðÁ+ÿh¶hÇ ´rãµíi#ß{nJã<õ¬Â¡Ä°×X>é²4 Oœ‘eÎ"‚Œ¢GÇ¡$cHò^4Xͳ@(óþÁ1ùc¤(4¹Ùgãyý0O{{` ÐÓH¥d£Éüc¦–-ºØô±ÎS”ŸÚÄÞÒÞ›"bs(‡|9 ×½±•¤ƒnÂ㶯×Îo>Ô96lÄŸß>^’ŽÍ™ÉõÎ:^ðx& –Þ%3]z�ìÞÏzçÆS´yL8~Ù·W›{‘ 2Ieófh[M´qFZË þ.ób±š2XÞ†Aâd!KèíkÛÜà •½»<ýoÍ2Gk CwõÁ·GaÄÔÁšÜ«I{qCDó3Cs�fº?¹üÇQèÌ“Ü@wt²aò»‰4Ë–¾!ç ÃskÇéëZ3PvhT—Ž 9Ìï]Ýô SÏ©ç, n?#˜H³IOSh¯ÕZC`ç0"ßàþ¥×’6"Rë.ÛÈ©`Ê="þH" †Û�ÁÜ8Ž})):½wGz&q§Ç¬øžó4�0ÃcùÊó®ÝŸð€,•Kù‹nZ˜f>Ú�[ø’å¸öù‡#ê,ݽbr+l¼GÃ<¾r'˜:<æí·-¤XßÂÚ”sP4«u6uÕ¶íλéÁ6´ÏW4JætŸ­*Ià”iàºÁíCí°Íç®3¦ MÇ›U64ÿþÇé­o¸È2®ÓR÷Ü›™|i™Še¢¿åÛÅq¸Tçžk:ØRF>d¨·à¨Û®jª©¦j؃c³5 ¹]­C?éƃŠôÅ<óÚ …YŽ{7ò>eáT±-t8§Ó´Ò;çIy;:M¯Àþ¢èÚlv#öš53²00!¨c¨…æI/h ¦nx.š“P½‡žˆi¬êÖµ¤_½÷çñŠPÊ‚âh5¨+þ£*%¿^5…º—#;¨Ñ_ÊŽÚ÷<úug¬EÞ ¾‹˜«CkO»sHœ¥ ]lË4ÁЇ‰‘–ëŠL“;ŽÁ¥;|íú'¶mqå«gA�¼:¿5ÊCC Ó}ÛU¥*oÂî`iz…:*"+Aɳص4M/ÖÇlU½q·j½Þ±Jä’AŒxr‚z¸×%È¢Ø7»…·t•U§:îå�©bgëÄU†co<¤qXÜ ›pHƒ‘¢ERÂ0°á;"«¤´³Ý^…PFá¢6Ö¡ Ò£í˜âKô{goòK³ö8U¾È(Ä4E²bü£2è£1|›2iAžß6Ýaܘ/泧c7þ»¯uÄò„åî(k…1räFöQ§Úy<n]¿ÐÅNÂ%á+üFu­eˆEå{Ga­GhY¶lŸ`8ÊÔµ#Lå›-ݤìýdè:?§„ £êÌ@RºÙƒ¥âhŒ %OS¤ö“üíß7J€U]m<\ꞧg0þkþuîYj³æÆñäAeS_¶ÿÃW¥ºÂõõ/V“£:ØSLŠ¶[g4n  æYu+,oŸmùÔ¢º‚Lô(âÁòðB0qÝFµ:‡iw"eÌ–º3žéd‰ï m"<[9 i:ìW}Ÿ–Ýoh§kf—›w…"ò“k¼_šûæÙ¸Ot.†å²U"BGûë¢Ò¯¿QŒL(9€Ž¿?GDJ1„j?‹_‘6ΟÄriª?턉ÇmÇÆéð_æ¥Ñª!ÊT&±ºe#®íîxn…„‰ûÍþ83&G÷¾A´í5E-½ê>[XQ(¹b+O÷Ïß:~Fª¿‡Æ.hufã—ÞÓÞ„çùr¨ˆÌ5dQêy†0“Çg*7\³X£[[=(ʳ»ÿÊ1+Oü7G•»/‚dÔdL"‰Y#©ÐÃ'c9¯…tÝL‚+Êu£ErVlÙh/ànìSTÑlN=ÕXmT±È¸ûµÍâC‹BÀ–]Áž/Î|€V¨q:EÿÿRsóbÑ`ÿQ_3òØz‹`ûf:‘£êjz±P�üï  ÒhøÌ1¡.)ùk=›Z¦/4+©|¤À¹÷+ãAêߨ;¿òÌáscVÙÕÔÚ‚v f²îä¿éÃw³{³ª™×ƒeÎÅ¡ç*-ª£'ÿs‰·¦ë訕±®ÇAŸ‡ j–,[¬]Ÿ=0(N`•ƒElâòÕ±\¹f¢tÀ„RªW7%¢\ѹxŠõj—SaZOfx‘ÎA°EšÃ­¶‡ãц2wQ ûPßT¥¹?‡Ã Ànªá×­;ׇïMøÒ\‹³3@âw=‰Ï.dŲq_Y7y«iMŸf[Ÿ}‘)Ëh{æ–ž…,ËÁs:±€ÌœQÊgÇÿ[M¿(Ã*£©Ø¹ßÔ@¼&zÿ\ŠÞÍ?jnúr| ?[�Z/Ö>>ž¼Õ‰VÍËc ¡Xј"ú‘±XqüýÇñ.ª{CÚ¡B}RÚO"Å‘ËÊŒÀàòåÑÞè2¸)$–]Ê8W§J-³Õ`¾ß ­C;¿‰MÊǘ'M ^3(¿BNR ZÑ;ª]˜³ìH¡0a4óÜ$ÿTyÙEdfó{Š5Õûè¬7¸v0Gïj…äãUåûÉ¡óóØãÖ3›¡(°?î\XD­8o|AùÏJ°.?¤»m‹¶½[›«ÞS¡·×W‹*[Z΋óÒV rÓOB‡«#±ýÎ{)»2¥Û~GA6~/<5owÁÛšrúú›Šº‘áìWÈ ˆÎEl.…RC<iÞ3 ,2øät«iæü6J ×zIcØ_ÁªÄ³dÜœÚZ¹gê°ðÈi!¯?+eƒéB ZÌî(1Y½¡X$s}Øv€µ‡qÑË1h# :r,”H-b¯>Ñ‹r/B9Ú gŸ>V‹ä£ƒ­onEèI¯K©ÉjVøjsP GZÞø©ÎbWæŠ$JPˆ,¾í´Œ)ã­`ö­r4Gô‡^(Q-Ì R*Ø¡aù~1Ç2Ò* ¨–G”2lqXmy­Ýßë¥o™ }ëi¶eò=v_Gñ@:µÃÁ»ZÁnÁü‹A°G‘5Ì^R.†„tg¡hüþ ™·|1{§÷Ì1'ÍU"–´1Ên”÷®"Rÿyë>2lÀ’ht†‘ Dù«ó Œ‡zÃò@_‹"®«¥]ç¡£p¾ÏNfâ¶9!Li+ÞM÷~zhcná.Æì2†"(º/¥¾QC„1ú¼·V\/K\u- *Þ»’ûç®çzìö<çAÌ@ÝÄi–;:nì[²…f=à5†‘V5<¢?âœÞ]^'D0c¨ûÑ<ÍžsûÀ[:âß™qRÆDÓmèüÿð’Fý ‚‚Þ ~ëÇ@ºÜƒi!ck‘è]³™¨òÝJíiñÊ’Veži ÀtvOf)ÚF¥Ýhùe”•ûœþ"B=u½ÖhËûyô#Žé[ÿ"k2„,LþC2ùïœ/Ò¬Ö×Fº¾çj¨Ú)ÃJ<úBRlmR`¦¦Ú<Ô+,ã"bŠù¦Ï(„7?wT>8oÊ gyÛû—· Â$´²€ôùÒ©!.ùíá€b©{ mzßWÐ„Æ §ú_„~YŠþwT7fNр꺯n~sbBWíÔçÕ2t¤„Gu}T­Î~ 4¡�"ïýK½ÄÂ=ØP‘¡?kR (8ñ°é/&3ÝFVt¾°#ðª«ÙõaÍ60GÎ(š­ÎÛFæýݯ´J­±qaGÎz­q0 ÀG3ÍN##ôߨ£hîùîMEçº@sšX¬&oD·¬ró–aSU h¾v…1ÒìYí_ñøza`è (ËV:Àñòž+×1Y±óœB3%—ëÑg&mp“Ñ€öX[Eëþ œG>ø3ô%’¡ó67ë$tí›ïov#þX8<R¸ñ¬d&m“A!ú)‹yÕó %ëïK™"5îø’+dn¶|ç«ÝÖ RÀ_Ž•‰ïb'Š½ôÞu¾‡ v…_NKÀŒ'+ ÿZ*—•‹È‡:¼²áÛ‹€Öí-ûÛËž$¶W±H;ÙUSëÆC3µHäØ!êL'sŠ™dc/nKLƒÉÒñTòhÃÇúy‡ÆîÐHx¼¼e §¬3… †§æä10Nc3cJ@1•?ìKòÝQ©í›ÌÔÝ7Ýï¢Q¥IN› 5z§éŸ{—wÕ™ŠÐGfRð_ÍI}zŽ1ÈþøfïV¬m³ªt£±c½KÅÆ™ËÐø¸bõXUO¾É*úÊIˆ*É»é=^c¶¨#Kú´¤+›;¥<WØOê?j낵LBžó>c%�wà`³Yãá=å\rvhº÷Kƒ µ½Š#“Dk 4zŸ›Q÷ÜO"ón%qûcx·x±Øì¡Í iàÖΑa²["¦îo�z¿…mmÚ9KãÞh :}‰K´ûn³15ÏßéÏÆJX?B¼ B»Ÿk_²Þ­=IŒ³€#íëu³`é5 p˜A%ÛÖ{²ÛúbÓ'NNºh/M÷²…!𒇜ñ’7CÄ=•J/å.:î4õ.õ8MsdKŸýÔ”_(Û=`=Áãq·ê êÆ€ ãq·œ†á~{¤œr3:™‚õ~ù$ØcÈR)2ž)½_¿,E•ËþbFõôeÍjú€3ïmµG~¯M“¼ÊM§&CG‰ö)L ·æ–|ìzŠ›—ïÓî`)Sï?0I,Ë„ýKçÈøïÄaöö7r€�ÜwåE\*8_4À!¡KõøIM›°¤¨Äº´†cÿ2Ú0­\]$Ú Í]½¯sáÅæª!ÊÜhtÿ¬‹œfY¸ÐSå…3Mµ–³‚ã‹?Îp+ Pœ»ýźˆè79[EžL{\Á,> ò~ã3„pK‹Æ\HtÕv¸Éø?<²-“ðªß´és:š•yºf'"St›5ÿÖ_¨ÏãáÔêËíWHK§4Ï^fÛozÏI§Uj¾'œ¨Í䟛ÊØ¢ÚÑJÌ9:m(´œ:Ç}é(“›X«/`î¦ßœ{VÆœúÏË‚iÓÅ O6öÙØÔž�ι±f²}e }x%±ë ±½*“›«÷‹kKpžØÔý‡i_MC a‹¿'9ÛYšv¢ F»š?”VÈÎÿ¤c3Þ(3•ÆyÀù}Ôæ%djèk-¾$w¦qùÀv:Š=m‰–Ö¦/‚ô]»ä‰jh°’•töÀy4çÇã-{~;° V{ ôùx±{,×f$^€‹x«÷bK»"‘b7*ÍzgÃáƪ(ÄŸÉðZÏnò‡rÙþRžaÜ�g¥~o�X³ÙÖÄf÷2Zª9!zn·…‘ûþl–4l² êk§W=c¬.Ö%ÆñÚJ‡x—Š:{þ+$/±Û±ü W_I¿wÞ� {ªÿ_*:šùs‘!¯õ»ç‚ƒázi!§Óžz×KB^q‘û¦R´OX?]{«}}²·§šø‘§H-%Å4ÅA>{6g*֤ߟ$}o%~£Ð¡Å÷¹)è·ŠÂmbžFE%¹•K´Ds~“Ú@czý‹'EYá&õŒ.-3¸º##ÓŸR0 ŒòÌHá1*-ò<šEQ‡2‹|ÖXæPI5Ö¯„žkÄ”©T)؜Ҝ©E ×G)r¡7ÀnÓW º¯Ð-…Ë#øéé´‚µBÜLƤÇýŒ©[s­°ˆaeC®$ªçº ceÉØí»^!'çDÔqÄŠÉ\/Ý ä:‘•ÆU@†ª5ÀŠí÷v+³é/¯hí•6ñÎ1ì™ã š—âb®÷Æ"{T%_ÌzâNÂ_y$î–2~‚ÆÛI<Iƒˆºø RþzÀ™«æ®®ÇM¹‚å’U0a¢TÆ‘6̉±£¶?Œãn2"Ú¬ª|óºì[m눳[*²AØŒë•Ä,>iÚ/ùšVa_Z¥PxA•›¾{ƒPÊ`éë‹ÔÁÄR–“h~üíͯlIxLÇŽËÉÁŠEž“¡Ä5Û]è°jKAyrâµ/õõ`-T)Ïú8ª Œ¹·(ÇÂx>eðóE^ [ÖVS‡¯I‹<óš {¤AÖn¼ñ:›ï M@Ø;¸—7h~έ4[$ƒTEýd3'5û¢bª¬Y1d1pfoÀÀ¨#ñRY ˜EpÃcìž1Œ oÍBu4˜?Ó tÞÈ@J‘S\Ù=æé8¾xeÔ®†sÖ_{fÂf¬†u’óŽë&¤•Æñö©ò^’.‰@0¦§ ÐØ=\$úª4¦Ø®çW84Ãa”läÝ¢ŸÝ†ã¶ZûÖ^è³2§ï›Ï«We"hØL�X‚œÎñèa­è.`~hØ(6.‹²æïT7CÏU8BnÖ2"vk×\,¬¸ƒiu„dý2B5ñ*BÙõ JBE4®.íæеl[h;Á@dp:O±îØÕK”Féj n<œ©Tøî­únÁ­Þ"JxÅÀ"MQÒì™ì·aq¶£¢ýZPÝ3[lX¤fõÓá‚Ãîñ¦Íb™â±#Ç"¦tÚzÅÙCy×Ý^šúOT”²"ó&0¹Ë Ü®©Õ×m;[ÔsÍH  fº‡šâ–y«÷ņø1£¯ ©•H—Aè»cÌ…X~ö(Žï)ñ›*„²ÈE»Ö+*C?‘dIË,¨¬¤åD'ÕîK5蹆•åÐp@þƒ{´ÖWŸ¯5®Íû¾iqi\ƒ¦ÊP_VÒãñ=¤ô• ³kÚ`T œ|Z˜õÔz.žã®1®ÀÇQ8ßúºdâ•™O ¡ 7ZÖm<³7aÄY(2´™¬è7/õg^ùn‘ë7}Äõ»g¡"Žt ®¯çL(rE8•–çNXÐw$òë•æAñyQïN\vä×’ºßo wiÅ™©ešKUWA!mè=%ifÀr+ŠG9·ã²'s³´r€36Udy—x8{ƒ JgºÑíÄ]|#B šŽt–Xâ@“ôxŽõ©·ÃóºßÉ=}ÐfªÂÐïÐD o¦ÝÞ¹Ý'Ô96yF¸²Šˆ¿Ú1ÑB…H˜‡=c×µU án)-e&isÄ1Ò›žË3ië$šè˜ÑUu8@Ð;FÄQ «Í¿›×)èÎIvû{Î}Ì Vúà KyP±÷k$q 7Gæžþ–HÏ�¡$ÿÞ´5«Ü' ‚×:¤I­5;«Q è<–¢ì© &éÓ›3Ïf04þm.ܨÛÓuôño 3ߨ8ƒüûªøÒ¦x?l¡çT+ו3-°_þº>XÈߧ’}E9j#ì×nEùàÎÚŸÜ®Œß­•È’ØÓª’¯Ъ—C¤ëwj(Óêm-µ–Íè®m $È»|ûPxÜ–’G2pø™<~^Í]¶nܼÞt8¶Ê¨aÎ5‚ÃZ]CéAí!]c¾Oð7}û‰É¾G”ÀÙ(Ò§mçÉ!JyæÞóG÷ºÈå¡¥YÐ]f˜\ݺâ°ëñÑ9 xà¸W`rá‚Ç’É ÷wà+ t¥ dälèµ­ácGéR>¨¼úL´h3NDË/¨~–¬Öÿßÿ7aZ2,~0 Ú"·¨èØW ‹Lr•QÉ®Miô3÷]»ûüFº[ljhÃçÁ럩ÀÒý ~Þw‰p¾Å(ú$!ý³ú[έèú¡7R¸Y…èA4}âíÑK‡f3)ðFnÊ],Sš2óéÑ,œ”åQovÁ뜭úØäŽc-Ʊָocú¢×I²ˆÁΘûbµX@_:SÿY#MK_Ÿ”–ÄÇ ÷Þ­bhPSPdþhÇ´�k§ÆÓ”™+çRye_!Úî\ǹó3­Ëfèf=XæÃY‚/<Þ´MîÚåYá»hYBµUÀˆ²‚“­žRŒ·ó…•®9ôE–häËÒ}è'žr[ú&v NJÓxvàfeæm8„gH!ÅŸO¥µ¾v ³rý·{ð¦QVÆ* Ìâõ(â ]k|–¸,©ì6' Þ&hݼ.Œ×tü•Júì —8©ÀƒŒ =…%¤Y3X”^½ù†cZ Qb´#ŒtLìé˜gn®€Q/£ÄËáìKúvRïÝ°ÙŸ+áEa|¥˜ÛÖ•'D^ØÎ�§èÒéßî`Rw«:¨7†åŽ)> #åYs4w&b6ìÐvgkÖ¾cÅo¤èšÒ¾ ¤•8…nü) bö¥rºõ ¡ó¬?q™vó¯çn% eI$»ÅVQ­À¯WP¨=Ä=1ÝûÙ¾j±¤4ûK‰“ñèÍÆ(há†v€.toæ's MÛŽVZ×¾®é‡>–ÞéC$K†9Sݶ ñÚ”¸3‚5Ö=I2î¼óWwã´Z–.5I˜ºM+ç14¢`g¨v¾&îƱîõÅK§"çÓÀlz‡º¯‚Ìæ;J"Êx’S×Vz³’0úóex³?_r2­+îD¹u¹ÙXhdAó¸Êà t ©ß6;Ù,ûµú¥Ñ]AXáÛ–gÚõSoÅÝ_ÂóÇÕB Ð*DŠ€ ?@à„›¯=ÂôDÿ/„<ÃL¸Å¤H¼˜OÝY€6.9ÀMq$Y, Pœë4çP`ɽÀ̇£®Q:axã]A‡t{ßæ å^ýõªæ“÷è�˜L"æ´tú‡¤+ðßs^[–yÕ;ä}ƒqO1®W˜'7® PÇb ùCÿí®©°ÕD´= ö´4ãµ5 c¤, +Ýpõ¡gÔ=ØG÷ƒzûVƒa ÚÕ©öп�ZÂkÐhHj6;½–G¡ ²jÔ±²z?æ"OïÖJM¯o8*eÚ[ËLÍ»9QâµYÃèØʤ± ÝœÝ\ÃoPÞów®Ú‰+FC.ÝV#U„6*óÉD›RR|«)�ëJ²úÛÕOˆí‘ï«Á0œ¾B3z:5=]Šˆ³•øúèàßò»oe•´#=kÀ¹Œ¬\LÄ<™õx^`[fEê:[¤~Ì1´kÿ8 ß ‚#&-o^÷¸ÝÈ£Ûý¹i­Ûg›zÓ}6Û}°t«Š[�Jc©Ë( ‡Ü¤Ûâ.ÿªR9o{Ü)(¨A´y7wÉ®�ô¼Ñ‰;ñäàóT_î²$"…‹ šÐ“(Ê×½Õà ]à`v?s’ Ï·ˆõª˜GZàc„:qê� tïê~~µ-fNpˆÞ@‹ßNËXzi·ÛYG{/2P#—HŠ%åæD7"ÿ쵯¡§¹òñ t}ÇÇÔ} ’(/œfmÆÝ9ÎÓ&m^e‰§ña‚ÙyZég¤Ž2{&QÖÁÒÌf^# xb:‚Vñÿ¨-Òe3%»¬þ&â}Û¨†Î_6ø’0±S&¬oÖn¦3eš½Á%øi¢ênßÝgŽÓ¤�÷$8¹7§Š¹$èœì½LõKy«?Q¡ãHK±0 ø{ ¬xÝ8éðzCÿKÓ˜†ÇÀsºehF¬<@5�«°_ôùÁyê}ÍÀ—tØc[ÜņsN5DV¦€(Ι‘‰RÊ[eÞQ”‰×\–Zw kËÅH<Í×kÐ(Œ' FÌnêñŠéR–‡ ïYŽÞôØ>{×æ㬊ö­¢?àЉúèü8zÇ•ËýÙŠdµ¦_o\µ»íý[.Ñ<s�!‡Óƒ¨‡£§búýŒSgíÅn/ ížü¯˜Ö¾ÅhTð ÜÂrUS–w>û,<¹ž^XvÏ"§² µ‘E¢ˆkg^)ÆÇyùòÄâ5UªÙDå¿…ŽÐ.”F#pdš !‡å´Ó^èF±šè¢'qÈ"ˆßß­1ù©ß§@«*­ýS¡eõc2±§¿ÏЊÓIš!|èÃóDïUúMšÈ°5×ø¸=žÍ d»oV2]Ͷ6ÀU{qgØf¾µNŠÔø>y³²5tK."*Žs4xÏÅEæNá€ÆaÞ[ö'œ¾éƒ@ùúWwKØøNrn_3êķ®¢záðF‘1åÊÇMǹ±_:«y… s¯¼z¢ðJ±—v =ÐV³À$°~Ò`xÐç›Ï»c°>‡‡a¾é¾ÑJÜÒíhë·ÕeÀ †¾À½_±ÒwææжƒÐ Ô°£Txy-iOšW ‘2¡¿VP‰|-KˆLj›'j/MO Èáøòr®]þĘô¬fè¿´[òuÜ ç B?èT‹ò(îÊ.•ïãÔ›ÝpðíAɘ’-igr¨uË#€“:E<m1ɾ¸J´”¬ýèÁgzBÞQT±«èÒjføùVö!ñÜ´ •T0ÝÏ è¿ ©_;Ê_¬ŸH‘F%‘uìRæT$–ÞÝNÂ/æûÞv“6Ö^’³»êÙ3ëÅÔâჾŸšíb/·½«¦å®ÒM´�k†Ó»K“QgBÜ�†U\ký {4 ój)pþ‚øÙ椉¤¥ B8×n4€�úÓÏž’¹G6c+†N•ŠiÖxkŒ¦úÛéLK _„ÔŸÆ–`E®ÎxÏ&̓dmÓ$´ÝÈi£}(" …ä?†ýã;S\ÛTØÁid‹ê*È{  úÚQÖ:E}! Ö—‡|¼(Î]$eÕ“)ƒì¤@…˜åÔZÉ:ÝIŒûSN>÷™®‘擼_LÉÏQd¸…ä6òÁk`´2ß°ôü@XôIúà½Ûàü¶ë¦X’?„!R7Y<!SÊdUZÛûyÔ;¬b»¸ÄÒ{8Æxö:±.8ßù0BIôðOAom;ºýaà‰Ü¤åO8v”L,™jzåjÖMs˜ÇdxöŒ˜yFªŽIõ¸›w{ÑAæ• †\½rmÿ GŽÕºLøÎi.�=J·hwÔÝÒà#*a–y¸@>®Ç a£ˆUxMóà&a~.ÕUôD¸¶xwS©¤{dù£'A(Ý9¨³ƒ?_5…¾í±s¬LUõ“ó¡l4'W÷Úÿ‡x³œqhÔ_¦‰¶älÛ£y`I âz†ÿ½ÎF6ÛßPvœ»© ¦ f5ƒ&¯Ãzml¡îi<WH2œNØn Zã¤éLïéžH6`O •x(;`›ibH€€å£U²ªø3#¯pŠhGõFyVùFIꆲ"\_S4ŽV‚|8(Zï¡�E¾òS“OôD 5:Ù‘U__¶È>ÇMš¢,õõ ÃDú"é Î>P`¾€Wé}\JêIA±:òv7î‹íYL’¥ã®xÿ²ù)%,=—;¿ñh–R´ÝP1¼Ýx5jMÏÑ'î”Þ»L晕 ªEÒ]Ïd(Y8•O1á¦,À¢¿àO3Ʊë_žDê”*”¤˜Súù½ñþŠkª)€g¯§µ»ú=,Њ‘8ŠÛÖ¦ ÐíåóB–.åy®óâAkY=•¡ Íc!§­šV`u£3Zxk¡O×µã#ãMèŸ{"*ÈÃÇ,H­«$wš‘ó@ ”+˜Pú—e¡¼qD‡í£ô½ÕwåljwÿÓ… Ÿœy°UÙ‰ò{ëË• „-p¯Ä�ðuƺ_ÊÜý¥Gá´fïÀ"Uì Ü$í¥ñ�{Fzn‚g{ûBudïAôQO rÚÖm·ŒÛT ãœcÑ8ZÝê{—Þ”X„bák¥£§ý…Ç}R€‰<‡ð´ÞŒgÁϼ-‡ Ð)ÝôQÙØ(ÉžÒÀβQ£¬´øý¾n/~/l…ÉŽ¨¦ì;ýI´x"sU’… Ï_0¨S€¿›Iaóº4òÀèþrëÈÞÎü Í•öYn~aÈ'Ž–�ÌVjýšH°Iæ0?‰ý¥ár6¨Å»OÃ5CPµÏÄ¢€™¤IP\4­„ùNyè„‘à!ê§ôÑr§söÈÂA£¥™pQ_Ÿz åŸ>é2ôazÐÕi¡¶GÏÓŠ·áÖîż ¢Äe|À*³ÑH2oÍ}Ídf7¸`wßiä¡fJä3Î2ª :o4oÝvoX´—Þ*ô&4 Ò°ë— Î¯r¡"µnEŸ1<c.ƒÒŠ²!ßÀá‚ógÙ8Í8W5q\¶h\g 6ø€v¦ghSã4ðÜ}ÌýQ£ØŽÒ2£à#Y}«ãþ_§YEBìÏjÏürjo¹„,þç°9QRTnõÐN««Fª)xW¯ìT'›ÉÅáÈô?n@q¦Ï´ ¬ói–ª~X3¼! V�¨ïðXÊÈ/»cTª)m‹å-Y’š­èMN¿;N¼ü¯_=§@Ûe8íÙíüSïAk)/ê £—>1´!Xâ0MX8ç —Ý¢`èü#.+œµ+Cì?Ò,ˆÚÖ噫Z[&2¯ûÝÌœQsX28ô™¸Žu[R<(>[ZóQ;˜mÍ©Õº?P˜äñ·´A«Õ?Œ¥³wy‹ñò¬Bà Äqš·¶öÍÔ½ÄH‰À»ºíý|’¦¹L¹hY(o>êƒI‘wÔâµ"Å>]ýÓp±Ì}@xÄ¢h´V­LÇ\¯»±wÕ.•ü±kììM#i´-…µ¯Y=_-çl�/JF_aÜ—žª/‹iÐ*¢¤@C’u–ø¥ï„m‘hP5鼈§‹瘟2Å®ù_>òƒŽõ”ˆX~yfIz¯2ªls&Z@üeÖÖ\ÓüˆqÐÄò›šnþ M€[hAœ-Âa„q %÷ÚH®ñ+å-msïÿ¢¡…‰?ƒƒÁÓÌŠÈÖVÅjW8˜¼²ìïƒQái•,î<CDZáÕ€b¶ê§fçínB—yGþ0_˜SD‚+,0>o«½LµR6-ìUP˜çHj°´-­¦ñä(Ø*®izqJgg½¸Åt§•›…Ü®;Òéäs»‘)P%|<ÝÀÆ¥,}=²ãÍùš:ÁwÑL·´x“ïÉ+'XVLš8,nFnŽÖ­Áàs¬x +l_«=ª”µGöEÓOéûäÉ;<ʨô4„3ž,}u7Zšx¡Vê»xfB‚á#›¦ïÏžÍi˜--^¥K0m|³Ë-d¬×´ë;$¼/v²Ô7~£¼FF5Ãà·9ÚvgUµ?©ÉÂ…üF4MÆÌ‚ÈØ£æ>8Þ´§W+=R¼Ëíeh1 ]N«([zŒÏCRyꊣ ˜ŸË-jºod0š=^ý(M‡«h±0b¥Ò°.@Þù®©l-f=kXØR‡5ËŸî”4‘¥æ²Â>…·}ÿ·Úcö¼×Ó‘î2 >ZÖLD¯4r‹ÄÛUÌ2è|ÏO ¹.P)uãà:yz¾Ð‚$ÙåP9I\ÆÎ <:±�|÷æ”ò—oùèÈ*tNQvÜ@ ö]ûy7‹^»I­#‘5ã¼Nã{ :.Ÿþµœ½LêóÙ"¶,1˽<Gù$r™T B€WP¦×îjüùã/=_)½á½5dAÆ4Eñx‡`N×Y­ß°ÌâÈ3ÈʸJ_'q¶2Q-"ÝoìÆ쪨u&­W“ ºâŒ?v^ÿ±Âå1|³»¡Ýû¹#çñæêÅò#·¹ÊaòÆF¡‡s¹ã¹ï÷ÝeÜ­\ò|Æä{4‹d&ÔñÃjòñ„L|ˆgÏø@~¥‹±Oô§„Ês;C†rH3b¿÷¾x—£õp˜È/(ÿÉFË:y{ÒâöL1^>·bWð ¢iàKüÙúþr5óVìÊç®/Nœ,h;°\Ð-·´Dô;V»á“"ÛÕÛ¸½€´„ŠNÐzÒ÷ã_jž”„¾·6¼˜Ú$H×o‚æ­t’ÍûnOmk¤?|PmÔwݪZlیҳW“þD£zÔ¹X³í»É˱Ûqwÿê•¿|{95qFvÖ™P§$è æЛ';Ô—þ0Z;O•g1ÚMaP6î,DêžmÝuƒú1BF©ïæé¿!½‰ < °>„hº´ƒã<Ñ[5}÷‚ߦµ:–y7°3Žƒb­Þ3Ô0ñ6ͪÌ„ãj)$×tb'ýÂ!§ã®—Øëî¢uoUËëGœ~FúM˜H>‚‘Ì¢ÄÝX“uÚ+`*ï˜ä ø`ˆÙ-|Ë­~?F fP&)#T›¥ã¢*“T« ªËkéD’á¸I)’Žºº€í/V2—n™ùÞÞå}ùÊ"\Øꦴís ­˜F’,<K‘5 ¸y` _{ V“lt®d£6÷Kƒ9;Ò;ŸFèV/b®o짘ÜQ£e»M‡ŒâeÿÇb³j–•ï˜,:§2@ÓGPÈ­!š¬Éû«³*³å–kšÂ¦é17‰ê¦¡eoÚDç­`mW=è”ãA…fƒ»D³%KûTèKéçäuR„/ÉzÁ»ÉÕ»´€' »{¥÷‘SÕI{˸‚ÆìX²¡»á„O©*Åû,_î6}“Ây»펌r‡OjªPeÙ¿Bûõ—,Ͼ¡*ßY«žÐ؆ˆ¹i»ýЋãE« ðªÊzíP§X“”|pÚfZ@ -Ú´L~òúrÏ�ʾ$0ûÑã†'monx"¼uwS¦Wn·U™â n7$”Ffñl$ÕóÚV’¢=¹Û…Ç›à.Ŧ§÷LëÚ[C«[S©‰ï’ì•—•ˆÂpááÞqwrÜÁuݲ7Hw{Qâ5ûæWþ<yæÑ5ØR <E›M æ=w ׊æöÿ S±ðx¡ 2±ÂÌyã‘vN¢øZJæi‡sç°Ï^Ô1Ë´ºõ¾ƒž’Ú+¿šÈeièèÐøZÅ— ”g•Ü830c¶ „걡 =\‰ehÝb~¼Å¸x‚ù‘Ã’Å �ÄeC'êP› û¾BòÝK×êpXs&¦1³ØÊúð Ëù)Oí†;(ô¸vÑ×刓ÌçQäìVÑ>HÛÙ$'¹¿ë1b•Ÿ+m¶g¦xaá;‚ëÇN§ÝE¬SzY÷œœqaŽn ÑEñ¯?ÑÂùº‘W$‹™>ðEU«zÀ'å …E·úpf;>´l•+}•*»ê:¯Ît3¶[ ÏSUé»sçÿ+è!š¯¶~ç<O=&-›6”è”ÃÆËtNc”‹ÙôýÖï$P²­MŸ½“ÃLzóa4 %Rï(/×Ô«Ó‘{ö ½†¥[×>Å<ÙÞÀ¢w_OºUüè·?&»BÈJÐäskA­È  ˆ®~µ¿¤dd¥_[`⼡÷ߪ&4zz®HþæYꀹk¸=asqÖÃøUçJ²¾—ôý>¤K3ˆjÔOÿ‘Ÿ`î�ýÍõ…RÛÐÖD÷Èu…’ ?ø_ù¤Wi à®|´÷"Øæ"üÔÚ€¹z-@«_[}vÑUÉŒiÛuâé³”,2¿MCûx[ÇAÕo Í¡¬V35e0†¾Ü€h2è´FŒ‰?­p`?š|î†îOÀìÅ_I—.ÍŸÍHkoœ{d"Íw_°?zfˆE’•®4/ƒ=´ 6Ÿ&ˆÇÞP4¦Tȃ9QÿŽ9’ªêlÄòÍÐÚäA\«œI{¡±£ÿÍl§ÆwsìM}Gu1’¡ÀÆNj]#Û†–Š°É:tÌû|[§çò1U’ùžqôgÀË>Õ¤¾ ÛVWËðÿÃ~0öÎPií!ÍDï_¾{ºýø ½0ÐìÙ‰‚¸NàŒ«­‚M¯~ô0 Qf Ï@¬åÐ^À}{šÒN®ß»ºqîÒþœØÿ¡qHé-Oß¾`d“mâ3UÝÙýeo¢þ θŒ9ˆ¿¦êk:ŠÈŒ©ÙÖÆaŠ©tˆ¢vEÚ=aîÊ¥ô±«?–RDUn»ÖëÍb õw„yêJ¸*ÜÌóöd$1½Â²YÍ´™'ëz^˜ ‡I¹çív;çôÕ+ÜuÉ‘>uÁ4FiI?H'U', òË4)t–`ì!¯ÑXç1c3ˆé÷¨¼‘}½áÓå9:̈Ò/Ýèóܾfr®4MM[~œíCÙŽ¿óŽÍ„õ3o71ŒmêÀøU¡¿E˜DÌÃÊe‹ÙÊ2‹ˆ>­Ô–78)YP|º>~¼ó7ö@Œ$¼wu<•V©YY¾é–ç§ÚÐâ�÷ÝS1héA”.­Tø.ï1ö Wœ§2ë iì 9Ä}ïuÙíß(0NÝ’nðKîCeF,aݾ[[CBA0_GRÓ눡ê7€Î"“w¶»Ê`t[¯¿X¹ÀÇXR:SŽµWN¡Fg6¸à¼a¯_5¯H«Èâ¬s&õàó0ZX'}ðƒ(ßh6&m©³ˆÌ©¥IkȨPàô‘V¥ë ù™Jú¹íÔp  V–hÆk³:ÉîM·åÁ«½!žŸÒÉ‚¡Äe}tÝiìzɿͧãÑf¿E—Œ¤”þ1:0ÖņR×™2|^¥/7£ÿ+"³Tzµ¦(]ö[íOElÉ;½mΦUÇnêÓF~â3òYic8ÓíOVc|êV 9à+Îô9Z`Å£(Ž³Iä|_sUïAô¹cõnØXÖòOØÆ›qz·z»¼5*cóùÆ‘õ´(¸i(ƒhÔ°¾xL�ÚFé«0Y7qPÊ"YèO˜aß#ïêZoøgö2˜ãi½¾ás1ª8O•`ðI¿«.{ldØÙ|cßí ? †¦_÷é½e[æî¤àꤡò1t±) lLUJâ×]æ¬ =ËzÌ@iÆVn$‚¤ÙªÛão¨1Õcxfœ,(c0¹:Жž>=â 8†;+ÿþy]!“¤‚þJÚw¯cÑžœµV/‚N}ÕÚòÑÏN5f$ lgjÚ³'}ûø©vÈ@ð«W›5¡yÈ9´€JÓ«/Šü™CÄœE4”Ô¢L ÆÓ¦¹˜¯)²éB>.e<S´9lÄ:&¾LoÆXNgMiØVÊ Q•p¶ÚÒ·_¯Ís:í÷Æ JÚ¨ úÔÖôXÍæó.}»Y¥lƒ”X9ܘ1»bOèÙx¼FŠ—¢pÈÿª þ¶ðÀ”»brØ¡;1a­È&ðšAËÁven‡Øã²z-=¸tnÝÁD§ßŒ:ʨ/˜‘¹wÒÈ29¯ùV'¨H{zb،޸WÍæ%WÒ¿pÉ˽EÌÞrP„-ÿ4Ú|`’ŽcV'ýzQ.ÌÈá£D¡ÎºŽ!Œ~ž:Ú <7ú¿w~ü.º4ú¢.kNqì†Ëf<P–ÍbjmwšèhÀÄþÂõ'äñØüåÃÍ/<E:‘(?”–QÔÚ† k‡É‹±z˜>,ú)r¥¹Op à<P®7Y hH îßtáuØC Ó°rÒrJÊÈ7™+®ƒs^ÎÚáCŠwHÿÍy½Ä‘Pþtì`óÜj É+±GðBiê™G·CH'82,£ üª*xžù'änßYPu¶5�}¢ŽŸ¿dr­/Ï\TãÒkÍ0­íÁÏ›µD’ëYቖ_j/|Ž‹ÿι«*ðÞÀQR°Ïö4xKj{%�JÿêäQâ7F¹·Üw”!¤'«Æ“Œ}<ê©ÝŸ€®åS»€…¯¹)9î÷q,‚ä]R@”Oßœ[‡ŒU<b//¯‹€šÇWHMîR÷ºبxo¬¿$]•ëTYí;Ú Ÿ¾>ý×eê(wd£Hèý „ÒYwË?gèr­– QíÅë,àSàVðù§†c¬æ®¡âEéÒì³ÏœZìÔ_ƒcëÎ%&»€µ§Aþ©êÛúO€ÎJµªTžu{ß05l&ºõ…5)nsÌÑÍ»3È{õˆ+ X“ ŽÈÄRÉn¼áŒo¼ãÈ '’Ès¦»[<;Üo·Ì"¹h”#`¹ÇÉ¢¢5¤Õ¬^% €è­Úk}<Šî +B$ýé(3Üçv2ýŠû°¬Yì”ýœúœ,]ØÙý"ðkÏýò:°oa·ë½F£ŸL0}Ê™Üìf@oõûSf…ܽt9àxš 2ó$µ•`M 1lÀl³Ñ5hÚ'~"ŸGö·w»jwýó¢Ô›d24Ìx¯æ ói[+¹b~xud˜{&n¨0‘ª‚|ÒB 4¤ÀÕÂ#æîè^d=Ì»™èNŽ ŽFý­Ù³©åŒç†-Ù`*›ÅÄvaI»eÖg®]dÇ[¸+é™fîðmˆÇx;]•Æ°W‡ »)‹_ƒ4jÇh¸Dl,íȶÐDšÝ€ô0Y’kïinT`¢X›sL8¶Ø'…3º†£ÀÓ\û²c·é†ÕŇ墶”úäˉ}÷sös`°Ðê ¦ÒÔ6*¨°{tÂ_OX;‰‚*#‚ÚB3£8ZÂîó½7Ùè«ÃÌÜ\a¡ªÿÝ–�¼3 #Ò~ôt8®û>3Ï‘Le‘yH&Ú¹üË㻇üi_® f ûªgÕú1¦“g]ÑÆËW­ †:ÚSœ"Csù·íþíëÿN«­jXqå¸Ì™nR¨ÒÓ.`2|÷M²ÕöyuO¹“Š¹w>ù«tß7Dä¥í¾–¦J…)%[°wòéì†ZGäŠ5§'ZFnXøìof¿–jwðLñ¡ZÿñàšÖ8G=Qx_�EX0äê'õT°­¨sä­ð8è)ÜV67± cgšv”Ú‚ŠØÕ†Yý›ÆÑ›[nŒ[öÞ߈ºùk«dˆÉVYïéë0PŽ§­<ôQŸôñß1Sëð€”ð2;7Íî2j yÙ]þàáJU2‡"½É«r:†Ñ”£ŠÆÓÇþ¨y‚Ñï ~æ9Š&SŸ#¨>å<á§01šZë“V:ã ણ}ÝJ~–å…§?¦p¥Lçý›ÀuhßZF|?ƒª�límøÜùÝo¬am%FÎùÚ°À‚8ùvák–ÎÌÌœÄSÄuëõ9V‡¹qñ_t6sO‘,åñ }ôªµÜ·ŒÝì´r~˜Å~» ö2Ÿ—¢øJ ÞÐvl°ÖûKŠÐýߢXJ\ÔåŸv Cë9p²‰<¤ñKÃää.®L=3£ 'jØpÇøJŠ üÔ¶œXkí<[˜}'øÖΣq¢m% ÑÔÎ"ZP2Â�ÇgaÏ:¨)îéžáγؙQê=´ÒPy­c—ׂ‡–¯šÎÑ_e(gšÉ~‘xq·« Òóh‘ë¶ûQÎ _Œûéïu9#O" ¸TE:ÑÏež-ÖÀ÷mâ›+°ñ NµfôpÂ6¥ÔòKø!Z…Wþ™ÙŽÍ ){ã—gªV¡«¨0Ÿ˜îÿÅ/X¡?÷fÜ0®ªñÝLy«¼´SŽ»Nsî&<N 4ÿÕ QOÛ¬Á6öõxGï6Í3/ƒÓ¹¦Óí¨ÄŒõiu ]5bòì—tÒÒ€DÅœâg7€Ùõ©:º…úN©Cf'ÿ¨Ç—; ±˜\®¶�vÏßNMu3²Á ÖØ¢›K‡©"øD)éyMŸ´Ón'zêP™åj�b}®?:ÓÂuW7©yî­A.e&° F¯ïöGÊQê „þKö×FŠ"òa¼~5} ¹ûkoÀÈŠÞèrQ©M­kS2%Vî˜Çqœ»I’±»>e÷ÇkJ¶‡v !fÜ…¢Ÿž³ç?øCƒìÎDö;’¹ï¨ ”N]ñìì¥Ì—Àrå‚v¥â0ãi@h;f™Ë‹ Øú5§ª ’î츗júØbªcÂð“ÔËž_¡Q¸G~|úÝ>z.ұǬ?au¡ùò‡b]w·}c‰ÀÌ(Y7ôOÔÔžÛ¢ h<[KˆñV±þ"ó`°6 âR:L³e3Îw«‡‚ÃIë¡Ü -«Ü²sM ü^q…µo^Åb•0ŒKÂ…‡PÉzwa«ã®ôdÈ&¾{:ï1¢‡ÓsËòFüîGr`/4;¨öé̽×W_µåð±Ñõëm™]3øx´­[úïh(À!�g„õþBÜ„Q¢æ™²&Ó†BZ+š:1@ŠyÃ,Ã+Äu÷Ê#º:£1¶¦kÊ”;uOæ+Ìzž:Õ°{W·Ioꎱ,<à­yô¼“ãî`q ¯ŠaÄQæRh=1)(oßMÈð\€jù˜jÍÎÿ (A =”$^‹Ongh1éÀq8¬ëoýK‘¡S–øuèg´ã–upOUww×í6òº 臌R[몘xVÓŠÙÆ73M5$¼zUØSêQà ¼û°¡èPlc¦ÎrÝ×umic ˆXÞí×&FŽ»œ›Ê겸«¯[H'V¢ä>–䞪”Ï.gàÙ�ÔÙ÷2ò„^é±ÒI´b¢©ñº¾ ÝýßqdÅ%§¸0ƒÍz¼^ÁÜ¿?` 3ÿq@ üMaªcéO²ˆ‘ÊV Ý©=%>½5ádòÔ÷¾`‘l/®+`ŸAψ¶ÃOì³ðš¼»ý.‚¢Vü"UŒ«­kíñ§@ÚÒB¬kP¨›¥õl&k]í"ü°°r¶U.J¤æÔÛ¡lsú63ˆ'ŠÊà"ïóº b÷¼Åy³¢Ñ@Ì0ïÖ´rgÿòI>—,Ôî`(ßÆô'”Çå2°á'žäߨX.Tn(hç¯4H/½'CÄ…èV•Ùé.\Ù<ûéz$¡Ø@±ï!ÂFhM# Îáà´¨b;k%ùüy°•E‹"ˆ†è/–ŸJï‡PÖWCÄsš4Ê|y™ -Ø4(ß;' {€6ÜhMRw=ž3äd/KÇUû®I’9ó,&ˆ¬Î󦞳ۘálÏÑœ¦­ 3Í�Ó yÛ»ßMb•ˆ®Œ&-×½ñ»_{1†Çœ8Ï+Ý(*fänD¶Q C2Úkç¬{°O†/±aåD®±‡˜¶Ëò ÚXϺ„ ÊI‡Ç]„ø¨¼à u»´[¶Ò<âï-Ê{±5�.£À{ªxçï4÷ªÊeõ1ÍË :ê€01õ†Àk¨ö­žßNwÙÃxx‘GØeIØéœi3ûü‘þÛtBÞ{cú"(I!¿ÊŸk}êï~·2w‚a,ÎD13ãh¥q‡Yð&N* ½ø±üH³ÈGIQ:²ÿ�ïl­õ*ø_»^÷ÿùÀ§çÄ1äw.a‘Ÿæ1Ü, ²úè6î‘•><õªÿÆ0, ßÉòÊÍ *)ÛÚKŠ)‹óŠÜJö¯ÅŒÀVP ŠPìy‰±,úöA\ÀÇ°J#ChsF‚Žç]ów´½$_ìXp@0�´è=ˆZî“V{ʘ𘿠Ïö­á!\5ö¡òïÙ`€B:+ ÍÀ¢ŸÌ¶åþ`ôLŒù cþ+Õ½¤p  žì£Ú‹{-”ÐÆ>_4±¦Ûòîæ&ê?éf¦‰gÁ›––ºX!H#GRÖ4»A)-¶f|Aj&[�¤#Ê ’„åÀc li(É›˜n¢1Y>4½7.䧇ifQšã:6ª?ë Ó©7.¥Ê(bÌc:²2Pšæÿ÷ëðéöë ½W¨®ÐgØñæð r³ÕñJŠ&0-£,n&T¯ ª$e³xIŒBZ6X¶ŒÇñš&¬kàê«¿m&VE´_J{aã¡ýÎb–#$t³Dßê“Aó®ÐU¸¼Q4/\ÿ'O¬4 r0íz¸ÇÉg1²BTkõ{WÆAãÞnxÁÝ$sÎÃÒTjú"mﺞ4P DŸYKÑ]Ý—WtgraDš†v´ÕˆIØüÚQZ;Þyk{õvÆÖÖã¹{ôÛ+žiŽ~jhE5Úpbä ݨ€üÓ·©(ìųq¢Jmw^Aþî­º ±p-vÊâ'úb Px8l¦öq_?ý¼xlõõxÀ³6ÚÏúùEåZÚ,^×T!£·\©Úì6ÆdzÒ~LJ›½¸Né‹"·g,Ë«ÍST­Å8;&àÁædüqŸý£–È¿Ñ NȾŽ/|¨?�6tÒ§W9k‡f€ù^«¢¤Xq )ÅÝu…ðDÌúi1úWZ1Ðwß^<ýÙàﾯï%h€7ÿ’ÇÄo‹3ïgoùnU1 nb"¤bGê„"²u .pq«ó±7|-î h®ß©›’…#»rQØ=YÉŠ42>³€WCìV ärúê¯V5šã`Z3‘«Ÿ™ÝïÐs^Ü(sÒúÛ|üwªÃg‹‘*hŒ[ê<§Ïœ:]QÑ)ÞiÁÙfx ¨! *Þ]Ìg*óÌ[l¤“Õ°ñö‡³§`ÿÛ¦fQù:¼aF±1 ªÆŠšT\[$xS6”ÆöâçðÄÔ¡ zàì–0¢WtFG P }:‚.(çf•Êâ¹ôÌÉÈ"¤Q ˆªäĹÙk¢©Y­™V±Üã¿þà¿ûÚÌú—¿ùI)À�%OC‘ªîM/"õ@Þ¶Òùbs¼`!Ã&ãÄpVàGÉ‘b¹Vš÷•™b”dUêd`êäI³£žI-á`ÈžäF½c”¶Ì[³ëÆþp~‘•;™q׃–™ºsxfÏ·ßkÇY•|5$Y_¨iÁ`R?1¸’^¹/ÇR¤îÀ L˜K?OÒöÚ©ío †â¼Z)­_€žGwΰAw¹å/7qæó6éx=Aö^[ú.ÐFFRT@ÌÉå qW[J0§þVÆûÌÐý¥2­ÿ…ìAÏ©ì‘ÞDhã“äῪÆ5 ”ŒIú*½ Ž•\ÝÉÈR¿‰þBä˜úÃA4ø¶õs³üŒ¼ð¬HJdd È÷ïϨ'ñ)3Ò(ÓD;wrEà}ö(vA©Ií‹Ógüavß`² :ú|‡á>}útrúžU”¿ÎµŸŒL¬-b®O(®^vµôâÐË+ÑÇ‹”ÂÅ· =Å,^}ØOdó˜Hy ÝÂôYøªS§™*f¹’žEüµNù¥v¥ï­”™ìÌ]r…Ëäô½ÍñþU«C÷rºykfHM…IvÜ8 KM†eK:û¡¦Çqj¸2B ʹ‹ƒÊŠ™xsøÀ 0´ÿªÝ|±­¹ÜaXE±s%Ïë1ûÍ›Ñ{œcM[°ã9öÙ±Õç;-íÓ<H׺Ò+NÙì8€2 dg[·ŒûŸ—ñ°ÿIÍÈMÕ¹i°U¹>0EjÖ€&Û«vQ²âBE&Þzë+‡ïÎ׬Äæ¯Ðœq\…žÊ$­úy„…}SߺG‹³Oݳ ¸»Xap±úðYá‹K„(wª ¯?}ù®^s*óÒóôñÝl×Âå5íFÏ“ëX·-Ç? ÷¬YÈÅ,íM ì±} fý>Þ8ñÑXH¶Y¤”W†vH ½¨ÿ VvØÆ`s¦J^_#ŒG®Öƶ.Ù-Á‰TZÉ–}]»a#×ûrgKš<B‚î; Òw•ÐOt<î¬? ^ì.p>õ¥í¹«4ŸQ’õ½%û3úZò#®ÉÍ[Îô-Õ%^ÿ˜Ì~E·úv¯”Ë¿©HZ£yQ¬›€{¡['Såç ñ(ö«4ÐU6cXû|ªÃwëÆDôÌöbÕñ#•* ÃEŸL/åÂâqÚ`‹u‹#sà Hì>7®§ï4¦þDØêmGÆrd†NY4ž=JJJz6"”–ÉÿÏ™ùwŒÕ@8�[w-ÕâáÃý¯oäÈb•¹/ˆŒ ªJÖyÓ°‘v©æ[ÞJ›| n0Ø´ŠÆ¤\ÉÈÿB<² }‘4*ua&Ý<}™U1ôü—&¨ù¢eÖ¥ÚGO•y#¦9&ë0uÏ‹`d;ƒ`×Y%$Aj«AxŸìEÉÓ¤_ÓH³/߆qGDõ»Uvl­†…/¥vÞ-,ŒÕœp‡Ì¸ÂC–JÄáÄÑÑŒ\€ûœ^æÆX Uêaîy0»Z§i_|¤ Š ©�Ìw‡–T‹ þ²²€¥@„ƃ’'.I½uœ»E ;)Š~3vIÜí‘‘ÎÔŨ–”hlWÛ…§Š&=ŠkùR¦ ] ÒfåêÀ‡ã8’ºÉÜëiåÈ÷þõÔÝ•’o§4¨FçW_"Ãűeùßà%ã8÷Ÿ"ÝÞ)†‡ÚÙµc6ß ”™yÃÈlç!ïvÓ½Ôoà'H»bÕ±±Óá·ßÒPëc·§óq•çÓ屓‘X¼ãgQd¾<¨F¼lË,4(e2ñx'Эãnh=›—gÓh™Ð]‚ÒlÔYuäWa½Ò~À•Ùóe)&ÔÎg ­Ã•ÛüîdÚieKš!Gƒ_¸ÝÕrøÁÊ€8ç¢vlf|¥[[Ñ€õn`ÝÌGZr´Ë ­%xô¬­læxSDF6J—-~»o.û¼‚YS\)AÕ=äTä0Šæ¡£²H“¾áøÐ_iñfðåž¼—¨7#B*ïÌËYËoø䙎¥~Í1~¤Äs:™{ÁúëŒÓ[ÎÒëÁã½dìé`pUÙ´°¼ê/U®¹ŒÖ†Ç|_`úfþêåw D9¶† )²¶Õálié¦,^¾,+To„CŸLoÑ•”ïtÇ£³o¦ QÙüÎìakA”$EYI¡ÁÌv–ϺÎô=#&G¦ 8™«OÛúË<.£Aþt bö¯ú¶Ò¶XÍh9¼omöò>}›ñ‰r%gÞâäË£¥Z#ÛfSAú½u,�ú¸´lzzVké=ŠûÏ=Óß¾¥ =ÀÛF ç2(évHÙMh£Âq¥L¯©€‘y¾Í‹ÒËcàéŒç÷ õP·ÀðvÂd­æãÔý­õwŽØPˆ )ŸÞßGûØŸö*Üûs:“x%uÆœð!)‚ðd;09;Á=\`¤rtÐ;íö“Ò ß´†ºv£¾ý½§m®Vãž‹Î11;À¥/Víæ.½t¿òhá6~d ÝàU)âÅËú½ô‚¤jjÀ`ë«ðšbVªlqÃby⎴‘$:§ÇzkÓ›ùËçmm^"mÚ6@O*Ô5æ&Ë>išY·;n>ósÍàЀ@÷iDéÎhÄSà­‰dUšXrVžÆýtE¶}®’]W#õãMð“ Ò°âÏ>‰î»9?§] ´yiºï»j»YèŸôQ,¶ÑIk+\óv_F½Ýy?ˆ¤F…)ÄvO7{«Ë2tÙÌ[tVÿƒ‹ifz>F)% &œÌóì5Ý;x˜ZµdŽëæ削`ä\7Ä,“Â@ä˯€Ò¹±|óÕ^ð$Œœað(Á4À}v„ÖÏDAWfm3.¯ï¼‹Ž"YGËvbOvœEn‡. ²wk>R˜3þjˆIIðáؽL ¸hYh“¢5W_î}W €((Ò¶Ô¥ç)N} ¨×â:×µ$®2żÈ|ð/úØ}•‘tÖhµMs=»îqt"^n}êì.©F0ÃJ‹ÑðÑa”iÃohýéüéÁÀ&Ž|rÜ2> kÑÚæ\"‡®i‘�ÛÀXëñwNCQá)N°%TšâKoMÊÊ`g‡X¤ìüx´”ÑìQåS«Ðƒ­ÏækL‡þ°?@¬ÝhÉd¦‰‰†én³½«Fô@š?ÖQŽhœPÜ'*îή$â·^Ñÿô0Q|P®êY Ò2ÄT6óPY´\!¬–Ô§ý§ÏošvÂj÷/•°Gnbüua,P_\c>ÎEëqœÛÆKùêÒ‚¢\“ŠziBTm¤1_Ìã= ;ºÕ°7Þïƺ÷õ±øY1Ì6FôuyRÅžÌCô‡#D5:íø—9ÒÙ½¥U™âé᫠ʺ&A¡‡»Æ´UyИA§T¡¢³•×¦’Q¶ÔH¥ò»‡»aë9ÖQ¤G»s:sýÅÌ;TNîá/(Îä¦0·ÅJ±Òâ³²°f¼‡¹±�wd—{`è+(^R@úãdYYøCÇ¥™˜|AûªoUÞüêOF–‰uÿP§¶ŠÈŽAwÄ>‚x3”ɪ?yD8×@•màŸR ˆ ‘LJbg³½KþÄ$·b_)šKè$Ÿq ÷@kl˜­ÿæKÞ%¡ËÉä»ÚGй־b)z¾ ¥›‚-ßoáä0×Ò]iú‘ÆNnU8çÓ™’Ó´Su$€âDn¸wàÒŸñv?Åî´c£x}XÛtòwµFÞ_û|‘i“„êÞѱ]ôÚÒH!¥ÕaS˜KŸö¡‚Ï»[iºäqÇB î¬+>-lMØÉ„“ã_À íƳХ6W70áÈgÉCH›mÖšÎ5° òù'wäs1‡®‚ÌÚ3$Òf¸“4YÞd´Å2œ©t‹Ý\rñ㎠]‚TÀhµÍ‚tÖqí¡þ@..ê¿(ßÍçÇÏçq¾ å¢sóóñp¾è¿ ¹.“¸~äA<( ‹œ™…Øì î=²Ž—ádIêwGa /#Ï <Fνw ™FL�üVŽð[°ÔVî‚‚®!^§1ŠÍ^NV ¯kËÀ]Ñ}8Å»Áµ#1µÌ¬8»U`ºΛŸN~‰â†À˜TƇ䋢YækùE¦²Õnn Ý£~·–�Žýzß¼ðI'Äÿ#¢"ÃÄ% Òwí"áâg ý‡ˆ×"UÜÅþÁ^<ñvaAÒÉi΂h°mú[ãJW%¸«Op©ù—‚ЭØXÊ_ˆ"…ªµô¤“'QÀšØ?ð‚ñËœ›*„7òž"ZqÔa=°­Û“_6¦K– .ú„›…ߤó�Ž ©­¦è‰²ìÊ£éÑ‹"ÇZ•ªl›}•ñ\9>Zå‹00ºFFÀÞÿWýêQÖ/²_:®ò<ˆÎêö˜¦"t³] 6±‘^T°OâÌSǧ‡{žX‘íÛñ”§S{§—œ¯ÒbÑÀ¤¿éé ?G¯Ù\›‹æNž'ìO—vY&W`ší©¢»¯ÈþÒÃÈÎÿÌ0 }UH7À®ÕŽ#ÂiÝj[w½ŠýÐÓ¬‡=ú/ŸÆ•¢Šë‹àV êF˜²~ljÑ‚2¸j`ÍéÛAD¯0‘½^ºx«DÁ ­ÀhýnZßBû7$ã^>u(ÖêÉ»R¹e«¦[š€3À@ª{ךÆìÿpÖ^8"„ït'Ì/ö뜷·qÚXj…Ç<ÈNJæ@AÂÄRñfœ,ž›3™3?;OÏ,Ÿ“*öËBhK@Ë÷hÅ·anlž_zqìj ÆÇM—<(jÅ;2 ½n²rJèZi¶ Ï™í´&úx—,ÂyÞ×(Wª{-:‘BŸYŠ¶+ò—<©ÊÛÙ,uEgåä[£¼‘Ä…˜i©GŽê‰0U¸ìÃfñâ X먦ià›Ð¡§`¬ÏLù~5Þ¥‰O‰!ã’éÆjNðé€Z‹ãÈÁ2¦÷p•Ï´\ÊØ>/Á˜'Ù(†œ6†(׋qGÚߘ)Öëî<EæÎ8i&O—ÌKØYSBÒRwéOX:šV<\P¹³=ÇšJX…?·Jt(¯Ðß&)ϯ”øï*ò'Ù²`u�ëIuÊ#Iâ¥1hy¸R¨•<U•ð@�Ë´ÂË“Âðg•]A’d½Ñ„ca7ÂHÕl„ç ë4r»× B+R†~5‹£˜Ôÿ±l”]jV·;ÒCËëoÏOÉÓ¾×1hBi Œœë[×îOƒb7•/äxC‰Úâ妯¼¾ÐTMZ¬dV(ñþuŽD”%²%¼Û˜ŽÓ"HÏk—¬¹’©Nùœ¸qê–"#Ûƒs„0Øâ¥ÖíügÓ±áü]dÕ«JI–ùÇ{ÌŸk|Êßâ>VΖyݲ#û;ÕF*E.þkã^ünXlò¢=ÆåÖ*¸ƒX|9Ž§ÉrŠ¿:‘ÖX8ûâ<÷Ú T¿•M-…ÓÛh^mÕíJòÛû›à² ¹ÿÜý%ž<[ÒdéÓ£?Í&Ÿ@âÕŸØÉ™Í{¤B¯3M¤Zž‹# ™ÊŒÖÇöHÙÝÅš¿³P#ü1p ,…¾š1ôîjŠt–Ä(„Ý{Âj¥Vc@ãæDO3;Z»ÝäN.'Sô««AU…U#”ôüE'ýpvK˜LÖ† pä´ýJþÆpퟪ?Û¾XÄÆÛ, ²Û@l?:EFýÞ$Ò†„PzçqéÞAE±aƒÆ§Oœ��oBóÐæ. ¼h;tþµÈ¤0ÅdN‰–dL-èLX»‡sÌl»Þò$û—þ-}ß*o|áö=Ά{^Ï%À´·”g$ƒuHY<Ml ƒIÛ7bÝ=~‹U‘ñ[ë':10­°@92y ‹!Ÿ5OñøI–f™–h9ŠYÖꋧwO’‡ÊcJÔ°ýïôù2`ÆíœÖch¤[\Vh‘ £G¸gw@ËÈj¾¸:ëUnå!WDxKZn ß 4ºÎˆ|(™¶ +³ÔZÃg\ÅRR×Z³Pq7á(ɹ÷ç5¯>ûCÞ[–ºÇá`m)yL>­H$!ƒ²-Õ_)¶z_Ï=:g|–­¼03éHØ©Ö -„v_÷3Çmc³Fn²ðªb�0"¬IþŸÍ\Ò yŸÍòÌëp#&ðh†/b„ˆyÑʵI·Š=Œ‹Ì' c¢±IƒòôîÙ.’*H6O½ÝñÙd.˜ùá¨P¾Ä[™ÂRù¹QR!æáb)$¬ØôªrSèO±)R´[ÚȃbE¼M{›6üÝéXþ –E ¶.Ú6ž¶)•ËÕž’”¨1ò˜¶tô±wý"=HóØÎÄD–nJHñmtBþÛÃeŽu•3†Š÷!tnp"œî4h‹™ÆG,ðŠ–7ò#pÅN­·d¾mÁkàÓib‰o]î=m˜•Ha—âÝêc+`„ǽÑ(*¯ [¦.§TÅj‹@x¢Ó]a­‡€¢*Ýd€»Çó9¡@û—ê¦l–Ãy¤SÄ4íkÌÀ~­•œ8ŒÌh÷Œdõ£íqqòõšcÕ0Ö¾#} Pˆn^#ר–†)…e(n‡CíøærfÈcØZóÍ'ZÛÒV™ý<UAõ®Ð<âÄGçxž?:\¥Ö31² ”{&A±mËäÑzt¯kÙD¡#Ý‹¼^S„Auú´@z¦à5ñyçà8˜ÌìE¹>&{Šßj†n–Á §a¤Ä¹ê¼YÆ“A3YÇ©A¹˜D¿[5´(r„aª·—2ÈêÚr‹Å*Kܱc¸Á_®ÿÆ—f¥–ù�²´hìØ&êæ“sGÃn{@E1pÛÌž`úY’9vô‘ŸLÙø9Üô¹ïÍÞØ"ʧõœ;ÏkÉ´ëã‘ÝÿxQUbˆoŠ;*)(I€‘¨TÅ急¯'“׆ܤEšÀP%žµ¿˜+,@¤Üöë»’ª²Æ㙫ËA¾$ì>"ðú¡X'‹SÝÅ+Ž¶ÆɨK5'džñS•ªÔ3ãe÷¬}eW«Ú&X”]Ïœz•§,Ф8/ +o;Há÷øâS«;ÈŠ³ô½ �g?©ä-™¿ÌÍBÍŒ5Ôt¤Pßi Ç™‚ž2ªTÛ8Á,i7y]8|r¬YÙÆñ¾}<û›`ÀQ4:íßÛ–MÆNp½W¼ƒ›nÐM<œÚ;CÛ‡c8Z¯ñ<¦Î+S¨¦|»¼í/Ã¥€sžÑÑá?1´w. >Q\W‡$HÚ‹GCïvZôËêÿ¤kìû²·Â°AR[…lîÝZRž™ìQ@¸ÒÖgm ŠîùlzUŸm†”VüF F{;‹+3ç©GŸã—*N¾43@ì}T°È™ÒWã4¦RA¡ñ—£ãúУ+2~í)í” —Æè7ZéXËt�ÉÃWO,ªL 9nÁ´´ÑRðìÄ"ž0¹yk^¯ºE¶P ª€%¢@ê*çFt3¬ 8¦ö¾¿Þ M<ý-kUFåY@<¾úì´ßä¢@ÀפãQ:2&ôÝPRÙ»ñÈ¡ü}l’"Xèx:· EVY{d÷yÐ}Cd¿×G ÐS#bpwÂÕe¤êR8²�r!‰U1c¾=Uõýa˜8ui…XðŶëg©oî_Þé^’ÁºËÍ@9QQ*KpØÃ¥î1^Àæz I™fX-ÒBJÉ*ªMíå…<];:@¢Œ2Ú°¦Kv÷èÊk–% “¦¢vôž£ßÑ“¾Å+Ô)ÇÌt$-¸@ÇöÄíú=Ë}Z«&Ì“rþ¦“硯KA%ônCÙW¯rhYÌ.™{Ñ ´vrTñ|˜ñÎQYáÆÂÂ7œÎEêþy¼,þ%Œ­¿!U‘}ÌlRGÉ4Çߺ[ ˆ]îXoFÃÊJÌ4ùh2õ`¬ÒÏž ñyàïs¶†�€Hñ[Œtn¿? ´fé^c‡£‡%Æ^´k \-øì{£~w¨ážawÛVh…¯×7¯(9ª8öL~bÑãâ*22 ¥Õe3XÔ¿”ã²²)¢¡Ž4Æ’ó`>r•òò=`)>8DÜaÅQèu¹ñ¡%­úÚƒŒÀ@æm³£GüF—/8v£‘wcÚ  >µ66üB+Ž*ç�%åME¬U´"báWgIôÓÌÈý¥ç5|Ó¤_ÁdsŽêíf›„¦™>vÿía‚>:HcSªkãÎÿñùÞy%ìÈ0£Ú? ÂÚóhÄÎç#K/I{P.KÄ Í—³Ù<ôìP µéÈú¶¶Sàût}M!Gkì_aµS÷TìyÏó/¤ah³ ‚˜(ãÓÞ†\ {ï™™yÐ’5õ¾â m,ý$ZǶ¡pñ…!ØÅ]ÜŠ59‰kdèað1ÑY³¡\€â‡Qù©âÞñ#ЋåÔó‘š‹30ʺo»¥-|ÒPåKOòÝ$ŒU~›\<üÍ¿}÷¯ùC`f %Š¬{¨h•ÓVqÝÂ$¥–QÎñYgN»VôkÝ•r¾‡±La?ä´„{Ÿ‹La¥·ö'ŸÂ`ß9-!aÌn•í<§ó¶ëœÇJä(J›mk*öOû›<.q$z‘ö`¯geW5+ʲ‚aÑcßMܺóêšMײkìmY“äW>ŸÓ˜RA¿ñ¬óì`Áp °#uÿòF–;¼²Ój·ô�gÊ Q7VU4Õ‰ùO (N–Æë9#GóA§a¢DÈX#ÎŽ]ÌG›Ï6†}Í|a`§Ï@6÷U¡Å,º=|AÎœå;^‘Î- _w•Þõ¼®‚x´º€÷R¸o©Þ¯OAÛò5¹f;€ÎLgÕš³Ú4 Úߣ§9ö’ cµLÛ3õÐÍÞ6Ø{¼´µÞósG»Ìd©¿òe‰U§>1$rJ¨jê-Ï ·„AnFÑèKœL ‚Á'÷ê j¶àÊBc’‚OhM%(E›À?à"½Ø k‰éÐYéˆc½aŽñsvžÏNÅø›¶$Ôµ»óŠå.­Ú_Ý·'ùR=B¬ª¶’ík28AÈà„gâáè ‹8¼m¼;õج¬©f™¹ÑïëÕÇYLfd«ïö”À ¬Åÿ¾ñ]›k*Oç;¿ñ™†Ø…GN5a¼à#‡yf ~‹ÛÄì:ó¶-ÏE“wµ,¼R§q϶¥T§;{2ðïôMx-k¸nèãqˆß Š\ý8oGˆë¡Ä¾¥©DUì*H¶˜Z­1IlÕMè@ú_BƹŽÞÍí]Žï¸ñ‰¡’m7þ,÷gÏÞ­âiµ=@Þš58‡õÚ4<U ù©(rä’+ãÌ´.ƒt³6zÑ5“bŒåkÊylgô<í)P½++¿®Û ï ÛZˆXæå:rµ'|V‚>©‚¨ßXY§ŒÉ#;ŒDLŽ|÷#'èRÖeöZe>ªäZzãöìŽÎUr: é³ôÇí}¸ØKäŽ2‹3GdGMu ŸÓÁŠ%3d6áâÞz¿¿ò³$ô‚±»:ŒŒzŸ]0šé…üØ‘OÛQâ:6 {ÃIG9È]øÃòœãàeùÕ÷hÁŽù“!Q(¼4ÆÍ‚ÕBë+L`îz&‘ÃA‰ à|¦èöÙ8¥c žGj¡137f¹ëõ¢b.4§³`š “®A(f¾ùŠþËuo±ÛX:à­ïq¤Ýü‚o}÷G?ó0ÆuZ¬ $:{ÌÆK Õ Ã]?_VWð'º{ ¾Ý.]Uå¾Á p¤£µ×v�4àœ&›ëc<ÃôV‰ï* ©64 €¹ÁQ­XDFÁl=û‘¬†Ô÷ÆœÏ;ÑÂÜ ŒØmàØ•NÎãÛˆ7AÅ“Ò0ó^‹ÒýåÑcªC麅 ÄŒà]ßx)ôÖ󎇽ô—UÚÁ¨ýäÅ«T_¡ˆÿü•y«ƒ‚yç»Ár|aó)ðäÊÑÊâsE¡¾‡/CþþÇI¼oYGFTŽ¨laÅuyO³èךWÄþÂ÷hF³ŸÊΪ¥ÜSÝ1}ÄÔëÜõ•zÿ•k ¶]Ë! Uн?)û Ö*ô„¼ŸõÚü9ª¢Rc´jò ±ÖÞ8RxÝ*†¦¿Èÿ‰BÞ¢sÓÕq Œ¡Y㦠Âñ§B°­7¦“okÊ̤0‹Ÿ–…;¾EɺIT3eï½c± ¡"]kZÖhôsÍÃûŸa–QùB”P‚2(*(g ‚Zí>G­­ÍÊ»7³·‰ghöñ0.Á­G+!s9Y÷/=Ÿ‡(7¹,àsK>4c]±ý„ø›°(‹rØ‹¤/ÞÙI´gò2ós'ˆÚN”;OŸU©ªü¢ùè„ÂcÓ%š‘˜\´N…P[Éê|šÎ+ ‡08/d=¯n/žŸ`•WfHëk[Åç§×°]ÕtDž»a'©ƒÝoý…£Üšv¸áû{—¨ñã"+œ‘´Õa˜Z¿+›Åº…[Z¡Âãü ý¢ï„6n®ÎdÉš‚bA$ß³+ÂYTE·»?uËThwz²½|tAm$˜ýÚ>篧ØÛ«.ðCt½M5¾£åX$ÖÏX­‡®´pqŽeôûžê¥lÒ<Ìj|ù ÒZYØÕv<÷=ݨÝEœÈ/Ÿ%ÏÈê{íC ñTy þW0HªL½_"ÞöÁÑ š„FåqÁ©ew)´IšË:£Y˜$À ˜;¨3ÅÖ­vç»K‘ÇÓþ¨Ô uáê‘OÀ»…£f1¬}…ª¸j×ÞxÐô/5ã¡ÔtĆèEyéˆ6ù£Ð4ÓŽý¿[zq)A}£Í¡õ�0n†ðó8!*l»D´½*«d çFtú}²”S­Ô‹Ÿä,íÑ#Þq�œÑˆ5•Î%•æA´è^i§>î¦Yh³DVL7¿Ùs‰k o?Úž#é.¿b¥ˆRYèã’@tíjƒï¢ˆ.íIŠ´˜Á wy¤8qv+iYÂßÛðbYË ÷Èú‰-pbÁ7ï)D}=§&9×Eñ{Ês”Æ~ÏÖð¾ JnDGF$°¯ÏžÈox¾\¼dŽå¢,õ†7O­Ö=¦ª«|´g€;RZ_ݦäÛôÍ«œ=[¡Õ¬ŸwÍcבSD¾™—û,‹GðŒò)H]Y ¤4{6uí€`{ÑÈG»ªÅ"Y6pß…-Qñ$÷3ãKH+”ù¶š!2ÜkvÆð& 4%kR›à[qO‡äM Íbšò ˜f7¿›¶õ0xhòÓhб]êé©­¤´áéD¾ÝxÙtjü©Ñ0ûkKö€ÚN@•—cÃÐUœYÍpIÂzúÐÕwë Ìoë3óïgãc8œyºt¥ŠB¥M�˜¬e­Ò…û|w/Ã$ä%‡Õ\ò&­çÁtÖÒˆd0å—i¹-hûžÅ§=o’W4,\pN=Ï2e&´ Þ» ïÀËɽ;.Tn,›–žkdú2á3HÖ»åÂ7 üqó\£×1«c#ÜÜ<Å2Ë·QnÒ/>j”*464ƒaLèL EŬdìÔ(qîd™vËzf²CŽ™b„òôèƒ"gQ²ÙÓð€(žt±Íª«OhòÐb\ Q‘c­Ýç»U±s–‚[¤å×=†ïÁ‹RŒ:ô/öÊ"óý¤ÙÞ™î|~T­]Ó¾>Â)8ÚCÝRiì…½¤€µÈf2VºF|ЇÁ…ªŒ¡O¿l…žù¼†ãyz·Ð:÷EÜÔ„25ž«û¯šSz~'[üÜûÉ/„X÷…Þ®ƒØÑ·Ç~…1/`§¿Ú3Eâµ€¯Žä4¶ƒÀˆ»¥«!wØp% îö= ö°Ûœ Q3k'%AÛ›˜U^éwÇ-ŒÇôõ™!wîÕ±¢'KÄ™¡ñzÇCY8qcn1ž¦-öüË-—‚•f(8×t2«Ï«èÙÛ„x¢lHrÑÐRŽéã2C¯›UA;pw¤ÐèàÕ K¥ÝMVrõÚóòÖû2.BF@›ôpP “g?ð#$\ÈÙ^Tуuãd)¨Vì$T ë'7[;ÄcdÄýGJÙMóÇdNó©=ŒZÙWuþµCnWk5v_‰w>"D%b*¹Çƒ.õ®ØŸA©>Opw XÖíúIPtì½x¥\gžPVÁŒYzâ$.i¾Ê´)ÿéØõrü;Xm’/PeÐÂ]ï³óysÂÃÉjÓù Çûkö¥¶qÈŠ­(Z¦"H&Å4 4B!aÑbM7¬{F$ë…QŸ9vƒÃFº˜-X Zze6Vp ˆ•_åÕ÷õÒ_- ìj7#6hÚæAØ)tb³‚“À*2þ­€<Wìezóû}-áí‰Ój¯|ÙÙkÕÐò?ª0DSï±;fÂÚ{6Ê[xze«ú2ôe"äŒH ¬ëGŒwfµ>èï$ŒS·f$ô"],öS´€?ÏÞ•Ô‡)g7~tì>ÉS·ÿ �½(\ªÃŒñ‰Ò„xV‰&»–=-z³uì!´ÖßÐ[ãüz5Řx£¦­<Y9 –¡KoÑ°®ì øÖÝA/üÎéP`òiô®-¶¨P ¦)bðkŽozŸyêŒL*S£Î#Åá»2q¤ ?éRÆ£u0L+Z—V6ùLýfÝïÂÊ5AÛð{EûnGAØù}ÿ(ù­uU˜š¯Á¦Z“Uú‚NÇ Þ›-Z#­Ÿ íö¨ØP‰La'£¬· .·I¨jô ¹Û4ÁÅÌËK Ë— i#Ý“úd·;#+qžiio~%‹ÕèbÝ^Ü×ͪ<ïîÂ(›ÐÏçê‚%zÛ „mÇɲa \ý䯨$](ç0ó5¥ºõ ø|0],0CeS±^½9\nÆÇM“1Z@F–(k½†— íõj¥SKïr{ZÞsË¡hqeÓÎÀ“XÑ<äRß÷™‘yCä?£¶fT¢Ä ÑÚ7’ûNØ×J6�°1tK¥ã ;ÊZišMÌcý÷.ßW?×*Z0mé1Üb=¾¡«§;åò·ÒÔÞå�¯É“hj 'ºUC ©5±/†ï¸Ue‹íŠ"ŽªtÀ!››;< 2ŽrÝù ˆ£QÝå¿&”i„I8÷\QÓ<Bˆ#°÷V3 Ûf#¬µNPa©ÎåõžYc'V/Q=£ZEW€†ØuK‚7¡¼æíì•,+þ£ÉP¹PÉ»íAHÜú8 IC1Ÿ&å3*b3ÏÝ$ÃX*¹Ä‹îE±ß"¨Ö­›b å~vvÁwµ~C|gHªÅ‹ÑŠp£mÃÂfYS�ä2üïmXòÜï!é1££c©`¹Ü´þÌ]÷!ÿ,vÏ›ë¾Ñ«ìECuM4i”Ä:uö+:AüŤ1öv-óR§’nÚûÉSâfÁ|Óêúb:1?ž ¥¾‡P.þ")¬øè©6¶™ËӒ˺6m)J›(”}´ë]ÿ»!b_I)¤o¢•Tô“§î‰ªØW÷ Ø ­U!U—»]ýˆ¸œÙl›Ñç- ÿêD¢2Æy†ØjèÆü+ïug9]­¤2ò͸1g„KZzMy;¶è­Ÿi7¹çÊ›q“”"NÔ(çߎEÀo ÀCÝVºñ‡aÇ™à‹˜ñ4óL-¾Õâ|ñänšZ]‘ÿƱ<M})=‚¶g?œÚû °ªñ+öv&«Bo›x)3)Xä=Þn|7NiÏì¸]`§W/̳ÒÜòP±}ùQš š�eSz*oÿkûòráèLCÓƒ­µQ¾*A‘öÔ¶^—DùbÆ— c}¨Í©ËCi{PCzÆËÀé‰]-‡Õk„õDËþ8f©‹ÌÈà_··æÝšâ„2;èï¶hÿ¤_yS®¿ŽJ)£­‚;#ZmG‘¦¢Ûù~ØÆñp÷Ž+žð�Åxõwž«gû습“±4Œxtì¬;žçˆõÔ®,}ÀM ÖYBowT,Ó®eSjËI¾TrñìÄtéþ2,0›Uº€7"!©3úâôíc¦Ã%œ½ü n´€¨#EHÿ_~÷ŽÑ¶…°¤ßÓ-ÚôT7 ú7Ç1N€E¼Hüçíx:u =\IV9â(M˜þÁÖv `üÝd0’I¼Jo.³…i2x5ø›?®©ö^¯ÍdŒ<W@±Tâ[­Ð'Ï]•jÂDó9Ø”å–I¥ÜSùÀ$†5 /ù”åY¶pZ4F_ñqð:ô¦¥ zÊ�%™–â¯æêVÓ05­ãÕLnx÷íåQ­1¶ÕÌlbA 7%@ Y_Û(Xˆã@ÍégíƒûFqçKGôš€þ”ˆF>c.Sµ¶´S”kV5cNeAóU¬ÍÍFÞpÆMWšm¡§ÞÅNZTÃÇAúþí2]§DÁ€˜v‡v ·eîìXŸºsÒØ©ÕÄÀaö 'o¦²xéDI˜ 9yÙ~”Û“§@íþ`¦O»ž-ÌË“™bV…K7·9òmo©¶WÊDÉkÇÌ2PGÁŒ ãYõ ·µ´Î´×NßJÂO¬—À/,“ðJê´…*e2[ï¢\Fšòr0âéóŠ2y9a,<lŒÓY¦Õ âxqj[;Míz`W~´ðËbçÑ%ãÍ^²³Nè@ê¯Ý$wŽß™"t}ä"Òr•_6%ÑÂö-“ž@ÕŽ:Ûb'c.RMÃÒhÿl¥íTã8±¦\hsŠDbÓlº:p^INrGF¨îJN4Û33Ç[Qú¹‚¡ Ñ8#ðŒVÇþéŸá…Qpœe~Zƒ]ÉÑþÝZ4b®˜Ïæ°W¹€/<&VŒÊ¦¯)3ÛÔÃߢÑ9À#c¶Ç<ÈØÜ„;=@‰»½ þy£ÍU ±ô²­B¸ÞÜH³OTu£¬t_’iÊÓ†ž‰aRÐeÏ}='N@èŒÂœê%¥GűŠ¨!å–ítk(T„äR¤®XhÃŒÊá¹/w9»åÂ0cš-Þ×Ú/P¶}/q‘ÓÄ&>¦Ÿl‹¢ÄRa$ZxENGÏ©ÏRµ¤ù蟕èn®›m$E”yÎ…zGAnµs‹ö{'È^÷@¹˜¹|¯e$w±œ–eè1$éi¦ÌKÊà9ß²®¤I”ñ¿°ÇëMŒ"q2Ü\ýSI‚¬_{MŒqwì-;œù$jºøá±chµ€¦ÇI÷µ7 ä)¡<]@Óô¤ð¯1ŒG¼¹šï»4Y³¿ ´³\ŠOȪïxÇ©NÒ­!Ã/­¢\³N¹q1U8!7½Áè&@7C/_5.Žu/Ü{ÁÉÉöÀžV×${§”$„îŠjµ4¤æëàˆ!ô¯¨ôâz¾ f¹i1×IþöH»!¯ßÝ4o<°ªâÛ…‘ 3ŸF¸úQ\T6=f°)Ÿvy³õ<é¿ï: ÐMáÇuîêÉÁ—KñI‹e°°¤ÄÜg ø£(¼í ¦F»nÜÒ'ýTô6&ï²yf¸±y «þÈ€ƒ9ôôºÃOV5Øt•yëhHKrÕd¬Æë —Œ”3u7í’x¾Í±ðÊåµêgu ᮨánjºÕÖ¾®»AxÌ×ï_{9­Öe””‰ÈË_/¦ï0¤­'PÆã–Ç„÷/#Wƒ ¥äÈOoŽW﹯©t¡3yÕál6âfg Ñ=´�¶Ý°9tíƒ?ƒFÚBÖ†©—Å-Å1L„²¢ ÚÓ •Óoªµ°Ê|39ª©°¦ß+S3â¿[m(šu•Î¼¶ B›umÎwuGVHM¼Ä÷1d k5ÛDÖžý…”C°>„²¦™²°°Ýþ¨<Úúfׯk¥9¢á¼ëÝÒ#—#cÆ)kÚ–Nê ð³8(ïý  Ò »ä:Új⢲¬[Ìy«=”ÓŽm-‡F„¬ïÙSö›mÕk¨^ahÆÒHŒ €žÀ™øÞ.~0jÎNJ4¤¼' ;FdwÖ‘9`žŠœÈt?’¤­¿8�m¤e÷ŸŽ«Åxþº\‰!þ -ëù^A{†.¬öeY‰ˆ¡;s%+YUiVÚ‡7óB_p7°¼]/¥çl"Ö÷uT¶øäÇ…ž½\AÎ €„ÅîZ?ÖP°Pñ@H‚†ÂzÖª;`Ä]:z$…b‹æ•ß°b‘¯AÄòŽl§^}~ÛUǺ7-zhR¹Üµ¦¹ãRcÇ Ì¼ƒGÀ‰+“[§=lç‘:6ô.–àÇГ£gôNӗ̬–&ƒÅðnãàþ¹/üÛz¦Z¤·Îßu’ê�wÕømŒ:7U•Åg‚‹ªk¦ÂÖ×»oÏÕP[-J½VxÙã+kç*ÒÃ<+1›=Jžö ¼"‹ü =Ççlyð•AH¬”~ëY‡œ5ÊÉ�H9"õ ^‚w‹ô*ó·&+ 5hì^gmöl5Ì ô‹rV÷J }æ 쉹•Áî;‰³>ç)<<rä9³jÊf¨ô„Ö‘×ö¥ÑQ"VeE1z¸&–µ‰Ny.KSùŸgц'º+R¸ j:pëÀÚsþ¹H2aânw®ÊQ™ü¡¡í2Ìbëáp¬Æa‹á ·=²2óô™@NŠVEõÇK=,Dâ#Epû–m¦¼rd@y R†n7C“®™è„§oS£…Íé¼1Šйs ˜¾e`Õ™_þFã/)3ßuhû$ Âoõ[Ø·¬ÙM«“ê6\ èËÌvTT¾0˹ÒCÌ×J°¥KcŠ“ä_RÖoרk–g¾?#§=e:¥sîÍ §T2FÊ6/”Šœ;X·n¢ O¥õjM!8µ /šPt7+úüX½Ò‚VkYŽZkýnÖH.‹Kz¿žŠë+×tÇ ¹CZQSæž5 zf”mÓâ'¬ù XÊnå?YuT%í6»å%lhß^’¿åAÉxöW̳\[¸ j@zËÿ˜ä‹fZâ5ŧ=dÝ”TY·àÒ˾é×ÓÉJ£`7ÕõJªè_°ø’4)0ëfñ ÖÁ£3$¶àe(§èÀLšä¹©Š`O¥¢UèøÁÈ'rÙ—¥ŠLÀw÷:‡ÚÑÿÎI2T\reƒhø™qW¥N>™­‚FØ\¥µb§±àÖ@¼ÍÆ]»ê4_œEl'@Á³k—HIs ¸'ÝÔ#tbÞè~ÐïêóÄ[ [º§sÔ£ÌfV3½=&ÒocÇò­º–~ïIâÌŸTKˆ âN»ùR 㿾¯§·ã΢c(\ï9 yª…íN@–µqfl]·™õ‚FN»5›n㦙ƀ9šimÕpÍô £´ôUcQi%wN^ ŒŽ–m;¿ vÅK>½éŒMÜ«HÝäΠÖã®ûƒµ"#¨Å11"˜OŠpwvOf‘¡è¨kz“ÅønZèðW˜ŽÀÀþ˜·×>/³ k7 :=ŠúKƒº8teiÁBÓmFùGëåøNhrû:?B.RòÿgíÏÖSW–nQôZó)|uöÍk«..%$ [Y3¾ýþÏq¢Edd¦0`ÜçÚEGöø')32ŠV]»(8Rɇa·ôP©[¶1'e¡$_.À<Îí-NâA˜{úèåþªAx+ËLzHWð[î1ØšŒ áÁÇ,ô—ô=ðÔcK ¬Êu:©ñY__T|JãÌ”‚Õëùª¶È§¼tŒWG…Q1#JΛnóqÇtÞ“‡FHœAÀóÛ=„}ÁY<Gü8ü$å‹o`ZT¬Q| ÇΟRŠÎ¡6û‹HJâÂÿÜPãØWA2[žíåZ=‚Ý+â?‘GâF §C€*m;™Ncö¯oÜNÚì"iŽÛ‹óüægþìUv’Ô“ˆcPvM¥mÑ·ê• â[‹þ7Nöß((™)Äå'¿z¨³U®AÓ9â-¤ô\odnPÊoJþEû>Ö}ñÊ«’z’0ÝjÚ'V1‹éß\Ëþ/95¨¼Ÿx¡ËQSèüôÔº(ú>°Cç ­ûù'+)›µ jòSʲàrº‚¢Ën[=‚ˆ¬�œÞv)ëñ׉– Efˆbÿ´µ8†€EöVñ~´²m¸x$a1ÅBÓ£Hèºáøé€X›-ár=>Øzx®ëÍ{dÎÛ´@½×v`³pòNˆÝfh Š /jœu+ŸC<’ÔÎF1ò‰‚SO åp6a=)†5R8ý5Ú+§¾eQ±ÕËýC#cãF¦Äð™N‚|¯#qÑÄ3RüÁ|dº7¥h{ £H[aóËõV2ÏY:åÅø4ò/PAè¢úÝÀ—Äw’S¿G¯kö¡ÜÜlQFïVE3æ®ùò—>>|G¤Íö)¨™³'5‰õÏÃh¦Áöõ ã–;¥FmA‡Ý‘xâŵŽðJ8ùmÅâõWžxq¬A…qʦ"(»YÏtfÖNœþ<c§Óe6ý)Î3Ø‹J¯‡¬†T’ÒFl¨Œ¿Î¶s2 ]/=Xá¢�ÐW¡Ÿ’TÂÍã2RÛíÜ‹|XŠ 6ie~)æ&^Ê!hÖfóÞrÀ¤ ͬ„oa™¯µOŸ’Iëi߸šd:S(<Œ¿ ­'IæknR0íéÉzÂlº¶ž´æŒ2Ƨ«k ›)âÓÄ5šžÊ0Ñ2|·š} O£‚¢øΫÚ+q~P‚�¥;îVXŒØžÁöÊ…¬€¬^šŠ´I ¡) æ:ñéßËu¬{'ÏpÔ‚l?h(ê�èkí*^p²(!Zûì¯^ŠÇÆž@Ívÿ ÞÇA¹V cTm1µmº±8”PÂ¥ÿ=ϧÍpË‚û¿„Ý3‚ÑðÝ©ª9ßÄ:2GꀸÛú}Y4N‘å´ÃZV!†Œ¡ˆü²¶ÈW !¶)òí¿k½°5TÀ|@Ý´ú[‡kÍÒ=ÚZtHlÔ­åhu‰5êÞÞ3ñ{h%ãOÍC“Ö @‹åÈ'‚3ŸŒ*¿is,§‹ÂðJú‚Ÿ¢*Nè qìHÛOO¬fß™š7èNËü³BY®x¼ÈL7ûœÄÒzS‹Íi8¸þî GµyaY,dyqN+å¿(¤ZÅ8lA3ž†>r½˜,$å"x°ú·O!ÔIé À*MƒÜêÀA“NlTpªhÚÏŒ46y‹±%Òß®2²´ô^~ÜÅL“2œj3áBÑš³Ü÷~&ó¤+F8=8Qóè>Íì¦âNØ�Ó#ÕS{YÎ#/CzEO Wµ…^t{ è‰ùþ|å¼ÑX8ˆBí®xÜÚÙðŸº]î>Jæ ¯øÿrý±6J‹ÓUcˆ²¾i¥A±S‚&àÝð%ö‡.©x(÷ŽÛàgm;ARÀŒ¸Ö?R<Z»\À’4zmýÑ9#oMµë(fw³íÝ<†Ý=w&Œí025_°Çü®ØÕNx‰ŸªŸù{<8ÓÎð¼ZŒ0r vÊ­Šâ9 G:‹$i=˜ÓR\s Õ¦F`bñ$†‚mç P¸§.Íé¶+èT´äé´[1|ŒìÌn§úŠß•!Š˜Â­Ë¡²”jB´ÐÂ*8&€fmM— !®9Ûåì‹$š¾ÍËþ¥qæ£éÑ9§@ogÓAØR!·« Jµ¼)œ›)*%\ý –—EªÊ8ôYl“h£[Ó1hoŽ#e\W$m§Ê&ôfbõ{©[~´‹VÞó.a»‚‰­ »ˆuwtã ía8œoÌíûï[i4ÈÓ ßfîÜ�ñWT@*K¢²X#‡aH·*WÀ²ƒ&w-üŸb¶< ^‹ ¿"æŸymïB¼È‘ÏúDDLuÝwuš…¡ã; Dñ¬ÀŒL\§Z‹Ü¹çšôÝ?)¿õë¦ðI§û~oSÙ7ÓÞ–3å:/ªÞvç¾?I7ô»Ã¤£|ÆFåðýðpPÒ5wÄœçÊÞ(ºqS¿=—Ž„=ûø벊§yÂP ‹ÒÜ\ú e<phMRüWPø0q  Q9IyÜ)‹ê½£ªÁ”1^Ty‹Š6;ð:÷pî â~šÉYP|(£¤Ú¦pŸÎ(ºCÍÕœmêIì]ùàŠ(÷äšØûp¦/– zê0&ì0Açò¤´:9êHp'çUñx¶ÈƒÛÊ”Qt¶˜0:úO ÿOøqŸ&“†>½òà-«2› —ìècUy#qè4ŸØàKjQ®zdˆçŽÐ-R×SÙyëNCú8Øg|´ãi¬ƪîï0O ÂùRW|@)B«ŒZ·ñh¡ŠÅ YÿŸ4­­‰[$ðÌŠ¥Etª#Ÿjôu5@ÐsUÕ¿n KHߺ¯&Ž«ÄMWVÑ·l7Î!Xª.•Ñ×W 1Eæ'#FV_KÙ—ÑŠ|ÇÆÿ4µ¶†YàK])“šÎ#Àþ«®WâƒÐ s"”A6µÞwbo^1wOgDn‹ŠBË~` )”Á[¡°p[H–oûsìô'ÑDDs?Ø^iPÃèؾvŠžÌçå»Eœhõµ™¨¹m‹ÅñJZ¦ÀŠ§Hb‚ÌÈ1ôÉžXß–{¤]L²ÃK¾pûsQF/Úµg³Õvf '´§§ÝëÓ}ƒ–(užÂ=[z€;e¦ìjCÓò‹õ"àSŠ˜Jt³"Tþ匒þT؉­;k%ƒˆ‚sSPŽÔ{›KFŽ¾IË2K;7ÒŒ^{7Lf±kƒ|S°Ÿ l§<ÍÜtc… ÌÀIóïò¹˜RVf¾v2ÛJBÁ@á ¼ôko»™Ö割oèì÷G;‘7¹· ‘‰Ñ顨áxs›é ìŒ{Рá#ÃÍ¿‘+d1PTL¾vƒNˆí…ÿ%r‘EzбE¸Ð>ÚOÑ¿zŠªôåeËÌÜik¼¤dY»„°2b¢—¡¢ÏµÙéIÍ39ݹpÜÇäÄ¡oø&ÈÖ 촉-,d#TÍ» ð]Œ\V+%{q§îµc~†¡@~ŽŽÁä<x4ßå äs/pÈ_‚Óõ´669Ý¿v î" $ú÷ê8¶Ìô|,ÎuYcU×Bä×aÝN×–‘_žeÝ‹Æunö t™tTxÔ/yåVm`²-„ýMÇÐ[M§o{ß{e–y¾À¯1ÏÝRo0q¦ÅZlè;üDl·VžìŒã±²óåm’¼î8…•ÇgëHJ}êÁÌoR> ûó}¡bý¦ÀZY¨3àx<Q(ö;æ¸*ýòƒp|yµd`Ýâ0‚áKÚ z×ØSnÂÊé° ÿ»óaî\L{Ù²ÈO¬b“©‚¸k=Ÿ_Ãý‰Ù£l;Î2›mc¿R>ŒuQõ*ƒñðVù3§HfYGËo¯ÆaÄÓpeâ$•;£B%ùF %gJ{ZÃÒוöZÏ?@BŸm_¥I”)÷†GÖþÔ ‡/u”`®zkbÖcƒüZÌÍóµÞ©§àuVöAÌ$>ä²ÚÍaÔœhYJ|A²¨²õ±Þ 'Œñ .Ù4ËLÝ'‹©ž¹iƒCÑü v„÷›g‘e‘HÝ3<é·Žy¹Zõy|ç?³ .=Ê[§l&:t?k1EÅ#;Õ:ôí›øÝü¤¯ßóäÂgãRæÑÃeá½užìÛÃô†%}F™GÜÕsuW«ºHMy0˜cØý�‘œ¤þòÔ¾(ÕÜ8zÓ;úã—ŸN㤨´!( ‰öÝ–­v³L—Ì(ÞftŽj\·*쯵³‹•* DZwIP4ŠcHøÿ9XG!ÿùjü|þ+dÓ©kúD2¿Èt«MV‚4ytÙÖtÛ~u<Ú"‡cB!ÏûóÝÚÍwâ]ªŒõb”0ßø?Ì~â…ÒP€³è˸þð?xšœ¡±š` âÖªkÅ /ýÛ_¢c§R*ý­ý˜±Õ¼Eh-ÌN?žôÒ­¯º…«ÌV¬NˆÇ4 *‡ŠÏ�86ùûrrÖNì•úXÜ›2°t bb”óìÍÙèjdРRü¢¼gåL€D±m=sæs¹È)[LêÙ2ÞÌæŸLbž ê3Þéy»<Wu…ܘ7²…QØΞ h Ù+†o Úûù½‹Q©7‰JÚ€uã5 ÷º“cÃV’Oû×÷\(……©2 t^ïÏ)%0 Ý,Ñ_£ªÑjúñàt;¯en~úOS+|™Qºkx(ùh½ÕD¶§GÀjtØÇOä…Çâ—™ñYfú'dêCdöžŽëLñ®·^´vûŽcø—FfËú2g&a¥ÅĦfÂ�’ùQsnuNu×ñ5 S5@’²xØ¡þø÷ª9ŒêÓR[‰×´dÜÓuõedcf/ ôÆ­ )Â.ôê+i¼Õ •$çafº€!þ@ŒôþèîÞ0/É3¿ì¡´;duMÌh'„�Ø/§!pò‹+óÃlü=¦ŠVq欈¤–Ac˜_Úî3I=s°ÂpZæ ʾ÷è<Çlcð™Ù»v°„Æ®izåCÒIqØ ÏƒÖ"Iî醳<á´£6.›ˆ*£» ¼|÷ÆîçùŒ^TÚ./µÏÕ%%ÕÇ µø³™µé‡ø²ê^ú³yX[à\£O éñ]Ìž2 Þ¨ ™,òijY•¡/…ú€Å ž–rOiîló·éèð ÚþçÖ‹Ä~—R‚†j“r«Dœl5‰KSÆO³mó/ávåZP*Û¥0ƒ\(ç·J ‚yÀŽ§°MF[Ÿë!ÉëþaiÓúë±û®n®½£+¤9´Q¬?7̧N0Í4B³õ¿Êl²ØWꎣEßnV  ÿO;¦Ã›´jœ'fÎC="¬ÅóÇT›Ä)0³E†™aP̶—žÇ§-=ðwü*8O}ï�z÷ À¯±­¦¢´ÒyÇ•é¼ãJ[_7ÒS£Í;ßy8Qè«À<âLaØö*Ù Ë›ã¡ÔÜgÞ:ßþ5üA -¤ŒògêÈ*�—J[‹Ã·µ4B:ËÅ»üá8 +¿Ø Í„{´”Õ¦¾Æ ?M6eðôCû’5néñÑYÑEL?Ï„Y±ÚZŽq¶6ý|Õü3òð4L´^>)-'dzƉ¸Þ]ÝK󖎺/¾o·r7Ö>“ZÅ»*Ȇ݊d=} ƒí ¬ hÌä"{¹wŒÛæD¨l¿vO‡7­C3¬ ÍBŽA´CõþèÌ)?üÍ?aÌo¬ô°• 0<C¶@¦Ÿ÷V"<]‘L›7?ÈÓúD7öŽíÒ ÚïNŠ¾h_c{Öjn'`=ïFQ÷3.«ÌuÑéi{$³öŒÕYHgH1³j‡Jœ›©Øoü¤Í+mŒ®?QÞ@ézk»ºžŒâ-좻:Y½Ï3fûÜ D‰ŠEë½¾*| }åPº HÌE§¾$o¥>Þ4ÊècÒš×:L3_ Œ7[?¿+ ›5€èçk“ ƒü7=ÊJFIÞB%\´xGÃŒ’¸t§UßSFoìΤý47Òq~öfµEæ±MB¦á…CçvªUGæu‚¶ Ý‹$¼¨ôäÓEͮ΃|jÝ_NiÏNp;ZáÛ kL§kݯ€žQèc´Ce þ©Ëów˼óØ•g4] œ¤Õ±r{È™;øF53EÌ´uT¼jÍ%¼Ö‹ÿÈ™+´Z°üÅTûÏQë« -Uo—7¾SlKs6š{Bi3›Ö)Þ„žn={ªØ² ›j_Œ×ÙaZäo*¶¤HòÒlÖJ‚sF¹ÞÞË6uÿ§sF1¿ñCÌ<y™¹³>Eب"¦wâÛJIê4ÿ÷-+ßþyË*È‘cÓÀoäFb­Cý§ÌWži…Ç8ÈÍOÀÍÙs‘�T§(öÇŸ¥`â¼pe$ª¨<5JC…À_×õoæÎÄ›!±xÓ®âCË(wtÃÐ-³L0<ØjD‡ãWËåüŽûbßóÄKRö½ÙÖfPzkÎ&«*àÑWèœkjg¢dG¤CìÀŽrѨ]QªÚ9÷yÁPÎrøÃÒ8 íÎT¡gµÞu4ûŽÒgkä-¼z7ïO‹}½/ýšZßB çsTÃàLqTœ§DzëM—±6Fhõ:'l¶F¨¿þoÃð"_©WT'¤ÞP ²{ýáؽ}¨ ähûfZoâö±XA†û">I¹ž‹lÍtïœ^Ⱦ¼²‡þÎ>;óHïL!h€c>ŒöZ{¿¥©é¼_YNÒÒ—=‚&8ŠÜÂJ¬üÃÔ³…¢´Óíæ<ê‹lµ'à”óGäcã�Ü]ðŽD3ôz(Žª•¹Q ¡•œÁò@Uân+ü¥ÔŠS,ÒføÊZ-N£íªÉ v©aj¼œ"{óœ� dÒfKßÕé"`óáèªîá<H~¢ÂI£bÈH+Z¦cÃ'æäþ{Ñ_¼Ö•ÍÕ]JÓå'íÔ«(˜Fz¡÷´žv`s¦7Ji¾d~}'î[s¢op¢Ô…Iæ¨ãÊVë“<3}”WšyþÅ�©d”9›=…úìS™S@9K3ÖÜyýG#­2“fŠV!‰;¥x— :}@Ô*…†b&+#™Ôk`“Ü7z #–s‹ÎƒÓTA* ܼ©¡æf—‰õ—m¡Ä~z³S€òm�c2nÿ«ã8\ÿâLIB¾o= [€9—Yo9ÀfƒuÐËûçU¬¨‡X…ÐûžJ4X‹H¾ÁêOíu`@8‹]YQkÌš²h1~û…uÁÂ2{Zí{PGâ$Œ»÷c5} ½Ð{òø t“'Lƒ˜\Ùj.c …yJì\¦ÓÅ ÜîŸ[öùF‘iÇl¶I/g/ÏäÑÉe†€KŽÓ}šý’Åýl5¯¾#.VšÂœó´mwêÜš. ÙIS‹ë 2^U¶”ŠGÀ…A¼¿xÚô�&iÊ[ß¿Q¦¸Õê¼P&Q6ƒ*Ä$+îŒ6Êfže:°>”'H¸'x¸8ñFÌ<"Ýœò ÝŽiDá¿FŸWlpX`”²Á!³Ð‰®oæ]j‘••O†�¤Ô¿Óqc‰ÌF÷­'^ó£H¼{±Ø4+BBeɇ±ö£Ábý1ì»—ä Ó•!Dd vÙ¸wóFô°Vàçß¡í\B-8¨VÅð·Ø+&†þ§ ‚³sA¶ê‘®œ,zm[OtB ía\¹ƒÛÍ]šzoà}±A u@|ó}ãÿenšeá­ÞrWÒ­³2€…!ïz‡›ˆA¶› 县K…fs½ÃÝ SŸ¼Oûðz¢@U[ù�ó—V¥™¬ ®Ä-†_?#yV*­\ñv¬0G¢ÃãÜ9ƒxÏÀ‰…¸¸8Ó7}Æê³gG”!Ö³¶jh¼ž8'¢ª`N'×;œæ˜ýF™:ó ilbÞw9­v“‹ThÎ%Î…­›Ó©îÅ<ÀAx$¶~ßMÞ&ƒ _ŒïžhÃ|À¬±)æCH³nPPù°K¨ÄbcÑÈx7ÌTÙÐføP”UßÕR ê…|úNü.nGžúÝú#R‘p꽞í3‹H9‰,æêåö [\¿Þ4Œ'¯h3:£@²œúÃKMcõIQÜ…%8çÆKïêÊ\Fswã˜û‚ì,JÕA5z+€ré»Óx²™ÀO2qÑ ýF†’ÝÏM!û`êKCîó󋧈PŸ˜‚Œ%ç4%,Š•Á‡[®Mª,F±ñ"J ¡ÐýV×Õ¶¥™ê,+G Êà›@×”x°©9³Ø|¼®U®$=8ýk“”,?ç¤~ñ³­ #AWBˆ‡NýýÎfJ s ¡Î@/L«ý=‰ÐäeŸä{¿¡ÐÃi ~Uÿᕼª#FÅ2»sZáÒ{<öÚô`8]ú™}qlïÏÓ ¼ËFP¤5äÛ/<%?!NÓN»ÄL.r\²Ëa–’’Kçÿ+jõ �7¯Mî+Çð’^ JqkuiØÜÏpÐz£ivµkg—(~ØZÇ{GOe·7eè±Þ†å4ïY%˜²æÔ›úS…m•!l2ò Šdê9ð°~æe(é´û×S¥•‘ÌPäœf†g­~ãÁÅ“UhÉ S¨48¦²iu‰M&ä@=OÇùWÄð(Í­9•°çSåbg !kúl¡>lÚˆ‹�ÿüFÌ̤ô¶” %ö”u_Œ{~µÓÙœ>=-¥Û‡dƒ8F:Ê,–«hÕÅÄD‹«0YñU°èß~÷ …'>¦6�è}_T797V‹šÇü¬üiõ…Íìü”E­.ÊœÜa± égRòaÙÏ÷ňî©NÅ©cÂJ3ÀêòsöÜĬ ]¿VGUáá•°¸¡²¯°ç¢ œ‹·yÝ×Còí75¸Wƒ—¶·­�¢[ÜÚÔÁ;[½uÌ[£h^-""³#’¥»>£{u={¸-C 17«9ÌûÓˆøÚu:ߧsé.Æ î4sí žún¶idÖ³ƒKí–<'°±€:2M‡Ù»úQ$Ûçªð_Úa&/µ›Ô}sЬ‰â"ýY±fp—²ƒ¥#„Jø»ª[æ„û® Ê¡ÑÄMÅý©›ðx2w®ê¯+O¨„Ù°2÷DOjc|›ûfWB ›(r´9Îíy/¢:Ȥjîê¡~¢U¸—$+æYO”­3/�†¿Ö™L°í8à ¨ªæþt¹S]Gk,&ŒäéžÄu«%Pµ&â]G¹ Ù$7 õQ¶b—„†:[ê2)í3¶RHôŠ}1$܉oLÚ8Š­/aÄi Û\v/ ¢v¤ÏæÄ-Cïß{ÍŸ8òºP»’2­Ýn«4£ÃP3ÒãÚ¥œu÷÷ p®JÑŸ/ Š;{FuøSçù¶^xL³vâ ì„z'AZ×f¡—ìvDUeÛªê<¨ËQ²—júCiE*¹IëŸ|»ZI$àe˜y?»ËʪzÔ4õŽ’™EäÉäM¼K¬ëÔ9ªqB<3Ϻþô\âpгA`O¢Ø`ºÝþÙ®\¶µSmµr»¯¨Æ„=Äùݬtàõèo@™H#h¯ :Q0È G /9QºCÒv¥4Fh•RáÎ*HŸ2kœNm¦Ë ñEù–jM tðOÄûwSÝ'O]P"kvò‚¾·-¬‡9íÀyøúôngÊE/5wj4 ¿wõ$SOµžVH‡,­KĹ¹…IÓb²FnÌw_7åÅÙ“ (ÇÅï‹Gg¸ÓÅ°¸ˆ~ï Ð"[¡7 …— ¾$r¬ÏL€ÓŽÏL)5ƒ†I‡¯ða¤™„_jÐTUá¤eü4Ñw^,]¥Š­3Ü‹bŽ‘Ú€˜h^YÍU1±>ûÍ–G3ž''MrÒø2ÁÏ‚ÓÝø³ZŸ ú¾ÃwÃoLìÑsÏ Z–�V,žÂ4•|໳¾ÆúÅm¤leR23#F/AÜèÇÊa¼ÈÊðŒô°x¨²û̃pØƇh\¿¡…äU`~ZÔaÂÿFÚòÎ`$ÎVXñ•wTVt¸ž€C2QÑ•ÑÈê¥þ¹´¶QLÌsC�œ)ÌûÚõ>ðÜœ êð£¯Çl±BanŽÔý. 2kͱ©û­�vXl“ÃË"z²IsÀÆ<tšÜÀ3­ çpêŠLI…ñ>zè‰ÅþÒ§8þZÔÎ#jß]g1Œþ-wMß[ôP·¨ýp¿ÎߥkéôÐt‹áñ…¦"Í(s´¢lX ‡½ *G¦6’l RαEás¡Š°mí«ÁÞémb¾ä™çǺ"àTέøNqypþRU ^å`*ÌwÅ QK%ŸzXåû]¡€D–8´Nð~‰à¦%Ÿ›qôt¤£¡Zv:§ç  0zr²“à§Â¤#óúƒ°E#Ï€föù¯=„ ñæÿI9Z›Nå8=»!«9“²"t qÒ,í4Cð`uÍj ý¾Í ã2¹yŠ›#ÏÕþ_ç6ƒœÅÐk+‘tåJÜ´¤ú‡ ,ëùÐ3NÂ$£™S¸1HÁŽV^±u!6ôi´ ë·âüüX5ÝzÎÊè?d<2=¾ÎŠ«.­X�÷f Z3ýê ´ €œ¯¿uH¶c5¹-ÜcDEÜt&Ê™~!mTIw…Ô²AÖÅ Ù^q›k±¨°ZزH.­‘fËi¢@±XƒÏaÔ~œÅfÚèÐÞL»§ª¥QÃà,‡{Ñ\†+cÆZHPQ–ŒÖ®öx|Â’±hEæ9ùÆ”×òA¥rqGî÷r= ‘ íÚ‹;n£šW ׌·u¤½F¢ æì ¥Þ'ã×ù–ö]0Ѭ¢ÕC Š#cv£ÇÕ­l–ÑÉ2/VYg9 òñ¼^-óÀkwh÷ÀcڽƺKû&b�vŸTAº¨Î¥a´†£€‘t5œ¦ã X·»xÞ0õÍJX2h¹TA¼èYVÕ,¼ðÖ‚XÆC »ì¾Í~ð[ íy R_àCVFÇÄtsg!ƒXáÁîóŒÅç1uG#P¾¼1¬r~ì]ªg‚zraŇg«úeÔ›`±‰þ ›âªïñ³å»<:bäúþœŲõ¨\ÞÐÒNïˆy3³€æÿLáÔ n?L»–² fGžkÑL\×íEAÁ¼|Ÿð­©x©(.G¢ôh•ˆù§÷(ör˜ŸE˜£ÿ¤ÑÊ9®LÛ°©+ƼٟN¦ûü—=CëEŠu®A¶óž¤’Ç…Ü€Lêd=]¢{aäJÞÒ”�ãTÙ¬F vù þc³éUÚúÄ<B}]zz6Bš¦²—Þ¸v0Ì÷ó°YžfÍÅÌí«1¢wS7z¯òq²Hˆ"Pó §€~~/Z9óŸ5´Ê•‘ ¹P6Ôœ}F•¡28[7"cŸ–²Ã:¦[Iÿ¯Qø¨æ% “k'>ŸmQ2TÄÎ)%bM¯?yPŽŠt‰•ë¡³SŠ¼0{6]›§?ÝZxUž„dˆ•=Ntß«w‹$g–F÷G}øjÚ@ EÌ(¿»Šñ½ž¾ñ`m0ÅØ©…ÿêó-|ö5mT±Õ|4�:THÖ—²`”=PÇæ½R¥Ñòe€«šõ!ã¹%K¦>Kñu&‹y ­él/¤Èå\4ˆß5¬çÜá>ì†ZÇYÏ •3•ñ0Z¨ôõ›œAéò~g®¬u#ûœ è—·£Gèw² oDó¿iè;£lˈ¤Û’mUbª`‰9ªÿÚò÷Æ.;D=@U@ci—°â¥'µ`i/Š½ Kؾ~Û®9½ce`®,Ò1•ý[]QŸEÏs¶ïê{â—zŽ&rT0r k?M<˜GŒ¨¸¤h rm”¨` Îo‘ѪÔ>Ç|tkÁÖŽ‘¬Sñ‹ØÓ@c¦ÞóóÜô® ½ó+{qGƒ"V—ìÌ,†¹‡’kçkIJ-’ˆ¥0ƒº@Èü«ú8ø¯^¦c²3àâ;¿ö4ý2am{–|~wVð”Mv2Û7nh»cvpÍ‚BÈÕZ«„È{iÁQDÙbÕnÑÀbO£é�”Å‹µsܬ˜QIc>·ìçÈC‘° ‹¸õ-y;|Š2S#6-h/ç½ÄYä“>3Ÿ7T̈’—É_OJ¿E9[{¥mØ[¿Ò¤&tc1"iåîòËí¡“¯‡Z¬R—E3{†õÜÊ$E÷n§8=jæ»#œÐ ®X%Áþk_š ¢]çïj{»_U…}?SÐ0[@Žzk-ˆ®Š¨Nëc¼ÈJyáGVô-6ÞÁ힢¸uqIB£²0«ë%'ãaÑ9ŸYÍŒ½¾ÝýÉÊ+ù¯î« òÏÅÌoâL¸&¤6x†L,­)‰xX$ÉmûsÐoºZQ1ƒ[“†š¦œ&O*û1»'ÞàœËª‹ÁŠáÞTŒ¼|èUû;1çÜ[60sÅÙ3&O*żœñ%.óÀÓ•|óy}?/[žD¬Œ_õïÎúMŽUO‘Áè§)„é ÜÂ�2£65÷y:œz?Sæâ l؉G¨)QÔTç£SåDáç(ý0xGelh‹œØ†x·¿5KÉÈC0iE@°R‰Z í …M1™’ñèI dS2¶*5¤ ;r¡©£>�Ý ;[:�÷ô‰³•ñLÄšé§ûAû>qJhP¿ñôû}<ð.”¡˜©'-wx?y¶áf5Œƒùžï„+Ù,*|« ½|zbf L§ûNJžÿÉ9 ñ•j¹Æœ?bŠÓγG•²Òö§0ôf²{ÛN0ñ’ˆÖÕÞÕÚ6%»Í>›™Ò+ÛÅEG„òkö Ñ ç5Œ óÇ û/$)b‚M}î­bƒ$ÑÎ^é'ª•×’ ñ³’™Ê<2ËÞS§ðBµííÉc,Þ)îU™oÑ̤ �Âû­Ç¹=Ò®>uAm½/ð»ÀÙefø’]„õJ°°fºa´9îñÂr3pEËíMÐȱƻ‡ˆ½\éQ ?Nìâj%SB§U[Aú~qòi…Ö§ÞÀ¬ZÉÌ1l}Z'8¶T9æì.©T›„»ú2ØûçxTe¾ð1}ìÓÝçì]Š<}ûç-Ï”oï‹BüdËàºDÜDå ÝÝÏÎ tcHMÚ83ó×_Dˆ"[I¡ÄASåAÞ¾»y£&Ô¼øécý�›N]ÛÐò²ßҳ¥¨ÂpÂTªê­lFÞ;�ùº<1#]ò}¹yÊöâ\pìè@Iͬ箦̖V*S]·¢Â­IÈ…_ñt;æÖÀبïœÀZÔ £<HÚÖõ÷ÖïÉÌ(b.ªç}¦cåÂâHy~ÌKêÚ«Ê�|åtA%ù)ì@lÓ$cejSo@L‚j™¢§:è.â[Ý3– 9èºï¶¦ÐtWßÇ'±—£–b6˜åÙseægeìWd>÷‹ö‚³6OêX7T¤{í"î'â0’Rh›Ø“˜düü­kŸW¾„Hã𖯞@ðñ´ÝÖŠÐAF Ž)7?>ä&ÞqËŽ¬LRŠ:ý™C#%iébÜ»`(øwT¥Ê‰/q7)¤ˬŒ‹‡2Rmâ÷?dŒqQêvfzpí�µI»c¿–ý§*A<·3|²]MùøÚiõgñë‚™\`¿£?;ê¹ #éæLÇþ¤½›ßÙ"R­g’�ÿPÉÞS|ÿ4½Åªr­}s.³3çÄ 9¡åån ­¼$’õw©h¢xè´u™³¨(F‚WE_Ï– O»“'öŒÓ{…{F {i6G®OzÚIè‰2^}{îï†à$6 F,sœ ÿaT«Rÿ$pHkH$¸záÉÿ†óç\+“Yôœl‡ ™Ó£ÿM‡äG-¤ùUlsä5ÜEÊñ0¨U6nDß ‘ÞÆtÛåõ±žb•e(à)dïy*Ð6ÝÓ ®Ï ’›!ç ±|bí7ÿHˆ¡o*‹ · ¬º}°+á­Q7Mw×…ïØo˜uNðRP˜VA¹Œ*»AUPîåÛ©¹×G¥P¥+c³4h(\f“ž)è(3èS%HT§³—ºwU‹Aú÷9Šß¯•õÀ"Û™0c‘OTìlëc}–öï/øhŽÄWšóP6t³7Ї´OS2ß6@^ØÐy¾rϤ¿N2©!›Ï,Œ!*àtóEÕ÷ÛÅÊå;SvpfÔHFd#ñ§Ú›Ú±Þ8Í7F\øÐòÌ}öù<Î0 ¿ñ±þ_O×@^@”tý¼ 7–eرQvCOÖó¬ÉÕ·N ;Eýç lzØØOª´›†-±g’!s:ä)“ûòõaús×�$,±b7|ø«É¦£F9Cª[Ù§* ²~÷^“. þLú#{¡æÁTÝMÛKÎrù­ÕB,}Ëz,—mDýbg lA8ÉÀÚÓb£}©÷>Í5 3ÿã'ÁpI)z7N˘ï¸|fWέ% zº{±#tÒU⢺ٖ”aµ“SÊÜœºFì§N£(´'éw§ŽM!ùHÉ«éËj«%U3§%esZ$Ì8×cp¨,Qõ²ÆŸ'˜wOváÔ‘XÌ14s·>{ÞÕ7Qû ZÙÞY8æ‹ôÛ¹’“ÀúÑí¤Ò‹gôÿÊ6ÚX¡úõF©ÿB×ô’oK÷ó¸>[9û„)pyPYä3y^$E'Up½êý¸Ë…]ÎW Á¨Œ ;²¡1ÜA‘dxׄËØ\ïlŸ‘¿³Yoë—;|Å…F/ Ž´>R+\îÛ€‚hI‡ÒrþŠÚZT®„ÆÑ‹$¨¤3@qk8$1úœÐýÍ÷ħŒÌ—ÈQÉUÿ£6SV×pÂô€bÀ”™çlO'éZ!‚vçr¡wœ¾¬€@m6¶Šq%Uê`ˆ�×ü!�1`Iæ;ÏÒã†cnä±p9ô \²»Ø_1–ž ^‰?ÂðlË¢È3ùVnœûkŒvá’Æa-3-ÔÊbc u®ÌäóÙ¬\þÔÚ"‡èê_übü™' I‘Ÿ–C]•Ýã€Ò¦¼/ÁåêlýV6¥aܹôp¿q¬göí¬w‰¹¤= øœë²÷)(bÀ¿´žÀª)sï0G®”I¿¸;÷Í-i:Ï:¨³DYnPÔÓy¸É™l,î °7)eo·<E.ƒ™wTvýC'lhuV¸!‚Õp¡0îœáUáèz#þ+á8êÈ2Jó¡ÝÚ{ÙL[†ýŸ\·U¼ß/l`IBÿs³,¤kkešcd .¤HBh„ë›9͹»6íIåªÂ”Ý÷ZdÛºL§Ã³ QÄkqŒÏîë%¡b…p("õÔ�¥ÁýÕ#Asþï[œ½ýó+óœm_O”�ŒJ93·þE‰Á Œô¿kË=�§û¤J1¾­ÄãžNÄE¹º›Ð"Ø¿Ôanfæ—7ã®GÜÞ•;  ¼ºãÿAÇXÆÏvFЂ¨<x¿¾ )ñô·~‰š»®ñDéÕj2[°(ëÄŠâÍ·çêé‘[ÍÜYËÉ×PÓÐÓé8T1ýZÓRžú?‚ eT£N  X!q)Ä~ç¡è‹—ð dž Ê$\ž¡Û:B:³GzP7èAÐØ £×0žƒ§,ûæ ö£tÈaY*Éøt�.ÀP~ ƒ¹Ì·(˜¯YP¸ñ¨ƉM·,ÊŸmO“ö2œšµ/lûgŒ_è·§Ñ#}…�z®ÃÌÖ`Ñ®”Š~ tˆ(¥«Æ™¡}ÌÕwM—ÃÔ7þe‘WÌrZ'Kå k͇¾ë»þž8å•VŸ—,È[0Âlo:tó¡ÚÞŠp¼f}by’Òþ‹À£Ô|Ú’‘Õ;¯r ©®/ՌؠÐN(ï_:*7 óÃýNLïMo™Ð‰%ˆß<•ŸWé{¹_x…<„ ²nò S¶åá‰]ü¶c`õ*´C‘¼„t=Ø°ê× œ{ÃCpŒ„oNq…Ûs\å eέ#‡'4®Ë‹Íq/Pçî Å’sèF”_¶£ȼBÁì{ Ä»œ÷ÝèY¿'~NDc§G£v¬ƒÖæ¹üjr>lvÚq®´ÓS6ÚÊeKZŠ8%'+ƒöúaÑÞ¯{kE~†uçæ9dþ~de^·g Î|Køö îztCûègÀÄŸ¾ÞD«ùrJœ8#U•Yöð}xópÕG´F 4Ëý^>haœN¬̯fçÖg&1NÊ^>vX‹Ê•W5UGû‘Ž¯úâí,ºÏÝ$Ë}wìú7úwþÍíÏ]=ûX‘<8vð”²ú¬Àø³q÷I5Íà–‚A–PØÝ•Î~ÃКˆF,hÔTEYÅÿ8FŠ7þqúý§,WP2 ª¯csákÆÉò¶O>b”FY–Ìj%zXˉ3d¼Uåö¬?dÚó·Ÿméúè2RÐßü9å(i‡¢_A ÆIySÒ6{–>Îçå«Öøð/hƱ–®¹¹Œ@å líž7S½]xÝíX úA¿ÜÇŽœŠ‹hoÊæN÷ŠÂÆ#2OâýšhuVÖsVÖa>yü©r'‰m°¡7 f¥¥‡ü„­XTŽûÁ(§SAØMŽ‰ì†[2fžÖ²TçK¹x5x¹‡Æ—ÍØï0HÖ.ŸùÇFÁªgP¹‚2C+™žod³-¾ 9zö˜Võßê×¼Öߌ,¬4†Cã© 2Å0Q;ֺܒ+ØÈ#;[þ«Ñí‹…çáJãˆbVJøòî‰aO6;”;ÄSR¤¾Ô<Jã5'.¡‡Fá'Š c–šI_F‰WÔEʼYQd¶éäØÐoÃÌëÎߌœh$d8¢>o NHLÊWÆÈÿƒ }šx¡?A´Z@éìÄ·,³Ò»#ß°CaœêîKŒó}ÒZ'Íór>Ú;¸?>f›w>zì‘ÕRÍŒôææOÄ’ŽN­a°Òrß±” äÕÓh®æÌ€P¯á|ó1ÐÙ!� ‹ŒŽY,­‡‹ï®“õga§7)”ê^䇣5ŠN\ ihui@O9о@ÚÖ,ê€ÄÑ]P‰ù;Jz4Ê®ö=º"£Ýƒ/ÝY:lø{-ç=“xæ:ÿÚI5 ãÌsHÂÈj‚”nï»:b>ÄBçbLU›vµœ…w:-vØ­”XØÄöÄL Aé:ïOýQ[y¯[$¥~øÒh“ìm¬Ä›ÛrËAÞµÑ̨ž{W·(3›ÉG•™FvH¹'Í„¹S÷ÇÓd)r?r¿¨^Í||`Kž<¨¶­ÓÛRF¦I¨|=Š$€Lõ¿ïdzf%á°+ƒxߘ®:}}1i×ü<8—¦ËÄ:§> ’­¢lè6@òõ+On,¾ð¦V9-V³T»¡3¯ ü¦ñ »»—kÝÄóDC%]Š®ÑdEE™î?QâX{]ÞgêE©Šš…F\¢ìim= gΠ˪þoÔô" ×K„¢ ÄÍfkbͲt'¯oÐfëÅmï±Eý=Óz§?XPÛòI_iªÝ¨(=¡ÊP]Ùfð'^ÁVÒIÐ,3ƒ(˜v`™í+—£,‡2Z=1˜ÜLØ øÿ 1;ó¤x »9‚`ߨw@™ñŒ×zƒøR)OTSü!856¤ˆ­ã6«dB•…SÄ΢ø^4¤H ×àm¹|&Al3ÅŠõiðž¬ãócëg_l€«jô‹•€ GCguç%?ëM«ªzÄ®ɘ韼óEÊÏ�Ì ÍÉ´ìêa0øˆñ,¹åý\<òõ xØØJ^Oô‰¡›ƒzàÐfRÍ ‰H¦y+öLq*vʃP©i»ØNQ êó÷ P_¿ÄX¼ËšÛÇ•6ûi�¹çV*ݹñ-L[‹‹ñ PÖ¸GÆÑ|K禿lökðá.o PÞýgۜөÐ_<D0E*\Ž<Õ6uaac&ð{WwÓ‰ÝgD38•ùô¯TQBA•¡ävº’�lÅ$ÍYjŽ&[š©Ç¦¡¯Sõ–˜]¯}(÷Xü-î)Ê¡Ðfä™O¸¼4Ýý«:Ìe`èo®g‰øBC¨;C‡#¬ Œêæ'z4©4i;·ý¡È~!¤®N3S¸Ä3’ Ç—háeâw)¹´ôOØ+åuÓQjž ¤¯´rù„Å0Qè¢æõ›®U²ŽGqp™"¤J;ÒB_ú/… i´ÐŽlŽ9àM;÷¦ëŸ0V!N…oL»-ºqTÇöAX¿£à¸ÒqŒµC(½Ûñ#…ñúˆ]_t¶½MÝBŸkE6Æ‘šÏ¨’.þ/y¢ ð3[ŸN_Tf5kŒÉW8>Õ æ_y~>r£¬yF!ûÞt%¥gWår¦áȶÍRl­Tè#F`o]©õ£fT”¦Wóä+ fˆª'V!¥b±ŽÉÝõK|ôŠJ!º!ÔÍ\;û¦«ÏPÒõÆìþkÆé/OŒ*oÂ&þ:_p­l ’›ëµËʼn/bXÜS¡¸­¿@kMª÷ýœS[Lö¬b쬳xì�ŠœOÚm/û‘D?PËÍ´|³Go[׸lÏ*}:ÊÎÚ™îžA]&%7[ãÈD¡ÍŸ,(ߛ̰´Åøìr›v~ÑQÄvffzqó l/n͘åobrøÆzTÂúIK=zš :‡{ ¬¯2Ê?ß;Ä•bM⛇ *¥Ü‹KâƸáü¾©YÝR6¡€0× ÅáI·ÑLÉ÷•èAR2¾¹·&¥ °ØDóæÇÆB±´ÓÞÚìiÛdz :å@¦±»›ž0,·ûa3 ïKÅ埱)Q¦#­ÂZà 4qMÆ[˜­m¹õµ%öÏ Œ 1:Í*G±b/”¢!uaé"8CMtsérŸ"qP©Jz+´ó‘ühse¿ ëC¹‚Fý”*KG)DêôCÖ‹™ºìo}W;¾.7`½~cªâý|¡Õ˜Yåõ’rè…»êá–ËúDg<ôlÜSΣß$˧×1㉰Öx ͽ+ç·’®‡ tÃ!WÚ¦AOò£¶ >u—®ŸQùt0s¼ác$¡§äkØUAjýH°èš©>2¾RÄ:ÞÙÆ”¹ï9m¯,š0·½TAÑZ˜ojÇ.§çzOÅœÍÕŸö$ww„“V ÄŸúöeÅJôåe.ü+3"vG2/“cWÑÐz‘ûrÓ×Üðj|ĸË[Tu¦´ÃmEØHY·[“YÌõ×É¡*(uXÖÛSÍr4ÓY•¾FË)6YÏK‹ïM+q›ÛMñÁ<¼–|‰•Ñ}Ñ»bÊBîé\êëz#Ù¹ãÙ䱧^6ÇUú¨ ¬ZEû]¯ˆc‡ª•™yëMêo»¬/6`ãÌìbòM±ž§t7!Tô7oM×ï&ª\1‹ü·Fe?8ßí¼ì„: âm³¥Z8\¶¶ºdÇEþúAß_®-ó$œèÌ$hQ3C¼¸më·Í¾�ÀÊÜû•oñÌjôh1Íy±ãôwçü”ˆwe}e!Þn³¸taÄÐH ùÞò‹ÃÂ¥¼¦v}æ‰nDÐRmjË-£»w:·úrÇ:%u7ãûbKT`†ÜRo>øˆSá5–†„lÕö,dëW~³9£î¬E;:ótüØb(ÎxÍÅV¾Zuu8�¬¾þDš¶¦cì’¾ª tÒƒhMW-ÎÉ]ÓÛ@Mº¡¥+7gõpa'ÑbÜÞ›´0ƒàªqïŒ2ŸteƒñìpÄë³eRE>i".MÊae)ËÕKëÈ špüœxDáª|qKÕ`hµÍ1(¦¼bhko*µï6@é_Xaj}<ênÁUû•ð}Ôlz FœØ^Ýò¬•^®3Iг(«Î&JsÀ(†ÿ¾Åoÿ¼Ef˜ k-þoê¬÷ÔPÁ·VÈJ§¦Ë2eírámçz÷"¼mP³\ÁÒ-Y±šëŸ. Š½ïŠW¥o²Ž,ÿœPQ�BTd� ô‡CóðÿwØÈ—­áíJ4(@5CKõ¨î{FhËO½¦®5í¦;S Ê7-ˆÅK,Þ+–§×Ë40_êU?±×<ÆrŸ9¸.çÇ©Rfç‚ó¶ÚãZµò°É¬@0tY½wˆ€xžH×TÏýýWY³)4óI}®mh$)³¾¬7'ô«³Ò"ñ“Z¬_…•-B6óruxÖó„N„àܸËuïwOW¿§y'«�î+ûª->4>|ÈÚÀ;pø¿wçžÌ:“µý)–Õ¶‰ Þ_±Y[£}¡Y”W+9&úôCJu€؃³> •À %a§‰<›§ž¡PþõlåþoáϲR „ {õ^5<åüeŠ Ëb}ðÄ|†ÑˆþËU)ý?ÍÏ Ñ6Jöéä±¥@ýo¶©7Üf¿Op¡Žä¾”£¦>Bˆý÷m³&׈ 0|ž¿Ï+ÿ7þpƒ1.ôØ–OZyE÷Sgz•T Ñ26Œ¼eŒ—î°3ˆ›SË„ÉŠ’”€›gAô~ÕÆJÉÃ< Yà€ }k˜#Ð;@Ϩ²BÇŽï8¨Þ/^÷Ùê‡*·×]<>»ã¢ÊãÔ%@®Yì½Êú¬ëWÒÀ‘ÓÒßÖßEì÷ò¢È¨0|uÞ\2¦-zàªÑÿª ƒ7Kï ¢$Õý ã0¸áP̽յ9¯ °`o ŽúzC‹=™ ó¯yûÎó ;FX`,-\díÀáÞ©‘Ñ6ÏU`7?ybAŒ}M[ùlqv*¯4JÅa´» J•GlÖ,õtkXZe b?ݪu+%aÈ·V]QÅ@sîCzh'ˆ?жcË7W—‡ÇÜœØó�z¼dÈ\ñNõEN×'èÆ8Íc_—¦’9Xvž<X’Ô謕à*ý_O²̗ðÃƽäAqí­¢‡ómγ oª¹UŽÂ Áý¾6F%F˜Qåᯧ”ηzPQP§„V±_¡{æ› þV”æ™]`<ÆÝ“8ˆkeƒÑXØýLW‚ò’§T2B Ñëükþ»·‚ÈU±«É3é)»|ß™S˜×ñ<5TcØ ±ê12Ë=#?f-Cdv>–q l®ÎÝ¡3«�“9_Z€´Uàš"LÀÊ¥Û2j³Í(í:§{ñä¥ý Àë?ÍõúÏŒí§4xSË�}FŒ4ƒîý’›âh'¾ñTpº ò¹éè+õ�÷¡?DGjýÓ=`âø•¹á<{h7)"yÝ —΀ҕ8fÈ“uhu D;Ü1SÊ=Õ¦Dô0âÁR06ÞŸ.ð·4—êPµ qù?oCwb“‹ŸFìØLrCÚws$¥‘ºZユ�NÁÞ€Èó9;ö£ãÕH[Ø«oWß©…5{a”½ëË!(ØËÿ`¼·ïópVz‚§î@EPáÞ‚;pXÔ|0¼èû„Y%­Kʼæ€6ʧ§ÏÍ"a\w,§ÓÂ2ç“+)—g)KÁÙÝÀJY˜Ož›PþB .K}^D1bTš‰YÆI=2O‰r †/{1`6Úí?åÔ'o˜(ÌL£×â hEù属_õ-´JèÂr*¢ÎN og¸Rt—zÊ žxM%ÙJ“¡0lbkÅÖøƒr’hsàš S·;ÌwyìU§™•»bî%qï9ìÑqêÕ³Îemð£tã/ip®yÀ³TvËË!cÑ6?ãÚYÛ¬ æ¢Ë9v[Gá¶qÕJo¼ëëãi‚çýß"ð 1ÏظÖ2 hòœA¥ÿ_¢€ù…‡'–ð¬Û ‰s˜õœ½Sày¨¼Œy[5´L´ÖŠyhÒ÷âsì1ÑçÆÖåhw¤pzO!&­Òl­þ1ÓŽ(§«s­ÒžƒýëÇÓ\©\ƒ$"(–¦A2yÚàØïÓyw· n CFï7³ÞßB0bOkUŠôº{EèÓ >Ï«Iä»4î Q>‘¤\ëßCñ¡Á ©Sby÷e…ý¬ræX§‰+A‡Ï÷öÌ-,ÕóÀ3åÈMÆЭÆX‰£ÎSÑ¥Ô;![scÜÍŸm�‹ñ¶öŸ¢´póz?¸å.àãdSa¹SɹLu 8%3ôE3 èj~c«}³wŽC¿"‡ÎèLkÚÄ—ˆÝT['ШŽß©VJ€yÀÅH¬“a}09¶V^ ÝtÚ±ü$�œ—ɸ¼où7y0sLüzìÀ=VëÀ’Rx†Ùf §,OÊ@U$½Š‹]ýðXLLŠŠŒ»>Ky¤-ëͲ("ª$¬O4ˆ¸Í´¼ìcåbl*Çy€`Ñ^ÿÎEþÎæô¥wö¿o XmMy+7R3ú‡ì<ôC Ê°mÆâØ¢émú^Û‚?Ë�X%?3 EסüÔ„fsnŽcÕ£ Ρ_ÓwˆÓÜ7ë�t¦ò·Ö{ƒ4ï$‚ì+ÏåÝþõ•í¾Ff¨ƒ}W±Ú—EÁ<ìj6ÏÝ×·ãù«?yÒ¯P¿ðÅäì’ÍCÿÈ£û~ØAþ®_¢ÐTÞ@ö‡#Øí…2™Ækg^ï‹¥\ Q– ½Ô 8ºþÈ]‹ly¬KVø=iÀ˜+T•oÀ•ßL'z: “%§#±[¥Øï¿çÚÝì.ø­¢å®£¦Œ¹çœz©Œ’` !<ÕÚFŒýq¡çe~w¡Ã&%'ÐßØliù¤‹Rr3*ÚC=Ôn@ýØÛJ5ÅL[V 1D³ô&|,ìxÆjªVÐõXÏÞ&t h‰vD ¯)í¢,·ÙYDô NÃÑXB˜óþÄñXŠ¿Ì»²h•V‡ÛW&­~4ðFN³L`{ªS·Ù÷5äŸ8Wz:#<¦izÌl[sä' .:á°5¼<×&xÜ+ˆ³ØmÌ“ŒiGOÑ#“BãÚ—6ÌÀ~?àNð¤ì£ó¯ùÀo;>Ž|G 8ô@Ä ×p5HËRóK£^|š¼ÉMÿ¤‡’䡯0LöôE‰oj¹‹ Ù‘¼«;¢¬"Ò<6òàñ¬6r½CÒâÜ)ŸwÎb "Tâ-¼¡Úƒ#}ú?>I‹¡®éÍú�sÀ·Qµƒ(åQʇ)yö×iõ‘}/€ü²xUAÓ:™v€ÄÏž =²5yãÄÜ7‘À±\›Ÿ�Ç6Û•ÕƒFÀHÕúû¿^Û‘×Úp¶Õ0À#;á S@Èû­2"”vEçöÐáú¹÷¼¨ëÍÇÛñti¦úêRÝÍþ4*RŠƒ$G:U¤ñäÀ줯s~( …›Y©ÙÆö4²±|^é,ÇÝË_ýèyµÚ?ÑNë´[~< o×7n·´ìŽ'‘͸žS)Šúp;Õ°'a1(Ù˜t<­nxj̧z(ïö#ŒárG1‰qßyAÃé"Ý…@8Î2OE-ß´Å=™ÃSÐ'‚ȉРܥŠ¤Xqµgíº¸µ4ÈB¨8G¥Y…+×$^>™ñ‰LAŠ`Þž‘Sîeæ‡r¬öÇu“¯mw!mYí¹勇ÖU¿©áÊÜQë¬ÖŠUp,™íY®ÒU˳¥ÅüN´Â¶p'‚ê» Ý¶d¶ÁÍ=Öz<Ùé†`€$“yヺ‡ÙNôŸÒsa¹g<$HÈT² 1Mc:É|ÄqÇI• 4m¼ëGꛄŠâBÌׄ};Ûh`Îá¸××ûRX¯¨b9ÿD6ŒsX8•ô˜ß—/ž‹Gb¢ãÁüÒ  Æùt”ùψk·{ø¥ß¸ ™ð“Å~ð@ACwaÝ3M ç Õ%{,Ô— ¢2÷ûéŒqsVïtZ>¸ÍüEœ(,Ÿ_z\NÊ·³W~;Q*cŠ ²äÖ“v`"+ªœ;=½òñ™Ÿ[ñ] ƒ´ÛzRÍÜrº¾G^YkN{s·ôõåè·È\z•"0Ï‹i*P9W¡¨ßú<†À$¹ë×ðYv™é3WÍ—ëeQ„½úV¿—®µ“€GBï"û§˜~3ëYçè½Ön´^wèÄŒ§ÅXQAJ\Z7÷}[bÏ 2r¬1ëAXùª ΔZäeèþ¯óëÕ[7^$]çééìßwhèää×®ñêè‰Ñ+Šàü¨|)'2ŠÚÃÁ:~²´JaeØ(cAÑ뀄ü“êNÃk’ð¤Ù+E(l;kžþ]mÊS,ú¥ ’½ÚJÆaðC˜Ø"æ.`ë5áÄ2ö# H^tÎÅËÕÔ­ÌÄ8²÷3kU·Ú~p—ßF•k“¹â9§ƒÙš<³ýw}™ ]nfàWÉ©Ý=7Èoß*êK 2—%‚ò¤mà˜ áí4*£•L¼ Ò±^IƒË&ž‚¤^4M¬|ÕëP>Ö-—î…¹vU =²æ¢yK€<³o=~{@ÛÑÞH_æôã{¯re`¼¡ìç}äçžìtĹl—c—ª ²–Ö¹EþÆfY õ éò¥P2Ãj¯åÖ²^°=e%†ƒ÷!Tk¼÷ÀûÕg£É,l™p¼/†×»Ù#7 ­ÚíÚ=äèXZŒÞ‘åÏ3dû°P6þÖL¬$—v»6G q7šG˜2tŸ>§DÉXNæÝ•íDå©M¨õL[»ƒbø×ÒüU¯mÑÁèÀÒ ,.nýËàfž6Åx `²‹.í ŧÃ<[…«ÇŠÐçê„~°-H}º6'!uO¥×põì#œ§ƒµ§ŸF™´?–ƒtÈjÒ¹},OvUOéoÏ zªBxŒ,¤], J~ņ8@ؤô‰ÓõÉè<ßק/²Ð×.¡œº/(ê¼›”ÚÖQoíaG÷ªÿï%ÁÇ¡o®&Ïî,Ä�ñ_'ïOБÈݶàqi)Ï {K¨ÈÂÀÊðÊW¼!n?"p—‰Âd??Zº9ûÆÖ ž- iUº§ë—Û^j®¤ãhí�«ÿô’Ä [=Ú*Þ£jýt¹‚‡kÊ"z)HYªý»“2Áhµ¯Uù ªQr;ôâ›*H^¬Ôè“n(DD{‹Ú‡}]3Ù™•Ð”Æ3¯¤'†E©_™Ó§<Œ´b#+Ü!Z‘ m`Oèþ"9ƒyŸ›i"jÇ”ÌÆ°h˜t̆®þ¦Þ"#—"]²#Ú[¢¬ƒÇgáß“ÌÙéÿš‚)ÜR½oºÉ¤6ÓåjÙÂûÁ6¹)ÌV „I±h¤ØSt{ÛÖÓQÕÈ|[IÊôQ>Ìö hQ?ÄÎzA˜„}=â ½*ýô:µ û« mí…žïÁZý¾A { Bt|¿¸aEÃVà|n¡ x ö«Æ*Õ*Š*]IQVG•i&´|.•øFjWa¶‚{ß®¾ßÁXÑMbjÈQ›™•Â g‡lÍÜNìϢΠçŽï¡<ýL+*‚ë RïÖ+)7Ó''ʈŒhǪ¶GÿúO,Arao±G`:[Ô„¹>íñàmÁGòÿß0RYˆÑš9ëøöÌ°FÎ9’Z´,Í™Zú§ShLéXŒR¢É⇫/›±p ­èÑšAÜdA‹†>¥Ù»Ó,úæÕoª§yTxP'Œ¼?@8«ø€#ÄÐS–þ8÷§Ë:'îÄf‰!*+Øv¸ÑÝ‚?] k¯µRçq¼q2Ù{8*œlrÄÂcKƒ^J<Ô1ñ„2»é¿øîÐÝi¸•À™»4^æ‘jf×#Çà)ë79ÍÒ%n)ò×ýH7²¸(ÙÁþwÌeL1‹Ü ƒ*¸`¯xøtlèÚb¶ªúÀ¬8$kà±µŒ§+‹J9Œc͆زç=ÎrG.áàCðHk¸SÏ4À+‘"!þ/åWn5ÒÙ‹3 ø»æ¥sááWHù„Ц­].݆Û2¶§†©^Eýš¹VYÜún3i¤´DžLt™û®ûÓÍ® {D‰ª¨Èœ‹:ô´úŒÎcȺå¡>¿íº©mE.’ÖÕsèçи¥,âB•tÛÚWl#m르9UAÔiÙ[±¹+Æžvž `{£7­”¼<çÓú–±!º/)Õü‹–/œFQ¡Å1׬Þé0brÄÿ>íºøª©èDs‘¥mßygãúÝ—Ó±áî—þÚ]Ü‘6ʲµ7ð™qßYmöÂé6ŽJ÷3:óR3*b7±f™fƒeiUJ¹X|Ìò5»ßü¥£yåÂ:—— ¢/{Ïñ2—‘uÁZ¡DŽIvïÊN9×BÆ <Ã*V”œñ<–7]"/ƒæ<3šVýoǽ0cLÌ~›Ê<ZÙãÑáøÕwË¥G Ä)ó5þÂÂfWÆzz<%” M³¸ìü9©­ }¼ØŒãþ(•“Òb¼ò0ÒŸI†wCUÈ­°œÜ¥c½ƒƒú£?L@]û#1v‹‚dÔÉ3àlõ0HŸã/õÃcJ È¥sÄíï៚FGÈyEó—™ÎÚø-ã å¤Þ š!W›‰H£S„Ðf:«¼Ÿ4UXwbº‹-Ó"óPJa,´6£zk%°s“¡ß8Ì[(â DBŠÌO 8eA©eiGõÐ{m+k®/\áõ ·;uª_m(+heQ®üÙH½Òs|ר”):ÁäeŒ¸˜÷´>Üà¨ì>·¢1Ä+ êo¼³ÕË**î üAƒ“0¤_Súr¦\•¾8 #˜Ñ\é¬À!û·¿qYm!Ì(Z†§þ6nFhJÔšÂYÙ(ºØî!»‘Φn¡Ù2ˆŒé‹ò¦Q¸Z‹a‚ÑK¶Êè¯ á*Ø5CñkFϾ~3×5²^‚“¥süÀýØ^4òG$i�žNÅÔµœXš Žfz<ý  v“¯+ó0ž ÷ #øRÊߊK~™Œ’¨PÌ~0¼®í)iÜò¯Ú<=è{‹þç|çÖç'/ÜÝÆz!®ùê Ðô]ëñV_Tâ*2ÿàK8»¥§ø¥Ó9<3 Æ3’yÕ9H±y†§C¤< BÇËK`Ï;ÁkÉLýý¹ê±äôW¥£†éuýG&¾(y§NE†Ñ„­˜ôí=€|}¦¯c¦¿ó‘·¨Ùº/JÑ;%°ò3-ãÍÉšfv_@éê‹òs£$ö%¸¢T¸K%w`"3PO£q4Ö§ ¿`.…+s–$87” œ/ö¨�Tò~Îè“¿ú©_ÜÅCŸ?Ÿ ÁóÍRU«\˜étLµ‚' ÜTlÖ^SJƒrÁ:¦”¾Þ­¾]9®÷‹¯Ay=9¿¯#äÇ%g}¤4ezÏSsLñˤM_f×Vê#¯J‘Äž³*khÂ14­u—ªí»W>Q>ÏÞkn¡iìz±Ü’ °]íÇú:sŽju #ºC”þ\|ñŸŽù!æ?g@~nŸ<óÈ[J÷£zôô½›Ip–æùÂŽn­¯j¥&a检ê¾Ð‰=ŒŽÞܨa§I!…¶AÝûC$õ ÆbMÄ”àb»ÓmFåÊ (S¯\!3ûت¤8AÏÈÆ %‹-üŒïá‹×W¡_,ÐR`lS̪‰2Iiìµ~Kž¥Ôý®v{ %%‹2¯ë¹e†¾iKHFd{mÒFlÚgçO7Óí‡öY‰CnEÜ×úX�lètÑ�+Êr8öc [a|bÁKѨ¹õ\¶ÌÈHM»8¤…²_Yf¢£û¿ëNÓΞ­\nz4D‡î"˜ÝaµqªÒT¡êÒlÒ?T|š‡@!¦é9øß7z:^W¦”4y90üÁ˜Ú‰zܨøp{F"ïë$È—/€ÅRb7.7/w¤œsדç k›j&œÓ©eLدiœùñˆN‚¦ ¡wº£›žŽ_¸ÊV`•(n»+n )2¸'@jUSRãë Õ”t¯oÌhøóðÑM×½C=å ÑÆ;Ò.ö³ÃXªL§‰˜'.ž~ÑU+SwÞpnyŒ`ø²órª Lê; ûËö]âìð—"Á4$íàá·NRwÒ™œYœ­I¬sG›8<kI)¨]Ý@êð—H-WclPJÊGO¬¨FÊ &�“ÈÓ=M‰5WT 6z=}÷ºñ%H+¼¯—¢lõJ"]Ä(3âFó˜3EV° \ š†‘@Å‘I»Æ„,8š~̺–äºFÃmb†ÊbÒ™¯Þ\;FåÏßÉËõ1OÖ¿èWÂLlb…FFÜë|Þp»†šbàß2S~@{hy…¿mo$¾xÚ™T{§ År˜ƒý 3#{H{ä…q>ô¢Ùí®l°Ïrß´–cï@·j\ŒÝT"¨ñÙž¯àvüÄ~·ŽRڌ¥òN“ CPî»ú¿o`“qè¬ÝtVK=PŽÎ›0ÞÓ:|4m!¢FôèÓiTǯÀˆf¶ÚžKn¯™=îÅpúÕÁL—WnJÌ=ÓY ŠB3ßDHݤ­€w_!Ä:åÜh†4IÌô›T;}§š²ázkâÁ}'‰'îtQZº2‘ïTË “}«­2‘¤˜OC­˜º›ó¨/M÷uß Ò'ÏK»lOáw«êª®k �² |ÎçÁ$•ü‰«úÿÅ™@˜Æeœz`%>'ïÑ Fk ³õ}<mö ï´÷Ã}¾&ÎÅô¼¨¢plÙ¨0Mx¼‡qÙ?É´¾µï~?R¥Ñº­ ‰²8fÜŠ‰Õì£=u:ÝÖ½Çï~Aæ‰ã|e\wç+0º½XŒh¶Ûë0Ðÿ9}þK¿¡%øÖÒß¡³ wx‚Íå:›?…‰¨ü9Ùöª±ð9t~ïw%ýs-ßèS.3ÀÊŸÇï[Ît z7Ÿr²?\¼iJ‹ ñÛ/Ö²‡bz1Ÿèü©Fõ`S³å·S/a@š÷®Vœ-+ ‘ù¦FçòK‡L°d<Mór„0•bÐ÷cñV;Þ¤Å?<ýÐË<ØMœ-PÞyÿ¯ç}"ŠÿêSI ó¯&Æ÷~âF£ídˆ¤ÌæOÄ–Èa°ŽÆU# \eM§ÿ¡—¹¾wùÈÜ.ËËBÝÏAm˜Ðc8@¦z:J1"Ø×Ü.T§Ê/‰$¨Ç†žñATñûÅ�ÛÐ71~€,ö yíÈcEº}ÁEØ~x+GÚAô‰ {¦ï–ÍžïŠYhÌC1Î:×øæ–›„+³¡$^ú–ý›9²–û†Vêˆ}׉6/…ÜÞ¹Ñfž “æ±Ê®ñ’Dæ‰vÃ�°M½]Ì¿=ñB4/þ&c!VÍ Ï4_¼Öc+È[¦ýÏ› ÕßI„È° `\Ùþël ˜;{ô~!aÒmh¹ç¸èÒÓlYÉ·Dùú)ò¹í»'ß´€yrŽÊÉÖ« ¥­¾­Aá.Àø[‹|‰˜, º­…ž+çýÉJ^YÀ"Þ4œ¼ûç1v¡ŒÕÑÒ[v↸~]åØ©ûωÞ6·hBŒ§)Òãã(ͪç f‹çvÍ+ãéÈq°ð2«E‡ï[•AX«7§cc‘LÒ®…Ö¸€ÜŠG?a¾%™wúâ–Ó7ùOEtŽøVÎdòT¬œ¥ëoÉ'Ϻ©Ãÿ©’4XQÍÙÑeÀ–"Ž²¼~ù_´ÎmË,µŠ”àJž·VõŸÓm«`h„ êÞw^ýô]ž2Ý×bЮ§�ïÎN\m—â`<,‹Pt7‡isžÞɨ^Ü¿¼'€á¡ÇsTß |²Ú`À¹Ñƒ8Yȵ…›É ßd`ß+åµ+&a]J…­¾/¼z¦F§¦dyFŠ*‡YKöõrÏn ò¬Eá»GÌÆ)mãÓf:™Q&OCT:(ûs½ìï퇑#Éo7Ç¢òÅŽdpc %­,°ê-Zæ;n&Š 'ϼØ~FŸ£Ó>Ça søÈšBóÞôïOÜV—Ç”Í|"˜¬P(-—É}Ìy„[žÁz?ñNŒ¢ÜrT•¿·Ö­Ž±HµÎCîy>u9tr+•Áî.u Wä­§ nHnæÚõ*,µ@t…CPîÔŠ’"[)7…Pnâ&‚ËÝèÆÁ§ÄYO<±òŒÊÒ÷‘Œ1'vf×iâõLëóõK3bOBêÞÎõ—ÅSºåÛhNÂà öÜ(Ö †Ä#ÇîÒÛ… êÜÀþÔÆÊû²Ž©fêF©wÇIÁ×ðqs ٜ֌ ¶¦Ç¥ÁT-CT‹¢ÿºöpcä—Sˆù¢Ý çcw™´ ~hI݈§Ñ‡o»úU ë¼¾IŸ/Œ|ûÁ®$ÎnòCq“ÛZUgHOõÚšü¡“\f$¢Ñ#H…¯TÙ—6mcîBø9>ŠLéö©Hò}²’E° ëh&Š·ygQ„袎<1“€%c‹&…¤ÿøKõ4¨bm ±gE„ ¢¸æn/ÛW[5V·4„w¶.K'›ô" Á²4~t,Ëqf˜§˜r¥Ýåņë.µõŸƒíïÏ»­Îc7§º—ìÖœâ¼ÛÖ"Cß4‡ªÜ•ÂlêJQ®Øï¼[7]èÍ°})-`»Z7 ¢Ø'ÀS°©‚bÚk'6Å6Ó�d’ž%åžiK¹_þDع*»Äô¹½Æ;ÜL«é1ÌòЛñëýõX…™Çü6s j´¦k’"¯hH¯ ƒŒG¢ÜÝ”ó?˜®„ç«íœdR>°,ÆŸÃî®ÁŸš¬æ ‰…jL¤®0O¹ó8Q†²W·x,À¯èÊ<#ˆr—Éú„ÔyÂv"‡´¡ÀÚx‚tðﻋçZˆÜ劼¼[ÿ ¯ßaÞ•7V Ê;§3ËjÊR\é¯0\Ã@{¦÷0Ë].db÷<˜ØÄ+äaÊžñ`Ç aÄü¡žþÜ×;fzq㘠.Új �°£Èm&Ñù y·…›IŒƒ‹§Ú´ÛŽ­E8uT+jŸžÎ/€qQጡd06²îw¹è¶7t¦ þëJ‡oðºÆHú¶I³ÿ“…•oè Gh£ärÂ×Ôö©„Þ53å;OÅ“ðA»6X.tŽäÝÅ1¡¦£hƒ S=ôû%ìä À‰½0¶2'ÿ>|÷uYKi€!ƒž¡d ¢`äü-¯ô‰j°öY™%LI-—‹aÓ­{ ¶§7Õ»ˆ±^™¸ƒ¬ÃÐø ˜s¥*|–…aaé½+~¨bl�Ôx»±ŠðoxzQé¼Wd;·©Éú½Ó=»\µE¾gp iF>ï¾ÄqéŸx˜—É^‰hÏ#î§q-S"Õ—�‹ºXþÍ`ÒŽ|>ßS„«h5c>ÀtëìA<(am˜¸Aö µ»QX¾/¬X–™×qáÂIÇúN‘¬gO…*å·ô ¶Ë[ƒ‰Ã<R~L'Ÿäþ7VaìÄ* ÊA}­Ë‚áȱßØNµŽaõ>AcUž—Ø•Ð*›ÿÕD+Q¹îã©V úoðž°+ûÊ-ÐLÎú©Íáï‹ØÈHÖŒÏIžÜ’ör#³=íRª*­¦®VÌs¯7ƒÌл,¥ûO¦åðí3´2‡K éçÙ3†R%Ýéi~;Mì3HéÅD-+½úÒJ´äDzŠå¶‹˜²·TS/œ$ð𿞬íöO—ÞÁ­D™ª ‡`OÙs°i=ò^L¦ãÒ$§÷¹PùW4»‡E9“[»~+SÛ`KÛb6M¤¿˜#–¡ÀCæÝç)•<æ˜5}•Ã|¨û·+„ˆ,ÎCwØ9nE <#jÛo¿0j!6Ѧg}¤²¼¸h[{ÃÈaðzj§Óµ‡ß„Jyžëd‘“åcÏÈù„Ócn|r: H9õ€ö•¯\c›¬Îs:k)ï ƒÌ˜ÁK€6º§eÇ-.ƒéx‹©º>¤NV!¥é$ l4´¥Û|Cã´Ò«²ð�?X ôê�ŒF6ÂD^òÎ0dÊ—Ôo3¿’6"z÷aï™où$‹.|Œ2L=±}‘¼ÜÇdÏ:­K¡#µ Þ ¬^ œÈ[JŒX—ƒÕzò9_ÇÈ”\}GÅËиžZs�Qvà%o†/ãÅiyGSi¿§£eG‹”ÿi`ö]Ÿä"B#PQÊE‚üýì}`¼ V›ÓÏ/0RËÂÈMk¸.UÖø“ú k<9ý#|4nå#Ï›®Ç_¨áçNd 'Q Å¥2ÛÖk¶H=û†ÂPš9àtý]X™;€[w¹p™2zNÀ}Í:jÄÆcî•¡9}œL§f}Æ4"c6Põ¾x0l©¶mGH8?/q¬£–ñ™)Ùþ4d['Ò‹ýnNÈ_ùÿF±ÖºÊ¼¦$¦·<wúšÕ%³ä«È,èñlï Ú¥Cw]qFâÌŸçAvõgµ'O‡]ÍÝ­E1ZÜ;Ä0l!ÙŽrv¡¢ïÔµQ9ÆÝõàS–SëõI' ãö(ÿÏw'Å%8Á†SÜi¹ Ë6Zi,5®&¯¡lÆ+çÎ]×éçÞ1OøÛZ KÙ§:S+É©2ZéºÁ;¦ ¢³¦¼,ÿÉ1D9¸XÖbq*7Î(0ôùÖ3.*_(‘®nŸŠ¦JëßÓPÛDÚÐBLŠëf5K‡gü*¨2ÍVê\L—`p¯y "rhM©íëÇK×OB Muå… ËVõb#áQÄ,@‹TKó¬ß¨¡Ù§"’´!;Y×dþJ†Šÿ –2ÞùÌ,#wžrñ¹¡ê?~W3Ë ©nƒ‘—õ¹­¦ø“4ú¥‰£SñíjjJBß}9B¦sŸ¤ÿ3ô ÿ£ êz‚¯Þ2x}”ŸÒ· O¶ôºùÇP',¶ŠÓuZêÝr_|a5„€<9J·þôÔP:­Víê8èÏqPìf7ŒĢܬþÌò´ßþÅ„Ù}b±löÛÙÄ–»}Ó‹ú=Ü5K j·s>µÙÉúM›éÜÌkmºxHǃy|Ûs¾Ô6=À¡ ŠQ[R1ZÊ%¿(?Lô²Ì-Î6_è}"«—H‡Om`:Ü1‡#u=�Š£çìщS.ÃBŒœüJÆÞ÷þM¾#C—Ï‹ÎmC L<©$;èqcYfAûßVÂåµs¦Ê|ú½XåÚ`±þª¨¥¿²’ñô.“ÅA»§?a¿„p<rÏOÑ#{q$Ñ䉋Dm3@®ºó“çY“óúÏ‚žNùp²Ãö8øž¢'—j÷DÐæn»ÈÃv£ŸÄOa±Cá}*^íMÇ—z9è‘ò†*—fªÿƱPÉ O!³Çˆßz ã‰pÿÌ €ÙT†÷óoay³’†9ýgøŠéÍÁ®½x0nžÀ‹ã=±H³•}Hl.EŸ[—lRöc)/×X¿Á—>Ö§ óegIºxçEð–V|â¦æúå~Kc[Ì! WÞŒú•*ìI¶—]ªÐª È0œ™C?óî+AÚu5Ãtü*`-¯Óàh·ñ>šÖF·Y±Â×Ó¦¢¸°ãæCËsÕÞè*®=3Ü*= ¥T†ãžèöž…!­Þñ`Ç(5RÑ Ôv,wq#ìïM~Y¿]ãÓJÿ¦âÂwd…9GÌ6_¿h{Hò²ŠQ€ƒóq´vL"³>(žtúí'Y­Œ• â³$ÊÔpï—ÓxOýá¹DRø ?ÚÚÓ±ÂOU´£Tþ«ÆpÕ*Eôþ`{N39I ά±»¬d‹§HÍ:§ˆ}œ ,=œm=œLå`Üqo_oêJk}Œƒ¢HÕ4ªJVžYg|m;þ†inûr‘9˜H2¥‹ê7ä%ÏðP±±¡·\6WÆÕþ¨ g«ij\&úñ^ m ¢€ô+fcpQ-æá# '©î…—ÿÍWݳeâ ‚¦VèTv‘<öPÚ-ïxØ/Ì *78äÝl¶eì……˜ÛÁÈÈ6hœšGvg—íu¨7{úTÃîÔ=ö~ȽÆ,®Cƒ%²v¶ÂÃö0YØŸDX(uwrÙ+¤çaõ³²q/ÎIÐFÓéÑkŠÂêo�Y Ãa¾L(}žÆ8¶C ÆÍø¢h¡Ÿâbž °ÂV !ÔËL÷3 ^óôÉ#ùíºb™TsÔEh¬Óþ<XA ˆ"컞[Çþ¥^­óxeK¬lˆ"F@XzÒŒé5g۰ϳ^b·G0 .L̀ణ»ð¯²¿òðퟷ" ÆþD‡}ÝÑâÅ÷pØ­%jø˜;Jõ²ÏÚƒ‰X4'¾ê jV'ñ‚ŠDúÃŒ… ‡ÞÌfünŒk¯§ÛÉõ‹#lgñÈ-%zôÓ‘•k¬è@Q ¤Ïk-A|“&T1BèÖ_Þ±Ò,üð�Å:~ÓFwZÁ>HÄ(—ø£‚@–zþ…¹1úÚ95‹e=zjcÙiº³{J®†wÏêâxžMzø—p®ý¾ÒôÍ–™’¢Êö0/0‰K¹03é;ÎͼtI®µi‘Òă®ç€AÊ^&º»‡ÿAËÅ2W¤ÙD[óz*ƒj«„I€d¤¸¯=P‘üÔ7„¦ýÔõöß; –,ô™ëȨ&HHÕgÃeåÒ5¾PÀ\=¸ýfLp#$‡.47!cqü ‰‚©çvñÑyàmÏ+ÒM® :J‘¶YZO  aÃ9Ž×º67ò6©oË¢ÓžNš¤ÞYá;xbPv ç@aSëádû´ã¹WxÀ¥¶€w OÍ_H…àØGïÊM%)ã.±•›ø³>]ñª¡‹ ;jkOƒt¸«µ!ÕšÄõo5£ÊWã!§Gã]W<‚áôe²Ö4~E!ù§K¯Ë&ªè+ñàââ;Q~žamŽ‰§ãŠbÅ1hJ‚lPgô©•h‘ô0}› ‘ô<¡]„–ŒÊ›Íûîþ†¥—2ß"¢€È'ýÍ^Qú¢ìI)7%ö´¡;ä° ÆKßS"p¸#ò™­¬ê#ÎìéñžÏ! h zZ=íÎn·Ó5¹cÒ‡;ßbüX<Íaÿó_ßÔötú°) цpò˦‰;4 Ó5™{ˆh: æÖ’~¶ÇšÒ e¯½KR”Êí§_ë"°¨Ú6kD8©m;sñd֠ƾDžM½® ÞsTM-|›zÊH²€Ï=³žXžÞË:Uê¼lsOÝ'á¹€˜š›>… ³­ÍÕ¥þèÔÿçfjVéQ¤l |ø*(΋§Í·Ô=6ÝÂ>å-ðbôú/Ø2¸€ ñÊCõ:âD©}»ÄAu¶öð¹Ó)än ÃͦŒ§Ó˲,BÏ'͸º ½öæyˆQi̓ °t(Õq¦PÌ}Ìyˆ¼° _FÖYtÌL+¶Á>„¬}Ù×”+· #.¼(—~—7L‚c ¨‹9%ò@o²yž<;ºú§Ãå�ÒtüÈW„§ãw86Þ½s0j\Fú抶ˆò´¾ýøG„„½Ô®,2¿Íöêªeô¶š„£î0r?@q¯Kà[ô5'ÙJ1X)Ö=}E*¡ Ë¢»ø)I#*Ã.‚%(zÔLõeàUè©©àŽ2í‰e'‘yVÖŸGø¹UýË’›&ÝæOÌã®Ä9R $¾¾'[GÈ(væ!ƒEýóHÏÒ2MW ®JiX¡œœ^€ùÒølJ!uSú~ÑY×½ÒÍ:B†Z|Ò¬ºD•gÇ ‚\ú¾ÓÄ—’%¶É¡×ƽPlŽœ; ÏWzù°uS5ù´fIn)V �#úÒ×#›ý-‘ÂWïfå3Xp'õäá³Â„D‹/~âK¼v鈂¦…‘Ϩ©lž®‘Å‚oý.ÆÚ‹ï2myæç<`óP /*â¹ W�¤fº\Ñúzå(ò^"vë"¨¾>ÎGRsOå­¶W¹³³ä”|³‰üí«i“:,=¼iO5Öõìrtv²)‹“àáNˆ40òaùq'ªã:˜ÂJvôÖIc÷ † të<Á4ƒÞ˜ÊìÃy)±ºÔóþ]x‰qÂ'P1ªOá–õؼ ßõÌÁxkÌ»z§¨›ÝEÎõ-35ïsïïŽç‰;Åfåy›ãî&‰Â,ódï)Ckª ýj| :øÓÕ‰äRî×v³Cq¿6ft>gEt­Âå¬ÝBCä.+î3ÁåXÛ¡ëÅÂ8eIEç{ýû8 W4ë±£Ä,Ï>àŒµï§Z¾ÐyË_´ƒbëýª~YME+ioéã\ÒrëJg¦±j>õ‡ý™§¿æâöFå‰/ÕC%Ð\çAépõ¨–‡&:¢VS‡ÛI;$¿O`±+–3ž¤ƒË=áSßâ®_x¾ºÁ:¶”1!‰»³ƒ›!’hÀñï ×ûŽðcmT– %¢t«ZJ¬ÐÆ®ÿï[©ÈaôÝÌž—&Ô°ÄóZÂ.ØÑ']»ô‚3íD) •`,ßêƒDazËhJÑû‡ï}kð•)7î²\07zcÐØ‹ûKy¢ˆDi@{¥÷¶‚÷È`€ýÐY)w˜w•#B‹4`3ûîžjSÏÓðxƒv:¹±ioc}îç_à6-¿CÒééAT[tãD'ܪÄÓ~<P ๕f’6¹++§›­ðhy0 …O“PË~ƃØãì»«Ñ ™Ö˜ë·oí‹{TußÚ+fBmŸ©EXq×ø°õ´µéõ”ÜJmŽ »Ò™0݉'nwËÇÇϬ½@q„›çÞ6vƒÄ¡™[op¶5N^²F¼·Ñ¼·žÔÏ|¹•¤+¶gÄŸé�.Z+[˜²b&ÏÖÍ;^kñ]ü c‹(KW ›Œ Då~tf³{4÷6{“.èj±$§aݾrîyÛ„¶6P‡)7d"“O´‡š7Æû¹9ôõªzv˜&¹y׃f²ŠÍ8ôê‡f ä_>l"OTˆ’T=àÁÎ:â7•áÔ©vÇtÞ5Wóï­A’­EéŒÿBDîzOõ™3*S£ 0+ŒU9 ¡ÿ‡Ég¾+k³Ý0ÑkTv BëÈÚŸk‰ç½*®8öˆÔ)Dz6NƒÊ"Ð+1Ñ~5€ÌVõeƒ*é.j/}Mœˆµ× ¥¨”$O]·•ÓMNgÜ„äP;þ3ó3y,’æNS‰çá}—Q{Q!g0Ãj¹ ±ÿŸ¹‰·»Ù“šúˆ½N38Æ‘ª^Õ§fn"Cqãcæúâ|XvÌ­sãVÊÖ›‡Y½°°¼§S3Ì¡Õ’P ÿíBÏ£juúÃ@a=¯Jªyì–ƒ)©pÏ9Ó?ge£Üæáiv3ÌÚìSÊšwºg ÏóyÈ ªÀÕ Q\˜¦›èDA¨b=àª;£L‚ÿ’&Tî¹¢r’¿a#ºfpO¡…ÙÎä›Üéj¤šÂËÔÞâÒR•“ÚkÆrÙH'ÌW n§9Sêu}âÈgŒÅH³4H'm…!›>Ö:êêQD“_ã³GVú 2ROóL‰Egí5sVäcâ=W5žCvC5k/vòŒ¥O‡añ ßâÌ¢yøs&)UTû[ôß·8}ûç-‰ƒ>F :îqBΖágÁ{æ"^ï GÆ™¦F:–d>Ù§ˆÔÔQŽxálóoþö¼Ì3ßÍŽbÂa¤Ü¸)Iø÷í4üÛù ª‰›?�KºOKö1ܼžÁ¢p"êQM÷„âñy|›÷§Ñ”ó’p²ÂÌ,6; œŠ8ºÂ›{Ö…qQØvsÎ�kˆwDvÒ›4 ˆp6±¡kP«‡¿“îpN€±à,´“g«‰q÷ITU âï‚ž«C#SÚ-@ESo¿¦zÁÛ¬<Río5èrb`@3àsœêO#G§âoC+ƒ¾H¯]e¸×&$ÝêdÜUÌp·H¤fR*s)ï8ï½Ï8Næ´ç[Âk\:¼|`e rmTóìaÞÄ…Ù|eˆ•^™¶Aß8�)BùT\˜FP24MIÖÂø³hGoDŽC—1{•(5ïo'mmZªwÕ¬*ëT&çpM¿ìç â€?8ôÓa·“àª?ý,èšÆV)V4 ‡‰VK5-žiëpêzmПF‹Ñ‚¨„T7?º$ËçJ06p^¨™ïèÈåb‘­ äà.âÄüüßüˆa‘­m€ú~Ÿ#öõe‚h™ùJ¢“ðv2'-qQ~\8ÑÒW<-LbcyÅx¢ôS÷˜ãÒ®k^ :~‡)ÊBÇ€~$ «–”�ey³‡»÷š9ßNõhÉ+·gÈC`kªùEhø¨ �o¿t)CÏþ:ÎWÞp|¸²#mÇðo¿£ZqYÝUAÖ4žÎŸ–zÀŒ:žžÞ»ºe(%‘ÏŇùäD?6º7’x‹ÀÍMTËõ¿>õæp:.‘ißOÜé±^cQ˜"ˆnÿbm3DD´ÓBàæGíßiG,„fQÉ·9ÕIÛ e:ûæ]»»@4W_Ù†¦‘S7ç$n€ÊÛ¢8ººõK¥¤èĈˆ°ÿ52#sû-âášüƒfQ9,É:Z©ôñ7gãr$ü´'}ÉÊsm`ÛÒf�kïÝSÒŽ¾IÈ .âEÈD\ùÇ> ò¡·½T<j({ô;Ñ…([¥I@)×<—ÜšmE•¢ ²ÝtNŒƒ:~ Ê×Ñ}Þ{‘Ø£Mtn÷;:*gí½ä\ø©;¼—½:“Ô§v©‘gNÆ)Ä;ã¹õ\eÀ9¦n²ôç/:\y]“)Y ÆÀI‰•±kK£AÃGDûª2vž¯,½C�XÊ ·ÒQî‘»dROëS,dWÿˆ"Ï/é+cz@®(êUÝà ¾ 噳‹¥»2 å ð¬ŒMdŽM·•E€°ÜÈâÏa³œ¦Cm!b/K�e¡OE]I¥HÜ|y˜*.rtüí|á¬^„™3Œð<šëOƒê*0æÏÐߤìŽÃ,0CžÂ<›,‘šDBªa*y.bU¶ñ{-̆–(7Áôõ6¯M‹ÕèsÈvë ewªŠúb® ÝÑAÛö¦ r-ßÍß�º›×CÂ[5È”!ªÉøîõÛtžk<°ú’úß·Íž!, ú‰-ô+ÿ7žÒ8RûJl‘ ¶Vúˆ¹CRŒ‚ÑB×Á%>[üñÔéÛ/^pNòåÚY#âôEk§ètTÏfÓ¹CM(õ�&Fœÿ¬¿™g«ñ l(¨ëF®J âêÀº”2sd@NÿOâô÷ß<×{A¨–ª!3˜ ¶Í·³9˜¶‰áCb˜çŽ+::¯¿³-Bß Ê2 =Öõ¨`}áy®Ö"ÆÃÝ•ýbÇïêmQi<Ì$žŸ/*€z=÷E⋽�ø¤Ð:…OcV³ùÿ½/ÇBÚÞANÿƒÃ¶þbŸânb§oè…¢ô„m™Ï9_rÊí´BÎóî©°§¬x›¿F;ŽâÂå ¥x#Æž1·›çŽq´ºö¾íÞÕí×±ÊtQbš5âÄBÉâ„UãY2±_ªÂõU(ar˜«o´t…ó êwØE€én= 7Þa pð²…ÅÒd† ¾?ÓÇ/w[ÏÛL ÒzUÁ#RÊ °Lh£º;òð? V }¯6ȸ”aP ºiÅOP–Úß`è^÷>ó‚n•Ì54MµÔ,P>#aäšÕ^¬æ­véñ?smû댦áÔ¶»ð̉»Ï%íÃyç`jóæ´õ¼ñµO£}mh»vTŠ^î<‡,wXÄȈ S™�°ªåÌ8854†š?à‡ŠÝ©‡¬‹ü¶¥ Öœ6²êíÚ~Œg²Í"6t§`ó$l‹².x$‰ïÏÑŒož •Våb€¾©C{Ÿ%•˜ýÌGÞì7^!†3î°гÙAàGwB5ª{ùš†ößèúåÄš—Ù¥†øÌ<9¶U‹cÕ n(È œi]S*90mî–bv×j¯²ˆZ±Ú›Ó$H/ƒK0K}"e"ƒg–7‘°ÕœúYZÿ~ÚRÄÞAâÝ9¡s ¶2’aàÔ÷ Õö0?7ŒXé†yÈZã›ÑÁ<Hj̈N‘jל÷›á„™#y¢.ȃžõ¢WèE”1ºnØ|X{ûŽî üÆnæföÿˆ;ц~§ñ[Fn/¥¨7:²¶­Ò»Ù-]ä%‘¡ÿé8<Kt¿³¼‚-=ö„È\¦ kX*7=P‡öSç]=èFþt‹ÛD´ñÒ™Fç-²Vœö¥ ?Aö„±bÿË 7òåãx>ÃÞd“–…Pu“”1hóš‹æ3ÏV´Þˆ<'úÐcg‡=ÐZ§›`8<¿£d±#q¿nwm“*›Y^nuq¥Ð1Âyú .‰Œç—+™$ŠM—y~?8•_àj—ÀïÝæçxǸðb[–=Ý Šµ²Tª\àH ¢íûƒ»±‡ Ñ‘ŽìÎÌÞ'oír±åä4Yuåkoü‰ìꥻó:“‹æ1³ÒhQ¤×³W°6uÏx]ýÐßÄ{ OÔ‘K vsßšàRPp¡%Ùtó_Ç–(^—r”‰w€5~’ÜXìh¼käa?~á"û$:î3ºÕ%ó(7éæ”Ú×׎{M½ù#ßR^Ëß. 8¸ï) ×ѬÀÏOûkK‡ÓPÏ\‘°@î°ˆb¯ÒB10’väS£@ ÂÆÁBUþŒäèô‚ª×%ªEÛ†—Žôò•ÓЙї%•»sìÐj¥o‡ÿ ^—ÆÚø²‰=»5^CÃ�ÁõwÍ<Àôhc’l9é5îâx±È“Àc6 )νK¦­šC­‘à5ÄË3©£{eá ˆXÀäpjð[ßÊ$so.òU5t­ à+­Æåë.„ šé–t&ôª ÿTôH ˜Bßtµªäë‹Ý‹f8œ…¼ò�²ÐW‚Oæ±à•åTš+m1ëqrÇ«çŽkO’ø(ÖÞ¡2}Ùùè¹cݶÝJ|G$sï;ÅÎ*T1÷0×´ÈÐaäm.GN$ž÷îu’bäØp(§dCÕqQ´Úñ'?÷þócY!zgôžVþ²ÊÜbÄä—žj$–¹—3T»÷KO8+LÔ³’jýèm]“P˜@ôXU'ËŠaJX�ù…›Q9”ë ›Ã5VBùOºÝNnè…Ld*ú¸°F´¦ô܈¯¨Ò¡÷i&ÓspºRþ¡Ç Dn~Âùû)x°@lÛ,Bh¬¡É±óNG屚nÚ%–ÅóJ©Ö³ܳüé!÷îõ§7u€QÑ높JëOóÁwÊ_úC°,¢ò°«…n«ç˜H†¢04ùï¸mÏ×™g››#zkJôÄ•;TãÍo°½Ä‡Ì(dÝ¡ŠA7BVU%Æ5*¤Ivãð¼¹À(kça’E#Q1Žõ°0ÀÅJ- ®Ýüä±n…ÖO1«èƒÛ¶YaÄÊõߪ‹“UK(}<øŒ=Õl<ŒŒ’*hcVS¸QÑк¥¤7¸½Ùõ‡¶0h§j .¢ ­Huð~PS«—ÑçM�™w‰ %tçk™Uwà™fâ«aß7…2u¦änBé_¥qÂÕˆO»˜N3}0H…_Ð=ýM²•z—²Q5ñ£Jçib£Ð3ߪìײ¬(ÒÒÌE¸Ü´@ðöŠ¤‘4ä: !§»a+ÝSý¡Ž°òë'<²¨táë^¶U,[×ëYŒ ºW±¬`•50.–nKfyÖ$-£\¦Ü…ä¦"¯“jíÎp«t´ãì—“”ó©X3ÛÙ-Ì#o(ýO>=¯?ÇÒL í}ãI¡·}qGUìÆe Lå§Õpøû<ŽôQ›z±¢r­/poróPúE@3©3V,&pœ²¨ïMÝËò‚øof…™É:ø6'Oý—‹$%“ª!¼Â¿Š}± %Õ«ÑJ½ÄÒŠâ·uK}¢¤nF8žd)vÜa£3ꨄ÷¶¥ÃËvÜ‘õ~S½sªºéÖRìÓw¥Â•ê6‡‰’Vêíëº6NŠ՚Πî4»U¯œ5õeIüÜ°G¶‘õ—Õ}Õ^²w˜ZÏ­Ò(ì×ÃGw}e=$ö°“£» ¦-ºüjû{‰ ðG^½h«Ø6òO¨˜¨ŠV.! ¬Aü9yMf:3½žÕoÈC¾ÝSÎô-ØÁWïŽ%»vZ_³t-;r¹õPx`o=CÄÓQU¯S‚ûo#Ýyû¿¤G¡f(„3DÛÊÞáN™:Y•=~óöqéV"Ö¬ø¤ØZwÞŠŠª‘Îh'ùŒõaÇš·ÒªÊüÇJ‡ÙÌ*ƒuðnŸ ÉQdSF%æõ œùûØ1Íð+eZaA©Ñ®VËÉg“kv…Î$÷Í%Æš‹;¢d¡gJ%j”OsïyñRjæ宬ùÝL±p·ZÛ„o\ï¼�ˆ¢IÂ~Á5Žc¯¿Åh0Zñ› Û(Àhź;ƒ|d9ßݳվš*³ÝñÃzM](¨�ô÷,VqÜvºÐO›‘ž{ÌÊþH¥@š³·û/õ²ØÒ@̈Ш–äüwj0ÑWþC¢™VM×ytÎíÁIÄYʃ3t ^ÿ M¯Â…fnzµ]–‘5œÈ0Õå¬È°!:€¿´à§ïÞ%Íà°a²¯u”*`‡·¿^”)=YHFÍŽ”^¥ýl¨ú�Ä'J'kÔ8ŽgK~½¾®…A}IÌ$‚% ’^3ÝÜp€Óm^~G��^ƒ»ÈŸg^YO¥ @éçìñ)®¾û¯‘Ž¶­k|è0¡§íþ5li 0G—9×k$c£Á¢-Ê]OyV~Öcœs.úÆÆ0cÂñ€"ûè¢O2L,ܲÍi™/'âß ¹}Z@*Þ3øÓ§Ëyª¹¬ø…p½:é²z2±i µ=¥¿e}ö†PÆ`Q£'-JvW3J7uŽ4˜ûb…Ë¢û¿;Ó»¥–š@˜6îéÜšðç0í¸'ʪ·?Nà}»Ö3`)=×ßP\ÖRJF k ssÌg} ä­ûôÌâ*‚l¶D Ný¼h7‚>a: ÅäŽîuGj ¡†ïÑëéí.8/ËÇ5ÊC? å‘åÄHÆ©µªé­"~Zsÿ¿½ZUößMË¢°ô¥P),ÌbÎVZ·¸o#–ò×CÞ<ô‹ÓÈè<(êÉ“Åðö¹³¢"¦mAÕÈ«bÅ£ƒ•!Ùvïe Gdñgà`FïÜ (ÙËuj™ù³4Œ,»³´‹gô+O<_彃Ú: E„ÿïÿ™ß¨ÀV?½ô½oôŽ*Ç;0¬ñ-ýÅh´n–•’~9 §-:´w.ÐùWF`i¼Ùæ"ˆúE¥_€Ìiiåt«J!î¯ÏÙ*‡,eAc„Ó—6ìO£¸2*Ï㞸áO:‡Q^f75f9í­ 4¢–ØpʳõŽu*=gæîQÄÔæÓC?õx%6â;p`ï |�(©àŒ†­f ?‹×[/íÌ ÅÚŽâ~>؉�Œˆ: Œµ±›¥FÀ.èØÐÎ\¯s+2‹7€¤ÂíV·2môU˜É êÿþ­°Ç¡Ñ€X&à@‡w¬V§:FVïþ·f²Icæ|ÀäÚ³³º¡9O0-,»Þ ×øU¹´äùXÐóËݶ˜ҒŸ¼�Ìlç„B!¶UórózÓøÏ2OÒ±c›‰²äÙÎc7 Vnô›ÚPöBrv¼–:RZB¿ï’vÍÎP©ÏÚ÷qèîú{G™cÕ…³OkÕJѦ~œ©ŠfõÓ7Qˆfy‘Pûv,&rpžèöUýÙ:bÖÒ8# p_1*¼°Ù¬à=ÃØslf9Qf†ýäÙ})Ç–ìçQÆ3iªµK^áÒRJ˜3Y‘Ç<_ehYé"U¼á™í}'/ÜU-{…ÿy½—T´î³ ¢&4Âmˆi‚P˜ß �4³ƒ§ Ý‘á°¼ÑþCA Hy¼VâþÞ•Mx“µ5ôª`6÷+ý Uª*Öž×"-$¾ ¦¦¤©³‡ÈR«P)ë»­éþ|i¤HÅ<¼çá—Ij#ÙóýB)©I\ùà= ò0^XÝŠU1É9º¾FÔ>AgÎþõ]Kq—¤'¦Ìn*ä#ÛµÊx…N]CëOÄŒöõ¡7}G©ÖV¹e蚥’ØuÀç³Öð´ä.ƒÓöÆ`'bŽHG×âÎf³_¹(5 R ôØ8¢ÝpWx3áa­2×çuÇŒtÿSt“‚tT€kY²Lâid¹о]#ëS¸ËfÁ¹ÓÆšáým0z;v1Ü_)L®ÛÆ0ÖñhsL{xŒëÑßDÞ”eAöwQúôµtí½¨mÛ°Ò(²^´íÎœ³˜Œ_„‚a§S–ñè‹Ç¡/­Dß,J4G ‹2K‚‘ž;@Ÿ™d¿&R>$Tfi˜yíJ ³¨4óA%Ž Ö\§m~˜oMXtk:PßG ©×öçÁû\'°@\LàB‘®wÇîLa‘Ý:|¦{¬þ³áˆÒÿÚÌ(¡í¥ö‘Ö?G¦U}z s‘ÕÞÊãÄ‘kë)¨í mȤŠ}Þ}7ªÁ@êTÑ«Ü'~™íßœvf#•›ï9äÑ››ŽxÚéù˱£G|PZÊkèõG]øM5œ|CEÕ®£îkCYØá´6¯ ƒyƒ½ÀPûmºÇ>>çoá:‰7BgŒcÐw´w ¬)ûè:fK[¾�<ó¸Ô ’‡%»¾[!~í‡þÞüHBgz%›¨&í<1ÚyD wf„‰;ÔÎQŸ`ÝSOÔY2€ÍŸNÑÎæ|˜1ÇPLÛéko%õ–ë|²ò°?£ˆé�u±† /{wÉ°øÚ §¶Uÿ&Ò™Ñ*-d4qôþŠß‘¬€Ù!¸è‘`œÉúA.·²wGÝí›Î[äØÌÐÏàÔ[¯¶,-¸y„ö)¿­Tz€WÊòp ê†/@Õmâký~’ÚK»ïä7 H±Æ­Ò, CÃ<[]–´B:Ö45¯Ï'&VÃI\dü‚•S#¿Â´µ.19Æ(Ѹc_ä»u€wòcÁÓÉßÀáû]{¢ØP£Ã½`¾Ë¬ÁŽ{§66ê7æREn)°"§¿o!Ò3™¨Ñ­rhó¨0ǹl‹â]=ž¬;5$Á2PÕ´«²Øeúp³³²ù“ɲ˜9ÕØév2M¡¯ .ÒæÕ¬D_!cÓ\e¯X¨¢dXÉ´´5"óÌ×çžQ±ÒMë«2Çà èpôîÉ\±÷”=ò ŸTè„H±ûöÝÿ›²Gú|0#誶œFæ=°!¸õæÌ=ˆZåéÒì|âý§L}·T âû)Âö_¯í è×0§?‹)ZwRÝøçâgEæ»PfÔ´Â>µšK”ìÍUw"\^tU*•f9—iGÇZÄvÄØ0Èí˜s¢à„qi@ª1à!,YûBU‚ yWPmÎäø)Çl/í£ž5‡ù7p‘"ôüEت¦ßE¯Ð|ÝÔ"£¦b{þ�jŸÉ·kÿï_ÙçVâTüœaÐBÿÄV@Æ·Ü Ð?çK3s£]KKqërÎ .ì !ás2vc9—¦Y*ÀK* &º³ÛN‡Ú<k¸ËÈGÓîtØãBçét¿ÍQºI¶¸Öl0ÊŽ·¢ Ȉ”BRŽºëœùiØéTé)”0*|íDhטž-½q|lX³bèÀ“{?ežyœ(£ž}¼+ˆ'ÎmöÎÚV|ÚíÈ‹ì{W ’XúδnMàB€Rý‹áa-o”^ÏwïqRÚ”±¼‚Š+eeµµ¥aXsr°"Ài6Lkw%©Ó½¿‘VN\ˆ/Ê2†,H÷ÿÚÄ%@/Æ¥*óH/ÆUOªt3÷eYtÁF’µe˜ƒmý'Rzžg¼P1cœùÞ·ÐìÒíSýÁ3}Ä€}·¥ú΄f7ŒH’½)«²o¤¡;¯éÕPŠ2@ª_+8EܹúFì4â¬%ž´Ám³½£Áч»þ çi`"žO@°›ŽŽÒbdqœÓmùÅȽëÔ÷»Eù JØ÷.÷Ĺ / óØXš¾ẻÒ2‰º™ rŽ?Éî¬=¯Ó¥—+º$æƘ™KEfn?ÜýQœ™W@<9¨>õIBˆdYÅÿ¾eT¸$/hQíÛùÁË3!Kª.¥MKâlGv@õ¢dm7ÖÏÆ ±%M+³nù¤äaºz†!ò¦å 6<œ=àÝn,2!½ÓÖÌB/*8” 誼;Dzÿ­Z`fu) #´É©oبXü‘óX|íFºÕ’Ü•‚ƒ7S£¶*Mâÿ71 ºv íκ„,wñ°ç`…»#U6-=Älü×£ !A³¨CÏÀOZ™ÏAÍqæÉ¢&,šÀ’xûO×d «U5?Aëoþ…*^ærYœF°=Œƒ´M«ï¸™™bÞüdпp>Œà²™ÙƒñŽâ™,sD¯'Z8³õ­±?"ŠÜO—á3ûèÓú†âåÕMªl&÷EÙåx3íÔ‰‘€Ü¸>#']sûª4ópÏ1Ëú¥tÇZg Z.t¶Æ=D^õHÈúF§“Réy¡§5?~oãäé­Áðž6‡U—SGŠ”± ¾ÿÅo-#ÝÄ74ø·¶C_j‡Ö;2°jI#ƒåÊ"iñ¯r¨ÛŒªÈ+ UzÞ¯“íäÈrh N3‹­ìë/*6¾Ñf£"ñÕr°Ýª2»‹óøù¨&ëÿ¾Î3]’ű^6{;ñ�‡~vß\‘ÕÑI °Ÿ¤1›TOd:ÒXÕAv­µ½s½0QÃ.cNðãnv½c»ÑHaô‡ý“î­e�ZD§/Za;tK`[á×ÎÀ{‘gÆ.É�",€¥£&ŸPè3‹,ø I6÷JXšíÈùç$þÝÅ�®Î>liAs ZMÞ(ûP›ó’Cl cοò—Ó–OÈÀFJkú>®ö8爖7p}�ÞQ€©ÏÞÕw’°úR‹Z]žÉâhJùDZdL&)„ë^èúÊÏœÅÛŒv§%‹]%T|àŠWŽÍÚÖÛR‚ù'çÒªÞG¦|~âéGô…yôM( ¾«4,R�ZL¬ð$BÅGø¦Êáêo_ŠHpmÏšüt‹¶–FÇJ,IÃÆ8l™cîg/Wd¦w0ïh86˜+‰EMÚ¼¢TlX´‰Ìn{î|býeg‚ Ÿe§"m×C\s×½ô!XŸ•ùïëOÒðE ΂ì¼õtÿÖLµ‡»ë¬\Å+ÿ]º?'Êl²E…šªÒä/\:ÁÅõïVêÑ5œÜ ‚l‡J›x˜Ö.ÝŸÃéÆÂÕªw™”ï:tww+©eÞ̉ûãDuæûÖPk(—8ÓÅå3cœDXG×éÐ4ë6qäY`éðiè’ ›ÛSKXP˜go¢çñê7yåÛÅU¾ò³J‚á4vgÕW çÎÌñïÐ[©ÄBù®¿‡t£Y:^£IAÎèW°$¶f6’eÄÖ úè?…6‹…ß”ÝWìY­Ú¼,ñI©ë|•Úc²¸ ï®F7k� m’+s3j—:‘>ùÃô½¨Tòœñ1)€Ø‹y?Æï39 "–3‹Îz~'lƒpìd„c-Ós{6Ó]þÏÏÒf‰×f4|ÓWA>tfò€`€áÑcA‹•ƒýçnYhï¸VBÍ�§:U`ç /|˜Å6è×â³îb ÁH2ÙÁ®c…m=0oâÒ`PõAÉËõÃÌ�>“àüfïåˆß«*D8‰6«;˜¶Âx¼Öq°Äyi,Óªžöi÷a_�×}jé@WúQ{bËy:Þz+‚é¨kQê³Ù¡•úA‘:ê>]¼‘rU!4ýaá³Ý´Y¸Ÿºj¹Üö_<…Äœ*8RPK¦/|UÜÜ{?ím¯‡¢Ï|ãn:×ým-O¤`‰LðÚß?­´<š§ó°Ÿ¤±½ø-¹=¯öÕH¯'ª~ÒA˜ˆÑ`}"z“¤E‘%¦å'Ê~±õJ;m–úÏ¡¶½{ŠÆFR<å²ÿh[­¿e:¥®Ë‚ŸŠ¹Ò¨wˆ}¨$vÓj\–Ò+Ö§xâ®Gë1“š¶`É4£u¤„êÊýw€N®bŸϬþyGÛ}Qè³ò¦.ø „ûŽ±ƒ»ú¦z†}‚Ú¹)®¾ÆèCDÕä#c=Ê!V ¬¿5¼Nmæˆ MW—2(KzŒ׳֞®/جÝC¶&#Fh<3(\n%t>ŽXª Å_=n#<Q‹B]2 {g4É»5³D¥Ï³~fîrXXò/róã=Rïð‹Ò,Øï`8ëé]yÇLÍ�âî!m:Sõgïpܶ¦¸,¢·Þ*–“侈i'ën~nÒI?Û<Ö¸f§Øô}çúùâ(Œ,MÆV*¼úRGSíØ ‡vlôþÕ Òi1ããz„×ÆûŬ:ÎnôU›" ŠiðÔ¡ŒÙxÚgġ΋¨yô­9¯nñD•È'â°äÑvP…uÖÅ|·î JœêãÌ––æ)ZrÇáÊ=,Äì' ²VG`ÂTB¹¯0@òüuî¯5ð–>^ÀyótìÖ&ë¹×*`+뎣g¦Ä„ m*˜ûŠpn”æ+Åø"è6Ñ1È»Æã¡gd€EjÒÊÌ´ÛÅc±ó O.»6%ÎfU£ø~�¤¾kiB)Ιb`m€˜ýP{ZËNE”åau¥¬;Ø?ý§ÐŸÞK{ùCáÃ:lC¶ZŽ€¥=O69— ð ECÉ”ûÉ =Õûå§Ú›Ä¬ç|Õ!Ö9k†”¶½«•éW–EÞÙA ë2 ÕÓ™Ö@RÓÞ²Ÿ)N{@hÍsäûÎðqªÀÌãÝ([‚ÑåÊ´N}[Õ/|Öodj€¶ .}=AVcëµ6gÑ90÷£ž»¡¹Ò;LóÇÓXZº¬QDÉ›=íàìóê4lzá{,ìJÍ¿ŠÚ”Š+.øª-­þØ6Ÿ™ùÁ­0™£Ìc× MÀ“V WãZØ|ìböð*J¼´ OúW‡I’®Xû•½ç›·\í\îo™®•Ë dBºYÒ dm/þKÔ˜\'‹Œã†ž,:3Ï›P9]¶‰¢•Ž¿~ñÄàVFeýÌ´â4'CM€ö‚piǺe`Š=Çç oHI¯ »£Ê ‚„Y º{ÐÍYön³K,ºË9òfe"âQ²4i²ÛÙ~÷OÓš„Õ "‰NÿJ§4Êü³ÎÚùRa­·ÔJõ§[Á”Íí{>ÌVdCpÊ7w=«hkÛ•-T­íñ°ˆ °998å”ï(Þ;ôå*_Á ¢`¦š6¶‹?c¸áu¨�¸¬~X«&¨™j(¶s%e¹ìŒyJvºÐÿXö*+$¼»ûì÷2ö)º v}†æ%EFK‡?‘©šª†¢·ëþp•Ø/2G_ºË‡ÑJý~g2ÍÍ+c,0v`ŒìÌŽÅ¡ÿeÛ-ZqC§ïffKaÓ*;¥,ï·²"ÏVN¿ û’J¹«ÉbGÚûo‡¹ÞpêòÊÒT»fòï]Fÿ±ò‡ì—BÉ÷©/Ø¥ ²ÃÉýé‚ÇùÍ‚ÁV¥£–0¶zW"’Ù5£é ø5ŠRgçÀéÔœ'tª^ p+bÅåîˆûkfÅLª8]i;às‚éIRb·Wß»/eiå£q|S‘A^[›GE®ßLÑëØ\½Ôbî¶ì¥ëgyäh¡¬®¼;clkÝo™…M)å”NG2j$b©™ßÚ¶Žo˜Î“íî "…¶·È­]°~³ëc�–%+™ÝïY–žèl(E‡[º…ZÅ7Y4ED™Œ^‚» ¥x¹RžhÿÃmÁÎâWv,ÁöJGȬ…D>©0Ct·ön°§á[üüÊëãÈúrhº&{pj«Î ¦CAð§f«#3Ô6íé\MFœ$<l<ŠÂ ¶ÏVåý¾ZUY†TyÉ>É :ȶ*ý~š9Ã’2Î[W%§˜ÓQ²UDÇÙÌ-ß8Ñÿö³Ñ‚‰ÂÊõFYÞˆ½8Ów¥îe¡iã°#‚ø¿±átvÔR»ì2~©`dƦ58wã~Aj{v—Ã|·×Gɪ6U–qó€.²vµƒ‡»~P\æIæ 0S¨=7`&/úùPÓ¡ÐŽQÑ š´˜«®FQöÐéN�,Ñq·Ñ–UßHÄÛ·m* ´õpÿ)¾Ú L²"«L¦3ˆ�P‘¤Qº�NÄy_e‡»:OìÔ¤¯ë œx ¥¤ñtÓ÷öf%Ðø»icB0w‘Í‘ê.':ÎÙý¹­j¸nàG0¦Ëèæù"\tÛíúÄGeœT{¾Í[m&)Ë¢`¤´gOlÁ™ÐÝt_R…£ÛÙÎðÙ°ß9”<¾›g~hMÒظAïHY÷ªÊµsV©/­)J(h…®ÿ^>&Éüv7„®§,H:u*,¶Ž~†åqbÌéÜÏb5÷Lú>[;ð–Á1 ÒólàÔµGú ³ÏTK‚n³ÖÑ’Øu&pûz¿¯å°DRpù:zÖñ¸xŒ]}u8¢¿ÓîHS×ÚaÁµa¢ Y<=æzÃÍKa°Þ*dzº˜žÐ”L©–yöÒx°ú_*-±›ŽùfjÝ%©ÌÍð+N¢•K*{'|½±¿Œ‰Ìm>QUŠÍód%‘G�Ñ”ò‚Åxc«º�êþR/Or¨­/ýÚiæu¡5£èM9˜sgÙ]€!å!G½/¤mPËsðbçjÕØèe43-†¢ýrS/Šy­'üƨNÑcø;Ãn[†°¨6bXœ¬v¤Xš†nºr@~ê%•±‘¢Ã‘‹Nô¬m“’RPC{0H¨í:2…’÷¯tßK‹ý·ãnZ¡]ybLj#D0¤?@–TY8^¦´NšRÏ#8cìï@eðÞv´EÌj‘kÁ7߬éÈ e6W N}:«ÜÞrÄ ’0ÃGç4ñÀ a™'2¸Ïñzžy=%j2)ØQú“›SŸ „éªÃŒªµhl* Dðxsêm—£°Ì\VPbeR‚Ä{ÝœèùìNXÖÖ¦ÙÒ¿0¯/CߦQ4ÀzÒƒ Ç+dº÷¦q÷í_ìM§b±£Ä6á>†Ö K§wb]XÃô`Wúĥʓ¦’@À’ÖY@Œg pëVÒk³ŽOKË+ZÔä)ù$È|AkAû5¦ìxÕq4õÔ†Em›5áÓFCuÏUþ›k3¼™?Í2–iYþ‰ø$u5 Ïc»x_ ¼5;õ¦ yçÀ2“šå†=³2(zk{Wð ¯Ø#^V28³÷’›K•a�E4’ÈštÚ#NŒÇâWÂc·@Ñ„­Ó4šò¨™NÇþn~eq„±ñX¢º(¡zK.œþŒ­E")1vy�—÷”0óÌdsT‚ˆèÿž¡ÍT¦H­‘³ù/?ì—(®ücIHOÙ›³i†@¢¥Ôi¹_ÿ90:Á»â³à¦4ÏÖ“0¸._ë †]””Áö¼Ó>È4C¼ÔǼÝ#m%¶*,ùôÊE5º¬¿¼\ª‹®ç÷\2Ú:©˜žÑŸ£ °WkÄ©’Kè~#÷ø�•q}áNýå¡"´3l¡?Œð—^&5ä‹Å;®±º¦ß%í…å€$©0¡c ÀSµÓ67Ò×ÎNI_;UNõ^X¼—‹áª0ª\¡fþÂ× †Ãb xè èØOö8@w¼§¾¡ïn¸£0FÆ1Ùêé"{ÝÑW["GVÎŒÏJNçK–¶5Y.JÚ£bõ‚4FÊïjîiä²…îOKé—Ô`éfOSÛr 8z`êPz›¡BÓŽ–•LÐ\DlfaZ",1Õ_Õ´O:Õ¶W¾’Yjò¦¹£ÝØ’¾?g;ÓM2Ã_ Ç çϺ¸|L¹‰V鄾@R§y9kØ^ê¿o>n¢’­(žÉö$ñÎœý”pÛ†¡ ’ýÕ“€˜Nt2,v òöñ3 $)sGWùX y£«2d?%ÚÞm<*Çã²XIì�½U¹•[E¿c¯–aû˜#!<w`}Ë¿wÌÙµC”›GÑ@ øÝvCã @ ÛÉMÕg¤,­zͽ)^ØÓý8V¬l(¬Ì,‚ôæ™þBT1³µIHÓƒ9š¨“‰=6Çi[+><¬âÐÃœaB÷EO4·6`xs!TÛD…rª«…kÞoU–y¸è(a)™Ô #¬Å3E>hn…CèÜüì„ï+’¦ÁQ¿½ÊJv’ø­áƒÔROæPÞ7¤ú¡™îѾ¾ÎÉ'V\ŵ;> 8ÕÆísb=Ž[ú¢ëp­(9q.ôˆ]# Yʽâ¼Üï9_y(áœâ·Uõ ûÉ)U»aöMÔ~Í0d%ó'’9 L¿\c|Þ wd›\9M³N €û`)âåŽÕ3m >FçóÖ$°YéSV )ÓQa]ëAÅD·—›Š4ž¹ÜßÌŽT¾ˆÎ·} JÝÅDZç•èkZ!•Y\où6;:o£SY];Q:X>¡P+Ñ­ýÿþ8ûÍ°´îd6Sú•ßê‡{qÝÉ:†fcF8ˆ¶ÿzäŒ÷ssè;§H@Çø…þ⇈±¿éÝwOÁå΂L¡ì±Ÿ¦Ÿ!Šá‹Ü0sÔ=·!ÓŽ]nŒ°ö_±÷†ÒÜÀ Ëeßõ[–Íž�+âûý+KWM™˜U`¦¶Ó¬=ƒÞ‹ÜŸT@ìuû‹ðVsz訚Í Ž Ú³“ ÝMZ«`{½!ša6÷.é­t–fw‘Z;3£­ËÚTvnÆ|‚«¯^œÐàxº£ÊµÇÅîl×gT‰O“š++~GC;7ȇ�‚†)[Ê ª¥S#dô>Ï]7ÌŽÆYéöõ»Ó’J*Åïj[îià}Ï<ã¹›e”{I #’Ú¢ég­s¶—ô{~–<Aå%™/›Ö3…«hl,„no|Hî ù‰eNÿFÓke¹ÇÍšy©‚³%úèû~\§Cgc×¼pº¨e^‚ÝÐ>úY½Ádf<ӣĽ=û`$6\˜Ö=âÃ3 Dµ‚þÐsîÏ•þZCC~ž”-0·Üðhšó¿¬Eü;“0Ï3•ÁiÃD³ê{G¸µÝ#J ÞÊ€Ò8ßœ—6BxÔÌ·ua*ï’ã¶':Û¿¾Œò œ4é\çÌ—ç|[ìÀÅ#°Q&¡«xèü.—Õ/:‚jç–²–ȃØpëåûH¿¤ŒM´‰>QJ}={úX’8Ƀ^jÁp>u+ý5GNzi©®ÜöÎaŒ²ižÒ¨©(-@.ÎPµ-Ë“Þ§CE”¸ÔbÖ-ƒ•| Œ¢´VÀŠ5ò_íƹH-X42«uü ÇÊðdö®çëOª‘†§#Ú®‘�qhÿ:IÃíyb‹ÑÓ¥ÌÄTZthÓ“CÝê®îT_Q¢ÝÜÄôë6'ú¼µÖ•M¤‘—_V²kPÇt1©t-íû—NãÒ-tVª›—$Èìä²â&ÕIÌEÿ7¡2gö^êåOd‹ÎxÀu„R³˜½;Ù…¿7õ}¤T›/ÐËîTô+JMð±ÀæÌ4KfÂw�ÜÙÊÄ‚u-سB‡qº!²â= Šý!Ùöâ;z:ö›×anDÄÏ£NFYÓ‚œ}úçâišøe7í®¬³V{ˆỳÐúè Dàd]/_àÙtE&AtÊQrKõÜWm5Ëá4YŠÄŽöZ{˜™ÌÎ}“-›Ó·47óž1 `\¶y/V“D„e(ãŸfIæÀÑÝ.3v•Çâìö0Ûr}åßoN”Ãu Ïí}½ñ�œv™vÙØøù´THm›Q1eN"?Echè^¤¾Ðã¨/²î:ô³ñÓ£ ™—άh« Ãoe×´çV¬kd® wžÃÓù7Û$§S_{Q‚cìÜU^‡à~S_zïêžGF”‹4붱qÄ¿oÝœÏIž˜-ùî] BéŽ.Wì©*0ЩûJÒ hßÍæm¸ÀFu@ZÑ͘˜ÃÖµA-¢_Þå=|^V­Û±81Vmïùþ4õŵÐ^1b ³l=H›±ç\Q$žà¼Eé‹\—¼|·¶/\^%*ýó® *ëùyª?09 ÄP^ñt[1·ØLxkOÅ *ó‹L›¾½‚Pf2˜aO8].÷v®´gîôš—oÍ8¿Ê•¡ûDÅÀ»v3�Ü[çȽiéi¾cæoGp•§{Âu@ÓPaÑ~jl‡ÖÞ¹„-CY¥Õ^½¡oòÖÖÓ¥{ô[ß¼¬4æe‚jÕ¼ŽÛ@ñ¿…Yk›<ì€Kh<"FŸ=KZïäß+ŸZ ñ|ŒBñ(?Ï#n×wYé¿ÿÏ=8Ã…ö5š{Ï7s)däiK•¾~ù¾™’<¶Ç’$�ïkho±H04“L 4�¿¨F—{'¾ó—!Â^DH<©w¿fϹÇà‚É ù÷>‚ªZwò2!ž¶[—6]·Ù¿‰4Åß±NÓÒׇØà‰ŽWk±’Ç(‚f†Ž?Ä$2Q,ðϺ#j> »Û ÚðS²`¿K=üW)\Tbe¢ðääXžŒ¥r’ µü@ æÙHÊ*{·ÿoji¤I¾Áæ•sçˆÔѾŸaa‰ x6è%Eà¶þ°“¹$“€n6Y¤ ïhÙV®0ùcðª l§ÇÆPb+tÈÎEœÎžàEyÔ—ûË+r"h Qá‡ÉœÒoXáö¯O­GàZgÔòÛxŠèM)AHn-Ãv§Y4�Ìë*$¤ÅJ˜¶ç¤Yf˜ŽÃkp¾¨1Se+K<ØÓ©R| žlç\ PˆÝMä� ÏåÚý t,?åAÎÒà¼Û+Þ7ç@9pa¸dªâO‘O°cïÉ¢û/P#zGÜq#ÁÊ8e»%Ý^ÿô´g›Üú§˜vù—‡sXºãØ;Þ{âYúZƒtC¨lˆéÙªc@ÂŽ¶èòYì„_-˜âíZ¸ú¹‚!µea°ò‘Öyòõ¯ºd üw­êòmº·Ï3+ßþ oþ“yÁ­@O¿…gÑɳ±,Eƒ•<ú+ÎeñŠµ ¡ì=Ýð³öÀ $CñvX½£‰§6ÿè7ÿôÝ?ZTª»¤•á/ t³TA4í<˜$×&ŽfC¿ê³ÝÁðûÓ¡œÕG>RÚ®& ' [©Ä‹êš<xý&+!G”NN»ã¸O¯ÐÜÔW(ø½áûŠ‘?ªGªg»£K±)t”ïžìßÛH s6Æ&øÔ½T ÷ š Oˆ ÿ_0€­ù©Ží„äO¶˜ˆ;0öÚíü}Ã{ß{Ѫ§‡+úýV^12Ë“õMXîX{ýÚÝ´5îÎíÁÚ³›–a?Ç!ÝžÁ­«Ç›ï·™ žNŸ¢°pmÞQ›m™åöËëŠ\�z£€l1d);©m즭˜ëƒK¯”lZØ°TÈ:e an +Ù%½RXÎ}}@v�7ùŒ£Õ I›)X9?F¤Ð—8R «ö{ų ×á+GŒŸì(C0÷/+ñ¬<E yÒ¹g¯Êè›Ü$óG9‚Š¬wÉƳœ•{žÈÂ-½Sr,­¼uÈî[FnÖô¾õ¿7ÂÏœÝôø‹YD5PGšÉªÙDìò54‡�`HvžÐ1ä¸Ìpñ{}÷ËJ/Ž<ij†¼,—"(lSÑ.ÂLúœ©TuîŠöÿ0÷÷*™"óåY¡ß -äfô˜¤u®ÿ¿us×PcZÅð3.êÁã­ó¦¬®ë͹_ߢHýIç20§¼Ìùb3'YÕ{mÚce]ß 5[Æ’:ÿ ¶eNaëÏMÄTm³M sï´HãtQ…pñ(ñ-<Qyæí°‚*ð¶™%¬Æ«iO¾ÓòÉY_@uÞ«hë-î½ð¦ˆ©R’*HÞ}²ðªyCJy…£âÄhr7=N}Ñ, ‹­cJeù@üóƒ©Wˆ²Ë<”cèiÊ \:ä´n2Ó«=“›Å3¬ÄÖÝi,îMŒCçÍ"³UšY§aªd‰¡«œø¢ŸŠÉ³Ÿä·çE7¤Ay¾zE‚è¥ò1*9ßÖµÁ£yž»çBü¤òæ˜Õ ¾Êˆ‘mh1IoQ q¯nïòQç/NÇ•(ælô½µ ©E6'M³ï©“ØË×cß'*7+ÜQûa¿¼·ùBøËÂTOvgW»vDAæø*¦þuä\X58©3–ÎïJod=J"ÇÆ#ÎàÞBïqñh×Æžçûý™Þ½ÖÞ4½ÚÓÆ·n´³7è.34U^H~þÊ!Uí¼ÂÄU8ˆ€`l &ºQ ýñúÒ±@Ì-XÊ Þ­5wºƒßê¢MqžPzK|`s•{¿»\)75ØÞoÚ¿VrÐÀ©i)>ZÍùË”G';ž@ä ³U ï6¼/ƒ°Ý}Ä:˜[9n19½x,›b ƒr:²¢ú^û¥2}ã}¥¡¨éê JMOÖâÔ¡ÊÄ™~ mf%Kc3Ö°R^-ßNÕ,å?>²ÈNc'㚣øÙ "œZÓ°Æ›SŒd”¿½Sùþj)áÊÊ‘ÃÒçÜ]<ê“9xç½'°C1É7ÙO.ö(T¾ÿæ†_ɹj3•A1)À¹¬£ælQ™š ¥ÁSý1Û[zâu"TOKòSÚˆn@”ôÝ7Â<y-k´nª;±ùùFÛCëõté5¥~Ad:²êîœJÓ îÏ´’[%ø¢¢¬7tWWAžKÔ»ÆtfTï_€ŠM/CZ,è¤Ó6!ÏH»¥ZOÂÆÿYýT»r çÇa»;SæV¾ëŒuñûϛﴵèÏ4•æ4µ =~ÐœŽ½’%ø#‹õ¿ëxVOŒ½7ßí0Î<û¹}u¢¸¸Õ‹ÝP"]Ì;Oëvwè7{¤š¶SII}¯¦¾újOªòTf«B&ƒÊ}¤Ý»ëÔB“³Ãè}6 ?Ú¯è�‚xPP¿+ÓJCKfÆU”ßPR¶›U˜Šžp=ìγ=4ÀÒÁŒáoÂgPX™RFvAªs‹¥³Ÿ\ÑBwœU¼z@!tTB«Ûšæ\Òm¿¼ºáC�ž;"ËZœÆ§äÏÈ—˜H@Ÿ¶¨µ£‘ä|"à‰1zH1lð€ÒöIÍGE¶Vøa©ÙxÔÒ-Á‡–.— M߸eµÝ…y(Ó«ls! ¤$vb&ÑzN¦JÒ•[x&*;ÓV¡}(³Çþà¼dÿRjÇÚ„Ú·£¿d®/ÛP0ê ØÅÏyg½Ö®ŽZ'—�èK[‚FeH�º‰‰\ÆÞl™ðOƒ²4K¬§ê°(h(y.-@12µ7Ök§ò0ò;?·)ÊÌ}ô©¯PyÌ™dq>�¨ôFGÊfozu?ÓS_›Aˆ]$;E/QåƒPÀ…R З¤Ê‘uT”´þS+ÐòþÌt8’Ëb¯evsVþ¾Ç’Ä©ãa1F§5­›<àW×¼_|S¸Ï ÞQìP@‡9©»˜„ŠbÞ•QS—Í‹À»<^õîSe(Ü{ô„í¡{ß¿V}¾­ü^C«:_,?8eÚ#Ýôçt˜¬ºå0‚{í”eœ9ºPÈCµ<(mƒ;®&ÒP¼ñ¼K-Í3o£Ófé:ý†Ñ£o\¤å¨XÍPo^mÏÓÅ)<}ãÑ\ô €÷<J徆µf¾yµÚn…KÔS¶›7è÷n¤¸;Ñ*eqÙsh5+ÌÀ¿žº–N(NF7=¥“Œ½ûK¯-ˆ3`œ(¢ùo]e6ûzìúê凉£cá´]OuÒܹâ¾ÜTžšò‚͇!mÚ®ÖsD^êíò™>Âî1ÿ´‘<ã4'ûgùëëë#K ÀÚ“•ªsÉâïÉ»êyÅW½¶ö° 6£ðµßã n C Àùê³³ÊF™¹áœYÊ"ý†œÿ (}zMô9‚îd¯0Åìð·óç0‚ã½"ßÖ”™PÞÄ–M½gˆ@¥ŸŸf(œGÆב1ª§üLê0{¥­\OnI ‡è4¿ñÁC挄ƒÀíµÔí:ݪûyÇ;AŒ·èÝwÜ×Añ2xcé#Öº €Qé‹궘üI„Úªk¥C%¸ÍõyêàŸÀ=Ó¡S.”»’^„9§üñ¯§gÏ]»qJƒìSQ"¥Õ‡€"Â’yf?º�åæ{tÁÎ vJñbMDË€%ëéO§Ãð-ý æܳ9µ#8±gñÞ*<©L˜¶e OkýÍgCd'§mÑåÇÔsÊŒùè5h·Îš$É=¥çHï*=ŽûÜnÈå–Vo‚VthUºû×ÓËE]˵û ¾òQÙ.‡4°ššr‡äëê4ðÙúÎÛú W >£"vƒÞ3à‰fûùÌU8Ñ)¥6IM=9ŠèCVr‘øêctdt”Ý–ûÖŠ+Œc'÷š-@@k®J6kEm Û×ï£ÝÕ¸#³J¶_º\°�÷‡fÖlÎÈx>QóÌ|¶\„;r™Øbpò":Š=SI4ȸ-h^W?o ÆeùÖZqÐ TÃtµULUy% úŠ‚¼ßEºÛWºK”ÀeA›dï)/S7xíÇ{¬{¿{øY}/aeÒé}rFT¦M”¡Úñ=T®ÏúúOÝ3ôm4šþJ‹Ë¸Æ|·só`¼F…ù‹¾jÕÍnÔ¡;F`ù"]snŸÙ-QèKÜÀ`¢}ÑÖŽ±¯4 ›lóôP6!©B¿~¾¬Fsa½;­\VsºàZ÷ eî¦<+EÖ¢¡0(Êöÿ“ êÚ¹8wö"£¿Ý`ùûÁOQhŽŽX»® ;χÆ@5ýÎGt-# † ï¯1ñ `‰ì f|±»Gìª"÷¾ ¢óôäK²N6ŸµXáXISõõEeÈè}Œ9M^«‚z›ëdXK?OfŠr¥ìDudGk1ª?Í#¥%[÷ž¦ùß W‹’§÷ppáÏÑÒ¤ÿc«ÃÝBÉç©*¹g¯•9Qïض~#›5œe¿§ÖáQ¾PCpqêÌ\õJŠÊ±6åc’fžö…ÝÌÝl¾)œiÄþt… Êü°YþJß1\ŽýàïZOžî&ÏÀ‡š”ͧ×1§F³‡x”¡â?‡á;¡~2ªŽ”¢1»›ÞüR§A9!þF gÏCmšs-¶sÌ{—,)æuHdRt›ã ¶B_È‹úL<|TVúýÝøÆŒ}‘ù6À'ÍæÒÛ†<ɵj&ÎFÐÓP+tgîëјè®Ù®?’S<£ñ¾=Àyç¬À*åjà2y¾ÿ˜—'F[M#AÐ_À­ï4 ‰òÇê<–Z«¾{Œ"ìæ€ÿÖð/S?äøÛx[´FbA<hó™–<÷ôõžÇ}”iG[ŠÈŠ©ã¹u…" ¡ÂBoLL¹Ï¿GOK«["Rv=$¿ÊÆ¢ Øç¦û¾·Ögþõr³gh葪[®÷¥J*”Ýö&¥û:è�«ÈÄrˆu¾å¥Ô�ÝèUõ™m_³à È®t_I¤“5Zð‹:Y‹}<]è]•Ë=¢’.&I)àí¤£¢HòDl(NÃì¥yw´Ro4SÝQ̾€z*ƒpûe>­¬U`2ýVãù8¾£EÛDi0ƒâoðµrë„×_ ­éîâšB´ÿúƒ#ÓáD£%/ZhŽ?ÿ§P‡F£…ñ•%v1wЧüÂ1KÿmcZ>ªÝ+‹Œ–»lÏW„ùbàÆ°É<åʪËF<{‡T„ö”æ°F¸öÝß)dÎ[™= _£»;×á:£3K‹pœQü¼m.Çå2aw©áÏ_®³ù—‡0>â¤Ø+rxkÛž7Nü;–%FÀñ°£€¾_œ¢¥£7¬qµr3wöÞ±í(¿IfËFC(<qwËLI¦Ãl=± ˆˆÿ­<8lG†³{™hï´ºß3n¨]ZžÛØŒÕVZ÷®n¡cq¤œ¿âs­×éEÕå)Ɖ…*÷›ôâvR¹%g×ñå$ý;UðF„Ý_[ÛÒ—¾! & mFM?rÂ2ÞWîëuèøÝÍí±­[iMC#å}iAkÕb7¿- ¨pfZSsâãŒK”€3Uß‹A­¢R-Ék¤‰Ö%ÒOõú'náÍh+ø€ÔnlýÁ«¤pÉ,n–g¥ø·›í+j� ù]$ZÓuÂ`:R–íÏ®;´¥àÌÄ5NÜeœ Í@eé4±D¦^X.™÷I§}T‹ú/Jùm¹ÔT‰í;oàÿ¸6ô1–Y˜„#„ÍbWÔÚ.í•"P´·°¼Dáå4Z·ŠîÒ ŠP^Ÿb™,7(”-Ï�2¶Úž@†ý‚.’³æÔxÚ‚Y>-¡uçÙ‘ïÓßW´2vîŽwËY3]×o|Ï9ŒÒû°\ß scýó#Lò- *•¶œª­ueyº”O§Ã.@o£ç+ ‹Ñž:SÍ·§Xyó+ÄÞû•q272|:¬``¹Y†žöÑ°Ü“1ðþuN>¡/QcꂱÅÕº’EB*x[k¥ÿ<wYÏ`¢Ò›_ˆ! æ³&q@Pn]ñ/&iáߟ3ÚcÙûdª‰4PuF üoNÊy¬™ d0ﾕå.Ž±¢º4_{gI�ÔažOÖ˜øyó5Ë|;.ðddV–J3$›5¾l»ÆHÅ»þÃy©<h¼ªÒ‚hÁлM»‚î»+2~¡mN•l`¥Í­(Þºéôßü/ZSp§½O?ÂU‚ g³$_;öSj, ‡\/u¼Üœº–²’ɳöá¹GÛ]o„-vBPÓ§Ý!"Q½p< <¿þÉcªH/϶ƒy¤óŒË± òØÐ/(/†ƒq•m—Qÿnê°ø>Ì`2+ŸöÑ¢uWnÓ¾1Åç&› ³pµ.i{]¨ÐXç‚. _úý Ä2IN¹­¥O‚™Ùì žÎîáŠWßKÈ<£H0SÁTÌJ·á]3Ñ}BcÆ&À8|ãÚk<ïr…_Ç@²‡Š‘Â!ÔKÅŠ)qb#‹)ç汞PÇܶnŽÖÉ¥»t“"kÂö*œ~ˆ"!¨ÚÔd¨n攵›õøÒ³‘¨œ‚7=f`,k)ËLRÅÖT5Pn_^ëÁŽ·¶u±!ŽŽç…¼¬Äæœpš]ï”߆î´Ìl J÷¨UàÆ7k6K¹‘Z®EÄèdJ!hƒÖ‹»úæšûÈñ!Å¡dc HÍSäã`XiåËæuç/ßï®7žÊɬëž*K€º,¶€=nÚ­ðfäÁµCæl³æu}_zØZÎ.Xò0™­K5À’ý¹FªÞëׄs—áíi)¦TF蹧 ÝB¹nãêúÏ"P®ÚÇ@ÚÒ©¿Õ|9ÃŒàÊ“(¾€µM×õ;„[aVYYK­(ÈöŠ çßãCŸ+'÷ êæPÜ„jˆž`‰!l$aÂhC&Ç>?tżF]y¨ ;Œ´f3V‰Œ­Rþâ[wTwâ�š¬\Üж4“«{-¶ª² Q#œ4çôiíôv´ý ¨5çܢgŸ¸_úÞ¦+#kz„sÄÆ 0Å­X “ØþV‡0 }Æ;åù§/Êxòùâù»ó´®§)2¿táX2Bê–:æïÄwõd§b4t4.è7 äÈÙÔ?½rå~æO Ñgx…¢‹p»à8-d(—©œw{E3­~@­:H ÷Û_+“¼Xœ&ÆÎSÌ8ÖÆʇoØŸ‰cÇÒpæÅegF1«í((¾kC¾ÂŒþL;Ü©<ð²Ç¦·;ô‚±¸ß 7aÕ©ý˜åb¡?‘\}”}Gi'=mª°Øêêöç¶Þœ¦óñ[‰îœl ,œ—’ OoZ|¤XÆÑ7'» Ln)“ÞFxCØ–�ô}ƒ„¾öz–iÄQfÝ¢3N§yì6`|‚ØÊ^Ü�ŒÛ+~®ÎîB9¨û1 ¢Y…Á™2Òúb½ÃõŠIûJç7æúßÇ–SnMK?–8b=—DjKmX¬†:ïùIèëßÌ8sØk±ßéª ×ÏÅãh€ ™tjÁ³ùDïп¼’4óé`tж®®V´š-øFŠÒŒíÒDÇîc 7»ùÛæö‹9÷0‘N•_j’Â>Nç¡c_cBz‚—¡}Y”.Xñ¬£]èyïílš‘—´©—Y@y8"ìÅ¥§ >êío­cˆë,Wê(r@5÷$Ü‚…-0ä0ýÄ‘wÆ)Jg¸Ô±.ª¾Uˆ:UÿiJ¸j1bGˆ“iöŒˆòvé?Ô·d…·ÊF˜êØÿêFnTIë–”‚~{:Ì~Ÿbsº ç­Ç‹>`E{cp¸:FxU)ÅÊd-B®ÙKe±~Ñ)XQ8B 'ÍDKЪŽ5,ûï«�)ÉHi´ÍàN]"Ÿøy²]ìïÑB^´VÙ4‚,¸ÖÆâåÛŃ¥g~á ½‰z‡¶�çq˜§ÒȬ\³|XÇ‚ª×+‹9 Xª \»<ñu?aØÕÒn,5476i+?òWZÏQån·GO=ÕòSozB\¢jˆÍhOÃé™”SÊü‰;%ÞyÙRfTŒVƒSšy2É‚²ô ¸}¥¯Àé]¦ŽöóÚ3çUe’^öWÜTc]>ÎÐqª¬SôCW“á(ñfaŒÁß·i¿,«½ä]Ô ܤþ/ŠpDI±r Ï(Ç£“%9ë0©dÃtÖÿÔÆ20ÏD^ž“}ßÕĤ¡ý™j‹³Z°ëÝwâg³¾ïŒ=åíEbwëS1N•5 Ýb_…JT6¡pö«r´BÛÒyÔD´m:íwÊî;é(:îÞ;?#kDIæ»<'ä(ÓÜÏN†DN %°³oï ›Ÿ(Ò|™VÅ·5ãûqp¹¿9EPük=>™¿Ì«"WFðÃiပ©û.X—–ž=rδÒ=2k1u­ 2óñ¼Ûñž×&n!§T—Ñòí´ÜÚp¥Yæ5y’(vð {·3¹\TI”Ï�•'ÙöæB‘G‡S”{ãxvÜœ€Ož•‹‘Kg¨_Ø ÎPÜŽo‰–ð©ÏvÙ¦·¶6C»gסÕo”:Áªè«‰+æE¼¬dT±8ŠWÏ·j nêe}Gõ,­±=3G¾¥_µ•’R€)Ón}V 2_.uäc~ gcéå®vÛC¯hàì·ý¾xî[œŠ›ø#Ž×”Qž¹L?S¾^ôŠÈñ´ÞSùÁc=JTUõ´åÙÊ)³¬:±×…7½¨ÙK^áÔ±ÆÍ´ž~©xd”lÙóm¾@á”Î5…€tíAñIÆ;EH®÷Ó£W›¿Nω×%\µÓŠê¸É݈zŒH— OÝ›&9òb/(è“wC?ŠãbõÌoÀ؈(ô†VìÏÎ ö•}ñÈh=„ŠÜÛ­À{|¿É;Fž:¾ !w_´ô]Çïßwõ¿lÅL–¶œ¬È£«1úº!˜Æ¹Ï5‚và·ÅöÓA…7²í¹E|”ã2.¦ò¹ßÛÓÜßp´¬N_p^Sy ø¸x.ÕëˆÔüûS#ÆiJý« ȯ쯞}´t¦•òk¤ßïѵëÅä†b(\‘<è±r­ mA*ÂnÈÚƒ‹ me‚C*ºÚ~O3ËRN™$'Fb.úZ´«‚y7tj¡·¼‚˜K ß¹$ÊYüÉy{F‘Ñr§Ô×Í£«ù”•Ì+Þí‚õËÀ/ÝazëÔÚið€)-PžÞÆíÁgÓ&e¤•Ø^)mÚk²ƒ8dw„†ýˆÌäîLÅRsuÛƒiz·Ò¯±ÃS¶œÜîD1ôÈÃEãèæ5&Â2ó¸`¼üÊ k¾<ðúrÒÊÓ±ýÚ„ÏúWÈàÖìIP´‹W²^ ìj0ÔPlßìE̱í÷OòfXâ•@v^@Ò­Ï8•ª·Iøÿ5¬ï¶XJ=oD6¹;z _×eö&Ü�¿#È\½3œ.}»=÷vm»A2CûŽžFbËdŒePvÈùåÀž˜­×F´´õ7ߺDùÊ"Gõ´¸&hažû~æRÊÎPÐݲXïž…ƒ•G(x¬†eÓ)Ê$¸­£³B—„4ˆlCå…ÎJéõŸXq¹î³ 4 *¸3:rBŠmU´GÑ¡pWO]T” ü†ûuÕyðX€iÍ—?`LžW:36dÅ›õCøÞÄŽL0”Ƶ ˜ZÓ>—Ci…Èñ!+‚Þ´ßÇêBý_ŽRÏ’µ>–8ÈkKvˆþÐ4+6=v¢Ï¢xý—ßóÆÈó+¯¹µ‹kütmØ‹èxºU€#ÝÅ$Ùi„)yb@² zOt³kmôÜÄ°›á;r‚{ è5ž'óDBcžÍð6ü<[ÛT©5Ìœ2 "pkx™¼æÐe¥#4$8­º¯4Hí$…ÚäyrËø†ÇCçòb¥ä30O>UÒ—Ýag?Ù™»ÖǦ»g¬»’¾+™ÒX@þ¿6)¤ÀX¦Ó¸ê7Õ £7Gçÿ­_Ze«]=ØWÿ;îà ¹9%#JÓᜋ-V‹?5MRm°Ã¼e©ž½(6 EE÷b¨¦PmXYqPé¼aŠS5Ë1x&ÀEYvSÛSÀ¿þγt‚™ÁHl:«½²2•TÆì'`º;:Å‘óPœÊ‘j“ª=Ý[/{ÝÖ‡Þ˜0xýY_..×æ8lÉÐyî5ûšŽs!9ð-ë†5¬­ã%|»§â†&w-TpÞa«ØŠHjhejC"·9Ï–â|‡÷¯DÜps÷¹XŽk¡/°Z¢­9ýðá¸!t˜&0åe• 'žÜ’´¹FPªòQI s^eõ턧Ÿ¶›)Ýƈð._1÷€±÷ô®íÃœÓÉ•YÏ­¶´ ôNg;ô9½hªN9íÜ/‹-ªáCHEã°çǵçêa4Ztîúžcmµı¸nç*¦QâPuûŸ´j<ô•ñ »˜bXë ÏC̮妪Ößc²sÿúóå088«‘¨aÛ¦á—Uçó¢¨Rç$Ÿ±ülÖÌ«¶‡$c älúèÄâÆø¾c_ò>öibi�³Ðÿj�ç«á{#vãJÍ=âhU3—c”ÿ'åÞjõWá0\§A<hÌÏ¡äXÑN˜>¶MZ ¨‹U~´)ÍJcAéëYô­8L¾ P÷£ÛAcß]<Á8¦¸þô”ó…Ýàqb¹Kj?ûie=ý¢sN”*D&6Aäc¡/R ʽèšæ tH”E(g?ô ºq>ýùÏu|{nOò…e‚8aΧƭäÏ30^¾‚lßÕ7k®9¦nºÃ¼L1zvÁ -‡<(Ø…;@•pÔÔËÒ©Jä+4b7ïOæ„Š ZÄÛ½IãÚú²$¦ACŸ}ÒžÒ¼ü­%V— Œ$‰hׄ\Æ`³šþÜ¢ÝDÔ¨ Vš~"8TݲÔXgªVć[¦Ý\ÙùsîÛ{ßgE¶Z´öýu~Ã-Ù,!?Paaí¥éSïNS°»PaжöÕ«°e¾ÇæÕeŽ[¯Es9õ3/7÷;Ð>&÷úH(8+¬ƒ#Jì„5’wí†mžÀß’èíŸ7Jdb±43�ö“þóš ‚ø@[ËH<Ñœ»H;àn ÄàGŒ¤‘ÞÁȹk1öô©,q¬â·¥:sP˜ˆ·×EK£_éK;UžzPœÝO)%.:â‚ô‚¸ ™,ÚL†-à^í[~pu‰ª•P`˜À …ÒŽ~òh«`TáÖœ<µX È¨û¾Cxæ;)jA»—+%v °lUDIyÓ¹§ ýçÆWŽ¢î÷ñ`¦éÛs͘)ÿ<1]ʺ§M°UíèôõÕËé†ÑbSÁ1Ê žüŠ²Zc(³ÁsOžŠÞfÁô÷kK#>]tL³’£>O�%Üi+F•¾]“r%·î@·î =EOT5‚ I½9›1ûDr)gú?²c».ÿr­•:¤­Uv¸o{;OE'–ÕçгÒNÕ“0–OOö÷Lº×úþ%ýSñÞâlA×ë†ÉŠÁR!s<¯ù@L-N¼v:/±ýˆa×­b+|c>ò/üãxåæC!jþÀñó馎ÇzthÄljæ:M–Û€1fòz‚Àvð­Ê¾J îvR^~Óê´òÁB SºÑœÓi¥÷ ñ�,~iE ç5[ì…¤PDñnºgs_®ÕÒaª7V{ .ã8ÌY’R³ð{~:Ñ¢(r qœË ê'ƒ(Äes¿¢³d'º•émoö©œOXÄjðœ—�Þœ#ñ½À‹a`zTŠvTdýÖgtP„smr¬ HíÀ½{õƒi¶I3øÆ·ÑÕÿ©A¢Ï=­ƒÎ¢»°ù¶\‘̓›¥ðX¿Ð^»íâé.Ä“o� Q|;#?‰Á˶,In«sÙmíž‚ÜÖ¢ñY…Œ’9ŠÒÖ—åtaÛÃè[¿8D— ¬qöÐ2¨¾þuÛ’â|îÖÜ¡: ž¬áÚ÷õÙO”‚)lXî2û<bò6¸±˜h#ÃS†{,Z¦zÏ;XÏ4ö…å(H\¦,ˆÞÿ59j! ‰ÅÆe?#9gn¦QîÒ€ ƒiO7gVm¤”½uóÔm¢ƒÛíæU66 èȸ_dÞ40¨–>vs1…u Àî"Ó7£`õËù¹´è0˜ÙAqf[›û‚À<àÊ'<l¾̸¿V¦þUÅ Ë Pq’ViYe¨YEÓÕgèÉŒë´â¡ÌS'þ]§àÜ´�çu^N·¯‘#yïoèÚIž:ì4«Ø"ÆÙºiÉ…1ÚM×:ăӻ¿w¹vH¼V†¬÷Ä‚ªz©A�œTft6·Ÿ^%©¬Ïš“»<'2µ?ìCF·s´s€a6‹œ$éH»«äØ~ U'ƒM“Éyñl”ÐŽq[D2¦³ë¯ò~B5§Š2–Q(”Ù<G!€Ð—§·ÑÖaTp dˆˆî¼¹G܃ 1ÚI¨þþô,B-ÇdÛˆ°—3Ý8ÄÝe-é�‚™þ çJ­- m'ƻ֛½Úœ.òˆ-Œëvm—{h` ¢¶ï4\s#vl‘¡¡±ïc‰élÖÐbíAÛRHÍJ«˜ß| ŸM4ŒŸØUd^ÅÁ,÷–ÊìÈ%›9‹ÄJ‡H¿I[U<{¡õÕÚNªq7ÿz#ì"M¦¯» ”û¬öræÕ˜ñy5£us4fEð±Pþ3¶^«N¬X åRZ¢*ïn~èz ç×°Õʵ#¡@Gçv³ó3K™s‰¯ÆéÜÏíÅ£ÀX„ž$|ˆ·ÞÁ-vgF?LoؾU¦S? <Í`M`×Oz¥‘Óö¡=Êg·9¥sŸWR‰6¾¦ö”ÜÕ<ÜÙ3›¾Cw—*÷ãi‚ÆúýßÒ“ð  ÎFŠð^É9{Z^W¡CJhof1™ÿ ÿ-YŒé)1ôÑ5Ô*(#‰Íƒá¶ˆ¤­9pDγ©î½>šñq1ËÀü€þ„ü_"ZèoÍR.µ<_RXIQÀ+þ=1kt´MAdVôù–—©êV£V¾ê6¡ m&-1O.ñ¸bN5$lêKï]É÷ZwááI„aÃ@L±ÿXÒ®øÔ%!óæ·öÀÊÜwvJœ{=<ï[¦8Èš‹Ë ç®u›æó]§ïOÿ·çétw“V^ƒ”óŸ†Eã´ÌÔA«9yXL÷¦—ŸvƒL‚Æs¤€qÛtŠ 3V°G1ý|vóòþÜ‚ä…à±=À•á ˪ïó,H& Pø¯Û •¢=;œº™]fÑɲ֕PâØ]&ÚXûSeÑ>HaÏÕÃNâÕ·_péæT¤sN«éQ”_ŠKª•¾÷ f…kÃ[xuÄ,>.7g<âšç™/Ç\BŒÞl²‚Ï0šø.«:R¶‹wÕÀ0*«Çg+ÖCˆ<ˆ —½ÖÂ0³=BÆÅÀLò§­W�H¾¨6Õq§žê8CÖˆÙš˜qfÃàä æØe{Œ“ˆ^Bm¯Í±8ðz.êàŒe"(vÕ¸º}EZ˜ûG;D™.´õ?ß=üŒMoþ®³'kˆH„dŸªÏÏ«™;±wšñ9 ÎÜ•ÃàcïäñÝ…Ø`˜–9òyvŨœö8áoêËßHñgþ‰1Vª-‚²±ãó4Yí³N@‰/Ë3¦*5•yl&%MMÿ$l®'’•´ˆÈê‹aDkxñ¨˜ÚIOÙZЄ >ÓÉÈ—}ž) ¾<K,r—ç3kÝÁ¨ù×Óä2Ñߢ¿ê¦U¸ÂÕ•ZèK„ýViVš² uPB‰'_qìPF1AT®cC#Z<'7#˜ˆÙN«C- !RH¡ «í!˜Ë¬¥ã½Ë{²Ó++b~¤Ÿ;‡c…uÛÔË]ï´1?ð[«Â°7š™6Vâ`!+sRS8c¸¦1,ÕW¦?úýÿÀ.€hù~¶ê/ô¨Oìéù·lîNjÐDÎKÙzv¾øºp5+¦hæO›³Çiä]ØglaòÒë‚ÎÕ¹]í½›D�§ ò;$F’g~´¢ûÉ—B1€ZœêÝi%2™ ùà`Éß„¡ O•øÜ¿´BÌtÖ)aDÐu¶&{Ï>u™²Ã^à‰˜µžÑ#`[ãatþ 1òÈž¸#¦•ãsqcáB•[ò~U½:òÞÏÍžš9Ö-w¸^ëÇV̼4S!Ps[¡•»¶döÆhÈ9qUùˆÊn12É[=.èØm¤ŸÈãËŸ0Âpˆ°Œ1XæÍ¡ÒÓy<M‰l7°Ð3 $£~4G8ÃèØñ*®(FK'c8’RÒù¶ATµÒE4ï8éó— Û‰²ÂÝŠÑb¤/O "­Q­MºJ h䨚yøöÏ[IXÏ\N·ìcÍÖ"snr%ú"í�çeí¡šÔR,¬M²›ǹ¹ÚWæ)~ã–¢þý÷žÊKeœ"fäÖð#g`°,‹ô5M8õô˜„¶Â¼óíðø¼Ÿçé8‹ÊšÍ÷ž—“$ôíîÙ4-‚ªY<D >Ôâì °µ¹ŒÞ&¬¹è{™øöí”ÄzD ¶èÝÔe±ÃRÉH”«+J­ÆzAì½xÛ¡ð‘΀ ÊV Û;츜ð´À²v»zg´çý ˜¾«Às~pÉùîšS­dY nÑÑÊÍÞÏÅ}¬´»Ã{"·“¾ó5Å㶦ÄÍŠø`ïk†HC¿é¾Då‘_n{TVò2*T( ƒÔbŠ¢ŠµÂ`·„gc´†^ÕÝÈ}&R§-½«eu õ^Óa4h…ƒ™þ̉q™¬mcÚ*•�z“l0`hμ4áäQù(žìp67q§îùÑg‡ j6ÖŽ2‡m8ؾ êk’¨Yì¨Á�jË}·³aì}*+ĸ¬ïñ­ò²j…Ù .ƒÂº+ÉNR…m5ýð DJNF™†Uá�H]!…UÿÍ@{4:7¶ ©WFÞj)WÍ+-ón¾_+ª,\q¢âàB¥å8YÁv´€Š`àŽÍõŸ&HEŽòr§éä¿ i}¦Ú¸üü×…hêùq4êeÏçÈ.æß4t _]Æ4»¥åAkòƒGœ÷®Ö-¿ÅÂ9ðtDá·÷”‹Œ'‘d”T ˆ<¾yE³cºk0amIÄ¿ 7=Z‚lP8U*†ÜHq[ë]s»ë#jœïHÎË"è¼;šBgÀ“ýQ¤R¹1©T1¥ÕA'¿"ês†鴃aiz—¾ùrÂÙK j½Í绳zÝìX€ÖҿΓYQTö],‹ò¹¯ò*_Ö ¨ÈlÞ‚¤±=ˆoåÿ}BNž¯(h1«½Q«,ݔ͚¹¾^÷S68"*Á,0G4-…Ž¸½¸Á”lâ3Yß_QÉRãp§SMøKŸÿšDj¸ß¾hÊ+ÓV‘ûʬ?”`R§#ÀNDP‡AçiÂÿuný'=/–VÂý/ö $3Ôåˆ/þ£Ýh¼#û®“‡4š8󆜔å5hM¤uïyP`{P�&aK¡ 3ÿ~G"Ò­ª,« rTd'�®¨S·«=fç¯Ëì*3&æSÀ(1ƒü}Rµ ¶Š«?DÕEY¦ú"ž%¯Yö¦‰g;V°ÃŸz~˜ààas«°ö+×÷þ¥cÄ &™rf˜Ä¤”BII΋‹I¥T €* €7hM>JzÊòâµÅPðeœ UκÒ-<d̶¸Õ±Ñžù°Ö›ŸðØU3|w(•§(}UƒÇÁ‡šó –YHYýw¸Â¥çìÈL·ýÅ\»Ð/¾Àô?šƒ×uê•V(äaöôˆÑ=‹-Ú”6/üÕPÚ‡Jò¿¾<cn¼ì›òñzJ§Ì£¿°ÂÝ_«¿n31#wˆølJ!³Ó¹¿e*JçeúÓ¥«çú‹pN_¦œ_î�CBêÑeêÆTÚ:Íä9-N 7jU‘­¬?ÑÚË‚jù4‘!ÅŒÛõ¿'ûôZW/n½?©h¯E7–7 µŸn`—0ËýÃ:®-ùš§wŸbñt§ÐVζÁ\–ó"øƒH�ø‘r¡>?)GVV•‰Ì½…·*·Œ¬ !\ÞXâÎîBðÚ÷ )_¼zn^™Ñy–lZÜYs5‚ ì±6@Qצ&{©=þi®\†ÖíùÖc³Ó܈bKÊIÎÞ耖ƒËI¼’ÿþå _è»wàð›U\̤àÄ“©ÂÜ›TÕ\¨ÎN^ù7¦% é˜LBõL‚hm×-Ý Š"oÌþ±ËPÈíæ¹ÿ[€ÂÉ÷ŽŽÖ²[,Å-–s‹».ÐÒßè _Ø `/µ3ÄŽ{UÎg ´¸|ägçL1.lý.’òîR®µ|ÕÁ´ÿÄ(|ÕE«‘Üú`¸NÏ›}_ÔöÄÙl呉}ZäŸÚ¤]ø‡:%NÃbÝ œç÷T'nGJ\Ñ9Ë&1ÚÂ3¥Ð‘“oF#k…/|µ’Fže$#YŸ§jT½<2 ZÎS8iÃþoÊ<‰W2úù2Ó·h­d\èæ·øZà¾}½¼ëI[š¹Ž”±;Mœ‘kt×é@ùíH :@(¯²™‡­eg¼Í‚éoÿnÓ}S2D{êlIë5 ÷’Ð9[�Š\Ðòp¬ós�?EKÂ戾¢:†é „AçY¢÷WÓyÔñë,2²FT ZõGŠ~ÊMÃy)4îôHeÆ{Ï¥”Å"6­@3¤àqW¾BP‘f«‚“Vô¥ ¢Ú O5[L2ÊÎZùüX ÜhñCnŠ–tzmÍø£X«6ýj+Ù‘B+“oÑâ*ƒ¢Ûyr@ô„ù9]ÏÌ]4/ÖVå6vŽb)¨[VÔÓµ‹i$u†…’Ùëpmå‡+óW—Ó´­»Á¾®9/ögŠIQ§¾³H–mÅŠ{r+¿ôý* ]Ì0?è‹dËÖ³Þ1jnȾ¤(™ßüf0|kÞ=¦¥î¯´ï¹íúÓ_øÖT(f>þ¼ß/«°Š–ÕÖœ<h»àöÔ£H$sô;ëØ­ .*Á*ˆz‰³t¨÷οfX¾ªž×ãD5K«(X×ÌWx¶š‰Özÿtº*é__W½¶Òß2þj³…¦B£Y]‘²P˜Ó‹}”!z™¢ÒŒ¬HS:rÞ¯Œ£tµôšßd\Q‘y­Ah÷9S7ìhc2Ña‘>�pž�f%Æå¶á‘ô™‰¤ðñ3Çì)÷Š¿”nÀ3f=3ÁZE_á®Bº¶F¡âù#…]ÉÕKñvVíóT‹¼_g:J7¯žxi¸¡A8«g‹®ˆô˜O™¡XˆV/PÉÐÀðbZWD®ÏÀá¡£=MµçŸ„E÷Ç7Pj¸Å«¯?ØMD‘×N¬ÄÉ* ’O@ßI¢7ŠœƒÇ¿°.Km©ª((ÉN7PÃø!µx>ͳMç^£¡Äñ ¼ås_·Õ§œ|³aÝœzËRp—ZT™/¹xï$u=ó)9Ö”vò:j Þ_™Šþ¨#Å+Ð6,égÊ¢ö{oVÂdwð+õñ×5/ŽÔÜO¬àÌÞÀ½³áš@˃?³ã ¼ÄPˆüì9ewÓ6–ÕûMKÅÓ"#:žÎý­:`[›žê}Á±lmqÝ™'®µN‚8+¤ÓDʛٔÁlÏ®> ³“†{,€àŽ’ÂxÚCz²²CUñ ©¶É¯{6”úeþl‘‚fZ½*öfüdê>¼CñùÁh/$ ïûn¨=܇XÒ-UìG/Aù(XÃ\«pá@ÞãB²&K¶6ÆÚüï»sÏ¡“ªá±¨î¬›æþŽR/uT§Z“Û^Tµ¤Š¿Z`Qö"i^Œ;­'[!¡†N=éü¡u>¸ùÃÒ ø`>h ë³àSïµY|Q¦ã[r Z:Åðî»×-E=Ãf¾½¸ûÄx$i'z”/[„ÛAý;™å¾äÒVï÷†¸]ÌQjÄ\`Š™~m}µ0`«øý}1ó2[¾q+:µ2)vÈ°¹r×¢7,Hþ„ãwb`íB§ií˜&y`ÝôDxQÁ¾Œ\€Â»ížöØNqÊ eø£2÷) – š&¾X�…鑱ÌÀqܨ=ñ¡vÐ^¦XóŒÝ¦rO‡¦ùFrWX›vèü—Më£ XâôÁŠò–¡pA/ËæVeÝüäORÃëÞX·J^3ª¦§î 1ýQ¥›ëQÔ¶O̸ÇÖŒVBaSdÿž=”5”/êV%w(p,2g¹ã9y�±»‚=¹#kN QÝS]â‚ýcLð3 ôóa1œÏ„ æn8YL<ƌֳ\Èã{E2³ôš¸q;žèär±žUȦ“†ù-ØG¼šîà…î]zræ–Éà_•ñµ5Û‚‰ôl¡# 1eó=µ®J“J¡2øæwÞ-°�Ý«Wþ~x3¿¾aY–vHàbtêè¾,6vh»ã"*4;6ÐÑè3Á¢¸töê<ÛŸéy¶ŠàÈ]‡¨eõ.͘ÖÒ?ý'ÂpER¦êËÚXmÎî†,ZeÁªwP=ü+m&~ˆ7?ºWE¡/­CÓŸjºZóØLü*ìÖJËQ›GZ6V†ÂJ.w_˜N쵇À‰Í‰ói“¶ü#uÚ=änVødþY}±û@l)È›¾¾zÈx¨Ñ’a®ÓÓh¾RÊ:à·}®ÜoUÒæ±zlí5ŠX÷ÖR”Œ<4uÄö#û t¥Á —/:Øý¦]óƒˆMR¥.´¸r® D7§þ˜G™Òqù¹Ëlé¤<¤'ÚLhùªj“NâßKÕ¨Áú3¤&3_fœfn_ïôBKÛ»D† Ãà”ÎÁíÙü¡ºb+"Ö‹[)+b³›2×ϱr¥ä ÿ²ó3xÙwšÿojmQž[ªT×m‹|PòlÊósJ@yõjg~À'˜(ÓGic|—9‰ÀÀÖXñ9¬g/WÄ™ÚZØêcºÕ·1c•ø4öâÀ–ЛÏÞ%`"7‡úÿÏÚ›m·ª,kÂל§ð]Ýœ]ƒ¾¹! hÊšãÿçøã‹ÈÈLdI–箧–°×^²™‘Ñ|Í ô Ž¢ÿR+^ VŠ3qÁ3}ôb¶”óQâkÿBö7™ÊÿKc³*ü´c…6¦pÚ¹•´©Aé  €ŽÒùгzqO'èê‡ñt¹ê?±Žc‡-9ÅEA¡0<æÕè…¥uF‰V v\ B1ýü´ÔÜcÇ#Ó†„¡š.ù¨bŽõÎàÙ͉…Y§`'ö†×ÊËð¢ GTÉ\Lj>Üyí0a§aŒléÙÕÖ žEú­ ¤îôb!Äئ½›7˜á&fÊ=œ)$h«)å=½+ãìÅ4xÒQ@{jñÝtö]=rgË<Àÿâ8H,%€!¢<E‰(Óofƒ®Š3më’'$oé‰b¯»!™`ôÊ{kîzÖj)ìý—,…ghÌM`èáåmíiß.õŸƒ&¢¨x£ˆ·{ÚïŸÙjp¶ FÐ>ßuâžäGFÅ-‡‡kW÷óÇÞl’=cÆk%;<MYI“w\\÷Ú­J˜¦ÐôEÛYœ9(YXœú{Ç+óÛo(ç;ïqT’|åÚËÐ9Êt¢®òÓÝñ4Ýȼ=E¹/+£t[, f` þ·¬É#+´¿áùÁUJW_­ÅlîGx uÃ+ëRÄ‚£ìãÙ}ÙV—qºnÿª‰×<Ðßp¼ág@7 nÐ÷ˆ4åÈSV³ZMwš²²}g²«m¶D²˜3¡´‹FS}èù÷‡ñ¹ïNœ#c¿[ówë}ït?Á‡Â%X§™mM¯îbÕA±ð€H$+4¾À¾×¾O,KÓÂk:wuäŸ7lÏì{vŸU£âìeÖxÌ<Œ‚ó8rû«ï“Ah¹—£%±ßª õ=v´‰òúÝÃq×g ðƒWA˃û¯Ê‚Åevƒ?ÞüI‚øÜú¦”4kÀuÅa`—î@µÙÊf(iÕú]‡z<[Üx칚jep§ò ¡kLEUµ›}Ízƒ8•Ü›bàñö”Eµ²p lÿ,(;å¾ rÏÖŸ·[oädÿ=†OŒ@=K/K_}Bfeܶš™`\×Þ Òwýj¥¿Ýíä9A¾Üšˆ0ÜzòÒ=Æš‚ÿ‡Ã?Z©Gª0H§³—{Çq•’ª¾ûY-üçÒYùIg;ª¼UÁêé‹Î ¸x$6r7=Ý×îp´I»¡+ÓꆅÜϨDg7ÓaÄ`k{}©¤HçQ>ØtÚu“45o±úê+›‡†ãɧNÕ[_R‹ùçå°¼Š™G£EËäÄp6XȬøÔñ&›Ç¾¹3Ñc3“*½¦d–¨%CieCX/±9€ýÙVæ üWów(“f̺›Nê²;×·»?ùç4Í¢ £Dï}çiÒ#«7wYmt³ï–ɉ÷ž)ÒÇë‰NÍÔÚ¥ª&‰‰›`e+ÃÖ¿þ—B'ñÄ8Rd“Ëœ‰ÕÛŠY–°ã`¦R/ ÞÊFYæÃÿ0 «“ éZOß¾èe¸Qbm9tüïù½ ÙŽ§ÿòÖ4ãMZäåp6q{°ÚÐñxlY?û®ëùú¿Òë×’ß@Täð´ž¼Ùkø|°™§êJÓõ/™lª'$†œ²[ØK´•˜:QEÐaØSOØw5ËÐÙqy€ÏÁSKßã!>úŸ$Š3¿sZQºN«ePÆ$Ú”?²"ál&ò8¬[ ü,ìe]ZSIÈ@)H4]ÍÊàdC•/­C‹@ý/l{°é|õ¢Šÿe?9>í»©Ö €r-Ÿ­K÷ƒÓÓ fHû6ÓÿÚzô§Ý©ÝNÝUûiÏÛQ¯ ãs�­+ Ð:8$g€ß¦ãKóL§¦¯í]Ñ™ÓÐcÖìýþO™øVåè~€Ì>Ôtí ÷är�‘š 2{ñÈ.3Ê=g—ìCÕ“É/±¢1ohXå (fúï\Â)ÿ‚ˆc1ÕÑèƒSŒ™ƒ˜zìWj9áÆò2œ“Ž†YËC¤'ËyÆÃGgLbLsp ÜL=iÅ”™Í5%¯ËÖK^§==ØzzëNs°¹§ýµ½nºÃty"´2|ãS}:ÒûŽƒgûHõöPãÖ¾Eìþ¨o¸#O{³¯Å¨^°ÐÊz¤»Éˆ ,ü–6üðä²íò,¸Paåz9ŸÊ8þ­éÓ j(DùçÝéqå·íböéžéÑçÛÚyò¾øMMh=ñhck ¢èg6a”EêÝ´„Ž'Jœ;}¦¸iBàÄ‚7A×Nñ¾FÏ«“JÓCØ|÷�μI&H¸2O¡>Ê,ƒ¨< stQ\‚óü‰Yî0È'_ÿä ‚C#ývimfŸú¤.ââÖÎ\!ÇôÍfݘAwå#úMuG<ý‘0_a{C æÕN#•G¿x|Ÿd—Û_>‡ f+÷ØJ·¼ÃO÷EËc¹G-U—ɘÊùÁóÎ}XwÚÆý£ìU:µts0*Ì€Øè‘Ð;Q⺘§ýŠ�lh4¡"õÍ;~¤HæϦV‡}5`a¤^ÐG]fàÿžàò¢¨r2S ÕœŽ”éåÍ¢¬H±WˆÙe´œ„?Np;u­hÍðТî‚n}r#ß 1•ìïÚˆ±Zƒ>÷/¦;=÷‡ÎW 5íäÇ—^ØÖØ‚<:=¬½º²¦¿·Ô˜*|x%Ú=üÔéæ=³8u]½ØÔTtìQv<©µ]’8€hÅÉ¢’cíöõî™çÞ‘q¸:7(å­çFF}Dæ´†þ°L7Èý�šŸÄh‘#G³‡#UïBИZ ¾"|¹Á,J×}cŽÂåONïÿî5àíuÜ.§þCÄ"øÙOßÀañ è]²åH±w­Û”UôÞ”†e1‡/{Œ$±'R—#CØð1v+ÝGÓ£ €ÔZÁ\soU"B1ÅàƒCÕ]´è7—‚$‰²"s଄No€Z¦Ñ’xNƒW4Æ=ïy†`-ó�T_o(gšÒ²àÃfŒòÞUˆ•ØßS{¨7Vä¿V(ÁÒ»>£ðÒï<ã6uu· ØfAYRê¹H’ðDH)Ë“ÚßPÒsÒlÚ&¦ýpÛD�¾Û,Rwv�0aÎŽîËëf2ð{»f9ÿêøˆ|G >žæ”Ò…½ú.ž‡Ãò Š9\™ÄŒ€¶­4F¼úò~ 9vÎÀ9–\Ä ò®úêLP¡ó¦ÿXþ&q<Ny¸›©¤{¤Ï6aÍ[sP]qDþ‘mâݬš'¬©1µIÝøû*;ßþ󖛶>ŒO=Ö·¶ÆhÿdÞV<r¤Â#bèM¥èiŒº´X®´sßèm„:”½M"~Лïhõé`|O'/wE!žò;4yC�á0/iÛá8¥¼l¥h:ÑÑñk î(Œì!(t˜Ã¥A6ì ¤Š¥;›ƒõ³¦D ðnñ/龍ÅÊ1›žü<c~SÛ¶_ªMl%ë9ø;A¨ø ·°øD4¹*f‘yÙ:4*ÉeÙ‘úºò¨Mv Ú9¢\DõÒ_[/až$ÄE|þ¹'­ÓÙüHw÷ò9öFåD: ÂiPO5Ì.ú]79šv²vîö)8Œ<¦=䡯Žþéa¿NÅ;B#”Äÿµ¯|ÿP?rZ’™á"tô–ûÖ¶cÜܪÜ,|LСJàŽ qå=îЗ¶¢NÝóá¹õ4³yF úú²ÙwU¥Ç¡uíÎZR¢V¢6è÷¿o¬6p¤ÂÎhͤ(Ïš<Nâ2v´Å Íœs“2>͉íë+åóIç_<•öË’l­ 7ùtZ¼V»µvµIžÛÈÿì*Ÿ–žzʤoa€ÓæþŠë“ÿ¶_d¥ŸQ>+‚x² ìæg}÷Ñ5‡É¯”¸µ«ËW|i¸’o‹ ¬÷ºº-­…úÒv=²ÜÌ–ÎØ·ùã0Ñ¢´²›v8º†ë•ºk땆,8tyBhã©´sâ1ÖPJ‚ϱ3¦àGr¦56i•ãÿˆ8_ø@HHã2jðô|v›žølºÄ¯‘;ª•$ü#>>eòPÀQa2³m›*Ü°ˆiË–T `°×·ªn>û oÖ¢PæêÒøq~ª±1ÅømÛÇwÇÁôµÂœ ½‡É`µà®E i(ÿö‡ ׸yëÖÖC¶<Y Rî9íàdÚ¾›ÀKáõí@ùn ¶õÕÓÔ³€s!À஥ûÆÝnwŒ¡›žùÅ'Z¢’,(ºÖë`ùS÷hUGt1J­¾póíH?©ÖTã0.Iî{¾[‡NÊÊP1%¹! g¥ ÏšA¸˜o%vQmjTa(Ï;ɯ ìXu(!¥|HU2ä¢ð;ß ÂQáÏ=éØí¾¨ÎˆÚ¿^¦…ûe�ž(dÚ`/ŒPÙʒǘ}Xi”‚> dË­zæp„¾-ÛŽ9‘¥˜O“ñøé×V+@ÓéOuj)ŸU5%ØYÕ°BÆâ/‚|’2ôýœè¸&ô)‡³·˜¸†Î ð»g`Ü¿à–‘¾œ‚åÜÂ*rï‘ä®`L,Tص‰»#CgfógþQ’$wCC<"¸ÝÑ+êÁc ¢ ¡Ê«öŒ&^p½Kœª`$¹6Õ˜ 3™Ë˜¦úÿlo¶rNŠùÛ¬–Z±f<ö¾vÉÄÓ/‘f7íãÍ¥ô™Tãb);Ù¢˜—]Àù ¤°ý97 À eq2H:ÅG˜•ë ñá·|ø8ÉÝ6y¿áa¦­²ˆb¼G(mÑj˜bi¿ºp“ª-“n¨‚x¼:ù ‹‚4·s¨ÿvÌ2XZn+) Ñ€¿íÜ-Z‘.éÓ52ct  Ój_Ðrb!TFÌ™—û"Â…—·ä<$¤r>k5źž`'y² j駕¼Ãqp9J[s¹Ð†qcÖ]¤pÛ׳ÅwbO½Ô|Ëç‘* =û\9²ST–r“E‡jŽQ0K:2rÇíyfƒ¼îk|>^÷(s<Ì�¿U8‰×ÓOÄxø¬É[Êþ¿ücSäkóL×(L”òÝ’½" )«‘ñ.p ²ð°òRƒcâ]£|6½|yÿÕ@ÿDN–'lÆ8Ìž†è+³2çkÈG.£2¬‚öJÛhQš@/<ãÒ$q:ÈfÐ.w½ ²rE;Hƒ#}êèR›ùÄLéº!~Ï$QQ¬ xsñÉþo’Y~nʼ@FmBd>:£ÚáßXi¾ºÆ»Z+,”•äpʾ¯ém­§q”ÐWi(XË ªSkŠ¾JœÎ‡¹?ŒOK¹(õL¬E@¶Î‚¨ùôbzÏ™4ýWšEü(½¿Váã•mÁ’Mš7P *›À›¯còCòU^Þ˜%÷gZG¥O·gøÆXL°CY±î×»âî/Qî>½pC˜,àÝ -m8ØôHy”²nŒy ·ÌÇ0ñ°ŽLÝn`\d­˜Stúp¾ˆ¬ÃüZù2ŸªLA°i¦”Ó¢‘tãÙZc¿ª_•Ý8¨íÏ·xÌ;— :p~úÃô¬Å%çíkÞ\0¹È<õƒÛj<êņ½½ºgùKŠNߧlzÅ°ÃÚ™×*ÐOL3#O¬RÚÂ¥àœóÏÞsÇpœKb9'i‘0ù¸s: o™ÌlöiDÖ–[a\½x3à ùYÚÅ!XÅN1 úDœ¬K)ݼé¬e¼‹_Ãé""@«@–dþ™.p¼ÿëå÷”Ï€ƒ1>=wf~üØÖѱñ†ã©:ƒ™ T©VjÐŽõq¬®è=úïŠ © p”¶SSTAi°<ÿ<ü­QÏ(Äjv<ûêÅ71KJø±AïH«×E602¿ï¤ìÔ¨ž3¸ÉŽ•nÙ�=,* Þ¥ðŸî•W™? ‚UqEÿî1“è‹ÌW%耢{¾B6Ð3¸ ðö¬_Ìæ´˜­ø#ì&Ö‘0>èñ#éYå·Y`J!kÝñZ¼yœy¶ã°K()ZØñlžxAB`ÙÔ)§Ñ¾Rú>wK__î*æé­bËŒÜ5&—Ês8{*Hø¬øÈ<¥HK…ÄŠ9¤¹:5ñ]^—/ eæOSbôÓ[ïZOW—2€ Û\WJÍÝ+º+Q¶²¬53£©*×’ÎÂ]~i1“xjk²¡6Ç<HvïÎ ‘²¾Nrûm|Ùôg§ ܉øóñŠ7æÒØ-Eu äD˜Š„a¹NN g¢¨ û³[•È*Oä†ÿ<³ÙB­%s;1Æ¿ç©3ÖN9?UvãÞÒ€+ö©TRÀLÑFºú†½×‡ª6ѺJä èñ²x+kêvxî¿1L3†U+ö¼«Í˜ÔÉz¸i¾6(šŠ’Ö¦÷yÀõ =¢ï…Çd…,óe#1oŸcÌœnŸd`ÎNˆß “½óØMÿ9Ö–¬h¼7?¢82*u¢½ÁNuà*M Õ‹‘– L¾7’ØÏîdÍg?åÂEûîi;ÑãëøØ–1>&ø\ûÌTC4ÀU4Û_~{óqþ I‡Át¤ÏéÔ»«boaºå€}ae½Ÿý& §ûÌ,?P (îôó£÷á†Wl¥íϼ»¿<óö©P/ó¢ÒÂ!DöCµ·S:œ4|lÉ;ÜPvÍ«ÆbKLÉÊB)f:éQ¤Âžû Rß Ã#ÄãV¦òa’‚¶F—UlK<FíášTÿAüÖsp¿ÓßÜ®1[Ñ1d Î!% [®ˆöWוP[ Œ10ßwÝ$þI¾¾jT®4Ë¡½KG}ú®˜93õ'ˆˆ2 IÖ™4X=U_YÕòÊííFÌÚ±Gê©"Äjw|ïêžrTæR Žm>Ûê3±ƒ„¾AOýGÛ•.�à„%ý ¥×`üu<}\ÙyÕR ^í)»Î„P•Å>ämmz@YaÊ@hÑö°üט ô…|DǤ|j=§On«9é4úÞŒ©µé1uÔùlëÃ<Ûþ¯™GE)´ÙvÝýò¾Gè\eãÊ #jÂRS }|iÁJÈœýÞ´&öŠ6îºL;Š3Eý©H‰\zžÐ%î|ÂêëO–ÙEä%Í9³Gt’53rê|D^o„º¨ÝÓ)ö÷U eQ«q�!T”ˆ©=·Œ/æÇ̬A+÷°(¬¼Ú…+dt[²iô%üºÝ) NV\ß({8Ì^óÅ Ëž5$=ô© †¤û9ëì³j¶aŸÏ2ŸþŸûŸê “F¬ÐâÑëÃëLLPb¿6ÝË‹•Ëe̘½¿k&¯]£Ï¥#åÞ6>ä÷žs úa³S̺Ìø!%h�<{ÆX*jÙ¬óG}üÏaøÏö,A_8³þoœ_鱜XgqØeTÈ_uÃA‘å¦Ô½^IÄV—^Û;Ïå5!âÐLMÛ!¥5ÐyÖõJjÖŸ¡©{Jºhã˜&»ú~³ŠÂŸ uå Î ÉSÔ;L€ ³X™ÅÚO¹ë˜¿xObßÉ…K¶½¦AzÕ"6 ÑŸà€Ž 2gÝ;W¬AìE ?ÑRšþ>;É’yœÎ€nDîKpÊ 8ÞÔ}k<¿àl~[·“a—Їœ›ßÞ$qû®g.{ôFfå÷Úù¯ »AË¿¶‰OHÏL`þ¦íÿÃI‹ÌŸÑràsý²w®Ý¬ã^Êå‰áñ¯p¶#A¡;?æQëëAlYrBt¾A»‡Î¤ûg1ÜÐÒ´Èœ°,@N±HrÁ©¾åÀª“‹ÌVúoLØØqAÅwõCMê-ºÛ+üØ̨ïï'´z#–{#¾ÿXŠ?Ï3o° *ç)ØÈúÂlj'™Ðw2mÞwÿ¡Úï³£ÿ HÞ+üdQº˜¹x B\5ë[£`µCh›F³ àw߬8»_mŽ´ÒñËzý„ÆFÜ(6 @Á² y±ÃÜ8ôµtèHo€wl¯¬YÇ /©ÒâEÌÁ—´®V–njÎj§/Jò“¯OGy«ç±³-¶dhQ‹ ñ2d‰,PjqžóXÛ$¯"WЯÆó±/j;=¸ã/îša$¶‡ôàsË€¡'uè·àÙÏ!ýEEò³ƒ †ýÓhÐÁõ /×î¦á†'Ïh'ª°yœ8ubpŒÅA–�rÃcÍë%é^f'µµ‚B›ÊíÒq*¦Ïð·(ãï6´î/ÆžyÊ·lÌ»_΋ûzVé÷‹u°I¢0±gS„3œ}X›Æãs3TïX»:ôãÕÌé0àyDÒ‹$(vº,EüÊÌPØkÜXbC€Áx0 á‚r+l"U+òŽ6AØ[ O&¸†+j AâÞ\ß;Äž %Ë"î)ȺÁCÊ2 ×ÎÈÀT=ŒB ™N 2¼#¾_ù%s wjtfE6l)à< ³z¯å0–©9Mßc²2jǽ�.õíJÉ+dÕ).\7u÷Ä¿ÊŠ²žFˆ[Tf^£{`Œ5¬ÂL¬“©Xet_LÙ˜‚ovÖ.t’ªô{Ì2& ð€¥¢åi»‰Á“¹A”E¾jœD›0(Ï_²DOMeŽh¦be¿F;¶ô¾HÉQ›-˜ þ9`ú¦ÎÀæ•]B·ã�a£'ªþq•ùm.* i†Ò@7XPúawÚ‘ª�AÌú{ŽqŽìØ<3)|÷UÙxv%#ÒŒ8M÷õ`¼i¸)¾T`¬Ô'8†z½Õˆ—4ÿîàîÏ }©µH¤ô耋Z{nˆÉ2(tA&Ê»¡,~3)p—4ö“rå#Hʾ­ŒyE´ê!s¾Pµ¹›u"qêÛÖùÇa¢Ä »ÇØÊc¤$»Ê¿1·¦!I`Õ)LöF¶’ž7?JýwKcMW˜Fˆ˜íÀ<SlÂacÅ¿dšâFoöõ°Ì$B_ìíkD¶È<Ü5pMqv¯رërƒ FÞ‹ìÝÀØO¤‚m­ˆÉ¾þ¤gêžTÙJ„‘•BÓ«r€<¡O y³ÐEiû»6h’dž%,èØfﺷu¿9­ô»Âñ\ŒÖO~n—ÙãGŽÏ"Ø4´8ûA‘—„Dh“OÅŒµ'²]}ÍÂA ³·†*¨¬äJe† ÷Yk-˜£¸p±%gƒ?yo'G g¸›}”/Šiù(²¬PÀ¥#-Úk†”"{¤³²÷€8ËåĘüù…‘yìu…j2ÓÍzcÐ:œÅfo™xѾ1¶®c>äüVüï[ÉQ¼ ˜RÄíKé1¾â¡ýO»;·ô3”¥æÑ•˜˜µ96ú­žÕ]o%2×Jz¡?pPµ¸ÝôJàæÖDLÖ'fY qûG2‹›5‰Œ*RHúô‹Ž»ö0¯·Ťî Ñag,Á‚å¬u‘„½ýÙöØ“•ÐD)ÀÛt´}!°˜F¤^˯}¨’p}ǘûÄï¾ú=¶›¡h%ˆš+õêöå+B6M)';ûÓÈI£å:?â«ÀE÷UšO¦³PiË¥pMƒ¯æ_×½Á$‡‡~R´!gcùî› …‡z¸ãšæŽ±ÌŒÚž’ž¢Ó£RŽIÄ¡™a“=ŽÕIŠ‡>\»Ã¿v[ö—s]·Ua"5dÂq*‚dTT;\ëÚ©•q@È„Ç–æu•F¾ã6ó zÌ«ª¹÷è'`¨æûn¤ÿuD5©vW b2ð$ó›Ü§O" ‹–‰è«÷V:|ì±,Á¯­Íf³j­áß2+:>èj Ǹ P ;-Bé#\fK—Õʃ< fZ‰É¹÷œfº#à8H¦É$ARK*M]Dû‘éíuY ü3÷‘ärá½”ž¢¦îBß/îP÷”ªqâfŸéôî1 œ%Ô=9 C½ŸY1‰>®pø?U™O1¦Ø¬hV6?X:Þ;^=VLâ‰õÕwÉü4õy 0dÚUA¼X]ÛŠ›¹ÜTRÓ‰ÆÌ?ô½ÓÂ}˜…àçÈWµK` úÅ¢€fìñ`ðiE¹ï.öœ¥óÙ€äƒ P•[Q,^¿|Ç&…¦ÛgÀ“ »'ÛkóPÔäóùG×àˆQ°¾¨É®§ZjüëÉ,Ó9ÞB¥Mèû¬ó·Š;J•zß^KÚ»Z_'Ê‹U Î0†m)c§¹ÿ+Ûáû/¶×¾½ñžI³Ð7Ñ>†×î°3 ‡}Û³ìˆù£tL™ñ°±ÎîŽ|ôÌ8ÆN5Erw¥p²¶e±d7ì3Žb·ü3ÁÈØ3JCØTaeP]ÞÕΆ»,(CÕºáhHŠ€Xý®‹¢Èg㡉0”t~û”Ö¦îÒM×·8j´×nàÎÔnÙ‹‰Ž^¬ÚÞq”:£a£û5©8x›`Úwt³î§êeµ~ÉÑAi_EANZ³«ð©ø”ºw¥;Áú"‰…{Á¡r­ÇB™ÛÖÍZ¢Þ&XºË‡4&ïl„¸Z18)LnÏZìÃrM ÏL:8ð^÷/ÍJô�B2ê™ %–pß4ð´3gP«À«Öã°0²ú=E®¸Ö”‡ØÈšì9¸ï®|¨b¬uÖÝïFE.—=A¼SFïÝ}yC oû#1¦:!·98ûŸzW«Q…¯j:¢ µŠ‹Ä»¾aŸ0nGtºÜgA3´£OŸù¦š„~“9qO!÷ýìy‰i–n `ÿšóYE~7*D“½ ʽW¬èÎ4væR7ìNÆŒìŽýTÝ2ÑwgÚ%ñ²sJœl2± SJÍcoðÊä$u 6Ïqö0ªƒÿŸñЦ–4=Vê /J)$+øY²"(Ú½—ÇØôSn:®$öYz†>3’p‚ÎêÚOc hiÈ?{¨äÌì‚Û£ž˜ì…kiü¶™Ð]¹S£¯O|ÕBOâL*Ì ý•ÄJÈÀ0Ë6rOf9ïõõe/ñ°Î<á:úG1\MˆV# ¨JÒ�ñÌŨNõÑj*átVÓÁo‚¾ï«èýUʵ§æ»=}7ššº¶eûŽïß’ÆL“øL%+&:8߯6É`½ìØè®ÊC=_HŸ½}A(8ÑßL­wÌ~Ümk{]?­2wµ«µÎ(Y®|äóÝÿè:•W ¨FÅ.7:.÷mcß\'Ì0¯¤”Ëb`8…´Y!~—•é Võc½ƒ(Y©åÓÖ'Š±‹îK¤Ë˹uØ[È»r†[¯[‡õܶь­gk4H—üÖCäUO‘*wÚB™ñá^ןŽD¤yÕõÑQŽr3…1ÕÛƳ}gTm~Êô^‡ø¼×Á8¢*μ.š}´¬óñËDYªHëžùo–ö8ÿï[• BºÔ"å®Îj¯qײpEMƒÃ*kgš‰›·/qpûNóBûÓ´íï`y"™¸>Ó¯Ý ½­Çý u©˜ËQµfFmõ»î*\°dåæÁ^!œ°âCd\KæuòÃé¹rD¿Ñv†}§ ¥–¥ñxý²¥w~Wör~¦È¿Q-äÀ¥þ0 ïê[òouƒX® P_ZEép1}W:Á5Âj¥jrÂ¥yòÊìû¬eâr<±˜†g{h@éØ—Re�?ÄRã\öd–Vä+õ´ÅWNÙþìaƒ›2êè»Ýa\ìÂñKä= 12/'(ÉÐf«‚¬±F‰Íòª²zè© .2@Ù8t§eþ¹<ªt ¥åQdóèÔ¾7§Ë¨j|÷m(ÆŽú-gm„¡i®š Á0ÒÀ†"ð3U ={šHVèÞÚt`}R6}6ÔûÿBšÄi0JžZâÔ¢@ê$cÉ~€XcWwu_í wu4P‚&…³×_ÏÖÈ`ùD�î×û:’ c£[Ñ”Öñ±AÚi+‘ÒXÓ‰Ñì×üT’ušI÷©û¢Ü»hþz NYX˜ïõÒ¹/D%+}(”ÓûÄCãõVÿ@Ú$"éYá[@¶ašW×7Ù¶3«õÀBvúë8ƒü(‚ó:^B–ÍŸ§uj0BÌpÒœ½ÖQM=ÅÖÁÕ~ªÇYpïªÈü²ö[”G¾šjlTæÂëÕM“¤[ïT”ÿYh®òÄ÷Ð¥�XHc;– 9J¾-†�ç¶I‘3 \ÔMkÓd…á„HÞ…Še ·Rˉ€ÊÙÃÆÿ$ÄdM•2M%”£Òíjþhf:¤BÆ !:wq‡€K ç²ÎæË)Æa’B%!ý×5X0䶺¦ƒEéƒëã,õAÀõ�…õµ×;èú¹¶ÆÚÂIiº¯û>çîÁøÁ`ž)Ý´h„TŽm…çý©Ãj’ίÑey–…Ž!¬b[i¯=PØþm§Ã_?«²ïß1ÅžL#»æ&WÏ ™¶-Å(˜²Ú~åM¥¯¯ X2ß´‰µsf”ž±Åɨ“`„.­ Í/ £Zq3aSö¿@U6l'E˜…Ò¢¸š“dA(ëOggF)sÊèŽvE”ù¬Kz¿ËÔv² 'ELC21æàÿ,€…¶—‰:ß±O\b…Úë‡ä@®K)2×ß/žKaWNË 5H!ܬV’{{êGˆÖˆ8œ$Ž!4u½ÄÏ]\K¸bPv…bº½F£±¦­Ñ÷þp;Šª?VÿY³¸È2oD¨ª \¬ÈBrëf°Pü¦¤ Q…jà œ=xc^´<È‹lÝ3îk¶–ÒÖëR_ꀻë\õŸñl=‹û;X¯’1>RðÀ*'MQ2é“Úh_÷êÙõuuï'¿9Ÿ™£(Øè³±"7hçP8r"ùÿ“bÏ_–a‡�z\js $ÜȘ¦ƒj?Ý+,–H%’ÌCR­·ë)•}oþ�Wôü0ù-œІÎãökÔuŸ¶Õ£ÊÙkK2Ô}Aó£íUøöí?o¦mj†…8ö%]1Ú—jÕjˆä®‡Ìàl v’w¥gcë¢ÉÍsýzéælö¯w<š[‰}º;WA8,¾èÿÓE¸ó"{h_!®)ærÚµ³�ø°2ò5óc|ë³€»Sg5 ŠÍ‰þö ”¿}£È•g¤£+D¦÷0Ã<º¶-zÂfÓ£ƒLŸÑ¾.¸¦è7¼,£I%9l�õT3Ú{ך[¡µø£&jZzºð™”µEDÛübNuÜbúLï8"´óµù@)§¼Ö_ÙgùóºB$XéþLW'Ã<77þm•’%+­«Ðtä~î,Ö8EwµÅ#ÂMô›œ£C0Á(ò ´¶‹Q‰3:–lTÑçÁëŠ{åT!€Ÿà¼1|yr3´n·´*.à$D];ôúÝG,ô”Osc^ºŸb&3É›Oó,$_#k]8°íŒ°ËËÖö¾ç*“íPkJN{ýJ`1ï¡<ZÃp5*îÏØ:I•ùæÒ‘¡ÑNz¿JŽ´$á¢ÐRi_âÔf„«ÄÊY>+nÈ B[‹rñiu\'ìîP\\Xáï»ÍqéÕˆ¢©óª‘ÑggöÔƒf³gºè+Ï(ý¸AÆE¶–ššŽtÖ9‰%(Æ\&¾ÿ^i‰à²'?HBJöWÄF$6HbaB›ûÕ)UºÒ‰IXŠÊ´Þ·)üèXÎK‘f˜<Kœ_ïq“ʪë¡X°FHd…*“ƒg†a ê‰g™üøLQ¶~a(zfÁG,ñÛ L­>-óV€)5°E¶ÓNDÊe²¡Òø$Ý#B§iè3Æ €A+[�$ö…ôœÊ™»R·ÌèxA�ÉÒ±x”D÷¢i#w^)8÷Ý àM@ú7’õõa=iQåÖþê}žQÌ 6íH=wÎ,Ùž¨oÜ×R•TQ½0fJ {ðo<•çˆÉé» ;îÌ^úAå³)‚ÝiQ‹gBçB8XwH²I|+¨:¥A>j÷4B3J!«%üëY”y¼uó¾Àð¥¾x3øíazã¼1¡  ‚åÏÕüa¼AÑ…˜É›ã쌉µX¥Ç*Š¦ý™çNÞ?AJμ¬Œöïá~qä [`ê:Z¦ót2ÿÄ8Ar{^¥¹'®Ì‰Ór)‚ôóâm^k¬«(H©Ž÷'Jú{°/%bF‰©À7*bÞ-zc=züj]�'èKçÖƒù×?V¯%ĉÁ‚6p€¤ÀÔ=Bþ5´È3¯iŸ¨=óûÅ+îZ¶V°ì©;³ßhRÈ}]Y³÷”N ]00 Er×îÄ‘À¼>Ö©õHf°/íå:D*¹Å„Ù®z®IÓ¶ï\+ôÁoþÓwÿ1¿±Ñ¸,-­{þàO͵›†±û’¾Ót…i'¥Ë5;„@d¡æm©ûæ´Üù>]i¤³b. ê¬ÞªG*Cès Šd]<ßÔа¤Ë\’ . …ØK:2ñüd†kþà“œ­Z?0d˜(âåWMUÊŒ“ö#íšî¾î˜úÚÏ?깤•KU2ééýœ½¦…˜i¨Ø ÚÌÃþÔýR?#uЃ”UøK¸ñ5ƒ/³ƒ¿òñãÂÃK±ã \F¼ŸÝÀ‘S·aˆk±WÝ¡â"®ü¼ˆ’¸ ìGí_@ìÁ°e ­éGñOûnì’ù*Êô0AŽŒ>·&5ä¦È_±Œüíä,¶æh™ÙõBnn4ÓñeìÏ+äŸOl~‰ãœéÀ=3Óü]ÏEïU'î8µox¥ OäÈÕ ýWF§¡“áéC`lb™<ÂöÂ3(éèQõ ŠÓó½(ìü–Çe…oˆˆ{J3ºc£gÿnݳ…-Öºéjâ_ÕB¿~÷k—X\£á‚°XŠ6Â9ýï›Ë'ÆØ_ä§^hÇëñ/|ñÎÌt{¦ì<dßQÝS<•jÀmdäÉj­?~?—ÊÈG#€w{¦ónP Œüö+LØÀ™ÂIÅ·|B³ §a!n”@nË„2xÛía]ü©õ4ÁhÓºGçùúàA¸¨è˜Wê:ƒ°¯i¬xWè†B"ºoàg~umÆ‹'æÚ™|üt…FHèÉeAb1-ì®6Žt?=ã¸ß<[vè°­$¢»£~4 Eò‰1ÚÇ£¥Üv+AžgÊ<Õ-¬™hÕÛ, ѨGYÙód ò°<Rž>ê8z>ÝtkÃãõ`Áw/ÝuÍdý´ ç<H,õÕÒ^(¢iÂø¤×èé ›Ù!»ë&Aò®ÙÜv=ŽM²;[ù#>®‘� »ÓŽòsï éÇŽR·“+ o~4¿Ú4óF–ЋÆ*ýôI÷ßK¯J§Daº “™ˆOgoz†rÕŸ‡þ$h¼Ò6N3;}0Šõ]BstiÞ‚pêàCÚý òêë½Ú™Ld¨ Ã®²Ñ0(ñ˜æ¬óF/Ñ:¸ZŽï¿iEY’QeÔk©N­‚p¯;pÑû%$’=È1"°;®ö®¾—ªQé¥TÜf‚ÍxƸ N7K¤…gúVÚ@ ¸·¼iwâ'ñ«ô+Ž2±ñ ç|v„L„Œ´l€~,›EŽÍB,Gx}ÆìÈVb&ÞN>{–þ%yèk˜Q\>é»Ê4dwVdÓ¨§ÿHœŸUxiâÜ}¬»ÁͱVm¼8w…øÌtƒ‹ ©UÕ-HJÿDª÷íù—q\x7ƒÀºŠêÔÞºT:)Äü¡~sæ^ë?±¯7ýX\å™/Ž—°¦BÜ+™=7dÌi>½UVx¬°P®µT $;ŒiNµG¬¢3•²Htnä]ãÌðöÕ‰¦Ç¾¯=£6§Šê_KFw³ùʬ“˜¨{Á²~G;:¸À´ñ’Fµ`|Ê|„vöÛ›Ó¥e¨ÉÓc«=UÐK‡Áâ¿1ì(_L­Žh£Ðf5ѧ^½p<W˜;ßwy•š‚›C#”eF¢ó—Rž VS¢ µ=@UÚ¶$0ÿüIm0OVúÒwç,»§·F 'ò›çŸÓ�ÚŽ¥w>ôæü>‚S£±84Þ¢›mN5I?xU­o€Nv-Oh(éúݘ)Î\û¤Äš¤PK w?{íåЃZnÖÎx¾nÈ͉þ˜Ê­Y-©öÉG¤ƒòeÀÍ:m·Ýä‰ý¥¯#Aýe8|³}¤£æÄN>yà'­ƒ?–·ðê˜9rŽV"EÑvtöÝâ=]<Õ?¨Ô¬�ó2 Ä¥ny˜µt?ˆ EѪ˜¢U:ç9­TmjW…ü³ÙÌâq"’îêΗÈsW6GbteÄ‹9Œ@ÚĤjé|mˆœ¸BèÚ7Šç7®§Ó…j@¼°·q×X ¯ÝéxߣTûþåIæt…qžä´=)É.?Tyø8]Aðø•?`áksD¹럌пÉ297[ÀÌŽß'ñÖ#4—̺ì(0  s1îRÐñþmAåžþíWMnÞPÅÄ@AéŠãÀbÐk“ÜÈz+Æ\PÞ ¯ð¾ÕÃ܈wŸu#®l€Ag¡ݾÞPƒVêJ7 NÝ¿fbÁvÃG* Uxo—©æ!-‹Â¾ãüA…çJnϘŧ½ï'vKÏap�†(ô’W|\zRIâ¥yL‚b[* :Å€å2>Kñõ¯LWóiZ÷—?ðž,¿_Œ¼bðWh¯B›F•«°ÚD²ÕmUvxA¦ÚõW4‡ÞÚîOd&â8õ'ÿ[Ü£7¬ë%R‰¬ç7QN ^)Û|ã£Ã4=ßúÊÁ·gŸæÌxJ6×~mšîv çR,I™™M{ÊÒ –Ž¶ýúÔÈ»(w‡×-@\±¥^E(À³¬¼Û¢ý3†¹r…w4EŸƒVȹ‘ ãÚ„X´LWÐ:ÃJµ Ádx÷—ߟÁ}å¸|îü]WÙtÐCºSÝ7§œÃz F1þö´G³î°Üí°Ü·Íyú{«ÈïMÞ‘ ¢¿é<ìƒ8YúÜLøæH¦«‡ö¸�$/î ŠW°¤Þ~{bS“7;ŒÕh݈äË ¨¾e0¨Š`Áôz[_:¯žxÉhRw[˜”�¥qiÏ_ÞŸK­÷“íÀŒÝ�Ø»}ý]RY ‡Ì˜žð¯&K$4’#ýÁ²¡^ÙÞQÝpÀQJövH‰%›gȸízRêä, áàHåÖd{=Lˆ¡µõÖõÌ‚€ìŽAyù^Á$±Û~‚O\Æù¯s¼¢°¥è¸±Ä…Õ†ö5x†-E+S'îÏeNƒ7#¦7‹Ø¯¨[@”쿲L‹¬gšH¼$Á´/‚|åÔl¼·Öf�,ðýwWwèÜ‘,)L‘:ÂMàX1-R'™¦^ýçÀywÅx]ú¦Z¥2 }È&Í‚rüòrCQ˜cëzÙÌ'–CE•Þ-Ë*¢à1K\ùÆÓ-œu¤œÆ-H&Ÿg£Ï±Ç¶›V¥û¥3­ão\a¢ôàî‰í`g‘™o Ô- *ÂÅRõBÓ.W¤RJDû%8/Îc§ !ï²1Zà Ý(ë‰'‚ ðku¿Ýwù‹+wø‹Éû–”KãÔ«ÜqFNþöy>H£ç_ L"_–‹ý"G:=*Õ Œ§¨=Z·çž+úçœ^ý‚r£ÝÑ»Zó|h˜Œzj‰Y�aǺZ7ƒ~pKuÜeØ—)’bÜHsÁÒ¢G Á¼I¦ºº=ö{ØÃØgôãÐ ö;Ü}È°"¢ï»«YéETY¬8í½«;‚µQ¸bfOw®¹³—‰tœl'òUD]ž:?¦s?b¶zQAºn•¤!æÒFYÙšw©X1TR«$˜§?!Fž¤�èþPò [µÄ‰Œµf#Ïz:°¸r=³ÓÖžQ\µ±ÆåJ2ñHW Âß)Âç£-ªØ¶ÎUPly£UC÷Ä*aš>¸`°-d‹8óˆôPÚ+=”ª©Qô-Ôæû<! ºžE:ïýî 33Rý# _ŽMÂÌmÂýÖcíºÊÃ}Ò"´3‡Ü˜ü43h‡VÍ&6÷ŸÖ·‡ÞÐMþÅr=rÄ Éo7ûÂÙVÞ´bYaØòMhÕ3‹ܱÃô=µB+õ›·[g|DóíŠ<oóŽìhÉÖï^Ü!ØŠ¾ ÒYSp°nù”å ØÞ=åý¬šAJÄ„ÍÈB‘߯X„‘ž3¥€VÒÿ¿²„·ZÑÒ…Š‚¾O1´ž|EŠÂ×ñben{ª)ëóÛvÛŸp8íîýjw¡­Û¶öÕÓy3¤¬ üI.Ö“3iXMO)>«¯•Wx“ÙjŸE¬æ”™™ñËPƒxÊ<f•§®')OK9Ey•yÈhtA‰Óʤ`x„ÿÀYpÅÀì8¿¬ÁYù³.ÑÑššf¯ANŸ € ÜÖ¾é§ @J3ôäsáWÄÞe0õ ý¥áŒ çFï ²:qo9ÀûöäâZʳ0_“ÖIWF!Ó@Û;½!VûRåMZR6èQüA%áÄÄ7ä…0çˆÌ¢~YyEø(¦²ö¸±ˆÂj•ó@šäð×QüámAŸ¨ÀqŒè„qn[4·8“{,Kmg?Â;¤¬zó‡Î¨ð²xTs6ð¡û:Q'¾§á]gÃ(ò°} 1™!vU¶ö†DâXðç.p¨‰é.j(_k/‚:PÉÒ¹“ïâÊJLzc%Àµ¹;w扯ðë› ‡Þ7É"ƒEö'®ª²4L™VÜ Ê …³&+9ŸáSbm äþ~n}çmÈc=ìN‹yŒÿv�¦I¸B0†P©ÞS´>¦ÞÒ5wÊ…AÇíd峂.º¶ê4Yy™0ô¢�Xz ö~jNËÉ!b—Ù§'ñQf¯|æŸÄ¯ÍR²âLœ= 8ëf€àïr˜z§()b 2r€™/Æ#“_oõÿÂpJõð+¶\XÎk¨šûnÍé´ìû˜Qv/ª-xðC‰mŠ™ñyï�côéÿX+cZÇÒ¶fþt¥ŒDÒ«úˆ§Íhá IZ×»¹þÒæÚÿ¾%1—¼Xeãq÷•7òläSBËÏ€Œ °(TS¢mÀÄ c Çh.ïò™¤qÜÔ±_„ü*-¨<¶Í§’= Ì”œˆÏýuz[®T½ö?üèaW#•)?"8-£×1ª‡¹í\ÿ(«¥(“hŸÑ–‹÷–ÉP¡8QÆÙ[4ü‹“Õà—î =‚†–lÙ¨B5D~v¥¬l‚Æï|åCþ*Ž®¯6²æ(.ª&…~²ƾ¦ël ©ÏXë¡™ºûP‰#âáñ`z"T¢?ðÑÈ|”È[²íÎLŠrÞ%0ÚbJóJªb…#öYÑ;¢B¬Õ®ãpúS›ØG7óóÜÍ=´”…ÂÂ*=Œ¿ú„ ¯&çii;`ÏÍ/¢t==«Èx©Y2€ï €oÎ è7èÜ`¤¶Ž'©ïÕÌûq¢¼Ö.“A@áF·®‡N�Š¿A·ÅE¶š”¤bpP·~wu­òº¯nuÁâ€ß2@RßRÉr">{žóÌ{ìID.Èp¨@ÉŠ 9,F‹¹Ò0WfG(…î#Ô2 ›w¦€.fc þ§ð ©š'ͽW®¿ëáêàB5Qûlè˜ï6û†µ« #äuûà,ö5 ?‰6kµ(8âض' haÖ*<²ô†î 7Äêå:<–Ñ.’•¦9ìW(øk"Î#‡i9-Rî2n9¡}Nf-¡YÁ ˆ=ûÜ ¨Œ‰ñ/ŒJrÏŸ«d,ãL©}Ô黂7À¹- ×¥³ÌGz³!.Õ £¯í¬k ¾4 )=Â@‰Û )ˆ¦l,ÝÁ{Aê€löleú;ý¨ðXuâYVSvОÝ(ƒÇQæ˜;žY|Г…n^!èQhïgJØHì=håBY¬ôÍügßÄHܧ$¦˜”mDÇýa8xu±êM¾ž¾änLj ÍRÓ?ŠE—ts»†vAÇn™@§ªŽÇ<þY¦8GDQVãDRwä=A] ÙÍ‚h°^?è‚Ð÷pÒ°œ[ \<BëÆY–V•ã”Á% ÒŒ;Þ|7ñCŸmC \ŒJ ý.ã-iá…3º•N;ðc¨)èQõ¬\•ÙšÛ?ì’ é|=’±VÍößØÅŠÜœÐ:EïAŠÌiQ/úWqͱåm©¡:Ä–Óqr¤LZ ”´óƽQZþµ”]ž9Ç8ö‘l;P,özƧ‚¯ó˜ÇßW¬óìœÓH °·="V'>óykLN(zöË›ßÛUæÏOá"Ñ•A2^<L (i›ÞÛÿðvWÅm%±Š¸Ö¬–Îx2à˜çÁ¯$¤VZx"=¡a¦sÑ$7‘ÒB`_CšDÙÚñNtû8(‡Ù(ÀX-{.3›3+8x´å5Δtêöê–˜y@D®²+3P¼lKÊÑ®jB²‚W=ù¦l*ÓÁosy6\¯<TÆÔÁ³ð¨µøÈšcÎG·¨…Ýò‹ü†Ñ¯ßÑZeáˆcôçË œv†‡Ï©þu ­…[ŒnÌË^ÀÍ 7ùÓ8³hü8-½’]"ñ¡¾Ôýp^ ¯[FaÂàv(­ÛÕ‹Ý‘Z%¥H¬­{Uý[µt-Ã$Øðábú)?¹OFÿ“å©W³°Ç´+‚t?šE£3e3 ²…E§(§϶ç¾ó‘¡ø<§¹¢eö¨ÂÔýõÉ·nØöÜýÐ O”8:ø7tJ*“9ò4c3Aa])ª’󦳔AËë1Ò•t6ïÑ7ÓÌM˜/K¥aÖz~G•Oq®rÆ¿©KÖ t7>@GÔ¢JF5bw³’oã°ÆqìüuXRLjmÕ*(a¥UšüïÎBkÜgÆ2€˜Ó×—ÐþÔƒNÏn@öÇؾcˆ—Ó�½µ.n;È€K”SgY>ufî=ð+�œé;*C€©•£ß¢'nôW+>Ú³wÇA„óL÷ ^?Û­=‹9ÛYê/Hß …%Æ’ÍV3¢æ._Tý‹³ÕÁÀB©Aòõî©íA5À¤"JOELÓÄ·õ‰Xí%¥4kçõ˜ûëÑÌNäæÛIçÓ‘gùší`šžèLIv=;‘œÏ;¶º6yŸsv3xµ:=™�üø¢“匭M.¾äç¯õÞÒØöX¼DÌ=’^](âh±ô§ë¾v ¿tøpmÅÔ¬žyŽƒ|P¾T‡A$Ø8e°‚Vs=ü¾[›#Ùbï‹ OP@Á4ðÑ|É¢´˜IzŽN6Œ®§.Ÿt¶A¨aYŠÿ†ÿlaçù¥ß8QB“’ÛL¢¢d4¥ã碔± UÃPoP/+íëéÜ3J–!xˆà2Ù7P‰çuj[¥Î‡’[c—-Æ-Ìõ7bãaÿs…Öu›lÚËáãæ‡'¾®i™y‚ô!%A4é.øÑg?g¡ÞÞѲ¼/j™Ù e‚ù ÂÁ#`G!q46 ]? ŸfÇ«nw˜ƒžë·N‹ÌoRÂÃóò«¶�˜æVÌR¸þÆÆåfé¦*V=’Ý™NÕáê¡XÛzlÏš8Ü˽+Ï”=ò©èñd-ßÏú]b¦(/ªä' ®ÿmž–ä¦ýQÿ.¦JÄF’‡Õ/Å—Ew FÅFòè)E¢ }Ãñ$D·æ)žµ‘¶? Ë—*;ÿ¤wòl$T*g'�7Ô•®£$IF‰^—n„¢Ö?ò<˜Î›@9²fh€&=†âkð€Ï+sz7�%⮲:øðQgÜ‹-L¡PKgÉÈ—X÷"^ïLdy¶Ôlú*(–Ú;¦<P#îËç­ûÇ}FY²b£ps6‡ É»õën~ƒ«6•ܤ…u,`1€¸ì®(´gf× Öãdþö‹5¼ ÷)g±¡biŒ1oWîÿûHºÌû}ðƒìPô?iZºoÃ’=Šöêáljž0iaü;6J¼!;|ŠÖúùâyŽF³QÔ⥴n­>mkq3ùÒÝÍ“hƨ,ôÂhï<,¡(dnò¤¬Á7y÷lÙÚúpìóÓ8k¦F¿r¯ ×´M)¸Bm—¿Zg“º¼Mö_¤ÅäöÂÃá †°e'šÈ,6î\ÛQÄâ¦î¢M§öŠzXœå¾c<(}J¬õ ºá«v0ç-æ‘e±¦a–Ç6× î˜éÓË‘ê ÛÌ®Z ÄÀu²tÜúëð“Q”¨'7ÂÃ2h÷eÁ§Fä\s²L‚2ˆôßÀ¾¶H@†…ÿˆÓœòÇ•,}L¹KAÚÞ‹Ió©Ç ÃŒ˜Ìò,MI·…)‚žbrÞ[K]�FëãàîîÈš ÒÓ…5LÖe¶3W >Ò‚Øj³Œqç bdœô˜N ½bßÒñ“ûA|Ë‚ÁXËíÉOM_̪Âç¡E%™ÒÍ4 Ø®½ê›ÇÒkã^<÷m£™Áÿ"çž‚Iƒ•f—‰ütäFÀ}û‹0ó=Š�Çȳ -Ç…hp¥P2é-Å]É×V?`°Äéî7ÜoB3ÚPT6ØΘ¡ß”O/NH£ÞlT¤Ò»Ü_‡éÈ 6^Å #;äT»/¯}Ž«¡ÿ/}nTKšçÇÒxªf(õ.x: :–V÷G ZWNf`8b~¨œ4]+ñät¦4V#kT3…së]Ø—µWåf«Áðb—™•àÐcO?o ÑWýÇ/¯aF)0D­î勤ôà¬1>û±£M×µçùСÉ7¨Nx/½†gî_¡1æI“g™•bx_}˜÷<Ú2¾Œü·Ü8WÆTÍQ›l }{À\P3«ÑP´ææÝÑ%ï÷Ü0wÓÉ”›8H¬š]YjÅ«úÜ”‰ð"·Woì<ßÖ¿~»’'TZYd[ÍR€ åÖ¥NÛÔ¶ïŽ'×^Æ·9:¶±¹\â•o±túFÃNaÆ;©P†^”¹B¯eJï;žÒ -8ãôbÝo'‘Q⽘¼6NyvW« a7ÿéLëêÖôýù»óBq=¥ô^;•ÜÈד£ê&”á‹ÿ[v“xM?v5¥h¤W2ÜÔ 2OuoÈ}¨¨¦úâËÞ1WTËÕV^ìÇ_"›÷ 4sã&tòêc1ÓMëëi^)cÇAÝË>TºÇ3’Õ/ˆW¦¬“äV´=£1*ë1`ѳî}žGjïV Ê oFßx¯ ELO8Þ �â·TkÀ  ¨{èºFmça=›Të<ûUe¾Ê²WÔ>…>nò©B¬÷B*ªµ·4‹[—}¥Sò4^“^+Ý%iÒJ‡·C4ö›«g tu,{îè`ý�#E`_!Hyö`+žf¼)|æ=Rx#Ä÷ÀzáÆÉ _níÍÜ  ŽàáR㶾…—ŒX="wËþ½Og²E–FEælÊ�‹U[›¿ÔÔ»y__Þ´…èAþï[dfniÈ“”b™¡äk,½(ÏB÷D˦ÙÃm¶Vúø|‘?Ž“ùÑ€ÔŒ€çƒ.wâ‡îËÌ3Ä`¬Ï ¤Þ%- àtœ¦‡ùçG§Hâ©'÷v‚ûxÚMnF¾ãy‚‘¤üÓ9y†|‹è[LLÈÕ À¤YQG¶£¸4)¿Jé+ÀíÆßØ°ë8@5  ÓûV " .S”õÙAÍ6WÔ#³oNfúw®¾IŠM"%ó5 ò÷ýêüîDß|8ÓrÆ—ÑóÍN0—œ˜˜ÖÀjSXžd$ «(8ÒF Ìš£•6AÖÀa\è3K*è ˹î«^•qœ9͵±yÍ[bKŸ®ìÅiôqK¹ z†.$P1"Ó„Ñ{8ÓcL¤Š œ-Ö-¡äûÜ×û7(Õ³–7½â°Å[Eþ©nþ¡Vqû6!ÍÅë¾ìUd gíòè�É3ßÌšòeœÙYwµëÐXªþ?<Ÿ-íRd!-TZ­éòný 4;áøŒêU£íq¹Ò²ácöÛJµR‰¢V™Ë p¯\d†£OŽû| «OUõä~†Ï÷~t@®ñ,+Q¢>ÕÏ[®§~°Šª]äº÷ôùœ E΃›GÄ––“v‹±†âMCÏ.¨”Š3 ²¦ñTè¸IÇJYôá¬ãÂ??ÍD›Zöp¹l1-½:*‘Õi7 †ö<}ÔÓk¢yáO’¡¾‹yÜaöj(Ó Šl<˜‡Nˆòÿ‚x‹ÑVµ¨Cà.j:ÂzkBžåbyjÂÃòi?#ØéÅæ4Þš‰Å¡#Ê3\—N5z Ó—cÐOµÅzš6ò#û8uZSRUQö2iݵŽ‡1Bâ0%ÌAýWZߤQ–ßÇÜ\–£*(v³û¼íažê®?XË-K,÷(æ`ÛÜÑìˆ*/±dqúP¼[<Êtµ²(ã©ïÄ;äîÇM›sâ—ÎÊ‚Wt˜`ÑÃrf E©Qy°è§<ŽÅ›%À_öºÿ9Obô\sQÞlôhdÀðÏi¢5k¼núúÊh[ vC •ê’ŒÜ0vŽ×ßÒð(®2Oã§áGJ©Úçà!vdjé;iÏ(¶üöÕ¶’Vµ?rŠ à·&>4JêA`.™j`{¯Å‡Ìžµ±Á#oŽôwâ³Ò¾7§¯NSAwméBÈ&>/éKú^Eå/)Z »3øSsç*°´ØáÃ`÷/ý,´õûôfV˜5©ì·_øèêØÒSœ+k„°?rÞãHÞkÝÛ.žµ\JOH =‹oDIå;ÚÌêÇ;S¡"[ùRVÁ©/¨¶Ý{Ž¸ ųA³ü~>{É8‹Lôs”±a—ªo"Eézg�óìô-²ÕT€ní¥¥‚ÙR-çóÀQ‹¥Wœ¨D-ºÜB[•ªÑf(l3ÔÖ›Ót>~+½¢¸X±(‹èò"H¬âNšq‹gïÐæT÷r:»+ÃócÓzÿ~ÛÎ.OLÚça¤cðu‰šÃ„ŒC¦eøüeB§¨¸mS7Ý´óEn«Ìá—رj?Ò»Öê†6?³±$3–ÖmGõ?Õ§TÀ±ŠÅíÏnœUËH°4J““rª5=œyÈ1÷Æg/¯jNZˆšèõB곧Mgû@ÏÃpè䤗DLÜ8éÊûáöT»ý9úŸ8×éOxÀ’è«”g¹èÑîi}“öz4ˆÜ¥‹#&ÀÞ%T: {kYI_ˆÐ9գǚ¿ÔËì,3¤i@ßÄ$ôÖwy„™s8ædÓƒ}ÞØ ’ˆêÁUØÝ©/6µ3ᣇ+âGø*Ò¸ÈÙX¾1‰ªvLgíöÕ抱¯qÒÎWÚ¦Mr+½gÄ’\®ù`†~WD×Ýa;t9Rr¨Y: ¶Wß ›RxÊq»qDgÌÄzÛaȳï× ¨U÷éépí1ÀZ)梊 Nƒ^£¦™‡l(ùN£ûnµ‹£Œ…‡ú¾ñöì¿´ÞãÈ™ª Ÿ+¡�-÷wOìmOÙ?&+·÷Dú@‹9¡¶A òšS~«_ÈmžjG#*öaàÕ²ˆÜ·a_™ù^ñaDA!†ïZëVÊ a£æ4ËRö_n裑µpOÕÂ,ö¯áG¬aO…þ€#VKÏW¨©§µË„ôÃH‹$?k'3jøÃò®´Ç9üí»Å¤—TœÞú YÑQ&÷¡7ñíh á„…òË4êõ.Ý“Œò¥AbìK³ð ÆŸ@‹FžᩧØpcõ((¥©¯L x(ìQÍË ú†!U^§¾µÎÆ¿±Fñ{ŒB™i×”Vò™SŸ4¯õË}ÚÊI|óXuì)©,Z=Ъ,‹�OØâüoµè¥\;v RmÚM{Ïê‰[ZÃ.ÊùÝên C] aú¿å…¾bXDGôîÏ+Y*u§ojȃò‰à]>ºWžûÿ/ô:ÝR©@›Ú+ȆóÊâ‰Dî¿ñößõЪá˜pIUŸÑ–U_¦¿BÀN_ŒÅÛxãÏ|Ê*nl@ZØÇtVÆ]fóë²¼­'íêþx‰qêJ ‹K4©µ”jëþ£;¨TÝÿ¾Q†)RâÆ „™>a,+%¥}_¾±×ÓäR®íŠŒ–oï+ÙeNc;Å4Ú]⣭T«Õ™š&þ\ŒÅ2P@ˆÛÚë�Ð÷î­žõ^¼·æ;ën€%α6'” €¤ Ïjš’4@b;)HÝoˆÜ\z¿/–%Ò´§±‹:~"à#÷],§ÌÉ*iP Vâ�ÊV: ¦ëtbæ¾VËÊV2cˆ/—Lû×vL«VtæµT²•{‹9¢¿TV–šR÷¡R¾¸Í·³"ÿ¨ù¨´`éõ<‹¯ÎÏk(£ûs \ÖºJý,û“y¨^N£éÐJ‚|¯e¶Õå SL¡o²ÃîÄÓ,‡~ÙÓúÿ`%Z'Cÿ.mUäî1—hÒÁ›io[´,Bí ÙìO›V;·G/L¨ÂÌ™.8K>†=÷Â*óý_¸>ŒÐ·ã•„g¶“�óü8_5çL´Ã`fC%»ZeŸ£‰|«Ð wÆS/ûZ¥Ù9c~pÊ¢vPÆÊâBçùóÏ:óNö*×O?}Ê1%z[µºlˆ¿¹¢–$ÎŽOúÍ@Y¥u› øµ©ˆqŽ|BÐò(ÐÌôgCÅ䀰n–iš….žÑ¶¢µù÷ÓÆS?R.}Ò!ñ ÁÞŽßÃД}]Ñêx÷öS=Že¤{Mè)ßô ­WaT¿ "-À¼ÊYÅñ |i{_~æÐ<+­/K¡‰$õ`&ù*ûSeNÛnZ�ucÎßÈŽ:qûÄäÅ3å:É<™ì aϚ㶗3R[6{!>Õdz/šWÆ>/i‡R­f5éT¤ßÞéì5É)bÙ,ô;}eãR_¤…ðÛy÷î«õ<M6ÃëÓ²ç鵃o»«Ç\ …06rýqð;‹ ZBSÏÐÍ�ÇÙÑŠ©)œ±Öõ?a|kúBÆ6°ÂØ^s|Áët wo£èMÊ~/èñÜ”â…oô�Ñ“> [hBÔï0¯´‚Ÿ%*ÄñÊ£,…˜žLÚœÝÉ̼;-¶¨÷—áï‘•Íœu ÈxÔZ—UéßN¬òg’ºÉÐ!“ÊcYÇì΃Z¬¿ÔÉïtD%a¾úžb ²ïo›¸š&çæl²6™µÙRÚ‚»•êÿ;Zå…e’ÄŒ¡Õ­‡¢_*Ù•ÙÛ¼îMëæ5i)OïI¤üN=}ÿóÙ#§B5½ã5³§ ŽwÞÎòr·ÀHÃÐwdÄé2•AÙíÝqÈ^¦­Œ LËoæ13™  <PÀpò£anOÈ£tpSa÷¹xr×ËidM‘KÏ“Ç^äìÅ5KR„¾9â§/°üõßIKÑòµ+œ2ýAÆæ{áþÝä˜UnéˆlE0N´ÊzÕ…ÆD cÁö¹SòäÛqüAm¼\¿Á …¥qE·ß€ ἧ›¤¬u¾Ç•É Mû=Ž­I¸x‡�Aae… qV¿2‹€}÷Ÿýiì¾ÿâÈËüDÿdó‡6µu:Fƒ>–ƒY¿ ÿcÓ±¨0ã–ϪýÙiª/¢ÝÚó¤ÖI ù“ŠgÓ8[[ýd¼Öüq•ø¡}þ5Ï`:]ê•ä8Ì”üv©˜SqIû¯´$wF¡¾äfI(èèyŒ>ŠjÊ|+ñÎ4P-Òc°‰£Ò᜗1žèÉ×¬Ó é+íº¦5BÈÀÝê&žK{Üþ;TÑ$ñŒÕ+¡WÒ?ªVaŠöÃ'7 Ë;é&ÑP‰˜›qî&¾Lz†;Ç©ÌX…ó©v­«£ß¼Šˆ§án.‰’ŒÁ6át/¶ŽÊÍ0°;[<ï^Éã±.‚j²¬ƒJ„cyŽ;èóð Éasþûºo?Â\_YAÐÞ,šÖb„ò&�Ö9Õ-ËòOï†$é‘1-O­ÏPŒL®£ Ë—{Í«<)|Å�Øh\¡nfåMyxžüþ½i¯_¾©S&™ÿù¨¦ÏYö:™â·²­l ¡õîñ€uÎÍ<ÊÐ>:¶ˆ{(c”'ká (÷�Ë`%üÒaLSyX}Ø7|__ƒ*Â&+0Û‰”tf£Ž«øó¸<…ZR,ßlhé¨e­÷ƒGÐõØðÒÁ=Œ ¾zçÌŽ9XI1Yø¿o]{<ã¾û}s)½i;kÍr×­i?œ@åޑͧ{ õ9‡rZ™ÊJƒ×jhñK¦‰üðôëR˜A~çô _¶ðܬ5L9£–TQqɸ¸ÔCÝ8Éä[¬–,Hëjò˜ŠÏg Ø º? íßÁñ*%¢[}©“ ~ÿ2 °L!À%·L¢Óeø¿‚êž4££Jçe¥1ó¸ÉÔ^ÁOaK=ü!F *áñ40wDîãú'¯we¸U1%H9ƒyt‰î=wìÙQ£8tî^“š-=.,X²=ÝkaË–fݬù¹\{®TëÙñ6fÎ_l ‘ÃZ+<ñ¸ÂêÆøÿtáí´ïzt×M¥ÒGØ Ë6Wtøv¾ïyçô‚¢¥S(TA l´@ÎGè•L_3žaVg«Û¥Ù×ÛH–úè/¾TWYèêvZÆû›ßܨÔëи%x÷b1NÉ…i ;*¢]¬‚’ØQqñ†n­ñt›˜s:Û—;;ö´ö4°;£¯QëŠÀÔÏk~ÛqÝ*%±ŒC©üî£ég¼s=Ñ)f?»ÙŸ¾œ@¼qÈ7ÿúŽ€Aú‡8Å|ÖkÍþ¢*Qp‹ìGºæÊçþ„ß :Å¡‘tG"½«7UjôÞ®ÎâùØ3¢5 ×ÁóãÔÚÊ?¦"t´ìea¬Þõ±€U6e‰G£›OÏÙ¥¯…iJFYìöõ;H5ñLPÞ…â÷zS¿ÙK¿Bð±‚."ºC›yÚñúúë…{ÈÖcÀ&rÝE†½æõ§vL†k…´ÍIt¿óä`\Wïj'.ö³A?`;ú€òÔ›•X³?=òXÞ?^‚컽 ¹-!ÈÞz†—=Ôד§G´ƒmµ¾nên±õ¯þ¥ÑésNhTõíé~5+“½ŠtîúzãAÖ5’Iˆa¦þðo€šÖ?›*…Â"}íš}ܱ¼ NHéco4Ð,hýá/è›%¾ˆ°}³wMržeËFU³Þ[ñ`w±^«Yž­ðø Þ›Âʧ67Ø©ü ÞšëÔÅ\*p Û³?^Œ•¯Ž ï˜QX†¾Áq  ãŸp¨0Å8ýÍÆ`ÎÈú'–¡³jJ ³³IÓ ¬µãŽ°Ûè¸á_ö?$t :Ú.Ï‚¼ÓÖEżˆš"уµ©û+­æHìd­”ØÖgOJ•ö)ˆK”^ØÁ¤¥˜ˆ C7RUà T´³œx«5šZŠ1Ô›½¸·[œ3å˜Nñ·©wèÛ=¤qdÞ Êù,O}¬'SÉ[Å”5›ýiòã 8R÷ÆÁé+¥„öÝ›µ‹ç?>içÝ}q¢ó²LÎ ö[¶�þ,dõŠÍÇlXM¿S!H•€`D ~dmíEáÍB¾–ìb%æ~ªõuGùýЬ©<ø§õrøƒ€aîò|àÑ„Ì@¸Xf¶r@šáBo—¿k.G*¬ñyî:>T‰ÃïÏEm#4ªŒVk÷EwÇid"hÜCÙc–åÔ_ ïàû³FYyöÐpÖš=$<GŠ3áƒQ‡wpóV1Ÿ¯hùÇ…‡ Þ?TÒÚI …ý¿oÃé<+œÏ“Ùݺ»¶> $Ú_3·ÞIÕJ?D«c …ËÆÓÓBWÆ8#€±ÇÌãv »ó»–VU®|sÌZ ú¯Lxº+p?ö]1郱# Þ™Õ´ÇšÎ2¸)Ü4¬ªÝ"Ý*œ”OªnŽ¿U+¬Ý•‚ÕŸå'µ6Ž‚n'³Êa¸á‰í"\èÁ1ÅQlÆnÙ]Uø­™(*N×7Ê^§­yúîÜqéO'§"úc]ç±mi‘Isu· u Ô/jÜ%ÕÊ=­¦52Óe{šÿûÁ¡›UÄFØx?Âg«BPÇ¡òü#µ;ô©Ÿ;šéJXä‘šz^×F@Â’ßøñ5Å‚…ËÿH�‡òoWò“÷~ùðh‰|¹¶FØÑæêlŠä/V³8v/~ØR1¨¯Ö\†öÁ•Pxjâ•Øe&Ayi\Œ>Ö»ñЙî!^¸“›So³Kw)ÅYäiª|ðRS¬³ôÜT$úU£f6Ûyíx5?°*Ms¿š1Z8h’‘¢¨¦]²PÃ'¢NÑ~˜¦YS†Šs_eT´œ½…ôq»i8hÕ(4Ïno^=}„°2s.Ê¢KçùÍo¢èéBŒ0ž¨)d‰Ä3 †,Í<»Û(2´‡÷«ÅGþGKñ GákL‡ÂðÄÆuQm[}<r%k ìXgÇ>ÂsŒ«`ÓAj¥ŠQ×P¤ð¨ïÌù:òÿa,(ïÜ{bM'š¬Jé‡Þpý¡×gåäÄ JÞyÄgE)§•±Ã= SK £4Ÿ Êó`&àlÙHw…>`¼ÈÕx’ùö}ü­y9xè ôpŒd§û­“4CYI(¡šb«BM9‹ ÂQ'&ÝWÇÛX^ìTíXVÍÄ1ÿ'2 ¹EQ½¿¶ÝëCÔ0ò›…a‚Ä0ˆÎ½ç¾Ê–ßWEåh|qWtx^Xú„_xCX€GĨªÌ)u[oCˆ¯š¿é¿œ㫺¼TèˆämÌÓ…?²æøßm¸7¥ÊáûéÜ4¢û¥©u¹Š-‹¾Þ9gboLÀz-ý2r:Çm&¬žœýYlŒÜ?£ÿñ•p¤W\GãWîÁ¾ÛA¤{ƒ¡¯%DØ,ËÇÊMݸý`w%¾f4OnªoHbN6Ñ—ñ„¿<*Í+epUÙŠg] >3¬„[&!ÆÌ…ÿ f­C[GUúSõèŽ%ÃѺS¿Ò`[÷¦­qÇ×Üi÷°q1eð@}¦®ëÍvy¨6T¶êeÜg’Û=' ) T­>GdÖÐþa2¯%—þ‹æ¾Ž¥ÌÖà˜é´÷ZÓùˆ{¢²Äî,}ÂVŠ¬Lpn„XfØãMšaò¤‘V`'CxiÈq¯Ä BEÓüêɆIAb «û]7äŽL6™ÙrÛ™zèþf¯h¹˜Ñ‚‚«½*4û°[:;Tûã›òóÅ›¢pÇ ä.þNTy`h¢gc÷­Â2ÎV…g¦÷Fû.oÖpLhö)ìàÒDK9{ áNœHœÆµQ²?AÄyV”)cí­Š ÅâêX_mYú ò~·"·â÷L¹,òMHșʣÆyý§›lô¿Ÿi~K:i{{þ¢rìë„EÎU€v7–> Ž58?—pìh7g à2¨íš! 8ÀÇõ<íì!ˆ–™üóžÔoá)†&b¯ÉtK"ÞSÖk(õ> ž•SMWN49TšÅù¾'U¸jÏQè»”A>hïòØõ\yé(¥žÎ¡où[Ät-9„I %Q³ZÕçÝ“îÕ¸†ú_:Ees´Þ†ÍTÏÜþ u,Ó‹ãÉ÷öJgÕþê\©=œ‘Ú»ÃåÔÿp…®‡Ë«l1Ï!%­‡QØM§@CípŒãLíuÿ‹u4C ñè/ìuÔ�Ì ‹~Õ™:Î3¿wÂ|¤ ‹G´5$^¾3Œ¥ú{êú—OZg=–pÎTã Š Ûé¦Ù•xkÝîYâŸ*$~Aëÿæ'B³z9HHôÿs«ÇU‘_{ãžz’™¿Ò8żtÈ©CŸËˆÌvƒÓ)²3¶XTÖé•ò~D5êâ0_¹°æ2-ü(Ö¤ÜÓé0yî*èobáùøt˜h¸_õ†Ï_t”GJ®S­*I"¶ª¯šP<úÙ *]IáŠ=lÅŽùd×Ö“;~8æÈï.f)J¯jϵ˜³Òw3ÅýliµYi`^êÍÔ¹9Óë¾K‘ç!Îö›mŠ¦£õÜávüt–zËEæ¶~oøl:ŒFØŒ{þ´ÂšÙh6"·€©ÕFU2~Ùó¯œ <ƒW*e*ðBnÁÛ|XNþAP±8Œì˜=E‘wú°.{Ì.JZ«‚>¼Îo~´•­\£;bmǦ¡¾¿š ^<8•¿Ãý1œÿ¶¾ŽîUéT»£bV�:-£/e ¤J÷ÜwWNÃlµðcìM2¿ü!Q•Që¦d±È=œœÜs¬ëÕÞéLÝQ,Ué‡ÄøŒÌ”âÆKk™ÊÞpK:ób‹L‡êð¢^¯mÄñ(”Ž±GRÔy¾íú*ªlé~ìÎÃ@Ñœ~Fà¬âàª*n+óh]¤[eßëé�?_³F ª‰-õÚÞ¬5}ÓÈ×Èötµu§„žfÂõüŸÌ©´?5¼²O â5�_KÚîw©7>å`;t•™gktÕwpÕËp«8\Q´B®<)œ~Ö®ƒß\' Ó¡øÈŽ1EqäMŽ8Û¦,('kÊhšÞǽ(`Ð{Ude™ùú0E¡ôË’¢€«”[ -÷é0‚^Ëÿ|f’'¡7´�d𘽗xQÕȹÊ5œÀ@ÖâãéO·«ÊüiLl0;–‡qö†–»Ã?buÌ€G˜&B+gk¯AK✥ðûyRº'Æ^ >°á|¯\ÞÐXˆ¨ìxX–|eaˆ’/ _2ÏÌ.e…îŽâxºXW`‚zU-óÙ¹xÊÛ- W`âë{F£Š³é"ÖÜY“e…Cf—A*»î ïÒ;”X­à0‚ôUëèDMeÍlâ2ŠL()¯ö0ϬC#_%Šg£<üŽ{­F‹„ÃUÿá"ýÍðûñ(Ü%«û˜³Æ¼¶Ø·(¦Œ+e%ûm:¡Óp˜O°Ï 5€T‹™ø]BiwciøCâìÙrT�³6{Ñô¢u×t€+Í^2~O£å‰±n”yûÞ=«Õ6q9·'+�Ié¹>ó ŒÓÔ}ü_ð±TA4YÓIMQ=™*´Lí»ºæQîÓShA±²JÆ­)½°ú0EŸ~ÉñŒ*–­ï ÇŠtí‚~ Ìwù2F¬ŽÅgú Àí;ãbM0üIÕw$$ö˜½bçø’<ÑÿX tl D `½‚·9Ÿ«'Êtg®«ž WY¬˜žÔÓ$¡O¥¶ yÏh¯Aü»ÙÈ«ž{k£uòká.tƒÌrG¹×´µzd °PÑvkÿÕwцúÎbó[ÊîzGqþkÅS½6FtSï×ú…?ˆYu ¢›Õ»ò³ØAr´ŸujÛnf°Ùtú2Ñã›h^”ø 9Ì’w ¥£“’(–¼çApÉSך&þw•ãÜ7Ò†ŒðkûÑ£+E•¦×3çEÔZèP3rj6Sd_;ozHiI7y3þ ,¼*ºÇþ.›ÞÀac hyõ֊˳QÅÒÇ2Þße’¥¨×ŽW%(ÈØ®Úç2rôªû_)Æø&½bŽÙ¤ytº¢K®G[³N¡'pôx2îÝòZožz>[íÏ Ú*º€œnmP¡&à2›ÿ¡ŸúW^»ÕØ¡Ý$AÜ)XºÂàƒE¬VªÐ¢ö2¸÷ö·'Š(œw?ÀÔYÏðHœ+ Ô7UÞÂD2ùç#qŪò- á«½ÀûôݦÀ‘ñÄd†¤9TP„½ÑÝÜ2Ý ‰D',¼2*}q®–V þ÷{Ç@ÝfÖɶ¶M]KuÖúEz¶}÷GÐ&wéÔGEÜÞ)h†Ÿ‹9UÞéì«i!uÜò> âèfþ첟X¬$£`ëޓϹâæ`‰<«aÑzkè8,Þ{Oh±õ––ú({qK¦-3§žà´å¯P|vÎaµÞÔmw´"H§©ÊþÅœ{Ê9‘Q/ [´èü’Õ2öà¶JÔÞ»z¢c›U™Ï ÈlŽ Û î ÆtìO&U9vèЩ¿¿Òqÿú9i”Y€g+MI^Ý{Š.”›~¡¤0ÂàÚ(0<a,ÆÒGLjêœrú­>‘é¹{kª9wˆêÒX}?(-.gå€ý=]EŒ?4«Ò¼ ¸\zÅ-ë¥FÊEÓ¡up<ô9Ä«ŒC¼¨v›E–ë*S© ªØÕ jx,ux˜î¢ôÇâYðö“´‡ä 5?ùÃ_œü8¾î¡B"¥Š ë1’l÷ÝJ2E‚å0´¥òÛô¶ŠÃp¥MpD×~j.ëÙ‡1Ÿuòó²Àû—÷‡¥VªD¬ÉË`˜( Û·û¨v2EºóØÚÏ¢Í7‰1ð·uŸÝÈ;÷sÄŸŠÔ€j=í'ó q­áÄ%†”" ‹Ç³8ô‡Ú¥G"JˆÏYßñÕ+=/[ä!8Ñtw?¨‡>øö52t™ûúb—¯È½H kÇÚö<TOî^è}ѽéj]4¶5_ä«Ö|b´*'OŒ§^h‰Í§_‰UFžm*TA¨"Úè°•rdŒôûn˜ì¨Á*g¿ 38®ÊÑÛôeç% P8Ü¢^¶D*µ˜Ëý ‚îyÁ®W‹µëNŒŠÖ´C¤ï¼…¸=`à;È@Šªø.ìsË‚ë¼a?$ë‘&úýn^¨apûî ·wS}¥òß™OÑiOgÚ),/ã7V²Ê-LC( ËÊö#sdx›±Ëú¿oõ™Þ…Ö8 ’LÇn ²ñ4–ŒUAOÖ®óL¤*îÍÌ¿æ{Ãr5àƒÊ0w¼¹SãÚrI0$AòÞz°1!"smñšiXå:ØÆR£ƒøð×_í]) ‘všåÐànŸ²欕:ðié=ìà¿ø®Òy3ä7H¤ºgi!Ê Œ(Çô¨äÙ‹ïETšs?, e>Q=P~j»¥dÁˆëq<løIºÞä½+ÕYÎVT™Q$ãÿvzø3Ó51ì> àý ú¯ ++ 'ì mI9Þ4y.m;Hí·ÝÎìIøZ_7P°¡ñû”™WT®ºeºâœånë[ø´'4Ó®žöÚ‹£eŠlº´Rœþ7KÔ°9¡¿f�%EœYÑCèÐ]ª ² B¨9B¼QÈçâz°^ÙïPY3¿« 4Ì”Ð)öÞyjIo¢=Éþ]šÝ"•?`ï§=2,¦‚ÓÙFGg·ÒdТ35Xûê!ɲ5}÷”EPû–ŽÛåÛP²Â)–)»h•ªßù•÷ Rdiÿ+lˆòvº¶Ýà0Ô E!ðïþ‰w­¨œ¾fT»Ú³ŽØœÎ5ìÒ0ÁÖ]Ý1Ò,*·k^u=Ñ™”X3‡\•F$#Òóé>‰û9¡;Šªœ¾e´~‹óèÉgã¼a(þv}kÛSÏóž‡ ãérÍ?ádb½¶aû’ÄöÔˆÅ%‚-%=¸9~î]Ýc'òô‚Õ›Å&æi‡GAý7íDk‘%V¶T£ ( k[œåÉ8!ᬂ–óà—» :g1°~ÐAVf`ˆI#­Õèâ°ËÛPPí$NJ?y:8`#m^¢ÿ‰ãÜ7²F÷¥ Jë5§BAöèäVO$•îDŒÔSCg@C÷•TìPã2¦™"Ü :ïæ¦`+òjÒ“Ýu^:yKfk$Mç©Ì»¡=Œº¾p5<ÎFèeÓœío¯¥õщY³=Ngº±BRë^Î_àÖLÿEßvëu—ä+O9XwÅôœT̼íeE¶ºY/‰G«‹—ÑÐŒÅÄ¥t™jnð Kàž ç¡ Ø¤™þ‘-ºÔuÌÊìe+IÝHÀ¬Cîß¼šo®Á¾·AO9Zõ¥4Ì8X¹Kè²|êÜ“¯`Û!‹¸AUdï•"›º¯ó¿k¸¥±¯²K§](Ä»$XëPi0w¦qñí‚S?øó‰cõóã°ÊüØ£ ¡å„•¯ôpUà¤sÍ«þ3OÚ±PÅãgµ°h«œÞb§¡ž [ü»Pþ&¬ˆWÝ“»¿ô"ã'lˆ|Šùàü“]ЙÁlŠó þ�¿ ô9FRftaÇŽv|þn‰ÉF “9©$œMwåŸÆÙeæ©Lþ¥\#ê¼�ÃE“±cò ÇS ÖôþsÏ®5¢šÝO™èMçp k[ þÄJä{Uô¬<JËí£ú6â¡«N,VN5L0ÔÃÁ™0è¶Qlj™æ6ßõI§Ydf•!'½ZÉÆÞ*ìÑðž6ÐÜݱ÷Ú?èK–!eÖvºƒJ˜ø¢]Ù2”GLŸtæ�e騯÷ž*ÃÒ2”AÖ´¦7ëtŸhi&2Zš›ýŸÜ*“‚C 5³ùìØli•f668HÁ ž2Ášš({shQ8AIap- åªžK‚ t²…Ev=ÊA˜]ßõïŒVxÈ”(•Ö¾ ƒïdQÇ‘I}4¡½í|õwßæ8>é=B¹ hJ÷nDÎ5ü2g;gÃ;H 5j30zZ|GÞxJ|3*J|ª Ù+ðÒí:®ªq¡Ü iBÝ4,åÿô@Ø(òDö8ÞOqP6 Pä%LÿûfD¤„~¶aà ž™$Nza9ôݪíü-‘CBa2§ˆ4wžˆTß_®à"Îs½P¤x¿ìíë/5EÓÐÓÅ™;в+ßÏ—’[•îÄÚM‡ãÜ\½W(péOû3CåDO´DCcY#Ü:p‰¢SnAeBJF'&7Òºø» ,bŽ¡°4ÀÞ}5¾‹:U>ŒŒ#e ;O³ÇæÿúÆç©ò4ÅÙ° !.Ü)N loè૛ݎQè¥\ê– Ü¥ûI¯%ÊV®ëÆ?<š¬—/Dy:�hÙ¿GŠÐ•}øê›™DÕÚN0 v=ÅúÒNpÜò±s0GØ{—ßSÁ¼r“61ÀZ"0"öÎZp¸Š¯”Ú±Vî¥+;¸´¥:keZ_»»`Æ6›ù¶7©ˆÓçþè´ÔèØa= ÍÈ/T‘ {…ñDè?Kô¦;J^?]…,ÁÖÃU~ä§îAŠ"ô-^étØÁ–®ñˆ´Ѹªe‰¹`f³ˆë›%c>Vpå=kѾ YPXÙƒ(ß­wÆm‹¨ H"ýÏ>AÎæ¥0¼ÉaÝkÅ"ÙëâÊLo¸µëÚ^äø¿µ,£d5‡ÖÛ§zÞÉ—†¬ðÛžÓÕùßJƒÐÁ@†§í÷ ñ' íž'2eÊ¿>( ˜j×p1o¬˜Î®f~ã¹?ÚŸ„¦‚4ÿAª¯½ ´u` ÙyòJ>GkÓ«¡õëýWi1i¤ÀžÐÏ× §Kd­$š(³L¤aôå=AàÐÛø?h8Ò¡ÙzÆê¬Ã©¢Ì\\Q”Ä¿ò±múi|Ì€@ZF¹A°¯ž;+”id~Ãp èSEa( š _]ñЧ¦¯ï©.ÿž Q­¥½Cú@ð†S¡ îC™JJÖ ¥œý?UmÏ"×bµhvȳX„/'{g†D?C.# Œkëq:‹jFF­”UĺÛ@ØËã„‚¢²H€.<W ìÀ€X,5ãÀ˜ æ[Ú®È}Z°ñ€›šƒÌÎÍÅkÓh'Ë"1q*ZDƒvä$ñõJ2hNƒ&êû3(Ê2€ÕÖsBšoÌÓÓRtQ»¨‚¡£©›àO,ÑȣƈD?ï¾üÓcs¢hèr¦×T®¼ }`¹À{¼ûëÄv(ezh~aM¶¹Ô ŸžYΞˆQE© ñ83´¿EKª¸8 £U&7<8 ò¯3ÿŠ(óÍ=s±™,Þ?WýO•!@éqm¸L”ê\µzNFÿã¹!! Ãa Œøün"A†òÑö˜ä i[-‹¬?©tâ ÍõDùp6žD›înégû(|1�Ûû¨E«ÃÂlÏ"ÓWµÇZàv‰¹ó¸>©æ4|„õ6u_’$ Ýmͽ˜ÝéärŒ"q¤£ßPy¢ ‡*®£_Í]9Öìÿm^lÂ[†+wî”%ò¹·é45oøÝŸÐj0›SÈ.¹9t+Õ›¿áÜÞ”RÑ-ƒ¢¿º3ˆîðŸƒ^[Ÿ‚Ͻ×GÙI÷\cî*üZUPÉ”âà²-(±îÀ¥ŸJóbÙŠŸÀû(|-Ývª7Ë3v+C"”ñVCYí=ž1 9}aDz¡­óæå_,†òÜWpˆMû×ù¾GÚuPÖÞ?ðC£ÌWR à<a˜eµUئøÀ‡3F˜Í?ïz~¤î.Uíáñ®ÃÚ$1ýâá¬æ3Í $Ý·©Ûæõ÷T@£pe£sV\Y5£¢¼£fôB4psOlˆâüýËó‡ÙôõÕ£î‹>N‹µ4 3³—”ŽZ;¾sIJ£tºAÆ<ÿÑ}3šF% £F³{05’bÚ鸿„¢(VÖG”ÍC*iZ!3êéOgÇZt3é ñÇ]}C¾§ëîJ¿‡$(‡/`ÓÓnB‰§²ÿ´ö ®–ww¹ÒaÚ9ßPá¶VX f%´}›­Yé;ªÃÚ: U}ÕÂœ÷l@±XZS”M£0Í|†Tǜ©•+’ÐÃe²ôAbë¾? -ç‚öSz¦Oyj¬NK03=³Ï{‡ñs»Lçôg`-|®‡Ìí«»I¡°×Ð_+ƒ²Õ\­ÈdŒ5Å�îÚhSsÐg¬‡2ó«eÈN�êjc‚}™ñÙ+`š ìß }È‚ÒpKPÌãÀ©5²½ÍÅX¼Ë™!h<ñ¹muÚ‰¢Œ~->úì5ïça³^žÐÆô—/ඦӫµ’d,Çumk…4á¾~¿~â5Ì2 :˜1UUþéhËë׿œrBjöÓîL‘&œ|ë½ã‰ 'pÚ÷ÝNòO^Eì@ùðZÎX%ì¶W:¥ö½¶BB=bœ`•öQÿp݆˜pFðIà} XB‹<a•1Χ§²o†‹ß/\N–¸ÅWJêM.ê•| ùõŽÓyOr0ç^e7ÃI¨nyî¨E¨¨4¥¢ÓVß1ôüq›½Þ?gnsxWw´n/šRp@Ñ  bŒË¸mŤ$lwŽÿ¨(H„ÙVó•–•ÈÞGϲ=˜LĶsÌ@ »#%r;€Ü¯7/*‹bÁc©ÅaCË3ßÕ¦2D¯}šÇÃR÷º†è<POø×Z ú†Ì‚ì쀠|ŸÍß0”#ŠÓS ÛU»Vu|3V™"_%{˜( ß-N)f äÙ‹5ÜëÚ.w ]ÕZþ˜J* ÒŦ“QÀ<³Æ[€ü<C¬#˜Î»Žù»Ó%ºÌMV†ÔIp¤Ü¯ZÞÕ²46ÂïÒQ0þΗà ÖD6›Çý,Í'ûU[]ž‰Ó;®L÷ŠÉ™P†Ük®î&YñÂãÉ…Zìø?2Ý‘ÜCìcֳϭód§ ü@ú”+ÝúUìã$ôƒ÷HénÅûÉ!­ÎÄ«,ȨʲÌK1ÓàˆGû©ÇväiâfÁ;ÝàÚ5Òÿ ÷_x îý éwž©³…P¨ÐוJÄgÊjí‰pF%Œ·ÅZËWEàõ7&úCxË’Ì\ñ„�@Ž«Ê>±‘UNK׎‡‘×eàt,‚ÿY×(Î6–ªŸI±GûzyYòßW„4Bt¿&+f––º,ÙÎTd´#ážR‡•\•¥Ÿã˜Þ¬í,?%•ÁýñT›¼ÿßV~*¿ƒ?‹­åcNuG#|(¾XÜ{ÝøӉȧfFÞ6R맃ã÷ÈÚýæ 8PݶZÖÑ-S«Ý'”ìõŽË”íÎ<mPp¬hÀ/Ê’Fqe}Iøÿ‚¦V£S)ŒÌ/y¥†P+±øÞE‘yS¦õfz[ãk•¬ó@ɘ5a –ƒ RÄäçq{æñŠÜL¸‚ ËÅAá舞®>––zà-i/¾1‘ïKw•#Åà[Fù™’b´ŒÍ ëí¨`ÇÚm9õÍ6‘Fõ”ÔÖQ¦°H•ƒòë,Ïíû…b$£(]ye\=‡–&�^”Ñ¡æI´áF½RBûêˆÔ— ì…›•ì;ðñYÙò¦5XÃÛø΢Ž«¸,LÝPòi{¡‚Ù*§úÃä²yÃ’&}³ cPóŽ6.ž]„¿78„·žª dúþdIÎV¹ô†8}K v}‘ÂôE`Ò›üÕ„çØÕ»¾›Ý=òx]ÏÔD;î¹.õOÙü©¯³ l5—L}&Dy§¼A1žyQ>ÄDáG¸é8ŽW(¨1€ìØz°R*”e"fM]^µ“¬<æ¬x[×1|f{†ÇŘ֮ &óü†Fþ%²LáÝåC }«HÄŒúG:üR#³æ! ¦xYÏoÎ’*5ªmÊ d[ëDÆñÓ"eÊþÄèïH„nL¾&ÍfËⳃ|G7äë•ÿ“ïö„ŠÆ¹òIczìŠ ìœ=á;Œs>Õµæú}ÅUØŸa!téþz\Ä™ïÐ#Ÿ¤2|Ô¾VÖ€»Ðúˆ¯ UÆ+|˜Ç´°·ŸªU sð%hÿûF›ÕË3!°$ÿ“Ù RÿJ®Îì7”\æŸ_Íz_ÏœG*/dª/ -þ³ô:)O½ËõÆ*R?1�<ÿ‹VL|¶¬Å‚‰.[`“̵? k€µ¶–±ÎاlgÈ(ûÄ’´©¶¢¿ÝûÊÖñõ˽'çtË¿¶ Ïíh<Pdv†_zD©­xº'N:TyÈ*^MMùz»³ŽŽªŒ¡2òxyt‡{‚NSm€Ñž$´%—?ý—~kALCbŒ¨XkO~ç<›†p¸Ëb »3xpC±Ü¤IÝe®éþjPˆTÜc\{¡aFW'†•´1V:dþ³æ3ÇL�ù í{;ÏÀ¾?ÖÿÚ¼Ï<£i¤Ð:„ ®õ3MÒ¼rÆÃM_ñ‚M#Ê ß¡1k;"à|g–ÿìœm—¥?lY)>'M À`íeF`.ì@¥Ít*U~Tüó»Æ6n'ôh@ãÎX’ÛΫ”=¶tpÉõã 8Ê2Ëh׿) ²¡3í¿X4Õ6ÈÐæ_:8Faì‹Ë†EÐDbË-·_†_¬?âû½—f!*ÀºÉêcȆŒ/Ƹ$‰â0±{œîÖHÅ[Öëte¡Bn)^z‚Âÿ€àíõ »pOòºÊV2[Ì[ L÷nEø.N,ÀL4Gœä¨B]µ6.²_ù«â !)C!óSÖ:dG[ˆõÔÁg7;è—b?eè›|Ãd>¤eón]¤Qn´ÎööŸQÎUä,JÖ^¨¾Ûꉑ0óWUÑ5,ÿ2ÄÅJ9›np´q[›å8/¢-otáMlH“€Q€è¬s‚³>áÀÓ²{¹“rM(éȃ²ýôüâʉÙüwý–µ2›B§Œ©,ËPV—գгœF¦+Ë•9Etbnën°¯ÑÿD–ô®¯}Wùtvt([œw§5âÇ~uÚf'‹³Å­°¶Õ‹õ ç†BV×öÃ\‘ð+ X!½ÜPH= oÊLF68µ™DZªÆâಧ¸Ê3é;Kù±¨_ºa¤÷oû<ˆ§OwºA°›ÅXY¶j:ÉA){H{a0‚„bãuVºÖ»3ÕxÙ¾QA\–”¢HŸ ']{œaFŠ#åÜø\öÄSò—¶À´ƒ²l;:%±c}¸âÐfO1›£³“gxAª¡òÌöd„p©ikTÖ˜ #„úo×»nDø8ëð—É î1VoÞxgÂGžÖ±²žÂÁŸ“ÅËtÕ` !Å ¡ù«§åT³gUÁ”d•P¤Æ](b‚K®˜½~}Ä¿ñ€ôÍJç ÿ`üé·1R|)Uô‡¬™<˜žlŽp¬o† Ï|?¢ÿɳx9§(YÍÃvôXÁz÷¾Ð‹ ‚£ÑŠ-CDô•¶  ºÌR¶@A >rqcc€>EÉþÖwõ¯\ä²ÔUò,9ÝP½v­÷¤•c¦Rò§ãlà7w/¿³Q^¦¢®\˜ÒxÞa:÷©E( P>÷eðme`ÔLF}@D9}EWbEC¼á$ƹ§ ÇÉaJ­É‹�‰>:Ñ’°q«‡l³”oʶU‘9Ë=zÒ8+ŠaošÀ!ˆuÛU\/ºg«Ì2Ý1Ñôus½o½  òQ$Å[Dc§CÌÜ”üÒþ6ÑÌÜ!‰¥ÿšžXMÐR1È;ŠµaS{;Ät³´d> ²ÝiÌVðÿ7“d-ùC)Ö<f´W”φÿŒ£†o>cZëûºe@?­j¡‹Þgn8,¸èø1tŽê„)e·äÆúV@´DÂ7:MÏÏuÿÖA ï{”Ô\*waÊ8*¯eâ잎ô+å?_³ƒ„šƒ×^çÖÃÀßðÏ\\øÞ!œ&@§hüô`p¦ýË=ÉIê ìÚ^Tš“Èwc„„&tïÞ-ì‹þĉê~಩×i!Ý:œ',AÂ:Åçþît1ÉB_ÒšíÃcÍ79)Ïù¦5„[i;?¿7NÜ`t]sº1Aꔋ†ß=3O¹l4÷.WrKѺÝ›Kdgí•Ajøx]\ƒ”Z‰)z±¬´7ì¯\¿ÏÎ4³††F†jËTj¿®¢añ¿2ýæ÷O× ÑáýºÙl;3Âi‡íkiç)í˜T¬²ÈLê b ÖáYh­Ã©B;7hp(Ï1%N.þÍDº0b¯ötbœ{8zѺúX"ºÏg$ÞŸàãìŒÄ%h ¨+óWauqâÌK€2í ~|Þù\³c#J\ù£l&Y,™ÐgdÑJ0_øc×G”ÝŠvO ,k0²h¸­øQÏñ®R€>=´‡çOG\¹YÃY§=rÕw»ƒÔýxÂ4{–g‰¯Î¾$ùþ§q˜ú=Oäõ}Fó]‹û<SzöÆ^%ªÃSšT£îi}iÀ µ­­“œÑ0ãñ“D}Gžfã2a{²/¸ÆiåÖ_[äl†9ú~8¾áH¬)ÞN¤þNƬ·sdXLŒÚ)gŠ³wÁtº0üM…@�€¬èûÉú£ED1 Ͳ«nT 4û“%yJ³&øidysnF¶]–Qðšôœ.P{3Ï”¶h¨Õývâ„ûɤU‘ŽQa49®':M²mçJ(:e¹UcÚ'ßh‘E½q^Â9» B+BŸ' f4#7<T©h[3¾~GÔV@íút¨"µe½ã¬-fU7Ì‘ G®ÛÝTí¹|\W¾t;Eù§ÝüõXßða“ݧ¤e®KÇ4^æ^¨„O9QTø]MZqÃHqÖqþ(%´ÑZ`YtaÚó­¿b©rÛyJ>µ½=™OUï\ÁÞSK{¢›Vyàpæ/5{4Ãuþpwj‘¯ònûjªïýÓ3'Q‰¶b5š7uít:mѬÁžñ)¯rÏ·�*ü›âˆmòìC¬ÓÕ¯­ea>Œ~<¨T‡ßë?ó™ÖïŽHœ¾ÿÆ&èDåæÇ›|VfÆD.&=©pÊ¿@¶EY,‘¹ 6 ªþQuÛÁøDÓË#Ž£:5XZyò?zK—•nÊ(’¤«ÞßÇÛAjK÷ {31§œòÉ°Íës:P-öZ¯ÑQùN7b¶ëªN±ùYƧˆ|z:áÑòBCnâÌ,ª¦§ä+Vhv+”~®ia¯œo.è‰ÄBW¼ž8D+ÃîRŸÀúgoZ(lp|ñÀóë_‹53$:Ðpê Äé÷ÚR¸$¬ç àø”tæ zn­#ï2×:ø¢\]þdÛž¹í¨–•F<ɲ ¼aØ<vÃÆö!ñµ0¨¢=0?Ó.Ksú òÃâVwe Æ€¤_ñ1¹A4ã¦ÁRäæ[-YA°©êªèÇið8úÌIéfÏÁ†¾©ÌKBSKE*ø+Ô‹Ï;Ï…’"u¿•ÙŒÜÓŒ·¡€øýb媅™çì.d:*¶Š0z¯µ®žë~¡ZľÞq&KK·UøÄ€‘Uõ—ªšAiW“AüÊÿï›`‘»TŽaðsÁ*fo2h_ŽTI׃zêL¨ þ•¸3ÿ¸Ë²5~Êq³ÚŠ`âYZaŸQYa°!BÚA†Á‰èw,s–ù3+ º]V•ÏøÜò„ý»ŽÿCAÿÌkÍDÜi:~¤anÕC8Å«á_ÙNY+”(Sçúî–Íé[D(Î/µ^&ÇHR2ꬅÈvœ/Ö00ÔôænD;~¡áÛ¦' qÌLÝòëÝ´9Ùc9 éaˆRÊr½ûlÝÄ ëËy5Ba4´ ò‰áîKᲯ¯¨žß`÷7´ßüƒµê÷HŠ<ój`à‰v€±:6{©5–»Qͪôú†_ô” 3À œÅ¬Èy.Õ ~væÈDw6BfHÛÃq~Yø QØòi5BþÓÌš°vFºßtn­9ÒÄSyy6k =v¯›a¢{“Îz‚¨ £ax[}Féîõ'ë£.è\¬^éXÝ¿p…Kç*ƒ²ÿ²¬ž ¨bëúF•Ö]½'j5‘ïÎv°‡—Ï<9ݦÛ]®ÃüÖô”Ûþ:ûnÍ©‰SÎÇ#×ËDyÙlEüÂ@{Pú_èG‘‡,ay'¾Ëùd¡Y™],ƒ†N ¹ãOïlú@%×eöVs24.Ñ B –îHËD~xl£‘%N»œEúÚÈÂx<LÅQYÁ¥†½Î!¾O¤É~ãÀ”‘ªÓKC–Ê$¯¥_vÁò6f´çáC²„g¶¼pƒÜýû† ­7?Xºý¡5éõ Ӊ÷ãȶ6wÄãSo¨–`¦yÙÒ¶ ‡³·HŒ*ÿ›zMD~aÇõ®»çèG®]‰Â`ç^1¥±ÈÅtµ“ù<‰ ç«„#…”aÖL£û<í<¢ ,Ìs½ÕKó�pwÈoßO&vhñhØ×! ɘÛ%¨*ßoìÒaô~}4Nì” 7¹ÅÀByÝx£F*& ¯¦¼Kº‡Œ—,Ÿ¥â'±5Yðöé+ Ê÷Ū_Q1ˆöÿt]ù×ï¥AÊÈ»/¾ù«—oÀì#ÿÅ8koÅW( l'&ýÎÑl¥2”à/œ.S´mº‹+#ÑXÞÍ¿|` ù"N¸åTöSv­"FytžAq|Ï¡]=‹mŒÑoø/à•i¼ÂCÑ®ÀãŽûÚ9ˉ.m;Õ;ÛÉÿQEÚ·…*¸ dÍ5å»ÍÇ–M6døÀäã2Ye™®O@§>fžGIê× aIG7K÷åuÆd¥Êãæ´ w5ç=sÿüc;cŸ@C·D –ͧ#JÕh¶Ÿ0æ|kºÍëË4Nƒíñ®'Ðù>~ç`*5U¥9šQòÞf±RêbïÅ ´Ý/œ‹!,1ŽÝì´Ø)ú¸<0¯bB^ /×æôZÓÌÒÜŸ1–lÈä®úCN+ Ǽæ'Ö{¤åþ/:&>íŸÙ÷;º/v|ˆ?.ã“aé‚jDüÌ’8FÄtù^‚¡ww_® 7˜?ö>ùiý}{Nž•¬h1S²“¼_­Ú¯?±]P aç8Êiæ¾OTœ6¶»Z³¯óÌÿ{¼Õé°ƒw…T'«‘iAWÑ7ç“àæu=äS~ŸˆdÑÓo»‚’ÀúË“¨Ñ“:éhì›zv¬DÅ÷Ýû »­4ø‡ÔØOmNqPìÞ ¡ ño(j#j|žÉõ–=á."k²jÜÀµ1íbfÁTI±«+%oÿy£Íg¤ªç}×\Q(öh‚RëêåŽv~ì ]À³ƒ愪òO'âp˜ý±wL'Ûø“BPæ9?Ñá¶ÌY¿ÏžÍ&m0̦ꦞ}ÓlÚ¯ÿ„¦ öÈ@N;&äôæ)U¨à‡ÍCsv;zh ùl.çQžˆWÁ {ŸÉ©Žç Ž¡¯{DžâcÎîžsÁè—t+‘}_£ò¢sõðì…™ÚŒ§Ãà ÿÆ7*¤PñK[˧…|ˆ�×ß`¤LÁÈĪ—¤üòÈØ*±OÎ)™l[çD¢k€òÌ#„|f^h ¶Š¼¡}ÿ7Ì!sÇ_ÈŽE\µ¾+6äFXúÒ.Þ�¤¸Ö“GÜ~©nõtVEV± ÛÉíÇ,š+mò–ôI*Ó‡¨’)]5Ù‘J$Æö Òz0çkÿ2ª³ '‘±ŸSºoÛÙ•ËbIÍ­ÞËЭ¼PþÎÌ.»‘þ-’uOýò‡ÞÑÊ&¦]<,æ{\N jZŠÊ³Ÿn³Q¥Ô›Y4¦yî{Í}™Øi1Œ4êXúÓ]b÷Í'1(ýù×Ðɱ” £6Q£KÕX1ÓH]È´*¨¯-˜<˜åÓ‰ÓÉ,ß\­ŽÇD)o"Ý—@ºöéû§!ú”±1ÖPñôJÌ?o3ˆHYôvæÓ-Â@yðlü¶§¯¶3FðŒßžØUl… 51¼X6tÈCgý®ñAâ×4 ›´è'†ØÅöuÊsW”/ý×ãs,nR„7Ê—Í”ɶÖ3‡Ç¡ç75(Ê@UÝä‘Gs®65»zQÌêgŽĔn(Ý *ù;Æ™N×_j“G‘3lc4I0ç!´­¥¸†p¨MÑ@ŸV’ò‰}Ô‘»¹«ï£å< WšÇ)U;”—ô>OÄŽâÌ×z艻Žg”0dê˜Æ\~>}¬ô*®6àk`=?²ÕÌ<×m¼ïXPˆ°,z'QObÎ ë›× Ý èmcÄ!‹ýï˜d… ç#mŸF/¦ó6'äýß·ØcuÒ±uÚ,õŸÃy¾µÌ~,ORViæ¦ú„v=¥³½ÖÛIÖ¼n<µ5‡ úñÒ=à"sb9´(± Ê¿ƒSKôÈ ìŠÆ‡j7uPþZ‡hck*á F­Ps iµh½{øsu0­T-§VgD(p'´½¼4L4_ÎÌfsAi] w™Ž·œ=æOƒñk„¢SíÁ¹pó°6ÑFT/ÑzÌV -ÕœjÏÝir:’¿s> =ñM:�|¶øÜßáp^³Âξ¤e<µ ”Û!Ø—»Ñ4ôÍ°€ë )(&~ˆ÷azc uì(SY¬åxÈ“ftY+2Šù‹€ÖäõV4%³ÜÓÄØtx„{Õ%ªbßÄrÝ]x¨¾èrœŒöðhœ[|Ðò·;TEÔCÆ:÷]ëîbýÞJhËùa—ÙùÓ ¾0²–þ·ÆÏèÎÌá¡5¬(òy÷ÃŽnLe!‚ÌËowF۵DZ2n_¥À  7<Ð@ªBÏy/‚/4Pw[o6 =&:Èy#ݪn}WߊÊÂo0=4UA±o¼œ–*Šë/ÿ ª–h#*Ž 2Ƭåôå8!÷„’^hDªz E\lš"ȶƒ äb‹Ùtm'¢'½ŠS舌8sŽmÛÝÙ(16ÖVÔH¥ ci‡_†ϧpÏ„v”y¡Û†Þè½É $ÄÊG›}½ù@‡ãîÕšëŸxúÆ1;­ìséjoAŸgÄDÞ™ÀIf˜¯”9u3‡x~ºë¥»®Ñø ­VƒlП(hõN O‹ó[¾ˆå4©&åcÉÚ8 }5ZLÍAd¹ÝlIP_–ýÕoçAÞ^Œ·ï7õ㤰3N‰;tŠ†ýÕsÆ\®ý Íñ#ÀÚš¶»IÒÇþ„¾ŒÊªB¾ùJ‘¨øïê ˆ]×·»?EŽùÏ!†½÷ØNnû×+Ô(Ù<´ H)þÌñt¡œúzÿÇïÌž¼rèžwÎ@ýœ¯&I…ÈôtúRYTsá@{-;-cW.±ªèØ%tFŸÏžÖ3V7³5y>8šê ŸØLÝæãvøévOÆ¢§^Zwd°Y­jÔ�å€|ÿì$® ½|ïË qö€ æÕ­AHèÌêÀÄà€~ ¿È%·ùÍ·›î¦5"ÔQ}ŸWAÕ¨($4©r›ö§Y ?TŒ\gÀ¸í…*Ø×ÃNègß~áë*±I)ða×,—Û龡›ôtWõÐb qI»ç=¥”öRQQk€T:íNnÕ1¬RS±A?²ƒ x×îDQV_¤£dE2 i™~PþdÜ’cì~¢zdúã ç*{q¬Ù Ø ‚]H‹“*ó4¥ª_GM×µÙC“ß O ,D$ q¾š^üµîW±2És]ÿ<'>}ÁîKGÌÅyÍ,. šo‹*¾B6‡Ýëyb‘¹”žÿÄ2Ó#N‡Á›}°w9§®ÝðPÛ{‘ÆšŽóïÿÒÓüÉ À{`‡ÕÍTZŽ<YÉØ1Pì٪㇮T\¬há  £u ›˜ÄèœLTÚÃÚïN´1¥5T?´pg(H]îL>¬(‹Ç îäAe iñU¨ˆ7„m†"M4X VDÿ>“Ör_”Åè]Æ(vo•¹z‘v¤;4ó¦Zžói–Vž¹Unàá’2»Ù_O,l¯ÚVVÛ`u`Pfs )E$÷(4ôéêíÖxÜ´\Q§*ôÓ±Ÿ'‡iš:×·Jùøe#Ý‚bö9Bw�ÿöbá«™á(X—I^c]-`åtQ¨Ÿªw¼ÝS‰=w›L Ñ ¢hEÅf²ŠóÁ—&F‰gŽ…aóÓ-Ûõžî/˜Ö˜Ka…7x{�J,Ж SŒQÅjïGÿsƒ..Ø}"·ühVíæ~ºóø¾Óüý‡§63e»ÏP">è·ÀÇ>ËÂ6ò´îéÜ<§Gš°¼ÙËgÄ‹²GÆnWS*·bݧÀ¼žk“±õaÇä{Aÿ“æ…'_ƒ„êax$%óèuÙ%àQ)¢çßK6I2V†2F‡9vWm©·ÓµïÿsýOsºôœ[¾MÝ–Ö€-Méj/}ˆÚŽþ‡¯ê‘÷7Ù¯’ . Rî¡Iû±í—dášÚÑB¥%©ãÍLf¦ºÉìjÖñ³§ÂŒbŠ™ è¾Q­jt½Ç XZÎS›¦2qñ2aw„?-^ËYËá5¦±ÅóNñ.%€¬e·ô²"qà”\D£(£ /ÚQf¼Üyêa•÷ Ca7æPw™¥…7Ëùê*kVa<!3¾8Ãlï—àiâ³þ·é?Ë¥ëÚ{¿ú²V3t1þF¦.ƒbÿ× ¿ë+V®¢”.‡öMkïw@ W-²— ˆaÉNé Þï“x@™!¡¡³)ñô5fXÚ4}†ÙÉ4yÞí,AŒ–äá 7éÝùÐËðáÞ•3¦H<5æ¤/º%U«FÒ¸{„Œ• ~â~O»a¼$]ëÑs#ïœq|Cw)9÷6.¥Ç“nJJ:ÏÍÞLã^‚‡YÃe‰~t?.IPŽÚwÛœN£¨rÙŸ¥+ñàz³¸ÎØ£ÈÙfÆþ³èYäõÎÓÞ4N³¦p—]Ö¢¬À—…õÓÈS0ð-JÕÃZsßæÔvýv;Õ”h¡Ú(S·/…ÙÄA1)u†âAVŸ]’°¥[} -¬ PÛý9ü´ó®„• ÊMJÕ4ePõZÇ`^~´'_ƒ¯Ü™Rå×ÞŠ>F–R#DŒCìmþòŒ³äQžçB»Ÿgd!Œþ þÉuj"cBº9Ñ­©êÉÝ¡ËÊh NoŠÛjMeCO{ç÷&‹Òo¬bØÁB[#VÛ&ëÿ÷ýB=X­õ £Ø,Šöâéù Áð\˜ªÐ@Íãây—X‘9^=¢BµYmR#¸6‹N®¯ ½ÙÆQÛ‡öÒœ2÷í^ãR‹æ…‚ „ð­Í˜/݈„fЋ%̼O}§ìezÒl-ˆ[oÖØ)1k3áÊneOFv¯xö&V„»4ж®‚êl?vŒBÁ½vXz.³(áÝwߥSr(µÝ“q]{=™öüá9�«"Èé<pýFì‡ R%ت2[i;˜ÊÊÑ!c0­‚ÝËs?Áij¦`ÈØ°£7ßéj®0»ëÆ»n´ZL<ÿš;¹Ÿà¼B;&}ߺ¸ékªÑ0Ú7w©Ï’ Ë«)Êü^‹-dC£ÈA‡)<Ø[Ë¢ËXõ�5<Oïpdk×îXÕËóЂ ú¤â½â&Ò(Pi-¡¶Ÿ¦#dˆìˆàÞàÁgå u_àêªß16¤š‘–T;Q”惟þ— r0/*Šå©5L“©¥Œ÷J@Ekû¼ØÂ-Ãø%®±Õî7‡}´=m¹ÅêUfµõó´sºïJÌ·ŠÌ^êÎ(€ñ„4zÑ[18ºë|T_$ª~h{ž& |w§Y¬‚o^ýç˜evÿÐ ‡O'«˜±–­„ö\ð(ZPß-2Jg¯Ç'ØöšI7˜43c6TX,wJ©Sÿ±5Û½_qw™»¢?Wx–Z‘ S¥c­&ÑeÒ gR—ˆý—zpêÃL¢?4ÿvx:“áÔøt6{°j……³zbm1im‹$¦ý¦Ò¦ÕËØûbEé·Œ –{¢""ç‹ÿôÿ¾Xi²GN×{æJ¦èzåÝsO‰ÿdßåEö£$O§æ`aôµQqWæ8äÎĺwþ]»²p–¿2}dí§c@}§Q‡Z2K3¯ZGúyæ]í†Ø ².1ãàÝÍ i¾uÒ»vGåá]Iò—€i¼‚hÐJ ”0o¿œòÏ^ÆHªüso z×üʪ&gÆÉÆZðC5h$4¹ù¿s¢ÏOç¾q˜®$áÀ[.…)ci \ìSæSwÿßÿ¡/Ù_®È:ÛK Â>}X ǯ.ö›;Ý@nŠ ²Û´¦5´ë¦ÿ}‹ÊÎC;um­¼†¿òÏ‚O•ùFôH#Š”Fû´ú×Ý?œnÆà ¾‹×Ä™q²%4ØÃô¸¶ó•`鳤¢¡Ê‰ñ#æ0GU˜y#À˜Ö[Oç°VOÝ®S8%mßÂzΛažãw;]‰¡r<ʲ¦y=áÞ·^ëÄÌD* üaŠÂ‡iþxª…‘/õæ¬| m:kn¿í O`Å­~Ò»Ž#ÕVRùõ±\G»”À§ ÓL’±t×n-8moÀ¿DÏ:÷5 „ÍJ§³°vÌBÁñYA´µ;ÁCTYîlâÑã´£Ѳe6õtpP`>È3ô-éÄ3̉۬ª×e4æ½¾ñz~”fÞx°dAÔ�‰“¨`×aÇ?ͬW ¿ 5xÝüï›ÿo¸ç/Ñ+ÿ(0VÙʸ'%kþº`NwóøFi%´i‘ ¿;í¯˜” —«ù'¦©?ÙFvßS•Z,­‰O%«îœzŠ7ƒ «´ª.Þå7ɆÈÒ¥2 +=Ÿyt-e¯ê ß‘ôÅ‹}‘Hé¹Ï5 K{¤gvØÑ} Ãr¹e¨åŒ-Ç=e¸‚¼¢ƒb»ûG­œ¢VVüÏžw·P˜¬<}nîPˆ#Æ{Æ ¤¿n~ú“ÑÙ4½:V.”�•³&«Âùfâ~ÚdÙ}Fh;+Ö']jJÜÏb…1 ©…¡_âçBÈÇa£,@‹A¡=…ä™ K_ •ÆlE¥_P -³õ°±Kƒ¬~×a¤iró’Q ¢ùçðåä£*sÿ§=ÌxÑ£Škp8$ÎŽ”ð­”&Œ¡·ôõÖÆÚÛ,ÿaü¢™=ÏfpÏ'OÎèwºø®ÃXòs®(Q\˜-ß–$gAŠ(Ñ£ÞÜØÙüžmeqèOóD'›J†w­Û6õÿ÷ÚÿïÿÐ]6�ùã§KË6/ªeÇavƒbé†*{ELYgÇ3á¦Ú©ÔwSX—A1 —VÚ_ᢜ…éW‚Æ?5½¢Ä´™6DOô¡âQ7oUÕ2%bs 5$ùmagboÒ<ˆšÆ›X»¡¦3[Ï5Âߤ©#|‹ªmÝW{çŽ4ï'Õá¥691öõ¢dr$·oöç[yÜoV0\¯ò ªµ&‚†Z È@x8ª k_Ï3š•+3ÏØ<H1ZÕNƒ/ãn{sØÔ«Ë|G‡0ö‡Œ„iöUL›û| §Kï{;úgûÃk6«uK›;±—mE ÇRŠs&ú¡ú$pö‚Uˆs—ÑHÛ©Þ@>ò£ÓCIã•šEí$¼Ñ!Dj-5¯7}‰Çð# ¼paçBô¢öçHöÚ› JüE�3¹–4�mP”xYW&/¼¯SbrÓD”îu_Ú³°}zºu/”Ü`AEÈ…Û¡½õv*«ÔŒcæ>ЬìÁD•¯oÐ_[Xh’d¡"d#’iÕO½ÑË÷3HúÝà—⬫ùƼç7ÒNƧ¢kï¨a8†¾˜–è±Óüùé¥Ú0?ê£N")sº»Ó—ÈM_JkA•i=x†m{±KàzU·ü-óˆÛµfªš³ìܼšw¥üöç–Kÿ÷}O¨®e hü¬C$@ÂYµWž#‰2Væzs(mK%)í"qQ´³F“_ð®\îß¾ÒAâ%ŠÒ™ñfm³ M1å P"Ùª‘òm`:¾ùÐWÃ_½ÅØq^Äë'„õzÁ¬wù¢i©è EO©|Ý#êßÑA2-ª8å¡OŽÁR´¼{<d™üpÚ6@Ž•¢Ø¼¡¦ˆá ”H÷®Q|¡ìi¶‡ºŸŸè‘VN#,bÃãºÏE­Q&Ff,QßâÅn Á|>~ûù>WÊÔX>}-ìTù;¸2Þ´B ˆæpX[ fãID‘÷ÐlóÑÏk=8Fð4I†Þ±DͺR0ßêå'ÿ̳iå'3¢ƒƒÏÄž3è¬Ú: A²2<ÝÅ%åO‘yÚì&;_h[¥ó»r[‚EpÕ"¨k‰÷´ù uèŸW1X0@×Ì23§•ÞB-uŠWè“u‰ó$†ö¡Áés›+¡#ëÜxó2<âÃàìƒð¹ºöxæ‡{û ZzæRÀŽV²R†t¼Sâ°UÑ‚âT{qçÚ£YßeYù䳪ðg€aH o¤ÿ^€ô$*\ G”™¯XT"j„“U|áÂû…‚@\·=åmò†Þ¥WU  B-ca¿õ\¸am¤ýŒ÷}Á½& 3ïÄhJJέõiˈԚ’uÜäp¾MÏ~¼çƒ¦Í#ãU±­v6^ô< ¥Å=Ñä/LP=ª·` æ.¦#û]{ Y¢ÎŽuO÷l¹ÛxÔ6Lüj’QÇœÖ%Ö T©³¶X£ˆY»&OTaÛÍële&Vó—!aöŽ“{P+c»a Òð{!ª¬ Ë)Òâ-‚äó]|‘3Ù>»)TQ3³ºŠ¼>Z¼ %x]jG2Ûq‹÷Ðð“pVèF}£ÊTÒv{qLJ%÷0Á ·ý{p#lë0÷òÂUþqÿ¦x.ÈÏ䆋r±7ætG(‘œÎ­vXa'�àËþ6-ÝŸÑZuBÉA°6Öc5¢ÿʉ.ö1¬¶´Ì1žþÙ#Pó=‡–Wœªìßø² |ƒqk-Õ xƒ÷¹q08ŒdÄc½;¶›¶:¬L!¤ì-÷"³0"«ÜqîùûÜW¤Èó7^]!ïîÁ[nÄ,©¾y¢åªÊLž~q‰õqoVnBžŠ¯:(;븂eúv~P §¹ÃRˆÂÕ¼.ð}6)¶8e¡Ù¿�ßSæº6 ŸÁò q2Kº˜GfL½A1Ç/1¥s/ͼ?ˆ´‡ˆdê_Ý4§%à_77Òäy|£p¸ëNF³c"hü̶G•8ïø‘™&°D`ø¥ð#JGÄ¥?µlKBç¬CXþF20Ib«èÎVK=lëÞpyqš…#@©wý~ßQfç«âv°¡”ª˜Z?péØ·EÏUÇGúÇ6gú¶½ì7I&µP‚‹1Š‹˜«NÎ ½•¶“ɺ¾sß²ÒןD6}¢¤Ÿ½jÌBþ 3‚'~“°ãbû�ÁèÎ(Ï<ê²]Á~z–3ٳɅ6˜î«¥½ ¿ŠbÏ�¾”&JÄ‹UÒdòŠa®ËÝ¢¿möƒ½223œli™+j#}‘cœQ_ÁìœÇøáx.®7'ÎCçRé¼ÒwöÝK“!D•!ê-5š¸v &,š ý0wº§p? ºƒÞÎ(/¯I¦�Oq2XÒÁÓ˜d0ûÏHçþ“ni^®† 3U“«ENáÂ(GWEUÔÛ,fM!:7@—«÷Ùxã IÊÏ—¨­ÃëÌ£¤,씓á1‡*e.°§h”ÑqÆG)XZlEÓfó‡þH¡g¡Ã‡)Õ©p}ÐùK‘r—æìåWÔ ·zjfì»~ÚJÍŸúrõì¨^3[Ês§‰\²eá™Þqµ öLssú÷gF¡û§!’YbÇ4 *k<]aã×Üv<OÇùÆBóùP†²þ´È,÷ÖåWz×sk3G‘fs6”wPg÷‘hκMSõÃŽÖô¢Ñ ²°’öp(Ù"æeêZO¯dœ3 ª Ÿÿºô‡).¢°yØ`ä-ƒ€û*#áÿT)m›&âA± I²=ÄBE^Õf¨|( &]6íŠVíñPMLFàîM´#†Ï%ž˜OÁh]y¸•ó¡?ŠØø­ ¥Åj𑋯M4yâÓâl(ÍüßØ8È_dDÜ—mÁzuöh:Ö­¤¶Zùó ”=´tò¼/SGŸC_ÐT‹m0ÉxDÂ`ÄÖJK+köé4æ>Mþ¬ °ff ~\KB?ôr&egk VSA÷ÕZ2à¯pÙM©¿?Ó®ëOb˜Â.ó>­¼Ú]/EÙ oG!(r gó{_÷îÜî’‰Åí‹–…)”MÍNòR8ãdfôn©"°ùå+Nô–@'D­úPôæsë¼Ç€=`;!^SÇr4W,ýÀb•Œ0ôr…Dà9”¡YbÀün¦s3¯u—_sâŒþ'3½6¤:ÌÝâ–B¼»xhšýy­£û›ŽBäÕR©ix÷=´4«<vê#š\Cq•ÑüF†»<‘yN|ÁÖ9ŒtNV“î7'ª‡z˜uw<˜ÛwÆÒ¶~<,ÚiµV93¥»êº¬öï°ïÚ/íB!}ì,ã鲯Yg‰á2�V…^¹ÅŠåí0 \kAaˆRæ´®uæP°3 sßí¿Ùvü5žœ=+C;ÑÏbéL+3‰*ò\Éÿ?`’º'Bì2WAfï «TŽ‹VÉ=W²Ï@‹e¸Åªyˆù>E¶%ŒÏÉGŸz4ݾº:%ó©Û”'Ÿ¾â êßa¡kkÓÜZ ÊÿD gõ²ÌsS¡Ò±?§A9*_1ãæg–¥€ˆæUQWÖ ›U Ú+½‰•¹SÛÇaEë[\¤™—ÇçŠ'¢*'Aºª;ûÌY*¬'F׃˜÷’]µJ†!×ÑÈöÖÀ 5ÀL§u*ü›™$•µï£ÝaŠ1åÐÎ*¾h-ŒqÚâÓa×\u\Ö7¦1ù¦:´·?z²³EèaÙf-sYfsæÂïSp”Óí6ÓG{¥nµ‚+0 “Åw­øòâF,bêƒ.êþtõºnöõg½e©øÚ,‹zêñ5€g¢‰ŽNëÚûÌû„*ãzž–?׎ô¨¥°>õi£õÍ¡í«Ù㤸'E‘ßÀ¼ÜOò‹Ìü1s€6âY•›z^µ2 Y¢Ðßó·Âþ7õöãKO•*õŒôR@;–¹ ºªõز}÷Ǥn—+¨'TߊÎþo„±-SQ 71³£ã½ÎPDVzæ…-#Sšðê‹$é2öÏK^Ҡ蕹€@QO»«“Kê Ö\/ ˜Ê=lœ“¹'ØŠ‡ï¦2(ê½·ºlfR¨Óuvüù &±ÆÜ�¥1Ð÷OvïÎFd_ÿU* þªí›§Ë•jFGiâ"ì¡ 0L^d£{Å€} NɆMß>À ™3{݉˼”Æ Ø$‚xA9ÿY£ Yœ¨öîÀˆ Z¬NÜ)Sæp{€ÒÍ«­Q¼ÖD3ÑG}ß{E n´�W™G®_¿sZ²ì†¸‰#¯Ur~ëAZ5Œ9R(¢I4º²¾J¢³žaj¼&´£‚!œ&M9×¥kæÀˆQë°Ë ¶Ù{o Ç‹”Uæ;×ÅðßFV=Z•@öï–ZMqp´ŒÍÒpWw츙=`b%ËÆ6û8æ#/´eŽO¼¶Ý$lÓuæyògV;g¢ˆ¾sl‡î’E(œn<|ÙøCÕó,YÙl—Áæ’Õè²ÿ9�¯HE”­¸}l"ï€P6¶ïdk‘RƒC# q©é„.vÚ,ÄG¯Ç±ï©q<a°ÈþIÃy±Õ'z±Qå±)$û: ªZbyX¼Üîé|�˜Ì¾>ói=ñe1ߺPÎYÖy”ußJƒW oÍy>ÀôJ £çá�­@OÚwSØdú_:Cž»Æ<‘“jC#MÑ %Opª’ÝA¸‹¶hïp½D†Ý=dIE{‚›~2 `´Ž‰2ûš>e­â©ßæ�¯\€ ð åòSmÝSvÓÚ µ*„ü€QvÉuÊ% :Œ¨ßÿz'Ÿìz/@7u¶Æ›ïϽ}ß 7ÈwºwÏ\w Ï{*éP1õ]wdžÚˆ[¨Ês–TúÀO¶é, l5 ÍåÃrðÅ„úÿÊŒºÐb](}øO¬2`qÛ}cñdú¶ÀA6Âò¡hü›'A7»Ý{u§¹^zd2Þ(ÕpÔܪ`]9�gxkÝJñ>’N‹5T€žDMK§Ù[‹Ñšuîy8"½Ù®žÈEÄ jÚ)y}öÂj.Vng¬%–¢œ•4Ï¡ß ±5ßÈp'ü2#ÑÌ)mÚIu}ÊP7íˆÿx€¶iW[¤ÝÆ4ÊãN‚ªº¡²á¯ÃÙáÝ¥RÛ¶ÛùíTØU/zÿ´2¾Ì·¹Íš¢Ð & kšô®çÎ:ULšœ×Ãý {gïV±GvŒ0 é)-`¶V9Œ‡åFÕûñ�#Zåö¦…Åå§B¨¡lšÓÙy½vT®ÌUŒ!DdN ±‹ wEmùƒ„“Ý‹” s¤²àzqªXÓ»Þ¾'Ú†¦ŸD9˜@^“—ö]¬RãJY¡U�ÙtG°‡®:$w?Kü î´›¨}ŸI9/ŽiWE vË9?ÛÄtDnÑ/ða¹CöŠ±kÛS"‘:‚-…*R#¾Ìúl;È0ñøÒ»´’Ý*ÐK‰à­ß{Ö{vºìk·h^ô�ÌÊÌ#ÀdQQ ìÞ½F·¤–†>sëzýÐþ:õ‘SÂA¬M:«ÎqÄ®-húGb­æOQaÅ}ŸÓÖoôPà õÄ&àÖâÔ_¹ê~E`©(½‘OÅê´°ry×]µéÌ¡*Ôþ7ö-‘׈  aJ;»Ú£5Pj³EÈv:pQ³a ­«Œe¯+=¦‚ ›†VcYëŒ$„dÆ”ÌXÈÆ[3è‘hé4..ËTA2«L”7A`õ…=bÓ]óÈî ¬Îíe~ _±æiâÁ^8 2 6ˆÁ麊,›Nx)¿™XtuDëí‰Ãp»1/ϨX4$nô[ ¦l˜'ÞËõ7Â!±¯�ͦ¾£bêÝöøbÕ±J³Î¾zá•þ©=À¦¯¡7s›š&N*@ú“3¬q·Õg8yvO±¯GháRÍ6ï»­Äïê[~äx¸Ò¦üÚ ®Ìí÷'6ºá›ÓNõÕ$¦´ð{>Taíéd*—Ñ¥\=Ä-‘;X#ã禫Q•­Zì´ÄA¬ŠEYȦ ³Àª pK' 뇖ª)Ÿ\ëíÅuþûNš†‰ºûìÙPOµ§ÌHñå;c:hàÞé†ŠÊŒË yeCIb6í¼CÑtf0Ñ$©§ÑêÞ…3,ŽÝäD‚ãØѾÏ.À˜!‹xµÒ_Xo,jÂ1s†ëŽ}Õ7·E\¼™Ç{©ÈY¸PVº×þI¿ýç-OU«ŠÖa{°ƒã(ôÝù7ȃmëGRšÉ;Åùÿî8»©5h›�¨$å+=Y <çã«sö̳ÎHñ(ºm±õŠ€·.­Á¦bý¨Áè=Ã'r‡©§ú–óŸiÈslKI±ûºñДŸ¼þ ÎÞ ‡åÆlwÆ“¯:š5Ð+z{7õ­‹º9µWr·ÏgÊ=ÄMû,}òyÈ(§iTì<ž¾*»MÊÚâ4 š1?q´d‘Ú¥°0!I~žuÍÖRAG°ö@r"dqPLÍjKtô¡Ci/{Ù;Ëp€6‘î.qòNëf´Ü†Íiêýü!߉I莖“›s µ,>€Ms,¤ý® ;)Sôù²òdO0`•qfõ¯ùƒm½µ[”\–è¶ÐÓÚÑ¡“û‹‡\~‹ë ¥,ÆÛÖW^®´§Ø~ŒvÞþÝ ¢7²Ý¬•ø{ÿ±Ä‡¼—8wY»9ÙŸ³¹ÍÉ< ix9¥æ—A9…Ôž^§>A5k«;I$Of7 9$õÈêä ¤Vª[¦K÷è·´ÉGæDö´Tæ¦NRÓú²Çr{¦£ UÆ‹] §/—™]Nu.Q{‹ëeq}Êÿ|Ãü“¬^¼Wñ¢UmVe¾µ'µ3•Ëäþæ3Ëü›SsÞŸ:üÈG2ŠŠ|ùÃϼ0Ûh~un¬ÁÚoãH‚ò‡÷ú ö ½3xÇ- ðJ°3U—Š7ú|¥“tÙšà—Ñ„Ÿáƒ[D¦ÞýÙ8¢rOR "vå)¿.ž»Ãþ<ð}ö§‘‹BøÆ÷áYºË‡XþŽ ¯"öaóÍŸ,(¬z~Ì®^‡¿·š}Cyô°À€A/¾££"SQâV:¥Y«Çs”TzØÆù?t-ø.5†ÓÛkÁ]R_ÉtBËOÅ:Ø–§Ñß•!¢Â(&‰¦qXÃŽ–sù¥$L@:ѦРÕå?µ3¾xƒ×„¿å+I옞 #ª1ê•N÷C¸"x;mD½ kŒòÌ‚®…95E-Ê¢_ñƒŠ3Ú>³)U(©í®ƒäÚ1=Ê5tWlžî g+:–tÀ ~Ì¡clôì'ŠåœˆA¥ºþº>ažZÄ ó=Žô³u¦Êkm`Øl îµI~ê˜8’ ê¼Ã)¹‘!ÿÒ‡E=ï•”0T­/Ó¡óôx~DKD¬‹ï¤w LÔ)ì52†Ä–ý _Æô“^™š;ECâÐv»´T=Tsëcš3N1j ɘ9Ÿ¼Þö3-§G˜6 {‚ÚTØ#]ʆ®´ Ø ôÙ�5qS“„': ¯ŸÎðh[O2ªì"‡©Up‘Ch:4Í7•g»§rÓºhrútͨÛ?vG‘1©é;h² ÞÕ7¨ÈS.õ´¸òyïò¶š äú(¶ÙØ`´´gwà,S²Ø^¡ß9v?¢•)-¸Ø0úUÜÓµÍóâŠæ¢"svÀ1]P—ft½fmŒSýø^i—‘­Y¤ƒÙ^Ë ëkïÔ�QÊÕyÐat=Óó¤ô§÷ÞŠ˜3+Ì0<‹÷³‰f”†š=è@ÖíìÛ³"Yé±ÃpÂõ¥…AÁj_/óºð“\kä@ë`Ùc¹Ù0ûMÔ D‚â–@ÿ]µJÆÅ£‰¥y)E°â"‰éôˆæ‚ù"*‚§¯—Ó‡ŒöJ¸´‹y÷Bủcîùˆ3”ÝX«šøœlè0ï׫Yžl[aÿå+( Œ‹}X¾×Ï ÐÈ­š1¼?'AjeBùúZlõ ß—­xû…�UÜIõ䄃¦<©XóŠ(1ô»c’E½8ÁåÔϼc‹v?Éc¥EšyÓ!Jç ž0²B*cqnÔž„žy-¢gÝ¢ÈQh+CC˜{ZÕfZêÌ:«Q){¿ðMŒÜ›¥^³®XUäìsa¬I­tz~œM›?V…oÿy«L³‡*k×&²g†|bŸv’ñ�{Ƀ¼ŸM)É,HåžYT È©¶¬Qw¢°Æâ0÷QÅqhg„Æ»»¦õÙ8AÎv:]O¶ÆùgÒvwý½mèdlcCÀ=õeMï8):õWÚ›/áÿâʵŒ@LD|¡0°S¼öqÏÜPéÑ�.;îFýÊ÷ÊÕ–•Ž ¨L‹§Ñ|"2 6¾ë¿¶ûp*ã…á5m$“ŽUJ£_Á 3•’~9úp`»Ñ,¤'Í«/ч²c1²»4áçŒÁfRœ=bHŽfsTiö¬Bƒ„GÀc[Í®QšÜé2¡b8VH·½`XêË£Û_F›c°¢ ÈéçïXج3Ï´ÆLô§ª¦S ÓÞú  ƒ ª¾y ½ƒÃ¼©Y<j} åi^ã2ß˸½\‚[ê@JfËN Ñ"ÜDv‡|1ÅKþ7étò S‹îG \ÕÐzæ¶ÝÀG¾ù3w|^p@*<nBÞQæa2¶NIJ¾;²L‡$weÐC7S7²û[ÚpYý×°̓%ªYŠC{çÂg–—Æ2u„&IÜŸµtFþ³cœ¡Em—ÿ¥v¿ísªÆ óC³ùâ94‡ tÀÅ3Õ oŸrC#¥üºsþ9½=a<À»º·9òiÇŠOÝî0¯€çô àžÎf?CC¶‡ð„ǽÆC ”Ž$2ór¹òèèÎJ°š±¢ÑÊÆqx÷Zâf{ʆ{À47#â ï¸ú>{åÕõ9×ÄÐz±d˜y¾àÈxºÒ÷=¡R˜– ˆqî ˆY9¨´ªÖľÛõÖÌÍ®ÿ©1•©ï Ùä9Bk¨uCzŽ,SkŸõ¢<óÝaZ˜&AÞ̪Ë-s»3û£„KÖÚc¼¹r/ñ!8±íˆÒX!;ÚŽVL›] 1Åg®ªÁ»œôàvW·îõyxÃ_jÊ«²Ö’}ƒ ößXÊRÕ±÷Å o¾'û.sã9æ¤ òîêª~ç¢'ôÃëՄ⺚Ú`à%K)§æé¿4¢—&ÝJØ6�Z×áÜ9àZï ?¡p¯çzÜ{Wô©šÃn/õƒí{IGó £IÙ\á0;éÌÔ)°�É^›€GߦÁèëÆÃÞlð”{³µuÅÂAöa°6 §äÊ gýí&\Ê‘¡5€6â‘+@ö§–Ò^ј~ ~KCŸ0 `ÿ‰b=¸^CÃ¥ºð$³ñ•m·ˆ³æw—�¤î“‡œ¢oVŒ³„k:ªhðÉE‡à•¶Y©š‘I8¼kf‡È‡å’šPò˜lE{[Ù¦+öEã.åÃ?UËp Ý–`ó;tmìB½ˆíet,Ùì§ LFïj¨|m•U¾?ã,–!¡ÊN�ŠœÇ"îòŒÃLÒĺ¼ÁrVñv.üö3ß©ÈU&ͧTÎÄøK5y±ªÇ“Fû•CC’9™/öTÚƒCh\ HÃ¥´„iª·”Cëëm£ÉùÀ®› ™SÍD\ Žt¶D–œ'8DÅ’Qµ`´Œ¼ºJä>óqâ¡Àî(BWûYaÔ÷q{‰òD©¼Ù1†ú5 ¥2©<]°YfÖ–Ò<-â°UÓS£3ý0w¼"ʯAž0É‚Z:•W¯W¢«þƧM}áCF‹Æ«ãÌ8}õdÓПñ†ý»bl «û5>ïYb�ýÆ¢öþé¦îBûu 9ö$w€c¤bª¥ÔlouÙóXP÷'güMMh¥ôÄô‡’³%ñ83Æõ–*‡9ðQz–Þ嚢ÿÈÕ5Î<±Á6y g¯ÞœœŠtc÷Æ^PÕÞ/¨æîÕì>áiÀå,BY;E:wO'VøôüO#Sí…Ø2˜v°~Ÿ<¹9Ì/êåÔ±€È­JuV2øÎ8Ø^édppã„ß”64þ¨A’¤ŽªÆwsÚ󾚒5Sé ¦6ïë+„.g€¼ùñašçà^BÖ¢þl… €+ĶƬ=¸èaÅ㬤òÈjµ|J'šû$fzÑv1rw; EÉZ¥I$ÿ…ƒ—œ¼½÷gå;ÖëÌ>Ò€ÑCÝÕ1‹+½Ph_’îLnÂJÛgA±ÓŽM›m¬7O—ŸòUÃßÍÏ÷àÌþ¾a.7%ª€Ð(ñ ÅÛp2ÔbAKskgÀ?+GDm“%”ª@Ÿe< Œžk°Yœ6¯¿{¥éFY…kòx¢Ïw“×Iß³ü§¦«rõs‡F‹hÞ¾†¬{«A ñ=–g ŽÆ0 ªº 2uþ¥¤0‘bD¦KI­»Š…zÈñLZÂF~;¦””—Ð -LçZ˜Äqìª ²X~‰¦Í¦Ï¶º€»àOÿp²¯ª¥Â’¦{Eu2­›Q«ª*Óƒ„ÙvP ù>#ÖøøÏÐ0«ü£›þÄõDÿHØì“[,(ø·' ¹qýG×ß)Vi¶rN“¡{u¾ª;÷òIþq˜˜ˆÂf;1¸ì!X&÷Ðdè¹ÐÓ@³¿z«v㚆™P ºÒ]ðó@¯‹éÖ9ö.CÆ!ÖyIEÎl­ÌèËj6Ï3|Ðèkô»nY~"„•‘y\ê@E¢c5yÏàÖ0Uô_iW‰ ‰y¥/Ô÷OsgÖú±<PJÈsƒPãnþüqí<“à‹—ZäX~Â-ÝÈ<•Ó²n½–ßöôåcãܕ8 Ž]f`¬&-‘&0Z`A'>wB–}ª…ïëUÅõ0Bg¸xœÈ¦«ÏÜR°L4 9<E›ë/¨Èð JRMúßÔ`¯{©g™øuV\Q¥[o™I,x¢Mmó¨=Ǿ›—oÙY‘8ÎL‚(túJ ³×€¢;Ôܹ¼Ç’¹!ËÄv(²‚`›!;9[Š_ gŸ0 €ó;Ò;cVsà MÝWæ4¸Ç#Û_<)¥ .þ…Ø“é½+U ŒØE&ó°‚TŽ/ÈkÂxE½nÕ«Ù'Übb(gl%FAdthvölm»Y#ŸÃtº«{rÞ:±Ž3^í¾hŽ;‡¨ú¥ÿ¾SHÇØWuÓ­¿k$åMˆe ¬¼VD •*§þÈÄWîe¬_+aY¦7“ˆéM;¨Š~Y}çujƒ¿µìâRnädè¬IøõÞxEèÞ´)¢éu¶Ö|ê1, DJð%5ÔÙÄ¿âÜPº0`ÞF.é8znÚýšº�Xê JŒûfÖA>1Lã¡ Šæl‘g–Yà ÿâ[ñðBžpgï©?D¥ç•aG³NžA¾´´BÏió¡ñhú–¬ÈÇ#xíL•€"jZ»¢‡ú[ö@T•Y¸RËÙõ}Ð^£/DžEmæêù y(Tïò; µˆÜJEÉE•2ÈÙ:…×/‰éê´¹º¿cgŽ¢#ðZÍœV+e8DSæOÏK“óœg£’S¯÷+«DÔH Û> ú3ØÀ–R‡ 7‡4<Dbe+‡.­‚jTY,ð­ŒÎ2å‡~¹ì ÕIT83OÏÚ4»ѨÏÜétû3‚‘³Ú@¥hw¬ÙFèZp%È”Ëq{.ŠŠõC…7Å2ð n÷¦ÀÎt“ ! Ý©“)ù¿þÉÔu£?y¤Ì­Ü-$Õ°ƒÈ¼ŽÍc+.&z}3…‹Äê42š}¬¡t¡:“]‹©*†|îD@èwÞL>$"1¾¼›SNïë¹FSWjhÂóŽÎÅox—ïÀ(<™Ü2ŠY§‡ *£sÓ˜LùŸfÕqœùjó¸å°q9÷ž´1,¶Ðr:î"nGWQ‚[le‰òÔ´NãQg…!8F§·[Ï #í†é@›²cdš+<ýÕ`¿ ýXëÓfÁ¼ÚÚ\¨•p¢t™:ã7/±CFúò#× :YßQY½Ý{}†Ý¥C-ãñ3™ïG^fœÒ­œ¼`Ì=äßݸ i§ö†Ü‚Þÿã9+òðD* âqsöU Z *\¶ÉöâážÌòÚŒ  ŸŠ�J¹_Êù«ÂJoµ`îjÂ`ùî8Çô =å˜U…‹ÎØM‡ŠÓñÈÖ¶‹À5_m­'eæå˜a·;ÓŽÚíLHÓ(jt„˜qËÚàa„æòŽ]W¼’¡‡â×Ök}uÑWU8Þžé9Êî}&̺—–ŽE|(JHB5”)”óí·Žf*>ÿÂõ·)ºœö ¹öЕ[ü™Ó,:¡ÒßÁ R‰‰åÒ“÷ë»ú£ž8ebnÓÄt°Ì[‹î`¤L_Ÿ'Úv&¥âWü­H•ˆý ÓluÞÕIE¾Q­|ZŠõ[œþí©¿^Ðd‡oã–NíÝ_Âó=; VƒL>'+ck ñ™œø…,w¦=)È;ð”8õl—˜å¾Ùª}s¤‚³Ë¡ñ—é@•ÃÂ_ãºéé§=Eº¶~Û\¤\T»ßûUø?¹§¡!g?R2”o½žn½©7‡Ú•lí2ù¢ˆ©Kh æŒà̱8Î |Ë–v†Õetä$Ù­õÜr€`öIqœhz¸ï0•b`„w Ú;'Oþf®l‰?&Ô‚ä½±^aKšu©?>WŒ+Z´K6нk?§ºKcg” f#Ò[΃ŒÎ^©*‹"ó„† Æ¥DçZ‚óÁFª&úº w$Gö’Bv*§ÝûÞ9˜›èeŠ�/ŒÔ0â»çU—®Ût_Kú˜ƒ6™S,òáèÙj_yÏ89ÛöÚ·7ä“4 ׂ%Ã0÷<»xL›«À3Dû ì‹ é[žX0}»p´º•s\âEÈ’ñ÷(Ÿ|o=¹.6­Tº¦AeÅ_[yâÞöÍÅͦ!™ñt�ñ?wïŒÉ½Ítû%⦒¸‰A(°ßK¼,Ž10§ ÐPZ´½€·ŠÕœTêä(cÑÞðSo2&dðQrZVw‹¨4Ž3¯' üD +Û¥èÖlW¸Sœ óX ž–Y‰,)3ßdž™d®#Ô˜%¨(ïÛU{�¦{úº½pc¾ÂZ»È¤\œà¬Ê,d toaÇ/šÀ•¥+ÇYqj³ÊM¹²ŒÂ¶Öˆ1C¾>ãf?qõ¹Ü˜Œû^;+4]l¨ñG°D£Ok­ =bùPÚylà… ü Kªàfäê[ši’µ†úé68>™WÁò™Õîì@„+65N>¸—ÓÔPT2/þ$35ü¼‰™Œ_í'%L¨¾ó õv„ÌVîÇ»j…׶bí~t°Ëó§Š0¨°£±Œ ùîÑí5ü¸WšÙtÀš½š6?…f:ÃÛÑsa¢PŽU¼·M @…˜ðó]÷´J:ñU¹](íOM×SR ²Š»½Iϼ˻<\eŽî…a$œŒ©.!ºožò›ÂbxvKŒ> ÊÖ²"#¦ov³†øÊL{3¨ŸgàŸÄc[¤Ü†àÍyïPtP–¼a¯òU‚1t¨yãtt„ªiYzXÍ—k`#ìŠEß]Î'kXåÒ¡z0,u{µjOX•¤\3€”~|×Fv\ öÂ4 ¸Ù¦ýa…Íqêt¥™ 7”KTµ¢GK–Àj¬èš\¿ØÊÌÓp-}ƒÞk¾ŸýžŠ)e¥)áµ^Ÿ6a£ØÛ|,ú0S¢õ0òøèúFKùo ™íþµ@z›ª} VÁ= š"£ÊIçwð“zÇ\J4ÓQ1Ž)z¬ßè2··¦ˆÓ´pî€apŒÑÒx’:Ƨ¬ëÀ²]+§ª‡cÇÈ›Ê ÊÓ=½ß~4²°ÇÅÊ·-¤¦9°”7Û_ùÙ©íñ¿‰D_ÄùPÒ3Ì‘k|ÛŸ·÷Ó~ö�)½”Ê‘½ëžN‹)òä²¹­cäÈ,ˆGú§Œ‘”\õ²(ª|%ÈÖm:Íf«Ð¬îáظAʈæQ×þ@Ô(2_Œ„}¿Zõhh^`•q9¶¦Än»Cz!gÏb·6ST^M ÐÔ~ÔX[ÐÓÃ-9´ÿžÃ€bU2½b˜¡¤AdÉXœ» OZ3š˜ãwnv]Ûˈï¶m“{Bð¢xÊ‚pP”8m/fäKßá0bAþÐZMâî/ÆiŸ©Í…3ÈPœ¤é É°jTÚ×'b•ˆØ,0bëmªK{NA8™µ®ÜÀ$aªUðû‹³4÷&b0+äÖï9¶Œ6;†y^›zVîâ,<íó ´cÏJ0¢ÖßòÄ0ó2u44¤"­¡IQ{o–™æj…Öê]J8ÒV %÷ ƒ¬3mŸ'Éj–ûÊ78Gç’Ž¤/oÖxì–¿¶ý¹©‡?”hQÄ'—bÓ婵kQP¨¹W]ùçèèAÈoø‹ËM<7¤O<é9Ùá_*¼·*ƒÂj-”²˜É ÖY‹äÝ]|§ïånƒˆå@GNÝé®.@å èe±íÌ9ǘÌHlÉüõÚ½KÐ$uy´=°Î½¶2-«Î2¡Ml�¿.‘¦áZÞœùqÑÙš†ìŸâñ¾³ã,G.ñtg"lLµSƒ‡b3<Í6I –_¨N?6ï£$Ï|IXÚÓ×/¬j#*~¶Bd©)³:è¤ Š¨ûxYnËõós °¦òn§ØÁky„ °o&ýB0s)â3�‹‰bu«SšH¤m¥-m·Ê ;p÷Å¢°t¨«ˆe€¶œåÑÅlß.#cÓù˜ýX&ÃÜçl¬m»39 «ýÕä$«€azÐܱýé$Œì0–e“pº“¶zx£¥¢yÜ Ç±úíÿœá ’x}âŠe÷)´¾ëmOb˜íža8Öƒ73Á0jïõ^s)[/$ñÚœèal'Ϭeìè.êþ}~n:Û­Ò$·Ì ©õ\`ÈUÚUm¥% ê¯2wøm$-"ßÐê:ÌæÞ·V­*bÒ`ÕF_d'‘qÉ ¥ÕfKùuÕ|©ÿkÈ Ûë¶D@·Àþ:½-WÊÖû~d×Ú(Óø">},”j4ŠÃÖšÖÔû 8­t‚6†c¿„˜ÈR'U™àï¾`š3yí&›G âÛ  V/ „JòÄ÷Τ„Úc¹Åw8 �øg&Vìé27:/ nn×Õ0ß¼g¼ $æ¯Aa¬.[·à©ÖtÏ­­šÎùà8w Ok‚ÐsÙÔÊ_¬)Ç£u ÂVzï¶[Ú–®¶ïºI8Ô®FÁ'Í]V‘ À]>“ ´â…¨ëMWú`Çx¾c}Ø Ž×‰°nŸUîsÁàÿªØ­Æ4/чN52j ì½h´å%¨ßùÕl\î…1^t éû—ë™~¶cmž>:çŠ÷« }B€ÿiN­?"¨@{B]|h†£[Ø¿Æ“G?ßD{µ‰ƒ´SxVÊ�&Š…à tû_)A®Ä·ÍÐ>B;cÊ8ò µ’Kþe\oͺd:É%�x³òí"t€ÆƒM´„·sób³øÌs§aºõiP JºaSͤ&l_@DßêóæƒÓì Å  QP2XŠGdÅ™b£¼\ @1[>uÌ7ã0Ìç¾V} mÇœLûJçÎ�[³;Q>ó]õÖÄ,ƒÜêJÇÀÒ°‰d*b:ºXeèb›#äV, É —¦³œu~(†Ú{ÐÞ$Œ}ìvœ~l×N®Ít–ÃäÎO †}¸ ¤ Œu»yõ龜·Óçì[˜!i2&:Ço”!Ž—¾ßõ§+8Ý(Òé/\®³ù'Xxô­#§nzæç«7ªy#-ý]‰È‡‚ÁnÒ•›0¸´9ßoÜÒa: ¡7ƒ4z“cÐ_!P˜žYOèk}-Z§°’“ÈЬ˜,~›¾>·@;^îK<+«hù‰ìØc½5Ë b/òü%bú:—WiÅváf†Dt¡õí;}c”ý•^YS¢n„•¥ñàÒWñê Áƒ×vûnòkô*Á•eÑçŽþ.TPn>ö2Æ€ê›oãÁHþîD¬2ÉÙÅôh¯3‚Cçll™ªBç½ :|°å¹Ü>ïû¿õ­• ã 5 •<Ú{€±¨‚1jõ‚jð2‰ü³Áq¼VÜÌ‚–ª‹ÌÊžr­¨ {­œ%R8P ¿û:K®-l©Í6)ƒh·õ´{1n2d,úá<Ä­e4È8Úöe8HQúˆ/ú‹ó¥?í¾Å̧©‡mõàµdm}–SdÙ¹£Eû¢|ìió .^ü3~ã*ÂûñúÁâUjSû\×Õbù3#è9Ïyßzª?ÜM†:žÁçˆXøÉð›.$ÝhUï-ô<¯©k» ‰©Gî�Ý• c„f|h}ñèVÐý«ÞŒfrð!>ÊVK[EiFë 1AáÁ˜ªÚ8ñ-E{±‡®v`âAÄmýéµã¬·ÀJònªçÎ�¡ˆ •)‘«ÚËDEÜÜXŠ<l“{ ßjÛ>܈’ŒîÛD{bkÛÄ‚ÄtyHRöŽÐ}KKTñ{Ê=ñ€ÜÅÍÐ ö„ Y­}{̓¢­}>m”U÷e<Ñ=üOßýG`.ß~ñ])9)!¶h†Š£4”êÚëbNŽ’qc5£¬,€òÊЈ^…FÖ¨0JgÌŒ^ü/BiÆØII®‡÷«ôèijB`•0ì2«BYæ\ÆŽõ¹wÂC?2ë¢(_±Q¨ÔžPÞ/žFÐPÏ`–z®T šéèôd8¸ûKW qIËzü ,¯´��+d¯vø»ª(W-Ô°¤õÚ¬f[°¤¨wš©GÊO^)¥ÃHòn™ã<(Û¿"Äg±}­J^ß1³ìÇKfæ™ÓÓå*(Ì¢,بn`pï(aµžfÓ{a<;g7ÐZJ°�yXfÂ⥑U¥ÆâO�öŒƒâ}«Zgo³·+°øHî(ùï&pÝW—«ù'Ðè~"÷ a åòÝY1dÉÛ×Gäɀà Ë&~iD—Ñö|(ï}¥ Øg¨o±èåsû¾ÄWÙc3Ãý. âO; Ûb€æ`ܳÇt£¡ Wß9ÉyáÚNlèI+‡Ö˾ՈœñtÅ€²Ëf#3¤äiä=€Ä—fx5@©‡Œ Ð |ÑÞc½€ ˆýBœOª¶+à˜fD/òd˜é«´7®>"¼ ·Fήõá»ÁOz”Óµ"ƒ´i5·Çte„­×íA Ôrÿøgݭ¡íÄÎcî  ðnÍ#£ßÂmhÚu˜i¼j8'^“˜e½¦Cû逡`÷‡î¬~K¿Ó!uRN±™ù ò*»ÉYžÐѦÂÓ"¢%æä?n:mö)Ý+TŒÚYå½ÒÃ�“ª‘¨¸‹Ã4Õ·tÛÂëf1ÒgOk8þ²`n´ÏÍj)«x×rᣯûnêV —CÊÌw€†ñÚ63¼z» k:ñUç gþbÀŒúz™:J ôÅ“@1™(8}Ñ ,ùãÚZy¤òÂäŽæ·(R L­yÒQY®ÜkØ*dÉG4hÎîFÆ—¥7þ`©¦Y2aêß ø½ÊËd?Ò_¨ÞÿZ‹8•hw1•ˆßz‹~c¸ŒX z¢*òøDì139)Û]Ñ‘L‹& ŠíÖLaÑÍîkcÚ'©0õõÞ‚ÉâÒ'ï‚žõ‘F,—eÉüj ˆüöŠóËóÉ Æ^~ªùS…´„ª ‡û {ÉfñN ‹›+Eü])aÑwó¬®5§×|â5u-ÆÓh´„A lPr±5o$Ì"QÇI’0oè½¹|4qyµ@îü àÊnQJlþAq½>:%Ù¢b‡#f39F’™u<4»ÌÊÌ#-B8¦AÑk†•„Ò0´¼Ó]= °i¨Ì`EõŽTj9MÛº쫇Tˆ £7öTYL¶åPØfçRzÞvÈvg¦gÙYûõ„ÑR;üË|›æñžŽì‰’�¹÷ìÅ <+cJÚ‚µ*ËÂíŽ"ŸÖ¶ŽÁG+w6eß}ó>®2_.#ŠØ–4U‹ƒ¹·’ |Ù˜4²xOÚY>##™t8dæÞZÐã`S0ïu2ŽRßß0Ÿ‚Pe­X ^]<,NÄ¡gSróò‚•{]ö8jrzGN�yîÐ4F½:‚—Óé8ùwwù­.ÒÊ’¥¹híçŠMw†1»³ÈŸÉÎë‹%®é7 ä}m9¼í;:¦ÛëGçÀì1o:+ô´=÷Œ5ÿ5!,.bå@wškÌwoÃ4´,¶ôÅTvú‘E³ª‹\ê LvcËM Ö´á¨6]ÏcMÕX1†læ…Ïœ‘êóuŸg™g  É0ÈÞ'CÑŒbš5“ƒáN‡Õöœ@´e‚Z–ugWèî¢M)qôž?½²rr«\5_èÄh>q¾—è-‚çiËã{Ù ë$îÅ„¨¤û·%tDñ¹Zæ<­Mʪ Út"ï(´ Më½_”þQ–­4uSLÛ`§{õ¤îЖ‚ì–IŸÎÛX§0Œa ã7 zêç;.(ô î$çÑÿ™?ç¤tÙÒÙÿùåRó±?{mpJh?L)æ]}ï1†¡çHá§&ÏÜÈó³æ“ónèy…Òp%6þ% âYç-1þt_ø+õ½A`MÝòÀ×÷Ën‡,¨&}ßÂSéVÊã+¾g¦|¥wH¥"¨Jñ&«-;�¢šÒ8ËrefÛ™Þ”wÍ–KÓ±[Ñç|öU ª|OÊ)azUÖ+{¬<Ôé‚SæônÖ3¢|\fžÆv„:rj>:íník6zTa8Ü&ÏøCø•Ó{¦çæ ƒ–¦Œ„–B ê{‰T-ñtu"iÍÀb³@(Wb¯âþdCҽQƒbcZÛbHÈn†ÉÿD×Ý7¢Ë™X9QÄúÔÆ�›f9ÉÆÁßÞ¾®ÚÁqáÁÝx"<L‘tT+üÅšF3˘¦ùyh±Â³W"ô­Ü(„uÜY^?àÛD¤HN´Ñ’`KÙ³¤êæõnã¶Ð^³ÈÀ$Âi÷4²ßsöá¢Ø"TÓu�ý'Û!Væ †]”D¿_½JcA{Ò ÛÐq8B¼Ì 껫»ß%ÍVB­ôæÑ“Ä’Üt¹¼ãdm^ú[ÃPÖ¾I©uQå·ãéÑ07ɯ:å‚øÏtjºiáæTm:þÆ$w°>ßýi¹ ¾7XØÚºx]=­\Å‹1†+-©Aµ¹Á s¿7zß´.Åþ˼Þ0Ý•))¾Ôa.ÎÚÜA4A…nÊÅÙ<üÖÚ+CDQÿéhÑv­ `ÜPvFÅ?Oï4›ŒCƒ‹â)ã_-¯ÛC+Ã^––øß·(°ÜXS$>X­_èÙ$qÅ™d@Ì„Aq]<dï5PÔ€61%w.žƒ £jÝ ±ºò zÿô*!úoÌ#“ ¯*õX¯þõO«*)}hœ%Ìҧ⦠z6º/&£.ƒ?|±yQF¦ º™“ f±é× ©Ÿ­ÁëP²$[ÁiK°±BÖêÀõx…~›Ø%KÕØG‘|9·ÿO|O$‘Ž(ãM?uô± åÖö¬.Âwú'Šô±¯y‘áZƒ¥&ˆûö_;œDr¥d½å·ÞG^à—5NÝe?³Ì† ¦ŠG£JKèmÞI£pÅ·¥†CíÌ/0–xK‹ßÒ B:nT؟͵¨“•:˜e}êøóâUä= fÛí¥*Ò()¾(PíC¶x„Yßà¤:hû·^îÍW“¤*<îCL;J¡zu{Üw—ÃB[‘*DÞ‹ET:Ï©J²£ý[SC}¥Š„e£«Ë½ü½wì4ÞJ>ܧڜ‡/;îÆÖMÎ'Z>GzãEá•e¨ú¢fœÅzgõrDªöL‡!Tl^¹=‰¡98îIÆ‘5¦z EuZp„FntÆLse0¸ ÏATŽð™ètìù%ñ·×˜ \ΖÙ|ã$îžë—Û.XªÊi¢  1Zôe7[%ñ:vÝpª×±µ\W[ѯj…בÃ<çâ–ífªí©øâžÎ+ꄸÉ` }hµ_WN›/P­m¯º´v_)¥ž=ðÐ…Î1nN †âž>uüK‘ »$d\˜iÿBˆú\ó˜ØŠï¢%ðÿýŸù­¿ÃêsnŠÔè:¦mµÄr¾¥âkeÍØÇ“"7ÐøYÝŽ6îÈU•/‹Ñš2žpÿ×7=nŽëÝgä �¡èê%x(=nyŸÂ`:Òñò¥Es–bZ6F#Ë{KÐ|bˆ:#RD?@‹·æçl©Q›j¹ ³À¨‘6 VFæ,7…\ìrl8wùT³•×åœ\bÍ¡—Y–y}d½›y.vl4Ÿè³—óÕ©$Âz+údã*æZ@˜ñçêØJP:"/UZ{í¦Üc™«Mô/˜t«%‘U–Þ¤b¼¹úÁ<È ‡¥úÿB;O bS6E‡È´G>>l½¶Tf赓¼g«øx¿V©rßõ€îÉ0%ArV2»†À4NW?¸µˆö^u¯zžeØ«%Å£$È­Ð! Hü)ÿ÷-3ÍÑ‚{:¶ N š#L‹yu“ôæÑÎWÊÙŠóÅI¥|�ô7ÛRr`VP6º†„GQœyêÖèg1¬úZ{aq¬—épZ, þ%LµMùØÿ*n–’¦¦÷ZqÛ msYÂÝÜ×bûj°"]=+íÔ‚GBϨ+cWw�úOGµØu§‰²»öðe[Ÿ/’b/ÓcdMßÓYÖ ¦€MúåÚ³€šçDOÿ=$öг·?®ÁG* /-(Yíò Øj¶ Iø}wœfõvÿ WÄ3Evpe“û«Õ†¾yÚad×›wø&j!‚â^Éž4ePÌ:ò‹bÃŽØz)<” 7 àù‡‘=ƒX›!Œ.¾!–d9t?v=Égkù ñMCyﶞŽw÷ :®Á÷ Xv9 êf;P #¥ÜoM˜êZy¼E·…gñ9@ŸõgfJ”$¾T�¥¿pœNv6ý$U¹Í¤_pœNÓ×ñ¦¥]4÷.G•Xê1Ì~çšäX’ju_\S«X#îÎ8¶°3ÊO ÜæèŽûvVéžÜœÊÃH§Cò)ë…J‡^z|gdö|@1}< <ÖO¸þ -7·Y?¢ïâ ø¬Ýíè @köåÓFßòI­x~nÜY÷cEEää1©/x8»¾nás€Ýv52ë”ÍÓîžý û¡×vU9ÕRÖK $«•AÊ*Ì"Ë«Ñ“G˼Éߎ-îSBVì,Y š‚üy,Š ¸~¹¾ü^äPÍ!ÂÉÃi195ÕýÐâpWVVA'ÊÂ#Fž1@mëïNRØýp«XÛÔb ×Õ~|Ñ"Àºc¡Ù—søÏèäûÒ¢Îz°ÓI~¯¾žDN53µGb²|jC)5n=^Û®ÅnæMŒqëùUæQ±²2Œ#™˜�Ý[F [=;´¥ÎK~˜›¤¥/q…C!;úÒ6f¾82TÍÆK¡ÅÛÍ:#hû™¬âÇ)ÏFo“ \Ô¬ä⟮·ñëfW‘ KÔ$LW‘[ÆôeëÉõí;æ•ýŒ¬°&ÌâD·£)*ÊfOr©éOTtp4eq¢“3öXê£È·Ø‹[äo–9å%Ä=ÃѱZ~ -†ú%«¦‡Ì£:ò;`Ô({g­•–" 4Á¾™É ÞÂ÷šÞøködv@=“¬£^e+Ñã4Ø·ô{K�¢žŽôu—ƒ¦-ˆ×™c¬ÕìÏíá/#߬¿º€ŽÒp¬óî­)û»ÉÛ£(·è+Á4}˜uNŠA«¶Ú[NÔÍ€£ =W-�YÞPpS¯\[J˜äß\3_ Å¶*Å@w–š¡cg$˜zŒ|@U¯{ʧVáx~ú+¤2ŠMésD¥.²výuhÅæÞ=ÇŽ<ä W3Ä()bkÝ™b86 YvBS€Äƽ¯Ë¡Ç‰÷¯êÓëQ€…|«ŠÑ&Ž<± ðQÉ"Çýò]J½‰¨p‚—‰RƒxpÆ(Ó°Jèƒ" +äej32ŒôèEÛÈõ #¡à¦:äå ¾iU2"<ô«b#MýE2âž-kyG°2¬í¹¤ªW×™þÜ„\SߢyªÊ<ÿâØY~ya\"Ú}ÄmïØÈ7vÿ?k²Ý:®l £mî§pïïdžÁºh’"UØ%“Ô’µÆ}ÿç¸1#�¨Ê²ókœ%Úû¤,‘@ ŠYl&kFÞ[˜ØÃ߀Ýd~cë¸ÜµtYò&ÃtâT@4es×Ó0×N=ú±Íð]ÇaËñR,¦0x-f .ODS”u¥±]M¸•÷Yß>Ì–šƒñL©œ£1N†® W˜Ü¿t8j™ÎìˆÕŠŸŸåc!ÿèý÷Yõ¸Ò›W†=šTFȈ‹¨6*ÈÉsÝýQš80¨„BgÚJò¼ÝÕ¿' þí/û[ÒKœxzŒÐ÷‘H˜©¨’$™\LØÁï8­uqù°ÛçL<CC¬·•Žªñ’³Ì<sÌ¥U$†R˜×«SäŠÜ Æ4ˆ×Ÿžˆä¡þ€0–<EA\i¤cŽÉ1÷þÄ¥Š}‡Ý8f4oÖtž‚ t¬àÅñþHWÇšIÚ0H% ’^“ãê‚{ƒºñ ´vÝÚ¤"·pßôÊëVœ-k8Âaq0f¼sL%ô² ¢ÂNX–˜µ„©( m6‰þÞÚ'ß;MK¼=õõn²Z ßK&ZyÙƒæEM•K«beÀ-¯Xó.ÁžÐpÇPwór«ÝW,zÛ1•ý´ÇìveR … ·®w½Qô–É3[Í,w&è6Ж¥x´ú2^ó#tõw£ÝZtxAWAìBÿÝ ÿ®O"_sûOX<÷EAè FtJ‹D(ŒSÐÒÊv꥜³чN_¥ÇÏêWGKª˜z/Ëüè«1þÆ›_ P’å.×lçkvÅ/{³èAÛï«9ŽsFãæE¾SCK·õrr ¡­h**ÕÒà/O_V[Y[âwê-¬&UrÍlûî žfÉÖf©ºz´¯wµš‹Ìh@W~\ö´§EåÑÆèø¥j®¿üÔš LÈ,´Ð øÛvUP¼Ÿ•)r|•IÜê±j©_¸u¾ê‘û«+e”ÿHIsZ¯½ª`Oë³îzSé5sýØ Þ¼ënPø¦ª¬6:áßoêŸJ9Êþïꧼ†ÑqðíÒ@×Ú Œ%•ªÜ×ÐåÞÄ _ƒâa s–(Ž3‰…ŽÂÓˆ'"ò·øîþ¤s!Ý€uU§‚±5ÌÐ_Ç´Rgsoì´ÚŽÎ¢é%¨qá rB¦)ýÜØbÇïàùÁß²Kþ ßæ¥4lÍù\Å0yÓe3³g�$Ädѹ«Çà86$ÁzSn¿ÿH³ µg~‘Õ¢6jåþp‡?â¯ÂÉq1†¼ûKÅ…¾Õ×ÃYœ JH`§Ï枬g~eN`Ò <£=n=üˆƒßë¸22(Á3>¬C Xq�âG0´'/o&º}Oè3ÇÇmĘ#…™¼ÀÞc¶º•×CAUÏtÄŸ­¦ÍOwåI+ñ6[Áò]'_*uh˯|©~ˆsJRËGÀ´Ê;wrî{@Xý«ñdFE‚]hwÄÕŸàè]>Ì€&m(¦¦Ö $€ÃÁšÍ»¾“fÁcsï* $ü8Òj:) Þ+Ê4† ÒÇVØ‚ÑìÃÍë²íj9’™Jº ¢:tͬŠ¶ 8Ǽˆþ”8ëQŠf5»¢ßqtŽB/]¢|bé4n.ž:ñØAú\ÿÞ‡õÏÅ*ÌhðnäƒRBJîÃõSfnÀÃÈöB[¢·>s¹UBQð¡Ï»Aˆoþ@‘Þ3EŸaŽš¬ÕΪ–D£TRž$Û½j|­ÌR<ýµœq†§Í Sü “ÀÓæÁI_«3¬nŽ. 6QK“”±;/þ$Õžœ@.­Ø­yb‚˜ùykDƒ|W<½Ëמ·ÞVv¦4g>Ã!Æ*‘'"Üȳ Ï#äÄw>Läð¾ó›{T¹$Dñ€ò FaRE¨ÌK´Å‚ÍH ôÐÅ@ *²¶L¤’Áí¨÷6OÇ¢�z´ßAxUt ± ÀSÝw´<¬.6ÊŠ‹3ÃöÚ›÷Þ “³¥1øË´TÒ÷Þ®¾<0[ÃsúN€.õtBc–­è ¯Ú÷…ÍQÄ`mîéc¾lœjˆú=0° ƒÔÈŽmOØ1_[›‘ÑTùbõ˜€a`ÿ»žb:˜a'üÊPÕ0Âà9 ÒN«dŠÊ"XrÅ{Ä”ª”eš©`ß)ö°Ùšbö$[ìžÞüåùbQÓÎB_/·öOΉ Uur»VC~dã\ƾð#<k::6£çžw„Àæe|;´—Ýðy¾<‘VŒcoÄ2ÎÓžî¨3D¢¿!ëÐ Ò:°“‚¾<ÑÖž%[¯¶)A,f/cæž•'¯9~Xg«;ŠeæÏ–�O² 6¦õ…ˆµÚ1qkµèƒ 潯²*óÔÊákÚå´7U¦›õÆÕôÔÞÏ/)ŠDÀ¼-X‹°t?º“§.Î7ßU#W ¹)ínÛß.ry½Y›–nOÓë2Jtª:ħæ+`‰¨Œ3¿=Bo¼¥;”L'+%÷Z…Æ)SXÓ8‰á¤11R¼.ÄÍ‹?:,L?yÚäAÜYG"(86uß<ºyµ‚šÜ§7¤ñ&¦?ï^;¿ÎÒˆ9®æ¨ ²ó 3îXj^;O�<qoéÂtd‡sE÷—Å“ÓBn­±ob`åc�w?ä—"VäÉÅÔÔTá?×nŠ¨·“]ÑH~E ðt¾¿=ÆEÚi÷ç²õR  �»]Aho§J,OdEÜ)"œiªqºœnÒÔyX;,VfBˆ9â¬{î*Éyêƒ0p·Fíy”µ›‚ù°gv¼»Gý–ËUjÃöïÖ.,³wÝ qðætýºFŠåsן/ÃÛ¶6Ýá›qJåI²µ-È”R¤/çã²¢/ÌöaŠ•l»º7ÿ m×dèAç9¹c»ÈrÓ™¶SeÀE¸—dÔ=‹V¦ˆN?s´&äÊÂ%“ÍÚl ’íìE%LPÿI̤ÈýZ5m#]«È†Í¾†ÚÄioôդôàU¼6Ú,í›fB&W4û‹+( S[À0Ý:§>|½æNýaÆÓ·úÉT‹åj¬ÜC˜rW±‡›¶‡N,2#™·$41Í¢CŸIÝxò¯7†¸õtÃÙ·|¹ßÚ÷œGY[–Ò„ <ê8ezWk Û¡æηæ±sNfž¬5¸p í¾vâçTžˆßªÉ:~)yžg–ë#Ã&f!'ƒµÈ®ü4{?fWüCÿ¼DáØQj¼z¹APZ‘¤ §”’ÊÄ’—Ëç æ</·rðÎMÇf€S]#.*!m÷×ÞÒ¢Vv#ÓÁ*cÊ#MBqâºd°°õÜ7Bî¾êNž~ÚÄ"FÇ•–/ø2AÑé)1šÝ!!çb§)¾ƒ,–ƒ+ÿnº˜¹æŸè¥Ï dÚzHÔÈ#'«ïðÄÞå+ÚBÿ–hÉ”Á<” ýõ¤Ù!PãŽzp¬Òs·ISåÞ¹ËóŸ¦c{ê2Úe@[b™ÆniéwG~ÑBµŽîƶÆôädï»9ÉÌh<í¦~w´¯Ïæ=‘•±`2 Np¦GVíŒ)�.N}÷FŸ¾Dwäæb1ò.<ì»ûУªç]ušQžµõN¡i[Ü^ºŸüûÙ’ã‹ùñž¯’wŸÒÒrí7Ož:÷YÂ44éyÍê¿Kip_Ÿïxƹ&gj ^[XÒÕS“Œ‡óÛá8ïV;ªìþyƒÓÈa¢:x\qCxÜ¥®| xùõ‚ÜíÕº ‘³-¥¨ùçp©­•íxÚ4óïÂò9rö׺Ô@¯ÌÁÊnYniaBÿ•ò #«¯ž&Q~ ãâL,uÈÌzèòv§ãÅ0LnJ4µ×YÂÅò'†qˆÞ*Û—²BÛ¶ Š®7©SÕLJÚ³8©pK€~¦Zû½óÜÅfméfAæ*xXÏÖØgÈ÷Q)ÂœÉW¸Ni|åà=}@vÄòËR'g€ìíéàæ¿ñ¸w •L8¡üå8ÆAüeýŠà›¼Ç—EɆ$ã—Ž†Þ®iúîyg<KB?›ŒÅ›Î²Ë¸?H«Œá`F•7C9ùÓE™óh–}³$´uP5å*RFÁ|ã½jnè´e Ý…/o¶ð£EÞÔ ]óh°»ªÁ]„¹ï{ÚÊŽ‘+t#ÉŠLŠ ñ,éõä*)݉£.Úž Ôstx¶#ØèÚ\ò?z�.š¾ûŸ<o!!™ÒŸ ¡Òûˆ3bM½Ù†ðF’ç]>b.Çaì÷Ø"XOÅAõ®vK«ëŒƒ3 ÃÒ7ƒªåOÇWVá4ä*ª.‡2¨¦¿^0Ç0´#U_øSw=ÅEù÷ìÃ’²¶ïD�Ð,Y§1,ÇÃîlwðüÊ3DK©®0n4ì‹‘tW òÞå¨`²ï‡ñŠ7¦ ~u‰Ëqì¤K.q_bIž6ø¹ì¶§4Ųm[òÌ=¶LHQnJÆ Ï§–ªÓÐ~üq­Ú§èšC{ŽaokuJË­Â …Énr9Å_¬§Å WP8ȸoÏï"vO¼Ì:§Á“Àʹ’” 8øû¼¦×j-‡B3¥ºNœ­7h½b^u5—Ä q~ÿ‹]üï|‹ÕzÔ"�œ%¬JC¢\ÑSGz³´ˆÛà6=ø fë‰åa ú~5ƒåêèé‘Q´g‘Ð_>éÒq¾ja“)ø(¨ÎTzLSvâ.+;ÀîkŽF æ£Ã˜èéOè¥y¹;›1~ ±XNgϱg%@þS&£êŽÓa/ÿò]t7?óÅKS&fÒ~ˆÇµySÊñhý¦, ­çl·Û@ÅxAy­Üf …9P@�Gß ¼h+òÆ¢ŸùzÇÊ© ¥˜L7¬Ý$cÞ„CŒÿN 1N=êP$¸³<[‹;cNÛ)-ÞY ¢7W]ÝßÇÙ†0Ú±‚æ8ÆÎô¬B;í�Œ[§Gíćcº2ó^Ã*Øáièåi6¥|ÒîÔÇ#\Ó–™ÝŸ˜‡,Öãøc�øWq ‘NQnú¥ùPdÉ’¼r`ÕÐf´´•ªUÁˆ£FkøÒMþZ0¶ï² -—cE©É*•…™ˆÓ®˜—ÃÒ.à°üú¸j¨džc†t“ ü|÷#UsǸÑdùvr®FÜgÞˎˬŒù¼´~°ÒäîÏ^6çxé.| œ^õÏØ/ߘŠEz-pD¶ùöõFl!w–càýãªk½®¡øoyxß.êÎ5ªƒ…‹=½Õ:§|fr.N Ýóm}éŒÖD)#´‡š9eôÿ…t©å†öÏaVêþo}3Xá‘S²FÝy ¼mI6sxÐþž·nª+É4#ŠélƒšøG»ˆðs°A¼ð£ªa“ÅZñe€QPþC{JÓé½f=o;Ü– Ò}QÒܼ{ÒÇ8÷¬�¾9™î»©Æ4A™¼ïh5¥ëÎÉþX°§ù°\0®H§q:yêRzý>KV l+,džìˆFå]Óß;þ¿…3—Û–nvÕž=· 9‹ %ÚÙ×ò§§V"¹16ŽŸåñä ”°7š ü¦ÿ™-tdÙ="å¦djÙ5U¯''ÿ·<¨¾±Ž}8öh›&¶5|wE$/ Ù7*0WO»^&™æÂz!e~8'¥ŒèóäAëλaan~SäñK‡˜pigXÒá—ImÁX•y¸¬@OðãÁ»Âþ•Ò®&Ç^ñÏ="ú–”ß5ƒÅÙì;±F�{wXB:}±Ús¼µXt_í.ö ô)Ã6ejË!Êx,:;Ý•ó}iêmüÓÔlŒýn“s'Ñ %cè„kÇöa²Èc¶Ê Ÿö9í"†­R?‚–J±È*MzÚÎ öi/Yuª+ÜAŸŽ“ƼæöWé Â$’Ådþëq_ØêÔ*äqæÈ�Âþ"³oUþ*Ïœ‘ôç?´>²IQR�Q±¾—þƒß(™†-ŸØÞåƒC¼ðOì_ uÌn¤\€]}8â^ãåUAÈX9¨å=_ã"nÓÖÁ)Á¤åf¦xé»›ˆ¾øá¡Æ_^†>i9Æ) ”äÅEDÍŽVɹé,©Ó»† _ë¶T‹lj¸ÀŽOf/ÉÏ@û<xà¼tè.Ëô6æ‰ ¿Ü?´fòΧ :×÷Ëîƒà!ªzm’_¿:’Ì·Ž¡çZ÷tÓ§"w®ÙlÎ9QÿŸ¨Å壨e 5=äK ì~g«ˆ“Ûɨ¤³JËüTìR‰´"òe¢¼5NV.²dû›V»G4û…Ò¥¡²Â*û}唇´ªmóµ¢òqwÙ â¹;­ŠJö '`cúW?>s£L3WT¨Û®²/¦P÷ÜDRT®iO¸‹ûîÅ—'‡.”íu©eìȉôj²Qdõ!˜-½¸9zÝ _T}•§0زŸÓDQÁ'w{cy<’I“ÂÛm «éRr<ySð‰öÁÈê1˜Ñ_ )€Õ=ûNÇ)^„:º»T)t†ÿõð¬‡úȵúk <$á§Nõ×þ4´Ž$œ×Æ÷•´X[h‡Æœºc€4œo7Ltß)UÒ¾Çá £ySŠº5©½?QlW +ëLt¢¿kÍ A àÛ†8ò¨Ì£¥¾ïô§ï´¸#kŠÄ4Õ0 æž„s6¿ÂæÔÃdü~èLL8¥%È‹F_U‚3¯rä ˜¨±¦SJÝ•J×yÖÿ€¤n†¦röT,ºþ‘ÒÞmZm.r‰¾ÚÊm:rîß Fê)€úÈ õGÝè¹{êqbvÓQæ»wèüO|qº°T§Í@;Œþ@­âî¬ì°«GGžÙHêOqø°Këöʧ÷åFExw„ñÕåèÄ$°-¦Yl'iÏá{ЯÌùNƒ$õüÕÓ9}PQ•ÖJFƒÛ쬻`è&0 ¥Œûzµ‚™%'â‹<`ŽõîØo€¾<ÛÅ~éc¦²s>ÐÝÑ›sÅ5zÁ'Ö 8$†h¾ÝкwCD�/m+ EqÝ3…|VÓYYÉÒ8¥X¥7­—¢ñysTsŽ‹é ¶—àŽoe/n ÷¨4ãmŽƒ&£lx½ñô—)¾áïYw@W¢]Ì{ÑUãí⼉ ‹ê‰  ÛÙÓ&bÝè†ex!y—×í  À3ºv xtT¼L‰!D¶ cl{“~½fE’¤Q•W–NÓ÷HzÒ¹ÓþpTÐZ··  ³–^ÐGF:rš”®‰\R4t³{+ E_A8Â{Yö>”ýWí妩Diwd½žžü@çÑ•tÆÙ;#«p~ðáã¨Ì|¿Œ6·ŠpFo�þÔ£¨cÍ¡ìÀò4m~Ï…ÔÅ­9¶§2½òÇh¼õÍÝpÙŒõnã<¢ÆË°CºÌ.µ3Jô¥ûºêÓÛ>¡W?y‰‘à˜PþLô-¢ùÝ#-‰ê›ÌB^露ÁuaÚ£ý—,ãf|Üú³ë“´H\ÓƒgÀ“X{ßÇã;iÈ8Z|Ì CØ·ÎÌÈwRv¼�My/Çì†cõ*:ñ'Ø8¿·˜ÄOž”˜¢Zus3]rñ/“ÅTÍP¼Ã‡¡ bkAÌîb#sÛXC¥ãúÞâÁŸþx‡–ÊšŒ–É„y)p ƒ/ú䉔i­õŸ¡ qåL/Ùîl5†AyÑgÂLÆÝæ`„Ñ‚oñQžûúý=z‘Eš Ánk\pÈD<làÿ§Y­ ~^b‹ñxꤼEsÊéSÖgoH`ùfIí»/½ãÞå³àEFj’Ÿ¼[x¥ÚšT G©ÞüPïgn;ip¯á– ïç]z®ºÖá… Fú£7][íÆÕ©WÄï´þÓÈ=Q†ÁOsäç7ü±wÉà~â]~ce¾8/X*¦ïèÚö€R®íø½‹Å/q ÊÈZ‡Ö`±”›SØíkm;íÅí©cì+Ù;›k¶ Îñ±wÛù¸£*gu0ÉÄX·ÆÁ†¿¬Wƒ§i+ÿóÜ¥òÌ´%[3WcU°Ö¶õ�ö‚;…V*c(VKe(î©­…¸eÎT0 ÚžUÊÏ®oèk.˽©O&+nv´‚îççé~”Å6)ÎìllšÁQ~e;ëáScmPö$#±ú5Á¶bÇæC„cçÕ+µ˜Jª·CÓ äFs7´¬#e{�–|–+ƒ>G¹õ?àÕi¸Jia¨Jü!·ać®Ï=%œ”ge ñ,&uÜzբѕGý1)¿ƒÍ1u:RÐo=gôQg»#p³pàH¥þ�@i¥ D;Š’`È/äÛ[;㮳bñNZAew–Ëñþo}j¡žÑA³¥,Ûj_Ÿ'­|À?pÅèo§—ñR&Eæ”I÷åi~4;�ÒvíKiÿ +.¹‚°ºaP­ÿj­Ê¾4l s#YB?ÀÍB«pkDãvF"âg´¾Z­ ÓR|Ô\¦´³°ôu<„©‚,¼&V™¸84¦Pç?ôO¾^ûˆûºe…2×®< CcWÁò§ëñ{èùòÈW;ÓŸˆ­]2Ó 4w\4zë^›Lói4Ú$o´ŒÝÐçšJéTݤçD‹yd'r§Ä[³ž) éäißö,úHx{àõàzÙ:¥`ÿ¢?j„G©q!ó*oñ’¼ØIÍ3ÎaÓAÔlL#£G¯MÿÝ –†þõ3áso ^ŠsBDo͉72–Ÿ#7Þ˜o±šBÔ$æQÔ½ {þI=kÞÂÝ[Ê›özù½bÏfÝ?– H=jcÎF؇8¨º³Ëðµ7é¾Õ#uª4Î| 6'¸…N®tD‘ÁO÷�Æ&ÏÈï‘Ž_ÔU’΀s›IûéôXZ0„=Û3$Ð_lC(½fÀ¼ëÁ4æ-J`¦nÞjÄEæ5Ê#pÓèó›<’;‡u3ð;Cd†i,¬ÊÐt+æH_î9áA$¾³C†=O7FÍqO:ÔttÞî"iÄ}K#pz7äè)«ŒÒœaŠ`ñ¡ËÝÔãâ÷d,þæî‘kT•l’±§8ßÿõ’l8{4—ŸxF™¯´Ç–"—óÆcuF.MM�ØõËû÷ kð aí0ßùGWŠYð-ótä£&î·Ž¦Ö6¿ǨrGâeû†cO›)´äZ¤¡pM±GÑîÏe1óZXÉ;8,)¯éÒ T=8kÛš%êMlZ“ˆÜÑ’IüÔ’xäGeŠTàEÖN,å±KǾß(P_°;ÌÞµ¬-Ð=cÙ·»r~dÂâÕXÔzÛ›Ï^.‚ìú¶J&~F+ŽÂÐÉ<HCzµ¦42lz3äÞRÅ*H"QYïæ¿5í-uÓ}Ä›þ—i…¯ è§G; `±¨#ŠNDߟ6†Ýi“©“Ì6H²µÌ²8]q:jïôæ0ÉDçêõ.1YÔbÐý½ AoÓj”y'Z¹ævÆEmð¥J™=Ñ·‹þWå^g¾Ä1ð1Ó>.OG·õ£#O·G×Ûá°Í¦ÊÐÓýâ™×€ÎAk TPîñu}ˇ¡Í«ÌOPæS·* Aý;ØÇG­¶~Kz˜óe%j_F̪76«™�›b²Ð'hÀNV?ãûÐaõÉ™Hù2ž%ŒO÷L¿_7<(YïÕe²À»°1]c: Rî±á0Ó³¹|jò®¿íÿ•nE5~ #å4yé«ü¨¸ãñ¸Å­`ù_P§¦$ÐY#ždæÂBºLª4M<u18CI5ùü´’ätÇ,Þ² ÎSÝ´|Xãñú•åt«—ä‹“ vK=ÌïÖx»F×p§Ù - 3i ‚AåÁî^2@Ù'»ÒÉÏí϶ñÈ(¸YFMí?v?£°pUt,¹<ˆ\@Ü1qF £¸—½›­ä{| âÄlðWÖãÅÌxéVå¥Í”Äç;ÙžLCÍJê¥e„ç·§a:ð#TI´XÌ1¦ª>?]·wÒ q¼8¥26Ù«ØQg%±ËFµ#SJ �•ì „Z;Ò”u·ô©ë·òOÂÔè•­@ú‡Ò>ëÞ ¯iN²³”¬R[ÚK”®Hq$¯Â‘¼pòdB¿jf-ŒèLÆ¥Šiå½"³Vz°°ˆ…©?蟰V¬ãñÐïVöäÙ[Õ% «´%jhnàø†Ï>]M UbÕ8TÑýÙÓi<QY%RzÊúý^ÔDî_jT/=G:¤¬U0nÊ zWç°?ÃYûP±‰.ka96RÐ —{M§ÿÕ�ˆ–væâỦ‡‚àÇzò¿Ï‹(qª°€ã¬¸ Í�áñÝõ´4(’-TGˆ¯ÇÓp#Ÿ›¦°X”hfæAy>™Z0Î ‚~8ÍoªÆ‰¡êä)Q=˜Eaìz!—"#%š’°~b EúµÝ›„WlÓž2²S¶)nµäïŒ1’2^~Ç–¯GGSS#ùöœ.WP¦ Ù$²íx– ;=S:HÛÝÑÇ÷Fy.-ÁÛ©Öñ¯ƒvu1‡àåðU ¸R"¸ûþÂTÖÉiq£”¾E`Ò/Ðå~ඃ"ÁÄdŠ_;!Ý£(Sò\„žó-»v XÕ –*Y†ù²qœÆÏ/ä~òÌGY Q äQ:œÃ#6ØÿsäkU,$ð‡BýqrO·ú¦A$áò»éJô?ßÎ*C´–Ù+T i:þèlž‰ùߪõ¥–&%1’‚ñ*Ït«Kõ<}&£‡&¦p¹è mú8erZþ¹qAF´b¹C6ʀĥ¢0÷uá)híË íkÓI΢Ú4ùÁx/«ƒ+<Ei¡ \ݨ’ x¡´ñhµ7hTQ|ùçÍóíéD<sëçâkeè—ü€‚°ëÙë{PTœè[Fâ[4ñ‹¾kaè–¥HGž)IhtÍcžvNþΈ´<6d,.˜TUœ°F¿<W¿=ƒÎ‡ÝI[ˆ¯)ò»lL%jN ½i§ °1c-Rk•ê×Ówã¥M_&2£æn³sí?(Šæ©ÿ`Ý 5‘l{´Ã0v“B@— Ç$Qðš@¤Ü,ŸÃ3ô¸g½-@¥}—Õ¬;«*ØáÌܬÈk:š×ëÆpé& ƒìƒÜf5ð7p”Ýd­ Ѿ²Ô'–#ç†_:t{ ¿(Áª§óùmÝÆ,AÚ¬¯:¨;nb”ÝŽ‡"(-΀Á�‡D]Ía,1ý=©ÛÖêáÊú9Î|Ypúȇ/z´E« =æEQ\ ÀÌ?vàß›lÁ÷\z .§J‰¥O;ú’æZ± TMp,ëýEB|TTqYÁ©¸bi+ðŒœôpcjÿƒ°U™º}$¨ÕÛ`²FÙhZ}‰-¼Ô¸·2ꔿ ±¸ób‘3+…[°¢o×úÈ2Ô‘lo÷O®<qºÈÖUÎÄfú¼ñ"&•Upu´£òÉ©¨¾Š +3_ú f®Ý”lÛyÓÁCý!x$άŽã©Ý:ûŠ¼Õñ}@÷2\¨Í'ôæ N–ÎÃåo¢™c•˜n !úÎOY¦I죒€ DãllLÁ _jI }¸ákê¹qœ_±r_Pkís„<p€ÿ¼iQJiÚ2S}ÑGTH™Í¼D.9ĨVÔ¿sàö×ð¢ëç";mÐý[çíÆvw´†ÎkT½ãÖ”B9o¼ó›§ÎÝH‰øDqÄ‹r"/ÙŸâ :k·ÚSj>rÇ > ½´˜ßeÜC'¨¿§ñ½?Áüi´ÍÊÖ7… ÅŠG¾xpŲWO ?kÛÆllš!"Müæ·,ÿ)ÿiå|XU*  ö­Ï» CDôàqà]$HzÇÉÂÅ*å5ä‰5CærPTŒø†„3îêŸõ…ïÊ3 eÜÃÙçAt>Zž{Ðק±ëÕ÷4ìéÝÌË ÚêËÆ„P@@jÆŸ6ÝKxÛÞ2{6'H–5 ZÈÚ[™õ^ÝÖkX@ }¶]”nìÚò)ÿ2Ø.(±ÐÃj.é”ûëeF¾_x’A„®Ì™ç!‰ìÔ7?SFƒç§,“Ä< —)Øo#ïz\�drwù‘×F\zŒ7Œ�¿:mHl–5̲y&³ÿ?#Ô8Éé¶ü‰¢ðdóvψµZ`ª(Á4pnÝΦ’åÏî0[˜­†ÀX[ÑN=š¿ý%ÂIáJ5®Æ‡âìY{@`ÑímÁ51‘?ð,MC?[¥\i¢`¼NV„ò±,5–¿àh[Y9IŠXÁ!íõÜÓáZŸ<êFâS”ó©¦OÒù%.*Ê ÷ðb¶Àa‰¸zëåsgñ±öŽÃz%3òGq¹ÇauÌSò¤Uù˜é4X¯„“¥r¯).wæß;­£·õ!Œ ¬X1’Rß“ {6üói=&.Ú©€¢”çÓñXNÊúoELd¢?µOi!Z'ÔŸ¾f5>¾!§q?]áøž[ÖFÑ‚BÑtêi«o«$²@;QU¡³6†£M½8*>õ™Ï “!«ê¾(ž†VGwCuÑÛÜm¸îêvc­ÓJ™„ž WÜæÔÞ·Asšˆ©Ñ?mÁ{ 7ƒW¨*ËXµ:ú?õd{á߸€—‘›rb /j7‰LÙ&ˆ ¦Ì»C“”)-/øQGIé—uP8d åÍzT`ÐI§ž¡ÚMN{§ïFèíX“X®ðƒÁ€ê¥°ôu\)s>¯Ë >éŒuDoz᣿¡Ö­GÚbϬÓâr®4ï|”5˜K{‰-ØðÀ …º ¾PåØ´_uV¤úŸ¢°åO¬‘;žÚáðö~V3Ÿ§‡á|1ÿzß(2l(œF\º•h:àÿM‡±òÆ¡,4ˆ}>ûêË ç®Â¯Ðõ¾,­±™€ÚmÙ,ÜäQ}VKæ…ÞlY]7P?"丳æ ·Ú ÔIgçrJëºÐnå¾såÞÉÁiüăòq@ÎF"Ç!š*ƒƒ.Ù¬l~µë‰ÑžMGAW*èÏtÊV¢ì„þʤ)™\æªñž[©ËŸÐÎdU¸½5<Pâ–Õ=}ד�¶—-8´™m¼9`jNODà;§‚¸2ëqdP¬„«@g… Ühë©úA”+mB†ÆEpø¢ýoµË$ö±æiDQ­¸t_ìÔAÁ˜û7yšy* T¸¯€Â¬$O"JcRáhAJÿNs½§Åõ2‹-‹²[ Ì-Õ‹Öò(ö°Ùtæ<c(ÀôïÐ}Ít"wœ[|ȵk¬/ IÀ¦ýnTÉÂÛCÓ˜ñ+ûbb–èku¹p½Ñ‚ØÔPÊÒÀ"­('¬ÏšªÐvsÑoØ+‘'’«âG‚Uà¥ÍIg÷ž¿‚V”p%VÀ:F6L§åP[×S04/“_²@3–ݶmöµ:ÞÐ?lDî423˜Y­éÈH­ "ƒ /ƒƒëIkhï\`!…^Ó ñï@ÇqvT/4³€!ƒcßÁÒ#ƒµF¯Ó^¸%bZ-/NæØD²óB÷UÑ×Ù5j`Eg}ŒBÔÚßv_Ò:´¯lçÃØHEHZKhQKéo£wÙZÉ耛>®ßM÷yßëç~õ­#äPj’à<Aö>*Ô7 ŒöbïYëòïãÍÜÎÕ&7æ=Ë^;é›` GÒ2>øPãæç+ LUnŠRi±ûBät›†:ŒQÌ÷ãž2‡öâY¹º®§ÚmÅöXN SçÖÒG—†!SˆáyÏö§Œ§déQJÑ“›X³'SƒîÝì Õî4±œÓJaôp;<ÊÖÒÚBNMöþä‚k¸“ˆê1r–s„ã/“DÜ`ÃKµŸÈŒrÙÐÁàðrQMíL„7Žô4-}K1ßuèÎF÷C¶ÀˆãÞOìNvÝR-²lY.mO°+Þ(—!e{‡Ò§‹ É/†V‘pƆ5¥º *§{h:t˜iXåpºÙÚ¿lk¹aÎ4(u .ivÇ’2T«™Æügf»[œø;ü:üá§k¡S¨©%£Ã†Ög¹¶fÛ,>ÃõûL™‚ƒÎ`iQü\(J|±Ìö:�ŠìðÜÉýªï®ýŸ¡)CO–'eÄ>ÌFýÜ8?Œv¤ô3Èwšeþ°œ–êæƒ)©�FÃj38% …DvÀDýë_‹ZÈ=W´\ŒÙ ½E7¤ÕSû©¹ødlKÝC‚º¦ù]ûÕ Œrˆ†0^›Åû—go�³V&áÏ9+\U)¿¦¦p?ÿ]&l\pÉ\¶P w‚#$[LˆÏ;¬r”–Ø©Ý•§ÿ£ºY…šÊ„’Ï¿*žjg7 è°Æ¿‹%¡'/ȹ 'Ç m/6™95ÍäO¤)ãèÆzÚŸ¦klðK®ÖjÕFæd…¶w¶^Û/ /N³Skþ©´wT*}¦0„í©’õ»:øBz¬nÙØ…‰Ôúô¿Z\{C·CŠ\ÿè€rô|v“.ïÝ^‘Þ2¸Uºý½Q…qg@L±UE‡â?UÂó„2.8HÖa¿9ioÎÝÊù›c¬±'I5(@àÇ®ë'ÔG‚FæU8] ¬æ‚´Y}J°Ô¬Œþ‘²X !Ø´ lG×.HlÇé!þ$_ÍÇ ÖA`kûn6NQ¾ýûV†àÞ´b(ª¦«ÓÑü‹ïÆ쵟…á-\!V^”Æ^rá9ZCáEÔ3gsW¬tÏ®PU ’“’5ÚéE)C&ØÁŠ* Íë_ƒùä‘S¢d‹œ3²…më ö1Öåè‘ly”¦¾±]gè8þ={£K:î=ŽQË7ÿšŽí5–0ö⟄$È®¤³MçCÊ÷âÃÏ Á:'ôÒpyÙN+nÖê9«¯â®6²q?óÐÊCG6Ú3EP­·ùeÊí²Uxï°þæÎf_´ìÞfn&Ù­’†™—ƒ…âlVvÊqLÍàΖ©åÏÅ}-¬dÚ>-lfŠ­Žá€Ný“ Š³ÚïZÞGÝ×]äM^x)­‡¯´b‡ã*еZ餢¸u¼Œ26Ÿ­vëwPegšíSÁñ¡sbŸ›‘>’[/jŽW‰/YF¡ *¶ñ¨¨¨ûª¦„îŸW´l‹Ò7‰ %É”•èýäÑ °™]fý*9%N=Õ¶Cžh1ÕŸäqÜ SC‡`„Ð6tW¶ÍäŠ'A’!xTNN0&v«pŠG¢\S0=v³u\ ‘?ÿ�øõô2QãiK8£\76úfeP7s‘mV†ÉlÍ‹3ƨB?{¡ÜN@ÅûÑÃÛ6bñ4qù•P¤PA|àŒµÎ”ÚvïöLPiU“íÏé6 7îÎÝ7ÆcUZeNØKd¢ÝR|ªQ#Dƒ¬½ã`õR^†w¢cZ,ùs±n>¹‰$bß1Ûï{Áæ,ô!9!\õr:Œ‡/oïÇÝÁâ[æíh’6t¢kc8+ Ÿ˜Wîz7f{Uš$©©)™téÇ“ªÖ™Ž†©hRû³‰ÆŽ!˜+t@4½#ÂaêÚêìŹÿ`µÖ«ZM‘çl2” ;Å‘æ'¦1©Äê˜2I…±¶€‹Õn½[½·õ¸¦/ÏLêOÁo„êðÈEýuþÏË›Šnƒ¿ÖU”À¨¯ Êwo6÷1 ™W÷wƒ•a5Ò ºßóŠ3o­u£85ù?>(O¿´éŽÖX2œõAµ-¼½í+öw ü¥cJŒv¡=8í¾f F^†EzÛ;fíüɽ^;íRVL™ŽpÒD¦m·—½¤3†"ì]¾&ÙæeúÒý×UoL‚É;ßj—Þ»Åã¦}t@5‰™â)^’ˆ»ÄyS°±R tÓ x–n´kŽ>�Ój{8ô†“v*‡Ì8½‚ಂ»a‡Ç<¡ê´oNN¼ê%!÷…‹8 $§$Hû/o”êO†(�¿fâƒÒRv^Á½”À¦¶~"rt€n†7{mjma ¢Éˆí ‡JÿpkY°.¨~0¸F -=lI)G#r|#ú’øBØÌ1¤,2Þ­– ,�jnðÂMÇ)…Fö(ì»·‡#b3¯� Ú Ë[9ŸT¤³Z©V9œ ç¡Ó.Áš k&§Ÿˆ0† i2àÅå{ô´HÏ»~˜gkÝ÷ø~!(åžN Kµ1€£œ¬”dei]G?ÂoDybb^¨…ëå´åÔণ}uÁ³ X³…ý¸¥»‹ÔË€@A¥Ø½_yÕ5 !Áq«òc%ÓEQ)4|[]ÿë(ˆûÐ?‰œ]ÅzKôßM¦Bë¾°qæ'Óõ˜"O\ÑQ ê°Ãu1Ú >4+*ú øDÈd»¾ƒ,â‹&×mkéÀ…çAn5ŸsFÇízáJYdøO½§½ik} ££§)Âzjz( ÏHéˆ:Œeñb‡•¹“ ¥WûÚ*>ó[ß÷'­8U 5]žÐäŸíÍÏ-ǢWWv_‡œ4Y²›CT_ŠÁ‰Åêîm[ãyqˆe©;Qó‹=p‘óö*;‰3Ÿ§Íë†Öá¬^ñh�¡Ù‰í–A½èÜ\¨2ãªúÇ„ro½-1¼>ù#-ýÊyϯ\Š’y^mù'¨ýlÔL%-ggÅú*â¾ôœ Yñpo7œ,¨a˜ö Vê ìì¾cuÑû— ~/†Ð9´.[íë?‡Ug°ŽýíÅ Àe€U–=cBæ݆íXé 8-yFz ƒ1¬;ì/õ·ªVìÝŒìŽÛ“¹súSg,p³ºg®¸™¦Î8¢ÿ{“~éô`’•T½“e-¶˜q´¾ ˆ–lq¦õåÄËøEx|â²]6MT¶¿tº6� l]‰™}{Ý%MBÝ6jI>T6E§Ú“q=_> ýf—‡è븋+aéÊ&v\®ˆåC´Õd[ˆÀ€É¼Ï(¦WÛúf——‘S ᎴÓÇ€ŒùÈÙ™÷6x_9òêJŒaÍé Óžk•Î৴ôH†©ñ–ß±NY0@$œŽ3ü&«ÖñÐÕxWY‰žúá+ Ò“¶#(.ÁÄ š1æžË.Y¾Ø‰oä‘Ùx|ÒÖq7kCsEM°gÁ'b;xóÝëAoVºX—‹ý'í@}7èŽm»¡ƒœv.ﶵŸt¸óW¦d�§·Go çlm­3Fäׯ·ö™¬*c1ý‰ÐS+j–˜¾Å„DÅɹÿýÜáë¥îƒk•þýÚã$¬(^¯]ñºôJ-EqUÍ[ÇmG&ÍWœßþM ?@E9ó6•¯ŸŽ€üµLFGH£'‚žéCÌPy£XΙ›1Šw½ù«ú8×»a2ž±qП¾æÎ<b® z–}÷€ùŠeŒ ï©VŒ¿¾¼Ž•p@Ãx° ˉó¾f¶£·‡f>Ý÷YÄéC•ê)Ûž,¯kØFfìwäõ•êôÈãsåÈ0ç3mžO«Ò=‡úúq/Àº:G¢…ñSÞ*Þ YgnêÆ?‡ $KÝòý}i§qæÎcp’„}…S5žo d‡UnäÕF�lY¥ƒe¤˜W?…NÁ83VÎ èÉ{ïáCùƒ°åøÝì[_k“n¸Švx×fëØÊA³Öóì¾m°îɲ¯©£Uœù¶Qôаœ†½G)!©'–P¹pSÂ]M@Yb‹ 9؉hâõ= fµKí< æ£C¦ÀÚRe7P‰wéŸ ¦Fyd*JVEd‘Ÿ"HÚ§è’B®zz8Ü Òæ°jOÞÕ ô)mø¸”Í)ËëUCª®?B€ïþy‹Vi1ì,|e{Áöp…Ü™£&^wSø³G:uów-Ç ÜKçÁž´7¦U¿ÄtUwã·ûâ_†¾ƒq&š”*d´†•$Ô®ç·aP™àK§k칚ÈR\ý¡C'?ªu|Î|$3é꽩e§c}ýãL´NH„lVLÄŒ¾ÖÞŒX¬GŒ4Õ¯©˜Îi‘ÿ$fGT„ÚLY7 ]‡ÆóD£žÊGe‰¯©MÛ œ‡dÝüø½Ó衸ÿâ#ú_êx;Ü¡uÔƒµ�諾x.õ¯¢³â<²–Ò ™èØŽÞ7žž�Ïþ€ÿ1ºQ?žÊÜÓ8‹o-Lðì}·]¤Š{’Ú4_¦‘ê›Ì*+o\_•cYº°c-‚iO+¸SÜ"“˜N­..ýw"± hæA~!§'o!‘@oz*JG-Wz*ÇЇ©s6³§œ_ VÝ™êaØJè8‚Ì6®XjOTÛ"Oç•aÌ°Ù蟪V/ÉüaÙÉcÙK3Ùº#­äñ±ºg¬Aµn·—Ì&ˆ”øÜýP€ÎQ¾r£_ÓOyZö À‹¦pÕhé)z=ÐõJs7²dŠé#²ï³7À$½|9?ÎS'·P14d¤ý…F¼Üu ÚÇ®XlÍyIYt¥åÍnbúêy<Ó õ ÇàËã…" %Wm;OKàƒ_ ǘéò·P(r/Õ°‹V½;3¸AÊ®¨üÙúVaV‚œ>½ù—*ÖÝPß$VQ´øÔܵ†¡´µ`ÄMÍ…Rˆ‹ä0›N1¢Àòj!€JX¤f·:IC©Ü>úË î`ê!ó¢ä,; ÚY‹|‘ó Íæ“šS… Ó³üµ"8*Ã_ÐÙOb¶ðqê0Öœ´@è T/#䢴Z´i/ì;Â}Óæ`*­›–aRdK¼\ +Û´WžÇ[Ý߬=¥Fuô…B‘])Nmú”æÆŠ$ˆ%Eos²¦é.âœa³–û—nX]ÁR.‡ÔMÅñB÷ô4pŽ´m€uþ+Õ¥$[€£Ô�\­ìÒØ]ಀ¸¦é5Äu9À} èªø+¨ÓO”8¦ïóPq†Û×¥OΚBí·¶-žµqfðfÇžyúîé�Péxñ:W,~s¢ÏJ;•aã¾[²Œco 0Nfw¤‡Tö6H…VtÂ8õP¹-ñ›†¦1Œ3t?ÛÑLó…¬Î:V‹¹óð<Š4A ¹øÀOïEl>Ü>A‡£†ƒíÙÓª£œržD#]TÄÒCHº³ñ¶mñª·Ÿ¹°úº?×Þª¥ÿ�‚QVøªŸ¸µ±#°¿]ê(•Å¨XS¨A×d½ «Š5"£j:s—Ìë¢ÈªR'CÁCؤ©¯nš�;ÖO¶n_ÚÝ…íæ¥=ƒEÍç<1+áË'Ž‡Ãž‰&×ZÕÀ±®yLiº•L2åµdæ ž:Ú0I4yIŽ[QtÞØâ{E/ø†ôøX:n‹ˆÎðþb'/èÆy yA_Ï~Y™Ó¤` ±Posæú4°Pú¶NâúñgÅ‘}'™7T`atªë0œG¶üžÿS‘™x‰CÂÍ¥ud[m `^+ÐÆ‘#ôL^Lç±£ i‰÷píÀĸøíiÖçÔ¿ã°¤½½žáíö3MÆÌI¿ *û £¡øÓ’žöÍ™:KX ÆÓ†¿ÀóÕXÄnÍìôk­Z¹Ô» È%[¥ cÏUî· ñölõÜÕ"´$YxeZô§ â㻥°7NìtxòÐTZï&×÷+ú«ò¾4A!ŠŒzØŒªn Ž{¬½šZOb´…œXJeÁ¸§x›~iA?¾oD¾ÞÙ6HÚ¿¸¤°9Þlj†*™ztJØC\?Œƒ2e¼oPsjvwžùl²™x é^wضJÒç6¿@“¼Da”íNBêX¦ OðpQùÔÐïèoVÝÑ©Þ¸*SÏ+UÞ_¨ôFV²0!¶©èÇöè¥$ôLÚݤ‹»Q,ñú7=ìÅ(@éjpÙˆ†0ÍÆÇŸöKËšÕüRö¤Äݺz½‚œ0usw¤çï„× œ;r³H!W¢°wüÑß)7âs„ÝɲÄãÚšë\éžÖ(=¦ýÎp·Ö§þ.ˆ/ŽÒÊSØ£/¾jò ÚôžõkAXþ«ßÍ<§ê´ë/ò¯ºÇ·:„V95‰ô›Ã°]»3­G §^VFIJ_Ÿ6ª^šPG¯ØÁ7ÍuŸ<Á8.|¹{#K:{-%Š¡ó– ¿/î×4ô ½ 1ÓŽsËzÓnqÂZú=w/ͬ²Z*ç’Ý„íä>Ž#4èµøJj£,ZuÅÁ 9^ôY+98dD*Ê\‚^åxws=W|ŠëE Ì¿lõY~m©uþ*¬)òK'»C­ªßѸë÷&¡Þô‘Â,Tå0ΉÜE*Mªuîá?Uä¿ÞÙ{"µÄ"§ör^V½H°ºTid›…vbÈn`’C„ƒ¢A&ú;È¥ö5döûŸqQ’<4.KEÇÌ»§/ºñ4¥Mº se¯GP1&Æ£ÞµÛ.BJ»Ü}”_Z\‚,v˜ŽTÜ÷০:Š%ãLPLÑûhµD2®ûî°ý‘æ«2Öš=ö\œÍÍÈXó éF3úcÓZA[0Ø3Ì;W÷A¨6bdvƒ‰}~ô`æ2ÿT‡_íî,ºã[àdîsã�°9Ñ©¬!hbmbOG¤°lVÛÕC è§x vñmÖy/¼1Û*}&…â[ú²+ŽÃ†„1íR àéø×%D˜¤ÿ<T𗧃ÁWâ¾rȹ´Pº1=wŒÞ¶w"ƒ»—–œ(Ø#©ùë0ëqW^Oeóƾb>ç¾»3E¸å&N=s96ÌܧIPXKœ¸·lU„lÇÃ¥Ÿ°k|…¸§*MéRlÖÁcd­íMåµÁz)Ëý‡6¨º Yßà+5Kç–%Û+e»W‘;:â6¾ŠpÝ£ÿ»Û¦I#§–±ܶ-ƒrü4±…h‡$Ÿ—¶,·ê^œÒY¹“Í! ȃ|´2…É:ð¦ :xdظ9ûdqæÄnyLø4]¶:JD#L ‰\ 3‘�ø\î$}[+:­ç)B ³ìýÉKgOˆeãdý·¹XQ¤{¿£BcEë–Å{ÔèÜý%rlX±YhH"¬'Q¡8ܶ=´˜¤³¼¾^=Qq”ÂŒ:Jc³IÅŽR¨Æ}ìz|7‡ÀwâèwEo¬xaý =øòØ™‰Wýg÷õÖœ¦Ý�sÑP+‹ßþ}Kóà@™åE­ïm½qÕö+Àh1’üú´ÉƒÄzík A®•° h×GT¬3è;lEÁµæN¡—$r¢,iv¦¢9ýõäÈehÂcé¾Õµ ¿úùJ#+COIIOMßêdÅSsŒ9>O»qä:†‚ÆÚ 2ÔŽz† Ú˺kuÔã™ÿ1ž„R3P/UZcÇn%¸JPÙ,rÌfri/|`ÚÍ<ÉÑG $ËY@{‚ƒ¸´ „ø+YÚ#p韌cš`×n½Ãn[ƒâó6jнÊH£ÐWÈŽ'B–‚KæºqHßyçI‹m)`±6†½€Mä¸pl®¼^>·äPÓ%çÖN®Ñö¤“kroËÕÜË]ú@_ ÐèÓWS£341n‚½¥x.y»í-=�¢Å©Å uqwä*¡÷,Þ[&ñÒ ±îúÝ:çÅåã‚:I _iœj `©¼-þ4àFã›4…¯áÁ=Ý­¥+O  d‘;ð˜ããÉSÂßMl°ma7=µ¶q‰WV‰KbË–ÎŒäöÈÞz@ãä§[ñ·†Û«…[Pɨý+X•·},sk«5¶Õä8ÐÓW°L€¹Û]½·®o*={ïÅ£À–NÅÖä¦öxi´§Ë¼ÝÕ ¨x8Ÿ…EêaNà Qzs=`dV*¢æ± ÈaÜPn~©û·CýñÆèùWa¹ÿ5 Ò¢»ÕŽ vÖab"š[9ó¹ëZc Òq§ó_�sþåßßûÕ ò; C¹O§ÖÕªòxØ ³çå%tÒÑj6¶,M=:i¡eßï¡“¨o=—æûj%m½Y"d@”Lì`Ni!wfõ'ŒÁ±çFÌ©í°‚·gÓ Ž/-4!›¦<„Ÿö«|Ay@ÏVYÛÎÓ Æâ{}<mšËâßkUÎÌÓOÏX%š“ñ`1Ш™ëÝpfž‘k)ÿ@|Ò‚ƒïß…è¸õÊ¡MÝÀ0bèL¹Øe¯4Åée>ï0Ì?Œ‚Ö4ˆ§MO»vD·üþo11Jʘ ˜i �7]+¢m¾6ÅæšÓçVKLµ?´ˆç…tr?t6¸fãÜÌðˆŒ°RF�Òø–AJ Á”+?7:/Æ=Tc¶Á^†nÈÑÕááq'¿* €·[?À@ˆ% ÜÀö4¸ž¢|LZA ZôP9¤µ×5ŽÞ¦°jZÖ q”V•l¼€‚ç%™àX};­º¶K“ž™ªRÎÒŽ¬ëòÊô§X(FÑz O[°²H¢ºíƒü?¬½¶>t5nÁ‘Lú®:£6úeBÉ ®ð¦·2Z.˜òkÄãû 6¬iõxh`òî;v~+‘R.6Â(ØôY”Ó§¹=¹.—z5ªó¦ÍhÃtHú÷³!±wçƒb»ÓdÈ2ßH ,È®õœMe]rûå;¤#på†á1eAqj<tí–ÖŸó‡c%;/Ï‹‡ˆÒŒ™“bAè7}ÀîùòþûâØR°ozz”e²¸ŠXô'¹â2ç Ô„9~�²ò_N¯ÿíœ ý«ä‚’JYk,~ßôài¨zŒ,=e#lº%Í©‘æå.2÷šÅ쟾ú“êÖT#œQn/5œÓRº¾€•¡Ü •Ø˜õ &¯¤Ã»ðŒ'€ö¿e°J -²´Å»ŽK1¤â¦›5:.K›çÎØ—ÆãžnBdÇÝhp\%çàx×=ëèÅ=º}Rú=ªN”?iPÕ_ΗŠõ¶ï¨‚ÂÙø/¥7ÙÎŒ;̹§Õ¾Žê‚0­Ù5VDŸ¾¹j¦È¼ÉLŠ ^î»: ˆÀV@ýy8Žþ…IèÈ@ˆN3:<ÖêI‹Ãã„B‚i¹&•ªÇÁ¢/¼^‘Õ·öš›/áÑ»§÷g#I¬ Vêv©ÇeŠDvu{Zé×yÞÐwRxv:‘èÈbA±')Xמ^Ø#‘hO-:-=¹H–V€tdL²(¤ŸiÕr±g–µ8kX‡šÕDé¶Roßÿµ‡H³šŠÃHßâK˵|”¾Pqš“5OÕ¾¬÷jÇP~‡âº/àëíœ/fK¯ýѵ±ÝêëOGÿ‹«Â)Ά2W‡ýÇìxMÀSó²aÅ4S¿0XO=Ì<Kxt_´y’mmG’9?I J½ÁICwQàÂz1FQ"SÑl ø  ±•ŒHoù^¿©ŠÌ*z»¦ÐwrÒ¸•ÁH™:E“{W·Þ©Õ¾1¥`€í…Aî§ _�UÞè$äág5rT ÜB~XÞD7cÅFé‡ãuž´ta!·¢l:ïtˆ>Æ°;N²ñùãì닼‡ÛÜW)z‘,¸(:}Ìô ³ImUrc Óé6œksø´kèd‘¥ ¶›mvÙødlQÓ`A+«/H“2+†’š‰ €¬æ„ÿ¥#ü¾‹MœÙvj¨n-S.3´Z«ÐC Šy꯹Äf^B1ìe"'ûH¡Ä13´>vã-Æ[²œç«:Öa—]¿‹ Ø¾›' Ò!Õs½+¤Ù,2Bð8P¼åäoŽ»¦¹ =¤/³fx¬–¼o=_ù'ŒüÁl-Š"_+Š¼#íPKcÊ•¶«n¤}ȨµhBEyŸTJ'OÆl7L»cÀ”wsvN”›ã8æ&¤(²¹»°¸!Îl)2IÐywAÕ*¢; ÕuyÝÃÉõW2ÅVU¬Á"ÜPX­× uw{c¢ Yõ´y€¯Ï¼iS@ñÁÛM-ö¼Ç²Ðìpº»,üÌÞœŸžÃí?oü¬9ã¼È|Â?C¤n›£ëL¡‚öãq×Ѧ>rôÿnÄ 6´ð𮳣›sOÎÃa‹‹»2…HÙß1š¯<,AÉ=œfg'õÙ3"¼? ú­9 ,è?Ñ»,©ÅUóŸÄriÝ@ö zØ §–P²égø°\>æC\ýÔ³QZŠMÎàËÌ€V˜‚Ø¥eÕƒðÆ—TþåÉ>E£Ö|¡7³úÀ›}th(:‰…`ÞI¤{äñSz–§ Û7EY)b©Zg°oX@Ù}Ú^#è3›Þ4ò±¨ÐT�@=íTnÐQ‡J— 3C‰¾>ß@ԿѱV¾X¡ýö‚Þ¾»8ÛÖ¥% `೜ç1Š½¸-2@µöæDA³Ö6n› }`“²;•ü{WöôÍi ]“Ž°‘¸¯i9mùþÛbà¾mwœz¡²à±ê,ì7¾øs{j[“æ¶;ùº–0÷\CÔZ°ö öâ0P•7)´¾*áþi╨-ÚÔüUwÈ8+¯0nMCà R ¥2Ǥ8¸÷i¯Þ@Æ{kkH+?ø-n{¶<µº7¹ÕœÆó„ÊL7yþbŠÂô®¸DQ¸f9›\Ç$ˆ/:ò±ó0 {ð€ÆƒyóVÈ®**¼6®O[ ÁS�s+{ÿtëüÏ©§d—)L¬³ú*m«t7ÁÏ]”©Vø ãë¦é‰}@1Ò Èo8[V’#6`�lкÀ(Lçz`ÄwÖõv^j§ ËÁ°nÚ c$é`/(¥ÿÑím.ÿ¶Ý¿}ýï_º%O‘’þ„?È/Â¥uD£}0¡H°°3ì3NÈ^§‹$ÕÈ6¥Ãèë¯WFíO½ðM8~˜BÚ»<ïFʈ®úÐåB_¼&‡>øפr±Q±‚…ÄZ+ëÑüó.Gð*ŽM>+<ð`òš§ÀÄ/4W¨Žz[X­½`}Wz¨nŸS±–Ñè=ÉWØ÷uTîIµ¶ê‘oûUãw*6+�g‰T ÑE¿ö[b‚"¥–0|·×ÔP’4Ob3I‘~õ`Y,çôE7“Uvà]Ï¿‡WVn2³ý<F‡nNP¨míž­x…{=”öÀºëè’»81¸ðSãÙÑ€« EO3ÂÁ½`òØA?£»º=QS×)�Ç–sÓ¨²S¥I9&lúnµÂîe:º¶ Ñ‹äC„îGD£#·¬¢Á\‹þƒ7 `@Ü•Ü Ki4÷%Iüt—¨´?¶d|ª[ ¡]ú%ÍÔ©˜Â³Ÿ�=q©Ï[Û-àÓÉÚl¯vrÁ¡þàú¾ÃˆIÉ×Â& šéÈo@~4¿±IS{Ú„)òߺÏÙÈ ²Ü6ÉšdÙ‹}ãòå±™£Oxbk‡žv@6ûäè¨û–^ß [Õ1ÏÌ&‚Ù‹è‰Dl_óoï‚÷E–úÏ[’Óÿ²ÌûDWâM…=øŸ;‚‚PP¥Æ‹¦|Ìë˜nSënþ<Jt\V$§¯ÐYòœ!ΙÕaÑM@çF_á|1o ö¡§cÍ|r®`ï6¶L(6’ZÛ:öú”¬÷¼­×³Áu®¨@ï¯ ëÍË-ñ%Ëüy Ä>‹ ê‹C^?aÈwè÷¿›¦9-=1Š¸¶Ì›Æc­Ç•»”èQ~§À|­ÔLË̳-F_„ŽÜh°2i*îgÛ?YQé×”°<Í:™Ï~ÐÚº/ožÌ h++]·F¤ŽöÅt8 êèØÕW¢ žkX©ȹ ¢mãyi7wÌ;«ÐèÖ»ú#¤ ¥ šô/3Aqîœè~œ:Ï«]ËüµGê”B¸ÏJõN»Í؞ƌ`‘]Ö»Þ¶ÝlüŒ¶(m77ê8ŠWÃC ¸s›žÝì ÂáÔ0§Q´øÎÓ$ ‘&˜ƒ–Å)¯¡Ù÷^«´\ÍpíÒöØÚua#µ†ž(§É7V(eG³Ž‹ÝN#ÿ´ \槮o.w�žÎ¿GÂMt_´ ‹£z#BYj ­¿˜ÛÛ¸ÑÖpºþÒÞÙCÎÅ„…U ª s‡ÜÖç#™ë±9XÖÿsa½8õØT%S ?Ê ífÒá,·Æ“&l$Y‰›Àw‚0ÖšJºÈ1}ˆaùjBRq¢Œ…­Óôu©Š»@ÂÆÆÐèÓêúüÐÎ(‰½&UŒ]¾Å´ºêm ´Í GÃ_£òeA2É`^…-†ž@“âúžŽ»ªï¸Â±£Ü‰Jçrfu<ñ­Éã<É|¨B‰Xz§wí~lôg7nÐa3Àâmºûßiž…‹´q† Dò©ÇNnpüÌ%„|§G¼&Ž|1@“ qÄÆÂÆ°U"?ºq§èP`«0Ÿ€:¥3ö} [²R‘èŠßKéOl¼ ÂOk¶^Kûš­æ½ØÏiyd© ³à °aø©ÃC�¸'^"heš»½ßߪ¸ÅÙ†<ŽÂè»õõ8FÄñÛÄ$]rdèÌ´ÍŠÉo8â”õ¦„ B<×_ôÏi󳄻k ñ¨ô |¸¬;¢ýÛÖæÐÑbf ‡À7•á‰{¤ìú@ñûpÆe=kŸ|ŒáÃ# ØþO'VRn Î$æ3Yåä8¸8¸€¡™ZsÛ˜q˜È9³F–Òqÿxúix”ÒÆÛÀø«>{¨¿"ßÞ‰ïë–(Ø)%óz®Q:§W`õ]$£ÛQÙY®‚œºßñÚ€óS‹ÇHf `›[‹Ç<ùÛ\„ŠUš&¬DL3¯µQ¹È7ú¸eàúò„<z—©ã©ê·ššðž„V[d_êŠÊð®v†¥Î·ó±ƒgºÜ‹ô¦TÛÒ°ƒj¦&Ô+[RQ±ÁÕ3žDà9=½a<$ è} ûòœbÒ¤ï ˆ ïŒAÖ#ÑžÄ4‡_:´Ôh“H=ŠÖ‰ù_¼Œ2Öê9Ò‚§½Àxí„x'S–×€G„„3ü4š™ð#çÛ£W¸ïÇ ™ŠÏ¿Vî v‚>§&­[C?³m&ãD-—Ò)óÇìÊSMœ0wKÙjnKóýiÜëÝ?oܘGô'"¶cÒ‹»×’[œ: |™jÚ…qÿéI1uˆfŒ†÷Ýœ@KVõ½±-ä“쥶—?ãé;6Ÿ=LŠéÓsxï0ÈæÃÓ4^ØÌÒÀJcØ$èžÎ+Ÿ> Ã…¢T¹ŒžïÙ| ô⌂ÊÍ8†ÞµåuU÷k†·<‘’s¸¤Lµ¢§œÙwЃ!”“±.¾ÜügŒïäÂþí+ôc:í¬ÁéHæ4~˜6\¯Z°¥¡ßª íÉvk‚‚]ª3£‘•Ë7ÝÞ¥Ê+Ö(qéñQRx}“^Õý2L<º¦³ìΛ@L¿oD·î¼ÛLw.â°p>Œ\Õèu¬º¶™£pÐúx„Ë¿»á_>þRϺé·hÕñÑhyT€(‚°·`àD–cÝî6'‹{ µ)ÿªJ}êsô�ÿ<d1'ÔÒzIPÆ >;'º75¸šv@h†XРFúV:k%ûš‚ž7Ž³·‡E›ÍØUîÌÊ£¬H}=…¦)‚ÈIÞ¦ºµñ§C&ïêÉhÉ"pCÓ l¶TÖƒÄAÒón/3„c½!è<¸6’†^-§\,gy×Í¡3®Yz3w°ª? HÂÐW,JD?ÛØ]‹�åӼ˨®;OŠÌáÏTð‹¥Ðwíð*ˆÞ·®KbÂhèOÝaž¼«­x¬µ‡áÁ0Èvñ"žÎW¥ïñþé ƒ ç4»Ìò,ƒŽTDU+Ê:U 0LÊge:àäAr7‹uš<•{;w÷‘¢¥¡HЇ%Léçzë«Ë± ­‚θŠ××ç2ñ±JãÉ * öàZ1[¬¨2;¼¡Ãùšø`¤%¡4•CÅ´E‘°ÔÑI°ØÑ…;ñô2)·Èó<¶`-ú”«A<)‘†25ŠiªÏc¨¢Ì¾Û!kâV7âªÍן$îÎ~†wØ*†$’cíùç‹]¾W‚Ê–µL¿÷Õ\n Ž2ñÑ%¬ê•a§ <iæIrcÛ8°£„hýÆëçÅc^!]Ç Q;:Ó"IeEÒê© Z¼o)„r[`Ыêʵh{„…êÚêæÅ¢e�š Þo½À¿w·ôôÔXlsm–OG¯Âè{líÃþQqe¹OmŽrc¶½ø¢¬L~7ú@ÙLÕ_7HS‘KIšÀ[�½¿QrEDÒpv'=Êô:n'[4‘˜ñrzn¯ sןâ÷žà,ך†g¬Á[£iiÐD=CnRì¹,eP÷à†¸H~÷—XºYœyY0Ÿ+¶ rŽ™žn›ˆØ\ïí 9lÝœ.ôìãQé/yn ÷4­ùObö*$xgN0Ë -À�}®ºi–Öµžÿ%ÕݱO\bËã ¶\êYIó•ô"Ü|̳\ÿ¡ûzTz‚%\YO3ø&ÚØ/½ì|Œ?:‡dþ£×8bùnF“Q…QÖÖþÌ›$f{ Ú Flo°Páµ@¦åB«;õø1 X Ó yÌS¼OYô FsÜ“Õ:)ƒhsôÏ;ŒãOZEšÌD¬°Ð»Q‡½ìiy’â`+ØFT|“ë7RDªÖÍCdc\¹S.Y禽Ø,§ Îd§,8þªëY.Ç{*»’ÍÙ¡ž¹ÉÏ/ò8ïë’~'Qêü´ C\’ ì¦W‡WnsͤZJClµè.í ôäŠØ•¶©(úÔ'WÙ}QHFܶB«Ó?oqXS¸=Ž}=ZŠç·êŽ™§®Á:RÛc <ɧ'¢ BËÅ °þÍ;ô•RâÓ£h½O%`îÜñ0é�,_gÔÍAÈìòrÕ\w=ˆÔt7÷)8žƒ@ý/¤HmDäž2mÊO„5&©aEÈÂòž±PUïâNŠØ·}/Ô”jÓyÈ0ú¼ –¸ÄÁ™OÑ_Ƥ “„” :ÚùI;[i œbâ²Ûlè¦YϘè&§hÙÞåCîl.(Æ%‹ÊÆ–C…“}‹VøVW6f»¹gŒ,‘“ÉJ‰pé±9 ãÆ'˾aŸSªùš/²:ÏœoT¬/‹XŽVìÄ å"Ó¥ïg´N¿8ÿ¸zõÚBÂK¦šl4*±Y@tÛº_ŸÕIÛôô¹€ìÔ¶Ã0`š)Ô=0ñ¤¬XAx:y¥žs?Tèô⶗‘ ­v½ëö£¯û(€ÀX„¸‹q¶ò¾ÆÞÑWõ/¿ È ¥ë,•1…*]éÖcVXX†—L‡úF�^çÆ'“vuë‹níµK?:¬CÍ0 —÷M<ÌyÛýÿþ¿é­¿ ÃâSžÒ¼Uv+ò…¿v˜+hÆuZAŸv <I&ØÒsåQô##óÒk2™m81¬ÜÐD©-s=}h‚y58ª÷è“=V-Þ ÏÍafØ{»‹MaÝÈd[ÿíz“üÀoÐ3•Uë5½w¼VÙfôÖ{ÊR¦{”‚Uëï÷r'ùóðLŸÐòT|°„PFˆo‘ê»ïó\QÇY §+¡ô º^K!&W3ÂÖt=(ç‘sŽ~6åç¯ðÎY¸pˆ²ÁáSQlÏ õÇB-ᣉ[cŠ•ûVmGr:Rì%Aµ~·K âaÑ<Z½ogqž®@+9ËŒ_ÀS€!NIRÚ©Ž ­µvüU’iE bÆtÃ×~€uØÆùm+EÄv|_ &Qá‹� ”„þoaÇp+í6Çp@qŒÑ°­Üvhš5óšgó×3¢£ó‘©˜UÝõ œŒòÒgžÒåAÅ~‘7˜C®4±ìçHÇZǦT7g&!mŒëŒ)«²e»dþLék´øºMME†¿é‹Ì‡‘Ò Å~ë݆m è×°F2/ˆÔ‘_Ô"#ª!FVo½(4BQ¹"kªÛp¢ íîè\"w¢Ð Ýæb~auÙ¿œ¿(#¸o?É@’¨H]!eiJˆàN§^zì†açìTîG‘8wEÒþ@§]5O²ÌÚ6_ìöµ?=<(¢È;óJ¤­èNvkï+A‘ÇêÒe¾+å±”-M0¯2Kâ:¬r)M‚uÐäUoƒ³‚¯p»›çZ+jª|9~È*K=V³ ¹H·ªå™`êµ£¨]ê7u{’-J(ä}^T„nàV'tÐphLÛ uÉÅð,héé í»Ÿ#—'†qµ§ƒ¶<]Ü W£¶RL‹¢5f?ðll< ÆîM¸Õ\zÿ¯:4ªô›E°´0ÓI›w¯ÓÀäšjJýäé³~Í•ˆë+$È&›Âë:’Þ;ˆN¶¿Ÿa L¡Hkú[Wék{iWÞFhÕÐ^¨ÚwO#°?¨Obƒ¨Ñ„׉þkœÐyH‡iÜF°‰Ss$´ã蜶„ `½ ¾¾ ?«ä±z稳T‚öÇa•¨d‡ž¶îÍÉFGØƇøEiìDÃzf´± A]¬¹Î6:}ó¢°R½0ÑbÞõ\w$‰12t Õ2 ü"¹¼«affW툅 LlÐ0ǹ¦ÿÌܦB!lº'^»àëÀ'þŒšE |ƒ‡sGŽà8P–S÷|žßK¤_rùZˆ1C]¾¯èReQN¯‹;`_EI)^âQ™—ïŒVÄŒA\Bê¿Îå«e¨Š=JæšN)÷¿Ðꈓb¡+ ­júJ¥Í4´’/�¢;™ÀL‹žKïêF#Å“­6šøˆáöWuš]  >äi„ÆÕÁTÒmãCM¹ÏaÂÛâ€q>C Ë!­\hG'øVáUTh˜q5æbËzCøn€yçw7ˆ,Àªý~ôé¤åOY¢ ¬g+#õ­ ½ë=[öÜœåvô¨ñp÷e2Jxpؖܘ ®FzÿA±‹qÖK$`ðmš’xòÊœDìó ;ÖŽE·®w£`ä Q"×õë7ªíªs´ÛP:Y}-X§UÝï¤÷hITa¤d^ùéµT¤weh#G_,ŒˆM³Å,ã]¼u¬¥ciÞ«÷:yF,vñƒƒ¥F ý_a©AT¯¤o…ÁOšE‡ºç•üªd•.ä;ÙÀ Í=ÝÑŽ¦íañpí`€^¯™¸¹¥*Ç”‚"Èz]«"¡/Ó8õøP¸¾!³¥•¤¤ƒòŠV— Ãó’7eWÍ‚l·¢‚Qž¢ã‹AÁÂ,x È 6Sš˜BN'¹ qNßïØ[6í5ôàúÕèH8÷ÊÑD‹Û/m–,¡o>cø§Ý“ŸÜ®Ç¸Z<D…€O Lÿ0Azf ŠJü?h(¯”Ï#Z+mGû ·jTP42 &cwÑWüGóÐïʸGä´F78BÄð†Ã)ý17óY®úΘ;\ èw§Õ¥K)=¬Z­ÈÚ´:¶„fÏM³HÍ`iËQÞLQi±œQ‡4nšX®²ó/—Ò7Yj¹™¹¸/ÒÉòyñ&ªH¦‰ïC%k?á.ë«×k.²ŠhqK;‹u‰³nvà4Ór4ÂìèãP&-(ÓºhÙØ¢m4m`üÒ{éÇDdû¹Ñ㽫k¨•Mgä3w})­ÍŽÎ³6ЬGˆžjÐl/¾…ZEJ6ŠDŽ£b!ììô¥Z}ôŒ(™0æÐiÉF(M–OZri¶œ)Xk%Ý|©’·e™"ïyt*^gé$V®~4%’™¬‰‹3Øõųwt©¼Þ+ª³´õí¥ïÔV¨geLôóËJ{ ;Pê ÃêyÍÂöØ™²J!t}ùâSFå,œÆ‡í­R.ðs”ÜóÍdç”Kãs{87%bÉ™óèéÛ½“*8Š ˆJCh¾;Ó!+alÙN«Ÿ‡žÿ³q¦Ê*ü»�=OóH^ìÝÆqdÁ~ÜF3ê‚ãÅ,¾ÒŒbLKÆÌv¿•Œ"O¡d÷Ìš¢ sàAÞ™³%4Ñ‘ÌTûG’¾ç îrŒ”J¦­.1¤ÕÊ—h¢ªÔöõñ‰šD¡?y„pôH u¦NÄ�kÓFx=Ê>ìæY ©Áa<š­ðPÍ$šI\]Ë št -Êù½ë¶{‹ÿ52ó1ìcú½Óu£î„ÓOaëöÏ‹X Å÷y¤÷®ú¿n¶£ûƒEI#Ùöܦà Ä;„§2ôɘ,טQEnÙÚnúhkœ®†ö¢/ƒ“óKMk§©xè'«ž³Ù*úÐpµ A™Íݼ5ø81“ÊôšU ¶Kɾ˜0ÿL¬šŠð”&áËƘ•÷%XXˆK‡Øª4¢_oFŠ¶<y¡bpï˲_‚MÀÙØç™]¡Þ(¼qs‹EŠ‹Ìwê¥cßæ=»&ƒ1åçÝFzM®SyÕæ‹ÕÒLze°H:ßLšL¤‚V“ÙêkÀçÈW¦Bã�yoð3Í;‚z/Ñã1ƒ'†¶NV\ê/¤QìjaÚD[›Nz}cyEÓBÙ‡"Là ºË�J\U¢Ðoå@Æ‘>s£Õ�ür/@¼×ˆz„°Ëœç*ÛÈ{:sk%ŽT¥n:]Øכ͑ƒéæF³ÿ<Ò;?]Ä€²®Qör2Çϯ‚FÞ«?IäV¼¨¢ëU½ÚÕö0«•ÑǦ�"à}-ääIœg~¯d®Öî û¢6‡/¯í%Pëð¢Ê³f먷ÓÇkk•Æ|—&øß ¾•|œ’ÅýÕé,6%=­krîV¢ë®njëÊ9Y"ˆáÇ™E7º&;'ªó:\ÓÄxb¦¢‚£­í×F†ÈØÙõ% ;ð†.Èb®¿ÈòiÌß}~eX¥fq `¤¬%ÎÆN 30`Fì˜]«îö+øÍoIšk-­ˆýÔ˜sæ2Âì¸úQ¡Ñÿ¢ÔÙ‰HchO§x¯0Š\,ü䇽>ˆßaü,rÀ­+ôi)-½±ÏÒ]}v„ ®^ie´)fm¸?ô1McǤb¥Ú0E)¯¹Ì¾/Ö¼¤C,!ñ©‘¹ßéo®X|]aæΟ€2uÖÝ;—®È1©œÎ |Õ Há€Û,sÃ…|+ËŸ‹ ±Ê𢕆Eê!_5vu×]¤ÈýœÎBاµN‚+Ö¦: âpeä~¸GþhÈžV¾h¤_’<O–Ä“•"j~Ö©¡_Â<Ìl–ij*&÷8³õÈà4%¤œWbU˜biÿîô›Ï'‡MS¦‹úq £[ÈL¬OÞ„‡>´ÊA™A癸!ßw‚ª<¾<;°Ï%ÃÙ§R­Ñ_OGŒÆ-úS©‰w.®fîé¢áœ„T>gtê~ºÌÃBåmW{˜˜sWý9Ø~6O"ž9|–•?}¥öLUZõiñÄ)«œtýåÞ,¬÷,ê+W]óXcÿ‘P’ú×ÉÝb… Ãýa¯BV5ÙqŸìœ¿ééOfüh²Ht°@ùb:°lIp–†JïXË"v1)±Š7ËÿŠrâŠt ¤é u“C¦”ÎNTâó†Ý*¸96ÈüöñÙF< 2æôé»&ÊBwv² õ †‚š~9!OR_-3‚X œñ»'ÈX¯òº–âBƒ5ÎûŽÞ³­ï H‡56æi0^àœ» ÷ªòý`0$AyÔ‚%CödPåüäaÇÆ’¶/©Sy²L ’Y1Xé!ÔC=ë¡é-�.”‡îžòʪôGØ:¯‚Êr̃(n> ¾Š ½§š7ÿ_¤åê§+dùºØîAU–‰5Ù×QÝØÑž0¥óÿ jMáÙ}°XÏôTÙç§m>åWSµ}Í 'ß÷Xƒ×9}&@{zøIçÛ Ïè­ðhÐøŒÿß[}bùþÅõ]»ak—£o±‡Í`}Ö›E'ᩧ[¿³¼ýº5f¨/aäãri]D;á�&ÆQ3‚Š[ÇÜ°3#Éækû#J9t¢³à[Û­QÐ㣮÷/Ï©ŽÖý¼¥ºnÞWžõæ0 ¸Õ¼.9Ü…«l B½¤ÔcPmaÎì×Àèy.¬oSœK{t›ØÞ×ãÒú6§;y˜(!?Œ*˜òü²96çbÛUÖæÓ~\,n)ŽeÝtƒ˜Ù 3)bSD[>äiæ{—SN â¢ÛxØ°°¶%yUØÞ·9Š£Ô¯©˜­Mk:´†ôÏ9vÓÖ:†&èúõ–œ]…žj70ƒgxj óð”SU²ùx¶%s—¯Ñ÷|O%.DgÈ»Z1ð#èÓÃrÌ3Å/FL._Ùm½sÀGŸ½›»3Õt~ä_>„ÒŠ«| þÜb†{ÿ§ûÁ2ͨ¸IMÝÁn‡æv£Õ� ôèã V¯Ý¨àÃ;ÖI݉0¾Ù¨wžyìtý¹½Ë}²Òá¸(ŒX$ ›Xnèù²‡Ñ@á’꾺šÑ€é<².Ÿ/r…2²EÌl:ˆÞ¥¶¹|¸ïªÝ‘>òÒäÏŽ ðqWËFí.ÿŸ´ùÅC×yéÆ¡/BMùžÂA´=;!4¶õŽ H^‹ú*_YªèrÝ:畉˧:«éªÇÿóŒ[Y> ê[š´=öjÃ1Tùº¡(‹Vvg%F*S§ž/ ŠúV ¬Õµ=bôó®E ÛóÕ>áÜ×´{Qà®È&žé Ór‚ yÂäjÚ2… ½c¦Þ—Ë3_a (4?³O C²5žpOXk€¾ƒ!qJ.fttžªëDiâÔ\+aUÃôïäÀ/ð’Ý Ò…Î¡h‹Ü»Ò só 6«ðGDì÷š¤A¾Qkê”…»‡ÏÓá­>éñ³,îi\uénºu±Ê•fn8]`…±®Í»ƒ6Eµ-´Ù60ûc=ý²Æ°C$i>°Yöý`ÐÀhó6=eœÒŒB dsB*Ù B½'8Ñ+ýÄ’¾MÛT;5Ó«° úv<í÷Z+còÚ×<^y%…ñÕ ÖPþ±½îÉþàÅÈ»éþ“Ìߺ·8m|~$“â(S½=´ÕVZ””–oÜa²ÜÎìeÐöBù©» ˆ�J™&ÛŸh»Ž!;`šñ9û#"Ceý™d=°©ƒCÄ‘¶È¸¦àíýâl*I½Þ;ÛÄLmòÚë\P¿?íÁÍb7ÛWqäžîCd¸HîÞgO•Á0=—˜|5îÚB'ËEgúB•åŒBüž wŠ÷µa€ÜËëèý‘®ì¡ˆ‰ ¸>õwu±'¦% jQËéß½á˜|7õ]ÿ…\NêhÁ: æ  Ö¯Ú{V‡sЛGu{ª8ðŠ&A¢ê›FŠ¹ æO œÝ»§Ñ:97ÖÇœŠó&u3†SûÓ'êî=Ø9ŽwÌ¥f­âÅ>ùöÑB’q‘jÔlk{‡ô h3¬ÔIþc³¢¢—?/|Ír3÷Ñ,$"U{9këš•–ίjãõšÊKš¡G|. ®E‘q²I±„FÊm™ýÄb;ö”o$Yš(æƒEïµ_7ðöÙ±ˆÁZ7ˆÌÌÝXqiÞ~õãR€’SŽžö¬cœÜvN 3$^½Ä#1> Õ¼éûÅNâk±°eU;L1MwþEÇ ×«ÊÕ0VT©ÏNecK«MÅö!Ö½å¯;[Nyn·TZ× æ6ÀÎ ´2¡]­>¡G¹7¼ôÝYøwÈÎæ$ÇɶÛ@ÇWÛ {Ñ›3cF'ñbññ :ç‰ïK'Úþƒÿ²ïÜPºéz6ÑdɯÀHÊܼú²Ù©Š ì€Ø²È›šBpm¦?ÇøGN|‰g”qŬrjûÕ¢© ÌÍH$¿gq¸{ɾ¦ò £Ž_z«¡—äùZ]âL‰§C‘ÿJÓR{ñ&mæÙgX pª¬·sQ»/úÀcý¶é»A¼·Ç ÎNÎA¨Þ Ÿ^í"q¨×[õïühß6çÁ ÇÛ“UÁ£êRÒ{—K€W”Å&Ê+ýgµ¦t´ÚH5É™?È–2Òþ²AºCKÅ“è\Výix™C[ľ¯lÀ9ºNÓà%õçiæ…ö ™—Ci¨ëDS®ìÿì&ÕhÕc_¨d[+ZÕ* Æucl=Ù{�´ÖXߢ¬ºšIYŠ¥À@ éñ‚¶±8ðÊô ˜SÂæ…^åwS^ÿL©|’.š,Q0îiíý1åxØ»©Ô5Øl âÝae’¸€È_ ¡á©)i?_ÃŻ̈́å>~=N¢+õ£Õ:¡Ú¾~÷äV»~SSwy£»2Ç TXžy=ÛZ)âR€dDŸªÆ‘³@hMgêÆ“,~ŽŠ…t*íÎsj-/ð!S³ î£`¶‡Ó0õwñò±;J»“.3–d:vƒI)œÑ‘»OÓVx’^×ÈÝUÅ@*[›'Õá4Ç´Û2ÚVJ®™ÿjÚÀ߻ĕ^C)ª›SF»Õð¾¾`Þnξ,˜dFë’+ Zù÷F¤.M\òËmµiEce«Jvì?0¡ü)þ:¨É)|EAS¤A:Ìö ^ÇÌ÷Â�¼eöN'¹áFÞüâYöšf\Ž¥¼ÎëVá õ5E(ó×njëç‹Òù½ˆ*̪.‚²ÕX&ò«k-º¢ÅG1�ËXìR 1ð4j­:]i”ò¹ø(¶_Z|”LÑY·ô_UQ¹à¾ñ€8 bßÅwÄQã8R>tä·cḈ³óÃØa«Ö.:' ?lk‡ýÌÛ‚w×ÄÐm±úHÈŒHùo;ÅâO„¨ë­ ™/¤·ö”ýë»"M3Ÿ_e LÒÛ[^ðö/'V ‡À¢)¡>ºĪ{VÙ*%(¥M|€&Ó‰eØÙêÏ®;ÿèütêâ™Á"¶Û*¨ìiOK-ƒß/>±Â`ýÆoÕµðc“ð¾ècfkkHzz+ÎR2·ÙÍúhæ…ØÞ'½úÔ^nÇšÿÛrÕê˜58ü.­gl· ½¿Ê³…qy1:"­s¸XÓ vŒBìýáå&^_IMð|½Ú¬„8NÝmÁýËùzæÙq3µÇðY5œA/™ë=ÄàvŒ|Êï¶n+¢m‘S‰Yåvc´^LC¸q$^¿Ü°U±p„*‚M:IÀPÖ­›]*=Ÿ2åÊrŠL^zìèîC¬&² – Ÿÿtdðë ¼ Ï;#o\L{x%ª)Ý™“åòx€Q'6ðà¨ö—–—A/^ns§sÁþŒ´=Æ åó[m¬bpn’ ¹^`Ç©et?ö¶çu §ä㸴v”ŠN‚’Š|é¡óøb3œ¦¥®áܱœ¿HÛœ?Œ, wy=²Šþ—çTI/Ó™Vì =$j¸¡Þï:4Œµf×%6É=g­¼²Jƒ¢à?×%åµïžkñÉšŠò©0«­¿üqé—¯¹c¼Î tr½ÛðåɶuýîoOhsgDl3Å|Dq·‘)T½)ªuF×P-ªqöÿ¤´v‘x®„H 7cEá0#…míÍ6ncÉ°b§¦€¡ µ.“ \ë¦/é~‰£ ÇNpô7»ñˆpypéÏ~­¾ÖÙvvÃIiÏùz<?P}¹íÞ»RGÅÍ”P ™>]ShèÎ2kuþ4ýq7«…ì¯Ô£<ryËÏsä™”ÜsfTâ4ã|\l]¸CUП(µ›KvÌd"~bΛÑ¡\<gz§y eÙ”¢íîA]èГ~dz[ãÜ;[L#Óþn~ÖéèÂÇ”vy?ÐíÈÇwG_`ê¿iC˜‡`yzL1ðà­ñÈÀË–ô/H%åT[p€¬§Ù$›ö[-~<QKÊýF”<ᡶ7‰£UþV›CײÛ-.ÞÕæ|¡D®µ¯@$‹ÆYP}ê,é�e¬óÙÈ¥¨ÈE& 1ø†"E¡/m !é/ºãV¬"f¯Õ‡…ô»uýe_W\‘suGšÈiÄ‚\-ÃCä2‰ú£2&tY_ÙCøÅHĺD|ûËð+zxŠh=mæò]åsY sêŽÛéUçZ«¸mˆ¿)o«¨W¥ä@Ô‰7r)ý:7—›>‹*@I'jÓÁ<8“ãFeñ”Ê9mél¡ŸºÎÔ˳A;=>—=M-ky°‡,Mxük1›kÌ@{5þ>’ðZ×Ò—óú¬7×ØHC3;kÊ|‰ ŽkUšÛ=Í2”ÿ–ßPdvš†Ã�“U Îw HÜr©ór—c ™«£dξyå/v3Y½7j­ÊÌ£ÒC?C8Þ´Nü”½øæÑÞþ‰ûú\zÃŽ¤#õˆ†4(êOWTô»}‡û¿çégÔBõ'ã,=CK4Ú“m*UJ–ƒcÃ:Ðpyýê À~מ2Ê9 ÊÏO î†‚¦rÔ¹¢j,|˜%W úYj †n@g+ò7ÁXÝ5ö#2ý»—…OSµˆ ~ý\SÞÌÖˆ sž½ô¾è=<Îÿ‡¾>¶ø4ëÕ2^X*Ffœ¢.ª¨£Q—CT¤ ¼2<8 3…;Â[vQ³v9@)Üâ1Ü¡‡ÊÙÅêW°à”s2 ÔHV˜‹ûð°ªÈ¼Xá$Ä¥•ìŒ³µöa–-<Þp¿%±‚üÇÝß=8;EšÌÈ1íéI„•U‹ª¨Ž³óÏI’Y¼ØuðاAVë("F‡ÇÕäˆîˆù$¹Çô`½ýóíÚƒs£Bõ(®ß³B¯ ɼ£qC)èçÑD¼±nJìâ]Aán€e;Ë Qµ&®_½XÀSgZ,{úʹS¡HÒ4yt®#îžEýÛû”féî‚»Þ¢ÃZ›×f t;¦£uC>BÆVø¢Æ âÿ]éã™°ˆôÀí îÝbyÓ… {™ðÑ=ºÉ)ÆöúíÄ|©CðÚMG]M)¾çáâ)<Ø$cêÖ³@À=[U+h[®ÝjLƒ´·–ÝŒb覚j0›Þïdûpyz]8щé»2Ⱦ޽±!åMãá mS¢OHr{Ý ÃÃÈ•2§»nu•'äB,y.%zÝÿyCW9×ktßJ6%Az´šêPÕ3jìÒ\åµ±…«Ò…vÉQ§7UÆŸEÖÌ·ÝöCÓdáVOîlÕ§oN;0YÐñõ<fi™Â¹KHÕ/¹´eYæaw(ÅiœLgO €î½d"Á|ÿ8¾©j2§¯#Õ�%Y£ÖìQ¬Bí¿üµ_å\êp6·f‹ˆ_.õΦ#„f{x8"•:ë|îºöÞ¯øXcv?ŸÓ& k‰�Ý£q´Ý ö“å0¾>"Lâ…C N!5ŸÌl£ÞdªšX½H#È}ÉnÚ_´Zƒô½÷¼Ã Jy)›_Rë‰ã…~X ~ÚÅíÙãwù$\->0LXá«g–h $%ÌgfÆÓ˜ph<‡¯M7ÖVSÆñ‒(‚cÛ*¦÷d?ѼÓò•ŒnêÎ<x§h»2.œô.“ùöÖLTrã]ÿ€rÇVȺAAO'ûÑõQV:±´6 ùÆí:*ª…Hpt_E®7f\ ˆ·Þ}éíiësO!ç.¡º(šºQÐ@’Íjê‚åÄ }1ÒF?/$ªPÿ¢mce7R«­ê±V“0Êr=+–§æ維¦|õ§G“¡?ÏŽÅZ¯¸} òµo'ž«!ƒãXñº1ؘܲ…WbÈ›×¥*Qè¦+ì,€­ÎZ¦ÐUá T)~ŽÜÒ@#õ Çtã³Áv1ÃDt'wõ^ÎZ#ý'vvº™•¥«ó¢ïw§“àxaù°¦uÒôŸOVðïGºax¬Ææ:Áp¤’uÞxþ¥XVíaåˆLÃ|¾ Æ6�[‹ªòuÝ ö݃ÐÏI‘òƒâ{²Så<¯h&<ãžs/áœG¹õ4?ÔIÒrðkXמ¦S†3²îú#/ÐÃyöØmvSP§á*¼Å‰WáEÌQÚRšÙkX>Ôo,éhIдϴëÚŒéã3³á82Z]Ð"£ðƒF»‹Ì«Ã°óÜ#E:Á®Æ›e™U>„MÍzˆÖ�‚é­â@.¦Ü»¦ÿ*ˆwzÜ[T #/Meä¶ ò^‹#1P?oÙûÔä:ô`ˆ?$ê󶕨ÏÍxeõ' ;‡�Ù…oÇBMvuø·À‹»¸‰ e拆i0îË î·¾U$%QLmÌ>2j´öâE­Úréè8è¾èk$ÛÑÂÛúhpŽÝÌýXõ¨0±6Æ×¢nqäëDe<\8ç”5(žî°Z>ún Ê}•@‹³cçjF!î�wÓFÕ{6q’½yäWAâ  <54säàG×è¿.Q„…©ê.JᮘтáëãÜîþLUü³Ú.*ýô%Ck|:£õÈ?+NÔ蜱Ü9FÃÁ*EC•¡¥×#Î×îkô¿(ª¤9’HúªÛ­k¿ð`¤œ˜8¥µÍu­ó|åžé ªe:¤ ~ýéq®¹Æô€H´ ÏC·<—šC?‰K÷â(R³™82Âç: â/`ÂÙ@Ø{u•9pž(€UÞÄ6sèÛ¹QhC$!ýp D3^†¡þð6wB«R}ö ʬ©6HI€ ”JíP=ŸÕWMWs/]9±ê©úÜþÕNŠÿ:·ƒòiYºÎ#Óô ç“•|ƒ!«Ç¤à|é?UQð‘Ó£•_có.äã†RíF›H�ÉÑö6h­¬ÌçãÎT•8G�VË…*«ß= ò$ÜSÃdû%}Ê·NÅ‚Ð@IKG`©%¿î»¶33ªþpÝné-Ø0áŒÄê詢τf U‰ªú­þÌ´Œ úÛ_û'<&F”Žý²æÐÑ?•U?„Rõ¶»ÙB#᳘sûÛ™ g¸Ç:£,¿ú®pð¼rÒ4¶”zI·8Î2_-„«EH¤˜DI1 pÀ3–åHaHK{*F°ÖJÓ×ZK¥áXÐ)j½é“@ÔÎøaòiàœÿƒZƒ‡ü!gÂàö0¨Þ•U3£ï=5xfº!­tô¢)¥Yf—’{*Š òþ× ·@·ŒV{<e>äžJSjYÙ悱 *ŒxÃöÓÂÛª›×ÚäÿV´ÁÂÁ"Ó¼FzÓªõ½ýD÷lSS¬Ñ6Ë ¾Q£¾È½åÅy˜ùíû4ØZûjy`tü½í•]ÓЇ·®Ë¢ÍÍ'n«ÃxÚߢ¥U%8,Í”kèrº/Ÿ_.\ÖƒoßÀctŽ€1ÕýÀxÛæV™/d2 µ(ã«;=ºB³]dÍl=‰™Ç?xµC²nƒPõˆ 1ÃœEF{ŠªÚÉë³Êë•õMaÁlã-!(o-¨˜œµßï¦iw`ì»LïE¡cR9Aå”q‘30v™Š8£!Õª%ÖLgª¡mwäMoæÕ…GkäFû¶¦ôn=“àc¥ äÝÆÓnêwGÞËYxG—81•fiŒ'(G ªõ—#4aÐ.ãJíÒÑ 0N"ß8§;]poY­SzS;Õà*v÷A9 ž‡árdÏtwõ²i_ªa°£í6 ªÆ²psÖš­{Õ–%o=’oø[˜95~!½I–4ÛàæÄ)¼Þ;ц V“ à–•‘ûþéÿR–Wî g¸F ”¸¹Í—ÎߌùKÏ'A$wPµ¤Y´Úxªõfâ‹þ¸ÓV|È“jQ3/[¬ñM*…ä?oyá” Íâ}U7.2ãIÑëœy­°B#„]l·Ë¾…yú’×2ªbbf5ÏŽêHÿŸ7F…Ýcj¦=…䬤ºŽ“Š«{§1{<üóVT¾_x¥Éy—Ìü„Ö\x‚Ü`œÑªOÞu"˜&¸³X¤e6ÿœBýo!ÎØbˆ³oàxü©iÙ!FQÝ?ׂ/9ÆÞÕze9jªœe¾9H”)sÔbÛëó t#lE+¹cyóºHß\]¾œŽŒ£UUsºÚ:Eú‰µÍ�¹Öœ¸ÁZ´Z6§iuøcÚˆì)C†I¶õÕœV´¯4°©m vê—©þ“Ú±¦#Š¶¿c.ÄvTÍÞÍ0ùË Ÿ­Î4€S‡qð¦ñ %§þ¸½µRô[ª4Ò2 å±/Á²+a˜t/ ×ɇT póÝð/Wßãµb¿ÇÉÙŠù¦†òˆe<N†WÂ’f7a¡*c‘LÖ4>€Û·%ŒŽ™Á&“Nˆ³VëÅðàEÏŸyÄIA?!1›|QýŒ 2Ŭ=¯e±/ÚRÝ=Ð2ÚžÜñB;¯ÿÃyØ÷Û¬ {qÊù* ÖÀ±1±èaÁ3^LÕ‚¿¬«~áh‘z¥[‚²ùÔPdû´ ‰Á¿óPO_fþõ,oÊ"—«ÊVëû"e’Bb³¦¾È’m@벧eŠãüßË¿J«ú€24æRÕôC‡áÕÍ/0)}B$?™Ê.µG½wª£ EG³ÑÑǬYÀ!Í«N`¼–jÿbö “˜d´ê…A3«Œ5ô(ö,—ºß³™ÔkV1Eá“…ÂT<pÛI+ TÓ§qt‚[\p“Äc‰pýÜ qMz¬Ó3œ)ÍÚºg#œ{°±*²$|LƨßÐ.ÁÐCïþÌlQßþÆw7ˆµéšƒ{2a¼7f®©âš*QÎþ¢³f”¦U™Xï$–Ï¡ûÕi™2ŸiöÑU)徧7Jóºÿ$žSxŽ¤±Ñ·i´8 ä ÃoZd=°+y,ùX º /5(ØA™õWcÓõç 4Ž–„¶o(îÝçšÞÙ¸—ÅAI©äPïF?­;ð?Yp×ëäÞ½ôÅË3Ô§TxëÅÃDêšjì `ý„¶=œÇÈ1#=óÙøY™Kåw-vISÂqÈŠY…`ÓÃÍ<z‡,ð—ì²”V&²³Z<*n¢áËIŽê³q!{ñ8Š²¥T,¥¦Gº5½ö) [ ø`¥8{gž5Qô®–Ê^‰C†±Á eô\/Ÿžü8ðì{«íÕ  Q¡ËⲞvË^\ž;ˆ�ÓÀ.:GSFlcƒ­qcÅ÷@>8= ø9¼™á,yƾº<õ©Hº¥�j“zc˜lB3ÜŠ^Ÿ4‹;ž÷œ)n|‡ª(—4­è(4¾Ç`Ê'Ó»¿\º³së“-Õ_néñû QefËͥݑÞöX;÷[ÈX¡­$ÙÎé7ïŽ ô\¿:uÊH1"m—ÁyM÷ßz$*› ÙïN«|ûX—R1'(ÞÄå.êÖI Ì—Ñ3þF†»pc\ù¨Ý@·cÖˆ úîáËhL¡W}“¥ëCCV;:DmÀ˜›i Ô¥ˆm}V÷Ò£Aø¥ÕÓëص} ÿÄyæ¥ÒÃ\蟬ÕGˆ{ÛøDà(�E®BSZ+ýì;Ó_ÒdAJéØØzp{+«YécÖIª„ËÑ"ø¸œ…Ý7™fi‡jßõ“ÀLÍÅÉÀÌÓíg}h�¢ËXJŠÀœûžÎ„=n ,\Ô²¿…žæ…k½³óÅJÔç£Ix4gŒ¤\õ7†!~:Çë‡9´Y}±Šœòø¹Q ”ºßÔ†˜ü"–§¦™§/VÁÇ ðýl%mf/˜õpŠí®º^ÝÒ%ÿÓcܹÓAun¡éTK6;þfÙò×H´Ío4’è¸ÂÌQzÄÿ?è6™SmÞr<dgÝ;Ú#Šlæü8äíëOÝ-¥#þŸ‚;+7úŸ‚)ЉòÏÊzÔ_.¯ÂékŽþBµ(u8¾ Ø$Åi㆚ઈëõ¿mÍNÌÏÍʵjßS|ëJÖ°oäáÝÜ#¾éqÓéÏLŒú†ÿd•lF‰Ð¾( ä[ý£¨êV‰•Cõmß'„ó•Å*Ýs!1š×2 ´nOåÄ»Ö?FJ݆Jù'¬ù8r±‹»ë퀖٩<4]Û½Íà4¯ ‡|ù[ÞË´¸iMX P+?uœ’�¤|\ Ó*Ž„zÑ y^L-Lû•¶Ö¶ñ’o™"wêFx¦” Õ«¾®©ºd´Æ‡Z’ùælPÒkò êÕI¥¤ThnÏ]f>u½¡_½ñíß)ò…’l¨SP¾ Èå¹¾Àm“•:|ª]¸ø_$žwÇé°÷ÿåeÈ®�. ¡lµÌ>®ôŽT²”vÂ…8÷{+˜å½ zþššF ÜF“ ·Há’IË”K»©¼Ll§FÞáõŸèèÈ|aXƃS,߶NÌTú ÐÎý3‹ºÕ„² ì/žË¼á9X¶ô®g ‰—leÂÅT$Ú.¶­ðî³eƒõË›eÍÕëŸï«oû"NâtpÈèÏŒïžÂ}JäêÚQÜ�ŠŠò+mæÂSó� bOT㧧LOÐÕo Y9ÚÖ§öò!/1ôY_ lçÂÐúXŒâo篶 ’ªr£D–½Øœ Zÿõ\Ãé¿:Á+ólž×¹i:?ª©í‰‚Ùy]ÅúèZåŽt”]±úCþ5ŒHÝo£ØhlNEÖ­5z.YcsbÕÜÃ,æ0Å]­‹|TË™ ûèYŽ§”Œ!l’Í™Ÿ>Èß°ÈÊ0\žŒ´¿BO®ß9ð0MÙêÿéï÷Wä•<Ì—·ÿ\+9oL§>ú6Ý+ï\zdß K³Ò î[«„[‹Ïäì4ºpZ*p’›ÀJ=ûH¯ÛÊæˆ~TÕ”0¨¬†o¨ÍiiMСSƒÎ»Ã„Nù¯½Xê¦Ä¡o�Âö‰–¼uª„.ÂÛËúZ™_X 56ÝDÏ6(£HËr}‡ÅqîrH)íùÜØS†ÕË…„+«YUÜGøA±òRqhJÑÃÁ—×Qg^Q‚WÒ×؉`UO›§rË N–&C´¸6=í¹¨ßz´?´mÏ ;ƒñ:úò­?…Žéj&Š#Ù0zL XÚËäÊ(ó‘”߉¥$‰ç¼#ü¶)¡„¡ÓEY€I¬ÆXsRn�¿¿ShÉ|ÙçQ k—°'Qw4®›zÞìÒ'ÛÕ3…àfôôAyœ¬IXÅÍÍB··=¸$ó¹€´š A®.§Lq~»ÙÞ(^›ª•)•øÔK(ZŽù({þ˜éÓ6³)¹÷i} {–näÐþ਑6Ì+§XÈβOë–AtËÖ|8ìLðM6`'K‚áÆýíò '¯{‚‡³±Hþï˜QÇ!c$z†ã­ï³,Hfrsì´±ÅZ>´Ûv¢€4Ôã™ÅâKä©Œˆm:÷ªe„N„a)÷[Ô¾˜kº�UÜD ž£TD¥ãœ>î %‹¡=.ãÍäi­ï¦ÝäJÒoªE«¿f‘mGIy<h+º`“ÑXèÜt•í}¨?²ð’„_YXÇWd´¥¸$ö/…’¨¶µ†Á-Z¿ô1‰|3X.u.èÆïGgÙ¬™coÚL_\ݘGŠyM'è¥÷Ž�F£Ê¸Ãë  ——Ç&«å’ì^ù¤ ¯]Úcýg×ïòºÿ¼%©)c‘ܱ¤½Å^ÓÇ…[§߇öÙ¢•ftTÁ¤Þ8âî¶>ƒJg©P¿…„%‘)MMÊÉX$$øjÂH�žvvŒ¥e†&ïHR¾â£Ä¬Ï3vus¤"ú²”£œ/-À÷—ßOµ£ÿå‰R­B“Ò7#åÈG-¦ Ø =«½¸3ÚK3o9ŒG³Ü ³àŽ°XìL£"Léà6oßNßFžu°éãÆ™™õñ{¶¶.ø :óþWY “52„ÂÖ3Ï9³fQÇy;k±c9­¬OúˆU Ä&˜Ž’&¯wUŠ8ómkÑ[¨‚ÜL‘L"Ç–Ah¨Ô‚ûƒg¢/É€"åp„AJç "ÐÂhì0ÎÜ_=·±X൹/úÚ%kŠê´}%£ÓöÛË|ŽMa¾ÚS–Xš•joàŒÝ½((ª¶ôèZwqš¾–&ôz;¬P<Œt‡Bkã²ïz.•zCJ%~´ó®i�âZ×Æ4ð!=ZV&lÛ•5 CÞ3îÐ1-bª”þ>úú‚b~êi¹‹gà\éû§-J@Áï™ñf³Ö¨m7u5‡+|˜{Ö‚y‡³ì’:ÑmŠ j[O縴œQÒSø@Qeü ½†½’æS¹Ü,å0u�]:·u Äè£ žºó›ªKn›©„ù g÷vãémRV×­ÅÔ9µ—¯ =D±s’U€}›“¸¯ª#æBrInŠ»ºî$§©SbÈpî4yDÖOsÇâPæÝŸk8Quj&ý´ £<wë)©…Ö˜/®ˆq‰¨š6}KÑÕõ®nÁ4¹•¬‰Ì]Øn€ ©­ê¡9§ �ý˜åë®nÃ\zXÚXL}º¯µ+ɈÓ,z8SÝϦÞ2•fmÚlÞÔÇê¾>ý=Öˆ×%¢BrìçÏBú÷;é‘ÈwùéNtʤ}kδ,FìP[¶ û¬ü²j-¯|oWªÍúw¥>s'D‡Þ¦±îÒ:|k‰L,‘« ®-” •Fýä3i›îÙýá¹r…Q+PMoÜ÷Ð=ìýŠ—ˆ­£Vç=ÅŸa_¯¶Ã²«ù<ý{ùwMM:—Ïó¯ORŒÌš7«ÿ²eX±ŒùºÿU ÊÇTbêQÒnÎîäÇAÖ«]mç ÿlŒ$¨¾>–ÅÍ2¯4„¾IE»Aq�%«$ü9øXá{Ò&DN(ŸòµÂéݧMTƒkGzbòÎ>àHvxSŠÈ¶œÅ"¿äO€¯çÁq.88—#h”XîœÛÓV†Za*ƒ74Z ã»5¢OðÔê;g³™;¼DÁ�‚çƒNÌès`¶ãYÓoYŽ¿ä{¢ íw áÎÌ—ùÒ°è:U>Ö>€»î°ä¤Ûä$æñz“‡³‘¼SZ¸Y÷—aùƒ)HD©òÚ+ }Ñu(VÐß•Ë‹zÒx$ض´G¿¹yCÊɪÐcä2n#ˆIuC1œ¡‡´ªOZ¶>q¨ñ­jì¨;7ì °@ËÏw™& ¬ºf©‚7ã§ÕöšýWÞSá½÷1ǬäˆçCµ(9Ü–LNs¿þË[J®²èUpn:@Áä<ªF)*Òl[ŒNSæ~Ñ7}c Qùl{ñ0ÓUNišIK8%'azúha­”ÙÉòüÃ!è¡Q ‚œ=“u­ẫ$@”oŸf/o�ãN‚,’Cõ_ڹȴ¹@¯Fóãý8Ï”\Й-ÀÑç¨dB¨[˜¬Á¨$3b¶Ý‘×Ñ•t=˜ ž,¡U§éÄŠÊ‘9¶5u£§žÔ¬…‹ákïz—wšÖ¹×êçùB7P•9y’9Ü=@ÁùàL0-°ö†â?¾Œéð-¼Æ˜‘E<ó¤stÓÓÊ;«G¬hž¾žÌÜü­ù´^s­o?ùýË›éªÑ¦ŒéT¥`“¼ÛÔ‚ñ]§¡S{œÇ„ÿ2»’ýé;Ša›Ñõ$Q Œt²t‹WQËQäíI¶…Žh5l”oØĸÙ1¦Wïï a.—†>È´Ìø¨¬‘MÍRõ´ûY ’Meþ =ÓWfTZ°§X¾k¶‘T2åS®ŽIÂ/ëwÆ•e—ˆyÀ<P¦Ztï–^Õ<â¦7±wüI¤Çí;:ºi…*¬‘Nð™wŽ¤ÙVC©t}Y–L8ƒw`“šŠµÌ§YÆ8¦›TÏó›"ÞX!ä‰NHîY †ÅOe­Šœ4íöp6ÓQ|Ö‰ƒé1Ç£)àú×Í?ö­E¾›¹TÈeŠþ­¨(œ·"›-¥KÉÜx+ôß-lä;Çu÷¶?õì—¸Û7È]¿_D™'ÐÎþ*B}µÍ †€:™ÅI±Â?"À aúèMÏߟ¼ã‰s$ü¾tPÚÐCZÒªÌ7dÕy‘ˆÜ!ƒ¤ZªÓñ|Q´F˜ÅÊyVð÷/•÷·�P=‚6U\ŸMäÈyÉ ·ZnÝ=WWvÄMŽ¡€ÞÏ°ÿSPÔNælÃÀü;-ÊéVÉ„òл4ŸÛ6èc½¢8¨Žê¹”ä´i/§'G«6<´ÖdiÞ1ë£|ÚiäšÁy õÕÆ×+üØõÇP@å¶j;j/S Ëô*]?· Hj¼™À"ybP5GÉg®T)©Six¥º¿úSR¥jødÆúëHùúløæÍ©ipij헊† ïñšÿ˜'¡/z Õã‚9{míg\Ö™ãú“‚QÏ¢E™£ƒú|áèëµû%”}<û1¶~œÐõÊ{u™‰mA®ÝM?Y–£#qŠ¡3üÆCkJAFí˜DÇ™‹}}l™ú„ò ÃÔÃ%ÐQ­­g„hªÂ8?2ƒézð�|šÅ.0K›¥N‚¤;ÛAr©ÆȳY~¬[fX»‹ÿÒ9òÍà f3Rb¹A³e@™rƶ*Ö°={QEvy̽(KË*™0a k1éq¸‘› ÓkåbÚ‹»nH¶Å-"+¬\=øz³`«­(ÉM˜ín†_㪶(ËÛ~^{¾™œ²`[n•…Ñïúzåªrl‘;ªzü³{ª•˜û¢i,-´9UAÑÚt²h AXI)ƨւñY²X×ͬŽn.`‰ZÐ!Ãíì+z˜Mgq”hýéZ;¹yl)n`r^k\(XVõ"¢È¢£È’×(X©gÏkCD˶ÚɬĕæÕ¿Q,‹£Ü˜µ3À7n}zïþ||jY*\7vgÚçK$¾åÀItéHËi‘;)ÛÈhZ/…×ÈžLpxš—ÞêÁ÷ Î# ÿ–ºT}ÿÛ_†¥Ð²LN<wÖU¸ÐÝbJüµ«A–:v&'AS“ŒlFºâNçì8SK–©j TÝ£x¼uÎâ¸ûP^6žl< ’ÙÚ~Â÷…"ôÛ4Ð7­¡–Û(F12c41z‚Ìo7Êøöž·j†“ÑYÛÒ»ý©‚¸±@vøm¤ÃœéqŒ 8$ #ŽëŸ¸÷åä,Da´3¤‰joÅpìãÀ"¢$È®ä*­|3RHhöS;¨q’p Õ®½ ª;ðé¥j¿úQVŽðéÞAž:æ$cº…ù§Î¤ èOÛ“sl£ZH@Eöê!“ Xèa»‰G?ŽØ¿ˆp^Ô/ÐHrü£1¯-ˆSÃDn*äÞ•/!7ã¥lÍšiufͱDs6žèç;u:µ°:o]{H±mwè)!_#òÚ….pÚž¼òF¯)LË×(KTih¬§¢wÂËR;¡ Ö—„‚Ë—'^u6}?K™Ä½à>ý½+TéBJû‰Êµ¼ýôô ¶À?ì=ï`ù}ŽUß z¤ŠDOL†6m(…*7ªöÅ‚ƒõ™éF*̳Û�šr®[Z¤H—ëþÍ a ÿäÞ/}áÆiÑâà´z±ÀzF®n»^a×ÐúG–ÝÞX[î`V'¥ú°Ú°íö¶93å?~]&$µºE�þ h–÷­qG†ÞFámBOmšGûÊ9þ±«?®N¾ØÓÑK??v Å‚º÷T±ëš*V‹I+lkë]¾:Rð4¤Änè\šÖÎ"°;gáõKùMט‹Íåü'§˜ª¢°‚Ê”Ì,¦£x›œ¡‘2.´¿`|_Wv`tóîµNdΠÊ[?A@GQšyÚ=Tc (°èÔ!Iý TÛݦ;Þ¥.§ç¿ò}1 £ qž/®ÏžÝ :>bÖcúÖ?jÖDIiáȈ„ðöŠà5ýדJX¾Œ?Ü+4¯8Z {xŠÄ¾vjRî” 8ä÷:†}¬-šatÐœžè®oÕ“½1írdÜB6ÙK°æ$Ëü¤6 º$ˆOï–$;à ­:Âw"—fþ„*¼É«Æ$Ö… ãñ;Ý•Ì<b2ŒT«xìzKÕPe�ÿÕìß4ÏèÚÀP«ÎNVå"±–'Nóuýÿ@s)ñ),ÚLƒ:+ø_ó^ݵ€Í.É⯠ùÑÏÆ&A×!Ç[ŽšceÉ*Xú±‡ÅŒd—²¼”w×Ã2}­<˜ÔØ Ì Ûw•É{:»´é˜ÉÜFÞN€mÝÉÙ’Ð{„\wC”­6Ȁߧc AfKfVÛ^˶6¥{Q3}Ó=úìMN‡K7y”ªH›…êq‘¶ô¡'úÍà]µâ¼xkº±Ð“‹ À IƒÓÑMû�P¦=ÐÖÖç£ã¼“V¬»ºóù‹¨²Þ,1ÏÍ 7:1ÒÐw 4h¶ ’Ï·ÝÄ íÍ7O< QQ›€Ï^×{ØqZ+À¬N ˆ ÿ¼Å› VA'âx¿•éBö ¤Ý‡ oãÉAVs½9 ÿ¼eqQ[£Ê5ĺ¬úÄõ÷ž­WîwzÁKÓ {|#F뎧Øèüþ’‹AÒSv›Ñh›hú´ê‹cw½Q‡�OiOÕÛîè7–¢*ñiáœÝ¥”±*¼ ª«`\_5 ¼òPâ#ýÛ'Á¡O‚l”ê]¼¯ØLÕ¶ÒQ«QÒŠ6>²y¹? SÞH”Éá2QE¯–„Ðc`÷+¾×QnhŸx:ô;‹¾q ®2¿p¤cU6*-¯})g<Ÿ•²l*÷¿ñA¬¬Ç­(,ý\(¤waž`…þð=´Ëá°mc<¿²üºvñ´�ý 2H/­™B«ê™5¯««a¬W·:HyšyþÄP¹<Ðí±'$3ÙÞV—ñ¤ƒú»X¶;°6ëÂæ¢Ò7z´aoY'57$«ñ HÒñÅOY]€Â8Œ#ì1Ž~ƒlÝ›úñˆ=5Šní¼-~ Úø9øbØÙ¢l­TW@~s5ØAAۆ穂;×I} ,–¦ôäD°§P“[OBd(þäwc}„§ÌLõ(°Ü6@+UÎ/ôýáÄ(’×Äj£lÙÈœ6ÈýèÞõ;·Ò|-<*6,[žZ±CGn}DéÉÊdÜúì-]9�±Òî†s³ÑsÛ9¤C~HèyþõÚ¶[ÄqÎû*z÷tõ¢B«xU½£L“îÁz2”o¶Q¬™X¦pž±8±Ð.µiî]ýè-Èx!á ·ä?i}ž4~{¡r$!Ó(XVuW?]ßó¥O -ÕÙY£ +ncR­J™‡áw°d¶õ 1» uwFÏ€ªß…À綩í„F®%_}&y²P)ý’öï¤V„Q¬õxFç™0Ô¡È»Ø×G’©Kh$wјë“gÍÉù–#Š¼Ù§þ#o‚(rÜ0fËO*ä«­ž‘1€N#?ˆƒâœ¤™ÛP"ܹ¶™Ú=Rwˆ=j3ûϱTاrÑ=û¥ÕË*aiäc.¶ô±Ë~6s€»Ðõo{ø蘽-¶(Ò‘â-ñUרoLäÂýÿ'¢eáDSã¨SUøé97m mcïû.UÄh y:â€0ï‰î_Üv¦ŸY©ÎÙÏt�€ç7$Ä4r øîBä#=a‘†à}8ËÀOÕ¤Õr6âŸ÷~’¬J3«Swu�d×ó |Y:CjëI»Šiƒ¥º¶êM‹^YäÍKSkÏ#$ºÎÖäÖfÜ/C²ƒjˆñÃ8œI`.žy¶Š%ºMEµêiôt éQ†ŠJ@Y¡tçâÖV[ÅŽìEc5ÿRZq%ê½ êÛW۪ΠíÁ=¦;Íjuì�ø¬WnjˆûŸé8ì÷zï_Lò#²'çKßc®¹ÖŒ†R,0Ï8TU¸ì›h¬_|_½z.¥aa˜çý“=Kç¦B›=°k“¸¾«Â+98_åC­ÒtX}G¦®YqM <g}A6Õ¶â�Ùœ&+n˜C7¢ë÷"¯}§°|¨ÂŸx6,B†áMú®¨Id{«ºšz(†É‰gG7ÛËÐòÅÕÔÆ[á¬V?A,5·Ób6·Þò°ï<WÆ–áUØ ˆ§^Ì ®¥—Ôóé½:ÀÏLM[Rt}ǬŠh{µfˆ£Ìþ¡¨L1”nüIA %Æ‹‡³c‘Ó4µØo¨ƒyVÆuªã 5Î`Þàû·o—ñ Ÿw]:1°"8p_¿UúΤ”Gå”»v£ÓQÛÖÖfeT4DfùÓc™Šý‹ a>S¶ºSWuŒú†¾ÒrÊC4¿ú܈&—~ qÐ^Ê sDÉ\D#ºÁ hQFuå}Ð ‹ܳ0 Æ=ObµÍ I‚X*)Oã'ñ¶¥JP«ËÄ°ø5º %Tùn'Ǿ ªI Os[ô0¤Nša‡C÷35e—™/„•{:õâÖú˜fBÉ;ºs$üÏs_U+“iï‚…em{DÜT�ÝȺ£¯¯@¯Ž>ÊÌÏÌ€ÎXSv9©6& !ÉTC)h/IÙ¦ž¨ÛîMÐÍ/Î.„Ë[É‚¦ûºÏ‘c§R#€º'£ÎO¦ 5%"¥ø✠Î:Ù%òë0H×_væmô|?Ou;²0€ˆÚöèyW /ôÈ}yÄ:¥ZºY;zöL{錿‡Â*Ÿ‹} ÿiÚ÷«U½öBB 1MXúà2BFœ¼Îž^ò/Ê/cÒ×'3•ÄL29FgÇ­'ðßœ†MÍi§ï[¿ªg†tþ§˜]ꔎS9¨TÖ%m;‹CãyÀ™G 2E)É6ÿ>ZUNŽFtVbH6_ÞAþŸ5ZŒ-_6/Lã*óT]`éE%ntáV!k¶q„Óº÷‡^n žÄÐ+l=’…Â&ÖX0/Ïv°_D3ê¹ûJª j¬ÄOy…Þ0ã 8©Hºãë´rS#`·¾P¶lüÇù„üs¸ÔK§ x¤(éÛe¼¶Ø+B¿­C÷v®ál©z ,=é)È“ê/´gæúÄsü»PÍئBmóïó¯ÓÕ•MÊ›ßöÔ/L+MvÓí/Ö—¾½þIf†+¡QÍ\AÖ=š.žGªc¨â"ÿh¨qz¡s²ò/Pî;c9O´µCŒÜÀx@î}[ÕÝ+:GvL&àë"8§ÏAE—+œuàƒ7W†Øu'Mî8 ÝnÇ¢¬<î 7ç*(7£ââ°”¥Séc%t`k®X‚A>Œ5­œÛ麛uï‰{@‚¡>õ¦áýskÀÈ—¯”FÇTñV­\ /Á˦ïê¿¢Eôê07[šÿÄt¢AÑjO²;.ïYaÚן8¯œg>LX´ïæXI+ÇèB3! j(Âl8‚ÀÊûüH©é„²õ(-@w…ñeßP|{feN ˜ë@Z”å-Yœnûa:ÂJÅìx,ñxêèÒGVãa}ÔgÖ{1ÏĆü›¤¯E_:”È—4WöŠÛ3qX¤™v´Å§…¶I²iTL-ª“•è6üÙ—:ÚQœ8ã ÉÀ|¦˜7hÆ+qHG=¸Mþs QÌ3d@7Cú­îê1 ZJ©ÒI ûV{^Â3¦ÙDCoxÛzöÍÔZ9*ŒÕżNƒd>zŽ¤\ˆ9¬y¾d°Œþ™G6¾€g±â¯¨9døjóæع2´0®‰ÇV ø™já/ W2PÌÔlŸª;/þ"e”U|iË*²4–�[Ä<_Œ•È´ÞÍ5œóa¥“r7 ¿ðÊÎrOsŒsßa¤² Y×΢¹lƒeÓ©¹ÙÐñ°Ù¾<cÈBO‹"6 U5/½‹’Wª‘ѵ÷d&¾Ì£•&z÷!¥gq4ã¿—´ˆbïpfÑûÕ Š•h.PèÁ‘ÑåŸøŽØív¾iËîêªB úºBù¦÷¤”‡>îñìÝ7ÐSÙ½L!ò.,3'>šþ¤±?eÔÀïÝ“ÀÃÂ]Úê]þôcÝuAÃØYò–^qV‰àÍ‹M¯KQg(yæëµUãÜúx2¶æCÙ|îuçAË_“6ÎJ_¥’öT溮æ A[îZO Ýkú¿t-ˆ[)!œz'8£ eî/(ÅÑÏ°ôH‚1¥Y€ü ·_‘gC–„×¹*°uýe_W,iÃ@þ›[a#We š&BïÅÊÁþhÃÖCƒenÃJ.²p&_»QgÕB<„¤pö^5Þ8Ö(=Q!j(†î’#b=¯˜êáË ;fSl(çûŽb*¼ š/ zÔÀR˜ õ3£ý¬‘ýBt¤Šœ™·‹Ú-ü|:?ÉÄœÅ!^ÅpD ñÐYw *¼Ì5-ƒ„ó´ØùKq:+$Eô¦·Ín½…½U‡-¼ ¹Ämh´†Þ“ tŒNi7ãn?5ß;c1jô{¿:Sôçå&,Àje²ÚÃ,./W† "IÿƒÈr¢Ž™Á.¶=}³µ’W€þ«g´þ‚è~œxâ IR;t\+X™è±ÌŽ~ìz3Ô:Yx ÿ¼mCÍ^à$½J }”ŸÚÀÈKTèšðVÙþÎíofh—`mß°‰¯õÁÖÕ°—nU¢´Ú%wìà<qÑŽÛßjßÁº }+ Ð,æ,¨zk¢‹Çšxž¢“­{MÀ.ö*3˜'ÊÐ";:’8e<ŒœN²q,pïò{^|´Î6YÐ^`%®Žô ¯v54^„,6ïd†y¿s¹Ž¶tzèÃÓ “ÓѨD4hÀ9ÿZOx;OcÓQduî ©kê¤âÓŽ÷ÚÎ&dÝ7d »'z«ƨߑJ…XÛÄú‚7rA¥§é”ˆÁaÇ1ðÌf ƒ³×ü1 #½ßcoï÷©�‚Ïà V/›‹š°@rC�ò @œ ÒÌûFs>VÆ…ÌbÖÒ.0žmé-zGmÝ_QOÄ›ù÷ó±JÆîF&Ÿñï°¹èá@§Ú¸½´:ë“¢ö¿ëtXqºÒHÁ '²°¸’íïè&w$ПZ©ÅÌù²ÂIzy»ûÓ•Ð T@¤ãœ·g†`¿¦Ã°¡Â«5[Ê(uªO1O¢žö¼yZmÂBêF·l|÷œ} ¹Êo wýžÝõ^t¥(¼çË´ìóXÅ8y³"”ß³GA Úñ°“Âê1¹Ó!Às“²åÂz6ü(ÀÌ(Ó¬êWv Eé`E±º ]œ^ÎÇá0v{7||Ùe(Ål}Lyþ|öäØøžKцÍFáùB.Ü+ÊôÓVf�vL×p²3û3ð| –xaVç¼kµ7>tEPl,¡ˆ…XhËvÿUº¼¶Ü¹è8IÚ÷]8x¹Ó¦«·ed¿0Â?Nj)i5´X>FýÐÙÝS&1¿Ó…Œý¾6K›ô'ûµå TÌÔa‚¨<œ{ ð‰£»¡B‚âä šŸl*11rga‰.þãœYï>WÍ+fC,㈼j””DmÖŽhÊ\Énx£èÕBàðE¥ý°òi+Áƒbœf‹ýDÒ§Ë|ﺙ:?5 àÒšfto|¡wžþñKî[ÕÐñ¾ç錹2ƒ>Ÿº,;M0¨”–û›ñ¶ÖûòtzBÏ*áêbt}ýOE§`øl(¿:ˆ¼ËÐt±kº±ÂvÐÇEÛÚqñöï[ÌÜ^à:"â}Åîoô*#O•¤0™øŒ¹šíø€Þûc¨á³d=úöòÏKiݹFU}»¥Ãb>j.€Î šÛè<¬ t™JÜb蓃Ö;ûìžl&úÝÖSˆ3(eZ3 Ôþ¤Ïâk¬qAý1ÃZásp¦‚<4K1u¿pSX”÷z×¾Ãý¥ŒoÅùZ Ü‘%(õµÈÙñ〬ש·7b›<I¥q<P„J‘Ëcô½8`ñg/tƒøÉ?£»úɨV¦:ìOR'x¶?›±ÆçµÀ‘{Á°Œ]ž²Uð@[´´j?<ðg0‡«p‘%¿Ç—äâ„_åtN¨N,h/µ'ϯëp<îVÆŸ‘²ŠÚÃòÂAÁbÍ}ŽqEÎ4€ÑE°j½¨¡ÃÇnž´àûçMÑ{=Ú»åÓ穆7÷k(¶ª_¬þ@X¦VÄ <¿¦Ã(‹qá#Ay~êL £%ÃxÚÐ +ÿ^Q×]^)¦¡U°Ñ�Sí±d)çaÜufC‘ĨS©n!fÛ-0gž‰¸9³îVØ*· 0®™µ”ÿ@)\¶cK¼=·ï[¯»<й·,¦˜Oß¼ðع<°:LÏëÙ£’múz¿ó”dp“yÄÓž”„–S^j f†ã…‚µaá@7r>ÑÑÏÅ°f<îâÜ]Œö¤Íomkwqf¸£;Ï#Ïšcšèù‹fu^¸NëàzL¾×j4ŒžBÝÖNgaÛ] ð\.Ê.©1 f¸‚o5ëÎÚÔ”úB*ƒj©Îœð|¨Ø+ ÁŠÈ³ñ؃^³B=¥ôUOú\¡Ó ô5êëi_ø~„<l@ kt´#3úÿÇLJÑBâ-Í„‡®"Uâ†F,/6lò ª·^ƒÏJoýýAf‹´Pœ¼(ÖQrܚȓ‹*‰ù¼‰süÕ6ÚÖ«á.8'Ko]SN™äØyÅ“Æg=Kî©=Ó'J|™4–µ9¯¶{W$(Úk¤× ‚ׇ¹\7=.¥´Ôö5cÖB6v†Óh9r7ï!%TªÖÈÝ"&bÊŒ3ƒ Ìe‰:˜–È ø(&\æ¸IƒºÐ»qeˆ}¬[ñRÀLc¿mNÛja¬w +ïµd¢,Xõ¼®ØvQ^YÓ{aÛM´ ’õÙˆóD!H±›™WÏåXá!ü9Éól^e¾ëpsç2ˆg'³2äÊvAV'ëYá`%¿s¨òÜdñ$þÞ'×[`-6þð¼¨.oëú^V>ó;Ù1€›%h¬‚�º.ÓÞȤwNb¥¸¸9ºË'+Ø‘×ùÞ…ÌÈÈ‚ä³õ‡³)WøƒŽ];2vö!#ËåȬ ‡¶Ú…Î/Ðj÷ hVu÷ô’ÐgáÂHaCAÔ¢Lð!ϨPÛg¼ŸƒŠ }•Ñsuý|1"§„¡ïpì]Á * ¿¢o¾USÃ…H7Û=RˆsE ­}‘a´z†È´ì‰õúQ›.æ+ôÑÇ Çk-#Ê2PÛ"+ÚÂÓ?}å•A'£ªƒ-ä‚7s<ÑÇÜ;-†ÄC»ò°K{êÀ¼Xá>€£ä"iÉ»bÎÖ¨÷€1õZ!™|®n•l?¸ûç]?›o`¯|ƯƠÝUµ5öD&"AÁÿˆ¹Ñvwdv;/jrË&Î Û½nMÓ€‹»ýk¨xÂLÉ錑¾£r… ˆæu‰Ì—Z«hýÑæOºçÂ(„ѳø¦²£¥*Emà�§ÔSå¦ójÇqBÀ8®+(ë íI¨Òæ0‚¡2ƒ÷EãÌ I¦°=•A9Yz8²œò þG—ôÒ7à»ÿ‰Yè€]”®µ __J ($ô;z.ÃAi÷™�$] š£D•áÎö\1,Û=æÙÆ4ŸFq]`e<Lîiåvý¾Ó^ïÔõv¼�F¸m MÁ Ýé|j‰Z1ÆÏb_’ºmZP‘0ù"h'Â#¦Ñï¨æŸ·¶›õyhÆúËlßž"‹µÈ 8Œ½(ëáKµÊ¿±£øÖ ÂæW¹9L¦" *Ëâ‰Y÷bœê¾–T¼­ Îèm9ǽeÝLù˜YÕ(‹ž•`EFTÊÃÉ0½>'d ‰32fdó�6ªå:VFó”J@ÕœIAEäúgmîDž«7?MOU„áÀ@aSn5ø³þ˯ûEQáÎî„ÀMÂÜOEG¥¦Oï¶ÓTæÒ¿h„"–)-?ÿz<kL™UIËz¹¯¤þÑâ4/¸ƒ?„3Í`¾?\Zsº ÷ÐÕB­”ûµ¯á#H·ñhÚJ=z,ÕW@Ø;ácÎW”^<ÌÁ¾³2Zt(ñÊgn1‘C„’t=©·#7ª‚ÐõHëÚæð?çè% leSÇ23zÃ Ö éÖá5÷¾ Deœy>ÊÝ_IDdåp˜}†x=bö̹‘yº¾^õR»:‹Þº1$˜0”°–ctWÞ»ñÏÎê/YѨgêQ‰§™Æ¨áó8™Y_9œíl<ÆÂ’¿ ÍPT<Ì[ŽÒï<HÛ£sC€qߦâ¥þ`sð¬'~žŽ­‰ÌˆúÃüÆN~³aÑŽ[i’`P(ÝÍ@Ý 9É"$™Ù2€k×9¦(´v ÂCýÑwõZCç¶þcÖ½à>õ7SóC§¥M•U«“ô†¡|×AÒÃÑ·ÝÚ LÝÕMÔã|a‡›¯C©`§óœ'MÇ“Ô£ÌÇÌÖ0‚þ`¥“YÝü‚–{ä7ß)Õd¹Þqv)‚7+çK¤´?Òë-RxoŽw`;é¥Â¹§<zl_žk¥Ù‚ÖáD“âyqâ BÊ:B¡f‡²r¨—…b g>}hh:çr°¡îCe¿é˜deæW �ž#úüÝñÊZ1Êk›ª­ìá•ŒØ+öÊiq5܆£XøÞ¨w'Ò–Ÿ÷s7±²°Ï»9ƒÜüSc|–«§Ðð,)•(çiEžQ^ø-uåÝËVô©ÿ í"(Ê=LËÌm{ [à-—×nRàßc>^›ñ=#ôNV©‡Jì/ÖÆ6aú§p<Kü¥vÊÄö%¶nUX]q\°¸-5{ùÎõÅ SRÛ–Ýû¬&”©¨z7tk¦×·=¡$3D¢Å}=’eÞNÏúðõ«þìIÇžMÖÅI½TИ8ë\I|s®Ýÿ­'"Væ/¯öe¿[®lÁèø#ü®ÛŽÕ;!ŽT§£¢sHÙ47]ïÔh¦P*Q¯MےΚÙÖöH5èDÒ¹°ÚÂscv¹Ý#|Oªös§èÁ4ôIÒYZ°Î²è•{ãÙû$˜'|˜ØêØ"G¸Ñgãà5·fô›Ì4Ûþ)lÉÎÍñëR}Ñ›î±nÁâµV€ PYftÓv±N—å¼ÿc8œ¹ÒY¢ â4óP°ûÉØEØÌÀ¬îÖ¬†.Ölòzm³›n¢–ó¬z‹;Ý8þ=Rhþ J™t›SQÚ÷Ü¿£°ð9÷h½%<$±ìo‰ÙaIèkîf;ÆüUg‘Ø–làf gXÚƒ‡[XH!ó+í¥)sžÛå'ô‰í© ¢£Jõd¥xÆ÷Ý›®öéy¤Þì§lAܵ‡4Ø«ÛC;Ò:±I)ž‚Áä¼hΘxŽ�"›¼:äAlÝLŽ5—˜MG‡ˆeàΗ@ºéŸ7(¹Ñÿþ§~X”!·á"ÍSÏ>ÅX]°‡ª�¡tÌŒVªæW§V4_ÄFêqŠšD YV Eš4ˆÖêSdY?v}[»»¤�¿{W6õJ*FP@¤©>ú¶(éäQÓÚŽíÊiBùÞND×Xe^ÌŽG<ì•Q÷½•¶±—¢ÍòDÿ ,Œ›ß¸À=#78bMΊrƒÄKÀrþP1‹~©%Rx8v»8Op²îM¤ö†n~—b€…Ìæ0£_ú2ŒIµ¯×øîÌÙ0°» {)ƒß+ÛŒÏ9[!±éz8sq°T;öðYüôˆê§ áf5Äû×­bGà)qjv<…Íл¯•†[ Ï7)¾ä]'ïÈK8C/câƒêCäñ¾ÕáKM4´‡šŠž†v£¡çÊ%£‡Å¦úeþ¯È:ÄŠÎv˜ÑíjüëèôÑ“œ謓¦þ|¡¥?߇ӅÈ<Ð¥õì4é €‰±ÿJË è×{yœy| ¡Ñ‰:}y`B#S¿ék¡Ãmª7=#�%™Ïw¤Ó´Ÿ(·)>-ˆ>ž hÿ`¡Qžs¦`Í÷œ*ø‘|¨¤X ¤0 Ð\º´¡6Ÿêë Råû鸛দÂЧÿç¹³nRVÞæÛ_¢‡bû42#95TXÍÃeÙÅø2/\dÉ£Ø1/~Ø ä¾Ìˆ¿¤¸£~ı2Z¢~Ȭ¯Í–iåWn-az5 Ùïþ%–Uä±AúŠégç X¨“W~‹u™wÅ»M‰rWD˜ãÈ:…öºžù´ª†uPHØõ+^Åh¤óýVôè6;Ô—îÒ׌όrôtÎ=ëÐ >åõÙfÇ]oôi¿3XŸõ©¿?HÝhZChîUxx®<€çì†iÿ¼©ÿ]OtÚÑ“@âÿ¢úNº´É`„ÙѶÀ#žJ"R’@È—Ã#Ý®êsï]Ý5Ä.Ü 1k$8Ö}Z·UªÉ.(v­é§†xµ´$tÞ„×jÞ‘«ù*F)N m{ê@|…>øˆ=³y_‹ë*¿ƒ›KFi5Ñ!ÀNñ«8¶^wª¿ö´ÝÑ AZ°êë•â"ý¹úqî„â®Õ¢È}þ@iÁ|ôjLèKŠÎ¸WH׾х¶bS‰ Žó�Ú姶ÂÓ@,Ì„Í) ›Pֱɋ»2㎬ò²‹Ì¨M…¥$Hv÷'¾{ÚaŸŒÍ­‘¤´ó†ñ4m qôŽèt²lE02£ fê”ãÈÍ{[u×hìׯæ¹U’´ûÛ’Ê€©ìZ«ZÎ…ggPœÀa7Áë±…„°à²V­“U¨t%ô½îµéžZ€‹Æ‘¦^àê í>ÆJqâr­3õPo*ŠBŸì1 ØŽ%-ŸŽÆXlÏÅ#³" —†K5’7«­¸’^ÑÉ7L« ÜC¡×”·l—-ÿ2^òm®{ºiw~cºßîŽs~Dï:'1Ýcã2úÊè}B�}©•Ùü´/uþôç+™âßwžbXhkrŸ A£Ç*Ô} àâŸ8­ dâ”ækO½º¡ tL*ÿËnKž_! Ž]ä_ê«„¦ŽCŠ<¾ÙÜ‹¼†³›f×½î—*ýãPOY%{ ¹ÖVI%‡ÕÛÚZ@;šÁêÄ|S˜ø:­¦§=jìÛLV÷ßáEîL�8}?à:ßj7´=ôÇíÓ“½=½x;ˆ̉ 8…ÇJ9s逑øl Âð,ʳ›£Ü{v%éÒØWßeøT$Ÿ¶áVplë~ñ,ÊÄ—+§às¦7ÞNÖWR÷,­àyôA´¿DÖ2¡2ÖÆ›¾ÒÖZyç†V—n/2·bÄ€¾Ã<à ÝZj‰;¼˜44} :)CRA€ñÞ eäéK&ѯž«4,=ú˜rÈUTE£Ì‡?»UMI»¢Röh©oåÿ%¬bEYUÃg­™¯n££_Íj“  Â\lg×¹ãh»¯‡—­íè8ÎtPÀD¥ËÞ·µP=hhûBpUmÙÁÿÀz½LM¤¿4Ð¥¹ƒñ‰€Í—3„µ5•kmpNä0Ü3²æIßÛ()ËÍF­íW¤Ö?‡“´á¤„ÂDJ ëgw„]¾É7—7Ûóz¬_’‡Ë1A ø}d£BÚW[–ã1wîX‚cQ±žñ ãBu]IÕ²#î ʳ�ÐvŲÐ40É– ï)Œ~\ÑOî±N"m·«©!=‡¾†7é—nF,cíi ¥l6DÇ„ leË–âÉìdEÛ{ÚÚIìR-ót<Š@ó¹{ÙÇÊ (‹ç d  H6[OŒk:@Q¶9=Ái{˜æ�üj-åy ÒžÁb.Öƒ'æ:îö,Jn’÷}ñ,U{3:XÒ T0¯€(-ÈÉóÝûnæ9U§û1Ó¹PlßM âF++ŽCD^«ŒæD‡ k;‰òËE,í¤fÐXyã#$âÆ­L=JëðˆãÅW¹AÒôzI1`¡QËrt´R/�Á1brvvõ 5] Eà ‰óð]ïÊÉ×ìr~êw5U4´÷?Ò;<w¡ ›¹Lv¼XÉVjÜÄm:s'WÙž€g5“š¼ôÆA,ª²ÿH“ lÒô²\Ñ™­×JžOã4Ø:Ó*]¾Þˆ˜ûÆœÙÖ·Ds׶EoÍ]ò2-1J1,™Ùqly$Y´uBñØZ\‚ØÒ푦^,Ü úæn—#²$ƒÒô3Û‚Ÿ¾53Dk-ß}+]KûŠN÷bABá$ó6fôHäÖ¦L ƃ_—+ã‰r‡…(ŠK„=Iw³è•$š*FʤâíŒô\:hî>é GaáO_À0X>{ðÆ_tšªË-†E‡™ Wâ65Ôqûú|QxÁP”"·)½»Ncu1&º&¶déÛ¿o™Ò<SÓ<¤oÇåˆuö}IÁ, ͸V||#x*àäÓSN²jwž~S[éUïh‡8H­Ò{Î<EM(Íj|±/`éÐx÷Q"�šèÖ !¾ÃtØ£¨È�†Ï&4dŠ½×V<2æž;`ù¶“ÖÉi vç‡Ið/º[yƒ$Ñ/h($†õ—ï£Ëk±¶8õ¯Iúží¬@F ëç§'gnôƌùš°£ÕPª9Iÿ·ïþÝŽÝ]Eü¼ }40ÅáMŸA˜MպЛa뫉]üüqp?wœ~͘ZI¶y[Y•?3G‹aHJ ÄŸÎYOpÛ9e¹ùÿÞúî0@˜D{”`›MW£óÔ¶B#E;†¶½±(Ñvwd1CÃxÒ-Œª|!nPJð©Ó*øœ»º9´—7úšÈÖ¯¹Šê«a’èÌœïapЇu ?ž…íÝ«‚)¯ˆ¨¸ °0ÄÔ†…>u·Å5{Œ\ ëš²ûÃ.tœùtŸ¦PøiÅÓ+,âþèÌe—7ò4àd=‡Ä¥ë»`î–|TV¡?fG NJˆËwólfBßt£KÏ—%Jò;uK¢ˆ…d&yWÂú¡@G鉵Á@¾1F~kÉ`wÈÍáN ªõÅÐQ>¾›Âß0ÐBûR uH”Ò™±¡z‚õ&jßì®â…—e¼ªF:ª [¥Ùâ|dŒÔÙÐ’¯_A$Uäêˆ7y²mݤ#S™ÄÞÛÜ7Ûœr\‡šÎEË–îL«êí™øÆ^ãß ZNÕÏä”^ضÀ„AwùÚÂM½*ãÞZ‡É„²—Sá`"«ƒ§ƒ‘ð6'‘ ù£Z¯yÅh) Fe:¾Aœƒ¢ äBÁÓ²€{ùpš¨U Á’?OÖ)œuH5ý)œœ5z`T^rÏ^r߬ŽÄ1¨Å•|rpÑ7ž“¸òÃáV~ßý©!zbù3ý$ô±SL臨½¨±Ê&ªdÂ2 O­ÌÃÆ1ºŒÛ [=ñ˶¨_´À<’Éw…(«r¯2§³l„¨aºÙ껢µÀèÏ7,)ö@ØÖ—3_£lð·“&KÛ¾ÈØ ~~z4C–Iüë©¿23V%oéGíÖéë—NÜé¶"eØžýcD„êK5ÈŠ¤ô ÒO©ƒ¦w–oIâ¤UákOÕæåÉùZß2š+¹•¹óÔt_¡¤ea™ð"1]2ºßƒ*«ŠŽçÀj_VùÌmó+Á^U_\1V¡Ÿt‚­RQ][öVfØ[|äÝ·‰~àÛ§åÂp³¤hI±®ÞXý³LaDÿâje§2&ÙÇ­ ÉiªFOG‚ÐovÌ´PSIfïâÃ3ºÁ‹ži‹ë/µ `Cº?´Bš‹ñøŽ¦X-g P¤ÖÌžýìôy¢‡4½q‡xs ³ì×'€…ïK6NŸæôg(­dÜ ­bnˆzOFâ‘è*˜ØÌë –¡Q§ƒe0SÑ¥9 ³^_×9ËüÅJiUH@V´¨Æ:PqšŒ« zqÏʼ8Q0á±½rÕ3Èï‡í09)sôžûŽ±Âß^*}Áuvhù|ÌôOü~vJýØÔÈ3¢6¸Ë]¯XRÛTôIq±È_Ѽ]+Ø'QÃœ¥âèwëÀ²pKàø?=ñÔ½*¾+Lc§Ç#%—•³F …>zƒ¦ÍFµvßN»y ’Á±þÒÖêsÓT«Lºa±­l ÆŽõÙE3¤éÂî¶ìyºÛ}¾jú5™ú½Æ'‹õÊ2ñµDÅ,PtµøÙ¿àýÊRN),«‚Þ{Òô$“ÉÝa‹*ñíÎ^‚*¦¹úqÒ8È­4&³{ÞxÑ:x‹E*¾hç/‘ÐTÈØ_jª™1‹qØ`<g;¯±“¢87RÉšÀíŽÐš›Z[—"c•9¸×.A×Á4Ýþr)çm¬&šr³¾Œ™Ò¡A14x¹WØÓ[òoFÃÞ@k-I›Qÿ_I¤GK·ÌTÆ­Õ°ñÚ§L-{+C �3m5/ܲ>võÇRDÁOPY‹+ÃMc ¡Q^žJ`Η¶Õ¶Ñ Þ•OÐð¹Yav ƒJYSã�«Ëø ‰õ)¥µTAt‘Ê‚ó@õ±m8ÆP¼¸îP�ÛÍÝ]7mô ÈK4rvÝ/å1j´7 Á(™Ívܳ¼Óqx±¾žÂ¥¤5Ï©@=ùÖQ[>òâ×´ïX5è㉓§F^sªÞïgÅ{Ê{6%ªYRk[°/zW¸/¶©\7 ;nµý™9e$ÚçÊFŠ�L£‡¶ÙX»{^¸ˆ6²Ãß9ï.Lxg>Ê3ëâš´}¢nc滧a7¿5èªúЧÃ^þåðÓñM7Ç)†º¥Ï 8}®Ó ?~™ã&‚óÝqtž¹?¶ªO âùágwrI-試E®Á>‰#n=S}·é€§ízî ¼Ä#ŽŠÒ�i`pËd ™0˜°F±dÕÀ4ø—´Íºë¾ë¢•(žû*Hß­æhRqMs<jÌn©²äÞ^С†)? ûË;…Cæt‘ËdAn¸Ö±P}Á‹¤‡l‰âÝÀTV«Äì'õ}å¾ÅúY´+ÊOÇw¾ì¼s˜8zP’O¾æŠµ”ZBJð‘[‹jy,'´#ÝYJ‰ì»P:ASÙ«»{°ð�|^Ÿép§KšpO7y€Ãh”¾^XÂqæÙýDl?›qåàœÃ|¸Â±>¡î°úð+‡MÇGè ZV,Å–˜ÅÐòZ_<¸SG¿Œà‡Aï1ËHúÀF«Lkš€yé$ ÑÍ-ƒ¸þôM<£oŒB]W·02¼§†r¤éÝöBƒÑ™-;Õ”ÒªæèiäR£ àž‘=q“#Ö1úõùxšûº81¦>âÚwfSøŠî+ô£%_\RQqQëñs‹âðËê³s3_ÂÚ…Qª†Oü~¸¬º×JTÆqê¦5Ð6ñµë´FH¸À<ã‚ÖýÕ¹´Óò$¿Žµ™ÀcxV»Æ(ºzWš…‚¦_ˆrrÖžáp£ÔLžøŸ5õfÒižR¥©•«ñ*HÞ5 Îé›ü©{hVèd¦Þc*íß(ª#¾ &èúNÅ‘7}âj ïôéAPº?µM·ÑäþåÝ°“¦NQB¤�§„7;ÍMyxæù€™ÖãÔHWâÙOÈ@=š3ÏD‡3¶ƒ…\¢žï+X³Ûuµ{îÀŸw®XW@Ìzfâí T\{²5kW ÐÔáD¿·frMOg1ûî]-RÛªJÌ„l†8XÖÎŽמZŸêö£fCœ,*þݱw7s¤¯ù ”=ØFtïê"ø¤Ë–ÖÐ-ºù…¹7N84²Š[;FÈÔXÈÙ©ÿBVѹ‡%†ƒÞYP º; |”˜ªŽãa6ëæ5$B¶@¤Ã±qLƒÔÚ×Bÿ³íhU0#ß Æìwbu¶—þÇbÐFz#þì]³Lž†(QÍ)‹þD}£Ìmó’[mq­-àœñ_J§Çˆ¡¿Úi‹R—‰tã¶Nèök;Oë€]ªôhÛ gùrû¶IåL’*¡@uê= åšòŽÙ™ks{âeŽR±ÈRC*ä_£'Lg­5«rÆ4{¨<HY÷o Ð×Ý_z ü‘ŠG­ÖI6¢×ÅmZ”“ä+øãi?°œô# ^f 55Ê⢠fë©\L"<g7ô |yUºÈÍVÓ™ ªòT;«±läæuuk}"1.LiA”Aõ©_£Á±†»êÑ»á80îào& Ö´†a;º×GŒø­%b‹—¦ ŠÍÅÙ/\X‚¸D…çÅ.³ÞÀ=6sTFöu¬öÀ+)™l@£ÔpmF0�‡JOžëÐóÈRú ŸÙ >ß»´4áláµEEȦ§ó:s~®H&1Ù©mbã¡pî_ÞAý§¡œ€¿@M·>=ùô«ä6¸·Âf1|ˆÑ³V°4Ûˆðÿ|…göQå Õæ<ÍD‰ÓãNu#ðöÌ…Ó�nù,"§è­œÆk9ÉWÙª k(v?j Ú2_¶„ˆ}à°„ˆô&Ú›ã›*®HÝÑW p -<ëx¾ ø›&NÜlï’n܈Tk•þ"”å’sßÍêÛl:¿TË·XŸÓ=šVkÃ�%yBFó™„çóQkÐ%µ |šni2«ˆÕØÐà•>L·y0+à‘a³åJÎ ]‡$ˆÞ7žíT{zÎÙlsõFÇᮞƒiåz¶\”ŠC´»WK l'þʦ;ŒPÂþeˆräý3¤~ëKÎ#ˆÄöîÕ[QšGqŸæNŒr!£» "Uz§)u  aTQbVõœ(Su¼¿KÆõIûKžÓJ`å…[<€<_CŸp%’ßI$º§ ýY3ØÃÔ„–¿LéÑ:ºÊZž•*nb姦(ƒäSs1à—L©Âo¿®ÿBº ²^rõ;£ŸtC&póµÖk†˜¦ðÀjEQ›¿9Yíð âò»¡¶(‰›é‡£-âÈíoøäȼT¸ H;éf¨bqªÝ{dËÅ£¸Œ2_!¡´ Òñ/·DÅ*c]#}oäÀÒKºÑÖŽþ—UáBz6‚&PÌ­Ë\©  rÁEh±ÂôàÈÿHÓ‰#‘Wÿ<=„pQkèŸìdÓ7vGø:ˆ$ÒÙ¹‡:éÉô¯xnôxbkœ0 ¡ÜX€œñ®�U4”:£…¼dŸ=LO_ø‡Ó¦ rË@ ¥<ÎÝí€;ãŒA4Q±Åo¿CT¨KBª]9PÄRfäGF¡¼A‚AZ£•’3¯_}Ã:ö°§àÝŸè ¸hƒ¨âæú¶ÒT»˜·»gÓdÝm#C ê!O½«ú bÈ’”|h tÜ5ÙùÑiâ{ò/¦1S÷qCÿµ Ä9ï'¡K—±ÿ;ÁeÔ“ôÉ ´à®¥%Ý!][xeæÙ ¶Ý‘“>Ë<YÀ´ßôäÈR}Ä9,·: ·û1›’1A\0£Ïô ïᇞ ‰²pamWÑ)KkeÜhãL SÊ ÌhUxw,l¶fîùüT³ƒÞ#Ä\-ý'|-hLeèiŒU*gYrÈ)§ÃѾ>#YXi±°0rA¯Ì“ÄÏï3LoEêGðŸWÅ�MÐ’ªë¶_^¹:!ýlT…‘öìÕ«ïF›ZˆÐªz‹¾ÎMKØ3U{1Q)Ò+v0¦1ÙÅÇÙ`•ªÁú‡cãçå©âì?(s‰ì½�~k>µ‡ÑvG»xéÔb}ð“!ŒÅõ‡"–›šnkÏ&b-œmmúJ›Ó®—dåÞ•ãâ屯z ÜLNwéhÃk¯ñ(U;25\ Øùó°ŸäwÞå­5‚×Kª éÿzüGŸ’°­/©am…»zˆvÑÔ°²˜Ð½¬Ó”ÕþåÝJ/ëPÆ?bµp·R˜ÃaÃ×íe:õe„¬1·2°µVÛœÒéÆŠÇ@øn¬™º¬ë 9g%â£y×N3ólt¹9bˆñ+ö¢þÃC<¯ Àåã¶Ð^r ž{—‹é¶‡Y‘–^SÓæmß¾6)ݨ$ä#´XANU’ˆ8íaw\´é«tѯ¥,®*‚¬ïÝD• :¿Í¶EkSHºÇ-†îâvíxÔbQOX{뙤P=´73mUdù÷Û‰Tä© rž™~ÑwžÁ%gövƬ;ÖF¨ g‰Û;3©4ö=:`ü‘ÑÚöºJ 1QÕúXåKwå0+ohLW –(÷%ÈÃ’ÍÝ++‚Ó8üѽo¬ÝŸ;¼{:HjY ŒÂ¤›¼=‹œÖS™x½ÞŠ<"G(šÿ¡œ+ï.ÞÃ[S€ß»1 ¥5õÞøÜNÇZ%º¯¥º-›5¬ÐÐœ¬þàB[Z¦¾yÎ3–g2‘¯ð~øŠƒj«ïWpßgÙ'‡>#¢o^8í@K‘J[È_é›E*p#(ºý‰ ÄÖ ¥ºx•/HËi?j¼¦aµ Î)dA2[÷rDY}àŽKR&íÈÎôÓ¶ræò•óÔSn±ýëRúOÿXÑÚ(˜4,_LrX³Š 2:‹ÓÂÛmA],2”Íë¼”,˜6tSÙ•5šk¯L õþ‹—š½`Ì*GÚcbôëÇL§W~Ôœjè ¯,kŒAŠR%w£¦@¥¸1¼WÝQ$t21 ÏÅU’y† ‹ ŸUHQLþ.:r¡ûµÄ@Jçé‹(*æÁ±aY²2-÷MOcÜxص•ô y[ΧõšßÇöáî_º¶°‡ɸÙÈH ¸ÀÖ§äfïà¯cmòĨK <ß0ÛÎÊÐBXÍ$åK?šIeUèùE„±aþ|*q›·>•õÃæ0î]Oî‡ ¾å”©¥õš=gˆsÖnjÑ5ÍY$JÜ»‹×§· ôž¯~òV#…ÚÖÀ¡tž?y¿á)•R.²:‚8òЇEDx¦,7³–ßœ0toÇÃnPM.ã(f<NyÙcuç¢[Š>{bnܽx¥XùR`AŒõBº¥ªÙeÑ«;Ô¼âêøLŽbÎ,i-!Û:š€Ž U÷FåC½ë>Õ7z£‘£gb–”0æsíÑ€ h¹­×5ÚýŸšu²qÄòfÇnO{÷Ã43–?ùˆÖˆ#iJÇ_Eµ‡þ™ã+ìW£ßkq?Ï@©×ÇK:äG—Îó‘XzÆ)êyý­Dxa‰…Æ‘tȸmY›8ø„½¡án;8fWQ–Úbšº¦¢óÚQs²å”îñŽA?··h´…Õ7KÞElC¬¢b\í°ZØæTÝÿ¬ÚÝ‹šwÖµw[hºøKỂ6'dùÊäÌf›ÞšÓ´c#ö¾X÷§iu@è`,V‡ñ†N"¨K-ÁÝÝWŒs[eñÕM±/õ­ÔÆI”…ýí<¹žæÔª Ó]j‚Ëâ±ݳͩ¢¯¿rdÛ£Íó6 B{Xø ÷…È)“1wGÊî�³Š³ÆjXÞm†¡¶é¼µÔ‡r"‘'á�ºŒ0¿áÊÙDÉ·kþðóŸH¢•¾"3Nª Ü™¬B$ÜgÎ*~ h§»«—�! ª$@Yk*Ã棇vhv#êi“›ì)8óÀŒªÐé7sªnÑãÁ+ °t²ºÁ-¬¨ûê¬ðÅ•éý¬p¸I 'd Yßxä[;WâFeÛýÙýí8ÇÄÛw¦dŽ¯rØ}¥A<X7ü Yœ‡#Œ|Ö«zwcì¨ BcG xkOí¬l þÖuÃô²!P/¦ñô®ÛMDãÖS[ Eöm‘´nÜEMá¡&ZµÀÑnßSrXž?̳›N:Vi÷‹¸©îƒØã¨rIW$N®i­× !¨¬'¥Âð³Èþï ]UŽ6TO?ª¼ª TZ:­€U‚t’¼ýû–ê`€†Ž‚MDÙ f*ƒ:P>Ñž—¬ÝĹ,Hë/Ì,E‹Ò{¬gîì#TļΩõÐì+úF, ¦ÇÝ vZÇo‘º‚nG·/ÜNžk¤fª/K‡¾>ýn2?!_åû&qMÔ•RHmQÐöÛ©E–މظÞŒe¢Ëªæ,lÅÐ0 ‡Œ&¼ù•~CO@tÉî…Ó¸AûVL²‚a@Òl<¸ï'Ô xßz¿‰瘟ãr}¦M}Ywí‚å¡œÆé­Y§ZIa<‡hÀb,ícgXTw®üHd±1™sµ]–Ó£QÍ*èâ@ÕHÛžýD[yaâЛ¤0ËNPR]IÃà1±™¡KX°2+ePe2HFöšÉ{œ;ö-[Ê轿¾,´T!ÿkYEۺǼñíý4¬ðk0)9Ó§# <85¬zÖ‚ÂãqÓ÷µ• mÄö¦›¼Jå;eSkj@òPƒÆÛnÞ=œ"Gt•Ý”–þÐlŸ*@{JÐ…±MÙt¬%§Úå—­Ì~'ÌnŒ§wkyºoÚ|×'wQ¸°-¤£#”L›Ú$½8ü-s?æô@ãYþ?ä ÝÑãòäE«•ðF–çØ_d¨fùÏáöâÐÔØ íúÒZsñ)JŸÂ¬Ý“i' Mü1WÜ%Š‰Ñ]÷e9SIØ=uû£“Uú-MF›Ýâ!GµÞq„À›¶K«4`Ã0«ÿ·fêÎï5 \e w‹KUÊ~U”uŸžn¥Œ]ïD÷_uÆêé¨ó𥇓=‡0®|O3SÒ©­x“a"Ïåðò|‹s7q–j±ûJ “>y•5¥Ï�zÞô‘«ÚNø¯L˜kpnd«È^¶;Úãz$úF C›£ó¼õxpÌÊ>¿™ XH.cçY3 ¥ñ¼öî¼@�êÁNÜØ_ÁÑéí`?Jã…¿]¬fX›h±AÑ58L"¸¦o¼å gC7ß]Áó‡ÁôÛU¶ðír—ÍJ£=ùg7p”VÌâOm±ç #†¢ÇûÉLPãžøî˜Þ8¼þGÓ,�Ëú©Ü}:¾J+Ä££î>ôˆ®%7^_è¾–K.=åQ=šªk¼Á¿¦Ãú7âë™7¦àP1œ« ß*ªÄ–FjÛŠÔÄwöSIžùÈyJ(öI~m<.ó2Ô׆ҢIì·(ØÄ X`�JVEkaÿ¹ÕG2Už€ï~"_•¦¦S3äí)BgE 'ûžÉí0$¥ã®eY:,_ÀuY’1t)¶½@¶Ê ‡^uýêÅP½ú°Î½÷ZYêÁm3µ­¡žca¯!¨¬3g%¬ä¶p­ÿÌv'/íÖž~,–ž`N£-ƒZáÛ,‹´Ê²âë ¯ïv@‰|4w®ÅL~¯{W°móp¡%¨ó�Ôÿñ¯BCrÑà¡ìG·ŸXÿà™& #éÈr†+Dú©}]χÎïkxð˜ï2öK­IOhw„~Ð4ºyûK1ªÜÎiw_"�ý¸í“%>–(ýÚýýà0|=“y´±„¾Úö2p|çƒðÔ¬ÃóÅüš&›äã1RåÕ–ŽŒô¨374cé¿ëEeBš" y3sô3ètܼú‘ÓœAßL-ò WL>5©Ošæ¡ø[V*� ý÷ɪŽª…?@&6£åqëMnæñ4l'ïUOQ è¢ùœ²åIÙlÝ${>• TâÇ*ÿZ±<'Ôü J‘_iMÈw£×ßS•²ëà/tž®1E]×-‹"RWT°Í»"e’@ê,ÊÇ>tÎ?¿.¾’)¹U„WkÊø2C¬ãš‹5JÀ5cŠn¸Ðª|B™‰ŠÈ¥ ¹AÒA±QÓ=VI»õÛ¦Ûv÷Ï[^ÖôL9Ï¡Jѽ™è`æ $2lÚ´ª)|áÓ\üËèébòÖæ‘vDònQùlÖFö±«G¯Åüxéò´,»6iÅzòXÙ€ ;Wh¸2ÍК8×£g\hR){añXÈà¬x5pÀO!3å¼pcË:âÉø3P*)¹Š—ãüïmáÍš±�hCcbÚjLaf2¡hGRÞÖöŠN_¦åýlg§±×çbèíî—”é¶^Àº‘�Ý¡¬mMÅ%G+&cÈ"†ç5ÕSŸÌésKK Gƒ@Åùá?Ÿˆw½‘ಲΧiÛqb=s¼_1›¼“-s™¹ûþn…Ha˜Ð_”Eý;²@dý1R£jØl)r„­ÍG7à¸CN&I‡ÃH·¨ƒaøy¸ï{í:Ž)c‰#ÃCm4+™éÌ¡ ÕîàãPv³ÓÃþçŒÔ,óy?¢‹•Ñ¹ø&9ÜSV²èB¤�(}ñZ·§kQBH £ìðE;ëÖžÔ•¬£zjêíR!¢7„ïFÛÀJ×*[@ †åäŸ_¦ù˜0ªu¤…ƒT`B×¼»Âæ,^\gQ˦Âèî;8‚·š w IuºzÙ ûz× [Þ]©|B•y~p²Äô44IgO[w[¯)³dý$19Ýw«¯^Ñê³!OºpMS°Á ñGWL²)¨ÅkªžR’A7õЩ’é%.ú™ç9 Ñ:×T=uÔ >²Mš‘;œ`ñÍëV2[óâzž–tA7^ ˜Eö‘ànKM žª¢¡¡?&ŸmñCD•OîU€Áü“ÕûE<𶇱±3úïPXa*̆–SU[]“И lú·çÞTÆPn¡ FÂD¦‰ ¬?%Ë°ô• 8Õ£%âuÝ°°¹gxžG™7³1Äá¤ùò÷æX3ÕÓÍ #O.á)>dÂ’E4T|ë.£"ð½ÏüÊ5•ü°7Pn"íŽeœj’„Gã‘eWêvØvƒxäíŽKV65ȸ‹c©Z2N² Ázɱñ"Ò>³ä­×¯Íì$HDÒàœ†W›lJÖ#UõÖh°`Æ‹\½^uCß×%„9%”©åY»æ[â`¬ð†ÍéBïC¡„V `hënÝÛbo™ˆY1Õ‚q¤Ãìy«/zñ„©y€ÄCójëÀÔqZYå«ïhQÏEVÊÒ®7'ÛÄÿf…¹Ãèp`>CÄ2ÝhS)r4 &6è+õÏ1F ªÛò§ÐAC*Œ['Ã÷Óú¬Û’þΟS¿b>†°êÌœ~úp¿,¼1@�:äDÛÑÛš¶ß°u<.EªÐ—ï¥u23+¦÷æ¬Ì zË]K5ÁòåMl‡Í°ëþ/Á׊}øÉžnS§5IRêø[šA>–/÷çÉe¼Ð¨ç Õ8J%{šŸ€4ö“™&möòf°T¦Nú:6‡E©¹u ;«Ë´¡ûŒÀZï6zÌØ×MÚ3å#TI$mKe¢@Ÿ5´ïœá¨™Å÷Áà2¿ƹ—Z²zñȯ“&5©°S¤+eÖùa<še;£ü ÃÔOQdô©cK€ijt_�ÐòZØ¢O½O 2Îþ½°¹-{kšÒC­|9ÑÜ©¿sðØ㛪lQÞùXqM…±šC¨¾¶È‡™ûGÖÇ›5á“Fè(ҡت��üùˆG…võõƒÝG¿¡X†J˜bÀ&4g*áßQ_¦߉AG…¦Ž¥¢Ùú2ˆF]:t³ÌDl)ëFmçm•gd[0$¤’áâtŸ¨yÒžª"@®_ïWHŽ$šÃÇáœÉ继¦·E\âpï÷Í#OÓ&4@a`áVMÈ2¡g÷5%ÈÃJVÂ{Üœ³Öóý_±'Â0\&ì,!÷ï^R# ‡·±®ˆxAI@ç¡4J:È!h4ÚõbÒLÜ^1‚£÷ÍY󺢽y›¹g”±¾ÃH‘$:žœ§Ï´O$¢Š«éß¡ûšÿ¥²€³¼G3oV‰1™&×(|­~.pDu¯¾¦èHȈíîÕ­yÒ"øцSèþdz‰Ê|ë·Ÿ9B ]È©“¡5±oÅ©Dý÷ó´CÚp½?)¯™Ìãsâ#nÔí~ =Ñ0Fÿ»Sq!Vôôôe\›ë§´TJ^3¯ÏKOxÜÀŒ²qÈÊæ4z€\¶îj^1ô¹[\Xt¤^±Ð°ë ¤ÂÝ¢Eß(Ý é/ $Ì•±oÍ¥¤ùïà´Yìcû ¼¸†*y«G‘(ÏKŽ¥>—’u¶ªÎA}YÝ­n®Ôè©ú”[s‘åÔ}S–±{èáï~õr_Ö>ô¦ñÜ-“fV­‰~ËÆå¼Íê ×¼Š"©YànNðD¶d¸ZÞXzªH½}ßé+rTEõŒ›¸Ë�€ ä´·Âèî"ñ—‹3¸MûûÌ%¸v|R1gñ ;ÐíÐËRÞøûÝsÄ®ŒþU´Aü5ùÌžô]˜Üó’QT,Ü—B8·VA5nšþu½GÚÊDC‰ݾéS(¯­Öº$Ó£¥ƒj+]£ëíLëý?ùÃþ»=±`ŽŠã>mÚ&g÷0;‚á*C~g̳¶OmïI7(ùÿ³öfË©+ËÚèµÖSøêüçD¬¹C}s)!ÑØB`I3âÿç8ùeVV•èŒÇÜ{𘠃T••Í×$Žì‘0 w,ƒØ®Lˆƒõõ…Y®’鲃íL÷¤«'õ±fœi¸ Ï&¬1’Ôý‚XžÛÈcÉýç¢"I¹,’¥–7¨� [Þ @U{zÓøÊ!9JÒ’éÄú'ñ¡ÄËX‚Vº‡'Ø�9³WÓüù¸'EàÔÇ@æåy”k¤�¿¦† #7ŸœeRz÷â„$§»ˆ/¥"n•#JÏL›»;#”IóéÃÛ£cýo3õº³àÙçµÓ|õÒ;‹Eí7¬Ïn‡jæÎКMe,•Ÿš&»baœ|zÈjךÞCÓ·? ž©c­r‡×ÏLSÀ·1L-ïŽ)|cC†Ì‡í€±°Eí<é£ë<EæÙtQ"µÿ `ÎßKšÈÜëcßõ©!¹‘ ¢çë3Ëü'&ct6ÅïÊ‚K௃µo½˜/º‹lŒB+òÓ*݇¦k.SäÌÍüI–b°< ×ß]uÂdÅ°Ý.‹)¥²‘Òeƒ[åhñÞ:´Ç__ü•‡ Ú0ÓYÄî‹vZ5üÑŠ (Z tlÄŠxÀ�üç?@§‹ÌiÖ±$Ç\£1x­šE©ÈíºsÍ–;î)ûÍòiïqï­Ñ—ÀÖ žDÆš…"lÁÜûó€&‚î—¦QžçEi¦#È;ƒË!ƒÓÅäè8)J™wüAù2àn3ž}Ü­"e,ª:h{VAÜ<½=#|hιÞKmúm™¦cNÌ `LgÓLæ†xÛ9y_6Îr4¹›éŽ•O³HÚí+ߊý"¶éέãœÍ”I ‘#mu®_îý‚h*RSÑä>ÞíˆÍaŽ'oÐÖק‘J•Àåk* ðó* È|I7ˆPÀñ%ܪÝ}La£ÿ‚ã’ä TúfU½õÆ+­)ƒ|¨M=Ë Èù˪l™Ÿ¬(à'Û‹ê9UËs,aì1½÷ÄyÂÙŠW¡«h÷öìéÚÈš?‚3³>AªßÊj%Qæak üyÊ‚ä8z¬ësÆn··;ö_A4­eghŽÈˆâüÓ’CP?Z){û7ç‘ê†ÓÝéësóDˆsu®‚Ò¶P_3…Ð×)]Àù4BM:\=TSQ]±ØÎmd½B¥x¯µ²!óÀ1áæyÏaiVd^R ÈÍ“F¿ôW©¨Xô éTJÒip™æóXÃb1¬îµhÍO—$¨Z÷Δzrµû&…ôòwœÎ-énŸòS‹Òò‚¬—úÃƉ\7ÀgRÞÊÄ˱5nGÁÏJÇ8ª…ã,f4h8lœí: dkúPFÞu Žõ¬Þµàb9ÜJ4à o”æÂÕ7…ÂTUkÌ—‰™©áòè7˜œ2êÔ1N†öêùâ4'Ñù«%Y¾·tµÚúmu@Ô¢:öÞ¯d3\0µ(]¥ÒÄRIpÔMtV-<~ú¨÷ÿì†Ö¨¡§éöbðîÿÆSœÍCßô›®àt¡3½ë®¼ÈÆ,W¨"mìL¹Âªä#¶?µP¼ydŽè$Xu6´šék4tmĬþ9Xa ¿ÅÊ[áta Y1³à$ŠÛ”r\†€ÑÒ† êüÕ×M~Ž]¼ê¡`,»ñê5¶^`0¹FÁñ°ÚréaŸÜŸd…ª3˜NH÷MoÎQ]Å•¯4Qï³M£Ä“cùÕHZ‡ì à)&ßù£ë¿:ÞˈÒ‰0e}fY‰•Ë£x×ç|›¯o€$ mN6§¾ƒU~€ZŽË̇¥‡±Ì® æÖ|!bT¾fXmA‡v‡#õçÁu’ùâ t<ozÚÁ–öÖÖ»éBq7(s}èWÙÄ‘}9ÚsDaá&ã%®~ß1JºõØzb«"ox¨?D0o–ù©yô28_CqÑlA·ù¶n¿€*²™µé5U†ÊZ.ìU<QÐ‡Ï „ÇMÌÙnšn©Ž8¿sèc;7|2_®2¿Žª}Cçã §­0†1Òe?=²r8¨‹ô^Âÿ,õ¼U#8]ž$6¼I"ݡΞeÿr gº/sõ[’ îýFk×ïç ýÛ_%’Ø“&㈵9!sv°úÀÈЛ–‰dÝúà|+CŸÿ e¨ª¬ÏÙ# µõ�N™"l1v2G¬ÂTä?D_[#OiñDÀ}ÐG´º«8ñ0WSX…E6úO©®íQ&-õx `#Ñ¥¨†t$ÌÿÚBd K@–@3Ð.:˜”.HwÄ”[Ë"Û c[“é3Er†3§ÛÙ32¢wËMt©$A\æ(— 1 NMæÁ‹Y—V6|)ëÒG£Ý<Ì|ÝwŠ(ÝÞò¨™FRù>FÖ—׌I—7o_êxH¹k ­—ðÝ֤ܲý¶>‘¿F¯E n;. Çfå÷Põ]ë)výÊe!Œz3U0}P²ü~vf/âßbç7¯;~EjšÈ L¾;ÑG·´.„D®|"¬‘W3=©U¡* Z mçiÏÐá�XBj¥-Š•hZz¯é­æ¥§JË“ó']ñì8x £ðóµ£ ©ÖÁm¢Ã<}PœdT-­~î”ã·ÁLÑCÛ6÷ð3:½Ç=†ïó»G(¡5ñ‚åW"¼x 5—û ‡¤tñžñ2¼bø4-™”5JV[Cnèç"ò´#ÖÅB÷ž±¡9#眤4íQQ14©èèÐ*<Ž:ÝãÕ™>¡iÝŠpÃBÌÚáG/ïÜÉO!íPŽËÛ+p}%ÔÛiºAu\»>;Rr¹[‰øgÜO‹çf|ö +òÊ·ðŸeK‡J2ûó–M_·&1´u'9þä…°Ó1øi–�ë “Ýl°l…Tä@žŽÜœQooê“À€þ@óáNˆÒÂbM"¦ÿ²ü%+›EF> ÞÖÆìáGåËÔ‘4e¸B`‹ºÁO‰‘tHANÿ+À¥Üʨ6Â÷d"ÒæÇ‘.üÚb”1†“»Tg#QIçOÚ²Uz¸ ht™ËæädJ¤eÁÀF×ìSÁ$%mX©%‹f„ù4Á°z4”¦´¨9go0°P#¥há›_ðíœ-Ñõkµ*WN(ZPöˆœH†7«óžU< Ä•í(O؃+Âï¬í¶åk ¦cº¶Ë¨hè•Á§‰W¨=]Ía‚jí~=òý}"ÄQ.º-,`M§o¼m=q™l ªÒÈØ;.­èñ¾Õû·ƒ1®{ú¸§[ÝÙ$Fö“÷ôvâ§0[Ó‰¤$ [ÙpòNÞÃ9± <<‚èjúØœVWÛÔ³è•{nÿofO€þ{ÉJÂp6rØóç%bé8ÝÂ&ò<ó­ÛèÃ6TÃæïêæå� R Tý±ääøÑNð�ˆÒ AY1æ‚Þ‡iç£y–ÌÁ-´7?¨(Ê´i® Ú¸–Êž2>é‡àxbi¹§?NîDÅæ‘N¥è}í%EˆQFªôŒ.ítßZ>ö”è®0Áö¨´Õ5û=ÐB{»ÀÇ}GÉ5‚cßï^؉Yî¦h½M0wlTˆŽŠovLƒ,!GÜZŒ,2ê™V½º™Q†·@ý¾ë,/ãÝq‘п­/˜N&^½D¿ÛÔ5WꔕëuIð]­º6Sm[uk˜™ê{iR>ÐLë÷ƒ™çbÖ›JÓI¼?Œà„Þÿ-`+…« ¸ŸqñÂ^;yyÃ…,G;?ÿÑ 1©ROFˆ‚Ìù‹ÞnT–,h T¶ ‡o+zñ÷þåQ•yd¢œ‹ÓqKIÔ¶1Eœz–kEE ÄYðôÎA+‚FËW‘ø·:ž?Òžš”Y[P›±¾@kê¿ <ícFFÞ“6s×?à’yš³ b7ðÈà (v^ó ;‹ê¦{ö+ÂþÓ_ö·'…ÌŒ®|ßÓ)˜®ÿx.éÌÛïj*Íaì|éŸÐ¤èÀ+ +Þ€Ö6ý/Š ßÚó#áš³$±nö—{4ŒÊ'j‡"É(àJ*a½¦‰¢C¼Ùš»—³X0f&¶Ùq+v£”U¥¯ø@×—IKyÓz€2ßÉ^™]?p• Ås÷Ö[ÜZ‰¡$’xà™…üá ~)ñª‚t[;¦ß¹køÀ}»ÔB˜¡o  ç)½N7ˆ =Ž3säÔû>¹¾.±†™ñ_¸ƒïýä×*ã‹ÜšÆ„Ý[èŒBÐcÑPÈþÞˆÝ÷q‚Ótº–ãÏvŠ©ù9†‡^ F¨l·J½®G¿÷,RÄG‹aN ƼÏDÃdÐRÓÍ;Ò¶3ôàNV‚™UE¹8$âò©¬È$KJ¥=°+¶ûsi8ŒVJL´³gc_,|wLÿû%¼q‘fÞeVG¤ÑöZ¬‡4 kûúxåÖ]ÿ!ÕËãd9K<}  GŸTAnÝ'иkx ÁÊHŒë“@ÿ(´L@ÉÕöJ¢¥|áýlKL )kn/¦–a|†s2 äos˜'c#f&ƒrA®‡÷KYäSVЌ苜9Q÷Íî°ðï ol~)çô Ýæ»Ä…(uù$KŽl+Çž……„7] åóMýòÅÆO÷’y”ñ<ª©‚°[;–/Ò–1:?<VvÏœh€Œ°=R¦ó[ÃÃ7Δ­âX¡ÒA_åŸ9^ëÆØ'?Û.ÄKç™8hÚ$(jàÕÍMy-ãöÉ �1-¥âî©`7Z›+ÐÙÔ–¯ÚœþüAȾù…¹O~¥º­;§,-´F¹¬­qdoÝ=€=‹7?VqB;’/О©ã ì/ Òtõ‘bjMLíÀ^ç4Mr5îw¹Àk³¨§ÿÈ`øÌþ}&“1²0ê·ׄ¹3®à¤6i#aêmQ„Oà„Iè7ŽpT#ÉŠ;­ë²D2'gtÄO?&ZÑ"à‚‰½åÂk áKUîàXÀ? œ¤X‡±ÓŠ°÷?K¨¬42¹<§o*²‹[è©ÍPˆÅDö¾ºŒ—Z”‚΃²V9 äšÛËGg±chÐ׃%ëÝ™#òaLÀ¶Íp«Ë×nlÓ [ |÷ "àCçGˆ¤ZàíB„Î2(ŽkOÎøÌã( ö@k匞üŠGn-û UåæBÌ•i„§‹½¯FÇK_»Í•ÕÕ¨ëäòE jÈ|¡Ó$ضtmÞ{ý ð©h5 È1½…êÊhâócâKYXX lëKÆæc±µN3C6ÑÄ`¶8vp{»ËtïW·Ö¬®Fa5;ˆàø©ÿC Ô¿ºðü¬ü^𙟎‰Ûy„>µ§‹¯êR ùmX„ž#æ©¾Ä ë?M-ª)‘ê}ê^2îlnnÅWëÆSôI e¾ä}‡ÛÒ­È{çî~k=BŸ{¸¾W΀“ÍÀ„ŒVj®?KIKp¤Z`P«W€Wµæ¼å×8†°ˆ_œ‡‚*˜? ebȧ•ùùDÄÊbAdŽŠªnFÍa)™ ,­§Ýd› HÍ0“¨w#–fi§"o‹ÈßFôY¹ªµ`=¼£­_érï÷v7=-kcõ.‹„›‹2N9}:KO$œ§ÎÙS=–ÄIË3戸U°Œ—5DZÒ`Z¿E†ÂÔ›rÜ $¸sQš–ei›u�"°¿±µ÷».“^¬¾í®¡P ¹¦ÍlÔQâ¶pºÆQ'©[rl°îGç91œÅ½{Ù$Ë=È +µ:<‡ÉãE8ÄǶÞÕ›¾‰™Z>s´r®‘èoâh†«ä»×éùØÛÉJQ˜èpÁ>.­`x¼çòö¤¸RnfÂg{TqH…²ÒŠ¯t•A®Ù­ËŸŒ¶³lá?žói¾kÇ8ÕYé‚|øÃQ•Yæé N9K¼99,'nØä¦í8è~‚Tì/´³ŠÜòØâ h·e·ê¸0èÆÎu¯–’T’tT êã]>ù#ê˜Qf13']Ùk™=&bÀ¦:‹Ó‘ö�Â8ÏÆÆcšõÕUÊ5'e“v4GÊ;NkV<Õšþ§³Ñ"¸–ÉôŽ ©x§CR È,´Xçn2c)€æ¥Œƒq†éødOëš¡3Ì™rµ ÀÚ{=ÑfŽ”zû?93ïx>êÀ Ö¯§0RBûtjm ¬èŽ¹ÆMßÑIÏ:‡¿FXÙl"6>úôggh1Cü—8øÂg0A¨“Ìj=A/e5sÁßqrçë`<RðžU…IðV{*_6ku\¦Œ¼?ÌÒËŠ‚3† ýX›¶ãXïì´»Ïv3»RÙé¾³ µ@^J8Û XTâÖlJo<]Ñ÷,Þ”µè–ÂÝá¥âxHÊ Ùöî”SNÂæЊõ+Pt¥~hTù"ì‹S;žÝÀ“-–¢6*$†÷÷ ÿ¯Âþr†Çp㣘}ê 9É= UŸnD`œlî)í`ÀO?ä <¡‰e°œ©¦àô‹ÎÚ ýÔ8\˜ 3FS…àsóë C÷ì¶Ý¦"8\̳Ø*XJå{íÆ°VÙÂJÇ®,dâoT/’ØDgÑ/ÁMáѯíæoé lE/Xq G~zÿÚPºÒ}! y:lù/™I¸¦  ªVZ”5xè±Öº§™ð—tcÞ èžr›*Hj ÀëúÌü#N‘¤‰d[ëòoT"¶³X¸°<ùvqåš3¬.<�é÷Ùë±— ~xŒ¿‘嶚Ë—Ѽ†[¶\¤­ÙÊ$3]÷Ò0J”C1±§¸ã'“wÏ•@¬é4¿è L?µÛ¸¢»ïtWmí‰Nc|¦þ dÑ‚DÃkOÙaº9›3n:‘$Ï$™5%&6ß0z÷·Àø;ùÜk‰ ø¡>Îñ{çï)GD`¾çíðÐóZaŠ¦%w­Âh·t‡9K¡4³l‹›k %Øaf;™»®{ˆRs:!Àòبv€{|æ#e¼HÎ/hŒ%éÒý”îtq UŽvÜ?vVåÖòáî<s÷4÷e¨8Î>}¿xHd¹ ÷Ä(ó¸ûiã8ª Uôd5ÏD6ê~Åê´þ·µ+Åç™ßž‹„–œÏÎ\“•ÐôŽR–ô-›Ù‚=ÈU|1åc1)¼¸A;{{½ú]S!ö*¡Ï$îMgìòþÕ~2Õy&VWÙûɦ]'ç=ÇÑmz<ÂÍ —ÿ˜‹~†ÎXmýPò,,‹غbqKÏè¨Hóß\y<RÆ¥Îu$óÑ‹ Ý×ezƒ[à9ôÑÜð)NÿµÍJ£ûÓ>‰„ æ" °9ˆÚ£â^KO#Ë|úù¤šøéµ–¹Û¼l z 7úéѿБîîbðý|ðå|ÝyaÆÅH*GƒN—ð$¶B?ïX°ý6׌2ϲ “Pl)©êÕš)BG®›ë7O…ü£›Ø£[1ý“œÍ›lÇ¥Ïçc(Åñ¾q›GŒš•½k[}ì)Ÿ‚ªãöèiéŒ`[A©fxšÜûCÈkÕÍöOP0ìE¹ög©‰H+çÒ ;WÌèQ p4¹™yüÖîjölãf`Ù) Váw6ÒR?ü þjâ²ÃXÜ)gÊÇÎÊLµÆ<õ`XÓňvÿß³¥èG(ÄïÒêBCÚ‘«sƒÄù™ô]% ö)S´(|}ª TÁ@‘ãq·êŒ• ¶fã|×i‰ðÍͤÕbšåúǬL“ŽkoÈ 3›ê¿&Nã+iB  >pïƒÇ¹£mììhõË\°¦=3÷õùÎÌ)ó*ÿ»&ŒV¶ÊxŒsäÏkˆê0É•ÂèžßÝL‘k +w*è·³¡F?{% B‡‰«|vqbÕ"}r§$ñfÜ¿mÆ,HÎÍÒý¶–ìIÒØW)ãÈ÷« 0»Úæ´Akë’‘lmÝtÏ;º‰ýÕÃ’thåEb© ¦žŽžQÙW˜Àñ·ÖŽö*ä¦5ÞÓÇI½ÆCÉãháõ`hÌNs®Wz”»NfæG“Ï[ºãXÙZy€=E•Káù´i¸Ça”�ï*z]IQáAg¶ýöÌMgÀ(Í»ÒWÝ3Xü"óÎ¥­I/)€¹ØQTV� /0ŸFŽùCŠta©RqPѨõöu»ßÑ ŸÌ3AÓ®¹3}Ó z"Þ²uÒ2IS‡$‘Û…^í@‡AÒjÏ!eÕœÿ²v·õ®¯Ð»Ü¶¤ð+Ö°„Ú3½‰¡o‰¶Î�søîWjÏ•çÏÓ©ó„–Îì#¢q¬æAjº›ÇkÊJêן"iÕÆÍÓø”¢‚Bðè»qÕswûc­‡×›wJ­ C3þžX•œŽ'$ň\äúÑUqņÙÖ¡oÅ…†*ËßI¯ÅÖß37t X6æ¾!j‡£¾é>þÚ´1÷0†)bOÛ½r|÷$ÚÌ)÷†úŽñ¿~- ï©(^.ü‹’ ?ÑÉj}j!ï E¥N'æØÜüDÛ)»¢ƒ£ ¨Þµ´ÃÑéÎÂ`¤èÏÍÐ8óö+]³ýZÇiïõW­]‚ãnžÿV&ÞMxD/B׬âþËxO;útR¾PRÝ\ÌÏ{ý0—dñ d>ª-º?n/œ¤rùêq:11Sz÷ìo©ŠÃ¥vÖÇ iµZÇ¡Ð4Qy€É§Ø¼5&y\½¸";%ÒÔ À5OkUjJéVx‹Ïä2ýçæK²9%Ân´ÃœmºôI¾›S.XÄ ý4ò¸òäê¼…£¨°šþݘÏÙg"Îë{¡Df£ø+&Írœ1G”—dÖºžP)±¤ŠŸkvy@ç©eX"w·Æ‹(Üá¹'¡OÈ£Óh:dIl­9C(áRhB‚­ÝÖðõÿïÿ™ÞÄÑ䘽»g~—.Õ G¦Œ}9ý<[x1¿e›l;tÿ‘¾©XE™í)ªÓÚKÄÿÖ€³þÕ˜Æ/IRuZJ­Ÿ�šfM׶F­ÈP9£’òݶ±ÊзoHíÀ÷O×׃_¸7Ð (Q[ÑYÖtß÷“Y_rË‘Ò°ÑúÝìºø ðË“t ‚SSM8‘÷—o"¬ËtH­k¸¡ï`@Ó‡…÷y/ÑICºarCé^ÕkºÇ‹ö̓×ôµÞXMßì̵g›°Ý¹jÔ>]bœm„ÚŒ6ÕŸýÑIÙÉ*`¯?¡y®}kzi׿x«±ý±F¢;Õ¢ ›Ôë·¡kX/m¤0'À4Y'á¨v°žÞÁÒû‡¼ÒΔ…®¿=í•ñÒr¥ßy7Xkο¨çãp!lÃKšbgwô0ƒ†êvè MQœ9?ðHô(!K6½‹“[ÈžBóZÕHí$üµ‘xä•,O?}PNm3*® e‰:Ø…ü="^fìÇjÊ$XèXNinO Ã9ØüFí© }TÚhSFïŠÕ‚Ã|a$oe´_íPÆaìáÇ>UA\þÅé/ûÝ¢MÃ\),‹?“g醇žÃ¬HöQ°o{„0û‚r• ¿ÓKhFçN Ç43‹ÙÊ÷ U 牼ƒq="ÊLÅ‹éþŸ©p0T ûÌÓcbç`€ÏÖŒä°wš­ƒ»ÙƒŸY1ðTÁ]&™ŽúôQQ»qüY>jE¿~×ï'È\Ù'ûzE…‘Ié<z7+‚ž!‹éíiEª%º9T½OEÃþÎ{®ð®X£(\ŸÍabPq/7žP׋Áë0ž–Oònôäè‰nç¿;ÆãÄJ„‹a¤{ gÃÕARPøS)/íÒ<ñþ%˜èè›»Áq’ôê¥R˜"‡Ü12Hß•A1yâÞNß Ó8€„Ü`Ž®eør9˜d >ScÅ ú<jŸ¶dEcÛ~¬ÇUæÛ3qç4çÚÃ:¶c}fŸöG(µ8ö]s$ž¿çAà ûÀÙ¶¡Ó¥*ÍPrêS:(”uEåúÀœó¶ ×ûÚÊÄ·Óa¼~ä#Z©X÷î?»þ5Ò04á$âña79ºßˆåÙ¿·¢Ó¢›B¸¯)ãîVa½´¬fa&ðŽÞìá0v˜_v÷£—VÆü2õZ5³H¹‡>6ÒÏ}Õª{VE|åñÛ”/880¾{fÇü›¼+N<]O®ƒEÓŠoF±øYsOÀRrœ æ+â˜NN¨0"KÛ:ŠÞžÃtTîötŠìêÞ²ŠX&}ùp§L }åÐ0 †sLÛF‘˜þ¶#«3=Åaø ›”XŠŠˆz0H˜‡³.;Cn‹Yùµp}ê‡<r9ЇŽ¿ß˜˜Ij½ ¿ aúkˆ…ÖKMnÓÓÚêuÈdòºÃn€Pi&dh›TÌ lî?½2¿Ðñ"m—vH ím-~0!’…ÚVów’Òn·Ÿ´‰ó+ægyÌÏLüÒRúŽ¯Š>‚n~¯z‰“fO_ùñ†ˆèî‰É¼:" $¦Ü9g0ÿšÕ¼±û–†Ú9š©t°žÖYƒ"oþCÖ›6Ëcð{Fß© /,cµÿHÊ´ M+{×4”…é¼ £d ç õW$µ4Ëí´”EíÚ1É JjmGÕq}ú:ì–'±\ ¿?¥ß`7é*¿£ æìÊì ‹¢Ýri‚½FˆÅ›²Á!ž^A?i§>V˜êê‹Â¢Ó}@X¤kÍs¹Niºãic^›J'Kä%(q±®Ññ@ËKØ»^KÛŽeiÚ»Éü+‚kEtŇdHrUŸ=ÞЄù¬ÑQú9Í<‰UZ ûŽ–¥½ \Ñ–¤Ý¼sL«š”‚þ}0ØiÀ³d Õ‚t_Mœ_Ü^Á,3NGÛjÙÁÖ‡†¥«—Ñ,b/`ÊTß !Ž:å[Ž«úÃÃúö<=-.ÊìªðÖ¨¸½ïg\TNvŠå /úëÐØ'XkMJvä°~õà ڙ¢Æ 6؇Uö*åYø5&ÞüL>L¼É(’-ô3º­º`¥ô‡’ØÚ´ÕeBùÜp¼Ê–f,MK{e·#4NÝ x mܼ`¨æº©ñ˜Ÿ>¨ö‚o•h³,´µZ(á#Eì/¦(}N”ŒÓÐÑ$r6ç>ÑšÛt&§c€Ž´ë½ðCd7âZhñvò-´E3yèòŒaœ‘Ý´ œ;‘‰;† Œ±¹*ÇáÂTjÆ’6ŒNÓ’x!{ÒxêùJóo1c`¢ótóáÓs‰F?SAŸÛ# ;òÆ•¼iY@gªFz†û<´¬èæí»z\´«UPÍ[f‘Ï'ª¦õ5陃~:µË’Œ2³¹ÐÿBŠ:÷DYœ•gÁ¡ù¹ÚS€¨Öµczï¡ËŠL‚{ÉXñ 9}¥ƒSn§£ ZS¢p²’'‰Ø7Œ®LXðfÜmž=3ØK––é%ä(Ѫ:Y`M¡ýk,½»–1ý#í=¸Àã$¤8F+¡öU/“ÔU<|º¤ ¡sW¡éú‰«èik‘õöéÄR8¼\¯R¢2÷G‡´—V_Té¬7O'Ÿ/bü³„£³*ÈÍ'^Õt9ÊKç]m:zÛE½G&·#&A„ 5su8Þhµ¦šŽ¥0(À? rz]Ä)º¹TötŠ4`;½ë{³£«Ä�¦” G7ÜìúÝŸÄ1H^>ºW l«2Ší¨¤²XÐ¥ÏíÑmqú6Qói~ê»<¥ìæÕ À/Tªs@`ütm“;³c!#ª¹§;‡HæéØg8žçsÉóeÁ¸+®]½›¡a1—v|I¶0¨ëïUy•ùTÊŒ¦2¨¾5ÁÖS­[ÕÃWwy£ÌTÔÊ—¯0¡“’É!+ãÒ†yÉWbÍ¥bfô­ûƒs6}e…'ÊU³PêÍ)ãäÔŽ¶D8ØKœbõçDmÁ»g(‘ÛçQvU£Óº¦ îD¤Ø/ 8¬2<fÀÛ'?8#Åe¶ˆƒÀ€SÔÖæŒæSk©Ö{²J©ŠÚc@r`É2þa!%^Œ)…pFwØ2Â!‹Z£ånæ¿£¥®j+gÎF{òBfmˆ:XÞh×3¨…†?É�EO˜¸ìêYª–ÿ R(–Ó}M{8-®Má¦3­­­ÝÓ‘Öm«ƒ“Ù“ú·†ªe˜ø”`ú6Ý*¾e«.e+Ýt¤åÊS”¤È’Àhblv´o¤§ÍË[˜ªa+†"²”_sqo´é-Yuk8”îš³'âwûÄ?q.X‰T_e)Ÿ1&M>µù™¾…bŸ/]q;°§di¸˜ ½d#'Äý¡$Qz›TYL(ɃäÓšn‡�3G]³Íéã¼ ¯xÆ´XŠÖJ`å öV›×_ F¬º°ÜP€3Ïà†?¦šOl+É$¦ç¥Ò&Ù×ã3·‰*K<G½¨÷0ÅRy]™–¾yoî:)kc(³u³ÏLC\¦ÒV×ÀyÕ¼—o38�Å##xaÕ[á38{²[£²25±UÐ]À0(k%ø9¹y‘=—mœx¿7çÏ(8}¼’;е.‘G$µ’ø3Öî€ ª•À±"§âPIEŽÞZ¿“`èõç4È,%’•™=G¸åðÇ—áÒá«…ýAd]¸‹@ÖŽmànè£Oʳ\¼2æÓËFcn]¹s½ö›’%Î-˜LL¾™>!ÙzؘAÇ«"s¹çêž!óœ¨Øq�G(ùtçÉÍNÁPçQòƒG/pI  “êx� n«D×Ü„-GÊD$¿¼V?V¹íˆÖë—ô&ö¸ªÍ¯n|WbÆ¿”7®Â…!M-¸Œê,Ûyt~s„+TÁï”àâjAÄ}ß'T!-„ WЂ<âbøX.?öÿ µO’ ±¾Ù@ó4Óá�üljÈýÁ²úž‰D åv‡>H­Ò©¶÷‚°+mëó+†Ùη³4dxöcí­<yÁÚ*}þ“«ßUWÕئ§•ØZ ¯ Îóô¦Bv;F³ÐõµÿÂgÌò(|v"¦ñ¢ÚƒRQøQš-@7ÿ}c‡ÍöJb žŠ$Ñ‹íGV¨ ´j8%éN† À°me¹NÖ(ìñ4 —}×zŠ6N-ˆ[WˆÉÈ«‹vP®.ÅYQ”óä¿T,ÕÃgòüyøÍ>q›-OÆAò\ ûË0˜Œ^–WŠ¢YêË=F&àÆV:Ë“°ëáðrM#ŸýBï:C<¾ØêÓ‡o•ƒÃG‡èêž™ò Ð`­”èµ°ÝšUsƒ|>Hƒˆ©Ö†êÕP2t8âÊØ–¤`‰¸Ñ5Ï<cÆC‡);ÎV",P£“yùQƒ)Ž}ž0ç*Èßs¼9wX¨ÁÇpšÑfLC¨È<4§ÉóiüKæZéÑ&àSçtšLæ[íëMý‡ç�šÖ$¬Gv‘‚ †RòõÉ Š9÷#é/ùʘÏ46ýñz“¼YÅS†ò×15×1Ši›žþF1.o˜†Ã™Bö®¶l qÑÆ‹Gk{ÊpË¢p´…|iì‘€ á·ÚáÞ«è·è?qûÄ ªw>æŠ5…5Éç¡+n¾–¸ÀJ•[¶FáN«ßT¤‰]žrJAÇÙ¥¼lúàôÜï=»e¥9íÞʌ᧛¾_{$é±Þôõ•ÄƒIx)ßú,$±øfœR»Í¸Ñ/~²È4?_ùçÍä÷ ÛE)Àhôg}Î"÷¹ȲFúSµë¬ ·=P¨5ûqâ·Fω]A¬Iˆ>.ŽË²2ž–j=]�dW-ÏŒu׊ååü;oÑÒׄR̘³dsdÁ(âvvìéÁ©,cÔyÏik‘-Ægⶱ¸\Ö¡r™ßÛŸYÊwU)?›à–÷ Ô(öjé"0Oæ)£È/j”|ÐNë�†çvôpZ›¾k:~¿5- O²üê傹Ñ÷µRJ|rºÊÝÙJ˜‡åQ¼­ÕD»ÿôF)-v,i`n‹GŽ›@šàf=úòÛÿRŠ[§ÅÌ-ÄDe�úm\>6[¶rò#«<âçïܪ܀6¹‹Ùé¾Ù¹1L'ÔJP´š…À×ëï]ßجãi*E ¿Ñ‚²Üûiêj‘?Èôþg=(mDê{اX·8|Üz}Ð ã@MQæ¹)€s™.u9°Ù±¢m…‹pg’ƒ¯c3ÞΞ#_á<çŒeª‚°ÑÅYœ¢ÎVì®îðâOüÅ¢ =ƒ\Zõg g³rìaçéMuïÁ´’XωX”}sÊèç£.·8ef7—ß’ó$6;æ'zqKÈCéO\™9Fë6mzO¤ïØ ® ¿Õ-þ”±9HŒØñ€¶G]A\” e ñWý–Å+ª<¤ý/”$®½†ë¤^ðÇÆö| �¬ ø»í >Qˆì¦ÏÌýÝžP”O–iÇ‘-@ÍJãZÀ<ü•Þ‰×Ä6¢>[ºý¡Õ"Lã=Â3/>Xæ‰[ÒSCëuùœàÈ÷‚a¨à¾-t¡]w›Zó©Ћ±ƒ.‹ƒ+Ëj¶W>EPgžLð‹šÁ¢ªà°I)GÛx-k,e#iþÌàöWWžR–‘ÓG¤Öž‚1h~쌤çkÌ4utc– âã"«’flwèßXC–3¯¿:+è¤(|=t ç›SBÉÁgkäf¾ð‰.tV€×{úxëç6Pø›Æd¨M˜{! ÝaîtgtœÎÅ8zÐv"›P¥Ænø ¨ÑB¾<üŠk¶wÛ ó­Jµ¯(/Tlb^b¶Žõc[’ÇZ(Ro„ r? m  äÛ?o†‹J’îµ6™X ä/°lIéÄݘÓv`äDˆþîÖŒ»#VyxlUaÓÍT¤](òÉ¢äÕ]¯:ϕ榽@¥A9pw¦ª7.íO}Ã*”D§£xþ¶õ;ü+SfõnˆƒÈ%!LyÜîhY?ÈPGŽSÏú|IzÚцÃögµÑDåµyõ�žÄI‚'|Â5kIµnÛÝäP¸„<S¹ÕoŽofÈSÊí(±ôit=ž™ÍQò¨»ä™°30³iÐ;±@Æ ql‡ZÉ|Ɔ£ºøº²„‡ÑþJ¥É®ÖÊ°ôú!£3Cc|ÍãEÚt®•èúbcés2פ7lÆ"È•nÚÁH‹#D(ïP÷Ê5†l§ØÜøÏj¹¤±§É•àu)펋“–BÐö«tk›Æ€GoÊñ2 }\4»(¤¢p}½¬€ÀêÀXä7þ¥PD¨D£+Â4ó»˜Û()\A”¡@äZËúÌx€Ê�DëêúL= ò®Eh+ŽAZ«ïQÕXg%å™›nX]¼5ù Çä,óM@)e:5`Å·6ù@š\ÏVåÅâw~ äÉ õ¬ï€­ômzf?NÂø9º“çî35]U> úùMÄí§ƒj÷»Þ^—¶†´>°¼o:´ÞžþÖ³wÍMÛnuXh€Çì1œfWBÈÀ5¹r•¿©Ì3Ï›kžŸœZ³‹¹‹pþ˜àÕ¨TÛW§'¹‚æSñ]ècBFÂY×Ýj-nkÁ@Þ~Æ*ô”Ö"´û.N ­ïpO0ÀWý*oeˆ÷Ì6¥à=7žƒˆ¯:…êTÀŠwÔ›òÍ.…”Be:¥÷8«$  }§�Å¿dQÚã¶0ŒÀ¾†mûUm}SíšëM=¶ÆDvšîüFâ½ÿ Ì3ßl†•ÏS6)µ×~ePd×@Lå`*·“'W!-b(£@yÀ¬#;•ìäá´Vƒ¤øBRli¦ŒN‘O3\Iª´á“êÈ9í=I³ùuJvš›fe©:ƒ{ºëÇw5i~¼±"3Ý1ã £BiÛ®ß[þ§vDNº‹õ:{ºPÓÉSè1Ó\Þ-/ˆw•ËIo©0(Z%š¦¹ñú’àÄE·ÙH;̨ÿê©»ü…o{ccJëÈ,geú.Eâÿù|Õµ/zkØ”©HãÌÒƒIÚPéçVý™Õe +¢ªi®Ò BYŒKCvxϪÄÆ\»A±œ­IÅ#_\›œNö+ò‹–›hÙqO©þç·7 ïkuC°Ü’Ÿ&ìQ¬£¯ÞÞvôfÍYÕÛº<ðyì‰w°Ís=öŽ˜ŽÔ@~ê:¿÷Ê Š ]í¼ 5¿ñrh¡–±û¾ã܇ÿì¡yz ÖjKé¾:Üƈ—a¦‹ ç þôݺö2nwg¶èÙ^Æ·ùÒ®wý/Ãÿ¨q§UÓ‡L ²x¶§õI±gÞuŠßŒŒ A&Ù=‹í©óƒÑ ¸~¼¥.å tň)Iƒ¬Öô“YÖž¦ÊéÅÖÌ«­9áÿÕáözd�Ç.¦³ôøíWÔZØ•=°‰–Ú¶OÕùZ¹Ê‚b1rß,(FÍ}×tñ°ê«$P9ZÊÙgá+êÁuÎ|zè£q\±,¹0 vG åýVÏ%Q¹Ýt‡‘>“ML7ªÓ¸Èá=.ÄŠ£°4°ùm¡aÒAYÏäþ%G²Ò÷'@”°b ¢– :Ùizk´¬é+¬&È~G“)ólm8Û¢ëMEx«ŒÐ4­h‹ëQ½ïøäÞþÁ\µeÒk È|­hÕœ‹ ¶FkqÌxÉðC÷:‹cçÈÁê%ç:¥7Ô˜ Héf„çÀx‰h¨1~ƒ}­©-#ãÞSogá; k–jÿ½Q~Ùй3ºÖ[:'M®FÁ—ù[¯ùè†e #p#×H¡d8Ó¦*6ß&!Z ˜4 NÓAŠrds .·t«'<îȃ$„Æ-eU³¿»âA«¤’à,Ê©÷˜=©î$]Ùq‡¶ÁRO!R šD‚¹ÿH‚¢Q¬HÖÊÄ|d÷W6)©§d Ç1tÜú d ²”¸ ÜŠ2+•nÇñhÕÜóÇ6YìÎnePpÅ(crVŸûúÂæU|—/èÙýK¨œ“L'u»ž3¾—otât›þ|™þ·ŒÔ­ª@,hcΟè¿Y#Æï-ø: uÔm?w»@ÉS“S©ƒJ:Û¤T`ªÒ–,¾·ž+3ÍpfeT$cþî™Iê‚0—ÓSM™P¶]/TbÚõè$47èrDð~¾±Ž åÍa¾ópF¶á“#Zî6yL³›JŠÚ§Ítw=´§ÌÕº£«`¢€v ö#; ·öh‡u+Ê,&’Ví ^Ñgå s²v[±Q”…€$….¸KiErjlå¸CU‡HE/_yRœ’H'‚G‰?gÛ*£”×à(”à$ U¹Uª¢ ·¼ÈÈT5à€;~¡óÙž€RÃzÚ4ž`³cùu,R†ü˜& ‹ÝÓ¡ß1¯åF²ÍâØuHqpµ§åa•…ò¥râºë)´ iÓQœÀŸ^Vn]a½J(ÙB¯Ë†8ûôð²ÐI•› ûOëK/€+‘0¿•wÖ¦‹ŒÄ(ož€/TäœèºquQ¾Æ43¾ôöɲŠ£ÄàMJÃ1™f*††oíôW˜;bfÓ¾µ5cµ”1' ûü¥'ú¬[&DTv¦±I3& yt©ÌsúCé:7[Úå–r7yÊÞóæ4Ž‘ÕÉÜ×!à”ŽR‹ áìpû›ã¡]~‚~žé0‡O:ªK!‘9›4À øÞÒûµ!ÃIë~Ü©­­ùeò»cŒ eí¥ó^ÆeסçcÆ‚_œÀD?Kl;TÙ*a©îgV;2$†`K%Ý{vÝJSß׃š’¨AEXuLY›øNVí¡% ®µÎŠC#NÞöY:­?Æyq÷Wt�†îÌý¬‹a’=›yžyÜdaP6+êÙÉÜÐ'œ=ésº<VêêåMóSÐÔzÈó燧gNéw¨±_45=©B ¡[L°6·#È‘}Eµ<ŒÅ({~÷® í²À¬Ö^âÝ.;É=„=Or{ ÓæEÌ-Ù¸ñSCþúbáG¹?OÙö ú»Zè”SŸ5¢éF°k…¥Úw?Íò“Èèg¸AÛ#ÝÃÆÜšÉë’¾f0f‡lbRÂŽ¯ T¬VdxÌ=¨ ·™DIn±‚g|Iæš®â?;Ð¥>ZK”(l‚à°vƒæå0û‰zÅþG‰ÕžéJXq,™Tg¢LÄ`ˆÉ_Mâ"tÇ«NP¶Rɧ¯¬ÛaªsYÝë m8~T— q÷Š*À†¨Û®‡œÔnÓ¯ì΢v'N”‚e£þÇêhwÓÖ\Ÿcëî§,øÚ,Ëü9ZôUéGKV)Ͳ¬bçÏviâJ¾í¹Õ™Êw(åFûÙ; åõÖ-_Á[ç¥7ðÍ4«²%´)…¼~Êz±Zº4¿ôØ(ƒ29åáÙW’yg-Q"Ä‘ ~¡Þkã •Ãê0wº{¯—âù TáŠN§Wwr8¤ 7Ÿ_èxœñÔ¥'O]æí?tð¶úf<wÌ…%÷=’ã™/)ÕÈ,Üa˜û‚t¿ ÷w#^áË™ËÞCÕ×#ös¶RPíGÇ=ª˜»S†ó+>"㼸dšeqRX7@†bˆauÿúY[‚EBBXÕRbxṗ=í¥É¬ß1í³+û›gpv½~=N6Ìlñ'T^lž¥SïÙ½§þ´bÄê‹J°Ne7á=†•"†}B6þè†]6§»«³(³¥5Ç°AŸh;xÜz :wžTð†Žê+«·nì }rU˜†eæÍÃ\Ôæ‹ébî&¯L|]ÓÊfòŽUzÇWeæyjÇ”‚»Uj¸¨î•¥¢ÖTNäÖ¾X~â2\Ôvp MØÒÉõ„¹#2\Û–2[VŠCæÚÖ«ÃxÚßðž 3›IA>z+4œÌ´; œJ§øÙÒYÈÉËÙ3Æþÿ4—(Õå\pìZJ…‰ãjißû¥ãÄSæW⪚ÚkÚ@4Û)ÔýhÊÔ¼å$s¦ÜŽ6)sËxÉ`ùÔM6J‚0O¤iöÅ �Š(3…ö4qüùǵéŒ!&/’[ù¥ÔÔ9¤ ùâˆ>8üÞäG0!FŒ©Wž=Á|iñ%Þ6;±)>ía9iÕ¤¹õJ—v¨‚âÓj&èºQEyÕ(xžªïuaªÓÍ© ÊZ§˜Å£ñ÷å è$Œ&2?Þ‘<É'^Ç«>±ÑÜù.†ô9.Ú̹q…•ûæk½-ußÌæ”ÏÌQ¥1ÎPkäíâuc–Æ DÅ7úU=­ÅJÊ™G¯Q˜ìQÏU'z8eäsëØóa|;¼10Åx‚ZPå¾|ñ Wz@z¦9ƒ˜RXî„íÀŠ³2ö³£p›¼ü-W%©’%£ûNâ zï½q>j^£ÖR.gŒT0ñré}§öžÿe‚_’Ó5KÅ\¯u–ž eðÇ/<~bQ.ˆK¤±”K ƒšR~c©.Tá^ ì%<ËjÊÌ|²Ÿðî›Ú,«T›?šH=M_}ÿ(¤2´ ò µöRšOFqXäwø‘ r§âí¾¹gôÞ¡+]ð3úZT÷ßx@Ä),›Økq¾b0§F%R‡•ŒÀ#ëÕ–§EoZ¿{gÑÂ*†2ƒ2(Žª]Œƒ™4Øڱ̚µ|ê|hdᚊþÒZ1%F«Z6å9nøF[lä!¨IZÐ?(¥’±ŸmÙ>ìÝê9,ƒaŠÿÐÍKºoùJ'ŒgnÆC¼¤Þkf7^I ×VõO"råæQ™èwÓõ…¸ˆÛîøó{#.ú.PμÜÁg=Cl%a²è%Á¸§÷oõ  5ŽN-»z¡‘%…!–OÙ48C~"­-¾„`é‘ÿ'˜?<ý´é v•{ú«†%tuh—…%Û¢ò ƒcÊÉê²ÿãà‹¹ô@Bˆµ,r'd¦´™k®ñ〤™õ±º;I_Q÷áè:ùç®gqBµ~ýmΞ,æ™ÀËyo·&b®}±…³™ú–·Ž÷]%ˆ"7º’ã& Ê­rµ“<0Dz=eq™]®ÑëúÑ늅¢\A&9ˆ{‹ˆÍÄUýj[Ó§îPÀQˆ4£©ßL{ãܹß>ëðM ?Ûœœÿîê@Õêh`”5Œ‰N<¥½Erp•„$Õ‚N¹Þ˜ùztS<üRÃ:™°™ žrŽ%Õ1„ä+ˆ{zºÏ1[¥´ì•=3ïf³¤)ABrÆéy75¿@‹ýÏžøYDÿ‰<$4W&MKñØê¹%X÷¹N/§‰Ë……Ÿ!ôìÝ–:)3ÇÃÉì©ŸTÏï  çžÜ×=}OYTµÞ±Œ0´5•Ë269µÃáíý4¬fÔ_¸tRî—fN¼¦{زI3x£½5ÔÓó;ü¬Èþ;‹çÉ ’BâîH«%oz¯8rÈsÍÑvHÒŒÔ Þ@$ñ­ „†{’wL¬ŒÂ<ÖrÌÈÞŸ–ÿОÆa½_oüJ|<I";y±!º‹Ø;$˜?ŽÀ”ð(J(+ý¥Åé!Ý6íA_ãæÚo›]´š)€ÕzTW&°#ñËQ„¶œÒÃmÕ=[QÝG†ílŒzã ¬W-Ž~¢,lø£}OÓ~¸ÃiA¼Ð›,XŠ,,'ô>¨¢YøÛ–u…^ŠK_ì“¡£='ƒTI'i)—ü]ørSkEú ì»³š‹ ²"Š%fPT…©€ÓŽª%³pèôºÙÚú9Ó€û,ªÉ¡1­QÔëlü‡èÿÖ‡iqXß#v+… €>÷Ê›-öf5èÑb§x'¢ANî¬Nƒ1ã‘3ï³þš¹ä÷ä+Ö“ƒ X×^hÄÜT§6U¶Jù«‘ÚbWÝýed'TÍc‘‘R›Ú j²‹S׳п íwœ¯„œãÒ›ýdžPSY­Ðp¼+m[Ž2;]fÙ{ñ º“c'Ž`!ŠD¬¶÷îƒ9aqà€yáКDKCZ¬À}ZÓ–”J}ZPVj‚ÂLˆÚ„†€,^Ø V`Z Iê|§©ñd\Gµ¶{â•ä™W¹ÐWŸ?á <èÂ0$9[~1lMÇp| €Íz?Ù:÷N 6’¥¢‹^7 ,-CÓÉÔ’œ®çåH›–ÓtgÚúmuÐY§ËxïW”ìFö³KËaÇãÂÓÖÑŠW#6®•ŽžDêÏCkðkqp=Ô‚_H.x.ÆŸ¿xФ‡¼; ­Åº . ‰®^Ýøêh-wã^6Ovö,Y ¬f¾ÊÖø OÐט€æ=5ùŠÛïÒת© œ!æeâá†ñ5|öOßý³¾ômÇó¥+™ÔoÝ£L¯áÌV·y£"ògÏ]nñWà~fQ”Nј힩.ì75T@ 6DÝÓÞâ†~ò3ÉQŸ;L2÷YYûóãIÉÍööºõ:E}þ+Ï”6âÒ+,$é{çiÜÑÚ`Ë£íÌ'<a™3*y̦/‚謄­„ÝÃ.›z´‚ßôáX(Ú8GÍÃTî`-ÓÜTŠ,K™\S<ˆIœ–øž•Ì;°W¥ôûΓ[ý˜Êsó)Xµ}NØ¿[ÞýðQ5 — w�éÇy‰Ï"öù­bîh­¾©Žïõz åpšS“¢ê •ÖptÃU¢_sA£ÐWÉc@*Л:”¡ §¡?Í…™ê ƒRû=·r¦‰¡ø´Ó_t嘚d~K¿*¤•â)bA8lb ¥ î¤ òc׆²~'·Å<êéˆJW™wn?]&pm'ßwÚehOóM9ÝÎÈ?Ùg‹:@…Ã$¡¯ÀAÅIY%zA» R{/þ÷D‚b_L5ÁŽn¶´È7G,!‘Ðkè_QѽíOЙg±ßƒ¥W]·ÌãÈ §c^VÒµ¦£¥X릋‹…eˆbz�b½ßçžÙb¤$|#-“ɬ^è(¡¤ç9îèÛzTàÂO vÁ1¥##‰¿QlÄGw~ë.”Dk›RðœjMaX¡ÓŸEñ3•Óîõ¶Ž˜-f¬ PRž:MVB|Ñ°-}×1Tï´ÙãIA�°"`…i—Õ¿�]HÛÐRIÊËC+lЖÇþ"§©FûÇ¿°Ükë'MŒJDSÓ´Jàöw¢Ú…Jîe½ÛÑs\ÛÊ^æª=:,÷�»Ö&DXØapè‘”,ÈtÒê5à+ !yæwûä> ËÍ%¤á<]’ {/ÃÔÙ‡ÉzîªÅ½"W–¶ âÖê+7Ü#…ÂÖ½4€_7>(b Âl¿ó nýyÙé3Tmf]½|Š*Q³¥(3UܼFß_Á8Ûèô}cGRú¨Æyáìô¡Êi»ÑI‚KíœÇîc7èÕ#X!J–UP~ZËÝ£>Á§NàÌÜæÙ¸{F¶k÷´Íí±ynQ.$娬šKÆô8‚ÇAlC͈n׶§þ¸½E {Ï›þo¦›B(‹<©Âl–$HºVA°améùËü,+/¹Œ]²e°9Áçúýx´‰)aµÇ¯fï\ð¹¯âµç¤Áx¶v¦Uz:ëZ…»Mã7“1ŽöÉýÑlZfžù<…8ª^`x¨ÀÑò»”ݱø€fŒûÜ(xYî W±”±_tÁœ-â­Í,bQ!é7áÓz´ò`#´‘^ÖÚh0+m’àg¦ÓÄfš(±t|Sy·n\^³ˆ.(¢ &±™ˆY…⪶ڂ.#Uêò…»Òay•9¶¨\�ºŽ]³e<4"æÉ¥÷@`¶+‘g¸&Ú+Z ¸éƒ±VY¼^›.¢Xúþé|Åø¤{ZñâùkŲ$L3ÍKÅ ŠòßìÓ1lÞ4 ÒbâU³Ò+ygrÑu“§q|ì†ãnÚÔêÄøûº=Ê=ÚbÂÔ„>§ob=êÐij¬Í®ô¨ýÝ©\e¾Kn¬-õéä9§Lh®VÛQIb;èËnze3ÎÌÍÏ2wÔŽÝ@‡pMÿ}‹™ƒ‚Ú¦S‘qÈ�S ™ÛeÍ¢çýR Æ|pÔ}Ùظâ ‘™–+cÉ)d¡KýbýY"‚ðÂS47àcÑ:Ûe„ÂN=ž‘:³{™ÿô\£œ‰I<8.Tô¯qâkzkÕ­J÷ì¼ø‡îé=+ç2ó/hú*‡“ 'A7‰…ñ,ù±„–éÐ?Ë®xÄy¦^ÓXIÛ;I<v«í¡¯'ÛŠ`7ªmÜ+ 8†Xåà%ÖÒ±£C=:êýÅõ”ækÐúcÇ‘Íeâ¸*×x°*óî¬É[ÑÊ?[×;ÄHîj+ŒMNÈ0à¶S|“zF¤øºõ,mT×¢H}|B*}›˜ªŸVê ŒñI{¾\¸>jÙ$•o ŧ)¢-Ð{蘉ַ`6<ÊÛÓI‡…ëÇF¾mÿ‘Rì¶^\ÛÑ;Šá‡t é©LǵŽÂþÙœ)Ë`@¡ ,YõvXËêŸüg´u(’áöß7ÿ<ãÀýúƒ†TXxÄ ;Š²óÉ›y3Ýeò.ßß"-–9èøoèÎô­å¶ó0|Gÿ‰kV@ËIð(/Ò8|“Lq&ž6´:…Ú˜y±⌔D×úÞ³kØ©a)ÑhMäGuÙ^×;ƒ‚E²°Cmvƒõ{ü¹=¬¬ ~чu* 9`˜iÏ UN´¤JCó"ÏëÓ×°çf„­²Ó�½4†�Ô+¬Y—ë½Ð«l뗽ΦCëÙA›Èè©_ :ĉ˜˜Œߪ£ pÃŒå8¾(àÀïL'ßš²B£B7 ·†kåcü‘^„ æTpéic  Ü¥<BÐ2�‘’±·Êpv6'÷a„ÑÄS¯›±åÊZU‘é)²­¦Áo•¡+»ã`-Å[¼ìREQž¥Ye2± h² »è÷Ù¼ÑD·òØwߧ“f„¼cÍ)ÿSP¯VÚÜ^†ÿ¥?ˆþ“e>~•þ\W¥Í#Àµº{m¶DÝßÉ-Ø«<>Jp¸[±EL»ç¦õ¾€ö‘ñû¯&¢1ú˜Öš LÓÑÛ·[Â.¹IY¾ž—LóÿPÜêql²?[ž‹‰oŒKñpž¨rÌ,|.e ;®´f*ñÈ5Ô™.9bØä!ñÔöy´C'#¸ÇÆã'!;ÛµOÌô@Uø. ”îÌ#"ÔÙ#fh·Øääb2§ñàbd,²Ecfö5ôÕ{•?¤ãa½C* 1FEˆ…Žé½˜þˆåÈýLšË²8s0¨8 hÝ>bÎs ZEŽ—NþŸ &®HÁ™¢É…© -—Ü1¨c’°×8¶, í¼bS/Ýݪ  Ô8ZMXŽ4åäƒLRhŸÐù Í&÷WgZe>‚‘òp.Û;Ùå‘œeÈ‘ÕØíié9Ñ‘P=h§œ ÷ÄêŒsR="I¹2ÎúYû­L3_e™ÒÖ-š"á§VY«S;![õ×¹:7J˜›ûÝ4±^µhêu²î0BcŸkFI8n<"Žî­/ãûÓ´.)m:Ú™ÇC$ï½—öq&é’kÊuT`¹X·”¬e,¤jÐ Ã:µ2²(ônçW€aÖ(3”ÏËí²“À³Óá‰",†5‚;]D)-2ŸU ñž,ˆ†Î5Œ\½¯Ãx+–üd“§•ëOóÔ¼‚¶8öž#4¼Þàé…ø—z.á,aIY@LëAË«ö½9§»KÇ9¬tÚ¡þv7ð+Pí·zŠOÉQžakq¨?dPBÿóùÔR9´”¤™ë{7ÄòàÁB·h;B*¥¬5à¡á׋UkI€V&Å>¹ËHó¡~ :¯ÑoÚn=(1_L“8œæ .)ŒƒðC+r'&+‚») 7ª·VH;Loì1 Ÿ6myt7ë–ÓH¸½yŸ}ñ5òÐWÅ¥¿1ôÙ/ëÞŠ:Ön£ìs¤™ƒ BXtâû=t<@QËo•:{DÆCÿé’ºEGVÔ}–O¸ŠÚ Éåú7è™7Ï£¨4Ò­È/½Ÿ»¦±š¾‡ «�ªôB™ž{ÚDn‡Æ–ûØÃÐÁ¢ÛÀ€«T¨¾R‹)úS3S4»þþÑ_,ë0C§«~Rb—šEP–±[myë¨9¿»BUì<GR®¬Öi䶴JŒX¾´Ž%Z÷5eÍA®,¾Ð« £å10DF'öÀf1A׋r˜ýa¾–pþ¡ ±åsfÒÅõ…î­³PªxšÊ2z¨"oçCèÞ3t!lí!Ÿ²ñvme)J ò‡¯ºwúÿJ„"®<3‹Aú‘­óõ±-Áô&¤J3+.ÑÛOâ(ö!½Àl»ÅQÛݬ a,„”vÌ@‘ ð%[ê~ÚØJfáé¼™ÌgXÖ#O¥’Š¥;tĆ|Ñ»² YÿjÜVûÉRþèÉqèáØà÷p*‚xT(ÎeG5Ì÷‡©æ~\ïÆ üîØÍéÏŸz¼ó‹ŸÑi±pÀ¥-´¥ïµÑn- »~@Z²G3™¬)ú8ˆ÷Ëcs¾=Q—ýa¥íoª7¦ƒVy4é¿1u±Ç,é 9|£¢«›…‘L/Gšþ»–þ¨>üÈÖÄõ`j/C qôÆËÆhEã—ê%!['(*ÈNÈZÒÞ)ÆÆŒ{–<& SËѪE¤dþ7ã)¸h¼ÍÇbz‘!¾ôÅ”búvHiœÆû™g'»ïi¸·œ2†ç¥Mœ.@®‘ ÂFë&ŸÐÞ¹¾¿ 5„ 5?ƒ’àŒ@ ì€1ÄR;kû÷¾õdÖJÖö¾qõÏZk”mÛ”Jà_´„JʵÙ5×´ò0¡òÁµ4ã}¨çãUT&ÙÒÕ‡ ^âY;^Âm“$ Jó²Z=WþÊî% ³…ÏO&šš%mNƒXèêÞ×Ñ¢4¸ß8xë2VÞ•Óôa³±aßô h ¶YHgä{G³¦U¡Ó–T€¾19jQ[Ù£EFü¢²”M½‡zT,Ÿæˆü×Z¾Ü6…`^ËmíyùÙ;£ îz隇ž‡ \‹Ø#*oOŠz¼�´kmòø£IT¹j+f«¹M„ÇÚkcÙ×;M_a´xVí€Ò(íìó´§Zï!íVÃÄ©nª7¹®  ÜTÌ`#P,kÕ bŶc¡ôH“DÞ˜n Ù+íêáö2%ÞÑT²^J—”t8h‹¦š´¹4çn(›b²F¦¬è4ˆ/ÀëŠo*¬.¹´HjÊF’Þöê#NXREƒ ÿ +Ñ¥ðX©–JW)›Í)IƒxýÇx“–¬í9q]ªù:³{N¡th†»Ë¼­-/54)'6 Ï+ê8¯h½ÈIÉ ê5¤ŽÁ=°ŠJöt”mÿ[4r•ÔÌØV_´ £“²!’›|P˜Èk>Ú BÓ=þÄÖ‰3—ùá»`ƒI¼Öô<Vå-±ywý¼É¬ü–)àKq ßÿxœ´Ó ªw|ðKþ¼Óô³[håº2E`ûó®Î¦!Ô|°ôx™¿Ú€É“xaÑ™gúÿ²îm«d>ý®®ÐÞÔ½IçÍËÃäU„J”dN>³D‚q ÖzwÝï}M)³zBŽÇÓOF³¾Œ›ø M0ZŽ­¹Ry¢çáñ4ÃpÂïP¿&³š.ð§ %Ÿµ¢¡•Ñx13A/s£ÀûFaZdžƒ"|½ÙüGEgsQæj'ÏË]ÛSGY÷Fõ"ïiUdËF2Zá¨ðG+É2'êâçZ?ƒÕ­¶ta¤Ö)ç͸^´ø”¨Œ†î&¨¸­‘}ö7UBœûn¢Ì(ÒäQOaã¨èR¡O*èæ—ò“Qì k§­iYÅõÑ£ÎBòÔsïÒÈ›ýW¡KÀ@-¢C•vLo»Ñ¤?õ,ÐÆ`7§Ýñð쌲b!à@ùÄÕ»VöNó…®Î¯¡…qìäö ¦Bbü6OX™qÂñ뤂¯ xAÈsM*ÁUÁ@á$?^<…_†@ùb ¯Êv¨«€ØS8Ðßß½œLrks§}ÚÀ£çJ²ڇ ˜´ôºÓ¾JDŽÈcUBc+÷÷^=&×VÎ(‹méÎkp"ÏÞÕÛyùK dÍöáIë7bÇ@w(e¦Òµ×Sº«tCÑo|¡Ò-=<RÆ––tS]“†-í)·Règ€vNR„þF“!‹óÐ#ŽÒ먨¶œ5*e¹Q#ù¤±9Ñ_^ÉË®>†{ë(/ÚI, ¨E5+ëO¢X'b!ÿ¥·U¥Š‚õ¼^qUÚdìb;@BÉ*–C•¸î7݈V¨667ãn?©õݯØ;ÎËšµMisÇ4ÈõJ«X§ïVÌ·—q†”op/ÞÛî¿ K‚‹Êf7ÚR`þ4 ÍÌÆÚ¿Wyô‚¢”Ó”5¾Ò¶apùNzâtw“åaUZß Jú: ²“Eãò´•©è¶1¥Ü|¥á9¼^X‡Æi¦Ã/jý ®|cG4´‡rq7aÕ±*#äü1ÓyYRÿZ^Û¾ÙìþhB·À¨î¸S•­‰åí`½Y·jugM'PòŠófäYo"X„AS@4Yq˜¸ÀJ(7B©r@¾aÈmèñO@ó©sîa©¢=�G' „E(n‰¦¿ò—nvñB¼€ EŒ'{6 lS+úr<´ A-Išô‰Zûò•¯í›}¡¦Hnö´Íae•eÑÄã÷Q¶‰/�³ ôü›¥Šä[ -_Û¡uücáK¯ò|kª©è>v®©ÝŒ—áBY­ETý\RA°^( Y_=ú@5õceãÏÉòˆ¯ß/Èß“BJÒЧ“aêÙ¾ô¸65>+îàÞ2YMË"º}ö&óööTCZ] b_»ÆkJ0ä±þÖ=ÅgïÕHÃùÆóO溢ØgÙ’ &á ÚÌ HOk7jŸNýdî×sT@†M†E0ô¦ªY¹+ZZž”�«ûÉDÉ<‘¾¾[ ‘k‘¹aL% 1Ú¥„x® þf²(Ñáh›ÙN_Ÿïyž«/rÒÖD‹%¶¶]±Èx¾t*dõè¼€¹¾.à¦æ›ÆÒgªŽ^‘M5¢•|{NLMâ…š ë ÓŸH‡µùÈýEúÊ ö”f UëžsÍîÌ|‚yʆAÔÕ+`î2ßE�Ròs”mí‰èJæ× VÀâ—Öq¬J?¦JÀmé­×ßfÿ`ÝœÆÝaI]¹®¾[]§º< eqÛ2¨M*ÓŒµ(°Iù£n¨ý¿ìNòdáÃP‡ï¤ Òw±Å.Èn@YÖixg=n%Eœù î º\Sk.›FM†´٥ɤ–†U” µz¤—{8˜$tE›yÀëºè5£É*NÎ' |Uëné.ßcƒèf¤<ò¤e{À_¾Õ),N”“°¯ ›“;ŒŒäC9É$)ã¬Ë/ÍÀvHƒløÔV[N~t ÃäaîÙu4ü(óçÚL*£ýpô$šYAROÀc=[T.:+Ó±ðÆÊdá=hÉQѯ ÐAݶֶ—öð$f‚m#¬^ýÍͨI Ø=õàéƒÎ†è½6[ó^[ ÄöB¥ÿ˜‘¢0¹›0(Sšt‘†#]®´ÖO \Ƥ6¤s~_ŸÇ kš³±ûéën¨Oo›3§â‹WKÜgɽ:ˆÕ•ZÎ0¸¾«q)´"®M&‰EÇ÷i¨ÿt÷~uÛ*ìÖ4FÚÐá©õ0¦¬[e«ƒÖï'‡Ý¿:¤‰7d+µ=¨ õßÅ‚9][5•eÙÓ5à(ïžé‡M½ø ×¾?åA|\{ùÕQeñ‚i>1ÁÊÉ´½®"¥F²)XQe>ƒi9XŠZ¹+×Iì–SB}Üœv½$‰¶š¨<tRÈlÖ=•©! Æ ·9ï&Ê™é΢ÝÐËô öÎ…‹;éê ¥ÞÑikgW;ì'Eöó§AepèØÄÐGxS†ÊþNV‘T f#VvV=¢„DŽÌû yäë…ý…t˜ãò =œÒ€}A ¨U<Lµ¥qâ€àý\\péñ­Öˆ]ç)äŽÑø“Ù¥Ñín½¾yôjA!¢âôVçiœÚwóì#ÊZfüñ6*}…bZã†>q±Q"‡ˆd/=7Ç°»¸ÅJwWDTP§PB¬<›åK¶‡ }½ñ“ˆ8(ûÁBÌXnðz¯Œnª×t„Ÿq£ó·Ô?3Öò_åîHÁÜ…É“…«vB¢ ò¾ñHB‡^]¹þZgɺ^HgUÑ—ÖZ“È,KÇ]÷©Ùͳ¢ÿZh}íãPI(cävê×£ùtäÞ·pÙ™ßËžf‹†£®±P9œ˜·y$µ |"ó0b|³jxïPG58'×Ë—‚]†˜7®±“nÓ­çyVFéb}˜Ûª,J~LË0 ZénZ[ƒÖUl#”¾9Q„È[zf�QtGÇÓllÑþÖOi¿ —²8l'a…®¯-}`qÅC%4—MXCÈ05à ιuÕáH—c[ŸïM�ž�‰¬&¸Ô )jx䉚“®L#[¸Ö™ß©® ¸Š‡úcºûL%ÃÒ7Í; ƒ líeqÂ:°°KNß\ÊöJ:éÑ•›ŠÏzDCí­öìÆ+ ºz#2²ö Uâ<-`\§þòŽ=Œ›,3æ|UÓ}Î=lPà¯ÀùJû ¬j ™“Áz9áÄk#ƒ!b,uÖ(æ<7v” ô·n—t^ÃTÇ¡ßR‰ÄÙ± Â Ö“r¤r\RET!ê¼Éý]›{Hdn1 Ê|íS#hdìm<¸ÊËØ•Ìó¥çûÑW”ßÕõ-ϪµEŸKÊû3UF=¶�Ë� þþôÚ¨v¶;´ƒ?v#{—kç_ —ýþp!\C_>£yilTºBo*Õ"²`FÜÛƒµ¤¹šÁul·Xa”;§Îa xL"Z±}ÐйÒÿq'«üRN-‡ŒÇçèéØÑcM,BX_töaÆ2òá‹Ï» ½$ü{Ì¢Ngl»¯g3äb"«"0'þÂýîLâi öïóý'V X”•(@ŸèÏ$§Þ©RHÉ…o¿ƒ{+-,säþKdo’ç†Í^àíyÈ) Uœ ®¤”ܼ‚ ƒ»~†¾.“…‹Fª9}¡íÏwÒ°ÈôLƺóðmÎ.ûÆ=[&kÚï óq[Aü©Å*,ºá*8oÏ5´ÙõìÅÇgÔ‡}òûeþ’âÀ¶-ƒjûî&]€ï›EØQ–/¶=ÝF¨bƒl6Úwð\…çS#žÒSÄíäö¬´Àl`f$ºâ!/¤e4´^£å ºÒŒQ5N&ô¨T¿BøÓ¿‹ò8Ý¥Só�fDËh¿3¸Ïõ©¿{•åâð¦ßÓµ¬+rÆÒLІ0Ä^Xq÷€òŠý­Ã¬I8|ZvmÎ.ê¢Æn?úPï¥üH3¾×þøÕKÄ)/Ëgj0:Q;[;ʤ6p´YÓòâ<ƒ&¡§ÿD›dêÓ µh†”ã&V¯ºãõ£™C€ÈÏæµ~íÙXÄœ 0C£«ôyòº"kŒ3ƒ˜<zHx˜æ8øé’!ൟ†ÓÐi‘¿o¼D棞wŠ,í€É¢óùE0‹£ö¦¼p*d}”cX5µÌ(eñ»s¼;v+>|^œÛĹ™å³³Gïâ{rzùh¹¥dà_wL#ŸgMh¾k’—@Õ³ûòø¶¿Ñ„MãªôÅÚ3Úö”A”–;ÌËÖ@Ͼù0_c` a|/—�Ö<ó}Ì£`^§A2uvŽXÁÈ|ž; XV¹½‡²{Eæ{Åcع¥õâìÉ0ã%üß·8Ó¾â4íZ³~xì:|LFÞÅÿéã3Ù¨‚mI`ë>˜²üt”f¸×WÈí/5J<ò'q>%*Sjô7)g×”ç0RlVÌZDªLåtϵÉ÷oŠT‘ÒzköÕµqÝéÑŒÞNÓ­Vµ–€t~6—ÚþçÏá´R ±`:–µÇm)¢ú©’ù¢µÜA òì¼å<ÈxwŠXÇ­£ó“Ê-Žô/°”sÁ¬•.Ô·òæ³0·Gßá7­QX¸ŠŠ™ô=}Ø2¸ÑC L²1Kö2%›{Öôµ_ÌÙfLé»iÓM9¯wöÂЦ·�駲åOEÌ]ÀËT2î@5B?{ã<Ïk³mëÞTèúäÖVÙê¶ñÆ{î« FO‘’N^zOä|£8ÅH¡’uþåÁ¶­})z„eªJiÁô½kLµ}CŽ6nh“1ÝXY¥n°!ºiSÄv" (,N >m;U½ûìfÅNÕë¢Îm„ÝÅ;úŽTÜÚ5W£|ênP\½dƒ˜ñÞ´>’¸´%¤LI·5üÞ=³ôžàx0ü Š0îB·ÍƼrcVwd^ñ½ö/Ý·µð}‘z—[ïØʈ¡K8n×Ö?AÐ&V æNÀM"Òº~ìèø9ø¬XàíéÐ7øÖq³Ü*üñ—\¤—7‘ÆLd‰É¬`ó±ãbÁêÛÞÛáîøuÅbtExª“qpù>EWºžTéž':, ²í ö½£2†;/ÞÓ[mÀ²,-V“½a¨‚l¶—9ãóß9QÕ5³µ¶~sôJ¼—œãÜ`\î€^Š¥®&eNŸˆ‡³1h/î¨Å謉Y3Çz·!¨Of:Ô8‰à­`ÔÑŽ¶î¾Ë‚j¶ÆÞ¸vûnÞ^¼þ —¡eQ ¶—ÒÔö*L¶Ä=äPOãf7±Œi ç±‰ L9á’Lþ#ö5|……±Y3Ãi_‘%¸büyÜ­¨š º›Ò‰³`Bm oly‹°ãïC«õL•jÖ^LÁ<P{Vµ«Q,Ðf tÜ<x#Y£(žà=)ž…‘ÑEÞ­ÐÉásÚ®‚! õÈxÚq�·OìÌ-uú}"68"T­¥ßâê²ïÏoͶ×L>eЋy\Êò;žV¬ºìu$ƒÕWRڠݸ› ˆnYì ÿ{Ðtßw±q˜¸Ì‚(ÎBãæÛk6Ðj©)·²:ºæD§Ì£áÝØ˨ª‹thCXsåÆ]&’ºàÈÖìF'bÆÜ'N› $¾N ʯiÞ¼±áy_8ë97èñŸêm´"õqdºu€÷ŸÚºD–þgÝ]ŽMí¨YÕ<‘¥Ò[ß s+,l”r(Ün/íã›5&¾ ¼=ÄÈ:ÞlcC›ákªâ/÷u1Jç(FrÈ‘öèJé¿? ¢fñd xµE’Óò¶c[.wÔÁè¯Tµï5òçbTGç¹XJ>£ò%ÙÂ¥¹ |, JÛj†}µé«šªe«÷Š'N›½8d{Ou9ÄEæñai; µÐ©3 C=¾¢Æó2Ö㊹–ÈÊCÙÖ Jöºj¸{óªàbâ÷V¸ê€áA|¼®íÖ¶ƒ^s:¨2ŸÁ¹²‰öW±µ³|ˆPYÝIEòƒ ¡xi4ê~þÅÂœY°‡1¡;h‘äH*[&ƽ1ÏŸ6@o`ά¿Ã~¾ô¾ë™Y‡Î×wZ>‰‘9ÙËøÖ¯}#„䦦Ä�ÙöëÂQ‘¸{*Â5iJ÷D#uÍúÝh ò_Ù׊wûî ÐxF]=öFŽ2¥£¡m´Þ\6Ø;¸¦Øϧ)¶•ï±]‰ Ô0òMçÑj1\m'þÜF†º;®N3›¥ûæ· ãÔ;‹;]¼É7'2 &â o u€‘½ñ 0w@1iå2™„î?Ø`tëRKlYŒ®ûÐ O€s°ßg¢D¾Ü´W†cšq7xaE¥Ø‘îÐM—U·ëw‡ $|¨näo]wîÑ& ê6ˆÖqÄÛÎyÊ«È&ç|vkJ£¢Ä&£Çš×bþvV^KÑg0¼FËÈį̂³_“N(ªØžAb€–òlnh©ÈX3lëzOùÙbç‘C´ñô¶I3ž­8yefÄ,ÄfìžN´ø.¯røŠÌG%eÁ@™5|,Fy´ ìÒ9sV°=»¿¦Þ¤ž²?Ó£ö]áÙ´'‰¥ã"[Ú’T®÷rú$óMjé¢ì!~?Ú½ŠªÕ4fKø«$ÈÕ ‘j~Ïê…þhÎ9¶VÝb2ÇÀUh ¨l•ð onÜ™ ?Ž±…\²å;•³%Û¨q2@—04øxâÕbJƒÆ®e.F²e$íÑvªxz¡žƒ*úDžÞ1³gj)S–<ˆ.*æ„�-¶à Ií+gÆÎ ~ž,<8D©ÃF¬¸?Ë ú¶æÊa¥’…(ì$û2=Ë õ¡qOTä™ÏÝLƒþדî&ƒ�ròE§Xº4K¢ÂAnè6—AxTdÏ–² –h0ÀÔÿb.æLá‹JŸøÏ^ÓµŒœWiiÜ[§Ô;z)DÓ'~c3Ê'à$°ë?(j:® g$Â>¼óìîX¶*cMúb-åñck ±äÞëÕdJM÷Ò“*„hA–‚Òšöú;:W‡xK.¶“Åãx Ë×ñf79(þ Öç ÐÔ¬i]]¶œos˜è{Û‹…}âeyïÙ ù0ÏnutÚÑÍ6e(m%Œ¯æ¡ ¾ÒЯ¤’ˆ®rþ£U ýøgäLŸ^ŒÅeI­‘A v5­ÇjQɼ†>.¥P ¿¦Ëò‘X¦®¥Ä¢›«uÏΛ8Áóg™ÒH|ÃÂã'¶©nÒ1öq¶2„X»«‡Z Æ ÅXNO3Ö{:ì‹ÒÌ¥O`BRÖ)æb<ÁGqFÑYF†”Šx$-eØœ<²/ù= ,IÂÈ$0k¨ÌÈ”j*.b 0Œv~¹êw K‰@÷„?ÉÒY9òø¦Â¤š¨®£" zýÒÿÎíÅ"Ôám{„FËÚì¢ñDGÀ¯âm»_�7q«w=û2£flj“ùø<W¡ˆûUÿ<¦‰¢pу¸'Y [ðVņÓ(4?hH¦N-2Îì°;#+ÅšÒ#þk½{#3b_÷Ã-#Ïn[$}vÇ$Šõ§æ0èL½%o ~áE´IÛ'a2m¾--¬"TLþž¥:rþD=©û&,ìtº ’QæOÞÅ\t}“¤È–²Ó 2e£Ó<àÊq©îÓ QF5g,Æß9Eešy*ð°|þª‚¤>;ÌÌØUöFVwëù†ûOöh¨ò…¦8öª·ÏÙ'’t=û$H¿Š;=énú€4 ª~ðò†õâ©™Àô9Çþ]©%Ïrf lOéÌèÌ=}Î鉒Âöòxâ/š£ù+‘’`XŸËbìæDø­  é ÖNo@*ŠOòg ]¾ðœ1Ý‚DyíƉf[:V|ÀºHzź[ºTÁ€l£FÝðÚÓÐÔ£µ½ˆÕãhWPÕÉÝ%§ ø ,] ·üöHÄgí¡&wÃG·€uq//°‘^&²n‹|N⌡¼ÚÙ ÿjM s[Ó´Ø‘$R:Ç #%Íå‡ÿBá*ΖúhÄÇÑádðFÌL/Í4,$fÄ*4Z[ZH.“(¼¹ƒÑ`øD¢Ö÷€œ/ú†Ô™o�E7qƒ`Ýn<- =ܵ¯Û•ˆÿ¢æä‘"ÂÈ?ß)².# °a„5iÑŽp‰(Äžî“`®?_Pº³˜жzÈ5˫ű@Ò‚åèkB�¡çZù‘„¤ª ÙÝLQ¯; ‡ðÙ–u’¼4=ÂùÆ‚«[£cjÀs¯›DQáG ÒT¨Å½ê›aöyâ%oá7uZäµEõmVë\JØö·˜ÄÁ¾ê¥÷E u:(õ|ETYÚ¥¥ÆÓ±÷­Ðø¹=‡z؆]aj™Ý‘ê§ts4g3ôq¨l é©ÝMÓÃAEQùÃXˆVäyPN:ÌGë†þ÷èÇSÞ ýÜ~A›:xÙÛgwP¹×œc’UÉû·“%˜Nv9þ ¡Ê We1·écŽ=ïÅŽv󩥺[j•ég¦w%º&¯ÿòŽìsn ò ùI‡h±a%[ö·cê‹›òT‡Þ2 òÏ­ia8àÔ¼Û¥ý²¡áè±GBÙ¿j«øп]Þè2ϻѰþ°¬Wíå݆Ý+ÜSÕTQK%ø8w´«îèÈpò(™;ð˜ÛÒ)ï¾a^.ET²`ÕÀ£ÖœÃŽ•nÏ÷ÜÙQ }w@ΑRSÝuàýj´•zJGlJYYáacQféÆOv%ƒ:œÅüg%Åàì§d^n&É¥”&¥Ä¦‚®=èΤò›N’Ëødà{#v4² [ECP~~›á}–Qþ‘YW?½\Øþdê¥yèi+S‘²ÚSýðÙ™4/áF4¸úf’xpxg†)äH:ç9º«ePÒIò;Ó ÙÆIØ}Ⅎ]VZÈ”½e™1=Ó|v“{wø4{zm»#ƒ¤ãêï…š@1ƒ’îVK Øø„¶¢JJÊÿA&#¯nt sÀåÉê˜Aã>êt€™˜Qržom;Jʺ‰%múÎØŠBÚĹ1šÏô#¥BÙÈ3åŠBÆ5íŽÇîOÚEVõY„L)ÙŽtkk¥È€+)ú±¢Y®¬½Q¬Bnž‰ÚÅ+mJIÛ(b]LLÃI‹ü,ÅU …_ÿÅÈôÎ Õ:Ä(ÁfØP:[6:ä@ ˆüׯ،õ0 ÁÀ<‘£ ¾+ òÝèXDK7Í‚bmäݧÏâ9ö‹¨îæñž]·0ŠbT¢Ôubèl¶F=Q2Ãî|dœ RÃX­þÙU3Zr5dŽ}¦^+M˜È ]M£p>so‰O÷t¤dŸ’Äö‡£ÐG^Å*LèÒ* {&E0ô9õ¢Á‹6a뵎Ø8ÜÜU:ãØ”Uÿùºƒ“¡c$BÄêA¼m<iK:J¿ÝP™ëïQ5¤sOy DUŠõ1P“—KÒö¬èÅÏÐ÷µµ¤¡/ˆzëÑw³ãÙx!ËÆ@ZšDOŸÝ©«Í *û»Ê#F+^¿Öëðjû*U§*\£:ex(ßn53b;¨S'Ëž ÿûdyŽAãQi²ÌgW2—Þ¹š,ãÌ”QDç‹ŽËAù ƒïûÀjym—ñ»bk„¼åÜ€pØÍV`L„{ßÀâÅ d½Ð÷^@M<Æ>ƒÄ( bVîì£f 5fàIÙGs1?ï@8­æU¤Þ T·åA´žÝ•+Ä°ÚFçîm³“<RË0¹5×Mëû¿õÈã‘‚WM„ͧ'¶é¨`êxhçµÛp›Œ »`Ê,ÊBÛž®‰T¨ˆö†¥Ñ=ŠÝTˆáSÃÖµ™-øÕúß9ñÒØ×Ú CtÜP:ñ>ÚЖOŒ3:#p]yÂáóaõ¢Rþah(C›æ|Ûê¥fÀëQæs°–p’£pÊ<&Hœ¸Àß³Š É% M?beŸ,|=*¯*a°þÐ僉4ß7øØÒqD;@¥öP6™·?²2c].qh€TÉVAV+ô$3 ä…šäk-l?X禅MïTïkG_Xaˆ"£mÑ‹78ÌëG¯ùîu³XÖv:¤Y¾žÏúð=×»^Çe»¾ ÇÓØïºÓKªÂ»ö ‹­ D=¥Â¦ݧÃä Ë.êÂ~˜/«þ4¼n¾jg[ü×B–:¡åó©þíphG!ªþKÑøb!Üß“MÄÓ·•/ç¥6ï…ý{q’HÕ#ñ³¨€ï ¢r“PÐa.Î&7E„˜DåS‡ÇŒRψÅ<ÎÂ|AœG€¥< ^Û¦ƒŽ0joøg:QéþϾïýæ'Zi"ƒ_g’Î*ö©àgqf|úæŽý- ¯°M¿³Y’Âo¬B…lŠÑz×NMÎ-ú=3jøâäÎÚOa«eæ4÷Ù¿u¢Kž¬·Êc¬Á2d y|A;Ò:v Ë“5 WìØ;ß—ÖX–2´¨Y"cšHTÍÞŸ3µØ³¨F@d@Œo2y©šÚþ»ÈÔb®…ºÕÑ*ý§þÞw$)õnë¾±­.0ÏN¡2»•Š òbÚµ2„½g|¹”w§$p†ûI> žc–R‰µ,@Õnè³Óù¦<¾:háé.³}Àáj!­:JƈÕH=ïÌŇçMiéÏSi·Û’Žb7¸�þ¡k{GõÑ‹ƒžaæF›õmvöq•é·­ÙK?-º´tw“DD=M^yȉ;Ú±µãÈÍê÷ ELß ©ùÖPjA¶ãlÁ<B.…‹–G%½Pݹ7L/§�߉¡„ÎþTæÍ=ûÙ~®Œ!{öuV! Û@¡¨ßÖš!BiñJçE%õ̶§seàÍ©o+ K’Fu÷µûÓMFÃc!ñïŠÃ$ضE¶šüelׄ$ÙÖü‡ž¶î«ª )þ€ó˜.ƒ¦€÷Ÿ> £+¼Tz/"L·O®óú"KŠl!ª|^Å åP¶ÅcŒæ À¤ƒçz.ó°gI&‘aí6tvVßVî7掦ãx#={ºzüA Èï¹KÊÓÑl¬f’á÷Ö><ãÍ$-xšLwß<ÎË+…øsDõ°Iq8œÆÝÿ¤«û;{%rŠÍ"ÕNÉL{OmÅQ"+›+¥Œ§ã½øÂüô)aØv £ú:õÐpc؇Й^Ѥðí}fS¶�‹Žn@BÙ4¢G1§´ýDrÛ…–Lšeå¡j½ ·Ÿ.Cw¬° ßNèŠÿÓ_öÏêVÑœ.$Ë:ëqÜ™ eK}œPYõj®6(v¶¥½a_{-¦p´j¢¸€*"·yYG13ßÙ<£ N«b;*¡´¨°ƒä#òð@ù=I…zó›ô¦%]ñ³GÚÏs䙽õ”y®Èž$qæ ƒSÔOhÍï³BéØÌ·ðtô¾_å™5F¬¶}†»öÑ&0ŸŠë—ýÎrÔ&¡ˆCc2Ì<UæÒE2›êã‘ñææýÀUµî;dÕ·;ý7âMM Ýž ¸òy² +övüi¸W£Dù;sÓÒ)°<3²Q§ÕYÁÍÕVeÞT/ë!6R]ËPÀg1r3è«[#Ú\íxÚé$ ôÖü|Ü<sEÖMDzü…5d£+¼EMÝf$™­"3ÄâwÎæ‡"x½7ÿét¬ôtc§Wá·gÂÉsÊøèP5¸[ñÕÚ¥?Ê´e³ÌìSñ‘i\sÉh¼®}„nˆ“…éaHÿaÊýÝ µ±¬æä„ã,¾,éR»ine˜¥ ó‡Í`¯@~cUù ™ßÊ;HoÆ_eÚvʵßnøè­¨Ú¯4a<·YSG×*dú]ãÊ "äsRïøq;⑹´mhm…œrSªå f6å‹XžðKZ¯˜‚¦ùlµdOPÙ7úøý{OlÊš/Ìi©Á)ä|t”¥�Í®7øêÉGþó /9$¸X…uWUùöSÉ?è§õ¦…fÅð¾w~«ƒ ‘í€^兀HôTfJ¨/“Ýr!?œÇžü0«¦N—2H-�Ú ¸9Ï‘`u÷&©•-- 8?-ƕ׵c:Z÷å¬hŒA3eT÷­Ä0A?Þ„Œ²ÈÕìÕÐ6Œ­â@™‰«¨Ïœ™¨ÖáàñK½©Ì8úž[H•+¿ µÌ\«giÅA–¯ ³ÜL2¨†¾kxÒ¬¿òH³ ¸Ò´göÊÚþñ‚v}éá¯ÛI JÜìý ×0RèRʵDû‚=Sÿ•>hç ïþ%}¡ ºÇ†'*ïÞwZ擦UóÏnøÇNžŒ¢0Zð=àoFÛâôQrvjg\9ÞŽõf0*¦‹×Ï/\lmt2Õ‘?  ¢ÇŠHø³S‡n¿éÔ:zFïc~Öt¸oü¦¶óÈx4 3÷V/•ä|SÚ¾Ê/}¬ÛÓx¥â‡-ƒ!»MäßÖu  %ø]-Zêg§Ö<ñ`Hµ)¥‰¬gY”0Éq§|ã‰|w?ÙÏ¥GÊ™kUPjÐþQÅU(#pgð‡ 7?^iZ"5P‹P±‰:°u½6:©Õ2š¼‘Ež_‚­Ì“Ø�‚[eˇ¥j¿ÎV(>¯“ mõHÏQYƒ–}ÜÍÆAf®áœëèŸ ëmw'6êï ­|N‹nÞIˆ›Nº!“¢¨¼ç¯áîªÐo1‚ã»IpC4±Lb[Ö+–ð4}˜?A7¢ 2¾†@VÂÓøÇÅlŠ‚¶(ߨºe å ô@•õûü­‹ÈŸÐ!Xt€øG/áF h!–Ûb¤ ŸÜ3¬2ÿz$Fõ¦´L‘qvcv?·šå>²ºÍ­°nªa¹4ÙM[PJ¥Nq8;jL¡J£cÖ½7ÀÞëŽÄ“ÖD䵊îwɧÊ>b|¾“—«ühtç›°)Ð<¥ü–f%†&ä©Ž›e`?Iáé+Œ);xÁßô¨;‰±Ný^("6Ý4-觭è4Ìdäiwä•6 õÜÕ½†‚Xõ cJƒÐ%5‘Búÿ?êiés¨0nª š¬œXÚ=-ßÞ’R=»Ê§Æ•n6/09Tš%ë£w®/̪ÐmzAí#Ž¼d»ƒ«=ãÕØ[ÁÖ©Û©w9³û;áŒÜu ÉTt-¨N {uäF �;·¯„ÆIa²ûÂtÿÏCÁ" ‰´zUGÐŒç5t&Ý=ÕFöìþäÍ=è±ÖS/u.qú¦¬û¬•ñ°Ú²¢Èý÷Ï’EöÒû#çþcšbhš@ˆ¥GMè½Ùîàpï7ÏÉFqTøR"°æ))¨Þÿ¸ ª¡-ëáûú(LJÒúx®)w†é”™ôœÔkŠ Giò̓46´ÌÞMaFÖNwJg•gví^+#nÎÙäodÄ£ÒUÏ ä­š*(þl]OíÌÀjcY7ŸÆ=OÁ�øVÌÑîQº×÷LbÛ[Ub -`Ž˜úcÅñ—½üGá%«ü,2Œ‚¶§¹éM/úTgçIÙÖÚ~úù)O¨³åÜnØ@¥gr|¯íaS;„ ­Z.æà·à�Šêß cÝÉéÓ(ô-¨Æêèl¬$1 ‘÷(Âuº®—„rùûà «ì˜zõy‚ëà{‘îÔ³SXÙví`æê/jŽeñ¢í–ÁV& ’÷ÆŽé|? «Ùµu)Ä‚Ôñ˜`W„ Ì|ôȈÁPAÉoɬ¸àgec �IÔíq¢ÜwP 8ê0bX}”CÛ<œÖÐ[»=t(nUýƒŠù­ªy–§.X3›xÓg0ëxWÉž‚‰Ž-,•îûšfcVøÝ,ƒr3è  ´l7>�¬®ØoÕI-LÀ8Ë„AÝÓ%Ü|{š=ÇSÛšäÚÞ_À)Gáb$EIÚ <²Æ÷cŸw½¼¯ï†ö/H‚Qâ¤~žôxHJ·$V‰àR«¬§±J£­ p ’ø*>Gò{ ”Pô:N�[étÄ鯃,?éŸ<”þ¨œzœ¨I¿�Tîæ˜E¢ÌÙZ(ßß û¦KK¶BSRØûã`µh‡ùú,í£ã÷®Ó²'Ê$ºè‘â¶÷emÇÃtìVÐF�R\Þô×AIm*ä"±U4¥X“‚¹ÙxÐéÚ‚©W+ë¦xо®>~”új!âí/;(‰y´Y÷硅e_Ý僮^±¬‘¸/Ý“Q¦hJÌwZžóý1FyT›×f‚_ü¬)ZîÍz#¯'^˜kÒ—›·ƒ$òÑhä‡åC«¬Ê,ÊO3B3Š"@Ø+óÉ'šÖÌ)t`˜Ý™jmùx[ªåê.râïjð…1ò´ßÁÎHýþ®ÄÄÿ¼xî?,h}9P•ïRÿX´²ö4EÄûÎzøÖÈq´tÿ  ñL+¥œFSÅžEVzà�s@Öü–‚¥ÃCó†Ë¾k=O±"÷=9cNDî57#sSS -؈–ã÷žÝ$°azÈ-Ð:†*ˆ¶­ã¢,;¿¶ Îb=K“lî?àW¡\ÄÞõ¸ë&_£M<žørý¦lAF…¡'ôs¦Âò¨¼êµNÀ’^¼–žÿôJ9Ö—ñÇÿ‰u™ÅðGÈÅ]qû·VeUœù7›jÝyÔË…è¨e4?A§‘¿€%hÈi~EÓ¸am$~ÍWIéKQ¦èß=$Ë™’ü3;æ9¯c›øß–�q\óžT¥°i­†F›V”Õú½è’YȈ‚4 } ñ¸«‚´×©™õ3„³¸ð—Å^æ÷;½‰7ºGß:ldàmŸ†Öé;¼"°—žw”Øf›Îèš@ª©©?„,hÙ0m×·‡…½><(k#׎â·o€DûÉ �³]…J5]øËÓ­šⱂ`âéø –¥Á¸Íƒjê=öÛú4þÑÌlËj¢úðüÊDUâ-2’ã-åç§k E=të¾›;‘³ ÂX#ÖOsc¸ûÓ7Z!ÇŽnfÜÚ %¼ñ– ›é£ÛprÏ8Œ×"²N—¹qNn¶ôÆù¤K/ÉW”TôÀ2(©;¿IHz¾OR€+¾èpN,,`Ú‡Õêð_X5ŠÅ($)¢àXuõ`I­>ÜÿÑsãæèFñ®³ ëT~( ÙJœ®¼•v>î†+þûš¶E±�£&ÁyÀ"TFO_½è­ˆºçÐõ¤•ä‹ë³ß.zgZk PœÑ³Ztp÷Õ ½^àbÅži²ø¼î?`0 ãÚ¬® ôdi©ÀdhµåÈô‹“(/½Ä:ã`ÌUŽg†9ÿ}Ë‹eÿÒ0‹úúM }_1X/‚PÜÓrº"tñ0ÝŽ­M]t£å¥ÊãªÌ¸üÈÏq�¾Ñ¡³ö`:—ì;x¦ôŸ®^h¡•4àL3ÛbKŸòƒÃÄõ‰ã;zÇ&õµjéÖÃ<%l­·Ú³çvà³W!?¾|$Þ²<[G&ÑÛ?vû¥`Vp×]#Ù{Ö²qê™é1a}}É`åD掖¨*°ÙþØ?¶[ΈÑ++Dßµˆ vGºúÇO7¡¡±vßÇœ£8‰}Hû°€®¯,Z{:  ¿jå9ÿŠ¿Ÿ8œ‘´À†‘6E9(«Wå—ݘyµ¥äÀ(™¡Ý Y,|†z wneªK·@Ù;`µ†¼«•±êº.½é–]¼g¯r›2Ï}‡Ýë*ó‹Z¿ ÈûÈýe›‰… 8fþdR»n”È#ÏL.±¶=Ñõ*zëNŒ-Mî»#b¼ÑÛÔô_Ñ›ýîÐÚ_Ë4Ï‘rPþ Fºô¿\ƒºk½Ü¹Jc_Æ‚¡{öÊÞò¹l†äÅáÌßhÞŽÚ]b©CQüE…g–µ�ûB†~×…ã“’{Ã.¼[£æNàeÑ“4÷ëW(ðÃ.êÞíè`ÈZ:9‰çþóg)m—Ì@–Uœéœ\S݈O³ ¬�Îç“–b¢HuýZG¼Ö"ǶJÏ9múoÛ®‡ ¿$ø×´W)ÛŽh¨õÀp„bü¤KXø"Tfq.eé Ì)S;ó ³îÛüƒèhaŽ\¢å«è?É‚ÚHßáyŠîÓ’ ��И6söÞahÍã"Ô¦‘³^á«ù\PØ8¨4D‹,¯A9Оèh”.²&ç¼s;§.𞇙W3$®x}Þ>ÇòðÝDƒõLÁ$›¬™ zrR$ýÂi¾Š}*½ë0”A:NKì;^èPì»àƒ}’}Å2Ï2Ÿ%McŸR)²ýÔf7:D›7"èDñì¸öhpO¦žÞP™ï4{Ó£2c´lÕ´>¼¦Õ«[KÎS:¶uÈ’tnÓ®ß} Ë‹}|€%.“ÌCpc´ŽA~ôiÑ®HìLÆ«ÔÀ#v ¬×íA­Xµî¶Ø1‚œBi¥²ÚBÃi¶ˆ±Þ*{…áæçÝ8ÖWsEUð˜¢ÏىМ$pæÀ¸îGÜ[!C¢ØHi‹ j¯tmOnCò‰× ¥Ä||µyy3ð‰å+Iff$ýÆjhMã6UOVqÇÜô÷‚5uŒl¦àÐuÚª/S.¬L¼]+æ戂[1ò: R«o‘è×&+<ˆÙÂ{&±sèe¯Üá¤YŽ!˜hCf'âݳÈÀDZ¾äÐ^|IÙMo¦ðh0÷¦ô£´ê/yÉàhší¶ F¾$á‰l\’g^—ƒÊ×¾«‚r{²Dñ<°ÈaÓéÀÒAžæ ‰‹˜ªð[’ð*‚ úöâÒкr®2fì4°¬¦ˆø+Ñj<S ÎÇoçÖ‹)WÁèx0†ˆs+ÉŸÜÝ\MÃx¡½su”o·^c匹1IMä~ˆ*‰mœ&eiO»ïHei$ßg¥h§F5ŠKUöXl¹Ÿ:E¾Ñyˆ|õuÝOÐÙ¬¾•u•#³<å›H.^ï%ó®51^¶bo—¹§ì_8k{öÐe¢-F¥ÑêczÈZ–¾-9]ˆvH² <n–нI|þ� 2yãdraM¯ö·¿÷d~c±ü£¸œ¦A¾V¨Y)ym4’¥ûqè'䛨bê/ým‹àáf ^VÀ¢cìgõYPmvMs°æ¼/Σ¢€KÒ Àöx÷ìð¸TXŒwF•øúñŽ_[¶"-ƒf„¢Ö;0ŽÝ#÷ƒ=o†P÷uú+ýQµ( Tt †o7ZàAK­¶j-kȳҎÚÝѧa%©—ɳfät7 ³ r‘J´ý…,4:Š±gÌzú´6â#³øâöЮë7È‚Ð'ºÐZÃs%}® ¯2ŒOñUl±æ˜[¿”¡ÒžN(8r'¥þzáˆÁw+Ïc’rˆ‰V%Û”UYÌ4ÿU˜‡‹ô¸ó»-m3ìÏ«gmúDŠ‰×ŸÁÄ´V.UÀG"„{²ˆ”þUž$/P°p.9mêJoc7ÓEa'mé\ÊZŒàmS¹¿ScÊÒ+¦òjx²W–N`% ñ»’xáýTï€<ó! ÒbÀe4K)D=óbZÓ³öyIÐ/\�xÁW>Cyû¨^vo2 §‰E$= ¯Ù¯iÖùPa–¾@a.žu`°5&öfzŒxÜ9+á•¢<|~Çñ>L|E%*—†žˆÍ»­ó€Ñ¢‹ç zäH|~`ù2³Õg÷J²*ó§CH ª4È:N˜üò]„w»_;c"ZUýŽ{Uâ‘JW÷ ™kÖgâsª3fK)!±“ÊwZ5sbmb?ïû…,d’Ÿ¬ÓEë "‘G1\AèU ï3ÊkÞÓîu÷XCê0óÏöá×UÕ ¿†«¥c߯-°ö§èœ.0nhpî)‡Î‰Ò¬¸NÛa¾è gS GB.øÍÝ´=ÿïÿ„åÁ8_ßûÝ iQ{Ì©¡ÝV4=vÎF÷bº¿×ѳTì;$0Ž¬³jjúçfòÄ +̲ÿC™ë×÷älÊʇ['¬h„uc&Ùyñ÷óeØœ!è�øßÅ Ò6EGª@fö¾|m<øÌ—”ÂXÅqcýj¸­g/ƒäm•m³\B2©xµd¦_ðÕx&ê«ý¨Lé‰g ™tÑqò20t4ôþ*hî5ðœ*×É €¼©t÷­³vC=ìj«¿Ò_†5ü¼ŸoÌy›ë¾9Ìw~c3T+°V`…)•¬S$ø›æ²î™Œˆ³Ø¾8°¶‰›÷ÇeåiÁNî#…?£:²d+ÐÛöG“þ�űÎS†- ÜôcMU¹õ5T…&ó³¦or“òØ IFÏö*SZ0Øn×ßä´ ³Dð¥-j…>0öË÷sƒw'M4}ŸTÊœKb`ý3­.½Ë«ÀðD^®ÉÕo¡1ÖÂhxÐjìbÀèôp#éÒMÖ๠MdšŠŠ¤<ñÀ•e³}tÝ£wô߃è‡FÎaîü©ÊÜ?ŒÖm:–!õ0ýá xœ6TBÔFµßaùÔ¡œ™žhÛ«™Ïà¹,;™1)éÐ1«ïµ6OR- åµ=¥fõ¤r)! Ș̮‡ƒ0 _h~ežã Ÿ¿{ZîÅFßMöúBGö³öúó!Pœ™sB—!<+Š Ü4žº eåN­ ΞÝP›±1Z>;œöÌp¤pcv@ëØÚµEK_Y¯<rü-ì;_ècFWG°qÙzF›Æ¤VGBX²tK×ú\QYùÈ­0’y"ò F¨/“P*Lº}:¾m9wé“÷Úd‘Ê_Û—GÛÃ7<‘†³¹ÑeÂt>,y™ÖÑÁ°OÔpCašãt-—„>» YΑî@iml㤬yŠ@oæↄýðkTí%4AÓ"›ëì" $+™|›`úØųWî^9àWÛÜdý÷ÜÒñÐâ<L‚Б8¦êï?«ÀkþI)eÕl«=«"U=–us8[Ã¥_̬"«d[("aŽiÁ^ßú²‚7Š¢]hÙ˜Ÿ ù~¼[šy º¼ã>Ê‚´99H�ÈÉ\™)U¼fä…Ù#H—sK«ØtûÄã%•&™kh#æ"æâ ýÒ®såMtlÖ¯rÅ+ç”Vâ4bkºÓàyETs)~cLû®T¬~sø†ë§Ê D¬{·¹ôvéÝã„_mß©ošÑ Æíûœ¥Uz¹ ©Û¶› EÇíD›XÜ{… Zà‰‹àÜæTV)»’³8ùb÷,/Úy2Ž´ö»-ÄõìG0Oè–ß”7þèÁË󚊛ùèû­!}ðµ·æNtôñ<v”4êl1K&GÓ—Žo?”œÄ|1@)<F¥™6Ìn?©.÷¯º¿~úÇó1xVãÉeg¸…»ÌI=­á5OüZR�;u·òA»ô¥Ô—N(+ÎõÄ{**÷"Næ‰4õÚÁž®÷6Áé(”E×lâœÏI¥»Võ¦ ÓUï:ÊdiÐ’`³2zòš´i.+tCÅóm¨‡yIObŸ§å«e‰&Ãø±ö†¬­ÇávU?#Ú†œÌÐG‹à=Ýy”ª±'{ɵ2"Ãßye¨³sTLa±Í§Ù‰ÔiéPh¥¹žß¬?ñª¹gW§”œ‰¶:óýjº>ç?RZZ;rtíCª¼Ðñ¼†Wsøö­u#¯ûá4¿‰©Ão¤eb'‰qoS±tã4LL”™êÕ‡AWš?éÆb¯SÏð‡õ�š)e p3Œ€_“*LÿmVnVžˆ‰8š…ƒî\0 ¸˜ñŒT„ &] DZs¤dsbã<gF{¿ÐtðÛKl—ÂN¡ÉøǬ1 )ø¤Œcqïç‘ÜBóŸ[0”ÂlAi…Á”müq"ÍÍL“aB‰v©ñ`p×ù²:`J®w¼ËÄ—–Å ü�"ºut[ÿYή^Ev'ÎÏ<4Ì º{çÕD!@n0óŒ¸Ë/iv†ô"R¦é®Fʨ¼0ý«Bì,wßTÙðì¶æúJï *[kÊQ²=Á~ÁÎÉ1›Ü(lË€’½MéDù’Záo�q…¥ëÂQµƒ$Å8@„§fÚ�K² cóýø^'.÷¬JRv©úLƒbÒê4¤ ÖöÑ*7>”p´ú¥Ò‘HEÿ¢³ò4·©Ñ|°ÂÏêÖ¶MÀ¸Tî€Ú'ƒî4rƒäûŒ$WSOÍüèüç¢óۉͦGôö™~ÜÒj¶”ƒ'ÃŪåãȃ–”*)ƘM»‘Aœk*:!ìƒ&Hù'/Úƒ*T¦^ Ê-Ñf›ÕVd9a {ö_¸‚‰:Aª®DVÎDõë•ç ã:Aý7ËKºÞùóô£$5¢ï©ìBaëëÇκf¡%¤‡‹/àNÃöäµy/Š¦îÉVÖãÐÝÓ­ô¹ß±€cŒ¡cfºäCÛùìNËÓ±éPsRuZ>Vâº-@ «”’š¦ä„:5ÜêX87<w}í_ËÅ™g”±­ÒWBécÓºrr÷u1ã}Ö1Ûk>ºÝqã–ǽrþy\•æÎŽ€µ½`+šL'_J“VÌüØT4tŽs†O©tÅ ÀYVLã°„{ˆð~~…:f4åŽËe ôôε‚™L²$³%±éùèaAÚáÒbÜà4=YcžÂ˜¹0fˆ'3†?:g×[鮋Wù‡õÛˆóâJ÷0èxôÄŠº˜ù¸/‚ óÒ¯ÃâBÜC{‹Œ Yì e£}ëŸ=Dݼ91²¸Çå&ag 71Çów÷¶šÃ†!mÝf7ÝÝûÅÂj+¤Ž.C£é6e:Ã|Úÿ—"§Ë­#ºZt•å³gGùM7&LÜŠf,<\‘*YÆ¡mÆÈ]EwDØå¯uã8õu˜(ùü˜S_ZþÇnï‹Í[¥I®^¾h·Æ\ÜE Ê¥ŒpT»ÏR1Â%#ÅGZ¾WglW)Ÿum±”›n: Mœ…‡a Oœ`£ðó§ø¼È¶?­0UþlÐ+ª<±Q!ðÚL‘+3c 2Á ¬Qä<ý9&ÄŸT|U„?Mü ƒIàæ²÷­›Ù®FÓÓý0‹»åýÍWá ÕBÊ‚3IÏ:ÞÂ`‹Ã·ÕºŒHËUóÓ?á°/‘à!zUë8†à 5ÿ®³†(#[ŠRç|F2¥ÓÆ(1…›=(K×troŸÜÙ× –쇳§¶…^«É çÎÓã'32�œk"Úî?Ò$(»ÚAåCKw¿0çùAFÂ:•&Y9ö1ÊmÛP®õðÞ`¶eXz®ÛNdw,w#k臬qOË©0s)i-lè"(þ‚5Üº× vDÎÞ©æ8×€§nõ’"}_GíLQYGßýßîÃù¡½s^.ÌÙP$qj;õg·jR,lx®•Öo°7¶+Æ>ºã–>{ÚXp}öšIßÎÚÄ¥N¯°t±E« í’ ²æ8èñ ­Hh�¬Îô‡Æ°¯(•ò$>¡­ÑkÜ›¢ÑYöTøöÔíä³ç~×yæ#¤qC[PükãËØÞxƒ‘®ÑÓg~<ïtJY?àeÌ]¶àW!w”’¬uZeh Ä ïžjõt:løn.ì lÁ—¿3š/²*ó(¾”>(ý¯·¶J·œ6º dÒÁwcËûO­Uj’G‰Gï.EÊ$ÿMƒÆeôn¸þ‚†I\z;¬Tžp9ž<¯Xaú q;'1ïüÓ˜¤ôk¢\ q** ¬� ÅÏSç4h±:ªœû�±ÌK?g{€ùó𾔫f™;ØÖ‚ÍÑÇ›1q¡‰84Ÿdÿhzw‚.<–ævc1€2P¾ÿ€$­\¿µ`Êàž²¥®s>\P5Gª¬” #ñ¢t†Ã0U HæÙïŽG<~>Ùê¡Kc™ç/£ÿTŽ¾Žˆ–‰ßv<zLªÅ{ îxÑlÛe‡&ÙEól–u‚ ïMI¡óô~vG«!ý €Ç²âW ÊÚ™êØA™e¬!©f^ÌÇY«v!ýd•„Æu&,MRN¡? ÖÕ0‰&‡�¬Ÿ Ü™§öWËÀIf&»˜G ½6³ªÛp{„ÌcGÈŽöF…ýÎ9].daéÍöÀ©¿;È7}íi’¢Ó ºÇN€/C<¢,w˜WøF:VªZq51;w•‹@¶AëÒZöÙ-M=Ê 7Cg©±UCï”×ßê×ÀTÕ~ÍUþì§# ÐJ2Îú-¬©R¨ŠuSÚ¤\C³°£§¡1]8Ê@P¯ÝØÚnº¶—ôûzúT.´tcÑÏÌŽv@»ù]ÓÐÖb <ù+M'Ïk.×È‰Í ?|ƒ‰«}d Lp ÌÇg¦¸AQí$‹>"­¢™vÈ 7x’8Ê]�åã½ÃLÜâÅ#H4‡3eÁ&é1ÞæAA¤yaìÙCü:vô‰ac®õL¥NmiI(2€¿´ññ Ã5¥m¥øLÏèÊ|„q dí[‡ðcª¯ »BZd—ܪ§è ñ=[(O hþÌ‚jؘl&lFb³ä^÷Þ¸´ÓÓo²]õ·³¼Êb;d }9ÐF˾g³2#)œs*ŠšÇäžýÕ@ÅÉ£È sM‘»;y nªÄNܪ±”P÷ö‡Ãè3rÜÈ*3#ãžÒ‹•…ãíæp üø¢<¨ñ°góøØ®qe¡ÉN› \ÐeÒ¾•Ð@mÍG©‚Ì=ï;F[ ¡ù„é?ë[Ý9‹„&Pˆ)YIVûyv%dM‹I Ÿ­©‡gï|óÞŒ,*¯¦LmWP*4Ú™ p¹Ö×Ȭ\*¯X—Òà:ÖÓv9ÖO²²RM²ÐÌmS4Í:Ïú y+(G-èôuëƳ/NnóÐ12e-Ñ‘‰úfpÕ(û:©³‘§Né~󴆊¨úðŒ@9×ØœèkÍ¥ÇóDOѶßY›_×o§4þ¼ÆJ;Ee¸ô«]¼`¯£%êQÍg:ÕحʆÒûOÝÝ}¨£ëi›¥ïµÙî ˜B»†Î"žü�B/Æ6¬•rybïÙ(J \Q6ZÅlgÎD%‹õ5 ïf·Ùìôýà•tÈŽ¬1¹b+Aù€6axº¸v¨p½Õcé4mñ|Éï›Î-ÛX…‡f+hEV÷€ 1GÊkœ*ÁkŠA¡of 'ÈʬjAÁã‚Þcõ&ík,Q¶ÏÀ¶NHjU�!r:õ”§YLT´‰éÈc§3³ý$Ö!ð`s›w¤¬]>öòUä9‰•æÏôTÜ„µâÕ«Ù\T²'ÅF!b¸mBŸ�ÝFxª>r—Í<Æ ;yª‹„ÂÆ׳¤‚ò@!:[-ðÁù¶eTæòÕ³/æ)EEÜS µÚ 5X7[0\鿵ƒˆzŠñÝŒîu)¯­%§mN‘ÃÖÉ…Ú£›Mw—3m#ñpOé!ɼûÎt¤f¢º$Þl|ôö°:ôØnðÂf¿²XšfÿQ þÞ­æÓ$þUÝe˜$4À–Ú(Íxà6{Þ>ýGÛD±f\eçt÷éÁ< «:¿&ÎW}½ÒÑõ7…¶U0CÓ×>|.ý½ö°Ûú¼ µ5‡0ËˤSÑá^žØT/¹–8IŠ þ¬Ýw�÷­¦÷ÆF=‰Ìš>®)e7œ7ï©QÂs.�´ÈÛ¡8Þ¤ D’ÇtÆØ{÷‰÷ôVý$©ªØ¢ ‚~¤A²^k…H¼¢ðJÒˆÏ5ÛÊ~‡É²:+ü—øUCCI†©;ôTõk è •ƃaj]?²ïP•9תȚ¼ Âní5z¤‹cÛßœáèãC9/cM&Íž„ë4ÈÜe) Ñ_€Mêã±ï 9Ž+yï©ÅŒJ£“Ú˜À¾[·Iö©/ÖÉК(ã=¸ûŸ<úOž-Ž#¸ÒÓJIZUÚFdrö‹¸¥(.òÌñ£¡¥PCÆtÖr×ÃÜos1š†BŸh~ðˆïÒ09~ìOÛ/.Ö LqßýÓyv4ñHZüªüÜùÂ×+sÒѾ¼í4=°*—¤Š¢§0ÚµNe¹dè‚þ²New˜¯M5ã0ñ¡ŠD€ûÚ?‘ö®n­ÙÛôõkøÏ‘»pu³0õ},x�9Aü³>óIOY{xcA }ƒ]=FT+yÞ‰l½Õ× ½™F6TV‹F™?iÓ$±‡³åF⸇Ðìéâ¤Qø>C´\„5¬?ùk¦åQìœ1†ƒÐ}¤õÆ䉂ÜÌ›È^u?ñazýx)ÂÐ7®¯þ À£øØ@uWTö,~ÊaxHVeéÐ7j”scmõØÈÇêkG|yóÛ{€:¾L!îßDgÈðǤ}à¯ÐŽw¦;ö J©”º �Ù±jCIjº@ðÜÕŠOÿ<¡úþUåQy $v½ž mã<"-êFæ<Z¶úˆ°ž˜8&"”Bª?ëÍÂx Úænœñƒ…Iå™·vÕZzytì¼®d–9Q¡w1?¯y@­Kœñ+˜I8è<.FehÀ§Ebíé×w­´¥¯F„Yæ nÂ]šosížœ ¦WòÑÏ|ožúgK£"7‰Îí3)ä“ø3b¿ñiàZÛf@ˆ?¤>®·:àÑBœna‡b´¶"³!Ô‘ýCßP1Àór]{þ•Nxî°ösß™.Ä„ŠîÂ4XÒþŽÎ7†ÉOT¹@pf QsaÅÛqÇseÛ…Æ­‚;£Ð Èìe• ÔÄ´asûú%¸WRúêÏtxÑ=ÿ¼Xþz°2›%Ãå¥èß˱Íá’ˆÞõ�‰«œj–Ýî’$*Mº=dÙíóÂåæ/Ýÿ­éŠÙé<6 §Ù÷Ÿ«Q«X<ÀkÖVŠ_¬b¾4U™y×:gÔñâAy&졯gt˜W{‰ŠAGLÝ»)‚¨WÔ §muU¶S¡U¿CKRqéÖ«êÖò€M3? èè$ ëO¥p7¤2p¶ª"º±D‘ônWZ^W/#×JµŠU3äÿ‹ÑŠk`n}L_àÒvÎÝ*ÿàþcò¥ P8–ˆð5ä³ÅÌ“GÊ=ºÁ›<RÖ1ø ÓÐ]ZSÿj éöÙƉBðüYÉV»[Jbµc~è…ÀbŒ`HN¿:S+øóD$oö°@6&”„AÚë÷éL™r(¾Æç?ÄéÇièÁ8ÐÇPtîÔcFÛçÝþ¤½m�iý6Àr¼Ô?²ïh“÷:·Fªéž6ûZäZmà{‚4v†c’–(9‚°Ÿ½jÏ©¾£ÌrËÚ ÿª±”˜aŠ{Ų”fŠÊt/šÁ9ÿaûãÄ2Ç-‚yM ®$oŒÓ@…^ÂZ}xq»áûœDSæ¹án…íxåÜ.ž‰¹Áé™ÙøÏæqä.·-TÜ:SU1{6·ÛC? 2ØžZð¶%ØAäÚ¨¦^‘„òÐ3ô0>:Í® ÛÚÊ9R€ÍOn¼§H(ÍTI…?ËÔaü˜ÍAõo$ŸƒÓ[[26€nü‚·ã¸ÎÅåÈ<¨Ãy›)çq¦b.ÙUÉ“›;ïÊ~yï•Å‹s†]袿۾* …EIÍ Öö/œò°dFÁ/ÉôDV,U §4 ’ië¼79pb³ KeÁÇ/–tÍ<µ6×8’)bCZú¨CÔ+º-l‰Î£Ä¢ú¡öxžÂS±Ð,[Ô !gÆTØŽ20vÐv¤*yŽ}lºï»Ù­g™1 ­Â"«‘Ÿ 8Ê= OI‰’ÄÝ|nÑö°w…AŠñ§»}½¦OD—ì²^_èC6ô• ØĘ�Z¸r5/|QímL €–ïÊU*Š#s—Æïõ´nMª‚+fÊ£jÀj_±¹²Ö¢Q;¨{lwu¤2X¨ËbfÌÆE·õQæ§J´\Ç ÊÅÔ9JÀp.¹²oÜúŸXÚpŽ^áAN0Wïv§É5%V=K“ëòÐßû >Dº^"e_[X¼ÛO‹¢s…¾^§;™Wõá<b¨(˜T7h‰›pšdEæ´úÁ�ê3*‰ÚÑ & ¿àDóèVrÓ‹¡^ ¤›3ewôRUèÔ"¯¢ ÐX=›¼!øP7Ï—É’Ï» ®k¶´Zaæå«®ÝÀ%ãÊOMèxi&úìÑh…Ú™8»·RŒÎþ™NÇnüg_›`ù›Ÿôˆ2£-Á’Ð<g\§T®¿7N#g¾P²Þ[ÇL¹u{·»3+ûn/ã›ü?¼ôd„HJYö%-Ù{ížílÝ~Köä"î7½õÔ´«ÙÎ2„‹Úv6€ÏÒáõ«YèÛ'÷±UIê´- äÌíµ´!Ö¦-<1·VÅ~ öª'GefË{úÜéFKµ ƒxI¿!RüZ›$½RÅÊÔTÉ[Õ¯ ¬8WU·G*.ΫNÇqé+öƒŠAÅæ¹UgÜ„O…ó<ÚÁÌKâ>QT-œª)xn)Ƶk7üSiu>1SïzÌú/<x4DÊ2( ùk>ÇA~´óÈškqŒf€4V_#ð%w5ÊÈ0öÝþ –G7Ä …Žÿí$6‹B/¸EžÒÅYw¶ ILwþ\_äJQ2]ù<Çf©O;‚ Ä1…Ž¦rÓœqÝýÂŽ–&#C¹:ï±/°è×uçý9PbP›MQ²=œkU¥@ì(ŒD×'·‘ÙÂH=Fú�µôwo‚Ñ£+Q·ëÚxhÔTÝ{Ïž&Ñ‚<ˆ°Mk(ú®˜±Y'%¤ƒ½ÈkŠRųhm°ÚWTtL΋`ª¿m'lOÇ"ßJÿÁ¢×}nLƦ/Ü+d·ÜÈ´ŽLri®¬ßçži ÇŒ–mjJú¸LÆ)ÄI»Þ®iäœÉ¹±­áJ»Ö£3"Oí�©ƒ$ÍØ=¦ùZé5iy@—¾`‘;w˜X¨ kYóvÑ@xÜ'¨œ=€à[y85ÜP)ƒÂ¨é0\­ kúGœõÂ9÷wçäNTEnß1%r<ôˆ“¢(^P3JÓ+KcÖw Get£Y#öÈÚ ¬ÑØú­¢ŸXLqúÖ°Å‚ZtÑn< UULÚMbÃ)£}‰ó/5Q£ÄŸàdì�dªMô ÐD…8‘ ÇñmŽEèF_ô!ò*¼Ôø£%›ñò±çÌ‘é—Á•p¼ô±¿øüöÖ 0-ÃÁ ›]-Ä1Õ\íÆÕi²íòÅyË”gb÷ˆ Ijò¶ÉX­³ jŽ¦›™eùÛ?oÙW8¥‹;+Â>r¿×ë›GºL*Êhƒg3%AÒh¤¼Q©ø$þ^ÌÅf$Zñ�#ëmmŸ9¿Èc¯NÐÅÎ>eèf©óÕÕlpyõÒ J_0Î+>]ŠÉš¨EÙõ8ù·'Lle Ùc_lÛúcÉM´~¸KvWSçwÒèyåx>sºï$J«_ÇG&”e:×Ì8m®ÖäìJ‘¸Xh Ë)÷·>í+€AV:º…8ì‰~°ì$à¶y<ý4Š(ô¤ó#¸ƒ %Ë4‹þ°.œSÐåÃ}²Š¹±Ì¡¤Ê¨“­ 2Fx˜ŠZͯJ¢› )*ÝX^ÜqÅ]ÕŽ QfÖýŠŠWàîí±ö he `I<j^ÄN#ÜÃý î�ðœ+Ž^ÄOÅz7ÄÂŒ®Ûy¤£ k<WJ‡@„v$Níß{f‹úÄóÓª° Æ -£¢m-ÆZµrF슮ÔavÚ Œê´¢¸zéqqíÅoû‚®‰®£Œí±;$jƨܼ ¥o>p£@Ba‡%ÄeË*r [%õÅî£Ra%ÝÇŠþÁ ÷Qå)«Êæ’Ê/DiÙ¼C©bz“£Þôé»oœ˜Š¼z)MÅ/œÐiƒ(퇩/œ¿mWo<ý°9ÐyžÅ‹ü°Y¹·ê&Û*‹(ÙË0„4ö³…Nê þ®;'‚üEAáTk¾lŒõÑo~qí™$O¼PUAEV  QhÍ=~_T¹JH¹CG'Ôüéʶõ¤\7÷¾;’|ñw×7‹­ʘ(8Oô÷˜H ~Uÿå÷rĉ¼°õ‚§«ÖQæï¢P¶=¼låI¨Ò`À’ç‘á#oàŒ£0b‘xH¡ªz™”܃Ü�†µm4<Ö‡O,û+4r³Ã™ÖàûÑtEÆnÝ?¡â)>;4¢K”Åy�Âß`7²,ô€ –¡é8˜Ì1Ÿ:ˆ6_Žc[âÐ'b$úFhåFóÄc#ŠÛ"OGï'´"QdÜè3Ú/†ÐAßËKí׳ÿz'Í*_o…îÑîÓeüTY’¾¦Ðe2ÜüÙËç±ã^7Ecè0vT$˜¹ºÚãf¡D¡¼ÛÐ_('KÉíaãjŠ»~ü $æ¶3$y×ÐAqt˜TŽtÚAÀ_ï>+nš!<Hùä[¤ÐmÅÓà=K^ÿYÒ'^Š?Š*¤míÎc¯À®;ö.?´n µ”˜…´ZÓS6ïJš½%h+žúÆ͉Çn]Sšs}õ=ŠãI‘èA;¤û½Ö–Elì¡øÄǤL¦ÃXõ‡#ÆS7÷õùί(cðRž§O”]Ž6qG‹Vé•ÉÐÏMU9š—–GŠQ¡¥Ëtã<Ða’ÎYJE+ž#9¹€W–¨;É£¬”Q‘•|DùHŸá¸3ûɇXü�·ˆ•‰Â˜ügk(H‡úiÜÔnF¸: C½Þ¸‡Ývb·þ¨ÇåIæÏŽB*ŠûwOÚFZƒü6ªQôT«¨²ŒÕÚô ˜ê¤”÷SÛM:«•œõéÞλYô.=¸å @Ç#�¸ Æö Yʲ!<ÿ6p\”ܘ”L1c³Çå¤3€Roje¬7|»îmÍ|/ÖË;võ‡÷l1zNÓ‚ž´ƒÓí·—H÷ömy]òUÙ×lZîFÛ•‚sOž4ïjpÀj¯Œa® mZÓ/›j* .¯pÔkÔ´ˆ ñ,Û?¶GÌ~+ÃÜ{BÿÿÎy°Šñ ø0±Ì;]¿YX1F/=úyVý§HÜÃÎh¬‘âtCñ]˜K8¾ B™Æ0_FežÛÕÅÖOì4R˜VfAeÃÛ¡× BëÄÈ8 ‘ÀuCR!×Go˪L™Å>C¼À±’É ùÄt¬5YJÂÄ¿à~ãO>’v|<Yª¼ú˜cv»M‚äóÛa|ä£ë«à‹7§ýþð7*2¿±¸™ÄûpO­hG&ƒ0<p>Ô\¹µ sJüä„܇¨Ÿ‰Èuô1œ™”:ŠJmU·­çòûs±G Nã!D±$–Ær”¢·’EÓ€gÑúþL°ÅO=ÌGd§eI×½²;«úZ!îâ]¸£öÍ¡Á€ìÞî…"c™š¦[ŠÛ|þÚ÷)òT#Ø mº�ütñȾ²ŽLa1Ç°ÂþÔâsŽÎv<˜‚Ð{zȳÔè¶MCÖ?Ì Ý}G9À�jFø:0þ}‡·Ôo­'¬³qFk½gYÛ»f±—hÊb¤3z#mˆçÑ:ËÃ…Äs%?ùVÇqR]ié¨(wv|Õë$öÈXGÛ-´¶­ä9Àö¶YªðëíAQÃý®£sÈlÑŽ!+øvvϦeæ [Ñ^j{¸VZl%iÃP¼`²S8ȽÕ'Su<7ÔŽò,óÀC1*&Ú„åZ„…hAEK'ÿóu#îаô˜.Âl\íiC·'ÿÔ€wÏ#ç4|á÷FÛ=µ³?‹ôÈŒD;Ó9Ó«N„XýŒƒå´êºÕ¸ØûÝÄâÄÖœ‘͈[ÍbÛçöP°-ÅåÖ9ÑÙ BŽös± Z#ozû›±n‡ƒYEÇÃù"’öP’4Ü–ÜžJ—2.šö Sê)§‚½S‹ ³}´ž‰£Û³¸Ì ¶jáÐ;ˆ›I ¸¹ÍЫ6,˜Báoi jI0ê<…fNü©-­’âáËŒØþeåèð}…1-Þ~ÇA9÷Š·€àa§PxK6©É+pª…Ø<ðxj<9˜ ˆÂ‡³m¥ý ÁÄ×a‘ÁÕE†VCÔ5æÏ6¼ý(žG ·5 ÿÉO:…š,p¬ÿhúcT Ð;ꀿ3S÷1)À(Ö7uQ ÐÃê­0sòNßv6‹Ý¢Eƒ»\„ §¤ä<ôÍê速¨~*ÎßÎpe_“J8M]Í3y¸'m•)´5‹þT£Wq¶¤û òÁÎœZÿCŸ€«›_¬/´ž–åkáËXìƒÚgAø®0NLëë ?þià6dÝ°<Ù ÝB}„”BiÐÀ"0~m® ín¢B;N®mY½tëõö¼"‘»ž({J´Ó¡õ Q½ Ž×A§ ýÏ}90_†7^œÇ*ažŸÖz¿k9�ØÓDXÏ—}'‚P¯*—G‘‡{ª8{¥k«-mºóR…­2*ŸÓË­À4wfAb4ÙXŒ²u—=ï¹…*äæ>†6ñÁbhuƒ°©}êm›%G[?7Ê¢Ø×:å‹2ô!õŽ¯ÄEGh±ÂîZ˜:ˆyFÍñÝÁ‰äÈ ôæðMñ쀛ìþصj*ä=]³Žû½ÄxŽ±¼Â>¦à9N ‡Ž½ë¡ãT†~sâ1WCÞhI�ug ¢Ðã܉‘ê/–-‘PËM…Å{’®uPöš 6'5c¶8]ª!O〠*ÍÔ‰#›_•LwR›•  4Ñ­w-´éYï©«9Ó?t¸0¢™ˆ•NåµUÏúá5ë1øCPöœhQ…ï£ÇÇNfé~F¨°Ôêó¾,»â䯾 WïòuHEú¶þþ+–®ƒƒV¬¢ºÎ‚¼ù¡ÄXÎÀðuè,tä·’­nª#ªŠ”H¬Á(ã²5<ÝÌßû=¹›Ï#L½!>=+–®…’Ï•å´zÓ‰rƒ]ÛŽhQ™³•/¦ùoïô-ŠÌs®¥%vŠ ;~+DE$ù6“å éèçy‡kôLÈWKœ¨SÉžŽ†n þ¸e›¯©Üêá«»¼í&©q®^q²y<ì'óšDéÂ䔊¸Ô'ËöƒÏRO׈U(Ê¿ GÌ_úԬΪ…(>üCI—›ˆålö ·ûÆ]ìÌMªrŒÌt©iQðSÓê¶è“«ü©0rŸ“õ4 ]ÿÑ1׃k5£Îñ£HGûs›È€K‹qöXª;;˜}rü3‚&F×+XõçK»àf̹jèó¦—Ù× äÕ²p£ô;§`Ï—BÔ¨¨ì)‚ª¿xq„K>ïÌ-éñ²Ú)£k›¢OkMtYÎT‚(£R!Ë·OîCš£$3]œÜÌ‘/X´3:’\e4HO™…Á¦Ö5ȶZÞ×ÃÉDÀ`kºgëwƒýã‘Ò¹,‚a¨9’âûR úXtˉ¢&&­¦ë‰†èä•êã>±$›ÛÝlèaw.lšùÖdå¥MJT_íP´íÀ{ª9Õ±J@R#k¥œ,ÀoÀT·Eƒ?ߦ‘¢Ç^78KTp/b½mJ}7Øé{ç¶�èÔ®BA߉àÇ/VÔ/Q'ç8(>1Ôîje !ò ûÿγû£Õ7°=<ÆÝÎGë‚ � û rë{Q°c€ž™…&ç%t!Ñq¯ùýS¥\jG36£ºžTàÁÍäëýÚzÊ? nS0€‹D0uÑBΪhQÆ”ÁúºSkP>™eŠmÁ]FÎqÊ'—dÜ%u—ßÞSóÈ=tÆPðMÄY°ì㾆%åʊܧø5åÖôQW¸½züº¿ñø¯]Eýˆ«ÿ:Í‚Ê2ãÀŽ1|ü9 u>Ê“U7vín³C„uO}ŸXŒmÇ2ˆí}Æ”«g)E¹Íhlé#Œ[5ËWž$·4~éÍè^´»…5ÏßÙ»¿Ã7¤ÖÙ,3Ó”Õšj¼=Y€CÁÐÉg€)ýa…õêEù’%=O9]ô³G·ð½™dê-IÃÔݦ®¥÷“œŠ%!gïþ’‚¹·s¹ÅCUlÙotÒˆX~¡¥³§#ò:}Kº6}7ß³×Ñ YÒR õèTµUU�"pÛ5V=öXZœ:9WnsÇ<gÕÛI¡^‹hÿ¨ó‚}\ªXèý‹E\& úTõ”»—„"€ÇÆÀª^dT_›ÓŸ?5:ÅhœÑŸ[`òîþ’Qæ™g— Ç~{œ ôORÀ¬6±þ0Méêž=æÇ& #Å´}òO{&šºæç. x›N}Ìç"Hí€&«â]ìÕù>R6lÎ'÷ìñÐ*ÝpÉeNù 8{ëµc‹7Ý—Òˆ/l$žŽuÏÉ8pã;¸š=;è´dù!ºA9å+jvšåj8ˆï]µôdr-$ìö7ψ;U¼¨Ï#Ô®IƒEX†nÝZQQö¸/c½2:!Íåa!f FE»…î̧½á{þöT(êáî!½§Kz‡‡?P8ß4ÐB²Õk‹—ðpÚ+Uä±F–m®„ÆÀõ<‚ù;:?Š#÷u§7IäNG+q7Áßsxßz=ÁÀD­QR•Xj¶ž:Uy2¦÷d)÷>kLÅzMÏѾWEc+æƒoÙýѤ3òÿbÊN':šÞßm'ΘŠ¼uýîO‰¾qí`^ŽÑ 7OœÁÊÂ’Xë§Ñ£Ô®§ÞÆÜeò´¥m¸Z(:e¶éÍñPñFù>È’ 0Ÿrõ­Ù­Ä<xPà,ôM9ÑÒ©‚²}÷X<gÚTÀ.jÍwïXxp@¤w–÷zC uYkˆ-èëÔ3åÏöÌyQ;·Z rÂ88·ÈÒ;m±e`LTt†# ÌëÇÖz‘¸$‹{Ã9áF‘¥e™à´¦DN¶y5¥ôäyåþ‡Þ:7%â©Çºz¥@ͯ!ç™ê‰ˆI”°+pØ÷IBå™5Ò}M±Ÿ€3»ÐGÑ-Z÷[O\ìˆ@OŸÆ p˜Üfž€ OT':u!ÀiaÇþ´g=Hk¾üUÃ?n9uj¶˜z~ž¼T -»ùpÜѱòDÑ!Šs_ 1¦`[> Ç.ñΰ©êË(vr 8#`l Îöì”7»¥™#ÄÐ×d’ª}r‹…ð}Ä ô¶8ey®ØpÏ´ qáCr!®ME… «9ƒd}T ¾ÐŠs6@Yø ÝEašûe–ùTïÄÀ6<qú®ŸmÜÃi<…l¤Å²iJçß*ê‚ü]‰—T<ÕLUѪ-)ßþyKŒ�=žöNö*´ù£° ?ëðÅ !§;í¬”Ò@Z‰°êàoÖ²×Úœ[z®Íú;#‘bù"®OBH÷bÕ[EIdƒà‹yv¬£²& tlt¸ÄêñUPGz¨?X›Èä­SÍ;“öúaþ¡ÿe]ç¬öò gXO^š q”]äqKŸ)µêp‚m¶ql`›õß.s¤|ÔÆRþ^¶Ž÷á>ì¾7cë†[ŸÎlsV ^s×öñ‹ò nš]æ:ÌÎ*d Ø„ž•×¹7]¾· -ŽÚç+4ŽÄʾ&¦i}ø®˜Òµ€ë€i-–a³D³Á£2+“Ì·Ãi/iPÞØwǾûÖE5ï„ë÷H ;JË4ËÜ¥ ƒ}¤§“é)Чëz¥ý;Þ¢ t—"²Œ¿ÎõãýÖšö«Bí`Š–žM°+ÚÙø/µ+—Ø$bçC|ÐÝœaö)šqÚ}þÑ®žnf–Vn4^-Ìdë³7ñ8œEú]i9èja‡¶~Ãq7])ÅÙ‚Â +]ŠwWµ£¦¥õJy¬í—÷Þìć¯>E¨ÅIæ75aeI¼ãÆÉB} æxàaöoñWÞášÊ·ÆžÌ•V�æóîë–õŽï‹øyô.c\š ·‡ZF€§îþe`j…kyÁc6·l4ÓKbi‘L¾<U)ôù¸_ôvdO¬ °<ÈØDÅiEQqFewóRE†šo ’uÔkRÝèK‡Tg Ò® ËîüÎŽoB_›SÃsÍtáiÚNs½áCYÈCS[ ÄÃ1¬î)Цýê G!úOœ%ÙÒ¤xõã,Òý–²p4BôôO›æb~^O™÷?3²Z !›Úc®Ê¶â¹ñ$ò&îæ¢L ¡erÚ®-K°{kºßê¿oô_Òæ@ Ë4æÀršÚ»0¸¼Y¼«EZÊ-ZLA1>Ôwâ,¹*¯¾(ø³¶[6éäIŸú" {N Ä0µÅzex»#­†hun�™£–—ZÁHÌvȤ>Ï"¢sž`±4?(?/ƒh<{Ú³}eÇ1ØÖRBJj̈mss/Tzéy¡Öf™AÙ¨âä1gP0Z.Ò R=šŸa Uf†5RI\ŧR„˨‘ªåmÓÆMçR”ŸŠâ8w93b| ®zäßµ'KUv!ôPàØ)0–'Ø$½fÊšîJáÛ¯,E-gæÂB“iHéþ‹jåd‘IV=ÐŒI¨ Rr1¨¸w\Vp¶¦tÕÏ Vð9ìÚ·djCUfdÇ>fú#Ñôi›é|ôÃÅxª°Ê’¥ýÁ©8[Åã,Ì<.|3­ãvðe ¨s2Þ¿H,nóŒ8öGò¨Ú¶y]6^ߧßkp˜…ÂÐÿç=ý±já€MÔnsvœBÙ—6nµ|rz¬÷•Y£dAÁ¥Äq[²ñíYpßöãN»©ßŸÚçFU–f¥¥éóè‚.ùü©Š9vH&è ´v]ÁgDí¡ìÆ[_¯¸RFLª œ(ÅéÓ³–¡}ü%5°‚XÎüvÏΖÌkËGVí|ôØ»gJ|m¾_Sö,^ÐfŸ<¥Cáçt{õ<ýwdd‡{”`ȉEù©ý0¼kûŒf³úà¿I/ìŠg…-ú‹Ý�\«s¥füaöùOF®ë¡j— bü-€8aÛØugVûæ ¥g½hÿglúÊ0ì._UãYIó—†È¬€î{+`\3Kz ,WÅ>•»¶U~ªVX ¯®ãúßq¾Ô¶M#ߢڂ±a­GÔ¡þ`ÇÓká8ñ$ÇaP#Üm}ÁžVˆ×ÍË›7­i³!Kc¹1 ´°ÓQ'¸qzEñš·c}äY1þ|Ù!öx¼Bjk*ÛÖÊ.@`¥ÿð=~[M ì‹DZÎ}"N—ÍQ7ItõÑ?OtJ¼Œ™Ž-f:6Ùýæ”Ñ=¶84Ž§Ç*¸÷" ‹fÙÜá5x¨œ-/zåMÌ1@ß¼k4ÂÚ-®-E/Y‡’‡»ZôŸ¬X[–9 GK¼ÎÙ¢zE°nä"¾ºÙ ÏoZ`‘6“N åÜkUРú¢õÌ ‹Ü‚Ê÷ë“*æg‘³¬t”Ó,/a“nÖ1d{C4Ç/ÆÛ´rÿ—‰qøa$Ö;¹-GEÀ?î D•U 1zÚAÙû¤™kÄgúåx° µ×âAY¹Ž/ÀEÁöHÅ×Ðx^5}MëÍ m;Êä)C¦%ÁÙÔõ붦<é´¿MaÃÂD¬ÇE0îéô_×æ~J§Jog¬¨Ìl(”$ ÿÖ”*IÊH D{c›5³ÊNKuF­­-Øz‚ ¿)á_7úþhXàÒ(÷®2íÚÌk•³—Ðy.{°µÈàÒ¦SÖv0·‡Æ{nµFzÏRl]ÂEŽá‘ý…E¼ÕT‘¨IŽmáácseÖêãø…iT™ZR2+(EX'±cÃÒù®Ðáé@±ðê¢?t�½³²@Vð<÷hÝ­NG6›eäæuæ™…ãή)í¥¢`nÝ´ Ù­>¤~`áiÔÄ{ÞžZ'7·ÎW¨`Q—¦¢w­µä²0ß4;aìwÛüõÉõ;* c|`Wi-ƒÊPý ­’ Ëmk cûÉ!è}§éïÂ劸rÃ¥Ó8½£Ž¡!BÝ}¯˜ÿhÛ¶Î5_}vSŠØÁà#3¨‚¢nÜ(Óhû²H™¹ælãŸÙßV^ô ´«z‹œ`)%ßyRS;Sš€RGé®Þw Ù*KÍR-u¤%Þÿ±Ò<ýißÍ, {pc”4¿£Èª¶‹7Ð:œî4³Áž®ÏãÞ~ãÙ¼Ô=!‹.80¸õmë×YUdbEE™ñÖ9ò ²Œögž¨,rÄ©u=*é…€ÒsfH|“”AÕ¾{¨HÖôRâëk:ȱçq ¾rã¾ ò^g`1v°Õ8g TýwÇójbÀEgŠÞ‘ÅÉTÎ’Ãjü×´óyiÊ�Yù×ÊÔi呃*A!”A¶ñäÝÆ2c¹wÎÜhA¶ûô¤T5|Buü–Ýñp¤Ä@Íc¦_žÙÈ‹q>ÖHWQŠÕ¹Oö…èØ8Òg6ËãjÄ€k$[™Ø¶¬xež×ô®MïºëÝn¤,;RÑ'æŽ ÛÕÌRqÚɺå(ûžnðq†tD­5KY—W‘I�âõã}qWm$GÈ÷;zÓÎ7à³wÐœ|yý€/­* §dÎà<‚:2ºhÈþ.—kÇÃN\1ݳó…Âð×a¸”9wkbÓQ&š[Å䨀¨C}w"™rWŠ¥;ï¦ûÙZº(®ùŠ—}û|eÝ—±¶¸§XT½Zb^&‹6rÈ”äxë̘ÛȈ¢*ó7 d7^Rš?¼)“iRI—œÍFÊÈœÞyÍ¥à3—J\‹r‚ ÙU,û£Ér;¨‹iËÜ÷»c+Ežh;“Jš.G[[!K1l€¹ØAL¿ÄÖŒ;Ãb6O8nÙÇòæ7^3KºÖ €¦tÒY]¨ˆ¯Î‘.ºP}ìÆæò¶?}÷‡Îs1kúš1Ÿ7ÕsæNÒèÿy�§Pí[‡¡Uö7# T¢£n¥ÆuOî6²ãʷΠ¤eè8D= K#T·ÜÅŸ¶æX{‚’*®¥îÚ!Êñ]s‹@Ôt=(÷–â+²:ŽÔÞ×=»-âpa¢ˆþ;XXik'•¸ PÁºKËæ[냥¼d‚eI æ]}'Á5’¦ªÇyÄìb½.ž¯M;a¥wIïfÓk7Í^ë£õPºS:ÜÔaêV!£î·ßEP6ƒ§AËÐ] Â7éøÓ¡Oœ8Õ–ˆÑ›5”U¶“ˆBÝÆ}®-šï=»iD¦úÙœRètÿñÀ«H9áŠ&¼Å ÅT‘˜¯'ë™ïvBW¡ƒeèVG˜ëÎÉARù`â±¢»'žºO»°Ñ²*öO*LºèLqP-(ÅÞ­ ¢Lkýß·¬Tç¹>ÄÿÆ:¿:뢢ðÛ×Q" ù¤n=m»u-šY špàø—Pò‰'Þ̽¬Ð6èÄ{hEP·wŒ¿Ñ@É–ƒÞ?¦ØeŧY t`At)’_ûØ´íŒÑ=eG:Yç¿ÐÂcòðo(iåÛ"¡!¾Í)U¬õÏ¡ÄÞ§œH4;ïFz§«‡+VKåÃß(ÎLÏ)>•®Š«ó~غ ØoFVH_®Û0¦!8RÖXñ¨–Eª !G‡é„C˜µ¿hWŸþ„c ÂùùœËâm™n]Ð"c]ŒØ© n¨°:¨ã«íoln]]#£:Öä¸Û®Z,ãºïN ^:-½ÃÑãÃýìÈ„¢Ìr  UõA.üÙ±áó›Þòé›ejîKHVièŒØ)•Û‹ó9ï¦ÁúÚ`f8Ÿz#éÄ#¿‰}×7í¹¼¹Ø0]Ê€×iÈï�˜úÉ_%*Ý|€£Ó‡AØjë8Q58§=v¬Rš'?8šZ>DXšyW¨ö͹ùwê{¿ a«Ñ_ÖªŠ_Dˆym« ¬O^æL‘”÷'ì«9å6-$D†™ÿÍbŲʩ¬I¥eߧQ!É1“.1×Ð8ôZ]æ8’…Q¸î»¼’^z¡½d j«{fxyÏ$åæw¿J+oumòÅ 4ŒÁGN)ÕP]B¸ñZdnµC(|÷Ô¸ŽÖì‡xm+ ¡U`*‹+6KÙôúKùK¾¾æ/´6­o1ëó!Iü˜3ÊŠ.&J€$u^– ÿ/Õ%Š/L*8’;bÀØìDS†Ý‡çÈÚ̙ѡ&ËJƒ´Ÿ<”G,ý¥ Z¶”> jÜÎ{¸¡Äà ¡O׉ò¼“f½ÌoíÎ<¥³ÒÚ4¼{ÒRù+˜¥gñÍBÌAßÓí)í@pgî6;»îp ë;ÎI¶Ä¨¥ÁLuz>Ôd¼,d‘ÞþŸ· gÂÿK›¢¥ë÷ÿ½õ3ERè?�Ìþ"§}sGó)úOšd~C릧C.œ×žv0•&}á9£¤++JôÖ|u¥¦e¼�²nm·^RM_=:<4—JF”ÙG èÔìù¯0ºö<É¢3×ü:4×ØRáq™ ¶Ø9e½¥è`S7+O˜=áÚš÷„8œdFn°ÈAr+Âim·ó}SÄä"3Ùå‹Ã‡h²™[îilRq캂ö˜rÙø™³•qù³5oõÿÏôÖ_†añÂìp™”_ñ’xáÛ ˆÓ4…­ÂÚ Mu¤¿xø•’ndÝ\ ]n0 '®°kÝ}6a5–ó–GTϵ‰ŠØñùˆ”†Í`²5¶ƒ÷Ä:`¤`fÁNשï¬îÛ¦F¯ºQW¡¯ƒH90OùÐ82-ª¯Ãèn¿Âž^?ÅiiX;¡¡x ð Ö.ÌDi}õºe–†ü‰;2¨ßÅ(ɼ#þ¢ôîñò3;J/¹qw õœ®]Ï¡n÷´’ûIoúêc20HÿJQAÕmÙ4×»N±"A‡‘öe~© Þ*…”±£Ê½ë-ꢾôÜT‘]–°½vgHŠÌ¥Wô®mO·ü½sª5 / âzÇ­.ÜŠÅêím‘ô±T}=)ƒ…F Ž@õñ™ €” ˜ke­:  j¯ ®ÏÐ,~”ʊ҇ǥK!Š÷OåNCè„&ï¬$Sš.óï€3·Ý÷ôJQ:N]&C†5õ�öêÈ5˸£qog99ïrÿ‚.T3Çò;·IPÍ[‡0s–é{£{¸~d<¼¹à¶nL9·`%ŽLÿº™&ùÂJUã¾ÞŸÞra&«¸™–¦IŒîöæh’‡3§›„ß¾×l&—}Ž“E ¡Õ0Øžè}‡Þƒªtp²Ô–YÝ<ÅåzF.¯ŸþÉð`M,ÈqwtwËéÝŒ|VwÅ@g«•véY§»‡¼‘åµûñ¢nƒ™³¥tr²….UK—y{¥®xýXó%Ê‚‘ì´‚ÞµÚ„ÏÈåMlãNÓV—õf3")õÞJÓ±v²É¸c ÁËc&!¤Ê=Åßp²ý¥R”É1)Uâ4D‰v+J¾á~¾pJ<—d™Œ{ŠdS££“°B{½ó§3ãao8íò³^†ÂÝÒ–¾E Á-%[ŽWà÷K‚ý µ¨ÂÔî¹ãx.2‚F=v@¿ýñRj 3*F†Œ¾áã·ÂaièÏ;èQ²E[wz÷²Õæ2ê9^³¸ SX½§#Eì˾kýI~ºÎ;6§$ ªV; MÇ•…t‚+úÈ­IÞÜ©·ÀF™¯lȉ6lÖ·šÅ•`Ç$DnÏørèŸéŠÌ�…¼YB(ªE(¬<ÖãÜÞ¢Á·Bßiûm± Í@YRHýÅæûMüÓ³ö3Ê4”‡÷j`gŠ`á©È¶®àr‰.»+w|šÌÂiËQäÍR:rÊwÏņmb©°Õ·£‹tƒD{ž¹U ÈËTú$©¦7›<Hß¿ +cgM†vÚÍ@´¡>6#DÌG¿–BzùGo>BV.¸6)+Ù¤ÃÚkÕŒ¨þ+›$½ö¦û@e³E¡¢ƒhÈ-Vd¤›ˆ£t×ÊæpÏt.R*N>23ÆqK{.Üô&±®IÕšL;öPk¯í¼ù5íâɸt”I\uÞ Ou‹Ã‘nPøÞ8p%ëðƒhsз¥ä–¥Õ=ºQw”ðÆöDáhÐZ¦ß1^Ö¨MW‹éß¿<>u&X7ô©§;aáù1£ÍÏÆ>ʨG_?¾,2T^“†ÿÚå@ñ¥ÜöŽ8º·®Ú˜ Âvò|RКãüõvÂœ•©ŸˆôE¤iôÖ+U÷¿o1@`«Ã�rE×½.?âz‰!ylèze§Á!ìÀ—ð<$ë¦é.høZ~wŸºœÎR"#-{<ÐE5þV)÷g¤|ÎoŠí‚úÃAúËWw@ìyâ ~R‘ƒqPf‘¬R7‡Ö^¤ß ƒ\Ê b3 »?nâ“鲚\㕦wl{‰©a-Ö=УÜ*Œ8Ø> X«ÛÚèFÚ'T›Ÿ/´ðí?\£ï¼Þ7°¨4jÈí˜G†ÖÙhñš´Lª4½ÒŒ°:)’£mä¡• ÊáŠuþYõ±"A ÅA³-‚|;¹…¸ðô5$QÁ =zî‘,Pò Œ!ßß=¡|O£„LHл�çZ ìm=m\JÊ<KŠmÓ:¦¸ë鄲ã4¶{3 `ˆÌàÐÔ3M£…ë`,ó§ã§CaÈ@p2ݹàWó¦(‰}ØÝö™ª˜ZÇë%Ѭ+j-ƺiròãöùkä<]8Fl\PY(Ä y^Of’FßCïÿ„âÃõ¼ÅÃ`+Ayôõiìzïϱ¶OÀˆê¡};åõ\‘±ÁK#/­ÍŒZ7Î>¹ ¸Ôö\¸3Í–Ô Ã/'Ç¢mÜ7*GwÓ¿d„g‰â ‚T”®BÚ¤Ö]ó±C£ò ±æ¡ªýƒ²7DÒz#*F×~@ÔŒaÖ— ˆýË“°?]×ßÞ4Àˆã» óUVǤã¤)†½at^+–šLÆ¡ ê_\2“3Ôñ±C3§òýÊ2ÛÉ¢fÖ¦åä£VnîuT_É3§œÇõÝü1×Zþ"\$76YšðÜ †æ¨!UFVõPé$„(.ر+‚¤ö¯×žîÛaT‰Ký|uQÚmOÃ,-Ï: RŒX-§‚Ýü7/^Ÿ˜¾Å·/¿Üð®å†Ó£ç2ßìX#Ü/ÎÊØ)=3lOéZmID0)ÚÍP‘ Eœy%U ³.–BåÜÖ[[÷ŸÞ]„¾ÃfÄ ¼¢z›áˆìöG€z¥öKvHU¾î4Ò†)Iƒ¼]{@¯fÇ•è5jt(Œ»¨¼ëuRuÿ·|4»ô—õ­VçŠNQ[¦'"õG_Žf±blN†çøA?ͽ€É®3…¸øóâj¸¹#—„bIÃQ½·4N-ü­k|ʦuy“ië'lÃ¥/З ]]}Ô°êÓÛzÝÁ¡fwØÜ™àY„ON‘ Bî à (»Õ|2þ6ÿ}3³˜)ÕL—tøإ܋ªp±;#¾P1Ôìrî1« s*ß nJ_o¢+EߨL¿h°¼}t?}þ§\¨ㆯÓ4(º£;p z٠ͥÛùª#¯7˜üö”yÓy‰$΋݇óù75\$ðvM09ÝîZÅŸšm7=<ûžåÉl¢f�€¬VÌ µ÷l'èéúh¬HÔü=Áõ‚ à a:CÓ25t#ÚZo©ÆPÞðC Oé5‘ÙθiÊ ²’mÀ  oH|:ýI ½fsDi˜$¾PÚT—6 =¬$8{~t/ûæ°|>pöùoŒ¥» ø¡£¥ÕbGŠÄÙ|ïø|æ~fuK íkw̾ƒÝäfö;j{VI¤™?f`-ßÛ8e‘äÝ~j/:±01ˆ‹ßQ})¼Á»7ôÿñxñHµt«¤A‚ñwJQåK[�–Pyl[IÙh¤Í †UX,{´¥^ú+•W 2ϵû¦“È ×dK[LSÄÄž<Xo̳ãø¶  )ZkW™C¢«Z-aô;jÊê¯ÆYΊ:á#«`¡ÖÄi©!¼ì˜£%CÃâ2ÜJy,ÛšzýL£EV;LX+¢GI;¨Úp?Hðp\…ÖBQV>¢½‚÷•©Sk¥2K=Œ»ùäØÆÐ #‹NOÛ™ÃPâÖ=C°CÕ!âþÓ”˜\–(…’ùÙ¬‰ÖÝé¦ÐŒ-›µ+à'Na5:^‡¡ ”]À¿Ý|Ê;ÏL'ŒÛ‚–ÏQz|pIv�Ú<ª¶<e9¼A´cI_á4ì<‡±m¢ä®Ý@ŸhžpEuŒsJ<uÆÈšÆÃfÇŽ¾ÝâG!š;²(–¯®†Ø>çºVïšwv˜Îè¯G}Áº:)2ωüãšVÞ§ú˜´§½‘`‰ï¾FûŠ’ŸËÞ0<bp9&Wœ™gFϳ¸IíÚÃ]Sì4%¦ñc0?Ý,uX€šj0jþG ¨S†#|þ AP”°Gô˜+¨/_ôFˆ’ÅI{q$êõÙkâp‡ÐâˆèËñ¤Î{Fu¤IKoðƱ7ú`½ø†6FµUx<ëNuÀê„nŒû†»=õ¸Zô²(K^ÍtbZÞKœJÎÕ‹!E®(~u2 õžÚQ@¶­Íé&AÖ¬-2Àâž7Ø5®Ã‰7~@þ¹GŠòʧ3@|ØÆÈÅ¥¢îzõ•+(®-‹òj\É”/³x˜îß@ôÛíÿï¤uK‹:gÁ°IéDùãiqY³4£.4Šê¡kºl:ö໇ ôÂ2H6 ç³ \2Fr7Á\€å|»þ"ëã'ñŠ.«¦¦ƒ°ÓÉ;^˜§æLi7ˆ4ŧ_€‘àHycHŸÕÍ„ÃË‚\Ü«ÇËúðmÀ‰²„ÿ¾¥™Ñ‘\ˆh]bÞ :ÜʹÜš½X@T§ÆÄÌÃN©SUÈþ(fv’Ö“øyé"%^§…ÍFz ç£ÉzaoAÐEü5%õä^^Ö~©2`âOÁS [hÙÓè Y%îù3í'ò)Tx6ôÑN*Fòä­i m¢Íµ— ô‘–‰˜î=×9„kO¾€óõåè oËMÇ o_¾:ôôKcæ}NtJZòFÿ¬¿iðéíRsŸßÁÝ´“¡%ߣ×}¼è„·C6þìi½s…,ÞêêU ÖÓdOgüG/ñRß²çjÜÄØ:{, /´pFpŸik€~°¥Ír‡Ì•AÌ÷�ñf2Ǿ皲evÏäUÜ)´2 S,\¤ áç3 ‚)¶ä0(b)Oç=>¹ŽÌy{ë¬^ëiC-¯yPû?mpÉQÉA ÒÖù›²eeߟñ¥¾oê¥sÌE›?a¤ÝÙ^·r¯ÜegÒ Ìt »Šâ±­Hâr‘!ÂׄÊ𨰘*£a7©¢É­ùZå¡à ë µvªŠhš¿‚¸—›URÄÝY)4ˆìLEGhxü¾ ßì’áiô­³úÝÓ.Äêa®§hRŸŽG^™šiØxÐïNJç[d¾ÿžÒâzka@!ZûAÍZ‡½dBÏ"? sëho6Ù“” SJ§ÆÙKŒøÞÃH‡ÛæXÞW¯Ó+ÃKø,ypé|˜6 ÁäGgÒ¶>[Mäá,*T/h^”žƒNj·èÔ¯,;0Úg=ˆ³YÄÜh.öQŽ8í¹¾Ñ£ßÓò Š³ªUCWéh›3OFBk7VÙpoi¬Ož94“gÅ ÊÕ™þÄpòDcß1š{«g 3“q¨„8w¶•ËþêUÛE—0`ª‹$ˆ?kO ‡Ík;¦T_¡8^¾úÁÞQmcUÑl­rjf¢×²>z|ŒšX ÔTÊëÇ_FN´Z8QÐ4Ã8e_#]ãlÜ9(q@­o[ûLÖ˜Š’.–Zr�¶?ªª×tšç½V‘ø&&É—äJ{ûÓ §`î`ÚŽs~xO}ðDa8Æ–è·kÐñÑ3¸•*/ÅÂ~ˆK¢hQJ—fÈn["è=`™ØR­9¨×õKóö8­|ö<¸íçŒ6ž’é£k£}`¯¤û*ü¯úì–…CP„âòž²övd3ý†¾:Nls}Öœï1»ïg§÷ˆ¿Ž¦2¦óØš0‰ÙoMÂTS¯>4ž u^gÒWÅ×$|ù¾$‘G+cÏ“ Ê0ó»Ã�àÆÒ !:™¼Âû®sOî ΣÊ3êDMÁÔwø$8µvZkfJ®P÷ŸYï©7²ù¾ Râ “cBîdàÿf8g忤ÑòòœY¯תªû]“ÄýÚ‰ ÓÑÔw+kÛ {ð$ØŽyPZC\ÆxŽÜù¬þRwÐA°÷ôy£ðlƒYˆDš£UÂ2‚!½õ�¸‚j>nZ¦½ïA÷ ®¯½%¥õš6JߊX Ž†vg<ß$§²™UâMbbhÛ e!‚±fž©ÕsäúýVz$ˆe'ëD9þ�ÈB¹9yGÿÁ@šŒ\ñþÔK—ÌrQy½$¾@~†&äŽÙh}Ÿ#fm]8½ælôÚy¸Ó2 ÌY:;Ú;P¶Ò›+²ëÑjTAi!ô˜-Pi0õukû$ô¹/´ê]Ï]‡íËs·Ü¼qcêh¥5S¦Ð<]é1b¼„ß^ñÄŸ a’ÔÑ·JÔ¡óHß+z¯]ŽG©×dž¢+d|#‚½>ÞÁd¾ƒ!“Í>fÈÉéÎ=L;‡ÀÐ󀉟k$UnÆq 7zý—·u’×RÏ„%œ¥AܪO%D¤Ã2&>ÝŒCã€j“†['¥Ã<щyo­D™“KãžanÉrÊ‘=2Ö6ÀùäÕìàêÕµŠ@˜¸ÛÆŽ%[H8Z‘:V¾9,ùm¬ümùhÐå©vhkÌv¶£7ìm:n {]é] ÙEóÐtß´µŠLaøÂÏ­Ë êu&hÆX \±X-wÚMxÛŸ,¹ãÂèkR>ÆIÐŒ\«‚2N˜üŒ­{U…Ó¾f’šHIBLÇ*k¼m»&ÊÙ‡{¿Ù&.w–bì±c"³äp¤-´ x‡rj6q(ØywRå?@T›0/ 8¼àFu>xGœ¼‡îyV_ÕŽeå+L†HÅ¡äqYôªwCË“!“wSÓA‹Ì<®)‰åÛpáҼҀ™£‘@ç]ïõ·-KÔxùá†í²êÍœééô©Ht]`R·X] €8;Ó\ñãd²ÿ¥“m)ÃNÆç»Wþ_ÀDƒêþƒ¶QÕuêå\f(Ó(^ÜÆ- ñïÎèo� Q’\1‡ Åìc~Æ®õm &4ƒxÒ©O¤¤}¤ãçÃÜY³ŸèÔû´–K¢ïZžoÚ+ûÜûÄÚ¯ Ÿ(ƒ‘ Å™îär–ÃĸD“V¼hX8­ß„F_µ¥×kƼÅzÜýé½±ïk®÷ÙB´«‚Í#å-Ví£bmÓ]<$1C{@ó`Q‘esźpÈée|hÕwGÓ›? ;hs¡}:´6½¢,VK³7úý‰v<|Òéš»_©ØS*–ì$K¨ÕàD‘¿o¼ò†¿ÓhD‰Ì辟L)Oýù+ç! Bãôc(u\² ¥ 3þÅÏíÃÜ®E,ÇýN:V;ÍØ–àN„Œ0P}ñ\ºœÚ"¸÷ Ç_gÎ[œ2®¶£øa¡#1·ü) õÕ¤/{ö!”vâ+"Ì|Î(æ©B>Ͼ»ð`‰P¯Žb¦ˆ EoøÙ™#Ç„qZùÚ®\ƒs,0æŸÇØÙ‚à {›=Úï­²áç·U׶zM m¹ÝÍ{(>›…³ëËd~"3”½{‚ýå"‚°²§}dkmÔ}³Ó19ûZ-ó{£I̸x}¸åYÛ>í; ¾ýöD½4kúÄ/qàýÈÀôãyʃð½uµ»àöÙæÆ|RJå@‹l¤Gu×éþî/Q~§~‰âÏA9Úª>ÓæÜ^лÁ{åß~öÊo'¾v<Pu0h>ˆ)•Qóñ\sÑ«y¤Å®�Pùq,ƒüSñ>Yä9}ÚéþÇ2]èÖ\ªú˜û<u 1èJ,^ÐÈ@nzV4è8ûxG*# ­g"M{ʶ¢ÏѹèA³vª[ÓØk‡¹·÷>¢/σ©Î#vŒŒœ·ÊqìØÍɧ°‰qaYÒûyC5.â…tò ð;O«„ÖÒnâþ£´8Íb×ße"Ô"eBÇëO¾n†¥•w<¤3H¸Ž+˜ÿò€D™û†ÂÀ†ÄÕûh¾fÕvôÍü_ÎhD¶_àÐC ´OîH'ÓȬzÏü6=}ô“nŸ³& ŒéÙDø I«l7‹qÈ„¬èbÛ!ˆ€Õðùï7žsÍç¢ÈÓ²äŠòÐç^£ÅYÝC·Î-§ø·,ã¤ð9&Qœ'úB½µ8¨džì­ÿìÚØ—>â¦Ûî•©­?®cîU§ÐûÝqâ�|ýèÉK¥ž4i,ÂchýœzxӜƆK?swÿ༣ɿà ùÔi^™ó9´u3㹂‹?„GÚÐõúÈÇ…}Xc𸃮! (6ÍäP´èJ[" Óקa%mæù0×nêE^³™ÇÞ(‘1|ûž| «îâ>þïFo™¯2Aþr ƒñÝ5ˆcbaÆ¡PðH>,ÐД3¹üûá?D IgÞ¬oàÈ5LN¨évÉ“ÛÞÖ&K¾}rÏ®(÷= Ðh9e<o3³*èŒwìøý¿¥�U^Ó•…¶WºŽžf-ªYñ PÕÞžEØÐœÀÙ;wˆ{0eÒInµ8Â"˜�JGÏø½éú/q«‹VðÁ6[âszW‡Ûçtò^VŒ¦»øŠ¿ŸþÐj¶I®3ý»t‘ÌR­sŸ6+è:úè›STGñ`*}3ÑØœv½Tuî™;JO"œmþš–6@9­½³“—KS)óû2óÝK v57ï|$¾–:Ì1z�­G_GÎXSj€¬Ã†S2×nHÈD_¬kõ28Ì”u>è 1WpSwÝgýr¦1ï«­L*pï5•—®•ó¢tŸskИ¡×l½* F¬eàkèãM€� 8¢øš¹+Ú1¼rmX™ÏnNyP¬ÏZäNI_W ”¥ž=# [QÆ*%!Œ dÏ”§0tÁôË›Ž'ŽZíE¸ßq«ìÜ׌p*ÀãÁ¿è¬Ó“òöà’éõg/˜q¬­~U_دú xÛ;Ö¹¹SGá¶ânSY­D%@ÍWÛ݆&žH°þÎ=éD*Úx’iäÉœF;{*`{•Ab…]³R(µœh ±…Çù3ŽG…¾ò{I› æt¶GXÉPCÃv;Ñ1†ò÷%å±e<âÍb°ô`IüÇ‘ûÇÅ,ëŽ2×`œÄ´ Á ú;¶žâvÄFžÎ–¹.ƒ¸³Î,¥©| mÜÕV©wD&­±þ>f/*ý¨Fßiè(�UÖŠˆ Ù,.ÚÿF4ñ x¸ÿ€•nwt%0éð­éÿ”Šk1öíî8ãä×Î8à™dÛ­Å`,Nßžîƒ)Ä–(‚-zú›{ÅFTŹ=CàÖ ±m|NÛ Þþ|¦î|Ì –{”/&_T±b:ª”øñ9bFv© ûƒÔ2¿‘@Lr7Uf¼äÂVs`„g1Û'wžI²ï˜I¡ˆ‘jéU�  ýñI‘T˜xö”^ÕÚhOlX-Xš'L)+Tã›.Ô™2’°i}¥Y¦ý¨+ÔÐî¦íÏ BÛuÌ f­i �Ó¨~Z ò«S@'U<Û°Gb©ïÀùÎæDë>ûœ¼qÉ´OÍÿOÛŸl·®$Û‚hñj½ìľuÑ°@ÈEqüÿïx6ÍÜܬµâæÈ›‹âlŠÜÍ­˜…Ä3‰•=Po2:ô.åDQG{¼”ˆó†3Ì *åã oô¼Š2³µL×ôHH£ú~óª:Ïö6—¨Šª ¹LŽ<ÃÅtÓÑÊ6ê>äý†ÅG±0È i &AÙ¬U #…§‘ ›AŒz7À€ëè-B³êÌ Ö7È/Ù |*‚ÔºÎoyZÒJÀœ$àGaÒ ˆa€Õêp†+7›ü¨QUÖ U €¶§"HÖ­9,œ~˜±š'oR-XÿKÚïdcÓÙn øªÏ^´¥/6ŽØgƒéR¶¢v„—eq,ºýW4ž*r(­”®/v|=)#ÿøç•šnIÚ뎊í¥}Õ6X˜ËD‚•Àß°LU4[·Ý¡ÿh»óîcOÆÖë›WÞÎ+±/:ÀfWM›`ƒ…»4)Ž¬‡„ˆ$‡´ÈÒ °‚y`„ `ff9-žLÚÒåùjÊr¿Ò¦Hqž1³Uòo‚ú¨é?H ͆¾î<è¡8 ¼È”½€ù;ZÝpå«#ëbd*¢Aæ?EþGY‘yJ©À–€5)‚ù‰|®Nìiw-÷hùwíßż RD…Ï#Ž�ÀÛžÁ@|³Yî͉²|ú_ZG˜óŸ“ZÙkñ�§'JUxlŒáS¡†q ž+îÂÔ=4±¶ÊÖBQ¥êŽLe­)ÊÒÉçfÀJ©ëþÒ‘)ñuùóÏ5ŽÛÑž/ ÇÓóeþ ¦Ø2áaƒÎ̯™ÝQ/$æã ½ÀT T¨ÖíÙ_|ö,6÷å Ì N3†žÃêÿÛ"‚zÚTåu3Fª"OwõL–9Cß°— Ť�ÄÁ”¡³¯qa"“Tÿõš•ÏÏÒÒ¸3²,ó Ê@~þ‰=­Ô”ŸøÑþ ÖŒ‚®‚ˆuk/nœ¾¯=€ð@™.ù0:ÑgÓs±3õcü">²Q´â©3•–ž7}䢭ßêð}êìDeµ=Œ\µQl4)¢ §Ð‰aæÑàuÞ¯h3|-ƒ)yÑ('*æ5mJ7¹Y”D&áç’þ mÙ°”RdCíiÂôh u¿—µ©²:ÛîÜciýÞš//nJ@=àx)&…ì0°èŽÉå1÷nÝ»¿»¾±þœ…º‚-Z ÑñìÕá´tf(1Ë�GBûù"ðl}½­¢â¼ôn‡èê¿=‘P†ÙLG-[üƉù¹Þ¿ ´Å<Z@1¤@6 ®ƒ>J¨}{6Îņép0§i0iÐÔ=UæšqRÞž¾PzºúBe¼Ì׳ܱ9™îç‚ ìÖ {Øf–õ]ñ] V`Wb•,§.ÊÓ¦ ¥ýÕ÷Å3AãσóT[J¿“EÊŠÌ@§[qøIé°´C^Às `¹Ñ˜·+Ê땶u¥h¼Â°°š-EëpÔÜ'§~îr£ï4³ÙV¢tƒ¯úÊ»ëüÞ›SFÉÎÖÏ„ñ<:¶ù÷†JWz± à‘ýHŸ3ë5…BfðÁÞÒ38ÐÓ®¶éδ½ìÁÑ;›D©+£ìF.ÿÒçk‹Bp)2 '>½bT¬<v5ï=é6PÆãHÖJ» …åt®îvz_#cSA¶šÝªÕìê0à#rð±+c–ãiRÞ…†8ñÕ-wöÔ4df*Ã&Ç]ëûú˜°SТãbÇÈZv3Þ5=GÓ߉%ÁùO=åÞËQ¾haàä27Š«5Ö6ò/¥¶Y|eíÊVxíF󒄉 §i!<÷ÔϳF¥ŸGWd ÿÅ©bHx2îÞwç9x“D¥ZKI+,¦ïUi§È®¢(¹=Ͷ|{Ý8O/.ïÛQ§ŽûŠ4fª!Ò®±eº<ÆýMÓOn­íþògÚ§€u+š™ŽC‹¢+³šF=ã4µ1ùþ¸"®,¸�„£Û÷bE•–í¾cÓÂßaqAQ9 ƒ¬nLTÆÜB&¥’¢‰ã kå<½ò›z‰Áþ5sZ1“ÆYßî/`Ûg|©>ùYv­­­®~ä†ä¿šÃ¨Ê#ô„„ìr˜gÆS5§¾è³pd `T»ÑäFsÀ'ýÕÀ!rP539)AÿD—}6ÃhFCq”T­ù()Ä<¤·–¢ÈxF`$â{8„PÈ/‚ògtÞÈlmcµ•ž!²2O΃5²Z`šãA«Àö!ª(ì¦mŒôw®Þo¦nn%ô°ƒjü¶ ˆu„[›xsC…–àlì‘[N:&ð&c‹!YV*g¨fŽ38ÎÜyŒ´RŸ¿"-û†µ²tô¹û#Ôlý’D}ý äü®ƒ(v)í®h8y§¹á+ã4j<në¶Þ ~Î^<˜"ÛtGæ9y0oÐ¥l=/ªqQª¿4 v¹ƒôì/¯¥GâÔ¹Ä KìV¿F‰C«% IÒ¶H°ß̶Ünlf:T¼¤ŸßÚ?D…„=i‰ßyªæ0 ãG±)‹Làý«ÙN 93å3|Þý×;©œ¡k9"¸³È[ šƒ1zøGhâ®yâ;<¾»z]fæñ¢õ {Ú£Õàé?"”BÛvßïÜÅŠ’$8Çvöa/V·+”YÂk†VÔvã‰Àì»ìÍe³ðá Ô*+µ€P\|9FþÙ” –~®-¾Ô§PÙ}õ­c.$:˜&{$Gæë߉*A†æJ‡R7¿ðDM,À¨™é¸-6ÚÓÃm©éƒcÜn¼‰pHlgãïF…'(›ÇU»ö0G<ãA„§ÿn‚úÏŒ>fö ˜¥…õnk«òš+l²Ú÷1µµ“ßÐr‚º_|@AÝ–Tg®¨ùþ¥Ïgˆ Ž½’¹öäÂD«>[0!£:Qpügãío^%I¼Ü¢=R÷k” ­`pûPyðu *ݹ¶G%ÕTP’Ä8ŽŽø¾ÜèµV¼•_7˜°ÌÆ,È'Mê— ¯Ê2ëõtvаաk¥•Œ¡åí…8YdÎDÛÓÖYwææ1" Ó Êx%V/íäå(®Ýú$”žceÎ> ”}Ÿ³¶¨‘[¯"Ý™/IdQ¸ÐoÁ^/¨èÔl$‚(!dòÔŽ BIü h·¶h˜JíôXx¼L|k)ZŸ‡ž6}Ñ•‘ ë°³ø ËÌpòúâî�&Kèÿó†²`Îé^¼qmepGcLë'IåŒUÈI|ï„é$£ž0Q5 òv²§ž¡ý§¯Q¯hа;ïæCšÔÊí›@WAõYkb³êÈbÄh¶Ñ–sÓ»?=„6Xt¤ˆf!ÝЗ)׋ˆçTC=ý¡¿':e©ÞÅR%qj©7"ܾ9%”¢®gOP^l ›‚[&OŽÂ$óL?¡ ØS¹¼Ñ&fd§®¶o(!ÙÂ÷–N©}BëõÛkOn!PºÓšíîXyæS?0ø¤ךc„<pd·jU‚džÚb$ä}ðgŸ?Ž?ˆxV¬ŽúHµ +–—2'<=À�î+û�ê]x•?HlkºÝç± ú…È¥sN~ì¡[Q‚°pª¯Kµ¦}볨Æê­Õ…À —õÛ6 òãE­ÖÇè–p±×ÇK=¿Ø’´È|ÂH&‰WúiÔ û‡XP�w7öo¦_yâzŠ,â²ÚÓùke®£¼Ä©A÷Ôv°ïkÝ‘9*3€ò1"s÷ùCvÛÏ¢ÿÀÝ›vûñf|uŠ¦öb!Û⣠Cq[¥‡÷Œeuu•†yî6Ó²)aƒzN9£`Š>—"B¬®þðk1ç¤((&“ÞÉsÐ1fÒÒS,èÿ6µîeP(cm&–ª¯•"ÞŒO¥Æ—æÏ,šÛ•u¤Ø6ìzÓw®)oì+£³®ÿ¥Ë0Ì7 ò� ÝyöRµ½\øÖõnr¤%*^:ʲécÒÍ`8±îô \ýº±ã÷æø à‚FÇ­'-Œ#VF¥ŠA."=?º£X½gžSéô>KçÝã<›WS}ÆC iûš)JKŸ4ÈY-ü &%Ý1ØDë?¶'çLJdüU-àÀ‰ÊdoŠ*('q-ƬSq-öâºc¦|º_Lª´®3L(ásŸtÌ~xJ©Œ<RbHlj>ÜF9Üèdïh#9UcÔ€+ú+t{F ôšÁ]}gåÔHY =W™K¹â÷Ю'DŒšÿï²Y‘vQÌ/åÄ­-=šÄŠšf‘ *1Æã‹ãÂ’êCU­™¡-XnÿõÄ6Yfâpö Þt¤¶{H';sš°4rdy¼Yzý0DšãOÕV2ÞG‡~v#F;qIÝyÁ2 ak1“+Ý:ûYH_Y@«»G^òÙ¬¼Ñl« ²r_lÇV÷v¡7Hrò+ù,iƒÒÂ0è?Ï? õe/¬P΄^!�£0÷ý‚ß ±Ú*.²Kèep¶º¯ßïèGÕBì$ÄœŽ*¦Y+&¦Éø p¡Øà‡áòB¥;‹Ü°ÀP'‹ Ôöò£ #£½r9K¾ÚÊ™úX$ÛÉœˆ>è0ð­Öñô·º4¤Ö=ªy©(žEXOÎŒ“ªQˆnù«ŸU¬)^²þÓ ðøûäÑ¿5tçæ ›†ñÃV7†zJ‘«V ªÆ†I·«Ü`Ѫ&}¸¢½bYg[nÃ\|õ És •±¨¶ím¤‹èù¯|\dd<g.‡œÞù[ Òx‡nÐ�¤ôŒ–£é zÚ: U`VC…¡ÖUAñ=šŽ:z§ýžo cÓeL–¼Ã‚ªˆ�\Dná`ŒªoÀ²Iä É1 Õeo5Fg¹o8Ú`Ö—­æ4ÞŒc<½_ÙZì–Ó¡GaK'ZA¬šêÃÊ‘fì25ऊ‚+(Ñv„ÏÓ†ÝFÕU±LE¹(—Á›×=`¦0»¡ã¥!J²=å–Ù¶÷ÔûÚƒ³õÓ€øÄÿûÿÌ<ð¯)‡Ÿš¿Z‚`eÊ4VZNûÑÜ+—mšZ¡Fï¦h{ËÌQ;:QnT^ÇŽbUøÙy9¡éŒð ­wy®¿Q¼¿ò@x}¡GóïÚæ‘êˆóÂï\È_ÿˆ �}ßà|™®ÒA;…1òËQ0öy VšèÉ5‹žà½dcùØ_ä�³œ§aÚ9‘ù#CGÅPÒû^¹˜\2¨ÂqøˆªJa/gf0sç“úž‡–}Ó·”PVâ‚mD½r_«ú„þèŸ*ˆGGYNx¤Ø{¶ÎÐù±€·Bºa_ñ݌_¶3w'(ÿ^{>ôÖÚol»º7ÿøòž¶m)èW:ÅøkwZ¹åžãÓìØí6rΚÍõè‹'Yv%¸2œiE/V¯#N:²xâkÖ›zçÕ{´o¥À¬2eft;gôØŠÏÎc%¨å¢v±»÷w|–á’X5ƒµRµ…ÛœDÿÖϪj§?HÓeTIE¬)ÿì—â©Mt°©*ANluäbö«éûÕž¯ÞìE³lµdôåuú‚(`k6óÞe ßNu-(Ì(­’ã¸XÁÒáN«´ø$μæJ£o«i6ÒÕõᇪ4õVÇüç«;~LõÜá¹»îY$"®¸t :‘XÕ œý<êd,©ú©×GHçº_ÉN©ï\CAãŒ6·s=÷E•6URŒÉ¨¬@¢uFV{W·¾ «Ì- *T•Q3Ã9ˆB ùëŸùÍT7­® †MB…P£Ú¯œ9Ó[}ÙÎê8‹„DäàÚÂÛø‘xWlÅKã/u<SÊyªµÈWíHÅ&ð*PÕÛ‹ç2‹þ(€_<_Ìæ‹×5ýx¹W h•yÑ_ô,ê'6Pah,&6…`œŽ $qj,ýLfñ¹èbâÙ°°Îú|¤oþ îè=R9ÆöpÈ$ä»®n/Ü ‘¹â«øÃÈUÏ—4¼£±FU&Sëß×fÅ•+Úêlt­ˆàt G;¾VÙ°7ÄÄ¥‡¾Ÿ|C÷ ‡»‘³ ®êùw¦v2"{)X4`„¨m´Üz™?¥g:ÆHŠË!†ñh«^–‰í/l†¥Qœ+ ÷TT°Çñ\éVÏF= ×öq�{’Ûç®ë½”QXÁÄðâéSn�YÑÕ¥`iå†$ÌŠ÷ìÌ3ÊÕÃqâécíá]7»¦A0|4xûÒÓN¬f&Ia†Zº¶Ð½ ·'wS›©îØÅƨú)ø58!• +-Úrß|ž‰YãF„4É^íö}ý+ð@V&™SÁG¥ÕYË…z:q/UõCã2¶]O_ÝuÓ·×WΖßè^gá,ò6%ƒÖ§-S3ðÔ"åo™±M–¡á0äAîòñÄèµðt^–ñ¥øõÑWLy*£â¸d™ñ8OYY(>”[ÚÕ.R«êÇÓ+GtÈ­S%Ξ„\¤Ÿj&-ÑÏ‘<É®ÿßTÊÓ8õ•x~<D€ Xíö”%bèÓ_Y tÍm{ç‡OzâOôœ¦-MGI¢Oõ}RkΓ7£Ço„Ö·)^—Mß*÷Π ”9ÿüëy3@à•ŽÌþxãú‘è=m4J|2¶�¶1x%ƒ³ðfÄþç¹h鉌sß«eïÇmë¦ mƒõ ˶þ^|é‡yö\p…TôO`‰Ù;`A5åTœ¤‹ðædF7IÅ”ôu ó\AÙŒmOÇK±Þè¨6‹Y‘à ({iD¼Ü»t§ߣ"¼ò¾&JÔÌ S÷þÄE€‰XÀíW-5–H¶0 }ÄódHÅ@I×Óžc'¿%ší8žÍËý`˜,\Ñ`7ÐA+lm6un9Êbì³ÚÖœ_ÊÝè[ÓÊÖŒ£2+‚VÛœ@:Zµq~r¤­£(õ]/’0˜sZã3ÓeaIkŸw¦thÆ ý†ŒØ«[ŒM™y^<"ÿÒUìbâÂ4äš1E^XG1pÖ! /»*ʀΚ^û·èZq¿KŒrìh]nò£›m½WE‹¼�ŒÞÎ^¢¼…Ú6×5”'¯¾D€ÿ=ÊEYd¾k3¦])Ý‚‹jV r'ÈËB”¬ùK^®57©M|³ üTQñTåH©üž.¦±0Ÿ¦†}Þ¨/C_R3Á™Â” ÛòP"hv›>FTÃI„hŒ‘Cý£.ëw5a›«Jã6gvRXå¢{È=³?|ÛíÔýÁü=³~סÞ†A岨’¬O½Í’~ëùÅU¡ÞQ"HHaTç^Ïyc$R+3zêœÀÐÝã.Ì,³þ­öyº»öybÉ`Jàìû“£å®:Š²ÃÞ(í¬GM¥â¤–Ô7ɱŦî(Ž¿kØèÈ-Úh”r‡AØÙ÷QA4ÆN¾Éû.¢Ý7½`è%ÞeŒ»áB·Íë÷Äoó«]U™Y›zÿùUû¯¡™Ðó^êë®ßýÌè«h§‹Ö-E `:Mç+úO¬R¢2 at$‘µ£Db{:ʬoÏx¡ŸÄd�ÂN"/¯WwõK•Ê46þåÑP{Š“Ûúß®çç$´ƒùK's7,, ŠyœàK«Ø_ü, dK‘„ Â8ÓrÄÈày¼%tê14Cú.´L§£¿¨r?2WV¿J½ëÙ_äµ`WåüÞ¤û°NÊ 6ˆÚ˜g_<ÅÅÂÀä¹k[Ú"/—‘‚Zû¶kJ‘¸q1O®t'Ãó“tïÕﺧ?1R/#œÇ¥©@nÕP•sb&¢]tèw¬ñr{qëŸøYJ Õ2("Ép¤wr TáI»Ö»¢·ìÚ=]É`{Á±O¬gÉH·âG;¶©|t&Ö£Kü.Å1i� ÚQ¼ØŠAôM–y º +J,«ÙZAâðÃE:ÇPú‹½¹Ù÷{ÃðŠP3CÁ(ªk;ê4íËþäè›”¨HÊÑtèæIO G &,J¡â\ìæ3Ïï+`Äqé?BZGHx�*7™Šg“ Øó»=Mœ_™\Ç)´˜9¤âÞi^dþ§ýÚRB× RN*›‘°s¹¯=®ÞÇÁ5‰8Â…+»uP²½Ö$µ )i=v-£ˆfû#ÌZŒè²»R˜l‘yb}BÇ£U7Z}½UR{ÑNÓŽ³È÷™qV‡`Êšk€G–öˆ ÒÙuŽ†û{n ±Y tE­ªÓ‰}ÁÞLP¾‚·f“8–¼V/»$S‚”yg-òRÛ§eK ÀuJ@kG:‡OÔJ³i°ö’yãëÚÑ‚åF›èÉÙŸ ¼²Üð9}¡ÛŸ ÂgÅ‚#3]v„OÅeLÝf7c„/jÅæ1d’¼ÿâo_9 ‚ìåÀÉEgÛ·Y`ÄØíY}²©‘5ÖZöe·J† ÞΆZ*Ea7´»úÚBKÛ鮤º3ÅqBy V¥tîÔßÞ0l˜¤ï|a†ËâÔ™ûÙ0毣jf•ç:N‹Ðílh X…s0Q…79ü°ý.z;Ôi¡<€4d ¢­ üž¬Ñ¬ X’tB¡Ñ™Á}è+‹Ã_*z«€Ñ‘3’ÚdÛz6 ûK¯U€}¥›iÙhÜ/#ZÑ:I>Má°ÚN0ä¡:—Gv”OåQc6céY•èšp×·‘Ã39àÆÐœR½Ø*i¿¬ pÝh72ÄpÜõÜÃY�=»ÙG!0-]ª+9 hšI;XÃf˜�ö¦,¿¢iƾôëÎÎ µÀÈ ã—f ÎýŽÓK& q`´ [ýî/Ùhˆj+ZÓE/6|ÙVZ’®×–ɘN/l_ZR¹|"7Ú±âeR†ÿÈz (`þxœÖ'Î%QâQÐRnþœé ”Íàмp:u²È¯¸I¾ìy±ÞXNź¦jà(ƒnSÁ½ÿ~̓Ԏù¾ã½xŸsí b ææÔlu¼]j3ß5Ï´àÆ’ßWâ3¹éCªÑkO,i`ÆÚTr |€Hìt‘î÷£ÊÝ6蘶̇8úRÿ‡ÙfƒHIº¡Ác”<o1ózUþgžX ïl@Ì+:‰àxyÆÇ4ÑOÂðxø·ÆX¡ã$öwrÀvDR1Ǫ¢¨ &ððmE/ àÎwó¦nX’((þ¦‰]&æ„—¬bþ¾ òŸÝÉòyز çëûšk¾å‹ÕM³óG¢H½‡ª…]W±ç0«•©éR?íVÇ^nJ+»ŒaÀGk ¥Ñý®¿èÄò-$pêr¹Eµ‰U=`ÞñpùTc\×XSâUe�Ýe¸Î%’ê ŸÑ³…ÑNcD±¯"/YîE45- iþ�aáYð ËÜ:V±•f^™õŒV€b{Ë›Oû›Qdœ]™ËAÜ&®ÿµ>véúš¤ãWÒ69(�Æ'‘Óë> Ê­ÆŸÃí¥£‘tÅÂÂÝöWÍÈÈBLƒ¶n�ÖÊ~NÞmß@ŽVQ \^ºÅþ'Å×È…r±Ÿ,ëOߘ<–@J¾çCù4ô%w(è¯`¥Ð©rD¦"w´áG;ô1òµ±HåáÎY¥h² µg ÷Î _ä¨nÆ)¿ç…ž@}"BHè·YïPÖE;M*,¹›³õ{Ûá/ý.@íë´ Òù_'ÒÖ”iã;ðŠ;n/“À ô‡ã¥]ïú?zcD5¿}—Z¹d%â…ÝØ6ÛÛe«µz©Ì!iYÖ+ë5Žd˜%µž]IïŒÌòÌ× ÁN+¼gg®om:T†¤òîè0I½FêBÔ°´î§Ùz[À³pÖÞüa‡îó?"unËcѼ_Û&‰Ç.p²¬Žô˜<ˆ,H;ÒkµHÆ;´Ý(K}O IÎy}Ž–­nÍå¦}-ãJÿSÒG$ØÃJ…‹ 3îì¹°ðUm('œgg×úg“Úqt– :ã)1«ò™j/œ(©Ø„*ŠÝã ÃOm­±«YèÄë =Ã([*ªÒ‘M+½¨u˜–ðL$n™]‹¾óbÒüDÝ!±…NS-T+¶9}€‰¦È¯TãÊúR‰çÉœùúÛÚ E7ÀÖ÷Ô ¬—JlpF‡žîñüé …ˆS(ØÉ`ïSe?sÝöko­ÈK— ¶mlC³®¢–ÑVÜ 4J¾Æ¹–i´¾Þhy8’wÄM Õ–ι²Þê Åãlæ#Û¶ÁaÐÖ-/Ï»‰Š´«3µ}+¡R$ß ¯èüc%o6°™¦Å!|Þ~žùFšùH âÑ*.ÚÖQPy3®F)åA·8¼2ôáäôŸô]ÄÛ­×qæ©8Ä­Þb¢²<à^(°lÚ´L‹4p­NyÓÌ9¸Ëëáx^¸”ªtW"Š–¦[ÉÛÝÊÆüO1ë6/²`ÊWdU´˜_æÁמµ*K�.¹¢S7ƒôì;¦(ð#ßSÕ¨ÍÛƒÏÌQ$·'„Þ½¿ÆñD÷®ïôþ¿aåñ²˜(¨·Ök“ò‹sôiµÝuk¥Ñ¿·Å“Äe*†´†v‰-SœœŸ Ù"J3Ög°Ý53Ê K*Cû?ÃD–NÆÞÙ÷õ‰c'›Ûnßaêµ—uýs[¯Ói³É“4μžwF‘ò¹MíÙê¸:Ë&̯}º0âÅ3Qù–·:YgùéØkÄšVHӳȞê<¨ÕÊXHHbq¡PßÆTS¬ÇSoÄòöðL—2,1ÛMeͧg`³´‘{î1•%Ž{LJØÒý\,§Fš¾û·Æ¤Èì çL÷¿xÔAìÌѽ V<€©„#þe0ãÚË—â-:AiNÿþ ÏŠ›_¼ÑJ¯²p¡Ä¾Á€±2éb8J™j'òÜïú,ÆQìÒ&ÀŒèUÓÑÙ% \áÊdýMÁp©þY—øă'fEU"l®ìð@Ùw!ò›—¾m#‹Kù¥±îÔ°/µ=ZOeÙ3óµ?@LëZJ!.Ý< 5@ªÞ±zs_5$ÿÖNHdË`€àIËm¾+àà*—±ý¡ƒb»1{’·ë÷2t͇¸~H½‰ÓC]Ó[Ðÿä-¸xžÇ–ñ e9ÁèA8¤± ú@pk’™úÉo^ß¡+ßþž[Nª§2æ^ôs£3TFûúÂ^ªQWÃPÐè<4úª<ÛQîÿ0ŊƵsjn'øZ»Bx{fpÏ_Ý«~è{”(+Ô¢ÒWŒí`sVz¦DÈ!ÜþcáýÈ ðg‡ÃÀ,é§YÐëfª}xW·S=¨¾bXø“ß”î÷L/S'Î1&gKI^ô9ØE×ïèßûT«`K™Ðe<Mï�ú ,I¾•ÌåÁÄ·ý먫’YÎK¤?Ž¬¹2™ïËn’•ÎÐ]tý�ÒžJ cÚÍ—½óí曡³–7„“ùÛQø9‡—ˆô‚¾=µˆïüÐÅÄ*öÓ­‚±ªÑ±wnF†…>ÎHõ°j½¶BoBÁ’fIP4ê-PŠ=´WéþM߈ü©¨3|‚Û‚Vþ¿Ëm Ÿ}}FC‚62Ì©†4;Y¯ø&Ï)R_± ³À"*KŽËE¦ÞNŸŒ“èŽC4K \˜=SÛŠ`ãÏ<çã³Um;JÁÓߤM ÿ`nE J‹2ă䯼weì`*©»¿ŽþS„±70=“‘ÃV !ÁS={–š¿‚ G´”ªÌ¸A÷“@ºúDz˜n=]|Cœ†> ¯Ÿ+ï`…¨[dT±o^R÷ž Sä93SC#Ï5ï½Xm®Y Ÿ¹™PÁ( e…¹9…šÉÂÞb…L„ê/núZÛƒÒ|Õwü¡ÿø•!qŸ6)Œ‹·–ÁƼÁ•€· &ÿò†8¸¤•Sª ßL7ÌÞÌÛ§|LÙ½xΔÒ‘ŠƒyÅÔµ´OÍ‹ ͙ϓüî/WËl©SY³Šò¨“h4fà\á¿Žñ¿ò¬ˆ ¯°MÑÐì{ÌA'¶2ân»î:Q‰Cq(°³púìèx þ%&x”k'Õû[m™×G‰ÑÞŽxp,çìq¸Òã^£ iÐQÜÑ•ÿåW­îršg,>»�^l±`sÛæ^ÂÑžŒM­Lu$V95'êÃ`ÜΩšÈ#¨]ÖNÍŽ¡ÆÜçM’Õáê#“bƒ Y›’Ô³X5L“U`¸w‰1¸òóÄë,£­ŠÕ,£uö}Úa¥YZ<æpÜh¸6‡ô<p–„AÛS¸Úv^W¬9P ´g_[ë\áõ%kŠºœšAMóŒIëæìÈöc_[ÊV8º¥å¦7½ÙÄ–E‘Yý‡À¼¼I“¯4€]&ÑëKÉÆýZâ<μú5¦MK?gÛOe„%„;þ—@¼î]ù;ׂ<B¥K!àV›Ñr�kl¸ rî´»ùÁup}d£<r"¬87vIZ”ThàdZ.AVNäå/ÃÿT©í Š%ÖjMK<ï:g‰ÍØ%‘C£UÄY$.®îæ—á,Y(3³!sÄò®,iwº:x>x¼ û¨B×òÀö/‚ÝQUýDí@;Û'Pð‰Þ‡h­v­)n&Љ¿ý® ú! Òõ¨ ûRqëS¾ô$@fÀD s™rç‰,Ddm{ÅÊ šSTG+,Z&I8Øué];ŨTH¿K’€Z-K곂³ýÍbÕa{¢™è{…Ây!Ï@ÉE!36C@h ¦ßéBæ¾T‰$‰ô`|¯TùYª¹ÝF˜~×ÒPQ®ß¬2Ò-ÐÞÉ×ê^ö<;$-¸Í¿SÞI › °3FÐÐiâÉûÄ"Í°·ž»ûŽ Ë¿ü«Ç²x®¿ÆlÂvKE‘U}åElTéüÈÕs¸ïœ3ƃßüÓwÿh˜?M&²6¿rà'\Ø £•;ÌxQíw8ß­ìÒÜ7Ý‚ùâT0üÆN~êV¡Œ[ ö‚…¤ÜŒûÁõ¬§~ÎÒsJð1gó¦tÜ2ÜÍ`Ë×¾we§Jû[#’ØgæØs ÈÁÑ Y€1(v°ø­ÝRå”}Ð*ñ8Y8™Ñ¦Oƒ›ÑT²¤‹§´)­!›F=VXi<ìh•Ù JSk+¸&—å×…xv¶H‚øÛ}~ú̬¸n¶3¤ì†ÝÚ†*€7wóQ¸ ¾ªâ?üÿ…wáÈ|ßwþoÕjãEöc_1Ü9ŠlFÃÊ6‚ ùվ̫^ÄÌøqŠ‚êûèùóñ {êŽVtÿ,I©¥KågxÅK‘׬pˆ¶Š+Ìš*Ì­u6´2wÜC¶sùBïâò<eÛ "D–ÓZÍ©p¶‹»bKé+(¥Ÿö>ô ÿR¬ (CϪGDþº7Çë ŠÅºÈ'¾Åê×Qj J‚†\­Qžk‡éôI=ÛàôÀªØYG…ŽÍRãì!‹úx4·@Œvª7ƒ¬[,áÇ?x{1¿‚¯ç’]ºl'ž—±ƒ¼¶Vm^¡ÿÃ{“ÂD<«ÐE+Nû·@v$^AWD@)ýJ…YLc§î«mÅe«ø>#©¼>ü°*"¦—/‹1uZzª‘…Ø«Ò·É•�Û3³é8[Õãau¾tÖ]õÚe52€5‘•ŠoCu_ÚêÁdtË@Œ²‡4íÓ£ šô╺teÞL<LX'2ýéÝRä·‰CFaî3ÔªaÚò£Êß•±Q?ð ôþRÄ!óÆtÀ{ªt²Q‡Ùgc^èõ‰+V°e°/Ó´Ÿ¯ÀGÏñ_ÙÒ(ÍéOaëQá¥Õ¸ÙÐÀý¢õ-¸>6»sÈuQáíš%‹ZØVóØ Øliÿ{%Åh“ãÂÕgºùV‡Ûª‡ƒI'S1òé”ó·íðÔ »v�5¯tŒÕómvigFFv(á¿2hIݸq¯Ö;¯h~^÷1ü]‡ØöòŒ5È&ðz¸¡a(ú°¬R*[EÌO"©Oå·^ªºþBh?*R?„Ôã™îa­š‡›î0mvC­ÚžA½ Òÿ9úò<„~OáLDÓµ™N‹m7Òw™Õ*Å´¨ôŸÌR ‡“Æ<ìÊ‹µ*ÖÌ»ÍP£ž1û§ZÒ Õ·üù|ÅyöiPœìÀ“*€�ó_+'6¨ Þ+}µ$‡sKÿT¶CKçÚ„7Íü ±…Þtž9ž» ¼µ,D¬¦€ÅˆÎh`5Eï«Ú׈Ä9õ†$dhm8ø¬Ú Û‹üTýÇâ8OqhÓ'"‘õk™äÍÓö´ZõC½!ÐÝKKëYººÒÊêO9«Ž¤+ûzï÷ºÔ ¡ ðIGºû ý&Ž _@”… súƒ'‰KpöŒcßqN'MBl_*wÿ/XNz©°JÛŽ=¥bEÓx‡öe0ÄÅðÓF0z˜‡~Ãæ\î)à yÚw‹©z\TV«ÌtD´9j9Éy·àr¹zñ¡æ_Ãá,:; ({¹èydâçœXà®z Þ5qŠ3g§"Óÿ†Žòê2XØ `T-$~-o’-5í)J¨‚NE»E êø9Ö;5Çiw @è#ðÜÝiqÂ=°ýp:Þ|²RVòÅ<Ÿêšú=Pð€ìIg$:8³aOJ ÊTÆ6W<ñ8.ø`¨ÏŬ@ob’QÂ`CŸ·aViè¯Ðs=⨎][ר½ÂBG_BÐg'$ÄP²ÆúðOs¡ïÐýã¦9oŽqRŸCfhÿF¬÷í Ž\†š*T¥°À~¤ó­BÉfüXâ0CG­]Êu²Ä†9/·CšºÕוój”UV MR3¦nFß¾ÏŦU­ÕwÉ›ÞXºpã!©‚ÐNc!u3Æîô yì÷!JÆîú™ -÷62¯©ã±ª^1g<v˜v|üˆ/åú@eÙ/¼ âÊ'ñ2u! ’F³åœ[£´À¡Q¤=Ø—u¦5 3”ÝÂïûâ¼saCÅbÔ®uxî Œ^=Š›;(‡Ê'áRý4$ �QÇã’ƒ8’ï‹Þ>òá.W³ÏñØÅatG½Ë3[³‚œ`P1Ía=yi¢.¡7Eì£IÄø‡~n.žå>wP åÐØý<zõigÒˆ(ª¤Aòóé9?wBÀ3\#iŠŠ:ÔHxa¢T3äØÄÞ¦¢ßÍ.ÍwÃy-"R” X (ŒÅ,û쀌? ž+¤–D}èÁå®b•ú'Ìq¾é³ž¬-%6w7ÔpK ;H°Ö^ÖýHf½ôÁ÷l9YRŒ œèDøêf*štU½¤™öòXÌl!Ô_ƒ( +†¢¸¡»A‘T¿¶‡²Ã–Pvd†&)AíÚÙ2nœy f@÷„¾ŸÀ®Þé‘FqîËó£EUSȘ6éuM OÃÕ€m‹¢Þ™ûλ°€8¿Wð^œ ªtO&gá³ ‘¦AÑ{˜„ž¾|]4íÊP­îÕ9Š~ô| Ô´ð&£Í~î\fˆ1åÕOÖÇƶüéÁm©Lú<º3Ôj\„k 4¾i÷µòqX¥A{‰Lµ›X3¤£¹UuE�¹¸˜çV´ÅÜ×€I² 0J(ÊÒ7ÿÔÝÁ1BšáÒÏ€ˆr“—׃Ô4Ê<8s2U”é·´ÂZ³Ýt1Ðx|b€û׃gŽ¬†‰¸ýD8éÏÖÃ-7eý¸S4 ™¾½8‚ãØž:’?ô@ÉŸµ‡Ÿ„åíÌ.ÇY¿\g4ŸÊ*óÖˆ#Uïeý£Ý»‚£TQùD•£ º¦9Y⾦ vúØ 2¸ú‰‰w‰'DK«ŽÞ¸Ñ²˜r;Ø”êü%UÁtÔ¯¹ÄœPŸÑ ¹yöYê 9Cyö5Ÿ¡cñiu,@ª¯¡L¬a¦’°hïžÖ:•À=S…§ÛùtyÏ&Äð•þÚd—\²E1 œXþ•'%zRù"O,C™á·¦¡%‚FLJš¼Ô  6´<Ù3 Ü´Ja™À¥˜¦ý.wf Wö7Ì,ÑZäÌ`Ê'O¾v_;¥.@èvÿrïú®ÌŽë€ik>‚ÚW+ª¾dƒU(ËÛ¼ˆ5–ôßꃖyPa9ƒìÔ2Úo®meɯê£ñ¬}O•4ÕVµï…%—§ÑVÓ# —øYÓš§ø»±Ëïwj„¶ìÇH›†¾LÔÙN,Œé8:„pcï:‡®M‰^\ }º4¨l/§LÔcÑ#!ÚÜ5¼Î]EPà�”vCž@(BŒo3Ù“0¼r49NØ}CãN¿õth½¡ì(›±ã=fyŦb^íi‡Ä[-GŽÓŽjšÚ÷Í(¬J¥fÏY. ˜ºzïÊrW£Ìq`r‰ç6ap £¥nÖŸfÝ°:€Ð‹t´–?·PAxåÞ¤ÔY»ª–…ˆáÛa½±Òü㟴ÔiÄ•wÇ›°*ϼ܉Ž%Þ¯åzc¢ ’'DÇ%xk¿Æ±sÆ‘yʱŽ¼V}Êl=.ä„ðfìdÛÊ¡/Ž“RÜÚ¾"+¥IàMwuwÛ<Û@yv¥^ۃ͖_•@œãéÙŸ«sÚíÅ /µ(äÓD6™á ṇa˜Ñï6¬–Ë ø£5²Å^­‘#ŒVý•Ù“Ó—é‚AŸrœ°INO ôÔñPóA_±TŸabn-¸¥Yngè'h?…vdËÌ6_¼ç¤2Á[ÁuÝŒˆ•ó ½:eþkU_|ahKfÖUÖÏcÚ«•¶´T ¶”Ëú³[ÚS·ÂçØÙC“…‡¸{þÂL. +W$8?™öZŒš‘ÆȈ-ËT9À/x¯ÖjMäO(0×-´6xJ,vÖl‡Ú\Þã¼ÅYž--f9(~ÏžÒh…Ê]&݉Ï»áÐÎô£ÈìͶ§ «ú<ºjÔ²¶9kÆ!±æ7^�ÈÒÜ+t/Ù´üÉðžÜkœ¡yŸß˜Aõ:¼¹ÑÉø/‚¯(9)2Á4òØ­ûà?htN÷‡s3ñBêï ç¢ÿ$žŽ•:ÓâŠ:-¶ÐN?,&ÐIYóþ´Ùôš÷,óÔ§‹>êStù« XëƒÅ׮ǗsZo îD^-ây³ ©yTY#ÎŽ|'?êqœ`8×Ewõ„óÅéoEÉñz\á4xþ¸,ë†Y½e…ˆõËs“¤…¢|.e:Ĺ.Û3ì=û9Û¬b\])bë-“™vd?äAµ>™ã–>îî¸õPrÅ hˆÑšš-fU(‡ù§Yºð=/‚¹È¨xÓÑWŠÑˆMÊÒ‹ìÅÝ“ÑÈk©aÜjJ‚¼¼vèås«( ¬ ÞczqG7‹bω ¦aUþ(O›•­\í±\Þ™óÞÆ|•6Šã2çN›ð”ŽpŸù´9Ì\Øëëb¾:×QJ‚ìP±µ.Ó£I$Éÿ„RÅnÐÍ °9ƒìbÊCæF‘†©žgÖÆÿ­È¢ÓÈ®Œ6Ü|¤t¹ýtÆõÄÖ3<`² ­&S¯=ùQEtö 5,èÇmãePÒxÿ Î^fL‡¥ÿ³kÖ$¡'üœæ˜Åqí)“~Öóžý\ ì»táªáŸñÞ¥ÊèXKñåMØ8¨jŽÞ¬Pö•Æ¦¬ãÇ8Š½mäÐ~ÂÝÓ6,úÁ›¾õ§}cü:¦Ã¥ŸŒò¡DOõWâÒûŒŠ‰žÓÑ[:ußtN,ã‰<:.ÍI´úSz¡bgû§ÛÔº/éNîz¹%ÞåC“PÅÀª‡lAÚ­-Ô²Sºâ­©,ôÅ{_ÿ¡+O8Ø ~FG“¦ç%õ/È=s—ßÄ4DUîgjt—?l#•«%Y 2*½ ?X0g3ÙªDÙÇd™,_(‘ÑIiÕIõò’ñûqW›ÎOϤ‘»/8òGZaꦧçú©f&_Á®‡]%/,«Ì‡æPv®‚¤?Ù”}E ûâ1lþ¢]Wz¶¬3›à¤>-¶'­ˆ÷ RûÖ$øί8%ç2Ä]…ÂùpÁ�3HÌÉšÁÅÆzÞökGðÖh¬òP)s&J°*ëNƒI–±[±�˜Áôµ`8ÝÄ;1>dã¡ n««¯îp˜/ÒÅ26¬�«Pˆfû¶þC±qyìÙ\¢2ªŒØA¹UÂC{|_=Z¯üôþ&*nFa¬ªSóu§ÍÇœi½}gÒ[ô2 …+U‰ÅU¤ÓR$÷V37ó"BÆqç̳ل"ø@Ýaàîùü}.íjÑ>0Ž5® LšÎ§Í©¤póíUš8´×¿ÚîZ %Öä0JÇö<“ƒ¶ñ¢zKÂ…Ëa LNdŸ?ÞdÂ]>÷ô—ó eQ+ •Ç g}‚˜P­3|˜½s|b)ÞA€.×_³ÆJ`N ”•9ѥ镧"À72d¿&‹JúÏ‚ÒàBÆ‘˜m`ÿäj¥\Pïr{Z4:¯&„N‰o§#:ÚÃíàö\"œ€Á¦é‚ÚÄj|ô³o/WNÉ0òóÿöÝÍ©G'È4å$†PÎ8¿�s "ÉL¯ˆ‰ã¡äüÇ�Ž€ZÜÖÿö*ç.ãÆò'qµ¶1dI¬öP#©tNhiÎ:·ºŽ©šwèž¹É ʤò’ !1ÒI­Ü1øüèz[]P+ îîuŸé˜È¡¶³´l¶5Cƒ&Ÿ9ô°N’øèÙ9r7ò!ª5.<…³„‡«[Z>eßX‘aÌ>Jªò‰>ÿ‰AE¹ñ‡pì¥iÓ{Þ›z^v›A¡’T ñ—xǯ×K:$C˜°¼¶ ¸é0à ì2céiñ\:SFaúµì- ä‘ýºç\ÆqæLb5c?êieZó }rí¥_9²•5@qSSPÉ·Š_cM´^êwþcæi&c&ñÏnøgç2Ï÷)k¯¯¿2çÉþXÐU¨Ùà†¯ïµCÁ„Nî͸-íÝ*&Y~þÕ"»&Õ綃¸ï¯DZq/¥ö²¹wíòøjóôp 9)âà£ϲÝõÚÒ|Õ..½ÀÎ,ýi‹eÕX¨u%µ2»Ì±@±I»~]ög\ŽÌø<z_:3.~<þTÏüOž #Ç£Î]É¡gäâ<¤F²ˆã¥Œ’ñèÜY¸‹‰ÜôÙ&q³…uq^é|‚š™îæÖK×1ªöþ‰¬_²3­õ¶ %rv€+;å6²¤<½õ©‡0Š\4$_ØÀ¥‰û %“»gúÅñ_×á5�wAä¿! ›W®†âATƒñvñ=9¹­È³ö9EX ÞU;ïÁ¿~¾V¤°›Â·M KDsãQôû q)—­á½½xÞ^/óE’œ°·e6|ºF¤| EÁ=ø#.áµÏgºÉyãsœ÷$W§ðßï+'az“tx Mt¼Ï£ÄÅg­ÿìèxš<÷3Ö$¯ÒÊOª‡oW› ¤<I·ü.'óžfêɱÔ|¡Åy@Æ €ÿ²p€%Ñçö’ßÛ°çô‹´“F6Õæm ¤ÝÖ‚ÊC Ꭰ– ëçOÇ@p¹ÂÛªY•1ù‚^ëV¿“­ÑÁ)êœPà]•œ7s¿¡ÈNigZŸìµÃø¡Ñ.ÈbL½úƒyèÚÆ­1j» 2¿X£¼C;ÿTh[føq8aé.·B@·¯eÉlÃÏÈO38 ¨/­ûú¤RÚ¾lT³ä™Þ¦-\î»ãó ' ÇÃs;zœÖäZPÞ›…T´ddþ¿>33ú¨ŒÀëï˜3$CÓ›|WÁDi±zÌiÊ$†ØâЧÀ1ÓUiO<¨S7¤ß4œ“«ŒèÅDGë)%$G$Nlfx¯ðø,ãñί’ }÷"6oéç¸Âvô6·ÑÊÔ†‚>{¼¶kQ©ÅÁšP6hëo f¹2"Ê;ÙrEóiÛíZJfžŒÙKÏâ —OuoÝÚrH]'á yš¸O>pYø”Æi@ë±° ¨úà?bL¹il=³SÊUŧ2,(ÆÓÚœ c=Ïƽ„7~Y,õÌ^ FqhÑä‚“:¯)îoJ㶋aq"v46¤nZøP'>óQ5T'45-„jüñhtê-hG |“÷jwãÂA#u99cyǾÒéÇY8pJg s¿’Sˆ2µD ‹c7‡â¨P�¶¬Ûcwô¤yŽµÏ”¤P4UÓ6ÅÖ õöœž[×´€#=A³~ÿÚl:I‚tŒ]ß žØê"aÿäz7‰“¯açÕÛ‹ÛYÆ™g/û¤MdÇÙãQª.ð5E¢òPd<ïm‡$HŽ ëÀ®ÃÇ¥o×ï;IÒëi/`£7 ¿óÔ¡‚E»wf¬O­(¦ì*U?Öco`ï7Œr_–ETFØ壊MŽ»Ÿ]'6Éè®Ö.0óüÓ9ý.‘IT±ÄÊc3ÂvEfÖCíü‡a(¤†€à¹˜‘Þ[ë¸ ”(ºñh­X…úÂO|Ôº~ùòØ&Fr‡½X ÓÑØx[‘Ͳ8ÔmMçºhwÚ«Û>fgá’ÈØŸâ Ø|º¡Ò¶¾¾pb¨‡÷/$b"ƒ�H 4|è ÙÖ©T´ÑÉu’0w³W¾§åóãj‘€PÜè qwðýÜÝ„äû‘ÏJÂû…Áêe;¹²ØæÙ­|èzoþª’Q¹1=¯³ œ:7rvŸT˜²î‘Ѫ€êªyy‚Q|R(€�ñ\‰'UbNÃ@z´ë8Zr‡[xŽï5ñ`yàÅâ;–2e�Œ/í,‰šãêÀ–vVDfKy%îö½üLC9÷÷#­ ¦Iƒ|–H%ºÒfR2 »Õi®kl;J0 þåRq§Êƒ‡ÌÀ(ìŒI(0RFÌ¢‡u¢¸‡¦p Z«T ÝÉ|srB}+È@q~º›t&³Ê¢rx¢?•‹Iü‰ ßvÊ\éXuÑŸŽù_åάò Ú²H®ôŸ)J¬G&„¤z™ëÞïŠ<Ô’ñ 9ƒ›€•.º­W~Jî<|ÜÛÔ,c×™Jð±µu¤M_KaÞSU]ÍJAãO«D²š¤ÄÉ`À® ÚÐfVvTÙS-eV„(*ÚQ6BgüöEQ©Gƒdånž™–ßµËÄWCÒ«aiš»”ZÌd[t*¸—áƒ.5ÞNÈ2¿pWÎ<>NŽm²úC)µdÿÊH~àFÙÖépŒ‡¹ °Qc¾Æ2$®œ—Þl“GAiÅ\pcÕLÓ*YÎJ˜ºwyǘ7_¨lDA{Àî¿NÁÙ|~#­h¤Uw<Î2/eõ"'6"œ¿v ÇØn¬ûrÊ„ÈVÚ»ÛîçWyU{Þìw¦N½;B:ˆV<²}Ô‚ÈrOÉ’wv ÈQÁà ÓB3T_]Èßülûãò»t=|»d›Þú@…Ü̇Aópªw ßÁP+×??90ØŠÀPs3P,ž½ ioÿ¹>~+*³¦‡ÊÙQÙI.>|ÝŽvëù`Q1KÇ5‹àl;A[êëWGoù GàH3ghŒXƒ„KkÏ&¬ì*YOÃhGœÁ±ÛmdŒ)—ÍÕ§Œ— XM”§Õ®xrþr¾wý×,ýRsažä=–Sbé |G!YÃS›îàdM:R-Ž†U™<LZ³òª“Ï·¡êZ½:0NýEo^߉'7E…ÜŒJB%âd‘EþAòŸy1½Ñ='‹ŠE'nÃD`óH†± ëìÑI;âÜ“y—»¸¯œnï³5dóÑZÛU ~CÙ Õý™·¢)=oG¡ 7Es÷4rŽb!È?Ti|k ñ<† }©ÌÅœÙ×YºÔ $¢€n™§œÚ‹ÔN»9)û„A?‘Løð¾�®p<ÂL y~X§BÓ*ƒýäï;Ç뢚ŠþÏéä{p¦`¯ ‹iÙ…{á}u(žþäíÁ(³FíðjrwŸ;P¥^Ïeæ€ù<ÒjÛ‘»¢ÈÄÛÆ"ëÚîýÞƒz–3ÆÀ <–-ï»ÍïÛìïëQùçÈÛ"F€@d’½nœ{ÿ_ ¢xäxTõ™4ME]±ïrú¹¶u€\]C‡²ÍØiþòOÛýÓ×ÿü{8­¶Š\dåáå0ïf¶—^9´FÁ@~³17K5™ó/D óîâ~×ñÝi³ÈšÐ?ïzO=ÊI&ßpâçDÐ#¥FtÀn¦ ¦ÜZÆ;ÃȦ#>à‹Äo@_ªôÚ¹'Z{*jÏÉ% \ÍTï4R¼+arTSðÔˆ¥sI(PÈŸ”¾ã\ X£þN*MÝ ’§Óå§ÕKÉYêE€OªòµªŠmÝÅÞ´Sõ+«ÊâäóàÆ‘GªÂÙ|B{|¾æø_K•ûÓ²õÊH…PqÔ>ø[MMeqÝ¥ûû¿äJ#¡| É!ÛŒ¦‘¨]7 GžàD}Èøø-Cm/JÑÀ–ŠbÈÚó¡ÕQÛ£á4Š]ýpìÖS½zÒ€Nkætð¼ùüðÏqRá.¸Q¢}™ ÉYÄ¾æ ­b†~PÁ w@[­‰X„ùzŸ·�°µNzlÑ£’|åoÊ̳³¡ûßÀµôhu«¡RE[eXO�ÀYÁˆ½ßʄ׻ˆA/¼˜Ó ›í©‡GÀpÏ)v‘ÙSOÏùü**³‚JsÙ%Üž†ÚPu²–à 'óO®šN/‡RÏ÷‹wûåˆwVl,*Á¨d³>¯¼@!¨ÓÃNÿ¬,©*_¥c/?~9�L*÷Ï9ó›²avx¢~÷Ç0 À‰œôõŠÝTUnY” ç’ ;Z³>(ÿŸ£d°^“„Òj¡ˆ”Ò»†AÞi÷ŽªºŸ±ô…“x;AlAožÛ<È&}JÄM§,ЛÌìódœÞDˆ ,HÎw[+6 ¦øwžª1Gs“Ü­:âȳ&a>þö' Šó§›6íà=v¼×á<íô†?žæìO@føZ  äh_Ûœï1ÈK Mœ\æ#­À´±ˆc Ù—æ4oÛà†›³ÁŠPð !é=¸`œdQš[ ýå#æŸe¾s~ÎÚáfZ°Ã™wÖA’;ô`.–7ŒÔ' Íxª"T[£G äÆšiàFIÞ£‹ÍeMM ¥BUáðíY`1äP‡G{«ïwâ%ŽUfm®—ïlÆ¡i4®/èŽ)Dª`mx¹jgr8±”aßý³¾Ð’ Ηéº}l麥a=¬¶E4:ÿã䆷A ‡òÍ¡s£g¼­iÁ˜Åï]­fO²܇8äq¶¾|4›ôÕO�tsîú™ŸvNÆóÁ]Qý§05Æ­M õ±ÎCÝ·§Ï<æ®@ûC­v•œ¶Øôš…qZÀ= ¨&ì,¨¿Ýͳü#=0…IyÂ…eéSiOíÒƒ­ ?×4Kî%ìXhïʪ…‡>Ú%Û6¥³~ö¨eHДlÒxTØ‚¡oê}6ÅàóôÛè¨kË.ªèèi+²} kQ,8ÃÅÂà’ÊDZ;?W¥¿è¹Ž(ÃëiB;ü0,ý k4#«özñH ÍjHF™9`Eêd´úuÀ/QV“Ô¬ü§:'v›Æ<™Öšå C8ÃÇ”šO,ªp;ÃÊà×k0¾Œ!¹GY Óyû­-IXÍŒS=RŸѺìädŠRõ <ŽB¿ãΊ=8Þ² }ÊX‰otü1Œ˜J0„¢ûNkùÿ;¾Q/œ›3:£‚U.-2<¢"5_[æÌ+ZÍÒÀ–ãïΉxuf•c²KC˜ndŸG#<ÐÃÿwþ8võÇÿöÙzÝ)±ÐÇ™kãYùygÉ0îéGÿÉ2_HšOu”0J@ÿ «¦•™ ¯.ÃaÔ‡ zw�Єçç¿¡J'-2®P@/#B[‚ùA[ °;ôl»œ5´ÜV­’K‹ò2ôð"úJï7ŽV+ƒeH÷nѵÌ*aÇÝçqÔã5†2}šè“çcï¶EöÕÖJ¶õ¥×áj²ó·0æEæ?Ü8¦Ìk6¤ôðÕ:g\ó›ûa mIJ0»ÞJ+º} ð§q*IRnj1ù™•u6eõ ßäVJÇ8žñRJÍ­|}}‡]xQ—{{ðsÚY‘/,ÃÒs'ÏRØêÖˆxy”®Ç\Ôd‰k¦|ã®×z£±P&0Mš¼ü¸?º‹Gƒ ç,—›VÝ—A~Q¹ @QûnÏf ¨r<_ ñÊöɯ¶µH£Üܵ8õ¾· V{Hž Ç ô¾a^p¹Ïfª¹Ó®A;‘;Cy*µ{{R{É–³íC¿æ3}6âÝ–%Ù¹ î]¢/õÿþ?3ÚÙƒ‰àâÑ|µ±ìSŠDšê£® ²¦³¦¨‚æôÀ¥LúkœGo ÿcÌ‚ ð kmã&¦‚G˜orM²0óFÑàÃ7e~Ξ–cÛTÇ"dx£ðÜ•6)+Äz'ä. d~TCçp:©êQ m|XWuƒ öç7Ê{¨ñĘ´X72 Û -Åÿ~Ä9ðg¬)$mG—?´ÎJ’pcË‚á \BÛ{tæÕ=5·÷ísµ•¬y­r Fû,ê;ÇÿéÃèNšp¬úÀbe' ãá¹ DPXº…(ÔP| «Cû§:ÃVûkýøð'0C!“3ôˆ°7 ©¨Ì®<ï÷_ôŠOÕ-t%ZtÓÌt~9’±‡ÔK¿ón‘~ó ÿtì=ù{ ¢t¥=í ÿRoTÁå�Œí§ÊOš#†'q<k (94”Ê¿e-+‡ÃdÔ‘ ƒ·µÏuÝ•| êT»Ü´Uw£ CŒã"Ú2v|ûš¹ŽtÄ–¬ÜãÈ/N6’)¶¯y¹ž•ÙvYb›Å`!%r”Ü@ÆÝUC}ÀTÔãÕp2“ ¡7 {%V@¾}Þ²Š&½SÒVnÀñ)Ïþ ɨ ’€{Ú &ôn/´øßó\(W ¨|f=óú€¹7�Ç- Ã݈Y„~®”ØyíµW¶§~º_0!?,Õªº½œ¿@|ÜØýØ §·=Šéè]Ýß›ùÒî‚VȘÒV±8®Œ¡js8y¹9=¯ËÄØ°Õ™b\ ™Èi]wîÕ‡ÿ)õªc}K÷“ùX7›OØéÁr¾ ¤BߦVòh›6¦Ð¯¬‡}ö{å×4–Nó—�VìÓs'Χq¹P£{4AX[3Zᣙ _Œ€¤T„Sw¶I8+‰]YEÄÖ¤,4L«ý­›ð\+’'a~œSÙ,>0ÃÁë×¥U‡l{)PmVÉКO<mwH)úzG{6ôŒ|Øïk!ŒRPíÖç)h/ë®õÝw¸ŠeOº& ª^禈#µåv;M§W7Ä5`9Y@”òŒ4¨¬à/Š0Vy@rJÜ4/áV[Eÿa{q=«­7g{Ã:ÀS„õ ¸2Æk£/ꄉ3`ÖfßÁ¯…‘½öâ â—>›H<Th)],“ñ ëªqÆÄŒ”jn"„ÄÛY `@”~ý‹×H hë EèaöT7·°°iÎe_ã&ò“¬”×zkã·Cúѳíź…ýï´ÕúS‡T}Öw2B·kdlŽúüºajêQaðýLÅsûiE ?þùHÔ(Ù³ÊäsvT¥Še…Ñ¥�¿!i;oj…dXˆ¦mj¨ ^m.ú~`t§·èPŸ£g|%¦@xÐ?Êè+£Ü~CrË\‚&PMKŸ»i<Õ•nQlèû›$ó)ßÐçÛÐ2/GË +„‹6Lµå+@ÎÓ(}RN(=*û;ïj8˯R>�‚ðC”g¹bèp„IºüÌ9±ˆ˜½Ê˧Økà ã¦j<;‹ Pºúd¾ —‰úï­W“Ñ %6¶´%Mà‹pº¡Ÿ‡-úí–hâ‹&¼« øâ‹qJu‘<d©#xT@5(ÂŽVε²ü[køàR×À$'  }´ÃZD‡áXO»ƒ…¾WŹצªpo06H¿¿]çÂâ $ƒ¾êÀÉÚùÞ¸`f¸Ÿ½7Mâ8\ ÚR íèOÍ“ckÃX—¥aâý¹Þ ý¥Š?8øžy²6è0-˜5í©ÄæÀOÙ »5€í:§9œùx†¡Îö2}/íz׿øQyV¶zKñÐtÔX_H±¸=Àؽ•ª§Óp=ÕsÏTâK@WíE±™ap&صÝe¬%3tÈžÄy«QYšÚf+=“ZI\#|rˆ½>ÛQz­<vzν“´Â€{Z+ó‹” ŠkÚþ†2ŸŽ,J•l¥gÇH’™Œ-1M†MéYåRÑxëd½hRû}—{-NÑì1ÇÜbMeXƒœÿ@·?üÔh³?�•g:ø·¸ëmOq¯s·‰uþܳ „(§š¨Ùx¢Ë ñœP÷°o»¼iŠ‹/¤Úc†)KÌeÛo¦ƒ{+Ÿ[hqóþ¥¶\ìÓûKŠ “Y9›‰ãz§}Í7¥_œ¼['Uu¨ ãx13ú/fÂqk¹oqÃÕÜ(q ܹ?ú" 5Û5j×ëMÀs±È¢éc3`5ýÔ©dSÓâ›°Xz¾FŠÈÕ,5p³Ì4~W[*Ì3«[„›}¨E®ÒØa‚ÿ33BN/îÙSÛeÎÐ ù÷aP®DA±–™ß6==±FRÜÕÄ€XZ•¾þ¨-Ä­´áp΃¼QˆpR­ßD‚$F‹úþ*ˆ­Â¨oO'/K~v»Sï"®+ø…¥YÕu&é½úŸ®ü‘¹OºÚÇA1|š™Gœ›!6·Üõö ™¸7®ÈîRîMä˜[b÷¨/œÔíѼi–÷˜xH!jž£Ð‹!b~Õ¡D7fø‰>o:km=p1ß[užäÀEL!†òÅò(ÙÁš\åñÇ“lŸºõa׫R¾ Ú.9 ¦Ó¼5ƒ Û”ÑI:V¦þì;º õ·CÙƒ´„Ñ ÏgÖ0ÿ,ÉÄn3ßf¿¶¡ƒîuCQЂ¢záÙX2ð¡»þ"MÎWš”ÏMº, ”{£Æ*#b\q< î(TpÍâ$ù>˜²*®T8š¼ âMëàº}SÏóÅ{¸Ñ×Çä®ÐCƒ2Ò§ÙÆð ûtÓRhqUæôî>ö'hSLÙ78å^™ƒ4D>Ùš}úŽví§6ÎÀ¿²BYæî×#[¿”“Ž“…¬")(=²3Y0LF«)»™�,ay,_ì6*}íu´t[“AÇÆ_º³×ʸ6P¹©å•SQñù1 ªOíJƱè6önѸ¹0¢"kánqìAJ¬Š±§¯ÿtEÑú4ýK‰¦§2ñ+‹Äj§§ƒ¼‘1*(ôÒP:ŒŸ‡aÛ†/Ú¸b”¬¾ã û”ú34+醪h^'eP *-)g«mÛžÑÀTí¨¤÷˜×ݾ¿pÞ‹pÛ º]—?ûrœ‰Qšlk�5¾5¯Z]Ž£èùš°}LøW÷y`�=g†«f–d¤d ² »q·úbY¢ßQ•£Â¹ -¥ŠúvQ[{º?l¢ñ‡Žz£Pøwc'¤'¤ÙbŠc黶M¶ü5qí¾ÊåÃë¥þ’ +ô×k› ç`ày>½cˆb¬!g¯ ö0°ØƒÎfÞ¹Èækr~õºý’¼fæ•ï Æ7…ƒ<oè·O²¼Ìü³’{ăR ôÄ£NȽ˜àñ–¥ƒOÌÞˆŒì`TóÆ{â#秼 ’Ò±ÛÎd°–±5¾³wNIÝäjäpF?9*ž,e )=pðµ•ÑJ·ƒ†øåIfKêp m RŒ öõEÊÓT ¼N åªÔ$…–‚Qÿ)>=\iúe¥‡âòá‚úõ‹‹|ó» ú,#R5õ ç¥j4!Õ"þ’ÔmUÂÄŠ… <·k̳ՔŠÈË-S÷[xnÏÄ{U-ÞÔŠk§ÖkN|dèLñnÞJa‡oñ„›¹æ Ôém—ÑZñ°uŒðàDµÛ]¹ô_a¾ë…dЋ`õ§àüY–:XleªF”Qœ(‚[†×;í˜Ky0þ ý†]'mlGèÇ~žm6|/½l³éóE´t?èëm¿6J<-ôÆŒÄè¬lqßÞ’*,r8…›)åby;òæàI·"ñ!™õ :¢Ešúy(ˆ4eõø†ZäW·÷hJ#‹ön°é˜,{'èÅI¾HJKÚg1eL'.´¡ç¶³^Íëôâÿ6Ö®>C§ }¦ÚñÔX ‘'ˆìÁ}Ójù?-ËðîÉ^Nß�`’R”æ*›ø¡3`¶ ›ë ¡¹Êù† ¸ëñäœ d\ gCóÁµJ›N´|øßë�”‡¾ã:Ýø™ÎêSgZ}Y¸Z‰�ÓTK�F÷-,óÞFÎmX5¦¯#Š?=ë$cݶ „AÖjšíwÚG¦ut<Ó-Þ*-o'wWÅð¥0¥¸ £´³…züR²¸ñ!€rð•ÚZÿB ÜÂr°¦OH¥‚ù çÝÜtøm7ˆ†óuÍW¤¦é\bᯫ gË ¹¡rˆk®ä¥â“üDdC»Ú÷è„âÒlsŸÑ¦ciŠ…;[�TA1öîs1GæOÄþsÏ©‡±0û8 ÂõVÑÅp9œÐf§"#bœß¿…ö,3ŸA¿3úè‰FQdçæãï&vBa3[q™c¶¸³Ô¶ P\zDû=Æw4¹³øR%׳G‹X€5Ï€—·FÁÈXÅž”W0çFë¾cÌÜcÚ»&÷¢½ç‚Øè”-ˆ!{D]%ПŒö>>{ä-ãÝ ìF‘,J¡ŒÊ)ZÖÍÑkq'£|ÿ›Ú¼>ò 4†y´âkð`kÁžvSð÷0ë’+ø]/¾êS³¼ÒÍ€$5  ›Q*¢#ó’…D-訢Oh5QZ8ž½öPE¯6kÅ°¥.VbÅuù7ÁF_eÍØþtjزH확¢´MÔr%–ß›Ê>›Ïz¢ë»L]àD]þõš¼¤©Þ¢«/42­õoªÉ4w#z./Ú–vöó¯·ß”ÞÁQÐXF1¸Dþý›¿‡…ë=ñ¸xÚ@(³VYãÝþ@™‰Ih©ÓJ—xÃÜ/àðxçÊE £¿;lèM’µ&²œñ×-ªˆ³±YéLõ³#º‘òÂ{ó0ùŸnS¬Òs b­šð†Q«chGÁyeµ5òjRBîwûýLïȇGC[î1é5«|¼u(uL6Úe–ÒoàÞùî¼._¢¥þ3Û:ψµÞ| %€žò íÚ•ÀPü+óƒ¸ð·N KÌÚÞyk¶eRè>È¿Êneùµk–k‘:CìIƒªí<»yTŒ·±†×/Y¹§À€_G¸jè66n¸ãy?ägÿr9·xœ ™¯˜‰]\Ÿkå<Ôëµ.þ7è,MZBÚöP‘Ú^|if,>úÆ“­·îz©¾°VõÄTêº> °¼9ÈÙœ/ÚB¥ r6‰œwù¤ NÕ“µÙhõïÙ2º^{bE”ƒ0ûmæoPõÕ]þtÆNPѺXõ'րܷ¨°ÖÜÀ%aغ§ÝÔk~W÷E…™“âÈx ÖSfe:D×®¡ß³¦¿Ð£Ä8^ ¾B;³«×žS¦£IÌ$?ý‘ Œ–XŸ ÊöƒÔf!ôELÒñg·ª§zcî»2°vÚý…ù^î^Ä eµ,˜ ºWŸµ/BèD:Lì¸1@}â„Zz€î&‡}‚jñeÆfæ4ÞùžÁÿ¹«‡£”,¶Írú›6ôã“Æ!p+꾩‡Ë»ºÆô…VËÃB!¶G'Ú4ÛÓpO§š³ode¶r2Ülº;FäkO(–YI´µ-¶wVîõK`g\„W~õ5}OMš�ŠŸ x1ŠMÑ1y"æí^½"yB/<§múŠB‘rÓb ·‡nØýØ¢úk"öí¢bdâa'£Î€ŒïV‡%^c :кéɇ8þÔj³–÷8•´ÔמÍ-z’˜béÉÂËYÀåîêf£{’X­Dµ¯£Èc˜öɵ'$öˆ>ÿEÛÄpµššÊþþc”8¨(lv,Ó ÷€tqáš5,Ʊj ‡ØØXgêmqaYŸzŽ˜¿6�L|(4·wªL¿kOR]iÎzæìò¯/Sך¿xG¿/ó =³²ü¬HRß8Ï ÆþÄèçO-b«£xŸ} §£Hƒ…ÙYËŸ�¯œ®“EöP͵Ùd âϞǤ†at×Ëû¹­7†_ÍEHÑTte,¬íDž¾O¶3þžyégÚ˜ÞEPNkð³g!t›(·X <V’»ëÁqé ýå b8•†g³êSË·B‚ÄÃ9ìÍyYy.ªg�xžtÀ€YÇÆmÖPa`µíw¡Î•¦\‰ËΓ”ð’ª×º«5†ÈeìyøX²~ú3£ŒÈïw òö ßêÛ’(¹¿Ùή·k{n¿˜d×p•ÕŠ‹ H g§eTP(k§;$É­Tx\ù†‹2裟Ûoâ B8—êì²£$ÏW?zâEè‹,Ò[ïFoXO±Â7Þ÷Ö¡´¾ºÙaªÝcÄŠTùyò*¼mýcy?7êO¥ç¤]á vcjÔ””Ð<Ó¾@ñ*-9ÌYöÀQW®>Ç5À½Ï™Å¾“,2'Hm%aC¶®²:L£‚!ìÕc©ÛÂE0ãwœ âuq28`•s¸e§ô­?ò=`‘eVŠ Ø-º'–v‚< oÉY1½mF÷ÊG}‰{w†Ú,ê oO¨c¹i†4¡ƒZdÛÿ'ί‹§„°]ª šÿuøc~*=ÖaM¨FËŸîC­Ìè€Pv8P•ÝÙ:,ŒvíélŸ{$)Æ7Ò΃Ô¡‘ª8­½£ÏfóQºäû§A ¶À¶q´&Qcj,öp§ÃÑ`ÞS–Nß›‚ó¡ËéíÚڀΥņÔ#Ö¨µn6WÈ5™Ä·æÄs<L<,ñÎ Ó`NcK!`WuÜ<³ÒÔoM˜] &rq ÒO¤íÑ nlStˤƒ†•)Fì MçÛ ne†^‹ƒîmÆ2H›Ñ;Á}©+úL£ˆÓ=ܹ³£ËÍ×î¾`þÀd+]-W4ÅŸÁxœAñ>;f!ŽÏè¤#¸ßFÖÈû?©°óÏ„eÑ*ž(!²G˜ŠÐA§Ýwª‹¬fëP>àѸ†ô[æè®3-¾·°Ûƒ³ÓI»dǮǻà*ª~>FÄðeFîëJÞßá£÷<WVAÌ|¶‡a§L&„x¨¹×«'OýþO„21¦ðª#°Â4 rY*¶òº@|X)få¢*fxí¤³æ g½ì6¹ëE™À\h|t†/’ñR s ð{<;¶€HQÔ—’džÖS 'öŽôlâŠYJ¤iÑp±SäD+'äø…"ëùfÉ—AfŒÉd½n˜’ÑV¶z}R  ÖH ]v[;¼î™ãŽ5yJŽ­W•”(·Øˆ¨û×äÊX5 @33+h‡co_îÕ¥Žoª9Z—ÉFqò«nÂPÑàAÌ"‚¼«`É_WׯøÉa鎪4˜‘[óZV¶êÄñGïɯ™yzX… ÉôGŠV©صv ï-¸‡„ÿóÄv;¶lÿÜø+ ®åâ7Ò]I ë¿A¶Ä©kÎDlV8ã”·‚ŽøK rÑVS+ÈÑnŠ*Kö€®q-‚ q•] ni}Gó·ÇåÝÂsjÖF"n/_n •oíIÛú8ÐrD£-ÑÃ3¼Ó´CÁƒüqK÷mÉ;KðXRªÝPi˜9ܦµçÐ_ð9~Õ,HÐ ]q‹ižN’¢¿´­/Yÿ¯ù¸Ê|ë°*hÒ2(Æ“G÷ÄC7 2i«û?ä­‹ÕþÌk¤4Bä¥}:í»9åê0:SûSï’ÎzßÕ3ãÙ4ÈO§}bÅx”õà mƒÒ”(öPX1/27úŒÀ)‚Ôª¢G!¦Q'c¢¦P%:Ïgf ÿD’$óstÚÁ«¦ ªïÞ¶W ­££¬Û˜ ÞbîŠVR×îOºß–(WÊjåqdBÅÊ‚´ž=U{ªÅmØqR¸÷k¾lá.JaOEë Ÿ• ì¤`áŒÒì;t½šrÌËí‹ÄW¶4jŸ¡­*1`”†Í™N{ÊeY"㇂Gt¬4ôEo¨Úw1Œé^íÎäã;„Τȳ åw5ÎoÖߣ(­' Pv†ÃO8tá—D‰o´E gÚÓ³ˆ;eÇâódm_¨¼ ,†*” ¶Æîø^CC"8ð°tœ—'U2Bî0Ìõ؆ïCõ¼¡ÀaöT×ößæP—ÊKÀ¤ÎE¤X7´‹‡£¹Íoº™–p›RØq#Ü–1&w§a0'£8iÔM÷ÛQ:¸0ì¸ÜµµYxÂñ�{èRªKë‹£Å�Þ¡½y£»u¾ôªí Å›º1±ú<´ }ÿEMtV]¦(3“E<»óúµ¦@;>8ÃÊà{]ÙÁB‚¸v€¨ÇN²¿ñºŽ«ø‰>úñ Ÿ°ÁKE@  j—뜱4 ®šRjä1p§#ðšn` Ñ¿æ9OèÂèyŒÚ²O3�±‡ŸÔñt³)çy¹ÈˆÖÝ4"’^üK`S"…0¸PiÄ–[ˆ»0îôD¾ænÉ¡sÍ"¾ÿ[œ(#6ÌÀ¨¶M8QÈŒÈ÷…ä/°_ˆlz„–7¸.qäʸê;ðjŽžÅ †.°2¤…õÍ»·U3{º ¼g}¡{7MN�æx™ (¬ öS‰“…ØITø ,÷Ë¢æÚßt¡ÿ~Ð3£é}× ˜Gµ(Ñëæv3¼OÖà nW?ÁhÙ“7 YZk mv6 ÉX‚îåÀ¢`\jËáo)£¸Ãå÷gì³4À›ÖªëB5“@tÕ6äí9çÁjOS Ø:å~žŒÑzez·Áy<QƒI“Ì—CK‚¾GKhÝyªÑðÙÖë‰Öb0m/=¢aC7R»WÞ ”En0¥í¶òŸÎœ?±ˆÓ¯è›C¬ÙòX(`ÏMÉ™èárk°šÓ– )|ªÌé.G¦Æêq3|žmŽ¸ßóC6ÜtbQ.}®é+ØVkYªªƒƒìOt;!žЊÀÁ‚¶ënÊ‹¥KìIÒ:ÐT¢Yš{ÆtnÕQ Õ;R":×úÞH&Â)zéøë<,d²\+VGüô\¢)¸ÑØ€‘ M½Ú¾šSzz2, r a¿õ!£GŠ(‡iöćx³45„ öЊ 8JX†f8TZ›¡Ô0Îè½ J¯þ5H–±?кˆþÁ¤¬¯µEœ|{Õ6ò ¬9-è84ò¦Ï0˱ö®1ô¤ú%û(sïòN0ËEÿ½¤r 2Ÿª… «ëÿ>2//õêÚ–‡‹©YE÷%¢Êè³÷:Â-ႳŒ¥h°nN·¾N‘ò‹2’&ô?.ßÖëÝ`ÑMç2ú7r¨¹"§*­‘˜öü§§JcàæV¦EþI_¤Ø· qWZXye[íUTÎ6Y¦¯Àü(骛ÃùQ³=-2o¦ï·mšSŶÑs3©5–8F÷ÒhïžÚBžU™s H˜”Fo{9úPžåTXÉhúúЬ.ó¥å#úêtÀXª lHÅDÕ_¶½P·Ï5K½òœc·©‡GòÌyæiŽ£ÇÕÓý´K‰cE&Þ%ÆçúFkå¡äJY˜A /è¹e[‡êŠa‰‚Ÿ&ˆ++‡<õ‡wkâ™Ø×åEm7æÜA+§>‹.‚ÑŒê!tϹ֡îMíö¾å›áK§µÂ7'êÍv»`Æ\�Y6ƒ(AÓ¿æa0nâBö?ZiÒÊ<OYXxt@èqÖƒ’<lïæÞ•=›Sß–5A{ï”8bhhÂSÌá!ÇóÛ¼å8 m‡T¶+{È…µæ©Æt*: 8–^r×–rYéÛ+¡ÛÝ•A2Mn ¬wk§xñŽgAê>)Žä‚Â-ÕKÑ÷·íOb¶‘÷ © º|x 7Ñ’¿úQôz®úQ^V”–+ïƒn=-ãi™Ÿ±CeºµªÀ Cç—yg¹D×NÝ1Dõ(à­”6Þ)†ô'ß,H¯æ8‚{ëFM'Œ"Õé-“{{eJ=™déá”xý!ž¬¦2Èjßç:®7ùËW7ˆðÏ»(ÛÑÂI'"cP”Ķt ¿ñ@»fzON2#_M\Ó :Ï°îÇ­yf«í¡q$‚P+Q¢­:ûž,¦zalÁ"X¼ÍYN­ÞJi¬Ãi­Ñý±J:5XËôTÎÖ7©G.,NIÞåk˜;ãP#iwr=¯Å šeª5ñ+Y § ¸—48ÿ±Ö…9ëUC=­­ Ú»ZE=ýéÍ»$¯4úziP´G3Ìgÿ%³Ioöî+í¹Ù¬baVg:Yí„2—©/8¬|à;q³ûy®Ù,&7ìÐsMÅ€±®¥Î£!:LuôíS@§áÍ5A· ~1“ÒÝM ŠÜì°r,éÇKïÌÎêW‡w태‘¾B¶¦;ÒI|‡�#V®>’æÂI!`#Nõ…å¿o/ä¹oC»¸Ç<r>{³©Ý~ìt+iaîã^^‹Ô”¡?º “àÐQü†Ð0)¶§Ô¶»“:yEGšûMÐ"Z˜Ê‰A…zýéàY*¿¬Ìå«ûèÃ[°­ô胋2òæÓ›+ÐGÿBÕa}²ïj#/æ°1YÐl­FÃ1ÖYKü�idœÜÁã}s#2yÛ‡ÝÏŽ3Dúm ûUô²æ\»IÙ¿ÖôþSTE•Ûš/‰ØP¢h.ž¬‘ o¿ð’ˆâ䊠ÇÞŸÑó,‰L:O–Àû˜Èëp¡¢£œÑF.ûÛ"{âГ858ƪ¦B²†x¾3žVFŒÏE‚ÿóÛa{°p=hÏo$k- Vf˜túžGâzY{~f[¢‰¿½ Üc€$f{j‡´fÏó/àÝQè!¨M„ÆÊF2œÃføýk(Qä �‰Òt³E²Ûž=MmªÄÙÖO3:œ8”¾Íü€Ñ†½/©•„¹ëdˆÞXZ™uÊ‘tô,U pëºwj—Ï“w‰Lm4t®Vã§zjT¹Ì½Ó»›TXë¨DäDR#ÓÄØ%ŸTm étø¼iÙWÊ?B¼Xr›˜! hö‰­sfb|øaÀ`¡Æº¬àÚ”–` Á–Û&L–û‹’6¥MAâ íMç¹ >)çP œó°¿wåv©íqgF‚þøMgslob»yT¸;Ùˆm—÷Ã=ËŒe€ù0|PÒ8+Š#lb&iš¿¸ÖTVT:¼bY¨Fж\{Š½hTЧmX·PQ)Ð \™XŠÇwìàDG‘ÜFKÛ›4˜ ºÃŸµ×§k/z?Oûñ-ÊWâù ,jµM©â²Æ4,xö¿µh¦× çÒS©pÙ +KÎå¤ÇŽ°”U«/éÌM§A(d´ ïËEú”¹Ì <¶õ§†B¨¢IvQ„‡òjÞÒ˜Š™s‚?š2ÖNͦ÷qè­Ñ'2)ÌRÝÕ¼Ó>ZŠ+Ý£ß2ÐHl¡-òCACéÊÙX»Èçæ¯`)DšfûÕ¥Ÿ^g¾t¨ )‹AOêM_/ «"ô6|€nƃA‰çJ; ±h˜mèiåŸVL) <A{[Æ7pú&f‡AÒÚ ù~!dƒ+u­o¡X]‰ÿt¶ŒUˆç­:ÜŸL]Œù:¥ªà5/,ØJ›âŠÔݳ ϸYªX³Þÿ•dÁÌòUƒ¢òþ'ÿ~ÎK<‘.åpÜsÚ™ü]КSÑëHWúÎ8HY)¯;™F–ù5 ˆU°Ùáð ò¡\qhÐÝTä—A¸V»³ýaÚص“Ø™ŠA=u‚mxìQç1 ¶ˆ……òŒþŒ=Wèl .èÍæž0û‡š¢» O¿ ‘Wu0özuÄ|~R2P"IB'èkSu ídhâ]^ÍhLæ'«ƒ¡_Gô<l‚Z,¢)_¼¤À/Dèû™ç[n¸wœÌ–w «… ÆJfq½‘Dqb1óRXïÆ*ˆ&Õgƒ~ooУ<g“ÈÕ‹Àw V«&Pq^¸éVU|Q6®Áºq6u¿;±­Tµè<2~>Mè/XŒ@t[׉Á&Mcݳ&7ÿZ´Ã¶úD�ÃðÈÓnã:ç©þ¡µ¤2ÖïCµu˲ÂÈ·'JÛ>G7 4[F-:ÿw=ç¼ò[€¬2 êÆ‚ �Àæ<v#0fSSŶ;îè¾Bx…³è‡ëMÏ�iãR×CjVÃ%gz¦¡³ð IJ)‹ŽzÍZ¢ß»Šþ“i¡¥¦52mèNFŽyëq‚2óò€™hx-Ä-dih#¯|†ãÌûR�ï²àè<yÁd™Žªñ?HŽ:Xņ› “ƒ«Ôð봴ÙR¤�Öò´ê0ò{$S-j'&qC¹Ï² ýڟУZ%Ÿ ²z‹JLôÌãoœD)7<Erí/ ¶luñ)™ã!åqrSÚÅ!ùZQ ¶Á%3„Ýã™n†3j¡døÓ,E3FêŒþé0\èp\0¿ÃE ¢,íB¹Nô¹ugøŸS¿ªíü›Y—ùx¾àd즮ÝmvÈÜ¥Ÿøfƽ]x1Ö˜ѼÌ� zŒv1Ç‘‹¥Íö51Æj_Ç*×ÏPÿø´6÷;Ú  kä½8¾ÿû¡â·Y�¹;kÞç)>Ðt\JõÃÞÓ~-¶ƒ«E>Ž,G=+oº^ÛïÙœ¶Ì|”=ýy÷ãàßœ§zØÎøXªuÊOO}w>Üc'~ÏË-óÄÞ5¶8•|ï~ Ê©z'1Ñœ [´: K«ÏTþÞ÷ƒÌ½¾"u§”R>+šc®Óoà ïõ´‡:Ìi: …G`üô+†LtÑÊ m-Š>åjhÇ3cZmùß/>4Z ‘ëƒ>ê>áôÄÂÂ!¯¢é¤ ,8盟º XΓEû¦P!¡­8içŸù(ðqœ …— ֢G(xõÒ^5«÷êGÀ)X9ºMç5¦Újø•¡:EµsýÕá^wu½MÊ8ós¸È¢:Ô´rTûºß™¡ÅK¤…URœ:w õ¸ã¼Öa+€#»~:\ÕÈ·¸|t­2Z:²¤·§e¦Qdšˆ!.+{³ã±'¢ëuñ‘fFf2b]l:Ý÷_tœD›ÙÕÀ¹bÈ"r&®ûËeÚÖ;îûT÷ ›Â»¿ôp„&xPõ/=Íê°y~¥\%{¯©»Yïø­¾§¿žáÀOµNÕ?gñÔ6Óõï¸Q¤å_¬åæĈ۠ià¸a¡pf &-J«âiãQwCw…K«0Zk»÷žÊIý÷£4šÇyeîŠ<í&KÁ|®K©nlTÄ‚9ˆ*¿ðÖ;Æ©Å£Kž·‡{êp2ÉqBG°—¬Fh&wžÂiÚ3HË;‹ž ã4u›œ{ÍãbÞ¦6°n÷;Z¡”Ï‹øc§Îf/E µµØŽùr£ç3Áµ|öKÖ¤T6&…€ý óõçCÖ$ }‡wð²ÿ$ V ‚¾¬.³à›#0$V¹×—G¹"ù—½úÊ‘C¨+8£ó˜Ú£9‰ å²êöhûè 51€b^?VÛš!šK…Ë8ozòpÒ ·–,•K“éX«JÌ›>º™&à‘°†c¨ÏTA9wž3‚92ád/·©DîRãŒíi:*£BÛØf3h+;fÈz<ÖÚrñîOé8Q;î.×°¶nÿu’Ÿ+äúà;ok/á§/5½²Œ¬bSjN½±§üù퉣¬è¬é&L‡ì>ø+ð„/òU²¾ÎTIouX Šph\sHš‡ô¹)M: ôvŠÆ^ü¤ð`;Ü¡t±Îi›]\fÇò¥fÓ_Z ŽÔi˜§•jw·€ îÉyÊìÍ.ù¼ýåÖPî‘Ý)‘Hà¤9"+õÅQG›‘þh¶ôMùüÀ‡ òø ¼SÏý5ù¸ÆÀjqY’U]ýCo{lŠ%Õˆãô¥?±wÒiø¹ÙË¢y´ësgoñ€4»Ê|Ðf–ÎÔõo| }e&§‡žR¦l«=€²2cAî�X¼Â àç¿KÎVXô¦"¼0µç*¢©‡/µ¿› #¥£w}¶+—˜èÏíº¤w^~‡É”‘È6øTãn¥ô‘Ptsóç]»8 °G¨V¬&5%¢GÅ’v²’oÎ0Bÿt¦'}9Гf&ZdðG´BY±P5:0\0ÿÞ³ÕöÎôοÕø´`ágVîTÕþI´Yhá»—P¤¼bAq!ÞêD¶b¥£# [±…'ª ‘JÈÈ1ä¹qΣÄj”0iêxç‚ÓåÃ0¿^1¥|ö±x%Ý•ì{v>M§©ºúŸˆ-ϾÝåc­˜ÜN„â D¡·¨ÿõ$È.žMØõt”…Iæ } Ÿ³ ïÿÕù–ž«šÇBâã9ŸvÇî#ðÇÜ[¡Zl™™MÝYŽÁÜ÷ˆS_ðšy蟈 Šèoíæk7k×îܵƒÉݽˇ’š© ȃÏÁDr=þ¾Y�O)k:º½«g¼¤8J2#G Ün¤[Xöƒ7cíëF0†+ÜQ"3ù8Z¶wdJàÁz’ҷʤCàr w-Ù9e0ì ±´½Â1rbn\V˜Ê•S>Ô8¡ŠQ|–èÁý^Æg”$¾7ì;ŠÅ£¶®Sîmz‹ƒ æá b!ÏQ¼ö„J {ow×þMÜfM MXäÃÁijÊ[wÈ.~¼Ç„KR‡½‰LYQQÎp1u@kÇ‹Þ»ç¢òpf—–ŽQÀP‚ºGű±Ú!ø­:¨Â2D[E_¿†Ã™a K$Aº3 0 8 dAÕöœ˜‚Vo¾;ŸOvÐJo²:ÉâTç"ß•‚lL›tÒNÏ«jð³!v`s*ÍÅ¿:¤ÄOZt?D.§Ž© ²úž‘™ØölÐèúXaüµhÛ1IŠè±ëwè+§†.ìP%ãáæÇŒd^QzóÙ4K°XÑ9Ctcï—•’¦¿>LèÌ)�L´ô ØœhgÙ^³ùúÕ†‚k]¬óHqo­†@fŒ:‘ð/€ÊI˜•’'ÈÛã(H};W ý�Ε'~Üó‡™$пÂÇ™?î e*%Ðð¯Ñ0µjy„BhZ¿WúXf·ÆàaDŒÿüñ�J&n;$�íׯ÷ÑbÃt‹ÝúZ ÃA�‚ᄬ ž¹àÕAGºLï¯ ïÌÇý#mçSg'§aGk£‚ÛxöD·=ô‡^èQQÄ·)˜LÛ2?U|;JŒÕŽjV¡¤œùˆÉâR”7Iœ5©œœçœÎÍO‘‚ÔÀ—O[¦h•a»îwÆ}r}ê™y«c¬†Ü2†¬à¶“P*´ºAŠ4÷Fá¯mv¢4w´é”QI}ÄŸRßļ*εË1'Ó ig»ãÈ`×@D®¾NŽ=}¸ô)ë‘>Pp·à½.ã0ô 2dx@W'm¥|V_‡É5—y7tjÃk6vÇ=bÀ;ÃXëg3<.‚CÌ9ˆ¿'õ€-DkG¦Èâàþæ˜1}›\4›x@¨Ùqi¹Óâ1²ŽÿyAðê >™Y–u³ ¿ë¶–Pñß8Ë Ó,Ugó7³~›m– •âÔ¨3H´…A9ZÁ‚MƒtÜô§™QlV«m5±NõmÝ”yv«x±¨É­?]G¢¥®r$¼£(«¿VÄøO�vTSKLq¨9Í ÛÌ{FSÇѯ‚fBO7}þÖU PƒÒ ivþM$á÷J¤-)»Ëƒr>¸°~SJOÅÄÜ©N.7Yµ(õç(7éÜÍ/"íŸÚϼ‰�ê©õË%¾ð—ôr¹¨úÝ $^ü`9N´ ¬b<þ:¤€ï4܇þÄ,eï_7ìˆë“Iï’º’Åû7"ñ¤ç‘C3èmþ+¯Å!§ÌÁ:MƳ/"ÈŠ/èÿ8]š8GíšËß6ªl‘©Ð(¢Í¶m½Þ:òöÙuC[*@™±ÐÐöÅ{"\Ù_Þ‘ðó¦Œyl#©U40"Š“3ÿ%×Bû{]c…/»÷Kƒêdi£"cM›•ŽiAµ¼ Õ°©×°€)ó¨5wO B9ïØ!Å3 ‡5@"UX4o:ýL_¡È|Só”iKùhu¹SÐ8Î3JÕ}Š%rWG¸áöU i$&‹¢„Õx¿£¨:¯I#IäYmîn…Æ6ñúÈÕ˜b‹=€œžÙÇÖ¼=F|ó=ýB�‰"cúÚwt´¯gÅÆ‚xMAY%•f ó£xÛ¯OA«ËBTš†Wí½ã™ñC[ÏŠ“J^2*FAϺ˜ž7mKSßµÅÁóTV:àÖôÅDÁVGúó—ûîœO‰W7IÐQvÞk½]•¢²«”Ô4;ßë7£.Š)4ÃaÙ1–¾’i’Uuà\ê vå׶±–Ð&¨àʨ$؀ʒ‡Žy%•‘SŠ€š &tTY÷[6GWykõ |ñ¿εù¦$xƒQ“…¾ …™±£3+ÛnÍ-Ûœ8ìÓ{‘P¸Œ]ú ?m”R¾º ÙóS£ª¢ô »éŽí6ðŸ¶ê7 7Aël–Cñm[Œ4ôõåAǪ3ï±mÓs¾7œœ~* ÿáóÏ\˜B†‹ ˆœÜ•¼EÑ1(€vÖ•ɸ:–½1 R±2ý‰­]…Ý–Áq¦Ü0OHUq÷ê‘À‰É¢÷/QfézŒ0Ñ…U‰‹D“¡…‡C=¸Cð Ý Éà ìx»XQÄ‹¢dY£d[››Ákijö¡™ëÕ—ÏãùÄQâiÍ@çƒNÆÂOd@ÂÂŒWî‹Ï'Uv„$“ZE$AÔo]Ë_Ê¿wySqYù½gú¤)¨®h3ÙQ²£F-v«ãaÚÕ*'vIîàVÃÉÿk€î:äý2S"5[Ьo-¾ãêçÿ~ä…J‘ž¼4§Ùàö_D)i'J lr6{ÊëÃϦ‡å‰9t}³»ÖfQ‘e^K¹qÛÑ¥óÚFl®ë€¶ÛÙ³\r4ϼ÷û¬.¬‡¡š—@Z‡ ciÛþpÖ¶?ôģýKá¼8ö%béø™¶t$ƒÇ“;îtàÂÌ];•O½:O³e&Ú¶n©(¡Ð¤±ÝÝœìô¯�}Ö«C3H=‡M+TÇVhù-0üqåKœ¢ÿÒ¢#:ZééËòÏnä<±¯7DÄ´ræ4ÌÐÄ·ºúÈüZÖW”ÄõU*y›Zf¥Ó?a”|3c†ÙmývÜõ›i·—?ÁôŸÆnúg_¤àÕoÀG™égD¡£(^È7@ô�’'“-yé³_Vµïh”î߇S)çhÀí3{ì&4£c»:i§S„¥oÙë<wøg7ü³Æ1OîíoV't©jnd.,±gë¦W?ÞHÒ“õ*<§öõD÷+\LàÚ8ÄAÚYl Þ¾­½IÖEÑ.ü#§ÉÐþœ±8œñV£sU¸ñ2“e¦«yÚso$éã­è¨ÝçÐyhœãá ìþK—Ò–&ëž/ôí)§ ­¸$zD¦ÛµÔ2UÕRï2úO’-2š(è1Œ³–Û”艘ƒbíî<ÝÕÒp-¼î+6ô¸’Ñ—àjÕ^à7OçÌCõ‹Ÿê›æ쉇S¢Ä@uV8TwñwÞ½N£!,-ªªÏO_¹Ñ£qP0–;3Þq»[n—eWÌü™ª–؆õ’BN'ÓaµXóaßwóýÆgé!PÌUM‘&´`Ùv›s™éÔ±’Šˆó ]ÎÕª8nR»íeIì°ñtóW[È7*©\°9V}Z[|8`_VæöšNý'vÙ—èp­/)gz¦zƒX•«Ç°|©o/4ŒAϘéêÑ ßU#¤`<âüãú·T††uA““6Û÷”ÄcFI(£ŒnÑÆ2Æ¢K·bM‰{@²ea¡ˆ¤¸°‘êê½iøÏcm+±k™#/h+¿=žæèP3%G0 TaÙy¬>v[#!͇ú v[ÖÍ çVÛu£ÜTQY=œú™y°Å©(“-½5ô/ Š¦s$å'h3¼A¹fE¿àÒáz£²ÔUdo˜7ƒóŒì.?žlr¿ë9 1,¾¼ïCLFîÉ–fÂ;;çxò<PŽõ^æg´ÆV_€ˆß»ÒŠáæáª(óT鈡RÆT9âSÄâe_kµ§SÆ` %Ž K^綣ª¶”ÁKg<¶:Nˆž_»Þ’x%M‡:-3§:“…>b’¾*‹-ƒ'=µˆÉg£ø° ¥ Ýaª%I™ \ŒìC‡÷WÆ&H9;kD+„«yúnvüÛ÷:—Yš,´~R:½(˜E£µþ‹Z í­º#¬ûºu‡UP·§k¸•¿Ùó 3ª×¢){3åX^#ýµFœ'þ‰ñµ> ëº5ƒ¨ÆAÕ KƒõdŠ:xî©P>Ö¥trÝ\Óͦ\†þØæÛ±… °³ºˆ7È ‡Þ QægÛ!S]¨ì›:oJË ªfçÓiw?jC³¾ù£dp!pÞ;qd…9Io4FFFçaÞhJžY¦Ÿj<Tý%ÚÍŸð›*^ÝÄÑmݪ׶.LÛÝÑt[(Ê£3lº‹¼]úîœi0`’l§³"€7õ*ÒcQ“¦Ý‘+ô¼í9{)'ïÏÔy%FJ“xÌÈqæE‘ö°á�QvÚ +  ¾Qy?G1ûƒ ( ´½nuÆ]a-ÿ÷#âƒËÎ<^—U¼áQ”–6f æˆ[›|[gjÖ©[•U¬õ;Ü“¾ŽË…XÅÃ/ÀÂN}U{Œ=°#©BíÄ鄵òL&#M/n‚=k…Ù’ë7ï)ÔN[s¯Xؾ> w˜|ÆøCÁ|g9�"B°|¹‰±¯u�ìÚ¦`í§ÉÑö¯‡vÚè{»8§t/ÊíÉܱ\°Â«¯-=ñÙ¡ÃGÊ'P_÷Ý?ëKßv·¿8_¦+¿Í2ËòÔ šy‘Ó¡ƒY½==ŸÚÌ­1.ÊB_²'‚?=Kªfq!:*»DH£ëÊ'7N<€WÚš²›Óþ¶Ž½Þs†&A ÍakL9S�ÑXŽ‹‚hª§‘RÏnð®—Øî£'†ŽÛÀd®°ÂKU`šâwe¢{‡¤¿“så/›YJIâ =ɾƒ¹Zýé™mMõÆ—l–@*Œ7Ósz¾,3ÏWŽsàãùcë:ZÆw’":½õjËÿõ¶žg!fu×ÖXŽîÍí'�:6t~lÕ#1cƒ9Œ›þ3Þz§Óªå3¸~"iêð"¬§´9e`:oöó%->À4¤˜^~ÌBx=ë'Þh¨T«5ùaåÔC¬FÜxµÚ+DéÏhä.Ù$>ÒïÑö8j$ÁàP¨þøf˺"¯í—,©,5ZÛ«#-ËŸÖæOC!݉•ïÜÕ­õ²ÖŠ Ýn󔸷¤.‹bhÝõ»è`wO¼‡‹ÊŠ½b\¢išPŒÔNRZ›èë·hè9 ÆÇW.Œ ø¢l‰ãp¡ëïÖ3½÷Ð{êñÓ¡í<*Å ½¡,µ;±Š ŠjÑ7þ·n:,Ro ˜×žr‡ÚŒZƒ{WzËS°ZB=E:¬â¦3‡•*,h¯Ð§Èþ/öý•Õ»&>B{có’am¥¸ýD™¢T'Æ¡”åÓ~ç”y|^®íO E;×æá³»ìm—•ƒ¦"ÆÌÕ£>b‡ ;–’=:­ŸÆºÛ}¿ÚTðYJÅ:‹JX,Ÿ•vö2B1–}Cùh/ž¶- ªØšVuë@§´c9v¸“|ÙÇzFñ°½àØ0½V5å"ƈ3 ؽR¤ñƒ±?í)vbc ßlæa¹æUš7–ÒT¯Û<©ÚºÊXÙõ¨ÂBÿ³öŽÕ’ ¨j—”ƒÖPp‹¢”B‡uLa0»nYâÅ[•.îww­r¸vhØH 5m9«™w8ó3É'¥IøÀ»¶Ð—2W_vÑ“$óÅ<b°Y)Cïï¬ÚS]¸»®àÕq¼÷”ókj| ¤…Z…鬔Óu õ/-ãGœæhÏvwj~Ûvµ=²ñ@_"¾]‚À7¡jFZu›Ý|Ïë¨Ì|–<cû4 â­Žz!¶W¯º,ÖÚt-Å°óe /`_±Du"*~Ì!š5YØÙeƇÊþÔ7ìÝ6ëŽ×§Jå ¯ú÷ÍÚß3tÏ\ÈËMwf>A4êƒZS¥œüÿ7ÆжžŠCõŒüc„¢ÃCà9þìVP1u4ä‡Þž†³3ú ›æbþ½j’f¹  BÛ>½±êλA>åst@™%²B­äo#r­Œ”5÷:HÏ^]OeîÐÕ(vµCDÅW©8ƒ§WÔ'[| šf \¦Jƒn€fîoÎQX¸m™p÷zMObV–ᄾԅÿ5•9T <èÆyä»rQ$€4øgíÑe–˜“2˲âÓú¼+Z8-LÜ WÈ’_rOð…uæÐó2 ³ ”Ñ_ùÐÈd«¬ÀS+ìúõ íÆkêHûj„ž¬èï¨îŽ/ÀA[Æ9yA²# ²ñl&Œ¶êacÄU…BÊ‚#Hû€³iCÿrQ >*+ã‚ M‚tÐÊèRSÌ3 P:g(†úmüà oýa; •í¼ZƒßeÍ Ñ„ï/3eÁçŠñÝfG«øñª<LlÉ£-J»¢A¾Kù,ØuL“éz3 ¼"]Ür0Ê…oÿ6M¸¼7}â‘y6åÇt@k×|êáxÜŠæ^Må"´Š² œÐÄ UÖ”ÄÒgD¿=X¦Î6¯ÅÊJ¥¾ýÖÇM¿­³ÏϱEÙŠMn°¾ÞF¤$Ûl£2a,_o4„‡ò¦KCªÆ¬™‘ð›éföƒtýÞ(z›w¶F²÷®þanÑ?=%Ü·,Ï4Ýú¨4¿OC –“K¡×̃Yc”jÍ+n˦ýÌc•§NK É6FtŒD§¬,>SÛ”Œn¬`%4Û(âú6“o{NFYq•¾4hhýeq:Xø+#Ž¤\P`b¿Cç¯K;–_Jܾ¿9ÞSR@JkJªÆ<?>É]ÔKö·Ö±’(1>~ÓÝ7ϬázpŽözjyŽû!‚¸ïø’_2Ìé~0PwÍ>¸ð§cÃÂÃW· +úE~$2îSC—»¦7ÍfE]Á ÊÔ5àÍ(Aú«›yê{·´ñp3bˆ1ÐSµÕ™B‡3ƽb<–YÌéªÒ3 e­Ç¶.ƒxÔþ�9Wª¯A7í0}DÌ-)x‹–2¨þµª¡Ì#O<·’ÆÌyÎü­•¤äqÊF©t?KvëˆÌL–£ˆõÖZw°'Ú¿Ìè“Ü7©^f†ePó¯—¼áe9Àì è÷™$b–û-^NЗª/®OA§×ŸŽó#qV÷‚íµ÷Dü*opo—î›ßDŽsjå²ö¯d¥œC´œ3¹AGºGhpý$z «zsN¼ƒ:XX±ïæŒ?¶/ZñËÇÕó®Ç*³J7sÙOlì)¶cd“UC©ÑP19²ÃÆÛKkvvPïÍx}SELRoÙÕÁµâãäõn(‰G¶dÒq¡iÉ¿ð4]p²® ZEš¥™ÉŸK†[m©–é5XotŠ¯{˜}㔑›_¤þÿ€®4Š¾™ô«¿‡×¾ÿYe²Ý ß+zeAJ*bç0霽’T¬2×OÞù„q{öŒ»7t¬5æÎÝÕ#›ë<\HQ¬ù:&A^o}›œ=‹9Žõ‡üâͬ+Âpés<o(œÍê²°>üB EðžE(G¿Ì®ü|:ùí@ö‚3L~é4Õ‰X1%8+ƒ­Ú­"%ær¦Ž¯+Ä剶Cú³õŒ7(µ¥£.ÓÙ(”sM_eÄ#Æ¥W…FêÀº’;6ö‹ú³¥ž€?¿"ŠPôvÀA–'ñÔæÏG׋RÊÉi±Q˜zÇÝðEïaãËØÌ»*/i’ù´¢0Uåäµå¥ÃuKÙÝ¥­¯‡ßϘº‘Ó€ Ú‘½þõ̽ؤ®iÎ"ôè®híwC}úØœñ¼—?ù2«… Ä~AdçÞŒ4^ÑG¯'C17†NÏqÍg¯|;Z6\ÅŸƒçRÒ³0»JÒ ÆÈöaQ”æ “<}ÂNe£€e$³ôtèhfñ†W£=m˜LXž¦HÏlcôw�ÖàÚ|2æî¥ó£È /Uз …o:»r(1¬>¡Q‘1ø’ž–¤éº¸¾Ã3/8+‰Êvmh÷4 ó©Uöo&x»c}tâuàv3 Ö¼.Ë«õ‘ëô¹0æSù;Èêš@ :¹jç=Bõ•Þð:1<Zki£%új×£ÛùAwf¶æ Zª#°\æSï]½V±Šbç[,îõÛšÅaí@ý©—ªW*0ZBÝró"º;wªédA @“ lÓÆ“¼AÚ«‡Òݮړ›“MHµ× IÞò¢à3.LOƒ1ß3â #¡W¾Bn>¬f¦Ã´úÙ¸^÷ 0ð”9Ï^ ¹L‡ûfæ |Ö«5GVw;’Nkë³fLT£`¼ Ö¤^�/´Ô7½ÚN‰ÚŠ±ÆÒÛ™·¦êE¿ØÁw6³Uk`_7úÌ \¤{õ–AXÛ3#’IäT[³ðž»hj£bp Ð{ôôôdE! Æ• íw'Æ«¾®x&ûÅBGÜ:tÃyKº2À²âÐ(okzÃÍ   ¶ðþÉ i1|Ÿv: 7»âÑæHskê-0Õžþ@ÁlÕÈñšFUGšNÜ~!ò¡æD™;RŠ“a5QAkÇLUÊF§³ç&' bf…tý1ðØo„²ÂÊ0æ0¶…çžF‘©ÅgVY£¿½Â&ÉRCuâ´‡Üæì4R©<†ØÓ¼Õü% ç—_-²�ÂΑe~eG‘¢Ç2m¾½rðq5ð8LÚšwõ€†šZþ~lÏË,÷XI佚ˆU ¦”!ëüG‰vÃ?†¼ûŠ#œTNå¦À®£èG©•…èó|}o•R€áš‰%ETäÐ[ñ2wé3ß‹42)\6X�(28Êõ´Ež$qUl‡ÉF`›>ÿ¤XåE:$6‘'ß   †æã~}nXv£Ü9üá-ŠN£#b‰ÃÚÿýPuZ”¾ZÄ{u_žº3ƒåàÔ@UÊѱP>õ—A¶¡­>N?&´[Á—ÞÝU%ˆ‘ˆõn#ˆ×%9£ÊC­&¤§vwøÈ¢ÿ~$åÇ?( Y\IóTÐ0Ü͆ҊöÞÕOÑÒ*ôäWY$‡nLÒªq,p{ô}°¸!ëv7 >D^ŸXxæ‰{onÍnLjÍ}lS{Üu8 ? +p rE+Úå¢zõóC„`襟 .8ɽó›>Ìg‹ÆHƒPy™WNíáž–Bœyæ~ÏxÓõÆó œ8Îèæ E:%,¹›;˜²ëõW·µ¼YÞJéƒè"\@µf¼Êró^:ÚPÜPµZ<wj”Ò¬$Qb3¹/É°õJæ+Kßë7÷¥\°”"T*§µfžÀ„ š%‰kò¸PIëæåù‚“¥ƒ&Q 5±1ªç½$d¤G8,rý§„ “ŽNÿÐR@ѧšoåDɸ1Ÿë–œG­ý¼„l©fžd™Ï™(‚&ÍXeÊ*¿¯kiÜ~iÚ*¿À”‰ÎEœ£{3K{³R²"Í<O¾4è!õ~:+/„ «Ž«Ñk¶b¹(Û²`ÚçžEÎÐOÏ —>œèDèëc½ˆ(-¸—Ñnh¢x©ÐžéuzÇ?0šÌèg‹¼ðÁ&:7´îÐcÒÌs? G»:Ð5(ìÅt|à,-R°½þº—ê“qa9 aYÕ„Ýv®'½©Ûæà9ñ–³·{<AÛH Ž|}ˆÉ fV2&.©@Jà ÑÃrÞÂ:ó<ó(¡ÈðIsç—š_£¼ûüs[Þ ke 9m_l<ö:åH˜¦G¹!ÛšÚ×P"¥XK¢âI7T%uèç£~púìëU}êk›8ÓÊöÕ›�èÈÇédŒ±8ÒÍùvšX‹ým<ùf׶§~ÜŠú{~£k³ìȳ¯žj ,;õ >“Þ:œq× Ù!hœ×ô3±ábuoæ¹K7‹¿x=7ÈBÜÊdë°©è´³"J¬ºÐ]ž;M×™«åP°ùahïíÞ²ËU€ tÓÆC”íè¼ÁØqVU°ùûÃg?W?ÑÒ¢»ìTR8ÖHï`ûƒôÚÓ C»þ0ølyÚ»uýƒZ­5ã¾Û”C…3¼Ú8ÏÕIÌ¡Ý Ž0W(¶¯?2Þ‡8½¸ˆý¤ƒ‚gÝAĉAd¸ þ®ø›C9mÐ}�ýõäW[Ó¾Ít¬ˆtnNôzëŸ:|„!$"êç©Ùõ>PŽ*2a¹úñYœ––XÑSUùÚM¬%‰¶E2ׄ·—4ö³œˆ¹¢aZS{f` Ãà[äÏsÐ3ªÃ—Vö Ÿ27 ö˜§‡ é’ͨˆ†”ç§Òa7¦Î‡SÏU¬s}ýU¡ò{›SA;]¼ÔÄÀüM2eT¬³íL{òQœ±¹7Bäñu+T`+ ÍͺP-XMÎùÿ|lºÃ´é¬ÿ.} Ôkx«žÆž&Xˆ<³­)ýü×¹xT´@ÛÒÊy^-̓G³k‡IÎUðy›Ó³h<çõó®.î`#Ýò6<ÿñÁMŠ­Jb0«CdµöU3áo¨ö;jÖu¯2¾S$§žÂãÎöÿ¢­¥1,0 ý:TINáãñEþêh8u~‰R†¯&zëÙß ëú¼r³mÞ<lâdi¸¨ìs(O„Aa%É£0bµÐžK@ƒjd:qß")îƒu,WuTµŠ[° fÆû:ÉÚz±Ô»°ù…'8+õçÜ•ÜïsÖ‚ÝŸÎ;$ßU}H<5?Dæ»Ãd¶ 8 Ǫcëg”2Þõõ¹Ìváv©¨åϽí·V{ ÝEL? §þ ›z«æF˜’jò4È­l.|4ƒ6mE)’¡Ó´†§û¨0·5f# ãŸß^MĸPSñ  m‡d‚ÓÄ×¹îšiô3´wÛ“rö uÚÚÎÕæ´›yù(R…×KpªŠçQïfkâ”ÿnf÷¨íeú8^è$è_ühit‹&¬þNM«)(ïXc–ä¬zL\ӑˆx>ÇÛ ¨p ièÓQìL¾;:äDôϼá E´Ý¼j[XÅ(#ý”6—*Y~ä5^åé€ÿAÍ¿q«ÈÓh ÑS\¶KFúѪë¾Ó¬<°ÌüÏ[¡ÕĽ"X"vXéX“ÒRjÊè[}§ÄL šë•JkÎ0Ï()òlq^a�í·ñSè Óan u  m½ ÏÉ¥'!;ü‘U$b­žjwA_ꛪS˜WüiÀºoÎîÌýlúíw½kÓÊ‹tìÆ>”MO¶†Bf²›àY¯1.¹¹òUãR"V:>wÖêÚ Œ³Æ&Ò”¸ zh™¥ö[xj/T£âJ–4šy"õäxxüW¨š¤Gq Æ-&¡«Ëkï3UC ¸îê¿{¶Y#.¨¶ ‹AÏø´õ*´Lé˜âSþûL®¨rþ$ìÓl!íñmEA}†]Ã:E5°ßaæðJGÐ WǦ)5p€èœÏ8íöŒg¦w{²"y÷–ƒ¿0웋Ê4½ùy>éÔEþ"áȨ-BÉf±"}ˌƹš—¦Á¸ò êQ0ˆ|À&ÒËø4’”MCw«[ ˆº«÷W<DH«QÛ8= ÕIÌ9mÎ7«¶R¨ŒÐìv*)&iZ€‡ „%¹AKÆ4eœ‹«$Ý=UfxÏ¿‰M¡2_06o”“fµúÏ”šÕ—{UîÀ;Vjêð ¹ÁW§Œ¤=sÅÍ%tÜ×Q6tt $Q1Lhù ŸftCÿÇN(å^EðÁ8Ì´Ž†Â`§î‡Ï™«WœßžJ1KÄS>LY”µ„NY?xðd:F½Ðqò´þðÀÒÏ‚ÐD]Ÿ‚,}vzΣIÅ\�mW[$l/½üó̈Ê:‘Gx 'ÆŠˆ£EYÄjwˆÐâžÞ°mqØ¿ÂØ~¢ˆeZÌ,ƒÉêù›lj°Å>Áæ] ç"IX}QÔ¥@j’9;* T& ÿz™ŸñüWd,‡Œöbº]¿onLL\•À4)xLßµmxEJÑ~ÑÚ½k2ýØn:¶HÅ’ž…n‘Âߧ’9-ÌýaoJQÌ°+©åæä&×XÎÉT@5A-ú¶|›UˆøZæ9*´X(H£ O[;srz§~7š“é÷Ž˜±š‰ø¸ÌZàåZ«½‚ö=ž ÝnÞÞbP¿±Yˆ*Óix ÁìÝþÜ¢¿‘lB8öp6_ç ÍFuéAõ®‹„»ÏŒ¨õŠRœx=õ.V[ Ð/§ÃªázöºŸXmtîÏÅ1EVŠ–ýä}“Ä®¾òx¦¨£}}6. 5jBã4zÐË ëi­A´ÅÖ÷€KÜù�PSÀúJ:ÒÇx´r#qŸ%¾æšàÌéltÊ 9'Ì©ô™ƒ‘n%¸OæÑÂ[™ä™žqºQq#Óëeq2 (ÄÍ#(Ói¿P/;ci Ëîf—-C¡èDD“¸Š)¯°¦²Õ+¥ˆØeŠXÝxÕP`ÿÖ“·ËrG  ø#0¿åÏÝ»º…7~ª!Ê|@ztƒ9£í4ü`6&* sš?öžŒìËI¼s»ø¬e Z.Ÿ[7Š7Mn¸›I XÙ}G'wÑjLã|P™ìMi^pãïÿV篱c®S¸]ªGýßΫCgpæÚãÁ±àrÌÅŠržv·Ùái¹KUgÒ"‚T;²:²²¦U'÷ÊáKÝÕu&%Z'­†sN;+33c¡€y"SX¬Kß9µC{q3Ê2Û{‰Õ¢ wÖCM#ÚÝü¨ ¨{Fvx—˜gÞIás7Bã»Uô¤ém›¬³…§¨`AIŒv‘óšc餵0:”ð#PvÞð\gK{œNnåèë §ñ¬Xгà^K¾\ª׋Þp¹U¤aŒmlqòj™ç—w é\k"*ò†Ã�ÓÉSÎubáFÖú™óäk#Ê(Kü&¡ð_h-MÖ£Eä½j7ñþ>†Ñâ¨õ«“4IìËHÔhÓ¦ñŒ¹µÇ’óÂçr´@ý‡4dðid½Â‰!üËð(DXtô¥E=a^ ]‘•ãëá€\ͯ¤a¹ŽuÄÛ×p• pÌ¢Û ’’ÔaæêY~§.¤¢ˆÓ¾AAPŸ½I…ÒæðäÌ‹â²E^Ñ¥‹Ôud¸{´=AÞþë#¥Qp¨³®ÿ]^ÅöuÅe¤¤»Qñé_eà—:¬[COo¬Qø‹Z3mÔpÙ>a±hÏS$ì~Ò í'Ï~{p’ÌÝGëå‹VÆ6‰Ï =e>SÁ´ýÑf]˜2%6{ïµRJ§ çüË æ´æ/óp’ ª¿40ÝÔ<´ Œ£Ì7bãå¢b:ûspvâ1mÐþbt‰ù<3DànÕSAÆç¦`7ÄH®ôØWr´Á¬DNßCJ^uÒWP&.ˆÊ¨vœè“þø L†ª¤Õîp–€%ÉÖ€í.…)=/=Œ ¶´¾ªZ}·K më¬hpT`w¹ìSe oÐ÷м¶Ñ &®§ÆúfPý%ý—÷p¡±)‘¬ã4UóSãy$LÝÛ ´©ûÖ¼Yæ¤X¤¬ígŠäå·6¤â@¹Í¬"ýlˆ‘V~~AQzì+OíäwP—îÜï,ù´s&¨?¸ËbÒ{´ü8 jT&Fp]f÷?ŠVL)–tBÏ)á^œç¸1ýNŠ4úOj ÕÉz<�›·®)³µµ:ÜÖ·FØø°Ä ‹3UA€ª¯‚Y1þôlfzšêß¹Œ|‘KÖ=&úØY?»1žö£wBãÐï™ÚD¡HP7·ú¹©uÞVÁãÀ6ÙvfbÁ.ŽÕÑãU÷ƒl]Ù.b•yÕ¦Jâ…¼d}™,Hº£åÁ#èž`q'¤@{îõ6‘«õÚ˜9"ÝÄn¸+«Ò…Ê•æ¾’ '¢‰¹2¦Ž”É„žù»«»ožéðm± ¸—¦¦mèMË™—J,f·÷Dª¹ð?ÐQR¯ù‰ÿ‡&1lb[oRº¯/kasX#q�?tj|™ÊÑ^é²'‘?ìå3Œ*Ë­¶¡\ddmìvý;)@WjC &�Ѥ#‡"oÒQ¾grîoÕýUIlPØ»yãaÍ9c†°töÚ‹{VŸ‰›CÉÜtõ‡ªä©V&I…dŠEÏDžTt´Ô«du0oþPG<õ¤hâFØÖPÅÞx¦üy„¶l/w3^æs‘g×+‚”æœcgÊ}ǽPŽ8Ò»šähÕ+ÑøWŠaÖØ8ŒµàЂ[ñäÃñ²¢â/Kî8qR5lOq®“ ?¦8†»b_ÿ8¦G¹Ït®íŒéþ%·ä\+6/gŒì<<Ý…&ÛaÆ{Âw±·cÑñ�Ê*¥ì£½æžüá•D#…'UaDÕ_y¨„ áê<è{`¥¬Á§$ÛÃü_hú¬êèsè/\žÙ eq0‹CŠ›_„¢ªbR6aá_² è[çp-º»£ìƒÖÙdýNûÓ="cM·é3ZlŸŸ( f ËŽ¨‰Ó¶ëbôzÿò¶DL²r¿ØÍ)ˆpÌ ‘–GËÛñëvµ¬.ãŠéuÅùŠþë›Ç‘QîÜžJJE<»«Íéâ‘<þ·J-/2Ï?šN³¡+ù´OM—8‘dÒ¨°kƒý)¼äPUnNzâ3}³»°^®Þž±ƒ¶ÁW÷Ñb.«?ɽYþ„§]º&4 ë¬þ”AòÝ(ì”\̧ž.†gÅmD¾«Gè´Æd¼,2Ù¤2@?;¦ê+Â,¢1;JUlæ¥òoJDqáð©\J®þÄôDÔ70¥®Åanð•ü^Ò1û­ìÅõ9£RU¡0äòàÐç”Lh1!EºÖQR ˜º;¿yž—%Šá•‚“ö|A7¶ºŒe�BÓ¥<åûZcxæ C§‚žòwÊ(¬™HãtøCmX)Ð�;Ób/ÝåÕd8ñ:(ÌxÞ¥y6šhcƒ*Ï÷h4É¿ËÐò'å†_‡>P8*)ªLDÈH„ç Yð—Œö(*¬U¤ ›™¶_Ø.ª ƒ)JsVNu+x2&Áþ¤|±Ð%…ÈØPouƒ"g:¸ÐXñ¡×K×>Ð ÓÛŽžnrî<î=XpRÞqŒ´:‰CãÙ»3Y@X£¾ŒË¹¶ò¶f"jò®GƒÒÔS¿gxòqŽy‰Ú‚íÏnp"2YŸiè>ûÉOµTR¤h1%ÓÑsþãÞ˜JxÃ[A–ʼR!ƒ÷6“E\ŒÙHêqGoÝvýz‚}ƒ:·,\$¹I¦¹Cz±~ûEôÂŽ"VÉúëS?û`gî|ðÙŽ^ùnn:ŠïJ÷Ù‚ÑNq©†V¶“‰ÙÇ®C0 ô3ør—‡ ;ßP23d`X\„Mí¥Ò-¶‰ïÛÕ^- èÃà\ñ¨GDÊ£9Ë®…ßKÝi‘f _ª‘)þG3&…t‹òÍÝ`ôm}þ�†Lt:#‚¼.Zx‰âÀåŸ=áP{›`ìSÌSŒèpàuì‚Õá/KÅ*rR<üàÏÐ'1]¿˜5Ùêý©³ûæ¡Œ û¼2¾‹ý)áù±äó@–µ4ý¾ï_oEªï„Ha÷ŠZŽŒ³ûá,ÝÞ…dÞ+ý¼8Õ¶œ´0ÀÚ¢7ÿöêcF RhóÎ(KΔŸLû–µ3"ÖÂV)ÒïQ;UC Ç ®õË�ÁZ<Žqø›–Bu=!7v jÔG*]`¬†ƒu7ßðz‚âoµ‚5uö=¸“j’z¡âÒ•°áÎòßgV]O<uÑh؃V³î<+–uݯƒuÛ-„;€LÆÇ€¥9Ÿi˜-ïL<['*™“Þ4^®t£êˇjxýº�’¬}×݃ÊÇ~¸’ õÒÖãă\j²>}4O¨Eî+hQ6Óöô~ ëŠÔˆï�)E¯Jj­RýƒËȳÓʦîæ’úø¯C^QÆšM†ö¥/Î*MÝgãùD_ekÁº°tG>Û Îæ÷5;Ús~⒰Ƀ¢±„Ý*B–s¡â Þ:Ê4d&™’zÙº7Ƴènt«/m'¾[-gKÇÏ<ØC›ÞÇEˆD5»ãÍu/˜3óú ˜;·=Ö(næ2ˆgEE€^³höª¯z>úÙ›¶…¥!¬þ$Af²ÁeØý¹øÚùxùÓá€êÞIb+oô†:_lPç“:OàG­*§°™#õ±QÇy»5„•%:âÏ£§wÌ=�]w¨¬z2•D%<?ˆY{×~FK½€.^$ýÀ8.œ_ÕDÜDôj4°l&O 䡇ÞG§‘'c6ôÈy€Ç¾=]Ò¼Ü] E埞ÀœŸÓ üV•C�bWØ)-…LÛ£“lë¨gŒ‚ãw”6˜Å¦ÇäGæiÇP` ˸ÕæÅA†Œ"iÌöºÑ·µN/ŒÐ"ž‘ÙØÏýuN»¹«-EUu7¦Af‘ªèºÕ3Ý6%â_;^ß:_»ÁcdT_÷ "¤*µ‚,ÈH~™@Ï;N hwé|/ØSðªÚ��l=°²Â´ê&:mj©x”¿p¶«2_W“bPËÖ­µ¯fx–£ú`~j»ˆ °O“t¾ hø¡4Qú%_"‰n6¼c¼îÍí/“W§›jä<1kf¨¼ÅfÚíçæbÿ‚¬bÖ¹ÃTÌu,†Þ ÅUheÙ>4jëÆÒ3¬V ߨæÓØMИº÷›Wru ö…î!vžþX÷¹Ð–à¨ð(O>BŽƒåœ½ë­Š¹Á’ºn ëçÄL¢€3Ÿ]ÐEuhzx§—…‹sƒî`»MX|2¶OܸwŠBž@W-wúÎÉmðoࡨìAµNÍt0‘pÍá'|åâ9±,Õ© >9†ãåËÂÇYÓ38×tÛ³úÇsN$Áò ¬Y&û€p¿éfpê®–f iµÐ…g}í<ÈŽƒqýÂDÕÁ ¥#´ §®epÏŸ#_ÔÚ 1aáŸf„‹S$e© í,þz™F*ÐkÇîÓö.¶agPžê¡ò45™îuùH©“–däFÕ nÔý¸ýÛ¾_ú°ä\µ–3“rNÀ•ž£Ž¾tÏI½~›ØŽ} ùoMs¡A�Ä‘…Ž?èlú—– =Ò€g¯Ó¾[>C{&ÆÖxÚ@R¼î]ƒŒ¡;š ‚˜¸o™×WZÖeîˆnaVë"ʺvc¨ùx¢:ÄŽ;Š‚hSŒL+{*¦§-݇¶þX] õ(æßû:@‹17Nø]Ö'od¿b)F±ý‚QÏù-p0t½h“2å––Œm­¨˜î(bb##<ÿJÎ2/@g &sô¶ë@’‡¾µnˆ'•†,x`rzuuÝ(â„Ês½ÕËð•3Ê"[0h£`»^ŠŽ¦ûæ(j8˜W<­¦xD_ÒBpY“e'î0Áýã’(ô±KÖ#&ÁØ£©ÙöÍO]Äþ¸^ÔÞ² ­;§½~¨¿><3ñ¯]Ïœi·6¶€¿nDžWkÆ}R:fŽtNwwXòr^“¡ôT–wŒ˜È;yÎ/7÷†R_Ò'7U„Üa5—ù\–ãœ*/ËôTì4¢r,¨Nýßê«xù˜™ÛΫÁ–]Õµ:ÕÞ´/ŸaèëUŸ›<&&âq¸™oÙoxßUê;ÊS}y²ÓT,FuE²ƒ¼þµ¶NQf¾3gÌ)Œ¸'¿¶;8]LJsÿt^Öâü¿ì ]º4WreiÄô:HrëÆ�ðQ€_fMAÊÔÞåQäHç²­‡.Ϭmµl Ò í\"Ýf=Õ{p{L?@•€ÕŠ^Ú—¸¾c13§þO‚ÖZ«lUÀÝK͉Z“½é»”¤^Ÿ„]M¸å[l×xç‘ Ý&u¬~Ñ浆bçRyIwdv´PæJ8°ä/jËD¹e‰�Aü­ýݘ)­‡¦ìÓ/G@Å:ž"6äAÒÿëÅ6f’5hÝj³Cêþ‹–ÕÏ |è*¤Ôw27Núh×õÙTQ¦#è ÀïýRù(,èKRôN¨2o­¨o÷ÑÖ;Z­æ°c³‹t˜À|æ\þ*žOHÑBpÝ*GÌš@+ëHE¨Õ`G¿‚Vj¿sàÊ`ù …Å ½‡Úw' QtQ— ÛÚõFÁ š“eÞ4Cx³™‡~W%LÑòÆÀcrRñ- 綗³tý,mÇ{ÍïÀ²&´G–øÎÜÚôðpöè=«©fc°‡Þ'óš<¡òcwþê”tÛî,Þ´0HÏk¿8Ãñ9±¼½Ak ±ì(­ŽÏ8#™gñ�Ñ�<ÈâhK36«Û’-™´#Þ÷®n¥~Š<óÚEaÁV)ÅÏŃ9Œ»qwÔ§klR~c—R:Vb"ò‡,±¨ýŠyOÙU'¾•ÿ«ôaœ.üÐ!ýƒžBÞÌžë$%àðâ4äPÛxÁ¼ÛS("§÷ ÌèfÍ?Þ(Ⳟ÷;+ý9uÏ rîBÔr½˜¸\›Y–îK0ȉÿB:j H=Ö o¹Åó}ªEïî½·/K[ŠÅÜ�jub'M½ª¿˜SeNeøKÊ"rW·)ž…+—Æ^ùˆ#?étÄ#']ÔàÊŒL¼ ß=—À³H(6Å»gA>þkY€‘¡@@¥ò«ÛÏ|#€Ê t|ö®¬¨^”yµ�’ Ú*«o8á`µmhJyIn»fJHém`ëz˜®h�©[Œt;H-Y›,dºë^$ÛÕò ˜W]p‹,Áâå/щª3’B¾QØkƒ5–C ®§õã_¿.å2 +e!R(Ý-q Fä>qöͽpÈ; ½€vW/¸ó¦«yO]„Ýè[ùÅY± P%´)¥•Œ”bêo}ñÿ¸qÍéß멽ý…,ýg¶]I^9Ú.6„¹ù×ñ‘û }GEqï»qd·16ÿ jd98,OC©\âõ·N'0ãNëvëòxçâJ Äv×£v6mhS§klæ’þÛc= ïoèQ݆ª,qíú•ñ/1 ðµsÙgm¨ 4@¥ÊMS#KÛ¾£H¢Ôü„쪪²>zYÌKçÚçq¼å©é²bðPÆ”B‡ja¨ªuT8áih1õZ«ª ’ìgJˆ‡ëf7a–nR;¸jèáÒ•4<hŠ`ížJ#ó'(Záô²#Fò#cµrcû4Š”µ©ÿ–íV8€B;=ù®*ԇъ!«ä£BPkú´V!÷›Vàâ¡Sa:f·7' áiò˜gP=ò|fÙ*CPEöJæîÖ}T‡ðIj| vû™Î²n1N¨q|IèûïGbÄÙŠÅ[Ö´RéQÑF1²éV_Ï;�QZ]ÕCÇ5åÆÜ�ˆŒJ¥2,“³¡ürÃøJ}Ê%eÐ}ž:Ê õ quuî·5åx‘µCHráâ1]É6´åœ|$‘Z… ÉÞŠŠº‚QŽRÅ&€ß¶ ÔqÏèãwi##úLM´ò4G °Ä½JÙC¼›CýWÓçúV|›¶×?fî•”ž d±¼P!´³ŒßA¬gKÀ7}þÃF­ÌÎu?œŽ4Ø@zMνc_Tne|X«ØýÖhŒUTõÎ'ªEE•yi+íŠS“ÓÁm%O@6ìÁî�ùØäóÓß4”ΞXæÖç!·õ[�D‚mäp̔Ąœâ4ä߻ݾu¡,ÒŽN´¡W´ ý¯½,•býëÌÆ¢ŠE½3/Ú}kVA&©ßRcùÐr´x—ä+x3ÊL¹…•–9ÆnðÉËÑÉ~±Ô|¡|†•}éÑ�žéÇ?IQªjdçú|Özü—äô¥L2ZÅMO‹)4,u™‚#µÙ!ϱ_ëo2¶hâDÔ=“ÃÆ<¢Q\žMñ7 äYæV¬)§<ÅÝÆsþèúÝá(ªy¯•zØŸË9Ú#ÝPåéÇ+‚‘øq<Tµ[ôñN Ëm,w,}ŸDÉØ$iß[ObBÀ&&òÙQ7üÖ›J…í˜ÇB#,Ô4ØY =óMß5Îáû­žÖ ¸*7…†°è¨ yé!?!¥W_êÖI¾Ù1J ±:b‡»|ëèÑ@©`è³Î@XFŽªžý Ÿ;{ÔÄ‘AÔO{Ø¿u³§œÁj øþ6 ³§‡pU|ó¬,ssržÚm2Zdkk~ê7ûUO Hø°—M×rŒ¿®»#ää Ý•›"ˆke»šÎ/ºÛœèü÷ƒ’÷,bô}¶u«1äY°1KTUøxí³ ™­špbt^˜»ª¹r){)RpwüÐÇ<8Øӻ埶9‘>HXžq;.ý -/¢?ç%¹î¾p|Ò`»¡Ô6ž-)»¶ ¼!ãÓqcúÞmtLú*¿/ί€réÜ*]»šwâ Œ[”dÎË7u+ôûè:¦¢†ÓÔÃ×ïV¨õ1cÊ@X$¤Öüµd±‘]=}ð—Ç<åƒS‘ÞÝWÖZÓ²á�›Z‚f*@ÝN\{å¾@¢T†ÎïÁRŽr8µwΑuV²)�sLIbëKŠ‹šúÌ BT­œ¯öçºq«¥=‘•uz¡ý-ÆjR![`ß ˜}¸8š$½ /lÓ�¸ye–HnQ ©�+¡î»íL4€Ú´[­v]'¯‘•Užyb¸è0˜s‘çŒ �NOùÇ-Žë[†ÀÝü…háÖ šˆÁLÑ,>}:8©JДF 4•9úúNó8Ž++¢"ÙË >0}§¦SB"_LJ÷!>…ßVáÆ $ }l2l¾ê*H>?=«ÝÃ$ókf÷ á+×ÎX EÁŠŠÁä³õ¸XôÙ4ÝhõYs‚v·^ß¼šN¶/Ý4´2Ž–‚¨ó)5.Ĩž»W *NžùdÓ0ÿâ°ßhêž_³Ÿ»ge”yÆÜØ<ÛÿTÝ|”h·“üùƒÊàÕ¢X*Öã~˜ì;$M•ž—ÄÝfLGÒÞjUæÏÙ>QXO3+â{üÓ\¤“ õ’_ȸ9÷ŒÌhÝuƒ`¦…õYöÚë Óù‰Äæ®Îô¦4,‘HeggÙ9¦ed”wŸÒ‹³Â?­AuCc>þö¡#͉ÊËÎøO°úC—v÷o7Ö¢ã•{³ÃÓŽêJtú óƒjJƒEŒhdc™ž,«bÙ\åf¯çKÝõTI½m=÷ât¿vê•Ä’¾ã õýËH¦®.¡òu„yo‚mnÆbÆaÖýNŽŠG¹Jd™ô™1š=×JÔ[½½6th¡Þ„ˆÊ.˜/=,ÌÒ8îö£4¶haB(›aã“̵îç©šÏÅbŒ”ÀdçƒÍµ›m:…å‹—Ó1•šÅ¨ƒÝB½|mif?_(èBuÍ5å§ÝhdÒÀÔA¤ ”Š®#+%Î_¨GiûÞÉ’¢i9üyn¿=ÊéÀCÝ=¯ÙþìùKœ§”Y-Ix†Ã3ûè/ã솩Ø<·ÌÛ+ßö's=R”Ÿ{J¾,|¿€N÷‚¸;#ûɬŸåËíjòññl(1—ôá?5%-C¶-iç´NöøŒ;{Ÿ8ÖG…;ž ‘™iÈõGª\gZ†NAó(9 —�†úóHP.L®`i°Ukn"ÆÃy>%`ÑJzïꎌ¥U±”]FÕíà¤×;ÍÅ eçÑ/nÆÇÏ~\ òcݧ̳ê;ßo£LΞ…vúZÇÏ*¢©•#¼¢ãõèQâYãgD�zûnU¼¶Šv\iÁ±BÜž=J6ç»æ®üÚ¡ «ðÜ8(¾½\éÔ÷3÷Öå8¥¾½Òµsó ð6/§›Ò*˜žÝÛÞô»k©ÜÜž"\è`&ð¥„ÂÎà5ôPr,t0»àgÝÅ=;MÛëÊÍ}ÿE‹>ü¼(Jé´ž€ƒæêt¤løÞ<׉ˆOMŽ»…eÅ4ø·�ÙÞJÉ-Æ= ¯íÛLÃÊŽ‹ÆQ Q¶ˆ‰Þ†I¶rsúqjûš±þó÷Ñ–†árÅ4-Ýø¸n<G-Gòhî¡ÛׇÆN¾¨ì$NŠÇÉ3ìD·â•E ‹ S.uIhEß0Ôã°Š b¯ŠØQÐýÐ"i¶Fá'f¯ÑúËö¬Tg´fÙE'«ÉLÁ©G(ðfyEÚ®¶6ª´‚ãEÿš>z7ԧ͙m4?…^r“n ¤ýÚhQIÄyµï6¨ÜàŒ>¸ºET% =ƒö«T,ýè`3fÑT«¡{)7c3íŒ×êÕt^k¿LæÓ؇bP„oÊbº½3-N*2ÙJçãŒâJæY~ë1v¤Bnqm>{: ÇÚ¦Ú¨Ý4œ—°£¬þöZB(‡™ƒ)ݘ^ 1øxÐI$¾Ms™4Á¼h¹k©Áç¹ ’æ ,™\o:ŸEcZnœp| 4õÍü㯀TÑBº†~À1£O8ÂýPN–•Ð„œÐÝcÅ»*[ÀcX³S:Òl½7ljHÙ …ä‘ê1—?_Vœ‡ú °Éƒ”•W9¸:UgqÁE¹D'\{J?î%ÅÒû­¤³ƒJ|kÈYª@¦¦¥-ÙGsÙ$Î"”½?ÈjlÏ GH½›=Ã�™._œRYØ·«XÖb ¡B;[/Œý7Ù¹Ó³“åû‘+ÔÊ6Lé\ôœ²­Ú?T‰¯ŠpkZ>ë‰BÕ‘A¾ßú áè1Ÿw¦Ðž•ý´ÙìŒéü™ó)õ)¿{SãÌüy>FAfô ‰ïOýç‹›xþ"S¼I“ÌǼ¹ÜL÷ñ|êð�ÑæÕ5g§ÏÇä.]Í „«¹Ïƒ|>úBº Ý.Fskþ²¯¡wÅãGïRQº¬{õk�q¼Î'cãØ_(µ9+î$Ç‹ö£ëç]¼öJrôÜ-hŸ<hiQýcf:Ná†ïS}ù°ã‰ù¿±žd”ï\ïu¼ô¨³R¦‹ñ~‰¾v”Öi ó„Ž‚Í¢¶T�½¼¾¶Š¿ßS=ñm\x²·ªiD–bŠü•¢«!ÜÝ�ó#Woþ„”DŒ¥]¢™Ä–ö‰|'ƒ ~Ì@ÐØê÷;Ñ6ÓLs‚ú¯´õÄÂpF½âªÇXˆBXù 0†õAÅy¥Îy\ìXn†ÈjQ\o/0³gk$Õ;´+g’‡ÙŠÃmO<¸¿lŽc×cÊÊæpØ÷섽©&«vX›†Ó¼ÅY·6Feè—Áj öáúÓ+l`üñçÔyx³ÇM[ëÜ(™ÖÛ4 Škþݵ*ÖÕãaœ˜”g_ï=(kc"‚¢4Ÿ®¿è)›ŸtÿRc>*£¨ÊmÖ²}õ£ [túêæ^:óar¬G¥Î\¥À…Óc1£vHY³[!ñ@·*,ÌG¥Q{c°ó2²•»¤ BÆK£Á©Ût¶¯Gé¿çy”à»·â°¸æ|EÎ-8–ý"ôQ§ÏóÎX;ÑŠNJƒsK{=¬7¶Ö¬Árv&mÿç)·Óa7Õyá™î}vRi,r®L·ëÎbhþØíÃâÞ¬wóªâJ+iµ§!ýV0mb¥^i©Ì\.€íj^t(“Çi­Vw™ö´ÂÇos6|ž†Ý¸”K’€Ñ^Æ]{ † •ÂRÑØ´î1nÈ`ãÂnÈèij·6…ƒþkècQ}¹ÓÎhÔТL'=k*8ÜÍh;dϵPÍïäSG³C#˜:ݾÏqe)åÔïöÍ¸Ó ï:i&Efð²)Ë ”êN*ùÁ¬Àì=È,¯iVžàJïd6J½™(Q˜dS6h=¡˜LþÓÍÉÊÌ&Üòú2ƒ88Mè^Ù ï–ì‚­™iE%½NP7néT ªgÂ5sÈ(a½üÒT*RIS¹†Ú[—Ñzëɘ|uK(ú…¿e•2U),0È.‚dVtÓ èXyÖ ‚¨/xèÉ´TëÒÚÝxRVÞZdêŒßlõä+v âLeª~)O’d¾¨b# È_úâ6µ@¡§Ûw‡ŽÐYßg[3¾x¾ºÇqéSß㔋»ÒwUˆÜ·¥+½[ÛÅ Ð(j…ÇÙƒ̸µ¶ÑvG¼ë¾oGé5ñ˜³=aÖjå„áZ²=ôûÎm%JÄíàp¸­o.£ÿ†þœd±sÔg_­ZÓÐ$_®Œ5¦°+£èKuÉ!ƒt¦ß„5\pÜ铳«ØÅùΛÉ¡Ãtä–^5tñ-h¶h&µS‰(­úÍAgQž2û“ï=Kí Y‚PYùqë™ÖPIvæB³¿÷‘Y0} L“X"ÅIñj9Èh‡žïNùPô_‹ëÓ«Xáh:-ÚþP6¼Õ ]1Bà·>ŽB¶àçÊ©ìZ±ÐÇþ[t{èP¨<*6+KëÁ£4r$܈þ w²Èé‹¢È\Ó-ÊGUÍÍJkËáº$YZqÛç¿ñM”¸³…0ÕŸ¶‡™3@E3°Šx7©'Q¿pÓ¸C¸V±õ¦™KzÓ¡uM8FDØ`~gZçé" ØLë?tXVTÂýyµ#’Mo!<‚sÒOüP=[Ÿ¯!©Å0j ¥¯4ÉŒåÒ�ªJµxŒtp>V¿M<½i¶–Ú‹‡Œ7¥“‡ ÿ•‘Hæ»à”ÆÏ“v­5/7Ý‚Oì¬ì໥ßæ3O[»ñ.}ò£ŽóWS½—Ÿ0øUêjkô¶^MyÜ*ÌgÍ›¼ÕS7J­-øk¡z£¯¾ÒÍ¢bÒ.¡»¯ˆ€6ÜÇäæ+a°W´ Ÿ÷Ÿ³öÆsßßþ`ÝÂ1Í£=‹ò«WVöÅ•²ðêèm�¶7œ"nG¹;Qý[ÿ÷#òQÄQ1j×Öõ[¹¤4óù8gO‚ÄN¢á|d‡¨¿–ŒÂØ·vÆ€³ƒ3C¹öÒÙÒ>RÛ¡¹x!ÿ%9MB_U<÷ÖT¨¦*ˆ¯«FÉžÔQe %%€ˆ€ÓáB׊¢°-Ã+üRìQì¸E±é©Ê\·¶YI)УFw¢nšîÂ#ßy÷Òf2у‰ç–ô'bª‡//*þž¢:¢Šý.÷,™#V™uÐÆ;mÈ'Dƒ(÷ q„Ü mŸV×z3áLPˆƒ»æpævhpå‰r7¤'e¶@Påt; &òyr%ÕÒüyÆÀˆSãKwø³ÓÚÓnOŸÆ _V–Œ€/ýqxDLÒ}‡u×ï~f„%1R’[ÃÒk¡/é«4†#/òZ'¥[nµuÇoñ‘'yËã"ò ûQzçzþ’Vº¹9�Äq ñĥʮúŸóíjOph/8x *ôx§.Xäf ôo¦2(N rÊyD=ìÖ ¢ñ²¡ÃŽwÀ5ù=N}=Á¸bVñyñ¦E#%˶KÁÕšèÿIAþ†ÞmîÑ)˜u»‡°¶î=­Ó•Õ”ðvJÚê´FÃ8B<Ý•~öØcš°È͞κr»ñÐä5Ÿ\ÜÓÝM‘ͦ¢Èh^�éX¤aI‡}ÛV-XvH«>L})V,©LxÙ­Yü:S0[W²zZÒ†ê{z e­¬m,ך¡�01–wEž²šó÷Ÿ‰RŒ–5¿¡[-]º=Æìųâ¶ëF߆ \w¾ø×wPq±zÁ9 bÃâÑÈn:( óŽ²}Ó¨ˆ`Ùž`û`„Cëk˜Ñ¼ÍË2_ •àLQâSg QÌzO€MÌö ü‮<‘Ђµ¶kzG�©ÛYP÷8yó×3ôt`#¤’ÝíüdkA·9‹M럫)2:mÇ1ùF-¡¨|㪄·§,ÈŽ >ì>'µäÿîéëó.yÙTô·N³6Õ˜è3OtsÌ>îZVÝ’0ñ …Iæ㜊`ì#0ãT¬¨©û=ûܱ m-tRÿɱ) jy¯yÊ’…—p&O4({í‹"˜nLç¥ý2S6æÿo¾EIàÜq—„>ÿça;üïþŽQ¡ÝÛ˜ùÞP ²†E¨•Ü.«ÿì´ˆ©ÿ•D¾<0 †”Rç“™Ó˜Š¸zTãKEz_ Ê8cU¬ƒj аº…ý¨¸`Ù«?–)½\Ú_¼”ÑO¢‡Õ¦AaW6Ñ'>›M[NEªы[¼B趴C ‚ÑÉÜlkf9”φVÙìÚ5Á|8±¥€Nâ¹²æ¦yÿ£Âp!ðÿtZîmÍ`G¦“”láO óX¸Ü—Óì+¹‰/vž­ÁS)x¤V˜_3°)Î'_íŒêŽ¹¬nÎùH´L2¯“@yÕœÆA~¶qŽé$¶É¡=ý¤ZK Ao§xhˆ0"÷ hÞÚ«‰ÒÜugfE‘aƈ¦Iæ„rgÎâåOOh²Å…ú0%){Ú€ëKyl;ƒrkD™2J:Z»¥‚G¸è¡CÊ‹¡Ñƒ¾_ÐëòÒè÷P>!ƒ÷&LŪ¡µæòÚçuŠˆÝ¤^Voê '¡`È·7Jû§Ýž•àm+Ûþ†ñ;¬Ç €ÞÜʇ_ÛÛ Kckpü†ºæçèX.X•:•>ÒžbåÍe³<E£4]ô_ªàððY§#z¼7ñ(÷t8sºþ±Ù­Í¤• @‘†á¥ôXØ!JcŸ,á‚ ¨¹Z˜³†§5‰ÄL ·Ð]ÝpãÊ2ô6#VÏKƒr£õd"â|{>Ýô}k¬Ñ»2y¹ç>ĺ>t˃äSL$ëtηV9Ò Šü×…ÑÁBx5ÁQD#Uvš¥µ¦lÚ©Õ>q!ˆc�A«GüJæƵY‘)·8Øćài<,£…�wœÊg¬JÉÖ_b:Õ »þBûÙüûL ÞvA ƒ¨9¯áÆÑÛ<gÎÐ\¼±†&c®ž`ð"«œÄ³eÄç\u¨*ííCòýîý¡5ãͪÙÒzsÊè1דIí{ˆsˆ™c3È¿àW-ö«'L2Zì¼Fó¯ë €b…p½oxïêú[Ñ~µ¦¼3í¬ö=NòîÐ\ @l%Ü‘ Ò­¸]ü¡½s¡Ü™C³dÚÌ.’–:ÌØûãiðÔŽ^ÔéËš]}‹D^"† %aŨø†‡Õ?žܶT[_XöHƒä@0óo ’=ÚTÅéâ-€ Ðu3ÂÑT´ Þܱ½ÆR®?r"²²Ê»3:Ï`g`-Ú¿„îÄ¥7½bçÕžBXʧ8¢¯°=ÈGÁÁØc¥2%föÊ:ãøöˆü†. ÒA36 •&ZÓ訤)#ÿþRå5²œ Í…ö,Ä ý™ˆ]hPpI›U³¿'m‰8¿[ã<ÖUdíõ8ãÖk~Y\üß~üÌSrâ¼Ï=³ >èDÆAm6ß“¬÷„ËÙT{O+½iÓ´Š‘Gu°ýß&CqåIEq -ãN{8è7K{õ¿m‘ÅÏdâþ7pc+è#€°Ðx‡}Ï€"Ÿ‰k ó°k±8õº·)w‡¿Ð‘SñLÀÁÛ]Íf(ú )-üîíövE®q–qª>ÄYÿ57¨ârsØ­j+ÀԘ5Ïääùê5r•Ka,DVGÖÑÔ*vs¢€3óCrcšLÏÚã¿Ìt-‡¾^HŠ¨=¿Ð3–gdI[Azr=¿ÌµhTâÀ{ÁƒÝ^ßé1©ÈíR¤ž6Unu$zéÎjjÒ[:G¨Ž|@‰ú°·?£ ?!R¡¬©ò:MtÐÁF¯j°Ÿ'í•â Y:¡$S…QS®Å Ž«nùjIåàÜ¢81í!´\›’‰>x' žÿýHKÝFÑÆÖ÷ýM’<ôúdÍ©@n~œLr+90Lcƒ;>4p˜§Œ¡Í2È]ì]ˆ3}ÚÚ;T±îg÷¹ïˆD>Pá/r'™•a©5-¥Ycã+Ð&¯m·b—<ÑCñ¯Ÿø#ê![pËy gÛ©ÉØÑÂßhä¿•(%åɶá­.§ø3¨ÊPÄädÏpä7©¯äï¯~Œ\ëq: ³d ™„©fõ‰a¶…`„.îBv ä<¤ôJ'^´MAq´|A ø”3ˆ_úVnÑ“r¶È}—`‡'ʤ7*ƈÁ¬:J€;¨BŠó9¼Á„D¨áƾ.Ù„¾»HýP ?µ<;JÃðC“Ü-P 5&…|!˜•VT?Šéš£vC8Ï©'ÎÕ$0άUÈÏõþåM^P8­?‘d}ÓhT* *VuÀ€oµ½'tz–,§Â”âÎëŽÄž«¿îP+om‘2 ›6ÅáK™4‰ÌË°o¾ükä&³=ù‘ù—üå²ZXž£»Öl2dŽnN˜ ÊëÇ£}}¬ˆE‰'¦'ÙÖTVÙ¢%¹Ô3ìN„ Êö~{¡RÚ©SKbå+èuZ ƒ¼à„²í´Zû5¢Â:—ªÔÝ‘ªÁÜ Á¥Ì“£` O’­Ýºnƒ¾øÅj£2jJ„QSn+ûÂ) e[«¦²ËÉs«CÇ©©%j>°4Uo ]Wn¿7æ¿Qù"s!}þïÂzTy&IÚj&]ci±É"4ìõ~v½§Â{kæÓ6ЩúôIz”V ;õEýúAä›w>+=îMb„àÊ ïô GSºžùа‰pXX(:-E°–'tWÞ`<6àÌìŽ\å3#èȼ:¬.Å´u}}ÎmýC•è K°—4ËŒî#½_¹Y; 5sΨˇ?ò/PÒ¤rðä�Õf>[žÛÝœQo*Ü­n/Àùÿ¦�Ñ0)Â)!•úÛ*GݯYeC¢§¶*�y5`S®Ã­õ_û6¬à4ÎqG¯ûAÿ2xhÛW@í7€Ü…Ó#té (]ÌÄ ªOfË´ÀE\ÞZÖR’aü3ñã×¢\.¸Í;¤ôsS{Xî¿vNõ–Òwûú¦W? Så8^.ÇÆÝÃÑ÷H™l sáD·öTM™L06l}ÔÓÚ7VW#t1Ù vDy=xИ51ÍÆ&GëNÜAš:&\<šy¤q¶°É‚íDQ{R£ †7�‹ëãé(6V<ÅéÒ-”ÖºE79[˜¤Ð¢ÚŽ´¶,F 3­æðsì´ Øvûl›ý(C¶^¦Óþö ½&£ÅA†OOª”±‘vªßæ©�±šwÿvVÎù‚|±� Ñ‚=ÎPoPê/\æ¸Å8á×ÔHè~ÿ'¤‘/ªMw ‡âÛŠÈ¢JíIê.ìo²Ù­é5g¬‡¿¥'QÔ³§+øŒ'D¹#âÆxâbÑóÊ|h+ mÅÚ¦NÊ¥=J¸Ú]YO[3M%È9–JDj'Œ¶ëj4£žI$Æ× í…>r>X5ÊŒá¬t¿f[ðÓé -Í=«MÐQp¡ a’´!§d¡®aòžI¯9Ê÷‰–™‘ÿý0(:4³(P˜jã¥à}–]™«²ç]¸ýv~œqž%[áÿ¾ïÿgÏ;ë4n‚EÅà‡´½Xy¶…&Ù¾ÞÑMP:øCÏݵWÿg|CûpJz€Ì†Í~jý U@`gÛvnk¼Ã†upØØö-eóÆrj<­¶‘m·¾ Ãaƒ.ñ ï}8_fó¯/t‘1˶§Bp[{:‚HF%× ãÛ´¹i ›uÿÒÇ6g\3§ÜÒKšÙKŠ &{•Ú*»_Uó,óv±¥ùØœ<?VÈ · ÷¼YzUdú´ÇoôñÚÁÙ¢`ôél ÏH ¯º‹JFÖ x÷&¯LÄêêX}GÕF<«¶o~üóqjŸeÞ–eV¥­u¨{–çô±Wˆè€t–:—kAx±æåç·›i,[^ýå®D/ïˆ_:—qê­‚žßô¤èøˆ³3ñ}PÂSÊXôŸ¸È|eKVrºùÛ­× æ9ã–$]¡zdi[îUÏrnz—7ñÏ–Q"¤ ¶d‚G±õ$!—}}žÄy{ky¥²+î8Aù][\'vRáîóIònòÀk|2;Hé|ÁQåxo¾­zŽžWÌ´¥÷ÚükJ•ó,7•Nl?Ê@dÕµŸIKŠÆæU¤}jƒå°»Ãª~†êU;œaª|²Ìƪæž#ÃÖå-A.ª73ØB´„îI¶Øy<ŒNE/ͬäo…} ÏõŠ1gìõ[:T%#ävª¿:'\ö¾Ñ«:Y„B«.‚Õr:í§®û½(‹¯°¦/dL‹láÏPA'. ²íųáÊÖ`í“vÃ?kH<B¡ÿæ7ž¨›U‘æñQÂD1ªu+CsioTûkåä¸ =‚,°K =Vã‘Ã;üF,1öNºâyLsØÍAÇÊæE[Zå¥Ï« /ÎÀ¨W—â‚­?(Þu»Š¥«í.¸ÀÉb7ÐÃ_^oÎðHmí+Ë\dþ LVAŽ¼1•a’³È­"óýK‡Cñªh–Ð8ž+vlv0ÃÜõL´LÐ ¸½xnag.B ¤ã™rLÊg»œXètµU,¨É2<É]•t­Cß&Îx†ÃÍzˆÆ,7ËþBÿ p‘J˜Èn±;ÌjmV™~K.ÆflQK®C˜ÿS¿íXúÂ<"¡ ¬VÀGZHjÓñøŧÞ/'i³4x¶óˆ¿µDOµ‘¾¯3W~­ßZ.äY¨Šn;àäœ@÷#†qúÌ»ªtS¡+RúÞOK–PD°Ž³Øè S±ð±ž0!aÀ/\þîfCÍ¥Ðx%°U~óJ¡¦EžG§dh­c™£ ïrFÿ…®†ÁܽÛ&^~;,‚óåÏdÚ#Ë*ÝhÕŒBhí¡‡hÆQ¯ƒ¢Ì©%£,á û>©™ŒtŽ‡ÑØî,ûìY5çPv©tõÐä.‡³—†AvÒ¤­| Ht˜õ$ÜVkAD wàÃífÕ/2úH`–ôcg‘1¥íðܘ¥š¾‰±L=Q8ž´Œ]N¥ºh"=J¶!a–b-G¹…o’´” 1†¬äÅ.å¸Dý¨Qi`ûV5v}¾‡ªGNý(ñf^ŠÈ);•&í!¡˜f ­zúÜèS©;gÊ.š"xÈ4ª3ú9ǵŠæé8Þm4c§òì‡Û׫Û\¦¹É…1}œÕEÄÍâÀ@ƒ,¥d"Y/Ô’$[JÜõŽEÅ‚T*—6†u³|S$õFA"§´Mƒt»öÖ·±QR­_¬�–V‚°0·]ïüêÉÐ/)ã8óœt#ÙSU­4€ñ€·œY˜šþÿöí½”WæùV†­ÖG8^Ì3� wÛ5¢Þ‰ øKzB”§ ÆRÀ‘év°bìQËŽ•Ñ5ÀÜGfžQ—€M`2å”F ZÈÝz ¥½2`‰ ÜÐu­ÀÒ8Yt9º4H ùuzžå~¡Êz„ÅÒ`Pq¨¿¤êãCKtI¦ÅjÛ\ÇLø¹ e¡+�ì2Qø,A&ç–õ~AØLJí/êÖûÔ^ÇÆz!‹ÀãOBõ¥¶csî¸sz ªu¨­ MÏr §Ó†¾Ü•¾jVU‹`F´ òþäBƒéß1Ázk芊sÏr™=ý”‚:P®‘~žÆmÚﶆ§V‰-ׯV+laWÌEòŸÎÓÏèú¾­Ï6ýß„(s§ç€pI÷äTa«_îbÞHôg†E¡3'Çþ¥£ ŠFI%Ÿ„´"èKT·ëÞ~°™‹ÐWf‰Å/+>-ì±T’è±ès±¢,Þ¥~翺s ›F 1ÒrÕíqÀtõL?lYŸÇ»ªEÜëŽÛ}¶Tól»ŒÎ ¶öü- Ð )cpáu¿f² Ì8gÆÆ-]–78O.t§Ì.á†%ž¬.Ø!ÿ/0àÝIXøQɽè4ÚÞíXÃÀ­±WÛ4íÑ8h`°\®cE²…°¢º‰ïâ²Ê' SèÜB02U™§&C§8BàJ[ìÕ¿Ó´k.Հ¼ðWB ìèQ´?>¸Á|N§š–/·R¦‘Ãà[}¤4œ½i)}$hvg¥c:௻ú‡©úËþöüqF4¬ÆO5pßQù½Þx9úÕ»©²ô“™¦¯ý#ÉùÛ£­2ît>ɧ"ÈèÞ³ Uç‹«Puæk7)G–-;dÌòèÚxn;õ%XßnéU½«"s#\Ç÷…i¾LœÃ¶n­¦¡÷±(ìS„ôº>ª¤)Rm»èÕ-ZÆÖ%ζÈÚ¾JKwÄâØ×ýXÏö´9nkãì|õÓ3Ÿ•òzüдôõ“ÉæCl©cüÊ- |»ŸU‹JÇP©F;øežë=v´Ö€BÝ»2&qé 5›�Õ:0J™´9î”Ñ„h+Ÿr7Ì2E5Õ¯N¡®~Œ¤ìqž¸”ÜuCë­§O»‡CÃq·ò¸Ý U®¾Þhå—yœy9cÁNåZëà#ém1ŒQ;Ü÷;ŸV)Ëúô3Ìù¾[Çû¸`ìÌñ NhUú>‹ä¼é-“ñ虄îêÃz…Ó1`ȶdC#ow† W9~{Ñâ“žO­Ô¶5ÃÞ|,ÅcTEì$ïEæ¡çq”VS1Ayh©’ïç©ãvŠqÓ\gAÑúJˆRö²ÛÔ5‡vãÕ¯ÊÒWú£êc…û§iûËà¡Y,ë@SªÁ$< N£aÉŸüf›|27KxWÄA>iê�ÈþJ-µë?ói¤ ¿¯§W{Ý<‡!åb�À¥òøãÌÇ°£ÁbÓ×åð¸d…#‘ä¬èn¥ô±Õ–th ¶â€À«ùC;?êž\WT¦×^˜1ðyõ“�ÒHl:¾òÜ*ÿâhw²±bs »sà(>õL’”qó"Ê)vÉÖê\’: =æ;x§²“EêS“RÉ­iï…ê–ÉiùÏ‚7Oþ5C1)C_C“rˆm]Õ4xÚrâ˜+œ.ûú`‚•ÇÞd&d½Ø3Z³~î<¯mÙª-¸÷å I¶ªò™ÍByôx\œÃÑ]™ý¡Ì[饭TfÑC›1ÛøvßXõ«Ý´ê»àµv«öi…6Àã©*È×*Kû0Í‘¿:¤äú"‹£¯¿nü† O­Åݸxˆê‹ÅÕÞÌA‰‹[2<&ZbvJJÏöèaR¥ÑÙìiž,½¶¹€„«ÖŠS£€½ÞÙ‰¬øjéÑÐ1(hcì¸}AHðè:–ÿ<mÒ˜si°Î’€ùΔ§Z¢¢aü âe Lpöè­:2Vƒ Ãìé’z¿°0Ú®ûz{J›‡W¾sJ•†N=ÁÅx…#ïEºâ·fy•-`æM,”.²Œñ³Øh}õ-%)\UÔ«•™³ÛËÐÞÚÚ$!/‰„a0Îà ¯,Ú¼¿ÇÀD±�±±‘õ¿æ�ˆ@Öa)¯acOÞWúXºyæÜötÀäÎ…‹¹@^SôñL.ÌÂò/¡Ë/«ÎžlÃpˆµåæãëÞ÷@¬÷æ.뽄J{q½x¢È·…Š¾pvè/ÜQ€!ÜF4ÏäüØ€Xf¯øÙ??¬¬VulšèCÌ÷°µÒÜâ²énð)e­¼ëCù¼ }?�ÀÏt¤Ÿ´ÈJãHƒõ©·*|VCªÞ#­a]¼«üßÜ,Ô:75ÝÊé/ÔvÀÉtß@9Ö¼0åßçòXQ‘d9–÷vÀâ虣[mE9 »é 7Ê þõCLm’º„ÏjMÑ®²ÚõlUVw ߱협×Ê»ˆ(óˆB&£hžmõ8ZØؽ¯”¼jÄ„{,Ë·¢dù ÀvÊ­ç`®E×ïð9ÙÍ€¤ Ší¿6d¦ýoí¨W”‡ƒ~£¯w3ØHÑQfø{ªu«¹sãâ•�6g#;aàÌlßxEåöäSDAq_Ъh<V‰) a€u-á–ñmüáEpļÞ‡…'IÛ”’S+›M‡úxìÔÅÌ.:á¯yÍPJ%~X¸ñÖK4Î2_ƒŠ­Uä]o×^îû^؇ض0þv7C\ŸE…Q7D©0ïj§ñAù®›F4Ói=9 løkÚ~~-B9Ã|™2Ãmó½¿<Rü|TT ½OœáSNáÑ‚_ v–ólÆßcã©ü«¢‡”{€Ë;(qÖ:\k˜°{fÆÒµ~ÏŒ¶rìK©1ËL†µ¬ÜÂÜM ) ÑòÅø—^vüd h ñȈÚQ(Dúìí‹ía¿žœÄï¾Æ;lìë=YÂÓ·¬Dô›-ɵõ—Ò§_ ¹Qò'àÇ—I8«óó-ZüM¿°UÑÁtßéñý1õõf¾u=çŠý˜&(+<éM­�;¢Ûl.´ª!æŠk=:û½1zu—5[ô±Ÿ€%×è ZÄ3+ÍnÞF³yéH­cK…À®’ç–?Ó›—~U½£c>íÚ�Ðק©ë­^¶É^n/\’úrPpõCª­N`f…žèn6ÿµ¢µ* ±jÍ먢¬àÓ€m0jÚ×›cz;U'ÑÁ®lã]¯„Gò‘ÑJWt@=ô­bKcxÓAĺTíá×<Ì…Í%Oð[œáNÈ…[ùõØi7B»Öò§ÎèS¡ú+D& Ä¢ ˜þU܇ÎÚª7‡Þ °ü˜³8ÂÊÔŽÐ6Nt;N'Iåßìkö].vgþ¢¤ m×øûâU †ë=¿+ßZ•KBVÌijþ}öp®º©þ»ìÔi­åÆ‹¶™éÝ­}VÊeÖapëã×Âäiê:ù1RàÝHÛ3ú\{¥w4KÅb„]K×îOXa7¿ Çb.E¨Úv0U¶*ÊŒÎå°‰¡§íÖ ï¹B³=÷U¿¹»`xHÊZÝçù¡#_èl=„²ú“A4ÖNÓ©Aê:ȉ±vr¯Øâ¸Ã³ }Ÿ+á«pŸ™ý¼W Ö)Ú&#… ÆyÏÓn’ì„“¹FŽÏ&ia˜ä°g•ÑìgL3·VH*2ÄõNôd¹L1Ҟϑõ´ÏMö÷›øû[™46 �†k8ÝÉ·MpœUIb´•jƒ�~¢™ÝŠC‚/dÊû ,[ª`"(ÁVÍ·ÚžqÕë¢ß2Ï£® {îúu!>bÏÏXûhk÷š×¥¡B6õ©í†_åŒî)Gf(~®(«°“öXmŸèC3ÿãΛëFÇ“Ö“è¶ì§ñÜ÷c*zcÑÏhûñ`-êå×lôÔÂ7ÙÊ¥›‹ª‘Ðÿœ/X®Ú¸}-*^y3M¤vRù†ÛÑUdl. ‘{vÉúeÙëÆß¹±=^’ é7*§Áî‡#$Õ΢½ý¬ÝÇFŠúß'Rîl#;·¸%sfàKŸÚá€"õ|1ÿz*ð"-‚¹Ê†5ëN^î©ž"Oot±£^C³4ܽ_‚k‘¹q‹a3V­ÖçN2>Üñ\Ÿ%ž ‡Ô�ŽæÿF´—8­„Èíp£JqG‹²tvànx¬Øh× ¡;W¢·Qø…Þ·*¤‡B«¥÷Ÿ0®°8MæeöãA‰s*�výúT§œ«‚=}Ô¬Viǫ̂SˆO¿õiÚs°ó’ zë'5~ꉕWÿÚþl¹qfɯQO¡Ën³ÚÇ0—�B�˜óý¤}¹‡G(’¢rWÿvþ$¨oE>¬}„ËŸ4HÛ³§1)u²^¯=nÞÝf…p±ùS°§²µle%Y­œŒŠPß4Î<g™'~zȪ*ƒ¨×1Nš¦?ËÌ:|Šì?,Ò“¨²>·LBŸüÀõQA%ê—üÑm›‹' ¯ñýÃâÂðÜïò Ñ­V¼XtÓ©9ÈžPXŽ‹Èò>ç>ºTYuüŽÐñÛ¶Ë èÃù¨wu„­Ð'›<EZ÷Üaúf† Útôµ=Ý̵E©ÀXaÅ -¸^ ®ÆIì‘1 eltžŽÎG¿àUÄß’W®×J‚õ®1¤ýžªE¾¬A‚¶]ÀG4ê}2­MÚšæîêi{ºÅ8|Oj¬ï]erÀ±Gszñ”ù6'JZ&Ï“þ7W™jÌxüMjµŸG5Ðbþòæ‡qfSçÛÙä‹Ž°ÙJ<7 > ƒÅnÐs(3Ð5éà]¹'OAßÜð{-ƒ1ŠÍ,ãò‚UiñL ½MnÇ/¤O’¨ð™5Í™"¨Ã+­{!´évÌc®¢Ïj0 3„Í‘ñ ÅvýJÑß\IÃ> †¿ap-FX`žaÿÚ—<<º}5¶Ð:œÓ'Aí/GHeåj_ñoØícô~+ñWxGð´} ;}¶jNh�S=ÀÍdºõ�e+È+ôIÍûoC\ÓøØ´¼àŠR|6fža|P´)¸Æð™ úD‡Ô×_äAÛÎhöDŽh9ÑV÷К÷{P÷ÚQEèûÁ…r{µæî´˜}D`Á4þ¤Ç/²T*sf+ ðmæS®¨þp³¨¿¬T})y…%Q@[n< ¸90-kžO†‰~ÿµv ÍšBó§°·[¼ïœàCÝ3ýÀ-)¢«£›l`këvó–²põ#Ø»Ë_ý„Ñ™Þ$µí»EµLG·Ogê¦@OŠuó=‡˜@ÚÞ;nL=-&–ñ¨cw>ô‚½»wå¢N‘ù>ô^þTA2žäi²àƒ\¿Ÿ¿–úm¹\eYCÓGp¯²ª•/<Jy˜ð©øô¶þ $þ­ÁF”4tXÐ]÷³uB{ÕÛ+Õ²Á*}tEP~Zk 䜅׺'t_Ò?òÀ@‰QÄH«ή{ç¡}=×;Ù¢Dêúf†YëwH±¦,ãhAß1²‡AÉ…S¯›ìWgSÔ(Œ:'Å úðO×Ä=ôì åÍSAçdÕÑgð2 R›AñzïF·PBr™øPQ-_\ú# J„HDâ÷ÁíÜíaâÓÀå¯&"‰í®H!ʼnHÿå1·èo­)SÀÉgǵ6ÑøUNåÙ RÚ•Aá¬CÁ£ZžÉ›øê¨9 ó5 ÆìÇó,q5šxçŽSdíU½y)CY©Ì`‡k,þó¸#CîuEÙ²¥­zW(RæãÑ€Á)F‹àØ?vc‘‚1Yˆá ÷î:“ó᨟Žž+ê¾E@¬M= 5æCRsq·\ ã{UtaL¾ò ´s–TmdÕ£88]fïb]üGqá«E@¥`¦›X’eù]wšvn°øˆÐÂÿâtÌ´hGm #œë¶ó´Wç=|KÆ{ïê›(¸Â#î/»>º³½gJ!×í ý/ŸE|sÚCUÎVñ "Á)®· §î¾ 1”ø’_Ðçî‹ š&ï–4|:Ønµ¼…¬+<Í~‹ÊŠ#Å(êwì¡oEWãÜ—!¦"¯?Á™|þè�'¶™³—BW^ú“ñäx¡?Á®õØùÎZR:é¿1Ó^â‘é“î´GºÛ; Ìêƒ`¡ò.h—1Õ<äÛ×›+g†'П‹ •êÄºÌ ÄSeK.}ÝÙËR"+ô÷/n×·ì“ß»i‘¥q¸RÅMƒKK¹XÚYÑË#òº§?ÏúW_d¤`_o³x9åT-@ÿ*ˆ­šKPlëÚgNô ï±ç?Š#.£ÿœÅû§·‚)̱Ëa=|˜öé† Ž{h–È Œ°»Ä»ÌƈBFTN&õGï2§!§ÎÈtCúó{×ÐÁ Ïc[OÓúé®ÏTtc—2‹BÓ‚¢Ñ{kÙk)’i—ÊW½Ïv(2/I–€ÂPÙ¹ó‹ ±¯óïœaã,w\JV'e´BU_¬0–‚ÊÅ‘E’¦_BâȬ-<F¼ ]ãIêÕóžY¸h{’Ü®ˆÃ®Z9©û÷Å38n ƒÎsóà°ç!½ë_ÉЖÕëñmèlòrù☠+*ªÃið;Y¦?4½´_ü-qgÎTÚ�eP-'KÁqö…M~±£Üâ7øh,ÆúlšŒ«Á”OΤåÿ½ P+k£ñÌäýK¢íè™$Eèa… it×ö©YL·ÕŒìå>w•ßŽÀDGå¯ïa.*=\,®wÇV–”ºÓ@-¹ä•ÐJj¬µ^ºÿó€+h¿þœ™n‰:¹¿°‡n£Û όܛŸì[#ÝG†ºš0™6ll¯ôyÝ—ÃóžG™ŸJ&y˜GîÒúüàurï &v8#F ÎuNnùôø-å(X ,Â놽<¸~7vGz®†\¶~ç÷HØhƒÄƒ²Q™3D¢ýé4:«÷õ£ýÁL>Wh,ã)Ñ‚¤šá¼ÂzQªâÍþÍ &Ï¢¢ŒL’Ì€}QÈ×Ò9­XžU¼Ç¬ÄæŠÉ·6”–8æ`aeÖ<O¢éÆß$až+mDú犜¢qàPƵ«6D'ÅõÔ‘Íóò”ïÒ»5ÅS55{þ%À—ý™­8';z'qPØQ'’›SÓØã[à?£=¢h•xsËŠE½#*cz�x]D¢óàÿ{ƒµ° HÐTØÁò oŒ¥bJÝÍMÐÂS©âìÆ~ªÉà Ýï Ì \vÚJp ô*úKÏÓV| PýO¥ÙÒäÀû3ŒCo;î\[ŽÝ<÷¾üùÜw¾’JeÉ‚Ê"*c+øîN)C4þN-ÙâØ·&ŽPçÒc/[µ@À±é¤ÙMþbm½+ÚA ¥x*uæ½1÷Ö!•5Á`b£y¥pL'來G‘S­3DÔaVìXc*nOów<r®Ò½6ô@ÑÊBi [.³dÓáëÊÔÏ»üvP¤¡y‰ž; ……j:K_O*x[ûþ,–d+ïŽAú'Ú·N7o>O¬ŠB…crÛ'EG2ƒ�íGZFVEX‚fòOŠ."Y™˜®Š£÷/$‡JÝ/ÒÈ1á¡´èòéiÒ\ê3}BœË LiÚ«‡¾4ÉÖI<ý’<È&m¦…žÿªÛsª²Ào”¯Š»¨Üùõ;¶Bpã¦p!#뢆°jËlÈj6úšnáJ¢Žpµ6Þ€°m€jÝ×J^y±'—N Y=hʤAÜé|>*Xó‰ଅ°ÐR®Ê\G´Ôúö{W&ÉCO90‰ÀJ‚´Qªh PGBg_i¡ÐgÍêλ‡|¢¸ÊÖbÑpMO04uÃvê.nèóßjãd‘º`ÉûeKY÷Ù+‡¶t3 ½¨Ž<v¿[ÿã}b^ø�ôÍ%"(¢§Aaéå\¼C[l6«j9ðš2/eiŠÐÉpñ¹:ÏQÓìÁI6'\V˜ð‰•u%`øè|ØSVÈ>Ý<£ícªüÖYóp©Zf­ãÎqk…|^.þ—éQÉ—öC:¨ÄP;,>:|Ì‘à5m]?hæ:MUf›£šš“"(¯§ ‚õP®˜J*èHé®?ýípÿ§^yÅïŽr²F«+`‹ùÿ”ñ²ÆÙÓhê{È‹]×2Rä;ìÂw‹ÒÎèÚŒ »ôº­Å!Í1T,Jõ^Õ‡¦iwz¨€‹©™ÌÛÙ0pÚº§7í¾wG{q³v˜e8ÐúÌ÷jÜ”A†Žµ)ñ I^x4võÇ ç9Míð G0ìã�ŒO‹BBô®–¯´XªÒg‹¢7O'{2éÜ+ ­° À6~‹è¯"´ GðÅéÝ7iF±§…Ý[{0LŸ©*èú£&'n#U+H!KsRB|¶&7&†·ÓE¤~c·Pxœ¥Ê´5«ý¢TK´õÏGåËü¢­z÷¤’F$m‘ÏÎCVÕ-WÆñ1ö¦ kÿ†Ê+:X£W”vHÆV·ÔVö®®~zLœÖ5ácã ³Ì&*ømqåt…LÀ(Aó/¯*òtJÔƒàUÃHFéõSCËGR+Æ›�Âí¦)yæsùÛ¿DÕV„Óg8º#u³QàÙÔ8yevHiê¥6ÎÀËþ L"tÆ¢½°ë³ 4ÑÇIûyîúÙê½ ZêS\:[}ùH-®Á�)Ûb–áKìŽl_/äõù+kÞÿ)Šu+¡"†"l™ÛŽX,Ò¶ÈYiKcÏY3D\_ó‹´P¹ÐBåàÀXÍ­ù[¨Èàž²W:Æ$}’ÊùHù™árÀzÀv·mÜÐH®»Vš¸Èqµ–‘¶œ<h°}¬cQ<Äë±”ÉÑ@üXèiì/žÌ%}AºO†´¬-“¿(ô¯Hü´Ú;úãâýVsÎœeA!o¯žb½)\ÜÅ}õLYÈÐi ³ V¢AŽ³íéØ™ÈØ3õþÀ1}{$Êl¸¹÷åyÑŸ€g™‘Ðü/Ì6ã›ÙFLe •a£Õ5ÝÖb•_%$„7®“¥ÁÜ hëð'D¨öŽš0[éYñ²qò’J)  "¢·Soó$WѤÆ^å‹ôN±~Ñ Ÿ:ÿæé”<¥€`ˆj”ï““2ÖÄaaOgSú<…¥kër¦pÙÒYh{4šàÉéÏ@­õë#°IäIf•XŽíž6ÓYC²¯Ú´=E(L3˜¨ ÐàƒÖ/h~¦™ïŸWB᧠ÒQUhss¶äÛxQvràùß îôLë'õÌT0­ Úž’Ƕw4Oï®@ª®g¾ËS “ÓÅYàœ¶GÄlWÿ©œÄX#¯Ñ¢üÇH¼?ƒ¯yÁ©@GÜ ‹ÕýUŒî¬µ¸r?…wGaêd*¸ØÇЮ´â,s,a 4 ¹ÿ/Œ»îX[ÂRN!ßI‹ ªÏ.¼€véû2Ä»z…d›gkÈzÕ8èd[$¯ÑåPS"#Œr ÷é8sÛ¤Í •Ùìó<H¯*iœdÚÐÂǼÛÓAEy3”xgjË¥õ[‘ꮩ/ÔÇ6Ñ´ã0Ò2QÓÈh;6´ÎÌ_5vŠl| UNµ¸h1T&üÒŽRÆ~ÚÃl³çoH™W!3I䕼�ŒˆGÕH*Ý+¡=$ã¿“{(n;ŠO_H•&€Ä![˜Ÿg3µfÚýã1ìËnd˜w€­l¦‰”¶ã.°òÿTcu=1Jå´65ƒ4,¡‹Kˤgflš2€}Ê_øK/¯Š†‰ï›…Ò•}³RÚNÚ3‚»vRú÷/qÄ軋1c ƒê((k=ˆQ˜`½;H7¥Ê-@;?Ack7/» Á]σ¢¾˜Ñ- È¢²`§ug $±Õ6ÙÆtàÌ(‰Î&L™áR €ÍIÍ›þ²­‚¸³ƒfpÉB6 ܬ:* 7ËSkõx­¨”Ñß� ëè¼™ûV_=,.%áfTÿð‰¯!³ü82ÕZ/®À~J¿rdzјIljÌý`‘“kAiLcFë›þ<Qž_®À´ø@üYs:ξ'óÊž9RQ¤Ú¶»Â˧çaeðÐÿásKw¡r—¨wù½¦3®‚’ä°—Ûõç¬Åf<”ê©¿ëúDÐ3ãiE-—!=<êem¡;*N±ç–ˆî -éÚ³ÉjkìhºÏ¿R%¶Hc!óémDÖœQÒ/¢4Â1}XsÉ)—Õ=¤µop>Þgû¸öšyä÷à£s mÐ¥åØF»RÄÀ8Gyào'p“¥(~gAÙµæ„K¹!w˜›ÎÊ5Sq¸¡xÚ‰¼ö7Ãí,½F& ÉW퉱^)«óy1èÎɆ°âû,xÃkˆª8óf¡@VAGÁ)û„w@ÊöØRÒૼÒD M£¥˜Ó‘Bj´ÓÓÊ*à¿èH›@°×‚Ñ@â÷-@d¥”˜¢b-Ç?}Ôe0}”6[ü tÇG!¢zà8n·î CækŽÈ ïJ½L‘"¥“²ó@ËPÜ´{keZõøͪ[ÆÎ^:e¸ý9eÃȲYâ«û©i•&7Œ[ˆöƒ<Y*4æUV†±éj /Hö'YìSai«ŽfùP{¤6Ì,öuÝ— ó¯•ö¼U[:×x9^»^hôò „j-á}¿0Þ®›-í§êÝÖÃÃ2g¸´á[^ˆ»Ãî@Yùc+]÷"r‚mEì…Y™Ú±¦ýivð=¿öô'\¦î‹ûÎ7¯^%ª û®í©þ³î~]†¯12ÀžëAjŸÆk?¬ÝƒK7d(hMUËÞÓ ¢;ÈÓMÕ_vΉÂ$ó(¡Ò•®ËÒhSn;Ù öã_SkpãŽLÝZê’ e^ÓNќƶqÆÃŽŸ$_ÓÄ™ò\n³-Á¿ï?Q$ë² ¹*¯ChÒ »S÷d ^$~»ê5P?LvzSèÛuõ´ßø$ú߷̤giÈùUtP±™1¾píÃ*xI ~'¢hö¾ïC¥}j3´~w:±Îåÿ{«Ïô\™¦c·¸'*4 Ja%§úÅt™e-23‚[Êz–ºé»_É#؉¦(så”iRÖì¼L“ΕÐ ”ó²Ë{Wßz9ylQ¯2’™ŽPï·UÃÈÉoì® ”d'‚Ó %„hWò$SøÆéTÐE‹‘J�ú×Á"Ï‘ÒP``Ì.<=lôÅ‹l+KKÊ ‚·™! vñt'0wêÖ*.¬ÅŒôµ–¨™EG1ú¼™cŒÃw椕ˆI¢Êe�™ç3¿&äYµr#O%ùÿÒ¹=m0#ÜŠ}%ïÏápfh‰Á¡P0úTåZ¶G²¿‡C°£EØ×Û!.‘¸iÇ‹)gä–²yð¶Á™yX®Rùå(<Ëœ>ku›˜NÅñªüôà<–·ŒÂå ŸgÜê[™Pq‡¸£>Xež ÝKM5‘U舭ˆ¨ ˜:P~?ìÅóM}\"¶¢œ3ø_‹D³º@¡U£Ša7!òôP]_êÕ…V)E£ÐÔ(ËÌî µç`Ë +‘Iûɼð}ßôÝ9îþpmá'Vwë¼é$²pƒS¬¥-ý#FΆ"³ðÍóñ élP@‡¦q�à'.Xž¸£Éòzt÷[wˆÑ¯FN#÷€Öz/ÿ<ÅF¡_‚P4Ù4˜çìÄbºM¡KQ\”ämá¼ 8:J¦;¢3.ʼnUžÖ\nY lÃ÷ІÛ© VT$Ž÷´c¡¿Á›ØóãñD¨,óöõ¦™]B«û2ö¥~€ß뙳P-¾åøÚ1Š<13–(uÜxÈAA!÷Ê¢æœéÁ#†“€—ÐeI”¹˜Í]¡™ ßâó]‹#ZV—©ÞÉg чխA‘Cqó*¹•ÙcwcF½µWÞ dÒ€(6|xJo9n_ß(±™¿ƒ[më'ŒLOw?V¬›aFu>2Iq¶»ÂŒlVYç\l£7ï¿ÙÐC�ÝèžD¾î–@ДA8w:¯HTl/ÒÃXLx3P¿å ÃKs‹°Y7 ÊŠª0³–rQ‘Få1©€>ÖW»íêϕ꣢#ú…ZØ*O“×­`ÌßAÏÍ”x�W¢ô€‡*·ž[ïþÜÎ'uˆ”Óã¡COì©#  ¾½Ò´þáYu£”äžiÑq´¸ûM£•º›P‘QQ·³Þ“°À8zjjúuåg÷”à’•å@)Äñnô¸€s·›¬«í/ÇšYè³ ›QºXxIè¶o€2‚ÃÀñðSÙbÍ¡xîÒšúS¥žÏµKö&³ãü€q¯Œ8­ð›Ázø,€[J€î”8æˆU"ƒÊ‚è³÷?´íÎ`é»L‡êЦoçùã0o¡l$6ÉŒ»C•ã¢Žz0›4íJä›ûîp|£L犞×a9;¼›ªòÐ9(Š‡gÜtxÞ¿¼?ÄŒÄué¼æ±jÕŠ!Í„]ï¦Òm¦ë°¿n§«“©„¤2òÚ¶¯è'¤Î‡\T¨ 'QYcd¸ÊÔÓÑ9ûü‚ÌÅ…O. "»ih¡¥˜ïNÛõôU¨g‰lXHmú80/œ7‹,ÔWŸþ³ïÖqÊß ˜]½ÑŽ¥n¨j%­ëåæåû¶vÞ …†2(߯Ö2“`CZ€ßRw}AW¿ðµÐ0):bm],AÂx ‰Žø¨^¼ñbU6ÊÔ¿Ù hɃìÝRwjTÐ+ŸGµþ3¯ý1Ý=+ýVJù"Ê?ê/–O©¯‹vÏ”ö5>*Æ)e) #@£Ü’Åx…ÏRáí•òÄu2—ÆÖ-Pé+àÖÈ$V¿õ÷:5'¬¦ÓŒ`J1Í^¬F&qXÞ�bö#•kåäõ[i©}�Õi’ÙúÚ›ñˆ½‚¹O÷-Ÿˆ¼žtlt'¯§´5íafØ?¸ Ãì•;æíwtEÛ1‘ÂFŒYsÓ¥7!ÙV__dä©“½ ¦½aé�Ò4Õ=<¸s~B¯Ç‚ÊãÏTTäg¥Ï¢²NVë•}=§šéjæ‘kÔäTèdT¶’yÃŒ·ƒùší¤ªÐ;˜~¬ñÛìZªÎsïÌ\+`P™úv°–†/k€’œN*ºî /¢—þ ¶6g¤½¸‡åXW !KâÒçî¾Ì“B–-²VfìÊÆŒo·;Íb»c^Wª&áªçž@û>aýLg¶Aé"Ãù-ÝuO+þm¡šŒOþ%ð- ‰yH)G¬^'³©m§HjKVÉÏvC{oö/sßñÀÓ›wp‹VM“4v Hφˆ¿éÇÂÿÚ`˜PßÚ†«ÏM½æÜL¸ê¶)’·ÿ¼•q‘7H=©B%LõUpî߬S‘©€ø2©í$g·"»Z0}øs!ÕJåù°zcè5²¸Ôw%:+Áõÿ§’r²ÑwÕÑßfh€€lôwÑÕ³ŠR:/Á<ʬTy²*ݾüýÝ(ÛLõÀÅ©(R Ìû©ìY;2ûX‡X§1„s²µ’žCl{âæ yq PÄÚ*´¡û¹ 2+ô…H}ë+e}x:V8õ©rTåww0†ÛAÃlo'¹1“rYºÄd ¦ å.xý¯»S·½ªÔƒâ¦ìçÒ ^«×wË5”çÛç¥(݆Îå™gÆÖ4ö±{¬Jû5´Ù¡+üw« ÿ �ša1·hS³íú3jp:«y†âamÀ’ñÓ³ynDÏ÷d|]¾¾4’HMØ3±IéÖôïž¡Ó·u»yÑŸÁ‚@•*ØŸéÓÞ[Ï­gK;ä飛ºmÍ®ÙçoæUá«ŠG õS]ìÆŒ¢º÷”Kî+ÔÅúÊ*YÐP.‘|uNC®îyôl:¿w°(}ho,Á çäykÂòDOì@ës8Ó>œæ±<ÚŽµ}e;‚w̧04½§m†lñ`…Mþ'JSßáêÓUA[ytES-šEvŽÿ‚»‘éhËnæU qdáÜ£dn–œe9µ2š¶ý4!G9dý*R”‰ƒöHÒNÁ'|W±Xú¿:ˆ¼¾Ìò"ÅZUB2–õð‡¡Ó$ɬTgæÏA"ÌiÚh;K‚èÏiXk‹þ<¡-S×4sÅcT}ã¢Çé¼é8iÙq©{—fÙËGvF¹çp4ÅOÈf[‚ ¬þÈ«UTJðÔtÝPY"ØR²`ü¶ˆ½áuÄhVãtà ¡5ãήŒ«zY±¡ò¼˜Ø¿Ùg´vNÜïã02O\Öew$XÛ 1vKÿÅõ¼Ké$–ý9-œvö0Æc½ë Ή2;†Žë+’_HwCéþO}øSjºŽ z¶a­÷«HLÇíÍPå¬ÒÓëú¥ÆÃãT°šibdzf}K RÛŒ}C7÷¡ÌëZˆ¨¼U$¤lH¥Æt p†‘‹Y¥ÍÁÕMWzÏSÐØsø`§#(#¯>{* È©Îm5lX :è›þ(AžYzWjȧ/¤ÒgÏøœ]§Ï #Ü»/¸‘ùÆih"Rqèi8êÁl¨}wA¼Ÿ¦&yèÑG¬ ;õëI%"(#Ȩ;Lô<yšõã%ϸl{ÇX(ÔôÙ;›Z¥28q”T}ÜÁ«b+G'R}›#L¯>EŽ*øÌèxÈ$éçÆçývL•ù&í(§B6W_­ï=Üfs(×— 6Oçç2™•¤‡Þ"X0=­ŒvnܾÍêø ÷®îrTåGʺ»>‹ƒ¬ÑÆ'²!®Ü¿¥û"€å}×/’¨y—ßÑ ©Dc]CMƒ~I÷îÅ®wº›ß䇞^<$fži ë_ôôÖ¬`¤EÖ¦s”¸e:¯¨wr½¡È¥_uÎÄ Ÿñð’ÜS§á†0�ÿY¯÷o#~¶Ö͵¢ŠcŸxª{K¹éÙPÒ00¾+ 'Þì/f”ä”U3{|s›}zzÿ8mÚ¦o+ßÒ ¢¥ òI»g(9Í:6Ê´q@iç´UWÁ¶=÷ãþVŒòUCå8õœX¢fC…i슌w‹ìË Žg9Ù€EoŽçƘP•gU³(1Òìî{¤>˜SÙQ¬ŠÄÑÊÛ·%}¨²Ó“HzC’ÞJ#ò+¦a-m ùÜÇTÒ4s8U8l(áŠvÄb®FáJ m†C ¢ºG Rwfè›6ôØQ®UYõ“c}u»e%µÞ¡à.a3}…a1M w©¶ƒ7âÈ^Ïد₨fSÓŠ œ·÷Ó~°Èg}\íÓ¤Ì<î0téwðo<Jüw&VYŒEïè¦uCNÛýÝ™>qD6Ä´‘>�¤O*iŸÉ^F¥« Ʋsõr1c“Ôµ«ŽgYýœRçî¶úçL»œŽ¿¨³ï«C€LWófR8ƒå9€Ø+ÏûGI› †aËÙ’ÜÑIYú‘ã�è¥çÐ�ü¸áYâ 3«¨ê°B ¿ù“e;{ýVç[ôLU÷³•kÝ[—:}JkõœÀu’x¾àõÓC'¥8•X¹ X6ö”Ôï^»‡¡ÑYÀf.+_—$®|ÕVú8ÊË ² ³,÷2Õm~ËAGÞ!~NA=66òP$(®£çíóqèõÄX ³.âºó·Ÿ è~P•ö©È}�¨ú¢³su?Ö܉rÐs>pÐÞ¼óT@ åÂ}ÛÑt¡(nSƱXV%ßjÞ&òé”…cµš—ûŽ(™ÏR¡ãn˜ { j®T¾Ù×6 òŸxïÝ÷^k”æÎòƒEŽôÅàAºW˜~Ú¾£<×Å°èöäú7­ÅTA^Ra<[£UëŒÍX:ù{¬ÏÓac·Ú"tîŠw}ãhmvÁö0 ÊftjJ0ƒ\, ä)íÚËtÉSÝY-žÖcçî⯆ºqe¾7c‚ ªNë‰H‚ÓÿíõßâUeç“å—<6=ÈWØuú\–‹?ßuö ’Þè(mF È“ˆõ¯›þ >ÌîzG,Ö BæFÂtb»á½5–fƒ]/c§¬óãÐ2í[6¥oµ¨‘S(èÇ´˨‹LGfèx;GfÏ “,pë]šçtd ×=ÿùÛ{-F²p¥d_Ò¦Mƒxhõ!>‹ÒÌñ°È‘²ÞÜÏöxT¥•Ç8¤ µ¯a‚°x>u§úC:ô:œjw aõõAö‘¥Ž Ã5T?W´ ´'ƒqøü!’kŠØðWþƒõomJÃ=ë{:nÊëì ¯p³ˆ¡Ç;Ê�ÛÔ §!/}O…Ø!Ø]®C׶öÕUË@½9:L3«vðÄÉN´ê€ìO”¨Î’|¾Œ–Òm “¯lD`?QXûÔiZëô[@Q£D‰ÉZr᧵­å¬¶™ è$3z­Y;*ñ —„ÖBëM¨Þ»éÏÁ³°ÿ^Ì<{ë ïÄ�bÀsHIŒÒ³óƒÛ´ôÚrâ©X@NAº¡}ôÞðuÜQ"©†"ˆÚ½'FŽIAdÆ,åVXàuÑ‘(Éo˜5íÍ°<½G4¨k€·‚××ElÛìh’,(¬ï[ÈÔœ9üF6å·S‰4 WÖ©ôd"¶Ú2ÅF!+óÒN*¯„Œ—ˆ‘—L©kLˆsbT*%_¥2lcc/0L,Wqóºj¬U™o¡Fy{O§TÑ×&ëÁýf½7|.ßH™°ÔB<¶^ײ¯ñ}ÎG…¢ï ¥)ÿ¢°z1Q8Á@(ül½ªLN8é¶Ïnî²"ßêšW©ÇI\Ñ#¿“³œÀ—íÕÜ©Ú‹ï•÷‚µy¤-ÃŽA·‰ƒjwµHâ¡îPˆ)Ȫ…7n‚pu¡6Õq1—æo™x–­¬è1Œwn<zÊ3_aÁ=Ü{V<Î[NH¿œã¥A1î4zJyMÉýu¶½o:LF¼Bj, .KÿÐtŒî%|™š³ µ<uHÍÄŽ³K™Âiô »tNñ`¯{]iÆÚfŠº-,`ÑcŽk ×xÀ2é1¡ºþ²Š¾ô/WÉEÈoÔ&B®§E#î{ø8J³è¸ÜÖØúÎZ‡6ž.Kå_cþè‹å-PŒÃDÉHfŒD8}¸ÎºÈ¼‡ìÅ#a_Ô>¡¯fâü<ØU]×`tñ«yvêñrî©/X#ïÞ|aÇ€Á˜ýâèûvF¾•_!}ß…ìdzX’;Ö[û¤|˜\0EõÔ2PØÃUA_ŸOhœô€ª×žª¦Å‰à¦�­R,õ•Ž.óï”N%tîúVË#;åÂœÛ=C;ï»Q6Z7=s‰<¡-yš”u…bݺœl $Ñ‚—âQè!ˆbžÂr*Ý+¸=µJ˜KõË ¤ô;ªKxxô‡0,ÊP·–2TÜÙ‘‚Æ,ÅW[mUìR¶Uk8Ó9ó,øë Ô]Ï'U>ª‰kóóŸxGG¬"íäAºÛ{’&Á É´è±AŽs£ðw¸áÀ£Ÿ[}@I¦8ê7TO%ûÆG©�´ãqþt®ý¢t/¦XbõÏT“$ŸÚ§Üž¾Äá  JEê°¨'úì×óÑÜËz…7ô±PÜk>Š¬å¶¸«x÷‡÷ôXœ•c…ô·Ꞣñã̾ññ)ð$W®óA ±Ð‚Øë¦%Ô¨†‡vÌøÍcÐwR®l .ŠFlûîIø$ݲ^•9¦ß0>7Ëê9NL}”¢ÊXå "êGÅŒ²1M`­Ø¤çÙýYGQÆÃ,lfýð9Eæ;sÓí]3ZrqÍ1͉g:Ÿ!Î:‡ÃD 9ßKœ…8<!—0= à�f›Ó½]é¯ãfíÍ[Wib¬âcVC˜ã@ÜO¡øm=ÐÒ±s®ÿ}Ë3–Š¬*°Nbž¸FîŒqW(ÎP6ï<[Q¨ÁÏkYœŒª¦Ì«ëˆ6^ „ ºtTS£vKõ>öõ‘UÞ0E—níhÞ©ßîš2­; ðiDNtÞ[zbaœ8Æa j3Œ¶ø?Lª8ó(” ) ÚjÈY-½²oô­Ç›3ÎÝüHÔô[äC½ÀEZ¯ä¨ôÈ4­[€iìõË|rì(¾[¿q¤W¥a鱡³)ÔË /ï{»x2Ï5@b¯i»¬ö+»ü̴“ÎË<ºþHÿãyqßSÑmOqn…§•’âø–¤½Ù9·NÆœË|ˆ¿´MÛÈß‹|—Ñß´™vŸ^9€ÓÕØÀœ7ø^âA‘NnÆ÷´#®\*ÆÛ9;jðNXûÈ÷Þ»%ˆª³v]y7$‰¹e¤äîœB«v2¥”d8!ÈÓã£ôø˜Ê¿ŒÜXÂîõ¶õDsÑ&˜aõ!Rî5ÇÉ×0‹Ö0^<eÙÅ,¨æÑ*ˆn)Ü,%ŒØ]};¤Šx¥–”Ó¾-‚rTýyœˆ(œÅ%KhžLùgÁ2ôIîÐÛâŽDÛy>µÌàðò…ëJq‘¦N 4 ú„ÇÄî°Ÿ�Kìûp¦K½…e½†.ËÙ£ê£uÅÏC¸ú§‹pÖwì¼zÌïÌÄ®[710÷šgUp©‚è]åü»~w@¿€*dŠþ¦¬(Íoæö/)(ú4œ÷ ¶çƒ s³fþR¯ä_è¤ûfD•<õàíÚ³‘»úYÏ :†¸å B"k#yÿ~“A¶sìz(#7ÞÄp<µóÑ& õãåê{»šl¤õµw”‡Í‰¾”bßl|;Â]dycšÙøßÝkì®xÛL.nŠ$È?kOW†ž‘ž�)E9Fkó ¥­ëi`¾>'ßfaX䨯$¾™b/\EYk óÕ;™6þ4„z0”ŠSW‡ÚyaÏW«™˜*¬&#´Ï€G{ööGAÞx—„ãr%Q7º2H‡½øfvS¹=ûx÷&î)ÍWð¡Ç”3Næ›ôƒÙ<‚M:ødºÊd1믋 j,&)±'Írë‡lòŒ]m»¡jhØÔT2ŒØJv×)R³¨ŠâéA»$Ø& Oÿ£‡Ô–F;œb’<¨¬Ò�›Ec5 ÞIÎnÅϧþÀfBß6ñŽ#G>P�Í>ÕµoƒOk©dо—aìÐÿ¨÷}÷"÷&5>€ˆÃO‘PæÛa¸ªÀ8Ú¥ARž %†øºVѼߊC“„ºŸÎ6£ÉcˆAô˜ÒŠê2·SêÂÃ`ºO¦ôÂOèÇë!–ÊOpCòñœìŸÐB¸2œz×û1¤&(›tP4Üá÷ÚOÿ›¡‡™áE6{œ mëÉgw”¹ÌÁ=/g5P‘&9+Žì õÌm”¡—ë¾™bG<ì=OßÕ~ÞnH¸¾–4îƒë)§Ó¦µBÀ…"Åäy*»€Yz ت¦zlvõ]à/¶\nÐr–¸5|¡š&óçù0©Ù⺠òãâ~ Dú³²‹=mr#vxÞ Ã"ÖýŠØ`çv8=v¹š‘¯øçeÆ.œ 4Ö —ÎXAº4³ÑáxŠ€q‰ ÃidñûÞ¡º)þöN-S„}]SPRGw—Ñ5Ð+Ñw»ÍRo€’Âùß·¨V°ð{×ÒWöàOt¯([ˆ—l,™´ ¡Í™Va™Ké$™&ŠL�pÈ«À¾r}ý]ß±^¸Ú艙 |æ¬K¸a?y¿Þ¢Iä‰ 3`5û³O•=)y¶"ÐwGÔ„Ž¥`^Wî÷v•ƒýDEÓyôüJa, rŸÊõÇ\é›+‰s}!G±õ¯ôÀQq P2d¬CèԠđל˜õ"…ïCI¥Øƒ ᚎø2HšwG2:Ö´A¯ÓÛuÞa^ˆÆ[Pâ9 #xAÅê®ßûe|b€ @¬ª9ƒ°n°wJ çCq©ÏŒ:0¯FŸÎ;‹È ³åSž³ÁWú¡›/‡¾9~²_¦>'ÙzhŸ]”uëI„S‡{Weô9JŸ?žþ?W9•PŽƒôºõ0Aí¡ñ<Ë^ÒVâ»1oÏ‚ýô¨GÏñ¼9ÍžTÆŒE‚öSÖo7Xc­Ö;ð£Ä¡´wÎƈ˻‡¨ijN®ùfÍ „?4E´=PžqÔÃŽ|‹­Z¢È€¿ô¿ðãó5»E³Eœ|ß^Ρ¸ìä&Úÿîá«TGý¦àQÎ6U˜VU½ìcqƪ÷/¿eóUá]CˆV•L““S¹žéYÂÕR� ½3Øë/¦ìy‘ùNôسêÒzÉʙΆ6zÂÝÅøl Y@mM‘½×V=‡‰V§e~Sr­ûY¼J×Wø-ZŽUÎLMÞóLæOMo³œýrG*7ÌÇ ¨Úwh ª3Öš–ð]è<÷eŽÃŠqþÉ~ò 3æÑ–“ K>Úÿ5ä–ye‚Ϩç: Òyr=R8v*)/ÄÁ'T†žÿå‡ó 8‰B‘Ð@™êq_w½õj9u q ´^~ð}øe¥õn‘Æ# ß~錶„…J7P.HOÙÐ8Ep[áT¿TÁ"ª]!°^Z Þù¨Ê„T­×ßgŒ©7ìë7FIÿ_f ±ªH*^m¤€°Ï´; ð4dkBôýâF©Qµ½Åc¦ ®5à$öØtÌ©'Î2qd¦�6¹¯´®­çpv&ÉÑ6ìž2+#‘ðÀ" ד2Ø3^i- ÄÍýÀaÍM*#":öiPÕºåñ×vÍ´Vsú^ô?Q¼bÆ‚º@éBdE:Ù6 ôM™Ï©qÂ鄴ּ܅MiO^¸ávçÿ«ó:¶kÕH¹Ù.íÇpºpÏõÑyèÃP(9våüZò$1'Q8‰g'ª B€*åÕN‡d"nfC&(…³ìäl£©Z¯ž1÷Mè„—<Ù‚ ΃9 xˆ…Ç]Ú@èï¹PD*«ö:ÍÂH|8@«[“×ãiž­9Åíì$Z±ˆÀŒpX$6ýb?zN�ÿ+úCáÆh§¦Á혩3¿¨¨<8Ïc’ÑÉ–•Â‰‹ûšÏ}ü_<ÿo9T¡Ûy¢xÜ8^Z\ ÞšËó“ÞQ«ï.e›Eÿ“ĉ¯Î åÆm’9#ØÔ¤µï¯r»%f3}†öÎ…ïY…“ÍÂ]ò§*{¢êôÏ¡¶½÷ëqÄ„íJ‚!NÞšÌÍw4ýÇ$Z4ýÕ »”ì$"Ö’_ÏßÞicÎÜ‘¶�¼‡ˆÕ3Lb"ætXêÜnª:ÙfQ¥¶|žûIM¾‚7�¸C‘¢ü²’{œ—Nsæ5í”(ô €ðÅíé G£²zÕ¶'6B¡¬¥Os‚úž²¾É¼d¿bБ:ÈÈÙé`8´ô-ýØè7,gܽ®Z,½s"¥…¤žôžtý!º¿³ƒTØQÈ– ªbQŧÜx4O‡F™z ½ «wš>SCÒ‰r•¹ö&»!Ù£Ie®~ð-ôý^-<í¡èh]áÞÖÆËÅnR͉›·íxß%gB›?IwÖö¯Ttïb1¡ÛƒpóäH:½ËÔøŒÁ‚§øTÒ\‰ÄX^Ù),}1Z�Â(zUþ#úŸÊ{¹4z3 Þ½¢£9]X(E¸PûŽ)FðÊ›Œ)Kê°Ë24Gf öõìF \[Xìüï€n™B3ÕÎݧ{E¡Ä‘vIYÒCS7“1.‡iªWg! šh¦q øígƒztˆÄù|<jËEã稶Ѓ™3„¤iÊ tgl É<Ü×È„£v¸¿Ýh«ÄÎåPÄ£¹yžÌö¨#Oì '§m÷v<Ó“~êš®ôŠYtu—EãÓ^ßÙ#ÜìR°TWPŽ`'²Ž÷@¥yèéaUÐcK§ÑÛŠÚ1§.Ä/C·†Ï4§~Fܼ%!(ê¾23yƒ$ýkΟ¢0Ñd¶sÔÿ,i^¬‚}nÖýŸ]ð$[/—FK¿3Yó°þR'°äv6|LfëÝ_×ZgëÿÂ2öDÅ\†ÜöŒ`ÑɆì0Gº6§®›‰ÒÏ·=Ç4Ì ;¼Ôê\ÁÔQÔUP´š± ²ù‰ª^F,ª°ý“Ðvy`ܹš7ɲWsÆæáêÓÍ^hÙDaUy½SÐyN0µõ[ÊT‘Íô˜÷áBO\y×(åÓ¦™� š çh]ß½¯,ăž²¹O5–Èñ´ åP8{uß~^S&ÎòµâæâC+§SëUø<qmi½g6]£çÖ]^‘ J<,é?Mðj,›^ùùø ‹u8XøáA²Á߬P6îV©Ø@X ƒ³W]ƤzûÏ[¬@|${¢cì<ì~ƒôŽÖTþRª''¶É ød/÷øWöxæ±ä)?ŽT¬%{eÐ.g¶š²š0¥hQ4í¸²¬¯³ùwÙŸ'Hÿº Ÿ%"ÒáDpó ²–bq�E!¦mi%àaݾ®¼olXVW¦j”ïÏÍMÍVï¾ÏÓxNÙˆ|‘š”Á!ÊEU*bzÈ7¼$–äƒi_Ï3ýÙ8¯­ò­MñŠ•ò,Õr´9è}7yAïp¤¯v¨{!@Khó¡#phÉüü˜ÖšÎAaò˜=ż²Uš€küüïE)A'”F A6Í¥Ã(ùj_p¤ã2Ï+m_±îÖ% ’¾a@ºü"3”ˆ‚³®›×]Ýß™‰P5ls±È0%/E[̧õf"õÂç‰nuæPh8èzôìö*¾Æ ÑP¤M U1ß]ïêž`êšW¢ÁÆTÑØŒeiÑdq ÞžB‹1ÓÆWø¢‘‡5À²´*l˜ô>@Ê`æÐà´OãÌÍ }uÒcE雀11aeÐñQ£aþ@`¹ï)üJ§m¿…0I ÂÚ KÝ(bªgëµÿÀÓ¡GÆbž×DY%¥èŸó‡üFk(«\W@òÝáqáˆ6§Ý¡§F]¯0ºç]€ÄˆNû‘¢xaXCq`Ø;þL”[ßW?Ä^Y¼/GR¸ÎMcñ¬GOºŠŽ}¯Üñß9 –¡ÿpKšØ•Lš7 ¶Ðîlïê»X]ž8Å}ÎE þ“ÏÚ+\h±¢Zt[»7>ÕýÜý. ò2ÔëÚ-‹¶ :›7 aÔuŠWø@“/Ë~| âi]UƸõò‡ ßùÓÉššö‹@Ø̹°r ÑÞÆjp;Ƚ´*áG»§D jìy„±ê´»öÚê|ãOåFÒ‡õe¸­¡Ää �kyõt¬Š_¤bÐÀЪ™ Œä£»²‘ÂoÜhb?5dí‘…îß| ®^ÆÑ°¨í3iè(.(žq–ìÇ;ÔÞI RŠ®ý[GÉŠz‡(¸r—ÙâÆ›à³?ÃXÓd`´‹`}ýÞKB¯“’¡©ý±dA9_¼f“ F­¼Äyj¸G/Rß<­ÙóQˆã‘ŽƒÖhk`Ù#|Y¹ndEA{­‚ʶú¡µÙž„nlÁ0c×b’Žô‚þ#dzß$*u£úÒ Ë¤—t´Ú¥®é.›Ý®ÇÜ¢íV×h­d³o4´]rsç0G৭0l=Tçç¹ôÕeP^øÑLÛÉ—£c@6Œ>µ³š°~°¢ (ÄÏÒè‘WúYs•§ùÉ7 \ûØ¢_Žd&ãv˜àÃZðöè;_H,ò·ùãÚƒÿ&cTÙs7èû‡©NìIk弈ò$È·ƒ‰FÇ–Îõ=˜º ô¸�MË+“ !$įÑ|'ˇ1ªV *Ћžœ‰AÁl=‚%û6Yùž´d©Kf!ìZM„Vò7a‹€‰Qµü€N—~=*EfŠ³ÏeßëlóÛn†Ðœ-н+-k0a…:̼ù�]:+ï]ªÑòû<ÔÁî”TAÐÞ_€Õ�Ö äG~iîPUáMñ¸;'´œµ™Ì'´éu¬”ü.§iìEhw>ôâà®l‘Txå#éócF¨Ù(5Q RÒ±»Ì¦C&Ý ÿZ¬laç—x¹gp’`§·íÂìÓ 1CÌÇ(R]ƒÿ¢Ñ$(ˆ¨Ûןn µñ õþ0žbŠWQc‘oëÈ,QJB&ÅlV¹Lâ¹Å®³è™â± 3»«;œ³2[ >|,°˜i¬éSŸœÕ’œ±r„p½(ëóÛºþ¨Ø2[¯¹çܧ_0Ž1Aßj”>+ß+6¸ ~¨>µ:è/߻͉r’i0õeIÕxUË€ë¶ü4i½e@É(m¨½†1ºÁÈ¿‡VXutïÜàwC´ÛáέrË8uj_³æäÈ8÷‡�¨Á¡žŸ)|åñJ‹ Ñi ï[x>�¤ˆçè ·­V‡æƒÙnôíÔéZ,X× Šjý|“`{¥Cjœ,ave¾ÊÍ,qÄ…Õå:ÝŒÊxÅE¥œi_ïjôòJ:çíl�ô¬¸i}¹Ç&ÓÈ™nw3к(œU_¦~%½³ƒ€(èjR_Oçávz¢[<þX>©üþ*ýä 4ÂÓq´œ–¡Ó‰'ž»m $kðF$Î"õÖ³º‡ú¡ÞX‹È'>K†ŠtU;%Á<¡õÒyˆ*f°, ágLbäiàgFEíz‚¯ ½šÄC'$8óо™”¹$6FKQMÆwGf¤´oèj$æû½ žêÚ!•©ˆz›‡­â¥®om{êé±ùæСÃþm3E 6‹ˆuþéÛÑ,ªŸË ëm9è I=ÿY†Ó?Ÿ«›žáDTÁÜQ¶7«†sÏÕúñ´ù°º5$ù±ø€óç) ä´ðj¬JVj2ÌGä3„—5‡/LÂxüH‚âSQR˜dÌ{㣖°àƇ˜šP½‰]ðìüg5/�v ªýìü?ÀðŸÐ’7¾T§a‘©‹e.˜´êŠùüàˆaÔ²¿«¦é"&ònZ›·ýàòtêLKN 2£2GßÏó,µ=EHD†Á0¤AÞº#ѤW<w¤Ã}¹•ê{pmÏwOŒ*@° Eïæ¢À8Ögí«½*\’ÞòapÊæORU·W´QÁ\’±qzÌóžá¯Wê…Ç!d¯é_‘¨põÒ|•K«ÕÉ‚_t»­Zû/œ”“t%ÿ…¡ÄåßÏŽ4ÁzTü¹†ô“²|šež&?‹¸aùxÖ­d~J&¸‰» Jô¹‰ÌžÝĬ(rÛ¹£š•³tkT±AjÅ3‘žõÚoå¢(»QÂ?‚_WÔÚž@DƒÅy‡ÁTÒÙ{Wʤ‰}ÊÆ/Ûˆý·c[vc‹\0ºÔI3î]Ýb¬éhnJzÜää\{F†Â8­ñ®ÞòÔô‡;“Jc±©vEÐ_Åç"W­!¼ôEviAñX•Ïõé¼pÑWD#᫤¢: ’¡÷Q!m úZæ®ü�6„¢œ¾èb‘g耲* r$Fô½t*×ïžÑÿÀVÄ)RÌù}'Ϧ£>#M¶Âæ†pe^ä»t¢üð­Õê÷ù˜o>ð`j­Z8¸=EÄqêüç_Ë—KœGc2 òZ̪�©{‘|ŽAçüRÜ.¶^”¥1°mfŠ)ånpTÕ KEc1c夶ØÐ%‰7g´IJÙ¡11æF—þ·þÝèî<ùûO"ŠB+F ëQ^>u¦)•¢¡Jyl¹Þ¦n¡ï˺å�ÖÜœyž%‘úÐÔf³ŽÞ‚õB±'6ÝíXï¡U‡­‹ÔÂÅ?Š^Ý ªR€Æ+}n*‘ɼ.üá²bVôĪ;¥”³´mCÂL…™7Õ±= §óWc²ÊÀ “wùQÛb2˜>ȸÎ]”ƒÎ…y†Úõ[:vƒµ­jf…Õ| (ôôÝÓ¬%t^þú™âAìÜÆRQo@RtÀ¯·}ǧr…—Dâ&Ѫ‹ƒ¼SX'Èwòç›gð!¢^æå¡iM¬Ã~ ÊcU½Q‡ I&Jök£÷K¨E•ù¾Ý´¥.`Óѵžî£ñ~—/¾@À¬ڻ˵³túž¶@§Ò&+¶Šá$è‡í»úo÷ŒêWVðÁ¦}T‹~LÍõ-|êaéÝØ=Ž´’㓵…þ7ý%öÙ tÔ½ëÀM‚B2SV`ž–rö?uÿ=¨»ìüæm´²ƒÀùù'Ê«­¶7à€„Ù«uÜgá»çŒ@ÝOIì@.bim†ï[ó· ²^Nª¤IÙîd«“ ó–jbEE2D±h?Òï ›ÞýrYÉâhõ8NGE]ÀÊ72„|iåëS§†sJgóiOn•U#iü©è"©»O€}8QÈ×–e”¥ÍTÀ•{Kð¹ò°ˆGcß÷Ô ôgc£ §¯¿|zNh¸Y4‹æÔª< øÇ[}6¦ÂÀ¾0éÕ¸ïk =3§ØÆ ½]ˆÄz\l÷S¯,]z Jtdçã_;aøžx6ñ®3¸€'耼 =ð-Æ»$Èóì¯f–¡Ï35¶Ô"™¡ÍiÇúùÝî0¯ßÜiy¥^4b€ûÜSNhq³QÊ|ŽzVz’îWºž¥¯“‡¦¦²xÐÈ V ëû«ýOŽ„I²’ÔIƒe¢¥Rž'7sØp{àOK0€äº;î[:Eéìߥ:/!X¾”]¢.ŽhR7vlj’–ø: ÉB_ò�Bkt>\3Ú-×þRO7Ò“GIì¿W¦©;jñÞ†Þ©$îp¯'’ë'oÎÞËM”ÌÒÌs7…ŒGGŸ÷©ÙYeœ‰ŽÎ°æ¹±ìÊb6õöbÉ~¦Cd™¼¡äEÎ ‰ƒÕ«Ê'®1i¶ZµU'7¶&Øž{„õ±Fp« ´½1­§d@þ§Fçš~äè|,´WÍkÑ€Ú?ü™ª´yé®æˆ¥}7\]ë­–…G”¾ƒþ÷Õ3í<B¨Líj ÷ÍàÜ}õ¤À¾ Sßk€ñL]DñzÑCo™êmÝÃÇ;ö’’ªéòFÑÛ%ôR„¼3Ï´.9²†h1ž•W]ÿ±}WÜl§DÛômw:Û6õ¯`+QîìîX¼ ÚRô~«]ìãå Zäü`®Ý b¤OÔÙӪȜOt‚xœPÆiw»™oŒû_sèåI¿pîz;‡\Mê¬GºjÄÌà‹z‹"ÊcoDõ7l|3¡þ6§ˆžÖ”w¡ãIèŸ"´°hg{‹ÊJ�Ÿ¥ˆã_áïÁßÞö_Û%qÞ4wç:زÄiXLga'ÔÜV¥£Aò"õÿN»ÀrëÖïHŠ¼L-M’ö¦®‚d_û"RPu2ø‰ä&Jû‘2�4ºò;»•Ò¨j7sdµÂWÀäÝŸû¹sõÅ‹6ÈqîÛèRIt™iw7gÏ]ÅW…ÛËOݾÞøÝhAHP-¥˜q ‘ù¾®£ôú¸r¯ƒþêϾµ`’8óÓAÜ0iKë Cúy»Ñ‡Ž¶Ý¯ï`–…KÜ#˜ÐÑ/qSIèMôç£zÃã™ÿY0ÇFÿè>è=vm7ñv¢ÿ?³ð‹TFˆ'õM~µ³›†™7ŸB½Jÿ3:8wŸÚTñÝßhƒ°Æà––átÓïësì”;›<u¨À’Ï¿+KÙ^åN—n·¥Å@¾µ}†BI7u-íÌãÝ¥i>øÂ˶ •ÿµrOôzvǺe©ÚGr0išù­øî ŠÞ†Üõ<Og^¡vXúJröÓ74‡çÍíØ—*ŒË`ÓPpɧÁ$nW"ì‰&4ÉÓÃj‹hxI)$3;Jwùø‘Ò.ëlÒ†®7º[\Ñ™»sæZÁLj€v¦º_qïþІn¯¤X`ñì71ÅßuUÒF¼,¸­ü%ÀyŽ„Æ}w!ùîµ9X˜Ù$»Ë~ªGÓ¡QÑp.‚^ò•Š{ÚçÖ© ÂÎ2ªé)ÑÿÒAR¬_cz´G``Ö-Wš×§¼ÐٹׂÂb®´;ú¿oq l…)IkÊš+Tî£Ãò¬Ž: ð JÆ@PzÌ›î <0%Sö5í”þ¯‚ÞöWƒµñŒµÍ/±Fé“{/ßO™gk8Ú€‚°óz ¢\4?¨åuLã¢0Ãæ_C É©(Ö ”°Œy÷%Ê›} ¥Áþ*ÿ?À[§ WÂÒ…°öãíÎp´0Y<mh}9(É Í8õ@ÿ >´¡• ¯þ; ‡ÙŒsÕ@v¶¸b�´mRŸóÕ¦‚´”¦Y+´•x}†Ð截„>– ­V°’¸jªB‹5ª˜Àqš,þ™5~©@“ÙÂpL¿§ZQXö?Ëú#Q:—³™‹ÍÍ6ƒÔ8²Òc0pºÌ‹'úA†8LWî9«Ë…k*ÎÑ·¸ÿS¬TðJœ&TŠC¯ âES²²²­ë;ïqçWÆ‚Ëõºag}0ÐüÚŸ:~ÑÒ‡.LŸùê(F¿0¬Q9¼ÞDLôž®J>¸¯âãÔ|D[Û(¹±®$·Ö“wÏ“poj6"æ -®‰™OÙÞY¸b{çÀ§&Aºh‹¨L÷É9jÖÿV&Ôt—ÎÃÜß 3‰€ep¦<}ʶŠåk„r)1,‘ð…ãçåA°ù…Ãa”ìƒM3ZvvÆ™Zº¹Ïm-2Nw.Ì<:õæÑoؽ2Í22ÏvAç¿tŒ’ÌGAa‚ …ë÷ÎA;ÞÏtwݯõ­¿6€¿WrD¥µq“Œ)Š—Hœˆ»îk^Ð)0íÖïÆ°íãVýZÒ°Pk œ™¥Ããìx—š˜?ÿ² JÏø¬?,Á± ¯±¤¹õgåZ~¥Â˜¥+i+l\xùh2àŽ.Ï›?YÚ†?ðßÿ‹JCZ=B Ý5X°5J”Éö/_çª$0ÈtȬ)@¹‘Xò ¬>L‚Ëÿo…l­™þÈ´£È‘,_^„Ç£k%¥ne.Ä/?³¥­âGi 9g:«ië!Zþ(ÎÕ”_j¯úxnWÇÏ}7¼÷d^0é·äç~¥0ÀýP¢*ú'>´$t4Sgž^¨'{Αi†ìòh­JAÛ¼NšwÒñÔ-%^õ<¡ôÏâ‹»­6™¡âp>6WÇŸå­a‘“¯sÛ2׿–.Èõ„щu‹�iÓm´äÞŸZ„ôÑÛ»—l\ãð^¯*t°kî/_ ÐugcK+Â@HMˆÅ¿Lí ¯¿LXRtSÐdÁ÷­™ÍÊtoà¶~·7–VàiÐqÒŸP¹úLB-¬ÙíJ ÖŸ(²Ö#›iÓ6»üõ sïõ|´¦•L†1õ§ñÎ~M½0 WÎ5eП3*ÇUZ»ªjM¼8«º f:ÓÒù¼€’ý«¢1©2OwšVS9ËQÛÀ{íMÝÍu±>£Bœ¼yõÖ•h8¨!0ÖöhÍ9''óðˆvºܘ¥¼m¸”AUO7‚ã;Ñõ»—¾ä.’†E¶! AõýÓ:’«’^æ§Úæ²vsúŽÒ¬­Åwf€¬N›«Sz:Qg¦1!o¶È[ÞuÞVðÝýÛ¡‰`QÌTêëç2o…/­v?Õt”MôÖ'½!aû!w®V|GÛ} y(OvóåY¬˜F™bR¨¨3'–¹xŽËã’?1á^{³§r+Þ[Á~ÃŽ‘¦ÕŒtê=åÇo¬æPÂdË И~º·2¾`ßœfž:¥÷Ÿ›W"Ý9÷¹FÚøÅV#;>×ÈpgŠ»CÏL}L¯Ñþ¢ðÞµÇ3RN‘�êÈo‘=¢D3 ÚžN­jwÍ Üà5lÎ=<é‘ô+P}æÑ7c`Œ÷m$ÕÂGÏ~ŸÌE3((‹kõÿçï@OOզģh(G½ÿbdÙÍý¡“¡×røsàiþ©oEé”þR0™¾{ÑÄþ&oh”¤öÇ÷§L÷HSN‡ÚÃuWS|Yˆwò«[PIg^ó´ v=ðåÖSêšq„á.c±ÐSZäñ.—îòaEwt¯³0\»©s9ŸôªŒ‹_²ë¯ÃÛõmwÚÓþÄÐÍ)ãS§Ìo$¯GªK¶k8]„¹ÉkWvËÎu!åÝÊ~9Å6•pAµÈ/ÖœœÎáã?š¹ô™¬«lHíwåÓÊ÷ü‚&­à%ÿ²?;±„ðË€$˜¯ýSJý +‘'+›$è¾€OÚkg_©ø±)ÄLÄ:ô[¤,�6x—æV­UD|o‡ŠE(ÑDήÁÅTÌ7i¼XÇf™9Îss‚qLÞÿzÖhFõƒë VSøgý}Çú ’=°¹±Õ@±1ê øÏ?ÀrËÜ´.ºÈêO \tfò•ò”qÆ,.<"dþØŠ4ò¡…:¡lªέëÍÉ ꑦ<Æ“ÞË#ÏOý~©ržn¢&ÔÆpŒ›<æ½tõµ� ssžÜöq åÄø‚»¨n‡Ø`ÝìfÊòäÉPºÖ*"F ÜÒ‰xåÚÝYˆ=åçÛZ+”¾WÉky°‹=‹þ„&ù[°&åûz—8š#Ñç.ô0$Aùùéy•uÛžèΣ bbà Xã{óˆå£ÓF©àhOÆà; £Kst-i|íŠ"Çþ‹Ôî(wRöøô)Þ}*÷ ¦MöÁEÏzÌjÄ0þÎÕýéerC׺À¹²-å<áÇÎôL‚msÆx—TVú5 ŠvTÉ4:¿™ÓÂÎø?úÐ žý1—zì;ÿò^¼ËF<¥`ϬŸ3–ŠHš[B2¨…êø“´µçÄ)Òû¯$(jU `]™¥>K Ùa[Ù×gþqÆ=i†,æãâ …›ÓÌáͳ[#MBŸé'FdD\€`±®©8ûfÀë|8½‘_ ÄÖ—óLH‰Î”8eËÞ)«Â^ÕúXO]+(L3ªÿÉV>ÎVÈÀ¬[hñw%ˆp(ém¬úAÝ?ò6šò&dÌÔZPjEL³€0i¸‘…þ`ƒûjÐadz EQ¯øÄlPê;Ú‹“˜ñ{ˆ+J³p eXà9B•ð̺±T·ïk4jœ”>[… Ë¥†”»¶Vüð€ · Öäéï·R¸÷y-Ù–?‘¬+µh@]`°ÒÇý©ïï-¬ÂÐlÅìPI§‚œàk t< Wp¬¡Ö,ŸùÈF¡,}¤/¸…ú«‹~ïŒßöâvɼ ,øØvó;R€Uå«wƒÏÐWA8Œ åÈ=,Ga„ö~ÚNûü§ åF 2I±Îh£Íƒ'ÓÇfÊ`׿I{hÖM¬ß*ç{=™ÊÊWk¡Ðu,ž˵CŽ‰È%@c£%u¿ã÷J” vAp4­ž$^>XBž0ŸŽ[ƒZwM=|üÒ©\Ëà¯u¡»Ó6–ýñöŸ·$×.?eO[îFˆêÛ —ú!l®\íxH[L”¥ÑBIÜ<‰›^’„lðÎD/îð'_å–×óÔöê=RBd‚AºžCÀ/óá(,V³¤JÔ{[aÂÏ´ ×âçÿ"Ûg©[¯ Þ^sÊ ´”`â‚)N|UGKOgÖé»ÿl¯éï¨E¸ÃOµ›}EÑÁ eC¥§g £¶Mj«•zÄë5âOŽ}t`]§ö L”üPêN¿'Š§I®ê¸Ô,(Þ{×BýN½é ÐÆj7ç‘Ó×Ý!xQùÂf0.?Ñ+·zjÀrŒÅòr‡BmY‹"3Y±p‹Ló8Ãqê£Yhé÷Ègâ®vÄéfºèÌè.̬½Lw:£ßp™º/®;o^ýá‡Èü‡híûÔ˜�z≴Ò*¥ÝÔ e,³E&P‰ =Mß :ic>¢ÓYÿ5èYžzZ¥ƒÀµ™ú[÷;Äb(ѺÂT;DØ™~ûÉs$aÞľy¡µõµå½fÖY”j»Ñ6*Ê\uögY.TsµÍí› ÏÆSvßd ‰®¿1¶ÓÿG0€hå•ÈíxÁ­uq +U)bhí|× þ±)¼3, ÷<8ëÕMçgp™ç<8mAœh!ÍXSã[.½A\D…iÂͬ/\;—ÇĈ¿ûaÖÛ® ÂyhÃv«§µSÄ`¶uKY•³Žê9V®_üŒ24˜Åá–·Š F4:¢Zà8Ö@Û:�3 ©@ÞM§œMte*¿ ÝNÿù®r|¾Ñ!ß³ Úõûz(Š•D,"ÎE “ëàžª†ÃUKèA±„(¿œpT®*½VÛ´’ÇÑ×òš «tP#Ô½²ê0»1¹+ëJe±6…qn>%Î èU mL$1ÀÿŸñÿ«Ú—²Þv ð_¶Ú+(#™Ï»è¿‘Ëc§Da—oŽL6˜\ J(j*)å$úq@ ,nT¼Þußê%»Cãq–:{÷äP÷õŒ“iwØnÁHâ¶Îo”^$Å_ÙÔ6SDŸ:ÊaÔv‹Ò¥!ªÇO÷4&} +Ö&ϬþÅÜX®AÊõŽ©qL½jš7ß/~(ŒËpep™2ý¸º*oc_ì·ÓSÞ9m³“ سÌ^£ü—¤ä"uñ8æ†$k}TPwiïZ”ó? 8–¦Å&»h*úãöšÖÙõÇÖ­½Ÿ~c>Cà8õpkþR;® X‰Z#H.Ç›—û]ÔÐŒûék #óä;Oþ9±º‰"tLàÓ~$¦¡4ä!ËþLG`9¶öøct©”`ˆÍ ä˜E«šnÁ¿ø‹FiiXF¥ñiäÍδ²µø[¦úˆ=’æÊ°ŽÄ#Ç4ŸÕ€yÀÓ¡inÍ]¬3º`r)-ê šV«ÕÒ ÍuYÎÍÏn¬FŸc³"e¶IÒ,Z“éÖ–‚X¸´BæxyÌ}S)ÎNË µýmÁ ™žÆµ…êÊþ ûé¡¡-¥2ÞŸ©Ä bè• ¼gM£ì ºñóH)´˜ò…a8~*«wÕm#¦ôºhŒ„=Œ ÀáJ<ü¹*5?_ªRÆèßÆÂâ%Ó`7Nrß‚µ°?8kg&5åÄ7žt§Ýc±<0ïË<“nÖ:(|Z»xö\_èÔ^eù.Höì¿lEoŸé0Ñ·Zb4Ê•–”^ò@äWl˜9B%U2Z˜ÞÃuYƒ>+ ÒԀʶ;o&ŒSç°9Ñ}ïR9Å(a˜÷ÖøÊHzÜí$…K%QØÁQ ™j%á<Þd×'Ñßæ~ªóŠèÛÜ›G…ï¼ …«B'ƒfºPH€vJ[롃†9åöoºêº¯Ì˜éXåÜx`ïÈ·lôgrãCŠã:_¦ºÿJƒÒò’˜1`®‹Ð€[‰ÂÒ+½÷,[ÉPÑiÕÐ'Oj»ˆ‘å"ŒØ²÷ÓÝø™f\±Ü¤Ƨ?õª»ØÈÕôCd–k˜qž!"½r‡¸©%ò€ÏÐ{®c}!HÒ^Æ"ôV%¬(,å¶H¹æLÊÕöCÂÒ{Bp¹N”“«G0¾Ÿiç=¾t±-òYì‚—‡NÍnñpÌP@¾òo ¼ROÌBäÁ©±Š4À´Ðföƒ¢¸ðh/F;s4üÃqÆK¶mVÿô?bo9dæÖ”nMyP4§¸=÷tÈr×çûÛCû7ª•ÂüA71›¬_ôqÎ:Ò³üž =Ób`Íó.„Ý@/ðب`H|l¸¼ŸXE죱�‹/3œÊáB§ÝØ^9Ræ¼¹#±\:Fg ‘†$ßÖåÐsä´¯wzdea`Y™1Li÷UP}þõ¼à(í´@ᥪ:¥õ-¾vn–ÙZ°i1™›þz©GÛõ£27}}•„¼n BØ\| <qæ)^ëü8 ’EI_, ÄR12Ô•" É<èÿ½!É3°Ü)f{±éÈÔ×/ÝÑ *é'çQA’ÏpkeUy>“1¾”é•õìæùpH¢Ô¦µ¢Ý¤<Cw)ûè;„¾nå‘çéPäQÔ§ö ’ÊÈ·‡NP8ëIÔ+ƒ©4JÝÉ›2öH_¾V=}Lâz0w´9–„IeÁªòƒeB®æ•¢û $6i®@ŒH2”óp@®%&ÃWO[1¨!Ä,JŠßT "Â-ž§¯$¨z¥ÌƒÎCùÛàúV{A®°é�ƒŒÖ/vD;WÌ8®šâL«-ô8––îÒíh\[H=¶žw]ÉrÄ?/kjO^Í"ûUØë%ÿ<6ÅÌLI‰51´Mg«ˆ€ð0ŸÙÈÑbˆõüV£sÀö öÔßOnROA^^>rÚ=Vjà~0ÅMý áut­^Å`XO+ e¢G˜öºÒi™5²6[Å<@nñÂíA7o½ÍWNëš9»Ë¥ âq°þ/Õ"\ íþekÃùVIï? 0?Ï-“ ŔпӖ-S×h×æWmÚAË þ Ë[úú«ž,•Í. Nѱ؈;Mì‹Ì'¯jÙ�y]šWJãigÝ‘.òÆÒΧC¤ âý—§³¥5pøS÷ÖƒE$ÕìëãsÄÅFªï)²„Ö9œN58|ƒ»ßtËeþÏõ?ö|: —«ù׫aÅà*´sÒÝÞÍlz¨¨/‹9ê¸UÄAôwóŪp]û_wwƱ÷®öõ8º©(Ÿy•þLG÷¬ñ<˜½’øg‘ΦK\æ¾R>v‡ÃÖJP—³ó°rTB“y¢໾™ñÌŽÖLaÕòÐ4šN‚9ï´mê.~ì­#!K{ ÁþQ*WÀ¢‚°î@˜æ›Ð•yNa¨Î{Üö¨ýrÞÛ+U†F+a~ù—nTRܪt Ú†ãÖ“øEöÅ΢)߶âB¿ùË ·wÆ!3bVÛQ‰wž›iÓÕgî¦s«¹­Y‚û�ÇY„Ü¥¶ÿK7°¤)/Mè¥9é¸?È­Âþ«+17*X¦…£FË6“ÎX{:Ì<UrS6±]˜ÍSxöΗãµó°-=ç|TÚ­ZgW,S#d<~y‚´O³© NñÄ*—9†bl°5h忲µÈÖ}9´à‡2Ȭd¦8IÚF׆þlˆ #[2k<ªÇ¡!}‰ÙR‡tý‹©$Õ²sŧz€²»p“¼©?5B׃&òp‰w|,1ÕðÚãîúÃ߸U÷34&ÏÌw¾‹¤{Ñ×+N\ F1Ó8òîÝÓyfê#d”ý GR…+;ˆ*¸SaU‘Áâ>�g(Qn{¸mpCÚL»y{WÙ#[û„ˆþhù^ÆÞÜÑáqX®Œ+_ £Î´PÚèÔÐ%S\Z¥f$&¦/1àz9£NVÚí9ØÍ÷+Ñ°j…Ä A:L€uœ”¼ƒ_GÇÂl±·î áåü-ôDM9G<~¤ô<zźeìó4}�I8º Ë?ðjÂÈ‚±iÿ$&S”®Ù±˜dOÁ±üœù.é/J¹ ¤žE—m~‡m•Î“á?°ñÉÑFEtâ­wÜK&¾¥gðó�¤Ëƒð½öT7ÆÓ¼8DÀ ,Ô+`’ñ^èÀ·>[ú˜%ÀZk:%úÖQtL§p“.bÌæß#1‡Ñ/>“0õërLÆáéSX÷+¸\ƒ'mÈnó¡ì} Ðn¯Ís™×H ìÕêSSZ‡ÞDÔIG’iæKÍX&ë“–€ZHYŽr#–מA3#€x”.:Gèábõú ýèû®Ô¼XÑhÝGU]ìbaÝ:Ñ!­iõbÿÉøÑ°fT 6MÄB‘#>Ò]>Ì'/xH|¼C¼ñŠÊ‚Í%òrí8°:Çf¢µ™ºKçL­uݼc{3y5›ŠÏô—¶kÅFËž óXóÜÍL*^2œ®ÒŒ ²�ÛŽgaôcsZ\…מ.<2šÛ·/Ó€ÒÈàŒw™ö)iŸV}"°ssÚ3­iiõšr®¥¨=›³HÚoÑpõ\" ûãá_o´¥¡VÙ…)W§Ÿb«£Ø(äâƒ;½³ˆpüÖJÞIv‹~Õ¥Í(¹~÷¸ˆrTò/¨<<ïö”F0¬›¿ƒ«|QýÈ í�°Ùz\8¶ñ4#Íÿ“*P!b®`­ü¦WXµIZ¬¦"qÐÀÇe² «`|ä°ëÞÜ4àE¾ZRdFä€'“ƳÔA«¦Ó3ш”³¸ JÍ¢¬òTë÷žà»Jb,ŸZ[\u…b„ c}رõ›½XN¢žyñ^«Ò컣O³gBÌšSÝÖ¶Ýñj.óÂ(ëRvæù|÷D5(IÁz³¤%3-¸}½#qRø[”ÏÊŠçƨD1}Eÿù$¡X‡+‰®aLSÊr•,†Ž¯qŸJl:› Þšï,å^î•’™<ÎK—YnÆt 7-0ªY–ç! ëDôíOƺ1Ûè8ÒÌ¢ ñ<ú‚ûz¤úé9OŠòœßþÊ<5Ê òëB5TÕZ 2ÍÂmóAËå£'vvƒQÞ±vŒ/²ù `”’$û­7–ÞœFL+[q[jÛ³1®óµ¹ôì¼ué lùÚ¶~Û\ámê½ùöé¹ÉXv=ýã—gÓŠ¥jf[Þèû§K×J×Û¡ïdué:À�¼ëÇ’§ÎV¤+ZeÓ8h+Z^Úé©Pp…C±¬¯üLšNïÍ[Ïþ,bPé9²÷Ù”M±QýéëËðK•ÔHønN5î„Ê$°·Ü3çnÅt¥óúô±BU°T5J°ö0?Bœ”aæÃÐA¼¥ª?ýR�iG8uÁ§ÊÀÿíŒ}�ÈúN”©Ï³#ð€ÂÄŒn Ä¡çæ“»xdäåœ}Å‚5.Ýû}ïr¸ÓÄô­·ž–SÝo'XFR¾°Ñ,´g÷;g³ûùZ/Çõ Þy‰àdÿî ÇO·ä›¯Ö¯uë³ØÏB°/Ò zWŽWÉÉÈc ›T3®á=ϯV.(F6ðXAñ5ÍFP¡yœE)<`){‡ÓbzÞ‡ËÉ»²­ºt¥/Át‹ í,¸pP㨳²5?9‰O[ŒÅSƒ¶ºæó€Õâõ¢zÜɃø— gþ~0|ˆòÊçAÃz<‡N‘Ú“À…fíÎÇþÒRõ¹VTi3Qá  j*ªl¦S­CÍ(ŽÕBHênNXÃ?|÷v˜ ´ææ-wÌV›ïÖùzØÑÈ›«‡¬1d;·~­pÜÝ«ïØ7XåJs>Q%P¼_=°Ä.éÁ"–‰þèñ£p˜/3öœ©èl5€‹0Uœÿûç!ÄaËÐ5ûôœ/uü¼zß@™ç£÷>ç%R¶ü-’öêrK¯¶¿Òÿ½ùSwdþÚU—3ƒÌÍ— ªš˜¨£¡ '¯Áïzºâ©+›wû(ðXòÁºslQ: Åš6�~fÜíRVçÃc"æ$ö2ÕiH*u2Ÿ×AfÔÂÑq1jŠÜœ ’דö3'yY¸Õ7í•5›£ÍØMêhçs–9¬io–­ez§Ÿiž¾:ƒUìPYªeaxl Ê¢š‘yxÕϺ¿·õœACîñõT¤~Wæ…õÖ›rC‡Îþ‹“kQý/I&ïÃÔÏ•I@ÊÓ‘îoë·b±M*/@|o^è;Y>´ÎY&(w‰ºkdXú¼ÐPÁ*J¦K¿ò¸œ>´š´Wფº3ç‹…ØÅêÛð½‘öÍk,f§Fó¸R† ù¨j„UØ•.4Ú—g/¢Ê|\¥ô”ä—çl´©ˆ†Š¢=  >—¯·.YêÁ%&VW‚e@ËiÐ €þ{€ÕÔKì.î0(Œ‡ÁfcˆÎñ‡ƒ(úªY²VÀX„Ëûšç…îÒÑÒ¤ò™Š¬Ì‰¸fÒ³à–Q¤ù¥ñE&™UЄnJéÍMY¬k=Bµ§˜ä];6$4/H‡×z qp=Q÷î »HN9Õq½�`ÓüñÜT«d N!®îi×9¥"‘٠̈ 8°‘/½  ž¯û·óÞÐkZD¸ç}M{/×Qm)ŽÿP€…Dàƒæg‡ámÃŒúÞôþƒáfî =Ä9‰šÔˆ¼µuEqäj'*r¤ŸÁk•ËÐic{¶¼Iö°‰ù.dXeÙšN¥ÅW N˜2QñãMäï×>/ÔAiár*Ü¿å“~g:)[Ž³NÑTáÂ$FÌ"Bë0X(sÑ «•˜*=»núìGx� WÇh\‘¦ö”µR‚CùŠiɾdNg$zMµX¡–3¾nv¶S _K·ž¿ßXº©"£u˜á2»LÛ -��]xhÄPWa Pvµ•õú,ÏJÈKEÈ3¡"në7.ØÿG‚¸wüûRõ‚Ån¢ˆq[Ö^y.gX B÷ )óº6?[í)æ4ǬòÙ~:Ÿd¶öØ×——U¡GnËE6V"ãÙ“PÙKÐ|4vä¯Í4¢ ŠÊHD7ƒ`8-ÑŒFÞxÁYCƒÕj{qéB»Ôú,dÓvYì´P+Y½`EC dÈ–yR•Yëk)ÐjuàGl—.ÒÖÖÉ“åe8Ћt3»Ÿ?zµ€³Ô‘c¹»yìŠ ;k†U¤,°õ›££,}‚NÖšŽø³ñÈl@Ò èv¢§�µÂo(Í$s(ÍXLáÀr©k^9Y+ÝÓDɹíʃ~Ó2»cV†Ds½ccà©:ÊFo;¬Ì¦W-ÖäXN*åwö@nüà~ðó- W?0™f×—A¹w=‰Ú�7ý&o'œ }¥äd¾€âð½U™æž;?ÍU×;Ov¯¥U~•¹ÐG&æ?V.®F|¶Î#%M_{GGá–›YÆÑj}õ‡Û«UÛ; } !8xñ„ß‚ò³;tbUí_A6]gO™ŽÇ›¿×›ÙÓ<2šTñ*Þç®V’3q´’]€UÊäÆD@«µH<®—”ÿ£Â碠¶ÐáUµ‹7�@ÿAÒF£4C_ŽòE4¸û å©0ä(ó§°Ip™SZ k¨Ð:rµûª ØŠñ‘îmÄ.f;P¾´¹ZºúD(ÿòB÷Hs»$Y¹vs*‚&§ävï3*è3†§ý£Z«ßæ壌|ÙÙö5b&q¶×íö: ,3,W "óoF|±ÊæFL–ƒtŒ8¢I9+ ½XžÔH £\ºVZ×=õª€@‘™¹YÉRÆC»OÓ'e¯˜p“0Æ=b,´ì°?FZžû„ËÈØ¿B" íƒ23èK£8v¤• ·ºRÊþš  úõ+ i fý½†$í®¾'Kiéì%ÂHyqAÕ•‚�±ÿê·åÜ×¼Ä[Äfõ ¦:‘ÿ‘vç‚ S‰ŸÓcÇUO˜Í–r´Kç¹XÕ�.™Ì^¸xb�6µ‡íöŽx˜ýL9k(XC¨Ø}iRYNÝK9ëoVÙÞ˨ž©Ý{tKñ³¡X0Ïô{úÖ ,#H$ʶWM ïâ´Ù¯`°HZVÞ‘]ºguûˆ_a¶WÈ|qVÏ÷¾à¥2Ÿ(ÀuÃf*‚òSÉã)k7»² >\ä1²öæíÃ1Mf+ØHPl£*L¡#Ä)š0.Ù™Š‚ÜEN³Ç€XÛŽ“Æi†XðÔyyÓùH9 Ñ¯:-λú;Ì«ª›øüÁdz›aE\öÓ]cC53Î;‰å±cWÜ$˜>"˜ç_8!¤um_´c´mšæ*—d‡QjAÇ“ªÛ×G“«</<#aص ”9ÎœÁ»³@WtŠó°X5�1Ï~O £B¬ó&§fÓ`rHPé�•Z‚—þ/É©ib¸DF †¶Ö. R+ÇŽñ̶ïpæ›&"Øë[$oû[~óÜs£¼ÁTÆaîŠgæ_"ᨮI÷‰ôºDë¾ÃÍ«VsÉZ3�ZlYý×)‰5èÔÛ¾ù«2 7ª3pì0¦˜<hØr˜QæÎîà¨G‹úI[>-ü5do›œqgÂ=n2¿[ù|ÎBÂûW;]ynZa—?H†tG Úhsj%§:a{¬òÖ̼Ë*µ Ô¢ ÙfAi .Åçv˜Y1Zó®—(¦…÷°—Çf‹=2(N}G_üíúÖ÷×€1ÎlñÐM¥`N·G¯>¢´0ixOé@²\ïw¨? ¶»»8¾§N ä<rsˆÒ$ó�Ä•†Î‡Z Kv$ÙIU¬lhž[ÒØ#[oÏ\ÐcøÜ:wLéåxÞ4Ì•0wò—le}Zу,‚t¿õ`¯ô§qûVôÊãLÂÜÓãàcIXìÕf甉T–7Ãc};™?¿8H#_£•ÑÈÀ­ÌŠ (ÌŸ¹½Üõ ÷¦Ü]þ¨?áfAŒ+¢Çºl©ŒË÷³û“š3"f2”`oöo ³¾4陸Iá¼Kï`6µYÐ}áÛog/%jÎP‡²ú ÃÁN oô‹U›©KQñ5#£© PÝà•—ý¤î.ŠÐï¿eÁñƒŽÉ¾wS]Ì×ä“–Ë …›ýF6+w •ˆ+£ò�{u“ÀÒð*ÅzŽJã}næ]]7Cç5'1:Ðç¡GGË"²‚ôÓµEs^£—¯Ðó #ÊTŠM‡Õ R—N=x¤ôú§ûG7¾•hOŠG;íÒ,È?'?3Òî÷½A0š¾÷'„iTúDiÌÐXw÷å„žJ|å©7 Ò4>œ/rqœ¹ÀNÅî~1sÂ1½(ð.òoV&Ë|°b˽«;á1ÒHb”\.´5uvM2¨·|脾ú¡^§]Ýß×æŽN-T–±§B#k{-’˜®‚¦¸þ¿·úLw¢Ç¤Ju˜ëøœ’ÄW£3=ɱñ–âj†zÔž†+©Ÿ¨œ Šû`v¾ìÐ?}Tsž!ù<ú“¨T¼�0I /PRÀUžXB5[RÑJë´«�‰1aFz·tbÕck75üTÚðû/º—ýè—üô%Œ£­ÎØ_—ªOS7`çkGåy­š&PÄ>[}‚_Ê|Å 2û¬‹¦È™¢å†m=ulòˆ‚JTèÆô­Bß~ðÔÃ$óù9ýaw¯EnuÝìYý-x’ $…ï§@Aq�ù5½aºIt8 q;,Ó½‹{„¹D y¹n`¡�*ž;ße¢º³“>Œ@a¬&éϼ±#_o¯DðØUAõ®•Å„N¨QÛ¨G {ÚgzÞNBWíU‡)’÷½¥+°çP×t÷¿¦÷j¿d¶rë)eΔ4º`¸ ô"€ph›Yóå÷¶íEîÃÞ†jGè`1¥±ƒSjŸ¨ò>“áu–¾‚ ºÔ¬’0;ÎNJGF\ÇQÆ/!zÇrihê—:¡$®3ÃŽ$7ßSJm®aDÊ4Õ…wì42¨èå>hä$n2™‹{­ÅíNËdD` éí‘Ý÷2b~ -ˆ2ŸÓŒ{öVsµ3>ˆZ­4Xžôµl…ÊÁ‹NÉN§NhØb'�•¦j;ô ή¡èÜ;,b_„íi/iM*g¥VHÆá\Ãí-0ÐæV½”µoihÑG âÑçUgV‰yŒp·27 Âà_kʼnn˜Ã,¯sìèÁ/žP¥<³kÈ[#äosB«œÌMJj—'º5ù„iUæmg9�ºé;†Ý¿ô#"ƒR*’s†h<ƒ"†é/ýüÚ „+xi/€$&7¸àSM TðP£äúÿ Çyë;4Òôó•ʵw`èìuÎË ÅŽv'MoáA!ç™'’@ñq™ÑQt“–°<§f 4Èn1>eзI5€™xáV\SáØ ›h  ¬PM¬5A Ì@†^?‰SÇQ™y´ŠøL ùÜ{Z,™1Ÿá„xì~t0Ùˆ‘Òœ³µ—K¹·×XÑ@3Â÷{à¸X>þ&æ‚:H­Êb“Σ•X—H&uâ?|ý´X1!ò>Á·äs°*B@v[¬”{ω3ã솿!º»¼ídí1)ž¼ÅKÔÔWʦM=ü¡%l°â·ï0LyOˆ½)º¿Ê|é“Pp×I{õØ€´×!÷À”V)Î~ ¬®¼ú†zÙk±¬k/ œNVùužu±–ªŽ‚Íô ®^ÃjæFײ¤;lò={ñmŠœ9¿@ID6Û„Ò†÷ÁñYh!îÚ3 kü<5x-  âÙ®}Ê%…afÈê¦yÐÒÞòôáФO“¾rÙz¬0$í!}ïÇN)bG` _ØÏÂÊqD5jo” à¶MO:š¯<aãìK+± 3R½Ê~ŽKÏ‘ [‰™&8Щ!åRÁYì>0c ÍàÄ[Ÿ E@_içÏÁŽ§áƒO…_É›'Þ’…ç‡*;-ãiúä7…õ#*f’e7TÿaÄ7ßkó®˜}ïp jÚpÚÉÖ=qEÊÖÞïtKèÁ¥µ&dI ” "ØâµÿF÷}ÿÜ€ÑgHËç®ïø \Ç'7H°ý néte+C¡ YÉÐùƒST×]mú'»sÿ§îŸÇÆÂzÖóÑ(<£ÊI÷~Œ©‘]ƒëÇy”„øAŸD–aÁ~-W*ù’mcx~¬V}Þº]¹¢†À“íû  ŽðŒâ¼�÷€ÿ.ÿFNˆ64V\íBw ŸnTèýOJ™ànf¡æÛMW«F$o of­¡—Âs˜«¢²FN%Ëmë£ÑaïyêMeQ–ÏúînŒ&TE†åw–¿aØ¥¸ó“¥XœÝÄÚ¾Çhn´˜’ê7ýEÝnÇpOìk€&ãú¼ÓmuHðئ”:`¤È‹ÎhÜ\ìÉ÷××e\k4敯ïN ~£"¨RE2J…Œ_Þ³îIf2ÍnAù¥Ti|çí» G*³EIoXú÷–ÎR~F#M*mέ-8~ßÛõÏ— ••4í_žZˆðõøÅñ$+Î]©tÚ­PkÓ¤ôYƒ©ÀrÕˆ­ŠÊÔÀe›ÓiAJ7;ø—k,.›v–vû–Zî ¨NôíA󶥶,`1ÕæÏ)%·{›@—–ÃÍ`g¥=—åÚnýïÞâÞyrE,ô;ïà–Þ|š 8c଄ ¶àäUWuÿšgô"ºWDóÊ2ó}.‘P¼Lì­ŒJ§sgÈ9?"\«‰3EŠ” e¼ý7ãZª×ŽÌ Í*>óË”kÕ+”RŸq»ì]Ž[Ó1tnÏÐ&:@øÎÜŽŽÂœi̼ÓìħÑÑÿ$iv“wÌÀ*‘€ñÖÍY°ž”æû\¦Ì#/ÇxÐÎÏ #Ú(¡Ù¸>¼Õº{=5ˆc¯Ä yꟂ¼ÆÔR¨oéY‹Ã¼ðÿ›•ýöáú³Ê3ωþšöJ+«² Lé7煞錃ÝuÏR'©;?‡:mƒCÏ”Ièw©îìà*<©qÓõ;X7kVž¬,#c^¼[æžmÓæìÜžÖž£§ÕwËü$cÑ( ªªS¦eL Å|cÝó_VDYâoK8Î7”À¼oȘâ"­âÅXiRúˆOêú«lú[´Ñªa -å°V ‹{Íæ±ûùLhþ“‡Èf‘Ü^<lb'O bfn.ݹJ¿A¦S ÈŒW}=å¿Ñê.±"ÿË‚aGöy\õ+7Ý¡ŠnÚ¹=œÞRÊ9ý(äkåkÄyþ£Èài…³+ µfUÜ8âlìd=î²¼Køi77í›$fݕضÒ)êï€à,åó,Œ÷×Eah">Ü z¼ûÔs{ؽq'Z:è=›&ôyÀßß®.,¶Øò$  ê%¶Bd´àš-¼Ø z5ø-é ½†}q3êÔœ€üç ,ÝyÜÔ³ñ±{q¬7›¾3üy… xr°B§Õ´ôÚw…M‘}\šÿ3>Ź9df½î¿ÐIµTç* uÈ‚ý/À+¾Y¡´ÇƒÇØÖsƒÆëé'ÛÚ™ÇmjÚÜ1¸R?�<;•Ú@�«è×?N,'L Ìei!÷zÌö®&`,—îˆìüÙ1Ýæ?@Ñü‡~ïGw�ÙU‘ëÓä®Ö ŠÕ§òOPs.ü_˜ö}ð]iÖïÔôäÁT&Ç‚Ž•MÊù¿ÛÓ7¥œ€6 B;¢ïÍVy>P<lfÊ(·½K"꿧?VÃåå|È/ëJNU”v}iÚ•A'ïÀ:ˆJÈçSü| q€/•aºÔtÿçÎù‘s÷Æ3_¡%)Áå~Œ^…ë$2·œn`»,Xþïnöq„‡¯(÷+íìoRÚ.ËŠ ¦ ÒÝ_÷+,$™1‹î,“"%pÖž)30¤NÓ§“Ÿ*+&Ìépb8ü¥Aºô¦d §Þ >âìôÅÊ…¿]Fi¶Ân`ÎSPX=+XQ³®{‰O*zPüÕÐò 0@¶.—€>tH¼ß¿lîƒeKIúW˜Á >x¾ûî¡VFîñ8Y>æ¬sgÀƒMiÞÁ¹Ö[#îGÖIìi¯ñ^9}I7ŽO¦zD<±ƒªÝŠº1§Þ´¢i÷Ax嬤n, òU{¡¢2—¾sëë%Êÿb=‚—P_t·¢0¹qU:è©6ÖM˜W,þàÎŽ¡»˜Ù€¯Ò¶üö³ÛP®¬8‘¢±÷ ÐâìUú[sv5Q÷34a'™UÀž¢õ¥m Cϧ(O{ôéΰŒ˜—€&ú3†^™#o’‘ÍâàuCÃ)”¼›ñÁ:qPžÿzê|;²=RPî]i5òíØÿ©-G2öÇê©|{7Gü=A§ã– ‘;hN¬`^8]ä>ч¶AÛey-þ Oòt±#6Va{F§õÅ9x¼¿™Â 5ºûu9õ³ªÐ@®[5@QÉC6I•fž[$Eøi—Rõr¶ßú8=ðÍ6¸À5ýßî�}è`\z¹17J‡)I‚²U\äWxh¤ÒSo¢ÜxŸ²Àø î;{æ,xj=—¬LCjTggÈ3îUþ·*˜ Ów+ ݵ¥Í£ð…Ùª«±8ÚTï­×vÅúÇìX߇qfHÏí«÷Ce`ˆÆ) ÿÐ+Ú{=z€—tÎpdöŒnç‘iÅb„†\«²†›\/Aubß,«nw< ÜmQÎãùêºö.WòE¹ç²—1ÅöƒNT;ìtlÜ’º‡ ø_uŽÉ¢Ò'n¢ƒÇÌâU2RÜ€39É‘:÷Ç°Ãù‹'t…Èŵó¬DòúÔŒ"B›ôa³nTìB¥¸Úï÷Ö‘¶^‹Ç%'q·ÿÁä>±^Î¥Á?t_Ð/ì|ýÂ}ý·ëa˽ša2]Í_Ÿ…X×RVºPT\Y±S|Ô®CëVÉ?½\R®ýòyòâxnÒ®ðÜ+CÔþW9Qèø<;UY+.‡…#‡¢)C÷9ò¦u0eH¨¾AŽåÕû¨æñëèð“•í]zÙ› ½PÑ0ºúŒŽ‡¶ “’׺aÛ«ç7 @”'®àcåŒeByfAŽCYW <[&Vç¿Zˆ=ìQÁp©¨FÙš¼‹V÷lJ9ÿ/ºirH‡Ÿl’Òêna÷ð;ÊÏIèkNÂ<¾ð³Ö2 ͦÁà‹ßÕ•FÍÙÝ•.÷ÖˆÖØ„ŸVxÞÊ/3‘GŽˆ±«7ŽèÁ¿¼§ímT.<2܃өõ@¥°Ù•Š=B/¬ô†3 Õè ¶Á¾‘*¶·OÒ¾óŽ~Ñ·Ô ·ñ _³¾‘æ“Ý•óÞñø'ª9¨0Àò¤ªû’ºþ.¤´Ž² ç2ÈgËÿȘt󆣒7@8ÐÍØŸûc§ï~ ßiìÓ4¢Óú*(gy…èÕxìƒù¼›ÓGQžZ>;ªü™^ ½Ö¡©#q[/CtȺ; ÜfnbÆ—3eÖùdœGèÐh•FÇ·«Ò ]H÷ÂožTˆñzWßë|…IŽ@‰¤&ê¯ÿ¾= lª1ÙæþüÑí€ÌwÏ,T] Y™êì$Sß‹yÜ�³òÚÄÝц†íÄüÐ’ÉB_z;bl�%íݧ7IEóC>þä_èÍçiJG¼D_®j¦#}væÈ,ÐrŃáû®#v–<äcQ½ÔŠÎΪº€#toº¾96þtY„v”´â!Ç$q ž²ªQÒ~*H™±§ ¼½m#ò©¨Qâ©K°æÁ2ÐRAƒ941Ò œg£µ º1 Šœ®¥môîÎÝÏZ«õ®éu @7˜ ^½¦w­å0j¬;‡ ­7"£%âvF* ƒ6ÔVMÝ $}Y* ¼ E$�¦;ŒöOÒQ–i¨!X*DãûvN<¥36˜{:·§Æ£íö'&ë |âócµ¤¤p}0öuifª…Ëæê|ƒš®½XR("ÖafdØJEÓ¹éÞ¼ÕTLU)m¶tZW³´àc¹ Kvšlñt¥…"‚%×M^V!O/ñcXf6[uSÜ¢ÓÇy~UgT›X]Ù= ²Ñ7©ìvÚµ÷uq^k2E΢Æ8@!/Î)Ž)v*f}¹3;Øh ž#ÈåŽ?ìbùnG¼1Ø“>.žÑØL‡7âEÿÿ¬½ó¥—ŠÇUè| gÚß[OFÌq÷Íf¹M óüöƒp¡¾;·ÒÚkdﺶ¢J €K’©¥¦v6VŸçIòÁò}\X8Xvʶ¿q×: M+U(uäÝóñÉI™$.›àZ|„Ufùyv¼æªKZmžÔÀRÏ*ïr]±ÅñÊ“¯žLuíᛶP»­‘îP7�î¿ë€Ó\¹ù$Q¼òcƒ…_EYrï%›t2¯Pa{hÊó­ù4è‹E '.óNx_Aü5ìß =íú0 3œ°Ü»{£˜È`;í¦î®íªÁ”(A-7Cì#À¥šQaQ·õŸC;¯¼+V¦iNØý¯®DÅJ!Ú¶T±U•»“ ¬j#/Ø¢yŠeš)o¼[’-¶ñ©^D•Ê„ :Œe†ð[Uì¹qr=Þ`ƒ#Z)YGîËžM;ÆKßï»þì.ŒÚÖ¾zªU¹ÑÚÙüËY‡¾yȦÇÝÚÝí¼uXún`6]é^;mœ»Ð˜,j“r9ˆèÃ}¥ª¢…¡çEƒ£ì…EeÚ>ヤâœ{3¸÷Âd2' ‡m …›0H–½Ûî[Œ©ØÎpÔ¹à–)îc¥®( }O;0HjP°k§ƒDŠS;ãO‰à°œ¾ø,_į̄=»½C¼ôÌ=2ø.Ò“ e¸P»ñRÿî®­Ëß~73K<| Rú­:|[Å5«þ™1“òâíOoX*¯ª®Ähx›.z8ö8ANÖ¶ŽX¼ôºø“qÚRÒù»#ªy¶d¡u˜fAÖ+~qfo½ëÁô£p˜%HʬäôK±¯©´^bœtCKþ‰¥lmºCõ•Á¾M‚”ûèFðlÛ!½w¢ýˆÓ¬‚±"vžé3…Uì«igtª¥EÔ>GªzÎ õr ˜Óß¼¬î{ž­4«(³…©×¢´M0N™‘ÂÃ4‡ïþ5~5Í]Â'Ù\'Pn à›ç:uû~¢z—Ž¯æôEÉÝ*î‘þí©Øý(pA–Ó­*†XŒ@ÍjV­öA�—íOýâ÷P@n»Áznâ~™8ªubÒ]zßjÌCI»óÕŽõM¾o’Ý{ï{Ø?B¡`p@š•Ÿg²t5¶¾€ŽsÁJQp<AaÉ[(Q¢Ü($Qî#÷§“Ldî8cDž, �ŒíSnL{|âžÂÌ°é¬4¹(“›×[Úeæi©å/ÙH»þ ª=æå0c¢Ä›«? ÛS×ÿFÿÐÕÖB™(),Ä”VÖ+ Øþˆ)¼Ÿ¼ù—�RÛ~NôC[Ó­ìUí ¨à™³2­‚ö7)íÌ›ç¢Ó,Z³ÝÞûV,`*‚üŒp±º/†tû˜}k!õ•íSª£¦wçêJ-So͇>‹ž¡7vBEUS”£MSgo 7€ˆ30, (ƇýÎØ JXtbvß^É-³ØØË ð7´|�Í4vMÅÚ=Ñ4d8ú}(”iO RõôQ1°Sw„Šƒº©Ë€¥ïç· m¶-ÚY잣¯?¢|¥ØByÞ2TAÜh)³Í³°å9Ä¥tººŒÌ¢µàëdËq‚ 3怾9 ¦¯t:ïÂIÙJk8£¼ ïV4€=âG<MYà×CËüoÙRô?iì€#±x†ÂÀú¯ÑEqÃgO«gu Å¿üwt«yÁx@À$ñX˜´@°HeÇZås(†ÍvWžÇÑ`´ Øšî̵‚}µ9¤äÐlR}ùÃ>‡l³¹ñœ†nÔnÞÝž”åŠÓÉ­‰‚RöˆT±°¢ ÂÏNGq—’×ïëÚù°›ÁvØjâúGã§ðÚtt_õõeSÓp-ÐTN﯋—Q´çaXãï?H´¥·~÷\Å«þv±nPÜ\¼‡ÁÔú+¼.ñKrAŽJñ6*èMµd­ZS†¹tÛøA¯>ú¢/ßE™g¾KJ 7f2¹e�z½MÓ$ êQœr¥“á^ùê3RB«1[Í;o�Ø1¾<éâC¥d¿·n“ÊK™øPMœ5$ÑêûS[ôÏÜv¯3Èö5¼Y¢ypTatÃpµÇÍ/öJ±¢ûRøl!IS¶%üMÂí•Ò'ÖçªXý ¢©é4§~ùfÌŽWìÛ”³V^ñ¾µHFøì)qµñdÞ¡í¹9-hÕÓ"KM&~k!¬oºX¥Ñ•SïcÕ¾³äK#¡ X‘4iþ‘D©‰Æ©aƒ\ÈÙœMC^/ë0:K‡A:‚,¦òDR¥Xш£s.³êS‘ñ‡îfq-<Ð×ëYwGÁˆØÞ[î&~ûîüQ‰Âc¥»´91I«�!3¯qvÓædé~? ®ã –®C!µРùë°‰Hl¡oƒªûñă_ÌÚV×à|Íȹ¾kÂ&®‚Ž.ñ˜ÚÙkh͇ :¿ôËæ·ÃôG°Rð_¤³Äavƒ¤ °÷ªuŠözÝ4nÓ ÀœqP î›Ü;wXñk£74R§ùa•Šì²8U¸Ð󅞟`HEžy2}ôÉç†êö²c¶?žwȼÎýi"ww…þ v»™æ;ÕWdôÍ^w±sŽË ç*ž ÆBƒRÒ9u3æLðÓ{Ú©®Îü�Dì.Æ„À»üþ¤<c:ƒ0ºRT(¬Ú-Zx=Ê×nÖ_m—ß¿Ÿ²áªKN¿•Uôg]î,÷aþ6IÔ^SÎw:åÊÄ!Ý;j·6uó–JýâÌ Rk.ÑçYûbˆzβ×îþ¬ç’_)î_âÑ—¾r><𠜟ïì-UïåyNÇ,Ý<N¬Ï ysgT–Š< Û·¶ÕØŠÊ…Ü…W"£íW Užöú°£_÷µ;˜w€}Ú™&Ãx´òÂ9 æ�ÜÁúnc™f43ô6e±:Žœí8 jOŠ£»/ö<4ˆƒH-|qJEŠÐ£1.´Ù ÒÖóxFãú§3**SG0á4™¢UBñdæx"~LTZrµ -âŸCTîcߦ¨ÈóL™$”î‘EÁðŒzÄpŸº…6ùÁ’ÏŸ(°¦EæM?BÐÓ k}g:, ¾nÝxÑÒ=˜7¨G¬NÚþ!NY ¯MtÌÃAÑ«3•z ˆìFÖÙ¸,ÛÛXwÿ§þ¡™³ªíè9%çÞƒ[ÙÞ°"˜iÄ–#b|£˽w^a%9v™ÕÛ+øbþuOq\S!ª1dƒ=˜‘áý[¡¼¸tøÜ”GÀ—”N M„ÆÓ”x¸QŒ²?y-1©B_]Ž ºi[—‹þôö¨´PGÐ_7ûñ°üÒ|-*òñ'1±­‹Ž§ö:蜈âÙ²gîU17ÕL\U>›Â`GõÇngõ?8²zÝ}`cd$éèAíÎÃÖ"f½HŽ`g게ûÓ¥Vˆ­u ˜‡ÕN6²Ì]Íž;òÒÕ³êÃSæÐØEp=Q…ZZ€mæeïæ3q,ÜþÀ†´þE…Ž²Àw|TÅà+6T%ÊŠ—‘ØØ1Šq+ rr~ö¶“ÄP Z»òM×ï"VV¯ùƒ‚ë¤è=§ëVXe¬²Èñçup·=›…žD+èRCè²V™Üœç›ƒ'Y£H*¾@[‹=Â9o‚í³[¨e€}N›«C`ý`ûmdçÕØŽ†ÓíÍð]3=˜®ŽãÆtÕšx í¡¥Ã`åµÓ¹º`FOò®:^ U’5ؾHž[dÏY<8' ž¨°ÊDÒ½ƒÇàƒ…-òVt½˜‘}Sô?À ç…ßƸ‚=ɬkX õÀ™¤*ÿaŠ¹A§tÆhÌ#d¹wé]ÃxxÓý9]#ýÜîi =;¡7¨Ÿ—ïì•„+«äÎu”X|ºŠç%Ýu þ6o"tæ·**¡“P\Í_f�¶?µKüªY™2~ˆt‹ÁY˜Ñ½9íÜBGЕfÔ lÄØJ+2w9['úŸ]÷±>¤ÞÔrþîêàÑ‹EÏx@9÷Þ¹Q”Dá`Ó]{«Gò’7ITæ>8â·r 9ïæþ°ÖÊ0; ‹$EzÛ‡ó #‡a·µ—`DÑÁÜ"¤+ìÕ·Ù&iP{¯E‰ÏQĨ–nwWq.WÝàBÌ$Ξ¨RÓŸ; ½ Üy³ës?c¿<‡³¤žphðšÏø\<ò‰)NfÒ2,©ú<ïÙïou‚GN€Tð™,Û”Ìz €ˆL[‰ ªÖô’hS–­ÄMáI˜C1Õê2U³Ö&l–÷’aT¥>=6]Œ†ŸÊÊ]®èFX‘”ÿ}KÌš,¸¼Ù8—ùçžÇ?¥Už"ÒÁŒr¿*(:¥ ' èÍo†z ¼‘²æeW`KJ2Ú5$º’ ² …X‚Ã2jX2O”¹¬@g¨z“Wú¼pÐòàÑ·ýu;]i…<9¥¯7ïùÄ[« $Ö¬Xân Â,HjÝ0‡B:,>¥´8#Á ØïÖç•°UH%\iÜwI1 $£Íï~+Ž›…᪡V±Hüe7Ûtq²¶½Å¯˜7OݨS7>ħ'YÏÛ½ ±©ª½‰X¼^¾;1o/Z#a½÷$3;;’f´ƒ ݾ— üÔË'JÖ07:Rº*HÆÙk¤lúúʃèU•ÂËŸ÷×÷:¥p†®¬=ž*Š£GhèkÀçvBi±ëÏ~ ¼u5EIǸ>˜'6‡¿5¶¹>‘2gCCXê£\˜½rÜXÒV…º‚6ÂÅ<X�+ŒYíÓÄåÇ�êÌëdØøûšBæ øéÜt̉42W_šâ¤ò‡ËP:§b9ùÈ´ =ó™*դƥõh¯@M¾‡ŠOSoÊÌÏp®S˜ýjwwÓmY³•²±áȲӷfF{©dßtS×vd¬îÒäð^²Wò“LÞÏMf:ÓöfosªÚÇg/ns¡Yiì)ðöΧ¿^GZ’G[s·]#msºO(©3]ö>!_¹vBr¡Ã®ç0ï;VÕ“®Ä7=ýÇ û¬fåJI†@™uHň¯¹ŠQ’¬‘F Lûñ†án,É.©Ã�‘¡Ùñ\Vx3ŒyþöÞP&ZƒFbéQT[G3jš «¹Ðßµ(Êʪ Dì‘ØäUY»'™7Ñǃ£±5 ‡?¦:ýhÎjé~"ÜCK“ËúÐjýÂxì†+lá¨ì[Q¿BTðÈmh½Ä}çŠrŠÊ“e¿ßå}»wà GOņòß´¾h(EmÞ`Ô̺ìAs`I¤7ÑÓ†¬{£ÎÍæÆøO8Cø?ÝÄE'üš¿jìiŸ•[Ÿ&§ËÿOðƒ:¡f8÷(¯vØ/ðe*-é£}û× •er“eÑ[û«¬vÛÅ|øvN6ª·<°Ä<l`Ë-OÆžO7w4µ-Í¢ÿ@ãv<Ž^=Ò­ÔÇÃñ±£uTÌ_Þawh1«2óÖ®fáñ24#OŒEÝxµE݉ç:§Ê²â¼uwó'ÄÙJátI †vžÑìf`TÝÏ‘Àeâë퇑)”ß•¾på‘1eÂËÃÿ 'WâNôáËgÄcã:a#:è0x¬;Æ}ßRΫŒ4 ¬fÜ4¾Jl(©ù1®ÀFyë…klaÅ4©KOÙFl-åh°ò=:ôº}?Âgäâ*÷ghæÖÀPLv†?ûi:,û{ø°Ìï¢L¢˜A_ñÓ÷æEÅOÊnPÌ’¬tÔ·ÔgïêÛ<<ujÔÌE—ÚÝ€Qlëõ7dEO‹÷Êâ?ùÓ 1ÑWýôç%#•3Fbêgdmby©™Ö/è”g­º \C¡þ><ηf!³Ü7#MY*G+F±9¼é•©;€dx‡/^ÚÌ =žF½fŽ€m £*ðˆ)Z¢'`?õ•iažd>î’ª]Ö0a×øÞá<ÞѯÅ)GK\_±e;Ìà[GÏ­`ç‘ _uƒÏ+Oº›Çç=„µ1±wn¨Öþ‘‹RM ¬ÜÀ ˜¤bb´ž€~îdÞ/b�3SA«sRl®!ÿßê¦yÄ÷>õà€è™[ÖŸ¶¯ØõãÞ(êËÝN}ž¬’µ„ç¸TD|5¶ó="ç4}o; Mrè_n%IâÓ²)%ŒiÙ«ˆdîã9±&ÀüdírÅùG=׺÷‡KQ”øµ,ý%;pƒ[뀛‡Ô7W%aØ£× ü>„p)ø6œÌôHð)úç¨ð/­UV®Yþ¬NíÜc6¼ß3y¥Ö2S}øÞø%¸z¸ë9+Òè0¥ÆR}ý«cdÈN¿­§'RL½æ ”öµú'Yš›wµæ÷¤‘CµŠ0Ñ”³t¬\?pâOÖp>c°Áïò–ª˜´\*#ÔÈ–@ån6Y¾ëXoÛÃÆlèÿΨ¨|¦3à­h@ï¶ëëÖs œGyˆ/­lŸZ€ïÎt"CNßØ›RÅ+s&àÊ”‘éÕrfâDG=3Öìij˜>i[ËV"»Ö>Õ-ÉðÿC»­ûÿJ^Ñ©Ù@ŒL:¶Ý Ž¸nXœ°«| -e§Ñ¢–Î4ã TZ?º=Es­má“+çCçö7ÛˆŽÐ,dz׃–ŒØŸÉ°`>mÐŒ¡Üqèhg¿ —›yf1´)š9¦²_Ì%3³ÍD‰ãÿ¾å‰NEf÷„ eç?óyì¦ÿk[¿=VˆâÔ´CÃ.¤PœIטEà9Ý}O œÎå°Ëòî¨Qß´ »”"Ëè1wŽb¢Ñ|æ¡ço^ ì%Œ„;Fo5&f3#Z•P¸5›F Ýpìì¤Háæ©WQšø˜;˜½UÔ* Y±(Ó4mfÀ$D/Þ¼ë¤.1¨7Kå³½ÔvöŠ ¸úô¨?§R¦9±å„ݲìÕ SÞ´X%‹%c{‹å¯ç§ybw= ‰´¿û_‚z]å/2<X2´Zóiv(¯±n[Æ«H¿˜’r±6E:'(^µï(Ék†gƉÖeµ¿˜¡lì µÉŸ‚Šœ»«<fÃí^íåÜj•0›–gXuC[¬àhµ—ñ$ÌimÀÙ@ŽêµBÖÖ®6ûþ“–ö@”½¡„ôã5!¾Äu‡e™6 ÝŠvñÔ¡\ +.eq0¸šŠ¾`Z¾XÝŽÌÃ2c¹DÁ…nò¢)Rl6èÀ-ï7Vµ´.GÀVâãs{îïºäáÊl· CÀƒN3ý”·WcÅÌ·Å'ó/mãö0úthƒ¨³J,ÎyÚy=œƒ¨p0TÓqX'#^¨Ö*rßýé„ŒsCèséÅÊž-ÅÇ^˹„%<`³ÅÝTþÆ«¾L]yËTÒýWTµrªxhè?Uì Ú�ž&î†æ‘ûè©4¸å­ŠŸ åû3ˆhvz—cd7Y ÎivTŠ×˜*íÈ¥ENÄ7ŠBîÃþ4F*N”>å6ñà“¤÷ô¤±©‹¹î¡}WœÇ+#.܃pút%$·»Û·¶è#Þ؉€#Ý/Ø]ÐoÛí·W¡.X,+  Ð (èn-Ê$c– Ÿõ,üƒE7/ØÌM }˜§¤ëܑɘ¤6NTŒþµŽz´‘@œÖVø0l.ÕÛ^ûöV0Î&aL‚Ͷ¬ùkNFà}µŠü…ñÞþ¹kýÌRë’[ùçEíUé)¾Ó¢­Ý-ÆY_ö¬~§/ø¸8Ój\Ì’þ$àöþ] ïLÍB¨† _èÑ«ý¢qæ©€§s»¬¶52[V#žú]é€eYšç6w±NIŒi:æiq³óê%<èuÛ1àKS5¡ˆÊ)P׃æ›öŸncRÚwåÞ¹¸`ß²|©{š1«6uèv`•wJV7rÝÓ¾Sph(k‚·£±±ØÙ·W ØrÖ€‰H•Õ…ÍEœ•|m{0j5tÜC}l¸k´qÐŒ‚%æ<ÃÔ-X Ø#®‚‡ç=ƒqPtD@ì Fînó/~ø½#§Hã ˆ$ Ÿvçõøš‚Òª„ι»`®–ÓEǯ#ë³ÄQ¶rk­u4Áˆ­µt–*Ï­ûê˜J¾zqz™O¡xo€µvsö¸´*¤¦ˆÆ›ÁÃ/¦EQìZIb¶ ­³Ìò&^*6xOvìñ"/ÃÊEIÓ5£Ôˆ¢’M{ÑÁ¥í¼h}´ans£;WopG cƒÊ›G?Uy/ ±h¤Ó.~ï-MT¥´Ý�U§A¿%É­hì‘UÖJ(X‚™£Z[Ó¼5×ýô0õÑ[øhb&‹"¬2ÃÆÕétØ5:>Rº Î*…í;ÔŠ’\ÛGqæëɃFYéP[×&›˜(T5=)gU¢z>‹ÌÍÕ ÎÀ÷ôÈ9Æ¡T�:¹Œ‡` îb”×šãnä`‚f€;ŠyŽAáÆS© æ } ý¾Q÷ÓëoZ¬ÑMŠLEmØ?Š’ ÷ƒá–­Èÿ̱(Ë*sø0£³4aOvÇOTDOœz†D… ÂKéy»À® ÷|è.K‚Vç¯öâÒÉêç|ÜþÔ¹e* Åxò–PœB»XqïêÞj·ñ_ÌÚõfÁ?ÒgŽ«Õ“ˆ2Cš²½`"¸XA¾û_Ò¥ô©[_’Lµd²À"^^<�†©R~UÁä‘–aþÎåm¿´Qöÿ–ƒ8.ŒãaãÒplwËr—Æ Iæ1YJèc))ûØ-päÚà•�NÊêÿ™7]o5Ó´³hŸKa��Ç”ª¾^ÐH†wêBÍ ×›ê1M+/߉tä¦OÝ©Ô\°–Þ{ÔÔ›½œ <§qW›º›F z®þ%ª ø¦/Š^{ù©½v4­öÝu1½†½ß4×9ˆ@ߘ-uê« ´œÇ”Gæu+¼POsÉýð•ÁM’Ǧ(ªÌlsœÖ|0�³”=÷Ö™U>ç­c{-&„™ÔÐuý’Òͱ8â)S°Fkš)~˜ ‚nõÀº,R)·R¤/С¡»o©ì€{Ì>¾Ìß@ƒ–cø¼º–è­ÚÈ·QýûÏ= ¼eÙ°…˜õQaÔ\sáçÆA²qä ’Rãs§Û¡b-–d°)‹ŒûÏ@_×Ýn« šöÞæÕ½ÎV$’¯u¹²Aøý,ï‰OÙöý¥E«»ÑíP…2!°¤Ô3¥W}yLlÏR_#Ñ ¶ù§+_y²„•ØIÁPÜXE§@Å`}õq`‰/°ÃnsŸñvkêlm¸ùpÁ&¤ÎŸÝÞšÀ§ÕJ �n–ž±4úb…Œú«ujy¬7ãM’MWkN(³âZFÖ‡~^qS®øSþ_G©ëç²VUñ®÷ É¿±êÌóÒouåH!½|IÜå�¢ÿýñÈœ$³öæSà>Õ7õ›•–!;(øæUËjåLÍp.~¯z¯a~’­HÖTº—AÚnmž“sÔÚ Çã!ƺȿËö´XA CA7ÎE€Fìy 0ó_ÐÆV°94Ì�Ö1ÒW¬ÊBéßxõm4~5(Påʈ}€€¶­Ð÷Uc΀ŸnAùß·*ŠÞþCÿ&þ³/ô[¹Gó„>ê( W¢ŒUÀJéŸJ2,RžC)ȱ6~-<˜yL^¡ò@>Ú5ªÁÞzªî²:HÖ8^ Kê½úØ5ü9£Bï9Þoµj.̈üPñ GG¬ó`ñŸÄ9;¦kà Zõ ¼Úäê>Ý-¯ôÇÆú…n ír«DÄüîbÕZ ôÙM(#FLñ�´Ñ¢žý$R¯Ù©êßcŒþÀµè Ò0³÷_ôéÓà®°TÊšRáÖE}}ÖyϪÐ3€ë“òšú¯W¬•œI[?à³p%»Á8%(vªÜojXÎÔéžÐ`ãë cŠ?¤U^¢}GR8¬�ÏLP­†O§?jvŒgeÂÝ…ÈË´Ô8ŽW‡)ܤ =ÉÉ#¼‰—„¬òíÄv·…Sãî29­™÷³‡J娆<UžçT_˜ A© J>6íÕ÷†SY: ÷‚‡‰whåà(“ç<cóµÂšÝÚVÃ5¬ÇÞØC0H¤Æ®l¼Õ>Ë3ÅDJ÷•Ðí§¬Ø6‡éP°jgC‡‡-W¦",üÝÐÜ×1"º¾ðàÛ^Á`MJ<­]í]GÒ´õIÍ}ÄÖT&bôãt8M/ƒ|ÔY&äʉÛý¨{ÛIY\‡ÁÌ8ø=«×-ÝŸþš>¥ bŒ66MTÝ»7Ý–¦ˆêcª±ßctp²2å`#\ÒGjaòâÔíºacMš^šf|+}°âö¢e=Ën#ªHÅð¥ÈxÃ-xò£ÇlB‚Xq9“Søiu5ð"^áÚÊKp[ôGÚ9βëî_~w{V·,tf¹©N ïp`é&WF™@66{Úkíóž~9CªˆAœ }õÌrncã£ÐMfsNý•j‘ùÍVî÷Qu›[ê?¦ÊE'Ñ+æ™ظÆ$ü_€ú¾†"’à‚E ˆ-¼H}c}ÛÍRCf¦×YƒUïÒ˜ÂÌ [TºsÇœ»¾ ʶ5ùeÌõ<¨OŠÔYº…wÎ,dª¼Q–K‚e <(ïœb¨Èr˜¨9¼Df=.öô±óo�Ðq±H‡’é¤ò,Ó™þï6fÚ‹F÷H»£Ý¡½zÐ*œ í¿=ª¤Œ}¹K*c/m”³Ía³ 8ÑÉ 9Zöij¸gïõæEÂç¾³ŸC@ã´£ ½«_BÌXG<©dOíëá»BI¬P¥Áfôs\°(„d %‹dPðgŽ«Áç<¥î¦†3cú±¥Té^Õsõu+ÌZS>&êØEe…훾rvù×¾_€rð·WZ Ãè;šÕ³+"~ÔûÈŠÛ)ä´Õ—Y»g)T¦Á£N^ ®¹|£Õy\çEúž¨Èwæ0(;Հȧ`”8Õ“G}ý½ñK´rÿBƒ(¡Ê䎭óï­E`¸Z 'qlëËÇiU4Z>mÛÍ¢÷qú2Ú ßº9±‘)s˜ëSVef-W(õ ´›¯›>»ßˆ¹û:è\²�u jxâèR!kDô6 ¼@·gIk.Ó½žÍ)=ê-à"o´v©lÁŠÅ¸uª—e­0ô¬0Š¢È 0(ƒ}·òÆ3³–Á³4|Uû‹v[™Ç#ËôJŸ½µ–cRè?Ý›È'n,C@ýtù÷‰Tå±Â™!Ǫ¹…ó`}¢§.¢Dæ‰U}½1ã‰<kBN …üÿ©“¨¼d˜8¢ÛüÒã])†3%÷Xé»~G¶¹ê¤—̱nj]o_ï""W±X®Âfã—+w„r“Ï2€Âü“låA©Ùsã0¢þj•[ÀËr²v=ƒ³-rfª½5i>µvjÙ/ýŸÔ€Dù<9œ°=XFI«'D‚Y¶,q­•¾©“?×)Ïò<&hi;úª[§þBT7úG¢Gúv^,¢M_¸Þš;õç´;wz Eañöú·R¥Ë¡e?%U©ûI^;)V>ôLD¤ÕNýéžXK»L‘yQóWEZ“ÌÏ è‚öuÞZxÌ ~ÌVL¶qþ2ÏÁ^<S44‰ÄpÔHÌ*&§?Ñ' ãçþ®odLÝ•³¤eG_/ïS¹r™Ê¾‘y{­»K ¬@…|÷u©2_(·€þzò×ó9¸ÊÔTÞyW¸ „*bÎH›zØz¶·ï¨Pdo.G:³kXúp¾X:¡)-çiQ6g!—¦sËÚ÷ÿšeÎjŽ]”Ä`ëkð‘£8!‚árøzj�«ýtT1åË”r‹IûVeAíAÉ/®>¼we›‘ñªy¾QŒó 0çƒ7ß=-° ½ÃvŠ²Ü(¡øLçHT7žPÂætm’ðdÜiò(u3•³ïŠäN°—Ç âê³­c~ÁÝóÄöŒ{pd̉ƫGî¥ÓuÒí¾û­?Q褅¤¦ä©yضÎ{úÚ]TT=·ù®þ43,aÌø,GÆͪð³�ßê·ÃLA˜öÞ¶~ºíõ© Z¥qæu¨Àʃbê¥÷áÏUE‡fжG ƒuéÝm–jò$H?m9rÝC¶� Aͧ 9éÕ'Dƒ@·F…•¸HÊ‘ÉüßÞ < R©¤5­>[¹×¿ioÊ°yþÎm¿/?R¸î;~yth¤îU‹ò¦‰/†M™áPÿ©'—%¬õ?‰fú÷’QŸŒWÉ®gg‘2Ý+…÷ü§Ež ÃÅš„>¹ÓÍŒä<�†W$B^YSpob»-(U<3mdi­75æAÒî¸{iÒK“V³ƒfN¡† (Xä3\ð3¿X›_<¼¥=ûªS¬A+Ó~çÑÚ»”Ê7ó=Ç<‰Å/$~ruJæv6êà…vLZÏž8íR+6¦NéE¸…‡âÀ áã×ÜCMüăœ¢ôCëC˜¥ÖÓÊ`©Ît@¾Óãسme0Ð<D Å¨ÖGwlŒ.jÀÊ·3-{“™ìûîŒ,.BÏ’—4˜ìöÎ £©á”(1OÕâ¹Ó]V%I;*UáG8:Ó%-�ŠÙ§·­¤iofvL·�OËú³ì¹ƒ)œl²Wòa~ùZqa�åó—ë;ôˆ êäzÜG‘Ç+ž6Ï}ßeƒ³èñÔ8¿eå(æ#›˜˜Ï§s¶Js"Š•©Òº”M.œu–÷ÖãXù™áï}Ç~ÇN J@¿æE½® ´ZøYÉÔ\i�Š¸y4ÕK}ýéŠEO)ÝÑEëi~t=XzN'E`Ð_Z¾ÐQk¾öª’Ï×4þ”ÒWV¤Pæ�#ô¯˜áÑ/¢ÅÌS)écÿ yô.ö{½DA2Z.n:}ñÓBÓ§u9ôúŒxÉ“Û=- 4¢t _²¾ü4ƒõׂ‘/¯rük¥¡ï]ˆp‹ÏŠÚöÍÁÒÉ+}ka#¯¹zå¢ú¹ ªwuzB˜Ú!)ãÖ¢õ*®oúú�t¢±>k6üudž§Ñÿ¸_(´–>—íÝ2(gåÇ ªðá(`zBÓ]ü`G%Uåá/Ã\èž 9^Š§K/ðVì�áÅ"ž¡Å¤¼OCˆf´Û Â0qd=5UP~NÎ'©éúãiXìbiqÎíš¡ëg´Gæqüª<R)7ìE»k:»–#´ªvÅiæ‹þ€Å2ÓŸÿÕxü–ö "×÷z®¿ŽT*#'€’¡'y¡"¨Ó_àœüT®�L¿ïe÷vxÄÝ¿lÔÒ³(OÙžõÞ¯zf`ošF€äÂL«&¦õÝö§´D:ðOéí…í„JÎÈ„&Ôí?}j%²§,+èGJ]Tx86 ^¶�óì5Úg•S¾7—ãyƒÎÛÐã«Í�ôdœ»ä4ó{")¦qôþÝ£•ØÃI]wjË›¾gœæ+K'½ ¬†~0wŒ«âvsSs¯Ë %á½ûGŒðªÕþ¢§ÿÑS+d :kš–Êyk-…A׋ڄdw¿ ˱ƒrI+¶_Î䮣ÛÏ OíŽ>³þzj%© « râħ¶_†t…Öb\gÉ/DÒ‰Ï3 ™¹X´-·û—k*»?៚@çUy䑬ۮ4ÔTÔ|ó7TNÍþ%:,¼%YÌcý.üŸ,YëÃÁf›§Abëßœ)Ë}MŠw5à ÷œqógíúšŠm€éïÿ ¹• !‹˜Ñý«êÞê/G¦¨'Î弟ÿï›ßƒ7lWÿ7‘ó¬,Es?ƒû0*Ó–¿”´¹xrc±'Çmät-+£y7!_¦wm-¹m™S ½^¸…Î(SShsB½U$–3#a¬ Ž)Ìbôd¤j=±™º ™¬AgvÏúu%²®'@(A3У޽[¯‡J„:)ç­•Š°fô‚ïí^з?Á×Ï]"Ï*Âtch«Œ_îoUÞŒ¬Y&Éòz3µ)"Çòç<Œ>+a 3 âÓšÎ�Û|þÎU9¶Ð Gíd¤ÉÛßxú@*è‰jP鵦8ŒÑ“a¶Ð'¸Õ:Œ“Nºöu½ú$ØܸdmŽPþmMJ* !­Àyp£6%��€ 4¼á;?ãP²žÅ~C ä«/@ÓÙ´µ^°T¥n€¹ñæ›\»ñ½ý¶®^\`qäÚ¦›¡ýmKû!}/Ÿ:ÿho¨CÅ×F ‹G1½ê?ª•‡³¦Í<ÏÇ};dÎwö-åËç³×a>º :íÀ¦D·äE×ö8TÔ9wâC®ö‹ ² Gtw»^Ú« G?±Å‹íä–¡/�‹Ÿc$N ‰ÕØM‡­ÍÐöR#¼Ñl§ÓLTä÷’37ÈóOZsA‹E'ì@1sî9œÕëhºAæÒ"@ö&.$öÛj"/lâ°¢‘0È;¶0ã±Þ|ØsÙM=M,Å«ý)ºÑÍõûl4ʾe®Ü êG³Ð™Öï$:œÁ‰ßz±3TD¡ßèã"ŽÞ^>VüÞÛadœÈü}ðZUçä"ù@‡ÍƒßloYQ”ìÏ:ÐÄX|Ë•¸@_¿·ø²Ê™0ó>Ý)k^ήÐZºÚj?kì¡êKÉè–±ò‡žeæ·WAw:Á*gÒ ï:f;×·<Ü¡i¹_¹ùE~Û··ßdß«Ì—“b*‚ÄÒn8Ýd|žT¦³Uº}]+y·½`O˜-Åóê}2¹b»Þ^6/ûηÝužJ•8…ðp¶gle¢qXÚ¦‹FU«†œ¾ÖTbÞ›¥ç>Àž—-GHÍJ#L þJeµ¬ï]1Sq—bfîÒß‚q¥3Ïë“l,·2Ï÷tZ3÷ƒ_ír[êƒ0^�‚¼€ä>71ö‰.Ñêà5if«D‹ò–]NÉÅ—GÙð͘ÿåöu5¯í‹^NWñáTL­Ó„n¨0Š¼U£pÔX“¼«ÝšhñB½ÑmÊ} [Z>‡^ãÕK›­ú–ÉélÄ÷6¯"¡Nq¸OÉÌ(ÈëŠêÄiGùQ:êš•ê`hëéjÁ¡L¿xA§=ͼ Ó�{€k»Ñ¿›½tŽmÛ{ô»Mö*ËlqË~n›=ÂNñ{ô¥»e0wQ‘¿¯y}Ä8BmÆÒ–‚oN”­Jh'eºFÄìe‰0Á¥“¤ŽT¡}†èu3™ÌqS7§Å²î P…þu)‚{MˆçÌ¿Qÿ¢ØsÊdŸÑi}VÁ>Φ¤ýªðgâ¶4ï2ƾ›Z9«“ê;ÙÕi8™‡Á¾Jxxžé¦¾:<3ƒ¨n [;|+Q,Oà Ð`ãê^£“Å<¦ï‚?ÅjŠ’‰¸T¹ï=£éÜ\½æŒ¬ý”¥’¡ØÍ¡^Sê98MW$†íŽÊQ‘Ìf°¡ù}Ú´»7ûˆ²•7Tø« \,¦€Ýoñì+Ûô;¥«ó/ߟΛÖÈ„D®‘ê4¡„?)Uõ÷ë{³e7½°ÓÂ]Pkß‹,÷DG•µÙc`1ïòµ³ ò@Œ÷—2ÈkÍY ývûŒ©Î8CAùº(,œôUŽ’ùò§ âfÑ°ÇÔG FBz‚±˜Z™“¯ša¦ÑøÜħÈü¾wœ ß:o•o r•Ì=’ÇËxÆ­v°ëÈ4*Ø3<Ú)Þ;b|ÿva‘-syb[ò]j”Žö5E×Ñqÿc±ÀŒuO™õË÷Å”k\S½ JYÒ è´ë\2Ž€÷‚‘ýþ&Ïú‚­Uâ›·°<PH ϶sœ±²Ê_)ÿìÈá5»¼4ô'=èARΚ½d†ùöçÐ]èŒìgÎrÎqÕ^Þ¤‘™Ï—…êPü‹Æ»˜’•–8ÌF÷oÁöB࿘õŒH9âTγ ¨uîŸÒWdcOÑ Ð\=ïkßJ[&4ϵ` ?ÕLåç`(-ÜF;ìÈ`=-ºËÝt(‰AŒÅ`£œ~úµ-B§‰ô L9ô:^÷üZ¨!Ì;÷4Y²6‚À“´b~lÄGiæ¯A62¡»pÝzþÀWÁ:�þA gJ$ì—¡bëE,Õ­{;cÌ¿OU^<…DA¤ªÉÊElÉû6Ð2>Á2ÛÜí ­¬Iίä?2O{€eµ–šölõi»=R5oÝx˜7§ñÀ*�rwòã,‰ññ˜;° ÞMÈЄ´¶ÿ÷-6&Êpïë(AŸ4¿þQG%MVk?B÷êÕY³®4Öð ²o7ÍéJA½ªEÁùo¯<Bé'畨6¿š�ÛZÉ`é«`¸”A5Övæ)jfš€"ðSÑßàR¯[ÄÛb_ÓÛýì*öaÙ�×Htµ¯Ìo‹Ð—P…v4ÌoCÏ©™NWûµo”qPFiz£À¦5r¿€×uêùÆ"îðBkéü#Q=÷,·Ñ ö_/¸8…3òµÂi¨ƒYE—‘UOµlÃ*ó¥_Ñc« :_¯a€€¨]½¡ ã+¢4›ï´¯¢µ�àÔç‹.œÄßV«º`yxÓSÛ¼OÚLL4+[žb»jG‰ýu;†kÛ>tÒ¬²Ì—ÉÄ^èŸhT¾`)àïét½·:ž1Œ,°!A\C!N{Uqé`Ê !žNˆ”?TÒåj§�R2äIë# ”ºõýœ¯\„Jx<[¶:CÚZŇî&>š¿‰Rz€ï2À7ÔkpÜq6§^Aþ˵Ä8ó¦=”)m–<Èf«©Vçppž|Ô“c"îYI;Ä]}}F•wR±Êñ£˜¸Ýª*àò ↢n˜˜žñ×¼µ¯QȈ¸z•Ó§wÕÓŸÚZèN#÷~½«ÇJ†ó¦°jº#Ë% ’³‚”cØ»ïëÁÓñ¡gyfžFèÅwípïh PÀRÍÕ¡µäßKƒ™ØWÃèÔ2^ÜÑÊí­ëñµ;ý9ôÏ`•ÕP>ÂÜ´EJ›®ð(báê´âÄ—ã%çŽÌÉ�…Ü}eåôxoÓÂÄdV,×kÇ×ÏÔ-YTü@ ]î^>¨‚:co ˹9ƒ‘ïÜÞûþK°}•1ï§vQXžƒµ+XWeTÏÛê ù\;Å¿Ê؅άœe_ÍžH<�· —¸íEO+Ée ß”E¾ëi¨<VS#Zë‹({ÜV?Uè[†\ÏÅTÏýµKØ¡±Žø®ƒ`úü/u\’۞л¯"ß[E ØU…U8ìaØÒÖ—žò³`¡dWép–lú“,yÂÇ-™hÜz¢Ú”ÉÌyQmÕ—äu5¾4BÏÀÛØx¥{‹#Þaì1Ûà X©4xnÞúê: ñNhíYË~î››!·•jûwÖcú#Zì. ²±ñH‚ÛÎ5£r3£Hiù\‡îîÏnQ‰]T)7a£ ½–AÜkÌ…dj7¨Ó¼{¹hÿ©¾Õ 'tžôq?à‰¨Ÿ“÷Å9˜AòyUvȈŸé fÒš¹¼Œ Ì�|ñ©©ìÁ™3ÉÁÀmÇúH؃¨(¶çÑøå>uà´Øç(2b†óØõA]þØ^ù_æ>iñ§Ã…[º\þ>BÜ•EæÁ?àuˆT¦p6Ÿ!;@‹k¹öµüs‡CTèX,7#mÈm–×iic&V!ÊõoD6ÓÔ÷Å£04ÓòoÅv@èóbŒñÙîîà'{¹t&ÙØÊ!E<£è¯Å{aüàé”á˜náç$‡’|_Ëz—Èë¼»œpËó1¶Lvñ©þ@çèÍJ¼ÍÿûÅv8Ù‰Gž!¼ Á¼|O J“—2Ÿn(dÞ€pSœ!tÙâi×öâÎÍœòžhISvh&ýuS RDuç-�}럊;!šÞ9]‘È÷8!z¤ÑYk‹#p Ã|pDbë÷‰�˛ݢ^³ÉH=Ê5ËU.Ÿ0wï·®ÃÙn×h'µÒK¡Ç¡·òî‰Eº¤ùÜ<E>>Ö_7d’Cô…r¬y­tðD¿5Žý? aZ²½ú±Üž®à”ºù0 ÿRaÞ^Þ#IåJ˽Ø°<p)퇣«Dþï4bãÊë$çÈ>ú§è4ÍÅþ5÷05¸vñu#eþ¿|ü0DÐq£’2ó+}€K¨¢Í>ýVl÷Â÷7cÞñä~w¼¸ óôÕÛeæÉÞèÔ^6¬J¯ ¶u\{¢žÊ¬UÕªc— 󶘴¶MV ™çþľMB.Ágòæù¾v‚ªX&b£�þ‚0:¾CåÎÜÔœBUb¯ëš¢›5+Jd|iÛãiðJ7;%·¯ÍÐóÕð³,¬Ø¬×b¦(`{^ƒð„ìi¡ Fé"’UôŽv“óªIZE?ÑçR:©ª0fQ0µà¢”mòãJÊó®@†`MAè³j÷×Êi²@²ùE´UŠÄïëïñ"9|M«l¤•oØZ ÿŽ¾±„#çÃH槨%íð©ûb\ÆÍ«—&7­"˜wôõ'Ë­¬²‡5¦ïD»wõ p¥+§£dhªÝ‡Æ!b2uîÌzÀ·îå0É‘Õuú3­PÛû‹*$©eƒ¹éIfÞÔ·½Y›È.Ò#ÜOôÕv*ò˘݉%Ú*•5Gøât“€ƒôÂ㻵XUœg¹}nð’ºAÌÌ]+Ò~wêt3Š4ÑŽ½>Ÿö˜|*é²r»Ó©½Vb+Bãõ/¿wpbëÙš¬êæOB»óâ _8m°I¬Õ1¶·~\D™§ E«t?RàJßgOÊÆÇzy±#èÞö;¿÷?‹8óä¹y‘ŠÎBÔ 1ˆœ~}>ݳÉrf}ÉkÖ™¾VúqˆñôxWè|”„¾,fx¹+—`Âc­áB†4îïËNäý ϘxBKÒDdµì~ÖÒŠM¥†¹¥M²VÉ––$’¥úq¾ÊìGqåp©hÁ)ž$ÏU•|†ìOúïg{/M$’ÔãÀV†ÿPy×:.½=ÆòP(»õE²'4רŒ�*ë²­2£Ò˜…í×sºuF*Õ geË°d;¬¬ßÙqG , ™ÙÙúwO,{¡;2JVœås`¡© 8 frdò`þ,°Ã ’›·,³zWÜ#/V2)¹tBWb!͹§-zjäà[+ôqO4=@5ûMÏPÁ)wJæs,{dÒ·(iép,׉÷³/+oð2óyÌlte(]¤%êÁH‡äØ¡Ùyš¸•ÁŸ~óêk%‚Î=îqv}èýiè® VQPt¤®*/å]ÿ¨übi}JÙXg¥¸iAûÇ©ŒëDÏWy[>‚Ë^ì„2ˆ·O³Ì ÎQÞêPù÷ò;¶rÏ\û†bG1Ž®Œ£ˆÑPæà&R,{ýFa¸§ü“¼UìÛL‰Öâµ ¢^I|õ€<×Ü8ìí¹³ŒÎÃÖ‹EšÇj„UT~ZÁñXTÁû`KwI$Šž¬Ÿ8 }ÿYZþ-þNsEË‘»ì)õA!To¸Êð²ß»Žª{Êù†»È±ªÈ<&�Q8ŸÄj7²¸ Nóm=Å·“3ƒ™‹ÆHDÊtÞ¶,jz:Í”–Á¹é™GÞh:1©¸8k+"a+=o1›úÎ*Ž¢Èõ˜+Ë ?µ«Šs ßu9‡šRƒ• ‚÷¯g‰ ¥^; ÷[Å:e˜îˆ±°É¼¼nˆžUÏyrB!ºÌІ{´ûò邯¶—mDÀåÝ 6ZòpM5‰5»XßM½¥ùÊ?˜Î½#eù»Ê‚–èOs#öÞË6lIáG\ød, ·*Ó+Jê<q™­ƒÉžç—ôžþÜN\½K(Õ"Ù¾ÍÁ¢Ì4éN}{n‹ Ë…eÈÍ8­%–äëZÕ|<—¯<fÆåŠ8離È$ 7×xÓЀÑ­B｟=RíMBßKT4†NÙcfã�¦Aš#ä1xê>’ªpƒ!1Wjš"¨šw=n›"›®Ï®žUM•ž¸"&гCjwêŒ# Ù¬%|v.%Ç®’¿vòÇHØisæºÖŒy] jþh:ŸeëOiÜ\ѧÆŽE ÆÇÄà¯êÅúéJb0ÉË@ÿTÜÆ·‰%›ÊUõÂלŽVþ›å\V™7w¦Db”újÏÀÆt»ù$d;ÀѬ ,Äô5ö&H2™¦p]b1p3l@8…ççF—+í ³½Aˆ>ߨgž|9å¾Ò ê”çP‡4‰ _¨§GvŸ±B¬ SvÐ<Û+»8]J<¤ª [X/ æÏ)MÆ}L´9«�÷zÂ#¢Ô“Aö›!ï<v=g؞盌<Ž¤¢À(jW¿ØóÞh²Š£§–}ÇKΙĈ%p�èZw£Õß“s‘›æhå_"ô=xŠ#:DÇî±iª»ôFή‘»úú…ñ‡åcРroÞù>š¥å#°z Ut K Ã)JÄà¦Ó˜G-:+[s²;×ö?Yê-ú~ï#¯‘7é"ZÚ(ÅË‚§®vNQÙÒÕÀÄCñÓ|"wáXé€D»aûîÝ.ù#dú®÷ tS;Óf ^ªíorEîÀñLÏÞJ‚¬Ù%–(ýß^Ö<_‘“…mgþô Ì]ßEÔç)ãä0²eZë‹_οH+Ï”'ö(© uG% ï€ÂsŽù…yUQ¬`Ùì-B¡¥ÞzPÙPÂÙÿA†ÜÍr3DYæ2/ƒ£UFÁ âÈ ¬júæúf@Ñ¿±;Ì2?5†ÉeŠ~ôXvp/A–á±íýŽÆC)¥Ô†uCšbÈÍ×Ù4Óyèz¹%P6qæ)½fL5èlX* ¸å?à=êÉ—ÞøÉÃDŸÚ²|G÷Ó Dþ[Túk¥V`Œf ÷hQ–yœR´wx²3x r³Ígÿz´Ãµ‰' a¡§]<¿PÈß‹ZÌÿÍZ¼ŠZôÐvIÏžj:«ÈÈô»­)x$U†\½ ‘F>†×'zNÉ¢¶F%³4¦‰îÿQ·Š’$qb;´ ¨®®f¿;É8p( f¦¶Ö€fiö1JÌnåÐÒ8öòÊ|‡.²¡ñ¬cé#¥ojE³^Åʼ‚Ÿ1L?5>GOâuY﹕;£ö|²Æ$+»»Šv¢aë“:šh¹GËÙP: ³º¶†t5…´d.è‹ö(‹ÖÛ4Oüé ÖÄAÖ4Al†+Œž–_á¶cŸdÌXË hÌñ^‰xKÚÓse N ´Ð~ð™,÷¥übOh6«RŒÅ¦Æ3„\ÝÕó¸\?º—X#ÅÚj$Ú+ªð¯Î³Z l5ºLáã�àŒÍ¹®S§Ãûo¼m+úâô00&¤uFYør®¿KëÏÌ]ͼå8ó¤Bx0ìª µM>�à([&EŒQ™…àb°º€øíTHY¬î¼Q–-¡†Uñicöö­näj'+eœ•†>-â• ICF—êõûö7.½V‚qõ¤³7\TW\§²4)¤–»K7y^étÃ8lJ>Ê©›û™þäƶ²J}­<Œ§à‡vÏÏóØõ’>; ÙIë&Yܾ—íûœî˜•Î{OÂaC¿8™ šÐ³ÔPïLM2OòX%„ÔÌ©ûÖã@köߊ(¯ƒÿÞ5öA¦9NK/é|ÌËrhá0r ‹ŽÂª™ém3n¹î)›é<'* Š%Œâ³Wm(‚sŠo6þ? ¥IáOHiµt^}jÑ'ªbì« ºæ/è"w»¿Y–­ÝǹǟYÓ©ˆUÓöpuuh—ßè) ^;ߎÅz®˜¶žOõ 8pïd_pŸ‹ÊÒ‹¤wË‚eé²(¸Ö w›zøx]­,ROs&@™d:š•ÌcåmñÒ¡*áð—j"}¥õ‹™¼_9[ge €” ýÑY][ååîBÒbsùd|/VrD #fò÷Îä8ÉÍ:”ò$ŽtwwÒÂG›©kå¤×Ûë5g½Ë»­Û8T,\iT3ؼ¦¸þuäuJOÁôֹ澃M…>þVßdzçžÜ”mß' =q.æ¢ÏÚäÐTü¯ÿð¾Â‰…LÀÀe¦G_öµ×o™§>QÌàÓãÇKŸT.F|‰A7ï;#žõ ö×"£™ô�ÔÖôôãagéÇapgânLîìë#Y2µFÑ ßœhô¸{©ª¼ >õ–2}÷Ò*]%¹UÅIX&*xùøiv.EÎÓ¥ÑK¡qÞªà=PÃ+nÕ~¾¡þo™4JÞþCÿšOkÉDÐmǪÙ‡Ö‘Cø‹ 5 k4”Š±·j$ ¡1K¹âðq¥£ðy'ú8z±úòÂåÝ@fÐqb;BGu™è;Ü˸cPS‡wk㶇´¡òbüÕ÷žo@QµÅš³�#hY²çQ“sf]éwdŽ.�Txepcê5Gæ~å(ª‚Ö,Ïu[üRm¦Eè;7À‡“öi[kk?ûV€þÆbäæ-‹²ec5îHЧ´(¸>SîwÕõTØ ¬îëÿâRdq¶RtÚléWgõÖa9·[J-ЃŸµ‘8´w.¼š=3h»š;ggÂüft>¨[]êNjÌïÚ,¥§‰*ÐJ›^µs.Ô�«ò…HMï´æ�ôÚòØ´i*¦~Bú+9k̓“îðêÌÙÆQ¡ìå3a:çvšQ?�y·žÚ +NpDÞš3úgÃë% ¥÷<Gà¿;p/}Ò"¢×X»˜åŸzôÝ^8y@/mðâeP½+¾+_ï’nzb²/]V¸Êº@àõ¤ŸV ‡b5$²j6àŠ&\Œ¸&|Ìã`Ä¥š]Z²ý_Ïl©¡e{5ý?SrqÕ$Æ,fñ¨{â >Ù û:Ï‚JÄÎM™ü²/5rZÍKZÓF'Žõ¼0éáX®Åß‹b—ùJÞŽ©Z9–ÙƒAPD,¸ÎdƒÿËTnP—2/Çñ¾O1 ±˜’Ž§³WQ€1Ss&z˜¦ú¶jNR ›Uqª‡‚¢þrŒŠÍ´Lw­ÕF¼©‹?/ý®*Àgh£óäš,cw¤8ö¡ÅÖÝ!ðî¥Ì4¤Åq' “?üÀ÷ HM cØ¡1mE9y J¥ý¥aX®5öŒ<;,¡ùüç@¿Y&v½Ü#ÑøÀttŒ'ºƒ½ªf¹¨ì™€jKcKðþ½ % 7nÄødÑy,T5g­ÄI¦ÑJ®`‹/ZAQ£sbˆQÅÕž,ƒ¹qÓánbÇ®[\¹l úª îoò웺¨°åúÅ—\Ê|™ ÏéÓ( &ÿÿpúäA¦ÙÕLBnæ$ Ê]«bzàè4æ7¡1HÊñ¶;lM£ñ_šÿIf>à!’±¦ëP®Þž&E­ïŸ&˜7°fx•Á÷¸¯=J V½çø£ýqቅMØ”r†ÁU”›úyV×PûUÒVE®«™q#ù!]ÅKcËrf­N«O‹•Ô?³£`›¥@ Yò¶jðì0=¥�E«dþ5ìo¢µáJ!„.Bú–·¹�°Ì`ê„ €ç}êÇ™™FR2”ÖÚ^lÈ6!Èg¬ }gÞ žŸIsü-–ÝbT†e—å4Ø œßKcv³¸áÙ£Ml%Ó$=+( ,‚ÂzbŠ8ÌÔ›½g—ŠØ§`«‚¿`ËP1v·R:¹oA0�e»¸Ì˜Jz¦¾ë]Ï2ZK݃<è_H ßžÿÄy¶píùDÁ¸œ¯^)Çàã‰ÏÅÔFžu ~Kì'Šƒz#ALmF_¯uœ×È*±U†PÆñîœAh|lvG­Ñ?~ÂUË"`lX*føñížÔBjoº¢ÚåóÓ;~uKg¨×Âwå”\[Ä{Å®…’™¹ø±BÏSC!°"$åH”ô(½¾‚ùô|Ã}íОt?fG}¢’ŸxX˜sM«4®cV\» —kÛªÿÞ›ðÃDea¤º¡ Bk”þ4ß<§VQ ÚÎÃbÝÅØÃì™÷¹ÏÙ g—­â°b¾ àüÕ±Ÿ%[ÏÜ;Þ¹VŠÀ:Ä”RÆ•VКYß“�aÑaÚÓ¤Ÿ~-÷s]—g.cÇM¢Ú% ²]­Vì~§YÄá ¦Œqp% Çz0‚DËF.ØÚÓwÅ+ì(•†ieäV7d0lA)Ên}}Qã®ÐÝ+=…„ì¢SàMdúœ8F:eTBŠæú&š¯†o×óf™^´Ö Ûó"'¶C¡>_®Á“º·XËǬŠ¾Û±X-K+šgÍçW~ɪé<‡AÕÎf~SFbY¶œÄe˜òëHÑH‰gVŸo×S*Úü;Z5¿ditÏñ;¦† èæ´Ð:B¾ö= Ì2ŸGiùt„,_¯@À3ø8äÉðe~ÉÏ ×QGåekËÆPJxÌÓ¬dúÿ§<KVËŠeY¬¶M›ŒsŽÙJSÙÝà¯wûAžÓ‰¡°Üòij}ìŒË‰¹ä ;ù¥œÊôÆ‘iQ,€ec뺭Mgm^™*$žìÓ¦è-˜Édd¬¬.³[hsͳê!ÀDIŽbÿúáÈ]µŒùQjnЧÆ0Çó•_¾/YxË[®é†¼« ÐõtôŒ…íïê~Ǧm7näß|É­i¨Ú`¡Äº‚Gëqj­ ü¯L}ã$uÉ«Ð÷É‚x°&ðë}·æúŸ¶ûO_ÿç/màýŸüBñ'I]p‰Är ¹™uÄÀöV!¹ÚùL:o>´¥{o¬è$> ³´æ‚NŸa´•,J #rÉšNWq¡¢R¤½ÍÅõ%ôVŒe¬’®€&‰u Ï9ÁŸ¢¯3·*úÂ#=§WŠ-åÚO�ƒ €oÓQ bLkM#Êqâ$àЮӟº7ŠÞwÔ}8wJKep¤Ã4”:Ÿ?²R×΢ @ö×k¬™¼ZÑ Ú‚GÛè|/‹ (<Ð=~yâŸ~—”"gßÓwOgµtdç©èŒ7)ïþ4¿AÍÆé§þrDÛ9§ù—A+ã¤0h¯YvÚ¸*oL^FÊ;‡nA¬9i†Gý Š[kÑù¼i]=?B*§Pn³«ùâé*N=ù¼„cÄ}<<¢­Ö/Áö:›:´²6ø×Üà…³ÐW5�€±¦=cu8Àœ¤Ýd´¯ÜrÆI*K÷(š•^ Ïf"3Vjõgc¶ƒs>|I8)ò …Uý~s„Ûý~òˆžµñaÏbôò ]uØÔ×ïéš/ÄÄm·cTEoé}˜~ôgÞ¹†—zŠð*!ŠWãtúŽÇ”‚ÇôiÆNÉ7]N{4i?‰1%÷q•ßÉÃp@ç´Ö¼¨Ám}˜¶µi#©šò¿«*§¥'yÊNlŠ|r¢ ¦nO;È ,” flˆy ŸìJ=€ß³m½3\:G{•þ¿:0˜9T¨†ú'Àw—Ì{£órn³ã(d oüøæ_¹]&¾¨wbà+´mj¯Çqˆ�‚rÌÐƱžc 4™Ó6DÒœ¹0VyÍ´AÎUíø xh… Bq�‹DFáìGFSì;¨ãWÓå¬Z](ý×Xo p¶pÃçÖ%¸Wëíß. ¢Æ¢1Sÿ©6RL”änÁÏ …"/RàDkv×A¾­5 Áã…£,&öt¨VÕÓ‚)ñ¤m dOó—ý ^„ó@:Û¼“-eµh8Ay&é&î~žCñ8a1˜_1× aRãÛ&6{ úE•>¥ú.µ:Oüb� ò%c#hÇ<À9+>�FßD÷콫ÿ0ç?hÈ|kY§×,_H ¹o[Õ}÷E+tª-„~>|½¡É<5З|Š\!IÔ õùmwáIøê'5j¤ŸvYÔ )qì‰rº¤OíÏ–SN«Yû]ÓŽEg¬1§ëF5s=ƒ¦G׌› UÎoZz.T³q=n ·‡áí0 žˆ–µyü＋#ƒ+êOl˜Ä€9üõàï0j-ìI¨Þ&¹¾°¥ ;ÜD¢fÈ�gôVç"e›@:ØŽÎÒæE°°•rv…Š>zïz_ïõ|„d¦:åü Ž~ëßGG€Á¶%…¡åiþ€º®qà;�uYŠHV¢F8aº1d  Û)1FK}ô€Í÷™ø:ȳNÓCGû6¬ýïXoêÍÁí*„Å+€“+%>ùoñ5s/àU ŸÇ¢ülÜìm„!Ð2ßêœ=STÏKÄE6vgöEVI5໦Zg¦iIÑzй©ü¥VVÃ\Ul1Æj˜DBovô³™×q–jšOq•2pJSTÐb °5 »qìîöT«U”°êJþóéì1Ü?º«íóÑf�ëÔ²f®yŒ÷/}ϱØ0—Oýõ“ë$NïQW{Á¾vÆÊàgÝKº)Yj"Uκ„»2Èßu¶Ã3sðwHmôã(%›ÀçÑÚßØ ¯9ùß(úIâ D¸ÛÖSî~uFŸc*÷ñlŽcÓ¦átá¾Â**=›v´ÌPN•4xG {YV†Â3}¬$òË”å¼ðs(úög4"+²†ÞÏ Ý ëÙ(;‘_þ…£ŸD*æÊ MèSŽiP4ÕÔ6ä™cN%ó¬Õ¨u®ûƒ\Ýï:<¨ ¢«àÀRcÓâLÿ¸K¼Ç(z™Ñ¢Z¤œ¯§Ö’Ò¦O7º†¬‘Û÷`ßÒÁwô¤ªºñ,°RÖxH-ôšÃnG¿êRÓÃF$^®Ü¸¯D™oËЭKDiòÜ�§ämœ{ÍÅzš«°j?³xëEK5,àýé"ÏÞP»÷h‘ÒaßõGHqpš1_¹›]—ƒªI×é4î=ßÙtf͉c¡<‹¸y8«ï¦VÚááû§?ÿá¨aÑâ,4µ†œzóvêô‰GÔ'+7m>±CZí5¡Ô3t¢s¦^ÌH_6dÇö)<”R¬ñ?)[D¡ÏfGûbïåòei(Š¶7ˆJuáctÀõõ«’<Eì€Ú�q1A2ýš^pýõ»Ðà‡ÔHë<™Ñãf›#YÝzÚ6”hèÙiòe_s#–6;F Š†ØÑ/9M0“ºÿSLxr×gb­×eHJVV6M[‡*5E»bËkú6ÑÿhK/ÉÇŒ‘nåçh‡H hƒ6‰~¹­ðnN2¾R©ºOø*·£+Nк1>‘¬Œ¸åŠêÐ÷Æ<uÁ„§xH›">Ö­3Ša¾^:Û³x%s*½ý˜Ñ»<ÈÇÁ“6]}îÝùÁ¢yŒî÷lŽÑpaûsª=›Î“Wû3wNœdß4≠>Ö]¬¶ó8H pØ…²œ=÷É&.ú>œ‘v×ÓöÔË­ñÿ0¦¤ÇÊõÑç Æ�Z^'®8ƒ†qMgHxŽ§ö ßl-À·×¾íÖe¸u"1ò”©1më”�YJm_Æq‘#ÂX|¾&ǼÝã«dŸŽb4—sq–*—g§Cìè lµqüˆ0qÐãÅö;g\üýGä¨ óR[˜·?{çÑtÄ–$mD½&vúR—C3w×_Q±¥E÷|˜X‚Ѫ”Âô>lö5”Ú­ú³sMÅœÉb5°»�_E·ÒRB‡/O¹9Êá ó‘ŸQŠ I r ­¼ýähŒZ*ºó:´R1øÇö—w0­daTÍüÍQtS=XØx „Í|ycXã[o›ÈqhúÔ3·T/检çÁ„±¦Èß–¿µEÒ½hí•äŒõ\À³L(æ T/™ÿb¦`ÑVk6Pn½o-œ±ÂxɈjþ« Ø-^|`¥Ž Ì“wå0‰íÎ}±1"{OAáDc7LŒ¢XÆîŒB«¶¦ên UÊ 4z/E•ðnîÚµ?MjS÷tø™”•û LOŽNÀÊzÄÅÙ1¬=¾éH9}0„aUÞ[íKËonZzÌé§']/ ;ãH±;Øqw 2Ÿ}·ùس%üª…sN×;1_Ê ~×þ4}•ƒO TËÄ2t¸ÑÝüE¾fý#R‘Ö ];°D‹Cüf“»Á˜xÜ»\.NÚ.4¹ Äëã«–¸›Ã0P*7¨N(å¹ÂIƒoÒ¾n•�ûŠLnQú¾¹Øæ'Ú‡é8¸vÄ!t6鸸³iÔ½«UK'ô:Q,ŸÚô¡KiŽ”Õê¹d2PžŸÕ²«øÓ{©ù°7”}g^mÙÔœXºîÁ·aŽ×s™ý8ôeáè‹·}ä{aUFõÁšþz$É/‘úɈUó µêc5xÙµŠ¸§¿ã�<{ñØ×êV'âÆ;í˜æA¸ß©–=XÈõ¡‰Ì|<Ã"o` OÜh­‡}e ž—Ußû»š+fšýLgh0ðÈ~×qG­ °eÊüM§"6`›HÓÀŸœïU"×ncc–‰ë"<AVŽá±ÝeKÁgjÈ rƒ*WÁî¨Ñ—Ö~·¥…´<cIFYj;w‚Ú\€ÌÛæcð”dV 'fi0ÎD¼ËïŠ7¾$?SðÑ ŽËÉ"uJ#X BÈOø»C³tè|Qß×W¦÷”jÇÖy%«=C™ÐÀ—C¡mÉ-Ø$L Ò‚íÈI°¸ä‰0Ó¹êO ¦Óq–‰÷7œ8Ñì 19;Nƒê}ïqEù¯çÏ×,~:æþ0ÚWüQ†6ð½DóLf2\›$ ò³™%/@f_uµ#^?Ð2¶tÅ(«ƒ�DÈãá¾éöOâÙ?ðC4ÚO;wšâ€vÞÌ/ª?Á)SJFÆŽfqvšúÆà§á°r“¤×¼,ZiŽVÀ÷¤Aüµu4 ®ŽØR–AÛÍ:0øè–EjSwuOé([Uz8Úáqnæ�Lñ‹‡£9÷±ŽBoOùÂã—*†Ë]ÄO‚“ÁT› ƒ¶¤äôÅ· ãg™¬Â‘›ÒÈxè­&�àP¶ L!­~ÆB™y´V ”ëü²5A°ZQÌQ¥¦šL0ÛF2úêcHãÜ®zÆŸ4EÂèv3 ‡xí ”W²?Õè8š?Fíô¿é[³¢nðlÛÅqæÕˆ€XüɃÊiÿ§ÑJÞ…U¡yÒðÔ‰£. ®`‰Òº!³”ãé0�–Ù)~rCó97¥=†‡ŠÂ|¡8À÷Óº1%eæ…|ÊìcH±ž²–±På<S‚§ŽoˆyÏüeÝ\·JoTÕ—-¸PZ-ˆyЉ1ä ÑŠTyÄ¥ëÕGèã0è‹—Û3 �Çöf ƒbÞ{š‹hÆ!ã0O=({Q„yæwßsãÙþ¾7» ›`xU³Ý›¿äÛîH7…!¢î`£T´ŠÂú8ô¶8ó<),êùÄœ_ÁNtbì@‘êüÄ)Þ‰ `œ¾è‰:"l¹8òL%¤ê8h´Uæw*#¨¶dAÑÛù#æõ…g܆SÀúŸºxV’<Šköò™åÞK¬e„±=OÝ@ ‘¤nQC¶[–†Z}¤œØacÌþ”Ψ…øŸÒó"ô¹É‰w”Ÿ§µr) !qH×MEç6¦?ëÀ–îòaÆfߟœJa Â\Ó½Ýo­ê ãàzÊ8Ðú7oÍ yÔóúpy’y¶ô'Œ'º7Ñ»o¶b¤ÝŒäµí`øyr…fèÍ;ƒØYÙ<mZ�¾ÿÔmpOF÷ƒÒ\Fo?žƒÚz«2²ûËBå6+@ûwÇ‚Ï…Îù(Å]qì¨tO/(š§_;-Ö©˜e Ù‚rŽ&Æð‡6ÅÑÉ0ÞG_<"×Ú…<…¼}ø»ç¾WcÏ0y“œ¨ÈúHâBrÂ!ÅÀ�b—ò× ^LÓÕÚFÒ8±rÒ—k-7çáÃV=`TrîôvÚ3­–CÝ+8@[,þ²Êþ'w: ²�›†VQÙU—o¾l¶X÷ÊvHÅ¿Q}{éý4r Òw£§=³ìgëirs²j’§Øï)rClæÿü;ïgëáÍ´2z^c±åECoaͤkNgfV[Ö{}1[ä š° š¼ " _B[¯&ÂËáÏ{<”º˜ý ÇÛ'_”·}çÍB•G6ë“Ï ³k£™`O‰„ï—Á1ù¡å„;¹i±Ê£ eð ¸"BÆe“ ¯KhFjô`\}Ð;¼®S}Ú±à'%1:šÌƒËUÃÐãí☦tµªOP– ”‚Òß<w›ÓÚ-’}GŒn„™Xsà{¶QÅ’%P•Ë�{¾R=àÁÃ¥Õhr·Kþ}Ò*)K÷Gp_ÅlPÊm,T¶|U“~·T|b®ès=ÐL¢¿›F6«â p†&’ÂöìtM¿cÓ_*ü5druä³êÁ¼)}ç5ÀØYœAÞ…éMGT-Å+ˆœ²Ê%¶v¤—p¸…'Mü¥í÷†™w}0lÄ)z>"L8¸”Ôd—™¢Ø{íÙ¡ïOÂ)^Ê°IÔF¿¿~+#´. ü§í0Y”ËÇ(t^pkƒÑ+ÿ¢ÍZæ™7ùÄmJ(=ü²cr¬½Î)YÜÛ–÷‘R±mj°ºB̢ȹG5 ÓêÔ¢ÓÕаžÎõÉø-‹Š4MíáDËéRÉ XjÊ5¾·nq^_×£²—�8•kTáþr™¢Öªª—3¥‹8KߌㅭnD¾7¬¬¬©ÀfæGv¶ eˆB ï›ÿ+ö‡mÛ‘<ŠÇ0ÎûHXAié¬Ï£|JW�pÞí}¥@-ïLÓã8ò‡!™Ó,ȶZ!@ H 2ÉRøÐð&¹M[RŽª4M;ªÄ�§·L*”¶Wr‚¯iAd¾‡-¯a‚ æÎ x¸ÛtC×6~UóïU±h±·Š8Dôˆ'%´ÂÔõÍó•R,÷ݲã4cVÞ&TçÌô$Ëw%hIí3Ó¹Åeùë4>÷È2ߣ„0ØH—ÖMÇt~ÑÒ»sÞ=2’.Cßè D½v “ÐS9@SA˜}2„Ã×6 h™â§åf’ÎJ£4�ïî :^ûÁ¤œÚž'&~½1ü¢Ê¤=Ö ½¥Ü¥îŒ߮Ǩªé­˜™ÏYUg©{ª?T3ðÞå÷ºOPŸ*;DÍ.fÚ™ìÅ=ç{ñ)áÑ«WC‰ÄœÑ©* ²÷× …ãgÐqîÎzÞÇ(ÐÑâlé1ʺk-˜V½ã`¾‚sd¿õ@ÉWÚüý:îƬµL¡vY§ôx<€ëÃ*BLеÁýÞ;lÈÄÇŸâX¥Ú½² ù$i€O晴;b標ÁïFlnßp^@qŠÛ.Õ§CA†AèÚZMû.?ô_œf– ̨fª¦sí×q’@S½ø6œJ¬zDlÚ3ú½ƒ2Í2Åâa¨6B˜ñd‡îÒÈä wgJ;)Öí\¶ô÷#O½bÖöb›DÅ¿»âõa¯/‰œ±ªHT%N ¨8þk+…kü+}%$Ø…s;ì8"}9 Óe{îï#Þ¢Ì7Ѥ/ÐÓŽªá€‰S_Ù‡ú›ŠÆ‡Fg‚Ov~wF Ó©9 Øï8²O貑rñŒXÓvX k+w©éÆokœ–H®æ¥Ð¦ 54zeå­Þø*æ‰ ´ÓAü«óäï6=Õ’aóPÅ€Æí+ǦÓçæ-Èœ7äaWùþâuŒpUÒ;rÞ|xùðÍÛn172§½Õ}\©dÒ_°Yò ÿk!9<ËBŒë^> 5HÇ4uwuÇʼ*×ï|Gu]>[Z!¨ðý¹ŽÎ:,þVðÈ5M èXj cÓd¡',7íí‡$᤯­%ýŸœ™¿a^ ÅÌweÊW`ô‚*Ô˜3o#ˆUÔ‡™­VM6O6¸D}R¨ºm%ÖÌÀn§ÿ?Öþ$»u$ÙFÛˆQ¨õþNF.ÔE ÀBA �ų¾ùãÙ6ssw°¥¼÷®!EEîæVì‚ ‘óÅô;Y6[T]L®Dñ´©gu¢ûÂ=`óV0g7¥*¹Ò£†s=W­ ãÎF6¯K6 ³„¨§öæñlÏ™¬”³q£ò'LeSüˆ§dýÃM ŒBÊà]¯”ëq¸{ëúÝß>%ÕcŽÎQÕ^t,í–r°C š ­¥i"#32SUpykÆ‹CöýùÒ®”‚nI·ƒœÃжõÛê_tT›÷~´$â‰ëL‡òðýäåSÍe´` ´„ù4¼GÇÙXXëF'µ6p(Dá@4eg­Õ¸ä|²àº=Û£Oÿ“WV¤jÿ†ö¢¤Ý• 0VÕ›ïï|¢ýȺ^Ï<À“Üͺ8uF¨ÁÛü°4Œªƒqy«Këõ9îÔ›ø1qžSĤV9Dfͧz|ž"ZvkÓÛt_eM&øãDÉ/£qñõPë‚â[ä¸!$kÁªx?:bc¸¡( !ãÕví7‹"\Dµ ÅÐòÑëg .{e 4»‘ö8/4ïòžVq”Ûù ËŠÛ¯‚ÍB›Æ£ª1­Z+[¾í4ã Dò±c0zÚ‰ëíeXaôáAA8{B+ìAz`¡ÇŸ~~EàFJ?:v”ì¤çw ËaÒ(îÀÐYq²�\Þ_†añÙ”"™rµô"Õ…|™Ó‘bA½u C–Ũ„3Ü´Ö0ÂC‘cnÙ]Bq¢m¡)@‡mOKñsí!Þx¦ØZEIõ_¾ÜÊÈǾ®¼¶ÐÛºhy ý†J¸B‚ q‘=ìr$±+³„¢›±5f¦ÀÈ'³7_|ÕŒÝÓ¹‰¸ÆZýÉ‚b=ÛJ:–[c3mæRê‡d/®[•Vä´2b=|¥ÊZWb²ýÑH~Hc rp¨?pXS¶)nÅæUMGåy1Dñ<Ìtäq›1:ct¼±”›…Š/0…:3™¹q£*ÜÆÉÅ`’r+×Áüî8õÑèìÎ'Õ½=³´ÀwßëÜÒõN€£E,aøëMXûú ûàOµŠ,óJBß{ú3¢÷^ÅBÀÞªÛ‰M‰ì‚ÕÈòÅŠ§ŽuÊPøªŠ®ï™2@Àj�mN;‹“ò¯Ç®¥BýMìLpÿ‡¾R÷CAïèè©È¢X¦¿–qý#¿?KNÌŒq1ÿŸ|Ý¡·Ue]ï:Ë>1™­²ÌוKƒ>©‚¬9ÈebäÔ§î¢|-Up÷0岡¼¹ÂÒ$Zg QnæÕçuDsïÆr ¸Ô6úkpÑÊc~Øí–rÓþ¯£ys6ħÅÞY<¬‡âú[ó®(2/䆢öZmí¤2F>Jw–áC¿-~l7‡S _@?¼² ÖXŒË�kóK^QOÂÂo3SXd¬ØO枇ŒÈì,í@&/ô çÝžd^ƒª¥¾ßFytr¾T÷»b6Q=8pŽ¢)úHÇ #8§²«ôZç:ϼ¶B(ÝáâhÑ*û§ì&Û³Ðΰ¾65Å Íç{Š*˜# ™'ìÜíà)›F‹Çæ8ß«NÆ™ÐK£q,ý3+Æs5¾åÌpø®g–Ú¹Ai0KÝW¤¡žðŠŸÙ)éÌøÁßöƒ³Ü}áÁ*¡–×—°²wÏrv–þÓ¤ïw/ˆ%[ÁJqÝŽá5BéÄ»/~ƒNêô¦ÊúKƒ‘»V#ÑR½ 6©t±\ƒ‰ö7ó%…~%‘ŽòZ +â$q»´_B«fœ¬‰èB‹úù/ ç‰õÝ¢prøBÙ¾Q8ÎÒŽ[4qùptî»Ë"ú§ˆ¼qRÊba«xòmí&ŠÒ2 Ew:à¿bóNÌHTÀ)›Š~ð LõEË™©WÆqú×F©e@ „3V %Õ£âm…Z#“ë{ÙFÛºme.ÑõI¥¿SÙpO^zèqÑoiU¦ûZ(a‰¼×­wœ×0æÂ\ µüsí©³0;Ë×+û¦ÂI²Ø¸jk`ØPêQŒ½vib©U·€XŽ‡óÄ2ó7EË”&yÖßÛ•Ê›…g¬›…@›a=0_½ÅÈïY{½ôÖ'ÉtHO»1¬’ˆS5îþ|#‡5uQºlPˆ¶ð­Žeâ ¶ 0ü}Þ¸QÌ1qǹØT˜){  „»|°®Ò2Î< *?û˜ÄÆʈÒò}?õ;Tïþ\Ì¡è®Ì©HÏÁã-õî©Š½Ð:çVJXÃ%9Ú*ãséù•ßÀOÛiC'xøyö8Ó´`ºA¥rÏ;ÊL(ƒrR-<ÝÅ %ÍÌmÉŒfäê=øÐjc•(Š/a†Ó ³Ó› ^¸M×*YgaŒ:Éè`‡¬ÔCÇ{ö®šbYj(†ÅÓß´?Øà5mÐ$÷3 ˆ©ýto´2FÌ뉪ýn}¥Éu÷Ò®[¯ Ÿ1­kCuMÔ:K|ë"�ÐÅ|ýN &É<÷\ÞŠ]N§Hï—«(³d¤¸Øà´îΙrOýŽ; Ã&ÂÆê”åR©×½£ÑÝ¿¯r†£¼L37G€é¶ ²‹åò&·}e3= ìq‚Öî �YÊTOŒ&X~çÅ+6'åÑ] áÖÁâô‹Œë@Á¶ŽUwSkûz}8X…Eñúá%¾¥�éggŽ¾(–t¦¬?²*sÜ÷¡ñ½BXm!šæòњǹ3o²ZþrîÜ=~¬¯gbøzÍ@¹ÿ¤Üœ%2{ÆâXüë("öB —¬Ózó“¥ h¡ö‚ªÚ:òðüÌÚ íë [˜¸ñäÔñ>ó>wäY—ë­˜Gºçy­èžiþï½é§aS£µÀÀ´ Ln$.ÓóýKnw_öZ•žMª^‰½IÕvªBlÚ_øcMÓñ±¿‰KyCÆYí±6ӊ綽´F¢uUħ¸8sÀ^é¶LSÁÝJOc¬[¯‡ÖPDf#@3¹`bŽc‡:g`DZˆ¨Ð§û¼.4­„Ó¾,!óñ°7sy}¢â%ž²Ê†‰“†&Ha‰´‰YÞ±ÿÊõ9¢Ø.Š°p|ºã:6äž+BF+úªqéÑ÷È B½*ðųÏѬ 4\è¤æOùâqR-œvsZøÊg¯¤CÏž§vjì%6›7ÄTçê'ž1 v VOÖÅŠõoùø´æ·±ûü8Ö¨Åp5!)É%(v‡‚«3­'_~F"èDeGJC,Å—Á‚WßyŠˆFr½�›ƒÎ £b†PÓ±™=(§Þµ’gÞ»RçËraÕSp4¯Ýð%4’‹Ú¥ „ÒO›£QgáÂêöc¦/ѤÄÌ”e*:›{wG 0ò•ÃiÇ¥£ew$J‡ë+¨­Nô€Ó¯¿N6 †nÑö8yL-ÊÿN§#}Ü}mñšµµÓ Y¸hþ¡¬(þj<̱„o)ø<ÕìáPïMÉ5ëëoMšwîY¨¢Œ,¡;Ã2KGÛù e2¹ÝÇŸI,E*Xau‡.§¸°ù4ÕJf\ …óGí;o¿•u(ã‚—$ô,¬é9ÏB»ó€…ƒþ£ƒnàq×N«€ÙR@×ÀÙ<ö ÚPÅè·$kí¯#›v#•Š,:,íø(QŸ»Iæíújv@’ƒŸgE–覌{àéf;èÀY‚潶®‘i3 ›úaÜ/I/Tºˆ ËÓ๙òÍdXƒ9¥~èhýó¬â@¢ ÜéÙ³íóFg¦åµ­båNƒOHEð4·öI¬2ŸË Ôe3¢»v‹úÆÀ|¿sÊ øÈrT>0ZÇÔ­p©T›‘ÒÓËà؇>Ö\:&®é+X‡úÃŽüI¸ÕŠ‚ƒé×BUì¨o8×Xrª6ü|V_,ê x-ÎI­G;h»ßù[F”7¾é HÌÀ$½ºÒ¦ì ·›çN%Ñ ájµ¾2,gº-a£*wº¸)óØ`:R¼ÛO2†Ž;éî ÿUT:ùRcÝ@ùY§-)1Ô};Ö§~rcYõIyê—b+ü(4©Zì̓370ëRïMÿW"Û,¬\”¦]%C²í‰bth ù8>ôÀ’ ÂH‚ïŽúIË,õK6ªœ=¬êSwn•XdÄ…ÌÅç O8ŠåüW‡‚2-­5·‡£'ع1•Ç_óÆû! G&Ù›Ç!¾a°çiæ ãR¤BKÏØ{F¦Ü«bíTIN1È¡`…6ˆnßë¯ÇV_@çXÒôGUý»×Æ@¡ê"aa_k*’¯Tžã$ö©P`Ná`KZåˆT™JaØý@¸×AÐåBÑ„>j;§Üù´Äègú¹»Dçæ‚ïÉÑaæÂZ©Ûcd[+ØÍš#œ÷Ò¾ëé ¥ËZè×ß·!ÇÓþ¶e¾ð*hAudk[œ‡P¡ìÎBGh!ˆú‡¦á>VÄ^ˆcûPKìþ Þ˪ç�Oû¾“ >@oï·ø1OZMšMSPéÞ»ŒŽ“È0¹áÚ°?!:c sÔÐA{K/O] ˆéâNŠõÓ“3f¦êC76‡Ëô³n–„Ë3 @ËøSEü!GD[‚ <;ùT[²!' +ÂåAöÕ8Øû\³Àœl2s臭ø„}»‹ËÅ+½°l«Ÿ˜U�G®bÛ ½°ç²a™‡\G?µ w½Ø&a^˜rGÅO®üÍžåžßš} :™ß"f3^[`u»“¹ý«Na©5~LtÒNõ@4jã™?9û£ÈPIæI8Ž&~ÂÂS9‰ªÂ‹À;ÎT:•¦¿NŽŠbZ1£6Ô_œ&F¨F2C˜bÃí¦M©8ßêä„Cú^ŵm’ð‚D¨…QƼ»*n¸”¶aš®ßMb³ýÛŽKáZ!<!>ö”E…íÚ=ôUÍâœÐí™AŠ§¿gqÍ"³#ÅÙE.¿ÆöÐKNÛ%%$ÄôZ]wp9œußAåTÔÏ}…¦O‚èsëWÏŒ¬P1b>ÜÞ�_Ùhq¹Ó8–ú<¡BÖ v‰ˆÔF6„,œõ¨`Hú†W? Ü©CRÀqCŸ Ÿ×VðWÚyªrôÑõ§Çþ>ô-k¢EÚ^ 3¦*§÷çuá¹ò¤Õ³À«UqäEý¸Di")çÒrŠ"­çâ¯:Ñ´Aé¨P÷Ce/oÔž£ÔÝQ:Pún>}ý&´-Gwlj‹ }õþ“Ì©_2¯íŠ$Èέ9Â2ŽŸ§ËðÑÉíY&䥩\¨ŽÐí0 .}ŽE|Càú–¹¥ê ÂI“ Ý¦AúÕ9$n0çæ gT·]O¯µ£2þŠmžAÓ¬ú¥ñ‚¢;%+0‹lyΡY¹Š»~}.mË æB¿ m_Fó[;x‰0%GÄÈ&+5PÔ°ýéw_:D?¶…oA«Í¹J•#˵ÜæÊ¿vn?h,/úä ÚÖÀlÜæ’g©Z×´Æ¥™)ÎÐúrûé«EÎHѵŽÐUV¢ñµ`𱚃eÐàþNŒ+E8ow÷Àýgb•!!®`Nv¤G„9÷ëy|« êy,  $ªr,¢5^âënp6–«Ó‘Öõ×]Ç_+-qê.Øaz¦sëéòΨ¤5ŸAÚáÏÜvop]›–Üt$®ƒ`€¯­lã¤tªÂlNº§]Pžk§m;4« º.¢/i’ÆÉR£�¥Ÿªµ‹Y(@4ßƽ÷Øi…wu‡‡-ø9PË™² |ÿò$ùlèPß”ŸÌU¢…%<JZ©Éh‘ pW:œk«\xÞMMG1™4GŸ[\JžF‚:Ä�$¥ŠØêoð;N©¾§`s8 ÜÏèß<‡ÃÁÌ-iQ0ˆqž°ƒÂ•i ©~üˆ{i nÒÓ§ Ó&AÕz+£Ù Ãζ:n3ÁÇ)alI;©)æD?u¶¤-´cEÅôÒžJ¨škõSú×+Y™ÚŠ«fç*€Tíb_%gev…ŽgâÒVK\`ùñöü)ñ€­äXKqµhf xèhÑž¾<ë æ´oŽ;Ó9¤÷n.ž†$/GÜn#Þ„×üÊs;™üÚz,r”™8#41˜wû£´È^hvDŠ„Ÿ@Ž‘RTÇY»D“<ƒÊþf¦dåjŒ+¶Ó-²Úw)‡ÖŽBļk]…¤‹úz_!Î|a'ú°ÛcÄ@>ŸZ:oÌçdY R˜â¨’EÀ<Œúåiõáw®¿¿9ö¨v›?){mV ^xžê)¶PÝâîÒì–5«–ŽˆïÄÂx€˜oüߌú€ûÉËN�Ëy9¼Fhg¹q9ž+Ë1ëï¦1|uç¬óÝ•Ù2|ÿA5t2ë€-Asö(¥mßø¤$ìa3oÅpœÑRߌŽ&~‘Jx3ZšÈzìlEùføvÖ×|aq% i¶È1m=¦ ú@–‡à]»? rV/�U¹-2ÒRu“ 6ǾÄêÀP+ÇÄnÍ-ðø¸Ü¿ªàQVN~€çËbDìÀ50k3gÚÿ© q¹@oEÁp¤‡„,U“KšeJ•_'"h«Ã~Ï:è›ÃÈì¿EYëØ)fù:7 ºA™g5¢÷„Šptó¦î $\_Ï wDWeK ߀•6=f‡ÑüÊWÜ^i’úŽ×§ÐÚ¤ BÒtS([îCiL}VÊNkmÚ1$dÌfüFC4‰S‹ê•Û1}ÀuqX›ÞR%æ¨Ó»Z 2ºã«,pxç>ÇE8‹“Èe§!£JçäÆzÓv<H[Ñú²Õç'çc•U”‰æKˆRmw„@ƒÚíÈK¥SŒ×Æé‹O[F»‹Ýد å;Öx‰o„$&ò °í©BŒ™l~Ñézt?1" ´œ<S¢#ÏM’e}r;Pëñb3J²kˆáˆ-AtnH,U¶à‹—´w),Øa3Ôþd(�ºKš#¯5ˆrc„M[4 ²ÓìwØwµj“Œõ4ÑŸÑ5Í™-;ñÎ,θ2oÏv^‰¥´‰IèÞoVkr‚ò¤ñÒ|,ê+6_IèëX J¦¼­èô÷åŽ1£Ø«%”ðEL¡ËÀS…`%.'GÌ1FP÷røÒ^…=vŸt²­?¹t-(rî6 ú­…cæ§6‰¤gýÄ%0N“EjŸS°¢m¬}‰;ëÎzï(Ú_+¡*®&aœ*i-ô+cÕ’±_š²øYß»‹®îïC;âp‘¡‡tìAf•{S6ærHãÍÎ’¼ËkÀZúí.) p‰k7]iwÇžÍ3äÎCX“¡@÷~ñ ù+8×_ÎG¸ô†ŒâüÏ[ž¿ýûVÆM‰"ÿ›‰ü�õhi±ˆLT€gÛ­‡­¥|þ0Ú½ NGN í©,ZRù|blè šý¯ W0íÜÑ6wê®tŒqâ?~¦ÉÂ× œþ½˜š÷з=¢­=«9ø¬Z„~¡vEgb´öø9TóœöG‹æÞRŒƒÄ®üÙXÜœPÝô ç.ÁˆpaPÕµ}g3#Ø=$ªÐM2À4æÓÇGçéÎóŒ3ÿÜ‚ìÅ@Qg«% åºÊuDŠbŽu[³S”¶6ö{ã”ÐKü¹Dp㬴 Ï)ÉÙíðê/æ¼^v½KãÏ*'ùgçiÓó —).Ý÷ÃQ‚ä½Hó`Ÿ§¡oô¨æãVË37Ò -/À¥íø«.ä.ù‡s9†«ÉñgfÊM®'þÝAœ„©70£^ƒR7^•±a3 „ÿ0øB¼Ÿýd¼Q¦ŽOÄ¿6gTOÖÎ�㲡nëû˜‹:›–äš}Gk¾ÂKÌ3uí¤ÚVuWªÀ/Ùg™/‘A�gë³#lÀÙÑN´&ZV+–#xœw¦‹ˆîúžÞ7ÙvÖw&Ú^Ô²ƒ¯£Ï1S 3: ìóG¬h“ˆQÇ?~‰!l&¹ l›žîÇQûÆ«Sdøi)#Y&7ôËwÂC ß“M†ÏuĵŽÅ°â÷õήM:»kÆÓ€¾¥~k^"ZíñB_vé†VM¾Ñˆ€Ãö•CSù@“Y%VÎñ;Õ´È °jå‹þ`ñ>XV+:ÿôñNÕ‰ÆKíÁ4òÎTnÁÇŒ€íd¢O5z>My¾m0[hu5;qÑcÆ`⚘Å=!.ÄFGèc®‚xsñ}SáF6Ïþ„ošã×^¿öË…[’H_·¶úú‡u&]nâg©¹ÏŽU47Òzí26J Êj¡î^kãy“#ôôesœÂu_éö¯§±Î>cÑ¥ÅG¿ël5¼Þ}ôGj{ƒ°Ê6`OïfËRö’E�p Þ!»ã ºÓXÚñÎWÆg.H)%CzËÚê8WyÑWí¶+~÷$oy pÎö´^ŠV;Q! Un,`p×·OmIú"¸ ˹Qh¯7žÕN=mMù)á—¾7Î>Û«¤ôòv¶ãkõåEó$e<Möuq•²/ãO™Á´âñÖ«Ø™dabú›¹ÅÄe”Ûv÷ÿþ?v䤊ãDƒRC{ç"úǺûɼ.a;ãèò×SdTCn;y`§g~Æ‘ªZZrã¹s.|ÉíxEÄ£ðè%‰ÐK°Ÿê :UÝTÕèUâÈ“ çÅáæP)Oòað‘ÏÚ(.‹E²­Ü /ÿßÀp£D›Z’½$”þB þk!LM¥µ9C�%ŠâÐw´d‚ "Ÿç»S÷ݺLFGbè[»ã{ù• Ê¿¶Œ™h!ZH«‘v¥ÁŽv yA$/áO·Ø™¢8x¥µrM䓵}ûBM1TÖ¢i0:™¼ÌhÂÙ€rë$ò#On/û /ZpI«šÉÓc´¡ít}çV¦‹£µ¢T2¡¨¨ÙX{ äpg]{9­Ì Îèµ¼ÔdõAç@”²w)äð”7kµ+½ªQð^&z-™¶>ïûÝô7¯2Ox‰ÕQ(�'V¦½n>–¿F*7È·möpÏÄfîGÊJFÜK~ÿåwž.±w‰PBñöb‰(e QÂRŠmð¨bˆØ TLe¤?�'[½y)ˆî‹®6h”pãnÙ É7VÑIì!á‘p“ þ<9“F‡‰Ô[áÑj,}‚òµ(;Õže/­^‘û)ûTTÈjL´™i±VŠÓƧMV†T[.1€µõžæ£nÙõ¨™3\±Î²ØPTœZ¤ …{B *¸%²\^µï,Š+h†Eý¾h—õ«'¬üCva{às†'u_I¤ïNÃÈ<@<Pi4 yAú+{2Ê2¹R¾ôZ­’¾èImï&ažL{14hkRHY^7ÐC«ÖFÚ+LhêÓJ ä54­ð¬! ´ ²öG•`Lh%"Œ8bpzÑ°†wyJY¾G¢Ysq²K:Ž%ûÏX¢@ã]Žô+Б}ž¿g±«ÄY1„…ÿ“Á™jÐ =Ñ{Ž“R>¬Þÿáÿ,·ŽK[(‘*ƒx<:¸ê [€jó (ulëÓo`t–ì&ƒCÅôZ­jAìšOf”gFä»nhøð'],ÍÜtŒ9n(ά~Œst‡naŽIyéï½ì®L½«Ø™b3Ûˆ-y o%çÜdô]ÊxùÜk>q)£23É37…`DMDgUXΘ\¢ï?Õ_:s3×»|8&[¨°yå§} *ÒMÖàoÏŸù¹ócUØ‘4Sª‚ Çâ»Ò„2rï;/!ýÓyÊ{n<i¿YLì­Ímf>öñPPM1z´@º‰õdiô6ýáÀSÖ«ï¶õŸz¸’% £È«) ü¡xTZ{7׬Æêð »^ ·r\?HOò>b³Ö~ʃ¨Vh aáÍÕ»£»¬ÿQî¿Ì�~=@PVé¯Hßj̨LóF;[XpÒJ:ev ß•Ù§pýÄ0bsÉÁs©| áÈ?)‹)àÝcØOÀÎÈß³Îb( ´åñêcá´ÜxåUš´!é³ổf(ù\´¯q »¾¿Ž=ñHQ\ù€ØÃƚ¼ۮÃθPŸHãÎÕ}P¥%+`†ÇÉÕl»CͦOèVê óâX9 #ÿô† ”ÅR‹øz‚»Ë<k7Oò¹°X–âs[ÏU`¹öU³ŸŸî–5I=)èñÿ«Ý€íã]Ù…gmÓ6˜æ8(¶6º²æWÛ²ö€g2üSnwWi¶²êÁüÌ?Õ»�ùÛìTVP# ‡‡_'‘ׯÈÕ£…G(íø…Àz´1$–Å u;ú£‰ñ~ÞWʼ"ŸõD™£ì’Vµ?ñ¹ñ´ÅSëNyºe@6/ÛSÈlII¿ŒÇ“Ûö匜÷‰·„ÅÚõnS<OÝÒæžÒŠL,ÙŒ»´t9óU¨}Ȧ^m¿¨d²&5Î,H6kg>ʱ~zëDç<‰+‘õ5Mò».¤Yè“þéiõ=å¡Q¯p£œÞžäBQ E±ò%�ÃÁ»Z†óÅ|õ{ÖRý²=xÚn �ÔÇí²ÑK~Κ²c”¨2vúÈ‚ÜìŠàè»pôy‚¥/¬¨ðÌamƒói?󦡰R‰bŒ4ŠßÖè;"‰xÁ#-ýT) #Z‘I¯rQPqe+>õ=,7ŠŠ’©ÀÃ3½ÊæÚH¬BË"&O­ÉãÈëÇ”¸Ç«‘Ê–~íu«Vu7Õ´Ùï`­;`ôõmX”†™Ï­*)¿Ûbc15¡))¢SXP4‰v 5Á£›`zÿ’ ÒГ' _2Ádé”uÈ= 쥿™i×úúHA,­ü¾)…¦ýGN'º ˆ”¬ÆIÙ>=ص2-L¤âé�C áéwÌÐ0£Ôè”L==ÅͧIï§ÃäDzxñYw“© ¿Å‹3»ŒÅÑ‘î̘ÑQ©³†´f(# éz›ç!íȦ…Æ×I|ÊÏ[sÞ$l™rÙ[vØw\+›Â‡Öƒ%-‚póå ´4(æ­¸:QŸû‰WieæöŠm áü £QÚ]À–6ÅJ²ÒŒùК6|üÆu«-¨73bºh°�Šº_ÛˆU¯ý÷ÃëJ Ôèn< ÝËÖëÑæax%ÜwENÚ,Ä° ^…üGŒõlÀÖJÅÅ'Òv4ŸqÒÊB‡@éÓïh{Ö–ŒYÎÕ?´‘*o)¥&ïj¡Jgç’Ƽ8§ƒ†ªÛâ¢ÛÖl©0¿¬¶=üË6l#'©z4gÔæ€w'mÉü¹'ðæ3,¤ßGëÆ ß¸n\]ì [¢ãkÍ‹Dz<íÜŽö¬M©“Xí6æˈ6ΕŒdßwÓ]!É*òEÍ(W߃·]ê—°y:ûyëÝöNïòþ¹”d~ßHüh(ZZcÁDU6Äè³ûc*Yƒ{CM1¤C—"¸K¡jæúUþÛ¡^)’Óò0&ÀF׬ ÒV[]Їik#9"uÌ›ÕîzÛ‹Aw@¿Ü˜> ŒéOUû'ôè*AxIΟޟ2f ý½ùóù€?)ˆ­¢ƒ=Ù€NØáäOá­á'ͲñÏÃ+oŒ&³p!2Ë&«éé¤fP)x  šØqÊÎàc~æ·j iCñ{Ž‚Ž*êSíSên£óŽÿà4@YF7s$ŒÚÙbvéâHßÍ÷p¹§Î^© X$ùç»Ïâ _½ãu*]^Uqæmcyô› ¨†]›¹ ¸óýOèªUv…Í6ôTRkÖÄö’ê…h‚?Q¬¦wvmù‚Ñ}u‚ÓàŽÏÕyÏxç$ùšÏöi}8ÌËožnlÆ,*à ŠÊ ±BeIfª>Í&ws®N×]7½ðßS€õ aHMÉyÞ~Z„ôÛÒüùåCj~;a{€‹¾‹”N®c�#Xº­Àþíz¶R1VsU”‹QØÿ†g‰"Giävr°ý¢{:Ÿ]j†°ùw:Ðë/ûúØ~*ü§ˆñ9ÃÀÏ-[2ÀIŸÏ¯zžûª7ò?öEÛÊ Ìé8ž(M¶’ÇÞèYü‡?ÀHü_� Á–vg9ŽváuMvÐ`xàéª3‰ÇTŠ,ÈÞý9GO¡Ê5|쬦¢]ÿàY÷;[À„ákS§A9xJç ÷¸UFà0Ìt¿ÚS_ï&&f{ýê8´Ç,®…2[£#”Œ“féI›¨òßs×ö(]¸NAW§¡ºaìLÄE¯9Avƒ{lÒì8€ÑΔÕ`Gi±Îž·ô—ñ¸~©.H9l![ÄÚ›ÕnèÓáÐäüÅäÉÇï È´îx­`½DŸ(.›éäxÝÑ?EX-‹”yÄÌݨ ìò0›†}jÞª¦þVšƒ@pÜ¥vj°•-}dp=‚SoœJ¨×œÓp,ÁLL½IóLÖä8v–Æ®ˆ§lMÍÖ–µ‡NýØÈÿ÷ô^ãálÞê~[)æLÒT8±ˆïâN¼›;aðefu@Ív|€…æLªzÅhHÂ…£h‰ñ}„µõß j缌Tyu+:ß î-î—‰ÆpÂWŠH‡1ºh¡É"(È†ê ºë*±põí¹G÷@Ó Ìà,(¶_V@‚O 1¯ÔïÌßDžÁá`\qÛê.A8/ÍP04L ù ÌVŒ :G&¦œì ËÏß¼ôðì>ÄjU7º`…Î kjÙ þŠÊcÜÁÊã4KÁ¸qQàÑ;Ÿçvt´ô {¸ïíЗñ+tB`†}Õ&bUyÜÑfaBâϧ—±k‰ŽÜª=ÔÊ-T2¤]ÂÊzÜý5áÏ»\Žâ æßíÐ; yUCe÷8;U(ÞñžOÓh¹ÏâCè÷ îÆKÞÔL úÖv«Âü6NÚú Û›0]íª;8À¸ˆ uk•©KÓe¬-…œ±³çx点ý‰2]4«-oè—´=Ý¢ÏÚ“9>_úÚšZüÌú½¬ü’†4jnv×'£]Z3¦ÒWZ“ðE]¬ô<õ‘ŒtÜDqRÍQîèp´@†ñª3T7Hùó .ª8[(!mN1n˜Õб­™¸K„þj#x}ø`̺¼8Áƒ<ñHŒm² ·‚;H úè0QD-ËcùrÓ›Ž žî©M[v±ZRnNôÁ³O 8"¬Þ6Õoê #uï# óЬC/s�ÜÀJ(”¥KDM‚·:»ê—"c­ftú%º“ ~Äpû8™¾-È|G8‡¡²5ÕpØîîPñae·Ìm^öµ÷,«%š)ƒc§P‚«#mî‚®µ¢ãðÂ2÷ Ðà*CŒíPÀŠ6‹D÷\謠,ÚglÇ6n#ZH§£+vج†w‚ýü;Ó+ë3£,Ìë’òäñÜí S„“â2+Õéöûpmï"ŸÑmÄèô¦íçñx‹{ˆDŸ=³WS¦›ûãÈÅÄ),ãysicõt|JjáõôF\eû—ƃÒ÷dˆý– cë… P«v"Âçéh¡=OX�™³Œj£‡w®3_.–̺ •ûV˧Z¾/tCû“9»‘ôÕ”h$ó]Y'!qéT<><@ŒÛÉîëU}òŒy6ãn‰y}õ´7p„G?÷ø¹QãfnJUOÞôo�ayw¯³SòÌ7õŠÀ•M‚ܦÉ)ÜFö 4ϼ\î= ¿ºY³Üf$c4^‹ ™lí�e€ ÿI]ù­Ýè|'æ'¶ –p9öQÂ^|Œ®ËÏÀÓ/ÚBiHùݹÃ#ƒšpÁé )”Ó_aMã"p£$ bï]8ìè¹»lä|÷|ëâÔô†¨qð�d0›Èo¶œ×Û‹»L€ÈŒ) cH�ŸÂ²³"µð-ç þšÈ§€Úñ[Bkb%Ú“ƒh·ÕÖ@Ìëš…ÂdYÿP 4ªËœþâ¾ ŠÍ¤za!KȾ-$~2þˆ½¡¯ôpI+Ûw×ùù³[ÍJÏÕž~7ußÐf~¥°ÈâßÑh ì)"8Ðq\š'Í•¯H[Zì –¬y+zó³ÕLJT#ÈÅ@Æ™¨–¼ŒÜ@_ÓŒ*£}Ëú–í D’FÊ Ë6ÿ‘¨¥ðc·I „l5^ØC#K®K`LõzÛkÜS¤8¯!+Õé ]æioô“ÕCpáƗ챦j\Ú4”5?™´[XâÎÊ52MÓ‡aµú)d#vÎ)"À¸=÷ú¯í*£$:¨¶#D˜ˆqF5+¾£fžµGÄn-øà6b#F' ^¾û[<Nœù&¥!€$ªîÓªb£,p6SóÝ-±§C¿ã y0ÍÍ ‹Äc8�X,[n˜Zó¥§ 䎨wCÙ‹àií[“ѽ½h÷”V$c=|€¥û¢(oí /ø­sÖ/K¾êÑbi!˜þîõë)ð\,ÃÐJîÛ‹où“2 o\ ÛˆÉ +úšEa¹, Ûmss414NÑØl/ô`¶§–gBÂ/õ¿aãVÌhn…s§"'“È †Åe}Ñéµi0,eºA–ì; S7«ï¾é—5 ÌU©kƒG:L¾u¿/ö$?šËFu õ+Ò;?»0R„BlÔßÒÍ»×äbá£ëŽÖ&YÔÔ+ïcŽ*üZªØêæ@þg[É»'-LGïN™u´ÂσQL’éÈ£kP‰¼MÊvè¬vZ„P݆Nྮ<tš‡•£ÌÑÞĬ¥ïª ´.9€Úãˆf<ˆQö¯ñãFâ[J—ÙeœýL&Õ½ÕMs_• ÙÀü°®­&\èx›jS ?§–áO°X‘Ã�¦ £»–U¯O£™69·…N6±6ÊíÕJe‘»°–r‘£Š°85}bi JÖK†¬Q˜ø„4x t˜ûNÆ| ¿×T.°Ì3ÝÉ;Þ¦wËœaáµ<„§•Ï¶¯ù0+ð01~)¬ã:ž¬s”·× €fÄï4€ŠláRç M%óUìBQîŽ�¾PÆY7ɘ5µiÕô7êûËô¶9_†gDj{ÁÈ@Û^K…ÛKoô9z¶>«Ãùè¡p¾VαÅÝhPc“ÞÎ@Rõ‘çœL©€ÿ39¶L\û ™ݧîQª äèÄÕ&‰´ººé|G‹Ú¬š…+‡mÓ×ûàìýŸb˜úÜwÚs—œBÖµ€¶§´q±%ÀFð¾‹Â…ÒüÉ”—ÁÓÅÖÞÏiyp&ÁóÞ Íjèp‡žgGkJIÖ­r—Äȉ7Ž ¦”³ðJGï) óØÑá§/hÇ;SŸD¤ž(}JÞ'‡! ê/2'3A ]7jC�ÀˆIÈöS&if÷/š@P†ÜÎÚ¯ìæñp¤”l®|ÇëWf,Yìæ/ÍM"çë%ØZØSP¦ÞxY)ØKÐ¥ å‰í)žL¼}‘�dEèfA9žÞÖcq9³ØPµ#p°Å7“œí±(pQÉBYRÒtNXmUSN‡1kÖSÞ ð=K÷ç‹~õäÁd,ÒÀZŒk©Üá8S€¶*m«ƒ©öíÅ-š ¹r ^­%Ú꺩j|Ä™™á"¬bôׯþòV¥¢mÒÙ䤖Äù‰G¬˜ånêwGûº¡ºö <ójc!  4¶OŒ"0Ú¬Léç“;ýÂ{R*vqÅØ•tðÍ5eQ÷×ú×ÆVÝH€ÁDõ£³w>ÂÍW9WmÛtaãVºÊJøÎSZñç»×Ÿ¶õšöƒÄŒ8m½ci4…€}gY¼¹þšÕ@9Ö£§)*“£ZÉ·«ú,¤òÓ¦¹˜¯Wlí2¼¢–lzªÖZZu«]ñczæÆo\€î¡Ãæ•|b}§½dæ8êäG¡S"ç«Æl'LkŸ¯ñ÷sÛq‰ ~xßQÛ:�`{8×Êog;ÕBÒ’ö×y ùí‹G@?\�fà;$KÉ×¼[â$Y(NÁ¹Í‚°³œ´wM#±Ê@UøØÇaé´«oç-¤ô˜ð=ݨ©ßÕ •„ñäpb›±COSªEÎ};X=¢uÈ &ô¸ó¶ö<Ä_µ=œ8×V]˜””lìÔò ç÷¶m†P>²³À݉|oP” X hEX>6…á ÷yê€`47d{¢úõÿŒÛ¥ –õ“ ï,™36B*,…èf̸]œÇÝ5}uq=ãª):t«vë‰þ!0­Sp ú~E½‚9°Ù× ÊJÄq²ÈbTΪèaØ–lW›²}ôLbt³`Rž~Íi,7Lí—ínsÊy9{rn¸†mÍ`èüxôóa\×Ý`_qvøÊ*8˜›Â\¥xøõÛš©õ¬¨<X„»7¶œW…ÈB–.ò锢}ú̾âH¢Wq“W]:йŸGV¥Õðá"¸êEAi]õÄ,õôáAþ<'½\õªÂ÷¾`¨::¶M«4ÐÚÙÊØpØarâãÞPâì%]{ì胇­ «)cEÎN¸°9L2.ð_®ùÀIéúAœú$ÈúÑÚIŸ˜Œ>Y §çínCa¤-n5ËË5DÏ«ÍÅ"¨FåcD8ÿ|Ìœ½N"¶èÕ ©Wìa³) 9lè/·IêKF… TO(¿°+²HEtÉHm¸ÎÍ õ’yOü$*'yÅ!a…ž`/±µøÒQ—9@1'ª[Ž8MÍœWW’ÉMKa3¶®&-«û½õÕPm@ùßÃóÐßD!m¢-Ý‹^éLƒ8¬bN3—¶#Ž,+¯Ò¸ªüªë8Çe*KD ¡3´åd#£"-}÷´ÖÙ7ëåE[¡´ZäÒU™twg•®Á‘ ¨ŒÞ(ýTÝ!}]bp+¿¬ ¡8”P¡s6ÀÎpb·ŒcMÕ1¿Ÿ^\«åyæÍ{(°zÊÄŠùËkG©ƒPÅ}žj¾ˆas¸y;²QÒäÍÚ+ÿ¬*Ÿ:ÒÍ[ïæ¿"–BÿÅI>º¼šèg6Eìë‰:ÒzÎzKÖH–H‡#{Š“Æ‘·K=JKá‘ÖN”–Ž…ÈiÙ9¥v4KØmÌ ¤áe|ˆ 'Öèñ¢•‰ô ,Ôö½r¸¯L1¡µiÂ>™s:·ÄÂÐbÏkªè·šJBY¾V¬fn ê°+™›Ç"^¾Ñ4²cäýäyàíñgëáÖàÀtlt™Ëα­+Äbe^P¨tgŽ_…Ê‚ˆ $µœÝ/ï8·û™wOï7óx{ôÉû)ÆG?ú}ƒ³5`BÜŠ£ä…Ê&”á¦Ó¿`1'w­n„M>Ä5‚GF‚`äèb™˜ß&…[ÆÈMà<½›¦4˜ðð˜ç Ý ×bzÜlŠ³$órw:ä)Òßo™©8iN+¨ÚðÝZù»ß¢mJ7µÅœ¬Ú =ÆÌ6îÁBáQ›Ú3|ì0ÎRåùBùºߨ‘Å‘D£'Æ}„ëÞlÓÝÝ+¯‚Î Ú¶Òµ“_ö‚üýUó›J)ªšÓõÙS‘ZãªÖùÌz[ð)ÝE)=ÖýÛBÁèî}GÅ`Î(hŠ<ˆOÚ˜Ž;üW†çD¿Þôh[Lo”ã5š[þˆc‘K¥¦”d£ÕIÍïxó5ŽQÜÕs£à8 Ñh.B† ;4ŸNŸo_wÓÛåm½¾ ¶6„ÊÍ+YØ¥{t±;‹G^~ç•/Æ!†Yõêå ¿=Pl–<ž6¢ …ß[†m=Ý‘§+Ò"³`8*'€ä§µYn@öRfCm»˜2Î]®×PqIîÑ€c‘WÏië+*ËÒúÏNüÌæ·UÐBïyCjlµ“ÁM_å{ï /üÁS0w³H °Ñßk(%I¶8É"¤•A²í5\3zúh—왳#¿©yfæW!³Äƒ¸·ÂÛY«8t§»yú?P½«20„TÔöHû«²¾q<>¥÷tfîõ¥—Öâ½+ãmsãçf¶¡øsUèÎкòÔIϺÿy+ßþ}‹Œ‹ý+VfüJ¤ôY»&S�£ª€Þîi5½_<Å*NóéA£IÅ;ú4MÐý®£˜g¡Ïè‚CàÎñV':iéÐ0‹D‹¶˜èYÈÚwW×;­*ÝlY4n{z7ëûAÂ×´ö>ÜýK›Wg~©)gàBŸÇtd‰# ˆÞ£ŒB)€>'Ò–ÛÅ[ÏËÌhDÏkŠ5=íÑ#’ßÎ^¦”bƒ@ty8…rä}éERáv.Ð캃ô.zgùæȶº8Î?#$ñèŸxw=6 âýGsÙÃ:³^ÂAÎ�îëÍ`_‹ï¿XYTÁ»†D¹nÎâÌ Š:}aü½7õ¡ª,z´;VAT+öaƒý•¥J«ïH«âl pu_¤­ôjl¨Ç#ö°UÅ 0•\#q?0F»ö{dJÅ^½[½t34­?A+ãâ ,0Þ¶e’Rü³¨>Ëœ\k£4¢äP£µ ó0Þhìp§\r`YO}5~‡~£!ñ©˜³Ö=ŃÚ79\TŸ¬V �Ä“wuÝÏL=K>–˧{ñõµÓå‰â(¶¥¨; éÿ (®UWbºÁë£Ë‹}í`z\OÜÒ¿Õg³ž…ÓSBÚ Åæh)4è>Ô—ÅßPcàŠ°Œ†p笸È? žÙó.¤óÃ0•=á8òASáÕwVNq8•‰þæõØõ‚Ðô EiîŠ3ÎJjx„ôèšò¼§}Óuˆ) ó»nVîêÉsM“JíT¤­ö”•”Çú en’ê¸ÍÜèiƒÀÌK¿&kÛ.ÍÚ·çþ…ͧG‹àmã& •´ò8ÿ}ª”ã±#rí?–,³yx†A ®æ™ÞÇCÎ2*Cb§T˜ã†bÛñèa_÷5妄˜– 6H®#i¦/ë´”xÊ 7ŒäÐO) ŽŽ˜S÷G*õìZÔÞDÆ|èJ ª×Dw<µ½šÄˆÉ3ÞÃS¹z<’V™‡ß‡pæ!¥ÊìÝ:IDbZËûCqÝ;˜‰½Oc¿ëN H#Ài&\ú-wª˜éÿ,NV&´î«zãòz¤gµ£_±Ý-xŠ8°EU?F£m³k­ÜåÝGÿÄab……ÅB`u�Pf­l\´kQõ f¦Õ)$Ÿ«RCý·»5ž’ÄW;¤p•S¦û¸d¼úÈŠ-š]Q ça±k[”µîâêt¡? 3ÿt1jµ6Î+q¡j-0óçH!w蟻©P8ÙMÖÌׇÃ÷ê,GT-þŠøø ¯]ŠI3ÚÅ–ÿó–*:å><ÙÞ×¥ˆÒ ZDV6 †`0„ŒFm±q[Jh¨7¿ËrMR³ãìTƃ r tßÿ)Û‡>~šv.SŸ'JNwÓêóM~ô"…)"¿R! ±K¢ËlÀ|=¾qs’˜öæÙ(¼!E÷?ǦROÏD2¨Æ‹Ž@Ð ¢¼oÖPÁ‰òi˜-[c5¦éÙä5[HED‰ �Žïž„ª'ÛîÛI@æ¾ÈR˜@¢E½ïq…ÞÏÝ6ô#¸¹Ë½yzK·š’…<(Z_W’é£ëz´äm°IPôøçÊTÁãJ/tµNK–I³öjVˆ»­|~l/ãÛ|i×»þ›o#'t™yÙ4A1öÎ6Õ¸a˜ð2u5/Ayéj /Öí/Nª"Ž±!‡:}غ1o,ª;KÌí˜ÇÝ^˜|ì [áݤÁº‡rè‘kÿ‹ƒ[Xˆ®%Ô•¢v‡SJæ?ÔÂÍ\÷Ðhá®óÄcà ÍUŠ@(@ ­"‚ŽqñÂûúìî?m‹é2owµUXQ ô[%ô"«hé ݸâ.ÒŸ¤Ê‹výÑyÄydgÚûZuè­8G â‰ñK˜'¥¯Á^$ôšÖ´Öé Ô'ouþ_z™'¡G gÑúfÙûÖ³|¢U©ø�õ{{ZPi¥$Le:=(S‰ÇÑæ–!´@¸iÈö*´d”0öû/´r¿™QšÎYl[¯çKWÛ2ªPï‘ü߆¡j~*‚v›™-!,`f„Š¦>œycvîòÅW$N +‡Ë¬NXJT®QšÌ©Ìku•`m˨ ŽEÊ÷Oï‘9A*ÜÙM¿n˜œKç5&ÅJ‘ Ëœöƒ´?c!ïÐ.:™ùUç1)=ÀÀ_Rk‘S`®ìd c= ‡ñÛòÁÚ«Db¯ÇìÎŽ¶¿ü î:ÝûÓ°©{L™÷CúÜõ“Ì'îú — åP Ùó�:r«ÙkfÖòxÑΞ X¨?&ïÊ´îÊ…ý�ð@S Ë£‡Èj/ßzfqÃ}>Z:`�7¦š!M‚ì|ñÌÓxz)& 0Emþosa%£ëïkZîW¸èÔN‹ç=ûáûVM»Š@&\ҸÉû- /Ë|Ë#„>»‹‡òÃù@ùËßÎZvxºç" ½Ð¥Šr£Õ•Æzmú�õ¾WÎúÅ€v–0²pÇÓ7žÐð=võÇRƒ4I”r$Œ*Öo¤ûÛ鈱Eo¹Ýõê‘E™:ð—ÔVàkúÌJŽ…GYøbýÕH“Ùé§ï@²FN<¦=b”/M Q¿®Mjÿ´Ä„\ÎKŠA ® ;Ð¥öBb0¶b¢%ß^ #¥8µ¸ošUé+‰ŒË—>Ov¥ë²Fì¶Þ‚Ùú½&e’ Ó½Þpº÷#t1—ùp/ÀÅ=^03Ø¥“Ó…UÑbʪÙ܉ž¬¾6Ý×]óäX•#yš¥û·Ñ‘¢Ã_鸩kþ[éÍÉØ\¥Ú­GÐ2\bƒRu§ÿy§›ÜÓ{²-ÝÊäQÓTPb© ëŒÎ)nHýKK}ÝãÙšœåxØ Ž}^”™§‘WlœX,“ßè£w¥ÂH’£‡ƒ#E¢‹Û—Õ¶ {؉ 0O‚[zãÅ ; ß•ž.ólÖ8gå-½KdFxAFö0œ »‘ —zø_PÏÛžäÉŒ²y`û³†ÜBÇ&½´¬SaZü›0ñˆ}`òŒ+Ê¿Æ{¢"åÓâЛÌWÒS/‚´î<'r£ä@ 7+<>6¥ý‰O­ÕÅ5âý%fT[ÅO7å0zêÎÞF$”C„áL[ê´3"?èµØÀê<€œ€êŽS‡[>퀕˜S‘zñM€^ÊŠÄ+4Pm×qJ†;>P%1oü"à/ª¬A€;Zkåpq@®¶ÞMÎ `Mç ^Vñ2í ‹+ðlæ©ypF5`ó9×^ÞÙ0^Hk,¿›ùèÚƒ‰‰J�ÝU~ãdkÝA >ûÄ hSB¿ðÞËßc¦Ü²Gä÷|PFxT™/ñô¤dµ…?¥³N¬÷ì‹ñºQˆgû±èÎê p×ŵ®Ù«a?æV T….¥wÑ?qâ)¡"¬ý$fÓRG‡‚¼³í_?E镹ìtê"+×Î_¦0]5Ð/1húº¹Ü2²¥/1Šuö«¥±¾À�Gê‡Ì~k÷Ý(î¿/Lå’+Yóv(‚üóÓó E­ÈiœymwÙ3SúaÐ÷)<}tùÓ‰+žËÌ—é`ï)gd-åѧ7:þaœ¼;lЇ»¶µ¯©‹Ü6 šB9jH„ ÂÙj $tܧ\݇ö¶þÑœñ/Ì‚bR£Àm·ßMGºÃÈL}jgœJ—™%Dà½(Ši™aj Feœù¹u€GžSšS½ë¿!«EIœù¶ë0 µeÛVQ¢š¯ÖÂO„Œ—¯wr.ú…F„›…)«Fæ”A»Þ¡ùív™6¹ÒýQÿЗ’a¹S`ú •ŸM­5 �yåx™~vTG{½Æg{¡ç M '¿ŽHäÉ/<Í©#O×ÍÚ11“-au²UuyõæGŠ'ÆM“äÑÄ îXÍ{Ú§«­€÷_Zƒièù> ¢°/ƒØ‘Å`hÆgZš_¨ô—CÄŠwÎz?9¨Aê! ¦éAh·r²NÜI¥!ƒ£ÆR©{Øi!ùÝc%õj$^ð‡ïÿ~ôT/w¶ BI´ųüîrÞWšÕh?A¶£±ð‘tÓÛ牎…ˆÎRé‹h—í),\aùœÃ±ÌÓ‰žíðnCuiL�Ì°MÕÁn\âÔ+®pË];*“6E}¾{…޴âtóÃ-'ìMÝ·:“@±<Rnil¡ë0î¶AO£nÍ=Y×  xÆ·bI‰§`…öϾPÏ™g¾D‹£jþÓ†û˜áú4«ˆ8ŒoëaÚ¿bãzwHùúove;b~Ì.Ö‡"(-ƒœò ù°œÓ†…×òÅjyÿÈ…4‰®�Ó”Õåâ–º¯Î ´§í¡C™J%¨Ð!©ŠÛß}/Â:¾h!–"”Á®Î GªÎ�¨q(Ç›E– %hDÀ+‡”š½kÓç�üØ‹%êejß –ÓEå@Kð\ÖqYïh_RmëäDÆÓ€B±†[Vòâ»ÙIÞGeNNïU[¼•”qô{YÛ„Ü}Çx¾ÿŠž=o¦›3_•èŒŠ  Èþ&‹—|UXÓ½ïMF磵Ö+™í Í¿míyðïç“L,Ÿ$F#o2šæ£Æ[ØÒ]uAéá?€‡{¶ð °û•²Âƒc_ê¸ÞréD/_\ƒÎPB–‚Δ*¨f;oaùþ³(ñJið#ŒEfWBEc5Ó²p¸™ØxM%3æê„Ç;û± óþë=í΢³FÙ1[¹ãýDw[`-_´›“Å ~a‘î"­ddž&ßí’Nhlñê]Sùzá óHM¯3—Â_Ù¯öƽZè­w£¾'ï sjôlþå÷øéÌé }+Ì¡j¥±mv=æø>ï£4F$ü†ËlÎ\®¡K^g—Å~fP†ÒíäŸrgz¤æ€ jßqýÛË¥&%˦OuD½í•R<´íšöùᬠý‚ÈØn.ÃÂxd©j'UEÖŸmÂjUIÙØ·«ºÇÑYßKm!"íï[ë³Eºo²žö¾5k™î!ã¢Ä;Êâ(�ËÙó ¦¼Ï í8³­(ú*‡Ó¥3Ão¼ã?¥;€z]4ô_OŸ0PÃЗô„2ÎF"Ö ñ~‡5vq"’½Hhû&³It ›²ÑÝIƒÊR£ú< �%9³©_ ›³ÊEqîòO59E£6CZi XÛTC=âÛº‹çÖeú­*`öXïƒ/; ˆË`5Š 4²[¡ûZS²È;Ñ*Ÿ:À ¶wA9?2ïîìt¢(=p*–`>wƒÊ©Q›/›4Ù'\S ÒÈJe@uJO´Ì¶Ê¶€ò‰Ó/‘ì²Ðסü ¬”σGÒG±Ï¨GÑq²‚èZÚªàyÅ;G1Ãëc¶ÃŠ¬ç#‹XQòÅ|ÿ٘߷8d]éáHZj»iõX{>r¹¡¦¤HKeÄe×,'Xׯž¤t¬Š¹›enÅñè" XjÓy«l-›½.t*g U°ÄoŸñ§Haj©/Q{L|,DIÕ�·¶?¿2èrƒ!îH“Âê#@�ïpìëQˆãóxèÚ˸ÝÚ™XjÜÂÌóù“æþûº_úýBè-£¿ .}êÓ7N¯…Ÿú ÙÂüYㆿ—!©˜`5©‚«±â·5·%‘^~ÄpÌ O±°àquBqiû×îâî›@ÿéíΧ‚S*á(æOaÂEn5kC*¦[ö^aG±¯'E‰Ò¸§ÿ2>YðTÈ=ë¾>{ôìÓQɪîê1Ÿ4-Ø)ª)Öô狧9ƒŽEÓ9ϔ׌&£¸rDÕЊxTµU€º…(ô :k#Ú1Ê 4YX3Á³ ±ØvÊ�- øÑ×nÜÊðS8‡ÙSw8ÃW¿/óÚ¾\Ä´C²Kf¯Á2h °Â$“ÑôŠ²gHRH2VP®ô©œhhýq’gŠl=ÿÜ…Ô>Ës±½¬»vѱ¦MUä³¢ªÒxd²ÊØß@¬a­¥ç¨§<ƒ9R¦¥?YwtfÙìÝž—TlÐÿüQ™f1I†‹ÄËdžz<@|õËöhsØn€žÐIðæ0ÉÈæêuÙ~Èüý& 0Êî6ïúÆ™A8cv(ge}fˆñGYq‰Õ«{’ØQæ{8Aä¿‹3FœGã"ïi¿£E‹ä¢þõ7ùjáe[,ӹǩö©\ô=œ´T¤“ÖTSVºcѪ—•iŠp±¥Üxµ§¯Ñ’ ÍŠ© tÉD&õð¢L{öTÞáË$¹'M«Wpy´g ,Õ"÷ïû?6 Ž²³Wôá*Ê1j}ìl(tå÷¶ÁUœy=U¸wè—”ƒjE&ØVÝZ"¯6—#eܧ¾ ­Ú’€Ÿ�–‰“ãq²î†Ø6$Û#ˆ) +çZ»ƒ6ìM¹k»u‰ikºGÓÉ;Û˜1ìylI1r{¡¶±7 YFÎüf¶\®P²ñ!¸;ò[Ç«táöDçÝj õÚQ³=¥/Z=^ÀÿŽÀª†Šahš·Û¢­³Æ†2½!@K1ÏüYeÂìlP(, ’QJ/“4R¯'ÿ Ú]Í^ðŽCJåÚ3>Ù{Òi|>.ûNOhýÑhšÕ×Ay ‹2H¦ÞU™c·ÚNY#kXèB­°ÞÅï‡ìl§kpW-ƒ/3Ýè‹•$ž¶pIðÓTÀÝP;[Â4‡ž§ß˜™£‰çZ1£H¡ˆ9Þw4›…N-<mô±û³GR¥›þG:¼÷mC[z.ã<I лÄ9éæï<OÛSa½3;¬ÛT«q: fR^¯=7Kωa£ã–+1õ<Î-ü†o3ݬQ}]§^uˆÙA‡Œ–Q¶¤L55-‹®ö”˜é¼j:ËÚŸOƒx’_S[/¥²xקÿ±_ ã ã…}Æo®Õ¿ˆŠÕnêýÁø¯a‹$„¹Úþ÷/ÍÐγe p¤28Þt›é$=#$ ß»þ¾E.¬­W‡ñ´¿íÚøêÕ%ëR÷®îêY ©øÎIAÌS™=È¥ýÓ[â w¨as².FÏtJÌ£zè¿1HU6²µ èŠù€i;Žw‘ª'¹8s“£åä1—ŠáMgZÊWÁ~<\îJ»“‰âÕ îL£‘æH©3Ø+¯µœ"D�)áBñH'½h3�8låíõƒg¦¶ŸÒ„Jâ/ibǼ氥o¿mÒúé�Ÿ£e&’,, 5J¡<;Gîä!ñne›cÛzŸÐs(\&`1KëfÒz¦/ÿ—›ºîÝÝ‘kç’®€Ö}°‡Ë#Ôc–g¾Ðtá“ ÜŽŽte”ï%\P8þ¸0¯ÎÁ}­ýÜY爹:Ó/H>µ#w0õ˜ôô;Ó.0üjïjqž°ï­´#nôvÔŸ'Ô§3Sê°­-æ$bVþêC÷­¬4]ðù·žâ (S0<vÐc³Ò!¥3Å6¸€Ž†ÿžÏêàXwS„Ü«J íÒd+ƒ~*‚ôýÝÙšR®Î`i3]øfÄo1щ‚s(¨&ï[—cõð0箚‘f3qü æq™,üˆSPöƒüÔz¥çnø@Ûc1¿¢½Òï¥îð.-ð8óu÷)˜@Ñ3Ÿ¶¾$/rÝNSRè ô<”~]׳(,²@ü˜::v’NcyžI(¤'.¶sâjzÔZ‚÷W­4õ<š™�á6'9Ã^Ð(¤cuöÍ…lj˜èwÔSÍA[±i€ªÜ¨ä)õ°ñù«~îÁ¿ý= ÄZèÉ“"ô)„ /¥A5|yR`s½Ú² †£póX÷ñ@tÛ\Ù¬¢GÌîø³ëÎz‚Št”IM0éO êÍÿ”‰$î¼[,Ø~ÑŸöõ×S3´x Y(¼íÖõ—}}V3øvKr,¶3½ëvð¶«æet¬õû°ér¡ C½4 ’¡u±ñÄÂp:_n$'~Y¾4É|ñŸŠì’éÝô/Ø«ÎàÙ#Äa¤-öÄwµ{Åã. cWÙV¬Æ´gPa</s:³ ýÁÑ“RT¥ ýÔœ*ô2ÈÞUÑúºÁ4>Ú› +†eÏ}wy¾ÀÚäÞLºÔì­4ÖˆÓ9öÏ°¢ªØÖcsšê)šxEÈ3Þ;<êH†Ö¡‘Ó/¸VÞUÑÍ:ÿ¼&‡–¨wÌJÜ”’¶5”ÞûÙc´ï ¬W jLdiStY6Q´ðÝ áÿ\Ñ´uJYÆÌI¢Aw”ûâ﫽ä²p³ – Ø"uÜ8;²õÅÿð/Æà$1Šj™Ñæfö†é\a&ÚúNdUp†/œi{¶>ƒ;íòñÓQ º¹’ïØIZ_ K¾†/³2â¡’ åQi£µ;@_ìØ-\wÉ?øþÞˆH>Ó“,3_KŒ6àæy£É[–Û™™™rzâ.œšÊUíZeîö3~[Wlvn’§«?;Ç?w˜ì]ìkÉ߅éØ ,ì?Š è4Œ—´Ùk´VÚÒxÐ?s4K¼9·¾!§”ZEØ*!¤eÈ=W”²Åç§uŠô¤"e)WJh Áðk‡®N]yèc²æm©LŠ'U,†CÚxhçjŒ¥ñaun¨rºöxˆK_.›{ÕšÒ1+|ÊxŒêønìZî?“üÆlߧº�I0¤Af©SLA9ò¿sT>;4³0ôa(Œþ$93“g¡ê·ñ˜eº2ógz—ãdà ôz¿Ó. µŸ¸î Û%¯š2§“a¶¡ ¢¤iÇÍ7Q¤ïΨôºÙ»2ìEÞä)´PrnnºlÙödÿšÎx¬šÉ<—i>µ|ÙÞâ¬èJ;fß7?=d¥¨‘¶[Lܬ®aäÉDj~$€³ ×—·»ß±J™:Gc+Fo¯77¨*Ë@«u3yõPü¬Ý°,)cIÏ“Í¿fðùÈ¢GaîæÿËî@–@æ¨g8CúÍUÉ_¶p±š2Vz±™(ÞåëÖ‚«ã ɡ«rÿÚ.ú«­\_&3eT= ÌG¤Dϸ6°T*CðªA;ù"¤cTâmª ތ:nG›¬²“©ƒ'ÈÓ2°¨ïø!2½ÆöÒ艣tHëÉSålêÕÇ›d™^ëèõò! =_ià·`Ù êf -6´Î8 Óª¶mÿúÊRf~«�‰ê”Õ´ñ<-LNtDxÆ„Ï«»8ˆ-Ùs‡.åÆÓ¸¡2=oÚŒrLNoÅ<p=yÁÅõÓr#r?}€?ÎÞñæýí<P~à 屋èèô{:ê°1œd…†'›¾ÿiÜOWè­çÔ’(MæLÔ&¦Ê¯‹š{'@¶›þ+³¯Q©Ëܪ‡XÌõsÛ4Ë ZŠmÁéžed#£aW7»Ód~ÕºÞF¸ô'9/*%%ï>•¶E.„OŠûzZfÜOÜÂ2óܸ(…Ü'A^o½÷¤m´[Û`?ׯ$mr—ؤxÀEÛ‹7 ’‰æÚ/#Ƭ!€é]&l� ,³Ž ø¹Âl¾¯[ë*ûØ /œƒ¸Aß3i×:û†Æ,µîëõáÜï y× v¬y5°ÿZEæaA,B”y×Ҳ̓úíß7zi¬X¾ñôâÑ[Ê~£5f¶¬í´T(hù½z,Zz(õ‘“ÃóáƒÅ/6£³L)q*ní×Æs ojZüã몵μ! ðÿÍið432Ò¦›±6ÀûXV|üÒ]Tª Z|v_¾¿OÎ2\½‚„rsõ¢Ö¶ùEÆ.¢s¡ *ë�•Ÿpf¦» ÿë•9ž¶°ÏS$ÃÚ ŠÙšˆ ¾X3dµ(¥ž¤`u¿HS<ô|c[ëäpVw�ŒPÚж‘w3]Kå¡'GK‹ Ñûlg˜É×Ó–1{·h¡¾«bÌžœp§q㉌u¢Ó…ÿá©f«¡PÓú?0XÖ‰4ž)8&L¼ ]™Gn¤ÁͼaH‚bk9™h7`„¨}lø×*WâK½\ÉÂÙªï4”å·]?ÙQЫKÇÉöJ:„]K”Ýèæèb+À@ÀàÏG$I˜ù!Õ°3€…é§òÅFæÀÎŽâê#–ajmì–¡lô«Õ˜dåb‰¨ÆÓÑJúŸÄ›FzÛtœDŠ…êúuð½ÄSôOäD¤¸h‚y=QëUÈ\4*º-À¢9 —=õöÆiá$tY0`Ê <¿:´å%0õã¤î.oDµ|ÌRœ•±§Z‰-ÃôD‹‚I‘5*sÉd Ã48¯¢¯ l´n‰b;ÇN«¿:x=µß Ñ¥Ù"­”7n‚ä¸u8AóÆâ 5â¹ôýËBw‘/вòŸ2ˆŒQ–ã¼±Ä$ãÐÊÞX ·µYñŒÏP.ãTZwt(–ƒÞ‚{ˆ«­#-òÀÚ|Õ’íÞwžÂD”¿`Hœ:¬i®ýé®O=ƒž;åÞÀŒ¼7§ :ÄÛí´º¸eÁÚefx¶Âô ç­È^µ¬|‰[’õÐS;‰ÀÇ_ŠÄ=Ñ?}õC&@{*\­V! ž¤BÐË…$¥H³ùõ‡W $ú§Ôé o@l;:gâ‹/¶C7€Õ½ä7�/A‰)ŒÁðõ@=ùÆèÙ]>¨ NÚìi¼=¡&˜ÕW` G¦ó…eúEµ€ Õí‰åoˆÅõkª2(NÚu.ù´ž©çìs®Ö&*ÐÜlË ´+=b[¯ž©ÄFáÅ ¥zPœT¡Gý�‰jCï\+ 6<õ£ˆ4”-ÀP–@°y⥢W‘E¡W7ud›ÎÙ`°›¯_7 O£ÆÐîŽKklgn‹ú’#!›Á¹{S÷ÍsÓžÀ8wO?4]ºo{‘QU.°Õ1Žé„ eb:ÀÃhw.ÉHõXS|ÇQÚ\ÚÅ‚ÖùUÆѱ÷¨ð×½°Òð„,Éy¼PbÉ_ž“½–Úàöyoí 9žvNÿ÷ûD&óf¶Š@Qšýôä)0PXïÏÿ¥Ül»‰@$n7Pi<µõndâ,,îSw¦(S±<Æ~`M»‹ÍÅ$ŬK ´§LÂwyýéØÿîk;¹{¬žY.0ò@Œrï4(§ÙQ¯öõ…¡Üì$æþ$û¶xPµ_¥Ô¶Þé¤ëpHà »ZF’M ì¼¾ÜM³Äã8qßb·)ƒ²=¹Ù#L®Þ8+9üÅ=“]Ý1¥s¤QGbñ“¢ßx“YàüëÉÏwû#ËÝú"(ß?i¬G~j¶Å<ÐVǨ&±:.ü¯§yºre:­>”­tWÎ5sÈ+±øbšSgMhBø_U1ǪN5«ªDcõæïCQéŒfwhy°�ÑÒµýuîÚÁ(êz—…Š²²[Ü’@Gµ˜g·wÛO½«¿Ù™aJÎÕü55Ș;ð1%"†uÇ^yóy–Äûaü¡²w‘xYŽg´ƒÎ†WZšÏô@ó²‹÷ ÊC+Î(úѾ„–üî9•' ­ ¿Nä1ŸÔ9ªt2ÛúUóqh]ƒi‰;üì&}‘•¬d½¸Ó¬i¥eõæjmäü¸VÒwëõÍ«oÒž[¿!ˆJ[Ãí„ãÃÊ:Uò '…©D‡ï«¥ÄÓáY§gs¢[ì;t<¿×VõH{òÝ[ú×v½pãÝ•óJ<å· ¨ŒÀ¢T!'6ó(¼œ "¢$kðk¡ø”¼“ľ&3‹M ݱç #øΞú3³`ºvÓÔÓëc½(É3O=…þˆm[±Üœ©š0ïfÁDHÇÄ"Þú=Ñí3õ(ö`Ñ�„›†vY“0´*!tôvãjW÷÷`Bœg‚MIßdGTùÄs6wà¥ÕSþml¯Âþ”æN}tu‹öàϹšijºš‘¡Š¡¢V6[/ÇÀ]Ýn?tÝM¨=©òÿþ¿é­¿ ƒIX;{åÃ,J®*ÂE¡aÊ küö¿£=8è›QúÕ)Øóoï´¶Ò²ôc XÑgð½k›õ£ÈÂDÇ¢ÓÞ #=N• 2$057È øŠ£ìª#;mÐ.Þ˜ ÜÒŽh¥QQ 昫0^¡°ÔKÆ©l1Íß1@óÌU‡Fá×fðe”ùú a°iwób<z™DÑX€•FáöÂ~únQ2%‹ê&…‡Nñêsãá„ôt¯îØ`b1v›ÝÕ7õx®0Fv (3ÎÌé;O½ŽÃXNkyî™ („’ïA^Ö\'✲[à3µ:ä’h%¾Ž‹ãõ‰Áuœ_ù(Dó—g¤ Î__„2‰W³—2ÙMƒê}ö\Ç ò~ñ¢â$¼-!胶<¿ùf`Ÿè|+Ž$hgh¢üõtÎMß–@ÁùòÑ™§gņot†«Äy°kãtH±&Ͼ˜‹[…ª5>%kŒA{à †mŒ>q9LL°óÔ-XIð·b´UЊØLo0}<æ¹ï€2tŒRoÒWxöðRUÑÙùàê•kàéc\ éQa,¹{8 •óÅ[-r³¹‰¼µ–ù6àCo[/ð.oHãYé=RvD=5yn]G ƒ¢ëíÐŒöû‡ÂLEéì± »Z§´oŽ½·õ”¿]ÞV îyçÅ渥wië·Õe@ÉLÛòÞ|K†Ü&<ƒÒéÛâ$­wc@™ÒÔ};…ˆ oŒ›0YÿTñ×ÖÞïŒÌU0jœmÍéï_t²"´Q¤¡/·—ó”ÐúÿÒ±UÅúžL—»/›Éè·=û.ú'-rLI T n0#Ý¢¤Ö$.s˜#biO´¥<;ÙuÞIŸnHŒ)© ½ƒÐ¬=`ó,ÞÜ¿ò?‰ª…�!ÍÐmÛ/Ȫö¿EÇ“~®+äЩQfþfÔyÝî[ &§xµøñ $Î4óm°`¸�TæÆk©8I1$R׬OÌ*ϯT ßf’a0&Aì‰"Õz È“=RáÃdÊÆ •`^|Þ!¾ißœi Z×P¨³Ü»ÚÙ§Îëz[ßÕ({’Ðñ9ÄÌØO#KI|ù<±§cvG (ŒÝéòÉX[)ž `2öƒ1­ löÕ–‘ræ÷x@æû—˧Zž>{…¦áø”±/ÕŒ5RÀ~­daüBù¶Žäìä"Yð ·Oê»báÖPo”#›ÿ’<´Ê¢›±ö’´W»-áÒ˜*å˜+xÒQS÷ÆMÒ‚ý19Æ×ð°auÂS[gjõ°šaÜé¡Ø ËµZáÜXP·L¿È3‰5BÌ–[áƒòWmjZe"¥>µs”dzáù3¼gˆ¡N9Òfƒßµ‡2’OåY&%‘$&zº,­}þ5¥BùiD_^ørž8 ;Lÿ_D6­" {JSv±‡ÀZñnE+ÁM¢{/y¡³®Ýµ¢‚vïÊÜAQÊ’‹‚R”­"Ò§Àyr^'Td_+'9þSÞ2îqâ¼kŽ“_N4—¨ÙT†6T‡íº9žR~*žOŽ3«�¸Í!yè)ðz¢ü¹‘'Œ—ý`¯Yæ—±Hø16ß R‚JtvX9ÞÀØ\V~ÿòÆX.rлÍpk:Ø’¶õÂÛîÐÃR¥cC*½i¿Œç k¼ICv#XsÏ¢Ã<=¬A&¿dAXoü–ð”¯IÐH26=A ÛŽfx—ü÷Ô3·¥äõ¬ˆ¬`w»7}¤³Ž1*@éÐL?˃bÊ™hçYç™û—·›…É ô=ÇCË¡�G¤u S¡KôAG®ÇÓ#rI¼èR¾=Œèu·ž‡ð) ‡½E­ìЋ‚&DÞh5­A9¡ýˆ{h‘ûyvåü=ŒtTõžtÀÒ목Ï,Ô©é™)ÏnÛ/‘ÂZŒqZ<(t<Wt„'iã©9Ó¾Äèo§Ñ–ö$#PÚŠSÓè|±øÕ¡¦?ÁøÞRbÌ-Áaþ îÐ7Z•I岄á·icϦ. )†ìZu=ù‰lh:-¦g CœÕöÝ3L,/ Eê͹îz:¦.FCùQÃ82$u§?1júàfd¬CÒÕÂÀ—Š•Ã姆zý“>½³“*Ì#é{ +Õ¨ci4¼ñX”d¥Ž® e¤GMAê)ø4±z=6Ž ¿°ÕTÁZ®þç ?»ä' 6‹’bPðûËÞY¶Ý«Ö+äÄGÒ<Å°ƒLTÜä' y²'sÌÂøšú£·{O9­²E§îHOì8n7BÍPM ¶¢ž¶Úz_´ 8ãù™òLóM“<Î3ÍTæ³1©aΚJÒ”v?4·ò š€È¡ò«´Ûž±(tèóŸ7àðȆ CEÉØØ*Òö¾^gYùàM´÷k€OÞ5¢§¢Xà1Ö”tæë´ƒFW†m¸ÚÂÃÑ>€"ƒã8&ÝVûÜÐÒî±Ó\éV° ·ÒÑê{%¦³‡¤—í:¯(ßXÊm=æÀF¾îHÂdø4È>Õó6Š 9ÙÏ{ÄÁȃ¾_zƒqeŠE1|F[i�»ëݬàÇÓ´¥ŠIôã@ùz›…‹ÖºT”à¼9ÌJ×[(mAÝ»ºavõ•’¤}"šDRÎbÓ@Øeš±–Rz¾Ñ¯S/ìÒcOkCZÚ*“™Q¶š?^Šh߯.Fèä2BQÊ7?øÞ !uä÷ˆ7 ¶gÚIqnbðŒ–¬?“ L–óuzÆç<({‚e|ñt–¥6Ýì‹ýÎ)¬Oý„¿ác»¡¾-‚È"í fFç&Ú¦­õ1H[ëJ¾¼ò´r,¬¬±èô»?KŸ’ÍŽË=þ`îòZL Âè–9™¡‚¤ŒŸbÚ§ÕÇZIü\vÈêLübϱAœosHw¡¯ó ¬$·i{8^§g@ÛÍæL£íPȱÕ:^À'£ÌI±b ÜÏŠwu³f{b*·=ôëe#.94JÁ¥œ¸1Fãy…ž •Í¿cO׌B•huŒ€ë‹’Vûrîél4*Œ#ÚHĤí¼1ƒE!;ý8&ÏÑí›9nADhÙ£K7LÙ~®£›S2=2gŒpb§í˃–$[šÄA3AË„†T¬@…Ly«¦•×¯·{(ñrF^LôÎF@Bjò#à „…°ö—¼Ô}r¡ém`Ò) E”éɶúæñÝy’.ÜDFrU�·ÊºTðH·Ûèʨó ‚*rÏã«Ÿèy³î&L-pwØ’D¦.´ÐyÅÉI\((ia”H0ÂE’ø9š™+¸9ä;—¦:úb`Ùšø‰I\ù@-ª.Z¬ò¶q{ç£ëŽ<)’aÎa72F¿åiû¬³wþÈWC–;€qæõ¯À{éÓoß=ýjŠ(ãáìm¼Ð½WSúÙ®¡aê‚iùAú¯ä~¿×ÃŽŠ2@^œŠJ¿kÛZľF–5¢Òk!=~żRT sXW3 òAQN”ÃÑ G‹øo›¹}§ïå•c²ç¸ «uš3wÖÃ= ^:8%ÆÖxUÌRP0}«Öžž|'ÊuOK}}2‹F:‚ÚY×ã>ÈßÐ3æìxèxÇ*Ü¿g»X¡äÏßû/Zß¼P=Fè¶'_£ËÑiÝøyÞšÞŠ½à'Òtº ®¾EYú F¨è šËÚÚç¤a» 8k†î²g7…n‹{Ó¬hÿÝfj.v¬6îöô­}ý¹¸w.¬t"@9¨*·Ä%vÄtðÔT Å®bÒ9dbg{$q·®1‹ Î¥ ’¾1Y6ëÇŸk�•ÖµÃUœ}/`%–0 ü6Û©^b›Ã@YÝpvú9uðêÒf>æ¡«­ lìü%}mÚ˜ƒVDGëð&^Þ#ÇVgPs=$ûÅÐŒâ°AæFľ5ÀçY \Ö2”wª/VZ#¸Ì5ñ&Ó¡ß1_áúVÎ=C€K=âégï´W6—Aüb%>¨äîƒW{ß/+™ô{¦OœwÏ@NßÔ=+–ȧÿ T™.Þ<66÷ƒ~lÕ´ÞJ§ ¦‹tÈĦ‹.ý‘úÛË /j”>| oÜa …Dº‡ôJ“à¸4Ž¤~çêFSà£ðA:íB3M&)^ 'Þ[ÎEµÈÙÀò†“ò×ÖÉuƒ$¾fÈGÀZ8§ô/ï´~¢´ð‚©®·¥‡å© AÁp(°SZÒ^ érÏ,9ÑÕS`Š>Ov�fº¢Ý#ò0î'@ÝÅÙ˜Òkupåï‘rV~0ó¨O&!†â»æþ©µR sz÷·›ì+Ð>(P¼˜Ny¶ëpÒÇEm1zÎDа¬~Ž4Lò‰é±*Ã<$ijPY†¶âx,_ó˜2(ôü%+*Ë m6“©%¿×ñ·êó?“¯¯˜cÓŠì4ª[O,‹Ü�ƒvװГ§9ÿˆ¤÷%Væy�ª÷ P:uFíøt„,1’>:¶çrê#ÖÓR)öêzUÇÑ£r¢Î•> Á²Ð£×…F›¥‰[ñw›a�,x…Ñú½zHWEf> ÉØL2@v½[w÷˜‘ÞW›[Ä æ"-¡¦ ŠéKŸk´ü¦§ØOèy°déò.q‘9ÿ ¸·YþõÖwAìþ|v¢ì·5n°m'~tcËkÊâá‹Åó§çff˜wü)Y6Î|ý¶—å†úPð‰ÖrFESl=8/®8 œûÀ£Uu÷ó KqZÞ༺¨YG4°vMs˜'GrY¨4)ò…9Ð&N 4ÝÐP±hÕùbí8-…‰ä«}”Çwë§T3qŒv¸© ¤ÜfVñ, yÈù1Þn©iéÝ ¹ÛC—”t k[ÙÅZåù´÷pž¯A>uG†Ãcäèrò HTI mT\ÈÏçÇ‘*K¢NeäÝ1 ‹áËY{ZWfçìŽקúêfŸ‘è•F2kÓSØ+úwÏ@œêk¯ÿÕŒƒé»ó‡Ò|.y™âxÝ•¦Ý“y£ hPw” ÷z¾—°T³*ˆU3Õ1<K|+¬C¨²GõÚJ{rü÷[Ñôœz©FÛ«ßGyVw/‡,s¿�£µIKn9i™27ü`{ ~#O\¸.–(…ƒo{¢qÞíp«¯$€`±¹–Dÿ¤¹gIÇï9EÍZðä•ø5P´!ÚôaÄ‹bË]ÀøÀÝp–cç„sTÜ‹3wmmr•_&œ±?!$vl¡óÀªlûÎHK«ä;(USfÄiUèçÈR@ìÚ\a)E&É–tUÚªe·G/8òYivz¯ë=Å*‘Þ®Ç=žÉ/¿èÂ_+a{ ñ´PšÁH›¤&‡8°bü~u+} ½õ…Ç8gž\Û'T©àrž•+ôÔ-áþ¥ ì ?3•Â›ÞLÜÙðŶL8ÌìáGòð˜¼cJíäáÓ Éi×LïÊwB°êFŠ0;k@0Ê4TÚ9ËïÒÓ2Å Â2òsP=ñ„Y×»ÑxÞÜæ¦kÊW»iU›lc>÷¾RZF…7aTĸa3í‹3PdA5ÓHÚõàãÞýÊ®š±×ÕCûÝÂNýU\£lãÚ"2<|¦‰ã]F,à šÉÖæ5@±C3môt:Mœ%'‡vN‰$Ç›uæ8¬š-xNŸÏ"‘Ñ,hb+@i’ÿy[mQ˜iƒ%^þw�|÷-1¹¤h•¬íP¢.Z¯F  ¸ Æ-æâµ1öšÆ¥ì"Zà£ãaîv`÷E+“ñ#…2/}±IzP3Ý¿üó¯´ÊÈ¥¾ø<ñ·æ"Ò×`¶k`t©Ù6eÏÅãb²¤ê%±– ½§c:ižÅRîMÁºÓ,6Æhd‹‡ ¸<ߎʷ¥YÅ(§�Z5¥’X Y\¯uªUú+,jr-8rž qe 먊®¼>mëe€s4¯0ÓjË“$ÍäýEvb¢\­=–š VH z„¦lwZgO–Uš-¶ ´q·¸ z[1¯A¾;Œt�z¶èß}=³�ËSµdèô»"ÈzË„¿¿ÓÊ®æ'CcIÐþ>än¢V{2‹ôƒdpûØ&™(  dôlØqá¹NR¸gŽOݧ¼W~ÀXNôqèÅ‚8/Ì-ÍôO µajzZëÛšÑ\ 'Í?çb¥õï4wO:eP]Ñ/«'¥s»¤[;$9Å;ŽJæuÙpŒ^m´�m¢OÙtÎH,¤Ôd”ûÿy+ßü‚àžÁ/%ß4&ÊŸDEó¹Î‚âëd Dhi7§yž ›±Á¬Añ‚I•233„NúÃ¥þ™5 èw3ûqóœ†êæi×ðÉ´îx,ÕÔƒˆrl¥¬¹*ÊóØOq!:RUÛYr¡ø‹ïB§ü²|.ašÀëø<yÀßAš¯¤á|†;ì`riù(ÿ¶žF™Ÿ»CЉJ«›†r·€íPPÛµmÇÐ4Éþ¬ÔèÍÑ(¶ 0bKðs]ÅðéªSÎå ,|‰}Ù Ñϼx3q!ÛÑâ·èaœü³�Q8st-/<‰4É"¥‡Ú±\’DÏ £Ä™$›ÖsüÙ¡r°'ê]o€× ÜßÀþ{<æÌé¤x7㜔çË@'6=t[´ËõŸmkUÒ»Ö?RCv2G'vÜ€úuúôèñê*¼=‰_ÀO}9:š5$ìg«ˆÿ3_ë•¡³ÐfHã:#\¼š§ºº;?ÁдÌ| :V¾£_àÒE0 z/Ùé»Ú@XEé~§4VÒ©ÌýÐmdÌ +ñÿ‡™ 4ôýOA§ú/êK꯰‘E…;Ù¦¯­$Ò#™O®#÷:)Ïc/IPO4 ¹ ƒ“§»" (-`io—,,")Ù؃RmÁÊœ¿ºN$Ó ÁótYG¶6çÃu&Pdþ' eN:º[/ŒÈÎ;Þ]Á RW˜ŸÜ 7O‡7áL£¯‚êÓŽ¨r¡ì%¨Ò?5¤g7<þË Ã9b]ˆè¨¨´Èþ‡MìáEP‘ å§QödX/ÊÚíš íÃQ­ t¼qáýIïT|5n3q&ÅŠÊ™}êW^D.x~>RŠ5=‘3æZl‹‘áRjÇw§,·½ÂIá“Øt"à·}1-åo_7.,úœ—´ª•Ž†4°Û0{€n&Ú;ýMR£lVùÐÓÍ¢²Â¤É¥9ÉûŽ*(nÆD¦x†JÆA‡»Æ¸ÂZ Í3òwúó:Ù.q7üÉ9á\øbr£«?º¥)9 }†®w=•ŽþÑ&²¸ýÒŠ6e ZV1‡¦ÈGO§… zÿºUžÿ(ôÜ*Ôñû¢È[öÏÿ„ÏŠ·…Zø®§_/�~Ù2Wà§Ò±DÒõx@X[ùUŒ£ZrDX[ ­kaQ_¿.�ö ÉmH öaPõ=G{E™¢+Š’ ýá‡}ÀÁ–¿Üg” u€Q‘n4ßÇêñ¬5sÄøD-0<ÜŽ7ø¹š)šK´ŒËà =+¤–«õ2eQ&:~Ó8ÊÜ[d(†¦ë2ˆ{ÅQ°Gìê€jm4¢”Íæì_ži¹ª¼Ù5žÐ&áJ(k ×;[ë©r©”¯:a üÏžŒ‘48`^ôëóÏ­WrÅBRÏ÷Å3±3!XùTMX‡Ê°ÖLƒÏ|VËnÒ|çGY-6ŒÆc·« Up~"~¬ÃD­hè¡*Œq+t^©•ËxØß%^hg†¤Ó¥ ýZ'¶@yÒ¡Åîyyß›ý}3ôUÚKèUŸ¾|@üᬭÚmý‡~áÍ‹7ç=Ï®L\éæ{eû�&iµ�/¤ÓÆü×LëG¡ýÌóÑÈ5[Á­0X#+›´°Ãhˆ²€lÅR¬dÀùrƒãÌãÕØA½³ó$•E”å/ɦÒnÅ}B¾Ã’ï¯ÍØ Ì™q‘¢â¼Ñak•0«åhR¸/¨ ÓO´¢<cþСöXIšF“cTËX(*S3é¹Ï ǧµ7œvýµH*Äét7/ÒâÒÎÌýZ=V ú‹em"Zݵ6:‘„(…Ò?kª„™çæŸO_£Ð¦Y³ù!’ãdr¸¾ðò`0¢‘Óàǹßí÷ |0X5®yO_Õ†:œáUÄCÔ íÙ,üÊ0Ñ„%£ji^t]JCŸ‹ Hü9hzœ_9(9äàO�_qI“…Õ0’ä! òSí%âJ3™‹Êµæ½ê3ÑÓR °Â$Î¥Ço‚ú7ž©¾\Ù|¿¤á.%(]—I®­ûB‰r¨¦,ÃL“M- n¸´­÷\ú8 öC§…¼¾”=ŽÚ @+Þy)å.³ÈUü—îš17?X_úö:L¥¹õæôbw¤Mé”ê:èEhA²Ä ¦Ñ»4 •§™vGÐ.ü •íœS¢§5/&,ûš={ Þïȧ‹½¸ï [ež]HåÇ[kq”±jV=ËÜOË£«áEÕÂÒ¼ŽŽ¶wõÞz 't7k—ìQ@Îæ-­œÄõ·Œe=‰YŠ0½Ì[m‘•¦¯qE�ú¹ñey…&jF8’Ìfkt»¾[vóÓ€Ÿ9ëóQw‹RÊúSÚëgÒláR㶤܊~u¶Ù8¼öy·g‡là_fa&Ks)棠ÂëYb|è ƒ§³lûb3fye¤Ç…ïU�`˦Y³÷DZ DWÕ+ºiI¨Î¯{Únå¦s™é†*(ÿ]ï>IC_´�²šâE«˜´¦»ý)ίügþçô;ÊÈÇ(Û064%·øq¯ÆúLÙÇÙPå…˜ôœŸT.1.×±mšA¶JëCãOÏ#»/®FÉ®,ªš†žs«ú°¥‰ˆ)Ò±p©¤½z;ƒJ èÜ=ú)~“gvÊršû’vŸ& *§5xKR„hÏez£]†08vwF—W¾´*m ,ªâ¬Z|)«ÿâ@µ26¿YT‘Ê`EÐZô´³Û€RªOÎ/üºûù\€~â·à u4KV‹&7ç>³ÍëmìñPŽ°³ Vç*ÈÌ`Ÿu\³\å¼sU,jd¬MoLç˜7Ú®B—]*[o´‚6¥Qêöæ¹ß+;Aô' *È+Êâ/ž§—ßN0rÛí  åµš¼€ž%Ã-"§ßòiñL ìf—Nú–; úúX�<YX]U”ãgAiw<�BíX_Ð}¶‹ðe¡½åwŒ_8YQFùJœ2dРɀX¼bÿJ}®óŒ"Áé½¼ò¨¡2u¦œ1ùÔù Xè¬@(×ÿ¼%iiÆÝ•ñ›çá§2·NѤRð㙾Äó¨‚)t ÃÉ–ë•ÿ¼ETB(‰_uo§a7OJ:V/ó+ïG¿8ú§ŠüåFÉe|Tꯦ ðY¡Ð¡š£ƒD_Hùœ‰Ud <7=¥ÈvN ˆ#ƒªd[@8@Í'v,[¤z‡p›.†t‹„©m&o* лCÙ˜x¿€ rBnÜÄ€Â#…r´6§@2KÈß)lñ)‡7ú'OËÌ;ÆJ@Bò W–-¶ •ö½tL®½Ðé¸k&F~‡g.E¦ÄªŠÏªH1Kv—˜ŸIí¨+ÇŽ ÜÕâ÷$¡uÓÀÌú’éö˹´ $ÀÀè#ZÿJ‰Þ±ÙÍî´M’ÒÓ†8�&ilH¸î¡Á8rÉâ}�’6>ÎHóòÀó2^¤”‹ Îe¤QÏ7•,Lwõ̱3YhGV�—Žã *ƒXü]ïØçÐ⤬2O:ÿÐæûÔ¹ t»ú/xónXI î)ñÝ- bÕ©‹y ·{Ç¢(£íÆ‹ÓNØ‘øÐ[4’»ì¬2§ß®ƒÇÁ†vÎædÍ?q†è©R£õ±$â‹.Ä™§UÈãÕ>ðh]K2áDÍNÊä›Oåâ¬aà2·:5@¯ ïXÛ»ñéPV,F„¥H÷æ§Þ�êÝœë³þZíÞ‹øZÈS®/ÈJ7þìR/Œ¬ç‹hø¾h{R2⮳ÍcFÃÄNXjáDŒ–‘­»Ÿ´ÄtËØŠØë°S]¬ùòFË”`Z(kH-@Îc÷ÅŸøê9fåK;‚½³7s?àFê}ƒÍ/,õz‡ˆõ&BÐøÜø­qÎǾS‚/< 6¶y§b( Šuë#vhŽ]õ±;ë¯çÊQžÆKEÙéBb2ÿõµ™iy¾­:ªB ‚ojZ:ÃÛš/¤Ë4Ÿ/˜–wc×î6;dÑî’¥[ª* çAe+üŠkpó4[vƒT„Û KXŽ°üô£yþkÊp”>ø%©©lë³³æKO¿C˜ÈN[Ê^(^Ô7þc ,xJ‡†«/,W:Urw}?[êeæ[è€Â_úxTiÎÁ’¡<-.ÕŠ‹Õ«5üÜeÆ<dªx alû4@½¥z· \¸¢íZ¿ï šÁd äBnýÃñCØêIXºU{1ƒÁfc @üwÞ—çAIRØÄJ Á”ÆAv²¼C:ºº…¥ —ÀS„ " †}yZZD.{`W MèO«o˜Š+Íe´DÐè ,_n=Y]à}îiŽ`){Ö]— ´¶â‰ôi@a+,Èo8ÿäͯÉE¾èƇA3AåL¡"@6@•É®¸Öiz…”›ûé9ÅŒf ÎJMñ\¦ëyñÒØ ìņ|šyÈ¡˜$ök¸8˜ÍuO‚°åêÍw¡˜YYežÔNN{}Y¹Wè½Ò鶷yÿó¶ß¢è£ ‚m¥Ü²4»å }œe&2¯<Ù É-)D–Á^i¶aQ¾!/¨*¸0»ë&§)` æõ¶L+—[ø×·s FŠ#ã¸jrª‘[—ªC¼µsþ­]o0©W·R¥¶®Ë•óJL{¶9RÊõ·—U¨ Ñùð| •YªTÄæÖý)³Ilå`f�¸=˜Å£¥Ô|®6ÿ‰Y@”¸Â âQÛ晄ÚÓß_fÚÕ3Èâ:ò×ñ2â¾LÔP¾“U8(}ÍǸ:@{öܨŽX$Vù¾*ñ˜lQf™§†‚~cÕ>êDÙ%ì•Ã¨‰ë°„‘±‹“ú¥o™<HÇÙ`(ñ9 ö˜Kt8uâbi üîþ%›'éôžÊ¤Ìú—ÇÞ$ЬÑç²G¾�’[£¥¸mÑá@¢mù\SÝï<î…ì苤qœùŠ©7§$âíÅë|Q1×;£@ ÂÀ“C{¬ùòSl7 ô÷Õ9ÀøÜ#q¼¡—j`ÕW¼úö®Icäu\åXÁÓÜjë´?õ öEC8:V¹R" ‹±-¿ó]åŒI‚&ŒÓÄ ¬ÍSÁWLv-¨Üý¾çjaÒÎ^ÞP”ÓÔÜgáÌqSdƒtÙ©ï…i‚)dMVˆâ“•·'L+Î�í•)’q/7>"¶Nl+ ­ ë}ü»D’– _TŒ˜bZó­…`A'éÈBeòG3X@hr@‚ÛšÞ]Þ_<•2H> ò<¦�ýÇ­tÒ !‡ÅYãHËBì¼Á1Ê_mÕÌaôÑ!|úxâVÅ–¢5ýMÕÜyÑŽŸSmL„RÉ%ÊÉ•;pã˜JWPQkÁ«5úXÇö´º#ý×ò•“5ò˜t¥ „>èÕ¬ƒr™Bbë!ªzÓõÉo:úhU‡¤iOkr¸x“i‰Ê«ÓÈãÃz`£ZŠ;–G§µ?t^ÞZGdÈ@­£ÚO-�Àa¦uËE‚½}&à3GÛD}B pŸ’ô)c‚²ñ‚¾¢“·O[Êý±D€ï"58µ¢‹±Q}÷ÀÁÎk—ý»Æ«!±Ìùä_>4EH£Ðsc¤H¿ÿÀ0À12žýdIµëÓø—1Ñ?YΑÚ%¦' ÄdrÔò¥Hbjm'õEŒdêÉô±AäSÊöÓLîX–©wùÀ3ù”8Í}Õ zvÇCyõ"; u‚vg}AÆ«ãÅ›oo0xy‡í?†p"®‚|R”ÐصVœ^0@@&P˜¡•ÁtXA%<>Nm³¤0"ºí€¬{«k¥Ê ‹%ü†I¨òõ7\ª,!f¨%¥c%==§ƒ\ó½¯Çÿ¼ß× KcP4ÝÏÝÔÓÈ/í�$iW¥Ç/—óSpùÓ VMMžÙž]"gËç‘öØà7'…Ã}Wîñ)ðSgO•úë´Ä³¡a@þ¹†0Þ»ö\Q³Ô3 t"$ïù,{—ϪÓxáå—}O›~ÂöÍTø^ÞÎÝnÜô‡ïs覞ՂéÃ×ã#UÇþ™y¥’±rb=%²‘éTŠOÅx²ÎóÅ¡YkÚ«c>:°'Š{{“"»úcñ/.XЉ+”"^a«u’É¥ö@èñ[ºʸU}î½+ °Cë.ŒË©Std4Ý~¦‹ GÖ8®ã$^=¦A¤N7†g/Ê'n:P]ñ ˜Öš·tØ…ø¯µˆœq®XþB¬¢­Ý¨C$7Dý×A'PRwuÏŠÝã“&Ü]Š³ º(Æ4_bÍûZªE¯u„îÛb´t8g©ÆÍ&Å/A`ú¼(Ômiýf=äÆ6h9*Ñ)`—e/Ô:û…F jñ 9&Sœ&ƒ:÷+%‚<Í<|/ÆÓvDyÔA7¬FÇL( L,Ø›¥ë«…²˜·Ú¹÷=VzÇÍ»¯b}àþ˜£;n)QJ<tœéß\éìæJ>3ÂñÍDUnn¥_™\Ó¡¡ÃMõÕv+ž e”dÐ.˜@ý@F©…‘âé³  Y­ -,AÝw_P/¬ßhŽlPEÏw1I~&5‘§.-¹±Á)ííé„©}u(›&.bU ¸”„ŸVƼùD[Zá®wÞðÁ[;ˆØ‘8ò \_œäÆšÎ%=­…­ÝøS$¹Gœfª„‚«÷“Gzìé •¹7/Ž—T€S§$ØU4ªníu{}C¬ï…“ ‡@ r­ŒÚLY çÕ0]&ÛEð›‹íŒ2ÁÞ¨¥–Aô©?C|e ´CK¼ÎƒÆ#l# ]¨Ä¡ÕÈi·8SëëºÚúM°,¯Žµ}dMëDz”¾ß8(ê-R§†ë×p3%ODf˪fY£³ (H±Ï•9¯édõc¼y !ñýÅ°Ÿ Ø5|yZ*Ó\ï.ŠåXòçs¦t¥§±ËRcÍ–Ï|ûîñ¶®§£?Î'ãÂÑ+€§GD ¶·Q!?WBeš±ƒ­!±)^]c€¹r“+Sé°qJÁlª¶£<£kƒµ„èuî"$e»úæ•õ-̇!Ö\T(.4ͶíÎ —š´è6q·B`FŠRÂëÚ\æÈ ´úÏæ5“Þð3ÔÕ$Ût)éÀ½«{SuÈŽrƒÞ:×[ (¸Þ–æ2=¼×ã¡eêÍïä]2ß3¬FãµÜ@,À©˜X´¸‰ -ö)î:D‹‹vÅ)¢õQ[jx¿ù4I–ÿˆ{–ûä%ød®)Iˆ[SV<Ǿ´µõÏ¥Ey9BÑíe „õzF$d$Á9¥õëÄ@*Ù³yÈw!Ït22ߪ®m(˜Í=8×ÜÕõú2 IGëxïbiú·ôSð/ƒ´½(õ§V«^ir;‰çÐß±W“ÊÿØI$òßÖ.=¯vœ W^Ôþε;À7šR%Œ7ÂÁö ÎàŒßΩ-d|¬Gò­e츕y<Ð'.e-À u9ŽHÓ Û\Žó[7ÑÍ×¾Bùü þ8‹Ü܃%oš–ÖüdÑ„e ¿Œs‹úÿÖ¯,|ÕRJ*‘£[›òÁعëh÷L¢Fóò˜#Í|%:‰{˜Þ¿OŽ›ÊK›E¹çs/ã»'/ at¢lІþôŒ{à…{íÛoq¢³ïïß6;Ì$îþˆj%¸´ß™§äÙÂ#2 0@.ë¨@ÄÎ;§½úc§¦|ÿ)ƒaC¥âæhmBKVKÕ&çoèò‰×ódõœÕ™6U«,ÊÜžÈ|ö¨I2ˆü¯݈l çR¬Z`u:«Ö ÿéx¶åÉɉÐë]_ Ë# c#M¹9Å@¾iñ¶§ª3€.‰Á›w³\<6qÎ\öS:Úg£µ,Ú²ýioQ ºçXŸiâX<9óägÌ5­½h ´¸Ç¬8kˆ‡†Yv^CÒËZze2~Û×ýÌ.¯BÁ—ð¤åyU2#ûŽ’†fü(Áõ¬ƒ$ ì¶r?˜ÊáÀaºÂÚÇYXç'V ¡Ô‡ÖÇû§…vÄ7Ž[u?A¤ôæõ†¨ùzëa1 ’ƒ6�™ÏÌÒ,e¬&÷Ö@Žm-Ì“¦®‘Ä3é¡JÓ64çèÏZêÒ)ŒU¢Æë}7þ¿ÿoz“™Å7‡�Röë¦|ýõ:ìtaØÀNÆúbˆ°•S ¹ÐŽÛKÃ.Ö{—²ìãi ÉT/"ý—6b'Ò¢‚-µ!w†ÅhT‘Ý ßH2ÐUb \ᙋÑ}—É…<HØ”`Q½6É‚·‚ì×Áô8‘YM—þÀ�Z¸£�ý¢{Új "–¡37§Œv2¾"ƒ9À¦.mj‘ߤBùŠÆg;"L Þù´9m@«|Ôª)‹Ž…_ÀBo7ñÅÎm]ÙÑÍ8><»ì k7g`ƒ¹/c<d{˜Â;H‚rR9Úz7ö»Ž?ëÞ’XçÁje´-ºÁ7òë=àné‹¿'¸Åó€³é˼ Ì£ƒ!²–¤À…êéî•éñ–Ibõ­d\Ó@²µA- ¤·ê˜Œã@yÊÄRb÷FfNYIgÉã–NçVGɘý2ó‡Ä!ÄЄçSÚ¤ÈPÀUUÚå©1̪jvÈÊL=kÔïµÀúnôÁe{ß9±£ÒÊ b8W=‚\ó©~Ý]¿SÌ;=EþNÛ0VëöB…yŠ4[ÒÑ„U­lçì©ú9§ú'ëÐTÓ¬çGgž,%:ûÃû!ê—g ~ _KO å;H]þèŸMÊŒ_}ù+–{Ê‚Ðê#%2ZÞ÷Âo’•b½EûSÊ2( ßGÚDfÓ–j.H¡ Ìߎ(}ì=Fù¾<H·­gw"ÉžQ‡Ùñ¹bû®{?¡úŸ·ø‘ ,ÅýÛŠŒÁ ‚^5kÒŒí͹…øóÚpG›¼»ïòl1ÇY ã¶Qg}k°Á=gŽé$[Øó¼k_”‹D9§$¶â“vÛÛS/³ùR ô­¨j‹N*§3“ ÿþ…×ÍÍä¬\´J®ŠYè÷“ò©qPuVBʦwa#?à?R_™ØŠ²w»£�Æê$WÄè8Ë|a.¸IC˜+ÿkN_žBag0GBÖ]ŽY&bº`ƒ£ã_BW_;w°¢DÃ:|DË0“s €:3 *}5Ä×Ï¥(+“83ÝÀÜHl†Aõ¥·¼õ@›Š›×ìiIGå{™Í$ô‘Ã:7ˆ-ge—¡ëHIýÀ+ËðA{ðßnÌ\Ó¢È<-iL¦Ž”#NG‡g¤ÉëN&½x¶ô vÓÖ±}oa`tVA}â][È,ÕÔÚ)Ïê�.ŒOׯ>uDÄÑRvË­ê“ÃëÿÇ Û.£€yŸq±Ðá¥u^SvjÝ(™B³”!¼¿&¥›a³Îgèœe]Y«}$Í—Ã_Ò–ž<e݆ÉB´Í½+YÙÑ?e™yA•ÇYäâ¶RIê ŠÙ°zÚ ¦S|çòŽ“pæ×E@sŽ!k•ÙO íhT¸âÎ?äÐGÉbd ºQБön }Ò€”ß.TœÃ~/ðÌ4^ðÙˆãpQGfè¶Q’T”>Ó¦£ÝÏ¿$4é¨PÚõô[êœîK§ÌBZµ—MM‘)¿ABúh/ŽÝž²ÁÓ‹Y~çý%RmÑS–À<nlulšï�U20C�ëN½›n¦A?*æyñ/þ †ç¡Ïi§'ÖԔ▧O'jz�š£´C+�­o½}¸u,„ÔâýèH=hÉ»­¿Q7C¿%¥eæ;|BôªO©¾×ÑÔg Ôa‘p®Fš£¾r”Þ×t æ<ú±Ç†‰*ƒSl;(:ZG¨T+²ÉlϺm» 7™Fi+ðÞwKW,¹WÛ:§zV»Øyí{|;ïãG©W[‘¸¹»Q³¥äeìá¸î­¥ÅñKëYòié f$Ê8/ï ŠÔ—U¤þ Új·}X¢ˆ D¬a¿[×_†kîœöa¶p. BÈäaÄûÙ#3".­]#÷ÿl¹ÉŸŠBíéecß1¬Ãò2EÝOtñ#¯N\o'JPÊ ªçÙï}Åt’í)°Œ×ë‡Ì?*…2OŸÁ¦”½ÏŽ†‚&Åêp4�7E ¸Óì!uT§ê’Я/‚ð´öªèñpttoÊ=ÿ©å7 KËdã)"ŽŽ¹ *µöh<œ¶œÙ¨N`Sר%üîÇýË®mÿR±zëåQeEæn xD·¬t(ÞߜՔ p c#LEë– Œÿ“ôQéýµ Enbض˜QìbE8Q9û)Õ*Ñ‹"r Ù{Dõùìi;)F dénÜ_LC¡R¯9âíNÓáãÂçQÐÇÝÓoÞÝø¥¡äÔ%<?Ø7EäP‰~ÈîÃID›-k3Ù÷ÚªÀfQ6 ÚÝ47�A½:ôk’f>Yž} Z›n&’ ZÑʽ°ÑD]àÛéå'ƒÀ²’ð”Ù¬Ä_úSÄ”jáDeTÅKûôLeˆ X `GÄǵeˆ¤q=sÝ×0ÙÒ—™ÐTI×yvG»ÐŠŠ#‘ÖÊß‘ª·Gß{¦¯Bq !îœÐjšÓ`)PtkƒrãòåùˆÖ—ŒÑ‚ïó µgsÆNCÙ&P¯ÃÝ¢xaKA‰™îNq\»*‹]ž÷W+Bª´ÞO¬@7ÝÓ±,<5R–í¾âÄÓ 6éV³k‡ùNY›S«Lú{þ}±‡’—F(øòѨp¥Xû \¹Þ’å¯Yó ®+„¡ pÙvëº}>ÐßhVµ¥ËùC}1²»î å1¾_½a¸I@QP�pV2(ŠM•ˆWùw!Ùè#1²ô[WÀ@ÓH?mÊ›™Æ_jZ'qæéa’i»¼íÜÉLËÏÂ…8ÌôßJÛ)ë&”I#Ý–H·w}¢vãf7ÀìRã£t3GQ¿Çݡ󱓸v+rU9Ь`Ufvµ—hãÑÅ€yë&÷Jgó,¦ŒÞ‰.t=3 %”ËNZS¥‘³Úù6f¼SßIº„KÄ9š‚øSÇ‚{ÿÏ[ÌÙzÛ¾®³®—ä]³ÄÎO±ËÐÿ¦ûvŸž‡ÖqD¢'³k:Qè+o¿›÷½¦·åbUCÁLOz•NCB°Ìßâ¦í/²<T„ì¡o3ú……‹Òª=g°'&aEì‹p¡E]Pe³U+aìjn^¬¹Súi9–øSá Û}¨LÙ> qvG±åÖêBcœGw缫;2BiáÚU¢¹>Q1iv"¥â±«(°yµzðÏÇWÑÚói9OFo£š8¶æW7ôø:Š¦¼ùnìþ+ Ù“Ϫ =ƒCŽ¼´ªÝÁ6â™õÓ5·ƒó}³Þ(wº¾uÁŸ¹ANn‘bD3i]åµgƒe ¥Z <:Ë0\@2Àß¡m™n%Ë7ý­7Ä º˜ÏúÆ(“Xï‘uî³—«t¡A£eGÇÕ¤r�>½ÃkWÊ#9Y¯¯c÷\Ë. ýå6‡/dÖ/0S c˜¸ké@øÖ¡œª3Xq­Rº]Ç“{×4{v{6›cëÛr²Z­1úžÂÀǾw=˜ËüÃç»Læ¦ým ·ª�)ÑA£ãÖ(‹Ú\)«Y¥Ö¤’¶±äâC G{a’¿T]¥ÕbhTÓHΨŸM˜wô'ÙXf­ÄŸ¸Šç…ßý¥ r„ðò±ö Â8ÓQ³ió¤;}Éê9ðºÕ×¥T^ìÉ$8¨:¸ÑµV-öé2o]ŸÝõ~ãi— õC¶/@3“ò’Ä ù‚> í[©›Á+Ý„ïˆ\ö©vÔÈfSJ eNžÔÖICýÕX_–Yì}ˆJä ZµŠßP->ÔÞIÇXΦ>ä°ó›w¹éZ†Âܺ8JBOiˆÎí±ªN«epO¨XîŽkFKâ|¨÷&Ç·OÀUj»X˜ød”Üç½î÷E¦ù Ña©ÁdºŠ´) “+ÔÒÓT‹‰ùâ`þ ]’ç-vª/G‰\–¤)N³ƒK;:KÏ´ÅE Ç/ºÇ[DfÐtŒF˦¿NO¯=œ‡N®?z¼<¥ ¬€‚ŽaIéºôn†©F³t=5ª¬eþöï[erÏM†j2fvj¦]€å I™ù‰O H£³¶´òÂv»%°* ú·àåUŸªÌÕ48T‹àŒá_­ü‘H8×"ÔÓp·©óõA‡Ô«¢Ef8 Šqô˜^g_6ý¥È\z’4æl¤PÔ*†uÆqÇf¿‚¡VÁïïç$¾ãN΢q¦¥ ^²T_H*Ët b2-/÷_ñÆ–»#ðÆ_þ.ÞÈVr >Ï€qd ýcìÎôŸM Lx"¸ë»Ü8!c”Îü¼=ê!SÎåËçLjDB‡ªßb»öÄèàðjgÄ;oÀóS$P˜.ª¯G6Öö™Í" bÔ9Å0~Aëq‡•Õïä ËIy©çÈ“²B”³þð9gYCßë^g¾›fwàâTŽ;,Ñ8˸ö'ÍÃ+ó‰iŸ2Ô+r@Ža pèþ€Øƒ×]ù´Ø?xùVÐ# ÊáäámŒÂ–'Œ^û~/7מý·SË`U¡q'ôæŠãü¸£#ü7F¦Q\úÄÀýXÊs²Á’&Y¹Y1P†Ûhàï°¡žÇËþZž¹±1ª'ZtĤý_‡µ)P;F¥(±5Z(ܺ¶÷Ã¥ÿxKô¬Vû$H$ÙB„ÛP+V0{&lû—N³Ð-Â$, ²wKg.£ãœF¿çfFÿ”‘“¶á¬s*ƒÊ(,Š³¡(û¸‚ÿ%Ñ·‚k}'?S±7P¶U•%tïX¯Ø}u³zÙÈiQeF$cõ}N;áÍñ¹éÔA‚¢ð¦¹˜¯Wp5çˆÈpEZ-}Ö¤o½‚y—7έǽq¥ˆ<™î¥»º§çÝfîBû„‚K㉠E´O¯íúº ʽÆqTÅ™'ŇؕAµîÌ„ c’yö¸Mœ5y„çòXaá×Maìè‹­b7÷ݸÇÞbqd0šPŒ¢êyµå0`0Vb ²“Õ7vªwß’Ùâ¹|Ÿokâ]¨Ò6s؈µiDVBTO: ×ôåWNÜùâׇâT1é®?|‰€;š6ÿy‹•ƒ°g…íS5]Ûj—ÀÀoÉ]F‰1?–¶?šCd rnPuë»MÞÝtO¶_¬’]¡ |Ìe¿×¶e¥”ÊyxKUÚ:ÖÀ´‡SOž?³ zRÉ䨪,a¨u?Ùvqœø`¬aª‹Íì,Ð{µ–¡Fõ{¬ÏœÜ˜×%U)öæa(PRtÆ+¶;7Tóú,oó~¥÷,]–DgY±'­òŠ=‰zë­Rò±Öá´1.Öê!0ß3ÅèÞ‰±f.#Z =¿^ÿ1iålZ`0-^âåÅ"¡UådãLItÿ~á8Nc_zíY ªE}Ô-8EðÍ?¾wþ-£ÌŸºÂ§²£·Ê«›'Ü«6º¢?’V¶¤v‘¾Y3Œ"ëvðæD<HçB÷£Û3šYa¸×¯¶CU]Íû@+Ž~£3ÇÎëãÿtü±‚ªrJ* ¡UÐlÜ€òc×SÞ;yåç "qá)¿e, ƒx´©½,d8N;+q†¥Ñ³Ó…^hÖ‘†iæÔYèÑ6Ù‰‘èC ° ªMÅ$ :™Qç¥Ø_‘•iü þ.üÜv²©KÊa–ô«˜ïùFˆ8­“²U|+ÇÏÛg’÷Ó\jǧ4ðÍýå?McJEˆÏL´ÌÈüwÂŒ¿†8OT½… ÷oŒWÇNÿ ПúŽÍ·—<;Ë<çJ9Ó<¨¬é�Ph ™1yÊ£+$Ú“öB•º®[ÊjLcäóFEÞ#HÒ|múÃ=eé?ýè�©¯‡ñJW½F¯È]Ô»™ UiP;vT %‹#wª Ä°RÞáñ7¦ñ)ÃÁ+^ÓÄÈ ±`¢—¯OfÛ •»¥ŠÙpÄÏ@"qÙH!猰z&eåÐk©Ñ·Ùœè/+>5mš#-~+ óiðM:(€·”Û?V®þIë}²;Â�îh‰¬>8iqZ¤€b"Oådñ®ÝŸô Mµ”µÙ‘F>Ø1B6ŸÕfí5_×tÏÝ‘ó½ WéÛ1±æ9ÀOoL£’îçqU³n'b˜FœÑ/OœKOlµ<j†ŒE±¯¯ÛËLÛaí)ÁÕÃä‹à/à~ÎáÝÁþ<H•”Vª‚ø]îr?±åT+qšÊ,† ˜$�3šÚÀpF»A¥ÔSó—˜dÁõ»VÚ¥÷ûr0héÖ ·ScÅÆÓoÿâ.œäæhaqW-ó‹ï_"…4ˆH5ö´ä“Kk&“è¦hÞ:¨Ž“ $mp{zêeñ¢m8zïÞÐPDï(?ô<»_W†»Š‹m§¬2ŠÇ ÖNƒ[1ÛnàÍ*ÏGºÊwõs˜éÐï {ÃsM“Ä×û„ÅÚìæŽY¢Œ6L{D¦p1î~Äu-´ÈŠ!¾W{ ig 1ÃRЈ„€ l'p†õ7/6£QkëÍïè±^Fë¯5¶õþ°÷â"3«G¿Ž*3mïégçØ|F­{[Ú&Ú> T¼ï Ê©7îÞo.”á(ìÙ§~¿¿ék_5ÀS×ȼþ0èÏY÷ƒÅE'úñ´çw­>qPž:¥%¤d){Ê—½½å@l;è7nò`.ÚsÏ/ ¢îÓ ±)N ÎãòçHŒ¬tn |æƒÁ™½[Ò£X`›‰Ûkjrq;ùsîdï6UY2[âá!µ“¶  ¡# GP^&Ù>­>/ÁÓìNä ®Çj-ç ø"íÙÍ)Æ”DKÍÏ\_ñ;æHïu©LcG_lùš¥…MêCãˆC}6gã±Û�y剡?5Z³O¶X¬Ð¤82Ú—¸ÿœŠ-Ɉ–õiNû—nƒv“RIã< ÆmÎÜÙXUAÏ]ã…ÌÀÌ>žs»# [‘ö~€yËæµaÿês‹ãà™µÀ8mc*@÷¶†/ÉnhOô‹ÑëàAÚýýS™§"RÐSI{+«²ªúÄCPm#ì6’›Wº—ŠèOn‡„Qf’úÐÌC€/²c«S¬Ôàƒ¥}·­fýX 6<(£Ç-Eéè}ë&cœ…PÅ#m9Ý7ãÎ<AƒóúYö@\s¶0éN_ÇA¾=PAT^Û¾"ÐH} Ÿ‘—ÒÕ•f·KÏpzªoÅrT,s…µýÖè¼ß[Ž ¯÷Çê× hÐ¥èaÒr´?²µlßÁeÀg¿£ƈ¾EEv国=Ò–í¬·8Èu… Cr ¡Ýø7wí⺭W‡ñ´¿‘âŒ=E‚ ù±£Çyúòü„(UX϶-AO`/Õ¾½xîÕò83êô«uRÕicLizf¨f­;.¾y8^6›žŽë5¦ËÊEÿ‘¶óÐAÚJr³}ÊŽ>ÐĦâæ6¯(®i:ú Æ¥ðúª•9¼RúÜ:À+Y,æ.;üùùå˜Ç…yÎÓ…VäûÚÑýè)Â1J¶¦¾L–àì(ÕLa˜!——½ Ñ“Ú)GÏ6ÓS…ðüþÄiùz;T~Hn¦3óº �óå¦lU_x°DaTeû Í–±£í°üÌqº`‚CmÏò´õ”²(ê©Ì»E#>ö´d£¥ÂfLÏs«w:/EÃWG±uOÇ4NwõÀ·#s¤ù¼çšöWð‡lº‹@ˆJc˜?9fÝ£Ž†•×0‚nY°é1DVNY«‰lþ-H}JöÝKw[R£­0‘Ái[Y(x°óBçl°^:q'C.Ü}ª›“ iÕÆ;3P3ÔŠŸví‚›?¯—¡LePiÎÕäÝÍÀ"h,83òïëÿ4 âYèŒ`–lµšgŠ«õ@ÿ¦()¼ÎgÑá—ÒŸõÃé˜l |K†*ŸŒ&tO7¨V14T>ý¥•›mîÓ· –È#6‡ÚFŸö“¯îˆŽØJà6À;۲פfãE�ƒúù˜mq¿þ©ñ`T «$˜Zï›Þ;—èl¦#ƒ³2±¢} mài䉯ñG;u†dñ>Û^»Ïþ8¯…éijg…qç'w&Gyè+˜•J@Ö7é „è+ÚIíÿýç3ߣÓ¨þCª ³—óàð̯údZ ûÔÀ%.‡„àßOý@Ÿ¯6~§øÀ‹‚!Äz_p • ë˜2è0�zW°¬P“Mʨhã¯I_±=¾¸fIæCÕç7ZŸ±]YW¿qcR¨%…ýá²ë÷¤Ï'or3ŒŠ¨ ?îÞlêÝÆZá|‡îH7û<ÕŸy@)HY‚8W[ÞÕÇ€¿åE$¿%²)[Ê@yõÝšð;oÔ"ÚÏ2J ¬¶úŠæjœ¦~@ë®Ù‚š0[x°}¦Š ª¼¢‡üÁ)<P[|õ¡MÂåa{ônº°Z5>GøpžÌmÙ;dsq”»àG’´6§¶mtqö˜6÷…•pEÛ ë¹»Gaó þÂp¯ âíI'•¤ D×hˆH*ÑðŽš«QÕ‘y§n<Ȩù²>l¡‰¨lnŒ'xµÍžt UźŽ kO–<­‰Š þ#+!â䙘‚|&;5‰ÄthÛš–sáúH©±²Ò¡á®]ŽúòP«06À SgRYE™OÌ‚¯\fÆÐ{…<°2ÖÈ`+3ÍçöξއÙÐgzøÍѱéMsË€¤3¤QDáõIC-ú'ñ4¤S7ó >é”&¡ìÞˆ 8ÆÌ]mÈWeq}{㜓{ºI¸õÎèånÌÑÒ×LÔY=ì[ lT¤~ #’”¨þú6‰úSôÑžñýáÀküê»;ÎT^怤'”«JA!kF¸Î棓1r.!ÏC©2ËúèªÌ 0¬o8WvmËšäc·®wý²ÐüVšÜybDªÝ?QNeT“RÜ:»7 XÍüí¡ÓZ”©ê’Z¦7CÄŸÚMG}#öÔ™¢‘ë5úÖ¢C¸ö¿.Í"S‚ ]ѧB¹Ÿ½ãf{‚ê=4Æ“¼8«"žB Oô£VçbÀ)r3tU϶ûªM³ì%Býj0-e +áßÂïÔh×£&Ëáû?o©UÎ1Åz}n»‰@ϸ‘oþU°öï‰êÆÉîØUü·?q3î櫯ϖ˜ó‡ò–ì}ë´o$ æºowÈ_J]ªlá:@kÕ]¸ÕT`¤ÈØŠÞ rkáÅ/vŽ>!ÐmÐHÏ{•^GèÖÑj8¼®‘å¹ïyDYÒ<Ò½¾L^åK¥U½ÝAMuØx0_W˜ó­>|$ežùºü ËÔ€ôë4(—Q%¾2AL=Ž¡Möyªç9¥6µ|ø^Úè¡âQUØÛ"fÇóPÞÕmÝH…rCOúCyå;ÚŽôŸmi«¡/y=2*ÏÖSô(­™´U•K^;=“¿˜‚/.ÐòŸDéq¤Ø¯is¢¸ùex`¡v{ f� ÇÙ­Ñ¿L‡¼L\í•ÃëÅ&Øq—'*MÓa;8Yq´ì˜ulN-m8ü¾ñ%‰k´WÈýÎûiF¿epO}Ðë¼l-Â}uhE°{áJªRbϹ_žQ C™›‘~[­l§{ÂóPѬqjÒšRûyÖZF ä¦ú}aå†3,”8là[£åm;hëoõX×iF·›çÆv€þ £Q^÷ úÍ_(ÿî1÷rgkÅ2NtpSÄ/ëOñ{fº±,(Ü£Ôƒ¸Æá 8„Ñ9ñû‡:øQ®m1¦^£s²vÒ™\78¤0Ä;èü”=Ùhƒ ~ Γخ™’ù÷yBÉâŃÂ@`ñm7 ¢æ \» bÅXY Ã�v5‚¥“ªÛw–F„Ç5 Š‹ßì1¹J}ÊRà3ðÞYÚI´ÐÇ”0÷bï!Í®:=»cäÖ Œö~í‰ ™#œ©.—,Ǫ àƇY¡†PSµø‰-é$Eíì™o(ôC„ÀùD.܉ÒÐÍÌÙ#¢í©Öùü+hnî¿@kîb›FÞ³¾ˆ¾üÍ÷SGY”ò¶>ÉSŸ{†IeI÷ËSÉ<£>“µwFNDX_›š–0mçó]î«G¦`YùþDö¤ ¤®ÆãPë‘;iŒ¥Iæ•>õ”íZOÒ‚ k­”.ø”[?§éjçû‹œÆjþ…¬|CÁvµ.â l¶Nø”ò1ÔÓ rarÚG,Cwþ4¼nDT9�O(£C­¨Âqu_OµELÿyË „¤øoÙŸ¿”øÓ…åþVâL2Eç9V”[‹Ì¤%|¨EÔžh}7(·÷tI”z_ƶpT[6‹‡ÂiÛÕ+g“ù*°:*r{ãA•Sškivq©õ#zŠÈ=±þ¯_¯sá-¾Ò`zb�Wò|"xaÃi¿‡0HLŽÃÒÏõeiS0ªOÚ¾Øo_¯ âa>÷ëî~I™-=¯¹ÁUžT¨� {ð˜h¹:ìóÆΞLw˼RZØõ:Âúó¥e9µÊ;Nàã´¦¨‰+ÖR¥Í™2›zÜ ±¦¯è¨`/þ¥oî—©‹íWÄΠD­X^:ÀaE¡S+½gj’…ãLI)9”šNfGÃËoE©þ0ýH¾!.3ß åIM¹rÓ›[¬´‹�ä|e›hC÷’$ ´ñS<'Só¬&Îœ|}Øy±È¶-Lå¿_¨näôÅÎ=ÍÌÓ¼ ¢yx>Uš"ãÚS<°Í<Õ< PêÛ´³ã9^x‚º¹Xn£¸txïÔȼÑÕiáµMÃhHtM»3·*õõyƒ¸,\7TFqsĶ)˜0kOz¡–Äø3¬#ÕžJ埠]Ü‚á™×“gŸýçÐÏ»Mw9úÃï®­´%‡ 7¤¿i–ÙB>s´Âê“’ð2ÖÆÁÐÌI/ôë“2Ð òkÁ‹UõIÑyA·¾‹ª ›fçF1ácrÂuÀ €# @zw˜§`{‚+ÚdªÕ|eýg ±”]\Ë÷Ö;öé£LèÌ m|F)ö©XüÖеò̿ŨdM+(ê¾¼‡!}`){vâ=s²<r*Gtå^=–m 7Ž šž>í¿÷³ƒ¬Gq0§$ºñ,ö×Pè?ßê“iô<ò–B/è4Ï ŠLýÙ1wl9i(Y#ÄÅ5àká8· ,­T¦5ŧV‡©ñ8lJÁôÅU^Úä‘”±ÚîN@ù×V›ê!Cükm×4ˆàœiï»þCNã»ZôvÀ`gýMå˜Yô+œÐ½X²”twcü�lìË&Ʀ ´ÚÓÛ]F ¶…SqOÑÇ4_ßîLâ2O±€á©¢g-9Ó+óß+Æ¥žÓ¹èT{úÍãdZÝê21òý°µ'âü™·”|±çÂdNT:r¥þ@¡š¬D}~ó¦/($ø 0Ú]ìêR[ûÍ@ìƺ_·syÍã¥ðð?Ì"<5À¤¼Û¯û+«nÂÛ͸õwî’Á†X–“Ô…üT=XöБiŽà8„2â(ñ:âxõ„«ÐÔ÷\ÖÒ#¿(±N?Uu’•y˜¿€òÖ‹ËïâIåõz#ü‰3ïî~ãµLëiëyG¡µˆ4Øz*&Ssä!,kå”fŽç&¾¦œ¥Ôš¥¦¿”;… 9O^¾eQ¸ð¢Ï‘Y…¬ ¬Ò«lªhjH™fp½§ƒÕ²\"Ͳ›®Y’(^¼0jõ' ª¯Á—ôêèà¤ð{öQ•.ÑaWÇÕ˜Ù»uŒXnkïtŒéxž…è5ã\R¯íC-ý3¥¿“*ƒ±#¯9 Þlo Egõöï[Áɧ(¡¨ °¥Pþ¤ÄVZi(®Làií(Ü'ìßäs¿0À—*¤¸1ËA¦:©4ðy:}Ž`ÛÚ®ª/ FDdNôø îRq=ë¹i¼Æ+ ÃǬc‹¯”ÙA—~ÝÚh$*ŒýnRt :ö\\xWªeSz56Lb‡æNýÑóå\›Ô¿³i¶X'Ñhø€RÞ]Ú›ŸÃivòê-UöZ¡ºbËÜÐãá|™ÌWß™Õ>À†ë(ŽÎÖê5Ž«Í-+är8õ,ìC¹ÐG§C7ÓX{Cþ4-;m?! c±Ð÷¤ì¨ì:sfRåó§ÃàNÜ´*OÃn~ËÞþƒš®>­±<t®É[ÃŽÝÜ÷µíè[)ø«o½¾°òi‘nÑcŸtĨdRíM2A‰s¦#”Ѥ]‰˜"­n½0üËÅwáAP ¤  ûìýÊ=7ÌZÛèæí9˜ÖFòßF“þQ:C¯sÝu”ѱ½µ/Rš-•Ñ´øV£”ŠW×åÉ+Œ[:ªOLJN7µ"ºv¸/ð`íìÄô _< ’Æžg¥ßÑ`1~€ wîšëï~u¤¦ž»KL´TÅV£0¯ÕèL8+Ÿ^pp:š‹3K‰òȯ`(§ßž² «µ€) ̵C!KÖ ¾Ì¦¾ûGؼ¹Ÿ*‚~xÜ}z¢áà%ô­•%ù®#ž¤KÛdŠà¥Š§ÉöÛõŸÇ‚/I±­Ù'Âè`TÄ®ýæÙŽOGeñ#ŠòÆ»¼Ô´Ú_¶ÜãZdP0ÚoÛn/oïN†bc-GGŽiW"uÎ’ýc ¡XÕqë;¶K*!ãE%ŒÜ²J+ãq%XöYæ`,îS8W\×Í?øÛ[òÊ´»Æ-ħ5®¸·oÜøcUýNÇ?‡/ðNî$9¹¢M“êÐÜsðœê¯ƒûÈ}-c´'¾šC^VvÌÖwAÜydF©å4 ;ôvè.meXøSo§zÊCÇ‹ÁU¥I¨økq…ä½ Êœp‡±cÁà{Àª´L“Ì6‚a—·¦Ç{S‡GÜs£šÛÌ:+®Çv·^?|Åû†^ƒ™Þ¥ÙBWsœ|Ñm UÒ¿Fa*3 ãÌ –ø jü¹ñĵ)PÒ‰@ɧ~#çY§èc|zNÖL>’|í•h¹W*ÏîH¡6o<šhÛ5¬Ål* D ¬ JU`FïrßcÄŠZÛ¦ørSÓ§éÛH‚f±�;t¬y`¬GÒ{ìzXV~ÁEîx +k¬ÃZÁ£ÝR³ç°áNû‚-¾¹# ”zpo>#š6’Ѳ++˜üuÝŸ‹c|oâ«yû…‰P>Nk7_¤ÚtæØÛG×_Ä¥Ö?01ãxlVëÚ´jŠÜ)ŸJõ¹›%5¾ñÒüÖ’" =áÛ¿«îQ)vY±ß÷'/Ñ›0!~cjуOe¿¿îe¦!°G®üykÄI˜ÜŸ3/�ŸhóusA´ñ¡sâëþØÆ5wjoøÃr)u_ŽŽ£ÎNj5öÏD kú~ Xr˜ÎÈ’±<ºÐk%FDÇúµ©¡UúÈÌ7HßíàÔâСü ÷’N&áýHËÊ-f¹@ŒŽ“ø¨–G,°îý‰Ogs<­`XbåM1œ®°O‘­íEû«BéGqú¤U}“,Ì;;¬ÑCïzGQ¾WÞ–†ùµeÑž]Zë—"Zu½@µÕ鎕Ów®N•r4Œ½|!¦"ñ¬·ŒmÚEÍwø»‘N>c½ÄqîÈ §˜°TÞ~Z tööï[HÊà Iž–ÇÑ8hMEæá’#vk×i…£Ô>ÚÐùZ,ÎÃì]ÝõlÍ+Ç,•Cc‰LÚüuªÚ ¬Òbtʇ‚kâN:D5ë度šAòÉOõÇ°#M‘¹¦ð>÷^£øÒ;$ƒX-Èþôž—Yš»Ä…Ýþ†.—عšÿ$âtBî1餸£¯ff®ßòqÍÐ`®]ü]fÌ éÈ‹ƒ²¿¸yHS÷µ§•ö£ãÎù� •z{L<“4îûògåbÛí±:S]ÿð…‹Žt"nMfc;þ¾$B±Pê½’Ã{ÔrŽr%â$†Ô7TAøÞXÁ[žìy)Ëì_!·¸ëÜÁ1ú¦je­…†8ÍÅÓ†¸mb>ìf:lMbSš¢vÞië]´4 š¦¼—s,ð‰ëû̓›zâø…ÒtV©H„ì=ÍhÊ1g®1xõE¹3¹ÈX gÀàâìñÇÃ¥îíR¥4á<Ýv_Ô©µ<î9iaI{*½v–œŠ�pg+ë:î]Ɇ¸ãÚ…ÑB»´dÁáèSQaÇz˜w袉I ƒy,âç œiMþ,ì]âåXL˜7êfc«ŠyÉöJS¥VH·#]? ^—KU¶"Ûµ“(¥XMIÞ±¥;:.¾šx™ç•¼È‚>Ƀò}£U«5½Áqì0\&ÄŸ˜Àä1{ §…”¢Ê¨F©ñ còY÷×úöÜÇò5W¾Õg,ÑZ°K‰ÁV9í^höíè>͵ìz5ßB«ô” _”³Ë@¹¶Æ@€WP&­ ºæö„g.@Õ>·*9™?ÈÒ-<Ì棥éî!ØÄV.ÅI‹F¿S…{!ÌX“sŒÉ›Ð¦¡b;#ÜèÍ—¸¹VºYløŠ]0As©qRÆPUÝ,VÝs‰Òê|åò€÷¸™¨6…Ë—bÁК>v ú@“o',9xxÞaF–ì–Ò¾<è"±Zu†'›úâ¡Š-ÎŒ•ÄRr§-ëXJ¬È4hýZ¬VÁ¢u_ÝÏxÂeµã°ü<¼ ´âÝsøWS¯ŒcŸľQEz«C¯ºŠË‰ùýŸBMÍi‰0×¼ûŠ¸}éÔÔ´Óª©w÷ÕqggñÂÓ^ŽÚ™_ S ‡Ÿ¢i nÓ¦F©0Æ 3­úüÆ ÚLm,ÀŽq×`L³TÌI|á`7:¢££Nž·´úÚöè„ÉàÙ6M÷… ®íÑ‹¼æz%ž÷mŽ=;¿~ÓãáÔÓÞdú<·sšÓ°©¡uãýK¦Æ@‡… ¯òU2ÖÐÂé™ôKôOž{üÄŒÅ3'ù¨Õ@*ÓÒŽŒ9‡Öïn/ž"^öþ˜ó“¨Ùz\7Œ·Þ:·@Ü�åÙ(Åq‡EÈ›5IÊ =¾»ÌצŽ*•ëÚÖ'çcl *c–È ƒiSE«o ©€~·W%(ä-“°Yæ·×ÙnbLfäèWëœÊ°¾ñ$¶Ý¡GkìpK€¸~ÜÐâ¶{S;§¿sÿ§¡£D g8qýe…#QÄ"ÒowÝ7¸b ò~准ޘé{ç\}bðWl7BAòý4¬ ¥?x,×åWO¹íŠŒÂhÏ;ô•†ö¢®ªtïð'%Œ5ór@R.\‰€›“ ít˜N½oCî‡0ºÁô8àÜ N)V5¸52rp—|`E–߆¢ æaÕ…Ä“GnŸO­6ß ‡dùrnð)s ¶•“´2¿Îî³ãþòãüÏ[’Ë,»šƒÚt]IÞ–‘Ï"gI‡v¦}mµuMËkèæÙƒAºŸÑ–nTÄói4¤7A›=h8Gq˜§Fjs°*hRHV¤"0„üñí´çE>ËB % *â]{x+¤JúWð,/ðK²´Ò¿îYèj�æpwÐzvFè±ZŽ ?îVžð òVætVg¯i,ƒÌ‘ø:§³HcoRL¡¨gk´yð…t±”T_¸ãÖÇþp¦ÔárÿÛ»ªw®óÈyÛüIÕâ®6Tªb·³§ˆé_BÁûó¹?÷Ú¸ô¶âl)Â=M…RµâEúQT†Çã°6xaâod/LE¤sí,¡ªœ “W!Ùì¶ÒÓV‚’äÞòÌŠ@N;”|ê*ñ'—^æ™ÇàFÄè2¥ëx„–Ïæ0^D±éú#¸$òò8æE‰—àóìþrˆ‚¼W”Ë{½:4¦‹3->Ì€¥/{£^±ubaX�p¢ËEwk¬}×0çÝI< *<cb;Ü}î1>²äZâ ƒŸ’…²ð …zHAÊç]ä?‹otýýÑç}²táª_Z'»êk 3”àÛ„>/gíˆ&Wߪ÷²ålP¨£'‘ù¦÷üsè×t¼ŠþD›e ®HA æÇ>¾ÆfwDY{÷·{œ°öÖ=üwpÅc¨ŒQ^–ÛºÂø+ØËÚÑ/°ëq'[!sLÜaû^}uÆ%&�OTH•ëwuI¨ÄÌ”·›ýË·}Ãå÷+xpgÚ&¢Å´0X²µ~wÝÓÂå?‡–'ö•þ¦wîB=Ä­Ì5$ºè£»k"ÈP“_b Ã"oðñú‘-õ•¡‡o7F±“o !XHŸÉn¶¨1¦ç:ŒÑ?Q.¦012oè5žÛ¶Pjïw<ϸc—m$h¯Ö)ådãÆë¼ËÇâ{¼¦ˆÂÄ%{ñ2}0¶²øE”O1úñf3ƒ…A:-HêÅo.¿­@!h^ËlFÚú¸ÙE&ÚÚ)2CÙtðع¬jŽ'f¦³§Í›Ç@ð$¾JËVg`~·÷ùYrÝɃb.‚“Ï^¬°I4žÊ6DXh¨ˆÇÁp.‚Ø*Ó¡*†l@dY.»ãØAÝü@¬Ï @X¬µ¦Õ]ÍÇǨ‚6ãeXu@ÄÜÑtòÄbÛ—ԅݱeâd "81NÖd¥è@öÕ:À½LŒUpÄ(Ê‚d 1M32ZïÉRßQ̶5\ß¿ôÞÔ”âtˆ~Ñy“´ÚºÁ»¢!zz²ìÇnoÞ€ö5¥æŠöQ¢h9ºŒØ×!o/.f)Eá7ߎ"JgzÏ`hZ½Yö=FQ‹ÚMßÝzž¥N MTÉ£)£V¥‡�÷2dç(b³·³Æ݇q¡pST°,ylb4s¡÷ìA„ñ-åýœÂžàñš|«#V±¾϶‡ÎÍó¤©i ŠæÚU”yȨ~(ÞE½u<*Œ`§=ôy÷gÇaï[âH&ÎF>ænWMQhnMÇ[øö´Ú×û¿hºüEÚº!…tJÐêÆiuÑ*öÖ&øÛ*$õ´EvªAsV’AÆ€Õ³N¾[´ xÀ·­§ NµwçMI•-4` qAlω©¹Œ.ÊÿÄÑàxmo[Ä«ãZe¡µ·­G×%6ªÕߊWǶßÁ¶?.·GZåæèÂp·¹g¢[\Î÷(õ¬ô(}î¼Q „cú “väÍ=üá(b’xgFb ÆAdW$&BXü†–еÒN´¯Oâ•…©ÅæDù6½¬�«¾›œHÒ&¾Up£J9ÔM”Ô?%uA<Ö¦„ÙvãÛW}äàM]*B£f~K3*)Vv݇, ±1ØE4iê–”[Š×‚ïw…ß“ÂÌ%¼ÑÇô-­kã•[D$\T¿·Eqå Z¹àÝ€¾[X³ÙÂc'X»¡[�6LoL†¨"àðuã$¥¼ÈÜwš6tž&ëÖ©Õ÷‡õ,mÃæßÀÓ•ÚZ#òIrÅ«½¥Ùúèý\Ô°AÀR,¸E'–6lm¤çg 7áHȬ ñ8ª¨FvÑ}kZo¨NZå܇˜ýçmµÅlÊ”‚Mèó•'üg©¾³viAY¦V“eÄÈ–cEbs³õßÝð¯U-½ó£'Š¦Öé1R¸s‘Zõ¢¸Ð÷pCðQXL¢äë&ü‹ Ú£Ž@éæ5’˜nú, â¦v^•ÇnSSä7 Ü9¬{žK`w% “;@]½oï¬O—ƒ„¦R@_/Ú¬*ù,²F }øÜý@†9 –H¯îY:GžW† ´")‰¢¼,±D®Ý/LÍÔ?¶Ý³áãŨNßq¨ÚHôØó“gб'XëV>lºQ²]×õQ[E-¯°\Ò€ÂÐW{¦å¬'2ŠÎ#Ñ6ØLÈy¾¡§Kl>„¬ÀÛ›ÝzcŒŸDýÀITy—›Žû$÷TxÃʵQÎ;¥Úè“9qÏX—fþ±?hÓþ³žíÔeŒÇì˜Õç»õÜ ïVëãû OÄ4òd?)¨„¡›ïŒÇs–¡¡ß¹yý¡Ÿwš—N\•Ÿ-pý�O©ÞËæDsµ­»~z¹ˆÈóE5ÈæÑTJuª¸’—îñÒÉÒ×g^Jâ[÷„Ðhç̬ÂÆb‹‚wíe§©êgXC%!£’½¬fÑ¡fùöž”UfŒŽVkú°l¬¢Æª¼Ò.-hn/7+¢(ËœNœ½FÔÃĹCc)ñ÷˜ÀÃú[²oM‹xá•NAg·…ÄŽíSÏËDrA: ù9È´³_>ecL f­ÈPaÀ«Î�ªÙ1 “¯ÜùÊ)ëd(ÇÈG<»=´->½Bm2$iÐišý0ÈÙÏ|†0™U1‚}9XôM׸ÇS¶2LHìïçbN%E€®OÚ:@(˜€·«„ƒ­ùªíÕ{ßqi·v§ú–±\«î VDÓY(ЖÍÚ6œÚ,ÿâ›E¼¯r' Éâê€zwãýÛºçÌ]gc“¸gýrËäiF<rL³uÄ’‡þ,Jh„—²Ž tÅCúðô¦zš¼¦ έ¾^=#ƒÄaæ£Jq(ö”´£· ÍŽ0ž%¶`ÿÔ@­9|$º|QÐTaõp¤»ñ‡ÎlÁw ©ÕrÒÝ–öósŽèŸ¸\Ô\ptT<iÕŸÚƒo WdªÀOÆѼÞ‹´?‰iMœ§JÚ6ŠÊ@‡§�qØÔ¼Lq X~}¯9‘f‹>8Ð!¨üu*ÅGr}ñìÇLÞƒƒäž[*ë|�Ó˜´š?äqØzSêq:ìý¯ü8… }cafÇQ°¯(*\üEÔE:ÐT½ ûóÔ'JPxØiQ9…ˆy»Ã|’Yƒ’—쾌b¸x¼Z‹Ww)=!˺‚H¨h·K{=§uXð’I,Psu¦„“j»™u‡›“Èc?Rî·$S#mY[¤8°14ëœ+žõeÏNÈÐÞ:(£ôñ:r÷=2Ü¥iFó\S¨T,7œ&['“Ÿ¨UÙÈ[+D:ö2÷B™qÒ.]myâj€„R^W÷ ò8óúöPpÀB:*ÅkÓwM§8䦦­dDYñ8ÙÓ¹÷^nµÊ#ã>2)ùò ÙMwQÒ Z¦[hXÞ•OÞ´<:îô† íö$HNÝJ,®5ÙDÊîïë×ëýg~§ögÓ—A<Ž¦Rñnj ¬¦9Ó7ÄMã¨ç°é1ÒÕªGTÀbšé«òðjàjÞ “éWÒap2#Ö}êÖHÔâ0 ñ` STx+HáoJ«e«>µñëkáÔŽ“¼BÂÑî&+êüØ]ïÊgm¢ÊBr§‹=?“£vФãÒ mëA”u{bgëÅÃ3™iu‚ŸWACçãÜÏn¤÷ƒÃ( } _èê WKçÆM *y&jß'lyå#0pº”Ögïf¡"þißû¹NIhFG›ˆáŸšäP‰&Gã«¥Kß÷šk \µõïV;Ñ8ö˜‘@ Ì”Ž:GFÛH?KA}ÿ›Ÿq¥ ],X²£;ð~ºÝð ݶä’(oÍ´yâDn¯¶Ø?¶vÓ%Ç´ Ž}d“µD‚sýÛŽô3àBQ8Ð'’ܨ ã â¦~g2¨‡êgÚ(r9 ¿):WtJ6=¯¿£”4½ñ¤0âIèÆ1ÒðYÃ*.S×�L`K™4Z ±é5˜ßñC3ÊÔúW§æôî“åŒÆÍõ ÑÊ“à±ßU,¯¼–åѺ¡d xl‰@Û®ïèd}@žQc<§{!ƒC—Ü€¨neKh0c·DŠP>õæ|i/|L;:h5=6Bówü`)UÅPRHFÒ‰0u:4m!Ä®ó;óÁÍËs»Î"\H]rŸ!ò÷^1†”"Öë·C¦ÂŸNe4 ažAûnz¬[e Â)_"Úë·5�—bG+÷ä>fߨ¥Ê0,eÞKxE& á?ß P8}b©V¤iá&–³“ œ«É.Ý´ÔÈ¡‡E¶ôx„ð¯{A èÃ$©ª+*tÛ‹Û¯¬@6‹1Âõl¼äIV¾w³ /Øóïc”–è¡È· Ø¥›“)3ëp×ÿŽ“E>•*èãHókã>‹+4kä Ð΄ŽÔÈúKöu»Ò¾ªR¬mçÀõ5=}‡t¤gg²{WwT6­Â°c÷TðY|ภ†¾ˆr«>:ÜŽ§ßñ¬ÞéI2yr�¤¯d·ÎHæ?ãE€vrc >ËÂ\|c¥»•Ï|2J36Î0…÷�OÐ6¿j²Õ©ßSX£âþ ”He\å„…¶rÅ@oœ±²_d*NsM6>wí&½Í4-¹FäüD 2+#‡zU•ï€’nüÌ™ó+ìÿØ+™C#ÙMk½[[«J&àÎÇ®‚Ö㜲=ZíL1>Þz–ЮL_‰IZ>·'‹ÚxGÒò‰ex“l­ZÛ³Õƒõ«F4ç£7µyYC”J¼ˆ ú˜«öhŒ?­O|ׯGí^�)Ž†¡)w› ·@ï˜Ã©•ŸU…m€ ¬†¿–²1Î0b\°~ãed6wÛõ÷XÝQ˜ú6ä €¨úøî{×㟮—îo¿C²® ±;ïèYLJ[¿§#=ŽÞrµØ'+^=#À.ÓXOÝðNgM¢ÌÌ?f€ìT%bÀTÇõêFnëë^ÈBSêz;Gv65N˜†Ã‘ôßÕöë°eèXÑ;•ì|¡¦ˆÒÂ%®¬Ø´§Íl­Kv"¶ -;Ï¢…RkzCZBg:>×\V ŒÁ¼Þ/‰3Ï]GÚ:ŠQFÁÙÈ)‚•xhkÉ Ü…9)ãj©!Ñ]ϸG«õz§±Ù©¶È/èÜÅkB³[*n)šÂöVØ=HrøMôÙÿóFŽ@2`ƒ¡½H07Àe‡ø»†q”>ôF™RåûÖ;Ôl€7:‘Rq»Ý‰¾ «Û‡®| dã)Î8©~W4ýÎÃéîÐ:vÇdLTdÅÐzµÅÀ¼¹‚ãžoÓ§(öf⬕|¦ #ßú „¶éRæ#ß¹rDfÏá–'ŒL´|ÝÍúÔŒÎùä5ž­/I:ä@;.׃ï×ï`çÈÁ Î-zÿõxßµg&´ðKôOšÅ¾Ðn È>}ÊAÙÝpƒf³*Þ¨`ÙÃ.Xï¸MMÑT!€·9b9L2ÚP¥ ±õ(Ç ÌÀî«õ=1Ì+ß$ˆâ…Ì*(G jÈÌ[*û˜Ç©xáï:âqžf¾CAY•ýËûÏ|¾ˆÇ‹ÑþPjÖÓ+ Y|nð‡èôó²c—OËUwÒÀBã¡;}yBØŠ¬A\k‹qK¿(ÙZMãúo׋Ÿ´cqî¡™gL²vJ~<õúPï{£Tz§*ÃŽ>¯¢mP}j!Êóhÿ/ŠàýÔ¶×öË«z�ÅíZ/\ô·lNIB7¬ó&<­g«0™Ñ§KÙîÞLQ(amM_²úäÉtô7C·¢¯‹«²aæ(LcÄ_Ïü øʇ*ýáÜ®sã7·‚ëoûîÁÍé?. Œy”’Ì ­ÛK{ŠêÌK*ƒê˜× »Eše_ʘôCÛyØÉ=5÷4¯Õ, A¬£Õ«8­xÄCßàVÐcã¶2קª?|E:Å{/Õ’Ò ™(ÇwFÌõ1TŸ N~®®¯Ú{ô½/YWªTÿ†nƒ˽,&§³_ÄÔíºö`4úÞÏÄ„¼Ì P`ðÖfAÕ®=ª"͆žÀ^7Â{ø"Ô$í3·}GÓcaŠO7Rò.2M”½×ÃâëÝT¬Ì^ 8Šè“®mŸZÎMI]ÆÉ;€E`rÅÙR+ðÔ`û®“¤2D½éYUEŸ€ÇãžþéË$¾[\Ü_é•[é˜ùG´r)ªL*°ULŽ Äy�@³8—Ë(ÿŽŸ\h£½I²Ê‰H¸ù=ÚgQ¯ ¸˜ã‚¦T±”Û‹oäSÌ&–ÌÝ’Õž¾¤ÇÙZx QöÒk¡S%äEs§7™]1"¸“9[I£’õáÆñâOÝÑÏôÌ*ÐHÑC*‚ðtr‘Ûp«æq%; §å\”´û2tÏûIU†ÚÊ´uv ‹>=É2..Ñ6áÝðCX–ùzÔàHc�5ƒ×k¤Ï +!§MÇò–æuQìÕ‡ÆÁßMÞˆCž« m¿Ê}ÐSZÁÜIl¥µé<dþÝù¾û©ËïøLÞð‰ØÁp„k£´.4®(L®Œ“¤AÝe²^z²vÛ…ÊX˜GÇ¿Þ€®!1N#-ló´_v®³púÄ8ç­´~Öâgì©í…¡Q‚˜ó\˜—j[Ç“æò¦©év¹i1šijŠÿl€Ë)Tƒ –ýÂKÏÃÚ\íé?D¹Vº‰ºdÍJCc{ÐÁ\Ó@ŽT®·Ç³~Ū(]O•Y‚Ükˆíà€ _€N§àË6ÃK}‡h!æ ^9¦¥Ç/ÕЂŒ ºmD+Ùr™·lhï°î“Ð÷Œ�æcM{ºz;¸9QäÚˆ ˆdbÆcIcç­Ç ÷¦²èËG>d7Ï»™jí ,¢ëáâOé`è(.CG§qÒY1Lõ»‘6ö¾»rx´k£<»²?k&ˆÅh«.+H¿cáø?nü #òçpÜS›!N6!eåhT8ïç°Ó;hH+‹% ¢°Ž=ÒÝ»Ç%é!›ÖŒYF?ñ¢Ž¤ qRKùâ¶1x½×uËCÅÄÔù™°ìm0»¼Õ'¶nCGÌÄž}RMgHÒÕ_=ÄŸ˜à˜R*]TKŸ1ˬßÏý6ó„}í+)_éýÆþ1 oh d_ZÚÅð²dÉŽ»#÷X§O‚µjô‰#rt Ó_ñ©É#¼qaB–¸vX+á§^I’ùR§�rNQkÿ%ªš 8A£vŽßz³„Ù6^l·õ�+òÍ®ó0ùKñ[C ËÉ( ‘úü¢UÍ_oÀÈN®Šq¸rï¾úî”TxÄ'–ï#)<Z ˜‘àß#㾪>…þ +fž/í82�ÿÉÜrÐà Æ)½Û•´l‰­‚=bÕ&I ÀÔ&5¿S%ŽâÄ}ô‚ÏvXR.WÆ>íÌ|KÚwïÉ“Û“Ä× ³PÎÚÑ©ÛX??ƒ,>vTûs×�Ùßèa8O"Ž¡{jÒ üÜX•tô<¦¿5 ¹æë³*öºØ™ªAÆ[D ªÃHDä~úêÝ Á¡çíWÈ/ ŠYÑû¦áÓ�< ò@Œ"“ü\µJ$Þ=6,>U&\IPƒæ:nuqŒ£è»ò$QTÎ]¾Ãqò­Â{‘ùFhˆ°H€­î¡wÁM1i\)mæöô\& u-}iŒ7M]k’ÓRôÂNT»Î“/ÌjØ»x«žôo/¬/}5'Õ‘&4 !”õ~ªé)øwgèwÔ˜/*ÿŠEað19ÿñúÀVcò[ SêÕ øï�#FG‘O_uª7¼CõsêÖ<p^ ­zõóë¦:a 7í¬�¥ÔŸ(0($•ëã''qÄ ðæ-Ù¨²›½|{¸òR¬Ökí½(,ÝÃê2ý‰>lý×ã]î;‹³¹k—^U>!rº &?OS ù¥eÛMÛB±?zAeÖ;Y¤mÜÐ]…^¹ápÇÀ•ÌÛ]=™úgúú±§7¡­|ì(^UF/ÆMˆ¢_"Ñ�%ÃEd`µx¹žµB4Àó�ºe™ýÏŠ˜‰U¨¨{XàŽš•rný½To‹<ÿ:ë—½*5Wň$ðõßuJš–7´!M/¦™‘ÚÆÈä ¨ë&–¾žùC0½¤ÿ‘œ§A¢"±´b~Ê8¶ÃWÓH,ƒ&ƒdó®© ä³©¦ß%žâÙ~’BéþåM·Ì5ýùé€ØRÐÞï[ßfÖ�ÿy‹0±–ÂŽhkI\{Å 76´n:û3Á`²šýkðþªéYÕlé7­Õ°Ûõ€gˆ‘YR›ÒùÞNô}6œàý ìí¿çíÀã(´ UÑÈ„Xqö(æÊ$5Qâ×¢aQ£XÆq“ÉYV�>ljú\àHšf{Ïràâ°ƒ‹Q »;sxyîå‡Q°¾ÄlWÛ^S{BÂf³~>¯8$Ý»BãÞ:0ùðE‹2ߎÎqlëÔ¯å9 ý¸Ñ¼ä¹VááØq烶Ïh]~z•M'UcA\_ôÌ»úžH )Í:@GႹQBÖ% ª^Ûô¤è}.mˆ³õ¦k)ùŽ]Ê!–þ‰I\\ôö±£qcƒu,0ßZ•ª”B—¦["Ž÷´×˜Ê)Nf3í@³y¸ƒÀ¹êQ±£kx¾Œ ýâÈwrç¸FipdV(Œ“i9›þ?¹Ô-LyŽqø‚àW=z„K:;>ÛîÚÕaþ6ôªSTÛ‰ZÜ=Ïd}ôt<Ï™˜k'| Q+àFÍ°znába†ÜS¥ýÈíµmm¸èãl ¯kÂs°AV9› ëV½+ÙAÉw †&fåÂÛ2¨°”Ãv2ðä¦�ЃR! € ~½wu…-zž¥ô “Á û°_Ôv7ûbwO…Uzn‘èñwHskk$ð¬/wú ±oÛMkÿ8©.S¥Ñ/rnµÒƒ}ëÅÒÔb]«ƒ§êµkj u2Š:Ù„Hw­§i©ã¯Å)‹®²éD._nÿ …,ZC´Í‰r¹‚¹ñH7P,“.z4j¾µÐØGòûiè3yÆŒ=;|Yd_ ?�LGeéO¬1}A¦Õ¥Ç�ã7ŒÔ1B°ÓûÃx4P w…Ôæ>: ]ÈÜ–‡iÑÕ“>Za_{Ëx8ýª©.‰Ûvd“K¡qÇéªßÛ—õ‚̉ÃAØô›}T.¼[PhœhعkÄœˆdþ¢©ß™ó#¥ŠüÒ…LÆíDêÒ͈å·Ït¬Ÿ%Ô�oÛtüž;ÿ«ŒYêaf‘' ˜deæð͘HÍ´Þµ9ÃR¥ðt›õ/°óÆ{Wÿr]÷oÙßfÿUé 2¬O;î#ÔL·Qpâ<LNŸ g¥ºù>T_2AV.‹UNCÄïïÖyWÎ0x-BW:¨ºér´8ÚØ‹t6,œŸÈÖ!KßU®@Ai,¡%KC|À\Pu_BÌGÅuÓ¯ï X=i£¿Η~]üþ�äqg_w“Ã×Ð}¶öæV¥Y› ô¬pð‹å™Ä±$Þ ¶;a0^Á¤éw¶\f†¥ÆÒ.´Jçs„ÖE´üjï7¨ dC¯Ãk“ÌDâ«ÝL 4þý§Ô{ÀèD[·/uLwD9\”m †Î*=q«p«Ö¯‘ʳÈWADzÓÙ“n9ƒèë’µªÊ¾¬øWyƒ?vï�(·’üT�hNbZâ?¾)Yäüñ ðc†®–…íkÇf~Ã] ðkÀ`+5'Ç2ækkfÝ*×Yºž|‹>%7Ggîå­=‚4ƒ`-)"jrü6ý©ãªéNLÕ¶F(|[1CÊ3å{ÍRÒ§‹Aø€~Ký§v%CSØ¡Ñš§¼LùgE7}¹»Û ïeÃJˆAeÃhѤ¥`wõ¿åØ©ž’TìÃæŽ"È ºPªR/©èMö”ÍW¶¨G�çˆO»~÷„… •”fòÂöd«E1ó•M>,'SÔ6w0 ûT¤\Âò•íNÿô'>ÃôÕÓ@ðhÛÂRº< r;çÁi=b’aQjݹašÆ¿Íå_zÒŒÿÖ8! ýž3J‚™~à '¦ ñ…îJÃÂ(¶´w–6·´`ßOAxÆÚ”œ5rr¨¯lHfdâ=˜·Ë­Åg`ª©Tm6®»|¤ßÎ5žaUKY´fqá‡Íà*ôÕ�úœ ´x±äñsع@Äg¥A Õÿî{FÙ,:±jÀÙVÜW8/mòRûÓ«©õKÜóˆQ'Àm±ŠFÕjÍBgiL¨(þIÉ%¥‡¦WBs6ŸöUüo¤e¦©ÕLEŽgO®b¿në9ÿ†¿op#V¼ %ȵz£~8OV”EªA™ qÙæ¯*'ô!¨Úó„$YÁï1kôbÔæÐßÊL¤Þ½JX¢öD‰Ò©÷0Ìë®ùkólP`§„‡Ðy—³MžÃ ÒÓ\LZ·þ¼îeK·²X¨óÓYvÄC¸†þ¼< îp�èÐÄb¿3©õ©¿+¥eI*B0©‘má$/>[± `R)+D7Ç.¤×²<9wd*Á³¶S“•†ÄÐ`H4qô½9*—É\=²ï,©úMž]rƒb›‚é:k¯¥¨#0©³è#Ìä]žw#%âW#0ÿAËœpeAºž +MUÝÐí­mÏøe‘Îׄ<£jI^„4^‚xë…šš*Ò‘² øBÕY]½Wy…c­šx×ÚxIjýÜå´è'º}Nu 'íJåöxbžyy ÛŸ.ØPØ®a�iŸy”0¶³V‘c_O(§žÍs¯çÍ‚Õ{ kàÛi94­¯Š.=n¦ ZWVü¨ zÈK7­ªc–a�¶�ýל“‘Øõ«í–yÆ?܈šàPX}r#}‚à…êûã‘(Z/0ë[*ú„±¯mBÙ›lÐzrHtZ´-:ô&êî|m—ZmÁ¤Ó†êÐËÚ³\¬xÀÌÕÞR¿Ü|OÍ&ñÌ~2ã• Ýsh—³Ð´¸ï"Š=D�é]_â`Ÿ$AÜûýg «ºÊ&üõüEQãàùNÛBèÐt–C[‰Ê’¦Á Ì´ûLîOÿ&ÀqÔ«jC8öVã]"ÌÝ@S†W¢tͶbÆpb±FC½?ý¨œÛiÒ#së³ 2Û0ÆGص;ëL5N½0¶ù-5èo?VºsÃÁÌ%#v±5É£U,#�Ö°ÒB^Ïæ•öe°•Æ³©èNõÖ^.p-Q¬'H[ãÙ£¢w%"4!æ™ö'O:Kó8ÓéþNpP‹b±\ w›)V­\y®Û$hDs _ÔÚÁ]=@'—¾©$›ÍžéV\”žK<.ºi™ݘAËxÜ Õ`»ƒ:\´ápR ø¶½+˜qw H>N,°=»çæ.•‡æM @ø©SR ÁdZÕÙùÑÓ7Ìâh:¥]„}«ïÇ:‡`¨<J*•ª(ýd{]ÙBs.‚ŠâÐÛkîLœ1(üWÌ#ôûèÑ?¥5d‘Úa¤Ê¿QÜHLÇnžO“­ÉUÇõúÕTµ®)iU;B+ Õö–}. œP£ÚîpäYóÌO'sq«¹%*2¯—†Bx²idþÏĨ“`½!>À}Ù×€qZÐuMÁ‚bzÔç!æd%Ü=»õ “_c=îaÆMÔOóäÒé!1$IIØ?%Å¥©¯`gÀ2–A´µ¸ªeºþOÓý€ˆp¢¯¿B3æ.}•(ä󯋷‚Nö˜ùÅûËpiÛ·ÝT£Ð>Vzt`&hAºpÚz‚Í ÌÙ‹ÈÃÉËðظJ´{ÎÝD Ä´¬6½YÂs|£ §—2¸KJ¹ÃO±3˜Ð´¥Ž-àȺְ-“ðz íx�:Ùi˜ ºÓ]>rÈ.€É8J�ïïcݶ¶ýÌ0&Ãúz†“)û<3¤hè9äLâÆ:‚ÜÇ爯ˆ±,×ÉêrÝ*<ÜH=Ä^˜æ®ô©¡h[;³´X¯CKCnúùaÑæ¦#" šcS@ Lçm¼€h5˜ù©p¿ÕâŽ*êåw¿Ú!‘ºàDÆóù\ãCX@b¨0±ÁÑ¿¯>Å(ëÅô(‰`�z˹¦ó¿?z¤!ƒƒ“>Æ\ŸXƼ¤Ÿå8EjËn‘„fì:)Ô«9uCýö‡âO-«Xº‚—®K4j˜> ŠwÍ#¦­ø{ʲªLa–p/nÓ÷^T<^TY„ü˜íqÜXÒ*Ú{=òÇ|zðÛÓŽ=J�}ã œì<’Oâif½;©þ”Ae¹_lÀ(�(,5dÃ1 QU}’`ìÀê1Î_ç-íFö$¸C¼DPÜè¯g–¹4—G6›S”'í‘~°znïn3º9Îqðk1 `}KózG¹*šöãt°I[UÆ>lt˜éù'�÷Iì-—ßÝ'zZS6«%‘l€íÆñ¶ì˜Õ¿Ù�‚®¶DNV{úÔ©í¦ÃI¡þSõf;YÌ åxçÊ–Ú6&$†I}ÄsÎÛÚiÛÔ™Õ2o—!ÜÕ³WënðáÍ™yevÁÒc#}ðâsöŒ>Ô“áñ€P¢3^<HÊ|K=ä¤LVÏ̼ÙPŽâõ°2œË ëQg¾^}û)zï¾óÀÑ”̬Ž÷Ö#q< Z-¾yìre´¢KŸw�l*q°)Š>hßÖýî–<n»ÌY.ÃÝ&(?â{†Ë0gkÉQMšSS$D"óÞËÎÚk6U‘2ªØôÔ)-×N©7½e¸‰YŒÆæL 6îôëνb´ák‚ƒ3QÎ7'|€±P 5݃@#†zÇ2MMñ¤ÖdÕ>D,ÀU°8᜼µ*9qê¦ýFèã5ßäÔ÷°Nà àÞ¢Ó[¥VªÅ@VÝ0î  㵖ŦʥÔm¬‚ª¶©ðýæ“à¤e·È°÷ËÁR4Mᯡ$*ý´LS2k;gAQÖ›e ù˜ÇÞp(|÷’I‰Ì³~dìj¦¯wgoʳ‘ô%æPu'«ŸVJê°:Р¦ÃoBÓýk£î趣¿>ÚêX¯,ÌŸ.·ñuû‰ØŒ0d ‘Ua–gP¨žÄ ¿žÂÿⶖþCå"ÎèÚúÍX£ËR{Ý=Š¼@È-—|ʶº“¹ 02ß®düŒ–ŸUÞgÄëI³-m]"rÔ½4ÊDÞÈ:¹´ÎŠ6¶#öûî_nºÜs–®œ¶ú§M² 4I¼Äï…Nà¡BSÞI@ÈŸ-Ñ<•˜‘·¬(67¿Þ4TOy�?07‰³…Ÿm‰1dшس¨©çÉ“Wéžë×;vŵs Ì’÷A[h… ã¥ódí^fïzfV8s qM™¯04=Ö'@Ð~Ù7%JÔóZÇ›{8ô³g°Íž×2 Ñôú„#Ò»ÞÓœ¶A€¼?+ðg³\ œÛÚu¾Ùð¼›ÑZÖÀy¢WUÊå&ûM˜‚ÜÐþ¢2ôýª‘ÞÁsxV{#Ð'Žl% .v¤´hË_ÌУÂÐÒ(F÷éÁÎ|óiè@¹¸ZÑ“Yš¥IͶ:À4Hqsgˆ@_}競VFÀc.àZ{Z† Ò[WÉ$‰ßþ¥¯69ý´+9»¶g>KiîçÐÏí¨xkOÎ5àH+ŠW•×+ÉÍÀ0<¸>=4NãuRVŽ¶WrÒŠmQ|^ÜlˆÍ¹ê=ZsSp_^æÎÏnTºÂÂç\S:Fy}Aqj²é±ù]ÛÃa¿ ÷^t7dåÂŽ.…KÄŸ[O{ôýDå‹Ê€L»¯·†žÂÄ~\t–ö,&zJ·êÓÛæÌôµÅw¾,ZiT_&:I£fëz#´³ hKÎý•E¾vÁúe•KWK£*{þÿ³ö'Û­#ɶ�8F~…FU“Œ·Ð7C€� (�<cÕÿGÙ6sswP$E¼o½„ ¸›[³›žÁ»V%š‚ói¥Unj3ÍòAheýôud© Œ{æ½VEÝ9]0ƒ óTº&¶#ßÿå~³2Û¬×Âå$}ivõ`2Ü3र…4Šî»6.ÝåÃX—ܬdQæUÀ¦Ï´ŠÚê OçŠgŒ¡þûQ¸4ý¦kÍäÍu~‹‚,‡2áà%Þ^³uœ+ybÿáðݵiþ¾xº>„hq¤[å©B ˆ¥JÀ‘ ¦ÚÐKüðþØ7%sj%ò9¦{Û^O»kï¬!‰.kø¥÷·g”û̪²–é¥a̬nöW-}GeKYF›òD‡xÝ8Õ}ž~˜Ì–™Ñ/Ùßä¾6›xmš2¨¬{vÔkèSƒ {™°ØN©9=~ æU*ii!G‘È’åMïA’)¨&¬Ä(«BèA+æ‚­‘Ÿ´§›£ÊC~ÑÑj;qAO{^¶»ú&Ò“—þh6Ì1ÿ¥|Ýy<TF×Ï6 ç;EÇÎu6ÿ¼—Áš�¨�4¸¥Tc-NsÀHnöˆÙ[‡‚<ÁcÈx™ù‰óˆJº/r»c«nÎÓ¿kHâÃâ²rSSF9RùVò,Ë%d ¬‘¹Hm„¿]Ív¿™…©ocAË°ÝÓG{÷±Z»ú@§!-BÉUNܱUì.XO&òl`p}3$ÊõO(?½’ȶ 7Øêˆ&ȵÿ÷Íh.Ç zùµ=OF%\î.ÿÏ / ‰ò{š¥¹§²ÜÊ´£…xÒÔû|É4_åµ°¿µð%ÎÞ¾Þ> Ú8#\bíÂÏ Ãâ€q†‰÷K^¢mןöZ=«…"–Ñ1kU´N¨Ó^k!à]¶8‹)>(ÖÎ<Иíë‚“ÓtVc~Wʉ 2+Q7gÕ%i¡Ëßyì~ƒR 'uxÙ>7 h=¢­X;_ß2ðöLØœQ¤,ûW†#yú¸‚’2ã"H?¯žÑg–<½™Y€UšžeÀ‰§²"7¨Ÿ1Zª¯Î«YÆÒ, f1õx:b°¢ŽqdlÕÁØ,"÷έWøºh×–«Ã¶ úl»½Ž¦+ÅÖ^4Þ©&ÈÍ/GŒÜ»tlÛ¨ö07÷‘P­,J¢\Ðs˜SKñö¾œôSôs’ûš{@ª”ñt[;ŽXÜt³¨,ÏÍ/úsH~(©àÇntR”7’ÿT¦Sf·›Í­›Æ#¨˜Ó‡>cÈì¦úÖ Ûîù.*6Éè…AFGèÆ“%ê•Loî;lb µÝQæµ–iQ+Ÿ `g·Ul'q8,=/š�#:Їê&xiŒãX†7ô(€ëŸ“ôŠÈÜòpSÐïŸ:CËõr]™T¾ð° OeˆK´cWáI§ÚP…ihwò@ȼëÎùøÞêÖúþ‡öÀe :ªÝ™#’·ê‡Ñ¾ÁMð¯/´xÌÚù ªœ ·æ:‚g5†féÌ°HóøöÈžL²¶A;±7z||ÈßÏ™ËÌ“]B¸‰`á8Ù± ´0(+ÐYà B1Úä!Ý#ÂèÔ{=Fúß[“—ùé¿–ƒ§™µ¿azF(PN{gC‚j‘"é,ËñÂL…æó‰NŠcmìdîæG_{O&Õ%èÆ[Ë8‘WÖn:Z£à�ã¬N°º´N àS¾ñŠÒGo· ´ Ëælk+ÇÞŸÕÑ¥oß% ³âôt|kø¥¾ DtFéíž¡›óÅgŲ˜öã%#rüfN¬ Ð4®À2Z,¶qì.ð>´˜â¬ nq²Xýä[|TFU¢ùØ¡º½pÜ¥¬,øM__Å«@¡üV¢$v£Wž˜;ü‰ÉòÇmd „A4òÜ…iK瞃ƒ>⃠׻‡nVÄ5ó+}ˆ€ åt®pùì fA6ç=¹,‹. ð»$gþ¯¢GOÝ®¦¡è^ô­UÀÆ“¢”ñh2¸×êÿÇýyR]‘Ðï©þ®4¸ÙžuUðÐoÌûè?q¶’Þ„: ÅßëɃ_Q`[ÏS^ÅEÕÊmÅth²®ñÀ9GXž¬vµödî_ÞiÏ„™oàoàt:©B0Ö*VÒBu„Tª’‘œÊ)ûˆ>”V«JŽ¿Mÿ×Æþ˜­þe:ãÔî\9�œ_OÀÄa ³¤VÑÕQšš´Gùõ°ÃßCœ%i>ÇÓGÅÖ;âó™;i…E1Ò?Ò©óü[ššÏsx±BùJȸã–+ŒDý"Bß³�E:òî÷Ù³á¼óO¤SÝJ2`e‰X¨®ÓÏzó#âœKG:VtkÓQg(B M-9Ôgá¯*¶ò€Î+ߘ~K§[êzX…ȉ:‡¸z¬VbÍEÃJ“¨™j‰©ušTì3KÀ¶µã†¾Ö úêҳ׋ï2ñ¥Pô®.;½Aõ³Ïžr_}í9UU$ŸœŠ 1(ÑسÝÕ$hÚp³ÉcÕwÓa㼊huðJÔ‹'~IäónÅIÅ[aæ%ÊF[©è>¸¶hp§rŽL! :È%”]­µ 8C=ý7‡e¦xжÝ,ͽz¢”Y€µ”ZypÓ˜I ’òlèéq;ð¿oÜã¤:³©­LÒ ¬&6ð�÷o°†¥×s‹ÑŽîkT¥'ÓéBI¦ÖW’i Æ \_·ør‚½ù§r–™+Zb¨>WAuÖ»˜0‘ïä<¥~§øœy¿6ÜÖ&¯ÔW8óö[ñù 8~0Ðä»KÜZ7cd­–v`ev×ßP©Šþ°6Y»Yÿù}.j•]2#SÕ°”ºÍXrvÂdPÒï$|C,“1¾úOB§äâT‡X ]5ú0¨{Ñf cñÚwì/ð P#,—{‰œnÀ8!íUlÕ€@E‹nAÅ”ÕýS»HßIé>ŠE.-ܶ®N)Ô‰7”öÚTœž€„‰›×ÛÝ—¬e\YÌ™%#`éŸÎlík["¾7õŒ'ÎDùŠ†öH˜5&¯~®ŠéÇ&7Å`ǧ!?Ÿ$y¤ Ãô`B˜K«K¾GB¨êKÉ^Q®tÎç:Ä èÇöªg£(Y��}0ÉÞŠЪÑ!òÄ 2å6,ý't· ;¡�ºÐ µ»?œ¸I+ÕJ«P´»9S,z‹'"Ç µê/ÏM–Óy^¤ûî¯â¤ÕûdI)è=}¤ð¥o\G�ýhª ûºªµ\SŸi#‰›O°âÿ×x^t~FïÜM­û·ÄÉï÷郞m[…–ÆñÝ©ýìÉñîáÔhÍ_qà‚hÚýÊƶJV.3ò“áÓÃ’À´UžÈçã@Æ{»U÷ÒîÚ$ôw-E7éa§›ÿ~6ÂvÛþÔ½vhx¦:ÆPV3ÉŠ`Úì: žÕm(éü²ªË<£sÆB’¡¿XÑçÖtG>´Z&àûå® O%C T=‚,wdéàál¯pÖêŒÙZ^ŒJš/de­[ÕJ+ä ‡-ÓJ9lë/û*Jμú¾§g…wÒquÉF¾©=ê`*}:Obº"úAbßû²‹oYš“]ÆÍ6Á$§QÂà8¿;ä.@#,—hõû8ÝþÈ’´µ€ev”Úz¾÷ á@Šnf•0-(òO?¯eã¼ac§Oøä©¿sÀù[ªÄóæê¦Ä\îq?­X6³‡T Ê óG˜lm²±?CÇSÑeÌ xü—�#fø¿ˆnÆê‘qA´CÚDùû—¡A{=®Ô÷´>¿7Ó•`bO”õ—=ûöÁö”]xŵS}µ† úÃ3Ù{'Rª^07¢-¬NX©œbš-–õý¹ßN"ªÐ÷™3¦¯w0å`„ÜþF’ÞÇrkäÔÓÚ)Ü2L'ëF«ðÏêCôÿß¾’Ì®�ï?v=3êY;Ü+"C›¦£»ªwżÁ®…Ó~ô›·Z‹zò<dgt Œ}€üÒ%EúN°%mxPW&G&ÎŽõ‡uÀnw‚A÷.Yw÷8³ÇÜIZºÉsMÙ,~·|Q­&7J±}î æoM6›:zr‰õûŒX. ëÕ9ZÄÒ/ˆµR¤=£ñx2h2Øü¡õf/y`Áê…&Ñλæºúç-¾?u$>ò7ûÆ5V#°T+x&‹ßè¬íS¢”-ñü¯›b Ñ$1†ÍkË¡¿w�ÊìTKì«ø2–²[úðçÖ£§öãx”Ñæ3ƒÐ³˜…¹ c-=ã ôrƒgVÚíë÷½6a L-ƒ7îúÝÁâM’ଔ¾\˜!Vß•Ajyì,H»M'è7Ž8,„õc£øXvÿ:šk_ô˜¦ÚjÑvß)<ÒLûª¯/wZ׉jq‰¦$íŒ=fñ2zááÍø‰okÕÜGâ¹Eîf1óÚ€jktö´f-®oÅ×m‘,1¿4Èä½^‡J•2Ù¨0çU}/¨Þ=€©'=Nï; ׆„±',GIm¤;‘Á,nÂô“ßp¼®ì)ÍY:¶r Ï”ýuë<¹t˜Î‚©â®ÌÿÀž·yèëûÁLt ?çÁB7²öo"rÞ0} nÿ{3ÎÇÓÎ$Œ3ï–Ð^f÷¦ªYœðünÏk•¡7}·^zèçäÆ"aËS2³trDçÇÚ)1ßñêv‡ù^¨, ‡×Dï6€OÍÈ7èUƒ¨(ôãœy?³ ²6×Ìl<Svêá¡k½Š¦Ã—Œä•Ž-(š¤À+Wõ<8ut8Ç_½+`vTLí5v˜áV×ÿïÿK™7w‹ìÈ*L«¨aS•AhÜqèÑÖà5gj£©k[o»‹ï~êYèK3n˜Þkߘr,tH3st‘G±Oñ c3ÚYÜ3XŒtSÙÀ³^ Ņð3r·í(1Ý..Œ­ “æ̼Ø]tS‡tàB]¦Î�‚ßWp#ïÃ#f|õ$BÚ/@D\k(U,hm¥Õ âTEMœ¸a“Y¬¦ðåoyçoÈ{³&ÄÙf`•ž#Þ[÷@ m¦Ñê.nȸ… m9r‰ˆ÷•¥£c"/uòŽà+�À¿†%§‚kŸpßZ!Ò‹ÇÍÕºoÆBB¡51»ÁÕŸ›êÑ(òLC8¨6ôH«“J§iŸ°ö½cš¥i�‰&ü–™‘¿jù*­À´2S,M:?U±’< Ri‰÷¯ãºã4§ªÚ:ïDµ¥œÄ:°ÝÒx:]ß ŠÓ1ª —nK'òòì\(½,ÓÚ'åI ŠTvÿì.]'¢Šê§™¾+ÏæG½)2w[áîüÊXêR«PÓ0à¬hU§�½Y°s5¢¿^çùŒKnöçœNþ«?ÅjöjŠËö<twõ³˜zªjv’ ãkìp2´VpCïÔõF¼�.Öpõnw‰Méý QÉíhýöW×Ú'^­ªKùQ1®"·s.¦AÒÚ¾~ÊÔ”Á÷ý ?EE扔PÑЭlþÂrÖ~Tr°üô³]š¼ÎÄ0‡²ˆZ5',;£2RëΙà!à7 óŠ¡„Æ ìöüÑ€¯0ﶚ‰9è~#öbݦCVI¡·nŠ µ–hH^h¹Qw0šÄ—ÎLÕ¾]˜NåÄ­U×j²ÄgãžFÉ<¤†“ý¦Ùt4Ý c3Êä.½º£os;Œ'¶ ûPá:ÖpÊ\UW¿’;ñãÐõíÛ4Èß¡n×F€wt»ÛÖ#$b‹ •ÎC,¥¨³Ë<k(O?KªõÛSDqœ®›š'L ½Ž­>:¸[9S± 6­±•�bl-JBuÛ³ÃüÅÃÔì#¯–'WX·Ï¦—ƒ±†9Ä×zšúÎõ°¢Ø4ì<8Ö–nêô«c.ót™jÑ´.âÆ;·”Ðéæ[:¦¯6ãÎAñý÷¬øäÆb<¹î‡’BÖVµV §nÏƳ²¦šr§õüuá×bíÕF8¾[”¶WƒüÇno»¼‘©±*ú¼ºþý×ÌÃU)LéxF Vï;:t`€ËqÍßÇÛ~ë%üHaÉÙƧƿ‘íÎ,u;zãsd,~yîdõ×heæ§e{·WÐä-'ä'geæ¨xjPæ[•ÁÆ­rê²hÁN¨¿:+—›Â®Ëà .sÞØû¨ç¾®$§2ÁºÚ˜âÑÂ(Þ[#p—jcßLÝíaP—wˆ<)£2O.–L<I¹ojU,§±9Ø/Ài˜üóÙ@<QEŸÜØÀ'ÀŠlØR4>VöL‡yS[?„MÝM'Ô>WÿÙÊcŠŽãëH·¹tš×" rÝò·ã@Äî7Q¡¶à™gfSñ ÅŽÏì zWò?èþÉ­÷}Ëÿv¡FYê”Xí•ÿâ4kÚ ‚ÑYQ­þó¿ÿ«Þ@]aæ…6çþì5 éÐ¥À¡z!¿µˆ•e†t.•JýîšÆÈ ú~4EØ/ë•(ÍVvPhIœÔ‹qvÿv=ÔMýµaÎwuÓy®¬CiEO’Ìä™q¤2žCLÉ‚N‹¦,0š©µÐ¨Ùí |/8Ú‹aæío ÁùÝ…„[Éñôéy3R½~„±QS¹ÛK¾ÓVν6'wR,_ô00oÇ—ÆC©Bº!òúM¤:Γ(6 N‚ÏÚP–±n]QÁV˧N'+¾«Óú‡×ÅÒ¸!õ´ ò½oN±G‹Iç-×ßh¦TžšCŽƒˆ»Eå . œ{Ð-èzuˆC¯A¤ò™J `>ºîÏë,ðÔ·Ýv‘§½•’ÈVZƒ‰{eÙÊx>bRIÚk�ÍaºÁÜRÛ Ì÷E.ɪ¸\á“ n?Ý C…åÌHvª·²öhšÕuòɘ}wd¼æ14ÎZ«†Jr%Vm÷ÇÅÉJú†ÞcèèÑ%¶\äþpTá¥Ótn÷£{Å Ž;øßPhšRõÔç¼ß]¢2ïÙ]Âï}þ ·èƒKl.rŸç³g­´eVEýà§[l™‘“œ/‡\3II D“«["Ú«~qRdk ¿Ã‰þʼs~Ћ“¿aüé[Á€+‚¬ÄÅÎG>‹‹i—éôA0'1ìŸÚ¨*¢Âo�ð iÎ ‘_¥ ¬¤ÃJ4/0lãx%TC&¥’Kgª…Œ[¹cO5ÖðµþÂÇ]Â??ÏÊ‘5äET̶Öâ Ÿ;~á,D›î÷jTÈ?Ë�ú°“<óvl˜f¡ï‘«Y¦ÔYžx$=SQð|B¦sbŽœU„°±ƒJß`2ã¾>,ª1©ÜŒúà½`±¯ÝæCëÃalî9‰qâÚ×ô)§Æ±v f”"û®Ö{û<ãШuÊùøÊjFnAr·cÚQž^;ËŠŒ!›m+žÓŒg4?r2mWá)w)N[O'F¾ÃýþÁs#XËE6¬ö"8UÑ£ ];¼ó´_÷P­\Ü‹æõ†ñ³Ša3bXþµ¢ï‚„`À!«úx„a-<ÑÕî“ ±‚”)0ѱû¿a“[Qê07~‚ øô ?ºŽ>›kÎߢ™ÜCÙEìP\ú5¹öü¾>ظȧÐ,Ýοî[D¥OÓÁüÜ/âR%I ;{nƒ?Î/­!ºB%”g”û«×S¤ûÈʱ—¨Ž±~ƒ"Í•ºY#j4^ß½Äàj`®Iúz¥žäNè‡N—O8R¿{qmÃAžÕ"ŒE/¬·‚e\ðñ¤[ �„Me²XÇÄ" žÂ|žÞmRìFù’ö§ñÜÃÓÿýá_4ïzÏ[š¸À%"+—vZs”j½×žQó‚r©‡­1šÁ;Êç£Úê·TÁ`½ía?.è<j#oê‹þÜè÷-x{]G ¬ Âæ®$gäôMž0Ê ·¦YæðRA:yƒ›ô:ÍZ¦:`¶À ‹Ì OµÓŒ»P‡\P¿þ5w ƒóÐ݈”K¿KÀµØÓ™W™Ö;3=^ßóH9­¢qEIäQÖhî~­”{ÊÚµw‚üCUñ™?’Ž|füÏyïûñØ ôÄÚ ¦ãüb>÷r× !0ÈÌL/µÙÈh4³æ£tL5+zì¿’ ìì𤠤»cF¯£”·{fÞyîèktïv¯9‡JÁ°özOÍñ•Eëk¥ƒª~ l˜‚ á[J†öÎ<î_§È*N+‚m¢¼U™lTóǵ³½:1ÿ:Dqâ›sQˆè\©>•ö“2�éÕØùt¥÷<'ÛÝg¥eæÙSDL‡¦ Àè”qîiß5�þB vvG{àŠO-a�—¤ã¿?Õ›KkòÞF0sLdJV/TyÑY0ÐR+kmQÅ1æCŸçÃPÏßtAîú<ôYö˜ƒ‚4•¬8vÝñ„4c安Å9ˆ­X7?0-3/mD ‹ƒd¿7Yc M‰ãuZlÒ«›Pyj ‚ÛA×1 Š~rƒl Q÷c´*ÌßúŒÆ9ëV÷+í4gZh§‘õy¥Àˆë{Oü†yš+ÍÀ”Ò:!ŸNÓì 4µ‚ǹºÈa.äŽ�"ÔÑÉ÷m‹«ø¤Áòd` R m*™ƒ.ÖÖ10®öõûñï's<ÅíµŠnrZœ“áϘ“˜A¬F﮾ ©ü­ÿòR{cÕ/”CÕ``^5à‰s¿5Moê Ù1_4 6¤‡†; ŽôC7‚˜û¼¨ŽþS¬”±Â2ØláVÞªöMÂ"õÌ~û£Ñ”i#Ó=¼\7ýy¦=Ýç¶~Û\¤I´ïýŠÝ~MàúŽ’°¢ßù…­@ÃôŸ)F @lƒôž­–ÇöŽMgRø%^_ˆ<ȾΞ«(0¡Î€õïÔQiû±/¦Â™ ¤fš<q�'‰É³+üyΗÑÍý9œè©gg¥Â`ž¶ïxzb ±UUUÍP¦ÓÒLò¼•1‰&aSŒÎ†u¡:Ã0îfw T¾°fŠ»AÕ"­Ü¯ÿùéŽ'U‘ù~;˜©Ô|¬Ä<„1§¥ƒ³Ú…bÍuà•Fë¤o¨B?Êç¿Qz¢Ý| -ÚÓƒ)¾9¨ä8Aj'5«v„ž­%4H¢‡Û4EPõÚîg„ÇÁòô)»_!+G*9RÁSN¥à­H’yS6Ôf”÷Cå_MÈî©LíZd‡¦/‡Þ(튅Þbþ0J®Ý¼šáEŽkÂXyÉ=ÅŸ‚Çšgq©wD­ß]ët+1Ù“ªOA„Æ*ó§TÞPH¦Ú<cæÚ‚;×Y`ŸQ1ÜyojÛUöîÛ6ó¯:ÒeqÓvÙõ´çZÝs‰~~®îë¦éØ÷eöfä|ÍyHÇpÉÙ_ÛÙš£yÕ}D{Õ4¸ðPº¹šV‰=u´ë๚}§»?ä½;2I¡Nª§4(-A‚ra›îð¶g++øãÅšã ÒÂnyPì$»Š¹åqêPêŸlzU‹î¶¾ÞiIGN—SVOˆ( ¢óäzèFJYS”ÂN2ðó.ïÌDcæÖ,Î|Ö,úl].±£c«sªT¿T&J/z2›b™(&´goP6¢‰.4zXÜÒµ6ËVf+N> åBà®Ñ�³£èÇòñ?°aÀDDIy3Û“°ºZœ¡&±ž³Æ±›àrÎzäÕû¿–¹Ènµµò_=p_‘(7‹ÇÃd‹GmiÃ/ (f™Rk]¹>0¤IÊÌË9­‡L7,¤Í€Ç8œ Ê3Xÿ•»IÝ“ü.)Wí„Œb?üYg qÇÏ8IP¥wXej>ôèúûiåØɦæ¨ú7ÁÅ)L¨{îÚ±NÕ$:Wh¬2,uS¼bÂK)6…Ÿsog’« ;»š—›—q™ÜÐ1.8 ´Àã`=Ëo¹ÖCË»ªôó˜üôñÒA¼7T§ìØXÍ0¡øÑ!ÍÞ#I:ŽÃ¦;qÛ&e‡¬ì’ÈO°éùŽ}N{ãì$é[Š@ðPRõqFýÔÉz¬ùï¿ynAÑÉö§(þ. ±²|yº@‚§שŽÖ¯Aw^F@Kµ=qóÓ-ú>IÜ™Àð¦�ÜóÝÁO]g“ õLã‘gžëŸ ¡ÉB²·#_™hQê»ÙR̲Lµ¢™ô8xB&5¢ÿ0ša~¢#U–.~óÛ6Md{륬¸ÕÛ… A>£Í–ÅÔ›p0ÔøBSÌ´ ”yÄ»Á¯Î¹˜½ÌR}³kKðéÕ·6Qä沑ËëG|ÖÆêy8Xè¢þ¤*ÁüqàGºÅå^Ö˜z9’™"=T‹Že­=íÌ7̵ë9€_Fÿó1ËWÎÚ´ß0ù´˜é”ý¬ÞÞ–ýx¬gÜ¥—áðkiK [›*(žSÌ=,Fà¬?;8oâÐF9ÆÌ=B¸tÝâSÇôdœè´bcžLñá1wü=…Æ’K“[ô3&*Vy €ôÑ/5è'•ü@09 ý2 Fÿ˜òÏå꺊[:_è›[}ySc¼i¾þñYK9/«<uÍY¨R¤ôÉeŒå¹µ¾æg@ôz¢»qõ®^n'* d˜{ï<ýu¯cñ‚Èœmñ[Ôc“S™üYûÎ=”¬"Ësì[“à>c€5f 7ç¹Ë@ùbxÕÎçþÚêÌãzzÓðâm·¨J­IVøwwz[qæ‡äx#å`Ö@—çæG\ è¿í$®<70Šœu<:Ñ”× UõïÞ)2Ÿ,¹lÝía踿!b�ë¶úñNÓÛ­ œ@ùSÇþXó‡?vi¾ž6d+y(äY>}yèÂ-î5V*lý?9Ft» Kþ@7¥¢C'l­ÔòÄ#Š¯ó©û;%Åè?IµRÛ…gß…K}9«I]}‘Q>7¤…‡ƒÑÌùî2ìB¨D­ш”šKŸˆÇσè'.QT9(“HiÀÓ/ÿÚ™G ^£".*”@äˆÚ45áÔŽLþÇûè·x¸ p#{ŸŽþÒtüÍ–TëÃGˆ¥7äÒõO|ú×à|0U—EŽžù BUÎÝz>u‰£ä3(XÃÞ‚×8‰;Y«_n¢#O½wõMÎ÷Y¯˜QÿYgO|d}˜ú÷î¥Õ’H”FWìMp Ò±Ä7t€\[– ¦f¹%®pgëtEF嬅–_Ì’4ó´wi‹·û’JñYþŠE:Õú/)±¨¶QœF3W06Œ´ª-,1Jì`YTáSWͨ÷GçVm~³Ÿ*[EÏ´s¿4Á­E§Ç›¿CÕ©j:øpÔÿÞïž*'söX{ê™Îÿäë⊼‰Ù^‰ÛZ@ ÑIû@af5?¸mìÓIbq ¢äò°{á¼Mb_Že²q8~ê~,µ‡Kÿ‰‘˜œë/Àøбı53²|÷2–Y×V ¹3•�‰ °ö'ŠIˆBþe]Y‹ÇÒ¹"„Aeå(“$3AVÝuõÑt7Í<nÚ5ÊÅâ䀻1�-¹eb‡qDÃÿ¡=3xôö¡Å‹äæÕuáÃCè³ý¬Þ®.‡¸“Md…2óÄþ¶¿C0¤•§ÉC[ÞØ\W¯Ì"ÏΨ ö-%%'ýÞ)è4¦ü¥!(zÜTÄã}1Ö&¶^†`ïY›Ø÷lË<úÏÁÿ6?!Qàò­Q%>”œòÔÉv~«ýÙ¢²<N9Á¥Q®áÛW*¬"4‘˜oƒ Zwc5ýY ¶ÚÞ„g§ÐC¾z(ðuÁàycrîZÅÞB¥ gH‰ÍÕô »¯+Uë¨õ@ú*®ò8ó„ÞB*oJÊ5TW„å(fjÚô´¨©"ï‘1ŠGpeS{ìAújô~^Û[·—aAÝÙ[¥ëÕ§XcóGFAZû™r¢àýqN•à'RAáx0Ï Îh>œô Øì á”S ƒêÓyqCK<¯±_ó ãU然ھÎ<‰&| ÎŒØj´2éË#q"g˜^H=Ø:i×yHî!{óÕ´ŸÂbU˜Òé4A4ÛYá±ëÕó&Ÿþ?×-·Ô£›¹Ðn.ß/žç•l†+L‡ë"–sæí¯G¶i|ì{aM=YóÔe�SÐê>¥, CA¡·ÃYëoñÀè"vœìÒhy7{¨¡´'ë>d Ò™þ?U†A€àì´„9bT뱜|¿-»exø Ѻ"³·ÙS†[«HI.šT›QàýrI–„Âm#šßÊ»ô‘;©?RúÊmf¡“Ïê[«,{û *†7è`·ÕéH·­øªˆXˆ£IGÚF‰"°øÅAaLáÜÙ§ƒ+JagÖ- a.úñÀcÀÿ¾YC¼‚Vn0³õ¬ãÿ9U=Œ¥š\+B±ý§Ž*¨´ë½¥fÌ» Òò[îEüJ.!qZGâ3Ïí­t¯ÚLS·þÏËJË ëd0Ê<¿kqY5ŒXË‚¹¦“6µs öþ(S-Cü–YŸw˜ÖãPLÇM¼KýrëŸÙl;S“‹—Yø®`AçŽûÁù›Ò¿¦z/«GöÔ,Í87¨éÊ}Ä9@µŽéÃþ÷-yûçv¹¬ŒÌ(ßV_ûU;kóãÐäXÍL©f7–ÄLpöˆÞÛÃÊêA²˜ÛöýßÞì`¾µMMçYi#a&J–_LX0ŠH¶´�þNÝàÍ|‰Nÿšz.«!V± Ùù(_bõòƒ—JªsøS”'›•³hJ}†Ï¦,ÊA·‹!4ú׆Øw#@YÊk`P¼Y.ð,?©òHÁlYõp’¯Êtú:ŸŒP‹?r.²¯¥#çj»5ùxb•­¼Ðî|°Ùs3½0ôA7'*&º½‡È2‰§Np;pÁÞLª§IéØQá¹Hó"ùXJÊDz݇eC1iþT®u¦)„”&tÈTJ)„vl˜´“¨ÌøZ]þ°1«’qNuÛ‚éa Ab¶ümg>]85ah~s£ ê.çý4Ú�fñø‘‘êmj˜zL™Òtô§Ì ½vãŸC¯/¦rÐ’zU[+ÈQa‚ÕÞŠV‘çûØ`L)³; R¿‘:²zt&dPr´¥R~X<åÀz7Ôf3´l†,�/.SG§¥¾ YkЂ ç`[çUÌS–3³“lzG¦žê«Ü# ±î%Æ+=3ôz@u›ß=ÑiI©ä®·µ´½î\XÈØ¢LEMª§Ì89 ¤vÁí’âÉ0 ¨ ˜QG·û„«[V#ÐÊK B~÷i ÞmÕ¦éÜ<üc8/’»«c½Ùô:Ÿõ Kçì‹4¤¢HS¾¨ÛJL9ØÐWÀ{à$Š¶»TEO±Øss÷;"2 QnŠÁyIƒò¢uìvd‘'ö¤±~ %KâÒá]h4RQ§x+mK›ùtv˜/ª„$>{VK”;(påµä­PÖ(ê1Ô8©"'=¾ºáÇh’„muW3lযÐJžòÜ -®Bß 0 3¨8Ë­H“<áþŸµK/'gÚûB…tõiåVËÞ®7sñ£XS±~ \P±ÓÄÊnnd.óì§5-<A=9 t°µªÇáüá¡Aû¥A6Ðöˆ¸÷E¬Ñpט‚ !HVÕÏm‘"óSLˆ7˜ŽöÐtOócv—Ìÿw²„[(gz“Ž· Z´OëI‘ˆÈUHÆŠ ëjïTÝtè²töt…€ÆߥbYåþQ(Lô\>[¯z|õ¬ƒÏp˜Ší|Gµ'*³gwp`RãPÚ±Œ´4«£\l6&t«ó,É’Ì‚‘ãÒš7j¿†ÄÌ,ÈørðÄzî]®ý2/ݦ;]΂äŠ0Š0{ô¬ƃ?‘•¡¯ÐIUê"¥'¯×½=LnÝ¿&e0QiÎù™s8+Ë|@ÝK…áQ/˜ç"'´ùJp4‡ž, ¨Ïó¦öS…w\²­†,Áw=ÝÐs¥·ø£•ÿaýEìvi­ØJ1câ²Ü§ópXÞªPJ-Ú*=ç“™Y"ß}CÚSR(Š®=£gváR$c©VC“C5F¹µˆ˜¢a\Z^’<DÓ“L6ÿÛ1òÔ%B¦Y¦qˆ30*¤Â2«5­‡Çû®Œý4Ÿ¾ÜfŸ¦AåXº\ýÜèg×Àà …Ezî‘l_»ëifÃÙ¬°rùRmÙ)D^L—u†êá®6°NwE¿66GÎÜ1&ÆÑÓçÝ|ÑI5‡eG«uÍéxÊ£­œË±¨&w0 št\ aŒë(â‡ájdý(cnæ,(ÛÖc‰xj ŠˆÑßübúVe™ç«f�°UAYzÄÍåÚS8z»Xq4À`¦n[S©pnê‹hÅ%[烾Nƒ¬Ÿ=äŠS2) šhuÞÕ#ˆ°Ì<x`¬f  šÖc Íà»÷tÀÉFk»ŠÏQéiš±èê<ÐNúœ½ùÅWyë ¯€ºÛ;¯ž›·™q¸Dê…®öôXéDŠSbyçe¿@õ® Ö'ÚÝÒî¢Ì±µBV#7î gOZs³E!@ãxB‚(ò•Qìw´æ{ 9‚”ĬÀŨ�óÏgênQ¦‚•™¢âéÈÀíý»GN§U">r:çp¢Xßä±ÒØq”3€œz Ìø¬®õ1Ž“H;É>ÝÓ÷d锟–ž•Û0l¢48BI¿÷T‰–=ôoØŸ\†ÄðhÇœÇ5€ž0)“•~i|,ô%ÊY“FÌ ìÑë„&Ц’D‡¼”5ä_£{¡ìÛ·(Wè$¡HAèë]™¥”¿Ôm{˜-fý· ©È]ªƒ3%Âò¥šÖ“�÷݉~õÀCŽ«4èÏ ³û]A^s/ë¤HÎ3‹îxÿÄðc…4 ±Ó é¦UÏì°@Í gšAõtß³d<ª×v+À£¨MkI±±û§½“ïÂ,ˆ‹ÐY@}¢I‰ßõ¿¨‚-W.:¯Êâ̇ÄhÃXû¯ÚZõi Ð0™AÉÅî½2i×ûŽÒŒC_Ÿ -\ÞâýâÔ"A‹ �«ÅÉOovçر6ïò܆$$°fV˽ü'œvˆ;í ñJÄø¯öÚ½lMÔ£ o?j±2Ù¦°6h/ʦËóÎÓïaT¢‡q[õŽ8m¿ *h.®Ó#¶*ªX·–Å·?œ`F­ù#?¶ñË~ÿ›"YMäK‰Ùƒ¦Â6Åa>2 ¿¹Z÷ˆv’gë‘<­½œâÓì¹É² Ùqt@×Q¼œŸ6€WÍeöó9ì k¨ERê˜`ŽgS¥ ¤Sךfìw%£Ä¿ßq,K9k‡!o»/ü'Æ[]WòO+:Ï|†8•ùùYõ®€|ÙŸ™eîìÃò$5XÊ€i6ò WYÀ=¶‚1où3c®XY$^RS=Ú(Š›Î¿™þKZoF,Iœµ«þ«ÿè(‹Š»[Vñ³€Vy'y› 0RÑüE-”›™=‰ù£`Ó¾Ø- äÿ@Åïþ¥Ø(§ÿë‰ÄS©âµ;ÓòO­¸iÓ©B´?¢ ðh7o“>빫»Æq•Þx%4CâÉb•,°KeÌ8°(¸¢9§¹¯tzOûÔ‰ˆåF±fw¦»X,ajmœà(H¢ëgb ²1§r–fž§Zˆ ½Qñyñä÷°L£L©>&Pó8`ìúóQQ”û6§pܸæA1-f«0ô¯»vJôý5ê,öõï·²ÅøÔj5 óÀ!¼mVÄAgâõy§ŸµÖç± ’zötõç]¥çCò+`€GÛ}Sª‡èV”R+‘˜oÛsƒZþ}}ºùóâA¾yrë˜BxP”«ò úTÁ”ݓب‹Õ÷´< ¿Õ÷¾`æ±�ýÜ)³=¸®LÊO­õwëý÷³á}X(ÙSåî$öâ`*VqôЪœ0ÂÃô‚¹÷¦¢=[P ²v® @TDp{j¾…8ë Ö’8ZÇ}ó· ïH{HtÞWÓ„øÁB!Ò)5³t(eöpÚêYŒÍ5^ø{ý÷-¶¤ÊE"¢¿™d¢vûzãÀVNB©bsásF{ù_5øBc­­t­|4§ôÜ]|d17¾ tE¸BùU¸-ƒbè< Š vC,£åuß^" Pàw;»œéRG°ZwgëÃ6zßæ=gô<LáO¼ºæ>y³ôDŒ ¶b¢ þuf•è´yòO„½,Ê<h[”ˆPÂ{ãÃlçÁÍä¿Jˆbß斢б+¨zÐ 3K›ÀÍä å±ÂhšgÞÞ # VsFN¬Dèô‰¡ûmX—cߪh½¹þ¼Ç¥ÏF‡¯Ö€ºÚÔ©ÜÜm–ÿ¾¥¬™©Ã`ŒoÿahÏt·uÿFœÂ‚ÿl‹Eÿ‰íh–'gPôÚÅt¨Æ=ÎF4j‘À~‰øP–¹¯µ„?OekÕº¢ F¤©<+\o"«CXγn~‚ëŸoÆG©ÃòÉ-'}ÆÔÔÜL3¼¥;ìÑ¢àËf½¢b¥7 m¬$Èû«i€ª=ÍÄ•è?ô$Û"÷/­²D×}¬[Wo¶1ó½¥eõh#8P}VYŸƒ(ÿ€~|m‡tï¸Ìó^®ì)""�8“2«½fr^£A¢@Ê{“7ÒýbÚ|Ÿ 8…›ÄÈÏ[ ‡ gXöÓøÕ³”N§¸3 êxC¤ymæù¾ Ò†‰b¦ `ÌFåæ)Ì+é&hØ×{>ƒ¹6͸éDÚŽ™1“YäÄà ª°ã#Ǭ°X7¡ŠèNÝúܦn³wÝï=ºæ°á›§®©$ô¡Ó˜ò™î`×tÔŒzÊñeÃo½À»ÏF§Å]"Ññü`ddÕS}²M¥Â©kÇR:ÆÏñÐ/¯½'þgÈ,ÝdIý¥^l×Feæ,Åïé¬V"€E­ÀBnÖPkó†îOn¸Ô8 a5th*1e dURÅ™#y¸û•çÖ‚¦³ý{èÍ┃d-tyáH*Ö�ùžúj¬2馜}ãb+ƒ§êõÖg뛵û>4 Ç’ ¶VÅåQàIcØPOÞ厈ùÅßiÙ—²·ºDvvÛPLÈOšÐ{Á /ùì¿&ùø@ð­µ¹N©*½ù±ÛÕ:ÖÙ%xxB!Æ÷·¯˜ x°iŸà)Üi~¨v¯5is+}î{ò:>°2/ý¹)ºÍQÊæ àú,ääŸ$'’ÊmÛ\õ“Â¥v‚½Ø-´¦8½8o·¬dþªzR9(2`TBnG«*ú,T‘ àjAíäi9³÷|ªŸbt…?Ç¡!´5{l¤÷Å£Ðè±·¼a®än1 Ezãî~LhY¼!ÜDG ÝEÙîçé8ßÌ)–Éè:>ø½6,¬‹g€L‡Öëe2§x¤3T_{ÚžF“òö¬÷Åz™Éº¯éÇ^cœox¶¾°“°v.˜Wûú@PÇ7}`K¾†rȪÕ÷æT ¿´pþûF÷I”o¢àóÜ¡äÿ‰˜¹‰~'«WÊÑñÊ5©Ò·Þ¤³{ü¢Ozråe`J7S„b§qâÑ8Á¸N%ë®o¢¡‘TÃI».e¬Ô&6"ùKoC[Å¡—ä`$øÖÄ¿cFòVi«¾¤\f>/žCäï:(ÁÀøRöï†á eøÊæíé 3C¦P\.VP$2ÍŸ—ÃV3IæŒm0JòjÍbv(éX¼E‡ÜîVß¿¼ïjQf~ÚMEþþ ê‚_ŽåϺl D—N¹ $_Ɉ#° o™Jo” ç¦ôxÞPdk·ªµ´%r#f•§ü†[tÖ)Lç »ï–{HÎ̤›qhªÜaÀÈñ¬x ¤nÎÅÖ;zÛטú†ã»ÿ[ŸT) «‚oD$Fòx÷Z¶àE³ˆ"Ì]S¯j3e&ç«w¾ïGø6:µdæP1€àu‡›É 8QhrZáš|=CÝ[  ‡?Ì%Z²D+ CåO'ð�–pùþå†s3((-%”w•)iT€ä챡8ßeŠ°½óH;¥ knûKíÙr¥ÇD…(­Ùwß·¦È®9xW ù¡&2t‡|% JÖzzÏô¼s3#¢¨‚õ…rWÃ(:JkTežJ ƶ€)eý§'qál ö<ö^-½»R2wo ^:©±'¬Û7äÉòá.åpzréżÀ`JŸ"§“ë<©3^W®7Nzä™2VùŸ¶û§¯ÿù—ò*«ÞÊUÁú{|ûZqì$˜…ö7ÏhrZ‰´ƒ#Ðe6\%+Dðr¡æÕ³(l[©@å‚DBÑ ~•ÙA ý-Óp<ô4Ç[ »8ÍP{(—*(¸Q̧´íw@Þp€ä*…g‹œ*Àvv3$aG1ÚÜçÇ ;ßSÓ“ £N‘úËÅî4 ûlÔ´¨H£çЪ-ÈËÞ³k&Ps¨°^’ ²Y!ÊF_Žœ~Ë'?Öm''mwñ$­Úܱ»£-»o»t¹ÌRDA( ŸÆfóe{Á+ü6{Î+ÛÁNÍÁ ¤ÏÞ)\aGéÙAøB´ænú3 öæ.+ð‚`{n[9§¦u$­>nf iÃ(‚ôÿJêf^Êýí{ÐèšÁƒhÒy<l¤›/>#o^–T{9†Ôã´jâ jÎæñ ?œFt…Uw:OŠuÐtóÞ•]kì+ ùÓq’·/?!Ñ;e“€KÌ{ˆÒˆËo4èž*›«ßôÝÔ'‰oq°섽_èao{._‘ÒsÞu¤"# :Ç‘±[NË=`ŸP+Œº¥¦ÿ®@†ííën>uÈzmše\Í«áÎzK%óÅrYy¦PW êX\``|¦i¹AÂ>öOÈ<ïÓP²iª&öZëzÉ°ŠnDí©H¼˜LGŽ+*’Yâ‚g@NYjèù€xHL3þxÅ. òôEÑK™ UvUÚ>u‰[N_¥«7ZfPtå΄û~„õxÕ�— R®¶´Ö�*1£ia­óPâW‚šUéãõÅ@½ ÒOåt¥aœ)ôzÄÿÂA=ó×d ZJ8Ë]c??D¨)>í#~Å|¶Lüv0”â0p¥\pÇ~üº¡I<òlX±œø¦p°™UÅIH8¯”1^SŽÊVÉwøJ¤íäÐ,·çá¿¿ãU~@®¤©ÇCâ]?ã‘î”|¼ [ò—šrœþlÜühKM mDbAY'ÅÊéÝ“h1Ÿ„c Çú¹«…cl^ï h”n‚…‘¥Eƒh˜l­«š»iW«OÈcÃ8ô&ˆŒdÀòé™I÷ÒÛ_TêQéÊLA2λ°Î^ÈŽYVϼßáºWÆ|¯÷�ÈÍ*›¼¹î Õh:WvÚÏƦ1`q}Ï~i®ÍæöÉuv´RzëpÞœ¿ø¤“† щò!»ö›[Ka8X×ÙõäH¾«†Ž1æܸ1!3Nde•f^†™í@2›ÔkÊY'ºg÷ÒÙiÃäÃйÿG:ô¿ÐêŠ\DŸD£ªÏîÓqKë2å­z†«×M³v@ùY#M<¨,kvºQáE½ì?ÐÞ1½L5=Rv»¡"½»èž8™äi/ãû;ÙNdù”SIoÓt⶚%$‘À[;X;3ä§ÎXVûYRÙB,ªÓE+èÓµ»NSËxZ³#£™|êWO”êÎSët¦|óIÇ[�Ó™åÜÉ^ zëÌÙˆ…eAO›ùkkÍJGñâV§„ ³Ú”¯=°æV~Ј¤ÊKl›å–M®‡áã2¯*V¸¸ˆV½a¹L”G a…Ù J±éŒÞ‹½àPDë#H:_]hxø/|Õ›Ü8Þ´uDvÈ…\sKÿ©VÔAÇ"–M÷u×M6+}=Œ›Œ݃¬™r´mÇ(§BÍmað™ñ†Êî0÷>çuíÍO‘·¥+S>Àãµ·=¯TZ‚®o÷º¿ë­kÕÚyœUŠÓúöQUÆkœKïGêתm‹É32ëeП³ ëE$Ò蘕!'oS·;Ì؆à(»à™ªLâ‰4ˆ×,È/ÙçNõ ¹(:ž+ˆòkêKì5)7páNÏûÕó›XÏÆMÃÓ–ˆÃ€2، I¹)pÄ$©òegÛ+ ¥^û?õ m[k¨ã]>¬‘"ÏæSì2‡´ëÉóËÜõ&ç´YôŽŠ7I-T²£€×õiêYæšÅ¾j˜'ê81s=]m‰ºNy_õÏ+CÒn hþOf"û]FŽovÖñ2©ÿ–â•j‘yH øbÀœ5<[ïwž—£½+v!ÀN[˃o ö=gkc))7jJ¹wŸÞ •ªöΕ7úýÝ¥Ç sÏâ ½ôyýpòØçu†%ª@ †_•°O¤P¥3â—J¿Â÷²byê௪ÎËAøêë‹Õ9ê®foܬÉRÇÖ/ynQSÅŸÏ·Šj¸Í*Ðåu™ØÇ1†ps̃êsðv²ûòˆXô|ødß_Ù!ÅfòÛ‡þ|–·##ÿ„þ”NOk8uöŠ4tÍŽkm N{ Ž|Y=ôèûâ—Õ�¶° êc¡Èœ-õ°y o¿`ªv‘yóòP`[ñYá¨èü£±ÁÂ|ÌW[VnË ãª`Î3ªÖ¯Î«›otÑüqD³ðº/šÍ&ÙB„¹“j”ËÌ°Z”;ºÜ¯©UD^“a0¾l)¨Ù9°!~Êix(¡ŒÜ#E Dñh¥Q Yfì›ÁI¯mThø‹]™SõFœÜfAh»ì˜µ ~׋úu{¬y5>4òÞµäR¸¢w³\#1îpú0- ëhê0S`ÞŸûÞ]|g;x¥v%R£1TëˆÁªîNÈœˆû¹¯-1´ì{P�:6&B Ï$(­¼_8Ž»Ü·Úaè, ƒ½²á+o´a—mÄCãpg§3÷¸ó˽z½Ãö•¶œ¹Í+´\Q•+:`Ä zá5ÊäçV9Sí¶öŒ$Æ4N^È‹²4¡w¾°9Îl„jx¿0™¾Í‹žõ×"àÊà’á”Òé6ÕÓ²>LÌ4QÝþl.tJÔŒ¥ßÖ{5�BÇw ƒc„óâÙ0ìê^>Ôõoš'I‘ùJ5´:Ž%•Ý¿^º$®Â–fßú Ý­gx±æ•‚|’­hë/7¨…=E¥á^5E…«þy´w™).}jÂ�1@FY?ŠmâÔꮞ’4ôs¹ˆq)iPÙ AдUˆ 石Œ$×?¡ogQ Ž»‘†á¤ÏÀÌBrcYÆöûÅÞŸsç Ì@ˆƒZÂÉ!Àè\õóVõÅ6¾‘Þœ®{j¦žs¾ßग़ ŸõÇѳ!ëÅuìÞ ¢rœy< Z»§¾â[!H[w8+¤ –ŒÜ®ý•{cU¸t*FÌ ðF™ƒ…D’÷’·\µuÝ˧Nä±3°¢8r˜»Ô8Q•AܵÞ>¤Dgó†°L {ÎÐ!‹NK; ’õz¢€Ý¾¬æ‘zýé “Ný-Pã¹ß!­ø_Ï8¾tsÛ(ž,83ÈyË¥\u‹V?\º'rhiîk3C·¾Ëò n,Â# ||58KÊrªmOà£w¨¤àÕ—8‰ÑW‡øD¼ÌøÞv} ƒËÖ|Y|¢psu.*ZÈ4@þØ +<OGW„üTfÐ ä ȲV“0°¸ØÞ­8LžzHšë*>Ø:Ë zŒ³ }çƒ- Owy?{íöèb Ð8eôû¨üGXýÒ€¯"θ¨–›—,(,¤&«Ô5† ƚݢÝ4Â! ^ÃDy¾rëv_£ Fv×õ½¯…ŒâNr÷[3‚"*”N'ÓY ÉU;‘Í ‚ZÄtâi¢ÑGÉ:ÔW�FІmì:[ôa¡Ý~µÓ“—«ò+ž1ëÙ%­¶DóTÏR»AMnÿ—âu…ÛMlM¿9R€sâu 1Ñ]æs‘nt¬`^´A§÷;ɽŽ [Ì'Š)ý)0¢e:l<ק`vJi£4³5íÇëXåÖµêûÍu¦iÐs¾‰Üf¦tlu}s]ýóû0¦*üil 9uŠWÙd¶8½èì,EïMâ*¿qÂfç¯ÆÕPmø€ø¶Û ƒ ¦ÚìOT|èm£ãü(<QÂ\~6æFPP¢wЙE™úZ‡´è>w·žÃOA¤‘ «a áTL·jÅ™Ä óALsk•çéÙ­£*Ðwº¸Iè· cÓKÔl5‘¡ëš¡ÈÿÔ@_Éäe¢T´Ù©±Ž˜EUèð%î{ûš­¼•zÏäK¸ Z¹…[@j{=ÀŽŽâKk¾Ñ2 <´ÐAÌ÷ß«ÿªeÁ“[#¨sï§í.œ®ª1Á¹…‚dŸÌQ¢ÿÄ©Ã!Å¢ÀO[ûÁâÓìxÏõZ§NháNù­ã3çôi=`å'pÚ­ÉÆK RçR–m7Ðégñ\q"‚•ÝÌ"!šÊžØ¤k†ïÞêÒ‰Ã76iyê\ÃwˆßY“ !L=Ìâyœp¨ûsB B'X¼dïZVõÎêÓhˆ(IÃHjn„^K3ëÒeQøJµ€Cì :½ÎžSü 6«æt…ò¦yø”Œo•B¸b5Ñí™_Ô0Á³½JúÓþ­¶†2=BË„œhSwÿzÒ—S×v¢êbÎN@d4é.oqÕIê;Nƒ'ë? íŠàä#ícÇH÷Ê<E=n!¶WÊÍòáj:|†°êÂ>Ø°VBÿJù¬9m©‚YãwÓÈc²ø £m{swG(ê!©”Žøc˜­#q°2˜pUm‹åB=ÕBdÆ/ ›«Øרä9’~öF˜¸ N* íLOél´Â>¬iAÙPƒ5j)MOÐØžÉLTšwæ£Qa:‚‰ögz#[¢µéñßWdeåþ꿠ݣ©þî&¬|å–¯!Îß}ñm3£ r„¹Õi¯czv¶ü– y]ÿñœ’gÎcƒotÃv郺6äF&„=¼V O¿o^WµWºþÔtÌèƒ7{r2ƒ ^Óʲ„•œÎ,„ÅoȺïS»­r‹'–ˆ±”›ÕÚÍÇ¡AY§ ³¯¯<5*tûújœ•R•;ß„uÐ i¤soådFx‡„>i]66¦Qîq¾mFdž^è�ø¬1ËIÆr¬ßUÈì¿o€ú[:>ßNã¬v²»qКy]‰*¯Ú€‘i›GÖ¢L`¢s|c:+rS*No^,Þ߯Ê97=õ1¥é­õÄ:ž½5W«qÈ…×EMÿh‘Cà6°ô¶¹Ÿ€RBMõXîÇd•´�qM ¢W†Gu–Õ¶°¼_«”/`×ó„š¼·ÈýÁëÕ¤R?ÿå–Ú’HŸ,DýRÕrÒE^²ç³4Å}×î. ø=r.œL/†zÝ»O§¥¿éŽµbm©úÀ|g8¢ïL 6¯ ZÝ—ëì.Ú¼ðýìiIá0sòɇ0êµFôAo¹­O™ÄÖ!ÜôçÖMKkE˜¡UŠÒ¼³=iYÐÿ³FZšá7M$B PŒß›=D;Ø;Â06  c<¶×cëO•ð09\ÄÖiÛ›ø‹UÒâ ¿™êëÚ®âáif¾À-Ž vÄX¼¾sU|Á#öª–kb¡©¬·ö ³þдX¯7³±´Ø ˜Ùp~þ]P ÊÜüHpvuŸ¡EÎ ,žO'úžrÒ/ÝåÀÐ,ĤŸâÒyà{$ì8SY€Q–©sµ—¢<ó—a'H©ÕØù§adŠoî»åWÅ4­‹ØÏSéö¶à‚ËmÞ]#&á”pG§F&0Ýþü¤5_›¸R ­‚ª™=wÒi?R~|¨Íb¿ƒ¦{€«+MCÂØ{A–©‹2[G*mèÃÞ\³þœþ×Ü$0´ª;¢÷~÷Ím3-ýÁ9éÅåï[í¹TÌ¢ÒTÌ—þ(¥à>œÄ9^b†�\gÖY0@_mÜLÑŠ9 ïꧥ°7RÅ=Kƒý)æ!‘ƒDݶŔfÒ?E þÛÏmMæùø}s„™&£Ó˜…Ì °è©Û« |ÎóGpEšHÞaý%h…ӯɄGSyÀ6¨£ûûæhàxÞ¶8’çåÿÑG†Î[À»š¯ÖÌͨrøŠ›åGzŸ‡¶úæàxq>Ú—6Ÿ¥RMS…›Àµ{¶€ÄëBšBO–;É?î8NÝdQ”|? ä»X&°ehÏð°®BØɉéÙþ<ò�J6�*ÙiåD;e¡+¼LNð¿äâz$HQŘ3û¥C„xŒ¹û0œšB6Ã?ïn[>uûã–E*سР†6úcͧÃÏzë#ýÃœÿ†¹ø+ô•¶éA40í½hdž c-·êEýßÞ<õk*[Oï¶ >MC‘€?¯‡ùüEW™Ý‚š}„ñ¼>ä4S¼![_ÊëÄ¡/ÚÍ÷œB.~na/È á(TáÒ5*2½êv­òx¤^è~["ð7¡MRÿ빚þ‡9Xúþà.^°tômœ¸FY.e®ðsÐql5Ucž¯á¨èÕ~¤çÑß³¹µxߌ:€4ÌC¦yÿÌËŸֿ5õÌÂvj@`¸ÖwEúÀ<8œh&ËàÂps Lã\ÓÍ‹)“‘ü¿·®…„4GNs)&XÎi5·¤Ð¼ë)‹M®µóW)©bà%\oB{g60…âE4N½Ë;Ê<aéS¨P'9eëŠBfh“r- Š±ç7QoÝWt 7}çSFú M§º³ µŽ´‚\×í¥öB‘úêkg+{§¿PTxmîõÈÈÞÚG>:áŸâ­ÉÚÊ£…ßN–»ºø¥·DrœÔ›mSñ¬jvøp{*àKmвT¼º–J¤}Gm˜ÝØM' ]WÿÒË9ÄŠÊ~tœFuçã°ýF²Ø<ý3t_Ë?´TþASÖ¸¢":2ñuç”ÑrŸtò·(»!÷z?®K*¯››òYtJ)£×OŠF¥mõý¤MO~4¸ œÏwU±wĉûß\¹@@?s \Üäè7ÏÀ…“¯�=8ìò ²î¢HVþPýz(«Ö*Þ(©¿ ¨î99„âœN§}¼×ÍVqÊÝ;Þ¾Ôñ¨¢TM@D®r�y³h¶&[Ǥè|„N¨ºѱ֜7r&jx¥Í-ÚOæÂ’¿Æ„ÙÊ`‹þ$ZV;™H!k¿=÷®óöÛD&® §žÌò¥Ã.8´s§<$Œë›B褥§×tò,†Ö Œ+4ÎØ„Ôdc!RÕ?ðH£’@ÿ}{ô;Néqž­HEÐ.ÐPúz÷¾ð\#CN%Ð¥Ràöçû¶I–­`Œë—eÓ§;‚ó_ª—•žÄc…R§Xcë#íQc00ýa¡ÓOgdëŸêé<ܵ¢xÕb(‚MCëù¼óº¹h%5ôƒªG<Q>¸CŒ}`"ÂƺÀf›ì¸âæà°•.¦u¶û÷3^×ò©ŒžäÐ%•o?/P˜îíÏÙ`ƒÑÔ ¦ñb¬w�Ø~¬yæc‘Fï“ç_ÁOö È„ØÄ_ é;É \¤¦æ¼´ô¾iÿ¯ÕƒEè^2kP J�FÁC}«dÈ‚‚Ë!hØQô¨öº0Ž›<ñŽü¥›¶%R”f¸ÛŽ:˜knQõ#–g6ŽîL²<m,•½Ê©L"Ϭb»ÕšnW¹×üS–¿a>{G·í2µõ+™³oŒÉü¾…Àú[=”y7L½“9êÑ×2b9›«7ñ~äƒ:ò ¶CÓyÁ¯NÃyéë}9¿Ó—5¿"î†=uè†Ýìr(,xXù¿P ŒÊUêRr+¡àaêºötü×}*OUŠÞ¾OéKì'7Mäö<%x5ZRíØïèn×gïjw¡7¥ÒD_è}‘%H߃ oË]ŒG 8ë©<å¨úlX.Ï¥¹­µqièPm‡êñ4{n\Xü@P`Ô&7Ѧ̲l-±Ê~ˆq·µãö0Ãy–ئ TOýêŽçØâR}ìHGé4:Èû¶6m™7ü©ÌqâY{ññдt‹’OíšqKu1?J}Œ^QSÈË•ÂhŠ™h”Ö0 ¬]Qç¤IS xP ûqª¾YNƒ©«‚lß8kK‘6ùà:¢rËžÉÑß"ªÃ0öÝIpÉ(;ö1…ø¼²we§••|B:AØvFò(]:ã¼`F­B÷¤—ïKüÖî!öeH 1'¤È}i¿Õ̱ëEXÜ Iº*pÖxf²#'­éw5¡¦ïûk ¦õçÐÉÝåNyúÖì¡“P¸gimsãg7s|Bìy Ót”±‹]#+Þ@Tøá€Kˆœ"²å—*H*_€B_ÏȪ[ä“!÷®$nä$«ÐÓ…œ;é§.!^Óîj=vˆþf¨\ɾ1j: âÚúk•ÊºÞyòý(j^ef\/”¦*¸láÀ¶?©t_iÀ¼M ã¾ò qzÿòBO‹y jP{\èS¿«°Ìæ…í~ðªò õ‚o…º¸‚ ö 4Vc8ì(Ó­õ­£´ZçÄ[^.j£¼ôÁžPe³öÓ²c Ñth¼¿9Vð‹…_”+4¶4Dµî+gt' 8³}×ü6Nx¤…þ¥ØªNäaî2TéJ�-¤GZð„ËsåħaŸ Ù£feÖÃÊ8ÅOGÚ@Ëâ ’OìˆÀÌ’±ŽÒÍ|h–WN^N𺠬Ûó÷«÷Îðà¯Õø權fðéܘ½+å2$«µe×Q(k¯Îp³wv™Tšó%*wzü¶pgê×ÔzVSxœ‹Ÿ_‘g¹•˜`EÁ· ¢A1tn Ø“öZ¿ `F®‘Óá{ÿl¥Äµ°>Šˆ”¿gód -4aí@´†BûlâJêþÍ 6}˜UôàŽR¥ë8açm*»RÛènŒ”ÙDàNÝÃøFܽªû"ˆ¶_¶ÔM x2m ä e&{ JÄŽ†¨̬Þü½7 tõW”æ¦Ûm5WÙŠ¿3ƒ¤ í©Ûá0”¿L!s#O2øÅxP:•!—v_T:§6+‚ …± ï*ZSÁ…ùλÃ<.Ê“ÛN*Ó[Ë£´ô¶o*Y%ªfU 2’Üôƺê8ôSp§·˜š¾â®GÇDAØ]œÜžhGm½ÃÃ2´6zŸAõËG4º ¶ö=GÈÝTˆ7óþ Î5¶Éž¡ú¥fæØtùö³Àxâñn%_@ºn_yôöP³ñ‘ÉâÛC‹M‡á9“ö‡¥{Û3êl­ÏÀ.ä”ÄÚóåAº´fåFÂ*£Ï¦!¯˜?ì“ó¸e[ËÕôvhƒÍºTRV©é@N Þ€›iÜù¸š½så ~ÊÜ6¤Õq‚bÞ|rErÓ ïõQknã\®ì¬½þA_]KÖÙR_y²¸»*H, '+…p0FPªtÇ»íâ Ï 'eÍ�ø‘Vïƒ7êA ¬ù#å7ã¼DÒ½Ögë8Ê+ÇØÑ:îk'±òC Õúˆz&2±º¤DÌa· “[ýaz¨­hð®v|ä- k矶FbX*Ý2o¾oE‡Àõ¢Øƒ–3¿)è0ýÒ Hç$ƒë̸SÊØ œÈÃÎ“È Ý‰‚Ï dŠU§—ŽŠyF+åâZ)æ¨6o¾ÅÜÕÚ.KwƒEêµÎÇë2¢}w¦-èðc¥ÈªŽn(Í?( hÀ‰ 8Î0’k5%áám×ÐxÖç†À‡|È]¬1´a¸ÒtIE ¿°N`a^–ߥúKüÈ7¾aŸì™¶bõ©b³XÒrc]6è'3¥Uë,ˆùì[¤šr¦ÕŠ¿¨ Ó6²}²Eäÿ^º~N:9ábúŸN+ºÉ}K·ò¤ÐMÊÒv2žSÊtN¹{¹=ô#‹¬ðÄîrÍ?¡è“¹=Ë|�B“Om�¡sLYioáÃÿ»[®/¨JXÐwm ‹©, êìÔÔäÞ•¾ŸJ–Êa]WÈGº‰zôE$þBÔ5Y1² fÎÉ}qwúÿ5ÄÝB¦èÀX}EÍÏ“®Û‘T^æQñ°jIK<¢üuèè<M‡qRÕËÍùxôtÂ~Lb#Çø³#阙Ub¥fKŸ]œ6´žÒÊçYu™ÙÚpjÓÐ?’^ß9O=Ý3]¬/óZ [É› зÿ©ð’ÐÄOƒç10Õ§}ÝõNÛøI¼t”/QeÞl³ jÎÞhÞW3·ä1&aå#…¸C¦ ¬¼f&rï(›ÏŒ¼¡08ù¦€ˆŠÂéÓ-è¨OJi5}|zdbÿþh½E¡g¥À)(œåÊF<ûÄPÉDþ_šËEqîƒ×©¦b‰¾þ´wtÛUjJjÁÞXñÆÕõw>nù¸ÔàêÕ+±Õ»à§êO™©ÕÕ}´·uk- êiþ(ƒ´Wròó}}áV’¼ù®^ œ�®ŸÄŠ“Ôu9‘–¦lISõÊì…o'ã×|®!ÆÜõLÙóaþ•M–ºÀź¡û3%§ï¾ÜlÄ-Jü嘊JF,?ý+_.1b²sMKª8MNŒeƒ6ÅÛ�F…äP™¥h ¨íš<éõO¡³e1ethT6L“Z�þþ!»óEpRÏý7eϮȂbøT‚rl<";Cúáii>‘Ëp;X¤ÅøXM‚´ÕÃhäÖÒjîöÆnyÖGç7¿ðêŽ\è9ôþamçOˆ^ÀÕ,žtÖqdäÙsÙ›2ó ð…a;yòŽQæÁUÕ±ûÒ}ꆰ÷ºÎ\_J»ç$HN+ÆêiwVøË/|ƒbk S˜š²EkÝN¢šÉßÌ6Åp}kËþÔŸ5¤%•³�ak êšã$bFæ v?9&òÐ×gÁ² ?³£C Îj>*òç¦Ãþ*=·r#nQ¶£M{ÏGß’FÊ7~ ’›y½vF_tÇw*Ë­²¥%¢)é#Ü}qet’åFìŒ-Ý'1#ÈcG¥ŽeÔ¼Wñú×oêAÐùŽZâ{ŒåøÀÇèZ4Ú `¼ì@å’QÁ<÷ìF'á_‰-h6’8ŠD-éЪ$ÍGàaUÈQÞ—är"™N®Ì/ÚS¹í;PÊ…íg6éO�Uêó àý¯Ã¢±R%@¥éÃ]¤£ö ì­ÈÔiaÀtPV¬(õJøHcrGB³ÿR\±ÊVàUú[3ýÁbÒýI¡W\*eZ%µQøeY ’Ð顈ncä¶h¹ùQñ²Âü+xª²P ãXÂ6;šôQÛ'wDy^”ç¹éîQNð‡vJÂ(B¥·9AS‰£Þ€C'•™L|5¯n†SÙÑ™Š'ÚÅ®u]iÊæµ�B,rë¸yÁ;Ǥ9ŽBqÿ‡Õ!™–ÙÚ1x`ëeS9K3UŒŒ|³¿TyH£d-4z3—Þõ»h¿ƒ>©š°wûøQ”­ìLS£.»Õù2´{hiÏ€¯ëØëgaYÚ0¼c¬IÒRÇA¾èF^ ™w1› e*à&À Ë¿àHvÃÏþ6ÎÿGÂaaöÊ»æ Ítº^{`©±ÍÑ9ˆÇyZÝöê†IŠ8µ*:)îþ<_t<õY§>í™kÎ"k/|eƒŽ£æ¶)©§4·V«,öŒÝ§Eý:Ó®r’ÒGÞ‹ ± EiÆVš­ÂœÖwQ,'`U‹^[xÖõ‡ô iTIy4³©A½ëY²'å-Ú^mýÖÎØSΉúVŸ¨ñ øÁÆ(-oì6û¾ÚÚÍ“†3·V±xL"†Â¡{@¡$Z¹‡™h0,Þp“1€¨å´Da¸åþ0€}²í©1TŠ�‰š-¶’ªq+S]1ò ¦0ŠVYþß[ß”é â‚÷Îïî.CT'·Ê@—¡¢zgÄýÑ®n0zñšZò{ÄgV ˜jè3NtÈ/'¯Ì=âÖXúý}u•§B+ñªù[BN ­Ì/ 3ƒ¥.3­NÛQ,—Ñç7¼§Ôs44Ò{GŠèÃÕ3j´so ¦0r4mu}ù.Òî ³8£è¸¥Óv±›U‚g>Ö‘dýfd™…EæZ�ãî¨$·UÚé[d?tѶØ– ->ûú’6. V^Á‡?7iPNÊ­`;9“]q__Řÿ|èpµ•™)Ë©AŸ¤ƒê˜$ù {ï!jÌAùèÚS ‘::+ö;*¹{E!BU®†©?£ >h»tV«ò¹²š¯½î †_³Îc  ê5ÑS÷ s>S‘ Î^ˆDŒupEájdBÙíÇB§²d¼Të{ŽK.{„F:�Ä=Ýã¬çžÞ�…§© 2K€.Ì]ÆQiúhTÅàý®6Ü(1O—Þ¯Û?ÃÊÁ×''*/¢£ìô2¬Kî%�D!`œ¶üp›ÃrH?o™‹ êô¯Þ3N”.Ñ`�ŠùáFk‡ 5úêâ€ü›ƒÑÝ_z¹•X½RØÚ+-)ᶞVm«õŠ{}ýÅ–ô${''œŠ”ó¢¥g)E²§àY_ñ½Ðš¹s%4ôïƒâ<õTÈY/m3Aþ©‡ž· böè"ℳ'( Ù;*¿Ùz845ÿÖc"F¹/ÎÂ$¨`_;ÛU`è€I*6ãéÄ­¼ýh؈¦7tWHàATnh§µµ_Må,™Lq:Ë>²ŸLAŒu% v}bY†Fã—uÞêžMeûïÏ góäÜ* [ñaÁw¨E¯E`+xàíÉ㊩—žB:|Ñ §,ý¹Œîû”òÎÆx¤—¾Š+N¹Ž7/wûÄžG§$Š}zB?8AËà —ôÁG¬éx‡LCëGnÂê‡Ð!³ÄÅ”¹˜’AŸÂÓž1"Ï;Y‘ÙÆ‘±…·ÜjAß~ßTr._¹Hg¼ÖýÛ#jïURW"ÍâV\ÑiÉí$3NBJÿ:§4óÇ e¤wOOº4a‰õÑ ‡~ÍaûÍjYñãç i«>‹%»sRɳ¬›üÄ2rÈ`¨¦©‚jÿ®B”¬«~<,{BH-Zîí-˜ÞÌm,nœrMªÃóº÷d›î%<Â];üuûƉôá.S$óìåTך! ©Âzϯܱ»áðâ´ò h>Uê£K8‡Ö§a®*]CÖˆ­¶´ãJnîFVÛS™Ó^žÖɶ†a•¹Ûʨz"f©y`T„V»P è®^F^ þ@˜å¯áˆv´Fˆ[F¡JD…”1Uné´Ú‘ÆƸlýïéqU®|iÊàHÿ‹=¡Óï']dêk~Yq’Z#ÏÎ×2ˆ¬*‰ºÓ³ü´£ús éóbº.Îcå‰á›"KÍL7 ŒÁOtŒ¡§ÆEX9Òz:Ѫø Šafz=Q¥LÖ?I¼«mK$ó]ÊìZZÁÚÝÐ5°Ôîâ[sÞS–ƒASp™ó ïÏÎÂô1%4ÃËUjººŸë¾Éc̦NŒ¤‚cZXì§ÅÇ"wxå¼ðxf1JÓâf$*ç Ò%:ó`ƒ�y´ý×M¼÷ç…õdO«Êü<bië$(úwÏn£¡?ê½ÜÉL{òV¯Ë ì ÷Ídªë'»µb¹H ÝåóLB_|JùñJh/Qµ7¥'T&ö[ƒöBEæÖ#s§²*wûê»[þ/,¾wz6ÄÜù˜÷tXõí¯}½Í\Ór£¸iQßxÒ÷t¬‚Q!IáÄ(Y*¥ì}V=)}žK…Îð/ÁáNuZN¡X5ÇeÝaº‹Æ´àLÙ¯o7…iIOX‚Ç®õ궨òÐGÜ0÷ºÏÆS`ƒNa’Y!¿°¯³zcœ¡Àéo‹¹¯Uþʹ!ÙŸâì$÷¨í.’ÈÚ‹ÇD”(JìÄ&2–-ý=°0 À¡E‰ô‘¼…ÙØvƒ?D#yé•é†\hý”µ³wËåž×F@n•.²ìøÍÐÝþ„¤¹Gwý^:“yé Ã"q%ŠìÐ@Ô%Ÿá!ZIèÊð?yp "gÃ<‚ÛßDBš™ ôåØè6;i¯–jT²s}A ýË­ËQŪ”Jد"(ß¿œð̟Æb*¿í»(~5›Zýô òűßXnBL‘nò:K•¡ÕVy³ùr“ùÚ1—–Åì&DŸ«O'ú>›½‰ˆùZÛDæã=ÛÆ]o~zJC/rÿ±%apèlÞÏ&œ¥™@hÈfi§cqsoõ‰bdd奸΂„5Î0ëeh]ƒÞökŒÿ÷-^8[«e¼*’‘”¾+'Õèäœ6Ðqbš4á;Ü´ôOz£6\l-„2‚íì$²_Ðv´f©˜™Ö\N>&ŽþÇýx²e‚£™ þŽáU+O�ºïížîÆÒ™ú9a¨ÕùËÉü™ÏùÖ»¢îÑoþé»Ô0Îê3g‘™É(‡ÒÖ.1ž‘©q¸¤åb‚>ÏöuÏb¹=¹ŠÌçˇb”QµŠÊ…@ãyäð’¨ò‚;Fž¬ÄÅ!Dw(ªÏM@kþx oÏ@;¾r pQT§ƒ‡ñAýáßàá$+%ªz:‡÷–H\ŠDÉÑ%Ä÷Á#Op$+87§’N±“럞jœ0G{H‚=!¬ÇÓÌÛA¬ƒ¥æõÂR ÎêÍó£§ßx…WuãD#)v𻺫úýÎå/1ø릧úyRK”Å `_œóÿN jIóBžµI³ô ånvæ¹æþ<õ«Nè«¡(+|U1Ø*\’ ¾êü:Ï ÏiǦ…¼:Ì嶇©)<SŽct}êÓ¡Íwªd^ùÂo€%Qü.Ïš{e!³¤©¾ÁÆ—ô±k‡º_­*Zy³Ôöß%ùT Çottô~Z#&Žî'“d­[-”•ú9oÄâ=v†Ìö}ViÿîÑ;ûþrm&XUÇëpmÛ7 îÛë®>€=¶§;:YäayAÕ”©gõbåók†Û{u羞ÐÁ¡{kSÔof•ùî‘ðZª ¶—'ZV!©?liŠÊ$•Ü.§L -ƒÒÒßS!‚Q »‡w—ÔТsØÒ›UÎSU"žÉET©{ëœíc(³^½S­ÔÆ΀ï[/þäÂh7”9¹È§¢ÛÍзè|÷Òÿ)¡Â³–dI)Úg¹ÍQ‰R: ©º¡{•Ælýn,ëL8×ïêG$”Ws*§âi†'³ÃDÌ +Xã%&¶³;–iAQ‡Ž·óÞ“"éÁËÓ–Âÿ"NQt;Uÿ"è¡‹Zt5wGbyFÛÉÊíÏ|(#͘9 Ø#Q“Z4Ö¡.+sÄ jºMÈ ìÍJGŠ½bí3;teA0œSš RNÀ4’ŒU’Ä FÊ6È·*ŸR;zb”ß±³ýiWJÓÜõõqœÕÞÿ­gœl¹ss¾æ¹sžU‡ª€æS–P ižoÉ%Ï,_­'x¤X¸”Õ-¼—‡hžŒ…Éÿ�˜òÔŸn³C#ˆ=ŸªìÀ ºÃ¿Ýy((±Iíß9ä¡(H œ¢Ð´£¤°VXƒîíj«Ê"E…‘ÍD‘òÎŽiûÐÜÅ™¼ØÄWtxQêö0$n<N'ž«2=ðýL³[kì]Æü‹@£å7xÓ§d¥Cý ìB{p1¾-ÀÊ«Æš…2®C§±&rÓgx?o–te ïn0”• ÿ4ÈçwçñÏÿF¹n5%ÍžSÈ_¨ÙFeî{½ÄGãmïÔkdˆÉEܯۡÁÝá³—Vß綆¯°'Å­Ñ\…ÈpOžSPÔÉN=ôV“®ŽŒ¥—x^ÃtM`~‚± ‰Mò½Â€DDäÛeÄÆRÉQ~~À‡Ü`E’Ô—d…o­äüÒY™ ¢‡©W°ó¯U ËÜç„‚”ê~òQÜ]ï;¯½ˆAcí=%Fdz,4lNÎăbóÜwÖri©ðoÂß Ìp^¤ž#­ð‘e’§´P$™§”OI^÷• X¯ÝÈ_º+ìXŽÀ ±˜©2»Q¦\ãdâ"ó]Ç«`sw9Ûf4'y5D~5w”ϼP:k@ŠÞåk?‹1‰C¥ ïÒ v†'ˆ�#óÅ-ÆÈÐüVì®k9Â|'Ñç0*sб÷~Ö¨q:šÌ m»7¸ðWð•ó•`“è ÉS*­nZ%Ó<V µ\t¾}ýú§‡MYjÎý/`P«þêyŒÑ jôðmNˆzgTßøÌSµ~ž sÏ-Âð§JÉr …¡‰4®¸ýÎ/¼•—'*UÈ–»¶å;n¶È­C»¦»3-ÅðßOû¶1:ÁLÏú+›™³h’›óõìêPߘ1%?Ä ë'H×ÿk€›tCáÉ nªX]ä9Î%úO”­Ã!D±—j«^ª FHgÏhó5ÅÔoÈâÔ¤§µSVYþÀUò߉úæIèiúFYpBžŸ¯.­Û-¢Í§ºç$GÞ 5&ú€·%Q©£ÏÔÌùXÓ¿©=ïQÛ×$ôï„ýŸ^¥þÞu”Û‹NYšÎ|ìÙcÛDý‰ÖagõŠdwí²Ûcü2ÍcÒn;äAuúrIZ9£ØÏj6þ±Ý6VÊU£ Ù.±69M×o“Ô:‚²=‰*xŸñÄÚð°¾a+æž"j"Ú×´ ¦Î3ò,¡Þ=¨çSP’VNƒ…M‚zFÔÔ'‹]¤õ)¸Šõ¤ ?CšA )ÿzïfߊ8£‘gíüò`@L¯È£ÞD¯í¥Ð}`°ÀC…Ÿw#›-Ý‹ôÓ³=Ç;°™¸Üq`ó¶µ wö×ém¹¶ÛCÿö'§.ÃTEM{µ}éž„ü6¼~´ ãå81qL_×:i®ÔÉRÌhÕ4ªÆ‰è¹àVèNn ;$|ÖNúméé»ùCìQ™º?³ºÇn«j‡&`¢iÛôŒ˜‡€ã‡|»à®8\)ÚÃ6¼Ë‚ÔN–Aƒ²Ë,'¦&¿?©Cä‘»±%Bñ0ÐÝ´¤Vˆë±Øììxù¯2Šœ$ÎKÛ+š©æbËXÕŒ¶NRÈ…þ%Š`áàIÜýÝS/ÒØwÖcàlŸPÓkð)#3ÛìGt$ÞÑ››«W5ÌÝvÔ™+ìb˜3Ë@£Ö´®¤Jk4d†,ª¹ ÆíkéW€ù<^ÁqJÎx¢ÎNÊ )Ñõ^WôYŽ“„7â™m‡!Þ0yŠ`fp×ÓHîPVÒ ¢¤úŒð—ZGžo(óm ðMk€òòÖÙÅ"æ4«J ž¡ÝqzôCŸôM‘t §÷znV̾¶&†z©±w©m·ç¿ò½ú¸,§?v¤›žíìɉéÑb…kêäû¦¤ÃÐŒg×÷»;ÅÚŠnÕ—HSÚæx` VK}E-Öɧä–âŒm]~œr‹Zä11ÊJ«…›n([!‹ ¢‘´Íì q¬¼xª—«†.­y,×ê0.’ÒVšù®Š0Ë· ›3'qæyMc5S8(öÖ°õÉþ®XûÊä“Ox‹¨¾ÿ[:’èÆt‰c¯M[»}3óYHvœ¤ŽæçTö—ß=ë-¦(s€6w†e•c'œ{ôW ð1}þ†ÀeBiò‡öJÇ™M€¯7ça0˜¦öÌ~Më—oò_¾ª`Ƹ̺ô¬Y;èÈ„u5Jœ­‘£ÿÄÕJå qLƒªk¼ P¨Q×"fØ¢æÕXÞ¥+²VRe”­`×IüЂvÛóGçÔÿnŒCØ7 Ùè?yVÂYQÎ#~Ã&CÖaí~UA[çÇbœÁ2XNôæ�§?'0„ü¯nzë¬_e’nžÎˆƒ à´E'O¯�$¯ãð“Ðà+�þÛO”0,öä:dBíkNÒLÒ@g[§¸ànuäukU±•çè½Hì|-‘!÷(\9~˜?:‹ïyøæB$bqöuÞ.E}Ï}­«R ~iéåŠ;ÎM÷s˜¨ž«&Ž€æ #ØÄ‚§OvÜýv­'©fo~t)f–„72ûû: ²ÆêõÎj*?m®žX!RX?÷|ÇÂÈë6å¡›;)¨¢xûç 6?¬ùmœQ¢p"—[Š'ÝãG ‡Œ³'I…ÆŽÔ|æýT[âöÕ3ŒbýúÆ”ªÃvM£6à|ðyÄ"ë.N°—‰¶¢·�ò“cÿ¾o}âÌ Ø s³Mè3Ÿ/ε îVop)n!]6qÐlwhx~¿@7¢¸.­®¸µüÔgÖkùHQ§¤ko~œÆ…‰wk–måù?ñ`«©)¬†ƒ•À»Œ¼g£.arzE¿%8V¬x«ò–‚_™³| ojÔÛšë~íeE€ÂØŒi®#Èïjõ ‡Ñ¹,Ë3ÛNckR1 â[Oþ—ü=_ð `]EYœÍ£„®g:} ¾¦“pþš8i”ç¾ô[Ä)½q»x„~ª/FØF˜ÂÒ4<é¯|üm¾‘¯4VÂÊТ[gèñ^o¨žóo/¡£ÿh?ÝðÖE 'µšÌrܪŽ=Œ~ÁáU·õ«õ+¼[Œ"êÒÒIړ祃¿õD<Ï{vÕã—Ç´’H͘Å:.sCu­âUiÀ¼Y_ë(Bt«ò¶­ ©àN›ä™ùÜ$¥.¦6V\˜ãö|l&'Æú[M+ã v{¢ed=‘"¶Š£Œ®‘À O÷ÿ£áòl>/l½¯Y;ÔÂØoF›’ïñ2vf+/ ¹dYR¥™yZ±X€¿¶˜‰*•é:V†‚{3œÈ\é¡RC´n{†9S‹ †iê0\&÷‡EÅJK! 6â m?=¨©lV+’ø#OÅB±ÃÜêjÐ:-ß5vÄ…OYÒÃ'Š­»8çéFƒ¸0Œxafây^ÁOè Ç ýËþ˜ÎWà¯ÃE:%[|X0Îøäèút¡ÄéúÆ&g½Ñdz÷;U”›MŒ©Z?·gb£éŠüLOÎYž¡±‚!�V‚£âég$iœ>NyÚ…jÜ&—èÑUxzÍÆ“¸ û�PÕè©™E¢4ª¢¬ùh¦Îí™MZZXãDy÷]‚É©vRXªRÀø"…h@[´U%£7fÌÒ‰Ñí<"«|TX m·”âr¯w@]éâ+\-0›=/w—ÅÚ¶›nFL{º1t"l®0zÀ¾¿÷+,Qš?ÙÌeՊ݈sÉô –v”ª©¿ìýB*Ï·£O1:@o5ꬺÙãâ\ÜžvU×ýÕuc*ELÙXýåZäÊÜáÄÑd»�ï®6·jjZñ³;\XŠøyÙ÷¹aO¢cMÛ%€Åι`wh¶îÓ½í ´j¥½ÃýÓoåÀ]ýVÅKÚñü<Â¥¹Ó¨Y¢q4ösg˯Îø*2ð¿þŒ©Ê—aÿÀ4kNbi›qÝƈ‘ó¿ÿÖ¿”´KTXÀ4#(ÿA1{u©›iI ãɦ¹t§3‘Š?€JϪcwá[óƒN˜M'd«npiLE­(ižgV ÐØø¼¬äœÄÙŠÊÓ6Ž*JÁ”³ˆ&Û±îEÞ‡¢Ë¾eÁùˆvþÞåMê¯0F‚9JxJ,¦M#U„ê ðè ÷šüƒÂ¯¿Ý{¦ÖÂË’¥ÊvÄóe^I~ß»ã—ýÇ6û-ƒWZk\Óc}­ãt×÷-É|µ’~zœ•K¥ØÕ»·þ©h~ñpÒXn[ÇíûÀ~:×a$g ýL%UõÞ«‰ÉÈ>ºoÒXBñÍ€±Æ!¥½ºè>p~‹|¹H¦%,¥»éWç1Ñšú€Fì›TfïyU§ÆxÕþC_µ¼&ü |^¹5Gëtþø§ÊolÞàÕí4·qœ·cÚ«¹Å¬Pý¹éª ²Å|»È‹ ²é¦ö ‰ŽýÁ’ËÄuþá+Õe@®ZœóLUÄ Y_ÁýKÀBø�\ùÓÑae¹~øÙƒôfÆójè(.æóÎàòð ØíäÆ%óÔíf®WŽ`v/¦¥r"V¼ÿ£é~[íR Æ›#Œˆº­7‘Œˆ‘Ia¡ŽÎü§Øé;×èhÏ3ÓÈ|t,.„Åv¯™lxlD¨ö¢ (¨¢Ÿzx¹' ÏÅÏ¥ƒPcﮯ[ÿ:RNì—&‰÷ï´€¡™›Ý¿¤t+_{TA3¤i\ÓÛ¨Z8”Ð2ž­6î<)¯ÏÝí¹P!o„G¥å‚tžë­Æˆù0½]0g«³ÂŸ£*ÄÌ‹Žóß¿c¤ñŠÂAâ[áÇÖQKÔr¼ªX¯8¦Cˆ3nS§…M°"Nß›bš¡¢VB7ÃpÍ€B´QŸ §>’S͹IÛ»’椶%p èÇNõ5^_ú#]fº,Ÿ0«_¬_¡„¢zºúPbLì˜CO¯{̪óØ$Cü°{J­Ú‹)¦i›{<¬<`ÑÕM0~‚Íú3W)S‡ŽÎ‚ý» #,4SÆ`}X_õ©}Å»6ö %Eô®E^Þ׊4+dµ ¾‰X£¢Ühõ\0=;Ÿ0–aœCY#£Xd1sö'õŸ‰´ÎóMìØÊÕ) :ÝðÒ3€Æ»i¥ÚŒ¿×¯UîËò�‰%hDa…šž^;ѶË÷ ‡û[y[ÒÕ¨kÏa'ÆõBWC¤ø쌲ÝËmKYáÄšì`ö«ùïôXÅópggÓeV·Wÿ1͘†X¡‚{²´•ÕâMo5¥–9W,† ³Ëè†Îæ-:zS·CU‹¥Œ¾É«Ly8v†UC$Ÿ UËW!¤9ï¸]ßÝØ•þÆ(Ï2ÏЃN²fO©q9kà‡â$ƒ¿d “u[Ï\ó-OÈRå,óП¡Q×@i»˜lW2äzÏ j›(7FºïäI¡ñ^†^8œMáâ3Ü<±gûkáX&•uû«ŒE@„³ÍðktZñGÑ[å„ü¹¶·?˜ckƒ=• ÉÖ?ú¼úèÌ áäê ‡Eÿ‰Ãµ§V X!ýÍiÒVtÄöö˜jXW°×ˆ`+ÿHÜLiƒå“fsqÉP£a–çmˆ"c©xº°¸‚5´>uëH„V»<È®j!Y±- %I´×¥dÿjÁÅ© 4Ë„[°o<NA=‰Y¤³nÛÖ½L#îM‹cZ*F`ó@ LlðÌõ 僂Pø/Fîâù\£+3zø§>¡¯lõ#í—SÐ,Ð1q�ÈÔÉñ>¤EcZѽfNƒ¬Ýzž&mÀgÓÎ×벤ð¸Ã)wuG0Q›ÞKæMãM4¦|¢øÎxVøʨ´1l-N­¶n¦ú@É?äüôü¸áz»þùàՙê§gO;=ï”› é~&GŠ¢ô‹d¡¨ ½²ƒ«Ñ$ºx­BñÉUXãK²DqZúÍ6ØïîÁ³|·VZH¦hquÖáX aˆæ.îÒE ÷òz;h }³(a‚e:Ùdl(ÿ#¡²w}æÑáElFÎz'œ‹ýÅôØT@�Ík¬5Õ~»}ý6ª³Âu±áô;ÚÅWí¯/Sçõ½hŽ™œèQ Û™vF~>ÑÉÝŸ=¨ÍÁÈi D�:Å»CKª‰\7ârQX––ÔÁB· ­±º196 .—s =¦,óÒí(=¢¾³~©'¡C–0f÷„•ž¾LGó÷„–<~µ÷Ïœø3ݤþ~üˆSgWò³(î]Ù¤øöT|ôdÁ¢»û”óØøú.›ä‹Hœk£ “ŒÉiø¬ÎK™(@¨½>6Hl.¨­2zÝ—æðHE̤ƒ¾P˜Ç¡‡?ÏX©¯‚p¯;9<í;ÆÅ(EùÈC²Solt ïƒ k{ðùýJÔÁ¾….­%À¿+d|3ö´)Ehi‰ÎÒ�{,…Eɀ̈¢Ø42™Ø˜,z"©Í¹g…ß¼ÖgOcoÆ'€8éÏQ¥éº7÷|¥-\f~kŠîª †E{‚Žv<Ø¡ác¬æÝ1íŠ z×7š146ªvO‹ vÑ!Î2™Wfò}#Ý´ºQýoú’’‚³QÚä’¦?` ?*e™×„ûÇyG7Ï%]7$T0z4Wª<-µH½kn_¿gFIìv"K_\dåa¡Œèít0øôàc8/2A>ÖPžaÔÆW/åd]ºåÚþ“bis“KË´WÈ–œ¼®ü W#Šbu@1›"\”Í¿®“or#8äœRÃafS rw5£4΋Ìår`%Àz,|W,ç¼i´¡`†ú6²’š•@T™ÿñd¦¨÷Ñ|I¼1&­¿À|pû®?Œ³è ™î*e7=Dd¡âq3˜]wñcÜêÊŽ‚þr®eñ^Ûs'%æêÕeBz¥—ºð¨#hY]Ýd!÷nÙwÛá(ó?èš=O­B +2Š¡y¯? (íýã3_¡bFÛ¡ÿGIa׃FUœ,ôxàYÿÄE¬\ ³£v)ƒ°¹jãË;ˆSêÇÕ�ª"‘Ä^íé ùŽ7T‘ùý/\ÓjÊ÷­sÌY7I >"ûÇ]ÝŽyzèøø1Ý”‚µŸé—Ža#V"3Œ3ŒaˆáÞïô0¬”¹$tnö':ü³úËj¦ÌÉó]cêYºà™›¶5-óñ[z—¯ÊG >G8~éÍŠš@¬ÖMYŠN7×ò7zb®ë(C…Šeé"+xW6²H ›gý»Ó9 d¦%ÈƭŧÙ4´(ƒÞ­§¿²m5b$vŒQ áÓ12"qŒ[ì9êØžòž¡ª•1¸IèZÅŸ“ƒÌŒõ‡+˜ï÷«ÒÂY@–,/P@ÎÖ^Jcu!ƒnµe2«Û‹ï÷YÅ CNd¹wI¥ÿy§/aÓÛ-Hu…*ûÕL–3¯¯‚ŽAÑõÝ5Þ¦ôZ7Ù>ŸTÈ]17ò>ê'Ì|¬,%Fd4++Á¶![Æ“Œp0ñb/¤ AÇ›‹ÎÛÖwš;àj²¸ƒv@…\.’‹jçªæÁ±1ÒfGäo½Â{ÍÃt¥QX(ÏÒ‡1­8⚦nY�7ƒŸ|EmÔpòŠ`wN‹ ´ŽÅ•2{G¢Ôw»Žah5ŽŽÞˆ ~ûl¤]ë™UCÐOÖÅñôÅL€¹Åëö¥b¬ W¬�4Øñ|оȶî?„¶Ã÷ÿ4 •á‚T¯9œ‡éJfŒ‚0•‘ñpòZƒÇÜò”àž‰ÂYD¤Õa-½óɤ±{ p2kŠ(~QS§žatñGÒÏ« !y)Ÿ×ÉNï»v0àÅM= €Ã˜×7:æ;àÑp¥ÃZÑ™A_còƒÉÂ4^g;ÑÊ;WÒV5ÇŽŽ³U+­EJu“n²2`bÇÎ@„ ßU±Ÿr^¯C/¥Ï†’–ØNG¡˜a:Œ°A°-ofñƒgÄÕa^ë~•¦{#I{§„2j«>Qò�æOÇS-[ˆ«˜¤¾zäo+Q™¨ÄÇŒ3Ò‚Í´¸\¹ÿ %1ŽÈæó©›þ9ÖÓ½ßüd”—•qæ˜{€¯Ö9}øź.ñæSØqw.b§üÌ@¹rÂÝâÓÀè3yב 8;H†C-ô¼¿BéÇjI²²!Hç—4H÷:ŒÙ×ÿv=[Œ›|^¨±äZ `…îbö÷òL¯T¯å–R «³W±LØàȪÿóý⻎Aq3˜á1ßÎQÞœæ«>‰‡å3§í¹!zòŠDŒ“Uì³?Á ‘Õój/|¸û]±h£ðL0ë/®Þ¤b…Wþ©QÇ·@saãLš|QNO+jž­˜Ù#þM–ßè™4¸ƒ–²Ó`ïØ,v‚DwÚQà »ÅñE.HyF/j6‡tÛnuýb5ÉÝ‹Y·0…Aµ�`9ù®uVØqa?­Høn·úˆ­ ÁËgFÉ„N§�ÄÝ“§Hª”¡6õ½ôµh7aW¯tÆ¡wx¡¶Ã æäÍÔæE ›<ùù<w &Ç&ZïiíÈÅm…—ɶëÅaã9Ò6É}Ÿ{éÓåAqª=uV£m&A,ºyõÇ6e²²I¥²\â ?5nÙ ³±Á2�;Ä$A/ê^YW@ÞýÐrùˆ©ž=æ|¥Á/ ¾©&þ ŸXÆ®îeã»è.‹:uõ¦%zGÏ,þø.nº¼Aûg¸XÖºªð2ÁºßŸ}ÍŽýMGHh¶™ÑÊ´/IiÆž,¶T|-fò¥uaZè¾>uË5Õãºã©þ_é2ëjɦt¾P"PZJMöMÒ¿–ÿÞÈ3Äi¤cGëG±mzÏ®óXâôvØ *.b”F:èE¹íÜS*ÌL „Ö[kaNe›s²3¤lqŸú…ÕéŸi„ϘÉþ깉S Ýz­ÆûÄô{uÝêQª úšÅ¾ñ¼.¦þ2ªMúýs·jÈ'˜Dõ'XgìO®1³§ì9ØÖÕmó¡wnϲȸŠ}; ¥ÓŽ"]¶¯mGX#iÛãYÌ@^ÝiÊûíùˆU_L{®LíÃÅv‘ydÍqJÎàé<ï¡­¯/WÈqìŽh¾#ÐG(­-`ÑlÏ_à%ygÄRšZc×gô‡OÇ- 3}’<Ñj:ö‹„YïòŽ*EæY;–ìN7AV[M_LËö¶oIáNäáì…é½³þ‡È­, RÆY ÃééÝãÂj™uûÃé'¼ùº5™Ãó¦àâZ2å…·œd—7ìî_ȳíN”Rùÿä@ÊÔ%g“+>8èQf^n¯ ºŽçˆ†˜�¦+¬H@9w¾lÀ²þ)t(2ë½4§†‹Ê)éõñ‡þf½¹QÒ¡Ë çó¸«'“²›j&ÉÞji?rѳ{SJƘµŸ_\±åŒ e(ÿ;åg—v KšNG8Û_ê·¾ò¹,ÖMg´»Y¤ÃVÝ€_{¨W¼íÃ2ØÒf¬ÚÉÑé«îÐã37‚¡¾œR>¿òt¤ÂÂÌÈ—šj©óä©…®àì ‚Ûшˆ$Ù …TLuý,ßq +s6ìú˜e¤¹PÙ®<€!Ýü<ãýXÅÙÞ½tÅ•§ÜÃ_c¦*:>]­–im$Ê#™æìM`ÅcNæìÕ½®J­w4Ëg6ô7ŠÁ6K2A$ -¥o‚Jº×°zÚ»²ô:á{…ÉhÙ7º_)·Ð:Ó7≌²!V?üLˆüž%R,ÆîzÓÙŸƒý 4VÕj¹©D4 ¢³> l]Z@ußbæû2<;ÉoRf¤·•˜AŒï¸tÞH.(ܨ$¼×'4•(Ëün0„am•¢™êÄ÷M© ¨ŽLïü' š*ßΓ»×¢ùq+z˜†wÕ‚‡ßÁå X ²j=ýÈËÊ5Èáê?oôýØ-Â`éÖOŠâ,H+ÅVV/(èZyЀì'D›w/AUÿS#gCY¼²B¦¢‹ØS­¤:û½ƒù¿oEfÄé#ZÊôë[ezáþܩ³¬²‡¤î1Å_Ìî{WÈMõ¡gya¾»ºŸYîràt±g9¾.À¤žG¡ eV=é'Î&Ìm¥:äzÓóýå -ô¬S>¬è« ƒ—?j Úõõ<³‰îÃÏ%•L#xå â$AîÄzsÖ_H_GŒ‚Íû§¹Jì¸ù¹nÏßÐ.I¼²bLD†,µç-}è‚qb“uÓŒ‹€„ÿI²8Oü$„±ç´jÓ­ªòˆͦ¯0°›ÁKêO7?:èÊ>0ú9wRã{øóÒALsv.™0€©ÿf‹ï;vÜÑþx,þ•©“®ÏXNð”ÕÙkD࿵{{ßá€ÚO,+öíçG³k«å$ãïš´êtòâ~[ëY@”æè¨Ð¿ìØæ8<$,÷iæSÄýGý L�›Î¢!Œú­©æM’r0nRŽ>2‰öÀ LjÛl *VfÕ&Ô ˜Ç”Âø:@Gˆý›þ<¼ Ë‹S' �€ݸ±&ðÓùvæhR<Ì@(¢ƒh|cjhã‹úøÒ“«ÓÇÅG–øŽ1¼¸FšÎTî¥kãõ:ãNà q²Æy, \@ÕÈWãdZøtkñô¥®—IûOb\]ÿç y¾zgsNlP³ex{Ü… ÷ƶTcåFLDkz*ÎÊyÑ1§ôìÏÚ›¢ä–³Â‰ÿG´?¿·¬Wºþ%¦Y}öAµÓ÷gÎe8°AU@%”©_»ñ—'˜óuþz*¨bëÍZ†s[åûè¢Þ.¦is?qÚµ±QYå¦{â("0ª¬'Õ'x¹ç^f3(mêýcZó ÒvõR½zèëæ*¼4€y©ÛLûM[Ù@ëC¹…õd¹]£ˆuõ¢7+)Æh+Èw½Ë*xQŸü ºHƒ]=¿mYPÇɯr‚©2 -PE§”ª.|²âóTkÜ™Sý§ðd­ V„Cƒ§:ëh+çäkÞK)#&ÁÛâ)JWi°SEWQ5óejw+6´+Zÿ&ÂþxªÝ„êÞÔî!<¢*]Uò‰0` ¹Ý9£2ääúøÕ›žãIú>Fðîî!P­RxxÐÃÕ)wŠæ@×ô??{­ˆËØÿájOøgëŸnOæ$^™,Òˆ®:ýø U Od¾±„~›Íȧþß7¤c{šJŠ‚¢PyS³éÝtÝ"Áýrº4~í;ÇXxj¼1ûšV�ÆrED_Î   ¡Cªlž%Ò™5�U0rº<éM[¾…ÔqÐÇF¤šuäÝS·‡L<`ÌãÐ\5FòÄ—4 «ûÇÂļU⎴ãѪd‹àœ±jÏN¶¼B?¤m†Ƥy¹þé¨GÂýci{Ø” Ñ}®‚è}ëBXÖÎ@è÷W‹³ÌGW•°º‚àD»¥uqtþ×ûó° I…®�½;o\^ùÐ-L™GÖª‘V"rtÃü¬zJ$Ó׎rë¬ÎWeþP?C3¬þôŒ¤¬³(XêV…—é›%+D>}ùýXt-QèÀFÕÉ(숡†š®ZPõÂ">jߌl‡‹Gwuï†+Qµ2ØLtFž°%EI¬h_³õõæ*IšŽÜ¾~¯¡?Eü'ò­=ßA›î¯ d 5à…å%NìSDÆ/ {Q­ó·”ýt&;Ì ¢Îˆ(4×£šÉ¬c ¶rcä·íÓ÷ýȕЂ5_g©õ¬k œv³Ï‚xÿî Œƒ7“r ŽÞ°h1 :qÛÓÛÉGô.5WÐ]Ìx#ŒWµ“ƒ?ÀžK®¤¯ÿÏæ¯ß~ñ0¡ÍJ—U ½y.©¼¬H’~t9—†G)jdM…Ô×ÚPC°éB§ÅG7ˆF¯òv žqºñÐœ®Šýq)(ºsLïÓœ]b*uyÌ©>²ãÄ#ÂqjäèMD¹:¥&ñb{ P D#“çw\ŸRX9*ïß\<•sñÒÀ÷::ªmïÜnøò6fÄ åûöú]Ó/rݳYÕ2CøsþrØŽR35¢¡!êY/ØZ¥›ÐÌÐŽô¸2ŽåÄ;ìö�,+ çŠ&ŽlÍofÁ2$È¢ Yg½8Ú‰õð¤Z—–ð8œÒ+u$èî¹ö+çÁ×P=hmÏ8#õ~/-©ZZi·¯Ï `äu@O¢ìß=pã±îæ·+Uc]{m[îœèõù #‹ÝÞŒŒ°mÉ~kSjxÔF­4(1ÐÆÍ«A±ÈqUD½L@3öM„({9FÏ!;9x~e±¤©‡£à÷´ƒKv¯¶0<¨¯åCÍ´»† ]N(\Jv-_w-BþöÈÊg+-¬ªd¬'ú>Ñ|v=™cÍSÕwàÐi£snÍÁþd-r…þ< �×"Èg]üØ=7LÁͧ·¿¿™´Ws=AÊ‹¨Öºv†6õ1Œ—^®FaÌÿ• »ß8jÝÂù8iPšYðòÁ¯£ÿ$¹9WÄY.‡Þ %:ý¬½èoáaø|-¤ÈÝ€Ô[ }¥g´BßbŠ‹Ô—‚ iëõt‚ǃV²QIæmG6 ô�«w³¶É·Mš*-šÄG`ˆ‰vÀ¼;%#îé+¼Žb‰cð ’ê˜ÑI©é¹Q LÖp©~HójÍi¸Ò´¤ï2¤A:YÁL–èFžX±Æsµ¸-|‘Ý=2¿N'ä´JêÞ k‹ SGµÈÍÖØÖ‘~{ããe¥›£Äà ßêj“dîC·ZS³ŠÃßuÙÓÔQC™~zÙRxÒ~7ÀèÐÊhewÔ§Ý!Ä•NŽÎ€ÈÝÕíÁ_­Ð›œÁR\m<¥z¸þõÞ>x¥àòT$D”½hõZ:3'yvìµ ósA¯_¾wê¢U!Ñ’ñiò<!9s’,^“üœ!Nã´—îòaºwwfÛqRú¾v˜øQau>©+ïMíMÇ–o˜L¶‡ñ-¡}|csõK[ 0>¶šŒÁË9Ñwªæ­¶"ahz­b%¨ADÎZC¼#h \(ßJσg¬Ós_Ttr¯h£V‘u'Û±îÙ»ŒmؾŸseáÜXz¥ÙÇT¾oMLÏŒW•‡Þ~Å‚1ò2/b:Bv«gOÞb_ËRâ2ó}E¡]H±§ºÖ]n®§îC’ñÌÊ’µëe"À—t§)KÎ"Nfõ—° W/ÙÌѨqbl&û6t£¿¬á7ñyÚØvŽJ£MÁ‰ù¤ ¾P¡Ýêx¿?zšD+ÏÚ[G„檩½jh¢MÑáÍTµ¿±|:J¯æ£µí¸dúRžt`.ØÖꌓF¡™@luïéCóÀB@¦)>ˆOO¢ÄwÿƒxàêºïŸšæU"õÊÚo•°¢¨ôÇÀža)o±þÀ¡ø)îÆ‹%îò¯z©zY±­fÉúÓ•Õj˶ÜÚz™ž 4´Gv Ê}ûyý˜Ö?!'²^¢N°aHyc±²äµÛ›žÝÎEsó#­•–GÊÚ‘(¹àVŸÐÐÈNO“§´ÖÒºñÎèW4§cLŠ!$œNyY*lV ¨àÝôËú't¹ ·ÐßqXú^_°"n(ÅÈ·–ÍÐ4ü¡%~Ç Ì߬­œÓT1tô'ÓÉ¢-¹(ÿÓ½AGXPP gö×aXý`˜¥2¹uÃñ´ny¾†Ú-ó5a ¸ˆmèÁ8ª2í ‰ÃÌWX.‚iO_�¦nÎTœ jÐ`B "©ûéÜ+wõ›g¶æm8ÏRšÈÛBâ`èB,«`;˜FøÀhÜÆ‘ÃZF5Ý*<YBÃœñýBâzÈ?+b£4ög—:òi[©b´Èzªƒ<Þ'½ø"u#†Xl:TRk5W‰ç¹õiðßu"LEñä­ÜYÄÕu ãNú¹³ÆMPw©¿WÒ’‚&…:<3ãtÖUª²¯« ܽ› Kýp>®&itoN5Ò¶7:¯Œå!•Ò\§þžo&Þ :SﳬVos¶æV¬Ø: iô‚ïY•ÞúÖu´Æ¯­×igÅY;[Q©?õì,35¼÷“UrÓGIOñ-´µ­�D^Cõu€÷íÀœn:JßïGgëVo·Iÿ0DJêCs@™©|®�$+˜´*ßô3›¿q¥B¶bG‹zþW§(¡<جÂs=Z„΋Sÿ*¯VîgÅT»O³„|Ÿ˜è-`x œjõwŒQ0…ƒï÷+­â$wžÃ1ï¨ rÛú-r–÷ßéèj¾Ñ®må®ÌÆŠ3§›$’LÃŽ>^Ô~ê–TÈløáÌ#ˆm§üùs ‡) ÒÓÙzÁ§Ò•q¾v?ÏøRŸ‚“qÇØòò¼3&ð”:†C×ëÒÁˆìÒ¦õ­¾3¼l;1ÛÖ¼VP/0ÖÓ‡·Èº®X`nRwzhAb5IñÑPNÎ2²¢ìSp̺½ŸJMçÿi^NÑ¿ Âe±ö©ªœþÖ¦EË2ôí¬¨ œãÈLRÃù·Â*™ÈV2'a´5S; ‡8„°>½5(c_Lór«rçÎT(dîÁ®áDª†ã´†/3T)Nøtõ íËu³ƒÉïúNXtÛ!c99‡uYéW›¢ãŒ]ÿ¬Š™Þq¥º•ó‹³È÷ (ƒé`©284žÛQ÷ld2ûP³#KܤJgjØùª{—ò¦ŒÞŽáMщŸ°BÀ>\ÿxÇC/ñ iÜX`Zýã¤â¦ÙaL‚òûéö]s}k¤‚|aìqo¥¾m&Dc‚Ö‹FcÌØØ;‰Â"?‡æ:@#Ûž.Ó•r±Ãl†”$½ùÉ¥ ±Œ[ (ûj'(ðÁOè½:Qü‘ýmïãp£ÿëü3b¾\j›QìT`pV¸ýÆ¿H˜³qM¨™¼›!|ѽ{äÑ°öÁ+s‰8Ôçq…"˜ÁDÅ¡»8³å‘“É^ó“Ê"ã‘@š(ûöufëÁw²[iû¾*ô{j/bˆµY8ûëyˆZÇa­¿ê6ãš xšôpU_=ó¤M9›™—$(æ³C±˜ Çü?V¢LÅ¿¸Ç›à^Ìb§ªUN‡áížî/ÑÔ•GÛæ1÷…Âô<©þ§Õ3GcT¾ýó¦ÉOZç¯õóze%8’Zh¾â„öQiÁõ†È1°j°yâ[^ƒMQT4Oâ±-1þi^ùB å€î ÓÂ÷Ú!l÷cß×î¯ÐYÛv÷…‹S7Ïø¬X1œÿr¬Ú/ÐÔ»y?ÕÞ¡>qIØŸúbY}–µ«sÜ©§ÂÜr4àÄÛž¼t®Êvjžûø8“tŸXÏøôlë¹Ln¹={c©r9,�ÿé ŠYó±ÆD™v^¸øÄ¢›ùVq1øM‡sâ¯}™<ï>‘-­ û\Ùô«k]ûG‰Ð¥¤!Û%ÊFƒlÒ@Í’>ñø13 ‹&Cgs"Ú 3@¹«O{‹Õ37º6[À<»|"NGßÕþ�ïWˆ<kÍ6v/µ�àç`ú’´R—½ð´œ%¸d6w÷Báå %'Û´’óÙcÌÎ@¶-jèõ`{ìPÏÌÓ›~­aE¸"],VE3;6ÆÆH©HHöï PŠje= ÐdëOm¥B¼lèLQ˜¹#!Z Ò¿ÕŒÉ'F¢n5_PÓÏ`¡ö¾H$N2'÷÷ÊÇ }mp6…ÎlÓHLÜÇaéŽ7¾¢´½æûºó–)œv¡óÚV×5ºdËacOsÐã­¯Þ(wƒ{——N ‡`û[‡P/½žá†ÏU|ZŽ }Ò¾vüp8˜oeqè¬iù_Ù?hXîs¾äAnií1î’ˆŽ¾™îÌêf½¦Oê˽&æïÏHŽ·­JŠs¿ Ðv:TŽ(u ÐÝ^üUë¼(ŠÌÓÙ…#QNIC,4·Ýte«m œ é“wM+¹·Hr÷l½%"Ý B¿YØfjzæãµï|Oç–oÙ줓ükQ™ºósO =àª}´øJ:Šöû½SP¯=ªK3ö3Dn†çUrc“Ó}Ñ{wʵJ˜aNO–©¶ªÕ¿À£ ¹Õ<sJljq1Ýü¡œ>Ûîn{XÐCnRßÕG“ìϧúöG3gûF3÷mëØD‘I õÉ5] !çƒQ/üõ�çsîÄ-Gñ|²Z;ˆÝ—Dk8ñü•¡x†™Ó •»_Ò™c)M ºÈLr.Ow­Ž9_b ÷?IVTyðMi‘fQš°˜êb„'ô§Õèêú™ÿvî&lÜ2izÚ�½jdÇWš™¸åÒ„Åo~vüIãr%Y-¨^žiÀ†ÒÙ¥6–Š’C¯ò3öòÑÂɈŠÒ¡Š’—Óbç´‰Í|Ü*á¿ø–J¬QU”JÌCL™äIµ¥*Fɲ!ÛÛOzßKݞƾ3iž°´09j ]Í›Wo§‰á&†S0µ„Բģ’)ÿ.ýâOúq@Cú‰©e’F+z5 ô˜UÖmMæ­ZÊSëÅŵ"ìÚ±S›Ù7„”´ï¼­ó7û5_94'l`FÉî²ó2‹#`JCèh¢²j»üôPª5c_Õ SÇ ú•§“{i*Y7/PÛ£Ú^<bOÕbåîó…Q£ºæ˜KLõBïú’Wzƒh©LxîÑOΟÎ-¼'EJ5Ç4zûæ*7Âüæ[›¡¼­Ó—!¥9ou<“²w(šµ*Có…"OçÆ7?ŠÅͱ˜TžexÊ|{HSíí(d¾Oçˆ-™ØÚˆ#{qWº<ͬ¼ €ÃÞ; ªF©/è4ëëÊAêÿÔ�/ñ<ÄØçô4Ñ¢jÿµ[…A£_f ãp´ö4ª¯ks¬Ìø€XbS_—A9èp––É•‡3Á;fœi)m­ 8æqÂê‘êUIäÈXY8bѦ6\”ˆÌJ¨ÞHcâ{ËÇÃh¾AFE¢é-vÓ%䉗oèqÍÞ> b-lþ<žé;`jË™o½é 0*½/b/«Ð5‘Yüˆ!=I§íu,ƒZd¿�‘ÛŸq=¯Íü_î$!Ztaó镺ül€b°œ(0KX…;¨{ˆ´s“‡âÀö1ÐÊGÞ0–a»âµv!d06TÝrŽ±~5½#¯œKËÛÄxî S¦!±4…Q …‘S ~æÆÝÀsª;cNeÉD†܃«_Øz1cnc*èLÏ�ÊÍÖêäîÖ©#ûu1¯µ£{~î½á=/;[»'0ü]Ï>YÙ•ÉžÕ»Öâ2Rêºþ2¡çµ]^@±‡>+†R£ñ‹6”_%¹Èp"XÁcÎ+D7‰�O}èßM¬¼pÃD*Wj¹´‘– 8‰{MËHÀV“téÚV³Pwùš¤³úÌÍ9Ý¢õ¶§í‰ŒWb­Ê©^ê–gG‹vouC’ÈÎÅñ Lš±¹s]À]'û‚a.Öá©’—Qºq÷Wjû~îÝbEèv”tùÿüVÎT¡À¢r&BVúiM|±”Yì$š¹1Œ6­œ—4ƒ3k¢]ðÁ™•2ÑþßÕ´ÊŠ7™62£WŽÓò ¿ýB9¶œ¾ºOdæ”V•Ž³£,åaó©Û˜Ö/4€Ð^ÌŠ2‹Ù%Gö‡Õ#,ÁþE •wXQÝ—´_ üò'T|äû\1 k:ÂlaœäÍÌÎÖ™î&ô7—½hǺ ¯»#-kØ£_³ ×ÞD}^ÎÇ!¤M*G<Ýà=‡pãöÓhÚõÞ¥¤]–õHÉ\ÓTAfè~1ÓZDT¥Ná»húŠT @.Æ¡|㧹2s‡Òâ…R†v«´Öˆs93Š¸Å«˜ÜGªâ‡¾[Ø.âp ƒ»[ø^â,u6Ÿûúøî:w¨ÂØ…M;(,*Úh>«£•Í«¯œ�8jïÍž<º¬0D–Õ×™kÆâJW#*-ΖO}E­¯¥ª„5s¥)ë,Z‹Ýè uLÂã¹Î›!!ýÕ|+/=ý,‘ŠdÌ H›¸úüµBkeôQÚó‡ ‡ÅtÂãh¿pˆGeœù&ÛQA¼f]Ìcˆ©Û Š„@;žLô¬û™*áé6i|Þè,R/'aM*BZÀªš 7a˜-xîíD{@Æ$|³D€)Ø#+¡@ŽÌ “=l·ìÿ1ÕGQØZR+¨ƒQB»§snœ“a=Õ;3 ©ï)Å‘Á…Ì—èD%·µ„ßìAÞŸvkÍSýW;ÙvÏ':Z¨¨L™Æì„é|‰â=K'tœ¨Ç ­ê«ùñ{Q™Té-g‹3Z0ï*Ƀ&rÇo6£ŸBûœ·Àe_OÛõ3~ékÑ‚M3«v‹8í®¦ÐÌ8�ú*ê”ÝžZñ2QÁ¦{ÒM i2Uxb|¦fœ÷ÅvÑébá4Õiªë?{_*Ë|b°Ñ’"ÈJ"†*ƒvgü/X=ÆVÉ0e(M ,Š«çZÁÛ¤‡ÊÞÇ ¦Üþ${hA—[ú“÷?uQØñ§©K;(ŠXZ,è°lë/™åñÃíoÍûÿ2WAÕ¿ßÚ=¹ü }aKÊîõž†…¶(YÃzF¶œ¶g+˜XÆo’–”fëLí‚7“fåw4d²âýÑ]σüÔ{xT˜F†®¾WÑ>3ÍV†„Ц¿€û9럨*VGhšQ{ 7iæ}„®Õ 2j»apLb¦~JìÔ¬ÌûÔ-ÆЖ«ÏKÙ(©üZY%:5;–Ûc›E*ÔmÃœbÐb3dûþwz‚µˆ81Ÿ¤ý¹½–A\ëóŽX»‹V³;Í ».‚åý”UƒhñíÛkßÞä]Y|ãœÝÏ´çr«ã•‰ë©iK/ô>Œ'»§s;?Vˆ³Ê2Ù„âÑtÐì,ÃÐýÅaÍœ»çÍãGÕÄwW÷Äa5ÍS:C'Ã*÷aÑvpÃbÝL+XdŠ0bõB;ǶH&º G+ñ»* ”PŠGŸ\)”Èr¢ô¶–éj·Œ ¼ƒ´P-¨ŒÞuævÀ“”Íô,˜˜ t³|…ó°ˆÐǃÖN‘ÝàÆæ4 ’A«D؆Ñ:el‡qVXé¼��ˆ=ì›ðSt|ÅÖG§ŒWˆ•�9†Ø¨ÅêOv!$üHrDIPœÄž³è•E­TÉëc–Û™Ñô²¥ªzÐ枉,º.÷k¬éi"«¢’ÀhŒ^¦²†æEèUŒRtOÊÓÎ5½Žµ/6Ę$+¨ç±±«ýÐÒš¢î2PVÛªw!÷FÚöW—Y1ïr€UãýùWå%…\Ê4sZißzà)F1v‹…UÛ¦¯E¹KöÁµ^Œù ßÛŸ˜¬ê…ÃG8M¦-ÈC±Í•¶Ú½³àIÜ,ã•lEæ& âùSƒDºŽ¢¥fýëé‚6-þllÀcí§¿E“P°YÚˆƒ]Æý«;7›ªf j’¡¡ž,í©–Q™¬d†à8˜ÓÑ¿Ó£�ø€vÚO©/‹š°¤ðå©kMrôí¶åž2KŸ¦"ˆ>ÿU²-H±N~ŽÒyFLܾ®µ#òÜQt„â.sh‹Í”‹Ý8Ë,û‰³}úV¾ ¡.I~ÚT“ÝŒ{ñï0³÷ßB>=³PÖ° V%,eOëó!\5òȹ¡1âÙìé&ÎIØ° o¯/f[gjK±èýÇã…3t)¹¶‹Oª`TÐcgB붇8Š9'ç„ýR±—UV;C5¯€Ñ&­$J–ø€=uá1ǦÍY´ý¾äCŽ3š˜ ã ²DŒRh‚̙ŻâhìþÜ¥žîUå#üè¸Ú¡%¿¸Ê×)°˜U~ïíî¼³•I—4΃iŸU[;àÌ;QuV¯,ÓÁ2øš¡íÇLïza‹9-¢ U”ÄzÞAhà…°GŒï)ÿø/òLéZúú‚åýs¯¨2OŠêp+¿®ž‘ÀkÐh€0šɪ“÷ÏžÞIêM)=ÒÞ·¨‡„)ELT•{ªI? (%¥G)ÓÐÙuú×5õæë¦f­ 3øxeì›ÝjÖµ+Y‰h»a‹ó-*åus…ÒÌðR ýÇï³óÀ‚{ƒÒ-aUf‚?dÂ}Ç3‚/Aª²¤h½]A¾EX3öøLÆ&Ј³' OèÌÙ»ÅpßS8?ÔãçoðrIVæqf«{º¥¼¿UXc3Õfª6çáhiÓÿÆñ¢œ~äœÉ´wö^a÷"ñ/+}#`,L>¯õÑ¢‚:ÇšNþ’|îF¡)7 •>_ï.lêr–^Ur¤“ð{»Îç͉F`x0Íx1‚ˆt‹Rr> qÏç`”TnÜ»9tªÞ5x QË–'›cT®Eôš"´Fçè `¹+{*ÈÎ*»¾²¯É©½5ãWsžL-³ën†}s`…rð‘sòžJKžÝ(I°Äã~òò‹¹ÛZäÙ˲Ž¶W!S$\{°Ñ¬'e~„ (ÂRf¹Š{Øʈªy™ÏLzqé¥_Ñ+f"0El›Û ¬VÖ}šÇžNö«mwPÄP¾«ô×ý !ÙTëF±§ §Œccëre†ÇÜOýèæìêný'è£Ó÷€Ãy¼F±oq»“}ž³m¯“4à\�3ÜÏ36 §§ žNŽPœ ®äƒs�Šc*×ïÐÜ¢.›˲4º©‡•´ççŽãÉRÒjÜG´8¾ý‚bH±’àÆl3¿I“°Ê°˜ð‚S]%¾ŸÙùÆcqéõ"vÔ÷Пßw¶¼`?JBç·~*®Û­¢ö×^þAk±¡ç¦õ»÷ƒ§„#êóa!=¹‚É +RS˜WW_\Ñg¡B˜õLL-ó¼Gj‹vŸP,¤Sog‡k𖮈Ø£ñ“\¤qð£7ø|×1aÅÖÆû4^pyâÉó‚gOì*±±ºl1/·.§1 ³VgËx´if/>ÓK|ŸÌEkB:3þ ˜ü´qà‰ÛÈ6yA‰+ ýã’ ȷÔ§{ˆ,3ÚÖH@F4Ó§‘žéxkå±äŽ™¡|Ðpvq¼FŒ’$ó¡’¤L¶ÓoÐxj{¥gÃN}}Î, ô¸­å p²5U‘­¥›å¦ÄU/‡3¤!æ'.Fi¹º”óó -ÀºvKQšÀ¡ê‚ÝoË¿4’¤EÎ:µˆ²ÞÚâ°{§M2ž´S @zï\}ƒX[Æcl†ï»sJ9ÑN¿ Áf»bŒõ‡¬µ«ˆ4ÛWd¡7‚-EæQ¼Ó?RèO;Ûž ‚Ý¡ifã|nÆ[˜¡ðnˆè/8ÜG‘Žx*SÙ4-÷“úFŒÇ{ÐŒ"Kø,~X×ê#º¾_ðA³+±Ûß„.O ኧJï:Ú(xxÒÔÓoGJVŠAO™íIMT½Â”ÞJ¿¶¡K>Ùî ½÷@‹7nTAøïk#‚#å}Íyž¢"3 ³N¢ ¸êÞfƒRÒ¬·Ý˜ Í„ˆg?ùÆÁ…aˆ7è°î/&²!ÈQ† L‘4 ¸ÜÁa>t„‹¤ž7(î ƒê™ö‹SHê\EQÇõÄ~G÷LJ¯ËsøãïÑuñ¨Ø€ÉÔ–ùªÁÿ›ÈÙwÑ3+ãSª|á)‚~á^s‡+ruóV7è¾;Oot¦÷‡YV ‡éMÝMÌŒ½ú—HD=\4[ön¶œcí=i}Þ)´Ã’³G}EïFËwðÀüãÁo1œñ* €øàã‰vbc’tP³àÒØDß,°ýF îûÎØÇÚá¤ÿÃÚ°ÖŒ- ¥ 8…ö³øËë£nž:,%Z"hg± »¶Ùû‘74ðÏC뻘ïϦ¿ÎÔ±õ®lb”{R,gsêèO„õÕÉ ãÞŠá–‚ë'…f”Ï./7BV:!7¼[ª”à ¬$]b Âê%`<º›­øÔ@}¬ÌzË™ Pa—‰µÌ1%¯½ 3f ¯ÚR¦qxƒ™¢›œáÙA¶3ôP½.Ú‘ÃÄ8Jø§78 o|;©†£õ`•qx¤9ïyT Ùþþ°�z)/óÆzÆßéñ[eS®êP]æ,HÚV!ž¹ÑLåâÛ¼ÿ-hàÁÂÓ^–±L‚#tƒ¿.†Œ +›·zc{dSÝOïצRQ¶B Ç”•ÇA:¼[©¦¬æ¥2 ãÅrGþ"Wû–mAhº?;ÄÑ-6z¨ºÿõ—BùÛ3ÞM 9þ�À@yEºŸ}]$Šk‡­Ü/äBS·Ó¤‹ Ê|ºWOã—C¿›Çùæ�îľ람QîH#£rM郿ñ-@Ãü—É>4\ÌA©®/ß·yjòì/‹¡góªíkZ¬ÊwŠäô”éhéjo´ðzF­ÛAÉܨ]s4b@+Å?PJXá.»6öæ×l£%&†û‹2†cžI-èyY ø±5ŠHêbøº¿wé\¹lZ.ð¶n;ú0½O“˜¢„·õéf;R ô©ëŲÞ]~C,aöÖæåõdºCòç?aBPôDÁ`_H^;¶…L³ ¦IA´˜>í¹õaIù0Íñ4€Ýp%0ö‹3u¼U‡´îÍ‚xŽ)Å͘âlfð£ªYž«)(ùk£»kˆþÆü Ç<—yiõ¶]AŸ¼Þ{Ö­k³(™ÐÇ Àg›ˆ0 e};n5çžËИî)oÿŸ7î•þ÷-Á*ZõaïzzPÒ™åQ^YYHÈÑ]¨$ÍzQV*©´Ô‹Ýô}÷ ÏÏ *3A^>$®ØÓÒO½Ñ‹Ý7æ]®XºÃÎ(9p髯Àªu¡·ÌOªY”²!äQiËû+í`óÏÙHDGê,Ùî‹ °®Òñ- ýÌð 6ÂnEˆmƒØ}»û,Ñ|¢ %CDÛ“7K7JŠ'3À•98øxp<Ü;0’l…&‚ÈmS2^¶»ôÄgÇ«³âõj¡[odëL“YFú.¡Jc'uËàjLîÓ}·æŸÒX/@;Ày:¾O=»R>Ñ)M«–^9׬¦p•�dÊÚ;,–|–¼È|Mæj'Zé…}% yý•ryS;héô;QÎ*•ó)fÿpÙªF¾lñº…A1ºh]ðƒÿiôŸ$vÒEb¬¹9&A^w–²\Õs“¿)*2Ì éD\õ5£È‡æc*õG‘µì`8spºnxY‹ßï\Jò×ìVšw—µÊ q;…Ÿ}¨V™jCUÚl|ª,È>gïh^<¯\Ëð`Îÿ•ÑsþáfØCÚ|\ùÙEĘò?Aò©¶EaË@_|×Q¹ØÍo3ÕS÷7}¶4]©kB·k˾õtó6\5ÐòƒL~ë5­=ñ°4°¼P’æË*¤QÆÜNõÕMÈ‘ÿ¿)xÂ)~Oü)ׇT™Þ(§6t $síùô»ö0ØöÂK Þ"É<K0¡’~\¶ ž‹ÖÄ+I¢æ(.¢ÎÎw`hï\pßÎ òYŒNÕtÐÓ/S_ ;À/Žýçù°,¯zÙGΤ,6\ktãóàuiÇ7µê¨ý%!¶.´½bAÓfïïNI ,ݧ}J^ÆÓæžÇk`´5}èéê 0Òå=f…;o<\ᥠÔÇEϤ<ôgíÅètîNà?:ÔÓ +%òô­4Ùm†,¨Þ5ñšº–b¢­b,ûOjwq_¢Û­Júz˜áÎZ8„6­3ô¦Çµê§ÔHÅz‹¤C˜‹vþnõ_)']®ó Ø‘µWáƒr‹þœéi¶ý“]{¸@2€äLA©nh§¸+‰&ÏP²I [óLEÿc¤¼©z_œ8â¾»PÁ2}uZpüÖ¦$½'±žÆ7ªkCNƒ'àMÇ™dæÒIý Ò{ìÙ#ƒ z2Rg»=¨Nô½_c FyègêÈNpšõÝ‘Þ±¦¬Ä*Z6”̬¦!ˆzŠŒs.9=4Üß6{ ^ÕIˆ5¶^ýß òYS”¹]Ê[‘pƒ7µdS)×±Æ5«›ò]ôÒ5ï2òZI‘™~ï§ØSéý€É•5n'cÎ~¦ÏÖÀ~ó”NÄnÍ…³t+cУ`%H¤ç1…J²ò¤Žã ÜW㱙ꎡô«Ñ\ò®x"¤‰'XÀ‚Ô ÕW¯†c؈³fU盚3ñõbíÔúˆ(^y#2ßàp¢TŸÌXd>YÖsž¬4áœ�P¾Ö"ahbƒâ#n¡Ñ¬T¦UdN§½zâ¿Æ]0O‡y3v^ç„õpt|G–¹ºZlªJ .è¼ëo  ZÞ¨ 9*: ûÔ5*3ýX±'NV#6Xž àÜXë…"ðä!¥jš$%Ö Ô~Û|Ë+÷K1é.ƒèýª ÷Ú ‹óÿ6„Q'x¶úñNsÆ™2ˆJS†yUNÏãì�KèClª–?ÒÕ@ƒ˜.é_i*Çùª¥,CÓ!Ü©dv«kgöÃH~±5v$ ¨œ:Ê/Ç“^®ò$9Œ?Ô}%iP´{û­Z³W¿Á„ÙítóỀ]håÔlÉlz;Ò Ð†@Ty4|N9u°'úT<µñv˜6ëÂÞzýÌ{qŠøbo ô/>íݬµÇïÝ ž>w$435p.Õ%÷ä+ pH0î«]ú©23žÜ šPÓò�mUÜZ€,­á|8Û* ”–­èCQœVEf,dUÁRa Gr~V±2Viósd?=˜# ʬë�±‡D7ÿcA€Ä†¿/îgžRņ€ÔÖá$Mè&%5ö !+WÞ#P«‡BÇôé ›Zh Šã Ç“€QhLx–+„E«…k‡˜£tC3Q�*ÄÄšK‘ºIýgÖE·FFQ¨‘‰in1—DTÿëòrÚ‡&ØX±núƒÓùÈPLJ–§Q¸gAZ|*™“[<&z_Nâ‘OBeÔãMж ¬Ì …¹x;ÒÈývÝÔ¶‡ÿßÿwz«·œ¯•×á‡Ò- o:¢¬žZWõlÆñ„æ"7Ž'O.Ò]}W-,*ËœCáVQA^QvûéXZl‘ „Ù¼½yÙ=4{Ž²Â•¬>ÓÏ•ƒ:¼œ‹3[à˜$*éÜ2À¥g IäË�P໎T h^4U< S”hqõîéóõcn·Ì©çá€4A,g/:³Ej÷*\˜¸aðï¹Iƒòód^"hw´=t½í©€›™iìÇ¿'àñZN°WzbŸš#2 »A¥9oo@äÙFç&ÐÌPÅf-Yw‡žR+ |Ü'QܸT Û¡›ÿÅnÄS*tì)Z²ÅÇB•r¸WZÎù %›<9“¡Äø-qåô DJص'¤•9íC;®†8ó¶5_GYr>Ì*U‘5³¾¯Ì?žÈ[\lú4ÃŽr²b°œ^T=›fèÒCrÓ\ß(€ôÍV îüÎI xxœŒ«= |Ú;ó•ô™¬ü!ëïN¦’ãf÷å*™@› Næï–Ô7bzsìÒ ?+¯bQ ²KÍÅB–wG-+r0Cî ¶æÃàÕ÷؛ݤάˆ"6QæBîýKc?_¢±L«i?UAqQ98«žé;+°¾gNÊ<#S¼\» ±2\Íür�é”[f—¸nΔۊ•s/�êr3ˆ23F¾ü¡‡jQŽèùatÄëÈÑ ;”{ 7?Ý4�J­Vcˆ „Ž¢ê¤ç  sË$éb]õŒ!`qPjJÅÝqkg†>YÂséúÃ×ÌÚ¹Þåd{ú’Óôd»/úùtU×—€¥dÞØ­CŸ®Ê€¹ Рo³ger+f¾ÝCA_÷/Ï–zXÀ®æNË"s)¸¦‹¹Ê‹n¥¥¢’l‹çl@If­vF’²F€7éŽéÿ0¦+öŶºˆ90$Ö)y A;Á~²åË[ ©¥ŸJ›Èç†2‘6³E!ä0¯ûΡN^ð/½ôœ}7S”ûKgÔZÜè#›´i=$–DŠŠ4Ö³)å`ôx˜¼žÚÌší60?Ê]¦˜„àÚY‰UZGÄ⫈'}Ön²ÆZ.Yè:ëö×Ó^ßÃ0Ò»¾dà딼µž²áI²U1ªZ~#ƒì(‘ªD”Þ9Óóù^(«ô÷5Q]LÛ]Ô1ɶ‰½cèúcX:è—_�;)]ñÈ!^sÙ ¹ÙÕÿv|eÒê¿Ø*²•È>•×WZ°Vcl(:QH(fEo›ÁÚ»g¢xpSOÇÙÞÍûìÑtå-MY)|ÀbÛº„ò†ª 9vñ¸ 2¾Sš8mu^MT¥.ŸºRræt�NÁ"žb®²ŒÓçj“ãÔ¸1Oâã6V¡ ÖMÙîÕm4fòíÄj›ªNÊc™”¨,}áÙ8#äÔA€;Fv4Så´¼j†œd¾ò8$“Ì‚ȘOÔî´u�Òa„Ëñ ÷{Y¬È>ïJoD‹S35Š<'-Oºô§ù¥›$军 T.ÿjÜKO×ù{'*$J7»?ÇAñ®÷²ÈÀux%Oæfò·¢Ô‹ñ Á›M 66ƒ¹Ó"ƒèçÛ´�©§UYüÙÎÁÉJ#V²;Ó™WÌjBÈXæ¡VT"'ýuð‰ȧ"k<¬ê¥Íœ•õRÅð°#“𹵤ú¹Lã¨k•3Š!‹"c­ELÇn =:Ì *ù~èø¨àSçøôƒ'k¼ïÆþbíö0ŠvwF£à‡³_Õ™ÃÜ�ª¡ôwV£ÀXz½�ǵýß“ÐGÓ²nm$R–ÅBÊpe2­T]·ßoQæÔ½„ÔFÉX¹ ” «ËÔ±^åžëñד{‡ÅŠ™Ñ=Dj }Æpî(·UU`Êqe¥» Ž˜pOy /=ÅÒJ€«Tzè’?ô`œÌ³gì‚}Ô]ïfIIæRº°dîp¾íp#`òÑßÌÙrCÇèÄÿÆ9  æùÉ[^åWÕÍÓhz:¸kõ›@KˆÁ2"§Þ¬@Ö^íÃv°ÝŠL»ØcÑð]yöþ·~"‘Bc`6e!P´ª>Õîk¾–Í^sÃTö8´ü˜ÿÁòtßTË~ ×ÛØH©0=þÖçÉÌŸ{È^˜êZ`X›\\ë…ÈbŒ¦Oó/Èg™jˆ^zM5En2·Ûë0ŒÆÚótÜÎÇduœ—GÌêºÁ»ÔÃný³mÛÀ‘µ®.TdWïíJ ‚>"½dÄW–+ãZð¤ò .Þ˜?Vó9v—9éÏš5u-}f‘ƒ± í»¿¤TÑׯLC-d Xƒ´±HØÎÒ[,÷¾ÏG5ÀÖ|¨ÇÑ¿ƒB÷PÏ<½•†×ùâa†ÀçfÎk£üØÞŠ’4ŠBÛÊïr‹Um{¬\ AiØI³fþ˜ƒ›dÆ“ù¡ôD[öóº¨8JÉãá8REoÏ’ù< Wn5‹ñ¶÷O‡dË|u-¦öÒqÚŸl1_pmý…Ô œ®Q}½Fn‹…Á¸·„dä’йêXþÞúoã}€)wWÐ!Ç(§ì{lîço.UµVwÍàÃâi™KÇ‘ïï´‹²,ô=~€P¾A¶Õ{/¶Ø\Å8¨l’Û‰Š§ém`aTÉ3Áû•ˆñøÀu¾îŠ›?èYWu«Hùа‹m—hPmDkt;ðÞ+ÿ�5/“!×eç3™6v UÒ eLÇm‡úE]ûÄSRc=ˆfÂîRRÜ Hֺ픙_Xæ®2_Ç£48ׯw¤wç¹Â"S3•~ÑîˉЈízæ-Øì¹éLãÈ zWßè»X‰˜}K¯æ«(´Æ Žm–unéöÏ?íq«ÛPÙf ‡Ÿ×­&áÓÖmñžVz¯#¼›Ÿêé<|3«Ì|©ˆ oŠ ýzw ·ºç'ËGëDsÂy×±öýà³Ú*…¡÷ç‚2Pu½ؾ ÐàÖ”yoÍùß‘X«iÐ Kv÷—žÄ’zDe±ósbÍ œÅÎQR½såüT+m+J†¼äAèZ³™'«Â=¶z:)\ý¯ÔÑÊH�êS¤ƒv#‘·ÛÒÜòëpÏho2èJndÅN‡¦¹Õ°·êÂ,>’>xYóe)ÜØ—ƒ|èÎqšFç fQÝodaæÉ #à³h‘¶áSÀ…©6°’ŒëãzOéÜp?Ùö€Ì—ÜSö*.)%÷Ä©ùQǬ*YøL¼0²šë%è 5˜tž/c}‚ Ó_žà&™?±„ÅD÷:o.®òà=tžl°Ãú™mBŽY´0n~ôèIEâ†ð¬l>ìÐçlC�×óQ5)¦³u&ñqÐ+ RèÎ-Ž³µÇîLçÄþ¤â‹ Ǥ™öò¨Ðw™íÓ†Òæ~¹[Ow˜r]ž¢*¹ÐXÙ‚CÇЈºíE\`–E‹T[Ñ‚¯‚²Ö]Å,-Î,©»æåäð«le[û¯$(¿Þ=x”»{@ò܈šn:ýi–š›trżµ:û•ñ‹#«Ù8®«ëïÝgOM.E=±äXsõ°8ô±*:ž€ÄÓ¯ ÈÜ{Ý*÷‡¢ÐXd¦lŽ>øñÜK[Hh]ØŸÛžgCÏ 3‰oJ·¤ûB°X§Hx ¢%Éà_Û?´²Œn°?Ò²(NÔÃ{:8,OÚ7ÁÃá�T#%*øèT¨¹ÌUHLŽmä#·> ï(úWV} k%<n?ï##î œN׿aLy‡ð÷ß<;¡#k  ùÐAagâìF~�–ËŠ,ߌT méå,ÿ©+ƒüªK¢"©þ02^âŠ*i¥5ý:«µÐî*Ą̃Úo°ãyvú‹ð9SÞl)»„ÃÐN«Â.õ°€Þa¬„”Y…SÑé¡]õªVž”ÆNtBB±2¬ÏÞ„j¡D¬~‘CGùØÏ®§œ!îfõ² n‚'÷‡Ôw/ïôžÊÌÿ+´JÏM$Óâ!êa?Z5Ëó—™<Eâdž=r$ Œ0HßoÄÒ f<nÇýš<'ñJÄ€‰ÛaP´ÚÉÜR0bl¼vœ2ƒï¯´ã´|¯@ùß>¹ôÒîª4FÌ CÍ:æA<¨ [3ñÄPiÊt0x²l´uz@z œ£èwYÃT®6^þÀ’e±µ<#Ý ›mý€]Ç aïòVC”Ç.‡ Q¡ìOô¾ïVz°ð…˜éø=B³3*sÅ6ãt>~WEŠX>Sk©àÍ‚¢ßyâKtÊ_:µkwÖ{Wüþ"+MÚtÉzvn "å”þ ýäðz0ß¿y5%·b‰7oB\C’$ô Îî€@`ñÄT©Q |‹=2ýóÐC3Œ¯ŒƒÜªt2@þãÀ¸Mû,%é÷m/ïÚ_F î·¼Ÿý}ʳ† Ð~0`Út‹:Ær¼’±D6…&8žË¾v÷b/½´þ_slðú-Ô´¼”Ö Øšã|vò¥{€œ;›WËwgñª‡Wv*…›"8žú,ˆºÖ#&2çoD•¢¸¼1ÏnŠ‚RŒ‹§b9PBÜ,u¶½ø¶à|#9çC]Ôc‰à'Xò“®hºÂÄ탬­-Å18O¦ÕÛ&–qwD'ŒÜËô™>É桱Ää‘U³`ßm²lú“ CùýŒ˜eÜ©ðé>ݤw¡}q^l"¸¹é¬€û# ©²¼QIo‡ÜC®<¹8«U[~Ñ $¶é1$ 0(z{åÅ1¥šÂ}7;sPôü°'¿QØû1ÎÜÊd6¤ôæ»Å»ñp—©û*À±é__·Ýï1U †NŒMÏfÄðÑ£—R™¬^iÆ®÷žYößl $¬ \kè­»É;Ú€á×ßîßIÜäÞ“Ëܦ�RË °Ã ͲÆÔS Qú¸âÌùŒJX9 ³äÜ— JZëB-ÏXf± ©°ADjŠWcŸ$짻—TÞF™Çz£³ÿ:ÂGëäMèX@›¯ùôèúŽ”?¹ÇzLƒôÓ ÐåÖ¥ÍHX1“^_ÔÏùº�šh„Q“~t´>kCŸÅh2Oôѵ‚,±Æ£³žÌÌ—eÅì)³ìD0mcûv÷,b±Ú37à£"¹í0v³¡'‚º…ÀßÕ-·—0Mí(ÃE%]±8­d«Xÿ0ò‹,;º^çóxkË] ¹åàpÏñIáw"¶O)©S÷(ôâÕ;ê-Íÿ¡ºÂQÜ­6‹‘yø’qXú©>ý¡åBk¦ûw­#£$Æ[ h)J¼Ë»vv#>†2ÈúÙÈl|УeÆ»Iδ úNÄŽ{G xOk«dŸÇšõÚSGk Û©þÓ7ÆCAŸLÓ+ !³»ø‘GYé]ÑQ×ÅÜ9ÕJZmgø"è7Þ6uxï§D_ò­P{#ŒFÓ“¶DPìmiE_• f&£?Hã$r˜snéÿŠÝ—AP°  \Èž®"Cà¥ôT <±D‹WVz´T/µá—ÅVÿQì9ë«oþ²xZd•îš»ÿ4ÂöF£ œÞ¡/¦èˆû¦ºkÝ8 ½=lÜÐê‹l}š§ Ï‚¿Ãf-ìæHì‡ÂŒ=F(gÌ&µDÓSEf45ÌÄÚù -’WÓÈÄ%d¢ÌÅ˧6XYˉŽ–¥é¨š’NÄ‹uK|sDTßæ¾Ý}¾†ÅžjÛá^ƒüÍÒ|f£•¢Ep~”n:š¹ÀOmý‹Ê§¾}õ†×Iè ¸€oÑb0n­Œ*¦w€¤C÷×÷…q„h+ô82MŽ#Ò ÅÚ /TÛžœF>Ðaªä {ëù+³•›Xž(}ë,“ñÃ:ºŸ G÷%4½:K„^Z:¨Û]«26Á¬û<e|Üuæó=–ÞÿÖ]ˆ5“·íÎÉR‹¥u=À–¢Í`‡S@óÊ'Õˆ*D¢'nUTVÜŠaá”nLþ3Ez˜SÀEcŒxpL׎ è;C©,t«Dmc(Ü&[Å5ý8yædóXû = ©š’­Ì€ÅÑ >{Wjú—ßhÕo¶”»e6å¢íV€POÜmÈØzWÈçö׉ÎJûÛ}°lÂA‡ X‰‡3à2ð8á¡EŸwµúA_¿s°"Òž#<´C‚Ü:¢µXœvýáß}TƒŠcª™™¼è¶^}ƒÁ¢ðÑïÙxªÊ,(%å€Ê¹Ä9»)w†‘hŽ]‹FñåþÙr=ÑYg £-…à+aI÷~E®ðù1ôèZø#Ev\‘ зw7*°º pšÏ :<#$3ÊÆw¥ïÏç¦Ô5àļ*•Gk‰ZxçRl:w‹6“Bd0£Üüó{C>N’ŒŠ4iY°FI½ÕAáƒHí/K*Ýó@—4ò Aƒöo(†ærMéÌ·Ü(ÕùGDëEM™¼ºi“í¤b|júÈ’¾3Zÿ=÷ßæg¸z F±UR‹™UYÉ{ë\aÂ#,#¬r‡âüŒìœT! A.}I)`ì<éñï¹üÈ0¹Õeû½WúAÓº¶´a…3¨´mÑlŸç—~£¹ûZOĊ‰DÚtÓéDgIÖB:A|u.ïTbúÛw9UÝÖÑwÅcu˜Ycn3Ö½Ú_L}ŽF$d—>§@T÷žÐ-̲ÌdÃà€û+óîìÅ+®2Qž:ÑE^¹u² œÎ*ÆZ`fUU9´›óI_…ŸØàÖ.…EHk*�fªÛnb»—@@ÖtÊíÚ×êáF–'õº,`'zìÖõ€>j·ãRIp«\àÿ$¾^Ù…*®›=,e%!—=ë1´ MèµííÅ››ƒ3bUxø8,X¨0Q.Z>Ö•yAfƪV¦åyá„SŸœHûnœÙÚÈT±çFyž!Ê&1@•fH¡À­uv#Å["û¬ƒ`ïPkò+ŽªØ#¶#Y·çéÛV$+ `¶7+¶<¥¹*¬þ¥VPç†K”vGDYžùÞ;,"SÁcã9 ®ÒÌ` ’ïQ÷¿úÕÅYåO‘cVÕÊþl›–xw:úÄ ò9ëyºVüøKO5!Ö*µIè¯ÙN~T@y­þ·ëæeíâ—ôšèZì8Ý¢èÌd¶lè „0aý_‡ö'&[’æ®ìâvÀ ÃÄb×:'>ô°z¥:‚ÍÍïŽÈª)FÍVáµÆ3´Ú?@.5³/Là•ÑY‘†þ nÚvsã½íTzÇþ=Ú'ÍÒÌa™Å©¢M®hˆãðT!©A-Îù¥ékÿgËÄ/oE•L ÕËmboÍìóÍÏppxÂBŠ³ÕÄ‹e\R:³5¢§å7\˜ÏPþ$/Ña¢*íÉoÉMežJ4{?R1W[‘ûLŒ¥!æârÜfPñ]†¥ùï÷¯Q†«9@Ó :uš²fJr)o¥¿¡ó¹òÚåGÁ³¥– 袯Í3Xãrog>+9G5²>¸7\·ßXHp”6›ºÅ\MËÒ_}™0ôëw�Wûœù¼¦ÍÜ2ÞáoOõ<ýø¦?ÿšÙ¾«º¬°Ñ°N`ÐgC³ôÙí¡ÝAœß{o¶™pA<³ê€/h‹•õ d“)&–ÃâMÚºe¾ªOÉDÙÈnDWÙ“{|T§•žvblFªy¹ÊÄdÜ,˜òP)Þó6£Ûrâ­ c2yÃõOôÙ½[ÁvÄ ¥±ÔÈcƒ›2ôãuw}>9DRê¡"èÙÕ¯}÷»…Ð`A,•yž/ô@@©LœÑ™xÎ4 ‚Ìžü2Ýrhß1ÕJÞwY ¹¿ÊYþy9ñÝö Á$Ãíû¤zøë#;§)DÌŽ1}»ív¢»w‘FÛußÚze’² Ω¬Aég<7ßÀIBÇm/Ñ#¢² }«r(¾Shkf'ˆ…,„J<aA4>õgéÌ>ǭ䙯¾®ÇB[§V‡Š÷ss�ðÃHz‚^²é¤]ÄGú ‰X¢J‘øÂO˜~FGÁ¼`ì¸V–èe‹aä~g°Ben†fò±ï68y/‡nýÃãF­õ)”ù=åK´ÉéÝiËB€[6pGÜ¥ ~y‹ GâÒ´§ îuX˜˜ØÉmÊÍxâ$q´#åqPzWìØTÒÊ°r éoÙΞÚæ;-—ÉÁWY+¡VÓ“_ð¶ÆÐÂF¹§ YàQì[8õ¶Þ8AäB˜«ææJúG÷jÇ\)€¡|ƒc5$. ÕG­^?΢ RCq÷‡ƒ7?âk1(àí­®3£Ç�ýõåsÖ¸õì½mVß�Ý‹(ØŸ0Þ~9Þ43l´ñ^_AÆÄ·WFòü[5‹·Ž‡¥»3V¾mEa,ç|n!.Ž/²6¼HÄE³õƒP ˜"ó-XZ’N¯¨WÛ*\ë{ŠõüÜ!•¸1*yÔØŽþc/YðZíí©ýÞ›ø7uÃFÄ.ô¿êzX…«Öú-YÆÖx€F)¦EŸ5Ì^`dÑPO-Ü](y |B_¡m`A•òyç‰*ýÆ'QJ¼?8uM®ÉúŽ‹CÅ«‡H䮄TMåSÄû7¸5b*’nìé.÷Ý3K+»õT¤ W«1³È² :ÕfaCÝÌÔðøQÃLtñqeÉ@ „€²)ؼzÓõ¨0 jùdÑa%+â×€ËI‡rV ¾|û—¨ÌýY0Ý߉²Õxj<½n8hxeŸE5Ü�Le¨n5‚Gu Àa†¦þŠøäÚab%–J œïõ°ƒˆÍ®ž†ƒJÿ\ÛEeL)ÐÅA>¨©#÷Yi‘R„0Â&~4íRÀ]“Ûï±.»u0`Q°þË ÙÊmsC¬ÿ ]°ØŒEÜ刷Ú6jüÂ80Èäp…ý«Ì%é0+¬f  W*ePð7À(ÓpRÙé$nÞv{_Fj÷ÓÐÁîêEÿÉ=§Åœ sZi]–ª‚¨Ías­½¢h¡ a˜ þc4 b_…¢*ô1«©óÀÂôé;CÏ0OõgÌ,ñH ‰ÈgPÅm…›àvî&Qåê{ŠØëºþ±œzÏ›#²âÊ(ë|ki:U˜eª¢Èû¼¡i‡m.iPž´PäįâÀyG¤Ý8â^1ƒºtŽ¬É=ìõO êúúÂaEi¤ä]©”i-iU7±¼Ò¯2M•CQfÊœGÝäTq곂Ùl`çýþ¯IÎ Vœ—㉪k1_Fâš×UþœT•çÅžQ +�EBÿl)c²ÍBï|ž{WpÓå:K«‚KKË!]<µùм-žáR‹Ä£¾Š¦4Ã4ßádþ¶gˆ\o´ñn¹…J$-ŒÌä!Š°Î¯=Þšxß”tôÐRÊ&„nÏÓ¿†t˱¥iœèŒ»¹Þ9€ªÐ7?…°ÞB9ro“*† oóº&uWïjSèIJU»Lð³Ø<Q•·¹Ôe-ß#þ'¯A^äôS ­™½@ÌËz´#¤íK]‘mFàŸ[^¸òNÓy€‚ž}½}Ç$u3!é ZÝÙ¬¶fCˆ®o¢h¾¯/98ƒÌ¼ªžb€² i—†I³ncåªECvýëc÷8Ž]°#M…"(,µÂÌ'É…e ÄÎïÏ[ UìÆŸÜíÞŒûV‡²^·46v£©g”"t‡d³3±v£wì†( ŠNÙF€¿×éÅÑýç+¿R¹…/Ccºùm&…«¡rüŶË)Š["27[Îî”ÜKú'e9Š=yŠ•RE\¹=ÖÑìÈÒ:„!™gÉ3Ñ>´¢ÁzïÊlÁíH¾]Ê/‚Ê*ìVµC0q£­/ýÖÉ=sÁ¨\ßíŠj<¸£Z}ÿH´wl\múQçëF D Hë<®x Àåþ3¤ÿýNBo\réz„~‘§~ 0*W ¨jzFýΞ¹9zçµÅŽÌHû`y{ó }ÜÐ았Ý'lnàÀà¶zr.M¿˜ÖG>r^Ò÷ ̱ÒaçtºÛ+ddŒJ·ÀèQÍ •ñ²’p¦î½QnîJ7`º{q+Z?MÂmbÓCƒ¯N³îÍB‹­°Œˆ64aq�mDh¹@ÈÉwoâÿ‘.áÊ“ñEá”îIf)Ûüõ¤í›WËIèat$壚&üºZV (t†(ªïŠÅ]ºE’ù9và¢4áÝú3Šœ)ï[:;´ñã`ÚA¢uÉÎÔíbcÐùM‘T?z5YŸæ—NÉ™ÉF}í¤½”8\Pjâ~ÐGäÇø¨Ý%ú¹cb¢T§Í‹ÓÈjÝ…C^P—ôŒ¿gÊØKü©(Œ,iTæ×»3ÝžÅ:˄جm­ŠÜ«ê™ÿ�ù´ÃÐßõ5J�M‡Úš_L•ÀBæsËôJß~ÁzÔ~v/àR’ýä1ëì§g5@!^V+]7,ÁóÞL”}·šv¦Zð´F`Ù㥼ý”6xEñŒL…:ž¤Ô²\^Š ÂùËuëѲ´WUzxÍ[¸Û gö²jÒ?Ô¦2–J‘ø‚àð¹Óê; Œ¦ usyc°!>ÌP„rÐ]={`×W¨—´ò1ê–:gëçÕA�O/�…½¡ìàhflP0wtH³ñ®Ïà¯2ßä•ÕœÙ»&âY,*žN B‘L¸~Ù°"5y¢1wIƒ™;fON`ÒÄ‘2y#fgšqLã`³…œ>J‘Ö¨<: fLc­øN ìûp¨U’B–¬[¦ö8ˆ¹°Ùn^î4½J§¾Á\ý#¾j£š^ƒ7àÄòÌË°Dðƒ}=)«Æ-;¼ˆ3=æÓÎSOSfMOé”7‰6¥üƒÁ6Ò?覀1¶ÇÃp×G) kÞ"<‡k«è)q³›Â3;©™ƒˆ ÆÑÊ+:m½3’ ßúx•‡‘g͈æOÅžC<i‹yøñ£‡ €—ô´ÎrÏ >áwn)Ëß—¯lëþÃÍøÙDˆo³½øVŒ¤e•»yŠªÚÊVCžÜ‚¾©¶¸ºž»ú#Ý·kÝÛÞ‰ñž?}ÜK´²úSõ>º"øaB’‘ƒóÿÅß @D©# €oÀ¶ì´ÂúÝxˆd>êa¥¹ï/ŽQj‡yL¯L04V¤µ×Õ<ÊôÆ´°®ª×s\Ñ-þãU›–Ÿ íþÚ•yÓö¼€õy®Û‰á ,îµ?´K©däã‰qÊú«`Ë4öç4Ò,Yq Å„®|×zô„A•�óC\ºIXü"ˆëÙ[¹Ó.e:Âû HáEXv¨Û `jõÜðD£tSÐwwaqÈq˜;/f4 °rö_kFétÊyiWÎàÉ•ÌZˆ&HåÔÀG‘ Ö”ë©=Wù©mœãGR f‡^‰ÈyÖgQ™4óÑëwûÌÔP–)ߥñäÏ´®ý£Q”žYBÙ^ÝÖr‰f@eiÊ%â³Ò¹ƒ÷Ó½ƒ•zõI˜/ð1 í™±ó'š’•¥óÅC 5ð-êtöƒ+9'¼«Gá=‰ l– ‘löœ„,¶£ ~ºéV?š°'ô…×ä‹ë¤ÉË'È+W3•7%éô iá1Ñ^D»4»2ç¹¾´F"é{šÖ¸¸¤˜Ã¶*• “¸ 8ÑÊSþ=Ê'K¬Á¯GŠZù¤ed‘€Ã´ÅU³æÿÎ:»„¶©Ë*$ë3Š=:úº½JJ§!k¯jFÚO0ä2áçîLê®ÆJäTzÈ|�z©@ññŽ€A_k³ô‡ßõùL£ÈêˆUà6hÁÅ{gÆˆÈ üÒ†S Ý£ê2rìxÆ©¶,¶“ÔIž³sJÛ<ZQ|¥R¸û<b{|¨ÂâÀ@“¦Øý•íð´Ç ñEOÐÊ|ü»¦»¯9ñæ‘À sJÊ [¾\|aÍÖçE«™þì~œNÝÏ8Z‹û»Ð*Ø·ePÕ‹ö„¬ª¿Ø ûåz0âEàK’¯´áEÊw¯g»¿|õ_ž:±yýó+ON8gïo˜ÞaT nb!*?ôEâ8ôaeЀŸÐ\þuÅ,e“½%lïÂÃ’¿3­‰RϘ£à¶ãˆ.údéj©z›´°ïŽ³iÌìÖVÙˆÕÚ p¹0nuÀÊ‚R(ʸæµ(˜úŽÜ�ùXrÖó‹h‡î€DAOŸë—îÓQæ“"Î~‚âEÚ)‚�âÇ_>ô S­úØSDIáÛyª¾€¶õÈ=Ͳù׈P[ʾ–ŽÅ Mg5]™ºë3$çŠëf˜]Ǫ4Ú@~YOéae¸WÓzÍíÙsÓlÆY ˆŽEVS¦ÇlØü¸ ¿=Á*bðÀ¦€£r™ˆåKg½¢+§¾…a8®ŸÖÄ"i„‚«Úm/)ª:åLEMlŽÜÅú²ã̬©‚vdÆ}mnçÑ1Å€|weåì<tÜÊg{ Œº/· –úXkñß×göÏïWûi¶²û„îDäÓC¦Ò²ÁXRî,-†~~ÞÁ+¼f9HÇôü)áîj»0Â"ƒo©íØ‹×zÙZÁ„²oqüÐPJAzÇ.Æt±-Šüfqº¦NC$§¢/²8ehŽfp|ø‘UF+oNX ±„ te‘vên´ÊUÿàõœœha2Ì}[é¶5êÍc‡¤'h`£LãÖ&ТÛÚäÎÇÈ)Y0‚œ–ßf)Íï#V÷¡ÆñH:hu¿ ÒDÅÛU¦m'"+›þrm}ouã:Ó®¥AWvS«Ÿ¹¥iÏ‹úU·Th—{°îÔ·s`�ç|¡Ê$^´Rƒúª¼ý­~ÈÖ„]ëQid‡˜ÔšÌïöv¤7šèÅg-b×ëc¨0sò:û‚=a»WY¹qz>„èÉÖT¶&ûÆà»8ªÖ [W^§ýá02|w¬»Þ¯‘>3}Šþ“úb¾¼"/´I;ËßJXDìcVØéKiø ¾ë4Ò’)»³çQµ£<õ݇mTŽ;€yÌuÏ +|Ü3½i tWÖ)Ÿ XÊý¾€@¯íèvGùN÷WdÅ$ WÌÁ9} J٥ʌ-Aì4AÊ¢öì_í½G 'A€2´0'UX‰Sãmø¯w/£Ì=[ùü‡SFÒ»z=ÓÚ7g3Ç3h¯@ÄU5­V²¾…¹cÝ'ÎÍOÚ-3�Q¯yH$´¸Y=XéJ¡ö>ü‹hv—µ•C &hu_ 9¬Ì˜H¾ý¡°¶w"K}²»ùÆ6ñd˜>Þ&ùÒÖ.²€¡öÕíÖ‹¿ï(C¼þ9€Œ¤þ,uù©òdš‘X‘2HY®kPõ\V£¸Çzé`l¢r3÷ZÏó„iZͬ7{èàâ£/§(ê50.õÖ„)ãSéË<³“gß#±ÝY|$}ȬÊ<ýÌ_h%ævÛÆR·íLñ‹‡=”�æÙláDHeC|ÊœVœTD,h)uøH¿ ”kh:gtiØi3CýQ¥(ûU¶p±‡ëÖÏðð¹#—'rõ:A4[Ž úžõ Tã3º4TwÃ^vþÀYb´§î´¨3××ç#kθ\ÆØÍŒ±ù^m 軣þ³F‹[!º#í¿ð½6 @¯¶«UóŽ‚Ä jA¯)žI7RÅŸ! È^wÛÞóÕü€”°ÓÞÃé¤UŽ½4GõÝè‘{÷#Aü›?ò |ß{´´ù€6º·É™³ÁKñe¥æ(W‹¶ÔôÚ6Ì)ÚMçjª!ô Ûôõƨ(”DåZËèh͉*oщ,vU¯ò"”ÎRA ïZ:ã; Ë0Œ2¦±å°ôàLH*_¶‚Ö^³§€Zp–‹C¡™X5ÚÙwrÕl»ÁÃG–ï -N+¿ÅLácO=ÄÏ´Ö¢ÅÍà ½Y¯ž¼m‰OŒPš ® #ëK'°@të&mÍS†m%Fzÿºõ\%è¿6Õ±&¢"¾ÿH‚ßÒ" Nµ ;*6-©3JcùÄ­Xt ÷^PôeêZÓ²þÞs×.“ †Ð{ÃÛ_¶ná¹^ ¯ø7?=õ±ë&5ø'Ú®A\+ìòrnSXÞ?èí+T‹ÊÐ3i‰ÁóƒáµB�èvò¬ÎuCÕJÑ×'£;Ãå…{=på$$¬Að¦ß“&± 8Üáëç"Hm4ÀHhâ‚ôèiqÿ̰ͪ5E,G²Ko×jŠ¸*ú Âû!ÍÓÂwë¥%3aF¶îOSh‡æ|Ò ²»zLJ¬ §'t¦õ�[›`í;øÑixÀŸ:ž¿úñ…f°Í9q78xÍ `κà±NTºÐv˜¬‡»úç 2Â?ýõxGQÖï/0ªùp¢;-ª›Å@Ê`O]mé  z‹ïÈ]y¼HX´ž`iNw‘VÈeoº…hvÏ û39|Ù=÷t ªbÕt«0Ú«‚|ù×Z6•,Þ´¹ŠP™Jüf¶—U÷5…™<ˆâ,2cù-·âåøââ¹Ì{a¶ˆô{PÀ‰¾ayOB¡ äÑ*| «:ö£-n/·˜<ußz>ÃK({ñho7Wé;÷Š:Z2y·Žèâ¥@™Ld³åŽç߈“†ªm²¤Ì´_ûžžoeÝiÒxCyèuPm�1‚a€ßfìé_ò"œ‰q¸è?ý 7WqLø*¾«yŠÀ&ž÷àï¥*l!ó<˜•Ê=�¼ÖZê�ä·Ã{0_xxroþ^fŽèQ°/ÁH©r9|9×¾ ¨ÆÚê©àk@L_u¼.Øg7?A‹ÎÉè Ù' K :ÐöžñÉß61£ÈY|˜ÆÔý7£HX0wæñÇã„ñ'“ŒîTeÛ/´ÁúêÒ³Ù_Çr…îò¹=Œl @iÚkxz<Y¸¿ÈçÀD¦¥0\ï-ØŽhÄPÈnáù¿oyZû[n<õ¤cžŸ€Y‘“ ;‚Ö; -¨¾$L;À ÚӚш'ÚS}efγ<0}Øpò< ÒÚ×ïú£§Z´‡¡¦¿4^x˜ÑqŇ¥µc'ytÊîÿà ¯C¨JpDgR;Nè2ö< ã(,Þ 05¦ÙÏ~ )òM¬)ã\Påöpñ)C鲿‘Â÷Ž§-¼žÈ¨:ÝÑÄ(ú ,÷g§@¾Ñꯞý Cl‘cý$!àÉ)‹3-è*(ÞÏ6&Õråíµ«¥›òd 'áJæ-ƒ¼ETÖ&@´±ÕÒO·E«´Ö'šùÚ!‹6Ü�á¡yïà»ýÙbVló™ûÂã�r¤Vq”]㈞o”¼ÎºC -ÖÄÑÊLÏ~Ó} FR…¡O7©FŒ)E´3wèì1¼Å³÷M=5(³á~FLbéÏb{ áY)wð›Á:ºý³ƒt�04K²tÿò2N79d±†JTèÍOª“˜¾ûC7L°¢RÄe/ âÉD(ó±EˆX¿ïß'÷°Õ8þ ]–ù ûÒÌYÿlZEG1$¿’ÒŸ[" 7,ÛÎÓE¨‡…2ºí)ꮼƒ4ò6kjtá—d¢zòå‡ÆË©ìž×+ËaVû5t,Þó _êPSŒ¡‹! Ÿ:MåpžäMµŒ‘œG°õõ'eþ´òîKÅPGÊöºXçyS÷þR-¢ÀÐýÿYû“íÆ™dkã<…F÷N2k¡o† 6@�cÝ÷ŽkÛÌÍÝA‘Y«þ BúNR$ànnÍn¬öÀ ·†Ò´¿ûîÜÝ=¹=ÛXt8R`ÿbVæt ùŽ2¦­b}°ÛŽÏ‘N£,2ä EËäÄÃ1Ø„˜6JD¶k•øÝ•–Ò­FPèStгëÊ ¶®:¹*÷xÊêÒ¶Ã?wsŠ¤´ÊΘE`—¤Aù©õFÎ’OóÛøü#åE»¶ÿ ÉÄ!™ÄüŽ–dÖºÖî‰zÐMçyqš˜úS°œ %ñMt’o¶®™¡»ßãmÛ„’‹þ™Ìr–·÷áÐ 7ê¦K/– _|GA'™g^ „ý Ç܈ËØìÉ}ë-íù»•Ñ³0­0¾˜ ´­þlõ-K’¶SÈg¶B‘VF¾3EµAïÙÖÞ@žŽôl/ãyZppôb]_1^ëRÄ.6™•÷—™1¾ejÞé÷’ûòu¤äåYÓ8y‚Qh5kgQæó «ø΄Zª#&F3 ²zÌ+¾Œ;—Ú~'Ê÷.£¸5Ñÿq5gò}YÜ 4Â|úRKS”þôNuw´z ”Â,¿dF¥×‘æhÞOQÄïZe¹ELˇ®12×Ýê‡ Ç—5 ÚÖëQ¢R: 홋"ª1KT§¼‹»ñËðÑ:OŸç?úMX1�xɲf_.֛ͰÌî^DÔíøi¶}\9UNqámûœJ<ÝöJóÑÐìÀB-ýÁ‡¾ ‘'=òïv :œ¬’(Jº3ýŸ¯¤ü¤†Î/º½<äxغ·‡Ü`!7S½ iÓ§Ù[ÓL’q‚r`7¿ÔŸ¿gñ±Bá\Ð~h« úTÜD…ƒ£kéH¾+äó$.–ézìgëÛÃ@ºMWš÷k]WÉò"_”‰*S:ûF•bØ÷BÊX½ƒ£Btdñ'EhI«ÕÚ÷BüªFÐ/æO€pÇpAdA¡hæùØÜ6 É‘¨«?Ö~J¾c*êîÏÀrþµ„Ë0¾áŒºQûÜÕS¯»VæÌú[yiF¾EôM‰Û©°p>øéß òÇ”©ð}ðö íÓiç5˜Ñf?XGWÊyû£}¾™¤‡žÇnÆÃÿ+{;¼ûÎEíDËUuß\&ß:å¸ü‹OvëÕ¦AÕ]\]J«gO¥ý_¯—ó*¶j¥‹4šf@óÂÃÆkÒCÿÙÃj^ŽZø¡w:|.š²&.[ÿ䉭Wfr¾»b àp@¬’D«áhí8%WyæKTUЯƒÐ’æyèrî¹—nø1:Ãﲩª€¦V:€Eð¿ä6Z|µŸP·c·æü²æ\ÂSs?êŽNºÑ—ô½\…»ÄÝOI/˜iùäW‡z1z"·j^\¤”úC;ߵśò¢k/P÷gÉVŠœß ËÒzéÛ4 ’iï<ª·W$÷³™LW1ÊaàâCQ°DóQaü}¶›”õîœq ”4áòfgÆÚñ¿wåKU*g‚X¼UU² u~Ê9k£éMÐÓ—‡ó‹Ä){us:h’ξi%5'²54ÞË<9n¢¼ð9eêð¾÷$j ×QÖmàªýÒ�‰¦=Ð ;¥ïe¬“|4˜s^T—þl74"÷Mq`Æœ°¤pÝ=åº,®bGçq³ BÛÕ­µ¡¤'›Á‘¡³XS!зçÞî;[ý"Ѹ+½çÃ0ÕG¢M‰Ò^ ¾”Qú” hÛ‡£/å7ÈÒîjÄ$EâëqC×2)ÙAÏMÔEÛasi7³b(´§!fCXš¸Wr|:Æû—½Èƒ˜²fÖtȃêkq’\¬÷jЃŽÌËóÁo”«P ¬è@W ßyÜ—®­?.ö¡¢@ª •ÒÜ꾯‚¼Ó¶s^,tc¹¦€´ÛõÉ·èÛ"½W/ø{ˆhÕÒ}ÝGÇ£èêóЧ·2]?X±‰Ú\ .„þ›`&ÈéM†æÜK²tqdÙßØa'¾¤cCù+eýè%áTì}ûo¾I)ÞÌãv QŠ[# lViË(Ù†Êã®JZ%™’ã)ÂEQÎ♣³;i5wF”(íåC©‚Äス+€¶²ût¢”ûº¿D•¦¿ƒfû×f(ÂŒ h¦£­øZ¼ ¾9÷ô×äÅ�·ÒG•ÊÅò“îIVÈ™©çpá<(¬bEÉy–ø|KÊr«|(Ç®ë!ä¹ó¦¤3H‰&˜àZù2¹óç/ÓìųR¹VÅÁ²£È961bj÷­3*uLV  2G¿L-Ýe}A«t,§$…™ÏlüëìÝ QM§÷ÐZZo‡.­¥UNâ¦8Ü,­ÿY(�ºLN´ÊúbàÊ4jæïüͯžfit#Þ¿ïbú;­gÝNw¶1$é‚û³ $ú?¸|˜Åù—'·Ê; Œ«ƒV‚À.¼áƳƒ.–£³¦eSbÑcm[ ~§Vò]ún´*»úrÇ>ÃyjåÆSk3Cóð©H8qB^€¿T ÷î8¨¨ÕY»ýñZ+IšZ”‰àoŽ#å UgÓ¿PÝbÌÃjñ'šÄŒÙ¬ÝÞ.‰¢RìXè‚¿{XþÝã`µÓþMßç[(õí S´gè{ìì@HÇüF‘~«gãºÇƒñoû¦ZûÅP¬¦¶ª¹ß,�n^OP„½îftËÁdÅœž6fãÀ—^­‘êf•ZåÚBøY{Á“Vg¼}Îäë è S὆ÙjÉ×È‚ø،ǧNžgžÕ5jë¹ R‹«ó¼e›»tIÀrÊÚ§R9øG?IoWÅG±LÔ£Ùè²Ó„kg7LâQÐö˜Ø×ßMÖ£<.l‘˜c íÏZÊ’… êpÚþâ{ŒQܲVwu·ƒ…åÊ¿¤ ºžŽþsëz”ط·ŒÍDdà©ò@–úÅÇB°3ߎÖËÀäéOm×ü=ræSž¦ËècóéŬi=åk–W‡¬QzÑÿË*RK47:“ËI~¨ö`1ôNÈn°ÔPOönȲÌØ~ÌÃøôt²Îl¹ýo’4(g \Bt�"Íôý^MA¡’HZYæ¤é)Ùp†öN&t˜iÕvR9Ô [99õnÊ�ŒF°»ºó…Ò*óÏ(€ö#º­Åít¬'ÛÛ•2§­Í9áÄoþgµÔ3 (Ù;tU\2RqÚ t§hÖ±»º­^Xa‡¿0îºæ3I Üý5žƒì]o›#)%Êѧ0YØ+cj$v¯¦E•'VåO ˜TŽÀ¯löZüeguÏÜC 5,vþÆIÖ­ žæ–†bÜÔ”gŸ–eÍÒAÔMÐR¡Û´Óúê¾?¤kkˆÖ~BUy$ãƳ¹< }{ÏÛIFMÕ8g•Ã„Ѻy ÿ¯*|d=ëCâ†X¾JO<‚†•OLOøV”ð5y¬ÊÀìW~ ]^°æuŠ¸5‹­²Íº«vG>¹tnBIÛ—øÉá !ÀcR´Ÿªg+ý[fqðsjQÀi_¬&ú?çÖ¤!øº^Ûã®[””•wÖPàke}]\:.îÑ{ã·¥<Ͼb¤ l0¶í›–™ßcGÂ>mïä~×:óòÿ¼Ñ÷žÝÅèÞ"ôåµà€âP{ø'te»«5œmÑcXUô±svèAלÔÿuJ|Ì ŠNªMØ@·”¯}qP¾yE.QxØ~PbGú„Z­ÅœJÐÓ¹²¥´Å mÛ]ÿ¶Óe‰Ât‘Œ8ë®þåZOEÝZ !5y2¡Õzr}T³?‘¾©O]»Ü›M%ë÷Ï‚M‘ÅF5® Æ°5Çm= ÁY*zày#ˆsû‹gþ‘Q˜ç¥µÒÑùô(ÄbÈùÆì é„ü.†ç+{YŠáMMáÎŽÚ¢°âÖ0eÎNÀLB›Ðf…¹44SHi Æ ¢÷/ó¤ Æã.³3ôü¥ŠKK^šæ§ñe!�wÔ¼ÊÒŒK/ÉâŽ×›"¢d"tj‡©¶˜ó „ÍG{À¡ g–»Xû"ø“¼oû ³Ín¡µ-䶦ìmGEž#̦RÓù6=OkñSÍA±¬¯±eG ÞÕmèu~%•á+õ{Z~ÉûÕ­üí À=Kßµ-ìz–¹|`/îØVÆä´h°|™„"f«hN”4Ûs÷ÇшT´Òƒøž†^g‘Õ-(žÑ£ÜhOËXÐáÔ2i Ë?Ð<0ÜGˆÔ²8¶f9Ò?z–e²œUdªkÓþãÇy¹¢ÇÅïa¯=S Gc0çö>Y«ÉÝ3 `¡”•íÖkÜŠ(Œýò:™è/ì‡Z1ÏšŽöô¾\)£gM?-�jèÅw(jåòQ¦¯·}$׳I÷=Ôצ][bø †ÒÞOí8b{™3@§pY`ý\ÇAÙ|:e¦ýÐ]öÎ)ØôЖZ–ë xgµÈ´iÚBÍRY3{Ðtmž1F{é­àù,@Ù·O&Y´Ò’¢e2_ –¡©&ÁôÅñ½…ðc²˜_â“ÊâüÄLcÓÐ_™Õ‰ ø X¿ÁÐÏœÌsô-ÃÃåÿCÃbR3Çu¼}¸µ®" :g&ÂÞ=¡œÛ*Â5ÇÑ9çliƒÐS€9åÇ“Ü÷»ÄÓ<¼Q­íÚ"( Ì:–a3 ŒÙŠm§mmR$¥´¡ÉÍ"lßimqBû?2Q7Å’™Ç*(.ïjÇÌDˆ#X%»åØH®{›ý_Ud7ÐÀ]âùBŒqßñ'ä>¾%$¢Õu>±hËC )‡ðñ]Aë à¹µJ•¦Œ4ßÌÜúÀXΟzø›š¶=äqø~¶ñ%KeïjèÞàaJÍ^Pb+-*ÏbÊûÈqdlóF¬Õ­úxlßï´ÿ¼•‰b?}‹½“Ú0®ÅF§ÿ…)³øÆZ1žÒ˜ôÌTk”íèyWË‘Á¢0Ýò›¦ 3?wOx®FIÆè5¸¾Ù˜buýâúÖŪ<™À"Эhko‚�Ì£ù#Ë}€Z÷ë{ç™L¤ô²£3¹Þy†Ú š»½)vñz‡~iw´Bé­?TAí;ò(ö" ²j`ÙaŒ,ϸ9÷mÃÚëý|¤jè?oêÁ-Ú¡dÅ ä¿óyl§ÿÒýkïýæ›ïçNVîS×çA9]- P nUs†àƒ×ïZê‚>”<V­n ÓÁ´lšHÓyƒ³”µ§N´Ò42£Mtbâ^¥EÊÌYšq§¡—?&ªYå#ÆéÛ/Œ?5é»çþÈ%æJƒöHY›ö¹«oVR¾€`$µ<àÊ=âÎ9MWžî(Eúÿ¾4uî€lVr™‘¾¿Û¢¸ì¡í ú÷ÐÂHŠ÷´V `g^ 3þ–eœç·Ì‚Z†‹4…“Užz®Ð÷íT÷’5H|ÁÇkíéeQuqh”.}ÌØÈØ–P Iž…ÂñýÑg*¤aæ£Ô ½¿GåünŽvl3òBR’x¿±:{/[ÔäÉæöB÷îSg ëECȦ³¯˜ÙEÅ­@ÆŒÉ]¾±Õ,¦ÌÂfÝ_+° ì•èÄ°Ë\h¾¹²oy„Mm¶ï=(™²_d'@—í éE¸Gä@bq!Q„úrÜ|y¬™u-oAyßKÿoË€Daî¦æÍÐö„BáÞÏ#ZQ\Ç׳ޱٞLJM€$óhʬÛ~•T4껲„U‹f„–tí—,ô;xR1ÔËz(°õ:Å,8FCÀH?ÝŠ’+qÉd¥ñRJŸ®Z4j€Ê ¬ƒkƒü~*¡"éajz"=¢t:¹<ל \)6µ)­¾_Ü•+„95ÃW ǃ+ÐÝå~ƒ?2{¨-âørdÉ?þÔO`:©ƒž²¤MÑ‚°·4N`;ÈÝ×ÎeZx`ôl2~劉±8,W²œ)Ý„2ˆ>­7mUn‚€ÆžQj;Ÿô¦¢ÐH’[?«y€®ò×h›ü5ª®FÁ÷3|Œ´GfÙQ:!#xQú’èÉB*ÛXµÝ"dÍ…=ªhúß|<é-ž%7L™ÓS¾ï[~3]©NlÑ«@ Ð4g*ÑzªÊÚ„`—P²¤[8ÕŽ†vžÔgþÊ#ÇU¤_i±û Œb’I#o,c½á£;ž¼Ñ<Ä»ÄÄ[¿8bEãè±Ф°¨–'FX¶Ÿky�ã”aÝÛ˜•Ãàˆ™[ƒ,Ô×5i/ʳuσmËCí8A@£ˆ>? É8›L3Ñ7ÑÒ¹ ú`ûéøß®æÅ´iËO‡+ׄôé›vO;êQÛ<* – 4ïÀ³/ï£Ïçþ‡•~~©VP¨§ û[Å“Vþú…›%þÊê*^‘mYœ‘2Ë/kgÀí½®¶<'ºÝûœùN±`‚•6qn~ôa‹•a•^þ�9¾{h+ˆîôbÝe5n¢ÔÕMkËÚ¸Ãt‘V¹çm&JQ¬J s?»|ji¹¥ç/‡´:ȯ7ˆôœ Hþ:”ÃOü%í‘+ †˜ñèÑ»%èÖ×]ç¼LEFŸ€RËHqʈ{ Rÿ>Ö²ø84è–~¢µ½+!á!,Å F!ð2¦®bDq‡ÿVxÕvÌú`5½Í¢3>¤n "F^Xùì'Ž'vö-Ê1 {,f­\üéíग़o™Ìae·øÈu1«VVÄyÐцIÆ‹'ɽ‡ä¥Ü°ŽàÔqÕJ2¡[«åéÒ»Îâ´+6[Æ®qÿA{8'ÓÂY½~Ï} xTØP âÎ2÷l-/sÎ\gxmºž}˜Ý~Oÿ#ú­nËã³~OO>nwÚ 5ÞºF)OJüõ ¿=š»Fîvj±&•C‹{ƒþŸí‰Š&yá õà’ÙàòÖ6'àÀÅd݉ëGW”¡:zç¨í<(ôA¨Zjìh^Í¿Ì*ŸNíJ5<ñ=ïX‚ol‘ô|¶®]n±Ì (•If†)%ýꓬI%s3¿P'[†ŠP„V•¯ä¡ÑJƒî-Ý‹ØíhæÂÑ7ÙŸzö2ºåÇÙ#‡ ÒìàCˆ<{ÓÈYÚ¯4(6_¦¢ÏÄ<í¼¥ÏiĽگ–ù@ò¢J\f+¤(ØJªÒt:œqããåW>ÞnI°¡4Í éDC´*™Z JdËÝô»“ÁÕÞï3K·ÐëæŸ7Y/ó¢= Ë<ÚÊŒ·ØÐ-Å#Õ¥ŵ ôÁŒÂÊƽãŸcß™z¦Ú Œ.ÞÖ=ÊlsOï0 ³•ølÒ¡¬jq>Ç"…Pw0³ö£±œ¥r€öò|X› Fq¾rÞÆ€ŠVçAièø²+ñ Fkq7®¥føÜ/v`%tàgÓ¶ ©ÊÄ1MçfZ艺©oæÌÃe?´‹Ž<~c©¶álšÉSýmÆ/U‡Œçª Ÿ;®-ï¾ø›X0‡˜ÌfIwÚ`Ü»c}ö #}–+´ñ*e„û UŒMc_Ñv]Ía=;PÆ5µgò%}PÄPµ„a³åùÍ<ÈUæz9ÚVÙÚË%qUOÄ[G)s«¥Úõ{ýeÛ—Ï™$å­Ã¢Wõ¨Þõ�@L—Íqt[þê°ªVîge¤tø–µeä†8­¤åÊb´³dXE'ó Ð<gw¦uí#¬gÕÔeoJWj«æœ+‰Î ûòÏÎÉZØ(b{Ž Ú눀%BÜÞ—„"Ç�rÄ¿µ¢oïR|þà”3®M/êit^ËÞª0ÛñÊlõÇ—žŠ§?æþÀu õ˜6z¶—Iˆæ¨Lð;Æ|2 ™MÑÿ"êã‡Å`x{¡¬ÕMˆhÑñS]yÑ êë~aäÉóækåüïħšk»ÈœÇ‚ÎãÖø{ÙtÆÿ­Â˾Yí-°dzW<GÆJ«ÎÅ…ÂvÿºàÕSoJùŸ¿×YQ±ÒV¡µMçehm™‹”;:[à æme”™#ž¥Kãæ0yìÿ6Lâ$�˜JpØ×oQZ5þ“ëtpñ|¹ »á6OÿæýßÚï%B9†UsÇý›ÇãRwn8u9ÊàE^ØΑ£€«‰‚1Ÿòc¡d%´xDÚ ôŽ¦hyŽC}áaÏ\ýtîûë©¥$Ïò4Ë••²ÈhS®Òi‰¸ˆçèÇP¯•´¾[f2ìÍœI¯™iÁô‚µj1ŽA=…_?2Ó¸¼ÍèJ‹ZM ¡Åa ú#CîÊ_t?;9ÁÖß•<Nò0¶´bº9-Ô,,r*+j‰ˆ¥)=*Ù–Wõ(WNÝÊ‘IÄ<%\HËØ.ã.,—8: š,Áê½\œ{—ß¹™–Ë:š/€_lj㯥ub€í®ŸrÁÿ@³ÇÄÒÄ ãÑkÌÓYƒÛÌÚp­PûÃ:Ë,=¸7«6/u w’wOüM¦®¦ì¥Ñ2PY~{Gä‹A²jms¨|o–ÀÈ謁±(Å<ÏóÐk2rÒ¸=ä°éÔzj97ƒ£1P}Ù2·GÄå8MtЯ_ÖÕš ÙÂþ̘*ˆiobo™§FÛ3+9èè‚Pœ:7÷,Ì C˜™†Li,ݪ êTkUš™õ ‘ùÞú–ªïêG̵õK¬Œ¼EŽ2ˆ ÑG¤wÑó“ÙþLÇç‘Ûl+;…' Å(‹]YÂgôf“2wʼnpRIÈð’±û—ë-Y»cAE”tnc [6ØùÜìâŠÎÈ…-ƒƒäd%âXÕb5ÂÓöÞ;¡m4›³øѾQä,0eáæônV<1 9¬¬jÊ:¸ÆM‘,óôŸ˜X@çVTïŠ1ŠÅÞõb$}#=1ÿ__-ÌØcËŠð‹Ð¸Ôm û‹Wé펓 ˆ4®à‰14…¶æ­|’¬”)= ŠóÅàÍh÷ ΃…]Žü½a Àвž€ï·ö|PìT!•q¢ShÐêVÌ@¾©s:�27á5åAvÖë8OŒá³N`›‰ Æ“…–ýÙ½÷ž}‰/SÇR%Íb5Á ÖŸÝ­a»&øÓ:ÖÅÉŽG¦+þÌRgRFÛ£¸wRöq¥Ü{æЮâÒy‡ÂO4i‚ÂýÓ¦FŠ8]ŽB¶äÁg‹ê¹sÛ¹‹ŠØ5�˧×O,¡1·Òt0–^G¨Ê±™)Ÿh6¹¹÷pÐjv’.¦—Õs"7@hàä/`žŽŸPÓö,Ú1|ð/×Uv–Ûn5Sð7MÁB˜¦ùSÈCa§¿A´Fžmˆ-‚Úm´}˺xÃÞ“ò1÷b ^è¥YM©‰¡_~œ=1¬å¸ÙÌoNÐÓ¨åuìU½ýñ)U*ÎWò°ô g.Ç=Ú±ò,]gËqžòÛ ³ }¿ò(Æ~Ñõ”ŸÃî<¼ÄÉ=t¸u+ïÿz»¯ºkC�ü«…þ¼¿¤4Kˆ®eÅl¤eÝvW0é©jÚ¡{ƒªð„úÏØÑÇ»4í‡ö1)Š€ª±€ô™¯\Ùק‚?ù>)íÝ?ZûxµîvGû§”¡ ‘issñs ûýóºZû‡E0 X4íL=jßoÜbâEXwf~ÂÏ•«N³AÆsg=d†i¶u¯9Ñ"'¿f”){8¥A:ýµ¢àžãµ—¬Þœ‘ôaàôE„îõWθ»âZB ᤧµ]}œ|—ßa:!˜~¸ á|»,j•PåUè ˜6«¡M½ì=/¹±ˆ5â5\­~Û¾'7L¡Ê€ùôä’&&ƒÁchÚ¹Ç=ÅÊ(óƯäŠo´‹Ót Ð*‚î\pg#±ËËÈ¿q¤ƒuÐåƒÁ<m …·9ÿý S³õe*OЃ}%gz&çwÏkg¦„™ËÛ…öÆŽþ;ÝþGœµÅóOÿÉGªxàòI˜•}†%À¡¾¶³²µ\Û‡¤[«ÎF*ú=Õ^£ë{ýQS¡ÝÔ<§k úµÌ@ÎïHºR¿ ep ôªÜœ‡°XÊmµÝL‡·uýy’FEQ#£f€º.qÖnrƒCÇöÒÖuµó~Û~Â]ì0çK›>ñl2û†=:{êò‹ÃÕþs£–ÅŽÔÉñ¿aªy«Ç ³¬àa«1b¡ÔU,f_cñW+Ñf=QÛcŠ¡ô»p¿êhqa«vÛê}ý¾>Ì÷z·ÒÊJ9EU-²J§ÚãlßAj?થÌE€÷gç­v|¢SýÑŠRÇotŠE‡JA’˜,uâwáì„>j¶ß¦Ú”¾óJȧŸ**'õôF?7gg¶€ãjbÙWôZê¦kÿµ™'+€¨P)nGÚ >ô±»®ò¯ÿò9Ö‰ p³w»££)´³ëHr— }ŽÁ´¹o%ÿNzŸ¦~Û^{ü úz÷~å m›®VŒr‘JóÅNë6œ€Pòà@³¯ÂГԺ`Ø[²ÄMº{Wë$t)(S~;ÚÉ5]ð<é—*7E™fN…óµMÌÎl ·¹`*Dœ`I…çwõ†Êè­©AÑð[Oæ[º´PÞ<�YÕ¨A!Fy>ÝýY³ËÍ'rƒ iQ•N“çt‚š„aYZŽ®cêë-MœcèÖL3›šÁï¿®8˜HÆñ£�/‰"­Õá1>뼚c¦96TÑÿ¬/“¾YÔ›ê2(»³u OÞ¶¸£íݳ¨uKá‡b˸ž+•RÑ–†V¥BWÁákŠ¤6Õ"2s‡égâ BP©QtWlÜErßÀ6-$ ¿ùña—(Î ¿ÔaoF_![<I¢K»ÙØôŽµÓÿ‹øò_὘âŠ|tçW<¾72°êl0ŒMîÌ€³´tb®1AS~áïÁžNÿ™ ¦"ˆ·eA9úS3@=ê?ÇFmÄïÖÏŽmkl[«–ö ¢ñÆ8 ´l»‚îÜ x¢µë<žM ÄûÅ+›-ÙÈÙn(B™O"I]žvr×kç~#C@*GQâŽ|â0ŒVÈ@?ø_LJc# ·=|Íðî¦ *ÕU®G\ñk…öŒåj%ÍE±0 Ž#%pñû§gtEÿ{•R:~Éœ…+ôÖ Îí1ä-Í”âw܉iM'ÆI]¨Ï }R#M®¸¶mdÕÌÌoŒ O„yþµö¤}/¦Ÿ-š5r[´Å}ÓêŽ3£ú¬ªnóÝÞ¼U21Š1Ækµ„Ì,XcæèËÌÖ3ÀÙ(Øžk·ðz)¼Ù`¾³­1mk6û…õmFµï—g¡oŒ%}Dk±ir—kß¾ü»o¬ ²ž¢SÝÍð>´ŽÓQõöß7À×M(@¶žKëEñcG9AQQßx nZjaѪOra¬¡} Ô­,‚5®/ ›¦é’ úš\±¥B.•Y#òÝ¿Œþ/N³•[Y\`kPØ ‘×oèð·ÙØE,‹íë74YQ„ž +™-3 î[ú)þQ®$Râ?û�¿«3ʘgÏ †eC®V‹y7ë—;‡ì 0T‡&eRƒ›£])%)·Î Jiƒñxìä¥EºöQÚb¶“nþºyZsö1™ˆ­ÀàçC;¢D2 JR§ÇÁ¾òý…jDJúLbÇÜËۮÀŽ t0Œc}rÔ]­>5í=CE>},#c 4œ(D¶®ÿ<;ŽË8LK§çXQrŠÔæbR�Þ;EªìU•!/îÉâÊ*aýI7)÷Fa\â]vT^§sí©þSÕØ/¶õ‚K_fä J—?à{î”ÏÄt›#d)ûYjÝû2+ÅÊÈÐà¬ËìßÐí²4˜ †º;㬰xþß‚}â$1´ÂP˜èv¤THÛA^ÄÙðÂ6ajßjZ•OnH•úµˆ7‘ö¯Ç·ÔŒ1…ÄâL^nòEË •|]®–}&j³XŒ^<óÐìä„Ä•ÐËJÿÐÄ÷bËi­I|Ý4\¢êr´_¢6g|f,}ãEŸ™2ô†?ìquÁ3°43ê óÀ³›KÒÐwF ÌÚV£U>}Y¨Ä›JþNÓ¼Ê}Â3m€þ$œH‹ˆmê/:wQêÆÌsóÇ! Jk€ãð[I2sœ%صiQd…ÍV­³ÏVjÔÿÂþJ]ìdp} h7ÏÎ+z—¼ÿŽ#ìÞ=âàI§mwY7Ä‹= yéöþpîÛT¢ŒCQ¸¬‘* ³/b;î–_+KÇÌüË5 @[ QjVÑL•¹Ó;‹ 9ƒûß´{€ÑÁS_Z+œÔó.Äz[(–;¿AcA…m2Óbé1„.:ÍT¬ž�ê]:E˜'VÍç†L“‰ØÞäÖ°e7Ì ù”+yn‚û¶ëŸ—\µ1þ·Ë0©~þ¯8‹~΃Øtˆ v¥ŒbV §»ÅW*®ZöÓѸRÜüøx$§q™[T F(MÎr³òÕ²ðÍ‘ÔÀ95G8Û)Œ‚0¢nÍtËеe=GF }SƒŒâÔ-B>U找Իª£¤©¡_l !nì†îâüž@þÊÈ·Ù£ÐЦ¤EÎdb¬¯nÊÕùÀòþ5ti=ºÙxî(¨'Ï8žÖ™ÅƒòH‡ßqw©¶\¢?ûÓ¯U'ÅÃWŒ°\kÞÔgM÷Òã§S¨;y®È7Ñïº=€#홉9M É©˜”:«¿»œ<ȃ’Ð0g&ñkX7v„žyÆ`nBŒÇE'º¦×°~¹!µp½yJüµ^= |Ýׇ©ÕùÅëø>(‰=D £‹êŽŽºrQo*&Gx“tkõ³AT%Në1ß—"˜sÚ^Ÿ+¼wX²ÐxõØ"’EyR×OE¯ÓÌG€x8OµQüã Ð3j>Äbûrm±ö{›Ü‰‘˜új¬W¢YQ.ȳÒÚÃÄè‹òöwùå3àY‘åŪè^>« cø]dŠÌÕoôäÜ'-ìËïxv¦‰WÅsŠ%áÒÞô84oÈBc˜Ã´4~!용ѳAg°¼ö~—\r8OÃæyoÐ’•”Ü¿å¤Ý—x7þ¹ûKÝQ¢ûD‰Ízð4ÔÈá‹nk´ùtœ¶(Îù´çµe³ñF{ªÒÅ.£Æ¢.ƒ.ɃtÔ!W §lOàp¸¥[~ôÃb/7ÃÒ#K²Fâ&†ͧ×Äà´œ‰Âv¨ôZYz\zv ÜÀ¡8´*4‰QØi!2(H8К6à=ž#j-g–'ixsEÃhq´WÜgtÕZ[¢S–tžÌÛú×&ùîç›®`,•Àæ«›çÉp˜6à·ÿØ—«MDÕDÚ¥£§z ¬ |-ñêØËR9<ÑCºR*ÍYîÍŽÌym à™GJZ¥QÔâ~¯ÞCIªâZÿƒ/!è]J&w«Û•žô ë÷C-ïä--F Ø?io_p$4Y½LµAʤ}V²X±±¥Å¶ÁÿÏá™Ëoõ;2ÃŽ;ú�‘3'¦½µ™©È)[mTâèFˆ“C 3Úyû�E´ú;ut†Uè‡îܾk7­m3Jk˜` î„°„Û&CaЃÝÊÈŽ,ÔýC³Møw|¾Žõ<×Kð†©oZÄR7¨¬âÏÚkcžÎÝ4X×_”QΩT¿Æ=¬RlŠÃ Œ&Ëi°?zhD¶1óë;¾AYáû†Ã§nŸÆò"j+cþ”  vÎhèýV“ß‚ÜXõ9†S$›¿*w^1¢ é :(f ¼¤‹Ÿd¡_R”ï/yõʸ<ÔÝ‘S"# =ZUÇò·HëûýÎèÿ<,UÄÚ#(EÖ6ª»šµ;)‰Çã$ï鸾²ˆ­0zB§PKÚ›9…¨¯V·5ýÏ7ÎA[üCŸWâÆÙÈÒ YäÞï Ï æc¨$5òz é§KKØÍld|òf¦‚æëËzz°ÿXãúúaAP Wäz˜!ÕR˜•Á±;‚õ„§ «îX’)¸¶-&YÄ·Á;-Ü9.Çá¥/ƒêSÅ 0’•lWKð²äp~q-%û“5¼þh;=W¤>Be:òÔ𣶴 �ø3ÉO*ÃÊƦ¾[,H<…Ã|êÛù|\ø´l•C–ñ¨€ˆžAuO‘Í®žC ¤Ò‰ «ˆ(:˜îjÕÆ«å‡Iu‡‰ª¼«…öÑž†Ólóº„Z ïšD¾röÁ7H² ¬U%ˆíþÊ ô(ɇ`Qm0±@…5z¯ãë ó¦!°“Á•'icE{ŽžêRîQ™»ù<Ëþ/=dúÇ€ñUsÍð¦7Õë£ÁnîÎÿ”W5óa®:Š¢]öǨDs‰½£§ÑšO£?b)“„šî÷öD÷ûý}-7oœÅ¡ÛÁŽ–,IFq‡‚ï}½ó(N,‚FXPËÍ�ey"Pî)H] `ÁÁ~óG^„6Æ3îÈ;: Ëźgtpƒ¨\ƒ”äU�Z\„+E”jvªò¬Ÿ¸ôcXÿ…qôä>®bdñÿ¨AC9ìt>}/ð¯õ]±ù)UÑàyÒ‘ÿ'rÀÎt\ÔÁ+¿bˆòÜá îªsºàR·˜u\(Voíœù÷ùBœz¬òe¦1]);EAŠN¥±ký#¶”‚T`Ž†©óê %MÜY(íd¶Sœzÿ‡ÀË ¦z|ÿRà É Æ(åg'H÷’TaœÒD§áµzî_Þï Ùv|fΙ 2‡Y×’SCša­ûVDÞÕ#Ñ*®E}”èá‹ÎÍE¿Pº`°˜¶‚¤í(®êë㶪o3¢& PáJFÅÒ¦!«ùNìA§P£Ÿ´¶¢´òZX*'£ÇÑ© }îÜ(<?h7Ñ­bÿŽ©½Pã˜ûk%¾à, J\é–ozÏ P¦ræÉîqI@‚«,ðgm>Ÿ¡‘Ø�íÚµ±ñÜy2Ï”±=Ï1þ‰®dM<СPý±$TA[µ}fÆÉmkL@+Ox®½ùî×°²,¤@dIƒ|g]TB‹>æ E èÏ·¨²ì»%ˆxCë¹Í‚r¾: ¿€XïLðŸ4¤ªã%‡P¦IYp3µ7éëmÿàKyô~Nw`^É2¤­UÝŒÖå^W#-ÌÈG‹#_Ü:Ü£cdX7Öÿf¾1Úu™ ŒD_é óŸ"78{A·>—E²Qx¾�µö8Û&7Äd´šétÿ¿Ÿ%þr‡Ç#-÷ìë²’ž¢cW(É‘ÿ_x¬q¡sßÈôyë. ¢4sÉûÿ°x‘­žFʨÚÞ»zlKä î…±œ¯yŸ½Y5 KÒÅ9ÌéÜCÖ/{äl×G¤@‘%”îý§?fxGF¦ië…*"(ìÙ×ÛÞ u­c�t÷(«vÖc11žô<oå&ÚÿÎÙ€ÿö›ý0óXùV$¾A‚L“îÀ<zÔKÈ8ùš&g3»ÐüÔ{1 w·¹€cvÐð’!ºœ‰ð�P\ô»lŠ:þOÊŽ‘U²RùSKqãjûÛšé »¨ù™ûŠîêÖȤòü,e_(+‹k?=jZªA绨€›g{O_ÄʦüFìP×hFßy…eb­3Ç1ˆ”ùë´·äI¯BBAð¢I‡�½OO]ÏÛvötŒ…ÏÿP$ ßð†qÖáq÷ÍO¯â%bDN“[÷åZÛ·W¼®°œ©Hºo,µJ&Cï)º¼Ò(VæËTct3f_–2 ¦u}žŠš•]xIÙ:ˆ±Êgo[T v8ý³>J^ûtôÜȾmôóº±*»û~èŽõZ‹^›¨MCà÷>±ç6Î W*Ñó l>h1Æ 7‡ËOžkYbÎà84=u6/wµ/MLŸ_ÎC0ßMžóÈü;,ÜgÌ<+øvz&‚Ts’®½'Oå{)*›¯ÏwS(Kl#aw¦Q3V!èi¿·À… l ç"¢ïæâÒJxCYÔâÄ¿6=…”¨Qn3|£äH'kh÷#7¯|´JQ2Ví_ÍkeD±!¤yæ?  âjmKFYÁ@oZ5¬œ¥©lk…/©¼æza2ö)T™ãí  qQÎx¸Z¾#Ý…3¾­e¸ü+‰«Ès™ä—†+¿i(~'£ÂA«œÉ@½“|%ûúužgžÝ$¬æ®´æ®OsžR2Š±F%b>LŠ_½{Ég ÓXù]E*£Áà;J¶ ­³Judj|Î’¹íÐÂSäämùž gM¦Ò3¯Ð7š°jÞµû.LeŠ4TçàÆ.j 'r툰§&œf¾žl’¯´bêÅáiÓý±F¼Ë‘3Ró‚Â$¨Û\©ŒcŸÁìsNçØÁ“F<ÔÛNÎ_ùæT\ó�à%†›˜ÆæÀÙЖ G;Täòµ>Ó:–‰Ë:#2öªÉG\iÿ›ILn®þFØSy|Ç1)š©T®meòÆULºÿò¤Ð\rÝEø#kãg”˱I,Š!F©"F¡oS»rŒoÅHéå÷Íu(Pߦ‹Ý”O°!9hã`B«´RX®Epð"(òÄ,™á\h±l4;ÉxlÔóðmõHøP3ÏÜè-öT»}zðÒ‚vÀÑGë•ià`{ïJ²×UÇ!ÏüÚŽ*–ÓGJµÓ¡=Ë”õh¼¢!üuí·w±$FáûLu·–w¸ûK¯‹Xï1>&ïÞm¦+U3Ï·ßè®Õ‚Nø§jXëLÁ(R>_Ë ÝÕâ“–e@l×üÔy>B{ Üï#ˆ¾ï±ÂoÙ•AR+Á6*6Ø ˆs†Ñ¸öÓkžt6ûì-& ¦/Z­ÛrUWàÝåjr˜§ zGª¸³ìN ׎ºÙ|æ»õŸÎ,¨Tì»öÞŒ*­œàsŒ5Õ\“ îtðÔ̦­mÓÀ Y�Z܇ŒŒ;aÛcÁ´ £Äâó,"ýµ*š8Íëû—ß4ŠÒ‡ôy÷A!9=Ï*[1œ@àÚLß8\öEs h¤ûa!Y¹¥@R¦E‘j‘¸9z;M~ѧ4)|™8Zv}Ûl}âêF„â…Î̽.Íb ý¡é¡ûÜ{ÆßKÝ_™Ä_Båun_oòÇÔ“_aú¶ƒ¼U8©ºO™)* *mä„œ¡Lß¾Þ¹Yeæ™]!ì›�M&:@?fß®ø7ª]YTežÉN$/UsP÷&,›¨}į¸Bþˆ³)B¿3Mñà”$ArÍ_EWšïž 8Sy@‘±„|JÈ UC‘Z¤^î¯cCU9žéT«/¾ˆùеô?²E=/Þ¶oT÷ö§Ÿ¡›yŠàTm:ʳÆÆ›|ò ªi%ÔýL¯Û£ôˆLAßæyÙèYqð¼2nÕãê®gwºOÇoQ9ÈHˆ ¿ÐK…½Äf aPÃ+ý™^ª‹f¬H@Mk«UBÍ…?ªz YMŸ¹ýjÀzÁóé¹y¹ã¢Ø×gTôÏ°{ßN5+•v¾l/•0G U7¯h‡†>ðýÝÊÿ³‡HóؤϓþÝ èX=1Å.ÒÌ#gÁÓ æ¨ÝâµSÚNÏÙ6±ß²¾¨òÛGõgše>Á€¾útH)“Û»™>eŒ f˜”tŸ¾žý±Gb‡+pN‰˜e­M1*Ž`HxçqKNh Ñ=y°ÍÐ\[ºJZÑHëuHE¥à› ¶iQ÷×v9âM¿çß«¤9c�饈²"¼ „Áÿûp�0”¢š üŠHVh±‘)·}¤G;ml{2³Tm)[ÐØ$ÐOãô5¹/D©Úü\;1 :åé±-F$†2Päت]u¹N­B!¾‰ŽÆ©g\Éâ^-å½²Y·´…N–7¡hè; ¶¾­¿±rb²Æ…ܱò× 9K·QFÖ£B`®ÿyKÒÂ;¨`; ³hå‰jþo†ÝYéÌ xÒY7Õ­äbùÀÿÁ©má·fVlþ¿šçÞ0™|°|ÒvOö{ÓŒ¨Ø/°Wiz3mhša‡ò>àßnÖÀ/£‘ˆõH "töRl<i||§Xþ{)çn+Ÿœaùü®Ç…H‘PpßX·ÈAžaÃ";e|½/cçʯ+™uÇ£êãçÑЈ2˜ÐíÐ{Lmß›0Bžƒ£¨8(ùVØoó,¼Û·«"6\¶¼Ž'ÚTÇÚvC8ÒìFZ¸¡•1_<_a8Aœ`5)ϲÎõ9h7›‹‘ûë궯Ïoû OzV?áh|¼ ݬý™MQëNò@Æ]Û¾‰LI‹‰¤hǃøCÉ«ÈÊÛðµ‚Òy¥¡X�SŽžÚ g.ÎqpH±~ÕtÖËrç@ukûFxlo™Q.Ö9æ‡tŠø¾ˆõlTT_ÿ uº“¹Ãð‡=„zñ4ÔÌÞÆ­ÕèˆÂØ—ò§´¼iP5EÃTc3 ËQwx(ÿ’p•ùÒºa P|ß­Ôkñ CR*ö‚ Gƒ g^îgÇ^6.ÊϪd’ÑÚÂwf‘T3°Îùe(Êq¡pƒX€ðûoüú‰ €l-ô—B›` ‚Ñ<&$ªöx£çøDá1Ô>mfFϧ6§§¯ZbYm³BmÌ”V›€ýÐÅòÙ(7E 3äß¿œˆØµ^ôèeDqYyM4:»Ã2+ÊÄ®+ï=#¯'"_?i}Y÷ÚÔ$·¨UÒÞJÎ1ôH¯ê®þjµbùR쯊½0vEï®^Ÿ©Á¦éÎkuì®fü¨z/ÿ‚*®ÔEœ]¶Ñ‡-ò”'d}v?H Níeàžã=jòC‘Ò3ååhrhª ·69û8ô-ÈÐ[mb6‹€óÐöåÏ¥U|d4"ÈÖÔ¢<B䌇Ùü&üÑÆþÁž-÷Ú»¼Œxš-­SA‘C‚mî·†zqœS%~miPÞ# „Á±ð‡rЫ…ÖK@nׯÒk§s,oÚmdÖ`C0p¢(0mÎ ålÏÑš!µ䡺¹~貪HFê±Ú¯"¨\8ôÒÐTv6³‘¸4õ…r÷ÃÝ4­ºu£äs"\T´—Ïm( ÏZþê¤H y¦ë¾ý“À€±7ýKkÕR ¨ø×s;{[‡•©˜pø”M£vP-Ä"ÑšýÕc'I½¬œ™ 3á29»‹ {pÒZY±ãòw®oäwŒh~@|û&þs8Sªú¥­¿¢Ò /ó'Œ.ÒÿJ%,<\Ÿ¦ô¨Xn4þñŒ©ÝU€´õdD©ž>…ʵK¥[zª¶Hæ’²î"fÙìÏÆÜNæÍV™N£è¿ô„|-he{¢rÛMà.í…“z 9ÅQÍ8èK«ò䑚ʨ¿ÄLf¹?˜úrzÃ$~Ê((°í4÷K"÷:ŠëÏOa÷VÉX³ÓàK n§áÚˆ äµ¹'zîM—$ëZ`@žwvPítÿå–ó(1埼Ø\73ýÃË„8:yˆTUÑîm‡q0±ìΕÓ%÷ S�z6€Ò&¾í4`{ÎÇA馌A¢ÜϯQo”ê*<â¾/‚Èa§oÌ ztvüƒzÔ:rùÍ| ¦^·ôïôø+/B±çìq̃²µÖ¸”T ÀùÇX~ù:}Û"6¡Pý haþ›Ñ ¹•?´õc¨=šÙá¼q±Š¡Ô Jª‘p™®w.î}zÝÃ3¬À8WË©$ Ö –•dxZ‚æéªt«(Гx·äï„¥6²ÀPkLéu/vm/©ã7cñL+›a£‡O!)™5ÃNL˜ãtZЯ¦)pœå5›ƒÞ"ž·è"†4‡AjAž|º “yñÊ`]¼g¾ï¶è+ÔÊ™I =Ò¹ö8cVQç>÷Ü>ÊY^È_J/”³À <XÒw å±p! î!OæW&,¥§«Àaps`m÷Ö£ aPÛ]åš«ó^¨`û¥§L µÌ–CåSM�%"Šó€#æúÉ…Q ;}ÐÍû^1€)’ ôÔTàî-ðûPÝŽƒâ£½:MŒW…mÂÅ¡Ñf6R¶ûk¿;dlW,ú3ªuù"©Š}íŠ{XñV‡ÞÏÙ�Dz0¤½#tƒp`ò×âP±´EšŠÞåw³6ªLÜôƒøýž¶wº(:0\µ©ÕåvRŠ¹¡õÕq©¾¥…ø<,X]y¤”'©'WŸ¨^–ÄSO„è�îÒ™$mmGí!°Š`ÞçAº±*ø%óK÷V³k—íAD™öf~DÉË£_›ÊjXþ÷nPbb{ä³Pµzþ | ¢rÒv’N€^Ý[uq¶²Ü¦b».‚â°7«¶:à:~=8ÓtÚÖ˜<ìl&åŠÕÌNô´ßõ³£ÓHÇÚ�N€ª¸úáýßsÃÈ3>‹j[´“Æ(µWÞùn÷-U–­ÓŽµß||Qÿâ8RQÓ(¬Â(óÈ“Å Ï{ìAno*Åé>¢âPÂÙÊ© Rœ;xCÛ £A1ÚN¼‘tðð-O. ••R¦Uwô–µü)�+¥çqº?ÞØãd<bgDž#«ê‹<7í/¥N‹ÅØ›IHEÐňHžÞíЉÜ›¯¬ëRÝÞ!'!!4§2ÖÆ’"Ógk8ð²–Xi� £jÌ/˜”žÉ7íMO'mTÛ”dæ®­ÍØS±7ëšž:dà K°ŽNv.™Èø¢ÐzÈÒÓêìï¨<_€dz.Ù: HÁ†A´®[íkd¹¸îõ¾5²#TÝ»ºoÌàT‡…~!f›³&¹‘„c} •<{Ùb3Šs—M%L2¤Õ9Zó–ÎÍq0m]);”ß´ÅLÀ3°N¢ßM¢œ=oÈâ¤ØË~4«ˆ©¾è€]ÍpRÖ¬>`k‹þ`fçÀÀ$ƒˆFëŸÞÜ1¶OõU!ÚŠ à©ïþèú;¬0¢å)ÍÑÂÀ · =zgÚí˜tzEZÅHýY³eßJ‰¶¸W: zŠÔ–Ÿ;7ë)°ôZõþî´ªvô´QŠ±P„Ó^{Y„M"Ö 3±¤Œ¾þzh™¿ ²ýg?ʬòÈ–Wv¬×핾W÷†bÈÓEÑÖõãÜžŸwV¹}~úH$î:ÑûysÄ ËúgÓÍ¥U@Å°t„þÊ™:¾¤i3´ RkDZŽ –æ²Ã¸Ž4Ž"ðþº‚œ¼ã¨dv2åN”›í“q‚a­«)3<÷N˜s0Y_piD#[™" jçÍêˆxË“HpÙ"Ä}úPF(ŠIù ªKåô©¬mhzXKO'@ôùi>1ŸƒÕ̦-`cÊŠö g›‚£î:m;Iƒ”{ê8bpL³2Ð(4@û[ꨊ|[vÈ. ?T9"£ùÝ¡1ð³ª+$‘ŒtÝÏ&…´’¥Uð±äAñ®YX™) ÜfaóyÚÅÆÛ\¼J{®|5: ö6E؉ D´‹{eòÓÑñŒÇÛ>Óø‰=½iËÎ0žêÅ1€•Óöñϳ¸Ê£Ñó8|{H+ªµ&-ŠõIoR‹°£0‡)¤ J´,‡ŒGãd+Æ–RµYÛsÇE >½+Þ¥*ƒè8ƒ•¢UÕfï1lÞ‡^NÓ³*î껇‘xçŒ DÒ×ïÖxÐ ¥ÝÖš~Ûoµ""ÿ¯@ïo¢*ð}²;ëÒ¦õ¯bõtïþŒfIÒJÁbÌ`عƒJr0wÇÎŒ†y°)õÌm1{ÿ·Ñÿ%©3&B‘˜³ì`b?‘‰á Ó$¬ç>òKbƒ±B‹m)§,ÕçÅö!v:—›dåW©KfIäJÝóúË-TüÏ,¹ª|ªaÏÞ2íþ8¯¨§sÿ ‹¬#2ªD#¨áýè5°6]}œöÃe:êsþÕ¨µ,="&ùmOyب€„Ekk¯$MÓ jÎýi¸ °v†ä¦[.µöÒ ëÛ>b]GŸT‰MLM—+ÙV:';è_z8“BЊS{´î wSÿ{ìÿ»Ã›ç;¿ñx…'Ô ‘ˆà0¢oØ)�™qhaþÀ=Cgéù³¹gêE 6~ý_oðœÊâ•koYÔF[& ¦¦õÕ|Q®õ:™êëlþ]¨Ð„mƒ»¥XëiÈSrx}•V¢ JKm;k2ýÜëK´ ïiÊ7JÚ] ¾³¢,µ ¤þèLSæÉš#P³ZBX¤äÿÂ8¹.fUï‡QrV±:÷ei¾cÛÿCì%î‘ýñAT¢¨Ü£¦|לÖ˜m'6XFVÿŸ •ÛRèd¢¹séÙ?Íô™_RÚñ;›Ü:é÷´jR+NCÀÄÅ__›`^öâ{÷4Ó^s¬^Ϙï‡SíTkDnwcšþó©eký­7â?¸:ïÛœ¿ÌÜœ¶ %;¹•C™ò9Ü…Eý ¦ÿ‹Ý IºîÚ÷« *ŒnÛ¬:ó;ÿ=Ay¶Žœ°€&*RÍÎñ±TøêÙíþþàùÝaYŠ çïl\³4¼­4.EM‹  èbÓ1Xo¯¦‘¥^àŽß3ð]¦Ìä(ÍBKæÐyϘiÑ ךj/ïÊ$Z‰Ø¨0²ñ]h¯›I•x° îR‰°Â‡©”D÷¤}¤°PºS<Ûôs$ŸÖg”YJ˜Fgeõ˜še&¼™€dÖì|âb׉tŒÑ8„ˆüZ2ËÝiÍxMƒ”cœ]{˜Ù¥Ú«ÿ€˜âs´Ol.C£Ç‡öfj5œd˜Ðn6M Û¸ú©Ói|´Í}æà;í©4Ï£×wµ†–¢A϶¢§ðèÕÃO¨S8ÖÅyòúƒGÚÞoæç*†W¨Ö¥mžŠää¥FI¾èp˜õ˜gnÓÁsƒˆ*ÿoÈ¡í0oZqÞ Ïögxìv¦¡œ–õZ\‚þû±“Çç® Ì:Z‡ŒüƤÝø}û‰âžÊ„¬Éòè2*2wSÝþ¡ú·n¼ÞÜÒöíÄÝc•¨4#q{ñ8™{­Þ$ÛMÄ¥jlͼ̈ìÏÌn´Ð{WÖŽ#Œ3üâ2.®w‚æy¯nl݈·¼ÔÌDQçHpWzƯ(N)¨‚”o1šV”(¥ŸÑ+úÿ¼Íc‡´›ÏÇ¥}K"^2´ÈA䥿…”¦;Ê>ïˆDB!1Û+dB£wËÆñ¢°9°±oÿñ3õ-Ÿìªýî MAºçÍ÷d°›$·—78-æÄg †}ÜÅ*Bb[7W±àÕ²ŸŽ§ysµ¯ž’Ñ«ÖￇÛvä†p|ÜO†Iœ”Maït_GC 6 Ž-dò,¼¡äpQεٟb¥õ6ÂC 8°M1,œ­KÞ|USûuZq¿9‰˜´Õ§€p—aœuVS±:nµÆ„Á‚̬nàÝKo®'˜9:4èñAÁ¢†�í«e�Cû?=˜4 }=U=”¢6¶Q‡¿8,Îq:ÏJ÷’*\C÷*ãÄÉ¿I7‹-®V¾s-zBý×€’^Ô¨(ƒ3/(Û wã]mvúç›LWæ€îÙé-MSeÃ*Íô7"pÑ k^0âùöfÿé­b£‰k|‰Ž϶.ÔõN}SuO\_,È7Ð5N¬§`sì>çùxsöžis3’ñz;ÜÄ[ÕC9S"³éê¦_2:Š9´«y˜`à¼/Ñ"éµ ‚ém”IŒ£#_q´‘tjD9ujeÝPåf;÷øi< ®ÈÞŽsÛ5O91qšú2¹ ´¥\›Ô3±NÉ{ˆsæýØá*+ü68edÓ‰>åÒy- 6Ì¡b¹µøñSÒWÞº+ñ©Ÿ b‚ÒC8éK½lèül¯–!ò„l›f¾ EŒ£žžl±ŽJœô}Íì]ÃJªîX—¥us¸Ç«±ƒ0ÁÃtkµ7í9ž\‡þN³æç¶M:.rÄf·=Õ®nÜš×ÇrÄ14<Òþ ^Åž?{ɤ Ìõë™<³4¬LCkÆ ÍÑúÅh–Q¬áL”Á:(ÚTç‹Ù(Ïsâmó®î¼‘f±þx%÷³ê›å“mÓE§O-«Ó^ùàŒƒc93j ÒÍ´+ƒý±AR4!‹K«ë>brŽº«‰›¥“Ç’û\AõiÛÕ™X¦²WK*驇TnÛá4a 7ªèþz/Œ…-eñûíùÝ ‹T^@`Jt«¶ #2iš‹^;‹úëp¦?c ‰Q¢¹àöĆŠlžšÝBýóìä5¶ÐÊ8ôf‹\ !ú.8@ü0]É)Ñ™7íö bÔúkD‰Æt3æ7›‹wxñ ÷kÏÀøåð\M°ð„‘¨R¢}h<Î(òìm=ÚàvÁ§C’eôq¾ÿæ %2=05ÀË% b{‡2ã!§(ÝáÜÏ †×‹;Oe¡C¬Jº](ÏõÝÍ=‡b9-}ž¶yÙr¾ºM軾r+íÍ]Y=?»YéÍ[Ö¨št™NõÜöOA8Qâç&×™®O­ÛÓÒk(« ïë|N§Ç™^×2Erì=e½ú,â·¶ò˜Î~ïÕW\+#’*ºë“õË. ­,«×qž˜Îuûºžž™l–T[(Ô†ÝU5ç*ƒ?°9KDm ?Ì3íªcoHˆ2T27ØtPbº/6MË°X² ²E€YfþBù-[ú ¦I*q`¨?¾ÊB@öÕ¯cŠ›¡{ÚõHh0#-sÃE¤ïȬõÿW}hZÌKM¡1¬õÐJkxyŽô)`Q*9ëb~íòÈx›Š]ãCê¸}^è6„VY7Y¤! )™ ÈÍ¿£¹Çvf•Íþé{m5i€ãf§PÑöMJð Wà*ô¦Àǃ¹¦é%ÆXʬn`; Öx…{éyµF&ÉÅ”ç䀃ô:%/À±½,m³º~äQ*m”AXI¦S$Ýâ9ÓœÛíÐcËXL…º…ً׼Ī"[ãr…S=Y\nÉY07¶œz…#W®x6a¾(±9+UJY¼á웾2‰²Äï¿„¥ˆííîÏ×-,ºÔb­ ~Çõa ëSäþ„ø£$«Ü´Ùy.9Nt2½Z!~±Õ8Ž,îšãU(aŠ²ŽTm•›×µþpå´ YDr¥*¨ÆÆ |'‘ÎPy3ó§åŸ-)M†qA1° bk3Yä´ð¡9¼žÎ_Ýð+îg¦½¯™Nš¢Ùx =¦¾}zV”å]ùÉ1Ô©mh‹™^áÛŽJR ·÷~ém…)£NŒöö„FùsĦ6 |Û™i@ôzrÿ2¢øV¸n*Cøèd¢ü±{·Ô\WCžLˆúù ö”1ÏxyAÿ}ð€ÕI±ÔAÏzŒñþâ8~Óµ}3#ÀÓ¸ý÷ {ÎÓPY©óGäÍFmdH�JìÖ Ì_ÎÝ©ÕŸ~Bæƹ§“\0¬‚e {ÕlA’/ã ‰Ô¯©ZȾÀÏ V_Ž›³–ä0ЃP‹ÌfUšâ©³ >ÜåÂáÝÑ[~ΞÉ\3]SÌÀsç„ÂÛ lýÀ°Å¸Õ@‰Ò2 }`ù·ªÔ`!ŒO±Œ‘bz 6¹ š…îÁæË#XÖ³g«{iÍ|[/x+áòNrÓÀ(]¹–%º •Óã®’]é÷‹ã'u²Ôbê@bͪxï=À Zäé±&lÆy}õºî×d…o Ô ¼»¢Âó=u¬5l>œ1&åÚ_&âd ¶­5,²æ2Bb‹8¯ úòæü¥Ä ÎW"´à:Fÿµ*^ÜYŸQ¢{Õ½B#A6Œ¶ñžÕ9�£¶Öƒ†OCIßg«Í&§æ 6·ÜÃòW†¸úቃ5P—Á7e9{ÚRic%êæ_¶'NÙ¡PÛ ~[Ü:“¯tna<KÆIs€nnĤ©{Ï„›¢ÀÃ÷síÎ<ºi¯ˆtÿWãÜÈ6Ѓ+ˆ"ŸUÚ+%À{(÷+‚j3;˜öG¿2Á~¡H•iªÕ4Û|B�Ì)§�a€rš>MÉø K«(ôÙ~ôÎ×!M‚¤Q¬ ð¬]d ì¹Ò½´FȆbÿ’)F7d_ç8fû¸SÝæ4{xÖ’iyö«ö¯yÙ'¶UðÁ”û®²³'ç±²0Rèš#ž`bð¯ËŒ;p‡W˜¾ÌåÚ]G÷ |ýÈž}ûË•Æ+`ø|Ú^ïüë©÷‡•QúÙî(Lεր ì¬jýÈæ>½+i%õ»ðô© #©Æ”ÔPøˆ”&œFã¿Bb¿U™ðó„!Q­œ.NÏêŽsÙ_C+£ÿKâ(*r“™q9{Ê‚ô¯ÒM6 ÐÝüç-õ’ô¨“€“7IªÅ–P_}'RÁY4[?œw*o\BÕ³ó|’vÄMùþ�ÝäF¹žÓ=¨YJ$vøš‘6Qù ,(Å÷UPºçòþqÚÀâìÇßÚãèB. „ý…²AoÈÓàâlº0!.Ž_ˆŽrÛCdúáSGF‹„9WAÔ+1·¾æðÑ–øº>”ïbä/¡½Eá 9¼{Õ,-è=ÇʻݷW#÷žë,(6vÆ*6™Úp}ï¤à_éð2J™•@ò+m¯®É¤îÄçáäÿËùƒ=SÙpmÄU‚›NŸÖ¾+Ï·„aë݇a‚¸3REQÝõ)ÖÖ’‰é»Ï³ „ çXÅ”“1öä—]÷ÈCnd¬V”£#5ÝÈÎ3ž§Â½åÌí.mVúfjôîÐØ<¼[óEdªÜCùÇ\8‹ýÑ*{îP€©?½”sŸ2ñ¢­N”ù ~ð 9D¨öÖ5{ÂÿÂ3NúÏÅ·Zõ:Q<XµÎ`䆊ÿ¯ç -3Á+rÎ ðö©VuµÓ(•©Yo^io‘yV°%°Ô¾¢¤Üˆw$ÑòßJ_åµ–EŽr²:ͪs‹È@%¤#Ÿ“'ó'vл§÷Õ×Çc‰µh=Õ›<È; ›�ãoײp€Ü‘¨zqÅ$.µH=Ðs¬`KšCP©­õ³× !ß¾úãk¿Iá—b¨HwÞš3HêþWS^ãIr´ >£ì÷³ÞŸ#4±›HÕA'qUÄä—™–Ÿ¸Ë+%Õ{¿¬Üü[[°á‡ƒÙ«Œ|ÄQÞŸ­ÀÕ(j¸·ÿ³æVìõTYú/èlÏZ=÷ÆÖ0ö†Öôt€s붕O»¡£ûC…Ä­8Žçõ–qûê`ÖÆó Ä(w@€Ôh¬²-ýV;æÅ(9YmìTA~î º©,˜ˆÞt-ÏfØ»Ñøvý6pÙÀqÉsšÑSl=½%T¢­õ8‚Ⱥ™Ô˜[ªv nòP€k>ûµr+ŠˆÉÍ4­éûÆÃ#8C9 ñÍp•f뙓vÛJ¹7×JJ¿î ÷?ÁåÆæ�¦ôŒ°ÿÍ*8­¼I»Â _â²½‡Ð§Sˆ›ofz9.½&J׋”þµí¾Z¢Û·•AÕô&¡ÌXsýTÛ.Ó`Hþå:ÂGåÚҹ䮧SN; £E¥ÒAE'†JI#yŽ½gž{_?3J}ó³‚î›ë‡Ô嘘Q¶EúAƒ`ƒñ$Ä1ÌOÆå7–¸Y»48Ó”þ›V1ÿ¼ý€´Š<![¬ó¸´é1~.šÑ4R#3ÐöÌ _É•uŠK¾ß4sSï>2YÐMkc‘ôõþó7Šé­t^‚$V˜õYÚGAqm="˜z?itz$D¥Íìc6Jb‡Áô0p$�…Ø‘Çù`{·¿w´¤xqü�Ì€jwk€ôAЛ¨ «%8˜ª74?°7µ +à„çcÆ­í~¤–m<äÄJZÍ—ëÝÐ\§+åÒÖYp[·Óˆãóê_úzÛªO=¢4O¬õ+{a0îÂâ­¬ ë=;ÖÕ¦+ÐÎÚS ZÚT” ‰Òè$©~ˆíjÜ¿\©ºÎb  ×½;h‡®=:&R°‚Òêß{æ3åÚ¡�vŸ’ãy4µ}+wÀä®ieÇ'ÐÎ빜ƒqPsºéJõ0 JUÐF`ëÜšNßYðö–ø•Ð@M Áߌশ1»;¬IêÁèîØ”êË×>Àv�ä;.Šº+çŠP.aŽó÷_ìàY¶n$¾ÕkÉÌÙŽÒ‹dÔè}h{Úd2”˜^²œ›+m¦†ý»Ð,u‡>€$Aœë—6îõèBßU·ïåp´sOÊ×Q©_d·ùDª ×¾QôtæÞ‚B³Zk‰ïÜ8 û‰ÑÏÐy¡ïÔ]’] /ëÅÓK@üÈ÷ULIŽÓÛ}g¸mÒÍÚæá¦u&p‘Ù´ Ì­Uv ³§®qX‡×ô'í,&1„e¦^ZóC™¬ÜóI¦wé ƒåtS±i¶©g =! ´}éG¦ÅEäžaŽ èšx£´Ï`Ù¥¥l~YKbÒÚâÅlœ5¾Ä~ÁC‡«GV¯pÉÊ~'¥¹£°‹'öDá{rrÈøÔèÊx:E¯ÍôsOI&ä’»‚RäwOÏCäòLªw¯ÌvŸ±4Š:í…ð¬Vì-ƒô¸ ÃX¢­L•»Òßzz—Ž¼ÃªKÁççÀ>¡ébg(Ò’¾ÈE–àr@+KÓïÚpqåT·˜ô×ôINñè–Ã,g·Eë0 R\°Tb„Rî ¶ «7šõ¹çKdýäDÄ4–KÙõʬ-H$šçÊ-Å�|õ÷˜d=ÊÜ]h\æAbMè ¡0ÍG‹…Ý$§ÍR %âqnÍ+r.À«`û‡’Êl£»=.á<JOÚˆýš-yÞÓ=’o•‘q9 ꊲ`Ø‚l´LfûMÚ‘Êõæ£ €mcÌû–èä…?ý|€uÅp7-Ž½ƒ›Ÿ;mq«‘€!æ½w­X~¦´Ù§˜f÷¡èk¯æ)ê5CÏ÷´ñFõ¿ûøUiÙ¥b± kºpT]8ºïi•ÿÞˆNÍÑÅÇ1߶ÂR3Áîg8 -™Ùœí%‡6}çʸjÎHc²Y[fœ|ßnZ Øa~Úþ£u|˜Ý�m.»<ˆ&/éÝ;@tìm&úœÂ’zȶõa™ÒuêãÐ(Æã©¢•…ÂÞúM¤i¤Ï™ó°Õaò=íÀ¹3Ò÷T\5B9ȉç[ð@¡ïÔó:ÿGG¯H¦æá­¾äTáá¯çÔÉ0€âþó–Ç ©Lo锘+:xîªÝñ,ÛÏŸ¤÷¥®YP®¥ƒ«˜4BB Φ§AUðæ¡;²äú÷‹o2/ùª”)ÁŸR:#gÓW�4yCÛ0¾-²L¥ku²¬Äì £?ÖtRøèÝ£ÌÖ¢¸DÒöÒ×™­¡ØKU`â8iPmw)}ì¥öR¶‡š>²u•Ù�ŸHÎ^LºaMý¶½ö¨ËiÞû=çÄÙž 3í¶óHM8‚ë?”L™¢í§Ãµg§lfŸ›~¸™ý&i^–©)¾Ù›ïÒälá,[ãÂuëj[¯G×0·Eç‘#Žçôäoò˜y–yöaÌT/'£Òÿ5k3¼tP.{;è0ïÝæÑé´Gƺôc)ƒØú]DUzCÈ–å8ˆºvÛYÞ’+á¼¼³ä^~MÉgyØéÖ7éz²çÌÔ^>ZgFO¶JÚ>g\ô(¹8_µðÜsÏXnüÞ̾…m,½R¡¬n÷íAß“WôüZ ùöÊOMØ®Òbñc$eÈ4rx€­/ÜéÉè÷á ³,Î žª4Œë›Eu\ë+zð®´3ä€ÁÅš–Ð0}ƒ[àm?ÒŽBC£Áö‡á§ Œ•|,Ãô@­:Ðoùça¨P󂢑¶OãC a…­†'2Š‘¥·¥f°ÏÂ’¥5r6vfp8B¶Àæ—Lnu †ÞH5” Ʋ¥p‹ÖOýã¥ç! º}CJßãëêÕJtDŠ“_ Ë­O̦séidªíÂã‰ö”¿LÓ³&àl剻[“á§ÅXhèÀ†™�oš$¨v˜ry³ÐIÖj+S!Éϯ%¼žµÊº3eð= ðÞßÆ,͹§pŠUù:º6rÆ)R-€×YÅΖ}!Ú-"¨öî^��à¬Ëàp¦úú,tQéqç‹ÿ»KV®œ )¥ÈéKM{g›‹VŽœ@¦z…€Ë¬ºûöò[O#ÁÌ˼3ëÈÏ�×eŸŠ¥Îm¿š«5ÔMäv·:U(œ f#J»ƒkL±@<W³Ü&x Pyª5<CŸ!¹ÓÔµ·¯=>ú¯èè7?ZðˆÜ—B,L0“>¸ÁëŸiÓÏ:HwzIÖ÷0ejCÌyÏ{O‡vøhçfBÇÞä¯.Î,¼1Ø0ƒÃ ¡Å¼©;évèÂçþFîb}ÿÃðFšš;é»bû³Ú(‹MG䤘%Èÿ«¨BT¬FÔ\¿&YPÌ=V!EQ>µ¡£‹Uz`çF£ÂöÜŽÈÌ'´SF±h†ÇÛYAÊPÞØý="úC¢ù|e†*ð—«xÜaPWqæa™Ò™R.tõX? • l¡àx~šHÏP^ÌF.Í]BþÃMFhiÄïC ÖÝˆæ‡ \-qÒ¹õ®~XMxóð† ¿ÝÀ&kÖÊ>Ï¥¨;.atý¼ Sƒ”3ò %(üîÏbÿäÔÜp³Uéô™¿82#†�C ¬<Ô-Ý^Ÿz=xÌQ·$ºÒPÔû)6"+|蓾SÈÆÑJuªñí«ªõ+qH(Ù5PFø4é$óøÓú8——¡ÞyåËw ~KèSÖêy|ྗ’þ våÑž™­i…6^"¨<@¢_æ+f+ç•TÝâ³J”~ö ÍþåÅ´_`‚höÿÍ`5ëò_k”ŽåÅJM§â›Éã@µÛA5и§TÕXìTŒ…ÄïïÂõ† ={uæ›vgªæÙGc<Ž´¾8tt—ý¶9ÿý[ÿ’0¤óNkp°|æAÕŸ=S6 æ{ƒBRºÈg•“ÊÞ;ÞŒ9œpI›}¬|Û¦›~f᧪¸Nïÿ–>zìãcè¹SÖÔ)Y:…\ØÔàúëC5RчHx •ê\FcM]­r°Ð2±ê>í×SŸ úö‹Jdz¸¡až°Uã îeƒÄU-9éÿZn½Ô¸®?¥¦eî;Qðº<Ví[bЙÏ=ªJí¶ìŽœ<ÇxgÞz„ÅFp¢Ç/ÊxÒÑ\µ…cÍ0^3¾HK/¹`…´ãžbW7[r|&¹Qëz§¸?›ÃÆ>;ch}M‡=L*ÃÑ’^Š(Ë+Î[7&mwõm³0\)4P…Mp£é"‚-¶1ïÇæØ`ªC•û¨žè–°Á«:‹XöÁÉ7ŸGlsvþÓTVªú/†~«9ƒU». ÆzFÇ$ꮾHù4ô^'‰’Vñ¯Oôd„pXO'$¿­5ÏXÿÌtë‘ñqÖía²ã¹twV@ExCá¾êë˽֤º51„¸Dôµx-ÓÀ òQ’¹ÀÇMŒ Š­åU;A,{£) :çhAÂWdßNNò ‘)JR_C›JŒ¦¥½7ÞǦ…Ý[}n!b¿BÕV˜>7m•*™lf¢«W±"°hôgœËQeklÄRÙ÷¢ ,B|—ëidšÔÑʨt¸nÐmNéd?[?¤H¡k¡k“BB„÷£žÝ^ißâÛ/À—*W"ï9è†,³9  Ãp…É Y¯›&Xuí@ÙêBÛ*;ÔF“'I7ô>»r…<Æ_pp›ÿB¤x3uJÀ9|šþk1…IäoY“RhÓÿûÅs£„(÷ ˜ïÌb³ïZ¢p'{eä»Äû×ú³Ig+>I?Q"-;mü”Áí»ÓíÂ[A†á‚ûÈ¥RgYâk_BëRQ-º÷`‹óö0 Ua“þ)‡N¡­Í!`3Ö×Ãÿ‚Άo© Y]ÑçÞ HLBQsƒÿG…KW—wÕLÓ(ó)[¨Kw`%îöÞëÐÒ·¢¼érB+up%fO8+q´ªF)LFŠ@©•A†�kw†àràìÒÓõræ²ÂsªD’69Xùؘ‹g€òDŠ6vj±,?ÑPLC;ò-õä塆aðuߊ!ò²ôÂXäFŠm”—v6îxÜ“=»0Të[ðÜÀ Œ¸²lÚt›­puSŒC/bWV?ÍLǃ¥•<æ2µtcõÅ£yá¸ãv`ßæàýu4FôqYSØ„oŽûý±ÿïæú_:«y*sÓbÿÖqòÒ1ù!†ƒœJ^K4…R?UæÒx1ÐÏØ\»²Kùd™q›JÃü®ºiFøþtíµ¬{…ÏxmTèÁDÎœÜcÅ•é8,‹c±õõ»WwÜ*£5Á Oz¬·~TYW>øHÀÓöá“M¬NŒ%Á¾ §-—Z›s^1SËrÙ)kˆm¿ Àe©?Âän±Ù§œ�ÛœÚý�çYÎq’›™éFz=B®~Ù46ɼáP‰ªŒ"YÊÊŠö¶A^E¹Žó4 ‡0ËÕ³iH!ÔIPZUžz´íö`�£\‡ î*Ž ÒÕ[x¨?f™•&à„r3:Æw:U`–"6./deqœø”Cö Ãe}+ qÚL뾯;ñ*fÇ1wuÇ}-óT ØwNéIîTsƒ¼E½Ýx™>ìÏ=nÖQèqر ß ;§ìÑnx_z &ÛhªýLea… ³c(‚—\2¢è† DŸ¨¦ÃÝüt¨ÿÔýºÎ)ŠÌë[RZ9Ïq5³—V ©(¦»Žëýd€ýó€Û×ìÂ!ð˜&»Úù$¦-LÜp056\þ…+ïŒ-SS>t}„–cLÃGz‡3¥ÁìNdšk¯i¿ÆIè›N ýŪ†_Nä{¾Ô–}Ô_jqø­ÿ€<É<í±Èß›ÞÓ,Q¹>1[Ðü瓼 }0IÄP·$(FÄqj4TÙûÂ4Ü8x±§ÛobeâÚ¢ ÒRÒí—AÆT®pºoâóÞ(xx$ôˆºcž×ÙuÇÅÍÐ]Oãq+{ß|;úTw5¾�#w“pþÊôOi=¼aú·U“g-‚/&°‘׎9Kò1}ãí òs³'A ƒï~ 4åI¬Šî_~£…©1âà j:{N‡¬«¿®“sN•á32¶UÌ ëN”ñ|öt}ê¦9Î2“REª'þ“YúÊy¥¸"c–o)Åìk“ýè‰ôÔ%)÷&›1FþЪ.Ïžáùâ®Béª' }6h¯<ÜUd8XTGt{ëkÊŽø_(–ë„q×cšP¹6g‰ƒÝ•îü{ïApfp†‹šC�¢µF‘òjÙéÛ¯.×é†ÔP ´sÎ<1ãµ£º37c[cCq9 6ì9о3a¯læÇÀíÈ +I7°ž°`žš²Œ¸ÔòÊ{´®ÑDº›±„r™¹é.}¦Í&âñìГÛóô׶qÔ 0轫7#½áiýÖ3Ìa}(ÚVì2—O{7¶ƒÀ„Q¢—N2¥ÿUŒ<ó„ØDŨ¥•ž?õ0 3±¤´Épp Ó–¶öBÈþƒ)1¿IÌå™?èOxBV0yØb½·õ†¥…Œn@]úòÈ°3AU队Up™Y ¥÷l¥€Œâu%ðŠ¶é-¹¾UæÕ¸•ÝÈtø“Ãýݢ׌7…Š:Í=zOÌ«82¯‚¶MÃgò¢wþK¶¬œ”�ÿ…¹NƒdðäÖð¬ÑZ¸îƒ=Fž üy¨ÒùÔä§õ¦¦:µˆ„,Þ°ÿQ¨Üó4œÑeStIÉ›z÷$æÚÓª çÑ•°]•}>Ï㟽#ç|æmGÜêôS[æbI?ϧ@õy®E,v¦B–[ fp506ó6+* J¼, ¦”ʺvw«7t«YsCNÃá¯Y.Ü] (D(ó@5-oîµ®Ç,5˜Ûˆ‰æVB ‡YðtÐŒè=-ôrÅ9#S/­¶Äd)aìXr î‰:Lý±fŠ«ÜåF<ľÀ‰ÝuF$§bª!eõ“×5(!ŠÜàü ,L¬+kÍ‚z¾§c8y÷œŒ{¦ºËÙŽ³Q§^õŸ¿©±¥·þ3,Ä3˜Ø§ä×èyœ¦î(|2ÒãŸÔÕ²MPèK:6öûÌ´¶÷´ Žã(â¯Þ¥„¸ûû-Mn"÷g:" +‘„u=i.C+zC3sœgÏš&'&l8“ïÐ>ßûýŠ_z´"“|.5mâã>§4Ñê|æŠü”Oo€?Ï=;1ùM[P™¿¿z·E£¿q2²A”BªúvjÝOŽ[V8VëŒÑN©"ÑÇ!Z?<¶T‹$Š ³:”quâ)š=!ÿçÙ ÀJ94´…?{·%¨ ïkd&¶÷|„© ‹"q`}ŠšuR[¬+}ÈgÉìœÎÛåêUô!?‡ 8­%ôêŃ=Šc'u~ZH6[É g¹Ù Ëìõ‰§d糕™«­þC£DVç`­V«Sçþ¸¼QÑnRÅ·Ac­û?·iän\¦nÊ ¬q�Ïî¬JpcJs­b«G7j¸w¹†È%yæ[ËR´ºôàð‰£¸V@î›NÇÍâoë`hè…±ÀœÇ‚BåÁ#ÉRæùOèùPïã÷á_«Æéñ`–­¤ø2ŒÌRîÜ Ö!«j†Ç¶ Rvõ S¬ˆê5Ss^GœáÖÖŸ Ç´q"¦GiŽ¸_® m  f3DÒ•áAsmÝnཔÎWðH™^R·½Á–ÍâöÇõ¥‡ÏU_¸ÊI±Ùå^õ•¶tݼ®´Ã_ *G¥Óo‹$Xå»/x{¢$V 7þ±ß{h³ˆç_s‡bµ¶ÓÑàùsTMûò¹‘ > ð6‘c…2Ïx±P/ztôç©8ý£VJw°¤@¥ÕÍÒÞP¨l­_2F>Ðdz EûFÐH2ÿy ¬æTò*Ó~˜ ÀUÍ–{yýƒÀoŸW¼#Çþ™[“8Ôfû'ì÷(3<’Ð<è0ÍÞX¨?»²`þç©Éß³[f¼®˜VÜ4rí/®~Ôц²Çç˜N–¬2ÉÛL G6B|5#×”ˆF]¢<…Šž±Ià¹Èÿ1ý÷áü]3rXˆÐÈF÷Í~6>ÓµõréÓ¹ÛÔ“Y=屩6¸Qï i‰S¾˜®`':Ý;òý£érœV·>Τ À‘t°}˜Ô#å´¼’!¾­òÊæ)AS_ÕÈ ½i0M뺣iˆ¾‚þÿ€¨ŽÓh–Š‚ó¾™v‡ÆÙ–µ·D”NŠl æôߣê«ßµ/Bo>Iß‹’P:kÅZ–<€Äžõ±3›êžpa»�TK·0¨µð«­Õaõ1ƒæ�aú'bǃrm@¡™/špwš°s…Q¡:ÏcãLãßH_ø mB?Þ<4T]©»Ãƒ;X ˜¾{"ÿôâ8ÝáâdÛž ¸%JRçQ­èó&tCæɱú)ýkk#ǸO½ýgÛçÂÓ{ç3\D—/G#ÃÿÒ ìó}Uk0òøˆ¢Ô{iÅçû6-ÕÃεv­èg3Œ¸#è•É #™Òj™�q ¡¥§™AÌÍ«û„éjŒ±a^ù>9¸¬=¬!Ê4„M=Ã"ÓšÄ=+ “Ì›Mœ/ƒðsöªOœ…èÜ[}zs/¿]|÷qj1Û¢1r8GPgh]q5QldøDǨ ô©×ÿɾÃþ½Ø,þ™CÑê©›TëcÓFŒ™ÃK.l¼ÿ{e [F¢ý%âZobq;ÁÃw÷ÚÖ'DŸïª'•+Je¶ÓÒ£+¨ÚS44$”¡»JL0®`o ¤F»ßé”+ÒÄþa¿ÚÙ9ÆÑ<;Ó>ͤ>ÿòq—Ïz¢FÊ­¼ü)ƒØ¶ÓQBbâ·x »íÐÌPZûn¾îª³ú­Ïêc¤x¶±Ôe]Íð4,VßœŠþˆqo~œáÙžªÏ^#½ ¸Esö\d™‰°’BºË¤z©Ê"¯:Ê e—‹½Í¬’qì†/qê¹èBËËaÝ,¶«Ç¿k®P‹èTÍ pz Ú®‘ÎÄäîíó^ÿ„1â,¿ä‹Ò×B…$å )ôZß(ìÙ³êÍM#O°|ÿ—qD%ö¨ØöOBgã»LÔ—Zsrûæ…2rZŠ€¼þ,F’ûèïMô€²ó_•þ«¼æŽ SÒw’ùeôßÝÏ’ØÁÑÙÐã¼PÌz,C»¸×£C8»]ç.Õóyé&ÅŒA›ZIÉ»•¤…2èC:áX‚]›©–³s¥æôþFmg‰µo—�‚媜 '|´:üEÄM€|°60 ÐÕnsºÒˆ·ƒÓß zx²G@øoKÝm†åÎoüÒÜPaß½9c–ÒÜ~ì,Â埠ߡË1ÙËûc¡ƒý¬™ „ÚÀêú«­pw°° ×?J$¸g‘蚾܀júœâ»º b¤ˆ!ŽÐÿֈ˻«ïÊ]þ qp™Ð¹Þ¸Ü„#àxl·*„ÊG7Ä‹´Õا­Ò½Ÿ‹8¨6–¥AQîíÊàÔ`ßÓÞªú›αí�ÓÔ³ôÜ5š$ôÓÅ}‰ÎAy¨­ íÊÅÙpnô07X//Á¸s²ç¡gC»õæ_ï^oƒ9>Æól6›äצ½©âŸŒ¼}hd«šÞÓߪ?¼š÷ßd«Ò"ur˜ìûõ±Dèû,žŽ PÚ“Ó¿´Wó]îHzØé—%Fð=¤T¿¼Ø-I‰à|>ãeÅ2É|LïÄ.="·²çZ¯é8j!a±êËÊo³¨‘Œmýá]­ý±'iÁ„É9&@½§›¼?«”Ú¿$¡7•bT‹F6{ï–\Yjë Õˆ|,E…oK‚û”óÖRbUÍ& VnÑ+7þå7iÚèVˆxži×d£Bà (ÙC#ìû‘_`úÇ©©>Ac˜—0ØÆ«C¼5tÌlõ¯Ü#{»óW¨lŽ$}r1?9™®q:žP´¸§éÌÄ_s·ê{üGЀ6Êa§L”°fãÄv.½ ¯]ܪvœ×?4çÆŠø�¦ƒ[ú<å^ UbëÅÄæµsß^YôôÁUø÷™wV$çÎã¹ý¾°íÕ¢e6wî×tµ7àm1±üN·Ž}XÖ‹žöTô„3hÛµT2²”Ù|ÂÀOs3¿cmf¯”Èg‡ÅcéZ¼­åIyÔ¿d‹þ/jPeŒ‹NI†þ‡“8ù¶5]"£Ç`!ŸùÔÆö$@dЧ­êÞLKrˆRÜ2 Ü EF䤱è‘gT¸€«(9Öm8wÝîØ«€´?ÓpåCϼ~ïË)ŸÝ¨‡œÇͧ)_2R)æö?_¿|»"3Êa×!§·´cÖ=ê¡ Ú›«¸R=“v^MRY Š5½³ÍÎizê3ƒP?ŽFè`âÔòñò@ ÿ4+z+×ÀÌê+m˜¶ƒUàc´cªþàÔ áœùAË,´(g§ò(ð XŒ&>í¹«žŸöèq4§Ûÿ⟡<‡Ð… ³®Õw¾éÿØù,™†Ôí+婹߸É|Éþì±íšIÒ÷I+øËŠ:ò- ¢6·ôI­N"e9ãA…ÿ3Wá¶Á¼}³qNXšïñ_`àð÷ j”;Ä,xˆ½iPXÒ2¸BÙ)u1KÛ;c"¯ë ümä+2&ý…-¥…Efs¢m¨ËqpçØ7…ß‹‘»nß[BÅÊaÀAî~vÎhh¬çèúäÛ ž$¥Öa�Õq¤ðõîKr\'ݸÇqæùËí«#üÅ>]1áiu›égíÎìfØïÛe¹‡“êÚËq¾ °Ž=96‘a¡½:~¡ 7QfìƒùŸK ù$ÔŒœŽRòëìd•¶uã!ÓÄ:‹w‰]3“éÏÿôkôx#_’•nøÇBIͨøà· ÑÂôBÎÓæÈ»]/Ö"Qˆ£±*ç‰#B…Q ¥Â*íDöQÿÿ¼¥éÛßè€áMVÜo´XÄHðûÅ .¨ÈVÞ¼Ðw¡ˆÛv$uÞv†CÀ ójý{/Öß¾0ªÅü„¾68š–ݱe #5ÿ_yDqaàM¦Û—>K_ã¢,¸X#FüweÒFåXÊ”ÍjR 꼑W¸'λFÛ—°¶,XØ|¿BŠvzc“¦ùΖü-=¡S)Nú‚’´/ó–oG>ÜLÃèîëMøDÏ †ˆÛ'Œ¦Z�þÑ çá)·™¥Ã1 Á‰+@ºÑÜ{¢hPö²‚ôÀ¡¤3iŒž-Í-ÙÃÑuí6õä®G.oãmAçäîJ›îð×ìW¿ ºy*ïj-R%( M´N—«ƒBw�í›ßÞų)ío~|\¦Øø—î*¤gE�@•‰¾¤´ðîÖGb¼¶%œ¨ yO+=j4ü§q\vÅì *|¦Šó¯Ÿ ƒÇžš0]éÏTÆÚ˱ëk—q¢ 3ßV„Rç­XSî¸Kð˜Ôš±ö#jµ*Gé~ⶱ œ†á£æI1Í;ÌxEä¥áJ‰[£ãTh*PöߎâŠCŸ£½(¾êÁ§ÓTSc|¼ ²²æ`Ík©¬nKÊ¢–ÀQ8PÝã¸Ë1ë ê~·¿Áœºø%^(¶‡}£î˜©¬Y€Êu¨é(¶+ŒFOÌo�|ô|± *1™›5Züã¾ûâ±ÀåúC`,ôÕ�øÖy®ò„fbQ±‹¡Ÿ©#ÀêDšÿðj”šöS›Œ§i^µJ©êOë]¡(oÞÉ5›Þ‚æu÷)uò·’¢4ü‘ëÑ“|Û'ç÷ÉOoo’þ;�ŽoógO^éŒÄÿè9ã­±W%Û|zRDÕm?Zúpݨer!ÏPÚ’ŠàþE;Î÷Qþ4­ÆróîáÛX^ïM0E"}“ÃþnØ”{STüՠσ¬S\Ga‚S+LËGÓË`îé…w6ÀLmì#® DÙuõžAk,N ‡v*ìë‚abß¼µœ¶ÄhB²AgÕí,f8²3¹¥õ rû¢O§ª ˜¹|ƦËI·sÇ„=éLL†¤Ž@wÌÞnÚ]ÐÊÜ—Â0‘@®0+òÇi<:Ò©F™Õë+Ïùû¢Š¢t 94w–6Ñ�+®Y©¯í°A`ûÖ↔Ké™ôx™‹ >LV%–³½ÎµsÑ$^ !~k,ɾõàTíLRaö¦õ_Ø·-5Â#ÂÕT ÂÆtCûIyEÞ¡cÔHh§ÛöUm4«‡<e‹²ûÕÎ…AÁA;Ž@i˜á°vq³8+*S%°2ÃöTAq©ÍôÕþ8øRË¥UŸaPêßñêQ;ån>„–>¡3tü«ø9V²¢ð1 ciºBÈc9(sÙ…î2òu½ &³Éƒø«Ñ3¡db•‡¥×¾`grôŸ5¶©-NWôĺ¤ ÒiãíoõM’7L§ÂŒî‚÷…×Ü_–=s"©:÷ç‚B¸ÚÙ'ù†s”Âr÷&Œ5s¯@ŠÊU¤P©êÑQ lðƒAkÚf]¢àÑö²˜¿1üÌ2M[6&·ç ³S™”¤žGÜ Ð×…÷€íbs^¯è”ä8¿2žN9hVõFä… ·~.y¬Ü›ˆEbÌÑÂìY7…8ïÐG m34×7Þoí+¤Ò3Ëc)‡~ª‚äSËA&ël·t‰Çpjþ~B¬:]]…Ã6Wñ{ ‹ÐáÒéŒó˜ª¡Ý‚f!ͱg)¹7U°;BsÁ™ªÝt¡ì¹oÞa ^¢k²°ÁÚ¥Nƒ¸o<È‘e˜¬ˆjFáPvQ3¹{ Ìiê9²ÙlIIŒ¢³*ùMb´¶—}æ2ë¤Ä¬ÿÍ”é¨HeЀ<úožh~"ƒ/*ffAî»Â YâdâÄmé1P[<�ÇaWH¦`9+B­ªùÛÏZX—+­~˜ÎœèæŒ0†U�u;ÖúA+ -•Éo45<ÐH °¢<P{Щ—2÷‘tD¹™"Ä àžÒ»-چϪku¼²ØÞ=7ªÒ©1á{:Á—bÖ�9¿'³hÖ!¿Çrì¸Â³¯ ¾ Û ìa/£J8>´ô©ÓwU#À„R¨8‹%±_:ï8פ[1sêv8á=:¶´ã„-j5È2ž½‰þ–¶~o0”¿Q0íš;n‘Q¯úOqpØS†<*%Š×OðžîÍ3I33c{ihs”ŸÍÅË[ЃíV<Ú!ÖÏJœÜÐÊŸÓ òí87¦·S-{ëN�Œúz‹+|f5ˆ2XÆZ±[5Ü”Ã;f‹‰½ºK4±ˆÄl;cuªÂö"ž“™ª[`DP£çSô¾8•Ã:äF««#ŸOªQïïl,Už‡ÕówB¿î\ÃpB¢H gGgkÒ)£ÑW|ÝB¹"5H©á¼GîrpÒìbqÜ8ÿ™ZÇ?Іý;#à‰NžÒªZaiRÂêÎîÉÙpwU¾ûþ©…7Xõå.ñûÎAÔÜÖú¿°žI|•]vÙ>ŽôObq¡[˜�·Ðã—$KªCÎ]dé>µÍéÜËÃÓ7«±Š¶‰Ñ¿ÚØEÝ.Ê„©”ës!K!r×¾Éh•kdŸ'mŽI˜§+Ì •È%½§b¬ ‰0שֶùápîN­þôÓv²jaiT1ñW’ú¢æ<˜èõµu“³ÄPB^ü iVØÆ"»-÷# 3Kí)ó¸JD½·H®ˆŽ =ç>²×?y¡¼0š@›T Hüjøóhò˜tÂÓ ×â¦~¡”k:{0™y„BÕ)x¨¿ëZ¸ê³é)AÉ7Oò}ƒÞªÝ®ã@Ç4Ž†û¼Û-Uœ(wË\²rÞÖr<4“° Õ¿ Ѩ´7Ìs_ú +–ÌÂ`vF骂š³œ ÌTEC áµþx§FÊbŽ ‰š=-÷Îó_Î œ•xZ6Ûס: ×Ùaz~*MmgF#”b\^CÈ¢ÖÐ4\%ˆl¹ÿ@0xÙCÛ~'Ãýü ´{+Gµ½�ñ6{È¡=¡JÕ§Oʈó{R®¬(Aߺî|9—f -!Az–Y}õ(†°aúDL„ŒËó^Rç>›±m“ñç^Õæé¼ô’AÜ:1uAª@˜73튢YtHòèjmç³J.e©ç±þ ^ÖßÈcq7?úþáb¹Å"pA²YTzâvÞ÷DprÚ‘QfˆXóW“‡J ¯ºŒ^�ˆ%±;N ^·bùl5î2½WŒuöÇþ¾¬óK¸Ý¨,|7G:c.´»«Oâ¡æÃþºñþŸy„Ε/úö.Ú¯4È; ž�RÌ9Ξ{ô½;Q²öû�?¥èsÐU íÐñzš-8ÒP ïqäì+íÐ÷ SzÐùX4— ‹:9ƒÉËð!lÿÅ>µ(K;ë†l!½Mý×(1¤æ™•”Oãì›”þH[®r?A¥E |¹CXœ†yæa®¤Ó´ªfmLù×SÛÀÍ”%žY’ 𘻿ÄâpM1,Ã*8%þ¬½7ÇQü}+ÃpGÈ^¯aî*`H>zÀ•5Hyr4XZü‹lõ4\Y,@2 #Mäõñ*{uãR¯tl H?HÔNëþ^õgÇ ©A׎S¤Öû#2´6WW)ÔNf_VjCb1åépg[ÛÞWÞ¬½äœá@ÑÝ ¡…B¦%¦Ä<îur¿=`ü£Ò‚þ6ÓLcÿT¢õÅ£üÍ_ÏFþÈòt’¿šé§. S›†J’±ñ ccwfü–Äz…‚i‹@A¢Ub ˜ì'³Ý0·�+§©VáæUW@s?Ü‚FŠY烫r‹g&þ:»À¹Ô‹]LÆ¢ÊzÝp«­îyÅ[ðÄïF×vÄ)1ƒîÇ8@ˆì½3§È‰Ï#_ š£-÷7æxÚ {nKsª Ü[剤¸ñ1D[þ¹óˆ½+«¸cÀC…6'|\št`¹0¯ëì z´1ÄáÁè³ÊÁ<Rn‰q¤Ç»H*… IZ™ˆà[²³ÙEÄ–ŒFãHætÞî’?‹ÄÇ+Ó^<4ePõ¬«Ã¯ý^5¥¾ð2{ч*òÐô%`›žê›¯§¿Àl¬4¨£¨9§^ܕ׈ìF—¹AtUöW¥x2;«_Z+ ø²²FìÚØtúÍ´¬óN; Wò,Ùë!]'Öx¤¦¥’UQYsÛYE†CgVh èYÍv||ð- ©¢S<ôâ~ÒlµÝ¤‘SôÂ=] ñôm ¨‡$7»¾1/•ÇF?Ž½]¨¼g—y;{òþ¢Ueßòߎ&œÙö±‹!”ýîis™ôÇÜ£ãe,¹«;îVIê…xZxá³k[ÔEƧèÞöXÓ°§ ÞãtehƒÚü=±û‹Ò㔧¿#RVŠ›ØâYëtÏ£ö§N­\üšéH¢°ÑæÁ繆—,ºá.7p>¤Pˆa¤ýüqäS„íaîï‹È©ú±DÈö‚±ßæâ•{ˆ|S5 Èä÷|*6U® *î �Xò^5ê>ТÀ@OÇ_ÃtØ õ"ƒ ÞôýñÞ¦á6vŒ-mŽ¼ÖVZš~·›ÝB3º¥”ûz(¸ë&+joN…`á%ú"œ‰búË¥¥¯Ä^ ‡¶iêɾÞå›±)ƒµ4§÷;úÖ§²�§–ÓG¯¡ó«=Ç‘¯]‡Ù‡îèû´,Ÿá�ÂÓðvñç=ÙûùŸþG_&á®FÉçR9¶žAÌ2Œz —²åÙ¤`[^<—bêÍJ˜‡3ôw6'ÆÝÜØfþÏ–½òÍù*r¿¡/4ªoiiÏ ÇâŸSÇ•‰a…r²ýJª õ¤‚Jôñ¤Œ‰@v¾” 7Ñè6Nf4@úé9+‰_0Ž߬aÑYù‚AÖºeXýsÝ´XñÅ’ 9ÐÁÔµžõ¶fQW:qèCküà‚¼u{‘óß®ý¯ùÅk:=–B!î §¦Mïµ:?¼¦Tpm!™öÄnÞ¹-ÉÐJàc½Ž¬[±½ô“Bð(Ùc‡ÑX˜íŠ\ YpÒR³Gj±7d—ל£l/Ê‹÷{ÊgªÝâí-ܶ¬¶ ?ùö<ò!ði€Æ'B¼Ì$ó€›(»}fA¬Yú‡§˜úŠ³fœ$¾ò\"ôï´yק|ûšF±ßÌ»¹]¯qÁµŽˆ¹$BëG‡¸è˜[¡ä»c³=‡ÙQš;´R,²YP¬ý8Ü9è¦_¥³býP\3C»Ÿùw –zGô!é!§AyíTÕ280 0e`Ie~È][sXxî:‘D¡—O Ôºh[/õôtLeƒ9ötN^8ÒÚÔ±"¿\‘´¿ÔmG·UÍÇ ÔÙX¨‘j;SÔ×G¢ŠIèÃp1€‚ŽN1îœÂr„Iã´S:õsŠ»ÂEèK{Aöb [½«:ÂûTY;ð?oJwjµÊ ?iŸü~Uif)|Z“ìK˜OŸž™% m”NªÕßKî7H𵑘38ZmQ÷剓™S¿5Ô#Ôöƒb›m-E¡q©šë¼ ³æ\´=qòµ,ô'N@B”ý8v † Hkgø0IÖú§ðÿ²Ò…NŸÏŠÖ»Åi ³¬aiïùR Ùa÷“7ÓŠœ]ò>QØ¥Å9[iA)ܾ>p5 5ï¡í!-‚¸µ©1ÐÞf;‰è ƒjoëÂ¥‘&¼§Pè|†2Õ˜›éY†_/Êo„Ül>ø?Œ€îÌ„¢Èå½b¯sÙÁ±j¹¸ñ<}Ì—’±±Ñé·—Oô?<Ÿ¼=º{T¼½ë|°áU¾m&tþ¢½Ç+׫Ød°–kÇZÖ6«‘»ÿ#È�ª�Bˆ¸EÚù~O1oŒÊ¤aŠµÑÞå!Ö¿únÄjŠ«”À©¥0üéóÐ<pp ÇàAËNæÒIVpN(ý]’Ñ|uŠ~ŽCW?i¬(öfQªá Ò_†ýSû/C@a\Á  z7×~¨/ðao„™·— ¯ràT­«aŒyuá«>KƒÑçj•Ïy|e 2‡ÖaŪ s‹Új|@»ìäÙU-Ľ†û×3P¦ÛöÀv×Òâ¾±FpscÅÕ,Zã™6¾ Î{:ý$8^)Ûh©ù5¯ñ†C‹ÑQ’ÕçÅú?½N.˜˜.J´UŸ©Ï£ÀŠ1¡Ð¹ûú%ï^ûC´bA†æVÈÉR?°¤cD ;Ó]i­|œ`=¨ôBr”Š©™,g,£¸XAàà«q�HÝ)QĆÙǾ>w‹YªŒ•¾Š»Ö­‘jì+»EÜé¢/m·–dAÿ/eý†V{€Z«<a>Û¾ztƒ©Æ6ƒë[ àúå;!0»Ñû9!.Zu2¶.©Ç#åA&¸üÖ´t(§ÝSThk/ÃÞ_L¹VÚ×Oøhîêg_Š8Ž3ßè3�¬`êÄv°¶œyÀÏ8,°ü¸8Þ•µ‰˜Þd†+q¾ºÄrsF»ˆ‹/3%*/)fQ­C å®Þ«w¬jÆMcú,¥ñ©odU§*ÓZmÚ,§·n\º 6OûÆ»ˆÅ¶G•XzJÙ‘7~ƒVéZÐ’›†¢VÚ«ßTlv-­-L å]÷\]£{Mëã L¥'#„0²;GÏóÀ~@‡†ð8­g¶ïÐγ¨ˆ¬Fd-ç”k¯séÊyˆÆ&Ci?UûIêÀ¤'®¹ùš¶ô2 \‡$’ƒ$Le™l‹J«¿TÅýã s'F?„MÁB«Ó˜póýÀÎÙ¢~ðS‡Ó=® þš±Ù¥=ë-Ñ×æ·²øåŸ$`“Ð×ãÆŽØaÔ)ƒŸ­$g3§­É21VûF ‰C7”oA•E6ÙE40g�ål;ªSàÀµí®h2ñe=Ñ‚S¤Â¬Ö?{uñ˜¬ü~œRè…Ä%S_þó–Ù„ÒçÂ@ÜC!_E[å 3AŒ‚M,E“³ŸgYßvã5H/ÑÈÄÔC“å×EyžÆÔ×D{ªiv£Ë}øJ¼~$Ö;&œ\êªg¥Fõ—}ݲúƒ “SC«‡Ç×ÐÖLˆRxl8GïQÞŸðy*/sLeä1®ÏO/ä²3¨¦ê%»µÝ,‡¸µD ;'4´Á ÝÑÀ6 Ìrǵ¯2S{šÍtîgöiÔœ÷®pÑßݬ‹ hºW2V)?uhŽß úóÐú½ËT›‡Z•Fž¨DÖêYÑVTèXW!ŠœÚ$[Ägý‡®¢3 ÍÍbßÑûYonzÓA`“vÌËC'żh|ÿÒ6³b²ÏÓC”Žù Y°ºßŸ­1H¯ˆ<’1}çõ ‹ÌÕô•Ó ×Y*m\1“C)É .¤'ŒjžÿèuD¡£ÞýŸºö²mæújµH~áåDIM¶6Œâ­zÿëüŸ]ûenúëv*´õ…p^¡m{Å4ýÐU´ÝîÚ÷b;…�½ö¯FWHþÃ}/–èÿ²È×/9h†‹øøå±É·aì×÷ÿJ›#ËßÏ –ëh 7?4ëò>ÒÐ@îÈR%«þIôXúé¦M6œÍÇ¿Þù‘^y’V>¨”–yý–ÑœÆÄËF¯u£56r—+wOŽJ&Ð=¦·;ó‰eÖ̬/´¿®Jâ¹Ú}ØÏ= PšyX£HdÜË jõî°]ì°%€Êa~òï´ûK¨Ò,÷õfi[±‰o¸÷ –!ó3ô¬Ø‚5f`v<Ì}Ñ¿·ð¬2jAÄk=/ävT˜/añ¦w¯üš9ËVThJC »Þ80:w$”Ú®ˆ„åº,ŸUl›­¦©éêl†ÜÙ„V—¯ ‹6kªÑŽ<w³œ•æâ‘>²ÝI}–H|ã x÷Ê’Ù]Õ&ÿC·­Å‹†‘öà .ÍØ­®¸þä %p¢}íútbBP¿ûæL¡ X3Ö»oî\Ð1™&+U ðŽáÁjuôŒ·Žk7gÀ‡Lˆ~~V:À|n¸œû. Ò¯‹g½å‘Œ@)ä{° �óx^=.­cš˜kÃ]>ɃꢜÑ"î³TÙ‘¹Œ?öó"óòx˜h^©’Þ4^$ß³Iq­åÍŽ²P]øÞ¢Ôé}2–µí :!¿¼–èˆû1XA†¦`yªH%¿p€ž†/ó nYevè àÊË.¡úNÓžœ;#ð7cà€Uü÷±ë<ôÍUhµ|,´}ÓºuØR kÓ"x²ßµLL¹³2DS²;ÉVö-°%hjmdsçA«F4â&¯[ È Þý¶Wl!“¢>ƒ‰kKµó®vÈÌc_¿°–Ù„dXÒÔ“¹'�,ªËûí»kíÓŠ=™q·á !oô¯FÌq–99ùˆå.þ�0Ðx’$B”\w[^˜Ãæ~n‚|GIñ¦sj”ÝxpÙá`U£z Ì~iwh–g‹ÄÈ=¨¯0Ho5­k™Í¥“§Ë)îEO€«vá‰!Ý‘ íñƒõQV—܈¥¦mÍ}ù\ž(öñ»hå(ºÎksq }åi8͹¹ù]Î ¼[õ{@Ê-ߊó·¸S}ì=*9ÐAmø\¡ÏKBºÙ@m¥™]Ïd^΄ŽvH’SéU×Éñ0•^µ?gtë'kTÊ4v—|ü ·–u#>WquVbGy:Bÿ^¼Q&bmß×sEqüîφž>"Ÿ·Ê ûñ—ÓÐóíœúJÛRköÿZ8íû%çð!Aö±’SËVÎî=üéÝë9,X¬†/È{ güŽ�ZH?ÈdÙ:·IEØ 8nçÈ,ª†† %ˆ±ÁŽšúÏ3Fø¯ Ù––hÇ‚hÚ¦…á‘™9Ö¢y‚ºšÕ˜Ç° EE6šy¬!kMʼnq£9…¦³G“¸ð&£¼½Méac÷0-YåœQÆ”Ž- ènȇì³UÔäº/l»¥m‚¦ÞÓùôýø]³ÑÓOXcÑt‘œhÔNŠBùAúÐÂbuÙƒf³S©‰TP²—5»Ù~ôˆ×žØ¤ö¸î„Ü“…™¥Éð|pÓ6ú(+oŸûºþO$þ ¸qdàXâÛz°ZïÙöŸ}[AÒ|Xs¡–Lhuζg"^ â&½´ªÈe”9G5 ç#ÄÅþ¬æ1)kжÇãÖ@üà Úúƒw¿é)Q¸8µÙ).€è�ÁÅä,Ží“þ'*¥±u&ˆ ú~†rÆlm&*è.˹oå¦HÃèÞÕíR*Ï9˸é@[ª=;bJml†v"J}½›¡oÄÅ(±}?Œ ĶÁ6Uú}ßëH íê]MZMý¶½¢‹ƒ¾à½_ù˜*LqJÓ-·´ =Éþ7Çòrþ0šœÊbš×Qú¾«²ÂóceÈ£æø0k @»T&ó(sïgKÕÊÖ]=–äÉlÒÏL œ”Ïôµ·üƒ”‹êÞ<cp~›2ØsfÞ¯zйA‹Hp¡øKŒ¨€½&‚a}{KÓº W³ i¦„÷¹Ÿ·˜Ë}9îë~õï!“Ô'!”·”6Wé”± ò-úû/b°’ÔÍÏ qO=ÿ ž1>kjÏ:û…´<,Èc°Dù©u)Ü©¦£Éý2Ä;ÉOUGH…þ£¡L_÷½¥[¨á_Œ!‹ø¿~©Ñp©BÎÆm݇õI¦ƒð£éÇŸä³| ÆßÃ7ªrräâ-R’&¯zêõ=gý” -8Ž”EÛ®×µ išÛJUX~àç~%0f+Ðw÷´<Ú««´Nu3Õ …<Š@ÄÔ6Œú}åY¾Ka�U›© ÊÍųãuêƒN5.Æð1œ(«³å‘AXU‚Êì'ßµÌÖ²¸sýuDßGGE;ð¾Šr–®�1‘ѹxùŠã%Yè×K’!Ö<"5”cº§a|*wHåŽ*¥vöøÜèÑ‹ûê’¹ò}Js¼_Ùì®{÷:ÑK+“|Z®Ü?SíÕ8ç©“g©ÇL2<zT:Úcî73I b©(´=iÄ{|‡áÔnêþCM+˜€°‘ÜÁ¸za¦CßM_ï:-556]öíŸ<(Ê¡LB*Ýʼæ…P˜W®õ‘czÒôIE'‚FØ÷M\Ù¼¥0!ï~î¶--RóòjY[˜î¡¬W`«rúû“=:Ã@z’š¯¿ÚP½VÑԎᥖ�YÛ=Wm‡ck>=Ò‚<CÌ•‡íÁJ¿åf„¹ÒEüí‚Éh°¤AÓ•|tFPÚÑL&ŒTÉFʲgF7N8C^ô g[9Qzp †ÞX¬aÖÇY%%í¨lLä)²ÐKU0&„&ÆUç œ§wÝ�ÙŠ#ò”»È' ‚(1 õÄ<[^Ÿ ˆ€÷Ö0œ pcÁ3T5šæŠ—C<!&^¦ÊÚh8‡çÉ FX"ë¯ÚÍVí¤0äl¨Pæ²eGJúÅüÌ�°3J]FJ·T†©«UIö…5õx§’zÁà ³n0Entz®.!}ãÃÉð1^12P¼ê뤢σry÷å¬ÓŸÎoü­ŸS?ŠÄe‚²ßSš=YUn¶\ø¤•½=HŠ c™7ô‰ýZþìóôÕ²*EéN~<8ν[Ï;¼Ï–BE°¿´í{y/>(ÃCgX¹£'Où6­ÙIlj±á¥Ó‡¼êbä©báSbQ•7Žãé4i¹Ð>½î ÑñOUUê2Y†ª2›9q ìs›©!p½‘Ìx‘Ä¥¥ËÔ`„…æaÄ´òÄÚL Ÿ&žY:ˆWÒêåvfç΋SŒ‚‘5Ølĸ…ø$±ß±rb›pÄƧyR€p:OƒG“l`5ƒ~Ó7\>¤ßø.„39yÙûöŒ‹~ñüHhl¯\{ÆWè ̦\N“w®0žWÌZwÓñ$LîóÙZ_û«¶ðw¼ƒws(²¼×‚î·–„3.Çð+Ü¡¼Ší¨7%’38=hNÏíD>øtD®¶rÿrìÆv] >i6¡·ìò^óžæË^4EÅMà'…­$öý™Q 0§t£p§¾ÃôÆÈT» ÆÏ¥Û&û‘iZèv–x„¯„.F7yú¹àíÕ)ÒúuO/'OY‹ãˆd í½qÚŸëVÓù¥:˜B¨¡íqÑE_•b¥©^¦�kk¼9ÐS‰ì44Š¼?MXDEw¾Ìë7éÈØú•òÀ™*ÅùÉ؃òo/GdQm—ª'¶4òºÙöNìny§Ø Ýmçvi×&žsÎ*†ç­ B?ɘÆÞ&Cÿ; :‡c‹Î¢,ú8󭕈taéغèøä‹®ô¤Þ ¤Ç0žÍè�V¦ÿ¸böãRî9?¯<çZf¥Ït>…Ó»§¿nQ+Q1›tþ¾²yW?¬ñá±ÊÖäF¿¹ƒäWÖm, ŠkçI²Í‘Ÿª»§iæ›4AGË­°÷°XÈõòœ—‰J¡·EGím ÒH¨Ì6^Ä2±ümÖœ•qææ•8QYݤ¶¦¬Ÿ{¦xÇ£¥MªhÅUNȘ[À˜ã:§3žÌÓ\o9>ôŠ\Üs}»û“·Tì ÷02êÐÊN |ë˜d©=\†jË¿¦8eî{œÐ<}йQí,èYOx@Š¾y­ê±Øˆ!oÿ 0S…飯vãíRztìV)·V)eì ÎŒ³ÙÄ€•èl<¯�íl´§¯ o3¢{iuX[V5šÛò˜Aù¶ <0ÂÙ¨û"Ei'F}=$„&Ú¦{êÈ9*?zíRÄ@Ã�z¹Üöf7Œ8ý>ršN¢Jß\« ìfèŒRÛDãLÏ_i]™nJÞHO<°GŽ²8ŽŒE'KQtså/6$·L{`£ƒ¬§QÃà!ÁvSPÖ¶ø® �‰0åÒBáÄ"æE¯(¬2ñ(öï[<>PÛýi)DZuìÍ,’µ+%ÆÁIØCz“À¾ FîŽ_aÇP57¸r·÷:µ8Â0R5vò,0Æ Fõ 9í¤Œ¯QäÿB;¦€R—:ªŸ¶‡Î¶ÇT…]yàmÈ"”þíõÛ$wS…ñfamž÷½¥½×W_ ˆŠ®å#ãþ¥W›ËŒ…Š¥&xìau"ý±=—d¡?Ö¸ÉzrU &Ü|ØÊIôªqjZyŠ¦<7ßžèÍ +S錈Œ¬’´rtt+YÇÀ=6uŠ¬‚S¡¸íy4x÷MJB"Æ•=Ä_‡r§0ƒq¹1"Îí§©0âýëoF1QeÜ“zŒkš¿¶ZOŸEfÂã/þBœÅqg ±lâõyµ„ÒT [Ök2«ãw^¹ŽÀ\ C+4ˆ¥f]ŽûÉJÓ²r~‰¹I2ß:<LÑõ¦œñËIݳÔÜéjØbž” ®äݼKO DLêÙ�:£ôV€ `ƒ–Òçn{{ľÌð1,BÉ»˜LuöŠ•~ÃS�E DGj ðsíõl*¸ æ»Ô‘bºãepJ(ëýüòð[âAc ¸g —°ñÅfÀÀ~ßn>WÛ¾¥”àŒ¼gÐ/eÕð+ÁÆ·²u8Xã»+>~ZÅŽ+(貜(ô4ïŽ'Šg,ˆeàOvñ’ªXIôSLß%?µAÉÊ 2¡ßÝJ‡{dl€÷kÿÒrs­5JÓ˜i@¸ ?/ ™5ØkÚ¦ÄNs¤ØzúXÓÒ4“ð g¡Ø˜S¨£`±;Nâw«Iå ¶B‰…豂3[dƒRb‹Ð¡¹ ç“*J¹0š‡'ÈÝ•gVÀ² ÛI‰3¶¾Eº|üXéÚЈI’2¨¦ÅãnÛêÖx‹$@¿*×ïdR £ß·””“E—n‰ëýF{wnûæyûÔÙþ Ј­3Z8( &«•iá$ ×ç™Zê25–ªeg”YEóPLsb!Çõ˾(¶w#w#&�ºÚƜևáÒQ¢±½§pK_RÜ»˜åGËÉü_pMÇy=ý0ŒoõÙPÚŸU~‘çP—7£¥§u”í{ß=–ýŒqßzWÅ+ßkcXãˆ843™Îõh·áÙ /H:u¤cñ·¯žûOX˜îîöª+L™Å2ñÆs× ÔyO'ŠÿïÍijÍb¢ÂyÈ;ÊÏÑÌ]Ë*už¾â/r‚<]ùzRÒ1ÒüÀ©E·tlw¶Òc¦ð£WÔ‘ÎËDUÙfã©ÊJW´ÖZ,h¦á¸0¬â±Š¯k%£²±…µ¦uøŽøMÒÇ5IsÓ¶£Èì½õôö»^dãÄ¡ûGv1Ð߸ZYbØ4l‡K3ÕWöóì\°$µÊœeý>B;¤7''×ñ–Šf¾¾i[õù¯<YY•ô6y¤ó§­·1JÿSwG›kà<€’à®TƱJ¦ è�p+ÊöªÍÎCÒ©!š2¢þ_Æ©&¥RÿcAßØBa9—d9]ZíPÝQz³F6%jû2›ƒ«:¸C5t'ªe/ó?r¬F¶U¾¢˜š­IÚ²­SoÐ%0hŒêQ™¸ãÛÔ‹f¢€b§šº�Âãpÿîêw.O}¿ÇEƒlsñº)fVjÅo¡—xZ¸ [HU+”_/Ûʧ ߺ©áÅ9ië 9†cÞYûƒÞalkCŽôTÁ]‡2È¿{�ˆ Ý|fÃ:ët•õ³ªhGˆŒý˜¶;ʱ+«VÇÖo½m„Ÿjü½}ýNуú•› g¼~jzÜ…Õ?Žƒ™Cáà9÷aLù_èÜÿW¤’¾ÿFž|Wˆ-4k§c­Ææv _à†ÁÚï¦ ðEfÁq9ØB”Cè„ã°1îŽãp¹ê¿‘x2š/$^ŸSì#ýÃêÆʘ*�ÖZîU`KMôuM³+UA€|KO7~þ«}T?ô–òƒªvFëÊGž•¶¬Š ßiprönŒµr(çÜsøƒCg{8Ú#Â]®eåqƉ0» ( FU&ó$û<(Þ††•Zýx®ýFÁ¨kÿÔšÄB+룽¾‚ )tÇ•Ñ°™aL²lL^•ËÉdpÜSÃâAþ?š¡Ç E‘¬ÝˆÒ%öôÈàfÌ|=kñŠ]‘úÆ´ËŠ ÛYç>zHB�O%–~íq¦²ET›ÚŒEaú¦á\£©Îø´¶Ù Ô¸,ú‘=N¶ Ç(ü²ÅÀ­0e¶rš‚äe ‘~r&›¨ndk‘�h¢ÙéAŠßÿn®ü—jÊ›oוcU½þRa½Q¹ñe”º±Á ü§¼'-ĘyI‚ü È‰˜¥ø)…†Õ·†êßiL¬l¯9išaB¼o=ª Ï0E¬Ó¦ÁwQ2Oð2jÍ#Ãu@ŠN#÷S[„\Иš´tS{âMÚbúKs(ÜÀCDè £g‚zýä ‚D²·è¥Oœ+5ª<8QÈŽ:+S°ãºå?ÓŸ!ãË5o|ãd¬XÑ.N‡òpmZ65ëýáb™Fñâ))6ѾÚNEç mw‰*±r96¢3È/VjÒ—›5#ÝÌ~máGçž1ÝjÆŠ$ÈB‰‚MUxkœ1× ÛøÎ Ø@ý/_š¾ÅžyÏÙÑ[oöžÍÅ3Þž@ß6÷Ên˜¸âV.Áí˜ú`‡¬N4 Jêi÷Ÿ7ŠÒžïlPAß·Ã⌌~;†¦£ßäÊ…¡ùö=h;—=¬Q÷ÎFô‡êö^¥kÙ2™ÁØ&Ø=nضFÓ²C`�^[kô(º{•79é Yu<JQ)I+ƒ´ÝxÜ~•åVŠ»ñ6û²Ä¤Ðôl¸QkiÚEÁˆ Ûúÿ‡F­/‹Å0ÜyÉ<ˆ‹@]‘»ÊÝ»ú/#³þÛ]O÷ÎÞàXÌ3±]ÎJº<œ›YuOÿóF©¼[PihHÒ¼!58=R~'—Q‡=m”úìAŒOæÛ ’ö×^Ñm»^Ë'Ã=#„ÏæÜ¡´&#6ÈoÎ3QgñMfœ!ì0ûý=¯‚…´:­¨KŸtGŒª¤}±¡¯—·gs#Qíê0’TŠU¡7³Úäúe¯^ƒ‡Ä6*‹ÍÓˆf_ÆÀ¿ÈX_Ž°ïtäËRßT»N´êç¶f=åobdUžù€¹ïK‡âù¯'°Á­�èëiÃîµ]}f­C‹S¿‡¥-c'Éu^êZiYqI{F‘+Ó¹ý—Z5É]K'f-¸Â§Ê¡¶ƒí÷Ù²ð¨öø C²e¡Œ«g9wÌÅ$oæÝ1}Íé`<Xw[N€ŽÞ†Õ(ès­'•óäýÚ.²–uGKì³s: ;*"?(”©B E4é\þŸ·ºCêCK¨»\{Zo‹šgÝŒ¼ 9ÍÀðé�]d}aîd&°‹…¦žJjîV?Ï·\˜›:sF²\<31€‹ רSFw¹Ð:ãIŸü+O÷‰ÕåZJ)f›Ì…©Inç5v…6êÝyHT$ðg$(§ŸJÕEsYzœô'nìh¸ Ó(·°›¸•fêÓ,1ª3…puôXÃù“÷®8# PHeûko²*ò”Œt--˜nñ¼M6PÚÁ`IZ¯\{®0FmÛ…îuÕüõ¸ôÍÝ/¬CÁ³î‚Í;*²•ó`÷8õìD+¤„mwî:ÖöÕ ügj^ì ŸYþ³ Òfï„876"AC÷ÑÊØŠr¦Gœ~Âh5;P‰ ~rÒXM} êŸõŠÊÑóbd“J°Ë«6GFFÐrHë¶Ù3›÷‘BAâÍ;Ä.’EzH³•"íZ±}rk¾!åÁÏÌï:\èüûaèƒè$ÃD•ö5€-f\F¶Ê“ÝžGù¼¯àÆ“ÜìFcMN™JM?v{/“hŽPÙÚ.¶Ë ÈïõQmÌò>D¯‡<_Üy†½; °êåèZ™Mk­e?Z6øbŸ5½º“Ú¦±oF)¤@ï;oÜb|Õô€øm eEæ©Ÿ% K‚×Ö·žzCæq”%k8eåà!L¹O Œ™•²‡­ƒ°M×þpÝM×Æ’&™õú6¹Õ$DŒ i驯ñá4÷%Åw`’/¨šh2TÙO5Ú·³Øé»|éÔ—1g5æ=bsátÝkeÎ×2Lh U09wË£Œ…þBsß9×’L„Õ:O)匭:î”2!³H¥¥<è8vîxÜžéùg—ZM -z­¸“¡Œƒ®50Ûó[ó0Úk¸v–ù"ôÙmµ°ZÛh-¡&¢·+SÕŸVÝx\¾pZ¾<ñ¤ŠnN:áUZK–Þø*-»8( -f-ËãŽ%ðQ°P;ú¥•cç2µ´¢ôÅøZé ³`v·-öºdª*3…ML’¢²¿ò¯ln£ÿË}sðÜدÑçlÉ{`ô³S·YBÎoý›ózä$~ÂÊ´–)å£ÐÑ([žÊZ›SÖLjÚ°Gã¼úÈ5uÓ— ±©;'t [ZU!X¾ó…ïÿòÛ8T;ÄÏ]¤ßX²k¿Œ"ŽYäž…ÅÏ&½/’ÔXþ_‰f\¡þš¹^^"|/`P¶´£Ýb†§O¬#¿Òиl³U庤‚àÖùDk]ë @ü&÷ú½K•«ðE§ ÌWSÛOSÓ'•ŠWM¬~e»šy$U`ä‚ݎ̘JÉÔzéìº*¯;=$Uè¡, r´2pxÒ®,6Í©R¢›׸ÅnDë-[—& ÊÝEy½Ç¾¯·ÝJóº,™§/7N�ÅGñ¡hŸ)õEsÛ|š¿sSso‚!*àß7F?Dhx‘ǵàÒ#+ÀÈKÈ NJ)Ï#mÎñ½bä¥öãjþ#*êûŠ²|MèीRY¥©7”ñ:úŠÆŒ¥âËÛCªà›ùì¥E¼mêÀÔŸ†¥(65;»?5ŒU‹°0¿0~¥u‰òú–¾é™c˜»š/ "ªzÓ:­ÆMYÉ(&Å?È(Z˜“0(\Þ/^j "¤ÄùANG[ Ÿ¤¥>]= ·oÆñUæûnÌôîUmá>¨_ήA|þâÓH^˜þ;¶õÇÍñ_y«ƒ%ÐÚ>g§A®0’ø´±š©çÝ›cX 4€»E’y úàKMyó¡±<AT±,\c䓤dUÓ%xÜ-Hóõ£¬‚6¢~Õs/gt2D ÞØ GeÝW`Ê…xh™tí2ßc z%>ûÆ.*=MfÕÀ[p¶ó›ˆ›ÓiM‰Ç À}ZzéÉ5ŒþHà m•C\¥&3¦¨{Q`* }j:mËéD'ǧÎÚìíYµ‘ê‡H4BßR7Öu*ƒxº8E`NjöC•'ÊJ‘tvº‹¶VK7K=(ßãMMqj¶ÂÕ•¡ëðS”âoµQQÑ«ÇtÛ8ñºbªú)b³C7FØBN·±Œy´/ç½*ež ¯ÏxçÂN% ²Ž:J(U¬¯'·öpF~Çþ„ö°ÅNg ‘�/‚ùˆÊ€{.üÚSÍjWDìbfA³úZî ¸ynWÈ@ïÅ$lÕœ³¨×©"Ë·HcÓ(¤53[ß”oFIß-“| <ÖäozÚ:‰M$#<è’¡“CO°­¾ú•Ñ›ï¿g“¦55x¦£=‡R£—cؽ/9Zš¶ñ&/¹ÅW\5¨Ë˜cKß~¯ô±—û{Yî ¶£ï0Xˆ´FøÊñ  è…¸U3†@£vÚ¦ó~Ø£DbÑÛWp·œ �þ‹±¥åÇ–Ü*.'*y…qÚ0yŒf ¿ÌÒ“( ]µÀ¡‘*ËV^9@=ºFŸke@YÅöSV1j_­íT? ÌÞÑØ»Ñ^ö3GÎ4ô”:�.±¨Õ¹øtœèÿâºà¥B$‡èrú¬¼g.\^U-HãŒ6Ï⑅㵉ž;6¼ýÈu‹ŒÛ³î`Š< J—,An²‡êdëfRφSΞ-7¸®ó†°Êñ cŽáš‘Ñ*rãVgi㙘Z_Kxæ€V7‘í¥ ÒëhZ*(éÏ3–Š…;˱Þ梼o¹Íjeþ =͘ ¡v8Óá·Š ­0iëí (o'Î"½ËrÛJCËB’§DÚÍæpæÂd ¯0dˆªòÙcŽ}]ƒþ¼o$Ý.Š^6.ý*==2Í€&ú£;vå°X1¦ˆÛ„Œ«çï ZOïñBº? íOÄ Ô›%ç\•`¶QLŠzc{'lï¦åJÉN‡&ž^ø„u7j³ŸÞ8Ê@„‡;“ëÑFÈœfÄ-N)¥ÂŠ=sP¯OÏÌÐQú†…¾<и(M«CÒz sdµmOB̯¡Û)‹¼(vT&æ ”†ÉqÑeÚ©#»8gÐG³c”©í›Î8ç¾",¥ñêH̸ÑÏÚÛ+#@pþñ¸Õ”NçƒM“Àêˆk=;*>®—SÛ(Ưh¤ùÊ 2CÍ­±¾(,A‘Æ<L Ø°¤Ý€Øü……µ%E³w%_œf®e%²p‡œê³Z£—rØçÓq±z7†{e<V€õÑ•ã>ü?Æ´2[15aøÍýOµ£X¶º »%$˜Çc‡œK³ª{–Š Œ„üO뵤gëJ† ¹§¥Þ“ aaãS¥à$Rÿ©É¡6ßý»bù%ÐaL' /(rˆyøG JÙÓŸp¢å¥çkO§d °³#; äïÁ>²¶,ÿ.¶¿’@eîwwW=?<n–ñÌÞ¨‘ó3[ûŸ´”©Ð+]n*”žîäæÓ´ió ÍuÝä‚)©|»ï³Ü4»!—´_1Óœ 5h>²kÌ„ôŽÏXDµ\~Sõoj*hß5oÎ3ö8àVžaÁnjÿ^ß^¶o©§ÿÑ€8|<zÓeÁM‹‡ÎöÿÇF×^ÑGWeÞü<cÎdTt´.Õâ€í-¹9u‰þÑlå•! °Ea‰Ï¹ÐRWú²vHWÕÙKîW•çGðPk¤=þ®M±qè¦|ß)ÓkþÔ€ÿàK•x8~v `‹úêÝR%‘šÐ6kæLôÿïYÔ—î4‘Œ¨¥uÙQpÍ®ƒaMÄ`i‚rÏÖ^>Ð�Qs¸Hĉ² 9€±ª[>jùÑšúáš‘%H�¡þüœ‹Yž'h(¶@0‘ªÕ/gy"$ †Y%| 5Å™šŽóé;+‰œBz̳p9Ÿ–MÛmù<ÒKëJ:Mõ|d‚¶Í¸<ʨ V[Y¼Q0ÐÌÞàWr+EnÇ·;H±T'$ÍÙBðP{µ,°stõ²p}úOI„Ì1c¸IbqǬ¢|TRe{e”Lk2ÇUþè/û‚ÕˆÏe.Šà)Ð8¤}Õ Ò}çfÏÿÐ'òÙ‘Ÿ2Ê÷ë¯õG¡“”ª÷ÞíàDúÆaáÂk!³yáY]'ŒÓÓŠJ‘X;C©~ò1ŒÔ?#Ž¥rOõLi-AKƒPrj×Ú¦c|ëʽ;ú¿Ä“þ(ØƱMã ÿTÈ,›Ou/nG¦§sƒ‚ãÆTå»ÇJäúC< ¡õgQ…BmŸç â6Øœ=gà ¢Ýð1^ƒ�ç•ÓDdϳí¼ÓÏYáè€ 3%Gœ…lù>]Í¿HÔG}ßÕ'Ì$ú¿åÌß+ä9[$³¢Ç#´~"8y¶Ó€ªÏhaÑú@KXÈ?ÏGk`¢Tæ11wæ:À€þÓÏp(·T¹n®¥ÌÛÚ¦Hþõ÷aŠ¯Œ•§HGl¤“¶JëMH8½£NWëÉ¡|“;Z;ŽcÁÛ¯ksªiÏÊœÇ2ðå0¡Ü§Ž‘z…þÁš½À^æOÙÞžÓ¦È|˜9Uϧ2ˆzÍÏxÀj|ð@ÐZ`£”Eì.nª‘?äˆÙ„þ+ ªMï¥T°:‚ðµñ¬™žù¨ –6e?¥¬ÕâaÁXPË*Õ¨1?ØáØFh̯†wiZ0N/2È“¼ëí‹(kpªaP'f­þ„=qG]iÔÐfx-GõÕ£ìêã´«¿ì}²æ÷“3 }‰Vp—0¥±}ehE£j²@"¾+ 4³UÒÛ$(úÎÓÏn;`LÞ°B3–~QíÜ(â …RS­C·(ªhÿôõ~~sœYëƒûÄ×ÖÈuš+-é/ÛbG»÷ж];¹Mÿ³´\ù:Ñ|¢}™¡ø b]ÈÁ×Tkeþ1Çð%q’¯Ö†&Ȧp³ìøŠg‹óÅ~:9‰¬×@T˜'¹Ù�Þ8I}'+ûùÌ÷ðþo#ˆ$ù~¾0Ó›(’„›ó~–>™éN(…ôEëw‘Ñ2ñ»0¤Jááj§ëåZÀ®ž×ð¢ÂèJ0‚­—)Ò÷ƒƒžsjäî—LJJÏ­•çyÇ‘þ)Û/ÅðüXǬR«Úµ&<{—Ð\ï9|hO«¬âlå³=Å;þ¦0ÒÕH˶-عJyæEV¶¼ï}9¶8ô¦¼17¯G‹gßý>\·âˆÍ# î ?¬4 ’²p}YQ'&0ßXÁkÚ‡Ðqsi×Ï>_y²ÂFÒ9ŒÚƒ ‚‘ž4ÓxDâÏõ _jfê§-˜:zz ë5w‡ÏÖòfœ†ƒ2Â:ÒÒê¡ÛL{£Õ”ØOÞö2@3Ih{‘˜yš­…7?Ò²ˆœ4CæOWÝYÛ6á®nlÒo[O™[–×+xk¨p|¡e»«Mž�ÐÛºEÇÝŽýmpBÔÖ~E:.Öß=vJ'è§A³:Š«åá`ˆþ¤àâÔZt‚õºzu9ðkÄŽ-$Uâ¶Ü>…à³ÜókÍ3†U›ìÇÒ½Œ7¼dS%ª­ƒ¤n<©x&Á»ŽÙºè2žywù½½âñ@EÝ°!·qõ¬x‘ùàÄT7:ìVd&$pÞõONEæ+˜ §€Œg±ÌN²¹œT:*s¢Ä@|ïô‚Wì}|µ“MN ]jlaŒªg5t¡Q2,N”Æhä{OM®Õº˜uÀ‘7nÒ”RéwŠ0 jdÛ¯å™ýÎS,.˜™õµ§Y"j§“G´øÂIO´”Ö-T…”FÇuï•2{ãCcdÇ•ìÞÕ5™0÷ žé9lwm‘Ï‹jueâT›·í•L<ý]!q¦ÉO>:¨CEËFûÂ|ÐíggÃIÛÑv´ÑžáÞÔ·ŠÆ°]ì˜E‹2Ô ÅÛ N_Æ<qÉXûŠ‚’ߥ§Ã6â†Î1Õ!;—8”´IµyBC¥H[ww¡P…MÝ+CYýXè ?ÿz†ÍuoÕ*Nÿ{üˆÒÂç/ ØE,«öŠHUP¢¦ñ)¯3‰äåà »Þ+I°„®Š[2ŠþÌ•Ô`÷p¹T2¯]bËÐÇÇÚ¹h¬¢Õï¡<‡k1ïʺ±ÞN¨³•/W¬KÉ8F+ÜtUÎáÚÉ?ž6ÇýAùÞ¾y®8£…ÁðEﲪ{m$p›ÓSEËò=¾Üô¯qGÜ°ž}&ºŠbûáVªÈ¿@FZ…ƒ_pg(-ànVQ ß;'´a”zœºÚÆü?ßÔTîýî‘Š]¦ÒË‚ Õ.I«îÉ1<ÊGlzõ4Sóß+¤žÓ«÷PN kÎó£_Z4WeÀ+E]ì‡ÎhìíÚîøÖsë_>™MÇ™¯í öB¥£!‡Ìöž£»W ÈIºô«`qGÕUŽ·bc™ °*"AËÕ‚Xo¨n£CP´öXê?G©J}ÐAäýÞú×Ù‡-[}üQ|Bµí¨á,ÀûCUðn›§n»V¡13,pºª.Öé*U:Ö–PáÕ¼=Pä›_4¼rܪoµ?SÝ—Öb1· Iqøwy¿u%±‹%܉õi… BO¶=Ïÿ¦;–ej²%tuý“Y9ÈÄhþ»:â4lÍÄX�¸‘Wn‡þ¢ÿr™YüçÇtÖSè{= eŸ±u¼-…¢G?l¤…©¿ùvÞ;lnè6Ð-š‹çNDËñxRY`„C¾}|yGy4dž¥À,6Š‰6ŸûþÊHs¤µÝÌP¨—ôÃnÆðs+ z¦„+SåZIWñ"¦ÌÔ~UÈ:®üHÃO†ÂwÛz1:kSëPËtu˜®Ý»pB(yæÛ Ä\dŵUõÿìªÈYÜWú ëk×ö¦û{SX%NùQ:¾¢Øâä!àjÁg¡]‹¢×òX¶%ªBŸà†–c$Ý_ÏFH¶öÚÛÄðGa€0ww6Eœ$ˆ§÷)Ç#ý¯m´ý×QYæMžx¤±™ Z…£ÓÔÄ-ô:¯—ʱ3yÃmMŸÜe%Ýãã¼ó§¢/-7K mû‡û@‹¿I+éhqdOdv£P±8RÏåt T84³‚¶ùö€/²†¶5ÍQÊRV¬1/·-%0b®Ð©}ïÛcpQ8/¦JõÆa«ÌíL¸½XõÁ|ÝÕœ]TÀ°:$ܲ$£‚w \Þt3Œüΰ‘¡"@wʹ²ñÞC¤n¦½/1¾òÄíkrÛÌ´÷Ló$¦bòJÿŸ—ù¿7êL¿ïÛÄ•ïæAÛWAôU;áÝÃpaë4£9# ì{óÓï‰õŽŒfEßxh‹=zÝòÐùÕ™:K÷uOyŽµµ©ú»e} « n€ 0³•y´—G3Öb97)ùAÌ*ËPª‰ŠÂ†¼R2ÁÄ;W¶þ^Ä%I…Îÿ‰Ü„šTS%€°Y¶ÖXåÑʺ@·FG÷ŠÂ:OÃ]¦RêB‰Ê¦¦Ñ²³…ÑF¶/£—‡¦ÖÜ/JŒÂ׌ÖXºh‹µÐcZÄX­³Œ´LBJ ø.<I»D”¿Ôñõü¬”T?Sàêñ…íë­àÕíç}K!§˜æÕòñ&soçF¶ï°ÕOÆUåJfäÒ¶ ²æÓq—r}Tƒ …/à®n»‚–ŽÏI4Þ8¥ºL«Y¬S/‘=XyKÿ\e~k7þÅÅ—vÑÐF߬¶âF˜IõÜ+À&?ŸT Xœ�­! åšþÆ21L$Ô*8LâUÊ"&7=–C»8I¹„>pèB{Ê`zßÍ61,%µ¥B¤Öá«Õ¨ûvaɱ­_à[/rÕ!¿0ß´²ï{Ž-à‚J%÷åjSÞúdY0°6›aíìÕ…/ðÖ³x%AJ£¢F N@§ÖP0b='.œCQ{i}ˆá£,+ÎÃUÿ„Ũ Döî%°á™óûÁœ# Þ#´/4Ý^§Þybjá» y»�ÙkÝd™×Œ`ÐÝæ=êåEeéƒih½_”—Xý¢ŠÝ³÷€8˜M!¡úî‹Kyrë•„ OÉJâù»U…–U+LK·—_“¬Ê½8Zg´åò ¯-$»–VÜ7 F ƒÀíÿ·Û-çØѹQÔÙîèþVï;O –nÜìx£ô®´ÁE6ÇÝîÛ«?TÌ ø‚Ù\¯{´BŠ +òðo tO+ÞGÏu•#O-¡0Œn¦5Vl¬Ú�mpÕ9–EûL�^ÕdÃÔ Å·h=YdÁ´©Ñ¦y?;{EVíÃs.Ñ>(éŽÉVƒ†J_+Ý)Ï´7w9žÆ¡{ÀZ~ Ô~œQVIüÞ;a$ü—ªÁ®ñʈnÊ[§==ZDzȌŠ&Ê©ÙâÑ«•›”È™¿³ÝÐæŽ÷;%2…<Ô8ÕÓuÖ¡e½ÛM »f ’387vD¡çCÂãa‰Çý§'¨†£Dæ1ÆÅ÷6û’\²Ù¶7ºèÔê€à:wÛÁšÑ!2víâ™ÿNÅ;ŠC¿‚„“ÒRÑcT¼�G51Ì¡©5 úŒê"÷hÐe¬%|�¨Ìzæ‰íòlòc‰±;-¸ä[ëFþ›aø@¼‡„ †S,΂¥jh,Nš9tôAý„ó»©=u”ÃÐyy¡é–‡ø’¼Ì|“Â<Ø^*–{v„ùµtƒÇ€·uܾ?»¨æ±Ä}¥OÜŒ8¥»5}.o›hÓ ©:Ü j¬<m‘ÜK=ÃIüÔ*Øë$AvV¡¸Š;¤ÇæXë#­ç/åÛW•¶ƒ!œ)h 8NÇ ŽØ¯ÎÌ�S®ŠzN¶þæí¹^´)·ûúÖ±%ÍnÆ^TÈñÒ{ƒlŒG:ºÎT¾ø šý;ŠŽä#oX;"/Ì݇6obƒ‰ÄsƒÕ>Y–ê}]›7Žc‡æ!Ú›ÚþõJï-üÇm¸ÚŽ=³¬„Æ#1 »x c5yANi1²¬*2t¬ÀYÁg ¤;¶<©GO8ìhMöWϹ¹¦~PŒaŠ¦ýüäXv\•åY¿%š¯^kųåW[Ù–äµù³r<‰Ãf±ÚLû¶B£ˆmÈgíW^í|3ÍÓ4ô˜qGç')zE÷À(eì+çe¡ÍsÞ9¬#­éMË6bµ`–.=žU[÷6*Ê;ή… ¼¦Ç6O•C;5r‘ãýœö„ýÔÙPI£w¦£$k¥Ò‡×ô²Ý<­¾ÂàŒÜógÔð€µ)V(Hhmxü‰×Þ×uÚ¹¹Á]§<ëÞõ8ë¯/„Ú×ÇsÄW îvëZ% ëÒ©—k˜°Ï dÛýñµý3¼òx½Öy.óW5d¬ßºÒGö°šÅ¢HS/¾å|ŽÜ‘›uSI‚nzZ;Éaö;»ã$ú™ÖGa:ϦGiø›ÚO¾#¬gE¯Œþ¸Yh†«ê>F=Æ«Äè‚ €Dð>ºI £ÐÖJQ*cîäÓÊ£Æ|K|Ó/7é~yæù0�6pë *eu*Íæð¡ïÕϤBKÅ»2hð£µÂHHÆúËÝ]-æ•úºbÜÆÅê|(áušQÍî;:Ëñ@Km¶¢(`kŒîËAÄ+rTEQ‘öƧ¥Ëµ*`õöjŠ¾þëaøËrß|òж§hß´ÊO¿õ-øú!;<<iÅT½Ï<¨>5D ôu¦{.ò!¿ÙÔ+çF²¿Œ=Åé°Ó\!ÛúÊf@ é—}À¶F¥Ò¢Roß!‡Ÿ²Ÿk¡‰æ¡pDàxïÒê`i/¦£zÇ2Çz¡ÆV `îO»¢ Œ\_;:(ôAðº¹Gf¯ž(Ǿ~67%Ç¡ ªQÓLŒ™ÿ·Ë0Y%{mwà yüú'j³ËxM!÷&Ú•áBXIõ]P]TLʤþHqWþåbË:ÞnŒ]zU_‰-×öYõVkÒLÉ¡[U\ú3by¤TÆŽñD©ÅFÆ'ij›FÒ?ˆ¥ÓNcÞñüAù1Ä‚Ü{Ñáºóœm–ºS{;ÿúy‚ùJõRpäAÞŸ-Âyl{Ïqœ’"ÚøB_嶌»ºÿ7t b ¥ˆCüQÝêQ…,=LMŠ[à쯂’ÑjD7ür8²•¼4 xßã !3ßµ´L¦ùoà¼,ªÔl€‚›>ƒf¬Íá‹ç䶭[³”ÿ æ»eÞHW%–šV&v]¢ éë’Ù@«ÁëW­”p aK¨8¤°›mZç6ˆÔ˜A zÝÖLÂ‡Í ’ÑF¸Ö“Üï›]hÙ•¡v´6SâÔ"ÚÃÖùµ¦‘ƒ„"jøxxÊ]MÃé¾K”øò>ô}ö«É½Ás²Jœß"ÚÔûù0,öõ>Ô%)<k Œ¢(ˆyáNeZvÂð¬ZÆ^JÅ–ÆlJZ9p|ñ*G‰¤(Òöu•O½*“0Z‰Rg2KŽ( ‡¶åÉ¢ ¬w`ì]F+?pCx¯ájª€D–'§£ào¤KæžÇKžN'Šˆ±sL-„عy÷D©¬ù¦èY¸ fk Þ!M_8é®Kˆ7¼Ú�¾f Oæuuâ„ájÎYŠbg1OÎh Û„í%^Óë´à+·rØSŠ÷^{O…¡LB6GX=V[ -LGè,ô1-#%æÝþ°xc•ßöGm¶R¾ÄåÖ6T³Ì³:Z+8c“Ò ÕG"‘xwNXE+lS\æ’îrç5KNTü×·éMÆÞÕ׌*'d¬3æºöõú¾|é( ›Æ÷òÅ$[ÃEñ£ãÐí‡AK¨¬iÙN„¾Êtj×Ò—‰“QG‘Ë…VJº· t0ŽµT(‚åèì+Û\¤aøÈP0ñÅÚYì•JŽj§°“XÖ;€èzbô¬öˆ½àkhßØÒê†~#@9‰£ò›s§7u‰T`pße0èš<@–ш3iÃ4aéÀ.A7lD÷{;,óeèîi×WÉÊÖ„`ðX”ih€Á5«,Q&K!z%ðòÀ†! c“dI† ¥´µ%a&Ùíþž Th+M(£ößâäB4ç5cH˳¯ƒ–�½rÐÒòòâšë´PÞ"»·œÆÇ?ÀZòÒŸ]Á"j†ÔAíÅdÀaŸóËï]†+?ÊziPôº¸ahÖZ]Ú åb¦ÐœTèê½`®Gz<‰¨;¼‡AÞÎÞPV c­Lõ«Õ¯ÏÜÞ£¬p±:eïB%®íCòâ8­Ú8S1®ü±#gñ×"¿C‚’•4ÈíÈÚ²ûÔ÷¬0’ß7¼?Ïšju ÿDð/W7+ }ï)Hj@ü*o¬geÂãvÄh´ŽO.6Ý•öº™‡|Œˆ '(îtŒgAÚÞf¿ÔìÅjríy+ß;Î-ü25Ó³yªvï,_Ý”Ë+w~q²=*¶ïKÊŸöž©±¤2ÓÍ*8Ò={Ï%ÌxDY{§?ÞC[:'dÎIp8cTf1Å/X@ ÎíU\ ý61å&› R­9R¶ù©IN†iÔ5ò(/}aUf‡€i™ŸU0 ÀÔmrí¤ÿç-á™èŸcçið¿ˆD~ãR<}¡”ͳdž„“‡Ý‡N¨± }>WK˜[äNú6JTŽpPbï×S㓯ÞÔõÜYD–”ÛtêPf:bÅÃúF¥¨¦?•ðƒ¸}Yù6#´‘€Ûŧ–ÔaÀŽ§ÄÀJPtn­Z¬±_ò¿/<ˆ¨ð÷ýÙ¡CCs6¥1cz‡ ëmÊ‚Zké>–Ôµ3*¥Ø‘ØÒWéû( Ú–*OK¿ĉúá v=­n”C»†“µW‡ÇøåÚí ¶B÷ÌÕåKÝíkVm¤¶¿I•Jmç(È¥n#‹€‘«›ŒG=c„ÒLùÑÔ^~½6Ê™þJSy*iSŸ­¯m(]u3ú^6îƒôoÜUËôŸu;8 WËŠò\V¸±Œ²ÏsmšgWèç*oÉH›;/ö³†ËÒ²)üÞ‰¹d¹U•ÇÜQuCnÓ gRvTÊëëGOË‹5AVvt±|¬\’ y×@GÙwÝ+â«n>böÈŸ<ÂÕ¿YBtšÍÊãáÉÎvKÖÛ½\js#ˆigÿ˜Rì»–bã¾S¾«Ñ£¼+‡¹þQ„ÿÄüÒ^©ÇyeüþiGb-+ÖSµí°KÝ;‘(î‡Uÿò·‚¾qäÚCx6ÓR©Œž Cª§+ýiÔbÃŽNØÖzµzˆô§´yyⱱߥLšòã ’3ô•®¿’á)‡*©8ÖôYPÖø—±ò™²Ù³Ù§ *G\3PØì·±~UåwÕ=<!¥cvÀÚ¾24Ž‹Ó6mËè¢ç6Gi´fšÁ$€ÎÞês´°º®?/âÜngØ'K€ÀP˜þ®ù¾Úì˽I+ÞnŠ‚6«‘€J?`æÞ ³Ü¥>)-½¸+<Ÿu–g|«Åãb¬¨!D$ Ë­vÌkÊ•Jl¦ÒöÓJãHô5ß_\½þƒË”u¥Œå0_�’ïU2/‹xuv×hò#%d‹ëÕ7ENñŽ¤¡m€­”¤ÕÓ‹©È³Ïˆúü4}<«bić«8TØæþsç›" =–æ{€RTŸzxJWꈸɚb Ånm[ØÄ3üDš¥²?E Î,P‰ÈwEÙÅõ6ìX)™ÆX7 8¡Œ¼§o£3‘³º„JkCy›‰§¾É^ÂWa€é8¤ŸaÊN+ Èë=†þ;sCêûoä8„¯Ê U,=õoiÝŸMÁ–(4x¬Çve#nnLB_õ{j¸±ŠíY j­EE¤¢TS%60ä‡ÃïÌ.]<iü±ºÍ˜è¡3²°ê5çO2Ñ*5øDÜ·ñŒôù7laâ{~–À�žN;/üPt™Ö] ‡¤:åÄ* ÖtTEtŸ‰[c�ÆY F°šÅGË‚ qA¢?°‘×÷î­í`ÄL‹„ßAM›rµVÍa]Qœ¨bb˜¢mX¡km¹û.Ä‘“îD•òÌ>jjup¨›#«ü"U¦¢’gž&ÈÙ¡ýãá}¥¾]J‹®¢Ss|†¡êff¦XB2±¾—Ø—•?`« :·ò^½ YÑpm“…†ç¬sOü."‰|ùGÔo»,H6:ñE»;žÚ¹]Í”ZQgYìdQEu¬¥|¾9xúRb?2X„…UÄ4"×þõßÝa²È?o¹WÈÚÍãáwm/ד©ÖÑBÇëá’óo­L½8· ½j†Œ4 Ô-¯›Mßó[É®½ç»,«Bß× Ü5ÅÞLªšc”«­10*åÆ@n6E÷ÑÞjvW‘áËQÏÐî¾M){k¼`Ä+dq ÿú@’8ñµ'™ ›Ù¬MÐ$Võ|m<2%`2Ü|½“«Æ¬,ÑÚ‘Aü©öU˜ó±çæÈ}&öš’ÕL߃íÛWC%rVpÌé»:E:»†I^! ƾ¼O¶h“…—½®¿Ž|6+¬Þ£ÞÞ%àfåZ/2âtleËÅĈá—¢ÃÉ­5F¸ô_]žyâ2DÙ”!VAÒ½ûzÕC­ºŠ÷ÓÑ8Ì?äû¤™w8r m¶â]éêÞäצåÝùkQÏ4>o^i¼qlÇ œáò¬¹\œ½œéÀö·0a0õg“CÓÁ|mèœe¾‡íäeB¸Ð©v$rÖ”ñï÷@Óh§öóÌÍ ädô¥à¾|AÇà.g³pà8¹k]Gk)ZÞµ~LÐI Ji0xt=7ýp+á‘úÅ2©ßgtÀtžÄŽñÎÔŒ—ÐÀ6ÄjËì[ÖëºãÔPe®*çy¡7mg¨1R*`fs/j‘„‰ï7R.Ò²@Lëi«Š0–•!`n9Uð ãÎM›îû'GÒl¶ùã}>–Í«w2z7ùå>Ëc²D<çÞþI %ù„’¹eeÃ×™jîYþÑõ¿¬Böüwú››àP¤V‹Pzj|«Âšã"ÜÏã¤FÓf&ô»Ûè‚ßbNdJ7WOÍHͽ#N ^ÞüËa€3¹e2–©ƒ,ÊT»a¿9ŠzÓ*¬/@vüÆÀú”UÆ䮣E»X¸ +ªM4•ûA¼)²·IŒ1RØP]vð­æ÷ÇÍTwHËíÌQ5^¥Ë‚Û]ËA×aò¦Ø<>µÈ$¬„ùîO¥ KåÄÚ&b‡2Êj°¯Õ~ªi'[åÀ{~JÖVÉk‘A.Ÿp¬EçÖ¡W:ªy<ù‹{RCßD‡è$4ÊI}Ks¾úº_8¼ÚD�Kà}og¨ ÿs2TÝjÖl/”ß}j‡¾’³ž‘[_÷‹hLè=¬‹¼¯û•kiRye.¿€1N’EgQ!´<èìíÔiFEÆÿÐãÙ=ÍKŸG‘„5ƒ:}�HQo”•§V^ïÕ”™gÄ5xk^åÌ-kEð@—[K�­Â«¦´Bs£3fw…·ƒ¥ï—,^JeÓaxŠ°(½ÛLõÀt<ŒÃ$/ÇD¡gv‚µèlíþš¦kŒžüÞXe9$Yçà)h2r<=ñ5£@¶)ª <«TÎÚZ' íµaã:„-C߸é&evãí>íiÓ§g‹ýg‘e9°y{¯nŽ@Îhøž!z¥ªß~Áv|YYÅ©É–™ærÙFu µ‹â·ÿ¾EÈ~€ËYë=?òé<®VLà:Ãô×’±uF$”ÑXkÚg"‘³Y2Ú Ó�Juür¬–?GøòÀï‚7Aæ‰ñÅâ;ú §(º¥Ñ /L[/1 „ÇòÙ ÚÉæåîHÉ®ìÜX£G*šŠº¶JT°VB÷Ì-m–¡�Ö6§37Ôì¥ù8]åØkÊ2æ~îŠ zÿë¨ö´{÷�+(vêTO�c]®ÛºwÄ&c'v‡�KKäl£º™É'yÌ©Ge»úW±ôÚÀb€Æð…‰À§æCÛš:u8MàÿFm`tÔsä«ô)›½¡Y}Ëd±<`ë¯ÊÇNf'Œ.èÙ);=9p|í¹•G×RîÕú£-úøG†ßëÜ2iLÈ©Ëît<ÊYß;¯<oPíW·ô$áç]Rå×ÞJ>V¥¯D�$Ë>΂¤·Â6¢ð°Øº}ñÒ/AK.QaîZÏÔ0Hz²@Ì6ag7÷¥Eÿðj_ ײ0õÍ`Qko² 5EÌÄ¡P‡¹ðÞÕm×Ì„kZÑ&Æñؘµ^Û73ÖÅ2v†‚7�i…(™ NÐìe¬îŽž\ÑŠ-àé„ÁrkéUs¸ _³9ÌbzÓB~äû‰¶“ëªÓjôgç"ëfºýU&J?Ò Ó|­žÝŒÊÉê!Í8:�ü}¯ÃHº:š¾«´‰¯´’4í’;>À¡ç“þ‘$òDy†¢giæ‡Â0¥;–ù|^ÍÕ€7Ñ5 Ÿ›Ô†.…•ºhž :´F‡ôð‹m¿ë¸›§wá’îì*“Õ „‚Öõž>]Q®QüWdí½dšDÊ¿D'<¦p±1‹ûؼŠÍx_Šà—éKV"R<¿Øv»²ÞJÐѪû¨— ê2߉ DVJ²—vGiÈòL1-óî>‡sN¹pï/ ðzÿ»U—‚‹°0 QèM)$ïœõ÷nj&´ý½Yä¨o‡m†oÏe°ç´�ò ý´Æw•á…¶õï<`£ØwÄà„²Ìn[àÄ D›÷cÛX"ÕΓ~_g¢ß ®ÒÂGœÄÌ&ÏÙÿË ã,D ÿ)À:k(A?R¸YŽæ€A;q=xIüf-?lœÚy»±r¸ÝfXnZôûãTŸ¿å ‚•¢ÕJ¹Ú|Ç¿¥ðÆ)öƲM­ÖQ[tÕ¹W(Ž“Ú:!Ãc_W»sw·ßêóiyîÓŠ ÷ÍPÐ#Á£°î[n‡÷ê8iJ·ÿvíUTA­(Ïþ8á²æO$ÍÆz` ¥š'§¦õp’"[K²u<Zh=OF07xÀ¦ˆ0:ŸNõZGö™–|zSMn®j0,?OTFÊÖh´ÙCîê!‡ÐÑER­½r*ù¾T~õ¡z.˜=sÖ™tW¨–m• æ>r;&/‘` T´‘৆Q›…ÅÜ7iH=™IêXæ„ÅŒ‹BSCwÍ÷™juÞÈÑýì'_ §4mÛÃ>Jëõ#ˆ¤c×Ô³…ŒFν«ïsÞ2ò©_a†Â&»»3;v°R5¦ã8s¯ãöÕñÖ)äÙ1Ýì$Ȭèp~ä6|Er¤Êâú€ërc³k–¿‚×ý,¢Ès ÆvuEPÕ;E„ª2„€_×]ŒRžÁjÚÓÞ+¿,B Ã:­f>¯ï•ú/ýiìô6™²ÉÁ ±`D¨;ÖÝ0šâ ¸„¾²Ûf{‡¡äQ„}Z(è WDFoÅœBÓG0ªês?ÃSÀ¨‚µžë ]Ds»V{ç§QäW\ÛHÇž¡ˆ÷VhNWTµO^€m»“”{韛Óiµò«Ãmb1­i£­}ÚòWÖðµ/?Ii%¾&!£ªfº5a§<ƒÓÒÑ×#¬XªÒª8ÑPÿ¶=#2üÚ­2ØÍY"ék„–…¶6NNì7¬¸ú<Áì’ÿ›h£Èà›]Xµ ×ûèÇ„²¹z➧z?Îò²)BäÂ$`m¥È…ãÆG‹QæÜ)ŒÌØWíÛn:Âcì'¢*óSʘÁÝUÕ–ÿ }VKëq ŽÓ Q~/Pdv ›^ÇØÒc¨š“Åòô?Ü+àvkVPQuˆA#o à=­å„EÕÔ‚Íè¹x aów>íá@µýGòðF¡t{‚¬ê—7zâÁ¿ÃW³M£y±UUúOTÞ,°#Ρ÷5ˆ &礤aJ‚§+ Îp¯™ü– • ÈL‰ºÝäAüÙ¹†{fdè§Pæ}“+ǦhÓ£r·¢LEhT"·Ãé¤5Úÿ¦æÃ89¡9|Þ™?Ø|¥Â§‡vúžm¦<²<S3Á�dž´þ9{ä×À[`ÕfŸ²Õ3gß(¡8KwŠ:CPüIË`F¡KÿÒ_:N“PÈ ¹Ñî¹B®&|_t^©7)×áÞ)­¤ÃiwäQÆS_Û(É3¤áŒ=Ý +3Ùµ_fq›ö?oE`Ù+oLñ=ŸÆųÔõF÷z~=ÿÕÚIaa� ;Pì7Š-Éò b¥¿«ë𾊉R7°–n)oš÷ƒ›ëº“ó‚É‹`/ï5ò- Œqø¢7n3щjE$íl¥]d±¾xÒ@²^�bMË‚klïJ$*wt;½»vbý±±<!DÇ´É5ÀåB­¶Ñ¹Pe ´ÄÙ{qM½¯²U¹ ÍL+Ù.š®{¿9<@¼‰Öªü{»>£ÿKœã‘°7X§°èv[«íŽkC¶`ýŸ‘+­r�‘šö[yî½é<ûÆ÷¥6½ƒe²i,ð¢ÊqÏDKªãýFÚ¿èHЫSvõö¼åyŸá¯×<0Úѳ>Ó(G @gSœ0+àDH§¶æê±rè×BP âÙvxòÔž½ Ýtë—r÷Òr“ò•¸+•‡0ç¶6SÌ(®¹M½9Ï @G‰… âtd ˜–Éïèœw†L™/»Ë*Ø™õÐåÆþŠ˜{Ÿžôl6í¹ÊG<λÌHP­ÀCBmz­m~>S^ˆ¨,ˆWN‘àÉ¡e½÷¬R; ¬¸dÞ9Í–ªœy]¤y³%ÞÁ‰²Ãbù«00:/?Ïx œ$“°¿Ü\ÿ©Ç¨ï6!;¤ä²Ã×£|oZ4i·öd¾(ÇÆö•ÌͨȠ ©¡¨×_½BL5§d`}Ý´_÷Õo’ÌÆReÝ\Ó øÒ•.²õýÑ–#c¤ÍËÃÚ4©|’šZ 4åf±Ø¾8¸•Åɾ›—[ƒª|Õj o¾ìèAZ´œXe‚ª9XZãûÀé·òt ¨!]€TaãéˆT•V 8pxÅyÇ>¤ÎØ;í°Ï#"eÎŽÐÿMjÈGPO0|-Ó¹h¯âÉË1o:n6·BOQì)в Ј.nÕøÜy†Ç˜Æ8¿ñy”Guœ7-§ˆÿ¿ÿïüÖ]ûÞàoè~W.¼ì\Æô$Ó‚fënsÔ„ÿ?o˜G¨p8&ñZ±Á\*à ¸”³^ ¹q¤z1È?ÿÚQ'o •.‰ìëÚay’­xtÓŠ¯=ý<Ì'ĘϊÛ]lÁ÷¢1¦¥o$ÆgU¤%aý¡ UÛ4ÀZ� ̽¬ÇQ(pôX¯íü|šæ;h°¯ÁöOAYƧӅŽG¢1 -³bŠiÍCwä Í÷vSå›êRyh@øê= ÛšŸ“üoèN6h®ÊSlĦ™_~Àø íäKˆ4j`2Ce#ðÿ†}¼†Ì4§ÍM{†J¾$s‘ñ£˜/ž±mêÉÄÒ®>q½ùØ­.쉞x\8îÒ@.ÛhñWÒlgûb{ kìw-³|Õ(ˆ+ ¬Õ§rÖ¸ó›í†j?…ÏüWÓx…áçÖ í±ªÖªEM€’€JñAG?vN/ýÑr)ƒò½óJo_\M0 ÂÄ|¨h0Y´*åQ)ÞËŸŸªY2È©9E ÿÎyÙáÌRUÉ.ƒÊú~墑}qVE¯æ¬aåü3Å>™ß¨q�"•n‰©zuÉr†µc‘¾by³¾Ôq=2ͼù´¤(iâÕºëÛ–E‚ƒɆ N~^wòñ×?yG±u ÙBÀ%ì?•Ku=i±4«U²l¬<f>EÝ•í1e¡/Jk¦GŒÎßGk¡ŠJnYx¨nfoÃràÓÍþÞ»º ’$)bƒ¾â*t)âDãÙÍV² ÿ9Ÿþ¢ÆK÷•}´Ühƒ]÷§õ¹×fbÕö@k`k#t«µ-#DŒTîwÅÜÈ;àÅ‚#¢Ì$u‹(bÉSSõýn%í}-)‰üg—£%6¶”ìD¸2çbX°sZð Û»=G/x9™¨0õ7‘’í;È^†ì ‰:MÝycϱeíyZŸ_¼Âo^ѹJmLY`n"´Qåÿ{sð|'›i8JCÁ]=60’Ô7.An?”¦©=T½˜¿ê(f¿U×JQ: ‘ §RdËhp«¯{¦Üï@(ù~};’òpUøEA‘ƒ¾³F«g "”cÓ¼ùÑY9JâÌ«¥UZ†˜6�â"ÌF P¬åÿûPŠÞÚwŒ¢w½ôσ é+F%Õ³½˜Q~™&ÉiáÎ.ÿ>ŒoÚß"aÑ+z‹¥ê1s üS¢T%À,é :°—Û ÊâÉá“ÔI'J—zJ NÒÄúÓ ²™"ß7óT[ô¼ØcT+Ž·Àîœ01ÉàuKÆ0ÚEýîϼ¼;1Òe±p^¡øœ$l®žXïßUå@wm~í‡OWZ}pèdX*d)o~BKÈi¸#Ág™B[<«¶PÀLO·}ÑÎpça»:>@ÌŽ“ÄÙô üpL·ÍþdëvÆÂü†^Çþl/CÓ}ƒWÞê’L$ÈoØãÀdÁDñŠéza˜P"îÙe7z‡1Ò®·ÔdíÀçNª˜õªYÉʃ+[«¤~~×T1›uËèÔébú5Æòut$†íÞ“<AyÁ7XJ7œ?wcÙ]øxâ© K^–�gÕ›5že`U§ÃЬ²Õ/ÝÚÌ@¬äè}NŇ6¾cf´¢µ'QbKotqt¼¤Û•ø+ Ú…yþš¡ñ…íyø´gì>ìíè¨E£ÕÿZƸ˜1 ÐKÄ曉|8ô@1&m­ Y$œi–¢bñ‰—a`MùäH Üýžn`Ü[Ñ&Õl¡Ì¡ÝýºŸU¯ñûÕþ¥Eõ1o‚ÖUkK8ÖmØLR>H2ô3Ô¦pŠQÒu¬©°:î)Ú->d#fóic9³Fž½“‚d7iï82“hΤßú*^²*}?a` P<“féRi,Z÷ˆ6Ó=£IÖÝ^â 7žF1— :âQh9˜[?‰Ã„ŽÎ&¡¹¼y~¤·4—禘åÕø<! ì=“mC¿W_³3ÐcÒ­»{yKn‹|y"êqáÕÙ"›³©{µàÙ7å0ÌÀ¬¹†Á塉‰[ñi!Ù1Ÿò—ÞK-/¢b‚tG^øsRù:Ýt7ݼ§}DÈ\_ZÝ—Çõ…•‚8Y_˜8/+‹´;4ðˆý&¬¿'ßÝF602Ìh O|tÛ[Øœ(î]LÁªñ€ XÛÎ÷¸¸0«î`nåûKÏŒ=³ƒÂÄpP£&é.yziKn`  EF‚Ù¡»¾qj%P•¯Ð!õ/˼À‚VBÛSëF׊ân-fl'Únç«S ƒ2sžŠÝ§Ûݱ+°Ó6ÛRVuØSN¾¹ú’B´„:1À1±óÆÑ >ÊŒR¬½à8¹xç{=(¤›!»Ž“è¶ôÍ 8;‡£ˆ½± ð[q·R ÃÃ0Êqp8bKpσÞb¿9/©b×MFŒfKÖÄš�;œK&¥¥ŠÓ°ÝÕ Íð(Ì< k‚…ÒR°ÑÀT@o­êU_î‰v÷J¦¤w8/[!ðódx3<ÀYb«õ\ÿíÏç±–ŠÀ ó`ÓPŠ˜Z“ZËöãù ‰NRÊÒ·Œù*Î)—;Œì;ŒÊâ5¦CÜAw—ý§!n¶Cö2qkA_W–,ZíxÊÕÀ¨þT|Šc–¡ö–5s·ø¤h_j‰4Ce£ýR|6Å;È7™Áü/ÿ€ÓŠþÿ³öfÛ­*ÉÖð5õ¾ûnö>Côp 56Ð’µÆÿþÏñÇŒÈÈLÔYvÕ8ãXØ»–,Cfd4³‰ ªjúȃÔJ`fYÀÞZMko»êo«m’—*VL(3â}Ãèí.^Î'„+Ƴ±¥ÂyІé2ã±Y8û£kÐòòqÝ.‚ ftöý-òçÖ!>÷y£fs‚¤·€ŒkÆô§U—y8õ¾©Þ ïò>5<Y]ãë&áÁ¶Å쌔¬ˆ_þj1Mwáñ$ŵN“ÁÔ”ÇÝìV Cî^Hâ:÷y<�²ž,¡é¡ôHå.'õËf’~t8»"öGku(ý|ñ1öx±˜2$ž“i&:ÞBgËpm×x6<çÑ"¹°ŽšºŒfœ°«Vÿ)’£Å"ë!{MÔSM àõ<é¸ëßÿ€ÂÈYaÆTÑóuÀfæ›v.èÝ«€ÔB¦Ë¡Ž5ôVÛºµ¶Ç¬×ÃqjQá1²KÖ»º´ièS n¿èšª§ü¾t³'•yc¿×å‹ug£ %µlIºCG™Í§ú(Ñâñ@Wvµ¬C÷’Óè;‰xb:z0†Ì°€.ïgo½$Ù„»~ŽWÃÁx6åô$q0Üð(8|Pú˜[5dˆ¿ ªY¦Ü9nTÒì+vRâ€h¥\Êõ‹H‡šíŒ“bEªÙ”[9>þÐÖÄÍøçS\Q°ywn‘õ»ÿ…î•c<ó̆9hÈè,XühÄ¿Ç.ä"jqqó-fàKß —Õ‹ zQ̵W9_8÷Tñ‹Ç"aTD©³–¢ÝÒ÷¬ŠîìÊr¼¡õ|ÀÕP}ð&(13_ú¹Ðæî©<(;msBฟ'ŠxÍÖÈ÷øô½U•`úð#‹‰¤pÉ-c®æ>‚vÀųJÙTŒ³–R,8­?ž™Vxæ—’HM´Óîì1@éOz¯=;V „O;½IüuW·éH麨¦ÃFIkÖžm‘šð¶ßœFÏ;[ÆzÓVè“é\ÿàIÏ-\Gü© ¦º-kg;¨àqSûU!Л‰5«B oâµÎ^¡e †u, ®ÙbÕP ÍŸu‚¦¼UMãŸ[©§—½²d¡gØÜå»füÑÄ^-p–¤îïuŸ6»bÒÜ™¶ÚÊN¿Ó\„4O=0ì‘Ð*÷­åûDÉe9´=Ž!à’\9™1ãju²£õ‚lY#»ï·¤+ã'¤›èÔ¾þ‘P·ÂsLïI9¹:¡oªË üù“‚Éüå Á&j)/ÿ\B¨xb;z­Ý‹‡?ÎÕõº¢*-·n�IÛpÞë͸ÿk*>J®•m÷ɺ”ÔíˆØž;œT˜ ª÷wÛ4Õh_'8yp‹Ø—ŠUù/qŒR¡qE;¿e@æ„ßw€ÿ„ÍÅ’“µXP ƒY¡B/,6¢ƒÍ·šÏäåîzæhåÁÓêgOá{¶ªº‘Áš<ÕOw <º¶›Ë3ŸJyš¼£Ô(·#i\N™Ôjª‹ ?Î_£S±øÆ*(G©Ÿ¦&wî&”ôV EWÛ†G;÷V‰óy[©XRh2¿7Ž¢sدw˜¿ÞG?”KV<^’þþˆò±«\šÒ6g”Á›ýüwÛŽ+\rg}JÛM䦸pð*õšlqæã/0šPEd9Ü+XŸÂδhX¬Ý"GÏcû±ïõÅT»º>XB‹u‹O³çó3î.Æ—ÜaBÑñ1;ûWÐ:ÑBáÜí>¤8Y0ÏKºELGw¿ù9UŒ�½µ‰C‘»ºî>G¹÷é™1:£íÖÚk¥û,rä†4?½±ÝÒ=ýeV挆ɿõå_úSþ¾¡ähg11}KËp5*‰ª¾k˜­P•ÎržoâErÄ+¯VÄÂ+´À­¡”NãfìŽIZ6;Nâ~YÁÀvü@{{nŸ 9-­¤0H°~Ko”~jÑÉT¨¶%;€Šûj=ú°› Û3e7Wm=Ź‹<'Ë ÄìEãô|8ÌvÊĦ¢@rÐïìlÖ<èL Žé»…•9(a]î¦7=“ÄN‰Ÿ™+„¥Ún7{¶²kØ©˜^5}ýË›tÀ‡åó‡>f?ûÞzPÿ©ú2½R8à�Ð¥Ï_úôœjÞ™‹d¹»“Tc{¢ð’_žktí{óâTjÝTŒ ‘à8Râº-Í$0mgçÔ‹E©°¥#<sçù¢K[d:gA´ý²Rë,ï"ò6•­—#„ÛýnÈÞ‰ ûU4`×*ºÐ꨼®é9;.y,:¡ z™i´Ô+Fú;Ætè8L�¦â|� ¦±<*ÊÏÀÈš½·=€ŸuÐœ÷ÖØ45ä‘EhñÊhñùÆܯÍ+¢¨¸j7L ½çWïõñªYÚG.‘š´Éôä›e|ˆ—R-Ýæ, òykæøÓ¹£çq¾ sáâýD{w?kº?ôfg/;pNÞvù]èAJ³¾ë‰ÎÇÒæ²bA<öœ¨ŽÓ!{•< oÓ ÿR].è,·1«¹S=q٢ŃիdEÚØmÕÖ¥”Z ¾§žü(5ÉË•'^FGð@'½Ó)Œ€¯á!`4IvUc¦ª¯øiÅ-šk,íC_²÷Êõ”†êC3ÝЉˆWY´Ó–E©ŒD0¢*·é=44ÅÐÚ*0w*b|¯a&‘³þ2æâV¡˜¬«Þ”{w¡�õ¨¯Ϩ˜¡OUÖ†>çUe‘÷Œ0Á·¡lh‡Þ%ÔÈVžK$¹ÛŒ²õ“~V`Ó®pŒ@À•T×]«d˜Ûl¢ÈRO4‚i;ô·[ `$Sú™ ŒšP<¥ %¾†@ÊÄ×CÄ_ai­ðwB�=Px±˜®èø6DD¡áÉðð?´ÎÕh«ÐkNÇiþÉÌ?Š"›Ÿs¿Lüˆ¢J­ ^‚lç57¢4ñV�gƒà+Ö¥gòxqðÄæÔ3æJú’èàš0²»Bí'ž°ðÛ¸à™o¤Ö—»Š©º½ÅÇMeÃëo_Å4GQ¶™á\EßûÎéÉy~³\ "*k£ñÈ}«zïòŽYͪÈuä)SÛé³4vlÇ“çËåkRÌÆìÂÙ^Ü3Àðó¦Ü´˜¦žöäoå)šÙ¬Ž&¿Z@(˜DÖµT|Ö¬(D㽪ì™'þ0dU ‡¦8zTÀC"e"´Ùõ­«ƒªh«ëoÎŽ¦êÆ5.B¡àÐÚ*æ@YóØZs–ɉ%ø.GŠ²ÍË a»„[¼Ow” ‡me€l}¬q¢qŠr+ «â°îƒ ý0d Ÿ¤vüõ0ðŒ™œÐìHI>‹”-Yºª Ò^á™P”q4M*ߪӗ‡fV¡Åe†23÷´³Í”OÿP3TÛ³Kì‚žõèšÀô¡3ÕÞ"ã£i`’(²é Ym:N¼iU&´±SxZÜ�»+oþ\û=\¡bkaf5ÒqÕàqï¤ê^‡ž/]ª\œ.o[§OC‡’çf ¬»À{©ze;Ö*E.ém @ªyw[µA¿~P·¸jï )¼êú¯–Ìq¨àe”4j¹®ƒó²Â¹»Ó–'³pZX•ˆ›Û.GÃRïFÏI•æƼˆNO3è}M´oÃËcÙ,\ù˜xl#¨ ©cÍ‘’Ó›qå ÕtÑ&M\~v@—yêëÃÁ®¡ÚJܾޑôÄ jÝ/Ò3]óO…j×禹®JkÖù¿p¤®¾Õì(s_®i•£•űöÙèÏWÛÔþE7æt›Láv]I/^ôé<îþЈ.z®«àðAc\óëjHyt6€Ã ¨GßXr|´ØØO¿C2ºBW �,{—8„×èÜŒPÔâå¶)2_Å,1­û5rääkË}iŒŠ¿ëÙG¾‘%{&ûæ“S3–$Î,›áÜMò&t7•Ã÷‚Þ}¦ž^…‘§äØøýt:¨¾�´P’™{&£yãž·K“È5¾ 樠?]ôgGy^CÝ�̨´?KØžºCl¤¡Kꉦ¦×W_’f¦þ¨É×F.ûò¦ÒôBâ›sLjֆ 4ZM›Sv¼½,¼Ëênð·ØÖâƒF£J»Ê6”AjÙ„èa]ͤtádëá•íðf¾I�²ŽªÆƒœÒ.ñú®ßQŽâÜXeÚPïDï"Võ,£]jt#9Êñòʵ‡} ™Õ º!ѬâÐuwj¹Ýæȸ±u`ó9JÒ&:ëËÍ_R&>ãb»=%½ƒTš+lÍb¸Ú¢¾º|¹Ånz Whœ23‰e§f¾Žo†ÀèJ+óÍÚ8©s!Íæ£çñ¾õUî÷2œ·óT @:`º‰ìÑô…|ƒîP•å_k)+}SpB»vÜVÐeA!ÄÕ«+Q<9ZIáQ-^LÌ sëõ–-ôÀÊ ]Ó29x¡'ß|}±ôuðš]y�ܧR€)§¬«©å߀Ç‘À8$X%8í£˜G€ÿ‰Ž;›ea^ÂÒŠyŽ*P1¹Zù¨Ò;ðá£;cóú*ÚӇ͹‘ÒÊã õ—ùÆjœ¸/Iÿz³©ÐÑrßµþ¥Nz—ßáNëzôñ§Ž0`¤ÓWûU"˜^Ãk”ž)œ€óPàŽ“•wÊdœÆ} îx*ôþ»$Ð2¯V‰<‹Aóe7 %;épUSÏ|à{‚•ÓþãÅÅ Fqª¿ÚG*)¨œŽGú7èZ‚ƒ0îÞv¬âþ"hÇÅÞòtNTý Õä UOÚCT©…ÿ{cþÊ´¼Ô«ë›uy.ŒÝ`7ÁŸÌ pc�Žƒr·6•H3OÒº?®Æ=*KÁ³™pP÷QP~õ®#l%Ý©$pn{Á äXèÛŸÀQÄÓVHÄ 2FÛõè${I4¤ëú+W:ëcÆÍE°í@>µk`î ½!ñkU*Fæ†sBáN"7­¤ð?aîÕŒ1#KºI&5‹Dö׶Ž"ó D8Z-µ¥×p1¬¬¬ æ„ê}7d/÷õ±eWäY1b»¹PúÞjŽ‡.›—r!’FSû?Ò/ÝÑ#‰QûgAb±N%S﹓À7Øì‘Ãй™žùFŠÐ+—c{‹YÉŒ2ºzLƒøl½ÀÀÛÀ ×ù1½àÐécšÙU…Õéìh7d¹6e{c|‹<á|Y¡..7 Ä@0ØQF—Ô“9R˜×[¡Œ”Ò±;A:žÊW¦¢ÊòÓ ËPmý]ŸÙ®Nnr‰sx²U4£6P1|c{õʉX,UûC`äŠ ³x<à HBU*CºôºD|DÜ•ëQæaxª¼;̆7©iÅÛž?¹å;èÆõèèüßÛvxÃÝ=Tð³ÍØwèÈÒúì:« Ÿ:S™¼n¤ø‚ù $÷ÁôúVPV]$Oe/ŽqùîÝó¢’P0š!-NnËPM£4åûŽžiìÔØ$>Í0ÎÖf2Ú¦oaÙÚX»we§¿‡;v§ »y—'*sô´ŠJ3ã …Ù4݆ýã$µÉqa~%¿7m{ä‡"æõ^&Ypôâ£D÷‘3ÏQ4¹s 9]йt²<*õÅ&<`HÈß\,äïâÕé퉢~ÂZ¼!×Í�H—at„Lhü@Á)›‹|lgáNsOÙK¬¡”ÏŠÖƒû›—Ÿ‰)vÌi(ð2–u ¾ñêfîrê â¡ÍоX=¼‚åÂhsY"Þ¥]Îo1<G„i¼°úÉSP´®©gp™<Õ"ïÙ†e‰;á6ë¡¥íÏ'S  HÍØGT—ŠQJlæ_r¾í¹(µÃR´Ö¢ÃÔxU ˆqÇw›â.ºþBù¢(}áÆÇ7½–Ì…WnÈÓÊÏ‚¼z÷ä_ zñh‚Á1ZìýN?eIÔJÌTÏJðfÆN‰hJ·ÌóÛQ^¸Z8&—!UÖÎ�-Ê'ÑEÁ‹-aØji%ð)RL%Ó ¶ÝBÅ9tΓ![º‰³¥¿³–Sƒ­Oï_÷µ(½hÎ|客´íß2ç¤9Å¢N€ý}ÛëIB÷ì `"æ>.ƒ¸ùòö™ÈùhÝ~÷§þ�Rm\m„8.­EYCnž =÷ÙzdþéØrƒ\K1Arvÿ’ÕÖØé;xƒo`A5�þöÉ6töÝ$Uã]êE¸P"á(³¢®3O9V<÷QíÈ?æËkçŠe‹vcDA²lúë)­‡ëÛ¤Œ ÷\DœC$täe0ê"«²3ùrŠsE³qÉ‘B„hCQìãŠßÙW$Eº€'DAO¡­Öi ÌŽJy çteþ„Ú÷nkpeÓ æBSÕE7½þkj–ù—+ul‘q˜|Œœ´`öÔ,qx3ŤA¢(XÚõ<Ì7m»ýØq÷š7S–ùÁcJi]­¢Ê2ÛICŸö°çéÀ¿{*'ãfk/î 7bMäµaMõ ݯmmäBѶü°Ò°\Óúƒ>?ýQG;`»ªm¢Ô7~1y‚üw¯Z†®³æhW®òv´³­üÏže¨b%©Pàp´ˆœG7åô€#Tgå„á2Ãw„ƒ™b|ÕööÕ;X¬~Q×–AvV,~Y ÛSÛ'Þ±“1]ÔǽséÛÍóN˜[F706-çÞ3VÙPñDadzzýø®<Å!ÞÛ;Ù"M‚ü}§ 4Ê-Ê¥c÷c¡¨ _,mQ+Œ±m—@Ä…˜ +šT7?¸§’E戌âúüI‡£ô­ð—<ßg60çŽÕ~Û»rËß.R˷Њ�ӧж D屧ŒA¥×~>zŠ|ø]‰=6îèÅ[u玹‘A/? ?;ž:]4 bÙf¥KW‹ó6‚x?}ìÞ*Ò¬ …ÎŒ5QÚ@,†ÎŒ¾ÙýyŸ`±³ÈÊ®Šƒ¬ÞZEÚ@è<‰¼Ž&—ãGS'ØΤǺ—Iw[…Jºµ¨Öp½7lÂ{]XPHn”‹„GœPn¤ÞgaZ¨ÏK¦¸?LÖ€ð;R·?Gµêx¹\gÕSÎ�2“âG’Y¶:D¡§¦.à¯sgWY’Ù:”ôO ;ï³K ¥öaa‰æ“ó0cÊ|g¡‡‰ëiãÄ ŸQµ«õdÄYÛÒSã~¶uwoiïÈTŒ/ë%´4,â«ç¶Ã#™tÙ�‰Ç�½Þ 2¡l±B²/ÚÂ$YˆZ¥P-ƒ¼ñ¬u·< SÙGXVó¥W…<•Mñ¾¡U_¸Y ¨¾€€Ù:aþ郎"ÙœZ´û#øàüõiˆLRŸë •àœÛÙòˆA±œÒ"ÎSž{êÅmÃ=‹Ýø€k ÄÒÆ’ýR­±m±_¡Ê£e¯'*Wk}3Ä­ÚX[ø«åeOg žšÊ–ÏŽxçŒS zí (Š…SQN¹S Ç‚Ê! fl-Ê:S€Ëã{$øœ¸É;w®á”2/2´BL¦¡.ìZ–ñ­öHv¯ãú|W¨‚]¾&D4ÛöLÁëµDZB{ "ª&€Èš¹ÞC÷ »_Y!k‚°újÛjþ':3ƒæà?–UOüi:ÃÚT¦”•"Ÿÿ EƒÉÂIŒ¸ç„B½¼EÖ,Ǹ¼Ùxº£Ûáb>õ£¶Õù­Q\îF„DÊzŽŠ-°¥üÆeý±Þcf©o OÓJíu[†7¶ö_(ÿí™í$Ñ‚ŽŠYô6›ê%¦ETºõ†ÃÚ•T€æÜ©¨Š(.sñT¥NƒdÍû&¾úM^ʈÀÍÌ^›·z5.á κ“PÞÿÙ7 þÀôê[´<.•¨lvàR)ø£‡é·€åŽ±LÍñˆ³ ,ÐI­¬lû_PÂmÛ64"OuW±•`Âø‡‡åÒ¿2J…RÅñæ@Ó¿ÜÍ<cÅG+£M}ž(hí´TÍ ßÑÃ/<·Þñ‡âƒ]7£…~ñä%Å»|oI‰?~D…33sýžÂE6ÖÞL$PUÖ§¸KË ”Stªæ4^{¡ù= ¦µ_ð´~÷@fÇvl·,O$&«w,Ê®ÊJ7Nä¡Þ…˜Šl ˆÊÑœÄÏá!»ôȬ×MePl4™j×»á ÈÁG©qÇòGšO8Úáò•ÏÒ\…æã~n­ãýŸ¶×Öea¼·q÷]÷ëñG·™” Ssþt€@Û�¿+(Ñ»oéšq¶Z8¾$B‚¬Þ}êúzc-–ÉÈ«<Çx¥<GúM‚ýÂ5gwuk½Tÿy3˜/‘ÊïRQÇQóÊ¿±©¶&½½n:”k‰�»Þe…ØÞ“I>BËߊHIc].»v¢?Ž’j r–ßÊ°\ØFþ¨<+²%¢¦-Úm§ÖlÕƒáÁNv2ÚV‡=.&¿–4©bÇz½º†ndVBM¥º(°‡ìÒc¼@»¶Vªh•‡œEó{0UlEŒÔøy7&tNW^bq¼Ø5·®lá¯Î¡}ɱ>äAø·³Nl`eA&j?µì°%Ó‡™¿EÏGåj¡…±mÓ>îúÄ*x¼À`ôFÿÖ"Žâ«+Š¢\Ë®½æÅ#LË-GϪ¢H×é8ت>ºNTÆXûë!‚Ó·‰+T;ºÍïGñÃâ}|œ8Þ¯l’Øïô�7³£r8Ÿ¦0§±ke”³tɸ5Ë`;×çÑå¾€ôÛèçYF•5 e@Š˜Çç*(Íl² ý>‚!VýMøíÅ“žÚÒ“ßÊáÖ‹R¡½Â;w1•cI.Èœ6ŸÉîÏ~ͲÜFMØòI =Œ·DeÂœ×È°½ž§ÿœèªù|nâ ®:g(oxÞ’#Ñ×/¶-â ^Ðdð4ï 2€1Þ»2@,Âä*½£Ñã·R¬=ۮܚm˃B_7áöG·cA9/ ãkéÒë\§€ÛúÞÒÒºµ¥FsŒåT½öœðˆDWš Ë¿-y$úþ®>s9ué*Š„ÖÇ•§8ÍÅ[·íq HÿK  É*vµ2û·C.ÙJ~H)xø XÚ}Q`4öÔWyR21+ýTo¨kÕt(rËÖ™¿ó‹Š"/Ï`az�« øÚyZËK›ˆj4hò_=€dÙ!*Ø̘?h 4Bg¶´M>¡Þv§d?„ËD;á4â€sÚ{V5Eë(¼n¼ÍΦ`NÉ |Þ^Ü"vòEi‘Ò_ˆ–Ù»†¨Òfëj­„/¾fýÊ5ÂêÊ·Ž@BYQñ–[_ÍÇ·DÕG÷ªí‚K;üÙ룰ÁǧŸ„+_V2è-}Éí‚6-dx̪‰Í·0Ý:(–À¿~î*ã|säŠ1@.=YK%‰‹€÷ÐoM”x±À=Qw†[t¨_Ÿ•çäQÜQK*úxÛ¶kyüp1_10uãM(¼ÇBÑåÓésÑša:ÜžU=âÊË,–2R«YM¿ã€Ïº³ %Rˆ^@R¦¾§pû­ØmäF/åó¦ ¢úÓ¶#eOX£c^.¯Ì讥*b=ÓÿhU½ðZ&8½2.o`„M³gk/Ýt×´`9-W‘Ê ¹È<¯óPWý¤ÆdšVAy²{™õ.ßt9-[ìøÈœ×)‚ÿ̶o}W8{wömk¸uôny#¡çÞdãö É�¤"JMšç®îeœúøß<˜(Q-fv`b°Æ¿r”Z ßœ p9w‹=Ñ®Wf¦}KoÚ–pµú?°œÝ@ì‰s‚ãUH)…]½góés7wU»áM<·¬ÁÅSwùši£Öìçæ�½£÷iÚÿ~\S¯-ØÊ‚ÃQm ˜M)c WÀЗ©¥m$*¶^x2tXI~+gê­õä@š ‹[}Hôäß©R›R¾ÌŠï‚dú3­¥£¨rC€ä‰¡ Gwy éYÆ—€Ú©žCyŽÌ Êz8uíŸJ?qÓý·)%ÚۦκÍ*ãÜGßÀ¬äÕ&Ó)Æ(¨SÉ·p’(£ÂËÁâ`êÀ4ÓEÛÑB´p2Ú‚ÒÄeðκ¹1<u‚]¼„Îã€eo˜[Yñy§òlåË“+åçgÞÖ¡o½Äñ4—Aù©=Lv|Å0$�6eg\ĵE³¤Ð¿êzÑ3Nc{SýÇ8¬W*U(Ãß¼{¿Ž™ <ßèx'ÂÃæ z€·,ì÷¬fÉ=›ðSÒ› RfkpÒU@lMoáAnUíÍï­Æ?&Ð|ìA­¶lÏËØ*'öÆb0ñ¦eBV™ZŠ1;‹ÈÒÖ~Àz»UG‡Ä2?“FÊÏ€”aÀ«E½’ªýØí4Á”³Òæ·øµpé»åÂ1*)�h.„ˆTèœ(•›ëËËÂYb$PBÃ@ƒeÕÚ®:ëüõÌCæÛ¤6q¨Øû'Í•Ò+ÏYnë̽ݪô×öKJå™ä ÷Z‚7ÊêÐò±BC÷.™0“xŽ‡T%4¼NûYÁš¢õaþ…Á¸N½`lñVŒ‰NIÍ€›Ó(æ˜á*Y EÓ_s½Îˆ@Z%8@NÁ’ë,C\Ð×±D‹²2§TœNé—ö,îS&¬å¥i£–ð·=ú’&+¡\ó€y½G£šNd*‘ó†˳ZQêC:„3x†Ðb9piå]=É"C‹iÎŒ]æÕTvT,zj¢¯K7BŽ]SîpåÞårPQºXŠ½±‚m{8)L£ÚÍú·¦§y„ª¾>‘Å7¶·öí}¬[®Š2SAqM1Jðk©Öê¨À+ç8P_¤»õs[SËSä¿”5ÅI|þµÌX³¶è Ž~«’Aùä£sSn§*£ƒî]mkCÑt´cžšç2<ùJ%??„ágªx¾äW/0œã 61r?CFGÍé�sN콪œŠ6•(R7¥óV™´”®-&1V\ïÛ€ íÜ`öåW½í°å¬•Ññ?÷„ûìÏî^9âNê œcv|ªŠ Ÿ¶^ Kƒ²Æ©üà ôŒ¤îu=Ls¥ð&‹Ó»¹µbIÝTöÍd!9}{®Ñå^ -˜ß±)£"õ%ý÷îJ:ikO§ËÄUó^R°fA,&� ?e§Ç/¿FĆ1¯²Á~êå— Z§tÓ² é­]ó‰Ç9Š·uâïf¦<¶ZA¹k2õïõ­|pÛòÜ×’¥¤hž² ¬.|õŒ$JÌ*åÎ rª.Ó’® +¦0²‹ðà+yŠÉ–N,a= ë½×ü¹ __!qº~-Ÿ£'˜ÄÓ½ w• Jð:ĵô�7Ls­(Â{‚tQbÎ-ÐÓJ`2xûiÆK˜üÍÃ×Ü:¤÷O:,ª.rŠPjƒ2ÖéhV˜Û~Ü]ú¹Ô'^ç†gLlw²š,îz!Í Ä4Ö¡xÌ«CÝøu5”%!þ5­;ÿ ø,ëHfýŒŽ*êu.^­å–ÍÇxÜ‚*·9{nÀG|¹ÿït:¶ã¿„°ÛŸP¾ö1¯¾õí—Rãz3uEvÖÊ0Ç”¢øb‹ê×¹ËóE n¹ iê—{ô\.-ÜÄZbÅ<MÄ·UE6‰¹úbÒ_ÎŽU)A©5ÈÊ·ßr#Êúν¸k*®' Ë[x×vVýËüp9ME)áOmìŒy£{ñmžç镹M)AɶÆòhXeµx¦d j§g:bèÝþ'35 cóq@“õN|ÈSK³åöÓ²;O\d™ùžjœ¸©=×ÝKÖ»’t/þì&BF«ÔkPQÎ&ÜÚþm.É°A¦¼âÙš¤Þl‡õ9×ív¶†ÐŽ!»g„£¨3›ýžXmä™ËâNßQT¼6Ö<iÚwLÖƒù<œ “ÂR¾Å9:Œubz›P¨˜þlMêr¸0bRÆÿ¼ÙʇPK?‡‰ó¸>Mÿ“h“%v®!úÖSÓíµ*bõ©Ä„(V)Xý$räuÖ1Wtg7óÞ(ãaR¤ÖÞ;Q̓Iñڳ67waô•U(ZTjRTå à#©òýzWpGÊáì̳¨²¨žírÞãÆ‘3H§º™l8OPÎÇ— `²1Û#}:ùÊ;¡ed€‚ÏD8I|âø:ZT3\È_(l - Ú3¯èºæû(ûh êHƒNÄÀ×(¥Ï¬Þ•Þ‡W¦÷®bG3V~U'"áÑfÛ ³Y ¦Ät&CG¹OK±å‘Y²é#q[§´ WÎ0f7ÃØYÅ–º-Y~åý×ö *xsÛÑ6n+ bËW–=_¦ÁÝžÖ¸héë}Ñ$ N`"ý®‡Õt¡»ƒžÝ?oYªÌô ‡‡EgEx‚¾ÞÃ&ZeýÄÌÁ`(“vVËŒËáàpÊØÉd R…¿þ°ú´â·&þ,&æ’x/_^ËͲ4bÀ¨E~3»mEü¸kÅUâ —q`âèï÷Hð Ãb¦˜ÌÈb3W£:ö…ŒÑýhßêË?%Šþ—$ê·RY Jq³Æ¶Wf`±¨(¨æÓQÁv/-roAG¨Ûöǘ6t«ò= gbŸ=o–¡Dî$]q½ÑfçzIKq¡þ/êÞ÷Ín5‰TjÔ³’ߥ¯™1`Xü»&˜e¼`áIêÿS\¼U¾—ž$…$ŽK©k,@öuM;¢í×­¥Y-¢Ñƒ¨”Ä.eaǯ®›ÎUqÿçây*¢G ›œ¤0Û3L—ŽÖòyl¿øݯ^zì¢lœº’*£/¯¢0è)v€ñ´^¤#lÑÐmC©Â3å—8ó0`ÇioäÖ·ˆ[žð´Í”èE^‚/ÂÏŠ±mOŸÜ¢?ªñBë~Ò ›”:`ÉòÖÉÝe3O7Á ϽíÜbkÿ¾ðN¹êj¿Ôå¶" †‰ iTJü¢f²–U`²?ýEŽCèÐôÿ»\+_-ž$èiXQ@Ö!™E[ƒ�VÄÙw½é<¸.VW 9ã"¸j—s¢%V±ÜÛ†©,ºßhëܼêÇUÌ1dö[¸±îŽå·3fsêTÓ®¾üÛ´ÿvÕ¿‡Óz÷Ue;0OÇÖqˆÀEþôT~úK;ïÙG„†-—Dív?-¿¹‘ɸ²3?nhÞ}~y½È3ŽÒ90=¶õn€¸ÒkJwJt4ôXQHšÞÕ[¸AR¥7ã(¤æŒ™Eûû¶ ò±õÔiThv²sðzÖÊÕg®AŠÈJ£szfZxëJ‚1hÛ÷ô»ø6_/(1Æ©KÕ9óE\…ê‡APņéôc¿—J,³<õì™Ê�XÖ«6D^VܦšizUB<;dFh-)¿¼û¬×ôô°]äë#°8Š¯ª¾¹RCƒ î¦h°+æ°ë­y"Ц:—ñ®ï+‹(Gµt´€ÎŸZtKi ÚŒÕVˆ“,°ò"?,}TºL¸<¿ÔÒ5•ê@TÌ>�ty2(ï»—>NPi°-íÇìx²½$ùä5ÐR€;©�6`£ˆiemøG:,¿íü,DÖy'ÐXL Ž¢Fþz€íüàž9Þc›¼{V¶ûB C0£0ÌÞÜè9÷8Š æ!PÌ\½«�;ÃËVnðsB|¾�‡Ìêú-Å�ƒpį±å’~lqÂBÕåtVxòô?%à›bŽ*ãó¥W+0 ÿžühW‡†ëß\,,è÷cÄ!KK>16±»®]OÙü ‹3¢…å]+nYT>¶â&àßÂ(BQqZ!+0š)Ôžtr !g€œ»joÍ‹8„íGºîe¸òi¢Å Ø[¨-1)Çæ–ÓÍÔ¸ yÅïø˜†#$…)OéªóM<üg¹+Ju]GéJ2^< 2ð‡èàõªÞo‡Q_`0F+Ú¾z*À² 鸕µIåVÞZbˆ›â]ñ¦^äO9Ç×س!æΧ¯Ñ Ýq·ïE°è·Š~a‘X,¾¤«ÛÆ5»¿fôÄ@¢+�Ý<eâ@ap¥¬³w…!+çûÂxvx¦e _–xÓªà œx‡vF[œ:²$éBš€ÞþÜÐ[æÛw× ±¤ñ>ìZZU,‡w–Qàs˜TäääÅ@½nè½ë“'_Ä5ºÉÛ_aÛC_u˜V¼·’¹5q!C™%.¡]'ÁáÚyë®W˜xžÒõÁ@¨°ê´˜dVÓ±]ØÜý¼/[äŽÁ䡃æ¡Õ3§ƒö2î­ò0¥òçWzqâa8˜•Ô~ÑÑ×[üÀ5…€ÖÓ×mö‚—7T ^K9­¼ã§dѱÊ¢Ï'àbn©ÉmЇ`ˆõÞêÛbäw÷‡PYÉ}Ì=ß6Åï£'Ë£°@‹xbÜ–hJŸDÏhß�{kœkQÂ1z�EœtÆ{h@ñ×ç^Å ÇÝ¥“/Ï´DbOJ¨3ƘШw3²nhiÍ2Æ”‚U/žãM²%J/ƒ®^¬jÍþÂP´ëJ]fé>tíУ—`äw~¦öE׊{ÑB/ ¦‘nRoý¥rž¼ŒN¦Y G]‹ñÙ©‡Ô–TßËï´#i« ¥ÕIPV*J•%µ[ª° Z˜UH;êÚ§©\2ƒScçVi=œ–1j2§ã/�ÙExÅH©'àR&«%î„ÃúC2« íß‘Ž|i¥bT[Y'nÍ÷ýÐ{Òöè„@Ã’{ â­ú}r—x:Ë¡ mRæ‹ê/2zý߈ˆBãv_€7'EêÊ#&A½½µŽ%hñ\ÄöBÿQ(ûŠ?à*%^3‡ëÂCXaÛ9a>P¢‰ãÑ"Ç^ÇM¤aê à€ µÉÊCcaxarÖýL%co_%ÚsÓ«º‚»2…ù×_Ï,ŽN˜õf"Õ~úmY^¬¼‰TÄÉ! ’Ê  �Ðå|FEÅá­�$~f7”D‹·¥è_³S?8Žû ~é·0'„ç´;hÖhç&Ûf@·üÖë*Hר¤c€¾”»¿vÄŒFu¨,>p®þìcë]‰“Îb Ù­Ìà«88Ä´‡ßG=€c¤Ó<®Ô#˜^dKùrÀ£a¥ß§7é(ÄhŠˆÖ~£"HØ¿m`‚àpi°b[J5~fQäêFFÑ: B«Š€µÊvÓè:üï+›=¡eù-KÉF8¢eÔAçB“y‘eT©€ÈŽz9Ò]z‚yñáB„„䟌QœË,QY+ýNR :ý©§'`²uÊ%$�_ƒûV«Õ’Ît ®TiVq<ÁØd»vèÖŸ‹‚šÌgTÔø•ÂÕwÞXϨ/¦Rå_J øêÜ‚€¾°5žúMý³Zù>y`ÒQ:NJJI¡y V¦Ó¬U‹Ï{W7¾Pñ’r¥¬Ñ‚Ç)DüóµsÏg…ÛÏP �yUÉkv³|WSѦùÔ:šÄ�e¡tïìfè67¸½09Bù1}'@úëyCÔШ¬cõÇI¿÷žˆ³Ä52äÞÛe¬§ÎI*ªm?t{ýü`48V½QžÑ¶_Hã[Bf¬ûš6¥ÍýnÅC¯¥hpvU!ú">ó: ñÇŽiº@ð…‹’i甧xúÅŸ† ½³-Þ»ä[búB<>õ2 6›Î!màÒ :ñ°Þã– Æ#T�k1¼ h†Å¢rËq¢b^[)Dq�‹YLê¸Cù6W0=;>ÿ‰GkS÷UJ^LáSs´£L1Âæž{ ªìƒ§c—ïÎ;ô?ý‚sŸEÓ˜"‹«Zò˜ÙúfWxÊÌ_Øo+ýz÷HÊŠ…•j¸¼U–¼–³–À„ìzt¿àû½G "8=eB«ºµ"Üåòº"!°‰Õ‡sŽùN„,±6–ìò à}ÝÓ§kòÐéØ]ºöJIàUåŸÈ J/åfcd¥Ñ¯LPŸˆjü·°þÄÉ{ ùxýóæÞ"£Y·²™ê‹;š“ìöâéÙV†Qæi¿­‚ý:¶ïš”+ÉóDÈÁôé„›M£¥5ãSCåÈ´üéE]oÕþuDsœÖÄ‹öÿ±íÞ DÕ¾mFºÛß‹ì9ÍÙÔ Ö§–|g5gW:‰  ýžÓ–$ÞIÏ@Øã@«}Õ(rŒ™%´ÔØÖ¢#vããé›acáÕ⎨sU²œo¨¡ͱªéÛ¶±Ëµ÷ŽRc{e/õêJ°Æë·dgmOÕþWçþýTQ˜>ˆ@±Ô鈀¨nû2î7=ýÂȦø Çr¿¾šÖÀzÄûQÉ„?j0ÆYi-‘hCÐ]/ﾞ°Zì.K¼s£L\&þô¬»¦nã‰m�<À"•2n¬rÅ\`ò!Ì…r%ZÕ®•˜c®KIáèßj©OµOÉ|¬opg§é¥Ÿ¸q~bøïÈ ÙdvÊè¾XÞ„‘¸›0GI­ÙáùÆj;/Ú²¥KC^Œ$i÷Æ[խʹ{|<^Ä´Š×\¸>âô¹wT7³¶§ÛoŽ‘¾H–| ýxñÌ y¶EKc­óhdæu‹Ìÿâd;åCm<çì:D”íÀ ” rx ¯îŠ’6㽓s$žª)ÔL+Øé0²¢ EïfïàÊJ�e²3Ì”¿ÿDZS_gEd{ïSåËî´íé_XõFXï1Fõ¶-^éÏç$Èe'’N1ÛšØ[q{qûX#§+ËDªi {÷Ÿžc­í‰íÇz‚Ûë½µ EGŠ¼èÀÚp%#¦ ¤ÿ„lŒ3>Ï´VYÏÉ™ÅÍ:¼‚ºWù~ñ Rw‡šà“Ó˜¿•/ 3—^�Îëõ`§ÏŽ;T)ù£¤Èàé^€,§ýÎ4ÑÒ2ä®d"ËJ77Zv”\áÓÉìÆjÙ!ú1Ûܱ#Zºé|#G26-Ç×Ñ,©§4Úq°ˆŒOÖý7T]pñ¤¤ëyï¦æ¯™DZ`GaôufÀü³“å�¼ÀÐUMnÈ ²�ŽµC æ“£`×Øþrœ.:p×:Ó‚(¬Êyb« çÎ «é!QU—ƒ3é¤>ª/Ný qÔ¹hU]cŽrØ(Rä=Áy©Pz™[b X=Œ#j<ý™L€A=6Ê|“B~‚3<ˆ z m� ,Ó Y¶ª°Ê¹û¦wîÐÃÆo¢D ·Þ#j$ùÒ¶yôISGýââ„A‡íåƲ© W¤ö ï=vTdý0"Ó&wô¾ªÊæ©‘Rsm…‘öøžIúºç5Ä©¸Q@÷±ÉB3šÑŒ™wâ” ÅYþtÓƒ®çElÓ½K²°°Ã0z[”QF0#)¹1b,g<É}/ž‹:hŒçgD²ïÙjNþŠÁ”Ô7½p•¯<¼z¨]ΦeæÌà3uòW.Áßø;Ët…ô7`y8i é¡PÀV/ÝpfVžý•c˜Ö`µ&”zIg5X}~†¹àí¾‡–„…¢øWF¦¡sZzx>Z¡}Ö3cô(*¡Ocr*ÞKŒú#%‡qmY8¤1 ˜©nÑ“È}¬Ï¸ñÝ1¶ÉJßþkUЪLƒx¶^x( ã3÷@¯éËCr¡@'ÒöD'®þz@Þ ä?•êäqsŠ5Ûì•ì$£áh5n&Jì;H]A>[º")ààçý¡vÛêûŸ·õ9ñPæ úůüoÂÿ¤+§Ç‚õZbóì¹Ó.F+“QC|‚ñéfóðÕ#µp£ ¶éØé»2šUeXä]¼9œì€ßïƒ8\-è!™Q̪-(+[sZü×61{"x1´ë‚ä¸ã‰#¶ö›“‘?·9 )NeƇHç²M›É®·&0êo6XYòDö݇äjö‚4Ɩ݉2º™ŒÒŽËz/Æv€ûÓA4JôÛVÆëm:V×ßš®Í‰s\øRZF²}šQ…š( 9=´×·Ž³÷Z™ê–nMá )s¡3MsчëÛóÝ&Yz† '3ŠñæïÂ0‰ÊeaÆ8’ªéÚßê<Yf;eô¸%»b h¶«v ¯Ò5íL5öö¸ñ.ýR"/|L Ošr±^£Ø$øk}Ê”ví;U<³—ž®‚-0v¢3a§ð4'CÿóÆKc¾|3fŠâ|‰%b¯gkƒ•Cõd;­/{<‡©ú…¹R�êŽæÚ·<ÁcjÞè_^úà/¦ô!†Ðn‡%h¹ÑÖs±ZXsÿQz®|CEC<C;³‡©¹ÚžîéÃ?ìO¸ƒ½0ÅV¿…ˆí¨"¹²:lV‡‰Eu6I•§D€^Ü<œïéXHLj¨kJØW•<ñ h?JÜ7±ÃB¸waûLE”úƒ´P†çE7¹ðEëB|ö¸CùâìÜŽZ¤DŸîУl? JÝj˹™uå˜ödHáS xP7( &£êU ª=0e³wºùDÅÓ–; ›(]z·vÌ$l­­"2‰®jè}÷ó+Ž I/놼+ÊÑ”›ˆU'ò£æ‚|äSç'wE²ë¾KB‡}ãF¬ÕËf}3r“-^£|;ÙÂóUaû8õTûhEÏ#}IšOO;¯†ñ,fFß*ƒàøŒ’h<qüÇ=G‹°ó»‚÷‡c¾é|bÕ×�ýºîÒ/C}Â8¥ªkÜ&p¾>z3v<u“tËÏÇNŸŸ^á/YÇè䙋 ïkΊ÷EJ.ªJ›æÔwoRÆýî´‹ì¢Êª!í� evÒÅ­ÖþÃóÒCüÉâ/#…jGMÐËP¦ÐÖ¥t#Lû¥Z­"Hr̦¤|¡ò$¢ mK"3XkÆê"bDv ¼˜-'qêksP¦}géå¶BóÔ¹Þ£uüf&jniÝMü¬Z‡èfÂ]6Ž¾“I#>ˆê+ñ=ãN4JUÍ�Îm…5ë—1n­½ô¾šÁw÷÷ö~+wö%¢ tkd¥P�Óß@lZÍ·ÐÖ4vª§9öØš‡¯SïÜå¼™¶º“€$èj^ûX` OAèsÎø€!N ÁŸýšjVÕ'¿RŒzö_ÙĆ/ÓŸ©(˜Ô†e†ÌÑÅ$3Ý=¹ÿ#Áz™$<”,³,îØÄ úeáN墤òë÷²ª»»ióøªÅ ÷‘؆F áÔ ô‰ñH‘YÎ'K>ëšÞgóדG¾ÉC¹Ä0Fœ·W®WQ\izBq³<jz.Ô¯ÙÆŽ  ó-pû¾›I¹ò5ÂéÄn×a'kºro‹ºqyƒ)‡Yb%òÀ}¡X»EÛñ¤êšÂ0š¥)lŒÞ*¨‚ppt-€­Vlu]Qæ+_6:†¡ ò¶óssæ¹evV|sù'=œ^,há«<:Ú«!q U›ÙtKÕ.½½p3ü/Û<,’T’?h†äÅÀ¡ú¬½d•©ùȵÔ6í;Ù>×veF.¥dðT¿-‚Ô ¶‚ʾ·c/|{—:‚~þ#¿ñ^ƒ§c­‚¼Qe¨‚ <DQG¾hpŠyUpiÁçiãmnì”zÕœb A·hg­œV2«£$žè#î×ûº¾)Ölj6å¦õ.JƒìóË×x DuAÚ󛈎ó¥É+3³Ôé¤J \æ”9`D©@ò‰WÃ÷ƒá<ºÂ¨õyPNº?»Q¨µŠG†EKòǽ -—6U2¦µt§Ó˜»v±¸>v?-Þ5‘:ïà Èø4z„;-£ÔcL$Ò]剱U]EѨ£!öµF\}G‰WÕ/ov⺠!W¤u‹ÓZë¤Ô©›øŸÝòå>ËÝô+÷ìš‚*ÆOoðl†�rw[®’w' MåÆГ?:Œ—oÏåÊwL LqwJü")Ë„óä+›îN“xý0ØK?ð»ÿäëð ~•ƒY[ljìÚÒEAµÌLÊèù«?³Z·T&!IÑ3Æc‰:kƒÌ=Ümuönÿ¿ü`¢|åwòèÝO5ÚVC^äšòwœ¾Ì‰j/{ˆ¼ï=ë›0õ†ö�ˆÐ—š:—†Á7½l3¸`¸,Ø÷®4BÜü€ »SÛ€>”Øl¹ÛfŠÅ¨¼(¬iIjÖŸ—AØ‹(0€VtÁdQ^h¢Cß7•šWdÿg¨PKQÀì bàÄXŹq‰üÁH+ E!hÆa/ØÞLj!03%ˆæÆ’i·MƒÕ¹Ö¬ÌƒA§xÅ7|ôt4ZýìåwÏØù‘eçdž£;1Ärcõ¨†s?µÖø2Cý0UUw0cÒæ±™wÖ”¬Å|ARÕ6anÚ7ô¯F3Œ •<¶Û¶__®YÒº×#TßþöÑxŽ8XËך�%´*ÿr�nŠ))t.>íÃÏJ%Ãè/�dºgâU0ŒLˆûU+¿ˆ|ŸhzDXqð®3‘ òÓ§®f VÞ?»ì^Y€Qœù (¹ŽY«Û™s ;Û|ÿ~À†«4v9ÑŠíd² ž”º˜ËüMdVMPÈõIÕkdÉ.ämïü¥ðä¼0 ¶E–’=Ö§õÇ0¼œÞÜq#jp@ÿ~ßÛðL;§Ñ—[ƒµ¨k÷<B¢²÷ôø°ëö˜ôj¬Žï8¸~–×ØrRdâÔ ‘Úù³Þ&¸5BBÌ‹ 'Ókª72g¿¯�S–ÎôE)1ƒpTçútÕi¤X¢ Fµ÷©!£6€³à!+¬á÷› -LóÔCÙB\Îj Í=ƺ°u3K,àríEúFšGqåÁ–ó»×–¡Õе¶˜z(Fñ‚YRaSÒ‘4û¶ôCõÁéæ­Áâ’lýADëCü}ÓÇIôïÞ ;ÜwýÛq˜Ø›B^=Ø;»áöçXU‘ÃRœZ�Éîì™;p£¯ahøׯ78ß\R+X«y*h·5ÊtCÿMpWfÿDZóaI±u“äÁê²u X FIŽX”­»Ëø6_šÍ¾ûÙ·Þ¨„±d0Ëi¹xûrˆqã3W5m§íe¶PÓFéîò ŠÔÇîäôèig÷GoÖ…ÃAµ5h“0§æ%­xµoaá‘ŒŠfiÌô91ÍPôTlŠŠìå»g%ÃÕH|ÀZ©ŒhØûZoM(¿Ž(þeÆñŠ—¯:žŠ‚1xÛOYíZOaëcoÆÑz@üÂI­\˜TS lZ:‰êOÇ£½‹·M5¸ÉÕMZ—€œkæ¾!øN©OL6sñËƧqAçÚrå0þŠãxä¹FºÁ«lŹuà iãâãcÐœéÙü&Dñj-àdÅvm$õÎ3b:wìEO¼«ê‹ž¸ú~Ñ\÷J¤4Øi[7jÀ -_§:˜æ·½x¢Z謥—L[˜"Rþ©h~àßjöíé±¢ä ã"¸]í'ÑÆmêã°ïÝÜ̉/GºíRŠÞžÎ%+«ék1Ç´¹”éqiaYªA´"̼ú䩺Ÿ³–å+‹ô^‡ã‰?^˜e»_âîoOP¥¯'«#1ì¬è ŒZáΛɕ¾8H²”eS™8ˆv d©B‘= ¨ÚDû©Ù|Óöæ–_µ|£HY¡ È¨¸jò 8Ön¾ügjëé c7Hõwí<sha‡ò;Rj0u=Ò²hk•Â°tmÅšp~ýú@hRl¼CÄ,ÿ(ñ÷oÛƒ&l_ÓOn™ÍϨ û»A@æ ÉÄq¥ëèXLì\*† +ßíJ(€P:�,drK»Ïl!§ ð[MÅr>ùp;&‘ωKMâFŒûšr¥€.2Î,½õ¢£´ {=yªOKõç×—p\ºyH†cºÎ3×m?Ǩ‡pb/)¦ ÐÊî“p\ÿà™hlšùZ‡°�„$Pÿé¡Àš¶¼z=sfÖ[°epø ó­èNfm³ ­j®«$qåÜŒSðx¥C/pç¦ÿÙ³ï<Hfn¸éµðWULÅü)…¢}FP0ìo$x›ccªºýu©ï=íÈ@>Ù·.j¿|ÇʺúÂs47héP÷¿ºÈWlf-Ô'¬?5ßBÈ wÒ%ö¹>d¬¸ÚËÁNh%uGo¬d‰ŽJ»kãaºÂ<—lÈÊÔW¾äï\ŶqÉGÍxGýãiÍ/8ᢋjŒ/Œé×£ÿâÉKÖA|‘ÎññÝOJà¶%©´ANR-]½.þåjñÜs¶']V*aÎJYÌàj=Ѭzèø¹²!Âk%Až:Þ;Øà ³*’õµ­ø^ß[ØÁŠÁÐ?Z™Um.jµÞi«`:lC¬£Sþ´‹ÝÕÕ$Ãa#ã"Ú\2ª”ÀÓVĈ®€A\r_û¼ï…}‚ àœúÞ‘ÑJœÄ“÷G5Ü´Ý–Ü8!Ä9ü±¸cz”¼¹ÐG=Ú,ŸeÖÎÜÑR\4ÊH–Z½we˜³¡µî3è£dª¼Û¼9lܨַéƼ<r8ÙÈÆ=¨Ø5ž¿t‹a›QúhlHõyP…®‡É£¡¾ãTqtü<X¹#€®1ãdl_‘îòŸ…§‡ìm¹•Õ“•gK¿‰g¬<•B³³ó­¾6c ó"õl$àÚ ÓdÔ"7\Ê‹6•iÀïyÎiª éŒß ê¡¯Å¯Xå©´p‹Œ+~ewY/oÕŠÜ'@âvLön3U¨ó_,CÏጱ?ÞYÒm‹Ùwîæ't¦D2û£ª ŸÆ�`˜XС~^5´Ê\.T¢£_g´1ÖÊaËÎ;¤$<´ð?ü«‡g—E‚Â;]“ÏÚ›4:OHOqûÞÄ5IÓeª°k轶“éeL:8”¾Œ?÷{qúJÿ,QUï¢ ¥àœ6è(ïŸ7Û¯�¥sK©«uV}Åoé•ù¾×%þ¼ËE^7Vhg3It9¤-ÚµÒde«ñÒò&»¦XwëÌTX=zêÇ$Ö¶ëdÇÿ©uRªë!âÚ=Ÿ³´9{¨8uý@и?EDF…³}âs]úºS%C­/*ÆÉ»t{žÆÞ^\/æDÕ€­¸Â¹§¾RÓ4_b¨Á¼jJŽÈÂWUJX1ÞÕ"‹²¤H—bÑið1ÇA\[îmÎÌõ®U a"˜½/?b¢Ä¹oí¹©]d–ñ_0˜ ƒF+nAQk®{ŠôGlha˜¼Ú»D 1LËÄÊ0Á¦ùxñt2=·#•RÓ[ 9Ÿq؈Úp…ÕÈ 3RR®¹D.üO¤]KÿÃC-ëOoÅLóIì‡Y)àÛGþ'. Ô8ç„„ŽHÈ“„}ï™ÿ"á­¦Sxn*WŒG.¬QOË«ï®`´ò}{èü:0yQêéëp¢ôsß5ÊH¬» Òhžjaž]w÷GúÈq­@ããxjØ#ÄzzxmTÖ,“>4fún40Å@Å©ØJdu\« h&ŸÄ<vkÑ‚ª�}Oz°JÀúô =¥§7:2 Ÿ¸h7€¥)ôïMÇ"tGzníð¶:nÍ\Š•Ï3çg(BîF'…žŒœ¥mô3¥™8T>„í;²ê•ã‘Y>Ø=å€q2㯧”G›‘Š6k騻ŠÒïM%âMôöçËüF^ñ´Kí…’dØѶ›7?°Ù¾Œ2JhCY*ënÝUG†ú‡ú5’¤``f;" aÝ ÄaêÑ^(tõGvZÖ¥p×Þ׈°§ ×p^=°L(Àýþ¬.Nµ—õÃða¯Ƴ³1ë8qÞýøß®þ“ ÉQÈ›bÙs7b7æJC:ÌNM×ô[ýÀ²tì|.¬Ž]$m=Ë]^›MõVû8Kú2so¶í×wU}K­;;} ¿áôÝ ½‡ãÇä2ÜCµ^wÏãá–m$ÈD¢èãWÊ—Ä1×/ìßWØž³c½ t³ôÂ�¤§Þw£sB©1 ±¨ÔùüX8MÙŸ.yžI!òÝ n¨¦°®ÐI¤êýº.·æn¢úÁ0`Hr|y$ƒ-ýCk¨·ÞU8¤op¿ µ™XXiß4G{ÚEå'­ÃúÔc1ʧó®_пr×°`M÷ŽBZ:nœ¶Ju¤¼²Æ xî_°-qäòÐè@×´ "'ÚØƆñ®r¦ ²”ÇĘpô×ÀxÍ*­ærèÄU{»æ}Y;“‚tG,ñõ±B ÍQWeÅœ& âF;1²6ñ¢¹ªkù¾ß^XvÓÊ— £w=vi#ëøÄz¥ãÆ~Ô!G=4t+ôEÒù{ðŒ(Z­–J#»*áüË¥Ž`29®ÔxÂ<>EÝ…aî³™¨v>O@ÝžýEÝVk£`,²Ìë}}£?ejï|¢Ô§ ¬Ú)ånôú}gD“ËäNÑeìøù”{¢|¼²w§žà§&)›ÝT(ìñÉÅ„  w@¼mÀî¢Üû7ìr#€ËÏË4Îc$ïš}ž*  L¿ÑýBI‡a™õÀH g_ô1"OuûÅ*h£}šRµÚy‚=æ|ÒªaSñ×¾ú]Ó4õ©:àùâ kÕk…Ó5è@9NЉ1ÏøP]dV¶k»ÃdÔ‚—n ËÉŽàÃk»DÁ7³Ó —‚/=)ª5Y7±`þγ«…>úÁºêDiÔ˜žÏú<3Ë#7ÑI0þw�]¼Þhsú�8QÐh`Ý“f9[*Ÿì,ÊÉ;Äi”'¶²¡Sû2$@µ¾€Ò8léQÛsÕ¡”â4˜ÖÕ~à ~l:D³9O¹ð+mÈã"°tÚ¡MƒÕQw&äs@Å÷v~¡§Ø£ÓÌú†„™!#5-½H©(êÞ ‘Ì–£±SÞûÎçâ†FǵΊ |ÿô²$Û¢êW éëã–U¢þÒ¹a¶ÒJ¥:üx²i‚Ï^0'Y;ýVdïÙlmh¼+{Äé•Vû…3€Nw×dÆR#V2›÷(‡Žh¶³)ñ\mogIÂHCß›‰‚ÁextÜz*ï'úì­šGo$vU_|óÄj½ðª”-Ã#1:*— b>k+y+&©§êÙà ^ÈË w»ÄúáÜÐã(ÎÚ×f¤Ç¥e>k¿½bÐF©ïÐAÑ*HÚÝ‚c däî|áaÁSDîÞsëš19ãÉ‹ÎÇÁÅÙë0|7ç9%#Ö¨&ÞÀ>[Ta*ºJÓër²¾åQÆû&§gq«SEo¡Í†›<™»øîÉr:¡¨¨J#ó®5I’94¤ïi(O³ñ'Š1yæúî<B]`V5®¹$¿÷33_Ž)}ðŸ`8\bò)-©¤·Âj»Þ¡ç]ZpŽÒvL³™Èóð-2næö»áØ:UÝyÑOº™ÃÜÿ©/§’l9åÇiÛv;0N7÷†nA÷%yyœ'Þ´ƒ½]çϘ÷¼% çÝtëÏÕ~Ë“M{A¥+`æÅ–G†•ÙFA1NÎÍÂÞ&äL×@ŒÇšÉ‰ï ˜xA5˜3; Pa‹ª,32,j�‹F¸ë f²z1^„î份±h5ãsyU2<šj‰yVû. ?ŒúHPÛøû¾Ì#cd¾17ŠVÔ<Ô{N¿{ó<aÊ¥š•V £$¦“R�R‘ñõJƒør1½„‘瞆õ7Â;ᢕ‚£J3ªš7tÇ7½ºw¡Áß â`lÆ=sÛIU=¶ôÇë‹_€ˆÜcJÿ‰¶á§5<‰ŒJ…åí?“ö¿—=—¥ý¬üðæ>.ƒø}´5•¢¢dmi›³ýBá¤äsª.|„Boè9‹©/ƒ´²hËp‰%<¶gôçÌËyìX–5ÈÏ(­¨v‘eÍ¿- ƒ•PÖ ©f8Àh½±7–·¿h,Ç¥sî`9¦cøO¿UŽ˜³é1äR;-@‚­yè]ÕSdüà*gíÒºhsw£ÆYÀ$T-V}”Ì£áŒëO…ÌMR¨±UÛœ÷èßú-ª2º2^†˜'Pã2K=ï¨AÇr·1­=iR™±û‘²È'ê#8T}}OûtÜÏU§L¾‘Š)Á:ȵe» SŸZÞ ä×Ù^èA/¼xÏÕh¾¼Ð²xm™+@¿dŒ ö‰­Å%x“ÃJ©rÕMtG6Í=š·)wp·ž#» ½”•-‚{u÷âÄo¸±-XDVÉt#ÙŠfËzR§zÅkø +ÖNV"ÛÉ+”õš0°V‚hîQ—ùK:Me—±9(JAqQù«¥^/,DBé ˜’ý¾Ów^N…ó<jÓ4$iN:Ûg/'ÁzÁÌ} ÔÐñ4vûö´øøXÕer…Zÿ‰s–ô6J™¢uü§í.¨µÃþ°XwÿbZù/·6žÿLr#ç™_—L¯JæÏJòÀȇ6L•FÙ«¢³õsÏCrïòÊ™º´+Vô¹§œ6A×xS#ý¯]‰y¦Š‰óa.Ó•«÷\µàW¦IuFo[+_>çµ ¢kOZÙ0Œø”ëj/oθ̛Yc!»¯,ˆ¦ÆcO îÍ.¿ I.FltðƒUßÙe~fþ®•ÂÀ‘ïÛ­ª²µ“ M¡»e©îËšÙÀÈÉj9eÒµ5]÷¶a•Åó‡7·¿ÂÕ¢£O7‘KÜÙó;b¥sôù´©t¯ÍüÌ•'öº•gŽþ’V‘> _Œ¬ øö5†àPör9$JŠûŠþ‚ù“ÊÜJ¡ŠÂRj8ìÞšªNŠtw!ãQJO=Ó¸E‚ ºZªzL¡;CÚê,¬LYF7N?øÖ LœE³q—Ånã yya™üoÇòùßh G…§HŽ¤cKo¿%¢cÝNn;Ó7§þ‚­Ô·­í IšÁ‹]+ºèÉ"]´ÿ/è¢|êÑ’òï1ø~sZ ©¸݇pÅ¥¯M½JƒË@éküW×&—ãxšÌØU_õEšyî ¤1TÇÂYp¤Aqôg?n÷ý¾²<  rýàÌï ¤X GÁy÷qôîôG;öUg»_Küãw@Èă³1Ê|½££"ꬪRéÉ*i¢qÄêb³Ÿq¬®GO¥ÃÉm­ÜÙj7àÆ°£„-› ÖÑí%š·ò*2#¢)ôÆ« Ù©br–S ¦›¼P¢{ðUzCæíLx]6_ž×(†ß$ÛÞ êë2ÍgX\û×ë&¶Û=2owé¹L¨ÈtMÅzR}z~‹€sˆ—Ù§t/†ÇÌ«I2ÜwôŒ × »Þ]Ù,;åáàÓÆ)²1l‚ÅtãÀ[p_ÉYS³/æMßÍVžî<¤2Ù3;€ÈXÍÃ*³¼àÈ-å´Á£‡ÓWl2*T¾gFò ×xO~QÈ°ÄÉ̲àïúžX°Ò=Ÿ¯0ýÀßOG÷ì9ÅÞxƆ…ë€  ª?C¬½_�ðæùTì~p§ÊMî;ð8t;<?é2gÍ¢éVãDÁzk«MþGßSQ:íFšû8Èv_Þr£¤¤U56ßì‰ð¦½#"fI¡b}¦ ´™Í”‚mà©TgKÊôìZ{<e7ðqù¢Ç*AëçQ•¯ µ] °‰¿*´qcÊ”Q­ÐÜ¥X´Óî·õ{&¾ ¯ÂWÒÿõŒT zŠõp©æY !œáÈ}ë‘|•øÝÑâutx6bDÆ/~[{ø ;™qZ‚3JU:&m³6M„5txzx÷‡!%y¡!f£œ"È¿&+ f²„(,Zd\\Í‹Q•²R~ôÙ/‹JéQƪ´§ N§@Þüô¯Æj–Ÿ%v˜›/„óÅT~ý�3+#ÆgYÈÜD”!_ó`pîLÝ¢C º"e«[Žrg@�Õº¬­WDZw P÷ˆÖÏ'í¡ý± ´i¢Dïb§p ¤2`=h´FxU`Q]Á# fžøj%©(ÔÍ—Iq#*›6¾àî’"i4}`ñâé鑇Ÿí–ˆS/›)Ψ=Í«@iáê_šN™gš—0];ÜUFÓ½Óƒ]»7ÇIµlÒ½ï‰î󞲧0îöE7Ýîx‰¥_™X#tQê=e\.òm¯S…D'm±þ¹zÄìVá9màoÄ“ôj]ÑÛ·S&(Óbh¾´PW9 ë©öíUŸSGžE¼ÐùÛ+V'â©Ò{Z³dœ¹àçKœi™ftó#Pý–=$IJ§$¤TˆO¦ß�gú÷è­Ú?M ©úºxôtà=Aª@/ø¸ñ¦qò‘-¢ÉJ%Ý»ºü»òO•*:Z¦«‹–bPÅJŸ†Ñéz ®ü«®)‘÷·°2íî+ +!Û;Ą̃ºý¦ú²¯Ïº iä©WOÊ«)mÕH:v1ýàæ¶wð%?vªûõƒà€�sCžáºÙÈ@ƒËÙ¦ØB㚨ˆž ¨½}ËôsR¢2ìMÁKNƒä¤ÝŒ"`ËSëéewá8\î¸ÊFœlÐÂ>-_iMË=?&Êá#üÊåƒgѦùl~Š¬ÉäuOš={Ø,Øo©0·Â(˜G„Ë9Q– X¼_}{_<.©Ðrz:zícUP–š­#sh'&—‚:x~ê˜ø‚¢€še•2F«L×™ ¾ùTpóJ¿}uOF!-=± »%yPì&ß© Úäåq»¸ê¾¨cçB0Z?ÁôåNÕþ°ñQ>÷Rˤ{M”ˆÎë$_y&ï@žµTþÅ; 6) Ñ¿`~£×Wz0™'ÜÀ¾û#äGEi _Ýþh :íÙjY�0¼µÍáÔk^p‡ÜzJll[µ?RvPMžÄÀç ƒT•bNqšvlú$<æfèÇIÐò¾àâNéx¿Çbß´MÎÅP¥]QòŠ‚¢•M¹óƒ²(wc5ñ&SîXÙj«­F õd†ûš^¡ƒ"«9ȹ‰Ð;°í ÀO¬3J_TgZy”ã#[0=ë{%œ§,5.‡Ž²„™¦ùù·¹«ªMñõ� KùYel!À7ÕÚ)ý`ÞZ—µ˜áÏ)XP”‹4>è„J»·F­àÞ•?øµ©f$bnp ª½¨zÏ‚TB´ºBlGZ¶Î!õQäSç"ª¸ýHûvÕÛþ b·V"µrÁ9çÞúvÔåê2Ì~Bfüù×&5‘¨u7Îãï dÕž÷Ó}«êÄI¡ ìoø¢ìŒásq{Æ>uèší<-œæ±a£hô¹vVBÑFyV+"3ò²Œâ¨hñ€û[™ƒg¡*˜º ´OZ;ÑûèÙ8lö8mJOÁRϯߔ¤ù*]-ܼú6ŽƒÄaÕòò”¤eq{¸÷‡¸¿ßp>½›ÊVs­ÿ:¤ÏRðþgót±T`ÄQQóî)Ò�f¦åh“}óó¬”ì,J”ÇVÐ!MéL×ø‚™G5 øS ØÊÌÒŽ£Öf²D:ÔDf†þ=åWñFae$rØzzT*¹ÛW-xÂt•Úæ Jäl¤ÇÞí§Õ˜Ó8Ÿ½äÆœ{¢ˆ žüð•PY©Øiôäéã~-P³—/+ÃïÓãÜžèXÕŸ÷ƒâT×jVÉt}ðƒ}\KiðÔW D‰4EÒ¡ñÎ" X8b0�˜Ø™bâFxÖKâ=' GóûTa¯ô2(÷™èiqyBpÔš}M¬Q“÷s €Z¿uÃÌ™HËx¿-‚²i¼D¦n òÝÙΠŒREØ®¾[¥†Þz3ØrnÜ„vU$gå`¤pAÍqÈLÀËw€¥§ÔŠ øÔÉqC¥É›ÈýfëN<kÕ.Œ<i”´ ò × ‰2 3ãjÛÑRÌÏGÓÅLKXŠj=XëÍ{ì§~8óx1‹²ƒJ«¡Äè×Õ¨3ºPOk¶ÌúÞ%±ŒüL¤§žN‰È �e‰Ñ#ˆÕ±ü¹B­¨ŽVÊÑWAÒ½q”ògeÃjåù°uE¹Ñ¼;IPv–VnÜì‘^èq-²¬êñ‚ T!“çì%…úsJÚU‡‹U¯@ô:@àÌ”7Îoã±óFºl£æT4S1Û«ÄðGÛRe6¹å'Z·V0½bj©Ørq =PåÓ[8Wè�qB±B®„eÔ[:¼¼á7éªç›¥¾‚æ/¹¢Yï çÑ·Ž<‰iN[ ì+Ê‹â´Z¨{ãÊïwMâ)ze¬ºÛc’çLħ ²‚ƒ½¹X@%bß®›[ s%ÌñŽ”’ÆS^q\±þ9}Ëhoy3m¹ø½—<cñ0121M‹ùq­Îâ8c9Â"1$oºsî9W ?×Y^×v£Ž³+¿»«.…0ݺåú;Ü—­CÂÂXÒ¢'™Ó�Ž?BRî+íϨXÍ"Û§'õs¤„"ãi?ڟȃx6ÂwÆE:˜Ä aòÃÇÓÁ”ýw•ùž 5m¿Ÿ¥ÃO5;957õì«`OaÇ|É¥ÀwsfôÁjRô$È2×±²ÞTÉaå®t”—”>r Yú9£à¦óœ<3¢ž×ÔGMùÄËúE ì-•Ñeá»ö0½1šI‡ñó$˜}}]@øËÈWƒt6FÕ+cn1UjÚo†èn<ŠnÜ5þÂ'ÉÒÑyD 4l …#h³ï÷X꣥xLí–ŠÉ]<Ž¹pä´†èâ×»LCâœ!Ð( s_€äd\<#}ä0c‡3*¤\WÀ ]Ôˆ3Á ²mžo͆ÒèöÍþ¸}+³Ui:œ8Wm´ÊιSÖ'-«Ì›.ŒwuÃ|Š$[×uÊò2–²ŽÌéÁ€†73Õâ8ƪõZB»K]¿ŒyD[Ì<;®·iøÙ[Ú4�]kßþ Oøxah}£ C[˜àh·†˜Pþƒ1g­ Mj¯a Z9ð–/wú «Åo*iËQQ0kK^:w‚!jײ¶½«G²¬ìLÑ!’91Q£^ ´‰¬¸¨ƒáÕ œafˆôz°MÏ_uªããQã²*¥!l…Øs(&ó§°É0Î-8^ºõë?YU(8ÉÒ‚›f¬as¼ï´×RÏ'•)¿ç‘¢N8ÖΊ*&q¦ÔÖ󙿽¾rþ:Ýð :˜°,‹ y×QSÂrh“:±ðyÙÒSe§(qÞцH"ãÊB î»éŸìÚFµbÛ±ñV¤€IgYoÇæPG:î;WÔƒH ÊËUlŒâ¥ïÖ;,nUž q‡eˆ©âçS،ڎ&2¸«‡+ß„di¬ŠmT¼[kŠ…É’œCÓü.¾ýß÷¡.,Œ¿Uô#UñÑñè‚…qž™~ìuÖÜ:9õÛêò°±‡áb*s;#³àÈ?8Ýñ„RŸ65¢Ðè…o3nS¯eœå<b؇ɔ‡F°²Ïˆcy¶ G”ÁySñ¤ #¸dÌ1†Ò&Þ5:ýÜÒr\Cèó£5¢W×A8ÜGgÈ�Ï—ìc¤D\í5½7[úÆú"}=]ªH¼|òú±è•\Ìￃ-[Ä?k£ñ4¾)ƒð¤lt˜(÷™ç=fXCwØìÙý¡” Î­åÑVÜò ÙýõÚöô§w/4ŠÞ¹ý/}ÅÂda…Ó„‰ìÑS…8RYé[Ãr~àn›-4çÑ7¬â ¶ ÅH›ÞœÚÇV<¶MœkŸŒå»¬:*kSymíªßµZ4Ú᯽£Q~VžEÙaJFá#Rõ2I¯ã�S4)C¯ý2‡°HÙg¤¢g»S›¥P„bÉ2ÑÉô†ÁthÜ㻡¨Qº¡lª*è ê�4?d9ói›-ó¼uÖ4(ÕzhˆR†þÙzH÷v<\<¢ÎK"¢¡çiç]ƒ>Œz­@wQêqkÕýšg´Š}_HµiÈMõÐùÒ0ÑÜZ;ð†‚ä}IAÛªQüŸw`GÚ7ÆÙSJÆ«ÎÚL¿Æñ²Æ• ‘@ ˆz‹£ˆbº®©aÃJ¥Ö0°k주ßðZö¾ì431=ßFVíèÊYVï·’æ€vòç‹9\´ÔÉÏÑÇa@¡zBQì†!ïìÅáýæB°ªÂVºþ‰3è•'•cý1I‚¼ûô´GŽÈµtZmóÖþ©‚õù€¨‰štSµî£ô ¸WÐâ/ƒâó¯¿ÝqÒô'7Z›«ƒ{qƒ#SœÅŠåq¬ªwTÿÓv´_šÊvWÁð£jVE¾3îÂÕwhSdŽò¼LÝ_ïÈã>Å8À+p‡ÿ³x‡›8,„Œ™-4Á2u¬<%š éé¯g´ ¹‘·C{ž~æs—§¾Û:j<Q…½Fm+LÙ`Þó.2/Å%¢8]8ü�x™iS»éÃtD¥jHY.ãžµ(g¶O„l \fø@øí昲ŒeÔ9›2@³}«îtð·ÁÅ­a£üUpHfa õ..Ä»øÌÝ™+k§'~q´òIŒ!¶bÖP±–¡Â¦âbíuÉ/až$‡!‰�3[³=žj¬X6N¦N£;Èö–k¿¦O–Ü#yèÍ6Tž1šJø·DÌ‹_ð0Ñ'ÌYh/³],@Rloߢš‘N|-ö˜?)M²#5TeV6µªÜNhGcn^îñîB×£3¦E±ð©Ræi¡kGJåœ�zxõ¢og p°]»"ˆ:$÷[%_î7²ØW£‡2:˜Î¥ul€‹ÛÂâÙhŸºÃß$­Xgbn-xjQã¿+—‡‚ûG+9Û·ì´ÈÃ%±Ì`ßfPˆ¬®H7&�h2C_½ßn÷ "ÂÝ" cÕŽ­P Ïi™Z-Ü´rȶó ˆÇ¡ÞÃßEÁ-÷$¡îˆC¥V’=8TÄAþiÕ·xÆ7|ØbŠ6àÙ„ó{—|ºVóšó &b±ò&¤*é”ÉçQÇ’¹‹BNgdÊé–ÏTuÍD¢d1€ LóܧAn#4ð²b'!€i©·ßót¢ÈS#æ¶ié-?=s·ÝpaÛx©§,å„@¿‹¬¼dªr­ØÅôîÕãg+qñÆ\r%è<‘q ÏHÌŒ¦Zï‰Â ^y³Ön´à'y¾í_}ë›/)Åd'j»Ïå`X³ÕJ @ÅUc¯„u«ù•ÄÇQs÷*þE­ CœNe›ÓÑZz#zRÃãKWEeÞŸ H´i�£µPxdÅ�oQât­¥ÓÏ¥oñ9¹öZ ãí6Ð*ÐÁnüöï[ÿÖÆ»ùAÿO•~›‰CVCÇ´D¡áu´&kõDž‡ºZ¯‡7”f&oˆ(í÷z¹q*~ÂZÕ~«³ZE™99@ú¡øKç€üÊl˜‡‹ïÓX³­¡ñ¿ŠçroŒËÃõݱ ¯“³Ûf1Œû�¼èb�$¢ j…„Ûâe¡Ÿ(Âf ƒ›¯­õª…Šý¯;L+…cßµ‚†ÖVØõ«²çFE‹þ×#¡Px<­Uj9K¤“á.1ÍRÏÅoUý6ã­ Êñ+À/÷¢«a iŒ¥Qçù|ל•Qž¬ËU\Þ=ÅLÜNÞ¸¢@{*rßyXOY +(4Pe]:¨#zÒ.h˜BÆ· t—·÷ÄÏþC–nCÏæA]Eé\j…ö›d­:¢ÐøÞ´šú2û@z3sVÛ⟷Òw)Oâ`[ðÆÊ› ¿‘Ñuí<Ýõ¸Öž´g("®‚¼R>‚ÔóÈ—÷´ ÞÂM©�×wkŽlr¾ŸEJ×lÉ y i©*l¾dubsÐPÿÊág sÓ3ÞÃ8u²àŸBxºu¥Ø轤�æå ^Œ¶„›¸ŠhÑ‘â—5¾f™i|^ö’ƒmýÁUô¾@tËÛ>»ZØ€X‚²[c´¢…–±1øÍÿö,bKXa’¤¾‡ƒŠèÑnŽž‡Ú:IlY0]QÑŸ|*0d ÁŒCˆ`µLOÏúL!ë>ïöÓ±eem W]ýªé®ÓÕãæ/ÚΰÉùÒz±ùøJr}ÕGk«Þ<·o­¦ ÓÔT¾ÅyN1èžw Í¿£m–;ìÇ*TÁø½òÔœjáÜX_•ïä©IÇ)è=í¾dÓ(¤'ö´ uÎ/ô½hY[ñVYêºIÙ¤TIÊQº.Íéœ\ˤ/˜¢o³:íší0Ûó¥o›Æ¾®<-k@ µšb¨šø7€1Ù ™–v2±¶\TRXnžÛ¶ÍŸþGH‚&éjaÃ]ïèp)Ž'oê¹DDZï¿'’±Ìsí\¦øß5ynZ•×à ,‹æÙ®—A{82ž Ó¨®Úcr°ŸÛW×¥/퟈!\Bg¥‡y’¿Ôs+8ß. ÚŠ>Cö”—¿ÚÅJÐwgZˆñ›£éU¿"[¯Œ¹J7¦l§ôi0Ò Ú¶ò¦³æÍ+Ói|H.c Ñ7.}Æ:«Úî ‹K’û²e×€±ü9=@PºµÄ¬å÷î>‹6*ä¶K§ñ_àNóŒÆvã1/îZ¾¥÷/uÎÇ™ÚT1·!Ã/•¤ˆRx+ñCô—ËÆe¶öôDY¬Q  î@%z<ëÔ#NÌ-žœcú„"è¹_æ‚U²¿ÉH¶´hºm“udd™GÃ|éÒ�Cyy¡{Ì!øê[P†®ra —€Ê¢×^RݲcP{£Žp`°5\0béT{n€I4î"†œ‡&p6gºƒqûî­*zŽ=ŸT&2,ŸËAx7·Ï%JТäŽÿXY½uI̚≳JmÆê£>ãY[ãR½~s£|àibÊÔ,H«¿ýJ{ÕAäMô+`/îÅ|æI9†k,ÆY ÜDÕ7-–t–!YO‚o\¾,Aâqæc "øBÁ‰m£·6.:à6Ò´ ÆF&†W]¬l¿ o§WÖB³ßN¦Á fóB)ïlìò®CáwuDëL!«Ü5pƒ[…Rc|·ŠÐ7 YñâÏzê,©à6Ñ—º|ÿ4Oί›"Ç–îBé,µ èQì;+Y íÌúÜ’ ¢PýÿþßôÖ]úÞšDvù ’{¦ /xçž| ‚ã¸<}(gšûGÊ€KÕùf;Eâ¢,WâžôiZ˜‡Aýi¦DT‡á“uÌ€kÌ4Øãÿ— ›Åfxd()'d[@ðß>òÛ? J©Ý(õ¶ ÎITaÆÃ=Hó!ÿ;TC¾òŸÛs”™i4OåX~_{0í]õîÑ‹†PQ¬<Ù=�lGŠ;Ÿè½¦”µ÷€êwœ³¯´spmIJ7›È”bPåÑ¢ÙL óðïŽÈ‰Z îq‹X|9;xÄyè&ãÜŽ C‹Cú¿öÝnž ´Ž§� Ôré(ka줢3zPx\C¡Æ/%ìä©,k0Éùa½ô»_eÐÃ[YÛzÄžÚù¾¬7rxEì Ð$œäïB(—Xï®:@;UŒ”|Q@JÉ&“³z“¸ÞÖ;dÔáÏ3ù—ÿ7 €<Bj” Må³9D©@o׸»tЬ¯)GPÆ€÷ %‰+ “ž7Ïå,©Ýd97½O2Q·r*è; ó]‚RèÕp2kL Yž«jcžyÂCŒõ‡ï¹ ¨@÷–²N"†vdáÍú!õ®èZø-)S/>‚6ð§`¸¦e§wl¦<ªL5ŠË>ˆçÌ“®œX">‚y¾kϳ}ZéM;ÏFO‘jjf†±Ä¶'ï±iÅõçFƒ .\TçñXÓSâhÑH©•ÍuŸñ`ØV/é«(õ©  FB®º=Ò!úÝÕHÛF%¤ì]ó Å>¿—Â2Yy`´{�–7•y´@¬éÃ` N:ÈÎ1ô‘"“É3ºŒG¹0*~ñ)8SÞ½®Ë®Pkœ«SÏBÊbšUvÓ3ØSùÝUJÆAÙ«û€Ãth÷ã‚ÍÈ.s‘N¢OõOŒõ™íRaVÛ¶W§ðûŠ­Å[Ë•'+&>ó”xa -”Ôã~ÖZ FÐh¡ÀmrŸµˆõmšçb¦ œ%Uçá^Òw?ö3A«[ÜfAÒž<Ñüþâì ¾á܇pLq-Ÿˆ]kÖá$f'(ùû¤ÉñÓüFãêeý•0ÊœýŸò›KÄV|”© ^6÷îÂeŒ †ËÌí6Jé¯9Õ×ã¦c—áΉAD`IºÉ?~ŽÝEj3+ôðÊûõFàpL\qe­Ny�1Jâes|kmU|—9e©göN;wÛ…@íœ'+è®Ê]Ûê/<Æt‹þe±[¦[Ìÿš;­ûÈNîS›ÚÁ"š¬·ì=ƒÉ<ˆí'ø¹(ÎNFCð§´ýrµž EQ3²Ê/m·ÿ[Á‚GÕ_-±×„âD6S ë¥3ãK)üçAù^{MXî5U½©–Î{"È úÉÂMYŸplT>èÅ`£ oY5X�¯<VˆäZŠ=““¾{ÞqîZ#¢èÈ´¢fVËniÑÓé+Z‰‡°h¸ÊWŽWÛ®: #&ëçôéœ4õ#­Ì´Ý¸ÑÞúTï¤ 6«>}}W|»Œ.U•zç¸r%èX0°@)8¨6„«ÿ 1ôTê¹@k£`²¬êJ§˜C³#«%FU{FèÜSZ½Š–ÅDÎ `ªÆ*ø(2ºÑëÈŸœ÷í3Øjìò˜Ð†hìEÜ°13 wmgƒX͘]©v¦¡iYвºdÚc¹Ò–Ú˜ïÚ<hè.­R’\½ AµþdÇŠº²I®Ubs§‚…³86L<ëLuÇú„­qÑÎ5õ‡\<×±á ršbo˜Êf1ûù/ð?t*N»¡Eî#ïÿ FýfÝW�-@îwôgdµf-#EF8C9tAº°h_)WèêBŸ©Q±ä‡àðKÖeyaÐ"ËKÞ7>¥žYÄæñ̦Ürxï¥ê°oä+Ö5åHÝÑÍ`šÊ ¸ÌöÞ•­2rLtW(Û¥t´Vâ8pu´·vÅBe•�fÿÂÖþ0©]惇f‘ƒ]s/v<ÐÝȶ5çÐM?³J©ú Šˆûî±-4c+Öj¤- §½0dí[*2köH/èÆÃLrOàX¡/ÍHÐõ@[¸=º$¦‘Àí*­³ÙâÝKûÖIln¶DÊBQ‘ÔÞäwØ·Rá´îĤ¯€íqY½SÕd£ï[-ë沚‰zIÅ2vŸveוës¬ìÜ«;­/è–Ya¢+ÞvSňãQnî4“¢Â3JchÝð5¶Æk×uûì>œÒƒJHÁ\†Í“ç>’JI ¸É‹öŸ@=åë3±è+wYÆÓ3kF_µ½u:â´Ξ5û}ÜwY:·K×UÄÍ—-#öðY†1pßó Öï$¿C(Î%úÌuƒªÊoJ±œ0úíV¸ô{×k›ò„ê³v¤Ógì=<478LðÂÄàÅêÝ™ qê{ÓL«Áš‡’§ÚId¿–D”Cƒ%Ö›,b‡+3j¢.j[›šJXÅ”%W¯ ‡ãúÂ[”û·ô]~uÿ§^~©zÂŒ©®õ°…ŒÅ0Ùô€yyß.`°Weœ¥Þæ¤7çÎSh;O€Ûó­ ÿàô¹ûôm Ê™­²•ššŸ¡7ÊŽÄh†pôsÙ€¤’Ó,ǘYÀíü}ŠÛ¡é ¶²³k‡±z¥óÒIw ˜GÑ:v¬”5ÖÀt bÈ!Þhå¬zÖW6&ô¯Oãpßí,rÓãÉÄýH§P>zã3%g=tN�‰€ôºCè˜Ù\Ehës7lÆ8KfA³KƒÕ¶s»Ï²Qù4µàEù[lׂç̘x¦Ie¹µ‹güy°=Q>7ž¾/­^úéFª¾¸´»\ù.¸`¨² Ø|ª#ÍÊ8ÏÛâƒÜ'͆éÎ`/ ¬ä&Ò9M ýož[9~ª–5[Ø\›ô(Œ¾ä~ý!qN/nܦC;¶Tô…Z³“¿ÏLãkCË‚GëóyO!¨z§¸ýѤ~1ÌS}ÊèÓV»Û5…€ËØî!•ƒç=î™æ7—éÔ½0Î}OA±©)´ ØTúD‡Š û€`õ{õ³2ÔçöÑO1‰÷Le  Ì‚°ó CÐXx×Í=¶ÒkJv±uöMÌHA´t’ÑUç^;ž‘ŠBð¥û‰|C¤x SBS ~X…UzÁLH·oy¤&*àôŽ(F¨‚81i±²²ÌA¬9*1Ä:w8  x¯.n'ÿdj%C=þÇ-0ÿ»Ö‡’šÊRk]4ÌeÄñJ‹?4rbHaêè‰nsïÍ`ƒƒm«…#m½ÆfIæÑ¿ãM~~‚/IØa~@m§ò‹F|1!¥'²ÜÔ&„¿åÕw˜ù;c¬×œLÓ¿;¯IB±~Óñq#ÍÔ–•�ù™«Ò>ã‚3hZ é—BÅqvŠ¿ˆÕOB÷غ»¬± «34ˆE=ÅÚ@dii‘)!·¶``<öj4ÈIÙ¥l‰uϽøž‘ñjÁb^îùVG è–´ Å;Ýzî6K¿âÒÜ¡ÖXáÃóDgAcŸ&úgP1¶âXLœL«ñõïXÂåÚ,P;˜½Ì‰Ž”²É3mß5*ߢqm3r·÷Îa¯Í$z?PîÃÆŠ·çupÅòý!å>q�]! -¡tþtŠ 3åA:¦Sìá<@r¨aj¬^=×q”P®ÃÀD<£eQyâ:b2üÏ[fÈí9¸Æ€ÎržÞhÑrÅÍj|¸ vZº¯÷¨Ùlμ13½ªþÍÅËÆ@‹KçcÍJŸë %dYW9 ¬é²®X¢IŽ—®5}sç‚®aŽƒ}Såä:Ÿx2‡£5–Á¿¦EóŽ%–‡¹ÒC'Úu–ùT@‰Û$Av\a=V®ÌV8\»l%6²EZã‚or¿Ažë‘êù®«EÀS#Ù$ó†PÜ>œû8 ¢±óNì«Ñ·«ÀDÝNîâ Σ"êaa>ò Üô¬.ãþ:aeßs>)[êâëïU 4u¢c¡U/˜Y-ë/ô"$5óDFÙ«j¤ÅMµÉs1§iÑV×.ûôß1¹ý1Á*: ý+ã„*á“ûß9aÌØñ–iô€s”ä‰?b£$ˆ7ê¤Òû¾GæLC7™ÿaèZíV¹* ]ù´Ÿ¸”ë¼ÿU_¬¶=[»"cŠ•`¦chMËèòÚ$ôhÝÌýjªÐ3ábíw6\Ðjãö¢n¿î¦‚‰›ÏHã†Vz¬¾ŽŒˆž;90¸™žf×Ò2¥ÝbƒýŸ=ÚV¢\wÖz¦pOÖ[ LH%¨;#ƒðÜ8ï*4Y2è¸Üò¥óΆêõóœÍµûÝ^¸Cª¯ˆ*|„<j“™âWü:€ȃ²7«â7-å\T'‰Šx½§TÓ¸>Ä(¶|%Ò_±øMÍŸž ´Šxqëç”áŽø ñšn^tê= vÂ\í;xÿPÍgK¤H X¯ú´,!:-OG±ÙÕ’„…¥-Í÷×"yYáÚg!Òθ>OJáGÛþŽ÷EÑbZF÷>§ó˜Rüÿ-ÒBrçÔïÁlÇd€+A#4»?´$ó½CrøŸP!²œ… #D*t½‡}h;öîR?O&kòê|!(=Vn"nú^O;>ŸR‡*`4´ ±ø¦©b¼‡F–:P1åÃG²b•l“."3ü1x=™Õ¼Ñ2Ô´_¯^ñÞYêçøè P!qœÆ‘Þ ÅÏ$‡’ p#sýq¯sRz g®Ÿ‡/*×fÀz˜§3{Æ8émþ zhFY& ÏQJq˜øbOèll)*-7“Ž«ö‹ª— ˆƒEÅнºÑ}K–ò}9‚1ý ïŽHðöïí#Éã5©;_ÌBR~¨J„FO:G c6oÿ¯– 6ƒ¡e’ݯÎ8vÞüàÙ¸ÛjgK«:Žô_½k» “€»öœYA¼ÏÍèËépó½dp×Òiâ¦ù÷¡<ÍZ; Ø’¥ÙkÚÁ=+E]»ÀÑmgºþF Ahš)ÚI ÍÒ׌ýo• O„ƒÒ®*ƒbS;ÕÊwν©KDÅæÜjŽ=÷½KÃ2õÇÄ [@¸CñbhOÒÞéÚ[#®çv‰¾<c éìn.tä†_šjÆÆÛôgqÿØ#ßT¡È2ëo¸Ñ¯LµüÐcèèíÀ‘>ûí`øÂ?>ϬBžøºÇ`¢¬‚¬éŒ’¹²C£ã—Ü¿¼©r_’¢ÂÛ(( �bÉ/h…rÖüZ\Hµñ’ë_¸Å_½§U3zi¼˜NΕ[Ûc×6§ö/’Å1¥ùT•W³ëÛyÜGÃœ5–Qׯ.›Ï"ãef_«I› QVÔ–T ãxøbâýKO2ŽSŒÉîN0¦Ýh¨¤®íõc{Y8­Ú­½éßH”†ÿÑÂaUÐEÓCØáx¶f32ì>2N'ØÒ‘29O§'h‚¸L—Άu»%mtµŸ'€ò€{§;AB×”Áq¿^W m´ËKSN‹¸c¯¥žéPi.žÍ€è«Émê¹å¼¬^°Q°00íÜä;V(pnñ¾‡ú—›ÎÁ„nMj=w«W®í_âÓ$Ù&}>çAn«DÞU/d8Ù¾T Û]íhûMÝ=Á0Ælõ’‘õ�Qe,I`•ý=¼:r Ë·óªˆo8x:‹a»p~,%¤½ê#`’‹lêÝÚ@;ü÷.,ŽÏ©¸«}ÇLO{uReæ‰J‚¾­XŠ<qƒfÛ8(—XïÏíÅ­LZé׳£udï>@6§ ñA©UÀ˜\¾ÿHpØi;•nsS�y·è­+ÂÚ÷BÃ¥Óžâtm¹¤ª=€å�æ>óÝÆ0 dv°˜\†ñïštýjáÙV5‹ðÆ“¶ÙñwJÂa§½Zwܳ§ía”¢íŽµŸþ= SÊm”ô®¼Mlíèiâ~”K²ÔëXR–DiZ¶6VçZØí׆Ɇœk&¿NŸ™³,¶Îá„ï:"so^Ðó«yW£%*3ä)õ…>w0ãÞ÷ê¶Jž6V‘|ÏEí�›—+=ešÀ]©íš–4GªÆÞ_ÓÒ{Ï•;’1éÙxŽo§®·ã×2w¢Ã¬ÍÐÃp ÜVŠ ‹MQb4„ÿò8Á(2 zuo¤™Éï••:|Q‰Ï­yøŠžº®Õ²ÇNÍ:NÏ17„é)¡·êÏá˜é’V̓ƒ5MÚÍ_~³HÃ2ö‘CxÓI7;O„Å€PâÅwΰ­Lü§9¥zÀüc;]uP† ÅZÃl¾se°çÝåÐÞHj:ërFã ¼lnUÌCÖÔ¡gµ§JǬpû΂š^Á6è’ÔQè¸{Ôoé×ÄŸ½Áí6þ1­jú•Ú×Ùüéjµè÷o¿Ÿ•"\xr£ÆSê5ÄYq ›<ŽT´yËÒhàŠ¨ÂŒŽ+cS¹§'E-ä<(‰‚£‹é±°åð–‚Ò¼oŸV Å:ÝÐ01Ÿ}Ê":ÞF·8-ÅRžæpu6Vgæοè0W,4jWKEç<«Ã;§öØò½Ún~¡}.ŸÚ]>6oM¼±›ÑXù4zbƒÍ v›&o¿<ÄMKnl]Ÿ¡åãª'ÖüIË0kÙ†1ç§{¶Ñb$ßLoº•Þ ç6ý[U×€gZEfºá#fåµ�i€Š áÆ 0T–»ù-ø1Z44]àøÒÔž\-”¬ÉsŽüF9y©¢¼ì¨3zž6ÒFÝ)á£Öé߶b~KŸ§¶ßkÙà¼ËŸ çãÜ{°™H8৽§"ê ¼;}‹ûªÆ÷tŽõ‚{:ÐÛí)¦~}9k¸†þ„®R‡‰$÷I¼ºš@Ï}îŸa @sìí_”'&MЛ]©7k6öœÄ,Yªµ¨(ÿ¬½~: ˜�}"Ð÷Õ•ïÈÿGÈÙ•ÛÉ #ó@yËÞfzÏímc/iîl=QÊÑMÞ(ûˆ³·:ì×ÿ¼Å¦@LC‘ΆŠúOL˜]•(¤¨^fWÓŸ\p+öŸºá|ÅËgº—¥�`zu¡32ëõî§âÝtð¹›?h…qìûþQÂÓMtd¦Pj¶ïöCïp)Ð èRTô­÷ƒàx’zý¦m°âåXSA¹ÿëq¯ØSå3þåp´¯5 ¯æ®:ß9€­ƒ€�"cF˜AÝÊH…Í=ôFÑؾwзT°Ó¹Ì‡Ò圸€:UÏ]çy¥¢ÑÊOXårÁ]z§nÝj<õ׶vžö»¸ð ê¢ëÐJî Š¬‘ûiï®\ôÕè¬7©7‘‡%Ê~Mw~¢}nëÚjþ=4¦ty›Ê¶OQ$LJ|à(©,PÄí[ï0¯g¿wµÌkãØ´b#]=9ÛØ•K¨ü¬é»´g†ë+ç?ã¡]àtòØÃÀGž)+IgëÆŠØri,(èÓ×6+GÝIìJ|lÆ?+ѼKAd^«r]Ðœx¯ÖC­@,™ýà“Vø§Æ°½)ußú­ÁHÇF)<EIE‹ï]½• Å}úÞç•>Á´f©Ÿç‡l¼A•½ÆŠ¨ø­ÞŽÃ¾_ˆ åa3L3Â}Á»)óü´b&'S±zè²:=7V¦ÑÈò_yº¤žø€ñì¡M'ïyˬÊpU¸‘güÀtŠe–gîC¸\Ù¦¤°5é0£åµSh×Ænhyêß·Ã<]øn³‘FM)0Ó>õ“ØTã œë2uk./±×DàÇ>ØŸ™ÇÁ,¿¨R)ÙDñ]U·ÝÓßúŽ_debVFºÙ €'�ûRžÛl7ˆK}¸<àñT³³?¹Fwwùn•ŽãA;‹ãÑCí”X.ÕqÕ—}}ê7;ü¬Pê».σâ¬R1˜IÌ0N+Å ¬5A~oÛM¿·\Ÿ Ç#nÐÍhÝ+Ï*ŸŸj<w@Œ;NÃA`T µÚ¥[^X4V»\G‰žš&ÄvÝû—�¿€GÝê©ø’?^˜ä-°£#ÈèÙ¬3t6‡¥zqÄ0>„ßšÎ)ŽÐÂQ{—AaYQ‘¢×;ÚNQ¯Ñx@Ÿ¢Ée~Ëñ4²„»í©eYb)R mOø¨Û; •u‡B—>’™§ð˜vTcmO9å°p[k¹âk7Ò¶=j²IÏàÛ^k±r‰ëNœïé•çÖ7†ÓÛìâÞœìõÇßx“‡¤X•^¥s B¬R1"™öÈu¹:gY…±,@Fwcüíû c_ú㊻Ü+íd0”ÃEú«f9³Ê•Œ­ŒWÐùOÄr fô€Þ]5y*9çB¼š–]}·8·ÂÿäØ æ‘ ,uofÅÏ JaìL,rç§u¯/‚š²N×&£0ÜüµS?ˆ8ž/<mQ” TâÈñj‰%׉Úoá8ˆÞgÝ hçï.ë³Ë)ìËJú"1äĵè£�¼­ÎmZ +€µ¥·–à"À‚¡æD¼SʲÝrIœ^Q%9æ$»wF"qS V"üèÌ»=2ኲ异ÙÒW´L-z—Yö؇¥ŽR2;¬Ñý^ívž®-ûëxpf«èúrá¯V>Φ»2ˆk5­L3ÃUž=ž>îÛ¬¼æO;ó`ñ)o³ ´g£4/?Í+)°Gˆ²0}ñ ë?qFÒ‚„aXõ“'ÁB·–ä%9ÓG„‰ÄQüˆY¥WRQQi‰k¸;2^-ŽV@+÷|å eþ'#Õ(wc%ÎÑÖsˆ£[#CÄzçøSM[uиµ!ç>ª"f1qdŶŒâù¾i½´ø‡ ¦¦9ÍÇT]bHÕ{æoõx¡{mñ€·òÅämI¯’ÙÌèk&Ͻ«ZÏjnúƒ¯TÉÖÈàÐÆ-ÝŽÄ©ùa>Ÿ£ô_)^%™–gäº bmëÕº–fRë•öœ óƒ‘ÌE§ÎÊê-btU«õN² ðy6Xhª¬lyrLJ„%ž%xc�™MuUÎŽ!ÏX¸Ý‰µÕ ‘Í• ,QDåÌŽ¹ OÀ–Uš1Ü ûÖ{dÍéÞf¿žíØàd¸¾+¤]YPν×:Ü¡Ê¥Kqs›qϼ»5O®nÜÈm˜£€BwŠ8^XN!”˜Ó‘¹Ò¼yÓQè“GÀ_kkßrÿ0(<!Á¬“}0’2æ`ü¡ÅL’øêáTÒ‰@Ѩ¿xêVlŒÀâHÓOúa–¸ñ ž¢ŸÝNÎF(Pž¤ÕE0nû'’bÀ8Ñc+­p =¤¶ßVXY¾©Ó-*ÝnX ¢—r£¼¯¡TlÃ0èj¹Ë¬u H è×±µ†¨ÙžRS„#åêÌ5?®¡õph-<“sU QpD34xñs“ÖRºüá÷ò!Q”úà”ȽÖóôi½†Nq ¢PHË,KRª^Œ0¹(½åË•˜w0|œ¢Q¡x)CáaüÆà0ALüÐÊ)t~k…~ÌôwT¯Ãçß>u@ø@Y{'y+ WÚp¸¤´îSµ7N.½V9—½þWŽè-OÒ´pd)Ðû± ’÷³kòTÍa?VÝd:bpÁ1Zí"iõÈôÙ½ëqmE. IˆøEüPÛú™‹Òó…¡+ËoôõŽÍR¸8L0-iy–›wGÂÙ+bg&³µ]Éë ç>ž;ljÇö”ádÉ/ÀoÕž2-À#d/”¯¶­ÂÓùM£ÀSó˜¡Ha’àŒé½UDó¥ªáÉ/‰Ùjݘ Y9½¬ô,­ô)ü0KJòk ·mLgø¤”˜Â‡èÁì× §Í¢ÂÕBð¦h(òÇ•k­µ˜uŽ€È(ø�H»*‘ѹI¿âÂ_6¨îtOê‹×‚˜éö¶ˆï’Ì CZ a0À†¿¾Zô¿´¶fÏÚiZyV£’Ùö”"V 0 ÝúÛÁD÷jõOì.T˜f<O«§§Ý]úÆÄgqžÂaùAˈã·ƒqß8•G!¨»ÙúŠCG®mXåà°»¬t©D¡–Yg3ÉÄü©OýÄ%£kߊ_œ¾Þå’D¹ßUF÷áLK§V³¡žyšgÈ”{*œ)ú|Ý�%°»§=eˆª‚}Ê7 zw0©Ï8ƒ4ALϾµË‹•x*žWhõÚDÊJ&ŠE |˜·””Û´)툽 }Ñ©’E ö¯‘PKÏT8a)IØ/ö˜?÷èòyã}zîèA*lºýA€-UcÜÆŒrå “zÒXŒa+ÍÂjÊìªã‘î ´Ë‚ª;Ú>úü6LÊ¿qÓL}™Ž”ƒG µbRsØch{«ˆóê“Žsï°OÙZ·ÊƒlÒäSA¸Š\x‘’˜?âH:ôh¢¢,€³ÎHšu+ÛþZ¿,ô”nÅd œW(*9¥Ûz€°¢;{¾cº†V@YÄÙ€÷™b0ÐU®Zf°²ÏRªT†ƒúnˆY*OíLR.GµÆêýŸ2Ãεö ]Îéä?ÇÓøG§®’÷ûl–hUšAdnd2ŽC¤;k ™Cb#Ôãdî·áºa€K}{õÝ}§."þtüÃ{&ýÔ;-„›`Î^õ•òæýá(ùDÕ¡Õ,‚õOß1²JLËå¼I<! íÎœ3͉#—ßܲðÇc1ë^Š†ÐŠaòi« ì|%ŠýŽ7ö 6Þº—®È…qulY{4‡ÝJ5fÕo5 Lçj7!c âõÈ<qc¬D0%aPu“Dl 'M ¹/¨C¸ðøè4ñS>£»Ÿñ»*È&pm+I!i‰]x¤Ä·À[Ô:.´õˆ’UΦZKM»VP(Êä¸Ùú-ý-ƒä<®¾õ­CÄê$¢åCq°µ´Ýª«Ô3;§Í%Ør‰¦âh€+¡‘nú¥¹ë„c»·B»[ëMÏñÊçÝM;UFa€¦eß7pš¿ôHißÜû`))rˆó¨†ÞÌ}VP}μ°È>qvhôÍ@œ¥ïüá\êa/ ¶ ›bz>ÇOGC5•Å ðæ @ ¿‹ŽE˜ú}VÊÆ,Xu¾_öä’Yâ+š=7KK—Þ²ÎVßÒãÌ&o¢ðgO·�Òž8>P ;><E‡Î$Vdù1ÈœèO(ß5C�σjÞ ë‡3t^•ÈNÿ=T 7xbœ%›Y°á;tç  Õ‡ïÕt®TÄ•“[E Ë#÷5p¬K¸°âïc#Ö\èÍ­(ªÔGo8*0ÂkàŸ~¹z¹¡Æ©"BK ÖN/Š”Ó}þØF²žÊ_® t…/VÊ%ŽÒOÅja6݂̉.Ð0†„ÁÜ<ê:sóPÝMG4ªj\ð–xÛÄ!×ù y|· ‡(ºîÌžjÚ¨Ö€•ÖÌê=€m×¹‹¶bÇÉÛPã{errî鸼œ<½k-r³ú{`b^uwKª8èÃZ4ž§³»‡qBºîRŸ`†E.-úã�©å—…¿tâζµ8F•XY>!’T”{zŽþ,‘+`ȲÊèíÃ^YÌ*ƒ /HƒÅq->Gîõ‘íUá2ù›´[x¹ílCmÅvL§qÛº6-F½WÅ—Mrm”f¸%E™OÕ`ʳzN=/&Sª›QU–8^*ã…æ‰öê<zSûµÓ¿Rßۆ⨔!-cñ1¼÷C,×åDŸòᶢ­îá÷ª?¡Rã#ñÔ•s‹¦Ã¤…(ëy³3†»ºŽþ™C% ãg!”8('U N²"°j'ª×¾>ÍWÌmxØrMÂ+‹E<°¹ b A7»êXqœYI¼su™†[‡Ç0M=pÌf‘´Éìi˸ÙêÌi‡þõFbþ0œëäzþö Ÿ–¶)òÀms¡ƒÃš¹„iŽlà<YL¿æ6ÿÊãj/Ó½t¼¼%L@‡‚ªdÿaBÐTöÍ´¨ÉW1ï7Võ§¯†¼ËûèéÜSâàæÕ™g.§OÓ–z �oÆŠ©Žb´$¾îꆷä „Ü–¡h„±­Þ7fÃòŠ©Ù*3€Y‡ž8U~óg,3•R­´`hßåï~£¡vÛµ=v¯™LŽV¥?ßZ¶J¹G—«6ñá ûÍëmÕ¯ŠÞ+%;ÔLÐõŒª)TÎœ»C=Øpò8{{;Ò±?RýÜ̈£Õ’½^Ó ÍQMfwíŸý0[ƒ£ÕÛ¿oyfÝiêê ŸÔ‚ ~n%`‘¡kˆ®‚r|÷67ÕU}OA«õSõô«Ó�_h»¥tVZWlO@øŒ¿‡:ñÌúH+t®ÑÊô_›"Ÿ;Ož*Œöý;…8)×àMº¯Á5§Õ>2Èùpóc†³ËQ‰²üv¦ªŠ £,È�mÎ_ñiÂÖ—ã©ïéC4¾ú¥EcJ†ü@/¢>y„³qðEƒv—Æ|¡è+éû}‰íÔ§î�¤_ã¾Ìµ9&ØËM{#mTÔ©jc±󺈇Q®üÆ.Ü¡ó °ÏŒùòCc4|N=\ƒ¦ù‰à¥ƒùƪQ±…5‹î︬P®‹àøÍÝÕ[6Ó¥¦ô–“V6Ð…iÏ—ç:ë\<R*8YïˆÉ]R$ϬEº'Ã+œ«hgŽ((1÷çŒò>í ÉÃøÍ|jîMw•8±>ü!ÁúÌÅh&o©(Ep[s¤õ€ý&H‚;WžµA¢=¸ÂPÏÛ,ˆF«Ê"ì)xŽz¬¯µ÷P’«ô5ÿ(ùjÚ< òÍÅÉYbÙMNÁÍÌ‹°‚.ßU)õÛÍ؃´«&]0 î!ÑÍ3oúèã[ôgQÆÑR)8ókmŠÜl˺jlŽ¶V”\º={J¼ Lñ[‹Vg*¦·j·M(öÌšâE2çéø—àO¦qàôLj5ÿDÎ#grÎógµR+þ'ÜoÐtì‘~T:x6ƒ××rn�…Žý|2}Jü3_èàmx»‚¿jf ès¤}ç’(ζ²kLÊþ#ŽEH›ÇªbÏ®¾ÔSó „[3"5§p¢_ê—„ 2e¨ ¬Ï¬Ö"$ˆÑÀ2ÇsÒX¿ç$³c&Šþì#†ÆÇÊéÚUÛN]$M-³Ýçú4iìô£¯™’w}hƘÓ~ž«~«R̯È$>œADû#°[ÚžLYj˜·ì«€ÐٯĆîPž]­fá/´ÃÈÚ…`‹Zá÷4±Ø!¸† i§AÚêccÂ7÷ƒþy ®ÑÄËÝ8ºuMËÎéÞÕ“Ÿ{pX¤üTðdyt)Çå\m5è-:™n˜ÝÄOuY$Ýoyng+¬Dy‘g„ÚûDŽAÖb~¹æãhñç°/Nˆ®¾¦4€C6ûšK.ú*¿Í¾,‡B¿Ñ⇂ åb‹“/¼a '¬�Õ¶'”ªŠŽ•qO (/)�äÙµCkE|å)Ñ°â%kiç¨ö¿ÐßÆ|–¬Ü×í¤ u‚ÍQ~ÒJÎ-Ö€îËô ÃÐÕfô±§ui9ž—UØWð R ¬ÿÊÖ:YylCG§-}«Î/Ø{ÀÙ8ýðæÝþÐÒ›vÖÑ£stµçÇ°m ‹ž~'A±µLô”SBº‰W}Ýfã©k+¥²Yá]²ÕÂíRwYPT•é¨@M-ˆ;|o(ÕÝ{½âЛø¦F-h`ïËþÓÓ$9ï8¥ñ…«Pí7Šµaê{IŽ¾‰ƒ¤j5¬¢šÇ‚²ŽQãéÀé#_ê·#.ÍŽŠ‘ãß+<ã[µæUô#C–´4R5’±h$æŒÌ³ÓÛ¦¤J_ü ©~ °gL.Ù½N៹µRúsvºÇ,%k;–q †A¯(ɆÿQ"–„N°é@`->?½|§ølaE“˜‘ç.S˜u†?ß(Óò„›þXz:O ÿ«cIÈxÚ#¬à-fÊ2”ôÎÝÄö‡^ðë÷ ÞÎû˜û…´ç*„Kïøå’ÑA[öÉndsdk-÷½ýc|x½•L‰4/9Я‰>m‡;áñv¿ÅMÛ99JC‰}zµ’²éi9nO4pf¯7ÏÏNr†MK•£jvÕdÀb–óhµ4Ì^è4IߪôÂA8›Z†°)D¸ÞO»áˆ"qÛhyßù#zžŠÂ0‰ãÜb)àƒÝÝâ“Šjô¯û®jÚï%$­‘‰*HÖ5DŸgXdI.¢†@ËGcsÝt¶ôöÂüuT)¯:'¤Ä°à‹p£Œ Ñë*ðN´=64¸õ™Yí ½ [ª}3«ž¹¹-«è Ö‚Ò¡!Ä»sîÜp8+Ÿ{Z•Ð–{²£»ÇKSM€á£ì£ Ú/ügmØ]}{ÃÅ$–t9WZo2Šÿ6,ÁŒK SÞ}Õ`DmŒà~e—fþt€’âéBgƒµ æšél”‘äA[ʳvh¦ˆü@ƒ9Õ½K£ëì騡¤›ÞÚöe#I`d8•Œ^a}mZ>æ6]£õ¬3>ܺ¶ÒIÏ(mÏ´DÊ ôO`Ú¶"˜=žº©ô&É hR[J$Äî±é£Æž=Ÿ=½ý/7»%ö²÷pKº‰Iµõ¤ ® 'Û“²P±ùCUvÞÐ3þ¬½¶$F‰ìä�|wÑJOèüyhk}yæ<é@[\4Ú»Ò¹…©ÂôÆ€mý–¹÷íô#tÜo3ß*ƒšVU×9œ\Õ�ÂÿÏ[f2"Lóž-ÚÅ å§J&qæ­mñ\؈bªÙ;€‚HÔú¾;°©}ÔPN²À™i�¥ôô×íFJ³Щr%S|}½lÆ‘› %<jß”A4ÍáÎè÷i9±a»„*‡êƒ¹ÝŒÕz~öÀ#ÏôC<“Îà—~j‚’@NJ€Z¦oZÖ¨~‚SËVhÏÍ¿ù3 òʺ ³½0%f“µÈ©ö[>áìÅuƒËZ¿­Œ,{ß—AvôüÆÝxi¬8M2Xx•ôâ ûŠ�‡ºš©Inø²'iè¼ôq0¯ŽdŠØ[x¼?æ(ÈÚÎׯ,fYîá“Rbp÷‡·PÜÐa«XüæÜgAîÜ°(çÞ҆ν_’JJ—úå¢ÄA·fwÒ–ÉDn¶ü*Õ:s´ö‡?ù·kÿUUå(=m/v[=Žô8BWÁGêzÖ G½/Oõ8R§…²ØQ›ý¹ BâË”ÍL)6²ÿ!FJop6™Þ¤:ºí¼¤›ê;l$¦1“0ÅÝŒM1V¦4gœjoÏìµoû2Ð.‹®ªÑº‡uøñKú™/•c:”µDÝô[Í©…°!ÿAû¢w-ÑëÑ$¬G¸Š­´ÙÞŒ# YvÐT.œÉr·€gXŠzœ«l€K=S°*- –ýwÖUßô›™*š;ýJãü #¸®“ <ëýO{ü¶++K÷Š:}â0w;¥@É;÷ô‰³£›èNRs¨<¿kÓ¦™Gœá£QPQ<wAå{Ú•E£/1³bÜ. ëô‰:ýéoÒlññ¯i“xá®GÕÓøm]¥âuÓÚžèwJNåu)�ð}þ>ºÅº=gsëRh¬rÛ†&§ Ï‘Ú¡:Å[²Ò[u<Ò§æeù´oyü:)èë)Ê(<yþVQ…sfV_Jclé+�N‹‚:ñ�{,ÖßGAùnË·”ÕÀ~=™×8·QæD™+sªÓ ±š�FV@åúB‘C7?ÿ…a´0¿K‚cGÅkSyFtî=vð±»Èú¹½°£Ú‹ E›PÁ5ÛFÝ|YH„Þ—eåØÿ gÄ®z b§é'x}�õe÷×çµküµ{þ TœÀð n†”‚Öþ¸_W—{¶–‘¯hʈqK_ÊqëRs «â>Úžò¥¯†›ž6ÃcëŽBv]{òúø¿0¯ôØ;žzàÁ’y¹/¼ %°îJï¥qr­)X™Iú,,ó*ª%d(O´Ž¥P  Ú¨?@Xñ¶cÙGËP|Ú˜+ µ¿)Vï“GÚÜžöÓ£§“D ÄßccÛTL5¿í¢ xWìmâ¾æ-®á›±9†öeŽ|at8(:eùçcÙx P7¼rc  ¨Ð׬‘Ã\]:̶z24M;1 Ö^=qF ½ö‹ÐœÛžòVi` <ÑÝìvPNu¥‰åwÏ~YrÍ®ªÐäß­t; `Ê+ÄâXn:ïâÿô½ðk”.F¯¬ŽC;$junóŠ{>6êV†'F_×ý’Hà’R± E̶Øé*’dwj°¸ÿüª’mV¤O¹[ŠWemÝ5àyÉÞöN±K­ß‘ˆJ/ËþÌ»ºcvíÉX²/¬e¯§C!¦!ôM² ±þÀHÂÝrD˜?)Ç-j­¦PÍØz~ÿ‡RY*±ƒ+µM½˜Š+çÇ=Vnäü‘tðLå­KR™©î”x ÁgZÜÊbú‚>Û ¥Qå{G| W Fh´|–Ô–Gûuš´\�¶+硉Ï|Íè©HãH3¤ÁªQ=Wì 7tïôàR‡ ^È—8s{„BÔ´•Ø$e¤_VØŒ!º§�³¨% ÅÔ·Vâeˆº»¸Ñ¶ýhÎìàdŒ^ÈÆ‚M1äÌcÃkÙP6-Õ»º²Ú¬ÆÈ‚Á‰œŠæôb±"@B­;X.øáCÛ@O¯t"&]Ll‚¦Ç´M ÷Ò‡×#üÞ(èÑi̸þhC~wWw ¸«Å@›Í€Š ¶>(h/Ôü±}¢ÙMKù ÿ‘åt©:¿ã&¥ë¦1<’ÙnÅ×_¯ýÜQ‚h­ µùöGÜ6Õà cc4?QàØÍF5âêÒ¤«à‡5ÿè醅"­#‘l¿€ŠÝlUÊŒÜv~gÇ:í \ù…£gg¶2ùÈ4¢ûûé)ÁÛÒM?éK„¯0òf.ŒßåéidEæ­•Gæ·‰Dnæß}ÿ¯—>œ›bZ]ú åæ´TFí! X»is7s­ûz¾ÜêZ¾#Îÿ) >°Ñã•'¤ÌÃåwùˆ!§Ü¾NôÇÌdv kçê5¡ÖŠH€€ºȵþ¡ñìªÒ;ox,LóÉz8CRÎAwnG z—iYQÅ‘—ˆ§èHÛq{ˆ_Æ„,í\=k\7V–Îèe®óZZ—Ñïž• šŽÏ]—’;?»Y +V3¶sçKãïlƒá]nlå×Ã×nhƒ»:¹×ª¹Q–ú= @Ì{ -%# a4çã4ÈÇ`Dm/Quµ;ÐzÞÓ,Ò…b¸*«ÄyFÉ¢”Ê Ë}÷!ý?{qW•Ý‚UÍŒ¨¤"5’Omݳ'0*Ayª·¥¬öúÿÀ2$TFz•u–q£V–q.í B0ºþ#\T©tV^L”'v'48Þݬàþ¼)O ;¼ùêK’ÒÄ̆ÅÖö ÊÚoJÏ\€ÀÇï‚‹y‰Cº–¡éŠ¥A¦EÙiÿx:\ƾBª2Q-ŽlÇüä^‡µ:  v§©êŠ*M½¹Õþ‹,©É2Ú/<;·Oð´dÌXNÈ»uŽ¤q”w6##cwÿ½U1ºÙB§8<>n"eyˆòïîrUÆ÷Àã¾NŨåÃ;µ|eÜ$Ptìl ½` Ëç7hòTNS´2"KÒ¥•¤v²žþG?¤¾UÄÈ#øAp´G²†“´z@ÛBº²ï1Ø®» \­’„È Ñß<|A+ðR{þ¨€ô÷!¾svHPÆ>¯Ä’#o¯Ý'Æ°\#¡QD'xûï5…xô´2ûÆè<³ùÆÅ+tèï²–½f—è)[ZF�ÔV–Úúj²Sd¾…”âÚ"Ȧ…NÊXÍu¶r7„ËÚ°7¯¼x|’Pø ¨œ Åeµ(³Èot d…Êw^¼Ò²»‘¶‹"Ïȃ»FÇ– ôqrËÀNÑ ´žÅ45Ø�þíœ:š°?ëý-É8z"´è• çej):øòz‡e†"‹oï©´Þ³ î­P•Ð÷í—ŠB!o£d{0zб·»òväfùèçfDn‘‡¡ŠJ¸N^M·éØv¢h»y?–=ß3ÙdÒ¡mg;º€à‰¡b†öh@:®1ë_ÞøS¨ª‰ÁJcƒQCw¼«œfκ„"VWí§'�ÍÈR"cÓA+- ¢““©¦wö›–Ô'eø-ôÐG©QZ›±ž»”çp“BºžWaz„ÛSÔLç« å=Ó‡0j^ ¨°žÓp—Bá=qTh5¬<52èŠü‰‚h;[Qa)Ó§nz7-ûnð³�J1imjC¨§YÚQèËÖÝ‹€t¹Î¹{XO±°Ž0÷¤óù]RY$çìÐÖPÖ»X:W¡S'f½O°[ãOåaÇà¡âO­:+ø2Å5òD8™Îß~Q8-¬Èƒ÷Žtêy N$fÈ~û—·ƒS3á4Y'ŸuO%z­G‘Ó'b+lNÜCoÓAlK“¬ÞJj©Ù‹Fe¡ÂP ¶]F'œ¥ WÓÄßzò›튞{pêσ7þþÇ+çš4j7T”oÍÔõýñh«eÑè»|£è–«+ònKQ£ñE*ŽÃ±« ØQï; Vô`ϸ`a’/¤uhÐ"äÞìVç¦ñ½Íð]31L£…–Ijì¹êO§º2(ðñu.;¸Ë•D…”ÂÚ{‚ÎjÎp]DãîÒˆ,qÏ¡†¿Ò­ç79Áîü$”"ÓÌÙ‹X6´§@Äk©r+Qˆ¡·ûþÏ=’fÆ-|¨Æ­­Å+øMªÀ]Eç4hscÛÿP:<´Þìl*‡uòí_—#ˆÇ ë´eѼ û{G·WÎ.+[m#¯sðÍÙƒž¸ÊÐï7¬4cá20n©§VÀ›ë8P6’Z&0µgÜÏ¢Q´öÝKúöŒçkMløŸ\}·•Øù¢pÁÜS­ÿ¹ñðKx"Ÿ?ã|Å w37ìNÄõþ ®Au¨Vuz¾tDšŽÓ‹X¤úIÜoQ‡©“.6âj é¤ó_/¥RÝÉJ›}÷:NêY^¦Ü”Ý‚„5{˜5XFW�þÑ·µ 'ÝÕ+Š˜a¶òwÚ(‡0¡H¸õê–ñD1ÖÁK~ ´‘D©wƒÐŠ˜Ë ©.9óHÏ�SóîTÌqLÕWºM�C¨éd¨íäÜŒkvM”Û³ºÓ�³R5@8J¹‰±V¥³ãÝ ˆf€†1³—n1³vÚ‘½Ÿ~¤û_~n“U‹\ƒüÃ7£/ŒƒK5J§èê[€\¸Ñ“Üœ®‹}_Ʋ?o2Ô±PÓR z^z¦«sºÙž…K]GA¾ÑÌ•Íb*‘¾g«î&,i{ïj©KPx–p<û=c9ª#yˆìɴІø³_Ïø¯–›ù ÅÚÝ0Y„Iæ!DM´ÊÛ£95Hœðb„ýv±¯fv7.»¿±ÊÒ-¡˜£EMåäªÚpõÅ*éàҋ‚ ižz¨zEW"BÀÄxôrF]’ƒ±3E+UfýÝêäY“îàÆ;Oÿ¼¥‹åÀzkí¸ƒoà?�ýóæ×¥|¨1Ðë¥ÿ F™¦i«>>늒r¶Œ;fÎï©,4­J†4î°ÁýËõp¼QQ³™~ae<¡LÕ¼ëÀŽås. W§|vün7'Eáxù ´ö± òVóÇqøƒ„síM}´bèá;Î ·ì&sc—9ŠMal@‘85^â4SÄàˆvl)dÈ-ð.»–>ù5ÿD³ÈP„Çè³viO¶=Îr/#ô,1ú'Ml�ö½ˆÁ aVzÌ@„öêVî2G}Át ¡vGü¡ÃOmc³çm³wÞÕ?k»‰»ÕlÿF™o䣕§âüÔäü´º:±4aL+÷„}÷Á{ú± qìdÒ$âMS(Ò˜Lï'V+â²ßö)n/lç"ZùaBV9Àµvoª½´HE_�ÂÌëj|©éìz 2¨[ÑZ§�—ÌZ׈¤/‚… qŠçÀyPÐ]°W3{” ßyƒ—ÉB¯+[ }È ÷N»’ÿF¹†Z}ùï¡ï ”&7.¶… ä]kÏæfCÿçb’§/|[ô7·,1ã]Þ‘_^yè*v‹®:Zbco&¨å‡#Wòª™ÿcòªŸ–—zuC)ò <ÁmvPñ>z"ØT½!ú«¨—fx«ÕUõ¹¦wÍšN³$ïaH  AÆ&# •õ^^Çú¦°b¡J<iȃ«Z—'×ÞUË¢… `¯SŒ …jSŽènc}±þ$£÷Y(M¾{…(š¸~¤´dº.£kòæLÇ1y‚©2E»êÐ×»àŸÊ&ü×è%¶MÃíÔç²$ÐS â÷“G^¦Cf:¶ëÙAÎû™'!ÿÒf¹éBp /: “ QàÄ™Á‘Ù´ 'CÁ××{特çØÃ]Óò¨.7©™ëBXî!@þîb?¶{¶´˜‰ÛŽ[ŠÆ›Ñþé"¡±¾­Æ¹KÑA8¯¬¹ÃB¯)ûâdî†ûW,ƺðâ€p„ÓÆ h h2 fÐ\ºÙ«G¶.EäT¬Y^OhVV÷%\IÿÁëö¸÷ІßÉðÆ™¯Õ‡´f,ƒbl=3ovEY,ã1{Á¹«ÇˆãSȧ§@‚$­Ú%:�$\ í§VÙt<úÌE=[¥þ¥Ï?Ã/϶óYgÞ¿¢%̤v'vô~Ì'ƒð{CÈœn¾7ÀY%E†›0 Ä{ãã6†ÉS'ÛÌYüK8Óܾ-\9kOÂv+Hß?µ Ùy¤Kï0IKá{¦Ú³rÓÏÍ U,JPT߃$ôù×ë„x{¦i Íš ò÷¸«g„¡l”‚â{±Äe4k ƒ5w¸ KÌIMR)=>Ì9°üŽ‹e ð Ù6¯©`¡Ûšûs“VIÙ!<åÀ^æoMGµQ<œ½PÄ(òëp4Œ¶iYúˆbOÌ|¯·­ºðnõ-¶mÓÉ=»^âa¡3?Æ™RªÍãú°RâX oö‰ç·¦öx>¬woÌ­�6ÿ˜S%³èÔ‰¦2ÝöñÂ#¾!´>Ñû†@\GP=nfS‚LT8›b„b¨ƒ/{ã  QÐ줲iz÷úPï§nšì¼ánó•^§zgZœÒRÊ0M분ïžÁìºÛ?iå™ÙŠ‚Ù“ éGoŽLÿ =g35ð¸ëW_E#^yÏ–*’ö‹žmÔœ=Ñ•i]uœÆAs’ ^t @ ãÌö$6õcL+eVkKÈؘa»¬Ü¾™Ù)«o}‰_5”«Óz¿Å'©UаqÜÄŸ{'Ä¡çÏ7v:gA:)Ò9§óÔôÄokÙ²yÕ“+ô@5Œà?|äA>Mª‚ç“àÅ„¦Š;‰{éúIGþ£…jþÓïP`Œ¬Stèz²å¯5`ÇhèX‰¿­ôÎîBVŸ€WãÌe…`’2XYE¯ºíØ"V‚[,¥¸ U7Ÿw\>±ì‹VwMÆüš­º…bZÈÿŠ¸t®ÄêÆÏ<±`,1+ á<Ѹ3ÁX§l^7?¼>p£EåCŽ½åÚ<‰_×UÙ’{ºÏŸh=ÅãEƒþi<CCßhífx7÷TË|ðlâ[¾Ÿ•à–¦~°ÈÞ^V­ä4;ûÂ]ûï4tì}CY÷pÍÈòX®¦®ÏVAÜj¦õs¡ðÝv"ÌÏä˜ñ445ÀˆlxlTóô4Í bv7Á¸ÏçxdÜ" ¡Új/À,TO^S n02󵑆•Ÿå! R°Ì­u1ˆ0ýp6*€HãK Ó¬«×«žkïMCJ‹rg³vQQ­# ²ƒ:C;B¢Ãªsth~zW ñ²b!QL‹ƒºV0ƒo¡[1ø×ƹV®0äi"„`X éôé)›TuÛ¡Í›ôi$ë^˜‰ö‹ÖbØŽÖµÕÆ™:¡cY»ÛÞ%?Âå!ù°16þ˜Ž)ßsyo«ÅýN6”ËþQûÈ…_zœ¡wÒ ?ñHs2–Uœ2¶zÝŒ•ÛÇÆ¥ã)/Ð2X2£DPgIöÖ¸€Ê©­­ßõZtÙ­›ŽÿÝC-åJί„Ѥœ}'_Þ !¦›êà5Vl/î¥Ü/+OÐâföë¡¥l©8ZWLת­ïõN%2eB c&DÔÚ]™Ä8 ~LÃ|ûE©åQS°À„Nb€Ã|f(Úsmª3=Úû¤«2ö-¨¦o 3MµÅö賦:kËДís”v­†êSccLOYpÒá`ÂÔX ãµ¢ì^t”;#8ÄPáEoyaªx;¼›«ý¸¥ãŠV å8•¼ù+83ø·ö]�ãp<îÿ:sPÚ=íz’tw¢äTC3ì¡L\k‚Y@j˜':ÿ­†RÇÐò×JD3x•1:Ž”¢½*‘¾ðó›'WCû„N+çå³Þ £ëCßã-t›Ï«HdŒK'»Ê3胓ˆ³ñp6" 8OÛúr-clÕñ„Eàˆq­}CX±¡ïÂ…ÈPW뻸+7æL~Y«wšÄ—:l²>ƒg•ÚüY"±]•ÈPw§3½u¥Û8dN ýSúgVVTg0è©Ì»{¶Šª*¥&ÓTÄ<AÓùˆ*LÜ‘–&O‹”xÑçêÌz<EB^Äz³<cV­¯0¡§G)¬:íSçqÍæÓj8tÂú|eÖGhœh g•#ïy¯Økø>èý†bm“xp–»àb$¦8±ç;Âú. è¤->¡\>â]r¯6Ê=D{<XÙBjÐåE§‹õ~»ÝSvpúâ&ÜS¿4_†R”l)¯l>=Àº ¯-{‰ª-Ü7o[†‹9äô(Vf£.o4¡6UwI. 6jÞhOÑ úèæàxÐÅ£[ëc÷"V]¦nåjü]å ¾èÛ«a+]+&d°³ uï@Ì€Á;ü¨hvïrFvÉÎV«ek¨Ã­Šì!>¬ÛJ˾ÊÙ­í|PT4'£¢²ïjƒç^šÌ¦ Ü#Þ5nDÁ�€¡£Šºä•®pR,ÜÃW°Í)Å´¼½(2ê ,–`MbQ’âó3÷Öؘ=öÛ2H«ÉãµÏÈx¢! «öˆ‚ÒÀLQçž¾ldÄ^Ä�]Å ÊwƒGÉÐvó~-¢šÍ¿’ñ•—ô™ûvDÊ¢Q¨aSZÍ0Ñû‰KÄTåÙËzN-ÏœžRèÖìþšèf)r¶(Ä~†ÃÏ-ÂÿÄêQÆ2È;t|[²¤’%šøü—J^ešz£Ú8 k"–±d,0#ku¿p„žR)×Ðu.ˆ¡´Z…Îc Š¥DÊ3¥”0ìÇN)LWEˆMãúl´ ›Å›“‰¦{¾ôæåmWÍÒ)ºé†xòx°¥WRKƒJdïÒ’b¤¬zõ¹ áâñƨÀUEÿƒ0«SÏx- =VÙÆQ ãµÉŠNmY[Ü5[îb#;(M _þcFÒÓL^×z`d°ї •s†§²jGó˵…0ËSßE7‚_¬¶'Ó88¤§m1tÑ2™¡‹KÕ¥3p{ÅJª÷¬’Òtk¤}þ‡"È—æ, …wÆŠowo ûÞ£'˜üt§¡kwŠ¦9nX~ì{>5Ãh×T8ÄK˜¾œ7ßÌÿ•SRX¬f”@|Lt†C ˆ ÔØ/Ü}�!ðúUæpµàÁíó¯à¯ÔpsŠEAÉ’µ™ãÊdÑý–Ç*Úz‡tä´DœriaRî-~"Þ™1ž&%ZÝ«l´“Ö<Õ~8©FbÊÚ°LnÒšCÛ}LÂi3|dÜïx$‘Q!ÖïSKÒM¬NŒ —*ç¿GÞ‡y±*2_{ÿ8@ëMCV«Ú[x~èÐhBE:™'ã.ie®R"I›Ò&!†Bô§M[ÿ¢¦Á­ZÕ°?kùùG™Ð˜e?ì·Ÿ:Ž.j(Š È]Ë‚®Nœ­Á‹(íq]”d+O—=-Ò ·¶›LyôxiZÏ¿sl›¾zµoÊ& á9(´ÊÎÞ6­ÝŽ“§Iý;5›ÔÅfœEÇ �ç]ó´¡DR˜ªg9e>~uÚX ¸Ð!3)™oN&™¡¼â¿©¾Ìݵë$8çýGû¡ ±Ì9´å¢þ½µÉ7—Á)Æ2-HeÚûÔXf  # |„ߎǬ mx!bñG¾¿,.Ö4õ]çéý!áWï*t‡TòϾÛ»j7Ç‘k [ïLïY« ]ã‘]ÛväMå¹õ¿ w»ê¥Nðºq|E\€öc¶ÕÁLæh ÷ü¾š\O´XŠ 6‹ûÀ't¥âOèÊ¥'}ËÊ\¬–Ÿ½W¬Ö`«´+z Í¢F½i¢Z‡K‘I`Ë$Ú?›wï=ç‹~Î'ÓåUj]ÈÅ*u=°9â—7z˜Ú5}'#$µkI<s‡C`Éœ`ÚR†Tÿ:Âc'¸Dò 3‹|¾¢¡•¶é½‚èå”&XCͪ‹>)èSÒãÿØ0f¯°Ñ¾3©ŽóÔghcr4ålRYUà6üöçäÑ8V¾‡==‹”M<ïfþ·_!«*%VÑjÇr—¯·_-‹{Ê‹ö³}õjn‰Õå*ˆms Ä;]†/;‡Ã]’¾¦ ÒÜÅêxxÅßN­G×®ÉäþÞoþpKîK46ÐV«Yfm˜žÙ¡s§ŒKy‘0uo Wš7IîêI+‡Ñh¼µ!9C¤Š¹k?®§E™º‚]•6 ²ö¤¼i$ÊΊݵ…ž_14ÀÆ’N•TäÓúžwÚ>H¼±‹™-œ«ŽeÖíëµ:‹w¾s¯Ÿ“’§"&^ ¹œ.ÝŸª¿+nòè8¼6°´ã§*»YÙƒ}‚¹{J:èЃhÛ±£“š~Èÿi{êaݸ®FÜ­ˆöR)çËïus;Öy¾@q·¶2à?78pu§ê­} ªawóŽ(þƒ•pÃyBa=¶©VYï{>ܹm80B 8Ëã<ÈÞu[¤i¥ø•…‰ðýG·ïŸ²azv nOиúÚ¹¹ ¯ž=ëhmܳgØš!Ž3îòî³t¡:%¢q¿ûh0AÛ´àÑ%6±h³ï×<çž™%ýÜeRyêêø‡9umþŠm»i ]�.cJ8ˆv‡àù¨ëÞð«L]·ÉÔ³É E%x4ê·xoS<L×ËÕbø’=…ÀØþEdX®¢¿ûK½(òÚܸ¹ Я¹è,X׸ç(†V®‚|h%›�÷»¤ÚáuŒYúÓÎ 2DÌïÙÌ yŸÇA„’ùêð|+¼ÜÑV„ͽÆ)p3ŽðG9»¶»ìæ»/Þ°måI<`Î1°W³$ñ뫵ޙZÔ Ïß|ZÞ£k_ß:1±zÇæ³¢,²@ı½ž5n Ÿñ%$\êæÛ8VѺ=}C¤C‹‰€û5³!Y”lõ\É^½†ŽÚc†îÝ›÷Ù4·¸;Íö%?ö*ûïoV”úLp ‰YÂâ´Íi¯Z¦‰ XÕ§sw¢4 ß:d@uÖ-«Ž:£\þ+ÿÃ0õìcYÀ­æéT×8ãõ�yפß i¡ãã;}�;Þµxùé}œÙƒsZÖþóVú¤qt‰ºaÔ©†H/ÑÇ>´ú¤a ;»ÛŠÎ4“©':“9í£³7Lè¯R;vÆœîòl”F¾ ˆ¨ý]«NÅ1–’l†¯3Ŧ—atu[ø´  nÓ{²iw]ãô!IÏ ìÄ–ÂBV©èK³…j÷À¢ˆ:[‰Ðc›‚ ¬Ð@þ¼Öà #φEÍ{XÆ“6¶)—¦  ú ÊÁfßœ¦û#y³åw”®'Eèæ‘h‰Ay¼Sàî¼Q’s ‡£û_±Œ)•ÃWLœ~|è¾[¶[3WÐÌ êz€ËØbôôÿ‘UsÊeŒ5èê´}(YŽ®dåÁ…»ÆÝ<Êi pdí= RÈ:;I°—#Ï!Aìe/–A™ ³ƒLKÆçúµ¦Wè|ê„œ°1LÖÔÖæÿà¤qD–¬^„œMæTí?Q, ÃÄ%“<´ïNižÔ(,ÇDg°çÚa­>ÇvKû£9õ2dùQa&ñù¶nè/Hvbœw,1+Ç] I•Þåøœ›'®;Ëýõ†ö}Z©ãb¤ïØ(½l.›Íxaq!ÚÝ}óì‚ÎäĺûI&´Þ´0:u÷À…ZE‚Qsl›j?îZÚtô̶C‹XÒŽGœÒÿÒw›V;Å~Š•siìªÓØv°›No¶`a2¨®ÙIDWñ.QÔTõÞHbUú[ !3t¿­Ð£˜¡ â«©% {õ/·Æþí.‡Û T…~Ǭ¸-´Ðú‹÷+þо­€Ušl³dwZôÕr"ÿÄñµ\L#–�¦è`%{LÓdwÍK¼ÝèH¶ cŠx¦ç®î Õ™~%ìîD͘Ö×_/ÙÚØ]ì C–e‰´ó)[n§à†«yóL¦ ?'4‚…GÔó…õDEH5*ƒ!t®±S(Zôí0Oßë»Y¨„OÞv)å2ÍVAùŽ,# `ÝÅN—Ä«|å2rX¡•Ðæè€;ÿu›H9LƬxÚ0Ï8dìS “fòÕ<ý]’GæÁ‹C£BòœN Rg)êL‰~¦6–yUL&ØŽçÕû»§Ð¢¼áŠæ £6/Ûš*ÑÚ¸ ðRÀM?¢ïònœYú�@9ø‚‰¸±ßÕW£Åf>¬„–Óz“dAzÜyìQÚ^†Ó/ tq˜ŸÁæ‘AR6ÐÛ|i6ûîú[“Ä/í€êN’ k'ZCg„Sfò :mD'ó—˯‡n‰q‰ ³±É»ç @aŽvÉWµ=ù%†´ìwx_×$3’H«{Ü̬*P±gÄÔä\Œrý”?y3ðª¤ýص*éâ@a´�ç…NŸ3¶<yâ¼7“FD0†û†ÏL¤=(®°Ýj4Tе]!Oè@[‰ô6OPó®tK dpMÛ4´švè ivžÞŒÆÎdªFh¯Þ½ÒÞq™G©‡ˆ Í�|§U!0Õ,ðç?ßê¿£|a—AV ¾ÎÚwrrQNK-¿”¶÷¨w•/Æšô±»Š‡÷“«ùP…¿±……'=±áyÞw˜…–à{»¥OjKå\ ®‹I9…þª/c«¶··‰s´4Ÿ§"üXa5z4Ó\·¡zÈ» ºãp¾Læ«OáNŒP]A»~sQ¼$èTü5ö¤.í@AäI‘V(Aß ¦3<$N†„{8u“•…´„´cŒÝѵ]{±º2¦8O<¾8ƒ¬‚®ÏmÓ«ŠŽ»|HÒXòJ0W­è¨íD !ÂG~g‘RÂôÝÏ\‚½æÚÕ¼ˆç¹L­÷šòÖ·†K#’ÂÒètîW´~Ë-I—䣜J7 ÌùEè{Üp””4ZCg6«:9LÉ'Ò/ü®ºpQêb)7x›Žža§JØ<%—.œÇ[_ˉù§µ›§Ø+c¿»ôQCŒW„úTuïPnÀé·]~KQu¨ÒDÅM¡¨æ¯k&CdSœego#>ýRÀÈëma¶òè©|æSâBñÜÜbÔ>ÍVôúeÅÉÐUSÓ³žª, J;�“ªH%W}°ÙS2pBdwWÏ™ö®‚MŒ î*=~R vÀijB?>½‰ `å•ihw¸¨@E„Yøy‚M•³É`3NVÊ~¾–=šÙåʃff²`Œ¸ûôΣ^¬\Æ['‰Ÿ8«0´p‘º„ÀáGATz¨˜æB Pת«\³%Û¯;TLÉ”ßá{Ï«¦•l;X@Ý=ì>”°uzÕ‹¹÷ë„iMÖn/%µ¹¼†^G û¶ ¿aãu%µIAÏ ì‘|óÅ1š7ª+™¹K5i~²ÒæÙBŠDŠß;TÝ{èÑØj(ðYqÒ‘v§6Ñ{”?Ø*nY?ãî Ãjˆ)¶xBCÊÒCÀuqzHWñ1ùÔµyyö‚²-tã{nWJöžÌ½u½¹rú©ç»ƒ(Â>xMåR0»ÄMí'xaXú© ƒz©þýªÌüë ÿˆÇîæóÞ{< èJ-´PZ*Rß@˜v"[¨N[¯«�=ˆ}¥ÉìsÿTëš$�OPƒ û_qÅp8vBó7_\W~خݽï,,Y>7›ÀÕQdSíù¹`küíqÏÁk¦ñ©U'û :L3Ž¨Î_KÚä&{›xp&n¯Þ%ôÔ$fX(»Õf›*z£]Cw¥í,ñn -›¾¨Mê'¼ ©CQú#’=¬)‚ZÃÓŠ1ÞxëîTÛеÅkY ¦®äU j.ƒèK8Æ‹ƒH››i+rtô:Å ÙzBpÍhô'¥³j^FEQù†ÓË-m[*x¼í(ÕÍÛ/Ä*(2ŒÎÜüN£åiÏ%÷4õÄ‚-edÉçÑ“;ÄÝh'O›ÆóýîrÙ³4³’’ÒãѶò…qÉ7I‘¥,æ8—Aت²Ý)ò²l[ïÿÂ=ò›`ÌÊÝU” ÛŒ9øÄôNwd<AòùIè»Ø™ÄÛÀLûš.´�¿´°+™AïYN;œjR{Ü»ä…ph<ìÆÁ©ÞäKrzâBd§¿fÕ£Ðk[Êï1i©à¨iúk I9_Ö•õ"<ÞBk÷†¶©£Ø*3¨Ä ’ÜQ¯2v¡kÚöZ¹¬þŠFº?#¾/”`«LÞ|vÑ!ö¶Kÿ[ÇRR\*¼é‚Ñç§Õ,Š^Sí"]´e ÖNŒ·g“ËP¨T*að¸è‚z¢‰åÝÉ ò9p‰f!ÉíB&ÀöÝΩCoÉ™q2ÝžÛdKh%/‹õhÈ` 3*Oÿ³9_èß0 m\wñKÇÀâ3’ aƒb×Yñu–dáž>°WÍ¥NWYÏŠÓ4e¡ÛêãJ8¾„f§… ¬¢`DâWmlJˆˆ}ÇöÂnËo Nu ÕH± Ì)ä,åDé™åÃçbNÄ»e¶o"$}´:Øç·ú4hò8Ë×V<B€Pÿ¯_˜&æN `%íBJ Ðø·i*Ÿ–6X³€·Jé?oF+_=ÏôLÖ¨îT¢‰“æ¡ÚÓ† ÷´EùÓÓ8N}\YÿAðµŽæ>xWõn¶´kk–ö6þŠÁÔ_U ¡°š¼÷eFú½f\2šÔ‘THÏœŒŸ[áâÉàõ7¨¨(wp]ö‡\à%óes‚Äh¹LœL€$6œ¯^¬ÆJ™.¼ãBð¦"Ñ×ÉŠŽ¶1Ñ]†ìÒ™)ú…£ _uø_\‰4ÇÑUª7 &c_ž§'Òæ}gÃyoÇÞ¥¦ó…b$¦Õ#ÐV½6[6ŽX¥¢ÿ©‡ åÙf¤'ã‰GR—^Î"–»ç?ˆlUï!7`Sëpê½ô¿ôõ½6*â°(,ï艾¬ h"Õ‘³!iýaªµž(™1l.¢y\¢æΪ&¡•¦¾òNí¢äô3QénÍÀÄç·A 4ÍÛ^6¡[1ÚÇíÁ(õ…þÙÃ& VÝÖZXoÕÞID§€kÍ«ž›Ú„qìÚ²H‚f¦Më|3™ýïÁæä麋s+¤=#õn~ê´ÅV¾±ˆÕ­êºAVâPhƒ@Ž)œ÷Ü+ã^Áë€NEÎÆŠº™Å–þ¹´“U®”ü$_Fm–p¸ã ±�~lI1Ðc>©.8Æ{•Š~ZþF¶ÎSPÎÔÒ!žY8u¼²E®°íy?=ÒKRï A`Q}|w”îcë|Rœ½ÖÃn\æ!vcÔë!rk¥ˆÙ:–VRµí;öþp*ƒÑ@Ò;¥>T"ß©¦Prœœ ùØQ{²,VEN¿>IìCï�E}ʽhÏLÚì¶x¾tèeo¹Ù(Zxßç]i\úòX,æÕkŒ¶¢NI-Ùk‚^Y|5<ìÍ8{,:gV¦×¨ú:ôÆÓ1IEž˜¶ÄŠ•ãC?£’ç/KèŒV!ìè5'y(‰ÙöD;"þ¼ØðmÎ^u`kOí±…j¨U´dBAÕDÄò[ôX<C,´?¨äÀÞ0/÷õWx•›KâÑE¡v¨Ö˜ÜL\& Ü'»wå+Sef'ÝÉ£¸ÒùÁÖ­‚=ØñT‹ŸœJD˜WÐا;°Â q+ Ì!gXéRu—à?U wØãÂÌ5(X¬¨˜ÐR8Fì_ïàG,ý%Õý껫¸‘Ø!"·c)Ûã œ{o‚/‹Bï0e"ým•¸ÐTkf·ß('8uÀÒdšìÄ7YŒvsÚÚD³|û“¬�·|ÜŒ4¾1ä ÿSú.)zÓ¹ ;­!s“u'h•i™…?¦[çuv{ aÚ|Š]w‡J´•M®ÐQÝbÎZ^´³ŒVJÖ³Œ©×XÛj@[ɘuFÿ¸ÈOs¹Ožmg÷ÄUyˆ¾XL±ód˜=ÕÔÝ CØ+¼Ü¬ŠãÈÕXì :îÐ$ܩ€øÆêcÍ´À6ÁF^Li§U¶#g@hÜêó„–wÊãhÌú(H?}‘=WuÝ™Wypa™g©m\Å0Ü¡\“rGGÌ_WŒA@˪GÚÇÒ¯ƒ}ñöºÌ³¡p¢œãâIÎtûãq?Ï“é°Ü-šãÈ4 R1Æ-¥ê•Š»î†~‡ðÏefœÅ+VlÆÖ-<Å`\¿"ßÈ}+½ÃG׈³çá)å[äÑ–9r[·5C«W^#U>}ª#ÔWçÙYt NýpnÆá(üèý¡îl¶õ´‡(ñÔs+€#mì¸ÑäÚH§ n]5û/‹P`øíÅ}àxùA ê -æZ+Øî;kyãoÊÅ*O8h…¡DÌÞN~è.‡ã~í”Î2Æ÷¶'lÚV iÊ#Š²@(*ǽܲ‘8ko=“ð,|‹h^5*L)/NƧ4^» U¶¿1­ ݼ*el(3£Â*zÊÞRÃW5{/»°=Ø\ƒ„=Ö{.Ù^ò )<£{9aÁMšT@¨-WõÐû}+=J(œL¦¿ÉZ[¨Ûêó­p5S3犫N+H)çhõ³ÑΡO Ýc¼ßÕ·<š’!•ÃùÔÞ¹Øx()Mݹ4Ò’UX,ô5th¼r™jÎyðD¹ž9#Ö3Ž5Ö`íåütÁ2Ëù6fæº ¥CeÜ’M2²í45pášÕ0ntäìé¸ÊÒþˆrîóhÚüõÖêÓŽâ–!ºÁ¤QCc!Í¢Ö²èüª:Ÿâ»æçŠUjX0 úÜ9›¾¦­[kdþX- D#Ö*µBËlSÑûèæ5dlÖA S»«õüLv"[¨Y f´žÖN[ó[€üdگɓÂoñ©t¦ƒ!þÔòžþ§"ö®†×ÖZXFò;¯Õ¶'ª¥Få°¡+< Dô6Š@ãµ½1(ƒŸŽQWÿ†c›Fî³G2‹¦o-Á"+ÙØþ"ðR×<û¡³¨kS$FG¿îaÌfExqäœM…!=%#ýx¿S™92À%TSI¯Uá*}‡°|M¢C\ö8¨„Ü­Xù/{Ÿ6™ÄÛå ŽÁ…œ³ÕŽ\M˜z¢uR^´C!Zjn¬6Ï¥ú›é€ž`V-4§˜¦AzÝŸqdJ³Òç}ÍúU’hº;ÈjëÉbµbšKÊ p+KŒYÔnÐ7®ÑFdAkã4ä}÷ ÷–‰;<JÎ3é<ÌZ=ÙQ _s_Åö$yê×—<é¾t÷ñ×´)­W(#óÑîº=FIžºhË3©$ˆF›[§Önz¬^6û(Ë…OiÝÞœ(W ¬,(—ßsK»u2_�‚Þ]%9³áQíçéÒÖ‹ 6^©Iµ9fž^]¹G[Ö†r¶f )‘j"<€Âì]£(ñ¨O¼/§–ž^Ò[h_ƒ†Uï"C¤†Û|;××u!-gºµzjy§• æO£x{V r,xuéyÝ̯³)fÍ”KD;+è©«K+¥»9æhC4”„úõïp2{A7CÁ‚{:»8o|‹Ûpiã®·ì f<ÌÊÕRç~ÛÑñzü¼’XSa_iï#€i&Ò t}¹_V†,ŒÌldºÀÝöýÓú€µHÛ.˜_@W}Í€ñ)lôá¡�ˆ$*œ’}ÂFo}Ä_Vs¬FÇ}²¢3t�Õ`⌇ÄxÊ ”ÄfŠ ¾éíëÆóˆ°ËÐb[÷è¹éËuÑ­6¿– ±þyŠw«=žs:Î}«ÄþÔ‹íÏÍ…è·4m®uÈW^ÈáþÃôKÍ—óÕÛ _\õ˜–Ê¥1_f±wW¿Õ†©ZŒç1¢€nՕ㨙dñ¥£†HÒ\¢õqÞ`ÖUY;ÍŠ ,±§²1AÖûŠki†Ô„VA4öâ1v-ŠË«–gÝÇï`H©hµCÛìûJ:AØAwIb÷hcqûå <Þ'úÞ1 c§ÃÅNM^­<Bʵ@a`Y°¥×Z¦©Û ³fÄZeþW:y²ò“ª!0Þûëm‹¶;(÷Ô˜/‚ ¾‡¬£+øAŠ§: J—§óñQŒt,ï;eÑ™«G¡ß\ˆ8OÀ®K\qɲ´•WÀþt³¥jç,’Ö)•Y\*Ïj™Š‘ÚSñµ4ZSàSæz÷g°Ò2*%‚-=åbê=¯a›O©5ÏÇS„_d û^³ÂÚž(KÌJM(!¨ÜŠÉ‰Áew0¸Ó×]õ¢P [œÌ'„"j§Aæ2~–yZ«ðÈ·–LÖ¡%7`̱ËÊEÔŠ€fÎ:ƱÃëû—:Ä–oC¢E²°_ƒ©‹‚¨›¼LG›žù3jðÅD¼û/Þ|.3È„y¢¥y<y8 åý÷‰D”&Æ#®4B´ýXéöKgu"®¿öQ•Øsøõ—oÑáÕÌ„ÙAÔªë ØP>‹PdU°CäW©ï ‰ÉxXi¡™¦’.;‘ÌvÇ>qsK&ò*$ÍyƒêšfÁaSÀ½V([ÁØÌÈ/Šqã©ó&–X‘¬}íÙxß»Ñ;•Œ¼cððQA’[ŠyÖE-ú0¯ÆaÏ]GåàÞº;—àÅŒ.f°mŸl÷iøƘ¢Ú¹Œü„mœ¬œ[%g]D6ˆÃa6pëÈ×ßní(M}5LH¥v,‹oÆ`\�Ž&ƒü(Yñל(ãÀøö¸ ©ŠÏ•È'ÌËÞu¥¨ tOÔ¯† ß?]p]ÁíNA XO~ãzÓÑgd•ocû/jó'^>)£¹n1i3"¥âˆ[kòkèРò~˜ y;LÇý\yâ‘@'ªœÈ}�õJ9µìf6Gc¯bg‰Ì'ÙFÚË ów“æ0¿â0w¬\h-D Zx×xRÊ)u$ñm×4F‘f:ã<Rìû$H«Oã5Î>Œ(ÏŽ�ò[Á¶$½òa;|$´1ßõŒÌÔ¾´ªQ°ˆ'TTz‡^ºÂ]&ÔŠvˆÄ˜™ŽóC5YsÄ×jYhe(eSµ_´ŠVÕΩ…‰9í¶Õ{t•§·¹:óG¯FÈÀÕ:òÊæÍoÕ–å\†…²N—uÅLo‹,«f„W¢‡ãQ¼©{_8]7TÁ¹\& ÐÈb'“Eú£òÕgæ¿F†q¹07ÃdVÑgçõWã\Ù$Þ5~ï´€­½€ž’ +‚òt2f­ÍX]pƒ¬Îè ô(•Ùb˜–Ó-O‚°»xª͉%ÍÊO¤¸_{vO>a˜p !ÁUÞžûŒˆâqÖ²}mlî^[ÓŸ$*ËéƒWSŠïVñóF¸”›1¨Ì85Ãí;½f&X7Tè•lêJi0 ´Ì¡ zòÉÝÕ­x¬+%Å]N§§­—VÐ:h­8ñ˜ŠhÙÿ{¨¬+Ýc×ö0÷fqüpû3Ô0<o^ ¦LlÛÒ¢32ßËîÙÆm¸Š“42ÈÁH˜~AT7*„•{pJaÐn(6üfÚÞŠŠ÷}JÉ̸°ïµmûËÐê‚k,Q­ñ©}FÌ+ •£kˆžø°˜ =q¬Ë½q‘±„"¼>yÂâÇ=½³o7pTv˜¯nMÍR<é¶Ä€†Ó‡7TV)ÓF¸ÝŠ¥XuÁ(ôfvûÆŽŠÞŒAìÕÔÅp<êÐ4eAÎ.X²+YœíØ«ÆEx;îbXïÔ”ÐÒÁBƒ8ŽT!ÎÚå“#~ÓU[)µm–'(á™wŸ ÿáÊÈf3Pö]A_‹ò_lLø(»ÒwKŒ Ûx %y·”Þâ­_·?iÉ'¥Æ'hò×í™w+M�ø5Ä@n@¿ˆ0>oxyZºëŸþGü±_,­1ô,·ž0ewé;ÛR|fãi‘abªóéîìIÕzU2Loð¤û+".5ª†vÏÛ¦:ܺ¿Lóù‚â )ÿ~»)Ï]"ÔùRºº-™{'¡9øpÚOÊø½¦…®?úûR Ž‘ˆOÓùœÒ¾Öq͆0àv—QZÜyR0Ðô'˜À~õ­îͤøHa29^œGî`FY¿©M³Ðz2Îü üFo Õ†ãÑ‚CCŠÌ‚-Cìοãì(šh•G?Z¼tbÙê2‘‚U[(Fãå{©—ÜooÐBjû’ê`}¬üÇy¸ÉרDãneUט%.¾kG¤,r‚:6ž‡¡vpÿçtQÝ"pP*ŸŸbã–mä^¦0ä^Œ¡)‚ûŸµ˜sXžps;¨\âžc‹bþ€ÿ$7# ”·NÄޘ2ÓÊõ½[&&:Ù˜\5 ,©2bó>z_ƒ%Sæ�à¬Ìù«9X–¹N0“ˆ#¥ŸŸz¼®XD«»ÀºÝÎ5ÿ´X¡×WX•ÖJxaä‡Å8QpÎg « š¨70MÖp^ðý^t&´èù.§rR£b¿WRýOökòìî'4hõ««û,d¹.v†1}zZ«dFxÏ»è·?Ï—|ýY†ŒPT¦LÆÒ>çvË–@¬[Gê¢Z3Ë່Ãib¥7d–ÙÀyº´XÒ˜\Ñ£PѤ Âßì컥Ùþ² *üŸ¢?‹)YªÍ>öÕhÑÛBxœªþƒãÂ÷rJ‰ÏL ‡±?RB’|že‰¿UY€ý4=lq¦Ö(.â‡P}ÂE‡ @Og¸(WÅÅ`|®{çUû®UªÖã*ÈzÕBiÀsvë_[1=ôpˆývkÿ¬ç4HšOOuuKé'›£Â¡ãé…•z½ö[#÷Uhd×k8JŽ½‰,¬±<|±/è^IK¢œC7šjaq߸þÁ³†j¥>õ\iP8À�ã©€º'ˆ+ù6†·\ýp¹g3؆­(¶ÏæëŽ 8 T ¥ØÐù³cmqÿò™“þ�Ïv¶DMÛA³¯|·âô'ì{S³Ë)”†6€OѺ|å'®[˜” ÿǺõA2NÖ[,ól¿ÔÆ*]T˜ëð…¾ç8:6Øâ^#Om±½šõ0+(Vx‚C,N:UèIï<úŒºØ±È0r°ïjáSHWKVNw«cr–E—x$îìïEzggP‰½m‡‰b£ ö8éàv?Ïæ$B úú-'+_¸-bÇÊ76­Á{æÐ,€ Àn3ßk+á=xVÿ¼­w¸?,lJïWþ7ôœ³ÅéCۢ΃¨ß™ýŽñé©ß;AªöH²Jz¸ŠÓ†Ì•bQ’zr(Ø|@°ªïf”4F/%§ÿéÅüŠÃ7<m>² °@´0g…$ÈçŽרNŒë}Ó(Ty�<v€©êŒrôËvSýÿo|k·$—Æ0uµ¥ã^7þr¾_Þ%Jí8õld2ÄÕäJØãÉ= Q¤ƒBícMÛ’ÖŸVÅ£ýÿPb¡m¬Zô†Í„»¥ê¾5­JrQM6RÞÖ匱)§‘¹Dèo¡Ýo{nô´gÈ×°|áŸX“v Ãع�ËPk]Ó}wŽþyÞwœ—PV÷áˆϯܺS¿DŽáiP…Ã$&HÚ„Ûó¬Oê$ ·Á8€ôDØZ2\Fà×eOjöŸWX÷KÞVa¸òÍ¢X“;N‚ü«v¾\h™óš"¬4­õBòf&_£¥RÏ-¬ë‰NèæÓÉ<³„û¤ˆîÍü¶m‡qÛþ`x…ažç–&‹¹¥1ÅIWå“}€^˜¡6X(î/”¥œzª¤ßcäìJ¨ WJ&kÙ5ï#r_¬6õä$±y1-Ê‚tgS™U 2ÀtÛß̹I·²iç¤вåw<6Z”Ú§N‚¤þÒ‰]ùÞÝo´‹ ïˆÛïWdx4÷X(î~˜+Ó÷¨ºŽžnL§xÅäCE:NÛ}·¯˜:‹|=#y¡b{ýY¿úéÈX8­wqöŠ[ËqúÓqg8£” J`ÙƒÀöúŒJ¢ðs µå›ÿâõ^f Ûd&99™w6tÜ÷ ¸TÊ÷¥ªÁi}ÖèÄ,Ze÷㮌-2±Ë?o©áì4*4cO†QÀ´‚<º~½•bcÀ\)á·R6_J9Ñ*•38 ¬tûŠ±J²hLGìt–+ÛîÞY°Ì:+ƇKC smˆ–|“"Ç©¯Y‚Îã#áZ5V0>¡4´F†E‰u5Ã;»Ž²*I}î «ÿzEÛÇþ .í¿±[u]_þ LŸCððTžn•¨q+uw£F“Þ^ÐÒßÊôä=mþžæc×Ñ!ã"1èì.¬Lʇظ»túåÔ r¢,ì|iD(Ìá8ѪwLÍ>¨Ýs®ÒôÒÁ'ßX5ŽÜñâ´ý@Ÿzµ9™�Oú3Ñë1R¬kú²2~ê1Ä2£ñÅçÑÏçA³E Ç@`šáÐS£Ð2s¹¡Øq²¯UÌÃͽмí˼Q¾äÀ‡\á'Óh Êzx5‰|p¢ßr7Âͬ³È=ÜÊuɷ˦ tà>Uùd3ªáÒ ¥·|Óy‹ ~ñ/—òßQæFìq[×°¼êgEuAÉ`œd$B#ƒÿ¯^‰áÞÕ¸RÏЃŸÍBY¸Þ˜>7ýj㣈»«ÿQ'w4n»–âÆæ׎[Ðs{M #‰�@Ž€&Á‡Ü] Û°Å ´2'‘ëÝçÜs¡ª;íí¦…r$¥&6Ø@áÁìûß\E之TwE6jL˜Ã‚¡ê?øVš_ËÔ=ûåA-“øf$|nåTÜ·:Â~FjF)ÖJ„^´k™Ö– J&&ø~ž½àĺON,Ãçû>2¯_ùý4ÕkJÛvÕbáúò—BâÓJ^š›ácZ:æK»Lƒüóìê nûË1¸kXØ3Aëߥ¯…ç,Yk¾lž-KØ0æfO/Zñ9DzÔxüð¤´ûô¥õ¸ø7»èî¤ôž¸n¹p€çiGuniM±[Bõƒ¦%“÷Ô\GÒ ÑZ(Oý™q*FAEÓ:åVC·j‚øC“ <sç‹DJ+ò¯³„ë¨iXÍÕ½Ûy÷.¯Â|Z8ù6í„”hñ©c{öPÕGfË©’è+Š¢VFܘóåÂ�.më™5_p*³¨i9 Uô 0ÊþÔ“l%#Û/_èû¸‡¨}˜s/;ß(¦Ýjݪ…Yè«q‹ :ýŽwëä*CƒÃbMxÅŸ)Â)J+}Ö^²#¬îðÇÖ¤ŒqßÍ#…De¥£È˜‰·•Œ[«9îÿ‚¡0ßá:«<«º—ªöŽ¦®ü¿Æ¦ pz¢:%Ú HÞ౟´ j,L†ŽÉÌRbÀkjAÃQýŠûøÒ7£\9Ué1í 2ò9»±¤?Aá­Ž"WwÜ™¾óפ«+ëºcåhΪ$CÏxÇÑRiìƒÓ:PNAµ^ë3Ù]ú†¥#qÚ§“Û’ ‰,;ÁHñ´`ö$„ï� jìD…ër„r&BÒè¨õD©Õ;SUpO~Íßò0ÞgŠ(Ñ{¥Ù4´v  fomÏî,Jkß.egò[èt�èÏ/O†c˜fƒÿ”-ž¬<íÑ „îh¯Ç[’ÕÌJï=›ÙŸ6gÒpåɦ®"FbdµÎ€ËÜ´t“ªy¯×Ïz¡á*Zy8bü¥Öuc‹ŽÒø±˜ž1%8&ÒîÄôê'Û¯õtcÂYA@« ®n)˜ø—DÆïÜUíȪFL3Ȭ(;æ~sëòëôíß·(6p’Ö qG:‚.÷Èc/CO^tÍÖUæÙk¡܇9z0ï “FƒÀ»°“-#·!‡-Çá錑µM²S& M?2÷ÎòR½»ÖMtĆÇƃ‚yjâ œ˜óþ4MÓ›"¼Ù¦WÑ銲C';•'f.ÇþÑUãžõÎs’ù›[ðäAQï¼.ı¥3º@ráDĨž“€åwèêÆKx�¼×ÊéâñU?Ú³-UY”žVk×XœI\×–âåÅBdŸnH F°ÂX Y¥0ÆZ˜©ê7Çy¼ë~úÍiš¨ÀµXøarw‚ÈØøÚ»ÀÁX•´ê£UZi{\Ÿfî”pÜ5xneU(¸;Š3DDª<²A>Ž¾|½µ<¾íã?ëèǞƳ¶¿.A&ÅÎ4ܤµBÃxÛ`¦Ò<3–©×¹@ªLTU¦£6üx™R‡ìqcâ’)*�ìQiù[Ey_í‡Ù=„‹0Q4u2&¤Í”âp9ò±�sÓ…JàQ ˜h±¥A~¬<wk{{vÝ©Dó#¦yX$!™¹å-›Z!€Úì{×—´ìu£�ú«Â~qL3¥j×”Ad+Ę½@.(UÂÿÍAÙ]=f?‡axÅóùJzÖ‘P¹tÆ´/_.-dƒgä+øÑDŒ·w6t"˜íêú[3šÇ"qêŒ}L6Þ‚< Ô_D±öL(£‚z¾LÞ{=ž´x¡#£‰s@M:¶^57ýÿ´½Ùvêʲ&|­ý¾úëf¯3Ô7—-–ÄÄÌQïÿ|™):c¯S£NðÜ ƒ”Í×ÐU™=t÷Võœž–?ÑB£ðåž¿ïzC¥—jn%Õì=öêYØ8*0�;3è¸PñÖ²¤‹Eî.L”¸'A²î¼dhoÙ ÷m‰™W‘C‰…L:€ÕTÑ)D16JÌÁ7ô£cWõas÷Ù=´¾O¤XX“b)ƒþ(Ln\oT þO:´"s–ë¢6PYh[Ï•|Õï¢g<µêvîõàD‹ÿÙº»gíU†¾' Ñž¹l4?yà9Ði}èk7·½«[ôDÂ(M¼ì!ç@™T|±àÓÒêPè®5üðååµ÷¬±'®e/’ÖÃó)YAcã¬íSJŽý„)Ò5cù?¾{“ËØ"øe }‹ h.ÜUŒ±’V‡Ãš›BýÀá1më³JpRÀ<Èáû%Px©/ﲶ€æ}Ô{ƒe4lų́®@sÎuËÓíY[V^ßn) ¤¦ÜìŹ3ièÉ´«õømº/Ü«‹·|y—©QZñ‚Ô ƒ7'Šƒª-¼×«C3½o#ÓBÍ,DZ÷ÏÏiI¸@QÐkÁa-?GÏïØõ×Ra¼ÑÊ*ó$­CÐU#È”Nž*ÏÒœôâ‹ÍM3åôŒ©�ˆ­LqÎä!\Ìú-û´´¤wêïµ&’¤¼š°7LÛ˜4ýp<™qxC¿ò†‰¨v —‡â´É¨ôSÁF´‰N'½Öe£«ín°Æ‡ø)Ä&ñçN,;ŸéËlµW•'ÀVí/Œò²˜8ÎRlEî<ŸÕü(°eàS1J—­¤ŠÛƒî|aÓ•€.uVïÖg¥ç“Ø©Ë7ÚœÐk.^Z½æúèÃNé>œµ¯>¸4Ýbµ„ìF nGwzúëk\}_ƒêñ‡ÍP‚o]²+©éì>>e©îüø==Ù >WÛ´¤[Úy.ÇÒWRí}:z}X¢É}K"4*ª»ÆKpV‡ZåBë~Tñg¢ûm H((ÁvkT³QA#û H0ú­õÅMÝáê>x®†ãi匿ÈZCH±DMƒ¥Çvp2G¤[¾ –ûí²©Ç¡»g\Z-´Ó€9 ˆ·][ÒKaÚ+Ìék´0Oû71Ý}tPÄËé– j :o°Çÿ{/øù€“Õ2<ˆGâZ8\4D(´Z [LÐøpLúxÙ§^D>š*céK¤Ö)“Ã#3ƒ­‡ su0örýÁˆ+ü;ÅjV¹z2bšÆÔ¶+ Z f$à¥Ý‡ƒ ÝùðH1Aàæ$VÍ@ËzfŸ•ÚÒ†²™_cW¥×.cA¼ù yÀ‹sâÌýˆõÂÀé»=>Ì,¥%ä‘œ–Y4öKß2©<MuwÕ’}ñâqå©o/}n0Í­o:¸r’5'A\Nÿ}K‘_ µ›]c!Üw­X¾ue)¼C‡oý”Šj˜c]¢§s<ÐÅŸ’yZfåÃ\/Ê(†(Zmæ±¢‘ÌòX·;î“?ÃCdY(î•™¹ˆ-Ké }ŽYöLb¬‰ÍwxmyEV*œùT´á_”|•¬Í 0˜´t»½¦7rŤùˆn´ši4*ºÁç”WNචYxæ€hnfÇ"œð\ÒÔÖ`ŸÜ+T@-ˆ�§úÜ'ËKÔ½ ¡ŸZ³0áí³ëL)µRCÚçj†”vʱ¶½ê–Å45C¥+“š gíu{ºžWQvE©è3Z#ú”=Z[.W\Äí“[çê3C!ÚÍõÙ‡š±Ô LãÔô.Z•ûîôŇ ©wGcu ÇÿÿYˆ�ybkQfôõAìO­W ΓWãn:î´¥Ôž¦û#AάI8ñЖ¹XÆ3]‰ÍႱ;™p„¾Í”˜€ö�§úùo’XU:©ÉŘ‚.³¹Š:~Ñ!³ ÈË~¥§ÎmŠ†þz–V({<í™:)ë„þ;9¿]&Érh•ðä-›pšÕ<}¡]ï¨è¿ôÝ }ØC\Bª†îöñì U¾ª-÷ûLoì7BÈîTS›€MŸ¥|CìßCaÖžëÑæì 8\¹`Nm˜5Ò= íïQqJED¶“ÂE†¸î<‹þk;çX5æ³é'-N™Å‹++ÌÂb¸DXnõ'Ié¼n\ 0_ÚÜ ‚ÁråÅ7ˆàÒÙD $£ŽÜèýK完ȳL°èïg0ðÈ ùe&Ú3~ÐÔø°zj¯À´“ÕÛ'–¼á‹iåÜÇœÖé(î!±`ûöÏ[j:éîØDÌ�QÊÎ}\Ò®mÜ– OÀ*H·½câÈ#sG%ZýØÐÊ¥† ø¹n ªmcšQø>Ý°ÙqöxØ™Hcœd†æ ü‘7ÙS_JUñå§Tkê‹3M‰ôæÖÈån…•²Êçr‡e0nò ©ÿzšA0Z€užEL`Ò†V †ÜªpWž¬ Ë(b6.ëc¶ÕsE®+Ë lÜßjdU™æV¦žó) ²g‡å—º·ûµ,Êòiå0 Âº •Õ–HÕlcu¢Ühø¢!µ#½ÔÌy óùe­ƒ7®ÍǾ‰›í¬ôÍ/x3”©<3‰ü9ÆpÒj&CŸçŸMg�|sm *öÉØíXø,µ1Ar­ÄÄd±ö¦}ÿsðf¬ó™ŽÿõE¬Œ§ 2®ðÀ—ù)*=¶hâÝÊûÒ¤¢¹:ïuÉÒnŸ0>±—ëJ¶ýØ )šu‹'Xß¾4mT%¾é,€ÇE‰zòô9)»BŸì@±™•–:Q=ñÓ Ôܵ¸ÀF·5Hç ‡ZÛX “ÌF$îë®­u-¤­Â ¡(>Ö¾÷(L |¨zÊÒB$ MRèÈiïŽêœ„\¿Ûw‚3¥cÌ4Ÿ¯i蛾³iݲN)Š‚rcí90⬠ªÓ§éÀ–Õ–Ï÷ÞSé¢O‰7¼<š ;-‰Ê¸~±ÙnöÙš¶kIt#Dçœ Œ\ùÿfþÜSã݈þ\.²6BöQð¹ ÊólÊ#x§§9o9‰þåŒ8ö,9a±ìãÊ Tx@T% Þ—q)œÚ/®)°ÔÃ# ¸“¯†ù †ß)¸ë:OËŒúgj-§Aô%oÛ©ˆ Â,¨>?M møHQðGÂX%(à2Ê pð#ç9˜ÛÛ $ Ày‰\7.Ðë oV øø W‚t“hóÈU‡¨éîþ3ØØÇÌ´™^Ã~r*sòîÆp8°)ªÊcÞ>¹uñÖ†ÎæD?¢úÓ髪ÈäÌÙ´pÅéŽaæCçx7³öUãÙbÁ™Øi’·ÊiûâG/ŸÅÉ"HO­—KÓ-§ÆÂGÚTæ/:¹O¤÷—7’Ÿ&ÓR-[nÖis±©WÆ«Ïž,ºÇxj7œ=?á«Ì7Ü‚  Ï‹nçκ]WUt@¬ƒ”©š¡oA?ªÁ6ÏCi·JO×cŒlC’žYÃ;Q«ú˜ Ž¡B­‘V3wOŒÞÕeÝãí¯‡&•7ï …Úž_žèV¡-º·¬,é©Ú| ‡3Y— rÁ‚˜§ *Uñ.3Ö¦fû/NÏ"¢ÈÐà勧@ú¬Z0ÛS6wɆµ55‰TÊ,ûÇž.ÖV.6ýñÝ‘‚Lô©øJÚé°ËZ±É«tefÅ™}ìV;\%N³M:ÌÛ$(¬s;sÎ<M[7îy2S¸SšïÝmùÒöJ¾_{d®3ÏgÌ:ï êžâkœ-êÀ$˜>èJ=™lEŸÂÛ;‚ ßI+¨Ù‡fß@läظ~ÉtB–ý¶¾§p‹¬ìõ™~bD o*ÿ´£¸xRWkÓÖ 5Ýw/4f"Û­¶J¿ƒÌ62Ù×bnÃÙµ)OîZ¾èèQ¹e=•³s”I³Zl<9cÁŽ »MÝÜ×ç;àñ7Ö…D OER¹éNєӴ‰N¾ÆCM±Éþ‹W/Ò>ò I7©Ö/àoXU†iÔG½¡ç¡“ o„,>>=ÃT6Ø6{éqÞîÜx¸•N{ÎŽ¥³Ó.9˜Îõ0¨¬ÎO==émiË6E¦Ú¢G)\Æ+饕ˆ=ö¢–¯@2æNýM“Ð7BWŒm$Û“j–û”%“ÔáÄDì~(KbÅør£ìq<ÐÅm] ¦I*¾9L²ã¯—<¼²&ZýɃh8¹ðù“–nhŸÜlB•Ë4Bú™ÑÁ¨õc+Jè`f/Š`Ä^µ!ã꾦k…¢³ÜáDëΡß3Ê}+Ó‡êïiQYÕzn}Jø{Wi¬‹ÉYc_�1Õý ò• ü­ííº¶-Œœ MwëúË>®˜‘ Ã[¨©mJ«Œâü §¿Æ«¤1£Û,žÉûd>ŒŒ0Às™‚Ù‘p¹/œtg#­l³áxb´„å‹vz˜ÊQŸXe´ éÔÅ€ÚRq^8è=S8ÑôkÁ'‹õNBvÛ mg«!Vƒƒ`4ýßÌõ®TŸ‹Zá¦r°VãÊ3kúøå´±Ò }¿â" ßbv&8ûÝб¢$ÁwT!,•%2hy~ê©€fZ¯ê•m žŽª5áž¡;Þ·î±rﱟ(IIÆÙ?ЭÂêž uäaÇýqû=õ`YŒ§è`Ïga¹l,!I¥–¥Ê´£ô×Hz‹<¢T¥åϯªQVú<;úÃÇŽj—ÄúÕ±pË©op/ë�N)¹d[$}¸ŠGIe&·N �¥ë%×KÿÅÐIçjâcK*®ej " »à((©–à<zUÈYÕƒP˜5q¿[xé;´Z¯õl°ö,._KᦑhÞñ^5¬(³Ò×q1ÐúT]¹œyCT½Y1¼›Ž'c3 gŸÝi§ÙD™Û#•qa{ö¶©A÷í¤SB÷ š»Iq³×@‹[àEœg¾s'àLJŒnêzí<‡eÚV_<A–—aamµºDÌÛ=[Èø³‹ÒTÔiP}*(5A[ì@¥òš¶§‘ÖùòÕýr:[ŒFpCj*zO½g#0_†ËªVªÝɉ©=OdþÆ(1`õùœÕ´¶Ì÷Ó†‹K°-Œæ žÆŠÇ‰@WJ…oAUÙÚs¢1G�v]Ý=\IžÛ—²¾‚öS#–„¤õØ]̉ŽÉŽqüÏBgkü–í“G ƒKÆDH‰®nO ž›W°¥s=8ü͈¯nža~¼`™I Ãlô“³]m)ԵƼøÜ)ýß=ëú½å£›=‹C†­,ƒœZL[„­CÉΉ$›'iTUàÎüKœÒ­ø?ì»2-V)áÔ¦V*“¾‘Ìý³»OÍ$1 S_t´® ªÞNi¿Ÿh?tfݹ#‰G»hnѧ¼)V&öÜ:‚‡ÕÕØ= Žº+ xžÍÝþØߥÈ=âP¥žðV)£Ä„®ËиÐ×í…’_XK˜˜²­¿h¡ßŒ‹ØNÎhKeqö~)%ÂgØY6ÄP>¸XùÆ·ØÚ§Ä Ý–Air’°Vå T‹Î÷ÏEN£ÈGh[–|{'ÚGÖqö>¼Ò¸ÚµæVÏ`ù"¬†Ü%£õ¬ Ù ø4´h1þ@¦¢3.íûÑË…N+£§ƒ ßàb•“rƒ¶“ºA:€fÚz<ì'ºžø‘;a¾ÝN€¦+8œpéG$ó�¶Š;%ÍaTMMz¶$ÙBÈh>…Ÿ§+_Ú㡧=¢”M©Ñ(ïš,lk[»I,·¾Ó‚Jò˜<ÞŽ¿#R5‡¿´ˆ¯™/ßa@Ï| äŽS…ËÑ`ò0¯§­5Þ®ÍÞ•G“s*óT›’EèKÜRŽ:t)ü4Õ7êݦÎH>à¶ûBDÃ$Ë7E>VvZ :³â ´ó”*6 E>S:Üõã=q“Ìç8"zB@­ÓݱnáER&)"Ø<ÑZù/žŒ²ÊÊ›0â_Œ3«©óša,+SzÛ¢ç@Ks4Ú£¯»gF¹k`I‹eŸR¾©'Îê@™÷jVæ·/BUU~£Cäü›yRQþ‰r:èŠ žµÇ˜@çVÀøÜRoK7æî)·ï¸j0¥]€<)k»JºŽµçº."ô©d'¾lj~Þ›þz®J€n'ë9W‚-‹¶77j¼{é$br£tj(íÕ‡<–…½/ʼnÌúØ6pæŸOf ièQÛ2ÂLòËË[êýN•ãf ë6ö˜õ0Ù¡Ÿåho4”¼õÑ]jD@®#¶‡£ ë¼Y>,±„Upkð^ytnÚp+ÐÆ Ž( 1/5§Úúä¡&b˜YåŒ_SÚ/e¼kæ Û¥±k™0¦­EàI¤ uÏn¼oõÜŒ £7ή„ªtÆð?(ž©õ«v„ž—¨×¶]J%¸ž‰èðwó¬­‘zîñ¶.-yCÜœ–yŠÊïvªº„ªµtïì©•‹Á±¥Á\÷gO¼ùeƒˆÖJîسL7´‡’¯ÚëR‰¥GxÀáè|Öšì™ßM”ºù?;>÷@uCu׎žá6¹ÆU°v »=̨xQpŸê‘ÏzE–ˆe¤n ›w²ZЫ0; £¨7ñúÄŽ¢”âÆl=Šc7ýPJcØ4™’q€Ò-sÈ…%B\‹ºñÁر îfýäaéN~X˜ó/„vmï[¬a ªLegi…;Á馬y7á]�r\xž0rªþså‚­ÆN+à×ÒÏÁ͵ú tÕ4Ty²¤÷ž9bá¶%wfL¦‹¯‘"Sæ‚s€Þœªœ.xÕ:!úO’˜297†wû$ BC�c÷*h½*‘A2Ášö–©Ÿ¼+ÊIûG0—ÒWre<|ä—ÑëÝÐÿ´CU%QDGΚP68’n¦¹‰¿ó»¶€ª‡'u‹ŠËBà3¼²ÿì6‡gÖ8‘Ÿx³Ð7s‹ùèÆ!Káày‡,n’jþûŽnTEî€iì¡3i)Ý Îtp.8ÉÇš«ôçî>ë® ‰,öðx œ(´Eß;¸‘x�GªtM94¢ðK¢|Q‘Ú‚+žµéu÷î¹HÓ:maŽ¼ŽçOÏ•Šã¨0]iîzC` _$ú¬Mç~Õ×Ò‡ù´×àž-GúŸÁ£«ó8Ï?ŸG¤±·á¸R§/F¹?Z¿áÍ´ËVÚs°À#ÓwZÌ>Á" #%“­PÁk?žFÀ¯£³Äg<Ð6˜ÆÂó@áá0N6÷<î€/Í­8Ñò€V˜R¤}²`8Bßu«Š5 ;ô”¶À-ã„i›\™ÃÔÔÜ;ßÉ`ô‰|ìå+*¦=M–”Û‹SLÑӱؽ`7mY%\-tõRöêš,%B fU—\¢Ã€NZ4ãž¾‰Õe`{$€FÕp?åÃêñ,Å)Ï'JJ†Rujõ }a8·}Ó”¾b–q§g%DjJfLðŽQ·ndñq[>\»ºÅ¥³fÐ&Í‚rsVaš\¶®#-¬¤ö„5 Ä‹i°^%JZ†x¤›†Á ƒÎ.Öm‚ m7”è¿5p,’ÌŸ>•Á¹M(‘Ð4±”A|7²œ 9±oè‘Ê(ÅöèÛ‘eÒoÈnöŒ‹Å-êUPÊ›J Qó“@sè€Î½öBÖÖTÛáÿtÐPž¢¸&¶-w2ØTú­>™¹ès²ÔÄb“úw­«fG ÓÙ§mSÌ=ײºÍý#¡°ÜsÏúFë‰2èl«5Å-}Î#˜ šScÆ·K=JT¹zé¥WÄy4cKO¼ØÙw—þç`È;2Û™õ-šË£cæ‹©bN):ð¢ÖïØ% f³£±ô‡‰ý÷›qÎõK†A„à ïZËM 7Š¬÷ÏŽãœ9U/]oÐc‚Ô[€Ç¢ªÌ–ÜNÖÊ×Jy(YÃŒcmGˆ?—ÒŠ4’Ô#¥\®íÐX2{îu_š€±]Zé½ÞyaA6ë†ÈŒÆÖbbñर\u&Í{Ìwˆü57àFJÌÂÉÒTqîl …ãX}weË)·î²O 'œ*bÌ‚¦èT™ˆÚøT¯¨‡Ës¿ Çæö{X眴Ǔ ܲxìbÿ3Ü…vÁÚå†ê2Ú¹:Ú'†Òâ _ä¸T¤ÉÄP:$-`¨é·V_33ù]Ó%z·“Fý¶ûg:ô<—¹Š³Ø7¨¤{2×e·Š*×ÒÞq ª qžtøÂÕÃÉV‹ÉD³¥R«ý²Z—ž{Pdþïm㮳êV»þ×®q^ÿ0cÝ•4 Òfí²ÀÝÁÑÏópÅÕ¿7Š\©,øø2h/Ý åj”ëe:؈Ûù,Ï#ž6ÎbÃð0Ý :­ÿÐ]h­j{ÄÖ7ƒ;ŒÎ0Ë­DÖ³W׌›ta”�G "+k<¿åÏPŽäë˜jõwþ4K«šÌØ`H¿*Æ–²®¾ñdÛnh.†'Qƒ OÁfwÄ|¬tÅú_¼({…+ªâ¥E°ŒU–fº €4œêŠäªß>¯ÑRÈÃ…^z 甕‚äºQmA¥û TÚ$ã.j5ºrÓ7ú.‘ȯ˜”7d'’ª¿Þο &yà&ªgê³ÙÐ÷£¢Êk{² ä>Mƒ¼î< ’UMiÇÎËTÔ¢uÿ¢µŠ…-JœÖôqL˜s_å |õ7‡ÃD'=}Xul×Ç¥_B^G—© ’SçÄá­iV*6È_5íÍ R. M‰ç.MÌzÔø[„þt6a‘jŒ ±â^B;Q…¹ýC›58Ó†·î+¯,Sc–9§²ƒ=!á;™§9!…m&Áy€ ÙIÑô*v!Á^ L`ˆ ‰ë •+­|W\:}Û!¡ üsmëúb)[hδs';µÑf®kâ>ú=}›Ôe-\ǵ3÷Ž;çÜŠ^3cyŽqÜíl–×`90RŒ~œtHb܆¬éPìë3ŠòØ¡k÷éWÂ,ž„`ÆÐF×qaÉÿfûÝÙIêø›,‡Iën«èè 8®:móiãi–ú‚Tbî7¹/¾Ó èÖ®Äx²ÃÒ0¼¢ÕÃüksK¢r#*vèQ¼«¿œ|÷ôAÕ!i4/XÄퟞÉ×ÏÍPÇW–S Ê0’þä`jÖˆ®=4ì— ¡e~ÇG0óÌ¢¥70t tΧƒ²=ÌÓñdõY›Î²×¼§ÀŒ5ÝêãvÜå.t…¬‹»§âÏš²Tàu;Õ³ ÙâÁö2à-‡YÔ…²,ÛöŒ)8á0FØ\gÝýGØ…To :†ÁdîÙä‹Ç¶†ÙÁÖ#gÂÓ¹Vv]xljb˜äÐ¥‰ñgŠ èB»ù F&ƒZ}Lžž’» 7×·ð){âMyħN›úô=7Dëê[æ30¦5D4W†ŽÍ˜Žé÷µçlnÜ]¹w>ˆ;ïË'gè¾ÊÅ“8H¿ÞUÐ,A7‘Z óÁáÄã) àé‚­)=Äe1qEqX“ ©´)Ý?ŽeY�JŒyõ;­˜uú"PÃ(ܵløôå+?£ÐïÇ©'«Ei Ϋ%§ñ{6c™ó£‚*Lý»/ò''Þàï:iN‹‰¶Ý³(Þ(SY• nÁ$m¾Ì„"åÝ4‰T…ÖY»þC2º`gº7ùi§f`ÍML ÃÛàå˽îÿRñëE²Sð£ÑòO~0$/²ÔS‰ÇÈ}°îMׇ·ÙnÄZ£ &âå|«ë#¥Û�R¬Nª&gã#ùzÔê« ó4ªiéoQÁg&uI ¥ýÔs1y•^ý'UØvÈG}Ùå0H6GwßgÔΤ}ófQœèòÝû“Ø­eQÖýÉl›2qG€œý™¾ôV^žÎ§*q«ô“…>#Äg§S¤œ·¶ò)ÅÕŠW•Që§ÿT&Ðè¾>®M¡Ïgžh {\öÞ©x5}f41û{äùgý¤£s*‡¹¨EX– ÄÙ-ДŸÒvà53ý&™Ã÷pî»<ŽŽƒ’»å‘dô‹š„KŒµ"ºBlŸ÷+ͧ*Î<m‹íâ jÏj§ÑѮ՟Y»†Â ÐÊ2랸¸“Yæ“Ž|¹nÕ‡se/É ‚VØŽ^Ó§é‡~bWý[UÎÊ™[[XNg?‚ÎHWÚyÙ@K¼ä02}iˆy¶cÜ€+£o±Ã„«‡é2\h$ w†v·µàHŒ’ö±›ùg·ÙMA=ž†ë1¯åà `¢µ’ {N» 3• œh•1zäù ý@Ó5*S7ó?ÖäéùSú¥ßþX«1îAÎüÉ5…)Ææ¾Òaä­nÛS€®‚ܪò’Eǘoçöôêc+‘ô‰ÕC±Ðä JÄŸ*ÌÇ躭�ËvÄ|‰ƒ½¹T`˜ÙÅQ‘Fȃ‰ŠcHÁ9 V,,å´÷EX»nånÉ +®5 Ò‹Êf£‚Öæ¿ŽŠ¬|GhT°öP°nמk¢@ä/!À Ëò™9÷Uwš\µ[š: R몓Ëý„2eÙž¤ã0welkØDý~nœ-HFù/Ýj"ó.“Hé¡Ýx¹ù¾ªW•$~D»‚ÎÍ(¨:MUKd¿#Dkä†SÝ}Äõ묜¿;;_Õ†Žî¥ç’.Þ—uÔ’¼P Që—ÍÝ<yA:yPÏ7bÞÑ rz@ôgL-éž¡{|·²ò!X"[ßÐ6ÌÄ/¸Ï ;kûS¦Èj*5bÒ zßz¸|œë§ͼçÓ`$QNß¾V Rî(¬WØ@,ÿý¬«WÒm¼¼­±ßÕèÛÓRwz»‹ãD«ºWï6z;Ö§Þšjо Sˆr•oP-YìD·˜¬z®)vד›=AQ" ~­ÈݵÞãîZ™W¹‡ÍŠƒÕ:¡Ûµ^û«òíòצ³Í”Pb=µ#øÃ|9ÒŦbwK‹¦­ßV—Áª^¯ïý õ§'íË ýæ'?k¨)1^²>ÍFd0­•� WVÆQåÖw’îÄy¢·;Î&É0‹¢§vB“ÞL†\¦d%ÄØ=^Ûÿ¦ž»)L=­ž¤÷Ò” ÇúpÕ'zÆý„óî›*7Œü‚>D!O†¬x0¿ãï¦]â­rZ3"+öHM…c­U¦‡І®|ÚéûF!v¨fçÅ„Q2úvÃ?Ö´ö‰{m•™+ª0’ݧAnQ¸½}wPW:Iöp³05¿[:X ´Ty'Xo¾TZÀ}}»Á ëÛÊæÛY®¹äÄä%(ˆÞ}=z)TS(ŒtÃsñݪ¾°Ïö¢ƒ%©ób­¿c&… ÄÌ2®çI¥Ùìn]4x­¿ã·¿ô³ÔX¹©@KEGVqÃ×éý°U'ò—ðRiæÛ'£@5àâ<Ëupyã×aÖÏk’Öz“ÅIçwE¥¦XìLJOuÈn*Š¯öéråšÿL™Ѩ™Q,ÑóÀ=]3ßZ,:"Žš˜¾ÑñPáçä)Ÿ™¤ÕóqEŸÑÜs\æþplŒ+<Íü¸V%ΕT”¶¸ÿõ u‚g–Ö¤t{ܾëG‚E.«f=˜ºO‚Ì"õ¸¶õÀéÌÍÿãlbþç;Ç…™Y‡,² ÙŒìý¯Ñ÷“1ÿ¡œî-ŽÑÇÓ"ç0zÌ?–РÍê‹«cZº)ƒh˜•î†y6§�²·¼O¯eã=ÕÍôüW8\Ê+ˆóš-š”¬@í œqÏÖšbÂw¬�üÇ€ÊóÆÜ~@-òݹ٥iµúç¯D›Oc¼£_ðZŒk8-ÛOªÆ«O5>šXè<ɪWÝ9Œìä4ɶÍÈç]ÉÔ#óñ ‚JA ÔŸžŽ­…îj ‚³äWÄÀȨ̂à3¹Wuº´éYÓt~<Ëjñ D(³wá •C‡ÃíŹï¶BQ‚u…ÝÓ¤tt¥÷P(Vrß˺Âqâ,ËI‹¡Ko<hº‹z°ß�güÐŽ¨l$¿v"¯žÚkRžk´šäì9ÓžúÝ?´ß™¼Ì­ÆñãxmsG{7Š½)ê¥àð•姒3A‹šwóé(ó£$€óöZX>Ø»™…F`¬\Y@wéâXÇ®¤“±™y­ž¨b_ó˜>òúBÅÖÖQhj/‰þŠ9/¬wÂJ¥(x×—¾½:M,j8*URtÕWzzÓ}}¢ü£?Ì ÆMi±­…ž-¥Àב<5cê‡,(mDFeBõm¼#­±Î!±¤Õyýèð”*?W !ÔúSkg‰Œ3£ïŒF;¯Kö'e’9q�0 wŠoe IQM¢ÝY;" ó½ Ô.‹çß@üóÄGg0<ý »aÏfÜ$ Šù@ù¬ʘwÔòØ·m‚WÊ–ÞÒŠ#»aÜ^ á^(,ëc¸üé¼yÃKP²2[´nSÉÁ‹ÎªŠ–Ù(zŸQ04—·Ýðv'é~šˆç ôklG:èë‹)xé\¤½µîP…&´k=UyíâFXœ/núN7÷|™ÌO°"<PvŽ& 6Yö9*¶ù€A{}ú2-ÌHH+õyx}ÃE¾&7 eõ ®µõÀ;+`pÞî,²‡VôÝÎ$òŒ‹xÆzì!}Q»ñ¾Z[v,õÏ3âŸY°;ÍUÑF͉WA´µýsL«Æz]÷t–™ø£(J+·pdƒžjïfâÖi ɥݯå,„(¸Ö^dCÙ ÝþËLª ý«ƒ‰Þ–òþøÔ¸k÷v"Ʋ3ò ö‰x]¡j¢ÐÝy¡9öänÖ´ ‘Oé¤CC·©[Ñ*“—?Õ¨0ÐCq£¡¿ØÃ<0êüŸˆÒ˜lß dðp¦$çrÿå­ @åLÿøÞ³AfU`"`1¦¥#¬º£èªWÊ/5™ó¥é*e£5�çûØÕÿF:X1w? Ðã…çùèû }×Óù‰´¢I ÿÜæA<is1pÕ_ZIÍ´$&FÂ÷ž£úw¸êH˜:çôä­í‰òŒÒöÆáj„³Í ôYɟϺßÈEçá•XÏRµÕ»…¡+"‚®Ð.E=ð„WUù¶­“–¶9ÝüæâiN°Ñ“HÉ2F‰ ÏŸº*æQµ”Ž€Ï[ñoÔ5-LÊ×[ ß×G¾)rjF}¨LߺaAÝ4VcGXsù§íþéëþbö¥ZÜ$[n‡›ÝQ,äöÐ}í eåiÃÀx„^&Wˆ+zøu£%N#ÿVƒÔ?VŒr[J¼øöí‚:’6 ‰6”ÛïfÑ?}H¡(Š…lR ç2¨Z¼Ä†OÁ¿nL¹ûkgTVq’9±¹Ê{ÑWëñ×D»<P#°p„úD|/Œö¥�ÑClHºfŸ½§g‡Ï()“ù#tNÑ1®l>Sû•á›âÇabÓý1Ía†né23ß#Â$päÞ“ ¥½'ÛÒñTãêÞ3D—2óÙ´yV˜½t ‘ˆÑ[#¿vEgÁ®3¸ÆËTÄ–øBL—$(Žo–׈¯©ÒM˜c¾ýa?wªÈ,òÈ “4 0!•·å¤‘DF-›]¯•W÷æ§.¢{¯<ŠD®>okÄÚÏÚëR­oðÉ®!Ím¯s«Ÿúñ 8BLCÛàHG`eÉØRðš�MZF©-v­¬ÅG"¸iìt;|w°¿ÛXU¿’¥‚öܶ2V,Þ›?~aÍt Û¡ÛSòvÚ:\MÓŸ:ªo[Î~…�u/uß’t¡,L_mzUi*­Vð‘¾R7À2ñuAú²ºò4žfÌÚΓ“¾²­ylq«üZ-н1$‡’ µX~wº¤”ØQÚ7öAQæqÐÐG’–'Dz ¨d§ÿhW;8ëiü½ÇqúÅ;]îz¢Ùçl�j¢|OoŒâdÂÇ=ó|ÑP‘úGYŠ ídÔ±¨ÊV°ˆ‰$Çp†ßQÌ.Èy}qÐñ¦ë¶;+Rû‚U)ÿ÷/OS-F áÔ ÄGºFçº âÑJâC^‡õÕÌd”µ¼úNÖ¢y¶H.”Ì è1…ÐnHÑF¹@û¸mëµYšŸ}ò 0.=‚;ÏãÚ:ÊAiôèôïþZ·[Ë¥¾}~Z¹ôWÚä9ge;ÐW7FE€ìp›¥EPC 9üÙ]yÞa¬qÀŠzbË,¨ ¨î•A~ô€ÒÌ vÞB´3¨Ææ(zS½x;=W¤‘s½“¸ô78Ì*Z\Û¿ŽÛzÞõÓA'H/; Ä~–²XÅ¥tÐ n¦³BNÞ°òÝ`7 Kç\è¤? óú{nqK—Ô0×¹ þ“‡ОwµUEn,!zêåи÷€®¨wLó(€Ü |·r 8ëp:ò˜÷üCÕÌÌÃEì·¹9%)[‰›6}Èäwæ‡h‰Ù ïS$…žL•âXG�…)ê¦MäSïùþÔ€±ñž¾ƒç¹>Ó˜ Ü3ÉØ—gÑÍ\ÈJðjÞÓýÿ<z´Mw7š¼ñ™X4ûST{æÀbz¶̳Q Rž°09E›³›jFéÜ{#4ež@çSÅJ"f,ñÑ:Ñ%¡ŽM,Šû¡‹qfFôw»¡,{{¶ájŽ~б­Ä<€ãý!ݳ;âtÕ5QfÊ 9ö+k}øò¬re|ÔÐ_» >1Þ0YÜ3‘µ|b@æØÜ7ŸöÀ€ ôa£@šgvÒÎ%¸Rÿá–‚vÂ.©‘à_(™BT `ì½ÞVЂéC´´ÍËÛKâ&䪷ҟ(5šìvJDº¹6Bלºsì9ýý ¡�Ž”'ÐEr+ûî/‘Í—®dg`ÐÐq×äÓ“g:w»ÖâËÿW{6žË¸¸È5[:‹ÏµAô ¨òpuôÙÞ»ÆÌÿDÛÝ~›…‡…‰MàümO¶+U6¦^dNú]o©Pa§U 1‚HkkIGNF¬žø Dæ qD¬üÚSõ×+à/ãŒuo’Unè‹+-º…‡Qùâîëøj¬Guÿ× †º XˆÈ6Ê0p T-q¯ô‡nM\ÂÌ?—ÀILüOÞÕ0f_KñIå­£n°|dFúpsÊÐ%ë<áã™Ns*Ž­÷²êp€KÀ®m,¼{ƒÈÊœœäeÓ�­w»J’ä ÕFü˜²‰¾¿\S¢#d‹Ž53ç÷µ‹¡¾l›(Ñ9¤Øp¹+åoÉdaf¸Ë«?I”T Ñ€ ‘âú˜ïU_ml550Ïä`ÒÝYÚ»®�@ñÓÂNÆÁZ{‚ÝÄ]pX´gûV!$÷j–n¨õìþðÖ'ù0” Üy;.‚!óOÂç$IŸˆ%¨Ý .VšBeÍa.|:9|Ô PªÊ®“X.«-¢®qí-ú¾—…K³—>!†ªÜ ÌØÈPI)ºøJðR‚Ìc�ƒ,åzŠtЩ±úxh'cå)0‰ ÑÍ“oò¿äš5Ú°fÜêÎÌ .�ÑñV»gÓedyÙÍË<«,ºÒZìëz¢×â8kÅíj.]¤ g`ÁO§»zç7^ç?÷š±™™Ðk‹öÅÒ¤ ä†mŸÆpšŸ]½há«7n ,½µŠsK,Z]Œ&3ð Ms[Þ“eº˜=ôxQ gÚXÍV]¡‘²Ászt&ÇWØzvÊÂÒŠ!ïâ êþZ¾@©]ó{úø\v3ŸtC¡)fÒY· ô=kTŸ‡Ñ“Ç¿Í.Ÿå™UhË|v —ë2 J %B”ÇpRùŠ=þ&®E7±t/ž²¿®“ˆ-Êdc©N—í‡-±¹ÌFÌw³VKQ—´;,‚USáÐ{§…º¶¦‹A1TÌ›l‹CWlÐïøô:”"´ ê†¼°Øw§CãcÅ‚7¬Ük.™#”[6Öc3ãrœÞkÑž›O[בg Â#EúÊsjHqœ_åLPëöv8m¢—ø˜âÕ*ßa*ÚŠæ,A}3’î[Ê°eâuìΠи_eT¾=FéyDFº”_ðÔƒ…´¾ÆµŽ—¥54Y˜ù¤ùT�¥˜M%5ª—š‹¨uõœv£…Ÿ,*&͆º³µcûfFâ¨\ÕŒkìw"&C‘¶;y~ª÷Fmb'xû ¸«ÓQS|-KoÛQR9çnó'_ ³“Pþè.bñÄ"8Ø%ÜÑjš…S* à §YÜ|eìÚ.x/Ùi¢?B?'5"M€‡ñâÉü/=B³Ì›<@Ú´ øÓi7&|ê|Ø7ܼ7”yyÅÔ9†ˆØ'wHùñõ‘ÕTè¹Ê°ZF»û²– ¸ý-иîÉÍXÏ?š¸[ùÄjRüªºD:=ž};€:ÿD<1/˺AnCÍ[1Mrž°TD ðçøO˜Tƒk¿òÜ-/?bH÷q¤Œî³óe߬ÏЛí…SB+T³fTŸGnˆ´ù–MƒÔKãiÖ¶M©¾Õ/‡²îºŠôáÌW¢PC)b°=µˆðª¯òhðD×ÉÂ3ÿf@<³ãñ2Væ–gõi`éB+åu¡õ¸ŒbCî¾(4wž•+{fw¨?º¯ŽGòàv™7—dZãúa£wöèpu?A]—IáûtZ[ð°ôŒñ®^A²ÎŸœQÆØ÷Ÿ‘bÈç]¸öÝæª!ªeú¡¿p¯P?&Xà0¸ùÎØÂ"g¸Õ4U½oÍIPå¶É¤½ðr>†k`øÚëUTz «’3º#¬ì>­ô{ZñîµÖmÏÀyœ-O즥# <#ó„¨ÍH†F:‰§Þkšg½î¥ö#3œ`âJõ~6CXûÚ»åêw¡¶q“å ©%N½3§sðH»¿ðÁy•£Â4ñ–6˜U6É…ÀzÖ ¹;\M$¸m¢ hˆJb{0G.Í}6ë^jTgÁµ¦O‚t=KÎÊsØ®>1È[z/ñæ×_Äí Ë ¡À/?¹\ôŸìðˆñ ³ônñ9‘BxÝ\Š¾(}¸þË{Cªø†YMTõ‡iÍO‹ŠÌÁõYÒæK¤ð´q<6&—«ºò„1Õå5%ó$ôm×cá?Gµj”n/ÿðj ÆȦ$áR»ôK~P ێ݆õS(K”8©8 Ôã–‚l§+²ØåºX’…¡3nZÇ-L±±62p³v–å“Ýç&מiüÓÖz“¼ýi¡ÑZ2½EC­«w-ó—½g†›—¾x*¤! –Í_^ “Bu?F“L~þ$çÓâ­(ínßmÈ5žFén+ö~æÁÆ"¥óJ÷Œ² 6YfÑ9þ Uc| 5体D|o·œ{ªã J˜ã•í—/UÏnZ=kìýx¾W•¾-SÑ¡œ0)Ä™+wB|]Y“´Ü{v^º’ØÏ´EPu*<ÄÄ=àK&†ÎÐzçÙ k Ìóh¥d)*]Jq©½Ðî>é’¬Ð�£÷½;ƒ8ŒE8#’ô@+Éá³#ÃL‚lvtÔ"‰>É~7_gEI Z.ÝÏ<h¼¶—ŠtÃ*9)Þ„¡Âì=㙿DߪPÎs‹¨ÌéžH„Z{9+bSOÆ›¿që%çÔqŸÝ5ÿ½V{–.ÔЪ­‚´µäYšX�i.áìPÞÅ Žƒ´T½F´òñ61<}JÖ1íÜØÃc*çòÄ-ng0o)TßÙüøØÑäL_-l÷ž%šÐX{"{Mì~Ð?/½qd¤ªÉ0©Í5êTªî\$ç+oøÅ/±”âh±÷l(¥­FkCAœ¥k:-Ž€*ë`óe1eæTºÂ˜Ý@΢lÏ rEA6mtGa‹N¿øDV÷YîÏróÐ/ó]Å>ºÿHÑAV[…œ•ú¿lWÍŒ›ëÑXµw#G…ä1*]©î w£¥XãLÈÑÄ¿t½PýPÓÏ(œUˆs©âU¾/H;SýØ_<v#ƒ¢9ʹ3›'¼ýPð_vRŸú7xFÓ(PvTr_Zcþc9ÌÌWßá-01B¼¶¹¡¡8‹Î%] ³^»ÐLÀÂÑG“”EgNy‡EYÊ NfЉVSêÔœ¨> RTºP«5œíùp^'šGYáµ;E0~›ÙVÉŒÆ V Bæê+3¸ìHðdQ•Ïd¤(8F<)tLíy Ô¥æåóaü<9Ö±%geeå RÌu$ÛÚÃèJ“ßÖpðwc튻‚æ Ǽ˜WìHjEåf¶�]¸þJš,Š=5=ñX�“#nõ<JCuZœÇŽR½}¸Î”•µ¸q¬4Ü,_û ­™ÉŸ6'úI£i%Uéý]¼„NôGþÔzñœÚ‡ÜHÛx绳Â~àl³N‚¸÷UØâêê"0:ÇŽVŠ>àˆôu�•€9}:BRŸyŸÕ¡çäKe¡Za•—`«Dèªd´a¾èvÆÛ÷ž-)l¡×¾¯D1‡6~\ŽfÍî^ÛsZ}˜TLŸP­Ôcu%-§¢ öæÉ€îó]‘8ôæTØï68þj<çqÅ ÷‡À—Y»þ²qß³£©[U²ÛßxOoÿ¤7µÆ¡[ó9f{S7ãlº^Š~µåô˜Q§#Uºô/­©;%Sy"rXš Óôúµ:‚@YËdþ‚©çY`2iúØE8Pþz‡Q” äöpâ!¤XÊõ¡¼åvßÿý?T]†ÁÔÍÒž¼2óŒbC 2™CÉ®˜N… ‹Lxë&éf½ä‰i¿D0 .„ð"cû”H‡P†̃ss`íÀT÷»>ïÖ"Ôè¦K!Ý;=Oæ•Tf×.ôÛ•ÒðèµÚì)2Ðî˺/+@›jξã´<iívóò ÜMªæ|;°M\<c0ù”ÆAnÙü¿ÇÆç5ŸŽêohen¼ZÀk­-=ÉKÏҧuãrºƒ7!gˆ‹‘Hü¨ò†¶AwÉõ<yœx9ä!Õ±6à÷¼ˆ]oÐ’5 š¶[¯ß¶2Pd+öÇ“7Š©Œ±bŸ�É¥“…”}—¡„‘yÊ®2Ÿö%ô5Ó Þ~z$y*:nÊJᩨ;DÚ}èr:†êÖÙ½2ùK„„Y÷èˆižiiéËñig¸$cÐ4˜ŽTF:óò,`h®ˆ«-S|ðÝôdžÄ.s»’BUâ\á0à맃.ÞêÚù·ïis”FD9ÔÆdÝnÜ6rcæšÂ;t@´Ä¬Qï…ß2Ê Ãô‘ññ¯§Á¾Æjø4€×1 qUŒÀ쳚إ/ >œÐq­R  …5¹F/ŠoàÂnSÉð†V¨³ /Ø€¼Þk2d»—êÇ<Ï|tÀÛE[ÇlèÃÐåcú,Gæï8dÌã+xíbI»¢5Ö I[©’¼Èû™Oÿ½yzæ HráZ¥AÖ4žÔ6’cQEú÷ºX@ ±§VݘÅðåQDY¹šJ—‰¢šaÿ·žÞg*÷+˜ŠÙ´îéÈïÔ0€RcY,º½Œ­~³ÊŸ.ý$L}Î?Ý�QwürÃ@ &¶dù™²£çˆrd˜bO)Ðø×Óv1H1)±˜ÑvË©óžßëئ¸÷çPÀ&ÿè±r(Â!ÃRéHñ§ƒâóŸ×…°¶ÚW´€R*í94vÞî¸7:Û9ýöB7}aõÅ”i1u\€XSX!k\ý¡e E»D5¤é*Nn<mš‹ùy úŒ"GUâ7k€³+æÁÀál‰,XÝõG©×¡©jš?’Ø=ÀÌÿáLs$óQY9"{=ëœ<ÀõK «%iè®w²mŽE澶5%¢ñ¤ÕG¢°àH´Ñ³4¾k‡• –¹ÀnÁ'xo­š²Ms²sj8œ#ÆnžHÅÑ;´«+U ùOhÀ6s²*Åpý;sÄÔÚ“ÊTPŽÝ‹c,ó+§a1°uïȶX[4ý¿ÓÌpf’’ª…�iÓ5i¼ÌPìUÝLödvê+|s)tø¢%cm5q€Ô—I4bøz\jæ[Pñ`ÍHHÄ©éµD’%ç”4¢ã¬Piny»Y1V›§ð i‡ ©ÍλnpùÂócÆ •ïak¼SW©4Cáñ±_‘ï„ìZø‘FÇ­ºB1mä4Ò¹j.Õóá³?†¶½yU˜kŠ4Ÿ³g CãhB0`KâÚý¼¥”N‡Í˜ï+‚tª®NÅV¶¯–¸šî ú-SÆÂOV¹« o†»š?)°0JÐ~½UkõûŨb¢£m°âÍaæ„ËNyµa­%ó±L]xk&ÒëËT™«%K·„íh¤£ê›)4Ò郫ò5ý„˜‹MY°Ž>©/õæi¾E¹×¹fmqfK¥ý_à«À¨aÏø´EóÎ̲¿£I9Ûež8‡”÷•ôéUp†ÛF¾6=€é§aU/Z”ŽøfŠè!òô!¡R*M)‰¿…¡y6Ï!ýžqÒFÝ×Bÿ³ÞûZ[ MŽðâ@Òñ<¹W ,3<iëÒ.¬${›žúvzËq"ÐáNÉ tŒÜ3i×Þ5·/½­Ìä¥áLÁQЭ®Ô2£¿Ôp½sñC¿ƒD*¼¯ÃÚW¦ÂZÐœòw> ±õ ÁÁ )ÚÐ)*@DÇ•î,JñZU |- éðÜVÄDZ »»Q8˜`<ì5öÓöq«ŠÌ_‘ZðYPG+YŠ4TME£4VI;óŠ7ã(öËμ•' g²“Ð-4\ö™íé2«Ó‹Š“VGM<1hî‘pÖ½+"WêɉàþäV§¾?Åtô¹­ägܱ¡zêÀßÊ*$qìk`ƒ´wDNòA¤tõ[O½k÷ÓË›ùµ×þ¸Ë`Œ+w¬s÷ëØÑ 3é1– þ"t Æ"¿m} ûÐßK…žRA‰íwø¢;’~j×{u`>»Hãšüè¿où•§;ÄjxHj¹ð“°eB–D¡¯W.™ ­“ȇÍ2¤£J6€MÓÙŬO¡}f;€–m$ÝRùZɨƒÎ*ãaj'F ~bÌDöÙ7ßÃÊ!0fŸóJŠ*ùvëÍÞPÄ Nš£¨@ˆí“Ga6Í]ÞÁ@éS6«Š†¢éÊÇ„`N’àôµÀXIÉÂalTwœïdEbo*�ëÝ&\3õ=Àì袼OÏ3Ÿ‘DÛ¯i‘Ã4ikcJgÕjYÿá%t©"E„‘®ö¸O‚òËŠEÃêü2Îzø\›xoÁŠ¼{Eì!:Œaì ³;éAÄô‹±ÛŒ;]0ÁN†wÏ]ÒÈÂ8ób7”j«Õ5<(³¯U×ßœKŸ˜¡”*)£Ñí{“}!IU"µâ¶~™Ãd8ä,|‹2¥Õ:§Óß ßswúØu­×,·þf5´ßå³ =…¢Mþ<¬ îÿÖË csÄx´°í[l=Ó½¶4LƘÿE@šS=ˆÌˆÿ¼¦7ﯖšMïøHeÄ6î\tÊ}µÏnüš|6á_0RìŠ ,²·úÖÁy7ŠF{€²ÈYT܃½Tñ¥¸7Ôkóiõ!|&ÿ´zgŸ'±Eé…¬”s9Dh0ÕÞQtøb؇ ¸ç͸Œ=M%¾åÈ…{úÙÖ¦L§m¤:"?Gž`LŠ¡LÛÑEIÛ­×æö>À©_³¡3ÀE¬Î]o~šOõ8»{9\QD\”v nùÑ¿`à»!"³sVû0(¦Ooêé‹¢±0ï-×LUö®ŒU³x¡ â â÷uÀ³˜#y×ú$øËGº6l éVP‘gJøfÈý½Ndz焉¤Õs`(ÉÝg Ù¢òÞó¶‰öQyÔ€À.¦;ftÑN˜ØëÃ?µÈs@æ‰K0 ;Ç£ïYõ§ë/΂àÛ±²³Ä­B–ÎëaPõY{TiÜadëZÚPðb|‰÷LªæK.YÊpÉ1c᪾øÉâá0oYrÓœWF±ð78é­£Í3å´/ž[ó¹Û9ÒîˆÙ8îž{rXmŠÿUä I6ï<|¥TŒ n‚³Ü¡¸—P`’z<ŽÎ;=³Ž'´X²‹¶ÉŒèƒ&&¦ÌB9ÆË{KëÛ(Ϲ§pÊn3j<±(¯aZn‡­tF¨9J®$;|MrÍ_«L‚ŠÔL»©² ÓÒÒŒ„:ÞF­OEî$í\m]ËnEiTyG pÂ0‘ÚXC¨{zi%Üêá?TݺAÙùÓÙs;kêf7‰ÊÚêÆzÙ>‚=Ôúîl:PhX`é—SCÉþ¼õ$ÌaXö‚&ÌOµÓoï3ë [)Î×ÕXFTVêÌöëÈŽ_nÞdIæ ¾i;·€ÑÄÖÖ,Ç`mêÆ?¥•S¥ $;¹~mVÏn±k7r+‡îÅj•Ùs-/Xî,ö¨Ûðpê'¹üúpÑ áºUiF8£—V––o5èxZåÿÔÝYõFPž5"Òaãâ»Õ ü±ÍÆ1œ~&Q% 9ð:’ þštxÅ„i¿cÒÂ÷¼ ~”qjÌ| ÃIÂïëquxÛñ”ßC³Vqè#ÛPúÍ'6s9!€CŠöJÑ ¶N4SDÛÅ&3´åxb&I¦Ï|‡nôž²×—R€Žª’p|7_‚,Lte)E®®gõgö¹—â1Q¨ï)sO¶ZÞø—gÛ§v8¨@*û%°­ƒý' Ïós)„6Ç‘x´¿d-†ÄÖ²$Âge 1ÜåÝL2Ü'0æÌxy¼z.Ø|#4æ ´YŠ­öøWúHÌ°wa®B£7˜•˜ sPìÄ Ö¿•Çí­�TYÍ´EÊVÿ¬{O“íÿý?ØŪ@õ«yP:ëX3‚Í<Œ ï†Ž!¸ÚE^ivB×mí—À*IéOŒ1åš`³ÝŸ¼[²êÚZi" °|xEca!xb¡¦” ¿íEZJÖƒ ]%cÙzÇÒ›Ú´ý®T[@ИßÒ3×[àð[Vtâ7`Oy*µÃNÝ–Bƒ±Z¾òᣠvª{Ї­‡};vpoq¡Fƒ‘ÜÖ³VÂý™öœ}}£'bkµÒ8�nNh÷ï9|„²çL–^K¹Á µ¥ÿv™ÜIZ¸•yþ„ƒ,ª­›M”ZʪÉc³©ËÜç…PE~ªªÊ¾Þ hÓ›tríH³ôÇåÛQi¤Åž¨%S¦=Ru9ö^ûl¢s|´ÃLtÖ§í K+ñU>˜B�ê欙\Ä™\γY…íwŸ7§ÝtÄ`à�XÇCiø4ò ©ƒ¥|j¾-Fng–±áC:ãž÷ ²piÅB»’öì îÐé±ëÆÚV¦Î{TíE‰³YMçmŠV_£Y]Ù~Î¥aÁ]^´ö 2­äÙ±$²'Çñpì)B$‡’[Ó@¢SÂTxîÙuW5úOœÇî.†,60 oÞnÍÜ­>‚¡]ÛåÛ¸Âi.o)<u–¹Œ>YVÑBh.„£\”½ífW¼Q{ûŠyïÄAÄ<<i‰Ëø.¢ÂFŠî$ÊVì72úB}íÔtcÕ"¦’´ú´0Ì0…@Øy`'0† #6½P˜ÆUêÆ冤 ȼ–(}ζ³úϼèÿáÚ€O!+º}J[µSλÚê›A¢B¬ºB2¨ÝîŽGA¢=�Ò.(ó$1Þª¥-×-hß)†øg)qeÞ ¯5e›VµÐ3VÔ¯ Gœ—"ôužš£s¬Ù.ºj#f´æ¢ÿ˜ ¯¾5‘ô¤Xì‡ÖJ­“ µÉ) Jªf9åZõ_otæ™?"BµNbªÖõÈ@¼¡{ðvy ²IïN•¼„s¡\=ÑLOª]aØa–]Î'+ÿÝ [!l5pb…4/'œ7Ûþñ˜;ΓÌó S:™æ”чà$ŠHj¥W?¬ÌrGÔA5â ‹DôƒÔßd+zMÏmš”m„= Nqimµ Ì=ÿÝÐñÒk´ ØâͲàg˜¼?ý-È>e¸ä†Mç4¨¬@C,Ö¬u?¿¨6G±P¤½g=ßñl?|h#XË·'ê n&˜ eÓÒ›L‡„î»ÚƒzÄÜÎìï¬D˜©Èd¿í§ƒ¨ LÃeSïpßôŒ«YzUwp·#­Êföb6´Ú6nè¬ßðZãl!/fÁjLƒäü×]œ?µUFݳûíÞ=>0Q3’«:ç¥a»I‰zÜ(R—4E¤ÜépMeðSyÄ"»Rï8b¶5[¿`èjqŽeÚÆæ0 SáêñVXW í"¿ZÃ…c®=„_S«7HÑñ±ãáÅ=ùžÇ¹Ð«Ë˜Ð1ц-ßÿ*¶;s˜ä ‡3ì3¹àðK™ž {€‹CT[5 q—F-”é(‚g¹lŒº(¼`òºƒ²¥Ui†q£ jz¯$æÌ]´lŠ³ c_!‹=—1 C8ºÑÐyÌâÓ‘Og :žÆƒùIŠn €_åA× f쟑Ù+HX ±¹îªÞG~ÅeäKíÒÙ¸=RAùÕxCÀñ$fœ6³ßvû®£ŸG±x¤TY€¦c[º.m‡ùˆ¾wŒ­ŽK•M»@šÎŠý›9`©ù'C®„ÛPq–¬[ÓàBº |t—Ï’f­){P/}_Âûú„ìR±Ç"(mÔ,+qQÇyíÄ!ÙÇDÐFFmàêä+sß…‚ñP•›«ø#÷~÷Ýyºº©›sId‰(’‹`OåJ´ùk®‹4V¤T–e‘3]R#´Ç°b¯Ù+T‹ûÊÏ…þE—¨8û»Î‘²È!Š]Ÿè™úžÙ¶(ìi/¦t¬Ú†AÎ.æ#x€>ÑÅÜC·î¢Øë¾s6}4–ï®ìŒÀ1 æØCD¤{'ý¶—õ»Eì:r˜²-•mè3ù\´Ç9H~WƾVG†*«ûÂ{Žê’r¤¢mÕÙœë°^3|dë÷±Ô¹(²?„>oÃÙë²RÔߺÖÎ-ùÕCQÞÊU2èÃýÊÆ£g̺G_ËŠ\ñ}zt¿¢´Ì¼ò¶ ”dVÛO³~:¨t{F: w½«œ™=0M*wõ2tqÑE`ïÀ¦E«xZ;eTêlIâœÛ}||àåI•y‚¯´ùè MGóŪd¡þWãÒ ä{äEž9u8¶EƒÌ{ñ¹5„KtU!¶Ç‹EbÊ/¤Þó$ó¸0?çAx<šØ‘VÝÉJ#€4Šsl®é#ÌíuÁçEa9y"¤}líýâEÔâ˜×ÛcóP03˜S~ŽÞu£ÃÐŧþ“E£ÌõØðe!ü|;Arª=âÞ #Ò¥ìò±);ñúú/YâÔë-38t5ƒ7£9/ˆU›Lœ½5_¦™ß´ó­ð#öS¯œÎ^æIaÕ …•ŒðÚ”%Jáco3�N.P<Nh'€"5!Âr—Æ=3Íõf…V¤Ú¼UÆp}=zý±±Þ è7™Ið·^ëVÿÛêöEøäÒ’O¾wŸsA×Zþž¶ÿê£SbÚ�ßè¤ɲž‰Ämih5Kd…±¦ÆÈÀl£_º,™¯AA‹nÌéì¹Çݾ÷àÞßÉai3ÔñMàf=¾ÛÁÌî¿ðÅP&罱Г ‘C‘çÆ1»+)·Ó3à/k®{ðäÊK–^#DVX77F±ã†ÒÔ¸V;°Èx©®¬Úk×ïÝüFAö×ÆÒš´Ñ»ÿHó µÕ�ðæ«š&.'ÈÏçHÓÄÁ’Y(8”Ê|M€—Sk‡ç€œþÏûð‡ÐC…0àp:',Ðcf—T Ñì+Ì(.Ø zE–ééËŽvKÝõHë„×’£‡3bœ û˜ÉÒåxŠÒçGÒ7¢2; ²¾õ¼¸¥Äã]Í÷a]sùæqé’溘²ö÷”ëtïnçÎ𜾠S~<Ÿ0)–Óð­Ë,ÈÛÆü-aìÕC=^þûVjqÌRú<¼<n1”{¶:Põ䚘‡ÍyäQ¶ö<&ÙsçuÎ Y‡í¶ +ö0Ê3�n¨„†Ñ>k¶`¨ÕJäÛÓ¢e@½Rj², o𶦤||ã §þOùzfrõø…+´2¾_NÅózãaˆÎt»ÎR¥ fº†¿Ã´}Õ; +ü“5—¶|Þ:ðzËóí`^èv‹/ÕU#'ÊÒÐkﲄa¤¶ØäFÚöŒæY©†è‰vgþ7 —4vž‘hÜ°ägѨðîÔ×íÀNŸ3÷,­„¹È¾ š{‡M*,â Ñè ⌶‰µÝ‚µç³›ŠÎ™üw®Åaæf ¬8O0Y}WÌ=¶7eãNÝÉÙ9,#m9G©ŽB¶Œ?æ7¿¸*Çž±Â,d½5ú©˜\Â9£½Õßz…TIæµJb8�—Aþ5¹ªÑs‰Ÿt¦/™7tEžüêñä?_P€BÀªpÛ�™æøÃÆZa÷¥Ò¿D°OJ‡?³TºF­ê Tà‹!ýþ”|HÙã ©Çzü‹J8uõ"ØSl) $©“±ƒÓõÆx´É¾O|$#oü-®µT•mà(Ö©|;e¦}"}ÊÌ*>AìÊN˸mü-7/Ž¾šYýí@K*î= ´Ÿöd¿Î¦Þ “Žh/øbÅ´ëÅ '!wæÓF™B8fϪÝvP€¸EF•Ï ElG(š.†y‰v€GV[ô~îö€¢<÷5¤x¸§›OÏ®ËC «=�‡»Á5‡nš UîèÒgÎôY+«}w±Œg½[L{ïuT_Ín"/±BÍB‰Uá¨Y>‰Ô_z¢¼—rØ@Úlº#pV¤.ËaA¡i,ƒtúkqÜǃ7È ž–Ì ö”{Bu‰™CZðQ¼Ð,¤[0tIÁ^æbá&ØÖÏ*θò6ÞÓ'j9Úå\ ahØ ÛÓÅhâÂŽ3Wýî(´AÆpo:Ÿ_ôRC7ŠM±* ›h(‰›tO3EîÈ:üè­™-ðÜV\õEì(ÕmwO<‹öÀçiçZÄñ,ÑŠÊ¿™.Íð¬IqXV7^´<wÔ:ÑõJA°§dØŠNWȲ{VðÑÍ´µæ}.Zî° BØrÏî°ÓŠÜïUBð ½²8rn´Ž,`þóÞ\U] ÅïŽ ][Tÿ� È)©ÔÆúƒm8¡˜=Ö¼)Â.·¦éÜÂX,ì¿\ ·p,Ùw”`3Sù±„u<MêÅ ˆ¤9-°Ë#Nm–aÉ2ÚîgÔ‡t1ÆÌ‚žvèhå=jÐuGnŒ˜Å÷uÑÜ…g¬‚²Ó*„ÖK0^‘…×㮶‡T;RùÁ#÷ BT“Qᾆ²Eq’ù‡nASu–{âŠÐƒ´¦úKî«?Ð1¦€è�„œŸP;˜-¤JÊ=>&{pÛH°ztØú‹«À±²<u^©¹=ì;#ÆçyU*îбΔØåë'¹t‰»8p} ‚°çG¤žà—γ6ì @U<ÿ݃Fdi8„3©kbÌÇG{~ÕkvÌ”ñÃñÂôsæ+LÖ)îÃå;N~9M|½: ¤ÀCßœ-”.JÎÞ‚ÀÍ7ÚG>À&¾.bÎ&Út"ÆG¥“&¹ QÝðBé4à7ªÚž€odZ˜ì¼{ü«ñ"°�þÚ´Þsø=XŠIjR½ÊPRÙo¦ûë¹q÷à õ¼xA6ózóÒ›ÃWLuèŶx±éV¯ºÙ¨©ªDÎé¦4Z@À« íµyXñÒë{†ÛHÐÖ*æüàéU_;ÆvÜ£¸±|?0ÏØÀvŽ§QT«fŠŒèP»'H™=á*&QMƒÔ2ˆÑpÅYÆ®fP ê'Å ž)Y”wž>º ƒìx`ö k¶¸Dg¢¸G4?N+-…šø¼˜p>ŠÄèK冧”›Ä|5ÒK«\¥£Ñ–‘ÉUcVwþ°RÔÊzÈ *‚»al[è¼¾{ø[úT‡ÑÁ6ûÎÐñ^´I[HÿS€Ú¤f°-И¥”ׯ¥oÀÇé#Ù¥@ZL%Åû¥ÑèæÄò•°ìgS·æ¾¼ªÅ‘GœHEî~ sí‹x Š­:ÐÚú¢ aˆÔÊðædÎĪZåÆ»{ o²¶fŠQëþ Þ z^/Ê'‚ÁNü°4ÐÓcGq µ¨p+ã¾£M,„Ÿ_Vvê!¥MÁ@$³oàwSPJ–L¼j3˜ú¡wˆXNj8‹Yœ> rû—ð]¶Ý¡x³;Õ-•§=r^W§¯ ÿˆC£x¤x~RàTR¨žXÍ& ÒÇeí6}—6=Ë dƒE0¸µ§Òð¢à@œzfÞ:a‰`ácÅ—ÞÖ-†§ Ùrö¿¹C}ñX†þ6-ÝÕÔ:œ‹^æÀr÷ŠÚp†B…˪§„~+‹CB™y!!ÇÑ´:—AÔŸ­2Ø:6°®ZZVRjpÒøK;ž_´yHJ:¾• ™É=Æ÷\–±ZýŸ·¾; `Ù5zçw[Z݈ú×Êù‘㈫ÿ*Dvì‚>5x@Ò@2¢&ÆU½ÅS±Ò¹°î 3Yš¬aøb¼Ä¼£òÇiâæ8’;JŠ­Õðˠϵ÷>è54´g*½‘K½Ïä5š `Pð.‹.ÊRC…‚º)¬äzÏwXYù&ð €äh¸UTLš¥rF?cÏ3Õçá)Á‡ ‘]Ÿ”yìÈ "hN™©ß[A9|w4[¬íº£´Ë¶DXËßùè¤Ñ}SdÅBr; }ä³B6Ðîï©W"ÜEwYuj¯÷QÞvã°¶ZÓòˆ·Olׄΰ=tζõ) â`¾PC¡tÜÒÍkë·Õe�½^¯ïý*úO”ä¾ÒB —’‚Çl®×j¬wÆÿˆß°§ð§º5…ÓÙúdˆ´h¾³_r qÌÎâÂ:{‚Ρ \L�4fè­†[ † ß%}ðþÓÓȺs__ÌÕÇ$bm¤#ŸÔ ±Å´—&i¦p“YgR±Ñ£¥Œ¤ÙŠÅ¹(ò œž/)ëä #íШï<ÅwÓBÔÖ0û)uV‡„¥ztU6#m7^øî`sß»•’Ov=éN^ `²›NÏýN,0&6Y9ûÊDÇ¿žÈ6Htm·±§ª=µp|;_Iž’‚˜•'A<ê�XAZu+ž…r…²…½èáÌÐm}öÈ{ÎG<sk{µƒ¤³.îyŠ ÜÍ{³â÷gÒóÓ*Ì=ÙŒ˜Y�Q³°¯–ð©UFkðu@Vd~M—Hïûõ×bsí’1ŠÒ+ÜÖzÌ=ŒÃÂ÷Á€•9Ä/ãþˇ�Óú²TBœ/­xõž— v)Ýnw›J÷Ô“4  ôÚËA} å²ißS2c;¢¯iµ—‘ß nÑ\|ÂÔ/zž9;%VÌš Z=N^£�FTƒ¥®=%q¶€Gð€EüÌû88ö`ÅÂY(tÍ(á§AŸíˆZnÝ<ù¼2“¸zy<ÄØ8.îŽtG³ãæž­/ôõLÀYC¦\•Awé [^/‘A6ÙÙ Û#¥G¡5µ¯99g8ƒs¬[ô²ñêŽ=M.ìäc:‰ès·wQ.—0“d¼¤V%·Gi”“gÁÝŒ—a_ŸGZ.ó|žžóÇ,‰™+4:á=tö?=X‡±ÁRÞI¦.Ítþ×=DÞûÇÞXÏÙ'–½õðè3”Iâ”/(ÈDl“e â@ýOV£ ñA-Q˜y¢Ö/ú‡ø®(öÚ"=•Õ{çÌZÔ]/t�3ßD ÓlÔªn†(]ß76ý/m°™(9ÇÀøü[¿êjñ-Ù›¢G Ŷ³ë’{›l·(oþUC½73ÆéX[ú@qeN+æjÖέ–?¾ˆý35H…™‡ɃöB9ÑI+WÜ^ÕëNJ¥O£²ß½çNÔ(É|öb„nÌíÚ“—0ûÝͶ¶5Ïœ¦`-³ÒÛñGV¹$ºà}J÷úòiš©„*Nâ–'I!Sˆ€|±ÒäN£·`‹|ïö7ˆ1ž»'wâ×°ž<E º_ ïÚέïÒp—/lKóNÁð<AláÉQ’«³–ˆ™*ï™RHÓY¡ZÑ;×2CqxåÅÆÑçÉAs $Dz|~àê>«’ý]Ó ß茘€,wóBnÀtàùwZÅiº€mWTó@)d½á«³´Ô<‚]FŶQ;`�þÀàÇ9ÅŠ9Ñj›AÒXl5û<ÁÚJÐÐf5¾ Eà“,3&Yv@B[*>r.¡:º&÷<ÑA.Ýá‘É$"¥×G½Þ4Qˆýy\SÊE êÿƒÁuSU�¥61®^ Úí¦£áÜKeíO”kW»ôYµökO+C»°˜µ˜ž©Ð=Q¯-<SÆÓ7SRЮ�˜¤¸ÃH÷K…í‹ËÂ!;o®¬›Ì¥ÌÑ£öìt…þ-×KW® q£ ]7 eL ÿ0²e"¨Œ† þ€ù%WZ'·f¢‡íe‡‘qg¥‚3¨F@& ™z°j<ŸÔ! Éédæ²BÑ#_ƒhåíÑÒÔdYÉ1cwîüŸbJ]ó¢™Ç ÈÄ£¯†…º^¦sŠjE4³¤_ñ,ʲÔZ ¡´§4ü”RƦ•œßÏCgõ'n1Ýüô5#R£”J+’ÞëKk@#й·Ú &ŬöÍyÛìÖ¦û•¼åTs¯—‚ÈjOÅOõeËIÄÇcϺ#Zýƒj ¥ýᬠ’BºÒ\n¢ ^gÛÑ+þV ðnt¹Ñ1cìCÈ{”xf=×”PtªN~FÖÖÛš(ãVάkC“|aU/* ÍXs®cz×ZµF> 'Ãi¨8 8³·ŸÈ|;j§pÍÒ`Ÿ‰E%Ó%÷YÈR»õÌlŸ@W2Ç1݆ÎöÐÎÂ"À>:g~í õŸ³.+’=Q¦=•ÃŸªMž(ÜËε]“8+Þ-^¡eœúݵ”å»+»áï-\¢´òÁÑ”œ¶ v³Ï¿ì°ÈTâpòé ®ZÀùªº7/ì*«(ÎÜWMÓΦ‡7ú¬Z§¾á\œ ‚Ôq`JñG§8ôTs¶VíP˜õ(‚A”¯NB®¯îÿÜóhñ‹êD<ZŠ µÊ¹3¢åÉpÆÏ;Vß!b^h‡, ŠQ{„ܹޯG's ]×™'\rz¿Ö3¥4çñæDÇKa{‚QÎ�=-Ze 7¶�žŸ¸M£Ÿ6´tÕI&çK€që›ç3Ê,.nwq©òXï2J3Ï1-ÒZm#µƒ<vS®_é°‰oÂqw3H¾,02‚Ü3¦·3Å 5NñÀtoŸ'v7ÀLbà‰ÒÕ#N/6Æqª“ ;~ªep®–®<Íêqðð]Oâ4FÜ—Lz;™ ï*ÈOArjýZ>”…‰‰i*ò1™ÕªrVÁw«þx£ªö/•_5H×w2Ò`¬•±H6Uo­%ûoQ²cöP'#$O{“²‰/ÔôwСU^y§.ŒFf¸CêT€VÃÊŸ?²©’c2,¼ò~ô`ÁÜõ-R¶Š…±O?©^gõöÏ[YŽ.¦"dˆËü=g…ÒáxY t†J}2è´ iÄLgçq÷a$GXOËÉkZ„û7‡¶¡[Ñ’-¡Byô†#FWo†ÄÐô¼G* _ÖÓb¹½E´I(dv5K\Ç d—ü4Þ,.mÿjš›–®ÅÀCÁÝ‘¾Ú±ñô¾»~/:‰Rá^rï tãÅIŽjgK×jÔô#ÎW§_CKÕ •:Cy }¼GÏ ÌùÊÐõÿ˜)éx¯ýš¿·¿¨M½‰êÞÕ+ú^ÍÂáYWTS5Zž…„6^¨íj`°éòcŸ¿×î^­úze.öÜI…mÓÓ(Êc+ØÉEÛ¶ Šzã¡|eÄÇ–ßÛfҘȹg1ižy÷ÎÛ†ãªV´fn CV€µÏQ´âºÖ ÷ŒÎ^1gßã¦ý\²òÀ*<ân1ñ*G=*1¦P=!nÊ3˜"y»:uHy;8÷ð<r¦«UÚ2‰R¯-k¤åñë[®ÿdQ0�c[=™}ÑÓ¶¤«§^°O“¶åg\õ"iˆ”[}o$–5kâ2ÒlÑa‚o››+“U>Œ¢Ú‘åäOºt¦C÷¤üé§úIœ:Ù¥V€ï™¤…„X7Ž…°îÁ†ñ~Ê;yOqU=‚’ñ ½ßé]‡ûâ÷ÌÃ/W8ŽŒ©}A†§âå‰ç¸1÷ a›woŽ½¯/ÞÙÓõÉŠ—zõY¶Ð¾LYð}ãɬÇz²~B/êfqé[ !ˆü¡š¿žìpízpHì½½¶ž\ñédþá¬à‚¼XÅÐLl¹2ÛöÒ~«yž{LÖ˜´3.öim3U‡ ‡÷¶ŠÄ8lÜçJ?2‰*“…™)dÒeÂø˜½ÁZ†u™jw¡¾“þ“h+O@(©˜¨kké·´¥úÓ—sÙql ôžßïY `(â‹'E[‡óíO+ؘvâ7`†õ×ÐQ>`–­ ¯3zòW¯pã+_Õ}ÑOJ?ߕ劄¼sNj@í6b¡B• …ó ‚ÚÚ`)ý;�gÑé$Ç’d•„K¬çåy7˜¢Í7‘~å9]*OÞ6¡ì¯ ªYP&ŽÕÖõÄ~IâËÅuûéég—µoFõµçrü-$RªS”øçå@ëÇC72élX6ÎÇú,‚§ì&éýð5Ô g™-¥XR¹u)HtZ’ª^ƒŸ”‡žÖ_"rsôáËQm»£Æ°Ù¿-±L¬4 fãÞÓ+ ßÂh‰3-C–T›Ø.ÍÂóÀuòµ”Ú«Òj¹šð¼(Çô¼ªicÚðP�]Ÿzî²)gnDž¢æçVßSÄ8©ô9'AÙ«»|Q±RÈ@µ˜Î)9æp&´ïÈïg><ùË‘–`qÑ$·žŽÝ‚É3M:õG_ïm–óE"‚>Þ²! Ø Ó!»8fœ§Õ·âvÃ(>Ð@JÜ®ÌÓ®-±æÛ Ž•µ5Ð¥ù<uÈaLÏB,u¶4“ÄåE3«û¢„+í6.A?ú³gã:c;ò@`×^Iz%el—¡ ì‹"(þŽà:(wïu,Ã}&*¶Œ`ÕÊo÷ÌæãÅ"· Kºé©0Yo¼q-/§CÏŒ’7 £ËA%ç´¶~¿ÿÔVõE|­@§w¤ŸZ׃ÇšÜëÀ d?Y¥¯=T¿  j¤€½¯™ë-Gàs9GI‘ª?† �ÝÛÏÎñPÇÝÚÓï‡Ưÿ4—æm'S³8Dù"åæƒ&ΙjGMTs óEöî/ˆYtÙ‡QD¯Ç‰=y¼Cä®ZI¾ C²‰ÚrÛx&OŒjÚk&•*P›ZZ^È!@ñ¦“òj œdë$žåUC\5À_m [:4FOÔñåÿÖ››×Å›Šï«}rÛ:ÈË+ÓáÝne³ÞS`ûE-˜MºXž¼3$¬xø†A×îOØ´ˆ£NBVÃñö˜ñ»’i  =OåÈ¡½<rë«c53Úíâù£°Ÿ„ž‰aˆlªb(ñk)%'‰XRºÀÔýô,ŠÒÎ+DÏŽnçÑù¶!1 ó¹šH|ßüOÃ…{�-·SCgÕvë°SùU5£œŸéû”¥s<Y€²½F{eû·}üf'7“š3é6,̽Â?.•Yìh7ZeÉ,®›Ï—¡å©>•²1õñ;S^¿×.í‰-4±ÅiDløÜ "JòÌs=�„§Ç³«=Kãd¡Í€f&<£“â2‹À—µ;Nhr‰sëb~â¸1ƒ]ù¨‹f¼å¼8A’Ùë�f 6»ˆh;a(Bç†2ëö ŠeÞì“YÇóóZwž‹vÎ;÷zˆýÝk¥a&á¬]J~’m³–¶TßP¶Ö©¼Êde@svÿÚNÝ1n|5]1`QåÀb0O‰ÜÚ™òV0Qà¯/Á…VhM—òÆž.Î<]Z§í³8½s€Ð¡µwã³”žLX5‹¬öZ°6ñö²`fú® rëö•Êˆw1Û˜é½þ7†E¨tÓ­ÃÙ_ºS!us‹yå±Ï‚äônî]ghØû;d[.ˆ„9¸Ñ¶Öþ [‡¶”9Ùº} ýŽññ>nìy•F|‹‡¢Fù>zi Å7—L³Cý!f<¤äŸw†P:r eÈîkAT[uê•37F–÷žYÀ˜ó:‘7>vQâå¦ØÌǺm%¡ô•†LÛtsºÐÛ@mn¢P´}ŒÙ‹µ9‰?Yü‡^ G”E¸ìMÞ"£|Céäç=÷J­C§OdAÏ7—­g•\ÃQÔÌÐÆî‹ÊÆtCãƒÅ§<á§RØðÆøx“n9ÝPî©û”ÕÒIèu“€0¨@¯½ÖÁæ±…¢ÅN}xHa*³+±üy¢¸\uGÙŽ™÷ìüëÀ¶ë;.÷¿}ÊØß:öèöϧÉsqΔ1««-¯˜ÇßðfãØ! ¤>åú é–*÷s‡ž˜3\x¹ˆ|3µ #ä‹Ï‹;€[ YðøU¨†¤(Wäô°ÇR]*h$7‡"*‚cf²a†£Z[èÒ~Íij Ëy«ò~v¶§èüó<À¬&Á<†¼—Žl$b(óP±pWìtWóa¬­ã=}\E“é3.yö‚<Ñã¶HœÇ…Œ¼¶Gzg;ŠŒâd†‰)‹€ð8’Ëϵ‘œœ¡°p3vfËÆÁ7®Ù'G„n_tdÓV€0%Ä칟¼Š.okýlþ]}ð¸bÿ£ì¨g›…©žk•sL|ÍɺðfÙt̃x{öb;K©ÒJA‹{x,¡k^ Âæ4wåž!}. ϵ~Åã  'xy‹Œµza¼c`.?­,â4÷‡+h.£´u*\¸˜¢‹rØV)põÜšŸO'W'F sõZà ZÊ»Ç[¼á{:LßM(Ò"óÉ”óѱ± £•V²Mü0{Y~Ã÷büF^›Ùd^±((†v¦Zqv|¬þRQ:ÛN=—)7¢\~¼Ýf7ÝÓw¶µ¹ÚÅAv²®hSq•å+ñ4ÈVíYößô3ÛØ¥?êh[µDž&æAáƒä/¶šQ.º¿ëdó¤ÕWzäM} JÛ£o>v1Þ]¦)ÑÕ·â:l$å…Oge C¾VÓ;*Ô[t÷:¬þûKwë m™ÍXC°Èénn.OÅý¢0ÊÔWî&!¥Ø1›&»ÌÄygݘ]b~ï™çKHŠ)-‚ô]OFª!<J¢†$}¿ÀQµµÙwrÙ+YÝ]°?ÿšÛz»†“³¬<BR‚iÕŸäuãKo�¥öÙƒîK#Ò¦¤sykV zwÃú ê”¼nxxì=»£.b«ãдM› Rh³;’­ú’º©í„•£Æݼ‹<Ïb‡ËÅZ|’´!ÎŒ—cåsóÂ�ž�ܹ£s˜‰ê»¤V_3ÆÞÓ‡`iXQæù~J……ÏÍAw`CábÓy Hˆ3êuào˱ØH?Ø#æ¢f„t{h¦‰w¬ebîZѬøñ>V§‘ÛzwDU¶ æšöp¿Bæ²>õwQaü}Lh¥¼bˆ´{fáǺ0láíÇÂ[B0˜Å¾½ó+ÌÈm›KT¬‡Mä–HïM´»û¦ÖɈâl:¾cw.Z¶ íRò|FÏ;­O_«È&w=,#¶…°[Ö’y„sßtÇʾŒËج�Pí)ñ¥ãhŽ¼Š7ÙjvFäãi@5i)’p?P¸Aà F ´J¹9*%â¾%îH‘ußÀŠgÒÐäÝõÇíN… )éÙ⳺'ôçºkÈX\y£/ réE 3o&×߯CEÅÁ]“/låÍ€ž´JJuÊxnjîàé]3¦ËlÌ4ÓèÎ ”[g°ñÏê³pá‰è”ÇÖi[v§d`v _›{û'Ë}M1Ò•Ÿ‹âÔˆã,ÞñÉ©í’’Ê\ zÓ"¨Ž³U´Íí¼¯‡Ë‹þ~Õb^Ó²ØR øþåÙU2, Ç5c~!1ù€úæt­^ë-¡{ †aa\é!¨¡5ȱïÝ@ßÃH¦Lvt£•‘§ˆz[_¤®t7ˆ²/ IuÌ‹0/X!hrvÞn]ÙÇÆ ¸²ËÂ%?²ïa7-ÚË݉3ÿ°n&Š±¨‰Õ®Á‚¢‡sI‹æËÂ@ k7ŒåJE˜­[»%¿È:‹Ô7¼ˆq¤úTù¶º²öª¾u9JJw—3¾åÉjdµíi˜vØçÿ Õ[Uº²ZPÊH†ÆcÇï»Þ$é:AúF!Ã5°ÄS& ¦KÉZÚÖÛAåXéM軘zؽ”ÅB…öÛ'Ô“Ôh! á¢çèöžŽÇÂyâÈmâ‚„®7^¬ÙvƒË Ò=_ÜŒˆÄ•Ë?B1¬ÀQI{ Ø`ÏÐ`Má8™úÞ²|•¢bIö ƒní)·TòA½ýóVVŠ=[×<4hï[>ÂŒ'©§µayžÛ„ÎD•Æ�íŸÐ,ˆ©³¦Oå1ëÄÒ”ÃkÞ¢<æšpºíE™ïýÁ8€‡ù¦¡ p%Ýl(îTÁâ©íM´Dq[ì¸On]j`z³¬[ Å­”®—Å¥‰6ÅåõYw°±ë¦O_ÐÒê:xÏâ’yLj³? éÏ24<Ø'„Ø4\¸%AÛgAQ¯½`M!ëE£};H¾__4Y¾z}¿•é-:Ð=ϯ`¡‹_S&õ§Ö²÷%`[aTë€èˆÔìLju‹˜}䞤õßÐ äÉ/¬Y/OcÉp@§æKM�ik�69ÐnÃ6AÓw‚ÞêâÉd¢¥!•@Û“‡p%œ¼5U {¿Œv>Gýv®³ œuèW&°–â îÑ{àûÎÚ£UW¿÷Ô«<-sÜPdZ•Ö ¼¯›Üš÷³.Æ<þÖ3 ;õ˜HÊÌóÕ"Ó“ë ›um®†þY=$·à”j;AØ®è°o=ŽGû˜ÓÇ6x&;¾÷µ�œ‡ÖôIìöLÊbPÅߪxtsR-ZçëkI“VóAùñ$†u@…¥@‚ C(Ž:€Vm44ï‚É/ µZwì¬-ìyTùçÀÅM7^ ›¥j«Uã€v^¦ù ®Í#q%7(cÐíÍ󅱪G£¡ l€ú©¯TÓr/öD%Ì |?sóv|›ºñÏŽ•N™ÖxhiãœªÄ `bù`ã}˜û6?ðƒ¼¤Al»æÈD̲c̲ž?õw=fq0A&~T9e nàl¡bN?–ÁqüãPisP)'Ëw ¹ÂŸ·‡}m±…ß©‰$)(l±ibr÷} Ô²ßš«ŽUi%dßÖïf#ªjM§.TU´P Hj5 G¹2„#¸&¡ Øíõ:ÈaªZË×MÛß{àƒP̧³ £"=yÿtxIHéבּª¤dKú ;²@£TX.¼Õ.apÜWÑŸ ¬GOŠiwL¨7´2 {—ñ4½|ÁŒ•‰›ÌyÝ~åß=Â=ƒ&=>¤Ü#¼Š íjùòYõå©™¬>ÈÜ8)Wh“w­VÁ¯”ª@d…~:]O½‹ýݦ½°9Š¥Ó=”*Zˆ±púŒ‚âè IlúZ ‡NJdv°ä‘Ïpßõ¡ÕgUºÊm(Î#í©¨Õ¶ x%‡úÃ]Ý׈1ƒ>rçtº•¹Kr/§d«¦ÕŒQk¯oÍÒÍ»ù/ŽÍÀw©)û_<_zsVŽP,ûÝ=K „ä×áü&<yLæÔø¦¡¸8ñZhwÓô@p톒2ïºøœ=¨ž\ßxÕß«Äë4K¯meaÅÝ™ 'ˆ´ž”ŒÕô§Á—ûfïéº_Íîþ’Ö$IÜ[¶'ú#S§£ÅIäû=ü'VPd|»�–ÅÍtþ¡g¬J¬Èxý»ž4[êâ¡Ù–¬5%, ¤š¬_l¡ëw©POHQ*^&Y§²´S›eAƒ›/ÿ¾þ2öG\íÈ'^1Dzè²Y[ë¤l‰ÇÞ¤.K¥¬W%³´”秨!^œ=íæâ\±HºÈ+LJ( .6(?u R¤¦‰ÍFaéxh»ú÷ßELhÑü¯)z…íhù_ý¼[Ò¿¹Å@@  8xb% ï$¢l†¾Î±öN .YM ÿ&—¡DÏT4R^T×gǤà¼ÌÂv…@*{Fz!˜t÷žÒj>â¦é}íÿ¹Çt =š¿”»<¡Aˆ�¨˜ó- @dB9W4É]eŠÈkPˆeÞ”ä—í§S WQ@@Èr f þÿǾ|м‰%¾rko~Ût‡qÓ)ÃœR°®í¨JÃî†úô¶ƒäÕ+£Ùë *(ŽGs»¯k©–#%¸qäþ®3“–¾o_„†�`Ÿgß> ;ï¬ôËŠ‹Èoà-I´@ W˜Ïƒ¼Q¬ôåBi Ý×2ð?aùðj¾Lw…æ‹Â?û¥ĽBrR¾k#ÃåÿwDrd‰çí ŒïÆñ)S™”âYÜ¿>%|Ö#¾g%cÔ£¡Ãÿkîîö£ŸÌRµÓÁçv,ƒdµßÒ80꡽H|«qj½…XȤŸ(vž×ü rÖŠhªÆN!Ô�¸7ÁÏ zœQ¼ðŸN"F#T þ¸²ÿûƒ…Á~ HH<h™­ª›FËô UÊü‘opœxeFÂÈ7ÕÚ­Ê2´EÃÓ¾í<žÆÃ]Õƒ’ë›» …ÜV¡y Û¢¯G] €(ˆ†Ïî¯^Þ¯bÒbZ¤¤tÜæAõ·ó\6qÇ y* ‰‡Qœ(w ‘b ÏzΡUxˆüOÎŽ½—¥Žqd²h “ \1; ½s1šËdŽFûa¸x @ˆþXEä.¢Ìkò�HE7ÊIw‰H§Yÿ}Ó82³Ð³i‚ ™Pà–·bKøD·Y¤³fþ¸“ˆâ;§µJ›ohûn„§ '¹©üHo)M’…3RLÿJWhs6û¡£ÿîm‚Œ‚«Ê· Qð)Ánã¦8� èÃMEűȲÅéj¤˜ð~t¦£X~õ8ù0�œýôœqë Ê£÷›ÓÊŒ×Uÿ»”Ý õO=ÒΧÈøÁ4¶ãɪ"c°Ý—öå‰x¿†‘Á;ºÃa½^Ø)w¬½|tf }cÉGIæÜ`5¸)‚Ì"<3±d° `JLYRÊ=yÐnÈ—"¯,N@‰·…€±D}ìÙó ‡‹8Â!)’Â÷9“1öˆJ¨QÐ?Îgðƒq7ïã`¾•:N\â•°‚ïVK­9Mn$%º{+Ñ)—ÍVÝ5< ÷Ô UzdNUøkpX°1=îVõ4Äán{è€ëbÇ®ïl„nm…²Ðÿk ZA·ûô4FWÀ\Z-fèù~H þµ¾^á¹0iO#ÙêÔ‘-DLM "ÞX(g‘½³•cØTpEæ;µSðë)GE9ƒ ¿®Õ÷œ+«—$ÞêOÂm¥•„*E̬Q«üŠ:‡Ú:Šr@ ¼±lSE>}åw dÒ¬ëù¯Âÿ”¡—TH‘/‡œ.úgm*™*g˜<¾áÌû0áÞé5oOp&»Ùi[–ëµRpK!t ±~/œ˜€-»7óËüÐü=Í—ÃìÝ<ˆæO ÿôÌŒ7VÓ¡9�hôÚmåCŽm—§fÌkJ·kkQ•¾ô¬pì:±®ÓÇóØQê¦>P(2>¤«†«©ÁÑ=1¥ñøS}ždE¦88_ ØoÚQá;9SôG–mÿz³ã®§·>ß�?ɲó̇7Sý·ý¢Þo= |;îÌëø˜$öÑOÌK¢ˆo-˜*%vµ(J *³9ŒÁæL!¯mí£O¹…]ó@Á¬ªÏf:„·Úü¿>0ù‡ekÜÄÑRMˆÙ_T'»0¸ƒÜr‘f²õ%4ByvßþÒÿc‰Á¤œ§*(­íTdõ ÍYKÖL>ê~BŽm¯bí2Ǫ׶¡O^öVÚ‚„+¤˜^*Eyà¯edYoºáþN*S¿) L—ek•=Q3œq¹úNøl?«úÜ€»P»=ôËk+nÏ™çŸnÜ©ÒÝ{ŽÕBzò+Û4 ÒÖúZÆÞ„ÂøfR:ä¹{rO =Ž]¿›‰Ò?ˆ|® Ä K ’$ŒôãæX´Å'­~¼ÒØæLj™‘¯« @te«A™Ð1ÅÒ|êlHàîISO»žu˜4³DÅN\éü <-H·­'ÛÅc%Õ_t©™{vŸšºYkÄløÍ© ª^U’‚³UAJé³µ”ì@â°V2ˆý =¼$Ï 8KÆø¶ Ç£Å`µ.h×Çí—‘ŠÕ,Âðx¦¬~Š ت? /š€yŽŸF¾†¢@ëÊ!Ÿe3#:ÿF¿}TKÏ|)úR€ÕÿÉõKÇ/“Ì' –˜9ÐU}!|NÙ a�òÙ53—<fÙ}¯Ñ«yCžz”,ePÿé2v r;R¾ õà"%až7¦Ÿâ«ÛîZº¯bŸ!çÜ ½Òˆ¢ÊiÑ¿Io‘ñh·cˆ.ÏnìÅÔ¤_â‘(È?}ö¬Ña ‰ *‡> ’÷‹ *yê ù´J€rà ÎsQ»_œgŠ'ï£65ÌÈrùõ¼kF7zþò<¼aŠÜ£A'>‡:ÍÚκPú ¢wë°ÑÛ÷Ö_0[·p©€ –˜är.&@”ˆ¢ça5p&èÕ7 fÎÇ85ïºÚSrl‘^èëÒÕé!Îï{¬ ÕSýžØóÎb\b7$AÞ^üÅt™V£ÞV=®,ƒM–'eSä6?ˆCÓpàæ’m’ o2H€×_á+Dn=åLe«¡:£—‚‡ýV ÙúüÙ'´5-Ÿ8T? q�|ßxôk ;ÜïQä×�]óL15Ó™öq:êTÛ“iOݯÂÏÈcCy§Ï}$&,€·±ñh!” ØRàG3®ˆ>½×5gÄ€ÂQc);”24y¶ös?ðÔ+*'zKg`áÚÐ}Tàs$XC€7¥@¾rU,e3,:l‰16‰@hQ Gö݈hM[H8~ã4ø˜aød¹3°yézåD,'†É}÷—·w;N3/žRB¿:À[aRƒsöÀÙÒQÐw „þH¢:ÄÙ¾ lãKÙ„55ùxƒN³‰_1“PÓr‚M·v¿¶²Á·¤Gv øg=kkÇ|væ¶Î"HöZÚj%[ÎN&¤• çz4žhmê~픡_‡ƒ%Úw14H§‘UY1^ÓjgΡ@–'Øñ}xäݲ°ˆS0M‚bÔŠ9a�•ýÒ4Úë<Ý­¢ÿ¤QäD[¹Œ÷¨šzÓJ@t†^›kÿ÷-âó@íuêã‘þU$/{ü¦žØX,“ß懚'õ—=3CE$L_´—ÁrÅ¿™)åFù§È=¯óŸ*ȦƱîxé·ö 8â…¤ú !TPòÕ«ë&U¹´)Ðÿ*¸¢NmgáHk‚s7íp*XX~ìÔá~§¿¹²n+*CÞÊ̾ÞÓÍÅ\šãyYÖìÁø¨³”…ß#¤{ÿX8ŽJÉyZ¢0¢µ´ùÔ<¼Ê–Ã:7œ½§¯:Ãû’Ì :Ž¯9«¡·?õÜÓ±üS­uÓ Õ9…UŸN®›Äµ‡äy i(Q²OHábúˆ·­vçPž‰Áìúë ù ÇÁ…g݆íèžÝUsÁ{à;–‚[ýI‹ |¿xV'r&œ­®¾âå¿_/q®íÓÐxê6[�úÆ›&RU·Ö0qd7Zÿ§a3Ë;Ãñ›3„ÍšEñ”‡GÄ~yÁALÁ F>…Aé N|âöd1&è7Mz´QF»w^m=*Ø+‰Åµ æ7 Zè”ÔÚ{E' tú2ìd‹eËèb¬/z £~ô*7÷¬î¸zoú;§Aû¨4èf2kÿ&P?›Ä˜ÃÙ­Õ˜Öy«ˆH˜ÆRIÂ"½VеÞ;X‡{ξ :Y¼ñ#³Ü¡(3ãèÕ¥ÙQ3Gœ6ì ~<œwS`7Ñõcä€ï‚0. ›FkѪOÆ€e,ä^È¢ýL#MÐD ^­S¤è'ùsìp®|X°è<ºö2nwgÄ“y{ßæK»Þõß¼ô5™p §> *«ŸCˆ]ÌPkŠÞسµ0¾¡E'Þöѯ}ªgaò‰áX…5¬Mùð¯‡íáh¿ƒú7XToî÷Eär-_ѺZJe„àĦžƒ+¬C…ï5ò!-O–bˆYpìc(§iJjtÒV,WÞ4çá£cáššdgZ ò“Y2ã¾[ 'ªÐ©ìD,ÈVõùWsTôµë3CTÅÞ¼Cý‹ÞUGY–»yQl€qV< 0ÉØ™ùÍô[#tÿštIáx ".æ9Wnˆª @ֳѫ¸s3Ó©=¿ÉŠ±þ#ˆ¤ã»ÕÑ/Ô@™¯ÓºþÁ>yè§,<{I±9åjç$ÈûÏ«»L5´ ¤—g€ÿ¢ÖúÆì¿õŒîž>áý€3™£““¬×–í"V5mûìxñîÆfÜýí8Ë°ž® í0À!¯^ÐÖ¹G‹²Ä•ÏØxÁyLè”îœë›åÑ8¡uãõ1(üÞ3/«7¶Ê^º$H¸cˆ…Àv®—±sÜ_£ô&ÕàeèîþîÚÂ<¶í¶Ô4À›! ²Æ¶¿X±ýE>Dmï µþƒÀ=àk’”YœY[Sä6#%¯lžI.¶©™hè¹ï)Bä9ÔÈæ¸þA;£û‚uÔìá8 fNû‚Å–LîØ}uÌדU'ò%ÜŠ~9”AéÆš•(™|£]ÓÓ¢ç#ºg•>3f½EJj­þ.DÖ`CÓ‰Þ³ç×&þà?t!Ç&>óoóPÊ/R¾QÒª‚*¡qwvÄ&Óo6òV˜U‹åªÿ\I5wƒbïðPR€:V î£¯5Eߨ°#í3å~ ØI¬Îƒ›(ï÷q ÖðƒëúdÇÞsmèkŒwí1¬ ˆh>Äb¡]Ùîæ2.Ó³–z\Õ¸Ð=»m38e¢ÌÐIæ!ÀóÚ1¨XðøšÎBê—”ØcºãúB%ÿà4Õ)¯ÇÍa²$’o:Ñ¢t1ă$JCÒ:ëe9Ãõ>v=ÝGÍ!íÈýé3»H²È'T'P@¦0\¬`gÊ{§•š'4Š×´O°yr5òð°8›„HPÒlÕ³}K±cw§½Dæ"eÓõH‡½:µÿ)â¼âSs'Ž}z•\¦µÆ:Dž¶U0×v"¡$*¹ q´,÷¬J+܇™Zv²ÎX+íV3<ìŽÓaÿÓÚ$H׳…ÒºUÁ¯Ÿè�u()¢CrnL:)8Cµãø-efâ~£¾Æ>%ÂÝÙÂŽ °”f3{ð؃²áW8ª¸Ôº>³,hÆp Êij ìtŠ•´­ÿZ»‚‡*yVzÓ ZmÍ@뛞ù´éÕÀQê ;!Ðô­båa ñèMØî²ñXß݆pSbßWx}Ј½v†´G`ÃY-`ø`èÃù§Ü€—Üäðz¡KÒ3D]x£úú…bóÛLeŠÒKßÌ'”ÛØÀ«“#•)Æ}¹>ÆöþÄðÕŸ~p>ÝO'lU1€ì@ñÿ6³^�’Ç^G“;×tôgA±©ç\2ï´ñ®̵¶§É­œa”-Ôˆª`Û.Ù(”Å7åa,ëcà´/zª%…«%+Õ´¢’É\¡bg~ÛêA¤³á ƒ"›î8æ ÞSE._sVâJHL@©x©‚x<{Â#"«†µÄ•ó(M‘%1Ê“xzminÇ5R;湕{¢8–{§k5ôP’ m×€Ù©ÈPMkžŠBæM§ÃûþÎË;!Lif”ZÁ̃>¼u�&¤šT¯…xtüÀ¿#r³�™ Óͤ³ƒŠ=+e»Ú¡-€�åìqÓð0í×ÈV¾G¨B*s†.U4ª(‚Ê7 ºB¨Tc¦­­Ôy#çÉ25Ë*9±ÈDVß1/Wgk$ËRþ©ËU–8<8û™máb9[9¸ üé IN¹\¯@ÝEZùr²èK+ýÒ‰‡Ž[•]5dù4žØóVgD”· DD2[Z”˜;!³×æPÎW*7$¯ÕŸ„2®µâ‰K«b#†ÊS3ëx›ŽõõKÓô½nþ&Å¢¦•nSaÕŒ‹Œ=oWÛÝ䄇§•ÓŽ{ôüN¡' æL¼pâAOÁ´€fc§fg²+wƒ·?þµ;Ž!B¤iûœòYÅÐ0X¾ï|·ìƒïÙlþí €× I™q~Dêo¬ÐQˆÖÕòšŒü"Ѭ<LiÈ1Tá–®Ïý =)–NÚ"¯@J][W ¡$ØWV™%æš·5]>­'~à|bíÞX ÎHŸU<l 6Ä;eô»ÕÁH“M³ÏC§Y Âÿò´U Û ÷ì’jÇèVÅ"Ù„-«>ÂògtdšTOÓûßÛ –›¥©ƒT´£m@¿wª—ùÃ"¨ª|Ô™%³ÌlXa)Íý9Í'´EyåÏêà’ZÓyWÊBÄXå­[ð#Zbû[¸)lÅy¾8o˜{NàÎ<Î#Ÿû‹*¡â§ñhÙü!$kÿc8œûî‘ÚÒ¹6¡¢,ÒOÖêZ/¬Ieç›?`’¦êÃ¥p8néøͬb•˜¢kÙ†4U”§/A <³w´h<„™ÆÙâ Q:Õ•AÚ×>+b<´¾Š²«‰;ý÷ž]×Diµú*à@Ko¶Ðù’OGc”iúJ@µI—ÕSRä1çò%ÿ¡AÔ¨”0äL1ýQŠˆK‰ÝŒ{‹“?G{›+±š!³æÁRœb>YòĶ‰hIm¼°}î†?ÛÅ{­õ/’! Ü"ØÓ”NY ²øÍi²½;ȶ@6Åœ¨·NæßþBõ×,“' ú$È»­ ­êvgu'Mç¸x™ÏWgQsÏXó‘ÅfRùy2æ+ñ’6‚¦_›ž6%Ï$^µ#fÎ`¹½Ý1 ¢£–– yC4Jîø÷æq¹ô-Å|. âÆVòE"®^€]Ú¾Óý¡¢>úÞ0깃>ßQÝ\c«ïr‹ÆèŸþÀÇQngŒÓ> ²QýæbV‹c?'){½Sü¥'M]˜Á( yj&€R9¬¶T—þ­ßxVÿ`FüÐ92*+_*KmÌ)üë9¤›.*Æ ‡ñ¨£áGÜÖ(.\ÉÇhÅÝ1¦Ë=œ½];²ß‡Y-“€Ïߊ쌜ô÷&HÙB¥!•Óp­…Eb ñL8�~Ufý?V7ÃåÚfÇ›²ÖƒŸb)|ÑçßÙÝä.ÅN\ÏiVÃ0Eïº=´ x¹i²?z¼±ÊkƒÖŸIwtÒ‹í¡AÂbyM½Ñô}®Obc,o5éË,Ç"@@Ú#ƒ C»ûÚÙäó½¦Ã‘3MoÉ?±Y´Øè‚׺¡@™7³#Ì2@5ðö§ÒB†ûϹ;óLÕÓßÀŸÃ%QeN­WÙ£¢CÓZs6ˆÝ×ÌÇò8s’q �xŒŽ9Aç·”ô­VxÅ“ÆcG{z ¯w¯š/B«‚±\Á¼¦{<馔ߎ¢·5&¿æÚ¡nˆv Ü,óX=4y B¡²üTû:Zõ0ïnSúòË9e™T^t×bfß0€³Øî™.¾=¡‰c5uÑ×òú‡’9RÒA¹‘>üÆý)J*@k¸í²Œ2>õ4A©æ‹ÙÍ»†F¿¶”RÐ^'ÌÜ–½Ò4 ³E@ºmž†qs Ã†/!lg¡å)1u:oȧíMÛ©‡K_Ž½Rß/n…ÖÇa°¥š^k‡ÞÕ-ªÜ†£-úÝS«:ÉäÇzqèîd™Ê­M®u‹àʼb’ âmMWÙJVDŠ6ÖÎ?/ƒlªñžt”{"�¹ÐA’ 9zD:HعW6¬oòÂson‘-á߬.Áø³Èhþ”=dX\:i/Š¨‡•Ãl™‰UN‰®eý†³6éÊìÕãè~.ñj !œl,ûÒlÇ,HìT¦ë¨+¤ÝýaÖ§>Þï—9$µÛÑ¢ ²9Ѳ?Ýð,ÿèw½¥î=³C+ë *6‚ F”bFŸï®•LëÐœð«¥ÒTG Ò¬±gÙÕK,­Å¡#ÚÑ-O{•>‹©¯;U¢†uJZeÌÉžZ–¹á$Ó!pÑwÉ>·¿ˆ¶ZgCNCÍyM4Ï|e.tNEnÕÅ¡bÁ© ¶…§€%Üœþþ…ºÏÍ/Œ-ÚËÖÄîk¤˜fônM” âP÷s7 És%ÌË73Û(ž2ÈgE-äJ@”Ôépb¥q±“d^“N4ÅÎèO·ª¿:ì5¨¢žåÕHÓþ´¡pœäʽþé#Ïw…ëÍaG¥k\ÚJÿA7R&˜0HÅõÑ#@UîIÔ²fÙñ@WÝúhä ¢ˆ˜ªý]ÅŒG:¶üŽB#Z¹jÕ¸z> Dy8ÍδìÁp5Qâ•™:SDaO« ¿àsÞÍî­¬•wutüÍ”ˆlOD“ßq�ïÐSÕ~¥„±okݵ„¢¹¶J3èPÒ$úÖ?¥dZ‘¸˜—E�xS5Z[@²[Lù Ê®¬×ö¿5É6Í%Z¸ûÞërfÜÈTHS#»n¦ ôÇ\ž¶û³ƒU< ¼Î šIáÂÐçâÈŸ†…“³iaMAfÕYÌÒJ4±ÿVv¼È3… ½å×»V쳸c˜6‰‚M“=@ŒXF­}ÝÓ‡ÐD+ò!RrÕ³Œl_{F†+ðWôÊAžÝÌ@ÈDøH†)Wí÷ÐP‹¶'*2ÞD†Š‰‹ OETëßHÆY §è¹€q‡²V×f!(¶à>j{gýðHº*|j#ÕÃû’Ôà W/ Ø­.¦{ïf±(«¹Ý1+ÇÊbeL×ð dÌÜP {ëÚý‰1pö)ÃI]—ÉõÿÄ:ñQ2½ñ‚>Ýád;âì®Q7—{`Ú'rÍ¥‘~k3%iPnœ³-»Ì~àX‘?+ºƒoieÛôEÎáM8ù%æýߢ 8¢åE¢ev‡³ý¿Ò±ï&¶—§\ÛâìîãíTàŽ*TÉBG/j%¾ZªM&_?äe8›=<çºî•vÍ~›Vž;2#ç÷)•¥íÅ‹ì’GàÂiþ}ê!rù+à°J’ÜÍÔîÆVÍ4*"E>H=k2¼W¥¬@ŽœTô…ÚKÂ;ÕOco•Àa«8bh¯دV»83’yHh)¿·ž)-®ªT%Ú0™æÿyë;ªéë[Jêß=À&Qœ¹±;Tð.yP¼Ndeì6 �Ú?x<œxêÖwÿ¬/t‹nq¾ŒÝ•±…;ÆDˆÍÿ˜Ÿ”§ZÁ¯FoQäÕRÈékXm!tø ´—sJ¨`6#h΂öÙõ?òX¹AÙ6ñåûàæoVç.²Œp¦ÜÕSo*S&ã«v|Î??ŠN�laDïÜî6Sí@ݽWáu±Ù*V»Ù‚P4l½P"R4’}³Ü,(âå ‹ÊËE•3Ê뮶ÂÇÜ“­¥†Ù|!Lf†ÉÍøtëíå(~â<¤ý¬ÃWÁr‰çfÝh{Ï„,@Ex¶µé=\!%wú¹ÜU^—Ä~¬‡ýÂD)nuºxJÔë€{±÷æ£;sÈç÷ÇÞ;Ѻøg_[âØ“šuéøŽ{ÝÊvëÈHOhŠO®–^/+U&7Ö£GÌl† q�J€`ó=f¶ÂåèÅ»þe¢ª‹­ž¦ÎÓ³ÄfYŠ <êN„ÂàtÙ&Ô˜;S…ŠAÊóÚ¹qbŒSXÄñա昼²Ñ£èÕëýÄ`6ûd‰jK²<)=uôØ/ž-Ê Ã‘°Nš“qŽ}û¨ö ‘„ZZ¼=¥Á½jÓç 599D–„û°–¸£øOÏT`ƒß×Yɳ+¶-„!®iA%+¨ªÔƒª…¾Øßu‚­…åBÝW^z{²Æj ìO; ÖCõ_„€Û…‘ø]?uœša–”T_B³+ç7]ãXqF#£Ôxþ´áÒTo­Un}Ù,ÚB]ãÐ4&V[:Î-©"‹CEL¾ßíÃñ+«=¼Z×´3LÞî=µMäEL}ä}í2JÈL ‚»š¶áɈ¾Ê‹¡°‚Sü¥ª‰ Ù{2½¯ 5Eÿ‰Ãêš 4Á±»ÓˆžDÜDæ„™mÐ!ZÂÏÙ8žÿ*ŸÆ¸@¤­E6- zP°êwOoêëV‘B“yãñÅ5}Ý\nçDÖ K\LJ8¯¦AÕMvYo­ %2P3zªÞdSÜ{vã¹êÕÆ/¦]Ò{"uOÑïwŠoE;QŽŒÍÏUvZâ@Ãg®/=–‰Ù†”ïo)Kií“ç¢%QT¹@˜1‘¶ƒdì½<—÷.%ƾä†We §ˆÇ÷¹¥B%1¬zq(ó^6i ’6¡C¿0ÀÓÂ,–ŒÓ`8$¡ ÌûºmbiZ9ª-â©LÝi8Šwû=ýÀÌ BŸªîÝƳøãfÐxÛ»LeaækŒÐæ뾘¬­“3ŒÝ(ezî–$1M9܃ΫŽŒè}„t¨¶×—N)²á)º"'UÍÂ=¹•ÇÌ"+±"îÀ"¿±îKˆ\ýí´L@â2µ1ÐÓÝݵõT«²1ÊÔF©ôkf Žñù£? Ô9©çÊØg"CªÞ} Äç©ë…xÞA´çÐ}ãI˜:çdIíhùGAõéù0a¥4]¿—e]½óHï:ʃTÞaéQû*Ñ@6-VmSp9x®ôžüKf&€¶L»UlMÙ ~ÇÕwrpîÙ½Ù_µPgG"C›w³iûn¢˜)M²Ä›ú?|—¥¯kž°CsFkô¯›iö»AÒk­ÄÏÚ—Qduír£¥;MyPÍ_ž£½r%d{±YÝÕ=9ÐñÂÊó*góëÂ=›šÎõ¤UÌçÇ@áRã�]*HX°èHö"æ±™Ï÷OFãÙ>y{ЋŒ³¥Œ ó§Ñ‹}×:âû=Šãm¿!I¶BÐV8Òð“ ÖpöRz~@éõ¥¸™$éRãbúH‚rÛk2/J½õXk[éžè7’ ‘êX –äƒÔ á,–(ö0QsÆX]KKZ–ÝæÝÑ‹:œ“H9`ºÌÚ^¾¸ClL#—ï0“bsc¯÷>%N±9 Ó@–ª ßê”B0(ó¬¡Dæ퇅Ðy8 âLz/;ªSd>¿,z÷d£cCõ˜ lOóB{† YÁľ9ÅcDY!fZˆÃ»×æ¹½QÒwìEÙË“dFV.ê¦zÍC¿ÜƦݢfÚª$;š&A5ÐJ˜ÐCh€ÿ}ûsê»>O#¦l®½ãÜxŬ¯ø¨<XXJctx�v5Ý;æ½ÌÐiæCêIò =Ož}ã‰J`. (1±øÁ›‘ƒÞÃ~²¬üŸøFZ³ûÄ Yš–2Ûû´äùµtÖn3”Ç©ŠóZLM³bš¨TkoL$mI#Œ½ ß'mÚÞüâ{ñAç!¬’€Mž± ml5ʯÙZà–²$d·ÙMO॔v¢I*›Ò/[ü‡ÅªDÿ/•+ŠèštÛ×FG¶‰ølxv-” Š¼²Çó㶮aÚ;¥L*¡Ï´ÞÞ[§u5”kh[uGn r9`Û,ñ¤Þz²!i¬žk—ñò th½g¶ÙU:CcTá|ÑÄ@m5ï#0îTãVã0ŒU0ÆAqTò/ø5õGg[µ±6k“`ÛõÖýQ´2ñظ浄¤4+ÃkÝ4ZYÇhtÓÛe|ë¶]{iÛàg¤Ö¸Ìý»óXåIëSfuo|$È…nÇÃN 4ܳó… çþ7ò,Ia5°ÈK:æò Úüõ,‰@u(R¶Óî¾Ã¾¡Êœ®ˆ×eVùòêœh§³óƒðÛÃiúêæ‰h� …³íº~ =@)zš”w§Þiƒ”ÓŽö˜eÑw‚ÒìÑAV9è}ÄÍ–Þ8¯Ož¥ÈÖtÆk*.CgcKÚì»#E©jëÌC—“Ë ²z(b^êÑV3“[ƒÓÈr`6PSP(þ<z¼}tS-Ò•ß=tá3܆ѲܚÀc)Rzõ/•]€P m&ÿ3¯N憽ÒÎH³…ìJ‚�ÉéÓ3^ª7'Â)‚ì¦m}þ™@ìüPdpFá` 3°Û˜ÆÞiØAì ð£5 ›O ‰Ã…™n^sjBA±ŒüªÍ½ü}öhKfVá»G]Û ÿ¬·—”Î&5ËJWõBˆ2éÑ¿ÖÕ+ÖD7-Åín^mwšõ>‡œ—áÈp[C®Ø²{ •"²5†g¶õ[…‹¼„ö/åunºŒ{ݳЄÉÖ_S³…‰a‘¾0˜ß½ã3tWqŸëƨžÛ'/ ¡RÏ›4fý`‡[=ÙwëØw>m Cm'>T%Î3_÷ ÌHœŒ½WÎQ2à…žªâÐC'0Ç 丷ÈjLcO}‡ÚXÕN—m‡û¿õ¬ U\\ /ÖŽA€¬pµ;Ö½¨óÌÀËoüó\lË k~}¡<ÉRpXktG|HkÞüЪáœ}[C[chÖé`᧠ía’_jbîŒf纕¸6 –éC²:až,ôPsÙÂPçz{fL†#n#jÿý­tžª¥IÛmFû±õ*dö((™ õãI²tyäßž÷+ù…iG@•0}?üÙQ”d®3ýMŠm&fÂ…ˆŒÉY'=›8HòšSƒ0¨Ýž˜|‰¬‘ÚÚ“ûÒzk‡Î £eïq‘Y~²(ö ¨B‹úâÉ¡Æê¬Ó|8›I‡{fé\ßš/¤i¾ðC†¦WTƒjÅç »ízé¸Zä;q¯¬((#ö“ _]ãyÒ€ëɇ«PZi•Z‰j†ãÜù2IÛuPÏC_³ÔZVõÅ“ø ZhH~†ÀˆÓ Ùð7@Œ<\T t;¿¨Lk;ŒÞ¾¶VF¬]an>&û繯§Žür¤ØÛ©¯QÁ‚@4¾±Ö‹Ã“P9]+AÍ ø>ötÏë¤à ÔôûÙk1¹è»úogp ¥'‡ãÆå‰69M\.™OŸZÑwa7ЗÁ£Käâäµ\ïÝfº/c+eQ/@ž Õz„‹©Gš¹™]8vêÊH ˆÆcLìO{ÄìʇW ‰¸r:äb,·¾m<y6 2doFw°¸Í+(wT¥N’Ûw«™Ò´x­ÓP(nu=ÅØÓ^p'"W@�³òS‰‘çÂy�KIgÍÅËý 1ÝÇ<”—uBòꨵڃ5Új·ˆV-–¶%÷c ’iª£—$á¯0 ã<[Ò;¦:§ôø³s-"~&™¦ABÞ;ÔJË»._-Ñ×% Š€wÇ£FýýÁS‡ÑQË¥º»B° ·¢ð†£ÜŸÎ%Œ'¯ûK±q×?î'èÅW2èÙ;Ît±0ãPÄ"!Él§P5‹Nëçÿ‘Jd¹kÅ ºÓd•–ÉÍéËI0ƒ¿=`ÿȯ…xìê« .fîçØ¢¡óÖŠÂôíãí܉8ëü–îë¤í�_WH÷pý´l~‘ÁüMÆèÏÏC„ÍltdKîÉÂnS ÔŠˆ˜Õ°,>£;E¼Ìo ÜÌÃ+îô¸ÜýË\qʘöÐpüã˜kÅÎz8ʵaD­––,þÝcè]å*"[vHƒ¬³6Ð,®/Î"Š¾SÇ’£Ï'¤Vð)4y~Ó&Aùi' p¶‹Óº+~ßë-ÊØ6LÐ'LV,‰{‹.4]{ÝXÓõ‡^ÕŠC?â¥DYøôé]i>µfmÙ/¾¹]  0ÀaÕSBû~¾îK ^Oãn³¡³ô' øð;í‹ahg ¢ëþƒö맒נ1N!™ê“ÁôêôXÄ„å¨M@úèD=}eŒ{QŽ‚C3l½ n4R¡ùÇ)B- ßç$…Óu“ï³é£ ³Þ½˜ú­º•š-ºæÄ·O\“Æ…¡—ô°«5`�¡)e 78-·ÊÖCPááŽÒR4$L¯Ì·'ÊØŽ_Ö¶F‘ýŽŠzWäÌ>ùWÄ•<,³J—·–6'Z_åWç¡þ)9…ùà|ø!º©ÃTâ´Ê]ùÏÃÖ=]õyí)À®Áµ/ÿ}‹ko€O—®g<£¡±é®þ¡eªdï+*ˆS~œ-ñ‰XÌR ûñ ű]„fxÔÓÉ[ÐH¨5”¤GŸMòŠ¯òÆù{‹â®JXú* !»2FAñ®&K¸ xsîm‹L™ý‚c”ä~D ´�³Ídî]6© v¹$a£rçºyc¿ûQœ©Áö˜ñ¹U‘dºh¹n ½úÀ¸qîàÉ°:Œ§ýM¢çç-2·Xmi³m¶æM +<¦ôª­-–,OVªûö_<>ëÀàèngú#½ª½rMf[JPk»3%Ë º·R²<‰—)­ÖŠC¤^rÆÈ ·÷‰bôº™J¬¶oQiHhL@ŠNgÒØASIšoØGV¥4Ùh;Px(ÆOO�Ám=‹I *`\TÁFçQ]bcò²SKœdr^‹QÎkð…‡Ú³p¥ÏL:剣ÏqjÇÃð•Ýdi¢?3,I+‘’¾tAl _31öµ6kb”½ùn@+G…ý«Ê3ÓfNû÷ekY:È #öP §Îù aŒïæ¸ÓñÔË1“s|®G]íI{m n¥hê4àê8¸9®ˆßyÐÐq“´ãrº0ÌúyqñdÖòBóÛdà«>" XVõ€Öç;À­š±o/í·üăÿƒ–ÌŸØBu«ñÔ°ìðœg}Ms˜ƒ¹Ûm"À0“ò+·¾vª•5 ǘ˜1KÌJ{]ùµt3h%®;OÓ½é趩P†¤¯Ë† åKªäŽ0ǾdË0kâ*ñ·†âV#&ä‹Ur”XgÌu7v,¤„J»”\yu€&Ÿéü«lÈ !•f Y÷EÌzÚNš KÇJóέÉßð'žüŠ²Ù‚×ç[‡ ãú”…<Èë­µ�¨„¤Ç’õ"îõ(¬#¡ØïŒ[ËúÔß;y¶_@ÊåpƒJ‚ÂòsŽƒ['±Ò¯Z@¥a¸à {L(j5n£:£M6-fW›Ç ©+$Ô/¨²­Í,JWwTþu–$Uæ ̘d¡©yRc¿Dˆ°»þ#®¸~Ñ׌SÄ/2ã0[ñ`%ò¢²c ]÷î§_Á¦Áq¤œ ŠÎäq—*úH®B±¥UK÷‹Š5*ŠyãQîæ-V‹ËÃîëSTiœ{#ThjQFûwë¦Ì¤•êÀè—²²ÕÔ2zZæÁC½s>yº®D|-ÔûRæ™z PV3œG:n’w=¹ÛyRg…Â9LHL»vDÆ­”Hï¸ûáÈ×Ñ•ÛTgA:Y. +¹Šî«Á›×'*’)ž´íØk!è9\IUÙƵçÿÔc½õôºÁ`ó¶;¿z5‡«£ç·s]ÑfTL7Й¹W¦\µ´ÿ'D›×òÉÒ¬íE§bá“’‹ aIEÀ§×A�% 6>ÿªMNM 2H½s'l†.û4WéŒÑ‡ÊÈ·>QÀ Üø@ÅÖQ£¼u‚™PS¢7Æyäëtƒ/KÑÌg’- ƒ„”ö#ý©ÏÙ‰¶‹[«š¾ŒfÚjë§Gü¶ÜNråÀ¢;\1æÔ\™òö¸2(¨k½™×úÖž¨ª� Ú!¥Cy´î½1,3½²ª¶^÷[ð©3Û \ô@‘:?6ž±#R7!Ås[aQ®=¾)nņÁµÛÐ%›gï75_kLzmyó½þ[å ÌJÙ °ÙÍé•!/> »#ýGˆÃSßÕ"ü¥Oäz<d›Ä•kð'’wÓé{ª-÷ í¯ùR÷î.(lgúDß}‡©/ ÷¸hØRäHêΉ©Eä-´© ¦,[Û'À;¶G”šq&£ãÅÔ–%•Ékè(èȈ¢Áôº­u%™OÞMÏÆæ°±Hõ|hmÿ‹ŽMdaj<>öY5­‰¬9o™Þ¸ku(ŒÛðõã}m˜Ø› qi8¤¯=Eq)ï±ÒkÜà~/»÷Ÿ:"Ki¾‚Š6î?ÒУü$¹¹Ë]wìôV4»¶5Ù¡‘¹~D?;ó˜TÃu3µÈ¬¨~Ç«:îçVÏ­²‹Ò!¼ãÉÖá¬g=±L½Q’ þK7XSÒRœµ‹«1¹Éé¢ Süp£;ÞŽÅ9fjÂGîÔ›W,’6Z9Ž>bËux,,#íEjZžúÈÅ°æÐûd‹)x ¨½±”4™èwni¡w*'¨©û./¸¤ˆmΰ Ö  ±—ôÌ=3,Ož«-“óÛ\]».Q©†K$Gm)›^? áÁ….5s›zøš+¸K§dÚŽÝÙàœ�ìB ÖÞ}ÈÃ`꜕%Œ£w]7MÇßàGùH…2¢Êè'PP¢;1kÞ”^¹Ò EœûxHÀ)>­gF¹Fï: KÆÉ°ox”Ž|ýá#\[ÔòƒW-ô`¡ž*VèPÇÕ¾ RÛ‹„’Ý™SDÃEþ…)»\a8T´|ÌiPN'Ó£Ne–<v3.¥ç*C/£Ù®Kø¦g]óàÞ±£ØãÛä@¢¯îä0óGëô™Ï'-‹(¡½d˜žt7¶-{à@ËÏ‹Ì5Ÿ:+³õhëlNt6õJý²A,a§õ«Ç;<(¼8·TŽ„ÝÉ#R<A5e-pξy¼N« ç€Éÿ«yú˜Û“ß«:líiÈ$‡™ŠCI¥†Ö=  4¾ÂŒâ }y{µé£; uµ3|Ž½È^ éXý©‚¤÷GH¿G^Ÿ¢™M FîL&{ d,ðd€¿P@šÉcŸSäýn›Ñ—Ü+ŠÌó[¾X´Éχ:—ë@ÐÉ ’Õ{Ö5ÍY6¢{FŸ¾êÓÛ”ΫW¬–`GªÂk…Jø®ÆË3>þ¹Þ±7±©åjó&x¿ÝøSlÛñŽ#ÃhnªŽõ­¥ÚW´¢Ì|ǾFÇ~²/é–œ!Á?¯¤£Â…ÜA)IN4k •ó‚§»Ž¾ñôÆtG‰Í•|Zù‚tn_t<$dzB3|Xj9ýü "éX°™båºï°�_6éìoZ²Ìr, ƒ€‡¸Vxs á~œ|<:€È9Îçn¢[4xϨ®EI¸°eˆU*î…X5k§&QÐÿ½Y¿ƒI¡»õ X‚A¼m=žýÖÅAñõ~r3°cȯ›$ºš9• ÅíÈ™0â65]­‘ìkŠ¾A'#ð൘¾©LYS*q<Òè(ÞL»þÈyŸEØèøüáÈC¸Æhw¤¯?nÌz¼¸nü÷-¶¶…ѵ|ä3’Ê˪EtOl´!·hЯãjÛ�Óä^>ÜÍÒlÉìÝ~ÁÔŽHèö 1b¬…Œa×KÆ]vħÐþ© ¤¢nS`ŽR§Ü{nâÖ½@.²¢¢ž˜‰Ù¿¿^‹àH›åUó_àõ¯åöÈ2Ê7퓆|ák»CåyO‡Ü毥U”’G U Ñ|PÖ[GDg)Åäoª½8tà™wo)A¬&M‘jˆÁsF¿™¥/ùgwÐÍùúR´豂ìѶ¦¡U_÷ÀZi«ô]ÔÕØ ‘é°šoëHYÐÁ!'(ìe õRŒO ºO³Ë&”/˜7f=e¥ÕË0øñЩÌXPôà‘åh“Ö€e:¹=ì¼GÕb±ÒJڣ쎚“§oOwkÚ6t¡DÌ`©§36˜“ÓЙ%‚„ƒD7~ÿ4q w5©|*Ø ¡~ÿM”ϼh,€Æs䃃­bAçX§Š/Ó\s×f J˜™E“0@fùʇ÷jLòI{`tšŽà05@ò‹,¼¥ñãžÝ1䳓;É©)2ˆ¿Xq.@ë^㪠¼5•`ÿ÷ÿLo²M™é Á‘G‚ÊI¨NëÇŽyië­‚dÁ[ÂΛ;7¸Çc2ì¨Y\o$ØÌH†Ù<(þ¨Fƒ�¥ô›ëûîÂåÕ)dæÕNÜ2ÛœèGÕ4Q’q•7Ù½»¦<™ëQÅ›š£[Ëy=Çó%œ:GvÉ{í7ƒîƒU¬œih¤™¦>`4ê›rƒ q–&Ú>;‘º»zD£ÙÉ—²éZûÁ©¡ ³“ÃÃÈ<3]I"z= ÀP›G£ïp£x•‹¦L´=}û­n[Qúd™;V¨t“Ú k4æ…&(ªÎo2¯Ã&PÉçûOkÞhB•"ÔšL7P„Ö�n°Uù‘.k^9j8@'TôP¥’o5FÀÃo<êÀvÞívYÝÏ  b+Ì£\·½ïÒ×W ÷jX{52o¢Îq–1VÑÀöDÆ'+–n8Iež@5÷<êÕGÓFÓœ¡;%è‚Õ×4…ctªÜcG»l¨]• lm^Õ¸uëy ùFì*õ²qþ`SFµB Œêv¿kh;³¼÷k\Ê4_`O@Ó9±‰fÄå,J‡Nc9¸\ö.ÈÛÎé'¢O›²3ˆSË\×ý‚5ÿ¼ùéž,ãæÒ±q㎃Ò*ˆ¡GÇ!v¶9?Oªö¸ÎˆCK]Ý!_…ž¨2Ηà@;Z…§E¢›IKNy“éí”Êa™˜‡ûH+£ì!ž‰]Ó9±Azo€N‘š®äÝ“÷Âh˜ð&ûÏܶսÊB‚ ×VI¶ ó‚ÞDòËñxè(]þÛ¦ëKéEWI‘™´d«*¡’/¬c"H=Ã@l yN²2-328¹èÚ¦qÆŒÑy×·õuƒä‰Š~’ø-�áéŽJ)©Bö¯|ƒ†ê0'ÌLC‚÷$­‡§¯0îˆ|¼7ÅJc ;[7^‰úÈf;ÎCßýŠöOßòÏ‹'êÃñ“bO¿3ÌßߌàÜÖ°þD›!lÛ-g&Ãø¶>葾(Y,T–JÊA¡ó8ª])‚¿˜ƒ˜Czu�ž—[y÷ž9§X–´ºõôÎmOòSï'ôép‡puÿÂY»8ví'vã¬ùœö½çä!’b¸ÐzJ.Þáä³E^X!“iƒè¶ýôˆÂ~µ&>ƒX3sž°6ºW(„ÉUÛ>‚]*=‡L/)PêŸÓö�?`*„¹ý aËɺ=2Õte*ãáXjŒJÇê¨J½,/Ò]7Aˆ]¥\%ö\Zú,”Áý°Ç•àQV±–°‡`ØÔož6ð–TÍl+û¾ßr¿ÿ=dA‰a‰À3$JÖ“á¹ÁÑÊíi±¥ÙX;P²²©óón¨Kóx!.8_3´�aÃÇêÀÀ< ÒOŸ…||6îÉ(áž–jÑÒÄ×Æœe Ä®5N*áq^7FŸvgZæöÉÇnüèá>|Ó/²ƒD9B@–i!Ým)é÷5³�\‡þqi½ZeÓ†Ù'i5ª¡ƒ ܬ]½úõ 8²½Ëü"çÚ©;Ú+Ukyý×Q÷]»ªûµ9HÏô^‡c7Ü×{žq{]Q'Ì)Ã@r¦öý°ƒ¦˜iá g’“ãñ¤ÈÕÖüHèÊç1 Š“’Ø1L^ïFÁgËI´¦ŸÛ ‚7ÓÁ'šUyœÃÜøèL†Äes‚Ê 46ȃŠ/cÙþ%°Y1è¥hÑd­ãÛ­ÍÐQì ]ÿ{‘ßÖ‡C}M‹ ÖSE¾ÒáC%ÆŽkiï™$à :¿’Í<à"œHæ„®åŽØ);hˆâ)€‘8|ŸQ¤¢˜À˜}Év¯"7!äÖUV´ùŽVþ-]ÚŽZkZ4ôé­wGŸ4‡K¦‡^ä–ÊX ¬ÎOìþ;™åyOq›V|å«R\Òî+ ’ÆêtYrJ4gmÖ/´­b-©4ˆí+ gOºB•äUöˆn= ‹/§ž‘§Î –®Çž"Buš=Êb¬.m3q%¢Ë´ûs1aÿNW+KCOY/Æ‘H÷ÝZÅD|xÑZý>ÈôAÞÒ W6„Ž˜˜ø¡K±QmðÏSÝ×bW¼ŸšEr%7)7úÑ#0ün[!û\ýɨü½® t²ïjí¨~ߤrE”…¦±‚Ý›µ Ä‚Ùc×ovÚÔþvßZÒHfÊ¡fKß¿ëÌu@{œ`,Œ†Eƒþ¾LZ Ú ƒeîKëV2ãWžZ]”#÷Ñ%7_æ/7”éìàÉž˜<­h¢mÆÛ] H]7p~e¾ŽûÅm|J®lÙÚ-…àÓÖ•'asXŒœ¬Fá±´'¦¤[5Px½ûŠ]h2o: ‚‡+Œmh#VÕbù« ÃI´Ð£bÒt̨ 7~\Ó²ýè/ƒG‰•.m•þC–Òa­Fø~i!CûU®¨na{Ø={f+4[JþÏmƒ¬¾8sqÈ!aÆi‘ñÀº}råŠeQGj{?èí£QU ÿì<TôT%c[zžö{Ô;{­½§ œÜR­ŽRõŽj§÷/‹ÊªÙ@öˆ\\oËÁ78t´$£âŽV ìNÂpNçmC â Ð#«Sx80-ÿÞT4JcßN}y7 HFh NÝï4î9Yö³Â§]K‡–IU v ƒêË÷a¢<æ2:õ·ÿ ]«#ói‰úÁämðtá„ÙËe°?§ÔEYr…wù˜ÙUJ±:˜Ô ¶´Ï»îfníöãuX$~€€³ŒRÜÌßšÒiÒv §£/)Õõ»Ñæ€ßcìè‹Ôà/ºŒÑ‰1c)ú«Ó®Àë¥#RcãÞ™ƒ™púÈõo”ÿ{RÃFÏ U–_n?o(ë++ÚN[ u¹m˜Õ{$jwzd©ÏÆE:y¢[8[µ_°–ZžFë‡=1¹Êûéq8C R„AÏû»×›¨Æaq§§ZÏ—¼Dy×æÁö‹>æÖ k¼ª@s¶|t² ›åhç*K# ÎœýƵ£}KQœ-è•!Òt2¸m^ÝmGqx5žzÚ»6?¸Kï\&ÙìÂ,ÀÕéŠlµ¬>»sè ‡™°×4”!·½‹D©3¯-–Aúܬ_bŸ½÷ÖÂü÷Ño=%–03 ®¾Æ¤òý][—¹ysú¸h-ÊœN¬e¬ï†ÖH[¦éÎo\:i…FÑýDIêV7„ŽNXÄ!%“íd~ÞÑ#}CÀhI$£…c˜q<îõ63ÿØM†‰ŽÍ|õ egèq×à× ÌeZo<e]ô2\w›>ÎQèòøXT'ü…¡ñG+ô]óÒTâLΧK_Ÿj‹3ßsysÒ-BC¥ e­KfÃaéd§H–­½tÚøH*ñÝE -³o^°:AÜlŒ’×âbk Êb€èžü‘Ç¥îý&kœ$™GIÇNê@ê´´ËÌT˜†+ö}ÇÎÚŸ”.ÁTÅûìŒJpqÇ¡VQÿáe!»ÉÈ._qïåxàÒQÕº¬kXbúåìÂzq“‘ÿ1X 1T#®ùsŠaO«R¯˜­Åžfã—·GúõÚ‘ŒA u³íö:,z|\¿~L×tí\¡@íØZºUÇNõ±xC÷¶GBÐOþP˜ÂÐî‹ç” Nƒ5Lâ=°šOãì!¸Ð$­Æ,¥C­:|ÁzÇ[jUÛ1ç­S±€tBb{Ã.â­Kk*¨W¦ž}Ò‰{¦!{X²Ê–F©Zaú”¶Ú H°âùq¿fb4s/hf<Ø7ª\S<¶$¦/ÝjçÉÊÛn cÁaaIU$û¶XΫ}âéò›!P ÝÌíO\Ò•d”ì^n™®ÆúÌà óx•Á¥.G/æf @zÖ!q^i 4ÑAàÑ)‚ȯ{X°(Š|q°5`»4œ=Tô†‘µóÖN°5ð™ÍEà2éÐg”µ¬Í…å)ÞnõaÜF´£6ñ égΓ‘±ÿ”«ÃšÓXP”ý²­H:øbe]ýB--à aÐäE“7gjºÚrß‚ißQ¸À ï¡&néiˆ+ñ:§¿_» ŠŠÎuyË·ñ©¯jµlzXùaºpÿ·8‚#ßpüXŬ™ äçp PÆ—Xpl[ôyg$ä¡©¢¬Xð²3]Ïj-[ÆIÔ[*),àÇBh•gçœ0«<¥Mp]¹=œ¹镹flÄˬ€äʾ’Üå¬o³LvK!Fv^–šÜž/â-n‚jÖÕH)kaà„6]jº5-r*ÀÏÎ#ÿþ¸–… XFI_3Ï‚|ê,‰µ°úQ¦ë±ÝÁ­1æu¿qÃfù’£Ã`æL.-°-ÝÊ û) âOß»3aÖ·3ú§©bª-'&‘‡™‘9{×L©:Ò÷úµÒ™“`úZðMÁß²„VÛ×V7Wif.ö:”!ÎåTh ó@yF²½8›¡Õ=ÅJ¼Ü-ŠSé *F—åI%\‘'Ø#XŒ$ÓõÑJóÊ\ÅhXø£j÷Þ9w£þjÝj�SàqèLíVX‡ëq÷W™8‡ãM·Ú³ñ ™"{þCçbaw¯›¡kØNYÎÅuç†hãýacÞd*òéƒö®!|‰“ðôÖ>-^giva`P=¦ïQïz#AâÝÇg¸Ÿ8®E6C çÆAÅá8ôa¦ Úõ›‘*;S×»›Áú K_&;é>=ÔÙØñyb°ÇÎôî.P.J¢Å@Š&Š>Åqãœ™ë ªÇ=?× FÕG@v}æ›Uâ´ˆkÚùóÉÓ•j`ʪ»ÿ±¨GªH•éZ­!<ø^{'ãvÇûq_³ýn [–;,7Ÿî†Ö|b:ó|ë©ÑhTô[ÆðØC»4Rà:ñ¼HtŠ¹ªeâ¬ëÎÓ’‡Ò¾^í¤‰ñWˆ, }ãè”Õ:'duÄ~²’€çz”ûØÔ)¹’A£\¹}Ö÷œhËŒ_½Ú›Ú½šÂ±—ÿýÍž!8ápÅ…ÏB·'Xþew¤�U{W€ÞΛSšçËŒ`Â)à íþ„|Éhy(FÙì„ábkCbk‹ŽI-{D»ü7D‰ÿ‰ÆLa>¼¨ÜÑápì)ø•ëÁëh®i+‹=äŽ5Žéúp[öDWÉ/|I¶,v£gÊúf;µ]LÚ¹¶#x…Ì{ÔhŒ<.&<š-­›Ò5ZŠHMUíÍ-y¬Ãnñ¹Pæó«é‡šÚ-—vEŒÛå®dQ/y ý~Þ¸ðæ¢Ûüµ—’RºÖ€&cF…Ó­7-h‘_±©.ý)U§{@´‹<i .œú]’~òh⌮š<4äMÖ¶b½9[[ʣɺT³v3YF ¸™·‰1hý«¶TZƒ‰79pò½+t#c˜¢ð­å„ü€í‡EL½î”f aºÈ�è.^ Ž8­õÕ}:9}DÆÌC7šý3mO$« ôäz\/èe…AUF{‰ ÊŸY<2ú™Ü|6­(vÎçÝ @ä#(Ç™/GZ*-%ô¦mý¶º �íP4»÷+“%:ô=EuÝ©¼}·¡lÆ`ú›`¨G(Án¿à“H´ÂÄÜ>ä„–ãéäµFW‡a7ÙéôÓ’óŽBY¯Km]©W8’°p*݉'„ŸNá+õ¸ÚšŸën0-µ½ì'÷9Ø#»÷Ž…–ØEuÑPJ$ ,ÃÖkí–ºWšˆÓb®ZZ‡vxHòß1¥öŠ²'òO‹ç?WEŠ<Œ­ô©§ç•…9 ›d¸Å|¤ËWØ{# ¦ûºÅÊ2ß’f]'Ú©óu e>Öµ(ºŒbÕN4Âþ BÊ'B<Í9åAqÒÌWtJkJ¨¬[Çÿ‚øvžy'Ð =]¹ÜòŠY{››¶µm°A œb´wó°9í8ØžLª†H‰Éf‡ ¥Jâ÷½rÛF7‰ ºø¼¬K+ÄZ AÔ9ÔZˆÞã€xÍ7<=›'Ú*¸':¼ÏÛËÜ1�’Ó0q]÷T&¯öYæYy¦<Õè« êô¬8¼­)éw€6-ÃûÈÒʱ%x?dAX+;JÆm@Øâ:ÏOþ¹lVá0âÑ�UúÄÊ4�Ä1uâ'ŸøÂô…1öd½fk̇£~r‚Tíw̹b96>ü©Äí@•‘?ûH-ÍB±µml0µ!UÚèŒ5 ÑA< ®}ò;YR:S2K ,Y[  •ô5û‚!ìÁìd¿÷0n9ùź߅§¢–Yè#Ã�Lš’ z·›;8ÚyO¿Ã*Üb O_› ³«9 ÒNѺtM)†R2?¬lW…þéî©B¾xI#‡wÔvD»«V!©h(~vrL§\ä7vH¿sòhú áf!40ö“$ 7ðž(-}eú›¾ <ýÝs­Ù£I¬bµãï$úëþsN*ûöžáBêÉðq:ÓÔ±5r—®òº6ðkoØNkqESMÿûzšEçpØùôM•ì�eôAf¨¶¦'Ýaðò;ƒ>ÇÕŽ(Ñ­ÂÄRd4Í>»žyiƒ‡8Ge…çOº˜Ã§óÆÃtÝY© KþŽ2úO\„‹»“³Ød«”L$ÛÃÍàjª d©äU¾xÐc9ÃÈÓ.Æ߉2ökÒ‡†Š8 €õ÷ä¼ï×Å–Çž®µ)ÐÚjjTgpݼÌæ4 }~°CqÍ¡«/t52—<Âd»ñÄ$)™½qËá_ݧêE:s Å5>UÉ謹EÉ&;é”]ÇM¶=¸÷³UÊ€*Ç­úV–†ËÄ{ÚÐæ˜'PzÀfb‡*3„âŠýäí³[™ÒÄEÄ ¡·í³ ߌ†6Œâ­¦5¬¦0ÓjKßô­¾0„«³ºèúú!{( œˆw6 2ëÚ\ )Ï´[6تZ4âÀþOMçíôÑ s¯›•ÞŒ±Ä>h¦8µe1“#`Q4qSÅEþ™NÇnüg_ÛtØÆ‚«—¸^¥¶D<Ù sM¶*è\xî]Ò»æ "ït“÷,òê5àãÔ›ßj¬þ$EP¹ ›ºÓ%rwx, 9ÌHp¿Óß\qçÔËϤ(`.Ðo=9@7žþʃi¦›jfe™Ù'Öó˜Ò¾=¹};P÷ Z1,ý1§ñp÷.&ÅBÕp¿œ>›……c‚êV&ˆ¬ç¼Ózv¢¥±ç©Š?ÄZTÕV58ƒ ;kº™½ÿtêk…‰¿ª?å“™AØ4”�ôõžD¸v[ŸíÑ)'s½Z©Û–ÎqI-è¶KTh‘®yhç•íŠêEŸÿcw”qÖÅŸÙE|‡°Ý6N‚¢Q2Ö“˜By&c*‹hÄáþðX ãIóEèRæQæ{{ÀäA:Nž”H1ÓßÖ�G&Ó÷¼z)q“»­Kœ@ùšlôGú®¤Ðóé„f€»½Èdè-„ïp‘´Ù²kTl“PVÙ+ç‡5N©†‹*œÞÓwz’ºZБñ©ÁSÔMÜA•â«bQB&(ûŸ Hú‚òìÿ~<€šº¼ïR÷{Ç1Þ&Á´›ÇÅD± ý‰" sYŸzáqø®Æzð,+¾¦&q¸¼Ï(àÑ »9y,.DÖnaWÌsOD¢ù›—¡Ë§D`̉ RðÖ½8–¦Ë $¤Â_ ûì7Fé¹W5²á<b²hÛI«ŽS#Û»‹<tíql{ gFqíþО<hF÷×?Ó¥µvˆÔ­²Ï¿žFHœÊí°Jd5åçlQ¶`ð†¸ËIããÑ×d¤ÜשðòÚÀ#€ÏÉýáÜŒµ¾|¼¿ŒS7E¥–’Âö⋪Ãé'V‘¯GSp«wHƒâxöZ½ tëYûb§Ú³Ž>V?Åt†Ïk“P‰½çùcrV¢{#„ú ö€àÐ@DO©P8ŸõmaݱcßàÉäݯ<ò<ô•ÄµK‡ìdmâS­NÍA¥Ýpñ|íêqq”äÅBSþ|'4.;Å4fŒl> Ë3D6\‘YEJ•„\PY@©°“sX€o ª­gÕªpó튈eìÙ6{gñ Ë€¬ò%œ#@6+;ï»wl¿nett¦Ç½Þ8ˆ«Â÷§¼ém/K˾Ž#Ú«4Bi·Oî ©9î½ô×@ˆÏƒükò:†tÏêdïLrâ>¤C—WNg7bs¹ŽÞhhÌ´_dŒ œÚÖº¯¾‘Ê.£ÌCš¡¸]H8„⤾߽¹]V®›“fú¯­Ár æc[•¥lÙ³Òk)±‹LÓVA~\;d_0“5áR^­/¯cÕ(vâW³°b@Êw´ª8”Ê@i‡…Z Gér<kk>ûk\.ÇÞãÃÏ’ïë7A¦2:ŽgŽ5Wò™&•W4È1ºXè¦ýÀŸ/ró¬QVüm;úQmZ§ÐÛQØ£¿­§‹‘’¡ï?°FË]ÚYà‡>qiv%…L)id}ï-tK„#.1ëÊ]ï¾Ëž5}¤*…ªq²ñ«÷:h2e™7pkä7&‰fk±¹¸!–¹µÍ6 ‡RRµºÛÅA€8ƳHùÜyòÜlST¹1•[ƒ äk­4²€‘ßx‚bú1ín½¾y ÿS$WÍŒ.£„YuõcƒÛE&Q3åÊncõ1ÜmOeöЉmÌ|fW€µ%¨°ªï:«¼ S¸Çq¶jDÀ\ ‹�aªÐÎãŒî®./e9‘v°>+КI[ ø€æ ÎèŠN7®â^Ò  Ì2ÂŒb×¹jäï²B¶s.ˆ/€Ù­4ªœtt;K[—0^·¿ ¦šÎŠÎrüÊ2ý‘X¦ÙÒçj@·Ì¢Â¸½Ê•©"s¤îò³ß`Pü|ÜÌ÷¡K¥ª ²ºÑ©@ØÚúÏNƒÁLÏ™æë=kÐ…bV¸Â=ggv0�Â~ð´”›C/ÇŸjóùb a„‚.Œgì3ŸÊ7#DUˆ7^[9�X†\†aˆ‘¼·™Ñ±ÙÆ(–žZ¤ë°Y�ŒªÌgãb$t€JòZ+#ŒÓÓ�¥=9IK¢øÍsF繃5ÃÊšašœÖ^kòO=@¦»Å@]npÉÑÒC1×±[Ìái­—Æ)wû•ñðîú†À¢STt€šË›mÐ/^>£ÿÅ–²!ʼ¹Te¡• M8zÎqëûŠÌQÉ…©ÎU<Udï[ÇZœwójëÞÓ|jÓnZ×c‡¥K‰P…9Fq€~^bý8S¤¥ë(n5ý³÷S§Ö¼áØhŒIæÙH©m²a¬ ¶S3H•zS쎰Ý<+Äû6žÀO3mäA¯ñúð%òš½Eè¢xãðuÛ/ðð´ìò,]škœmYd¾µpÌ~tÑa„9c&|Ô`vªü‰G† (œbÒ–Êá{¼/"Â)C,9”‚í©Eú»AŒmݘîhŽvÝA‹z Ïù Åôâ²<  RTò8g•R@xÃiR•R §a6ˆ`5Õ¹ì÷òƒvöD½§,¢eˆrEe·)Ë:mûn< ƒÓ.¦^Ӹݳkm¢(óËãvd´)‹Á ïAOó4 ^<P'²ß;’¥žÐ<y‡Æqè¶õß¾´å29zmæîùš‹óò¾ Ò÷Ö,M´TV•û++Põ2º¿È ò|ežo'0ßl¨ˆ "Y!Û\õõÊe”Ã3•Æœý*˜6÷d%¹êšÎôGâÁ ¿CyÓ&8žfH64^ÉõºÃfá%×Ì›ì{4GÆ‹ç+ù$‹–PàŸ.=}ÕóØ}ññ|õè‰ÿ©ÝÖ ÖÎÒÉÀ±E§¦#­ÝåÅ}7CŽi(¦Æ*ìÇ+žVÏ;kÍþ Y†¨Œâ~Â<‚45ðCFÓ u5:’ ×!Zé{¹Þ߸_ÄyáÔºÙ˜ïðƒðµÎS‘mKsÔ,¬-ŽsÑ|§î¥k÷Õ¤r‰óWé£)š20Ÿ‰R£ MTûxÕš·Ý[nùÅeÐÐö‰Û­—œnK­¿æĺ°É£U¾ýBYpñP+¶e°ˆŸx¤±f¦qƒâ1l|v!‹²aM§ÐÙïQûjSoï‡{¯B(âÄy¢he,5¾DÅÀ>Þ ‰Gº($Eú¼EG`î¼ôhñFë:%„qpÍ%½Ï)M}ñ(–8ÜœèœJí(s:"sb.£r­Í&}êîiÝãH…$}Ò^r):âdÎò†t¦˜…:`úöµ’ë£e²ƒØ$³Æ”u1¨¾=ÀTΞ„zwy«B߶€Š¹žªÈËÚ9<Ct~Õá HaòžÝ`"hqo;¢æhÓU…Ö6Š_Œƒi’yÔEŠ«CTkíõÝh‘2¥—¡YŒ=#ê¢& zÛ¥rO‹¤°ÁÈÂVÔ´ƒ"»“?~J¤·²V¹1:èDô[×&¡ÕxØzVW†ýetÎåÕÕE4âÌ×õ+i©äArnM×6*#6N‹ÙŸýEþÍ" ‹r “Ž<Ÿf–nÚ8H)ñÕ:6 8×Y“ŽoúŸÑòêj’»;Ò%‰¬HËñ€«Ëø/PâÌÿXæŒ#шGŸ+m#o „*•MTïz& ®ŒuçɱӾë†ö;uË4½Òï{f»÷¸€ÁÊ®1¹ÜkÍpí“&?¿6a·ò¤×¸ ¤?Fá½Tc2xXoûî<áðAwtò&[ 'ç¾>ßAþ:Ú½ÊßmO³¿µfM¹²9ØÜô_à§#´©>®CG—¬ìÏnKé3Ô’¥ÇŽJI ÷ D&h„ÞžUé INô:½¢¯l}Q¤‡•,S§ŸbBo)‘ÁTÓ lt:q’^?B‘4h?ªNFçwf¹'éÎIø¦§<)U²b9˜Ú4ë)¥]Ë·!È‘'Ê&Ê —-i;OAËWÚ@r뱧œaêÜÏ;­Ä\smeGZ³µCר vŠøÁ[ÚvÑ"6³‹¢¹t èƒHÖŸؤßí;s:É‹ÞÒtÜŒL$¼³-JÏë™õ¡{Rn­‘“Ùx-×/ËœDE|…Я¥ 0a¡‘éþ=2~äË6–FS “‹?ãñÐNÚÚ>zì]ú5ÎÈAî£ÐèÞµ3Òµµç×a÷=zØ—Z$xÄ+‚B©þ+à7 €öf µÆ晬ýÔq¸¸EI÷:(lç¦Êçw,K>ºÌÈÊŽyÓS¤ãÍ ·øë¨ÚËùÜ|)?v­P=3~p@{M±‡ÁD`Seó×v@àíw¶—Û¨l”Èz.‹^,fŠ˜°Nô]âfkëõ¶Û‹ù9…_•c{—XÊŸ£+ÝÌ›uó"Æ„T¹jsQ´q:cÇ}ÀßA¢l‘²P@ËŽÖ“2Ü×<A˜÷@w…ö*8b;ÑoöžY€…é8Е ˜?MÁþRK¯‹zu×ì6Z—gh]àƒ/Šá«Ê8*\P”þçsõèÆ ÷´µfnt‚œ†‰Õ~ôÉí±‘–™§- Y_ñ`y–ˆaôñLáaá —ïx7‘5H©L&ˆ«]Úþoq•ž‹TPLäxøtµZf¼†ºL¼û€þ–Àå’æhþàúdº¤S mE?žÁeoè©ÎUv…¿lú"¨¾Î@ƒ®²áóöì6ÒœxÁ8‰2ï´ ÚBJíà¡1¼1ûï>éR)¼aQ¤Ò@+(uähzHmÃ*‹ÅÌ”å Ã: ÕÝ|o/¸‘£-ÃNß7æ𻳠æ]#½ ‡òÛº‰ã­K·Õ¦ÚYø2eŸ½:ÊCóÇ´n&;ÓÆåäŸØ˜ºÂ¾¦Ì뮶;Ê®À÷ÀSÉñD-à Qñª;+Ñ6göûjë´«Psl)©âÒ×{ªÏ–,Õ+ÛÍ„mé²ñh*¥„9Ôh=Ô½-½âHrHâÄHC6ìªÁIÐ’§Pû`­§÷ÀÄM‰¡÷Iœ`‡9F1=á3Õ|¯88Ž™§ Noô|†Yæ ·^ºµ˜‹ jfÀ..ã‚pý6Wã$Þwc3e"á‚ÐÁ—!ŠÍo)±]–<j!±áë"ÎQšûVJ0éáé˜MŒzÀ£À’§cWuÉí|,»Ò’šáï×-] –ÁK~ð`‡ðÞ Þ Ì2àtþi.ÿÐåã d„‘Ã(Àû?¼ûKL,S«$¨šk)ÌDgïƒ%¦žWVq¢H…Y"þ,þdݞƔv¹Ð*„$YjE”×¼UÿÔýõÔãY ?Ž=ß’;îH »‹C5]¿?@^7À÷Œ‡ÈÚàåèÙ¤Kâ[Õ¾lš<Œ'º——Wév¥c-ÉéÕÔè)[{8V7íºÕ–k‘Kw è¦&ÅÔ¬Ê'¯XÖÛG­K·.lÈe�&2ã¦)BŸ‡n‰¥C‹½¬¯uÜùžâJ¼Ë¾õæؼl_ 6Ú¯¨`Ød0¤»L!Þ°Oã ·B—ÉåR˜j‹ü½Iárhh‘¯JÖ:bÆo?=rfÓý1xEd›RuéQLºåß²˜‘>66ÍTá§~FíѪۺð+yᩱ~ù¸Ú‰Òõaž!¹ˆKä©šDéCGyÝÔ¦¹Ðí­ç ‡\à².UWy§"–¬<ˆ­ - žñ[yèË'Qôì†oiÀ‘²õL&ƽèü¾ ¼Ñ{º,sàö“.[U@éNtTöh¥yÉ|5P}˜-GÙB&“±`%kk–ù¨¤+îÈ#.‰“|cØ xû,ˆ?UãÛîzM^+Fy¨Ü 0ˆœ[zOùf»*S¬3pÖc–ɱ:XÈŒßöVZŸÓu=çÃì4);F¿Ì”¹Ý£÷úØÕT¸×”Ы£‰v¶¹ÿ—újq´84ag ÊC§_hèBÿÕÅýëÁp?³ûµ—n±ÉÅÂ@* †ÔkÛ¥é ~BHø‡Ã(T|°†ý¹'>}qáòOžÒ­ v}µžÈ£ñ_W ÒvÇy³˜}< K=Ë\6 :ôÀFo*“œ1 ¼¿¼1þ×”ÛŽ ›öñ9„”²öÌ£p�%:î´,ÆŒGj\úÈ–'ª×z*5Õ.”#®/æ#sŸj¿¿àÊc$/mîo+—Øk4 ¨�ØÎÂÅS™R!Ç ÏéìMìÎâ|»L\‡Y(£SMyr[{ štIÿèt-Ëm]ÒôXK§C¢Á>¦ôa«O[~ª¹éê½›ÕÈ äàLBªètÅXE‡ _1'îíTt¦šíÓ`á²ÿ@°9Õp¸ÆìiÙßvLGÁ*«ýЋü“/�“ô5û>† “~×”-¨.t´Õí�R)»¡7úúO‡³þ4u†¼¥X)°ªïçà$ålR(²©ßf„q²ôûË@ýÉèS¾»÷„‚í tJwÆ—# šRŠK³ÙеȳÒ]æ¾Í¼kßΉkd5w5/GŸSKih¹ 3ÒGùPà mOePkSÅñ¸»xWK¿í_ëáÄ…3BV ›^§Ý»šŒó«z\=URN¼y ÞÀæ)ßjü…ðï¸Sí$Õƒú~˜×DqጇÙ^D«b;úV#]ïé<¦Y=æ\ùvî|~Ìؼ¢¦ .PïCû ÓjUO-÷Œ–ÂO-æ Š]~ËøœáÙÄOÿ«0ãÏ­5{Ó‹<óa\CdR=îP$#n R}ÛüukñÂb šý1Lʺ?ûšªZ8‹b2_åFé‚P?쇄È*ô½†]œ,{T«Íaºj(9<ÀµÌ¹Sd6¥ ­¼÷“G• `6åĬ„ªEó<®âlQ÷ì»4È­…$kl3GßP•f´¬yÀŠ0ü¾È XâòÓ‘‡Ò½Èû^z×é-J‘½9¥ j)f+ÿë=R­G.ô>H´õ䞥rA‘ù€tÁäÙ̱™¨XÓ ^W÷wÉ-E±€)–ø‡AåÖ0]^ZÁÞ ¢é.Ü\½üß—Õ(ÂÌço±A5mŒêýäwÐ á1d¿´§öp.°æ‘Š†t|ù±}ŸÍÆK1Óè»ûê™ÙÂ8“g—3ò̤�%àqõ©_¬ŸóíbU)2£ù4fAiùvÐù<Ž‡éØ­f‹ÛØ1¶‘‚ÎYó�tŒÃ=0»°i)ØÇ/¹¶d&Q‚)[÷-ç炳\™që´¡wŒ¬¾}ʦ5½çB§?¬÷ê~9Z¹ûK[jŸÖ^;§A5jŠÐw3(¿œh }ØÝD|ñé.b»yÂë]DNvìäÒ9Èq!E .6Å’t( Yü<ð@[Jäg—÷ÕÏB[ZJënšVþ0Ñ3p´¬wéG¼ù½ñTM:áføv%õè2"þtÃÉT®t´RÈ¡e0yÏt´zÇcqÏcìiC¢G>ì¾ÚàX‰…�:Žë¨~HŠ§;2W‘GýàÕߟèuªï #d³œSk)ôX5^ÀÝ!ɇnpöÙ:‰Ž®wf+ý÷2c")¯XD äÚ­Þ|î‹eýNsÂJ“K†S¿OŒízm)áÃ/°1@§JA¨H•™vò «ŸŸª0­sÆႱ¥…‘¶n£=ð ý?PÀÅÝ[ÎØCîXú’Rì¶Ûò­ 'áÀÛÐv¸ÜkI‹»ÒIú~‡%}Ò,§Tü¯Ib Éa¥Z‘VMÚ›_<“EsÅ—¥ÜÐñš}nì ¥ÓsrW?ÐI˜¤çƒ7a¶U: æ€? ¼‹¾|‚ÃŒ‹Ädü¥áP¬þ0/m2 [w>wŽI2œàSˆsÊ<‘Ô®3–W’FÖÙÝQ'EŠHƒ–£ìxŨ â0ïÁ²Û×›¡>s=›þî}l‰5ÿNô¥>oøAÇÿžÕÌA¶ÔwœFû!J‹Øô@¥ÿ‡)H2èݦ⃯ÁÅW{AO¹Æq„A¹µe@’äËõ•ƒä€¡•Š¤ì°.©UM‹š Ë‹²¡<Bk‘‡”+§b0É-`Xµ%$ÜvÊÚ±¾Ø^ cˆâ,¸íÜ$ÕBl".‡‘ZBT÷·<m2ŽEêý¸²ãc”·!{&f®¨—Ș)û½ðv-¡“ìþ¨Ü¾(0/IŒêˆ8Ò©’¬FpEYü•ÞqS˜Ñi”§OûÉ<ùUïduï Lo`-ÌÏ[ìå¨ÎéÏž­ù±žæÓ( Sª‰EϪ¯%#A”ÅG<åè Ð̃Ì•#$)5m0nïb’ù*¿aœš*HkKÜ-U“×$[>h+€Ó×Biñ¡Ý¡Š@„ À<zw øC}½:0„ˆ&“´µ±¶Oî ñÊÐoÉ‚;1Pâ<nl«<a{Sèuêv¡XÐëÇÛq)I/9jGOøFð8Nôª‹ŒŒDø$®l¹:BÁƒˆ+Þ×}ê8¾>QL> "f6Ž`Q܇a”ÙÂ/¼2lYÛóŒSÃ}ô [ö[Ҭ׺1<ýœ¨nWoT`ë¿o±ÖVÛÝÆÉt^é{w­ùF·'®7ç*¤22ˆÕò: ``Ž=S<›,åãEÀ¼ŠýÙ¦ Æ-¤ôtßæÆîcÅ0 Æ?”¥A ôêQÎßz°ªë1Yy»Ð´TÚ¶hhMø?Ç—î•LUþ;ÒúG¬âŒfdÓ»«ü¦Ý~oÝØ^‚…Uiy<lÞ6ÎÛge“ï_L›£ÿä g¢ˆ%ã¡ÕÖ30d¿ÌÕi²®×iŠº+ÂÆЦ¼ä}öœÆæËtè~Ä<KW¾±êÂ4 ’R%É­–nÉõ´ëeÄbžÜð59ÇŒÐe©‚°S¨ìûé¸ÃZdú ­ñæÒËý¢†]ì´ˆŒ=çž®Àñ¯k'FÆXT®¬ŠG‹#‚ÊšB@g cépØxŒñ�Uo§@ä0²m^¿÷U'–1?Ž ß ]dÔháÍkOx‡àiHÑè£Z˜œÿ  ‡r7P?ÈE\BÓ*Ç/5é¹rC³4xA‚½€©HÃ…V }ã!¡;][/3¼‘ë±C©Ñç›Ü á9ÍsPH¤4ñ}†ÄkSU£_\p‰ÓõçÀ& 5:9.%¿Baƒ¬ð@qŽYZm/ÈvÒÀÝiüÍcƒšpôt>ŒôšéÚ1$¸z¸vXÈ*WDr ë ã�¤A<IDg=Ënè¨h©Âî’™1²)ºìI[·2fw±"ϦTCUg;w7 –Q¬~²Fò²¢Š½½=‰¡«ŒC‚¶¯ä™«úÌ×`<m(èËÏ«2.^úy²Ãœ”l-Þæ®ÝÖŒ'[!tT¢ÀÆcņ/lÕø6\¿oÆÇq‘Z †¯PžPªb§™èÚ7´5=·Ø3*Ž—ÝŠÒç‰Ýe‡Î'ùxà”»=eïêñ‚!%œ…göÓIÎB£æùË{”jVqÁÎe{¥Ì=¦•ÎG¸‰M¯Ø_?3Ä®ŒÑD¤üŠÝÇϵÕc ænœ÷Ò.›M®Ò W¸d¡¿B7 ÛÞCRöÃ&ëjÜ÷ó¡[…~ÇŒ[ýyŸÖÆÊ7*S˜¶8ªöcÉ€— Â|ážMɸõìÖ|3?HZÄœúï?ûäV6õaHÀÏ”YŸ_Ë…‡&[ú“Pxbý—Ù"›Oƒ `²é¢ÜPv„´á‘v$EV‡vÇ"k[¤w¯‘OL‹Ñº!³aå¥]£úytu#è3ÒJéôÞͳÄvSïc„bÊð�¤Hï|01H±+‚È"Xô>ht޶쳲e£7Ø–;á#ñN|h d[u’™Âûš2ûtPƒ™ßÞªšKïïUI–(ò«Úwÿ«.³÷ñÏ5·iÌÑ÷ºÚŸgÆC<¯ÒÏVÍžOÃ_ð‹ºÛoÿßÛö²ÙuhÖo;'˜ø½Vä�Š• »MÙ7ßʨ¡Úþ€a  A*»Ínz윥WÕòñ@ÇOØ-dæ´Rþûi¯4eu¸4/(èo §)°OÃFÙJ´›©7m‹#¥‚PV²ì´}Ñ  çÃHÙGÁEœf‹Ö4Ò8H;=Uµ=ô´J¤6kwˆùÇ#­#7âÉå( %îIåb€qh)žß¸Œ=ƒºEÿ)#ßÓž3‡ŠrSu≠_Èø@Sò*Þ=¡•b@Ž=ï©-² ìj[²¢µJ¸¤ÂqxƒPn©Åþ À>YÓÚ2Íï)ûˆ¹Ö ÷8¦þå½GîêûËD«¨w`’¢¡±©A”yˆ¸2ÌÛV*1 I‚jœ­ù­s#ÓÁ®7Sak’�G½»S¨(Lƒ<5 « ïÖ—(/–”˜ó³Ü=®ç8Ž­cžšÃ峧L¤iôny#\+ð ƒ+Î ‡BB5¶ Ú4|ûç šxŒ!;ë46l<a~ûV#‚G°›°eÞ€ñn9YE0c¥jì€è.ɨˉåØßyÏîÐvãë=l(,ÏVî-Y0æ90ÑAS;yÓ‡nPqe6xa´8zª¶Nm;†0›ã–¨•Um‘Tó8Òµ±,“‚që¾Ç a°¸gÝ«sñÆIêóôbØ¢–AY_¼aRð¿f+±.ydGg :ÌÿOÛ¿-§®,ëÂèµæSøní1Æ t–.[,AÃôXïÿ;¿ÌʪŒ[Ÿûõ7d÷90HUYyøN�~Ù˜©×Ý|Qÿ½0àË£É]GÙèé½ð¤BÒÍLT—sþ}}—ãa1êo½ûUn‚)íVJ×R=A;“CL :QE†ùÝr!º8Šß¶DP-âB&8÷V%Oò…#«fhÚfŠ^‚¸£ž,fö èSÉwñ“<öhèPùˆ¯öŒÝ´p¾˜Ë)M¨ìVBJVKqèVþEËÛ¹ÿ¡!›‰ ¡º¡gáM3Qc‘íl`"}wmSµV±E€@‡YóÅ':z˜4€{9ºÛ}÷¬t¬x§ù#*±W±týö»oR+óÈdËE†‚hعp$ÔÇÃÙÇ´-[+ò c3þÒ9/ÉÌdì_.£¬ùRr\^:œ&.Õb’'SðÏÿüÃþ:¿€ÊTfÆÎÔŠÓ„Öÿ ÈW1©¤5%}y§;zÞylª½zÙ`Lå%9g´|Öê„íÉ¡dT‘ןÄI971¸`9÷ð£z$'`—0C°Å ËÀ™ÞµøìŒÛì0aЮ�ýÃ~—ó÷§Å3¸¦‰�„é‘K4\šbý—Ñ°L–…FKªŸ8…ÔG‘C³ÚêªFÀV]µî±S\Dº¼†vÁ=‰ŽE\ Ù3‡i^åÐZ‡¢Þú¾ÄôJjs‹ʈ*ð|2S0'øÄÇzm®~úP“¾œyaSÈý˜ádl+§²û¿ÓŒ‰Ó!8(u¤Gu/âHñè^PÿUmŽº¶Æ„OŒ(îõÀ¨rVj¢½é š—#{V aVT‚‰P쳺´të^m¬BäåVÖ×¾½ÑYIƒœœœÎm}ÏežEÍ Ù-)h~*ç>Ê*Ú†M':Ù<_*8󢆯ïÊÊw3‘//¤n´‹†“^´´ÚýÝç.óY›·pPí?A‘d‹]vRó× dÞ™™Ý¶™c3n”l‘âN>)î/cfs­[qêÞÐa´mnÚ ëÿù—8n´ÅÚ+GÞ(gãMßµdÅÍ•d•}hç?=BRTYz  -|•,òâÑo+4 m»%Ý ’Ìi¶°9+jÇý¥réù:•“Dttf7‚å<|i•˜+þ+5SeáO o³ZArÒùuétüW+[ÇHÑO÷ú¤H:dKk!„+ób15"1† qôv¶ÁŒÖ”ÁW¶-ºf·+q‘[÷˜ žQöîq@ öAßwÝo3TôôÙ FH¶”�û{¯)Žöt¶ÜÈHè8-æt:š6ô–ïe8ö‡ÓEžËArË°`4±%KxÃy¡/‘ÒÝž©¤5×¼«ÉOÉgƾĨ€Y½}‹]÷²€õÄ,…ŒG÷þ}0`fð³€yQOÕe¬šæ§—pþÑfmì؈U°0ã„4pÞ÷×}h¦Üs“‹½tM⺀—¦Œâ¯¥™¥aR&Å¿'åh*ûWp/ø¼¹Í )ß¹4´ªí4½¶Ss{öc8Ÿ&¡Wù«}ã0žð‘&« ©3Žú4Šã1À:#$—ºÐ?ã%†ãwu8=ÒÉŠ$Ÿ%ãÇ.-¢¢×Rt C4ÛVb)+¾Ÿg ΣÀÿ÷¦7ø¸’F&Ú·*ëªYàôd0¢Ê¥ÕRN.¾Ýh´û¡×iË�©*ýÝÞ´ªà\!Uøj›YL4$[XÒ8·nJ¾GªPôÅÜ™ØᤉɃ«%äKµ§ßµÅE¢<Ig¥âŸ%{2¸ÖŽÆ´¤›Ÿ{T {lPi`"Ћ0ŒÚÂ0Ðw)4Ä¡6AÓ™ 98£z~[;ž™G1â0µœ‘"ôû+ç67\ªhLnpš×È#ˆÝYOèœjîͼ¨L¨¬`Ýá p‰vts6xgÐ$Vãn:îT†õ"=ª ×Åë9{ô´]8²,Ñú”ºË€�〠`§¿[[hpøküÁoTÒ_òð„ eêÏOSèš!eÅØfBrá1šÀ‘gçW³Ü ŽÁ;ò¨l.FKú·B¸}Ž'¼È2q"jqåŒÃ– ö¡ÈÆLЉˆ¸óï}³“<dÿ >he}ýãÎ/ü{þ˜Ê0+›g?=3~‹ó|n#€§Py̤]¿ƒŽ‰ü¡ãyÜ õù“ˆ­·[ðž—ETzßÏË]ßyÊz4àNx©>¢²Yµ!¥Ïàøíþ8äE` þÔÈ2+…OÛ¹�Åhó™/[¤^Ù«BžöèÆñúúLðÕûÕTn}¶ôÁ7Co“wÜïÐâ}O8îýä uCåBDBBr ê ü–žÎkBdqð!(\Ëí ☎Š¢¥}µaó'ñ8ó:úÁ÷(×M&¤~ ö´ßT&}æj‹s0‘ ÖÄʚРQùñÓgUÃÕØ›âÿvïuE@ùé«oÆðôäŠÜH )‚jTönÄØ\CØ×í zÏ"¤¼úÐWgcx« `tU»\°MÒA46¤ÑH‹ð…ü؈‹Ó8·ð”wIrÖņ¤è0M!þYR¥ FÏØw%^Y”/¯*¿swÛñ ž‹à½¾Ü=ôë4ŸSÜ–íì²Ûª£ &þûîä„°:„šÝ !ý]_<¤Ñ•.bg¤¶Q!3¸R`*\KaMÿÖpÓ¦ƒÎÂ|äˆça qíÄA�™H–^…BTôæ'¥¦Ëõ‹h‰¬È jŸ{Š+G/ø›GªB沚Ã^Hؽ𒬜ћÑp„“î¹ Ê™xóxØì:æ 2x…Ö–Õä#Î2Š?¾«!À±©SïÉÎ;¬ßU<p'è9t,ØjÅÛ1ÃPŒç R†°¡�¡Á|ÿr¶£*mæÄ|úH£j|×ÅèÕ í_¥P¿.x—¨¸I;Í”-Ւ夹˜µ\&`íI3 ®8Hæüå{X7MV™ÿ}Ю«–~ª GÐQ4Ê©¤?ê<8÷{L…vÜù`5¯§?a~"óü.kС•.‘¶­ „ƒè0±-Õ¥ùê;Pž¤}–££¶AŸI äç™’%ÄI™4³™'þlIöËcBË)ï5Ë!ÊHkSîœÖ¿˜;—¦OÏxÃ+p ‰{Ü1|‚)¢«Iu­Ï½)w^?^­È§8>Ã¥9;Oúß;�Ú&ëÞPD›¦vËÓÒ9¶j¶ñèg8 çfIA¡ºË¢ÄëOäs÷´v¡ò‰¬oßœzœ‘!hòï§[_Ñ$œi¤ìwª€Á�j jÉÇä‹üÜ"™y¡'`Ø/¢¼¹„ã>!½µÂ&_!ÖDZÁê3S � Eá“ @êÉÉYîÙwn¿œ ú]E€¸ÈR«5 x¦lCˆÎ–0åh|BñB§âÛÚpÜYþYfÝéÀ™¡c%[{qʲqÒ,f¥§_òYí0<bdÜà¶F¬c%Itè¶2¢šywL™”Ý;IÖñ!³â¶ç\Ó2NB埣Î7”[5Þú]nzw*`ô«Ð³fCWÕXíäÖ¹~ó£s: H! oYÅ_ZÐBü{ <¡ß´)øït‚ËMBs“t|õ Cç-ÌUƒ{.£ôÝzhQ2R™•µ‚ÊÜ¿ÒŠM=,~ÆÛsÅÇ«I38/>Þ¿T7ª7Á#Dí‚ñ#xï0ç=P-é.0õ‡_µM›^fŽÄ™±d+r*Ÿ’Qî˜P0tÚ†)Ã8ƒ¹óv:÷S'»÷E~Me”µ™ç·j@SÑrØžÆB»Aí¢W‡MýÝ +ÕM'æ|øÜ‘Òs¿ÜkA•Cä¶ëu Ò ÃKDg’ú:wHBV‹r%G½A¹ f郜½#=ØOñ¿k=72÷y‡Ž|Ö=8(ŒÈ ¨Uë«’ŸQ%6pZEã o„…*4Lo_¯—! +µ¨f¹s­¯t ¶_75Ñ~çÊ-¨U@èiÂó+d¡µO¤ðÿ*qeðÁÊkÁ8IÜ¿ódH³Ž=EÈŽ²©QP™¬þŠ’ôÍîcwŸ\öƒº¼áí™ê–â]úÀõÑæ…+~¥Ñ’Zì¦�ï+Zþ½ö¶�´…†”£(¸97§Ãñi'SÈ +›,ØZÁ¨U6=C·L:•é惘ßþ®åhñœš¨x¯À7ÙÏ52¯Ø‡Þ‹˜õñî4÷‡hŽ¬ž™³£D‚0BþÕ?f€^ý/mW\Dû3T¢õ ¬ƒÂf i¬š¶uc) þJ_¨*+_[çlA‘EÙF-èH:x¾qéäUR[“5]û«2xn‘_þÐùû¹ ×YQFOTpЪ9z¾ó®äsˆÂÛx0ø¦taœè1¾ü oô¹U¿Û``£Q$Å›{Ÿ;õæORëê^ÇÎ~á´F©³Ý˜.p~XS«—™Ï<ûøyaò.6gVW<…|Û ð¶“ÙÙw£Ü#õûãÚ_6¹«:meÌ·ˆZ¨.uV^38ú~*ZmwŽðbÑ+hÑ|³¹IfRÛò/•0xõá© ¿E3ÕFñ3C/OÁ´Ìñ é–âý•H+ý8Ú%ù7]Ñl\¯ÆÌá„;y2TøŠc7¬:í'pöé5€qu3ÉÝ3—N©Î7D!‘A$ ÚÌ�Úuþ¿SÙ£:'àùÈ vŠ(‹ÓÖ}/Ê6ûÒ®Ój †“ßè*•G5â^([êùÍâ ú*õ­Áᾈ›gá.\ÇþRÐY«ê’"LD{;ÆUÒ¶;Ò l§7J¶ç(œÎè �!|\»Ý_¡ÛÞs2œ*X:'7$qÉÄõ\åÎÔU”Žk'WšTìD9ÄÞøc^Ýÿ2¿­)¼SÆpô-ý4ãFß=ÛçùlZù¬¥@ ?-8dÄÞy;[†íê�…«? Ê>¬Ã¤û^ƒ°ïI7zqmCˆB¶Ïˆt'Ux§¥s=stcõxž šÔÔ¥Úµ.Q¬x¥¦‰©WÄEe³'†ŸÐ1q:ÏØôôÌŲeºåóþLïµ™§ûÝ*é/\Ìúï›%­õ‹ÿç-.K/¤„s^ ^éŽóÊú˜&Ž"³ð°þxãù¬NÆñ—´˜8©­Ñ0IÚfé§6Íé˜[}¸LÚ¥ý/Ñÿÿ #uw¤?hûðœ,œ4X{fmÐ4¸ÓþÜö \¤š\F}ô—ëØi+à»Ö^>ëy'¥èŽ Z=1Ír©3ŒßviŠ*Ø!$¬~ ¬Ù¸Õ$Ë)òÀßúæY̓Œ»•Ü†ë=*ºJƒX‹›;Ð}¢C� /´äÒÌ¢òèƘÁ”±W÷àA>Ný&œHßyU¸NªÒˆ]¨&†×Ÿ÷ò¥róÒ€äë•H/;L¿Á¤’ÂÜ�®íNŸt«½ß8ä¤è¸ÆÒö ðçÕU.ð0²®åmç°¬¬.#­A./VËÀ9uÞ‰JµN“"·âƒ‰x=ÃÁ/0R¡Ò0“ì«|æt ^(êÎ6¬+ë Ã{ªí9‹wöË?õ\ŠØâãéÆ­ÖY×£çuÒ±qi.Á™­ÑïM‡ÁжÍÛê [\LoïýŠ}»r#PCGËá+­U¹ê,§ÿFê \;ȪZpýëOHº˜iÁ¥rʶgƒµÞ7W[â<=cKsã*º/ ΚeÈSÿìqwMÈÛ1•ËK소©u€³ZbÃÊ(9M!p| Í‘'ÙÅN¡ÍEOsy7kó:È‹óx{9et—=%›+ô�}ÇèÚœ\ÕÅ㊟<³Â’¦ÀzØäQ±ôFãˆ{×1ÜÞVߦŲéZÆ°ÜaKÆÆìží¹VË<ª<‡;GNãy>IzÁ\<÷A„Ð%[Ò“ÌÛÉ`Cçòa”5ûÎö3ѶŸ¬©­;j #üŠ‚)ƒ0*x^«ª c/­E™Å]›QŠŠ›Cˆ¥ü/‘æh¨¡Ø(N[g`×ƨ¿©/ª|¦wY/P‘¿<¤?6v�*ȧíaäœR_ol¸’ÅÌxO¸¤zÜRiLn¯”GýÎjaeàÅ%ð(y”5©Ù1>póþ³¸÷;wL÷¥°Ê<â 1Ñ?I mEŒ;­ X,Ø¿À2 ¯­¸ WŽm l KA²¹Ü+¸8·øJ±îXLïFN&úŸ‰H!›ÝýÚ¶#fi2÷Óy(WÁ¥éëZº)PU(n&Œ´ÍÕ·Æs–ÝšŸµì¬£1–V¸«Ì#[6¢FŸêøÓè‘öDY„žXL'2½Ûû²iì[½Ðt¹Ó~É«™LxRDã†êšV«:ÚàÝŸNׇ;êÈqº÷­KÄOG\UÝäŒÍE.ñŸ(ûÔžOµð‚ºEÜï•TZçF/=õ#U;©0èDO2w7ëØ  hÑ™ç¹Éª¡¢ Ý«½œ»¡-kzÏ£>`˜¯}°rµë×שy(X“&4ýk¨b×ìê´eJ hh=‚e";î”s¶ÉòÓCÛä´2Jj(“ ³O‹ªW6!ÈGåðͨøP€vËÁ2€*å‰ýÅ1ý±zû©õ ˆS±]¼*”ŒÏ¨~wœ<òjÛ\[ ~ö�­L9”°¶0`ÞÉ ýÌÕÅáÜ5’Æè}òhï'¨ïD\9y.tLµ%”ÔðZ9Í…òÆQ¨Wš’C¢KMž*3©-èÑwVe<Óy¡{2n {ü'ôÒ¹Õ€éÅ¢Ìn"þÓ¸:γÜ‘(ÍF9:za N>€d²”ðËÅÒJãQ2 ʳ^[‰ÙYõÔ‘øÞÈÎ~S®œ>ÝtbBëJLÔ™ÜÆ…ʱ¡J²¹xÛX×üz|êN“K"À;YºÎOìJø5£Ë¾¦ìÄQ _Ð¥³ò¤)öÏúZEIÓ«õ »mì.3é÷ÌþÞ´ö#ˆØ7û7þ¯¨ï°FËÄj‹Ðwh{ºqE7¥ lÊDt¸2‚›>Æ@á²=cFqó“m2§î¼]n©HO>¿ 7h56» k»Æä[ß�¶¢íåð(râ~Ëè½î-c¢èáqP´º³x ѵhèQ”g.ÓÜùä!£Íº×1ý`wî›}Æ–²Y#Îþ g…eÐMë½ e0?÷:!»gÐРèµ5Æò¢*Ï×?o(ÐdßvhÂÍ\|Ì]8ÜmC ¿Øú !+„Ð'ò¼²®ÿC7gœ_Ý·ÇYnÕEŽä ˆÊfëG)oÿ}£ÂÕ5*×㎰‚÷²¦üŠÝNôÕ8QðÊ%~®XîhPyÝn§‘»d÷çza†¬-:y˜°@ÝoþÛwÿÕRKWd\9Sdâ €`‡ÅŸk#PDîœÃãÞÒœ¾Vê”iáb×s  þy‡ÅA6%.€SWDéà;“«Ïâóî›á5~d='BéS4–áÒ9;Ç—f4°àR Û!I·£jüùáÌhÁ‚óÍŽráÛI2Ÿ;»w²ãøcMd‡e¹ç`Çâ /ØyÝÕÊí©§;t Já”7)ÀS‘©˜ä½vŠ‰MæG;xõ'Ê¥�:)Dùyupjãþâ6+Ó“/ìX¯7fNyj¨®çvj† \8x^éêRsy£š¶(g‹/–´ŒëåÖ(,yhU eì \=Póʸ~¬¬ †uÕü-þ9µrA¥ sŽSýœ\fqn¼ýè]‡‘þ)·ªƒÌcìLgŸžþ s¦¾Šj(âÜvk UŸGÅY …Žä=%å3ÉÀ ²ŒÒùš"ÑYzÉ¢ÌK‹Y(qåAp7RæÏ®·Yâg›Òq;1ûàó¤é;ü,Tã´iª2Â^Ïåç_eÅ©^íŽôW·“B€!ÐØ{Éh�LÐuRÒG7ñðŒþWßüÇ SoªX;¾ÿ‰ñl:†`UHxzxÕ$ú?835Ö½:থ‘e¹EBp|¡x˜O_rö—lδv®¿45lË߈üxlzá2–M=^žÌÇ>…�.[ÕÞ¶Í$”ŒW•Sg4ªÖ–u•Þ$’ÛMÛî4'®Q9ÒbÀ.¾Í€’8tÈØÇ:f‹öb(Д]H§vr¨òÌ’8³ôV [§5%xU£SÌ°<¤©<‡VírúHë ã<$+=·QÌž·GÚ\-c—£®`¤Í§QãÌdî\½1kð»«D’,î´!?W‰ê];“3À>:§œ½júÁš$„«˜ânj½¤“Ô1qê?…e¸Þox`zTü5×·â˜üIg9@ÊO?Kç.ÏÖscN[™§|»˜ ±t:Œ’Þ4¦!ç49M†;NìKÍ+]>þÞÁwTx,Ńªg®c“£ñ7õ×AÕž[+ùʃç6‹š­Aq†kÆ冲5\ãG#j-ò™Ú{Ñ2ôýò=…®/ÌçHH¯ÚJ½Áá¿…DÕÛ;—›—iÁzOê˜,#ýt^s‡1à™¿ðéötu]Ûô9}o»–Þ‘`DL>I[Â\Þ!ËÅéLƒâàGï"‘ݯß@i`_˜‰ínjh·¤íxaýä©ÔkÊÍƘÛÍ’÷–è‚”<±p©3§üÁ›Ò#Ò¤‘E½ûŠ¡X l¶?¢õë¦ü 8Ù™ÃÀ_Âqû0×ÒéVVÎØ`Ð̨ZÕî~ÆÜ…³$ùìñE?ôÐû>e¥T,¾t ì*J›Æà¡-ŸÃ\z)ÓºÌó g‹q2õêýËH%N â³éG¾‹©~Þ7Ì3²,UMJ1æ¤ p b}ÀQE5_!¬Áœ,·ÈRzŠ=GôµJ“P”Ø\ÒÖÃ2€Ü:ìY|úm%°Ó#[>œ¶Ïv¬lwŽºõò‡¾ƒŸþÅá`Øt õ‰›ã;Ÿþt›sûI‰ºþ ´»–W™™åÉ6\@AYFÔŠ¾ÿÊ_|Ÿ$EN5~1f~^°É©kEdÂ]—$øJ>Wÿ\XÁK::/kh¹µfLÝž?XÅ?Mz éïÞÕíÀ£Î‚úšøj (X&£Ì%€#˜ŒùÄÊãr_Ó¬pøå2E;…íqëê"᢫$ÄxõM°®á$C_pæ¨MçÓÉYSàNŽVãRJ/Jz»ï½ß~$çN†æU˜ù'[¼lé\-ÏÿE‚K7ôL[ª’`U!¹Ô©‘s7Sbêf­ÕÂýv½†|ÙI£NZÌ9¢œƒE,R•”2øiÞ„ r¸™ãÊãc/ÆÉ(ÊâãžÇÎñ™$èÕž,Œ~[ÌÑ¡‘ðc0èÏžv‚€p€.qV_wθ˜»ÛWQSª>xÕ˜”-PNïÌù#™4ˆå3� ÜùeÅK¦�ÔÒIJäUª_òkÉ=äÚû„tj6A m3²Îª±„º’P[þ ü<:¹ÃÃâ?i”wïvÁPæh ï¿÷cõªÏÜÑEbeºájœÛ�Ôj°‘ô€ÝŠ Ÿ48Ò¨‹UÄI¾F‚.ÅÖ"|ô©DzÜU9ëfìðao_íÛƪ¶Ä».„­¼JiV¸ÆN—& Íåo¸ÅÂbžiq^ê(ž´}µÂ"tÍ‚\‹f×6R„ýjäš–_MKkOuýùlü?ÁÎi< ùoä±u­Rn [Õz5³Š3YkbÍF>ßNÞ$™æôígw¾åÆô•-ÔVĬFn—sæ™Áõs~½Ñ®W»néþ‡ß¬} ëÙV¢’hzŠ¨Ç6Ad:åK!¢•†ª }í£o‚×i2FCOE” ZÝ„0îŽGýÀ¿¶­õøíÄ )M­Ýâ],%£‡M𯺔Æõ½‡NÓð\¹éÊÁ%o®DzFÚdØòßôMb?>]ëh *Þ{ñ)½9q³R™ÖI`¹ã¼gbS®˜ 4žY5$oTmUàyM)¥ T¶¬ÅÆS(èÊЪæ³û9æ( hkÇíZ.cã-@Û¬V£ Ÿb€Ùq¸zÃÄþ­¥µ×=úmÜbÅi æUÛ  !…Å�ÃÆöœ¦ 8ŽŒõ¯ßõå€'5õV{Þ{¾ö‚åÁÚÖ/n,:¹p©ÅO/ èXï+4-;mÀÇ2³~ç=ÏÙiâ2ø×ãáB™ˆü‹èžÍÚ`Ð7ÎFìmU3<•>à¿:Ö ¬:ʶ½qN¿ ð}ƒî ¡^[�ã‡úí”23óOþú=ÀbÕ±1Ç]–¸@Ê/Á»Ìàœ…�Û¡ŽÒ®7-¶?ç~Õ Â¡h΂ѧ-,Ð#su'ld‰m–. 3„þ§Ë¶ 7•°C›7Ë ú‚E<×øSïié¦ëcÚzüÓ¿9{š»r™Þê”F±Ç¿Š­-zxÂç*Õ9Ð-;±ùÕ^ê‘SÌÚ<”#±úgíÅ­ ô’¨ …?Ц÷JµÏÕ?c”¡v­@¦å¨xšzCÄüµNCª7ðxÆ^>°ÒójúNp®j`5xåé\íÞ…î¾=,9ÊY˜ø팹 Ù˜û¥í¶ŽÊéêÜ0ô¥ý¸ Å®,€ê`‡ƒ‘­äžÂbʆ®›ëÃUEc9oRʈ1¢WÓÒ ´<¸k5oøYéÂy›M§**ÚA›Ë…3E4ád¹kÛsdÂçG°Œ3h «ÔÉ­¿…¼Ì%6)®NÐí:ïp ùªˆ‚/ÕØì'†!ž(´A¡UcávîU¼ŽœW*ç‘,”Ž¯Ó‹&äI’ä–¹ˆö@z·ïÁÒ@ëëªD¯±iÝì¿Ç<Y–xÅîY-½ñüc §Kmï÷7‡à'àË"·ŒOœ^[Z×™·1�®à­|ûm¨pqçX,Ò……Í%¹�YÒN»÷G‰>Ùì+(Y­é0Kš[ D€{(SÎFí9þ¡UL±D:àÿy‹)¶ Ž"qú"ÍUô?!šÖ*ãé¢i“³cšW2qQñì{…´àOhíyw<´|gŒð[z¸‘"IgfÙ¶ÆÌÏK&´þˆ½Œåì]cž¸Õ½Jal|H;䉲âj5up€ºçB…µ* í¹G[üóf*éR+§ŠfûS…„86.7ÌÔÇ9˜x\3O»e¡½çääË°|†…gVšGùû”)›i‹Ó[Émiur¢ýýb¾pýÀ,šbé@À÷:ï¨%·j¦ò Y«2÷Š2].«¨ìe•&̳ÜïúŽ-ä˜ÊáÜ;zÆcE`ý V/.7žq“BÍêä&óÝ°é¥ßi«Ç<‰öôîœàJVåáÔ·¯ ¯ñ&fÜ(NÁúÚ:tsòÄOBþìÎTí¼¨è.Ö•C&\xaÇ@ñ‘±¾>ô,ª™€,|Á>ÒÊ«ÀxÌS‚né^¯É)W·ayèèáõ z;À8gÐÖFJ;Zã¶×ÿ¦âL‘{¥´˜û®Ã&I£¢ÓÔÈœ‡ X²ß{’"ïÏÓ;¶t@ºå…ßu"çÀ÷DKfug霷{%þaœJcG­tÎÛ¿vàΪ›?ÖwS‚â B Õ</–~÷¢©êô'ÞÛÉBé@,ž0G°6þ0’|é5gV?ê($^Í¿t˜è%�¨ñûÒ´AŽ]ïÔËCw_~–nÎ2aÎ’®µ‘Œø¬·äÝ:õ—2s»ß²³CýŒA–øårÆkÏ+)™V*Ûc/_õA)Òpÿk–¯Ë({× Òˆ¼TøçîwËc8Kåó­:MŒÝÐÓ5…îñØw<FꙤczU8¦Ëø¨÷S1ÄKƒ±ÊÙ +ÄìNã iýrkÓŸïÂ0J#/&ÃÑûN_öÈvŠš c© áó]Ë4K*[æAmëZG‹³ö.+Þ³{©6Ž] — ¤GçQê÷¥‘Ër¶=æ¥åãÕà´XîÅ­X€/“ÓJeúP¾\Òþ?«îjܱ‡ ŽKàé£ÙoDT»¹PÉ�|YÏ8&Ètöòfd´LÙ®ûåã}c bÜu´]ÞÜä<:R5̾Ÿ+Jð2–½3°É  …×â’§¤§³û:À=à OÁ� òåyÚß-ä÷Û¨¡Šr!\i©±‡oÙž"Ïz­:Äðbzd{^íº¿-ÊöÄê ÅÑ¥aãÊgro}˜ð#Žn½˜¡¸|Ò労<Ú)×ÛzÙõŒt«ýð- #sññ|àØSÌ ôæŠAyâ–¤‚±x¢<Ú÷^Ja~ vÓ�1�mE@ÌÎ[òüi"ð`BP¦7¦~Ó!OiÃÒ¾¹r(È«ƒdÂ-Ä)á?Ÿ6YÅu­Ö•8£ÂàÙsoú™\é¯î_´[ÿB·gÓ7Eßîÿ‡o¨ž%â"Ê·£Ff¹kÊ_é”Ë÷ÕÇp–>^Q|O²ÍÚä }ó)ªA›³~pž$ÞÑS¨x¹ߧ� P]NÏp ¶gÈ8ä8±æ'÷ŠqG˜— ã«?iIg”6á' ñÙX‚GkS@ãñ‹¸ÝüNs3ø€Ç�D`~Ö¡eÃf ±ãÒÂ*tÇ nŸáÛˆ@<•ç-Ÿâ'%v?R*÷ê…Ò€†3ÇQï‡ël<Ñâœ÷5U;b†tž1g©s‹Ì6^è}6ç<62>Iœ5U9ÞùÒý‹;Ÿ…Öe;i¨Ø96Q5jVU¢Ý(„¸½åÞ×^äI‘ê6ŒD€¦?݆BƒŸÝé¤|˜'6"*néšµfk€Œ¿×ü¬Cwì•¡ZºË¢š°[;½ßùË k0á4ýhÉn²TA <wa«…võkÒtÑú0Ýìâ–èY,«Lþ.½ÓUxR ýÕ-¬F?¡òíäÛכ̦ša`kÈ�±Æ·zJv‚§?¸¼zè�öÄdÏç‰çô«ÔÎr�<áSuëcQ¢¢ÿµdyˆ%ˆÙ®­ÿøÒôáT½ÕÇ jµÉÇA>/FúhEA!ÇòÌÑ‹>ø௠Êålóüœ(™©:ïk—6‘ØûxÜ€ÌÿÆYÁC˜R—4!VeÛµï±æM¤âmw&Ÿ$«9Șö~ ÷³ÁÎó¦ænâý0z‹Ù�G|N) %ŸJ“0­Ó*ß–ãu#žz"iºS§ÉÍ X\,‡Æï#w€úÿ?yX² ‚c¥Ã—>TAT• ßª“@v§5ä_yk~*ž ™9-F/>ó‚‘ÂŽ~YöJPº ?~ŠD.rËrA²§°Ü]ê¯K†Þú~ý¯¹üãJ¹v•ze~ZV]|¡4ÙcžTøpµ…äø ÀþTð66Rv ×»¸è äÇŒšÖñ(2àýÆ‹ô€Z[Gª¾Û£òy[:”LðPì•“GyêöƒÒ;ÿ k::¯Z%0¡Ã˜™“w'ûkåå<·=èE-³4*–ª[ɇX³ë¡lAä®32Û£Æb–-ìj¡�½9g”Ï`ò‰Ö£Pn8_»Òa)¹Û”#ÈÅTÕYTvkãøFAyFšmÖ×ÕÜŒã„LÒªW�¨©¦<A“„nÃÔág(æ0‘¤,!>Zl:›#4:$&¿ePø¶=#…géÄëÄ=:hß… —NÊ$ú8A¾ÙKƒÍ4uЦ ž4Å‘4©¬2%”Ñ÷`•ö£;]àS⎻í{ù­ÿ“´BŽ·…K=|TIœÿv°ä"ÈžÕ÷òºi’Ï<†˜"›Gõç1Ð�1AïãHåäUŒ€U}hù“¤™ÿàb†bHßCbi…¡—³kßËs³ÄÙ:vì)qû:.g>€%e€º¼s§7±l†‰ë8 r7Ÿ,íWºÄéâËxúÌ¢üýˈ9NƒêF›ÝFCzq«m—(¬³à 4Õ¿|â_kº‘žXN'·ŠPÚë%xà ˆï @ƹQ¼¢ø‚Üâ¨ÒK)rÌæëàœºÚ] ?$÷òù+®«:o‡&⣖¨%û1÷-(ÃÚô€tÁÈLkÇw¼#³î>K÷@ˆ­‡éù $|~Ó³uüΖ{FÌàŽâÔÑ'¯M*œ’À2‚ªxƒ-:Ý"û»Ra¶·P¨Ë†’¥jºÚª¤?xºéír·ÙП¸€Óÿ!ñ, ÷žOÖéJqÁËVÓêù<CÁ gxò£åA2ßG¥YǬʲʌ)etó¹W=¯Û@·æòæe'ü/Pb'Œ‚8AçÌà·Àj|¯Ú•b C>¶´²zíB¡ªÐûâT¶Ìk;¡ù¬é‰»‘ƒ¹DØP¯˜ÔÑg—PóIú¥™°ÃÃð †_@âì;÷ïwÑY…Ö%±S½üûqð¦Ê€g4„>-ôrú‰b ;.ÌÜb׌=GvÓìÆþ€˜Ë°†hOÔyÿƒœ¦3 ÷kf!j÷Û³±gï˜�î’n”î%"<0äUžx:~ͶJpÝ趮Ýì;°zO¶†¦P þÒ$ŸpÄÿS”yVzGM cîøÈʬßþûF4(of\6&¦åÁ­Ÿx yžäFk!ÂIJ �ªËvwê8¸iÞ~OFí± ZnÄØÈcIKõõOÀ°?œ[§ßó<²'i©HJzßÏÁ£½Å•QqtŸÌ]Ëغ÷rŽO{PiR»-ž†$ʼ7Râr ‡ù¡¬bÏ‘èŦtlPs‚.Y ã)‘88÷…E¿è¡º<(Þ”J4& º+6XSÄl1L‘U"(g(âPñžìն݄¥ø› A’Y oŠ§Û¶0 Ì,ëhAÓIA\»Fá †…ë!}eå8"wÄò[ùä„”o‘»½¢ì¸^â*r«ý‚jk {Ôõ&cY]Çßd«¬ìe7d¶GÝWJ‡Ïúª)@É”²ÃÇúézŽ6(‹ êz 7ƒ±ÜÏ5$U™TUŸ.Ò{¢)|R¯ÇbÔ²_¹ö yÍi©2ð2>Y‰eThï m]²oÎå~�_zM+Áq¡(˜(¬.uè_W‘ae„nÂ_°³Ë:c‰é@Gcº/ÌMš™Xj~ï- ž=–[àð*áךɒוäȇêáã[0Ãneìéøñ#/øÈpKýbÜ1`ØÛ­LóC 8KopÈ’R½}Ï©C)rÓ;|˜Kúç¨e9ݲ2¥ý<ÜHßüÙ ;}èBõÎíõûåja0½O‰Ë©3ÕÎLŒé÷òO‡fR¹äÝ‹¢³ßÓy Vôø.¹Fè_z>•U%øˆØ±€ú®ŽÊV™_ïÍG7ù“m‘¨<˜eÁ°ô:ms4ÏK¢üª™9-õ}WEõ»¶+`’{ú[د"˜ ëi5†Ýw<½s/‹�Ù–/¤èA,/ÑÓ6�4*L®27·¯†3+ö{¦LXŽ@È/Ö¹QÛgóéd>^™Yný éù8%à/‡4½SNNgEÞ{ÝIÑw</áŒhdΠÖå7XÃeRGŻѩë±<_¹ï…HÿZ^T˜T…õä¶ç<ʯƒ‘Σ;ÙPƒ§éܑ縅%dJ—ñð?ÕÁPQ°ÿÈ�øš'“¶e¤Û‹·–K¯¿½b¼CçdâU‘¡¢5_Õ„:( ¿¢NœzÆ#ÿ{Ïü')CL¨„Hw?õùPÁþ]=ÑÆž§Õ‡+—³%uè<°ïÔ�ÈEµ~OpAª×ÔÏG'â^±šg∔-oÀGNG«@ü~¦ «S.õ¤’¡3É F‚a3ÜéÙ‹à¨ÊàÒáwi²(9z¦Â† p°¿ñÄ/à¯î^‚[²°ºç”&Œ[zó¥*v)ø»Õɇ°dá#V¥µBwžl?x³9¥e³Ðº·<oT=¶<ÁgcZ«±¹0ÛäæõV©'(Æ eKé4YPìê•Ô]#5u<ÓŠ¹‡q?}ìh—‰jM�KÍpSU<Ë}˜%ªÀ&‰Eý8èN“yÈliÜæQAg¶ªHÐ8ë–…dWð�TÊeߌ`ˆ÷}À0ø6XòDÌ\Á!Újé$q…Ot&ªÀšÝÀX6ãû‚{¬·øÂX ’‘OU±)“ªÉK>З´ç@ƒ$÷­´,©¬¾”QºÙ:-,´ýÛ®ovÓÕÅ°ar(GwñGíµé9ëÕè8CÒg].1u`/Ñ l çÎm•˜Eˆæ¡¯{½AÙU–yL–ª_*Iß¿‚Mg Ÿ;ëó¯_%‰y¡«�©DïZ¦´¡Ð £ÌÃuæk*8š5h]oÚ·ÒôR1¾±¾~#Ö’Îf$KC"F€ä9œº`Ü<üÁ!^,7Dpz”ñû»×¤€/à¥Ð 8Ê‹s¦v!¹0´òV§é@£H‚=YbÉ…}V;΂}`.Y×£ØíßÒ¥Z7œ„³)gÌg‹cäÝC/b4‘@óè—;ëIÒSz´µ ¬ Zßå]r;Yek€$n÷Ñ·Sԉϭ…:¤_wþÓü e´Fó‡ ´Ý†þHÓ#@‚r+(”l¸œôÝñˆ@ã :t*C‘,Ü”+/ÂÊžÓeuQ-1Qÿö‹®÷Þ$43a‘<Ÿ®y´ðœa0T¸qìä³G™8þ¢‡íÐâ>Â1É£þ!”dj”è¸Îù°‘vîOù+ cÏf÷Š–# H^7C|a8¦4¨oä#ËH–iÐ\ëÈ ßÕV%©0³Y5ã7†âC!Ÿl8,¦@T•-/|Öõ»üÏßÞEéCBÎ5ìÞË7ËHFÏ@%r¢»‘œßUú\Œ/żRól%1èð¿ÓùØÿÝ7®û4ÿÍO8•®2Òâ’³š€Ûu´áþÎÈU)Ÿn$¹i«.ò`+gøtïJ»õÞu auýÐœýóxE7?†ètH ÍÜfITÂXg`\ÐbÑØN‡M$wwåªØÿ©ƒ®.ñÂpc§ ênmŠh —Žæru�§Ke®õ°Î³±+\-cø½j+6QN4Ën§0-Qäò³Þ.˱ÑïÔÔqèYãfÔÑj ?É^³2h>SÈtƒ‚#ÕoIðŽYŽ×Þ«s«>âûE„'ÜlÜ ºE¹ÇÖ¦nv<£*ò‘ô£ŸCüçd*MùmÞ³¯9Cf®^VöAr÷J¢—˜îu%† 9;Wè+Ÿ¸Õ¦$ “,žcïâ¢cLö;öôê“b¤’7®¬Üý¹Îl˜Ð¥ñ¾Ât ؉å4Rvòþͱš­q¹Æ¥¬ÒÄø4žÇ‚ð3x®º}Ĺ3_]z‚ÿX§ißX•tTáŠÎίhQ\™ÿä¸Ë~#w<ÓÞq %´Pšú‹»S àQíÑÿ³‡<‡¡™ý×ÌmsGžXý%Ç—Po.ÎéÛá\¾éx?ôŽ³ÂÍ­¤+€Â’Žl ¡ÌeYè|Û\ÁýœNHRr:p“pøa•ª<0*‰ÿR¬JaËÊf5’j['Z)^Ûc.¸Ce¬ ¡1óÊOtº8Z FH@ßîyŒ§C_t@7¯>ÖØ{æN휭Ys/rÁ²’(ô\YtcÉzל5›)¨³vV¥Ç¥Awnaœ �ˆ»ò÷s%|jãƒlQª“Šq‹[7ý‡"Q ½ì¥gVÓ4ê2ªÚ“gûã°éFßb¤[~8äFw`tÐÒ|úÒ£üæ^¯ÖT^Ÿ®ÅN¯›NxUË”Ød‹Ò‚ܭ׿%{¤ Ûƒ�ÓoJ¢jTÈ‚/‘¶`0T!BTµ‹/r¬ ýW¬†¦SÁ71 ó¥¢;²ò7é‹g?¢¡’XîÖLX‰'æÜ‹GAw2Yá‚;’sõ¬oZZõŒÅžrt»ŽS[ZäóqÇð+íxÜíß–‹ÔXBSðÙ~ÑŽx_`íNÍÙ8±¡˜pÁTâÍŸ"³ŸM=“2³.¬‡)ÜÕQÒ F~’>-O ^\nÍfܹ.ÙðWͳ$Iª“µY |étjV×W X}ŽZ8Íãéq§á¬Ùm‹ãhâîúÞ@I1“z¢£ª,))6bÃÌ~ßRl¬?ivȾñZ9§f/ƒï·¶ÊŒ yå{yáÜc`Ø8ó'P¯? ·I`•FÙò×ÁBmÅßo¬qÖ휞h¹\Æ„ª·*N´G¶pàÊÕ’N°F逰Ë\ÑqØÐéŒ#é †–q–yq{):_`¦œZ»å!”4І“pg–ôz—e¹ÉýÀ¯bO2oŠ3)†…Wà-ðÌpÜ£DUquCÕKï\’±d˜:á£[YÉŒ¸Áéñåx#·‘Ç{¸Æ §‚»9çQíY0J>4ÓòÀÕÉ›+3¢?Ï�Cí«ðÜå@æK5ì–W}·ÐáÝ:w&7_ÚsÂA‘Îÿ‡‚vE<ÓöHjV;ÌGù(!¹7µ}Eð0X›'n1 @ã;“ívý^>´<#}:€ŽŒ²9\ÜäãuÀk\ì¿ðK¨£Míë<d ¢¥Ã©AÓM×Õ¡£â0œ®G8]¿ìË“Y�GÙxšéRsË飡ìùxüÏ[ *¤³é/s Ã„Ýf³sòüþ®Og˜žåd¸Ð.x˜ ‹¯ß¹­/î£é9ËÅÓíòøÊ$ÓHa?}ÐNJÞ¿Œ·\3ö: wm"ø«êœhßpåŒ:žä¶7%JŸ·}¥ÉJõRÖ¸Òý/ÌáŽØ†‘lÂIÕ7ç/…œ)¸ý<ú/‹[’_ )¬”5K<vü££ú•—¿CíüF–Çîd&Ì>‹hñy1Ìä¶sæ‘Oåóšö’•gçØwÊÔºÊ=ÏɵÈ`×k%ìùc£žå/4Æü²¨ ‹çe¥Íµôl¯t¬Ï_îXy†NÔ�0÷Û:ê)¢U“Œr°~Zzo¡Yܾ~k¹,*Ç]::`3?›ÎÄGJløt»tnÿ}@½‘[D}SGå°6G-Õ ¼¼Â,ý)}‘Gë¡x…Ÿ¤ ݾ\$è©}MfÆøLÍÌ<ªä§Ëo“Œ…>¾å¶0˜ÿÕ>œä¢‹H•UãâEnþc°As¡¼ÈB|t­Þa�½\"xt5UÏK.�”)3»3C%_†õS‰0[ IIÍúæâÛµb®çÁJø|MÌ3),(€‚ ’! K6CáQ‡nÙ*áN{, gÏô"pcX‰m{­ÿKÁéPvìv{•Ë,—-g;Î~í;¬�±"¨ƒÀìwŸs Ý °±ŠÊ­6§ “y ¡2Ò×[ŒDVäVÅn]Ö€ ¾û1L$1ys¼ãm3ñiMÑ'ÝÕ·4Ží9DK ¡-ó%^-Ú‚}£C¹gÍaÓ”}MŸ{ØÐg-ŽK{²‡±½—W±]…i¢&,B1ÕQvÒzBD,I(Ç&ï5]‹³~†::wõéC §ƒ-üI'æLNêV[qþæ†fç#w·9 ‚øE†Ùê-:T·Ý®|a»þ´)ZPg¼Z}pÕS«3þÊƠסãÙfúÂ8ØiJ5ŽvH¡³¤sÝ3 Tk‚Ý~RpЛ²õnYºßÏb©6`Î~Ê¢ÚÛ "¹<™Ó6ùvÁ·M›5ÆqUþ€n�"OÂŒtæÍ?½x³;AIƒ …â ²t¾rŠÃÏåÖÕ5Ï[,ÐVÊhñÞã,gz‹çÐŽ‡ã=:¸XwÜå Æ~z‚é8÷F† Ì|5rÙ~ù“ºÚ«3,“ÃÒ®Ôó_¡Îr©&º”bÖqíV7¤oè/ tÞC/8-äK7­9ü`S&¬y<R>œM‚ƒ´ÀKw¿�.Œ‹ îf;þy”Žš4–B%8™9Êÿ9è1W…µx·S)»=Â`·S‚D.[^b cj)aÝq¤ý èßÏ ×Èí(òýÚ@òOHýä«t_Û Í^<TºôA‘ PØ5&÷®nÉÏ®Ÿ‚Ø7ǘpq#JiE}3N­L|¶z×E›¥C/þ|<2Ä¢ëXñÎ1@gXŸ¦7 7J×÷å[“…¹3÷j©«ûqv&Û‘ûc¡âW0žY>K½ÑÖ„daé½Åöšé#»%OÇ2‡Ó_àÒda“0%)Òæ­òZ1£zäÜ#‡ hª»÷-ÖÑ] š>ånëòÜùäU«Ð‡¡oÍ‚÷BÑ£‘vb}3f—áËíÒHÖÁìÕETžò­;îì<3 MoÙÃËžÞo{qšu[â–A@*­Y8qäô÷G)ô4Keë¢Àd6ëê´¿T7±!­:¸‘(âõÇY®óòÒÁu†® X<)Œ¶4>µ‚kk[_¡C‹*2§õÇoeGå9û2ZíkúèvXË·Æç§ßpй0#ˆç‹#¥Ü]¸$QÒœ¼ßå’è ò'˜Hì%mN²¥ gð[‰öœÏ çÒµîJµCf/zÙ{ü2Ðʘ–¡CLOú Cqg‰HäžòZçM*R†Æîqb<¹Í75”µ#ÇçUȪ{©z/éys†ÎÉáÍ+ð‰‡ P÷’EÉ´ñÐG*v2D‰ýt¡M,Hæ ôït{V‚'e&ßtíO߸y¤©)JãñŒä}šEå×»R�!Åpð9f qËÖžù/´â{a¶á 0Üô;[46! s¾—5Z• ÕÁÞ Ö5¿Ü*¦ë1¤®L=v9欀ޕ²Ëi2ÂTR yD‹[5þâñ›'iœWn'U2㡈X~zºKmÒ®éµ]©³ÎYï¼¹)&…²+~ú=çO‹OBÕz. c"ƽƒ`» ãàCN¡ApDî÷ˆ-ŠøI /*±¥o’¨^ªÖ—‘�ûiAp.˜Šâ¡Ý^ù„ÞÝsñéB›�gDÞy»µÄ7´›÷óá~‡âdY»*J½ÛêIþËÊæ|"o—×…oÞ±ZÔ0ÒɼUIÇ™X´»øJîèÕC“î¸*c[7×Ñv³_Hì•{– XWtkýÎg?H†ã‡+Y3,qY…—ÓÇ+¢¤5àä㸠XŠk'†uÇ¥tðÞØiñVoFN‚/ÖšþJý®ºCÐm:ç[Fïð–òs�Ö.»îá~‰³ Y[›îö°që­n(í§œÕ¹þ…F¬@LûOÒð4—wL¢ûsë?N+cÌôÇòÂÙ¹ù±;N‡='r¬"~kÉ!û¿%‰ÎùfúÖ²ÓÑ›fÂ>÷ÛçóùO|€tyf†E¬¬µbnãzJP`ø >žß@zÉ þtžPÅœw ÁX6WACòvûÏc¾…Ò0ùlróÖîä?K±—ýé«ËB38•õà’T®%f±rÑ\•‡»'XQÍÎäû´ŽŠi4QspŒŒLj‘FD‘_¢•„F+7-¤?MŸ?½x†ˆ Ý™C^à¼-j¤‡ ÌK×ØÓtç7F>®B¾Í}ÐvH3F}%~ J‹Ùá™ÝóþûfL¶°u÷éït?DápÚõ«” þÒÃ4öÒªs$Íùºv¹~QhŠÐEÝßYŸ�[û>5œÖT›l\vg1Ë ^ Ÿ}t}Š««^}›pÆÿSN^5ˆì¬ý}6|1)Xš+jÞv?u@Š’÷G½žRêUEõWã¾D"Êd,ydé|¿É¸žøbÄÿ“(?ê ž¨^(™I ã抙¹ã›X{ôG½C:ñýÃz¼Õ¤MöÃêÜŸ';0'ÈÚÑ·]͵°?2ä^¥¢¦¼i¸»ëÓ @ /œª²ýGF‰÷V…¨n€F³ÚB'ÛïY œ«ìÊÝe\.n,ôp §­7 ËåníèÏ0rÀO1³xý ŽƒæŠ`0iNC˜®A eÛPj⦀ÏYH¹™§•ìrú§Žr¬OÏ°†g: ’«þµË³7 7½YÑ \|*Å„ÅIô¶Ó—]žêDéAsSò™9Xâ;ˆœQ}Ò}Q*Äxê[úîK¹þõŽimž‡W΄ô…g‰"XÐá×äH™ÐAu™ï™ÄÆ&©tgé ^Ƹ„™àÒò,ˆ§f¤,@¨“”xH6@7B ö!HŒònÊB›0[nÌ1ô~ØÞÚkPZÿ’!˜ÎT”@UÎêO•ï‘ÉûVÉÏ­“r‘ RÖ¯¡£¹ÓSM‰1?¸%`9ŒD*) –B¿en[â9{º´WÚL#¯Õwl}ìZZ–ÞEöJ;Ôµ&¾g›YiíÅãÚiåzÊZð–oËŽr~=ýV+—ªL Ñ€JüR9x³*±¢¶tãéüè¿­Ø;Á}dίc3º¦ :p2äâÇEãÔqߣƒUf@¾§³¥<½ø.0?o§N'ºåh-¢ÈÚÐó¿'ÙWÔaÁ¼‹C7ékp¶¤÷èic}G<ANæúoâ^îç åLlëw“lá}c<ûµ…—†>¬È|MTð$—­Ugû‘9Ø’ïˆB ¦w®¾ëjff¬Ê©î�-å¸mÃXõ46릧jÓ$èÂG4Cª<0À™Dþ@—Ê"c­Ø¸Q)Ö,Å žë7‘¥ ¡6I�çÉúSáX¯œë=®ö#ê—†Œu<ìM 5vwP5£PV]Úe®:?§0Q¸fÑã ¥líû\º/¦”guÚ­4Üxê°€ÁÖDž[LØ¢Ö—*ÎåÕq²‰SŒž®£Êy,£Ùwo”¼\Ì&ðøØu”5šJÑ‚hzo¿§ŽêŸ—0äÚ xóvÖTKNó댮âÖ8Ì\{¿¡»ßMc®é»$J×þ�…u7Ÿv^Ñ«§Ü»¢*«²º¶àu-aèõp$¿£÷¥² ”Ë `?£ýdç‚IV»F»ŒpO ¿åK+Œ=mqP‹Ó 1•­÷mNÚVJî9·È…È&΢„o.Ëx"l±0}ZŽâ-‹èÉob ttËÇß)õ1ª q(YôI£Úp;Ì(¸´pÝ <Ä35X7U)ýA¢·Œ YŸ½ŸÆBUœ ‹&+|®É1½$²Å{ê~¾/âçÕ\xÔÝd¬ÛþEu‘§&ñO‘øó 8 €ZÏöᣤ3þM’ÄõeUnñ8ƒõóè˔ҡÝÞ6¾ƒºnÔìzø4ÅC©Ó¤å¿[.o}ù (`à´ÁÈm0Â{n³Ø’7¢”æÁsrH¢qkÁ8ãpð¬Þµ­Š’ÜBï´t=ddYhˆpCÿz âxÓ%Jÿrªµåö;÷¡º~yuÿ~o¬fª¡”sQ¯¾#嬶>Ž~¶ÿ7¦#YeÚ 6'ØRz^zÅçÜy=só@gñ¬‚Wô XWZt§ ̬^5ËŠtL·|£Âh‡q¹›Þ.t×l[ëâ #ÎÆC¤12e½sêÅqËœÿÕŸ2ª|Þ‹¦`‹:OÆ~²L?ോؾ<Χ""@Óµòoœa¹£rü*ìî Ò®T´ôô!Ý­cÐ0÷=ïWòßKãعýX¯[­ËEÄs5|ÎŒF~r©skG€ Ά¢áe(ó9чŠ}adóÒ` µ :®e´hF5ѹE’ÒÜÅŠsñƒÂÐ+ÐÜ �@xÝ ¨˜Q|¤ä}½£¶Ÿ›Ž<m®cÏÁ­ÚÏõ)!e~9m/°”åá€VÝÍ:q6¾+¦ô}“Œõí§Yƒ´L¤èUN~´7. +YI‡É¾+£ø¨H)Ð>NÖ Þƒ<Û¥¶Âh³Æ#<ãj'æÉr›fƒTqò¦÷áî{Äqv?«Ïö]\ò•ø®k8$r'À±é‚;æGʹ.,íÀaŒ±M6aò°›Æ„§hê×­L¶»³MO÷ô?´­QzŒfÖŽÞ#`ÁuåŠ27Ž#”†÷=0Ã×s€îpåÙÀõfÜž[”itqí1­^R]¬1Ûü`€è~g 45hgˆsÍÒx ¾Zö‚©®6]ÛKKy[Ía¬bO=­¶údñâІe4­ÆæÈnŠFzðÉsËl·’! ÒZ êÔ½?›Á´äp²êRÈ„,@*à×ö3B+-ìAJÑbwL!x5JkG¨á4{ƒ>‡&Öÿ}ëÚ=2¾ï¿ ?à.EXÅWHõÂ4ãs¶½žÒ"ŠÇOÁ•žŸëf};î%:Hý_ÙþøjÒ¯ˆMOéó݈ SöºfðFDîî¥?½!ÏãFŠ5;/ѳ76ó€ûÈ8¬oÚ¿Ô1ŒÓbVMXB® ÜT¸Žz”äHÜbq…YkÒ-¼40i=_tz‘UQ0“ph Ýþ(:=M¥ Í ‹ÇÓ‹¸L) yÄ=‚õ•2æõR‘üô¤¥ìLâÐ3ÃÌ}”=$^ÂPéÍò‰û|s-°À /©áñ@9ζ7”ÌݯɯÊØ’n›?Í0ÏÎRÓGC5‹¦,JÛÎ`¡à9cœÔó¯^·ã¨ ¨IÌà)…©ÕŠpžªHŒULˉ©ö­ç?=tQ½7RÈÅ‘±]ƒBN„ÕÎý•¿wd }ôÂ5üÇ nE ]ËÈ1øD¶ãïRâ$±Š±2›>OA‹Å›ù!;sšnð{YM1{þ.2Î+À©pÁ<Q‰F(Æþq^2Xö«\°YtÅíÒ0B@u¾Þom *Ïú,ô·+ú}—GY£€[x¶n›«÷/yÞϱ«§\ã࿬KÊ3½”Ä`Á íh­\¤hV’§„ÿð”Áb[¬´{øB‚È~6¶ßV[œ;‚Ñ‚ ‡<²–Ì þÉÔ¤šWԌˠ£È›†úñO…«›qŸ¢ÇQà?˸e¥eÒP…½ÚS®³Õ#(Ï„,.îjzò¤q$}C'!ŒµIšj žHÁ3µ¤Õ¹6ãÕ(Îì¦Ã🷠؃Õõ8žµ•÷p²Fá:ž¾Ô; tªÑPÑŠVÜywú…=$sùrCµ£U¾9S�úR¨YÎð‘OÛ=Î÷öw0K\£gè–¶¼pîŒW<)ù÷±qƒ ‹TáöÄìÍä›./wN;믭˜ÊÅ ç{õ‡ŽÇÔwvò$Šô©ïš½ëMÇæöGWƒsiMBÖ%$Cf(§ËÑC ‡`ì|o:C…—wøÛ¿¡)'ÞOP:ˆèÔ”VNÆ:¬ßíw§®õÍÃÙ’sædf³X>zºÀ_{yõüÆaô¾Só*IY¼ÆQÉnÌ÷NT'KdÄ€Q <¹lÁ«í"³GWË|à5dbCe(걸·¶MÁUt$äI<O’€8DKÚŽyTµF¢a‡ÌJ"™|ù‹9õQg<¶jƒìÏB¹<=Ù± c¾õnt* 4†I"™$ñËÆqÀ ¾É«ü=ýØï*rœ¹}è!ð¤•9¬/\Ö-U^e<\_/Bq^…+EAyCû!óDD¿3"'»TŠÑ®[㯴å÷í†üÈþT'¥Cuq ÍòÓ ûókc˜b1oë¢Išå´ ×8†*r©³FJ¸�é]Ò9ÍYäsÜK`àx/¬R4ZŧµœlÂ!r3È!П¸\WJ¶î1ªâÅL+8匸Žæ`�•‡;½˜ljin¥<ãÝS‚Ô!¤4R¤…ã5  ÷N°J/"ô» ¬láX±úCõÔvmbƒqN¿À_Ô!– @¹ï ºÇ'¯AZg®Bò† üÁM/•M¸’í$@Éyãá{Â%1«a6 nyÁ¥9KGuz{†´xÛ ðà1Í"ö:&VËĸŽò£¯¨�Zt'5ºÎ[Y*ó?'NòB5xÐEBä„Žõ±niqMJMܳ0‡!ŠAZ‡ÝÉ©BI5– Uf{Š¨ý:J, DÊŠk'M½ÙYòÄ–Äã-'c5}$Q9´M‰y}÷v²º4¿Ï)ê8¤¶Iƒ»cÂ4ŠP^\g¡!]ÜZöª\džQ<ªž!€ú[9 o�’¹ z™è]ÁÍw1’]<ÏÃÉ¥'®?ªk¾øC¹WGxÿ&sUƒŒ![|’Ÿ¯›òœ õ$Ý=üdÍ„çë=.ëi‚gs…ÁçÚŒñÀ£é›É2�ØŸÏÕAL¡)ÊÓÖÍ·WÓ@86ã¦3ZöpNã4îaSÍÑ¥ÃÖ¤#ÞÃÞªœ£ù¨Zn/&çá<g_œç-äß#u<#k®úæ*8õûó¡ÖYÚ�±ìäëÝb0OM{:vÐâRèís#‹j­G ¹¡º¿‚~âflLç4¾X‚î!ÆŠzÌ×jh uLFÿù(+?Zr¿xõ¬¯™0w¸Í2²3¬<à/6ùó"8XÔâF9XÖžýN¯ÔŒ›Ã´[º¹-ûí+0a|ƒÒ2:]2æIJ™e òŸñ¤]"Ïò¯A+üŠÕL#Ér­p«móO× N¾s»x¾—M?ñxgàá(ýŽ™Tß’£ÌÙ²VŽÒ>í)\žŒ*eñ£'MN%‹ CÂóùdòGiA’V–‰»à2¯ˆ2ß{Ã, !rl½\þvÇãPÆŸ(‡¦o<6<¸Ç¯À¼¹-ôª27ô ô[+ •pÙÞ«è•TÂß7ïã]쬲áÐQXSTHšÆîâfø<Óš5zz"óyûªŸWB)^ÍUGí®%N›ÁaòpÕ–D¸ÃTñDBéÛ%”Ð?߶úØ sï©\=M±¤hñqC ð±ÚÉN'Ƽ]´£º¾ùÚõѰ:éŸ+šÙ÷íøÓÂÐ=Î<j¯)Ýlí–”e°0Ó.!àzJÊÛϬí^îBî[­ð5Š‹žLèì=†#ºQSo»a³S:†hô7XB_Õ=çO´LSH/¢ºóäÜUÞœ‡‹ Rð¶ 3K¶žXòhÑjÁ ;¤mwZÚƒ§Ý‘;g´ö½¾Y¸ô4/<R»–Åt­¢´W¬î1m?Þ9N¸#ú¢ÇÛÓ]F&ŧê£\ 6œH.=†MÕk½ã�ÛÀpZÙ¿©‹ÿ•å„Îû»îªn _''™”ªLœÎ,Ó€wümþ�GÅ ­&JIÞÛP;£ >¶áLþEW©®gˆÿJ<oêviT`™T¾>MNsö5Ï›"¹>S .ŠhqÑ­&.ËSÿžj‘dœËâû*—'Cáå^’ÔŸ|fSÎ&?à‰ýR›y†¦ƒ|¤?a=ÞY’R‹#a(Åž-ÕX�ô¡•]®@4=S *BwŽ'{r Š¡ëÿˆï’$:+æ¬þPb›MðAd†Sû!ÖyCy¡ü{Ûòô+Ef]@AStÛ¬U$*Í~·zcˆ3ïŽÒTa<BǧÏ7v“?¡¡c'¸&V-âÈTÒÚש´‘þ9„“q/|‘§ ³NÃ)n8PVË>{¯àÑ ÆeãkÕŒz½³™«k u¨äÙŽETM*Út|"ž$÷ÝA)æʬ3da7“ö„H9(±ZVTï.Ý Aî(#ÿnºõáÜ;é]ª:;^©·è™Œ*¶ÀO†Å÷‰víÆEìʽîFÈ®J¢#þÜ<Vt]H©*K5ŽU”Tí"D®3Ýê¯,ŠZ‚º‹<´�ð ¸dáœû¶_)íö> \PP2“MÛXۦ߭›¯§bر5èeã†q_#ßØSfzÏ‚ 5âœã/~R×sQ¹añö\óipÏ”äuû¤ ô`º#iðä?…®‚o)©‘µ­!G5=œšu ýÔ¸ƒÙˆ³…ÅÎÇŒQ§µþ®ô D2{ ü²ë—\Lþ«î·péF²ÓEèu®ž*u„üNÅ9¥¯Ó½]üXÍ%6-¥”OÜMábž|±Þ°N¸ ¶Áox ~ý z¸4â†,ù²=ÂÏak íªS Åã=•tÛÎ9xû¹mèÀ9ï¿‹HÕ̱’•‘)’ŸÖ¡._6tÏG§Sõ+Ž0+0…›˜c–t<TQµTÈU’x WfÒ»?Çüˆ&I²˜ÎQÉ\ˆ•-ó~þQÜX  8DìüúVÚï?¹ÖV&öð*Ÿ&€8;5`UÚfPǦˆ½pNÜ…ÏŒ“™:ÝøÍ9¦”òSÑÖxj.¥dó%|ö ‰˜3 ÜNw§¶™±0&L“éìÒ¡½ø«ˆ p&?tÜV½ð˜œBê=}W_'NªÎ±gÇlÉ6+•Æ”ÃÿèÜ17ñ¨r«‡º£ÒlÓ»DCâjfgè^äÙÖXèoûf3ÐË­õãÍ^æfæj$<ýã=:"ç?W=åþŠ[tR/nüÀ)߀ëÙÓǼF%{¢ñ<¡ï…Ç÷ïQŸ` ™Xõ¦ Ý‘¦#ˆ©dü)Ð7X¸âgÅEøá´ƒ8sºAÙ’ˆ J@dù³+`ú½-·ðF•;ž¼jó— §¸™Ey§Áƒ‘[Vü¿ÜÌ7ú!S2é6àYûŽs_jCªp8bSQôì÷M‘x[TGR]D—xkº|háɼ]1ŽüHß—íS¥*ãÎ-&æC¹üðŽËe *qʹlé/O¦!þN_㸵ª²¯6¨ÊÚuõ¤úÌ…VN>[f4+…q)ãR¾ñÁ^ì^f:‚Æsq¹s•ŸŸ&¬¬º–²}^ÍËóÈHqŸ"ÿ9—3;ƒ˜Í­*uLßÓõŒ—ãž «Õv“@<Ô«f1…¹4%¥£—„â$½ÿ^v‹*´ÖV|nTROvK\&39wJ$a¿< Ð'ýéN¤{LŠgœŠ$ú>ü>‚IÓo‚œðEè, Öz‡´ôùˆTù­†Ï4ÑAî­,‹ÒyÝ(æ}X÷¬G+jÇÃn8™>Sp[)åÚÆëOasNrW<ÓÙjl®¼h çpô÷õ€ƒÖ…èPdh43uÏ£…—Íh¤ù—;'*ð| ÿš†KŠ”°™*T¬]¢Ý7Übôæ–½«ÿýëík‡©¨¦ÕQÒ{ñŠ§7£Áíÿ›RCm¦Uf•BÅrÊ*ú:]ˆ«°ƒYèÁAT¨‚P˜ŸÕŽÏŒ*+‹;Ç£¸ÀïøÓÊzn»! <_3­+fˆâÞn!´GNXåLGb“9# Áz†{™«Óyp‡¦^µ<Žck<Ã×€–gè:%Êë0#÷äd"a>û@–”I$Þ¹šÍ‘h!­Ex# ²Ò«`üÆUë›ÉVàeçÎææ4‚Ô-•#ý_âëü"¥d×»r­‰§pÅÅ^ZÛ­g§Í®Ÿ:i7f´ÊvÂ|0(,Cî¥Ù{Ön–cþg›(+•q„ªér«E Ö”xž(q&ÏúL¥µ¨‚Ô'OJOŸ”µ*18šMw5:6» kLú‹Óa\¢;//HáÊ€³«n‰ÉJ«îòìhÝU®6NžüóL®ã +¢ ~ô•ÞøÚå}3ú±ó¥Û[ b·¯4õgv%lĸ„ESì?2i¢±ß £ÿŽ$Ü¿€¤ìŽÖد/Ápƒ”ÑÂiw­éú,µ’sNýå™j¡«¾ €Â·²½2ð=6î›®ET¶š¿ˆ!À,PtŽ¢mç ÓAöÉí1)™À¬Ç$ªßµ³Îºª»‹7Ô¼u4¢ ¾°zúüËÖ]`·aM Õ¯ñsqQæF’n]=:ñ skÓaO[¸¹Ê<hŠÄ‹‰".7 N˜MŽgXðv­µµHvÀUæ×¹·Ýb€Ñµ(”5¤ž÷®\Äöž½ X#d—3ÿâÃÑIyw¢ÈLß\qìùç¡P8Ùÿ嶊ª“Æ<1ùk†iGŸø?oôptë³é xó{¬oŠq¥oÙ!2 ÞG‡µCµrÌ=ÂKdòNŒ/ÙÍg3ûJ€~JúCgM; >y˜DIF늓hˆß^ÜÕ¤In¤²ebUFõrk8¯¬ÎMðŸ'ñÿ¤µ…ýÇÒR_Lg ’Œyû0vvûç~H"ÚoP>mQ2OFÃ×؇a-ãx�ú´Iá=Ù>Е]´KofV{ͺYáQÚP' Ñ,·+H¦Œ™À ôž¦´ 70$¶ˆD®GLüDa–qîPU<VöLê÷ór×wžw‰›¦ÈÊŒ{iÐœækÍ´â¬dÑœÔstÚÃyãMZX»C¤rLàz¦©šÚRâ"L”Œ½›a\¿¥€R¤JBèâ‰CvÚ³›ç a·o0ý[\N²XX¿§Ƶ=åíàz‚yè‘zçÚ½èòHe!ÇõL3àV@ K‚w#ÚvуÑó‰Û™¢_ßïBgÔßß{Wf½ç~î.õe[Õøåöe’‰=¦4Ù9¿’eŹÜu¦'ôƳ&qÐBCãU ‚7ù pî±nÀü=Ó¤Šã4øº°àñ�mWoh^l{§c¯Ía�êÍëlKÖp‡z‹)lÒ©èJþÀ-v'IÞo~6S/rc½ GÝkåÜî}PcžÏ®ÔaÚ§{w/¹Éì&góü&_Ì|Ï•(&'ï£öÛGÑ&´J˜L~ÿ|S—,©îé3f'9i ÄKíaâÏ5äÐ\®Ü¦Ô™1ü@’”EmC'f³ ª”è5»>ŸJÓ .Äøf÷DÃ;žàbçtªž¡§,{:¾è–M 8÷ÍN‰ê˾aã»W«ézî[ÑMËX{X¥ÆíLcxô.x­{G(\<êå{ž6f¨ [Ý p¡ <wo®²ñ¾CfËß Q³29cw@Ño8çÄy¹W®m9E”~5á`Ó êV+’J®v^œKl,GÛH޻͡…bƒkô–.w«Ùªô¼9O'X´ùÚØM=ÇÕ›¾îõûq½°w“•4©èö²òE¤˜ —°÷"­!½ø#Þצ·šÕLúl‚­ë² ‰PÓow]¥'³ýáÀõx@ ám+¶¥ÿ¯³¶3#@ îmù6Á¯pkq‡lPÖð ÂZ•çlN—æ*kD–r¼m2íÿ#íñA§Ðßv§q³Æù¶}åÝQ;u)¼Î$Ø÷ð¯'AJ¿ðGàJ¹Ý<_Lgºœt‹ Wœ—F¢ ¿ R%?qŠ“Ù\‘–È’¡AC'X\ûT·Ú\ÅÂ`íÃþ*‡ÁJq ½ç g»Ú£>÷NSè­ Œf¡ŠEöTëîVŽ•>›…¦ê-Ý„ýGI…Ð&(Š!í<¦0'Ɉ‚¿o¹“Й=P„KÖ›  ~€‡m›¯å•mÌ?¦7‘ˆR\:€èW’F•Áª•6>'Æ!ØD½÷5…ð,·”´Ã0Å­¦¬äÒ·;uÖý{ªaͤSÜ•mz{èU/&Í}Üó<î�auc«;*·HÜÊ|Ro8[D"º%'R²`f.fŒo &e Ô}Gw~ke~ùd¤{®Á„’‹Ó=µ€f”Ö=rú`ME> Á=&ã{átÇ(qg ˱k>ÌÕl>“Ö7ó8Q€õ0@|¹Âó f÷7ÀÒ^]§kßöL6+‚„|ÉàŠŽîÀ C9”À»½dÁ.ç>v¬ú"¬‡ÙÚÔÿù—ð^pøᇔ̺¿ü ­ä~Ã-WÁóå9íÞcà… ó+f6«ãz,(¹Ûìð ¼Ò¹œ,éÿÊq,añÏ¿êmå·4aÈ''5ªªÐkm÷»‘ 8Q¿„ŽŸQÍYNžµmów¯êX‚€¼:A-Óû35Ð^_ÍCïŠÛÞoG:‚êîÓÈ[Ð2e:›ÛVÿ;+))ãÜH>1áT´QÏ*ô1©RÞMoÐ\EZmô—»¸ou›^@‰ŒŸÝ.»w:wJ‡#¦,�ô ŒŸù[¡ŒÀ¹ZGÃPS*£N|PïN'ô-£±aÉ&”ùtçõóÑú’|™Zrêš™ïf$ö›p¦=*e×®ÎG}y8ÎT)i‡©…Ö©1áy}&~º¢•<² �76Ç}7àøôˆ¬8º/��¿´T¯<ÏMô8�ʼàt|?+üô Žû\jI¦ªôU<Û�‰ ·¼� Û½˜nâïfY±ö.dnÉïOéoM§­ÆëR¤îTà…Ýpì¿÷œq¼ƒ¹ãõо/ù= _”Žƾy ¤ñ° ƒÓ컇õP7<q·Ž‘{Á²J%’%g]9¥R3ôåÓlÌ'8@±°<o?%�îýc Üë kþƒÏí们ßó™ØtÑñ¹£éHoÖë`$a‡ÛÞÂ{."ñémŠÌÕLm]Õ!3îªÚcÉÊ9ÌPêd:MD1[/xsÒŸÇ£P>üÃÿ€4¸œ•U²%%$ŸnÍg¨3\dhœ¦oâªÛ,Aø·ÿM>SÇ¿ÐÝÇ÷z£m8—΢n€‡öh¼'× fºÀ‰å¸zÉ›!a‡¾Þ—Ó}ûõ3·Úiœ÷ ¢qÓšò ¦ÝMa%qü1ƒŽ;nó9ÎE9S‰œ1_…=Û%†^šR`™òŽ¯DÌDñ6±FL€I’ã»gNGÁRÁ¯Ù瘒ÔÛ1“õÑ|ÌO>ELi»â~ÐYÎ}ä—§¼Áp‘[É ‘ ô(+ï¹&viœêÓ´Uë”Ù««NKk7j}tI£z\‘} yšÐôÍlñ¡Ù©ozËQš‰›ø¨ÓŒ2•q7Ç£‹þ;qþ+Áé~ï‚žÞW¨@:À§™r0­èÜÛÂ+Ô^Jqþw‹ü+*ëEBIàéRÓŸ´˜Àíƒâ²£ÃüÀÆŒ—‚´ù&òV¡Xìÿ5Y¨'ö¾©cãþèß8U{Y¥BÕ¥pën4†3oxΔg5ž…OUä¾³Cù®‹äHÐCœ êNV´{§2«Öòaèöèhð¨Úg- 7Y¯ehÐ mÙe9Ê.ý_=ý¬˜ ®ÑŸéük%F…ç|ã~ÔõÍãÅ\ësŸQ5¬Í(6‡´ÐåážÇýtë úDæ7¾ ÜCÎfc-ºK8Aßš‰û>=CªrÆ Y«nÕÌbß@,ÀQ¸ /JáÌŸG|…¾Å™Un% ªhóQXÃȆ4§³Pú²õº'ç2¦äç´N…ç¬Ùqõ ò,^#ƒÞy‚Xá 2:ÿ�¤~ê(ç§ë â$K —d-8ºü¡í”³ºnÒ©é—õ¿?¤éÇ^ùÖÆ ‹8À“\ºŠúŽ¦Cˆyßì:îȳ—HäUÞÆfê.œzÍ×z®ZÀòhë�Ñ6ú’—Òüv<ï9ª9í TíÐsxØ׉K} µk¡-¡Oµ~ú-ô±×k?Òâ»à¤œ~á#›³x9UÁÁ�”+lCC²ÿ³…S<ûSÏÓ$ëÐúªð0tL¶Xž[�EuåDkŠÜF¸\K _:`TU¡†Í¢¢9=ë‰î±ÓBægÉXnÚ9-Ýiˆ‡«×j)ÏŸ+ZôeTù6]©Cgâ+šùüÐ:AJFwJ=K)GŸýÄ.;ÊësÕˆ„¾+‰bø ˆ ³€ –î]øT0«}š&JN�ÓŸá£r*”œFãe!gÍóba´™Ÿ�×™^Û:üœ&‰Žyú®‘ù›^ÈIñxû&7 C<#½Æ°{§§êEèKçØyM¶8r¹©ŽÅð˜ÇI¯¹£ù\Xp¹D¾U6ŽÄlµtlÚo, q\׸×yõPÕ3ÕæE!ÆÙQysL·bÑBÎ…)E‘ø_Rê‚Á/̼£T\ªY˼j‡²k‚4bá§c#½ã¡?nÖ{Í뙜&c(B½÷(„0³?©(_t`ûÑç#‚8M½ý’èï«h±œ\ܧŸ 刮²X•}Nîû—ê·×Dl—r«cŸó­Š½/!þè¦zƒ·>ô»Ã‰þ¯¯.@i£íá/”¡39àÙúÚ`s¨ñ8gËŽß™×ÚïþF\É”™\:}šš\ì®}çªç¸s÷U˜by}è~H¢ìŸ¥k¾A“lyX.wª›øöuî[+É2×_@%UÛ³¡5QèÅ5Cs5Öü�CJ“`æ\/])ZxbQÊ‚¾ã‰'éý5‡GÜÇ|&y‘…w¦[púLèœñ:ÜÉôûóÎ7­K¨Î 6ºŠéËÉάS4¾6= Ì’ìÝó¹Êfí¸IÊhñÙ)0AÓ{£X‹þȈ>PSP?ǵ¤*ÆgC #ärëGF p8¸ƒ-…)oÔzƒjž“åºøÉ}ÂE-$}¶pIZ·Ï±9Sàù=þófapÜÜÉ+ÿ7V+qò­ýúsô ¦AÜ‚ÎüI%éÖýÙõ^]J†îœJù+ºIŽFÔ%°Š©5 Ãù=b¦Ž&žŠ?p•¸z¥yppBrË£¸÷~~q#½£¶÷S—!-Ä–¾÷EÇ^áã_)æÚÀ¾Pa®yßi'Ó–¼q1MjÿŽQSG+skÒŒ}³ja{ó iÛöÒÑNŽ]ž¬Äp7IôÐÅÅÄR­t¹äÞ6ßF%óÉ툽̂ŠD¡ft±·Žq¼@òÇÊ&$qâ«l1E7uy_ê:DÁc#ÞQ’ªü(ÿ­¢ñèkñÔº2V¦pŽ#êD‡ìV·³es9©ò’âh™”-Ú²x¦�Ž‡¶Ì¨|KŠ>›Æ¥eYÙP"Þ2–8'Ø\`™Ã]!ßšxۀˤYÞÏ^ ¹æ7ëœVfáéX8zé#ÿ¡;dí>Õ’óÒl¿óC2fóéBÿăŽj—Êå³I€æªB£tî×òT\aÊ#j£ÂÇņÌmZ £íx؉{o¸º\W"òrk<ÌäOJwì¬í4/Þæ²ë¦ÉnPæ”x÷‰·Eß‚¸`âˆÓ”åzë2´$¡FG™?!rýÓx>QÑmÕziú³´ÛöÂu_eÙÀ‰Á¦Ú©—QÄsáˆ4)±6\¸9}lבz加L.|,QEzÙ[£°ª^t¸\Z ‰ùv0ùÝ\Ñ•…�ÑÜëí÷Ò(ª„´úCA*÷’íV@' ;ŸIÉ,NN@‡›À\ŸÎAG{Ck�½g®øäù%©Ã<ˆ)e9«„ô¤Ã_§dµ9£¹Žä©ÿàj•…¦Ž¦Š"+í[dÑe €uüÇ—vutc˜á»Ë. òï݇’¡â Rk´d)äú'·È Š€s=2¤µZ$º½ßqýMÿWs;,Í ô†V#rs?S¯€@º·u3*Fë.×C{ÅëŠÞ£§cm© Ii'ªç5•Ÿ‰)·ÊZêÓ�¯C€w6WbÃ8N> 훜6ÞñbÜYšIHȬ¤dú¶'©ÜÍåñå؉‚�ü`lÿ þ¬Sk‡­œ*Šf¼N^¦‚R',!þm¦¬vr=v\HqžÐˆ*ˆ Ä!ó9_R€qa”ä7dØ™X^[Ný¾ýS»|Ö0ƒ e ïSà˜C&q‹ä”¥‚ýÕ,—¨È'Üyå·RV‡1kˆ±7Vê 1 6¬¦¿·ÅŠV‘¿À¥M™‰“ú™ Fìçt+ihœ¶˜\|‹VYe|BÄÅÎá‹OE €m¶ìu¤H}›ö<ÞÚ˜$IÉáƒ{:ÄÐHœé.àÉC=úâÆ-+k|Fµ½{¥Ýd�¦8½„ûð"ÉË¿y.AñpLU¼õ>°ù<܈¡Ë—ÒìüäSœÍÑT˜:Zg­Úò%ÎdHãô»»–ªO~’,+¤ëS8}ÞË�ùç D?€‚ĉ™ÛXì„Úÿ–c£m*Ï·§žï.æg™Õ(@ ^¯úÇȆñD !³ÇXe›.¤'‡‘S8àµho¹'·ï^ Uš…Íy‘ UÞš˜bÊ‹57ŽÎw€'ÐYò¸y5X ;n¯tFv^ïo7bnôæªôU {xÔl¶uJèý<N‡õ—ËÆ›‘m¯t.›óXÿÒÈUn}®€æÒ(9©ÒVRÖœ05Ž` òUxý\,Œ¸ j’#®Í5øFs€¤«wböô¿g+KuV7?A ;¯{~U:sÊ¢éHQ­ÑJÌ"õ.P ï1-½·ßï�kÂUü?E˜8x’ÔÚÌcÔ3×éqN]7në'§I{šSË…¯y¶¹ªpg‚˜,2T:œ¹ÖüuØ( ÷)—?w~jKaÐ×tšú2%XDßt¹ëyêðhA.¬|Õ'Ã�¯ÂÆg™ ôê›/u†›ƒ£ºÍ¡7?ÞA¸¨l¿˜ð”<-(Û‘ª Žbq|Ø/{é6W/”¤RH÷Æ…t\ZëP4¶Ð?<ýN ã²—Í°k¸?ÀïFoíüo~ÿ>ãn@ÜÕ|%[GÙRÏËî4ñéÆ ªNüNü" ˜ÔMIê‚ÂÃ9¤,«¥%+7²z;ì5˜½½É’2¡Åñl(½N½RVw‘0Kò}G7áÆ%4пe[‰GQ¶¼@…”joªqkRôݬ¨Šó¹®\Û ËÐé\$˘×këôèN3©ó>d4Ic›ïÐ qúñØ ¾%‰L[T¯H[•Ø7È>—|Ò-áDs¹<œ¢ý7eÜhï.QÒd¼pîÆ2ÄÜÛ™uįcBÉ'‡ÈãˆÐIÉÛw÷•ÄÌ€Å~e€g—-át…VøÇ$û L¶m0ëÜÀ©çÏî>KïÁdÒ e˜7ÿ„‚È[Ÿ£Csĸçå+G–:¢÷¿ËúÊj•ÅbÄÇ:ꊥñß¹@ÇÞ•ÙïÔ5�Ô^lTˆO\«.îÌ¿†­–§<¶Ù„[…Ô_Ý|®’Ï<| w,)Ájn€K³*§m³>ÍI·ìÜ€­R&L.ú¸gƒæYöH” ‹?Á(;Wo '¼µÍxéýÖL5E^1IE{`Ѽ›ÄŸªÔÉÌ_P$Nâ™û¥LhÛ$Ç댎B_Å0´»Vâß«M›8Ã$É[­Ó’ó½]%¼·q£Ý¿÷Õa%V“×#=æ–NZ•mó¶ºBæ“•{¿Â7 §»x¨ÇQ3!?v£þ-m¥ÃIªÇv'5†sP4¢~âõP9‹$HÎ0úuµ‡êä&lƒCóî¤~ƒöLqî¢/¨â÷Bƒ º•…bÆÎD²ÿ pEÍÉþ•%fÀ€‹ê «I”P®8hÒ…1²{šqï`l¯5½c[{¢¯}€.H ;FŸ·£;5¬ôòQ¸™DQ =9´Ÿüãåý$VP²»£ äð!Z|KdIÜœeYÎ{¸ŠÍ0.å–¦ïмl¦Žû?óî ÝãEÄ-–õ%ÅÄ@°cPÓÆD%ع²õêE„?oÃÆ‹Y›‹()[Ûhƒjt¢4ýë~e KÇç-Üð˜|p6v,a++ßQö^TISCeæCk¤}• ­¡*@'žª…¨*OQHÂÿw‡Ç…* LøÔ�äìÕ®9: óbYÏ•XǶ¡’4*SÝÚÉÌÊZ-0;C"Œž” ðÓ§ó>ô]?ItGµ%µ©#Ëzu_²²^ç°¨~›+èM¡Ëéì*NÍŸ^wchõÏŒ æƒÉ$µêGháõYTž¼PgÍ*§Ç%·d¤AMêí€åeeq ô¶ç*ª¿®¡IKßw‰ ÿ^^ÜbjÅ•ú²Î¹û©m¶Ë…‚L°]ŒPQ}â[ÿOnmq2T‡ã†þ‰­Ðí¥Ûßj˜;ê>¾ -Ë™˜m,*¼éä'׋æ»ú'ÞF&Ù­ñT”—{å³vp&.0‹wµ¶ À¾1íAU¦}ò^Uoz´"¥òýæ ãù¥Ì—f>ð·Zã¤:�/V É¢°FeX™eÊ<‰/Fº=}¤s×[&ú}ë`·¿xF•LÊ tW Øú¨§T¥Z˜ØÚSpjÑEýQµ6Š÷¢’°fÓµI ?Ä7ªR¶×ö!Î8à“l¦‹F…C‡Â¡XÁÆŽ¾÷y¿Ü¹� ×GèôŒ›gä#†±HM)4×!¨ÀC‡Ðm\”*2¹zÍŠ.¯rëÍÍxº5Å»¯ŽSNŸ„%¥‹ðGg³$Ín¶%ÄuTŽ>)‹åQRPÞ+-€² UTHP}<®… ½ë?ž«™ú¡ÞB”ˆY¬*‰ê£bRÁ~Ò߃ìTq¸ áB¬¹o²àû]9_ÊÕ%g4ö"75²|¥ú”N<r{>g¡ÐÀ{ê™ÐhlGUÙè»Ew4öSèÿT�MäÄÌCëœ}$ev¦^|ÆÞ•HÐb÷@Ÿ„7.,¬°XÜ©×ÈÊÅŸlZÙ†ÈmE¯¼;=”[x±ÑÕ½9ÛÞƒ$³—›NSmŠpÀshwftŽk}ߘ >«Œš%0Ñô¿}­öˆÿ§äI¨‘ìت³U¸ šx¢—ëÐúiš¹CwqT0A>\%’à’‹‘[;óÄ:_Ôby1©/í/â¬ìÉË”›ÉèŸÁtc'ØæCß1[Þ™ËM£¨¨SÓQf}z˜Æn\4«¢pŽºÇ°sýîpq—ù–fCq%±œ2�á:-ÒR'ííÇ)›7¶‚z]a(ÈäÎPf­hµ¯˜%2‚mL¨?B¸A’2í"ä’~бNù¨cï¤ðF/‹÷º›OœW~ö/¸ËØ\a˜Ë™j[÷5×çº 1ç);¥°~ tnΔÒÞém7Aùãg,QÿJŸñR_¿%<A¡·t+ó2¡Äi´/™ÚÐ. 3ÁpÈõØ_±’õª €Eð£¨üüÇÝ`:6îÐùúá¸:Ÿ^‚þ¤ £Î(Czçç‹!£nÇhSºYWÖò ºÈ b±f1ö݇å—6ZNi\ä"›Šy~8!BËþÎÁFg¹cvV¿u²@(÷YZÆ·¾Pžó³îs}ãÊ‹ì8¤vGow¦gÖôÖª§:ÿïÿLo gÏ~pKô8å3拉!þ.D‚¨(£x}ñXCZâGPg­k2œp˜þ• ¶ïÓǪÿì«([zW²h¨Æ9ÀòjÛ9> ùŸ»ÕObu2˜¼Z³˜åÆÉÒ'Ä+ÚZDZ†æü$ùó–¬6JŸvØP€)G±Â9(ïÊ7çc7~,9·Ñ ;sÀøþ;€šƒÄªh™aNåµ¹ Ç8@Mì^"TÅê''ˇlΔ%Ô>ñc“q¦0Gv&dñcw’ ¸Úîf›ÀŸL3gÂ;‹Ml²QUÖb4:ÄOS§Á½f<O[¸Í †§…·¤ Õ§QæË{Œë‚´ãTEMÈóÀŠc{ÔÓ„ÙËx9Qp®U9,þ["•‡xÇ•ËZ:@€äu°¬‚Óî�¿Ø2£i�à“p™úŽ?)J |¥÷œú"Jz•È*Q IOÕ;½roXâ›ôX0 ¤JÁáç_³Ñ|nE>Øpd7o4Ï>ótÀÒ;鯼`Û£×îJ«�5äÂeC@ìùSBfçvÑ?Ô>*ŒŸºÿ±Orzß)ðgE`Š¡×�^Ôœéï@ÎÃ\ßÕ=©‹ü¦w6õh ¡'ÍÈ.¯¡ A zPò0‚øס̃÷3󚾌’vk´×F�ÌÙy _OYèÌ„ìñ¯¶Îõ;æ©îÎ% ¼6iTœ´C�Ö�Þ♨>Y.NØ\ík]Ýa\ï¯E™ÈÚê×ðª”çOg§æÕ‚++F[ö$’÷‚®šnÝõa˜¹-|v˜D¡ä8±FÊ}lZç·Í…ÅSg?î–CåÕ´Áøÿòž2é-ê’" 4v~@ '‹4·9PÒšŽ„wN Gõ~Û :5­NºÞ$Í€ó©-Z(C :Ò®!Û”k¤Éž¡y¢ª×±sŠZ­‹,JÏ#·I7Û·eÑ…mfÇÖ Âô¦oö‡Hªû¿…ºvF”,ZŨÔs„r¶_@¼SŸ T¶/(Âmà“še¹ ®é!Pî0Art +? 2&YiáPPƒC~•yìl¹p#a±èò)Õß%WõâFÍoê@ñôFàPâ1AŽP"Ú°™ÂýÔc×´àPˆ¿„N6åþ­ÒžùàGÅéš®?¥oqtÅ$”O—ü¨•bÅG¿ý «ý‡s%Mò¢ýúŠ¤ÐÃ¥Ã\Koßu¨0ÿåµòüJ5Ù=¢•ÞmÙR(šµÉX\kWÓÿ¾[}lEäÔ^#uì!IpG$£ó$ÿìŽôMŠé= Sè­ÿh¥u:·â_ñmäç8éûêklÊtÖE¡ÜyÓw1Î[Ó–uy‚K«ÄîªwÐSwùpcû;Xi;ª¹ðˆbëÑXóS@æ+.wù×C ÝãìˆÈE|W‚[¨Ïö¤Œ;cº³ä¸ü†F3 ÅÏÏ‘ìCeÖR)ê�s¨™Z˜Ñ!ÙÏ</Š}éis ¶,ÉòÝá:öO?f•þ¾ËLÔÃÑ‹SñH×/ÈPB$BbÆ¢]߃F’¦³§Ÿ 9i¿¬ZòxÚª³Êy %Ç/‘JX(aÃ, ',ùWœ°<Y˜ìcžú&ï^ÉøKÊi<¢Ju¦Þô3E¦ñUÎ{ …[ÈÕl/:\6ŸÓÓÿÆ{yÄ ú‰3µ8|ÑÝŠ?GK¹„¼ÑC,/»Ó °Ä'´¼ÅlõÓG·ô9û¥'ý˨ȩÅ‹âí¿oPÄts©¾i©šùp»bìZ&‹…ׯ;inú/ø²˜ôXTÅN¼:†“‘À?4ŽF‡G€ÜÚË[!ï•\I{9y¾˜{ˆÜÛ 2–F”©¿¿MÿNä-¦˜ˆuhèðP Áàæ,¡¯tß’îün&°˜bø¿721ÜCÕÐõèçxW`âÐ0Àã^Wuƨ#ºç.½2è®W®ƒípœñð vîU Š"XÁ²ÎÂüŠ–ä´ì(_wƒÈÀ}ƒñg3J?Nô—âÁmSÜn}„ Õ¼î¸ÿdªîÊY!-–EX¾z3ƒ¢¬{{<YoGÌ‘J;§¶Šn¾Ÿ%ú®¬È•hɃA"K8~é2SÐ#š× tïÊ„ê$7B]=7Œµ½Ÿlw(Ë .ãnØJeè¶ë‘ÐÎ.õjÎ H‹¢ªët†÷ ã)€8äôÆzáõ—íó´°câà Ó%¾D‹£* 之èIÔ¹Dä÷æ¦ÞT•E—¸ygq²¡ RÕže#>ú°ÇçcÅØ#Õb§w9t=ˆ£:DP $Gpj úˆîJ€÷Á>Í¿º’þ8góáé”78ë©ŠgµìÍx„9ð\È=ú{ÓÝ's^/Ü'*m=Põ|VFCΫét;”?drÄÕÜj©7éôÝ-85�ueòî4ÎaøwŽÒ~Æ.…‹Œ@¢Ò{G¢ 3B@ asùq®poÅð~Øwœ±}žž;‰Ä¢º±o0e,Ü~<v½q¥¢@ôßÝðß5º÷ÐÏ|á7Aí(YÌ+˜_dQåñ8<@Ÿ™Š[×’þ­ c ¢åhvDæ¶ðºF9Ž»=Vƒ^¾ä/™¦îÃþ®—muZD ú?…ÉãÚ�è<—#Úoî=Äš×ô¤*Ú\Ú·ŒÝcXThôÛüoXG!˜N­Æ¦•Ū¸^Y3‰A?Õ”m|a¸æ: ÊÕ!°ŸsÓ$½èèS*îNŠf`ëDªÊ+@ïm¶Çý„ºÎiµ…ÏͬÇ,~±LÛPݺH >àۡѦ÷ÇÐ-%.Kíú|JšäF¶-frð†Å]Çà¯Ù_7]3„ÜòU¨cUº^[íÉí&>5A#Àª»~ ôÆ“2]žy‡Ú¡PÚuƒƒ¬;«¤A¤8a…5ЉÙ*Ö®q®‹¬ZØœiAÎÓ!¤C<ÉäNœ;.ÀL››²ô®àJ<Ô»µCFgõiUí٥Ț™}¿nb ¿J¼ù[³]À{Aÿ«§Qù®ÕÇp¸0‚ÓœöñÿðÖ`W�Û?€Guì¼8‰ð�\¥¢x:¸]€þÆ€pi'3Y9Ãs–Ñp¤Ü„+ßGq¦¸‡nº®º]¿;l¢Õe ˆ­›.¼ZuûÊ 8Ÿ`ýŽ÷uK3U]ŸïøI \t6S¸¸eØda–¸ÖL”oñ·ì¶LCÄRWIÖ"d,x/ÊÄ„;ýº_z\Ô¦Bï@Ë+Ùt®>L9Ä]ƒÕJ)~4ât1[­5¸BtÛG«úî§qÇB+B2§[¡Óý…™m§MÚ2 Z˜f†QË å½u0(Ôf@ ©ýT€xs)HŸ@]îÇK ð8,­Ò©mì6tlmYîh«4ÞÃn°_Þ0Úõ?!‘ã<»ÑÓ§C2f@P¦[²í¼W­¾°à„¤/ÕisEçm79˜›ÿÀö|6ˬL[…ë’ýG–Gù{ïMI=ÈÜ»˜yñ%´8)ë™[ïÝý%Ϊ̺æB| Òn­<PYð,K¤Û½æŒT°Ø;NÀ‘AC$Z¦ÀϨµ9m+dΧ)®iUþã5F¡9Ÿb'­`wõM„õÇ_Øù>kíR†ØÃq;zßÇ Å85_; @Tî™^êþ9„:ŠÏ³nº¾„Šþ°ð#&µ·rܙ兢á²GÉòÞŒzGgÒ~èUhÙÒ‡f}k Õ׉2\J[ÁñŽ{ä%RÐØÀ'òdr›n&ò7:ÒuæF~5†EãskºÙ@‰ rK«UÅn5¸âyj ˜GI¥C£-åMÃg‘éº;‰€FôäoñÄÝb8~X; …˜®rÒžm—á“JPè]÷ZUÓ*96;1Î{¬’¨ëŽ¤iHè›ó§£Ç;À åo‘¥ q\( ì耿Àê¯ÇnÏ=5ùóŸæ  q*†;ÑÑÞJ¸É6M)h6Èv VÏ Üúî²›î+›åenÊ.ZDâ>ªðQ!nNsZa––Xñ»þŽýß›“fÕ  wÊ°Gcþµj¼Ë7¢÷Èͪ®šO¶;Ue ¶ˆË{+Lg§0>}³Ø’Â؉ûÁ¾€iV+*4d­=Ãó:t‡ë6³ítßg”®7A¡êÿzŽ‚•¨¢{ð~Ø: ‘Žx¬›Ëuè(rë«å½0Ò £ÖÂ:šÂécwêÌ×Ý-Þ Ü:Ý>~In-©‚Úô¸cŸ}à]´Ø}í®‡¬ã?ÓPæׂ.¡°Oãû¨.Kã·²`_T*ÅGeƒW-_ŒÏ|û:;j½Ò¤.”#,Ѫó}U]ý!º¯(äÐq œºµ8«Î’…¦0î2@TKÁˆÀ•Q #KQÒµQ¢?„$‹Ì3q`¤,–šNZû–‰<0ÈÉ<KUœ¿ƒ˜Ã\¢¢RòltqüëP°VxèzX,,ºR¨f¤@*S^×vÆ-«z4B³üÓqØy¢ñæSS'%V‚ÃÆ4ô·‡~.µö̾ÆØ)#žÒ(ÿRbøÛ>œÕ®¶ ? (%$3tøשj³¹rR£ßƒè<=™XžGéº7ôx‰¤ú(ò¶ÏlCL“mÜV”aiC#§øõ~vGO ‰(vmtbö ?Tm€‹|v Sq¡èýæËj%ÌQ<­¹úàªÙ{u’ÙV&¹cã]V1•þAÅ€¾9"<pðã×e@CòÂë;PÞ7:(ßÄDßɤµË¤†3+ìúWsÝç„%dx„Cf%[•srnì¨+ݼê Øü€yjeAŒìØæ“ñ™¼4ƒbÞ)Åaä‚9Ó6]Û MÿÛ‘–Ö6ÒAÍê‹oV£œà‰Ü±oþiþóWùüȆÉ®5¬ø_ÝUɬ1³@½F{8`Òx¸®ÆfíG8pÙöæUL)©¸î¦'eŒm„L7(¯{Å×-ÏP4€fƒ¶7̯|¢øýâ[µ.6¾tMÇ,*ŽWƒ¦ÃÍsÆíq ²25HŸ ç8µ¿Ð2¡Gu¡MWµ³# f�s ÷v‰6>{ó$Ž¢Ð¤ÿsx±¹'V« J&kÁÜ)NÇ0�êwû.\ ²AþÕ²àÞOÚ‡|‡M†Ž¾Çµ5¢ŸKZÔ¬‚w¼Ë©yñw·d›8«fê ”ÎMt@†á/†"ÝãÕA~púÙ(ÎœôŽ·)œ®Y”_{e境Ñëv¾tû—½U6pÁš*è@N$Þ½ôT²“åÕM^°ÓIm¬= ­K,hZ*2.s@rL$EôWzžæö)°ôÕ¶ wùRèL¯nrr¢[•ÐF DË¿Ì”‰:£oP‹ž& ŸÞ½9wÍpAGšÐ¦P`çDX£¨›HIœBnEa‡ùnU#èmÞÄÍÄWãÁíÜG6Ry?ÛTÖÀöjl~è ÄlU‘i7ëÀQ£¬o( t[pz§Oãßxí²çF'r‘ •Ó‘²è‰RÌX6iÙ8'd-ˆ ©¾ÉÄj/Áõ¨cºÝt¢¦›&Z· û>ºD 1¾c2ÒÄš^Q‚9î)TKM¹TÕT3DîýÅk‡A 7<«Žòñª˜C¶Wålö�¸Šúºÿ žr«,»ìx ’±z÷ÚO©'áH×û�¡'ùÞ'<ÝFÞwó“nä.ñ=Â#aÞÎaÓe£}û;#…KŒ‰y<ˆ†…ª4‹TÐd˜ÌsÚ&BݼÎdû³j†L‰AÔ¢øpÔùrº»=Ûcº÷Å4wß®ð ܪÊsc’W¢è:|ÑV8~šá©àœäMY‡´+BùýüÅïäºv^¥c‡²sÙ^ÂéȺùÒ1Ã/ô—ã"É-”Žü6íÆ´Ï>x†$e9Fy¬…ÅÑsƒêâ©ðh~ëB¿§3¿nƒ¡UG‰ÄN¥E¨à’™Q(9§¦l7–šp Ê?‰ê“Oç >>hMb ,ù0:dÛÿª´ÎcHL®ðÑ6<œÞZ¶ñ˜À¶vÎ6]ËŽTܬS­°{Ó_ ¤Œ¼2cŸ—m©Æó¿òÈÃÕÔjòWš¸U–«ô')¶œŒ˜©62,Ï´ Ó™b;Ïíh•çÇÁ0ƒ ¹„Àø ÐelÒ¤Äþ–b¨øinäçUhÉg¡ _]X};Êt‡X@j„·Ô·mQ:½ûÓ0q«š–µÎ;:º‡ƒo'gÕ&H¦‚=}ίÆ0šÚf¨jáy¬‘rº©éK%föZЗ^Ýis6éîÀØîœdås‡x‘xÔ™ ˜©Ãƒ]ÎP§šªhDy÷±iUŸÇ›²”8Gþ^ùyùSÔÄ ¤v•^ÕVÑy`š¨g½7È @¡»sÛ“¸˜¡Nãhó¨<èÑûü¡‘ê1áÆÛ V®àm·)­ˆ“Q$9R¹ÁÚÚ‚sA2•žûà7ÿí»ÿºßxt^j6;3ù¶_9ûþac1Eß5Áαw Ä'>k^ E¤ÿclK:/Öô‚ž±à÷®¼E—¹}”t–ÏY4_¦éíænºõã ®‹ÂèEqé“ZÅÝ{7s¹…=¨šÕƃ؎èÎT[C÷9QÞà$t2Óz‘CC㙞j”k%^<1Hr9 J^Ü0`œßè×lÖ•´$²Ç€/ö³ªÛ³&´i\ë‘3$CÄû7DÊ:™¡âSéê½ÿcØíl(ÀŠÕè9pOïIgÏë‰OƲ‡5àÑL.6MœBÿ›"å|6§*åõ縤°q™ñ9îéÀë=UœkGO_ýeNg¥EË°~ êUlÀ½›ë BÞ”ñi\ãiØœh‘Vß‚”gøm=äö»‘Ÿ½ÞÂT ÀÚã ÈsîÐSµ6´¦(>GÊÅwn"€ü7À½<Ph¬l³–«Ç$*?×NKOÿÄÝsô\ŒßvT+S^JI9ƒï}q=ÃâÓ=(MüXfÍÆ!û°aäV·ÙM÷2¤Ž­'¥‹ÝW‚|µek~Ýmú¾ø<MÄLÑ–§†°ë'wIÁúF 61þXŒH_-ÙiD;©Å¢ñAA¡Á3ð·Zѵj7Æî©ögº3§“oÅ‘²–1·zâ¹TçU]zô$½ÝžÊÕõ?ªi½-2:¿@#ʪ.Iš¬çAïMNÝ%evõr2ð‹}ÓS¥»w ¤±„ðÕ6ož.ætï¢TGÍ7jä§Ín*îú“B!!ÔãjáZjJ㜚,Êš³Ê×—XÕ‡þ Öš#VDû1…ß ‹jîÕݼò R˜=-•à»ÚëÌBðë:Bj°_Z†×a5ž7Ñéz¹w¦®…!%3Â}8BpÙšèX•å¢•Éuòí+2ç¹)fí?(¹(ß­Ô¢ ›þ‡¹<¸¹Måëgœ·r6®yt…+LÑÿ2 ›¤J G,5ÿXŸºÚð!2U¾w~:Ø:pÞ§û‘©Pªä®}@é9å­d€|ಣ6Lf×aìÇ<¿îѵ<÷$­ "z%å¥%rE~—{Bh)–ö¦?Ú e»úûÉfB5€/tônÝ Ÿ?v�f|Štâã%\͛ݱɆrµî‹¨ôdœšÙß½a2uVãÎvvÉ‹å¡€UYäq þÅL•‡º¹ê'a5Â*7-¥@C¤ ¾ÅûåÑ’ÃQé¡Í[pñó“&;°`Г»Ù‡ ã˜3¹®X9K_ï`Ð’r¦nB5ÿDUKÞ´A€â|Àä':(E’èÜz Û+â®H—Vp¤ªbõô?ZÁÇÔHz*rO9Dú®Ëxõî› ƒ/¶wêÖ'Ñ” Q²*oÔŽ_è¬×Aø `7ãIÒîZD]÷ò“]_VÖ¹qÏÃÞ“Úç¥âÁÔÒ#†à^{ÐKDèÅOÚ‰UóLÐt¢4aÐ!B bÇ>ðã/ÿ›ßÒ"<Ä•ÊqÔ^«(=iŸ,ç5 LP2ÿ¡½„Ö˜vsz°Û”ôyM*Lèíúæ2øtøtjQg&ë�öÿ„†ä r• Ë1t`Àq?˜Ù4.Äú_#þ˜×ioºè¦;SÏÀµž#Sãã»>ÇÝ~¤çížúºgÕ®¿Ã¦.íÃÍ6ôWËîjXŒ™iôºlwÎ2õ…¨žÄ3¨7›)P‚Un֮σ”b/þÿÚZªŠ-Âd8På½t' ‹¾PöÒ8?bñe’Ÿ ÒbfA÷g:ÒŽÌÖ[ i)¸(D«]YòÓfÞÓGv¥Ê¼G¯…nåØ£×CÅÞ-.ZØn]è9}èËc§Î7nÚ%Æ` CªphõÖÇq…,Œé‰R:w>F@w7an¸0Æ<:Ê88Éiid>?Ïݲ[¹öËê<8us)u6Æ»ó+ƒÕ`«"€§†N ÏðqM5ôKø®Ÿš3k©ß¼º59ª6LñǼ Âa“=‰Ï¤Ý7¸Tû™qT •ûìTÙwÿÝŽÝdprÔٜë¨Þê‹g ù F-”v8:~½4ŽÊÛ|fI§ÙõP`Юág~GÅʩįW*!yÒx×ïë's?]ý÷SC•:#§tÉc¥ìNþøÁq̇æÏÀÊ°³MV?PÑu¦@âp*"%Z8À¸|ÞGCa!Öë‰Pà˜9]@,8êä³äFŒ1Ž‡KótÜÏÝe5N¾&•ÝÀ6kåùª ì\ÄÙuÞ‰GÃO†žÚœ” t¿÷ZËͨ•9ÄSÿÌ^w5{hYüqš ¤éø˜ÿ$SA¿÷ŸË…úúþ|2À91PÂÞû¥½'åH£;‰–54ðÖ& mFÃ8”–‚*´8ŠÂÅ7c^AXøÉ· º€¾ˆ›ÿ»&ÅÖ¦'òãgǪgÂQŸÞd Qyó"yÏ!£u0#ÜÅY´GÅ€ƒ£&ø'óÀË”ã¢üÞEvüMlÂ0W»k|ç3wîNïQÚiç}W¯â¢ùÙ+सªgx+‹åQåÝÔc5—q7ï‘áœû÷L,waj‘:JGßQ’Y%—¤ñ\tµÅìÒÄ–¿‡¥ß-…X¯¿ùþt“Y‚Qð˜©<ö«Ý‰‡< {Éaf1sÄ1é¡÷Fã„ ‡É;öê‡I \IÍP;‡æVâ„@æ;Øð²¾P•YLÕW{5(ÔUR–¾§˜Js(݈ƒŠ`múžÊÅ+|VÛ‘ áœ?n • «ÉDп O<; RWÝÔz w¤=¬ ÅSPµÁ¦ƒéˆ‹1󟬚b¥ZÀ€«“51î´ÙÏÞ'os˜6þ©KÐ>N\ቮL5xÑ~ 0XÕK‚šÑ¦ûäVÑ}Qa©gQÒúéq27à’Oý65%”‰Õ—%öý¸’Lá[*Ô¿ï(({å,ôÂÎ-„Ö¸¶ Ñß\î;VÓv/¨Æ3ï§*ä‚ÕšÂoz<1Õ¡kiýw ?^t£Ñb\5TŽ#f^\ªò¦d¬y|ë¢Qÿ5%ß²_NÙV­W¯Í‹I^sîÑ=‘Ì‹s%I0^´Jò¯7‹:¤¿Òþ‘g@¹("­,œù6Ãfz”ìÝË^T?bQ;ȹØÏöª=ˈÍæºîù}~ã?+´Y/6H“¾õé0.1´F¢rôæMO¿1.ª:´CJá§ëéË Ü(Ùþ,¨ ~ÇÈ¡×ÀæR‘ÔŽŽbË"Bî-­çï `ÆÊ°¡“cs¦H÷~¤É~V´O;ÍØ6Sß1¥ý¶ Ï[üXâØ@°†UÄmÁÎMiÔòO~�¦]l œ¾>Êf¸CÊã�ñEˆáRDùÚ£ˆLN”by?g&<“Ä&ˆ™+ÊêVÏPvGËwJÃhT¡‚oÁ«¶´{Öõ…ðç¢Ó¾#º~}s”&©¨9­ÏŸ:‹ù …‚:U”ê)صÙÆJçu%û4­] S;d0+CÂEPRÝ`Ëà¹Y,D §éx_‡ôüÅØiBL x¥§«B›8[íÖ»•Z”ýC‘©½JìcëhÑlŒÅö:ëÛ3„R(˜œÒ?6>SïÇÜ€Ó f^úÁëÅ ïƒþ 4%mT|Í}˜Mì4¤“›qº¨£äý¨•ÓköêdÔ‹¹Ÿ¾>” úó,6°@€¥ož½Ÿ‚0䊖ðÐœvÒ;„œ4t^²Ÿåy�*l¨®iš ñ/d¿Â)Ú¢Ð÷Ð)|^ ’;bþ#`Ï™õVMÙ³5åÎpêa<C³S©ÔýÝ­{eá Í-ÕD±ÏZ€Å e¼4V®¥ªOÏË»—ˆ%iQå®wÉ¢Ž‚vñHý8eɲ%ý/h_®1(¹¸iÆO— Ù–{|9»ßÁ£!™þ º,ž**<ÆÏPß½güšOCiº ©¨;Ò)½»P,"Õo»aðÄùQ˜-j1dVÊ=úebœ¹±N@Ox¦Ƥ{&íéÙ}±Ø€{ÑyjÅ@À^‰p§ãwå—Ô•¢¼‰Fl¶{abÞ3Xi%9ÈÉcrk†g¨ '<€ÊáÔ‰ U *{Á,§‰b[o!èêFf¬õ‘{缕hø }ã*À‘$ -[0‘>]xÞŸ3§Gââs•9òbéÅHäOpµ½ÜÉIîuJ‹ËúÒС¹joŽ'ÅH"ko¤\Ñnþ; çÄ‘r_^W×"*¼,fò§Ý¸ƒ6@¤´ìkåœÇ)@½òkLWCÓa¤¼­×b¬Aq–fÛݽߎ‰5ûæ“aÜ$‹¨>i]q U³œ©£Há|e‚Ø\ññCKUÄœkd*³ÌêòüÐÐXÞÉéÐ÷F,÷Î7¸G·³Î/SÎÆÓ‰ï úŒÉÔéþáT/,„Û†Nøá+°ÜŒ…g#ãTõ:˜ Sßÿ~[aºÈ¸rŒ ò/m‡/>Ë®Ùkòø“(xžØ†¡}’q¨•üûy¹ëÕ+Mlx†F:ØâÜ÷¾÷ª Œšî¸6ã¤xÇ ‡Ÿå8¼bÈæ1Aµ£•,˜ ´±×¢R“¾)´/}É‚[êÌén.u»rj§Ý¼O!è! Õ„ !0¨]ʬ3ivF·wå¹QôŒñÌ"D«ú~»¨#µ Öˆ Ë_Ä÷ú-ÿJƒX¹X¤ DòÚÞOø»^8ñ”1¡º2ÿÞÖ$Il­ºP­å•m³8ð ”OC‹h+sõlø"(©H 츅8êé×®šÏ䊇• ½[y]º¥ŒÎ÷òpAJÙþ(©éQú#FB@eý‡Vç³ZA•(‡ŠIŽAvr¶´ú¸wCµ!R"�²t¾Öynºö ^Bö¶mU‡sñ_mˆM=÷ý)iåU欱hºR^á‘Ë=k¼<àËDƒY×–ý+¶ e£ŠÕíF8Ý_ZwÐÎ| :ù…¾<ò†H .RœÛ–0„TÖ¤Š¯Ó"\­”ƒc.·×¡½ƒøM•ˆQ¸LôѺ}w®ÝèŸ#cå–›•pÿòþ¬;/­ï3¡1†»UoÒ€·P£ZÚ𢛶 =Ö“‘ P|¹Ð[ï'×ÐÊ ¸väÿTÌÛI {Ë©Œª~íîuÍv…̸ ¬¢—tYB7<ÇZ0>”eŸ^qÛôx”Ð]‡Éù¿ ü. ÀY…ƒþ×èÛC Ĉ©.› Kc¡½à¦kî˜û gL¬óF-€*äGË^æ’ÈqÜ~€(”qà•ÜV)‡Ø¶¦Ç¶i åâMþü§Ç�ûYŽ-X,5d,†haLfø;±!?XáîÜj¯Œi÷,Î~ìï(™Šg;È=æ'=ß!ŒqjèvŒT±øXÖ/öçLØ£fa(¿Ä×wS˜³¿O ×ü(ö’‡Ö<šçÙO“åëWýßÀv¤Á NDg…o»5ζ8{½[dœ‹é*­ø|º¸\gôù8£ƒÿ§Jefn}ÎcŠP9ãjBùb;—ék¯6†^÷ý#µd¹VÝi¨(†,ªÆ&Ø,ÏP¼ö!ç/µä«4 LÑ!—ªQÅf�⸠¢Ä¾yô¿cTUÅ!.Ðçl›*J}/"wíº¹À|7îP„t_÷~’äfÓME·:².S†$yiÒ%ð~ܸón?ùJ¤¹•À¤?PÑõc¥¬Ò?À8T¥ÕD…Pß\îD¥¤ŠsÃg£õß­’kT5ZŸ‰Rg7W“C7.wtðÜt˜5"¹¿Ý©Üøc5l¸Tô×¼¾}"[üh†û÷ÿÂSQø€¹ÍxkSJ¿¡lk³ z¨K†yõ[áñ—%ó0Ixæ²N¢rl‚ ËÆ‘ziµïwÌéf 5'£ÅQ7IUãÍ;Ip)¶}ü" +ŠXÛåE”¬=“›Ó~ „Edm²…;F]OyÖ{õ|aÕZ)‚Ç:ª§ÉXÅ‹U"eù‚.û \ÝÁ<{&[áëkÅí÷T?ôþÐ_‡îüåšúý‡'yP¡Ÿ¾ÿb}íÛˆ¡ç‡9C s2Êä–ÇÀð¢³ÊÌ_}ñÕUœ%¡·Êƒìšl¾<Ä #7Æ:ì<í\$( ïý@Ÿƒ¦ÙÂB,±ƒSZêƒìFÌ æC›‚ÊQVs{£kÌÐ^šÚ)þœO7,˸¹ÞIX/)åŒFVs‹E½ÏÉÉijÀoŠÎKZ›ÕRäªf<á(69*¼KÅ‘4¢_c.¹Ž¦Î´Ñb¼ÄÇ(󲌔æ­“ª}ååÛß •‚£³¼ÛtÃêúoÂS’Ü`?W[:óºOv†À &N4‡‡A?¼~ëÑêvf›ë¢ÑÎxƃtžýÃ.³î_¸\{¼|É€2:~è ãÑÒœè´9ŒšSÚ´w…¤û¸A.Óÿ0 ž)ת,yFÎô®î¡ øŽ§óFÅ+îºÄh§°dâr‚²V«B ð?ݱ�4t<ÍãåÊ,­3¦V.ì›ó1À‚áó"Þ"ú ÞM°ååù1ˆC—Œêß1³$3•û=–øüemÉ0º¡¦eç]ùçÏj8#èïrÄd}̨;1Γ©½?MŠ4”g%‹@ô~Ÿò×ÌS×¾7‚+ßNº­ÊVgu|^ ¡Ä#1U pÆóô³ãíë¹ò—É)PµyÈRhí¬¯”>œ[E§286› @…â½ÌÿúÓíÞ¯î»ÖéœápLÒ(ßZÛ*7Þ`@8¥g¤ñQ·\^xŒò“©D^rpµw õ“kžù¸ùžì¤{ž˜_û…äY"ÿczï§FÇöC­£7æ2%P%o|Ø{á\ŽÕN¿nå¾ÿK|0fb´ýÒè/ FçŒN—]?ATò­þ2 ø$.Ù‡ŽÂPõõef!´!:®ðe m|tŸ/²×Rƒ>Üñ•áJ³ÖÆe¢ ßlè—ŽË®U¬³»|{ý–CÖfœSK2“³D¨¿WÈ‹¯›q/’Oô}-ý‚E0m_Î÷†t°åt�Š€N–R$Fú(š¦ÿÏ'; î®.û}s#*-Ö@ÖýDWA�{µý¹ü}­ÃL�XZ�˜?¯P¶½âž?-äe€iç"ø@o7~†Tž}XÝ0EY•O¡ÓŽè5+bž~U'ßôYÈl¹sº,x´G:+:ðßÜlÿßOÀâ¼ZXUÐD¨àÃè! @Í®x“wø < „1ÑçYÙz5«ín#‹Ä˜�Ñ¿su£‚è1Ûy{îlúÇKå‘ž:E+‘¬øq†§^Á‹…s¦ÝƵh ÚL Žª`iúãv+’2§6ÝçZXA‚X‚ ¥…Šfývs§ÅIËÕèEn=²daÚÈò‹(~Œmø0uïæëG¸‡LÝÚ¾ÔüN:T´(tÒáŠï6ÿØw¾2)\!ú÷ð mô=¹'ÕMW`^á 54†ˆÿ•Jõg µ¹â?MiT_4M%‡9*pÚØ[N@Ô¿W÷ôhaøט¶•¬E©ãë&v€”á<ÕÇ.ÿ쿼=Yæ.ÄÎ2·nxÁTô%úÑ4 Ý—1îW::匜ͦà¥çn–a6íJØoðûèÀ@2®îAæ¶ §Ý>ÀcSuÚÊTZOÍÒaçênR�Õ÷Q9k“'”0–ÖŒVöÙ¶‡�<Átû:+éÓØä¢{J»}ÜÓ²Y+Ç‘íã@ §²ñ 2å ä¹ì÷ÂȬøŒÝÁG)q H5Ø9H-¥¨®ÀÅ'.Í%dî@ÞÓ~Î6ÆÜǃÀ<ÂGÀz÷®æºøF^ÃkÅÁ öB þpö¶¾'àg(šÜ‡gÅe™¦;­ÞÕRNeηÍ?]ÏHb€ºm¿vGöÀ¤à³¾pÙÝºÍ rŸÖôiêEq)E 4ÕHÄúänô–Íø¡¹ È`öãsÅÕ$ÎgŒÌUŠ/[ïm˜pÈ&n`0ÇsTG ´ånÈA1²6F†´Zà`'FÐýÛnjšçGm·ë/DȲªMCq‡vžXŠøÖÑe÷?ä/¹qžcbÜT&ìmz-Ÿ\–¬Î¢ÚÃI$ëJú‹ïÌ‚¤4­¦3ŸFz¨u¯ï=}žw')!é;:BÊÇ“³Ä õBŸ‘âkij­ÛO±¶°¿À1RZŒýÙô9On.±?¹L×ôÝÒ“ÈQÝ¿¼c[žê‘-¸QâtÞóßÐ!³�ÆÞ¨^¤KÔ·"À‡/Fý%ŒƒU|Ó ßv„¢iàç1Èàáu‰¯C;5÷Ë*ÙFU«Í²Ìð…÷ÌãÞý9ÿ°×”ÙÞãuØŸI£{µe`»Ê?(äÞu#¤Å Í©†·Ó7VQ‚V^M}©rÒ†iœ6|ÐÂØá–LðÈà¡Nò9ÁY~rÖç¼2;&HcÚ§ôÿ*¯OÊ,€BEñº˜^¸v4‡#é*ß¼ÜaF¤ùǸZC®d©NÈIzž°1kIÒõ¡}varmê,›Ìð_W‡áØ4rh¢…Œ ÍÜ4ÐðªÚcÞpºýqOdwœ1»ÕëL@½ô.Cæû"9= Å^Š‚‚™‰µÃ»~h‡ògw–d–„h¦gïø”®¼ï:ÑCÏ\à8z* ªo¯æL^©’ÖRê£ä/n “Ìô¬&¿º$¬¤æ‘/íý›bî÷ƒÁ‘Gd‹vŠïOÏtùnÎ&ëJa;\$À°XÀ芹έ«Neô­/Y”z6JïtŽ:(¤Æñyè¡àKÑ=¬TVÝÜ–=­ô¾uu – bÜv¡Üy±§¹WG”—» ¤2ÈƵ¨Ûš“±ÂX¢öö碃W†«Ð)Ã^žæ­ó ²Q¹RîD¥l|ö€‹‡écÚpîh˜–Â_zö“ñ ªÅA{ëëSí“bíÛq×yÞؽI7ê är¥ÏîÚÆw\~Œ˜7'ŽÇýVey”NÆÜÂhü%<&/Â_B%ŽEÌã´O¹kÛ]·ÊUƒ fÏ~t¬"t¾ÿüH¨ËöFJ—L åPÅY[ùe!mwºãoô·÷‹zç··<Žç®pÉ|Ö¸à©% ýYÓv¸„‰p½àr¤(}ãšßt÷üd‰%>X|ClÙèûBoó&NñfPNY?œ n®hLùIb/zz[ß„À°xÓwËàò°ì\Š©vôâB¯¿½4€³€¨mK%©(rC‹Ç G·2á­žÜ/¦äg¥î¬®‚85·$–CeŸ“a|ôÍ™,½ Xب%Mz%„{zžš¨6ƒ�+?õæX”´'‰9éö 0®”ýW:¼eßcä}Õ‘$ƒtMë¹UÃÛqÓQÐötˆ_®î_g½¡í%.ã…»Õ“"ã¬ã2ÅÝ—+„yû3ñ6©g®Ž¨?1å;jg[½’#hC²6Õ¿‚Äüv¹¼Íâ™QxŒ…SÑy© º3«þžK喝m.8ê:»TÂ¥ÅCEןxJmrÞG­2Fж^ƒúW¨ˆvuÃËð¡dQÏxé˜Éç”óje^Àç­uœ® S)Ž;áê¿<¾ü/…Óï4²àQ®ž!< J½0hdMÿÇ ó…qí2ÑÿP>'�‰ÝÁN¥ç1CV½é½Ø¿mzÚ¬LÀJ§,¶Õ©AOùã±—Ž¾ÜÛ!.àÆ©­–}(,<`9¢ ²gö;-w{Ú/ØA¬ „hù)Æ jÔ›mÓã; sñ@/�SK‡]­ ú¼ßO#ÓÍP`ÁÜΧ÷9Q,£uýNáçwœ²Ìd¿HÔ+>Ó1 ¤÷~týž®¹N¿—˜±úKwy§+˜Y+^ZøxFÉç`üzúbŠéñ¹Ô³Î7ˆ!–os€^ãò`Ì›ÙWe‰á#Ši«œ›6 ûô›*JFî!÷£ƒÝM§e}›sÿ/u©!µñ`¦ÐR s[ØÚcpj\^íP_¤ÄÄ„€’mF¤Ÿ,�š´†Ž¹Ü^®ý»UUV[‘ tÇNhù]æ³î¯K%0:Ú@lc.K¹‚7C§ˆŸÚ'Vås¯âHâÑe0¼øø™›öR~í!ìŽ ërb®°°”ï‘,·h¬A tAåÃÕƒ;Že‡WZcœ îå^\ÆJç¨Þ`’ºÙÑXv¨bî£ä]”5uøY‚Š[GÍQŽ$èxeU4«C—Báâä™y…4,»q€þ¥±'µ—§ó ˜Sj¯'W:ìl`cä©Äe†nü-!à¡rGÎèÏ »¥þ8¥û Ãÿû? ®»§4.úŽRáŠ;Ù…Å©þñ~Ñ}3“×êá9k€=ňše÷­v[GÅqí0Yã¨$Ûƒ@ˆX ´ó\=úç‚óï˜ÿÿOY™;n¬Ô§ 0“àÈsÏQaL®½#¤WÏ(&T¥èŒÊ¼)î·Í½.;Ÿ_Ý¿´s“ 3:o ×'èøÉ…T›žòú6%v+]C”& &³÷K@ 1K·‡¢Ãc£Ëoy\Y/¬¤K]Ö´gê¾ñÍfT^à€à2ÒnõeËÿð˜Tžj.^1KÑPòÞ­}\£óÞu?Pâ°õ#ßy‡Û–ÁrçAñZxqéÊ¥2¬о»&RßmšÕõÛîÿy«*õJ_¸Ô´c‚ÄðÚ@=©­»ýöJc\ɳÃju>ÊYà…ë$[z4e© Í|naOäõå‡ÐÜ ‘I¬]sïêŽFkÎ~ÛÒÃdÌ­¨ý¶g£ƒiKµ'õ›%ùì@Ûw5ídU•F:á,¢•`2žDåg nUÀGÒ×Rõ­FÁiH335ŽÙ…Ó¹ h!Å–VÓ‹ABÏöqÈ"º´à J®?Ø+ä_žüíõ^"µ!ÚYHl'ïí«ÅsÊ´.:…ùlÿ@žëÌ;sç:%Œà7 l÷Ò e~Ráñqú £™¶B58c×RÆà^¤Øb(#Û'ßû%®Ò– g> yñrR½P"E#G¼sD åÅFEZZ& ¶4e‡ñr0UæÀ¶¨Æ¼ƒ©¹Ï#„lÌN‚ Hæ}«ÊtÆysßÍ”,åæLJs5aZ”NB€‰øŹ1FìÓÊ-ø{ÌÀ¿KÆÓ¦ÈSº¢òÄn.ù”¯N¸]Ãäd®(À^ü/ªÿž.]×Jø8³*†<î8Iíd„C¶â»ùÖ£[rÄ”úmú<7xhZÁ/̧t'.TÅïʵ$PüuKüˆƒôn%‰c_Òý¦ç%^1¨¡'6Q²®ÙÿooyQæJG²§ëà´)߸|îFé¥"eª‘¦Äk³º…1vb#”ëKãþ ³°ÅXBd&ÏbpŒ9¥þJ·/‰gŒ~zæÝ@kwR×í˜w8¥ÐâÊ$7Ó¹æݾÞÓf ‡Û?E´xWf’³&cÀ•CÀ) LQN@/î¾ùéÛ¢X̲”ݽ«mhY1ß±\JH• ÿ£½·Ç\ò™„¾I·çóâ©%§¬U7òPÌìµ�z A×aÑ »üð֢őˆ zl¹ë§nŠÑûýú©Ë²*'ôxžh¿¡\mœ‚‰ß©ŒÍËŠ®qº°j|¨Ì›f®êB#ɱàlpì€ØJ%<'¤ªÅX ûlªÈ¤-…W§4ÊzÚ�v˸m‘X×é5\'ks×^jçÖwüKÕxêàïõe ÚP\/ÅKøþ ÓÝ42-«2b$±H~ÅçwWÁ&<1Ä€‚oò¶kÑêðä+r_¡Eª9ñ@k~ñ©çBž9Áð n²Óýr⤬ª~×M7øWųƒ'p¶¦bŠ¨@îȬ {éÛßT·ÑügØ긧ø,êßü¨ ·Ž]è&Q­ŸsrìX>h8¬ еx;÷Øxß~þ“«P,nI ®?›$LÆÕK«rz¿µ‘Í•-Œ$Ú§”mv'Õ[!Wê[ÉdmÉPzËã¯{ùZV›+mÎ)hhš‹™ÛÚXD\µÈ:õçÆKbzìK][ôI>Ko!ÞG÷,ot¦´ßQ¶ ¬Û¹#UtýUsA'"w<3 'jî™çÆAÆ%†‘GM-}s'hVÜÆѧµ²r‰l3[Eé¨û:ñ“Vê@e‚˜lL;„RöM üU hßp ù\% ¨'°T’³²|ÅaR¨Îœ9ã’�÷s&ö-1«ŠÐtàâ0’²=«¿Ü"‘ ç:·nóý$ñe yß* tê|z‰€ÚqÑõ`‰è¡¹a&#/šqÇÖҵyÿ>ܶí?Jà@3©ÎzH`¶;i¯rjÜìà4Biš»êümîŸ×yi›öð#:>¯ƒ0�Åt6"×Á\è"p¡µ*¥Pö®g)+L�ØÆ¥¹V@/B•ÑùàvÃjKŸÑgÝ9+3wKš":ÐÃ%-úyŒö|À¶°”ôE ´¯Ó“?.:Ñè†ÿ‡â»„yª Îó?î$Û ä.´Î‹¦Nùàð•ÒBÛ*6D,ˆ<¹ÁÊnÞ ‚D³{ÿÉö*.³°¾c¬oFŒ%x!»š1æ_�F;Óg$ç4Ñ;o=Í™…˜‘}[ÄØ/“ñÿÔŠã‹Iûô mŸscúÇms™\öéF[˜…Ÿ¤ÉŧH²w'äqœÍàÑU´¤³#96Ø„QãÉ�ɦ˜°ã·~QT™²!GF¥ÍRGh5ô?ňËûß}ãg¬¥"³ôAL‹¯0B÷¹PZ‰ä¦˜¾3—Á¿—ëäþ5³”˜{íô¹OS’ò™êÞ2f§)Z ÎeÂ[‚fýkc¹"VFWÌájÜCÈj˜ ¾bEÅðöp v`’ R¢�QV|õîZy[>gbÃ, ¾ëÉ´Ž>ä.ròÑMéÿnbAI7²¦­I1½é­bzZÛd‘Š…v½îCÝBï±>ý­}v‘å6K@/ÿ}µé¨GTƺY¬ë ‡Œ`zDYÈÅü;—ócx&z- >^Ey÷®ºøi cÊó8°C¡µ$7þõ‘‚[ì‡6µSå7)…¡Ï‚Ö7éÐH§;Ú?i+ç¡yà|4Ne”¾o¼A:SWÜLRå–(GkÔ#â•ù¥Gö%1óitËìóŸàÙ½ì®#=¾�þý¢Ï;÷”NPfIç`æÐÜrþ0·ìŠBÉ-+iá¸ìê…kHåANæü»3®Þ�vlŸœ7gš§ÿû6t‡Óô²¿RiYà¸2:f›ÎdŒ{¯ x:œn7ê67êš 13›—D¦tõ SbzíÙ ²lä¯à8]&vF‚Çñ¸ é­t ÷¨ETúqWå^Åñÿü±FïJñ•ÞnüºõFjðowb­Ÿø.\FÐ}UÎ7v(WËzáTVNK=3ç.¹t$ïŽ v’‘C£ƒ6/ãBœ$½Ó› :³ã>{˜ì]¦œ“q¹câu¡H+Éö¾«ÿGáâ5€‹W€q‡E¿c-JØõ@wþt]¶£¡0höÎ�Ø_@RÕÛ'×ÄšW°J+Û“çk%6ë<°ý9—fÒ/ ÏAYMû£U¹Oûb‘×N#§‹æÝ8/ÛQŒ‡Q¿®™ç]N™;3¦ Ý/quD~¤:xyë¥'AÌRÒvC¹†—Ê®]8É>‹®€)¿:Ôξ°Z¨Ø>­Ë([.UE´â …ƒ9u+éx G«“æÃeìèYê‹%ò‰ÂwM rI•i< ø¸´so+03aiÂgÇ<M—ZÈßòë*·“/ú =7Ѧ«Ûj]ɾˆšÓ¶gÇÄzæ’UÍdŸqCš‚Õ8]J½�&ãÚrÖ¯Jo;ôÌG —þÃOf\£øÂ`èÃE³¢SÓ¬õNî470X¢&6 s|­ºYdö,œÊNÒz—ÚXû¾ûB¨ÒPCÃG$w›÷2Oz1#]=1FAŠ÷‘c˜\®€ pÊ«|4oFŒ< ü=WíÍdã!½q;^™¬åy+T9¹ãd ½/-Í¿µH¬f{<±Ò¬S% À©vB›byŽãá䈯9(…´!vìŒq“Ñ ñÝíŒÛ?ÍN%wäÞpã+JáÌüBôÐ>Nð‡h;£’‹ÇÖ�äî•&/B?Æ'¾ë½[¢:ûY�Ü”\MyT´ƒyÛT§48_•¶]„`(Gˆë½7¦èΞÛݲet‹˜:Ùô±™(IüYŸæ¦é†ÇK =£3j3èíáKhÜÂcø¦{ãÂÚ’Q/Çfõi M©¾ý‚ƒ¥Xuœbñ²¬™UèIÚc³ ’"$•¿˜wêáðž… ,ÿhßÑ‚Æ�ÚÞPø@–¢¶ pÇÑóYZ…a!;Ñ/¨ß5s emœÞhbékãêu:sÉ0,=èö¶žr~'¥vÛ\(—Ûú×ûû|¦¨•EÛ3Õ#›µïW°…â¡Ÿj€ÇëÂ-Ã`ˆuÍÓ˜Ÿþ“9ê\ðFZöµ—“(³º‰¶þØ ÿÜÇ^ø ©v.y«5Å­ºßz¯?ªÏ›®â*ø殥Rhx"·TÍ‹ò8ÚÓq¶ýôR®_Ÿ.âÙæü; î=†S· $±U5ö­NaW´à{¢¯?Õ ¢"Ždpåx >¡NGÇáQ6vtÄâ4¢?¢‘ŒkPÈÏöÑwžBj( ;/iá.ýF¥óa5ž�¨Â9åü%TC`+]›ûzÒqb·­¤”°Zç%˜¯9êr%žÝ Çù›çÏC)×H-ñ—â cdnvˆä¡ù˜ÌÏ:) -Œ­CÂSæ†ÉË—öRVøÂJp{ÃÑ:šá]ìÆ—v÷/ak‡$c5Œ”Ý×^=—{MŒFõ-Wg†‹öcÌ¿ÿô=•ùUî²e¼ùô¢‹+ µ\�Šhßàâòÿ Àãÿû3ÙÛì‰cók4ý½ªzìŠwVõ÷T?ºÝšh5tŽ¼õM‘,6X^æÛÂm0ŽÞÊ{1¯SdÇ<°;¶•á²•Õy”¶ÊS…ô¶êúë'Þr{—‡Â÷/‘VV_DôO)†¬Å •¡å=¸¸jz7´1”€M×ö¢Ds«u“î.b]TEgÓÆøCSŒ0"SCw–}Çÿfå©å‹Òux—[Êt«ncìW´ê:ÕMÜ$-£ ë†ãšë>™Ëç2L¹L&¥*Âþç»ñûøsÅôº5»£ÌT–vif•ÎÐûhßU^² íuæîúl ?“]2’9‚Ód/5¯ ó¬~,þµÁnmh³ÀmNzgƒ :ΟTO=ÆH‰$ÕT®§Qq±Éãx¸6=ÕÀèù¿æ'âO&ã±ÉEXσµH)®V¾o [(ä…«À¡-M³˜qZTEñF¹ì¨ß ûOÑä#ªrZï‡õpfª±ðµñƒqS긱ÀTS¬Išw÷\H5@ùíÑæ‹/ÈÖxÔnépÈçeF!ZíaÜsß…õã¤u˜G=ÌíLÝ!®tt¶Þ×RJ‹Ä—¦)ÔH‘:Í2>“¹-E¥×YÒÆÃaýÓ¦'µú0NXtX¬Ote‡8”Äeô5mu–ˆ øÙÂSûFõó~Q–1OrG¾9QxÀ1°ªi›˜éj»âÄtíxMÈå«Þö@îÿ–�¹©Fýð¥÷’!‰µ÷úýð%4¥*g|ZSöQ,×*@”3puðž…ûó ÏjÀšÿÀ5‚;…gæmF~×ñ<³åk£·Fk¬Å‹RÄÆžTà§P£ b¬°V86ÍÅ™çW†É-2ÊðRþ¤ÕÄl§fZ®TÞRv(jEÊ!˜pÎZÊ”yß9 „´3Wˆ„­Frþ–ÃùÄòžÚÔŸÿR"ø1"£Ôâ÷ ðQÈ/æ.´jë(?Ž¡"XL²óòÁ«^°«¾Šü76n¦a±¼í9ò`gŽ¨ÌOaÓpy÷¯*Ãta\[X¯ëÒB¶ÑìÝ·7ÆŸ2à~ëC÷Tz3�“œ¿%^8qóÖéÅ\ìK„=^Ç™º‰€*2@PXUHpSýUU· €âL;£ ^Û5º�ìNéˆTñÿ]$ßáÂফˆ»sÈþXv6Ó¡Ãz{„ßï»vÀ€Ô“#û‚(Þq3† ”Ëuu€˜¾~Ÿ d±µ@Äú‡}gÖ ÆÌOÊnÌ;òòÌóÒƒØ ¬GfÛ›,/¸ÿ¼ÁŽ@ 7e2î‘Ÿ/ˆ:µìHQì)6gïÊð-Dgýº9�ô è†Ð]›¿èç7®!¢Ë=(½/}aåÈlÒûåÍd÷W?Ò·¨mÛ w{ZXëF)˜¨%šóé¼÷zˆ?àܳ!x>XÅ: .Knb€<ip÷/†·ˆs ž^8ï ØÇ„½‹Ï½·-ø¹›-Œ3_%Àiôª'µ]Ã2§|v7øtáç7­J^Ï9lÒŒ•+½üòuoœ-“Ô¾k8èH4… jûo´èdÖæ¡æ+E=³tÙéªùÓ�«“Ä0¶¥‚P«øÛËT(1 KüŽž›ëÝý¹rê ¡<Dû�¦£$ Òî]Þ ñ¸<öR´!´aë±Sí2íh=k„¬já>ûÁ ~ü¥ ®Jÿ"uúœôW½¿!à,×UÃaÚŽ´–MKG½G¢º ê‘Z›ö`·èßçËŠƒC7Ð.˜â56Õ»×ùíòþoLØåÉ�ºéggLêaö„ É9g`HÏÚb ‚W†·ó7Ï2#XÌÒðË2gr‚ª@?s‡ˆèön|Hë³u4ˆÇè­ÚtÇ¡7 íwÚmÝ:`ÅâG2Y±Gr™óÊïl¨f6¬µ€Æ‚ggél•¬ÃútžPR²á××ÿÒÑðßÀŸ{8G‹7L-¶×d{õ5Ai¥"qóŽ¿�t¶æBj¹ tÌÏjÊÜ°ÝM¿»’£û{(—f˜äømÉZ4ˆÆaŒ3 Õåé£ö:E»@š]’zne"Þs½°Iñ/ÚF7™ Ä÷Æ€ñ#«mVFqãU5é®!lÐÉ ñjMYèÓã\ædŽ²¥#-Ïkß|tªßpOÆ!L¤S— ìn£vm€;(îé_ùZ,xíÈMË~Õÿhã¢mö>‹"˜†Wi¦¤ž%‡ýÓ‡ÂÅØ{ûŒ¾J0¬É¼ uJ·ãþ‚Ó›v´D_꼤øþ¾4œÞ©ãf·3x¥o%íüåÆ@OéUpó’’r©ÂËÞ•o†Ý¸ÜAZ@_“¾`§P5:+¡“§¹� ¡nÌçÆʤõÍÆñ̼ð¶ËÒî\y´w–aç|U *:™¸ùúü®¯º^¥iH,b®Óã„ê§5(¦»uÞ)^XŸâíëÌŒ@]Àv–<ž[n}j“r×úyº¹þ+¾˜1,0WÎ*Ê©=°Tà±;øNèßoV<ÜÕŠâGbPaäd…§³a2Ý%vÓ¶1Rx¯�cƒÅÏ)wƒ|ó6°¶‡þri€j{™Žÿ¨M[T¹e§,ÒY½†Tï»6%Ž'y{§×‰¥ŠfŤÕv†[MŒa Ûì;�ø?/?·‚8Ñè½`±î½[—ŠPÐ19õE”÷º/)(<’Ч¸!´!ÁúõÒ:t¤äDüù×Õ,sÃÃÊR¼ël,þw]_ ù‰73Ãá0x輤`ÓÞ‚,B¥xê�<¦§o}.ö8óÅŒ“HŸ ì<^#«çqùrèÝâ¡ΣĮ̂E,Vs/c|i€&¬XŽ°Íóiç%Ö2ü‚íhihë¼ü!8JbJ=-Â'MCJµÃß°›“Ô<eÊN£j«Þ;„§´ªSÏ’<n^E"²iÓÞ×èÔ+Cò2\â¨G׎cëæqpóee=³Ž YgRbÅsè¤v{êî d?ØI}„ '¼‚hñsR„5zƒSüjÿÎâ÷@ídÓY83 ˜%Xñò™}t'Îc}ÌĺK7mZÖ VØMÂ{u”öðˆ?4!hÉIqô“Ofe”‚¹á0t9[[E¦ù¿÷^pº^ÓÐ!]¡áúêïny¡ÙÂBGiµ=c ‘±È¾ ˺ÛPc~€QT£l¶må§O·B¹ 1¢D´‰¢,äwsá‘p^Vµ†ÅEé €Çã‚èƒÇ@„fé5•ÚƒÉ¦tüÞÀ ýqï¤eJt´è„X6t´ìÀKh#Û‰ÇÜ«¹’k®êccñÕ…r¬‹²£¡ë½Û3ZCGsàùü#}ŒÍ‘X¹q†Üá"†{h¸e…Ø¡˜N‘××ÇÍ›Êú»ˆWÕ%¥Çw N)ø$XNroÿnš\6@ h4-ó& ÅXðÄ{Ð⮯µT4 »Æ4übA§¡on êp·l.'ű£ K ˜«ïÐȺ ýNž]P. û‘­«»€Ì”„'øáWœƒ[Ae)m@ü£½{}Ñ\-l#z‘B¬3ª¼›T±ˆ±3ûÝ× ÷]ƒð­t8sÇF¨ŸÛÐù‘NŽ@°é&}àaÃçýƒBsR>KŒcEMuû0ÛN¼ðX;x<PÉËäÉó(GUçšä¸øáÃH¢KÄ"çÐó(>ú¬S9Ôét,ALÐiiÐÆžØÄ玂RIl‚F;@ÖH%=+ÕnÙÚÁdöÂ:N«™Ô8æ 90ígÓxQj™”hP!>AO<Ž_5½YÔÎbÜ‚yj”¼U9ùO”€ê×€;âÌàEeLÛ^÷Û_3¢,U–YÅËÏ@|ò­¥ç ÄÍ°¶ÐõRl“‘µ¾Ñ¸Nu¤#À£»¯À´ù³[´hîIQŒ´¦0Ò4s£¶¼(é eoßðÒ²?|ë´[›¬ËÕ¡éY †RÛaõýÀÙÁ¥:ßê ‡R7L‰v[r~Ÿú"…A  ¦fÅ…¡_õ.’ý·ïþë²,¿ªÌBã0ÚÍ£ÂK‹BAu¼¶Mï¡4?ºÈy×F¥`¬Ö´CÓå?.„!™w #2NŸŸ½l·«æÒßuÌHê2·àÁ2ºTÂ*½§l"IÛº!Pßrª¹™¾ß¹¡êúÜß×­+ÊÜLWJ çh¡ê_’4×*½€ÊÍs¦Ž%kàôÜÑîâäúöç–Îöñ¼ÿ6îL-J ã®$û"tf59a}/»!d…Ë™s§kª±–Úbƒœé¦ïÑ&šð<:Êciò+%¯d5Ÿ øVõΗL8|øjä·"Oo�ÚÑJÕƒ5ÔVÞ“ ™&úþ$©Ü<º}µaHÞã#ÚµË/«MÏsëèÔ0wŠGÙÿ2¾u‘çKî4TQušŒÜ3-ÝQà–Hü œq3«»Å°ÇżJèë$lqà NLz>±ºcûéN8ž§íªß­×ÝDab´¢¯½ï裖ŸÿxìW,97H Þ!h ­ ±Q°²„,X8QôeÒšWžŽqœCÂ` µ;®Ý§¾HÚäÛ[ß�Riò‚Y­‹Œ «Æ̧1añxÒO<Ü©vì¬(ÿú;Yí< ‚gbþ®ã•grÅð1_Žgú^ìúo²°0,~I_oP}üL¥Ý´g­Þ¥'VüŒ~ÌrË|¦=Ñ×z¼e1¬µ›‹¬Õ×ù~ <8B±;€ÅéB!_j3<@²\L-#^©RÌêaüýâ§ãÙHhAYS„ ûÁg¶‘çˉðß©ÎKùD,róAU[«o¹Æör…a-¤t§šw+PªãÆòÐÜØtÂè²ÿ>dw•*×”ÄΦ’T: Ú/W=³òŠ¢t‹Èµ+¥GIIÝÚ%'ÓÕ8ãˆÑ<èÏdçÖØ?òέ&·ÁÛ3¥—x.Ÿ›û[%]J·W[Úíu°šLøŒä&ŠÄo' 5ˆÕ’{ù;Ý—¼ ¦‚˜n�$°G`S­zø2&*ž Õ®cË:.*çþ"ñ‹Ê§C•'峌0u9´s‚%Í»5ý­Pp£úÃÁ¥—Í*SfÉ~1غàɉc/T>Ïà‡0á“î›Á5ŠÝÕ3@~•È˜2.’ssŽ!å2)+§ÜLhß?éјÙN|1 4|bÊ4fEèpœ¨�j—ÖQÁ˜…Å1êê,|L‘Ö¢…ï;p~hÁmgtm?Àì–nº… ÚpñÕ_»l‚wyîg¡Q°ˆS“þ„Ž™(õ¶ï.V†m+R‚ò<ÿ¶Wg>;“ Yy}ºmƒw7=ÎF³g%hQ„ï‘ñžnè^“?²Õ¿UÕÐ )qjz(å l˜üü7:‘÷Ä*pe!íÑhÁ6ìú.Èa`ºÑOúç� –,4›kã$o~´¼Óƒã>ú²ÝúË[Ôù+JˆîfC/ãIòa'IèzrH sô]8l=¼ÁÜnveߨÌm;®Ø¿C†rÓ.1'¹ày–[…µæ¥ÜÓê£B…ÚJê,suKýJÒÌ0£ 9¼&ÃPîßɬÑ%=ë v 7¢½°Ê].nH¹×GñyÜ€ÖäÕô`ñ.QÄSeDÏ«g¸­ì ÿgn_ãÿ‰K{-œ­ÂîÈÍÚVq”•@j&æ\Ù˜ú"®·ðt{ÓÎUè`¥©yŠLÐ9öthUìy›Û¡iù¶h1vd®Êå¾çª"spReÎsŠÀ  mºóèmJÑÓÉ¡Ü©ì<b¼ò„äïU(âØõ´– =ÄᎹ×ß`¤ý{³Í¬b6dX5”�åŸk㿲: ÜŠ4Š–Ckûcüü‡ÃQ`?A¯09Õ½ùàÃWŧ£v¥lïÒlÕÀ÷í# ãÍ%“</Ÿ÷â³xfÊtõeý©ÌÇ„³u¨5¡£pnE²àU4n½˜}Û–Ò¹ñèÚó9›(\iîc´åhà³ð•Á $…ýVŠñŶø=¤$L4Øî`G¼89ØWGëÍ R‚KŽD´mª(Ùnœè&` íyÜ÷¸ƒÄ ÿ»ì¾î›Â–†DÄåË0”2©@«êz$*á,ÐŒ /} §ÃxÇš7^¥d^ššâÙ’“›ÄÍ{OçÉ7_Á_ üù¥^ÍQQY6kyÔ +¤”íwºïzîÍZ[¥k„j×æK ïâ„ô_úñ´¥öeTŸ7¦ƒÌâ¬ÃÆ؉Í;b›z|‹‘cÍaô®$¨Ñ9ütÁvfwbÁPyó¿ohÍF=´{»¾„w g àŽv–Év^–ÄÎÂHYl ¯zØÉ©3%)Þ¸C¹Lÿ' “iñ,%È~¯ˆ“¤ ›‰CéáSßza˜²Ì€ l)5áf åøÐ_~/åsfÙHvW)¼–¦HôŒ;1ÔÛW¬U ÛVà·å ó»ý•HS˜üN×9o霊>=´–ŠÏ64Ø·ÍŽÙÇ^çï„•âDwtîÆ›Œù Tè˜ ìfôCþ_!DÒ<Ïg„¶9³)ý[fS\èçïQtG)|öG)tp"¥vìŒVŠBϦ;Œôß.Ûf\¿ y”ÕÞñZ¦ˉVR9.ã-“”òhµÍHÀá¿ÓùØÿÝ7ã½ßü)c§m·€s æ`ýNZHfFhE¢ʼnåÕý{7xçvË% 1•ýÙ@ÀÈÂ']î™~Ã2=¬N‹YW¨ŠN—š˨"\Š»? õáÖÔßv¡ –E× p°¢ {´ Š÷}óD4ö�L__œ{8@ ˜ëM·¨h§ ˆ( iéŸGt³àgâVq ÿàÃÎ@²´6ç!û+ä[ð¸Ï³Þ ¥Y0‰A'‹ÉITû òdt¼ÏðJ/+äûÜm¡j6}“GõI&(…ZJuò³"u P\–Ëæ_™b?®µÕ¨jÑ 0çq°èa»ª òƒ¶eh5Òý 6 űý÷¨Ý:$ÀæÓœà@®òàܘÍnOÚÕVGêð¢k>üÓè\G®û®íÂóÈŠ™g¤±4&Ìà¾ÂÕ›§oÎ;¶>Áê“—®™æãtƒ Hã(N@e{7y¢ }ÒNâ÷…—*L˜05ôÝN71,ð—t\É:^ㆠòg)½YcWÒJîBŠ 8 †}ÎÀ¨/¯X¾dùœÚAk+dúR¼·<h"$ûŒÃ{Z,¬j9 ÿªfëÁ\lÉ1m©Äåá¹å7Oø•i±0¸!ˆ(œ!®6u¡A<�£ˆØͳ¿SŠ0J%“U:B:½M,XŽY…4Ú€¹åæÚs=D/êU!Îàš}ú”0ãÜù„jÑûFý+¤ÒLƘ; ˜½i_,ÅLÚbWå]¨Ô;v³’æÁõ7mlçp[¡=–Q°[ײ¿:Yiš,;–éõ¯ßAÿeiqÏ8 ¡˜,?Mê#ô[|tÜâÛ †¢óo >™ñRlj£pÖ›þ (Í㯃ޫ;ª•IîT¾“Øé2\Ø9åS6“Æ÷·Ý¼î÷ÃG/òŬ œzø°(Z廣Eˆ—#yú~4æI-I?&7® Ký€1 ¼xg{•a–Sl¦#T¤lh-Œ½ {ÉlzzЕ—„p8nŸ¶ãƒ‚Ø…etÇuÇjx§ñp¾×zJãÀz⚃=êã1ôˆé¦PÌÜyeI§ì䦮״ð!?B‰ÊØï½q“Dn0ÍOØ%pïùL‹¬ɇ²ôÞRÍêƒ3VrþG¹ŸÆÊ£M@¹Ÿ¤UÆ$¶J¿@k¡ÜÞMt° Ò»U?®‚<¸L•·gÊ"ßOÞÃ[æñQ>Ñ¿¦ù‡æXêäì/-�ÏááÎSæ!â>t¼þÓ–Õɸ·ð]*©ˆÈÃ0öÓ!ܦ—À)â%Öƒöþå·lß"s´r¡/¡0€b^þÕ Ë';Ž£ŠÊN“ç-^t"ß0šk&VE˜Ø'E/~(^|I™9úD™LÚ¾ÏL)˜{¿2{I<ÈLœ– 䄬S†*”àÌ`ÄuéXqŽ–1 gYç?õ˜E‘‘%ú¼«‘2Ù¦7s—e7 ÝéäÔ­+ðCwà¸L-®,ƒ+¥¡ŸÇ€«¦òÞ¦Û‘ <½CÆ ;ŸÔ-Ä ElÛ_ò#hN+΃­æJnfõØ"yÔ}ÑýZ4ê8»T·9F9—›D_èó\êþè¶ÝýÉAµ°{�™i«Äï~ÒVYïÆÉ—ö˜wKŸkÜ-S=Ž2Ó×YaãÝXj§Ç·;òšÕ ’ý®u  C­˜Ë1ÙV"TEÑKXº7œõÇO`Bbx[G—‘ö`³ .º¯»0=|Ê+üÎ0Ìó›"óx 7íÎaÖÜ�ÜÛ1L' þx©³O-M�%-éìüÔùÆÄt—CýÅJ8y^ÙoáŠÝÜsºÄ*‘U«¿ÊƒªS(ÿ‹2/ƒZDÅósÚviï{¥bä<´ìJâˆ2¯n»4YX'ga`*ÛÖ¦ë8È[Ÿ§mºSÇA$·Ù¬ï×Шp"™.ÕÀêWÅÁ΂·Ð0Ò(óf¡¶—Fr4ipžd‘=‘Œ­ýB”?PQT†’åxüå‰z[àèpxâ6P£ÿzøp™Áü§øb½/z±ˆV—<ÊOÿôý¾Ùñöñ:øÑ7Rä4Cl<Jøï O\w“u¢[!–ÇŽ ½º°ÿz Ñž\�ê2n!ŠÕ]ýa`Ì=ÉâËàÌÉÂØÑÓ›öÃÖL™Ð‚FHÔî6 Š�Ⱥ U;Ó²a“¦Qîek–ØæÀ­Q\4vï}¼G㦧ÿÍa¦º©˜“rßôûî™óf 5_Ác´Ë²MYwÕ'BCsÜéû}Wƒx, áÏÀ˜'ôÐ6=妽Ž€´ÿÀS]K*X"åqõ ¬â'ÊHWa<,4â|f¹(£qaÎíè³ÇÆNI´ö>8MÃè|Ý™”enàñ v8‰²v4a�8©h›ûïeS‚=ªKóé)e˭ɾ.×?˜Ì© ¯ ¿<%.g.$5;ÕæÞ¾Š©à»=ËWêzy.ç1 iå-0!]DµW½‡B`ßÐ;ÿK;¢<WNZqg(š&f #ï;VjÐËÌ`O´.DžŸ>B‹ Ú"ƒaPËo]HÊg&K»d ûqÖF&ã̼AÕ/‡fåÂúBÓVY²îHë[°€ðzN¬Pï3Rؘ÷1GEbµ›@²(îZE™‚¯Ì¨/†0•Ï> æ·NæX-abJéOvTäB²€$*²AphÿÖp¬ž}~:ÉY‚øËC±¸=‹!»õο¤:웲Îð-‡ê3=ÐAý†q =c¨«0)äÔ þÃœîêõ«çù:òþK±N&†œ¡©M+ÓÕ ‹KpvþÒI”ÎQ´ˆà$TtªR$0 ¥¨já3_“ëÃ!å«nÎPþѵ¹Îrƒ©O˜ SGåú˨WîÃØw0ôR¤‘¾_1hþNë¶\Ì �T´1&×1)Äd~R™*žÄ6yÙ2öP_ :ðæÜï6 ½NÆ·Ä+ùîZ™ìiI`:ŒøéN�¡ö×E•Õ꺧âc£:aNý.ɳÐÒñç—%rb$•ªbÿïòK{…Y «[TG9îæÎÖ.<•ƒVF¹c”l7ITnuª˜W2df»³T¾gŸóŒo›v-—°\1Æ ûÃ4é$}8t™£íuhùbVĦF�<õ>öÙ²U¡H<É Ûü8åÕvâê‡Ë±éjŸmAó ]F˪±Ž[M¿¡ƒÚb¿/×^Ù‹O´6Rcsz³;RÐZœ—ÆÔuf>|¢ÃB—†¶îSÇÁjaü€Ð-˨¼x£tÀ[úA:œ” àÜüÅ €H‡ý°A°Ø´†ÅÖž‡i×{AÿÉÝi‹Éô4ìB³¿í=•Åb Ôõ@‘µøTF$|0»-xžcå¤ÞK¯,„vge–µ‡õKéð…ÛïÅMBÿ+Ü“v×RN«/? C TåÙ†,‰2O³©œÌ°"Óxø½Í_ùô ÝèÛj')‡¥º˜Î·Këµ ÷ÇfØ5oK¨pÓMùÏ› Kô5ßá£1t÷Fï'ãê\C0“Iœ7ÉÔÑ}÷’X¥ãuuî×km\ü¬ìXú8·pæ›3½QvZš<ouE'ËK/üÙ›¾Ÿ€2ï̽ÓÌÙ$'JH•ÑÄú¬Œ‡H¦-ýî<±zÝkƒ‰46FŽì²w¼nÝ¡•säúÀÔMçÛnípØáê[ç!K­C2p—…³âŸÎ(øÓ§ôWŠÀPM4˜Y_ö_ÿžåÂ*C½jâŹ5N”¥Í³,þh>÷9kÆÊæß~Öº6BS·Mº:J} T› |4øAÍÈhêÝ®J—npuE�õNµ©¥¦9ÿÐùËPjµt ÓÃõx2H œ¡[ž·ušf— Ô*õäsDVNÓlãˆR•ë ä‚Õašíô# zhCbR¢&oh._ËÜ<ÇE%¬ŽØó Á�¹\4"øü´ÔŽG‹ü¶ñßQݪ†Q¦L0gg"ð:QÛ3×ûnhwG[žÙŒ;Šå¥t“7Ê7ã§ãuµì±æþ“¼¢R“ÐÔ¡— (/ñfD;(N•£w“ƒ÷Šã²HÙ<‚Mç ø“«®Ÿ�;–AÓ“až3caö˜.|@gÞà[ÉCOH‰Ðн+í¸eµ“‚Í=úšâ`|j¢;Ï]cÀ¾¹póú£ã%9zu©fU  q¦ÚžèCŠU©K©FÞtÓ¡™ÎÊ7Ëdfñõü!¥âÎ-º oyý ·º/,"•´¾ùQ�v7Þ̯†Õ"ûsÉúL™ª°ÜÜÓ�¾ ŠoÛ•áÇåùŸš_*H:¯$éÚgè®–ôåëA‡K¥°ÅYøN6ÃnTÂCãíë^²×MT´A ™˜mójŠ�ª‚^P­ÿÞL{-$2›«ËÙ9�mÞM²ˆÊF™E¹$;ÈÇЫ‘g¿ëy±½ì•µH­‹EZÑôœÞ}²içP °�B}EÍâ0cÊòD%P}TÀ_ _ZÐB¸Q€ýˆ*½a|„^Ýv#Ê™…‰=}Ô/oÄ<ýAèP~úé]e�-ˆAi@�W#àøøkc¨©t nšëÀ=wy†Ï+ê¬ÜÏ«¾>\µ<šÀ†o«4ô†SÈg_iõ…æýÂqè–T`çÛÖ8EQ¾ƒ‰ ›6½› ò·{›Mùnta¼½€½A3ÿd{r|"™8tø"N¯å×ÔèÆ9a陚B‡ïÆÅ* Ø÷p/%ûÄR%¾ÖT‡$Þè6‚k€ªB(ÌóN—ûY´˜(å:Òžo£qKïÛ6o«+—§TüßûÔ¤s³¹�nƒ.æbøÔ¦ tv¬a«5.ٌ̼wu gHҬ̃W'w}€@¼4Ž­•8ÍõÊø§H:^Æ^-9zþÜK\Ú‹‘Œ{OÕàù~ñƒ*OR›*š¥è÷`CÌ- xòé5ü¤Ã¥¨ ½YÿjzúZŠ¹õ½¤Ä¦®¸£å `»³\21Г‚(¥oã±kÛþâÛ]熜b3 §XDyûnT€:X2+ÌÁÝ”×°êqÛ% *@h‹­½$ÑæíýMˆMÓÛÿG—þ¿Œ':MÁÇëo¦Ø ­Ï 0Ó3€2ÊÃu;…s†ÿ¼QÚc¤²S¿ ÂâÝþ 0(ÉÌ@’'§Ã¥ˆÒQDjè,ßþûV{ïCþ/³q_c“óÆP6²ÿOÓÓúò]熷Nß\Ø.š{:ôW€vˆøé+-õTolêF KÁŽÞÊŒÙ2£K¸mšwþŠG¢o-ÅæîÑomIRºà�óÓ¢U¬zžˆ#¼þÐnyíþÐq¥ ?–ãh:Õ&¬‡íüÈ™48”Æeâ5ÙtÏ6_.aÖ}Ù Å8áqìåo#€@,ÁßžJë…O'�1¤{éºîŽº}G©åc8H‚? ¡¹1ÃcW¦„ÿz8ÙÜåncBèQñEáJ¢�Z ·¼ÞÚT…Üþ>ª(Þ*#‘Õ3mâùý~ÂLC1“8Ã]…jf¼§tª÷‹¶hêÂã›T^˜þ¶6k& óœßš±(fbCÉL£ÂÛ5çŽ"]­E OÆ3±påD3ïôØL"�ˆBZ0ïÞ0¢dE[ä[ X6 ½åÉ œUV±�]àMÛé&@œOBWv=7Åé®\ÍSþ©ÀÈê…•£à*‘Cð¤ÐãÅÌ™KÚWNy:3]FDª£òKmŠ™©aüˆ#/´#ôåØ¡T¼AÅå¾錩)šø4±ï¯T{wÃê*{ˆ5ÈÍ€1U•·¯ÆÞ®tN{z”u;ª2˜Ù»½BÙPi¦`û|Ì‹]òhÑ\"ÎDéh>ϧݑ¹ÂY<ì*\qfõ)›ºLY/{s,û\-\Ä9v¯yÿ% ךÆ/pKË2Ê5ȃ8¨OßE—j.~Zxµ™³nâ¶VàÉãYn÷Ìf½ÁÜø¥bmß™âJ÷•EÙùìÌ•£˜º9ÓQ0Ñìø–Î^|Õ“¹¡A`„5¥YT¶­ñ_†ëFՒל þ­ã¡±®¬Ä…™þØQñéä¡W=|WþñrjT+cÁÙC×ÅmOÊÉhw~`¶³›iÒ9Ul #5Èzªd:F}Y-£j¦¶_E[z•ß© I“0Ô(ó| m›~·n¾à°Û ?ðŽëMŠ?àYbñzÞLZ¢°¹ð�?øi®Ôý­ß³hVN¸�ÍØw¸è tBI«‰ˆÕZ¿jÜ”$TyÔO l.UF—ïx7ŠïçW©°w=×Dîå(›ÃQŒ. òÚ¬›bˆ7Ï9éÌ;Œ"ûˆ1~ÙüãÍÝQõN×~'¸ �ú+tW]Z•*ͽÔK»±ˆk5<(µ V9ãÚkÕÓ¨màŠ¢A•60¢/Fmò‚ã›hßL ªYºD«ü¼DE{ùT´œ�æ`ót¡½d#ãU G­™Æ"ª\·6azŠØ³úõ÷Œ,n錠›.H&§­i-š½WE 1ŽSë€G•÷Ç ýÅñªGû‡·âçé bѨr~¸<X85ùñƒ/‚ÅÉ3Ê|Ø€Ýh&½Ê€oŒœ;©€H^Å’x9áBÅN<eßµ+´FÄPKC5¨¯|"~ëJÝiS ÷Oµ]b8ØÓê/šQ ÐTóù7q ø´ÛÙuî¨#@–‘O£ HîIœÔEÒäôIÁ³9…>6=V6ÒmÖì6ƒ3Î;½-8umùéiß[Ãa~]AÜ \cÓÿOñÿ£íM–[W’mÁ1ò+4«Ižkè›!@€‚�nŠÛêÿ¿£|¹‡G؉ÒɲgoÒÉK‘@„‡7«Yb©ùC iRݺ=,zû½?kÈXÀŸúôŤˆ+¼ÍÕO×à·<ôùIh’³Àɶ•ÖS­VvÐ4ïôf×—‰ÍtF °ì…+{D™úý=ÒÑæ<…j,0“?²šË ê„ãV±®Aòw2»¯Pê¨Ü« SyѨ©[”ä™o1Kq~árœrî3L0LVa3Áàè›PæO+ÚàýÿïÿsûŸ<`iÌy'Èá#Õ?ŸK�µGvzà2×ò8­×8‹ _ '9i—Ò˜v_YP¬ÿš›ƒ¤çr@À|ƒ'´p¨fˆ·½q[• 6£ŸÎï­µe GO‹Á^"BEæŽî´yíYçdøeÊi…ìtýåx™Ÿ§º-¯ï‚$å ?=Ž 1}ÉjÝMehÑXÜ2˜,†›WBmÃ@EÃçÑ©_(ÜM*û®k¯¸ÖÏ:ùia,rlEL¼ÊÙO7¤ÌÔváZù4«»t+‡º*Í›Ê&×£O;¥tT:ÄFÊr �T°éXØì.ѯKÌø2â±·c¦”q(´5?ò$ïÕÈVP?XÙ`k¯UÔ†± @ZQúŽÑ'ŒM$ê ì6TÛÆxÒñÓyßé5ô¤ºCáïmµ‘¡ &­ vï2¤žhˆ8\9kg‹»pÉÇ  Îdb,A槰Ëû„Ö“˜B–ï*¬H»+3£âkz”÷ZB™Üc}`f ß*&ÑEÏÉŒqƒ¸r<½ï|*ýcÇtˆÀt�rGÇÍ\Üû–éNk‚V¡LçzÏqe<I…¥¯¾ä¦š%œGøŒxžÔµ¼áv7Ð?ú¼¿ e<Ò»]xŠo D:Ê.šµ]’N,…蔥¿ÁìE{3³êjäî $ì+$§qgÑq‰ö\ZäמiÔ3ÿ(Íeê±PC£òÒy'Ztô͵rfsáÞÚ$ Vˆ{²‹qìÁð`bÊúaÕWíѳûNo›:ü Q,%c�>…o½Š)ÀƒúÐ=øZµ‘¥>öwþ�¡ ›ú ÏHÕ4wÅu;"ßš¾iƒ•á•æÅV8Æ(*�ç:$T€ÿô(KÊ"ó•¬cã9e¼ ›Û‚nh±?1Š²…Ç!âÆ> ª÷/«sÉê –œLÉ™ld&>ðíSåÒø÷ôý«£’áÒÄBö-”hÃÃ7|¸çìÇ>#™>iÛƒ8ú6­âepú}«Ÿ»—¾PfäQ7§Œuk6Ș¿ƒ(Ï[/– Q‹GÞ¼q±ä!ÇÌCNæ­Ê½±”˜J�nXâ¡ÓyÉq˜‡>ÌV´$³öÓ; öõºc-Bi};«Jsƒ¢ÜÀ·Ù%·Ú¨Ð j²´Þšþ$©+í:^![öØbÕIµWœ»ª‚UŸÊDÄÊ�þjÖ¸†"˱@ ½£T²WTQ’ð ÚG±þoÍKqa”‹Vëݨ“6MˆaÄô<ã“{í`ÎIwL5NAg„o ­:…ù&tò0HT_9Ã÷ÝR0 òJš $³v`çæÎÓ»¢PBQ_ᲆ½Û/–¸YLýmÒèJ¢}Fë¯öÅæ@‡¦]‹`›ù—wùZZ…™7ã�Žqƒ¬pØzJfÖrÁ™cÁ¦6‘¦/þÅ<‰;™t‘ùÒ0«‚êVÔœ¼ÒÜÓRž>Lϼ®ØŒížœM¹ÐŒbGR8[aH€^˜ðF‘ÓPÀïÉkûBÛ¥'qÆ®+Ì8FõgAâ+$ƒ˜ £ÊS÷Âåiâzº]!E®è¬V‰dØQ°ÀçdSä8[ˆÏѹ<ÂöoÔ¸RÓyÆKCÕ,u¶½˜xD£íÊ º@˜«?TMÙé%ÐíI‹)=6WSóÙ‹óÌÔ‡¼ÑÉÖ´ô¶Ç£ó)c%kZýºtœ:® – ûšˆhaMçú¸:Ô³ohϨ1ì±f‡)láO€$èj3B2Uê‘ÄtÎWë7½Û@iô5ÕbçŽ2 Öª/æߟùÝ,|È vEÝÒŸ*‡Ñ 1W"ûÇù²Ê|ð6Ò+Jä«ñì»#,"â“2$617"÷cîÉ'.ÈZq°§='Ò÷‚Slî`˜3ß üWsè}pÞrεÎ›Ä áRËfå9Ìlä|×—4íÔkf^rµ‹Àâ�ˆê]Ï œ{°QÝM<Àc½OñcfÏ1»u,ÖˆxÇÙbD4^sk`€ålÈ£ WÒ>(¯tÈ–ObÔÚ»ª§­ßqÊ2g8Ï!|ªÓ 1 2xà ;­Î;0qΚ{2`÷¬‹‘ãVîMQŸ5£ì¹nhÕ[°×ôß·4¬­X'í¦¶»Bd²Gè|O}Ôu%bõ ªÄ¦þÂ7ز«™â¥¿c^U².ŠLPè'ZBé»%ÍäœHÛH…zðT“ ¼®ßÃ5ù¿#ñ70# ¦ ½í§Úþ€•‡PÖ9©³oÍ‘BãºúCI]V[‹‘\ºmÈ@îõ«Ã¼'>‘‚¶ÍùÝP稘è]6«¨ùtàF5?é½Çaég,tŽ‡2¨:«’šóÝXZüæÂ^ç[³8œ~„¸wB,ì•ZÁ‡ŠÉ:,eê¯ïâZ$ëÓ‰Š‰”Mó|Ú¼'_÷öê XõS�Æ�5tPòCæÀwËÿÞds Œà•©ýÕÿ’?¦fêÛ˜u‰bklÚ"¶»^0Šà0‚Ê� ÅÇÃù¢ÿ†ÿ)"¿R;Ó"Èl«52ÓÏ"àA†þ"#.Ê{VFL£¾À“Eq¢¬ÈÉ̲mf}†ÕÝ¡ïò,ˆß5×Y˱fÒ»ëëNÛæòOÛýÓ×ÿü=œèßþÆX2 p‰=¾"'Ñë†ÖìPù×è©lw› ðµ’bAßçÄ+ºŸY§ƒ7rbÃz¾f ¬–e�AÊæ,pRþ” ë¯ç±)õõy@uŠÜ©Î(¿”’ÎÚ<^·›^Uà+?ùÆ,:£"ÔÂEàJ~wNáã5ÆfQ9‘oÙãÕ¶ôeèª= ²ze#+íË<çûÒ=a™H6Ç)cĪ!iPÖ£¯¶Ñwõ_>è ¼|gsÎó=¿ÿîqTÚΓtô§jüÞ¸8R)Ï<˜ Ué’F<“¹ò0W,¹<tçŸ*Z‡s†Yf^¾>|u&CÜ#­Ø‚vKý/åX|h°_ä:§Fèz»ìþlB…aSº/‰aˆà®MZýÀÛ¯Jm³0aàvö®#,ú?ËTýJ['t¿5ÕÛO”ÚÊ<ó0/8§ç‚µí~eÉKr[³�(WY¤íSùÖþ²¿Õzˆ–ó"ZW«?Tð$k{„§¨¥ëö´š­›ä ’YòïÕùù9<› O…Øä´ñ`Ô<¹á¾<ÓDžÑ¬¸MôºÞÕÕ‚)€µÃ0»~‡ÌÝ€äô <ú™q>KÂù¡Ïƒü¨Åt²ººw-X[´7“€§Ž…–M%ÕtÄ’ø´‹ß•t œ}š®w´üWhóî¦ç¬=þQñVÏk‹w—­Ph¹¨)™AV#ÿæT„+Óyã0Tl?= 9„¼ÎµÅ ù!ènô‰òÄï{#öt;FË:Ä¡åÎM›„½‚ž®<g³ÔøhFAö9;yó}}q0KÌô0Ô‘¥ á–O Mm&Å ¬­êyØõ¾<u�JCoǼ+Œ0²Ië[Ú>ÆÍ×ØáåôÛÚJ£9|AÕéÙ(#ríL#D‘mLƒÜOr^éFWZ†¬¨ÁUœ¢ä(TäƒC@¸vOil/¤ÝÛ[Yñl|A¬<ò$À¤)3 t¤ô*¹"sàðqñë¨Y“Ÿ>¶öq_ÆGE…ªgQ0Ò˜µ+3nÞf Ò-Ú‰ö±V‘h¡åØÐâÎêO’9v”ն£å%Ä*ïDä!BÐÀ¾m& ±JˆôêÅ‚*¹½|ø5$y³¬»Ýߎñô(uÛ³H3ßùÀ"å—…–óV¶\l¥“ŸÊëa!ÞƒLÞÐ?éàкù»¿5œ¼ïAê^DÖåž ;-õÜskŽžßt<i+ý6{ÛX ž¿ñŸ¸I¾­ësf$õš¢wÃÖ“AiÁ€uŽÂ?éú çŠÛ»”ìTïk{¡µ½miÒ~§¨ÎowÿÒ6f‹%µ”)ÔAz´S$¸ S¾g•ã~b[`¤©q.¡l H¬,ú³½€ŽM ‘{ó2~Çϱ챧?X»;QJ°«Äô#2õ•(2’FÅÚÎÛºçËfãzW¢Ð2ì&-íÄa/4ëÛTe~JÒ«èOŒŠ!á†Í¢}¦ ò¶Õ`dnÑnÒáç¡Æ|!àCE ¥:á»f Û ^«Ç´m’Yˆþõ©‰X²ÈžÇjŸîè¼YUÝ(3²A›>£5Ñ©xêÁ À]^§#ÅR,†¯Ð"žåì÷.ïxa–¶ZehˆX)¿+zǨ("úÖ£%šv£ý°Ù•^:“›c/ÒÏ­W„ï©ÀD9e;=l½µžï9t8=PYžš<(¿tM˜®òþ4`qˆ.w¬ ×\QÂzw‚ûªš%O¢öˆZ[}¬%SŸxY+ ãG.w@ͮ˖Ô¼‘l¼-:è3ÕL7J‚qs!·xùz¾ aëZiIPÿºQ¬GQÚ¡�näÄÆõ¬~¨‘f´Le •2 ÏŒãn¤èÐ#U®‚¤¡c@i)> ¨È~Âð¶2B†‡vÍA²Ñ©&w”ëó—¯.V›=a{‹÷äÁÜlP,½&@škóˆ)ü¶Œã2\èØ£B'…ûÏ&®Üm‡<iŒÄ¹wðÄô÷ì÷s÷Ú8ØJ&‡…J™k*íÅãx¨R³î)…e‰Ü+‘WÃñåU} !ÆCÎ!ï”ä âB½°ýJó`Þ‰ž±žÆ/âráUB¡ zTï&?u+Ü +?û‚’Mž\IÚöSdVøíɶ¯zÜÏv‘CöF¥Þ4Û‚ï·YStgç¹Ó)UÐ_±Â‹ÎB¥h¹Ù(§í£kîCÑ\ÎÑ7vÁ*öŽ¥¢‘uÛ5Ì;ÿ& -³+TÕÅñä1`ÇÁ½EúP 9/]z‹ü9ض³-Ë8Œi…V—yÛ_‰9kY!H::Ö—2ˆ×½+¤íÖoà¾îõr·g}¡ áƒ”£ÿ$ièŸ ìjQ³·fœ¢,}íáV}UuÝ­¯bgÀ8 åþÖ|¬�¼š2;‘z¼dI¤…Îí§¶îºD2U#`c�©Å¡ñKe™eáÂ9tšÁ¢T_¢4ºª©¾ÿ !¡­È–†Éó„öÜà©(÷)ÑN‡G“"«Ùt0°v¾î̼"‰eÜ»/tîZ«ò …¡q<|§sru¢ ü~oO˜“,Ûq‡ËœhÜPõ·ƒ½O /Þm¢Zhõ1 ÒµWob/rû ßô92Åú¦lRÅ ÂptîóvÉÓÕ3wç£Uì]ÞaΖy•ÅVC 0?(‘ÇﳇÚZ³¾9›b#舛ÌüoCw˜§�3n>ÒâŠ3¿s…“àLéyÒê\ 8ÓsçYãLÛa7ëę̈pC½”Ó‹tŒ÷¿ž·*­VиÕ‡‚'>¯^¯œ1c¿œ å¥O8½[ê*|¹(cÞ!,’€°»ã¶Ó9”m&y¯šÿ:®Ëj˜Îj•%¼)†^†à`iÆ(Îôi`~ªGä3Þ6¸?þdž-8RœsŠž£%‘½Î& oK÷e²>á+ Ê›²öûw‚/«”ß=¥¾ÍÅN¡_S¼MÇn5CÞÝKìÊ\ázÜY®Ü$ 7¯wûØÖêJåºw›„  ÞY%º”¨ò©#龌¦Þù%rfrœvWmMä°J…X¦Ø(ï$~†J²¬8c¿êlœônQa1‰EÝ÷ÿ}Ë -¬›šîTOµž=û7oín^8Yw½UÛ³Û­ô’RƦ±RΩ6–¦‘‹Ü"‰~+“óSÁœ$[˜DFÐ¥PµõÈlÓeì–oBцS{£«í{?ùr{1?öx¨;j' ™ÏËW�“Žä¥ÄÞ´ñ§cý�Rx"F¢ÉŠÊÅx[{ÈÎÍXÛ^÷^šîõ‘€ZR¹tÃŒHh»Ó'H­4P°ûbMyàLŽ]ý±”ÓnºÓ¹Œ¸°ù$ïê;µ¹ -¹ÿ¾E©Ñ‚¡eE…ÇD7ßzáþd:舅JWÜôŒó´­.~ÃxÂâÿ*˜3Þ*mØÃôdü¾ÉóÓ® “%ô5é©;ߘ"Y*éÓ!ËÕÍð9ÏŬ.Giäª=GɸQu¹ 8õìßbÖê­ô×3 0úeæÛœP]Âæuç ûEOr` ‡ù3=½Ãj=Ð_Ê<Ç_Ãaa™¹¯/EQ~#µ«Ó<+ï…h•j±‡Êi:Bt±ñ«×L£“Ú]´ ë‰bv·ASœ‘®_=QNë™= Ê´˜…û¼”˜ëþ@+Ÿ_åÐ.³Œ·ô{³¥;W:ôÏ‹LœÅöpšÍ&›{€¬-l,¤ ü½lqá„ÿ…¾9AØ»·ê"0ý£ŒˆÁ#œ´®ëÑÚyø×`л²ìçù"çÌ‹mÀ²êjçi -{Ž¨:W“Ö×ìO,r;1ª@-@;“†%tC­].g”ÛÚp_s1+XéEÕ(©Ì¢’>§VäM¥ÃQ± Çú´•ù7¢È®¡!Œ‰Ђ ë¼ùk×^t®ó,ÛJÊ‹¯ 8áÆ1·Þwýa¦p[ÖnËL°¹_öù²Ÿ\,íà®2ÆA1ëT‚Åh¶KÓ‡E'í3Ý}QÃâ’µ´÷”díä(î-²5}WqÀØ›åùïÐþ“"[ÒWÁâàåºó†9BýãW;ЃdM¹«äqúЯŒŽJ{m#¢7y<0ïÍÜ64Y‘ïèç;ûqë9ñ–b–K3þÔ=\“ÕA>ÀÃð£óüÿþ?Ó[†ÅæË”÷j((,^äÔh•ì¡:W«f¸M \T(ÃÓ)Ž»[?jæFIê`¬ØÂuÞ½²¨ßí»é¿o† š¨±ª9Jï9žN<Š$óJ±0£õa³µli¤g´"¹ƒ,’ëbÞêz²‹ŸúÔÐZúÇl“f!eÂn!¶oÓ_ ÍL±7Œ:ßâtêÊ® úí¥ ªîèx,b7¨)º”„Ë*kO­¥5ûaʋPF§ mŠ66 ¢'ýOÆ-Zå„^{vX‡ÔAäzéYXè îÓ<×k• K¸ÃQ÷NK%ài–ø‘ؔ弧ân.“ú~9cLVÑžY8¦ªÄHjv§½cÞ›$G8çàëÓA˳‹Ød/¶„àM¯–Cs÷1Òÿr᤾;QÁkþ˵pe¢ÄQ¥×L2Ž·>’О©ûñí‹$ùY—¦¾«U?ûÐÞ¦‡E7Ú ùyÀV¼ÒaÏŸ±CèÉK¼ùkÚô¬ñÍéynH£¨ã)&_½³¤› •ºõÃiÌ<$enfü[÷†w¡ÇÁüo}wàÔU�ô梥~5ˆ2ÏUN…qOuTZo,ž[ÅTêM§M]R Ì$Ù‚ M!àL‡@¯$ʴä¹áÕª{©ÒI"ã‚eÆêºi ÀÿiÊgXñQ‰UOŒ„2Ùª‡ºÉxèŒ*뛆UìA“PĆð ¢è5hÁ cºï˜6©æ®Õ­â_ó}¦Ÿ1¥o䯇ÿÁŸV©¡ä´OƒÜ•%øógö/P #hôåA…kßV”lBÐ(û­ÆÁOž×š= ûJ%õîIë­k,T»M$DE³,œ7ÊݨŽ+°Ù^tGXh¯VQ'ù œ}ŸRÞ;+¢ó2m}{ ‚à2` B6’Ê´S°9Ó Û¶öU§,žìñtH3™X`˜­�ŒÚ÷8¾² DÌ'ôï@‘¥iæË“Ï åTVLJ’ž÷S³£âÄÈ™\êqÛx¿ùEäÑcãŽð1—A¼ýòŒék+ gFEö€3?Ük=Å™àa)ŒpQ·ˆbÐ`qÐëZ¥éW’¸r¶iÄ—fk…ëÌÜš³ ï·¾¿WÝ{j‹C¾wõ›\Ø$JøÍ�‚ôÚb‰+#;*ö‹\õݞſË`XÅ~ÁpAÊõÅË‘fÛÙè£*kŽ63/¿õ¤(4]|…Ú®H‚ì|ö’ðÏhKÄèÅDç¥.\V¹o±áçøŒ³fÈ—çAÜ•&PO`$¢tYEEœY º)óH3·¸Sñ ÐADù?vZ¹ã‰û=ã¸c¤©Mæ’*[ö éP£d´ÓS'‹”ßõÇ-ÎÃ`«hsŽÝ^\=Ì슄7Mt ½«ÊJ šÒ‰3/nʃõÜüîgÀ�²+,:4‚jÖ)Gl u¿—;㤑'¾& íJñõ5œBrf{ÎA%W_1õ Ý”92´Ÿ*ˆNŠáahüÛ[9r†íS7 k“ú?ÝÖeµph|2k„›“eòmÊ|ï ›+åìJ*Igý¦@î†]ÏíDË—âôL_§#•B šy¡¯píñN­4·n *·—õz¼èðZ)»á)¯ÔÁsOšÎÁcGŸ8n¿¼Fbs`Û¤£v½wSÓÁgÁ¼®»A4v®g}‘UºCÍð$gù—ÒoØxaom¾_VÞµöÐÖº´Lm6€‰gb$YNßÑ>a-ø”ºלàâjÀÒ¾ölÔm»fGZß?âJ>õž jœäWVÕÃÑwE÷ÒŒ¢Úæöœ~úJ}Òó¹m ¤žY›÷=zÜG­:)ÖÑ{®ƒ€=U`êy95…üM¥„Ãp¾˜}ûËØäÅ}—2S%µ •¦«7½Íã¿Û)Qá$h¶ ³ã²ÍàÕPìå!çOép¹7_eÑŽ©Ë½ø ¶í‰9äÜæõÂùö‹¼”¤ºgî'*ŸÂvãR3æÚn LŒoÚõ«Ì'ñQà�w¡htËD\u{B^~Æ[ðÜb{ ÕÖ]/by>~ÌÔtA©}‘`›%>¬.—p‚:Nž‰ëÉò§ß±]‡´ÍüközéïùƶñÊ!%jŸþH²ö0 Ü¢¥¾‚¿I�¿³§µªç"û„Ž2 îa3X“ôD$ù Ê¼oÜ®±D�¸»w–õ-j¢ƒ°ê‹ïY £XRô#Ög—"; ™¶µø@ =NÝGäxÚ´ðÊáèY0;¸³ã®Nƒ &þÜÑÓ¹îD¾÷†À¨><ZÕkÍ5¼ñ‹tÃÐ÷þ© Ÿhi �ç/z×hžÌ0)•#†ùf”„3Ÿ­A£¡h~öæRY,õŸ“¦ s³Q8ï؉`î àêJQÜ–<#³ôíx0…—wy@1ñì;ªÁ¶[7E˜Á·V¯«ž¥S*¯û®Å"7/žhLÞqÏ]–Oî-E:¦>°à×n‚?½×‰c§ß^±2+œów•eDÑ~˜å!þ²òïoz Iæ9Û²àúTFÜï—'›(âM’k£=‚ÿãC @¼ÕáÈ“CHâŸïpgâ<uÎ %òK&ˆFu¯ì6x?ðÔH5ŸÐCs7¯cHþy‚NÑ»vÒØpUÓôψGÞÙbBG ðüå9Ä6ÜÔ5ÐéŸØ+>Mi5‹d1,!â”­ ¥¢ ÊMcn¦;]%ubp©©»å%‰mMäãì¾ Š†ÉUÐB§Ry•è±$é_SöŒ•ÌÌ�é¦rý¨ª�装>Ùuþ4+ñó“, ýíÿ•‘Þvš<þp¿ó†¯ù·™©9… ì*ê†mo᧠ö'°/ýiUO¶…ñú\·*Co»Ò~Ÿz ±ý»g°, ~§zÏ ­û/^A‰G¶(GK›+Qø—Œ?‡Œ(+ÉœÒ}ÜSSP‚Úi%6´gµÄõ:FíX_¬ö‰þðÔ ôõÕéÞoOTé|nݼ{_íTOÿß9n¹iOnÎ%™‘mGÇ:ÁXh`º(%w^ŽYÙ5fq!3èüþì]ÇíZ2HÓÎD _½.šb¼ T„ö<‚¹Uœ.nº¤è¦ÿ*˜œËؽiw°Ü}T�w+ÝF¾ê+Ë4c¤õ—U•-ô†1nII¢€N‹™@JEl#ûÁŒÒòÊüv:d U1Úí  œ}šŒTT… –£¯‰óƒÕUõa±/泆Œôlxb¼—ŒOT4[�l?µAWÁè²v�n®ÔQþÑQ V¸3ÎKw(óà¦,s~l½n�gìÆrU¶ån¦O¥áåOõx®U“£Üo¿Ð#a(‹ö¸™%âÙ'Öj@=Ö‚J#¿6�hbM¹Úzv³|«Áö@Ü–Û,ÆÏ<èâÐóo¢7i` GÓ4¬ª@ØmàJÚõÿþ· Eœ$4JÇû‚Väàuš7õn˜4ñ±V¯ L“e«“>öžêS¨|X»m·¡ò\§ÙÓp-~{ñô„Ïm¢-zaMSE];îXü…A×ü{Ï1Ìk<¡ä¸´ r ÊÓÀ:è{Þ©öïEIÃÔõ.¸§hÀk¯Æñ§>ô?P¼Œ¦ðý<Ú>ùj}îv}ò$ÎkÕ¼±|±Ç½}UhnT­!:ôo¬³‚}Õ(.bÃÕ ôY÷ ÏÃ…r©eˆ­©83ÀNŒ†ž4 º³P‘‘~TNkµ‹)”«­úÊ’%/±DlPg¯Ë*óÈ•˜}hLŽQÇÄJ= ~jÞ“Ä.±ª k„ž2Ÿà&PxþàÓ»9ò)Ö±}>õž{תÆ(FB½m½hFoeù#säoOôöŸƒ?ØÄ»Ùa™É࿶ãÐ7m§@@IM¤[• Ù9â0„Ÿ�Š±#{‰Ü¤ŸÌ<nð¤±Æ‚ÆùŸ4¨F;ANdz(<Q0‹_�×áÀõ±c }a~<ž˜*;ÕƒÏAÏ(¬åÍ ¬ñvOÀs‡ÇWHØ\#Ù~¹Úʺë‹}ã¬~ÂsÉ4HlŽ9‹ßÚègL¬4[âP»¶Iv[Óç�ŽZ#°!ú–£‘§¿·]P>$ÏŸ·h¸`ÝÓ´b•yòˆ!ˆ}d£ªû!æжæžù›ˆ[²Œ R„›éî’òJ Áïòã<[8?„MÑ_Ùê1ŽqLMÿgž,z0í¸U`¤â( ëÍLŠ ¢vÔ%d‹ Ͳì¨à!¶Ÿ¹@µ}ÌŠE•t<Êx¦ŠV*¨¥0Ö¨-¥óÕôéÍ7ès~cú»xÙgÈÙ´tRVb|?äA::y„ÍV6—Ê~™rܧî<öñˆÂÈ×ô wïh ½çÞk–¹Ã¥/ëE™Û™QÝÖ»µ3f3>î´T­Îr‘ùîwó;-''+*¥´LìƒY œªÒ‡‚ûW!97}åD%T œM}´å¶£Ù`YŽ¡jýåUéÌêDª“¥i³“è?¹7þÊeC ðS³“’µŸÖ"ÌøÚÈÒávRcò2c•Þ½ÓJ`ÃǬë^r|{W0^¼¹rçBÕÖîaâ\ŽÚbIˆö‚­þ¤i9uÊŠ…4WXòbz÷[0ÝŸzðWÓËë¨ô°žLrm¶0H´FÐa"þ©ôósB÷ߣx¦‘rçó•ÿ åmÅÕЄa*€Üu½œKºàà`/Ãh˘N§€ý)jÕ¾àû›k€o")`êq÷\“8J+ÁßGìˆ$p1ŸÍÁ€)*á}z<ì+T¸Ý ®£úÿÇ œSJhÐMS‡AÙjéšå*í<oÅ&þʵóQû *Ý’a¼@C±'l×vªøöÏ[dͱ¥ž¶Š#ÝáÝqzY³/r>¡aa,û Ü®­nÊî˜02tĘ%6Å*L?§û¢mv* �uÁz¨ß0’ª‘Æf•eÊUzt:‚ñ8ÖrìÊñðÀÐgçlƒN÷ý«Ó5]ñdÆ™z:·ó{W÷q�•?݆>ûãºA“Å´ä¾;éÉÉ.ÞµˆR@ñO§–‹œ†'Þ[_¥(ýé1Õ{ûª7ãÏÞs'_¦f[ït€Ãøà6 }Hòö }Ømï‚÷ÿsÁ†øJ(ãxàŒÑ]Ýú/˜Ž¸Ç]:ŠãéI¥Ý æ] ‚myôöµ¸Û§M3_7`2£[mKâ„ÍĸøÍö—Ù±vÒÁ‘˜`¢Ð†qÖ×»Ù6å ù,r¸ÃìI'§¯ÏçU•˜ª¯rçÒ¶õŽ::—öuçi2>>Ÿµû@£B¡WYCJ ƒ§q¾Ð’û/}hŠ± ?IÖk—$²=TÆâÙ‹ESn!`1Û“í ÙM;’¡a;֛ðî/ÆNü›¶d’8š «´=í¥¸ûò(ùàÎJò³\twµô9 =½vªâê7Þ4)îR¯×ÀŠè=n;í¤½ZÇi%Äצ§B«T˜B†ô?•ð œTãt°|¹ï{{¾ìÂË~Ñh+‡H|« rb‚ü¯üâE¨‰‚ù£¸‹C|Kl¹ùóadƒœkûØ(ö©+ì.u<ð¡÷é sM»e7}¦—[´®UGÕ‰#1ÙËåò³Vwqdl ”›A?m¬óeÖ7#ðëN`š¹ì(Cž1n(7=öιöp…ª�[·­/E®ØÖG¯†ðìMzÎ@}xLÈÅe®4ùÜÕícM2O|0g0 Ä#Þu²U…~%8ðÍöBÇJ‚ä·ãD'P‘›éÙù%ïI­æÙ˜öÍh{›y™+ùíóBèZÞT­{ú•¾CjÐTûú¯±Ÿ¾Çâø³#JŒ'Ï´¦ÓÆR;rðÍOKB¯lè{SÈNìq®µ™XJ•Xªÿzî°§Ö2Ú_…)åê5¦®æë hS*Y ÔÓ屮Ø[™“þ×´kqðOßý#F˜¤]¥óNðÄ€² o¾¬’Ø~û£¦C€°_—‹Ž­ºVllÁðO?YÍý20„ cø˜¦}½š¥>kçV]Ptzçh‹úF–!-z¨|«Al.=ö´ > ¸tù“OŸUë4¸:†›Á€„»¯÷ö[}×ß+Œ -mJ­Ö½'ÌçPÉÖuðÒÝS1C9/e"jÌj ”Ô§[_‘ÊŽT­¸›D*WA.‡~‚`Ž/äAöȧ͈ž½áðé>h_ŸxGè3|Í„É%kê/Bw»ÜŒn†jW"¼…¹QãE[ÞøĹڡüh”t²ã7rñ*®JADz²ë‰£YëG.P6WÄoŒÜãE^ò”;Š£>@ÁQ­(ø,È Ï5°ž„Hå.1™aņå*™É:yò«ÿ×êÓt`Dýé¬y¹ÿÑ‹Åâ1ØL­%K—xCsÖyásŸSeëµihØÞ¤çÊi³ŒœÀiˆ•ÁIhmÃ$€GÜ0xæ©žËíí•kxÆ–†X¢c9‹ê¤ÃPdç²Óöp”crCarÕ²ú­œEá¡3 Céþ„Fê@¡d¾ò&”&ATѸџe¶*SÝïn’g}Èv%ü¤ cs $#hÿ¶>¿ò˜}ã{´éÄ0j·žÜKCŒ6�x`(^ñdAS7T£Ãu$ãÑ<T\wEÚXá7W?JzýÈO^`$íè ïÇÝDwðdê;T¨æ ů¤íœˆUi„BÚŠ•ç+Ð_§ jÿÚSÜÀóp¬A®p+Õï«X°"PéÊ ”DRDrøt£ Qßé¾ÿ[:dB#Ê‚öô«¢ŒÐ´ÞSšëÉ 4à2!ŽqŽ¶üéÉ<FÒov'c§ ÂHíA&g™K ¹ù>1駼¤[žRZ.<ÐÐÜ�²­;z¶Ð4¹,±â> -ÑÉif‰¯Šî•§µgÀûï¬|¢ ›ALÀŽlC2 Œœ\ üãl²3™¢}ÓÖž½äœ¤m¨ÅÆŠ‹È-ðŒ5ÕÿСP5½gï‰?&»ˆOƒ¾>só�×Èi 8šK™²_!XïFIÜ4G)Ó½|ü ßÝ¢ScnßF¡ˆÚçGµ,JOî˦·TYÔÝR×Icwxǵ\0Ui)P&WQjamjÙ ¶ÅQc‡¹”¥}E¥6É<XÀô8ÒZ)« O&gõn|ÉlÕHÕZÙ·4ØBH©ê´“•°í°U×Yce"m4‹Š3œ> Æ 1+zì=­¨dão;†`3Òê{¢½¢Ü„dK_ñ=n\ÇMI_}þ…·ƒ®IŠÖêÜTÝîUSj£aŸš"6d…7úS®_ô‹¶´!TJCAÛSOÛϦÝH7Öô”%£7q¹ÅNî,çÅDŸA]V€þÁ¯é.V®&Ỹ‚þcbiÑ YÂmZÔ$¨L¢Œ¡‘g?îÂ'˜gxs]Q7¹f5EpNJsííÞîŽå,àÊxeOI)Õanf0vˆøÙ0霠 \³RQþôõw°&öó:ZÏÐâ[hÙ9~«sE•'Ÿµ…CÓÃàGD¥! ¨·Ÿ:ûÞÄy•ù.×y0¡áöîgdˆ¼³E¦Ý>‚EÆ%3z©ã¦ ¢ZNGÚRÝ|ª{ƒ”ˆ—Zȶ{ ïÒW;㨮ó”µëû¥fZ½o›s}Ð*ç ®¾þÐb—MÙíQ•DFënLÛèŒ#&~¶Äþ—"^¥wL"øÛ}”fãPÓ,ÀÊvÕSðo±S×õ_³…ŒomÍP;Ñge±-tú Å ¸Á ]r3†íŽIP6+ýÈ6b( ´õßî8ñÁ{ýêæ_U™$‰B ¼rw¤p’qJ«ð2ú¿YÏÎó×ø)ù—b,)ï鹩šM”š<b5Ó¡XõVD \Jï­ô6ø_͹SG8çÚeñ{å2B=A MWjøUñÓ8óOÕB:w­„p¦c|Ø} †ôA t/tðñ:5%ïjOÿ@*Åi³»`±4¿ösw3*ƒúŒX*Ðöyœ¦9ï‚m­à¦v×®ó÷U­­4xØOgZ7Üa檶dÜÑo½3ÌïNwè<1ùz!Zœ{} ±ï;°«µþ3àfÏ~€î¢È< û™r身kJ\ìåx{Ý×t§½¦xYäÝç‰ÔÜྺԫÛЗ7¢|±ŒJ9éì ŒÔ"u[Þó»ÊUé‚–×@t¿õä Ýn3X%´ï«•UæqP À+3ù´*C&6®XUgöl2]fRúh¹JÇƽ׫CÓY“Œûd”CKçmJwÜCÑ£Y{³©ãt× f¶Òþ£ˆ +Åö‰T”fÙ‚C7öNyúôH»8VhEzê)ô)ºîÏë"´ÖÝ06&Og ýŽµÓ‰¥=pñÍDH퉜Z±0¾ÿk–H?zÅX‚Njâ1Q@k'i�ÿÆg³(æ¼¹é§Uš¯Ì}¦½¨Z9üë¾ÊÝK’XĹ(ØWA8ô®DøàšIJ´ûBßiJĉå’.3[§L¸ ‰EÓ²ž‡Î"Ι=kþ…•9¶7ÿc�ÌÐå¯}W…7ãi%j¦jÙ9×=Ʀóö[Úz»18«L69Œ“A' ò¶ÌDgf^v›Ý´üá± Ÿõ(ÉÌ°=ÁvzPs€Ä颋œ.«6ô/ƒ~C¶ân¡)œ;Ø·õv]zD˜é¦Š>t-É ¯‡ pj°GšÓ) ®Ì £IÅtP}37(9ŸöqÒL¶>®o \¡©g™ã ¶=waT®üÎŒ‰ít� ¦S™cR~»Ñ ‰ Á“ÛäÍaÆí÷Á @òE[”2¼þDYÙúìpXµÙ·ÇÝ,Z=üNØ|Íéï_ FêK/ñΈ¿ßvÂ4ôðÍtÊàÜ';¬ 3žT{]ËWNú4\ˆ‰ÄÁkûãYX—3=†_�ïÆIègj´fÎ-aíÑ£Q0c:¨)V/ºóͳvÆ} qàÕçñpÁ6ªÑSlÔç&WZœh¬‚'úo‡úãÎ!ÜnýÀ[6b%ÒTvyÜÐ#p.VRä{oQøŠ&-x)tÈGÛ“6ïTÕ!sÒñ«ó1ýa¤ˆ|ñx®)ú‰¾XqÙzž¦}W‹¦8ãh%ä^`S0<o&eaá:èî0äv>SIì4çt^0öâñfhP÷dHsd™ýó„ñìç—g­Ž.“¸Òˆ&ìk¢›±o³Ëæ´Éƒø]U!cB‰ ´©Ñ*gu$ÁÊ {C5û ?ª2üJ¦ ʹóDó>ºþOgñ3”øR„€U Úã« <-OøEËšÔêpVF¯fØ$èÔ«á \ú¸ 3$Wãè±JÙf?Ŷ£qý¢•ó1§”Å‹=Rj¨ÆÒ:”£ú‘ɺÃ%3‘§²ÖÓøu”M¨!ÑšL$zªí”xºm(Ÿ±8,–˜_±¡:“iL!ýCƒÃ,Í<KÖP*(t('»Ù¡F÷x:R~dàôŠ¸­­ÏxçÆ¡ñ7Goý Uïëà þÒá¨Ì]¦c#okúq°LVˆÕ¼o-‘µÛ72“×(¢<ñXFÜ$?ötJgïšìÑjãZÄhÅЖ¦‡ ¸RKyÀ}Á輸#Zí)ßú¬ít´dr;Ô»^æoÖ;o¤ '½Ò]UÄ>s“Þ£áÓÌÊb)Éžéû&¯zï˜eQæ:Å´á½· ¨$¯Ä©É¯=á²´0 ”ÃH…p5¼;ÓÅóe`ÇpÞ™rhHÏg5¢ÍópCÙCÄ qDà 3±¥ÙÍçC§ÆBßKœ•¹™6–¦ï·mË \«Àr”sA64 ƒ_wCm%-_¼)y~…ÿh{¨Šlµ ˆ FÚÙ•<üéÔvVª×7¥Á/ó,ÀZ¨•‰«* FœõUPY¨mÂñOY€õ¼ ï¦Íiue (£·îÝ’òpC^ÿ|ú¥Î#”‡�;(‡,²¤P<:†À†7V Aû‡ªøNÚ?æj‰rŽöÒà1nèc‡¶…ñaK÷ÜزÖØ‘p7×ôáž­Ø“M¡‘ŽñdÞz£·®åà­s7n5u\†9U×»³ Øï±&ªä0<ZSè.FÍÔRq)·»s€übzãÂPcà×Öo« \½ð?¸÷««À\œMÀºU¹Bˆv�¾ýÞ€;› Ç·ÙbtÔ(<¤ÿ¾Š¿÷éDÚ³d ‘ÿ/Š¼Ø„|¯P±$çgŒÇLL%Ã>,R¢$+372•—žh­,ÄnÔ³#ñßrÏÙ ÌnØyZ²?u¬²3™þx[Ó.nÕ× Þ2šÑ!ŸÛ[Ì°GxqZ )«§Ž”ýéµZ×O™Û†€×î©Ç53„Ÿo«ìjgq.Þ(™ÞÑô6c”¢³Èç­(!9ih~uå$aìšpìÿ1Ó6N¬{`Ä,¢ñpÖÜ“o¦vO§:Í|pJVgªGìS'é­°QêÁÜŸñÔÊtž)ΘÔPDÄ*ŒÑÂjäö¿Ð9¿˜òŒk}xlÏ(U¦ëhØ~ñıö ‰F†„*øÞîä·À¢÷ÍS_¸¶El�ÃÒí†ÑÔ>|:¹MÓhômD‚FFàØ[~ð{1ª÷.;w6,² Dð3èuVá‹^'vŸ_ŸIZåñ¢ÉY²òÒÛHZd†¬âã‰IÿÞ¿”foC»uOkhµ¶1!’ œ=¿k{&á•þ4Ð'4>=1{¥!f¥¶ú£rAm£%j[ñ>;^¶0q¥ä|ÑV„NèR@.Ã9 Ò/ YTÞ»ý²Móû¥ ݳÉ2ôù8´€ÃF.¨–Mf$$) î¹ |øø­ÁnÄ(SÝòÝšÏ8¯ÚµÞ-ÆÏ c:s@¥Ö0aþw‹›J3_¿z’t+ªõV;ÁÑr°z÷Ó@ÒVÌTÔW) :Š—a'¡£®¶¦GÍ  •›üôgµº³`¤F‘+«·Ž~²ÓšÿÍžŽ•i¬ñÏŽ‚µáJ½0ö² ™±å9‚üV f¸Æ„&f8ÔÇÎ6'Š4SÌ™w¹‚€ÈaXÈŇ *E¸…¥€pšÒ•„æk®a G™·;Bô<‘ÃM' óH=+îo`–Ëëc aæ@âAOâîïnì½âÜý‘IbÒOç7™bår¿Ò†—+즩±/‘ˆj¤ÓG;³ŒÄ?ÓéØÿìk+ËbçùW?Ýfµ}djâþƒâ>ú¡FW¸ÚuO¹ŠŠŽX5ñŸ9e…žÆ‹Ù4®íÄÖ [L&£¤VŠ\°$Òòáffõ/=´aX˜9MÊß/D½“Y«ßOœÀúIgA¼ æj×Rn3B8“˧± I\[œ¡ÇìÑwÛ÷ Ei’Áæ.~Ëœ{ơ˪+9}ÂÓ㢶J"B©w=@ž6·³c•^3Â%¥“tPY¼6g/ŠQ•/œz–ý`YÙ*ëDÊ ë’Ñÿ$Êf­\U¦Öh)À?úwþbéžK‚®é¼Žƒjòô±û]a0–Ü.¶f›(Ï£²_hÚç±£:Q_ðž®üÒ窡Ì(lO܆yÎ5eœîTø›bQ3c^¥W7ŽI•>mN©˜•tÍmaÔ]FðŸ^[MÑRÉÒ==½­%’nåTW)èýf¼èhàýÀ±à¶<vâ«ÈVÐ&¡Lu\[DËá<mý~Ù0 Ø®6:^f)'Åb<±4¤›œ/0£ hý¥<TéœHK;n@æ¶xVãCú&šnûèëwž2…{(¨®Ó ½P)ñ®{<϶•£¿±~ƒ¥+<²ÆK<:¤VëœBà¤l%†vºvV9.æߟ!Âý[©eNv¡JDát´tÉÓÑb' É=MTKifeÕ;Z©¥óÃ?¸Õ:É‚¬ÓÒe hÜ;3ð—ÃER¿ç®iú?´4ç!†n‡îFsµ4ùp ‚`g¶ÜiõaZ]]ÍbW­¸Ðé~!ÆHâZ‘¾E˜ ý´ÁGÃ$&‘[Ê>?µWˆ ’¥ÁhÙšQÊw¥°ù @|æ7¶šj·X.MÌïtªÓ¨„—¡ÂZ üÄ=¹šÞìZnÕ"wRNc(žkæËHm}öcGŽ8Å]P©ªìðý…1¼ž®‚r¤/‚ÕD«‰`1X¨-Å×aøïCúò<¥·Ô.,ÍÌbmz­Yzí>÷tVáüX(.féiÊ4·½§~#óÃä‘\{7º`ó�}ƒ•ÌJ“‰åл¡7Yíô ï<Dß¾ïæéÎÜ,7Cö­0NYQCîCuëVÞîÆÆ?mŒUK°Iœ9!²ÜB&2R¶OùûÐy¡oPc\¹³…üò”¢>{zží¡ï/Óÿ"G)áÍâã>·›”ÀźlˆPÁŽÖªeŽ;Š”æßg ƒÄó DUTÛ1 òãÚñù• P½l^ÅÛn½°ùn1ìÖLH¦ `«t´åO:çB¿’ÀÎIæuµù<ñé<œ¸¹öTÿÏÙ†Ûhk°šÑTìv¥àÛ—WMÉ‚Ýžl½Þ{í.±2ãnoº\öâ¡2HîÍqyÝPžXÖŸ¦³økÞ°9ÇV1P/ù‰'Jê` %[¤¡ÃÚ Ó :{cmËÃz6ðùYîbÀ’— «F¶G*){úòZlL€?µƒÁ Ûä8o u/âþ»ŠmC”å08G(ßê0¢Èƒ³Åë™#-v\®ó­&S’‡>='.däQ ­¹çÂȲž¹q¬ø`n:ñΣKtw‡Q”e¾ HzºëÓÙÚÊ×JO¼©ê G¹…Ž¢“€È£ân.›{€ËÍŒ¤Q%¥8¯ÑÍØCǾ¿û£tó®O“sÐPÙÿù ¦ÀdE~…ã7Γ.zú_ìTFjÜð<´¦"ýþ;¥¥ßGf42$£Îêô|;†v*¤Ù(¯Á„B_MT¶ýVk"$zop*¤{ˆ%Ùwj ¤?V SŒõÏ÷ØYx%p eùj²0º3²Ëð@få±,hV^ÁU¸6rd©ƺL:Ðl㑦¬p°]†¨°öA¶UA"˜S¼¶ ô1ËRäºUñÀ^hJÏèä7È \3 2Op9Ç#–È?yN ¸ˆ3hÞ—#¿eÂËtbÚÜÒ}/ž¤'°‰g<”Ñ1;÷,Ìæ3å /ø[e")ö`ͼŸ®¹Sl¢ÄFÿ’ü]�Ël¡Õ\�w�äñÆ ù uÖäÂ�`Pí,ÿ¢—¨ K—YgN¶ž‹§&ÊO�9$¹y&ÉËDv«ý™ww ¹ãæXÑ@h³sãY QU~®3·/7ïpÃâ wÑ@àIùÐëZÜT%ítb3Ö˜Ù+Þòîé÷ä L=  Ž—’(¨>m=Ž\l¦ 1)ýÅ«Z‚eå/J?`éïšÃò£Øí§æb«ƒç¡¸ªüî.øãTÿ­ç Ñ�¾ËŠQúbhWÅ>g›‰y¤ _öGsèAgsG_:ÿÒÊIJ±Ñb©O£ Cg*»kÚ‹;.¯>þåsVl|Óô¨=}t“§ÓˆÚÔ+V´¥À¬¥¥–\eèÛÂÐa´!X©vŒÈ|©rÆ¡³ð~³šfÁ·|QY8 Wð-,=]'‚>õ{÷I'”R¨ãlÎÏ_8"â,»â6tCdïGSÊgÌ ¯}×ï±ù©ë2Ì’o0RÖ&v>2N,išÕžJ/<dˆœ± J'Ç}ÀøIåNP®³‚°Ü©ÓQ-ÝÝÕ“s;ôBÌÜ]mÓÌk3gnGú ´Vj‡-èk6ÂÞcÝ_æb_D"‚*iT]çéü Vxm)ÐrüÑä¢È²*›HÍŸ¥¯“‡ÉtJNÆEþKÔeäõZ°ð´ 31_Têøå0ÒÎáᱞ•H(®ÌÌ¢ý=…DÝ°"ˆñÐB­[ÏN€îlœPÚCæ¯ÈñD‘£–§‚: ª~ã½5‹WR|òÜ5‘ë±GÑyïÂQï“Ì7~ƒÈ7½{2(6<¹ÕùZ'åbšG&ZOsïedˆ|¸xï<~«N 5Åþy>{$Z¦„MÚ_Õ{g-£¹¤Üćd˜íèƒÆïVÖ†ýìóRcfÈ·ž¸jàåf ­óEÖmÍOÕ¿~Œ{ˆ‘X˜éP,·õë¥ìRo@|Ý_t¿g‰þ‚C½ �9í$9Ÿ¶Ýgž:ç-æjÈÑzÚèáÖr#6¡÷ú”¼w!i1^Dx: emb•ÄáÙ½¡Ã7ÿÒÖ(ý3ëM"sûKÒþ@:Ь C¡>Ó^/ícå­R …@Ÿ æª 4àDιïúÔßM-¢Ø ŽŒ%t&Ž²é<Åfó÷§ó¶éâXöX½�f´_Ïê ¹ŒzÞN«>¿v9|nú[+Îá{µÉžÀrü,èĹä°tYG™•ÓOØ[·7Zà[UD{Qnß*@Æ‘QÛ9¯+*�'/kÓ07›ÜÚ¾…›¹ƒà8Àÿήƒy¶èC2 òóè úPêC³5Ä3AŽÅh>ÞSL}oÈXšEPZ—÷"åwñ@æA áÕ{æ¢ubPBsL_cûî ±Ø”Áì´\�…Ûœ€%Z•f)Бu ÊÀ5¥Ïd>ÑY½5 xâÀ<áM÷\â3¶6êh¾ÚS´Š/ :-ÀKïMêQÜ­02®§Ý‚ÿSzÒ-¼Ð=Ì×¥·0lxä*Á f>…y‘Ís\agƒr#à åø¯Ñ9pÉÖÔu¸„ wsÁk¢9˜Uj«z‡5ðŒVÁ,æ‰Hb»oBÄ|´yÔí8äv0R…žQ5ötj Áü£ÊFâø69D#±¹|¹W/k«°‹”Ò¯*ˆNƒ†RÔgrãÿWÞRQT:D)Ãræš–ŽÍãÔ«± ]H{YÑÃæR¡Ð˜¢`…Bݲ»Ò}³óÑÚ¥8ÔÂ+7·v)NˆŒV$ÎO'O"¥9}9­ÄŸë›—‘;Ô˜Ê9ЦÊ?•®Œv½ÀÎù„¦}´Âòæ¶ÅÔõÍåNYŸç ºÏŸ)Un³s <vl#b”#Žõn#·÷*££"ó¬·Oý€ìáVa“¨[wÃ`iÉö"ßYŸñ¼¹ä÷Ë'ˆÉ+˜[Ê»6þüòõGϘ¿¨@ä‰>ì¦ûù®U»#Mɲ:ƒÕt@ùNiâü‘AéZ°÷¦Û_ÐÎ3—¢ágµp²Òïx³’½±ö §J¡sòÈÿŽV[ü¯ä‚[*³ñìÝÇõiü« q†*èTàFÈçN²N÷êŒ2×ê&ˆÞi«Ïä|iNâ-8ÔüD¸sO|ùí‚kíՖ¢&¸�‰v-ùD¨Cm¦bÂÈ´J”Y¯mù£hC‰áš×¥± ál&Áö‹žD79¹ h§o'ÃÒà¤h·®¿`Úص;ŠtŽËòÆ;#3qb}%÷ 17ÐVuÒt“Û'ªiµ0péhT0d p;¹×§ªÑ¯X¤«l±9„áN¹|eDKA®N½Öt­l*{1œÕã=§¿½rO/ÂEV›à’ÄV|ÀþÀÔw#Uºc”ÿ«ž›jö¨áÈ„m II}2¿>„Hb° »ñà ïݶcÊkm¹#æUÕ¼ñæضn­=4tÌ¿ënàÖüÍábå øÒ[÷q7Z",ˆ@ª“ö?Ri)^\ê¢ðð Q&.¯,à¦}äýè™Û o(ŠSè*�ÎóPa]Š„ôÁ¡‡vöû»ÏcÕˆ´D nìòV±÷vé°6ø¤Z tÂŽ³G‚ó-s$q5r<&¿^tÎ;ûö ¡„4qx1Ñâ)(¶Vª:ûS‹ r²` J©‡Üú>`o{d”!ÏkHÂ(û–v‡";ÊãæºmÚÒçITåUYka®õcZë§ÖIyœ‘¿›3þQ–‹Ñ-m/ᢩ [’IoÖÚÚVúZIÙBÎhj´ ·€ŽÅ‰âüÚò4hKÑu©$înL&ª")³ºÄf¢¤üKM:p#8‘îí„‹f™«9’ô«íκ<WHš³¡ˆÁ&Ó4X¼[( µ«w½DP7jxr|FTBzæƒ) ‡4dýfßns¡ ƒ¸®ö Ò7S§.tŽ²‡ŠÁÁiÁÁ$QÞ;ΆCñJrEQœ3;Õ0³’`ˆVAZÿ5Sž¹>Ò²Ç�‰<¶$TëÀ­÷è9­2±°ù‹‹e³6:"DªM_Axö^ ÒüN3ËtÉ>ô¥pFIñ¹xf ¿Ûlè¾â )d›Û£«iökO[ݬ1¡ÊPŠÆ‘òF?/LM*›Îý4%Auî̓ÀÉÌãrŠ‡R?!É£ìjú…Öw^Z³ô³ §=[<€rK�5z{Òî­Ü­ððÔ­gºS<…È…W0Ånj!‹Q)º_ï1üÊ]†˜-[×õ=…è¢ÕS-Ké-ïö§ëЫ[ÀŒœV+Ï7ßfAô®©7‚‡ILûX[-°îZ.>¼öO†[P±[™θsžÉ÷õnè¸ÁÕ±s‚¾W?ÞóôJ åÙiu „Ó)bÏ[c°.‘—Jˈu—DÁ/Õœ¹9Äüúr)kðs©E2ªÑïø#v DZ‚– žq?ÙLÁHôZ@ÝÒ;•ä™$nª õø°Á¤¤[»!¤*òÈ·}QÒ¦,ýª,Ì‘ïÒ¾ýjœNFÃ\l{€Ga…ÝMucëþ‡{˜¢  ÷˜Ö®®§­ßÒ¬ÿöâiÄjœ›ÏÝ lÎÐz ý®•@lLh ¼5å}g —å¡¿ó¢`Ÿ„TÙ¿[1'–}›»‹*˯V=&G.ºÒ~¢—zS儈`›Ô6^êŽÖ<µ :ŒGSʸ«Ç–_Qæ+]aÒÑÐzùTðlÄ}':ª/×þµiAúÎp\ CqV.c³(¡ž²ˆ¾‰ZóòÌžÛeE‚_ç„£7F:*ölžõ rFqGaÃÃÐz¤…TöšçÅêOD+eØ­¨¯UÙõåh:T•c<¡"Yð1çAÚº®š‘›¸ÖDo¾aŸÝå1ñh°ež˜ŸÌ(f‹Ž ½Ç�Ýné�¯èó--ÓÁ)*i³7ÖÛ%o5/T+0êóýíe>,¬¯_WQYø ЬEF)Qínœê–$-Òäyƒ ’ÔBO@S®±öcM×É›¤4síAüå~ï\XÄ™w>ƒÏÊ�ÝNÙëéí »v¯b¸·p\åf¥kå’{„žxÔþõ j÷5›åˆ5UËÈknžOÊ4æÔÍÞ-#‹ÄûX´hsÂç>¶žXù¾³Ó‘u=ú†þ5Ì7˜Ó°¨¢ÌgáчÞwe¶ƒó{§h4Ùwßì8gàT×]Þª?¦W¥5¤=“Y• éÅð1o"É+êžùRG¦|ÉQ-  (q7ýÔÈ>ViT‚Ì&�Õªê/´TÜ5ŸfÛkþ=g;KœL_ɤ—/:WO[/plE0Èy2w4¼xQeҤȺ¿‰¬î²n= '€“!UiÒÂÇ š]y\UçÆvrúòZáδ&`»—׌$mÌTŠ¤ˆÙŸ”6€­Rÿ9¬ºÙÊk¾ b_¸<‚sÀAbŠ’vDPHk”Á¦åE1–;°´*0x3ˆ4}¿f Ð{¸Z-WÜþÇ®5ÝA\ò¹-z1ß íùÆžÒ¯œr*ìZë2ŸJ˜¤3§ýÔ{WwÌ*ªÂŸVþ{:l­#Çz�‚`òÓîWèíQê)Ppús<¤|«˜wŠ)~Xåþœ¶Ì}~h±rmã]z: ¢ŸÁþÒ×_^«±¿°®ëÍ ct^ÑŠÏ=j¥¨)Bˆuö3à ˆƒÜU2L/ ;åžiËέêÒåØR¡ë¦NŽÃf×Òc@'„Òvúªþ UæSä©h‚LÕÑãÅlÝ©RØêgó‚9tböc)Š‰¹k­ŸªJ{"ö«œ¯ô"xð>ÑWȬv@Î>ÅRÒ³ÓùÞpç¡Oœ_Ÿn«5=é¤×[‰iã kÈ"§öè(ûJ8•… Œ«1 Òu«  O}H¨_e'®`úúHÔçƈE1¥ÅYok¯:Bç~eÔ¤1¢š¦ÁqjÈ× !ÓtÆÌâzËÃeåõ©oÈ–J6wçî›Q`T,6(BØ¢ÿ[˳Abrbh®ÚÀØádI¹ô@†ò8Æ¿µWᬞð»93®Î‘ιÏc³Ú͉þD¼¶Ì[™.μY5ÐñÖw¬ }®Íô×"{òØAoP 6£»“t–öƒÌl—»‡3È›ül_ÍæFV—5äü6•JMËb7ñFÐf÷wcƒ<ÎRMYœ±IÁ£¶6ñhƒöhàʱ/‹pìZÐÿ_ãJDQ’ùÓÜœîü\:x�á‘…9SÞvýÔ\‚õxh'£÷ ùµ¤Š:Ø%§£Ù°ö<À:¥2ØMƒý ©ºbG™a6 •äý§9ÄÙ±Žðä¿ïª‡‚ßx�‹–±¶t¤Ir1½0˜ïBÕ,¿söBåÐFjG~?—´—z‹ EX>ƒÐ\¬�-¥IS›­&ˤú52Ó€}ÏøCÃ^µÈb(A¨É9|þ˜…S–®g 5¸£ÅX{|]Ši{ö?ܲ)ííÁxŸEÇá ôqàôR­eÆðEó6§…ù×´Q …%CªîŸý÷é%¡Òw¥7nbÈ(<®&¹R²7ly18Zw-ã<c-æ¬V7R¨�…Ѭgª7EH—ðoËž$ò`š™ éé­†jÎ&‰b'Dç‚A»PþvfCt—”k¬»yd˜Í”tô=ú þŽDÊ Š€_êÆ%¡O-†¢8æmÏ—¹¡®ë×ÍòŒž­Ú?ÃP²9^wÉ ƒIK·<K(¡š mÃDÃéöŠRåóXÂ$è{�E›ÖŸµkŽ%+à<vL,yôê%ÁFÇ3Ír‚Ö®`Ú7ƽ[}Vie~Qèql?þ™L¼nÇJ‡s?xåòÁ¤.ŠZÆ©WoF^ùî-v»2ˆkm±FIL·¢ÞK¿û ¿ú«ÊQG˜&?2Ü®]çÒòÈ|¥ðú�¸— ¯½"óÌóÉÂ_>)¯`d‡`_Vbƒm-ôÐ+>×ÞÇgw (ñу’pÏÀkϾR!E©ÖÁ»~Ð )¬;H"몹ÙïúÎÛQHõ¸YC¸«?¼«ÅJ<5Á%ž4ü˜÷ ø‡‹B©V…ùhžÛ)æñ“~‰ï†Ì˜‚¸°œaÐ˘ t™~£þ@ež´%gæ¢älëMâ@«ô1¹bdÃéË+–ã´ú ßÀ:¡[Ps©67¬þs`íE™1ü÷-UnÊ´ë=ÁhÊšgó¨Ä˜Ö”½ò[ô•ùKT"§C$/jF|¡ÁèÀô÷jc[Ä[þ`ªÓ0O£eçð”ÑA%E+7h!Xj®A£S„M/„b¿ïκ±FLÙžß^Þø³˜â» &ª½óMï”iìpýÊ:ÖÎØÊKg92¯õ‚.Lš?an²¶rÜ}o~¦ÿ®›¬OîEÖË-™°p‚­9×Øû8áÚ>²3B:Z%ód �¤´b°ý¯w÷B›-?@5TZ”ï*+‘«ÿ¤§^ÏC9Zú TÍÌ*©’ûiR¦Æy…i×öl,ø®-ø*Y8˜·ˆæâwÎÈqê Í¡ -é¹l6žšÇªkk;ØùÕá€BŹ¢|ÈÞå¦wå½í®¦"HA{"²-’hJßNÞ8·ùvÞµ“l¨âr®W®Ë½âî+×m§ÁrÞ„ó‰(ezŽ×O;µÖç¥Ñ÷èVéŸ 9j˜švã«LôÕ¦ýï›Ñ‘JJ9-æ c±–É‚Î\÷ ûæ"ùÄv¯+ÚžrL{¢ø.ê™âJä<ˆD$/‚g„[}HØI8¿q_<û = å™)¶=ô)%bïšTî˜Þ茿B»µjí‰!§ €…¶5YD’h‹Ó=ôaZü Å*jÎÔj¹7rìà¹×´ÏƒªÿtxXÚ쌆5ÆßVgÉ^>ê¶9ƪÈÛ”ÁÑZÅz¤;=ãLv˜¶ 6«ÇP êvwÚßÏ7w“~€;øÜÔšˆ.ôjMÕI²õôEx® ‰O i*R†ËtiÎ=Sï.G:«Ú×MÔÛÀÏ´¸èomUÀ?â´öHÉûÙa»8Tè‹c®©à€põéý_ô4B« œ2ã .V2âljáè+1+’^ÛÚ¦ ׈*h ÊqŽ½§{†¡#† Ò�áçÆF×zq=ÈN"dIë'B¦‘É4)¤‰ µóÛ|Ö¦×oÿ áˆ}Ùmnút_©²7¬O>t¢£#¬îkïˆ_W¦‚…SU¹¿9Ë j¿@xufÕ)‹±w«íoáñp¦êXþ…ó“'e6U¿_´Oˆ¬J†Š¼'÷"Jìzõ˜{`)T%îˆeË™î î°qj5«Cƒ¸$cž]+ß×^ÜùâÎ*Ylgd*[»^À<Wc-"¯V´ø1È2û‡EætbI@ë‚ ðÕáغG…¼½°¨6ÛE‘öl†Ä*É[åâ #³ƒš™5Yï§È¥ ­˜­åmi=ø­Ò}'Óh- 5ü<ìv;W¥Øˆ`ïŽðeœ[çHËI@C…ÍÅÂÜ(\›mìŒ+‘7h(2_Ô ½Êá¥V`E^¤v°†ªË°¬œ9Ôž‘>’V¦NlgJ-Gm‘¸%öÈ"¢¹yî ¯B/øé«sŸÇ”J|¹ îDÙ÷Ëkšù²Šãi�iÕ¾nÙyD_\©,DMà?1öKl©A�2,ºÞõ“()˜‹ûJ­¹×=-Ø«fµ-pš®C 5ªNÓªBî„‚Œ·¶œ¬PÃv‹%˜[]<3¿‰ NžŨõ1Œ°érè'úÁŠp §Yì;Ü•_¯û .s[-ÅùRAëC{Œ\à ²Jž^ÃÃWñwÌÜôRZFâNË7Š*—J§‚Ò«Š<'óÀûÃùF@:òp=¨K[Î&+„01 5dr$ä%¥åj!ÚΑŠvœŸ­ÆnEÆ¢·TÄ 0œDh º¾o8@ÏÉ@‘nqï˜JΣµŽeÈI£t ¤}|f=­‰’¥GÖ3ÕñèœÕ™4°mVÉ»|m2aí^E±Ž6׸§ü¥½xý[l©>à÷:‰"þCMŒçÞ<9*[¸b¹¡Ž PvÝ8 ¦_rçÊ_œÒÚ®Gì™G…<‡Þ'Aº®ms8h%Ù¢³éŒÒž]öÌŠ'Ï3¯%L[i8ÒÃL6µÙKyvãšC ‰I^}ï^>î£Tøµ¥Mt0ߦÈwMƒémß'Ç®ýW4ÛÔš†•Æ‚i:dÀ9èè!Kõ¸ChØÒMï»­Û…xæì›E† ]qMHgà%2ÛžØùXØf)°§BB¶—ü´kØŽ7ª =î/Õã˜ù©ñÔnYMƒ¿@Ss}kÖÒqì¼³@æŽ×ÇÒèO«‰ÔtjsöœùfÊ8�Å¥¿¡m¡Í¡9�ž|˜ÎLò?óòã¡/w‹é24.:)Á³ÖC “ìÎÙ+Óÿ$ˆÚœå^¿Ã¯ŸþGB P…mñZDÓ3ë5°¯¿ØDÖ5[¡Ó᮶‚|¼¯ø&¶‰*ÇÐj¦YLª”QäÙբؖñö�˜±;ßr„”#XJÎæË(p¬´L° Ó‘Qó,\ b‘ùŽ>ËÂS¡+ÓY¡µÍéÝJH »éEÅÜØ×äF´¥« <Ïê0¬o/¾‡a#êx ¡@1БœÎ¦vn*‰É¶Ëh«41’–¾A1ó‘Õýzì¬Úó–Z¥~[L»?T6TÛ¿šõ†’ã°„Ø@bE”BÑPÿæwú›kŠvå#›¨ÛQ‚O£-éYKÖϬʋxý )¿£pÏ°3V­‚éÁ•‡pÁÔΑ|qg LbÓZ5ùµÎÙâÙâÙ°¬ðyÒ¹¨cA†i^$YÁÓøQ¯‘m³Ô“/QÞl`xž¾{Ç®2yµ–æ@éð;o‚àtÍŽ(tÏ9BöÚnË lTPJ‹£µvhÎöµE«c˜ù˜÷Àâ…Xk$™òÓÊSÙKiðn®éL¼3Îì­ecæº?“)_¯âP±@o:krÐ×X§½ ·ðCeEŒeLÂ𠶿,Î:Ðا”¤øZ;Uˆmý\Ùƒê ¿ÀH ¹Ë¼Î±£÷žk=ÒÔŠ‰ë.Ý’!°d\#Ò«hg4?²AUs £Õà:£ wý«T$Ë/†ôhN˜JúB:4>² kåÂZžEž² l,ù¾—¿ƒîb“á­ŒQ&.í†CËLwý¬QV¼‡ò  ìI L‡2 ïrU¸ßÈiôܲÃ^ö' qö¦AÞY:4¹†]ŒgNh¡íë³#·HÃp•ÚŽ¢\§ó:wÔÞø |£`¡™&wÉ©L!ˆôîé…à‰sì°b!wœ~ï»ÿ– %ì—?)°l=v`[¡B†Þ0îîP.ŠS7.æŽT[—´%“”¦‹ˆÝaµ¥©˜a­¯ûd7_/1—Ðé¿,àh�„†ñ°†}i=kœfi~ûó -ñÔ‹xÚ kÙÍùÊl'Ì5QzvØ«¸C7”ÊŒÓï¶.‚ôèõX×õi°^ÈÎ@ÑQæ{îŽÖƒ[fŽP~§µpúô³1Šx–(úâHØv¢« 5Ia¨µÚ‰ Ë*é‹-)¹ë¦dšÄö¿¶i“Éú}qvðèÒ„‘­"i«Í4IÐóÉkâ‹_3Ñg*Ç‘H©n¤Û„èãt™_B‰äÙBW» &z»|<ùª(uO­Çtoýïj5 2D4ýí1SáYl`춴׺/Ϭ‹’ ~U%ƒÎ?žhŒT�²CسõÀ]Øë‰Q _ôÖõFK—/N?3Çoº§Ý=²¹á%.[júk±'ø"=Ýí‰ržNÛk)sPwÀ'õΩáß1æ­ŒoXzì»c$Ÿ' †¸àîhUÜ`IÆ©çî81!¦aýÖãðÄaa½rÁè¦Aa[èìûÌ(VÁ1¦™¾YêS7‹4õ;þˆ0}à¡ñz³’ÅÉXd …;Wêw†�q+¿/”‡à56%ArR;òÔˆ;x†P¬ª§{õz--¿°ÿ ÁH£mœ­¨ýž5šM&Wr±e»…+ZL:†üÖ ]—à7fÛ”ŸkÁiæ «ã´ñhVÿ+¬+À˜³¡ºîÖòãâ }¢æbE$×}Ç µùpfÍ-|�4DÙË×h.BOº‚–Ô:¡J™&Ix§x®U_¯ŒØ:È,œ;ð‰(Ô€š¥W†i-,ºªw¥V<;rNì¹yÖ'31p‹ûù®ç‚=d™ÂbßHfjµ ‡áÇ…¸QˆA]7§ñ`þ…5:ít_]3Ê_^ŸmþØÆ$œ ¿6[zúú0!°·\%FcÄ;Ï VTØ,|eüÀ×ÔvÔúBÿqY¦žtRÖ‡Hæ“aÜ3”ÒBgqŒSq¾ã†q#Â/�]TÈa>ðnI™µñ0ú.õ¨»çÛK_ÓYŽ“R À¸Í‰•Ö–”&ö”¿=†oàÀ‘RD6JÕU³¶Y,ófNˆÏ³ 徨¡Wé•¥wAdͽ§�ȃM’¾ßð®ÞçáO”{ÚˆU«Ñ*eê×Eë~b—^ä.ù1B&Ú…ö”ådÔô©ä-|%Æ8¦Ö0è/#§‚Ç—Û6 ²q£¸™+ÇíÅu*}‘ åXúŒª¹ƒóFëbž¦µLKÄ6S á–•˜Ù«B2Á*›NÕåñˆ£Ø—M§(?Œ´ÊwíÂÆ¥4Hèæœÿ Ä2;.ÌUÆñýˆt–{µKuÎ=‘´L`½[ƒvdÜV˜3Ë&jø«Ýxá¹_ßq? «'Ýj¶sR†þ”å±Ã”Õì© ™êS‹fŽñÇû¿7ú“»ø–AàÐ÷œÀQýtN¨F×^+[‘=t]zä|cĉQªÙ)ïˆ:ŸÄ5^°f„±3Í8VXœ¦Üg3~WÌ:pRí+&,£øÝðiI·‚j2³ù úËty¤Ñåwx2•ÏòÐwq(yrY¾-ú1;^ù†å¢/‘M×EäŸïþßÐ85÷9vôDÁ{a\„þ$wùò­¾2J³ yvÈË…TüñP<‘¤W®m-SÙ&"ú’¨èéá阻L?j¾�Ý„ÕÎî]ÝŸÇV¡¿¾€&ÞÓãx¯öe†sC4ظåË-R®Ì<=@ᨇžxYÉsup—€ñC›tçE› w³¥gšXLÖÔÉ«&ñóð Ü�¨›Žï6¾e2óÆÔsf¬½µLaþÏïx@ÆçR²g΄Îðd¶-ÊXªhåß5j;œ†©¿×h°ˆÈ‚ò!+¶UÐL_ýž5†ÈY^ÐX7¶æPí¡Æ2/Ó¥ ÿÑÜaJ騽þ°·fÿÅ.w0"ý¢ÓTY»öb¹©ê¦¨:€ë†Ñ°CìÔ;ëXcØž_=b8‹`Úè'aZþ>ÿlæ’PþCY ²ÚB ׇ/i&¸FÈù€ŠVㆬ®oÌžR(ošN;g ã&ŠÞ:3œOÙ“©«¹O=Š˜ÈÍ«'‘F­`Ú ÞYöüî÷6‹—¦ Cèuý0÷ïþÒwª t^ÇtLi±À§…äJÁæ�Mœ“¥´aˆÖFn|v"÷u;Z‚ú‚mRúoOc‡´Ò=ؽ?`.ç_ä!,d="(.0îŠsÁÈÓɉŒ»ÜpŒÀ¯Òü[0Š&×<0aÉ ÑSßÈ»=G8J;¯Sé´ÿH)÷ÿj8cí9kö$·øÑ«C”Ž@ÏHj(ä›w“!Tܼ¶^ègŠ€õä©�à_®_k„û‡§HæåÀåAjÝ�êw”æiç †tX‘/*»¾ Ýz QÆ$bŸUG‡½žÈÂYÓ†–QF2å¼Ô£„µ«]ÎjUÿ̖ʃ™"8hO}(c¦¥s,µ[·;R1'ÿò½éøoÚ`匃L¿©)ƒðø×ñ-ÐÄ•§)e<òôÎüKuE{а†™ Öþ,뽑:Žw5£/þ•è§ÝP¢ÐEweÚ”ØÎn¤g2å‹L‹IBØn<\<¼ÉUv}“l—™ŸP‚E_Á4T‡Xæ é<ªk$©ŸëAP;ªbY{:ô;îO~;</C?cŽ³ £3.·.QB=é¤rqR?uw²22-¦·Å¼<²# Ò±Y÷ÃùíèÜ罤ÂB¢ÚêýÝ5¬ÇÃËÖë'÷pvÐvV@ bt-謷"AT.¸äN[¹_W‹{ýuÏI†ñð ØCùºW„ĺ#=-gHþÕóÎ^ýd8’wxa'pø|ÜZä)ï¤F©vÜÐãìÕ,�wZm)W´íÅG£; ­´ThfS=¤7ªzë9 7”ÿŽõžÞöܺèîrƤ“jÊ™1LceÊŸänYyÝú¸-Àر5Ë`@£ÓýFqÈŸ\žMrîý¤«EbÛ7ÓjÉ‚¢³Î�,Û‡ÚzeaÓÛÓêc@ ë-tZ w횃*ú`j+áè?Iäï¶H0{[SõvD˜³ÃVÙá^=:Hf³Š ± -ÆFÑѤ£Ï*P ÓûÉ<,J"—t²¾÷åÒÛZES£$lHC—úˆÛÁ<÷ß@ ¬—®äT”ô|äAüu4ZjhÀR$c-QsŸ(5ÈóO (moÓÂç@Ì©š³S ð¶›T](µ/ÌNKSr¥ÑArFqyûz†|Ø2D´ãÏÌ”õBÛ"±Z³ ™eµNúƒÉºWµ }=N÷åeSNXƒ*úDB5Ýã³¥™² l{ãº33j˜¾éZõ®DÊL‹¶ïSz—w§O¼ª»·îºŒ"Öõ[s˜•õ€¶ûº=l‚Í™žkÛÚW–eö‹|zã˜ë Á¬@K@ïY¤þïïTµ,­¬ó®e¡¬/”«wg¯U®*¢oi˜Þð‘êLhúîœ/ãU–äÇUžó¯j0uÇÞÈùìú‡qœÇo¼îwû†er/œŽßΗ"o©F.AϨȷ­XABí 8 ~¨ì„gRsôðéùU®® OΤ:£ÝV”7N§¾»ukp lã©Ë›i“.Zð�DUÎ E“õÐ1]_Vþ+GBázsr<î¡=ž‰2ÆÀój•õrƒß©Ä2’äyME×vvÈžiUŸgJÎÐ÷š7á‚“YÍDo=i[%¡T¤[a~àÉÁÖG§"þò¶ÀssH†”Siªæ’OË/=bŠù/òúcÏN‚±qMRÅy«!-—b”ÅJ “I´ñär˜›>ß587%»‰à÷_:iOµíEv+ï§û’Ž„mß2Ú3ð[)%Ÿ›ÃS-ƒ¯A¤ã=õ"z+J’ÌϵJ˜ÃåAÕm<ºj˦ºVÞíEO¸<óQE¬:YW›¶.ú~+Èmt:r¦dí@ië]ïƒ8ŽÜ€2g1€ Äöš°Øz/FµænˆÜ|½¹uÃœý 6EÙ¡ƒJÖ ­ž“àn›XõÈÂ[w!y´„»r-òT,èj1¸#Y̓[/çKçW¾´|d-Ü\È_þ¤$WÅû!i‹ ìk½Ú�ɽS1É–zo½1p úÖ¸ _—âÈ.ñð½‡Vn±™ ÍW~œ‡šçÙæe< ÇP_-éAx"à|Q^í¡±í¶× Äæ±}pˆÍ› ú<9öŒ¯…Ä×÷Y”“ž¥«z·÷¤OŽ”<ádîê&0ÕY­³+#Û_`‡&¾Ùq ¯6g¥OÐ7À0ý/ô‹EµKpM}ÈÏež‡ýí–Ò×Áº€…@x™dT– •*2.ÓBóìî=ÌÌKZ™ýï‚ÊÊZÅQööÏ[lÛÊÌ8Z0¥/ * ëPç$HGÅÞãPf»éÈWfä–&Âã9Žq ^ OÜõÃñ+ÿÂàO÷š|þôz´M7¿w\O ¶€‰œ}Ü2"7O(eqX]y‘·CÏ-me£µL‡Ô¾óÚ`P •­µêÙío·‡^#ç(fЕKù¥Àº4 ’Ñ&#y`š,–ÿ3^x2=&p_‡¨¨y‰ ´©ÎufˆeÈ„P4›O£¨Œ-a=Pƒq´Ê÷.1L(|!Yv‰ ’¡ui™è˜JßÅë›~Ó=ªüjHg d»ñì$¾ðÍ΢mÊtÞ¢‘£<±9AÌ<ž.ÈK eU´ï Gð© Ò‚ýnXdkn…¦‹˜ƒ) M‹ùJ¯PŒGã8O[dx¤í–ïX³QåÙŽ¨N«§ ò¯ÆL´[>ná<^BV>=6xi¨=eî9„PøéV»þ×bO•óù4ZÄ(úT zÄ1À‚ƒY¤Œù–¢ÄA¤“´^\þpé.–[d‘+Q®Ežd3yÀ¬ÝŸ‹aYoÙiEEgÒæ„_ìÛ;¿BsÞÙ«°Jp¦ïäœÙs‘gsŒ·Od Ó?“˜/&`W?]%¢…ÑCSýÎëÔç"‰E7Nw¹„oë3+ÆPþht´^æ¾*mA¸ËÈ à÷´ãü¤èu—õÌ×VwŸ­4]Leö<‘¥›ÐÄF@l„ûŒ%í‰.„Œ}êVÑ:Þt,ŸÇ*Îvì@L“s¾ QU>-š?ã{GU‰Àv^ïFA!òV\ïc|o‡¾X.Zo½ÛZñe´cšÎC³þ÷-6ºyJË^_}ƒgÒ¾2g,eZöñ×Æë1ìé“Ö]/Û�q'·°ÀÏ÷–Á)<©BtYZç<VÆ9,’v‘´·kÕe¦µtØÉ9pFg†Çê¤âÈ… º(M𦼑ÊêVk÷ºjN\ŒÖ¸ÌL[ñ `Ð%r%´£{é<¸ÑTè‡PúÈ=èaÉöË#F4áÅoô;3Û°}óÑ×»ؤôØ{MêéÈ•æ·FºKÃ,¸ ‰>|i7-l [xÜÒÅ|qÚE†Rà®~EÓÊ|ŠŶ՟2ˆ6½3¼w¨<#ÝÙ ;cé]>èDGÅbpJï?×EP}6¥ˆb_ëõ’¦­˜t#…;×l~X›ºøëV,\…HZ0+–^xÔ½A'ÒÙTDZ›w²È„]>x蟓Ú-]sm“$§OjÇ ),èo·˜•ª¼bƒýÊ)ͼù5“P™’œ´½zhhÍîÐ_æ09ÈQXøʲ@Q´)ì ÍÕáxÜ­Lm°붷eØò' Ix |}peñ‚Ê‚Ðw¦|ì,Y7ñ§l»©ûž=ÙFsd&ÌÛ/ÈœÜXŠy$ƒÎÅ_3ÆŽK‡;ˆ3žhmk›]ÿñÆÓQm‹•0‡Pã³: tô}¼ïT§˜ÉC±ÐãîÈñF=ùç 8 Ž¬ \†½òÒ£Ê>°¬åùHr%ÜýÌ"/Š³(É"ÓHd­Œé@?WÖ#*ûËž¢)„ƒ¹ôÓŸ &‚2é‘ödúqÏ3Ý¥aòЉ¼ùÅ+Ûìã×+8Ì ,ç£æcÆI3xe'“Sÿ¾kŽö¢cš⯌“|l{Oƒr8ÊUØÒå§$ŸÄ›bdl=ÑâM·'§(À·Ü«õ·];˜êxE›`QóúFQkº`EQè GÅ˦͗u­µjö¾vs’‚þ7õ0žU4—7uejdS_®ìD]9ž˜Þ÷ñPáÖ¬UÕh”0_å0Pxølè^F?Õ.¨…ú{áàÚ¨>M'Ír #–‘9÷»IQ¦wö¸…–dŽwÊóÕ¦¡|h>zã�ÓÐ1+uèú‰ýŒùåð%wÞ1tT{ï« |×ÒÒ)ÄÙ.|u"5ƒîÏ £´VÞ:0MÒ¼(ZÐ"ã Ž‰œéóÖ'¯I¿BÂ;[¼?Ýrz—e²ØPÙU‘zµ/ƒ¸×öb CÎgMKþ"úÒŒõnàY½ãx:ú:ZƱ@—*Û;WÅfñ[S t¥û>‡0%©‹XTIŒôi-LT]jj ˆ„\Âò·ë›å†0né‹÷:dŒ­3#•‹»® ×òúõ÷2Yc$AÓBéÖäÖ—Üv¸/°JPåÃLjeæÃÄÀÆÛ¤Adum¥ØEýÊg†¼÷ªû+°Ì¦k{'\C®¹_¹øÆ”³:WÆYŒ–e–jw�6¿0¼3{}d%« ¦¨×†…à,ß'CÙ¡¼Í´3“ê'9û¼`ûTÖgÀÀ"8Â1:j›D4H×´ÎSF‚:Ò˜¿{8Ó•™/6î»Þ'¶åB‹ÎŽä¹qo}pÁÒ`\Y«CÃQ«W§s·hr·j„¥ÔTPx·Ø: 9:ç߀‡yµ½sq[Í¥Õ‚IÄBitdœ|Þ|›Ú¡è 0áæx’êƒêKSYHãî¾£ø2¯ÝèlÆ0l§Ó3«ÖüÍ7CO4Ê°Îm>½ú#Ëö°ÒÄ ïÚ üf"W-š…)JJÆ´{9 7þ`)h)$«CÏœ;&óüølv‘ùbeП¨’xß:ùË|¤„¨ã|ïJ†°ÏFøQZX)-YLÇ. r¾s‘™ã­1ÅÁG 5DDò×Þ¦‘‡–FTdõ'I‚jTô<x£hÖ;ƒ ꦷ¹^mÔwõ^-4Žõ£²Õ¢¸UGaµMiYL¿Qª*nÐ]l¬ï¹Yg©q6ˆ#€Ê™ "‹­Œ›`A[Ñ*2¿¥™Ü jþ‚så…l˜iíÉ¡c¯!›ršúd?愸'×é[Û† ݧA:+k>4õjux[×âtD–ùý÷-1ýxv0où„“éÙ�iµd[Ò 2UAöµµãÆŽN?*òõpÁ±™µX¶T3Òš¶ctù”¢›ƒŠßy×:æ¸úi_¿Þ¢is(Ä}¤Î=‰äóxp6:ï€wbÌÅÀØjþøW¯ÖòÊêOAûŽÃ¼_{#^ø'¾YÝòoµÿ"«-X)l¤35ž4ªd¡É”°äU‰QP…‚Ÿ= ›Z5ÐïZ{"E(9˜áGñò¨`P—´X„œo²»ï=H­r¨Áˆ{S±ÕÛŽS©ýúÚÒIšN˜Û¯ù‰$E’–núM÷…>{1Z]à„M¹8D¨®ëC¡‹`}uIß[±/= ´cGÙRÖZ£>´)rˆ-—LüfÖje…µ·¡;Ì/pAí~N ãt{J‚ìh ƒµ^…dó>ÒüK‰xÑ‚‚žâbzÑÚlÞQ€®ºN2á°Bœœ#XNü³al”,àbÖÍßÕü°¼FÃݛítwT9ôªšò-P…«ÐŒ sŠLX‹¶‚ÅRø+¬ñBˆS`9¼ÌÜÕ£h‘”N+Ju[ѧ‚IÓâÖà›ÞcrÀ�ÖK°u’z(2<Ó± }<;Ì.ðIÙë ØùÅ gmôŸTW^,*Ç0Hmš” ]ògwè;ƒcԺɾ޺Q9¸¿(³—xÑÖÖTN�MÓ]‹ò#/ñ4ò“QÚîÝ„étíW6Ÿwƒ‚“•Ax`û¬‚gÂü):1n®CÉÕ›i L`½Ûp+éâb ó�·àd;“伄�WtMs€ö™‘Èèðq~ÐÄŽÕ‹D(¯Ó'þ<9Û€–Nf–c­¿¨é«›=%v“e”0ÁôºÚ~,ðQ! ODéÍ»y†x«áÑÚoÉ™ÆöòºûU† PAïŠØ7 u›³“pAÛñ²?t½Œ.€!»½ðL¡¢ÊL\ú. âÇ™jÀ6e%»oË—t¡—ÂeƒÊ,O¤V'À š%vK7\h/=s�ÖÃ^úiдÐ*³Ÿ.ýÅP»LeôBw!KB¯w ¡–no5©Š]aÇ®gÛ¢³Pœn^owR›®ElÑM¹ mÆÞŽrÁˆknIZü>$ÜÜ\n‡Î}Z3Gáë†Æó¬ê­bÆ28~gx–;:0ö9ÄerÚ/G7ßÀí4Þ„þÖarúºl!&Ž·Â§¦O‚tòì§Ù Ù™‰ ›ôå~²]Ù� 0 œ”ÝT&×gçk@”Ò‡ÚEÌßI‚òS.®U7{ž|ÔŽþSUb A¨«{ªyæ‹)KË4X²¯{E ö±¾‹s–be¨´ÁÒ3ïT­½?­x0!Ð@Ógw$ƒ;Q°Ý£S=‹Cß{ ¸¤jZ¥x•!rb#omYc~cKüöʸÂVjbG1b½¬Ë|ö‹ÏФ‚&7¸œH<LdšµT;¦Bdº³ }ršîðá ›±u=6ŒÃW1Ù®ý€µçù™®zš¸$$c¡¿’j£ÏÉUI«Ãd@ò˜ Ô“ûºUÓáÈüÍŽVÕùN‡u±¶Ñ5û´={˜Þín¶ã'ðs8)Q?qº]»¿¨¡xdWÐ殂j½QíñÐ’MeFw¦,V†3¯Óoo '™/‘É0(²r)6¨8 ‘Ô8À/†@ß ƒŠ$óÛ”º¶´@ã­úc2‘eÔc`FÖ`ÒHšÅgþý½_ݪ´Ù–|¡Îâ{ Šµµ9N2v?³ÄÊ——0X5tº!žÛ(i£ùnT§øÚvS_"ûFžMŠ_´ðUì•Ð½­û5Ð2†J/oÊ‚V ¼¸¥«ý‚—eXœiÌCRI«‰¾ÿPSâ+½çRNdåÕ4ÝNm{ãºÑ£òg<Xæzv™Å§îŠTŲç!½çQ¾Á·™EVd¾ÀhŽwƒ :a2ñéGµâÛn *Áš¡ŸTl<ÛÑÊÔaÜKžð¯éƒfµÚÔ ™ e‘tÔhOCu7yW/l/ãÛ|i×»þúGø!d @X‹ƒ6ÛŸmÙœmPNçž-à“˜¹¼“îË4Wíäû«ÒY ü³-ÿ¾ ÑÛ»"0÷ÿÏnbž•9ÇNÃŽ–QÒ-ÏPzÄ;[/×ã,_ךo~æ_Gÿ‰Sï`‚¼¼ñ«ÿ´|-žqzŽÜ/˜Õ[:¶©`L°/‚ärÔX•q]j ;l¼;&™÷pyì8Œ0Šm{%Ð.f¬’€‹ Èw:cl:ùÇòÖ—5‘a[!ÍØÔ6òÓ©ç3Ö“Už7ÿß«½I€Í•VcLÙ… °Ž~ã°ÝþÍ™:šXgÊìåO‹ï8)¯öö0Ž,m“^ÜfΘV¢Q䘧?½|ë7DݸȯèÇ{&°|õ&É‹JXƒ;mÏCÝL “°*ÍògF Zñ¦3ÝlÈ0Ö+�c­K"¥IŠ^F¿v½QaQÃ{þ¾Q!Ìf)ßR댻U×>¶ç:30-CÙ‚´P¥žkvJŸ_$Ñ‘Ç•Ä9 ¢£íå û oôü³‘,÷pú*‡O+˜&Šðóu ¡ˆò‚ûf®L+‘¼‰X6<~×@žåÝ»öÖC±ðÜÕ©öfÑ>ƒá‹|¬£™ô¿ ýX”îóq†\Õ{g7cæ# *· ×YÝ·~jéå:—ˆ4¼mSxô®Í’IÔª‚‚Üä„x)î.ÞÅ Õ¸ˆ3÷v¹A!X€m,°ûËžê‚nC¥wy׬$ ³+ƒøcA1(¬±…0çÀéû§\}v¦TÅäv,î ¿&5Œ+'Ê hY¼:1ÆiFßJM´Q÷ù—vr»;úé´Ö¥† Q A1 ©=¼!ZØÃËöU0òR‘ï{+¢VùÍt#ÚvMÔÖ1¨­‘ìø ¿ .dá"ðÇ–K¤õ§ÓÉØw‡^¡ÛÃ>`Ï™¥+8ÄËÊ\Ù¬»…{×ïïÊrÝ·ˆªÈ¡¸!ÆžUitÊ ¦ýkÊÅÇ®UÐ…yR(O¬«užñ¨~,0x¹#·q›}E2ÊÞ–ôx7}½?ŒÀtßÿ­3P–² *}´«u„) èpî§ß¶æ—ÔÜCxö¼­½MËCt:ZwÎõú¶/7ã›Ã$ Évq±ð˃qO±m®=EJ¯É/8¦×Ýãò̯ò�Ñ ÙÀh@³ .»!˜½&úWþx˜Â'©`”ù¸?Lœ{ ‘•CßÁš* ÈI˜ ¹ ­(µDò~0…¼µ6WN—åTs[}oŒC\AgŠ(ŠôE|ËTÛ×òAâbŒi%fJ.<¬ØËÊõÃ׈1m¯++¯’2CkMpláWÐBqô—É<lç©oë˺¾tUb}Û ]mè”>éÙO݉d·¿ÇzLm¾,y63°°Œ,ÅX“ÔÑ4çdð’£AúÖäh< ~aµœÀâƒ^czË¡­›ÚKjŽÝ©2©ÝY‰S‹izú}UH€SæÊ´‰‰E ö5þ„µ¢eƒ»ÎB‹@–Ù•Cý­ÀìëkAEb^ößP¨* ɤ‘;–ðy™‹TfN¥Aƒ íƒèóÓT’P¦wB š`”èÜ‹Gö&‘G3gñ~Hg~ìnØVÁŠoÆ­ò¾n/2SÁ¼=‹ ¿ ª·38aM@ë¼£<yìÊ™ÑX\QÍhz2nÔ`§`Å/Ãë¿»î–Gejä0Yƃ˦Oƒt­ HÀ¨Ög“%q™ø æfYú6ªPȲ »¬HÁ"½­ÏT›ìdU\½b1¤Ua»ÀHSk襨�$UAöõÁãæw¢ì&=þ ÿ‚!¦àì{ž)Bœùš÷ipø¢ô5ùª}t¿¼½Žªt†öȤ=ý"‹™¾Dôù×›�BjÚpK-ì5£ž<ó•jàŠ›ÓùÑZ+'÷ˆ‚*'ÖT•|­Ú³‚ 6Êo[:FXKÚ0ö0Ùæñ ·÷s<Âöë“»j¹S¬ *Ä2o“Pð�ÑÔ»F9úŽëÎ꙼ˆ»³X�¡¸‡%%ót˜Ø±#Ã1"í"3_ýñß»g:BYn2ۡ˳ µ@!ÇABcØdTÆòŸÞ#'OJö±þxÓ×NBï¡ðÔKzÏ_³›ýb„-nçÆ>[ ^?í?Ç¥é,áO±†]³¥G”ÛÞ(äij‘•<" œl^#†× ¸åL<u<§lMûkNõÍ[±PìêƒÑçØü–¢%FçÉáÔêËmròÞ…qµì ò½î ”ûÂûôuJï†wÅgÂÌ7r’•›Ùéìê;£xonÊwJ{q™yn¿�³`þr±Ì+6o?œ'np<\d¨cŸGžG‚{VÚ!rxÊúe•CÄч ÖRñ®èlžn´ä#í´/;I`²élçw}b½@ëj¢¯‹7ÕRNt½èá­Wu–ÍñV¸n*¢ô_/©_ïŒý«3NYMÀ,«Àô5À¿P~Øü(2Åó*ÚÕ Pžw4‚{ ßÏßþy«JÃ,‚÷SÛ^gGºdqRùy�Ŷt>MÚ{Ë2K3d$ê8üªUxý¸ q’ ˜uŽ<^:fø›¹W?ÿEtn¡ðßÖFyáF*ÿr+;Ò'GŸÄ ¢ˆÍ%¹]šwÝОø¢ t:Á©È ’±öÔÙé#awC’ÄP(õåqyU¦ ýœ½Â>±Å[hlöôbêýpn“8i´Vsø$ôaųéŽÌgT!Kœùô~ÑŸe>èvk÷…©zÝ{&ô¨2슜vfkì}ÿÈxZ¼²å9Ä3Pú¼\”:’ä"[êXe‚Œ/R3“ðggRá©`fu)‚¢Ñr$ÅMª?¬�;ÀeÈ2e˜îŸÁ¼<¶÷vrw¹1¯Z_Ê ýœœ‚§E¡*›ãÂ$:%ß3k2€U)¨¨è¤Ä¸³(z¬u¯TZÕGúotp²]íþÐwºum¶(þ(ÕhgJn:û°¥ [M§¡åÚ²Ñ\r×ë3:¯“-b˜æŒy•õs¡w„£bW+YóG¶Á9AJ «ñÉ¡ql'#Žƹ<}®4ˆ7G¯„–ÙJë‚ýNLÝíë£=“{^åLÊδ³ùÝ0´¢*¹²OãŸî.ŒåFï‰XŽ}Í’ŸÛcD£µKƒìžo„Þt5<M1êÿ`(1X•÷€•&\¹¡Ãœá?Vl;eœåí ÔÆœÖQ=ûN³¡ç>å’gWª°hͨÜzÝ Ò¶Ù»3|߇ÕÞ·p@ù…¼Tí;öNýEÝ «‰5qUCÇï`]$Nòk¾ &�ƒâæÓ㨠cCVL+°õõQo7Jƒ• Ôö-˸ž¾9ÝÐص=Œ€7‚d¼»:#÷0ë>ÊK'¬Â7º™Ð<±þ?IèuÉ u«>ªÇåïüU,@(fû@Ã\s´ºOٵΠúó3K7á„ Ò.«ÅA�a¸{¶ÿe›5/œÂ£¦š½¥5J£ErcCš€’4×XþT'°8ëàa"Q!" ¶ ¡ ƒ‡V-Ö~®�Ý‹Ã4ãO_A“SÖ?3ù³ ¿›È“Áa“¹µû/¤¯-Òë޾ģSÏÉ.âT¯–¶>zåì'üšHE]¾S¸tt!¹ÇA?åAT7žæÍtÄáÁ¬ Ïvš£Ì·âðQn<^Пd/“I\ô´Æ)È·[XøŒ´ 'áñ=€rK´ÔÖÆteËÒpñ‹öîly¸æí¦EùRºjuŸˆ–Q”% µ!Î¥äa¿ñßÓ,À(ŽÌô»¡·'*4! XÑY&Pš[~ß„ŠœjW$ýÀ[è|¬>UÒ#£îä¤u¹ó¢•«,Ôñ—K;r’§ÀcéÑr:×âWÃéq¶{ׯæ}­l>S­€+)˜/ý ^¤]='æùÄà·–vdšøú‚ªF—<²+üo…ÍaîLJ{Wvg6èyŒ‹ ·jØ~1äìÒ‰"ÈáÌR\8K·`\Ü{ÛÑ®…õöÀbµ:qŠJœQ§%B1 sÄXÈi}·C}nàé´"Òó»êþV{ú¶Îçã>‰ó[lÏ]GCÇŽþR2+¬àFÇå\ï4oo»ÐLäíÃŽåìi¯ëžóÙP$CßíÚµtj¬ 8œ±×5Ž '#‡ ìÄ®t#Ú·ÃpÙSçÍŒ,9=1Ê2%Õ ,>û|‚–ÿ´•“i™¸:y`‹4ѤÌ{€ßáÆœªU„v„ш�COIÔqEë3‚pîY#m^Ó¡QØZ¸*�À‚¼:ì®ÅÓÌ(~Hsnê�½¸QßµÝΊ¶^ÁN_A¡V¥›¥3‡sL4­�{�þE¹è{ÿ¾1¸l®ûæ0ßù ìL³Aå4ÎTå„­ÅÇeÀ“Mô]å ZíƒçWNÙËwË‚i¢¤ÝjajÉÔö}/…“¡×ºBÃD‚³¡ÈžŸ´ñ¾ïQåôX °îgøðꫨ ~¨IbW�ç¼ážãt1F¸€uЇ‡ÇÝÂ×FÒy²ðöLa”ÃÑ“êkº^Úâ&€}O‹ª*¼Ò"€®L:M žtŸúzk8èÚÆ{mŒ²…ýZ¬þÄAò¾qšÜNò€§oüNË”¢¹¾I×{õ‡¶c¸ýôÊ '6Œ�·5UòÚâXâž;†Û£fbéb7†E‡Fgm@¼qã'öéTÖ«=è~?·Ï"_bsÓK”£Í$Ù–~ÄRd:;ò º5¿ðót®U%O/Z]"7 )‹ÁÉý>KÔKEÃzLB~×ub„–¬ðÒ\Ï|?Q3ùÖz·¿·ìd¹7¨Ößð“so¥âÕ¨÷e<{¼á¬íø×ôSóðjçÂg£Ø6žôøogëÉÏSͬ5îOÖx£Åt˜¹Np"XUæ™ÉìQòiY’˜!´cÅ_›?°ÛЩ Ëš2û•Þo«ýÉ*²!«±Aî¿4Iâ?#Öð@M0Ü1ñ°’I˜¹Rizá÷³rwö®j^raˆý S¾Ð·>Z8J¤j2G*ãU^B&£-šzW€ùÄŠ¥UÆá¤Ô@yìœ@÷z7ÿÝקRŽºq_2§ŠÐÇõehŠ´«`®Ì{!É1W/­CËãÇ8nA§´þݲºý,U V£ˆS¨ôã ÍuÙˆ §Šé?nœcmÚnXâ Açž›“�>Ì뢑;À F€^E%í9pcýá==™¥$tWw$¯bç“(2½ WѦõ(4°yóC|™ÿåMèÇý$¢ëÞåmžQ,xSØ(x†Vt>Aãw¤Mƒ¿s¯‹JËfË#áçú†"Ÿ)a%Eu7n©p|?zÐ hMŒHÊwÖü;³,ÂR™Ê+ËÑk€¿ÌcêÑC‘QÀgY.¤%–6ý…!Ò¯=,ô䤌Ä\µV,2Dñ&uJÆÍr^œM­cìmÇ|¸  î¹G‰F›Ì[ä‘w*™œpq]ë úùÓN*“sW†²CI¥£ ¡¯‡À:óQì †9kѪÙ`àõ—› ŒÞ¯þ~(›(‰‡6kxµ5¥¾cg L ª§æò6Ÿº©­-姭¢½Ð­5Š”áŒú7Ü^ûˆÎ²ùb) ܯ›ËïDµò%ŒÖ(ëóFŸ–£+Æöuog=Ñæõ!c'Ú´‘eª±âÞ’{­SÜ;îf.êi׋‰‡¹°J¾n cmÈAæ4iæë}ùÑÝŒ|ïÿÖ4¾ 4M¬køø ËcœÚž>œ¾3½(S!'á]7}Ý õémƒDãê'1e‰2<oöívhëa¾Âûõá]‰Â8-M[¿BÅ ¢OÞ­½»2^ö–ÿñ-Ç M¬nmtìWþZ'vz“ °®kF@7¯OÜ&ı·¶-}Sc‚MGû¡©%³ŸÀ¬1Ñ—'!Ëú¥¬¶;vÞydý‘UúU©Ý4É<åØ° š–v‰™-Çâ]A²uàJ7‹c}««Ž«‘P£OÝAº¹cÿmØ]Lz€*kÕJäóñ4èˆ.»’ ˆ½©ËÁ:ÏfLä¡56ì&kÎ~ß›‡±=#¥ÜŸ(&ª\¤:íV2 Zoÿ½U Iyª˜< 8T7R#qf¿0ܶB¿QlÎòC±Ü{£Ï mþ˪fÑ-Í(·Ý…‹³ç®Ö™Òd·ÁÊ2Ûñû»Ûµ*›®Z ‚^ÌCŠj¡rò3}p}VF=æ¡uK‰˜ "ØLªïV<,}µ'ËbŽ.i8É*ì™oÿ¼e¦÷Fºuž8îá²fàŽØ'¨¦¯ïvùü ­´Ûc˜ßПØR:¸îpØòÛÃFml…ÅçzgNëJh'¦[ãäŽKkêzϬÜ‹^é×PõgqQŒ{ø})ž TÂùÔF­ç¯I!/Š£„™/Î {fVÝz¸Þ+ñ‘ç¾{½¿$6½?fùÆlAoß+k¨=©â­ Œ~k9¥¥Ï% $sÂX:<5Ιžoõcc©ê¯r†*l«úò<]jzÆMãL²×B¨ƒ ˜ùÐ;«WoGõT_¡!݉…NOú®0 æ¬:ëHß@ia>¨ó8š0û_Ÿ¨ì0,k]÷Cº7Â( ÞˆÙVKV:Ù6“¡™ÆÑÇc|—¾>>,R7€b �1ÍO3¼È öå3—„–ŠqÆK=ŠÊûô \mó<ˆ7_ž¬8мtç#Î'Â"r^ŽW?Êá*�Ë…Š}Ó²nU€9I´Õ%5t_§Éʸ„ðu@ÐÚÑàr}}ëëc}Ų> æu”“ê£q  øê¼ybßô‡6DIæëÃ0zJﳡÀu):9 ‚^R†éOß2 3ŸJRªESgg²J•åŽ‰T ëG¼åËm3¸rl”œùÔÜ…llp qwÛ^² }*deÍÑ á1#î¸ó =338|z—¯ŸN¡âýÃò4 2k”™H[vÞí;1¡ôF!ZVŸñ¼ú ©Zy% {9ÐÉœZ÷Ê4©éMrÍ*XÏÑý»á{v9œ*« mT·1ã¶èÞæ%S}„“¼'‘FuDs¹íÛ6ÄOñè]–­úJŬv‰ìò\Â*ªÌor'AÓ@»ãÝõ^DöÿÍàšêáfÕƒk5hA3ªQaNw25Å.°AÌjO·$;wŽ(»­ôàÌèò,ü[ÆÆq¾æ®lET¤©6qÙwcº@]üÓrÕŸ‡“&„[ªÙn/¦íxpžéb‡¦©c½)sëì¬ïü›nŽ[Ɖ„ŸJ[‹[Ã6¼qRç–Ó—YÄ[á¶ÌÁÌÚK æ¼í‹ ´Îcxۚ²’M b–‡1”–Éi{{¸Fié›")ŠoPì=ÓAÑd‡„×|¡vä¹%ÒŠýöä(\›î°^ ùºR匉PŠ–¥£VÍTv÷çnGç6=¹v3)k<&‘‡ý•&:ÙËIBrŠ!¿2yd ¦ëV[ÎÌ êŒÌäï€òéØÿìk;ž²-º«áñä¤ ¹ÅpèSª²4aÈX[Ü+¯U|ŠV ¯Õ¤,\‡¹PâÜ°NµY?Ñz8ø¾ÁXõx¬ÙTebÐ'‚Ïr¯´\t4-+¿ÔšAü[jˆçG&šÜ?7žþVƒÞ‚/Î÷Z'<=y8HX¨‹Îj<§tç€uöQ¿ Ú¦%¬ÁÃþs²´>õw3eåA‰Üe½J ŸògFôôzåü|-Ué•{Î5E6^¬­MMÇÁÅxIýF“-ªR‹7Æq3Ã2õhŒ ‚Ÿ‘Í‹û1‰2÷¨wLÙä¦øQÑ`œ$1U$67ämƈl�JG:̾kŠ—™ŸÅFõ1~WA9l¡$¢=q`By¦ôJB[CÐظ¦î6@Õk°(¿.·˜Èdªcךcá±7« ó˜ê]KJã@ÔoPLi¢erì»×ÉÆ}Ínâ(†xZÕªA„(LAuœnë„ìúõ <{^ΑQe¤oÐÝÇØ^U™¸£w¤O}vÏ Ë“ÜÙ¦T¢ïiU§‹wïkºO°‚RצvvPKk¨Ä ”\ü'ô‰·µ`ð&VÕv'˜7à@ö>9ÖȲ ê 8N.Û! ’I}zfõíeh€–ŽeÓ)¡•ab§»ºý©íî«¢Àæ”AJX±hµÒéw B]› Œ}0ÿRdZ)³êÊ´¨rì\áÓ±[T:¤+^ EEÉBÕz… ¿fëµGxÞgâý–Y‡f_Ê÷öÞpñÞi脤RšÎ s«ŸdZ滦¹ ôg$!e¹¥ð‹!í˦¢„xüò`¦{lfisNIš‰3`‹ÿêz¤‘!‘´Û‚%Mc;ËÓѸDÚf¬ù#¬+è]Þîþäc|CU˜Š Zo=÷\z¦ÉBKEV‡é½;*­*}™\ñ8¶Gú”µö³à$Æ»„î#¢]RÁ›—îk»CÊ?ö =v´äX£­WlŒy#‰-lPBÍiPl{ÓÁŒv…º w{nÛÏ~Œþ“”¾~f"žËÕàü7NcßïyH~wÐøfä±Xxb¸üÔ~9.¢ÐS¤„VÐ=+Ì‘å¾5Kδ;nXèãÑ nÉ;ü'Lø›ÿy¡º2 êã&‚ôÉ,FÓûí‘’öʳ¾Y—aèÎÌûÎg<õD‡#$zSÆeôƒÙÔ¢¸AÝ®? yØ×,N “”åÏVN{c #ï‚Âêé*ç\Qc6•àýø\÷£ jM4£uCÄõYÛ¨a! -¬ýŸz!òþt¨ ¤XЋl‰Ì|w‰RÀ~I� =|»Œ9!ÙRÔ¹q»UÇI7‹¶8ì/kɽù£OZÇièË€¨ÐÑ׉†Ú3$(´#Ι¶VSÄ<v¸f‹€X‘9ßk¨xí!è­VÎ8M!ºFC |´æAÇ‘vè#¹^kt§rHÐ|‰>;eÀôèþCùŸ‡&ô…ÞÝLTz5‹ŒÄ™Äî²Be(ªU÷…Yìg,áò‰çÏ„†²äÊñ‡õÈ�p3²‰¬uz8Ú˜ò;2'éÇy+y‡JÊkÊDn¬îgÝïĨwixwE|-5Ëž8;ôt£^xµ"”˜ÁЙ!#ÆØxÕtG†ô›ntg‘ßn<ú¾Ë©fÞÖ*èKmÛ×':Á&åÖ:T¯^DÆƱËÁEôe8BGfn­ »q'�ô<PÚV.ØÑúMzìtØ¥}WMO‹¸SI¦R%£ùŽ;Ê(»µ#˜„ÞrÕ,=¿*äßè éií);Üu}ólmî_Úa¢0)Ù1vϬW*$„<;9ܳý1C¼ÊK:P•¬ k ªiÃcãú…ðIû$“ojžÜ´2nšVâ8Enz¸à)ÆÃÅ ã¾–&Uí||yðkÜ®Ø%‹¹h=@u®×áhM)¢—A!Õ¹ë®9P,gÜj�ÞP·ø×o†‰ÙdFÁŽ>|g[2hXã|—µrì/2v³ÖQïá/<1ñHx8Epø‚x„¶<1Ž$m p‹”êÇB®ŒT]¾xðGÛ„‘[^ÇA>}Z¿6ÈÜîÖ³ô:ëN¾ÅÝ«›9kúÚ lXJ÷»øTjHμbª® ’s€Óêc¨—’y@<èZY–L5i¸‘Ý×V¼Trcçt‰ Ö¨ÖºSs†SÖOÚÚQæ0£ G¡m½7>‡ÎòÐõ¤ä–…ožh(_+*—#aµ«žÊ²õ¨\|(òlvnZ³´yæ ÍÚÌ™g@¡•b]Ø÷ªvÀéÓa¯òžRÔ�ú(ž/Pw“¨È<íÚ0¥2›–o2ªªÿı³EêŒ@ Tê6­júûFë¬`Æ…jCákjÉ2¦¡ª¿l^*¾–îlwüq¯2ªJÄ•q;Õ :XµIdsžÈQþD«¸£”µ÷rïû—2tßô˜g&ÃGAõ>zò*й²J}ïVô‘?`ÛjX|aí/Ã`²AA ^óAópab[ÐO÷îsp£‰±nÙùóâÛ9wjh… S|iN4qJÕÇÛžŠ ·# ”1g0ÇÁùï]ë«Û.’µ9=âVÛÅéx 5 ƒõÑÂ0èb_‰U¤©Kÿ%]ƒÌÑÑ’€2Ð[÷ uYÕÌ5y–=—Yè9€¢£7Lû/ÿ¡8Ó¹ðÞô…÷·vNÜÝVÝõb­7ž>ðÇ€™°*Qÿz멇obPB3ÑêuB^àâûðPõgD^϶,ÓW}Ê~FNXXܲ H›”ÎÄÎÚ…„�¦czûÆÝË öÆiu?Õ÷ôÂÄqõÄEÎU×y”‹3½‰×âô 5|o ¼óÓ™(ö?È"–tŒ\í`¼XÓNµErÀÎ.„Ý¢]áŒö8?Ht¶Ý8Z&$!¥”ü‰·åxñdFEAhÍFÑÌÇí4¼f‹®Åræ^^ßýC!äÎ/Ð:Bµî.h;©fÈr‘¯µœÆ5äAÜ_�?Ì ¢²ô'BXµ»¨Xx�tíZ:r¦ZV¸J‘iïÍÅ’/?>” )ä彧Ǩ~–Ø$¦êÊSÛv_Œ!¡|€cä­'§Œ.è÷žBlüuqÜýaµUܾÕþjNÿB,êæß;L „‹£!þbìA›7’W8nó++/Èræóª@tvSlÊ ÝÖÞ3a1ˆÎý§­±âù¯4·’~"+( ]B+êëÓÓ[¶¥¨4qÞ©Ê€è¥<èH¼‰]…UØ°Uˆ^J¥šZ4Áã´^³ùØ«Š°™ÏlS=ú¹¿x~ñ@Üó§pÛ…2 >¦Ÿÿè2K ‰Œ^ÝôàZ­;pq¸ºvªº|_,ñ¾\RT±î»Ý™ ówm­Ö‹Q3?d):q¬Üp ×,›À3Uùü.Η’Rý_PÕÑ~z£#ùðàg †õðÁvãh±î]ú2\‘iyÌŸ`oèx*—�Ή³–ÜÖfô±ßhY”ef3~Do8©Åë/e?IÊÿᆰϭÓÒp!ÁF§|MÛÓ[­ÒF‡!ªê"Õ'ùdËW6eè<­ØeÂB²ÎœE$äFÜ 0k°¾±S€HÜ„›*Gý_C»n7Ù>ß¿KK“raóJÇñG¤æŒ‰1¦f ªäöÀ¼íŠ~7«ŽBÿž… &§tì[½±;JoožÞÐ˽¹X:ùSãf›hó£å)þï³ó¯€·Çè‘/{øvãlÝ5lh—§Æ³ª= ”  ]Ùé-?bs~2ãNÆf´ ÒSkZÖxèG4VEŸÊ©Ô˜Uó€äYš%F v¢[¡}Á©¯>Rä®Å%ÞΟ FçQ¸0N‚íKUM8˜¯ˆ$ÑÞè ö~IõxàVœ»º…¾UáÂæJyPÚg’Õ]&€.™Ø þ‹ÕzV°è=xºE¼˜×PQ‚ =m|ZiP© ßÔqUö.öZêLð^­S€Ö}O xÏÝÆJ©o›&?÷”»±˜s*b…1Œ™6›/Úø4}tHØ)û‹]¨{W×cÜ(J1OÅ€¬?´â ƒÇ—êyYµ"©t£*f>‹ ÆÁ”ªG›ÑÚL¡¿GµÒï@Ìá„g®÷Ò“·×C¸*\|̘;Tq7Ÿc~¨À¶î¸yd'åßw§Üð"5‚Õ:øÓîJ›W™OÜ0âÊÃÎ1Áðr 4cû× ð„ubRÌmÏolÏÂÛå�:*܇CÝ×4HÎ×´®W<dÌκv ?=Èëõ׬òtcñ,ŒÎAÙè„;V‘c6Fߦþ€šäJëøU†“õyÆ(’ûw:N“ƒ»^àý#Ñiåï%µÐz¢€X<³"ñ´JYÒz}ÌäËÂÁ“; =ý¯UÄò©v—¯âe5BÄ ‡Öõ p‡ùè¢Óš¼ (ä“þ­”-btã]ªBBûjäxO`ø6ïN‘ât<"Ù”]ò¾y£>Õ–Ÿ*ÒÊãÚ+fðù&Æð¹<À¿² xôkiˆÊÆg†T$Îá,ß…å›`¼À²$TuÂFÀŠ‡Þ›¶Ñ’bf‘Ó25–‹ª ÷°° ˆàû¨ŽhጠÉ(­^RcÜh[çîrúUg?ß{lEÙÒï0Ä÷¨‚hÞxTüvWÖtaØu«+·ælaRßÒmY?(ˆ®‰»ÑÍ©�ŵ¾q·†]Qæ%¡2Üî ÔÎS$Q¦KÇë3­°ûÝÖÔ3ÒC37¢_ñ:â“ìUþ�×J&bƒ{OOÎè\…ù¸Æ›ôECo@­)Sì”hM<3Œ0¿ué‹ld6dQéÞ—“Ì”äÔ[ú‡oiòOj±iFÞH#ÒÈiæXÀ8ɨXŸÌŸ§[ܲ]†·hÉŸÍþB—{ä2Šàð_‹ åKk¿œ&+²Y!œÙ½õÁ“e}‘vpÂ3µHa_TÁÍ2ñêFëÞ™N„¥{üÏnøÇvÈîüêI÷,I3YJ@;Ð Ýo|O,Œ|qÿôËÜÃg>CjF•6J3ƒñÝ)&Å_^©±b¨'Ò(î܈éHN»vÑQ½7(›šfžU$£ôWò ²�e#FmÇÏ߉†ù"AàÙôYÌÊäžrÄažÎm㔞etsÿò&)K\ ::4IP³éÃòÎTz‹ VëúÊ!öØÕWˆSk·¢F½ûŒª›¦Qa\"Wö¹êýd¼é5±ý‡Þ}öUëŠEöh¬¨$/¸[ <© =2ÌLÚ ¸%vZ»:A»9ÌWZ¿ãiÚʼgÛ¦ 7y q°á9·ñÔxáÞhó´±nÍ{yé.¯ÇûipúØãŽôlçIÅ& À³S´öìþå‘•z„…¡Á\Z•mG«°T£<0 P¥¼hÞVd ¹ÒÖ nó XeµÎΔèjÑUŽpÌ#t¶Ïª5IÛ›Öãj<¬‘þáCøµ'6Z‘àe¦–Î0–PÂoÙãIdÛº•ó³â‘5I’-&³h­ 0 :n\c_N>Iøz‡ÅzéƇE–y<€8ø˜¡úÐ}énÓ؉[›±§U¥i£Ýü¢ë-ŽHŸv^¸¾%CÎV‡”ŠüO+K‰ÇŸzTÛdJÙ,üöî¥â²ratDEZ‡Dßâ9HCÌU¥�”kúüÊÔÒÀæáÅ^O+Òkt§æq7 ß'ñŽrh^ð2‘å{îˆ>E IRçýÄ-ŠóDë$Y¿›îkeØ`ôN¨²„ÚC÷÷ŒñëxÚp7äqŽy09Á"1&ÞjW½9ÓM¥D¬Ç~s˜Û2åïcÁ0?#{Z–Rjœ\[xz†£Š0Qèÿ8E2œA¡âüfÞ+ÖÇ÷t±¥„Ye/ *Û KXŠ.´ódLŒ<Y½5T˜‡¾v=üný ’úhÖ•¦àÍiÇ*Æÿ…±8¿ ¤}eEÀiC šWÅøS‘ß*\ò’‡s¤VÞ"Ž.!V[_ á[ßïx62´ £l‡ -°±ˆj7@mJPé?@ã—¡wÛÙ±Ú&Añ©ÍTþà"¯`7­VÖ1j‚\ÒÙÌìßAóÓȃæsŠø1çAqR•2 •B%)¯š (ÌŲsÿhpäeæ=´ØXÌž}ÉTìa 7øÎV6N—f–)•x@%~yU m2çáÖt_Ü]¼Ü"I-<WH_ŒíꎞiÒ'²ñ tW\.Eð) ”nÕ½™â*÷%=¬—t™“£xóIÅr·£#5osr°ŒJ ™2üJL..=»�¦^ìŽà,t;vÁ·€Íé‘b'ÙS+ ú@t7QªÙ #Ig ½o?!xÕƒÇãýQU²9í¤þ´_Såt¿ ÓŒd= $#Ùi«EebÕ:(óï/Õªò£ $ò|&Ø’€Â“Õv &¸Ìó‚âð�D—NGrýùŒÓ¯VÕ´ õ=T‚Õè?MG˜`Å]VY…~ó ‰=U?ÙQ¡íyAë’RÃ]€ËCu·X øÂÜ>Wk%VîØhz’î:Ÿ®š–ž)€¨NÒNI¬2'žþ O‡n¤“0SÙlÊ»»œ2ŠÂÓá€+ä©óNé£Èn)!yN[ª1©ëmsUþŸêTÇ…wç#¶à¡Z!u‚¬!²RË?{Ñ(Ϻ#‹˜ÅÃiO±ü}òŒ@¬´”FY0Ù,æ>".É}ŒÙ¨p(AÙ~9l Áˆ<‰ oLUû@è6õÌÒå„öÝûÚS웸<³.>н{MûÎzÉp!›fs*ƒÌZÈ1‹VsÓM= &•Ì™Me¨¢më~Ïø¤ð,&¹‚må1� a¨„v¬!Fr¢mèÓ›² ¶(nËôDÒÑ>HÃÖ¡Làbßú×~]ƒÝZîÐWxéBb!æÌ3H:í¯§5sv°€9õ0ü è–êš¹é¹z ÐÐ ·X¬„‰Ùµ²Â OFÄL´Ïi ‚E×óºZä‹ 9®‚ݦ`9µÄ3mÔ»D ᆥ\íÅ}‚Nl  trÜvtcúw—.Ó'{?liÉë@ôuŒ3âJ ¦¡ïh±´¯îRïõÓôõÛZÌ›'&lÅ ó!È»¸|ˆKT¦c½ŸxFTo7ë'Ë|,*½Ëå@©péä?‹@ê5™Î5hˆ·ãÎŒä%Œå>ÜŽ¤¹¦du­Àç,ÔéÕñògbŽ9u´'¤áÉ ÄN¾“e ¦ÚCél}Às¸=¬>\ŽÝž(§•¯ã]ÎHl-0ìB‚)½› fAS•Aøn•ªSç Ïß`ìÚ#À;7y]–Ž:±ì}‡;tŽHDg>+Zêăw«°ªYÇ,+sÅ@wc‡g^×!‚?&VŸêˆ³™Ä‡HyyȘÆÎ’‰¯œ(f¶–yÈV“‡~*j00i|ªe”y'Á0·y[»Ï˜! pq”6®‘¼zA’ÕʈÎ-Å}êºÒ´ÙÕ¡¦°ðçdðØ ×±½)7Îuß /ÒIò9æ1„’Ò Tb¹¦&\dŠf~b*•týê1†ÂʲsRæ£ !šaÉè_4‚oŒüOÊ(‚žnDuÖЪս9=}%…ù´ñ%ÊжRÒ›œÈ:±dp8ÕÀ‚¨ä†ƒÈw8„T¥ÿfÓ2¬cu¢LôØUA¼Qko€õ.”±Hö­õõ7 ¨(ò¼…bŽ˜·•LEƒ3¯c«Ÿ..µÍŽf!8ÈÇ8'ç÷´$£@™ îduθ8q[“äãìv¦•/v:ÆO¥}¸$yp(Ù”'…?BµÕžÕ„Ž±{ RÏ;Pråßû ø(ô=h Ò‰TŨaÌ~ìuµ†¯Ï¸7pÅë?:+|rÄcÒó)õ 8ÑrßOÁÀcøP"ÔH™G£o/}$I¬Åÿ@{4›È(²ê!®"l@}ˆµýñг~£ÎY…žz˜­蟪UªR…õyê?í«†bç_ZuH±¡¿]|�´ä&iRc„ãÖí�Q}‘‰óµ?]ƒ¿y5ÇÒØ÷”¡‡‡yMR«¬r±ßíiFÛm2{ëG#›è?Y¼À£„9G&°9 V íÚ¾¬ªâäéR¼ï¾ 3Ú~yp[>ãð¡9ÓÀøóÿœwýóRá±äˆ¿»c$ó»Ê©”"ŒÛm6°Gà þR¬Ú¢Ø¿Úñ›…ß“Þqë.‹Ú÷Ùö;™ñÿŒd‘^IF†ð8 ª÷µó–fUŠì³–ÖóÉ`'ÞÎ,®rý³œ6fêb¹@Ÿó˜zv´PÔð J+´,XÜÉÖ™Ž»þ[,­oMÃ?SRžþåµ)é9xÖ—f­9¨½ýa9ʵÊ驉½Çžn¼Õ,„Fáœz‚ò’­Žxdä¦AngE¾lD>Fmx:,Ohí‘ •ÆtpµNh‡³Ù¡HtAâ/< pUŸ{ïJ&[v˜ OúM¢-pXÉÐ{øP¯sÛôî#x%ŒÜ¬O1©2_ž†¥U¨Rï.G‚©r7 §àê’‚6ÌŽi~ËÁÁc«0j‚ÞÐ7®Mâ±þ.¶8•Å´Þ]½Á;ëªÝs÷è·¸e¦5 08ú¬9–Oç|óŽnŒ>ŒAÍ"¬¼ü顉ÕÎ Íß9èiDvÂKõóD§“îßgnA–ž-n ¼|JZ”½7¯.ƒçyضõ‰þâ0_Ž�û´Z‡¸ÇË€A@½^ßûz3:ù—úšÍÁ(1X7jé— êØý­!£]¥ãÉó÷¼…Þ…‘yOmƒ:”L ˆHŒ22Ú„ÁË|¡(ÓD’%4CFôQU÷uöÒ 4êv¿•ÎàáÎŒ.ý8¹ñ:!ʤªéóDazÛ²œ¹t¡C¸+‹œµ®}`+›Ä¡ÿöan&¦+8­¶”ò˜H@똖/ƒ~L0Þ£ ÿ£ªíÄTT3P¹PXwñfñ˜­‹P—ö NH–}Š8˜ÏeP¯{¸p¦çÞº©ýôŠ‚ë0õ‡óP9÷Ìï¾ÒAJùÖ`çN +¶:ÎILXzׯZ-­`]Ø-$=·ZYhê1q¶öß7ã?žÑk7}gû¹ø‘mÆì…$+n…˜Ï1¶0øI³ª×JfbD@,7ëWØÕüýºæ­­Iˆ•ÀJ`\3ù¥(í³íÂ~ƒ �nQéRQ‚^Tu³U 9lÓ]ßtHräi³ �·Ÿ‰¥7OÙ{e$Aºí=kd^âíÛe¤Ô­?_& @ÑÖ÷—;Ç¥wnFašzné /Í9ýÙ¶®æpž[LO2Ÿ úµ¹«‘ †^G™l`E±pœt<÷+ó€èæ~N°ÛSv+çLÌZgÊÂøÇËçIâ¨Æè›p6[oÓD‚õÌÕdé—z1…'%Æìî[³Ì´õ°iWý¨aù :øBãÀN¿ô«¤©8Úw5JzKÓzrjûŠXìÔ~Ý^µ·a,Í.Rrˆ$œ«‰šÑ ”ùwZ¹.Í-Ë) ]wY\¡öÐq«œQl¬ãf[£ÔJï®”$P†¾ª-ÕðÛÆ'ϲŠSv “­?ˆÍËm…WzÝïHôÇ€V|ש&gÓÐÏÂÛ¯YQá;æK‘:¿;¶NŸ ƒ¦ÞÍõ0ìjÛvݢͮw" ¤ãm·Ù.ý³Øym±?cßåAØè´ƒaiš•°ËÎÚkƒÇÜ5¨XÔ�*Tã_5DÊø fi7êüèæùò$~ÚêQ:G¬¡šiï ¹Ðg_»ç³4æñ›)o~œ3ä•ÇU³eÏÃ˲߸>ä÷d©H¶Ñûˆ„q.O«ª ÉÒÆùò*ë?Hæ.e†$±›\2Î=Ú‹c´5$ &ÏŒËå’´0FEj€ÛëÒ‚nrï6p«NŠŒ¢h´d%ѯ0'Q‰ƒÅqfªÔ–uÚïàyò0ôU��¯Í}üëÀåS__xÑÓ-éÛWý­O¼¼sÌ®AÞ¨áw 9Õª¦^Ñ¿Ìÿñ ßÔÉ$£¶¹ zBºušT]ESaâo/ÎCŒéÛœ›…ÍRJg‰Ò©�2 Šæ⡶õß®gŸj·Àîéëü£íÒrvÈ~ë,6tZ{#&o~-/ôXi(÷uX1¢8K9zuXØ8+`Fž^ÁXË€oÙ˜ž0s+¤)q©(µË{ÌW\Iÿ¬/y®ÙüÑÙ"  2k q!aCùÔØã}ËIrWºsê? ,dŽ~ë§*)L(;,>ïꎌ^â¤â%‰ÙPp©hÿÛþƒô¿'Ýü÷ø®4E¬smfù,Q6µ×2mÙGgRE$Víýëš_ÅUókš3:J­ˆâ,êÂÖw"—’Í]ýØù(·º#õï+¶F8;6=m+²S²ù‚˜­}°p‰ÌôzÝžxÕ(÷”Ú¹ ÒN÷Ë ¢Sc ªIÎNv”y ·®«&§ð¨Šq0å»Ù'ö«>C ó,Æ�Wl»­@ô+Œm5ÿ¿’oƪ˜/`¡žQŦ§Iª„«:ê8äÂM>¾ø-){0!AÞøþ> S_®r—-ñ£%(ÖÒ¾_B6°¶<Úþ½ÍQé鉕– TžôähRæ g°ö©Dy~ê:¾Y–4wç#{ç¸öé§bn¢c8;L‚œÔê{d- _!ï)O6â²®­3}÷ÆJ~í…^®?jÂú„€ë8_¥ ' ²²³“Ó§‘XèÖLˆ¦-°žá4t>¹+V­Š(4@ëÍ).cã5Øiƒ+iZM¯hq˜u¸,UR™!¾Í‰li‡wy­7•Gk*´Ø‚§œîÀÕ®¨Õöèß¼1 {šÃ±â\=µónjàññÀvÒ "‘ÓЪ˜h\HüšÝÐͱÅßî5ËÉD;fqlRÏ8L KñV*�ß ©7e ô=xZé®äØ,¼b¦›A‡¢jÂVì+\S©Âu8m;æµ´þ³•ñ·¿4r3În‹Õ#² ™½²C_RA=-}�¸@=m—?¼Ú@NT‰ÇŽN©¬Ñy[lz ˆÃ&Pì¥ Šíp«/ñt¼´´C„y] EIŽf*ù½5U*Ç}TE"wùX§§òÌê@¡�V» ÂÓì ”à²o5U~çô]ùF&aÆ&Ñ•)ÐÅ®”u®ÑÎëÎouÛ:ŠÉsËè*‰³ÌÚ•Ñ™H7*(fmeWl´1MFÖ•ÏôïeŒâÊC=‹JòÖzß`¦úå2Þ(ÄQ¬ÝüÔ€‘ÀV­:! Ä‡£à¥_¦¬FiRQ-'Yhl”¡hlÔÝ ›¼¢?éc´Ðj»;å<º§ý'Õf­XVV¨+¡ó踵Ö1ì|­õ¥AQÎ$¼‰éÛ í¥¶×Ùu ³ˆ±ëmRÉò}—uÛ¾£+}¥(¹Þ§9Á¼†ð§",{€žXœVÎx í⋲͛ñþ3:7žGß®/Rä<Šœ9üÀS ´@ÒƒN˜BY0½òÜsUÇø¨iŽ` >ú" âKk““?¹¸nŠ’&¬‡ _µ‡XX`®¶£¡á�MT÷Ü Õ=ÍÓ×e*u IJÀ7fY5@½¾=RŒ|WñíÖß¹ZØ£¹ÑFl¿hMggÈ)ˆ51L»­ûݺþ²¯Ð£7Å[‡×Uaƒ‰í) Ò­>bÌn£×VÊôßËå.äy V®ZXŸ^b4Õ«¯!ý"Ÿ8-2_ü›Îo¶WB=—X®)mäÍa¼,Óf"Œ<ðY* K«SÔ·Í’ ¨ÿΙ„o8óSÝmç]É°AŠ„«-2kÏtM(ÃJ ¢ ¿0â^m' ÛuØ vï’ùYᕾó¯eÅ´RæùðÆ-,Ð udAÌǃ]@‡žp ­2HärÀÄ‘špFSœíð@-4¹Þ³ië‹ÖãIìc{ABBúZÔÚ€mi©ð°9þö”Ên6¿žÆ>s“¹ÜÌ/ÛÁkz²NÏÛš* s³žtôÓ´°öŸ‚<²EmQs"bÕÒñ8Er³Î^ ZD™ïCuª¼Óì¸eMMQ‡ò=>Vž‚©»üMÓ9Uë”(7­½f¢¿|ükmuFϯíü²³õá2æg‘Œ-òþäuoD³j…d;ªb×÷Ì©<wØÈGѹNq¤®½ñæû©ßÕëŸä®m$Ñ[šÎï0 ¯%¾ú4Í^#þože™tvD~ô|àOGaeU¦WÉêiä õÅ1ßbn¼n!Õƒ3ETOÜñùg¾÷ù-ZJjæ4ØiƒEz+!«ïX²ÅÝ´É¥a¯dLêÜÜÈhq ð;fAhwйl4º * Aù'ýÍ eŽ¢Eð“âÊêª?ÑúZkÂI`OÇàÎ2ú«QÞüë÷áR>'ciz†ëÑCú)MS$ʾç‰}8¿k|†áBk¬-² âö¢²”Ø;t­â?’,ªÖ§U‰á–"9.¸ ô©ö€æ]uÒ)-—OÖ¬íZå.rFŒ"]–'õî݃Ìù¿¬ÔÍ ÀJ”FÁ™>ˆ=$ðTê¾ÙyaHYª&êpݱ¤czG¨ß°WjÌHSYVfº…Ùæß0©ÂyŠP«ÎWœ±s!ÇŽ§TµáŸ)Ak÷ô?úZé¾Ñn=¢ zVß\úXfp…ƒ‘2­!` -Ò¼áòy‘åKÅ¡™›÷­ž©õäg6;v2û?çLd‘»‰xòT ÒÛŸƒÕ•s½ÉEÛ] £%ó"[Ò÷šYúΔ•ÃX” ÅÜÒ]¹|z.—N¦!,•šQƒ 4åL‡6§XÖ¯1^øÁAèèÚZñdùÛ?oDë,i@)xkãoñŠ¨P’9: ð˜ÒZKpø0>á4Ï“ø«uwlw#“ÆBð`çUÚ[^ „ͧ‰– ø?§£€(MãïU«+w™®A;$t’v“o¸Ì,Lþµ ªbÀÞú¾£¼wû{Oqài&ñ×=@ïÞVg%‡¡[ã¼áM6Í/ˆÇEñWUb©RÝtÔ” O¼ç}n.¡ÅYÓXYŸÞWšÐ[,)º¯Ë¥Z$ÙÒŸ·ÙB3§Ýê]+¹$.C}k¥fQizƒ£Ã;:z#É’Ð4°P ʳćíæ‚÷kâö7¾îRaH1 LæÒ÷£«ZýèMÛl/c?/×ì Oõ±A;´N<! Ùê` øŒ™%ÃÚÚ#1%'ªd]c£Ê¨ÉÕ1�÷@üð®pf…0=úÈFƒâ\‡wHŠ ˜O‘S\Ù¡&7ñ(¤ï¨ô¦en$Hîü\¬Û³$ÊÄIµFÀER”k&§åN_e¿³6ç!TÝ…=f¥òYƒärÈà5yZƃ4 ´:eìž%ìãÅó’X²å®1òC—ÃÚêÝùiËÿ‘`f¸ <áÀdé× L·VqR,êø׃Nñ®7>‘Tçš–œÈFŒ¹PJ‰b{{ìWI÷FÎ Ÿ3û„RbI¬ó‰n¨Ünªt~ôƒÖŸ¯ðǘȼЦáÌ~>×ÜÌÙjÜ­V»Ž!ñz»í®míëUˆ´•ÒãÙÒa®²§Oƒ¿Üã‘þ½Uz–d¾œrXPžI[ö8{‰‘’p[½QöؾîkÊú±5ÍÞÚ�Kæ³Ò ꑽSe쥨äÖï›™ÇÇcÑ™¦)ƒªSB!Ε«DqN8NÌ¿G:‚o“øjÚÛPn}*‰¥Š„nr‘¾Å‘O‘†bËË „¥Ÿ¡…)0i g§Îbù’;%8<sí[ä ºsLiu[¶DI‡^Šq<3ûôÌ{U ÐÇbrÀj»"È­ŒXÌo}Þ)ØZ'­IT†éì ë1èÆ&µ×‚GŽ€'ç3¨é»6£¼0oʦí Òš³ 7ìktõ}5b·„óbÑ÷b;5Ì‘ÛÉóèdr#(X7H6AüFž ³+µÿHïƒ7OëO]Ó±¥Ðç?i˜§lŒ¢ÚË8+¨L©l¿œÝzé¬`cÙ1´ç‡úÕÌ5÷Då¹­ÙZ\G¯¢c¦ëÕ¨‡¤Ö”hþ²�sšú´À(z:Rªvp2Ú�øÛ\óˆâ¬¦Õ(VÚ›­zÖ{?PFVºŒŒ9yóÒ»M:§+˜|·¥…byè)}õã}©ÄÄã ñC^éY$›‹ëßôõYH,Rñw½Ñǧ;Ý°Ç*ã}xòè•£Â7Äc ÚPmmûphßtš’½*Ydyx2â/‘WÒÃlFì¬â…^ðpäIâdB'™wuéîËÔb#X2nJö˜l{œk3ú  ×;£&§ÿæ•�ø®n±>ƒ›IŸœš<(Nð<T4Q|Ah%L;Ž“{§U¸pf‰é)#éΞ\¥U2}k+³­/ÝôTß¡È|Cj*=áâ¤c”Í·é4ÒÀ¯ŠWׯŠ‹‰ˆô†G„þéä‰#Ñ}ÒZ‡DÐ[Ö]” ¦b~Þ!¸8ó*ó‘…ˆÑQ˜=ážA¦Á朹¿Ð­8 ³¹îò²QYúí9Hë\R;šTгô©Ù’èlx0[:R¤Çx˜ð5ÆËrVš†ÆYJXéaL]Åï뤜±ù Ö†ór†"ä:«_ﻼ¸±{bÊ)*Ö)ܼk±­-ô*˜Ciqô‡^H :t4‹'ÎÞk.p[Û-a/nO Ž¿ÏNq±ÖoÓwfÎð+0z¶Pk-‚}ó\3vâÈ,³>)2#wwu£¢Á3M¸úÓZ5WÊcÛü~™Fqœ9Ndó]Ž¡Â…$_OU¤ºÓ¢o˜íúO[ê}ù’!Šë$ òÓì‚ü¶;ôok<?JW‡®}ΕJ­-HbÚþç„Þ—I~£²6Ò%Ö2 ?Ød[…¯úb+$¹oHኞ—…ùCÉDWU‚föFß»‹G¡0YÒôiã{ºÁCë %CÅ‚NËÖ ?ǃ(Žè+Xžãý8zP‰ŒÁ¸`:mÔŒÛÝ™ž8mvð/ÍâÝŠòÇv·Ùáu—~TÊ i±6¾sD†uܱ }=_VôQYãô*aÌ3ÿÜg£ßÂW/ÂÆzkò±‹'&<r©*‡nfa›é˱/ßk^Ä LÁ‡jAAŸú,B?VôÒ¿\ˆ Gž+<ÏΈRC§ä‰zõ$_Þ¥¶Ö7Ù9 ë~n’œyÓS7t@åî{–Ié?jõ“žw}Ǭš'’@UåÔlYØu{*iCYøÈ2¬€^®%çüLDyUì¡6Fô”ÆÖõ@ÌUcŽ½…í`úâ«‹©ZwæŽ\ÓæûîÈñR¹" †#­l¼aÞùÒ€® f�ðÍ\À> é¥!jb”­Žd+QœÜs·„Ôƒ™õiØ÷9ß±‡Ua0Ìc÷A9Òe‚xÜ}J,–Èo“|bغyÙ•&á•Àâ-ÞÑJgB\iƒ|ß( ÷õÊÀ±û®~œ;�œimY•<+&š´ÄŽp%ÓZ‚ÊØ µRÏÜm·ï¨¸ëöGQþ¾þ¹­© ?íoÚÕeìèð®|\«þz ®®t„_®Eé73á<ñÛFt8öS$ݗîj¨€W\€ªÂ©•',4‘RÒ´*-Š1Ps òIŶ_ôi‹©Aò(V[»§„û©Ç°R-÷ïµÕ(©œ¼è²`/ z˜ç¸·ôô¶Go—fû¶»È`Voè£Q€g®È¥ù Ÿ¿ðøå¨bYONï­¦ÈÉ¿D¦ÙÐõì–˜¬CaönVoÔ~=[¿7k¯®TæèÖäArÞ¨{½@/é Q:©Ùô7w£ÔD51–)l·ÚÙ+œÚ­ÝÊfª?${ã󓈇 ñÜ¹Þ –Lµ2S÷oG UäZÌÉ;¯éÔ¾ì–n^ÓóNÈ(gtº¹ø~¤3çÍZ˜îU–ôÝ&U©<NÏàl)ÉòCqÇTM^Lµ ¢wç£2Ìj{XØŠÒ›`º¦/Lö|XpW¥kÅ|» ­d»E1êMëaC$¾åá{º[FèyµÈݸPå¸>¢’•‘õˆGÏ»ÞwÀÓw’»uþÚ$^(S±¹¾ä,ÛôKF´Æèh¯âÈ™‡;_ôÝ?ëKO¥Äùr]6G<Ü3óU.=OLnì=4ÚêD•ÚÙB½­ ÉcA+Á4 kí�›fªÀ3ßÌá4K×£á±×¢awçW 3HÎÎ?«%Y»4]¾¶_y5vÓ³�†B„t5ßšF!¼®àÙÇ0WkêhR÷Œ‚!Ý$+Ö'u�»É™ÁŒ'ÌŽöõY¿%QM: D·”ü6>¬Hö“ÏÜ2ö5ׯìlJ/*%œË§Ilu½®C¹BÚ‰J`7€ÀÁªˆ¯©vI¶8J:hŠ Ül<ëçˇÉv†Ó x âµØÂhyö“OÚHŒaÂ4UAòii¢@ͱ™“[›T 6óxØ No8* Í@©9,!òÏ“':ˆ`A·f°9´9¨¢”Ï¿ðÀ£q›%æ"]Û¨QÅ›,5}O²bet×þû±_š‡~DŒXø4 rGL“aî‡@Ëi×PÖù ÑÊ]y³cîyoºõáX{ŒkÜ·ùpÜA´÷IIKþ5ªX0xé7³�ÈÂpsÐÄ–ôì´X·§Ñ ©#¶ggÙÒƒ½ÏÉJ¯x¤Ëts¹ ð¦`lŸú,áA»ä‹ï X[Þƒ”bðL8Az:©®OÎGÇüï ¢9ýý[íí/¤#´€à]áñÖ/1bGhÌœv¨šÅiXËwÃc^ºY?0µŽS7³“GÑR¦WLSŸ§ç‰;&MÏCý!·æ_>Šý&–àXò{ 3îtø«`{}MÇÃä{]6—'¾$QzÝ Ù¶”}3f׊A µ:7ì,HJ ý lpìAÞºU(=7h>øôƳ¹6˜J`ã¦z˜é§¿æ ?NÜSäÑB6ÌÙv!Ý.3;´÷/Fþô×Û2–o9­3úä£"›`7Ó×4ÏÅøM —¨š¦¼@Vû$(G¥áPPšÿjwqÅ]€@� -ºëßhF¤¹¯G'Ëžî@y:šgšfÒM1`Ëtü]Ýž{ÖnÏU®[å7l¡QH7ÞëCÅ3\qß„ãoA/¢\ŠÙí`$oi!Å'Õ{†û=šƒ--ŧָF�})Þ›ŒW]þ(8O™ x#½ÈÊ:•f’q^A1ž<(Ž¼‰g¶”ÈÞ†è`·¦‚|ö Œ[8fQäeaÎÕŠÐZ+QdìXUÑÜG”IKëãA™ v|x·ñý' ÝoÄ‚‰ôsúg÷«Pï#:FCÝÓFg?Øèµ8+×g C¿kð°]k§å{w²¹έÿ¯Æ©`‘ßHÈ<AnãÊô�Õ¶ž’Õ¡;³´ù²¦Ä—ÕÊB0 ;­9Š÷–ˆ(„îUèL¸ð(Yžš¿Ü<BrëŸzdWªÃhšbžž¾Ž‘Â+'íwUtžåD…—èöyL)Ñì¹þÙýECÛO¼Är}q=°_Øóß·V�“]EïÓ‹bÆ¢@£ˆme¯>†{½JzöT8oú‚’z?u=&ËöòÝ©×;hX ¶ÚöØßÔÔiéfØ™ˆª‚;zC'&—u¾Ü=TYCТÍ|yÒT“áMÌ#lHkm1AýíHÛg*, )E[u4#=ôÉ]1\ÍSr_ÊZxµ,Hb¢ÂÛúÏÎÚÃ30øUçŸØ÷÷Ë})¦IáŸì&¶?MìЪbÔ'"êµq "Ͻçœ{ý €Û1]-ƒhRœwÚ¶»}š°½ùt Ò~>_\E¢ÍëqKAûhቘ»íL¨néÿAS_ïª4YIH}žû±ƒçh»°O7Îì&%5}ýGþ�±36•S{OÕaõ¹õ�*œ)¡c`fÝŠŽÉOžê„ÆQâE‹aöT7Ûn „y6Ýø§ÞÙéÊÔs¾ûâ¹PgF+¢ÅÂÉ·Vû©¼.7›úŒQókÔ‰o!Q2n mmØ/JI_jÄãÕñoôt.W™Ož¦sˆxbªHJÏ\gšOíî0qQ aUÊytî:ÝË ò  !ØéëÐÝÀÇb£> q62Ò1wò§†Ìq¤šê‘‘#¹r:.Ö­2õY/‚Ö¯Qd— ¶å(q¹Uõ Ž9ÉCÿÖÑ’h¶@�·šÓ0¾Šj¨Ð‚ƒSÛÆìcô¾µ‰ SUí9¡2<6ƒkõqÇŒSé_½Ømlµ(-öâx ˜—m­¤XȆ¶«-w¸3µÚî\äÞå²Z/#?Ÿ ­{®‹ «u › åËSŸD{û*Zöúï¦r0cdÚÁ‰Î™Ä(¬A8XSŒ0>ì?Á%©ßáøs¤“8²c>ÜiAÕ'>¾ˆ¤Ú ;jµÎCÌipª§X8àch>¼˜w(O1íÌK§r‘ÓZ8&Ø÷ SQ GfÚ8ŸˆÜaµ 6A–·ª»ñˆãìâ_}QŸy2ttT]z€Ù Ìž¬³–ÈÄê~÷®®Ñ/J¬õŒÑ©lé>=D{2ºŽ�ëÉfˆþüWÆøÒL\XÂìxÈXbÀÀ¨ž ÃuFˆä„Q¶#µ)ìánMæùºK43ólAU=½¼{Z·6QØîÉŸ¾s}IwçC6æÅNÙάâî€îɨRÿÉœ¾_áy’y=4èV½²\(jF+g»QJv÷ì5=5H)Æ( "[†B0i™RÝ82¾»œÈÏÁ%é;¶à¶©_^©S¬Öiêé”sÛž åy{1Å }×s}&cËÚ믪ê‡i‘™©OC§8!­�‰0êÕzÚÓêc/æÅ{™Æ– Ïí­à¼Š6…7Hf!õVÆ´£çI‡} Ñ`H}aÜ7¾óSu¨’G¦ í ®|QÂäÝ\;YßçŽè©Û[F1ŒNÒéÝ·àë·ÆKÔàñ±ù4ùµX–Š•0¹†9§5:ÛO  ­9=nŒ™?í†ÖHø§éÎoœte]ÝzÚÉÕà7³g±íÂðW�HätÀ^ÜßØqJ˜‹Ø)‹ËVô $­‚3Aí$7<–Y\Ê»Gv£¸KÅÓß:xQiÖŠ$ˆ ÖèÆ×S~½ñiѬëã6j¡ÂeèpFø:sê9TF!7É{ñÁ5~Åô&ŒÚG†©QRº4#f:€( –\ÌquCGg'¦©ü{ÓÁŽ øT5$·+o,‚j(PdB û³¥åì2ι"ðE)½˜PÆ°›IW†~|³ªˆ}CÍÂЀ2·¾ˆ“„X‰þ—7<PÙæ^ŸPêÉ»R±q_ ´ÄgÐLô98N⸤,ßÃe¬q(ªpT@©ØþÜzR$ô™:õy²Šb€Šœq„>”þŒ²Òe¬¥·¾ÐÂùt‚p¹µsqýD6òBÿg…0ý…éA7‹ö‘ëñfÖÕè]Šx*÷ò`½ƒX÷º§rá áú ìO,Öò3QýÌSÒLñµ&:ŒÂúÝ“ŽßÎÐs6yÊ!²þŠZté‰4²3æúBÙÆôW§-O¯ÄX$‰i·ˆÛ OŒäËy $|ëéß2Iɼ×é(¦o¯´¤=qWI¹š¶ ¤îËÿt7<µL¼±¬|â]™FþZg†UN™éÚ™„‚`µt`ù)¶(ª\MÏÈ–õ…Vgw4….B1ÕA lnýݹϜ)Jwµâ‘ ‡¢“. ”E—·ù|´ =-D–_˜åá=gl}S¡•¹‹Ä ¤Û=¤� Ç€nö®Œ†*Zr›šKq÷0:¢…\=ç…ÐȇÉ/Õe\βȸ¥G<jéÛô ÀÓ¯1 \æ<JÓÌËs°Fj]%².xÙjÍkë{Û;xQ <ÉÑ32z0GÏ"þÏ©_Õv£¾¨‚½à¢²µ:åT•µº–Põõ»}'Iµ*«9š™—'#W[R&†ÚÃíئ½*Yeúz¥Ä)ˆ€)Pæ>NÛᵓÄW'Xã·tð¼’võ¦×ÓïÙîw8(ô€ÕŒé=ô”·½õXRo;öz;ôì d^îËLÆÙÂõš´B:ß{o„$NvÖ¶ûc ág–”ifp"]ÙLû(¤e€Ž †¥úÈöÖë]¹ç!hÞ!…ÁàÉ�#ƒðD©¸Ê摆Už`i‰åŒ½\ B�>†ÿÕÊ ¶ã,‘ P%àdÁ%cÜùBÿ×y‡Fz>CÔzh&8o-‚ß b [îV ‰ëc[W–Æ = *#÷¥ç ;“&OgzNhÈÂÅÑ¿æ£Û+'—¨‰¢XŒðò ½Ð®í.Þþ5SNiøË8gùrÀ*öxaРaw-¥Sâ%h”ßOV÷µ^A|Ôô´^d«çáÕÁx^CGõâz†Òœ2äAd»½TáqÒ'•/¸F{‡çؽ徂Œ=ÖØŠWb�(KÖp]$fbæbgAÙ5ž2ª@7­tÖa賯Ïð07;ZÐeoG\8> ïW››ºÁ!4ÙúéíR’/^ýè6»¥¤K~<˜\7ŠPÀ §¥”ἑ?®^ ÷~ b*b§OÁÝ ã˜ñúhå+7´TèaSX!s‹Ÿ¨²›†F®JÕ×%êÕ¡£…~MŸUý×Z tªû ²Žé+“È3×´¢ä_�´'JÖÇ¡ËØ Ü³|ðk$㥥·�8—Ã{‘ž\c%>è&ÊDÇÔ‹”=¬­ÐÒƒÚ¾¡õÌå[{¡T®ÞzÔW>«IÞL[N ߼뻙žMæ›såð“½Z7aþL㸩|f@ômœèl©Ñþ3ea•øbjtó»²ÁÎÂu5DJnCw}s¤êäÇùfq¤ýžîÄÔ裼­j ²´-üIcÛí†Ýfèd¸ãÙ“ í7;bEwʃjüëTÔР€ÿŽw!)®o†ãDRÑQmfýõÐ £Ü–ôª 0p²ôÚ0 ³8Ï|ãmKY m'éöqÇþŽ>Fýe´êÌ*„Ùën½V¨4Ÿ«Üù~šŽ|g�–Šm´Û¬ˆEf*9ŽÉ»yþY̯<"ú"A»¥ÜB2ˆ\†vဥ–nÄøð7@ÍëQ©¶Èv`5/gÕøâ½vxÈmÍ%¤üJ1Þõ"*£htìcx? ÖKªÇ`áu/VŒ| ð…Oô%|Oû$¢XäƒÂ:S%ü¥–—‚’2SÙÈÔyZ1õîl—£t°·Q Éh{L>n!7~›‰‡7,œ¾ë˜µÒ KÒ:mÆp =³ øóL:¸¸Öܧ/·kÆR"ÝMlL§­9ZòÊV• ð2è›^êÞGÎeyæ‘q¸}Óáýå[¤Ò\ÌÀþø z Z´¤eË>‚4¤¡ï-ÅÆñf]Àa±>ÑLÿ…Ù ª¶¼t£\z¼(ö柭ƒìSÖppz‰}W«ßÈt¬¯<×(>ôõ¶¹(ºV0X-ƒêýâþ ÔG.,\¦gÇKЄ#€ªó“OÞ|ÅAÍ9ë!xïÊ#™h-?EÖ4– …åÒyëý÷-ÍünJó“>Ö«¢pO†ì¹?|¥åùÖÂ…?SúyñP]«Ã°[8»4QRÑ’îe¯¦"ó­IÃŒg1åqëÐûƒØ2™{¸XÀ¿Ť‰ó*âãþP*ÿë ¶¡YÒMÜ´¹Ãwxb5!“JO^ë¼)ƒÌØ;ÄïE<]·K$ñÔÜc Hž'S”a€µk&çÊó;(rT™§ß �$»Ã[çA´!öóãÙvÎ9£5!¸cn~¨s"æAÜ€ák<_\ Å´"7aöƤ¦?öTÈ8òµôcqïFU2س2“¿àù¡¿ÊŠW “Ê8sC‹­GÿÐfÙ¨p[ÁèŽàp×3~A¾#óæÒ9÷&ªÓ’víIƒ %W M€Yáþ×”ŒA”™-žnjž…KêÀ––eÑÙ.e&æ@‡³Z ŒP˜ãN©®Hó£µ¹íDI�£)»jÙéÍ܉¼i0n�ý©/æîL—™´éj¼�u}PÚ7I§â£{tÍSìcnöZ窙K¿×8l¡ÕT Éhúï[R†f< 7Úºr·™«u"!{ý¬\e"@XNþ˜àØÿ˜C/ýÉØ`ßÊjùß­¨×f,Qg® ‡„ïG½£ùïõêÐؤ&v¿ú¹f}ž9�kccàR´ú]¢D«_ež Z¢21«C}-›†Vâqm† ×z¢†Âû”ßûˆõ[zTöu<×0·Öý"VQukahq 劢(¶»²NpD_º¬ ©%Õ’©ñ¶h9ýã)Ž'Ö•¾î!|ÃáèœY•JÑNûæ´"¡œFNåý±¦ua>üèšõULÙ®²ß £—³]iig5ŽöãQú6W,ážòðéÓè<ZvXÁ[ì5帊¬C’!H°å¼"²�ª�6€•~õŠÂ¼°Б¸? I°d!¦‚ð×RõªÅÌÞõƒgQ…Ø(ñõuNwDßTœWPeô›‹õ’4,q:™ƒ¬oÞÌŠïï Ó†WŸ×R27&þâ[Ï´+çÝJ1Ã/,å2*Ì¿Džž5§?l�âD[ˆr+Üu1}ù¯[ñáÂL _p Ÿ­ÚKÂ;�ƒ7øwG šxˆrƒ?ì]õÝøáŠs4fO‹kɵ¼d‡—NTnšÛq;XX‡²1Ÿr¬¼ÔâÎËÌö+9ÃÉKɈՔ0­{ï25TžÛöpú¹1½#`‹ÚÚ­„ÎoE¼{LÊhÔ{~ä«V˜1c± �AuÙ=7‘ÍX¯]+úûÓ8ó&½pö 5{Cü¯[×oùIJl¥ÀYé9ˆ'[çÞpEò_£{<#Æ„°Çv4ÜÀf­§wõCЄÌt p©ç›u²Åü s&É함ú3Ìzê­N†;L‹S H@ÖO/Á}À%œ/eád{uû²pÁñˆâÚzv㜇h\2ò“ãïËöÁ¹7üfºË¾Kƒtëàý~7ÙÈ;€Ì<: F¹Û ’&ëo/5þ¢ÿ”ž,KÀ‰1¶®†qqe»6_|h˜W®‘§•$¨,ø -^‚C÷ƒk¨ïæêaâ¿-;;¡@ë”øcàH]wüï[¡Ý21r±þ[ ×X¹p`¦± V“A6¨$ †ŒuoÆêÕ×_ÄÐ[Šãa?Éì¶böÓ²Ot|¼^Ë?*çíÿÐ$.YèAÖ¾ÉQ#úúØ ƒk±pX¸ÁL)Gø Å=,弤%û§;3!¦#ýuçMñ&暢­.ù¨Ø!³KËT÷»É„R½ò‹ó(ôôÊX좡b69j¬ÑœN¿}=YÂz/\ÇÛ‹ƒC_"âá,X:Ž<‹âÜxÚ«²ÒÏl¬Ø8Ĺêͳ‡äuh`ÏŸwýz%ä¥nÎ˵^÷Ué§&oXGt¡G á¿û’2ML ®h™C³úÖå�õ-k.‚rŠ³:­t×qgÂûoäK£$¿’Ýép~B%/T”댖L%ÝÜkyï8sg V;¾ Ý èÁ%Û†e2@ÒÅìaAü[÷ð¹¦2‰ÌœrcϺ3ŸnèúÉaú<ù½ëWíÔxgoÇ1òìÉvˆ’λ‰ê`s ËŽqå(wMs-ˆ/Ç(g :“F•ªÈKØ7¼$ÏÒW8·TÖµŠèY÷憖.|Kc+µUÈHV¹iÏ«ÆRy‘ù†e�²½«óF²�<b†³x÷>0˜ŒÓIF†€ðæë­'"4³<±Å”ýSžó8Z\³È º«{¸,±Ž¸�Έ–svQy¤ìô÷ðçò¨ ÿä!– ’(Úy eÔÍÚÍ׺aƒ–Õº(Trá+ºÊ­ªo¿À«o Ü6·¶y ›ØP€tCˆWÙ¹“RÓ ùé§*¨zo ñ‡>0 þ¼¤a˜¤¡¯ªv‹¥vÔI6 ÈtÏÐhÁd\"´v6¶,ü&Øìy‹&· ïàcËÕ¡ 2ËZ #J»ÿ¾í;ƒaWŠý=`æKÏ ÊB^ƒ„ ‹îä”Vö€PÅ_Á,¢Ô[E›yl(†åý§1§‹ æLÕ׸6±Ýðuí èöv”Šþ“åiæ €ÐÿOO*…™°Xì8ÑW>8Ìo0cž) Bw ÒgAaòu0²¦™Á<¶jŠ–Ú¬!­Š4Š³JP™»*ÏÑœi ?DúÞ-9T¡ÊB·H­È‘r"›6V´ZÓéyÜZU´ØHQÓâéë]ðÄ/³Z``{8Ѳw¬R–¡c'½Å·òx÷øžpáBC2f2H\·“Íu ?(ã¨Áš†¿­zLd@"L¶ç£— ¬p+E7™¡…CÍìÉGŒÛ8s¹³ÀeÎplg^t1ûQìÐyj§¾ûƒ¸è›w GÚÌÐdxÞÖè}fÖ²ŸÎ6yÀ€ãûþÈÂË‹Ç|3jè´î½Њ¾üìjŒ]Këbù"¸fX�„z÷—žw&ÃÇÀuÓ·4"Ò&#?±ÂÖê9[†b÷u_6)}7t4>XY¹vª«ƒ†…ÙЙƋ•ìŸ88—Î7V”£éƒ¼Ö¹ØVÜ{`'± ÊMEýº”Ãt•¦¾”!œZOòÞøõÉStêå÷s_‡åž4ÄQ»Ýx" gÚÊšA}/š¦Õ?m^Ó+·Ÿž¿I¸L˜k7,ͤYØyìhÃé ú…äƒ7…Ým‡Í»“"ï$‡ä$’™»žu<zÎý’è^‘”9…qŽƒÓ]hË{´-(^»Žÿo켂`‡vWßOT¨$¤Uœy‚IØ‹1äç[ÏI±9\†É!YyŒ© Ÿ×°%÷ß>Ê?ÂR¤Êº¤à×(µT¨’xYX'ý‘·‹;/ÝÕâÀtè%É# .^£Ñ}š¹5³×½ÛOÊ×…zôè Ø*M–mÜ-wý­ÈwšÄÑ &1@@õƒyx„ÆF­:¥·øö$ÈNƒ÷PxÇâËpå„G/Lÿi.,Y!Ä«*Ùº ‹^LE¥^¤N~QWœöêþ×qI®èÉ ªé$ˆ§O_Äl?9—é†!Л4‰½I£§ ½LQ,<¡9ÕB×e=¨Ó|†òÖ#†B¡Ò‚”¥Ç:[£iFÕò@™=b6â)m@ë¡øßÙ0Õj’‹VYC¯UŒê­’’LÕÎ=,&•è¸^ù‹~Y^”-Ø?l“±õ9Š¸‰šÀVïz½²›½$xÓµ½Ô×f…U¾ðD4ÔY{´‰™‹܈¥al_í§ÆÐ,ØNd–é0x~_mÇt‚zÁ=ó;©ì7L'yÞ÷žŒ=ö“3)ƒlÊŽ»~1N1§®·²8‹žNœ]0ô= ±/ç÷²¯)È­×—¶Åj¡9 ÷q{韚‡Y(­ˆÏS4 ôs‡fò\«³³Î®Ô|^T²*Bß5,¥‘¼[TÐ@èÍõΤҌxÐ’È ³×BÖ;¯¡Ê<)é/Äx»7øžÖÓm5’ÏÙµ‹× FFf]ê­½·1Ó»°îHþĨÆ風ýãnË“*_A&¶«�hUáDs ÈÇop·‰uRÈ:Hü‰Mî§êáÞ¹þO?ö¦&%’ßóäA½A„ÒUTyE™sëùê§ëIÒ’^Cëz®éÆdzõn¥=ãQÏaJaŽ­ûh×»^íÏ%?µ¸( å7õ @Jr¬]WÔšš5§ûRMCxÅQûwÈï gƒésMIXQkJŠíEÉ=‹¡G«ITxl¶?4f´ò1œf«`*?ÎÌ—?…lÈe%Z"™a–ÆKkw¦lä`¶2U^t,Àt^Nd ºmœ[º‘¶Ù>l»ƒÜüäÔ)£�2|<?臘9ÂÓ6R˜ûÅ9øƒ¤SãPƺL¾­>0鬊,ÿ,·®Žþ·›†˜1ÓÊá}\•]PÄ¥çÊÿ'TÙ‰´É^ó:Ž2Å'©ƒð´/‚¸ùëÉǵ°ËÆ-Qˆ²²vŸQy# )j™àH]1–%ƒQ§­&¦æ.úAÙÂ=1è ‚£5oÈñÜSöxpÐ*nÁþ3ÁEîŸ}m¥Üì6¼úÑK…EõmqMj•ŽÌÁšÌqü1&Ç÷ =1–#6h«µâU QÔL5GñŸ’ÿiˆÅú»^vîe"0n4ë%?�îÈ@‡;�»û¨eN­¥²ø§R©¶§-ozf¸ %ÎÔ¡…ŽZ¾¾Ž÷U{ò¨0.›{0&Ÿ*]"y[ïhóØ0¯jfeÂlRÎ!˜½’lî”aœ/½ÕÛݤ#¢³h;2°˜î¸8…’*óûlÐüÛP2ݪA \›ÆÓl6åÞrw˜?¬—rB^²—;Ygî5xxâ: qP¶öˆƒéq½Õdà—,ÿÄ‹žÒƒ9SÓ«Üt•->wÎê‡ZJIèëeÄb¥7ŠŽÉ 6Û/ Ñߊpãyú M”hÕŠñ«½vØ4Ëš| ãnå¾bãtìÒ ÿܘ^ZŠ*x£dê˜í)þº?”‡N­$bõž¦Ž=36ŒØ.lê€XûÈ];uJÈžþG¯S\(¿µCRÙZ­‘I¤ÓrG¡½w¾‡Tºí¦ûH®Ò¹™‰::Ïy£iëúÏÎOû‘ß{³ÿ¶?Ùn]I¶EÁ6â+ÔËNì3PM€� !�\÷ÈÿÿŽ´iææî`!Q+n¾ñî"¨8›¢�ws+f‡ñæ*]A%—Åâ¥#ý öDizÍF:ÿ¡¹µ•ˆ¶cuȸCÞii/èWû“¦ßi¸G±BÂSsĶ{ZEÛÖÓ»£bÑËÛ©f²Ÿ® ¦7¦ á®oßé<ÅW Üѹ÷ÓÚzðF󋆎y$«^*(ù »EŽÝXÅ·óÖªíœѵF ¹SÍöy¨¡M¼ãYÍ_áâl…Â,¤<)®J/Jvq’§™@×ÃØ1!ðÿleÂCØéØ­J7bv½‚I}}†º°Mñ×Ê´´¸‘úÅ݈›WHEÄsËp“ý. ¢÷­ž™C™ëæàœú°æ›»zTy7^Lóî“mæ+ö?MˆÎGAL>蓺C†Å@:´¨ócÌïaBŒû´ñ¸~êu¦N$Mr¡Š›7š‘±œ)‡šý¦åËò·žÀ;;²×`l!Í‘qwQa@æU¼×Wfëý¨€.ªÃ0§—vb*ðþ7õ¹÷ïÆ�×Øc íyîó }WCØbDùŸg¾ÏGÁev£l!qýSs(›Ñ>h«u}׿‰îÖ5W,Ýs˜£P¢Ði½K¶,~ÕŠž?œ{<…§a¸ÒÓ‰¡|_…utÓÂB ß?[ÛI˜ù‚²`œ×„ñ„šaC‰ 7¿lžIåõæ<ê˳IY\ø6b›‰ò¥æjÆîIV½ýó–@[¥?Çyå3å‡Æ`ôŸ,¹áõÎLJØ’÷œï·Of¸Cå~ƒÏuÝ6¦å‡1LtûkUL®<±œ|€÷ú@È%Š<EY#½žèÁ¦v2Ìn7b´¦ô¯Ó<s‘̛ڑ†½ëÁ0ÊÃ5$ýmƒbVŠ `Û“Î?¹º2ZUíš¼ZÁݤ³&YãÕlº8÷ÛA !#m¤°-lÒ[¨Ê÷2à*ÎƯºÃF‰E4Gl“2íàѨµRl …–ÓM¹ý²Áo°RytzÇnÞÚî¢ê¢ÅÌt²N‡á»‰ž1ç˜BÓ=µ4©¡\ ËAøã¸oìRÌÀ;¶Q¹^õ>ÉiËXoÆÄ0ÅÐìz€€fóÙ˜]ݼc¡¸5ÒÇy4¨ÀÉavÚÎFšz¢ ‡žø‰Ûé5?wOJ×YA#{Ë‚éù—w­\ °NÄþ0›F†2hBÒ´¾B„6¥£î«Æ+é˜ì@{-H÷V §bTýäJÇ… Îluä]¾fUb3gn£ÓÝî;°¡úw«�ËH‡3ç7 ¶¥^hTYÄv,ž¶!Tõ*VŲÈøáºì›É³áaåþe-½då­ˆ¡}Oo°¶¹Pئ¿›…ÆMüþè® ¢|*4n¥qKÓyØ\(à ;A²m 'ªM_š!ž§vç¦jÜ-¡§RávçIŽöTbŠÖËóªë›,Û»wlý"ë“s9w¨ªo\!¹«A"XÖ9ËwŽ1έ$7‰æ0Až¿×ÔpϘ_زÞñjÿã!·}û­ÄšehFf^0_aoÕ—%Y…œDîÝà&tCÏÁiÆÍŸ®îbÞO''©…+/?´V韨̘»Üˆ«b2lZ¿ô¥c8"·Ú¯~R ¾¸é¼LãÆóÔ<Š—ª¼(D¶aQ§{ʽl–ÞægœôÑ h=oÜõGˆVÌÏ0Ñã.÷Úʙ?ýßÖ&Ù‹gfä劖‰¬«·ÌJ_cZq>šx*‹|aæ�ºx©x—·C�Û3u„¢?IAYÌ»Ù`t1‹Ùî©Wç`«ÀLVâÀÊôI÷3ýÉØGéýÒT\‰Õ]aõeßD2îo\«VWå!c9ø?�ËØö®êFа¨O,éöD+]\tµ‘JnŠ>þ¸?uÃá‹Ÿ.¢ôA.J.ý©u¾šÛ2ÁàÒRJ»Þ­#3(縥=zƒÞÕ×Ûw¥‘SQ¨Gtwƒ™ õR;™êÊž{ó¨�Y#p™ÐÓ€•iL¯hR•îìhuÎ`E\| F+;^ÝÓ.§òz'veá¿Vö®¯« ¯ß=ùÝé,y‰@Ý?¸Â1zO{ê¦ëŹ;¶2Œ%Añ‰= K0%Õ)Q+Í°]_²Õ¢|}s„ÿe»÷Àeüíë+ÖMKB»à[þ¿ÿÀ,Nòñˆ’ÊO€Öè’ 5nK1š„¬V¦<üW±©¯àU³"µ ëqîRC^rèL=b>…¬ÖtŽÑFÚw=ŠªÕ¥^­bh––¬Ïò›mN m¿uj³˜Õíì¸È Ç‚èW®³4ÞÑÎ>Mð¾xüSKúÒ¦5=ªa—±bbᦠ)7åe𜯿y‰XýË,4ÙÍœ:7Ÿ¾Ò)µ›Í§£ÍÊúh´ ú?>ô|lMXX3(7]!èp)Ÿ5fV’åþÔÝj_½¬¹¥.S:™Y>©Þ·˜,@bÑ<œ šÓûv´fa‘h^°Ýâ•]<-þEd‰uN:Sü½#Q-8b6Úë[úÔAÅo3‡Ôa`‚ÿ@[»j}ÓÙÃÀqBüŠOhlË¿æ9©§ô¡ êéKÃ5à ½ÐMҊ׎¸weøÞžÁ9S³”-‹¥.XÌ’›è6J¹u¡Ã¶þ£Âü¸ ax¬å鱬)Ñì(ŸfoI_G‘hÕ©ïOn~üx EeèÁ\‘ƒÔT;Dsë-mß!6ŠhvÇÏÖbþ8vO†ä±~çñyŒiLt_iž¿t–&ZÚí$îSÝWÇ^!«KØKV@ºÍ=âUÞ*½‚Ʀ§Z“݈ßÆ~³î+âÑùråf^¨Ï—0\é*T€FÆä:2©ˆcõv€/Mkúú0½AD’%£éç=g—ãéB°üËOÕà b£ÌسŽ`£À†v"­‚{mF:!·¢õ#§îµ«¥Kù ¨¨™/e7á*¦\V“Í<—ÔžžóådÑ”ó©?0°óþâå‡._à~î®Ïò ü¼xŠeZŽð¯ê¡¼Çþ‡;me¡Ä@ú0�•0ÃÂq¡B¬o0Ä“,só*̲ªÈƒxñÞôßÎ*¼`ŠUd=ßCY2O€R5Ár¡ãÞv#"àL>ö¿·#¢(u ÿB­Zmó"5í¹U°¶—¸¬¦rèuiTZÌÎB9aëƒB¼e½é¯ l³è„þt‘¯gjI¼Ò”Op(–Aæa׈<‚Ý©… 1è.F½Ý'¼¾È}ÙåH–³ìĸä€&µE1‹—Õ™ÕF|µŸØÌÛØ Ä£¯LŸÞêâ‘#„ÂÄ„®ÇéÃ;¾P ‹Ž»ºÿþi’Ýz”ÑS]´vÌKÍù‹c’Ýy†‰g‡‹›MQ‘vY4îL<B.j(Û|Î4]?Òß`^ž[¦[ÿ^éA†âÇ”õgWR  4sf‹'Ó±ƒž¿Ÿ÷g¥¢³lþ ÕÓYÜ/”“.í•U<„"ÑѾv³9ž kDMþľˋ ²0ðSðŠ¦–XHQ¨îá{ÑÁƒ ÁyL“誖y(xþ“>–¨0ø>üMpXË®»&¼'+ýŽ÷Y7Rø—ùÊO c”y3n Óû$È;…IjMõag%ŽëI¥R¼Äñ”›L·0XæË–îѧUîË¡­‹ÃÆ´ñé¨ã ^¹îžFAY2‚Ãè¥4†( )—l ½ã­¢UŽ× ÝEûþ>œ—6c± q$[›ýfÂm=OQzøùV—__MzZä+ÕÑì>gM‚÷õvéXÐÁ±ä«ÿA²Ì³…WõÔ…ŠJª§ópkO¤Ö/bãfƼc¿óä&êÞǼêÞaÁ[¢ºÒ N¸×kîÚtæEk©/ÄõË°“…ɘ7¾jÿ c@&Bgì™ñZ—)@KBcº@…¦nb3ðß·d0b®µz¬¿ ”+ÓùXd²óèAoÄ]ø/£Â ÷$—(Í<TŒC»2ÈY!2þ~`ºŠºô:âr~ÿá¯,B_Ľ‚àVNµÆúšÝ€•qJ`zbæq}µ®Àêû+ÔÛµlq”f>Ó~«SiÑ¢±‘Û:»vgà"¹â®:Á5®¼5¼ÜŒY›¥¢¯¾õf7«Q¥‘œÊèëZƒ>Ž<6k53­œ¢ÙªJlÅ (ÜŠßË4Æqz€ºÑã)É‚lòú”Ó©ßήQiÈò? ö*×0à9\`fëÖ‘qYÚ¼„^Ì£_7µþ‡ò—ù¡ÃŽBfhË­.DôHöÅ‚¼Xœ/"¨ÂÂãƒË!rà�ü[˜ƒdJ!-¦BÚþàIî#R1}¸VA¹4^“–Ö~ˆVYñGk´!Kãô"Õã-€NÜÔ,``B%}ß=>µÎ¢²‡MÙo_}…½T‡KÊPÏ¥¹¡3¢Þ<Ô’{j¯šé*¯LzÞv”O'»ÙÄFŸ#ŸR°© ¿·‹IâÔÁ¹RƒOÉâUaÈÙê5g•â¥;Ðf¼}ˆßÜŠ<óò6vÝÆþåi# æÞÖ_*…wÁ zB)ÌBoÅ1°¦@e輩 Luúãìl,ŽìSe^ <C_Cð«#¥3Îò}˜Ù2PžÑ{FéÈ‹k'¾0D±gØhYÇv±Ø@§UÚø5Ûè`�îÝÜ=µ\¡ò43gÊnŽ’èퟷH·^&>µŽ?ð‹z=1C¡Í`<Þz*&ì2m½� btl<S«8FYôŸÔe^Ëf›Â¡])ˆð ÃuQ)Â>Džr˜A¶;"¨›ÄÖo!;»[Á^%æ[Ÿ÷;v\šòÃW¶ŸG†¬|Øð¥žhxÚÚ²$[¡ÇÒÓºÐÞ68«B˜W‘]¦ˆ2<€¦En9TöæšviPLV“ý ÔÁˆ nPÅ2ç¹Kšs3®2¸ EÇÀ˜íJôyª’”ÈßVû°kŠÊí¹†"L_Ü•0×#ë“oMPlºž™ܼÐ7-^ì•Ã Œ~¥ã\#>¹îl—îÔԜʮ�0hAæì«ÔýxêuÄ=÷‚åZ½øò-¹áôˆÑëÎó¢ö�ږʲ}§°yÌ©Ø d›‰è´õt˜<LŽ ŽtßdÅσ^îqðs¬…Í1 Êyp8Šyž-[`ԊСX}ÞìŸÄ?)Ræ1ТúTÏ™_º*:‡y)ð‚ÖŽ—ÐjE¹°,Γ’>ÖW.Õ~q\å¥eóKãj˜(달¬«±—Þ’aW_¹…4pÉê¹å©×¢Šá˜RE£ç+3ø} #Ví}Á0‰ kf†ÿ¿dm‹¬Õ?;Q!vÛÉ·‹â²Ž(úv‰HZ_$Smö¬ ýê$ò‚x¡ ÑŠ€jZ€X{å)C�‚-Exš‚˜<ɬågײÈ<ôLWvU¼[az‚U©ÃÙaÄäà÷*ãJ¤#üa[·Ó&d‹d…'*óŒœãû‹BP»§d·Ýf„WS`»eq`L&³¯-"È°—ÖY•¾6(„'ZÒƒ~6¨]ò·ù@^ä´ìÃhðfî%ŒG5($tÐÖØ«`xƬ˜Í‡/âø=·¤LWõtÜík¸ªi›ySs˜¨À÷šˆúmŠ§í‹Ìóß©9—ŠŸâ½±Bá§d³ à:·ëIÇ(½õ©9R=’~ê‹ µÉiqœ·u9Æ?îm¦«v6%,ç&cd¦6ËÙË,".AÖ°O] óÔ•l=¹?ÓVh>uü…ÙÝA9ÿ›V«JF ÿUŠÁÖ‘’<– p.!§£6?.Vë˺cPe~  àFÕ)“¦ØeX›óÌÔV®Ø ¦Òoþè¤V\S>–D ê÷]í4JtHcÆEW^šU‰ØcO앯ýÊá!¤ãi*LëݪtÆÞØI›lë—æ�Uè³Äáa0¡'>y"MW_Nûó\_‹%þ ]ÊÝ%Êëú80J µ9PÎ!Ò‚ÿ}‹è8¯Üÿ…9Ñ€ƒ%ñÊÅ•}ëZ¤çÆÕŸzÓ%Phr÷…1š2^nÞŠìõ A<I3ß&©d§†¤ý×Øñ6¶þâQÜ=«·Àíqü]Ý&¾e«E%×Zç1Žñzjʲo³ óö~{gº½cSZ}ε¦´¿œ×ãxØÈáó+C”È—8/ØŽµMƒ²¾xrØuÓœ–YFUIvbí¿£{šÎÇ»æ~Yø7™á.XYÈr– ¯ÞuÛ­Ÿžøç£sM»°kž«^.—Ì(c¬ûù›&O‘ù²ÐÆ–c¢ÚÔùŠòôm Â<HÆÀQ…üÿBu|m«=çy)©Šþ\¡O/‹÷mm{îÇýýÂõ23¦hʽ»“›ö5ò(Þç“vq"µëÛ  {ÎÙ~ý¬Vœ2(NƒöŸSΩý3ta€œoäQåA!Â@öžšå¡½ã¹Gà6%ì•çä… kI+jƒŒ¶ soòdçxÙZX… tSz›º¤¦p:õG«(z/×®¬–«`΂rø2F>H·¹jM“ìETZY¥_aÂu®±U<?îmŸ3æ’(ñÝæ`¥<}®=8%V+÷zMº4Ãí+ã æ{Òzf%m+à˜Ç˜••È2•>ã ÙÄÿåÁCv_=¶jü¥šfR•_GÔr/üè�ø°Ê·Å¾uÿ M~9L�ÓMêóQã|c—º[Ö-ç\t{gߣýÖ<³`sõ$Ç÷.ß[³<˜3'šé²7dx(ÕºýÖ¼:€×ŸoQûøS<q ®šHzd–W³Sϵ3uÓGw•ÊîU݇¸XeдCØÈ,±"Ð :Ôۉʯ ËÒt%ßEñcw¦dèúét¶‚íéËЙ,xå;‹‡¿)ÏͶL‚t«T ˆµ`ënbõ׫êªÒÞ ×¶õþ§'—T÷Å.ƒÃ1ô},ýlCV;M‡ [¢ÀóÂ`ÎËu`¥¼]£Óp¹šźÅwÈ°ãó ³y£ëiÓ´¶ûù³㊴ÎÅÙ`žF§³‘oËa@÷…8Yëþÿ+çDç9Zóù¾Æà ¿˜qñ,å4sBÛ\µ±õßHf÷ ý'qÐv†š6¡ íìÑ°>½hÍZÿæ»ÄóVDꂘüáöª˜ÌzëèÛ)\:±­¸Ic‹p€èxÑÙ5ÎVòþØôðZŽ6'ž[ï%ó¶=›gnXÆϽ|§{#¥ZTAiiïHÏ/Èx¨%ÆÏ- Ü›Ã3ùgò ßûp @Q{ß®7Z3Ný¥­ýãƒYy\En3  Y?yY‹èÀ4¶¯û½†åm”Æ=šåwâóN·B XÛ–²œZ“VOvǻ䖖˜9 žtå�Q@k rçi,°[¨ðhC|™¥BAßÌ=Ÿ˜K¤^¾Èåy»D‰XáöDLìU¤z(® ¼¶!|J ü�9õ£”ŽU‹{¯÷o nô3ÇÚè+4`ár‘î®," W¬4è¾è¬°ŸËV<íÁ³g}†6Ž3ŸÌÉJmTcĶ÷…çE‰½¬2Ëæ4Ûa/ÝyÞ7%n ž@66dÌy7šgP²à6ϳ¡:AÌc,òí \‡¾Ðm‘ŽöLd­Ë±g¨Æ:™;l%½¨²ühe:²*åí1 Ò¾ó�ÀX ŒO0^t´wNǦ{kôÜ–åG?œ$+BO‹ø®Ïh÷ J†ä®/[[0uÄåøâ‡4æY¬ö]¿È€ã”±à¬ ý t×wöüÃ@ iüdÁšî×ð.ìæŒS¿gÍ"y†]íð ûâ—·ªäOûÎÔN’Ñ<˜aA<}yjà¨ëMÛê£á~ögW)>›ú;Ðzn¬vM—Q.õ€´Œ.6E›/÷ëŸõF+ï©–HN›=¥0a¯óh°ÂÏ‚\ ?ªç`K…�sáòòÊ_.X’K”½Îä’”©M<ƒîÿ­kcɉ|Ô±cÓgø­ƒpP é‹^œ¦Ñò@ž Ú-7­@¸—{ì�é¾fÇS"œlï >Ì3w=»µ¥»|ñÑŠ·#2 Î<+,®Эãi»­:r7K+Ja‹¬YNSœnÅü„]|Aç©£UïÌ#K˜—_!›í•û‰r¼öŸ†è”…,†&Ê`:Í-Ôöõ¿�C3ƒÊ* Ö›Å&FYLÆΔJóößë4¸ŠÂl.·jðn6ÇÆÓF\ýØþt¿™ÐÅ‘ñ6¬ï8˜¯Yö^b† ½ë»¦ ŒtƼŸÔ)Ô]ò§ºÿG,­o¥7›} ëÞÉÙ[~6ÌBú¨yÕæi:Î0"•î¹­‚lU¡ÔËP™Åþ§–£¦fȲ6ÝÕs!àD%õŒ*!h7üãÔØU-Oü‚¾Ñ J 0n 8Òm2ëqÒ_ÍÑ›oìZ‘Rô+Õ‰W1éîQ„ª½F±0o•¹°0ýaàÆPËj¤FÜvÚàŒæ'RDñKèDÛ¸ÌÖ¢k0AÊë½\™¹ã{ÇqÓ÷#$[•‹Qxø”)O:OHÓúퟷ4mX£c¿Uöìg2E”:ë i#³åêM!»cõ’Ħ¹0ë™m7Ôç·Æ¥7ïêW¸…¼¡ • µCMîâðNJpyîñ³6”Mã"½ÓŒ½ËíMá›(Z†;4žÐ+Vr/Äj?ï×–ö!YÙšâ™=sN;Íäp)SÀ¦»päÆîà¦GQ.”º½ÅE V–TfŽØ6[M®WÌ×bæiºNÞ“àØeT n0·;íIüØ1Áß'¨Ä�LS²XT&Ò,J?<.h@‰-ô‹�%µ44ƒŒ’1eõ¾™êiXº9å „Ø—ëH›²}Y9& Í EjÏÑ¡]tñÜxø ú*ŒÐïâOý;ÍæØ×”dEÁÕn¾ì\:9‹¹c¢žÂ¬€ ¯¯JWœ`Íçæº½í·†$ }ùBJ/."˜<[¢~ äÔ‘œfCw¶X‹Ÿ›ß²ê8ÜAP´ÏóñCË÷ôE¿"o¿<Ÿc:Y°€&òå€](Ûó`ÈÚ1)¶TS¬E-‘<qÃútÏÅbåò$ÆP¨¦Ëà±ÍÉYw¿Â(uâ—¢„“ýP®Ñí¾Ð˜iÀLõ®¹"mú6Õ³¶§ž ,7,UŽç¹ ÂÙXƒ˜Î͇Yªÿ\cËÔWч<åEi§œ²j»Uà‚º*VTÝuæø·ÎW/gô³D`‰‘—5ÌR¬Œùª€ýaÆŸt“Ð'’`Zsƒü]£Ò-: úÓæCÁK²¹W»8ñeôÆh•$Aü5zb±Ìhçj_9è´ôÕßï­¨Rc„sÓ ë4ЖKXö‡šÅ´ãÌ“}u-+8¬âÈ2†¦7èÜZY1  ÑS²è¾ÍÉ´íÅÝ88ôÊ;QŒ©(ž gË—¯òÀ)ähb. šq\þ‘K U¬Ìi€£é°dAôiÓ*ð® ›;Òsœð°HÒ“mtã.$7•‚ ]9U.{»‡ÒMà”)ÜÍ@ƒ[rbÑû®õF–.ó‹Á ª RÆEľ¾|H?]Fƒ2ÑQþƒknŒ;Cê’Ÿª€”=+Ó˜ñí“sg_Èc¾l{ý¨näû­2B…ʆmǘp,‡£86Xøë¤õ¶8šß­â<ËmfÏô°žÎ¸Óªªt×6(ÒœN RJyyÈ{J*7ÚfÇfŸRìøT!iDOÀð‹é¾`žN'*œGÀ¨4ñ§åÌ¥/šNÿúÖöuØ­­×}Ýo™uðÒèXv³ôYTl?&AÕ×~ë ‘Òl’ã)úwó„Û÷Ï «¡$aNƒj>;c/gLdµ­væ‡éýý§H£</,Q!bÒ5(ß5¥¦m.¨| ­‡nz™†ý§ô—Ütmè™k÷¦H$ ‡ËÁy)qÌ"‡Od)׊Œ{Û.HìÁK§Ñ1ñ¸g#à4“¬?èÛàÿ3b…6e§ô Ú«m~L#…QmêBcw.×–ÍŽ¨ÊZwøµ“¤¨Xcù+Šf°Î¡è зæŒJß|+ R…+z,¨Yp•-‹U½Huƒúêrdù2n«/à±OËò|ßþÄc›šê(¡ƒÂŸb s–„ˆ°·òFô�={´<Ð,VîÒtcQ檧f©EÖìù÷Ùþˆ ožË ɹNaÖ¬xôfª^¹¶%0”!{Á‰tÏ=ÚÙïØw–&¸~o~ìvøŒ©bwñ«ÿóÐt´Ðì˜äÛÓr‡$ F{»‚ÊñBB~hØ7ç鸅3Åá›”!¢óJ„z䧆@Çű@4ï.ÖÌ츺 ˜Xíá¿àed¶øH1|œ"²íÏ-êW¾JïÅJ4¦¾ÆŸ*Yð ÂSíú@zŒ&òYè&˜1²°ÞZå™ú£{c³©ÿ¾îtœ[ |·aï'ˆáJ/3άãdÖ(€.áù™ô˜„ÚÏ)4¶^ü$±Gš8æ—Ð ƒb¨½¥òÁœ )CÐ[|£ýYËú~-dô'ûŽöV6m=¾Ýo:Œ 8�±Ÿ¿1]g!sß x¢¬LUôOtØá¸W]¾Ìsc-ðA÷Ç>=àLŽõ lÚƼj׬‘ëôK/›ˆÖüûljÀ©¯{!\Þ-g6(ÅŠ€¿ИxÖC…åt:mçÿ¾e‚±dDŒ¶j~ÆÅYæ‰Qé8À»dœMÿŠ­&¦Ec‡ Úþ•†^dp>*ssÅNIÙ§eHd¢;%è$“¨î;³;á©ÜiÊktѤ¤ûò'Š½ RÎ0§K+†SÒ£:Ÿ»Möb8ãØ2ý~ûÓNkÇaàŒPj£ mRÓlÍ#L‰û^°­+Á¿÷ÿÍ2ßh„2äcdÖp˜m¼(³ögd¿†ýgÊÍžŽæÑúÁc†ÎÑN!qm4“^ë+F¶—;RªÐ¶*Ãã1ßÔǤ?°Ð„à�Ìb%Âq£È‘ØŒ_䘼¤œíkOÇ,çázÃ}{¶“ÓÊy1r”lë2ˆGuÆN˜ïF7~ÞA7xU=ÖúOT&ªŒ­Ù< :ë]ˆ¸&AEW[®â–Ûñø€”ы“˧ ¢iò èT³$k½……»M[›«3ëøì¯CËë’'?  ÂcWRf«r k8µÓéìˆ0.ä®ïàuß8vˆÊ›Úбvš+¿S¤½³eüY* }u)®­ò ßî pw¾™Î�*:IÇZJj¶þ�Ä^_žÑé(æœÏž]¯´UiKóçÿÕ™–úÜèeè‘öS¸ëOö‡¢Èn�ô&n¿èyeqîU#h¸RÂ3yZt,äø1×ì‘¥QR®Ðt ÿP̆ÈDdó nQ½ tÿ‡Ž±ì¿‚§:ã0M^O_àIï, æžÝ®¦¬T±âA°zqKßì@‚Æ´YýüzÙOçq4óÙ½Y?¨ ¸0é®47 öÈ#þc�Vû‰‚Í—& [šRöùî×"ž@oðMô‹»•Û_·"$qæh¼¨NZ:Ãì Çm{ÖüºÝ1‹VëDGÖÚ'7oñ�ªÐ·ò¢}Kµ{Øœ½¦gS3·ËTdžá �ððzµ*ùØˇJÖþ² mß=%ιþÒaðù·Žv±²~…OGÉ~¤¯ü9xS¬ñ LáÿÖ¹’bcÞ”]:cÛ=gTé)©!ï Ƽ‰g]ò¦çΫYdÒH$‹“œ o»î4íºWtϲð†~Tˆ­G¥Ä¯aÙ}@‡ ?üÿÞºöxâ‹^J7Ý5¤íØ65TÄå3²AGª±0¢lÇ`9M̲[kðFÿ‰r#i&ÜPˆf6Ráû¢65›½}t ,kÿ™zLy@©Ài§œjv&GÝóÞ×ÚT>‚¾*4Q„Kn ͸hVÓ§ù=ËL™@`ß² pÃ"Ç»½²ñ¸Ìü¡ìf*‘×'eG¦Á¤øv0ëàfî•ç’]‰j*èAýKßO{ª&Z}çǸH�¥é=6ØyVI—ó„Y¦í¾ä²ÀM3Vöš€%S©¯™Ý±C–‰)Û0€»:ërG'€®-@Y¤¬ cë&07,Ôü%²ÄH0×bx1ýÓ‡N“æ`3 ”kœÁ1ÈUO Ž=—~úh™×„øiÙ¡^°™<ß ³æ¦Ã¼gPÞ¤/,£ñ„FÀNy/©á»(Kî–¼ÿ½ÜW’jÜ+«÷ÜQ“6‹¶kè@¤pz¨e¥ý÷–§–ý,_f2dÏxS‚.è#ˆÝª•œkJmÆ‹U欽b(¦·ç¾>|×Õ*ãñ2–„¿Úº¦ÁüãàΨeï¡Ö©éiË.móòƒätùjú´”x'{-¡!H&¢¥ÁH þ솔T;]lùê]?¦RÄYxŠ¿žhe¥µU7b+×þ*RÔ&«¹cîÅž¦znôQ!n{d¬8ÜÁ1¢¼ÂÔftøÌé!gEê)€`2:A¢äÝC›ØŒÉÂ&iqõó·¦Eõˆ474pv”ùE‹í(ðð‹›F­ fé[Õýº~øCD,O6»@‹é|Ü}y¿b¡5õ±ý/çã"ªòÒ¢…(Rw”¸ì¯¹Ö eÈœÂãôþõÛë fûû™Jô+ù˜)[sG[ëúå "Ëë¶=o·9µ‡Í .˜‡õƒ9£¿÷ÁŽŠØi1ªû*(a]œÔÙæDËdwöÐÃ3d.=…?º‡*ô[BDúB›´æ÷_p”i].°ïLÕ #Ô¼3³a3¦­Ü7üS3Yø@k³<÷:ÿ!21ô¾$ –¹iÞÜ\zÝy•ŒB£ôsAO-s©c°ÁdqÇ C"KÀ´z… ºÓ, w‚r¿n®i &ïVÊv_Ê^§7éÁž<¾|:bÉKÓÀÉŒÀp©‚¬ÙzõøOzæ„J˜xM"ÐÚ#„Æ’º™éÓS+»”ÿ>ÃÖpRÉÜâÈÿ‘Ü(h§~þ ¯NïÜ3ŠÙj†4?–Ç¡£ýÓ ´ÛrCŠUÆ®þð®ÖrÖzdJ`Æ�1˜irq˜Ó£­ö“CZd¾N%M©†Jw–[Ê-Z eH³K bœ 7f:4@k¬ÃOX®àk)ÃUªw=Æ�¢Ðøh•4t CH·‹à2ÀXpÏ(Ø�˜OCǸuöYe±2!hÛ· ì(*-¿…›Àê'a¯7FzQ -QØbq§—äOâÈMêø(ÒkÜjU/œû«^v­\±æ… ýÒoíîÇ°òãÌ™G•ñù´~ò˜ãl§l| Så,j~¶ûtçzi†¡¤²ip¡Rê3¤6 ÊÒtÚ´5]ö±zû NtyZW–y„ ¦$A ƒµálçÒ]ÆÅ&†<Ò/ôˆFR¸¢}6Q Ð4\¸ÆT Œc­Ú…¹¾ÅG»Qï®®EéÇ NѹÖJfbWÆC­RaFÔ{)¿C®¥ž°ÄºÁ÷öÄ6©ˆQ¢¼%”;qñƒZ­$ÎKÔV »ôN¸ôXφ úŠ‹MV¬¦×‰�N‡D¢x¬êT¸éK¨Sõ©ŽQªœnÌ×Õñ¾ß?¤PŒþª%·˜1Ù® 6„˜É@Ó²?�ù¢òZI_ßò<‹3ÏÝrÈò(G$—ŠJi¨D2…$Sg(PÒ®¢{‹ƒ¶¥êÿî•;®æ´ÒÄ\t#ÿýT}è<)»8ü >KòÄÖ¡|25ME)™Î42HˆðÈTƒ/5/c‡–Â-®4vKšá½p?ÿõXJ¦;ÐW}V|úœAê’ Û~y —ùÐÌyoötìu3Ð~:®"7º347Æ AÒÚ>b1иûh/½kÛz²¯ï"²À[‘"œO0 œ¯÷¹ŠXêd὇#ô©n¥Û`Nr*Ú5«_ÅH͵ [( ú3¥3“Bà3àæ-ª2z‡D“ýA ûOSÜ£±ùâKØòD´+Kœ“²®ð% R'•ZWž·Ãá¡ô«ncò!žèaF÷¶ Dfpˆ<´þ¡ÁŸ+0)ÛxFlã‘‹+æ1ѯ×ó TEßLÈ4 ý±%ýsئSÅ, špÃ÷ƒ§ˆtq‹D6’”g"·îÜÌ–³BZqr[O³<t]‰ÒŠ:Ã]6ã–×D“<ô'êb–I³÷¸× D×TJ¾ÑZé»z¯õÞ)m2\V—b (ˆµ?]çÙZ5u„å%È_Z–Üü¤ûouX00äá÷M"ór·ÐÚ¶a1A@$|1c—}[ùo<§c/5fp3S¶=hnôksÜ\Y5¹~!~½ÖNBB?ÑC™U¿ …áCYücìw<HÊbT5î÷V»q#?é :EÖ4ÃÆ+ƒŽôùž©<Æ>,féEJïŠIahwõi3?£†Š[×�*—(z]­EâK•¨#—EøÃljgöu}Þi žñ:¤t½ëå@ ÑLB™ÌC’ £;Kò+hÿi®ÜÙ¯Ûót‹ìS&ŸÈ0B· Iü»vúa�ï)ÜÇ#LòËÏÀào÷õÉjßÑÇ›×M Å”ˆ}Õ¦MM¯…,÷Èt †ˆ×¡~»@øàÛŸê|N›ÉTW]fø¤X•¦œA…§eoñKݳoÉÝë]'¤Zyjå@¬áûhóƒ©5RžAÇz…2 ŸF÷‹TÁJŸiEõ¨eϪZS”ž;s~㯦s¾¤jf%™ÇñØrå­qIäuóq P¬ƒ'jl‰ÌS¸]©Wlú¬n°}aŽ—~^=bg‰»Je‚ëÛ0\:d«ëÝåÊÿ»¾úèÜìµùŠMÝ¿‘“ ÿMÿ?Šœ¶”ä¿ ’‰³R…wت斿¸Pœœ(ÓçtÀPšge¢Ua¤«‡'’ÏÄzóÐ÷œÁtþBŸju†Rçc•cáÍüevã÷üSõ—º ª¾õ@�Œ´´_ü(“'õô&Ã+³Ð—C ç¶j5±RmW£í(JLÿÅ0‡Io’Z˜  Ý7ÓõÜÖ¢×v¯C&Â@ŠO„€s€©ý°šò»òS7@ü¥Ü'vNd ±8LV½õ1ÄZ¡çæ$ödBEk TF•,tpÚĈ—ö:×T¬)} òð‡÷ã®Ò°¡ÔLÆó:�€y«øšQ®?¬÷fõfö7„¹½íiGû~¯#{€á G(=”4ýNã.ñÔ!óög(W +û//pÙCâúê¡)ÿ_zG§•7 ~îHe{YÉ£6ôµ`?l–lùIl1 S‡rc¸ùƒ’˃CÒÇØR|ÈÎYø¼¦…T9ù0€1"É÷³¾³Î$eà‘ÓÄ—'öØm>ÄÙæûßQز<ó$JðŒà—œNÊ`K v_è'e°YE²ï¤É¢ØsÍH9êÏeZ¯(¬¯KjäH‡?´`³ÈØݼãG-¢M+ê{Œ' péÜ{n4äqÆñ¹ætêîÕ/ lò¦¦3ånQwöøq”çœ/I ›{t²Mx~’Š¯Þ¬uŠ¬b}iëe”dq i¨ùZÓõ¬G!÷þçqúEa;N•6 šg¶xÀÈNg Ǿ¿ø .a¤3% ù—•s«*ÍcÙ^ F'ã[éßžÄbg©Ë ŒMWà kfß‘€>þªê˜÷¢u^l›¼ÜÕ`ù(Ð9§÷fêøYõšw»ÃàX£"¢ûT()‹ò*ÍL*ÄLµýaŒ½v‘' yE�øY¤Ša>h$8<Ì¿Ÿ%—.W&§|›U³Zaø…”z”´’߯uÀU·Žn ã7ŸF€>çŽöÎåÞiY¬%ì"J…Ë¿Š›²ó¶5™,7ˆ¢Á©Ð§LÆœPé®í˜ŒfvuoÆôÝ©@j»úúŸÙµEV“ †Ö”»ÆŠ5t) Ö¹3€/í@Y¤–úXµ÷Á<P>;†Ù¨D7† Û¦9£ù¨Sý!B³°ì«®-Œ³î|¢ÛPµŸœWfÆÉÈ âlä®|Ï'«ÍÆÐo*ç¶Wúb6Ì¥ðt<ô_,5[…Eç®õó.42@m·|ï=ûZWôì7vVî´ŠXw}™oLpûHÇ¡#‘sã¦dé¨îqÎV%5c·¼ÀN’"sy)ýÈKóZ¾¥q­ ú0Õ¿KJcç>*S±í=Y;Ò@gƒîm‘͇5SúáÖëœDzmPÙ‚ù~U'›u²¼…yªûîhTv�‘ê¶S½Yž[ãFÆ[VîI…”ŠO®¡Q^¶LùU!åu±#'-ý… XÊÏÄà¾ïJ>y¢ )wq/äcå¼sãk2ìŠ ª­}£³—MÊ}tËôáë?ëüþG~)ܘa> ’}çfUm}˜¯Ó‚•MfW!]_ï#zš¸Þ§ëý;+” ¼ Ë S>«ÙÕÔ øÚ~Õ]ÇìÔÑÝ&ÎFXLTº[ª2”F>¼p ¸øÍô1Ï|*¶•§øÃ’Š(f²¼œÔAÄðMP3Júúà�_9j"!¡À»XNaÂ�h'‚ÿiéÆÏ<ùm:bºÚ× ¶o“ m4„Æ8ÿÐ¥Þë¹JÑ…ö¹Å D~˜žlŒu¯+g+v¯d¾¿©ª;O¸ ¥gv‚FÑÕü{¯ÐeÓ¹AÁ7ôÿrx€RkϨљèñ—æVª±02`fÀ¼¿Qð£| äÿÕxùéÙ:CˆmmÌ«´ íÒŒØdZ(P¾7“ª©ºËê’骿F7… zºáckÖ%ÆZ;HL3#ùƒÓFZp7«‘º±Ýó¾‰=¿MX¦{1ÞãdiÉΦùŠKg`Š*1ê4%qG·t½Èä]çA `Ê%µÌ}»Â`á¹:Uz·•SÓ¹¹é•xå#cè7ûz¶Ýœ7ÎÄ^Óàwv›‘qúC²Uõ¯bž—Ó4È“hEe•yÃjxÙq=ðÙئ…J;Û·ms±žu çãIDÎFœNZô*s$­BÛÊ´†$øðÑMrB™Ãšó®×qûžÓ$ÂW´=¥bmã :RÞ¸«­aò„‘w$ò-7™X?NYîÕ,#†ä �ÁÖ×à4juØ汧¶ŸcÅ¢¸rda.3-Ñdë¡0wBVñ¼Ó KG4]E‘ݱ;êZ:¼¤ï©ƒÇ?4öNú¤2ÌC†‰òíj²þ¹!ænöÃH’þûùÁa’øT!¶Ö¡Ø½¿{åm3Q­ÉîÍáØ×¢Æñ¢JGî͵Öx)ðFÖ`o Rм«ºI"¥Ö8ñ0Üž¨=‘7’â–Y›T¬çYû&¦¿ËdÓÜ(,¿;S©\,µÒ-“ÿ±}¯´ÃP$ë+èk>¡·yô<Óé±W'븬aãTáJ z®SôâaÓ(¶ìèÈxûM{„xËd£]¬íìõ$÷8ïæUº#¦jñÀ ±Ûf[�7tt[¡QX(1×AtÇè —„<q¶êpÙ‡WÄ.áæÎõæ"d£å{ÅUÂN{`ÔìdLé]íMÐ+ý„Ú¹}R˜òŸ·>»ýEž(LÜ/å‚Ž%½¯ô@LY³þ·Óìu}ødå%'"úúi»÷¸ùu¬ÍçÞ0 ! 'úË~F—†¦žÆÎH¬y­Â÷I�§?ÍÓäFâ§?#'Ô››ž<ÖèRËñöaS”á jªáÒŽúJ‰ÖW ÓOµØÃtõÐKž«Æv®ZATì|ôZ@?ý¥qáÎ^¦µ²yýU9,exc^ï{׿àcïSú€%€8}rkÅ‘å@P 2Óº§Ì¾g=““hÿ �< WîëUp¤#$u¾c¬Ëq–rÆò¿Qˆ¢Õ ‡âpGq?·îRhmQúh…Zÿïíð‡a¼æb†Ù*ô ž€ k'úî-=ìØʚɘkîšn²3böˆe¤ª¼~ã=ËòëætÍyïТ,ê«7ÑaÎŒlrá•+Lû¹Ãv´ö1ÅQK‰O±·t“ÌÚJi+ê7ÖO©‚¨ ™/¥Å”RžØi«éÃÕ „Qf13‘ÿˆ…YP?ªý$ž£'k0;Ú½ÑYç¦<Qé(âs.-Rxó+pÓÏ_ ®Di™y Ž°Úþ„ð<yâMKÝàïÁO_xVj0L»Ó‰5û×Qbï»È@i±Ÿ_.Mk:Ïçìo|Žü˜3°ï„ønö€‚Çڳ T²<S%Œ?{Źc\g œ\ò Û·Î6þC9ÊþŸx^f–‘3+œÄ¥s›K3åMë ~¢bþ´a{îK¯—^¤féõ¶.X•ÃYžÂàj¬LªQ@‘¼á™J:²•¨·QAÇýÎF†Øf7àŒ-J5ízcpDÿcSoö6™àþÈÍ;ƒ¯4ÊS|Ò,3š ûO¯ê—ýÊmÓe:@8ù òC˜Uš·óÂ6Ìš š²‚s/H §u¾¤Ü+T³bzò›åÒ)ƒäÆ’$«†Ü>`|4ZÔG¾¶3öW1 geùáÚUÒÆ¡SA‡IF6ôŽ5Ð2e´E;_|{å=m>…k�[Äî»qÛ;íµ†]nìü›…žTÎ2˜0MNuú§fœÒN?>LŽ¤°uÞ·úŠåÂòw"µ*XFœwî⊅/~&UÇõñd>™Â0ÃElþd¼å^•Îãà *¶p9û0Ì;7ŽÆî*ÙÂØ LÝÂÓð «2>@¦]èqö·—ScÑÞ,Õȅ襓҈·ºý©ó•Ê •ÐTâ­{ZmžwÔG¦�Ð×hOmà…l/ w€Ü«³7Žóìfø´Îû¼õNh)“âàØ®<Ðr%¨±¡YÑÖYËá;µ{6¹Ñ«NfQ–ûºtL0©ë¼ÎíŽÑƒ“‰¸g=Aë¾=ú¥QÉŸÃÊ8#Ø#Sb�êuXŸâ¼ ŽåEš9/$ì(´Toþ¸ÒßÂÓ™ï5˜Æž,›5ºý[ßYC§T}H™ºÞÞn: ­Ó•ÄЬ4ÊDZÆ .ÝO)ób2ü–q*hyœMPNE`g#Û¤›;Š”m__D]Üýir 4‰ˆ‘›ãqVß:q³= CsÝ‚÷×,,å[­Ý`²ÄK”;4‹öž@Ó_m¿žZ·c¼ï$âÝ4;1)ÿÇÂìyAÜ8Kîùß·JU|Ig(ÊLL±t×YŽþ“+ùÃ]ª4(÷“wnqG¯½N¹ÄÆyI2U¥¹Õ¦Æ ×âPnXÁÞÄ&¾h‚[¥�gz·š¾5ÝêÚBTÂ`{˜è®z[“hZõêý'ü¶dTAô¹³ùs(*+¾b¡œÄVÚXÂÈêÑ>ø $×áËM@RS7ª¸l_¬“-°Ÿ—¶žC£~ØSoó)”Ú†¯a÷g1_¿¹Æ£çvŸá§òU6Ýȵ«Úlb‰ûô£ýÉÔÀˆK¬PˆÍÝ*Ý /¼! möÙ ¦Y.ÝH7é£hNI·¾|$ž¾Ëfˆ6í®ÐÞÔØ™—ÎÍÉÒwçÕúègßÄøí˜ÿ$J5ö9ý¾ë»‹õ<ÚÔÎ|õõËê±XRƦ‹Þt¤ûÉe†=¬œÕoµ¦£ØѵeÕ ;Ê<§ÑCŠSäiEDÀwûý¼; ×S³’R4øŽ+ß¡ˆkÀŒ–¨ûkc8CÞÕ³´® ý Ιâýyrwšý¸aŠ~¸©ÿ4oyAG)\íf‰ÆÂ#Ía7Ó3¾6' Nt†Œq1ÖÚp (Íâ4P–ÍúÝZË‹<.3%T{ýô¤èÓ86ªþB…÷)pDkØxÁ &‹Š…I9Ý�øÝâOL§É {Q a~D@eAÙeUyá%a+¡,n-<ª@éÃy1B0?z‚„{‚X¦S¬(2ÀœZÊt\Îë'¿žw0óTd6\}ZßÜ6’¤) ?HŠb.ûxqN\Ý(¡·}B¹ŽïW3ÔãÁÉðÿnP—~ó“RÓºO½Œ!sÀFsѬ{L"P6˜«;¹•0w#^¶›B,Ú;D±Á+8³ŠWá¬Iºƒ­hy¢ð²*àQÉ«z_}myiGßÉ×6WëðÇÙ:«d_ßòüîå®Üf8ŽcÇZ¹?xûZˆZÊÂ5niYÉeÉb°Ç_·©Ï¿`*CÛÓéàì«ÛÃ×þÔq¦: ÀåZÏ÷`U?ÏX¡Ò¢pÕaŒéPªÝÛò<«™O GôÃJ§$³ß×êaÝN³DÐœiLχ½#€)c°ä›é´]D« 4®ÃðF›»[ þiDZp&öÜФR“VG2+ƒ¶äv±Ja”Ý+›aÓ×ä¿F|òïÝè°¼µÝ; #ñ{çiø19BúW{¬çÿI*V¹Qe#ð»tÛÞ8¡÷e¨”KýçÀÓ/ã]¸ŠºyžÝT&û2xƒÑÑw ›Óñ¨yòÐ@Æ;I{ðE|Y’TN‡«ãKɹU#c A`¾¼â‹Ë}œƒ¸zdä'—à‡äIìd S†Af-€i=Sî´ÖÂt·¯vü/¡¸,|$}ñÝ¿N¯×�ØÜtXŒÈÍ?œØqeenŠ¹HV/zû­Zx”ÕzP’õ¤Ì§m'q(7NçèÄVáptyfSXn@È¿ O•ÄÈÂîfð�é^TN9"”9NÌö†nJDe N$û·Œô;—åç#kAbõÁ÷=‡A‡FU;7 ¶né?„+”YãérÍ¿ª9全»mh÷3¥Ž—A^â`whfÇŒfTœÕ�©{¡z߉Ü@¿"¦)R`>50¡eÈç‰Ç§Mà·Ã&ä]ýæg¯Û'±‡ØM¸qr(jëV,–ªàqLÉèrÁGÛè·ÆÑǬ]âaHƒÒŽ£áwЇ¦üoD{çWÂ-îà²Mƒ¼·‡sXÔÁÐûíÙŸÄÌ?ƒ{Zâai\�vg¸Îô[Ž µ¬ÓÅÒ´yŠ)jM¶\.M´ m¦²ó51)O8t7^­Ïhï‘'PÆJ¥Á2$P?½,…Ö:Æ{FX¶¾; hh½±¯ap»»%^ž—YŠ±Ld½rF�õE �“%/ &’re|I÷só‡2̯+¡ÌOLÚý³œ—|æFsì‹ ^®V&²bÈnBʽ4nù-Î(VTlipFËÌîßZÐ 95ž> «^ÁÏï¯dY£¼X!ÙRÔN©§ì€ÞìGèp`­y5øáU•î&˜Eo¯ôy-)Cq;²ù‡Bz~ý;éæÒ°£H+ÌÝ5•3ZžX 'çöܤÐ)ù3ȺÝðh\¤•3zu¦+êÍmŸ]{º„fV“+ ÉŽ€þ†””žë6g±3@¡U£ì!˜ùÖsÇ÷‚ûŠ¶õ§•¿c^GÖ±2Î}˶Vý&05ÛÒ5Yžûþ¼ÃÀ„»ë›SÝK@ÿyÉ5ÝYog*ÅÉGŒÊI»…8™Qn¡~?ÓûË­e¾z*•ƒ¨Z8åt:e!cõû“¤¬ !Æ%ÙEA.ãm!4ÉÙ÷ƒ¢èVM£Qù‹§½ù³êþjFîúûPèz<JøÄä)ú\,Œ¿àNYÿxìô³öK,"“k]OhQ óÌRÏ*ÛMF®ñb}iüëûª*Ίl­?4\UÓF975i¾a,ª±Ü44ÚKjœqê mýEç"…ë+œ'êí˜ß¡¸cÕÜ [œ³èŽÍ:»iþÖmGÂ÷�ÝÁôÓ2ôY³ï±>ÔMó|샭)žú7Å™ïq‚‰å%r›·G€„ÓjEY·Ž`Ï0汧& ÝFÖÀz·1Qka¤TwFV¯‡©"ÕÕȤŒ¶Ï‚bßyÜD>ç7V;Á}àϼ²}w÷þ@#)|kM(‹Qž\î­à‡A«»•Œ¹~=×Lm#ÔÍž~yPîW¤ö5¼]‡û[¹¾üVp~s‰ƒ¢íqŸàŽ;ZúØKçÿËw‚º|’z¸Û(r xQ©¦úÒ.y´ CCÝ-1ûœA³êTÈa1]ÉŸ)u¥gHÁœÑ†vrVŽ¹¼qò9=ûC㨊ó„ÃõˆÕå„°DÆ­d}šªo,ë? DEGºGTÜ^$b¾Â*(Tuòè€@*ÍöX²òÓ<{æîj,ÇÜÄn�ºšï˜oQ¢å˜Š„=N¢‹ß,ßÕn ü;’ÜôÏãP5¤÷8èj…!p-º�dÒ(ÀäÔ¯lÀþK;ÀDS{ ÜäÕÿ›ÈI³±€ª‹® bÓf +ÌΠêˆtÉØÄÛ•·ù¾‡še¦¾ÚC°Ü/æOõ¯, •?òoí£ÈÓ#äJwÓAj 'yÄÉ wQ ¨í*ÿŸù“³Ž°Œ ûg³Ïó îwN2P}Ë91}°óÂE�|Vàvñy²~+ÑBVþ*V8XQÐI„£ÞÁ¢`ÈÆqÖ”Á¤ÅúCŸÀø`j}ÿsìÝ8óL³�Πƪ9•€¦ëö¥ÎìNÛíüFÙ¿ÍÉyó¡óe€¬·#ˆ$òº¿±x¦Ru2«ÌŒ“ÖVÿÊÖ9^¨æ pΤÃùú×ðôw†ªÍh=º™J\›‘< ˆ'ÖËòŒÎfC9”‹¾lYÇ~›õuèéhþV’+®²AŸ’PÛ8NDô;ª|ôÈ’Ú¿¡·ÛhdéŽ,À]+Ú½b»YVÜf‚2/žßkpW‘;SÙIyÿ­Ñk6Ê36˜Ê îk Òõ—}ýNœ?Ò¡°œPÊdµYSèÍ4çµ>拉†cú†¦f_.ô¬Q›öü¡ò ñÞ´KØMQêo,£ªUzJ¥¿ *jÉ †“‹S;2HÖù™á8Õ”|ü¥k«(…ÆïòŠábǹçÆ*CdpÖm«Â7?).º_“›Ó{×ÓÚKúÁÃã35¯}uëxb¡òÄ–"H†Å–WÁ:t<]ènŽ·¨×Çd©ÜË9bÀ³{n|k>ZVõÕôfé± ] ž=ËZš>^’®àhœØPÜv’U[ bøÙÏ6ØCnZ0s-Z͵诺`¢µùX—e«^MOôdzšGHŒ>#ØvIc7+ƒÍ1’Fjµ«ˆÕÄ è±4 »}ŸºË€BH×yô‰82Ÿ)XsžEf‡Ñ“ð1:‰JmúQ_6¶ÒyljQ¤}홢uýáßØï·-Ýßu&ó®c”+]Š”¶’â­g{��#LPyɤ5+¨ p{F%yæcØÌ”z@üh—q‘9A”<¸LUFJcßK*Äm #éV¢ÈöÖ^;RÃ\®tð¡{y§®%•‘‘Óo± æ”?Îó\ÄU­×g  ô·œ¤()"U×O#Í þŒ·gºç‚¶éèD°´/Wó¯gµ!í:G»$Èfg­RBr¯oÆS´•JFåh¯ì  hK™„Ás¦kT¬0Xc�ñ¶e‰­&öÕÿEÓÆ”j»IÖîæ¾d6“æe–¬å•è>Øm{­âæÇ´´Ì˜<è â–³»òà´ xþj�8”ŽT•¥]ã¾ÙÞj8üäÕšâ›@<vT=%--¡ÔÄgéÓ@(ß[JÌE@î&©·YIl8‡1 2kWš ë~:Wô¡ÛFù}ÃÜw#çp1�U9JU&½ÕÇâÜc­~áø ѹ¾«P=nÜã¿‚Öœf:§¥ÁBkÖ1Ÿÿ|¾·/×ÂéO•óX¡œäXˆp«ÀàôûùöÄ©kû‹/ýî ýÁ“F6탈Î+‹�h¤U©ò $ðÈæ,wR¢ÿ_¤¸û"ÈkíÊ¥UÀÖÊøûélžD¶]†Òo›¦Antìíp¥¼ô`Î ’Ô©sÓž"F[¿m®À>õvûèG¬cå§@h]³ ÚŸý¡¹tN˜€ÃÓª´]ЀÏ�îJ_3¾àxA4h %‘¼t†Ly|]S<O=´;n eÄ“Õ&ÉÕÄÛ™èþN"#[9bS¡Åô8 ÛBˆõµ)Êž”¿ýA.^CG(.öèZ´:ˆ{hü¥Uκ/®n^} biæÓ>‚çÅÅ»Õ`áºäð—‚aýz£øm‚ݠ[œSe8\Í™“±Ó p¥Õ¹ŸÏBwu_¦¹«ŽX‡;¥ÒP9Z³+Î}ãíö´ïåÜ{tu‹PÍ}8:ƒ`€/òîjQУ£mù…ÃÒ‡¯*,«5¦0 l¡VVYð@ÎjeM¨¯ì2 ýï_C‰¤sCŸ_Ž{O랟™ùû2³½ØËLäqµ”¥>¢�þÔuB÷ÃÊ?FCµµîô3ùé¨,ÊÒ©�EÇF¶½x9ÆŽ½-®ÿ}+ßþy‹Bå¢Lu+G„i5ýÝaâ£Ä­AªS¦]ÏÌÖö:úÕ*J|¯ö̈Ó®®ž í`¶jg0ÝÑĶ^é`ùîÈARcp'pš\>¿Ø©$ Šý‰=³ ˜üèã_ûEÕÊ-1¦´Õè‘rm #á'Ƽ¿Ô+WzT ºAÔèR€ÆmsX–zsýÍfK£• |Bk*ú/O;ÁˆÐ™*”aZP€h]Ÿ ƪð¦gÈÖvÑþê1œÜXì~v´KËÌCY3Ý Í—åÓqh*²es=Kºê²°6ãBW9¦àO?–Ì‹ �V&ò°»xM<K<�+…\ZZé©£€¡FåâÐœ†´M;¶­_¸}¯§®Ã±i™ž![5ÏÖaóZ.PÖÓßè°:L³™KƵ“7VM8Onð9o΃ù¥¯Ò³’Øë?³ªÞüQQÛ›åD­e=…¨Ë¡?rûÎ^k–Œr¨xûé ãÐZSòmGµãBb> ³èÖ^ºJÅrb¾!—úæGûZJ†»gUz†örºýH[íÓ©™îôµtšdtÇ``*?Yµèö}[o.Ç°Ö.±¡á°ª´öˈ6ÐvPÚùßêJWÞIÁÂXè:4*Þ·áBÙA% ÿoвwW›:}œ)"õ‰0!}nCÁ/ý²Š^µj6ÁD,!míh¢ÉOó¢Ê�f%¤vr¾51‰½ß£eðƨW%Y¼9¾/º¿3·÷oiu‘$iRÉ—l¬6A:LžœÞ!ï¼,†AD‡FlʲÕ×U\Ì¥N:&›-\£ûÑc½oN984éü‰Ks«“êÃ}Ý8bkÈRé<$èЃӢüW’¢‘ë0‡‘ŠªWô¶ÿ´ç|ªë¹?Ûî¹ ¼ô‡ çø{öL2;\,àèW´T N ‹)TRºt�óBÀ˜VKç¹Ògú"öˆIÅZkÐgb:¸Ù­@¤Çµ||y·Tl>™U‘½ì¬ö_…/þ{êLþmÔ w„F7âOœW¢›”«hªCá 1¯RŠÄ—=£ xì"^*P2”k­“x0 í°N‡ï?þПÈÎsÎâÃ¥Õ É0¬¯Ò9;úQ†˜kKG6ʘZÓÅAÞh?ÖPèý÷-N}Çtߤï‘âpíe{pþpåFD.-¥0Š²Õà†~¡tÙø™c:DÏøÔ×ó[ ö^Ëa vÞ<â¹q¦Ms7ÇÓÒ ­X¯yX;䯤”UAEB)•1×Fsçúî4Â0Ót‹"è*=«CJuµñix›ÇZOÛÓ'.U.7sšžiÜ-ª.Ã-cúLß}þQiî¶2YñÚIyáÅ@‘â¿P¢íT²ÔøB韓 cg÷i„Žäo/ \áË�öƒeöøåé³mkŠ{W%VÞ6{~'œæh,¥‘JÇ™]Úíš 0»a§ïYòÚÉU‘[9+;)ðnàØ´´Å#/pdG2ûò ¾¯õE núœüÝ×RÝYegöWÚ¯¬x*™³‚6Ð÷™wýn:—ýê$ûÓüÊ]¼ t%±c.0ÆwÁ")ðŒñöÂqó–ÑWR‡\³!~¤¬Œt¬AÉF¬iYÌ×W½HBÀKôGQË(Y‚'I§U‰c1qÀÀgRÄ•––Œh^Ñ»- ¶\‡îCJGÞ¿^Ý(Ššƒ1êÖ‰>¸«ý1O Œ!CG™Rþ)ŠÀ àÈj¦ÁQž»AµÅqBsPXÕ‘3ë( ©ƒ!OµUŒ &crN¿÷þÔ¶ÝÌø){õ '¶Ë]YA@}„ÍÖ#Iâxõì1!#ÿ3é«ŒCÏÈ–V'¢qÓØÄ=6m+½ãR‰þX–¥[ö9^ш?-u¹âÑùpàÜÙŠ/ÿÔ€ “=–±mµ“Ô[c@Å:”Üž{žÉ|‹Ü©nùJ» “›( T×ƲG/)èß]Åqꪳ‚Ebé/)&å%ÆÌ|ŸN8[ÄAÝ$’RÏÐÆúÝS(GUdžÊ>¥P­&›g‡†°ÒПw]yï‰íÚ¢¥ ‰6²¥l«s ö@?}íY‡Ý<úcš«—þð{¹CqŽ}€ÙJœII‰Šøt[{HO†¡ýÅø½pFE!‹–ô™_zør´“¡c0ÓK~;"©mý´öokóOçÞkÉGö,÷\f6NÍÄV� Ȧ]êö¾}wdå^Nwa+!s‰çÆoþYÈ­µv¡ýT¹tªôt†Ýw W7«4hÙ»‹'bjIèñ¼‡zü³µ¡rFl¬¾( P£ÚÝF_òõù«õæ+A mW$A>î<NXXØkžnÉéb˜û®ïëÙIüiÆûè*«Ì§ãÓ.øXÐÍÞkýÓ)²š½Ê^“Vá#‚<[™VÄâûÓî-Û˜­ ”IËo]=þ ­ðª¨‚­gfŠþõÎSÅhêÝ€8 ù}(ˆØóË’CXodÀØ?o¬ê\ʱ€Ò?É .tªR±9<¦ß¾êr+Ý´ˆ§‹ UÉK·]æý>žE½á¨IAaïßHMD©:²¥kÀ>‹N½Såûãc9þÒýÓ NrçŒìçˆ XÃáË C>Õ‘ÏKCʇ´;GÎÇQŽÔŒŽê™õ «3y,q‰ô—ŠÞ“f´ûn0¢>¢QúÕ‡Þ¤ú"ãÏíóŸDEŠØ岬Èv=Ññ˜6½ûËĒĨ«`iVùWàt‹!cñ?¸bo!b2zêøtˆ—‹‹˜¸ÃLæçìèr-…JO©£"|ìMY´= Ž:*¹@ƒFp6B¨¦Eõ3œßÃïrÑÑÀUgÐikUúEêB智–öù«øZû@x^Bû{†×eÑÙÉËÇÔÿ*jãØõ2hÌiéGLƤz‡amkQèÖ–=¯,í »6룫û~Úª9‰ÁElA8¬Z$ÒxVzøƒEå ”â +þg» KM¨LCrs,YfÁu®8DóÑ7«÷´Hq‰×élzìóñªEé«SÑCÙì *pT4Rö»Óì¼)q ÚŽíñÔC{ä0˜‡â]k#…³~ï¥ ¢wU€ézx*Ra1Nô`¤ ¦?6IÂ:<êщ…E‹lUÅÚe\z¶€Ì‚”’1=ݬŠÜÀÐ¥6ú°‡ž+ËÉs¯ðo¶¿•²W'§Í6Ç4wPw:E@‹/³ã§@Æ 7L[§+ûïâsw}-[ÛˆÑ÷á2øÌí¾î DV (E&'*q ü’üêM½Œ«Ì1ô ç£z…L=~ö'|ΚVÙk8“8ZA(1ÃèéŠ>'O¨Ž ÕwÁxê§3ýµÛÓ¥»>Ô�‹T1Ê8¾¬Ù66Z¥âÚBwnƾ@ëïuͶªÈn˜ö=ª~ï!œƒáÔ$5¶Ï<L–nDÉ ¦lîÍhò0÷ðª}côTTtvÚñ0ÒZßR È·Çü1³éIã%öèÈ̶€´‰-Ö£Bç×3÷íŸ7c“GeÅæ$,uôù«D¥ˆo9ÄÓB:ï‹UÌHkу7ÝBën2Õ]™×pTž»]ž3~¸£Š ÙúbùŒ½e£IÙkƒ£V»’¢¦_PÚ©„—•(66Û¤ b+€‡¾*>õíx¥ôð: ÃÞÖgöV¼Žô—´/£ˬò§•eÐ̨kš«ë°oöN:§Þ|¼1 Gl5M?îŸùLKäŸcmgâÏ­ \W†ð´6¦$(,%6Úó3™_ª“Žï¯ì¨«ò¸&l9_˜ ?iÝsí~ÇfÙ¡2ß;y]k¯yúFEµr¡£òp¢Ç[Ë ÐC:ÛŽÏ~` C'ÞÐ�Qš® %"Eµz±³¶Ñ ¢2ç_øÐ_á€<ùÓlf€"²wmÕAPùÊ>t’ñ4Øâa}âÄ3ó䆗ƒ9N6l­„DÄéð°ðjYôƒœ$»¡;€Œœ[à¯öz}ò3U_tôòsq­Îß’³\OƒÄL©6@éÅÖíiÆœ¥: ~œ�¢ƒEÌ´''înC3õžÙÂæv¾ñ<T¯ñ|±ÀÐ ÄËÇ?Ä÷¼þÃoødê7@™oÚ&FUSÝŸ¶Ëü_LJ\)•@»ÉÈJù¨ô¿jFæžY±(tï똞õÕÌAX†ÿÌÞ0Ú«ý ¼˜e7ãë D´a'9ûã™ôùh…~¡ÑÈ5­^´ˆ–:°‰µ…o6±8½§¦è0.Ótò_½ù€µµ]‹a6§ž™«kUÌj¥z̬aZµ¶Z ŠË 0EP˜£WgGgΊžàx¢Uö;ËÆ®ÞXÇÑÇ/`÷i‡U«Âžœi¾j±WÈkèŒΞrõHEÝÌÅ Åße4…GÌ«ŠO7¡˜T؃ÙA§ñªH‰Óia«šû©©“¹@M,S”ËèZê3(MB@–ù³xi+_>`*ržN³ÅʃñÔŽ¥åð%xLÇÎ/ȃ°` Ú6"\툸ܨܽƜÎ1d"…d¦®½¥X— CmhsºŒ}}~Öî´zJÂÖcž­Äšjd>ŸÌ€è@ëÞŽgúHŒuŒ©Äºy9ïKˬ]†$¥å«ˆÊhJ§Ñɘ=Ñ3‹‹Ø‡+†pcJ‚¬©­ -¼¡QtÚFó!úObŸhjŠËî+¡òrú×ÐÀ¶| ð™éÏÚ¡í8¦Ó]2îd*ÛUe«2ÂiYH'’AàØÉèþ¨j‘¯åÝXÔ¢ ÂQÕ�7À²ntgòzn<¢H–䮌"ªÎ´’KTŸ:*i_®<­|X^w5»D?€”g>… *’5LœgA”‰n@hôygø…ÐØsb$àåÕ´Í¢š)T £ïèg t÷ìÍ&j¥·|‚%ÁJŽìálwbÍÚlS*&w­KÁ{†g^§·î4«a€{úÑrm·‡þ‡·H»n.hJIJN5Ë`Á Ì1Þ<K¦_¨WTB”'HŽ”gktbœŸè?áàõ¨›]|ËHñFž¬W §ÎÔª?§nâù+£ÎØöHL»„èYC3¦1œÞŸÆÎgÒÎ|ÅGïžvþ öt¬6劾s^h8�àFažò+ÍÍ–+“â*8@‚*¶jÍqb0ÇŒrØvýákF®í_šò–y e³Ž¢t% õ.3Xlhkì/õaéŒâôlšY¯¿ó-úJc}Ö�–Z™m7q‹†Ë ø5(©EAçS8™µg/VëÈèZ‹ÿ1Cþ¦]œÙ¤M,Óñ|Õ©ÏliÑOfÉŸxkŒš¬„Ž3JKºÖ³âö$|/–wÅ£]ˆ…ôöÚ êTt’ëðñ ùÔã[³¶…³‰€±”=mö<ý½¿x,Ù™ùSÎ0 Úº ’O%2#=k§ó‘ b3CèØÒêß­Œ\—§u¬¦·JÕ“!õaБVµL äþ<Äy•þc5P†’V:ŽØè˜àîJø棴nšÓ̘ØCL糨%©ø6|çÕê7Ò-ëèq'ç³çzŒŠãà©Ëôõ•ùl’fÞ¡JÏ»ÇCwV/ìƒÅìF˜„ Ü… ‡Ó؃Qj @›cDûÙÁÔ7”NlâežuÆ/þïJiµê"@J¦Ïƒ¼ÓYEÈwõ ãõ¡5¦+Þ%Ìæ“ !~þ1bSäš|\®�íZÒvbÏ‘ïoðyš­4*rä’´ßìŒ<ãg­~é·¬Ì<ùb &§‹dbßþá²t…cÈÂPvÒ{Ïi¬)c?xŠjX¤:‚þAù¬súyìz>¼A}”z�¹ŒQZÛœRŸ³•Rã™1³Ÿ=ÁMŠ’D=Ú¹'À¦ tεʈLJÿ†Qƒ çM)‹f|ÛQJ¬Dn´–¾mò¹ó"ì|àdŒÍ*™sT±S¯Ìšâ’ËÖíeæCháÔØ'Œd”¶e\rñÅžƒòâV/¾€Ef×SÕd'±2yæï>øÞW:N /¥d÷AJà.­ƒè>ìv–ÞÈ ÄÌEô5Tÿœ‰˜|83B' #MÛ*áôîþð-�ólÇ^Oå9/ÔÛB‘TéT. (LááÚ]íõ§U6ƒÎð½ê“ëÙ .ÃÀ-R[w�’Ö Üâ3ä×Bt—3q‹}�v·Z µ˜4_ÞfÁ½²JÌÁ0,g]}wuÝùsÆpPžUÕÖÆäÜ'‘¢ý¥—ßèxí¥¥šøS»”M ï¸Äõ`úR ò&o†ÄÃ- ¸Þ¡X¸ÌO¸§~o“$f jTG`8Ñ/Ýé¨$ñ7/¬¿t¸úHغ€ÍÕŠ�RgÈ‚l«ÜXðÐDNŨ{ýFØ1{CóáǸ–­Çµ¦a³ïѶÚâôõ¡–‰Œ É•A:ßèÏVžih!<4¾Þß½SŠ= ñ$©¿nØ¿èƒGiêÎvî 63jfåádÑÿ…ñ›mÌêøazy{ÇiÑ%üò_¨2øVòl¦¾ŸèŒ:t¡ÛDÁÀz¦©¶ßéWÒsäønê²¾¾°hõnm8äé¦e Jݧ^õsgãÈî$a¦Å)œuz "°m)©«Í1;gn€4ž T˜½Q ÏbÓø¸géÔ{Zý€„bðŒHçúË%Œ†‚ôìÕ†$4‰s«K, 3ha°æ{°ûÌ!Χð?ü¿ÿÓ9"â«ìŒ<ñ Ìõ¸¹;î½db< [0i8€ F+“®gÐ1`6­¯`-Ï÷Ù¶äG‰q¢œŽy“úS %CõÞ$t_<nea€_@ãuì[{„Ì&C ãò®òTd—‘Ñç¡;3Ú3„æåΫ ÌWø}vÔ ’ñì=fV[Á‘ NÞ¯Rec58¶Ý„]Ÿ%AÕjƒêh…±ÔÛíÚÝ÷&d…§\ÎÒdU£7¥PtÕeà½ÍC_S)+ÖŠ1%<xþh€¼©±–6½=ºý•&n'¾üà_`µ _N›±E ŠO ìRO¬Æ¨‚0€G[M_ý¢–»?Ä7ä�Pí,#à×Ö†Žc/Ìù_zÐPÆ•P¶ŸÑyç H †ÔYmíèë£4ßÓhŽØ›o”e1]=}Azè#ìLÍÇNTTc»‹f^îU1;ÈÄz±.õo0ìÜ0žèRC~À7ÿßp%ø ˜k®œyé¡uÏâ_®Ñ|¤Ò¢»Ìê‚2έ¾Ü®pȉ¾‘ú¯`ÿ‹²„Ê>TýŸƒ•—{‰â—ê£ä1n—-%£ak;¢èšÑM™5“RG¹Õ £Änýæ9·×y g†L¸ùC¥\l=…Üõ]ÓyJ.Óy×\Í¿·ÔxåñF•eÜ·q{ÌY–HþØÄvOn©$Ï¿©íáV†Þ¿?Óê¶U¯­_`z´næõtú§ÿ ElÆÂN¤œ+ôòóñ·¥Ó�…€DïÞŒˆ€W°Èå~=xõ“éX@ÅI6êÀï2º ªœ¼9÷´ªE…à§qD¤ðŸˆ¹ñ´Wú9cø¼ÍCÙWÎÞüoç£ÎÇK|¹ YPîvžmP;ÃÓ¤¸Íðóþ-¨ ïáàÇÍcI+Xeg‘ùÌiøஶqoyÁ';õ†2<acy“æâiümöç#÷¾Bý·Ò&‰¯ƒÍJ °šH›·ÔÞú†<ÁSƒÐ#ú;߉Ôɦ Ó‹`oMÇÞ¯ýYWFHú¿|þHYøƒÃu”•™%•²;A³èûó_7P@+`þí‘œæ+"…�öƒ¶ö2O8O‚†wqàgOèÄïñsî{ØA<OµYcAa®v`üaǘö¢GTã¿dÄ‘ÇæÉtEiaë0 l_¨·á•»psGâðÆuàµAÖ©s›½*¢¶’J®!Þº]:^ñn×þVÌ›Ìür¶Òº”A:if~Q¬4gìóþ%f23¯aO±g?Â|¶°é#Kªw@‰é¥Ú|5{Í<h{ÆÑs A™ÆW#¢õ’[¬ø’XH9źŠ]^ œ<ãûAGa½¸£°éd|î…;…¢= w¹Ã˜q7ïHk¸øT-k¦Ó=^¢æhÜtöF-ß™úc<è<Rv•mý™©9é?JÎ tº#œzŸ4ײŸå>:ž¢%®PhÕ¡w|„A‰H{såæß^±^•é›†ÎÊLh›Eг¥C£4P_.›ªX zxi­œÃØ»=lƒ7C²c´Óz€sÛiüM2ùé™ ×rLÉ»W+cšú%åû§ÇÚ_§³"ÏÍ© W~<´ácÕÙ³<}YçDx[säXBë¿kQWÌfp.[orE®^f‚Õ8UAµ{÷»ä"–$É2î [H<‚Haš;qñœmå²æì üÑZ<Û·|>ŸÙ—»_hZ,g™ ;Ï^Ã"vÜîÅú1­Tã>û½²eúäÄæ;EÖv…Ʊx…ÊÁf´ƒ�1í“%˜·½òÔH²gæË€´åêeâžþ<š¤´ü‘öW¾ &…œfˆáwô¯Ý°tw†Ó¥uî#O…šk6W©ßZm0ºýÅó3F){´Ùr#ÒÐüi °{ ¤Ÿà"®|,Íìëb¯åcâãF¡NS/Z½.N³òAŒ…&O7ÍsåHÙYÐM·@ï_Œ<U¾JÈûЙä¾u í©e¦JÏjY nôØxJVßá ~CÍrD‹ÒˆƒÏ;TÓÊ]FìÔ¼,Xs9-èÀQù½@tGáºo+)ì‡?ô=î1ÅÕ" ²åâuø.Ø„¤n5'‹ÊúÖ YŸ³ô’ÂQ iQ³pW rM[­ŠnÇ{Ƥ�dç×ý‚¦Ã(&i>ÚL‘,£m¡ß×JiÆ•§ÎŽ%Õ»ÂöV^gŒ…øFh0„³Õ`Hw¼Ù¹]¨“ÿ“¦1Jx®U^&ÆXñIÚÆIt§6hMÏ],Ÿk÷hq‰Ši´ûœŠ¶ÞÕ “¥¤K¤y꽶êõúöðØÍ™7£Oîû„–ÇT{ÂzÈXêžî6ýõ�‰ m‡Á®~¶Nç¨è,ª"?£Å´k:t‹-ù•EßÛ÷Óùšix{îm‚Äf Â1æŒ0@ÏÞï©Gÿ©gX‰–8 ¯ïZa±¡¨g0Ø´òb ¼~ñܸSׯÉX'­Nƒd7{ ˜å0½]Þì¶AºÈ91ÓCeÑê›WRÇ…>5ržbI¨¦¯W› ÑÚHßð…ÆD'™ßCÅX©d™õ9Ø0kßö¨õ­ï©À=~1Jª*ë$™@ÓFT#özÏG^B›±FQ—i-f(ôèF‘z5²x÷485Û‰•§¹ƒ0д³„ üÕÆRÁ€.äQ×F|ÖX„X“áÉ[ã­—Ÿ[›a?{<M€º³±/v™ðÛnXÙµ84ÊFTøWA<t¶ëR­[¬¼R°EnªE¸25£MÖgUŸ¾mØišõÜv§I_v°l[ûŠiì"c†œvìi‘ç}c—–!…tÚ‚¶R…œé<BÑÇa’™0B‚‰¿1«¢è‹ùâÀÁV{‡-o¬2å¿”ª¿’¾GqzvàŒlÓ<È÷j%BOΡ™öò¦Ü»eÉ´B¹N€aÏí?ÃÌNÔXœƒ›0­B�›hëK˜;gú/?·a"‘‘UûLH²€™R¥fç¦ûÓècg ò Î –ù¯›ÜZÞŽ]RÕhí¿¹Q?Z—|¬ážb–ú²³Tœ»F,«2"&ŸÁÕ$"œ¼o0Œø ãÆŒRé¤(éC÷Öì'ë¼bÄt5íæ<>—þ/³×Ï~¦õR4ø׋;o`a{õÓ±û¾Ï[¾ì,”4€‡ÊZ+PS’*^£·¼ûsø·cðÉÀEŽÃWUeæQ ÆOtêZÇbªü¥KgP²|i¡�¹À×Àé줒„´bÚ<p[\†+·çXÜ8ȧ½zH¾gœúö$nµÂ¼À²:³‘%™§‰´šF«¼÷‚Èl’û|¿61”dí z1‘àK¯¦« ðÝ¡‡c¢¾ª7â}Æ…’»…®å›#¾vL‚7–ȶf: îöaÃàFwyk æ&•™‘vZ�Ïø4—:ѾӇIÙŒiБlú1·)rî-QlL¡çªi{kq“Bš‚¼- ºïöÕS¤2#3}úbƒ;Ü=¤Òž;-V¹@lÈQøw7Nf¶|. n2}Y§·4g|*­¡A9àú¾Óê‹ÔjËb/–-}ßbÔü éúýL]  /S÷–¼PÖ™ûw:u¤ƒ·6ÝvxCöl¦â§a¡ZÇoRBˆ`ïÅ�t©û†nÓýOcg7«3¸úÉî_µõî—óT¿1¬ „2å¹üzÁ‘ä¹/™AiŠ¶úþê+{wýñÿ?¤Õ¬Zy؇§®Éyò¦FZ’?•$\–iNú©½*]WR°cT&P!¾øžT›+˜Z*|ü9L;*Sê7y›„fÝzs{ë+ÆBâŒç9Gl5áêíéÔÀ vß‘¢÷Á•+?ÂøÆ9›ŠØª®$,™5œµ«?.m÷Ýa‘T‰ëBÄhNíw”éö­ww§C÷§>÷_Z"} ½feº®ßYi‹G.ôQéòU6÷›»ŠŠBë•ÈŠeNõe‘é¤tw%ô¶œEèE7‡'ÕY£Γɳž Š&5—#}^Ö¶œ˜>χÎÓq–mZ|×Ð@?­¢áúù0Æ”ÎÍŠ6�úˆ–ppX,”¿ÅÈØɦæºÐ§”J|gņŠ÷cEÕʼá‡÷"p7òð#˜Ù‰†F<)ŽõôêÍs“²&ÄJñ‰€†ÓpT%FUwqœ:“B:•ÐÉFŒ&öˆò¿7 ¿+O+kåHU8šBÑno¢©ÈŸKÖºQXA¹œ„”àë/›øfµB‡^§î¥1ÁãMœ8§OIøâ” WÝÂ!õ±¯:ó‚Ä‹’N5“0ew¹õÜN‡£{C'Ë·K³â0~¢Æ „¾Ê­ÚF¥/TÆ(À‰’“Aý¦kÕS¤ûÒˆ—êƒ(¦´ŸMZÂð8GÃlh}8Œ]ÏÏÁ‚^r3Ž�’xµQŸq›Å9X÷§ ÖYµ”ûlùLü6GA–­œ‹`,-*™S˜v_FŲH ÕVÀ)Jf¦çA)}Ö]'$@ª„àlwùèJö4‡/|Õª¼D{¶-WÍPJLvgú‰ ðö*ÿêÿjàÚ¡¸•Ç+„n #}‡pî<â‘WU©¨�‡[ÜFA1®ýYî¬æsã`Ý4°)Õ7Ìp+å7h _s{¢ rÜïìü˵KPxk/¼ÔT¦ïGJô«X> ŽPQêÔ,ëÑÉÂÔ× Gþ†Ü»µB'¦§3 nÅ+˧ÕÅ3Y—*»A-CàӮˆ- Þ`ÅɆ‹@W3Íî-Ý®›Y”¯jÁßyÌ©hS,9�hB8€d‚L`qGÐ –sxý7ƒñkÃE®³¥ÌÓŒA{à )Õ6Án_ªYH æâÜXìˆ$œq[Z_ûšU|-NçsC÷Yyä„“b‡B#!Y–•ø Ú'“ö+oUžÉ%¬‡êÀ¹SRUÖŠiz,t*µ 8ñ“t‡±õåaß“©îgßwŒ[ft6S-Ʀđý;Áá@9лөïþN³\º&pÖ΃¼9«(*ÛéÏà!‚„kô-0DÈ•-¤ï*ê*õ™Xà£OTQ¼«ðüÍ(ÈÅÎ\›œ]­(Öø X+ò·}×¹ÿ-°³”X;îâfíðž~SØ|ù¼n$®+! W,}&ÏBŸK½î+²½†J¬wú?lkíÉ ¦éæÅrqbG g0%Âi6­§ÐÍ7@ëþß©¶ÆÚY £tÄt‚è]éJ1 l^tÞð~àÐa˜@_Ä© ;Ú=¥õ>Ì!£4ŽVžÿtçÆcEÛšå{úΔFÑm¶vÛ †ól tˆ¡_Í ¿=Š7ß°&EÌšö´ “ñÝK›ßÏÍ”ÅdÕWÀ&{Ú±uÞ‰•qG›�˜­v ˜…«pÇÂÜœ¢9«È-c.žêÚ+Oq°0GÄf¡Ýî?•O^ufŒg ø7Êv¬Övu¿¾FáÚÊ-¥,J§º ¥²ÑÀÈtá£ÌËã**ó\�Ù_¤Ahª,‹¹LÙänD µÚt·ruâp…}¦»Û€åÐwêø»@¤ï=Ÿ8òòð çÞÍå6Ñå}Nº¨Õ\Ěϛœ¿¦`ïò™D¾ïÌ,¾Ä@|¶X{–Ä[÷Kœ(t°{Qéc¤á¨8œ\Oé—ÄßgI %Ç4 òílî O›9SëO°®Œ¤¬gÌ’œôÓéÚÏLûðÊoô•€ýxø²²â¢O,êé¶4=3†vcã|tÌ5´Ú7BÊ’czåAGEî㊸!4ÀbíY§›!³¯·ÉG6¯ç†ö‘’; gýžöhºš³ƒ€“Òé¯uƒ§ìhs †²4êw<œòVâèRÃ÷È©‘ÂnGa@«™"X/_¿˜s,qìlŒ-½¨‚ülÉßåEbÑxà”my:ºVªu{žà”’*vœ0Æ/eñpqc2k¶€«�céáTÓÊrW´ŠÌŸF8€aßsÑÁ(œ‚ë ëwðÌ|Û dߟäõ%6OÜr»Zl4þžÝ‡;'÷eÜ,íÞ.ð¯^ûibGFJö¶¯¢"ã2lƒˆÐŒÁ»ÅˆÓIšÜp*^_Ÿy#U«@éú¾œï*u)¢ý×Þd· ¤ìƒ_–¸ xÊ/¢�vWЪÌB+¶ª»½ç„ Øðª¾{Í®Ö&1‚3Àò¡²"l-j/ÍœW9ÝóòNNlëPþàgO2ù2qz®±0é°®–Ð\IT‰ð%"ð³eJèØéba%)Ù¼7­!¸yEÅoï«þ*7+Vy%´TwÔo;­fµB%g$QöX™/ȉðñƒD4üëuë·‡IôŒ"…l>Ç &Žó¨>î,EÞÀCª@ eëÅÃ×ã¬åßÑÇ}˜ÃSrLtCmÚìqÆ]k Óç †§y1•ƒ“ ý ¶¨Æ‰ŠÇašê~ ô­'ßÁÞÂû]³Ààã|³T5Õ6í]Ý·è¬?kÒ!¹Ø¦ô;]&›³ÝÒ‡=gèË^ò¸¾,n,ªX*Já:–Ó¯^ÿŒŠiq éÎ7Çðw§ñ Àjë;:0óÙ1ËèQXê¦?§ƒæ/dèá¥c܆¡ï|ÄŠ/)>Oýùx…ŽVù²“YðGõ ^Ó-Ž+ùLg+£¢2†zv°Øî PMÍc®m23UŠ¼ŒôÈ>À¤…ÁüAÕJ«,9<â3ÆûFým:r@Ÿ� çp¨Wó¢ÈÓ“¬zÂ$^Åhie3AL»‘5b5:Óú§œ[øÏÞ•Q‚znz•FŸJò0È'%í¦ÓŒs_§éæ÷‡eŽëµSE1¡¸®ô<­VSð$8}QnÙyÌB(æ k¸ütM½ïO½×p§Áâw®‹Á·ÔÂ]‘úqÇúëûžuœ¹åƒ8a`O'ö×â™íÍl1锄I¾õÂÈÞeK•ØnNqPÖá<æ¦}‡æ®1QùŽ;yp-úáIW6{6ü‰ê‘£*+ ùF?ZÕ¤(A ºÂºÞ¤ ‘Š¦·˜oÖ<¥þÂ.*róm±®DüR2ÍÐL0~A“güE«=-2?2ÁDP¼ö Ù Îàeh€uÈ‹"£¿oéËŠ&#¡‹ÐÚÅFsL¸ù½Æ;Žø×[:#¼æA©µæKóì¸ì(ÒßójÓµÉji<‰ß£QsIþP(_3%ÎS¿ªgù‹Ù™ÞFÌ]Ë f”-Pú:w{†WJR=jÕaù„°õgïBÊ±Þ Tn׊õÛc Y9CÃãâ)XèGªŸeãUäya¤bHŸáhM¢Æ,jã3¿~yî:Ÿ‡u™´Œ;µm’Ï4Ñ$¼1 :}ë~;uí-ãK¤èN÷Ýòè4L<8O&)´ɾñÈ;L¾@rå;Lþ®Ž}‹rÎ>O_T°&³•tËr­¢Œ¦åaUð<À§¥ç{À“¸ù”DA±³Š ¬ó@;‘] :‚Å’ÌÏä 1ÐeL£òÏs-6M=¤4P£6esž«NZHæÞ¨I�x.º jÙ¾ÞgÇÉŠúAG9õqÓÛñ³ŠdûB¼™Úd[œóËŽe®›¾GHkmÙzÜ;ö0T©þE´n¤‹p©[žþ/zøz}àUK8ÊS+ÀÁDtV« é=o®æÔzLÒCŠÙ^ð³o:?7oý‡Ï°ªÍ�Á©¬Ð&W2 Œ˜ÉÚð:î¦ð|¾Y¹ né§>œ¦«Ñ2~>…³F“ûg‘!¯ADÊ$ó=d*¦åGŸõÊÎj«y$üoøøvÐ*Œ0à�ü¯kkD!9P‹Ô øà4Í|ý+ 6ÿPŽÊ)€úw=sMãfƃA3@.…r Û-…Q;CÔû˜ÊÜöOý*9aczõÞ‰Õ÷µ5Û{ÚÒìŒÔ¤•ˆ6ɬ’ñÙ~:ÏhE&®ìRUÕV e.µp_XSá™ÜÛS=þ©Ç7š EÐ^sÎÛ,Ýà«y¾ñŒ#¼¤eú Æå7 –Y·¾œí¶>÷TDØ)‰ÇæÍk‚ËV¾^HæÅw}†uªŒæQw½vÆŸ¿ÕvJ²•2>80šwß¼šEÍÚFÏ¿î¸Õ¡¥Ü°ðc‘€WuäÅ�JÇÉÌwËÀ–¬F¡ò¥VZ–ù*š0›/(¹ÞŽ|„¨åi7IŒ„ö›õçètµ²x¥9 `|Ýw;®“ìÅou¬Ú¥¯öN“$[ù2°G²çÆbñ4¡Qä±Û}RÅ(²¾Î‚²µHª¨¨‘H(qVZ¬yË;\ˆ 2©V`ó:‡™wÚÞQƒ¤»xbT´ÀZ¤Cl‡±ÔçAt²W¯–ïáRÒÔ[˜÷Œ§•Ø hEôÁù^«¤îÀð}…—+Nºyç+s†Š×îR›¥©hY3‡Y<­Œ^ä/lœpT¡ÀP§0²9g¡s}y£Ï¿Þ¬ô§f˜U¶âRŠó'-‚jòÁÄbÛv½Evbñ&¬ÞebÃ泥$Š+÷œ¹Ðž?�üÛ©¨,K‹wmm[„+‹3𮿟’å¹×:‰ÑÙàú1Ú[Ö-ÔÍ&ªVãKåcx‡BY¿ ž¶fcyŒÖHpc`ó‡À×ó‹zLd¶Ú#Àc·Yd–ÿîØ·§•.å<AiiÄQÂ/II„)èëɘTíN&--bLbP6—6§ŠWgz°Ÿ=q‚/z¯]?‹°·üCê±™ölwW™¥®E‰nC´å:ÕþjÃ,nÅ|q)@Ú9ðt®Àiï:·äé:éMOÛá³s¸„öp“Œ‡f†þJ#7Íã°*-g:t>MŽå•×‚BÖy¶aÍ®¶1…³ã[JÙLg+ˆ<é°÷x<Nõ„Ü×{|ùd<œ­€ U°9‚Hµw¨x`ÙæÚ‘úÙ4:ÙŸL;JJŒá㱬0%Œˆ’%¡QçØ©Ò@„„ònåˆþV–£Zïà]ò š5áIxæ#Y—Þ¶MsS¡}/ìˆÕÛsÿ�?ÍvÀ^ÄÂ\ aɤäJø÷ªJ<ÿBógI÷—¹ÌN]ŒgÕôÈ©ÚÊNáYßÔt¾Ü+þU¦ç2 s+­¤xTIÔX¹â°hßâ,R?ð¿Q@¿% YÓ™®§ Ê~ôj|çð%ù3ï[V¾ÇYoËOÒ¸°|:a®7MI©ÝÖö»À]hw’FËD‘¾ngþù£uæG' ,&ÃCv­6 ÆfºÓAaÚbmXì†ý#>_ ¥£;ý'R{–›;x”oտ鯖éê.îc×]\¨™'AR{d5Ì‚;sÐûSI´8¹Q¦nà4»œíBºO{Ò|ç½]†7jSP!*ÚÉíð\Y&D†§Cô­"‘oX‚ÏŽè¤]æÏVg7ÞP”EÌ7j\ßJe~ÞÎ$ÕÝ"2ï ¡¿’ÁÍ\Ø› g'—Ý,‘eÄ@ùT»OºO Î0åz=Æî¾þ·ÓJ˜GaPhJmîŸà í‚zH…ITºÁ!»h䵚ŸDu<!"Kl`l_Xä$DÖ6”BôÖEéM_oÌ7záæ-ôÓÙ»ÔÊ|eðƒ77‡3Œ™¾)e2ªIáëLj¾–çúÆ åe‡¯ÎXjný•ÛÞS)¡•xê5<à©Š1Þë}¿¤p·Š¥7ÙÙ«º^Ìò̱‰Þ_·ÓÕv«eìuçóU+z\=1}§±9 cJa’}¨šØÿY91§,&:NQ,ó’`QËü�ÞÈrÙ�úßÒAóA÷:]§íâY(I9Š±ýþîMºóB ‡;¸Au^º=Q¶7,V<þ—„(1®‘Á©�È ƒ²V¦ÄK€zžýžs¦ê1êûqhŸzœÛLY¸Ü  QZÓÖ^'Š)ajË]•ÞJÇ?¼&žODμ6ÊjËoãošØàÔý®å‘‚R'P³»âU³\h€ Oì9óP€:‰VvŒÈî>hÍ|éd¢„m<T}XÁë �>2Nõ@ë$g¯‚òáN¯«d8r´²ùš" òwm$‚kªæíÚHüÜUµÊ!Âœ…€ÒÆSoemXµ(Bqw¾UÊRã¼€ÓhëNÚ-xæ°rñùî[ÿZµËšè¡2Áäcì¼I½µ¸¶Â˜ïþÛWR­à†eгx®ºÛ&†×pÅ›ûIWØa–|tµÊ"²Ò­uF\ô0‘¯ ?ŒSÖrwÓßÕÃÅ“sÅW?·ÃéFÃ*ª¢ÌSÒå ³”¤6n§îŒï™UÕ~)ˆÅ‘ “bÙÓ}%)ÕÇ“ÏÄ�›Åt)½z†¶ÀTËÚ»4-…5Î4ñ¦‹,"ßS-S|:ôHÎçþØxŽËî~ §‹¤]+Ï]Kg£úÐéHd[;q-O¸ÖXÚeך×= CÃÐgÀálO%A³÷ò«yÛ7þ`„”¼Ù¤ƒõÔD­£ÒØþ ÝíÜQòÝ®E°äÀÄ—ß8DÆ¡S-Ç™‹F±í¼Jžq°’® óò#¨òäYÙ¯Aµnô¬ ÑfD«ê``Ýÿk"¤íBßR]é¨CúÊÌä㚸c"HKòîõ¶ÓT„+†CèBÚ6ÖÇÐ5@ñèÌ>,:>§ n¾z¯{áöç 󖥊^“€<S2†®øÏ5,ˆ¡:HúzCú(Öþj1w¢‹îÝ[‚á}é¸ßt ‹Êó@Ť ¸«¢.Üz¶ÚxôÁ¯Ž¢¶ÁºÓÃFQSË Hø#ŸßÊ\+: «Þ'ƒü9@¤Ò*­Z˼šL’ØO,Õl…êcŠøóŒ¬Kê©o²¯"^ùÓ“=‚ò<j.F6\³Vs­#�*)8嵯œb|;§„É÷'ZõHëš2�ë𶫛¾›ÿûfÒ1:±>˜ÙnrpñìÚ Î g<å”íýëÍéŽõ¦>÷µ;/ÍÆ)å᥇c 9¦Cho†3]£ÿXq(p¥õ5wÙõ͈0™^×ïÜ‚ìrŠbÓ?éPá5_îl‡kw‹áy,ˆà‰ÈËÄêÃùiëb™ñ¾­¡A¿°âô=ìxÚÖAq!·rl1s6(\Aqé(2„§/£¸ë]Þùù 4›GÁ¶&Эúz¿S%þ_„cCGl‰Øôzœè÷QZ’¨€a°O*ñÁmÜ7žp2ˆ_áìëšÐî·R´ì—ݱ‹‰Ll²{ØÉÉ·?€ú,Ôe¦p:.ª83Œ¨ØÑŽ#û‰òåXíz‚  nmjøl·•C÷]«*óN… ¯AÄWR8ødKh ît¦ˆïû‹ç�3#±ÕFŠJl¯å6hx0šãy4ÙwÒ|UVÂØ6cZ¿Õ“�\ó=sNÓhº—ÏÑÍj“q.I7’!²Ý¿ ‘•ö–Tõ¿‚ÆÆ¥•2ÂCð9§To¶D*ŠaïpæÊËxW/ÒËã¨pAÉx ó8½Öˆu¦ –ôƌ᩠½Å8*¸§Š _eØÆÇìÅ4¾&V¬èY“œÒŽÑÒïY¤®@@1¸ZHstþ¿â!kþo|IòÔ—¾BBq‹¾{{ÕÁM`¹D³Gÿõ™ý¥îq ¡‹3ÏßF¯¤0ýöÒlÉÍB;r«½Ì2•RöjýÙëk/ÎtþÒMá£vÅðM㬠Coᯠä”7p4)¥ÒèÑ@¸½¸‘<}É7úOǾ㛜Ñ-š§ŒrRP¸®˜]CTeSùÐBNÙŽš¥"5úcšòƒ:õqÝTFf3å˜Ñ4P®øW‘© 0í4óÊ öÁtêÍFGûëв¼óz‚RzÔ)îÏEÔ×Tá‘´ Ì,Ì&¾çÿ­Á:ý…®¸kge&..´g‹¶uœc½ƒb´©ZéŽÈîwWÏ£n–Þt—™Sü®rg«éÑ"jHßØŽÈïÛíúïöBÙŒb¤€J)(åè{Užƒä¤‰xfÝ|›ùܨ֓?'ö¼.‡¯X(fÑÙòÆ,Ø'êä^ŸYõ&EÅ™iy±èìØÑû¤Ÿ{½ýóRiöTŸænã™o”-#7È®*–0;ØûíP:þê– çzþ¨ÿ†Œã0£8Nÿ'N²5óøBÑèâ“уGŽ$4¨@l€À²çͼz; rÞ†ÝR‡RÚ­­¤”u‹QÞyBÖÇÕå78ü´ð§`tÍY_:/i©Û–}âôôKß,ö€$làÐ ,jÿåLöçv¶C¶é<«Ñ´ðÑ5)禒-W‚¸(ÚR³â–QX†YÌêF,½ ŽNº¬k…KŸCÇx3LT{8n…F´ Íyv` ÖhÄ@«ºóçEºâ¦Ðè@ˆÞwž~ß;Ý<ŠøÆð¼ùP!Hn ·š8‰×‰A ´OÔµ^'¦©ûk<D†|ƒúÉÂUeýLŸ=ic gùŠl4®47x&#–i{ŠO{º­È*X»øºàœì:oƒÃ8ó—ÔWoØ“d7¦3d€ËîS´h·×¤KˆöAMÅtK…èa¹ÑeH­½V(mRª”« ±6£ô\{Œÿn¨c_¢1ÅJÌ·×.‘§´Æ:ù(6„:¨êÔßÛRFEšyÖ¢•‘é¢Lo¬¿æ�H¶hÛÊd-q‹Í³nPÖ(e@\Õ‚<™q&^(¼²ÿVÍ<\Ud´Zª ³tPÜ@•TZ%b�ç_RŒñ5¬RKf„’$¹¢°7‡A5hrEÿ{m<¡X\ÊŒ[éø®#â»p�ì†öÙ{ßцEYÊŽ²Ôܳ,‡À?åaì¬Ü#ý,¨W9<?þ-g2nVRÔˆ)žµÄGn‡ “5GŽR™Ãü°¹á{k³ýÛx¢üh[{†œú ƒÇ$”Ó®?dhý€œk…Š ‚…nÏDÞçh ×<œ‘0ÔË‹ßÅ�ÁáGÉùÞwí€"q�ÔÕˆõXÄŠ¬L'Lè#ŠQsáþ»Àyõ Û Òщ¯Æ™Š²÷©Tø\PjŒNÀ³£ÉÁU˜W_Z7ñûè‰ñ±"r¶ˆ[ÉØN Õ[ +ãÞZ–œ_!œ›`¦Äè]JaZê$2jí5ë‘Á̺øºÓ¿Éüi”b�lKíŒàgy„šQn½S8»/Örøʺ­¿“ŽÍÉÊÁÞÙ“=ÇTÊbPm„@Ÿiñ,÷ÐM‚G43 C>xöʾÚ4À5€—ýâ$‘¥vƒQ™[:ëÌã]¾H£÷L²Eðo©Aœ±nˆpïõU¬ ¯…RNú8½îû\ž•i‰ç´«€ÐŽ¸Éú®þï[i gékÍNÃûÐ`Ë.?þ£$r(OcLfâhpù¨+úñ3tëMtVz2:O–½Ø#€JŠÈ¨ QñŠ“Ãoã=ëa¯4(ùТ4*•éËñÄZ†ºþ:G“ Xgé ÌFIÑi.ˆ¨äŒòÁÊpü‰é±½ Ãè «¢Ï*zeQb–|†N%<÷‰ñ‘C%ëÔµ‡Ýi»ô£Ó污à [¼/®9HåÓ¿ÆDó‡ Vä%þByš?à„qÍñ»4¾s,eNéÇþÚþDˆ#oÇ•¼.`ú®’áh/lPCh@UÞ„qƒ^ÈÝ\¿óºôaa0W=˜‹öâÊŠ -³ý•Eâ6θŽÆ¥õàé¼HóܼúÖg¹‘#&Ê%–«'uJ'®³©PXƒÔi|KÒd¥šQÜ£íïßõÊÎC U+\²yÖ{u÷²8ÎVl#ª‡Ë ·ôÉŠS¹ƒCžS ØÈ€’Pœ‹>BÖ‚Ëj‘µœ¨oÐШìÄ7‚¾a}å1Ÿ=Ê uÖŒ€ÖŒ»èKgµ‹<)áH¬Àaœìë¿{Ÿ/‚‡"¯ß:@8ÛÀÇ…Pîòfö|¬Û󇾼L³ =»/W­+Ú:éÂ#tËh‡‰TøÖm­#µ¾þ±ëv¸¦nb|òxîžì™ƒKcÅò\Jøý°=Z˜kÒŽwMz”2Ò´°1m?ÞH”?·¢È]÷æÀö@è71ЋRì«v=AÂmò¤a¶p¾–¹>Ãœ²±BýÜõ*¾ž ÇÆG®3˜ A>v†xdžÍ0SgГ¹4¿<WHœt*âUNÿET]íy÷ð³b(ª±îÁŸ^%½z.¤íä}3ã»ùSÑçèIwý9l–­�ÓB‡r²Ô\ޥܗUy'½¨ÊT¡‘jfʘ-¹Tõþ ÷Çí£ÃûÒÃj–O· ˆ¼øóâi_5hfÒža‡)kö‚sU;µ6q´Ò ³òH Ó@‰j}#²³*½wõ$*âÕ7ŒùÖóâ1Ôöu?;¶†êd ÷èõ[dE>2“\ì[ºóÛ‹Î_C>§®oÍya-OçäEÑ“Üž±±óùH‚²ÖÆ7tÁàèî¶îy'œ¾PK Eç¡êw¢#ÒXÁ§›¦²ËÙóZ§tÄ®ì—G¥DoL~r†MÃÌ7D¢h ÁX ™M0#åî—‰jG£çùþKéÁˆØ.o¸$Av~wÍ^ñVhï¯FL릹TÑ%¼W ‡Œ‚ÁdªxåçÕÆÌ0wáö†8~×ÅË|tÛ ZR…yf7QFevßs§­Û†Ø@‡jù2(³¢¨L-Œ‘Ô«¹ÀÚøå‰|Yúµ!Èy5fñ“—$k+Â<°‰a Ò« KËãþÙˆøíÿþ§Š}£qZ×èþÇ‹BpÒ˜—!*¶hÄá$뚎1e¯>åàóDS))vèc£Kgý'ƳÒ¥j™R ë7žR½*£Iót~Áäóñ»¬è»ÔH®7 ›7ûÓ©—J{'ñ€ J·}8FÎd%töòfçÑþ`ñ˜Gô¼W®< aK{Ê�–ûô$æåÜ4&éŠÕõF©5G�‘rW«¬ ^Y±0#,ò®.´¨›±É‡Å§ˆ©«¿¢$áªi”QÞFw·Sú:ÚŽû­~Ÿ"ç¥×W”½»œxÃõ‚gsºt(Àw zfU®ßmXœç*÷yIáñ&Ae .e綑„^Ú2h_Ó‹19`¯TBnöŒIÿ«émwe£“Sfz:XjÑ»Õ4UÇ “7üï$5W-憑¸Á™|jˆû´éyunº÷l­„xE¼ »æDÉ¡ôÔtõêÅz./ÜÆMÙÓ÷YÓøp¶ór>Z†ãëo^`˜3ùG©ÚüAGx7x‹âÝ$umù…xbì#exÀIulÖÔêP‹i,ÝX»TV'¦h7º&TÍ[”Q(NžG«nب¿$PŒÕ§(ÒKÜõz¹ûr©AµÓתÿu=ãñðuèÌ´¼™ŒèÄ#ðº` åápÃ…‰Xåuq9£§ù¿°œÈä§K\'ï vCR¡wn%3áþ™ÞõÊd‘ñ¦Ó.ÒæjU„i½n™cï) Š¶ dJë¾éÏ—Œ2Lyw†°ÁÕêãñÓ›(Òé$eŸ8ÞåÃ'o„%DÇ¡Ë!}ÿîÛf‚jü¼g¹1HÇ$£[é[~¾gö˜’ÖLQøzÁÈ•vtü[À<ˆéóИeßœÎ}÷ó §¡è_júþGFÊÂMJVÃJ†‹=N#Î>˜±ñª#Zú Žä3úàp8{ESßívfÅï_l>g”­ï.VcK‘2±B+ÇOOsiêv‡ÁfJžíÙ_8 ©DœUƒ«N>*gG,Æ®—NC´ ¼ìG8w’ù5MäuD­º�1É@ ÊÆ ;ˆRÒ?Ý<Öó¡~»vÜÙÈ<‘–RÛÒÊ}�½õ1`ù+ÏFCðñù0«~¯¯:êQjÜX‡‰"oØz©u?îkËÜ9ýJ9?·½oÞê)ѺÌ3ó°…I?¤Aúyv>>NnÒ<ì§ÅOçFîX;2îÂD=yÞ Œð¥{žº»ó³V37Vb.ÌA}¡´ê`àüb Ù ˜™'¶œaÐ3çnÔÏ.™Û è|”Á|M‚bØzî)Æ’LÕu×fì÷—\¢‘¾µH·L°¹1¹e*XßÚu¸‰•S¥5Ä@"fgLÇne‚®¢ÙF‘©ÀpŽÙ¹÷× -@–ûã!Í ã½¨T ³3Ù‹1 ²ÑJdÐóEq¿çˆ¯Øâåæ²C<×N›‚";°¦2‰°ÃÔ-| àÿ¨ÅYž7-b@Q?­/^ˆ²w,XÅÌ¿ÂL‰Š5Û¶ ¶“Ûî‚á¹·é” °ïþÙ^)w¿ÿÁåzþ³d%ŽVÁ0äAø©%–®ýG»Mv,”NÅ"xÿ“Ž„Ef…=èYì[pµjçÿ$"C7ÞN=%Ì/+ìVi˜š[Tò˜ˆËç¥öq˜–Íy’#üñå8%õ\x?íΣnòlÕØÒßmO4¡·Âi‘ù´¼u½Y%®Æç©óƒ¬k*+°'¢çfð›rÞ™A:ÒÀ 1±¶²1sc»i ßg‡UáKÚSŒ:]¿®nß ¾/«¿@^¸vþ™¹? ¢`T¶ÈÓ†‘ñ)h¾¹§mù”4˜*㎻Ï8¦ VN{7£O~§ÙT{~~“üÊוKµAe£[{…ƒKí-M±²w4k Coœ‘!È'z6nò/ªà¨¤{'Ò¨}ô=ãÐ¥gó²H^œfYî„6 –á‰Þ5‘*qø!qä¦aè¤w§ öÜÚü¾“âqk¼c%>Çß¾­. Ëyj&JOûk/ÿ€IŸ¬:Þ 3]»N°´§/žÒ^ŸL:3{aÙ7òYpts>¾Í§ÅxHrÀ“¬÷æk’…¾Ê¤G›Š’ëÅ£ŸP9ºq`S&‹ŽË3ìJù¶5t³Ú!¦e•ç`0áÇì™'Í*h9Ø¥ûnÂÇÆb¸@ðØy¼?æ2ر3æ†S}}íXK"¦…Ö♌:qâ¶A 8»)�ëQ\v´GJ ?ˆ§ö¶Iæw +éf;Ŭ£oØtÃpÃDó~jfåZT©(=Û´ÿ×y™CþBv,*MÆsoƒÇCE26¤ÒÈ©lÉé3ÇÆ£Jt+ü`|TÖ/+ÖF®ºN!÷¬ zž:9áüU\Ž8î5çaWcB#(YC†Ì¼?®Xê/¬LÎ>ŸËÉÆá*a©Ü …ZŽ_µvßMV‘u[ {!aõŒ¡Ê|íà®·E;×)Ïè=ó±¦,‰–äShx^º†ïUÕ`]/c 忱?õ3‹v½œuEd©¯ô]£±s-!t�—R‡YФ÷Ø\ExÍ+PEê�~Ÿ* +O´'æ ›qèD‘BDØŸ©$©7±”1|Z5®t–z5c>á,Noó[ˆïiñä•Û„ž`»ØÂÚ±,ˆ=eâå챦9f¡Ï²€ÔñºÙËÎ3ûÝ@ë1 NJ™IÛ·ÕSÌÅ„Uz·Æ3°�¥tikýÊUÓáu<i¹']cÇãÈ<w$¦Îvô÷~*¾*Ït£6oðØ;¯\` T-žŠÝz¾øƒ;A”¾Ñ6øp[ºÇ_' K‰$ýÿªÁH¡x‡tâùNËSžÃŸË�˜Ù´Z¤¾ÃCï ^%x ÉàŽÿUÍ×g(·Øƒ¨¨¬ìf÷õk_È´“Å\õ•ÈÌšžÞ@_·²'ºÌ›Ó86Ž÷DËýËǔȶµ(a1n½oL%)CTCÛ3wý•2iü¦ï÷kè·ã@”üåÔO3Š£u‹†‰P? R £@¾ Òmë5@pÍ.º@»4N€õc‹É@̹htîœ÷gÏ·‹Ý­ûÎ!v‡3H¨5n/„ÍÛµÂâ»AªTYe=,HÏÞ†ùø© n‰rÅœ\B?ëèØZ sOçy/ê:ìàâp-�$‰|Ôét<ˇ–†ÜÙ»cRkO}³/‚x§–iÎÚFÝÇOûè™øLâ‰N րńzÕkH4¾q]xQE¨ô:cÜBÙõc+˜‰ÕkKOÈOØL¾—$|XÜ35t»cà ‰M4›{ü]Ur)—I7ÜÈRìàÌÏõæÅ#à„•iJvT;mæ$g΄d–$¯/±~¹ß²žm6rÓ´:l¦ ¶´è=ÅZkÀÖœ:ïj:4M¯Â:7¸#OiEõæ:f›H·�i÷jƪ Z×áÈõÉs5°Üå!ënžèlÍνGa£§rµsÿ¦3pœ$Ö-7RÀ°ÒÚb€ªfxÔ-]í´Ë‚ÅØüNYw·%BÞPøŽ,®m<ŽT" WnX¾Y}ó_!�œj$ÂIÉ‚¨ÕŠ4VRJ§›žÓñ«¾<`¢(ГgÔlK{ªXpJOhìyÚ™íõ÷­ÞUG ²Ä¨A@Ø0;U(*2«"†Iƒü£ó©üí¡ŒºW$„|^8ý�¿µ× ]GÓßÉ_D“²…¯n{xØC^; È÷%gÙâÄÚ¯XÏ,U› ­Ú‰Ôüg¼7éb^»–yë Xâ9²ã·¦Èr^­ í…¾[$‚Ï·f=ìêkœ®žè£¯'Šòãhͯ8#'T ɦÞ5P:Ló>«‘BîãÎ*ͤZaP-¾/žxÔ‰·ŠDä®þæÄê5üïƒÎž§HRJÊ—PjÓk'„]®N=ÓÆ$Ëá‡|´vŸà{£•Ý9(1ºIÖÃ�5܈~?Þƒ?ÿ þK¡±scoþ­û©ô±C—$A²«=MÐãéÒLõUa¸¿`K|#¥ù eR%å÷µ×©šå¹ÍÒp–¶†÷{‹¾íçï«fO¹b›^xÓ¿ÞChiÍ0Ç@(W ÏUö?Èv¥3™n1:‘e/Gf˜6vIIÅ™b;X¦Ž’IúÐ&Aä0 Œ›·HH!ß_‡ÁÜ.mÝÿeeæd#˜„¾¡ƒ!³Zý¨r@ØÏs”Náˆzt“ê2H®ª ö ܽìýiF)òË-„¢Xߎ”é¹eha5²¼=ÀïóàÕü©U¼ªÀ•Ê“dy‡Íaβñ¹‘æÞ³×g[§ š¤rK;¢c&Z—Lk ÈÐÓçœOý¡S·eBZ8ß•_™òÚ=,éwf3“áM òð?ßç¾ea„ª© ±Q[qÌ%'œ¸Áa’¶¤ùªO¿sœx.mâºq¥`õÚ5Ë3õìb”ú…É’ ›Ïü“«²XkÍŒØ<h‘±.ÀJ;ÏpÌÅÝ5Ï|ôWHŸØ¡™¤ÉsÊo«=£ò›cù)÷7Š"Ç àÁà¦Öo£ ’„.üÁªŒGÇßÄÐK®qoÞ>0wXqèÄ�¦£À—5:y¾ŽçâCíÁ‹V®MÏ¥|'« Y¤j’FK+î<Ò"B磻Δ&âk.‘ûY¥& }QBÌ׸­<ÌžYrkçD&Ëý©«[¥±ÓHpFÒûùêqR线h°hN‹í±›sññ''±§’‹ë5dTßg¹ãÜ¥}7³á²óWôó¦Ô ìš„,W1YlCÂPùƒ?^—ªÈÜ”‹GCvŸØãzBÝj;"¿7½Æ Ã!÷^MVîò"S·¸†ÂoÅQ\PeY>—¨ÏFõ@Mûñ¼k?Ï5ûRC± óè¿ÄkŠÂ¹-”ôJêþÈŒ `cu•É O}_^>Qœù] ¼j¿D꯭æ l»zåpÅ­»Î¿æs\«³3Ï“B®éùü©}ꈥæÖCÚ¾â™^TVBúß›†¾zÖìÍÊÇ:A©ú_q“("Òµ³dó€â’$U¸–7CÄHL8-Ï©½~tÖàåɸô{)Ö<wòvLg›kú“&_¥äÖJ·ë/vB‚õ}ùYÜj¥æ=ç¦õFP¬?ÉO#ñÓˆlU>J>« N«ŠÖ:~ð–^4¢ ç»ì*öÍ/9Ûgææ8ÙY5ßèwÊÖ‘î›Êß5‹Ì÷Ÿ€ƒgéÃÙW‰íj6Át+/5ÿ/¦³ÒdˆUY JàK ³J~Ì7!@€Ÿ&¸þ ƒáǵ1u ñúÔîlçž¹ÒwÔ,ë‡noç9Ï»È3´ñ¢/mŸµ‡ÿ5•ê2~ps:ßÏÃaTçž—,ÖŠÜ·¤gˆmñïÓé6(]…” ÖœdH ôÌk(‰W"[xhMgõÑŒ™sUmV-mC2‚‘ÿ.3SŠÅ—0sÃ=”Î�(Z ¼‘Ò°ôŽ°ì MpÝtÏÛ%ö|Ú°4Ù0³_YŒg™Ø^†Ÿ¥„ÂÊõY»âdpРÔvÓÙyóéèÿË{¨c˜„3œÉ¿š-^ÔSÎJÝnê %óßR;¯.A…´Ÿz,RÖ¸w%´Èá?f J½µÕZ‹j™SšéŒ~ˆü{KTÍ"ßI4†á<¥^&›Ãà²>¡-Ùÿ:¤Åsä~9§™o+ãD»=[tp‰"uÓ×gåégwe\š¾>º‰<‘`9<[X„Û5æ€1¯Fè Æ®ð ÏÀ6€C^ßÚó$=tÿVZ–] Eq¾XßF°ž%ʳm'FFÞŒÎÂkI÷ 7Âω8yãèžî¯‹Èhüß0qóýܸ¾#ÕZ»(Å|7 â~ð¦¶�ðú9o'ÿ~7ؽ9Å^ª šG¯ ÄŒKî#ºf¥•yˆÜw<I¦‡‘q¹kìmêè`e¶5Žšµ÷8-ßÁ^>b¦‘_ ú¬i‰DïŸÞ#Üw§þ ÀË B&N`Z$îbòç„Ö´f>ë÷žMáöЉ<ÄA± nnÏðžÖ6ŒÚ`Þ¾²"dfÜãì•({…¦"a�¤ƒ•Íøê÷eVF…ñ]fú‚I£’´èl"œƒíY›EhVE}|‰ùpœyâÍ9-H¸èÄ™7œÉ ÂxýjC— r“þ¼ï¯t.¤æügdAjö\œãéááv{üú;ŸÂZ™†Â¤fÐúÆn¸Ò=›:ñHü‰Li™†k@ HÈ©å¢ÞñÁã˜ý37Ɔûô  Z Úx)0Ä__ž¯’"˜Ä6Ú{©þÜ…5”ñIxUè›-R\øXJ³…xî® Í‘Æ1æH‡ðCë7½­5ìù¥I™¸¬+‡\>íÜ¡7`vñÔtK4€½¬„á“sŽaÙ3'Ã'Š<NXd(íÇ®òŒû ‚þ–þŠZù²˜õq‡ðÀ3pSW¡çÒiòäW°Òvíè•£U‡1H­Õç«È‡Ì)tJië‚J$kæ(hÎ9í*ú ¾èˆ>™\?(g’ÜqibD:f{í=ß‹1¬{@Ö/”ñ'¥Ð²Z¼¹tÐ?{¯)fe$<Ó‹ÿ'}tÞ!Ž±ÞDD³JÏÒ-úªõ”$â¿oyÄÖ$õÚzø%MÌÔ)‚ˆI”à÷µ‡4Et¡,«3nT¯üâPrK‹q´åYïgÖlN-:Tf¾»‡¸­]9eÁ4ý͈7 =?Ë$78hÛI1‘ïèæ’Š9¡°—›W±™Î*\q_SE:ÎzêìÞ¯Ê;qpþòÛÌãD}y¦ÏE‰‹Ê1“Ò�ˆZGñbÞ>£h>ôš½móÉ4†HZkTµ?;ã äAÚ²Œq`[X3Çž½ú” Ôô@Gpï§ÉÏÞøëô5«~õW"YÝͧ?ð*y1”圓âBÔÛ&AÆn8Ëf{kù=ûšJVq»¶W˜ñ˘Â:ÙypË(ŸºéýÖÜY‘®~qÐûq]¤:ª »~´næ±L”OÃ¥“9³Œ³÷/`¿©ƒ† ºï‚2xrQ„­P 1ã?SJ%ö'H@b»» òÏ»eì[O‚hSªùò4‘U²§M×øõÚMSOÇ„›?›? Ãvh£eU1kǧèqài©û™þä¶ð,ŠÌÕ"Ûb½Œw¥ÃŠâ¤Ò4q|,‡+MB*”ì›)ù3ŽŒöóæ”Iýe–Ðç¹x‹èƒ%­ݼ9õÚBð.eœQäX¬à>ty¶Š„ÊóÀƒBê zU3øá•–ǨÓ'ÙPûmj¡-É‚!XG?“8m³‘—5=6ã˜}ß\kuÃÉã/Ý8¢x%7AáøkמŭhÑ7hÁ,ÝËÖÚ¦·cÖÂ`ÎCÏ�Õ •Œ—ÿ¾QbéÛ ݂ߤ&x¨@Y©ðÁÕ£é‡ ˆL“§j0 Ò¯ÑSgضÞxåI5èªB§É!ƒ½‚òÏ$(·‹²òP8·Õ)ù`µšéd!æè¹ê‹¿p4I7BÆc:ëmëã|òT‰éà)y'}jZž3¯#ø‹èMqNO‡,ø{´¨ÜMyú?xiJ¬Ü€y‡LõËõßx*‰…j,`›ºoŒ~E 7.|-*:Af@¬>òU(rý5Q2¶®™å ƒfHJ³”$ Ꙣ¶T%:O;aÆuü§¹ŠíÍûº=O·|íxÕ,ˆÊ@Ïþó_ṟ²C~Á>tu™ê½ü¡¹WìP”2'�åSÝÿÆ^=É<Œ+U%¶IsvÊ5|vkà u·P½oPn™'nÊ^œMWÍ»™&‰NƒÞvÝÔ¶‡ ¡¨Õ߉+_÷‡ñºa·vG#DØ–ˆ6 ¾ Ï{QÈ(‹lÝð'*¬¬GA¨h@Z¦$Û|7Žs=Q.£þ‚úºÜ'¦©)Øs_Çì"¹¹¼ÍWŠ Ý)=gVª¹«àp»éP[—Q“*?Θ#ú…'mçeˆƒt²*Êhéˆ ¡hø¹÷g_fŒ†íèá<˜ÔyŠwï•ÜbAà*fáö²¾:ÆuÛõãþ äß%Û#ß6‚QÓÌ X¹‘ïÚ¢zâði2]L¤Õ†çRÐ÷]z|©ƒ×æŠb1)¦”ËõoÑ’~¥Ø>0‚HÚñß “U«³06í�¹¤³g¨e³WZßßßäËFChÚÑAîß=x&Cù(É[†ÀiïÏÃN ð$4~òÍ[OO¿PŒG9‰Qt¦…%ÅØr舂Á3ØצDº¯/ ΈC¼]B°³ «[w0¥ ˆèzÌ\àp奞`Òr03ÖÙ@öŸü/žÀ˜À¯XRÊq*T‰n5-Ï'eô‘­˜ìçr÷}ý£?¯ÒIçFy\d­ö"£"‚™Ý_º füï oG%—¤C´«è„£†*8õ´F¯ovÞz-gg‹6Ù¼iðj0œ;½´ýÚº â±ön=ÕˆÒ«´Ì=Zºß4­ÊÂw«än.õ‹Ž…L­Ç³–·U¸]ÿ½—;•c#õוñž<*ÚŒÜ퇎ÿü¥>Jf/n!Ô‘6ÙâPlû*¨öVÆ |î Ó¸¿Ê?!!EXøÎttÀÔ=e¥µ…¨6\êÒÿõˆ“Ï®k¬Ñ¾©¹·ªWwI–UhJ•¦´§Â'½Zð0˜U´BoöͱÝlõ[Q¥4æ¹ÎhÏeÄ¥ŠÊu9Ô$Zí dAD)WÛÕ4dUÔ@rFëY×Õ\ŠÏ·BW7o#ØI•žÒmÄÝiÆ—J1–ì r¨‘)êÞÜÖÓàs¢X)r Ü^á+h¿3ç*³]eÍŸbÒíTH•Ev¢ôçuÖU™º!=›Øµû2ß·jb×=t›$0qÁ0)«ŠHù"%ßKm'(6Ñë‚a[qµV¡± F»¦³mÇ…O‹ô ŒåñQËdôµ/åÄôk†~ͧíl&pŸ»]L²¤,=o> xã ÉÀ¥êýýò0¦’Ö_jÊê—Ú“ðüY²ÐKøñaÌR?Êè v+œ?{ g¥:•ðgC];[ã·ÕófWþmw¶œv,]?Ú~=Æ væ^ª6·ç/ôÐqE©·ÀUá˜Æ£Ï‚ªþ²®¿”5ÀK™-BŠ’ þ–îÊZÄ« ” ãƒÒzÀíƒß³‡íNŒèS9ëMŠ(óŸ@ž_è¯}÷ĶoEí!{Awo~hqõD…8J¼#…›#Ówº«Ç•­Äõ˜:› з]‹|-ÅX€˜•a¯rÞe.Aoû-Úì¥|z‡‚æ‡>}ûNÐ\ô—AFË)¶ä·fºÎ;bì;_læX¿‚Òˆ7)ê$_ÿš”™Ã*Ê`Ûm™ÿû–ûÍ—( “À¿¹>µ¾>–I+Û¡€Z;Êq˽ÂOõ×ùÆ¿4U0bsÝœé^Z°²+<-¬Œ©S‘ÖHpzZLHÉðóÅr(y0JS‡Ú Rî0°øÃ܈wÍK“9C‚³g$¨K»%hýâ­çr•› zêiëÍ�ß^”1¶3rêY÷býòðQ$Ú 7ºiˆ#Û‡Ía$rµ]Åò˜7/NÓÒGˆçL–cä.½¢YSt8?˜cÄ{‚Ó7*²ƒ®i.2¡£B³êóÛî¦ê«wÎ!P<…@&ìé¸ú´*»øÓr¶_H|zÅ…ä…¢g4=¡{*E<i:owBU{xåò HÕ˜V)âºÐ¼5MÁÒïÚÚzhÏãáKòNeÙ°÷ÕÍp?RÂMšÉWØH5´ÚVåi,s–OaÉ£Ai}Hq¾¤BÇJ¨¬Î‚ä]ÙX,J,N\¬‰C7FþbÓVFA+“~ó£úÙ¶|ïÉ#•†_:Ðý,Œ)7gsêùz‚ÆãK=«’ØÀ(¬Uk~Võ®¨c@KaJmÇ-êØDëÜSÎÒË»3»RE(uÎv4·Öõ:ÁÌc’Œ_ þM=õÒԳͮkÙTû>¡IÔ©[<upzoéÞ—ÃÞÇòÂÿø0šÐ?ž†e¤pAå;£UÍ,cSöïÏt_2‹¹…lÒTÿ±�†û¶Ó/ŽRO­ŸÑÏÓ® ²O¥ìO•‡,¡!¸{îVñhûϘúÅš|ͦmË :žÐ7/„Âbþó­™Z\_TòSŠ®@BF{eAy¶½•˜K«ÛÓ÷v¤i®+˜QU–ˆºQˆ«–ïû‚±öÚd;*SרäÑõõgA>õžÕfÊ(ßO{+@»Â0Fþæ¹;ÅÒ(=PØÀß[ÉÆ‹À±xû½ñ#4qjØ%k±ógîr‘Ÿ’2Øq>¡mÝÛ»Åög˜j;ÿÛµØmšÞh\¶8nl3†Uý¥…hmUT„êÍÊα‡||iJ-QŠ¿4…îi±¾â!Æ“t¬Ì*<Ü]Þ::gpü½/gî±Û¹Ú<Œ ´ÚzícÁpˆ3zÞ: 7€a#Ãÿ³N†ÕÊ£¤4‡^b8æf̶[“fBA›%ÆÇ‘Ðfÿ·ÂŒþ¹#§ìÁ”Š‡Áfù¥qŽT¥Ö-ƒ• ‡F}QôuV¶ ÍŒ‚M¦ó±‡¥Át|ŸÈ$¹+€˜¿x™« m›/ <ÿ çë0×"ñ·~½™èT $ä.»îA1hq……'J=}Ñù"J ™7Z§pv@QeGOɨ…«2ú™"qÖ*¢Õ!%¢j­‡)tkÉýVæ歯įˆôa(h‡_<]b¾1Š±Y aÒ1,üMýv·p Ù¢êF¼l‰¥Ÿ"c5Âfã’cô„^¿ëD©‘îáÐF_Ç*¬‰TB7â=_ÚàIO7×x`4ÌFöâq>•nøœ`’×ì« ê·Î'¤éŽ׊¼°üû«çIQú@Jî)BEƒfÞf&…’çßÚs)ÃUјªDʇ^Õ?Ê}­‹Ð¦ÌÛÙ¢‹Ù¢ê’{ÀýMsõ+ž–Œq™gžþ8m÷f†–اU¥¥Äñ¶•exÝÙ Ž®š–ŠFÃ8Ñ’úœ1žÖ"\så¡ïjŠ´”¦ÚAá½8ò ¿À¥ô~di%˜õ]+9ùL#HëóªXˆóByì¿VoôÕén¹¹NáÖYŽ¨Nû=ŠzïˆOï°ŽT‰'Àjè.ÿÌç±›þ9ÖV.ÿyЇ"CHçG¨CÆB€laB1äÈDðÑÕƒmŸ‡®Ö�•Âô'µVh:ôlÁ³8Nü.1í‹ýÕ1¬L'Ï|Ñ!”§DôÏùx÷ÞØvÜp¡ªØq¹1NôùŸ_rƒøÑ÷W³Æn¸È_mדqæãQõz]¥‘ÏK1<¤¬ ª÷>P°NV„ƒÖ*ý×?6Nìșϼ8Ik9Ó†l¼ÀyM±#¿Á˜à-Yzhë±£¦Û{ØdH(èË›dwsþbGãçà›<w’\L.Þ¡lÊwÉaDÌæ�ª÷[ËL¶®©leâ­“¼s�ÉC¿Cv,xÛÆ»œ³�Na{+µý‡:qêT³Jæ¢\¨®•©Z³)�¡Æ¼ð Ÿs.,ãúÝO•4¦\\´!Ëñêµ)AìžnܨÞ3Ъ¿BÏL‘¡b0÷¾wÒlêy@eæ<ß÷;|—ÃDèºHù>ÕP¦ ÕÐ;^@€F•ç$P¢òÞQµ“SPêÚè¶~ž¡êÄóÑW½µbo¿r£Rliý¯ÎŒRÏ#ÓÔ“:kX8â%!¶2öš¶Pâ‡q8Œµy•0ÞäOwuè /Z…§Þˆ¥@梩a󯛃ð…­™v" û\9UŒžÁ5¬1©kرè>•˜úUw ‹Ï˜Ë¢–Rfc`#bý$ÍÖ<:6p:õM5‚y¬9ó±™a/üÈõì }Ç H½cH Fƒ‚ Ïm±PT€[*3ÖçUßýU&/}é]ú tÚÇÚÉÍÏWzZÿ‘s›íÿ'ƒÂÔS dEβ-Y{UM ÷ ´/?0uÿæu½B!Íï:·´Zâ dM[“·×MÃÊ‹§‡R3ü¸.øSï­,Ë•‰Y*4ÞbT‹¾vlí$‚<þîCoš{pZÅO;úÔô«v´Ú85(½$;”ÖÉ/Å+’ÊÓ|(™[RAxvÆ™tX­Z««2Ó_)dEµR¸M‚…WÜÛÁ ŽaQ•\ØOÀx•Ñ³„+s�®™F!{XŠæ»m&æ¢ùð®¡ysžþÕzÖøÑ#ÙˆL·sêýA"Jœ‡�P¦#eWåîÓœõT6ÈÉéÿ¢ÜhÙ±$0Z@-ÕÌ'³ô×"äÈÓÑÞ°Ãæ·´ æNÃx(óD1¿Ø¹L+¬-Åxb±ÿº”Ô‰„Œ‡Pöïëþ°­¿¾õYŒÒ(óúG´§}”Çä6¿Í-3ôpó2Q¥†Ñ«ÝÖ»r{ RúÂÆPÐA®]™™ƒqÃà%k†¨ý¡7#Ü‘²¥îj™kÃÞÒww‹*:rè«[ëzèOp#4þîY‘¯BÁ^ÝÏ5âÒZu"[¤ÓgH2Új–›–!¸çNY›êÐÓ›W×^ü|`/vÿsµqfI€³ ”¡£”ó`Â4^ðøO1rb&V.ò0ÂypçɃMD�´º½Ü$´=§Žó"dø �yv_ža³Ç¤_ª˜'òþ‘'[]pÖØÅU}YÛ¯L™$æI€f ðça1¼ wùÌ™¹ô�Ò2J÷½™¾!gD®µt¾Äùÿ6®¼dLô¾k •YÇzMÝW½CÆλ!­NJÇ  ÆÿóAn“ÚÊԺȫ¾ö„µ6':rUÙÍqKÑÿ™óñÛsÿ0æ™ï˜GëeÕç—6Êðù'(¶(HìÕ6™/Ë“1ª–ÛèT�¸Ôç–÷Ù8“,¢²n§Ú;'ÊÇÙ4ÓSFþËÄ¢á4ŽlójÂáCñŒÌ{Ü¢Îk­êëu±—nuöÑqû·”×2vQ‘ë9ªv))l\TäaéàIöíÐëÀǃ+ͽ&=;’Ã. RÛa‰À )0Y>ÏL–aH])(–'‰C6³šV3Aù©¥o†ºÕŽÃ|˜Úóõ>^êaÚXÓbU¿[W86ì/íygžÝë«g¥$´#FRT1ζJ0O+ø×kÀ§$Zùf‚¸ÚÑ lGo¾N‹ñŠÓ’ûüyænÜÿKÂ[ì (òPk×gqÔ{«¬sO>Y»éʈûT‚¾÷´ÓÝå}œ¤Nö@½¿þÜsën¨a0Q¥V_üxëq–”Ø&AbE){l7½4ÉÝ…¢KL¾6×L<„‹¸ÚnNYP6:6/�ø9âæX诌c˜ëo9Þ ¦4=“¶£â%}·ísˆ¨rÚXs¹÷Be-š§zaQîp.F’=Ð’ûO‘áàðìfYCÝ£MÌ�<{A÷gàNî`Qñ¦~˜Žé—´êk_°:ÃÎì$Öt’Àñ£wÏåŽ QËÌÀný¡4nÖ¦_©UÆv:@ ]Ï ó³Žv(3øú½ôAKK*v}«P´? Bx ºß(…¯»\º®}ô£;`KŒÄ!M”¾©7:½u7#lŽVßs &7ýÖ]O[ÌLÅpò« Ÿ Õ«Ëét~è…Pz6_ìB¸\ÈÝ{re˜8¤MHqë+ýŠ9÷OÁnæÌÌH±™óFMIJŠkT®NÌmùýV¶‚kbSN¯J‚ªÑ'M_ÁQéiD‹½wâE€Ë2ó•YÝ”Îþ¢õrr‘¼GºáX?·<¢rëh•Ž}DûÎScºvu4¡Ô4¿~¶‹ªrÅÈLƒÐíAûÀQÒr>‚È û•ª|Øöüd2RF«ñHØyN…Фj²!S�š:ÃCëåtÞL§/Œ#$i²îWb=7ªìÆxƒnöRþ×Å+…]HsîéëÚ(g Rðîx°ª3ûÍé‰)ãôîoáBη*4Óˆ.á¦<•¼SÄ€‰eO3…Oí±¼6ÆÃÄ'n…IpÁdÿÜ(ÿ Ìï[$ß¾võ31Õ* ý™�›!¸¹h®ìµ°°ªTÔ™0^A̶9ý9LëbåÕ¦—­†„#@ÁŠÕN. U€<Åpº´Ói�æ‚&±ó>ªéHÇhÜX§œTý¯Í¶6ó\ªñŒ„ ùÔ(-.nÛåcn¹Õ9üܨ/º€ÖÜ£Ç27ý¦W•|œù^nÐË ¨­E#:-ƒ§gdÜ<ŽP'‚öTƒRP÷<É�'›r{ái?øÙÔµ€kÙ%Ûè <þ¡çr(2q%c®ã¯†×G*é÷¬ËÙðÚ:*ªÌ“¦b¦J„mçX¯xb3ë€0†ÖZs¥ãÔÎ&9ý¦båt!€ä>sïVVÍ+»íþx.{ž¾¶wùs¯9 ³öüAIAÔh–ˆ´ë®ÞLvy¬7è¯s/óùOø{äšZ·ÎÄM#ÙFâ*æµlë'œÒÅê6<–¨uÆ”•éœ2Dù²xίݮ?È!$à÷Ðdcì{F1 ÁÙSzšÎC×;uÍWÅ­ÄfÄC ˆ³`œð®FŠxÌía'\O§n"&ˆRx]ýá]­Òzë°Ì™…‰ë)Ù _]¦]Ü1YõÔ¶uËd:tƒéÚq[æÞÕ%o,ìF*z’Zƒ¢®h;ówla–óÌ»DO#óÊBJÚ!nh<§Ê[é ®ßê³QÓûžO·b ÜL†ŒwÙ(º'‹×ž·í„I)—ß¿ÖµÝUX{¬| ³Â"D!Òn†ÊTLµÊô‚†<Ø7ö¾’Pú¡°4g *9(qRL­{Oé©Éí øZgÜ ßš–îQü~ñܱ°V°„�8½g^7¬êý`õ8—øÊÌÒŒ¼¼:À±Ðn­âò³_–—ϼ‘%óq§=ÕÌs¯3†ÕÕSgŒGŒŸ‘û nĶ²4Ë›S 5çà•þ«™PŠ,íã«áÇ×:ÿæý‹7qáŸ1hÚ‹GVê†éº·]{JyýÊwðvti1¢‘›ažщ²¨\ÏS‘Y0÷ÿ}«ÌÁ\:¨l2ÕÝ›ó¨/ÏáQbPs°ŽRi©~.®ÀáIqc4‚_觮DÓÍ#š³åoUŒé¸ÓátTþ§ÑLâk…C žòz¸­«³>�UªÜŽ0�=|�–Ê ÄnÐ+J}‚®dgVQAœc|a½G,Ò¹Û.¢íȤq‰|¬•èçuÚÙ«¹Yæ 6°– \!ÏcMñ� ´¹>•¾ÍrGÙñk¤»Ýn¡j`£ 02ýYh³™¸öÄÞY1sO˜-Ÿ0G˜”;r›'Ñ]ÉÔ¯a9ò"óL”(¯;"ƒŽ¬~¢æ¾v‡Y½zÑœE´GW d©¼Ë‚hÍ@clã|š+4·½‘V~däjQp ÙÝ9á®–¸l†²UôÇ^ï‹Ûb^µ N”[ŒDœ¯÷*Ùö£‡kêåL,ÙÜà ÃRòÜÔMðá±YÓ‹+;RÕp”ÛXyb>]6š’§Ì ©?ôk«ïôÏþÓÖš076é»sœÕ~ïÙÁâL ØçÜäxùúˆÒ;Ġż)ièymQˆ¥6§ßð÷½û¼ðKiœ'Z NP³ä¢G¾¡%Œ}×{Ž¸<÷AÇHOãàQ¨ ˆ;j!/�•ïÞèÞ`ãݽ½—²îh–ŠPÅÞ7qÖ`e’M¶§Ý¶È³:7a¸™”ÓÖõ„é8CצsÇði…ð?×üñ¬bq‚bž‰Ë`ŽºíOpYïœëwP¨Ô–ô¡éÀVoçÃ1³˜Wöëxcpö‡Ý ñ´û#¨”ÒâÐ_Ý}AU{(¬x88<é…²é½}}ô©Q怣bÌ4LI|^uJ@Ûº½Z«¡o çâ2u�Ïæ™›#ú$ÿzšI¬õᮿÌ%Í ƒ ÍкÚZ:cNÆÅJìW@ë$ñ‡­!wÓw߇™ì{p¸ÇÖÝ7—¾ 'TÅ=±"LÑX»8t`­˜l•*)¶íÅ3[ðÐd°¯kA_Óùµ#¤\XÚ}3‡×Ú^Ï\3ãÕ¦Žòà0¢s²÷05f]˜Ô£ælXG®¹iÖ5:Jmç‹N—¬ù׌ëÇÓ¬°<–²âôcŠ­óÏظ ½˜›º$6M<úv„6çæÌ4@#LRÓN‹€£Â‰žý¼½0Ó ãXÈ “Í‚=`¹™´OÑÖ©»Þ2ÔJ±bÌ>"­2y‡ Ú/bù¡V}õ6´ à>-q-ÂÙ{î°ûÿ\®ú?§­QgkMQ:ª èUù“ó ú#f+Ù6P ÙwG¶!“jÔÖ±‡•Œ§ÈýL;²<zBWýÓSìÛž¾¸úÑ,*R÷E×ãªsx£«5 û„ÔTƒ[ôRüé ºZ¿a/}ú0ËfýŽ%L|§9*·Æì^¬Õ\”z²±rìÏhS__»;©ë&\s³§Ì2šÏ¦vHxˆ4 [q¿âü0Mt�¬_V©•U1 3;Ÿ ýæÒ6Êééó´mýØSø™½ðš¬²,¨T×­-§ñP{N@Í邇ˆ�ý”N•ε“Ùp ú¶ïÖ!W@†€¢Ì´ñuxâ”n%ŠÄ~! :Zâ%Ò¢1Ý­•ÿ汯7ã•X…7v«ME7`¶�L†ö¢ú: NIí(̈ÙûüŠãhuCÿ;R~¿­½4œÖØàƒÜnä`¾—…‰¢•t„s3ÏÓ¸„„ü(Ž|0¢NZâòzKÚ‰cqÁ¼æý˜‰Ýžëó1XQ˜ûÎ5ÙùõÐ/ìCqOó?<GêƒépR褆¨ßK}.”«íH5Ú´cØÛÙaXp²ò9Ã.‰/¾t¥hλ�+¥ãuaœCü8΂¨VÏM´ÇÝ‚ƒ:õþ,)÷( œUC %oF…i˜™eŠo4ÌžŽÊž½2¯¯š ”a¸®¹;ÔgEŒBFC"çmã€�±o_�f§Uæu�éw_Ð%´90*Àœ¯.Þ³ËÉ‚À¿4t>Îm&ì >FâõF¥¢ek›ž§DiÒy}ó(‰¯Š¯†kGT( PHÊ?ýãDF}æ?Æú9 ûcõrÛâZ·¥!àþZ–}¥Fù˜ku r]}ÔA"%¤7oŸ´Sð« …: q:í':Ç­ýÛy8Pêüß·´darôP1?ðnÙ#ùHÄ‘×r¿':B‹/˜ùÄ4Ó@Ýfæÿë늈aϘÂøÌï!si݈¾ÂÕǧM‡‘yT£ø²L'†GÝ7Á“(ö]~Ѫ’eWÒgë8Cþþ‡(–×xŸå±Ãp#t aÑ׺ƒ™}à-c¤k–ål½—�0Õ­S—]‘ /éªX$±üÓú1ŒÙÿ˜µÆ�7ìŽ –§¾U7Üá«È –‡­øÅIv‚ÿéôq(±^é½Gÿ) oí0vĹÖP.öÜ" ŒI’Ô�Ó9©*cºtÙ Q•>SÊõK”½¢—€B›îJg¬"JÓÇ]ýÃjéÿЯéî¤Móð¶:ª{D%m>æ·çÐKmj;'3‚½ ´hý·{«ß•jÉ«jy¦·ôÜâÙæ≩Cû™ôS{>:„m–MÅOªüeÿÔSd©x¾<çA9kW7æÚ’¬I»©^“ñ‘»8möëpú*è Q¦³*è‘"¬71(EGŽÄr„“ôd Ýë¯ø²yr£“Ii>-™ÏÆ›š,”OL³ðÑiG[Ò^<HöÝ‘›ks¤#1›?=Ï·¹þsº2Ý Q¬erïÅÊwYòyaÙû¯<H>5†Hà“A󌊤¹J+Ïôg:íü†½déB*XÇ/¶TÌ÷ѨFÜc+Ç]þkêFTUe%„)fýí­n8|ëé»Ói¥;÷wT?k‚‹¸Àzt Ðr½îÝ[ RV-(À™ò4·î~ðÀõ-®¼/1‚¸Eõz.«ÒM3 ª²Ôfwè§ÉXò,€øc/~§¸V8Wi{OGh¦,‹7· €À‘iÿe-.1gd¨ú�MôdW{Fþ�Ú¼0!ÍS£Ã?V¨ö©bmd褚#Óh1¾·ÊñeàIÏ|2Æ«c'<w»ðÙ¥9Â̺̕å¢é!ÒB¼mÚó0À2#5Ü?¦ƒh¥Ï�7À¸·œ="°¦U»íÇæ Ö•ÓÌ»enÎø³jfëƾìm˜}Ow¸¼ê,`sêZ ~—‰w^À–&,E4\®«ѯ²qZ¼eÁz‹÷z¢ ÕÖí¼f‡îèH ó@§•eš%1uŠ—¸§i&NW…ç,Èç½ïSJK,æ“ŇÍûÎHªyW÷fc¹ïc€ùûÍÕÕF5ZœÞ’Ú 2î;ò½½KŽ|ANQVúK¸}m­ž#Hš+ËßUg‚Žé‡5S”yô»’!=S$óâùƒQ C2ˆ°ý™G¦¹v&¥âŸó5 ²÷ÑS^Ü×ÿB³ÜÀx.ÝñÅŒ¨,œ©!ëaé.ÇƧTŒg«¦ùò!*×FŒ¥”Eq·x ' {´½ °Ý�5•×ª¡<[ u9¡€4󠼪”;3tÈÊ<Šý°1bÓ¢ÙÄb\™Çÿä4ks ƒb»5›\òÁ}}ažál² %š8„Þ•0\õÚbzîUPÕ7 ìþüÑYg|G”dz\ƒR óË”AY÷Öä4fçLÏ܇"CßbßÎ8ìx,÷àgô¼öÛ½™”NÍFZotÐÒ‘át:C`ä/Âpj€<4]rß–ü{tž­<Z ú)Kç›x0Ö½ßH�n˜6®íée¨¬âðZ‡«¹x„ó¶à2.² ŽM=y!a:Ŵü~ƒ7=Ë„á†Âgõ® I—u@vŠÃ-_E"D.Št‚qÙbJÞž½æ<:ÚŒ´õ”\в›A÷ü†MïVec™L­§:ƒYÖb  ½q½uõ›M_7×zðY²":EÒÏmìŒé!rÑ8Séö_Ì°Ëê&å]úøVUw«í‹S‹‰‘,ù©µôÔç§ò)¼˜øO1{œ»� ‚±?3þÎX2Í{ãœ`F¦ß;&9û\<ëÏšÒÐy1É fò§“h™[æ3Åw‚ ®Û—ˆZm·/ç%Ÿ[CV³ü—óvûÁž¸ò<1x®ÜŸ³ k­9/Bvwìõg`ý&û›ºÝaFº¦ÊÊ@ÍPhºÖÚÈYWæú'PL‚»ÝÖ1'Ä>ÍrM‹ïÙ늢lVÒˆàôUÑ 7»¶¿»z§ÆpxÌ¿? üF~Eüc†ŸÉ–¨[˜yðŠÅ¨Ü”Üäê"cI7á_s%ÙJû,s¤ªî ʃ²ÛÎ'­Rt\ºã(’¯ÚVÞê/¬’,@4«3ÊÞÐeìT´ë—O:æD}Àmf‚� æ‚ŽÁ ›i@¡îSo­›fÛA»Ûn=´¬G:ÐØÍ¢‘=žÒ:+õ}Ž³—ÁBïß­Ò èükRMUˆÿãÙI–ü†‰n+Ì(4«¾Ôq[θU_<C¹ÿg¥´ðj¬Ê­›ƒPó` ¿±réÝ/ŒÍ†º;Mèž ÿ"µó±: ó@ÕÓdkÑò=µ'ø)wK‘n/Ö糟í,O³‡¾³Sé+Mí¤Ò þIÜu´Ò0ˆüö e¾=¯:+Bpyã qüdFJRï0²vXçdI75šà” gÁkÏ">Ç­£MM¿Köê_¨sc~:×Ð>iíè6T±^# \÷¯8‰½ÞƒŸøF-¢&B;ôV vþ‰–kÕ„ÝŒdN;cÐkã^ *­Z ‚R£\ ¯dÿ¯‹ãZ³Î¬¹+*,<×ÛíÄn9 Ë9âi]t¤•+ê’}—RÈÔH¨†ó‹†ù×i&•«”Dœ~¹Ð—MÇ«ØÑw:Ìz^Ÿ|ƥׂáùƒeò³M 7h#ñáý 4&ÊS÷ #Æ‹v@Í6¦N‘ KÇZ7L2¸JRaÿÈïÜz¼¸XX^†’vÜ—ªeÇÇ!`yú¹÷±zÃáßKcÖMVXßtÎ Ú: ŠÎŠgÆ4TÒbhÖpf D­´žê—†%«tžòáž"ejZ,Yq2=2ëûu¿«ŸîïUOŸ‘¿IuOïÍ hwúÒ§T+_á;ÆŸ`ÀOôŠ'i�ípð§VsÖ˜Ÿr‰nµõ|è%4ß^è>)ï•Ý¨†JåÆ%ŒÜ¾pF,Ç==%¦<sqôù£Ÿüh¤¯H—hžö¬6«ÆX_£šæÕÂ/P„¼i|ežºŸXã”U7Ù8—i͵?kEÁêòúÆ^ù–%QD®ò¬x¨’Òq85^}ÞNç£.iùó¦¦*ŒŽWúôÓtœ‘c¿Ø£$öÏp;¬èFô:»aÍÓÅö·N’ÊýŒÕÖÝVto;øѦ› ÕF&+9ˆFpèïä“Æ_$êMêÅ€7ßmõŽ#o﯋ø¢Jµñ3ÀÝ÷)ÊØ ‹õ;m`&œ–÷=»ã)Eg%eüDØüþÇ‘G*ÈÌžM!Êfëà%»¾k<ÄD×ñ}ùßL!`C:ZHŸÊBô¨ÒOæJP?-äùW*áI•©6ƒ"ÖÙ%¾h`QvÚ||¨0¤yê÷?‚ ‰ãÍIöšžÀ²0Æ35ÚóæCý ÿû–$·¤þÀm-n㎶ºªànʹ"»Ñ/ô«ÓNU÷)’Âôå4š°­o$í߇"%±Ý—¼Ô)kíh× š{Ó>Çÿ¹÷¸à§ êê_=¯ºî—%´Ê &+¬#ö ~²«¹ÓÍ×yÑ÷o‰üû:¼ Ú+-ÇVÑCkÙ¡‡Æ¿k‰Ã�{wÙè!ç(úO™;\wnD´ Ït.a±w`*™(¸kIrkNA¬r4Ž÷µ÷Xœyý!æ$ÓʾZÝ nm»C:•‚ïYàªE`g *³ù‚I£[RSÞìÕ¹é."”èÍåBò3 1ö=¨…wÌúFz+cŽ<`|½ÌÛÐ ävˆ½àþé�üûŸ šyVza#\`x¶þ]32•ÅB‡ <»•æï %q‹™HB/¸æÌÞSá‘Ϫݔ %¼ÐINéëhÚ”²pÍþ ˜¶L¬ö© ¶°Z«^ü1ÃjêaC仪æ#ÂkQÌ_O)¤¬ìeašÍLÅ2'ÉÆ ëb&A2ü›sÀN+˜) ¥86ÎG‘ƒûúßÎ;í¶ÝÂV£}Ç°ÕýS‰Ø8®|E�´fÏ”ù/_–sÐ'ÝRž}˦Q¦üÿýãËß4Ô’ÌG!B™o‹*΢ûKAs™ÔñRt†Pñèê΀Æá”0veš*Q*Ü 4òç™þˆ™á7ì0o…¡_ç¦RNZ¶Ò€$KˆU «¡Îý[oöo䮬G²ðOÂ*�=‡™ý‘ Ë=HTJ=R©è±‰<˜ðãˇxbK‚êÅ.VèIÛ‹²µ²Èœ |G Û¤šN×öáÙ†+XW*¾x[¹bZl{=Žjö­ž£ó³á7%€ì—5Ùf0ÄμÖP²~i™•DêŒW1§/ƒc)b­(`Ä3Ù¹c??Ù!øXî¦IIó­ié­…i•fžÇžG 5ÉûäB!ÀÒ_·[“üÝÃŽòl]¬ ¥Ce¯>(hÔý‘ž‡üQ;T<³]¯�.Ôîæ­c™%¾^X,¶ìô5þõ†JÃÙ“Q£ß�Ø€ X‹\½X†èÅš†‘Ñ··z[˜Ãô/Ÿþ5˜Ö¬Íu``Ä÷¸ˆ"}ÐK»‡tãÁ[k=«IÊëuÆö›[Ǿ.æ- >5‘¿P²åcËíê2ð€´×l–púFÈÉõüå eÏ Z/‹>ЛhÄ(Ûä ¢|tNÀ¨/Xc?±óŽ=Åa†Ç0ܧ°*‹�aÑSœOG¼QÊÒ£<P^qìùΟ:Ký‹ÍRà)·WÇüoÏCS«Ç×_xÔ­`±€Ó±—]•iƒ‰á¥¾@ùSAÞïOýÞ‡½ ®cÈOÿÓJUx…ÃDÏ(¯Õ<v×ÃA(±Ð68Ð=1˜ß«°Ô¿³5-ËÕ§‹"@b-·(´‚MÎ%þg9€Ò°XBpÓ >«Fb·»É;ìn5\h¹z�,½Ývq”ËG� 6�–#Ëzò¯ÞæGïXÁકλ ò„óyÕ,¦°&X4f0÷rp¥ÝÞ« XuìÌhÏŽ ùíg¿K‹2x{îX@ò¯dþâÒÝš IÒf›�ê¡øà2êiî„*¿2 Pþötzµõ…>œl”p?ú‘ï:™[òVäídæ\?œ!7í ÅýÆÒÍ0‡Sþ{äWl1&"E0/L‡‹µUg×Î~¥û÷¿áEÝŸ¥–nã‰By2( �Z†Ãµ[<¹³•jsÚ1´§Å«75Ué·gO®¤2 Í�Α›GG𠺜úV=Sè„Wgbhfé}¤L ,l&AïS¥³ 3CœÊÚaš['*£þañö_êÚh`½¼äK" ,0‹CÏUT] tïj)s^ÄŠú5 ûqÏrÔ‰^‘ àî´ëúJ·R5sãÐê:PÄ(–Zõ[ø´WÍ=sPt;Þð›©>jö}#ÿz§›¯¡‹,£›Õrñ´rOÝKÚªœ+ïž(çFÿÉœp^Âò MDÜ.¦©bOêÍÆü]Áþ:0•þ¦Eœ98÷󨬣À7ÙaV̳½šÍ{4…?x±ý×ï8pRŒ6ãþêMÅ6ç—°~=Š5sÛžƒËÔ}1íæÕ›7‰ö„ ::D½õÛ*¡¯Çɳöo/øãäoþëjæBÁ`‡[Z%éç¿ž-xŠŒJ”OvÓ§' õ‰Ãò–¨�4B¦Á‘™¸í µgEŸ¿FÈ‹*çÒ—24s΃bRâŒÓ§zøá <‰¬òy¸Aô|u iÑ’â-ö+Ñ…,ò�%\ŽƒK÷ÚOáƒŸÛ N(èóGÇýYxh +ˆ%Ì·(˜¯EPv­§„€Xuš` *¤³ à+ ²foTsÌv¯=Æ©f‰7"åÙ&·|“F;y-s£ƒíï{¼‘gn¥Ý}WU÷®36¶{Û€BaUêhßùSÓïàû™×g‘¹§}7xžhYv;ËЙ{þ ‡/ð_w£©R¼´À¦­…]Æ<Ã0á‹þŸ´“÷²Í»õè÷N3-ŽŒØaße v1¢c™)¾†ºŸPÒƒóÜ#þ1#™ý~·—Ù*‡Uy”zó’ׯE¡ªáL7”AÙ\@ZK'À ­©V/›‰*œ›w=6:"·ä­¬¢cÓ”1^ q;ÎNIŽW¯`6Ö‹e®‡féöäÒ÷ ÐÖd[c–Ò ³9ìaÖêµéú?Ñî©Š\û’!E½èö=àâFñA\8•&wv\ÄoH‰ö ›nP‰¦oDt/eÖ(SWŽOÌ’ãÔfß9?TF¢e6Hàú•×ˆ·Ü•™‘Õä+md箿ž¥ük |qâÁwؼp¦ ±ÝÈÔü©¤ÉÂKD‡¤Ì<m˜Bü7 ²Þ6¢r©Â¤ãÔL”z¡âK®t5« :”5ÊqŠÂôÐ1<[Jõk倥#D†:AË*ö¨¤Eq•ºùÀ8Ù€Qé=ÕÉ/,¯2òMîÁ½9ż»­@PÀÒIÂÐc®b\iåjJ–^ga£±w8,2É·þwÞ±…‡Úホ-&òZg¯rð‰ø¶î¨N)ø~pÖdÂkY{XĵÛDšfž‹,wzz¬eûé ­á®*ŸJƯ3“õŸ“‘Z銓Ÿx„³ÄjÖ=%¶>¾|Û÷'zûú×0¦UœyNZ€ØÕB§;éëÑ•åÁþƒMÎ�ì&T5æ7BáKôj-×*É ØÌta)iè)2lÐ œY‹âÒ>€t0™á­N»Aœ´ ,›îùWÅàñ¢³Ð œ.=ù±±EV¨"x7GèB̵%Ó–*€iLâ“C#}2esþ­‚€2v8Ûuž³må¬ß¬VQâK-²¢G7PØ´yQÌ ÍÉÍÔCü¹—¸U6RGÓãGJŸ¹½¬\ºøfÿ÷¢¨EP,4’ê³Ev&Lܼznš…áä\à °X×TèN\…ƒé ²·ªnÞöÂiœyƒìT4¶MyïœiùQ­ö$pÚ·`ü%¤šü„€e¾ e‡—?y. Cå°­§QFšÀœ€òÕè·ïnEl¢[ˆ°—{ÍE‘7JoÔL¢ä”æ(ŽÇÿQŒÝº2îJÔì×1¾{ÎÝ`¥8|í<ÊŠòû…ë˜ef{ËBË‚eK%Á²:-çšcÕ5ÐQ®ŠO«-Î+éÒÉÖbãâ ç>ÆÙÊ‘ç{µå˜¤ßXÂÒ³ð•N&³Ç IsvÁ¬¾Þ¶3Ïžm(Œv¼šýbÔ,/cw¸sZoÒ²‰˜$šô­7øºPuÖ\o•A¾3EÄþpß?FÛ8ÛjèøÞËñ,üH…H¼ ´µ<)Ñ €ãÑ3­aëæÇ¡„h$¨a'G7àAo è&5¢L%ë{ïtHPÔ6ll!ÌaÃ]ÝKhY6÷—BÖÄ N•‘Zl`Vs°0TÜ׈Óeƒmu—O$µq)¹”õv_ôÝ?G`ÔÔÿr7VìÍŽ'*D¸î¾:NˆäÅŠñ„¥K¸2iy¸J¡J$¤r;‡×û Ãû, 7Ú“„ÑÅ‘ÆÔëÎ:•fC8t훕(yåóžàÏ3•´sG¹Aï‚jwÛ„Töä·x̤ò›Y‘_D_ïN‡_eÍÙô‚ñEâ)Oü„Éé �GúåëDÇìk™éëÒ‰“¼ƒ)¥™ €B 8³w ­µD2oGÞÝ¥»¥t™o•Ëi�mçÏw+NRsíéf¼†ô±~¹¸¨E2l„ Œö›€õ¥]Û8ÚæO~‡ìyæów˜¨ÔùRzÿâ“«p„Þãp@׸QöHÍW-Éo›½è{AâÆì–Ò(¡ÑôåÀ¤¼‡½vâ‚°,2[/ZÃ[Aaª¬¹OƒØêdçâõpU„0:;œˆ7¯/ç«Eá{ƒ±T’…U”½ îÕØÑ#Ý<NÊä0zwkt_)S–œF£4ò¬`¹äŽý,6Å¥?û¢re™`)W[ë´ë_ÛÖîÚ Ó9}}Ä Ë0¹69;] .Y?>uÍ0½óÆ Þ4ù¤¼F`&ky¡86Z $@ø¢8]Õm*) T=ð>ŽTwüÙr¸É‡ÆZQd…|‘x%hÙçìÚÉؼëji”à]ì…Âu²¢J*çÑ•B%2 ²eðѪ89µ´}©›@Gc8°6RÓR2T_Ý!lãζÖîÛß´©rOdŽóÞdõpTÂ}¢l'¾ªÈ`Ž÷«Ž´›ëQyOE^ÌÓIß懶3÷Ýñ°`×#¶<F›øX†ïkPì[µ´fDßpe9oåqcÿ0«ä±·Vä™Ûñ�ÞSTVô‚]ËOÐQ÷n <—9âŒ)±úÑÒ´´ ^Ñ!Y0€~·nv13.ÁÎNµ „¿‰¼²n90¿RÚ³(¿,n >ÕÏ#:,T¼Bûj}‘†]û–=“ûÈðŽAÄ@ÜX1-ß„þEGz»ã˜Q4}ÄÃÅ­tºïµµâÒ‡yy¸N|·B¡Ï¢Ÿ˜Rìqä fñ0…ö×­D·ešÄìs(Š^Us²e,º·æ<Cju~ƒ¤5æ=,CX‡Á\ƒ1F€gÑœ‘ý]Ë÷†D²±RÖŠ¢%E‹cQÄ£~«'y«¢br›uQdú YVL¯Wî/ùÕê]U›IáÃæE>NešÌ%¦æ1.>ºáÇs e2óòDÍ ˆ/ÄÅFVlì¸Q¨£³4æÚx³§¥‡Ç‡%]Ûù´a«‘·¡;-/¨~gv5*…¼A—ª<«WÖ±Þ#¸nö§“é/l`%·Vwû_¼Ù£(õí¨’ÁõÉvrÚuFd11û•Æ¶þE=#3‹Âd/È'NžÜ¡É>ß è[‡*õ…(ýbA’VQ‡¨óþvšš5ý¬Db·4+Qx¾ž2 ž×Æa�=…F3Ý4x*À§ÆÅyègzèm I79ºÀûö…N‚'7öþ'‘@ïœ. €çhg ÿº$²9ƒnj¼&if™…+Ç�:tÏ" 줞kzÞÌ24cXËÿ',2OÔ›;”Rí¹|©yç WÔÉó™ÅÁ;×ÑÊ/¾d±ZÆ&ËbÖdÌ,cJ9ûÚkÁñ´ÕØyTwõ]2î ãñh¥i)e±C!Ü=øÙx¸_åq^ªOÏy4í쉄ëù΂üõžSRùœO ‘ËgdŽâ^ˆY²›ï5í;vã½á¸'¹Ó‹bŒa0“ ?=±V:0!á ò¡¬¡§/÷:癯¢Áe¢;ïÕÃ/FMÖõ µ«ÖÁ‘µ }eêÐì‘”þYl{‰˜(ÓÝ*Q�ƒ0+4ñß·Èxrdô8v»ž¾¤é-éòã2·+Ô!nî†Ý•3ÎÎCwh]©´Ïï¬7+¥õ¤Æè’kÑ—µwÊe:(ÀôƒèZœzô“p¶÷W÷î—–Æ×VímÌE{ȣȣ•¸•$# ©öì„*y‰&¤Þbú»YËwÁÆ0 •5@åüâ$)ÚPž­c }[QOä„Å ë?fâA‡à¥ûÁô<vün„\»å6x!¤®Ð¼Ù¿ª4 Q×%¾P2‹½ȳzhºÍ‡‰x3ùó%eÉEìaª�óª Û)õ =ð+«°›Dî@ßób%g©Çëb¿H=µvåâÐ)øÕèù-°CœF.¹5@`®ùñ`Ÿí¹,Õžùò%aB‰/ˆªÚ‹S±¶ûU Ó×-téÜQ•˜t‹÷pÚöo´X}EÖ°o¡×=÷ñ)“CFŸ"y…§äÊÏãÖm3Ž¼F6 îâJ—-VQ¹>óþ¤Rã—Nµï|éO1S÷ îs&—H¼¬0ô8µÌõpfÂ]¹ë—·}½h£4²óâ°4•�—6åYçŽÀŒ÷tWu°KWÙ¨‰»À¼ÏrÚhW˼ç_"ÓR Ý|NÓ´˜‡±€¹uÐã9ëIB7ð€°óu~‘pæ)úÊ(¡ø½öÜ8&È\ìÙDæùO±†oÛ¥ÈÞµÅ'ècËŸxý�Á—ž[+jBÂ3Ëà4)2™R®Qióe" lêF¬2àæYY÷g­¼t;L‚þåû¿NÊŠ<[(Ø—An&/ºÃ+RøF£î!SN«Ï" ‹’[ŸE„¾ÞÉ&‡TÙ»å¼~ÈŠéóE™Y'Lˆ(ßÏfb›f¾n£|{ð&Ðòú_ò"’ÈòÛéîLçSb¥Úú2hŸ•r2^¡ÅŠéØèîê‰?aéz`’.ýiÉxõLë1ÂeĘipMNUÛ¼y+úú·sšÊ7½ ³à0BEþÜüÿh{õÖ•¤[pŒz úNÎéÞ 4R�¸)îï¾ÿst¬ˆ4:QªêîûoBª*Š2#Ã,ãð wo4*×»údV½ôsÝE3vÆäYÑýÒE•Òé€lÓòröDj~zŠ”•k Ⱥr5ßÔÊÐZ/Z]ë›”=-µò°=GA;œÒT±€,+ÕÔë¹³ím\I®OØÔD ¾qÙÖ2ôÁv¡ít®Ž<ºñðw¸ì´¼1@èJ¤½VVËú¸ Ÿ_ö" U-ŢØp?pëÈ¿í€HÔ¤6j² TÃ7€ôàö2ÀûW(ox±,LÓS¥?Z J /=2Ö¾ÿ²«ù¬¹Yi™: é»TAî *ñ´ôï >9ï]ÝáædZù#–, :;æfòö°ïX™Ö&Ìw0žOО^îH`qpìcŒ Ú@¶¹pˆä/ë‘ÿË“qß-P÷NC8ëlбhñ×ÓBašñx>«ÜÖÜîþŠlõ’-FT.Vž5¸?ƒ5Þ(x”/FWŽ>ó­(«wÜCÝÛ ­ŸÓ§ê°6ãå`'œ¾ítï궋¢˜K^I^Óƪ¹t—üÐrA‹’ýÁlpû>›MâLë㉆@±µB…=ëϪÅrõçšžùÔ93i3ZEÖ’½ÞÍ“XD¾· þìV´€vµkÈ3@ÃþÀÇh ý‰ôÖlónj%ýre ù/×´º„y‡%U±ËŠJg–ww#¢0T 2ƒÈ›,vy¦‘qíò ¼8ôÊêB(éÀÍxX° (c–Ju§¦&½eB¸&Nb+Ó¦2g|ÉØ=$Ón ó½ú0Ëp™ØߤùáRº<9½Ö‚Ëp´ݿ(Ï™æ+}¢—…ôòT)–›Ž"åÍ›ÁJØÅSo&`t”õÉ ~\9ü½Z…&Îæ£0ÚàÓ™ŽºMãþ´§ÇC`¸>±'–x}7Ív-Á–†Ò¨+Ó§' ­¨À {e¼R6êÄœI(7<×ÂÚË눎ëÃi½ }ÍB=ako¾r ,ñ®S]Õh‘©Àûn»COµÄº¥…Inb© 'FÉqˆi³;F@ñÜÒC>må9þ, ÓË4VrÈ͸3"ëâ Ë咛Ī.d;›i¢E¯A¯Œsô“´ˆãa¹ ~3ø‡•ž$ÀòÿÍœƒ î ‹Ž]ëM¹~`¹^ƺJ†ÖlΣ³-€!iÈâÚ×Øà÷*qohý…ržwÊ‚g¨©Æ"N×"Ï¿ízçà ˜Šü¿æ?ðÿ•e¡ìøU‘Àë‹`Q)»ž"Øý_o:Èg/kÇYºÏÖ£*É”ªm76C$ñnU¬ÄÍ-› Ðöã®ç·Îcih`ž2ü šÒºúh‚Là#'+q-Ö+s|ªt—ÖÅËVÈPc‡uC4½üäZàv®B^}XU*ŒÖñ ´±eISÂèè4æ Í„iqnÎû™Öf‰×Pç;¶ÚA|Ü*®wa%%6ÉþÉX@š×º¿ ¦u#‘U¾´òlÐ3¨ò?÷¦€†ÚËx“»mô„ý?‰~0Ÿ¶é$ ¾ý¥b§±’f€Íï'µpÇK«ŽghY' -îÇôüùÝœ3ˆ+¸õÚ;*J'ªæÙ[.h¶ª­ðÏÂÏ¡þЂ٪ûèÚ ìc%–ž±hv—Ó»µ�Àzš.€ä­núÃÕÕ²Ê0£«û]M¾c®§îD-Ílƒ©¯ù`6ª¢æ¿3˜ãU=_i¼GÞL›‡Ë«†Î“Ñ6HX^ Úµ’$X ݽ3{ru+8šžéå¦ÙùY³Þ Áˆ îÄŽ—ŽS;#æÕ¿›uÀçâ%••<‹*H‡ž¦-'ׂþ Y"rè®ÔLhf@�“÷‹»5‘mizÌn³ÛlvÆK”T¸5ûÐJÛÚ)É©Q®Kʇº9 #ÓË1ƒkƒ}ƒX"k?¿RÍ<Ó&„‘a$ý¤£ê�¡¤ÑŸ:Ò)Ø ê걟aV.ðilç–R†PJ'WC·Ë ¿s¥S;i<å,O9˜^”k‰yÏÇÀóX«®r£ŒÂ­³³Á9¾º°‘#[fÖF¤ööâÎö÷e˜%ßmN@v~i+3¬°ÙHßê2y"–h4LÔ⬤)èŽÝ|ðïÇá‘ž’óïùæg&ì.ã…„ÈÏÖc'€ðéÆßÄ(ÍCU›Ñ–¤;B©¹Ó�h–¢µ{x`6ÙãE_ß¿;®½Ê*C )¡'n•—�-[ÊÌm[šÞg6ó?ÚGÆi¾F…b‡§ù]{FŸ@îÌ,Ã]Ç6yäõ”* fÉÀbl¬•AÛ¦koéЖS~¦ú(– ñïØÒVû°çÌF½frwàýwÒ¿I’- »á·ˆŽÐŧ:¬ä-º9ÿcÇ]7(3®Pi̓h=™Šèˆy¹å‘þóV†ED‰�K:ø?Ûÿ½Awñ»ì˜Iƪ º! 2µ„eû£Ÿþ]³%³&5x†MÉȲmm~•32—¾‹óµ½ž?ê=»½•¦D˜:,“ú¤Æ­èùŠ—¨í½üÙý‚õ.s±PZ*,¦³ééS–Ë—5(Ití¬ïU‹ È:$7íœa—qk"ia™-÷ß"/=<<2ÇN3QF=ØYýDÚQmÐ2›j®7'ß'|½vb-ÙH¡e¢Jþ´1-óÞ^ôÕ>sR:ÿi¶ †GGÌ2ßI½v‹íà[݈ó‡úaîv«Ÿfùa±VŽæeÄüjÞzcÆÚi¾NâH”ù#wL6}F‘ËéùG˜jA˜ý³m©ºž8~ÿòv]i(“ ¶§4È¿NJ§NdZnãý÷¸>_ìÇvãu´¥?Þn}ØôW¼€¤Z '¦½‚zT;®ý‡Á: ñÙLR­pömH"ª4D‰34Eù¹®‚ô識H…Dé,ååoÖùúyÃ#J#¯Ç2,Òòéà ¬o~Ñe·Ò(y]ž% ³…,YÆyJ­Mö`ÄÚ¥µÅÚlšC<Â1Ê¿“œO¢(Lô Ì ºëÇÉTÞ²Fé¿‹äÛ4çú$}Gy5@ …V.õ½' iõž®AÉ:âZbc¢‚ÇZ"zsÚõò¥|O?©Âe=3úà“ER€#ï D´-5v”¯YçÇkmÅ´ssºE¢¦]bð$1^kKr<mÓÖ†€Ð7™qQ™×ÄbÊgDŽ²ÒZ3S—B¿þãÍ?nI(ì”ãÖP>ËÂ\³¢ÝRá¦6™ÄÅœî²è‘G€@v5C·më’þ]?Ù_I¦¬Î€M¯h\\¾‡3†ý½a”zÕ$÷@ùÓ_HÁ!{€žúÚ-³íøöüßÿ3½õ—aXü`øŽu»î;†0·òlaS»n­ø´ åôƒSSû®Z½9_Ú™ÂEÙÙN¦7‚Óz·X°í=~4àvpæLÿœöæûe¨f;l ´j0à_ÛæÍæ°yÛ×øWqFù�ÓªP×þåuÕ¹ÓÉt¦NÏ}µþ³þ2K›äýÔ~ìlÚñHðؾ*ݖ̈G5-Eì­%W–´¶0íæ“%¤þ.Ç¥+wѦ± Ò÷O-áÅîK¾D’VcßÁ»‡Â-é·C–?Eÿ©"m"öãe9¦4pŽã¶ÿ³!¤Ýµy|øîýb©ù€æLÇnèá²`«õÆ`wÿ�‘þ-´g6xcÓhý™˜d3ô7ãƦ÷X'X² F7âÇ–íUšs£î‹ íl"¶VôkßüÜ¡éF"myŠ˜x½àÌÚ‰AìÝtP2Ì[÷]ïr½ÏS7ìn´ðžÙŠ™E…dž9³'!;Ïf�ÇÑ?5½tJ­”2Rs=Êä‚Ö¿·¿r ùxçˆ"B4Û-O9)äá 0’îTé ¢òËÁÇê3yn>v¸„­FTŸÝÔ¥v4'¨ø䦇Ér*Ó¹n™!=wß(…D‰ì¶ƒ:-J7QdeúÎ}/·²Uãe¸;‰ÏÊ….}ú,{ÛèÈ…„½÷͇=å^<’`oZ¡5õœ¿%™†Šƒ 2@–íhw…¨° ‡†îú6å“põ ŒÞ; ¦hqݲÉâ…°IÃ9a6‹9YªËÜyñO±ˆÓzþæ A6©L,“Å=S”øﾯ×ÍCím´M{tqù¨g»Ê66³q»M¦¿JR:<Ò·ù°R¹Õ× ü¶,àfj•±`52i‘_j›sǬï9Á6cÁß« 9QŽÌp AùÊG%Á~8Ö,¢`سÌrÿ,QŽyêñP¼´Hl‰ƒÞê,'"•Úfüy7o‘f»™Ñás #Æ×t¬øëèvÉ\õž•Æ—@æǸLqI ¤gTU‡g÷‰5Ît&û}¯'S-^FØž!‰ä5R–D¢òvÇ:V*‡þ*]çnMÙóüÌœ%‰TŸž“':N)rl,ˆ—Â#jhÁ^í®…tÚ+'i¦¥o£ÅCÍ®²…˜ƒ Èé ƒ¹’ªuîT=yi4:€�¶ÊHÂñ°o¯pÿµé¶’ÿ¸{y­âV .p/¶uT_D ûmF 1ß¼<ÐCÈ¢L‰æPùD§{Øiïp _ݨ´h¾±ªŒP�¦™·ZPW|YL<Ù¬Ô—NQÎ<žÆƒˆpÃ:Q£º2=cLv˜ì¨È@´šé;®¬²+›?#6‚!¯I¨ÇÎG·44€ÕH`ct,dI î¾N£À`á0²Ðòpdƒ‡¤ƒªÊt£ˆn¤åºO¯+‹LÄÎ1„gÁøšns/ßWýI²¸oˆ1«¨ªÞö®éOzT‚NÕaÚuFñyÙöµ (ß6ºLžYÄ@³v¦/3]k � YC×£3&ö‚W=ð÷¼\%•(êªa~ж-G;õÁGV¾5(Ë ˜iANLžhN_³ÕwžƽÓ2û‰­…kT׊# Çõ6  ×UgqDçK#BW"Ød_®ôhÒëôá\AÞÛ]–Ú‚÷¼Ánh¡N'›x< Ø8>Y¼]^¢ÿ”•n‹'ÐJ¨w3ãÂLQÙ—ÚRŸM·à‰;p—Vu%Å.ƒÉIÚ7Ê'”ŠQ¢ `û?ó9q|'™rÒÓ=¯‘æº[À¥É¾~°†fCsÖÛõΨkAÇI++ë!ñq¤‡±n,¬¥bq@l3Z«o :Y?OÍ\LdezÛ-»Ÿ½:© Ålróá1áÓԪʥ¤ 9+*Ü;d×Ö£kD™ŸdK5õ†{\ø#Ú](f?ÞuÕ¹µÕV,½„€M¢c„þ4Îí˪? /Sc„¢ï§ãÓ1¢/[@â4XX„¼N¤.=Ë7F†Û´�\m&3ǃRjÌÊxÒ{ˆ2#„�ɺJ¼S}³¹ƒŠ˜ÜøVé ×ô8Ê=|!!%eåúK}PzOA¾ÈšÆ}¦Ã|êÓ³FL¸ÐÙd®¤Ó{ì¥0·�6½8ä)ÂÅœ$‘¶ÙŽ“év0‘¸æ4Ñó9äkºme¥éqqœš<(]p„Vgׂå(w†§’…¹+iÞ›öT^Ž„%æ÷]¤8}ô0Û2Îò×!·Ìß´/KªR)þz@ØZ-èHwÀ*þÀìË—#£iñ~t’ ½»Ï‘.g¢ae_ù¿³ì UŒbÉ’v¦ îm¥†³†þZÃ.à2½7ÒÎg#M=ŸF;•qÞƒþgR(Qbƒ3­¦Äi=f¼HnöÞ½…SÊPþy ·É“É7²`5Óò‰½GA¼DB�ÊÐliññd-ÝÖ ü—Æ?q8§AúÙ*§2Q÷¿çÂúhi§ŽÜUÛ€í1£Øçåâóí³ÙÃŒŒ¹:÷šgè*�§yÕdt¢Ç…¡ŒÍ-„è¾l¢u¤ÜôØ­fG ¢Δ»~’ýRê‚ôà_œÃÿÎç®k¿FZÙÑp8äBgO�ÎæÀq÷�D,¹g½YoÄ2Æ+,‚Ë!ƒ¢µSåæ2ÛîÔ6·Ù†bc÷òRoZJn'XH6bšLÍ…GÇOz©ä¡2̃îÐ}kÙÈuFUjêÐÔU7§B€)/‹î'FŸiª8ò,€6Œ°{ÜLV_ åÝ3œæ7<p«\;Ãʵ,*xËÇô¨­Â°†#}b»ÕÄ+ƒu¶[•îëk]¿¢s™©=&bU*æDP±"Óo€T]ÛB‰ãÎÅ•¢ˆæÞË6 eNË1ºœ½à§hCƒ" #߬z{¸ñ€Dz-‰·úCç_§MÈúB¥×ví|ïBŸ”:ÊÐs;ô1Ö> |×¾–"ÖjHX@úÞkœés”V"Ü—«£›ºÆ¶êö$ˆo0HÞ'2;*º!£âßR»RìH†GfBõƒi‚·™‚28…Y÷!ÑèyTpM z<éÌÃpiÌH ¾øl1<ap-@•¦ù„÷8i¬ÅæÎÈÂbe6–‘K‰¦liµå9sÿÛøËÿ�£“k5g,cÖíµ¼Ö¢à–;û6ýwf½q¶Héò`ÿ:È»q˜€FšáWl¯ô´ÑÐø‘-m*¯*�¾× ú›gÕ4§ÿMKËűui³SÂËEÆ‘Kûº1a¡oP† ó›B½£Qg&oj6Ù]›?èÐ;•©¨²:7kªã÷‹ò½°x?‹¸2ÀÇö!7}M"lõîÿ2ªò°by­­¦o_?®‡:6j™¹f‘ÉWt8Ô ˜yzì V5Ö““¥ojo[àÌÓ^óQ[ˆ·ðÁtD�¤PÂ=>öÈ:È+:ˆo&SAÉ9©¼½ÐGÚcj: økZ}ì±q3ÒNóÅ™KùòÅÎÖ*hK+H¡åßh—ÎÛþž“'™Ÿd° zLôó§†rKn*Uµy3ÀÝÖÐaAÖ{ÄÜËÔI›°§Úemqh;¤v*XëÞÆ“žyz?ÑCÉs´¤]$I‡Aó³d‚…ÃëkÅD© .6à-¬ö ˜¬eêäƼÀTCp+ü­{õ"ÓJl«UfAÚ:?,vouñ°ß¡½(·Gt*¨UÆI^dêV¥´©ðú:j«B;³¶ð¶§S�gš–›J®>x£Pï”4°zâyD?ŒG;i{ÌàÈ4_ÔoäfÕ§“Ô+D×bF6õmn¦C²§ŒS‘¬ûR uoý+£Ó×s‘(,)÷öTAhpD¡±–ŽDžB™¬Bß.´‚ƒ°ð ƒúöâNµô½p+}„ݦ ²Ïw»p*7ʶí!ª´dÎÆ×îˆgbM)Ì>R.„Ü"¦0Û‹Y@h>ú™Õ¥zZvÄÍ/¾§S,Û©¤£ :ïŠé»§8w0ÍEãêºÝÍ„4ú®Þ[á J¶ŒoǵG”& ASöHƒ²ÿkïY˜ºðgíópÍØùîm¨ÿv÷~uã'PTJû’ÏŠs Á£µ¯ÊÙtÉý™æpÆ& w„˜óh¤²ï.¿¢ðÊ͉„À4H&«K’u7nNÓƒzþ›ÀWËQ\%ï_oœyž5Vcyõ;úoþ@UË–)cU“¦,B0õ}çù~,êøfóÙ—L²’°È–ET³…KÖgï‘7ÝÜ Ö(‡'?xy›l)XA®V@¶+ž±°13ýý5ígû$)Dr­j_}>) Crñ@o·¶•÷êÒ‚~bo…–ZV!`¾"{ð±Úþî<„pÁÛ¡7„B ¶ Ü©³°ÅŒ€%ÀÆÝeð»4ÝC|Ë«ð½"\`\ó�L­¾·ÓHTýa=ÃÆêíXŸú銢Jö€²:ûŸ8yÇ[À¡2¯A´‰ž_ä4­x¦ CB‘ûOr¢ÿä•Ë8©r§ HUšáÚÎþ‘Še3fbÉF®í(H„'†ÖQ¨= ~ª0ZÛ@„nŠt¸‰þ;až"Ê”ô)xó]EYA¯ÑCtz£%Où4 žôK}¶>…÷4Jm¤ þ™‰iâk&œê­y/¯öI½Ûau’štO¾†Ü–²‡·íCúL›Ø‹¨…ºìœ(„Åè1B3J…{—nÔÁP·=:pO —_>]¾§Þ)�`ÂoÞdAææÓÚ˜¹ŸëœáV=›x½Á‹*þé{3må®jé¥P^lbÉÈ^I~�¼¯{£*(6®€HM&5~*ŸF‹×#옋0n¡l0ÚªW•\žQ¥ mÖs<õ6 U—ÀÌ8 jwËbá?Ñצ•ünÅ£+®Q?ìäô<¡½ÞÖ½}y螘fáÂ$9¢äšN cO'=rúÃÑ�ùWtü‰©õØU¯–‡OYfZ)¬d¼xÖØ-�4§ýÕ¹ÔTDJ”·Ðú‹‹oF2ÄfD&êeVíD])Ð#Á<¬Õ.{øÏO‡S£;ÒçAÞž•l4•qîpû¦SZãØx[Ç,ˆk*’ƒS²w3e×~}~¥Œ�BÅÅ¡¨Ã‚ˆ^Þ‡/ïõdÿ×ÓÂ!bµM¨¬Üs¶üåüeú–µyg×É74O J_ýÝM›ÃbÈÅV4‚ž=Ýûª7ŠóÈz›ú" ³·Ý0ŒQ»總�8Í,¢ÿde¡á )r¿0¨F'êC·`è”\ª¡*™—ç–tIùFYÂ(è?tÈ-o_Ì7ª&Ž[O.}¡¹íe1Dч²ú‰žKº­õ¨¿ÿtNbþ‡0®¡BlÓ1žb·2Vt7’p¶6Z�ôT6p¬v:ÖÀÐô'z~†-†™OØZp¬îþÒ”YfѲºÚ4ç´fG'û^߶~{昣âJìîG?ò8?v)m‚…ÝŒ:8}P.ª)x´Ã‘Ÿª8­í[ ¥r±.Yh sÚz[búh'&x™®Ç äü{D}%j.Ò}ŸÃ1k­¤ÒíYäÆ“ý…™eîb7I·´Fë :r7¿@¸Q«CÈkTdµsѨŸqNö“GÙPN�&_ª­ö¸ÁæÜqE÷•Òáî\vK vsX¶a|ä…˜‡ºŽ E‘<éœ\] Åý½èfüL‰<<F,?îx¨‚hký+ `f­lià\AnÌA´È6a·N2#äVx¿[×_fÑüÀ†3ξ?¡KjÞý’Ä=<;£Õxb¿ÒÉ%i‡@,Ïì)ÖXrŽ%‘IfV ^¢›uŒº½x.P)¼E‚h~jè^¹yj‰mæAÏ“²ñý§ mŸÈ§_?á�ê5ÖäbN)è&pÇçi?4 }c3ÁpL)sê¬J 7[뱡eÞ)çû#·:ï„æݺîü«Æ)Y‚Ÿ9ë[/߀ºƒ5D9Så>7íÖÆtª~%ÁkÄhƆØcHyÂQƒ†)žÓßq#Üï�»Î+͘1Vâ•ÖÛà qÓ—˘'úÜ)J¶BƒrâD„àÂéd³_ÅK“å¿­/ül¿W‹´x”ÁžBeî¸ñ6`ÀÀ°O–È}KµŽÊ"ÍnðÓ‰Â{8þ5ièNò¼ÚºÏL›‰)Ëß_"$™"œÆAòõWå»ûÔël‡­¡ÊÃxKªË{òL>Ï« òóšÖ঵�u46¨\sræ´L_9b×OK½åé§ÑµP±ÈÀG¶lzj5{8Nêêáð«Rî1Lë¡â#WóÈ€ë9AðÀ/­ü‹Ê£cPÀ !êáAèž{ëûRS$—!?§¥VQ³}G–Áñ"æ›t"øwG©T‘Kt‰Ù7X'e_}�1¿¼•SÄK'm[çe©Vr„®L¨œPn‘…\ækš øZŽŽôY(V2̦Q;eAÑuJó}C_ÖuæÁ|ásäH„*Ôr¢tP*’P˜>*ÃbágÝœ°\?†Ã¹· ~ú~¦O ÌG´ƒxEîT&sš†8c9‰ÈJ ®wóßã[ÃÉ×gé\«=ÚWÚñB!ª*ô2wk"Ô4�Y9Ô¾ùÁÝYž×2÷‹¯‘.s!ë´2Ú¶l3víÎY“œÅøåD°åÔrðªe˜žá#ì"O¢ïø®séixU…ÓÑl…‡r¯Ð‹:ÆöIJE[kñðÅÞÚF¹™Ïñ�ú3`>(ªþŽÖŸÞÈCD•†œÿ®AÎåLÊÜ7v%¬Në5Ê™ãaæÐI©Á·¼âBIsѸ¾èû…²YJ‡âÈÅÓÓ.PD'`â÷ 3½çuT›Æž!aÀ® Ühµ™V‹ö†@¥ÎcG·Ë¾,U‚¹Œi0,iŽÎÛ’ñ²ØÓ··Ãty«ÛUY¨Oí¦¥ûžO-ŸÚlŪ½¬¤$èXŠD¸éîâ™ùm©%h`Üu Ó.œŽ½ÃöR»š[‚…Žpç½8w ÇïBÃF¸Þw^—x¿ßÍwfʵµ�àÚ(Ó<Ô¸uî Öäy:À¬åü©åîó]^꘳åpw¶³ã¥º\¢U¥ÁU®Š ¿¼¥üžj8Vv1ˆƒW°‰e­å³¶úSQýk³v9’TÚ¾+J -7c1 ¾ž —‰wd~>CÔ·–‡)ÞÎ" Ï/HB÷²ÃWŸ]4ƒÃW}î¦kJêkòàqä¡ç"ÁË"Rõ—épÂÓ|o픟݋€ºè?YšiÉ=³ã<K;ËH[õ—Ö–“Ðl7>¤N· à ÞMöÕÂÑÝ^ªŒ«Ï±´½·Ë$ç­½X{—‰Oâo‰h‰Ò„Øj ˜œÍN6<p;½6ëd[ŸùÈ ¬<ðšÞÒˆ³©K$(‘fÓ¡¸Û@²ë¢Üb¨v䶥= `ô{Üh©ntžµ1 ÷¿Ö39›-ôw `�˜zû2u É\ÚHÅj†Ïl­Ýœ¼³#BÐ'�ØZ`˜ú=Ú­hØÍFK‚FQ–)9TÈ_v1ˆµi£Ll3.ü¶¦§rà u¿;Í»—ünÓÊ‚Häš~ªÀ;¸yMFÛÄÁŸ½´in¤M?æ,¨š“rA D GÅt›`ÍÅk⊥¦Å‚n aGKÿA^K5úgÖ#ø’ÀìB«s?,-BÏ¥3!Ù/6ä‡ÉOwê¶"s�ºÓø—v‘ÈQzÜÒ2?\{÷|GÒñŽ^è¤G´pKÖû08]öoyÚ „Þ¿4AÅym¤Fõ±ÝÂúð¬&ÃÛºÙàN˜3â.U㚸áªiÁz40”AìÌZ v>+r6n„^>ÿñ®v¡EB\·çFVie‹;è›GµXCìXùuÓÓ×Éêη!?vf6åž)ãL9êQOz{Oj2Y ÀCж³±²¬qÔÃ@ű3=ƒa{€¨QïÒ#igæÚ•ý z(íº./nÿy×O ? ׯ^p8sÖiè½P:Rj{²‡ýÖjÿ@?Ö•÷5ˆJóaÚ*¡J™@<œD8jd”YÛS¸“VŽ?G…™É󰥡ÚÊ!ºFÚÅÙµLY¨ë|YÏØ×[òT†ªê €vF/£ì\_)äfý³ð0X�¨£g,2Ÿú²î§úŽ<Z‘x˜É÷XD]í÷ )`úäèwõ´×¡ß`ZŸ•ÕMCÇC;1bšH¯>|n…ÀEúñ@ÒJôì°HœYG¥©~øZ;o:ã*/ãIXüöÕÛiˆ]L˜`~Jÿh‡lL>z±ÓiU;k�}}G©=ZÚÄ‚ïhÿªÔý,H2'½õ’#³CÆ8Nkò}Tâ³”²P::i“Â×N"R*ÜŒ¯Fª¼Ã~ð€²™awºË?oЧBcßjêÑÛ ³écnþÆmQS*fPÈÃàŠwÛöêA`¯“7ùuC'.o:Ç‘1r¨yñ ƒ‘[–=+ÏÒcn1.rÞ#ô?5dBQ–‰?Sžau2¨#¥G£û¹pC’{L.¦"´ÆË 6.Ø}çîÜ/·š†¡Vg†’>˜”ȳ›/ÿ˜ ï”ÙÖƒËx÷‡A�…7ò]–?±'ŠD1–…Ý•&‡r4~¾vôÄTÕ %�œÔØnìÆ]Ý¿Q.;®ZJq¥ãà91;PÐ=~ÐC„~?òÓdxÒÈsNiôŸ¨ôP¤Rb2¯Ÿ ñÐ_& .’åBïõë $¡ÐÊTû‰ ×||w ùÄpØd¨eª@=&{0,sô¦ØðUW{:Î{ÉÒ£ýú Ò+…81>ýÝ+{˜gÅ¢f¥}3õB8J¬B!—ÔÚÜ­Ft:ŒÁÕ+?N¸ »9ÈÝ_GªyÍ,j|‘šîþÜ+è»!{è:c!ü½ éÒ6l �T XÓÊ*�‘n8Cz»`…~+BåüK¹Âj–A49  ØÎØíÄ©;ô›nwÔ~óö2RùÔ®wý7?²éÇ® rLùlN[²Y—ļkïq6­ŸÛä>u !œ6”±N'úUa묳WJ ˜ø÷®n¥½a¯a²ÇLÐNÝ,Q´BÌþ%"{å³&ñk·yïž›6SN=A/Þj¤S|F0` úÆ –/:+N &su@>69Ž6àç‡ +P™§z’þÿI,º¡ÆÓîéwF†]Ùr(~ïЩ¦Ú)œ,–ôÎf£—eòî 0¿¼LRÀÒò™çË7°‹= CÃÜ;ô´, éGLËÑñéÚËOllË°pyã´¦Žnùé¨AŒ´?”0ÜòQBôsºß+Š²ôÂmo·mä[ÛúÀi ©M‡%ÜfÞúýnõ òì1c¿–±9¯*SìiëWÃh îH©V»Çd.ê›Obëyÿ¦$W<˜‚B(-ÁÏÉ«·¯pÔƒÓ“g·ô|ÕÕC’U”i( °ú*(æÎà ˜ˆ„pÎâü?„HþˆM®O¸Ô´g»¯’~Ì"—N]Òeú’Á½b�)¨!§“Ÿ^®“vѲÜhã|8$c„‹=B,ˆµô  ìRʤŠ€-}ÒyHÀÌ5ü /¦E°­ÙúdòKyE/$SY!ê: R'·„9¯WRvù3÷×A¨îØ@®Ýµª™W8tâ–ç$H>>+rý W©/â’ûRT4Ž~%sv— ì-O Ĭä!oòî2±ÃÏ¡s’8iP(S’Ÿ {°4ŠÙ^‘×áB×êÜŽuÅïzîåµá“wmkªóÅHÉâö[Y-Í…¨à#DK/Mƒ+zê ­gðvY”ÍVèS*ë»N q¦à&™¦84x² =]L].„ì¢�ucß ,ÁÄ•'ñ%²ö"�Ï5›øfÓÉ[t¯:è#ñŠúÞDžLìWÌ| Õ‚æ½ÆH®rÚ:ò ’¤?GÑãû>-‹¥BŒ{Š[§Áì7¤«ºíö—7i=áÃ^zðæõAèܨ÷CÊÊeÂY›íiУS¸?Â';t¥'+AÀThm«8A„5o6Â…°öpaQÿç-ˬÊô\Zšh;…ÍIHñçØ%eòœÌ0ÚmÙiºî0Ývœ\%œãï}§[訊u èÿÈ+Ý9S|KæÎÍQ7&rÛŒÉ>¨:Mzk“À0ׯ^Jþ Ž" 3?ä+Yý¼úÉfyÜ?¡›íEL-àÓ h½Yð’þTV”§Ë™-âÉcÉLcúàIùä"Ìê@+cšDhX¬Öô5¬q^”šÜYiÜ·®•WÞ’Ú"´·‡Y60ÝÉÖk¯ô¸‹4SÀp–žL“o«HAfC‹ÁgŒHäsöÞÕƒ¤o¡á»#h¾ƒ‹ìsµÃdˆUƒä1ì¾dýwïÿ×&Äsc°8éaˆìÏYP:\ª õÝÊû6R-¤TéÛ´ð™J;ÛžL"áL«NOÛ P¢iE·_ø-Aâίù€‘]Ø Û1*gÝ1(4ˆUŠ¶tà\žgŽ}w°ÎjT»t ?ínñµâ…R&øEdÇÖç\”¨ô;ÇÿÞõCÇÚës½—å.n jÑ’ÔšÂ;…~þrÎ%Ϭ§­ë(m;<" ™4ú ã§ƒÖœÄE*f”ÿ$EPkºcöÖæîØKß`/âñ3Ôø¼"}Qõ;û›«4ÃyTÇè·ZC®ûätþ‹|­í¾ÐZOû©@´£T³Øpµ¥ó2n:%7Ûý©'ú#Hл€Ð< U‘"Û6¤½µF„Ö<ê[^§H½x|ÿ놪ŠŠÌ,Pn_4¥ÙlÒ÷I£ÏfdÛ&É.€‹|ûØÍNíOÖ0}_j›í¬,µºkÅE»™X~뛈thå¿éžBÜk¿ºŽóyIh�½Ó¦s­u»f)<¨( Û÷®²^°SË"£X漂;ýö~êwX *”=ÆHý‚$1#sÍòfßÂrÕü·TŒHÁ7#£¹zø*‚d°³ Ô ó ±.]¬<‰#Ûš2Öiòow¢J!2.rØêu¶\sqéM€6†~W¿õÒö[¾¯ GHJC1`1s–ÿJL;b”¯Ã+Âîh¤2 œœº�àÊìÿJ‰3ÐÏæqŒyý@ÿŽŸN <¯<ëUD=?ò }_;þ“EékáFÉÌkè€v2Š<?аŠ£…|P·À=5é{ƒ¡N¶Ì@òLp„Jþ‹’Ó¾­Òp]Ðu9ÓbŸv< LÊ’·®Ô7E”É}&å¯�ˆ’éÜ¿ý‹G®òV<‡ºí¾å-Тö^z,R,cçdŠgK@‚ÿÝì¥Ê´ù+EæMŸa\`EJ2aqOgþ°¿uð[´ä¹lè>…ÎsÉ˺fíÂN¹ZÔž3ÏcÙœ½nÕæ.úˆí6’~ÔT}0œ¶4?è°YOë1ÞwÞö…ó/¥eæ7¾ÏZ†z6 GE åä:P‰X¥qÁÌÊQp ”c¥ÁÅÞk]”Î"—SoV4÷ºÎ‹&Ëwmò(2 î84À€i¦Oê懩0À¥Ã#x¦Ÿ²-«TÊt³÷tp$›W"þ%1s3¡†DÏû­óŸLé+E læ2˜Vwîç€íÛåmÓ_Œ£Á3ú ë×?BÝ9ÕµÐr9§ÎÒáS8Ô–iò¨öó5`’W™OЉ!În[‹lǪïqˆ¶ÖÝþ1øûe$xû?Z¢Õl« >¾{;êݸ›,²IŽtD_¹ö»ÌkdϔԵ£÷ª“ù§ülEyª•¹·Ë¤ »ÐÄY¾Ä¨þ²EÆvnjgf¡@œ+`ʲ¶Vì dÛÛúJ¾ð;5¡JËv IPS)ŸL2 {:„/TRØCfOKX€©îŠRï=NÕn°Z5ËŸ-Ýç—€vìèKxòþÅ° d31�7鳿|¤ƒ“jg5Q§ü‘ÞÑéH((íç·üJ™hk'^|PëùÖ¦GJ 0.]YdqâKEoÎàëÛ¸$éº+чpÄÒ›�ÑŽä‹G+‡¶_Lh›í¯LÏ'Mu©ÄÔ&¡q£è”ºÕ­Ág7ûïÜ»ºÑ8ħðA0êß0ºnãû{K…w‹!1%Ôȉ˜õ0ð«¶Z&ÒRg‚ñ` ÁÒÃúÍø•»à-ú6ØÞˆÍÂã êlÈÅðYA׸5kgÓ=8.æY*—ŸlYÄ ¡Î?×fÔêíOq0ÿ´Fë¿MžÕ À˜¾)Ã~T¬»©§LMIð6œxÚ~­¼d#†è"˜ À_¾ÛˆL‡Ê¥^mg5ð¥G1¡)5¼Ð†(–]®"˜ÏT–8‰"àœ†®wÛX «Ë×ø×q¾àü…QÐO”^7ÎF½q`z³º³•¯´Ù3¯ cý@̨|"z(p‚­õÅ[3-}íCøÒ,Üæ'†¸Fq;)½ÖŸ—]Ï‘`…~4­7¦»~–{bD­Cx‘¦TÜÖþ,' ³ñâûŽ:Ñ+NL ÛÇ \”Kø½+ ½=’NGí#¨ ?g”à„_‡ ¥%ïn[§•T-­ïw™" $·ë6×Ó÷¶œ•˜�¢›� ýzr|}îî!�YJÑãN‚CqÞA~žbtÙ@>øP“¨Ô9šÅ[X¡‹3&„W?)?¤Øö!)Wô¢ à·léÄHƒPbú»$Mù€ò^â1Fyr"f‰12ílPu#Œk+ ]Zaï0}JCŸ—Eñ@-Z†òïbVžîUYÀÝ Ó0Îp¯íÈ06:â{g+]HÈÃŒÅüßTèÐP´ôÒ1" 8XvÜø‰-w õÌí5D˜'_f&0£qV g_ïJYhuoŽGaMG€8¬ ä°Ì#%#–Ɇ³îe­t yx”`[ÌÿKý$wŸC(A]W½ŸÝƒPËŽ2.myökE¨Ì•üWyCÁj­±3k§g»§ä÷e†(SôƒB\ÂØmô¤4¡ �-Kô졪mþ}¬jí’g«Ç5MePÕö]aÕRäù{r‘m€’’^ÿÄá÷ïQ‹á¶÷SÐPÎìý© C…qäî»ý«'ôÒ<ÔòOaÄüØ™J æ|µeh½6wó…˜EÁj¦;Sn•Ó¸�gü¤¿¿àvOÌ^Ò…Ža”K™R8P-…²ßÒfüw •ïk+–gz‡%'‹éö¢Ú; P †9Mü1e›`Ï…>F.WÛ¶`ÁG«ÙRˆ^îÎæÐÓ5}ø–*x#KþÎe A‰"J´=D§[W;¦ðÉÄÔCˬÏ5ðÈÀmû+~ïe½[¤ Ñþ0g£ÈØ c²> íNN8äþƒÈ;ÉA”(}<�!»hŽÜwÝYp¾F¶íC6v\-U S˜:ÓF¹}-4ni0ñ•Ãïcç¨*¯„×Ú> Ò¯OeºÖôÊ•/f ÞJoõÅ” ÏýÍó¥ØKÄð• k¶”LQhW_ñÑžaT\yšïDy'Hcî`’Þm:}†âÈÇiº»ºÃ¡K6Œõ×'�`‚È÷–  qï0_ÎõxôØwÿ‚4ÌôßyÝÙ …(ap&Š6`yóÉòq2£ÎÓ¦Ÿ>°ëѯLý¹jR€Öìm¢±£à IÑIOZ2Æ6Ë„Ìö0¿oæ 0+ãÔ3R`+_aIÖ˜íºé'Ü7¯ýd›ùã>R'§Ì}…î KÓ¦L)–ƒ=±©^Q,ØeË* ‹ Κ,.òŠþ¬œd…ö KLÐÂpbé±@Ú!'fA'[“aòÈáå)AZ-D èÈb¸-LJñpKÛÀ§ìn² ¦Å’\¤Ï2ˆ lCžjþNX°óoѽ«À¸cÁXØpª¶Ï÷0½Ê iJ¹Ãm©qòïl3ïÿ?rÁÄÚM e8Ç=Ý3GØÊet „ˆ^ÝW¾#$œ&Ç'V´C’³’®>§yÁú˜»Y µwû‰Šn‹<x$®†1m2 ¯(åÝN[€‹}€Ì·Ü¤yÒxO#Ðò qÓS²pþT,NÞ¼9xJ/-²Ïþƒ™Ýê¼é+óÔC´Åßh ™Îæ¯U|á¾Â1"â@¢[ü‹; ÆÜd›6”™M¶R‚ªÒ]œ ‘Ñ6Þî&ñµ=ÆþÕn‚²úceº=åù’4œÊ‘õ¡\÷X ëÂòŠç—KìCó)J‚|ü4H5PöêÀΰñÚ –>‘.Í•Q„“ƒþ”Ií�CaÆÕ!>ºo­ö'MÞüÊØÕhL䞨/¦/=|S]8±p]œON|7Ï­ç«•·g ØîºÕ–â}ç0)ÿbyYTŠïgA{)9M,bäkœiRÛŠR×퉮‹’XÈrÆ@�¶}ìý ‘ùŽ]~«sš$×xRÆ"Áø%vÆÑþÑҗ駧x¤Lyÿò!ßy¸¼ŒúÎ8)6ë7¼n‡˜2-!Od'{Ä3S  ”Þè32¦ø=«J¯P(2íØ“oŒuz̼³ì ÛaÊ)¢¼lîáÄBEh„ϹEsp=¨(%ÝÔ@M1[j7¯7rQ…ÓT ˆÿ‚\ÔZÕ#àÜPRoS‘W�°Iëà— ƒpý×ÊE6Õ2B' [³Œ?̶ʒ¬ oêÐ; C@"3ÂÇ,9Yû“ˆÛ¼µ³0~‰Uæè|™“Ÿº£‘¸«ù\îëÝD5øŒ¹Óiìµǯ¤é c9|'¶®íè%g¨÷ï6óØù&™Gî¯åÌy ›ŠÜ75$Ì3¾¬[èuN0÷° I€ÃÅÕÊ_=>JÕþdû í¡ÑT*©Ì¹ù˧ µÊ­ú„âPçÜ¢"A. {¡ø{Š9¹wO`*Áìôií8¤X§'o¬bø†Ôùkµ ÓÅ @Gw%º4NÎi(²tÿɪd+a_os«°p8–˜ù˜)ŸJ]kþ¶u~°êA/ÓRg™ ì<éƒgGÛª*¦x¿AKó #™vɤ:¾îÑÓ±ÈvxW¸¸Y%<IÓß°¾Ç‹“ȳ2¼«?eo­n"Ì 1à?nØMÁ×Ë1þT^Á!öi÷V;Ä*ô•þзu°üŸ�j25b’¡+ƒhܪ± ç‚ûÃ0› §9h0óžøqÞ»º)OR5ò`ƒùÍ)bÖžKáfYÑÏá’Åø„6Ë\ãÐj>u=ÈÓÒ"6,Ü!‹Iárwz^«·ÞóŒÉv´ÒÛ®‚MÈÄ1 ú~æ„™#kH8ýsÚ7H´¼:ÖW{Z,Ž !ë¾Fø;í%øîxøc^nçqa«toÓÇ7tGªõ—-  R6F‰P;\¾àvYƱƒ%F+ *ÒÇÜ·¥ª¸ž¬Ô0 ßü^áj~±#aÞÞ‚› •®•\mvôUpÀ››CK¥£a°ÓàºÿSsýÃ:îÀ»÷Σ\?V:Ðç)ÂÉ-ÂBÝôfœ\?í˜ â–²âɸŽŒ]‹>0KŒZk¿û¿¤¥d{"„A wÕVۜՓpá,øq�ÀYŽ™³é&Æ - Ñ´ vÇŠ)å~=m$NÖtI\Ò¶òDx-6Þ Qa´NæuÄëÚžR,L7¢jë3{¨>èÿº4 1ü¼USq"¹;°GÖ¶\èôäÚÖ_=$à$éb.E·w>—AÕÛ”0¢×$hì=«ÁhK²×‡žÈŽß†Ü$,13¬‚¬v@,h}Á³ôÍiâž)#4Ÿr¦½ŠiÀ”$}²pá+rAÚ|°±TˆoŒ©3Š¶›˜Ø9mªÇ¨ .jìS‚ÎqÖ6ˆ”óB@@ÁWvöð½Îæ ‘Ã¶¦&ÁÔ¸jmº Ñ`KkHÔÝÏ¿§•ÓÊ÷ª³ Û~ª~¥ A†ÊRƒ ‚j÷.™Å€”âÈMØا¶s'´ˆÿP¥ÕÙ…ûš£O¥WË,³;¡1¶ÿê)Ûwz>?Jð³P3oA<ÿÌ)`™gÛ‚Úkœ umJ¹­Oëpÿ-ëzXï'Ï–Ï %I%ÁžÂCáæq1ÛÉ­¶»áçZ ´å¬QfÂÙ¹¥32þt)[Ìæ“’°y­&u¢t‘LÌјςÄq.Wf-6Éü–ÛTñÒ;qOÙŸWÐãY2lˆØÊùˆ±ÇÜ—ZiYì•ÉDgtêh¥Ÿ5G‚8H¼ê²±ÕçîΡY4ܺŒX«†>roº©®…TÍŽþ@1ŸÄÛ †b"tì†q=°ü•ºL•ŠêÌçØü”¤µ3FÂü}·iää@ÍÎ÷üNfÅæ"a¼%ø”t¬¿@¬mÒLòHûíÃjÂB+‘£†ÿtNËÖ¸O¦Hh,CÍá>»úÄI/݀Èqâå6[¹“¼x¥®‚© {„  Iñ úé`žÑ ìCÑàUð;˜<Ì–œ>~ŠãɯYÑÅšœ4v=0ÎÝœ=†J& ¾[ \²< $Eé2u'N­±çø?RGI5å'åþç©—÷�&ÖßfÍvF¿¡9ýý[ÿÐp**UæȘ €>ŠyR 0,?Nžù Ô# #S¬g%Ì ÷ɹ®‚ßÛ'Øÿhªþ ¯¢¾Oétíú¤ÿâþ í¬O¸ù½¡œ…1§êaý¾¡ºµk[÷ª‘y©ñî™f³÷îT32^zPHi"¶Øô[ߤeF«°³é‚ÍT3ù™N«;1ÔA‡ñjKÙþÝÔ£…­Z¾S„ÍÅÂE" ¥’…³ÎW`ª G‡œw"ïÔ½%¶V&9™\ÓÿÆzÇáŒò~4MdkÙE²AyÔª°,¤ÎŒîê åãêçîÑoQë9�LÄó}*$Ñfþ´Âð—cýc_ÿ¥: ,(Âvà ‰ènøøie™—KÂ�$‘Ái4ö’1#d$JóßûÈtKÙë¦ÖÆ5+β }™˜%h½ôË–rf„™Ûö£_xA¼ˆ™Û6¥·?Z±*Ø=óƶXtA© 'Ô¬®ñ*z¨Pöœ¹gZ|ÛÑöôª·ßRÛíŽë€T&©ñ~ê‘çzxG$ÕàIPº^\1ÔcG¥.ûX‚—دáîý#â™Gª«2gú†ªôWÛ ­Áp(…©‹²Ž¿”!A=lÀòÕÐ¥$*=³Ä´mÜ ¼0¸lq ¢ðFXðE߶m±)Q‘ÁëZ_‘é£hbôÁçŸvš£4S:kô'š!ÎéÎX­úŠ%qJ¢9`ŽMXˆðs>w 7²Qñâ<Ƀ}„r`´íþ’ÆÑ ÅÞÏÕŸ’ÒÌymb?€ÀJÑ1¬-ƒ•eþvBÁLdgtNÝÅoü”<i¯`'ªnú„íÝSë¦lD°?ôý£Gn¹ £Ä ×ØE®h5zÌÙÿ…A=FLØí(MƒrëÇÏR= jÎóš=I–i-@(Q®é™$m£\,À DjW;xÿ]}¯§‹Ì9Ê‚N¢O K y~у/)•J€¸´`FjqÅø¤ÍiÚ^XBà ýáÀ½Ž{îŠWuÄ,Âœ³Ì¢üfÏ1eÞ‰³¼¿ Ûx®Œ’D£\YiÞ îË0óBçÃÌNÅŒãÜÉÛ-RÕë¼5W,®IÈdÅÎx  6'¬±[üÅ»Éw•ìžEkJƒŽÕ ÙÊXÆ·;ö:%Xlû>9ÌÇôHÔ:÷N‚ çrÚX-ŽñÐáèÔ½Z8 qÑWëw§Ñdºˆ‰y²ÎT1‚@a˜òbÚ /=Ý+姜=®‘{/ö©ë•³áw¶Ö³OÍ=a:É´©‚ªW@ cŒæYm(©i3ZàWß“Þ5+&å¹dŸ‡Aî�paßÔr»·Ũµ­Ì/ÝëK¾°©‚¯rÚ{Ø}jµw«ieóuË|¿~Õj¥Ö>¥ï2F_z?)Ä´Ò‚ÜÀµ¶àпóAuòOâ…Q0·3rLq”G‡ó›€' 3C7+Ƹ»DvU‚ Ÿ¥2Óu® ¶²£Vŵą5çV(t M_¨oîl5׳Ïø+5§3ö¯ë¦Žõþ€†  %Pq–¯ò·âö4]”ñ't€õ]_(eΗëFj)$ÎÍ)¡â½í|aa£r�ùm½ëÑý½<¤ÊjõY°jDŽÙ"7þØ62í¸zTgˆ'ÌݹrGiºà|d¨¥¹Q(Eˆ¿]ÞXM~B5ÑÛ¹…e˜)Å•¤QÚ¼.€rÒˆ«Ø%zép0ÙéœÞ/Fa¢#Á ¯] ´FZn Ùwþ1O ¥bƒÁ@yÌè£Ètø«àÈø'×:\/XKÃ=p’vÏdCØÖ!ÅvT^%ÜFàb ¬µhá>™·DJÊ_tnVë$ Òþ|•ÀK?j†ÌÓÊnF]ßÃ%KCl ¯.ÂÿdY¦5ü)¥› ƒ³ý„"Æ¡î!Ü%…ÇŒ´þºõñ’p[Rx9,>_@Ы‚üèLFÑtÊz?%å¥e*j($gz°éÑ ¿’âÎ4ÜN?І ãÔÚ¼ jEågº^›Þ¤¶Ç®=#C·±Ÿ~p˜bi‰3“TžÆ¡îÑbšõæ)±§áQ‘h^›odÓöõ ÷@½ÁPÿ§qݳ2½¸ËiSU9Qê;JK—/â(:_€QÚ,Lóót€¿…RwbÜû x¥kX¦k9 r’‚iyØÏZ9ÙRÁ>*ˆÂªf�(‡d>Û®®lö•Ës EÛ%§3’‚4ëOGBh¤c`fj“$OŇüI[>B"6¯)g?)ˆõntr›‚Ô¬ÛîÙ„ØKèJq‘šòi WÇ¥^l ¨£{}'/~¶œî …ˆ³eÌÀ\GÅYÓÓàé› ¿¿P t³HëÓ�«w\ɦy½«íPèqA|õºxàQX,æѹ¢wM{{.Co•–äÇÉ;³Ð·þƒþ|À{É2»:1CÓèýÓs€ÕT�?5}6>e•laÆObc¡xv±/ÐM*sô¨ýôêæòöa±w®öty„“û;ÓC’#ïÄ$:>è¾a@dˆÅKsµ§Q?}EéÏ$bjØ©k·ª/ÜLì™3d›2¶Ó*ÍIzËó”2ÇÎ{÷PöÇ.îæÝ°—ÄÕå‘Î’V• ݨ¨,æ@If8¢;7ÛnSç w×ÿ¢—¦F„1 Ë*¬økíýŠ,ÞV>ä‘öƒí 1þ]K'RÊJ£j;i7 Kþ;²FúLOoZZÇ @óÛ°çX=Ù[¥àmŸøbÍ|í.ºõ!€Ï÷'ÿ\ îÙjSRZÚ�hèÛGðçHz%NíƒJ°ÕˆzÏæt)P†-Õ 2W]‡ «°›×çýOÚëŒUŠ½'mŒ~Îί¤—Ýk÷tÿR †DÜ›£ìpsJ(µýì ¼0{‡tðzmÏð`{éýûȾîaòÄ2ÜùYLj{©‚ðÔº|.¬Åê…W˱kY‰ïÂCb…6M;¶ _)þUÆHÇ9; †?/_<8Õþrµ~Àq¾³T§<ÛtK릓Q¾þŒé-‚ê}+‡Œ²3;¢dÐÜî«ÞG¿›â î"ψ̱S9FwÄ"«”ý‡6Lg)ÝM/§‘"—MÕzXº!‡Sk_îp§ªÄŒöS#7:î‹ \Û¾Qúzk�þD¿@ *—_œË¼ŒÎ°ÖÒÂdfé4ÁÚÑëvNl+­T;¡°? 5ÿ!ûXŸ’¯cMvH0i:|Ñbɇ—&æÈoi$=(ìš{";šzÂâ’z¦Ã—?y ,CûGŸùþ" JRc:{ì©~ølÿ²î×”åÛíIãƒl€}ü‹ð?e©G²”®` 5³Ê±mPGðÚ ‚zÂpW’i_4ÚŒã& ŠÉ. J áÿh,$ Zš‹ù½e«bíp×âq¯*˽ !{¢±õù¹³2ú0w@ù&J~ÞÉúa‹pÑ,ŒcÝ©‚“xEÕG³ö{·ÙcrÐëéÐï8¿½¸‰`™bS¥ŒHIiÑ4W}âø¡h fÇ/ÚÁ¦¹nç@µ ’ÌÍÉCÀ DÑ9XBàŒóZ{qK]Hç(©Ü:?yg' 9»;ûÎœi\ý£@v³,ÈUÍv=Ç‚9¯½ß¢Ì;öÌûF´3RR2ø¤r-úyûåH!@“Õ»^kã2蔋+úO¢”>„÷0nY#îä%i˜"ÈKßp ™xUk_—ïqåiΨŸ!OÉ}ù”ÛK{§<‡f ㄤÅzïW›Þˆš.¬AHÆ¡ÖYŒl£xþò½nè0_FHS¹1û8^¸Qoµ¾éÍňâÁogç­q –Dé¨ääõ†ÿ?-)›ÆºëwF½3º%þ¢»3S˵[ß)q ¦t}¡¿5OÞ*4,ZvÀ *Ü"zSÉs§‡å‘¿9,ùq€ Dg‰²Y‰P£ô^ª”eñ½"º7èŠ fhþ„ MgqwŽãa:v«ÙãI¿Äcl@1’†åiâñN1‹Ëzöû¼å"Òw&åGÓKÿœk˜¢Ëã�™`*­Ò:HºÆѼýûV˜c9E‡é­ß¹€s2Çùñ¶y•*ü=£Z¶˜\´½É ½¹Ì,àŸ· #75x±ùï#»Ò}cRW·õ^tËiI¼±˜˜¹þ×/¼ [TFnž¨Ø«>-‰u�¾ ËlØKŸ¾:÷/•ßa&R²±…Øcï4ØrŒJæÁ´ü¹K‚Yá]Éì4•}dúÛ4ÈëWòäyÜmÔRjÆÚˆ½Ü\ÜÔQÓ@æ‚­ô´<æ`“r1õC{´(]p*Øp# Š÷â£)¡oo±ûs»¸ÔÙ5ùiH'•m|YXOÅ¡Öxì,ò¡JŽZCV!Â*™Æ2H? 2.Öaö‚½[&ØIáÕwßI䨭9ºö å–†E 7=øMU.]’WÒ÷*ÖkpϦÿ‹?× qç5Bmæõc­-k}“™}»ZgAæÌÈ2f tc}’°ã±»Ý4JíNýº»VwªÛ;`Ê4XO@Î0YÀäiEÉ¡A�âÇ™ª*¾;Ží*Ô\"‚”÷¶ïJ3m{ Úb:A2ÀÞúŸ×ô!GÚž¶“ì¯ncLiq/ y�3†Ô³¯žvãKZ¢Û`SìŠ[^'ñwVÜE¦u²èÎÑ·‹‡=«X:‚žæì„y¯'V¸]w-ÒSåe0õ¸ÍéÎÙ‘Â W þóFkÁª&îkºûàÀ›#á`rÄNeÀ8BšC†§˜±c®@Óz=5àWÖ–ÄÝçÁ‘Õ)j3ÀÑE“8êÀ9*Q&�:I«­›_Œ`¨ßÖã>ÊÛúÂè1ƒz¾¡qŒ5¼e„к³ q:‰È;¸‡“†|uºoý„OõüÆølÅõN´Œ³÷wUk:Þ‘üJª8/ÓPØîQC+Ϭäù¡`^*§àöà‡R9`‹t„9R½{ISÅ%aÎeC·9þ´,~ÑD6O–VšÏô²`êǃH¬‰–4؟º¬H’á‚€M šÑ’ÐP|g{ +…t}þ˜Øx<‰¸Íc6}ZjføÅÁd*{¯ÄÓ\Ô@v¿8÷œøD”Øô`JP:´*¡X®š8p ãs ßIB×uéþoK€¥oPËÓ&n­DyÁ®ÐÄ-Ͳ‹lCH‘CÑÂhþšC‹µÕY#Û ìâ–´8îeSq•¹WÐ b ”|…nð3Î5I\~@uÚêt4œÖ;Á#Îr…øf-Zzëd3Y®Na 8Ó·2šûIB¯¨±8Ñ;eõm+ƒšd½Æó˜S'Ì€¾CSû{Û%=´çÝG·üá$ºÔ }P@CŠ–Ïk弶¡¢‡îÄaÔ¥.>9åÇðqçYru—ë�€£?µ;rãÖª¦</Øwˆ¶÷¾ïv"Ì$TÚãô\aËí;«…’mäþät�»´·à~d_:áÓ„àG×è½ç¡’_†XëÃÇÍÖûL¯vãê´›=è`óÖÕWÏwËå(Vú º=ö”¼Oš£Ýw_µF.ÝŸð°Ö3ôD-æŒÐš¡»žé»-©êã±7·ÜØlÑ/á_ïFªëÓâDàðp¦JïQÿn—;ŠS?îâêgUSΓ´e‹0§=¥Ç~(´‚²»d¯MÖ]GU0ûô†#`£_0ždL‹”$ÀxûBç)JüÍgb0äͲvR¢R›Zh8 àJmÛíqF·/K›ÅºsÎ[¸ïò‚"å`½&щ; šy‡-e< €Ÿ„®Ä~!í.G··“Ü"ÓC9`Á‹ÍZ‹)‚nh × ÛHÊÚÉS_A�{œ˜óJ(« Àl\¾ÅÝdr‘6»š YŸúûh[Cç�ŸIëhâYÀ©°¤ëÎnê– ¼ß›y¦w6k˜'—N=¨´é„O­ÈÃ?0L.âLIêDF¬ o­ÓF“h¶ýó–GµE‘­¤#e{|¯…)oBž™"µÉ)uu‘$e/ÿEØŽÆx‚Qù8‰b‹º¼áZ/Üâ$OK+ ̹­EÚ–Ùßz1^hQœ”,ÕµïâLéµ§Ä ¶•‘M½ãÈèz¶û㜋⦢†[$¥Ž1BMð—‹?pýç²L pÓñ®‹ [C„ú ;ØTåDU.#b)'Ú.0üUó¢o ÓIAî™@XÝÎj|Ï}q?Çû-ÎÃ*ƒ 8ô蜛;k¬©J‚üHƒÀ老ìÔ¦»,‚Ûô>ÃH{8=&ª&u/Þ£ƒízl x£üZ­«½ä[‰–¸x_ePk?ǃœ0<nsnþ½m7j ṡS ŸœàPЉ¾êè\3LúÌì„æЛó>Û8ñ€ƒJ©ûf­0ìó›Œè•¦ðšžZ G%w&™bðر§Ý“Ovd€1° ô£†-…îO½Ù±£ñ7©w¿fK¸2ƒUܱ­!VdH œÍy<ìÄâ+²©ÍL¥?,.® }(CÈþ€4zÛ٨ɉ§Õ,¦(´>xÄíæ0 ŠìêuA6,½²#k CGã8:šS$"¬F÷òå–ÈB]_—Gëéé JÆ?&aß<Ÿƒ» Ê«tëO5…Øv”tö±®ºA§òj‘ΣÃ|Ù”ðÛ_FÿI´Û/Ë|Í#-ªè³UX DEz‹â(ìiÝNþâ¡Ð¡¨#3;hÖ%³=#WM›G‹ïŒ,ȉ;ç%Ÿ»¹X íˈk° w¢„ËÕ¹Ð+:–¾àÍ6ʯïÃcG#(|c¤ ²õ²G+••qÌhå•&H$ºùÄRÑ©¦ûœŸl®@÷s¾ôµ*³¤Ti|t� |˜ó¿oXôoT 5‡ùÎoTÌc)·0¦Õ(ž5rƒiÝI!°°"â™}=Kdûj¨½ o™ž2‰£ £ÉÂ~p‚Qþ6NšéâÿüÕ Ç*_`­ÂyH¢ ˜œÇglðÄtc©xnÆKgBWœ ¥âƒ M±“Búu4Ç7í·5%+ëø÷ˆ¬†ÿ`’Iue™Ñ»í8 lƒíŽÙ˜Zo&"‰‘Á¶ëáK‡&¥Ï Õs%Àмã! *‡€m0î‚jDÉY#Ì–qžäðU—xÓ¥Éf)„HOObá¥ÍÓz̆'m~ƒŽH ˜mqT§Úc¯}šßćØj`áYÔò¸ó¢å—Õžµš)9–—²øâ“^Ñ:‡Ò¸ˆ"ü7°|…ƒSaEÞí™>­é#êË‹:ö‡yz‹¸©ÌþXàcùGJûë£ïfÊ´`,CÿÃ3ëÊz#ÊE2 7è™Nÿ4i„²ëoäl^.Ç8vØ ô†h»ã2‰­OƒÕ_ÿÇfª´’£(™9†¶à;wõÊ"ùé;öݵ_Ýš—ŒÄci½s˜ÈƒtÛšÇÓõ{ÕíØîÐëFeÀ–TÂé¿-"Îr³Ð«é t¤xQl-×ÔcŸÝL'r#¬ 3b¡/X¦;˜X\ (åê*&/þLÛ²*DYlÞK‰]¡ººa‚& I1hjK',Ð ®¯ã2ëË$$p{Ôô^³=uó82�y&·WïÞ£7fÙÐ~!ÁôßÛãpÍ5ͯhúTÌö<>vG´·î›—ÏФÎ)°¢ïðõ©Œ¦7N0÷UUy:“¨s75¸2ÇÎW½kºuõ—qJ«G›2ëKñOëõ®¿ÂƒÍõƒ¥/É>1hÙxáè¦6^zxÀRôp ^©iiÅŠñ”9'ݻʪèÁ-œbÌé5ÖS7<u“HóE JÉ!ÈWïgDZ˄¥Qp/ò÷S­›¯˜® ’OûÎy-"èè%Ýk[‰Äª°Gܹ!¼˜› ãÂõÑŽv”—…Ö•&OO –‹ÆÞ–R³g^¨Kâx¡ÉÁJTKƒ­† '¤?`ö‰¢Ã¶A­‡é“–z䀉Öuµ² 8vJ¶’Âäa|Uê=µšr\ý)cgŸ¶QŽ6Ô¾÷Õ¢-Z7}wÏ»H„KæM¼¾÷šTAYïp;e¤7%¥òÙҶs%Ê„hf‘™è‰ý¬'÷b½Põ¢(ÕŽ À³#Dõ¥ˆB•¬ ¹Òˆ¡¬jm¦÷®n¡Õ‚{C‰Û¸‰Aﱈˆñíà´û)”éO´|ª(Ó*~0󣸟>µ¸‹ð/Ó5,²d_åãƒÂIÿ 7Ä:öÉ›ào¯kO;£Xø!ƒŒôW@ãþž°9on7@Ö~jkúÖVÌ%ÌßgÎqâ¬Ú×ËOé®ù�WÖø pMŸÇ3‰²oxŒqa„þ¤ É„ŽîO8Xå)>Í”ˆ£kñ’^8p= }E¨Íx™;—ÅW§¦’H¤­ÐHRœXQ“àÁ©UekLo¼;&IlÝ|07 1§æyE¼xX 9‡™Ø HØi°y7‡#óýU=ôà©{^L7‡M¹š*qøI›Ö7'ûK“Ýë08ƒå~|g„qû{5쉙Ș�ÐK h>ÕI¼wÊŽÇd¤4ë–ßm¶ƒ~5ž\L*Ý4>Ž 6$“røòl¬®ßý­¡‘é מÃÒ¢ÿ¤Êë !Õ‹eµ[›S`NX÷—ú‘vP¸ÚÒ‚9l‚ã¹ï)ËÞÝæKìX€éñQÑ2Ù0Ç¢!>KËEÿÌcÓbb¢ÈÌ®çº ¢á]xÃíÊeR"7dág<‘X©LõGbMˆŒlÄ„}t ^åÂà™ {Qy¸W.¤Eè8–,s‰©˜ŒªÖØ1lùÑ«r⪌ G{®¦IÊÊlŸñv¦Ý¾,ýë‘í’^ã{ÈðÔy¤lP*\D(JàŸÔ<ø‘ÒÞ Ì&ü®;îiÐÖQswÌ‚dºXá&ž8@Þó�xËXÌêy?ÁD*XU,hÉ>‡ËåÌšÿµ ߎ¯ñíL/]_ùWœš4(§£Sª ÙÏ[D¢¤ÛÖ—n²ÿ>³c)–*’°£´r²D\Œ=Ž’ æ"½ž]¡mFÉ z¸GG˳+u$Qå—OóÄ5ƒ*Ë Rae/åR¦zÖÇcl±F±ÚÀæÅa)™Õ!°p>à<VŒr4*›ºa‡ÔÍôQ÷2Bî{nrþVçÑÅEéÁÐ@¶P¶Ž½‚y†Q¦Õ¢±'O“…j‘,S6¸ÛPµ²^›¯º©)G¹e³Ñ$‰ßþ¥s<:˜-[QŠ]ÿbš,M»#$ªÿjzý®ÇÌÎЋE‘—Šd“¨iŽØV,´½©7C­?u¼‡ŒŒÓlA7­Õh¤‡«±·p¹¢‹S߈¬X JÎ ¥ží®aå=±Áñ-÷ïâëÄýJÍE'k±‰V¿TŸ+—:ÓÂÒHªÂ÷._��y'›Ù_Ïm™ûÝY™ÎÜèËí6•òR†-"=–Ê„cTf꣒*lVwù,z³âžºµ®Åt@­éÂsÜ[ŠX3j¤|¨U–C™nlN¾-üŸ‰(CmŽSeOë*nZomŒ6POç»:@´‰v´­Î%asgýÕŠÈ™7ŠÀ´·÷–gã§ãf1oø⛄Ã_Ò hª|š=\8âÒ& V�£§ÛÑç§À‰ÒÙ{&´X¦íáøÿôáÒ7|EM-¾Š'YpþS)URˆËI½Ý)XQ*Œé¦J‹“ðÈÅ‚À\­áñ”Y™{O”FÞ¦ÏSMÿvæ@.‹ë½é¼È/Râpb2“À4 *GÌKb¥;ä<Ubê;ŸÛÜج;úðÉûÖ[ätÔ(“[é ¦öbÊgÔ_†åæOLó=ì@ê*7‚¼¸ŽN»^™@t•dO»¾ãmêuxsº‘¦Épõ£&5FFæx üÞW&Ü{¥§ºœçͽóðÑ)éj]Æ Ã¾uS›š+ú阌LœÁJ¾½0‰t•ú†wÿôA˪·›?/`A…TïÍÿÒRÓ½¬j… clˆû¯KJg±(­¤‡? TÅëv_wÓeuÆôÿÍ¡k™UsDT¸èK /•ñkm*z·U¬eÁ‘¥+­oÜŠV·}v½˜ÝOæ½îGj €a×¼[Ý5´�¸Q%ªeöîÿгÁ÷ 3»ùFàôÛÖË‹ÀYfÃl¼óV_ÏäŠu†@O o­è4˜½þ³Xø_wa\ùs«´<ÔLpœ¡¥™}ÚÄg5µo“ß›x?š}k‰­„-~?¢X‰è³-ËÐUg7Ô…Gô~1îk&ðyZº;ßCóA9xr²éLÌŽeèþòÆ•b¾y¿¡“{N¾˜z4uÆDˆÄjÐQè¬ÇÚÙI®_²Üúž{7´»ã¢`ÖNž<)¨û’êe›é¤ÆÇÂh«<4 û‘'¹²60G`Ë‹¯Ù[R¿Ÿh¿tJã†îŒgs—KœŠN˜*, š9ͧŸÒ„…Ô¥•Yèë‹:|ÏëL*ßp,‘ŒÏŸôöåpòŸ©W§ÄÅfú[f q}i%^ F)¿q›*~{+D‘ÕÈeÇñgbÎ.àFÖóB¾»Å7›ÇË=¾@¶�ª°eZ©p«Y-#}Cƿ̼÷Óö²§œ¸4º¯è~ÙÞš•Œ<6FÞoF™UZl± ˜ª`ƒµ�@‡� ’>#O»E&¤Eœ)nì?’ h6ªåܲÀ¬å4}7¯`†ÂŒ-â;|©§?!š*áõ§û*‚åµCìr²]¬îK–€0i(µ,[ –\ ŒÜjbÄ°¹lì8ù^›ÓS SÃý™Îè¬|6r˜oW%ÆȬC«NôŠz]UešV«¹ ÊnãË=Gõ7úÊ´Åð±mOïúgZ¾ähÿˆ–t`”ÀêeÛŽW]à|·]APf3¸‹›ƒWyžbÂدHXËäׇ¯ .ç‡8ÇËÆ~ii�ÖÈ›åHÓ¹³66hIŽÝb‘|¯Fšx'-v<ì 8W¦\î ß>­µ�6d£'tfµŠ�٠٣bœ-–æ莞(-ú䇯"HfÙׄ åÇPxµœ]íõüîÓ30Tõ;¥¢¨ŒâÜ%ÕÙp^øt¶+8äd lÈþ5û4]¿Ê„ŽâÔpÚ§‹F]T´üÃÆ’‚ðH:Ì'ÆM@Ž°Å ÿÆ*eEìÑa,b.æzPà(1i¹€"<Nw‹ÌߞʨDäåÏm¤íÉ2ÐC&¹ì½ãCCÑ| ÁAŽý |˜[yðÄ)ö\l·tüŽJf¼P:è%.kÖ›´¯&vó1aHÿÈ*ìB‚1U¯]žÕz£Ì½(5êÆww¹ã<ðü¼qÑŠ ¸™PÁ#_¡÷vä›Aiœå Xô×&é¯Q„£*õ{šQ¤ …ÿ¤³ð³íŽ1¡¸·ÿ¼EF|$-.“Üý6äXÔfJ’ X¦úüR`:D¶õY–©†ÈÜÝÕ^ÉÄŠ#1ìÏ·J cËlÙn¶Ñ"ìòZfç*¯ÜtZ†‘Þ?×jpFm“PËöõ<ƒBÇ#ÝöNÀmÝêÃ>\[ºG º/ˆ±==Êᯭ\€¡ò†Iß<î•ÑRäå¾½E5TâXLÚ¿ÍV4Îü߶Íà™G{m½b¯—ë­Ã®Ÿn ¥:ÓùJ}¬Õé7; ÙÍPÔ°†]¿çöÂû?ú‘÷Ð&*ù‹aTÊm}V>ec X×ôª>Lš/4´iw´Ð•~2±º>M¯¼ãaf…à'…¶N¶¤×S˜ òîèóþæ2Úné}MÕ;òª~ô"÷£DuˆIð_…ÝçI†y©JðñªFÌ”ÅFÅÓJÆÆÎWãâàÆÉÁ«LæmÛ6jù(6OŠW O:„îðÂüìŠÆ»LíÁÏj¡ÃÑY‘;úI¯B!ÅeÀô¬'Ø«Îÿðì ‡Q¦êTÞHPìÕb(ÇÒ Òó¦ÛÖõo†\Ê<îåÏö—ëµ Ì¡qKË´<5ÎõY8ð”8¹¿ 2ómÐgèÿ²h¿Ô$†õS <w½VØ}ªMuáõSx®£i¸nôŦñ«iuàÒÜd„ öÆÙW]ÞLv’“‹*pÚ¾£ Š€Ts¢ëâeï_.‚•ß;³Âau’8Q# \tªÐó!CÕˆºó”Bƒ¬wŠx,Üs%R¬»žu�"ƒ 1òÕá búÁ2'¤üÀæú«“e}[3U‚J‚÷¨Ìˆ­ã¦„«¹¸°œ[´[å£jÅÈì ‡LÝ{™l[ ¸Ë"Оþ=«±P<b™DÄ*KÏ2.ïþ�Jd›«öƒSînÛì&‚"œOÉ…¥{ënFÐà˜nlÆÉ¿õx¤]æL ~¼Òb¡ˆFUÎÇŒ.èñ] !9 ²„ÝšMÖÕ˾kUžNy¡d]šžq'ŸG+®‘ìªâ‘Á´ÙqïÍËxše‚f^]µë£‹`;BÚVx ª2c;šqͧð4á™/A»Ejß-âi–hSÄ’*°£«•âï~7Ö ÅE°e”ºß«35,>Ô×ç;Ñ(r¾'‘1—§j² OÉ<lÈ®úzoqŒtZ]ýh–ð Ý9ÎÚż—èQ¼ÛÆË/” 74–z`/ßÕ©ï²&îtcœPdÇç54¾þúyšO�ÄJš…ø@¹ŸˆMC”;Ú ê|I¹‡8Ñ:éEBÖ¼RÀå±ð™º>û‰â@®%dXù”>ç88ìD¼´ù±óêWP£4^Ì‹#Œíâ œ&7¦ÈtY;Ê­�ºµ"“4M}Ü4LýGeÐ×K¯ý!Ö á’ªÇ¶‡qî0%M]=�tz[³Ê®ü.QîcεtÚšNÄV¯ôPJåÁ°¬¦¥7 ßO>ÝJ»\VenÝKýçP!Ò**p¦Š×®Ý³“i5b`³6=âçnTÚ—Ê éÅm„‘7 ú}T݈§¬(™Ì¿Ö™ëŒ°yõÓÒ! ÈDŒ-ú“o¥ÆÚìcçUüS_ 7 ­ðΣåØM�³’¨—7DTDÄÛ_óy–½»áTDq¦»Cz¬`:×®3}“ÝxEµyá±–ŠYrñ‚¶fc Y~mµø} PEúF�Ø•$A5:Ôo~nG±cú‘{£[Ù2_@�´ÎÖ%±¡óFs]G üÄ®_MÓKôZM…wÞ9qÛ,°!JÚ;o\½˜É‰Ùl#: ¨ß6h‰¶ùÞÕ®vÒÀƒ 3¸z¥/i»Ø¡©%iûæJ0Ï™;Ì«£º_ð¢»<y™rG`DzyÌ‚p´¢uói¤ I'rèŽ>áÇnž/Lþ®7˜4@ÿ¹bûEcŸðžbA89âWÍMëM(é“>:¹±¼‡¤ùžÀ+1ÎÎSÝü3/vø\„‰vާī{zV™&¦ñÓS¨rZ0€Z®øù9­^ºiÖ¤ú•Î …«Ø…q—mzÚëéÖ¶íSÆ£^¬òüi”ƒí¡ê¿ö1Îð^“óôúß•é¦N/3#…If/ÕóšËpë˜cPFÂÜÂ~Öî,`ûÇc±B 8J ÖììÌ°=¿�Ü ýùÄ=MõIÁæDÏ„Ó‹<ì;I¥  6ýä½}¢ uõâ¥s'¨.èê&)‚ÜÝol2Z¿üé–ÎÝõP`>‰V3°“ß­›$�p3yâ`œG�eëŽ9ºa²—ï×)‘r —<¤ZÙ»4Ó§Ç@œcDZ1 x!ÓòcÀÄ$(]TµëðÁ½Rð¯åÔó;ÇÕD5k ^ÊÁ¢<m5u‘n‡‡PØ8ñ(^x^‰$÷ú$/½W‡‡ô­+v1¨^è@f¹Ç70Âfþ,‚Ø!À÷0Ö¾e?IÞfg(r–C¾Ð¥4Ôôˆ(4Z“#ýìmØ×Ó ç‹â›‰Æ×aumX…æ&èÊt@¢ìq4oÇÓñHŸ¿µ_ÃvB¹¶Ý(ˆ×"8£– ãóT·#{¤þŠ=·0!ƒðð ˜Óè˜Ie @#ÍwÀ•ù‡Se;µ-=i%A<5n¬ 0ü^§MðÅ” ûZ]>  ÉÞêàüÿ€‚ÂûFYVú€oX*=øŸol*…½dÃ3Ê‘MmdYxœb·ân³œ± þÖŠ(ÒÌœ%e"´ìˣͩPˆ»ãåê¼Ù‹`Ãͳ+-¨˜Ã^k³*(ÖGÅ÷ÚwÚþ¡€>j}A°¥À÷Áè@ÌÈÿÖ@0Y€î ï_#%löJÙ¶†xLþWL@6AÆfM7Ò¢JRÚ‚bŠ ”ž³ò¤wèÚ++ûgX˜HS°XA§gA0×ÑŠÙ™UÆ`pSóVz¦ë¹fœ• ¼(yȶ[…_ƾ;;Vî¸[+3©òñóJw}Yt›Ϭqm–�þU×KŒû=A.SïÀˆʀjÓšfW’ÝIü.ÙÔ¸SÐø;ì¢2Óç0ï#â„Öà€sÄ:a‡ ïà$͞ן -{žŸ©Hˆ·V†>ñ¥;³tO–è\æßûI¨;e—‹®Ô¦Qó¡ú•=Êa©ßKJE…iˆ1O;�‡6ÛÔ&K-Ë(ÚõYœi‚ #~³Îb«l!ŠÐ+àâÚÃÑÏ«ÛÖVk/{Æ™Æ8PirúqvV@ÀœPHçŒQôé¾Úâ3áÅ\[±¯}³M‚b°T­ ¼¾¶…ð‚V=¦ÿó¶Ú‚Ÿ`Zvˆ•2ðyå¿£%xóÒÑÕv9Õn6ÝÉ3«•­%0‚&~òð†u;]9Çhi„¹ÀÙL–]bý!4s™S‡©¯Ûÿm£=;žPÓ7ONØ40b[žOôs潟§lRGO=)y妯¥CèH$Ÿ»ÀòjðJa_‹¿µ¸å”-v:tëè.?³Wó;ƒf^CpȬš#,tïH ':µŽ‡i¦{|à{,éÁ0Áâý~’e™–Ÿ¾ŠÜ´o½bÈnhOôîhsØÖ(¼]{·»3ç ÛËø6_¨ï¿ù‘AZšŠnôy¢m>~©Æ:-ÈKOÏΑ¹ÓðÊvØ$q9˯JAO'¶b:œùœ¿³à–»ëî\Vj×oŒê§5­|L&ú1 r|FŒŽTŒ¿Ñyˋ럭²„›±ÊRG‘w{qj y(£‰ÕÖ ï_åE¡ºfVy³ /-hüV»7*Àq—PfJ&¸CvÜ5͵œh‘gW\ ®¯;Ôè¡®%¢ÃA§Gè¬~[ZUNÒàÒ‡˜¡«±kÆ@}JXiÞ^È´{n.–bMZT)Š¬¡NaC@è˜QRg›r?ôÔI–È[HÏ U³zì8ÍÒÛ5?Q.Žò"[6ëšzðdª­éO]c!¦[hØÖsP¯V¶TØ^†–ù´K—mU<°@BÓfAè’oŠ]Ýq,0A,}׎léLÇiÓ£ök¬rbÕbíø˜ÿ/d©s…D—ÄþH'_áÄfØŠ†3еÕ|¢¿ÊÓµ_æMÆPi~¥ÁCÖ˜eÄì*Nü€Ϥ8.½§vÈêÂgt#/ÞœLÎ#ó¶àì|T]Ž»Õ–å,dZ¶EiúD܆•Q…V[y}ò8kc×ÂP±øëvý‡ëwƒå¤.¦0/}KúxÈíß'ôXïæ¿ãi»f/t™aßÌÅÓba£VÐÊ®x4«<‡‚‰wþoüß)RdËáÛÔ'A5X. ÿðÞbö®y-Cgg;PÀ `:‹¢s÷×~†¹qUš¦2;«äñ ¼ND±ÅÌÍꢈÆçæú'ž—»Á“uÓ¹ÿLÛ±±U=û•<ùÑN½úÜ› “ƒŽ5pŶSkÊŒ³ØôA«·÷˜\˜ 6£Þóf‡³¿x„y+U£Áö+e™xÁ* |Ò³?EgäÜ™c>O ¶õ~bFE§]èâ½ñŒ–°ý"˜fLPºÜHbí\1vJ㛹ç"04Îëh€ÆÞ§›-ª)‰V~-2AVÿš™³s…]ø}bÕ Ö]/_\ÕY,û­8J˜ŸäìÜŒ;C™1¯]¢Êãb«*&“ñ˜Ž. ƒcq½"ýo㔚Œ¤gìéÿŠa£úÏÒNÔŽu?‚µ”bÓëO© †çڳⰜÝw®w€ë- ,Ï,Ç25¼ØêÔ‡AØ»~h©¦æ�Ë%ÿÈû¤4Ý¡*EÎÏ/6 媹‡3ãà™þ– F5룠ËÁQG?Äé ¼*; i F‡Nˆó1+’@ õLX¶»Ãè8¹×›c)ó hðÍ­äpZ{RZCÍÎÍ÷yN hïÒF"U,1³GdAfw8H¦ˆ¹E|/ƒ¼9)]ºƒíoG!ôYÂ*Ï-¯!ßyä§O%ʦʂŒÕ?­è´<!™¤ã±ï.ÿî†E7ûúço¼·Sn(«tt €€½Ñ�h¼œãáÂÝú«×Û{•IæD¸6ƒ¤ ´Q¨{HÓÿ„k£ÂûÒ¢÷J™‘iàyR4GÕXez†#�¡9™x÷K#¬$ήz¾P”åÉ~+´·Ð1˜“ƒ|/G’8xˆ�ý±Õè94wÞ­ýîzzåô™"Óíº∅.5;Lç‹ï†4KE®y™(!³çÏ­³‚Ç\§f*;í)Çt¸¢’EIØØ·]½Ü*ÕäWŠH«3J«VŒN’Cb´°Íýåê€9“™Y¹‘*d;Ø2ÁÇ\áÉÚÁj§ÂÍZ'íŽ?éò§{Ä(7ç|ɸ)‚È»§$KݼEÞ²ßqìÑW]´í�|µ¦›‘´5´B;¡9ì /ŸÎ”7Æ`néî¶õÛê2 ‡¯×ë{¿R :cjW`üPPªêº¸-í@ çzßÄa=|x0‚pëDÌø(‘ÛÁb+99 Àzšv“æcÆGôÙ±í¤{Ë7ÿ®zLl•R…ÆGõãÎzèrøâü?oQ\³x*Hë%( Óy…y‘-$ó†ŽÊž¯rÁ¢Àeí 2!‘’ô-ŒÛ#Ë9äÍ»éý‰Vœé·ˆ¯°UqXª«ÜôºªP;­ÆP3FýÞ8LR`¡¾6ßYï�¿‰Jê˜U:†‘n}Ú¶Ê*pîÚÖɦCpWg,§Në9jEláo % ý×Ø ®ö¨º9Òt½úÓw±ÀG‡þëâ±é>´ £Ó s.ÀÞw§IÍ#¿mˆ¼ìŽƒêt”îå_KÚ5}s> çgÚBæÕAÒ9 €MaÚé·*¹‰Èè#8²‘fÄêµÜ€Ô‰2„Ë1ŽT {Ê YæLŽDFßZEýÇÊúQ¤ZV}mê4HG«ÄÃòµ`[š3R&ÜÃ= Ïïµ¹“¢X, I/g'Pp'Ým›#¯±kË–¹$u¸Ìb_9²¬Àt Z¬-¦6]Š¹³Â}�¯¿ê.V¸ß¢®›>/´S=e8Ý}xÏmˆì³yÃ0O€­aòŒ¾”}´Äx;>šƒÔ€á»Ë-y•P.:éF…ñ¶:8ZÝaõaΧà»Î/¾FZ©ãá âW5¶I�q Q链î·Ê}™gêIÃ’µÃÚÉL¶7f¿•‹µ'in˜ÓAz² Æf6&6§“Çû^#/+M€"h·ô~_öóãìã2­G“× Ñ÷î‹ñk311a -2™ª=fê¸ii'A¯ç2UéS˜GÓ=ÝŠÒ™õEðàjO^bîÈÄâ³Ys÷\ âÊøzñ§å’Ow!ëlKe:¡<>0¹Læß™žÛ£#w§0o—îW?�:XCòµÀéQãœÊ}yñ™ñÌtÔ¢ÔˆðöÄä§zA½mv*„ŸwÜ™ ð”#×üæfú›”¡v 3;}t{w[—‰mkwnOÉ Ï÷:ÂìÊa±ÿ.ÞG#jáa7Œp\êØ4Ä[g† »4ÊÖ—$([×_EVŒ“Íàø;rš…ÝÇ¡iÎ#4e¶^S†6¼óäUªväÐÇÓx¸ë1—¥-oq”sé†ôãË¢Y¡ú¼ë‘’Z®Wj¯+åWÊh•Öàõ™ž `^ü`Ìrû<âÊ^¿/:}¦ñB=>6þ2ïµoët¦"¢îÿh]õï->¯04Òf�ƒ¿uÇ ÏÎ2Ø°îÞh1³LÉ7~Y‘-Ŧ‰j‘öBÿ”Ÿ®: ‚DïÎ žFtd•ü ”ÔmD¾1¸†°MNVç’Ê“Ù5„CžÈ§Ù¬kÉX%*q¸û#V:MU¼+B}(ò}Gÿt°Ÿ³>A•2óOíÝúI­×Cï³U˜Ö«­¢ªÞAÿ>£*T^ô#g©6v�ÿ:©¶’›.³ëWHá³øcðé|ëÄóÅ\-™±ÕBù—÷ýµ|vx¯ZÄQp9Õ6z;)J^•·L2m¨ôÍÄ‡Í òĨ'¡U$V{Ç[ƒ˜—GÅbjC˜Ûôù¯Pý‰ÊLåæSæû—׉t¢ cx­¶ˆÀå±WTCÀ]Ç‹BQò X÷Œ“€}/Ü1Í·ë F‡Ìxav¯Üô‰–ûðÉdIúß6rÀ?w±Œ•ã¯Ôó@Ÿ<ÛvÊÝAÈì>ÁÏuœ]j_­ "­ÈÈ7[`ÈøÚCüáÚî±! Û]0ûœa;ØZÿÐwP#\ððÓÜ 70ðxšÅt5É¥O=L.ë¹ÿ¦[ѧdASM(QNƒäè%€¯ÖÃ|iÏ£éÂpRݱ1ûÀ ‹«WVZ3ÃÐ û. Še2Âûñ FÌf•­ùSŠ›SûZ8oþÉ(ÛߨÁPs¡ „EÝ(?S•&Kû皪®ªŽ, š^ɶñOÝÀq…iðÏR_ÒõJ zI™®/p€Ù(AÚ˜gŸ˜;‰…ô¯ÈóR»1ìPÝ ÁbÂÂã¨hkQæxPbŒb執¼|û÷­­á2fùû0Ì<àÿ>Æ…×èÞ(Šý)ÀíësÑÚYû†æfþÎR[vÙD1$ _@Wkm/þ&Û UÏ…´|˜]¶Å[ÎrÇnüÝ«Ûp…†Z÷úBßaÜØ95g¦�ö^Ë ÓpÁ ¤øC‹‡ìf´áMÆÓçiá_ÄpúŒ­dkS’«ô$]ê/¡óƒ@×éI¬ƒõo]…rû ò¹²~,•5L û[ [«¿Ä°<Öyµê-y·´:ÌÁÇ@ÛEøô k•EÑ—â”­(A®Ýì[|`ëŸ 7ÂE$ `µÕª·Q3åÎNäüPgÕå™N ÙÒn̶Ö- Éz×Z7Vmž°¡G OoJ%!çcw½“|»=6éÎêPÉ`SåM_Ot‹1‚¤‡ï5i¥‘]áû®5¹Ô¶î%Ð4#ä”À•÷’8 KXŒtU÷G5Ëe¤t’Œýò ™¸Å´ÈõÏ^N÷­1Æí¡½ò™Vo7|s€<O-©ÜžÀò'¤ ¥jã37,;gOŸqÑ8ŒÓ¯ÐÂ+¶zþ«ð?Y±èÎR¢–Aü®ÿÌÔ­Ýç§Ãb{áZò^%™‘g¸”<˜1*p´à’n༩úµ‰ÿYªÛI1Æ%íÚÙ}jkBJçx{($?ÒM®T.UàΟ‡„÷Bìænm}t¿2ó;è½ó~ ú€#†Õç`¬" qáZÞÔÖ»éÙŸ]ÿtöáZ3"¼±:€PaÙ <圠ìÊi—ݽt­4g³ cþ$%€Ï¶ªßþ!·qÍ]ø¹žTš)?«4ô§‚Ò^!z¤IÂíVü½æô÷/°7¿0ØQ§”?²øÁù"Úµ)Ï¡ŠvP8\ãô¦€o ¦c7£ §"sÔ9¤.%ÏÕÐ3ØpÅ© möç†ÄÇ,ôk'eyæ&¡ Tk;Äëz2ã, `!“7Ó×p½†nìΘþ-» è`˜7åÎÙ±‡ó™ •hrÒÇÀ_¬]ŽyQf¿¹pÒ$Y¼°·K)âR8˜CJ‹Xæà0½Qœí†ÕxÙ÷´gœê=æO2ïT‰á±Ž7L «Ñ¦bmiá_|ËçѲ®¶5Y—m#J’ô®í'B²ïOy׋2Å!²^³dÛn¡ǫr¬/ÊÃðûÅéÝdbÃÏA›9>Z*ÿŒ´HgQEçMh2wÏëÅÑúmÐÜÓ(7'óÀ`æ3–½0"áol®«8™A€kµ®Åt¢mÍNOUºÈÈ­<$¥·ãÄX'ZÑ’·,Óߊ4SBP¡¬ê¼ÝlŠÿ2¯õî@–‡p»œL÷á/�¨ˆ\÷%N!dGX[¯UÃõ% LŸåL£¥#)=}Z(0 Êw£ %‹Á,åûc)·öÎ¥õ$<a†ú¥*2‰§<㺉º€ L,°·óÁ"ÓÓÙÖˆ¹G[×D«¶P´^{= çœ_« Da¬!\@ñ³¡÷F9žÁâ¨(;þi_.²ƒHé†ÈMéoÔöo@ÿ¨ƒ”oͧõú'}ã$-<?‘‡m›æúëÙÀ»æô|Õà*X×ãà Ÿ§iËÎr‹Idª&697:¦0(»³R‘ÛŒ‡‰ÞÒxžâÝÐK~Á7I¬pd;íÇýíª¶ 0z½‰‡% wbò´íþ½t°'–]YL%£²Ž¢ð¶.ƒr>ª¯ÄÃÕmlg¸¿ØWÌX»ù®Õ¹ï E"uÅ#®‹ÕDC~ͽiMqÛ½¹@ë“…¾¾—¥»£SçÊDŽ§u‡/(®íý‚H”†ú]wr ìz0\·¤{™4ó”-=ˆ²·å•h_q÷ÀÊþjã&x%©Ç] Þ@G"lìà]i°¿ØÍxd¼ÖP3ìãpéÝÞ/¦Ý]€‰:n.¶ô¶T¡ë×;ì•Ú':xÒÆΫR2lñ[¦-ÏYÁx’1OO•«¡K\ E•SË¡Íl¿d ê–³F+þƒH‰on_»z²Î]î<V™b*fèE×vÐWˆ "cŒíØ "LJ~ßý—¤¸â4•öÀ œÐUû3ji§˜�@wd! ÷”W‡Z|Ê̳wïe…|õcDG±×<Û œÚ™·% “qFÁ”ô[Çç7ôŸ(ø˜³ töõQZ³ø©ù46;Áš‹åmzDdqÊ쑵®{"›,0„_éŸosOÈ¡HÔ£ª®nÀ;i¦ ‘!¼šN_�¶•¬O¶aÆdÜ_غÍA¿±_ ƒ› r'ráq:5‹“„<Ë|~ƒ1ô³HqüI‚Õžj„´WS¶£ûÅÃæÐÎöå¶#2Hpº.Ø]’Ð5Æ•]¤cëðBß’š"%†›fÏq¤Jx«mðh%]øhß Æô{bi›¾‘©„›mTÝÙ‘ÜsU4ﲺe†—e“ÄZ퇾b¹6Cø÷Ü[jÜ Ìu‘Ô ˆÆÂœòr_Ö;NrŸQpéÍëÖT‹ o)ø_‘ûnR;vÒD<_è2Rüz°WÊ¢E\ƒ:*À><!’°”¥æd£ùrrÓqÏŸ#v«ÙÂ3ÚÝÖéöXzÔDltÀ¹×á rõ3´8YÖ]Á8ndJ!Ë)`ãa DùüeúHº�†ÜK…þ›P=vÌ¢rƒ«hƒÒÍNæ£'G¸³\>0íÈz<f8c'ezd–ÆW¾L«uAÁf}2Od*Z‚»~×NfÄÅ3m=Jû) Í—U^Fú:_=#ÆSL“ÓÔðºèûÃÌàùÖ�ˆŸT;КèÿAÉë%êSYx^“þÁkÈ`@ÆæNêjûù>ÿ†ØØžª9ø24(óp÷Üpº…úh‡PíN=Õ#µ“§©Ê£Íb@¡Wmr"6Ìá‘+~dœÌßÐa"·6Þ@‡À®îë—Þùݵˆi”-tkàÛ+ãêÝr41E‚3ÞÆO¢ã¤iÕ×+“вNòÝ×GŒÂl¬ûFÕÀÉKôüKþFå6Õ«ÓÑüË£×Ï"(gj’È7¥?ÁZ§óÇåš ùÎÞûÄÙ¢úWKßdÆ»·¡â$j,¿6uÈ#íWÙ1 ž“è«F“éÕ¶ø"(åB÷,Ša½mC`,ô±kùÐë”'òËæµÎïÚy€^ºBñÚ…DåæŒðbÑf*mO‘r¸(ÂÃöd6Ò2å>Áôg«RE¿¼já!›Û†ÞpÂò_h/ŽÇî÷ÜjaíøN%3kÀìz·‚�H¥òÀ©_<QÒˆ²¥mÄjÑgw%Æ'`ÌÞ�‚t§ìcUç„–S¤ÊUßWq”ƒeMÄ…ý«[`»y®=fýêj>ÈŦ¬ú˜“ sz¯ (sÀäc+ ÇåQЗ¯åØÎ|Sn%=—mN›r®Q¦ìBƒØ700=øù|óÉöî ÇŒÛRì?*.ILNÏôÂþ´ovµ¡n­êý‘¥8Ñý‰[êìUD?ð{Êy•èG@‡Í $b­òz[“äê*E’‡Œ,c§ÉãLªLé‹ûÂcÒ—,¶Ì7DÉEÛºQb«œÂ³ûÔ”Øò§6¯KMXëªÀö’ôØÝð¨B~ÇRŽ¦�0Þneärߥc‰Gtƒx²;pêÌ]ͼ<§qÃ#k±ÖèÔÐ#×ÙÊ ¦�C¤ŽC]ŸØS’›Ct$­D�B–É\³1 Ú‘ƒ+¼Û•hYœèÔ}´‘þÊéSºà bwÂR1¬÷BIãÜØJsÚŸ)^¥“KƒBl2äÏ®M½¥O‰¢L`†ß¶•ÓØäuÒJCÊÊÎ<[uÚÁ+˜ÔS~ßØ¢‡Äí†zÒ*Üô°\ĺÿ[ç‡dí9a—Ñçtð]|.`ûdöÏ|/“ðP=!‹Bݯ£¼¨­©”Ú¯Ìj¸’âc–oÙvGÿÆi8 ¼+Šm ¿+ŒúKu¯„ ß&)ÚÆ.<3Bº²l0¶N¤f£Ó$Èyw€×|BåØÈB¢›-©÷Á}“ZzÖnK{G±{Wž8Ç™ÝN`ÕÃv­j)z<6ùçmØ4^Àî¡üq¤÷ö¢|ÈQÒ‹£–óy}Ù¨'_(ðRí[x|^ÜÄ1j”çÉحУ8œ/“ù—G6Ù"~v_1½w;ú-¡H±û[£¨¶ý]ŠLOØY¸ðu #À(²µ‚ÿ`oÖ@ääžëÌ?ÈûY1g¾Á/žŠ€1¤Iáâv¶ÕÒ¨"1«^Ýz?<¬¾ûâª@8>À6—™fæ6T—ý¤ŠzÎÿÞØgDSåò6v›Ý´ü¨ n®_ï¥L¡Ü"†ÚNt³ª¡UR�bºP¶}Çh™û—‘O{äÞ@¢éèÜ(»%áiÉdvMOøkbp€º4ìHzÆt²Ô½bK:4‘±Ã‰Í£,îÝ1°àöøg‰³Â,Vl=—¯Kx^šeìÃV2T:_JG¡ž0(1Ø<:)­ÞzÊèíoÔå êªZZ^QD@%U±^d2óŽ'“WzÓOª§<õÓ‹Ï‚¤Ñ = L¸ãí:»ÿEÞçaeÝßë8ȶ6 âC„ýÈ´°Ilðþ`†»ÓlˆÙÔwêÂñ-oȈ‚iÀÓù´ŒA+¶8,œ÷œ³¡›/ôxú½Ìwm{×SQQl¤·rj¨$ï®’c‚ØìhÛúB¡×ü+šØw5#"×�tlzPç[ÿÆ5¥XóöÈ™¨5ú¢mÇîÃæ4OçCWMßUp©ñ)\ÍEPy¤µ´Úúzlf³Y.K6u½4.¢L¾áÊ ÄâþRMl‡aîÖdg}ùäÔ-”4 Â÷ãrçZPHïÊ-ØÓ¸ÿPŸªÍ£6 Zs–H»XRqônê`mÒsÚ¼5]½Ú¾u .€Pa{Ñpz·W?jqµ¸äëm:%)¦çvXüœpܹ𭄗!à“µšÅ ~ï6‰öÖ£”Yì† å{wåF+™Ÿ�T2qmãF–S}ÄÜÊRXÇF+MýªFu”ÄJA(Ñ3ß¾+Ql°±^ŒšÈs׋.Œ5r?Eà¬ZlsMð,D?NæÁÁsÌt•û£ÁPªJ·ƒÓ¢¨i…§õÚÊJmÕ'(Z�¦;ó9Ë@¹0 )žTK;õ­>‹Tô2-™Ù Y %2:r:S::Ï΀4åÓzP8ÆoQ”‡J;5†2DïG%¹ÔÁ]‰²–F÷m:†5Ý÷ŠÊ/nÙu¤cGH¦7ýehÝü¾û¢om¼)ùúNÇQxs#{žÀògKº¥pQ_& %†R€V£ñÇCrçŽ#¢YhÉ ýµõÄ÷mÝÖÓToݱür‚Ó$F¤p�V3}÷¹n@}.[éž Lö“ÞþÊ]ÜÞüÜ‹îЕ‡NƒÒs "†_|‰™M= á»ežV×­éLÛ1©ÿ:V6MMÝÏW AÏì ?4[•ùíõþ¯ËÛ)ÉUÅ 9@µoFÙr19õ[Ý4‡9˜)� fDf1›,>äEér bÞê–æÜ/(Zè;uGµñ·µèYÝŽÊpAçÈeÖk…‘Cäq¢éPy_dz2üv.'8ÙY¡AÈ«¦‹"LY•®þ+àÂç0Q¦´KEh”ÕWÞ®ž`s>�Ö¶Ë/I°$Ê»ÜXϔ֎– /°¶™]Åwq¹ïæYD™ ÆtE•z7ŠëS¨OÈ둺Ô& î»8TìøÆãZ„pŽN[KñÖOfÒÀ‹«¿n:–*¯ñHè±À‰ù®Kh:8­Aõ®[mùø¡M;Bé•°yQÈ&aцìñAÛF9S3,Š›8ròÀ \Öã‘Uóï(€v/IŸæ%ê ¦gd9?§VÎ(~¹)/‹’r ­_�¶SÙ ¦¾¬änºÈ"cäÞ÷|'…Ž­z$_¡¹`æŒÇþP@ÃÚ7PÆ»²¯T, ,™y;„Ò~2<°§Ì‹¾ŒsÌŽIcd‘ß$Œñ,ýŠÂB«{Ãé8)E?*í¸þÀÈS¡Â³Ù˜ÓÃâw;‰â+ï˜?èn;�9È»?õ°=¸4z8 ¥¿¹Ä®k XöZU¯ÈÔ½êLGÿ„®ä£œ_ ËtÉWPyà”‘øÃC( ž&)ÑçAŸˆ]3Ò7k�4‘)éP7^#f1lx8t¨2×Þ•º ½Ðà1ÃáPxPì7%¼ |³ì‘žøT ƒ°µ²’‰!ù1 ßˆ€Á+@ƒÈ‰3”fÖ{(=«mÿ­$òá,΢dY®~wózO/JÔV(«ba”üÓµº‘£ô}"[¯?–E)”Mrž,ØäAÒt*”ˆ%wá åÇiö·?™Gù3-2BS�Üd%óáä×mÞXçË*„iVˆ‚Ž™«nìÚÝfwX\bj¬ËD¾KpÒ·Š\¹W aN¦œéƒåýßÿC‰Öe XA–ÿ•KìŽN€ £óœP¼Õr7u¿¦¶´$¢’ yÉm«êP%$”S9ýV”†Ú”ö^ñ4¿ï/5Â&6uÔÐQ™½[· RL|«GúДGY„ÐV IòÓCWÚ¬º-nà1ÙÚž =dÊž:n™ Ì0,–ª)A›š`ð»¹t¦üpX1¾»ÍÖ»>¬¶ÝŸÝa…ôA%þÂ}7Mc]=ÒŽÐlgàô—9Š®ô°v­›€/a»É>›ÛROχY"“Rl ËFO>6ÂU“—É\@eœ¸}ümªíÓÖؤLÈ\å`åošÎØû-´Û ™¨se:/ËoÅKäŒÆÒ9+ß«câÄvŒƒÜ«¿‹ËàŽ<kÇ}{ñÀ®;ZhP!°@·¦|×ÄžèXÏrbî»þÃw˜ï·³0SÒâôI/ðIL¶Ÿ^äk†6í0û4ùú¥±OZ=+`Üœ£ºU15:å[C“ænÐHµ%gWÜ`® ·[v_o5bF€·F/òyo=±3™83£>ŠO@Óq¢wÈ «¿ðC™\†«?1¾ý_Õ×kNâ+w:ž6Íeñï ´niBA¸˜ÊeÁ™¦›H„‘p#ùžºÆèŒa7C4 ˆJ›2šhûåtBÿ@HÃ#.L£,0A]åT–Õ«=E¢k�îêOÄçÚÊÄ– å[Ø”ïzYºêòñ»iÈ D2… ûS³ô§9“Šþç2ºÐ6fH_BøáV®2+-7@yS³…ÛéKyz]óG•#z†u±ŠiÑþ#Í‚¨k·Ê gPHb¤ð‡e4̨û%Ýñî/µã¬˜8ôÆÉŽ2ÁX‹-Õá5�#oúj#´÷'Ýr–dxÍH+ˆYM;ˆ²?iSðcœXS¹Ò ¼›ŠîË`[Sn/³S±Æ‡ÿTc�ûÐ 6OÃ% ÷c¦Ý ¡­Ó‚àP°Ú…¤|Ýq:ìõ¿¼í;>}”±—z®ð¶¬iÿi‡–<|=xÀÇ﨟id¢€)ª+)§òKgv’'ÄÐ Hn9þ°Ž µTVX t/ÿüòÞ%Gæ¬ØÃþrO!øR%¿%¦•­uë|’à…µëþv¾mñs:E=—­º‚Ênùé@¶ìœsѺTp·Â&øZVw~uÓb‹¬‰8B¾sL€Ø*¡lÐpWÖÃô§)pšŽÏ3éÝ(ö}YA¶[ZK]«èeÎIÊã“`LXÏì7ÊòD‘Þ‚Ü¿Nï’BKê±»KdÃÑHÚæIÚp;ATõ¬H ÷\“â5“š¨´+74=÷é£ ¢cçÞþø’ãylÝ‚Ø < #ï³/r;Ï) ƒDÆh}£d}:–~‘ùþåÇ#´(×ô!  'ÝÊ*ÈkQN dHç›Kñ'¸‡“+«(˜.ð q^`s¯åŸ7Xµž/ÃÛú2\ÚÖà6Î×ð•,Íl¹y¿ÛÂÄY¨Ö2Ô¸…ðÎÛÙ@ ¾5‘. í„K¹ØŒ6s¸™•Ýæ@kÍz+ýRÓ ™ ©þW@"/¥ÍHúȨÇŸ[Ï’¢{<oûš*“__KÆÝKÓø–-æ‚N1m¯\Ò×Í_3€Œ«Xg¹ôô`WT~Õ ú2Ã×Öb±Ä¢hù¢,-™²‡dq>WAâT¶ÖÓ¥?,ŠÓ&5ûøöâ›eÚ£›nÛp.ƒÑNJ¬öÀ’úuU*}»Š ÎðÙ™MÈj_ÂÒ×¥4j‡…}Éï\Ê’laçMgs¢è\u¶Ëµ:y$ÔqÑJ%‡í“>p½/5ƒ£"î“•OE< d%Û¿q±{W“…*±ºt¤ÕÐM²Z¹ÝáAp{øžaâ× Ì­æ…­>Sêý°ÜÖ£øajÿ±ÞO\<-‘¶šc² ýê• ýùšÂªåþn DÜsÏ…c’ŠqŸ¤Yµl©ÑÚ³Äi“høÆS3ðL“cEB ÷9ÛXÀ²žTâÿIßâ~¡WõÒ}/ÓðŠWµ9ÑwIß¿~P´h�35œx#b=.=qȇ/FtY’TJá›»1”¤Ÿ65.“·ßJǶON?1»ÚT§ÕõÊ ÅäFh$R±]_þ¿N(¯HÃ1†¹ÃÆ÷Í ñ¼¥ÖI”0l „²³rXÚnS•­b]tÓí™)ýÑ݈FÇËxg.æü"Wg*AçιœúðȲ`¨a–Z&;w_ý ÚÚùER^C7% òÓF7ù”òpÑ®iÎFˆrBõémsfJîâ'+×ì´)Pç´7Žƒ¥5ÄWJÖüÉ&Ì,…襻º£Ø§gÑŠú®ŠÚ*½v²¹ “q“F‹Î=± öI˶Äà1ÆAÑ:P ¦R”G,FÏftåIfV kJïVd&’Ñí±ëßøÁOGÙ0Õ«£ÌFN+q9ÀùñS v°¢­;áW�$sî‘Òmi‚ÙœÈLÇWôµPÄk½”ÿÅ­<ÎôÔZå}­¿Œ5 “ôuepkg=Ðiû½AjaÑî–P:l°A{g4ÀL톓W¨;‘µÛ«[|K‘èP ÍJ„c£ø#ÌŒùp1eá÷óÓ8M®¼æšmNwÅÎOcÌÑéþ©•øsn¼oÂ[WMO)bòþé•WéplL DÃY†Õ÷/ïA@±ë mÍŒf²±£„þDOI—% ºÂLz º^èT¯u1é/y6~)–ãatŸ&«×Ö1¶‚WãMŠá¦½PÔüCq7w–hãŒpŠs–+äYØÒÏ÷È,.]P‡Y-× 1tníé›ø ý‰Cìl µ’±·gTŸ]§wíÃðà_:½ÌiàŒ¹ç³cO¤Ðó8@POiPv¶ALY†`³=ï0ŠKO£ˆX¯Y”èg;ûBÓÔ>Yë*(³ÎkIzyÀ*š.ëBí'9 ô'\Ðó?L'¼ ðÈ|zø-Ù´÷¥**ËËR?g¨bFMÏfÕ¯`Z¯`l/rMZ“åþDõKïüè*Ô´ý_Ñ?¡vç¡/ùRÞa8xÀp®À\ ôõ·6¡•õtË ÜL†\ŸÎAC$™ëøÞ”è?粓 ÆìçƒtcႱ8ð�æ/ …,ý… ¬æŸ$È«W3…ØÃ`rëâJ‘3°N f£ e0¹êòÊ3IôDšÂˆÞÙñËgrèhwgnG¤>h_ÿžà]†ºR€ÖÐ)Í)‹ïÕRâöyßÕ¶}¡Õˆçc_o¦-ii9ƒŠcd+›PÞÍ^JåEïg`…æøŸ6@ò£j@’cLoTTo¡¾�ºéF.¹�禲o¶�aºy�L+Gtàm»[ë‚O#D¿”2zim T�#ee½5�ƒMI_·üýÞ't1>¦ûÐCÉ+ìm‚›0àoØ¢ç´?®®Ø 0m¢Ê1ÜÚ¯ Äö°0ÔùnpL[À(äfŸge~8ÓIÅ=æ`ëêûb¸÷¦T30*Ì )ñIƒ¤µŠ àŽ,-®±ïF‘ÞÖ©ÏîK¢€­% Û/zóc£ÈãöÐv…G}zseq‘ad$Ú€Yx†Híe4M*) øa^Ø£8[Ø7ä´"iµ•nte¬šæ]²Wd�áÁÄá3 ƒ«Ÿ@ô`gž?N›‚{Í“¼1§¡r¶ç!­¬™e†wCý\ pc0¹©†uZû¨Þß:XV˜G»_tÞ¼õÙ4¤-±ûÖÁÁpU¬°YÓ­v8pN<èðé´Šºi^qåì \÷@\ R‡£ªu’YÜðîþšm øeHJl)ã™ÑÇž€õÏNvþÎvŽ‡aÞ@ÉõI,³»€À3ݸPÐÄç,ˆ¦VYÿY#:½ßál¬òcIá ÐýïÜ}Bz°ŠÌ-«Çä/\ûSÈ+’IrŒÎ=lr7‡ƒ„x«Ë(õµZ¢ô{LÌŽ¤=Ûž¤1ãù Ú»é�莵¦%ÀîA·0.ÓÌ#Ä"4¢C®_»L’žÿo˜EB¥A2œÅ^<J”ü¤tº8 ÒÉBŠ¼¶3g0;<=²b;@ÒzÏgÊ“ÑÙ|†‚ï@'€å²î¸÷Ý?œtUo›¨dÏÍpZJv÷8-)û¶ƒÜé‹> ôTV‡,(Ú‹ÂÀ€"Z üb<œ·ûJ?Õ’wŒHÄ%`¬ÓŽv*á(X?cÙ‹½æ7@ —z„•‘¿§L†N„ÑI.³Ž& ­ðö?R]N"¹%«Ž1T zUÏÁ€áä›®ë.ž7!K+N›½°ó êìVF?–ãö–½Mlù<Ö­9´»kÓ>ð÷Pš!3 Y’»þô8I´t»Ö˸~§ìÅéBÔrU,÷õ—úètÏñQd¶zWÃñ¡š£3U²aHŒé‘®íjd6}i¨Í úÍŒKö0A®/æÇÛöi\.õ ù“Å0yUÁ Í?4„Ú¨«-o?�X—ñ•!é#Œtü«Ä§ m(“NÝ“ —\e¾`ãÄp}‰œ]œ 8W§‰éº=5ïÑ6>œL˜â™?ô°Éƒ°³h…Œvs= >!¼_}Þ½¼…˜±°&qЗ×2[X>¯ÈÝøˆ”]ö&=y�dËÙÓÀ™cT¬°’®ŒŽÙ̬-ýÿ¹ÂJgž‹M»«í ÚÛZ!^¹‰ãÀ>Ã}C†>Ÿ}ÅÖ:#Ç¿Êv¶¦ÛÄ:@¦Ýò­ISæO¾Š1ù}N.*©œß‹î|ïïàD¢Ì& ›*ˆÖ­oÒ÷QžÙM'‰ìk^®7Ážy!m¢J ?øEÉ£°FÛúo×›}ë±9ß tŠëÒ{£MGU`y¾}cô¿­ŒÐËÀ8o[h%ðûmÿÎ1YATR‘+ePqòbNOMxµxé´2hªF êÆè�²¿R/P"rD¯­ñ¸°päÈ t`jŠÎrõólÅ1¹ßa;QþËlÌ ½E¥…Ãɺ.Gïÿö J*¤—C¶ÕòÙÕj¬®||I=Käp”S äÿƒëJ­ª®¼»¦º ¿ònåÀ^”‰5s×D阎FÚÀÇnOkøÃèÊ-R¾z¡Õ¦9|QÙ1è$…­ÑX˜9¸Ô£¡À8ë‹Zïnï nj×ÝF›§Z‚õ‡õ?èV–<³üººvlÇÄBü<Ô¯ˆšøèÚAù|º(œü¦¯}\žêóLKÞõFÐÃ_šŽTmäx]ñZùÉ7y[ rÅ—MÅY‹÷0ì<dƒcÿ`_êôÄî êœ(ÔeÎÏ&5Áò Ø{kÆn„¿®__Ö+”0iÆ›°¢àˆªQÄý‰Ù÷Õ^ÇQ‘)ÕP„ÿ@@i°r¹%ö�½av®ï§þÃJ”X8ík ÛPIµ IRÞØ™~{°1üó硃3É66LÅ»XªGe”ïFæKr7_¦8¬O­&÷7Õô‡Rž½²Tz ‰äíb³FöiBÛ§Sº\-es£Sá?ì9N¤ûõ+ãcu¤c*‚ª=°/g—ÊåæU"z‘”vÐÇõΞتëívÁyˆÀ¤ï‡æŽSƒqYyhî¦ ªi­Rš©g¡"^˜ÃÛ_ù ôt[’pA™½iÊŽò–Ÿ¬�§ÝQŸo¤9î7a"U4”ο47âhšLi–Ì}L¶ Üióòœ8“Ûù|”·<Z.9}h«¡‘— ­ÆÕ¶àïÁpbø¦h0œy›§js¸ÄáÖОæN+÷ëj§-Ð[MòîxD«Â$ÀN\w1² ϧN¶s€¬ƒ¥Ã,G÷ ç² :ëèü1S0‹ç¿Š¢Œ©k/Ô¢.ÇÓ0\ö]Ûù{Z$Þ)šµT¦#:󵳯«÷†÷ %Dß,&w¥Gg.`} IßÙáqa�b´µ÷°È¢Ì¹«é™åƒ_C/WýNt.[*SVÖ „¾f7¸Öü?oE`ŽYë.rà òy† ɬoi‚‘r–+ ·âØS\..Žéƒ)õ©w–µ5Ôåb ŽÀÙ±C/=‰‘Jc-�evÞž§áÕ!ÊͧkìRTù<ÕŒø²kå›®Ï�E[e Ø1œÕ§= ìfrEË”ïÞ¢ÃV,}`« [E{.±ì§|û÷ÍÊÓÚ\KóÚáíáÃ:‹÷Zx ÔAÌÞèEÌ®ôÅL¬ûã˜+íX_ðt‘œµmMü³£VïOÕhU& ,— ³R-Piÿçëâ`aâ±ý�ýÜ^J©­º»Zåï{‚8*´´׶€XŠ¨Ê†ßb†L>Bÿ¹nyÄ9wß ý"Óu*¿º"ˆÏ½|BX«­Ù3¾¶å8ÆôøKŠ0gn�ñ N²2W„W°’K:È:çé‹u7îK¯S©Do~/¾½)“úé ï–÷‹#lAјž1çÜî“¿šå¡&ÑS”>@(8×j:…tbï}§4bLµf:tã£nRSÌš :“ˬžÝè"Ó´T¶G4\‚#-Üb½ð´ßÿ,<³Àþûzk(UjDÁçð4`øº¶ÉÃùB5‰¿T°-Þä—Fƒ¥û³ûKßò\áyq|¸Z]ƒ@ºÔ°±®ß=Š|sè׶ÊàòÈš�ûoõüVJŒÂÃ\S ï?}jÈçÆÉfðl¸a5HJÁé<`£7m+H/×ädU‹úËœC{ÑöáZõ4ì˜9nQ&«jjªáFî¼Íu¢úÀ­°ç¿‰<‘‹3Åhâ€ûlëƱ<›ÀÊ6cÛž3c½ÅôG7.-Ê#,7,õ¹šmûgÈDéÿrcKSž¶íö•¡ä7´;#µ<Ž•ÉËÎS^—wƒ.Àœ kÃpóv#Ý«—%.ºTJ¥,ÕÛ$Tš× µÈÆ:¦“`eÑ^4&Ìò+g¶iC1­µ)#cQ¶õz6ÖŒB?\&7TüflÆÚ#‡n¼Üý÷Z¥Ò äC»5(ûù}£à+†DÌ‹7¾¹wÜšìLnϹsé_ƒƒ¼ý¸ÈíR EO»Ú®-]®È9åTTVýÕ‰K™©°]=€ ŸýŒW»d †»Ï.äß” Þä*1»âx çRÌ“7¤¢Ãä,OÝ<—noÀT–Ñ­\ê2Gêü⬧’ _omŽov¨¯yéÿóVÆ.{ž/“WE²iÛõë#‡µH¥Ó¡é+úüƒ»ùFx ª ÊQàòÄ¿>Í]¤#øó¬íñšêÇCe3}ßÖθŠýè zêkŠÕ¢–È-ǃÈÕpžï4W^¾øÑõ-°=ÑÜ î|4cFnò:Êr´9ŒGÛÙyì Qjo *ÙzämÉ»“,˜ÈráÛ"wš+J§½¬xÂGЪ_â"ÛSÁ],\k®é/¬QÇK…Ò£îÆ¡×Ø=g*‚ÛÖ½jûJË€o¶’lœÒ^ò»*=á@mibiO©˜'´âÚmA+nã-¿)÷VΨ¦«G>._²UŽ¢<SŽ§ôÜÚjk‰#c)þfxO6VvâÐÔT1Í}}¾3úH"M]„¶6½sòeyr©ôŒ!ß¾­{Ê D͇O˺Gß‘ ÏÕi•W‹ae49XÝ£ÇÌ}tî}³xÏj¬ù¾ „hùÓþ쵧h¬öôOô¹QFã+*ŠØ‹nîz ªr‡kbÊŒ)Õìtz€f¨¯®^•‰’eì¹Å&îgÓåI#4 ÄÆL·êàúŸ—{„ß�Ýf:\C7/J廡ÍôÓ_rˆh]¦Úh…âתÉióÛ¢-ãñùyêwG»÷Å'žÖ”¬Ì®¿ÈI~Õ²¿éàû¦­Å¾°¡ˆÃ½£ÊëKoÄÝD|dnKÌgA1vŠ^hdS&JöõÎçínÍLA�sbxº{µ§ì"‰…e±E¯ j Š•2¯Áe%“½ú«{mRiR:ű€ûiç„¿ swÛמ|ØFMý S®~óò¤x5SàÌœ‚l€Ö´„E¯åÈveš‘0þIú“"¾öÐæ–óµ-ÚS_í8Sù݉sÅqmŒ@ÆÎcÔ&­ ¥¹ÎgÐ+pE—ƒ¶(´Ÿi»ZÃ+ÞV<š# eUN7ÂØör6@-À0·xåhé¨ gê"ˆ·ö�DÕ‹³^™ÂÖ\°‹Gòù•9õ”'–/h¶t¤º^×q{è†Ý—„$¦ëUòn.?‚9y_[þôØ_tkÊT~[ïhǪºô{aï0ÒI6Ôã0¯­ZS½›nµ§2÷K>~_ìÄ `é7´’â¯VUY€P½q1pL­D®¡¹HaîwËG‚ˆ’±S'hþ\µýô?d¡=ä]¾’ѺóD©‚ÿ [i•IÞ-Ó†BE2;b@y{ùNò1jäÅ‹¦3v¸=$ ÉúiiÁXV—Þ§ThüýT¦ÝÐçó»1“«dÈY Ú§“¥_¡÷gç˜fõበ׋‚Öx0ÅŒºÔ:Ó©Q [ª Feé3­¶ÿ¶ƒï%‚&bQ].l'læ÷¹Ì#õZRµŽT{‡N=QZ´ÓL›†‹» c>ÙVš¡z’¿œêGVgíi®™Q|Õ™¨ÍCU•÷uOËrìEw‘/+_)/3¯>%“¨Õ¾ r'Ê{FùêÁ€öaíÇ5±~ñŠ½¹v»£ûÍÖöá4xLÍžSºîEcû ƹm)N}YÝY6)åApÏuZ¿ßδÆÛ&øØWÖÝa‰8χ%'h1Ï­r]ëÝÚõÃ[ß}E#ƯLáÌæâO‘ne7ƒ ªI³w¤‘ïyT‘ÑGtC¡òuÜ(QkÇQ¶!ˆVÅQº±ì¼Ì#ð“&™yÈOórÒ‚JβΎŒäɽý?>yÄ®Ÿv”Õ¦à†UGñYú®9 Wc —ø‚ž|šbð°¡RbÙ‰Ç[ôJ÷$‹E¥/ÁÝÅ•nýÄ‹ÉDšj‰ý0b¼\9­õЭ[í\/õ…ÆB皶Ôèâ¾+YËòrhöYY q˲‚Î)¼ÀÓun·‘i GRŽg%X×úãvçr!ÿÉ]íá/°y”Þ4“h·_yOö¸HÙüz`MCîzÅ€H›%/|F-ÒD�T‚†A1ôî¤ 5:ïu™ù$ZŒ/ðÆSZÒ¡a'€F£ÚpóÕÇ) Ï02›\ý¨QÓBÓ¦¢ì@û¥î\S`Éãm +ÇoÊzgà+—àiÛš>úçì'9-TV\O*ØÇn!VŸ›x¾»jlA[žñ€ÓL4oh©É=µ7ö i{ô ŸšEð!=‚$ª/ï‹æý: ‡ˆ‰¹ôÁÜ[šÏt�óD{Ý µ¡Cï½USkû4´…OÈšŒ5ÄtÓšÑ,¨ZyåSØë =¥moE6 f+ìíªí/ì‚Êüh‘›_¬/´O®T$¢8óž7´ÈèË‚´]+Ÿº#ëz|Õ¡ú\³QLAv®•­]Ù£å[¨†³áVf§½¨ =Od´Ö”æ‡,‚2Ö´c4·¿(|{ÛE_oóP§ûêxO-^\Ü$R ÖSª/ÚOB:Æ›M6©ĺ–ão»î„ÐØ ­»Ô›Qp«YàV+eQn·æî ŠhÁ$¶1½ñ¤œŠ¸0•sq¿ƒAÕ››aºp£^6=½š;îéÿòm£Þ†W[«ixìÐôá ÒZO¦¥Ù¢#IõT9Luë¥iÑô‡/¢Û4à^¯‘”¶÷Àø¼vƒi»û%Ò€µO£8&wVªAÊ+^ÂMªWô+x”ß̪£ÿ$E¦ÅÛ‘6úÜ)iäÎxI©¥@å­d»G\£taËNoDé‚ô¤”%›sYÞ] [µ¼p)� ½ØwÞ¶*ÃP«£Bù¦Hƒøh,k¨ÚÿyKB«¥‡ÇxÁݓ⊠> /ÚjS&õ‹g½¢*\€§¡À–@ÀæËS»•ã¿}/vå>[õµ¾G'®½–释»ìÄiKàŒÝÌ«W5¹ˆÄbËÊߺq8Nw�Æváð#Üè?U™:ŸS3Ö)ƒüÓúœŒ},¾ñ¼íf)þ½¶EærgŽ“.Ì + € cǸžV!�nÃN´Vå•› Kz^ªmÁ8˜ÏЀª{U’°\µlØ„m¢Cc�Ó‘v†ˆºjÕIVU¦ë9l <æŽk(é ìàüpgÒ/ä1¢(^¨zR|ÎÁA™Üˆ‡9v°n禽,ú}7oY[]=œŠ°v²öYŸFÚ^í—½÷±ËbÌ0ÃËæ>QÐmV.vBæ±d ŒuQüO8;Âà¾;÷—A:Ët Ü_pÏ68*3Ýa¡Ûß^ª ì­O Ér±ÄÖ›åŠÅ7 /'ÓC¿gGÙµžÎª¡èö¾VÊG 1³h;ííLÔ÷®½ªŠ3÷þtoö‘Rvž*opBÜøØvpŸ;N8÷¿k€eÖ˜û$ WØ/ª½EF55ìÃp˜ JU©]<мH c‡\ÚVf§Á„·Š‘ÐôAÌùc#{ë'+ÇQc“fAåxÓóÈ(! s͘¤d¼Øº^mÇm×Ö|ßdE=p‰ó,ÓÝè,˜1OÛL¯R&Ò#CF§9 ×Ò{P2š0ä<²òŠÂÒ}•AÔž½ …‘‹\:‚ÒM*Û;AÍ·c#cl³a#ÌÎGºÁvÈ/˜gÕÓ’AÛ]˜=M§T÷Ž>GìQ©èK¥˜/ƒúd·p"æÄû=òº¡É2xSƒ.”fîüŠ–K¬¨e‹báÖ9ÐUÙ•"â ÝÖÃöH \€²i]´]AE»CCqà›1fNØk_ Äâ >uúœgŠ·Îª 0ÌÌ]Åòþif”^êœuc† è›^ňzì†ZQ¨Åx§Åp˜3ÅÿNš)Š#í!J•A9ž|K–vlEÌ÷úAäÉ+U:'x(ÛËTAŽËσR»ÈimšÉ¤]=ž`)RƒàbçŒÒ”‹¨»®€1ç°Â þê_>Ùþí/û¹'<Ƭðý™UïÃf|‡©Üâ1I;Î]IÙˆŒ×oñÔcF°¤Ò ¡â?êíL„ŒñãÌB“òñ?O»ÁxA¿0ÿÌ2•*2>lµ… àtVÎÐbðÃzðŸ¹OÀ†ÊçQÜåHW[ÞÌZ5龞Æÿ Žn)BðªaE­'^ïPXßî¼—(‡8ï¢`®M–ûgR`ÝÊbkycÑXH­é ƒ}9W›x“?q°dŠùd®Œ•£™tǶ-˹ ½_2õ~†¸ûsá¤Ý ψ éKO»²zVV^MôùçV馡(L«ûÍHôk…þÕúãÈ4~Œ†e´}¤G›0É´9ԣ׋Â4„Q6b­ŒO/ƒ^¯ ¨Ÿ$,¯pU´†19) ð^¾m!E´AÈN0ªØCø{™yû¢ípûŸDªe[ynJèhÏæCP‚9�”$ðŘ…ÍäW"•‚“y²kÆÀhGØW^‘¢ \§ ÎC”ÛO@é-H>QŽñV­ýÎrý=Ì%Šã«!¯Hx^lª‚¶>ª¤ÞJ«Æg*C‡oú…€g©´ÖJnoé~­½+Ѹ;:üöDÍŽ} ‡“Ïÿ/Åj“;d\’ûò€%ÿ¦1J§ò1Æ8/zotMœ6éÝÊæI‘ãô;e!Æ�“PpßO®SÎ%$Ö`~BŸZ* êÞh©¢B¼cˆ £r9ÐÎG‡£bzä&³‚ì[Ú6gô3*P  ~û<üBÜÙ�ä}›w%îdÑõ½øÂ_8EnD[œ$Cc°èíÆ­ÄŒ¼÷MM0×'¡¦-_9Uí4 !/=®"ضtg¶Ÿ–h&†lmúÚž°˜Ë¾8¤uL!ƒA«•¶báäø÷²Ûö0ЋŒInœ ¨~µcÒÍg v~(—²ÆÞ^Ìù¢)|%¸X‚u'ЋºJ“ 0¬Ï[*]Ià—;Ú)ËOÿÿ0{öf�‹£ø×'øô F”�é¸BÆ8oQz„õ= ¢�C{½+¶…ãdb>üM7¢Xv^¡g駭1RC‘ô¹€X²ó°ªŒÓ§»Z†˜ÖÜf„sör€Úû¬ÌÐúݾ3þa´9ÌàÀ_ñ¾ôëm{Âζ± R Ä%õ>I¨DjL5±­!çÌØqMXNôÏsv"8Ê)ÓöpìmÕ§7öO6ÔþÌvÔž×FƒýtÈ@[ëÑŸÒR*ÜÌÚµg̃ÇÓ†eQ{Ê L÷*%ÃLC{!}*‚jã|´0$2Ò ÃßùÞ¤øB5§¿!kZ_zÃ\-ÿXš)§•˜á‰[*æcgr*ÙŽ=–KÛ¸¹r!¤Äz@"d_o´MsÏO–¦hÝAòµV_‰Ë}i?Ö‘Ž#ãΞüꡉo¯&)½€é‘L_Úº}ßõô…:Náî{]Æš8ÌŸ›˜Êƒõd9w‡ ·`Je¼úf iIjÍ 8)œ#èØù@^5ȹšÝ0y“y££­¬÷2›¸­$í¨) FLSB…ž³`µ«úÔkuËígM…Øoµýoµþã4ÒÔ ÖϦ/ã'J× ²Ì3˜ÈÝ«ï6ܳ¦Ê½Ê?(pZ è±µ™‘ÖfÐ+;]™,ØX~ï'%bc\_Ðœ*è,¶#¿?»U̓z®{éO!}… N@¹Ý꣯[wn'G­èI¶ÇóXK6Ó4S“¢LÌ ³ÖöTy“x(õ[ñ¯i¿åÄ=Öhé}ãeX*ÿ öÀ„Ï‚tÛ«‰£{ħB±ß¿g— ÊÎÞ¨í@yjáf 2þ<a«¹äef)Y‘”c :ôNÛíö÷ œæf¾0Â÷ÁÓfxÀêÒþ¥¥1 ÝÔ^pžÉ4ÕZþ¨yÄLn‡œ¼Öj#ÚÓÖ´x6T©O—¾ŸŸÌ¼¢0ö¥3·yöŒ¬y§³+^×ýê _Ôú^íSE"Ÿä=1#ø”ƒÈ4(m«3å¦tzŒìxZâ{(3vÃýKKdXþ ¡Ä(V ­ªŽBe8Ûo9w¤ºÃ’è0åH»ß™ñš /½jº[”ÀMw$KìlÉQ‚Ï-f×ßóª÷‡ýÎcwì`ûá4ÉùY:ñ¬§Šå²"Ãüâ!ÛZ‹^ûö+ž’Ć×\E²Ò##*öXƒQO:Ùfv Îo_²\†}}_vë‰4ðO1e-¾ª¯šÓ¿ò`JC=OÇm;çA±¶|«zEÑiq ûÔR(ì†ër|#€›XÏ^çüÕΰHÿTjÍ7ªñ¶Ê‡º…¬¯Q2Â79ŠKUb­ É}¦vNÙžÏQ¦­³Å1ð½› cû'VJèÝöÃ#±ΠåZ©˜g’a{2s+¬¨‚QÚöÜ¢¾ÿRJEt¤G;å)Jg÷õ›R•gs<}%xÜ”òÅK…[RÒ©I‚Ä5'¨€Ö‹£boË póï“#<N‹PljœJ0Ê {‹+b0ÍCºÔ<`X”_ß*£9yCA¥EßcÖ)é‡m­«Â»†‹Îw1JŠEFI‰ÚXíE›»?õ@¹“U89Ø{{ïên•,)û0Õ¢Å1YI'H®.+—^üÍ¥ëäR<º)Ñì,¥æHL¦·‡3ŠGÖ¢‰öšôY†º§u(‚Ðåfqb†¡’¹§‚$PÊ®[®PåaüÝS‰ú/×÷§•cÊ1¹†ì;å\hŸ'±Ñ´ÍJ©U0ÀˆÒŒeE%—²ûúkW÷/êö”v]»ìÀϼï Õ$Y¹§?]Gÿ…Yt*Ý,¸Ãt<ÌV®#…ÃŽ'oÉ…û ]S§ø•›ÞßÇ .ÆVQ¯Ð0åg_ûƒ8f,¸C׋â«qw3ÀÎ9§’2YX9¿¡p«®/ý<Ú£*“aN0ÌÚâËÖ†ææùb/m­âÄ>|ðQœðž OXŒü%0Rbÿ¼h¨îm•åÂó+é'¨5àº+¡þW©hq¡Í( u^ÓÑè!´øÞëiÏ|{„~t3Ó(ßùP¿zUŒ–Ü°PŽ]ÄNC7æ´À¯a9×{+ºl.øVƒ&ÙÑ×¹î: dzç-xvtŽª6'/‘ô2¬[S ‘,Dt³i &Ã_…‚án„ýÉœ·ÚÃ÷è�œhLfÉB¶ðËG³|+nI Ĺðp‡)ø€3˜ÆÉBT- æ3Õ®ëÁ”pn¥Ÿò7Ï) 5z2€MôŠ¾xèöéÙ8‚í¢])¡Ñzi}вΦ|1º"u[_– ß«|Q/‰/¼Q‚ع!%0µ6ü0¬æçz{af˜Y¢èðÀ¥PúIëäËÖef¹?3´TE@­.qˆy¨"‘Ú/\·}”å`îE*¸ aÁ–cžµye%È»¬Æ\±8` ôjmœ.íèJÊeUÈ!×4{t¥Œ þmi’zEV‘7éÑ⮺ٷ¸7=Ó?—— S\¡¢Í'kþò7™]Ù.ŸÙó{»Qòç˼•ÉŠg7¸‰ÓƒÙ“§7áp<$ôL»‹ÿì‚NeìžS–¸Ðÿú¹ãï¢ ÆéY½õFìóÄ’bÚ¨Úðím2?5—7¶ÔÄF¿c{ÑéƒÏë} ƒ ÂiJy²ä`›NV‹’Ù~åP-ý‰$bETBçç­I/ u@+bçí¤_õ ˆ‹På³àƒpÇüÝR±xs`ª³•~%qšËFwæ½™hÝx,æ¤=²èÜ’Öæ0‰…y]ø%«Ç,‹Ÿ[ÈépòbALP„£½ß7 äÈrE“‰ï:̼SâÛfš•UúH�mÌ<Ø·› KÏ° =-€}GogH%1”YàÊó?{>ú«k :M––ôd8–At´ßùOM•:ªZ¡r§u‘Îçö ¦s‡3Ûò/J=ßÝæP=™k…Ý€G‰‹S´2Mî?ÕýŒ=ÿosù—þwf15J–?)=b!ÍS_Ë þ´­ô¥ˆð½:9•xî-2ùÍ”7f/èɵGsCgw~´-€û6»=z;Å~M¾Ì4—œ¨ÆÎ7)V:>p诖©²dy³3 +éâWlëªû²áY]>+U£*»b¸­ö[°cjdªaº—_5pbA´¢¹Ö£‰­Dâ<õè#w6‘Øè=êK纇†,Q%ÖåçŽÏÏrî¢(‡0q‹ƒâÝ2ÒÑìPm”—üÛ"Ýã`ŸÚÇZî½–XmâæQ|t „C™•Å¾7HocpOdÔ÷Þr#ò2Œ´Ï²Öª4w¬[®SÌp1"ãXö,ÆÛš~c¦ ßó–~Ǧ§íš¿7ŠþÈjïtÌ­°ùÃÔ^ö.C­ÐK¡íÑ=î\s G§/zÞqç†Gê‚x«O¿ eöPW‹§É+­ÀLïÌTŠ¢·D)Rÿ“·–•±‰)î(|é’:"å´h›‹É¸“¬¶/ßa=×÷ÏoÏýÈ‚L9ÉÃF;´Ž¢fíei'Ú+¡k‰]|eûÊ*‰ ]º¦XSÚP  èqgAôÞ(‡”þR;¥u¿›™‡aÕÚ¿³‹Sú`˜t¤4Ñ ÅþÔ5¬ ÖýÀ‘ì—27NYƒ‘MSL€-ÄþA›šJ`úë<rÀzÚ¤¿ Ãâó¶"ËÈÛÃo“85|*,ÄÙüÜ›šŽ³§3/Ç¢ù¹µy¾(ÙÆÑdtšchŽ~,„lÿ°à%fZF/Ž¥•Ö½”g;Ö›ƒÎÄŸö®|dy;ŠC}OO!ºlÌ"Ø íns°Xÿ8Ø&z’of¿`„=}j‡ôÏó/n|âç œò±î{ä–Œ ‘Ù¿¾ýû†f^,ÌC[w>€”:ã{àµ7&Y¿¯UP‹ó©ÍÆ:¶W±gÿiØÀšÊ::\­TA€ùø`R9sº\&±{+Ùf†­“‰Þô¶X÷\òÜ�ûœõ]jœ9çšÒ¡Ù~ü‚]®ù¨ÖòbDt¶C«ïKè–ªÅÂùí0R"Ð;ë&JºfhéÙjÿÙ™S¦×PÑUθñŸ¹ë÷JN `SÆ:£iƒ¾ÁÍCåúAo5ôveÜ$yc=i®-×Xçï~6}„(6žt‘¥L7-}r§$`ö­¶X~EXÁÅÑÒÔ~CÇk+©)ÊîȲõûFÒ2¡ÿϬ#!×a™†›wsÌ5nŸ o¼Ï(†Wsšœ(¦NYÀç_ÛÔ©ç`N=¦AÞl”bÚˆo'j¬¿Ç»æ…æ=RÈØi'‡_Öæ‚N¸AdÓ¼£b§pÎ&~ëÓ=àê‰îv&†¤˜‰¾Ë‹ ùl¬ö;ýÏä°0N‚‡º—4Pv;/Ž«Ê-[¨X¬Pjà�Ý­•PžhJXôëÌ¿<ó¢Ð£eq棡{÷0ÿÕ¡a€– ßºv0HÍU= Ð3¯o”Lw()Itå:¾ZçtgÖ–ÅÉþ#뚪÷Óˆªª¶ü/*Q®ÜkªêýaÄÄãþo¡õQ]}þAáôÄBç³Jú ¡ˆ=ôJCX}é^ ºæ©ó}Jq5u áw?­×¶ê}­k'¥–{t€«ÀZ«)¶f³à`Â$Ü"_šGê!sÄ"Öz(Õ<ùžÊAxkƒÎf¬‡™³{{ñü[$ ñÿ$Äi9(žk´J³C iÞ.ñ¦?ˆ;ÕìP¶aÊ0ËäóK=~ÀŸDÁÀMé®–7¿xÁc®°lâÊx̉£Lg‰2ˆp /èü'¾2‘uÝ0òo Ž† img˜Úý®ÿx“žlðûl:ZÈ#›>@DoúR¸zJLÑ7Í'´Cx±ÑWbfŒ}]èg—×½|: ³ w–ŠhkÂcTmlþð¼¥?ˆ#›ª6ueYIi¬äpPŸ©"~WÍ»m}93iè÷€uSQý¥õÛÛ 9FVN¹«›©[à±Ûì¦'tö¬*2¥q«¦TY|&%'4:ÅƱ¦;›Çì¯ CÖ¨ ;ñ‹*q­CDÁf-aPŽ:µåL™iíøæ;¥¿ªÕTÌ Ms8’—ŸƒåÆÐy<;VMÝÍåmG Ì´½Jw~wƒd½`›f$éÎκ®ë»ßñ$ËA*X‰nT6Ø †ž"S×ý,ÆÔswþ0¹€º¼íw¤i‘-º·ç?yPmj SsšgøªŒÉvEjŽ*yÐ٭ɹi ->øõ×Èc-/1�ü±zãå­vœÒ³;áÜÅ-S·› ¢‘Ùö¤4£,ýÍ)i?¿Ì½g‚qèW¨lì¬ °;tS¸£máß-çj³ºUÓB“°WÖ‘¨h”þü‡qF4¯+Î9ïø”37Ë ´G·Ö¸&Û®Å,íG–8b§a‰¡À„ÒŠKû¿ÖR€ÎñÚ¢èRŠ˜ ¿ó®ßcTû:³ÖÕ£ÒKûÇQÊ™Ë Ýí=’†×úsEh«¤Az´œÝ¾¿Lÿ^þ¸bk ä6�˜BØrCEç­Ø}Å™’ÎF_~¤Åì¦Ïû:Ž}gïV”Y©ÜJ`Žq&ÃÛÇV�Ö ÓÃ!!òO‡«(+Ó|¡HfWæäÿòÂYŒc—2ô°:9¿¯ˆO§6ñú•*°‰Œµa$¶µâÜ›Ðiá`›p°çkÝî2‹ia±¸çôÏuÆvPÞ‚6þ‡VòZÕ½DŽ„§£0U r–>·°„:})¾(/Ûá4Oÿ¼±…1ø­¶9ou9òТ4}ÙX­"ï‰Ël¤é‚ô ^èJʱ¸ÂÅ`OÒíØ6›»ä‡`å 5]ßV‹ ™“ùêùüåpÞ0ˆÇ‹3úù–²+=5‘m˜Îô¡£Öš}ÆêµmŠÔ⌧!ØŽ;â…êþ'LCê ^øî”Ã8-‡ÔŠÏ'‘Þ‚ü9ý_û²ïE•ërÖ…gü™ÞúŠQ&µ¡7Yš3¬èæ;̓e@}ö¼ß`f7äÛÖN«rֈʈS¼|.ñ˜\ûÌkJl;MHÑÚî,&ŽÎ%j;%¯ö…Þ%ÑPo8Šá0ŠõíVÞË?g²àüȼž6…6}®Ø–ùv™œÒ¼YÌÛÿÜõ¹Pãâ[ 0Rj„½$ø{ Åá!à\”âÂÄEg)½méÝÏï&‰,YPxÃæ#ÒÉXíà2¿¬Yl{È2# ›4#Ž¼OJõ¯òþÐi'Œ§2Åwt‹Ý!ÚœiB•oU@­ºÖÊJòy¢3¼o®m5mszà]º…(—Ò[B˜rÁ9rM§qÝsCíX³^Ó#šoT¦WeìÐåtF±*VdZkµÉX.´œbY)¸=Ƴɘ!j»ÀúGJ2—ð†”ή$Hή‰E_î6@LõêƒûeT‚‰ÿ#<oƒ-{ð³!-Ÿ„Äæ„¡§“¶¬¡<§k{¸ Îo…ž—¹½ì¤+4IQjä2Nâ-T>G«] ví©—v9æïùñáBh¨ ’³ ¢©q I› ÒAidïþìxD}è[£%ú ê, Ï gµª Ó hÜ[‡.{ëajD™òÌöÿN'ªMþÝ׆=µüͷ¾i¾ ŠŽ‚­å@ ÁèÒ^ZbÖ§ <Ÿïºäª¤Ó~g2£õ©—¶ÔC…"[¦6PYhÎnûSˆ9|ñ�OM¼¾Íc«…I2±MWµ±Ð8ÂnÆZô;^sé*ŠL{Š³™<}Ôú¯šÆ³!¬›`ïÄò¡9LNK¡}˜IÈ‹-mgÌ‘m¼2á©<Ú†%¼Ñy¬¸u,ß³œtS: ­ÔbØhÑAñòWwì—â´Ì–f%û4ˆü!fÝ’n !ìð+nþÔeúÚs:V¦]bÝ}!ù:µ*}œvt9¤Ù sáÞ#'½ÒDK-?l´.(©¾¨Quf#G°ã¡èĤ¸'àm'C-|£8—æE1wÞ‹³éêÖ£ð% CÞŠ:¿Úˈ½_ȹèÐêÿ>;“) 𸨢Þ[‚‡¾–šÌ<›ÓÀ£~Yü;L‚qCUA÷¥ÀíÇ(Š›ø)bI]m¼ÉE½ô|ø°h,wÅ,éLóV"Êc­5y°Þ~C©~çœi_Íݶ2òý‘(å;¹Á²¢­EÉGJ`¬IòêÀ¹ú÷Žd•™*/èNà¤Ìø“S)ç=ŒÓ±ž‚ŸœŠnŠ… S›—4Õ 2Lr€-¢ñC˜ZW!Z°ÊâHës8*^°öìhÝúü^¿Þâß|ÛG öqOw¥<ÙVöÓ¾¾HjQm½l’» Sžy—¸î—w8IÚÏ ”uÅò-Î…“zªôAuÕsæEúw4ä¥~¥麌Ì=çA5X#ŽQõE÷gýÏ[ì4#!2tüݘEïm@Q#,ü£dMX¦ý97ª‡ó�ä„Gü—üh1€q„Ô(¬]Z…ó‹eJq}fŽ½†ö—ôú%Z€Ï“GPŒ¬üõjKÉ̶õSžsͲ?ê\ÿ^2ëñb­¬¥£P`*¸Žuiæ,Þ"¢ŒûvíCÅÌ,ö§ä.òå‘m_Æ€½n[hßÚö\JåÃÓÚ„= ¤)AIÀf)^rö©úlìE%‘¼ãË œÞ´ùœBø÷ùigš„´,N™¸½x5R6÷€,ë2�uçÝtw½Ç‘® aÙHæFòeÄw€'µ{º¦Éô<ñ®Ò‘a÷h‘9#™²\Ò[Ïõ(²»£0Ê’r“_8›‚…CíÇ¥FŽ_꺻]ç>`U”i¬…ø‚nêÑò¤ÞOÍŽê§|Õ~³ÛJëÂ[hn&Zº‹{Ì€*Ó8N8ƒ¤±çÉj<Muk¿梴¹EfÙÂf~¡ÛŽH$DJw£bï_eÉg´È„<zî�î¸<¢¢ÇZZ‰™ûX[%¢x7Îuˆ³Ÿ$›~Fj‹”=+ç†&ËpXò?±À„–£®ÌhÔ!{ÝÈl„.«3-ÆNgBÜ›Àç²·ß o—*&' åâÆÓuâ‹e{+¦ÂŽª_ær½cŠ)ßs ”¥U†õr8>uxõô>‘ψ¸·¶‰ÛŽ·ˆP]·-|´ÉóK îØÖ*ŠFð§kÏqY1utK´oÇ î±s ,lõž’êÔz7 txæê¨u½ëM‹SÕ†8ul[z;—Ú‹‰6ÚqëÈ•¥̽*ÿg¶Ä&YÏ)­ GqZ|–LP¸ýl h~tÜã-õüGeËÚcäLÙæ»åäV…Ó¿©ûæ0ÿ«5;‡¶–h8ÎêlÅ®qƒ—oWeäåü #ì9Cp©vÂî3ä&®¥ÍzÆkyÎyñ,ëÜèGíà,Ó¹%Z:+Ê–×®‘ll’n^•?†.ÔYH‘Û¤µj$Ï’1]™*2)hÂÿ™(“,Ï3%?î¥Ñ~ÆRaóˆœ}´¸œ*qß„qðDÁ¬p…éÀe^‡¨p\n«Dø1ÓIœŒ3‡–­#Uï¿Þ.áÝu#s#¾·=¦Aòå$TÊæîÍv=hZú0ÅK¬Ž¹{d7Ìö_™Â$Æi�še4Ù™¯•}Úù÷WîsŠ¥C±¹™<¿»× ­Ó”­ÓL’¥Ÿj0﹪[ýxÙxÆÒÐEd’>-¼“ãóäÍAXøш ³QòËfÉi¹™‰‚&))"Ÿ­V&ð¦Ñ|î¼ÏԫƺY¥5>‘¶N%%;ö)㤽A6€<+Á^ 16î<úz'ÇÌmÜ` c%Ÿ}+˜Ö'Hãe4˜5­^-fºôz8‘xcZ7xÙš#Œãx@Üãóâ9¾dìÐV½µc+ù¿¾]–¿Éõ,Ãf€õ·C´DáHÄ‚„2Ϥµ©<e|7Ãñ–±ý‰DˆX( û8VTÓLŠoy<°kÀz·ê¼JÄ7ÆDÛW…<•©hµSÑÚ='JÖÍQ¬«eFt¹�ûr¯Wúúy”e>H-5_F†™;¢£÷œMš2„¥ ÿÝ ÿ:€ÔC¤T„»-µŽÐÜ�°NéŸ>í¾¬ ‚×@ÖÆFH8þ[JŒMy ,]¹œ 3ØG‹Üòßò€gCL¾þ@†6¹ïRˆ²Ï!Í‚l² ¯L@=¼æÏŽ‘É0¦Úu§Åà žfêyMê¿&z/;+±™Á=¬@\ºR®z03vÙÂàè™îQtgÕ 8¬æúó¦uT—9a¥[utÇW{XzÚ¼žžq»wâ ŠãA Âiµ½v¢•’¦t‘ùnGggeÌPJ¾™*±bE ~§£¢ð½é~G(È×G9c‚|p‰<ųíáÌ™ûÚ>ô¾¼oí+úÊΑ ÌvHò m-颻ìúÝßíISÆŠd­D–Ý~²×)úNEh8aÃHÇøçZÙpBlêÌÇÁ=ÓæŒïí'Gü U6’kmOlL"K0ÝóŠuÓÎ]5p$³mˆ¼3Ä~Η$½ä äŒmãÈ ²�:(ßm1…3JûBz¦­ô¼MçiVšìˆWÛ¥,}àEþŽ°™¶X”ù|xCEGµt=ÃKZ…&ó,cU.ÚžEP÷ }ê/å ¸éã¦óbãÇw—51{8.<Nî*¥µËñ"ûÖÚ~P÷…¾7»Ò ¿=V€sò~Øvå¸ç£I….´Û˜íh,ŒY|i²\,I7vg::–·%Nm]˜òwÿ‘†AºywÀÔ0£?ºîˆ»¯| ZÓC7\ÑëW_øxXÉ©G50kÌYAS°|©Y'ÿ¥ŒN7xôØLTu§Î‹/‹¯t*‡·¦«™°öeŠ²ÐÈÈì¿àYkƒçñÐÏ;– ‘ˆ •Ïw÷Ÿ9KÍÛÞ°CQ1­™vÂÇœùg§¤#›^Þ³b†­ ¯'uùH>8ŽŠE‡‚Å>¹ ×ãªhÑ´ôÜèkt^š±ãÆæS& ' #ŒèisGí¨\ÃiiuqÎî&mÅ÷ü Šz‹±|¤Ÿv°Ê}1Éþ#Ê\öu½Nk9aÛ�>3… >Ž˜¬<DzÉ–„Ç}ìÅE)DcÁÇ´áàü/ÊSNˆà²Á¨:†ÇK?¤àÊÖ“1kâš|TÉíX_à]%÷ªáÑÌôÏùÐm€êòáô)M»Mq ºnHÃÏ¥§òà››/Šø%E[WD/Úl|÷Ô Z”¶ˆ/qÉò…¤CX+R¹?Q‹bˆË’R<Ù^3#ÿF^¹¦ÇcÛG¬Ox'‹S t,“¿:WA6Ø:�NÝ$¤ §-òÊH…:<AÿqÊy~”8,ÚÜù’pép]ñÃj»pDˆâÈkd3'wš!Ñ8ùNôRgÌèLQHYÇü³ ¼Ù<zº¥ëÅ©RnKpu´BÂmãë|Ìrä9šÄ°ØÊ $n#ÞÜâ¥v; rEd'›'cžMIıë"în”™ÑKÓ‡Téúpżjâ,ß2(‚f}‘ý/eÉBþs©ÏKíŠ8´Ò3—’»sÕ8ûB`e`|Òs*%"”E ò¸Jjt¸Ür 3­¨M nxÚ·å®Î fëæʦâ7¿àGkÆ‚L‘£ Õ28H; F>ö7˜ýη1†Æ«CB–õam‡yÐÕbœa*ë‰~cŽîæäfžDUOqë0ñÖ,<‘æAïž—ÒÙ…¥‰ík>m¤BØÖløsÈf¹«X·=Ýá÷ê>c"¥L+`ŸÌTûŠÝØpX©“(QªKÜù˜!(=¸é´Nþ°f#îEc‹= í”˜?¤Ó§‰1ÅÌŒ¢çyåec¶;¢ ôß‘-$§û¢˜]¸èRnC×.Þ~zÍ0®.EqŽË'¦_lé/²ÂDñŽ Â›ýÙj<*dm«ØýD‡¾œÝ«ín¡*íOÿÈ‹ùV¦p£5ùyTtãÃ@€t`ãð œÑ4 sØ„Ÿ‡9,†ä‰~b‹:˜‡/gÉN¸Q”€EÚÙ_Ji¡¯ÏƒÜ' ªèίљøÃœ>>åI•dŽßŽöJµusÑ:§ŽoÉŽ(ßq¸¢\uósVXa`êûè⵸69%aþ3ª?€ £²Ò¤»-»[²ëá£ßÙFt QKéîò3TDQ8¸6PÆ Õä³wk"3D¢«¦þwÍÔ2öÙcðö o­Œ_Än'½ üQ´Îbí‹AÉ d”žl±J*€A=¶¿­êéçÙh[tF›Iõ­=žOjîÕ:z­¼¨ÒXÿã?S~”bõ>Ò?ñ`+pÌŽ:åë'º-ÖGujv"•îÌ#5—8ɽ?“8m©[ת½'ŠÛƒP”äÔ¨p÷_¢Ò<ÔM4hËb†TnÚf² Åðã&/#ÍùŽz'D‚E…ôøгÚYeØ푲jW'°O]·ÚõÞEÔoŒ{W×]ª¨0³ªaeì&æ8«+1hRb'Jeê¥kì“Ž¸SUÊŒkߧe;Æi‚Ö\ÛÒĬÊLÝ©k`o~q‡+×–˜6¯Ýh‘A±¦ ؈¢½dò5“¶Ÿ‘c¢(ÍT«¶ä<a¶ñËãsŠkû“sœx!ô€)_^Ó?Ñ4*æÊÇÅÛ{Zôð£WDÚ"S²Ò U’”tGG;ŸeªïX“Z °öE"÷=Wu/S™‘Õá‹žkÔú»b%°MˆÚ'_ì$ýåo±¾Æí.4•˜M ©u°Sf;ô †(ó#6N^ƒ–j¨|þ«:ÅÇš•d´ç§¶i.°&t~ÖT§ºàt¿“³°©6Ón XT5ºÝiùô?IÔ Ù¼Em\‘ŒÖÞ¡A§ýý¿L©üßt÷2E[ÌÑG:$4Îï¡ÒbZXì¼,·ëÁ<jíE¦¼… n•Éf4ân,�fÁRÿ³ìƒ˜Z÷¶±&¡âÑR²q<TA:v*÷GŠéµ#h+×Ãì_Ô%·ø{q,ÅK6ZŸ¹ ?Ιœš<³’]þ(™s)ݬÈãÊãk9!˜:z®³m«4h»¿Õзàp9û$Ö}Éš¶À ÿü' 2‡ß½²†’Oº†•–Z¢;¿Ð²±$ » ûÚ5ˆjÊqŒ®Ñ·Ð¤òÑ_fºó€åxVÖ LÁògË#E fZ¼&5¦È¡áŽÂ~!bÛ]”þï÷^ð>Õfý?úÐM ¨a?[¢,½i½ªWnB‰7ýð­ŽY”¤z˜ Eº%ÙÖÂOú“¦Ò-Ÿdù N©27á"$—¢w+NÅ·Ýh+ÞŸš8²xiŒXj0®'UPï(œÍk’Âk‘žOEU{R€Ònâ8¨æOOvú‘²þÐ=ØÛN?`íÈ ïU`)™q}‹—Œ¬J6HD³ÑBŸŽÎŸRaÓø–ë–ïÊl{Æ&ÿ™?(…BI¥BÁŽƒ^ÁoÆ«½çÁ8¾Ry…íÿ@µ&UÍ?8‰›¿&耞°í´Ÿº¶÷ ‰ˆ'^Å ¹Ú¬!éõú8n –iHÕ•ßò*ŸdÈÃÁ¬¢µ¸v¥ï•Eð ®n³ç&}gC–á‚(™³0P¹ NÄÜ*Ú›­ìæDQ‹rgZèpŒ8éXÈíµ¯tè套tŒÜ}Nk‹}à1™{z¿'79Õb‡¥˜½Sa?ÖtÅz¢˜(F-óUW² wfZ1ëû÷"õlÅÅÇ~âÞþ· 7Ž;'Ê‘HšZ I»ö´ž¦î©Ä¬-Ý̈­»×{â~)5bF%GN ãdUPVõþLŒ=Þ¦]7¬.“ý€”9žûåÅæB¹®5%`þ;87¿°€I³#öˆ8S”Þ-+o˜Éâ½΃„5Š#}^†°ô¦3Ò»w!q™g£2m¤ý¿šËoÕTñNs”åû$ÈË7FÁŠî&tˆWÜyr ‹?|ŽCLMV•f;^)z‰ƒ®`BÁTxsèÀ#ÀÔHü)£0WfWÉ/ ©Wïb˜eíUz~jä•&±SŽŠ™´\SRúiû Iº¬Œ-Nq¬å›ú‹ÿ&Ã÷Ž)|âÒ·<C®ûýË‹;ß²ó7£®ýŽ¬_;<7Ð<Œ}û¬È‰df¶·ÊÚ÷%¶Y²‘â×®­J‰“"íòû9 _DlÞÑÒr„ÎdE¢=ÇÝüa÷ +üûÜÊ÷s#cþÓL`@Ÿ=V2Û'Uã½ WuÐçÌzº±ÉOm5ówžõöÐ{'ò—BKUdJÀá”i•Õç,÷uj;Ç@ÿÅØÉÚYä�¾×´]ü¡Ak,`ßo€¾~"v˜-×<|Qª7¼°šq¬ýM)AëèÐÈÝ0¥»ê=$©‡âsþ9n1L˜œGCqÿÈäÅÑE®a§÷á§E¸ „´6éŽÔG/ò9uãùÎ:|¼ x¨´ïrƒÀëNv[•u Ðv” R¶ ãÈÿ�O9‹ÂkOGTþic¶gùiÁÙˆö Â Ý7 LŠb!½!hålÚx} ¬x¯\äW2æ«uJrеŸ½¸Ã ñøÀ¤w¼iÝ]è¿BoØRYv”³ú{¿Ò6§âöC[÷”Qm9舡¬c<¬!ñ$¼çÓ®—gí¯Üd0ÎÔè$áú ê6±sqÊ#k uq¯I„¦•V’¤“tµMašæÍ–º™%ŠŒ1Hj9ATY7î9<QÒJ=[´„=o;ç-x úç-µŽÌ9žƒˆ~I˜ø©ÒL)A’+$Ù‰Gv†±@þvµ¤ß—4Iº0 Ξÿp¶° ÓûpÜ[9á»­óè÷¦Éá/}Ñšz”'6Óžv¿Õb ìäʃ-|µf`tpן'lqd”¹‡!¢:ac»¡pÏDÒÉô×Yr:]„·›Ń_+þXd¬‰ª øÜ(•æ¾;k¢ãàzÑ¿Ô*«+$ïj]‚½\+h6lÚ· Ýh4­j Hh]\¢$Ì}Í™á°é»,ˆæµb›ÑN^vNãeô\« ‹ÝAa(˜OµgQQìùàA¸Ã¯¼`•É"¥pæªÁ£¹?0v q†¥ù¯“Püö—Æ×S † ƒAün;|XU`qz GÐ)Ó•yÏvâã¢]µ°Û¡›¾éé½U ª¢¾3ïè¡÷/!Þ‹ṧ«½h¬p­¼Ø^}ã¨ôNž'qHžÓéäƒÐ˜‘cT|,jSß^ÜÛNU¨ÇuTãC”}¯Æ€�Ž¢}ଠ<9àþµšvù¢ŠÑˆt @+¼Q¾’µ«g1ªQ û‹;áßk Føt{®j:›Ñ6¶ÐŠâåäãGw1¹ë¿ÿ¦FLO’VÅ0Ò*Ë]†ò�+0Ûé7·Éè;P^=û°v=ƒVÅ9#tÚmDc£€Pìv¦ |eQyügŽ;î²:¼�‰–/� TXļ>Š`û ÏÅøn›Ã±ˆåÑÚUEY xcWcŽ:¬¹õ‰™àÏ”4–”îŽõ=Sn–éÕ#ô²3\5å.iP¬7ÊHjŸg9Õbƒ§‚ -²â2¿Ñ>ÙëtE® *ž¨’+?¹¨*¦Nu(¸Xê;7=ÿ! *­<4Êض´¬k J#¨R’ ñÄW•+%ê±ï@‹:«/NÔ®' j ±I–"Oôxè;æ­œ;ù^5ÐrÕ°åhÞOè.;±£!‘ÖÇžŽŸ‹yüSXU¦\x˜¯ÝpĵS‰­¸ž‹Á™�¼SŠAüþoƒ¥°ÍRæå>–¦J³åÖÇ$,?VmZ fV·Ý¾uyÁÍ[+Ððî¯{ÚŸÆŠ‡UfÇŽM'«ëi¼Òqt>ùÕCõO&fßvydÛ¿þi4ýŽ{M¨áû"¤“çc„H»#%LW<SF>Xúy5Ñ®lû¡ØTº,ËE bË<ØÏZc³A@ÅPÝYL]¾ỉç0d¨~zÌUâÙK&Øœv»YFAŽžü| óІ÷…jžü/Š&EÐÑJ*ÚÎnîJ¨®à°p#ÝA®¯_os´Ôƒ ìé¼e™>'Éõûú�¦£a£‚\Ù]‹rÊ Y´0Ž~Ùovœ�HúËëÞÑi®#è€\TEÝŒþáâŒöçc?Ee(#¬é\Uãå좚›QG×m|ј³ µ1݃#Nýääü: ‰"Ãyk³ô¸NÄu仦¹ÆszšCeæˆû®¤°¸Q‚Kl¬°æ›ãq>_ÛÀºQ–Á.EA;Ã_f´M,)b®¶^6‡f¬¡¡ó¬<¦ƒ­üŽ r’¼‘r§U^.¬b‘WÁ˜sÜ™w”Žfû”TÜ×»þŠ±ñjº²25RŒ?¡y´þžy 3®Æ{Íâ8YXĉ€3lK}IáeÄÍù b6ÿs¼Äo”œ›4æ$Aì¦é‰vƒY.ît_ÙÞÕ´>¾³˜tã¾Üð!ÚK$G+G�f»pW0îÚøj¶ê庚g™B*³WTNqi­GøŸ˜Ùœ2¶›�ãzÅÐ"‹5ï éÆ”Aq±"ÄL4=˜”(”éš¿ãðQ‰e¡^@à$#pbâ2ö^èé)»àŽ¬…eÙ9žÈyMyûÖ0D…uýG÷Sè‰PɆÇÉ_’)Ñ�ÑOi'Õ±„ª²K† È®Ñ¾7ìp¦ÛÆf8 Vë4£Áê JJï û}û*ε ¥Ô]D•XóiùZ¥“SŸÞ.p^²Ûf¹Ï-«¢Þ#‚åÙbªM§2ÄOêQmÕþtÜIõK56(æ?=p\F‘P.ƒ=×0³bè°\ =GáãÝ~9ÉpÒNòl« ‡_.n¾·6¡E¹é0V ¼ªó,xýjAˆ’¾0, –éhŠ¸Ëÿ¼•¥-”­ìÉÍ9ú«B–‘Wm)ï݆>jëH|:u[Zg&™ ä«fÏÜÑôWlÏÞŒ½ËÂÔ×xxŒ{sA{4 Ö¿oùQز)1©ôjO;~Ø*È«9ž0„0ÑwmÓ¨ò‡jÁÕù¤Azj=QÁ1�‰ÂÒ—},9 þzWj%íîKñŠ0¹�"ïÁ«òÓÅ”%Ë(Ë‚Ç´Åõ@TÕèN[ޘƖC¿1°vCØ̸pù_n¬Ô׈”iñÇVg* ÑW¸Wÿkÿ¶º²l‹¢Ï_á·ý2ú*º_[Y ÓËùÿï8Q#22S0nc®²wCvŸƒ”—z‰ì§‡Û¥Zu„“ÕÜC2`:¥~ÜÎÔÇjðÑÁ¥Ssœ½Ô‹î¢Ù¹Š3˜–Y?¼´þ!’qón?k­½w¶ùþ7`©þ06‘ˆû­$N²lí·È팸Ûy§Î‘·öþÐî¬ÇØÝV†kiÄžls\.;àö­È1&¬çÁRìùla›ù¸Ñx}{A´_h綵3Äv³tÁxS9ÜÞNâ"[£4OünóâÕ讲½¶Y‚çmÊÿþD¢\ªÄ;#ˆ›nf\úYô%.»4ÈÛѺ†¿sœ&)D_iùä+U%zó}ŸÁz^ÐŽi~V‚žŽûÑúxÕ³=[ i]îc/ÏÑŠ }¤užÄuðJT î궩ø´Œc‡ÃH¦h•Îɤ SËáí¥´Åo)¶ˆ²÷I aç¯n€|T+CH”QBí´ÍsîäµÍñ ;,£®>‰L«Õ†ãçý£d™~ÂÄج3o~³ÎØì5ú;˜Èqîu‡¯ûs7s÷N¦É”g…|å±:>mOˆÔÛCmIÔôDkäÛ…% ´«æOîÙÌfH¨è‹•A²S‘¦Ïö8í�1F²?õTbE Ê2ŽàÙÐC;{>Døßœ(¡}¶½8pìaÜÆšIr…¿i Óy–ùÓjðãgP¥T˜4Ï”;©¶©öq®)Cï# aP}ÚXÅ ’CÛ\=dFwêu0¡”YM (yéˌõ–2’hé¼tˆT9 9‰ºŸÜKL¬ì·É9bлÚú†A°3!Sm}À áÆüòÊ 'dFuv[ÓéçÆÂ¥fÏ7JÔc¤x聯IîËIЧïç’Ö¼f—˜¤ðê⎊Èþ™mY?êÌ�.u¤ílº©lØT€©/·gàÉö‚ÉY馢OÓʪW™$@øŽª@ Ý°ßW:¤ilê¨c‚©ÖF½å#ÑÖóైÂ×ô e2†Ð÷[Α*MDFÛhSÃcôäY#PàÓ Â\¼þã±ì/LzÞ/&*Ø+_·¡0-ÉyOkÓ"cdËt>Ž6z帉ÿCx]Û]š21rF1¶6²Þ@0˜þÇöâeðÿÜYQi»`‚4î<U•XˆJî<,—‡{¸…‰*7NÇBÍah$ïE6ÒÛœ9[Àlû7ðZEÁæ‘p•ë›åF¼;ÓAn6žà¸/—DË;Ó¼üt65 JãhÁÞk³hQ¶ìéÚäqÕu}R,–‰O‹Ù½‚°Ú ‡ ÖikDæø,‚Ã�ý'èç˜aûiæ,W_]6áÙº ßÞ`¹$Ab=\¸ ¶× ´eÅ÷‹; ïÌž·%£nNôLòA¿Æý•+s…¤ÿZ‘"²–šU-ƒË:ÔJ+6¨¡ÑB3¯C?ËÔøn+0ö;ÉÜ;û"ˆ>µ‘ŒÖÙiœ[ëyõßÌ*óŵhåoª"ȬS$›·õÒŽ–·çùåw.¾ã8w}W¦ õè§{M@Rˆ)ž§Éçê?4zº{©tã ÎŒìk˜#ßöµêÀEEXØÆ$ìƒKƒ‘üØ:Ö?ø@ÜTÿ½‹èÚ×o›>É| Üf20{'§ÎÄÆl)ž4 Ò̺êé<ÜâLS3SÉú§#¿8/ ³`Áx7°­Xmºn›ÿæf =×¹§6ŒfÁksKxxâ£TÄN®7fw…ÃôÅÍ8½1$3µ�ýÚ"=¢A á:ÝLkJ— _sCk©z·ÞφcÙÏtÌ\_Õ˜°º¥,6ˆšÛq?GlÈô§Ó½úH8ºÈ3" {*ô‘¿¾ ù Œ Gy: ·ö`öw¯ÉÇ–¾„&p»cùÞQÕ6@tõî$hv üCsçbÝ3à†:4”Zh1y„âHìÁæ´ &ÂVíwÖ³NM ‰>à$þ6!§›òQ/¬Zgx{ç»{ß/c¶iÎÑÒGÒ› Yl—4[”ÄL<` T_XKÌä¡;˜Ò-'!íêëZþ%s¨oV4¦¿JIÏ솷Sm<‹¬Ûc +ï•,7÷ðXàb´…¸‹~oÝzã7•ä£I¥ûodiÝ›‹grB;=¥óvÐ"®n¡S£ßƒ�c2Ú÷בox¤ Úítú0õúú'ŠÙiµV*ØP¥˜Y—ö4“§e÷mž» u@ò¬×q´’¦Í5÷ik+¶—8/qó4zñܾ÷‚”ÐÍDÜB¬@Gw¯àT*"îá#át2-~ë3ÜÅÿ¦0¬@麣E¸?{ „»ƒWÌŠ¤÷<ÈÞ>ôÁ2o¥ä ‚_(S¨:í‘@¯{ wÎÔCM[÷48M"œ®¤6¥.TÖjª7ÐËðè`«ûÍÁ¥c?[–‰ï‚>ºU­*”w»ƒ¶ð%ÌbEjf+ez§SAÅ„œÊæÅ`ög¦ ¶ÃUŸs«²;‰AëÓêØpC/ݯ 戡t1ª±dÏ8É|ëœFI«èzF :`¸7G+ôÕF‘£ÇÆ1vž)M›T*C¤³îh›vûb/ŒkÖx: sº\õô6 åSùûèYµÂ•ÈH«š7¯­~Ú(²,iä%®•¸'RN>5ÀlÚã GØsàÓ üG,¾üæéSÿÄ(ÉÝŽI8ݘ‰ã²rK&3<ËbÅc­y¥Z™ª•{àJ-b5¤:À¥yÿåæ´t<½@¬ND¥µú¢Uy’=‚nÁH2™;CO6ö#NÚ:`y§¥;�Ñæ¶fI…[Q—ˆîŽÃ¡K·öÒä¼~"‹Ô‡R Õ§³›y$|"Áe9‹ï•Þ´Ô:zßxW+S"f±t3«¨"ÇwõÌ=(Ê<¨¢(…N!¯OÃB*СãÍÖÏ?Fyžyl¡"è¢þÝ#¬«€¥Ë>¶ò‰âÌ'¿ «¸,Üz4q˜’s‚ÛCÎV¦±lÛí&–V`ÄæÿaÝatN¥é0v{ºÉ£e‹2äŒX †Ã^¬*ÙÛ÷rX:1þ³ŠæÏ´Í£0ɼYvdLâ¢w‹y�Aè�Æ‚C˼Õì=„{,øÍõØ>ÎâJÞXi0@‚élþÖØÚáðåŸ8)+ç¹Q ªväýÑôÀJêFßæØ‚~öéë¥qKÑ€1éì™z\úÌ ‹)œèú[{ج(ï€I]`Q]wž¿ÞNˆÅHÌ9lƒÕû’ÀÞ±äp…/%<“òspýå-œUí‚}Éà^­`ÂÄìÞÍLi‚z·K;äÚž   ìR1§)׎ÔIìÓèÈêAQ-KÎhX-óÝj*ö‹ò§&½A¡À‚6pü>9m/æè'ëgðƒûCêMþdÑÕ°ám¼y\wX ÉT¡n(!™—ïB<áJ>*n¶ ÒͧÖíl<=ÁGÅ®è¬J²@ïE¿éZª#®ž»ÒO“Ž$Tjœ´u"Z-ÀZíÜ͂ח²µä%-ù…Q«ÞyÈÏÈlW&7)á%Š4ª<B>lâ6¼¹•BÎÕ%ëÌX6dž°×o¯«"­òæ¸)7‹»2(æÎk(Ž´œ¯ÜÓ=õW&)íh{š–¹wý'Kœ£o;Î$ö½„¹›âã!± )Ùåº=Q.¼þA_¿§.+cp{ŸrZßÉfô°¸ °ždó°Š÷ÿïÿ›ßúë0<þÁ¬r eß9/QR¹ä‰='–šö~ô®r%ÃóG6üR,Ú%,M‹f<%UZ 1TΪýÃ,Ißr·¥ œ(¼k踀ñpó“Wh–ÊÕ «9'V”¥“,MSº*íþåm|È<©« yÔ|¢ŠOÛw*Yy<™$qá ~õà%þ¥'‰c/#g‚ô†Þ1ì,_0ör# ‘9æ‹]UvcýÓ@:¾µŽÑhxŽµ•€5b½à›Î=ß =Ž¬~thÊÏ ŠºÂR2bÆ{Áÿ•1Â:\úo”ßcÊZE|µjÏæ®T–Xl³ °0rîv^W•"üØ·ºÿ¶€epf/¯· í"_ê+(ŒÑ͸èýÎ ñ5G¾ÜgÈa"3»}Õ$Àºgé@o[2üê=Ñ¥ÞÑ! ]µ™@µÈ4#Èï·¼|‘0Go¹=Ìlå2ó‘¢ë�éâ—ô2_�#NPM:ˆ‡ÅOÜŠxô…h‚3JÇW´îx?¿ R¨òÐóפG�'ƒÄ)HA6m»íÌqþ¿¤á*‰¦º òÚbm"Ë@lë=µÅUÛ×ÛMU+ *m»œÊ¶Åtå“ÇD$ò[ÉàdS6Û+×.z4uVu½§ø´âDåFÔy¾‹)<lÎÄ$TZ§¯"H¬$Nøå`fã¡Ý¶v£MLæG-2mÈ´~•}¥æT ¨–Œ+%Ç6”q4RÚ¿á¾&+^ÛIÅÀ«¨äÚƒ”@ Ø}ÇNì“6QÝå#Ö¨ƒF3Is4JpãOE»V¸wg„û¾žYnA}tß^|ƒ XŽÔt5Àe†Y‰ómrP=±úKr¯wG®0ÂÁ&ªa3{bæÔ{5ÙÅ�ÿß»Œf'7„ ³mb­ÚP‡Ù׸{Š¢Óc"b]ZD©õuH ‚ôК·Û%#¨‚z@Lh9nh[[×з§ñ„! \�ТDzïê eø[SSáðè·h3™¦0 ³ÍLçfqµ}´àò£¦º€dÜíЋ«2ÆÍ8yÐ !Rø.†P"(‹R‡E.6Ê8Ås—Òñ¥â2Ñg’ôLÎMØ뜎;­ÅÌ̵=‡7…d7\Ú¯¡ÙeèS´éM·GœÚ¶-d4à)ƶµP÷ŒwÊaîN#b:+L›øÞï^Ž¶þ£…Q& ëºÅº" ¨Ããé‚Þ¢°š…riQœ·Í=>ºÒºEyR  á‚"¹ÔGx%M ™w?ÄIÀõÍ7µ¥dEñ¦7ÜäôÎÖ¢ƒý¹}Í—ùï[d€fi‰Å,Þ1nªúlÀšÅÖÃLh¥çÑ”ÃxwçW%ÀQЮÀk²L2)’íˆkÝÁ*RŸ×Àº†I”KíÙßìO§ÙP%z¦½|žL¢u(ƒýL¦Êý΢¬Ö#Æ85–ôTVAùî5h>Ï-݈å|Ô«¥ôÿLîÊ••TT¤¨='£¨Ñisпœe•­šG·™éôJ'­‘Ñœðݘf4ÈÌÓþ&X%ƒS±ËÂGšSò¯W€ôÐf‘ÕEûž"€ü{dîóÛG‹öÍÍO`¡W™÷ØáQЬ™daåŽ×V£zÖâ16lо,ÏÖI¾NTZ}SÏìl:ƒ%¨/0±¥UGôÞtpE¡¯q3+ˆ¾®ÞÉ;µ :_­ ¡C/št—¾ÿÝßݯ6nææ8;Œ Ý!«; eº(ÃeÒƒ‰Í€¸¿ÿ¼¥‹í¬Ï­dLbªL˜öU­ur€Üï‰vŠ!ÓES‹>y±ü‚Ôˤ„‡n½ScA™/Rª Ó–0M¿{?=l*&[$”B¬‹ öÊ/,ÆÈžX l~’GTå÷�UÛj´ìj©‡E+€rr;ÐÅ_¤en.ž ,—¡ßÜ7o¢WkÓ(–®¨s˜ÛšßT^èÈ[K—`£†¾ýN!ÒELô‰¼›ÔÂŒµ³—W”‹|ãaÖÜ>R”7^{•%æÝäW+iá6`¤¡ªEõk4ˆc³ùÜó¸XÓÍñt5qÿ´ý`Lâ±Þn1~Q/7ŽJMò”˜YÅ<WA6Ùn{Y ÍÁN2ye¨-Ïê~˜íÐ<ú™ÂYäl#¹×º­iõ¹œ<WÝŸ3ûÖ;=Ò?ئ¦ã×âqð êÍñÎ^ÌF]úÛõ ÊÜ÷A¶¢œ²²“d˜àü” ÷ß·,|ûç-3œŠ’{Ýh÷‰o îÆ#Z—ÅàèX¼k’ i½©,ìO'ËÏøYÕ,ÄCç�ÔMeï7Ž¢AùMÇgb­Ùp,Ôן .÷B³7.:UrQæ"ä&;¡‘è+‡®†Ò²áî|-sˆ`"ž.¾½©UÒ0‹–¢‡£¼­$§@åžuœ`”N°`3óTŠŒ•¦ßTÅ^Ÿi¾Z“ºGK‚Ÿã§C¾~ pÏ4!Mêt#êÎÖ c½gäãóÌ¡Œ½9£Û–KĵVïÐ7ÃA¥óŒ‰ö#Ýa{ñ¬ïý'FgÍDÒ Ïøò§ "+’à¥fû$ÙŧFšL+Ó…W(ýIåªÐ"Ì<o;VkÁ·ùóÌŽ^¿ë…¾K»&=Æý߬G€$G|°£ûÜs›IŠU‹âÿîŠ{£‹Lä¶êa0.Ú<Â`—Fà(ô?Ñÿªon¢Ö•¢RçÁ‘¶Ó{­÷‚6.ÏÖõN¸F„wå/t¶t §#Õdž°õÅk"qÉÌf&’BQ<›÷0 Þv¸Ã’I?òqyfbÔzP–ged—ÜD·ªfHýøÒ“©P¸(1„÷î‹JÉÍÕ™5ÑÎ;kw„éÂaW=i$Þþgõ§¹Nƒ¤ß™3t– Ç}e'=Š—¦y‚Î+�- 8õÔ¿3‘�Ú­Cú‡Î©Z鯌ñîXàO_|g±Â˜HoXe¤õ&\¹ÃôÅyJžúË o<ÄAõ¯æ] ;“×וj´ØY¼¦rê†Ç"Ò ¦ ¦Ço0I\ëìC\–:ù¨À•‘ˆ¡øÀVÞOA_œçM*:ÕÖ‹ÃË «5ÿ£'Œ–†L9CɽlUÏ!fØÊŸƒU´­.³ûöŸî4¶ßAï?MÀ;Ù ¦[x¹Èêm@ÕïÏ6n;.%ý—!ó­hìËÐûÄŽF¢Ì@Gfxš[õ—|;â©Œš:K'öžq’ 0¤/n¨ ùŸ=‘döî¹Çwôg‡ªd{`'Ü¡lx3èšÇ¶ç¿×:a¿Ä‰cŠé(sÀŠÁ·tñÿÎ�‹òÔ^GQ̃غdâQ´ Nf “”cpX~šÜæ˜ÄÖŠ¨TöµÌ»/¦+4*yéÞèx¡rîNË=ýÃÔ³ Ã¾O‚”¼àû(¤O+⼂yÂÜ}ûa!Ñ—Ã"À¯£ÿÇCžfщ9 ƒÔ‘F‘îsÌãÖzš-X± ìš K£€²?Ã…§Ö£ rBbFÙö‡kŒŸ„¦rúe%ÿÅÞ¯()£4óû#ó5 ŠQå\@28éÓ°˜;1wS{±—'sÆz—‘B÷d°ØÌfMÞ*fBˆå dBZ¦c=- R/(=tÿA£âëHõ4—"Rürh§œzP[m00‰ '™YØ­—âÊŒ}Ñ‘YUâ–ãø¶B·¢£¢ Ò©w'' ;-×~ÒûóôÀðñ41æËgäB,Œo c©çÿ¾Á³CuG§¬{ŽSTq¼ƒ_<El3B16G“DûwYi8*ü�È­ìlº·-¤ØáUö$rÆŬrOÏ"2sr@L.bjHãÆà¯ó·wkkî!âØ(¼@ÄÌÛÚ¬-  Çzæ¸l…×CãôF}ÉsUHåpÐ…áüÆ4È›è¡ÂÑ :àÆ.ý»mzT¬”pÐ m#ˆT\^Ȧ­ÏÞõgéÐÈ€þu)Ƭðl`ˆÆ[ë+¹îs7¢Þ’ü”ÎòÛáïë "L«4p¡Šëú3 rïÚ*‚Åaþ¨¨+Å_þG7õvðÓò%^EWDªtôÍ[ÈÔ[xtèO¥˜ùŠb ¿éjÍ9? mg›ßôá(=ç7ÙjGú 9¸›c‘,5”•I{NlT#ö¶Ø)‰W&âN£ÉþK〶aUØnÄÞIg^»Ö¸gïªPå?Ak Šð¹ìÙ_Nç¹Êø=Û7õYâ-^VIï<\¯±h`ô_:ÄÅ*1£ÍÛÏôr«üÁ$Úw¦‰Ý¡ÿxÎň#O¦GäþºóŨ$ ;ºZbŽÊ3Ò¢iÙÿö®—í]…&힯=£VKìážj³ƒÓã¢Â—]7ÆÓå:›1¹‰2Ou7 .pz>ÏjkÈVêÞgŽ†#B›ÙÿÍ«áÞÆyg®!é)Ui36ÞU?)^zøxœDÇoNõ(óaL±ø†ó—‡¸µª.Õbº(›/{FÕ ƒÂ–ªã¢Ë"ëà›%*&"Ÿé¯ö}Ëd§;K½Z7dèP/(‚ìwΔŠmŽ–éªA›©e#TLÓØ÷Å^ÜϪok¨ó{ö¾H?+  ¡3…P¯ú`÷‹,0’µ«V¨U+„v›ÊɨWïëUÚ®¦Ë ¡7”œÕ{A¦ï ÐøÓì=×´,ùÉ—Oq"]ïƒX3QeùfH!§nÙ›3Ë5åÁ*?à””>õ?›+Oêæ<Ý’È«õ ¨B’8±¥ß¡‹ÊIUkÕâR/ýMé GN[Íê.ûé£î üQå~'Cgˆ’uÐR ÔuÖ. 1ûtyƒÀH•,gøšD¥f«ÑVßÇ%{4x& §f¨Ãf£s~ƒˆݭ퉵º‘Ê%Å„ËueDnèÏ¥ ò�À0Fb¬›†âÐ $°Ìt&ý,°iqÄ ` ¸(FSmÙ8°9€ '£ÏäS¯QÇ-\Ú¾C®î%%óDS,«]Š{Ó¯J.YkÈ«Š\§™* †r;¸ò0!?)hÇ¡jŒ&Eö8`ÞG¯Ô?}¹·¼ÔË­w=­ä/¬™;‘._=SÚ2èUá‡ê÷sÞ(+|5q:d÷}–ñ¨­›¬ {9-ó›é á`¤ÈóÀ]ðV>îí´P9Ö7w I"ß�‰¾AS—A´Ù™cÞv§Æ +E–mwP‘C:{¦]@É�Wüžë†æ�¥ @uÅuïÄdLeNN³Œo_W¸kÌ®ÐHu?±½y»˜AàŽ­ ükäl(în¬¼W¶ÑÐ2 lÜ´^:<0[á¢ÐbÑߌWѬ3XJ%f¯ÓžªðEHÂL‚tÞ·^ŒQ*©ÞŽsl»rò4éù]“ j†Ï;æ_Å"ø¹Åáùý å-Û»ê½óz‰RM¢¨6ØΗLïJ7ž9 Ù÷´¾o’O{£©§Ú Òêͦ½JÁü".µPø¥¨½T¢Ö5ºý36+®—ÎoR¾&Ò“ù£B¨^(š„›+DP5ˆ–¦2ÿ>@æ'ž8%Ã7Ú!åbswôÒëÅÈRIËm‹7#Úÿ·ÒÚqxã½™‹ œ4ŽåÜy{;‘’?òzjë®<V Áª(]Ó…y©ûá¼¼¡jt\j 7̳�= ŠÒp7yÃúÅÜ«ÅâßM_¢|·H‡dåH‚µGdÛ\_…ÇDY|c[yi ýô¥‹ _T>Á”µs‚[©Ÿ¥y\r°;VYè)ªSZC_Ù›VÌGxÇkÞ†£ÿô%»/}ƒ4÷µ(_:¾»F¹š´áD¡Öœ…¸ù‰óCâ;?䢖R€PAåÓ°ÔtÞ8ïúï›ñ¢ã är†ò³å–æ÷CŠVÆnW³_ø0áqÏ“êKçÈNPn(ýJ«ŒÁ7?:ÀlâøØ´é 5…Š«¦·2qrö_w­š,ª¨Üt¯ÂMŸ[z³eã2½k™ŽÇZ¹æ‹òÃdgù;RjrɬöKÉ4hèækË‚¸æøï:S~ÉŠ—?ÊƤiæÍ$YÎ9ã{ã ¦³Gº è$R*À]ߧ\q”­ÌÕJq:8¿»4 ?@ÉA¼ÞŸ{ø :ÌÇYfp¿kOuï4`Ÿ1¿iíèQx¦hÿ"xöyœ¹¾¸¸åQF0ªìÛö4Ž¼d{Ϧ7›ˆÊòÝŽ·¦^P¡+êí>DÛÛ³£Ò2PüÏ669‚ÏûKuHi¶" n åÏ©åÖñ(6(¤RÙhU–!–¤º?–üü>‹÷ŒÜÌN•Üè¹@w­^¬çŠ€0ûÃ|_WðÙP!wœy9¾Øù'«×EâfÂJ:õo¬~R“N˜¼0 ŽEÿÛó$)æ¸C[àúKôD¯ÄôX;Òú—ð|­nZóh´p#ù²œd•ûY 2¢K¤gËø‚ú:Uê3 ¼+á‘_…WÚÍâlŸ¾ÓöX�MÚ[& Øê”ÔB‘ZñÉf‚ö-‡íÀûè]©”EV:”f.]ð,ˆEžê¾­w>«~!*gU®¾ËĽ¤ÅNKTŒ­hýæ“TR}À–µ†“/U“㡸HúÂÛ´Æ�{NûÍW+Ìù‰;è&kàó þÙºÜFê]Ó€œ•9ƒœPX~ã1Œ  ì™i3ÃôâïxÜæIEdAôâÐ?½p£mbŒ@ËÁfƒ¸×Õ£j¥O…v�­ÜZQ”U"^J ]>ñšƒ«›Tqþ ”17|[LU ¬)Ž ¨2æù4Çƶþ¸µL«üögÌ5ˆ‚jPùà v²RÿZ!4[„á^Ý;ç ËÐ^ÊçNB�gó &ðæ§[ÝP%àk°¨BÕF×9­E¬;ˆ¼«?ð¨Ê^|;²‹D¦×‚_ })ƒbP]ü8ò›0Ó¦ðr³UÜo8¡ß²øŽZOáÐ`Nó Üïœ Ûþ°¼„<ŽZ­2¼(ýÌñÏ«ž"Æ@ÍWÌiEö9h¹Ðç cÜÇ¥{‚è·nàF¾ÃkÌ ½UÓÞZmC£gY”O—2uù |t'Zº¥‚ÊÇخж±SU0œDZñÕ0{’HTNL§ÍYYwalÏbϸNœO&Ⱦ{†ÈâRˆeËiúùš‚‚œlCuhé{¤›³ëFNg§bŽB.g%à¶`ÀÈX«›w†Ö@gVä´è± ÒýÕC"½×Wíøn÷MÕ,Œ”£ ú¯TS·Z]CçþPïÑæ°p åÜ»º_„Y &šRnµ •ØÝÞs"24Y´_¸ûÚª:Ü-Þ3Í|Âtgº‚UNˆ�Ú>'¨Ú‚@ÔÕckµ©ÔÈÜ]-<½1<Å稦’ÐD´Âc^+F-•§Š'm>𥢈,µBdILøá¿(/BV'cPhÖ5 Ö{góÍ5Ùë‰8TžYÓàÄi æÚ¥Î[Èÿ¬·¯·úÇ&Õ€”ð%l&ÁÚ… ÈtÐBy¶?iÉ•åÈöŸwÇ-OªÌ,uy)ò6øŠÚû€‡Zì(LµÄÌÔÛ­nêî:4Ìg^¥RIê v'F7= ÂNå’ Ì"EéFŽ2:„™ö,Éé‹Š8Iúþãh«£[\´ .d˜¼±Æ‹ŸÛÄÑÊž“>;ó“‹OMIæ-ú<=Ü£¤“ÞËWð ñ×Î/–+—¡°¶ÝEà²lR¿ZzjbÜ>ö{Ö°:¡ÿ?ÞšEeì2žT):fŸÕQx†&l $ôæ�¨Ô›—a²+¸cåf¥¬¥eyÌ»–Xé…2ÜnGGüòª…klt·së:€ O¦±¸sC7}qвš„yQ¬õ¡ÿç1 ®Q^i!SÝØžxË…ae¹ÙAëøð8±gt’M‹)êŒ=…‡µ¾ã­j.êöö¨¨Œ‡º�C¡ƒ‘Õ¹ó\”°]æžjI4o¿¤œö±OOÝåcO5-ä@ 5èt^<‚ */‰ØS÷™&tä²KN»/Ûè+(ç‘¡¬<±¾†›î6AºÇùsÚÔ½ÁèC¨Ðtù6x/<Bb‰Üª¥•_5Ö¤ã�Ž+÷Cå#eî(7¦ì¬ ȲêGHêìG¤uÃ} ¯…ß 4!]'0-‹°¯ñ³Ü´Š{S!È÷U Ÿžþ öTÝef°þxŒX³°Uûcuús3?åã§Xfë‹U àW[—VçÄ´‚²`¸@ÍYõ 3îÝBlÎ÷ºAìÇ~‡ê5nyÌ°éa<x¸X.Š=¸«÷Ïýô>ôDÁKŽØÚ&¶Ü�†%›Eø1Ô£�­ï’mTpδ¯§H´Œ¬Åñ:;S_y&ýy‘Š„a8Ó•m€îIo~[ bjiÓl³;\¡ðÐÔ“Þ56) þk}41î  Ï½hïĈ“?Ž„aåÆŸŒa3®¥÷zâæŽü’ý€€â߃"8Œ—˜ABAï°—u‘<PëÜ‚½eM“Âo_Óòmj$‹s;ÖWÞÑöå5V­“04ïiOGgÙ¼;Çó5óai*BÃ\E3~¹ÎQ¬}Lif>GlàÒÂ+2¦¢ïjÂб>{àî•ÚÝ„+ˆfs½µŒÍµõü¶^lÆd•‘ö-ì’>]I9•=&sP61Sçxs94 ½!k¥–KÀhK>l)"G¾ �Uœ‰3ñk€~aŒ'Ÿóo±)Úíÿ™`’éÿVÀâËi!lÙ÷x‰iµÉ q&$ÞX¬`ºØppë]N,>Éß(dÜ1ÑvŽËRóÎ{†9ÚV$;Äå³T¬l\ÈÀÐþG.¤©®N@ϵjœ ¤,ú"ØþI‹ ®ÕbdÅ./hˆDgÖŒnœö®^*ž‹®f`ßJÛ× c;w2¨íy@àÛ—”V¡Œ»Ì‘ìà˪Ⱦ!<dãyëßÒÌJÕû$LÓù½ìšj±'¤,Øn蜪µƒæÄ?^ã¼D¼æ‘XFR•+Iê”2ÔéƒG’£û,õ,«W®ò¥ŸDÅãÌa⸲íÛœÿFñ*¹hŸñ>W¤û~ß·"R¶=ÑANße匔Y W¾ÍZâ8¼1ÔÆ’7°QuK8Ù”.¡ÅyÃR˜Ûâ·]µÒ±‰"5fÔÉ¢›qîpó²pEó¸3ä`–t²DßÝ®­ö«ã‡œòÓcùÜ8º¬Ä„ÎÙ슞‡N{ž_®>Á^éš8ˆ‡Éb Pu1h¬}4!aP¹� m&.g›ÚOª<s•a€ð+ÎòêÛs6(r–T)“ ?‡ t@û(Qñµ¯Ã¥sxMŒ8§˜Íö,‰ƒÆéÿ<* pq¶˜i¯ƒÎ?‡iõK7²‘á¶æÑ¿níßt†ë±mü†YT¸¶Û4o7ô,’¯«éhãdé]x¬GÙ÷ô©'–Ýý¥yª•”Jƒ¶>~PPÞ-æ¸ìêDQ$¥£vª¿bM¦Eá‡2*9.5íþpj\_—U`yHÍôI6ÕâNPßR²ö1œk³)M@¶x_ÿÄ#JËyaªÄü ÉÖ©‘ióŠy¹ïYóòhü“8i9$t”:/ƘªÐY«&«7Dgòñ$’ rñH ܪv]ôg˜Ü]<šÊx´-œƒö™g'Þ¿¾$XiÄnš²úªÓ–Üýæúæ9ƒpkIþ}õÄMr7 fP놎â³÷T‘^Ú¹ù|l©|èÓ»zX£¦ „]ª®'ÚØùÆŠ*€šÁÊVÌ)B”Û\¹?‰nÂÜ“‚*ŽòpÍÚ€;ßXÞΪßÊÄèæ ¿R�pŽiìžÊô«Šn%$‡wï©êµjK'swÕîq]wâǾ¹FÉ:‡¬©ÜÚÚƒjVƒ¤Ç9‹üÌØ äÕW¶pòÄÊÐ÷AGï)‚ªß˜]“ :÷vJ±‹[Bši=2ÂÇ~ q˜ú¶lÛ_(Øì÷î éêk3¼½Ÿ+’0¾H ê…X  »_¹®z^e7EܾÇÎWæExJLyש0DbNjîe¶gl‚ÈÙ¶‰^[zûÁ€Q¢®#¯q\ïL'^u¾XɶŒe@(1V”§”ÿë—;…u‘;f¤A¼ïuVðqí!ˆhì¬Èú }‘zPÃçýÈñ�¢È�.·Kñh ±ªFLNÝ•–Ù­mªS+ù융›Sç¦ ÙxÊÁÔîB6•'Û|”Ií½n«£§óq™8´é)BÙéÆiÇc@n›�{ðçiåã«Ó&ø·†Òëº,º^…®’J„†¹ ¢Y!.°¦ä:H:诣e}AVûÙY[²lĆSFðW1˼$èûô!¼m0qT4ˆÅñ¬M=Z±›Våµ¢(QfâØŸ"Ùmx5«"⥸tE½ *çR»½y½P•€ÌÇ ´êƒQWœÅ-Ê^XP®¸NE0\(¸u£›”SL¶ÌhÈ„¡~tá: ꛕõ´ì Õ­-H:¦T¹½×†nÛî†7„¾zs§iG¹ÞŸ……ǺcÝœ(W½PÀhûêåCÞS<¢ÊƒÒÈhÆÜ¿Wû4¬¨Ýt82¸žÙ L”ãÑ´ß\¾˜Æžþ ˵qǵsø0.v†c™‹®Jà©Ör÷Z§ÝYGFF£s¨n:>Ò>}BÀÕî o>ëÀí2~šeÞ»&Ló ’IÁ#‘h=iB0èUíõg¼½óô&ÝTéy10þT`ÝHiNË¿œŽ×úGÛ5)K£D4ž)­ª+—�Û½jy‡e*ÆT¡¨§"Ȇ½›Ü±~Ñ»âtWG¥_ÿD4¶ü¾a’®-D2öiIß­ú¦hqUi;|¯:6­uµbv·MƒÂÚC‰¢òl.ögC Â6’κ^´7"UÈH×sždM´ÛÇ%ë>oZ›×å+<2½-†¬ šZ»n»"ˆûOÃó¥DêVˆÕæõ¾7 K¨;z‰œä�µ±ÆÚ2€¼SŸù�×…ýHq!úOZùÒœPR&°(i'Íæª#-ÆÓR*ÿ=´8ËŒbe TÛ]N‡}­––Úö5Fó q½Ñs†q×ûiâ®$S¤éÔÛ÷5…H`«îÿÖ7.Ì +æÔ3ºw¯´"Iõås¿Il<×Úˆ½ùº¸æmP •ýÕ+ÛúP:¢µÐKšiÎ̹0ÍÓ©C'ø¼¸.kضC«ƒ3vu¡…ÛÁæu½ÈÓ8=!öæ¥,'·rεÞÙúçQO±æUl|­è{OÌô5ÇärJEÒ›Ç4(ëÖ«.}VNsv°;òy+ [îPô@B掅˻ïùqjõÑ6thkðäåEæ˜ç.†[s”Ae™8žF!ÝH~v­—Ÿšä·=öbskþ´Ã²þYDŠÂÊT=²³þÀpS»g ˜Î_ñwƉÞÉŒþÄüAI@­FmIZèg:]ˆzãËÚʼ D‹}ÿ!&A6í­Ê8º’Ö t‹wàu¤w bVòJÌšLT­Z•,úf06Ü?ß,¦¹DßzªÕ=½Ùôîi¾Q%ßxz~@’õ›Z̆ÌÕwCË(É2Sydì¯3Ó‡-:œâÚè$_Få#î?óyl§Žõtï7?©j–´´K¦ßue:]Ôù·Š¼Q´2gJŒ‹H±4jH¦Í‹÷d_ÞiI†Ù§3bŒÙýæ_gQ½9ÏÝÆŠVþÆñ>Šãس«À}Â$p¶’•¹¨±=+~52iŒ0¯wæÀ¾ì(Û`°¨/»Uq}Y1«åþ¤òõŽçmÈǶo_÷M3å¯çfT5_‘*í6¦SŒ·£„™Òh™‡Q]<Öó_#Ýœ¯4ˆœ ®ñÙæ e)Æüµïhï(KWT­”=Žã÷/OÎ;Ÿö®ejÝÿ”jGž… #¹ú„r½F% ÁœoÚ«½SNêó^çÌ)Šx_ Å”Î×É_òk›,|Å)˼%JÄB’(ß÷¾.aÜeG<ËY÷0‘‡KÄI*k¯ç7Öô¶ê%/M-W-jˆ�«h½âËIÉN½åp=3ª­·¸k±À}äÚýï®±ú³ü•2j‘z¾%üæ LXš/Ó1ËVÍ]>ó{¼ÍÛçÙC;=ã¦Ùì/JU“l¢mœÖ“×m 5`ú@ž3,­ :XJà ´U—hF†ˆ0í¡.ÜÙF8@®×„KsòlX´Ÿ9ä®}ÖŠR®,)W;Úm ÌY÷oS`ùs°káÈ"”ìÿŠûOY…¾.h ýZ»`À|öus}Û\'•xùN—¾}…„’ež¦9¼¶fÚ"›Ùª\[gêÒd×ÙŠ_ Ó*þ¦.bµï šb&ýÁQ‡·§ÉZ„½¢S›džÁ¨¢—®zMK …G¬¦ùÎ*üËÿª‰hêAÿR> ÐÀY6ÚŽ‚àV°\ùÌüKšH‚ÙiDÆØ~ Äóac:/8›©šÕº±˜‡‰½uìúfxÖëŸ</ !Óâ)è#:ù#ÆSõz|kŸþªŸjõý##Q¼?'TmÛä ü:ÖãœdÂ"(%ùWÐ7vcù[,K³$s4wJé:€Î­ÓLd7pgÈPÈÙr<ô®¾#¬ª<\ÙÇ0¦)‚ð½6¸Ûó@µ:ýéù|XÚ·ˆþóu6À“·qºÎ’ÏõØ=q¦‰þU¶?Fá‹ŽFµÌ^)@¥’óRýYHÒÉÛUi»™ ¯àQÓ¯ŒkªçsƒªNÇûInœù¶!sO ßN¯ÓÐPÉ„wûí®²'N?ÓRyïßD=í­7¸}F¦wÊéeJÀK*놂Dɦ|5T»¬«,¤üÇ_Rù�`Ž›8HíþbÝ>~® >Ñ ùcZ”ÄkÇßÆlAØž½Là6j äŒÎúï\¶·Ò8BzƒýùBkq²*âìžIe yªyÐæþƒ|â[‚Wé ¦²Ý²XO^•á•z“Ñx->³žŽbÅ„æ ÙÏqP´­IN0cñW¿cØ{;eXE²{Ëèáb*Ýš¡ ›Ž˜«ÜW ñ@ø|4ZywQZ¢l ›Â]pˆ»½gIêËbÀ !Aª¢¹^’ ƒÚÔy:˜|í\)#Ÿ}H'Êx‚Bsq«BâBTpøÔŸ:ïQå ¡Ì=V³•DF"Î'vû9Ka,Cï‚jói2* ?ýS„ÄuãYf»dAÒª``Äý\:ò¡£‚ïe6ñANɧNRÒЗʥåO=¿Vü¡ÛÑ3 ü¥N†oÏÝ"ôí.Ñ5ƒDhrÖgXmûÇXq`ê|ø·í+«*.ëV_âfÚ¦³q…À†8•¦µ2ÏCÊÂ×2§€ ɶx?º>Û=Yo"×öƒh›çsUfÏ\Cµ[,¯„%ZV,o!_|àTÌû—±ß–ºßœ–;¿aå_ßæÄ`ä–Ålùea„5kò+Ô_f˜‘_¯ðÀj¹@Wm³óãT57ÆÔS2]Ë¥ÝÛ.Œ»³›NÖ-…à²ýôÇÚnÍšEì­Üï‹Ø‰²ŠIL;di‹š‡ÃÂU,ÿïÌ éjà öoTcÆsgüår#ë=ì±m}Žªm:lèsŠªˆrTöo¦'ëôÛ‰rœ¹[ÃÄüR—‡xÇ––a×ÛÞcÈÔz "Aáo]È£ëÚY"ÆÁ1¥\q?¨4‰x'к˜fÞχ©ÇÛ¸UüT¡deóÁ®²ó¾ ²N§YîYXñc›N×Ù kÿ„.õ 3ÙD\Dk(¶Þ»@¹dÎ,ª¶îïâ>Ë2ôìÉ°ÐvôðÒÍìor€À”‡û`2âMH¼žË÷§Ìü«óMÞÏb·QÐHƒ}}å.¤¹'ÞÇSh–È)—ÉóÙjgÈ‹Þ`·Ÿ¨íû¢Å,åÞ£g“ž{Ïš³§®¾0¼U€‚ôÆ„¯¶9ßw1¬%m&ésO ¿ ˆržåk"u%ƒþß™çîÈM (a­«§„*)„9w±39ÕÂëEVÞ·Nc[zÇÞú™±_e[Ïéz‘˜¼bà(É$ë·›­ªË7ceUÅM•A5\¼âŽ¬]Q|x¡àx—#“áå_¿Z[“í%6;œNÀr¦/jÚÝJšlhQb†ÆŒùxeâ\ñ°«àB)çxñŽÜc}•*èn§ïÉ1` í©é"ögJj‡Áã Ój`ÿ|¶ªàÕ,¿Q&` Ó»Õ)’`Çí–ùæNmc&[ß;v•·S)[éhJœl}Âu+¸›Z‡¨¯é ¶¦‰7¹ÌåÝah®¦‘ªÝâ-öíiÚ{ÆÖO<©ðþŽ(?­yg…䙵©øS,ív>»…úýTIB?å#øgAùÕzSq^‘¥ Ч%†óîôÄåVè¬*ê*¶bÊÒZ›g“¾F?‹ÍèÝÏ!nbÞ[DíÆÍÅaGm•eèh6½V9ÏŸ{蹕Z¾×¸#›Öñð©èßö-F=ú‰nõüsþÙ!™aÂh·ÿ›y½«Œ±3—a×1fp®¥Žý_ÄѤôÒ3†bDæÙó¦ëϳH1àQƒy)-Eu çÐt+m—9}©](¡Œ97¥^µYã�Ì4O:Ú{Å'1üOžgžÂ%uçMÎð<G,eD&ïñ\6I¹z”R¬d¹ 1E¡âÆ÷ŒBZŒû©<ˆåd‚„IKõM÷­×ØŠ*ßà—".(aá°s°ç#²·? t¤°èaÖDÍ ñÕ´±NT,Êßn=¹Á²ü ‰Z:Ùüið±àáÖ³ÝÐS½Ô+!¶È(�øð<U ”ÇÚö– b!�Eìù“�qª‚¨·*œ.׃msQp3Âxzñ]D.® 70äyÓeª‚òlñ»U @9y4Óé Hò àœL_¼õ¥·ýI®FÉ6=ZAÍ—'€^ ¿%x,ÚÄ`‘ÛdÄ’­®Sßû„Õº©v ûÆp½eÐżÊÏ€Žíp½•Y¥úÇŒÑï‚þ¼é§Í»ëlêCïI¿Ôo¯YØUAßж?×®ç‰âÓ¹I¡Jë/€ÅnÎtzwwòBÁh"Ü‘[JRÊÝÙÉ/³·ñšˆ°?ð¯BøÛ1yZ¬¬:Jª« Ù¨±;˯RÚ¼ éìL�‘2!ò5qùJå<dpHñx gü×£tn8W7©nài&aþã=}Ü ¯DyŒµòã „¢X@Ò`f&0bQâí+ßÇé‡H›”¶Ûœ±ƒJlÛgs»§ðuÒָݨZ~…YÐ}åA:\=Z*'ÊJ£˜#¼ŸZT\PŽ+¼é©;i¦Â©•)¶§4Èlq¦ UgvˆÔ¬šÂ¤]KîÒÆž0Ya²áƒoÀÏÙsR8“ÎYÚÞª'l6ÁÞ¨®9-ò{óETóÑê|Š„¥ ó‰VLh¥qÑlAÇ°l»ðà©ÝÙK¿+Re7¾¬»¶ÿz<®z˜½óõÉÜúá;º¡gÃ# ).;­X¶n°±Y‹Ëi¹I|d…&l(¨;A²»zL„ÍéÂ÷… 6–� ãòíJ3Ú�lJ]Y;úŒŸ C’ÁŠ2OäƒúÌ u‚'k}IŠ(Ý×Ô&£0_å.ºEdócÞþ§~y˜ïX]—°Xp´ë¯C«ç  |YLùVZ¹\sþCZÃ�²ž•©“z[c³Ú|úø€‰fVœ+ ÐÆ ÇùÆo+ ö‡‰>Ï4ßê¼½¦s›•¾t>%U\,FWår¡y…¨‡¾ì ]ÿ?[-~ûÅãL.uy¨Ìš—K„ÖŸ%ïíS7ª ÆÎ7 ÓºüûŔשê ÏxÚƒºðiÊŒWÒQèð×€’8^m‘° °Ÿù°XúK¦©âö¶±k高¯Íì£ 1¼™)®` Í…¹ƒ_ÃØÖÖ”»…g˜ª’øí"s24~F=—¯r‚BÔ¡¾Ï7@ÈÇÓäÉRÞ»ºÁ¬ÊÌã‚Ó-:~¤ó/ßt­*Q1©Y{í ã£+æ†ÒÄ\ËSYý`Œ± &šñÜ»+$j<{C{º¯UJ†v-wÁ°}gÊ«.k$-öÊ4Y³Ò1‹fX[¨Ãô“Í4yûçMÍ€(„ S„[52<‘¬‰£Ø‚4B–Ê´šu¸‰i&‚+Õhžl*G¢E¾%šê߯îäTElmq çÁ¥¡ÝúÕxªƒv<oÄgq¤s†Å~_7?>uHtUÆP³†™jÿ¯2s+z¼R1 â¥¨|Y1vññÑIèH²¨¹"ˆÍ”Aø® ûˆ­äÏò©é ÖÇöÀÒа÷Nu¿^Uwé)~D¡’k€¼¿\ãÀy•…r ¥´—'.ðqâc,1?§^¿;ª=5JÙT®Tá ÷®ÖØÐôÖúåcɃâój-qPÒ´ÍûJÛù<mÂÝ5ë4áQCÈ…Y®Œ¶ Jš/vœ¨94'¦}ÿ0¶[aç(1Í{V-L_T¡ð¿Q$ÔÏÂÂÖé"3ÂΧ/8W]ŽÇ;¾äÛåÔ+&Dì±î¾8=(ÿX�’‹©£®Ÿ"=¸ ­úKœÌsrÍÄ{œ’Ù¬?ÛÃ*$-²ñéDÿK&oOmó\ßÐ1TUÌݼ’qðôs•¨H¢`N¬ý»rßWF‚gZ~ýՉţöïíØM÷9ÁŒÍ‚¤Sß@ö„Ô(³ëwG¼ïnà d¹PTôÓÂ>¡G´•)-z-²õbó¯X©í@X-º¯½W1ï(Çîë«9 h›|h²à.!h+µ ×” '”óD®þËôœ,´ ¯Ö_Ÿ6<ʲË’%̼‚â—Û…F̪%¸ÖˆC¸#öâ ÿ*Š*ë“#¼Ö-ªŠQ›ŠèšqÂØ£"îÚ‘N”ff‘ ­‡BÅj*–ónÇ^_ï%e¨elšÎÖúGÙ… ÇS 4"`Û.§Äà¬óNiXgš™>(p(åoAæâ‰ÛNëE Búùž„¶¦å¡«¸TAÜÍ­k&]=Yð¯qyê,%S,*BkràoU7¶:£Ü=+‚jÔ\“Ö÷ÌÈ(ÑÏ>&öˆÛƒŽ‹õ® Ê5Ú´ê¹>–O¼þIå=,@'Z•e=YíZ¥‹ÓY¯ f0‹Ú›ø»?ÍBåºy]íÚÂý–ú»`äQ¼[ñ/Ú·-Ú'¢gÃﻎ£pÒé™ÐM�³k2¾g÷1Ö%5]±ÇI÷î5sÀ€ºŠ„•¾ýJn¹Â·`^ÌÓ•Ï—1mïäZÿb–ÙËJßR-ó®a?2i¬ƒéjñ©Sö»W´S+ñ‹]sž%+N\{¶|\(m £ÎCi½ú Ns£ÑÀe ÀØ}æù_C[˸Åþ¶?Ñ[og¯>zãƺ }…a®�ûÃ3ÃJ¯ƒÍ·s ÉìqS<f¥áQã0}©MÔ±µ2BhsOg쬎)Ô=(K…çµEըݯ‘xeX–ÎPIZ¤Uó¯¡c¥EÅÍŠ‹rA Øø™ô}¸\5/w·AY®´?(ÊàŸZkÈweú85#ƒ’#¢ô‚G!öm7DÐo»"<Ñi·–Þkà5ŠŽ¢7ë^!f(ºæûÂ'l?¶©)xÆB¹@°ÇÒ0ÏÏ€7¯-œFÝ-«mãÆ—ÒqÀ˜ªUåŽn¦IÊ*’Às¹Š8=.'¾Ë Q{…¼,IÔƒDæ„�D–¦AÑE×M¡'¨§ˆªÕM@Bg]œ@»:QÞ1­$Qã®ë©ëñÉi¸™(ý}×·­L3oÆNÓh’™Çh÷,÷%B(äÀΰWìÜg,Û³)lKžÉáD‘z˜e¦g8T š~úû O_Û¤Nyl8œ‡¾P&mM±™ud[ï‚‘ðfí*éòàËÌaÁçÜ\±Ç&˃ÔÂC]Ð>IT7êõOhmh§ùû@0[™#†qpü ?€�ÿ)¦Z`Ó]m­o—m‡Göºj^ôŸ¸Š­j“7§`7­ÜÝ@Š¿Ý”¢þE‡Ä#»>EBŠä }Ã}üw?«§ÉÍÛÃ,….÷,i³Ò‡.¶ëaÆ¥ªH°8-0‘Áçûÿý3Ë@@U|yËö1º°üK=HÏD¾üG6XEÓà)¬%‰‹™ÚíoüSý=aØrL’ ¾ZP1X §+ë "9¾áó|(ÉW â0˜S0]Fg“Èœ ÏÓŽ>üÑU³N×?¬Q¨ÙJÅ9 ºs„³"Á[€£ãÙZ#ý/Cè?iZf>˜·2²g¿o"P<ÛϛпxƧ)¬é 'é-)Ö~i‘¿4ÔHüC#ÉÅÜÃsû˜ÙðþË í(ÃøfÄX?o•¢^a4 ü=¥ î/€ýÞ“nuÍèиãI´ °Û˜†Oÿ“/Qû¶äD>ÕU ùº¦©Gn2­ OWìr˜¨ˆÐ—uÌ_=ÜCF´ ÎÿZ%ªÓqä^“i-a~¨lʤ3Û­e`7ýb£¥la|zË–O*ù 0¬Á Ç7?ùÑ?7g?K½„ï;'Ì-HP›- ¥­_ä…½EÚáVì%òâ0ÛÁ�n1Z”{Î\ zª-x~{rRL‡SV"•åwпÔS¿»³(ïSò5tæpáñw½Ø&¤8 6–ý¨€¡–>þÓ’#ÕçÚ"@1Yœ ég–æfs2y$OèÈ]•©^¶':I,Fo†*{CqrºZogŠEáss}jÉO½©úwyË÷QÐèe[—¤ü­K¤–ÍŠ¼‡ÀWËi”ª‡±vçüqÕ[Q$+èÜaYZ<C{Z(¢…žosÈ𖱯ð:<BݪR‰Q ú#Ûë=ÇŒWç™y±r¹sa¯Gf…WñT¯ïPº{ ôDµ¨âPÝŪ”šÑ{ÃMÝ´ÉáOCgj­ gJ°oHAëǦÆ÷ù$ß©%åj´N©ícª.ª»Á‚çG8IèÜÃCÁè)øüW.½5Ž=r£gšN£CF!KöÍéŸujâ²r(V´ÙÂs ¶ŒÒ·tÛq1Ž.Öo±ó fÉÍœÄAYºædÛ¹7 Ù ÍAêFPaÜþËtªºQ!Ùîò”Ϧ lkÓ‡vê Pv¤òP‰e3eܤ‡ÎÒoǬij:›¡ ªYaô)ˆÚþê¼Â؈ñ‘-N ½8ôK8ÖŒ£\.½Î®† œr «q7ây -}çàMb׈ Y„³›²VQ_<d ‘¤í'Þb?;ŒåÅZZÀÌ*7ª·�Å^ ã"&/qÿ7ÊHÍÞ„Ê„Ï`›O7Aæªæ¯¦üÉ º†'V•AñõîIÈ£Šwµ·˜;ëTj¹‹ïÕ[èL„swiè~G“êƒìzv™­Xj ‘Ñ1Í*DY0›LWõõŽnT¶>¯Y×zƒ.·Šƒµ¸Ý:’Žý]ÊúÛ†f R­Ãh¨Y¾ÑŸMÄ�G¬ ý„CrZH•Ñ[jP>uš¸›N{À ¬Rûe�C+i+'ýwZBqú?¨ÿ}aÂÕZíRj‰Þ§˜EpšÁsõùl´èÒp¶ž¤ç&Ȍ˻§�ÿÁ° ÍÕ~‡Îˆo ¯ôN_)¤.õÎ —µ ¶ ãºšÝàôÓËð¿ÃúûXXjn¦˜}[¥í@¡–ÞÕ*¶ 1Û UIÜõ˜;Š Щ1¹“a–}c•Žj$Ý.(H�k ù¤=WpˆR–Ì“õØ#Á‰&ÛñTÚÍÅt¡qœ‹F"2EZkzÏ¿²ˆÊÜœ—‰Á„ŒSa•Úø§œvìøõ'ýæbUÁ·Ý‰§úºF¸”•ß&¥ˆ:Ë n$c£Š+BD= *z«t¬_Ú¿…±ÆâOd{EUU`ŠL5&öâ‡ÆWˆf™ ” Ë­|sÈŽµƒ:x,ÙaU õ)9ƒ×8Z˜}ªQ¡¦nàSÁMQ½àc‹raÜ :«]L{ø|ÔUlD/s?¸Š )$»Ú³+¢±œ»}åð2ß9’ÈA¢¢ú’åô¯«$·=;-ýj*ìNÐLb¶hYN“BTñDáÛÂVɉ1ÒF™Û=ÚÇ‚lqv£Â+j'óèÒ*<ìÇ‹'yZYƒoéX· #¬â´=½§þôÆþ9ÿ}ËÁmÝœ@ý·'ÿ–‹^¤ce™í.¡{>u¦è‚᜽Ê)8Öxp{ûzÚ_&Æ»­¿jí‡Q €ªï¼ô¹kA]7Ç"Õ0•59f½R:e›0Ñͧ‡Mð…¡è½GÇÊ1®‰Û­ÏÆ÷ßû þʶÏ6ok¹2ê æ0OZðÑ€YÑ‚o=ÀiWoHþ Ǥغ ¢N/Ó Ž½þ¦wù\Wè†)a‰:-ëRTŒ&RMȺ1–CÞû<´e‘o@‡Ìò~_êë±ÔË ‘òövï»ÁÝý6?~±pí¢š£îúê±Ý͈^Ô4V÷‚]wα9cèÄ þ/ª³Ï†ÍÊÛZU›Î{Lˆ½¿y²…«a_„œ²£ìç¤T�Ã1ÁR£¬NM³»¸ùÄkŒü: E ™0]«†Ìxî­z‘»¼¯‘åñM¿ùÔã![ŸB†«´±Árj(&°íÉ^Hl«™P»÷ý¿¬Â}Îú±½ME½M>¦ßtÈrðEP}ZvtÅæÈ2íI燷—á/÷ÌÍËJ�Éš…ÕÆ´•K›±AÍòðdzk¤ÜOfÕþËm¨±mBÍÎa°•´½¤´qÅQÅs ³W±ðÀÀ–¼g«Å¼-NÝ•‚ut2=À9A)0«xy/B²7 3ÉHöÕ¦æEP[p<ý°•,ýCÞ þ£g»Jã!šø“B>|.M Ù£Üõµ8dhí÷SM™fÙvÎÔ!Þ_½ÜkKÉá¦uèp 68˜©¯/œÝš×õîªgp]¼H±ÔZ;%âXz¸­t2ŸYƒÅä·Ê©\ùØRìm¨êɺ־© ƒÁ9y8}´âyXþáÞ«˜ýs>šÓóV“Ê6Ô…rG·‹å2²Ïw®Ù¨¸äÜbÒË•Ñ¡4p 'îUز,JãÚÝ~ÑëtÁcZS7 -Z™Õ,�ÎAeæ«e~™¼( ¬Êó$³z”´]úˆu°Lä^™¡ÐI∣ÙüP­Eÿ‰ÒÜ!~KY²‘`¶ÌX,Æšå°¤|õ‚}´p³äÆ0l €õ¢ä5è­à:¡YzZ@›úê]ݽr,b‘ ¥÷ÑòÃSF~88þ¯å“<×d‘wXê2ˆë›}èdõ7ú –B‚“5.ý‰L–ûøÈb#ß‘Õ=„3¶ã„¬ÄíR™gžX½×bác§zuÜ‘§Óêl·-nÌ/íë­á®ä¿ªY6 TlŸ :ãÔs½‡Ï³ÀÆ^µHsbxBÀ_jNlySOÁžÃ œ˜Ž’"ó½úŠ`΃òl5D ?z_ê¹HÁpE0wu©ÿø<*sbŽÛP²Kzø{µLLÌœ{S­%Q—ߤ‘iåàÈ“5ü«eãìu–Óq~3.Ÿ´ÍÖ”õ@IÈý‡› h™µŒÄ¢à>°Î¬3Ž+2ãtdü6(3–¥ö˜îÔq¹ÝÞE«6»ìíüß IÍÆX}K{…J çâ›ÖjvóãZù•Ø¦#&Ò–JXJLšÌzŠ¾`$Z8jŠÈRöPª/ZnbôF·ð40Íï5,g”;£K/Û]áp«ÝƒíuœÎóZ ÅüÎbm®Œ|c‚:ZZw<[’Òcñ0ó”b^;oøp¬áô I*Ré¼µÛrŠÏ1§%E :ꫯÎS‘Á•r8šqùs7ßž¡Þ%Q{ 1›´^¸-€ãFðsx£ïÃL¬ß.ŠÎÖ<H÷ïŽqð!3W×Nç`q”ÂѤ |˜ê‘š çcѦ8üÈ‚ÜÚî¦ EîO®L|Ý:#Ž<gQy¤R;ÿj=[è¡æЋÖÎsÍÓ4òüÀæ ô³~ý¢|ûç­ ]ù†)»Ð¾ -V8OqÞžèÍ3Ë<Lc`ª!Wrbª¹q[Êëæ~\Zx~ÐÎÓ^­ê ¦žÑÓš”Œ#2P{’þ”ÃS²JI͆%zõmÐ’©=TaÞœ²¼ ›T‰r�o¬˜Àg­ždw<ßÒþæŽC‡I®˜ Å€¡Ï‹±@jk›k½èS”ؘÁ'7Ì-T¹“ý¿^~A‡=NûYlâ ¸†Ôe·¶_9ÿF¶¿Y™Ñý¥¦³|¿7ßP™ªR“¥|¾@ÅÍœ¾‘4 ¤_7^QŽ„™’‰}ÞÀï•k7m\ÀAa§Ã½}÷j5Óg1vž¿b­§áÊØ HpLa3«ØÃ܃wüd[&Nü%¢§G)TÕ Jß B&µÿÿÝ´=­âÔ‚RÞ]Ê ÜÍv`±,yn[PªD ârØ:¹ D`9F²ÝœP@Š ‹ t„[„ TÙõf¥/~Å{JW©(Hq jÕ‹wSævØÏ¿æ}ÚÞÉ›áˆYÕd5 ˜¢Òú}ûaÚUERQ©W±©â»Ò&ßØ’¦hµŠw:&÷»(y¾Jì`áFoÏ­MÔE+]êNSý¨™¦~!Q¦di‹c¡÷›ÿ�ZhÛlÆ-EzÃ/úÐg…cñËbÔ4{_:LÚ[©ÐWáOQj‹×îÛ’Un¯J§æÞïúVlr½!ê“‚? 3tz[.”ýj§&z@nDêUD2O"n¢,ýÛW_¹§0Èa>ç^ëpˆ½ŒuÓ@eIio(œ iß6½ ,n¡†åJù:†‹eJÏw±Þ„@̃çÕôЪÇ«Š€ d?³ÙîR=5øQxi::æ—-Š …9y`„5úÈÃß Xwör‚ºJR§f+̇yÿÁ¢¡;a­zO‘!Ê‚Õ3€ío7HpU†Š“à°¯‚ÌZéelPJQ›ÞòC‰1ˆ`\æHòuóc;‚Ê¡› …¾~0í#-Ó¼±<ª’MKépžøL98Œ\Â3ŠîLGrì,°‡ÎbýjÓn̸&fÙÿÍl¶p<`Œféþ””€5î ƒ±‹Q‰cZ÷–!_-€äGûÓOùtšz”¶HœŽô€[±bŽê €µ›n¨žÜEø¹2,Wb“!xô´n뽦Œ@25Ñ{<h+WŽPa· Z•òl´zGK¢E*ÉæUÖˆõÿÕ |–§~.š‹ÀN:}zt—-,àýÛ ÅÛËn=•5§[úɧò£znç‘jÊzpºJœµ=òç+2ŸPR”‹÷®Nÿk#œcn­‘°~"eyŽ쎅ðRy«Ë}>ƒœ÷ÁH§83ˆ9÷¿+fÆ8üáïkÝûœbG0 Í §‡û,扵â[@îÕüØö"Èr¡'y5?~?92¯§Ä-¶aîÏ"ô8ÿöo3蘥€‚PËÜU蔊VŶœèV9ƒî’åÈÐ͵̅R ÷P¶Þ: µ 5ZùVÖrÄþó/TmÙ[:3{Ê^ÍX'ãžÍtäP¬Ý¦ï|ÖgÌÖ$Ï|³ƒ(‡Á´k-W,N•e?ì²ß´¬<CjV ;—½|d>ù2?èãækÛú‚ÎJ?ÞµU}GãÍ9$pÊ|ûã3ÆbYX²eÂÔ=U¨µUK@Th'˜æýš½úl¶žu Pö<–AºSÎX’jÏbÍ"Ý u6#ûÖS·®‚–‚˜½²[çé¢Îô†Ê*ß•a&oâ3ßðs™ëŒí*ÎeAºÙ8¼ñÒ}×*à;qîíÙ˜Y6@±ç ¿{EŒ ³‚Jà 5“W ¿Ÿ)l­‡Î (€ÄŸúe¸û5•)ÙæêÝ*$íéI—õEx±;œê`] >´vö=-ÓÉÓ‚°rÌ7DÄ[¤ù÷XÌ$-W¦BB= ›0ê,lW÷°ù°ŠPeõöÏ[eUNÍ~Yßö£c†ß£„Oò ì ÕÄuûaÙÅÆÕœZÑ;vóŠÇsÝÔòø„ ¶Ý•t2:›Ù[Çœ4KøÙÖT|â)_¾D?Ò²Ũ}³‰ƒäòéÙ†÷ÖqP.F=£zþ~õ†ìîMHì~»b]ˆs؉‰K­Ƚ[$> ô”™÷/çűTÜj¾”A´ß)§FÝ,Þêq¤'£›;âžÐ±²bç›®4½|39¡LˆíEå¹Ëb_éƒ^`µ„Á–N»Jœì"Úrqm,Q=­~>+ ìåP8¾b+œ§+ÉYªÀz:Šæ-|Ìê€ñ’è~˜™kÓš3À»”({œ—š›oçQß{]Žz[o*E=Òm™%a~wW¥ï€ÆxUº_‘’A “ê{»]Tfâ)>).]K c¥Ó+ò­½%`1Ì–1O½«`ØšsX%¿=R£‰J4Á8Œ¢Q»wæÄEQî¥5M½ànj®\ÝqW~“ <Á! ò«FÈ-±0?Ê.¤rÛ­<D 9,h¹íÌÑæD–¤ûß·¼²Çç.ÓÝ¥·†õDo~º'ÙÇ7„†–Nžä¢ºïyÊ´—¦þs SBc¯Ù *v·¥¦cN%¤òËbc“wÓBξ>N‹ÒÊ—9¡ЀHÿé7ùhyþLüš ³[/Ιl½ç¢QVº„42NƒUPt£†'Fy|dñj–9 ê+úÏ8Cí•0å¿w@ãTµ£KƒÙ›[ ûÉ…ç­¬e¢ÇÎo¾&sêÈô‡Ó¡”õ#ܬÝÞ!GŠ#µñ-ù[ Všûªp iV#sñ”½Âš« 9´V2Y#·¼†c›ëÏn5&€Û- #;xe(&=ã¿´:-òµíGׄžø—ùStž- U &ɺ &€¾ZM@‚"¾ŠóÊÿE]`¢$µŒxÆѳ§/V¾+bç„ŸÇ–´Sf0qTÂ<ì‡<­B_6�gÑ ”×v¯bh©%1¹ß¶;8YõÃÊJñ;IÎâõgªÐæw«Ê”³!–‰Gbwе;ãÖzïê[èv÷BQË {×|/æ)3†(ÛêBxäÙx}÷Ø}EììøàØk9ëºl:sø7&¶ºÙ Õ· «‚…´ØÓˆnHº &e—‘ÞÙ„v½íÿ<ô {— îÕ9ËÉl(sßÔ L‘ã$û¸¹ÕJ|û5EÓ ù´&æìF\/’€ë8ü¥g•¦Ù­Û]p­õQ}ÐL5WðH¼AØœ‚%˘MZ£mb—ûY2 Õá ½_ŠÕ È“ vŠ€™–þê<ÓÉZ“ë›J­h=ìôf�äa÷?´@¥¡”ÿ0òŸþzl¿÷•«ÕÌTȸp-Ý;²ÁÒ6frÒü‹|Mô,MºÂðáÜ*ñ°Û7ÀÎŽ»ù9œäNíM<ìuú€“X¹ Ò}Ãaä|{W÷ŠÕô$èÞÞÃ2\I%çÐ;¢´Sj {]©L_XÉ_Ä*–é<XÞÝ­»9²EÐMTDŒÚŠã.¢¿¡>³<¶RÆΣ•EÒ么üD7²ˆ¡84w“AÞ©„16UôfxjÚ�ÂTÁ;¦(°Ïë¿ÿ‰ÂU«|î.3”½lC›¹G5kDš›ô=¿;M@ç]Ÿ›j¾–AZ«b¸pÐÂhܽpUVÇé´ÛÉ8«?7˜=ÿ 1gþÐ#ä$) ±Õ/á¤0/øÇ…2ï+£<Ã….Ú-Ê[Ì¡=*£1X­8ÊAÝØwäàVòaì–õâìè<BíE¹óõ¿oqþöÏ[bt,ŠÊw½S.á«œBp5UžɤJÒì@E«ˆ’äÀ¸K®oþbOÖK³Áõ*xèFŠÍ0žã«¾mõäþLÈx‚“[oG*¹Å€X0à•¾Â 2aæ›#Ðê9~ÐÉÙ `@ïR Fëoä¼<û>ýhÓmšŒ’Å÷¹Çö(CD…�|[¥OêÊÓåÞï\çYPÍÚ Xë‚Øð%üŽ(<í(_ÙŸ©Õ?.o¸þ Gc´«¹Éô¯çÇìÓc᫤?:›d^ç‰'ŸË€z\;ä\UŽôNrJáz6obŒ„~úÙ  ¢¤ð!ÇÜÔIƒÊé…Fï4°›¢‰‡õИJxù?÷uœ]+JBŸ•¸]'¥¬vÛÕ†I$ Vu]TºY—S ÞÑÔPOTgî3à‘¼¿{À1¥ K±c:T˜? ›øÛ>»³ñòÂ'¡¡£ìE¥j’‚¡L;ãü?2ÉŽŠ<óR[J>Yè2iœK6=¯ë¶f:¿UýYî²È¬*e$ŽÈU8ÐÛˆ¬¤“§}{;μkºî|hx·SGÙâû—'ÇqFöHnúÙt⧶áÚgq«Lû-±§UÁ8ª‡–›…#Û#y¯8ùaÂ0H¸ömî÷rÌ.KBCY\äA<œu‹ T§@U£§¬_nÈ“{ÐgÕAû…q‚­ÌXQBƒÿ}M|ã_V s„ÏÔÞ[�ìï][p¾êÄsxzbÓy¹¯—$áÊ¥©„ài$›ÅÓfÅ×ò€h³-[û}Ÿ€ás ÅU$Ã\ÒÏOϸŠ¾?›”Ùíð3Æ%-cO ”ò ´Â„™ÅU²žòs0áî(vg »UV. o¬·Ùз²–‚iRk{A�|ÆÈ÷‰¡¯H)×}Ø£RmýrRbN“.2¸sbïò2³ß±QqZ9<qĆ£'*?õ°Ã°³©õìî2W3ýé$âëŸî¸‘g·ùÚü}A•38žn(²Ky¹^®t<Ð?ðÑÓWß:5^>›“Ùáxel:yb8ŠÍ(óÙq ‘9~�7>R:Ñz÷ m®«7Ü;F•‰ IÄ‹•'%ž-§ˆÒCÉ7›56pÕ ÈÇñ_ès¦±§†TcñOœc*);|ÐË4ߊU „ÉÜ»®©×(1fugkñ# !÷´Ó¹ÇÑÏtßËMçî:H6g®,y†FHüfQ…· aÆBªR4ã�0èoôHt�üý©þpéTäô"Å©7FÛ0¶öxbRvþLDTyéìÑ¥HOÇåªå º¿·Ü"ƒ´8t×T¸@ŸÞ¡M#™`X·b–¹º¥ Î"†”I2ø[î̺ÁþÃt£Ì¥9Ó*[øªw¾×é–ÒçZ=ËÖo®zØoð²*:€¡>y¿ñÓ¡”›[…6úçUÙ'YlJc5¼¦µY¹Ã» ™“A2&z)Hâ‘ú·Hï›I¯((uO jœý¼t—ú°hC'B› Úš ;¡Ð€Æf;<ÉЭIGÄ ] –G®T7ê títm™Ì'‚ç¡*æ¹Úo™ù°ln"ƒª³<ðß…½5‡{Ï\Z¡è.d¥§&4`+1Ê £àl& ½á2Žg‘‰{*/¹bÞòfŽa|×z.零ÆØÜÏ^~o¦P®¤Héo?(ħƒkŽ÷WF4b=ÃÑÜ`ìç‘™S³áVYj5B3r·ãÆÚ-¤ö>`)7d.Ž÷¬%3 ûê4O‚Š wc ØHëö<XWU¼íÑ—›Vj†¶L[6üªÎ¦y!LÉ9N‹ Áfÿrz’Ç7Ñ{ÓÐbŠm׃ë‹ét:Ym9^†Z¨HÍ—º†ò=#µ)ñn:m‘aª€Ùq”ùŽ@z_X7fÑ⥜Ïi*ô§K#ÕÂâ_SãõS̘ºf q¿÷z6×öD»Þ–v‚û<�–í .CaÙqž†6×–®”WÛÐbûx÷—5ª<'Dùù_ÝîI.ÏéÃ#j¾:ý¢ÂÍ­áàà;¦õÎËý›–ˆ>©ŽQôfA¿¶Î2ÏÂ=d°ù“"Û‹ÄT—§é/G±qhêy£.·9ª{ƒ‰ L ÒYôµ‘ÇP°Ô_húø“åFœùÃ’†ô.e§X*qÄLks𹬰VÆ€Hv918½¹•ÆÈÝ©2àë0ÒÚʬCHªärû^Œ·Sè¸UÙï¯Ã`Þ"Äß ÁeºÒ#Ai^Ð]Ò/Ág×p^VIÜŠÖ—–«õQpöâÛp+J]·“" 3„®_xžé^Ü}ÆjH<šS$>3T¤ŽZ@Uhªíý¿i@ÅÑŠZÅjCôÇ•Uà¿yè/îïvíU¬…Íësòg¹JwPÈɓ:ÆÞX& È…9aä”%ð"%Óz<î~©•À£nfúU­¥[†J“{¤J@0“E󪬀G?ûÎH¹±¬:âQ+ö+æù³Ü ÷pþFg+C¨2(?–ú†”¥¬"¬ˆÐHUXskÿo1VV¯/1 J&4Vób„kÖ'³ÑÿÄBbåê±XÏH?*V¯ j둾pÇ2Ô*Øß™}i ì ³þ ¥×xcå&@m#ëÅ—†Š|ÙôXàOC Šì³•ò)Ôµ=N«ï˜¡0óïOÌ*DAôþîùÊÓFþÄ;ÜÚæt¯Â¤eQÒ¾+â©)Ï,Ë|3uz؇}äsãu()øýM ñ‚W¤œéëäÁöTÉ°ó”Éh¯~¡k´ÐçÃm¶1a©«{ù¨öÈB-«®<¼áaz“µGƒ[Z¥'wöüåuF”•Q:™öYÔµq ˆr TDdÃÑ p®=3RŠþ“:)j /¨˜(Ì**&”@Ê8Çz‚¼&/©:–n¹mC¿ 3µ=šÁúo ýáü3eÕödÐU‹Ps]Z}^<’Âç™r¡Ù­™p}* g¬gâ úÏfo2 Z(0$¤µ`¶Wè!¢Þ.TŽî‚VÐ&üï¦ýº?rO ­bü52ÛØ‹F‘>žàË\¦®@кÊý6•ª<UªŠÉ!Cdu»– Cé¬ö¼YÿNÿ=åþ<[ ò¡Ð¾ñ(c}îU[À÷¤\9SF¾ÄlÉæœCÄV¥»(=êzŽU©-u´¾ÂÒ…ŒÏèÃûÈb[(¿QÙ_½[mÈÉ^èqR¾ÿ¯óÒ(.}Úò8†“ÑÝt€N_ø02ÝrÎÉñåÞîô Ï¢*qÚß Ë3Mt€ôƒƒïìésËÓ7®ûöú})ÎË&bP ëÖU½Ò9#Ñ ²Î¯¡'ÎGŒ×öþL{±úüױɧÓIûNê€s·Âž¥w:ЛËÉW¤›¤rCžg‰H¦¯BDÉ2‰ÅïSæÍy˜1?|ŠH=(c"2²¨È­’Ìk|MK1pƒW:&'T=!s—+<>ÉI=R3u÷g8WkÊB|„‡))dܼ8‰ª4öÝCY ­ ª¯«7.åDžóî-­Žöúv˜…}óÓb$®é—•îhÀö¢ŠV!Ðôñ¼ ´ýAY€»ø„Q91ß­ÁO‹§HOOª65.dŸ¤äüQæÁ7B(P`õs”V¿xþ¸öÐôC -6vãB]õÑ/fß+ ’EšÑЦ¢h‡Ò{Ë-2L^‡\S/Ëkˆ®è?I²2ù¢àxe´îи£Ñ”¢ŠÝLt›pR±Ã’÷Î…ÜuýR¦n£½7Va+1È©¦îÛ5ëa_!òŽ÷ܤ'KM·ÚŽç!RúÙn» âý_1¶îöÕXOû6•‡×c¾À2@ ª¿¸Ì|¤O…&“£ûrBû†.fçýâ>ëÎöF$la;Q›ŽŠiZxæ à÷ÄóÄLPÄSã¦ó!œÆžR% ´IÇv_hî·…®¶j¨”;›Ž¥ðצÖH*¸²Ef)†²Å6›ÚFþ°]Èæ]Jã~¡™øŽy ÷kêœÁ³Îرw¾U’ ¯ýQJeiæ‰wJ@oYqÊb¼q)ùcœ»±rèk´¢ `Æ]Ó–nãJ&0I]ïS‹¦"(+¯!.ÇzºÎDOÅåé2›lÜÜ듸Öø¬ëÔ—kFÞòUØ29m6Ëø·³ãôšë?ýé&ÁÈ,Sª0P£b|f Eˆ`nu�V+1©½3SÊòÊ kæbICÁrþ2)�‹ZÕ7í âïØ'·´ÍšÁ¤®e7›NwrG6ˆëÉÑN)7oé9¨•…Ç6¸íÑÇÖ•|p¦¤GäOÌ!Þ{ÑûÊ+åI'%ZÓzÞ]“ è}ÓÝñ$òúÖYüGñž8/=yCÚ•}ƒ¨Õ¢}¤ÏwÀ$Ý‹0iÊ­îûóàâ牑cÅý�šÜE‹ÃšÓ<B^ß$æG^ÝÖYó.FÉ ÆSn íȘäñ&$ŒøóC¦¨P´Ñ·xàÈÆ8ó†ƶZ&jU7ÇåËÕº¿ÑÚõ„p©ºüƒi”*^ÚFEâË#ÒÃN~«ò,òþD©Ü»ù×ìJ×E }t2gíÎ/NºÖ’€ƒþ²Ö—±HÿhT$Anl@ÅÚàh¶BõαrÑßš÷‹t4ñE 4d¬!µb�†V…qþéÞÕ÷‘‚“äàÌÄP~L9Fq¨·ë£[n¢[)(¶G×”+Vá­¡ù‘öçÙS^R©2%Àˆ=â#—Ä8Ô¶ÔÇWÑî;«':5 }„ñðÑÚfÙ‘ÕcG«$Yñj€»¦ÿ?¬•†–g‚Þ’JÐ ñ~þ‘ Ʀ ÚŸ1ê?}ÄÂòöN§îØ©:1+ëÏÝ ÚÂsÇrÇ~•–†å,kw¡ÆÔýsò¹?,k˜Æ(RÚÆßqÛpH s¾ì/î-%dâ+®îÀú|µïékè21l<Q=_caB\ORZ+u·›¨êcH˜ù¼JJ÷—„'0bö¸Ô^\0Ñ“fb6—ÐÄ0‡Ò0ýزYÍÉӛءïsU¬ëˆØ`#PH¡g;J=t2§{¿{¡å”?2£ŒßÆA1j“qKŸÒï©Q BIÃù¸9Ü8TþÈ)v“‰ÃJ©é‹ú3£¨Å°Fª?`kÅ„>Ü+?«~¤±U^…ÀÖ#ÊvÎX4· \«Ý‚×/^3#ÍýEØÂDY屮°„›%è#c†m¼­ìþýËÛ‰cäW…‘4¢jõ]Ù_ƾ* Mjmp ô`¤8Õ̤}UPŽ´˜RÙòî<š Š¬¼ñÞ †ªëÇ‘?Þk„WFç(3"›´SÀ¨ùò˜?ÛÓfãr²]Û¾f¬gû#¯üº8‚;OA¸2wSesVŽõ()�ˆ`,XþKVÎø@ ¦mÇN®PìèÏ@h}UQ›‚»ãÐdBÔ+‚hT*#g™jaÀbu÷a™ÿŠè˜z A³žgØ! v@ømè"}î Lƒ¹¿…×:©aÌTW²ÈÎ,1Úûéñ}E¹X7·âþåÆ…¯aJP΂d±^!¡—aþ·Dd“ßÞ8©Ý[t¶Io Ï9å¹ä�–MÓÏÃÌÞ•¬3U•Ï¾úRœÄMï¸í8ì鳧ïKÉͯ#:Ö~ãNŠ¡i§ŠÄ72/aêw1 xÍÚ8Ýì¹bñéy_ öuœ(-\ßž]czËzö4ça›ÀI¥¹OûóA|Ÿ¶ðÒÜÒBs;'YÊ(’³¨Õ4rý•áð€Ó³€Ãó"#ºp¼§œ!LJÎ(^ÈlætAÄõa¸Jx—¦­ì³½¾¡èµ­×T¦ûãϘ¹¿÷&þ/Ve ¥ÇAòµ±Fy"9² ø”ÒÒ½NíÜî¬ë7l«ÂŠ° ·éôoÜZ´O§QÊI(=ojéõ`›³æÚH3ÏL ŠÃ1ÏV}!Ñ–91_ D¡ÆKïÈUeOT}S­ÜÀ´˜Pν;ù€ ®W Ÿ>6W`ÅîPžÑ<æ¸O?èÞtš›—8º¿ðÍ⧓OÜ¡夙{’üW.<ò5gb/D í(¼]Å˜PãÌÕê™FIšy®át cä…Ó!58 8xÿx–+/z>»ºì+Ò;5ûL4ë† ŠÆY£ÑÙ:°ž¶µ~mq{r¦Ì³é€'+7>Ø0•À‚^vSô¤ S ÃŽ€’õŠ1*ûün €½œèãA®uî~õ³ÕRÓ[é¸÷šaT~ ¤Ò[Ä鈔(ÞåEµkªø ;q«ÍŒÃѦ©¯‹í3ÝÔaS! °Õ(óýG570uìýr6¢lWW^d´û!ŒŽÆ…¥l�Mn¡ü¬‰]_Q„ =Zg[D-½'_ þ»\@3)‘Å}¼Ô,·{ûê™V¡ú.0Y}*‘½×±1U¿jýDÎÝ  í˜> Ò¥3kíqhÇ\ùì46¤/kDZ¥mcè“`@Hx<{ô<è&*òåÆOæyE¬"c MGòÕÐÑT*f›m0®™yÒ7Jo~Ú`Ú,.&ß„ ®gŸªã”#Ëý¢£âCºÁú- 4¨Ÿ[†ÐÏIXYH©ÌÄ71«â1ÒâÕø†Píd_{ÖÖ\/Wô; f›çò¹m›zš)Nb!ÁÆIÏrf/ŽõvKɬ“ù³T¹[ôvIƒÌº õ퉾G;š 1FnY‹û ïaæTó1¥)ƒêÝŽ”àx@åq±êüë¾NW3 ðÆ![¡µàO3³Û;ÅjÜ!S-Ì–H- ¬šV¡íªÏÑ®U5ÕŒ{%zÕÓ—Ç�÷«iUÜþg}ê¸ôÛ´ìû$ÒÙ·ÝðTöã±ÂÇpº°ˆðê€ÎK_éP§6£Ó¢¹¸aŒDG#Žz6™-¥5”ˆlæ£àéUUd™õ¢Çxy|<Iízc\{Ll ƒ¤­+1œÿö›ruŒ ¾ƒNvÆÙ¼õNçV„0cþg‡HG‰â ‰,„þÿܪ­#`L'úz n|5*hÔ"‹ÏD”~ë›;ì¶; SoZ#ið2ÓsµV±‡hÃ[¨îË*·v*2´q÷?;¡dhBÉŽX¥\[ýä(dU?+µþƒZÓçÆ;lê•<Ëÿ,Ù”„7gCGç}ÙªŽ`¬Nö–îIgÝ}í¤R»;âJ#Ë-B¾“Âò³qç´§�~'c6ok{t>,–C˜ “™2–O-iãtÃr`ø\^6ñ£¹C™ø¾otïGÊü* &Dæ'½Y…Îp;A»xvýøK&zG‘1×@{‡<à y Е)«ÐŽ?œ­ù ó*½”ñÉœŸ7¢bk²i̬PŒv’ßaž]Øœ=Zlÿ}+ÒBážE�êvÚê»ä›Ÿ†Œaœ­”f1¾Dº›ZìRŽÉ«¸ s+¬©7ƒ‚Èj¦è¹ „¾{a ´ ÀÓ²ÓiòšFIPÿƒù£P@QyënyçwÌ¡íG«*õ wwVÈlÊâÞ pe¶Ñ/ì|"oú¯IϦË<ÍAô‚ÇÃÐúÌÔíiêÎÌ8šVN”]Å}^Þ%tyæëã•ŒåAµóL L'Â,ÆÝt`”åV¼î¬£¤õtðµ>œ±/”÷ f‹šçc(*f¾]…þ|›ŽjV†òZ/2³ÒVA¦ÝHoÓ×ÿTlh†zŒîFVFA_äÝúúCxjžŒ^ìÜØБƒ¦Gjõ¯gôŽ¦è-[»ŽŸ/½¬¡¤¹ËYy[îzÖ5\ôŒgVªþï[id7#ùÄ’wjÕôÒD8-c÷h¸”ãZ‹¢œŽÿ¶½¿¬ã7~*ú÷4.õh3,E4Ï)롺€? §¾‡íy¿°çaœÆ™S° Ñž¦e?¨‚.læº?i–o€v¤o_]G:Î<R0oØa¢'š}ªO\Ûö½uùÜÖF¿³ ž£¾]ëInèÍ>N-¹ Ýî 2ÛQZ[TO_߸I�áa¨ÏO8N®4Œòe¢T0žtÖÈZãk€Ü8ì€ìCÞŽò~v ¦F¡g¾¯ýâ‰+H×r{ʃhÓy£›T(~´=âôxê­šª»´>ïž J¬$.h×·ºê«¢6ÓøÎxnP^÷Ý4£È³%ã´ãRÓò³˜:,®÷£àÊ0ÊtÒ”hßÓ߈z]ä›éJo}iéœYsâî4C¦ŒBO7÷§}p™Ú/No^½  Ô4 Æ šú%`²‰^÷F¯¢wBÿWL\¿g±—±ß¡»-þý¢¢‰-‡Y':ùµaDR„>nÂÎ{Ø´ô¦‰„`Iwæ4[ðÔµ÷¸7áR-sÈç3÷Ôæl±©E73Ž®OÅÚÁš‚¢ÕtX±š©‡ýi1%ÿß9*%-”Ì& ŽèqìUì¯Útøï[jRªÈ|O„>Š ‡ rõsÔ(˜÷´ñÏV—5¾ZØš™NÀÂ~2¾ÐÐr«G¿~å¦'Š¢T5¨9 Š/q8þQx‹&xþ–Å¥¥¯ü£ëFϵ\4éA'É wë^ÏÒ%sØ>·¯+$‚OÑJ­Dl8{  ;û3¬T¶¼f '¸ Wx.k·WbTOçºnýÕsÚ¬5ƒz§ŒªÈ½Q)ƯEPY DjLäµäøJ †ioÒiNû%«¿(/+ïŒ�L‰ƒr7šz µ8`ýù¨@껡ýN”ü¹?{AFŠ]“'â4Rè©Òý|xGq‘ùP¶„âo–ÙÒ›”€ŠÄ™v Å€Òî]}èM“z¼ô}Ggì=¹)á9¨×¥Ë.ò÷«'î°ÎÍ^]ØصÈû Uò2Gý§0þÁ_Ë5ñ äŒê50vÞœ}wúÚ÷ÎÏòIP„¾[ ܺ$H7gx»­Y„Kãô!Œ¢)e<ë4ÿº—Ù ¿ °ïêÃÜvPølzOðÂíP¶8“ n3ÿ,}% s—É`ÝŒŒû£ÿâ[Np“—9#FEµ6’¼{:ûÙjfRqé&_ÖÛn«lK¹x]~²*b«†I ØÂÁfËœÛJƒÈþÁÉÈ#è릦½¶ôõåÎL5©<mf4ó_{ÍséÈ•ŽœyN²¬¹ºm&¶=}éïøJ³ÒC²¿w5´ý졘cq=ÉVªÌñ²XŽiù¤˜ÔhÖ .$¶ V‹JÖiâ’—^7î-ÂćäÃ\p¡]NWGa0ô0/pÓûmwXþÁ‡Â}Ï2úçüÐ�,öƬ)iË@…ÑùÆ H@L› œÆ2÷õÞ•†ÒijA0e9ÃâªYGnXjBNß³—…3ÔnÊQÃ'ÿIÝ|$»b”ÿ‹Nãw r†âØÛ=ú·å˜‘…˃ùš¹5 Dwé³£MCáè"ˆ¦»—¼Õüä* çÑ�Ýœ't´ê,¯ =¬¶mÑþ7Â0N'3ÙÙmö•àTgÞ‘EÒ-SaÆ µŽV®ü€Û×ïµµåƒ&Ƨ¦oi_ïŽ\Π¦4gôÁ¤ºÉÔ&�OsŸÆÝ“ Œíl²ÆËH¨QÔp±G'+ßz}ý ¦g­âÐxª2@7>_Ô)¬xœÊ>ßðW€\“D*ù’NØÃH5”spbÅgîõj’¯ÜXPÜÔ ÌŠtŽ¬Ûù:†¡…0u½±*˜UXXè9?¥N—\'Ì8k¨¾Z-"•áÆ ›: dòÀ¢2ó¥nø4^´‚ñ¦VkX[ìD)ÑE sýBÂÉÿ`Ô¬Îä^'x[Ñz<‹ŒBÃ3l¿ª ï?ÕBàÒÞl-uRfÿƒifù‚SÒu’ãi­€Xf¾@-rï<È6šÓ—°Ö: ³YöV¿¯žFöÉ3:ØjÓûƒaoúc ÖÏ9«~PŒŽ€Áˆý–Y›&I¬÷°éèkí:3Ï…Óî¡om[vsº°GžIݶ0O¼¾ÝýÉIùEj Á̯æÝóº‘;ü‘÷éÀGJ äð8+[& Õ^¥ é^Ÿ'Üki²‹ÓÄ•vÓVøný âQdvÈ0%¾ºW„®8 ­gA?ªá0e3;ç;G7ˆŸ3½FÉ1lov‚·Œ•Ú¡Q¿sV`«yBˆ~I0‰Fã1ÉŠüÆ�{´[-æ˜-ÄßZïòrFc^LG�ºÕ/™mŒëá†7÷¬ðÆ+ì(ª–Öá&G[Àž»Šê> %`Ãð´×XÞöéle1‹•ÌŒ‰¬Â×±VÙ*W{f¢ýÓz„'C8q@®õ²Ê©¡Ëi9ÓºHfm‘bRNÁsªíxù¹ãmV¸[ÌÌ’S_á§K¤êÜKón”z@ûñŠ&ÈËý¶ŽR.bé¦Á Ý‹ö]g𸅩%v£±¿z‘‘f7tµËºP/‰­ÈƒèßH–ãô™ ¨„0„Íë;Ž¡nn!>¨íö’uMmŸu€VéÇìïu•a>7–|·CW3=9”ÒeïlªŒ„[;ìÅëvå¡ûè8*Öo›Ç–ÛÍëZ‰8Gíc¼a ¦çæ§ äÏ ¢§T”l,IJ"˜1æzïiŸeŠD‘“² eê,¤qW“Â&ĸ³%º|GÌnckÆZRöV‰á$ ¹+Uäˆ1à3S™œ½Ws˜å\<…¨ÍtfÅ}o›¥†û—ß²±ŒÌg¾Dû ·ô'ª}£® ÿ…þ°4FS9Å¥N7ÕÜMŠñÒ,ØŒ•"Jf* ã~rúÇú } ý’,ÈÚÚ¶Rx3uÏáš”žHw.蜘•c¤ÄÓ AéÉà‹vÞÿR‡%±I EF‰6Å>rT®#´ì:ÑÞN0Fù\ßÖœ/?§¬ÛA­¤ý˜( TÜ9Á `Ó;@*¬ÄÅó+ŽÏ±/êÎòXíPy[»FÒæ<w\]Iï†R–_ 3—îsßô lNü®ë@ •‘BQo5½Ü5jú»‹‰;þ§Æb"xô5¶ìR;9 TÄ[g=ÆÖŸðßá áÛ}û7‚.<z[Šå·?gTù·:²(k{úbÍQ3³4úج£Š†8ǪÿÖãš4ËVÏ%7-@@:¯éZ ±ª Oh(]Iï×Ò8:ÖýXÏÙK£µ}Eţȯ•šæ¬³ÿ~‚áÜlJc>9¢¥™ýû®Î…l3ƒ®¥vêËBõ-¤A;¹Ë¤·(, =C»'GÊö¢O¥Úc9²âUVjGQ{+†€^~ðž*S°2ãåéHgd6Yöˆ±'³W)òàи ?†d¦¡?ÎHàHŸ~Ô#ÍÉ©Ý(ãÑåüÍðîÙž4·á ¤”wÓ¾ÉF‹›Ó”ê#ˆ…Uˆ¥nîôLiBû�"[Í(6[Fkw6·ž k¬ðQïP'ô)ÐDáÕtb/ƒ¿o6Y•=¶LÂwMƒÄYåÀS�ôyþ²¢?)k¤·*é”ÇfÖŽYÄ­Ûm§ÀLéÉý’{RN6é-%TSÑvØÞù¶·ñÌÓ6;¢?C~]IŶû}C*Ž³p-3¾pÑÜvžS. –’E’ ÑŽ^¿¼&/m›eÖCƼ•%œffH‰:}?ÿ–ÈQz:~<Þ f^= í¶9XÉ Ó£ä‰oÑú'¤q|RßfÂyé; Ò#™¡ùkO{H“ýC¨£ß–º‡ç‰=`ªÿöü7~?4D 1»k>5…*ks+MÅàU‡»G,Ž_´½£wmO§e¶ùñ/$ñ3•U´¤æ¦ŽØ=Ï=`¯¤ƒh/Tž1õ¤àXàȲٶ[˜1Æ5GCå¾É¾)¹vb�Ôó…u¯HíÇ.3Z¦´X|W“¨o¿¸% ßþì+(æ¦î½Ìt£?Gí7€v¥œ�xD(_;ø M®Ò{Pñ%¥W—ˆhÅeñ¤ø設11“Œ€·4Óô^@Ö^ë™Ókh„“’abF¤ý±®Ð¿Ö°j¡‘Å÷}F9Ú§ò#bþøÛsoýó8b�¨¬|Jô‚£!v‚Òß2ÎÂY¡Äí�¥_¥Ù |–‹¾ÿ¾ej…ÂM´¹o†9ß^¿×¶‰‹­`(³³sTÛN3¸‹Ÿ¼*ßûO¤â1óUóô¯ïè„VÑP÷–�Š¾‡–i럞÷õ<mÄóئ-’ _Z7ß•AŸ¢-ÇzhÒ׶%Ô½ŸÐïL|ôSN \d–p±ÓiÑAëï­à¬Û<l}–t2Ë-T!áÉ(£Ý5„ïÙ]þÝPHìv`øßxÅ·øž§S®,ðñ’´ôÎõn§¡¦Ãø»×VäüG…ÔÒyVAuõª¤XôF„fný|êü¿_|ë…ž-ë:Ž½¥eÆ<åÆ£Ôu/œàXŒË¡N‰õu5'Î’Ì“vÆè¹³ ]fO‰AtŸ¤³Ëó¼pmì]ó[OÇv…}ÔQ^Ä1œRà¡EÙ=¾Û ‰mž½A¶fZQ Þè#²v¯üô[šDjØfý qŒ/riyÞhq^«òQÃ2‰]òÜ&ªaÛÎfÔ`¶f™øïõ•i~d©ø,3<u˜R5§½&Š(š(NlÖþíumVx|d‘u½RãrZ)ÃÒòZ¹5”‹05˜Šd 8›ëo°tqêþš8ß\« œõ¯‡ÇC/íI]Û—˜ý•SÏ)EÕísô$©ûñ½Š’þ‰Ê*-¬‚4.Æ"¨Æ/¯je³/æü¢}°Ýé@í‡=Ð@·é4ðxDVËú'OÆ<bŠ" 1¸m v2èvŸ.®ûøL=2W®‹ôSx*YíÌAX .»R«¹˜ÉÝšÿdÓ¦Ÿ¬¼ 1Ú }ëÒÏz¦}àMìžÆL&â­î%@Qà.žÂìæÊäúŽ³aºôg*%¸ÝŒ-½a÷å+}nÃ2äd•Ã½-fWHÆ ¸¼@…áìsÒ'ó§ýZJêâøµß$©/@íuAÖ+ dw¦4_(jÔ½oOÓþêÑ&¹¬Èĸ¸û¯‹µaY7Áv9‰»¿zæQêA Ø̰賓©àt(ËŽBö ¬· âfp0’PöÛahèp˜À€¢7Bù\;ÂÔ^dà*£×Ô@.i›€ÚoTúÕ`Œ éÇÒù¾å,'«tøÙ´³3Ô�}´¶™ YÖŸìœ6ww{ ùÝS‘Në0%pB@×¾£šé´¨ø0-ìþæeÕX°hÃTˆÙߤºŽ´²6Rc‘&îã²D'DÊ¢Æ3 !Fn‚·þQ¢,NŠÐ÷e¡k”ÓÕâºù>[²’Ρ<D DÜÄ9Sÿ¨|Õí+}þ4ôY˜Š³ò])¶ $=˜Á3²ì«‡E»¶°aÕ<CG¾ˆ`\t·-€âÓ…jÙ/7Ö„ð­Ò¢‘™ÆDÐb:ï8!]3òÉ*Zå"´†A÷åÇAd/ ®4ˆÃH‹Í qÜm® ÀØ2-‹…î˜(z°*ï\O°“šÏ«Ý`^M’tS“kaž­9ihEщ-)m¹žÎ}ß p¢³ <U{aöQ²ö'ß4ųmZœƒС—Ù%š²FþŒsF(8‰ÐW­õRã.€q! í/×·íaÚöì”K™.Ÿ<SwEÊ;\®æßpMeㆂÕi•<_i‘±–DÀÂÝFÖÜ8gõt— ¦å†mlïŒÔøôQmTé¦ñú›©f�:¾"âÄ'É´í@[ì£ÄßJ~k:9ëû|¤Ô7k¯l±9‚ùÏÈF:ÁΪ»é8ž&PRì…èŸÚ¢‰s±~ι“ Fï,·@èWaÀáÙÈ^HøQº+²}³82d@a6{{«¿k ËIztï~ÀÏê»Gµè™ˆzÀ]ªô#õ ÍÍ q{¡û¾ß{ˆ¥¾ö'­7‚¢0'ŽÏm ¢4v“W¾@¡d;íOcsOßÁ‚ž$åê>„,óS5Ö¤%ô¼œ)iÛÎÓЫú!Þ¸‡ÈÔb%>ÂH °”L`ÚNl}qóÊ+¼¡”x¸Û¤ÉŠ")}mʹ¥S5oÏzÓ-Sty==›ƒhîörêk¹%ì@8SêÔM^¤lνø[2ÝÿAÓ‡U¬7?AýÒz’R&røcÕΠÎc[cD‚þ¦XÈ})Ø·º6ÂÍj£ªÂ]ÍÕ$4”i˜Ä×þþúÒ¼Ã÷vš‘NR*:¬?톶Þ÷Z ò1ÿ>ñ…ÉŒîH”™¹�›¬/JÆ€†îÇaä!âö~ÿd>úòÌø´$Oœ�8ð63 Ö¬ |L3Œ÷.)¡ìåØ⾊3ïv0‹= ŠVµYͨš§”Vd8Ö_ó£ÞC©�A$©ý¡²?\^dyxI÷~ì©n¶@ƒÂxOJ„þ4JéiÁ†¢ÚsÝÙ¶ŠcB¹G Ë‚ëÝM\¡ûi»ö![q¦Aj ËÒOì…y‚šÑÿ÷aý˜ä̦%‘qƒøƒŽŽøÝú–0J¼Wt¬Äæå*œs^Ý+¥¤G²IE‘yòîh#Ìtþ×Eë¤^†ê'JééÐÑÃkÝœ§›žP\…¾Ò*zç$HÞ­›$æ`&Ù9Àóþ;s§Ðû×v˜µÄPX H²Þ€fpé|l7RˆÝu±žÞ„x81.k³ÊµµRá¶~ÄPÚOAQ7ž=åï3[e/û³Å»‹õFJl¿?7¾û3ºò›Á´P9|´íˆ=È ‹u(aóf¤Ú´Íø4Q­ ÏnÉ"BÓØøX(V͵'´‰F©9BÖmo“ßýå}„¸Y•ì̽ÝñHØóâ-Ϙ¼¥æþO¦`¸ß‹òùÏ>zEäúÄë‘ ìL‹ÐÊëÿV;Ê=ž?ÇÐc’°@„Q¡‹ÈÙ¾ñ’B¥Ãÿ<7]Ïr ñˆX6ýHÁ9Z´ë*8 tæ“_°q©6¨/í¯Ú¡IáTÏDNeîCJ‰&% 7=÷uc¾@€sEUᨠžïLg­*ºb¤†É{ÖÍÀ}Œóô¯@/M¼|‰É›Dn¥‚œ¾ª ±v€ž'( ÝÖ„“£æ÷ž˜êZX5ÍnЧž²zc·Â&¢M‚ºÄ…k”ï3°¯í\pnže«•y¤Ú’›w@·a wû»·XZžã(ôWÀq¬¾:GvÙYÜRNO“äP÷íb¼”¦B\ƒÁPØ)ˆÖVÇ2 ­nPøžðüÃf1kdšF[$?R(ˆLžé„Ì~„Þ S ž¢Ñ*¼yu~ ¾ zÑ[íHG eW3©€ [±§Ó‹Õ1Uæa¸Vã¼À}d°ãþÀËn³Ê—îB°ª"Š®d½PWþ ™Â;ø¨Š»âò‡S ¬ csSÃ8S)wçË%xýTÐÈg«ÛºašÌ=¶²Ì<S릜ôàÞ÷ÖV\W8"º×qÿ~ð½fÐ%·!BéM[dA1ì=Ñ4¦ Îк`ä!/5þ(ïuÎW¼$ÆñfïiËá=ëÅkQ ”SÂ^Üψ-FDÔˆYì ìøÁÜ–$ïáþaûCrè]éQ—f<T þsý‚% ·ö{d Úé-.LÅiû¹ãÒa<]®³ù×WøPKÝí‘nO¹Ó:Š…Ûoõs®<—–n ÖÓ¼–ùI3Gêg/Êth§‹f<ÑAo”¢Ó@ÔRÃÃÂd1wúöiéj´ç=(Ü'`:Òª¼äwŒÐ7°P¡‹œÉ žZÛÖ~<I£Îoë{¦1²þÇÂ`AOHElûŒTƒ'¤’­ª”²v�~«[ߪÆêÿ¾™U¡c!<ƒßHA‰Z›¯_6O”bÛŽ(ŒêX À¯í9<*TÅ ø§}ïXâ×·Ý:8„v§¶çé%ºtì‰RskѶëŸQ}„ž¯ž( �kñåié%4s>áHeå™ApkYþèæ¿xEŽS?MaèÇB”þ™}=ÔÇìÆ(gIî7ÿ~{†»MÌ «0cšMVëë‚Ó Õ‘ƒÅãº9]Ä6XUƒÍÿÉÏóëˆÒÀ8ó<. .laS ñ€~n Ä-åW®YFÉ··€<aB%éÆÁå¹y'ë÷£r –ç~"ww¦€ŽŠª(Aç‚oãdÔé!Ó]ú+ô^&ô},5„Ç-åÎjÆZ†Jo…+eƒS½ö¹{È[JÙ‘á|ŒM¬þ˜­Ø ç`{Åôé/ÀŸ±g‘Ž&+¥°HŒ>­Ìuh5¢íjm<®ù~q¿Äð°@ÒPd¾_{õH&V}þgŠ_vÂ+’*—íòÊ©¥†ìèEY tΆ¥JY‹Ým÷²²ü’¡Ï{úqÑ ‹ž,–qëàbv^â8œ[Ÿˆ·Aú¶µmU´ʈêv¨íâÜA)•[RwDÚŠxUÜÆÁe†¯åÆ3¡O¼˜‰‰Ìno±ž0Ÿq¼Ò¦Ïv=Q‡½×Ö‰èNܺUšfæ´,-¾œ;|x‰Äèp´Åבå‘b-­GëeGŸl§Ü•ˆ-–iѲj’ÆǤfîêvéÊø=†Oö{O”š²á¾­ÿm= è—÷X»ˆRiæ?ÒkkË8ž1` m·OŸû:$‰VÇŒèwL¸L½Ê†B`O Y´ ¹]}˜m6rž´4i]=QéR3 ×– µÙm”¾u€]ÓJcY™µ°2…ñ c}Ì—YÊľm—ËŸŒŽ#Æ&Ã4Óý ûcÚÐ+—Y3*_Í#o§“«ÑpÎg•·õÅó§ìΖî} µ–š·~Ÿ»9Ñ�Áð\Oe^µm\œYšÞSÛo®«¿ß–•F=›òvçŠf1—킾>g#†âü?€Y#—D<1K)ÈÀ>Ñv–bŠ²:ç6ƒÉó·õ0 X4¯ð¥›¿ßë| ¬N$¢{OUBq#5(]…éxô³Grà±³x¢‹‡KP]†ë³mPäçå°EÁ ÍÓî:½-WÚ%?ýèË”%FÀh2pŒ°¹íÛ<¹_çg¸—{˜Dm*#áz©)ìw_>ßqj)‡n¾Â¶ÀTâgò"-9$À†RÁ³Gš¦$|FCÿئ"*OÆiÈÇéF®ë¥èšù˜³mªï¤=4À°é,ÛSö{äBZÄ®>ODš €_„mjß6èUtÔ+ˆ©< }+uÚ Ũ!„Ù«³7ãV†°KÿW bž¬ÑQ2?‡5$¡.©Ð@Ø/”GwŸŽ¿0Ÿ÷º¯wNþ§çƹyåfâü}2š‚Ódè¥lÛUmÏÓ,B÷î›u}÷í*Õ#­zm¹—¬Ê1½½!3(oNýØ=€>H£²ðÕ–@=² ±ƒlÿûÎëΨÅϦ®Ç‘›A~ÝÃSp𠼨 Pu]€¯VDTó«Îô†nÁhíÖ‘ãÖ?0/«UµŒ­ˆ‰t^ÜÑæŽðo|“’4OVÐ ŠöÓ¤I ß]´ä.P7ì¯ jXõð¡'{Ñ.çû¾>ž¦}-vÀ‰Ç½ÆTz¦?Î*ðàaF:¸­HÿÛ0YšyÈWºáý9 ÊÍÕîï*p&z ßýùmåDT­èVÄ­*‘c�S÷{+’¥’00ÌÉ`ÀBù¢°ô¥Ž(¶ñæ,õ;fª7}Y¤ì:‰ð¶Ê±eé&óâ3cÅp0€IÖ’wi-I‰…Ü>qX‰Cßý ê"HÚ½)P¹y ¡êV.?´`;h‡á‡®uTyZ¼¶TååÝÅ뙾×ÓŸƒéß QBYÿôØ=]57„aÅ©åkÕâ{2ni±ž!É"·IzÀÿÌç±þ9ÖM÷Xñ!ÊÓÐ[ˆz ¼Æ¾<ζ?ü[oÚ¥s:Iáüf>!xÅ ŽÓòfˆ{úJƒxwQv¨ÅÒ;×à–p9,ªõ‹-% oÁ0¸¢©+¾&ÙÀÉðq¬ÑvlX!ä'2¤5ù¡‡Hiwþþ¯-­KßTá S?óc£"k�_Þ^Ü–•©³s®_ -iL}éY+*ÿ3tQ¼íM}µ‘'óÔîj—+65Ê ï�OÐdÓ)àç¼Ù€µã ¥Óÿ‘Ä8ãÂÖ]Ý GTü&¿×Î²È igÒ/€æ#¯QôUPÿ©§»à¡gèüHu—Ä!$®„0ïÏžØ<NÚ½‡”ÿ ¦4…P«“$ÖÆÀ³äŸÊq*8xqÖÎÚbã«‚}7súAñµH}•üA*Ù£F÷-H¶Ä€ê›~³õ{È„LãYÜ®¡@lɯ…5Ó÷àÊ]%t´Ýå A—§“èÎA[ùÞÈäËgdûëÃÑ¢Îê/L™Ü‚SWÂæáV¬®ˆ}Þ=Ôæš²Á£•M¢ç*¶îÆ«øÀ€yyHÒÌIu±s_×@ñJ©YlôØ$Uk4ÿë¿x/¢<ö…p”Ì•'°ŸB³·kÉ)ð¼ÍÉ“s”F`ãÜÄ×éMv‚ô›E#CýC$W¦ÕƉѣ_¯p…˙х:7^²HŸØ¹²äÝwAéžZxXyä,\éÁ‹ç]Øu¶W±tΕ“¶ßZH‰Ì!Ð8”AÒí<ï JôüµÓxTÄ¡WTÐÖ iPLš„V [5Øü*ðFÁ¯¦X2yPuwõS¬’/‰ÂôÆ_ƒ7Ç|«¿ª´Ë/°UZ™•Ö“ ÝFWc£ÈŠÌ ÈRùb%!{Ë~‚rFÿñåõ*žuBÛ¾À‘Š¿ÑÿšŽ&ӟȼŽ¡4ø^2±†A9jfú¾÷ª­FtÃ,ÿÓßyˆÅJýA„s^ús»Þ)au´Î¯óŠÕÚú 0MëØa* ©v)nQ¶`ljĈF „òžp­°²¡þ–³Ö¹X¡ó·ŸM’ūɾt`ÓeçX¦#G vEŸÎ �ñV YzЧó=š¾%•ˆ¾&•à¦gýžMYq…µº,@ž’ù Ó@ßúá_È|½Û»kÓÓ±ñùnj®J8X=«Rª$FíwÅ~Ôí"TçÅyOÑ%jÏ®‹h¸6ÒçÆYq5ÿ¢‹û̺3Š“T5`ÌøJuÞ+¬0b*/XQ†Wô±¯G:á·3ݨôp~C¯q]â 妻ªöËtú¢Y|žÀŒo´ÅÙ“XÙ©÷ìßéaýnã=:ñ0ëÅ`œ¬Ó–”V^ä¶Æí„ê$ÿÎw1IV ipeú õbV´„Í®ƒ õ2}N (<JKÍ'd]®QæÙ*g¹\¥Oè  P ‘Çê‘}:@ó¼SI\ÌŒ7ý¹}Û¸Ô]óÏsËËTí}]Üù„Nñ*�·˜5N’ ._œ·zƒ1ç‚e¥óo“ŽÙq'ˆ–c‹õÙz‚íã‰Xw‡­b7ÇC?£=o^y1¢‰‘Õ =+ój†qmÿ$àÜ(šç uÓxÊfµrCæ±Vpñ-ÈØ:*‡¥i~rû1Ü›Ý ¼o(‰“¹ªÎDª="•ñzîJiTqœ£5ÎóUhƒMeýeN‘ØØÚ98zkúCÒ›úI"ÝfËD‚³/ƒ|¿ñ´Ò¹),GƒZIyïR·Òó_yäØ8p_v`RoþõZ5”§¹…¦…‡Ðòò$)‹ÌãS\ÞÐ6ž§˜LÛ­þ.4>¾ÿk? TOƒùHo5l¼ŠU–4ïf:äë—{ lߪïÜL¢ë-JÙi\ {¨4+Ô ÎWåŸì<ñï/}/ZB`ëÉœ©j31à‰ºO­_<ïÆŒôTá”WÌMÖ4ç€+È++¡a±®Å©ó4Ð�«(†×«äXßÐŒF%¤hÅk £ý€Ú6þÔvCý¬?J)€J£Ì]_«m£|%b@1üØA´[L’‹Ý·9Õ‹<µ„λÓô‚ŸÛ¶‡Q™fœ² ¬Ƕ²\­OÒyªÌÂÜoKL£Í½ÝåtÔ µòƒë¼ähÉÃâÕôé»5äoLhaït×v¾ÿ[¯9ýŠˆi“T8¥N뇧­Øབ§¿.›´É)Ø“°BPâáÓ C%jÁÜ5h~nŒEY.ÅŒ giŸ¾p–î6Ú¦‡€HÝh±!;]îc;ÐóTÓé@ï —<o,ÛvÓ6´Øke6ìÁSœ]#CÇ.N>͈×Ñ73ª²6¸BŃy~í=‡•Ì‹*#î4LÀ1Y]ç òTAiòA±·‘ÿ+EEg®ïž³Ù^1WFGȨl婧òXa/VƒÓ¯|èg+÷á3úV÷:¢4ø€Sfôš>|6ãNĽ«Û>Y~Ódm¡ß3k¨þಳt#¨lÌ{q¨Ñ±pÃñ|£ý •£Da ˆõ®¸¥ÅpØœ—-K|g(¬KŸmTY¿¨ÖÌ3Qõù‘ËãµùDP†2 þõ`20”7ôLî›E®Ï"YÁ1 ŠÍÆ%#´üG ƒµ£{í­¥¬Žçi]G¿ñó³J^¡™nfºCѨ]Ìnµ˜â{-žßŽ1‡N´&âàÒÐùÕV”ˆ}ÛíÁ)†]„áf_¿›«¨{Ulè[p*ßß­cZÆV„“·¡ï·çb|R§z/Èc›T•Ël,³™« m|Û8ø7_=!g†w¼)T /2Dàzðá8[Æ+àëÊ4ëHé=ª<†GzÚv ÃSKVú¢Gmß{G!�~´ õð.9Þ®ÍN‘'a¯¥,¨¿¸R”\¬»¸Ž®D<ýÞ:ÏÜJDzaœ4s+™ÊDËTíimÎóWê<N 56Dv@÷WOK’ªÅ379Óv¥ºíw>è°|Ê<.&ý ²ÊÑJÛ"ÝcŽd?ŸÐnnŸëý’RY4™s'ué ZÏgŽ¯žBÂɽ¡O•ùš¡°„ rÔk“¡d«à?jM…cÐ8x—tœŒ¬œa@#Q"âÿ’6ât¨‚äÝò(ט‘&7o»))ƒ1`¶3±äºåÓþBæÉÊãfæÑ(¨óQj^±ÈR}•„ ð¨Êkz×ÏIÍ‘¥¶¥|CEDu]€–”(VÑñ2.ªÿÚ •ÕÁÇMF‘D¾>zðÄ1m îÀ%C£dËDh?ÊÓ{L䌲Db¦`2é¦læ<ÈšZ'4�êÖ­5¤n¦™ü h[ºˆ§¾\(3)GÕôŠ6V2r0¶àüË5nl;84’Ñó…nXi™z"ŽßÝo«è¡}xgë¡þ@Û»ÞÐåÑ˼öÿ£CZt(è¢j4üÊž9íª‘{ñ“kÒö‹ Ä¡­ AÇ–SjÉ8Ȳ1Täí::G.›J˜îÚ¢Ye-mÂJææ»ó¥q™-i¥ñø‡ïòò¥³¹f×*r’ :מ´–R`:©´^@Þ+wÊh5³¬Ð# ²ÎcªQ¨ƒ(´)E§Ÿ§ <ɼù.Úøüñ—ž¯HÄíc:„š…’ÒF»à czf÷BÙa#ìæ4Ù®%Ÿ¡7øh›bdFn»£,�ôÄB¶o}¹6ÛSÛ˜rnxzáÁÝ Ó]hd¼ÝºÃyîè¼™ÇÖs‚ðÍÉÖ?ðgÐWŒJO"\Æ3üí¬¯KXžœ9­ÁÏ0è·Û §í™ú˜JJ¾0ÌÆÉŒà³k/³¦E÷f€Ï¦Ö?]àAq!HèÏ«Ã6-ª3:_ijû8´íŽˆÙ¸”e½§^ü<Œ$)Ê. ³Ýғ槟¬ßl^Ü£b?sJ;kV¥tíÅ“Q⤗ŽÖm]ÆÚHÃÿ:À¹*1‘8F7†¾È—/5mbêéÍŠu[K®å]Òp’Š ² øTh%‹—ÙA¦”\aÊ‚{ôê´øJ(•’;v3¡Ã]¥Q‹Ù#û†¨LøßåIq+ƒ|D¬Ý(܃¥ç–·÷S7(Tq½Š“«Êj£dò%uâbª ŠË šg—FÕõæ0x›÷7u}œU+°`º>ÈÛN™b¾ENe?åH^ÿå…z>‰bÏA$zÜ¥e1Ù•J…„ „¦±�Ô…\N}@MýKÛó|ªWim|?»MÖ©YR懿ß…é 7�Šm Éî/w¦šŒ–ŽùÍa#ª‚Žgˆh[kéˆÌ$z¢¢ü‹ƒj¾¸¾4­‡íª»n"ÇšÕuÿžzÎ#¿…g•Õ.M ö´{ÓnUu³2»v*6 /áhñèZ°œÓ¬¾Q¤êÔt‡)é.‚pçÜ<ñÇê«Çu¢ÌúÄ í¯p\U¦‰Ùó%GBÐØÒÝ»ö£©´­/ƒâßá’Q›Âå™-r¥¹J4l!R¼ïtÌߦ/¶ýáDþá´ †Oß‚dvjˆW-¥ 7­x»cµù³Ã¢Œ3n¡Hw>¯wÞ[ªñ±ž5›F ¦Ïrª?`!ú].&­[:Ý7í ˜P„¾«ö‚u„kð[á|kø>H¢4± ÆàüR$F›7xAWmmG"þì[Õo#X°ñ–_c¢¨¦7l{5ûu§Ê¬W®ú•€ýÑš;” rL`h"þ2ý-ììED½‹`ê² µ‚NSËGŠ>0h2„éxêu*ê‰,qGÎÂ_Ã8èÆz!‹{CÉZå͸¡ÛÏÜ?}ý®µã$ç8:Sš>Ð}­ðZr§ƒ@üVËÎZYÅÁt¤:þ]Iïi }cé©[ëòßÒ-¢(É<ûʼn•Ÿï–¿ý󖳆ä�g£ö ´XT”®¹ÈC:v":¦Èzqs^ìñþk!(oøʦS=ñ^{„Y„èM™‘ç_L²-¬&öh)ôÀßÔš6Ðæš„ge�DûïÅv…Õ´‰Ø4“VÆÐ…õÅe/™C/XÖ“ÂχЕ›‰3}ô/Õ åÒ¾éèAR¹ßóX`†éý9×½Kpúèhº¨b-,&¶W )=1–Ó «Á‡“†(-í´X”ú>'ÅÅ,ó¾½Î{ºÉ×7®y4Žð{n†ÓÛûyØBíFc×ÚÉ^?ÝÚ:¥B¢û×y† ;jj÷Hu­CÄ¿n!’±mé–ö‡õ%4ŸB×ÞÈÑÐûd™e~( ?ÜmO25Ӯݕ"kýå9Ža‰ùjÉ?ÚD—…H <rêÄ»þ°ˆú<²Oq\«ûƒ\=§RÊ‚AóÁ¦~ÍÞW—§'cüÒ!U�%‘Ó´0 Z?£›U±o´Šõs¬‹i²ü÷ýêüÎÑØBµGt¸IÁÉ• Ø4ã}ú=.J¬tQ5Þ\”jPÀv¬Õëã4[¡®ãŠr"$_šÎs§Jß¼'v�Ž&>³O0ýÂä‹{ÖìQ™ú:´^º1 ªò  ¼w8ÒÁ}†p¶Ð¦¦%¿ûösSÓÎ?¿ ¤j€-îOhm&ÆÃסá` &4f#­ åèO=¼¼+›@Æ™Ïk‚˜ÚÌECcSàÇçÃd²1`µ €Î\|Ó%² âHÅ�(zßrW;ìpslŽ¿®Xjõ*§ÐæÔ3jòF½*)œFë~^O �^u¸XÞ|Ý8¡ ÒüÑöw Íâ¸Z B™!¦­ÂD@8ß ¯ŸèA*÷ù ÑrÒ¤B¢ÈeXø®}È1r`6š€�X±ÇÔc¨î¹=ýZEÆWwChuômļ¡c=×_›«V}WAµXmg{¢~395B‘Ú‹‚íB'¬B%9§ù)Ã󯯪ÌW_G#«åÌz‡Ñ!³¹úج,¡Ê»|VŸŠ—áYÅŠÊ'AY/‰ŽN]î«ÚhîLšx3“ù6¢I“XÝU=˜ûͪ› ³2q'v:•ÐB5©À¡®}So¥x¬KMK3§|ÄRj@¥¶þLÇÃÐrsÆ^ˆ®Å…¸*of*›†k>ÿë5™ âü6µlrúx£è×Ô"EøT—® ]°p?´mkïseï;±Ué­\ŸXØÐÌbâéÓj_ñƒ†+Õ€í s˜Ôi@…H!ÎJNÞµq‘ä±Ø¥;90óÉ£ ¥¹zHµñ:4Úö#mÆd¯e~ÂØøw%d»\k¶JùëQBç2Ø¢ƒ°Þ›¼³�® …1ÂtºôLç o§ãÏ°üê†}ÉåïWçáQàäq %¢ET Îýü‹b7¶‚¹1_\jÊqÊ]cvŽŸ÷óæз­UóœÚËGëà wBR‡¯ŽžÜ¢óeÚ8‡-ž±¶$çÿ‚,ªfa4T‚¶ËrK¥ùA›ËÅ…ÒzË%ÂT{ ¹B™¨Î<¡¦ôÏH:úéÄêÉVCÖ–Pë;ÛFìí7VšÖ¿`ÓG¹s‡“Äf{ ƒbQÞ¼*:ÃwgqLþ½ÎÏ)4ù9AQùB1G$‹Ï/V¨Ú¶˜ ÄêùÀ ”Ô»åw’iv.*ÊÏ9,Ì)U[lá�…�@„&n©Z¿ñ0C·ˆ»2LhSZ£$6Ħ¨L - •tãHDV­3Êw1¨¼trܽ?&)cÙ”iÀétíg‹«Ï¨%ûuñsJBzšDŒ•al^jðŽ»Ô{n¡ÝÕ³xr&¯d!yóŠÊ7‹, YÕùx¯óÈPj•Xp?qË k7õá¬gÅ÷‘BQ²Å"¯[ »óN×xj· róm¿`’XëxÉsufæöì 8l¼Fñ,Á¡ßMµ4·îÖ£$5®ÞRæ‡rÌ%“ ³‰kûd Ê¯Ãb3 )%Z”‡1çÖ¹s¿Æº4î9Fo¸¯?¤Ã¤8u‘ɬº‡YÏ3ÿl¦}úJ‚ÂÎó�é¡ g¦ÛÃ*ØjÃ8°'”ÿ8ôô.sHÇ;‡Ýeeg»�™0p”¬çõ(W®¦ïè×tPN¶U“£¦ÆLýj‰¾?¨ Eÿ‰‹È×5Ž˜Fya7yA€J2Ýþ²¢fÚF£‹ÿÔs"Š¼aj.ú½(áëw›àƺ<4žµ_H?uŒ0�x»}[kȧ8*5KJ ]Þœz,¬IP´Ö/Núv••�~—¸½X$%ûõÄ÷£Ýsl}F<²ianZ„â€ÃeìüN}³«ëÐâˆ}+3ñ'(%yÿ×Á5!'GÊJ›1ãí«§w™~ÊöHIá»Ó»œáP¯2ÊÕýÅCàRÊ}pí]¹û]ùºÕ̺ÁéQ™wÞºó_ ò0\ÁŠÓ é¬C¿À4WPÕÃð$¨ X¾ÄZv†ÿ´Åƒ<nþ'áʶ dÖˆ©¦NªdƒvïÙ„Û¿,´m&WDƒTΫÇäÞS"Åø5‘Û´['êx®dßr¶<ÒúùT˜¸àå,ÏÆüÀú(ý¶; ÓÎú‡WØ0és­R.ð«Ð¥c�–‡¹3ñeÛœÏÌa…,²aÁÇY°$6•Š´ßj­ÀÜàöàŽRr+-¹~´®F|\,Ú #,÷ˆç T,jæÔ ;3]ù¿oqªá“E·§Ú¥é3nðñRl¶À^PïJÅNØ·;¼†ÿ/l bo‰&ív—S…Pw–ŸýÿР"gö"©½‹Š¡Û•IG#*Ë<s”_©§1í(-¸€‡¦“}È)!šÎMwjí+æÌÞÿîçÇ>;áI4`µîWÁz§ÕsÀ³!ƉSe^ê±#Å™Co±jß&”")*³€øÝ/ÚàA1žµ}ãéÿÕkuQ~³¹~osÅ‘7 eÞÓ¼¤A1(Y6® ÉÁffô™Ãêw²õ©…†ÆfbŽ5Ý|š¬ÃXn‡L7x¾1ì¢óàöÿÀŒQ_Ðݹ)ê!ˆ†ŸµZ¤Ì=8²QŒ(ý@ þS&7Ç0ejaعDê & 侇Å7Æ~RùíLt¼!ÿ©² Ì…©&¡Êô2ÑG¹jw¸„`Âm¢ØŽÒ3Eñ.=Ä„ LÑ¡9Ñ)ÖGöõð žLö÷’mKúæÒ!Û/ªCzcˆq�ú¬xn°Ú/‹Ü™/¤iäÙŠ*Ò@”Ôv]£$R¼ÍÉÙ¸}¸OÚt‘W‹PïœåÕâ,³@óf“ßLõUÂßЕvJa8Õ”:þ¥÷tVoî°Êᩆ¢.½÷DÔ¶ rp—Ä`òæŽç¬ß+÷Šnë7YañÿbõÞ­9µY ÿY°ÙPÒÔ꜈ýù?†ð­a¶ò|u’Ù‹GM‡ÍÆÁ!VlÑ(Vg±Ú(‚¦ÇÎkï<3°.,J`1œ|ÛƒÂx7>·=qÚÛ,@Nå °qyÝ{ÚöÊ$Qs*‚[Ãg˜µútiŒ=úMÃèÝŒU5} @òÿÄ}}FŽç´ï ¸¾[bŠìë©ðÄ~1[ØÕ*kŽ¶é4<UUvÔ<='ögz—l3{Løž6ñ´©÷´û*­6#mûnVf¢0êË'mçdóéI5ˆ@ú¦½aˆ3ÐÞ’ ÚŸ6ª*9ì¼´hÞ]N×nHvö\};WDZÇba¨9Ŋ׾?8ø”V bñ®´h(yœØ´@£«<o¤ëèVÓº8[ÝEôŸA›i/žœ¯ØáÊ__7ö³‰Û½ŸÖ³Ijîiî^ÆÖêÉ¢ {:íf‹¹ÖróÖ‘øûïÝYjd“² ûJ¨Êÿòly´_­´_Xmv”“?õ‚ö1 ™XŠQÒ*—8‰!m¾=´”/ñ‚ymR¥+Ófži«nê™Ì_mx—¶ÈôA,Ÿ8 ú†ûO¯R¢u9Ÿ+¦ƒàf[ßêÉ{òÏêX.ˆ�1\DámµÑѸj¹óBS’?YYÅ>Á™›çmDƒ>6ŒLMmS«ä#ˤ(R›®D(¼»:òæÓSû0´N#å4I·Ä{ù®ýUúº¸”.Óà»Vxd5«¯ÞÓÞ¨?^Õþ oû(ÀAõ5´JeŽÉ쇄º³>î,°!´Ê03p ½÷ÖµÛž«:WüÒzª§kšb'uˆ`*÷×aXý`À»²¶nÚæYeɤÒÙÞ8Î…p¤*4ug†º›E¯É˜ê<L#WÀŒ åÎy9”Ù“QžÇÃ-Q_èŤ:tþ=š ••®dsÁàÂjñ_ÞzšG¤ÕÖçEÓ Ë-Œ.#ÔâQ¹÷°: ¦æôehWLçÝNKƒg 57µŽŒyÅ{pô¾œºk…0‚Ϭª†e„ßØ|ð¥¨{´^<l†„¢šŽ“âÂö €•÷ÙÁõ»l‘'#ÊÃ0v )û«9‘q‡ÑôëôØWãS•„à‰AŸ¥ÃB§ˆø¨:KËt*=ß®"%E¾)3Çæ­ë@œªÔjª®†{ÚÑE§8GÎ<Í^óµok#1=!WÞŽ˜cÎIaßyÙˆV©Ø­— ¾”º‰4¢C�¹á¡j{Ç¥ êD£g!ªyàÚã¹óx¥xÈ42H{%’N§kÝó™,…ŠyœÞ¯Ýðå7îÌå(‚;X&*¹ëÁ#å/04ìì‹‘g´¸è÷çét£%¡ï”tÞ5Ù[<.Æš¸IÎ ŠÂ ïž©ÛT±_Ið¾âFã³ D‹ObÏc»ûzv~ÊÏýÊý¹ ª¶©QuhZMLxæè›*ê‰EÔéÈåOKÔ¨ç£*ñ ohzýa »÷è‡9rž»½ÊšÙ”>$­ ñ¹7´Ñ‘ÜkÙêñ” LVŤ¬„ÇÚyMc×úùEî85ºœbâÅäÍ*HvïžfÖ R|Åù×g#xû˜æ+G¡"˜s*É­T,ÊOb7= JZ¤O%c(¡®éÕ÷·Ï*×ûËѧ8õ�(Öïžw3-`†°;ô·.^Y¼jBâÑ1hæ6Óó(f‘�'´9Q‚lƒþÒ­ÖÌó¬ÌÙ#,)¨.í\¨§ÿ·/ì'n„æ°›r_νù¦/‹7cÕ÷5øÔOê«@À™±¡•8Žžp !±&rjr¿h;¹A•X¦äÂ.*ßg¯M Šß¯0œ¢çÔ¢Â91Š7ÞÌPÅzïAë™’MÛ¿½9:¿¡”g› 2åHB§ ¡W¥ßBò¹œ±%äîÐþ<Hóù@t…‰oúˆFÀ.£ãOm½²‡7,Ì`º£VŒÛšû áÿ¥“\W”¦§Ð™w¶Š‹‘‚s“G9oµa£ÿÔ UzM* ¶;ÎØSÉ©¼cÇ^-¶‰õ ‰ƒÂi  î'ê®Eœ‘íf EŽSígOn¨YÅ4{€JR2~1ç‰ ‡9–#|l« ª€)Œ êF”Â,'êè}ŸG#V\s[¢cKÁs£C}ÊÇaQÞµ,ÁE_Pàé”aÒyeŸ”ã�ÓË-bC$ñ˜þ£UôfþáÔú‰9EµE1Þs»ôõåž š7¢•ÇdŠvç‘)蹚1š‘Õ|Æ¥ðYqn¢,BÞ‘(¤û½óúžºS³«ß¶íêì5ã?×võṦk”FêiÀLi?zö‚Í龘¼³e[¶žþÚ[)RÕW#/!i˃âsçán¹û¨beóm^ •“;ÎëÔ­HœR'w)§}$V* fQ²Þ:±”,S5|¹œ>´O`¯�õNq‚¸2–}´TŠ-BÑfjÙeVbþèìgK)ÇU¸6ö9·ÈMþ`øÄ ˜ZçÈÿM05Š#_V™ŽcNÏZ ÐçÝò™éB,(�éÝLÝ~È“Ä—i ͨëi8„3¦± Go&$<Ò¹y¹\Gá ŸXàV4®*¥S“,•£íe”ÉdðoD•e6 #ÿ íž25Gcnü)#ý¸Ñ”’­ÿ¾ì—³” |;)�²>Á­*´+{f–ªŒ‘y¢�¡çÔ~ùLdvü]çòèÆ·wì sO·œ4w×2H–gçdGPúŽW68ã�ðØîÚ77;/-o”Fû¶dž°ëíX±IŽ:Z·Ãj,ÝÙ¶×÷Ùt‘g^Iåcä‘T#¨¯¢ÉJ7Adõ_mÑe…_@Qз9´Åÿ5$À’µEä<0júÐÂ1¦¯É”¹zs F ¥´L7áqF+ŠóiÙGî5ªÒº 6ÈÏs…YõÊ Îó]ÞX(›‘$M|²Ü»ZMJ 7I¡Vò‰0ƒeUv-bsw~{àçn'4ûͦ ,ovš:2¸`M]‰ªô º §Ö»z6|ôÚõ×ÔP„ˆ—ÉO™õmµ\)5f>ó÷[R®Xö•Q([ô@fŸßCí ªžI“E–»ÅBfG‡{O²Š#‹.©fÞšý*CÚ›w‹5÷RÓ-lkÔ ëÍh o~ÒÝÊCŸóN·£§Â Ãk: ‡]«lØ×E#ÀR·úîiÜDQiÏd?ê”IçKãå ´éÐHSÓ‹¡ x—÷Ïv×—ŠŒ›à½]Êæ[Š-W#?ÒãÃÿòg°·U›ÉŒ·û¦¡:/r1‹±Œ¶ ¤¿ãålŒ†Ä“ò1 ³Ì™_Ñr¾L9Ò;³^J�e›Ú2Ùgïƒ)íÊÓºõ­ £4óñlÔ÷ë•ŒG)šHF% ¿6Âù²Â;–Þu=ÜsëC_ † ùh°f¹Á×Ѿ^ _9øÒÐß.Ð0¸Õ˜ýÓᆢj¸à}èX÷r�RLþ} øçJiòûÊ«_Š8@ÊvîÙgДxìNõö~ºnWÉÛ¾mx ò½¬PA¿…óET_Š¦Tt¨­œÄúˆ¯ ¦Rœ$iWðýzÍ›È'ñg¢NBA²Ø+¯7 9­¦½=™¦ÊÇӲʼIBE•êïÉFÐÂ4þyO›/H'[LëëÐ35þF´6mt Àtë<C³´­­ÑK82Köíˆr™KÇ~E]Ù¿XÙ<t^¿’ÒãW‚â‘Y–îbu£Æxséƒr&+Hõ–ãGšå –2@bR62c eåqOG~žÏñd+Bʽ2(ζãŒÖ­QÅïÄýæ5AŒ°òç1T K:\¿+M$‹²QÕl£Š±­)à#r\\ú™Íß#–ñ£Û}z§"½sýçÐ`*+¤¯ÅÂû‡²7 }vúö t*Z}z Ü×ÇÃìy ¿GT[‹pséµã‹Ð#W²piä_6S#{›ÑPôgJèYä8¸Zž?e.N¾ö¬o<•»Ÿôî|­L¾sÉÜžDÝ çó‘ba„™‚ïÅeQ…+—ª\îƒUJDÞx:;ÄÞ·á¾~åù0§Œq-Úì=¤‰¨Ü©0}á71ãX]h(¼=ÿßQIÝåBŸ×uÓL3µÖÂŽTœky—¯É¬~7ö² Z»'qÝäŒK•‡~EDÏ¿Áju{ ÖT<É(öµ›«×Ó2µ–‡°þ‰ÑLÌÿž Jk±é) 9ëE^v(µ«)ú…÷Çtj~.ì#AÝë!Á&^óy¥ÖYiyDf&øÀU z“Òš ¾ý{zœ&™‡¬¤:ó¼¡?³XÇÌ¡‹NÜ•úÿÏp;‡6ÝTä{«w«ß]{É’Ðð¿(ø•«ªxÆ }±lÒ†H)ŽÍÓâˆ0ª'öXW,uˆŒ\jXZX•Õ.Øõ”ä™-q8I”Û!LL$<p¹sÅý{´;½çÐçÁe ÔÅsÌBx¶1ÍZLîŒ ÈøÙ<pŸ×–+hÖ@×L{2U7Ãû]{ø÷4õyæMn Lî=*­bXO¡t>Ñêµ°Mxj2¬x–åJàâ˜Í¡ ÃÛë&ø}ýëÑ5FLv}NÍêŸ&ûfˆéÑèã`ÑÈ ]äÜ²Ä ƶÃÎõKäÐ[¡‰ s MÁVSŽYŽODV>¹wÂó¤Ü$VLf6@{Z†¦…vߺ؄Íßù´¥ÎÔG�ÈVt\bÊkÜÔ6ÀæâÎÚ JøçË©¿ëJhs„æZˆË_¼ï<å?c4oDœÆÓ¢Ö°/ý¹3•‡ª’öÊ'%ñIÍ}ä/m>vªJlñ\µ@ŽDÙhûé+ ¶o†©E[ìj°¼îªíª«©9’•ÇcP?¥-»tiUœeôW¯»™àp¡Gc4¬¾‡Øҧ >âÓ}ã=·Ýy2â®FÅècQ²?è™�WYIðÜ•µ¬Ìü.GI™}`«·ÏVotÚñiîü‹l,ÊwˆÚœý*“ÑÎmY¹ÜJýèN§^û¤M›gAÖ·N… ®pÎ-Xàö.“œâœ9bi‡ÌŒpš%Tb©1À<¨Ö=å°]ËϾRdØÜðŽÆíÊh«#¤U{è¬K_zOÛšÃ<Ë?ò©¿C #¯ÿ*ÄŒK ðD·7Ä V¶=ˆ ˜b›©þOßþ£ ÂXTFÓ¿–`^ë=2“†Ã4{ :ohóäö§Y–yõ 4™ï ”#>ìÏøîZÈ]ï)Ÿ:Ô á>z©øÜ•Ýk‰§Ƀ—KMåå¢ÖQ¬è·í‡¥`ÿÄñö.±é¼â¤@ý·iX˜kçb2¢7ѺGúÐ[˜;³HÃ+H‰,qf+!ƒ; ÚÔÖ«OŽ`Ù¨ôÆC‹† T¤o/nq >K‚Ç a§}aVÌ$o<…ypÇao¨×êoÝþå"\‘ªñ¥º’•®ŸYÏ[ „3¾4r@=ºfõõÐS‘  »F7Ò¥N„í´kƒ–ü,2é¿°6ò™N‚<Ý÷IXá~Zò;ÚNœBqî3ì4øɼJHÎÓÐw˜Ü�šå¤Ñt¿”_2÷þp¢TÎ>´.Á}Leæ=àöÿ~íÝjÙ¢gcÆïf1}Ý|Í]&}6t;Êó§óoµv«y*£}Õnüî%:dø¦ŠŽÕ ¨Zþ¥7ÕAO°àÊJX;Zý´—Ã|g]“dZè°™ÁHz8´f­TF^}nÇnVªí¶;1üP_×s–(wò/L‹X`W6*óT:Zö \iæÝvæN>K@Ç œ…“O‹§C÷ç㊶#§¡Ìžá4œU™KôUÕ×7FE¿r_•ö½•  ˜Ʀºñ^P¹?ÀŠ˜°REïÚü\¢n‘ÖùbÑ]=|гv‡Ùxú¡OvóðþÀ‰îÇ>åÅpqíF°ÍÍ禬àb“1úÀ÷™2Tµ#Û*˜úäWm­�`¼@jš­¶÷ô²aºržŒ3£84X‚) sCj”ßÉ ÙL76¦ÍP„Ì»IAhãx`u’¹â~4r KŸ½&A¨XÜ ¾Ø}‡©Þ¡BïN3ôuZ:9¦óþ´‡!Ò7Úo^­¬ÐpsQú-‚ìR{ôÓI ¥–Y‰<{Qå7+e¹‹—Œ>{íGBáå‹ÐÁçPgý˜÷îá ‘}¶Îvº™ÎLÑÐÖ,Wâþ¿ßÑ‹©_r0ÂŒN­¤Ó\ªi{)üvyÀËnîNŠ5³B‘/)FæŽù#“sØqçï“UÔ¥°?ñVRCn{q¬Ù%J: žË]œ®Ìl‹`€x<¶^×rÍ Ÿ_ì =s1 =±Õ¾n‡úü¶¿pª±ú Ï \i V´Ó ¬MSfüY„ÿÌ=Ù¡Ûg>žôÑãŸrºzA¦lÙ®€+2 ‚tÒÚñ.ïÁê¤.�Ý/´fñ0ªcwGm…ý¦i”äEèC´|–!¡¾×¼îT‹êíñƒèMMÆ)MÛÀòËþˆx‹Ž¿Qf©E¸/”ä${mˆ`:ÔY­,`ÀDTx5«kY0°Æ{ô½û<¾È+vq  Ý>iqãóÜB7Ô(µƒ½q9Äê‚qŒ‹%9?Ð\Ž=½„…MÓ²å±Ýá1ÏÏG‘nK¨¾B_Š¢ÊÇb†1Œë©ØÙ,¦•#®„K=°†­‘ úÑ°Þ¡¥C; 㿪¹˜ƒGŒèèX}cÜÚß*£-B‘ ”?¬/aFò¯êëʼnۉHW©L*Œ±§S¨ƒ Ì<‘ó€tǾBºød_¼á€N}úšÏ+é_®óqx_-ÿ'¨µ5òÍ¥´è’A99T´Ìÿ\ÿÙœ†åÀL‹¾n¦ëàucKïwú0¡oý“Oíà…V"y[¼k¢‰®Ìd}pžY¯¸'ð‰‡ÔK~t79›ljX…Õ–© =ŠÞFŸñ±t¦=äfT¢Á¼µÿrU½õ’z¡ÙI Æ'?X“2G]bÉi6Ö ÆêÂá‹“yOùêe·Àª4t\Ö‹¢(3Cw,ߨ OÜ»[N£Gªyƒu‡öPx¸ÏTÇõ(å±T˜çi–Ó�±3kñ—òðdžÃAE˜¨.8õ…$óL×�qú*‚Ü’ð%`?b*,Lw۳Š‚Þà æ®üàuëcÏBPÌ=Ë‚†ÙVt/0ĵzv£±{Ww@caääQØ`û§ ’þìÊf ÀÛÓ—5uÐÉž”Nn®·j ¶Ñ'Æ“9ž ß5Ö¿Cgd¥<(öì]ÅàE"h’ú²#!Ò±ˆn‘ƒ£s[÷› j®>çKÝpòeïŠXß­!ße·£ÌŸþaDÓS‘–Ž*Êž£ÍQüöðF‡+=ðàú¶kéOQi¹¾Þ_ ÙÔØWŒ$„BöaDßî]m|¡Ö‚Ð ‰6Öã[<´©ý³©¢ècÓgŸÐˆ{…ÄmýGIÆ°UJ_,1wš¥?*¯7üýÒSzàªgSÓ[v^æDKfÃÄ>+ Àiå‘öÆaôCœm…† 2O´‡Ñ›PùJUBå¡Äý'âKú-;ÖH‚ÂÒDRC„`‘èI Ž]­$ÏÃÀ(ÉÖ ÿúþŠâ`X›­óýâŽê‚/>Á¼LØn–ŽuŠš7æo9ë·¢x̃¯ŽÍaÉ:<b{…—æ¶Öcô‰ôzß-9‡ËÝ¥Ó¹>xZúc§×Jz ^+Â<“À|ø×sŒ©aÔ*cG~°œ!oOàðz—ω=Ø3ãL³)ò úT®E¢&«Ýyf…EŽˆmÀ–E/Ù8á1ÂÍUR8ÅôÉ“ {<°úiö¦ã¬F׃Ѹ¾Ô«[TvVŸ>¦QÆp¤Ìªp ÒR8sòŒ=Úð¦”ô¯‹Íù)„À³û–¶q:([ Æ BÁWSãA²ïµàòÄ7(£$­o©8¾\=†ò¾wn›I'ißÄæž¡úÄKž7sB^Ñ6—1`òm?lGîeÊy–ûbd€€Î@öž/á„»3Cà¯U^(ü™¹¨¥ƒ–“=ÕèúDîôðM<æ©Ï¢lãµÛí£úÖOÛ§y²¾ÔžòäyçIw@±4ŠÅ‚‰Â]7á_,­žR}O™aÔ)J6¹821šÔ]§9õtwz èîêûùj”í ±¢ ìÏ�䈳#À˜táUÍìÙ‘ÿ>^üe¸REw¼§·¯5ˆB¬°™N#·; Þ@n[ß[ q¡¤q%#B³¬{ON–9õ{!Ì"ZYŠ%ëB•½›cÈ×Nt˜ù4øº¾Øa_Y¬ ¶C:Tè(±¤åˆ¾ {y®õ÷ñÀOgZxZq€|Zõ½þaí|l¿Ñòʼ”QæÖÅI!ãâ­ÏÃAwê <ÖCÈB_K„ÂÖe‡†˜¶EàDÛR´1Mþà#ánÈ»ú&†>sDçÎÃ%í1”ñò¯×n7í·8�>GÍÍ4Y`VN¡þüÑ«wý †ÁqÅI ²"Y,_.;›Ñ7Vô¨w®¾éÄÆ¡ ¡<šu˜Px[oøZrCç÷Æn˜¯&»Ûk©éH8gPX_ÏÎÁ$xfž5Òà±ò  ÿt>l+r942O¾ß5KÖV¤ÓeðüFÑq\­7g¤h{d”«Ê�à #$ÈWºÙ™qmOG¶å5ÞÈŘå!ð0Ë[Î�Ì´Æï¢Á„¬k5'¬™ç‘V˜€äAÖëé„™ÇÛa®wäQ^9Ô�“ ðwo òâ|åÖÊjÇTy¼Ûùw•X½:žîJïÏyb¹«ïŒ‰*©</+ðhÇ4 Ò©õb ß~v>b4:P䇚j¤í帙jæïêÖ½¢;;)¯HÈŠ Ùç°ÂÛÇ¡—Vè=òïŠåq´"Nepi ÒfQÇhÄl+#cWóß2¯m7N@A˜y€x}îœn¨$Š~^ œ¨H[Ä÷3¡’(Zñíh?¡½Ï¾« Vw:™Õÿ¨jjkõÒŸË(?ƒ4œ¡žþÐwV<.œÚ›¾On V"öÒWÀ›Ø²0‰ŽaŠˆÞ*ÈŒWžHžújfä8)Óžg¶ïžÄ+*¼qÅ2X½¥7?úÍÝO½yñeµ¹ÒŽÀA8» úÂɧy½‘7O 3ÁG ²©ÖÒš•Ÿ®ô¯ cþÑ«WLWÚ\ _µ¨& „?Z.Œ (£ôÜ©{ DPy·)y¡’84Z~y?šÍSÍ­°"'MËŸñƒ ýî1š0óÜè¹–q#˜ój{�Ã8Iœpï]ÝéøìV!„xDfÅ#˜¢z:f×!.t“'t±ïé,kü$ÝEŸôúyŽËyˆ/LBϘ-ÇÍ>~Pz_|)¨'ï<^¾ŽÓØ?Œ¢v$£®D(ÿÕf*q50RxcÑJÓ—û J\®ôw!¸PBT[jõ¦T'lÙžžæÌŠQ25d½ª¬°M¦§w6@tî{3ùб# Ù\ƒŠ ­- nv§î­¯H Äi¶nÏ�‚TXp pÅZ|ø‚ƒO!H+4R”¨“NjHÊGŒæ7WAPyjÓƒR©S~±ðZË»–‹ûð¯ëbó “‚ñÿvh¦Hµ4}ðZŠF{GŠÄðk8ý¿ã¶$é*èHw¦Oª[AÙ …Èü]Õ¸ŠT&—ÝIkŒ™îMÇäïŠÖ.Û.}”­Û/TÎhu–_šnŒç‰Ád†Ÿ€;cyt0³ZvݶÝþ`À[¬ Y"èÜÕçÆ AÏÀ¢Rÿzlåþ\.RŽ²Qõ&ªDؤ’ÆýN9Îʃ¯±òÇ& âVk%$’kcAnkE£ß¹rúÈRu"v0ºü,tç ­MmÃPóY/´æUÑ PmýªEÜ3,hìOškËä©—áoAÆOI`¬õ¡/ßz›Éº·™ÁÊ6 ²½¾cU‰«%"órs÷`äBŒƒí7+ÛøÛn;…”R¿[r6¼´${Ó¡¸uz82´µ—%m:Ð0ÇìÇØíôEE»Âœ–¿z@6É£Ýbèh&=–Â9¦x{î׃À±ù<¹´ÂáelkG·izƒ_é늊¡½®+|~4õú`Ó³`-&êavŸ9F„F7ý“[¦ T™‡¶Ÿ5õÚŸXGfs}có•¡"ÕÊ櫢œîq4¼{F°íÊéýÕ¸/º†Êb£6³ê¡màZl=Æýø6&ÿÕi­¨BiŽTôPéËv ªÚ˜ü˜pØP„g:[=]m?)Úãžs¡oË' w'$ÔŸºe0h؆7™nà‹½èê?Ðý_YbX°Sd°ÁCÙ—•fG9ÊîŽ"œuvf`ß»ú¦¤•¬ß!D£`a?XÁBló�U7óÅÕn•Ø¢ÊõEØbNÑ‘¾x2ç´55*]éSJUuÃip tÐä¤U(KÑT¤Ýõ'çf}¨ù“®6ù¼·©èýßÚé±.Z%HÜ+ë©D逋/*º¥U‚ôY·eºZ¤Š¾Ç/ï« †p{ʃèK¡fX7mms`(Ío Ê°So¦Ü¥%òá]FÆŒ‚pÔ¤ÔÍ 5Ø£ÍmMÏ7Hi~iµìã7ðÀ HÁ…” ÿëÅ¡ùÄflV Ù½3Õîý„Ë<™Û¥kÿ×j!#$« jz9€\4<:É&é‹ð¾}õG“•a›Ï ‘]`ecì%îðEØ }À‡àwךuû3âg,Ä,ƒÂ¯p[(±À0Lªƒu:x—¶,͇· ¶HÅØ`£z´ÁºwO‹é¬p_Ñù“bS\e™§îÅ­:ª`2 \BÓa ð bÛ0pùMtýå xàõ[Ç.vÅ^Å'ƳŠÓ¥bˆ¤Våmÿj˜W>t/E7)V,×ѯàè­<ã£öQäß~-h žF·�{H8û³¸Z æùV‚RʉöYã91Rh£ƒƒÞül‘¬iÝ œ@ÊÙzÂ�s3ÝÌ(–3Ž4Þ(ýMlB˜m.ÒÜ©ï¡ûc6`¥m £ù7öi>Ý Ç¸Ìè7Ú4öÄ|–¼?ÃŽ¤×å2ž®(–gÆ0hË (9ƒT!cÜÍñoS‘úàðhkÚ:º¬á¶÷ì6?áÄ_.-@eõ€„é5!Û¤!Ý0 ÎTYTSï_úÕ˜¤«¯”£tÎÃôŽbè I"‘þƒXb'G>tÈj[~¿Å¾­æóX뎻ŃÙÎL,¼]˜ŽRðþª™6$çöÜn<o„‹ô—ããh­­†ûôg*èzUv,8§î‘ü©`ä‡{‡¼+̦o³ ]´Å³sÓ"ÕEÿáÅ’çW¾µUlуt04£G"Ú´íŠ÷ùqh´éZšëóoö¼¦’u…m—RtªEö1æ|l03Uû U!‚,îž%Qž[±`¡zѶ׬R@¤4h!Ú~ÝÂÚaúòóùî’•BéË=FgonF_sø�&„Lo84æCâ3­³;“òTe§Å®&–: í4Ô¢{Ó¬7‚÷w~ÅIºZ'”‘Ð-;my]„[ûŽaóJ<H‹»ÿ㇎ãQ˜Ý”Nsù 4ظFvwW7§=æGSwm®á½Ø€sûª|'OFéÏaOû2y·®_¹aŸ,Å`8Òk;°X«!ÂÛ"=/œjWjæÆIPŒýêFùãè\€k„foGÄUèk“³[TÝÙ²Jrô &KOýðy^9»Ð¨ˆÐ"´Ê$0ÂÂÿˆgi¼ÛÙ¡IY;è ÃNâZ:øï(‡D¥?Wc“ °ò,ÄN}¿e=²Ÿ<׿­6l†¤žk´(Žö®q•sçùbG< c&ã\vWz¬uÄbùÊa%Xý“ž´›¡KKŽ{A4(÷©!þf·Ïüß·$|ûç-)8 â¢¹¸û7³û,qv,ìb�3àÁªëx!ä0Õ›Ö¶ÄÓOÎs_Œ›¾ß‘Þ/ÞïM" £OÀ@+îneËý·~b`[§•Áá6ü_¬¯1&“C÷,÷)w·V_Ï˵[åõ4ñgi Û#ŒÆv<Ç+“c›ÔK÷NÚØ·kbµïyOÙÐz¶JØ}¾UB'•æƒ­Ž·°GÛ{TÅ ‘ ±‚M¦fõP¹qR‘”^´ÑÍÿDBÄRCcßãh¼hÓ) ü”Øjÿ¿ÇâÅÐg’a8äAû…r¾zö43…]:kyUlÏ´A¤Ëë]BžåÆ´ɯñjêÌïÎ iPŽhÑ«ÈÚò3´HVÜ f¶ô³Õ(Ö`¸4?¥¾q—O@Niú¢Ý‘P1ÓEïâΚ\C9® ¼DÀ¬b¿ëFë¤Ç` ×QE›€3ª1NLIðG+‡¡&¢@ЛÝ{G˜? }¢*æ{'*FšÆ u@‹7H¡µµw¿=s§SS¹9€•YY1›î:4ÖG”¸•gqØÊß½}½¯»àQVKy&t“ÂÁ7ö„ÀÊÅò=eæØûéÂÓ^´ Œ+ç+îqNýUõ¥ç–naØ·š˜Æ1Í(;¾>B o…œ¶² l|,S‰ëð‚C^E ÖyÓEŒg�-ËXž³Icî¿ø"¹ 4H梳«îaŸ¬£ƒ,÷d�-}Íý¸tÀè'waOb™ô¥6DÌO£GøÈ°Bè1OT¤æm2¸(S]zÕ6Ù @žØ\?«xü¿£Äg«N/ROÅqJÚª¬Û ù­îj%ÿØÄg‚`Žõ¿P·yz(')‘ªºÑÁ“Dñ»7ãÈ»ïyWCÚvÊY¨4„F.O ˆÕ{Ìû1œ ì ÐÍO¸ÙQ¶ÖÉâ&<h#‚Î/…²³£EËÛü‹­ø2r²°Š«¹¤›1ÌNÎñx«zK£8~íë3ãOÁǸ¢Ïà-Ÿæ÷­¦¦J´·Àv:W±œÍ«׺tfÞÂai£-°Ãç«j0aœ@Ù<ã´\Ò$OÀ^üí•êgnïˆð…Á&Ð) ¤¶&´”ðç>Ö=¾>çà±½ ¸‰¨û·´ŽÕ™HŸx¾@aÇÊCŠ7ý<«áZ$ó¼Cž‹xúë8y”Ôð{Ã( ÅÚGp]“éÙJ„r·Ž‚!EîÇÞ=WJÝã‘|d^ïϦ óö”DX] ácõ ’(µ9Åî"¤§ÖƉGÿxìý\ñçÎó>`"þq“䈌)65WûL3"öÚâ¼3°£ç¢àTd~è¾RZiÌ6ì#`õçz1<-ñáx$"9žÔ :VT²AÚú>®Nµ°¶(kÞs÷È^L­¿{Ý:_"Qºœ[*XÆ‹¯ŠÓÞX§©ü@BÉy¿Æ&_ª¯g M…YÏC·ÍÔò}ø{.IæAå–xØS¦0© ¬‡VP”Î}‡ñÆ{¿þñÉÝJ"¯••²# &ŠµE® H…õΰH¼ú¸þ‘©ï½Í÷x¼§âcBâ„HœO‹IcãrnN“o{šC"B=V_a»¥ÑZÈ¡ÂΥњwm¸À6V±¦&ÛÕb&¡¯«1^è`gèyVÁ0PœÝמŸ<25´°LñY×LF»~t©Ž¬ø‘¶± ðO\ëVj¾U‚GÌdZŸü\t0�[Ìn]†‰›–aX¸…Âœó_šƒúKëGà]‘`YcKp’!·ø`íT ÇÉþ¨¯Çú¬¾ »anHm9k'ޟ器P†L{º;ɸ¸^9ZCl™hB­×Ó}tý ×›Z¶V Àü]Q##c´#Q@º9H½ˆX$)Ñ.!0=†ú_šV°(i¸XÏ’édk¿(EaîkíÓó™öðÝ,fOuy«6‰ DrêÈÖÜë\u’˜D.ŽŒ8+´#[ÆÖÍ>Ôž/ÊO"ƒQìY3˼Ÿi‘Uïƒ/üŒuÊx>þ‡žmGÍË3‹ÔïƒÄì0égçÐMÛŽoè\ ìÿЈÁî=Go±ò ¶`fÔ_-öƒU-LÑ›ðµéðCgöÛþžÕ`Ë|² ú²}J»MRRú¦vZ {ɽ}kåÛcaì•"Q@ŒŒf LÄÜj©ÀO(¡Z�´^ŽE>b‹1{GÌ7ÛO§ ‚ƒ…ÔgÌlà à}ÞËõÉýï’–~ž%úè«Ìÿú*¾ŠÑ§äÊ[<|Sã»æÆIâô`ðíèüLœÂ}¤ Äæ”nÚ‹H/Ù‹'e±ˆWÁvúN¯`‰"  ¸s¤“ˆ÷¿Á“Е’”À.¥þ ³fœæLeT_]gÅÌzt‚:`AAQ}—G¸»ac2-”…žÞ¬è© û¢þS­\ ¼ÃJ~ýõ_~O1|µ*¹œÈäíÁŠc Ä_Ú 2j«jCÜ…õÆ©2KFÏ ’ÝÅTZÀþ3­êtéù c—ô]ÁêA8û°‚Ç›rŸÑ”<h´z"t…‡·ùÀ’_e\i¹LÐÇÞÌIdsëe/p ‚>|ËBìtbJòò—ã›,½Ñü^vIµ“–`t>ÿU Tÿ ðܼ^¦–¹¾x¶¹Qaä&‡–Ž”p§ÞÜÏ¢÷§í¯öDáÏÃ)Ê]Š×sHUÞXÿnÀ‹´a¶ö∠÷ #¹øë×—ÅHD† Ë÷Úã1­ðUÜ‹átË¿|6•¬ t¸€±Š¬²¸²ÒYB'Ž5â¬!¿“ùz[Ó‚¼“¸²ÿKt¶ZE•¥}*2À³~yîc·¢kVŠÊì¾³”ÒÞ‚ªÒ­«~jnÆ~RÇ^(þ¢üé†ìbÇzGê"q’âÖzMÑÑ÷5³;­ ;œ- ae:BnG+ÜÄì6O²˜üÙ×ÇE›u¦V‰´¦G/uïiQ!&�˜€½é¢ÂýV_µ¿ó3¯,»´m[T+Ö`Á�þê½õØÙwåàÿ‚ßOK—š&ÜÞ"Î#íÍý9l@AŒŠ®éí=zýF£ +ƒp¦$H—Þ§óÏ|Ü=t¢*ö†L~)QLzåÙ—‚ ¶„Ɖ͵ãŽãR³ÚÔ0¡Êå<óP‡AÞglŠ¢ Ý¿Uåò¨†Zʵr«‰ f|Š«¡‡¢Þûéa µ-1¹U@›!)<h,ÜÊyÎ%lŒ èŽóÆè ½É¬êûd÷û掠”yÒ ´ÿ“ ˜.Þ4™½Êö­g¡ŠŽï"éüýËïçœÕˆPÕPl09¬h^ßZ»¡?XOx!ôÀ½= ͦʸÓ!5�¦­§_‰#ÜxÏJ ÜÕ~ëG—C&¸”‹T‹6ð æ¼CKù:ÜË96Ì%½ãøct„&[$'êÚ¶ô5Ô¹2D­¶ýà.•7b~~žr…D€·‚žîÕcv.–2ÆTåBaæ¡_hœ:S|ú„‘Oçúꀔà£Q¼3È€Ps‘zÊÊÛ£¼‰Á€Ò-‡ÊÞXIJÁÍ„œ×°eêPXî9ÚèÐnÖ=I8ª=©:kBG¡Tƒß[¨Ž3gÒÞ‰nG­³XPQ�ø7›‡'& †è냼O}b‚Y?Ó·\Ÿñ}@ l¢û Ç¡;eùÄhК){ û.lÏL¬“(1»!õ¦¼™xz‰&‰{߇ÿ…VÇqÁŒ¶™*¾kã±èéqQÅt´Šu?al_o笾P3§„›ª`VKâ\Ùz '›‰0] nVt×ÝÅ71‘HYãÂÆw}.éǶ¶Öh ÷ ,ç7¯,w8¹Ü@wò ê´y\Z¨q*ü¸Ž“B‰Ø¸k(™Ý\ ú+‘jiO‡g5¯yuxc+Ç°Ú/¨(_Ìcšoèv´Š®¡ìç£Õ‡ßv Y)œ1§¤OË€ì]‘lèãïtä©xμð,ýûÅZ 9öá›èvÓ-ƒ¬n\újd.ØM–ÊO”ðæå!…P •¤Ãá»Qe5–î�]|!%›`Å#:è÷Ù^ä÷_™ÿÉd¡E<3+ ±¡ ¢Öª†ç6ãQɵQâ•3ì{uÅyœ9¬$´A(ŒÚÎ…žµŽÆð6L#Ÿ!‰GÐåH4&º¸žÑÈ Ú´ðò= ³‡ŠE™' †2¨Fë®Ö\S-õþÜÞ¬Ðf¾;‚‰< ?»Jljºéñè+]÷‡cûÆüs\\ÛÓŸC¯/E~c ã+Íd]D fë ‘zP2.&ƒ‡°MDÅÄEE·öç‚"‹•q0]aú¨�9²*–½ú.h‡+{jDBFõîj›c1zìð|ûß·¢0¤í˜n.mòÃ"Bé? ³4¼V¢õFÉDmmL WROÂŒÕç‡{rÚ-üÑþä*º²½_dŸ;ï öUC”PsÚš»FèÞ[ƒÆ7ý£·?º…i—&Š°MNkƒ2"á<�ÉOg4¯‘â.NI´‘PBÁ¢à°Øþ$æxÇ ÀÄIÝ<½‰\_[ž<fŸ#X;W·°òØaXzQ•üò´_3ãÞåcQÙXómÑŠƒ4¦Py­{;àHöP´"S¿M,½C!†ñÓ>ØiA›„c8Ìo|Ú£;µûÃÔ”ß`†,Ÿ1¬Ô�™Áy— ¶p=ÿuæ~˜•ñ]6̬0•¨î_þ�ø±´žl"4aå‰ zŠ6+7,ç›rÿ槛”'•N²VJz…¶æ±âdpg¾QKuBt+qNáèx0lóݹ¿»;cõž+Ì`£;ãÉzyh;±¤.ƒ5è†H,ÿ£OyÝ‘þé?™~¢Ë”bHiQˆÌF­ÿÔ×Áοñ‘¯â”e¼ºk°g\ôÍa{ZüyãÊ®YÿäÙ¬HN žð@믚WœŽê2®Kωc=¹ôrÏÊ…mÛL_3SáÅMá^Uû~ÂÑGŽ$&s2R|ª…J;{o½üê„ÂW`E£eB­°LèèUñ,²8I*±OkþMÓ«ÖX)¯VTwÊ~G¾ê*6.ˆæVÀvöª§,Aëwª1©a)4SWe§¶†øµ®î5ýù“Ñ,´ G× p½5Vçm»£º7žÿõ4“h1/SG[¨Q»<z·ëÈVšúû-­áá ]½{¿RØšÅÐPÌ¥ÇM**…vÚµu/ c¦xÚÊðö¥þzÄñÑÂòE;‘³5wBËræ[àÁdþ¿?ì åæoæI®é«�î ÑU³‹z9´Šf‹•U™íŠ�òƒHKš;ñ ÓÄèù†uÀX¾‹<”z›ŸFê¤L2oS2ÐMt7'%ÏÏ5œ0$ŒHÛ3ü_¾j–ËEªG˜ƒ6÷Üw0Aà•}¬ï6¤Ý®¤}óf¸\°äšÎw‘gi4á5Ü92ŸõIÜ°%4ZKË lȸsÝà-Œùˆ×gLÁÉVGT·oëIœ´õÿðþ/}°Ô”ÛÛM”µwößøh<éù.ד±/tc´Êúœ"š(…B/ú¢D“ Ò²leü•›M„Ó¨^ÃPgDøž­‚”jÁt Jv«É»5÷89\9ð`“úËSØL:œò/lé)"W¢~K»kPN@ßv!J¯ 8 7›"H?¤AÚî½,žÎ–UTØÀ¯v¶!åíCxóŠÎ¡Ž–Î¥äKŸ`,⃣FéÑ|$ÿªŽÌ7‰h»“¬ Ó“'«.$/-ñŸq”³¢°H¶¾¸Ì0‹è,W%O-ÚôE˜T.œð×�Òiꃌ¬.´.&5òˆ"NÐñµjc¾­¦,õŒÈ;Yc^d+‚c¤_J‡Ø05{‹Õqì7–Û·üÿ…U€OVkµú?%ªW ðÌ»ŸÑqÊ®+ûpÓ‰5jèÏz¦Qù0Ià†x—[}»„›ÿ"&)¹Ëj‹ßÝÝ©›º }€w5Ô^ôÅó­ê,Œ´¤„xQ“¶ô|GE&â±_Úñ…"KOê,ï5íØ$Ënÿ÷‹ç2ÀG#­7 Kª ÿ°‘DkÚdÌjjÑ¿µ‡Õ:wÖ5Z™|¥`Ò_o§ØUpâÊÝŒžï°ÓÛ1ºGküÿÓö'Û­2I0:¦®Â³3ùê_ôÍjl2 -k¯sÿ×qâ‰ÈÈLdI–wýgPö®W–!32š§)3Ï«‰ :Шøo=«,PЮöAòð}‘’_|‡–œ—ÎrOc_-zò\6ús/•žõ26‰òÌ:§ CM˜ÛVi çLëôßѶÝlO„3wç„Þ…öžE'v® 4Ë®Ùüå‰Ô†ÃIK€-¼Ê µŠ$ ×ö ?±ª¼Ÿ[aœŸia…ÏŒ…¯1RÛ4릣…Æü¸ø)ŠäÃÍõm¨¯¢°æèz Lé º^Š˜Û[*]‰?Š’Ò½FÛ¤lxûÇùž Ö“¿Àê(‰ËY`·® 8žTÆô ŠPÚi¬wãÌØC7‹FŽ™ÝߥrJç+ê\Qâ­…Ù1U Qgî_þŠp˜¾êµ°LsZï* Å„ÃúàÛî»Íl-/‡nýÍãY†Yb…ÍÄš?AòÞ«¡|f\¬èŸ(Ì YL벶2ðæjïöýÙDžG¥¾ûÚ#—«•¤Û¿ÈH]^Tö°­¿ áÒ-§úÔ î]×mXAŸ ,‹ŸQ½Uy£wùCéÖ—’É:z>­4tkhC]u�ö¸>zÆ%k€c`¼úÆ“íF–þÖŒã¢ü¬Ñ]‰P•Ç$Èíh––)¥W[g–JhÿááÇÜÛËœ¦ÏP,&K“ AŸáB`¼Ø& 6ñë?œÍÖ<e˜ù2©,"CCÔ[· ”É9ƒeuó²MráÙ&D2ÊÏ‹ m­p(šWÇ7zÖº.ǺçŽwõ _µÌÓ´Æ,.¦}„³:9å}I`­N™7±~5N²K§_ï´g¢<uCçHøyYÚuÉPúE†%Š‰+ýwª?ª‹Ÿ»ZC—¥”ä–OsõÎÉ÷qp8D×íù}ß'ŽÊÌ·�Oð§ŠN¡êQÆPòáÐ{½åFæå@£}㾇®]Î)3HªÃ ýöwåÿbˆ.ó}rxK»l¡0Â~›AwíX~@O8wÒ¥ê\›Ô™ñï-8UÆÝ–áwë–GmŠŠ-®¬Å1³ÿ²ÝVÍ[Ëüˆ“êרë¹Zܽúf&‡éª_[àöTÂMfÌ#ö³£_oYduz€5íh·7'Š¼ `Âí�OÝ@bYçõý:µÙ~ûÅ®^úÚ¨ô±tÞ”»ÙôšõC7Å<OsÛÿÍ¢<õ|oJcBOŒÙ§<jƒ±´FPÓ^"¨•™w23í ¯w߇v¨O-]ê?¦­ÿY{øˆ]Z´C„õ»‚(séüs¶g¡¡P‹cd;XwWwl)R/¯Ì\—áÓäå<Âhºu‡á¦©ð­Ç«ý&²½ˆuðjX<—ûzÞËäQ‡_9Ï»¼ÉpL‰9ý.+xÕÖ§ý r*©)0<µÈK•çëCì[îto‘¿¤b°¡bˆCe­H µ¹î%—�ç_˜½ åÕªwê0îRx]â†%¦ÅM5o7»Wú¿‹3øÍÊÌ#QK5Yñùié¿$‚€nŽ Em-Üî;¦ *ª••›lSÝÓµ®™aö.›A¢—Òÿ75yÐ{ÈÒÕQ1r²¨­n/Z¼ë¬åÍ‹@ÉÊSì—¥ÅÒVO,I²€}#òWVYì‰1ºÕQ’Y)TæüÁ?¦í]iC‹li”¬—¡N]=pÛçLCGFyc)GŠ Ÿ‰CùçÅCbìÆö¢àÎ;”!çèÊš8ÕTôŸÆM´w­ù£-ôt~xLg™…p g‚Nyiý”gÊ-ó~eín LÓå<í À¥¤œÓ|S×sr×°d"îBe«Åïµ»ÈI$)á}OÝ*”Àd÷™ý(ôb-smû‹Tòö”uƒwÒõÈ+p’ú<Ž×´; ¯Å z¦^ÔššŠH»Ä4ZY~zϲxÌŸÓÌws +û)QÝOαÕhE\QhòAl¯qùË[®ŒY#PãÚ 9œÁ-uØÿ{S‡Ô*~K­R_‡šcx”W5‰XG Oîn[ôvw½¾‚°Õ-w(ܟ¦Íü›â£RõKñð”´@Òkgr{ME.~‡ÙNYbZÇ¡aF/âHýi/ô“öã(]Ó˜¢÷0>{Åó cÍGM]ýÁI|'ÊI×�æøÚÖÒOÊX¯Á¼©ü”j/à>;GŠ¾³^³Nò6,]Ÿý¿èí•x‚�l(¦å/y]aÔA÷c3ÓY&Úù¹õÝ]»á¿Cý_:¨Jd‹ýæ< #FDé°g&Óå�æ³ýé6Ÿiבmz]<ÿlˆÔÕˆ„ÇûY —ûÇš§÷©úô ¸ËuÀȉ7¾Hö¬óV^ùø®¨ ÝA{»s0qVˆx£P´ôüÜä¸ùîïôì[“$~ I$²+ÑüåQÿM"±j =Ât—+\º+ËœU³÷ÛæôP6–Z³nÿfüéÌ°3SÀÜ(=_=/Dôqß÷úbeäÌÑe¡qP²V¶ëP ‡}Ũ²@ìÔÍÆB@3ÿ蹓ɀék@ÁÔ™ê3èÐpkÕú¶(áÉ•Î_<©k“_,0ì½8qãC4AêãIèŽ3Äoع­¦Î‚”–¨ì­0z6¦Ñ|8Íÿ'ŠÊØ7RßÛE¡äÝ—€%ý¾xi¼A(êx„gþOòÖk(¶ÅëâÏ(Y‘`O!}Òꢀ݅éJ‚?§©À^¸¾‘Æb¥ë¦¥ð[ýet1Ùq©QQÈÏ3= á‚¿ ùZD©,#‘@Hº–îj•¯B O ´ïæý¿ƒ×¬ŽºôQi)_1²w+ÈZ²7 ¤Î»ã±žßÚërt&•êËsrZ•Nþ¤@MÙA«½ÚN>|¸Çq¦ l?¶m73ðÏ^‘i–×­à”Kic#lÕÌ…ªÁ“Ëý¨—=×|:oúOÕ,»S]þ@à³u*(t€yNY(fz°Ì,?EãDñʧ9,Å?!™4‹Ãß°ÔçÁ?È^3PÈœº·«.ò ´Ôô‡$‹üÄýET¦Y¸rš¡àÒ­·,ŽÐTh—Á©SŠÉ佫•·E:&†©½ù“ÕÙY“™®&]ÖÀñG~pQYƒ6ñpÜìsÊðöW˜‰_·µø“:áV¾w²vü¶|Ž©ìåâ}ì¸\œ¨L»ÀçÇ(`Ó¶7 õ {œ»Ý]¿Ïy wÖDœ/Iu=ƒ¹QÇENÞ Çק3þ«<à¾é2 3Ÿ¾·àr—Dž‚Ulz9ËdÞ“×*=´ƒÎ\îƒ0ÓÒ»„²êçºIéôÞ3†Öö ”H-„32n;Á ëÙ4)^¤º[iÛH 1¨¢vƒÊAPü­!j¤Ù“Ά¾_|“‡)ͼíèɧï½'ŒÞœ¿lg³¯9Øuƒè¨Øtï;cÃ=YJØç+-£ø³·~cô!¯›š­ÝMía¶"%Ø—ël¾Òm¾ÑgM‘GÓá3è}–Á¥A0ïÇþ(Y˜ 0%½Þ¡ùmeI>þ…„—Vª0œøøíàô¤mŠÞ˜>€Ë2«g˜MK¸³~¹mÎ$yâ78ìÊx&CŠIh߬6ȳi¶U3ÑHx·Å®U ÑØ´ƒ÷o©d9UÂ$Dmó€ ‹ÂϹÑò›ó‚x‹ ~Wº¬Ì¥:©Ì±€÷ŒTœâ¾r\ßÉ4íªÄ¼ñ çõÔxH³ ¥–¬Ÿ«n{‡Øu£åú$ð처¨ÓÌtÌ…µe€@Ÿl¡O ¯/n€ cBÍiD½þM¸¤ÌVjýô\èOŠúÅèÇÄIòöß·4)„ùš\ã¿„G%ØZâdÌý&« šÛv¨†§%=‹9…¹¸ÃœÉ“l=ï>I¤­â –ó²áÐpÿ@O@„Ë®ô ~˜ax/Ä[ BEPî?=M™m$ÚÈ¢úN²´ž.T·¬U "¸±Ên7dA6èè¶�‘wô©'ZK?.©WPáTqÅŸV ¨ô©YéÕÇý> )Œò&|Êϳ;ÍXI‡ã"t~ãå{Nߪ]˜e·óFC¦rî¾ôlaÆ­.,ÆYJïÀ• Ââî¹`:ÏÛzé9À BÛ”?“®ª¡û„í`±O’aëéÿR],Ê÷Ú„[7B^Ý'qáÑÙ\JϳNÌRáw£d¡œA¿NÙóx¥”D¿rˆÃd毰›è±Ìtå½4³ŒU­U*:/0Ì*‹ÅÅ)²©kÙ .ž|á?‡î wn:ÚÜü�E™‡v`-=Ý"(¬o.r‘Ót8",ò‰!~¿/<à,Zá(¸aFëÆzÀAð°nšqQíQʯ›«¾ÌçJ&H ÿ½õ4ûœ(Þ9”Ñn4ò}ÃŽµƒ¶YþIŸ(ËœM TËgÌŠÒ±í¦Ÿê¶¦…jRÑqú<×Wÿµq/n܉ÛÚ´>Êé¯'B�«‹ÌFÊÀ$â8d]ÜGfÅy”ù”h*ºæ LÐ곧oÿˆ“§o­óóeo2Â}\1 (›³7«¤7ž$„žá·r x¦‹Â4ÍAšñÑúfujmš8àÏ¥°�N`Ew¶ÀÎœxšŸ#J ¶ûþ<¼QS<œ�t¬³Ô”ÎIKSQþ™ÔEêôø„šT^ŽÏ'œ˜vMûJ'%Òh|f[šÄõ!ç e×¬é £6®¤¶†÷Ö×nuä ú¨ÓƱƒ–˜ë²f%²¯AðÒЧÿ£T8åžm8RS¬-.¹Ÿ5]:Ýh_š» ŸW“Zû7$ËÒÔ³ƒ£ôêjå~ïfQÓØÀÁ´Ðä¡Ÿ%÷¹Á@·Ÿ.Cß 5è�'0«ÕÎçëÜáÜw§¨³0>¨õÕŒ[ò8ô¨ œ`ÑiQØcó§ñ* sÇ®ð¿w¹YRy¹2"ÁÛ—Aµ¨~1¦�ç£Ù•ªW µõwOÈI¤8ËÜtsÙ0Tˆ ZYãÁàiq[6=‹ò¾ìšZn¨ÔŠxÄtã/½05{ʯöXízQ üù¹ÆÉ(û<œT–Kzªá®*ëò5¶X\o4Kt6èKñ5h{•(Çáo§üª §´ÓyGŸ|½q4mm…@õ¨Á{Î^;%¾Öq€2ÚI]ó~¹âãÄ);E<Áä^}øeuBø‰ÁÁl5¿÷æ/샛}¾*Ìèä˜ö°Z;9CÍen¾ÏÅiÔë›ñd 'zJâ[ý`ŒoTh=Ÿî=G6‰…ï ÿ'Ãù]˹ ý–ZùVÚÈË…‚{Üo•Ÿ¿fŠ²q¤¶8õõµ#׊{Ç¢f‘Ó¤…ö9y:EC½ÝÊÒä we+ïüì›îZVúN’ˆRòÙ³•ü‰0ë=Éá¦C 7Tû )W4À[wù0Îæ™ç³A¥"¾–GØí}M ›6¼×n›ß\7‹•â6Ì绂¶Ýdg580‘jwrßA·6¨&Ó!ÖºÀLukˆ:,g=yTŸ–Üw.A„ØKsÑÜžåJ›š¥¥o”„YC …rç6‘ùIÄë"+¶LÎ ¨¥¡{QÙÆ;ãQ©¾cp¥Ég¿ k?TØV3Ì¥û¾PJɧìî¡>/‡M­æK"g£¶Z¶SqéŒØx;ò§6/”ú{‘–Ï,(ß5²b;–žùû·çéoçæд侸=|“Žû¸»ˆw{“wo MñæÔb…ÄØ{ÊìO5ÚsºÎà»áŽË\{ã)ÑNf©“GÛÎi;s"%ž;z×lQ’B §ËxºúXy¦ôæ89oÅc„@M‰‘¢³¥,TÇé¡^¿KV…ïAÁú¨Ô:o±ïš¶³£¦ç¾ØCìOÜK¦€Å·ÿòþø#dfŽ·x櫺‹©;@Q“£žý¡ƒ1zL|i{r“ªÞ{‚´ì-¡KöYo*úO‘ežÏ&=©º/ƒüݦYl؉o¹ý|û†žÃ“=4ɱjafúÝW’i£f°ebl¼ULöÎQtÝWßH-¾Šg‘cû•ŒÝSÈ \â—°ý<²Â2.ö½Í!ø ÏO#·á31s¢¸Ó6†Õè O¦†ò„uµGóüGlìz,êåÝ-.ëZ†bнýQ¡,¶‚÷ãâ]¡òb©èY/ñ°-…X– ÖlÏ^¶o(IÎóø©!y´R(§…OfÕDP}mU`çjêuœ¼õ…âJ“øu¤žw–½Xg#Œr?naNëÅå À«Å§ÖÛû¶¹ÏwõxžùŸß÷gWVòVzæ*ˆßÕ¡g®û#"ÔͨŠ¬Á¥ý'u3¢ê]16fƒ¾¡}ô½CV HðŒ¹`KMCÖÛ”ƒÏúœ¾ ú -Å"oÔa¯yP4Ú'笵^�åSFá,–Nðnßìõ÷ªÀ{ߥ2þ¶§™”ã´¨Œà̦’4"ôèÕðÅ©ŒýM2°sà1)~`¾¥¾wXs ³‹±H}>έ،Ü|}äJy µØ…çfW«âþP{þð7š—¿˜ kX`qT ´€g”ÁjŒÍ}ëIÓ`ÔÆÇCä{ú¢=ôÙy qn<lðãE‡§Sˆ$wó¾“/š2`õžÆ¾3ƒX 0ù¥¨,gÊ–Np©éÈékOó›JŽÅµÛ«å·t—wýüS_2Š&/ƒðdùy ÚîkËÄ’-UÇüYõõaóÔ™—IŠŒ}p=+ëi;]‡ à%Û¾]ß ñ—sÛÒÏ€liGš^£w©OÑê§ £ˆí¾J ¬9 ºÔp–°þËGRf~±±‡Ýò_Õ#6½1ƒ~w¦òÞ%@ßó8¼ðO?6b*¦ÄN„&N¿jê]‡Â¨Œˆ.Á«~®QâÙö<íª ë&óÆÞ=ÑVí©;ØWH{V,å$÷ùè8úÇÂFC' Lþä9¥©Ô ÌåfEþè‹ñ³;JËN íØÌëøZ:™vM7—nããq™ˆrg%–-Çy¤ò ìn<ÑB6–çki¾ÊGø|´:~¢öèZ-µ¼„\ÔFj[ß0¸ö<€=dµ^PI¬¼:¨ÌHIÂ^²™™¦w}·˜ÎÇÁƒû9þg|€ÿJW¢hÀî%åhŸÎϪëë¦óU$Ĺ÷mªçΠ՘Ý]¿ù*Gî\�eãªÒzÍØ–‘Æ ´í.™”è°1L5ŒYð}^i¤BÊ|j³üÕW„Øåýk?1PìT§®=Ü·Ëν²…›ßÝ@dòɆ:#:K _Øb†’¶Õ5Jñd»-NòÜi±ç2ß,ƒêKGUHï©æ;L»ñ2˜È…{ êþ^H”TQ¡ãlN.æ9 V¿bkX+Éd Ó¸ÙCÛ QyÛp󪯳 Zm�&�~·ûW1„…åak†zõ�’íûùM'>ó6©·ÌÒZ ²�ü’ƒê{WfQ}–¨ò¼,8ÅŸàʼìÍù°í¿k 7ý¶E3ù ýY|‚üPI[áÒÐÛa!}Y,‡pã³ÊGâøò¾,L! õJlк«Cd°Ž`–pZ|ïÊ3±MŒð¶Dˆý¾àcªS_XgYMW[KˆÖ‰|L±�[?Ò*÷ÝPbп©|ø|w"G¼ùá¹Âc ­’¿—DE‘y£*eJÙëÜ$�²m=[|Œ<’ZX“táöAùU\+™ç¾ûZ@i°Õ+ý�uåOL]uYL“Ê›c¤Mcá\óêÿÞ’ÂsO(Wêe|£°3mEÞusÄHÌtýµ+ÜÊ€nEüU0ăAÞ¼Þ¹÷áOIÓ#9¿».Èf_Ÿ¨*7¤Ãpz‚çÉB7zd»ƒ`>a©¨Æ-­‘˜o4;˜÷õvé„`z67T¯1ÇnÃÁf›'\?;Ì3&4Ríq •®æ+fͪ¦±ëýÜ!¾ûSï·T6C:½ùô¸ÞÚ9ˆh y†Ê‚쥻—·‹*v ²J,pÒ TÓD—§µ‚Îm?Àþ“ÑÑà§qïÅF=hCΫ ݧAzUz­¤¿â÷†ËûaØ·ˆŸü5Iú9"=#”@+K˜¡CŸ"¿4½øÀà™,¤å¢ÒzïJ9EæÃHѵcý¼F…rã@f,Hg·ök92Ñ€�Ø>g¸PÀo•œ[˜;ß Ú.—ëÐÞ(=Ï«<“#È£B.¶KÏÒót:{=zæöÐû¬=·îÂf‡…‘~iXáÊœ²ÏNé¼ê꾞ú§qéû—D•ÀŽ³V ̸¾à|l¼Ò;/±úÁ¹ÏÛ½'5Éø^5Íý‘lïø:¼ŸX‹€nñ—*ÑΧúcœóÏø#{R?]Úc1s7eÅŒ©â‹¢šõ©×XG’dÈžóf/uÄíëÕæŠÔ±ÈÝ| OA[‚2T7>5k—ø­•.jÍ:*÷gËí±˜ÕŒ1ÇÚî¾!ÒƒNgV¶¸*`È)]ÿzP…q³ÐyYã4•cßß»ÒUóíŒÇt0 ŠÏƒ ÍÚ«’-~›ì[‡^ ùš=ŸÛkTVB á©špltýOSŸb¥_Ë°ú–µÎ·Ù4×(°¸ÑßúV?yž“n¸@QÐmhO&ÝŬD}Šf Ã27/jÆÞÛ£ý–0ܪj¾|?M6¢áÌúnõœÇ]f:±ç¾ôœÅigðaŒ:©¥ÙnÒ÷W‚yôŸ8]{»ÇÁ©¯XjÁ×õž”±NÑ¿3•Î«$+Lñl½ ŠÞfñ”Æk_ì÷jU‘ù‚v³&‚l¯ͽRÞ„n%e$×¾kÆ¡ûe»(t®‡’`_IP¶ŠQÍb$ú=‹_(QĶp ˜´ã'’Cæ„ÖЬ„M'8•õà™í0#i‚˜uÌËù£czî/À™m@ó°%‚´ ­×I“Û¼\Y§ºJ@hƒän<Ú»*¢^¡àé`9¬’´Ñ¦&“Þpÿò‰V\Qú’1P¥ÿƒQö û­Ô¤tÏgcXÃp8m¢Vz Ì =8‚،쒠j}×R*z&cFgƒÜ¡ÿÉœ3­¼Üj×ô«)¿ ­xtÅ~ßûq§ ÷Ð ¤ÞI)&û_ iB.o‰Ó”rŸóà5è·#Ï6ß–ƒé½pHRyZUÙ_9•ßý¡ÿ¤c£fxê³ 9+ä±ÄH‡Î–¶s@€Œ"ñJƒê'Úv‹…õ1çcª5î»#•dôUÔ¬) ¢é|ü>DÏË(sð$8⎀;·ÞPêd�?Öý ´¨¡}@­X±,¢´È<ÕtØfí(÷œ.¦¤€àÖaÀ1ma¨;6˜mö©`À„ê$¾MÓÈë;h>NÃØ£•Sòƒ)±R¹qâNãƒB¢žUA‘Âð®*Ä£èøŠ- £¤öL›×(V/oC7.ó X°(^9P2²§åÒ«æff™M7]s^ ´ˆ8ê?Ã$‰¯áñgLäÓ“ ð!2Ó’!§£±‰w×Ò –ÏfÞYnËNvÌh`ΖLËäãCÁžÃ:g¨r`AÜ›ï“wƒ—Øë´_¼)Õ;uiPœ¿lÆšIá5… ûÖýñã£ÿä©ïCBGÉÐQøM:•NhÅ<ÆôSºc'æ6Zúo¯Qâ[ŠQŽ|š@ UWœ¶[ï,^¥’féUžMÚ¹ö½¦›³\Ì ¡`óCå½õüd—–`úÌ}@î}X®?RN˜oöE|oO8†:%qæ1ÄWÇ«oýö(+|ö Ïž˜•úéµe6c?;CéÛñÓïøŠYî)~WBÁ,‚¢Q>.+Û7ðZ0 Þ):63 ¿´íŽö¾ôMe#œä¡¯qM¸-i¹Ye-,iD»?€°Ùd:·˜wÕ”ßaŸ?ºtó£Xbì•q£O–²çqæ ãSg,léyÑyIÛñÅÉ—B5£Ø´&ÚTÌ/ÓMÉ*3.ªý˜ò õÚùUF´r¹P½Ð[CH°Ú’‚Xa¥ÝCÝ\/¾ç]VGOÔÓ’`©!o¾»¹÷[°.ɬ¥"1Êv$ïDnÿ…‰a‘9^:d0a‰yÚ{±g~nÜù§ƒa6‹éGžƒ› gÇ�å÷¼·rÍ\^kþ'Õ÷ÄËq ~G:¶¯ÈF ż8‘þ¢÷\zU_Éb—l£DÉ "¿­—?(6îçkÇšðþ ÞY‡]„ídê(€†ëA8°j.K÷ˆ§/¢éó$+µ [©0ëê¨4»h‹,m—[ÎüŸäº’ÊïžÀÙªïÑgë˽(ö[Ê7ñ Ãàæ;_}?J2ÃÃÈÌŒkØÁÔø|12 õµÝÏ(¥%¿§\e€€Š×)w箉DôŸ"õn +ß'9+½Ùi˶§¾Þïrm0Úmk_aÆç(S,÷sìh“ä_® å¹ðØMÊÓ4héÕ•|ÔIç,íi  õ)ÁfŸ¦AÔèL "<AÖƒ¶¯1ÒvwŒFãÄk0&g†¬™51ô›í¼‡¦Â¦äùö̉¸Á&„¿<²#0çc"„”sEÝÉÖ¸T„&Ò>w­|hb™«ÈdaŠ»Ý9-X ¶ ‡ù LÓ¹qã]½ÒxK"–F•Ñü£o³7û5bô©§Ý±ÅZŸgqeºÙ©«?¼«US;W­=…ŸÎׄí­FÀ ͦ?l·* 1ïá#8©{—¼®j±é^!3m 'j˜í½ø¼7âj8Xh=Š1úFôQÑ¢³¯÷ÌÕ‘£0m™¸c^;¡þOØWh5`¨’a§=3y¿«q[Á,A œÊ^ßH.¹$¤yεQÄú' ð0ô9QJÁƒØ’ÒË:XéhLp¡ÔlÚ_Qâ ý£¼ÛêÆOºGÎúN— Ä6kæ^D Ù爯fÝ& ?½r¥pbìèe(\BÀ&¢ËÞDÖ”å¡ñ_¸é×Ï6QîÄ»•¤Pœõ“…÷óö7M=‹vC‘xšW×kõÌ83âyÆ{ �µ”=¦D Â,Åô“–'îЂ@v0Ÿâ üTÀêè=/ÓÞúèZÌñÝ+¿eU–ŸÉïNG"[˧küÐMÁØ•�¯Mü’Ä­‹Š%ê*Hÿ¾sQÍ À"tTœ‰”ýÿCÉH¤ÓêR¯Ö@îió³LÁÐåày\=68³õ 0»ïNPÇeìשc W¾úí¤€CHOþqûð³Ó‡e‹®?Ôf¹]ºv0Óoïò!èÓéЈ©sJë¨ô Ý·›™» Ï°OëÙ›š¹UÆèŽe†=övÖO õ­qÚwƒíÂÿ¨ÓpG¸!ök¬¶&*@X„äùÝÒR b<”�ÿ¥„¦SÄäÊÄñƒdóQ……Æ¥«taƒôsºsìô;ùüÂg¸—'¡Ü'…GʵÓý§§­0Ñʤ"ÄL^ÅË©÷FO}sÒØ«�$ÅÔ( Šw§6)òëö¶ŒP¿¸7ÉYcBhAÒö\´ÃÝf:ÏukY�4×î)‘‡HÍø|ù„CÄîËÅñ=Z©_Ö`2‰ª¨”³¶F°t‡j�;KOUq‚hæ{E…æ5À¾þËÒm×ÕÓcë,¯ÐA§4˜ŽôäVH=f^þøÑMWJÔ×Ù|E«v‹îÂÀ–ÿCÿ9’ìjÑÎ1Žèé|²F Þ�èc/,r´ U‘ïÅ Â @±åp2Màg£"¡é41ê¿{hë|oVqèÍgéQ¾¿›77š?Þäô÷ˆáØcAqì^†„nk£mm*Sðîša¿ý÷-1m Z=âµbrÿÏ[ßäæ•Ó²§øË9Ù9³ï\¡—^÷´sªöìÉ”°P.ºÜ% ýDHóX‹¬eM{H•E¼0­ÜÅ¥¹eÃüŽÈh  ì]>Ó ¨Ë ©Áº …èH§š¶ «oßDíhA¼ªˆåPÚ3ù$òú¼œv„ñŠR^¸Î·Hº¡d•²Èšôõe‚0µ…3H:<Š¸äÝÒ"òåwa¼I«go©/0ËdÇs{_¬ÆÙ­×AòÓ«Çd±9L›s_O÷žàcX]•ù{‹U•#,}e[íõgõ„O^œIbíæÙîk:„þ*‘2”ne§t·Ý.J/ŽDwñ(J&™×Ôã¿êȼÝýÖ’ëy;Ñßå^Ÿ¥vùÊÕƒR~:1èþt“߉>O"t,]ãóæc[£$5‚Š¿w^¤™×3ˆÅTbzÒª˜M…^›b€ diþW.;N¾œú_ècË‘Y Œ�ÍÔ¦¡§¥¬L„ÇuÄ·‚"š  ¡ÿp;˜gú~>m»¶Ô5ê#ƒ€Ü û'ÕÿÄ;¥¸Up¡ffÕ¿c À!GÄó „Y·ðt®žk^åY–y’Q[Û‡|X÷ÊDkdAÉÁR›Áõsˆv­ä¹!ZXq«²ÖeÅïÍéòÝí[s‹é;þÇÃIÈìæº+Å×—ö"cè*MƒQ£…½Ùôõoõ¾ñ`ÙÅJ f_¤‹%§£©<ÉüÙ* u'ŸôÄSIÏ ô!³vçú$›q<¡Wh›/B²SÉ8lÝw‹8Ë™­g´ZLKoáôB¾>H§¾wv†ÝÈ8àç4b³Ý€c;zŒ›zðûœ /KèN§3Ê}??*ø›†Ê£VcjÒQ‡°ï¡ÊÂ_ïùn;haf´áNTn%¦éK hnpõÊG§?óÆyî´c“Ï(5„ã¹+¨V±éJœ‰³¨Ö•øgÅÕ*rž›lÿ~©³ Ù^Ü0žf³çÉd6õðÁS«ÄsÿÒSv‰X ‘V Àa3ë =wâ`ÿ�.È<·cN‚X=Nvêr“çÿN=N"Ëóä&ø©K 7¥ ®Uêh´Æçi¼poÖp™n¾}UÏ™™‹3©*ê'¯Ð�Y±›XRÛØWY ÕÏlª4qgjbdÒ#v/rÒˆˆ± w×*¬yžþ0ø¼±l+Æu»ŒJx;ê…{SOñdÖÙü ²WÓˆ`×µ½èܺ\gIéc¼CÖñÈ‚ê]QÁl’N9&e§C¿›0ØEwW:|Œ¸+[óTþÝ¡Ö^9ú¼{†·;z;Èâ-´t° ¥Ü Cp¸û³Ë•ž“ ¤ß›ŽelMc„ ÂuYo†»±Ç,±þkt‡¹ss¹n Gè«s™wBqæ…j¸¢¶ÜÖܪfRñë,“c!±ògÇdËjWò ÌYâÆÒ-�£áîÔ×Y¾´¤¥;w™¸t™(b9L �.×–E'j7|¡õkÙÑB¾¦Ú%AbãTÊT.[^Zœæ*YXXñ‡n|ß-÷T®¢õ„'-žrÞ™´ u8ÇnF!äù7oåàUMËN‹¤ŸM’³Ž¥ÖFY è†ÎwU~Ùsre­&6¥µŽ’a¬ÌUwS_U¤˜F¤þ|,ß¹ºãÊ),*7‰LYFÚÚ,C0Bô8a8?ä 5üÍŸ$²Sç,švçaè|Š0 G}§ú‘,WTdqæ}Ôˆùõq³óÌ'šnBÿ@mÏvh~çr'2¯&ÐBÂîê } ¤Ú<–ËÕ 0ŸùÛF…Ǩe-+,Åb¯˜(°ßv&kkiþ" <ª< R®Øvg6<SF3`÷s½jy£ï]I /ÞÀ.Ÿ— mÚ”xÓç®ßÏBô"¤t¥“ð´jÔþвÍU{…m¬Â*˜‹,È“.yŒï¶a$Á­†«¿Ÿ%È1óTÖ*öCÞQh), qý†!OG³ñSlƆ o#øʶ\™|ù=Á¦µ(;Ëq”Q­¹Ì¿éQ{6–ÂBÙ\è,~W…N4¼YŽIê-C¤ZôÒ9ëÄŒ›ï¼©@,Ò4QÐU šŒ!›@br`TÕDТs&­’T®Èëw~ ÒoÁDû"²š ý?%:%ìœê¶E3—££‰a·ƒ“¸ò½Yá¤Rw<Â=‹ò ʳÍSŸ±~È>p µ>)®=½õ܉,³UîØS™qVÐz‘pU«Hמ ÍË}Oq£Ç·Ù§T­|¾{z|hØE`Ýý>ŒL†wyG‘¤Î„$Á>œ’$ˆçFA°­À¶´4šY‚å MÝ®=žqè|ûd-åR¦`6ŵOí õXXê’P®(¬ooäz¹ÛhU_í@f¾;e ¥õVmbfPõ‚)$ÁŽ¢!ê]®í¥‰ñ¸ ™�ÁÉÀYgû¨©>ºVù:¥~î/à ?!ðZ‘Ø·Æ£²žjqÖ1¬ù$í=ã$”õh(æárÿn?~l&ä‘£í³¾Søéê¡È°½=½CvÜeÉÜãWŒÞÓD ‘ùvB´ >¶^-ÈvºJíûÍ‚óù_“¤ž¢µtÐëgU7ÔftTJk§ö=WÉÔ³þb29“‡µìnR\i ɃVr}•ÏhOQÝ q–džýÕÉÛkIAk¤'(WÒ2S¥Z9ÒNÝÇ¡Æ ÎÕ G¢[ ëší•Vòº)bÆË7ªsWnª³ÙÃ<ÐÔéœégþÑ1×P0t„†S¤ËޛПÆÓé*ªð\½õ&zÀ Ï|UŒ wô&¹Ù™ÅJIÓ1jù%pßú•ó¼,è Im Šú~èÇFÜÖ‚!ÒW_à%O-’KŒˆ—™–Zt>›Ò®`ûâzfênèÍxÚI¿ˆ‡÷/±7sÿp ¥7éÆ~i1OùQð~'S;ÒÚ0j"ò •én5²(%fQRäìg¨:t‹WÎA[Œ‘©f§üà½aÒ7‘h…ªUúÖkmL <9Y‹ç(iÞHÖ_tD~þ:ëeöÜymŸ¦™¿`JŽÎwqVç7SÝ £äšp=³5¨å—úài廀±0ºmg`ц¢?Ø¢ï»Iètöâ¡÷z–…+ÌF!Š…ÍV³ZpI™ýA±¤°„á©9“þR¬°2­€XZ Â"EE…3_ë|œukšË`„«úÓ4soT_½­FO1²Újuá[a@„Ø `â’ˆJ 7<Ág¸o‹g¾9ü+(-™·q‚<–™?B6Gë–ŸòkêÕ­﹧·•ÑNKvQjݵ›õ«DÅûtçÊWisèÿQÈj““"õ)vìfh7ç­ž¯» “ˆ1Šæd«ŠcJ¿â}ñÈ·˜Ìtʽý (=ó„,CÑSÔ:(ˆ8—ËÇ\èþÕ<ô$-b–#»”AüÞY®á\™ô)70aJ­Š‘}y,œÄ…µá0ÒLt÷PÛ°¯gi Ùtý<ÍŽsãtœ±\¸—;­oîÌ'ŒÓ¶^&(¥ŸÎ:;§šâ»Ð`çL¬gå„MÍ:Yº£7ß³ N½Þ›4#v瘞ÒקÓí®y~<@IL±®¿¡/6ÞUúHbí6sÎ…|hö F#ßž£ì—!+‘[]‰©è(–¦|lEªx™«üÀ 7ë…Zê.MfÆŒ˜z¸U- Kœý9g3 ÌÒ6ÐN­MŒÿw;[o&.5üá‘ÔI/Û…¾!EXO+!úbÞèã%g+ÃâœëŒÒ";oÁÐ�ÍPº_;V©„ÑO˜}¡ãgÄÍ«'© ¾ap9›(;rnDÜ“Û ªÊã¹çÉÐÊ_ÕzÐWRÆ e.kDTk`¥±RãÑ¡ì–…çÖ\ÝÖ•nt]SìiÐùtrÌ>”£±YÝv½¹É\?즃ùÔ »4ÈÝ×íQÚ ²ÂZ£g¯ß½9ó‰ àp E2Þ£Ï'ã½'"?QRÙ‚NˆX€>fŸJ0HKßbƒÍ¿°*ÿËÀÇ$ } Wbvx£A7]CE±JƒzR «šÿªbq”ež}ŒßF›&½òëv=EÂÍýøÿ{K3•ê�ì×—%ûÅoô¿+!LRÙ·÷´»?ÈX}‘_˜0'™OŒê lкªbñvp±¨c,Ó+?ô×qÉJ|< &ˆ‡O¥ÎÐNsbË‘ýÞ -ÿ/s¢( aƒµT6[“^ åsæÐý©íú¦?¥=l·_Ñ3÷ÌÙ¸¯û‚þ ‚µ`H+¥ùªö–itŒÑ„Lª Åø1Œ­M'KÏ÷î Iœ¦È7ßʘ妷Pf+t �BôûâOk= ÃÊ©þËNÚé ë¤ß]ÞkRFY|#³Ç$ šß®ç8Œ×€U¨ˆˆFÑòŸ¸'YéŸÌu†‰þ¦Ì¶Þëùˆ¾†•$õ)}[„þ5g‡¶ì g'¶c¯ÜÐÌ&8Hä]ëj|t¢fاA„ÊW—ëâ,÷MÜŒ$IÑje9:„ç“á€Êú} Åœ”±‹Ël¢=~Ñ6NúHXqéË1h¨ªiU ŒbïÄ£Žµ„(wMsæ«6T_¦Sïeò[À<™O†Æ‹FÕÆ9zzÈóTSïŽ?ü'8úþQQC±£Qb¨J3œþ³!öìêí>ü„Ë '冯.-Üé¤ïéäv} ¨ÒçÍï¹Ô¢XvûúÝ�# ×ÚÔ}GÇøWã ö/ pp¤ØC# ÇVÝ»0þ­ïQÅ+~oôg zKëéŠ!uýq–  ¿9ÿý[s;óæR³®4TnU|SfF 5}Í_ôƒ÷IÝ3èÆD¤-÷l&f°•‡y¹/£çx”MÕf 5m[ÓÇóú©§›`àpûú Qáç—§$:Âó‘÷@ˆš>½$tšOç=ÓÌgq0—{¤ŒÌWWŘÑô}pB*¦³EÇNÝšþЯ®Ç®õ²?nP›‘›†ÁȨj}ÔÀ 'ÛÓ³¦Eß.8éÃ8•ã¤í &«œþêË{’WQRĈ÷€qì;@PÓÿz÷FU²rŒ)UAr±Ø"(+Í®{ÊSóõ'Ñ©*[Åö0h)à¤_³*G&ld@yªm¶cϼ¡žE|w {N'(c2è¹î€„›=4ò¸Ê”r'ßÊÓQ²|ÕîJÜ ôá.Yó?bãV09[I2 öÌEÄÒ¨†ÏfS·™pØ`÷3ç‰%~}x¤ñ¼‚J£a¢ó lU<Ä"ŸÍ)<ó¼J íw¿ÊbŽ ç:%D ð…8o,ÃEpÛصÇÑ×›ozk"誻ʥ® ÈÐAOW%÷õÀƬ0ˆó|£0³ÿdžÓ«&u/×¥Q¸†q-·ûÉAywexˆ’ZÞútÞøuÆ–<Á�pU Ëföüt•dôXTÊF'´èÿÑr8¶§–Èf'Pè¥ex¹ºFèÒQÔḄ…vE‚÷qºýöwz½Qæ!€˜–‚&§Ú£uìº ,\ã<ÃKþM¯3$“Ù\¦1Ù¤‘h‹uzõÂ�&)ÊX£«n.T«M³Çš¥û,YÅTÈN1¢B¶ê#/œÌ“Œæîvßçè‘Öž›*•´:’ë¯<Û·j|_ˆmôíú+T,agOÉIgÑ tÔÇ“W?b>ºFýâ„ms>g¶��÷Ù©ÌX†SÚž¥¤ŸƒC7ú×—ú£Sš×·¹’çù :šb”5œ]‡’ç³7ôÆ-RDôîë/`ò°ûå„&‹Ý}!FÛ•Ã�D`KDoO‚Ú—ÜûŠ¸v#»¤ ¿Dc6´…‹çY«‰„µ?WÕ…ý¸ªÓÍÌÉÌþûÁÓÈ)•ú˜˜U-H÷zê5ý¼ci9xbqðjÄ–Âœ™N›¬#í}žá[,~¼Š\} aUÞ¿�ípðïó ²ð—Š5êX1 ä´¢€F\{fÜÏúÅ‹Öf¸iˆÅ¹ñ˜KL[bouK™~•Â•Eæ·‡iw¡…³_<§øc}õvב~ƒ z_©¾´ûFF³”.•¡0n‰­v¤Ç½ï¤W÷Ó%Šb'ZÆYó®‡>Å©·UÒQ½èLOv_mäÏOç‘Ž5Æâ;”à"b¾+&¯1¸ñ[ƒØ«ZŠðŽˆ@¥'’s#N yç; ó|SËtªMä‹„ç;§cûU)Ôna ƒÆYb2Ï,`)ö7ž0qêõ®Sv¥Û}i½Îâ/ƒ//õ³ðV¬º†[h5ž›2ˆ}ž_j &ozþ2Y×Ó¹#5VŽseðóœ!ò“ùÚÿ1ð¨sÈU»–î+Ä s÷9Ãl¶ºU:JŒ2Œe¹N ˜Äš\yr¨ò£8{d;Q5/¤ŠY€£k³¨¶¬ ­{L]œ±@UuÒßÃæ`ðˆ5¡TåÊ1y¯§?µWî7}Ý\ï0EµsªUPBo½¨â+Ðâ(dÑNþè¬ë‹(vþÌO·¼“ДW‡EÙzç­»æ¬DË”d£ <ë· iøžÎÌú¤:X  ±0¡¬Ž¦ã%í…F,Q¾WbY¸"å–Áå¼¾tÎMëFts›¤@Á¿C÷ÜÍw7Qµrd\ãM�çȨÙ[BJm§«?YË"†úF/t¸þR¥¯wNÍ•Xš ¶tjZ=3Ä%`䕘'Õ‡˜ªKÃû»'¯cD+øúR—¬ ìÓ–2,ZÚú¼ Q¢/{.ÈôÅ:Õ{í«=F~µÖP®¿öq,¢}4Ðò5/ZœqTTylÀ(‘`BïNõýO°_9¸ÉCææó¶m¿íúØT'–ålåŠ!ŽS íæ½'ÁìÌ„—îòaäZî_Þ9Çb0‰} Ö ÝžÎN€sˆB,¨åx’Ûô"ƒ5ñ…hé­ûsÂÝ$K¦íqT-•Ç–K•7­`ÍÍBUN~VrV…»åâÑ@Ê|A±¬åhZ:¤4£(ØdÍa”’È£M³´Ú+k•'ÕÏS›¦¥·;Y«£L)™)ûBº˜ÙÊA9§H–aÝzn×[øµ‹ê§ˆ9ﱦ�‡dA=S+ò†Æ"ñogXÓ³0²½¸‘‡ò>¬tI 8`äëÜÊè†Nµö"÷<špÉïiJRzf¦,œþ7tká^Iç@øÏ–n%.ž7ß>jy–¡o(‚èp¦úÑúIU¥Øž;µ¨ÿü`«0=QD¼uйxÌÈÝñaÑFX-�#¼ âšDQÆVm1«ë.„•ÿýTôŸ\óžùfY΋½²°ê=æm×µÓ_¨GKf„ȽKÆFË-Ô˜kÐ;q)﮾wœ*zLô:Æ%î0Ö€kJBéÏqï;(§šäÆ‘Šv1¥3µ•ê±N:cý!'… þlt‘ú²“�ÐRÑÁyÌ}Ì£>Ü¡-Ù@ ý~ñ¯éë°—¨Œ6[0êkeÐSÞÏíÇÁ2±Ï”ãÈ×ئG´ùC÷wgSýTpuò°Æ«»ø>4 ]"ÎÊÍ¢§ó99/V:¶Í˜Ú|¾×«Î<ZÙ¦QDžv´,JÛ>cîpǃK?ëúˆð/ûqüàÞøg¾F?mÆòMWš ˆºº¾ë'Q;»Iý©æŒƒ¢Ýº½Ýк·4Ë ;¹ÿ—A.ÿí¸Aü°àŒL'ZL` ÜqÑｩ°é“«²Ý¡å^Â¥n™„´èxÂ#f¬8‘Æãd`3BTDyui¹F¥óßßtÓŽ«Íçºλ¥4JeóH·?­íÁí§3ƒ¾4ê]v,sÿrõl-eI \" 3œ=VûLuCëææÏ„a’“¦#à bhÓ¸"ß�Ó>®Nþ熕B{FÆwj‹Üñ)ëRm!û7{R©æŒ’e;°KÒÉ9™:Šú‚ƒ8Î<ÞŽ YñN‡ï¥Š‰õÙcá°Êƒ6r×^øûïžr¥—xÖ…/1÷­-§èÝVAÓ@¼ÜBÂc¥˜Å#5Åú†FÜã©ØÓŸ¢¢ð˜2¹Ì¯Qà·v0]ã8zªžAVòÜžN®=F7Oâyš×ì9'€H «N2`à¨ÉÿaˆÇ¢?ŽP„Ç»bÑÐ+™ S”«³úNät-Y×ìY¬­¿;5ó!d]³ êþz’ZËy8X~úÿžÅ}”!åb|<í¼dKÙ£¨çʾ})+/3ÿá„ìŒ;Y'0›1Êu>Þ01øÍdÎ/ø"Ä™ø"/­ù¤^†øäÜÿ´ø)õ1¤Ç¬×'!¨¤£òÓÓÒéNoMÉÖ•ÝÖy<ÉëÕ´0ô©ô®Èâ KÅ3¤¯?@¢ù‡_ÙªzÊ C}ÛžªáòÔ{³tÚ^Tf3 NöÈ^óAC“QÛùNÒÂGÃSu4œh™dg•§,xÆþG{ DúMÝ·:ãA†ÜŒõwÆYÁDdw¡ØN½ÝGY²ÃlQÇørÙøàŽÂN­ª$ÚZl8ŸÕe ©n_Ÿ'Z|Îr|˜UKœ¢Ðuþ…ñTä‰ò³FJXû6Ò÷Æ;1Ö€¦ª¢°,OPpÇ Þî»G’yº !–e„Í_—D‰[[Ï¿PóË’Ø' BJlžºŽH@QbIÍ‹o…ÈKT©2äø¥6Äb`ÞÖeáçA—ùzM1øÙÐõ´" ñ BPUO´+æ0!i¿‰l˜JÈ#Pš=òŒ¶ Qù“>TàÛœ2¡÷w7d‡ð<xKFÿ˜>#*îrü¾yÂê|0)i÷^Þëõm¤sß™?âÙBȪ̫e¡_ˆ*3i—&LûÃåm[OG—(l¦ó‘~£mû=.bÝXLÊÕ« ëô°C¸ïð£T—ÀëɺñgV ¡ˆ­!Ó ?]m³1·E±QŽê.â |óê ®%ì†od“ªªNÛ”à¡gôí«ÏËŒjÀ<3_T“E³KÃÃhéÓÕƒ5™iõÌ´'Ù,Ó\X£¤ÜYŒaÑ'€¬å§#"¾Õª’«{z¦ØÏÄsÝo©ýÈø¥ÛŸ¨Ró¼x†;[Ö)é Ãœ¡û7 úË~ºB§kX®ôwuGn„€¢ †öûΆ¿õ÷˜BU™÷W±víäYAO"¦cHƒY¬Ö…”ç_ÛAÁ]¯›Xg¦;"ny´­Ù9'«Ǹe´Åé…UÅ@P36_/æ8øvj¤.u¤ýÙvÞËÀˆÇ9ÙÓ3J2qáûIR-õô$x[Ï»8¨öµ .ŒÈñ๷ t€í¬î\}·„óN îV[j¨I[(÷õÔ1§…;±†æ·~¹3-KãÌŽ ´KÒ Øž\/rsEr§ˆÛ¹7Ìx{!™7Ô ðñƒ(tÒØŽlŽRåà n 5vž—Cg1±ì9‡Tð;qû™»„ ‹yìc>¤Ü-Tpì�:¥Ñ¹.?Éò÷ΧQ=Š¹§Ž åù‰ETCgÓ³Ž¼³qû_²|çÉX™suþ 8S4Ÿê–'P® ÜÑ£Äö‘=G•:×ãA‹rK*$OŽaubë~C%¡Þ/©òôO™Ý±Ì9C¢\õ°Ô&Œ£×l¨S×Ò Ì¢‡µ' «wˆ¢½È|ÐNžA<ÙG¬Úª‚`-æU¨Ð4Úh>fTŠ£¾0ýª8`Yµ¦<e0”ؼÿÌ«WEN}=TýÎ(¹šÒ¢ë>ø¶gÔöüÈŸ•«mÿqU`<Îfzˆƒ+ëÓ÷{;ÌNi—zfð@Ÿ»á€D›š¥±ôBhxã|ƒ\w’¡áÌÖö°|×ý"˜ì¬ÄíD§–Þ7€Ý,2Øp^å=6°3 :26IÛ9ЦÛ`Ö`zÕM;*¯)°qô¿ËÖºRC¿[€#l‡óBÛ;-V"¡´eÁBŽ¾þZP¬.Uc1¹vÈ5Ž¢<óœfC &éž³¦Þֵ〇ÆãŠWœà"ÊÀ:2§ô lÍ»Áãa4}M1ŸËhl£ÅóøÒCJ¥ž7zÅ<vó´> Ð>hº?FÛˆÃÕ:küÂÚ3õ•¶èä‘þOkõö £î¤Ã¾wîd–±*–N^qæ •gˆq�Ì*صrfçn~w/ã‹ójÅßIÙõ%<i¹.„_áÁ°©7ÌtÇúí]Ç—Š/÷Í6à$0Ð4ýR[úâ?ª [ôgìîÌù–ʾøV¹“åçüüÔ•Aº×NËÛÏ{›ê× ßF”—Ô7‘Å{ª‹aå›í0Ó¾eÛi?ÎWúx Gœßþ €Ù1]| ê¬Êvn‡‘Òºár5_a6à·jaYÒñPϹ=XÊ�î¢xĠ̢ƒ»ûÙíQWègþ¾¤ÛPøÒ Ÿ]OCÕÓj]ߪµ'ë·m’&«¼¿  Üšjûº8­a5„ÿ{£˜åðõTgáÃY¤Ô}MˆŸä!,<f}0È)ÖÝ7fKbÃsóðä7⪲¢ âhÙÔ‹¿*¨±Góf<©›mu!vQÑG‡~__îä˜I^8Ð7É7 =íä¬ëéx{fÏRy[ÀJ!Õ/pKoà|ó@¾=ŸÔÓr$ûïä“*'LgIsæåÜÆ98‡å­dÞ§Á%×uB‘Gd4ǃÉu¶çþq.r‰»5qÚ§ñÙ{£P¼±´`áFïj´þ7Hå{X }o)Ø_bøôlH¾ÛÒ BÓه̚ر!ï–%]~ô¥‹ŠÈ%§1ܧeÚì”9£èèuô±kAx׉0+RÏç—>ý0@ƒe:y\?8èÁÅÌöS}â6¹Ó‰}9Ž‰{‡ªÚÑ¡j$P=æÐ/b‰0SâÎpmè.w ’VjPdc¹Œ‚ê}q])$…KmYV<�—÷2²’•€qZ94w¡gM¾ÓÇŒ9ÌÍláÏ•,vü#Æm¶yÊj‘F7š�P2ó˜žö‡Êä¢9­¾þ®hQÚŒÀ¸nͺ×Ì ‹ü{;#Qé;~ɵˆªâF"´Á°S°B"²h[O“à×¼ÁÔQFx›?eÛ–%v(§#Ü¢E7z) ¼Ë½VåYôÁ(Ÿê¾àûsò0�FŠÎ:[Kƒ’^r,Ò¢t®ÃLI¦*HÞU 6š6 Ub]ú£.ÒS|_î«•‘fŽˆLtwv-}µCìáÍÔåë¯G¤RÚ‘â…PÿÃúìá}}Ð)ÜZ/æ(¹ŸãEeâíR²U@f¹Â÷ÄœB#³øùp…VN‡ 9Ü•?ÌâÌŸÄcMŒEP|j?­¯QížÌW: ³égó]¦{!øwóðÍäÊÑK-Æ ¯ý)§=äµ*x~½Ç"õ °RafðfO7:ïߥדÒ[p)ÚØ Ý×p¯,«�z_*ˆœ!Y@7šù«Ýî0?öös&í±N”}\÷^—ˆþâ @WÊiw¦*¥¸É¥ü­æÙVRZU~ë9LPÄgAqR=\Ñ2à‚FÉ=ÞÄ|y9< \ìÈ!»^_ ZÙr|Â\"öEa×tÃOËÔiKVZà uÔ9ð/wä #pi×FÖt -u){µÊ´±Ý8‹lôÍëŠZëÙ_ ¶S—a£t¨<1=ÙÇcÆß¿J˜e-æoÝÍ£[ ›«A†Z¼Ú@vu ßÐ1qäÎÔ=XØæ \þ‰•Pï1I‚ì¬÷g¾npuÖaˆŽ—§¾ï ¯ƒ™-Nðe™ 1ãnb^åNÝ»À4¬™Ë éfÏæDOÑŽòÖñÃÔ!0i1OÿE œ,\á “Þ|*F0+oÓ›Ÿ›ˆ¥Aìv„j耽2)ª3ÌgšÎwdüŸ úÇžx½ñ•êÐ¥µˆƒùÐ Cýx½<ŒÒœµÖŽnŽñ³¹\TY\¤T•mS.aÍ_B±vÙQR'È5"ÖCè“C% u¹�;ÊÉ×å¤÷0fÍ6Æîk=Ùi?w¡°ø²Ò£‡}ä^KÓÁûnqÌlÀßzý=Gâ4Î<¬ÚGŠ¹Ù¤“a”aŽøЇ0À°"Ç‚=qŠâ[Ö`“ßÆÂw~£x ú~ê^Ö27‚/AA•ªéx¯Z8CúØíÕIH½&ÌR8 éìÎ p#ê –Uö0š»â—zš¤5Ä´78W!Ôk ßû蜊]ÅÖÇ,³EÛÙð/Å$úöõ®ƒ´uÜê[tM Vy׆}9ëïÐ)~òøˆ Ûõï©£R-»ÎNú™>úPi¤æÚî± \*L»¬ÐåF��Fõía~§)f}¥"·–Ì&  jXí«"Uÿ$±$<Ï2Š³Æ²·<eè§pŽoìçü´ÑÏ ±¦¤‘anŒ42ÓvÀêáC¥qÇÊzŸg×¹s‡j/ûo&gý1O'í§}µÍòŽƒ5®Ä€µ[ ¶ºq~KS¿»¿éD1/qv)aÅSaœÛö]»íð¶Uò5RP†°<BdqæG)ý›Oth_6W«ûVEH¶z†Q†ñFû©%±¿²#(Ål½z¦†Çñ:wÖÜŒŽg‹{—üäoHêI–ùŠgI�¹~ûÀ+Sö<Œ_¡nMIptÞ<—ÉÊ0*bí¶Ä6e±l›ë›c¬ü‹p[ú½3ÎÈ—KŘ.'cÏÅ‚•P©s{*ýoó2Q5…ì+Îï{'L~:÷=X[fçœYÛ&~ü0Aw|!‰‘I0B*ºÜ¿œ„»˜Ã‡ôë™VCêF T\Õ·PÌrE5’ÝŒmï¹KœÌêVµÉµå΋<aâœÓ"†F|$AÕëÀsž-ź=8¤Ðà7k˜ŸLb<l“ æ ý²Ô6ÇÀßé¯C+¼•»KUp‰÷j‘y‚¥t«TÞ©©šNo�e‚ŠÂÞÜ~ç>òÀÓ;¢Ê$Ë|®bÅòåU×XÃ4 /[õK[«–kçÉ;o5àòØÛ˜@ r_ž¡² ‰›ƒáÒ]ía WwÄxÒÈÇ3bÝ”Ælm7LVz붳 ¹_±BRÍ`¸ÙSÞø~ñ�ïÍxÞØ#eÞ :˾‚"ñÀ!`="#O¯#­ñ´·à¸D$0$¡¨"’Õ@ù€.ü“ú¡MnBsnîk:­ú¿^?Àˆ­9ñ™gbþ<9ˆ_ùš$9ëhßìÉ~LÖWLbV�š‘&…ŸŸVæÅ#ßSWO÷ͱ ¬]ãÞ5œÕ‡8HçÚŠL§€K”zešÐxóº²R3îC< ÔŠ»²h(jÕW…g:’m¶e¾£ ™–‹¾öÊ,ñH,´†$µ¾ ¶:± ï**Ìžk&«çòr¼yõÌ,Jõ3ìŠ k¸‹áçÑ«J½fc%¤)Ãåœîqø®à}ðts°Î›ëçöÄ4. c¿%5ÕДÑæÖ²Á]?ãD¾óÆOŽÿ¼\) ¥Á œjûiˆŒ@ºÜŠÏ#O®4ZÕ"uf¶àúìÿf ä ì¥b׊�0uÞÎñfwþ–‡‚y^dNõÚ}]’ÜɹEÎÇ®ó7$_täB P´¾{¢ §¾Õ@N-Ye†­‹£®paK‹;Ëk£ÎEÍÝO‚ÃŽîIù®Ÿ¹(¥îBPÓñDÍÚ²·¯ÜÄkë]7ÜïÁ„*lÌÕ#îNO{¾ï½êd?ÝuMÌ~qfÝì…™ |áƒ[p¸¢»É‹Û4½î ŸŒóÈ!ì ~™Ñ"Ñ]Uo×-êRøSöõöÎë{* fþ Ý*ì‚JÞPàDÌNÐ$¬ì€Œ‚ÕÙÔtX /§HE±ÒþE¢Jaõ´>¨º˜Ý*}o#qæY\Hê5£æµ†ÞÈŽ`„Ì& …^ê»ó¿}÷ßýxºóƒ{,;$Ù>%ü:~;ïyl !ˆjÇPñ»–[îõ™†|\¸?…½jÐôNNï z ›À›(ØÔæѨòflRåkš2-§6 ÒF§u©•ö;O\ˆ|Ð4�»eµ4t'¦ïºôEù®5qLÁ&¬ÚâàøÀ8ÁéàØ7û±ç1Æ´êƒV!Ïãh\Æ™ç´û6 rS‰KRy„c›¥»ý§«‘ �<é9þõ$ÌN#Ýýi^Kú³}'Ç£G£-\±(±ÚÃ)ðpœVo)*ŒëØó¤ï<)­µTÓ¼4øü[.X®IÒ`™« ;m=Ï-~�òK?TÔE·g…—}&˜c9­±qþÓJRºyê†m.„Óú/í_JÖu Ûï­z)okõ^›Qýr_“"«RŸGÌåyÛ9•éíØ·|æÁ:º›ýÈJ¯}·ùس֓év1V¬¤–Y÷iêiJ=’r>“Íf¹Òïá/ :€€Ü7AW‚EqÄ&ÕT{X“óÉu�ò ¯€0]ɹ&t,ad>ø€®£ÉMF/]kñ“§—q¹Âs£—6÷²³D™?óã Üt®›‘§ _œeܼúQ¡d†fÌ0ôŽ^@±9ؘôú|!±y±AË‚ž2€¤Q”ä‚[0wp˜x«çyÜxÚß/f7+7 SÖþß.aˆÕæYzq:{Pˆ t£žrÞý§‰zI„Y”øK` [µêÖEnWsF@çÝ*C¦Ì2÷/w“ïWp^H¤*òVAÝG´gï±O£A˜™g–ò‚oJ¯ŒAÀ@üÕ>è|B™€•qíØ:V‰éP¶µ׸3ƒsð8Á*, ÍÚGô}¼¨ ¥dÇŒX#dî·Wgåij;D!—²¾`êê¼®Ur¡ƒ—­Ã$Á)î‹N5Œ*3à¼ü¡"*[ZOÏKX ÄvÌHןd©î„ŒŒeSÁ¬Éæñß5œ h„Ö3§ðü_m±Û)FœFZéçä ÊpÇ“ÕúoÆՂ¨§³i]Ûm—ÙÊ_= † N×FFüßåÜCaVóB7eaaXL|Žµ,³§� (Mª,s(/úE]IÉôÞCêlº# s|Ü÷y,óS&®]Ų+›me m<جŸ¬ÜœÁð(P�ì7õ¥71nhÝ…é­)â²�ruÁH¼Ô„‹v¼ pè\êÙÀF(ÙZÏIÙ’vùSƒ~+³r±zÑÉoXi/) )µVFH®6ØBµáª)Ùåö›U£#ב‡€wD÷Ö¾²5á|9îAÆ­[@ºi¶"äùhíõµ7§á-@è;`(r�:ȾLyÕ³é8Ñǽ‚Ø$ [»f%ù´ëA±[åÕÞw‘³–’?F‡SBI*‘œOPþ§†´ xª�\#VéÒ·zúðTRƒ…V~p»/‚‚{pæÖíG9LdEiO\Þ€ëÓ>ꃘëÛÝïÀ?.]>g*ø"(¶ÉæRŸ‰r¢HðaZ ­ïòÅÑ‹%ÀW†F‰"í}ã¦Ù›ÿ^ î{—Y<(·ÚÇrì¾òkc•â5Lu¦Å}óêiI^ ¥Ctº¸.T‡àð»Rv¼?9ƒûMgZÁ©¯J¿gìã hl&G¿ Û‰ƒT±|G^8ÂT’TD(tðÔ4îÿšÍ G¹Ô0LkÀ^Dzļ ›­˜À2 ~¼ _ÿãL5úï¯ÂGcygF±G ÿx÷¢°='Lô4Ð,´Œk¨ºà—H­É‡ªÔaõ (¶§$O!í/.\“¿„¥é7Ç$Ȧ/O|áy°�ëä Ø¢"Ý4¡�U”ã,N†îÒ)U‡¡oH,§Mà+ > o ©+ŸæƒÓþ<í|_¶G„(GŒª¼Q7k¯ §4 Ò^§B9m.}Wÿí¤álfÒ›Ë6t¤LÛºs¯,vç`ãÃ0›<k§ÖH"U¨²ã¤>ÒMÇÕ%+«±ÁŸÓíMjY~q®SŠÎ’¸bL @{-„ù3�t÷†B*]ÆեߘâŠÀCÚ—ÊyÊY½ûùš"h’ßÚCG7¶¨/^Ï éDÃLeÖÕc@P>÷¾{¨4)ÀF;Öò?×É6øQ[ÀíL8sNÇã›.Od5¬˜kxU‡¹UãùŽOl ¡”cpx…«Xæ¾%*½÷æ¥J­`*2Oµ9%¿ ÛWÜŠz5{˜{tW«Ûg™ÆýU‡áRÄRíj@›=êvc0æ¡÷ÿïÍÿƒ½§³ñ¥ÿ‚ž,iŒ¥1~Qå“ ªrž5EbG¯õ-.j´á$û©~}à#V¦̲}WU¯·ö›wåÐy—³ýðÍû5ƒ«$Š}IC¶ÐNú‹û«X‚3«zy£Õ6€t7ž°Š(ô‡†ô¾lß½O^vCÕeÃÄdÛ<¹1ï5pŽ°ëò#u,¬u@·•¢^´ßyB`åîjÍÙ» ò§4£Ôò+Åî6Ñ”µbLyCHwÝg0Vµ®Î¹Þ‚\mÁz¨Uá u¯²4¢ÜTªxôq3á_žÓñÇØQÍW>øÜó}âÛ¤Cùûî qçÐE÷ÿéÿá$E-úÙ²1æñKp¼.çX˜+'È9éᛘ³ RûÁHp‘±�]’w õYˆÚ»©·_BµÄ~Ç5Ãts"»<ˈƒÊà@/O¥cÇHsóÂÚØ7ª‰›&†¾í_ÄE,tgÙW¯>ÉpAø·ý–Mè„%¥t-1x… Œ]¥¶}¨ƒ¿Ã24Zýkìƒg¾qy‘ݺ#}L‡5,æšž’q¡çƒ±ÄØxvüTðºZæ«¿õ™cû$ÞóAé™ ´~ï¢VnV¿±eM}…Oæ&E~µ¾lO F½“d£7¼¸ÃqnL»êM!£·ðàï?W_wéÅeL¼§ÕP\¿LgºbÕ"ãê®÷ê·µAB»Â9 ƒ I[bw5ƒwþl<$S>i„LÀ°ìœóQ ¾¢pRX,&5§1‹ê91|ªHÅ ÿ¿žù3½Ú(H<U2¶,œöplªUy!·´…Àã.ŸÎÖö*{ól„/’píŸtü ½SØÂ�pBx]«=—m&ø—¶ù :w:*6#² lÝ3ªÞtÑYÔçìà¸i;r/ì@òƒÌ¬éÏ«‡aHŸBqÙéÙ©Þˆ#í¬:“{öº‡ïˆ¢Ì¡O„™Y±‘ÓZVbþÕj*±‹HµÙY»¨ú¼zPŒ‹”ZsßmÔ÷Eí"Û. ·4_1ôV”bõ–‡Îs^ÆE\dSÁ‚N²·ªæE ºÝ”ZÙF¥â¬_^ÔÌIrÄ-~J”ÛÞ(‘³d(…aãÙò“rD%&Â:Å´6ÒµÞPªœ§êÿ;æÑix“î?¨ZËCÊw¬„屬¨}˜›s*}FhÜ~qŸL"áé«3wvì]ÂãÖõ²¦,–heÀ˜nÓá„°n•!2l¨‹ º_»k÷Àw&.Rg±Æš³}—Q½ØÔ?@^Fod‘L*œç%h÷®@&H ©-„Qʶ;O_÷¶ë¡¾C+‰*öÅdMGÆ5¹æÿ{¯[/zT*¸…?ITCcrLxl«¸qb—à½;ESF³3ü¡<nŠ©ÿˆ:Û …œÇŽ aÜ¿ÙÒí¯NVJŒ ®Ã–Ò2‘Ìk»ë4<dDÿ©VhšØ ¨ãîËšõì¼g²ŽÂO[Œ|jÂÏ usÕi¨ÌÕòk¹5s…)/·ÀÉ´tXcÆqyJÓÜZÉ×*1õ† *]X«ß(Úþû(põ²æ¼¤p‰9ØNà6.×ÍHû$Ð×ïgašø¢–tŸÁ [;s “»é-b¥}‡b=vEVR™ë\pá ½Ÿ4[`uªñÈmäœÚû®LÕvTpîU=©Cl0çm x—ü Fìñب¯­éÔ­ÆúûâÅt‹ûóÀ¾LæIµµLsÝ…iëø B)·bqÛÒÉ"¿0›¡ÝséÁ$¿Õï¿ÿS´=Ü(ë-`å_õ ¡Ð£~v©Ê˹¸ÈWr]0’w+ש¶{Yþo¥$Hqœ¦"ÈOV,¾ Ĥz1âZg#Ó+"ÞúºÖÖÎËU‡-6Kx±Èð}Œ©*п NÊÑ…²0P“­VÒðð@?Ã(™IÌCÊÈÂÜßìµ ýÉ--UԊѧ72ÜGNgfUIû¡*Œ'h.˜ÿe‚º^o¡Ëè=,á>æH.í󦡈M…ØY~2IÚÉùtì~é@BÑïçæÐwÖ+¦GQa˜õF€û]›ƒR)K³rž,óT Þ·$¶Ó¹Í_þM­D\àûäݶêy„B'á<P–óY{.°›ýaã•Ÿ`Ù“Ê)5¤Ò'¢]ïÜGÀÖÀ²Ð̉‰ ²=摲Ø×nŒ? ÈÍhÓ”ïO¦”öÙ°1QK'øúÊNÇÜ¿tÊÃbô|Ò}v"Ö™�š`B©Íç™6%½6îÅÓ1 c…áµ»h6ƒ|àƒïo”ÀPrŽ„†žå0Œ¬¸Î¯T"׬`½öHLópÉ Q²Ëÿ^½z™ggR1Ëcû½›Aya„çøÅZÃ*—ÀÊȇÖëù! $Š¶´?L×û‡¾rRd¾b®Ú-•µóçzš‘*€Q…|–ŽvDí—´ÝÇäv;¡ql§ƒàAȆQ Œí¸ÎÿYyÃ΢˜%ó[¸l”hQ3*ö%¬Gì=#r_TóÅ@jMÔ¨F Áq³gRß÷‹»[éY;±©p}q×:H(«vÛ϶½{¤»Zu¦³Ø—WŒT\­óY°Â$]·¾N‹±\ûYf-Š]ç[�‰¬œîm÷­à¢³Ä’‰àT ¨Lð½à(‹Bõ˜¢¥ÓÄà’šÞÓ !Ë¿žÎ3›ܸ€)dEìŸ"HiÒ]š5« w;u—U–´¸·“UË}IT3ñÍ,J7~Q2—t塀?ôÔk>êzöww«Ãp†œƒgIÀI-ÇŽ5’öeœ÷Bdþ¿7•¸Â‘¤ '>34ÈÓÜ¡£çÐi†Œ´¨6µîa|!)m®»?»ÝuE™ù‚ !¼H ©U:‚Í[ëiÔí|à…cîüÍwì<uÚ®wn´‹N=˜cËÅÍ:Ocô€6Œ¡<Ó#€5¹wÍJ:e=~öa]þ"Á†eŒ!ŒOê¯>Ÿšþš§‘qD]0pƒt ·x~�E”ÑP¢!… ËþQ¯Ý;¸Î‹|/K%îFÞYÔg­ ­(êKE’ÔK…yÒ·GÀ®ê³§¤>§SÛ2B¿If=/Ö‘ÚÀ±²Ÿxðî²RIXºôðmG’’¨“aÊ3þFd=å+ùn˜½îsJ)ÎsN%T’Ç.ç‡sÀÈqõÐ#±£bëkðÇ6õ`œùî‘3ŠË¤…³fû<0ƒâ³Í\"‰ãbÄ‹’x6«Ä ÞѤ1,J×ا´kò Ÿ#NÆnDëüŽÀkXæ¸téh‰m½o)}Þ·*"TŠÂJ{ØzLÍy)™×*0²  ÂR{ñ�«>ü‰J'ôœ¼ÈÁK©Þ ²“²ðûŽ ÕãD˜[ÃTËèUÙ;¿añXê\©‚Š :i¿£ÊhÆØRífè‡h½Â%†óÀ< ¡RuíJåïûÑI»â$iç#x.ØÈ ÕW 5ÎoˆgBså•Ÿ€¼9jŽÀ…Q ³ŽÞ¶QßMk7,æcÔp^B±¥Se†§T2P¤úÜ»T BazÆnhi‰ÜEZ¾Y ä¼ú‘‚el¹‡¾.Zô( Ê2…û…Ü[êß$CÏÌCª¶zÜM­nlKìÑÄR1÷ èÓ·Ö·$‡”ðn×¹î D¥ÍúõzKt&­ºÉ¶_©\ÀÊ Æ7 TˆÞ½Õž3È^ß¹r89_1dÕ}h©2ÀÐ’½¢ºï·Å*ŠC*ª5‘OWÂi.*ýK.Vo„84š3tbÃÙR¿¸à¦[ÊM$mÐf>¤­ô`1F¥ ~¥b­/ƒ”µ#ãªJûDÄ=¹3¼Æw>e*DUl qE÷ ®ƒV—‰'k´e 4`¹~#IÚµ´zaš l¶BÍÅ= 3r "šãfÔ]Ûíj'Fr¸zCœM õ=´mý¶¹Â¥±÷Þ¢ÿÄi¶Ê¦Kô‹ luBË(Þ£¡mПö’r#®È=õŒD1s¯iÏFºÓ“mñ$5€Ÿ³—MñUð,)ïÒÓY1ç¡È'ƃŪÜj€×Q­ Ïd#ÝÈÜ�D2¥Ç¿Ìž ó‘‘c’-­&:ËþtÒ£|iJ¥N[–UsžÕ´õœk­»¸Ê‹w_Zny—åñÓÒý³­òÕ¡ =&xgu-bíê#CëU³ÿÉ1¤ZE\:/úG'Õ5ç¹úxæÏ»ì<´A=ÿ½a¼ÿs óÉà0ÒY‘ÕçÖÓGEÛ½¦'Ãè¬ýØá1ñA©Ç…ú ÿô=mLìL“òb8õÀï ‚çi ¥$lÄ×£ûÍÂäÇ'Ÿ ¸šhd{ÅLæw)Ÿ&´Tv– ì8Kòõš3ÖÍš-Úž?¯´÷ï¹–ÎHr[NÚl’`ýY>²çþ‚/dî:’RèuÐÈêZ®ê'U!Õp´"+«ä"M7ßÁšÏ—·©[Zd" Š“9EzëíÔL¬±½"E ß»º‡JÏVxÚ X]Ú&ï{OÕxÈnœvV<½8þ…/Av«ÊN~ñ7€Xù²ub–GXÐi͸eÕƒ H;†ÒýÚ".+g3g†æ \¶‚,H@76’ç툼{÷Sž4·(~Q?°‚ÓÞZÆÇåÊT ˜w¾Ä†ö(*Õê…)mMàÃdf ‘&QŠ)Åçb@äØØKêñ( úOV9uWžbÏìPßZ:?Sv°$¡ÓÉp¥_(Çd7bÈãWš…5¨D‡Eœùƒ‹v6>¾Ñ¹’õé÷£nzS1…w —F»ƒ¬×4õ’ ˆP´ÜØËlܹŸ%…ÏbC2;ÒŽúÆ‹²äÚò`4®ºxy;ÜѶvÒäÆIŒU :åžG<á™|±—ÊÓ e“Zƒjø”'«= µ)`%!Ñ$éÚ½¾Èý¶˜¯™¬JŸBÊ´gÒýÖã$-­ýxf«Ë˜=Ìüxøò-¹O’U¸„= Y¯.ÐS‡$Àù 3xŽ/áä¾"R”„>hº 6 p[W_…R}ƒ¦AŸÅ™—ξ®ý¡RO…R ’ç‘’·â¤Ýè„Y[hg;KvN^²)\[º_–Ïšñ‹Nø³öÅ6ãñHÁIˆ€+ ŒNlº^Ü?™4 i{Ñir[”—ÈΘÃëvA˜uì‰þíG—ëtëÿì·€"db {>.�g†Ïê•âÅëßyIWn泧Žþ²¨Ñö†µõ÷Tçõ]«×ý‚Ù…+¶ÒX ¯8M”sï‡1µkŒÖ,íci„#Fü±U,]_×÷+IªSBOˆÎÕ¬:(Ü¢þÛõ<·ÑðÆIƒ6¦Ÿºr¸“¾0dZ&¸ÄµõƒC. 7UÕÅã³<þÆÚG$ L@µ!Üu_IÅdC"éÐÊagb3QdézÛÏ�ë‚ICéœØ\;ª4óµÑ™'EIX¯ú “bD…ëô×e‹ÔûÜK«Êá&™u¡ã¥ë¬ÜA@ÑF.ôç]Lr5æ_0<6€8%^˜”ˆ«Ì,™¾¡úÛCi •A{̓ÐZ²ƒÅÉMp)!Ô᣶½q[]ƒ w¸ñò ^˜E–˜¶òf 4³+cFcš¤Ê øÆ-¿Ç6ìl“u-Ø<$¡ØÞ:`~'i¯Y[ Ñè3¿ÂÏÊcW<°:×r)‚¼^<,¶Zºû2iURLæþžÊbyfŸˆ!qƒ¼·¢% óD3@o; ù88éú'!ç"\ù-Ell™×“7¦í¦Íÿ»j’»`)õÄB屜#£µ„ݹE¶dòt¹ô×f-Š¯±§ÿìÌîVæõ NÇÝ*ÈWĸ0úóZ7-þ@ÁH™¬ž�õU’Gl=Ö«Ž¦ÿžÈÑ ªÁh t_Ýç=p³ %ür±U¬@€¨Jûzç™^ùÎNnŠ|Åzà™¼¶¦£ÿ$¡£%$ÂƒÌ �rµˆ¹Úxj¡zmºþ„ù¬¼< d؃ÿ(Ó檰òšÜe¨Å¶ÓKd±¿d™;äBD °:mcZ#RƒÐ7\= —ŽÀi“–ÐÌæ×èùý·¹þ—~ †#ÞŽÐp¯” £¶gKMë大Ö„±ÂoD#œ‡×[úûhaVäãœ6 ]ö#RM<—1[’H½ è¼ø³ì—eßÜÌ 0úÚÖI§V4›Ã$ø S!ºãâûéj%挙$:“úËà›®"-ÇS‰©øÈð®–³ zà&Κô:zšŒ ©C·hç ·Reüç ˜£¾fè9æ\?ÑœZ‹šÁ-§ b¡¶Þ|ÚÆbÕ‘Êò³H‹Bvh ï|Lr»¾"Kö5 5MíÉâðÝ6Ïòܡ¼+Y5€lI ²ã¥de] —&º+…õtm»æj]XÌ Ê\S¸ºAóWϯ²¶ §Ȫ`*Žt¢xÜ_Œ-(ÝêÖs0²é?j¦Ç®Ã$A¯hkD_Úî’te4[:íàó¤{yõͳ¡pìE–­íVÙý¼xÝ,éÎQžkg0³áîÜSÒ*=õ5Ö§Ø, ~}Õ^Kñt°ÞHô€3/^0¥ÝοDKTÅx„ÙJ¼6 ÎMÁ¶…&/OX½{í?úM´bµ½$×Fzª¯,ä"4Ñ»šTIVd¾$E«cª»Ùó:Ù³³˜=ŒXéíÀÙ8PsZÇz @Æ3‰ƒ¢WäK”ÅΆDßêß QZeu‡Ny*ƒèóäÉœ7@ÛNuo'v_ê;ï‚ÞX%`UmÆ)T•FÑ÷4âIƒÇgr2È4ž{#,…Üj9ŠörMN±z<rè)HÛ+妘òK m 5‹+ÝiD:ñ®V®YFÇÿæzšT÷…êûŽ…,o^Wö,…ÕðtñÔ¥Aa=ŽScÐÇgã©–rsåkŽûŸèõë3“nÍK”ýÕ .ãvqÅ›EbÝ»ú/˜AÓûëñ ¢ˆ\»–5²çŽúÈzá^CÅWo9Ö/4$=½¾û¬C·êÉŽ¦‘¯ðù5ÁxošzePtvÏgl§€,úkÜØ2]åKP-gËkðW^lüùF&,ôßv´úwƒ‡ÀÆY ¿BÒº×\Àa6g‚i…Ie;¤tŒþõô  ¿ÆºYܽ«ïGHªŒwÑÜÃùMñ¯‰Ö(_7îs/¾l«Ã77´Dž*4- WÏAn;þú,ÙßØØhXy«ùñäEÞŸWU—Ýø­0Žã~eLãÍ(—Á©úò¢ýoÝìSz˜­b-9Ânû‘Þ—aèn• ÝeëN%2WœßÓ”(œâ£@*й*ßµ'ùÓ««Ë·gn1=ïV•¥ãû¢ä8½ÓY;®˜@C¥žÕ,ШöÐbÄi^~êTÚq‚ È9Ú¯P'•z�ýíH).ÞÔüÇNk’¥I•[|®pºC:[O­›Žhâ¡…,Û^(•olMÿô;ôòœ˜ôÚæZÑYÛ,àü�Å“S„Ã^ 8žËÍFI¹²Í+élˆý´�JÆT‘¬ìÚcâ‘ÕD’y˽+Úx¤Aë/äàæ#újŠ²²7i§‘Áƒ\ЗóQÛwÒ´]¸ò$Ÿs@Éû9'­ àP7 ‘—ñ0êÏ[íÖÞôr‹/àþy†cž ”b1ŒÔílxý=Ê»ø†"Î$ô¢_<t- ?ödQêù‹t—lrŸ‹áJ@üv¶ƒÞò(Õ½yÄ@›©7E"¡Ï³´{ øƒ«f8n›ÂtýÙçJ–óì’Ëýáô\Ÿ×v3ÃHÅt¥”ñ Ì#dK: ÿ»‹]Æ"3Ã<=ò©±Y"´§ P-æu¶ÈP³^f Ï%rÇ¡%ˆyfûŠ“s�ÞM5€ ·yŒËóÍ_1¡‡Ó(’�SÌú>Z<ÀÓ™÷ÔžR¨©ƒugÍS˜ïšùy™ù UÔ&´j®{Ï×ðÄ(¤…ßØå.ÏÛáˆúT=¢0"Aâ!É nŠÃÛ«â,!„ƒ›Jɽ›«ÿÔÙÄ©`UêΠعU«jS7Ø®Ê üÉŒ¦Ê¼Ô>Ælm†ÜrÙ~¹gÇFlÓ šmþû×(ž©SÎ’sZ›ùðåÖI'O:Xs½™ø£Úšr§a‡ i›>Y¶ÒB »ó± ßc-mAànEÏTÕšGÿ+7„;. œùAæ™ÁÖ ô ‡yå#X»qw7˜myózÇ‚1¿UtŸ)Ⱦ&›H¦|w:¥¿büúoagluŠË–n}Û8qz*‡�½”}û+8Án;Õôˆ?:m˜Ü6­M¤‘ÍJþtsÊ©÷À‘b�Æ ˆ›<ÜĪHãÿá^ò2µ�àõ•÷MÖxnË7Ư¿”óxò­¸Zx¸OÝ,mPáå}1™&C°AéÒgZ=®Ÿ•¹*_Té\i;ë؉ÓXûgÚËÁ[ hH,cÚÝÖâ ̧Ãûˆ‘j¬Y"ýÃ1@æv „e•›cAI–õ™-YÙÀi ©ÌN0€@ÜÕ7(¶á‡PjrE úôø¬<oó¬Ó1ü þŸ—4åW#gº-lƒšÖª}Çâô2çTÁfB)Ïc.ižð^3Bµvk™a£_Ç …/Ð éèqû/Ö:j?ötZŠ Û;ˆö0v^Ќ㲩<КB&+Æ ¯XC¤©(—î{sP4õ©éÆÒßn´(RÎ=úQí-XêûÅ÷Rßõ@äp‰šØÛöMFÿÕ×wÑ;çiœ&Q bp´Ù(Pž,68eHÁ¨‚uÊÀaÁYžý Éf¹ß%”ç&ªÏ/ÏøNôYw*ÍÂÔ#Ü\=Ò,Ms'‹™rlšØ‹E‹N5—n`YØ…ÛF”%¶52š…¨#(|žaâ¼Ö¶-o¿^T2,G•1Wæ6¶ëÆ—þ%;òb[ž<½lVŸ=uEPžþšñDaÁöè§ $š2ü{›-÷©^1Vk„'{¾°¸L×™B÷Èð¼«A—Ø®ÚðcéhSca¦‚ÐŒü|¿uè~Þ{x#›âEÈq§ãÎ"b4Hð?©ËÚ>ô©Jn†'eÄ¥L`ãgì-½_7C#.åF0f@2« ´<©L*½A ”�| ÖXÄ<›~4±�„¢•=ØršøfrTWî@¨ŽjßØHI«ƒ>:9ôU„¥×VÁ÷,&ñ©:̿辺O–úYYØO(Ç0éfUÞ»H«þ(ÚÇa³º˜'.St¤çeáDhXtÝ}¬]’Ä™ãÜ…™ Z›7F¿J”V.D¨„Ë¡˜]3e¡T•S}ÖÜ�ø3=ÂA6Ý MYå‹aÓSÚÆÝÖš$V†éM‹@ÔüÏÓqß"»oTñ‘<úº‘±6W¾_ÜØà|:d³9ÖÒärÎQ…Q—žì|ÿëi?pÌÞ¨W¬§sg•È½ ÷ôn@“™£Æ8Mg¶ˆk”ZŒˆ­Mì¤ÒáøDº¾n] èZˆS q¿)3ϸI ÈÕ8‹§Á4i¯ïëë?h¸[j±Pbb´RYËÚaxÌ64k£¯ qäÖ³$žÜïÒe˜VÊé2”” êÐ2Ï…‰+÷  1D¦¡®oºj¡º^…54Øcòú9(Â4“f^Ç´ŽÙ\ó™9:ØßÿúÒ®ûW˜0 ÁÀpokL�UVÜþ‹̹¡ÿ½ñ?ìs` f nàr÷‹r¼hçâL4[;„Le—*ûÏF_ã9`×j鈇&À{%¡'6ÅhìB²·•  šôa¡ô._ï›ZÍ2†­DgèçZ×õ’¥K?ŒÆ§4�³AA³:ÐblI)ÚO’fˆ—Ð"MºÎךdå)A^áÝ!`j¾ÿÀ‰×ÈqR&¶ Woh8&{W¡Ë¦¸fH²„dœT%ñ…«Ú_x®`0 ÊØÔp«ß+HBí"eÚãÌ$m4æ ã¨ÆÓ-à ‚å&Ÿmöh_ô´î–CÂÿ½E©%z-´¼8+T*;¶Ã ;û“öèÊ/™¡\M_zúëƒLWÛP\¤éÊ@!1ž™®¸—iæ³¢J„aZŸÚðMYÇ£Þˆ”ÝšAûû@Çg¶y¤£®jt2&Kש×;Ýš~~¬YŸ‚Ü)]ê2(NšŠ£àfTÊÕ%ÁŠ×ª™þ /7U\¸I£m¤bÓ¶ˆa·¾OØSð2ó]´A;ìs:£kwøˆ,ºÕ² tVgi´’Æɘýôc<Êb%¶Qõ ìÞk¿¢ *8A®7ù‹Öœ ¤àfãOÿÄŠ9¡7…cO88œ¼ =&¶ÙB n¶zØðë.o[Ô±o†ÀÖ«ý'“…"‡5šŽ+ïØŸyBè}õõõ2£¯×weŸ5ãØZXÊ."†ƒ1!×ùE3XE‚…nK·¤…›hè$ŽSyfÎŽ^:}ƒZT®\è‰{Šæ¢g€e‡‹!º3R»ü ²öÊŠÐŒw¼y$Á*ÅÊñ“‡ð?!ž.ò°@e¢¼QǨVxãù�)Ébä†MqÆÛ¤â0°š¼„?º/¯Œ˜³Øï,ÑSÝ‘¯wzš õµëÔ}=ÁÁ0¡Ú7õ==¬Ñ¿º+¤dK"¬FeÏ—*¥[ @_Ò‡®O&GMcC\kO¿ü§)A‘ø°¨ú?éu±s�ú-Y Ó¦ÜðˆÓ\°àì‰ÎÝ¥5eîÁD)Íý–Ó«RžÄÆVÕœ®^: ]uÖý…[ΊÇaGv>Í­'à†Jãh‹#íÇ £Ÿ­OÓÒ± +î^-Љ²ê%Ô©ð­ôÿ$ ]d^¹ÅÚÍ2·œM†Tsðdxœ[F ŠÐeL;Úé©í‘¡Ã·=Oµ”]j&V4ŒQ«9ö…b�¼¿‚­n¶è@Ä@$,)` Px¡ó›YkéZ¤S…îõ+ÄAYú¨ ˆYÍâMt7}Çp]}›q0÷~…nÈU^<4òÜ"ÝÐï\Ãâívoõt¹ªÌ0]­ÌàÛ¾ÅÆVbw†™P«ô®¸­DÎÇP³w%5l[o^Ü BÍf¸âbŽÊ…ÖÍ 'f!,®#NA1køÛLÝ¥“¯Â²¨‡…ž¡qšøòÓ`ëÓÍ ­ÔXÌ$‚ ö„nÈ°Z‘rW§×öŽÐ{¿á¨â0¼¡rÌÄêmϨçsO÷æ'¿˜ø-/h{|ƒÄ•ß ¥w&ÚßùÖúÁˆú+¯UéjìÇ~1ÓwÿL竧¤ œ¦òZ¡9ãûŽ¢ÑÃAt7"ܽaˆEG'ò8õbíšg¾JÝ Æ'ÛÙÍ®På þFµò ìký¨scywÄ]Ýí=žæÁêuxAñþå}õá8˼ØLç÷½²wÍK¡GÊÏMÌ ¼Ž×+ͯ<ñ«Væ:PØ©·=‹²€y¥¥·9Íh/s¦Éq\o|ã;ðºßÜB¹ý‰Sõ‹#ÓH ñçÉK¿¸¨u °ŸY?+ ~$ÇXjñB€‚!)nkê~gàÃ}#·#æ¤A¼l=V$ qœ£³¸7 ÉŸ9P¦)%¥÷½.ôÞy¿Ó¡EšévTÝ™›ñé lÈ«öd¹î¡©Qï½CÆtb*£xg=÷Mп·îVô { rS§t uIï W'ö•~F[—Çæ'ßm¿b¸  ø’0HÀ„õ ·Øf ý]ºçNu–‰ C—S$øÚÛ»˜Ö Oºcø)šNKAs×F¿ýN-ô,õüC‘-´1‡užzF5y«}:益¯·òi¶`ÀxEç*¥™Éöâ!p1‚Y¬å ™,îɇ+"DP/î(Ó'tµîÿTÍmdá0?®×åû_ƒÃEÛ}ßù¬€Ížäøñ¾ )å—Ý"ƒUgAÑoÝÄ Ëõýgx'\éYƒ6ý¸~²CíÜtÛ§==ÐiöO)ÍXæÓ¡Saè©cVŒ÷z`öËØÕÆâÍe¥Cìs éif)$oD_ZÚNÓ³jn´òË=Qš(ÍV¤PL¿òwÕ)¤#ºk¦/Þ¿Èå¥Cõ[Ë/g¶Ä j ‹tWA:ø¢1:ÞÒ‡k(>^•MG„ÿ½k§„nTÅ9øi¤•žïU›z–ù!Ï­¡fÁµ·;@cÅæÃg7PäÖeã§Ïyî? ໩®‹•Í/BæÇBò‡¤—Fa3¼85Èrç8š‹ýV”³öv:µ A¿K$ž}-`›md½®X0ÓöÝØ¿Q)^‹ lǸ÷}HЇÔ)5ORè´‚Q_1ýU-v€gÑu©¡ýÃÌ”W¬ú߸†‰NT EAyÕ�=1þß[”¤÷ìãÊ¢J¤(ŽV¤1,_éÞ¹�ë d·]@æ9_ØÝí·^ÞYz.ä¢Fí¾Ìü6óáï8*OÊùB(Ô{J€L~‡gzA/a?:]Vsõ=`!]ê‚BG£ª… ›�¨i…šÎö }½íŠ¸5Î> êMÖ³íÀùŒ?‡¡»³ýŒ­ú†O~ô˜z”éº,´j£/µŽÂCgÙÁIï”÷Þ°žÑ=²-¾ÉÝ;zHriåEv§sÆ­¥¡ïÎFzçÕ|;Jc_‡6”}Ä°jÉ7è>b±RÒKQé›Ö ßj.fozÿò†Xiq ;Ξï‡ÝŠïa‘.4Ýå#òH'¾K�²Ë-»ŠÙ™'غã ¥ÊLrV#iöcÈcyJœÛ,Cûëó +´þCg” T%£7»‹bt¡EedœƒX@m[›½¨,}8t,v}f0÷Uðôe6¿×bKà 5ŠÁs0|íÚS¿€¸fU–™#–YŽ=°ñ§š*b—4h'OWlÜQ× ³oU ž™RâDI`þ®Ÿ(kË“6s¹úÂÀ½5ߨfÈ3gKOÕÏu¤µÿµä„çLôé“gî'lžûâú‹Q©#×-r^›ŒïÃxô¹¥^±uܬg”›u½Y((`ânÉ‰Æ fÏÐ*ì}ÎkdtP¸ÁDû­Ö;(Å3ßm)aDÇ„?æ·×ïb¯ÓÆ ƒÈÊò³·ù8]Wut'…ˆù /Ô¹paÞìiÿ%³i‹ å‰ù—ÞRȺÓ'}Ñ"ŽBßË €›}DKvØks‡îî¹o8·Rl›úcÞ¾Þ°hµ§aú<-ì˜ÏÎk¥ö¦=kÚÚàŽcÄÚDòÏÜ(wÆqª¢cU«³(�ÉæTÂÌD\–ÙoZ1Vx§2ÎVÐà.;eÀ3ñ‘Ö‰@¶”û8ÈDô7JÜ©7Qbžk?—,­ÙfšE¿ LYyÖLŒæÝR´N6¨fJ¥1ß”û.{æfã ½t ‚æœ?à\x<Õ·kG‹‚qÜ™2ŠÜ"ÈäÖSWxWkÐQî1öùžv€kÎs^­ÐLý&V6^}2SlìSY8Ä&ñ””±b 16½ÕÅ8c…ÁËX^Uñæêip™*J½µQ”JAšø(óÀ Æƒ´‡/WJ»Ù«ðÖ!ÊÒÌóÁ =3Ë iVüüft6—m½™h{Ašv’cë¿OœŸ£ ú-gÝ›%›#Zen…ÿ㚸ô§Ó``ïó ûÔm¸îkù a«Ì'P1t™h±žOŠ¾eƒå ¿bÛM³¾L{MŸÅ“Ç“Ç+í]Z¯KŒv~ë COÜË·LԾ㡃Žcß©ŠÓ„WâïðÔh›¥õN³ìXÐÌg†¶½áœM_턺roTˆûH¤ U©3Òöÿ©¿¯3E#?üïsª ÂDùò¤2ªÜÅé6£SL÷nê÷«o.9!ç‚Q.•²;{ò¬Çúˉbÿ^S1Oœø _œFJËÐÌQo+£QãÍ102\B@Œ…ÛÐê¾ù )sphårÙRªÖ«ØEÌÖ¸G¤ ÔFRz/õ~’„Ç©=–ÐÉ)‘(‚´³uK i&ȱø_*¾8òl•KÆ…ï0ˆhĊ󣯡æt>êcþè®ó§ãC°;”Ó0u=°3fJ˜k{ðm¾©"½`HzŠBÌÓ1v2ڮȣÿ—ìd"O9ŠµêÛv‹Ÿƒ)?®óõ!ˆ”+¢`4Ý×Ýt2±šƒ!˜’JI*-òÎ*ýŒ'¡èà³x™TóÐÙ:��ø! OÐÿi¾Œ(\¾U¥erk\wéÆåýÅŒÐK ¦3çãòK’ÀݽtQHôÉ zËúb‘Ö‘ØŠŽ!q¬O§^øˆ/:“ÐçÁ¹FŠÓuñÓäKHoêëwN4eÊø“pPÎp¿BìÎZU·_ñ¾¤]<L¬=°uŽ",÷¶@`ƒòLj>(Á÷1hg+;Ó¢ ´^û¿nJIŸêÀ„>3WE+ê%udµý±p8u”ô,’!mñb�Ò¸žì¸jã<óMUé1ÑÐ@€¬èTGÍຬRî-C»µp5Vß1‹ŽB[µ^ï%XI«Ò’B+SN´B™XSI¾>vß‹¢Èu8\ßQ¾h¨ûåòo ÎOv$ZcDIÞÌ¡~tXòd®x¹²TQñ~â-£²9ruŤƒ¤Ú²Å BB?iEÿÉT™DHÒ¥¥ÄªÓcg¬?è–``vèWÝY¹íú9_²D)fEö¦¡‹]C ¥wmrFÛÚk¼ØÜwÞ…³ë‰=•Sñý˜ .øåt!u6qPµ^zŸEš0s2³ZšyÎypD"aG¬Ö*‹Å5ÿÛÌ>Ês'Ñ[òÈïHK¿zWÊvØ<b|c ë{º¢ºá½X”eå¹”1Fúø‘ÒÛ·µ5<¬Ù sqÂnÇúÌ 95·ÿ‰%k¹@(cS$¸6N+’�mD¨�ÊØÍóî¥VŠIRdnÈD±l™bŒ,M¥»ÝÃ<{ÆKûúŠ*‘¿ž ÜäS®yÕ–3E0:;Šö>�_δ2еƒ¬›ä†–õr÷êÎy’8V$s:Ç"½Y3ܵ¢$~öE§ñúêä3MJY%¹iÝÓqE·dœ˜Õˆ”Æó>Û½‰{†wVÝ'_¥‘ÛûìšÈ$í´µºV Ñåoõl—ž’³“p¥nA[²)¨4¬Õt€.hRêØÅFÕýUZ¼Ï’‘�Ò5çH ÷² }è÷Áü‚™²—B½BÜ’ûmO·¨Ub ž˜lǶ—¥Å¹ê2G§&¿ìŒ“LgOÖ�áÔKÑnqî䬓d wÁÊŠ¶zè°Û1-å 2ãL?H¼Ÿ#w=åë#‹µD²­œiåÕypÊ(‹ú•Æ\ž;¬E†Íº¯‹ ê¾T!=á j讧q1·’ ,ÍüH1( £$rÕ7Ýås£w±ÐàÃd–’Áä÷XOµÎ!¤Vcéä{ÄbJ*ËÒÕoܤfýý’=)#Óoi:ŒÍy€¢ãNf\ΫZð‘°-nM`gï‚sa“çÑbAÏà ùÌþ<7ìIÞŒ†ÓŸñ ŒÄô\z9ï,LøüÁ^bòrX%A -Fœ ïc4ož÷6Tj»sTƒE¾GÜš¸0à¿òú¾eK[^1W¬ÚT¥ûŠña C”KãõêxÔŒTKù»Ž€ñèú›A@¤±¬‡/L£½Æ¢`ÙíΦô‚|vð39‚4¶Àd4¬Jòö p¬nh™{Aà÷ý…8Ơ±8΂òýì“‘ ¯«§rˆ9IÇèÔÀÚ×׺=ßêRF…š„fç"4§×wÅ•¥ÃÇc2)£q!Ðúô=³Ž¬kJ«å£SabuEWH¾>{�±À0ù+Ĭ•"@ÞzR"{:ßÒy†x.ï X³lå6 eØÙX¯XE;Å8Ó6@^–Æ­œ˜”ÈMœ¡mÒ¡œZ±ü¥(JÕ³q,~*îºò f›°K q×Þ&ì¹TO†Op=åË# “mVoª¹§÷ÛËá„FÈ›Ç>ȶ^èÎ,*¦ø[žSîMž¥3µ;—AÚÕŽV0œ­¸ŠÒÐS¤¬ŠïÈH™Õ‘a¼ß‚N–­TÄŠ §“ê³ñd¡ÈF_gç_¿˜­æy‘y,aH\R&RØn;ZjPyp„•MÏrAÓ‰euÜõ?HãÆ©/ƒ<Dc'¹Êo©Úͱ^×LRפby®f™³o¯k°§Æ¶;)×]r¤gh´Ðƒý¯þ�‡…C£jÛG„?‚!;Þ áaÛ(¬|µYà% (¹?Ûv'=úk?xŽÇ¿Mü«Ì¯·hß5ejE ÿdÆ®|x?‘d«žgÆ€Ø ”_&Xß ÒãµÄXEPÔv‹„vF¬OšnŠ‰ ×Ö‹ðm«'ôv ·S4aâÏ¿ºåÓ€Gì\X¡Ä¨™¿Þ;‰Ë|åuŒF*æûO¯‘hÀSw>h†·õ†e¿õ”ãl¤Œ¡¹Vp„3f9!W‡輪‡{öÕ¤Y’V}Wãó{˜#$æ*H>ܾ¿œ eâ¥Jè?¨r¬z_÷EtƒóÂôŽ ½N–°Méü~g«óŠð¦Ì¢4\_ꔲ¶ÚÌ[¹JãæÀ »…Ý4V¥=6 盽Ð!KhíÍ ÛçI[#”ð2‰Óê7ÓJ“­£Zl:zô½ °KeÁGä©O胷­“(“Ù$ƒßfÛ1 ¨†Ã±Ð›€yOw…¹c˜Å&‘£²jQ˜MQb0¿9lUwûug£fe˜®sR’2í½Ç@4·g´-(Bn” (õ¦ƒžÌî0®.!”â…€‚ÙÀ'úÌ+SÝ®çݯùmGš²i ŠŒK~¸½ÂÐOÌ©ô¢Â…"YsõÐèôbŒ.7†Í~{¶Dùþ“gõ‹›Y¹ªáË l¯.Ù:Ö»Ó¡³:{ÿÏ$,°{êÎÏ ÅÜÍva §4ȾtÚn;¾yŽ.Ði^`Ì4«ZÕu7ØWƒ Ó†&çiGK¯¹o}T¢Ô¼¥eH+½m´Ü~k$Ñ<;Ę8=ü.]:Ì …Ú×´'Ð0P·{/«)”sç 0=LÊlSÕVˆˆ;°@}í¹ £‰?Uó+3–H3¿euˆ BÖo;jã¹fùÙÏf¼ß§½qežK%ê ȵVᧈŒï 3GnâCRÿ×48[;3úV<¤KÞõÌ¡çØí¦Ã°Nгï<¸Éã:ÏB5FCe_ƒJDvÓ½½DN)ÖÆóáÙsPâ™85D†smœLéŸC7 µÀ¿cð9cé6¨©X ²IßÏ`ƒ~ æpÝl›@ÿÏ[݃'usukŒ§¶_¼Ô- .«Š“…o?[ãåZ^è:„üºöL¢ù WÙ`öpuéí÷UV€ã[øqìYàšy 3ñæfåÿu…È¥„þ’Ž—DžÖO‚žð¾N(7·*•¬¨€s[g¤?å Ö t¢ð ¨=·¸†*®ó´³S”çY`™ùÖ¶al¦,HÚÙvŒþ‹à.iõ³<ëÅ4^ï¼Yî>+ Mu_”ˆÌ‰[ñ[ï½ýB{÷ÒCp¡ÍX9U³0\IËQ¥�™ôkñ˜¯”LŸg³U S…Þ¨ŽiøÛ+l?´ó-¹ ú3”¹@ÕjGGä)PY|—¾£8ä‰ò­fä ½ÍŸ‹%×Úw¾é¼öÆhø¯·˜½ žŸwèh–õS9XgdŸÊËAOš¤ €œ”Û@¿sà®èU¢•LV5QîZŒÒ1൙œÏ|ªîpäkþB?0öÕÜÅ©p¡¯èÔ’¥�ñÛ ¦LqÅñg@+hcôe�÷¯üR{´ì ”)¯V ì‘ã×sl»¾5{¬b§‹ÓÇjç:é‰CnßJ¹ýÃŽÏÊ•ðF!£t:¹1¬ó¿y}²‘zÒ_ 9ì`{¬]ƒ\U”ö,¤–6/”õš=úÝâÂE¡~SÉÍ÷bS›™zËð/wKÂ=×Ç÷eËíÀÑÉm&§dqÒ¥oœx:cgÔ“H/˜Y¼“º;ú¯ii;™sÁáDQ"Þ*Âu¼pC.t4¢BøšYuß»4J\”vÔèæxÊ\¹·VXs´© ”ÝzÝäÁÇ 1φü0¡?»ÐÁc/¾#íJopÅ­ØÍ}^ûê¾ûâ¡zM9@îJÍ ÝîíC&šc¤å¹+23‘ *‚¨ÖE‰€À0"3÷y¦’œÅ+»D@ƒ´Ôz‰ 3"ݯ3ÙÁÁIšûøEPš*% BM#Je19þ[d ÇÐ×;ÆÆ+£ ´?³ZrŠK!e[küæü/OÛŸiêÈÜ–gÑ¢÷}¿`^¼;°N¥ºîJòʉù3Õ¢ N¤w/8'“< !ì•c›Q¸És’ù¤²lÀýÃÑàðÇ— ÅÿMú½Z¥tg6G ëÙVC65äNä6QAð~6®Ïyaÿ'èásÛ]Y„Fè°å‚þ!ŒIe´caIÓâ¶5ü3!ŒÜsÍa¬÷i¤Ó³µœú §gÚQ’æâ 7|DîýKílÊÙÀý¶SGÁ£ªK,Àa).â¢'Ñ ¬ìMšV¿ò®’ÐÛ©8›éŒ«ê­7¹¨—¥¥¶ÝB‚¾cƒ’8[1ÚÀפ-¾­˜;ÆD”¥.s@kI;â´·Ãu0ÂÜè,㤋„˜xÕ)Ö*ùêW>3 Ìm­š³—YLû±¥<§~Úš¤E¶R¿Ì«j•£²§™Wɦ”ü@ÊÖFÇK݃HòýõV:µÌ|‘ਢpFa1©u%AÚ![#ߤ¬@5{–-.4¬‚„§ò±" ¯:Õ9 ÏO:¶¥™L I£¢}v&®=,$@‘t}Ò"F%-! ΓuN *ë‡N}Ë•Ò½bÈB£7Á.¶ì´Ýå:Ð-bìJ{¹î®Ûk¿ÙÐ;<Öøße `cº‡Ë•ÿßt€¯’^9éïŸiùäVàRù(dÕ&?[Ë!8©ÁÕÈ·*¡åæ[˜Ÿg7d>–nIúÁ:@倂Šqf’³ág+R¢*ÝNBì¤ä¿£ÇòwÁ‡AC±èícœ¼ uåÈä…5@(ΪB$é–­€Ñ—dڪȵ8еuÄ”=¸æüv!ao±­�ðîöœRQdºmÓŽVgò¥p嶺Ïý¡;LäWŠÂ«mGG†Æ{%ý“ø]±¡e œÉåÍMrþ¥cR:È%³ƒ…¹h/8 ¼tþ÷>„…¦”%ºUÐô'L­§È3_75Ë]´Ü “Zú×´­×u:QÄ­ŠØUH\<7£×f ezŠ®¬FÅ =k©›:·V#áÍ`uÚLw*×8ôÆ–)– W”理O¹Œíù¾8wŠ ¿²¡”¡)hA]=Ò£Õt6·Ù˜½Ñl͈õöOâfG¾àq„.¥â±¯qo¤OxÄ‹{1ýY‘æÅ(šß=×£ÄTÜsAŸPŽRΤÊšÒ ·º”/ª­ååXÑ0j?÷N£÷ãÐ{˜<uz{ØíuŠÂ‰1M9&Iu>@KÇ€¿’¿<פO³ÌŽÈ‚¦O‚dW›µ ™­32#iýòÀ{ÐshODW¦ Ò“‚Ÿ3àËPôÈ]øNûn‘æÆÂ2Q”úÆ ”óì[F\<äf3î„ ¥=Ò×,Sã,óœdvUÐò5agº)Fcù]•+º tûS Z˜ÝZhîîPǪ¶ç °hï¶WB«½ÃHª<"/ŸfH‚¨U<jš×@öw¬_ Á“ô®îu³J-.J—èäÊt5fJC«ÊàT\Í/õ~¬ Õq«1ŠÆ rï•J* À‹…¡ãÓà˜ê—+&Cž½ÂKšÐn’–˜®H ’}Ñ4Þ)|¬)þœÞhðÓÊ↫\ÂIƘR©a[¯´“¡¿ÝѶ;«cüç¹CueŒ’ºWÜ”¥ÃÉšDü ÑÑ*Ë|ME4Á?ª kt òëEþaúã öuª½ù.òŠ¤Ô$TËI·Øù j»³!ÑIÙ$˜¯ƒ<à›s€eµ]»Ü2Z|¿GIºwõ�†_ºÎOÙ2; ¥§ÂeÀ’p:ëÉÿÍ„2|¿˜¨„¨:-¡1 ¶±ã:ÒsÁ0a»xWè ÝJÇ¿ZÉhRJqê8Ý¿;ŸöüáhiA_Ÿ‡¸÷ÞXx¢Ç[4{ŒöŠ`C%öÁëûþž¥¢;dê%T¡¢I¿ÅX³h£žßÄvŒ~²åPü®+‹ü‚,F;o ªàÙéÐy•qÏ’ßöâ§aDæ±À QÚ¥¤Òhq f5�béŠÑ¸"Žhx“ŽÄn;E㈠z6Ò"ßõÔKcžIÏ’'ŠQ¸f›â­…L�'’ð×o=Pi_ŸD¿·¼[�E(íçJà):¯ÌV.(%P!“¬›6SAxC’³ˆ‰oâò‰7Çàî)x“åË!†¦î`ëOq÷ÝÝHñN¢ð„‡„c>l­”gf\‡³ÊyJÈá8ëTôw N+cYßäž2·è<{ü* øŒvˆˆ6ž%}§ãŒ¤å¹MLªò'…1†°X>é° $VŒw`¤ïCe1k•#’tWzFZ6êÊ"½Tˆ³ï8V»‰éUIô©.ITdþ\ nòe·÷jÄ}w:ÕÚÚù­‘¼mÊdƒ Ð#¥£Åb¥ €1tlLøQ 0—·B3¥sq•…Égµª?¦9wóƒ-M<SihéJAWyåÌÅÜN¨‡þê9Ñzœ0=JŸÿh ÒÅÖ/‚ 4Õ’ÅŠPGs×1HŠÃ¼Oÿßÿú‡£ÞûÙ+L”4q;‘ÍúúMŽÖúRD˜ÌLéÔ´¿| !ÐöÜc ­1ùJõWdú¡vŠ8UA2) <m;%µ€ìò#%Û‚†ÄP&fmȶç©êöQ@À0P3ž¸˜gƒJ¨ICø�Q¾3ß²Í;ég²’Í¢"xÚƒ HÛMÂ1ûo³½Žé»+“oª/L6¯kb0-ßÌiÀƒÚ?åA8Ô*…ÖÏòöÎ/ÝP©*´ãõëzÞ¥i¸õ{a¸E¼Ó{d,*9lP²Ùs¿xq>ÆXè1#ãa”ì¼L<åh/Ä_õÊó|îĤ»•ž°,G{’[h[R­˜‡!XWŒ¸W;ðÇÞaÂDA[<Ü)žÐ]Ý.ðÌ7VÈ%ƒ…'³%¿ÆHá[ëËË˲¡ÐÉ”·—SX›šsý3%¡•T©<8pH §¯jd¥ï>Doÿ±PJÙÚñ¢ài8Dù^˜Y6)koš‡ø¼²pÇNÊ@çkÉrõΫƊl飠í¦àŸskW¼?Ÿh)³¼ ë¯|8Ò#·pšmCê¯ãvåY æ8ƒOS¤Í^4WÙQ ã,ÐF ö[4 Fȼåthš¾»Ý\9Ö !Ö{úëÍ—«št¬† kKð]þÝåX"Û#샳Ãö‡¶=0æíAÇ=ø !KVÆbtŒètd•5Â뿖¬}«dt«hT8˜Ž¤ s—Ñ©þ×” Œ×¼n+<ñ4È+¿g…Ân%½ëÉôW“ªk·óS¿Rß «ÀOÉçU ˆOÝ4Š€&ï">,Þ›ÊëZp²™(ã±¾êð!­Y€LÚX—šÁ öõ–'©SN‹Ø c ]ývçëçÀYzÙƒó¶{)B+?9ƒÚ±A¶{WQ«Èt$L¥÷ÿÆ]vZ‘Ò£Dg ƒ¢×ÍáÏRoŒa ­Ñ KعÄ(rñ!‚1²*¡‘ÙŸkä õ§É@ üp¬œ§p àÚŽ_Œùå}C¬[ê¾—;?¡Uš…¾y¬(H¦6C\Ö¶Á`Þ"{Éq)T%†õ-Ñü*ñï"r¬bÒàCÍZÕ¦á/ ËwkòÒdÅ"²J#L6 š´ÊÁÍwó¶ë ££ væí(J£GL'ïùmwaPïê;ÏOT,ÝÂ4h(9¦³÷æ´0!¤ÃwF:aRy3 c£çÍ·´½G‘qçÛl“œÕ2M韰h¬ÆÞwC9šñ^`}Qs¡ZÒbãyNÓ–4]žÆ1w ƒ«~¿øVtezšgfȾ³ œ} J“ë(¾N ÁznTžx¯’ôj€¨ºÓlQáC­z¾Îï­üˆíâìY×#ÎÛÜe‹aYOq±8鳶îâŽw¸âæÚ¢²ËÑ&bÖÒ>ô#egO2ê÷Õ—ç| 9É�[÷ØjE!ÇUè-xÈ™¥ý÷0üaŸw±½¸£Q•ÆnÃpß(@y§tÉ‚÷Ý‘ÓTLê®Y0aö®¶|°Ké È'‰öQÜKfüŠô½õ™]O¿€ˆ{ÖgONã4Ê|Æ2‚ïÐ4Øë0Ûöô¡“[æ+<� £è³§‹7Y£?¿§"j»X8Ú‰Âè‡}}dIŠlÑ¿@Q`Þ?‰Ó¹taôU¯¸<ྠퟰ®Ôk©V–:*\$f# Sñì®?ü­q?VÜܤc­,(r#ØÌEìÅmNû(”‡0Åû—6˜ØÀ u ÖÁpBù²ÎRYJ ÷’Òã»´ÒÎ%P´‰i!Ÿ4¸¬m"é²]ÓLEøÐ2ÀÅ^|GS&‘-nÄó2Ð!tšM¤MhßË ¤dÏB4×l«¢BlD¾hõ´hÛ‹G§¡¾=Û瘯ÈsÕԗʽ$(/­š;”È1–ÍxÖwFÍaæï¬3ñtzÅáÊ]*<l¨ °ÍD+߬ÊÙàÁó׎z¬î%’ßRJkž¥¨Òù -{ìÕMTy¼MûîЂG9IGÛq`@Ôu^.WhB=àTF±E:Ê¥£ˆÊUÅ9¦>QYÇ ´º)ŽÐFxf͆> Ž*¦ñ+¥E?9¥SHz!}…S©l)Š"’Å.ÓO }™—·0aþ@DµË}CÏÐeÓž©0Sàý?¢p;?"ÆoM{ÚºáקɿcŒNûilÖÜëŒìkBÏcÖ‡Õ%b+H¶©è­¯ž’~37ŠÆjÇQNàû—z.EèmOˆ›üDëT{]Êýùx‚m¹½!&A»}ý.0-€÷$Ø,N&#)jt¨�Å]};Ë ¿#r½Af½8Ð6ºŠ™w9ÞÒ ¬}ûþ›Éleôëš™[µSXB \¤Ðq”Sœ+EƒXþàti§%?¡ÇÙ4´Ò§ÞÉúlƒ²¯/ÐÛXкí ŒÊ¼½\w4ïb°ßØSU1MÖÄŠ¡—t(pØž�RŸ3àÚÿí¯‘¾ÿä¹ö…M'T]ÇcÖYÕ/äÔGÇ ¾Lá'!âX+ wÄH[=5EÄAôe%ú…ÍC±ö,LDïb+iJLÛU<`ñ·~ `&YKÓŸ{VÑ2¯Çœ¡wØ'qP.Š¸Ì¦ý[㼂¼OŠ_ÈP¨µ‘•íU1B×0ÑÝ«±TdôK|»íÀ{¯Ö'òݲ‘_ÒÇŒ®•+Lk_{L÷g?s¹( ¬Þý8kcë ä˜è ò°¯³{ñ‘Éö½‡ÆÛQ$ÂOz^5ÉŠÞúûPÒÝyn~l¯íÙþ‘¡/€*ÒLÌ;M/ø¦,öwìø«ý©ÓcZºË‡+Ý¡f$!gê5 ’¾q‡)ðWQ…4L×2Ò×4zô{­GnÒø Æ–E�åðÝpø2˹¼±ˆy|és ÙHRíF²Pží‘]AöI þŸCICÆÌþl±ÐÞI:%ölö×ÿÖÃwì„Qæ,—é<w±?•—!k Ì»ÏâÙ×Ó«ÐVÞœOñÉi¶––ÈQÝéIñ?±8¿ÚåñŠlAá\¸Bvê`&tRé;üµÍVÞºÇ1ª«ûbæ_|äa IwgX}cP2x»î…^#3E¾ùlÆl#,a·¡m‹W!L=ÎÂNY»u³@\åKïrCzl87;‰Žóƒ&+ê5täë2¨¬WbÄ­½8Óýà<ërhAæ2/·cþ8-L>(´ö*c”R “7„¥µÁUœù„ôßN@»a?™f•-ÚÄœT½²³±5 ¸±„[fžØ23LØ^y Q74äObæ,r¾Ä¬±£}[C'þq÷ÑãJCÿqQ©*ЩO;zç¦�³‹ Šør*ýÆfikª›Æk,:�lh²å2bOû–ë³¾£í›8ê(MÖ€¥SÑʶøß<1ú³ms‰qtÎ0üÑê";ÞhƒrlÔ Œ …–oÁÏâü¥¯æEacèhUT'Û< y6GËMeþ‘(n'€ÁE;RŠž3’•ì\åÿžH2G‘gOìóËP1냳a`}ù2é³8xLîýó~X]Ê|}ÒH°.µ¬±‹wá‰YE;`B::lŠÁ{¡¿–•™¯5G'd÷•¤Œk0’»š¶TÇ¢ÜW©0ݨ`f¹é>ÐØP-£Ê˜SNE)Û§õÊU‹½4n([O½b‡!&g:È+;‰Bd�³:Ð[ñfâÇ[q&Ø· Ì|¹0´ð/t+¶ Çn»7þ¼s°éÚZ¥vãˆìÍ8kl(¥CÊ�Ñž`hÃÿT®\–áëÍqgýW¡A<Òæö¾šº2�›7î¿`NË↧~¢R¥°–i 9s®Ë>¬Îæû…eUä™C}pv> eò¸>2„<eƒôá >Ï¿½ƒ‰IÕDB†Q|ºPì?¿[|!w3 MŽÜ´�)MÙë#P8wÜì‹•^>Õ»€ãvöŒ9<Äñ~/ò�‹•j …똒š¯­‡¬l룣þ¢4tb[¥™`ZLÚ·Œ³èfŽãî]}sAH¢,rÝd&lá`ùº“‘ýß[–½ý÷-+Œéoœû¿Ê.ÌÒ44æ"6SùoÕVÈ7n{¿Y€¦ŠÖH¤”ؽúfí+–æÎû"B µƒl2ôžàb;þ=[û/Ãæ�ÕMÆãX̨´Ð2mïJÎÂpÉŽ- ¼6Ó—¨ÝšóÂéh@ýYŠÚiq¦PO°’‰u¸ç¶&tUV‹¿âÎ.Î3²ÖÉý`Û£Á4oÛ㦮}°IÒ(ôM+hwoþ”Tž(šRÆU ß\e˜®2Nãu+@Úó0³l¸MÅîXGó÷$zP lf'‘OÛ‘2d]/ú9‡…õsf•¥¹¦¬)±êøh=A¼$\ 0¦ê„ÝpÿR)ðëï¹7”zÐA ¹˜ŽE_ïf) v;OPà m#YeË›úËI dІ1¸9Þ3‰o<ÀkdO)gÒ+�@0îèx Ú´öǢ튛:éË#n`­D[00=•,êa¤„ºaSÓöS;Y“"CÙ,£â_ŸÆËu6_‡»# NK=9©Þ弜ÛÃøÿß[Éè¶+ö§¢ÈG¤²i6ÂÔÌ5£dÆbÞÖ÷lÕ¬Á2ëÑü2˜‰H“M,�g n¶ ™ÆöR\²Ò †rjëÓe Ð0Ïšü+ÚÚ‹¶Ê›÷V�·]·w§¿hô.°âÌäƒJÃV{7GLRiá0à®í7 ©8‰}0lhz+åûÖ¤Žõÿ±%*½ÒQ)RfšICGÁtñ<¾E-ÏB‘ë/´W† Þlôãï¯ >‡›fs¡Ž£•AÇ;Ú…±]ª1¸n|nضôñn¼ŸØH˜Õz¾ÏÚmOÄØõ•tÔ'Añ¥Õ.ÐÇÞLÚ< 8Ú³}î¶ü�ü#¾Š]yd7ng¥iW¥Ö‹æ3©ü9µ< £’0 –O�Îz“òg[ƒhÊ@ð°c=J#Pg™ ÎUèÁ=(°íP+§³ Ç-1{‹öÀ2eÔðµÅÈQoat£êùvŠVž|Ž ú¶o½Ö4wÕUø%†nåˆ4øÐ Ô¯i•ÕÖQt˜©8áµ:]k²ôNÔ˜n�âËëÿŸè?UáwFПœË ¶¯qa¦+\þ+.|:rŒˆLoý9x«.½’|E¤Ã6ÔçñÇúHçÐ`gºèÂê æ”£“¤¦Ç"zQoˆŸSÝÿô(„Úkq§ó{ù¯‚²ÐwÍ)Ø/' àÖ9†Y)ç/±ä½k>›–Ž2"jPÓ.†áìx\' N tfEÀƒÈ—úFøÈ1ó­›XŸzVÝ b1Êz�= Š—©¥hëÿZzßð3­TwNGp”­æiŒxÛ“Ó–UrF˜_A½}ÖìûnçËù#4˜QÅ ­~y-¸;:ò/Œ³ÊÊ7Z¡Š¸ïÓ*¨:…PZõ¶í6—Y·(�mÏ¡5_:«Žu;îüKNq*yæ݈MOäŸ;wJ®ÊG&‰1GóØ›'Ê­Æ•Œi—‰â ÔeMÔB7yœ=5ãYÔµÓÙ÷·ºktU˜!é|¤OgåX™˜ÀbgÃΕ»yùŽtN€WH¦•½]Ì -¹¯oȶн/aþ¿·48‡å-ɪ =·Ó¡sswž;­¾FŽJÆLl€v O^Zª»6LƒiBËröˆjS=Ì€LÊá¨)eXúúrçVÁ²8Thã6MÙ.&²¢ïãÞ抬¯s96ã/!—¦¡më· ºoP5¹÷#˜…>o2Á°&ÒE[ß@(÷ÍGNÓØœçgÃuv7Éh…èCÕI³ótfý מ~Ö ï³¾xí‘MžéIgÖ(ã):¸©­ØeÏ!É»z¤†èºÄÂ"7|R«õ‹Æÿ¦¦Õx¶Ðu=ã•–Y¶V夓ŒÒ•F¥¸1ñ„ö ÚÓ¼HðƒžºkÂ=høx_ƒ§YN«ŸÕh,Rh9ˆjÙıø› /{÷e¶É—Á®¢>ÙvÃéÜ÷ãmԻϖkÿ¾»?ôt(scE3Ãå=³#" Ë)+6ž+R“fÌŒ8ñÕ-Ö+í©¶Oâ+1Éœ÷e³w<´‡Lbñ‹F}”­œßË`N‚ÊÔhÓ'ÆæÍ:Ÿ¼Ä͉SÝU¹¡ eù°’Ç!1{"”ìéžî”=‡ú”¹hb ó§£-_Ò-H[å÷Ð>[x`ób‘{Tbž~õ3‰¼»8û7iÃG~ª/bCú¤±d ªSFøSV áK@Ì<6TÌÓº¼ê»Ûj™Çþ°?ß“‹×nFY@'YÔ\U<n_/ÒöW4,ýMnlQ•Ùwžêñ¿9sƪ.“ ôx÷{è­­(Œõß®çÓTÇöðeL¾4#?>%¥Ï/ ó`¸P|rú'¬‰~µV#J/?åHYñmšÞeà‘ê8ÞÛs¿Ù—+áÉŒçPÙòé),RÈg©‚w~š4éÆů¯ ÆžvGwõhô‘‡ZY{]>³¼L­S\h†pÝ@ãÐ:0ºþ’H~ÄJó‹¾|ay‚õ9sˆé6·N�äçYp6/Ê*:ÂÄÍ­é`ïulŸ9Ø?ÊL®¶<Y Þ¿: ·¥,ÔÀôÏBn#£® 7z‘V—ßxw¾2‹‚bvRaÿéÍãOÁ÷ã@µ‚â3CìøÈ»×ÖJ32*fTQWT§ëÎέöà ¦L-³gÍëé<±b¹Õ¼(cCö­L§yž)œÆƒù•XÆÌ“°í߇jV|6ŒLA4ÏÅuÄ•lÝÒtKµ» ÓÄ<ÈßYÐk¥±Ù. î)ëb/_¦ð­ÿ.ÝÆZiåfçÓÝÛºþeýÐ(‹3O™”ÂôYPlGÿªåÓ£ÉÚ|xh´þî‚ÊN‘%IÄ0u£8 ŠW${µÞ€·‡ÉšáÍÑPI^¢LqßåÏY´p·=Œ™:\ Ÿž(Š8Q[ÓÏß1†êŠØ´@u¥ ’“ÂA*¶n¦îè5ˆ!ÄØ°’Þ½•Ê/X úþ|vÖû±ȃ|j!ßjµÞlÀ.âddõ'D‚ßi/Š-ÒöpT™ì0åCßµN¶ÞRó~bì¥. Á]/‚¶Ï¨¼íÜ:1ãdð›îs}Eí¾í»e¿o¡Â+›wé+9R¢Žh䯯X™ºÎp,û8°üá†#½I×%t²jÆW�$ћٔYø†}çÏ@÷ÝÀÁ.$û®Ç‰º¶õ«VàÐÕ ]úÙZ Pºá[ɾñßò®kÙùå^^æÔ r¦É+:ÜN/=бoéWì;õì;֮̋.Uâz  Îja<±×>&®7ðWÚ3Јó9ñ Ó~–ÏGñÊ…ŠÖ%«Q¥Å ÊÕj''=¦Óʼn#’X SÓõb0ÝŸVÁÂbÂr†ÓuËÝ9ôg(Ê]~^_Ya$ÑT†‘3&7û“Û§}gŒ;ÍF¥sl:ð&²`ÛÔ|ø_‘56|±}MEâµó�¥ ÆY`÷›{4Á½?=uùL«¸HÃÈÈ¢³ áfŸS€4¶×1êí-ì+%‚‡…ʦY|—ET„wT—O³%Ò„ƒ›} kóá¿Dÿ©JWx¥,NA#=L;ø‡^TmäÏÔžÏKz‡qùÝí,3°AÙ=&„ç“'±a†‹ùeÓá(xñ7 XÃkÎ e¼r´®Eó¥6Õ¤ 1ú Ek ¬$„ÛĪ Ü½Ï)È«´*Ì:‡²˜ØïÞcN<;ä™ë æÇwkK¨ˆ¯ʶL‚d;9eT´8õEƒå„¥w}p©<,ͱ�ð€hxºÚiˆ¡v–3‡-¶Z¹kü{#û ûd™é6§Ó§'´ü^y–ªœ’ µæE–%ª=Î7ïþÐÓ,™QìÇ3ýž¢ÕžŒ½üB®XS”ëÓAOíQk=A%’aûîB|KÙññÝ“�rvg"—änp(´”K‰;†<kH`êG'Oà²"÷º·y]ËÑDÿ‰uòª¹øc¸tïåæ¯GôÚÖ½Ù¾:Óf À\ÌõήdÌz$”¸|t+²ûï¸Þqú:ÿ[gÓ#¶=4Óµf~ÍÒõ³¤eœ¹ÌTÏÐA»ç\£ï(êݪ°j_(·Ê‘‘xèLþþy®‡å|” þ-V } j[Sÿ¢ÁΞ’TÊðŒ´lÒ‡V e4~ÿáF•g…Æd;:w_Žp8/ÇN¾:q´ød®y  $Âé »¡¯æí—ºåä±æ£n¬¶š°%ErÃŽi»" âúb8¬ªm@I6d¨¤‹øÑí*àF•K5rù»h°œb‹ÁZF}¯œY¤Ä'æ$‰³GÏi±súg´ežû¢tÈŸ€ˆšÅÿX5j%%Ÿ~0Q;vë±@ž¯†cܧÍ[O¾Þ9X=²T91 JJj×ùT³o¢y.t[9ŒÞvÂÃÊõ~¬H&gË0¨8Û6ólÑȮƗêÞ•²CGô€Í|*‚²»z®ž­ÍçÞ×ÛÅІük7¾©ÖÌRµüm*w†ŠÓ¤²o™ššp€ÃŽÍøÆI·ïzŽ·RŽQž§*õùÕ³´€zëö^hP—wžïV³¯•¸eìÊ,‘Âm&nH㹬¥b±®Žâ¶ ¯wp ¥ŸÐFxØ°†ž¼ósß].}¢‰˜V¾š»Eöà› «X€ =_VÇ0¯N}o†ysU!*²µUôØSª¦«ç'N{öàAmÞöýâþø9½áïΗ2HÏ:}Ž£Üƒ†\( ×Ðõ‡Z¾›ƒ Æ/p?‡˜RaX¹×Û¬'Sh.nlúÎRï·Ô)OKÚl/ØA•õ¢MÛôaœžÅ<§G;Â3o -zßÄÒ“¤Ae!áËüÁŒ ç²í{ªãO‚Y¡q¾ÐâΊ¿1ü­hýúÃô¶¹N‡þqw<ˆ[çWRÜÙ<+zWU¶Š¥så7Âë¡ÀºÊĬU8»¡n;Ó)Îä€VZ­-ឪ¿ö´÷Z(}øÀÁ_yì–¡L_!wvÚÛ¿A摾Zxtí¨ß,Í:Ȫ“ÆÉI_WTMkߨp÷Jnû³­•[Ž›)211’n¸ÄÛŠ‰ª÷Qä(ÿeÞ.TsÖÐgJÙ‹9FûZÌ°!H2ÖŠŒìq)<åˆÍ*ÅGoþ€ÙlGŦÝøsRù lü-\HVÁIÎ3Ûq´"Ìn"Ãü³0s®†fep„FMÝxA¯5î&Yì¸Ùèç¡”¨>fèUžÝe$ÃD˜«`  ülüß[ZèÂ_Jå[{ƒÅãÅ8ͬ§‡´8¦#ÓŒåE1Ø!WÛšÐP–ƒÒ !æsx ÝEè@‚Ö°fGÒ;µs*“«æZž”>ÀŠ@ó ŠgÀ¥»fª£Ò^al„›)¡œHÕøºÍ‡†ØL;’$Ð ¯5ªö®Îq† ÙárJ`‰uŠÒ̹õWpšw¾Q¨£Øhlz€t^ØsŽÒ¾Îh¿Æêó…Æc»îS>(b+¥1€1¢}~¶É©ÕiÞ¹;?öy¶U›øòU­ ò/u%kÎñðNÌyZd˜(öú„î”ÎON”ØgïrõÃÖì¯ptnÎ3=— ™+#­8Vô·£;C4Ä°3©_YºFV¶Eh©TFnjÚKmí%A*¦¬÷`ž:Ý­*`ÆØÎP°6MhXSª3Ô˜«–›¨/:Ÿ M•AX«žpe=B@D«Ø#Ðþƒ)G¦&0© !¦t+T».Æ:sMKÖ¬zÃo5W“(ôÅ)1&¤ž¶ör­?ü+ 2/|ŽݦÂ;æ¡mƒh‚'¨=k\Í\¾J¿IïÚ:áÿéŸ"<ªƒËKÆn:îû°gGõõŸVW÷w­ÆÝ0Q‰iJ‹Ê‹j)C´„ üL×|"¥ï®.W:ªùÔúf'[~G‹Û¥A²SÁWÀ,¦óÂKH#Yåâ¬^5û§z´`â†?K–§VÚ)öF-vâÿÿ¦f¹oÎý¢ù >mo>ϹØe2“©ËpÃm‰=V8?U Y)}rgÊ.ÜÖì\€ƒ0òì‘’Ú°T·çé›õ¶'þ*Ú+—*(šÖ™¦´½«ËFo îÀ,*¯À“NñœÓ†¶4Æ<cÙñAÔÁþ¯^º%‰í ±BY7Ú_çƧÏóPóáuˆ$ó'èàè.™-h+B? ‰7¦ß=ÔǼ¯ð_ÂAþ,ãâSÆÙ Ëm¥T·ª¢�:BRÖ>ª)Õàr{–íÑb:<Í-ïôËÑ¥›O´fåœ$ì}Î #äÙ ×Óz¶¡âZŒ¦©½Šþc-Ä+%cÑxÙkA u�Ÿ'eƒBE^’݉§/“™f¦| ~_~°nÆ“rb¬ûÓa1®}ÿ¦g•åá øk†`a¾µÉîÕsª9ž%Q‘!›n”îr˜ï¢±ŠÌ 3$rž`Û°xm(ÔÉŒ–ŽfW+?AÜ=&Vô÷oÎ3*÷ë31s±>oUr1ª´÷„ȱ¬ ^!Øaæ[[@3F9Ð{†²@j€&ëÙuKßøæÅæÏ…×g*±{zÐÑyqCáj-j°´?_\ò\f*ÎVàxZ£ ¼©¿Z/ŒÒÿ·WÔtÜ^ñNÎ\;ÉÖr^§)³’©qPVÞ¸ÚÄt~&U¡yAÎ=M¥æ‰uì(J¿/ž¢ÊŒ`íÑ9¢»ë1†'J ¡µFŒé/þÚÅi1O¯T$Vä±­üäk+ÇÛ^yî¤GE½é×ZpE,  9#øQß¾£-œ¾Ä„Y°·ºÞó ¢bpÍfÅ{›§=œ<ËC߇ÎÅŠMcªå¬IΑïtj·©ÞV=ß_â9“¨tÊ9rL7|­´¶Oâ*¿cÛõº”‘¾ì&NÉ뻥¬á µ .hË$µb2JZx[Z°ôaEß”N5öç[]>rˆ=š.T)—V» Mji½›âRÓÆçW6ÕOcãE/~©™™øv‹ë"Pôô±ÿëÀ7Ž½HÂÄ`ö}itpš*í ˜=f¥/ç„Tr¤ß€I‚VIŒ°€‹W\e׳©">£ÊÈO!Lk%ŸgoË4šKñÉ%ˆýÌ"„εå bdé»,Ì̓žráÄRl)ÙÛ�z³ ñïi;ª…ÇžYôÝ4Ô”Ž ÷¸Z¹n†ÌŸ?ut†$½ÕiÓ _•›Ðp‹1zÍ8 /{ö°Š–)‘–.‘/x–ÈvfgUÊì ÝèÕf¾ëcì2škEÏ/âHù¶ieˆòÎmóù[pN¥Ð]p‚:íÆç´·îÄÎHÂÞ‘',nÀY—š2ÞFoX ÿ ‡ÈútPÌ$x9ˆî_ø¸'£×"<¯ÝU-@ž¤âìà€Dûúƒ?§³6¥»™£™rÃG>q{Õ˜ÍJuš‹ÛœÍU† bƒ­ßÜÜá¤ô!Ø<üA]·üµ]«¹¹®Ü8àî•6ÿº†‘¯(û„–Iâé+Ó!-bÖâGv8q –O s!¹že¾l wFÐÎ÷‹çö�‚«%G±•wàs“×߸Éjil7 YÅ2iÿ:6 ÕbÓõ×–”�¹¤yØ—CÔ³Ò|жqª¶yó“Üv‘ù²„tD´ud§É— îèAx¶¤L“7uÅ·ë;Ï/-nü‡/5½ùÙÖ¨R+¶2º¶EL#<þãî‰ãÌ3¢b¬4=?TÀÒöåØB8…[˜ Ô‘®Å('6ÐŽ(ºXÙçvµÆ¢k†ÁöJ›¦ÖŒê7�ÀÖöî`ÖÆ9øó+ÏRBT(¨]Ìgcuˆ§v§Cmç˸Ý(r­bˆwÙÒ{[�¦ÁÖ=àûÞd |@ w¯¾QwsÊóÛç�×€îò} jÙÕ»¾› @š‘¦ó¾@™ãç�uzr>ôg]GŠÄÅçì‘@ÃÝÐ_t>á¬9½Óøü ‚ŠÓ=0µÏìbPç¼@¨îËác‡3ÝiE˜#³Û |ØwÐùÁQ3‰n`#»3ø+}cÅZ&ÅàúÊR¤.;mÎR8E„ï ¦y졼&Ô—þ<ónÝV;ºÌ˜6„îë/Äýv»v¹6KéiR',29Å ,"Üy;oYÉuZ)žHÅf¦Áv¡ói%uƒEU¾–ÚY>Kl"ó\G>¶(fC°vª/œ}pÝ?¯Øˆ1°´Ã¢þëÅÖSMwÜP>ÿiGÄ+ÇC.(~Óñ.á0(^{=€?ëQ¡7ç͇Š8Y‰é¤ë),f¥SR ÅS¡ òÞ”Q1[ÚhO0Î@¼X¨üÆU°L\-ÇŽÆØ:¥±“Ɔ¥¿Œ­ÑKšl©g¼Íg?Óª ¯­¨lzµƒ<™–c^I‹…†7o­ O8ï;)ˆ9q1ÀØ<7ÊÕ¾Xóóµ Jìä=Eüªï 5óårAñí°ÍhEî’¥h%ÚŸâÄañ…oB¥^kõ=!º×ÕûlŽhïLΠÊ1oFè ×&prtö"r¦Á" «PÔò½sôñ5.û•ŸÍS¬ sEl²™µôW5…}N‰\/,fß:ŒfÚÙ|öž]›oÁGÆ¿õz’Òi ^Ii”ýÅ®lÓfjÆÙ“…}=™HÊØ—¥G+«…Ýa¯I²à£DíÎÈFˆøý,ióŽ]Ý›¾Û|`÷3ì‘jV”šÕ/NaèÇ}PjÉ/™0ëÐŽ·âS=Ü”¹)É]³·Œö§ß9¸…‘â,) Ò¦Ó¾º5®ð€#š=ÊŽò8óû pq¤GRöVf¹”ÞÛ.l]ÑC«”¿í!€oD,5}ôgzÂÝÞ#×Ò±'äõïÂòU•F¤3ÈZGiÿÖÆ}S”ÙÂþÜE¹ƒb1:ŸU€ ËÅDh(ää_b®z®{Zë÷18ˆgUk‚Φ¯)ò [4ë7Cfv¢÷jµK€J¾£Dà…r1ñæR_àÜrO1‡ü}O÷ <½;ÿ]hUëqeµ+kÏ`3“P¼MV®Ê6¿‹d%ÐK ²w)FiHÊæõö°Å qöÌM'³ô6' ª' †¡k,¹ õ³cáÙŠ¤@ëNàRXÍjEþºüÁG3o'Íõ°s<»zH.J“lµ.â`ù¤jXlÖJŠè…POû<;5󢩧ӒAE¥¬•î€„¢™ìñA©sX¸!®q¼;qØ><¾¤;~Oð >˜¬Ô–”Jå—Æ5€qHöÂå_Ö͇fg~~{O¦(ÜÒ'dKñÙÛ*ãÿyÈ£…FÉÛA¶Ø.äIíÿCµ…j)W*g=™ ûiõ“)Ò¾wƒš Î§Ã—´žå‰UìB˜»Ae7 ªVÛæ'˜x/ †{MŲùs0©ö@uøß#´‹¾ÿä'ÍÝ84˜°84¢÷»žîèb‘Õð,e/ÖùÂÚ”Ü,´ ¸?òbÃ'‰b×™Áü58ìà:¥’à1haÛsßûXÆ—™ñ.BëƒÙ,ô¸Së´ £_€¢<„º‹.ïAÞFixòçIrã½Ù£¼:‡¨ ¸oXXð¤7@ã] ½URþxï’Þ´òF¸,¯Ñ@/ûT{˜ömt¶*ߘ,òn.e¾O(4M`Ïj làßÐÖG@+ñÇQí4cÓ¹‹‡†^UY„ñÊÌ6§ß3u&y/ íÛ[à˜7î6ø_!Ô‘|áQh{ŠHÈ=ËËý8°�ÿݾÖ<½gØ€1 •CyÖ½ÇýçzTgøÏ`ªÙê4¢¿w™édÞ+ØæÊðf'w&„ÑÙ„ž}‡t*óGÈþ0³ª"�EÕ‡¡/fY¾6 3gA¾ †}éôîh¡ý’kÛmŸêr *w­çåE}£råz†ÐÖÒÄ+äš¡v8þC(N<µO™´QZ¾÷Þñ÷áTøÙac<EÑ&‘’FXã..EÆ!j§!B«c†;¡§,ôH»á‘Cžânt_ç‚æV]Œ€ûànÔìÆ«Œ¥^P+-'nÃÔ…†›ªŸÖ’¶H ç]²ÂéhÖãËܤ»™}è©1Ul%ó‡Â±¥=Fq\+iJçSG:¸Œ½t?\WêqßkÓ¼Ó«xZ¼‡Ûtõy;:×Óí„Y§A«ož‰TÞŸÅ´r†i6»…m;3 ˆÃÿ<Ó¬[[Û@¥ŠK/íæìpC)L=u¿×÷OÜ_± jÙw:Ε%Y[­DÏ•ðþ¥ö&£µ‘%Dï ­n�£<Á·’Îbc€íõv¥õŬàçßú ž›%Kb~,%JkÃ-£§7%z˜6¨€èÓ›¥7‡ÕUw¢üE¾rÆË%ÝY^nú®û¶ òVÿ´ã…|¼"lëyûÐQƒˆÎñö€ÄíqÏ ñåž™9í¡(×6Á¦-[0*…NÇš÷Ç›¾ôû•sz¿Ö±¥¼ÞŒÊì¸}½_Ç©›²�Û¦ÆZ].Îmm;uô_H¢ÄõÖ©DR2Û—ž¤+_fVÿ£ŠÐ¦iÅr0h£" $LÇ«Àš¾ýì»`áä|âl¶0¾|ÿkšM8qúþJý¹¥³ŠÃîPŸ§oÛí·W,ÉÄY[r»·’ µvhI©æ–^­¥³ô3õˆbÓ‡±z>ã­½h¸Xð„U.±ÉuA\ èaŒ¨²‡€æ·¨~¨ªM ³su†¹ÐÂ]&›ñ'wõŽWú«ÖV±+qV> Žt.³ò(À¬tù²j›îÇÿ“ _R&.,–|ýÝÞ°7r½QDÿÿ¡oÄ^9rÂ?ï|†iò©ž¡P4EYÉÌ^}Y‘f.kb/pZ[ßs×#£‰'ÏèíÕO+D<¬=<íÀ jkãÆvªÝòÎ2XòÙÑîªo[ª„iEò¨ ÛüådÐælF‚£¢Ä: ²ÝÉšÛ¡ë®Àkãß»‚<`f5axú6hÝÌ=(ÔóEªûÔXe$±O_¡ÿ~…–Jj°�B³kë¬Î8Åø™ýûÒ6VRL$é\\¨Àˆ:ýû®ÝÑ(âÏšÿêŽE«•Ñ w‰–Dê;°‚•Ê«a»w†”ÙÑέ5qøidQ­ƒúÚC¬LÛ–G˜8…’R‰»¨åX¢Og�Nÿ¥k¯ -Áš6Ïp*‚ÜRÖ0ìíѹ<› 2Î;üÃ$¿<õw«~˜ô /ðÖ-®žÿhm-!ä£Lj�KåæUf’ßßÔçî@%å ͇Ÿá~Xƒg<X @öbÞO£ƒ[ÃmiŸ²16h÷ƒY¯B›«¶dyégtÊÎcg½±ä¡fžÁ1›ä~,P‹Ö3‚uy´é±O¨APþ0q+ì÷K…¿¤Z%Âh– j3{Í7ÀÕ†êKÔ,ÞDµ] *¥î4Yì5ªÐ(WÆ#¾?gT¶LL¶>Óq"ǽôÞj@¹%È 9$ßBë2³Zç0«(؈êßñdU_Ÿ/°4^Ù˜Ózê6T¹%'žÕ}˜°ríaÞ¸ù=ÿP(wŽ2¢ð7/ð‹ÿÜ›ñzë‰>`ã]·éD†Ø~æo¾ÌWìƘUsƒp©uh›¥Œ…»"H}ßíº[2û}Ÿªè?:?Î9ˆì`Ô#EHWâ5")Òþ?Õe•‚÷Å=€Ž½!ª­‚já{RŸ)T¯©Ìû«€U3S~úH”<‹C?1¢uÿ•å¬j/¨ý`JÐ[ 8:Ûú c½ÖØ6|«YD�Q;¢¾PP ð®¹t¬÷O­½–õ2y môÏ6Ò…ÈûÎ3l™ é¡§Ù«òX¾{qƈÒ#ÝþÏÎM¶}MËå(âW?0ù. «ÍÊØ‚i+#ƒej¬5•? XÆNŽFü„7GGÚ‹BpK§ÓÊÕš»(Ìó22 rŽ³ˆÀ»K¥D”^ö•ñá2•AvºxvCË8ý±©ªe=¥U~¤G¤…SCÔi±‡Mq@4…†ÅÚØ éhéAÊ›â4Râ›eÙ6p`:v­$ðÝÅ<‚Ñf"r ‚4i¿ß|Ç£pW—¦âxCåÄÞâx„/}tÔ¥‘ 9£gÂè¿[à8ÛȬ7—Šðw¯ Hõ)3„!Õbý;*ìÿI¸Õ¡çÄ$3…  ‚'J l€þtøÊê+õÐæÀ§×kó±ŒÉÎLâ²r~"ŒBv€f×­£"2P€ƒh?^ZùÓ­°ê�IþÓ Î{c¼õ­æˆBS­v_TŽ&³*y7Èpuú{l3É/øóD?—6†Œ’t)N’i½t cÅà>=’FÓþ§fΗSY<§ž–bxm•²²ÅÖGgçÚ‡?וX+þbûÙr >ªŒhÎÉ»Š¿T†œTM˜Ð½¥ÄÞ›8›¸%RÙëw¬×wŠ¹Zhbv‡—Ó’Î\`\sÁÆ7ÇÝd?¼Ã¾köê Õ7V'yôSG«çî6# òœí‡ÌrM!lÖæù±î:¢_5¥‘K¿CäÝuÑy¯Ï]ª¾½X^ïÈG4‡wïÒäþÜ)- w<³ŽÆpɃbÐ-W5ÖÞŠûßå0VÎY÷•ŒaÛR\Ü;sO<ˆ†ï¢›{Q»\6gë¤õw™:Ê©õ…»~fa—ÙÄ’>Vì´é:IsÍm6š>?Iû¤ÞA'>옺f–ƈ×Rxìk› ݵfyáãÉbœÈiPí[o@`Áãzw |·ÌËÃÓ¸ôzÁLtÙŸò ?_LŽŸÄb½Ø×†É Q[nÍÚ ¸™Ó“JhóqtªmüâKìô,ÈZÕ ÇïÚn™vA¾Ï´0|=M_XÓçsV>%™í|ùÃZxëe±”´¼©ã6(¯g7zmº<%ßXÈZ´Ú‹[⟭C 3ÒvqïçoÖ×GH6é³óþ»ÔƒõùLBhI@PvªéHNš¿°1�4Ž[ý€ÝxÖF翇á¿[ôæùÎOÜú¶"&±™¬n¶ID“µHŒª#ZQB•ìr=Q4oýË×<¥Ìž2]dV̧›Y¹u‡Á«œõ×ËÒ Î.ûû+òÆE`³E×£©!›PÑÔrëI/=\éýbž?$Tšš!pVlàÕVºÊ‡¹3 ‚Ȫ^%,M(åŽIŸ©UñʬDC£ø¿º•«Y'ƒ&LáI;![õBíMÙs>k¤B é =¹]Àýó=×w¿{l’äc¡¸À=Òç¯vi*°ì\7t>šæ7}ùÂ#Bp[~®sú;u‡Ûæ=+v.ø¶§­ÝÓQ<ß.û·8Ì ›«{G‰w™ØY„ŽUyëï¢ÿxÎÖ<ú¢´'€ö1èÜ6 E¶ép‹éÐoi×d¬ê ëƒ:-2§…Ó Ú+t‘}6ë/̬i9„ͥµ· «^aàÖí! Ñ°7)S Ë$:÷äàüI)x"gp'…5úÇ t¶û?…¶¯B«6Áªš|{ˆÎOV§¢6ºµãtœ1½4ór'?°R"H|ƒ²\ Ñá ôn¶/>WG¨™‚*}ƒBÚÐœ°fnç—°ŠèZ0IT6?œúûFé¥CP†lB8I¹Ÿ<ͬÍt>ÑS…»ö`tñWÖ 1bBöÕs¦§rŠKb–b%kÖX`£[å<ÖV(WæUMLTÛL;O˜†ÎŒAR\MPœgÎýËÛMmÅ1”YÈpØìSõ2v꺓ý†MÂÜuN1½©¨0Ü»ƒyÙó0ÜÞ¶‡R:?RÊ}oKéoré°ÀV 2‹‰§¾çDÊ))– ]è/z‚³w¥¡E ˆ‘uFytž&Mƒ°0ñˆ¨’|‚ o,ºÕZ}>&iÝòBY¸ÔR¨ åô}B•>“^ˆó—»U²ÀY½E‹‘áé´T_ƒ|�û¥ 8x¢ ßÒƒÓAù,è 7ƒ’ «Ø§½X„¢šÈ¢§}vÒåê�£¯Žá_ÍÛå•óáYÇ}çÁ¸[áñ´ã�>»ü0™±2…‰A¾ÌYPÕVš8¥°w¥ç ñúÅ3?vs$ñßl :—ÏÖª¦4^ªÈ«ûL¿î=H*·éÏÃË™\éQ/YU¤i#  ¾eˆ‚Ápe™3œÖ¢GkXH»öâ]ÅkœgLÖš2&#™ì…×±¾²—Ê}m*yXþF–FI`™7»l¡­Öh±)ØÔI0fæ5’í úJ4ÖâAä,W#¦” {È[<Ph’¢Ì^~?Vl]ZÚ ›|Gg-¥÷ã±cÃ)J«w¦l•²¾{[¨ÃE‘û!ÅMC·f²³�Ž"e¦ùª0ôôÊ|ƒeX–ЩŸMV:Ï †€èßCçN^Ní,ÕQ3"PúÓÏÞSP`ÕO?sy™Ö_†¾ñ«Ìi¿¶Ú‘v°µxÌ­“EDMžÈ»D C/VP©ÄÙ…n>§tëÍD2²:›rTgÍhù¡žyî“oV Ì“qc[á Û¼Ûz‰Ê|BÎ391^0ÿ¢;cñU¢1Oi:Ò"h[p„#Á׺yaò‘úBwLòl@MxRϾՔTw­4D.] ç[û:w´X™’ís2%Ð }”žôHU —JÎ`Åtã{%üïꛉޕçŒivÓÅhð,ªVq‘i^+êûµÅÅùÊ×%bUÜpÖsì*ýs‰Q0÷ WªËæ#e f¸ùÿü¬¥±ãhq'w¡b¹š,‘ 5â�¬¶Ü§j*(–ó`ø(êæceTÅRfÁA#²½´ž²«v³ÞŸÐ#«ÊÊ•‰JtSAýôK-Ž(õbUêHë§aíÎÅw¹ÐÈ€—$û d_ôYO”R:ÈN]2`q[;“yœ$Ei–f:—‰Ys¬ÈF<$šé (÷âk4õh;ß»½v9£²t[#«ÂǺj•nÚò9Û.Su€ùž1ÇüýW‹QI3µ™›#}úÊ +c«˜.En™SV¬/:.Œ³lÅÌà2T…£ä!«»·ôœ,åÆQè¾³gsËT@—$ȶՙ ŸµÑϲò–ì•*̯ýÔ]ÔíÃ\VX—<ô­)rµ}dý_ÏÑÐÄ+ð½å¾ڣݕGÐSE>ì›{øË<õNFnÏ R˜ö(xŽù÷6tÀq�^hܨ¹o;|#RœÐ§í·Ý9LžÂ‰t°ý ?~bëZ?ã*ä CåÉàg|žÚƒÎ™…Lélšú5 žÐ²-ÅØN Ø0\oϽqL•æ÷Ìõq [e¾ÝæþœɬøAæ²¾$uæ*ß8†ý+(ÇÊøK9¡@ fSïÁ²h»š?ëÒALáj_ÌoœÃxf¦M Ž%· h_ wHþª”AÕ¿«Š# (!ýìVÊž¯Î@ym�{8Í< ¸}uð_O‰@tDš& ÂÓìéþ|8¨7U+ÚSÊÆûj]CDÕÍÀiþ(ƒØ2£9_·³“Ú@çм²*Ë1Ü7Ð*D©Úìâ \4ûN¬Ã¨ŠæÝÁç>FêÆU˜yr½´ìÛ2`sëÕÔ¬�k‰H<‚{(•x*Û™™ŠSà²,Â<‹Û˜%q¥}¿úÞÒw¢Ï¹1!i÷LOvàKø=ÕmËœ?X˜Qs@jj:*–¾¾Ü¬dÈãŠùYU­,C–¬6R�>¤J9Z¯¶²•P JÚGù§? ÂÈcºÚi˱ûSï3¸@œ‚™ÑÚ]-·69Ï£ÒPúO{nq¸ÅM-†¾ã 3Pü~üûO æUú³‘(4 öð.p ÔƒtÒÍxð%¨²¥ " åN•[k⨢úcñÖ›TíAsÞñ{:LuÍZ;¤ð’ yW¨ïܵYÅæœéØ5„býÏ¿¤¨GE+*ŸŒ™¬‘Xðýi_78>ϨÖÓÏE4A€Œ[î@I£dݳʃ ÆUӻד£ÚgöQ×?ëÎ%…›þˆÙþÄÆi_Îài[͹Ñ3™pÏáõr•Æ“Y³3¥/²û©‡BϤä6Šm}îù‘@—¶žŽÁ(› Rܸ…^ÏØgnΣtg”™A òôž?[m“ê © ßÀBn1ýÖhË $,ã˜J”?Ï– ž€:öº”~ŠµŽ/+ÖáLÛÛÉIdla{tãǚ%qÞؘ^Ç2¨¶³'¬>֪όÖQs5_¿§iðÓåûDa l¾3:É—Ë9GM{õÈ�ÙU”Üedkª(¯>o¶…ÂQ¤\•ƒ*­‚À’VûCöK Å` üV—p![u²õ¼²Ö4Ñoée¼6mK köÞØ ›Ç?QÈ2™G@‰¦o]OçᦠwTÑb‚#Uyù~ë¹lÚU>÷y:Î7¾¿”:nŸðéÂhÔˆ2V½ûîŽÇë´8§ò[ÐØ=𘺮LƒôÐ}oj„MàY„P!{¬æɵï “QäÉW–¦¡z²ßºéÿ~¼8':r¡à°‰p Ìxü´óúf£ëyküÒý²ÌzåºæXOŽ«é¬‰€€ͪ„‘¶U'ã$ÀŠcåŒb«ÆS0p¶¢Õ<ä„2Ô´T¶=šÍzêY³óKñq¢ÜU*QóŸÑŸúvÁG!Õ&2d¾TV‰‹Â eýXª ÞmMÏ%‰„ú} u)Í",MÅãùׯq,èx±Æ´XÎeÐÏì¬ @5}{ù‚–B\úzíl‹WPÄÓ4:ɤók$ç­ÌÙhzQ¿°ÆK2߸žA~�„îU|2â¾Æ8AÀXb Æ©GXТ =ÅiZµû3Pòmg{™˜*^g9hš—¥B§,Ãt|ÓzåBÛ^üK8Ëþ¨àõ]¿øù©ÀÞU—Û:%úí½k7þ9ôúòHà€F‡åY@A½Å ò —’ Êæ`Až¯œôç)8&A¹×÷cÃÝ®æÁ¤ :QÝwÿ! ¾ÜùÉnœ¹4\©&‰cÅb6#i´\‰ˆ©ì´)‡ÎÔôr‚�IbÌ„uaÝûÍÍJÕ&ï!‰j§~ŨâhOð´ÒÅìyÉÿB!.ÎÓ¤È,4 Vt÷g]Í+b|n8‰¸— ¥Ób=ÊÍXÑÉ¢CÃS׶LLVZü2žNDŠ×·rhõâ3�T*¨„k5¦ž>+C7#íÃÎs™Óÿ\µt§¿šuéœûÃ÷·¶™vÌ:!aìδ6óýâ‰Ýqsù¯›{³Ú!Sûë›åùŠ<¬Êr‚q…Uv„¤Ó™’š®ó+4/ìÈ$4Eïò›Eô´þóaë•T˜úþTã «y¹gQ¥+½[/0T;ûÞrœØ$’±f8Vn/øÔQ=@§õ]¸Â ;¶ÇÁä½V÷Š?¶±ØÖÍÚmð¹ù ™¡yjâ[™UZ`–«hðR_~Fc»º¾âî0Zü ì½µªË1ÔĶìl–zvnÉ}:¼§_/ícOÛΖìÀ_²lñaÀ’ÐätdËšQ¶†y¹“6Ft^ùl:f—¢âc´ÊqZÙs´5(V ²Õ{»¯9þ¦•d¾:,Æ¢u¤Û½×„d1ÏÆäÔØáùtêôEj)É:Ôb¨H·r‚‹Y› Óò¸^v XáôB}„"]ØkUñ^o€ºhk'¨áfÕÔäØý^eñj„-àq÷×û¼xO˜C¤`®MíØ‹;Ý0߇�:þÁcîZ'@0Ï;èšÅo•ú"ëØX™9Þ2ãL£ô/±ý®¥ºÎJl4Οû%­å2ô‡ÌH/¦<(º“g-¢ÆA[©å¶Ê÷xè*ž¾…=YŒR+gáޢɉ,3b5;}aŒšT…S<-êOºé}ï÷˜¥=õƒêb˜g>U/ š6*?Ñ×íõ­æäÙ2¦L§«¢}êB"ù„ù¿zÆPþÏÍÃ)'ƒ{Çîÿ0"óD†Ôƒ¶qOFÖìÔ ÃpúÙ{*-V�Wwðêÿzu+=whP[T 2WÙÕF¥¯-Êcc êæfÃQTº^Tà‰ä2ýÝ3ðx˜}ÆíZÓíȃmêAÓ¦„(¶„Dª–šêÆÚJ, ‡ÝU¤8zÁ¥¸Lðž5V†ŽNÁ¢éMï1+‚?'"‰ÎÙÜÉ”ø)n»Ê|Ü6¨ ¿*%)2tjbø(Ür1S�ÚÏï¾Þª6@çÑÌŒÝÀ]}Ï -ÛÜÀÂcÊBhÇYº–è1Kâ¥Y¤?=¢âXô ‘uèi ç¹d!6É‹l¥ðŸ‰‹L< ži8:B½˜è²!WM¹ z'Û¶@7ÕD¬Ÿ½eB¯g$l m´ÚRypò3gÜ•?°EpÔLÖ*_§MÞÈ8骠ÝÃ.Ô£ áƒBjˆ‚œ n@d ± Ù˜®Êú<µ‚ÇòÞ]Ä;%Ô”ŒÁj·Çîâh?ôÈmžftPÒ`•3·Š‚©JIÔlÇ@@ȨJ²ÍN§Ëææ[3äq‡'d7h›ÕëežÝínŽ‚ú0õ‡î›î'j¼*ã`¢°wî=#NN\ôï2M)ZÈãQâ,¶¿|žÔ³®}êÔBž¥4 à–ƒF$¥Í –×eeÈ‘O™“ø”ÇlÖgèMä³f& dì Å¸6õ|èÅÚëöBcpÊnä",ö0HEU•‰ Î‚N²%×ë&©P0/ŒüzÄC™a—¤AyU• Ü&ŠCƒÅ©£R`¬°X|\<“S ¬;Ž}Š+Ý„ŸšëT!Ü2Vœ§çjE¾n‘+df…à 5èË5#‚v'R㊿½‹Ã-s'¯‹ledƒê˜‹ÂƒŒZ – 2i²Z+^uœÂãËÃu›—G¢èÄÕIܦ.$¦°ë W½ãµfr?õPݽJ–8èmåöÓ£·m®ÓÁ²–Œ»‡<âWømöè06ì1†K<B´r¨sÝ/LG4š‰S}å_ÐÖj}w‰«Ýh¡4”.Ú*¼(o=Ž~‰ýÓʇ Q!Û id{¥S`` ("+eªµtƒþÛ\¹4¼c mS¨ÔPJ©¢¤£ó•mgã˜Ðÿ+¡J­¦ž0¸†. ’^kDd¬6FüOš€ÑªÌ7¦ 3«Ëáw(;¦¸jÚ}nÙß»z0£TDkiD$‡Ž_Ì’ÒÜ€‡âƒ0©Fi cÚr4ƒ’|€K—}MvøtsÅC\¹ž±¿Óå!ìÈD`ö‰ª¸roCÃ8ðŽ ~KädprÙw]ÿc0J#@4‘“Ž‘Z’È-ÆaÙzΆzd§"�tåJâ5 8Ëڊؾ<˜©G­¢šÀß°­€MÂ(Ý´ Ø»nQiîw\`ô8ЉØ7.:c<î&^žÒÝ+×®˜ú*·T²-CRáipg{f°°…&}oìü¦Ùe¦cuãe†[R«+”{ìç` õÖüNzŸ¾k`¤¿þÁ¥Év?”®¿ùC_ÊýÎÛëMí:XvÄe/^š€Åüj­žF‡ØOæįØ=®‹ÏäÈ-lÒÚS¢j"©ÛÍ·Odå#ODÚTM•e«y0!Qn0SB~W«Ã¤Ÿ–QäÌþ"–m>±“Xˆ¨vçx*šô"ë6Rü¿'ÎGΣ¯0¬‚ ¤>­:r–ðÞâUmK¶»DwÔˆnZttÀ·¬öµê©ÕÊLlÓéµ-•sùtÞ[D«¡>XeZÍ3ÈB“…Œ¼b©Uřߖ¦Ë^”ƒö.f§ì8¸Ã0å p8½ƒô^ð¤ŒÜOT±¦=l‹Ïêù¬Z´T•WH'dàÁþ›àþpµ¯78‡x…ÊíÈd¯ï l;î ;¿Tó*³ÐGÓ@Öü°®–’?VÁ½÷íÁ9»÷¦k½ŒÐ·qTµÕ‚¶³¨YbðàCNÝp…Îßãùc¹aW%Î2EP|êÞª‡²6–n°Ôvô›oRlí%Œ`‚´ÖÏÖÂʮ㥥S?üëžç±Èÿ…‚¾ívO¼ƒ€“Ê‘/êTê¿ê)ù’Ú|¶²‡Ž}Mïž2%½uiúµèBúæW0Ôi7$û«'§a 6-¸¾–Nÿ÷Y’¦Q…iñ/3ųp®½ìŒ?ÈÖ*¯cò×w,ç÷㥷ü Å¿¤FT8«8aXá®W`Ò5óòÝ&:œAQ`Ìr¡7O'§ØȈ (,ØÖ>A�¢º×%nìg¾Ð }¼¦-‚¤VpJ„Î;={ñ+µËß`öÓÐïÄ¢}ã½V?iäµ¹p€Ôlw/¿Šyî&‰1p‚šÌIŸlȨÍÙRb Ÿ ~7:ÛUHë¡oST¤7Š²ËŠ–[ï A‘ÅUg´Éh×à±êÅ÷k‡‘‘âÜ!bôå‘<ä§âÐCH£k¼2£VRŒ>ØJ“àÜì!&}²¨eAn\ÜÑ®gfåêÅø­Á@œ­p˜IÐ.ôÎ –VCv6€)ë$÷Ó<9.VywHá«Ï‚âôi,žA ©/C­-f˜æ«=Æéå4åû?VJ®Ž±2ÁßëÓžÂ8ˆÏ‡ÃLB:öbßûÊh«óÛŠ1Ì/¬‚†bKn@°Áóâ¸øÏ‹>r¶*b߸GBjÛœÅ*j-ú±;QWõ.oDµ¢Ðƒ†fhKu_hfÍ—Øu…!ÀQæ¸í¾+`_¿[îÄš¶ZTÒ¾¥Û°Ÿüapßµ”™›O»?3²ÄX²úß<¡F‰)¿cx™)6²A}$°SûWÇÙçªØcǾ{<p—‰´Ü×ÓfÏHÊ@<fÊ^“pÇÛÙgR@S·¢¨v«ù/ßúÿcíM–G–mÑ1ê+4»“Êcè›!@€‚�&Å´÷ÿßñ|¹‡G؉ÊÚvÌ’jŠ"<¼Y ëñ˜›Õßn(s: ¦b¦¿Þrvgl©ŸžiºÅ¥w„ðŒuêsþíÀl8#¼,‡Ò÷›èáÞZ Œ`wžª l;OX~»£[wѨvý<Žt1@.¸¥’§j:—‰æÖ¼„âs»Í2Çnf NŒ-ª ¹ ¾Í TD5ã«ÅPÑ^|7¹¨<P#‹„L¨ŸÞמÇ*sØù©š$I,f—/·Ydéåñ±¨ð æ۶Ƃþ¤Ãd’wõžJ#ÄqêˆÚ‚/ˆ5éµi€^ ,ìvÝ›‡o¹FsƒíÎ(û�n´Ï²Mm2×íi™nÐÂÖNº"ï¿Q"Ñw¿é,9úz‡"aëuiÁ”b¨ž×Ÿ¤æbLÀ0Ë•=Ô¯þA6åi·0—€…*òZ•‰�)Úvì̧:y/>‚Èó¼`÷UP¡ì xUïÕËÑÒA »!;«(\�ºKÁ>Åmã͵˜�"ŒV;<ô¶1£‡“à¡Ñ EsWFægßQmÐ}Ù&`=Ô~Å– ¤õ^¿qØïrß±¹yñÐéÂEî*:jH(h´£^ñ«rõ¢Ü•ª™£[ÊöÙãž ¶R²¾ñ‡iêRŠ-ÎCO(y¶õ©ˆü'ïêßÈêø²7–‚›¢ÑpWÝA~θæùµD™­JVRÉ;{˜PA®Þü»<Ÿœ¤~ÄRà%SIv'Jn§$ûzë Ž=1¼Rw ‹AD–,Y¸}}Ñ`ü²Õc†>ÞZ¡ ížwí²B~e¿›mïñ¼•¡#Õ=àóº@@1:Œ\,ÛO‰X†ŽN¾)E)‚̸ô‡õ,%‚a{%Ñn„A­l‰‡Ê©‘ ÃÊ%h&ú'jOg{<5ˆ*Éz&}ɤ­©Mê-36é ë íéD³Î³ÝÁa´”Ï‚ãœÒQªÈ“Ë× "–?%-0pº2¨¬™•ˆ.Ðb=-sʼ$Jß쓪–cG··šq8çiÀ’ÿøò’nþµ¶wZ9uÂ{·4oíÍφšŠLs|¿Š#«i_è�ÆnÞéóxcOú8YC§ñð¥ÝRwy«0R.TÈé¾S´ÎzmÍ£mAËuŽLo2¿+âÓS17£ý#Z;´GÊN7`Ì:lT%scÄ3§JY{{}'~ø­ÇR¨P“™T Âb,ø+­wØ¿ÞÛŒ}â½Û¡§n”¹ðöÌž¥|Øa}¾…öbÐ{š!¥åyuçK¯Ð‡º°‰‰Nا<è¤#Ïó5ek߇˜H`´Ð:C=.!Þ„æˉéáKzµPh¾`ý´­UÚöHÏ£u·±(!ýÁ£b)<Š“»beË{òÉ¥³£(Ð c!Ÿ²µd‡ 8' cëVrÌb"ÄÔu«ïs_èÇB"5âÎÞ§ég×Â÷ }Æψ{öгÓjNXlÜÕIƒUê‚Ý‰Ô ïä§v6œ h3ŒDÍ2š-¤9äa×›A‚ÄŒ'Š–Yäâ3«˜µp7¶Æ¹ çA¢uAÁâ NÔú Çw bQYTš”‹VK ²wqdÖÈ<1¦è}W[ô¼å�úÌWT6µ!³riö\í.ÜÃÆ Zió7€ÄŒ˜G«íëzðù˜Ù;ªDYæ Œ9?Õ^ F+Ö‘ùŒæÙÖ ´”¹Î‡³z(hrý­³Z™^åOML‘䢴ðÅÂÞîl .rÔ»NôÏ»Pa¸@ñ†Át÷ôÝ©/¬P)ó„ƒ ¯ @F@Ó™œÎ³wå»Îv‹”¦%ØLe´L]ˆa bP±Èá´®wœ9½ /Š}xw×›ŠÞyÒã/Ë™¢9\¾”¸ý˜Ök�²ˆê¸å±ÅàŒÀ1!¤‡ F mð±›ÕË©Ýð”ý¹í§Ï–b – ÆœñņXðíq`šç*NkÌÄ•ß›ÿŠHõFYHs˜ïüÆÓæJ™s z¼Òä0 0úL:ˆÜµ|oßDŽ‡ŽÜ–Ñ�ÿ1÷,3/£Y‹G4¼[@7 l2Ïw­‰ü¸~ù©UùBÏ•vǘÕQ™“(óVC9›sУ”è«)}+oJ2¥†çÚ½N +˜¿ :þ^ßêóó@*ÛUA6Øξb_§n/|‰¹{Ù¶«Ê¼®ôÈІÕFÈ2ØöºkS×€©p¤&Êõ…Ít'jXÆ™Wn³,Zây0Ÿé¾„ÓÉó¦<ƒ÷±Ðû€:‘?$ ‹n#’¹Ãp§v,Ú2O]ÓÂ\–&,ýæ;k`oWõ¹$á–ˆ!~²ÍRÐaÅ×ñ»ÖüU–ݤ Xöºa\Ôk*ÖñRõZY[ä1³Bš ®…9Lÿ¾ÍËM`Ô¡–¥"£žûá¿oâ~lÌeÎòêÿÆ(¾9mfZ¹EØôrRTmÊ‚·0eT-Áî¿ú²3‰1qÂÀ(²‚¿Œ‰Ûwý®¶®’/N‹ 7¯,ÌåÀ²§ÚÅʘïÔ^ÞXýÛb—'ªµµL{t}G6-/¯¾&ë¹%)‰˜'KªÛ%öÊ�Ý°;Ô_-ŒÙÐ.”8žƒÛ×ÔýBÕv¹Ÿµ�E<Ó,å6lèd'äW…#d•GG‚y"±©M ´/C=Ì?:0¯23 ûχv¨ 4yp¼ÐêÔÖ"úš½eÉò3�K§Qýéyó0j‘ÚÅá\‘åÛîÂÇ(þ0´Úäc4áBŒ,I,QL„÷æOú# œœŽvIÕßz·ájØ^\SÆl: éaÚHññä²$ŽqÜ83»`ÅNg%Ûr9 CWÑ$ÂMw7a”Ö6eõçn²œî�ÎÌ¢ûßz…=sóuÙ´ŠŠ± ל3 ¡ªÊž½•6¾qX~YkáÇàÓTÂn=çU¸x±.0Áxd&bÒ¶$Í[gFÙ¢ɺ·EP ³7¸¡¿tFÁ-¡Ð6Ù^סÈÂk­/|¥¼Ÿ\[_ßìT¥2�7Ž]ýqÕ¤õ]JbôhYs­ÑL© k@[-ü¢kE˜ùÇW„ã�µí§J óP9¤n´)ŸÉŠDNšN:0œ�èµ¾Ô1«®sG–b6,\OT9(ž·ké—²Pµ‹~ÿ—èTT~@¡»µ¥ê%²N¨=ºdìò±T•dÁD.ae{<w|Š¬DjTÆ mÑt½öøák„øAõXg0/.úòÝŒ1YŠÚÐ>¤“žú§ê4ì~_\Å)æ¨Z9PRÁ¡ôôàËrwʲDeÛe%WJ/@VÈÞê#eùˆŠ®f5f¬ m “Óϸ•ä) ue„|y~ª†õY`Ðkj¢äKÓ–¤ô”¦!|PTë `T}è|o —T­x_åž«gs[�Ò­6ÑàäÛtVÌëãIý(Hô þßSç�B(–|s訥®ë ¼­œ4.c¦(Û΃¨Ó–Öºë‚7§bîÊ‘•á& ×è'Oðl¿c‘á̬E‰xs‚½«"ó“8píè»{Z‘C6òÁF ǦûqUúŒRÊÄ_´i׶Lá)+¦¦ú Ïi¼F—&ë…FÜuµ¦M[å)Öþ=¦'0Ò(*¬¢x¹»¤¤Ýhç4!æMÌ—øˆ.B<ÎçNº•ÿßÿ›ÞúË0Ð1møÛkú"zÇu—Rt bÄèï’”ãÄÎÐÃsô©÷@Äw¦tý³§G‰ŽÒ*T Ê5^<ÒöÑH—lùåÅ“l&eEèç\”Øõ YÓÙµçöu7Áæ—”¡žá-wý¯jHI@ht‚T£'õÚõ{þá&�ÿ£GóRöê»ÿ„.LåŽÁI¸-ƒpk5ÈÙtìO×»²–VÞܵÙN• bÖuä÷ky(¼m“ Ùê«þ`RîhÀR—Õi^DG…©C¢°³Ì†nl)‡ÈžOÒ%´Ù]¼ ±åÉQT©‚è¤ ”îÍ#Ï|Åóçºi vu„R„¶V-h–(&²2”®9µtb¸¡t±D ÄT+"úŒ·ŸÄæ]33J…‡hri<4Ôf¬§Fu²4.½h"Z& laÐX¤ÝQÅ&BSÜßš  ±«×7¹U7æ8]6÷¡•GuúÑ2Ïi£BîbÛÜS6©­CÓcöX›Žä‚^šz*äìa!" k…å aÖå^A~J”$„kø­Zƒ-­­¹v{èÐúAÁ¥­ø’r¢X1Ó_TpËÉåJ^SÏ·i€å(í¼8(ÅÚCuåó„<Es}’"nùÊ¥WçËŸYãIëP(Žt¸4fU0EÙÍ>Kƒ•J6‚ÊÖ+d°è÷ú¾€À3;c» è é¾ì<:ˆ<d?]k»¾ÔÄ¿½äÃÄàÖ–`‘<\6þ¶§2(;E’UÜ?!¬e[ÿ=xæ‹ {jŸtkëlÖ+Ó±[™ï7ØvL,„~là$ü„~¢„¡èµòŽÍdIW?vÇcýõ<~¸¿rôÙqs­ £œ›£(jH¢Ï4À—7ãº7.´u‰mv”ÎsFÜ°ü÷›çÎÐI™ù-}–YLà ›UE•j%îC¨¨–ùùåyJ’¤–Ëã¶`ÓSá¹Všr©Ýþ0ÙQRáa{ æîüa&·½S , Í¡Ë]‡IKÜý‰>(–™\’J ATùŒ µ,?lADÉ‚ Ã(%È:ÛÙr™u½ãoõÄé*ô\jØK‹‘fÑÚK¬€“ÊB»úç•R¨JÁ¢ Ý;úØqóéÙ\Í+¥‘§o¿ÞrCÎMrÑà{hšÿ²àôµïè;]QNÓħ„Qit¦�\Õ¾¬îª>Ò­`nŠ¼ïa4¹ÿ Ú´^è’>:mé¤k<˜›©NkÆý|ÂY8Û cÌcôñÓå¦ SïlMºVœ™™ a¬ ²äÖmF!¨ÖÊFÄC¿tYПعqˆù3ÿI&4Š3çÏÊ&MOë`ì ÓB,ƒÏÌ&¢KY™Y°Ûƒñ }y’Ê,ʃ/Fÿè+SÙ£ÔmN{x¬Ëñò7ßÎj9oŒò¨tÎ>7ž¤åaÂÚ­ÞÒŸZ =!5<’‹â<óZ ´þÆ-�äŽÁ#¢Ô”_Y`•Üë®ÛëiÙéƹ÷f¾+}“*k¦?Norocºw»ÚÎŽ½Qq´ªöðÆxÆ™e¤tp sl=g¿óxŽò"-“og=v¼.Ï¢ác'%·÷ ¨"±ö—VA„TôÈ e’,â£ó¯yoIn¶@Öh؉ø�•ÙÓÉ/Jqƒ»Uõ½RPS9®ªJ{df&A¥'±Ógà.÷hró±s÷º›´ÿpÛšJ,'Ñx})âçc§ÚÝŒy܉öbßM«ÚŠ¡­ên<â|¾ø—˜åV™çCžÐÿ½±hvGf C)çþ0"}”Ï=æócô57³ §L \öH=(GÛ™ v†wt”’ÖÓöªwyš#<y¡ò±´ó÷­Já±`D™è±>SmvvTÙå­`Ž³ÖÌp˜ÏŸUPtV'™"ëÿ±J*¼·<Ò™9{¿M«bÇ“¥¨aÃÌÎŽx0˜ E%ç™è£p=ñryá» *'óŠîÈÕ,…’#@Kic~jê\Ä Ô‹Ç'×42YðêUöN½1¬ƒ[Àiì$E´Ž¯Ñ®&·ÒÛÏ¥U¿S½)Þ·}B1^žf[åWÆžÏ3|üèö2T}âÁì‘;Dí½Iéü©UžË ÷T´Y2U›¸ ‹0íê“ {¹D뽊DE}ZÚd³ía'K6Ž' üÄ,ùÖ<Ù'%U€žA‘›Fg|v¼?KŸzbùû]o’N úGJ^ð Ù¯ùLUΉ-Ÿ§^¢1ðD­ß]7Îi„ÞæÔT-Œ8HôõŽí}äfâ„Þ}!Í´a8ŒWÌ-à=bŒIP:CSáÑ°,"[–<ýÂ9Ù[n,þ¹Xû\ãXE‰þÅ”&‹B_±%c7Ê)JýqÞ-–Ž´×ãŽûF<qöÚØ×|ݬô‰Øà½RDëΣ˜LbÊ+‡�×jla¯PL÷lqªÊRÌ› š/ë4ˆ×Ú§`™vxRz´ ¡*Ãê©0]ŒQˆY¾÷ ˜BG‘7¥ßþ|A¶p"Òàï¾è0qM› 9ÛáˆùSnX_ÞôF˜?)~‹8cßôsté{êý.Í]ß|Ad˜6¡œe¶“ZzfÁil:1!Bð?ÏAªØWb�8¾bPØK 7; YŒ;ðlÑNsô«ÅõŠcŸÙ¹S)Ì’O+Ø,Ñ6ü~–&aæßEÊJÚ™Þ1tÖ¬�‚œÏ6 7,ðø&:Ìø Ü°X³ºdÔ×"žÖ3L”ÕAr©i“%ÓZGu¥Y4Ïê[—‚XÛfÇVìÊS2…626—ÃP„¸ïûò<rçIS¯ÀÀð>˜¦©Z eÚ]&7Ê(¤ L"±ÇŸÕs°X.aÚD,Wc. ¦qwtÈ þtžÆ€ p§cØøšÍô v ж`NõUnÀ}PN{P�ft_qŽÖÐÄè5ª‹)ý:Ö,‘Ù©‘Ç�Ë Õzèhï‡\hG2ë”R¾†©âÄñNô7.|î!dpó\82)= û_^TäuçÑ] xprŸèé,«csÌPº’…Å´ÁkˆM|ÁŽ½»²0ýÄV�Lã]­“ ³p£ä¦ÕëÙÌÓ>bÏcI›Ü‘P}GZѪÏR?t‚Ï÷‘e߈¾:C¦È$½SM§y5êtzųÓîp¤}°9_†µ|îMÝ6/ £¢Ì©ØUË:Ê@ûŽO1nŽHÃq96_b}øvÆ©X"VÅ×]Þva 7–¡ÍZÎÙI·4Û.Šd}gõlê3H˜[z@ô)\k/õK]é5Ú Ž¥ÐªEsðÍ–™Iædx�icXí½+ðS‹Ì+› ¡‡ä9üÔsx }*¤Q,>Út\.v-©•9–Ïþ Ù÷›âºà<¢#6|yMuߘ'õ–a~—Õ¶þÍdð«y–¯ï›bGmúŒJ k4L%¼°¿ ?&Oû`üÞËyê ¡¶ûò´>}ËêG&,I¦™W½æTZPîY¯­J7ë6׃ga²Â}åϯwç‘+ÃØölùÇúÓ“•\ÖÔ©ûÝÔß½°éB’û- ÚµÛ¶²A!IEÅ#wÍTLZ¸æí¹¦êèÕ¡³u.ùÖsòÄGÅÁÅ]‡¥“ëRX�ÆÝÄ‚•_ºfQ­ÌkƒÅüǸíÄ<Ýæ–>c·ÐóãµýBÊ_nÃ-ó#\ýN:6çlzÛySC]A.¢ �Lí¿m!M á~®³O'+.´'W¯Lò©ý—+å;OèÛhpN1$ÔñØ›M¯]ϽQñ|6ôÊKoæÌcÂf¤ïÔ;m¯µL19þÃ\?)¾Y9ÜNé±Mgý”•å°ü¢º?¼àxºt?]Ø‹�Ê‘6e_+TÝ*è€_ìÜú–Ž´#;UVÞò¨Ù ª0€nA›¤€wÁ×íÅÂqj[\ùóA·À‰Êg§`’Ùù,T%©´Jõ? üάd•÷~XvßÂÊoEJÇJœ÷ÚJ2^îÞÎ7Þû I^,ûØÓcØ>Ça×XI^Öäu¼üf·¡‹Fs·¸FÛ|a×}åÝ-9qB^àŒÒõ¾½ðES·ë\am/´›(@Ô”9^¦ù EòU7vín³ÃMu—ÞÚb4´ç·'0³kÏML�_Ê>E(€ÂÂ_8¢XOýÜJ8ÕÒwuGtêÄ0Ê;øó2¨?ЉP¶ÅС½b¤šrÜe 'ËÄø2Õª ½†¹>3¼Z¿µñ¢{¦Åw šâØm/cjYÙØšÀP üÚò È3´¯2ÿ]õâ£W áŸÌ@f8-Î-Öž{Ìy¤2QêjI×f$¹|½Á@U‹y$Ãå( åv©Ul'Û½}ìz\ÀžÏŸAP'm=œFxn{„ßK#¡Ͳ Ñ¶6ƒIùö oñœpNBÏA#ã7n[×°›�Wqôäÿ›š'²fN I#<?üͯ¾û¥ò"ÖƒÂwBʱGlüjÒL;æ›tdßsƒ€Ëøå—•—RËëOâ„n+Z óìæê¾ešÕša×t”nàƒ<v›ÝtÏ$¶ˆÝT…íRŽ(üÊK£Bƒ2 ¯Oï÷Ð3ÿ®»Aô<nôÛ£ØÍ—y@~‰ZôþéÙ–Ð94BÀ›xoJÕI£oªS¦¿ò,]ÏIæ�ˆtü¾õÀ¤ÆVKKEú>h¢£(9sLCù]SeqzÛœÅÑÁÿ‰EÚ|°þÐPÏZ'öÒqÆr©ƒ c2Ÿ0Ï“Âíl–:Oô=¶¶Q‡òJj¬×u–í}øâ„ð[A8+eÁÉm¿ÕžêõùJéÍÚY©6üqÑE\lñçÊÈV"VN|:´Þã?6]aÉ­q‘±2Ý—qòmΉ2ÅlAì»Rnë0Hjm­â1O§ÖÇ“Ÿ;´[.öõ¨|T–Ã-óŠµ<Æ0¹Ó¬³©î ?êˆãêGY^AJâ<ϼ»˃‰Dö6âGgÓÐW)9N‘!3¶€—CJ©‚•“ú½7;LÙ ŸëjöÎ!Z†ØdÉ £¿:ÞÓ)rí¾KƒÔâÖ€ µmK¥îƒ”Ð{ÚøàÛ‹ËóM·#Våy.8P™š8ÈŽ «-¡ùÒv=TýüaUÍéJ[TV®Ø«Dü™ÞêÏ®Pµì›ûãZ±ï~¦}“™]7î©L8ê0UËUîVüFÊ_vFÿ¤eæëT‚ò?9±«wšá'„·2m½Ÿ"}ÒtÁX1$,‚pUžù0Mèoøò+Žñ¬LãJQ-NÖíáØÝþbÞâ´ ÄÁ^x?†GR@<(ˆ, Ï5ï55+[Ãë×›ç“Ú&slL`f°>ÑT5N±5…½y¶ BýùŒ5#’5žx ÇÎÙš„Ž#ݲö˃Œ0BÊóg<³›€u·[_úöjhë6™ÊI¶”cV­Î·íóžG…R YãGbx›t県Š©Z¡ÈA¦hv“]çaMŒÑ¢ï0Žx~vNb½Ò›ª²/ O’@S0Ç–¢’…ɘw.n•Lr/{ʱ›ºAÅIé–‚áDKÓs†‰h_z™�½tÌJFÓåê'ÓõèÔ‰(Å÷^Û{ÃÍ祛àcÏ%Æ<|w¤“>µxÙ„mÝÙúMýœ»ôMÌëcvW\úè+ZÜ}ŸÒÜ_<³¦zTÈé¬×0m»ÃƦ?ޯЧÛn_™†èP™Ë5¯“2ˆŽ*2‹>=»×í¡€¦ÛÁ(áP!@w¢¥S‰b •Ûõz}ïWhÈyókf ]žñÔx:{õ¸¹¸L¾îi²Ñ+“èë-`À‡Jr*»)†ƒ—\P ¨ëT ça ©V4ÿ‰x~èþOÞXì!cÂ<b(}'’±éÚÖŠ%<“|ˆ}Wx” A;Ónµ¦/%ã{­ ¡ŠËªUòõ$Ó¡2ƒLkú„ƒV"¸ÛŸ(•¹#%\c™ß¾@@ˆ½™4º�B4 í²¡ÏËŠ/oM=|(’âò·t3'<R™#dO¬Þš‚¼Dš%#^Ëýðú¨Þåý.kn++Ùcóº Š­æÞùΪ.t»êžÇ©Ð ɲCB©Ü´Efëiσ8¤Ä«ÃN17r—äw£,¹"ZOuNqË šäL§Ú@ÛEê ¥€¼í¦í¾îúI`Úøì¸ã,5>La¸üÉØ¡ôlDRÈbiq»OÞ_º cH“Ìo… Ù6¡°>:LO[œÿòv½D·ì¦<JŠÌsA¥ÜI\Œ¶GÌÑ…/¾ßEý%¨¼^s0rãf¦ F¬­SR¦¡Œ$Z㠇߶ ƒÍÓ¿oF'¡“û¢nÓßθŠÈùÞpþÝLÆsÛà)ÀJ¢¼à“Û\Qê϶éÀ”-;$­¹LÝÿm(Ž;zò2eé e˜é‡LyŒ“¾§oiò+ÍÔÉÈH(Y¼ˆUýÙ#rìwFOe}êï¢þbåÄK£œ¾ù>Í9ˆ[Z0s@ÔŸƒZ±YÞ^~æk³4ƒe/ÊTà*Z«®…ÞíRNkÝ Úö"rë"fÏ1�³zz^›Æ¦+C7_XW58ö‡ùn˜�Ü™ßßᯚèÊQØ4:_”ó±üÕJi m€¶QÜWÕ¸W\úXñ¡'æöN˜y¢²Lû>¯)Ç«FˉËMêYã 5Ì–€MÍ ˆ'dP•!<Ù©«(˜œœCZÔ;:%¨|êÖ‡ƒb„_[ÁùÐä4é[£Æ!¢¯ðÿµ;Hã<ga lF¯!D—ª J›6"{1j)ÚÞ˜ô£WÖs™#¨hˆˆtNL[o¬Eïw¬O½ît …NÍç�p0£%îÕ]ÉBµ„Þ}ÓgC÷-‚aÕQå 0M”‘2µ1Á„J##½ž¬¾ÒÍã‘mép ·Ú,ÊØå * íÔ£ùûøa¥üoÅñóÌÓá`Möyù³žìn­EY8k½Þ Èði/"‡½1„*h º­µ‡Hë\ïÏ^qã€þ„«cGr™™óôC8¾<õ*à¢E"fM§<ãñÔNvöy³U¬¿©X}Å(i}TƒöÇÓB(„<À×[K·pu:>T«¬AKn´«Æ-Jã¶)gÖd£ðJ ðuûS(L q2N¹(Ôƒð÷Ž2Vèü•ÓÐó©)B‘ÒÚÚήªWõJ-LÍüíÑ«üÇþIAý6Hg5"‹r.¿z7“}ôzû!—\² âú¨¨¤-Ã’L+ÂDÇžÀšžt]Ã…Ë«©­;‰Ä ¡ÄW±~÷Ì胈.ßóÿ§bä….F¶P‰C«t²38„CÄO@×üf@Òéîã3B{)¥33…]÷•E}1±Ƕ1•R„A04 ö»kGj“qAA–âVÌ—56eGn;Òæó¨ |¨Œ¿]3ÄIPn-à7â€×) 9n®.Û+óF†Ðì?ÄT˜XPŒ ×õnôÄÏ;/+ºw¹Ài+¼"æn¼Hö-¡E†%F…A϶•ù™#[àÖéÍP؈>•a‘ ¼j/ŸÞ䇖"­¾ F%ø:¬#Dz! Z£iñ§R~±>Pç[yd:åLÁÿ×ò¼ò=fi“CÄôñÈiúw½ Àõpú5k^^ù•nO)TºŸ Œ©ê¡¯›‹ýW>|”E™G^�§|H‚ÊÍOB1"Œ²¶8¹µù¶F>ÒÿÈx6Ë|U]°raém¬FHëÔÆ î Пl)p(—ä'/ ºUEñ,¡Tâäª×CýáÅ(pû8Ôñ´éG?ú²•ÁøöpX«Á±dš@B!´Oࢼ9ÊcØhôOY.JšˆÅΩ¤yW±²5ÈP¬âá$¸ŒáHÿÌEu[¯ƒ'H¼“—”šsÙÍFAÑš<JÜÀû fÉ¿x€Ü.âpÐ.ž¢5žð±5Bp »û˜è<½á䧇*?u;ƨWúË`YÐQÜÅ=òx¾@™ L¹¤A:èª)SÑØ0#Iº­Ï×ßœÞJ3øð ¢*ªK¥n=øý‹$XZœªHƒ‰ô¬|ÖõÕmpCG^«:Â}˜ÿ:Zî€a}éúä€ÊnÀ…èglÁ¬p ôLؽFGkéU:Ùèë–{NÚ _”z¾•”ˆ@öhÓܦŠ™ß%ŒŒwÑ~šþ ý2“Éê¤~kÇY€Uhtú¦=°|ð8ø˜¾,ÈuãÏèÞyW‹7M½)²Y\(o6AÏ;a<Ï?håô² OêÀÞ¸�î¡0Søzh Zk~¯—T•ï;ÇÆmjê<UÁmÝ»±Ì‹pé,7ÚH2ÇO‚ó€³ü‹s½˜¡ù0Š˜¼`sŒÕ·¶ÆYèe8ì.Ø�‚Ùq9Iýz‹EjmbõV A©BqåBk²¬0#ìá‰ân€sv#²¯FÏ…7ˆ/e`‚ÄÉ’`§[-e%­™†Ÿ%ê‘SÓþ´Å¾æFâeo½ „4¿·—ó™¿ž½+Hä L-´+ßð(eÞkÍ 'os¾ôíûú»wÏŠÊëI ý@²Ÿ½žäê€I‹Ä¬|ÙÅ£/ÌÇÚ]žiqƒÞ2±Å½”•çµÅcø©§ û¨cdã?ŸÆµa8»láíx�cêEÍ™o>§»."ŸÑѺʱv 0~ÏW`U£› ^Æ[×îOCû-Ø&É*W6qÙlÃÑ€Ò‹qk_OÆ;ìÛǧéb*[{öÓÝxª´ˆ ÜÂt䣗§0QáIq±eÕ¨ôZO±‘hóæT"Ï2¸wu'ó,mZ@qÁt ׃é)™î{ÒBç)˜vH+Ýù7r³ô9é5¢ô}a8š‹nYÚôžOÞYüÃìÜ+©²ï•Ëò…;†)•NÖ­{¢}'"i+ ´˜yjÔ&²ba¢Î½ŠŽ§Î‹ ¢æ̾“QÎ<ˆ]dÝ#ñ~5—_´+DõI\JÖè¸É‚´VPûE0•+ÿï[zÓÖŠR™ú7ÅÿÙWÊ|MfGК:EbÄCŸ|ðt&g¦€3ÕKáóšž@b½»K³$åÌÌͶÇ<țטá®Î3³¨k4ð!íÅuߤò&jÌ/m覤'KX­¼-if€ôÿ*ýãï,)––åô0_èð|}yÊ@½PùÍn´hi ì®æ©%ï9R<6Úˆ&J|ùÝEr’&ú»uᮽQ$Ê®öpVy÷HÃbÉe ÀMóô962²‰0ÑDÞÒJI;ÍÛ �‹/ì­YùãÝ`ª“(ôí3ȬENÖ?ÅPOîŠ%o($1ýnê˜'ºì@1ÝvË äy„ž“¥=¡ub–‚™ÙÉ£±‡ÝêXb9“¸Í¤ÌÃO¬oGf¨sNCü~™ú’€ÕXÜem›˜^ œ1OÍj»<y)óØ÷ïš:æü‰ÕcDÏÏunUŒì…k$¡ç·Âc¨d›Ù€rAñ£o +ói»ÕÊ8&;‚Àª�–µuÆóØÕ:Fžf½ÓlFsëz¸aê]§Ð¡]ô„­‡¹Ë53pC§#% ÖÑ;m9×ô½¿c)ž];O&A{J>'O¤‡¾÷z¤,`7½J}ʽ7-yÁM”$¸1í™}SOÓåÇøÛ(.ºM9àáA^k¢9`¦Ok¬’k¿(A¯>Ä Hžò¾†·ÐÀ­ê¢þÑç¿ò!jâdQ‰¨wb{dÖlE©­éTÄ<ý"ôe™ïEÊR•i Í0è�9cY‘zå«WàQøª71UbFc`ãÇÝž×¥Ñø£ ÕÝC˜çÐÖB¹ëÕ¤wç.O&0±Ö½²êht_@ãugM«Ø£áÊ¡t×^3Ò¥¶†eù;Î.YÿMu’ daŠ.Ñíxê-õûÎÌ,ò4\KâšfJØ7½“Ø@7DŒ­„ðÚî]ý:Á²ã…'Få®ýãV•¢eà1ÑAZÁÑhby+Ú)“RƒÒ#üŒøG ú3< U1´VT¸w)Ot z9+ ŸêÕUì«­2“¨¡7OÚÑ3p]õõ‘ý ˆóZrçarƒnú€LÊ×ÅìHRVÅ2ôpAExw-60AÝrõ“?5ÍM×ýØÃI­ù\ŽêBUhé觺Õ]`˜Ê Eo$bãndRŸv¤‰MRx¸¹¥DÊuëC{Å&ƒŠÄS¥cô2%‡A~êœè^TOj4’,ãîË-Ì,6b€ZHÖë¤7/– ÉÕh!)~8XÄ+ž…y¼T±ÎƒqSå`µå¡×¾‡èÃ\‚ÂùÔÿzܺ#­5ì|ÂËBÓÑR/ìó˜²>‚™^ÆF-Üó5¹óÓ+‡ˆ\ðæa>Lò²ã—CzR–UK ƒHŽ˜2¨1ÅÝvwôIz·Àv·”à[Ïsò·«fšg`&í­0«".2UÌûPù§VeÁ9†Ì\{Rmì_trN<?ƾNÇ4ÈדÞñŠgùã"ígoìCïò9],Þ%7(²ÁJ΄`ò]×àE™›’UTàÓRú¹±¤ÙGVÏaºí—#,z_Ä`G ³¦s‡¼œ¬oÚÛú´² ãoäYä+ªôVÓ>j.FEŸè{Þaˆ§/éj^üé™›" â®S’# ¦t+ùD|„ÒyÄŸs<üÈ ¢§š>äiô,À§rbd+�¬æ™KQÅ»z…µ±[<ÈÚQ‰n5ÙÀ¨öØŸþøq63åc‡Wn‚ïŽ7òDUº¨^7UÇÛ–²ø1—A4÷&¡ªwó$‚{zbÿÞ­èpØY…ks ½Þ~ß\i|�d”Enᕨ`à}4OÕCö‡FTäÌMÿN³-“Ÿq¡ç?ÆRÉúÓýó.‡)Ã×z{‰ß–atEv>|Áë­;yÔU±ÛF{F8 bæÈÔ4ÖkšØ˜ž%F™.žOõ¸9wuBåigÎ*$Ú 4|–¡­‘<9žP,_®—f™‡ )ltgÐ]U1¶Út?9’xná/ø‡ç´¸ƒbNyüÚ5ª›ÑÖç†ã–Ž>d`´ÍYøúçG3c ÖÊ £’,(·ŠL/`)ˆkÇ>ºF)cꄶ8ž ë‚^ûè÷¨’£8sHaI›ëÙ¦©§¥Y½ „Ér^K}R7lá­«òÝ7ÔâÇé2^…Gåelæþƒɲ³ ˆÈ�n ðð5T[œ©Y­P�ÇÌ)~~µA³Î‚ð THM-éKüG>m…0Å°?åA´VØ:ÀŠm7í6ÚžªUˆÑN”çâûÜý%e‰UªúÖ`(8&6¢(ÈJ‰¾>·þ;¢½W— žŽ¥ögíÚBtǸÒÙPn_SÚ÷êmÚ&¬.yäa£ºË8ç!q¤±oÚD‘ƒÔˆ4+EïãÕç§+Ry÷H´YŸØȲõuO=# wR±ÜCdmj<XUî}/öh÷ªè<ô•Í›0GÙF@ãpœVÝ&+ˆA½¬Æ{°/úªјÔô!Û\ÅÖØÕzlZs2ªª®P$Øâáî(*¬ì·Ç+ðˆè“Úˆ ‘=lr&7a"´èPy°cv¤è{Ìáz}„îÉt°ŸZÚ›óõ¦±ûÂ!¸†ú•<ï Mî Tl-?AOÐÓW¬ÍxTÀ?ô§žU“7ÖašìÓ/Û ªÊ"vБÊ)s¬‚ÂmºLé˜Ó¼³ƒ$üÌë­£Zé« ¤\ ¡Þªm*ù !òSlH™:ÄQ‘q„ž°­=jv?MS¿S?Ie­x©NäÔƒ{7”»Öc{­!¤ˆfÊ=qꇮؔ=™vZ¢jMÄ–š¶ÛI¡ˆÂÖ6þ¿œdZ€�ÆûT5ÊåöŽä< }WŠà½E<N ;×TλQAgzfßj�çžÉ0wŸº<ȾTs0a?M:ÎǶ»Kó`ŒÖþîMÏô °!Š¿¬›Îaä{M­¤ü׉^¢Ÿ9ع‡²875ž$2%‘\5JüÛŒ; .ûúó$fIÖ ‰¡N‡Àlw›æ¢ñÅ™G”®ZqCs°^‡Ñ#SÐsuƒá>¤®ˆÎÝñ�ëØVQãa˜Ô� ù¬–,ºóüõ›C=B«Òî¡’3Oë4å†üXùçɳÿ¼1…ŸkA‚Z„Û¯ð„ÙUÅRH¥¶-iµgÐ e^X¡Yç)OzðUó»Ø‘q¥ý:l¨,®®è»ôÔüÅìÀ‘ãŠÊgê†Ù1”š¢$Ô¯ƒ’o´>£(vLq´ßÒ» 'Ë*S…rŽ¹ðyÿKeE›l«Ç!4‰ãÚ") ¨ÃéK=_—.}/L\–¾*¥ß«=;…7= l)m,  k Qâ,~ Ü´saõÝ4ÄÅ„ ó®ó ¨G–ÄóÀ$/‹@–iîIS*†–M¯ôä®eˆÍ‘Ie;Û‹1 ûΩóÂnœVÖKKZ«sÄãÙÍ'Ä¡Õìô³9þ²zPw(A¡Ñ±Fm}R@0âÔX_¸>³vÔß­Ø0ô‹,(<ΰyS^&€8»vâ„BˆêöÇk`÷‹ƒ·C¸'ÁV®ÑhåÌè„’G³¤þ<ËzÆ® 5šyÐc&þu2#eÙ2úîžÓÏabCœ—4yÒ0óœw“ŸÌoVë ù¶Wýƒÿ‘o%w… Ás>ü•×®®`$¤ùµ»|(P`ØŒô:[¶—vU¥dÝŸº~p5d1ìëÝÀS7_zaÉòÐIg³`xšPÎg½ÅšØ†|çôĸén ÿðLöõ¸•µ(= ×a fÀcÌ`Rn9á/ð(ó<Œ¸Èýš§x¤2ö(N‰Î =O!³½úX0[¸v°Ž!¸Àž ^Â]zÚ͹ò ¨NËßmÝ t/¡­'ÛøcË´¤,2OÈjŠƒymµX`ú%ícNIXÂ8ÐÜù¾]x”{a^ThJŠ­•.. 5Úx©3TéT>&Áš£E=|ìid[e âFïéXªýf_ôÖÓGW#æÞ©‘#Ë{©ÌxqFmUZ@„ܤ-ÊÕÜY)”×Zaeâî5Â6•õvj-¯+Ñ*ͤf§Áˆ¥3DêÛŸU˨ðdûØ!›eûÊik3£[®ê„1~¬Þç» ðÜtßÑYšo­> ÐL€¼Øä;µìy#@)>ýè'ó%p¾ÁÛDp©üU*Ïf€`M“pÖaFÉ¿ØúÍüzÜß¼¸ÿx†˜ÂÓßú­¦ÄL‡R£Gg ø¾¦läyæÖݪ;"~ÅBÏ:;8)òÚÒ!BV~aŸ"ÍȆÓ@KaÈ\ˆVY×J¿Úôf¾}±éî|ÌôI«‹rú*Uó“mæ:Ô|ôÞœÃSÜ’<¼‹8`kÆ·âU4ïVŠtœÙ&ƒ&ÚŽ­|•+eŽç’±W�`³‰S6Âd€¢z ‰¼÷Ô®i^¡¯S…íõIa!lUÏÕ¡Äm‘Ž¨~ζæütîv£ Ä—ÍÒ ¦L}q)àoö`mÚÙ DÂ0ð3O=ö‡óÕ‹¦ÀþÒÎEÂ9I‚´jš~¿ëÞ$ÔFpm+‘òÞOé …'Êì™Õ:cIeó(+«Ä ^Tó*[`d¦:¦•F9ïlµÀªZø´¨ÛV°{‹K+“ç­6_7;¶Ü"\ã€)Ž»§ Òö˜�ÃQ²µ˜µØ«»uAâáÌ3R´( â®·¢QL.#kªxûiT7gµ×?Kd‘Õ^ç¸Yæ÷asÅ&9Ös’½TŒb9š¤ÊØä|ë–ã åÔLÀ›mD³-÷k£D¿éãÆ¥?®*£Ä >I~{¢¿–­o‚P¡™--0±½Â€l½¶¿–Î.½¶§ ­¹¢õ ­j=Ã¥b”".ù#pN!ªX–*³BD{Q­E€éÚÉÈÖ• ÆwJ¯Ù)¶‘¶ï†Ö8}N¤£/d£÷2Ó$×ZК{ YP­ß „#±ú+3½U}Èûi‘úÅl¨F%óÖTÑë]Ý¢¯hĉêèÈxÆûê(•8níyó½xE”Ä !è“2ˆ[\H÷êw=ÙQʱþ` r7©³1^º(1ÏEìw[ÒB<3fƒ(õáf/Vcw–hê~µu1¹àÇE«3Œƒvȃ°ÿã¨ú“Õµ#îš²Ðqx Å>÷ „ÊEr²„åÄ&k‡@§ÕîO7ÙW§ÁàÚ§gáò–çØ8ÒM6e· t¡y'½½›ËFyP·=çš:6¨ctG7çÓÒñÞê¾ÙYOJO 0 Ì1½’êbEK¢7ˆ1`K)`…ì�â¸(†blÚ§a7s/ˆÖÒŪ^˲Eÿd p�ðR‡ b›G§„a DÈó°ļÌ|ÈÊ€a1.*2Ÿ!J™£Ä§&žhç¬Ç]M§Ÿ]E?ˆUi#4XÁq?Ñf.q`anª&g {ׯȓ+Irã†âç0y‚´<ÖÚGûÖûÊZë•FlªÓ’¿~ì™2tSÝÜÄè'`Tz´Ê¹QóÀì¡p\qAêô]T£¦XhQþ¾d±»p~ï Çù’B”„?”}ž 2ÂMiÝSø†]${Èë¸ëôê»aVêú¸4_5´×ÓIçdyͲÆ_ÂÞž'j…ëu%.…ìotí mBÚY¥ÈA£Nw,²a^ ô@?îõFŸ¡i:† Î?0À?êì,O|§âkY�öm7qg玃¿ª<ú„-ó®žÆP[Ø`§U®í‰M‰Â™ŒÿÌ8OÕoDñÐsJN£Q㥠Uƒï±JÒÎÃèäŠx’ûjºg Gô“g¨²Yߧ„Ó•µÂäÁ ¥Ÿ´þ 2?˜röí…�r˜oGÏ@£éú߇~Ö§˜Cªrló“RZºñ» >XíaüÛéé;8™™Åb€Çö¢Å43ÿts4ò¤EÔI_<ÙÚ‘C°‘2K‹kþ¾U™†R¾Í‚ô¤•aáQ¤Œ@äaêí$¾ÒT†r]õW¹ªHVb3åA>üQc¤Rç<«Ãù¨HQ%Ò\¿Ö†(e6bË›ÎôТq«‚Qð„¢ ²9Yi$t4h‡XGbÀ~ê yéz\1zC›>£"hP¤FÆå[Ói¢(0núh“ªþzÒeîœuDdD§’Ñ¡ñ\|<õ½…í<"Éè+f³:aQKvǬojŒî sMu4.*dg£há �ÜÊšÞ¤AŠûíz‘©U¡’g’š+*wŸ¤,¯Ž%gpO¬Ïò¾öGŸøýÜ6s†\|G vGÉÛûäaÏç펭ԟãwOì›+<N+…î˜!2En/eÎ'…kdx«Áì4j»ä>fÓ·"Œ0aFºã®=#b_}7ˆÎìjĪ}hu”¯R%ôàLSž.®êÙ욆5_EìÁ÷¡ú €ÎÖ–B‡áKmmJ*69î/[Ëaýy-Óêgžì4ÑÙ¸½8¡\n‹A…V’OµàwÈ P:fô_;’‡ÕvÉÎ-–lÉ"辊 jmŽªÙÿ¨å壶 ©�4a^ïµÉœ¶¸BÜÛ^§Ö?‰íseWÛýnû»!‚-1îý„fzæ jÑC¢±ÄâØT½N¹µ_ÿâC‰r’@"œ)Ù;jé.D¹y‘aAOépê»ßµ3a:Ði!FôÏðP Œü†7-µùÞÍ­ £¬&Ï^1t[[ðÙò§{¥ÈC?C‹å…¶ƒz¢y×ÔàíÓzAÐw¥×³ÏÏÄÄSms*‚¨MiŽË“s˃=·7º'{Ö©¶W·ˆ·ªt*ÒˆšP¬Î£. ÍóDþÖ‚ NCº¶#JûhŸRy¨£²”PÊÝ^V['J÷yŽ<uÑŽgÛzòåÖ¦Ô b}o†êÐuËâNpY‘×­E§B'ëâ™ôá‡OOB•k'uJiêˆÆÇ6ñ‘µ¼"m,ZÚˆª&WdkÁNñš(1ÿ¥vvár ¨, �~<Z’/z²ãN'ÍAõ>Â^>Ðí’ÑTIÛg£©sf\}þ@ÏÄ~7Íûü ëö‰ê b›,Èm-CoŒ&s%¹ŽÃ÷±I›Ž Àî(€EQzø3(áÓÛo;å– Ç¡ 0¾®ðÛמš¡TÚ˜O't¸OÞÜ×­ÀÏÖWjèØúï1­'©\S„½$U{ec¤ìKGßyZ ÓàåiÊ€ÛÒ1Œ]g“÷>=§ÍÑ,ñ’ýîÚCÜò@¿î)qçˆîjÆœ½îölÇÊ&Ÿü3Šéˆi°AÕp‡³Óky÷®¥å O:2¢FMƒ^ÒþÔ‹ªÒ·rFD*¹�ˆ4iTá¯6RØÓ½Zþ‚4KÇb'8OU¾ë©ŽÕyÛÍÂ"Îð·mÖ‰,3×Ý‘nF¶mL'x·£QŠ¢m%¨æ »t8`Uf…Ç…AÕ ¬ÕžœD‘ú™yÒBÝŽCîy¢ÄFuˆ¼4:ÜöÌøîXC™ÄOdÞµIw ›¸¼±ÔÚߥ˜ÖâÈ0¾™§]OÕ0‹rå=¼ZéDžæ¥˜Ð L»£k(äȆ*¾ízrMâð.ÜãÑi±7#»Ü=³Ð°n¼6šî¹äÐ!6­˜þÂCÏß’Ú×V0ÿI /T^'Г|\—Un£hÙ2¨ÞOfd5­vÜy¢ð�P/«½T”¿a(`þ ù_¼™d`-RÓ`ÜÂïÅÊ(OÙô§Î›f¾æ®5ÿÞq2·^Ñ2 Q]ÑuЛ ´f/亱“„p·ÀŽÞ¨¤ÆÅ¡)…ÜWPY)£„Åz)?9;aaÛfæÛšÎTFb Ûj‡ï½÷§¦,JiƒÉ]yÅ[;ö‡’ÌEº$È­î1N?zxšÙ¶òßú.›x£|x P¾7NLSê&[öi¥ÿ³RЗVb¦ï>¡%ûyvÛÍ%=.ä/nOýOv…ÍÉ�cÍK*v竘7ôõ™}<Þl…ÁĪ§¸Ð½á> ¾Ô%S`Y˾—Oqæ/7ðÐ|~ק•3Y—6"1´|¹ËÌâïJâ¶�¥çP%Ë/ Χ«‚bxwÊ“LD«ÍDëE>‹sJQôбKè«u~ÉH&ˆL ôH8E§{œt5ìö<‡÷ý£^6“ÊœWdÄö“óÝ-Û&ðS†«ùâÏ•ò}{8a¥Á4dAºõ'À eÅ)d¼ÔÃBOŠ@7xLñ‹®5¡Ýp¹.#w“Âgo¥ÚSG¹0t5(°N½Í‰p6@U¿`Lgä¥ÁhCܹ"ê¦Þ–a›Îa¤è’'ñh–¤óßv†Wƒý©GÁp\ý¨Ï6rvv†×žÕÔyê?=૯úöc€š£ÝA,”fd¡d9S€)çšæð»îƒÍaý¶¿œ¹{Ú’¨µ`†vâ B&"ôÉ*O<kŠæ¥KÒf]0òøÒØý½Ó,´ñBÚáàÖÁøò§ó…þW¦â¹õrLóo°Âȼ°�Ä‚ëF\讃È_ Çy(¿m« ¯×N“E}­æóö0ð¸úÐï¹ò|Òø.3ºFgíp¤*°é½–&eô­aaÓl·á²¸Ö±l ^ÔIâܨ4UÆ§Ö .x*Ô‰Æ&‹oFÁ`¡‰ôDÒä&ö´M©¨‚ØúiÕoäÉÍv®ÿtÒµ’:¶nˆFÜŸmU @ÚX½yöY; :úà0îµÞÛá„¥èЛ‹#=v˜EÝ":,!!7B¤)²¾÷õœ<nÑ‘å9ÅxMWÉ"@<PÉÍðœ2Ønh'[^2OêÁͦãa-ûç�Í ïJþÌÒ& ½œ ßôǶQEr ÆaÂ5¾Š¹½#^‰iéiKö­¢uªN,JÔþÀ›˜íõ¸p,B¿ñe™6öéäa÷È2’›&]Çò³îj…Üx”ªLç5žwbÎT¤¹Õxt1ãHÑu×rV%êWòܤZ›•â¢’ö¶Ÿt“cXnsz“.òå[+:rUlIþõ@$sB‚΃ƒ.‚òÛ»Tà¸tˆ¾á§¦ô´ÂÒ00ãy t¤¾L–‡é“iÝÁ-/êI.Ö‹ ¸Ô^€°‚22Öƒ$ÎdâЋòº™ÏŽ¦òâ<Ð;7jÞ1µµMNbB‘ô'¿×uO2/ú3ôqs¢# ›ZO®~GjU~w,zÀ$¦;ÂUž}†>(ÃшJÓÔ…&µì†1Ž£¸ ôêcÏy…i8[xïŒÙP b9û6ç«—;»³²[d(1d¼�wü2£e¶$;Obüý®Ü³ˆ€Ôl14}/«OZ…§¶3D@Ç�}òƒg[ëšgx–© %Ò£Âcñ,§#¶ýø:V¢ò×x$` ºÃµ¶ ›®>!¤c]M»%n€ö™þ'ͨ~¨9úT\F'¬öE¶pÚz7]¼Zƒ«Æð‰6˜JÔߊÕGiì\^ΞñѬ¸àëD‡H}–nñ¯ÚÆgNl…Ö?è[x6oN^Ïa_Og"¯¡Žcú-I$–? u)8ã‹t 70¢Ä¨¦èæÄŠ¢`!YüÚ†ˆ}¥ì„ ”²W­Šº�q¬‡Z‘“!enî+˜ñÕpnØ8Æ[Á®ö´^ÓÓÖ›âmèÖyLƒ³¹—÷®ìcµÍ$Þ·2/ ¢atøp5終Œèñ^÷‚h\+#1"Ž‚©ƒŠw=8c¾ n)e­è™]Ýy7}“rWæؘ§2O’\ˆeG ¬'ˆ'BC£¹¼™N<  N4ÒxöSC=¿ŒNNjÍتª:§”ù²a§V–\™ »Âcm‡|cš® =K¨¸ù®Æ’6çEw(‹@ò" -K¶Þd[LÓ =qÎñØ.Ü£  ½æ8¦” +µTÜ c±Î5'øæÐVMi ŠÇRÁ#[òm(ªÑ§OÞ?2�Á²žM„™äÔüÔ^ÐÙgzíicP!% ,5SêËáãƒóš¡ܶБ¤]r¦ø¹jÿªMÝæI^XÜÖÓÿh†’‹¡ðÿï_Å縟P¸©Èúw‰‚›PU†MÕ×ôÕ¢wkùX \g¬/Î}ªt;;÷…n#8W'tgkÐ.2Ðà¤0ëì ¿\02XÐè¯ÝðKœ,Õ]#†Ë]5\š–©’ö†bCTëZÕ~8S׌^6ª_ib—eæ9hEs¥¼;jÔ0› ~O¢+ë¿«nûú€(G¾'ä!‡Â}R‚Ì¢hîŒeÀÇ“'Yfiæ)ù”¬âXmFÏðZ o �í…n/$/O†½–h WHΛÎi4Å[YH:§M“ïpõãÜaú@U´ê™ä•Á±Kè°è/^áxi�S€BЦÃðÈÀçïºvÀoÌâ!Âñû»Q ÅÈÌ4šen°9¦¡éA<W «Š+b¹EB¸®}ïQÚؾn|s¢€Ì5àÌÙÀÍjŒUÛÑ §øÐVÛguèi÷¦…-Zb·{:u¦àE…ê(sƵÂwYÁˆ®ÖŽýÀ`ó™ÏùOê´~œ¥eè{³„Õ$q¤síå0t[ÍTù÷nÜì*±ÎXí÷è„V*:*ŒWœ±Òã¤8 Œò)£s²¨ÆËTj߆Çܳmï´é\á íä2gïu£mãã·À¤(ò=�"6âñÓí,(\¶Õø’ˆž­åê—B.{-ÌR‹OS½¿¨;¡RƒŸ“„ã%Ðjú”N–1 <eíð‚÷ª:CáÂo/,¸¿”½)¥¤Eà¡"á…Ë;KUfú  Hy’V{“e â¤uÚ<ª~²•tèjŒöÝÏÈü"´¬ä¯r®i×çåÑM+Ê›Z2289U˜ó³¡c]{!X§;ŒÐ"v”m¬ž28ãÔ[{xNU‡¾j[Õ<ʺ£§¶äž…ìú¼¾X=¡$_ZlÿÔ{ X\ÀA Z[ãäZº¼vèK+»)µõHq ÈÖW8Ý }n­†TQ¸V´³ üÎW¸ô\»KììéGCíÁʜ؊mOŽÛK/ÿ`¬H§µ|ÿÅ>ŠR´ëJØ„AfiQÄÖ(=OóíDßxY}}Ä.£¨éý1b3AT{l1”Á¸IΈY´ó~b‡Áíè“j¦Ý‘I=ÔRÏ™‡§äYö‚ê:*­—ŠcÖu]:mXpøT„@;5ŒõÝƳ¥T)4(–Õ°­ÿt˜ýj›4Ö‚B<Üë_¼x²Ð¥Oס½Ö ”úéР/~¾(Ùˆý +ÑÐíTm~¹à$e{àZøú7V'Zwüç6'«×£“›š-š#²?dæ8MϺwnô*49N Ú柼êWDÍ{¦™Ä\Ñ=¹ùÅs# ³Å8§°/á"ÀœGŒÐì;ËD+“MÕ¼—F´«E; :öû³c9K Ô>;ÔcY²Ò]QAýebÀ ‚ÅWž/ô5¼ÐÇÞ3$dÏ·ËdrP–ºâq¸<Œ«í«ô dn$"åe²¸ ˆ€ˆï`DægZ&•ùÞ¹¬ð�Öle´…çBk5ÔGwC‰V·›:glC_JZ—zaË¥n)³¬ ŒÒ<:ƒ¼U] §Rs+Ϩ2hìúõV·ª¤25·§:úmlØê¶+rVžÕñcÛ@ÿîc°F'`_Igçãâ†ÍºÒK™óòĀŰ9Šø*ÕqmãnåçëØ„+ Eÿ™4]\ù—еùÒ°ELLß諈33íb Îúz½ ²ÈË5s¶ƒåRÚšnÕ’¢ÀÎ]« Òi®{»™y΂ơo¢R ³½±˜d.E�P¤×€”ö8Ò¨æûn¦µº^®~ô±\ÒïcÛOªb&m9Cð‡TsЬÁJºã’çÞíàÖ5•Q¯‡=T@Z6ÍÓÄý—EBö½Þ¹±è42†:/‚¢<D•ðl´ÉA5*¢ÐÖ¶Eåq.òÉU¢ž£‹Xyß{.GŠ'¼ =÷X[ 4ê)`ʪ Šƒ è—ЉŽ<J”G IèöÒØ^z € \k_=Ö¡˜‚G^Â|jã  gù¢k —32„Ã1Bp_ŸïÁÈÂ…†+Ýêv¦»°nÝ|›Ã$~m½£B{xAO0ƒ7¿‰2_¬‘:§ƒä´±¶ŽJÀÒT²g¿VÑTSïýÍó´ hÁÞÁ*h,‚²ñÊJ¸¸µU z"©KUÄØP8<õô©¿T 4B4Q„áäj_uû]¼�ãæÄe¹ÐQ™¶ÕÓ‡ó�nóØwú_Žû“ÜÍ%˜ù~f™ëµ'ø%uÂÛx:Zñ׺YR‡$ƒA˜Søysb?u.3H—n‰¾¢ýÁÝÂXwèiyD¬åA!,ˆ[¯(ÙÔçñ —°ÿÒm.= I%ÊUiTÝìyÞbrŽM±(•; uqýXÉÑ7øHY!¶¡µ‘ ñ¦ï/óì»×Rº†ÒG_oûÿN$þß»/ ݺFú˜Ùoýš"%Vë®, ý¥>äõE@ªúÏÆ¡£M[‡•š3¹À÷u|””> &0âTÝàׯF…ˆûGž†L,4y/ð£|bp^¹»Ãz?Ð ­A=¬~¦mmÕE¢=’zàôTSt4ÕEë“žÖ‚"ÐtÒ<õP¾HÈ‘æÜ Î…7OàRqØAöÙ{³˜í̾Û_EÇ•—+pmôå7m´à Ø/*ËYñ`£.š®H›Øö…y”¿íŽ€ªqð¶6‹Û‹%ÈĬÓv›…wFL˺È»5Ò o*eA‹{¿šXΗ÷è-V=wr¾ pk;PY†ÁLE20rÏ;Ó¬ûßb¢ò Û×í8ï槥Ýk…!t@ü˜XbÂÕ©“xlp)ùÑa<ý j™çB þ{Ç­ÒÖ“Aæ“È dÄçžïËÛÐ{hÿF)Žö q?Õ”ªozZ£ê¹E¨e²ÄwÐ(2ÙÓF÷«ï:÷Üd’v…ƉfÛA:8ÔNÉöÒ=•4:ïèWôÐ_”t·]â0STÄ>æpÛù·q%CØ|`*}Ç_:ñœ‘ÀÓqIÏ+«¿Ì!x'=x‡äÜ„—¼½¸?­–\É S¾4È,f$â‰ô¼¢3CYHuc cöâ{—¬È%Hgº§õ–[keP-4™¼v‘î¿s·vWK«›(óêà }¢0(Z+qQBïT_¿;n)9¶¯OúE¶ß"Ó Ê·?fÚ•-{€§5X¸KÐ霓9vtœÔؾPf¾'„Ìx~ÕS”9˲­?0›ïó[þts0Ç’ßÑA²Úö¬ïðH›$ú§ô :‘èêÐÙºm=f™xöÇÌnèÏ>úòˆ‹w¥Rƒ±Êϳʥ#äêŽ%ƒ­y:¤å¾5„sQú˜±Ä? /1<»7îVb/ÍNù/ì~›A–¦=�a̪ÕlÑ¥¼d‚Ükø÷M5⢜>’�ÆYrïÅ–DR-˜-â7&Ë2F?`˜ L™Þæ©©@Ç>ñ“òŠÍ)Š÷/;‹Êd&ÇsiôGïêV‚ HBOƒ"ÌüItÐNG.Ðji9HØEûŸíXÓYï€)<¬¶g¾òÓ·$bÌפ¯Þ+ÿŒå‡ÉZ6‡I£Ì«¿“Ðw-Ž!™OoYvÖo‚™Äí!šºô•÷Êlñ¯Ê«·:G¸MÌH.ú;›§þôÇ9¤˜)–¶yLwÆéݽ¼U(B_$ iXÓ‘$SÖˆU Y2±Ÿýèã[JãTÝ 5­ÿXÒd!ðfòº2âBQì)w'Ï2_Kš’Š¥t:ËÄÛ›4]ùFßG‹Ru:¬Ç<È-—Ç{c $Lg‹åÇxF€¨"“†F£§’ ^÷¾UÜïÚö“êqo¬Ü^Ó²tx½ÂP2Ï¿“ ¨'÷ ¹•ÍKüµgB,¨(Õ$€œûQÒñî^Z(éabÇQãÙrWÑ»è¤?¼œ¦IRx~ðn„µRÊ„…”G#!k(կݦ( ={ Ì/'JyñÞòÙiû§™©""8mzýµ‚ØíÅ]0Ë+3Oa°§ì¦èØ \/{“­Oì8ç%HÏ@æy•yL»vp0þ´¦¿�íŽ.+¾à¯¾ûoÅÃùsŸGbÔæú>£4k󡧔D"”|—árîÚöüƆ7Ï›®›àxîû-ü,n›ˆyâK'P¹Ú'Uug·DÍk£g§ð:\çaÑ„ˆÃ¥ƒyl¿(F¿«ý´dyX<NàßÒDa÷hƒRA;‹>ÊnM©î ‹SZâ·JdÖÎJô\RÆT†Íä„ï`è€þ¶$”(^`À{ô1Lw±LeäÂs‚'±éc)ØÆ9p¤¿ë“ÇÜ 2ü7ž©‹õT Ÿ)soÁ›À ®ó Û!8³§ï'da­äMHZñ_Ä;W8]N>[¨›SO‰Õ { z!þ±ÍdÃ^Êòà·‚fÝ×àÕH;Gm ¹×ýݯ͗óf ¬±œIs²ÓJÚ'»ß—Vó;›\‰Z&Ûd.qNMˆÁFui£5 aGu26T×ÿV!ŸkÇÕ8R$th(<€¯­Z›(Æjå¾8‚Ë…hyAgü­ÁŽ€ÓqgdÿÙ'‚Ç+¤(÷FkÖ‹“yK”õõ¬lZ‹þÈsG!~ãºlmýO(QQêe‚¥hQQÁ“ôƒg»´?Lp׺CkÙ‹àí3sáXÚ4ëKd[+Ì‘%W´"ÃöQ/ù_+ì+ZŽ“K¯bNâ¡53ÓZJƒ´îõ¡¥Í.Þ|Ó鎬NG}iº¯þ.ÁªÌ|ùAz’<l-à ¬V½¼yÚCÓLoçNeFïÍÝp'¯ [Ðsn-%¶OÏäK DMßλ|Äjtv«jŒÄ¼5ž4UÀýçÓ ‡®œ‡ìÌ°æ'>®‰•\Qú~¸gö©1†Ùº>£¥#e@§ÉÑ$æð^¹´ÅIæÛ]ЪÙAÑh»”äö4Ò§’60øò'1£Œ$Âì4 ¹ìçÆ›‚à ÙI°y©ìã„Ö* …*5‰3$ýÒÜHø­wxˆ2­û<!¡áéλ—Ëö³üŒs©6 JË‘ŠÊ\ü‰T™õšÙõ˜â•Ø†‡I˜4Õt7Š‡©‚üßÔ½&¬ß<Ä–ß•8߸Ea>­õ½9Ú°®aÍwq’´uùÓ}¡ÿ Bÿ¾ Us„ZÍqˆ1â(ë&<kZù“çüúóÊ.‰Ýtk7¤#Ê“ºvñÏPþ@…»s( 3}IʉXQÑŠÀ¹KÛ X õÐ,N(’Ó¬„?él>ð"ó—µW‹Â”b|vÓY¸§z´²1PËÕáí@ÉšLÇÍ_Z×»ÞPǼ·;ô­Ïº+òjœY5%d�Š‘Vcâ{ÛGÆàk£Íà†w¬N#‹fŒA­C˜s%sç™ðô]J·c `©+J¤ì“°tDzõªN‘‡:+3,!³Wpw×îÁ×I~Ñ]këþ1$K–4 #`Àˆ1*.Í_íãÞŽªlu÷’CdøøGOBĪ³^0•eóE©‘À(¥-¡ * ØÊò>;Ž=G’L&Š OjŽúl zÀ¬Ø9Zñ· )Ëæãbì݆jšYÕiv«nØÉçý÷-WqY=‹­Ø 2-ÁÛp|õãý“ÛÑ3Ó;û˜á>?is±Jj@IŽ}m²‚`Eªqº«ëýÁy3Û$-<ý•ˆ2ðõòI1ÄHà'äD FËÉ�’¾Ï¥£Äc¸5èñÙ?Go—ûê.^~êÖ³d|®xM8G¦%4}”AR[Re%¬b…f¥7©4Ð}0z…[ÑwßiÇ;Þ̸ƒ6}pÛãŽÂTÊbP­b 7HÁ‡Á$}IÚ¿t4¹Õ}ÃP·Û÷šÃ*œoúØí¸˜emm™!¶ûzÖqj¤4gÅ ²jx}b:,h2¾XÆ4ÿß_õ½ß=ð°®¿„§`G &SP"¥bº1ˆæO¶]Çk” n­û®z¯ºçIîû‚cdãì 9Áz·î jŒ[T:È‘î²ÙLQZ.ðŠqÐl)•µF½‰õ‡`˜óNú¹/”•½/Œr!¥M@3.—!U¬C”ÿJ¦ÐïfÔü¨°;‹©Ü£Œ'ýdÁhÜÏg¯‡ÓŸ?lûøÕoÎìL! ;è)„$_Jƒ—öíÙÐh­b” �Ãá<q‡`Ñ¿JÜÄ ñ*‚.>=Ÿæ[,Ñ{yã1/øûÐÆž¹wa¬Th#q5õX&?÷á‰äV´‚ÏjV¥¾H…hoßO§îdVe•-Ĺ’`êé · O®9> Áã”6˜»µ°÷úGÙ%8K¦{ é2[@Ag.i[jžÁ Ê2ßêÕ( zË8—r嚊îkŽ¢ˆYZÏæGëê1%#ª5!“¶6f MXÎÖ¾ûO¾ŒÝÎm$Ÿ[ƒŽÀ‚¢Œg6{…Ö±hx�Ä ‚Ç@M´±È‰âSyë|"»ò Źýí«}Š2ó´1bÚ�±¹Ý:�Ì´ªGS.XÌ"h;Éx§gv±ŽL¦ê*çšy¥zl¥:?«±È¼ÛeXW÷ MqÎö<sO¢Ø5¶øP‡O~Ôb_:ÐHªÿ€G:Zѳg"<©°fçìÕº¤×Ô1#mèÓ\<û¦y7¾]ÞKqnsè`ÜCÑåÅ¿Œ¼¨^™Š4q§VÀhP€`ã`è  Ik_ö›)ÒÌs‰ÁÔQÉ™Û,QÓߨä0’9­Ø£MËEôÌå-óÄûÙÙ3mð‡MÄ°YTYé–êœ9èœñ´pÿpÔkF'Ç#z®Ð¿¬¡`æÅFöÜLˆ^Xfä¢ïq¿ñ4&·‚o‘ƒéuE&°3T³yPlÆÊŒ¹[´Ÿ<¦ŒQá|¢Æ ªŒê`>£+˜[_J¦f<©Ù­ÌP§Só‹î®Mï#ÓÔ·Nˆ#Ákúy¢»vLÆcKrù“ÆT––YåèÈ€"³D••ÀGÈç +æÑr¢¬¤Þý®³:Ϫ<¦¯äÒÐc镽Šží/x`ÚäDÀ\KF‰æÌjØjËÉEeY¸›È0R:å`ñ•‡†0ƒŽQÌm®_¯”ð‹ðŠ>n² ýú´½eÎk8u¼±ªRÃ7¡ºqïÈ^qegz±¡j0©§9™óŒÍլ¶á'­wóªµÆWªÖ<^ÒÂ)èm„bm‡e5Ê€§ô[ËÌðå/)d±æû«²‰ LÓÒ—5ƒaë²É)÷CÜ|ÝiF‡Ðvø0èÌQ¶1ÆÆHC˜üX)*w‘uª!{—¶V¤s÷a)Ÿ¹¡ÿC¼Õ2¬óÈÖ$(†­+F6ŒÀßzϯqÚ ÊÑŒo¡~x˜ïÂ[3ÏuŠGMK«M& º‡M«7|¾Ò€<W„�ªÑ‘¨—ï¾ëf¬-ˆ¦=ôæ‰c,x¾,þˆ«¸²6<¢¡Ÿj‹Â„ Ò®ÇN4X}0Ñ;ÊÙ)WaÒOLT»A„¶Ñèª í×ÆpËb}÷ÎX ›û»Ã§€’¿GÖï.­iœÓ}ï L¹—§8O/ zç¹bÜѶ^§@à§a¨MV(“7ú"ˆ4*Jç²ÆÐ@¸Ì$õd…9Œp©•ÈÍ_&©R×eçÔyµÏ(Ìèh©9qÈ5šö4ìU˜f}‘Ï|hA=š\YC•È˜&p¶Y{;ëP¸mýšæcÉhqËFŠ‚ã¡ ’f^(iS¶·Eÿ̈fX Å'Åb¦Ç6§ §Æû¡1©œòØt€-ðxâEÿT‘1ÆÍŒÃìá+ ë"V„œPO¸œX€±w_l¥“ù*TÑ}$Ç/‡Aó)±ŒÆnÒ$}¹ŸW¾Ðo¬ÜÞií yL3—¾îCÜý roµ=JQ7Öý!eOrÏÚèµzЙëDƺjÜ$˜ë|9x†ÒVW”†€4Üw2(zìûšÄÃÇÄ0ÀÒhë%Ï”Œ£—âoý¬“<ôA+[”–g‘À_òI”\mÙšÁ$s÷¬n"néõð¥ü«)À'³+æ\`šÙ™FñzÜýQ˜äáx#g•h=)| Y¶Ìh ÀÈÀ«º©ä˜»îøf]îX í¡*ZV…Þ»‡}\º y?¼SÍ|¡ :õwa?¬Íp8qÚ?!í·PĨ‚ýävÐæ´³€Gÿš Lú"èÈðÜ–»¿ô…D-' &*b£v%)J�óU'5…Jß‚‚¯M×kU×x(þ‘F‹-ÁBœptlÕŽ¢éµñ±5H :k¨ÆŸîZˆGIº�Pˆ }>X˜Niä¨Ìý É׬tÌÖk&Ú­ñip JPèŒv~'¨&!Fýw¹,ò¡¶!$„Ñ=úª=K‹­ivšvÈ­±á;¸Lv•Ü4cIUbé*¨Hî2ófÀéÂG³¾¢oNQj²]–È*Æ5© †#- í—6îr -|Z$Š$e‹J}ç‹°#Œ²¸|ÆåOžàMT€êT±Ý”T­�dm­ÞÝ·\ PRÝPa£¾s´±ã'è G"€ÎkZ`Ø࣪ãÒH}¢XQÆN ™‰ }Ð{­!꧇/_Ýö<v_¼R¯^±—Ë+<Ü„«Ïµ(ƒ”¥zãä«„<·N2¿†OV3¯ÿ°y‹Ãª¡]ošo¸/ž)YaR–E -¾Þ† Î¥dЮ$ÑÂÂw?ŽÖŒ³º­‡C›c<ãK‹ŠP‹¾Ÿ‚Ä¥g&ž =¥ ¡%‡ö̼aäî€EË1‘ c~Àoúû‘.ÎÜÙ˜¢»9°’╪v\Vöî6˜XqÇÄ@…¦šr½bë…2+Ž¢™$:%—ï(ìiæ³<iï³\<ž½ÒTb‚©Çæp™~V%žÂóä{Šƒééb{Ñ-9ì= ­{«ðÁzŒ,Ü)2Ûsâ9x ÔúpîÕ"z]ֆƿ žÃ²Oå‚Kfæ>@“FŠ<aX½áœ íñ bñüšû[d±¸v™oÀúöq¥L· ¡ßyùi&[J®”AÛet€wZéqR ±ºþ`-Iš®?Ro^ ¯7*X`1cˆÔÊ]pt°u_eô–[d€# Ë ï¾ÒÀ“"‹s'V¢Æν×æÚØ¡“|1Sj•ÌèÖ( vL¯àÿCço×ï9ƒIäqYQ`®)«Ê¶*HІ4>å ɽßðak4çÔ±Òb~ÚÕMS‡~…@Ÿ Ë~ãYXpð¡]µgL¹¨]qŸÓ £ÐÁÕEäØQqò§)kö=7wúkžL(Ëê ØÌ«‰{¦EsaúèóDç{45^’ò,ê]tÇÌ(YºÐP:Qgl§òÑ­mÓŒ—a{Y—öÉ´A\_ð– ½é ä ìŽiËÔ~Òæ!ŒÙòå~ Lw¿ÊÍh€µ¹ö˜6:Ê"®v«n<¸'±®w£¨Xü _ªMÑë@ÕI² ³ø044ֻљýYÇ4G.”Ñ´Gû«Ñ²)—ŒÚH¸.°õ¯úèT^§ cl/+Œê ŸòV:¶»…|?u«ÃaßðúFëíEÑ·,qG`ÁØù¯‚êïÚÕnÃi^‰° …Õ U[?!‰Ä 3RÜ~TLñVÅöha ÷á'¥)·ÙX@þã7ETîZWÝ¿énm,Ö™w—$ê®è 3h¶zqß%C ɬFÎ÷¢÷•Þ”yakþíøÉÍ)2zèâ©ÒOëÈÇ¡1JGÃv<¹ù…=ø“+üIº€ Ðó`xfú>»Djîf«LÕÕóþ›i%ÎpŒ±ãÍæ耒¸£0R¯Ñ7WTãZ4yîôSzsé úD§ZgÕ êFtúÞˆi²°¨,‚éBG Öù‚Æì6|¦™ŒŽSã¡á]M°ƒ9—Œ¤ò9MôʱöxÊ8Ž,Ɖ–k“÷Ý/´~nÏ1dçîÂï×ç¡É€½NÛ¥PÐÜÖ#{Ê›)ï·=‡Ñ^¦xëv:–^S™üek„]˜NµK Aƒ%î[íFQæÜEØhÂð¥ÛúÀÞúLÜC>`˜#èkùþ{x CSÒfls¤ÊMïx@蘴ûîPáe¹UÕ« ¤"#òôŒ-¦Ð<sΙ™¥¡}wî®Ï¤¼tBMxY0ОFSüÓ3÷f‰UÐ×4’®½Tž˜:­ÂØŒæ3à“š Jd÷§†ö´­ÌÑ!Dº»ÚR<õwr2fÎ8ɬŸèÓ6Cð)è]²0à7•I²^,†ÔÚï5δÇ>@„k-š>Ã2òÆD–ò]÷*N=ð:ë~N“”N˜M,Y±?­ÿ,ê~_«èú7*ý¡;Θ<>lP'¿;è#NÅËä÷·–ïÏ\à«Ü¥÷S™`„Óøu(­;lºJ:4úô„ÏãCF k”·`Ïæ³€o–Ná˲´ž×—áYVÝU%ÖÓ}Øž(okp;çÔk|iú? è€„Êžç?ÛâñɪäÄ ¡$ʘ›ÎQö‚÷%-Ìëè¹ãþá�" =ã)ºwç”râÖÄ_@%~Fo‚¬¤mŸ¥ÉÕãMæcƒ+œÆÓFÇå)Kf©tµ·¢^[\éBz#N‚ó„NÁÖ¾}(U±d#³gÇ“P¯VT®rÆàÑk£…ûF)d ¥ÓÔd³óäÍ´^;*Ý»’2±µnº˜v•ù’;ŽB¾ï–¸l~È7c§;s¨(6¢\"tÈ2lð×ÚL& F̽ÙlD‘Q#Ô3®e3nU4JßBƒ‚-cz›Rd‘(.Y8ôÆû?\¿†Ãdž‹N0V´@Z(;ïØ°Çá½^jj[~i$„ùŠÒŒ$ b«¡ˆ<Œÿßùï‰õ!xëÚý ùŠ»Ø¢Ë1ŠdÑQ¬‚Si:mš•…7÷W¨f}A—ù‰“Ÿc E†·×kZu´9 ³R:…á¢+õN¬õ¸G6x|ž):åö^�<²¯™IÕÀtœÓóÿ~¶ƒ…Û7Î+G7ã>¹΂ÒÄÙ˜éõ¸ûs€‚§¦YÆZ ø{´–Ô!åÁ%Xs&˜Çª44ŒT…Gíàû¥›~´õ&6õEëôÐsŒ'éË=ž„Ž1p`aŸÙØáUK­¸¼"b#­³âøÇ ì룕¯`M”AZnoPIDÆ»F‰þŒlUÊÃÌ ·cNÙ­JÐd¬Ÿ7b]cvP¥^ïò¹0v”+:DÙð—CÉ ÌÄžóüiÕ–®Û‹x-óKº¾¹˜ïø]äêÀ°Å¨D'¥ì¿÷@Ãnµ=ôõ$bH²`hËò' _P„Óæc)ëîV˜•ÃµªSb;ö‰îzæ?þÅÒVô.˜çTÃì­OQ2®ÁìÙõ[Uþ:]{·ÌóãÜbÿ‘yÿÇdèx�³3ýÈaVên¨þä~%é’— ™È¶G5 ;=¿ûzdבæ™g_Lß¾ƒ¹Å® (êêÍI·™³ë»s%i—aMX¯ÙÄIV1æóØAüeµŸ9Z ™ÿÑóµf÷Q¡mÚY­tpˆžâ„öâL‡2{bë7¤f„T<–´\;/A¡•‚rSúQ̪¥'Î÷ù'J¡¯ªJߨG7Û²WR4ºðΊï…)RæÝ&¢0©µÛÀ§§ ùÑMÇ®VAýáÑUÉ®‘ƒèbÍJñažÿ8üû—ÖRšoÒJ¢«Ã~£å[`uœhFR©'äo¨-< †ÄœMd"n"9»bšA·ñ}ûÞ.òMu™ì¼:Pè¸4žm¬Åýkeü2+ŠŠ’ضäyþ]Q§¼Es—ŒU‰3²ZÚ íÑ¥•™¿|£êI¿sókõ›ÂìZû©qeRøé êÙ,Ì÷}OµôäÓyð¶§ûYÌ>»t­„X͈¼2Û»¼[„[²nšc:PùÍ'/†jÑ(Z¡Z\nÑw#¬Ûì�QtúÜÕb {p,6n€pªf+6Ê\óA8Ú¶yÙì&òä#¥“À)±.Ä t5žæÕVZü¤ÿÎ$% }¡uº_‡¾ ÊFSÔ¼”0µ÷!”+ˆÈ ï…YS& ös« ozT+ÆáØŠ™œÉìúqß]5ü+DzrÑéPAÚæGƒÄ•”ÌŒ9~xùI±0ÿ{zÛ÷££mEÁȨ¶ß ·:ô储.U1­y«5=·±>“mºhüM=\•™'YæÁªÁ�Áör0ôßͨŠ¬­ÿ0-“U_an! 6i j0£\ a]´Œÿ/(0/ýU•3•b` ·Ï“´_[×^ÛYtàˆÝƒ^Ý-±KW†ñnjgZ½5ê «š•}³´ê2a²†kúsœÃ(3»ó Ùªê´qr,BðûÑ#Œ¬± ¾ƒy `ˆc¦³ãÁEà ëMÔóeð®žY9‰&i£ÑÛפK•ê‚ x¬üënw=}Ô{Ø¢®Ob×{󋆕êüß8(h™:‘>naŽZŠÅçÉÚþ0Ú• ¤MgÔ¸€R5Œg4ñWyñ~ó dt©3ñÊùÔm�^µ^šp¤ðhíI^ð‘S ˆÌD†rУÍl௥iÃOÙæ·¸«<ô›ëÀ”©Ï[s»„ã7pÎh¦‰~vÞ²â?l@‚7Žd‹nª`ÖìZØRîÉǼ׬'9‚îIæ{îa Ì<Bs:Þêz¦Üa“Ø!ÈD×ðp0 hûcÀÿ�/Í0fw�N„‡µ‘À*Hƒ|úòD¿-¦”7#hŸâÞ(rƒ/ùŸ»áµ"Ý¿ŽkVh“4zû;Ôµ=#/³Õ_:m¬ ?³µ¹Bcºª©x¾·ùË— zä×´G²V …Ìݧ½—ñÜÏ}¬$Xª;ëœøc¦…œeÖééhzrOÕ­4.2ýoZÿ&Au®íð5‡?tSÕÑIæ.~¼w$¤™í‰°22Sþs«Þ‡ÛÒ .õhþOÿEåtÓGï0I·è©xÖ²†Àj[a¶&¬=æZ‰Ç'“³Ážkç„`"G|Ç7ô/‡ô•‰XT¬},±j¥“¨ÚjÇŒ÷PBö<ÿê»V8ãߎŽœÆgÀ…ñé +Ûôõþ0B½õþoùaWaæÚÓ•ÈTDÌŒ¾Ë{ Z•†î'z‹Vü?FzÕh‰[lѶqS8å/W¬V¾}bðxE‘º?j›žÒ©rbotôc$Ç-µéo„Ëœ_XiˆþÓLoå#$ìè<âï_pÖEuD¯Ä¦îà J›I '_ÞŒõÚô¦®¼ì“<óݦÙÂ’û®±1,ÓœÎén}+·e5‘D(',E,í[/2ö»½Žû^$ð,ôW ̚ݦ‰ª0*<ö) T®(ô›U1¹ŠA`æaéé£â®RéðÉJ Wý{Lj>cÞµt�Š½^$ãö­dÄ1ZõTÈÀ9Êd…÷ºm× >0–áÀÚ#í…=˜¡å '¿GvO±Ûì(OÃÕt=Ò¾¾ƒ‚/ ¤\7gÕ6b˃/ý->BÓ¹n+4+Ã{\‹'§ÊH¤¶áo•Q º8Á=z×þÈ2©oFÀœ/æC?4·ª¢Ð?,±µO Dà51ÖÁÏÄ .tj'ýU <ƒ'NItEûcÏ—pRW ª Ö ­_-ŒÿʵÓË_8¿è= ÂñPJ`UeQ*³ýŽjÂZ�m0V�³«Ÿ¼gGFÔãü‰Þ¨§iÆ@Èñ0ˆL¡öCP#!²z/MªkÎ’Yℸó Új7>G½Ü9uà0Õ`àm9JãÌë¤ähåðlª]ò»:Ô«­%ÉHv*B¸Ûs½›ÁŒš¸)ˆG@}^ôJ  6éCÓÖCs1í@0Û&©{á“'EyåÅ8Ÿ1ô}E´ 5O€ 1w­1 ÆÝ ¾ºískbÐu”%œ\öÈñ‹JH;¡IÑn!où/ýS… èXH* Ò£uºZbÇ£¢}T6ÏrxÊëæ’:š`7 Z†ÃÅ#o¨Õ…DNªe‡=N-¢´ð¹ÛtÂmkºÕÓñ*ƒí\èPVã’Šò®¡U{ÇŸ¯^î x—G*Që‚Üüe-µJ–“]½Ë€yŒžù‹BD[õ¤_¥ê •FZ€ó§Ëé‘ Â‡å5¨J0Ò¸M_7÷³30¶5r”‚<ÐÕš©×š²ùQÅ!KkF+¿Öi¾ ‚E”EÙW·š³ ¶ž~³aô‚@]‹ÝÓ4¹ÌínòãÂÄA½Å„(é«üÓ¢4Œ“ ¥aì");ï…¡»9䵄¥`1 ƒÙêê**_oeôqO¡¡¦ôj¾‡£Ëmô]µ¥¸Ý8ŸcݪŒ¼£¡úH”êon©vFínëºÃUóådÚØêÜ´uŒPÐckm¯ûiF>G"×lMáW€Å®fþòýiâ’”Â0?†¡2N^¦Ýˆiv=ÑGÃñ”íÚ2æ‡å¦¥¼e&ØGƪP†èüÀŠwµ4óy&7víˆ:äƒíŽÇB¶óae­­{. ªÙ"bòB”­ßÞ[{è60¸bï8ö„¿Õ™ùøJ#ÏĨ0´ ?!F2Z¬è¶¯ nª Y£ô—aùƒU *ê{Ìm@6û4¬26)ê,-…†M”[±¸g[Ó9íïtï§Û"tGZVéŸÖGd6XO†îÙ]áΙè¸kJ÷UeëL–²ž:JBgõ¸O}iiÖø¾ÚŒÒÛ‘ý¼ª »@̧â€KG¯e`²Ÿù®ßfΰ¼™5\ωoçÆyúæDFÆlqkVc½sPíT×Jµ˜ävB"dì¢þãc4.«šMØÍÃT&öµ±dù3°°º¯„NÁ÷w¦eâ¸5I}ýˆ)¹»4¦ËÊ*qô}“5E¤s“°Ò?ÀuPïMê4C!Ü^\gØÖ­\à^èD`@ŸÜ)zìÆÕÅê³õç‹2-f—šnm»µ~êô&3{$ ±ƒ‚ÓSTš4]è)¿hèÞj T•êtør‰fóõ—çYb;ËBš&ÄðÏÉÓOý}¸€A«#pk²v{až=ÿaÜ‹Œ‰PåQ»_yÆR#½ïËIGÀ ½/G€º˜Wò06xU,6£gÄ ºÿzMA 65ÝpAÖõœ¢OÄ {ò{óÌr‰1:ä@ìõÀ+é IÛ…ÇžCw˜§ïÉÄqèMu>ÚAÙM–ûÇ\‚ñ0Üí:>äáÆå•@Õ0У›¶Þyå°”š ýå, ‡'r;œsZŽÊ)NCÐòèÏ­{ŒìPƒ |£F»‚–ߊnNé;ß*rÅ$b úT4äuµLofÿ­8XV¹j¯bïP.¶Ö©-kº=8‰¥ ”£æ‡´<;é¨ â`AÚQ`Ý ŒLï̧gj¯d·^á%6Hwõ©æDÖæ{Òk)Üܼ¡`üg×ï¨Ì3²†ê XÈYÑ× hÒs@'Šq.‡´‚ÒK.C¦^³Ž$¡ÿʬ�7ÉéUÛéüV‘øô-Šûë T¶í €ý)/H÷é›*ìu³§Û_¬/}{í³/Fj©xÜΦ¯þ{²úy?p¹Í<ûIt×&ô7:âbåà"¥­¥ºñœì×Ïú_{FUÜüÆßô_ýè·+ì±VñéÝi‰û- sÌ}£!ÅZ ráÃV>IÂ>ì.ö¢[ù°FFþôð»µW÷ iqQøþ±´ãÇ=âÈ—ôÐ;ô°m€¢äf#í~ÊL8)ç/£¿|(Èr‡ Ø”F¥ãàÁj19U_,¦ô]ç.hg™¼…>‰hª(VF¢_ŒUšr×_‘,cÜY&Sî2kÑs!rïÊkP ŒÞ’™9R™!¹˲—þ›¼u⥥La¸ZVPåî7Ðh¦c÷ï[´Z Ò§A®õ‹}´u „¢ÃñÔÞ™ÂX¹ñ…Cf@ÇRØ(®�–«~®Ç#K(zWÆ3÷R÷þ0Ù9A)(‚ öOo¼ïV‡Á§¡! �ßRÓó¼é½;ºø$´]‘ÐqmOÖC‘æ«uÓé`Œžg = 8«Ð mÛh|\$”ÁÁÛfá3×´Æñ¬V'Êe<‹œÚwÄ ]XáÝÉ‹(㢪uÓ;±ï§$ð4Éü �nzÛ¨·”æP¨a2Ü^W 3êNWÀ{Sýd@1R˜oj¿>wBá…l{ëv>¹—Ù¦UùÒiëÂhGý¶yÈÇÎXf˜:áàÇ0ô¾;¨w”Š$'ÛHX>eRQn¾<z½eZ…c·9Q…ž[ÆÓ¼Ò¹e¢dÌ'êëÓ¶+‡âIÁ¸I!a‰u0Ê’(¸x§¥.ðB!Ø»³“æ�ÅPlR‹'ÝŸÐr2Q˜åtCë.äX÷›»Õ7$ð8̖럩ßA²U»ƒÍN²F¯äÏ‘ ¹=4C5 ûX³–[:Ž§ÉñѸÛ@îâ©[¶L9™8 ÓÝ ¸îç)N¿¿T´Ì! J×ÕSYŠ=áßø¬®¿C'W±«C¸™/­­úf$•í.Ú~Å…“%gÝüâ1[Ë÷ÉPd6U—³I†¹:¡<X<¸¥‰7bB÷ ªæ¯BºP¥B–|TÇÖQoÛz_O:iäûÄ+Ê_ðo¬Œê­~ÛÑAÂô',vçÁ|0_’ŠC/g¾LUò{ N¢QÊDÑß43½$8ÁÝU#ŸˆêÁ2”ï˜weº0Eå;ñZÓ­f \Ä]¨Ø£¨Ú36‹T­Ú¥%¤”/ž 9\&®5Ï;ž¾ÂìÝ ¤;÷»2õtÕ]¥8-¤oÙ¸è9qTp«:wXu«]ÿvìqØð³h=\p¨×Ω½4j!·­D“‚ž÷—mœ†EͬÐïwž£ ½+?à{ .­õžöÕçÏôGìið@Qý‹B´‘f²( 9¯!¶TÏ›ç'~oxž()ç…[ë™h±à1·ï– ¥+â¦k¥¯f/úRµÖÁö·W¬‹,rðOöþÂýÉÛ‹™,±·ˆp$€â9QÝ—nP¸$×dÀ¢“ߎ$Ð)<óÿŸ¾+§Ð ‹<ö-ÈKVÖÉ ¶ȧ #ÞôBGOo�ñ‚l¡oÿarú»Sg5nrÓ/Fªþbß\Ø"œ*©-;WÅ„5E9…©ØÒáW‡ÏS7›Á×ÿR7ÞLu¥£˜°ûê–ãàY¬úVñ5# ÆN1¶ÓDâŸñ%U¶„ö`œ­7ª¥QB°~²2šOFÈ¥’"S\¯Ö�Çô“×j ºû ¯`JŽín½~øês#ÒµÚS©›ÌŠ~-?ß6µÿˆeË¢ìÎLöCë]Ù=ÎUJAqšJPËìDéßy8©Å"À_æϔނxpê*lˆ“HËÇù0~žê ^÷‚iÉRÛ& ÊÝ3 PÄžó¦'wLZãôX<7ªÊ ôa¥òt²t‘áâÜšUz2GŠµv ¨<*A Ž%Ú]få55è¹ôDM‰å®n™ôIá„ݸ‚î;09.Gˇ ¸oÈêwèL×\‹4ÀY0¿t8S‰¢?Þ™ —©/³f莔A9^<ܪ¿´¦6š)wÆŽ´¯w”‹ÒĤ°£ÙåÓݵ1¨s a¿¹ÙäPŸ­ñøxa…{œÜÌä$â Ε·³v»“ªR7×.zQ¸ u,P>B :GåÉhbLϺKƒ/{¶•Â4ŒªÂªJˆgÍ0–AÆ?…+Oû£BœDó÷@ÏqÂ\žn÷l¢u=°]Z?B­š ‰Y7 ÿ×ק±ë]#ÖÍ\ç¨JÉ„D—sžoŠ#z.Ê=‡ÐB}øhoð1 b—>ÇÈÀ}–^;‹Ž#dÂsz;öDÿwݱà; 'Œv¥7qWwT—£|a†Y²šJ¶n<dçöJÛ¸'§¢eáó_áéf®Îgk«íQ8”‰›,uƒ¯²Õt5ĽMœóøÆ/JîÙ•(↳õö)y4?î(o2 8e28î'ª¸ÕBÎ2p´ªO PŒÚBwª,ëxZzÁ'ºŽ&<×Ê06))çrÀüAùyô„qÇcDí6DbÁm <»ªx .¡Ì1ƒó¤ÖŽ œîŒâU_ )™Õà-ÔñAIQ)ìK×ö=òˆÉ!¤½ YíÚ{h¤,49$¿5í¦-ò‡¦ Ëç'ê±ß�í6(7zò‡ýôVÿêÞ>9g’ä©Ö|7L‹ŒH¼<#ö_Ž´š“F›Mð•·»³ÁçXBêxÚCŽ]«†²‚+·ó”Ò•þT avIO«ÈÒ9ï=’gêë6·WÔÆyÿX;�—ÃI1L«ºßx§_è,û- ÿÕÑšÅá¹:](?j¾w<3A°Òj:K¡½ú`gÏWˆEå³õ(Ǝ̦ýÓ8¶ÞÇŽõ…èŒp\¼—hzQ^^Q’VÀ®&ƒ* �®Ô9‡¹n†Yˆí¡ÐNnj:‘(nmäûøô¬ÜÁ¹F ´U´£À “¥ü>gõÅõ‰]¿)õ÷pá—A Ÿ0¥ÜÚÈxºà‹|íÞf UÓ+÷¾ ½©@ÄÍ9$óññèYÓ 6ß>!ož¿ËãuA†¹)Þ.ŠÙE÷î†UûúÔ:\ö=EæÒº«'¹SµC~b¢HZÔGw÷ùàã´øcw<Ö_Ï â<»r#i‡(ä’ÞÜw¡PXÖàÔ׺òö»iÂXæÀTRüïëó†bêFÅÅvKµwñ5y4~ N¬~ïqäÌÀ¾žwãX_kgøúL¬¿é³ ­{PÉ8øl‘K]ÃÂ1R<, Ro{²š=É8H[w¤|~²^º @€yk:ljðÕiž+ÕÄ.ØD‘ôý‹ ~c§ÂˆÂÁ±?Ð@‘ÙuÔ7ôÐ+rîÞ²»gÝÆŸ=2.Ý1N™¨Ôßh׌‚=ׂ÷¦@¥'l+]!Zùe£sBHW†c{ß·PyRJE"IiÊd^¤Ÿïž(éÀˆQÓÝ¢Jd|µHË=g%$,ñEù{=zŒ f~Hëf!Þù mìZ±Q{8Ž´Ek;3fd j7œ¥nŽ¹Õ ¹ŒL¢k‰6 ´ì°¬d}<LÇnõ8Zß…_kš“tñ´¢ùcýå‘æt«-¯D³¼áùÀÀÝYä2'¿õUo¬q&¾Fõ‡òÊD@㹜8w éß!û>XU³,0ºz³G€ùÈORúªø 6Ôï dh#P#Kš2þAÄb—?=·Á°GFi0í ×¡«ÕMêɱú7Qþ?5ûêÁ{îhCßþ^e¥T— âePÆIÌb”]_ï\“ûû‡RdW_MCK}úò\ϸZê�­»zƒŸô[[3¹âþo½J8* GoªA 8ª¸É\©6Ö�-Sz�×uZ——`Í2öHi˜ßÝíúºÇÛÎIËŸ=Á“H%†úN<®¬3]ÃNÂM§U=­ Ÿ‘> RBé{6)nÚ8qû &ÌØrª1j1£îlÄ_çÝïï6Z’ç<¢ÛEUé'±”ãÔ=lh¿ÎŽ)Íàφv[’†½ ·>SîåþÃò;ƃñ݈ښ¢&^±µç¢…Dù £ŠtCZò5¹Z¬%\jÅösrX(¹Þ¤t6ÔsÛª0Y˜©GÁ°¡è¶<q%z4#'•b5‡…ÐÂýÕØkó±ô'¥òAÖj4ßÞÜßÊýBò×î|Î¥o¡¿Ê†ÅóDË¾Ö ) ž‘›ñÊä’°Fn|å@-È2 ]Ö»q¶ }ÀW–km@d¹öhL-íÀ \7ËòâŠ76&AâìQ#4,wk®MxÐ~¬wñ¾jC»yciÔ­Ø9r:›83Ð (þÒ=Ò™ä$?îQbvÖ-�±¦ïœ¾ú``þ%ò±»ú~.ýÎ öìÌÓ©w+(g‰=’äÑ9B|Ö#üÙ{½$q0§ Ôw¬Ö¤˜œ9Â'L“–ñvšht½ 05]E»wàBç&r广ôÃX|K‡/ϳ–\5¬¼¥iéwiéé ñvwŒÓ ®ß€‹„¦Õ(áÃ^Pa&±Æï¢VŽ7Ë3&Ì‹1#µB®¥ñ_¨ê6·k×(Ó]]z3ã( —'8·ˆÒÆR\1[2ƒ^ᨠ—T :¸ÞCJŸöc¡Hp¦cæÍi(²“gã‹ pœÛ™ÐH€UL›Î2]¤>A*ú˜Å*õS@(¹œ)|u:%Åâ¾xF‹N΋¾LK„;ä^BÝèEå 9ûîykÏ5¤—ÛúHÇ|êöDœ_Þås‘yË^Žt6Ô}AÀr°ñûÃpa¹UÊå}'ˆúøíÎÄÞ+BLœ/Õèþ"È&cíØ]RjÛy?B°[V´"„¶uTïùHv:=ðé‰s`y‰Ý¾ss+:¼Ð$-­}Š´õV5åŒÛÙb ÒëÀrÇ¿ôÖÈÔ‰®ä05},`+32…ÝxÙˆ©¢QÑ®÷ŒWa]®EÜÕ}߀ؓAKyvÙÓÂÙ|ša u> æhÇôc ^B0$lÀA—TªËjý±ëSB¨ðJ 嶇}==ñ‡ŠJAÅÕû¾åp±Np1”ˆBêãoJûz¾Åý}º/“v bz l1&Kå/ –"Oþ064Êi.‚t¶·‡'󌿚YÔ…»];I}Èæ"N…ÁÂÌ”·§=x«ÃàüÍŒK-P}Ÿ“Ç;ƒ/)Oº©û–Ÿ´y•ôè¹faœÝžWPe>ͺ  ƒ\]ãpq”î3:šìÓn/ï#à3\j>昊í)âÙÛŒ e‰æ6º¯ÿò7.óA©0/ÝПÞ^üC¾¬¼ikM!Ðañ/wu§ï•Ž% jžqPQmh"¥q 3ÛÞã%¤Úwõ}…§Çm's‘ª^ú=éZQLãÅ' ªoÖÀebñŸ¬ä½vør <ûƒV·4 †Œè)¶J‚áYö,—¼¾úwžèŸ¼½f å(ÇTƃe VÝnÜè¯ðviß(IÛ_†KÛr…Œr!°Ù\(¼Þý%ýï'ªÁ†_ªQRc\€‘¶³Éõ°H ¬v®s¶¼’Ï‚F´a¯‰•Œíð/'`8Ø ÓŸU±«ê˜dѳ“Ó4z ¨IÏJK¿R|T/ÆÙBá*úSÄ­õ»ˆdn“á&0T£=[çÁ²Â&ˆ}Gµ“Õým¿=_sÙÙŠ {Wö­$D¼@FD•XÅcãQtèì@YÛlÌsû 2'ÛËga¶}¥¶ö˜†2e¦ríë;žÆÃÝ>³k¨¦Än7Y­u<P:Z’#r(«þ|„”açLož¸ß,¨¯Ìðœåh}=c#GDDdÿprq'œ›ä òÏœ&PáŽ6‘‡ÍÒ|PÞ­:R/ibsÞùœQôì< ?yšÞK]jn/îˆZ8‚1=ºÊ/¥ài \x]5ÿK8bfWöÚmG™}d8×%¦¡ ëÜÿ­¡Ö÷ÇœÆÕhÓRô*±}ÑÊÔˆçuÄýà9q<òå˹DèÙ”ãÃp@D–¬py9û²O}«ÜÊR%Æ@ƒN!zÖÌsxÀ»}(t/eM+Êg)î&ÍÑ›ý²µŠ2‰)©CûoòT è:!ݧx’í§•­¸Õ×Í^çÝÓ ù^°<_(ÆQŒê€u'ï ¸hø�˜Š8ð£2k$(}àÉþm×p·Ñ¥¯3l(ܦÓäXt˜ \šuÚ0x7À¼vÀ¤G!Êã…¡oH7&òöËÃþù!JíÊ—Yî~Dmæ°Œ¢´ ýýÍ»/¶5îkaèpž¶J¯”y¦0^e~1‚9nM'WØv¦í–L 5šé dþØñZz0ÍÍù'ŠâI°¢ýŽïÊwP“–4œmîLq·§õ>=ƒëúäêBì”é/õ<âk°8Ç¿Y¼O)Ù¼|›zÄÑbE´« ™… ”¿XPBîNËK½ZN·ŠÔ×U‹ÆŠ D¬4CO°ïê=qØqÈrÉ{1Ž,¾>=t$’…ÑlžžŽ"¯_ÓÈ4òe(@gncôHÞ;ïEjovoýY3‚¦½xLûwæN¡i±7[�Žïž&E#|Z3ækü5*¡Mˆ›E…Aq2 “_,ž¥*¥ÄîF‹Éd¦S‚Û ûûZÛê‡|Ê�¬æ¸2ìY¸œíhè©þHï‘r£Çz4ÒƒPá‰?;¯æm¨Z8¹R¼¿•âqþ¡!g¬šš¸ ß(cû¤éƒ6*3Æ€‰¼ýwø‰gl&LgzØt[±+¶‘¬Æ¨?oáæ`ºí‹œŽ¼­¢YÎ/‚";˜P*=R¾ýz³RKf…¢…lúŠN{C¬µ°œ°0à=Ò¤|î< 9Hö™xsvÃË}'6¦p¶—*ßœƒžØ™ã²Î@ݽˆ&´¹ç84”[Œ›‹©¤w÷h±¨F¢=BK˜* À§™.DÒäèà¡ÌÒø=MC’2“µ¢ã§'/q¨?„1'iÚ¶žSwÇ„8­œÃ›6ŸÓã*æ­WÁLÃØ5 lbã×ý…KìÍÁRVjføOoç2¡ÈÁ~xjƒÜ£Ö×™g|ÃÆbìhre>ûÚ>ƒ®¿}¢3¬> #º‡Å!a#G@^“Ó9” ÎD¥Qï;v:ãDæƒâ>ÅλŒþ©œØ#ÖI%çÅÐY?qÓÅ\*WOó©iLÔÇwB áú·ºç¥ÄrƇ/ˆ>ÔgO@bkÚ‹D™EŠÏ±Ç¸rx}’¨ý¦°R­/¦S3Çw³Ñu¾ªÏ“1ɤ( ÿ.øp‘GÜáh‹|湕•8í‹šˆÑúSô'ÅFÖØ]yo¦FŒ¸+´'Ó˜‚ñú~ EKÈÙ Ç9FoGÏñ%`Uä3y¸10•”€µ¦ç"Ï\·ó\ùjqšyؼÂëP6LÞIDz¦r¿kRó†õ.G¯´žÎ•»JiØxVV­ Àe µ\8ý “]95YÑædš~2O�þ€=½x ©¦Ú}û™(Ê3ÏkîíúBßÛ:€ógB‰ |y²–$‰ÓødCÙqÓZî '˜‹ÕnO:ÕA$Jq÷)þe–JJ^’ê³¥hS›œ\d ŽÓ®srô…Ä"'eŒ3ÝÍ=½÷¨Ð¦*»3r]‰�4êbmÑÍŒ¸ƒ÷sÕ*g ú9ª…b{ûügà—îÏå2ÇŠÀWçwÅÃWZ¸®©/ÝBy�Bq#æÂÊTþ¨IÑ:x>ÔÉ=`2€”j#LT«lÖÖa–M+<$õoˆÀ× t9hsÆêââáNaé5¿ ªppÝ«wµMƒr;{ZÛNjW+[§ªfT+*”ü¾ý/Ü3tv\¿²ÆÍq¶£hÁ “Ìÿ@å&Mc&EõÖå£åÐy'=°»«ñ°ž äz‰mºˆdåôÇÎ^ù•qÜ ÉOµ¶Íu.8®Þv'Þw€ UT²LpuTàIɆp$Íb¡Ò¦Á`‚Å䇟£ÐŠjÑK¤´»É‚tœ<AX=èù()v½Z©åìö2´Œë[ªxæãÂ]µ‰rc3/¦UZ8—ÿH_äøªA’Âõ%¡œ^;1FÑtWÜ-z=À¦éÒ«#çyh>ŒæÖ}Ë!‰¨‹Dv&Ò ª7ÝߌHE‡²ª¬>&ðúÔ¬9 Ԟ†¦n”vy›ù�¥™;pÌ_S‘·HÙJ+t<~ë댃=z”WÔn ðRÃV1ÁRÃ[O¾ÓȺ¤×¯Ë:+SIáÊ`ÇÈYäÍÖÓl_râo,°ß\¸Àk^Ž=½Xè:A~H—c=‡.…R]ídØwf_ Ѫ@ú_K?2ÊŽ]ƒ·�‚\÷±=§Lú!£uj¥–k¸~4Mç5^^ rTìÐØ‹ÌŸÝn=SÐÈ¥G¤ÍQ&DÁÜ”™ˆˆ‹Úm ïÄRÇáØ0Û.˃pVRÎ�2:–‚©Ø�· ª Åvƒ¶ö‘V.µ)º2 ñÙˆÒzé³]÷÷zuh('çB!€†xh'«BÃs Â"«2gå ~÷Æš-ç ±¤a³O \õÓv7çΟ‘u[¾xÓÃn-‘„Ñ{µC×r7ØË–øúèük‘¨ëp4,Ï€ÌåçœæM‰ÉÎ ¹žŽžÞ½Û¼ru‹¡Ônø‘nY-ltsè;%A²éœydÝ7;SÍÑC>$ZÑ-ëÕQ"ú¤¹aubŽ9¹`Úâ¸g ݳÙF8±›pñFòm×w #tù+‹<vz\ýèue ¿2dɃ¤÷¼z¯$5édÞ6`m`a—ªØ$|7=}**Yœ ¢¬"·>e —-Õ¦S§£`&°öžïª—ìØÏ«üüŠf©&‘ äbñž)7y×L¥2ÞÇ:íV®¿± I¢ÌÙ”ø¼âŽñÞ*%Ö&ÀBðÇöIå8A²{1£l¸ŽLGiº Ý< Á‰‰BÓ€ÉÜ·îÅYbž@i1âèËvƒC†Ñšöø/tîMVðõæê&îØJäŸò û´¾Iüöë-•Ö´£ü§«)I܇ð½†sTïš½wý^¥ªl»&¦dÃþ~‘¼¼¦ víÚG¤îlŽØp§—ZOE/Ÿ÷IúÓ_Nªá‹]«uÒ·XDx÷œ—#Xƒjf�ÀEÊA÷š·NŒ‘U"£Â"è廢$–B ˆÁ�cãæ(2öeQt ü–<S´30AêÉ]"‘A÷BåÉTBÒaŸãcyPêÛÐ#IÜ U™¢¶©ƒŠ•1ÞåâÂb÷8 Þ|>W”É|™ÖïÔ.Y–X™`Á*N^÷þíÅwf9NFj²¤µNÞ,ðÔf$R`N> h©’l7d!¼ðSI:b(Õ÷—†]OÔ3c¸ -4r/èá9™9i=SPAѾ[ëqÊÞ:uéK™D¯_Å»|l÷f›2r�WB ¨¬ 5à|\d–5=8Š’]û2+ JSßmˆž¤¥«aãò$ŠÍnÄ’¥÷?4R±¾(+…±oO�5Þ·¾{3¢ÉÉÒ¬-2wbŠr;JõÅŸÞ¤&V6`—–ÍÅkS²‰ymë±£ @Ù}öòž¢\b °rƒ®oç*HÞ­@O`EµŒ¢ }Ù† yÝ•øÕ]9#[C¬š÷=XAƒFÇL  ÌŸòÀ#¯óÊ(b¡ÍÚ“ b¤ ´¦Öu×6Ș†Ë‘nóåeó#kð$Ž¦0ëX—ŒÝ¸BkC‹ ñÀ3C¸§0±›ˆ£ÔàºKΔ¡ L§7~mîoÄÔõ‰™Qžl6Â[~EÖºJT÷Np@þxŠÞ´a6ÃÅùfig$£{Ã)ûè×?C"F=¦£ ïspîìªmikÌEO|f˜-^ú wB¯ÕÍÌü·ÝBÃI ¢ŠUj•™‰ ‰<Ünì„¥,»ß;ÑšÒàVŠÎ+ ™ô= hò΃‡màýBÕí£D O÷u¿7søû#–ja O#Cëõx%C‘Â&ãÙ=µš¼"án±P%¡ïöœ£‹¡eÃSИe@ÿÅãï›>Õ‘9$¨¦]+ó·»ÍäÊW-ƒoк_'VzXÛ{é*W¢ýá VËŸîµ­b÷ÁóØCˆ°U1~¡9ó­’fÂâùT+#O3èBqPl:L*¸©–jo¾·+ÄAj>¸Gúª=ñ|!ÄÊP¨Õ6§;$¶d’þÖ®"_§„]à’ ñ4mÍ»MƒŸšÉ'Ñ0Rb~i"—™Qß“IN¢ó™ŽƒÝj~åŽQŠhŒùgdýÚÔm |ÒAY+ã‹ }!‚¸¸ú™ã•? ]NF_ÉØ4`P“ZF¸ñ.{ɤ¡,Ü$%æã¿M‚ô*8CKŠŽR–>æÄÝ›cb¶,~wœÃ+|{!ŒúP 5¢¨¡l<éÉ„e°ÝЪZ׆ÇR:òÎÖqVëóÒBÂœ*åÞp;SñÚ ÏoÜ/tyàlNó7v 1Íóû…7ÑšMµL­puÔGJZy|XÈw…'Êf<"÷½]ÒÿSQÐ< —VC—£˜PŠ ËXP6zÆŠ­Ž:e×ý`ì;åõ¦'”«ögj¤š`Ë^¥q%g–_°&‹ÿà8Ô¹™ùh¼^ÆijEF¡¸5>nEÉbÌh.´ r%$­F7Bzô³.ȼ Πߎø<¼ ,æ=JŒ0þôA*4Ò£i\“±mè=¨®þâÉžnySÂÅtƒz±ÚŒ&ä2X…A¹9¼XVPQ× –Z½à†o¿²Þ+}}7xÆ8ìá~Ù{lÓz°ìÞû‚üßióáBŠ­¦ <^uºŠ'2ù6 ²9^©À½! ²VuÔM8G]‘0 pô±VmzåI|Z÷f~•:fú%Àº™è¢¢È âÒV'‘E`‚‘¡—òB_y"ˆž§7òz¢ˆð´ØÝ_yøà|¼`WÑRežÏ­ˆ1­Zèq¼¢ˆly>èdDBö×·7ý×Ê—¦±ÖÜûAÂ½Æ M–’`Œ©éÃWΦ.Ä•XºR¬ñÄPp«ZÅÚèèX¦RUâ[¥Ò ïû"¦]¥)!¦”X6 Äè†` J•þõõ†^uó ¯ª7ó«œ*b*3·_èßõÂõgÆá[;ˆåÆ9èzšÕõãHÁþhǯÁåžûú}<¥tu´˜úK‹>¬ùlxBßõVx+KòŽÇÞMQÑ ¨™JŒ@œiþÎte(ŸÕº2Oœ~7'ŸÀBÇ_G“Û¾Ÿš]oÛ£§a7¿åéZ§‰OÑYâD¼T0îó ?Z3“†ÖÒ‰Žwå&Ñrå4V__3.rfɹQ�,ÞX©pBªAH;ØlÇÁ^0®|è³h…L÷žE›0ˆÈ¦í–îÌ„PÆL¼ Rw²‹±q%ë»’el®ÑÔtÆ(ûcÝwP?\ˆî8¡µ;J;£¨ñ<(šÞwO©}Ò¨jÎßØVçYæÑV(_l,Tì Êþ–ëa@cqè+Õฯéžf£ }½°¢kœ«èŒ`ý À~#;¥å¼Øj!¦²îÈÆê批P7üT0ÕÅ!œhô¾·NI®(zŸÕŠ-·Ìy ÷ …ïÐ@azÿAë²°¶‚€,ö'Ê©ý=’N2ah— zšl§P½ÿq²¢H°l×ÿÔkýð37…<ö€î"}¦ÛÔl=» :S6ô]fAì~çºXDNÊ#æ– ¥¥0^\æ‡rîÿ%ÔÊ ŠüÅ·n�°³ótŠ;Z=“˜ÂXÃX3"q/w¶áL ¹Ò™ ÈVé=M†ŒªøËi”ÿ ûéÛŸMŸ�®/ë±Ãcù®(•ölŠ�\`ˆÈüýÓjMÂ,6Ult°ˆx§ìÁÃ|豋?2Ýýé¡kR©:<¢Q!{¡sf<…DúîŽEEY’Ëi{˜¡Õ õæd©|/4¾>/lýÐK5Œz³N¦F·ò;VÄ ÊMûEr¢IC$þøeµÀVæð>šTü¢½uR-‹Üò«•¥>b<ÃC~Œ«e æBåzò|˜ ±Úî\ï×^.'á±'j¢2í¢Ï‹I锟`&I£w·ïÝ÷Ê)*e"¯B.üRñÁÒÙvœjÒ7‚†¬4 ïi2ƾldÎp’‰xÐÎÌÜõÝq‹doË¿o…aiÓj]Ìñ_ÁF’yz(ipìaqº5l„’ wIÆÃDáíØyq-°ÿ"”É×h¥(´;¬pe ×U1åt­$k»ãĽþ¦æøê©md…-¤pl·%3n"}Ï¡;Ë™}ä‰N_4?út´ü)ª̼–sç*ˆßÕq7¯m›áÕ÷•ñ{d̉-r›jÉ zÅjwCÇ-a¾+%#C·Ì$¾P‚Í'JKYÀF‚M ›LÝý5Fô:uá:cì†ÖÓåÓL]²ŠmÍ)h5,0(™ÄO aVîŸíÐë+ö]v\NÊ®(“ÞtÊþ>&ys®øxÇz ú²¼Ló…|m *˜S 8ù¥ýo²Àwϯ¨JX-ù8r¶¯%Õû*lh¤êŒßï†>¥x‚«çK '÷û„Ô$qcFfEç,H>k[ôVù̘HuÅ],³®îïjÔ•žKÎ<æCŬâCS×K_ÓÇ’$TŒýÞqÍ­MöÃ¥ªy™qs Flá‘fWü¥=k ·®Ó¹¨ÂŽ~ÐJ’Å ò>¥Û¯22líå} �PÝ™Cˆ�ò®GV¸±gú‡¿˜µÕY¦`ÇÁÈœq ”–GåŠ~_•¹3 =ã# ²n­„¦öwS«@‹{ýï²| &ùÃæ.í;é)ð8žV’M×J8=wtÌHà6E }† ½óNíyýîY†úG ÷šöBî2ü%ó"˜äv—ä·šá•Kß/˜Á€#d‘Ô€ÔÎ,2õï "ܨ‰’šÝŸ3Y+·ÐÄZä[¥MbÚ{ÜiU`îÏKR¢‰g2(­‡/Ú¾k#£ÇÅss>Ã.Ç$Kôk'±½`ÀÝçÃEYêŽ:®>zÊR‹Kí´äçº÷(4ªüc8œ¹B[ÀË}u)j!ߊ^³£DQG’hýÔÔâ0#cÀ8Íðâ~‹n×÷Kž¹6¹Ÿ\¸NcèƒØ�›ã îj»ôH™†©‰º÷x¯Ú¹WCf¡l´£ò7|r-𠔌¼Ñ‘Œ;¼eñ V;ÅâùÿþßôÖCŸLn­ýÛ Õ{–±€¹–t:Ö6_dBÉãaðzÁT ï.ú»\LBLÂ1–9 ƒw}øÚ€gã1P—_»•2æ)Ë6×þ’:LOPúM>!} {á>Ñ–šåL8ƒåm•ÙÖ$-énÑèéRîÜùl˜Q‚øsZ R1öû.Lb7)Ðù¶þÈÂ…usÀ5úc/¡Ó*’ñzLǬÄ$Ü·7 z•…>%rD vÔYdÅ:€‡õÚ”ü¯ÓRÒš™­&B"¥AŠ:i{(‚Þãq,Š¼°ô‘íA2V[^tÏV)‚3^­ö_ËàFî vDd¿gñ›R™›ÁDÅT×´¼>¿<ÉP.ÐìÞÞÂ7í…PÛ¯‹Ìíï»”’££7™=ͽmWÞë¾Þ»Â“,-D­v36 pÎnæøS¹ázýïMŒ“‹j¤„‘€DóAóÑ´� ¹ºÒP~“îânø’QC‹¢Zÿ ±YŸÞ‘þð=dø|kÜwín¨…ô^ ™áÊ ý@ÏB^ðrñƒ'º§‰â_z å±Ó ebÆ•Ãlš™/Sº$¤•n²Ð¸¹0¢¸èý×kR”¥)ÔVˆØ? AÄYæ)<$"w T˜i1B›xE!_�Ú(*c-åñ ’§Vº>1ÀAà-â¯Á‡Ä@L”üù+ÜY<ÓˆLÃ¥Ý$¦)“6‹®&à)ªfŠNM^¥ÄÉb|RMO÷¨Uº¦YQ€ÊWæ)†}ʾ#úò,Ý Yk(Y´(¼ÆaCÙëìŒ=q]k¨3¯#³mºç|¯òõGU@h__Ö,ž9á˜Ä�Ï<Y|øk‰ìÐIT6nw¤ýšŸþ8M¬÷zõyêú'mF Ó; îðq‘šÊ^:*TKÑG¯{ßP¼LÝÙ’³6ñ‘‚Y±©=¨æE./{ÜþJi'©f†%e¸ô}fÃqýìlpN4kÁ@7éÐ×ÓcŠåÔ­ùÄ[ˆ7%î4ˆ¸ {)Õ£gŸÛõû‰2ýqy÷¶“lÔBÁŸ¸’e¡GádQf¤gÞ~šƒsÃm¿Ë‚¢ÎÊ[#@GÈvp²çÝá®Fà‡.wˆÞ ÇjÕû®ðôžYSìÔÃ*KýI$ç}æ.)Ês® /üª… üt)øÔpsÀ)2=*@ß÷ìê_Úä/ñòUC˜†Ûjôl!1·a0ŸL%»nÙÐõEÃÕ8¬\‡éHã:4¶@£È!ŒÅ®l¿k¬Ï¸µúºl §Õ²)Cß—R 7òf}_ÇÊ¥OÅÚ6܃ÛcÌn)¶‡œ§‹ }ñùŒÎ¨UìecôßÇ}¦@ÚêÕ c ͼ™…™¢mïßáÝoóÿ‰:“ ª Ë ¾ÓEØqcch­ˆÁÏ…¿L­ßŵóYg-@X¦¹6®”9ï6õ`þ½û–¥B*£V0A/çìÙ¹ÃO±EÒm9Iׯžm°V1ÓÅíGõI;zeîÅ+½ø¥¶ƒ³ yŠb°Ÿ‰µ¢g¯¦es‡ßæ {Î;è¨ðJ¦zØÐÛýà–±+I’V²âzñ\µÑ9íŠâ/Õ 4§è�d3c·’ÔÄŒm×°"dv[ Nª„ëÌ|×)åbŸg—§j1°1ï ‡4úT¯¬9qn“”ìÑlu¸³h4eöô;º ö½QL” ˜øª0«uAÉËfÔt53P£Ë[{7;v¦Ô…Vøñ0Ì—UOÕýËTŽj!l µ¢:*ë]RSX‚*2f\l›œÊãíÎx]îÉŒ"�/wÇ;vÄʦòªûJ� µl‘˜- [r§výz¬¥±á]Þ#zz¬¹8J¥‰gJçt7t~)ÙA'«L"(<GXDEâ*söÒYýNƒjÛz1M¡"-¢‡Å·©Q˜ßX»¤ìÕf6/\)6»ã¤%É·¥f¤f½¡Y6û”ª„îfdUÀÞ÷#€B{òa2œk.Š1Hz{¢ZÙ[ï 8ÛòŒb+l!Ì çKµ?FQ%ßvF$NÀÄšƒe6A�dÕ°éçè¡¢äž .µ±õ$¯™ºë¼ú‘b~ärd†ÛŽôPg%‚ þÑqœµçˆ²×¾!µi3̺‚°šyqº8Ál*êw{PÑLŒøFÅœ)4¦8æ,`µ¦„(œÓÆS«-ã~7ýÆry,ªšæÇ µD2ã Ûè:ɸ»äqNxo¿™ìåg™»df>j„ÐêªelÎÍ+OÇøîyêÎUíwäqLtOãÎNÖÃ@ZJªàýa°XjY¨`µè”ÂÁûPÙlûft‡ZZ¿¨,lë±Rz¬š"ÈjM· Á„d]b¦Ãvû‹ŒßÎU³Ô×xŠc gíÖ ÐÛ±–ÚÁ¸'·¢Õ§ós}uÕJh径ÿ³¾ö‚-,hÀûNk· }.uÄA1jeŽ9Îòã=«eóÆ  …¥Á.”ml|+uè]z¦†‡EJJ/0¢k-–™kuö$sÁLaý Îráhã¸ðÕ7qøt½½Åì�lpø]ßõQæßû;*¯·Êµ™PPL<”‘G0ìnþšNôX~íëñÞo¾ Œqì•1<aØ|-Ó.:¨(:ÁÜE¾ÐIV­J±Õú), Ž=µkÆ<7`7ïN`ÇÞLƒL4>ŒGÓ¾wWKßÈʯĦUÁŠèóä¡ §Cí9e>Nxƒt<î48¯©<]oT²/`ÇãwEô9ý¯ö¨*-ï]ÝÐxS}LØlÀ§µ-wV,%8û.S;n.ÒvA'ê[¨vµ¿²]¤ëÉp­Š”Òúƒ£ç›+ëî×nø…‘* {q=þñ¨ÙÒ!1­•—…YcÚ—Žtzðó]بÌ3ßy<§±Q+ý„bˆn^¹L—©:ELV÷É(Íq#Ø´-·ôéæñ\=Ï]φÑNcβĈWϲcP–¾‰�j(Ë×Õs‡ŒIª�Ï�=Õ]­j&¤á0¶˜ÈПWF€S%hÉôžÊù`„(lô–È÷ÖµûÓ YÈ­‰QæèÑJû¤ ’Ï­—“Ñâ÷U˜ã~ÏÏ]<EñT¡Ã‚±jÝlŒû­z]X.q@ƒ¡75‰ª­¡É*¤:ö~îšT‘Ó#´„±ü¬F˜yÞ= þÛ‚„ö¿+vÞ |H¬“fÁö⯲æ|Ñ×¢òT´OŽZ­Ð7¥�Ú;<Ïw '®k¯JpÀ£ÍE'6ûß:ïÙ¿‚¡EÂwV3qÀõPgP†ñb²X¢üd%ú'½c�Ì8h‡C³@³þœma ÞÑ›-<’ø3w#‹Z?”äÈ£Ì[eÄlk²e|’müm§˜-£ézÛª ýÝ AœvÁv«~niúöë-N‘ M¸ÚÕj2ú‚ tTÆî´¯øé^èx,íÀäˆèÓíºë’…!W¥cÊyûzµ½ T®×ÙÁ(qƒÿ™w‰ê¹X!pôbëm=+½ÛtæÁáöÀ —öÓçEw¸¨*Ï£˜nŒ´³¶:‡äÌ‚Þi)eGoó1Ñw9í“Ùê‡ÄoÏG ·À}‡CŸñÖ*€Ìá›Íý7îÏL8â8¾ÊŠá!™µzûãHV³Þúk=0ê}n(Yf YƒÇÁOïÞ ‹bØĉ¼Y¥´©f±ªÕ‹ïÆ•±¥w¨å6úæÞû+(/Ab°”êýpæ—VWî[«™ö]±Þš„,Ö·_ÿœñ¾]€SÍèScH¨ I—àËJƒ»ú³ñÚ0 ¸ñL+«QÓè ¥8q‚K6íÂá +°›ù€¦%9¡éw½Ä"Ï·¢0o«=ìk+hQ_p³Âì‰öj k´nŸ´rÏh­bX#Úù¶õ¤aý³uf[tn.B-æ¯õ$sâkìÎ0)œõä•Z[ðy› €ƒož)I~\îÛ-Âp±ê•TÝ®uÅf¢;{d×þØ;óPÝE$Ø ]¹ ¥ÎÀ¹tÍ!}5¹F·az3f›v2•Æ‹†‹ÙTÑa\² ’5žß×{œ}’É÷z«’žøtÎç;½ãQö™oÆÚ™ÎZñZ¡Ø=PK×ÅG;`ùêsðh@gàИ=³/šæå•n+* ÎAœªf¸˜‡aĉòµzWâ FlF´@‘Ñ?-V£ÂÙwŒXÊîÓÝâñÐÐñU«,Ó‡,,HäQ^Š é©&µ<ŘÉÀ *—Z¼�¹(<+–’epxSÔf’³ðÁíp¡)óÄ^½ £Æxð[„ãt±ñ©Â;§A4~]¹•%‚1Ôˆ|¯_ñð•,¼Sñ·ÍŸ #òÐLÝø»ž&ÃFyŸÆîuÇ€=&Û±FAí3jbOr´@Df•^Û8(âÁ—™¥bT~d¤’å®Q'Ëéƒ6Õ×ÉôàûŽƒ7ý `vTVi¶8Ï#EÞtP L•!ýÛz˜®_»}ûUÒ(Î<!+*¹“ĺDÅ,=s3ÔœÐÄåž›ÒÇVl]&¦•|ZjWcì%œŒÌò³ŽJ¡'¸bÉ)R¤”„ê8®¦?uo’•þޡk~7òÌg˜ÑÝßçAq´ÝÍ"”úŒ•œœ§[-Êsׯ÷çÔåUÏW愵‚¨ß[VJP ŽPÂåÝ«cÂ8)2WŒíÒQ)ÊoÉR%<¬­ãßs£Â¡Cé5mÌ­8-œ¯e’EµGm%e¹žG, ¬!öŽ,­?de†ÍêaÛº¨.0Ž"óîˆs,CËòs—6÷©|£@(‰Ôhrm7žýò¾¦çA± Û‹rNw-§—WrŸ|Á´¤}½;ÒžKìaT& !¿ë–‹»älÑ5],Ħ0vÛÇ7tô¾çAóûÊÈà`% åò¹bjê©!^P2 Ñ×íd¢ÊËŽáàÿ3¼8óya #m›Y3ô4ðèYÁst[¡CNFáöôæè½÷f$¥UðE#س+ ²Ä{í©™á\±b{ÐYm =ÿ•—…¢2¡fɃäýÓ3¨E—ýË4ˆ·»ÙŒ©™Ëÿj©RéÄ16áó\gT©|etø‘멦#Ý"6„q:ÕûŽêüpÿÒ@âM&˽Õa@å0ÛÊ!A€_¯wƒ¥‰Í[¶jý`]aôèÙý ¥c³ãÙ{pá1´ía“V^}öEY)m‘'ë+UxãŽw¿³ n6J̉ÞlÁÚüôQ"uÚ– È(CÒðG×<pwl½Œ'³Ûbj`”•5•ÓG›ÁÑÊû0Ý.ïò¼ÇúÊâ¡ðP8â×El)Yùˆ–‰’f?recþÕ%wï'�¨¼µÇÍIH*…V’•Yjªê˽ ðU Œ(I\8”±õ¾ð2B.4þ¹§‡ÆÙav>7ÍXïŽðîÊZùöt)0lÙWŒ[_G‚¹òfO\úâ|Érƒ¹FÁ2hã|Ýö´P%ælRž/K¬·§ÞHfÉvgžP\ó0[*'²î¼,gw á`)Uöf'~{éS*#øÈ-àb\kó™MÖ†“tܾU¸Ž2ÿàdX#jG¥âÔ«zEÕ•9ñ3=ñW#Ú¼;ýZõ…áBûruq–×ÆÐÑf6ïÝÄ Ô+—F Ôt4”î‡ï*œ Ö¡9íK‡Š-¿¢DÅT: ðéQsAÚóPJôÀ¾t¤‡KÝC+–çáÇú÷®ß<²Ì³Éq.Øï˜RĨÖúÐPYNG&ÄÖÖ;ô²W ÝÞª”-g…sñ¦|s ,}SÌr䬺º»±å%æ…ûW®­Yê3NãZÏk7^©A8àü¨í¾3)±íîÈøü ]ŽXãé’PÍl^L»Íf7üj.¿(ÙûÅ6´KáÃĨ 3[]ð@{’ â¾þO§ \L5Œ„ µ~r»¢ÐÛ÷•HTAµÑý‚>ø¦n€•Âá±;EAì&}ÀÍP“s©éåñ@OÞjªEÈŠØÍhô½Ép¯a2,¸·,™w€QÏÆR¬ÇnÙíLÍïx\6æëV̓e›EæYH3ŒS²øEÆg4oV[çÍ"ßeÀdMmÎ:Ï·×Fô§ÿQþ¦f*¹ úr^™62šÓV3_°-@ÌR"Àã]ýá.ƒ$ú§oÊÂ*¡PÃól04r€¡§¾öÒö |a)|Ÿô¥‰CàaölOè€{’çGøL[oF~þ§¹©‹ÏLÔöD9¬eöGH{à×$ºq–ß÷_þ¤u§0ó’5zS{èƒZ€dŸ¯òç:i�ýTž7.Cß+‚ÂŒÒM­6gÒ|göÔ]§"¯µºPWˆØÖ–6ä †ÂâVºçÍ‘5‘!8Sÿén]mm¬ ü1ƒóɹÎuß Ƀ˧*ô…C. S¿/[D¡Å`i®O·;iÞmÂW¦™?›¹§Âiî<2vÓ74ï%á{>w~¨ŠB¥f¶´pØœPõ|zœyIJs×”IiOÊ¿s‘Ñp‹Ó´rþ Â�bÏæÜÎ5ØmÔü©Isî†zù· |“6Y­­ÞQž‡â‚ïóÅx?û?è맃 ¢AÉÁ«ŠñN~/ÑTRûîËÞ‡Ó]¬J®¿dJœÉ¦—•1ÖmKå_«Vá°Y¤òQéÞqb¥¥ºÕÎÌ»_©Ù®ë7w <õ›Xg¤%œµ6W¨\f«å×õ ³ßå1¸wa¶–“�®zöíèéq,¶7ìÙ­óeu"œ¤}’É´õ¥ÒÇÃà5õýÁ-Nã¾ „›OT¦Iq^SŽWt½zȆFŒ¬ÕŠ_DºW¤½1OYNÅâàr :í}ëFÞ0þçHxåÑiŒ:i†ô"c¦è‡³Z,·Ýú`ů"].… ~@ÆLÆ${JÐþIPhÙÆãÝ‘2"«g 7ÚAš³ÄG7±ÜÁ5¶ö“2)“(ά²‡Kº#›‹gò‹u^üT¼t~çþ;6]»ÈÎ �«ß´<ÊZwß#šÎl»>+ÚrÑ%·zëO+kšÍN~†_Âo\ "©³êcÈй΃ÂrÅñ„¹“Ï.Œý×ã¡eà–½ø-d*‚|C¤()}h½÷|ŽØ(Q Zá_±Ì¨àªdØ‘ÞåkNEÞW°½M»|PW¹Ð7¡RM’ Ù­IÍÅ£C²ŠH7O㇤ ¢“e V˜ªÕ ª@$øóf®k¼¤†58¡YW~6N÷abWÁIëêÐw£f4r{H¯ûn¿›œ>³ Öå¿L{ÇšüV(.éܽÞì¢LД[š±ÚÑë‹–éJ_Î Ç·™haæE…CÁèà¶3-Y¥B/¾2E ’/¥³ý‰n“ƒ[ BŒ8ø#õ'¦«Þüë ½r.«4‹¡ü¦CÚc$|c#…Bg5=ìÃØ9û l[®eé©s°9L<¬\d'yîËÐbL0œçL¼`Õ4wÝY&ϲp8´ÒÈð:Þ¡Á”»”®Èà9—–Nk¨2ž ±•å÷%f²è¡ÒvZ­i}¢YþåŠò´·U×_Xôµ­OB £øÚ¶¯3è2奈ؠ±‡%ø<zÖSFÃP:ª(ÃÄWÕ¤ø 5¯.×¼NÊ…ƒXÊ°Œrë óÖ©¼„ÌH—˲Nl %'çü{JŽ3tÓ¢£t.m&{¨ç×QùU¡±øÊè É`”¼€"w÷Ûf Ou 6Yú’·1^VAa!ÌyjJLï×Ï1èbBÜDQlG2!Y‚êBQÙi,†’õ,œÜš1Ý Õ25Gø áÈk|s—ww¤ 5Zc¥ô×”óû€Ä©þÂ|‘ÓȇÙH y.K¥Œ¥`Ö´ºóqz[VŒ¹íÌzmгÐá°úÀP¡ià÷¿ð”ª„òGh·+xëÊ­¦6ŠoÝÉôݼŒJVÜÑW¯l¨7*Á Ò®³fQ}Ù‚³DçщÂgU/pÿ? ÆßXYØfJe<y÷UP®5mIóF#Ÿæ(ûÁû—eè¶BvÆì[bo^ýeîr@ÁhYÛ+Ý7¿°TŠ3F]´ÀÓ­Ì2”‡æI¾E@ï=q–Ô Ìr:öàÕ@d8Íšé˜ÑøÿÙÙøÍ/ËuTj�Ç”ðÒ":{ˆ°“¸3_—rÓýŽ¯ûËPôò(ÆYÉrÌlOÐíøoÝ$ôfÐŒáŸGÚ†˜…J[/Í çDi]W¯)P‰®ÖÂ÷g©5{šxÇJ彬H‘ƒêÑΓÎGóˆûB<~Lt] ëéÑÓè¬9séCç¥àz$™_ÄNû:Åq-üAgâ2G5ZYv§ ;ªÜ¼ 7énO–{Ô§”«‰!†ÿšê”∆ Ë4MÞÐn¯D[ X¬1-ýrtå¸ÊÜX©`Cèß:UŒ‡[çõyr$>Š­2‚¾«•ô6k[}]ÕZQ¬dÞÐH‰nt$†­½Ð@Ç΄Ýh&W( WÝ„nž…Q=ìþX ñ˜!¸Q`~å´iuZØ)DÌ'wé ÏÑx¦#pW²%¾h€Ðb8ÿqŸ~×3¾ÑöÜ o½Õ´x":©¶¯2”¡ƒÜÒÁŸ¶úî:`Y´+Kqþ;›qg ‰W?>$x%•ŸÛÒêj`'ѨhWRÈXT6Ù+ˆÑÌëz°UèD¨¬OÚA†pæ¥í|$ˆæ<¶/Š]ÿó—«š:4°âæXXǾé `GÁ€óÊõú‘3#©çÕÝ{ Œ£%f:Lûƒ¥y Gg´âAõ;ñ-òëÅûÛma<Â.³í ½OõÄåd–§é¼³TÔž>+¦ù4qÃ71‹|è—/ˆ¦P}ƶ;~¹<]{×ôf#ö5ïhÅ,/�ö€ÌéÝÈx²ÝÒýþzWÓ„È$Ý@%Ñd]°zϦþÍY7˜ßüê© 4X;§HÜœ‚³`5Ò°¤†HG±¤ôO£è,.í]}æГ6æ–çЀÅ¢a6Ñ·U‘zcð R›lêJÅ*óäܲúÀc-­==WpTïšD°ƒ³¯þÛ[Ò³V¾àvÀ| Ý¯'â ‚ÉÀÛÓVž_b YW€¬– Zjæ`øAy|cŽÛ¤Á¢2ô¼šhAŒ{Zhå`é:šjÀnk’Ή/î•ÊЬÜ›ù†qæßJJÓ x?».­`)QäIaàŽ·Ó×ï…ã̃.rŒè/üñ¼WÈÉ°u—,Cí³ˆ›G +ª�Åk‹O…<øLÚ5Ò¼ÿz«Ǻ;Б|eÈF§ •sÄõ~Úx/‘LsÖ96HÛ-sÛOÀsVÝk¡ µxá·Ä"¿²•w½¢l1€Hb‹Öez=NU1 ‡u7pÙ6s~ð3jnO<‘ ê\pcÛ¬­i×ÿ–p%³ÀoqÇY˜y#¸ÖL\ïrqwÈ Þ[QåÞ){‹ÔçT‡ ³ô}²ü�Æ)uä,w‘ìΕ¼&¶)HTUÂe%ÙCk­jCýú ç#}(DþÙeÒÞ-øeáðñõÓÿ®z¶z}¡®å}GõóÜycÏíÃÙáÈ6íx¹i œ »%^0CMºšéŸ¤÷�bÿú¡‡ Ç|B, k¦Ìi@É9i.‹:qßÍbO-v?КMb`ÇÊi)F½Jª’ÉPÜv¬¶g¦ÿ’b ó¤ÉÜeºA1Ùð$u"æ–{ÕhSˆò ÀÃɸLáe^níÊo#ÐÿÿyUS{¤ÐUß1T½Hï‰e<–ÍðUÀJ¶Ÿ Tµñ¸Æ´‘êѺ’NÛC‡ME5Ãô1ÈŽ2£PE»Azª{›ß°ÔÂhœŽLzídý?Å@K%àêÆÈ°X >–1åW×;ù«÷ŠpÞà‚V=úfÛ…‘ g{6Œ¸O6%Ù5Ùõþo½"“}OPÜÌC’Ùöäáý¤I$§!a,Gw{±”Ù’taéóø¯ÉëÛ•×ä è÷Ô,\Õà<vôýô…§G>ˆš‚öy„ÆîQïžð|8²·îDç·U*çÐs&®L®çzbqá%Ñ¦Æ e¼ÉÚy°Ð&wóìéQgÅ€§Î¿6u‡šs9ñ‰ìj†S”íì8zÖÐaÿR™y)K’£‰H‰ëå—&¨¥±ý«Ã‘ÂúíÇX)kÚJóuô>ÝÉ3Þ_ÆÖÕ*¯ªñgÞä…! ÇCTÖ ùw”µÐâUÅžh÷‡{ý\ýtG,VÎà ³j/ž¨›ÍÍT£ÐPª‰‡]2#I¨P¦JÞ½A0ô\=1Š'Àâ|ɘf¥ Êç;¯Cãv̇>éãóæ¯%–iééu¤ cîbxù¾{žl󩟺}çæ›ß¸? c0À¼›~~JuBRLËÃ7iÀ*aµáŽíP™fo^â5Išùój íÔ¸Ñj\´pox7=Ô‰¶ˆrÕc›ÿ±.~…8}òaŽëüPV8²%djHäó@k<ÎÖÀª¦ôaXŠ ð?¸§Õ‡ž¾÷4ÍufiH9ôWѱ<žš‘Â<õvŽï‡ár¤Åpyý„*¢ ­:C Ôf$˜�99Ã>ý÷ ”NxúY?«€ M¸Ýµ€A1â@ XD¾²¸„pF‹õ$&˜kØîéì0HòäKgÚÀ”I[Õüû¿ìÃ,ë±4ó›>ò“ªŽ÷—¡‘#½?:|tI)Žõn˜šs8µúr{ÈFUº°fª-:sß°¥ Ä=TTm»IèJ/êj¦>ë¿@Yv<äT ZN*;iŒ£‡v[ïó‚Ÿ?gáê\y¿õüšЀÚ8Œ´Šáø4нhN†ÝÊaMáDâß¡ʺC>ú/°¨P€ØX:Š} Çm·Çs5}Eزðw{ÌáÍЛŒŽÅóK½ciIÑ*ž±¯÷R,<³çŒ|4ëìÒ!›YóÇY”«B΃Ie3êv5m¬bk×x0¸O8ðZÎÿ„ êŒÉ*ÓTi¦„Þ¼³º†l¦Ð¶N¤ X* ÈœÌüU~ S¡Ì¸ç‡s¤ŸŸ>DáÜuíÂíë£ÞH¹¹£ˆàîr�òÃ5‰Á=°Ðø«*ÞæîÆÝ–Qˆ!.X°õVbÁœ�tl #œëYðy~•äùiä=ß-9ºùE}YiSÜý-L t]0Öý»{^ÄÙ2_8Rþ½{bÜSן/ÖÆj–±£y¿‡òá–®œ¡­@zÛßW(VAfË;ÿ9@X?¿ f ¸z)#`úž%3¾ÍTÐPÈ<ßê“ÙžÏmE#DÂg¥M|:i7žé€Æ}Á<òW{ÅišÇV”ƒ¡ÇlÒ—vªÌØã]Í®=@¸„“Áúr§ØÇ8ö)¦²Aði°øídú%»ž8C j½b ‡ÍãäsãIöÙ­ª Í%ã,ô%”CJK :•ÔW@þÚ rŸ‘îž'¸9PNµg{-{u®úžKªŠåÙ„H�%µ÷­V”y%f+˜8Ñó´Ôûu|Á¯8I½™,# {8lŸ׋Æ7†{øeë¤þÚÁ$Ãì'£ÄˆÎbw¹ÙdEæ7 Â(h/H”?õ(|Ï´OMÓ9ÑÜTÐÔ»kùÓùB«•ÜÈ•TŠ­ÖMÓ’©?fÖ3Û4I3&!=ûJOª¹ÈÀ×üæ¦rØ/>lÁ9«Á{×æF"«?¾Õ#í Oåáþå#-ˆ(Jc–2,?·vè_‰Ä  ý—§k&ˬÃÜÔni4‹‘³ŒÆ1òÀô˜¹^é“EüÕ(PÆ 7Ï^»­âEHyV?ÀƒxãòÜý©÷©øvI}güà5ÌÖÅiyþR©Êߨ~ôT¥ïYö,³ _ œj?QTŽ>©šs�‚“Ñ„ØÔ0 š·ßp˜*¯·Pp\ƒ'Ù¨°,,ìè&‡Ÿáw§ä…n; “ ÇW«ÏM¬G+é Wp�øƒ†X‹²úxáŽ*=RIÇo|/âK›ÊÚî  FÚ#Ûð} r-·ƒúK÷ç¹±(Ý2Np€œ)ävÃ䕨ß%®Q¾XÌtDL£%™îÑ9½µÃÍ2¿CÇY0ÅçFM5ZŠÏ—·5m3Ë—ãsmƒÜMŒ³ØÏ9¹×ÝÈQy˜9&œTœÃ^Ϙ#ÜHmDTÝdžb’'àÑ'Å`'%f}ÀbÁÀ:^B£çÅÂU„ʲJšîì°�oã·“óçÐïV 7@w [+Œ±}l®WµV1/–•Y¶§äÿ°R»ÛØZbe[(È뤢9œXå,�”aÙiš¬`%s]ñ{4Zº½Tî+bË/‘Áf¯öý$eb…øºã®¦Ï‹°Pn¤ŽÂ…4[XR)M1íuá§ÌÍZq€ø, Pïò6/NÁòSâcÄŽ¬ Z±ú ¹[êyýºh?ÅieùŠÆEвù4¡°â!åÜSTÌ8 Î<|x£Õ˜ç ˜—NÂÁs~Fêó3¸²j`Î|ìÜaÄ4OÁëîU¨ý§ ñeákËÁ'ÙGV‚ cë/«sõƒl ð”cn�žåzv¬ZÙ'2E£ƒšcïŒÂÌ—ÜÅSʘXa¾ Fªré´2 à . '¹*çànÃÍwOêH'nÐJpâÍÍËH/:!4›äÃ’ÈÔá@ºztº¬~Ã-Í6b¡g-î7Fìã4P„²É\È«ke¿_C)#£Ú›Õ Õö¬¸¶DÅêÞdeezad]4ÏòÁž’8¨>מõȱ«Í ÔÖ›q·Ÿš‹†Ị߳JBæM °|èɧ/O#Éè-Ž Õ0¯J}ô³áz:DUü4Jß‹§q¯H/' D‡9w~D[u¡ÜÀS†#zIíÚé£ÖýbÖ!É%:©¹ømäÖ, =±ÛÊø!|zŠN=;1xj(”|õ‡¶ÝmºéEEÓ2ö¥|(¡ØÂ~ýýˇ¤\º·+Æ3péwBŒ_7Òï˜ñ,ú'pƒjâ˜Û€‰3/ßv´8oÓ9ýMÄË"v@º’‰–G„Î×­¸ÒBßvœçã<:`Þdö3Ãôxã<>í¢²Òu9oÞ´ÐY±ùA,JFZ7Ê-ÑñêfEÿDžt¯ð«›¸á£ëÿlY¥À)¢3èËýó� ²ÚÃjL([œŒP|Å-æ¡›•‰·ch´ 0ÿŽDó#÷wú …q•ˆ"#àÁ³’¨µZè—á›hýÍ|¤\""+(†åtôûæ ô¨|ÖŽ‘»§—^=Á~ 3†ªíÉkð dºÓ¾¡è¤ä[óI盨<Ÿh;Kk£4“’Çn›ÖwóîP¦¢2Í| þ韨SбžÓÖá]{zÍx2銪ÜcÅûÿF>ÅM]�§ÙḠõxY:h/à #¸€ÖÜþÔ¢¤ûì›L…Ý¥Î3�ñB¹O=!iÊÒE4Œ‘ãËŠ«Ê–.¢hŽ§eÔï&‡ ¢GM¢|c®mß6Xð——Ç46)…·ùÛ:Ê©j®½Ñ*Fž®nP”˜~Ý‘ Íü‚J¢Ú¢Á˜8¶ë'+G¦c£\wW§ÛÊ_FæŽ0p�B`žŒöÎN¥ýú2yÒ`ÑÐͽÁeBÎÚ±©(<~ïši}Qè¼ÝÐ7nD‰·Bå Õ“ÛgÛ¼ÑÔq)Û†ÖÄ2FŒtÊ”¯›Ô[n„äJTæ×.õýQÐ|ƒ]4'Ž›Äw‡n!ôØ`5Õa²0 ùM_é»7ÿ rå(›’ɳœÁ#½|ÿ1²®#ÕÝç© Ê?ÚÐ-sé¯ùÐb ÇrÓÍ™€¿±¯WsêÁ¡ AªPhÊ­o«Ð6„–°4ýžVñèúöÉÆy™ùªd1TÉÀÒ^.`èß@zP™XÞóö{-²4w«¦w„"¨Fí«¦…£T¤rµuª©özÞÖ€*ÊÑš¦œE­@“Pu<Rñb!;‚9îzN°ßØIâ©Y=Œtzö(.ÛYôHu›†AO¼Þ›‹˜œ’ð°ï-«²»s§Zj£ô&±šVe‰y+t“pÀ¾*%©<Z¬Í‚îìZËn 6n»Þ&›ãáÂqÕP¢w†!¾È%ƒÍŽSZ§¤ƒ Z óÀ¯Ã v¢Hyå%Eæ«æ§Áþƒ •öèÚ»vp&g;Æ\¶ðYüÔ/ôÚ=Ô‘X"ÃK]iØr7¥p0ÄÖ,0×WÑÓ¼½æÉ•ÈT7 9¹œª}p9}èáv“¯¾ Ø»¼îmdצh=…Å´9ê\þàœŠY¥DKïûÉÇ™ŸG0 Ž( ô¾<�U 쟪ڶߪ§Þ'Ä™ \`”õÅË<�ƒáÞEÅ>‚ ´:cV‚qu¨(nk­#à1ƒ4nºÏ븠‡¼½Ÿ¾fJ™@¨G}% ×;:®¾®H%›i”U¢¬ _Jdvg-wY÷Ñ%±×{ßÄ‘Q`ùʈñQKq\65wµYüm¿ûBq¢þÇbóTBD¥¯~M!øˆ)rÖ*’š–ÔåÀ¯é;œÌ»é£ÃäýŽ&„3KÌŒ-nÛåYmÎB€>Âp*Sò–4–D—GÕ¸ •cnÎ:pN“O@M†ÚÒ»­È¨ÝŽD£Ðtž…ÿHÁ–2Ùf­.³ ¤[ÉxæSÔ=cÌ^Õê®,DœvÛ066ÜŠõˆ,›…Ä°> §\õ½t²ÞD†ËÛT +£‹BÂa½æž¯S¨nÆî\Ü6qæÙÜd”qÁv³óøû@c)C~䊟þG°ÿÓþ¼vq¾ý¥4;•¥ NPMŽITmĽà ªÝNàÎ÷Îxf£±§`LÃÐ%eŽÖ2-…®>ÒJß‚&9iŽñ¬'o‡D‘»Ü#¶ë‘§ýѾ1¬ÍH%ª%`ŒHV] k|Úš¶Ói+6”,-˜JQë±ö‘´¯ŽKÍx,ÕeÅÂî’Šü“ówJ]ï;ÏA™Ž×¯wX³©s—fÓªÉ(ïmÌžJQF¿³Zo´äþ¦ åW^<4ÛÖ%`šdc‰GŠíêmÚ!uºØWNêž@Á ¸£”Ú?í4Êì%ÂÇÚnº-óÃ’¹K‡(+¦º¶K§mK“øk·–%á—¹TG¶¯žX\¼Üï¡ÞñóÕR<ñyì_6Œ Ý‹ùÂì¯n7oÈÍý¸òî ˜¬:ƒí]å"²‡J^ÜœÌìúÝŸ0iÿ\-kÊcm¬OdÓm혘ºʃԵ?èöœ/ÃÅâîN3ž"d�GRLÛ,fÀª1·Njƒ°ØÖΚîïK ßúóp¨˜uL T�õœEp+ú"óÿ½ Õ£Áö4`lÔ†G›&ó°ø#=¡åû§›Nví®‘jôÞNÿúDkÎ×ê°‘™Hº.m8¸‰£½E`s=Ëä‘¢_w¤¥ö ÕˆŠé<M,LŒR¢#ÊsËÿGy 9Øêcn`ýh¢à?¼h+»6ö²T" ¢µÅ£=s|Nþý‚Ý:¹™ªŽGÜTÑXSÄî®wõŒ(Äšѡ憨Q…±¯ž`¯ÒÛ¤A:Ÿ<ˆÕ‚ÔA{ôŤ·ó“ )Ž„TüúSBRç !f*'r•wv~êPÓâ½³ç½A°¹ÆÒíŒHS÷@ØÚ×Wùâ̳RçA`;WAn%Z¸És¹t³BKÐÌ5 #<ºk¥ƒ$ÌÌ©&.¤<nÇäõd’¶p¬¡V·Sã-ióMœ2ÿîüq;•ÁfÛÞi…±[* €z÷¬µJÇ¢~ÐQj¯©á‹&iäi}3,¡™è¨Ï­÷.àékZ5UÞåo€µ©¯á&ú|EP~Õj‚ƒÁJ ›Ð—,“ݤô¶Û&®91$Pð:¯é{ \w_>ý¹S„;0NÒ¬s—OÐÇVŽ4äË–% pvjµ\´ža%—ø´fpL' É`DtåÚŸ:Jb †À6¥·?+U<Àσ‘‘ßÒJ5oès�|.€Àê3»hXÝnB ºØÎV˜\0U}7YíM"¼Ëã.Ó¶‘°Ì`GLQø¼Q׳ؘºêsÛ]˜O�=G®v-ì bîƒtã¹ÔíëœÊi ]‹º½ ;¢ÁÆÝ__}•íwû.Âw«s,Ñb09Ö3�§Ž®F÷ξr„{ªY¹R]V{H`)¬x½›ÿ�)IkW¢™Xž®ÒOÃþpN¬ÕtÇJXePEŽ®šmƒ³„#Cp\°¡$ÏÌón"˜)LL‡gêE!-²}QSÕ–Ÿ ’çÅÂX‚Ö!%åðŽ1Q#(4­¶”!›³n° O¯e\…èfçÀãT³ÓÖóp…lôìïß4]=˜ð„¹¤¿šaW{æ* °­—°@ÇÛ˜Á¤¿u¬¨VnÌÜšÖbjÏLÓÔÖÆÿ°ÙKÔþV�"JSë%|ŽÕ:Àâä™çPQŽëâ ¿.¿ÖõÎì©¡½s“³XmGAWÐZS-ª2 �H¥ê 4õä@Oô>£6,];B䇘Žý?¦ ’+ãOÿ}ËŒR X.Ó…ífDÃÆ0¯_o]–KA±ïó¿/=*¹3Œ-³€ü-ZòÔy¬>S„¾) @¦uTŸ%,ú˜²B@ñÚÊç{‹Øs{äaQ÷Eo½+×–uBF‹-‚ŸҴ‘ kïž5’˜U#Ïy]QRs1ŒEMóf@d;,Ëú"jŸ‹Õq<˜…î]znØD%bï\Ãù`rÔ®Øø£íÕÐâcÈF0A¼’üº3\Üvz ç–r‡‘)¯ByÀ$¬yæ¬påö6?Œ<xCŠã½EÇ ë½ÐÁ3Åe !sK[¿Ã]Û0y˜fÑï퇒§äö®Ç†Ì‡@iX§ýÛaÚPŽpÑ{Kÿ›î9ÑÁ¢&£Ø$Ÿûúœ¥Mjq òÛnÍùÀtg¹?IõóÐÊ!‚‹ˆ´ŸöT¦·ã¡÷S³£ÌÖD°¿Ñ («Å�ƒVyÉXFͳP¼Œžï+‡CôOn´M„UÆ hí“øYÍ–âé«^@yueÜ4UõŠþ‹d"?;Ç&d´p×OÜÚ¾»Ê2_à…WøtŽ(Êo­q¦•d5e>íaÙ<Q™^&̯ÂØã|î>¼‰hù[s’˜Ù€êôHÝóîT‹!gÎä™þ—æ,¿[îu¿ÑÀǪÝ.ÄÆ“a_ ¥™‰Ð÷`êóm)]øk”bå<PNžöÔX’ÏÓ—a ÞIÑ>újvq–ù¦7€ö´ð «ÒŽ•i'cÀqÄO‡'ÎæwñãÝ ,ô„í�c€ÀÌöèÔ Œ¶R1_R•‰|&HŠ<}O©Œ¼Óf¡Ï §`C5÷ -:dŽ»Îk¥½®éV™ð¢b†IîaÝxÖã+Å0VÂd7/²};%EîKü@ <2+'™„ù S‡ÕÖZA:à%Ž×{§¹ÇO×÷©Ã©=[]G$<÷4ûî¼›îJ–QèAñè9L”¤îÁ ¬ýÀ󽿻b-Ew†Ý*"OÖ7ÊR …b5=ýô8ëX$ nþ[¨Ÿ1´UZm’²NV=̬ÓwËÙÿâ°Ø¹ŸúÆb‘õ©',†jÛ“ËÍÿ»'W”ä¾L=Q8‰çkõ¯^p=Óÿ뤉«6âIáSÍY–» ¢¦Õ¸'_s¿G±¨©½ºú!â(ËÝΩðLÛmdλ D¨­˜{hÙŸ�hÁÞq´ ®˜êceË,ù�ã¢Ô``×\÷ªÙðou¶,7åêf:å;—Œ@/µC%äßÊ°1‡Øó¯ä–wìWÙoËÇ!g*h‹·žF—Õw5Y~ËÚI/!Y¬«DeºæO lô<Nå8†#¢ðÍFž#}#6¾jÜ‹—O¨5A1:ojÏ8g¥þ¬"oˆÃÏû÷¥£ÅÙìÎonä•i‘RÎF¥ƒ_ÊN¿»~ö­ )à ËBc¾Þ»r==ZN—ž±àÛlm&/œáúyÕYF.[ƒº €@X³ÐÉuͦÉʪí0ÅÇr2ñ)¿ŒHèìé §&„@TP$áfÚ@­Ðñ¶é#„wdù€Öã{ž0>¼„¸t2bŒî|OÙ¿©“MúÙH–ðì'hz”‹„­n\zòn…Ìg™¿J‰K¢Øפ¼v0L]ã—JÿQ,ôLD= 0¯I/F˜y8®IΩNá䀜ñÙ䶫DÕäôâȬÈHM¨?f°˜×ÞQ¾b¶¼ëzꢖ9È#%@—¾F¼óL•sÚh¢\TZ9K—¶ÛO?Ò¸ðu‡9l†‚Áͱ5ÝUµÅ¡w1ÿ^ÉÇùúkÒRžéðžfµ: CúL ýú2z÷ y6‘ç6‡c¢íúãV¾´«î]-»²Yès¿(P `xn¿\â;Ô³úf¼*9U8–NÄ“’s]²‹­›~ýÞ}Y÷O:ŽÛ)/ 72/žÁ ô²ÛLa§ôl¡-C�éæù<=±šI’Ì—H¡µ3ŸqnO)Ci ’ÌÓè62߆ ý‡Î„yy L‰…T@ÀÅנΰÌjGásïê¦â•R1š! ûÎÖt<µOà[²»+¦ä‘ cBûpn=ï†ÏS×éç} &[¦WiÒÓfJÒ >­«c®™(¸PÙßL¯¢ªlA£^‡"XÕÛÎ{î9”IÏÂcXäUE8oœLã8qãT¦W‚…Wv1LóPß­’JÂŽêåî\¼¸ˆCÏX˜bût,‚r38`-³áз“1M¥œo=›ÑäõÁÉ_VfzØÁvçÓšßqH�`e23–xU5»㠿ù-ÅN×MÌ–pýM}µVøêX@^´å™,ÝY³:Âz^×n‹Ž8Xü_Rec5µ‰XƒuÓHùU–N FÕÖ¿)?±MÊo!TEåïÊÈhâ�Gá*(™@²¶­yƒþ$N™û+•jAoÜé]*°ÀéÓÈ„M>8Ùó3@x¦­`RìŽ)Åû£§Ñµ­/汃‹¸ck½Ò….‚Ì°ÎNïæi÷¡™OQšé¢ö…¾QÂzb‘.tÉŸ5A×sé™##¶"E +€Ò5“§V´övÓ›mËLÿ‚Rª©:…‘ •ºË õhèR:>c?\ƒª±­½SÑü*Íç·@(ÏbLîÿ¤ :y®ËŸ<NQiü!ç Ê^ËÊR9EÒÞ׬¾óÿQÝz°¤¬xñß=ÒË­2TZv«3è *¨b|ªQ30åÛ0RàôðžW?©Ì…¥Ç0ÁÊ{«šÃÛþ0M6•z];̲ÊäÛ`wæ ânöNæ³0ŽÎ¸_:IRw©¡þù¯ü´+2`ƒ3U?¶J1Piª\Û±†?ÚUæ¥ï‰¥ @™;Þe‰Œ« §p’ŸÔ€ 2« X¼Á›|ÓÙXëI3‰{Ì„dÑ­‚²¦í­k˜ˆ|zànÔC…â»ø^).L-·ŠÖTëNísã\AŽ0ftà•šÞ¿’@¸pQ¸²T(À±=›êV±ñÈû1vÁÛ¿ò©N•q+ F/§KL¡ÝV.ô'¸QÔÖN};ª-òÃážÂ’̈2e^¶µµQ#«íå(²ߊ­û ¯ô4˜˜}?]èôº¢VœÂ\^C¦éòúW©UoœŠ½˜ò*"çZ#² WGÓíÇ‘¿àñÌVÙi€ݺëŒÉ'LjM'tÝž®…"¢ª\ô÷sZÉFô4­N³÷|'9nÅ£D<Fç> ’í»ª1Õ­x9þÆäÉŒwúس³>èUÉС1fYv𣼈$V³D2màqOÇ÷ºV\:o7†BnýÅʱf¦{ÅÅ­ö}n"¸ ‹tSBZ  \§¡ºu!µ©ÍÝ«;Ú%¾×€�8Ç-èVµ›FiËÜ/qž5–;p<õºƒ‘!ÛdÄ“Ì3Má\ØS‘*4ÇO¨l°OQ–6éÙ÷Ûþ¡X‘aÁX;ˆéIµUÉ]} B®“há·\SmOðû™öwTù³0JKöÃMçi¬®zÌÝÇC÷ó£¶\j¸Ò²:§AjMT©'ºéV˜›!¥µ·Ö¬>Û,6g¨…&“‚ËÐ9_æÕÖŠ`}ÆʆÞBxSÏÐ…‰ÇóÏ©ñz.¾q¢T† êf¸êGÇÝÑË–@¹Ñão¦œ–‘‚ê³20>×ûzGu £t¶áä:íX|o ~PefÑ¿]Zæ‘•Šâ½Ý õE#6¨›kÿQë<Ê+_RÖ¸pïG;f¾7&$ ›Ál³s^ç…‘}ÿªa‘Û‰Löų öm[½>_&I&Öú²”¿@³ð7ý¡ËSý˜È-C/Š‚íHwãÓ—q„ù#ƒ´Lvªèˆ§ ‰È³:!¶8Îy¶JCŒÂš½¼Ãr•Õ=T vZ(BÄ>×Ø‘í»'Õévòx tjïåŸG³E RyŠ–D€ì҇픤¹¯ÖA>oDîÐÌ;°»�Ž¦‡+Ñí¼ð öÜu7�ÆÕJ ‹W¹Ú¸ß¸p±´rX¿óö²âƒ…ÑÐàN³—œr§uÐ0pbðx™�{%§Ž »8eÀ8÷ju.áá’ÏJ~�Nf<\ S=œHa÷¢K¼€*ò(êÇ£òìX–K„<•–Jþú—¯¸I%,Ä' ˜-1š´ ²Zuñ¹YM«gÞ.ÏŠžŠÄu{)neâëß²æ|É®²ô‘58Jç$H­`DyÞ@êµ¢1ÐQTç~ð#2‡µcŸøÍ ­Ïºñ¸ÈŒvSL3[Ó ?Òx‰¢…‘.˜ÎÖ¬/5·m JØ,ï5\š!l<Äž*x»A¥Ü©$¥qØ–BÅ]ç¸õU «Œ,MtQüÎÏ:ÏVå?2ZpÇÎVv/[+U‘El"L /×`¹ÊëR2¥lÕÐ[ê~™³–NÑi³ÿ†{YlŠm·*?ôÁx!Q¼Šÿ}KÌø˜¢ŸtD6tG\_ðrxA;Ƴ”,Ù«5>öf¨Y2ߦBÇC=k˜† %‘8Ø�>­½æ`&‰S¸rÓtî=ºÎùýK'J¶0N‡TÛFn•3úc8Ý,Öü·ÆGš¸Ü2ÅQ6ךTåì|:Z§ l}ö÷¨yáÎs±uhÙs`8ù{!³·iŸ³Í›> –\0ò–+|JMK¢Â¹J3‡kÚÄAµn´ñ�ÂÂQ4”Ô+ôG3žxáwÍ| ø[X9p~è¤�&‰‹<ƒ†ÈÍÛ¡þ¾\ç½+?2ª ž¿�ÐAúÒÇ£1`ɯ‚´¬s_”›ê`ØP!WŒÚAfBKí51(‡¨c©»ºç Y¹)…›žnø0º%£–!ê'¤ÄcŠ…·ØŸ“¹¼Q 4àŽ#}‹I¿E‰òšN!coèñ „ú{§#–;&CJ£ Ê€ ÐÓü<˜ÂsUøÕ×L#`ILŠÄ Ú©Ù�Ž;tC:£?Ì¢ ,;LõÇFñDH£î?ºëópèηúŽ¦_”!â#`+—&G™'ýÃ~T¹j Ni@×kðŒ ? gé•p[ú=œæ‡## ã©F5ØèV:KZÙcìJ½Ø„šVúÓW¯8�ÊEw5f{ÔÌ:k@é2:PðOÝQ Ì¢=-­Ð¼÷Ñ6Óɾ{[ÚŠùöá…`*( ¿©ä?¾{F5½…7�òú›ŽœH\ýt#6äШ¢©x¤3ÅÑ‹Y«‹b<hC+‡:ýY‡P£CÓoÛwiô­W4c½)Ù݈_&+}¾­g‘îYº,»ÂMÁÅÓìÎgx "¸KsÊýnxÉG¹³„eîÉÐuy´uãZ0Ïw#w•¹Â½Ï@eÏÖ²$RîË 0To¶Ÿ>¸öãŽÕÁŠðó'}ÚÆ¢, i—î=Ã$ø=mÄKꪪ/ŸÊ@vÛÊj•¨5ºÕÎJÃۦ謹tÑ„ð U«Õ\+ï H<ªEqütL˜'^Çö¼A•v•öä]žq-àóEƒ ‡[Êçú“‰·FNxêÆß;Þ&Lt ŒÍ¹Ù—wÌΟz¹XOÓÁ* l†ûÖ˜vRýøêµÅne-TÜBó_± ˆ*+(ßG7ù¡_é™/*ËÓaÅý°—Å , (VÝvv¸ÉOÖ©"dŸ• Ôš f:ÿ?mÿ²º²l Ãe­§píTÖ<M÷KQBa %10³}ïÿôˆŒÌŒÇ:ÿnmðXƒ”—~ù¿Å*ÕtãÈö•³)€=ƨIÀŒgUÅÀ©¼@¤M=[6F“M}Æ<}«×ŸRNŒË¸pÝé— Ýkì`ùÈ-ï–å5Ì9ÕR­×I­çÞµƒ<W‰ÞYá¶Kï쪘ów‹·‰Åù{ïÜ<ï+Ë?™Uz%»]Ó{Ï lG‘.½qëèiXߘXvnšNÌ´Ké –O/ 6;˜“‰Ý«ŸÅÈññž¿ó ‡‚§ã&>Ã×(a´^â4­1ggÑÚ#Ü aôŸ>'ЭÓ"6�£T:Ü~zÊY@9qa­…_ÄñT¥h„ÿ ÇÃ…wOÒÿÂ-qÏXòë}ºØr>z¾é¥±»N!#5ÚzZ;#3©¦lýþÄ+Ù<>Òiö.¬¦‰[õµ¯ÙÕ] ŸÙY>ѽå6bfx¾Ë Q_«€�UÙ‹P¹ØÀ Àÿi®ÿPF!H…;¿£Šª!_ TŠI—ÿÞ/ÍIâ«­-åG–½ SX.=XkOûmD­·¾¦bƒþ÷çéˆêgbJ¼ëü—ž¬SjÐw0…Ðã£MÕyT ¥Ô×z’ÄêùK×’¬<ýQ^ê©«‚º'žrê¡øª€”c}²$(jÝßF‹úv‘Ï^ÞÕŒ‰‰áî>äðºÙMjZòKå§íŸ%fj××gˆ«Ï·v˜m1µžõ°ö'ºìa?yFä홪D%ðnŽªÁmê¾·®=œ‘g4<dXÁŸJ×ÊoXfƒ®X0Ó‡#4Pa#¨{€Ü3ÅÜ}û…¶¤Y†.VÐ Pvù×vIS�A=F[D¯õÏm¥Ø/&Ynx<¥�l~yõÅn¿õ'ËåøƾžÁæB9@͹ã¶îÜ£?µVXÙ´«‚èÜy%nÏÚ0A¤A¹6íÅcêÖ™±ïS{ŠȨßÏvRÆ؃g®G,Uÿm[CÆî(�Ú2ˆ§ÁEH.wé ²ìB"¦fÜmí(©F,»\gó%E¹…K(2Ò%™gp‚È£†¿w´ý#ÑîÇñ§‚Ù‰yÀiÞyL¤ûO¿¹CeáJ™þTJ:®­€ïíèÜ¡˜bB-¶+æ·GdôGÇeºº'·Ùû “˺Ecãî©Q`²õǹ¯å …ú¶Ù–hͦà@;Ô”Mç’*Ü0Š¹>x*Z‘ž?­¹ Ÿ0´"gõl™´Ìžú3²U,…Æ -¸1¨'«Ë,ŠUSòÏ­×É|g‘ÞK½ØÏŽ§½PXî#Qûݪôd¢bŠ‡"Hžþ€®ªEÕb]¯÷yr‘K*#†U<³¶À‹=TVF^�7‰žÎaoƒòlär§ãÕ }l¨\X÷‹"»ñ:íë’‚ØâA) ²Ä q;LF&ý‚�f ±ËxSn †OÖ8b½Ò‡cš¯ÍéâïÎ-ÅéâÆ ‘j^µ3‘¿…íÀMªúÆð5µ©W¨Žp´ÿãúÓSuwÒüÈ«}¸Ò:#–°Õ¼µWV4PJ謱î“wË<©Ÿ„çÊtw’YV²„iúH|ª##ó?Ð@¬é‹ Â<X¶´‘õ-d;08/èÈÉP–&:´ ÍÅÚ"pdú—Ž”>¸¼O@æóæ»V9c |î»f¿3SÏG4^©õ2©0ÊQ˽Hʼnþ©ž6àØ›½û¤‘™g>#$cJŽ¬w©=jñ¯5†U²^f.€ó,Èj;– K“5SÌvúo3öýÐü˜Öl”)ÒÀ'ÍvRí¸V~Oß|Ÿ"§‰#íû¶Ë¨ì˜Û¿oèÒ`ã`dd&•øÒ›ãBwŽÛÔ1$£=-Ü=ðh"‡åñ{“”îÚ”£±ÍaÖ®1]ïCÇNáþ³G‚ U| õ›Zmóè6ðˆ÷‡ëÐ t€B…ˆ,AÔ™ÞzF’ö=Zrr渮ª¿œŠÞ£r¿œ G9÷ø°öKÂ$/³o*T5ó© Š‹/^¢¸¶ÑŹìÕÅ‹NƒÜ°Ï¢ÿ$ o7èÈAÏ¢}ÞY©´¨Awc>íÁH[Æ,¸ÔÒΰ$c¦¢›ÌòI5S¨òþŽ.ÊÉyŽ”¢HˆLä»�ðÉŽâÞÐÿ~Iü0Ê¿Læ‘~ÔÛ|Þ€Öù1Ýlök×ÇUçÊî ¥?ƒ~Ѭð×=›ÎáÆj‰Ð©m6ÑD+ó¸õîëÃðEÄb£#tø€ g«}„È9›r'‡O[Sñ{Z?Úã<[9Ùç´ÛSÏ-ˆ5îÊGÅE  ´9àa4TQ`Åêʤʩ̳ ÿxÃ!|¤|Ï÷²P<Ž}ò­“T+hhµwtªQó!Ü=–šuHTÁí•u×q}A)VÿXÂÂî YÁZ•¯„ !91Ó0®¢<ë6>;  %ÓÓo‘j¬`ú4•‡ôt¯“ö)€hš­ˆËü�øùÔÕü™™ 55ZܪÛ/‹Ä3ºU™@ƒ¹|<­=Òžþ#6~YdvªìC»™8&FøVÔ/9°Z)RÿÅ7m ¯Æf_ã žÖôWL¨ÍÅccŒND@<xp‘¦âeiHÛ üe Û(ö–¾É„U:«Ëô;/ÅXš$¢Ð½R°m[΋Ò�™¤UÈÇåpó† ãt˜12‚YŽc¼¢[ÛÏ(Sg š‹ådu¬êƒsk Š÷‚-#ãlAVžé) ½ˆi¶òblHÎZÓ‡$¨¬ÅzŠ¿éÛr<½8»Ž5s2­m8ï¢q¥ÔéÔ\/ÆýiHÿÙt7VÓP=õæS¤óÅ{"vk:ìwáç=5Šs·4Ñ´péë·œJížTꓱ%M*…£øt¹-­øöšñ�ÕÁºq”¬ÔkÅ‚ƒ‘í¹ù÷›Ùž’[$%� :áç§Æq'›j[ dÀ˜ë1ŠWœÙ�à¹kx¶cÒz˜GZéÓìM”/ûq ŽC€`¢Ê9ûú±[ÚƆ»s¦¬.m¶‡ëÁ¨Á.÷hxʇ®•ÃD ‰'`C×RpÌPC@¥\ 8wÚhRŸÖ1Ö{Ïngavž¼9”ì£bQ”x-æÐbÑM f¿²D¡³ÃAX—‘¶ø©S‘V×tùŒ"Æãÿ¼ÏÕÌ3Ÿ«Ô[Ðùª¤é;ã4œ¾Åßã"5M»´ Nä¦N£ Ù6[¶µI)˜e~¯´Ïx…‰äÚÍ%²•ôz”‹ÕUغ~ëYëQ^5ì ĸæzîuùþkmÜ6 Âñ_‡!Û/ó°?™RûgΔ#q*Lds¡déëÝL]3¼%Ȧ¾µ Š¢å¬´MÞÉFòn%Šüý_<õ5å6-tc‡§P´"'|�솀aŸ<)S<©éMêU½OÚŽ¨Aí» ¾ •Ãy=E|ÅIæœ ¦»&'+i(Ž€”Ä$ y]C¯dº«û)ÙJ=.|'<õè´ð9(q88–ÿ:ut˜Ê]¢¡c,ÊOYz¥ÌJé^ $ÓÎlÕŒnEà ít¼38 ÞÆ\P_ár<ðÀý;&RàTµU6H¾ß_à£Éð_>� Üo·ß=eŒÌ€3 "P}6N0ËZ‘û¶Š²û¦àž¬éwyµRcãàøi±'SÀŠF¦ú´’Ý8ÀÚ{"š—gþÄ( æ<H곧É× `r4_òéxØscåUÓŸ…’àfxyº•R62Ä7ËËýx…å P¸ßAr\;Q±5E±ü¡ÉÈ0¼èQ™y ®÷õÐQñT×ÚKpsKÅÑßM}nqcEè»9S}: ÒYõd(màÞ£Ì0Z4S÷ÅÝù›G+ggUxRJÂGùÔžAVÞ8ŸNç]s]ý¼Í¹ÓÌãG5²ÐÇë}™Føqu^oC¢›×zÿ©^øÂóì ßÚ°xXݶf%Xs˜Û:úñl«´PXv Š_ÿz´å:±xý´®á ËO(â�ø~œ8§…Qš»¡ Ò¿Uý6ë|‘0µ4®^:A9Ä fm9«¯‘J“Üõì¥!Ñô`ÞØѻס=ß¡œªÿ}‹µ ç5´éÑÚ5Ðoj÷ß7ÿ_8ìËÜê•ÿ X¨…<Eip°kQ ÇŠÎÉípœ¿ygüùÈQuŒÍˆ«Àù›xi%zaì³B·;õ©àcPËÐùñΦæ¼…#0l&¡« k&t_g{{^�ÍÜÐDIåö%[Y7=`VZzW awµßÛùý°U¥,J?æ Qä¶Om «úÿËâ;W,¸üBiß{diQ»=6ÍÝ@|5ü§kØ’' d*ú²Çv´®Â’@ˆÜÆó£ Ž _Cƒç+ íl¥`´Ãžºm·0ÇPu¾Ì7Sò( msZôÇ”ÃY?è3¢ï`Tóð²¾ÑË–Õ‰á²ÿ1ŠTœ£‡-úÓÍ'sx½rŠÌ ,¹DüÃÊ •Rù/œJ ”|u*eH£:}õ³ƒ˜Îžu]Fô-ÿ5Ãì$Š¾+àD~>+§,J”ÁèÄvû¿ë|£ä iƒœƒ{å"–„y”ñÀÜ·ˆwyPžÒub“½0Jð¹›óÀ’¿à•·³ÍŸ¤òE—x”Gœ˜82¼#(b> Åç¿{@dLC_Ü/f QÊZÕó€;Z=^ßÌ1`^ï­3Ún¸Ž¿WÃÊÚøIuÍü›p7è†a^;cjý$°"˜Ž¯²p’Ôm™„Êðg¢Î§¿³x»¨JG]fó;OåVªÅÒe¤¯RžÚ‹‡‰-ŒËbQ?º}$ÙÞS 'N7oˆä<%æs†{q}òÄ{1äomFv¿5ÝsûF—Ü¥¥+“oUl�X£<wüê;Ów¿Èbúöø©Î>ŒƒD“ƒûȧI/L’#~ÛÓ~üºé"7ÇaF"~ãÏë ÍŒí<$Ae»‘á‚R!¶¸ñâoÍfâÔ#F3�€òQ*‘a$éòVÁûyÜ#ú°†U¦£÷—ÓòŽÄdá®SÉbÖ'úNåö䆧¸£´ÈùÕÀ$qz|秘÷&§‰‡ûåøÛBð¦<U Ï3{‹ég7ÌýL§�š>>¨Cåd‰¸»ýù€Õö{jÛ¥/P‡"åîŠúVò j?«Ü7?@Èk£„Ñî sû=/#W7_p9tSù×€ÙЪ!¶„੆¡+€õ2Ü}CÇð>ñ¥{ô[@1|Î%]p˜DT6ê�x΂‚ÒJR¸²ÚDüè‘¥>|>„hod»Æ7äœ6£åk�Áå[PñkÇíwBrþ6h°7A+Îq¤µ_z‹Á,„¥¬ç[.p^´; åØ?˜Þc€{¤qE?ÐWˆšÎ3¡û³‡ý³ÎÆ{£0Èf‘2»º)’-’È@pÑ€»È{ë´Œáãné-mmÕ…lšû¢=WRf>l „ J¿¢síåÑÛýŒ÷ß‚ì&3îhq0´YN;;ˆÝÛ®ÿ Mee•<¥7¸LËàGøÿÞ¾¾ÁwzÀ.cx=äìËäè/¢4­æô#°À–¶LÇs«wlúò•_"•cãD÷–ÑFœcÿï©îôŸ•¬Ùi-Íf¤ ï»â‘ÈLtÌÔÑ)Öz}"8wnüªa™ûÿüÞßëÈÔÙJ%�·zUÛb­6¨(*Òm¨O|3Ÿã2¢Ä6—§#HdçÁM&”’ζ쎳dÕæq%Øy-IÖÃ_&ô„Þ’´Ô‡Gà¡íñ)˜ÎðCÜðÛ›¹í}ŸÜ9+ ܼ©Ó {?k¶ž[ƒBCW¢ôEÓ†£©õËC7¶û“g7JþV×1 ¦jc½c+µ]óR‚ÒS¢Rš9¿$á œŽ´ ã^ëÉÛ©?hûìŒÖ)ÓX^óéúýöéèªn`¬¤%d ãsíF¨ÒèFŸ¢ð³¡;«¦&´“8(w³§T{8ÜaµÖ6Çñr]ýôßHVqtô©ÆÁ¬až½”ñGºçn¥ Z0 mõÏ:94›D¬ÕzL¹—ù®Áu滚¹ ¼¸6\ò´kß… âMJû²8T$Í;;º€Þá)eç4YJ˜yš¼/^2vPÎúHÙñ¬ð=5 å2lR“ŠàíSÊïéÒ4*@ <ééˆfùvË$J±–³jãJȽ}½–fðœ£9MÞ쥃$vßA‘¿‡IÆñZ¤*¥ P@;\ãýrÝ]pžÀ€âØó›ql\º‘Öîs½ÖÓWú™pÔ´ºÂñý@|P(ÿK c(§Ôq :üýb¥w{T3õÍÜ8©|©Ì¾Lt2%n4ì^X‘9«'æH½*ߦ×Ö†`ŸÜã8'žP6Ó26lÜÓZSEXœëPT7îV¥jRý.×âÙIÐö°t¦¾1“˜Ž†‡°´�~‹±xéÑšýç‹[JâÀ+÷$m+±è¶3¹–¼WV¯‡ž‘ƒ<†3ݧÎæ¼$Ç«Ó½¾ç &žÛn!ØÔ<Hú7˜ uÇ¢¢&éÿ¹6|X2:ª–jÀ>PU׳¦æ‰I§üÚÖöin<ó^UÊŠÌÇþÃ[æBßpQüá‚ï8).…‘»`ê “ ú5Õrc¹ƒˆÅ}=¦â­Ø7KGé‚]Þä[h}  „epÐü+g­èí\)O™T­­÷*0úÆÈnìéî  ê3ƒT<9×Ì'3V"8jÌ¡š=½˜Kßuƒ#@ Ê®Ï(mˆ©n¹Qú¿áþ ïs0_¯íhEwösP)pŽ#7‰±=ÞÐ(�Ÿg*d×Zaç½ùF·3õ?ØVýc)ƒjØzíá?ŽoÉ<&»Áª]Y!8í–í22§/‚ü2jËÏðÈ¥¿yÝô-D�o·T¦™CÙ{Š —§»ÂšÍº¸ÛwGÃîíú¶»Ðr0Ž€3wçÛ[¼—S q7ŸŽ¯`2`“€ÑªpÜËûÕIE&¹� #œmOûߎu<_TîILÓ-ŽŒ™k®ŒZ¶ÈGfÚ¯Yô¥j&£ZAÑ_)±”©?ìÓ]éùLDªeÎxˆÙ ßM6Ÿx1WáÊ<ã_8\M£*oˆëkg¬Œ!ù³ÁxA ‚ÊNìÅ̳Յ3x4ðÑBßïr¸#ó‰Ó@ÿi½uE‰8šéåšfÅGé—^Œ:èÊ ²7 Æ´÷ Â™Ë àÐÚ*?“?3V>ÔRž2~Ý»zø£¾þWÉÙ[ ­ù˜_@ì¥î>HiE;-¤z¢7ó¼÷B¹t7ïUUñÑó6ZâuQØRÍÜæ_ bv>’ENÕ+‹ÜšËqO·æ‚eÅÞzhTwú‹5'Ož=ìÔ‚;76ŠÊ°4 àõ}½_-ôÝè•m/”™…Ûˆx{¢Eýà•¢„õ&¾¹OíЪ8»ÁiôiBg¦*bÄ0'•‘69úiâýd/ûiªo®qQù!‰ ”2;ÇÎñiÌ«iÙ¥0¶ºn†3“=­è¶~Û\G¤5-•;¿BVøætžìwû±^Ë9dpØÄ 5 SŸÃVè”GAþ©ù[É’!Ž¸ …r   §¿\é(5ì÷ïövq±ò›®�ÊòÌ\0qÙP`Æð]?² ¯ÖßP´<iGÂןi•íÉK6é+z ›¾^Æ0üUÊU%¡7.¦þ±ä”ñŸìðŤ”†ß:˜qÏH�š½TwæÉÚfóabÆN…‹O÷R°Wb«pAµ}´3Ê¡WνR}}8 Z5Œm¡ k#ñæpÄidËBéã>ò ¶U-ø#'ˆêŒÎtŠÎʉ¥1e»í_2#ŸO¼“që¡2¨¨k=Z0}jž¾éエdn«ƒ¡ÈLÔ Ü9b‚µS(ã´‡s4”†V:üI¹êÈéCÝì”ÜBM¿SÎh‘–ª"Ïý];}ܵ–èw¦ÂCÊBâ[J³iÑf¢íÔk7á„éð›#ºUÇõ¹âˆ'Š%]ìý â�ó¿®IME÷ÞI?Höulm͸fº‚tQ(ö:œsêÀ»À)”A÷•¬Ke=ô%˜ÓÅÁ<’<P-Èk”kÁ&WjuU+LK Í£,Èï}nF@h|:^8×[=} ye7C>¶Â`^67ä‚ Rã×É¿22tk+= ½dd,'e׳²Þàº;æ5—‡ôù¡3(Qõ;m= W¶Þ _ô©+ÍÍž·ÞQ*•þp~Õc«—]ˆÖ¸CSp¬×NôÉîÛ_ò‡g;kuœäCCïï %ŠØ×Ë s„Aºõ§CÇbSQ…;A 4ØBËÂüüÞçÏ=þ<óÝyŒR¾{Umó†µêë·é‰,Égè 7†ŽÌ±‹(vÎÊx?YÍ~ùL ]U¡×ĤؗºÚ‰/uÉ¢¥üË ³(»Û ÛæaÃí%–à6t‚´ûDö¼§H‚wŒ—ìÚ4VAv½¸©%c2ÖYýµ%|¡Y©bãC$†²+’±^ˆªŽê_iÓÅ¡/a(™©U¨{‰Ü«f#g×üîcd-»{rìâ–P.  üéØzcÖæ<ƱPýŸ¼â;vNÎ.¾ECÌÐúj”ÙÃ)µì'[wS̽šPüS öÀ¢ƒ¡ê–òú‰çålœ€-ÕÈ^ê8Ö©–µîÀß´š¬µ¼6y§·‘' vÂb°x~#D„~/oúRP“pO<«¨+G¬Í‰µ]¬‚•dÍ_ÌÊ2®<-öPTøܤ,iµNK¯ï*|·r|Eèe¾,ó±ÐR¨ZE´p“[?õåÃ8JÈeÙ‚OKzèX@[·w牕“Æ2Þ)Ÿè§h±t¨¯ÛAô›½¼¦VKœ†ÿFãó vCîb®=f£l¥R¸×ˆ¢¬Qå<u~•ÈU©d!Ì·¬Ë´z¨Åa2pÇß)û>ô¹Ð®&õ1.KôK'–ôÿ6(§k>›(jèN 4»cÔæ 9˜›:vIJµÓâe"˜lpμ^¨²¸=ü£ wô 40£‚¦b&YN€Äšßƒ¥­ã¼Ø|ÓÇß^‹ lo›ì.5ùb:,rÃÇ+JÁ]á.åY=/j?½†Y§ºK©œW–+\M\ŠTLy‰0õj úgæ¾ (4Ec–…Ž^s’¢œ6s¦™ >h»ˆ5?,”as¼xµ77–ÍOâÞ{…íàñ{ v7) e—w‰›®ZKÜzñÜxòÉ·ô­QrnÀŸlƒÍí“ÿ7äüBçº,1ˆˆY—Ìve!A•uÌÒa(ŸTVÕå>2Jª¹Ñ2]¯ Ò1e¢zõÀGÐ"ÕŒŸxÅÐûÉ1¢s³(ýÑìí²O¥8U‚qå'¶v¾‡gˆð#ƒµcbŠéÌ-Ò ë#Iÿ[2Û)’ ™óœÑNñxÀ”qm?·ì +c¶ððÞ0 E2Sÿ×wž8æÕl¦7ŸE[õœFÛ�›Ž;V™ã¥¸²Y¾f.À/[º÷ÅlE”.#)Í熚Âaö><V¸vx‘Ôôç#½D›BÇèxY´ÄH!¯.Õ\{©UšbdV&œòWÊDì$wúc7î¿T«êÇÏU¹/]AÅ@ÛÓEi}«>ï=Â`pW²ù›€³O¦äÑÂE?{ª�À‹{²y~üŠPf•g>QK`}a:j”m`E " ð ÎÍÊd¸}D™­]fô<¦+ö(ð�ãPÁŠ[«Gÿù¤ M÷ì‰?b¨$5þ~ Æe¥õ妉Hqj½º;žýË…C“fVã5Ñ~€šÉ<\${ÀƒÍŸZÑЖꦑáçô—4õ W€ç‰g—›À¹„— e*3Ïk¬GúrÚ×={¤þ�j[Ó‘¼èØà Æ\ÀéX›ãÿã›»8•Ï„ Ysx(VFdÃ, i9Û÷ I Ó—>­œ�w÷› ô”‹×‰E±}õôVÑfoÑSqO¾uÄmA-âdðˆ0Ÿ¼;@yÄÉr‚V4ÀGÊ÷V¦J€³!œÚèB ÎÎ"¤5ÐIã¡ž¥ýÑ=zÎg 󮚟Öä%3ڥ͈^Mûå ÆöG+ã€CÊŒÞožzf¬JÑQ!¶…ÁÔl‘<ÈF½jëœ £Ð¶ùSðœÍâÅߣ‚§Àw]¥N_"þ¡_™R¾v"àÔ=Š9´{¨ÔY¼í”[â‡7=*×.R•‰Ž™™Ç_þDзóÙPýã¾7 ÉËxâM…f¯÷´æúž]z¢Q´O‡³¯\Ší£$k‹µÄø•E³sX, Ng×ǦHgmöÌ8ò—có4rù9”è Cqqô}ëÓièxgê®üCg8.Pg8Ë@è÷#â/½ç·%ç§Òk“­] 3מΥ:·ñìþo=$ ¸)ÀÎ ³Œ´ÖYÇæå89lúëÜPÿq˜Å+è³ñá ßkk6¥–ó§Î•O·î[w}¸òÐ/E^ Ý‹—µ[›)ÊŽ‡ÆµéЧŒ<eÔªT,´/vn”:Årœö5ÊÆ×é÷«ØÁúÏàš”µ¢$Y>²¹„²F·vþvïY„¼ß2¤‰EUð` Áàb¦‡d²´Ÿ,š#@ÌÅ‚BHðŠ“Îêmuºy¶õ³¨'O¾÷ÅÕJê4UmõèKÐdO§n¾\?~¬z(}ÉRª¹L Æ9°Iˆ~ãžý)’/Ô@kÆY:¡â¿Ûdjl:@FLJºUÿ® ùÝPHÿïÛÐHÕΊ+½÷»ßQš¸¿Ç†5ða*>u‚¬Þ~BX—œõïüÚ;âsÌ—$HNZ™ ×…BBu‰‘N©Ê ®°³°ò «ìáÕ¶VêÑ,ؽÁͪ}3Ï/¬ëÈ—>.ûÉŒñØ%y~*,ÌV¸ÂH#3ý'3 ¢æ(¢}µ{þCË,K×öâ䛃°ÛyîÞíJXcXO‘±óµáå¡útD¼ìbxÏàèÿÒéfÉJKçÁ×pÏ95«ä€dkVÕ/½3牌œÊÇŒö{íóÐPTzº$kíÿ÷Ð:‡»ÚæØàÒßC#F®WáŠèÞ¦ÎEbL{kª}D*UtPêÖd/^v"Î|wæiî›Pb¸\ÀG³£YÆ`§´Ë-¬”j[…WŽ(½Ää}¾¬ýk4C±×ÝLú"ê_¨Ÿñ¹2újÓ…,öJ'àéÓeÑbh1ºÚ×ol¥{¬¥*ò• Yk…"`l!¢RÔì!3um[)•‡ú9ªÉ¢v„‹Cïz:">_<Ê X±‚Íå~Â}få#¾e’úžØPÑÎNž¬j§ 8oΣè<úOåP[ùÉÞùÕ™i bŸÛ‰‰Až¹L˜½;äæ:º=c·%™‡£ ¨sèä´ÍsÁ:Ò1[«ïåmȶO4t®_Œ/øö…?ðÕ"ßR¤ÿCç•üëÏûŒ$-êsžBOAÕ¥ÿï_¦§ †ŸñŽÜ3Ù¤øÇIf„âÙe%Ø®Pâ¡]:XŠØI7)ÖHÚY“ZÔ¶–VÝ÷ɺãDW¶9VAl5²QlõWÚNtšt|Ú™P¹TBÃgªL ©Ž1ª¾ßt ­‡‰ñcÍiõ` ×ªÁ š=ÛãqÑ™¸IiK†›ÓHï Ÿ* ø€J×óᔨEd.ZåÆÓÁ«Äxc|!ÙƒiJâ äfý8¾½¾/ý™W¶m(RPÝe·V$Püã/}m´ èŸyðnì¼ÍCÐóÈ=˜SäøZçee8Q mçùçÕ‹µÚºçì‚ûœ@o‚BÑ×I;%*®ÐÝW´éú âêµ"ð~âN=±¶­8uTN¼6%n–š¨™˜ê#nàZtÛTëÇ_útSž^á›ñ²Z<¦-m&’¨—¿Á‡î²ŸýígWR–¸rXð.]E›»wS1Jr)#eƒ<ë12 .úô"£ãž}fja™· áœPÈÓÄ8Eü¦hÀzu²ã¾q‰”QyîZ¸ÎÛ%9Þ'ÄÉ=HýÏ!Ùµi]Íu'œ e­¹gê î¼CÄRã™ù³µLS×—¡¦¼oY<åZŠm§)μG>Â*¢á¼ä#¥ÕÐçÀG”B%I^T½ ’GtŒ³Ø¸¼9Þ–,“)µéekÏ!v~Œ'ò‚ÚbS£š«ná1Б3±_X?ºI#£è‚wi·_^E>çÞFÖ,UO+ÎÏ´}§#^ø¢upª›KJ.[OÝ€¾1ø8š¿Èx5XUCN’%%eç“öÙB¦CüÑŽéoûFQ™gžy\Íésë’>Ê¥eVúÿ~Ó*ΰN%ÍEPö*r_ÈeÖÊ:¬ó“èÂùOáf*S›øgùŠÉEÙ\7fAÖ©×:H,夈Óg~Ün^¹âQv2ÏÀÇMe‡u4.DùßÉ[i…½zÁ7¥sÌÏÛ×ØxeY&…•qCÂE« ·´ç(š! :q}øéMo_ë„_ÝWÍQ•å@!tôµÌ¸ÜXä‚è Ööé3i™Ø¬è Í‘"ÔnöŒU ô”þ‘eâ”ÇÃJyO­€s¹hB§tÆìkê¬Ø|À.ôÃñ䃺)ÊtÁ<±ïWdži}ý-î²;y¢ÕÒS´§T/ºïC'ß–µYÙÛZµèŒ1+|ps <E‘±õñÈc^‡ô£Ò=è³i÷¹³*+2±¿¸û—¥é§WÆÌf™!T<Zµ:úkï5+É–ö²wÚéØㆊ¼`ûó/|Ónæ†0rMƒjPjRÂôä3„: wQƶ3ÑÒÌú¢£A'¥<EcÝ`p¨ãèqŽÉĹãÉ>>MØKO™3Áëè ›«W§JCãF¼;YNäÉ~W&a;Âg¸ìl”fäæ.qXŽ-qŠn˜¦×ª À:d§žw¨˜zSí‘+”ì óýȺ†3tû¦¿ Ýd•ÿMxÓRØ7Æß™>Óqüïí•:<©èã¾–0}à*ŠüZʽ¥ÇB`ÅßeÄ œoö\ÁÉVR)£zQìðozFSYÜ3eñî³;'ž2—`j“‰ÚZÓ`ízLŠ4:¬‹m‰sÄëçvkœ à<¥A±¼{]ßn‚ˆ”_›æ…/ƒžPšAkMÑ°xÕÙ8ôØ3ó¼ÖÊJ#ÊêûlY¬}£Ó:‡?-×`Ü7pv»kg:{ÒøöÆ‘ I¦(g¢ºç':®«Ï�ižÌ¨Í‘ÒÍO¯*ß2#‚*¦ÁVdqÛ‚±^Ó;®<ËJ.±1lIæÆ›‰ˆ&¤a¼:k‰C¿z„ÜÈ£îÝCk@‘ÅÅ4Zxß|ôûoî$A~,ºL ú‘ ÈH±7gÚ¨PÇ9œÕTö>A'U9ÕÈHŒ—"ˆf»¦ÏÔ××ìëâºXù ÷Ñëw=½1ŽÝÑB“¸­Kz0î 储µMªnó4õã{a¤åYÁÀž­Wů¨ÑEb³t\¡º§µ…ÂæûãÉúØQ®9^×ϧ„÷̇w²a߶lÛä]p-(H¨ÚÂÞÈcþpÿ¢4_ѹ ôféy÷6J[ÿÙÛøƒdÓA…ý‡þlú[ݯ|uæB,Èܘr<ôæˆUÝ ŽBi8fµ¥Ú²5Š!?Þ�=fŒ|)9hVTÙŽÞÔǪ†š‹ñwRUå æê£]ö­×85F�Í€þàzóÐÕAátØ›’j{î¶XŒœŠ«21°x?{ 4Å|ãšïEâ k[Ô6TצÛI;Øk…˜Y†3%”¼]dñݼ<£Å9¯@”©³iMeØR¤}”ʧ6·÷uGŠ¢pã0]ÎÌ+ùÒ; 4ÖgªhUCñ…11ULUæXþ˜÷ŒtäÛÚ7‰DöÓ1:Áƒ¯îqš]5y¹Ù˜•Öд¦ªW«qrS$[‡8Ól&Žf°`Jƒ,:(œßÎJÏò‡;pì‰ð¥©I¡è.ìeî¼f‡P¬$ÍÑ4¤™NÚ~‚gÉ ¦~†ôÜÁJ=2‹ÖÝÔƒÑúÙxhOL/K†¡µhɉõ…aæŽ$àö,ù"(ÚÚ ðÙ¤?¬�k¦Ä¯ÖÂneè«ÉÒG^>Sö¶·t)>@B§®(°(oèÖštIbw|•8¾›‘VÚÕWwcðSuÃ-\Ñœ˜øa<S7ßõáÝÓ3wâÛo೦ÒJ"#i{X N΂ªWnm¸þ™ßèø†šf™ S[0«§…æhÖÌNÛÑõeJ­ëþ lÙË#6gçöfÇpÝÿ ÀoÃÕøÅRA£SŒKçýõr¿ö[w¸¹á4° íû¿n=ñlG§îgºËÐí1äõWYìq­&ñ ˜PT‹}'Ö…‚!}!k´Ô> ïžë¶µ-Ž¹—~ØÙKë=Ånv¹Ö·}²rm£CDo¤ n¾L“’ÄcýñÆRk^üZ)œE^zT2Gœ¶…ÆŒ—˜Áo|Tx6 \:t9¥^­qva§Rº¼ûóA[æñØJ©¦ f#&R¶&íO’(ô 6ІÉ:›ç¤€ÁÙÇÜÕ6åÊÙ´BÚRÖŸžØ9·Z½ÉÖߥ-i–yw1΂Ý�wúÅñj(þñÎ÷½À{Î|Ó0)Œ“|§ÆàPâàóLÃ¥Ê?÷OC×^)„ªqcIXoÿ¼Å òCÃX/ñž»€oOV‡‡õ‰rƒê=RÙ.²¢(RDXATÉ^µG²¼¦ÐGöP>y·º‘±!$ì­×õ‹¶ÚñJÝ „S¾NûÿE7Œ3(ͦµåqrGª6qÍ7gŒ[êá65n¬-%0ÅûÉSŸØÖËÁ™[Ù{Úà/yÝ”ÞÀ…Au-<¨»Ñq¨ë ÝÆÃÕvzw5 …\ª ÍJŽ,¶/›çîzpEÞ´1d<LoÐÑú ° ^±tË=þûùžØB^[ƒÚìùd¶’}Z ŒçqìØ°@Ò„ó—7õÒ¥mïIh‰¯¨H©Øñ‹Ž¼ªy÷¤Wf`$¥OÁ�t`oÔg”ä& QŒ#رJGÊC\Òçd³rcY3í¿äøòÝpžigz¼ÚU¡YÍà’÷Γ„ËŒn-·¡åq¢Ëu=t­ßþˆÖÆÃ�a‚Ÿ¥”Û㦫Ç=0®]»ÃJv´xŠ °nvÈK‚™yXÆø6(‰âwõöRuSÉ™†ï·ÇÕ 5/=ô£ëç]”úâƒ09PÍöQ_‚Ä™ß «4ÍZ•½üçC9’Še1ææú£Ÿh»V_S‚"ø ¬àÄzƒa÷ûGj"sßvÝ„1WÙÿßÿA*6Ž«¦ñIÿÓ;¢à±¢y_Á^´£spÜ™& OY5ÈßyÿZ7h…µáÒl¾ÆA¾´^Âun:HôÄ&ÉL–™ïd±…$%[­×‚ÙŠ•§1B×àò8ÊÄ©¢äqÏH…taɈ9¢#¥—ÛaƦ> åúKBoûpi~‰©2W”|Z®º‡²5׊$ëß0r|nåšÝé–> ¼†Ë³¨Ç¬µk/xsÍÊ£þSp rGƒ|¢¯ˆÑãa´]TƒžHqÙ™!%çéaâع?°šsO¥§W]é[ÉsîÝ`Ç r{ï™ dUq£ËwøHA5>yFì¢ãdåEÁ™‹J­üds£þšafÜ$ÛÂÏ{íÉ#žèÍnvÑËìÔ>Þ¹êQ;¹J>³z×j«P©c�L^fK‰@Ø‘­ØÃöõ¢×ð[O3Z¾—,HêµÄ«‡ èc4ïG*eêó=ˆbWwéQ˜¯˜aÐThEì¼AùP_ÆÙwÐÆ••ÖÆOªT”jW±s -‘½·^'Y† ü™ÿûM_wƒƒd|Wç)= ¦ð\8«sëæ†Â“ÄnêíÞÍ(ç³+÷ŸßqÑóGŒEª‡ˆQœ±¥$ٮﾼQdªE¹Ó<û6#Ì]v)v–}¤Ÿ½×tëÏr“nûX÷óãm'ˆùGw§ÉÀPìÜâ[2Ì®uêY¹èŸ°tÎO¿×;IúÖã!‹ÎÒ¶| á… Έù ¡0FÚöÉ^ÒžÍR·7˜,Ý4EP-µÓoø<{$òK/x…Í°Gzìñ‰VÃ*]I=&9–Vlþ”A¼ûte:™\“Ž‰ý°"Þ¶›mõ-ÊŒ8…j©ó ‚EyiÿKâuÂeéq[3vmÄ(!±ó_Öf0i›fÇ? ßûµfAA2ç‰b¡‚ >w\‹Áòƒ*ïóØnÀ”[û¨ƒëäB®Çc$žqPõ“§Ç!¶¶"ç/6ۤ㱽5ý¶öˆv=¶]+ÇÑS¾½ ³ YvÐœ‡ò‰)2T,U+I})lLÇùè!2-êУAÞ+bŸ•³qåQÓ Äæ¾Íéܽxî6¬¼î¼c'ú›èÑKˆ³Þg-§Ò#Ø'„*VýÈhapW»37BKÕðÑb´?o¨€Fä7E–îòa`ßã…•CTNÔnH4Fí×z¦Ìò„ÿ®Ó{$%Ü©<¸ÌôÏ[.pC–ptìÚÛÇ›s-Šcwl¦8žÙ¢:Û.*Ã2žŠM`¾Ì8T¿dTyY*§uó‚Ò§‡9mOç‹PCêö‡—‘ϲV9û…’/U¾/äl¾ô9»¢'03D÷–xGÖ1ö&v‰ñéH<ë‘B€˜\DØö›ã7¯ž‹$¦ÐR2@A8:™UÞ†«Zì¼àG5àµBܱè�øt$Ÿ‹fbs)ƒmŽ•†¾t*ìw:héÖ×Qz'L yÎHEW­ À%$¥2¯ðC;…¸beìÿôfŠ"™í"£ãuí~dµ:µq~j²Ù¶piÄïØ=ij¢À´£‘¡U<–{®w‘»"$ˆ2Èk=$`ìÄQê;§*f=¸XÆ㦟Zf+ª¢1´NšEBmRºÍÚÄJµ¹JWÂÉ(¿*±]8½voßlõõ§ uÛAqK)ðqÝx=±ŸçË(7EAóî£ã©ÊÞ{ÛÚ\Yšß\øÝ´?Ì…ÉÆ1Ô÷ß#–¹×‹öT„0ákúíæ<¿5HŽi?ÐEŒ`.GoµPÓžj†NÜï?Ö‘'ÁÄ‹Læ1°nßiúæyõe3x¢ºN®á¹nƒáÓ+MóßÚ´µ'ð6ƒ;~ Q¾ƒ‹öcASô'ÔñºÀq¢€‘ÌÎFp/ì†7xNÕÍëRiç÷z# }Ã<*cú/JÓ[+üzÎ4æ–PöL‹ñË>>K(ü\NI'Ê(Ò¹õ¼#gO_ëWTê8-RÙA’“fÁÕÌ×hš}‚FÀl ŽÏãee€[6­–ÂÉ’GŸ’H-Q•= †âLÕm]gžATgÖí¶ƒå ÿ)ù +ª®mí£QÀtšï #(ÜÏ'�±¨ÿíFÚ”bx2¿dÄšWM,m”í5¡à½õ¤Ž*nW‚ml6ðü™â ¤ÁÊ×¼íh§Ë§S• <l7ž•úRK)VÞAÄÌôˆe©è^Oþ¸®èç"ä»bÌ+×ë"¡2ÝÇ€1Ór+ñ•Øü[íö*ÇÒ`ªÍeà¦aÿEïÙ©%„Oš³¾¯éoþ¼c¢ÿ(”/T=< Üâarå?L7 ÿ¦Ð‹Ã¶$ñ觡ˆ©P³2ulF•Ñý¨BÕÊ<Q:_:%* ߇–Ò„CW°ü…Wå× òmDßÉ\WöÖô4!²@¤7S”ç„Ù‚}oÕJ¸ŽuùúÍË*攧4xûÃGÄŠ"¿i}¹å ;HÛÑ4 ~£X_Æ«iUtcïö* �¥ÏÑTV|gd+_¦ÞbN-’õŠ#aµ¶Pp‰¬ÂÅÙü2q>Mó\h—²jAoßuªW³v‡fD™™ªÐAO÷a?vËb» w^sOÈ’Ü›ˆÒ²ºtý-û¥DÑzÅ;q¹ÜÙ´”A<4EdŸ ñÁÔi9Nföx”&ÔR °_ŸÜâä*–qÄL…Æ´b®BRó­x‘¼{À-> DWP¯ÍpèMp¸¹iOPxn4LÍqÏhÏeÕJw8¿¸·Æ×5C×7½«Xßë+÷³~2ðËËÌsRj»À(7¶€ìRÞÙãÀnÁ€Ä±nŸl°²ð·<U˜4ó%Ö D9Òjè,ï$€ÙVíIã À!‹7=üæþÖ¡>Ébß x:çÅ„rv|;~ˆH½~Û¨rݺv[‹#Õ¤ëZ d*²Ú¬ÉZÂó¬Í§´Ôë°©ìF¼)ò úªÕa ¤£—²i³²Å |c\ú¸bâ|u#bdì1åZQhàÞ £qùöçÐ>¸ó«ï*Ãq´jØ Ÿ9&\5¦ZÒÏݬ .Þ|‚eïøŒwz�ƒºŒÊ2o<D·f>Ò ˆmñœ3Àãâ«'bôt¸_àuLlÛCtxå´°V_‚6f¤§ÁÓ€‡SŸ°Êô:rI­B˜’•ÈÑç‚¥ñåËÔm} Â še/2ïôüï¿ÐÐúö‹ŸÅ߬eAÃÚq¢É<;T“Ñž7È©šµtŸáQQú„:-Odr–ÁŒÒ˜èÈ|ƒÅöšÍ#½ëiòLe$_-£=+þ£·­fg•S¾f3?¥êÌqØ7¨ø"¹n6ÿñ P˜õãYZ®|A Tô®_îú4]·±@‡z†s ¼pï(¹-X/ª¤BZ9 <JßäRÃCU ±OÙíxÞ§¥¯aÉ> ‹2ªd[vÄ‘séó.›^Æ]™ùÈê²6퟾.¨<˜¼LûÝ¥ÛN½ldÑ`û䑇‚Ýœ¡)˜]„µõža–;†ÿš»>I6i¡9ZDf BâÚræss{üYçs—4÷]B ¡ –nÕ«ô-KdÖµ&J©»}¬M‚f¾fÅ?Ö-Šê³å†`…Ç'žAj>Õ,ŠW Ò0Z ˆô(‹a Ì›5çpm-ÞB°0­I$NÇËUšÒÂÜfÛ·}äÍÅá(Mo]Ïü?¢ÐÕX˜#]A–V¿ NGçÕ ×SO‚œMF–©Ð ´BV¶‰cw1ÜbÉ,¯ãë¿ûFFL|ó p!>é.$§«ïWO‹½ëžI¡‹…FŒsº Ÿ4>¦|i¿Sa`«;Y³1–è Ñe6-W&¾ÖSÍhb ‚ýnP/niØ+±ðjMd‹Ùž>r«¢ëáã´_L•úÔ•¾pR]Ò©^fú²2AÕ?š¡·=)o lndø÷ú+é5Ø…Æ{[Õ§5)ËÀ#æÛÔÿQže>S) †‘¶ççè¥/è HAfÁ_û-ï…‡"ät@:ºëíÁâ°Ûb>T°{8pæN ¸ÐÎ-K`}n±å¬ŸA¸+ ò“ªbÆ‘ª÷.‡ñ­”#÷5äi⮋taÚlå<j*«õÍ–þÐf¯"»í®ùV`ûju´&? æk JŒØbÇǼòÝ%ÓªòÍËG×Ì™¸;§Añ5yS3D÷…Ï=C(Etfä~÷‹"Á èöÞºˆAŸçU<©ùU7³Zk3h@·4ÙúÍE8ÝXŸÞ'|¶Èëë€+½‹hE_óòÎv¾šúêFLklŸÌkq›YÕ7Iz,zZ4ÂÔè•sGiðå´_%jX²| P^ÒÙ¼?³†ß“hzßqv uz “W¦±ýì>9$Už[ϘøyŽµ!ã§Ã U* \Ýr#,T¹©=÷º/à]Ï­gS –7ôúãȦ’úx§éû±%gºÔPe¯}ž|Q`ï$3âà[ùDÜQ´ÂÊ퀜»ó•õm¡gå’’r>‘ÓòЧãQ’%‚š³ºj%¹ŽÐ¦ãµ¦{Ø'•ÁyUY³X�HØQºÑ4#×è’Í}se^¡@O@LrÏdªõªT™àð ÑæM¾.Þ x9sç¡Ê~$[V«Ö@ ÖA<ÔV~îÿ Œæm >µóÆ:Ò4¹$ºôØÕ÷ž½üÖüè·è¿z¦®ÜìÛà¨ÛyØH#l‘ÏÄOÖ¢¬µ>“Ÿ…üê=uB6Ú¯¶jBìÝ/OuGÓAÔcV¹À^XF²Ž÷s<;MË@Ãï0n3ÏPO:Ýó…–^ޞ̉ÜxÒŸ{—H÷tÃxAÿð‰f¯Q]%»¥%%–v< Ö¿…-ÚqX~� c'ÓÀôqÊ)ž”+1«?YÆÑûi¡¯„1(ÄîLŸ¬–\°·SGù$,0>?Ô³ö‹ü*¥\Çs{�˜~é ¤ :€Ål£ÊªšdoÓÆä03ýù7Ñ~»\éfüa‰‚¿…¢ô© u!Ûþùå ¤jß³`,­R&Œv•I+Ø×Æcã[CÍúf‰ANتÛO‹,]<H@ÀcÅ»/*-æÞžÈq‚Bò5ìUäzyórn•x6kò±WKùaC<¨¯ÖUíT,cåEøµÁè±vw‡zÏ**#š»ë"/J*Ë”tÞ¸£‹’~ÚÖ_Z 1DëÆ•kç«æ¥×÷ã¼M|³ú/3„¥í®²Xï?8gy±\˜açЙŸ Þ¶!šÙš)6·>é€|ø +òY{)W=I"¥ ÿ«C»Ôë{ù=Sa§A³z“Áå1 Pë¹þÌ&ÒÀÐ<Z^…з`õxȃhÑ’½ý´qhŸñp¼Ü »Îg0dKhcãàt{Úý—(þ Œ…ä²Êg 0ШÃÓà]V³JÁsäù²÷ód8±}eẔÈYéëÒÿZ¾îPŸ§Îº.š0jFŽ5*=¡™k|µ`å[òNéA69±©f ?m°5›ºúD²ž7’PÛÓI槶݀}£$“½á -ÉÆ0:Vê6~¿ÈqLylF ;Ç­BÒùÎQñ@ÇÏXsÝöÓy¢®Ãß{šiìËî& ¨Raœ´ÊjÈ|,µ¹½¿Öäsgj’sÄcïéìB´n®iN’¯lLó`hM–}ïü¢ŽÆ$¾-T¿YlÒô#¬\Ô;XÁÅÞ ÝQzòS ³©)“¦œ¦}EKÂFÈa‘|ÌÁ¥ß/@'½§wY­eæáWiýlþ$þÀ®*«9`½&{¡wéÀzô -˜Sýó.³}9¯ãÄFV™¾’;GoJ °`bú± ­îp®våÆcS;¯^ ÖñåR32jë4¨j?-@KÜçMËÔà»k @{çÐ:£4 mãÙuݺhî ›˜;§~àMòPИ6o“k  ¯¨7 ú¥ï$O±R/£Ì°D›ŠRäÝ $Fñh0\–˜î+ ½î‹ø''ÊW½*ä¸óÊåò™­ß™m¯É ‡ÌQ>Ü‹3îÐœó™¹?ÁTàKSf®Î㮆o�Ò4Z¹jSC[ž}0Ž~É[> W|XmPâ2hš¨S}à®Gôa/ ƒH°~WBLR«ø Dy F(š”ê&–ú>eâ/j¥å@Ý·—/SBÃÜç¤ÄేÁŠ2kX­ PÚx_~CFÄe²²Ô¥gѸ~7˜MmRéqx8ŽòÚv\ÿ7ÑhvDÿ¥0„˜S³*«)»±úËÙ0÷ȲПö€×Ð}«g‡WÊê†ý¿uiÛÁ®7›Éœ4ÞÓþ:¶\d¯û=Ih1LbyO%tÑêÀ†þFÓm,üÕÛG):9g'�u I|MŒân, ôv•ñûb²¶+*5÷úæD$…DFa® 2H‘µÈ/è }óH¥´]|Þëãê2%ñJÙÎI»¬-ÍX 6¶û¢ºß*…Áh—U†{R¶Œ5A;¬0vP+Ä÷í¨�+×{ÜóEŽ¸)ØB+š.ÅBïù…©˜J_ÿ-r:rÆœ¢ÅÎ’ƒIŽj;aZïP|zhÞš[?b8—‰ß ÙDR;:F¿,þ8nDÙ·W P|F¿b´![Ï�úx4§Ì–V4§¯q]OQ°Ï9’E·’+ĬÏ1±þ4Ŧ#z¡øÏ‹î‹Â Éb�xzÓq£•e¾ ‰öýÔ­\ýƈ(JGò _<±pÌ+÷>”QÚÆÿmàÉ!Út^>Ђ÷¤ñYNôÎh¼:<€PìÍ\¼g¹i±%.ð8 4´BÂÉ*îöCWÈô;\`ûÙÐÀ–µF1‰’ô$Ì?­bw‰˜•½£wuû£3N9õ~D×UÕá´ÎîüÎE'² %÷íâIÛ¡¸ÕœUw>á™r±nv™Ï/ä•n ±)´ùèäîÅWpGcóK³*£Ô¾í4¶ôÍ+O‚GíL | yï±Çʾª¶Ð£†Ñ£îÇ}õhºý§nxÅRcu¦2»mUbeì%©Ý3Þë9¤¶ÆŽ²´ª¨<kÎ& -Mô@×Èܧ|b½R®¨nP"·Ó£Ëk>¾kÌŒ †t;Hî™í—æ…oÇÓ4x.› b`-{JŸÓ˜ Ÿ%…(H4”CVïVG>5ÕÅÌ.ßø¯ÓôúÅã°Z¬›ÖÐrKƒb«ã*Ulõ Êÿ"ðm"ZV(é(“ÜQúb0 æ—#¤ÿ{8Ÿ-ó=¹ÿrÕ²®–7xJøòvc‰ž P·f2€{¶âË•«n]èþŒÆìprú*â G{ß±(Ê>)—Ç]¡É• ÿé—¦`ŠL'[ÙéN™ ±R›lâǶD‘Sˆî¤${üºARMÍ‹•f<_U©J¢$s¹/èë=z¾úgn[ t×ó·Þ¨Ê0*~Ú’ýÁEC LºÀ¯<÷£2wí<HßGoø³&ÄìCª‹¸eÇ 5çP5ã:1¤FpÑ'°¼-ýL R* e Em÷ ZÜït[N=V·$Äâ•í„½½ÔƯwêö\0¶…âdÛJIl[†¨gÙ‰0bép/Îÿ…æq¢¥×p¯?˜Z±Î(2J‘›?IdïW§ëØ€Ñ4ÍÎ:hGwÎP�ûýiVäôB7@Ò9¤+ø•L:ngùyŽyº)’)æ 3Ò·÷w­â‹]íÎ{?þÄŸŒ3çwã{Ðiqntâr”ñI«{Æú(Û'ß"dáɉ+‰2Âkã•ôKAçY¨˜('p#6¦Ånš¦ç#—Û²rx± fDµO’Ûa˪“*‡5W.ŠXZWª2Gºj–4$^0 ŒóUÑÓÆ< ²að‹é½Ñöº?ˆ#Ï”XKKÜâÀ÷Ï3ª7­vlæ©öÝdn34›EvýR vét{zùGE7ã”Ú'Õ!ˆSc–*yÂê”gz}âa©"Ójfö'é=¡NÓGã«ï‚„"(éÄl9Ó¢¡ÑÿFjçÁ3¾v“ð8ls’¶-¤&®¦ÿÉ#Îîßw_ „- –9 b‹ÿÇÄŒ’Ë…óEåÿ-f.¢ÛB«^FÌHi2ÆßÊIH_ʵ¨¤å|É:Ùý–¹eÙJR*SF)âÖ 6Ø¿¨9~™9,œÖÃÞ Œì³Ë~pÛÏ:ÇËÆÎeä• ï^s\=ó,ä9ù¶Ô̦Ц' ¤°É)¸ýmñÜ*+ŠR¿qVâ3TtzΕ©©(¥ÔùV¼:Æ}gÚtcÅû!µÀ3J·¶¿q#÷d2æ4ýˈ§#TiŸXkrg欦ÌÝÀ騙å¯@m–• ¨õ˜j9ØU(£¾= 7ͯ䲔¥=Åóe€s½kª©ÂaÆð2÷ ½Õ+4,Zâ·4í©ýŸ«öŒ¥¹I%¨c6æÙM£ƒc¬²:ŸÀ{5ƒçèDWè99*µõ&W…€ûôQIï=zôCCRCµ#k_iWóÖK2¢²¡(ÌâH ‘+°Q ­ÄcÞ8>º´IRøm¨/Ý>«êo7)ˇZ¬‘¿�àY q‡€)EÜÕÖ–{%áÈOá"ýÆw #%|¿X(}%_% ÞÏãÆIS½C‹µ‡-'îý £ê³bPnêa}„P—ðgŸ‰o)L~ב2´’húX¢Ø“OC–²‡ÃʱQÕšEÃÀ{ÏF厇´5¶°Ô±±‹« o`<Ž`h¨Öö'@mä«Æ3-Ò͇)wè 0SG^=έÃUÛO¯©ú=é2n:Ø ˜X‘Q(¥}¦D¯×5­ÎMª¼Ç&§ò@u.ó BþÁÈœa¸ÊÿcãÝØ.~wa,C_¦PÄ#TßçÚÅSœHƒØ‰ì¡µhHg¾a'kÜÐ=² é2ä¶þqÒ(÷LÄߧòsÕ¼9Ò~>[ï@:SÚÉ2é~�¨eáî÷f[&Aº]´kÇÞ­ÀñÙÁeTXoÝM'l/Âw´ð;¶qÿôà)„VÆ ˆþ´l’Ïw6¾9^¿ÑC —þÀþ¸”}|tHŒ7Ç>Ž>IªJ}o$H èS§3:Š6Ô–Ôæ”oŠ]2Y¯…%•&"ìïa룠¹ JC­h ÉʒО¡·Íi±­ì¸ÚÅWÀ„èDPº¿Sb~óÞ—l)YvW~Ë#÷lí ¿ùE^Yƒf›mt (ì<²Òô÷'RÔwíJ@Ïe…±kRDÌ1B,:YS©(d2}Sj!'weü›}î-(7Žc›!¥é|äÙj䣩ÞMì5  Óì‹Ý¯V«Üj*£�~ÉϪlæ¼"Š<âL)Ø?ŒÖ¿ÿÆÄX¦Þ¼¤é‘ „5·ù“Ð*ÞÖÆrœúÐm׫uáXß…è?UâXnºAÄšŠîyòï ´½ÌŠ¾ÅåÝuñòô‡eŠÁÅqR+½JKí FÏ‚[ºÏ(Bˆ-%â'í `@Þé¨X1·´¡Çü!Û¥ ¬«Gµ:Í–fm­„&·7(ë‘–ã…÷"Kä=—LWÜ b  ‘Ì‘Í4Íýä€Ê}-´ïighð7™á—€²LšÇ«c£Å¦šs^寑¹¨Ç”®½ÍV7à0•‹Z½À­¼‘a’奀sõ{)NÒ•éWE';åDÕiç +Ð/Ä]Ñ+¶?œLùesóÞ?öyèì?\{¯?´¢’è84&è‰âûˆÂs!̲´S=ŒŸ)óÎéËÌŠøF¤Ã:9›ÑC÷¥æg×ɲƒd§Ñ昗‚®ýÎãSúñ I.f¸¯U-yÒÎ@ßiTBMÎð½Dþïý "Æ7sO¢ Å–WšÒãìÞŸ&½TOTÎÿ «ö?-ŸvüSBså<âœh÷·ý¤ ýó)TCaf¬ ø ûb†ŸÌ¸óyf©v›;c xfÅå¿À…5  “¼ÞúNZ]Ú˜©ÐtXTbTî}™+g¤`Þó¤U—žï‘éÀ1<AÄX«#O·e (çÔÝx7dhÎ@È™ú÷÷C‡¢r1‰ òÃÅêìz<ΛJ‡ÝìÕN¬9èž_†$í»× ö†Ïý{D7*”‚qø—tý=%;£`Wû{÷#°FTY7šM:æ‰ ;MÙäž91]Ë’˜ Pµ{B©ºXuXܘQQ刑ˆ•ˀꚷ"-Êÿá"±pèné÷u_1VÝäÁ±‡®îƒçÌŠ²Ñ¿¦ë9s–¹#Žµ»Yu1êLŸB€œAÍ€º’Š* à«+#÷«¨8)V¾ì%ÌíŠ ?©¥e^ˆ\«b¥ÿ¯Îôf+Øwçw=Ä ÇÝ| =³ÄøØ�±ÊÃÉfÇ`ìy‚OVxûd”5:˜³ÎèXâ”ã½éŠ3ƒ"䉊ۗ¼~8VJTšNÏ€žyk@77¬§IêOôÏ”ÏP?´’ÖxüË¥Á}L^y“F6¶:y ¥r:ͶèÍ‹äõ›‘gÑ/9èüßÀ‰kÓïmeêžÞ°£båÛ™˜Z®×53Õ(¼ÜfË|± KTrO-{n-ïTÿŸ÷…Z™šaÝÕ Ô9½›ÿFAJÃœj:­ù)/¾L ]-kX ásš´³qÍ°¥î=ûfÙ#hzçi‡±¬Õ?á/Zû@ýŤ„ÓIö†Àf2‹›—hXU´"•úÊ‚Õi?š²´m¢qn (´z¥;À}ý»cxœº, ß\jæÕ*ú™^g²î—¢Åðe-’eAþžÒVî øEû9c]ʃ¡ÖÓ]Mâ"[h¦)UÝ®sR°X$ÈO~Úu\‰ßÁ>ÝØ<„ÈÑ›kGÃé§k­Vpàc„u{ÿ ;‘¢1j[ôpÉBu˜oG§·3÷WD]#ky�ÏëDO³&Ì„é‚o“Y‘^¶öê$ïÐö÷ž)•+Îü1…ƒlÚÚ3X}¥X~jØo·ß­ñ^”‚J<>§¨…ÏpRÙ* ÿ@›Â©IŠè) À÷.·®ÐlÏ5Ùw=›Ò–£ÅÐÑ ˆíI#‰ÞÇé¸ÕÚj®yß:%n»í¡|Ue p<7¸t:›Êsä⫦GŸ›ÃàžÐ×çáž8Oš™G€+ ¢©µ2ì0úÄè_”CÇØ÷¢£{зS³E4™ÐpRx5 nÿGAO ù³Ð×oG«ÅuÀ£»Q˜›ä»Ýý1‘šüþüÎŒ#YaЩ`<7tŸ­Î7§»eÚµVt}}ífýùÄMîMÍÇÏÈZýâ¼›˜ §M¥Áô9Ÿqä"ß²Âı?gA6/+w;¾¥ÅÙZ×ñ§B%•9ú$„Öƒå)1k…’”Ζq_»Ù‰]‹eéú@ŸúÓŽ¢NÜ¿{:á‡ú£;í»km> qï™N–¾ýÒJ™ÇCÿjKK>õ�2rÞ—ú<¾mºíö:ÐQ4Ì@·€x7Mûùa;‹¢bÂÓ+À$³áâδlüÆñƤµ;Át/ï¡´,ŒØœv À(\S&.}Â?{Ì[èìÇñ¦cØp³é¦®ÝïöX\îiôŸ2òeÖ8õ‚•§6ã¶â^ÄáE‹›å¸X‘×ïÛqÇ<^ºæÁzíæÙJ· .-ÅQx3[0:΃ùó¼§Bf˜Ñž{4gÑ¥dɵoJ¡ƒ6ˆèÔ|ˆƒ¼Ñ“lþ £¹�4€í•‚ÏCQš°ôUs!Î2ÓûõZ|$,¶1ñùî¸Â¿÷ É,¡2îè`Ͻg02Hœ¥Aµ Ë/TÄqëó·íÜãÑ HjŠY0ÂáÎÕk PŽD Þ–º5ëãš!’úÿt°w0;ÑÔX Oûâ'×â"ò½-Àp¢¯h¾¼D„·›avKÏ9÷ìG™–ŠCb–ÌОuãC{Ñ—¿ùn þļH2¯§‰Ñþ1Í‚|§3QÛwo¢îèÃ( ÉVQú+ÝíWåIâ·Î‘öÌ”CG“R˜Ð‚àŠ¼oSÏâ‹öýÉ÷yó€®*ƒªÑt|Ììæ×äû0ò=:à4ÓEz·d”°dùpôÔæûÊ{z:=z «3ÄL©þ§ªñäØ@(â§Z¹íÝW/š‹êúÊ„«º%˜5€o³¾eL;<°FßVÆûûñŸ-ºkŒfEÿ7ÙWýÖãÈpÅš$æû«ãÒL¢»´]¿Gs|]à«JŠÌ©NDhŒÇŠ„0‡9¬>ØßðÐ]�L¯·Ì<§T×ä8îéƒî{úÅÀ ôõÊûÊcˆkkÙ:¿!ñÙÔ?Ž ¬²`©j{éJQgíÝp¹*uù H¥*!ßÕ»3AთÒ÷ÉïÔ´j­ôèæðX^tVr­ÝÜè:œ¦’* ÕáKê ÆÙîn 'ŽzÙ~% ÐM÷Œ ‡Ö5s’ùCZ»œŠÆ6fcñC³Òj|I³!|W›£ßŒnxcÛh ðRœœK”•e8ðÔÐþ+œÎfgwiïzåté2æò‚V›wµ§`¸×–‚JWíÒÍþÓý,ò *Ê›Wžçƒ«¢PHULh…'.]'Ûˆ*Ê Yû‰Ë.Ù…–Q—7õ˜ vÒ¤ådtâ7p-ë ûô <{rH|NÝXѲsáëDy]ÍêðéX7 J݉vÍYá¢úʉ2¤eLª 9wÎÖ ag…žLT!£Õ,åæåt„!ßmû4özkLoºÔP%´ÇG¦ W!0šÝø1ž‘&9Ô¬yïxTß Þ¡Ù}çvÑS® F¶7Wzg×Æ‹øfbª`Óì…Ø7¥i§òÅlîJ_ƒ%} *Ì{&y—(Ë­‚ßúƒªãÎaÅ̓â¢÷Æ|TŸ†Îk´ýŠ[ìD>/*sŸ—ɾYæƒ-^º§EžNgùƒR°j«ÖG¨fÝÀX¹”´/Tß©ÉëÍ£™ÿIa©ÔÃEÄZÓ²»Åt„ ƒ+]è“ „Âøžû—'¼,N»s’± DbÏdRV£cœ UD­ ø¹ìj•gå«w¡º—ÉU%²D`º?”@Sú©²¯”øò·¢»yÃcNI·Wº¶\dVô~ü£ÐÕm_âd•@—¨ ƒ¤=™ãVà°˜Ý[(Ô+nàN]gj\ŸÃs0²¶ sd¦¼OÑ)eRàoêóØ„+‘…ew(`Õ¢•—›,r'oJFgýø/çõ@ Š÷i4ŸžÈë(¤‚²Çéö‘ßõPÓ’Ô•z÷׸O¹¯ãD[ ­)\¾TZ\o(uîÄylE@ËižØ':VÈ¡€0°¯ ½:/ž~%¢Ô™î‘RžèSYR©6.×Íp_v+K<„#W€p”£óiö˜ÉU¢X[¢—¾£T‹»¸º¢_óÞ‹WÒZxìPNê}?hؘ{½EucRTûDAq¼ûßØõ†Ñç‰ñ‡æ£†ÂÐp0 ƒ š#çîâ‡g‰«xÁaNÑ…Ó­ÛG£êü”©Z˜« jg‡rBOh?›y ÏŽxÀ‘ ZÖ5ØVæäd«î{pQtêí0‹‚åæ|Ò‡G ÐÊ»Š|ûGd‹ÎáíµnèÍÿÖp'óa%¢Õ´K¢ -ea  ÄZöCÇ„%k´pûÈ£Ë Ä 1ˆ‡­o‹H©ÿ…g’÷d0ï)bžƒÇý™–F4xí 5§ü‹lgëßÌ{RëZ¹¡0+Öµbøó¦Q]Väs͈½6Œ/wn„ˆ­6§~ :Õ�”XÕ ±.óB-c`>²a?`ÄÇ™{v¯/çþð>FmF{èdç ÂS®z¶ «¶]ypÿ£ wìtER¶i!óÚk±ÆËUmzœIpt<ˆ |àéãCa†¾p›§êçÉõϸ[.lWs 6H½gcºø‹Æê8M|»°V´’ÚÙeÊÝ@å©É© þŠ(ô1©Æ‡y¡m«F+€8]…ë‘Þ3³DÖé¾¼ùæ×ßÔ…ÊÊYz±µïˆ^�´<lköPŸ[LjÀRŸ5³O~  ¸9]l¨QûþĬÌ.Þàò9ß0 —Gc\ð­kqÎÊ*”IŽga›ª‹fi R"dü©ßƒsUƒ×†3hr¿zQ˸ôrBÃC„wë{kzðid˜¹ÞíÌKd8ˆ2@€2ðbT—ž¼:¡=žwƒŠ¼r}]õÈ=3Ë­ˆ¼0›°†,D˜Ia&Ç0^Q݉—=Dœ û,Æ¥Q3´ (djzªZ춸1¼'fè€ H SÉôÊGkq¨Ý2õܾRÑÄ‘qs UCk³ =wZº§Ùj_¶çù—2QêôcLrÇ6æC­0Vò9³»“xýÂƼÔkïÖKBA»öœ[vç~N¼g¾‰È<*‰“Øcç11 ®~…åòæ¡´{§¯òªŸMéÅ›>2;¾æ XpãY¾r®û²á«'uËËãå£ÉE‘¬,EiÔ¡¶£Cua¶O€ƒç¡ÁÂQúõˆ‘Gú[¹MÝ¢,·¬xcÃh ¥î[KåYæ DÇ”?ÒÚH§Ù‚y®;ÒÑФàºéiGc‡^¹vÐNUS žß~gÑÌsn ‹1ò oì¶2ç•nJ-Tõ±©Ù[DòÈ•ÜÖ¸c15r}{i-ðÉPAé­(‰ñ Z?ÜqÐðTRSÑêÌa[fõ—JfÑÒ!ø¶íh1¿»:Eµ"­#Ç/‚¬Y<ø)tû뤅D7íp¥Æëê¹êëÉ]¿^2vBU¬¯23ì|¬µÄ+ ¥y=œöµ¤¢/�Qâ2]©8wª °}ÉØ–à¼WO¨=²´±{t™ø^ô‘IÄ'ì‹ ›¡+E§ýdDó€ óʳ�ÆhyK½|_LÜÍc g:,´§n[ïËî_®M _#…é}#†ðMãÝaxô@nÌï@/0âµn.8­PÚ÷J$Û/0¢sÐ-‚ãÓIoÄtú7nÍðaüƳà XN„eLÂÑ]DÃèŠå,Mo@'ï›s‘˦·¹S`tXvÇa Ñ:7@³¤dïéÚF>ñ»ŒfÓ í´˜§lÐ@.›áºx¸ì5¤i?›AË=«ã•e;yË üêÜ´ï #UÉOƒÛµiHh6Ú2¢1íÌÚbsOnóY_“ûúãžçŒªæ9å´\.ÃpÞÐíîDj J†Ù8'”‰ ·O4KU‚ÔšðÎ�¶~\¦åJKEŃþÚþ$UÇ._‘¾¦uaÒq.ïjº³-(“{Äšìî$dz¢æê·7@Ùíâ2õÀàZdÆýј­4ÇÁ{¸ß§öʱnœvi¤½*)U2¤lbkdI¶ûqÃg(+ýd(]†¾k0F[´ ÿgÝ=6£Äñ&¬, J¿[Þ‘?´¢(ë |þëÉ`Dñ Œ,Ï|/]8LC*t±s´×(l±#Ýí kõÆ¿äÏ©36gòl•IVžÉ%·Æ í—áËkêNÝßÖ²ìw íUx»Ö“°Dn^z2¸Iæ£ €#gÕ‡æË×µ<NÖ Ö)><Õ~pÿ€ 6Ç$H—Ö9”Lå.…ZýdÝQª[n°[§#}Îè]mµ¸ÇßÔ8#n ˆTñ¼OaV;fÛt»ýÔÓy¼-³ÂYͦØ`3ÌÙk%ÀçB±‰¹Å2ÂäŒ(S)¼ÂÓ(}T*Ävª,þfðNŒ‘¢)‘u9bd8 Ë’¾Ô‡úz¸×Áµ;þÙO¤¼~¸àÑKFh$ËÖÓž´>mjòËÃKRFF%Ðné$/yPL:Ï«FºåÝŒ¾ÇŒõæeˆü=ïÏÔéå2«…¥ B ÛìgSFy7<F@r-ƒŸ” ì'*Õ´K‚¼Ö„3a Ýi³§Û.!ž[ãUlùñ—~ß›KP|`š·óð·´¶è:uVÌòu�..™c‘c;—æph=ëbc«Ør£\~}LÜx£ÁûaGÇOûåiÅxØsÝ<ø¾÷T/Õó_y¶QÆ¥ÕŽAâP⬠=¡?I°\£õÑó Ø(vp(‘ulzxɽ+h,]ó„6SézžÙŠà²?4Çé‘ÔL†•VìØ%yÎ:.)Y¯Ó‹YBá9vjžÿ ³Çè.YõÑ0ý§|´’ÏêýÈFVnjòóŒ#ñ$꘽}(·ºeH<ÖlGÀ_b½|Ÿ­â¤ðñÆásŒ†„Ob÷‘³{÷hþ�M0S½`Ó8¶¡Êª¸ÓŸ÷kBhë°ºPÉ6w?Ú”Ä*( €1¢* 9Á`]2r`k( @[é:òhªk»ëãÔ‚eqûèåæ© ”¤ô¦ŠLÀñÌ—Ãmh»0ôDaÂýzÛ‚ÊäñÕAhu2q€3$YD÷Wú]I‘&…5Y¦ëÐÁ®e«•u#V&7†aeÀbÄ°ßaU“ü>ÐÜŠþ“yn¶ .#íÈYé”#à ±÷hDû[‡ìn݆]^­,IÒ`)]/ ÈX_Jd·¤3;œA£MyÙ÷=“=aÆ°åNƒÂõ«Óí(a¶“9Àþþ¬Ñ–!ÖNÂg0Œmm,œ76¨ºXpÎw§‹‡–U”ù‚èY°2ªFG•‹ð‡ò!Ä).ñäÎñÞÓBÏŒ:"Ê1 �ïÿz’1œi d�ã5G‡yMÑ(5)eu¦FF>ô ¡3²üÙÁ~2õO½„ªMOæB<¡jpÌßX ‚…ª~;qsé4.nù¥~¯V†§5Hæ*ɃÍ”*6†FrÎ/R´Û¼'˜µº¡67cN5º&ë2ó´nA'AÇ›.îüxSx®í¸!ídÊCì|´bà ÏFÁì÷G5o^ÜÀ³nd[kî–‡µà©U] kôyпù‹tÊó‹É"}… +…íf7RFä)µÝP·V‘ÁD¥+ߎ+ `5 †_B ÜtR™wÐ{ÿ+øe”Å™U¥U{HƒŒ¹psá`§ÃjÔ�©:ù±ãÛü–²4Êâ%l÷Í-~ò¹ÈWo6áMyb¢ (””7N|?ëâFV~NÖ)F³`õ¶Ã_bèÑt¶Wõõ8ñ2V;Aµ­è?½¹ž±W´²¥÷PÖ?®]ûœ{…tÅ›‘¢YÜh;oè.Ýìl‰š#¿vCŒŸ¬Züª5#‡‘b;ÏÅÜ¢�¡„r2øÜq‹@í5î9sç…Wܧ¬{ÜAö5˜ù*ãÍh9öbØò¯iÀEÿIJÏM‡5â7uƒÆL.�aÒ°Ù3xIÐï;åJ~†µ»:wú/-ùÆ“á[PµoÚ«9[óàp¢77ë_š#dÅ u6 Õ-s£M¯˜½)¥s‚€šH=ÃT¾ÓFÌ<3ŠIï‹kÚ2îØì4“ß>Ï,¨?Ì=oÐTw5×ÉKWɶáFmÌ--À¶»aq¥gì¸g·%Hš—Q¬K¥¼ •×;;l…¡ã‚æ€Jä͵!ÿo˜Á(¬Üž.Ñ€ZÐƉkÛ¢cCŠ©uns§0~ITì ”yïßœ"H‘ùd× c“˜îkëÑ ‘éêË„yýr™ Û}lï<ñ´uŸ•œtGÒVÁ¬hcÕ#N:,†áxt[³—¡ÇS>&Ììôgiô0^i‡P" ¢©ñÊ\î¦3oþ‘·2®€U£cªÅü~t'^Ê’`‡]Ú<ˆÎ_>q©‡è›Æ7:Ã:àý˜[èÕ•"™s¿k<nmSŸçãåôÖ0Ù~vyv0…¡ß4€_Emã 7‹Vš‚šeà1ûR‡vw:ŒÖ BæSa4T†ËÖÙu¨ÇŽÌau1Ë ðž~D•ž:k‚+rêèÍzã¸Ô&”ÿ¯ÅÅꮢ” ö;äÏKgSôJ©‘ô—ÌÕ4˜P! oÇrÎø±Ðé^ý«êj¬~Q åK§íç{:¬¶>, ÔšŠqˆNZ2kŒŒqs侇¶õ—áYéóÚ)˜´}ÄèØ¦Ý ZÔž‰w((–«Vœ"qP›ÅǬÌN©dâFý�²ŒW†öQ&¯</Î&GÍCµ3úìfH†«»™®ÿN»;)Êk^Ç4Ì=>Un$AË ·š´A¤ëm_T²ÈYè=|çE†Æ„¡ƒõݧaz;Ovd ÛïÌý½/ö 5ý/ 3¼8ÕÀd3„û8ðwO`0#ÑÎfë׸if[Û,³ÕOE;à…£l</.\Ù…b¡ ƒëWÉwØ’YÁe›R2cÏ<,¬þÈ„V{tвü +©?Ìç=ûÖõ‹Ýð>ƒf¶AëÔé2Á(íj¸pF¢ç© Zä« ˆ°ÿL—#þÚiMÄb]‡Î“¬n÷¬9·ž¸¢Œy×ß\\¹,Oø'ƒˆF f™p Å6n·üiEðîÓïÃÁ�dAÓ@…Mé=—+n“*îµâ@€E`ågo@—ÂYõÒ=ú-’‡Ò”]¹GˆQmç\UÔœ‰¡ÿcŠ•xA–aîÍ ·›yð”XÝ¥R0ШdŽõw6ÚÁ?©ä&Ú”³ ŽÇ5ðÈ.’Ÿ[)–Ù «œÒ‰LoÖª†Ló‘ \ªñâ  $àÀWÏæÊ}jnÜŒ#”l˜lJ0"”þ`£ØcéàÆÊÓ6c€ªX~ ª— èPSýg¯¬ÿ[÷/=?ªÌÏîà”1eAri=‹°†5ºxŒ(ñ÷8©Zèc¯8»q;‚éwÕíÜqFIãLÿ ‡Gÿ²¨áëúÚÜÿmôŸ,²‘±¸ Ž_ð Óœ£Âƒj;“þ �ñîƒ-Ž“¼¯$I2¿{r]·1Äpfn3”ä<IæuÕÄG¢/, ´í³©< ûYóõŸÝãŠØ×z Í¿F‹ÓøëЕG>GEd;Ñé纀?·£<^iTð(NƒØÚÝ`4²:Ij4PU¾Ó{*âVÈ3ó™ýÑÌ NQQDkw³ÁÚ\¥Ið7+>±û…~½L°Û:<ÿqf³$Cx¦"÷=NÄ…E÷È€¸õÔ×Ø^)%®ÉÜ‘Öç€6¯Î öàŽeê­ðHœ:ÉqV¥z¡ ânôÜœOÝé:; DZ£ÂÄ{öcÃ+Ï22o•ÑúÉÑ«°^í”ðA]v[µ® ~9ªJРòÆ=qà Fwãß3¡"ÇX­î>ƒÈÒtNPΛF4U„\ÁzMeŠv_�Åß­+3×·å‚…¶vfü39 ª8âM®§fEP»“rUÃkUQ’Ùšfp¢HcGàzNå qF<ÃjÊWG« Æ‚wO×€‚§¸‚Ò£²²Ƽ`>kÁ*t©‡nWsØÿ•öÙ7)´(+3M3†(m¡M²ËŸµÄÇà•ÑÓ`­X‘h)ƒ¢×N8: ÛýÍ}Ûž‡SÿýszÊÏo°×3î,·ÒúV.35°Í¦*‚|Rz„Ç=Ò¦Üß©k[ÐÜ“g9‹Š™ŠsÚQsVw”€V96•ý½(L¡(—<GÁ´Ë¸l±MB*QÙ*5{ÖÐ.VVá}¨áŠs_qnB'[µUèid¨–øã9fÁTìeÀ…;KÉ/g>lÀ¬œ–<ԑϽš§`{^H£ôê¥Ó-„$X1Z¾8¥-œuRék.×ÍñÐÜ3¹‰­%©¨p@”!cÍHS¥Å·Ä> hc>Ödˆ½å–sGàÄ ŸÑCÌÃÚR†¦øújäð“¡Cªh® ŒªZé;´!–ÇF•„é\hë+kGi*?î‹Pj@ëÚ:ÑÛ¯­0gÄÖü¯2ë{eØÞÌp¥Óû³·.I,üaàÊ´KÑÿÞoêëwÙ§´Ì¼•£-¥6Ñpòl<BÕŠì¦z¿Þø‰Nc¸~n·ÿ`ú‚¥íÛŽ”åÊö%æ:§jêëÝsš<ÁmûBþÒî8P̦«v…ï…õ³éЧ &`ý „e+‰,’“ís²h3a™J¤­BûÂÕ–J·+WŠ ;)rJmý*\ÉN†Œ³Þ�’Q¸@– Íx›³Y3-r -o§Ÿ–®ÕðhM.LÉFmK 3ÃÛz:Ðk©Ýô” bgÚÓ!ÿ ˜†+žiÌ—*¨ÞÝT¨ j©­fz?[¸åU¶Få5ô%>=ÆóhцùÖ#÷Ë¢'ÐRLÉ\M#ÚÔÜ §†[øŠÕso­Mãsx~AÞájƉô‘—7èáö±Ê?å¿gºÔûÚP«õ ¥qñQ|¤Œ®JËèmO—ç´óDŠj°ôùײüQ|cð"øíÚâ·)¨íKwÿ¼]$þmájŸ¹êzö|Kë3÷Š¬ð¸ã`dçþ®æ/W2£HÒà]ƒf†,]Î<L.}ŽÓy^ÌÊŠðÙÈ”j“T¤ê±iTdíä@¾ø¦-/8Eû^îÓg¯‚ì¤zKX)ÛýÜ+щ%¤Œ;ŸhŒ¸FÆë`ÛÎ_8ŠP¬QöùåÚèd*…ÀáãïdÊ2Î ¼tŸi½˜åÃÈÉ„ÁÞ¥úÅV©ÀkËÛjH«ÎW3¼>´Þô­^¤/ßè1lá.‚Á¹Gæfš5t™OHY­•n¾ÇײºNwŸaØ™ûK7‚Æ|[K¤ÇqJ§§Üdæ?½ëJÿÄèà¨5ØödiQO³“82R Š´Òqpj<Ùæ.¢ùìåß-šS¼ßÖGÄCëÄ:†Æ}â’°pEl…˜¤Ñ;u—yý¦RCKͨ$…!4×õqŠ¡–s¢T²ýÂâu8ñšú¡$Œœ’fa ãÓ� æøé¹ïЙjmSXwÖ© “ÜaÎN‡nð½éòjåMW�&CŸøýì›—ýpXIŠ$-&íà½j4¤ñò 3“9]<áUµPØO¿Œ4Žé°Æ@Cn¸}†»ª²BiéÖ]ªÒúÕÉš2nNñ‹øÓe?ík*úiå_ÒR‹Ùç7r‚qžÐ3ãŽw¦H¯•±Æ¶X1‡Ã JeX¬¢‰)¯wµ3mÝ·Ú‰ø¡ßê‘é² ]ôê³ñ"c_ð+Á#çFRÆ'wµ²VA8yûzôˆ/öµ¢ÐÓá ohóŸ•æ„~E|µï¬`Å~á «ß`9¥ÄÈÒo¯uíÄÅj$#DókWQ1w÷¤{ÈLŒÜrdnßüÙÁ×@b›¼<Uº‹Ùý½ël7YÄ"îáƒê¬ä½17€þÒ¶ÞO–ß²is— þì[xX[²3¢:TŒª·?t|œrÊYjâ~i1'ÏxѼÛÀahÂÑ L;­2=¨nØ{ªpÿó°0ª¼Ö`ÅB ×*-›G +Ò0nLBR_³S¤ \àYó(®*G£«°Gº±d;ig´KéÇA´¿­wi‘[žˆr¢ujÒ„o:C¹§±Ï%òþTð²s‚b°&Q°¯[~ØŸfîÎ4¬à Õ8”&WÝ°$ë!CßžâÜF>bå+œ…'NŠYîA G<tÊ‚Õ0Lìøã2hP~á+ðÿ$ŠB¿ÿH×(âmŒ»9Å>OŽÃ÷*w~‚6Ì#+¯e2ˆkoÂÄ+XZ.Äÿº@-d22‚yC{r'¥œ>:ە⻡ÈÆú�µÚömpbŽwª€(On†8#¨…ñ{gzµYÂjCè{pK¢¥XaÀO/JlÙ‰rfdrÚ†¡]ãMF¡Ó†‰ßJÕ½¹ÚGEzgœóý÷>&R5ègÔ­›Ž¨6¹}]4£(BòçUÚÑ©5È@KFB¶âq“ÇŽÏ;2›Ÿ7åüFôx³ 2›õ‚ì<7²,´fXû¦‰ã=¥êí„›æK,y ÖOXf >á¥ñÔßÌHŒÙœ·1(p0\öþSͤÄ/žÊÂôKÞÿ8ìÿìk-'«H7 å¢F&óåY­óá 0Ú} vkÀ•oØzvꜢ6¥º52Ò»þÕùNýé˜AQ«˜SÙ/Sh«î-%6v±Ož«5GìaÐŒSfÚZÅÂT|ó (åcßš#åo|2ËÄŒO+£9·9F´:çOÓóy¤ 櫹Ã{XºHˆÝN,Ю’ߺöÖ©2oÔ<8ĸøÿº¤ƒ"Î(p¹úŒ å¸íå/R¿ßWŒXÉ/�:§%3D"{˜}PGËõ›Kçi~r1.ÖâÜУXZy*¦¶OH¤­à<5s󸌔kS ×l?¨¼ ZRô©=×ÚÝÄûçÞ³묨Eï{À”:_ôªÓýF=½Ý²h¤i4Ðeeö±IÝÍ úû*šÎš¯ò[uÅ }ì\ÈSº,sëuÚ¡¬±Ç ¯¡¥O‡ÂEz1öÉc‹5'°§ƒýyGG@6jÆJ‹ 7õ¿o)ï8¸Ä˜Þã¡i )àÝ ŠL=¼­Ä›ïþåJêf7Öm÷‡‘«ç!G×…µÌôú‹•Ñתí[ÍrîKD…èëÅÛwϪ»ÝWß빺ÑZéÈEUæ˜DÐ�/‚êªQƒ“âÉ™»ê½Sæþ�(PªFקyfèT�¤ËÒ§IÐ:׸Šû)s8‰âyúöÏ[ž+yuÅFÆ­gŸ_ï Ý—‹lce8a,ÀÒkmDG™™Í)9bX(‘³°EĆʶ4<Aù’‹° %¯Ð ‚ã¦3öDxø¶†sÿé-«ƒ6‰+åE’¶8Åx¶ú§87 óïá^õÃIý”Ž¤ÃG¤Öªã¼ éÄ£¸£…ܧŒÿ~£o›Äá§5v¸ãçÁApi KÅoiÏuöÝW9øQ¥´šÂ´1CiM>°S{^KñŠÊƒŸä±Déჲ€èýËY•q³ˆê·½in‡=S7¬ê;&«8q+_e0.bE$:â¾N^þjù35V_xÚ!¯\)E¹§O?ÙeD_ÄfÌê‹Óx“^Û&B¥Òj@“ š¬Ýo}’4]ÙPÁ!¥©™Ü"“oœ§Ïx¼ú\­LÂU©žabAéÙ\«š÷òÚssÞ8¼ÿûVâ`úÑ©§ù3·Ð–̬a:» TóeAöÜ¥8Ž^¾ÏV"hÅòý«ªý[ ïmFæ{·[g›ñ·»…|fË Ø["K÷ƒ<g”VI=*8ˆÀ¨LHæ¿·”Ž›P.pl»¿s~ˆÃã“É·\R­HœÝó¶ÄéÈ RbwW«wÕ¥ÎǃäAô´ä“Ùg–áQ†k{ž˜‘¯i×Y¹ ^»žÏ÷3Ôë ¯5†'´Ù?•G‰­<ðl !ë>øb2{�O® —Ï*(æ‹ûÞ¶O6AG½hæ,ÇáþŽBUd�E&^&8 j‹ç„æn º>~À˜ë]ö çÁÊI÷ŠØ‘gœó÷~XQ¸Æ.æMSc‡dôÎT…sßÍÔnÈ74-Ÿ-º×¯¬â±Ú’"#»äì¶f]3ŠcÏš‡&DHxÈãì^¯—®Òñº38Ö¶çáî\‰]~Ý÷‹´%>uNñ«öGõkù©ž&¹Ï�æa&¿æÉž ˜nOÜ7² ƒðý­þÎZJ1M³õÀ|fŒeë¢uײ] ¹rºZÿ‹d“"ô·xlGÁ²±…Ú$‡Ó�æÎr÷¢?õqX€»Ð‚²Öó CÁ?"ŠÁnD´4Íãö^âwPY0›ñù§&Û¨v\ª tçÇ ~k 5]÷"ÚÃù·Š© DT¡Ÿ:€oëãRß,TúuW3“»}5ÖÇsÎ(J|pØYþ‰°~Ôg ’Ü‚h%t_ºvÔårÄf¶”‚õ«›iP®„¢àßHooQ7Yôíì:u2¢®¤Q£$µoZ©+jJäÛÆHFRGæ1^Cî¡ ~}ÅIÐåUÄþÏe§•(Ü)Æ3kñ›ã岜ûó½^>ü òKD£rÖþz謴Ah`ðj d‘Öͱ_›7%¾v:ƒû–¹ ²í»ƒØ�Ú7 Ë‚ÛI³€¿Yᨑb°gëNK¨Y=xŽº¬Œ,ÚcSãЃÐPQ€Ö¯ÉÑEáòn÷̬p÷Y[΀é|ÐáÈþtRýûÔØ\Q}c¨.ö™ú=+¹ÿ‰B^tÕ*ðmŠ1£Ëß>>^–IáõeJÆPMkm1–eœl,}äYýAìâà]„ƒ˜~TóÙ5Ù¨²ò-“ë+‹7zs|â¾þ#ì¯Ì®<ª8§×A8+>ãú6^©l|ã¶p =\(¿"Zyä<MëÏyP¾6¤0ŠÁ‡¶Ôyÿ“Ósz1!—ä 9/ýÈHpPÔBl“ƒÌLéèÒ †ÿl¶ã¬{3Óš˜:Âþj.ÍIÐÍoF(I ãqæN•éÌ~â’ñ̨¢£`âfíÕ§«Îû+Hq‡V¢ÜáÍ°XñG™Ë<¼£ðB1©|׉Ü1Px<Øö9 |Ø aÌ&­àª ,N0íX+�,âÔÓ~â4´34‹¹G±áOΗe:î(ÄñxⱑêÛˆµBœÒ?¾×ZFP"fjmÙÚ7‘æ*áÛï¾)sx¶G‚é“ ªUÝ0¶{ú¼žø. ¢TwÂüñkÊý¸p•ÞŒ>csÑ™²ìhVReF<Eå¾ ¤“ö¸\Ò’º£æ÷Ss»\ßç¢ßaN“G º"Ô]$§5ÓÐ=€IZú®_=•ý¶þ6ܨǼLôãw=€{y[¥N±´)%ÛÀ{Ÿø$ ¸½{œ²*˜™;-ö ¤×àUŒ½ö¤ûßØ`žYî(‚æ|å2B+žKï艡^^XyTƒ"mP ¡ÃÉÔ³«‘Ò]½xèóœe¾$6íùÉLÕh÷;†ü¬|˜ãU‡PXùñ]§åökµÍ¾¶Îƒb¨=À'—Žš˜˜ù\#mf‡IÕ‚‡!—˜i<2çŠâx%‹ ´ÅÿÁ‹Q´,çZ‹§á*-+ûÄ n<ü…ßjÑî\QœPšT–¨Ùùd˜([Q]´®àÛQ°ûG[S2Øt´["™ò–>tºKJ3Ó®}{-ƒdþWI"1øÇœp™]�¦˜$À®¤=·vÆäÃÐ+gžâNö»4ˆ—Ù1ÜÛã™Þš‘ýâ<íOGýù y 4-¨~çYô¿5YZÛ_u 2æºXí×”-nòúd™ª5 Õìûþ÷£ߪ‘Þ™* $ˆ'=^1Ï2áS%AP¢Œ<hºP¹UßóiÏWz† ýt¾”ÛÂÚrv/å‰×F£X2ì•ølF‚¥Ü0ö™Ý(ƒî4ß´Š³*«£ar= CmÅÍù‹…øŽV´Ž¹wúàá`¹eT�|( ý”ÔèXƒ÷B?™ç¡ðÕ=ÄÀ`Ý 5ü/Ü3…×U+dzû F¢/Ú…œq\VšáΞA˜ætóêÚ»§%˜Vu´ÕÒ“Þ„Ë^¦—)0üœ­:0¾ÔþÛËmÓ-³PÓ øU€‘/œ0ç\Pa¬FÚ>>Š›±ß3)‘+Œ—,H˘ª"ilÝyÝÅ®ÊüMN3F„Å äǤè:`Ð0±7”Öp¸ �}²,ËÄÁV˜½2wðõµSÀÔ…‚|GùüÉ÷…ùb:t•§w7Çc uHbnÀ|{rGš4õÑ�0%Ê µî%ÒëË ŽxD:ö| 1aÅâÌ£ú#8ØBßÀ/peš³ä*õ•#·a+üCzP½4¾ÓGGsPÎ;–ü»§ÝñÁÝ Ê†›£ál|› Ç>Ö†‘sÕ E¨¾ºããW’°«Ñv^-§rÑhå j#UŸÁéL‡ˆ“¸ŸÆvÖÞÌxì1 #å«Aá–p £$ ÖŽÖ ñ™½p¹BP$`fšÔÿju[áÎ�ðÿF)ÉW¾ Xî˜ÌtÖlÔ„Káò@‹)ÞS9Kî„®rM$‰‚å3ŠÎ–0b®‹hÒ˜â|9N,–H{02?£óÕÉ÷K‰³€«ÃJM ¹û”—`½l¸“ÜOÇ“CÏnÒþ9àEm/¾ôv1• Ï<þûFå´‰ó¡6Ó×ü Úº³j®ŠÏ€Áæ>GåûìF¡1Çúšµ¹ ª‰ù/šcE…bPó…6èf Þ<™ã‚@j-´³«•~1ŸêÛ—Qô™?ܧ³ñB‘íÝ‹lj2t_8¯^°8 }ˆm‘sC_¨ÿ×q%Ðdôf,f¾EùÕ#RM\zÙ[ÉTó?δyyX1襭¹—ã|k~–ÑMÂʵûyŠH¹INÇâ¿ÎEŒò™iv€Þg–™ËÊÅáï4@”Æbucžf.RšÞrAd¦ø¸z~—¢“†z†Ç¦ý=Ž›y¿£ÄRÙͦ“áÌì«¡øSÅï*@w’ç$[yMÌhÙÍ¢þ¨<¼zà)Vt -ªÄ9„,qt£¾;y}Ç’\ïå–)±Z¦ˆ~Õ,c—£�í]÷' øÎõç€"Ô ŒbÓ4Ò—ßÔrÕñ)1'%ËXù»ö êÃuÚÏ«6ë"jî6KN×*.�Å]@ãhš[ÈFmÐòf¿rx‰CêÖ2;JrëÏàªîÂ-!]5²n gvûú±Îm­d„K:B¡%bMˆ¡¢TÿCaffch6xÑÆ,TuÿBÂ?3ïÐï¿‘u O¾žr{XøNõa‚Ža”_ƒÛÊø[ŒÀI°×N$DUµ‚ïAÆwÄ,J6F¤® å'v¥ëï Õp>€Ãû©ú3YÍæ½’ðáižV7Ã6¤Å‘ES€—1� j_¥Ä¬Ð^Iu+¼€¹Ë‚ЪA'zt$)wÎÄ—ôÑzY>p'…„Ilw†ºälWe Ã$¡Ë›¢y£ÐÅé<÷…Y 8lù‹.IJçªÍîËé’4Ç I<9$› ¿šç·ZdPç5mã¬ÛOtóëé¯Ê‹ñÈ{æ¦Ï!Ž?z†Å°& £ý°ö¨zþòƒU•º8ÁÜÌyÉ‚òý¢}Öw}»^Û`¿÷ì>݉TFútÞeA4íœ.-tv=jÿZ»dÓ…÷:¡|Ž¥²4pÉh÷|¿!ï”þÂRàžÙ*ÎäG¶ã%ŠDdìèÜÇÀ ¬"M¼H•‰S¦™ŠØ ÚÁÞŽÃñ´_‚—‚!mÞ›òäá•s½pE¢ëOtÊ|^¬èrŸ?¿™u”ÐWÃÛ×mM¹Êùðý.(Æü%ø~$Aåƣܯš…ÞhzǧãŽa‡/^¢¯"BÔv«�Ò[ñKB”F®}%æWà!¤£¦Ÿ¢¯FÿI§ôÀ±Þsvü*!*oaã)Mƒ¬÷RÏBLK ^†Ó¹¹0,øÑé×WZØ�3Æ¢óä{Ä>ï Z©ˆ¼$);œÒáZX{eê)ã(¬›Ÿ©^iñª,Æ®K×H²¥?²q盲¸¢»3 ïÇúŠ . 3åZ~Q‘–LŸN±¸Ù#Eæü›V²&fŽ ³$«¹CS\YzáŠYÂ×#Eº1Ò,… ñaM¤BD÷~DtÞE>Æ‚-•餤$ð¦ÏÔÐáÖ (y®uà£"ñ÷hsOUÊ[›Š+*$iŠäÓq/;áÉ°-÷ŒšbMdAúÞ¹¥ÉöyðíXŠKý'ÞØ!çPOåÚè’Ðû ·—5¥7õ 7Þ¨‰Íòê°@3í€ø†ÆÄO.‰åÁ—ÆàäÜTAÚiÞ^Ñ-øÚƒ¿%w xÉùkeó‰¥?ßÙ�þ7’þÜx*ƒ¨m½ÉF[×ÝtÞ¡ëŠIþ‘×àڇ ²Æ­•Em²qñÄñ©2Ùçß)ØTŪ—Ó•¦Sà¤~"Þ^ø…!1.{1Mê™Í‘αŠFÁïwÚŸ§^ÙUwMOïùŸ†IæÀ@W€«š•�2àp6¼W{˜üõä¨ÈÖ¦(#]”VùŒQˆ$Ë“ç¯öŠtdœ»ò‘£I?QæÛ*Ù!~b;5Ý ƒÝå:ŽNŠEÏÐAÏ£•Ë]Ž„"óä–ùðuBØ÷ò”§‹ÕYÎŒàì “äÙW=žOPœ·©°¹¡ŽqÿÅjV˜®'×°;‚—ÊIÝ’±N¹±¨Ï•òÃ\3ØO¥íΡÙäªÈ›A9Ž-½­çÿ1•ð[53{úIQ3ÖLmMM’È:ͽØ+Ïî*>Â!›“C¬÷„ XŸ³ÞËìÖ‰Ú‘?ð%_ÁPcÛ ó~Zù5 ¨€ÓÜ߇è>m<DžxµÌç>àIÐ*ß.ðWœ@ù‹êÑè³¥™Ã1'ÀFƒ€çÔ;˜S@›³{ëfZâ#[ ùXhED[ådMÐÐNÚÑ3É¡rpsl:Ťÿ}K;V™G&‰0&ÔÔ›H¦È©$+0>LQÓ,¼UÏa€¤Š «#µNPš'©¾ñšf»Å=½,˜T‘~5*h’&¾/‡ŽSè˼<öÀ\Üoò&™G©gí¤ùRÙirJ‘Ünhö§…nÅü²O¥=p‚ÀœÕS&Ö[íÞ@bð,òóÝi1(¤§Œ']ÓÕŒÜAÅía† ucñáev6Ú¯j A¤€÷pbU«ëv]7X…#TǼm¬ï7Ý :Ÿà:æ4;êH1¿¦NZÉ&¡ äÁþ”Ðú¿^<_Q„*¾ÑÖ²\�ÿ÷­kgÖ§²ûØ1ËVè³Å<È-;æŽ T´»Ôw#N‰ßŠÓêFãþ@%Gd*·˜S=†·Yt]»íûœ1Ux2÷©p÷(M˜Ïý“5Ã#ëUÕ£"qx�´œ)G¥X™ ³k—.çÖž€gL\7õÐî7Çå‡BÓ ><%&f¬’JÖõh¯:Lá`²ãxè–vt‡­ÍšÆOMŽS˜øØ·!îu´‡"'†s?îh•fVª †ˆ”¥r²ÉYy®ç¡Ð~Íqþˆç›D+gzº«Ã€8¡é\ËbîDB‹vWú6/°‹o~¢›ùƒh»Ðg?y|Œ-)<y®¿v�©È§1x€.Òr±vÝt='×o (Á5ˆ+ Ížu\)Åí¨NÒGÏf'bC•·ÊÆ“g"ÒðB)OÇp}ÆE›žÔoT®ª•ø*må¦Íƒ¸ß®ÚT#;¦è¹¬Üž'$ŸÈC?aÈt˜¾;S ô6çc×…Åcè3R|žï-ÎÌÇÝF@,AÚë»oSíÎÈBŸ$ÿÓ€ú–3ŽtD¦h¦m—ìTïÚn³œjº3]#Cº|íKľ-0g/ËD?ý\<¥{3è’[z ˜›zCRK2üTX û”•­ãÜÙFHéiF¬Œpd‚°}¼=3ßµ:‚MD”;+È{f#ÉOÕ2÷—þÞ[.±<":|Lò®6¹ÐèVOöïpÎIúr`-tˆYéL_ÙÅ ÛG¹çS(§ëX Í?EãgÇ/Ï*ÅýfÚЧ‹ƒ õ¼áq…%j{ºqwÕã|¶Lj<(_èŸoN}°¸ùõÄ°fJ²6Öä‰çX7ÛÉwÚÅ×#À¼º¦VÇ„9 7+75˲ÏÝÐ\ÍÏ;0[{˜‰ßN„Lu—5Üa%ϳj•ý÷-70e,ä2]gõ´kd¦§<àÊøÿÆ”§ò¹¾°w!n5fÔ $Ô÷¿ù V´=8‚’à-/á÷L õ@BEWjÝïhqÓµ­‡•9Ïdž?ó¯-ŠÊð“I‹"tçMêi5¼2ܳWëj‘롱‹¡s{ÕqýÛ?�Õ2ÑŠ‚ZåýÔþÁ·.¥/ÖÉ¥þá#¥wwŒ£À¬Ë8;µ@‡8µº7n*æ$;‘mTA÷Uù ¼®OUFk΢øö£°ÉïüŠ•uÓ<fk#.Ç¥ÏL”ä‘)}vÇá²{CÛ¦k¥5o4¯H÷íÑÔR»Q¢t ó¢<[9ñ´¬#¤kI¦ôi¹>x5ó¶ÈDɼ铟:ÊûªîäHÜ”ïéÆ}°\5ähévÿÿg~£¼f\½0…äMßô c^ gàCD_³í2&¢ ÕSRʱq{¼gÚÞòÔ¯¥.Üï0ö<yzúb⌃½\Œ©SÙ=!rG:ÈŒ.˜^³‘(E ˆk¯è×Y™DB …ÞÖÔ cck€©v:åÊ\)(*¶vLX²å·5ÏS fJ5"Ö‚H­6ÁŸšb€æýQ0Ò 6œóc(¬>»Vº½’Sãs‘r8ÆËRQ‘sAc}*‚bÔÅ’ øwÓó…>±nƒ&—LçîtïæåC s”ä+_äÈè®ô* ,%àûÄ> :¨‡Ÿ]'ò7:+ql¼2ÂX¹Jh‘Y·lÆNs‡VÐtZA€ÇMòä?#4gåŠ8=Ô¡ì,.6²Îͪ›¡£4k‡ ñµ¶{âuàõrUÓ—››QÙü1ŸpåEþð…ñD¢`þ ”°y·ä¾FèÆ®5OiVX` o–ÿ}®¢‘%™oàDa{ʃ²ï=æ[[OûÎs^lùøA5cøm¤B Ѩ´"G %즹 —n;Õ›å¹Íg>U0ÑBEfç¿€°ô5·óÝÀFÃÁc…<_iÅ'Á´‹àÒ&ùPŸyÙz _Eþ[ý Ìœeâ½ÿœ/ôº5M;ö’YÎ 7 m»²UªÞ‰V ls|k‰Âˆ‚Ý•‰ª[ÎH©R‡n€éýTI柅8§Úž è+ì‹7yÉ¢ ö$w÷[@ßµ–ÛJhk‘_Ó×]ôTí¿Ù×·SíÔ£ÛÄ,†ºJ³dVÒÞºy o¬³ÄFÎP o@Š»s³§öd) ÂDœÃƒ¹iP³:C\îÉ¥É ]Oéà´£}ï,Nuÿ§û£~NëÚuû¨ª¿Ê„ÇøÏi?èÀ+T<(e³…G­ÛÏäSõQ$·jò =µæ£bŒJEÛÛ®Û¿Ñ´é÷Ap}ÛvT_öôãN«&J þÂÚ’®l¾¼;&øB ªn¤N"Æ…bfÙ¿hîV+ÝÅ™a[Iá˜]jYuqéƱvæ(#ŸuÞOÃ-õЗ;¿ñù•±f°ûO/aÁ*#¬‚í3©óDÃIšõ7w”ßOöîV–Ïî'2}÷•qGªØók‰‡ù˜%A:~êmàèÍHXG‚‰rä ùªØ?Y™ÆÇfe±Ó§`Ç,ÞFŽ/ ’âU–ût\¿`}›Q¦šÙV}:éb‚ìâ1”ݾS—ŒÖÄ«ö \jö^WA¼ÕDÌ2jO»íz„Éèk•õgvÎ’Ä^P>B•þvÏéÚÆilÞ«ý‰sÜWÊgX™ n§ÐͽªGëf`òÖÑ&P½/+DMêÓµx#ÎWú<¥Ž’|¾Ó¾‹7¦\M,ÁµÓ•†N/'m81êËÕš[?ÀB;L´k¦FPæ€gÕ8Mäöß7ÚŽ<å‘ü£C¾úe÷ône—§+^6á`ªª ,>†n£úõ\„7p÷?-Æaá üXÛìuûh«Ž¢x<ùi¢–ö“jZUÞô`ÇÒGªF˜|Õ p;®ÅGN}ÿR#ƒ‡íÑ\>áÓò®4pÐçœÌ•6çÙk#ÁÔ{±P,Qöƒž»9„T»Å}©˜ñƛޟO¼®Ü’%.)a]žë‘‚Hqúô�qõδo!{èU&+à~†DRá/‹oáƒfRLÎôí´ç`&˜xW¹™"Ëf |'¬N‚g Çx`׬t Ëæ\ÝãÙC”'UåY¤Á²¥¯*V†‘q£§€¸ªÉÜ °\¦Žµ>øFgLz†‚I…–ÂÎY=oŒU¤eCü襗”+oʧ÷;`õ[¬’[bÍÒÎ"¹Õpt¨‰õØÒ=6ÇE3ÓÑ\v[7lùfNŒo»þÇ«p]¸2ƒ™cˆiÜ)&rêÚÍqùï›5U:lat-W|?€MmoØŠ0s:NŠ†¨JV³Ÿ pÆÚ¶¾˜SW™“'ce“í5 *ÛÎæ±2"¯å7ŽÑ¯¶^“ÌÇ°P#ÍÖU!öÈÉ J›NH𙤠Sl“µÍ¢XUõµK€&GÈPì0å®Ox÷é „Øv2'†nAØ©NqùMCß¡ÛyL‡ûö„l/p›Ûßà¾W~JÅ]Ç<¨ZM©ÒB.èù¢šküý¨)òf[,*q Qd±Ž8\`m¥VXΦçS+‹ Jî/‚wt¹ëåìë„s%¿žq©ã¶Í"<d "‚#7>R’°(âÌÒÀÐ…ö|<›¼js„àÑ~™°)¢Mš¿ýó†£ÌôWY¶:ï˜Hs“ FTò…«wÊ0"çQ@»TMvÚú2jȪ6‡æàÙŸp>Ø¥à­q-Œ4åê´~¨þE9œña“2({ßðŽN–ÑÓ¹} ‡Wqæ;­„ÁH$µ­“Ãvèè{¬ªÔn” õ=ýOWû8ê†,¶/9§J‹]¦ú«þ D¾êÒAJŠö[úµõæz[`Öæo^óO °pEö£½ÌCš"Bñ¼`¨¬úúäéÛ*¼1X¾ Ž{Ûfx÷¥äŒ`ê%Ÿ{æñ›"•µ±JŒ²‡$ÈG-ãy}¿æ ÇÅ g˜u=µad\»ãK½®!ò•ÌLŒšQX=«Il4*íͬ§ÉTˆ?>õr¬›IÓE­×A†Þµvç‚å̦ R«pbqÿîV)`!ŒÂp™|8ÿylØzõÂ7.᫤BßÅ(È`©Ë ®u4K1‘ª< H“ýÚt<©5öÌ=Ujç"9’~þ’z4ò\šøBŸ:»lºÍç¹›:u®u¥%Ž˜™‡·ùóŒùî/Äz3ÿP¥|i™èÜ.–Y“&ºåvÖÑÕ_P×ar×±¯öø/(VŠCöןIMetêÒ ï-¯)DÍ5¯`)$•¿?,ãÜïv²Bì-õ–s÷zî$oö'Ö]ywíÞÄ ˜7}I‹× 3¾QÙ<Ïo8ökH…/†SõÌãpå³q;�÷Íoé=Åý.Wà¨~$Al5V"NÞ¥©Ÿj:Uùêè“[é«P$réL$£Äk+½�ãÿ¡üî 9ã˜÷<2O¬éP*¬¸ü<ZXsÉzTbWŽññ[÷§¶d8ú¸Ûºs^#‚RvMºÞ“V‰Ç¢$ªfO¬GãÐKù¤†|dòÞ{yÝúzžë–jTÓØË0ŠqX §ùZ¢˜æ •ÅCWQ} ßdÿçúÆÓb+U ®=8vOÕ´ ¯ì`;ëMS•ÓC¸þ<H-nÆÐŒèæeþ°Wë`Ê’ÄB{KÚ³ò8·ÇádJü— o¹ç6\!ñ`¯špРi1MÀÌa§\V�b_³¦‰­«ob ¸±œ¥1ïŸn³· å¼=Ü@i¼ò@¤âå"5±‰ FA SD[jDÚÇS7,Fq϶¼ÚH@Û㮢ZI2¨£l³Ô°÷SßSdzÃõžj |þ+_-3!žâBµ2‹U!B·¡ þ-¥8ÎBŸI£3L©l­Ë¿ ŒÇÑhT¶ééHAÑ4÷¿jGYQù*ªd™Â Š6iBÓûñÈ.XE°ëŽÛ-º=—zaÖRÃJïQ÷Fêi<‹B“Ñéä±Nè躌¾á‚¡ó_e÷º¯(|‡Êú©HƒØj«`*³çùÑYzÃÊ¡#+,<[ÙÉnGûÄD6Cm’}öÉ´tÝÍÏ ¨Ú>á­BÇžÜrÉv¼cÄpP×yGx3+ö¯h}ÙJ44¤ (’EÝyË@dþYð+=3σ'Á÷‰atÃÊo½Nšèoçòƒ–_­$ñùéÏä'ÁŸMÖ{ßêæU+‹4Í|‘/HÔAe]"�b`º9  X³Îu‘‚vX=  >#îþÒ;ŒÅOìÎqö–Tò­Xmí{Þ.wƳ…Åef«±9ee»Á sʲ|×ÑFË›öç™jžûÞ@@C¬2zò´|ñ^×Kœ{*ŸYø˜ †¥£/ÓøúÆ–ÒI_Í{^û?۾ʡi hc¸am¦Ö¥ž Ä]ä¦rù5±bØ·GŸ�¢TÅÝPi3˜1’ƒà8¾Ü²Š(ß+û„²ª‘Ðøóó>§`º£S"æ›l)Ã.˜v³â—zαjË8óÊlg Å„Zû¤ãØÑåñ ©×ûìI“ óTþX§æR±%‡)WYWHÖw £GÈ› á/L«·.7^ â¥iU’íšMíÐÙ3.üµÅfžÜà¼/[nM(y ûͤJrº¡2âVEs4¾Œ¨xE<@}¥og€=M%jù®øá"BË¿v=l…òÌK~ï5›ŸŠ!•f¬©™jCWn7;Jo‡8uÇð½gkò½*LÑØls´\/¦S„ŽÈpßvÞÔà¹\yçèèk7Ô‡ã´Cµs÷·žO”÷·¦IƒôÝ÷+öãN«eS2 O°/ÞÓµlC¯Œ¨*iÄGãY!µktž/´Þ“” =Ëh¬(S5ž=û&úvÈ€f$”§ú¤!Ê,!&gìy?¥·žïB««^U´*~Ãéü¾~³ù¿oE¨—ú¯|§-ÄêÖÊBWC‘,pèŒï.YZêÁ#në y¿}ô?xžf>K–®xðyí½ÑúËóO{y4N¼Cø²âf›P]Ò|ê‚Ì„ºÚv<ªÚ ÷%v#ô®'僩§àC!ks1_®·Û{¿bCVWròQÑ^éVdÏC‹×;±„µ–œ/D€,ÇyjW?ˆÖ˜Þ¾+‚äÐ-Óñt1b £È‡T �Þ9‹•™¹ášÐWËÈFùʼn@4}©ß[FFQu[þŽyPŒ6³†‹+®3"+%–È>¤÷ø—a]T(š?z9iµž…F,Ý»ßr+9À{‚þF;VAÒëØ?çŽÔá`†³´Qé;{÷ìNî3?øà™èª2XDªC &÷J†ô¹ý^äuHrCXi ÏU6V6«ä¡ÄæÃó¸ ø’ hDŸxa/rFµ¡ÑíͺSëy5´_+BúÛÎr”U+‘Z3f?“7“E¼ôå7õø‡Þؘ ¸È鸽‘{žøN#t•û‚‹î¯Štò¦òÉëƒ SÜÕø¿ÓÅ …òBœf[Òñ^·þ$yèKo å°n:áD»>xªã5ùàL‘hºÎ£ê¾B×—n"…Åù·ÈV;³ø¦Õñ…¶ýqóà#ðrÓœ›z€a­ æëT� UÙœŽOMÅcµetù.IÕ[Û±¯Ï�x[ïcj˜¸¹›Ÿ¾.—°R¢ƒ¡ßÑ×hµ,ƒxüñt¢E'wÏ_â™ÓDRù¼–h¥·Îû/%sÁ¦QqxÑ1']Ÿƒªê<çPE‘Ù{=L‚¿’*H·'uà`¿áøYiÓ4ûV’Íå8Ý�•ROK CÂ@¥]L§”MØgCòuœƒ]’œ…œ„”ì\ןû¯ÛÄÍ œòÓ’,·i÷”«WÛa”Fì^BoòHÛî%DïUPFØôè×AXëM¥ÊFtóØùE¾[–ãŽÐvö^ÙÉYå@w¢n '³mg:.1 ¢ Ô5¦Öb™ï¶\ž4_Ò•+Fˆ~'Ô0zkE™íyš`&ÆCj>zþ}éVa¶†–5=­µzvôªàŒ_™%½äלF¡Ï½  /¡‹´³J+‰¦kkxêÄyæe'e«j`ò“œÂ(]°Ñ’´ï<vAôÇùDy’-§ \Ïýø(P~ûÅÓÞMDòms,(ÅÐr´E‹ÛU£ôv†ßŒ/C‹xdÃYOl¡Eä/}gG0cÊ0èRæ­¦˜Q°ÛÛ}ºc ùÉ{–v'¸TO¹ûþðT¡ÊãT ¦p£“œË¡ƒë¸Cúî3€|Ÿè—äaZA¢œ‘ 7×ø¡Í9‹ÛË+`ª2wa†5¬Çd'ìÌ =Pðc­˜Å‹ªVA8L Žj¾�Ýùév} yßZ­^¸h3î×µ¦<5Qºgrþù_¯ûvÙï˜ h¤pþ_0ô«ìFñЕA5ª³ÚQ,XÔ¢‰¯57¤t¸uã‰b¯‹Èü¾izk§ã¦¤¨QÔ5Íl€ç,¥~}£žùß=(ÀøåšQ™7 -wbHŒ\ݽÛbö‚ÔÖæÐÚÿ¹®W.Òöò3¬ rÔJ3+[SÓøv·iu6tüÞ çIqñÐSL=<£*øXp OgOðhº¶,Å@®ÞM2ðgõrñ톃µK4 ⨌œ/CÁÜ‘>ö¶ñÄvhÿÚ²çoA~nx¥Ò;Ó.Í‚¢Û,=Wm†šÉ~­ègšaŸ÷´™(C…«ˆ–¿ß~¼?v^Ô™étЗ±BƒJ”åІ›ï©¤5øš8NómSì)Pß"ÚU;‹{Ctþx}ѧÁÎ{y±*j!UEÁ³ÂÊjʧ=l {`PèŽójy(ä.hW]5°mYè-§ÖI‚ÃÖjè`ªÑ}È•\õ04Rܳîô*BA{ܹ ?fmR<”š¬pB{8^cLMÛÉ8´Ó½5‹òž…mäD5£Ô@¨ö'ÚcÉI d#6í” O Ï2¤Ä¸·ú¹þ”žã÷C¬`êøq2ø¹ÌÝëÇ89çÎÀ±˜÷Ì:œ}¿f–9Ä–.hÛ´[e(AùËfz Þ—äÓ#§‘®pSÇ<…3xDh�™ *¸l3󦶥ýôÕÏΚS³Ý–ÙΓ½Ì7+§9®â`¸¿Ü2à© áÛ… Ç·R¤™WYâЦš&ceYwá6ÃÕòµŒ’2ÿÆh†Ðѱœêwµ†(/|­%¶C1­U§-h]Íû–RÏÁ‘ʃìuöÎØ·÷D“íœ5’1=¨ï‰v+ëé@âHÃ\ »9×ûÍ>Ö!·l 0ÅØÇå<{mî™áä€O|\"ôÀLÀàLb/!ÝYÍÔJ ÷Ì^Ôºz÷ƲÄ>t‚Ò³ �«©R’g7r;Ðô‰­P ”¤»?^ít\^w½²8HÎéèÝÛ+eAí¿ž¾1mOÁ8L®¾54£Ü‡&FFtw™à‚ÿJ‘…ÿJb7ô¢ÎÂ*†œ!ÛòÞ§nU(ZÊæá:‚¯FkçÜêÃ÷J#ÎüA$Õ9›?9“4'¬¹¥Ð¸  ®AöbÐF C¢"(=T—½å—ͶˆJ›œÍýËÇÕÛ?˜JýÃ*Üîwú›W'ë8ê,›-¤²w­ßXFplråÐT<SÙk>ЋîQErã¼·½¦Azõ5Lw€÷Ô/("á7o‚ál)ŠÐpÙï`,~³û÷;!Î=ã0žœ/5Å°æäf%´7]k©Ï£t|¨w(Þßþ [pzŠ$%RQöÕR¨.%Æ­÷ÆVë×·ÊEeo4í¶Ó¤s„„#ßFÓåçÍÃÝ&@å*V™@£^Ê·Úc¬y‹)tÍÝNªÊXU®þ¾^Z Ér’ÝvtçVOÁo8hþÞ- òåøùƒlbPÍr #ÓÐõ™lù‡QðuvJÖ#ÛÙgo¬qÜÖ}ð[ÏUÄèàdü?²E÷ñ¬v+ì•›Žìú_¿Ár¿ß3S®2_ÿ@œ‘‚YÜjâgˆ9 í•àa„¾,íúDIG WmZðœê£™Ä~>•ppEVÞ‚‚´0üì³þè\¸ÒÜ7 iM´|G…ܠ;ÃÐÙ•,xòæq=|¶V|†"?ýÙÊÖ±cúZ %óq1úÚ¤e'<"*DY¸º‘á.V9¶ô¥änH£†9Ç^åUðÄ…QöEÙ×C˼P§™å²è°æUèGd½OŠÄÚ+¢Åu=e8s| þš œgâôǘ™Ã}ΙµuC5¤Óf‰ý%­Ÿ†“¢ï¥w©nJL9Áw8QDMGûÞ°ñÖLʦ[Æêí#Ü:Pˆ=²›ŽÈÎ["M­ƒçÿùsÜ̼YLÈ]³ôKÌÊÝ0ÄÀ¦þ¤~äLiÚät£'!,0MÝ;Ëy]Ë w}¶aÍÆo|GÏ€`ê$±¶iéªO_^Kh?”&óŠÜiz\ ¶(œ/UPXé1uãô=•Ç?wÜð%îjÊ« kÄŠZÿø Ä$u1«Únê5 î5Ey`¥¤HÖ94U³ÆΦ¹Š{«Ï¼yí²yAEÕB #¥œ‡RsËÉ¥¿Dµ×ÒTEüÞ³‡Px£³æ[Ü]ªæ¡n§úu¹7ÏvË<¡e^™U§„¦çybMéŽí1>îKaŒ÷ô¿˜o )€12Ò—/ÛUÑÕ31‚%_(å=DŠÜ*ˇmDòD†’o (øÑ;Õ—_¡a"Ï¡Â9™1ÆÝéøC«¥«Õ/›¾Z;ŠÄðcÏx;—È ùuêad16&ýÙ¿vý•’°˜ÌèœÎ&³}yÆfJ‡ÓY=³èÕFJM1IjBÙ(íÆfð¦ÜÖ}‘ÓosÏù¤×“{cY¨YlåyðE+Ù­«Ï‡£\7:¼VWf¡{Ø툰éÝ_{V:Ùli·®vmcùgA¨ÈS"8fRSºœ]V·±§5<h'5ý½MV羦!­¬]®ôKUÒ‘d@ŽvZÉ÷×MÓ]YõÕ»÷Ÿ:…w[x.ʘº¬o<’kSS P=ä-åè}Ì?#颸ð+QŒòú<ŠZÙÌø¬Â$Š•~l ØSÞ7èÃÊb/ s_‚®v‡ÁôŃOôg†˜{ÓÕ—(Ûjä\'㘵|Ë]mÚ¶õ†®ß ìâo‘aYxp¤FÌdžÉûF¶tR"~(ûˆ?ßÕ`¸¶z?ÊfR=ñŸ“8)-¸ÉÀ iÕT•4 ÌÍ.; W.Ûšìá/·:¨‡,ðÄ ±°]ì­-J¾JÙ; ½Ó‚,^Á\…`m;/žG$ÜÞ>öJäËžÇæ½_#AGó×äÙˆÇ{ ´pº:¤„Ñ àKlžÏÇa“w qùò¼Àt("Ú2W'µ`W‡>›ØÔñ_3έ/Su|{Fù´@™$ƒMƒ!6S·]cÍqÜ+Ïâ5t\Bÿ—YLEŒóQ“'&³Mǯ¥C¯Ûd7Î s èÜn-òÐwZ†Ü2Q½óF Ðèæ{#Ý'¥MâeÚXî”ÓPh±€Ž2;·ÒÏúsbSxª¬ŸyDÜßÝTšÕÜf,òXðs>|¨ÒÆAkîïQ5÷ s“ª gú´ËâÀ! ¸YOñáÌ‹ûÛOßÁT§KM›e=+¤0)|6}·zsWRv;Ë3ÆÉ' q}ñ ‡s×`®(àcO»âípþŽ—&PéÚ\o·hºù¹÷é°b{V„o†^ggI8'g)Ëï¶+"èÂ¥®sEYLGׄ}c"ÓGÛ†­{ì~ñtІ…`GÑœ‹ œµ·ã0’6&¿q]r›¾Þñg*k -"˜:7tMz•†lý´o´Núú~0°ëa=у‹×Ç);,ѯí™áu¨¬70?Ïõ}õ–4_¹d•Á2[Ûžù-=S·wñ£€z3j)¿4êvÌhýéX£‰û³1kGˆñ½]ÉÏÜŒÔÃ]Ï©(΄*Àìâ º^<ã¬-ð˜“íÛû½gO¦ð©¯ É3íË$s5ù;lj±Nf%™¹ÝÑö -™îà¹rý$GQ#÷*d÷¤”oQñò»íµØÙá2¶5ãcÇzÚ"&߈{Fÿ)1ç6˜…)[ÐźÁ›»ÜÓ2Ü~Ì»mç'1¨‘ñDkÕþëzôV;Zñ׃ˆ<OGÊTe\÷¸÷ç©K“XYn¾F"ó'W ›.ÿxßÿÚÂLt”üà2ÞqƹÐùÈøXhmDµ®úÌô| ·LðRµÍPý§Óy)o}à‰æNÏ! òFé¨H ¯ó±s3U®ª`ïF,…9éçcJúª*ÆivvÕd%ÿ%ÃEXñp–Ú¤ê.º¨×5€'¹œp„¿$TšwžóõÁë˜P!5²µ}rG:=²-TiA°<`8~9y%xoBSXQFþðe‰@õ¦Fš£¶|f Û‹-Ùá¸éh³°ÈŠÕÞß œwÍë³,.R“!rt¼LtnLµãTÊ'1>éÞŽ¾ólí°iu#ÚgT¯X7eN¯ÎZ]ÇA† ”»qBŸ!15ÛK7tëÂÎzA¼5ì%öº }w afÐÂ> ¾t?hŠÇjeüNJ^%± âQ˜ÊT}vm»ï‹d¢D‘ΗÖtªÌu§È+bPoïD  Ú°UךnÂÕ{Mo±ßÔòMð— #äwú�þæårr¢3Ä™.ƒÌB«t`›d]AûÓÌ)¯>zjUîË$1²˜}lEJ²€Ó ˆÞYª¥3ƒÎL÷ª¡s Ÿþ]©ñ…þ¸ÉséØ¢‚°þxUùKåNYÅ‚¥„¾“éjr1úól <]9µƒO\öñ¡´°§ëÁ×`�^¼{o�ÓŠÑ´ñ®ìÌ”è™EPì-vÉËÛ:§dºÓbÎT¼®‡6¡ÕûÞÚ}ÞæM2C¢‹CuãœQq5³’èP'~ž÷+,éRçY•}þ•E† Ï më8|ŽÚ:×Ã:š^Ò hâ?,×ÿÏ€¡Ï÷ß,Ø`¨óî;†¥?Í…ãxA[Z“‚ :Æ\ÿ*-óV|g´²íÜPj=Ù«W:äqâ,—¥õʪ÷墙6dê¤f„ØŒyçWÄï3Ï? m]JoÊ :+'Ó(fËáXÛy ¥Šr°Ú'wœ´«xÍËeXNWO>ÇK½6ûisž_™:š ƒ0bœ,+þTƒ!è;$>ÐYNòš­XQc ã;¿’„§0âÌ3(ÏVí!º|MÁRü‰¥‰Óeñ²JÜU$¾ØW±^䢇]K‹ôþ„TuYØ@ʘ¢†#’ñœJ09ü//þê )+cÛ«Çü0YóéЧýq8�kÉóncUô“2ÍVÛ>aQ½È*t`Z%yž“�Å\�zý¬¬çˆT™ºQu­EF<l7ç"ïÞþ é^D+kÇ(8dAzµô,ŸˆCvÊB®é¥YúRœ™?+L¢`:äAƉ{d*džÎåÉ2+Õª¸1x]6è Å?Þ•qˆŠÊwãAP)è­%\Æèîî·L›Ü«—_y¿D•#hó¡n(µss§Ók¶÷úì‰håÄFéÐ ï*AWñ�q8 Mù* ­]ë×ò…2óš•PB ÑÜüëÆØ¥Ö þþ#-@…M¥DÉAÛÍ4ŸÜá'Cä­¬Ô„ ø„Dä¡&_é¹6#µã5}¾¡õÒn–v3õÌÏ×NrE¦qÐ)¤Øœ/~WóR£HèïÅ´ãêdè(Ô}~zX ³©Èýðñ „~zTÎú–Äü8Ò¬>3û*Ò?;pYµÂØÜÌÓ€jøìM§ý®¶bvvñ«1‡p=,/ T–ý—ç9º9Öh{© ƒ×wÏVð$4vw‘ÒOðæ:õuÏGÈ5ÙåhËúb5Ð ­y¼݈½ýƒÄHÑMÚÆ( ¶Íùd\XƳÆIìëäã]'z¿vr¼ËÞnI.ÿ¦–a­Ãâx ÅÑ9¡ oíÊ0M2†î&�ƒÄ1ÝåçØR¸þ‹+#˜sMЉ^tß5ਚ÷X¿z‰I¢•ß0, †HN {1\ëXR´õ7½ÑJ1OžX zpÚ¸²0(lôËÊ·Þ0ÔhŽG&Ø}‡•Yä¯ußpX9ÌôáJß×n9”¶T8ƒ§QÏû“oåI¦Nâˆ[×™VêÐx Tno¦}·ÝZ®¤E7Ü>Þ¢ü;VᄧRˆnYg»Åü…ÏäJ¡+p#ièyCÊô²?ƒ…fECÑM?Ò9h E‘¤r<Ò'CþLÒ"ÖÓ]ÃHçÏI½ÔA ºàœô-†,ùèqM+õlš€îË ñ^>(±öt‹83²>‹ò‹ªlÕ5 ¿·£€fWW”ßHyc³2Ûç/#c….€vÌ3�#³‡@¶Ù ­&c›ÉOŸX=Š0ôÍß(DÐr†mÏäy!Û6î¶Fâ•¢÷fcé1w©,\‡m)þ š —<�™–ýÁ,±Ëçxa·Ü#zê¬ÚÈ0 |³ÀB¡q ÍŽóE /V¤Ã&B#rSÀ\£†P|ï æ!…ÒBäµV@Jæ24nD*Peäy&, ²Wý…›ZçæeDw#ò5æh3b“.™´¢ÀôŒžïAÝ!–=àVÈÑé7B7RúíûÐgØ¡³ 2ÒØPö§}ïEäü‡yR "ôVg§kq8ÎTצ1È/ŒÙöé€Sˆ à¯íaµ¼óäãLÎfÃÑ~Z<¥º7÷Óm ’™³?—ìÊjd ˆÝ˜¿Ã~,üCwæ‡+àðÓ?¡ß”y*ñ¬¦ˆ ªÛÚHÏÛú«ÊxÖ{’UdÁÿË ÙuÎK¸‰_à Ÿ¿¼²M׶T#øê±#¥oó™òÐÞ±þCɧgtqsBGŽ]ò0$ ú6 +·eY ŸË£m�ÏDkÇصø/>öÓÇ€1è÷ɽU¿ËÍŸ(Ó/yt™mq\œ5Ñ++¶r Kî""§NƒI镬w“«ÞÏYm0$£Ã#Úy‹ÓBG`®ûëÀÎmÆ’ÎÉ;ÜjíŽÃÐot¼Áw»3åÎfèXÈM[¬°­bÎ…iÛªiøÍ6'ÍCWìS{ù-=+Äç|-ÃÉÙZOSÝ}ĸV§h7¯nr¦ÔÓœäiÏR#µhu_aù4ç†))z ¢)?%/²<%°åÆ?,”9EÌt+òY”mþäW.‘ÍaûA?ØeáÏ©¯<S•°zó¢+CaÿÒRš¾z^úBÎ õ"Œ7ûø­}›fþ»‚twàÄ|öZ-T\mŽ£/b%VQ£2oÎP¢{všÒ ûÔôÙÂÎò<.5cáÍé­¼ùþ‚¾¸Yø>.Šq ‘ôö£‚ác°k:¨—žò¢ßEÉ´ }&pÌ"ô™/'&DZ=ÃÜW÷\ë|ÿ:+®*¼š,¸€æi[Í ÌQæÄäQ£çŃ·=ü€>TZõ²‡øä‘ÔöáÙ¾VƦwgÐ:]•¥ŸÐâ¤[&döÀ€’™ÉÔ\¡2ʧ¡�¦ƒm™;T`aT‡3-»OëxÓ…‡ ‡Ù¤OðWEä;3À÷ š¾ÉiqWäPïÆ#ô í5~¦ö¦ü•E²¦¥Ö¼{ØeZ¬[PºDô»V4ßãg–®„-cˆ•'AÞê‘À#ð´r]!ÕM×ÞŽd9£ x,gl§&yßzL¥ÒµPïŠv–)2äÈ{>°œ; ¡OŒ{¯|•ëÊ(¯/[_¡ÍŽŽÖÔ¤ã,vÙX:iß:Ø¥±ÎB;!c˜[nAy8#¶S·,m•Žß8µ¼úˆx' õ ’ZR¯ì€Õ>;“¬6]·1>SoÛz:""KL¨žâ¥eN”pfœÿ÷NVOÂJÆŽA.:ôË ÷ëD›vسÊc=¨Ö·Zðq†±C!²’Ï©ƒéÚÒ;—¡K·Ÿ¼ž6$Z“Ýq™áºH°0 ÉÂÌq¥Áö ?çàbt,eƒ©8Ê?¢N‘åËØée¨ÅèŒ2êýä97àØç¾°u2iÍÃ?}É&†œˆ4a{`ÃIzƒ7o÷ªˆä Ïä ÇO`£>Ͼü <qTwßμt`º’'R]”n¸N«æ8_®KÿKOéÔÍAE×w1š¬p%’ÀÍÔm øÎ|ùææ¹Ï{„ËàÅéâºrG5¿ MÊDë„/BwåÑkš–f¸Ó}ÁI‹æ°6k^œ’{ÐÿDZÌöñ»ÎFìu)ßL°çµÖŸaüöÏ[¦k¹xÖ,‘9ÔcÇ串BÕ8�Jô[©&Ø..ƒ?û“r”Q–(?y‘t l×5ÎÃXÈÂfsR‰l½„!2Û‡üw &e\(mÏ�"#äŒ|yo9#õùB1·Râ Äx ¾²3Б[[Ùß»}îÞšä™e@ZÌ:/6u{;äm1l—VÆO=7¥H7 hÍN©ø°ê`Ó0;D>Oã 4ƒÕã:K¬ÒгC¤;6õô¾¡… {ÞO¾ˆêÞŒŸk†¦že+'AËHŸrþ×—£¡.b4œßËYU)y ÷íµi'%q’­"‡~6¨Ÿì¯ÔÐ#ßÔ…çÌt%‚¸ÓB1U´5ºö­§®åŒ‚n,#˜£VÆWÁÎl*BДØniCL6#¬u¤¨ÅXì^(¥5ýÀûˆ¢(‰\QRöST_W§1[71¤ÄÌdw9Jý`,ZΊN8±ôGÿøžW¯'¨ús”ŸŠÝO3Ñ™6,µÿ¹éc§#’qp•SŒï´Š´øx4 F«?0÷”³·Ý?CýÏ¿Çó¦¿óaPñw¼I©¾eXêˆ3çÒ0ÈÞµl3b4²c 7Ó³pwõÛýLÓØq@ t ÓÓ—ÍDR«ãh\˜B4tt^a¾"$æS=¬õIîþ»)¼‘ :ˆméFe¡pF<\g»¥6ÇÙè‡xi)z�£ho}#JU‘?ˆ‹à l½^ô›DTÓé²…›ÀÔm)æÒ3p÷éÏ" ÏO›m¿C"é=U!U,Åç?'ß=¤!P­;sî–Z~ïIä÷ꘖpßyªKÎû…¯Âµ;Rf«›vªÁTK 4ò2ç‹;”â`Ó@*¿ÄÇŒvŸˆß†[qR¨ ®hL7*eFÉÞœcâ„8þû–XõÙSG‘Ê&‚÷ó°?y-‘;Ø,^ þ„t²¡hÞÕÊZ õÜì#2c ´ž®bþè=…ñ™¬þö<»–Âkؤܡë3¶áN\EjFçz¶Q Éܶ¶xàCóÁ°2W‰Mq₾}”§ÎY\¨.—Ñé0¢lìuòÿ@f&ÑÉc —h]í)c–f¾Þþéïd©Ç¬)?5d»Q ”»ô¶·Óà ¯'˜ðÅP?!nMZh)‡µÍ–>fbÓ¡Ã7 XWÛ8fÏ…#}°í&cÚñ¢ûBùÎ|…ó™jâað–Ó"гî `ûðPô4 Ø“v™AúòHÈz>ÃoŠד¥ôô˜Qôs³’;t`ä$@T£¿5Fcû¾bú÷—©IªåL—ió'¦ôÿkÔEœ0(`ü·SºùETxÏ;›óÏe-OµÙ$�P¿n=–-z¼õA'sUå4Æ$ ‰yC…5ÕK'W_ ïüÊùKE ^Ì‘®YÜê(í]OÉú~cÀnÍ>’�ŧŸaýÛ î ÝÚ ül6Ä™àMLkvÐnÌ.‚²ªröcSÜêņh~„žbóéU p­fK}´ÓOï)hú|F¬¹%|(¸$ºÉI­lBc?q­œ6íâøgÕÂVÉØ#ÖƒçUKœ KëI§rëê<©ôÞ¦nG•ÚêE=Ç[5‰Ò×£† HGÕJþÞ,BIëÏ~ôQ"[¦Ú'²"ÑŽà3ã¶/a…uXJ™ÊâpäpúrÉ4mÖFÇYÍž¡Ó›ƒ°4èÍk¼«…öéY—ÆqætÁéKPQQû¯¹%mý¦R,f!ìj¡ö»ioJ qJäKusÙÒÌ´ÑkÒ‚m‰ ²�›‚q sʵØÄ܃TR½?jÓ-=¨ŒWUj^fÀ9å ÇQ†–Šé»AõÿØø¦ûW̆óXtâÌï Ø¦ÊÇ3WzøÌÿ}+*Û9`øËœRè÷1 ˆ äzc¨h|“mW¹b ¡°„^cm¿KbtlOägt[Rz`ôè`¶JÑüýj§ .ÃïÄBéÆ÷LV}#kDnžêŤV”/.ì•›Û©þwï!/v�uh(L§nù̃pìT2ëQtùD‹Ÿ£m±Hóé›LwôŸ<÷@ ¬½?õt:OÊÆFÃ…²ì=s3ð;æ1Ö×L§¥½Ô¸wBÞ;±íQÆš»œ.´Õšm‡®Ïî¸û·<ëW &¬E0í¨Dôp9‡#}óë~M eœß¡–³˜6©Å<sÅ°¸_ö5£ý4t´–Λ BùHÞVUÚ~BÌÚ »TŽöPlEÃŒQS}:M@Rñpe=ΟöK”Wï!ž gºØƒÖ^UÊó(ƒúþiÚ•ek› U},^±ŽÀØAyÞÿx©3Ÿ‹kÏ[;§ V™ß<'AµX›*Þ¢(÷ôúc‡ê‹Šù[cöêKqaÐÇpc¡•Vô£›ÑÉøÐáãD3½17Ç“$“n~X„àˆO ø>–Cï( tZËÏŒÝåÎ Ž<ÌtbO›‘Š¡¸µ¹v|Æ(�[ íegŸP„†÷Ê )Jt¶Ÿ˜=ÝÎ\5WÁ™F^gD´™×#4Ô›—àÜsሉßJÄœóŸb:¹æÁP_¦nÜt꜊Ë-Aôå)PQú91 ëQñ.½¹gORVÖ4­Å#Ïùç=Ù0%‚}"Œ `(»óD×`ÿ¬Ð,¾/ ŠÐ÷\FܾÐÊm“ñ ”s >kø–›¼bÛ±B…}|LÎ=ÍkžNÐM¡êjÔ›‚Ù“5,} *,Œå,±ï !& tÚÑÚBp1§Æ‘M ¿¹zäžZ3#R›–âYn‡jPEëYÞ^@›¦M&°cz—“ ÿÖ™×ϹxD£vìô ¬é´‰üpÜ…©ß”Âpa†Ž¥Ñ&¬bt˜(ŽÙyo íë7ñý-þ8ö ­¹­ëÀÖŽ̦í.B£±3Çßr‰ AI䇨ÇH%Qnyá´°DH08·{'÷-éŽôéªî§·áDïQÈA¬¢ûú~±6Ãççï`¹Œç†aÓWµ'Z+ÓÉ2hÇÓ‚l<¿ï ßï‹ÏPH‰=v6K¹n µ“ ‡´Ç+Pù(M\jÀl¾`¼”Œ·³¦½[§ù-Ê\î‹^ÚÓç7Þ½´”2‹‚`÷ŠÓ@á<ý|÷[Ò®¿Õ–KuÐ û‡»*.eèû¨ÐÚÎT9)è15“Í ã‚çîFòþ¹Ë½d-[iÄ„ÆλÅ5[mTLÝþΓ.ö©}%:‹ÝÌ0Þ•X™¤ÎÒS¨´ûûFQ”ú¬{ô¶â+ð)Ç(’òÜ1æ—|tË`rcPáùlïÛb>h|†IŠlmO[‚¶ˆ¨-ðPkýê6¿»ìØ øãB ¤ôØdE¸nÓû~ƒ�âžYÚ÷¡û†z÷£lÓ¦ ƒÔj‰�Ò·ék±Q°¸úý$ÞçGöÉ·Vzå9â°4D?an«±úTŸ‡ÙZ� wJjäWivŠìVØÍn%ôQùŽ&€?Î3ŸžH–ÚÂv•¸F[PõÕ‹Ÿs�«Ø-ªW™XEã»UÔXc?Z^•DoFE¯8‰m¯œuläw:B»òKµZ+“ðÖ Øè ØgQÁ5~Ç3µÏŒ—TÉÆQݘ†' Wz¹d–|šoÐoÄ3’ÈïÒŸë,(êóJVg‚YÁ´éy )È“ÄÇÒǬ�ÿ´8¦ŽNý#[\0‹pº„/r {Ͼ‰íFÆ)*“ eéת.²­`ü6žk:w}"s¡¢<Oòü%òl¤ûÜ.á‚i—I¯s¼`['¶zدȖq#qêY…Œ–+EíZÏIˆ WÂ8Фø7ò=e> Ò€šœL{.0Lì89Ú¿G¥×âSßàÅîoVÿ—”ÕNFW7ü¯v (CïyPlG§-ÞN+ ò-[ý)k½º=Ù µ³î"p’㡯xœA³è^âÇGžþøƒÅ,ʱ¯ø@¶{`-úŽÝK ï h’É(Õ÷JßÕz/–+Ъ’ e³ÙŽÏ`êë…ËEúf(ûÌZ6N|,Zi‹$H>º•¦ÏͬÍk ý T-u/‹ëVáüh—y¯HºÊ 'v€¶Jvî· (�WÙJSç©'ˆoX¨…ÝQ8ÿAëÜá#+5ÿ  9]°’T߆ªöL/¥øƒ4LéÁsü¢Ešš2ðÊ1gº¿ŠšáÈâZtÑD½êþp%΃”¨ÀîD'–ÕiG%H›÷c¯Á*,õ~ £ÂƒÀ‹"VÕ{ãî)ƒ„›«ëA[Ñ–ïê-Eâó7ÁG…³A5î| î¾FçÚ|Æú:qûL†Aw$¤£Êî"±i£¨í»œ‚ûµF”vçu;ð€fõ‚Y�~ä¶DP™]u›d Ê®Qw;ô|Ž( ¬Œ*´¦qê37}°<ö¡ùìÜ‘á8¸NR»Ç÷´¯ $£YugMœ1S½ÕAp{,RÕQ@ï ZøÞ8mS‡I‡ºÅ|#‹çexûh]¬e˜ˆ»w±<4 t»¯XJScÑ�{®lÂh*B8æzÆ®¼…bÉÑÊõµ óõñû4%_»1D°­¦«ý¹µÖZÓžKSÛ"âö¿A õw@ ¨DÕ÷üÜ´:RX–øßQÕ1² Ø<Ô‹ôß°ŒéEÖÊf¼ Ÿa»…ÿîwiµÒ­â¯91èº_áoÉÊèÿ,åÑJÅ×�3++[ÍÈ‚fª±!ÍÜÿæþÞ¿ÏQR¸ÈU°±ïPÑû—ªÕêP*<BÇkÉgù ÑÍâõA¼øAFæ:Ó¹AGí¡ƒt @)˜^Þ¾n™8¾e¾¥ƒh"®ÃЖèx1#`ôþv8•/Üp2ÚlC·lØ{ç×¥^%%íÎ:7³Ç"[¤cg* d߬o­ßªhúbp½Ë<E„hó®ŽÕ4ÐKôØê;¡={¿rªrîvŠòÚæHërëáw‘•,eõ6£m ‘Îã!¡„¨¾z`Ä+XÍ°DÐ�³¼ÎñxaÉšàªämi0¶›ëI+»DÄÕTo9Š2Ùaåýû³–y±Z*põCÍô¥öò˜KÓ'—56¬+¿<½Ónµ˜„ÄÀâ.-Å7‹ÂBáPGó ºJ8ºa.ÖuÀ6R0å¡;£}o^‚‚çkº w*À$¼$Ë øj\óU˜ó’ß4 ø¨�=èl�Žœà]| ÏŠ$I,† Xº;Õe1?X˜OÇÖ³wü̻Ͼ15óÊ)²Žö\#EëÕ >„m'µ2}•¥Ä‘oKG27ïðµ(¨#ù9À¦³ãõëÈ+2+µÄb‹è¥öD„ùSn¦ãv¹õux¬]eß$û™@,[Ý2¡bÀ¤¯C‡™±ƒy‚{ÐÁ‘hù°“Õ Ÿ™“eºðvõ|š9™SÒ¿- Ý209O„~§îðvEE‡ÆãR"! ¿Íp_Fö¹¹—P¶Bª!i-ÕžXN#/RS™ÌH2ùÝöíaá*ó,l� 8HÑc4E`âdñïdÕ?d,CÚe6*ªr!”5è 4™MÜXÛžºßF‚÷ WÖôV"ÓÇr©Í"Â÷Úp½=(Ùê§Ùc´>è)Øni“Eƒ3±¿kÛýítÃuN;¶wžxg™¥ý::¦­XƒªëÅó¾ÂÀÜè†ßHðU±-_%FÓiR±£ý²ÂðœÙ]¿Ÿÿæ4ˆâ•A˜ô4ê/³›Ð ¥¿sð°¶Z#‡ZLŸqf^?”tº™LôŸÂóEdÌøDo[ZÈ83Í+ÉÝ[>Ï^Ï8ËÌäÆb¥‹ÃÅÀÑ`DN§ìÐùóèç>ºNÌ“Õ #ð³èŠg§w«Ìnõ¦go5ô)ˆK&2tü…„ãwÞ2Guu[úœv¾$êSí«ŽtphQÞ,ÓìÌ<ª.0.´p>Ü.§²ÊÍê*¡U]œEÒ´f“jÜ×øÕÙZâ%æœ'CXd‘3 AÙg\æ~göËÆ]ž:3x.™ÇŽ²Ö¼±K=ÉÎ1ŽÌe?Mç¶? h‘Ñß”>ËU 5bøíñeçH²ô‘8_åt¤­ bíû“;ÁÄ›'Ž¾ã9æ`Õ³ ŸfzÏ¢ó'ï‹Äº¹„žÁµÉÅõ’sšYU8_J4b íÈL<Ç™‘~:íïØÇ›%»QŸÕjÎ02sÞñîéÕó§Æ(Ó‚<l¿¢>�Oó˜{ÖãȇŠYª*> PÆJãÚåï<Zº|¶JU H÷A=¤6µÓ¼üß·‘þ›ãPÏj¦—¢œ{Ç»¸1j~dÜ\Òݪ쀗®îæ@)@ÂCc>ÌÐãÕbI9½™ë7û.²Ð×ù^æd«Éœbª;¹Ï‰*lè¸ùñ) çûÝ&X5£Ÿm/f¢B÷^Ʋu2V|PÿòQtÀ‘Ò»^…{fúEÞ .”±7W5>*¤Dî6Çø÷­^‚Ss¸¤ý_&ÖQ’;õÖ„I)=‚ÝyÔòÚ»'åÝ­«ŽžíÚPVužk8¾ÞGœU} Úü’<R3ež§@ü§ó/Y¬/�Cf7Ëq²º”m»·Ã™5·.ûÓ´ ýùç•žˆ~hK«3¯¯À¤C?â8DÏQ¿ÅGgl|í“'^¤Už§¥u„¦Ìk<ÑšF“spç¥nÆó„HïÐÞïeR4í)®-ýlŒA(çUKß}[³Õª<FNNXfyÐe5WÏÉgGALP‰Ï§#Ü͹¦Yêƒ<1<H;ßìí*Ê|5JèÖg­6¨¹å‹®ÔŸê·<}‡iH§Ýî,)}¦•¯ý©§þ:²ê£ÅÎíxä‘íÕü¤Pä:àÀ;uIIE߻Ԝºu4°A±¶}Yò¶Š2OÉMð•”ÀZTD<Pôû_»Wž¾·ÕNì=¶^½ZàGYúȳù‰I�Ã{0:»y\OfD™P #}Êfv#D¸«›ø5ÑÈÜ#d²‰• N'/T^—)e~3u½†kºŽôæ»Ú (Kè|$ˆUü7“£o•q™8�ƒà‘:˜U´£!”ÊÆý /utp.t~l?CŸŒÞvþ‰_’fqæ„wèNÂ¥úšÌ �-p~‡—‰mÜwh¹n¨h`%¯[ã¥<öQ12”0[HRÆ$Û–?žUïê,“×þåÇÍoC®«2Ê]¥).…øüjDó¨cª¥hª?Á.Š2‹M©Ï>«Ü^Î|* fYUÎøi©åq晕lŸ.'M?S1 nfÞsø<Ë|7«Âå,Íîpª†<aâ$ÚԲݤmñ†a–YTÏ…áÌm°p€(X(ý OƒOÝ4R¦BÅÿŨ<VL©üÆŽXZ[ys®r'ŒÌ¸Hê AסXÞ "Ë{f²¡TÂr`Rj¹Îug©ÔF«ÛîµC=ŽXœtí¿š*ˆ›;az9thôÊ«ÂrÞîAßöá‘´¢Xüùí¿ø7~ºVÕFÔÖ`sK1¤jõ‰ÿŽtµgmÉRyÎîɦßkÇä–Ë•$vÅmŒf¦ƒ±è4OMD})«O1XâQL±‰ZÊC¼yÉ#K8•»é ºáƒ‡‰¥ø­™.×ñ¸C×ðܶ×18`jñˆŠç~¯„³.tIkk‹ãŒŠÝ_—ý0£8zÅD2 oÖèæ@ swVk4ì¸õçÔÀ¼®Îý§U2)’Ñh»s’ÑyæM\×Õ¸™3(q”ôvÏ}ŒWhRažmó4H&%Ø£Cu8Ž«sòîÔ¢rP¯1 ðT) ¹ÿ· é½á…N=`_WsµÐÙÿ³Ÿvû‘²ks@ Ãβ¶yH7L,êT•N(­ˆN'«h˯äIl‡a)•ÜóMu°Ÿ•Ùú=M,<½ÔˆÝh.”[ÄÍì!kô½WùçC÷†<¶m6éÞÏÇŒŽÊOOµçàÜMјYçí>Y;[#Îr:²hÁ' â71?…Ý%n…' PúÒâÆÞÊÏù¤aÍá©ÛRµ3îÃeÓÿ÷å²qßzÊÛQëÁ—''^?Üø90<þ*‡W¬˜š[½Ú6ˆMtzÿnvvF—îjŧõÙ]<©ÇURÛ9 À²†Éa]~úÏW› &ÄsÁ{-44Ïôퟷ Â3ö›Ó°y&=97Î!hí÷mÁ­OçŸÌ¬Tç±;t¹_VܵòZ"ÑãŽrÓr÷åeÖs7t‡¦æ£˜Vû•ß Ò¼¬$ØtbTu›¹GùJÐùÜÎg³^úŒ5ÑÖºƒO°=>½RÖ¯.˜j›–ß·|5¹×\/^V3|-Ë^ó–ÂghÖ%y„Bm¾an¢2q7—Y ]Ô->éÆs"@›$¢›Mÿ3Íz!9=Ä×m±¿G™' eµäS Ÿë>oÄ\gÐá TÖ‰«ý,³Gp®À:¸2Ÿó¤"žRú„kžâhXý›ÆuT•™ÁgçŠìºô ¼€Q^=^-[m˜xMÛ“ç/¶¹"ǶØñW³åJÇ‘é(S–¥1´WT)5 ~«óY”w̹&ƈΠ1aAO¼¯)™Ÿ-²3i€°Œ‰^ôáNUY¸ŸÐ¨Ð1‡\§Ûp,åãÖßAjfm»ÁfÔ…B‹Çï¬UÑöf~ æ‘Nðƒ“„ATߟݛ'&¡ŸÁÑê> yõJ“(+¶v{qhøîŽcŸXîKêùíÅBÁªhÃ^ÜZ^aH4kù©,›îÈìHåæœ;ËÚwëæèj"÷@äÏ ïå2ðFØ©v/ßkTaö¼ƒZ­;ïÙKæÍQæ Çòa(ââN†öAE»;{÷Â8ÌüKüJÒ`œ*¡sÈ£6‘°ï0ú£"a±¶|ï‡%‰[+ÜÁíÏôÆçÖÍÿ¹¬ãYÖÿ;W�§»$rO1¶&²Ÿ^㘇ò…¶¾2³Ù=[íªÄWŸ`Ô_÷E?’íìQQN¿2-k;uEø®v(°‰R7"œV,¥2DÓý‰òýѶàãQ_}-ñ'¦­±§‹Ç°qTÛÍ缈˜]ƒvo|Öù@3ÊÕ.õܯû0qYÜŒ¢›*ò>,òLú°ìh*†ŸyWVÎO´=韺<(›Á‘#ëAx©fmKS–.eDzê+Õ-Y‰3ß~“ظ(œµCÜ“Vu+=µ.Š×N €/Q~o1òE…b¼©‡­é*̈®×gŠ¤ÚÙ4ÙWœ›"¨¬^O¼Z›@ÈÔ~㩾Z)}ñLÍÍ¢ûb““éÈO˜x3\[…PnEýüï8Éx3 ä‚pañdɳäŒcVÔO* TAí9"^îl2Cß*´ht9HxZ§#Áp›öí½W›¹¥™¥‰÷E˜J3wÛ›‚H>à…¯»€ðYã,¬:ðëFÜ:ß¡Øvh'†[ý±ýÃñh$þfÿçºËxz,8ÍÊD džŠ½"+ªä榊cJàÏnéÊEŽ hO[5\ðÅp^Í(ÿg)§^lI¦º­n=U=ëo¯¥ ŒgùŸÎ•r…-§c²I‘¤íLs&]q8Eðªuâa7¸û3Âȸ]¬ê�TÚǃ Fîyk>dC‡™o^U‹‰Þ®l‡‘ÐG«mà;œQýñœ¡ùovw…°ÚŸµ×¸ªab®½ç&Fú€ü›«[k¼)#•n†uE“Þš¢ˆ£Ðwâ£ËÕÖF²éÝ*c3g¿óÅLšnøÓaø¹zvßC;¶R4ôK ó ï.ž¨› ’gͦþ<jFú²Kfe’/áóS¸ßôyDg§dÁE:¥yl$å\G…ËпÔí =Â3Ëö4Àö:ƒs,8´ŒEß:§Ä}Ô-óè5‡•ò)8£­Ž®±F 3ÚÂÝ…Ù¸Œl{!‰H³lek IALIkMÇØIlª=FjÔÓ^v“yí‰ n© Ù××søF>R- àzeõk¡ BiÆøØÄÉÞA†_ ÖýÎhùWÀèPðyñ¨ôøOhkî­c%¦íÜ)hž >ÿþæVÒKÇÄ®`™bZ§ÚI¹Y yDÁ§¡Í5ßQyˆœr[DËФÓÕ+”°Š¹eîΫŸ¥g¢PÛT<lAx„sc9,`·»ÅD‡Ýþßn¶”1Œ2`Xneìä<GJÔæArz÷ŽßÒò…‘Dek­êÍ‘î¢UØŒ„CyÞ1N™§²œž šüÀÐÈ3¿cMßþÜdA~Õ41Ö`ªùÈæεIȹ 9Ës¥ß86ad§#,3õcc60ÓißALI‚½€MñNtJ‰ìK_ÿ¡p¸¦õ¯0„t|ïO‚'6ì^jЖµœmæÑX¹ËÂU?Õ*ï£e&Ùl¯fÆ„¤°VåèIh-®ÚòOG:Q?“ÔVŽ‹B~«Ò€'Xô³i‡¸§tòrÕgÏ°:ÚΛ»QÑ|ÔŠÒ€˜E˜›×³ÛÝ]Ri^Xds ÆS n\놔lö,Â%2׎káÃq”ϦOä¬_±Æd¦¥(6#D™v­PÄš:Yã6!Æj¸]¿º£ü ne[[(NÌ•6=N£s°\Ž¶í©Í²çBk™‡‰Ì„EC7rÑ© ‘Ù*J“£utt¶O¼§äç}úB¶vøML‚øÔøÒ»´½ `ö®tV‘UЂ}Ý1ÎZÓIówž¾an›G0�Ò™ôßð—éöxõ&ÿ¤ÐÌÖdÅßü%ÅÁù™0H–Aøn϶DZEy¨ÊÃN|Ž÷Ÿ9]Þð&t/Ÿ´ '%z•°9›º–·‡“§«H«æŠÇÆ=øÁ5æ-ˆîEe»XGF3¸4Óƒâv¢©݇xp­iÍE±BÇÓ ©(¯´˜þʆ;7Æ ‹eœú€Gº¬Úks<¼±£Ú §i)ѲGw"Ò—|V½~†Å‘§ÌÎíÁÍD/—΂òpmWú%?[rûeaŠX_ÌvyŽ€÷’â™"t÷·Ä«mÅ jèÊ ÿ÷옗G6Ü ™n16¼?u”ê©4๦êàÓò]A‘쎎õqÄ)x¥ t+ó÷'íŸJm\ŠÓÇk øí5‚]ƒwz»Òöšƒ > ½Ÿ\¼ QûÎoÂÿØq7÷Á Ø9—”è¨e(7â ¼¥+:{iÙÓÉçª$ãœdiÍ•MçÄ“û+kŒšÖ bkw„ðãlUŒîü®§ ‡Øs,=cwá~,´MÃÁQË)Š^!7@c÷VkíøÅ+>Ë=×÷¼XÑ°¡° )EÅè0pS_}d¥í‡š¶¨ áp¿PÇ·ß:ÚffL±;Sc%Zqì5ÀÐjÞïÈ7÷ž9Áà0õ5Æ)êš'ŠÚîvOnº©é"ïG¯ð[·(¡Ïô�dîÛópŸE—¯P“NðM.>ÿuÐÛ™ŽŽIVå8Mµ¹ Wê“km®è©«„÷Œžt<·Ö|®f×ó ¦z3µ¼-)Ö–…*¾Kÿ6º%ÃI1ûØè ›Ý¤ø7æm^*€oQ}‹Yâ»ã¬¤IN€n>^E ØY~b&•—?UMWã/ðAÀ•Q´é£Ø§¶±ñ Á®à²!ï¯C®+kÀqVLwÅÉMÕÀÇšºÊ¡H‹Ð]>¡Mqò|ŽØÉá|fuI\7è]£+'=4 �Ð`éö;sdØeõ¸ÇbÒvħ~…˜Õgèíùcoh½ˆ½ÿôž²_è§{tKÇd¶¶‚9°Žåà7è4sü½¯}äNX�ÇlG·Ø¶ž˜–ièšh,ô}¤²ªëÿá;¿óâ3gtBäe®¨¤›<êó×ø2M¨#Ü ›O´ ìãm?$©BÕÉéGÊŽ~‘°ðjÏ‹yo Jœ.ÙÇG¨/Uj âXGá§Õ¬‹…kNç# Ä+(ÙË„›Ü;¤Xicó'‰m�á„Sé~)X½«U¦üíÃÊÉú+™ýtDãuú×¹Pùšà^®Gûf'Aòi|h¨ «RÉñ{ž¯þîv”âZÔb¥HEÊDiÚ¹uR¹sßh;‹"ÄRK znë[…I/mÉ‚¸³ÞÊP¥¬‡ýqp`Mº^pQöžn(yë&˜œ2÷Бñ†Aöö¬M[FC”ö¸Ý~`p¸2Ú~.Úœñ¬09iOÑÒ¯zKä´NNriRËßÓQ”d>d“òÎ`"«’'ž÷ØÊ£m&?}{ò{駕1ʼL}U(C.¶<ÕäVz;÷ ßØ'L‡µ9/l!sZ)³-%a§+ëu+ó<Ï3ü¹{xj=Œgë. §ÉÔ‚3HÇ(Q¬c@Eû{þƵƻ:âx ¿õ™öriÝŠRöÐåᨉÕ캄Áh*ÎÉ ¿á„Á ñ‘ÊÛ¦÷|»Çó¸45¥£“xÖ‘L<Ž•Ï3}ãcÎãŠï +Ûx¬„“ÆÙ(­í—ž½BíUdëÚk�`ªêz'MGg¼UåAä ÿÇÞ 7°¶]êÊÊÇpR¾=¨¾÷@ T&Hiaîˆ úNG˜ƒã¶b=y?¼:Zœq û&³Á:b²‹Ua£Â‘íÍœfýÏòõÎŽY>9+ÞÑ!¹œœÉÃöxní�1h÷-ÝeÞ{òv7Rwiâ›\ÏÔáñ_ Äl±yšö»‘ó"Q8 £é» èNWûݧb^p–wÙe²ÎI£˜É‰­œG^ˆí¸3“Þ,Ýà œ7]TÔSîs>¨7ãsã¡HDDë"ÊÿÖ»Î36d`v šù¬òàYoÝ5à*+…ò*}w.‚èÜxµ>ÝÚ9+Ûš=sèÌPÔÕxEîJx…Ð\rÒEË;ú–g ãû½ÔÃe²~Ž]{:B6æ±ð\d›WÒ:ÈÄÉ&™•z‡E³Ò@‹V¿Ó¦)קÏ<nl%bÈÛŠR1Ñú³¶š.#ë üƒý2óØ¡aiPAƒnL܆Äô<±Ü'íží:8 ’² ë­)4úà(£Ô©øÞàÑp Üwü¢UØ[EçÊp‘Λ lå»Ù»ªhõ̧ŠÊôÚ¡dǧ¶N÷­L5à#­’ ¾è4»–°,DàT(�ŸÀ°¶ ÙT Oæ¨ù7å8IÍ.‹°‡gr^–nA¨2ÿâUÏ<1…NlÚ ìVÿ5oÍJ! ØãPʼnÞ�vÙ¯,Âb5¡Š Ã?!‰ÇÑ#róbæáží§›Æ\?_ß›c'…W“ÄØÄÍŒ`vUImN1$Ögd•01X18Âæ3틵5ˆxÌ'+’ÌƉ1Ë,‘¹~󱶬¦¿«XzL<%»òÂ-Ý$M'HDh\uNEš«œ&žEïgÉ,Õ˜­“†ËTéÖ3ݱ|ã,Å*{üh:†~¿Äß­¼ÀÇ[£ŒhÑQ†HÒ‰æ-³êéli8H=Ÿm”žMª"ªÎè0Ë®Jg1wjš)¶¢Ú|p‘u§‚CCE(…ß8Î: §)(ân”œ‡¾Y‡'…‡Š«øÛMó°·ÒÇÊQ9ZÌ߯Z^ej‚h(¹J'«5†NàöŽ•%ýþUvå·QÙ-^tæý Úts»ÁZT½,n”E¿Ÿ£×qEâ’Z‚@!ÕG¸éo}}™?:¾O js%ù®F—Nt(åæÜÅ<85³ùÄîWŒ¿üÕ¿‡ ½9ûðÀÃëTñ<âl“çõìÄÍü]«æžÞÝÌ ÆÀ^Ç®<aW1s©á†œÁs”À•gJc¼êîaUQÅ’¸¼3EN×äp¬RÐPÆV•´Ûh–Êa^?R×Ês_™*ÝãxÒ³'*‰$=ò^9šCÏ]‘• Ú1f elU�-úRZaرt%ï=»Sòúèq–áî¾h}£y+Ó{Óâ69]¦¯Ué «eÝt?­=n¨¨©‘¢VöÙj·DMÖ½‹ä—Ä1ò"óM‚è&À© žB,¤®â-'ò}ÖÃö¿'˜±ßÎŒÀRžÞY'(„Ãû ÌøÂ\• X{ƒÖ÷>|­µï_*£Q³NÛ\ð··¥î†Qì‹ž £ƒ«QtV| ÈšóöqC«Êÿ½‰Áæ3óª¹ :<¶}XKŸÝ¥¦3>·þÝ™h™ú�°ûz˜i%©ï„x~¤OÝ81ƒ„sòÍÕóK{ ^SÅQ§à<”†XwTöᙂÔh=îÄ:^ñÍP’ôkÒwG ÈEasA3«áæØÒ:¼ë’[@éã§Á¼‹ )£çu,#AOÕ�Uæÿ¶7ÛnUY²@Ÿ©¯ðÛ}9»}ó56BÐ’µÇýÿï¸1#22Y’åuêŽQea¯³e2#£™M÷J1Îó‚µ@YP+l›-eÂù#ËeûII+õÓ0ö=›k*׊áÝÔß#ÕŸ;ÐÑõ;4WÖ+eG°é`´;`¤â.1Ϩ2G ˆ`®AYW§§AÖÿj\3w_}IÛv˜T -$([UØLõŽ9JFèabä¸xž*þG@ݱðõ23¼ý®1ç]Að�þ ¥¿Áè–'݉úO«è«`�Èg™�Ñy:·wt‰½~œ¸ i-–ͧ­#= ¬¬©³×þ³bžÚ„>šÍæŽid­J+‹¿ÅÂWtC2%¡Wßy` ¦º3ß›ìëÞ½Þ" +iÞ7.žFÔåêXá?3 rWþ_Ô-}ôñldê˜QQ÷—ë`6.þk:¿)KK¾¥ˆüíÕ¯§us)ÄGãà`´2–2•/’¤‹â¼Û5x:�ÐÚŒ9e£w¡dÍ xž¦Á5wœ…nêa8Am_ÏßÍ V‚óBr€„Ui}÷bäÑ(\Úº·>›ê»gv‘ú\X9ÿ)‚jgX+OîUÞÿk/AQ…)σôßQrÐê0}ˆ²ðFâXUõ€Ý«_÷×ýÄô§Õút(¿§´4[ÛÑ-%9pú>?h£n1 v¶KT+&?©Öh�ã¶üWS�“½[+-Ñη:Ðc jÛù6î3̤»—ÊÂ*W‡ÝýZ‘™mE–Ê\PÛ悹—g/îÞñ̳î3§Î(gÇ–¾­ÜžÝ©o§å $d ç ­· Š¶ñÀÉ=%@#sKïfú,üú½1«œywº4ßfi`VHÿ{ž¬é‘Ro6Fä.Ø_PÑWÂRÜŽÎ,_š56èÆïþ ?ü{Rœß³&´'_ÏÞ훴Ϋµ†‡D½Ôf7:Õå§WNÔ_cÌ …bÝ·P0ÃÄÃaÌœª’ù‚MâË»"Ý=ÑoJ?U3ÆË0 –ãye4w3¦+<p†®ÓsLëÚ$ § ˜c=ÁÿóV…~c#¥{øç° ûo<×àb´rm¦Â}ÂQbeÔ™¹^«(¢Z<ÉŠ²¯²Ö)ÙÂD{¥Qe•o’À¤Ø*(¿>ÝÄh­7‡aQ=º Wê3RØ+ElO‰)ª ‡u³Íïœ}¥àq¥Àá4 –™ÿŒ‘/¶HÐÖTuL*´S÷ƒ±–±õMÆ_RP#¼ê9±*PV9ÃF5  Ê{øòPÚˆ~ÝLqꮹÖ!~Ƴ[Ì ›·õô“/£DBÈ*'=s¯™; ­Î‘¬òË'ÑÊÍ‚¸œÂ*¼ûZ¹…·«Y<užéähfmî— ú¬õ¾Pâñ‡¾3%ÏíwœëŠn·(E‘Y­\ôA·T UE ¬± »Ëéb½2»JÈëcKæÈøˆª¼xã/=™ ÈN_Èç¯&Vøãž'“Ÿ¢² ’Œ•F÷. âIùC%³}j`EßÀ# ¾‰™ý]¸vC Çú«%ñcÌ:pÁa“Š¿ð,)VŽ{´?Ùª0<™f¤¿úÞ1�xû4]ݷ¹ëÕnàöüÌ| ìL¬Þuú ÛM×*¶ÿ™+@e'-ÈM’`¦£h§æ–Œ|G:þo ¥)σNBÄO9 U÷æ·ž$ƉWú°hhÓ“w×+5VAfót¨Ê<Ôo?øi¼eq¿ŽÉ¿°»ôéðèk_g Q¢¸h¶˜OËxáÚÉ"¬,ºÀùÃĬlßú6ìZe€bò“¥íë¶\­íàÄEè»ÞS^?_£<ˆ›Úó<¢Å4]d,[ؘNÙ×ñt¹Îæ+ºü«Î,Gtù5 ‹]Áñ]EÓCëÁ=ÊYNüßvЈý–K|Ï-8­²fäÌÑĆêçiveçKÒ¾…Ó¼adãÐQç³iÆ’Ó¤ms8 Ãbv+æÏ×[€ï¦�ñ ±¼i Û¦£D´_‘ƒÃŒÆ,hÚ¡Üâ–®3wûÙÓŸBÄ9³6cÙwÊ'«ë¿+s;Úçr|/“|ÑÓƒ¡ù¦P°âш¶µµ7‰”*As ÜJºl»]¡¤ôWÿÒ“0#ˆ+8H÷“ç× %1 Ìû©»HVD—'3lõ.¡âqQ8]Ùl!ßgåBJÂìZë› ±ê, E=FœBãj«q<‹k´Iw;ƒªÃ‘Å�ˆÎ¿'ÞÀ+@hú™'“ÓŒ¾QÍ6xs`å^‰K;œ™æë]óŽÂOK(@-ŽU±ËJ®=éÚóÀÒg‚)ßø’»Œ›:Ñî :±å™ï/|ÕœPh|Ð6[J½· 9‹Ø^ _·„¢Ø7¤âòz*Y„ÁjL6”´‡Íbú|Îú_ï´‹é&¤S!rÛ1�Nf< ÃéË:tý†Ÿð®çe%ÊP ó (õëô€dÑþÔ4³'-¹ªuþ­Ïf:}™˜ø ùšûÓ.¤ôl®:ÿ¦�0x&2/€>²«úÉÀ`á!Û#øϽï<%=‘’ d£­qRí¯^ÚC:a£™gcÎ@ûúhΓ¦>á9¢? ùjíÊ+iLûÀÑ¡ëgvæ嗱ü®Ú’Ä; 3‘ï~«ƒ•câRz_ø7¢ IæP4)?ç<Hú½×eµ þØñ#OaÙ æóüQP‘®9AÌ8à£Õ«ÿízÓÁ|Y€1)½±8£(~Þ¿|êCWo¬ 0í­Ú`> š¿>¥ã$u`“ˆ"§í“Õ<¿ì¾>å#I`¸*†f“Õ]Ok¡³$/8O C7ù²h�Vv˜_ö…v´ŒÔ4¶‡‰böôiŠøEtÚ8ëóŸd …ðÔ2Lu‘pææ-Mþ…’&Óî׌œÈon83sWŧþ¢‚™KÆpmMÍàóž?ø÷ª; ý¶<ÜÆŽÐ1_®.Õ5Nr`>á§ÄOÇfOgo§“~yÐ{t&tÃG&p‚ºc’Îæ†ò"cÊG×0HZÍé©tû�í³wnÂGˆ}q&k‡Ã¢eÛqó-•Ð§#§�W¾¶qiQйÉ.> Flw;ä þŒIž™Âž§æÀ3½xÍA ÉM¬ Užh—a³¸¬¨9÷Ž¼÷{>®—ÂGœlïÊ Ùj2ÁÃåƒlü ïªLÃ5¼ªÁ`&­·žŠÓftÊNœêï„(_’Ñ!ûýIÃÅI;yT%Í)_3°·<x£ª‘C$<ÈÛ«7°<|Ë(¥æŽ‰{=00‚G5õ ƾ²»ƹ«YV– É;eäo; ßôk§n[oö¿‘®vô“Øifx['-ÐÍ¡’¼…Ê¥•Ô©ûƒIçï\ù`×*L«Ô’[à¢BÇcº|ZK:˜*Ò2ùS{Š4€Ä¢y,ôÓºeúiáöÊ÷Žž}¥¡l7 Å-ƒ*¦²*±Œù«ÛøûšUÔ! ´«Ì„Å^®;Áylh/"høÛá×»„™±ÕË«tíÄ5èYåœÊ§ÁC2ôXG›ÍIb„›`ìÁqÀLe߈˦?k'ëan:nç†Çh³”,p%£ž¤R š¶¹êêþ¾ûbzã–Úìé=s+1D¡PzƒdŒMÓòÑ;ò˜dîò&í¢ÛK£ïº–Žwƒ]æo4 ŽNŸ3û#t½TÚÎ9ÌÀ2¯«§Z:¡™„î¿V1³ƒè¦ÌÇE1sØÖ_t×úVïØ2,¬ƒ?Ç ¤tÃet}´ë¥s b%`“b ºå·v",QœÜ¨¹5T\:p>k‚‹—0ÐîNOžIkÙž{d:R”ÑÍgÏxš‰ªâý‹•‰8¼—¾R`pÛ7¶Oï Š*$»Ða‘;²GA+Až¹rŒ©#Í_étEq•zmþ´…Z•µvF°É¼œëæï%ÄÙ¡úÝÑ`TøªÀ‹ÈvZ‰tCùÌÇkÓ‰É_Ñ­mJ®J^,å7ê<M}}i[tkqùºnë®?í 4ÌàúÂ1P:avQµ¢½¤ÝVÛmè¾ ³€»Ã,~Úéº;Œ¢!ó†Æÿ7GT¬õ—'âè€áag{qF;­‡n=eÕÇs³¥ä1Ÿ¯„a3I”B»C…"8<ά÷´»LÌG_ÍÌ<ñÞô-…›·Ò“ÙÕýIñå8+åpg‰Fs÷QƒŸZ£´rÓ£Í|Ø!p»;Z‘!E=,“òƒlàÈZd¹A\ìk¨ê²ÏxÈ 0960î2 îâ‘ {’»`Ï~•}ŸÑ«&2Pævؽµ´ËØwV]äÞtØl<ç» ¢ií+’ܵ_…, E—rÑ.®à‚æ2<ÒSmD7`nw�„ѼÂrÒ ›i¼–v ©œ¦- 6uÁðäܘ¥Ž§ë`#kõH~¼ëïFÐø Bž2…rhm=š ™~çWˆnUèS(k»ÁIZ«ôÊøGïÏôÉó±õ @–үݞ»5Wazý /ÈïK³yí·Øº×‚øàwvìjou(~Á(ÊÌ1Âòñ’ѧ6ShÏÏ',µ‚ƒÒ”¬)¼a¤Dnrµ rçdP lɃ‹8–JÙDu߇™ÚÜ=ƒ}÷ªL\ ig• ¶fOçãü4ѱŸžÑ¾>S´§ohôF)âíô¾ëQ“\¾ r¤Ä\µ¬á”ûÞ8)XHVŠK¢d÷j«qûú½}—¸†ëüÍ3}èiqªyûÓpp=E¡Z=£¾7h “• ¨g‹Ð|>» 96«Ž–ܰГ½׶}â •'KE@ /�égå£Çp}p¶!0·¥ûbîúŪíÞø‚U»úº¢“ÃvÃ9:à:»äêôäLýŠTóFÏ*D™aL0£4Z4†TC‰Éd9Oi£6ga©c€tò„•ÆMlŸ:Ä£ÞòÃ)¬·âáô¹#Š)›ÎlÁ!cZzXíÞÜS0õÅ.ÈH/{è¯'®$fF0¥¨T[:gÕˆóÿÅ¡ˆÌw›Ó`ô*¾ý@ ûïÚï.zq1Ý«¾ Ò¾v.®Ëo§Ó‡‰!”…A?ë"ØÔÇ�Õ<*«B«Ž”qP¸^ôÆNá‚D¤'$Þ~PHÓ¬«Ätv…D8L¶3¸rk }ê7ZŒgºO‡ºë` Ò?Î@Å,uU07T;c@™{ð‡ê¤‘õÈLRf¾XYd–N´SPšPõ„5—¤.ÇZ¢¯Z³„ÞÀ)¼-8ñûì™è,ûCm ›V)Zß®<0g[HGÄÄÿ#E’òKç%ºsž ¦ + 8ì5 ¹ÓNŒï/%ÐAÞ+üŒi6 ù¥©P\†™/ÛVsŸekE6Sæ¿7'7oëÅEâÞ‹7iÄ™ËZfG*Ç‹ÚšÔIJtg¶Óé*î…ÞŸ» Š<è>¼ÕóUƱ^Ó.…¤µÔxLt‘áp‹\J¶¬9J{Mä&¹�¾såS½�=lS+–ÍI7“Ç.Æßü0Ôó›døþõ/Áz¾9«t”·äÖB‘=x>®Ìä㮚 œqû*j,£¾‡tó¢s¥´¬Å’Úñ¤7ÁY÷ãnGä(¬Iñw†­JÞŽ^“‰N$V£²"8ž7 I¶l¤ò‚:kélî"Àá›TïŸÞL¼šÓE×èÏš‘é" Œœ%ÐH-y<·ø%í ýÌ’(J× ]ðš>\gå? îm‚q±¢‚n_¿£„¢ÒUG2ä”mäTéNª£‰â¨›„Î,œ\4§/‰»(Å]oƼ’cx®5+›lm ’1!¦˜ô/�uÿ4‹ žÑƒÿ%&*R_O,Ìllw¶¬µˆ§Ð6ìU#e¥{+ë¬8‡ø·CÒ¼(ý°Ì¼žr†L‘2¢£ÈŒ5£‘½ añžzAß:ÿ­ì%C Âá¯Ã‹y³?ÁúÚ/VKÏ©Ö¸ôvRªò×GSñȇTqýBë¾ ’YµR,aÆn§Ö }·ù_¾gîˆIé\ Ø×”ŸAñ®0p*$[ÏKA¶‘hD¿Í#¿îùcÉÓÌ3¶¢¥´ë)š¡¤·4å\#Y D­2'¡ÎXÊÿtëôêÄGÄ<=Wé0¸D— ØŠu%ºÏÃt}c§5ã LQ,*sºíµÈ4“,ÜMõlüæ…ÉJ(›‚JCyµÕ „é@ÓÑRàä닽îéÊ×)pApd{ÅtçÒ^FCàt™Uðc¥½|lÑå©u;tÀf©Ø%KÞþÆÄ×—sMoÿÑDäc=ñ�M_)1ƒ³€ÉŸ2,¬p»‘e´TÞ­7 šƒýR[4o½~W^o±‰uâNŒtøØSâQYíz´�`‰tGÛ16KÅo‘=ò›S"ì.@!«|ùn¸)¹yèßʦÃéÖ–ŸüUíÏÌ8bU…•D% Š“ÅS]@ÑÍ °À·[£¨dÊë�¼‘jð(/€*Ý–-à>µÓôÁ’Rƒéž1m׫½W ¹7%ÃþTOŠ[:OJ¢b<”L¸V$º[J]ú (;4_¾/ûqŽþ£ƒÁ¡yâDxò€}Ú(@OfS¶Š?ÜÙþå¼Þ5EŒŠ¶è豨×è :HvÆÏ”¸w9Ô~ 6Y¶â/$âÄaYœ¡^·î{NôDÐÜ5•ìSÐTA±xV“Ò²°»ÁXEZZY ¶Ïjò*ˆwµ) ÆdPlŽ:¸>ÒW©vw´üù& ›=£ z•îÇК‡¤s ø@݆ÅgÓ“?Ù!ó¡p7û}x¿¨u£%«˜FU2ÀŒµ$/¼°Ô†‡ù|âo›°¹õ/[Tzk1š”Är7zaçîM~‰[|«c±ÍÜñ/. 3å×ÎãJñ^àø-|Þ5‡é†ÊW¥…¼Z ª•lz Ä„ 7… ×ÿžÏ‹Üû¾5!êöÏÆ”–‘'"à•Q}ß™z˜&>¥©¾u µ´Û¿)¨£ÃYïÅþIY•æŽzDÉO õÄ|T­†”¿c}°å=Ž—ºådzt?¤Ú±­r£7~n(‘¬gÏô‡Ö(p~²%Î_&E°O½ ã•ØÄ�Ê uZ¥ê”&Òbr§ Øῦ Xqq=¨‚ Ÿ½G¸EH.Ç¿ø =aàÞùôLj´ Ãu‹bØѢͭ¥TlTn rOùÌ€SúUeæÔ‰U¥È¥6§4¨êᶣçDgßp˜!ÐCqMPoÏÛp™J19&.0fï’ÈPO•.²=±nиLâö/>[ÅxƒleÇ(* &…µÂ,ø ÑCôyã™=QABA¯}~ŠeÈâ°4žpÆr‰òg$‘ õÙ 9Ñ&ÌÁüÚÓMoõ‡ˆÇ{˜¦šSîTÏ̸g/¤qûÐ~Ò1U¨™èaï÷ž h}„Y¯¶÷OÓh>¿»z8ùˆÂÂÅÒLô ‹ ØÕžØ×Étª8öÎÿ™"tÆ:k’p1ÝLtë:eL™ƒ¯fž¢Œ¡¯ÀÊÂìÁqÒW¾j4XQÆs–  f…ò~]XÆÏš¥Á+~dµ’ß�O? 02jǾ`J–ùêêÌ©c55èø$&_ž¦Cmõ6ÜžŠ#«2u#¢ö“˜šu ŠdJ[£XRK02t_0>ì¦ÿ¼%fá ¡mwU›Ÿá¸np'Å ý1“k8‚m;ždI¤¶‚1 £Övžß8QAŠxÑÖB’UÁ7à Wg[_-sR¿Œ™wÒ$Bo© ÊS²ð¯ÃúKöÄ(`嶃˜È¹“u’?nî)úö ¯�ã–3Ç“’,t³ã\ç•›kÙøÊzg$–çgÓø¦åµ4ʯgONEp‘WËPÀ�r¬{ô=u˜ç "×¢ŠCƒˆ‰µžÎY‚³íS͇Ù/ÕI"EÇ„¥‘´c!ÁÊŠÁ‚à‚°ÓMºÎ·uýü;©fNîA ’ 97n“6ÿy‹ò·Þ¢RÁ8‚ärF)È ^·zâÒú"µLào‘3ø'²’éh؛罌÷Š½¸cnFÖ±édΆÕEÕó:g©:ÐÔm·—]ª-TD- Ú=-ñÅIfÃ\•Tµ é*é‡?ù§ïþÑ)j®ú.ÈÆàœþÔ"©1öó³b3õ¢¢«a| Ç @…TÖu²µ:à•©(#˜;VÏ�)Ê4fˆÞw‡Yêtö;¤HO‹Cu똔攧€þ<íæjì=-| åÅPÎH„¾è©­Z¾2ô¦Ú»Ý]¡Àlc¥0m|Ö{z÷…µ‘œˆ Óii&AÑè„uIÔ$ú¼r¨± m{š<^/[2Œ)¨¿´kyO~Põ-¢ØäÀ}ŸAܼ»iàUûÓìF,õ°;M÷À\¾¨ÓN_ôù£½�^pp}ËaHð„þ]xòy,AÝvYD[Í"Ðø¶5ÄrÎáýHnÍÜK^ ;ÊÌcøcˆ=$À\œï“Õ&VUG‹Ûþ~qc¼•‡>„ÖÖÜÁxk´Žáh€Ã Ãyí½ !諉FÌŽEaŽ§„²ŸnÁÔÑò ¬öÓKŠPQîMoù÷loÒ{¶{c©¾ÓP1¶�¦‰)˜¸áªÜç‹¡:1´Zu¹°F§?®9öI±Ê-™K¨›mN{Ï1ò"Î_/󾾪ÛõÉm {¨<‚ið;-ëßMm“ÜÛL¯…"U±¼cÓs$÷Gx²FxéEÉ…"»ÑNì»4(ƽWÓSØýs°æÞƒ¸w嵂RbäV§çRV¨ÄŠo¼¤à/`\åZï ¥T‹>w­È ^÷M­Ñ÷9Ô NJ§ïTò]½3·Z"Ðæà¨$!�“CÍE2z+MrG~ÕéãÑpæ9± ¬‚–äZMè…ùp{vé§ýfÝYåÄb.Ç㬣rP‚Ñ$ £QDÍtjóxzã•…ÁZÏÇ4È;ulÊ£ÐÖzQÒ2f�†yyàU¬Ú’‘ˆö&õèÄïé6ZÉþ4{+ȸÜ-¶¢<ˆk-xD“MìO½ŒË^ÕzôH)ÑP§:MV*$r­°ÞEÈ”$Å6ùEºDq‹© T˜Þy¯c �óŽ5 ?Qqâ,żÜ|â8õÙ„°§ ÛRõŸ&á4ÏT-¦6ÞÖÿBŽ¨Ÿ¤WËÄ—³§Ýâ„š !.Mþ,i¯ÎQ'ñ–—û”âøÆÛ¦(–ãìuZÆíD‹\EömPZo«qçG: ×Ò…]pÉ‚´Q¨f?›®‡7³lwCX2 ø}Éêp…¢ÅQÌÙ~ô ]¢Á+«ð`_ 33àJUüuWN™U¬€öW•¦ØøTÕè’/<U»«“õèOÈR_M„¶Íò™Ñçì-sðÅ€ö—4È ÐêÃŽ+2{q«ƒŸV^¶Ï¦3ó® B‹ªÊe]¶É=wôäèÏØ#”4RßñÞ—gúçSzÜ£HßÓÑ™]Z«™E þƒíãÍ×Õ`PÚ®¿\Û–ãiíÑ/l(Xj×ÝûÆÙFb¶™ÂŸ‚Šãik-Ü$…bÔæ)w)60Š¡$Bòõõwô‡d>)ˆ¢:ü*s«¹Íú3B5²ùN•/ÚVViå÷f)gïèĶªÈ^ýæ/=r?“陵xØI0ºÍÒ’UˆÓ󿸳LÝÐJ¨ª)ŸôæÉïcOãHúÐd¥ÐY´!œ { 8Ö‹iÕ Ðw‹U{5ó)K¨6}wº TÀ…ÉMªÐÍŸàn©5\O ë9KÅ°{)â¤PÁ‡ØxTòh4¥_Û}á½ažFò¨ÎÂTø§Nbç/HÚ^.¥ñŽR¨tÑ$“ÆuΉçU1„ȧ%±¡ÊîLohÉ=À±Â„—³ì©Ÿn”†þш‰/=“ìëË[Ÿ(Oy$¡žU/ºš÷{tL ò Þ½²íýÜãÈUͯÿÖ{´6Gãt€àOkM®B3Ž‚¤jÚ‚¿¦úbß¼³ÔÕBQÛ±ŠÅ‡äo@€>m¬É-´®ÃvCDÏ ÉüÞ1åX§Ší`M™UñþRÅDXIèöÅm²²ƒ'ô92Ú´NÊ­&—È"Æ©;œÔ:´$7ûùÀšƒ ø·ó=\ ÊEÁ„·.þµzŒ)ßîƒÊ¤oS÷ðe£(ÃÉ þ†ÜwžMúIOÉŽyûå�hšJ¸ÑDÞÚyè|ü?Û® ve¾Ð¢È÷g~°cw£¾¹Þ¨p\°¢¥ÿΫ.ݨ$2ä%ºÓŸ[ç¯7Óá0ïV#ì&\Rz–ḞíQ0e½•î­0J8y.¨]µg˜ˆÔ^EVê2”\€ÙˆË F%Ì·±B¼ú†ß×ëÿ­q#ÙjJÇ6¶aRrÝŠÓ/}0zþÐñv›Óp¹š¯€?¦¾/l<—,Èj•·±p-÷ÑuÚfäK(Ü•Á*Ò¸£ž%pK;“9òWgðÍšfμò"¾†”ˆ,ªóSmp˜O+¯ïó,ˆÚÎ3®6jøžÜÁ©¿²#‘½¸W*7©F?ÌÒÙ`Î5ˆ‰®§—ÆV¶SšYMŸPð©–Ϲ÷NÌô¥¢!JVVyô,FðštÏsòͲÿÆxû�ŸÙPŸ'Ò<óX™Ìeh|TT ä™FªµÏ*ï~¥p3ôø!\)qÂúŸR¸ YÉÔ -C­QPƒÔíkDupæ?Æ„–Ä» (ÀøÚ ÝžNG­Þþ? &yæw4 Ê»Š zËP ÞOûÁÂ�I{eÓ²oË[Me?¡ßp¥›[YûižB×ÐÃØ =iDJ6§i:�9¾Ù_ʵî2ƒËÄuØÉ`©)×j=¾¥10·ZJèî@×Èú\;H‰©Y/pÌØÿkØ–¦Cë“�$A|â¯V9[\Q¢f8Ce›Êâ)nÈצ~ÌPTÙڭ沉è êUl@AVî)Êb*bX‚r=q~DšMsWº0•©’ŒŽÚB1×òñ:¤‹9¯®åOážøÚþûϬ‡ÁBv8¡£ÚwC”ÑË‘’€½ô?j%7zÔ¦[¡í£ò0Šþ2ó$Åv…óÜjÙÇlûãe¿â!å¬c´Ç˜õ] ׹V‘¬TãN´Ùc".ýÔõ7íIY‰Ã‡¡þÎ)€F¹õÌ=-ˆÇžjÙ&ÆZøjÎòãq '6g™žùZR¾è5ù–ú&&ëžÃƒ1“þÜrp~ î™Fá­SK««¿\3Šïíé‹j¥U½V G+•s÷—mTöYà ¡ƒc§žO—ú£3twõ ›®–ÔS1p©u?ϧþDÀZõ¥™Q¸¡Ú“¶w"5òínyÂþf^ýšD–¨ÿòè÷8ÐYEn·oÖüªss¬i›ÕùjZZ¸±kCçPœeÊh7Ê4¹ryhà㈕¥‘´=â¸MñïÆ•#˜\Õêa{A&h¦©ÞfA14µò þTöˆ#<îäDm¦ýz=-&$PT1øÑ}}.V;ºË›zk]{垎61!`šž'ovûNÿÁu°R¼÷åKŒ©s¦W¶&é´‰:èQz{#Ï™#û íèÎÇ‘ƒŸù'ž«TȹÊ ½L•þØ‹‹ÄižÿóÁù ûÉ6{·œc²37{íÀ!õÚ·· Xaåþ6–_bâ\ítžS 1Îiy^d¸I?ŽGœn_bä ÇÍt[O¤¼‡%7×Ð?W…uW÷<“Ò÷( ,s³¾Lß|§7˜yÊ‘‰UPÚ(ÓÀ¿^X$Ù´&ÀwÐI0Ôž óŠU€d_ÍKê«ÉZ<¢4-2g]¾>dÚ[Î\®05,¯Í-¶ߺґhp¸X ˆ“F £$Wº-ZE¥Ö°Vî4ù&`>Þ|J(­?½2sg˜^*5ÁíU¶.w­Ó-¹œÄˆ×‰ÈWíúôû© Š¯„£ÍÒvZcÕcy¹®¯Ízé¦nÕ˜æï$ù²†´¾<–,þ ÚôËÆ/÷k÷"ÍÌ¿t[¸­½x$4屫¥y65€j¶½o´¥ÏÇsêûøã;Pä()²5'm{-è[¢«Qz5'Õ9Ÿîêr½­ÊóÂe¢ð’A, ª®v:Ít×ÐÞ³§-þ{<uK‘u€-(P`^, ’ÕÕæœb ¹3ØkZ*Lž§,yþ›!t^úÎôÛH‡–ÈQ‚>nd­¢ÐFLbh£_F¤¶±RV7dA<ëç‡Iª}•hhR€G™@ä²V–¬¦D©F›·­=¶¦FSÑk•ÏËÿ¢ËTóúR¯nç-©O2c¥¨#ì/S§ø‰©.ÝíùxÐãÕÌH¶_‹´3íTÕZûS…G™'^FÇáþ+æî'Óµ“†©#Egï½½ ßN„°¤Õ†ºþ×Dx[ÔFâlcฉ÷ ­¤ýUß?3KßòP¥ÅyD0Oâ'&2Ñ®ucäQ’VyåS„F”¬¦žð!‡kÓZQVÓ;b}uÛzyÁµ5ö%x(9N$ôž_=‘‹ÃjRpûºŠ Yæ:E97×>Ê mvŽZ Wæ•Ùl5*xÍ3¨Ù½aƒæTßý¤d%ª½‘ÝRav¦ÙDĦž/ÁòÐ7ðd)câú/+3Q9Tœþ2$î!2ÎöŠ#‘"ƒÝ,äµlêÄÊÊ8±q^ÕkNÓÌ£ ÐéÏYÍÚ‘g‹:ô>k•òÙ[Eènw˜Ù TDpäv¬Ì$o%ÃÔA¬¸~£äBõ<xB=|Xy*hrõ˜+ó'kE®”͉%®^ÎÐ××;I`·f5¼ÞSóØIx‚ 7}÷ê3ΓÌ•¡2ýc¡U’ì•P—¢GÄt7ì()t|ê–Ö¡è¬N(<v­‡¤UñDüb­)‚¤õ‘1¦u`Ý=¹¹KŸ 6þz5�Åg!&•æÁ8d¡-iÎ�¶Ö¢ÿÚ¢mkéUÑQ‰:íeQœÈYD‹ˆuÓÒ{‡Ýä¡zûÎõ`E°å©ÝB–QYÅûÚ q{‰ßÇ …UdçdìfM%òª,gõ=À..Üðµ Õ„Ne:G)i¡½IÅLJõŒ�ïØfkÞA|sÛ›ã%,÷ÉHÄ2Šï·®­)¥Ayâ%È-qˆ9³I„zîlÊQ¼œ¹‚6hÁé`ÝŒ R¯¼å Ó}A;ì]åÙÒj#ô¶¥G§ÅIroïò;ªÝSP‘¬¨ÇxìœÚÅÚ^Z8þ|b„Ë‹GÇîM Õ�³ÞÈŠH 6_h]£8æ3åŠ`ð:ï­<|³e§D8¾FÏß„v@Ç Æüåÿ@¼Ñ Þn.yó-È ±ìu>l.Û„±Ñlõº‹HÔçA\¯u°Âl5öƒÇAï­§ Ž7dd„Šº?27°m6Q“†¿VT:A¡;N‡EãNðÌ·v)^õ œSÉH¾‰”™7V€Ì[¯J{®eèR])k`k,u3…l<µî]}ãÏ­¨øØ"NÎËtìêó\kJªx"¨FÁ›ÃIé2^Ö¨7¬½Ÿ]QVnU!~KÁɽv[„O¾ÔôöcïeÔ|[�#……5|m¥&Ÿ÷gÑ!µôàn÷àvbO«¸B“L®b ¥àaÈýýq—¾zFOalD£¦=ý f~MÑ Ž×aa F31zúÃÄObçŸ"vðM 7ÕµHBƒIPÊ*w„œd€~zV"L+8‹æ™‰UbÚJ+ÀwÍѹhºÍÇ‹§s#IÌÇ$(kÅöÀ°šŽmˆg›m¦Ìß¼<@3d„�mëÅÜi¬EÎ/m¢OÏH¼eŸh¦Gaqƒ¶oæä8‹­`wÅxöH:(VZ»ÃÖ$ãæ`ý‡KƒÎ>7´$ ÿÉØ$Š³K­‡LíÇN[®¸È X-Ÿ*¿Ê¬ÿnÚÐd•/.P;é»TmçûO,‰d ȵ ³Bvêkæ<È=˜³rh§Øʱ½È³ÌMQ‡Ø·÷Ÿu$‹(ͤN˜| Bˆ[éUGÿccA¥Ž6CD£ÚúÆFo¨;BÞáȆ±7¨Ø@²e¸r’´ÝßmçãQržÎ-°þ0Ê Ê8q"‘3ƒ"zl½§Å€6Öwî¿:‘ˆC4„åäÏr´ ºÒs^„„ç¡Ïé¤7K#/Kƒr~úK<Q ç]€U? 6UALÀ& ò~R(‰X¾NÓ•g]švyÂ×\ÝRŸ¨Mcs¡Úwô‘èLP0 ôÄ¥Ћ?Âֽ̻Õ˾õ‡ælêƒòÐñM³îjí€TÄ�ï ö,<ÃÐ?Ëû‡Õõ‹=U¶Â/AB‡ºª×%w ÄŽþ“–ùthKò}úêª\PdÑ–a ÒÇ‚k>ðŠeús½ÉuK?Ï“̬á²9n_]~áWVv„מýV‚P.­§™áý8Ë‹ ¿ —ð‚æ~Õ¬¿Ü´|s6l2ëÿÄ>Þó³Á©Cá:H¦Æ ‰’ðm9A­EÄà Õ×½55…òÓöîÏß¹ôÔ³¤¤yyà|æmOˆÇ-O?uÿÀåŠÎÖì|>uTóã%uâº!ÏA“$Hf ÿðjR0‘+D›Mª ·ÏD`=+Gõe Ò3êU˜ o7ÓaëÙ<UBõ-Ù7ÈC;î ç 6ÅEŸã–Á˜ømr ÅÃÓ9«! cg«uÖ§´ùMªð•£îÏáß2áSÞŒ|­ è#-m:•o2ùö“ 'wèÑáDÌ%£|PÝV£˜ÿ’¡†Pü"\­ú—Ú_ÖA-ËõHdÜSkÁ£æò 1_ÔpÏR_sà 6¨­<2ª¯Éo5ý÷–�E™Z<S.œÊ”Ê°¡sR`FMó[êžµL§®½NûÃ… eûëDåu»=ô?|K´rÃAAt,®løÑbm­£Õ§D ÛØyŸvN‘ú¨}·ÌßUÔœN[l8ŒâIßZpÚ…úøP韟Á;‰}×Hý„÷è¹ìÿÏŠ ½' ü¢»]ž:Åzî€]¶”´ Ú)ˆXš¨3uú¸À‡wÛ©Þ,þå“~ºhÅ’σ}K÷£ŸÕE‹IÖu[_SÚk„•È³ fím¶çz·Ø®BvV`I$FtíáFò£/Wô?eéƒ()2îÎT‹ôÚ¤P‡xd±|ä¡78Ég›ˆs0eƒ§/Úaam8SdëÔýÐŽþ£yš—žç$0c ö7ŠS•5™Ò`÷ÖQ>E­í ÊANíûÊ”k–0eORªa¬4;[g¶Vào€:|šáÈ5¥}ÆýyÝ%8yXJ(`+# ƒ‡ßÏxŸïÍù¨XAÒéÃv_eìß= Â¥^©$v_²îÈd¾áÓ×—}Z›ãéÏ[çJÏÂ-P§i„ ›T½‹øç`ÂàI=¦\¶Àž-ž®„õŒ1kåfy…^öMΘ»:\€í®½CËà†è­Ai×£‡øÎÐ×_†ÄþHO3{?û£óŽ\‰Ëó·G¯pÎ\“”‰‚%¸ÉØ®< =^¦üözûgž¦6Jò-mçAG"l%|ÍD‘~z実1ó¼×&}�ÓhECL(ÿ¥;4ô&E-¬øåžESÌo8­1ãÓàØ=_n¤Ž]”Ö1`ä¤êTÓG‡õÞA“lð|T£Ü Qpû§­i%Ù-†¤á<º-¡rÔT©´1òe†t×6ãÀRëlƒíï‡H«YðàÑt´‰ZÛî͹¥9xp‡f£I™‡˜;éøy—Å´wÒŠS1Ž–ËÛaOýuA§hÜë%êªmÝÅ‘é†]Oô¥°zÀE`Þ‡ ¡õ¢¥ÃßäfŒ@6µTÂÁ]T2½K™,¤¶ëñY# ŸÝ6¿3Å= ˜šF‹Â)¤Zå¬$_åÛùšµiå+X´ùâ o”9åÚÕÜ©šÿóVFÊ„ðþÍðrŠ`^êõÙa­*Th:ÓG¨7´²¶Z<“Ͻî3ï’Ò’Ù6œ ¶`” � I­a0‰Ç"2¶øe÷Çuˆ ®ûCæ³V ¤–?ÊÿÓpµL5{qYx$9àÚ‚#ôz x€.×æ:9Ή­üÁéJmmÛÖ{Í&…ÛdÞŸ è:85§ßûVÆëQ3ä)x”ÓúÃSî‹iTjúÓ—¨-|ã_Ybx®%ªGtwç8(ÛÎk‡`BO”«ƒ§9eâÙ‡±LÔx¢œ$y·Á˜Á´_ü^Ðî4 þåæuEMŽSçEÏ}•ÍŸ„6SûîÁ@L7ºòê£Úõí·£q‹ÕÈ‹Ìó§§Û'кúWÉ`˜'ÖËÑç«Ž–ÊRÜóî­¼A/Ÿó3†”ç³&ðX#§ÉËJf&Üñåþåí°v§X0—h_'AniJà‰±±qb ÄõË÷ÙJ¹š Eh[„AÚí ìãгBñï¯Ç¡±öc"¶Í¦'¼€½Yu‹'\ÀP*¾ï¢ë"Ÿ¡œüUjk•CÌÜœàc;*‚ãØñ)¯DÉíÄ*Ȫ¦hŠh›Ð~Ó҉Έ©&¾“=£_ð úì®–6©ˆÚ£RGÌî åæuMÏ•<úBñrÒ4:ecFËØ®3Òa 4†>bmÏýv¡*% QynçU'öèz2/”[t0ºˆÉþîâ¥*çoI×eœO:墶[«ÓjøBûãN?÷ÄãÙ ¸ÝÓ‡ž%[¡¼+åµtØãÀæ×þÔ=’«³ ¼Ì8Êõ]d_b"߇7eÍ ú»EëGÅ0Œ%À…&@ìÏl©¼3ˆ2]7µÃ0軿J­ß’@œ¿úEƒ.ÈÊÔþ‚„E:‚ÑýÔHWþ¯Œdm8ë`—e”¹q(û•<œ‹ªkYÛÇŒ4+ÐÌZ-ÈÛ¸ëù*Œ<ŠÌ2?A3·ª%�¿ZÏý©uÀg‡j–é‚)MÉ<yM;¿AF¹$Êô˜†î„”ü'ÅÐ$-W$ º¯"§É¯«jZµ‡/9®ÛúB•84?;ƒ`v¼‘åñ2ÛEPYŸ•’b AAãýѬEPË¿¼gÊzpkvè6 Ú�ç= ïJEÎXEܾ>µŽð@MXsŠ/YÞ¿œ¡ÖÀl¦e&¿÷µÙaìi ‹jë°2àS.D"|•PÙ.S}Þtp¨¢,Ä“ zT×Zù°Ìøk pJ+‡­»™¯%w ù™®Zàìëg´éÞ­{l`²HwÀÓy.šàºE ó£@ÖÏTµ¥{mA{^ÎÇÁ'íO˜ªRöþô­' ŒÑÃ)uÛÛ‰¸›FûJ¬ñEgÞ4êþ×vꌘ£ç\»®HÞxaÌ0Ç.A wq1xº¸jT6Í'¡¯ÎŽ¾<DêN†Õ7&[ÃnÿΩWÁè6í“ m7Cê‘eG$øßѵ}ªÙäK¹ v<e,£e|bº¶ž,˳°6ÔçerÎ;?  ÇÅêXäc«èO'Ÿb¼¢w”7AžÝôpW ìµ1A‘¯Dš)lmŽ9;t¿x¶sr3Wð2Þn±îŒ}Üy8R|LjÝÚ”Fûv¦Ô-ùÚzEP ÷%í¦_(é2@<(iÆ­¾Yûed¡ßŽ‡kíBÝsö|Í]Ïz÷Ã÷¾ÇÄS•ž_¶Ò’…a·=~ÅtgÑšÍÊ‹MxÙ¥[Ô™&mzºæ|?õ’ÙSŽ‰Äq;™Œbx„9h~]ÿDI²¬K›†l�é:ÇzâŠÌ�Ì´ÕÒçœXˆú1–Òf”¥9x/€VovÞ�ªíà0ê«89Áܽ\‘ÇŒžäò)ÚeJhó\<Eº?ZQ5'ÚïÊ8W’³À ½ ½ïGoøµÚ纕6t—»çlZÜ„”K…ø³=DÝÓæp’`+v5ALÆ$ÂjMº hÀÚs)Å}ØCÚ›ÏÚ¹Rch}5 ­|e•ƒi0ðz«Coò¦Ã̦Ý`@…ƒ! ð§ßy:!,6² Pôv…„kL¬àÿ9 ÿXû–;?zbí©Z•ñ•ƒSl ëÎ#æq/ó ë^ÿ(Âò˜ÿãáµäWô \¦Š|3lí»ŠŠØ;Ù›šRÅI$Þç‡#gÇn[=ÙÀe²VTƒëKA•¦mþ±øúÔ ·µÅ,D}dع§àÃÊ9ß+ØÔÓy,؆�÷)Ùk‚ÿŠe‰š1=Û4]ÿê>YóŒX‘à@™æAÞx4ÚåÜž¬Tè•>°¨ñÝô½,ŠX>:e8lŒA™g.F®öžüèþ›�n]¢c!±A¦ØI¥Ö›zs¨­ç†ÕÞöçþؽL]S&}TIÝ ñâS3A“À+~¶>“ÊAÕtö.}}¹³ê+—³Æɨó{<¾]Ç@eŸ< âäÎ-Üg\ev‡Â¹¦”øLåå®÷ßÅ­?3?ðÛWZ‰;ø8”sÑ A•Þ4ó/ýÐDÌ;Ûä<[zÛØ&À%ϱjå m¦ªZFWfhï\„j”(Ç%2Lw´nv(Qs’Ïý_@uË*QÉÊš¦qu¶É¤Õ°Ò.§s‹~ÌOæ‡Q•¬ŒÒ0ýcbÝäMØ›3\'xÀHä‰üKÊ}ÿ¼ˆ Õ9Êðq—¸V‘ÿ †S¿H{‘bûiõRzêíì98Œ´ ŠÏ­'#gÿ>@&m´›N£75-<ƒ«éËì"Á.§`$":ç§ÅXÜ>á/X}žˆñï´¤—?ùª ø#ý‰å³~QùÅœqþP8 ÏZ\y°Ñj&ô2ì2¯—qw#®á놊´dÆ¢YeÆ. Wo †ôþç­Ì¬½냙µý‚à˜í‹³” d°vyP´Ÿž!8¥–Ó üZ¨qú=ºe mú¸Öó½ð»H¬\êåéãó×~’0‰ËÒdÉL¼LCŠ ‰XoFMOÇþDë;.ÿÉB~¯(ƒ/™×¤ÚáÁZù&ä(X³¶o=Šg7¸îpt&É¿Õ­U©:!í"5ßfAõþnºÉ(f°©pj© Ž—E_ž`%ÊØGÓ²S0橽‚+Ëäí»’rœß(S9 °7´Zïm2ü«‰3q¾òq°«§t¾¨‘r]Æ]éäí0eQ:±Û¥»Ð/àŽäwBIšd>óÀvdvguq ΄Ӷ›1Q¯æ“_£Î W–Ìß;ùΟé¯EåP…%ç%5oÉP»Éû7Ö°4:B¼s—Ó˜ ‰òCÈax—ÚH]ï»<©= ¦eMåQÅÞ!ͼWC³W6†(ÓÒAÚÓžC[¿m®˜“b²uïGxÜQ•[ObpŠ`IÜξ—‘k»¿8Ž}y±.è)ÍÚ™ac×2[8¦Ž«Í\Ê·^€˜GQåN2nò N«ÑœÐ®Fio"™yüÒî¤ÛOm¾ûÝcaÀìF¿í1‘mlé ª$ õÔ{Êî‘#Ä£e:BèS¹˜Qmaçq?Ú’E*B)Y5ð9+¯GVÊ¢¯Ñã8 G»9÷<ç [ ¢ÏDFîoÉ]gî‚GüœEÍqö§c'žß«ö³ˆÖòw *ƒõp—ߧR‘Ç­e­#6±¨¬û0*ü¶è)Îb;Ë‚JØû+0’É—˜Ðï£GRmÏÃpX%ˆ¯ÐQxÍ3å‘Æn@}úò\¤7§a8³§k6ìªäh—¶S¬Ó í5…¬,CµþrArôåÌšŠ÷nTgÒ–×lI©rr† ,CAU_F¹¢v7SQE9o?%•Št—œÿД0bVß~�´ƒo³ •Ý.ãE[ mž¡Õ×_ƒy|ëj§nfJœWlŽçN}„Ëýj©3²À@‡.¶Êx½Úˆ“З•¤‡}ØQ0´¤Ã¨¬•^,àö fÒæeêZ3$ûó2™ñdö+ÛŠ¡Òa¸îô.­súÀRÔ^{̨ 6:8°ƒ©W ª »;_=“³Ç#0;B3nø×Âœ�\¡ÍçæR÷4 ž4¥UèiÑP4¸¢$Èßan[TúÌBcæ‹1þõnVX¸ ÊàÔñDAy¸:¼‰C˜S70 œ §úÓIÊ¥ªjez3™îxìÝjK"áÏcûéiÓ™\>îµ\á’+Üõ’+°küúÓò+4zýE1Pzj)z­¢:g»Ãw­ûmøþBtÎ !øhGR÷')h‘ï¼¢ûV(óÀj©*0Õ\CÿƒØöOý‡¥ôgú“¬URô¯¬™$Š·àg½©³Ñ‹zJóþŸÏ-å©œìڋǬŒlU‚í÷‘ù^í#s+ŸÄ‰ª[²¶·õC—+Ž3¿ KG-©*Hz7ä¸%÷7 ˆÇÎÚ‹¥tG:^z±œ¦õ”>Î#®Sàü¤0«ˆõ­âËs™óeà,Àjü«hôÖŸgg€c}p’Â74„èEaì ¹Ä ‚ŽªLå'¼*"OÖ‹[Ó -¦p¯Á²È™mºÁˆzþÿ¸ªÂµ;F_S±÷µu£}Z!0Óî\ÙaÆVîJ¸5|`ùœâS3oª„1 îÄÒ1úÞ(º:²c¾istÕÎÇ�m1'OöP§,O×:•ì¸ßN‹éÀ¦;Ñ­^û±qÈMöb­:¨ÆÊQb “} @‹¢u·’œ§sœ2÷I$RÝÍz(—x!‰•/s$û­¯úï “}³¸y`uS&a­éQ€, éÎh«ølѦ¤ “M<‰ÔçÒÚKð?ñ}NÆùš¼|÷ÐJ)Þ=‹P–û¡z†‹A¿8~P"gŠ$5S§èIŠ¦Vu Žo)ZPÚsÚü#å3Æ©cr6Fy·]ÁRâ¶Læ\™ßõȨRÊo vü±_hâAŒQaàtÏ‚Ä5jCöj®‡k[|ûÿÿîoõM»‹ š ÔÕU¥|j5l?1•‰Q2 î œ~7_± Wh¦,¶³Ÿ²‚gk':�Åíºë8àÞP&<ø¬Y;ºÓÝe=ŠaÈ �õÕ}´•…o'¤„¨Í>­‚ðkqT—óôÚ »ÐSèõe-¾‘xÎ9à häã¿žl -’¾¥~�ø[lz®&Öï¥XÏÖ‰³òRÀr®·ìûÌ:1μî;÷ž8|'ól²˜Oœ6{[ÎøÛ{Uÿ0þ-Ê̺Ýâ ûR]µ8i¤¹9]œÍà+ï\ØÇ…ïô sºšR¾ìsðŽŒÍ ò³–ÄÅ?lº¥E%tßÑå1`3ëõNyßœ‹;ÓÜA}¦Œ1§¥tõ(d¯¦0iîU!…Ô€yÄŸÖ8§ ̘U½E,jÞ7×ÚþçßÓy³¿óÉwÄÿfÝZ¸#Ú^I"(ŒbÊÓŽ@$v,Þ“˜ùÜŒçªU²2ÂñÃeôv‚GSž :O_¹t+O­ÔkA¡£ó*ÿêÜîo»nò¬5Ä¥í¥ÎD|gáÅãUhö…™ãÆ&Lq={ë‡c£­¼5|ã‘å©©ç,×b‚X÷¯çP*®Õ5Ì˺Ñx~L?Š<4zÂ%ò Åü¯S8ïÏãa0~hjÚüš{sê»ë¥|œÂ®±×Zbú_ñÅŠ²Ÿ·�¿ÞÆ®ñ'gÞÈ÷þ\¡¦¶€É‹¿loõÄÞÚèþ,¾wÍsMñÔïZ0 žÉáî_G{§:§å⎒ÿžùà*= ±\IPX­ë Éj>ô[~VT‹Â• %Ï34[¬rUÚ2i›»q?;ÜHæÿk£¸þ‰iëoºùâÈ¡ŸèÒïl(ºçõèeYË•¡þLoØÿ¶6´o÷Ù÷|ú~œa˜ãTù»–âPè:î† ƒ!ñ”Xì®îLø£¨ò„lóÄH€²®Åßz„ž¡—ñ²¸Ü©…9üîTôp�RšõbñõwnߥÇùa•°Í¶Œ‚êS÷ çC(–—"¦ =m·+û~ìN]ûxD„~yE+d:VAÖ[U¿B¨fÎ]Þ¯Á¾ãÒCݳ¢,7Âw¥ó�å5¾ø…þS1g!vŒÎ…Œ•{Á³7Ÿ¡ž¿ä´¡ÀhwgªFÂF[ÖiÄEx7¶§‹./¦õd9XÊbwÿÌR“,ª¿V¤WAŽ¼ÙµEÕUV)³î „ÿ[sr¢KTwÂSãúýBBùÉ Ð¿Ÿ÷‰'ÃÁÚ¹hôe_­×hj(Ûr"†«öÞëƨŠÝƒbôö\ƒa­`Dð7¬Þ¤ ¢ÿp Äôo^QD—.5b:pxËw«S ”|ÊCG³ãµ˜ã3òöõŽ~ê·mi½ÎQlž '§5¨{[&Ž§«h9Ú¤îXo6�-[„±U¿ñ;íÏg+­žªW.è•;8&útnÖ'ÀÉO4'Î;§ÙHkb:ͯý§o—7쓸ðƈlð ¸_^k‹(‡#»§V�Ë¡ý^Áýe©/RCŸRXá¾qeòØÓ’ …dt_ÀŠK'ð•±Id£®åá†ÇcàF©[p~DŸ%YêaYU 8¬|Pî,HqtŸ{åÞü~6ù~× ÇnöÀAÚæ*µ}ݲ»˜pÐÉÿv<ÓŽÃG?6'+Õj¤€¬"•šU{ôÝ9£“pѹ .ú¾ÒÚ�kËî!=Ç’[ðcáY ðA%ÌrnVóÔ¸‰ƒ¯ aFiáZW5`ïZð$,óNO˜žkþÖ{"©üé2äê((Z‹Ü aº„ƒß<ÌÓp=ÂÔöI(ªÚZø~G¬ë=ó•ß‘zùÓ»«ï#—,ôqȪ”G[ÅS² Ïqme¼¯ÁðäâE™ëÜš&ˆÊ5;y"Ù©m“·ëôÖmëC8óÎožß~ wuÑ᧷´;©ïj{[î•Å?!Ycw´Èˆúÿð¼×ÙZˆ\çÚ‹´¾¶'VÝyŠyÇb)ü?6æ¾Îƒdœ\S›Å gnëñ„Ÿ£‘ýÔ«§+>r>oQ$>ôíç ™{¿={°6÷¯Aq¸â0A|gJ(ïï•-žh.â‹ÀT q¿]´Ä.–ãd%jÉq§¢xS@Laƒ°v;34#RZr6,õQ.L'Â/(o'Q…G�e–]O ‰5£ yÞ »u~¼}mmT7œ¶RÌ¥²Q’éBŸ¢?ßÈS¯øâb²ïrPÔ÷³t²s’Sî|Ò›Ö½Áƒ¾Þ[©@µ£CÄ"-$__Öl'“Ü‚×ñ}Gɳ½KóKïJ:Y• Á6´É£’Ê?qï”ö±ˆÕ©eìþÚczÛv{íyxßÀÜzUf�†Ð;u*š�a…âïÉPŽº2ÝÕï}:žbi�æGºe áèD· T!Ĩ=qúåw¤æº"s™y9%ÊÇ8vöšSEÜÔ›†•´4eü²Ï Úÿ£Zêéw¡óÞ- ¸±½fÓ<æZÛMÐ’–_ƒtâ°ôâ ¯\i€[±¬·Y<xwsÆ”OuiÍ(YÇL‘ [³( ?,`bÏ0T4ðö-b–SÁØ–nPMu&òL§«ƒ 1Žÿñ™ÕRÄh׈fè@1ì²Uà7Pa%…p_Èö›Ÿrå²]!Ü÷]D;+¤‘›ÀbÁW1²€š'Ž—nEÙáâIT+L+×0ƉG‹Æ“붨X+ôdlÁè¸#ÈóŽVE˜äGÇ¢PÇõSzê‡îÎ)%¼lŠðáôél©”² Jþál™òrŽÜç¿ñè£RÿŒÌ˜Žå%±E‘þ$¬»SëmaÇÒÿ™°ïÌg*ã£M¿¨’wí°wb}¬-±]º´�¢°t'9qq¦·[“sŸ¦£Œ‹Œ)˜'Í‹C©mëÎwê¢>·ÃéÆO¾*VþBÐ-§R¤:·^Þ ç°É =MG‚-,ìä±|›•ÉMßÏ0\×_´¥ÇDe€w5ãYqÅö“b$ÅÃ?hÃãÖ¤k†¤Œ/¶w?YeîÓf^(CÝa’á]­zóQû.ªÝ·×2È>¿œù¸ºÔó»S>ßbÅöWn s51 \ß1#ãÒ[> ÞáR{Í Æ& B*hûZ¶®î~ì_”ä¼3g[ª#Äaû­‡3;Ô˜ÕÏØ|Úʆ2óJ÷¼ZIH†(!<™ÞS}¦g©¡[Xxj‹HÈKqþTx*-oDjŽû³×ø³’”*†pÄúpÞÖý]œ…S¨´û¼‹)-h= ‘0uÈ‚ÇÂ]=´(Œ8œ"-§h:Ìæ¾lNÇnCçÇüŸ·Ƴiá÷}üÂÍa´›øÅDÝ+dÓ},”«eN7=s(±< ì0,iŽG0y®|—D©oC Äã³(¦|L 3KR¿ƒƒ[ò¨4bØQÌHÞ-b¦(yyñ¬í±Jolž ÅšÎW!HÍÐ}iU6á‘赆•=zª/c©0¥)/ög°ƒ‡‹›ð ”�u´>¹qÔs´l:‡ý;@…OeªÎ8HœIzU»Ód+'&Ï°®e yÁ#Õc@¼43`ðó ßî=˜6bæ.ÌšäÏWÈ~ý `Y F�#b©Üt¸ªìZŒ–Ìl?ê\—„T‹ŽÜžòˆÔ‚HÑIë?ýéOm>&E†ÖZöb h1±Såá<ôÆäĂɘS…£¨l¶ìf?“ƒRq+í—Ž•øÌ –3çžßØŒ±ºcÖ#cùFpGU ­ÇîËëÍE|þÝfª/Œ_7¯7t嵜[Í3å<_Ÿ¾/CÒÕÝGˆŠš­¾yÁ†6®|pÊyÎM”Ÿ[Sær® ü„.þ°íT_m’¨ß<õ´É¼™3+#Îʯ>·N›K¥L¸MüMÍ?@V¿ïzüß)ÑÊÙÑìa5ïÖ<G}Ã�–5Á‘ƒiÏt=þ¢Y›¦ëfJ_;ú-¼áÔç œú‰'#ÆÇ^Æé÷öD˜¹^oš’HmÿÐgç¯ r´gÛßä$k"ÚK ØdÉ48ð¶;oeþňúÎÌÚºWZ“ Û~Y. ¤ˆ ‹!lpîÉä?Lß;:Ÿ¦ùL~™¹®ê#{\Í‘œûHCž¡òýßN§ay`ºø³ÿbèŸg!|/@]Õ%œä:€œŠ§™¶œÕ–UÐüí{¥3§¬žó£–1¦ÃÖ;ð¹ü¬Ñ½´zX;æÌ]¯ž7"ržxµ4¹/T‘;  |ì%ƒÑbÐO¾F¨¼ªEey滈GT& kÝ µú’!\ÍE´°éæý¤Ó^wù&–+lb¸c©¬ô° úû™µñ•L¢%Ûmðùl†ú"4Ž½|p®4`–r?“€ª^hDŸz~§5ñµH™Nœ;RI%zòþ¯'“u¬é$5w<Èx²g³ì x3ó¬nZ •€üN2û%í,,ü©+U¶-†lû/OsrV«Z¹ù5Û‚^¤…®Å‡ØÓÿ&Íèаfw‰q&CÉg\…¡8³âP *5€žÕ:[9ðĸ)ÓG'þ`í®ÝIâÐÔµ‡û6¤ÅʦÇèƒnýÀ+F�†Çú ÚÍm[™Œ/1ô|©f(…R%ÜHUÐ7G) «ðd—R­è- ºCO?ùTs•¦wÈôÇBúElAÚ<Ú“4ˆçÙÚçñ@QâEÆy›¯RfÚ½ºå¹³�š"dǪ½j¶Gp¼Ÿ‡ÓÅeº¯©ŒY”/³è¸_¶ô$ç³7&jD@g’3ë–‘ÉK'-`>!¦ŽÇ:À¤Jë0°ÿ AŸî쨰%6 ꆆנ))­ ý~ôÑJ€3¤Ä±/ƒbÑâ%“‘I½€“Ü:1.W•‘yÃòÐÑÃþïmùêº[…™½5-½½Õ{cª­¨=ø”u8.êüúÖ_ùq£"R 6ÁvPìg(Këãn¯¡9ïõŠòùÓà î^p…J2øyÚÔ�÷µ¹?±Îy&ôäÆëk±'± óÈ´B.ðŸiœ 2åbÏ7V£‡ÍŒÿ¤«³þnÙ£Ú`kæ;#èØù<01i^ò êt¯¥…-þ¬dÝró/¾1ÇôÍ#ƒ³†4È»ÅLA"ÆmIŽO§åÖHëÁµC ‡.|бpL)f4{7&…Ïi79ë©óÄÜ«×ÑÂÜý}ÿÁ¶£ß*+K“kº\¤7̭㎠ùªõÞwë¡KNŸz&¼é¼Jºu*γ?yöÎFëžKÏ ͼçøAçZúÙ9 /]e²˜ºØŠ3[´t£.-kwåâ}céí»(²^m–Ø—U«b+BÇ2æð‡ãÜ\íë_ÌçÔJÍJoh]—õ§§“ø§>±ŸI{Ìgß@ws+ÄFK«SÅÙFµXZ¾áîË<zÝ0Q÷`ÙA8[NÏ ó»åd®šn=;¸1Úá¥>,L<™Óº¨›»`îê!!ËäM ûÒæ¬:¬™_‚Nwß³Š„˜ è åÙÝkàú ÛrýÉ‚¢, qFh%I‹É4¯ÖÒ=Þ1¸:sÝ$1–ACá"#Ë»®¤ÎìáÅiƒs ½`NÊBJÛOGá ­úC¼„毰œ±ö@D­™mÏË ¾èR…·‚AàaBfÁœ/ù˜•‘³CQÏÍœdÐôí<T'ó_us{/ÐÚ‰žÈ`<%&ÖXKËYáG/ÉS:;¯Â°÷g:6Î>xÓ¥ñ�è©…ƒFÉ_4¸®} ú'¿ÎÝ]:#Å'O”Gt½Ç#ØjI¹ÁÒ,‹*Ò8Ë÷ïè J•Y?YÜÕlœT¡Yr–¦^0�‘xl[›[œQžºù%‹4}ä‹ÒŽ6fó¤C{ãtßœ8—6/÷i¶2Æ,yaEõÙ£þ9l–Ó¤šÿÕŠVHkZNKã¡@ÛÓ´êª}£ï~#òVPs·oÚ‡‘¢G<ØÜ'd¦ëÄwÈðš)”K•úàQæèv8 B=ɱ6uXœxj†8œîå#aÙHDT= BkUPÎvÆßÆÅÁè< Ä  oŽw�÷]c3T…œO€mm°tXÏ{ÖtWˆŠÒ§!¦ÉQZVž/áÍób9Ñ ºÜÜž'ês©Ç°âõ½@åñkÐÁD Ž'­MfŽöµd \ñSåãµÁq~µUV"½pÎÃa0T,>Y£E æûj¹ÍÞ¬±Lltš6{twž”'Êt—!»çûýõ[ü y·R ¨i©Ëèk–O3ý'Ë]¦ÓÅÔ‘¼^îºÜÖŒ¹RÉ‚MCk´bÞ,�Ho¨D ÍbAô¶?ºÄ‚2î\ÙB¸,n|(Ç<…ms)-dŒdÅn‚éJY"A/ ß|MƒÂvëYGäH‡}¹¨Jhjîµð&qL¯›ÃW‘\±?ˆdræ0Ð(,&§bß}Õм5‘ø0¹­ú[ ù4÷5¨Æ¿Ä<-Ž,nÍ9tøyÿò5"ß5KÒ1 dªÆÎÔ#ÆéZaˆßpS÷î"}ú¢e ºÑp€†nrPŸ nÌHYK¢ÎËûÖ€cu§àç¹£O<*_²´ŠL¿r";‘=oþÐGÍwï:Æ…òyÞ_Å}D¡·^S·èÓÈgxf¬—¡,UkÜö[’jèÿØ{twŽ˜b‹Án ³zleø—÷寒xuJ–à'U aWQ_ø­¯ó3ʬmÅê¾NW˸X™Úõ×,ˆ4´x&„iú8ÈjÅÇÁð@A;ðàO‰SäÔy¥.¥Cª.‚ê}ëbÁþt™»Üpº ¢Ä³“go‰^9§No›%Saw“L½G€0u¨w÷À…/Ëɨ"¸HÖšÍC hpHpÌ h{tsyâ«^ÐRîKÎL•T\7“oA³êÇîjMô@Hc(j$×Gϧw‡ãHm´Á:(­L…Ø‚þv#CKòãe—2+÷$,:ÚÿÝ.åÞflj@©ßÐ÷úÍ. øòØÚ8ñºÍìL}Ù¢›2¸æø‰ÊA×úík¹Ä K´ <ô¾õNPíÇ|ÆQ×”qǦ ©ÕëìêØQJg•¯þ/õB²Èw6 l¤½Rº;~³È³ü€¦û¤£Žõw—+=v3ÌùV£:äqf û1¡mi¥!·êëÍÉtLòÙ»žBçqxÔí÷-ýÓùø­×R•n˜‘â·m.ÐcRu— ŠX§½íÚRÍ!l{ñG$=¯uïgŠUæÀ0,f_gA2[K^ä¶ãa`'ï&Ìò“‡i¹Ž W‹ånÛO[ ô=Æ‚ã‰2Âÿ¼™Av–S}mX¡¾àeïYYäjÑÕ㋳—Œˆ¨·K·â„uWÓÜ’WÛE½ÏÂs’2ýgØ—5°dy©ƒéêc%žÛ$]£nJJ¿!¿;/ž¬<W_‚’î†éu«‹ËÔ^)ÊÔ÷-ÜMjŠ‚RÑ ÙöTŸ[zðc\—õ%6£Ý8hztŸ“•ô‹¥Ô¤T¬ÓEqéŒÙê· Îñ0ìãΤeZ–@$RýQUo=Õ.ÓÓb¼>z=è‡Y©å•a_†Hš‚d¯ù0üVù°¶<g–Sf7 ™m…mrC%cÄçZÌû‹³´¤L߯ï唑ߵgsHhŸì…͘M=0×ÌSßÆz-Ï8 ŽØ”š¦ð®ÙãÒÙjfb<ŒÐæ0Ù¶'/}÷ò›dcÌ`OÖ}À)0û5³ûÏ”„W½ Ylê&ÏúöÜÿi¤}Ë8Ez w3{­ LIÞئܵ”‹Æ=±k—¨»^»ÐâÜ)ÂhÛwç‰nóJûM¬`Ž5}: ãé<´"RxšVÝ™[ê, À™Z… æââ1¦èp(186þmb?è1д·þµ‡W#µeHé<ë}ÿ:X›Ïߟ:'@G”ºñ‘¶h¼Û[ÑšJuÓ!+¶€kkà#ƒ¢ÊœÖ¼ˆK €8EûÑúû}B¶¸v&y/àžóŸ´êÚ!qiãýJ,9å´^Ò2å<÷ìþ'ÙßQ×Mh³¢íF3£œƒrËìüéa#):Ä D~áe~¿‹ÇÃaZTÍGœ‹×ÛÙ³ßïŸe £2Ú°M¥è÷wgš™@nÅã0B&8E5„<6~Á=ä¡mqÂ"Æ‹g qVª¾R ÿ›)AV:,@—x:eÓ ^”¥Y¬XÂ=¥} rS1C}S´?ÝÕ‡—gÎƆöàf›€T{…—íÛCXÔ²§ßl.Ç¿ÑžO tÊrÍž–U6¨Á2ú̦œ„¾¾I€r’#åà)ŽŒ4’5×Úœ(ÙMêa€×M»B ¯åL+� kC\Zú¬Õ¢Áùlëf¡“1›'¨Ê UŽbEÆ~ÆwXù: <ôÓö­æ󄔧jdVš|{¹ÐCMwš¥QõKÿw˜ý69ý]ØÁ^±íD½W_Ë]”ÕÊ�–¡q«­ÈÂ1ñxÉ^˜¦ß‡Y˱g~'²vN}$†‰K9WÂrç«bþ'8‹«¢0g–½š{ŠBï³Ó<T›K“ö¢!½z‰œ°…`jh¥ìúŒþâQnÚ)tÚŠÊaQº¶,Þ¦Íy™îEéÎöòN²Å+ä åjе½ú ØjúTõðßœe‰¶îTYUpg ±f'4`6;S@½ :‹}ˆ ªÏ­gÜôçàS/�È Û]ýÃ&nÿô×c÷]›4 W8yn;RÕ{S|ºÿÞæ±ë^r–­Ú#È“vÇMãM¼1*V…BÝùîâ¦Zfã²@þ©’Ì6DG:-Ô­êyl'ª"PF+Ýt–!5“;¶^R·qH5¤#U0@d¨À'x׬YÖ:¤Ÿ=‹Š¤ÞæÖ?Rÿ’…´|@:†JI„.µNdÔIïõ§»#ßüPëØá/b+¦U„AaO½M>'߸I‚¼ †CYØ?ùeù*AË‚ÍÔŸe§¹ôÄ4‰¸ôi‚ù0½m) n‚ëi€fã€~ïʹ…g¾Ë�=Ñ#‹i5g¯ICgD«°Y�ðÆâöæ» ºj% Î|á¦Ï‚¨^L¤-«Ô×¾”{OuꄤÅëP?›ð[ëžHrK#.Φ7#H¨—žÄýQ!˸gV¶ŽÍtÒ"çAÇ"%7/Ù_JØ>Àšï¯ÓÛrm·‡þwß®`š¨9S ô(?°+lTäÝ|¤„ÅqÅ•P˜ÅÛïe~²Šgßú¿åêÁÓ­Ûìsºióäm;3ÛQßa½›—*ª€Xq—DDå_¼V]‘­\!`P–Ygùk3z±Ëý?o&VwP¨‚*_�lµK ¡Ÿ ¯ÁX^3f^ÎÚG¥¿åâ9%ܺQ²rÅȈ(¸ŽŠð¶í¦ÁyÝêùÞµ–BÏ84b7–!²O' ÎdÓ¥Þœu²þj ›…¾ýfÛkÓì1 /Ý�)þÌvZ„/î]aDâô~"qƤ¿½ê”±'ïÁ—0ß@#‹Æóêú÷�JŸ0ÇR]T©ÑŸ2.f|Ç>Á¶Ã©EÙíëª:K=Öe̺3ÜÙ—Éñ„ˆ¥†u3›b°rb0ž[ˆ9=òËŠÐk1QP<|šÚü3SÑ5/q¦¢eðM®~hüZv C ¼…ç®_)9Sȸ‚JµŸˆÉ#S2~5ÌÀüÁ9(¾å¦²ù§MjÄ-¼Lj״È]76}?Ò—ð]G;è}"߇è4| BÚ+{ïšÝn1†¼öÆGÎ^‰ ‚͔bÖcI‚±‡o¨¦Â̇„µÛNsaú˜v±–Ý�ü_'ˆ´À“‡mcªJ$bؤ ¾ÃØs ùÝ®Ž/sXÚfAhE�ÿåÌNþ ›c›W“g›}Âv Œœžðü©4QH…¹Ñ§=™®Þ—ú€Þ¾e¤Ï\ ëó»Ù'þH3zíù°-–Ÿï(‡7”¸C0vÇf¢£@nÅú;ÖäÎœ‰-íè;:k7 Y<¨`£¢¡w  |WÏ*¤h¹ÞI懣e<À{mi=Œáû¡Ñ¾§|©ïôÖÓy¸e6g+ÑTz„Lœ®¦½sÆ¥ÿ=%r=UJóKlé(RBChÈ?Ó‘ª™ÔZÇTÈñ&*Ê“f¾#ÜBà®â÷‰Yº܃‹vêÁ [ÒL×Z2Î{dÉ'ezäëlpËj^b:Wvž]á¼E»ì{^ðâ\ßS²> +ȼ¬AØü°'K3(LrÙÌô%ûºzN^9Ü{c¸jÿÕt3X7Ùæ:ù˜éY‚œ2tßçÏ3ªÅ¶,2:`ÈÌÃ`Çn_©‚¹n¹µaÎÛÑud›zîxà€_ˆôÖjþ…¨§o!gÆüÌÕcQ¨ø„CȾ&—˜g~¡>EGŸ>©59/³@Ն夆ˆ0×èÂoSãÙ Ï™±Yäƒf“Ü‹·~<€t[;ª›!™¬‚oKïÎZÌ=´%Ž=ªs(ΔÛÅ›uA“…´Ænj‰|d~jkcÖ¶¶å€ŽÞÎßÂ-Çó³°˜% ZÍ`•á7¦µ/¢h…%¸AF¤¦³ºrÚ¡¡f+.àü?äÖ2F É« Ü+t9G_Nø_Èáy®“ˆ|ŽÂiz±{m9òq¤YëžRŽè]'Üî•#Õ�SˆÁWÍø°þM„ö˜žÿyóÿÅÌ°Á|åƒs²p[—A§ž\cƒ!”†© äi'khƒ:öRƒ4u©IÄݨa¤gUÕzæ£�Ù\Ž²"¦ÓÎ4OžPp­Gƒ¸Ãä¾Kƒô]}f w©‡þ0´ÔabÚþkJty²ê¿ÄB¥*öÖ~‘…Ü”F9³ß TϨT¶Ëz+áT>µ;OŽÕÒ¥œ‚fs½)¿_¬Æ«ÐSp®ïX±ómG÷nª¯:½DŽ dJˆ¼+×8Ê3nfA{-ƒdy÷úзgr…±ÀÖî]·çÖ&-¾?Zä°J sTFó:f?IQq÷)¦¿5‚,#—&X•#¨Ÿ;'ÑG!}6ÓcÌÁaSÙvgNy.K_‰·Qå˜Ý,Ì ù<ú]ú•LÝSÎËU‹øHüN«/÷2>Œ1éíà…Úy^Ž—îjä­³ë4òÈï‰t¦>ŃnX?³$€&E°’ßgN¢Ÿ[pgá å\PD—‚!)éÝ0E“uYLO9Yß‘oŽ³˜{òn€çäaGÚzßÓbU÷vº›ça±Ž'pUYhËt;¿SÈ3äJ›¹û¢ýõŸNš'èíš_qîû“TÞåwÝËñ‘]zÏ̈´QY•M×Ö“(*³ †…WPé‹ÍduÜíæ<>„ïdŪ9§¦ç<k€Èd¼DŽ€Ý7–#ìŠÍð¤™Áýò[jám|©¦GÿÆ)Q‘gž£²è<�×,  Ú” /«ÜB‡â,f(]7—ò|u×!ÝQÓz­´[WéÒ‘¬Ëä%²+€3ž²#W×0œÝÄ% ^&nbi:& d zjVB:צëp„kí¨%â@£‚R¥òýê6±Fp‘¸¡’Qdþ(ºµúrGö9/}y/ŠÍMSðï<Ň®ß9)Pn¢Ùæ®Þ�|ÃÂíýÔÓ[/·†(åÚD²à2P€Ü¶€0Ú¸¯©äºä;6ž;ó5 Ê^±3€Ÿú„™(oz’7¬µxî²³•ø? 6{ºCW î-ÕfAy�õÌe‚i2¬_�²rbˆ¬Sr`ÔìwÐ@a×éºå¶^=ï¹Ã]{<‹üò=r`qæ”1įé€bž1¬C“в€zí/“ÂݾFf� /ëÍ÷°RÊ÷žëF_&Pm1Kat»g@Ò¢yØH-S¿ïL{}?B~èÜhâ®ê„« èUtQû²¥lO‰_d=Ý+Ë—_ñq˜¼€ò ®ø3ö}yε§]ÇmX]¾ˆ(Ê"þ[zi¼é¿i“<ô2 ˆãѾû½GwbÖ¡)dêSY±×e^ç”à÷¤Ü�öF*ðET‘!lÃÓR& cÒNšô=¥Ý”{c2;PÔ2/Qáb‹âÞ,@Õm÷niìë+k1Y¥;,ÒN w)WV52蓮¨‡Å%)Ýdå¼P­Nöæ"jƒ5ûªÉY¦URd8YÛ+}ävvóð^&Mø|ŒâT$h+mõ€è^Ǭ=ër£ÝÇXM/É}Á„/ö�ôâ'3íXÕtñ¦AM×3-Õ\]v’Üõa¤Ô!îÍ}Ä?ÈPîìÌjß-F(§Û|è�ÜF ä®ê)ÒôN—Vûå)?¾†Ã 1J7¯NÞ#_IO¥‰­‚ꬰí*r]>íz*±¼Â:–ç¶ó¼´G D:7r:]çyP”Îw;Ãì•11-*Šg¢ÕÃäE{õ½.I= $4Ð3¦äÃ9�Nµ+•Ü–»+l²¦ý‰¿raÊ6ÑFn÷ë³cªGʃJÀéÊ[7¯÷ø„$†ƒ#aì\y¹Œ;˜ìq„×ïX^•/+È–3Äæ’­zÉQîÜ N\(ÜBÛÀqÝ¿¬æO$Å‚JùþwXŠ ËæÐbkÒ4(ë‹Ó9`•àë_zÌ©**rÈ6¨®ß ÇjY‹¦p®·PeDG˜Ë³õ·gŒÖÊ «Â›î9ôŸ€ê ¬fû¯ÙC㯖VñÞé䢹2W÷ºôÎ …@àq p!gæé>•'²Éid´oæ®5?„þn Ãb-÷`Kó—¥Aøﮧ2eЧ!%Šà�m›úƒ%äâ!ñÑwšŽ3ø€/JûÇ‘9›„N•óÅcZ…({v½²>¨nÊWb³è•ÓZ©ã~róž;Ú¨¹v0“ÓSyܱàõÍŒ<šª ŠÖnÑ€Õ 5gŸº¶Å,Â]|¯ªcwÎ"_¤gž•uÌ�ßÝ-z#èïÅP˜þ·çéıøÁØÂ%J® )ñ=ûÈ[6+”Ÿ »Ë„?éa~ÿê«{*¢¯!úØ©â9u`‚™q`"/XÏõñŸÃð‘ÑgÊÓÅÿ‰GqõÓ:Ö`**ô¶Ì‚f£je5ʃkQ¢8¡!¤>j’¨a… Oƒ¶O™…àRºÑìæ¢?Ý Ñ~~&X…žƒa!šª%£tb+RIÿMÔñ·Á­¼" MßK�:{Ó Ø©boæ×UÍU,Ôø¯·ßÏŽ®¢’iK%[2X3z°‰+;5î¡2}½T n÷°´#ŸÀÒÀLGªýΑعÆ:pÁÆ9á‡éð2jâÖlV…+¹DÊ{ÿ”Aü¾õD"lþï£g1îsÏÕïoc~ÚF5w;פþõ™UN®˜ÄÍ ^Õ#ÙØÑŸ‘Rm®¦c¶d¥B9K'ö¬ŠóÂWD„_6Ò½¹V?/œ/‰XP鯥ðÒØsþù?ò‡jìÌ=š¯›šáuÆH#“ü¡`%3Ì’X‹”>{ÛšÍúšòDœúÄ^¶˜Ih¡*3r<e‹ÏvÒŠQ™éÐÀ [šÜ7, >ÈLwddz°Ù†µn³R ]ÏŽguÄ },¥ê‡ne«¤¦¯yêácÓX~GäTu:#í†g¯(ë᧓;ó~P—º [J�‰3½{š½òM kK÷¿?8Ô9‡¡ÜÈÒZ(éwì}¥–eàþjWž¬š×IÕzï“í„ÄÚ^!vßy:¹”‹·®¶økw–8c`Ty�"OÑZgê$ù°Ø¬š±þ‹¬dç² oÎÓë–˜@-HÝÿfçΑíZ†"_¯£ÀCh©(wÂu¿Ö,¿VÒÒ™™ :åÔí:Ëááb9Þæ}•IšØ²Ýù …Çm€óeO¯Ó!-~V:¡‚$QíþÊ=S¥U@Qp¸}ï‰;*sqî¦b9r™™m|Ç?ÞMµNÃxßqy}ÿò»‰Ó²a.ÝfϺ¤[ÈcM þæP;„(Kjpö|9LS}+t‘zǔŭyì=Ò8ÝÑNCǯ ˜#§¤nÜwçxgÀLÿûqßY¥´öw\~¼D~;L8s††]ŒÙõ— ß$Ô!‰VöûyØàÇÞ¸9õ3€îë¦Lšç+·riÛÅŸ­’¬®o¬ Âg‰MŽ¸[p3bdû°sRp^SÏ º±ÈòO?öÀ]ëò¡X Š,iwFÏŠ ë/ݘžl+…írŠW|+C,3úSAK{ç (²÷¾Ö.Ú?{j‡ñÊ­ ºnôv6â—éÔª/‹Q y¬¢~Ylʽr¨ÙÑAãxj¾1¨eýg½õ¤ÌÄ3Àá~kßè%¡Ü¬™ó ]T8®ý¶7Éæ¬úåôÛ¶IŪBEul£r hE¯Y…óe0Mç~/)U"•™M`E5?æÓ,U§}}¹ˆRO¤Š-}§¥ûy¿x$…VlµMnËM™#>¸æµÞv2Åq+D;ý6Nm¶ ¤×õLªJ4Sp£ègå’ié#í PohÝ…OþÌ @rÙV´¥¯®q™:§í\ì¾YMÔ5æ5ºšEØD†14í*ª?ÛÛ+mWe]z2fRò×o?%ã ’­ÅÉ߇'Cì=}¥UͺgùtņŠÚùXôÝ… ¦ ›×Î4~ø…iå[¶°teDû½7 W¸áÝnå«š·/éà®Mþhù [kõÒ`(Kç mx܈*Öý]4mTäVñ˜Õ¼Ƹ\<¦äöðÆ8v \^möeP-šÔ‰6O SqÖ²îö: (FN× ›Xsó»í(‡6ýåÚŠm£ËEØìyØÑ)¬äJÆC,pèðî¼ùÐçñÜËÀ‰y�J‡2bûe†wS×ápèþÔçþË$=§ï¬ÿÑýeéÍ÷ó4üÓ\imw¢šßµ°™ìºþïþ9†§xÉê·›msÕØ@´9ô;0ÃAO@× Õ¥á¢K>]ùÈTÁ¿]‚êq÷j55 Å|Öh­5ÿz躅ž68ª®¿“ ò$ö¸”l‡¤ª¡qsÎ <]ùÇ…Í J°ÿþù' À³æ¾÷ Ïq{xš6ÓÖF²p^<´›Õj¼?z/ÊÔ—Õ) H›ÅY] QóÏèTx@Kgu%m[³¬¸}]g¡/SNþc))À[i æÃJ9©pT´VNâøÞõG xUAÂ0÷`3pBÅ¡?j¦ ¿ Ö½¯{ø Ó󻞊SÖFƒ1Ò%…éÚAAŒº™?Õ€ÖïÏýÑ~÷c qvZ¢þÒóœ`ßxþɸ[&©AÈiùÞøÕï?yÚuÕbO\ˆ¨ºü‰X9-¶ºäô,éP°›d-á~óÝMã+KýÁ7e ôlÚ‹'[¸ÙæKç E/5Ô2×à–Ý6‹ št>{ÂÐfmZkJ{ñܸ2*pt('%›²q{½5“+ Š’"ý óYS–þ¥RŽS×gÃZúµû¯ÜzŠwO—“6F:lyª…æíE«®û³£ØÜH°|%`ù)Õ&gÛò¬ï M7pªý‘yíœL™Fiñ´£*8›”œV hb‰`=æ/ÌŸ÷¦]ÍÏýΕzg™C-Å¢mæ”ÂFoiž9òJqB2Ëv¨l‘¥¼‡Ÿq…¯SV±·Äž~Gd,tA(Ÿ62Iñ~·†×¾@”G”¨O¸•Ⱥµ°ò")eÏîçV m@:÷¥²T¯R~µ§KQÅ]øp“ÔÈÌÍü6›åEhl1Ä°éÊK“ÝÒ0ƒeÌ¥ Àû­bWw=ÝÛš *߯B‡ÿ,: æÏø8jsbîÙ=?9ÇœcÊ •éûl,#!ÖÂ~mó|¢jbéZÁ½Ç{ÿ¶b5ð_ÈJOöbÍøŠ;@5FßD÷îëê™ä©š¤šwÃEzi¶õ,ɸ4 oÜœÃp%S’JÊöº¸#ܵ»K}Ëü|Áª ™°‡CeyDV` í¼YvϽÌ#ì?Ì°ë)§×À,ˆF€6uL¹êì+Ž´KU…‡öó‡ÎêX.–׎UÞÌ•vi¿ý�‡Ã-rGxØ»üü2BÌ*;ŦNñU‘ð¢kao™‘³h{Ê ãáì ÜZiúc·ñ.¯ë·úl°6(ft¢`§€Öõ(峎÷8ú Wk=Æ| ú8"8#wýëî ºæA£½°HË£`•"¶¤Èþ¸2Û훫³•ÀˆdØa:Ï{Ѿ½S%T…;O¹§¿ƒ%qØÚB;dᾦ±'ž+ÚЎꌾß:Ã+ÖBiàNæAöY»ŽUÜò§ÑÓIdõµ1>vÜ{�/â®+¤Î&W@Ï€M]ò«U>âIË›¸¾ÏV~ì/ËYϱÁ†àk^˜rAMqmƒ>íFfóaóýæ¡¢Z¶òÏ áØ ùn —P/'åè\Ï:WßÜ5qu*X"d7tEP|}ºŽ5%©'ÎoÐê†UCÅ¿_ÏIzYúÄ3&æAnåt²"äјG”Ôµ´Û›D?Šò•$6À¿ô–jX6EøºW\¯Ƿ‰š J¾D;c‘¤<Y ùUV’y<ØQç«PÙ5*2dU¶ ouÆJOò4ÌHþƒ¬S¼4BÏá‰Ë›c ¿bi¸¶7”#¨Ihl;*•²ÏŤlº´vf7Ø[ ¤G¶—RFiæN_ÞÄ3ÊÀ|†³.‚5\ÙþåtÚö”d¾Jã°«‚¼Ó™dY™áaÁôtï)]€;²ƒÖéNÏ;Vg\¦ECße¡ð‘Õ*ZYÆq³gCÛ@}A÷ÝÈØRIè-Z9*a* ´Õû°.êŽ^ ô"ˆÖNMÅýŒMÈ+Ú¹Y½ÃLçDÙNü‡ÊD~×϶4HVÖZ¨ $Aré]–NJ:ìXƃìϬÞ$›÷±>¼ó:˜HHç¸ã;ˆÂÿÄ[%�ñ¯âMª–b6"Ù­`ó„“Ò¶S¾Ó–`bÒ³™N½OU7GÔåãÎîþ,`JYg« º‘fèñ Mju‘{±¡T0ùRœXf‡#²3=¨GÑ[¼émDþ˜5‘í¯ÍÍ “×ösAéO:  rõš>'žE™?,ÆÙïÒ²k=$4Õ[=ƒÙÇŽN[Õ›°—÷,+*ÏüÚ®Èèaþ뎼é4ºN póÂéˆMÐü`iGBfd ,ž² ™tS5{}±‘Pi‚l$?B­GN²6V¸@[g–hê]¢U¸‚>F龎Šñ£$øœÓW”ýŽìxíÜa´Ùp-6á a9-ÉVsÍØÿ»žÍä$^oØÓ"zqŠa}etC.€Ï'õÙÉñƒÂ|f†ã}ólwÿfä²Û,‹ò@g®?{j(î{q�—Xý²ˆ± �£Ð—çÆãjˆU;@”K*ü‚¢ºBafìk…º7èÂØ£ƒÇЮ@§»ì•¯ ÆÅ™j¤–Ƭಥ7Ê.¾/§ÑØT0MPR-¡õ<vu0Ý`KÁO‚í½T•¨BµÛxéÀ醚n�:û©Às¾ý`{íÛ[ø®]~•ÑîÛ·Ò^Å#™´"ÙS�8óÎ`ñøú=¡S ßídØAùN'·z|3ÃÏõ´åãŠïR+èç?ò¥S“_N;l…Ï«ËŒaó ÛW3‹_MLcËR0ònÚ�Io…>†ïu39Ž®kÝ×z©ÚæfŒÕÏtn…Ö‹<χ-ÐOlDøJ[<ŠÍ–¶Zqlûj…˜3p$ìµl3ãÿbà¡} ‹yßõt\~*³¬æ<s‚m»Šû3´XºúªŽ}â;²óÛr¡ðš×³‡Ý—ÀÒé“Ò93¿Õ‡……¸±´½ðÝ!…ée«Œa`‚Õ§7 CÁŽR]\EÂB˜¿~ÃlE”£y¨<nÏl&TWÖQŽÑ´ô¤!cvã¹òfÔÖÍ·O¨*k_ÈB¬±GýôwDc)€ÖÂÈU=E4S|M¢~òšEvµš‡tsÞ-$<çŽÊl= ^d%±G¿M„Cïý_ •¥ZBŽ~óªúšÓÕ]®Vfë÷æ¥W-›¯ÍöÐèOÌôlDÇŸgß�b…à³W^-þ¾Ðÿø°¶_¿©™­mÄfôòí± =!ø‚oö%ã½ìTï€Á:ЪûÏ[œ™à”d #&ѽ=cNy[ü©FàƒGÂÂ~¿cˆ±`ÓeÖì¥CòëË8r¿ÏN&=*Ä/«e˜ùøŽ<hh1•“×úÃ1 ý'ì …?k6½wù V˜{¦È1vÄõD«ª¬ý<d-¢Ôtr¢S–mÒ›¿;[4cdæ§m‰|d¤cç]_·ª£+n̘!š¯w;™™CÝ`¡¡µFxÿtq`ÀSßð›5]O)ù³ìÛÚD¥†(»‰²®úV\Ä ÷­÷S}8þµí„º¦Iç<øl{e-Š(”"kÌÎxåð0ÿÌr:‘j?Þ1»x:‡:m›]ñZÔK­2½2Þwç$ˆßu¼E9Ëæб€¢‡Ÿjfç±G¯áìû²‰› zW2¸T*Í!êÛz¨ú_ç…—PG‚¦Êƒä<ªN|fÌõLä–qDÇF–{ügaÖjC,ò °¢b‘`x‡¦ehÀÉLKå®o_om"é-#4K­r,ë]ßÀÀœm ìxè<‡¡Æ­:€ñOPÑOkyZ™ûÖÕ9Ì4µo E9*)WG»–A´˜2rmÞžNËOZ¡W‰îÕøÉÙs"åPOa…‚Â2ý\¶ç²ÅJZ¬¦ ˆËè±Ú–dWŸõ.¶¯ÙBì¥ÊiŠÌ÷Ñ|6K㱌yRúýŠø#°ùNk­„‘V+G£0¢ÌŠ–éÜt›=l¹y4ó½åQºö£HãôuÄíâÒx̉éDn·<аj®ø`³ø0Rm¾•õÃ{µ§"L~™ÅQÄÚŽØáp¨ÄMï™xPXüè,uê¹øHžGqæ{®ž@M¶Jêa–ÅŽ'xHˉr£1©îp3A<v€£*˜ͽ>gT(UE»/‚òósí$èÓ‘�¶NôV#ŽÜ"`ì@ß%Aµ¨žWÌ9%;Ø¿8«EvïJµcÕ˜žË §O«Ò—‚…ÖÝð#Ÿí´pEŠXt,çg­PÞŸ¡©¶{ÜËúèEP®ÉQO€iXc7%Ý$…1‹¹l1ájß½~²A }6?A;Æ¿|Ü“-coØQŠßvD[µµ-ŒW,|¨4ëÞÀEÚªx «úÆ‚6ÏÉ.gŸºÈ×õ£#T3€²•yV³Q… <õ5»u9³%äb ÆÄ1í5ÉHRÏððM‘x‘@mÇŽOŒOµUصÜò´R‡ª^HÓ¶]¯^@¯ö=£¸´xM?ÆAö>hK@[º—0ýúå±/“€PŠ9CÙ4éÊq²9°<Šoäü"i(õ2`ne4yÈÍU´âŠa4FŒÞkI¶%Ò³Yº%5ÜÑjÏ(šQÚt2´X¦ê1/x“TÔ1Y„Á0Qé}Kú²¿um×`èÚ^}sOz#Žwn»¯éÛZ…Ʋ*Þ™:…3‚XkÌ&î(W+>Qôø£÷Å•,‡?W§‘oXƒþ£…nuëqÇ¢q­f ¢Ñó$¢;Ü€òykOÊCø¥Ž\ìq¥#–_êgx!Mµë0‹Ý˜qœxÚJ}µgnÒ},TP4¹ß ƒn;¶“4ÌÔ¼ÖÒÞû7K¨0Ä2f«>ÚG³ZðÈ# ºŠüý΋Àã¾ ¦Ð£ìÁLåÝË÷Ý{û‡k \/Ê…É ðÏt¡_–ˆ‹ÔÄŽp&�îü«Í,œ]0Çr³ßÖÈwŽH‡ºÁ»Ô‰Òú{߃-DЬ…;|8YÈm‰¯=9(Þ{øWÍâ‹•º7ÂcN‡S£EÌætëŠoÝá(_ý«A(1–KŽ—G«ÎW»½q|±Ê °…eZ‘ùcwt:Iuìu—!‚.é=ÆNîi§l¸“—AÙÿëi °¡¤.S/Þ’ð;âÆÑ-z!¯<±"žé´K¤£"<>†zU  MþK»òÁº§BF6T6ãIU\:Q©>лϬ^Æ<Ëij âhq¥ÑžO4ÒÚ8²ë³„j{5cE¯ ä3\~DÖñeo/+Z–xCl…ÙÓÐ(ˆà¹šÐûß  0Ÿ¹„Í[Èà[Kf†ý¢«uè,§¤}èQŽ#ñ]¢¯ÈVÐ@Óò ¬?­²Fàl,Ð{ †‚ Ûe¬äq<ík‰º×«¾4®»E·Ë`ó¸±æ}ñ”TBÃC2>–ÿ½/…åÝÛ‘G[X]Š�2Ë3RE==3á5ë– ÊÌv[0ÝÐ$°²¡M_£‘ÎeJ³ÇP ³dåqÙTE5ÚFd(‹Ž´ùÆÔI™çù%Íϸž53ƒ®âvvœ$*Þ0Ù¼ù¯gN¹7LxLpÜ8yˆQô_|‡ÚU:µ­/¬I[·ÒŒS¿Ü¢èr©“ Ï7òµaU‚RñoÇKèñ¼wi( Në ‰í\R–ô¯É’8õFÃÿy£­à;xžÏë¡}‡žeþ¨•Žëš‚÷^iE\ÑçÅu1)i[ö ëåúÆ~+^f…ÛÛÞoJ4¦ëK•rÁ:(‘;y|mË |rqã(M)Öc›;`h´®¡EÍsg?Ù Ž›¡;Ü ¢ÄjùÙ÷*+íZ`Qm ?“ j—ÚÓ$è[«*õ·LÆ(ÍÒ*u¶¼{ˆØd3qã’î2[I”ŒÖ»½�¬¤VßXœèùPFb¥•áƒTÕ’˜œ4õV69¸Rw²qûUPúmH% »z æ°ã)ìŒÝf¹ïsñ ÷Tù>h˨Ÿu ­aŒ=ªBJÖö³œ2µ«ýZ_ÇOûYÅrÁ“v:*D XE}]ð†fháéÓ•å�N5Sh?UöÛÐ ó•@{ý=æ tß«`¹TT|.¶¡*J¼¦ŸŠ7 s\s¾_<—ÐI2¿CG+£4›ìdÓúB§ÕËSÿ8YÐöýC›ÙÉ–U RÒ†ö”º( Sð]0áÔ‹ï*I.ª°Eþû<)mˆMtÔ! Í/«'V?4eîîœá dH+¤@h­Œ° ±í,å;âб™cƒ7of ™íä•‚Ít„¢ýÏß´$êÁFn3Ÿ(­ÞU>ÊŒÔ5§"¤1üíElÇ}ã÷þÍQ§**æ û© âóÅ¡€ieÏ‹m KéñüˆN’•~YȳÑ8HÙô4’qâ<–ºWêšZ4ÌTm®Ü€@C£Ñ8S�Îíó»e:½á —|ÏN­ð<£MçÏHà.fB½©éÞIWùÇÃ&±V×ÜMƒPDÛÚd‘I¢’"¨æÄÜH í™òr¡R´)SŸhqŽÐο¾ô¡ø|eÔ™D‰‘Î3¦ò‚£ ¡j(ÅŠh&d™ï Øg,ÍW™&$Œ½ädTi÷Œ~çnË»Ê暑Ѧ$¤NƒòS ¯BF, €éGm0´œeœb. 5õêjÿcÍ¡÷O€²PžœìÏçÖ· ä.ü2N¸ÿrÜïætAûǼ]Wï(6™ŸÏÆ;‡e¢V•1<™SøÀVw’Ut¦•3¶9eþ¿úf57/*ÿ ¢w1å/ç;d,¼È¯èâÔíŽ]Zê3 ΄óÞ˜ÉnNˆ“&<,„šW´›ì‰ô§lCY¡© :Ö)Ý VPþ˜(„Uá“h)oYx°_y…½µõŸƒ«C•ôè Ð ¸÷£îš6F¤†Ÿ3°X¬íÕ!7:{üãu•³¯ñ7ÞÛ¥Q”úBk€ˆ ôéCvIeg&Í­_±µfÛG¾ñ2UòoR¹!" ¢¡Nguû¯ÅUÖ¬‰z3^àUËîtf‰løZ*|½~`‘𠇯É+¶:ê©îLÅ««ÿÚ¸†hº|+:`IóEÕ–êÊùÏ|Ð(’‹ÑñqÿhGý…Åõ°óéiæ©HÒMÞï( h}‡]„.à¥[Ì#¾îêûÑQÆ+1Š„Ö,½ãâ›èMM£eÛrÀbO?—‹iyC⟑§­ö˜&9²W >ÔAxLLC'“òsñlÞ[?88)¨ Áq¯½®%ëòp…r­‰[W(É æJÓ¸'8D„ÌÓv¨Xãp°J—Q›t¹Fil êç§Cšy(nä »UþèQ]<Õ>é0ŒZ÷_×ëe>Íå…«9ôñŸ}¯[tkjÄy–!¡?ã}ëpP›¾ùÍyD¤/ÒJ¾ñEÙÍ|r�z:¯•YŽÿ¹Å&™s?0ÂZMs1=¯¾¦;y~Û]ØÅzõ‰ÍÿHÇ~n<‹e³–-úG*xf 5ïòG²ÄF;À¶°0È øõhµ-–£úòlÈz¢øBº¹”3*0ûÊ£O¤4NT¼Õ±‹»SŠ;4~eþ…þžÊ£Íg¸[óŽ¢oÑ+9&*™ËrÑÁ6¾ç­­Œ¾Åîb—ªš+žRYlÑJýñÌhG±ZÈS-í8/W6<çܨ•/¢%Òõ$BL×Ð~yƒ:Ç„¯Ÿ”b7Ž #[΂|o…ŽéGÜgò ¿‚RˆñîêNäHR/Ge¯H&˜ÇV8^‘ÍaðßúwœòDEaŸbè©u9h¬KË›¦óg 1®éÛêU Q{ŒÔê�ò¦õ—¦ßÜݯÅKý¯lØÒÊÔm<É S;GÊô@›v só´ ¤“çGrZ™ç£Áœ×aHè3kÑ–2æ¨q[ûx:÷·8¶6¥þ½“"Ì}b$4\àÿP_}âñèœÔeÿà@_…qY>7Ùî]/A‡|)P¦ðCí!Nü0…Ð_ö{séNXÀ %Éa£RHæ´¤z…‰åÎ.@ú°›-}‰ÇÖ–B•·ÉfYé}}G@o¥¤§mÂ84Púîñ¢ÒõÇš54;h9P™l(NùÿÒqû^ÏàÚq7áÇ6sž×XéîêüïõÕ¼ÙNð&Nà²=qg^|´M¢6é°Í;ñ;Exsû SzC"ä2:Ï“ýF#âß>*‘xZU>ºû}·“Þò2!ŽßâÍ7oÍ© ˜ÉÂõr¼+Ú =,u‘ñ¾Á(Üš!0 ]E»Ø„Ÿõ=Ñ…KnÎã9î^Y ôôÿY.]w'|'¡‡‡.b7x´*‘7û"¦r2¯à-l÷`ÿîxeœ€m-ѦŠ<HºÑÕEØ CZL¶öô;~ŸZëåOJkDor4i± üÃãu«ˆVaåâ Ëöè.[ûܹ=–ì¼?u–8kGˆ´XjküMâYü1g§û¢%�ð¾<cmå«ùÆTO­ùò¸®/âÐC„ ßâÓv‘Ê›œÃ7f|âÑ'N'@u§¡¼Õû„¯å\«±_.<,,'WYdž<­ë(}°©÷`S/éÙËW­ž«µ©H(}Æl¿u<õyd6¢A õÒ|­ÝèÈÚÒ)‰i¯&AÒ|yJiÒ/DYOÅÿKíÌÔG23LÈ®­=j#Bð¶by=f½º©óÐ81-èŽéé»`UÓÈ<UØþ2ìÀ±‚~pâθ¾®é¢ùÊ°!âpJK¥Ù{jJˆŸ*Õ6]Íé¡'¹Ì&¢»Ç…Ù¢ÝBˆåîév‚#¡ËûIEV�fç«6ò³ölR(dt GOcãEí(O2Ï?ž  ¶ÀFó…¥ìT•‚L÷î­ñÔ›¨ž4C Uº/utvÚ Wó§ão5»ùñ¥»p½T±nAYŽ]”»­ê.5mó°ÌV–>{÷_Œ1?Ãbª,ìE̱6棺®ëÍF/ûëв=æMm”ùIPî3Ü¡—µt:‚ 9u¨$U݆—Ç3aæ…ZƒXÏö¢±»|¨Šm–þ€[²µë ²™4ȾZï†h[ïÔ8YŠÉñ…oî‡gD!vèm$iw[Oê½éÐÒÐ6»x9˜*׎ŠVC£¸¥Ä(46âG:{kE‘n)¿[ÞÖmìÅ’l5¡J¯nç£' ýr"*ß«‘ŽÏþœÑ°x¼;´ÝÔž gÛ»2Ù¿ïywc€'æl^[oÆlr¨=Îrr„ÔØ v¶¿$öE:ôÝX °ëÏ^»~8´º5^‚Û•Ö”ñÈB<u¿Ž I¶æ¨ªöþËTFÀnMõ¥¿"Žêûh×´1~c£í+Ljðÿ¼£ll§óD0zdvÿJdq¹¬Ä¨„V5-r?ï°XvAlT=Ú.ep[KN§‹u+k¥Â0ñc½ôMtóþù|cøX…¾ŸQŒÀ›Ò.ï¿œRËT¯ ¹3p“´ ˜ ÊkÝž§[•Á2ô›\À0ž3úÄWåWr³¥št³ñGD÷AgìyÚ°n͉eľõ]xÍy0¥&)žU+¬èòÑÖ5d]=™~f^Ê™ÈfO·£˜'—ͳ’‰&—ã$ºaßÅ1£ÿ‰c'Ú†48 Æžˆƒ†B=-‹s§ÿÅÕP§ô4yøJÞIµ04H`Ãf$ì¯5k• o¸ßOUšXÖ z¥æW~žæ‰ÏI€!äR‹çOOŠt„O·gYÂ,‹Žr'îÆÝtûR¶î™Ú—åutÖY0Çp­œžÿNùªª ÷ürÏJ8F&>ê—¦Ùiiw£Ñ3ùÖ]{©Ïæûç Ëw‚dáÞO÷àK8¹úÈÕ¹¤å*ûÎ(Mª(G}ÅÚU5vÜóòÁFˆÃ-+÷';T�(¶¦ØÔin€rÚÓ‚ok{0ÍCXõçæ³'>Å^6Ý&úCiÞVa‚�IÁ¦Yá`ÅÛ?o™®0õdjé-Là0koöŽÚ€¯Æô§&t#ÚÆÛ7}÷/P©"Å k<- kq'ûÿþ?óùaõ)7Ä…ˆ9-·%Td7ãhèOdJb)²ÌÄ£â$™KÕ_@OŠtEîA+„öN6)a¸à`uºˆyÉÞh&Þ«›Ãk}U)öþa‹Áx¬]Ø‚ÏÌ3z¡ÿ³9¥‡¯~ÌKãÐiû0q{ÀKf%Ï¿K‘úþCélN «,¿,ÕI•}™8›Øœ–Näö!Œý ©@À#m›?ÿEˆÈ·ôE¦É±Ô-·ðM˜J-<øÅçwÏE@(ûF¥íS£²\u>2x°Óºªç‹s›ÝE¥JáØRµË[âõ·04Š/…(a¹ØEâsMã\Œóv½GQ§õÅÂà+Mè÷¡Ùròô•TAjqB CtÇ£ É ÖrÃiúÙËÃi6òs¡ÿ�*5Ó»çJÑI˜Í¼ü}øʵgûGÕÂRLŸV)¼bØÎv‡ÿ‚üÆ®œ‰Xv'ÎçÑù¦mN²¾$VmÙŽ…Á=Î#íÀ~§Có¤6.îNÀ ªƒ,wPøGFdÝã c.;vt²OªôsÀH-Ï1õÔà&°F;Öî´Ì?¥Îz™FwCNǘž­Š•ÐƒjÚRnþr+˜‹¾Ítw²³tV’v‚Ã0µ†ã,ÅL/Ó8ˆÞ‰F©göÌ(8vîËûÎ3ã4š�® ÿ×î}®ÆXg€÷"à�lª˜¼eåwiY¬¾1l¨âÄ«RJÜëo›ÛvÄtÖ €mSÕb³f/dþâßgMݤž@#gNŠ ;« |7µø´k½8ìèïÆnPŸ3V) 6Ø~´ö£{Nн¥¸'YǸá ÷>V²}ÉP.6:ñ¶Ÿ» €ÂíµK•æÌÞ\®ݱP˜ÞmÕ•Z‡ç¦ß¡<Ç}"®(yl8íδöQ‰ñnd8tï¤l¼û³ù¾ß ·Kx'M£†L7iZg”w«©~_[=ò|¥cžËüÁ `^<ÐP_ŸŸƒMû‡=¯‹ìúóÃQþzc —(ˆ?3õ{¸„½Êãrf$Õ¬þqëØrϹÅfƒ†VŸÝ/´äϪS71ûáØ03ŸÚ bö®¤ÜL#IÅú}_óAÉ ï¿Qõ‹Bßr‰ÒŠº/(M·ý"l<H/\JÂd;P*u¹&оámŸüh_/f¾µ(_»è’Ý4¼ó„©æÎh¦:Äl»z³’ýÕùE+ߥ$bìXÙzГÚl F»Î ÇÖ€0dÖú(3®g?XÍåâ´æ=IÁ|÷ˆvhêNâJ^ØÙgë[jNê6t¿uøc±òf;,# ´QÜ7ÎÞ‡§*‚fšÒÈ^ü‘¿ì $Û¾»±7ÒMáaßÒ 9Ï&ZÅt¬7õ¹WÇÑW•“­gul"Æ1c•“¹–,Òa±·´œçôœ4v²�¡‘ô ’EjlÐÎÞöT.°ã†è¦¡VÏf9ñxýæ‚O½ˆ<ÜþÄÊN :çøAWõ®ô¡¨PfNÌi£³ž-eÇzÇ퉔A<&4Ó«Aq£ôm¯€Òœ Ø#íIšŸc7|Êœe¶ óyU }·Œ­™£È©,U÷ïnÛ™ÂÚâ} šÚ¿”Îç÷J<bAz;Kgð-³åõÓƆúôÎCïºÙ‡å— ¥>/ÙìmÈ—g£â9çó0 åxÌîwª߉)!R±?uПý’|aïƬßRëOX~ì»àì$ .bO'l¥äIãIŒšP‹hÜÿë ÷oö5€QôÄùùžêƃrÿ×"÷¾SÒ™sh§´ Ü-½`}Ê><±N‡a/.´(ùÞÛŸZäKâñ[d×ì˜ «&?jGE¼ÊûÇ`Y9•¹EÒ$VUŽç4´ÁºèB‘ú“lj!á˜! ýaªùq©E!ßÇƽx6±›¸ò ùÔ± ûcÔHj'=Ä×õÁ«ƒ!T¶Ñ"äËa¢C§ÚjdU¶ö#.W0åXìû¦Ê¼#Ó(Yʶpò8À³Ò! >ŒÞU²ý{EÛÔ“sb†åÐÑ Ï§½…¢g2øl;?°z÷¾{¬žá“pS$?ã)•´õ«-¹&ÆVe¢Q’ ‹^¤Xi xß|‡ Yrc…R÷@~÷ž�,ë €“3s050´9qHNËÏsõ J[än‚)à²ЬÉö¿:J¬;Šz—·Ã\oé°ØQZ¶¥”Móº=í^Ð4±„;EF¢û]gº‰± 2<OŸû5©î² oFÆç"¨úųÅÓñm^U1<QíÅMAÁ­Ð2lÎÿþ[Û3éÙüÒo¸ñŒv†êNÒ[÷•”!G üÆEø>¦ˆ¿òG%ÖP:;ì='6ö1@c؇謞!ó …<ìÌÅV£2ÊÓžnSÒ,.#Ûì¹÷:VáýE[ÑXùÝ| b¨)#o¦pj6&Š+ÖToL;ïÐ1ºé†Q9ôáAâîuÊËÌ÷匠ŸUgä<ªçŽN+¦3:ý£}Ý .ò¾ürúöwpºí@I¶Zõítm­Ç¹ðµÒ`ê†-Lˆî�! ;ƒÑÌ@â1š+Û/âo5 M®io¿˜ÑYd‚Bõ¬‹=u^ðFX ŽÂN}ïxÚ ä¡ÚJP> âvöÄ)(/â cŸÉ-ìQášÝ~r4a·ž %Vï¹?±1Ùk°î,«,—Éy@|Cg‰?˜Òí0â·¿²± *£þUsŸY§ñº`…I”´¦°²ÞöÞ%ä;æ“ØýþücºW©ÛÖl£Ú4tû÷ÞØx{úâž¿Í3Ä(Ð{%^-ÅøîÑOmX( Pk¥”~׿¶,^BJ^!#D~Þæ ÓéþS¼cÜRMŸþ#dŠV(¡cˆBm>_ìì"4û®½êΤcªï¯Ûá@gI7 ”‹!ÐsèÚÖ¾zЦ(6‚à=³Å^;ˆæÐíÐrr’s"û@!ÿÌ2íy¤jšä7ÙÉf‹üVÁžh¶õ§ír¶Úþt”¶tD=| ÿ§2®Jæc'Œ– k¼¡üþu˜Tå™f1M¡™¨hì,E0f‹Y:ÞéÈáuÅ7á4æ0rWáàÙʬ‘Eýª ·4D<¡¼QׄA¥Wü ðç2 ,9‘¥Šg¯Uo{¥âlèÎ ¼7k„¶ô°¡_HwI`t8{DãArK›áV㣢ºjï)£@0NóÒñ¿ú#ËôÚ‹c #…Ùq•5H•+/Þ$ØQ…Ø^Wœ^ú»üîð—ŽWøná/@÷K_p­M|9�æ!¯Ÿ{5Ìq7´§7{±TäçSeý¸X;îÒ­™!fAñ¥øÒl¸‚uêX¼¥´WÍ÷2§GßÓºOVwø%ôÙ?•ú ¿÷I‹9lM @õõyöíÐÉÒç ƒ¦J‚j´,îLFZuŽ‡Ó…ÑoýaF:¦ßì–3дBgÿ¯Ç¢ž*Á1¦Öã® /;nØž“�ø)Ò´5lêGmRçQh?dž±?“žå ™"Á#o “#mY&(´Ú9QÊ"zý`#Å3L`mÈ ° Xí (¬Ò*nÎ d„µ'¶ŽŠˆýÏ[d".‰J—‹´eá6÷€o{†ÃÒ+dѹݿN‘ËÐ÷ý›x™¬fàÇ–Á—¹d×üŽ;\{Ìèü Fä-Lí@|áQúÙÚSÄbs·]æ7'·öëqzäïUîögÊG·j ´ÅÑáA"!tQ£v5FJý¿Îÿjž¬7ÀÜ>mè ×BŠ=ˆÚ¶ ãK^cÇ|LYóFDåARo=¾H,^/‡oƤǒá¦L{º½ NãÍ)¬ÂKLn{{b+Uûz<ÑŠ2ÊGŽPYÁ3ÍK½2 gNÉ+jçÁ—ôýkåì$­¬€†€“g¤»ågcŽ¨B}Nžõ¶ŹŸ‚À�ò×0.§¡ô6©wžŸO€|RÐÓx,¡ýi¼Ô3ÄÔͬSÿù[Ï7qÂå’nîÏyPX«û¨àeÄ õj:ÍW·ªµÂe4ÓOÿä×®‘!c •:m!EkNíQ‘˜Üž¸ú;ŽNzx€^ñàââ.²ùSñ¬ÀÉ8<• '¦IøÐË2SÈÛid”'¾j¥ HUçµK2N)l¨z{3>ü¡Ý˜äáJïƒqº H¨S+ßÎëA±Y_+´_Î+ªÐÞ\›åTƒ+˜v¶Ý×à´´Íg¤€q×¹8Ž<ÕòšaJbv&´#ƒþÄ^åŒN³·¡ bé@ ßDq´óÜ¢6â ÝZ Ifö“añ8Uš¥º²b¥âLi뎊Gø,«©áiè–û†¾~Óm¬ƒ8BÐï;[}¹ãÃU¸æqÉ$Þ®Ô;ÍZѽçarosGpºæ ?Eó;þFʧpÊ¡ìÍI+  Š¯Éwv¦w’s8PŽžÀ¬Ÿêç@“*û'5ïe›IgÅã 3ÁÐæÀv‘ãË5i°Ež¦k}jK^מá×æÔϼâeFKV¾Þ4º™Ò¢ÈR¦“£K<4Ýd×÷O•š½ËšA ÂñÝøð‘­Úš6îîiêêxÛÐa•ÂÆQhÑq.?£@ÑŸ Ž”ÞÆáÃo NûiáŽU ë\ZÇfõ ²£…c¨C»Ö³—›Šã¶*¼ÐÍ÷‹`8QªIYÁgxÞ]¤vtIÄþ:¿í.WÚ™”6\{ùòŒ³l£Ä)@PK£yZËʹÿ0õuÛý9ü«³ìøº°ðÕ¨Xè `«¸‚¨ŠÿÞ Þk:[¸^ôÒ\è*ñæ¹#ê’8wéí÷IïUd> PAOhPiù<`ñ¦iæû‡€ÕWT½{¹EÇÇk¹ãaæÞ÷<¾OàOpOGÖLÍ´ñB…j5ê½`ý&{AíÈÞ‹èΨ>ìë Á9-ÚCàhUR†4î=•KŠw-\´…`tàlľÒÏYú“ïëÑ‚¸“ñ-«Ïw§§Óµï$jðñ8ЗóñÛ÷÷%¬iQXìäÜ´@[çš�ü—‚mÌ7˜²I¿ãw-ͨH­¡’$cý–m=?×ùÚÿ¡,y[ãQü—Žo6ÜÉöK+.Öýªä&*¦túà°»1'´•j Öóuo²}Ó^²ö*o¡?—ÂÄ¿ðž5N™â?£S BÁ:¶5;?Q"«0¸€+ˆ�pyë¯d[ÅøGV´°Ÿ.tòZÉ(«~xúuëvÿ«Æ…YšÓ!®è$ÊQÚ> Šaò¥â)tP²p[+Öm¢ŽrïÒ¿±i»^&ÊÛšV]$–“;XYû—Œ7²ÔQä: #¤ÜŠ¡W Ï)¬ZÉé‚”Dþ5 … Z)@j/¸“¢(ÍËTIbÉb8Ó ‡�Îë>Ò-.z5€øsØ,':ÄYtî?÷”¥¦¤þ#–Ã5-wS“, Ë°9ÇMže£$@Ex|¿x€ùÈb§ &‡ë2ÄP”U¨îxrG‰¡¤‹Ì÷N¬Â( f«ÒÖ—{Z¥Æï4 7ØA†­ýT2÷ ËMPÕB»¨è0iºz°ÕMÝúUâ÷ý\ ½[ÁZ‘Íà+»'°³¦ ·;:ÇçàAµv¯~K2K϶‡]äU‹aä£üɪ{pØqÛÇ^t‚Œ1C6ŽgÕª#CЕÂé§]ü¹CÅø×Ô]Ì üÞ%n¬+Ƈ© *·Ä‹è‚Öä"JڻʹDò`;ÜE¸À晉LÞ7í¹•yÅ{ˆ#™ˆðÉÐñACs!ƒq°Š´ƒÛ?êsZYlØGTÎå Bè*\Ný¶³’tñ/õ®¬Ágè'ê IoË$(÷'Ê2n!»š¤YÆÌó5v'¾>¸¤SÄ*wef¸»¯³ i.ÎKÑ‚1tþÍÁ^_Äòê®·›á‹Ôç‰g»ºF�%ä³IÔèËx½˜×¦FæÛKŠ¹¼àãyнosVÙq�@Ƹx°zÔ; (îêÙFÈ¡¶©gŠ‚q{õ ê”"(ø¿5Óóì´d#Õ”,‹GqÜvü˸ N=¤iZ%¶(6]º#«%²¡´µ2Lú©½i™=‡ÏÚúH´–“ +‚p¯ð\&î§ÚC¾§ÜöÍ‘jçmëºCTq†e³›Ô˜‰ƒŽÖ=Å ¡æCxòuç›òñKI癎\&:ST“å?oq¥ÆYtÓ/Og9zþ.oŠ³Ø×ñ Ÿ¹÷º˜@È2‘ÍêP¬õÝ¥±`ºLN!ZÞèßÁ+xÏé@þöÏ[©”Ûþd É\=ÅÅ{²×‘%½K’Liñ€BÏwÑa 4ZBSÍÔCœt74SåOÿ ?()W&ŒT3WÈ×Ôo„C&Oá×m¯FÊÐnì¾èˆÔn,ªC’á{SÛij÷ÅgóbŸA¸é N8§pvU¤;€¶'+8Á@ayhàï?y6ÄÒ[ƒýÝ}Ê1“vç…P€þ<<ù²ÅŒèoŠ°¢ò›8Bvg*à¤6="¸;ѧ8òh¯îø ¨@›a¹çœóDØŶ§<E”ñ•JÛóôo'ëœØü&*â8ó½[! Ÿv½ydkq¿£7afFþ‰4|Rá¼ÐMÏô૽®‚„(=KOŽ.t{v\Lýó¢$zês±J®gviP½«JB*ö_Bª7Ô hˆ†—E¢(vÉ>³ë©€ÉƒÐ5DPÊ]ÀV17)WµÜ+^’X¥•Dé‚Þ´¡ÛÓ´k†Œx%U ÊÄí Ë5¢Æè7í•(6FÒÃf‰4Hÿ½¨ª|f¤Žµ9aZ³‚®Ÿ‰ID•ÊÎòÄ—rÿÍú+Þ?Í£Îp³•ýy¦`‡»"/]×JÔÖ&³èã_ý`ÔêëË¡5*œ°Ž“ã$-­° òËDS#­…‹¹ïÊS½9KãØ ÀŇja·uMÑ®?J© O§VBŽu|ìe\•I‚cJ…Ðä³ Œ°,ôÃ8s«\_=\­*ø¿LŽÓ1KB'®H9+*`PoÖ@Wt’^ùM—‡VlÔÐÞsÀweà-LP(@°!þ™Ùªõy×lT bw•g#î_(É÷UPœýüXòCkäsŒß h<¯añëë›1Ÿ^ÇKܱ·Bôvö#ýŠð²ó M›3…ðKð[ºØ'X±$Üþ €ƒÁ;·ðY—•Š_'vÐæåY†ž­8PÒ!B±Lºó¡•²SA=Ž·}wž(µ¢ oÜÌð°2Š³kZÀ+Ë®³²¬“€y–Áèó“ÿTI‘³W¦»Ô@¶°Q%ª½:þð•8c\t˜/ú¾c˜ï¸Ÿû-‹„šÚÎ7b¶rïÑ�>•Ðþ˪ÚÅ:9 ’ iáÈÒΞÈ¢ùb¥xø}>pyå2úŽLeûšTà bJv;e(CF…âÏ›-[a¶ß(tǘ?ú¸x²–›‘ ÐPÙJÞ{× Ø[¼àEe­dMéG§ðO ñÏÎìÕögz!% #ü‡NÛíacìJbÓ¡å„ßy<XL—k>ÚQÕįaÕü ­O9ÕòPÏv>…¯ÈäËaÁJS?2¾ Ó“¶”&0vH»ò¤w¯ˆƒVá•Í|0‚;výu¨Ù])€þÆÓå:›¯¾Ç¶¨ÄÁ^JñõîV E:Šji¹;t„ѺÔ:S"סâÉx1®y÷Bæʹê´ÃX’>#"„ÿ ÜHn"³s™ÌiÌ¥ã^wQÎ>=/Ûrþ¥“t”V™Gƒ�cëJÑÙRZÐz§ô¦‹�yn{¸ü@\Ž–¨É¦žŽÇžñ–X'WAZ+m 5xŠ/fUüRµ=Š Z´tÀði\ìÿõAÿ9)ÊŠ‰ó‰J†~}$³*+ǽﵒNô È- Ž´ªãÏÆÚÊ{‚ŒÐg=]Ûÿ†Pm‘CF‹<N¨žŽ*¿’s>$vk2„“MùF‰ýC·üàûíŒ …»p¤Çj)îäˆ݉Ô3!ïCòYý�e˜Å–ÖY"{©ûÌ6Fv"n(e¢Fé,íïê -ó|¾+1MÊ xßyRÒÖÙOûÚ -M\cN¾ñûÊj…!ÌSÜíäé.Ý0\-%y… ×:÷›oö…öâ˜ß7³[ü§×¯YNеãSEÀ£Þ‡}ö¹#ÏF[ýóEÉö]»r sBbÈŒ3OØÖWîH»Æ^Ý_…Ç{díûÍ <êºæv-}ÊãÑÓÀŸaÙ?ô°ŽBó¿Éú£ÌM.‘-°e!‰g2mßù°jÊô·Ýp`ÜI^ïu³RçÎ+Qm<õ;÷Þ|wGŸÅŠf¾>Lj»·æÛçÁÇBï–-:ÁJnN_ ÝH —ù:Q®�ð+ÃMjçs@QºòW¬‚á‚­ \ZÈÓÉ*y^¤áÜÐÝ@ü^².*¯¡1¿Ô´Þ£nd%¦HÚ ¨ÎÁ-6:žíšcM~÷0þÇNU´K¼Ì1œ‹¿<M_x9º@0é;Ö®øñ’¢—6ߢИú^ H9hÇ2 M“’ªHJ;z Sw\4¬Òùx0iòöÜßíGVíUœ è˜ñ«ŠÚŠI@ÍËtÀ\vÃMK÷5ŸÑ¹˜uf¦#Ý©zo(î:<ÚÏBUQùt1Z°›…2*g&ßœ.Lv´ÅJ]9ôqøŽhè¸H¥5Ña/‰#pŸÊgªbµžü½’È|¯lV)ç)>/Nci#rÍãHoÏF ga¤<1ðZ âØvyF{ç£ÏýbÙS{0 ²Ê½œ{-l›g¾Æ�-¸¥0k¿Œ˜"r8’õ†°½×X)Fc”Ó_ß•1²UVͺ)Ê^‰ÕÜ5¸A:ïºw|<9I ocñìei!ÓÜjeˆùNÇÂØo—ëÀšS?Ùf|sÑÈCß•R›¦O˜ b´W‚àßnYçÍ,¡½~¹»ˆÉÏbÖÃD1Ùó“å¸Ó^-©ºé˜“e_ 1ç°—¹¢þìŒ0YîHJdkÏ7°ˆ§wõøNYGåÛ¤QY¸ÄAuV¸Uœn!ŸF›ÜúÒNඣ‘¹Ÿ,½»£[åëNCœ¾*ª¡4°TÐZISpˆúOçöUhfçËÐ[æG,ú„\´ÛTì%•²ÂwFµöSyK÷@Eya;&¡Ë‚?Ad_Ml¢¤ô;IpÛÛ§G4ÇÂo(M=�ƺA}¯OÛD!3ú2œƒ”ïúrè¹ÉõË$$Ín`óû3<Ú{¥—©P"´H©VßýPÎ/¾cö©Ò }ÿ×û#x^ç g ‚‘÷´L|,7ŒÖ?é]&Õ¹²Ít€”ŸçΩÁýäªi5H˜ÍAçǾ…¯vg Nˆ4@XUˆ¬"ÕGyŽ¨T¿(åxÃŒô¤Ý:@ »X/KËth>QdFË; ‡Ï™¦q”Pmoýš"bAeÁ/¹¤Äh;²é6ŽEà.×/6îò;6öÚ,þ<r¸5ÚݪÑ"³W’ªª®æ­‰N Ù)ƒ£‹²‚°IéXqãCU ‚n • ”ž¦»òAˆyliG,šLÏ“ò^ËT¤‘ ÃX0Z³p3~ñIZ¬&èÌûj{ªäsÙ{«ñm[OGÑ0ÿv  ä£Ä³ÑezšèÜ^¦’‘MÎÉ'y1™vé4ø±.&^6‘–h*ü„&Ü–îWÕk$K¹BA 7oãEúežøÐNF7 ”ÇÎ%F4šï»+H’àþò»Ú* ÓW8óMóêzí®›gÙÊß& ö; 4{muá|¨ÙT@è¾O“$ Uóxo:Œb8üдV\’¬õ|Z®ãÅâM.RäÔïÄ"-ÀòÞÛkʶsn–2Q0è¯êtÏsù¾³¥n H:Žƒf¦½û~¶ÚSü8Xz*HBQy~[ÎÀj:%ˆ— ,*o¶FyÕ {WRY úwv'ØË£N·,ä`ÖéÁR0©‡j¦Î)ðý„´ºFal²ÊaG¹ÈVc‘pµzÖ¹0 ¶©>nNËŠ÷�ã.0äîŒä´5d”7�D;Vo“·]?ZÚo§´f¹ò`ŒWN¤˜Ùví'ì—óíB¯~¾Ô´þ¨Â¤Lc„ÂY&(79XÜûѳvQ†^÷˜Ä–þ |ìúÊÝ´¡³q#®‹ ìë²&AFßuYæk½Âë´£òÙIΑ·´é¯l¹¯Jªý™ïZáèã»g‘`î®é…)¼yʾ¾ûJ¯/Y9ÍÒžmªB§OvMË—=Ó±¸X=Tp¸Eè;}Qú6|ªž¹*ûÒmÙ.ÞþÚ ‡™©"_"´ç¿xì¨Ì·½I ÃV¡u¿ÈmÏݨ´LhT±c`Ým>þ -6§“,pæ‚~7ÄRëÆúñ Ìò7L2 ù:v_‘?qG±®3_ÿÊò' }‘. 1oØÏÀŒ~«Å{*E¾Å/E)V„B:…!dëMô¼\ð®…æ]U“Âé"ŠÈ€X˜ŒŠ†Øœæ+厧� ´YÇî“Ôªþ±X ŬþíV4{©é¿|{?Ñ1§Eãð“!@„b9ó@E”€ŸzJ=Æ/»}¸\f>aïx´�±iÖ/÷)™�qÉ9!ÙߌJ«Ô|IÑò{)¶ß( ÑS`±‹+Êb1\µ¡ó¨Œ##IJ٦pJ={ªu~<t=4:ˆ;Otº=œõGÌܲîWŠ(ˆv³¹ï*Ÿºöm¸#[¢›Ë‘¿{J`•/¬®KßåAhdQ@tc…ÝtJÉ’K_äCV™ßÕŪœó l@î‚˵™çRò»üÖÜÃÝÊ8�T®eTÿw›ÓZiêTûf¤@Òêù«ÝJ÷Bbf‡Ó.ŽYx̹ùP¨ÿè&ü+ñWW*ZÂa l­ðPÜû-³Ú¢¯ØÛ3µò&í¼û<¨ö;ëÒ*àô#³Šý ¡è8³ZPÂ/¤ÝÏêÖ™tñjäƹA/Oõµüôõ‰mB˜ºaKO6E汢ѹØšæd‡†âA!LMûD:ù—ÐÌîú>§ç{Ù¹ò2Õ:þËLû–òšö<½¡y°?õWf$jÃ…-¢D¿ýÀ³UÌ6®Aæ% SJ¾—Ùx’ø®Þ®­Œoú†4´ý2HÛÞË5;Ç}ù=Aÿc¿,}oH\èy·'uÀ]ÇN‚ƒÕ+£ƒ­ó¿ ꨖ•Ó1–n¼úe˜”–´–µað@r]&ççê¿’÷(Vš´ðØçôtºÉsÛm:AËÝdw%´žõ÷Ü* ¿¿éÓ èÔ« µ6ÝE*nV01ýëÇv”y bʽOv¥±# iÕ k^k#ýhESTþ§†ˆ ,3ÞÕLfÅgEK¤ßå¶Iä ®d Ötú'Sg€´ <'kó·¼"Z«¸_afPTÏ‚p¸:ÜÎö0Ym|ºŸˆ@úzÏ9PQfA,JiaX{Â#ó͇§âûš]mU8½ïPLÐ7ayÝÈ + (H7Y15 ¼v†WŠRí ÐÂÍ´ÉúçÄÆ̽©!~`QÕ} ÷|Ô$©/»èˆrÈaÙàt còl×Ç®×efnÕmCGeÐûäeÒÚüÿǪ9ôÚYR=^èävf‡eƧPLðÎUF‚‹í_ ªõaž]C¶ÚJ:‡PÕ`YK™í@BÿíϹ{*€¥™³HÐ%>}ª¿Œ®ÄÞžÎí¤øîöÐB"Á¼ü(ePx ¶¬¿ÿ‚ÅÀ§çn´0HE50jJê/ûú þêPUÊÓ?­12†“´'JxÛݾ2ßØ [IFe¾2©Cà¤{1É>FõKŸBÖ¥¾Ú>Ê !ÓwŸàÝæB‰Å¤55\t£×°d'6¶å‡k.w‚==Ԭɔ®Òf(‚¸k\ÿF²€Åȧu˜ïÈ×õÀËž(‘8ãTbáÖ_´„!.}hâîC„w±ëA|šÕ€u :ÅJ© Žu#³ÍfƒfúÜ9¦Ä«>IÖŽøÐhʇ_Z]Š2Ko=­¤üÏâò´ŸÌ µž±‹ó zÇ`B€øæâôWv»±“"ÁóŒƒí•îÚ<Ú&bÄ0lªÚÁ#rîd/÷q™”íê×’E‡Š/OTA†ÉFn¤$â"”´—[·Q´RÌ-ƒ[¬¶%x Õ¬}úO:uWc¦#ý/iÔÐ)˜ï¡ïc'œ+ðî¡£s.^jOh‘çÐîˆ3M#í¤Ëw;鹞rÊ�©Ð,öÖh*øo{`) xrÉOù�˜À!À0‰ÎpáñÛ>±µ]ÊŒ©ï°Ãh¶¾øºO”35Î: ‚¿‹´$Ì…Ü! d XõÍ'ÖÊéyIƒÔ–Àn3zöð´ !Ê»;¡ªXæB�嘗œ8F¼AÅ1÷Ïð†n˜†kû´z%i¿+=ù=Bzv³ô )éíõÝ3ŸŒÂ⊅žq#ŠÄUô�çÒìoZ^Naú—Â_‘.“ƒfä•ëG�K‚fS”Ó§bõt ð±m- ¡3Kˆ\}‡•Âçáý#ÆbôRUDbZ6ƒvú¸/Äñ4ŽR¶‚ghˆ…¸kêje/Ù\™Wî$ˆÂÌ“C¢:NqPõV;¬’18EÁöÜós`€®(ˆtÐÊ­L3ïH óœ½�âúÓõ‡°ÍJÈü—F�n¸)D+Ú[#é´¶Ð\àëaªBÌœ‡ñÐÀªò¡×ßy§ZÄò±”ïô­ø¼ßzå£èr+…«álD2:&a­úYßÚ[Eéo¸BeÎU\û’+¼"†³…Š¡Ñjì‹Œ«¨,“2²É ,Ýá!6 ÷ä¶!º u\EX jÊ3-tuCZ d^¥w”n"Gì$S~zò¸‡Á–e†âyëå3ÊO…½$MüƒýÓ¶˜ŸªM3wuçuŧ@ýòghÆ:  a€ áû`2 âÇóq´¢`PÆG « øMK0OÖ�ap‰öAÑ*þdc'L>±ŽJdŽoÞ?Ù ×ËŒˆnd;׃i†‘ÎæxÐ0«|Ÿ¤Ó+Ôka* åöÕ@ˆÈKF1° ªER.Ó-çþ0ºn8 <Dú¹Ùî°#ôŽ´Ñ’}çfIœÜÀ´Ï‚£z‰Æ?åöÕž‘ÎýG$2gð(÷çÀ…§üy®[œº€lclÓP0§ÀÇí‘ôÕ‹õ. =¯&:ÞÁI´WZDkxÀѼ?-÷å°â*³l`ƒ—bJݶg-ìaw~e�Ž¡Üâ óHS(JŠ"[‰† Cä»^i†¬I1 œŠððy~Ò?¼KÖõæ™ô)ÐÐ#¤;¼U.#Ø¢ù¤9ç‚®Lžúá:±AUì댭­ëp>‰ É[™Øo™õõ˜#W9/c, Q½«Œ+‹h ùÝ|ŠyµÙŠ# <w„Œµ—]:À×Ýø;•ëAfÐbÀûÐb¯–ÎS7œYë†êC|än¶½È±vîÐó3ÏœÜ8‘ÇÖ¾¶»ìÛ¾þ·ë¹üÏƾÕj  tó%úC»h´V†ß3‚¤e“/K,ôîÜKM™,·]4ÈmQ¤®)B€HŒX©-BGïEN“8“ß¿äÞ_¶6ÚÚli¯!bæ(Pó¢;ôv}ãÙ! XÛíü&ÊU#5Q¶Ý¶õÛ|Ã7üîý}ïÌG|ἇ1OeAóà¨õõQ·4Oyòr¥îÅæåtDnO[úH‹øìГ¯[–gë-È÷ÁCíâˆ1^Q¸‡ìbéF&Ìg\.”ó{¤¦õ¿©r ˜T+—È¢ ×Àå9‰l¬ðܹÑûˆVÝEOë׶‘=8Œ,ƒá!”ÓìaöõÅ W°#ñÓ§¯«]°èë’ÒîÔ¨Æ*~&™¡»À÷@ñ>ÿ”4"ÅÅ'ÄÃáuí'9øeq@ŸyD^‘½àŠÍ pnµ,Ò$¯2ë`KùêØQÑíV1øä¹­ÏK-ìwñ´¦ÎŸ«ŠŒ‰ ó`�MdäbîÐ^ûÑw¶‚Þ?E0sÝC´î|J Ö¦…1a„$HæÛKƒY[ψC¯®Gër¢ºf¯|‹ùЛ|Ìä¤Ie¢ƒ¥ÊÞ3eÇ–0÷°×qûÊÀôD–Kº²Â Ì~Åf¶ -È­kìŇ³ÂWª©~iAÅRVcUðû¶3dK`ªMJ¡ßwL»ÈoÜÏ”{§“F{ðÃÌ#UíúÙ&ÌB¯�¥û¯ ^ „à ‹…(] J³i+ý}|¤Bª•IÁ˜°¾«¤�´°[ìyöÙÙ©öå«œÕÌfˆ…YРqlä¥]¿nŒÞe=™j¥•}ÈâŠI¾W÷´$èöNåêÙl$o¸ÇÍ[Ù‘# UO TFGðσ‘!aß¿zŠôÍ¡dAŸ ’ ¡Ý*‹áø¯Ô3¢ÿ)ÜŽåyQ_G0Ã[ü_Y_(~yó—@´üÿ9 ÿl!‡9Ïw~âù†¥BÖT ÒF›s°[f#ŸæÆi@ûA±i{úШ@nºKé iÄ™Bô×âE±[ÎáVŠ{–/ÖhDn\¹+ŠÅïÞðTDç7R§ ?Aƒû¸= ©yB²ˆ½)÷É)L‚Êݦ¡Gt5X€¿j†×_ÇÇÉŸõ?º‘”,ô_¾®.å ‚¢U ÊR3ñR_ ÖÇWT)=–XÌaîTõäE+fm0ÕÄŒ?¡œ €þW†ëÉÊRžÔx¢ÔµÕŠ¹àø¼Ò’þQe¸ Hp*X 7#¹W:¶XùÓʯc•Qà¥Òàr‘²V¦‰Þ46mG+ÅËŒ„²Ö¿Ù¡?6Ý{BGHVT hžÒ! Ô¬ †®aq¿-ð˜¾B[&ú¸Y½x,ѱxˆ´Ã ¥9B6í2 <z¹tG€ûö¯ò"ó”B@ØQ˜]Uë.ƒ¯Íµ^´ƒÂäËUõ«oôõûLÆ•ù*´±;ºøîã¡7usMúùô ‘©ÛWð«×Ô›dÅ£Gu,‚¨öìTš«èOVDyíöâ9ë=Γ8³  ʬ³m¯–¢oäU’¿ö»Š*“ˆã)˜µMñTÏ#Öà‘w1“xÀ¤Js_K•ýÅÐn”»“°cÈñxr]T Ñ‚Í}c¾mqî}äÖÃ! •j[÷šÎÇÿÚÖÇ·<¶.«†-‚3Ê>=ú&•Á¢¬‡'%(Pñá|èI;ZI]Thv†AåœJbwKR7¨xÞîŒþ'ÉV¦p¯¾D€xo-ðnÃåÙÑwˆ2ÉêQŸwÌmMeá³m÷ü²£8Îx6îÆu†@peÇØ_æïÃäWmæÔpDuk ì!ŸþõàQ؆¶¸õÏʼntOpËêm =ÆlœÎãáì<AiÒiÆýÞ<ü…Ѹ"ÒsÓ7£9Âú_;€á‚ʽ똒H»Ó^=„…è0CY:î!Unú17d6S=x€_qÝò¿Þ �Y呲x¾;C²Ã.rŒ§^$#m¯“eV×÷/ï³ óüÆ@ …=‚‚iÀ*EIŽÎ;~Y½™¿d  TSê-5‹ †<÷AÉptdÒ­?‚VMs¥å@“ÞXn÷ú;_o9T^¶ÔR{ºLÝ»{Àg[²ªÇVŒ&ÍÌEõûK›ž@úŽ'l ›ÿ ÷½"¤ orGÁªZpàI\âLÁÙïšQ½^�Þu-+«ß‘]´m†UÁ§…åEUÐÜ2Îâ2ð7™ÏÒD7WgC�º 8TÇþÌí8ƒ9› ¿ëù 7uìg™oÍ5Iéyk Û? ÿäxèOÝd‰—Îý�‹çˆøê^j<X”,õpðIAÕZºÈÙñ¦^LnR¼×Äi#µ¯Çƒ`¶Ý¼Ðêk×+DtbÛtyc *|MF#VD©èxÿÙA:ïÜ4ns{#É¿æt“¦CÓ8»ÇÕýwË^±%Ý&ýã)-93­ëÞ2£Q“S0• D”anmµanzåN°Pà83˜º©Åj"½¤ëK§.(úz¼;Äe›TßÔ*ÂÔ/ÍèÑ\!¼ŸXá}$†ÎÈÎ ÑüeºvÆfêÁÁè[>–˜îÞB÷3Ù"$!%ú <šF4î&ñU¿çÃií‰äÎ5½]òn%NcÖÀï¡7©úØ̽±?ï‡2,V~Œó*¶% ùÙÓ Ÿ‚ƒç7è;¾4‹‰DJϱ“�ÙbÙ:áå8$;•¡ÓñØm†»<±â·ãÐÐKš=ÄÕñ½>·S}F†hÚg},—«k€>r<ùLè Ä¥8¸œXûçÿMô?•×uàÄPÉbҙ儈nõ([mÐÆó˜Ü`µrMË2¿x4â ñ‹ƒqNu+ÔanŠH·ŽÂ€we@sþˆôv^ª¢¾˜+D‚!¢¿·N/A ÉgUõ[‹¥¼¢b}›ÔàçÔÓ3 ^ÆpZ`ú2;83—_¸‰`b욌óÏ­§1½§³‹¢“=‡|¾x¸› óüYm:[!Õ`N�€ÃtõXõXÇûúj)coÌ‚4t>þhÊ™+ƒxÖ¸9%A2i©‚_@ÑÌU¥t_€mQÖ¨÷Å»´ÕbûÕUXPÂCÅâbî«œû×Ü¿wËæÄÓ)6U•Oxÿ‡}ä:Ÿ)Yäã­Ž¿"°üÎ7œ¹?¦Äú;5´¢raZ6àH~T™ž, NOšoÂÜ÷%º­6 7Q:]M‹7$!¼ˆ;¥üá–wï¿úB<J°.t°L“ŽW¤ç~Õ€F žÌÿSá±1"GŠÝ›)v}Äø^KfÑJµµ ¦c”Ã@*<ÖçS­"n/ˆ¹%‘c×T2d£ã,²ñ-Ú–oª�¤W«]ƒ0hAx¥¿Ãê3Mù÷›qhêëNDbsãó¬@Ñ®%\©=è¾;^¼Ûœ)—™27*™bsÓˆnë’BáÙ#0\?Éê+‚h¥šfo¾R ¼«=¦+8-Ñ" Ê~kΨ778·OôÑh‘šTër:6³®§«d{ñ]t6±b˜(–Īƒ*ʳ’Ü‘d¿Ÿ›|±€”¬$mKºmúÚ'á*ûÏêþF|QÁèÙÌ:˜qw½þòŒ÷€Ö ŸŸ1³B –„Ùe� —mkà@"^$a+Ùeòº6ıZY e<ÑÂÉ—‹gÓJÛo'Œ-V-Å}]!³0Íœº)Å…fOë£jÔKÝûÄf§™u©YO˜zl“½¸ av?qÚ̃ͥ ²]ëÉàaüpà*Ðt'ùôöˆ½ú#¹Èµîý~w%m„³—/Me(H\mú#Òf�>M½dUösgœ.c *±Ò¶8Xj—µ*£ª®jL˜N×»¡¶Ïõ¿•wÜÔÀÁ:ÊÏŠÉ"úÒÄ€0¼6697¼Dn½QI¿q�ópeì—0A5Ùê0Ï;Æ|b1ŽÅÆ8CÈ©æîóǾùŽÇ7έ¤0 zÍVar!Û©gP†À€ÔùÁȉÅV&Cc¨°n³”ìà~lã_v†ì@߶†¦Éùâô§¾6Ïþ¢,ŸßùU+“?°I pñ98}KÛœptFï „`wÀä9i`Ù–àæRÖ=øªñn'hý7£-dÏÌú@ܶϓ1ƒÈ“ÔìῈ@æa"b±©.‡³—ûíë­qüdM­˜,tÒ2îZœ°/;'mYcÏÞ ¦›¶p_y…Àz€‰’<óåèQŒ÷[çjªÇŽIîä\÷³/ Ba ˜ î‹ ·XÙˆU˜OÇÚö&æzÃcÐ0dnê?}÷ùŸØø”E~"ÎQ€C²ôâ=gw©’éÛRSɆÞ?¢ÎóŸ€Ï’ùÕð1<ÆIÏêcXÕÜŒ‚oŽ¥óÂœ 9Ž+G÷ƒ¯Qáhx*v½®˜[óˆ³PZžÄ e–|¿¸/bš{:‰™œw´*{Ûj/€ŒÛ8Ù¤_' ¦{M¬û2H—«Ò×KôÓèV@ôÎÕ&7^lÏ¿½çÉVy•„»¯")6u¨n0’´�QÌû`é»Á˜ ØüQË«Õ; H+ìp=ªÉnªg_Clª3kÃÙ‹µ]¯\^Ã,8vEä¤Á´Ôî¤ÌÞ×pļê ôõE?Vüʨâf¹AÆÜ7Šµ ¤Ú<MÇ éÔx½ÆUÛÑiÃIÛ1§"‡"W< Và•ÿ‘5«nÓù¡¸t\!°^.ø´þ²,ÖhÕˆ þ¦óÈÉô…"M·Ù¿\kDIèf58n(yO)7õ´/pèÍÄk:o_JÚc«„âñÇ«;íì#O’'óæŒÜ~–w¹™x¨ä–¡‡¤¥Ø}UAn1&qiÝíTòp¬,DéŒ)ïüèžÚ}Q®î™aÜ¯,s,%Œ2`w6f¶é†EçÎÑ…–úêD~—»¨ÛaTiYŽiNÙiÏÚP¹$þxJL4Ê9z`†—ì�/Ì9ÎÑNåÝ(6X„3 ´J ò)5t¾–`õKG@秫ãF(e­²”)ë·ÜTJõǾ“W}5'ƒ=Üô4y3Õ8õ:³®×¼TJ‡÷•èH ôó_]I%ƒx¹Ud’ldI&ü‹~ÔÖ.º0~¥RÅugn`º¾¿*Õ¬#-k-‡<"ƒ¼Uܘó+Ȭ@é­hù<Ž¦q‘¹A&ÕcOÇLü¹óFë0¿àŽŸZ”LŒ§ZyõTs«ÈA‹Tš‚�—cV35žRW'0&¡¾ žUÜ B·=ªƒ6dg´“,z«­a¹@‘ùC»­Æp©f#þK÷4ÙÊm«DzTãäYj ¬ðxÆõ2íÇýKëý—g7&ÜÌZâ´ÒMÈ©Mdˆl§e‡é®¿ûŸ;ê)9‘… YñJ«ÛÐqÚÀ4�¡RùV¬Úi^ŒZÊjv;K|ÕK7:ø ú5š»1À’'È£ºÿÞQåºç ZeYx#5QÙhÉ©VHcÝòÂFããÃCщÔ&±>ªí,3�¸º§tæi¨ú}°Êü XÓš=“ªˆ°š^ßoO§ÅÆÂ_ˆ•å¡/¤)“ˆ4H·£çmAUBgóäe?Õ#-¾I—õe×Ë´ôi�Ìã¢Â%ú¬Ý”•%|,†„îw²ô•5#V¢Í¦3ÍßÐ`š[­oTTHøªÉÝ~â>Æ”F¥±kÄ°gIÄïzÖUáÛ?o•QÐIåÌ¡›Än‹?Öíš›·iŸånçX#f?‹‰‚iŠŒyùÁÇþ3ºxNò êZO…ñXÃkE25îÑÏjíúÒYçËócq—¡²Y[“,‘!¿b­j¾>ÁÙÆ¡àTàå€|,ÿu³DV<åòƒ{ÑP\ÿDX'&úÞQ\½%ÄTŽ"—#Eßé÷´kƒwowÜ›çÞÚñ`Lןù'eæY#|QöšÏ_^H8‡†·53¤§Q+|—!Ú’¬¹Î‹Â<óPÜD©ÿ+Õm+T.žŠè¹ôm£q=cÁÑ‘;.ÿÇ‚!JW0X   Ÿ|z¢ s_·á£"RÒ—WA»öàV›Ñ¦ £bì¬MfÀbS:¬?ôCÇzÕK}R ½øf£ýeñÒI)‚:S›ú~Z™P ²gÊ $³ãb5oqñhisƒˆ™Ö!”âã ¾<=æ~an§^O D .wQ»‰3GïÒ”ã^ƒ1>¡CH} n+m µÐ¸7½7š\yqèð/¬‹;_w½×›}ˆéÈËâû ÛÖ£Ð'ê׌”kwús蟩±ù RÆ^ÝV‡j=²g#lG•:Y}ä§LÒ$½=O+½IÓ j”ž|:7†;ù"¤Ä8HÁ’cé¾ö@õÍIƬªúx¿îÛ׈±ŠõZ0íÇŽÁÒISAÓšÙ•£®qåÓoN¢”n¢_–ºÊ\¢þ\Ñ»ª:r¢%Ï°&°Íùßa‰öí?ÃBªÐw§Fò+žEVk¦þòDhz•ÖH!4=õK •bö·õaº@þ ¨™;YšÙ±Mhy¼ÂŸ®2§ãÊ„¶¶£ûà ]ã\¾±ÿ{¥‰—–Î ï}çËêêÖ`ð9½«>,½Ë¡î-éÿ¥e•3#æFaߥžW4à*´Ñ`åäfDûüÊk‹–;È›ÐzT5¯ˆ[[÷ä”ù¥i•“biÒ$È쇅»× Ì™ÃpÜya6)=¸[ÑÚ-˜‚ê ·h¹XDÄÿ¾}Ô”*_­òöLÛ]~˜•Áÿ¶À°'“†ì$²MÊ ^zß­û:ÔVt´kÛúL‡Ì°\éàhÛ—©ö¬²íèXÒ9Ey][xpˆ¾i2PRÅCÎA% ð2ºsNLáî^*™uDív-ÞA Ó†]÷MßëA^Ñ“qŸ‰XÍ@±·UàÕé5ešmm~EôßÕŽ÷Žu©-©»UVä37µêõDyd:è©’ò©Rƒè$‘ßœ-Óé¾ø’ª©†õHõZ[¡æ¸÷-Ÿ{¢†h3Çátá<l•;–Ef¶±Òû©ÇÝ®H€lǸ6õ†ƒª(³Yó‡ïÌ7C'°M¨ì@";­_z톫ü˜´œÅ+5ž´Í‚>³º’gjñÝtÝfÿFk¤ï ! ï–ÄyïgˆVYSZƒ_šâ ­"hÄ æíVV>—4­¿{žÖ šÐ~οôÏc!ONÓ§ÃĶ`@¢s¾òÁ”߃J”¶š­õz«Õ¢þx½1‹c>²û(ÖÀÏ$ØOÐFØ›ÔZkô„¾`àPÛü„ zg__؉a·/v JÉÆw=¥s­yl.œdgdGãÔ M`E¬3¸%–GÿSè­HDEë¶ ÊO«ÙQ$ÅlŒÿ•4Ó‚àf^hñIã¯×s=^ù´³© ±<é.ss‰¹&8dö2Ž_èÍÏ{ˆIâfJ);©Âov÷e¤_!`Øõòaõ96&›z±¬}è”Pw1‹aÙ™k-ï¯-Ï, 3Ìš»ú:©Ö<l‘Å‚º¶ÂÓóy®<г*õžIüùgpÊMåùI¡¡€æÈ:C·&3G g˜ÔÖ1à‡ú,úŸÌŸº–¸ïã‰n|¼¿8*9Õß;”¿1ù–KFqXyLº¸“º-ÄP¯àHkfÐV“'õh…•æeušÌµô%n_ïãÕÞ¸n'ÃÛÎóyâ·—¼õ àñÓ¾ûg>õÒιý z¿§¬3•Š”nÈ.ìþ¶(E§ÁTõ|èEÅóöŸŒ?eÂ5Fá¬ýt:Ö,ç)ª\‡Ú˜z=„EªŽ¨ü Q˜ wël'âOˆ¸'çë>Ë«^g7—z¦,ˆ-b$OÕmËê8Sõi"Ú+ÀóõGÙÝ&ú­5A±¢P3-<6$ºk@ójZY…>:ž²¨ŽŽÆ¸›mŠÈ(¹Íž»6œ¨œj±_y¥„‰bA�w§¾¢ß+:„ñ•Æ‘ÆNù_PâK”K/± 6qPÔW.[ï&?w(š0ävž H3áŠ7¹¨¨)Z­ž¢¼èAÜV¸hÂRpUÖÞý!6Tâ„Dø,œëÂŽO[ø¡\‡€ÑÞ "Ò[ƒïYvè:Ÿ{zgJ"»òwé‘*£͆æ1KfDf¾IEp\ù¹.õ"-‘çnæx¨¥ÑnÌÍLeYÜ_ˆ®è¹6³ íö®Éó2çí†_òÄ=µÓÝ(„òÔtnè÷Ù‹ßÎÝ¡ªæèT^Nà7–W/fI<.Ä6ƒ Æ­»c=ѱ¬V]b/(;<°¯wL•ÊÜÕ ȾÐûlWbZõp׋ùøw]ÍWV—P¥»bjR뉆ÄDþ Œ]Ya9:s`ÿ‰mÊM»Vµ©§“ üÞ¥'•l³¢ÍžâоõXÿ8æ¥&çÇrfßÏħØIJ\1 áÀHgwÑüët#ä¸, •­+©H8ÝôÏÑ"’Ý’¾ù23™eG4¬#r‰ìã‘“^çkƒ”³ªØšzDeaüŽà‡7³v+Õ`UµQôöƒåRxßo èöïóÌúÐKi˜§/ZV½öœyuv¬ãj°#©ý1õx ß!n’úÜæ™ãub2îÌ2l©)ºO—"cË3FåÛ¿6'¬3&Ž¿htd9˜7îÒ kkÓJ•ª<Sò¼Dt¶3¡Ñ$»‚w×c)*+EÌÝŽEŠžùË•ž³;ãžvghŽJ Ä^Ùʧ6 »õ4(bп¾+ÁZÅ+}ftH² :/“¿?](R Í¹9}Q6?¨è¶^Üí%ÛºA,@Pš,ttWÖ801QÊçÐ6Ãxíqþ<@quB†ö–nö¨µ,Ú ,º)²AU —_òâËÔÑvÐ ‘Cß=7Á@¹ZÃnOÃÒ]‡Ûy¡³??ѱìãÙ2Ï|kö�XºCµ>€G÷õÀú&Ãù-�6‹œ¯|ÉC:4ÒF[6ÒŪ÷<Ù‘³ ¨ä>ãÂ&¬l#Íp6À¿F=\áEÚ_ôÀWÇcRY«÷JhqdYõW'‹¼7¢ r ,‡†êÖ~Pi3uÆÎdóŽU `±L1ÇcZˆi ZÑ%øû§«Ë_wº·þ[™:O@ jYLfË”§í\6ýK÷§´ýæPÅmŽ¼Ó1~ŽâåB'Æ&d‡V M_êw€Ÿì\_U;vð­íÕè+cþ80™Ñ"b¾Äžæ߆ŽÞþgµ“4ºqêé\ÌÕJÏ­Å…Ô6®éx{eã­õ„ ‘aÑEgíeb.ˆN•¢›uî)‹.IœL:·¯8…]­û¨¥g÷WÑÓ¿å}‚íqgŽ™¥™/’¦°i^ùÕƒÎNÇ�'gt®×Ä~N ÿN51ójZnmŽQTÝÞ‹ ˆÖh~®e›nÔ›,}^!\rÚ®ïNB,E³¯çsØ$TOàŠp%{I1jOŸ(uTã„Æ›«›ÔÀW÷á»FFO–‰lB‰å«Ñê1°j©Àë˜ÞÆë){Î…Ju†,µL à¼içÕªÈ6Âö1‚ÌŠ+Äfš4N0îÔ^ï`¼þó–SÙ^tè¸ÊW$êøùKsWw$…çMɦˆóÓg·½=&X…~e.þààû³Ão•úyZŠ#wÕVuS¹è›=»õÑ9ü™18\‰h7ú>>6NÓ"‹Í_ˆUE«‘~Çû¨1Bz+qxC@³Þyÿû‚žm<JžCg@‘éÒšðÉrã<x�6e yèQè¯ç¿ª·õç/ :‹•?'L}r8ØXm3ä çv¶ÃR7``§½ºÓó À adÄݨô<xÄqÛI3 NÊ›”Ci/@ù±Òîžžyâw({8Bú¬çA\ÄjTfàé´†úŽ£Ÿ÷>O;›Öœ17³•ý$°Z7üÆÜÐQ^³r«"Çkdë—s“°~»úøqõ:H#Ä¡Ýöõ•üUX.wBU~£5!²ƒ[mD|èO§ÝÑÕÿ(=è©2Cø; ¾tÓM];Gÿô‰‚÷Ó~�ò¼?P™£ðé5‘¢Ù|WØ µbê9Þ’iózôWÀŠ¹Zû7 ?wê6¢@s©‹ æřޣƒÀŒ5†îæH›ÎàãßG5¹b¦Šzë(-ùT+Úþ³*v³”x"Ä[ë‚Iä÷§œùÞS�ñP-Zî¯n¬¢µx²ro\µ{5$z{ºƒüùJ3gR·g¥ÃÞªøA@ü=wñ-¤™‡®®««¤ýô hôëO½ÝÑd ëSgNAäIŽð©¬=鮦ÚD *£˜á·PôÑ¡Ùþô;ÓŒ29vˆ^Ôa¤ûÿ¾u äùÐÿ‘h`~Õaœ™‰~ûêPCiâ¿)42›*(5m²Ò‡ñÐm8.Яc+{õPf²ˆ3O‘‰̧FÕñ†Lž´‹†‹†/ç¼O5u|¸©:² å,Ñ`‘ÞaP3!c±†nôøOçöæåŽp·•½¶Ð¬‘GgÚ¾D?ƒJ&ȆڰüX¼r…”L‘3R.Á•³ó°âÃ×wwȺ~Æ`g¹ñóÝãÈç4„"ÅudˆŸØò¶~±µ½Õžçiz³…Ây£ "æH@Ù%C¤óÔD¢Ü\¼Æ‘Ë|î5 ¥tC”Ÿ{ ¬¥^二+rmâ<¶+ÉûJ”ÅzÏü]eÄ’FÀ^ÜÑà ê'»LÖµ,#m™Óý¶²Ÿ=£tæÏ•m1,G{Ø(_^ Ê®š±âà 8Xi‹ÌÖêž:³y@õv:]û T_%÷ivS”nhÅ©mQ:ýs@¡0‚?¬Láïçṕ“¡Eßù«E›°’ ¦çWzA[q8{ÅÒ,2s™(2jŠ*Óãí»ž¬èG§z*KïÜër£ä s±øâ»; Ô°oøÀå ‘iSç&ª½îÏL:Þýý$VÆþ`þá[”𠳧,·êuÈ.+x:ƒ%cűûè~® ×Å —¡‹ÛEÙ×Ì'®¡+¿HSöÎ.3µ¡ØRZSLÐô(¸9hÞg{’{V–tkZnÑ×Y¡=Ò=8ÖŠP¥mtDy®¯žÈÉ2Æ÷Ÿót`…þ‚µ(N:e±Å ›Ôö}mŸvÓuóMÓþ‰<´;ìTw¿ÙÓ#™µß5€Ð\®Ãßê8¹ìÄ —VÖÞÆÿÊé0,?ƒÙpÆÌÁr6,}6Júþý‡Ò„>Û­“K„?cò8æ r¡•õCŠÌ¢ ßÜ°ƒ˜^Øÿßî“• 23°)€ÍÅùí !ž‘oÅ,²þR<ë=ªµÇea¦¾ƒRþÎãkl' XNzú±õÃV‘õ¦ÙÓ@±¢—(@Π²ì»ÒÃzwEU­Ð¶ž¨°{ðS/6‰ª’-ð‚v£—Z•8ý©>.õ‡‘ ò®¾»·x8NízÊÆȲ„1a{²3—}ýxéü&W328JÑj-ß-Zéð|å?VòÕEêØÐ<*§Ã}ó‡ µ¼W[Ù-¦¾õvk"ìtÞQÜð¿R9…šë¯ôa1gêÊ ±Í( kLšFq6[µ‘^¬dãTÓªPm&'tš-eÅ×ÂøÙÐãE- [ëËpÞTò0ÈüOžs‡ž[1„¤úœWöHj|1‘xÿ†")žs]¡!~ŸùZh<;@ÐßÔ}% ×^nº1§½cMÐæñnîRÂ÷zg:Ö £{:TAÔ Î?~ß<¿Vˆe¤‘Òéud“¤çZSnÙŠøžIIY{ïT@¹×Ð\9w\ÉŒ|#¿—•“Š‰¹K>A9v•‰nê*c¿qŒzÕ@*I]ÅΆšM“aß*‘¯ ˜^²‚öÕ›ÒF¼Ëýu`1Õ›‰×%‰+ÆTØÙ+Þ·¬ï-¿‚¢ÑÇc¥žj~‚5P8OÎv¾ÀÒV£šeûá/u ^éX¡ÈÈœ‚ ÅöòÓÉS€¡ò¿÷¯´Q˜¶ø"ó%÷Ï@:þX¦…{*â–±Ùr˜# ®¨^A»—~Œtq¬‚K/\ ó™Ê›è7fžšùØÇž©A\19a™è0µžÝ•ÕS£ÿJ7:/=o+`àèðýübÝfi»Ó-8 ¢ª!iÿwS¤È92†¡!‡ì¦™´M†znå &ªuÿHò¾Ì|wsäË°‹ø´¦Õlo‡5ÍùKtcø…±«?n&Ìef‡ z§ÚþÖP*Rƒ)³ÄíZÔÊ~$kÄyâ禠.Ñ*ºÉC¹Ï‡é mZƒöBCæ*ä‡×Vtæi‹]Mùõð¯U¡¨˜pu0ÄîÔNtŠáÖ`öEô äáõ$bò/Õ÷»Ö 4ÎËy³íXYöûù,‹’8ó›ý×ö†¼HÁŽÚôé¯>Ñ«=Ù¡ù¯õ·R'îÍ:! {lŒf³kÙ¸¯UýuÙ›È&ÛåºÂAù5™Ó!ÎLaÛ•h*M§#Ó×ÞßQáS!ìÍ |‡ü^ü›EÌúéãÐÎVÀ¯_rÈWfѱ1I®ÆÞÃÁ¶ÛY{ùŸ¬‘}ãÜ\ìh½æ¡’ ·Nb<*¨‹+$Fpêۙǯ2LZŸ–Q¤rF‘Qè¢<šå*û‚I½§Ñ}‘Û]³5Šu%ú!¹³rF1¯4oË {ßyŽ5ô1 ¨Bàg^†8à)—˜G/Z£,¾[ÌÄ¡OÌá›R 葸b\D…ð­oðüÊÂÇR¿|£w?À‡+ü´JâÛðsnÜ|dÃFO—Í!Ê„dPA£¥ÔûY…ÕîŸÒ ;¡Âip“–™’&lŒýY$ј„—qæÃO#v° ÒEõ—¥ý'|0*Ùf JFáõ°jŒ ßÞ¹ û\‡'òaš?H‰"ca`úÉ]}fÛ …7îNx6þM"9Р8çåÁþ iëóI‡3úœv¾$°† ñ=Ó×}çŸþÉd/zg#iŸÓ_Ûj‚q€sÞüƧ_ŒçeéØâ€ód•öäî|è%¸+§g’n,Ur_±)‚ìê¹3ŒÝÔž9î Ç_×_¥ñÓÆ)¬ÅtbúÞ°� ÷V««uN qÓ×W.ðè]Ðïèvm+ÞsEà+‚´æm‘bN‹ SòôGí¤º##ôÕkÛzsšÎÇo-âÄŸe 4a½Óõ4qwƘ°àCóýžjÓ°¡J¬=Œk#F·†¥ñ�¿€rè<*f�“´›—+‰L¤OÛC·9y?Šj 6 3r©»®c;²­kó*ûê?ö©öÀ¼Ë‚t´2~U` øoÆωsŸè–Û @ûaø£(=¹ª\Íô-¶CÏîXÃa§Iæ­ÆkÆiQ†žt=&_à„FåMG†Ï“ÅžTŬöP(sÉ=†€ÔÉfžÈiÁx4AZÙ´ÚÚL“íÅÔ)ŽË8s €ßp[OÞyX·ÇÝßYÈZÿy+”î&ˆäM0Ì%ë+ìk?vŸ¦ÍíþÃ.¡äDñ½è„Z…„âñ©=¸a :FõgêôðzPhxn®à°¥(Z=æ’¼cúø?>ì«hæÚ©ÌÇáJl”Vipr: GÂÀ[×MhÀ@i!úú£³[ä7$pg‚¹‡£ºÔsùN1P¾¢³‘J•‚€å©âýùÇ^>‡¦krÚòïµ;Õ%ÙÒŽvè V£·.e1;«™ Ž¾¼æûYÚ«”^dQZã/I©ÄŒê¶‘’ù‰¦bKd6n³]=Í' íôóv€7õ½)V¦fÊ–š2¿™)umb“Ì­¹å7ÖçÞhü÷šò¡w>°TÏÜUŸ:[SW¦°XëÚò8µýÞ!µÈMå>l¶‘X Ž~Ê2‰oWfž9íàö:=“{¯"Bo» ´•ÂN;Þh‚Â'�«YÜTË|N‡]èNòh1 ›g¶*Ö ôKͳH*oFÉÚ Á¸²×-…üõ]VµãÀ¯¤tû½Íé j”³‘“º§ÑYZ4…t—9FÂo;:ÑJ“†“ö¸¸¾©øê;ÌâÌ|93zÖ=òɼ8!‡aHSãtÞÕ\uœæUæ¸Ø—5-ÕÝÅ:CüïüÁú£I=¹åÔ°@ ØBÚÿߊØßN,òrÙBñÛ²Í0÷CÃÁ)Úî"€g×ÉÊ,!ÃRy’‘yb鱸=®÷Ç…RŠ#Ø TçÇ×k/Óõ§³3ì®…t׃´CÌ]vWß!—¥W-—ìÙÁù¯ý×Ãý©ç™“U?™®œ'ÓZ;Æo„bInСsÄõÎ;*D3ÃÌM‘p²¦ÌéU-hª$óòâ=ezìP*r¢jµ‘ËbÚžßõ#uZÄ-; ¦½ "å,þÿX{“íÖu% pÌü ª&ïæbß I‘jlŠ’IêȺ«þÿ;*v�Õû¼¬æˆöÍ'K$ˆf7+ªãÑIG‹d¢[MÇÀ° dG‡“Á¹ùêük¾â(¾8=ó(ó:j Ô´îÜd%vòBœYü^˜"òÑÛ”É6µÿ CrÐJ§þ§Æ¨àv¯XÚD¦þq =¾^Û(%Ü^œòÙý¶ß“`ê±·+î‰NaPÖª6PÔ€·˜ oÀ²'Šè¾ùÅkxT`YY ˆÓm«ðä¡éfS-Z¥îcÍ~E®û 1› ª¶š-ÖêdÇBŒÂáv«VÆšÜÜ—HN¢ÄWÔ ã`»¡›µµ±&„Vé™ÃJ•÷¥9º»«{ÒÀEæé?Ð*m;ÎŒ-0ZšFPn’LékXa\ʪíÖÉùÿ”BçÊéÌ(lr_¼š:§³:œ©üOó‹ÝñÌ¡jEÿÛRŽaèW1kIÊü”ß\õ`NÐÄ5ЮÅO¿ª@HÝhTGß$®-p:dúÈar§ËÒëI†“Xh]iÔ›!M  K3@±Æ5ü?E+L[ÑËý§¹ðÚ¯é¿áJÆ¡oNQⓇAøùéÍÍÖlÂxvýäƒÓ!P9ú(Ý~ž'å[+3͆ä]c?ðq7ü\Ãgîër·»„²wìŠ ú¶; eïEÔ’À±eîH®lÈhYªÝÀ‡Â-e,öÕ<1X™°¶R¦°8ŒaJK;Ê£I1(ä©Æ·sA|� žráò¨~±ètîîïjVRª¹¿k˜ù˜ Š 2Êᶧ�ù¼ŒïÂ4÷ÁdίQ] Ž¸Ô J€ èævÇq¦»FʲWÁaýqÆ)zõ“'—(Èñ éMA‡Ì§Çä\tqÅ`ê¿Áu%±¿YiŸÂð-´s§J ¾ÑSnDSÂ| wjÏ•Ù›áLê[—<h}” Þ·©‰1æâƒa9œcí!8°º¼{໨S†Ñ0Ò³.{Õ‡L8èÐæê? ¨é ý¡‹Ñ~90ȼA!²ùߎÎÃc_¼§4 ß•ù·ü¯Ôp÷ˆ;Ùç·©B+àÈ÷` ´î ™vŒ¥ØÕOg Jó •ìˆÃ~ocoÑ ¡©3Øž3yûK…O™÷ªÎ#d |î o”clýTAçVK§ð¨?”’`TTY²·›rŽ<7û ÐÊÚymÍ%ôÑjbD57AÖ¨EUçi×®NG}yv ¨ {È,h(nœ“ êï ³{ô[Ï{ÀðájÂfoo ý’̤r- לü¨ÑXk]ƒ»UiñLZcžmcóbWòVÁ¾~•ÌëN,IMÑCÖ›¯ÆÐO__±»K¯HM¸p‡ðp9ÿë 3e.èi+cÞ“¨O ’"ÄKè½`.R‰¢wÑtžË«AÓ;‹·í•! ú¿¢”ÂI¶e¥Ç®6ÏfÐq»ªUÅ‘G¼à'ÝA¿m„ çÝ•ˆ-¢»Íl ;÷Ð4®}㺫ª‡¼Šƒ?TJE£-sÝd¶‡ åux ™5ŽRBÙâÚ¡ãïãäm§T}VëAͪFVƒ„eMñ¤¶«ú Ÿ@l€¡u,ëêÞ´àâñøb  !¼Kãü_2“ĤçÂJ§ûsøA'fmý¹B³c…épàµ2pŒ È"8 BäFÛÅz³¤F„nkm›J§ã(Y‡œ í|Þqt~ p‹‹*R}N9œrê§*•›©}« ¡ãÊ*ú/ØY’-iЂÜ0j'„¡½bG`D²ëqø€¬X/¤àa5Ò oq <À[@bé»CD\ØÐZë.6S,µw'ÒLÒ{MC´Š�ª%>S®ô£ªö´áŒ1å×Bv´žÞÏ(±ÁŠ˜ã÷ *`‡±q/(–Ã…ã8eIg*ýG—I`«eÀÐ!nŒâÈïÔ8™3TŽ¥È‰¡—ßz)ŸæﬗŽ¬ˆ$/ü¬1ý‚ÖÙn]”yö‹ÜW`o““¤3K<»µÖ(€�'ÿò_S\: ­£¬U°)!¿HKGÎЭïôŸuÓ2¼fo Ân-œëž +ì#~f´-Çí©Ã…Ê 8óf4YÎþqsñ˨7Œh2¨Ú™[ÂôºÏ¨¶Üx>Œ¬ûÁQ®ÜÕÊ~ìiÍ0:‚_–|Å,µåš¡óÀúw^ì ÆòælZ�ÓÚƒT¶Î~ð·OÎ@Ë‘Àêå«=žjTÉ2®!D^Î gו2LãWí¿Ít‹ÄªGQ*¹§3ÍÐ|©0­Ñ0fåeb–Rõ^aiß61§ä°É‚lm› #ä(“l5éôûºùŸÿʯBsˆ­à[PYè_Ì0‡±shOõHGèÈãiŠ>KCé§ÂíRÄŽÆi šíÌ¿÷ÐdÖA2ŽLa†Îie‰®Âã‡Æ¯ZV€¹ÌI©öïÐçºù…/d&üߊ­Ãr›Ìg™öÔ$ûàãÎR¾ŸÂ•n:Qí¶ ŠÏÁáj(埡¤«l(™wól_©6€øodç§m=pJ“Koz`R>­Ø­äA{Œ¹¬}sc°á8+swþ2˜Ð;jFUxåHF›1¬kÛ/°]|?=æÎLË;|µkƒ'²§CN]ÛG:ÚÑëa8¬”¢!çÕ–q¾¿ ¨çqš:) <õŒ¦»Tª¿‰n'Û"†ï’]¢ v–ý�>D½ÆÎuÅšzêx܇¿%‹ÑœLÁo¼“"ô t’žó ìü ësðqúo 2I–ž5|Lyµ/’¢Òbf(øž»cåE Œaa/ y2ì<X·Öá™K Ó)¹º¼²6&¼aD²×jÏ“þ‚jCÕc¯'jJ󊺆+–Y¹-Ñõáá+ÝÎëd? $°ä¾ÅOK–’ä5©hiU„ü.©µ\4ê»?ÌL~%«™å¾ )sJ‰¾vÙСäq‡¥ýwT×8Šýæ6 ÒM«_E@ÆX˜•0 €—|ú,^ØØòyžé÷Ú;šÎôÁUºlyz¿:Ì=´žpŽ#e7õ·S0[dÁ€ÒS,8Û,~e,åôuYq…ž¼1NJ>Òs*Ìg>tÁ�Dâ‘€®ßTÐŒ|Ý!Šy}Ÿ·‹7ÄqÔû2b2DŸŽ..½ûiÕŸ/¨ÏªjÑTˆŒ[§Õç§�z²V†™qeø5ÿ–ß·Þ¼N§ä€«º ’NÑ Íiøâ3 üÀ`ƒXþY · ð9ó¥LÍâ"˜.T,m7n„¼ªÏÑzÚŽ Žx$¸«Ç¯„YCüÀŽªóÌèYÊœjUàe lþ§cÚîâEù}Yâ;¤Ò6Ïöï㽨j6Ç›R•–dň� E[™:ty–dßšßGR ~¶þÒ†2Qçd DÉ(é,Vï*õ}Á1ŠUÌ34"«-6xçcFÿÙe’ÃPo§.ÛNúmkÐ.åz—­Bžd\ ÿPm5ÕŸÁØkЇ2aö¾¹LìugD^Õ¿µÇecÙe£\öÂê¢È2_3•ÞîkF>ýxfÄû®ÿCe<…ð¸knY ›²§bJÍDÊ;V/(éÀ梡ü`þôð_…©CoÍx<#>ô�tB˜Ü nž¶ÏT0³|9;®„q»Uí‘ãa†!k 9ž­¢ÌZöFe¾Ï<bmö}½ë$4Ò²±²H%VÛN³èf½hª&¢¨’Im³«Î9‡síëæs¦°|qßÔÙ}s-:é&õ:Õ„\lçÁäè ÌâÓHÏ{=›¤Ý…¯{\~7_\Ö¢3e= ÚŒ‰—åfÈÉGXÜ‹¿Õ=rìÄø.°Iwr<{à¬(,Tµ‹µÞÜ÷¶v4žš‚”ÊiZ¸Î…S^ )kÌ2ŠcÏËÊÚ™Žæ°áË2*›¨B£žg´J¶*˧Ša÷ý¸R¯áÀâO+ª�+ëÉ‹÷Ý×€ÊSÞ¿ÚÒ3žæË€çsá]÷(nL‹…A{½ Ò­uý@ eè Â_T¬«yÕ‡ùèg_Ë#6ŽbN>,h/´©b¬Ëw¢],›‡S kŒ*â8P®ì’ l´ï‡÷§ˆöÇÒ×ßÀg$U‘yž¨9 ”϶£6à1I¡CŽ'–Û¢OwiÛ;„{#…¢ —ÿöˆV£û*ÎêÀªÂ[Šù-ëò5ÿ2¯æÕ:-ƒÔ¶ ˜t_(hÙso]{·»3šóö2~Ì—v½ë_üÝW#UÈpÅ·[{nEÂç�}bÙ®¯]»cµ}Š¸ÅNAWlÛ>m¯dÙ£Ö/ŠnÝÚ,Œª2ÒÃH!¼Q-ŠªºãT¢ãïÕ²é+¿OÉ[ÓÔ^õDòÀºr±¬¶Ð~±cJ_q­ڔѴVrZâ }ª.3¹w~ÑÿÄÖÁ®0úõ˜ùÉò‹Ü¸ÃÈœæ7°Ü8uþWLƒ¡Ôª *K!(ààÞ]œ´Î+=ÜÈwà¡çwþÃZûo" •e­î$‹?3S?Û5ÈÒ–bwÂ(ð,(¶•Ú…ÀÀ±ÆXþ·-vœ€\ÞÿÉÔFpOù秺ý gBéJ²2 ·ù=¼×–QEåL:ÌÞ÷_È,Ö!Œ¾ÿæð6$fRY3ÙïÐýª÷•d¾#7(MT …ãÉ™ÐéÉ<é€@™‡Ç ϯ¥;B‘Vg´`n±e°äžwûÎo–ôü9–OìzñFxÏó…œN‰¨ÏÞ·¤coî”_Ô ´&Çî}‹ÎØK8nèöLG¤9Ф³m—·tnm!NxÆÇõèÃÇ¡Rå‰yü…o¼Ï–ã&Z?äAâú!% ¾©‚’=zuŸ?Í|\1øôèÎ9Mt\¨¢3ŸÞ»ä[s?ÓKW1šö?à£ç˜ÜP~>1øË‘åPç<ÏÃâ°òáS!`_ùl&U&Km³·? oLadàÇÓ µ—eãÄ*Äò0 òï:GÎ!ì¹·:gŠ÷¼aŸ[ÇUæ—ëtˆP•WwÏéC¸òg¨ûLêÕõBþ}êNàöhÄTù2(çÖœNÌ-§Íˆ_tn#ZÙõÉÚ@“­6<7ðY…o�d¸Ù4�@ Ü3qÊð/m²¼ô]ЮÜ'”Eÿk9V9A\£{T+SÉ-_îû¶@X×SB§Tg¹""QÊxm–q ¡IüR„’‰S.Tç*?µ €Žåš€õ·¾é¶z¨±Ä&9&oÐdqNOÈ®S±~Ok-Pf ÑÁþÔz‚—ð®J+Œ76÷q ?ÞÐIŸeÂA�kNu?Õ÷;b'c*Ûv:G‚¸UAA$ÜPDÈìî|æ­ÂÕ O„\DŸÊnˆ.„ÿs6 ò¹Ÿø/Ø‹GâTV1<ú­YP9rØOu�Ó·VÃçq2[¥^IÌ"›S,â´òi{zÃΈï¡�¶‡ÕCaÝÔ}¾£Ã™N‹ä{°½“€ÊfWoèÍulè{8ÿÌDóuʃª­GT©ï£’ú¨Œ€CSs1KuüóÊÀkå�ÚlL¤þ—B‡Í­ý3çîqS¡EnZ «”‚ªXõk+R·´RG]¬H Õ+CF‚ò½Mn÷ÌwŠ2V«º!ŸJGZ¾óƺq°c‹ø/8fò’ÓˆYB÷›òÑ•Ö’…AWe­ÙXš3¶vïö·)r§àiÙ9oêØt›–žE<ZÚ\vd§§ìn8l™×‡®×U+QJµ©l„–-’+wIÖq“XǹûÀÁ7ôüÍaÅ„–�ºñ�Ü_{øpJ:â3=-ÿA×Y¤|^æm›¶¾Ü·„”Ÿœ›j~}IƒlýÍM‰˜éÉ°c¼|8ëq—]¯/”U.ÏâȮÚU åP†sFcÓœÇ5Y×;&†è‰õjHgÎ×$ »TA1Y¡ŠtÉc8ÒÞÙ-5"ó®nçSqZúm=4@)‡ gÝ}‘¸øÞ/ćߵªLJ‚‡˜@”Æ íS…8œ|Oë_Sý"ïl*‘©ÍS¥·¦¡àfHÜÐ=ÿ‚…Y»¢ä_^›á-? »¿÷Ë ‰8SÌÜûÔç¡ÆüÞ oc`h±»5_c6fø·ÁߪXÄ6T:(^å¯ÅËìŠ]<”A1ˆ¤¥Œñri9Œ’ [–Päõ¥ÓqF…òÄ$ Hãê ³#”ýj~þÛ„Êò®EI‰@CÁ¯Üük� g|BzÜß'ØÔ„iPfH'ÏÔ¶3ã_¯¼+_õ"Ø'IPô:OÏÐþ5~’M8'øõ¸¼ª¬Üˆ9ÑBÀÁñyò´RõWëÔj_œVr0Ë ŠTETMïæwt›fûv쥣IH<ô}¹~£³—¹¡n)Õpu9ùxy¨(“‘6€4ÈõeKÔQê#£ÑÓŒ”¸8+ 6sÚ²V‚'Æ£IÒÒÙr_ !ÇgÎÞ«Þ‚çò°¥†?˜sp34¹š¶ß|{£³¥v9¬'á8;Mnì:ï²h9Šh/‰àÍÅ’Nie# 3÷Ç0/=]|—³Ã¸?Œõ`Œ ÿ+æ2qØf³©Ò T/`R,‹Ñû²£Âm~S©1rÃPf Nthæ³å»$x˜¨Þ;Âᬒtï5b²ìz×l¡ï=lUø¡v‹îÒîðŸ8g7iYJ¦A‘|´†#×HYÅË–rópÐþu&©€ãMÞØêÎgò-œyLjRäÃè5Ö•³“º/iÑ€>¢N2YõüGûIä¥/ Ò-8nµ‚E£‘}iŒZÈ0ì:‘Þâ|I¸íu7ñß/þ%,”VâFÀ!Új^‡~¨ TBñ™tƒíÔHAÂØ8(Z; OKE7¸|þƒ ¾ˆf²Lù¿«2«sb‘¦lØ^ŽßI[T@ÂýQ5%x‹¼À;®íqéhR•”Säký17 )fþñœL¿ºy†»º'I•g õÝ „H�í›WÆïœH799™{WVî'ô•ÏéóÎœÃ^%ÙNÊ»a¨Ür•ÉB‹kPœ¡^ áz,S–‡ð´ÙB6h‚ŽPãaP›º·qÇú€?§Eiê{ÑR ÉêstÀ7†ß3»é=߈ÐH´Ã˜*î:èW‡£¶5g~éK©(»ì áÝVAtúô¡ÊcÍtüDyZe$ß‘!‰”„!ê¢iÐÖEÛm…y$u|‰TÚp?ô£È|ËõžBìK˜Ü¶úƒƒî¨^lãÃWRFôo7èá0¹[pWÿ> K_+žîÃóµÂú,cjPÕN*bgݺýë¿©=£2rˆëHð9íǹñèŒG�m °[ôM(Mê&Úª¯~+ÑåZx/z*tëVu ¢Bí캀̉>û Y$-1)KÒ®Š3¿œKƒ=½U2hÏ¥¤zuyV¸ø’Sêy—wCW{áœÙp«mTë³ü„£¯Vô"Ë«woôag±ßA cT¿”Yo|‘2n7˜ÇðÕ]¤ôn\¯"³EXš‡ûÜ(Ú9Ó¥™2ñôçÔvR{®1&þ©ÝvçÓÚâ5¹Üê»Í–jÈÓl) ÏlÐO”ý‡®¤LÍr6KƒìY*x8…¥ÇZKiîˆ*Ü› $¨áäÃ[À_m²p ñk˜…ÁÕëû zQèË™£TiaÔi^H?Ðd2Ë e#j÷æõ¡}Tysš—`f“bÛi_ñ:î‹N%ÕÓò€w™€îms3«œ'zïÄ.ÒìÆÜÏF-gÙà]¾Ó+¨Ì‘fÀY0nÑö¨7fäsexi“ÅL¸Å2GÓXŸ…/¯~íAÕ£“íVûNîJgíÖb‘ª{¶‘ï´¦ãbéàÊônRÏKhr:ÉLˆW½9À‹’Âg¤ãQSšY vÈ^pcŸb™¶’¹Îh.¿‚%”¡?r¶b¢£¿ÕYKfa«cí ŽÓ³Q‹ƒÀ•f„ÿ5Gè)x2³ØIÅÚÙ‘ƒVy‰ˆ—Þ­Þ<wn,ƒÇ`²Ö²—¥³áa�€¸1¬èÈ‘í%˜»B•È‹ÌÿàiÐQ>ð£Ö(3¶k€Ú(Ë–Á¦E‡ÔùòuÕʘ·N_¤ïæ;¶€éµ Èöq§FñÍ%·4`zÀzTMgðíöâoò‚$4ù”Q÷„³Œ·›=€"…žI™ìý©iè>IÅê”^¨J¢…v#òâÊ<äÜS8w¶„ÜÓ7@}PÃw(¿�¢Sn9ýIÊ­ú‰Å“¬jÔ«Ì99Ø�ñ\uÈòJ8 Ê”é¢ßŠ3c 5t»?dÖ¬lÅ·È¢‹‹½wT ÄKÃÞâX÷{¡­€‚5ÔÿvBj`EŸš=ð#šBôx ®q"É®”èe”˜[e9…LaJmDj+¨c@GweuäLµ,ž¿¶5ÚnÄØLþ6ªëÆ©|‹qq¨¿VvðèÚSù5ßLˆµR(¥öhLœ–³Å�qìÍ yü~÷`Yå SÙÝv´ÿ>?ýÇ"¦ZbQüÁ /¬ìh_ KdìÎõ´] â$Ìâ<´9|gl³ÁÎå1©¡ÏÊyÖ²\“aý=ËÏl'Š‚ùŒ#z­ñÉhžLÐAíþó'ÿ|d¦áX °¶¬NÇi` '{q‹hˆ3_¹@+0ÈGÌïœÄÊ'¼s±wVž‹J&¾È¬"Ûxƒl %0DÍ®5l½NÐZ1ìEûÛëb,v�PI÷@ WãÑ#Úl™õ £Æmw¤ÿÌFŒj¦vÒ 1×/JRÛHQóÕ˜°ÇœôRÅnÜ»„Ÿ‹™{’‹#Ï%”•Ìò úÔä°WئS¤½Zs¯Öp8«Ô6HÕ™eªó ´¼ÌþŽ}=ÏhÇ4ú ë2sý UƒÌ�„…ˆÔÚ©¯/˜$öf• ï—éxG0 *Gƒ2çoØJiÊBì÷¶7î~øþ.R_J ÃjaU\±/aÜž èŽÒ]¼«…âL ïK¡DIå÷‡ã˜ÁÇñ h¹è,L"ô°Æ5ÙÚ/I2› ­‰ø{ô¤šÃEÛ6¿ž Å©Sa/Y½¥È‚¤>{ö¥G� .Fׯfç&pŸ[\Üãçz­î;mëRÎO–Ýò¸bÖûý…eY[þÜíÉàäµáqÛmüZ¸TQ†õ5—tëu9ÍÿËz‡“MçÌ—#C¹=QH¼“‘ZÈ(1¨²Õ:ƒòÓnþ’}îÆ`·2”‡R5×€ªÖ³éëýa„üýß"u[@2)f„óÖë‚N»Õ È‹Y‚‘ÁÖ×åTÆ÷¤r¨PÞpœ|‰AÑPæ%Ý°^$Ò>><<Û{X­£M¸ÿ”ZBZ¶ggUÎm^QºªõÓÝK*2_Úœ hÁäQHsê/ y˜þ_kXžrUu´„¶g7„xE½9u÷™ð«¯á®eîC Ž]{SÛ{åÙ]}¥¹é¼ìxLU>k2Æ%n.u>I<ðZ­!Ëù}ÒʈOÌÖ.çŽÒë‡ïžÔ{/fô× {AXe½³ ñ´ñ¼–ÙÓ{Ôô<ö‰A¤JAƒ9©&dS½Ý÷‰ŠÃ`¹ÍAu/×(ãtÙM™‚Pšä.f›˜³<ѳüƒ§L¾ºìJ1 {\ÎC=ç-CCΟ5EDM$ÐÎãÇçK—ù‚Û, ‚j<µ|”o Ø‹ÒYËmÓWÄT1RÄ+- Ì–ò£Û˜ÕºÖ e6õþÚ§ùi÷Ñõ?üÑN£Äª‰Å†ý©æ¾ˆé§¡½0Ê}G9�¶ÛÎÈ[.ò�"½Ãv•’·ÓVo *FCÍ—3úÖ´PþÖMS¹Û0öå4:;û‡Š;Y²Ý~)ã–y­lŽ®T@#T…Ð sä4†œ¿è<ë:U±#`”ƨ‚âöåd©¿ÏÆ´@.ÜBø«/áÎkõ¾ljú&ñ<{ ±}½½Õ¿[—Ì¿·ÚéÎ )3VôŽ`n¯¼gõ_ZîN�…Ý>`x™O¢ñÜ‚06*ÍÆy~øJQ‡ }z c¤ýzõz“:›tºÎCVl1 Ž¦=Ú½6|I H™Yñ}tÄáUä¦^ŽbÐý¹Z5«z´ù@G‹“aÕKCº}¤gŽyÏnšôì]Ш;ùL¼<Ë<ú »¹Í0+ªFm{ȼҊ›æÍ=À- J-œIˆ½2Mw¾Ÿ:Íuzù"Ÿ²gMùµÏèñz7ÑwÊr˜Ã¥µÌ‘eÜ/@Rh «¸|¼ÿâYäF®nþù¤ˆ2€§nÑvà¡öLÙŒÄÆ›KsƒTB¥ßŒ4aÉÉE‰ «GöSsÑÑßS 4tÔ5áeì¿°_ûÎó±Y¢Ó~èŠþ ±,-3O¾cËÿq²„ó}Çɱ·{ÙuhY0ÚOÜõ—ʦN&ÿWœ2Uæ ªUhîAÙZ#ÛÈjÇè ¸ž¥¾á—Dz÷Öí^ôç² §÷µØf�u§úç0\Þ—ÞK]¢.œÐBÄõ¿Î£®Þ1gìc:b:y ÌW6ÿ´ÞÍ>õ}‡béòP¢ÞYãTr\Êá,Ÿï7ZR‘ß·3åÑŸ”Î*ëÅ; £B%Œ4¯ŸÄ6˜£]=¦)ƒ8cZPÿ‘òÀoú” И‘}TÅŽš6ôýejk€8°vÍ:ÔJ'óãAkï=ÂEت0ɲ>1}ö,Èÿ]tv.j.ë$,¹l¤9c6ïk¿+1o÷üß&HFaÌ ¾§>…‘o•¼tµs§ÿVfKhÙÐAqÑö•€­�_açFb«íáÈHÊ{ØÜǃØ$uìŒÅC„–h‹ܸ[mA[±nõ¥…ó!ÆË]Ïf‘öj)Ò]™§g ˆ´¢tBw…¢‹ñûp's0ö~îöGú"Æb&¨{Óç~¹Èœk¬À‹ ƒl”…¹Ò¦œgFX1£§ZÖsB�©8d¾ò ÿ´É.—»q°@<zÞÇ…hö ù좸jú5MÄ.¡(ÒÂÈ4wh‹°·›¼Øn×Çè𧿠=>_jŒ^†Må±÷#0¹vƒmY6]w]z<1M_¼;Hú´˯@M‹öu!ç VCã™?¥"gÁN'ÀåPéºóì) vPGw}s1ÿ^.€(/ÒH³9æžù=}Z9:çÔ•P ܃« ‚£tBß ~ÓŸ°nf©‘ý^Á\¡™uÙd†Â}Lã?(Nņg¶üé!û,‰\X Y”iÀiñi¹Ì:×n¦ëáù]{Ö“Nù(D�íºå­vŽB8.ƒÕ#¸–u{Ÿ³#8´ÿCÔ°Ž6 1±µºìÒ¢d†…ž/¬„£lanPæ™a¯¥X‰’²gûõrÁ:äž®÷E:ó¾ýcâƒXhYoú,´f=¦ßËöB‹¬<^wy§¸Ë ÷<±h™Àyö¤ÀyˆfE,^³”Ê4óEª|ÑúO;[cÏÚ]L*/ÐÊQ¥{öõŠªKûñ~ððfÖÞC,¤èOŒ›”nÄgãñ àÜåX9g1RßÞåu/Þ¥?õ‚ëÏÄJJ�A²‹Î%ç¶ð6ëdy}áD|éSªŽtÎíô¯kgñu=º3Â!À¼yÿ¶-‚%êÂ~A;…þjÖÍ gÌ€ÛI?€þ c.¯_ý†”§%'N¶í–nñ¤mâ:ŠìdË:ºÝMn±|ñÞ«0ðU©Ë·ƒºŽ°YøKR~³�ÏПõåþûö½Ú-Š3ê'Œé¢:ý+Ì<£1f‡ë’2I±D‚ûo¬Ù]‡"VZhÉQÁ ¼ã&'d¶©Gö©yƒö˜…>ãИ)6 cþÁƒë»šu9 sú–ÇšÁ 5ÖîêOBU‡%33WŒVƒg5Í“OŽO(†€Ld5©Óõ«í•å> eH[ñQi'9+]Óâ= UdFÍ&w{qSUK‡ ³ì,¨z+b‰þÀx`ÅM]*´¸Ñ_¸c V…¾zµ{Kœ'`à‡³Q­°o'o%òÐJˆ&öÊƌؓ®;á5®–ï …àÓdŸãÝöÂûТãÙ"Ñ2Œ”¢'Ø!|ü?T”àçq‡îeVõpç òyx‡ç‹þ‹f»œ ņ­žAG±=[Ùbè+0³"¤åkï'.Ö))�Z]!úQx%æ âwÙYÚH\5Úñû!¼,}ñvèl©ö)=Ÿ’LEGà|ñndß:ø#ÙÄŽ08Ã:^0éß—Æ¿A_<ž¤S_yHEyNÉ@@óÞ¼5Î*ÑV·•TÂZ�‘xZ!›6êÆ7êûixEÛgó„¸S*`œ£„å·GÚ»Ç$Ê}Ë$2i7$Aö}òx[ô{,:è/†|eøÊ@3JêÖŽRDAm'üv#M{Ú0P_yB¤›} ox™¹'ɾRó¨§uø¢]²¢¬7@ Þv©.ïÄ›|÷þo]³0ŒÌa ÅYm38e3íâ&fËï¼iú”_ªÄŽcIiûÅSäÚÖ»³G|:ËÃ…31Ø©ZG_£k¢íœZ î͉@ßdªÝñ‘¹jUŽ»Çþ'Ø0sÞ‰µv{æT"sÕ+ÛSé,óÀ#8X¦SïTپĻv6Ç«ÿÄúFv +Áå@5NÆ�š3ÓØNÓ¼³s¦_–Yé§fìñˆtêøãá,iIÏì_­VR;CB›¾ºÍ@±ð¹Î„Gè×ö‰n^Ú6&û‹a{fŒ¾[06ß–gÏb‡”J˜iHÑ,bÊ1{Ûp_ÆÉ?ˤ£¤°À\c†ßçò¯i3âøð‡B8W™ØÌÆ"å÷ìÙÏ©bÊYŒá9æ è^ŒóµÚCa,ЃŽšÚAœ]êçàÍÛƒR<záã•$ŽÈ#lz»Þ’³›ªB ÷Œ@RЇm`á9° ï•|µ?“Y¬²'%‘–Ù5&ûž³æ"™/Ic$½�¡²ÞÓQdŠs¾²9á;;èÔ/ÛJ¾h_ÂçáOäíÖô°bÕÍ–„â©^¶s&Ì|�€¹ÉZN¯UsŠÞ±bPÙZO¡Ift;"“zMu”ãÑÔ)`GúóæãòÁ™­³a¦…Þžúz7=ÁÚEI圙ÓÙѧ_¶Á†XÝj¿äM=Õ¸Hrí7ˆRËŽ½°Ì«{¤ S;g6ÚmÇçÜ•4YrDdͱ7ðH•îmý婲ñÔ´Gçr[Z§…×zÉYœƒ²Ã¢ý45o*!ŠB쎛#^« 2qQBCö!Ñv@žêh1ô+È’Žÿßÿ;}XQŸ§ÎuÙr`‘ à°Ÿ*«‡,Ÿ*7×öyÞôEfc�ƒÜµëió[׊®™‡¬Ýî¦í_ƪÊ9V‚©¦§’Ôƒ•Ká.îÎlÍ—�J5ÿê¸÷…Ý4ô»ã}ym²-âc³Ÿ\n>Ú‘n›#‘ï ø¬s¸T¹X2gŸƉ÷;$â4_¹‘õ´}$UÙ§ø«‡ eÒ[Ÿ.î0ÍúÆŸwãX÷W/‹[^¦ †R‰¾­-Ìñãó°&ÿ<ÍÝoÍ.;›n9DÌƵÔ]–½yæÒö+Ãð ±w(aVÙkÚ/ü«ÁAšù”*zÛ¶ÇHòÇMUÆng7ä-t²õê’ªàÜ…¢Î‘N«{¤^(X±/Ý>*‹æ2¿ÿoÜtD¼Œvu÷“TA´þTŠ˜¡Òƒoô× BA;’Âi{€6==g!Tå.ÇüVïUïwž;Etäi`ز|x™qêïzÏ‘GŽÑak/UPZ16EwÙÓÊRMdÓ€ì£ay—pŸqç‰ßðÇhxT«•84 Ž»ÞN:´3í×€‘Âg}q ×ÄGž z8ÒÃýÞx2¸ÛŽr‘}ÝVÜéß Ÿ¹ŽhtŸ×u7Ø×eu,æÕ3Sxö‡4ÁŒíø&l%Zʲ�}Âè¼1«£*d‰GcÞÛÌŽßr*ªÊÙÂÐÒ£9 ŠÏsª€D¸Ñèš,ae—»ZÆÀÌ›G¦´*Øf¤~´ ¥å_ò謭¹4öüFî«tQzid2‹l:€¬ùm5Ññ8Ðã³tò·t©obÈmÀÓÇî[O;wshá˜`ÞYíKö]ÿ5=±‚“…ïlHÿƒ4H¶ƒ6ß¹½}nØdÉŒßf`.ÓÇnþ;(ôö�?úbL"­݆“ó¼õÎ<OùAlMQa·õŸ]kµ?ïÙåB’…Eèimdãh… OùH Ë ˜rÁÅŸ/b¡¯·ª®ØçÈDÛ%Û*¥¾1\•Ä¡šåŒôNí–ŠwŸo…½ÐIÙK_ÍtÚ=¼Y>·<ü»$Q9ôX º$8�Ç“ûÄ”ñÎgï‚áïþt²".ôèpmK.ÐX—Ÿ2ëÓRgõ‘ìv(z=wÍ2Þn‡•^jÁÐvHžªŽAeÛ&&{ÙŒ»=Ãú*u¶\;àÑïYãÐýU&áà8M=Nä¤üŠ$Ž,b‹ë3TÀ!ù<Qîx³Œ&aÉ2d˜Î9šMMMèzS¯ŒRd§„ÆgéîHµI7z�•Ö¨­ÉVÛ'>G¯_§ÓZ›OIæ³JáK1@¸ÞN)é Ô¬—OFZI]ã‡ãQ&¶÷ÃMš»[ÀäKJUCJbô„CÅRʵä$˜‰r~¢z—»h•�¸O�¿‘ΤÔ}æˆÝËà•û‰¤EðˆW?úÆ …•e ñ|Ž|»ILÊq8ŒÐ¬ÑuÇlûú¤O{yÒºbÉçè…ÊY‚'Ó_´Yk­¯ê!v>™bʟܺh0l¨Xµïþú3[ qg‚öã™NÒ!707 ©÷Î ò‡íY=·³ìjMÌSêµL+Å1«÷ï òÊLHs£þÝlél¼ñ¸Åò î™'²]#’d~W'Ž%ÒgÍQgj»†K_ãzet_|Ë<ý¿Xw¬Í÷*æײ[ ·&53ÎÙŽÖa*n­/•š¼D‘ñ·œY§¿¸ñÁxhv¶2ã6BûD›ÍM³Ó ÝRÌûV´^‹Ù0´à4¡xï‰Ô|ôÃññoþé»´Œ²¨À¬pýRØR½<s¶üz¡¢@!^ë<Ê™„mu[¥Ä¾áUeV %¡£Ò|²!\‚lâÉ`)*#Ÿc ¡›‰̈¥'Íæv;¦Àâd¡lYΧÔÿ$utUÁ¿Ng(—­BâŒüŒpÉtk¿ÁÑÐ,Öø|±&RPXCÏBIÿª`‚*u‚$’½pÝÛ²²HM„Î<h1a m;_[Xê†%dªB/æÑ×rcMúç´`þÛ2\ÅŽcÌžS‰Mߧ˜»ÜYŸz~U «¾^%÷•/YX‰f s}é>'3üøË‘øþR'Ö'QËLi’27£‰/GJ‚¨"éü> VÃp8·ãá(|¤í}w Û£n::h¹â·ç…g]²~ È?ñ¬H"diH ^Í&ÒRÅ"aåëˆÊíú „Ž ˆp:“|Ä& ÷°62¿ó[MA`2�a&/³ V¼­ÿþO÷—ú+2 íëçÖWIêÎ)Q”úS‘óÊ„SÌa&¸ô”—n>O½}Šì 5‡¡D5=ÎKGZ_OFÚöï¶uóU¦Ö$ÍÙcrÐòš…Õäôßÿ2ˆ#,uø5Mh[$L…祖sd' Ï;Ís§t‰ÉiUÃg®Åƒq_géE$ß‹–ߘI£ÍäFWì)zÆ!ýæà#X‰µ$‹þ`ëÖËöõÄÙ~úâ ~Íü­ò gf!Ô°º½˜OO@=jQ ÞP4E—?Þ×n‰B¯£šâHCùTZ/\VK4˜w$~Q+…FÞXT�¡±OA;ž>=7XÊråÎ*÷m!œü¦Œrž9)¯Éç„&Ed½cÃ}ð¢8F«ü¯è Îußæ;¿ñ0ǬåÊÝ„1ŠŸÆ»I”ïhzÕ£±€~?¬\øÈ“¬êá¼ÕX¨q.máz´©ëmÛd‚ÅÌÉÚnãK-Ú4ò$‘XYwuHƒì[{!hÞ°ð,³ ¸½ à¶ÃÏܵ/4ÂDÒUÀLÌ Öœƒü¥9˜ àü†¿Ä1Zætrñ¾#o”x7)’ÕJ Xj¹B•à³uà„9üܳ÷³"•‘ ÿÔR«0—ŒÁêþ&ÁšWˆ–eîPX\R½ì@4ÄØÜ·VÝCØ >ójòýñ¦t€iõú`qÚ®#¾®Ï_Ö,áoY·–s§¾û”Jü£UgÉn|~#zi ‚!§Ò‘ ¡ÇÎ¥¤-‘‡ºïÖWýƒwCiâ MŒ Ce—évÏT»kM“Û<gi§u#’ÐJb ¥A³’Ô›ù­ ì´=&aÍÙjq׌R1„>Oxõ‰y‹ÉŒC÷-2N·j4ˆ·‚ó÷²:¬¶ƒœ'`mæùòd‚[$ýлMTΉäjª¨êÆNŒõ¹y»ÖŒîÄÙsûðCÿDÝÚ„‡ŠE2ö¢f9ƒ2¨/ˆïcZìSo2d#«™nHÞž<‰u høcf¼´[Fób]Ѷ7íóÌGZ—Ú±¾p³ÿËz©Ó„È<¸}d£žãP]ïæ\æ¯üã :Ó½aí y àkwÒÉ^É æô¦µêþá‡Í3¬XgÂn$µûh*@ÐôÔ/ë6ÇWÚ}W0 ÁMq}7^A¡;iOïòzVáˆý¥oÃ6»j.fð Zki—–µÒï÷8ÐZRÛ[6Úö\YèeÀº¡Öò*áX¿é<,É“)º(„ø ½Ð£dÖ‡M÷¶èOˆÎ´ÊaÑòÃ:w²HÎcGYŽ¾Ø^µ¼iˆ È°K+zðê4þkMi^¨x:è¨(±¯fÔÚ)-²¥Pü_¸—YÇÝÔ>}ól{èîM˜`ò\YÅÒêó[ñ>3f! K-Y'iÇMJëš(ݯWøŸ‘b4³`D˜÷ÿo|°š´R”Í°¶Üxè¦Ä÷T®¹Ó7Ha÷dRÓ5__Ê ¶C:¦^èPN&­’qè?3»öéS‚ó‹;¶MeáºXÄd‚´BØo<z�wܲXÕý ÿJ£çþP!NcŸÇFïznsJlΞjñ •@§û©90iHÎKï¨8FÔÞ Ì“4]¯¦T¤AÒ­=· ¥ƒÛ9)r1€‚GßZGˆ»¤k?Œ�—r}x¤}R}© (3¼³‰8ãaÓr6Q¾Ì;ðúÕ#1efýÎDWZÍ.ãÀŠBÛÕÿ½iÝû݃’õµâ(t{ÜÐ-º‹'¼Òý¡ÿe­è‹íÎ,yÿ²aâ7÷vx' ©Ý-Òf¥ ç•[•55³|ƒ”K–Ô2®<ëPÌ|+¶˜¥ê¢cïñ©º~ÏM€…ËÛRu±7w§Úgs¦·B)|ONň¦ƒ±Àiל¢Ñ£u£”2Î|[ˆ”Èt<*†‰uo†÷H—è‚ŠnôTÕñÓ?ŒÍÙRÌ�H†y½",€:Êå=p%¡Iá<ÚÐ;êö Å`VâaãzáÞÆØë>ñî°1+|?V¶  ;]Ÿ=g_Ÿ{ÞN šAàs·¢~ol’]«<‰J?Ä„‘@ì¢æ_+½š¢Oh™jqØ·ãI~GIæ‰ÔÓî1Áo µ¥ûËøzþ,4_ æZÅÍ?na(ß®=¯âIµ»’;¿'{nð±¶d¡Í×"`…GµõA‹Ɣ˞¡á ý¨�_˜Wy‘4ë¾\ üÃwñ½,ýg±\$A©‘í5mu:B¨Ú(jI¹¹ãf¡ƒPþÆ…O“yÖWìqª–“î ,†Ü-:eè×Ø~(ƗϘ‰ßEÓ›n9ºŒþ¶4¢ÝL§ýÎZŽ2åà(s…lŠ¥$ʼj9eOGs6Ì6×!{J:5mC2q¢4Œ=êÜ5ÏgÆ= κ¦P×J> àäÓQ<©)AP ÐVþòT¼ñóÖ&ì¶é¶Œ%}ôП(Q)F'h$VÂ=y©æ̸¥é~¿ëI9�¹¿n#%žó2G‘sª^qL¡ŠC±Žjׯ·‡Wg>³¿‰ârú¶¶³÷5³‡Œ„Å_)WKwb:q¾’ ˜Îb`9þõì¼/~!¬%Ž£‰¤ˆVáL·gnÝž´#m‹ŒåõÂdÐã,šƒ:!¤D«J¬ú è6IÌM*;â¤6¤ÕðÙkUIÇ_t|øíÑèÀj¾Þ; X¨•°-E;XÿYÅ@5 fÏðöŸétìÆöµ!Û-óÊ´´ZŒ…‘c×iDVúñžÖª‹h&ÝV´èjwX\ÞÄŠð#ÚSéT;4˜qõ©×‰í|ס=€hȾ”ÖÁGÜ](½Y¡/¡Ìs[Óç…äîvØü«9 gŠ)¤¶0ƒ‚v£Õ3/ÑZ£ìwc®&-ZC¾eÐN Õ¦ÊÓò.oÄ´ƒ«; Çº¥CÄÙÒ"ÄÑ[:Á> _ëîc‚8ß{xK˜¸žj' F;=�¸¥‘‡ Þ™»%rõú6ª2_Á“aYIÕªµY¬8×5v¿ÑG5.-2ŽMpôÍç8ȬŒ9ÌNéîgã錬÷—`ɼË÷ÌIehKFýµD*E ªù6}9 #pÌ2QŽÿn¹àÖwZ¼=ÍçË™r¾x{2�¨ìÒ™-7%×5Ȇñ4àœºÑ§³óW!yÒo‡"ÈæOÿ€íºÑÖgÇ->X_�"oú8xÒ¡l©uèÙKÓâ€ÃÐ…î¡MXé3"ëÕ×øÙìóî¬âòE+^dÞ_Ìý�޷òqÆÃå]S¾8óç5´^F¤îe­“Ø„íh»âÑUh‚ÞªuÎî7ò(‰Ÿ²‡9œ2¨¢ëko€oZ´tÜ­´G´: j{é.%èÞI*¯Õ|CAT¢×·9!…ÚZ¹çÒÁ³L„«¡Z3mó}µ]Ûï“Þ8E”¾®èU-”U}d¸5EAa°u ¤“Í‹,’¾þºö0‹-ÖQ Ì%Ò > ž"GÕ኎†2V:ËãævÝÇUŒ¼ ™ÿES¾ÍîùË‹¯‡3oY²Þ„L:íESÅ^Üóß+3ÿ}‘»ö€_[+«œ;vÃ’èzÞÙîí mÂ�韵 P˜™¯³S ߊÖcÑNž¶eX[À²IÞÌ Û~(ŒüæDë¦î”l̦ìŠ!'®êªjÊm»À]Ùú­JÝRbèpSäA<o\똶ÖI‚7}¬›_<+Rô [å<8ŽôUl¨Ãsæ†÷|8Z-^<ÖÎdÝi)Æ™¨L³‰IÒ«=%Ñ“%Í” vÝ–Ê5½§ŠuO +]LÎ�)>#>+b4´·I®‡6¹ê_ßU¶G [®Ñé«2Ò‘ñ…a¬Û¾;O˜ ôÖRRYFÂqOAŠNY¿ ÍÔ‡‰…/#š¢5^[«û§é¨š ¥g,#íÅ=¥†hvˆ(ø£Ó|»–++ëèc=ÌËóý{ ›h›”³¸Ôž½Ý†‚ÝÅZ›¯ÐãòS…ëWLÝéZqGú+2õeð¦k¯$]įŒ.Ùj[Eóé'ù.ð@£†¿‘Uo8ô©<’D·^-b‚zn²ÇÁò^8_8&f:ï¶ÒÊÉ0´±ià¹yq.Êìq È�ZgjhðÀ<Ä [ÆœrÀ! *k‘ƒC lÌü…¨Lœ8ûÁrœ[í‘ŠýãÉ ÞÓãŠ,»²0Ä°ž>#ÜNK ESÝ¢÷»>Ve>ÒéûæTÅ÷èI8håa÷ù!Ýôwmà Òçt! «¥]Á B±®Ôþ†õ¾ºsåÆâ‰ïyOñàx Ú¢³íLLÏÎ[ ±¥•+D"ÔÕ“ÔÛ÷/ üÏä?<Èïk mÍɃW±J¸¦Û*ûúJYìÚs9/Ó‚2ðA½"Öp¤¸DÕ&:Ž·7#°$ó?#}y*oé;×z‚ íºê/m7yB€«›1ÅÏ åÎZ]:õrƒ4Ò*›•ÜzWª«KŸÉ(x\ýøÞùŽÈ!Vo7¤A5¶Þ°B“ÚZIŒGÊ>ò…#ãqPQŸÀçCÏî„=×;©ïC¨­”;ãMé.÷5˜^‰Üê)jC(`(’tEåñG³B®v\Z\­—‘GábUþ x®}Ç`$øzã¸]ä™'˜ÙëWÊŒ' ¥F-¾ïÛ¾BŒB7s’|l8‚Éÿ­Æ?"…X[7ŠæÔÓúøÂY¤÷>¿4¤(\›³Ö×@›(?mÝ×� q†ÝÀ[÷õE-/ªÎ†åÚ-öØÌoÜæAñim”K«%j÷ëYÑi ùsî1Öí×^~š†Ž±2GûÝØ?ƒ§¿Øîy’åÎ8‚­U—¯3‹Ù× +† °£ve}6|¤Ð¡ÅQYèrÑÿ$±Š™ˆëAD1ž²“IÇ1c×õyRÅvX‰vØ­ñwëa_jñ»ªW!nWãþ²êš­u7ԧ͙b‹Ÿ¼±¿Xò…p!¢›ðýãU]Xt:O÷×+7(Â)0§ºWñL©UMžf'*‹Üù±2nè{}¡Å³NÀä¶MI£¡¢Òµ ɯ.{ˆ<Eùƒüâ¬Ó ('߶^úv õ áº> õ½6LT†>†vßb&:ªŽ™jÝ‹èooEç<DéD™/â³tjƒÂ¤á$wåæÓíÍÄ›N-ˆ_-Z K1fHgQ Ï>¿=º“•$·y+½rìÞqQ+Ü]“åÄR½£:R’Êà8„:Ù×ÿ•ê¼½ªÊCÏ{¶´µk=:\»¶µ7| ¼vŸØŸO—$È›Îç~ÁVžnÆeR@eßܼÉa®›b¿ÏÅqåó­CPÚá€eA\b»é6=×_ “èÆ/pغn룮óÛ´ð%4)íbÏÞâ³s·½îÛÚñKÿ³Þ4¼ÊúªÖb{"GXê€Åò UÑ¡Tî±¼ª@6]ËŠwÌ›*k¦,²ØxÜéϧ¢½�'ë}^ÞËç{{)ážrþÔŽÉ‹ùéQ¬·Œò'Ïô¸Â´W·ëÝ—‡eÔÖ¹®hOY\jÌá4{›tÚ"ó_Ô›iå·(hËîý­žÕ‘Nš"°qëÛA;=*}|M½1rÛ7àºÈ‡Ù@ëýD±vûí?Ð#kr%#=VV€Ì„H'rn\üVÞp_¥ÿ–I—U¥XŠYÒÁH› šk3ˆ­,¦‰>5Ô uÚ³øá^Ë1½C5Qº1ùimÞ¿É’/ZÓæ@aÚ 4·0Ø–õ„?¸ìHYûgBTv΂b• Òü‰óP•|ÓsïêyÿÓÓ¹x“(¥‰1`S©`&CÙª(ŽE”™y5Rÿ† U„ Žaô}–qn9OH0}møšÊzpcé�8Ó³m[ûŠx]º!VÁLÓ e Î ;tí}}CÑràaJûØ\Ýa\¸¼ ÞþÇã¹ËTà/xsí_ÆF¶½ÉË üÔ“+¢Ã�‡x=zŸüз|´èëC~S\d¾_c„>2½çpñ&o—îì# Ÿg§IgÎÍÈZ±õ„¡ï¸;šêÁÞíÅ‹¹|éØÄDd¢|fV¾…öÆU®ÒƃÜÎP˜ã ß?…_Üü‚ã4e|~fñâÅ?¡hAµXÝØó3¨®;Z5×k1W+¿è%"n…|2¦ Wdµƒ¸&¼=ŸœŠ‘úºE¹ºÈ 1¸X|¶`ú 7êéxbìØ S·(ö²x>›šâZ5Xî±æs‚1Ü­‘áÁÕ¥;üÙõO”´5m( Š:Kå„6ÀÂÔ–¹¬¼“ ÇÛ_üKt]<$7t†3¹­®Ñ24*>Ærñ=©PͣشިÞÈ(\ƺD?Ûô. ¿µ:PMô¼Ü°Tu-oiU„³†—ˆSJ 1®V+‹×ªñQV¹1^Áfzdǵ×vô<=#wØÞ»ºÎ( _�„<§3ÅÛ£Òá÷|þ»3úFÿùH¨Q©ü•ÿ­c, Ð_9:¬OýÝ\$M|æ)ûcå(*5»…GN7îTÚuóÎÅ9 e®­–û”ŽÛMgóXКžÊÊ9<ƒå¥-“·‘í½Âü“2ÙÙb÷h±²¢Ghs̲ÅM»›&ÇäøâIÖX‡GÖÈ‚<Ë$ ;UFæ}…·æM)YV•Ó«/ �¦Qœ÷ßì$4õàü£¯á—÷ª©Q8ƒ˜½¯d>_dr¹xÍ;ž)ijNÈÒ0\¶5}…ùÛ™QÒôGs!’\½Ü,£ÜSm),&>·st¨}ÔSÇÒ¢X¶W“ÿ%D¾ð$Ìxh9ÑIœÕ 1ÀU»Íc}fJŽHð<汤¬B‡S´¶V¿e¨à3ÔÿŸ™8Vþ’唳 ­mª„Éø÷©ëÌMd„€‘F|=SRxgTÎmÓÓ÷¡çeúv‘i;üìšs.5¾2ÿ‰œªŽÑË-‚qo#8Øq[‡M>ƒÓ°ÃÝkºá¢)Ç´³g Ca º²Ô¯ŒŒo²<&NX›<¤šßb\B+(a%`BÈ,�ØÏIœ)¼Ë›ÉNTz4†Ó²ËþRv<zèúñ4@ÌÆ0Æ!{ÿxªÞb\«¹ÂVqži"€ªm’G†æ‘.Í1ÒÐÿæÀPªR´ZN¢$F‡¾S“‰‰ˆ‡úëÍqfaÝ89pSœîà8i©©iÄ*x£Å]¾ô=ã,óŒIQ³Æb$ª.­,we<6î·2éaÂE÷^7 ýÁ½UC´økO…Öeb2Km–wSˆ—ÈË{fZ<|(=ʸ@:éü³svƒX€› E9x¨xE,óùüs‡ã~g1Yå¼$3l£m[xÊŒ5u1ãgKoyÂöÔ÷$Ñÿ±=©3.ÔQåöH‘Ó~­¬î‡–ÂX[-Å®ÿ€¢¢Ì®~Ô4‹“Ì7³Á:ò ?jo…ò?Úv'ä*=e»rL¨¶†ú®¼­×&þ ô? ¼¥k?eëd£Š•:{"© ß±~dP”.äœb´´é ÍûV…+ë0,z¢Åù)ÿˆ†ÀÛ€·XG!†H[çuÄ6Ϲ è£N‘áÑ:Ö«ù™Õ› SÕ‘ù¢˜Qÿ8m °À¨2„£Iä,W?=Ê2*OžE¶§*ˆr—­ßú½ö¥Q9ýWvvbFÉ�#ÅôÛ³Yì—Bý‚âòSÅ*ôq¹0ш[½q8�pÛYáÕfæÜat·1¹×8gç±²ì,m¤’©Hµ›/†ãÕ _z>Vy¸ôºE~«zV€èÚþ²¯ÇÿDš?w»E”‡Ž–®LFÙÏÈõlÛ&Ábýmk2-¬fÚÜÐꞎ5ÆYéàÏq®Ÿ³¯Uh=Ì õ ë˦7ês ;»wow='"^кKú»¨Þ§É“;¦'mE¶©ÖìFvpñ®�‚²šÒ>ïœ7$姣§}õE–˜Ó=÷°¿…ÏëÒ‚éÐïx·Ý€•1©ûíj†ƒù÷·7cm½‡´e¼õ£æ/D„Ά–rŒ^­YÊ<ñuM~ïûù¢|Á7‚c&ç*˜\w¤£L’¿šå.µà]ÞQÜL+0†yÝ)*l³oëÂ1le™‘í®gËñ4RÙ~Z¨SC…܈Cù³Ä…q)»BÔ=­èãÖAʦ]ã7NÏÆ'‡¶m=ëAП/4õçàVî1³i^êðãEQ:j€ Þwý~ž8ÿ$™¯d UÿK”?v 6@mÜÊ ûËCóò°=[¦®³ÆêÛûûŒ·S/ &e82ÖÃ’˜%™2Ïà¶]Rx®fcÆjº+y¯S]¾átOA°X¬Ìƒÿ‚½9/ЇçæBÕ˜v|G÷æsö¸÷2ó@°»ƒ}õñóÔËlG?lÚ©§Ú9Ðœ)–ôFàZš¦õÀyÑp’sê¶Ô±åb3ó‡ÏiÒ©:gi½-ƸšQRRa–ê»>§Y˜dêSÇJ ¢ZשÝEšYEûUmªÊùpàŒûºbø¢Ð0Êftk_€E²<‹P¢ÊóWú?±M™U˜´åõ/1Í3qŽ /¶žàêQ”Ý%FýŠ¾u£ê˜�<à$‡Ø®)¤œikÏ1Ž8 %7Á­%\½.º I婲0Âx¢:9¶ã~t¶9õ6¾÷3*£z!ÏÂ6bE‘)%÷_׶Ö ŒÜ†©µÑj6¦“†QôefË”þÞ±OÀ+ÿ1 ÄXÄ0çî— 9´0õE6åýx K ª! J°[:MNÖp¿,²CzŠÔ¸MÆØ"ŸÈëNÝ}s¼"~جHÕò†ž»ßðNâ4ô%ÜXþ`Òk €4}4˜€qÿ.þ'á£ßwª¦âúqV‘ºÂUp £õH*#›;l««¬«‘ºì{"vz¤uûwžþÇð2zP±@pM ­ü>y:®Xa«]?Õ» Âk„G,iÊÙ* .m •×?‡Ž^éi,@¹üÛR ØNcUŸúÚ ùq=fRtÓ 6Ž›õP¼^º¹1é–þ½{oM>)-Od³1žp±àv“²zî È4ñæy&lQÅÍR³är`vf„î8óQnûÚ^‡3„;®¾jÉ–xû0(7J^XQVEI”Ø@È„$¤l©Þw»Á¹&€X¸¢ÐË&8W^Ý™ï‰j@Kߢà®$$BÖ�Páî¾[}mEòâqÏ%óØ|²´}(€ÂÌÐBì€2»H42Ø6é€kø` Íðh%Èaù[,.tß"ÃÖýÙxºŠX”œÖtÉ‚ºåèþŽµ›ç™ç¤G´©Š Û^<V+·óÁk YióC¨æÎÅx=ýÈ‚Ó(NŽÐñ-ܲŠi‘5Ía–%(ìAw¥ ÒÍ/€|Ðç#lIÊ,òŒNŵ_<î Ò‹(¥ºA8¯«gC…¸Òàœôy ˆÝð¯Ù)ôW�ÓÅNŽ}ia#_éñâJ-“(ŠðIÄvº“ši-«AË4äBÅ ÿ±qæÑ ÷»ú ÔB+pÆŽŽôúd55³@M,Ûº´!wÓ}“Á¥¨+E;™Ø­{ý›‡ìÒD©Ö£+R-ÁJ¼®ô_dRÝ~a ˉªÖª ׆š”Úæ‚ 98žçsÓ»¨HœOû”jšéÇS~¦#eœxôjþÂiÜO2´¹ó ÿ“ÜÈG•i‡<Ï“1$T8Œ5tùzO¯±úg„¥©n¨ƒÐN¹Ñá§!±¯¦cN¼;'–û¸ãÖ—¤¾68,³?½sä2¤ÂÓñèTEÙs”ÄÌ�ç £Ùɶý¸“2~ù¸Š`ô<Ì‹˜öôT0qà¾ûKÏæ\Ä iûöpš>z†I݇¹õ’¨l/_Ð\ÓBìU}æµð„« ?g»õÀêm‡Üdø•nNì‹>Æ"Y™Síj•E˜NwP5ìß¼µóÄÌaƒá»‚>×À¦g„AsGB`œu%½«ý“/Üqi9ØÌ+E)8mÙm·Û›'À›A·“¹¢jö.)Š ß®¾cçèO4z6žÙânòs—ÌwB¶žr¿QrŒ*o‹”¬ÙÁÓ0+JGl5Œ[³,Ga·à@«Ämu Aô@mzT1«OƒÎÉ9X3TVZU ‡Š‚ÿÂW9˜Zü&£ˆl×"3Øñy ÝŸ\wZ¦R柔ˆ~f"Ç«ŸU}¶ô@”¬Ûq<Ä‚î“ÇÓMGZ(5@Ö€huž[*íTÄ-ûRmÑdZ†»‰RÞÓpE2³ IU_íQMD‹ØŒ‘O‚em*¤†‘ÿì†Ö'éõ¾óÏ;Äê: hBåDõDá —9wù‡ÙD†‰Fņ1»ËÜÿ¢‚²Ê(FÕ–=Jƒ¸×¦  ÊuÄÈTR“®eÑ|÷úŒÞäCP„„s¤´*?Õ.¯n/ëõxQXc}ú3Ýð®iΦØxJóñj&ÃZë°êÛ³ž^èÏð­ó´f_f@…S­‘›ÕŸ$ÈÖ[;]¸IÐõ»Óä¹ö JB`‹1‰Ü^Ü*ý.æáq!~‡ùdƒD)Ll)X[êp¦Ä•=`­á!Þô‘ë¡6ïSÓwíÑí ‡=ôqøcó·yË5ßs?žÂLÓ]ØŽà`*w»ˆ¨Ý°ëÅ? U4´;¥$w®³½üIæêš~ ìmz}ò}ôD\¶‡¡»LLJÒ oÚq!­${ØRùÉM.òæôÅ3;SaNœŒG¡i *Üuy’7µ·Cõ¥(¬økœÑtÑ>Ó?e= ›ÍvW¯Í; ­4X¦¨ŒÃÑ+:”Èòay‹-KÜ[Q“S|l£ñ±ðµN²+kE˜ùVà<,ʉ^Ûø&±;R™»ÿ¢ÏšnG3±@Ë_”4çèÌ°hùêa¼HÌòMˆ#Ù¼ö´5Æíe?Xµ±ž&ªƒÞ#©£$²á-ô\)<Ù¾+p]ãi¢›lÝ<­rë£ëGŠ®*´‹›³b,¿­86”ßG·ïeAÂß0pVôHác  Ë[ƒÛ‹_[ ?¥œîGb¿Üs� Óz’‚ nÌJ š-EU¨øÞ€jÖ'+H"Ú®f| xæš}2¸~6þÀWÔ¼Ê{Æ)÷wèÙ|ê3¦Õ(õÂRM=n ˜×º=Wçz¬²Œ•é€ =Ü´›œü^í©N%¶•Ú á®,1Ö~¬Æš† ñ,�A-l=!�À¼ûÃÙô GJÏÆv÷žUœ/¤ý)¼¬š4ˆG‰NÓÏnÜ_tòí–pçêFè•ër »ç>m«»µŠE  ¹8ã²·FçQ’Ö¡Š2”Ž­ñŒì¨­W:ýWò;yRº`cP³ÛäAÔZøäŽaÉk£9”Ôf‹ÒêËÊüxVP|2BzæbçÐZõ þ þ?œ*Œ1¤݈Ödb‹þ£¥…¨œeƒ"s¾xV>G€ëµã,¿S\§‰ÂýôX?!URKa\!ö_D[&¯]Owzzžg’Vgîòe'¸ôtm9ïÎ =©eF«@|ëápEøHLÈÚq‹mX(pR%ËËüOz9캬ð´·P¤¼·ü3k†ŠÇQ'—YÍpFJYòŽ™rUž€Ë«‰ôþp¢Ê–8¾€ÊïÁKgÄÙBܶ ~ÂÄ6ØAòÊvdÎ{È[ ±|-:PÃd[í�Šÿ´b×põ–?t¨¿$×1Ì­ uš»®«_M¸i BiN·ej=1–—t˜(-®<ëŠ:*�æVõjtÄYÅHÈϨ±_Ã&X¡Ç �Ðjo!SÔi3–¿‡h°é­}ÈùE Ÿo‹¥wƒwðMÇ·Åe1› ç¨'–u¬w^+ö‚v@y¡mã°yìù´]žY÷ãå–Åf8�³kSÊýöô»RÞqº 7Ñ­ ì†ò<õV‡ŠÐ­¹Æ4›ò‘¨”—Js§çÍ8£àÜ&<²Ò[Ìt½¸¶‹2Ùx`§[É @+¡3Ãœ‚ó–¿Öûtû8cOuŠ©=­Å²V%a¯8}£×ýíRîðvQ$ÇG”Ödä'ú`ƒ¦o;ý¨hë’¡á6tÒ6ž§Åº÷^  r½{¯íº“™ÁÏ¥bCãZõœ‹NVÆf°¿qv]8)´a<[Qãj?CÁ¦ú—c¤5 AsÔêp‹ï¬ºÏFºê#qQ�… ÀíƵ`ß®³*D ˜¥*ü‹"áî/=»û¨4®¾¦<)ÜÌîéG6ž`¿êàà¹záŒoÏžcµ“ŒHÇ‘ ¿F}´Fûnz^iÛÙ½x·ƒ©ƒvdmyS¸ˆÓzdÕ&'—';é&ø¬½š,,‡vO”u÷?ž–ò°Ãg®'{DI×é}àwê5#r–¬‹0(úÑš«¾=%Ó/ì(á4ÿ;ºÛXÃ|s–?¡ñYØy_ÅYqôݹéÈD Cg=MŠoÓãHÝIIñ~ÓSFÓX Ã]¿—lO!¼J“ÍXQgÚI­¾Ü–l•dÀ :è©€HûÖë8YÛ3;ªÚmšwg_)?$…%¡2”…”sùî7¹s;ð–ôߤæ>Ë@fL»#¼j¿Uþ¸ £báDÛű^àúЩ}Â;»K¡ˆ¹"ï°ˆrÍ„uÚü¼jlÊ%±&¯‡_�œòØS=+¹Ñƒ)~:¬ÍÝÖg“œ(+TEò·;Ö_’T~™ûòßbÌÈ-#U¢“åjlcì"+Ejþk2x¾‹Üì¦wäqÔñ4‚|íèèV›!QÒn-Ø’Ä—óHÀÒž¬‹Ê-‰òúðMsDj¨éL±>«{{vSÉ�³?€­[üј@ËiàN- îIS›ÝÙœ´1eÒv© “úáýÉÑè줲×ÈõJ‡>Ê–6Ò�sPÖV™U„GÈUª°ä´m.ÿ´Ý?}ýÏ¿Œsù¤Ë™4d¦Æm ¶—·¾ëÁtÔXîÞL{±žG¡RÛöëe`…›Xl†6è€õœ|*犓õë`XùìsÝsËøøÿ‰gM’ûP}:oÚ: «8»¢•zYø|—â³Ñ³Y¯]ÚÈ" OðæúNéX&™'u~ö‰–ùfÀƒnfÏ(ç¡´Kš‡þ‰Oazþ®‚ì¬=^VT­ûy·’ï|˜R” ‚BÙ¦?n„ªa‘¢HIQß 0EØ”[~ô;”„l d¾“`š!Âð€÷ës–{Ê_?5%ÌPŸðÀç›XÄãþ‹gu*�:9Æ=¥}ÇO±…tëò¥\«°óžìNæ“yÒ¡ãÑl߈5‰Nc×+'ù÷’ƒqáw+c«ô¯ÉDÈÀw#K[HíR=èͯÇ ¾XÏ].ÒäT¨¸#5õdò›Js«Wé9Óœèký }:×":ŒãäL-ßÁÿ[*FT™ ÚÕ±¯ï‡÷–’Ö:,îX•ë©tuU9ðaÂ=€»Ñ!ªÀý¥a?E (hâÁ«#/Fî\I±ÛÞvå1ƒl˜»*�÷¾©h{]ÝL|Z1¶r0<^õÂU,¿1G˜µÈý…Wn’$WfG«uÓMk=k�Šè”C§£q{‘Äïõ"µ80Þ3*õ~þt½q@ ”íù¦¸{Tļ¬TdœržÊ*žêÈ&s´*¥ƒJ쿹fË…[dH‰?,7º=‘-:sz«\Wÿ±Ê÷ݹ³ ‰_ý„_†KÌäÐÁ@gR%WöU64>E‰Á¼¼ð5O*'¦%Xði�€ist›ƒR+f!85vÿ^xwÞ›WNÊ F½‡S6»uÒPûZÁ¶&w§ÕŠq*†w"Çe/”«fÓ >IâŠ0ÃF-žË Eù¡ÿ¸°ÃjýÁs9Ô‚–È9Êb)z5?&ä'Ò‡›ëÆú!°Ø5OÀîÚƸy”  Ê`èNÞ~™õ o‡¬…ÆÒÜxþãøÜ%aB¦YýIƒÒêŸÇ²Çìæ5 õtkÙºcJ¨ ßد€ŒÒÈð¹æÂîÞÜ+Ùb˜ »˜"H,ˆÍÄwxØöûƒŒï£ý©¯EÛ£ÔNîÐ:£ò>Rcì.èbwx׳ßòÓ(§‰,?ªáa¤Ê¤·žD™’zÝP¥Ö³wu­l C£Ìšrbå¤ù(Ï-@à?€I^š ¨víuµÒcÄy¯T±–ßQeä7Pãµ"mÐ,µÞÊî]_Öö”>êÖ—†z·ŠöAvÚ¨‘ú1G ~H"ÿó¡ÕhŽùɸ›ì%› ò*Qó™§$(­A-rRfœòùÍáƒÝ%}¿ëx݃ŒCO¼•ÙÃHÅjÔÔž’Å¡0IUMöÏÐýÌÿÐÓ2ª/7¿’천gáUε¥b%zÛ†£CàóÐYIly'qÚ}¦åš•¾¦%mÇݦbãs/KìõäÂþ€&Ol®~ì3m°ò–-ç~L¤ uìé@°V@¨Rèèàcºco¼åì…åÄ=ü… æG*~¸âleÀñÕ[ÐÎï’¶ÈÕ6½H}©hxÁf¤ÀKu,ËÆ|&:žœ4îß©¸ò„Šw°Ú=»´ŽÇkmÇIÔ�n’j‘{¿áÊ8Pnlæâí6â“öv ¦&×ÒësŒU×y>žŠc§=1ùnÚPUYn6VŒaê:I-šÝfÓÃgµí~Õ\Oâ%~(b+ÂñÇeà0õ…ÕÓìF2*<#AÅ©¡€^PJOw:{bÏŒ¿l^ÿ~—ûI3² =¡Ž"@®§¡´!×´D¿‰U²Ê烃¿ÕÅÝ Í1ÛO”¶xzãÜQÚ ãQ~z˜/–¡/ß&Á9ÚPäÕ;S5`tü´ù˜U³ìt)¯‚ý{€eÏÞ^zçšR¬uçô‘ˆõY[4ç];pºÊ/×¾pVÐ8A“’†OÅú1Íõ0yúƯ´¹Þл¤š„B­Œcl¼Ý1"åÓA=cX ÕY¸Vþ¥À,$…p©„ûN±i¦¶5½éبHZq—©÷¼nS$ô[t´°.‡œÞ}ãµ°hŸ%Ë2Ú»ŒE;S¡õ%ô\\rƒ¤ÍعÂ;1V—¾¯—(Ú§ëʲ]é=é†@*'/Ê<D|èO´ýáôõ®TN¾¼x #j Ÿ—¸éiî»yžd0v&½yh/«ma”™Îî<Pâ6Gç'¿­Çƒ× AÝåá»>¸ñ•_–MTÛ=wñz¿³í§î8öþ¿ :n¸Ztuì§'¼&愵qp9Õ,›XpÂîtÛõÜ®¹Çw^˜\0|çðC‡GbUæƒ{Ú·ã®›Ìl•ÅW�Ù¨ð5Í!u0Ò. ?7Nn C^:;›þ°Qå2qG}˜¤¹o¥®È›’©(²í€ èölͧݯM"§\%:ïOtuœ=Ä#«zß×S°¢H&/Óîæºos0°çóßøÚÚAl:½­àLln!CgFçò¹e%Ö~À*‡ùï?Y�)Ô~b^z‰R°Srmî<3}yÝ°*|{Æ ¡y˜]z£+Ñ!Î"hƧ&ô¾Ž”{ã®i–=B&³°\n@àü~ë¼#ã¾…óVÛö~ï_.qqv¢“¨ˆžÑÄ Ö¡kð_¥<ófî·oz·žñ!GÅ)¥OÝ•píDµ?ÄEóé6‰ýaôI¤¨rÓSb;’USÙú¤BhX¨+.ÐÀèàm:`‘w½1B¸€ßÎÃÃÐA¥sl·Õžþbwq ¾ÔZ{öûrGð=½ÃÀž ÏXÄlÖ7Î3·'$âøò<®#©í*¡—-óó¦ÚЭø º¤–•ã– lwu<@“Pþ¥ÜÑáD°è\û ñ\†!6úϬŒû—ôŽÉb˜T1¿šì|›³ãì«NÄëÞ€àG™×Ëʼn¾Òa´ñŠ¾»ÖpfþI?ñ}û]ñ—$H;Wû¯4 ŠA[Wl]ªp=/1¬Guœ¬ßÿ‹goxØj‡ñîZ-¡s4 k@áåKt¬à#5˜Ë¬*m˽ôW,»¬P·ÁÐœÜi‡üal³Pn+Œo\ïÿ¦ÉzŠŽlƒy<$ôg;¸Ï�'6;yé;·° +B_¢‚¾ <Õç§ÑM£%­ÅVÊÒNxÆ9ïïXù?Í”P:gYª� ÈÑ Ïx>À1ƒ[·ïÃ…lKN·€«�³•¶º‰|n·:Ô¦«Ô 4W4„ÏÆ`íA¯¼t™4sq:K?GÏ Âût€(¸ódoÚ˜/¤GEÞöSj5V Qri†@,”åäÏT,_îÿx‹(=[v‡÷‘§ŽŽ¨tÈ-žó°¬¢y}lêçf¡ñêá‘iÕ[sË\ md&ý»!©ƒr²âU˜øìÇ=5‡ýŽm¢Ì�Çà¼^ümúÊc7‰—è<Dlà:uF'ö/Ký"—Ú7L„ÎÞ½çXÀóúÛ+\XYO8œ2ÐgŒi?oõ„Íá‘wÚ™óyÀ9Àû×/º Nœ³4Òí@Å0è6òWè ôFŠ)r#RCÓ”¿lM2u½uÄ^Ti>ˆ‘9Ž¬A˜[•bÖ¢;Šf§9¢Ax#D¥‘©#SóF{dLÝÆl*�ŸÎ ×£÷7ÀßÊב§Û £%XÎÚª9ü0îÚÌëïtäõæËÂÕ<þžöðÝüÔÖ<Õ=B¤u h”K;™ÖéË-Ú£\°‚bX5ç´Wí´¸Pš({ãEoͬò¹PoHC/™gõ†m]am§[±áv³µvlÙS‰ˆ²;ÕT‰Mï–Óƒð¤9Xj’¹¸>²Ã³¸œ€G ‡÷Φ¿éLfq•-mVºUô'(>ÏæÎCí¦ÿà¿ŒgõŸÈÀ6óàpvëhÙ§~¦²ä{E0W‚íÇÊ©ó*Ħë4-Ær×&ÄãC¶� ã¸tR´‰ÓÐü/¥hcöñiê+ €NŸæFp"Šz·7¨"f9µéâV:§ÜÍx¢r†jGá @Á­ÞÁ³É¼Q‡þás ämE•èËÛ2±€ ÎxÚ¹Ô\eÞÖ;HM&jT@2ÚèYvµ‹ˆø´>¾Xe’Å2éÿ†mÍ‹ºqÛÌ#†å=p°êÈF’"Kå'ÙÁ×P³ïKp>ðk^ì†ÍR‡€dæ«:óð›£chwXãY—ý÷êÎEæ—m!U.[Zï§Æ³¬˜¶õZŸTÍØèÜ]<dhñß Il>-ÆÖxÆÈ}¢ãü,Iƒõ_å¿høTx¼~ãTøSräÓ «uªYÁªë²ª­B“D »õšV:ZÃpò!0Æ5ìqôÕ«d†4³ ÐÅ“?ÚzN¤Ý™?#$³‚¹ÛmÔ·WÁƒV9Bx‰EFß“ºîÉ _Ëk}G%’ÎÚ²0ɇpìZÚ”ŸŠv‡hR Ý8 Fàz¿¶Å:Òb¦õZ}Ÿ=¾9fl§Ýt¥Ôðh¦ž—®Ìwõxˆ¶…¶\jhÊÁrR6‡I2ø«×9vGwÄ5ÛêONUÂà‘mQ²¬Z#¼òðÉzx÷€[+Ñ>,»$ ŸÅFÅlÅŸõ._næ™ñê@Ã\UÛ{õ¸ô˜¯ê›9tÒпÖòLóx¸*_çÚLϵŽ9ݦ6€’oj§•9íFv˜¡Ï¼Ù¸ÅN‹WŒ¾jÚç[Èb%&Æ’¦gŽ¦kݶ>݈ŽØIJÛ¾mFJßèP¿ç±i{O•‘Ä_­YŸÄöâÐn`ʶ1ÓXØ­×7¯žŠpàüMù^Ø,:ç§ Ð_Ú„´ž<#ÿq–Öš¬œ6ž}’ tÌ`z ½[™«¾ÁÆôÂ{E 3c[[ÕI”ÚPÕnÿîÇμKƠԨȷ¸™‰Ê½FY¤™D>k#ô òá®Ôa,"®2[ôì#KyÎØjãag>§v}…utÇZ]C‡â¸ÑLuåȲSnØêðð÷®n0òÕb®C!‚)¦ãÙÁCLïü­rK£h1¦‡VÓD¹iµ¼Ž+ô+P>jK_ò;î>TäVL–q6õUÎVM<¾'Eãþy (°P0fšBîéX"&‹Ô§ôç%Ìý­aA²œˆ2õê~ƒ*jAÍ…ÕŒ¡�ÌßÁ°–aëßdó‘7ª,× ;ñä¨ß’ÇÃE§û±Á¢Õ|ê7Yã'D±õPMw¯t)‡©;bÓi¨–"D2Žó=™¯ð o¢¢Âcêð¶ÙŽ´’íŠ5OÆ<TÚFù›­“2/ìßȤãSñpôdôdŒEwAÍÚ´A|ïê^Ó8K¼3#G±±‚X_ò¯ÕÓ-½%I¯™OQù²^ ­ì1°»ç}kehÅ“öýe«éÁþÐÓ]=ý(ÉJ•ÞòSoâVâÌ·i¡ðì“ ëÎÖµýãŸ8UC5: -+ðï�cqæ†2œèÑr)HæÍ­­‡’Äÿ0ªçê`$«ñQF™ë¦/éæ<u~äNU`î¤MLKnb”Ä5/3¢Ã«ðaàà®u” ­Ó\ØâY}Y£”eËà‰Êêò|¢ì†r×4HúÆé™P#µ^oÌá»~]xRD¥ãr%Ìôø³Vÿä„‘:‹Ð LÊôl’æ_ ª#Ó[Š #­| ~íÌTUVU×ÌìmŸû,w¤ðÒ Ùbãm†„…jªÐ7[JµôOßýCQ¸?œz‰—ÑBfŒ‘€N-ã«ÉÔ´õ‰ +K˜÷.߶ *Cß*ˆ>;e!Eõ½‡Æ«û5H^rv=ðmh©yW÷1A¥Gžâù怹U­ëÈl™¨vr¤T}÷ßÕHÛ믿qmíªi-ûø{ �›Ú“M¼Pĵ/½èª8ô…%àWq¦ »é+ðÑ"`æå»>£‹Z&²@ˆY.ò4³òÍð4†‰núd‚¬„Jù÷ŽDJâˆѧ: 1¼õ¾9k>Yò¹tž†‹GC=[› ,3Lô8Ò6øì<4aq.sëSÏ%Š¢*ôuYÝk|¾(=&ÈJ›š˜ ˵V¹Ä_cõý‡ÇîXÛ‘–ÃVӦݟ‹wÈíöƳ²ïŠ?|~Ê'JJ4>™°’¢ßoÑGŽdz<µGxß"£0ÎUC5ª{µ@†š€²åFàÄõ¥¿ð I‘F Õ_ªPvIѺǾá4 ÍÐx°È‡ˆ²cÓ¦Ïâ úVmŸŽ ü0õ·ƒçX ·©YFwÏUæª"ó%,CV>»ÔkŠ?Y©ÊÏÓ\Ï;¥^ÿNS´ 3OèÙÃTQÛ›?ûgÙ‚]}Í×HÑ ¡ê{èFeÒ>SàpYQh|_΃M†É!öL¥ws>iÍáÌ|¿~†“;ßÄçâÞéb·PðÜÃ)tómh¨•d9© Žï-ž(°©"šP­0 5 .É2Ž™›u‡3Ó|üß©] Eeïè>Á5ܳÁbn¶),wû£L;Þ¾CEäãžÁ߇RjÜ÷&ßæŒ×xÖÌãiò· Ó  µ{pÊÌÎUØêò¹8³;j+gö¶) u0‡'ÝæS{f-¯T™2¿aØ>òNBX=uBLÿÏGšST³¢e Jx>Œ"'Ž<-ÃH*£çò:GÒÛZ0¦×ò7l‘ù NÈ5E52V~Çä«g,®ˆ±ÐÓÀj¸~]žZ˧‘`I¿mœLÄM Óy¥·’äîà_Ÿ‘"IÕ«l<:Ó'uÈGCS͆ºçÜþÞOwpª–'#exƒ1¤ˆ”ùˆQ…”îéh‘2ž6Íeñï•÷iáÄ8%á½i<Ÿ¿5;,´5~{¨;ab¼[[x¬%öîKˆïQÂíL, Bþ>Êb:LfôP› V…\ vÍhµ:~&*«Ì—ZJ1%+ZO¹49ÚÜSC2U,æÓ›‰gzŒÂ™ó\É”M9‘¼« ñ!_Ðæj<â¡';× òÔJ¢GYCŸxäõî§à7Á|Ò»zÜ^ ô™—8lÐa^+Kˆþ”zgÁsܘäýÊÞ¨(­HpÑlŠ~N^¶ÃeÕ¸TJÄ–ª.S-ºËGèÔ(ó[Z¤Ã|9œ¶nPKûªAñ(íoÀüά9©ün„‰AI7«±RV!/§ÍA :J@][ïFàÃõ?ÑïFë^üK´Eª¥šæ3•‹VªVBÝèÒ~ˆ(ËòtW˜�LPJ»‘È}`W‹gFbå"*¨ –ÿk†ÕH9^dÌ…ñ¤ô£ZÚþ¬j<â Gÿc‰ÑÊz께Ed »P¢ŽT¹’×ÚÙýÝ+¹5ò %\~ ÔÛ¹¦§¥›Ég]ÒzDJ‰ ^ŠV4.`P•OÌÏYjV§w®å?Õ?LŠÔ—G¦l;¯u –5žœµù]Råž©9gÕlàT¬õAz¤/?¸L÷ÖÂé]3'[ƒs£3˜[ÊKbË1É 1±Œ¹IÏ”£K] ÷%:üĹ›ïW|³­·YŽ éØ‚¥L*XJK 0ž—º7°_Áð7šÐ Å¡!øL<Þw@nV`0ówâ,EµdxòÀZÀª ²èpŸ/¦PLœ”0ìýðP!ز«¯9è Ì]5šI3Ãｨ¡T@Nªm¶m¤6…«0ï¸9ôˆ5ÛSKɲ9f[kYò®œ‘ÐM8£Y¸Õ1=ISModûyoì…'ì±4Ç‘nÀç·7ËÅmøã<%¬wõб-–t¼ÚAbeoÑòÞ³¾•ˆ ;àÔ-„j1O‘0ur¾íѳ륲à"ltCá¸Éóp³†¯ƒLZZgp3¸ÛÆAÖ*<‰1£qÃg"…›N9ê¼£Ù¤®ÃÿÉ2/FÆh쨕oÿu±÷¤™¥ÖÕ+~xäFuJÌÀ¨\ÛÛ ÐfŠ!Ç…»“Áeè¸$6ç+#8Û¦Ì`RI(²fúØ۲ᄫîß4$Œ2økÚ¡ GœÔÖ’9Qê$LíµX�º ¸Y}}dü/¹¤ìBŒß8éÚ)Öõ«hsxœAn³TAÞjµ «|Ù€•ÞåÁB4“3”ç"<Œ#*ü2zoͶ" ÚèY&æjkŒä(´…÷`Àƒ[‘Ú[±>,-û¸i=‘nº¹2m0ñãê7ö?uÅb+à/Tß“‡_½w@3ʺ­V_00ÄNár§…~€gTzõ#¯¼>©<‚nÄ6Ž]Ëîl‡q?au¹ teõ¢ÂÎROK)dN7ÜO ¶K’¤–Í_Ëu{;ªªÜ](žì•h¬îVG¾�ŠÏ.EÖ‹­G‰ryxòÅÜ)Ú‚BU&ú€Ü²�Î÷°ÓšÍ1£E£œÀ×Kåþo#%Ÿ¤/±ý"ŠL­QsäÓcß­ëZðˆåG|Ç0ráÖM'ñÑ;zªÈPËÂ8EaÊï ¦%IÇ.)# *â§Æ“Ñq”§¾þ ZAêù¬¼JŸ=sB‹ Ñw ¦0òï(<q‰²Âï*6д?gFc™mʹNûËIVìÁ¡"Æ®þÐÉ ¦Vb‰å×^‹Î;M/$ÇîZÙWýš4^¸üBWŒ¾Qy²LðT[óöþ¿…Ê®µº c”¾ƒh~Rð¶ôlWWÎOCEÉsçÈð›ñ0]2Þkq<´Ã΋ª¢ŠÖ:®¦ü¡«îb:bë=?7Ðä$öO÷—Ÿ<r1'3›€"Æ2ž;4ˆã¡õ@²¯qHKñ tòÖ´LÂZ£e‹Rž¸f[+âÇØÁ<Î|QTø¸² ¯U¸)+€^mY=߬Œ_<@×AÅ@5ä •Õ'îДÎõNŒŠ“…k Õ;užù´°ÂÔ<t·Í‰>´wõ\Õ;óѤ úç‚v³nDà2W5³ 1›5î8ø•-†XÎ ýiëÕa<ío}ÒÄñ]xäwør¡¡ËH˜µ¢Å“ _kÔZ](z—lø,6r\™qý8·Qä›Ñ¬iúXóeìfØ”Áÿ{ÊnÕ»X[ׯ7Ÿ>÷X\‘c$Jÿ�©ñœ¤§ÕXÃßItµ/µÉ7®~ôÅŠ…SeœGÙ@vÖj¬>%¶ãa7³,­»:_èε~㺒dŽÃXàÌ6°õêj®S°`wÙ@x:bzgtè¸Ó.íG¸­hÅ®ïA|“j!~@iAO1Öb¸Tî�2Ž^¾ÜV4EÀ¹t¸,UÚ»Ï[0‚ec=gKùÖ`¹qÖúšó 8^ù¨{r£9Éõƒ4k¢46;™ ™‹%}ã‘*ARx'wÅEÁjª³WÖÜ:ìèû=מ¼²5¥¨tö5•Kß'¯¯D7~'îé*¿:ˆ´ÚÁç—Ôk..ã<Îœt2ôE!ÛŸ<Ãv )‡¯}wžÞ+û³lQ¤çôY³ ´²Ø3˜;>8r Ì^ø~^7™WË´éLÉhpn¤¸Ýµ>ˆî{QX¹#9œä±¶¶"ÔH«1 K–NEc÷Øaß9R¡ ŒØðCÑá8)2r•dÕyc…O�Ä¡ömà\ÛCü&›†PŽ[„\ÈzDãŸÉc7S?ÚÓ«-S·÷Gʹïï‰vp–ULL,DʈÑìŒß_¦•Wê›ô¬Y]}3‚§@êïº|ðå�+šHÁ§ûYºFCØúr`.yîLÇGÙð¿ Ê_n~¾cÒâbœªf55Ý¢¡u'ÀRÉ—ÿ+OÚÂkê1“â\#ßï $ó¨¾FådGvçk‘'Žç™GÕ,¸ŽîŠ îÏFÁ‘ÄŒýeZðvîUP;õÆÌ›cSä³Âxˈ ¸£ŒìØâ ³ƒÌ×»F_aÉV“D Oß'ÈSx½ëÇ9glQêA=õà )—-*èÉPl¥‘¢3{L3)#×°lÐyK‰%Ô‘†õôëáŽøaä1 Y>t*² n} CÛÖX…Órbš^Ü™O«¨ŽÈ¸2& %Šæ)èãlNTlÖ,›$ger_F™Ÿ{YO[$qáõ¹²mj* gÛt¥e#­6_Üý¿ß I˜úªrôw籤tc¦³©IOëÿ>q«˜¾0B­ˆKÀÀ·qß-´¾Ê¥ñOqgZHÏÎg²–yûË|c_ïª;ÇáBO‰Õ|2àÎ*¥µ:pc×¢·ç~«PÎmû «†EŸ ÔÈ"¦N:í³¾ ÞF#cex)�ÿ̸î ÍÙ‘ÍÂñ‹NÆÇÄÃEçëh£R®é$¦âïœêÿ)ãÐ …áCôDN¬ ,kË `ÏYWûã–GÖQ‰³’C­SC§µ›˜Âº(i,š€)¦®NºúñéL’Œ¶wJdõ‡N†æäY¦/0ƒ–ZømždÅ™3°)«þ)‚Ò©ÇçÚ!‘šfÛ5ˆM{¹üéY ›”J·Ð2°¢¤;{LÉ c“ÑßNFmæ%¼ÈS™ÆüH?Ö“ Õ2×vÌ RäÆ2!{˜˜9cž •œ³^±'(úŒb”_jÆ7ɉMæÂê¬àÁ·ÜXâ5ëv ?6(=3”¥éjàÉ.WvÑ/aÞòEfgáÓQùvP)©Þé=ó=XátVÖ´gnEb`Cÿt^�dz#+r‚éG5o¥âŸ‡°ƒÐ`EBªÝ4¬íë£ÂAªhÁjŠ)“¬‚lž}“�:sL†ÒE'šóünòÈ{ýJ¿ S¡º]ý)‚bÔÜLpq_ "T ~Ý3´Û�Ùìœ(Ò1³ÿú¦Q¶ÐG · §îïËQ¦Céh×ûך‹8Jâ…ÇV—é4(: dI‰–æy †~@“ô&ú×ê3¼dxK˜ñiSDó¤*;ážz7ï·¨91&†µÑæ3büð¯Y&.r2BçÍipòëŽgžöõ1¦ÇR­£êÐѺ+dzoÒƒÔØéç±EŒÙÆ ׫˞rä=úBEzÑ–Œz5Ž‹¢ „o@Ý«CkòoÁ¼&A%K‰ ¸e]͵#Sè=rûBrÏÊÓs—¼jïOÞ³Ü×¹§zš„Ù¨=Ì=-溣ÿ^k?Ž4 M²#-Y ßÿú –«r”nÉ b°}P·8Z9„ŽïdY�·4lèþ´ÚŸaôsÊyúÏGJ&÷šçi'B|‡c'‚’±#Ëx!º›Q‰˜aÇh¾Är¾]‡ÃE“ß®?bÚV“»Ú¶yCÞàMN 8oõùs/`†%×€X+ÝJ§¼ª¼Ëû·î ³‘Å,(¾m‡—-¼©°0 Šjo\LSq‚„„ÛTq’¨¬Š°eP÷P=´ÓÆŠß…óa 4Ú1u –wu[ÅY^©„vøÐv"c.„ä䪀|2 ±NXy)_Û–´×t�뤂cÏ,f½¾ ÃaØP&r&ýÂçàC/Ô£ pgµ§×Ö2Z‡_RºdÇÿïÿØ»J:Ý’†,nÊMú™d ñLÖÛ¦ZcÓ™ÎÁc×[±>AÙŠâÁßJrF fŸFAÑŽZÀDà]Q²Ä &`œÆ=§ ^£á©!2‚ê 1ªD¦_ÚvrŸz,a3Ê0 œÈ‚aX*YhÓYÃ$6a¡êÛf§W2ñ�ä¡£² UÍ”e½÷áÖÏ!•‘½e&+¸Ç›jß”û5” n[¦ÅûªÓ[x‚Š9;¶ÐûÖ C†Ù�ûð§þ˜¬Õù~©L%±|¢UÛý°Ñ‘B­{È!PQ}XÔ)ºŽ5kËHk‚{:¦>¼r:Ž=Ñ\.‹WàzŒZÄãžsèĆˆ³°öB¿y«÷’)öiLÀéÓD†Uöê±Fè´2L’;;Š³Eïƒz h_Û* zªfÁNtòÍGë°wä|½`êäñâI_Sþ<Yê¯u'Ý´”8èé-‹úèY5K±¾VèÎçk ²™ X –´Ê–eLO±:b]#cA|¦xz榢† úˆ»¥²ç¼r¤#,#» ÛúÀõÉœžB~p£çبªŒ}ú?Ÿx§¯žùQd\ÃrÕ–i’ ù´Ã±³ƒ¬Ö®àÜ úÒЩö…ôûZAªr’ 8Cœkø•9b­r‰ Þ»²Ñ>tÙ‡enðõk1P]9­˵õ¼«;;"1,%S– Û“´gOïp:í÷píE_7н¥qï½-Ö#S'ÎÛåÆ Œt@M`zéôî þ’Žo¼„øvËhéxH¨´z4è©òY‚íÈY¢Šho©NG‹sH¼c}^ýD›ß—ýå~öž–ѧØ÷´ 1Ü„‰JØî@Qè%g£H²¥FÌ ÆÍ7cŽbÏ Zž0eåAò£±ËôÌ9óùÏG˜0(¿öˆ~Þ•Í,‹Ätª8W€tFG8<œ)Òî#n%£ê5s¿a´d¡ßÿÅèN&;«ø#%˜ÿÖÿùˆ½Œ¿cŽ±KÏÎßV°qžd>00ÃÁÉØzÍ8†·qÃ9`îÈY_ÜUù#Jf9„ –ËN+hàn­‰CVyíMnôOpíUØss€X•’yʳåÖQß�Í<ÀY.È+T\0¥ØX4Ž6Óœ²¦A¿bõGQ¹ £UÁ>¡{0icù¸ˆagº…k·îŽèRéýÁ7‘4ùÍ„ÓW>( ÂóØ%t¸ªUž£æJ\¢ÿ¥vP?XM——¿4Œ£Eô˜& V¡/³Ñ;¹…#ÄÛwhÚVÛ¥<NµÐX¥Çraµ¿Nk ‘åž'ó¾õm§| ɽŽÜâúŽ„±:RE|:P:Bkfì|cZ¸…Óâ’¬óp<²væ³¾d¦ r¡ qÜH‚|sr…˲¶ûëÛo‘{²±Ö)-µA§%ÞvƒÒ°Š| šæôYÇ-eOmý±º ÀŽÐ »÷+ƒœ4%vÎ(‰rõòóÛ“^é« Õ"µß£àCi)åŽÇ�óéÖ"z«Àóg4¹ÄïÜ<#J; Ç|JY˜ª¦Ãq=ÝÈžnã JÀGûúLÎƲ™WÅ>|yÍZæ%™˜FЭ?AÿÎÚÝ(+Ù ­)bÏ?V Y»cLGÃp^lNE¨6‚*‚é´ˆˆhAôn»IÍÉo)Ëi™º‰3 „mÁƒùÖî ؈_·œ>nÛíaÖÞíÂ1{„¼+=¦#—Ç ½ãQ!‰i(Öe¦¯¡¤¶ùùÃW Ù3»™ÂÒ£ý0éšÜy‚žçoy¾”2 ½¨Q€ê±°ª­[©áàÔš ’ÞÆÆ[)ŸÒÀÔ¦™BCIq/­·p„k‰Î_üˆÓ¸ð4Â2hY3Ú*OEbú Qõ¨‡éKX„Ʀ¬¦ <÷õùä.ËÜ’ghh³nk%À‘PÀqÅ,$û/ÌÈ[Œ6ºí>=) ¸·ô]íÕ7¦oë˜ÝØ¡í½l@Ú1¬±[b:ONÕÊ·yÂh-0ÎCŽâ膰4;•>®l3Ǻ)Ùž"Löã$ êÀWKÑ7Æ_A:¨@. •VœgÞhbÚcdßÇ ¥»âºþ¯ë¬È›»H?!‚©XF‘2•~F¬tǹÅhìÚñé«ãQƒ5°%¬‘r® |»ºØÔã•zFo¸gÁèùƒóƒàE#$ŠË8óÊû0hŠ0È­çM^‚Ê3oO£3‡¥8)!?=œøå¾dŠ^Ⱦ ³b¿+ í»v7o¯Å®PDNûA{¬Oý‹.…eÜTA<Úr.Ì Ó"~)z›.D:"yi×ùÐjôg«ÿv3Ê )"“Þvy×Jׂâ‚JõáV,äŒÀ:èè!§Úæ¬!æOy¼0º”n®E 9wP§·¸ÂEåì¹XPýÐSÀI-TbòuÓt>ÌjÛ]8H<‡fž“?T¿dkíBØŽŽc |7ó¬//üõ¢¤²h™„çÝì¬Ú” ESèORi^@û;¸fT–(•ãúO[)5Ì*¢Ÿbý^àN 7ÓD¿4 Îkô¨]dK± Γ§÷îQó;GR={¥ðÕPùX|*6/O‚õýuæ' b··á?Åý'”#(ÁwUæ‹ÊõYðg+ÏŠK‰Ý°W›þÎ* ztWß'Ž€4W‡ž–ê}<WZFnPÏz\›ëa«ºhûº¿P¾ï¾Ó»ó Ù D™S2Îñ 6~솹å�L;ˆÎo»ÖÄ¢m-–ª÷¨ÌvØR™æƼù´VŲ¯]}kGxóÖéTÃ`/yý ”][—Úä‘“l•AѾà a6#(67À4žTZé¾Cäurãθ¾ÐÿÞ‚¡©Õ,™�÷™ÇçWžX—èh¡·�E¢ÎÎŽ“ÜL€¬O §Á¿¤êóz€’fáÕ-žY¤[]…è²oê¾ÞÖ­…xb¦:b&gÇqR–?âGyáËø0Œêƒlóíà©Í”bLÝtt~ýêFé‹ñZê=}ê¢þv6ƒÍx¡%WSÚuØЮ‡†2º<žûžŽ¦]°9_†®mí«3[ã&žcÐ=¶íiÁÎM´§l=ÿƒƒ(Ë|  å[à%ÖªM·é)ÈÖ2®òˆmGèÚ_”ksww5òS½íK”Qæ©¢€?e¯iôe\¨:ýâï{‡­õ+ Ì{ÿ•â=µA”‹Xæ’fŸ¯{n¾~Y‡hK,Œx®\yRïüãv8‹üS‘®nèÝvçwÏ :ûÉRi|uÛ³7‡÷l;僿g®›z0nÎÃX8*´Bƒ‰2p(KÛþrí¬ý¬ÞKÒÌŸ¨ÑÓÃ6´kœƒ¡àwüð—s¢ÐŠ_ h¢†–ÓàÈ6 Þ„DD©n^ïæ.¥×vM“?”A^K£[0éœýL_”R–pûÃsˆuê¦ ülxÐðmâtŒ&%c;<ºÁÖÝåw !é¹[NÎ (v|  "1ÇÔÃþÍ“FMà¥ÖC´ÝÃÄò0w:ܦŽ/Tü RT±$8›âºñ (Añ8 µ¦_‰69%‡ÐðÃ=­Ì‚­hN7^æí&+¤óLÈÆ€'d/Í¥Ãe7‰³Ó"ȶÞßÐûãæÌz)‡éÐ +÷¯òT›‰š'—»M„¦˜_ïT¼mUÅxÞ- BbøŽ ³ow³ç°ÀBϨ™ƒ¤›´P)eHâžú<žÆÃý»-¬Â14<ƒrU¯-¹¸Ñ«®Þ(féMI¹<õI»Xœ3z)¶c¨\×#\UV B�Xøo-a’Ø“Ña.ì~'Ü–;4ÔÇCß9¤hÞõüýkí³èÃ2éHR¹9µº£VIGïoϬ¨ˆ.17pá¯f¼ÏÐØÆŠÙôõäúõ¿òЭÅ!åTCïÛûj!ÜÀ�8ìäýÎÕ¼×>®gô‹ßz:yb}Vô‘cFvZ!ä®Sÿ»oäkIá8wª´ŸunÂÓ¦Ó@ùÉÙ•SÏ|©rþ˜¢xÚÓ iÖŽoN)ß¿5þÇnçÞ´yWSð°¥qæÙ�EPÐîמ¦mµÆõü¶õ8ʘs¼ÉÍC'u(CÓ¹ ÊYu”¢…ŒRÌdYŸ8® 󠼕럩.wØZxd tÑÓ °\3q~ävvÊ[[~ÁƒË‘QoÚ:—Ðù¸·T>WDê4]xÈdÊŽ5Ì$ŠpK~SH¸ C_àŽ½ObÐIÌ>RD¦áD;z4jèýÒ—:§Õ—ýâ°q¥Ð-ü™hÅoÛˆ-±•c .Ænc=ÞÕ!‹ò̧,Æ™øþFŸªWPp êáèköðß¹þª j|'§$ˆ?­ kiì?ÒÚп{½gLfNGλà« ð¨–4‹“ý;c—"É)´Z'àêÕ ÐÚgÛ´Ùõkèl+™©oßNF¹‡¥exßO'YwÄéé6  9Í›ÝÔtô—ÖÝ õ .#̼XZ¯ëʳÁÈ#¦–Œ"M©ÿ¾¿º™–€L¢¯~TGñ`N8ïY†¥ ßj2ÝU³‚Ül´ÿÙÂc~Z8­N‘ék¦4 ²íÉ>èL[Šqœž’­ùÉfeæ (ÃçêG•ÆÒä‡C0€¸Ú¿Qr*{cfdŸ‡ù´”’Òýà´[Š³ßJ…†È¯ÖõzHe‹©ŠÓF6¿ˆùÍ]OJ±Òj†8¥[5*ã&W¹P¡^ùQ=ÐXŸ¸“{/HeIæ)[^ÆÖm¦P¦Å¼Ý9åqn/þÂí2ölC¸ yèQÿkÅÃç6wοì·{'% ¥,8Ž‡Ë›°C-“é×Íi² çËuq…ÑBè:zJ«£öG¹\!£CYDïÌ/¬šÓra![ ŒÖMŽóõ0y5þó7Œþ'JÜdQœ_š¾ ’zcÞ2+‚¥Ïó Ñ¡2[Ð|(I©û4(›Ö3æŽVù¾¶æ%\,×:‰‹w ©[¨5Sò,¢ #Êyjx.Ö³¢¬ß%ä©Ã•Ä~(lôt¸d[>ѽØÁÑQUk$„í»¡Þ)”Xñ‰ÌPÅVºùE¸P fØp¤B³u¢#ðy>Ä NW–!ÏÞ`ñ ÔƒœÏÊg_þÄsé…HíÉ:òéâAÚ€=™Ìð¡n ÜL öRÒ®ôT*ŒXN ^S;–}Eá?˜Áúdg ò®dD©çÅÌX‰aC§¢ÕXb†ÉàÚfÞxñoø|vP¡¥aiSíŒ"êkžâó˜ü™\Þœk&q´àsW0Ï£˜iÕxz¡Ž‚ôÌœ!ç…\UÖòMà*ÿ †‰Ý©¬zD.Ás>_Ê~)±öŒ�ùÌ´ëÏçÿùo¼aši%•E9aöHš«Ó<«« ö#ß5*ÌëÍP=ÿG# î°n·²™°`å9 ÂY+ÂÎ@”WLòx¨Ô|¡Ø00t—¶]¢åi1wå³Ô¹ä²å=J£Dn»âËšëQéÅê‡-aê0ÅRÈuž‰¼7:¶Ê©¿í¦RÙÜ\nïÑB0d KºGÕ´ñHY¬p¶.;–·ù˜Àé Õ cVßYõ^¤,MM 9!¢Š¯ÉJ•Wnñ¤Ò²Š•¡þ³ê^¤Ÿ ’¢$2âÆ@'Ö>÷ÒɆƒåƒç·ºŸ…¯~wvʘ¦V^g›¯þâÌŽ´ne6 [!Jå³av£­õX·ÖÌã0ŒÛôÚ%îJ¢â¢wucne>#!¾Qa¬ðÕÛÖ»k¾¯™ñFw˜`VåÒïO¯Å«G”qC|b‘ûì'¶÷öFi7´¼¢“…scÊhÊD…ÿ‹B>Š¯•ó�>r§&k‰]Q+ ^r6Íšÿ÷@Éh³ãÞï¬QðÕi–d>h;ü‡ªÊï§TÕtÍ)æz/AÑ^Üôò”qDdÈ4ÌO³6!Ü„!ý²¹êvk"ñ6Â6eÊHÞ em”âËad6%–�Rk¨^6êMÖÍ—‡Ò8“0/”¥†î£ â~JƒxØzuwÚ»øZl$SòŒøEÁå@O7ùž|‚K=/èÎÛú‡b+{亻âÌOsÆU±5ß¿‚xÍ¢K£B«èœýꄆmuŸî^²«ä‚ûUA3= òõQÿ�&¾œ¾ô´™O,êÖúréO”ÓݼZÜGSÊÎéýXqBƒÛúß®W0ÝmWõHìÏ7ÝI½Ç¢l”N™Ù·/Ú;‚‘®~ åiCÒ­ÌC±hØPEÝ8ËÈUÇê�8Ö‹=|—Áž_º³wÍ|ª%¡íòŠ ©“é´ðü‹§°V™•ûw&²iâ<²4¹ñ Zî÷²ð²<7ÒùÒ¨uçÊËÆj‚�éÏé[g’qõÂú´#ª¾åáÍË«ðª¶À @Y+‡í“Öón˜DŸÚÐLA ±J¦’;ne?ó(ê´Q!õ}R›Ê³€*ɵÿö»•}új Pƒ(©Ú*’³Ìµ·-4Æï°ÿzºL¹‹«`~ÎޜУøÔ:�9–å#b})ëÖî¡ (߈¥XQá®þ‡›NE†a<� rô8­´cûnfÓæ‹áô‡“è¿ý©Ù×Ö½eQúšÅ×4‡¬Ék;#Œ;CÐ÷BùRçÛ$(¬\Õjl"¤Êýâìαf¼¬ÏÑ ísD7™ú‹ÿbûZÂ1 xB¸ëO3 ÇT’—vÞbyµ§Ñ ·ê¢û?Y~%ÞDÝôzû­b‘0¢tÙ¨yXõÚØ”ÏõÖ‡SÁe² _WÁoÄ=ƒyM"3Îî¬Së\ó€6àöpìn(1†îÂCA…Š­Ÿ¨®I¿•ßµa—øy2Ò²r +ÚÐÊScõ-F®žáF[ß¼"Ýñ²jcUZáлjšö-6€áœÖ£ßì]‰¥†Ì°,»"—2WJOz÷H€èûS»m¬*:^Ú Eñ }XÐoçínP{-u<ô~ð\PĹ$a%÷jÖ¦IÎ=,º“ ®xjk¡ä^¥ÖEZ„7=l:¶ƒ›ª+„ØšÁÕµó}NŸ»Ÿæ¾¯\Œez.©ªQýÐ'v5¢xÓtólÍHuÈ„i #bL§î×õ³ß›ì¦/‚êx2[±ç²w³H†ƒÒ΋À¸¼,ªÛˆ²ìKÁãÈsWÓèߢ?íš%úôFµ¨÷Æo“>¶¡0¸«;‚IîP—¶qÛÑÙwž›=l§–ÜÞIÇø.½£ò¦£ìB6€Ê0ô¾p}ýÀùïq’% T´öç"H磓Ý2{¦$øÚµ“¤}WH ;.û‡»‘ÿP~s§øTB½ñ´«‚í†òöY)¯ŠÊ¡â¿§‡äX}H$ÍiÜå”w˜ŽzvI»‰aWÙÏ·‡Bh!xîC¼eLÅ>ž%JYµ4«ýißx`ñ[óL;6Å{¤[šd‹IL%KFûZA½È äí‘¢µ'ÈtÀøÙ]Ѻg $qÙ=ó—a]’l/ž+Ÿ1q×uù²»ëûvVBó C¨¶^£jF#zr” è…Í2Ã3ò ±0X ºÏWŒ ™cWÔÿš•³­/gVå1BƒzÖô˜dçhŒ)‹`¡q¯Ï§)V¤ítS6l>-·ˆXÊIý•ôȱêD|C -øIñϬÔ>vs£­œ_[Wáõh5F½Õ‰˜Ø„­nµ¬ .—â2º¨øöîêžÒ³ò…Mï#Z*RKt‚ÏB}±ïOÏŠ±;bd°[}}h-P{Oûûítœ?@1æN¬:K(~vöŒyÂ4ˆ©; #Ofͦ=èJy¤½`löø$]ƒ`%S£ÛDyôt×Bu¡c™²`=x´f7 »—LÁr©ÛTpÿ l7¶‹ÊÑǘ#ý”/[j*2ß"*çA^ô£ D€-£ƒ£ºg/üC,¦¬4”«=tâÆ΄hÏ\(E„êêM«ûaÅæÆmΆV¤ Àà@yˆ‰†f"g^^B¦áb\Š:=˜Ê¸x)Ó3Ði«+IšÐš|©�sÈ"°h°ã¯CTµTÆOðq¶½ùtW׳$a~HOÃŹëg³eçÉ;ÇwV^1€ATGï—~žœwÀîÏÅàÖð'¥ñø¬³:IÆL$‘‚zôŒ©D¡€!ÓS C¼~õÞ+ŒÌtnܲªÔªã l H·Æÿ$ Žò@ч4 ä_*[Ú«r(òÄ ¤%ßö”‡*v%+ÝÃÓ*ÿzêëK ‘=8ç]ãHî^7#ÚåöØñ+÷�6´ód-^ýøй2[èF±·ý±ò´áT8æ6í¹ÛK<Ì}?…H<I´‚c(×Àªúvèâ™ã5EË…÷ØÝÃÛ±PV‹±׌ }§_ÎX’¸ôC ÕÈ_s Ê“çŒß /Îepsm¤,ŸG§ÍU§ë}šŹ÷,[)ùVÐߦ%IKÓ‹~£bûú‡žâ÷qôNçïÝóÎrÖö‡‰Å¸è/Cè[Sh@Îàq‚ûJa5BcÑSLnà’[*žk¾°â‰Õ<Ã?òk>ç¢HŠIº ›%ÆÝ‚_Æ]!Y-�U¼P£¨| i«ã¬ é8R­ªŸ{Ù³zÙÁ²4‘AÙBr#± 6<„æ2jGá¹ØÆ+í v‰6Uº¢ÁVt†egp³V9§&íG{¾ @.Ø‚˜JT‘|¨CY¹ d˜ˆS”ÓVñ<1&ƒ]+I—ª*Pb€´¹£yy`ÿe ÙC§TB2äâÑ$Lê+`�È|€®Æ4µö2ú`Ek»ÛìЕs—þ((6ÇÓñÅžèì˜P¸dÀüæ0±Î™¾. òU™çÎ܆󣂳_éè�â4{ s&ǧ@nZ«óÁ¾˜€`}Øn!ò…ea`iŸF¹ƒ×4þǺÊõõŠ䌚E2ùð“Pݪd7Ì0 ø:îTŒöå³ãKsæmûs‹Ž‰²$í`3þëPG`ðiV.,9åìÍ7¹WE/áè`ÞArÑó7 /‰Â’а‹þ‚E¹µÐE‚NßþêG4“JÒ›Æɧ[z-®ÍÌ{ñb%e ¯c†ýWFáÅ.=vûaè„žO¦>-C*D1ü|ú“§p¥fl?l€äÓ ÃVwJˆü{ñ€#3l©ÐKÚ陧ö ¯J×Ñ÷ü¬w“б¸JO¤Æ¦ðZ£q•f¾™OL›4(ÇÉ¿G^þk'MÊ-:q;]4Ï%Z«ÌaX˜‡Õ t$Á®Ïuê†Aik¦ôƒMÃ-{ñ�üUy­QÞ`÷Ý[‡=ª)ÚŠ.”ƒá2†J¯5…‡«dÌvŽ¥/ Á” E¬ò³óüP¹¥Ë·lï\·Ýâú%1'ò¨ŸÜ“éÑ“qv²%š2تNêZGåÞ•µé¬\™ûë[*'³cmçÅŒ 7:ÎVÀuãCxRìe—�)¤sÔAT”Ú#Æ>ó¬?ÞõzL ‹Ì”±b+_ç"­ƒwG™kíi0_¬h_•gž• š^pÉjNW£¾Äx4tÇíXïöÁ rî’.Z8a.¥Ò:Ï 4Ǿk.¯Š+o' <ôb¨²4êaè9_˜ ¥ªÓï4bÏWU _ç)ó@’™`¥/ŠŠº¡Z< \dE¸äB ŠPENØÖ'è¾týÞ ü€d‚zp?×ïL|b —›ž6äºÖƒŸEéÇÖzòÎÝÌYº¾>qÏN —³çÒÄWqTmý*ô º v­ë¯Õjh×I¡pG­¦ ýÕL÷:ÆAÑÕ¾ÉÌŽîéÁ1¥é†ïdnsß J’Ê3W‡&!e‡ÙeXVU`å3kêE1ðÞ‹'i€‡ðvÀžÆltÈðç¨Äì•yû›§Í2óäeq÷»œÊøæSÝmkÖÙªQÒ¿éŒÜ†ŠŒ¹Ñ‰µ¬ŒCk0B<´…_’ñ î PF±Y㦹˜¯í8˜ÈPâ&ÅÖ ¥8ÆÝšiWÄG "õ?j–3”"Ôù˜rax¨D[–üCÿ–µ‚ÐØ<ó†.óÈÎ2Zì[h °”ù\[˜R,Že,¤i¾Â½îñÓ>rRzá,g¨<ê†Á©èçrÆd\ý ‡:z™o[ÍTQ­xô  m~Q¡ù+KGM·ý ü½Aš&.;€ãO˜l: ,ƤçcMÒ—Çê£×à¹4q€Ö³ŸæŒŸˆiØ$~έ:x»wõlgŒ—Ô¿›¾Úˆ¹MvÔ„‚½ÃcÍ;ʘàðd¢bE¹$'ã`})ƒ¬Uñ²DÞôÃàú OäåƒÈ­×Êô®yæƒ}ict}ëHÚk˜{5½z<ÅŠ­=¤Ñ<‰i÷Q}m <Pi£ÂGaa óhƒU™_�ÒÊo`êµ¥¿×è’As�Þñ$Ö#}¨{S¶£š’†§êÆŒâµN†…ÑÇÀ×�Eÿ»y†uMópšÓ µ „ŒjVÒ§äY4Va£(ⶃ£qûµÔíŽÜ¢¿|Lõ¹ýnåhyè×W–{^Ї͹³t‘îüáhç±ûáüêêÕ“ŽU“¤i“i¯á[mµ#¦¾*æ<fVë×òêeÙÇqæ �ÊÁ?Ô1cšG~jhõØ wÐŒò½ËÑñ2r«îz°D&kÉTüî"(¡cjº±Œ7MSuK‡wyã—ú5’Èze’[KÂYðÆV®CÌžÜéš=,–ÝÞæL@ÔÚs ¼cH“-–@,Ы+š£“D£õÛ4fI…®£ý¿¬+r_7†ãíRÐò º,bÍ̵ FPb c+ó*o,ݬ«H®¢fzî±CJü׫|Y˽vå¡�Ú ‘­þ2 03&q…»Òè— ¦´ÖöÔÅÖ»„1‡}¯´Wó0>pÚQ¶í„AÆ•Îgij­°ñdr¸þ¢¼žýq<:tèyéÐV67ÈF`?+üÕ j(©¡O›Úà˜HÚáϱ´?óB§7ŠÀ•³âæp8A«ÉJKÁKúîP êžó‡-ÜÅ_ÙxÚ=‚;=ÄaPΖÈ1!hãë&Ç›™úíñ¥×OÉ=L)+æo–÷¦|“Q•_6`9/n®QXÙn_¢âYVš}”ÙûÆ«ÞV‡ÃìMAÌ Û¾.›?EáD¢x)rlt•²PçÅô:yÕÐA> Þ[Õ­!&EÆ�­¤ ûÁzš·8ÔµƒoÏhÓq¬¯ùCC™™)A;Ð?±¥)CÓ‚ÂCOÉŦ¦­£çãâQµBŠyÍrÀÜ„ÑqCa§¬G/a<^¨ð5 €3¢|ó[1œÐ¹aÏPëBxëYÛ²ÀÔÀA>_ÄÆH_ï7{‚|,EUvdMk,œÒ‡³3}\ ¶¢ Ïp¬ž¾>4eï_ô9³ª¬úìÌîZ5B’ýO‚¤™N‘UX­úΨvXD36ÖÕO”°UÙBi´ À ®Œ$ˆ…´ôêUß]­=Áæž#F¶°®L¶£U|ºê2У¶aYÔ$íZCB¹ùˈ{ðÖ'ž.�Ru­õ²b=uã)ðHjÜRùxj¥œ­³´ì‹ «‚Ü:S¼Û#-vF³E ýj6m‘)Í+TF–VijºŒÎ:A©Q®ê–°ðÜ}ÐW³Ú›;W‹Eˆ-fÌŸŸOçÑ™iÓw²‰LSŸá‹ún5-=Ú sµÑƒˆ/jÎXÄJ‹À÷¨©û¨$Š“Ð×Ñ‚”�φ­7s`ž ·s_tþUCAØ玃ד£}KŠ-ÏMK@=È1àú¿p.ï=Eú5—A|´ ˆˆjêÓ K‡È茄º¿øáßÚ‰D¬Oˆsdgå®(5Ü¡Ô4ÜUÓ¤Ï3ÌXvÀó¸QÏ E‘¸ ÿÇBBúL.ýq{àS:8<º’Îbé<¾˜Ý¥©Ç(eçËéBK]»]ºù0þ%v«",¬Rù@"&-¢…ÒmD»¨ðhÕ Ë&ëê3,A#>óÌÅÂva1 Úû%ñf§ °ü:¦ HÌ4?ü¸®5šb ñtôé´a¦{¯WüZß 5ó Á2ЉµÿŠµ~”ÌU1X‚Ùh>('+„S7´Õ—³Kë“ñÒ™9õŽ‘�ë)bÆÝ·£�J-0|ÑüÚT–ïO?ý¡{ME¯ð<Ì‘è8®>g;ýÂ\bÓ{JÄãeØ^Öãå)«ÝÛÃB)«í8´Ûš¹Ú* SŸyúEµ$:2,(f¯nãd¾Ôˆ8,n8¸ñW¬"F{Tôõ~y|<ÓTÂÊq›Ù¬§ÝæA4ZÊ,âê]#D£T ¾,&BÌOÛt*ô³|ñ]M#1k&:ªyðE#^aÜiWhQÐg?s†"’Ã?ÓéØÿìk é},•…Eèቘ‚“eAtQ˜âñ�-øõzÇ ÐY<BèÖ÷tŽPIWS8Ü‘@NÒÊZ–±ÛÚ°IƒÔÚi Áq :ïÚ^ÚÔv^sû«[ÇÌèèLSŸ×¤¯¿éÑ ¾¶êZS»ÉHm±~Òñ�€F^‰$„”mAa³”TùlIÑÕaoØD6ø÷p[à´nÁ\¡DŠÅ¼ÑGêÂúÒ@·gCÿ»¶=Ym²c7\¨`¡d °'�É¡™×.Cù^þ|•S1XtÜØúGoUÂgåžukkùž×¥;'ÅŸ¸€o¦·Ö'ÓéíØ­ð¿¦DÀ½Ĺ՟" }wå7š-ÇË!äÛèÁZ÷ÈÆÐG¡G©ì׌ÕÀÐÞ¹�tÛ7í¡lõx ÷-~.ž`S‹Ï¥¡OwûI5Mn@lQᢌ ™†r°þì5b\ôåÛû+j™¡ãˆ %b›>ÒVMÝ1h†¢#KoãÍQ—# t>¹Œâçáto¤Z:d•„àq›©…f&;ã–VÇØ™ã£=ˆ*’'…:Ào‡ËÉjFSÝjŒVÌç;Ú—¢9sl¼<¸4}¢Ü€e·Ðvº< òÓèÑÞ÷õnf’näH»Íf7üÓ\þ¡-Á²wùx2™dž8Cl\L’ ™m…vk¾µŽ@à ù«þð˜Æ»rf2‘Ç�Nh(Ln=¯õ#‡ 'NÐvíÚG[ã5l¥ê*v/­B4wÁhµ8•= …Ù£jF¶ë‘”©­þbQEê0êµóÙÔÿî¬`Åk­CËê[ ‘þ}kýÁÉ d3½‘ùEnn”¢ìL‰<û̘GdzFµI¹¥ÅØ £3¹à÷Þ8Æw~§§È–ÂÅwëäQÌœ[Ì:ÿ+OaIh�¶¡¯Q4?žÙíŸnl;,eFqÿ ;Éæ’ô¸`“ÜXŽQh{ØŒ˜Ÿ}í°TCD’ýa&‰¡kWSíÚÛ”,v¹=Æ+œ£|ˆžåS-véc|$‘‘L\³™§ÿ8€^E0Ä ÊVyš0)„JíªóÂÔHC¹7öW³€$‹} -à“ºæ‹'8²: ëNzLËæϹîyô*=®; „¼ O %u˜ÃMG·ð(¹=vF©•BÒX›Z÷ÒÐË=K.Ï–FâÖ&¤0ÝĆ)ñ¦q¿ñÐV𚢔èËÓFªëG×ßhÃGÊW´r†Lm)¾ìà ™&­Ïˆ-‰ÏœÆ‡+r$Ÿ©ááÜt8ÝøŸÄLcAoßbp*-Ž¿pIŽŠÌ JéÏíÓ0¨†o‡”=Ô_KsJovÿò¾ÇSêë« ÿ’ ëÏŽqLCN´ymG&™'» -Rªšo¿A'6„¦Ô@­^TÊî)"NŠÌOKd_ôiG=I!ù¸®!,I1ªŒøyš±ßËÁ*ç %ú©¦·³~¬O€…î~Q¡r“÷q}šªÿŽ ñã2ˆþ aÀy¾2lŽ<qkwß÷©É«i›Q4[å ˆãäÍ/DBÊ3¬}WùedÛFŒT’J;fÝd(aheΪ'L-(ßæôP­!k7¼ÍÅ*\“çÞt«Ë!·,Äx ªÝ/߀$Þ±V½®Ïæn·áæ!;ÁS~Ö@ók­x‘—³ÐÂt ¬'tÁ Õ˜éOhètI3Ž|†ÈWÆè©ØnŠ&¸ãu£Ái§;ÂÿKûÍrKKXÛ¦ªÏÑsUõÙ ¯)‘fZÉ'b¦k–Gnæ¶Òý§K’ =iâš…–Øí{VÓBL[\µêÏÂCT'Šéq0ÃÄÈ+îÅ·}¢í»�T T4ËA•N‹B<r­ P¯;¡`¾«<•ž0 »£û"ˆ-,i÷ÑȈCÿ•(UzzQT…àDQ·Þ®#j¦ßÅêŒ[[ó™öÖ÷ì‰(PÂjõ–ŒÄWœ¸¾—.'Ë1øXë}^úÇ °˜>n`˜Çš Q®±(2±hƒXõÓ9ÊÇj»û£`@è¼io׿¾«ãd Î$Ÿ ÏÛÎIwºÆ šU8µÆÃ^åXÓ^Á¯y|w%ó"]ð±øùPXñ层±§œVù¯`å®n(Ýö9ëyðOŒ‰”þ'ŠVœ3äZÙºž¡éÊ]Ýoç5uìjÃÿe[×Ê–F ¹ÙÂPøtñúÆ*b|Xº‘“<wÁŸÿF±0+ÊÔ$ì×6c¬6h¦¸b—:E†%⠥Π¯…W¯8îÿÚ®PD”ÀCŸãOÝûcMÊNwÈZXºÇ‹Ÿ/Ð8Ê}ºJõ ±uA¦ÝR[äü¥ö‘õ V)Ú_Pèu é–Ãæ‘žè¤Èè(Œµ%øyVܼ3¤ÜM:e¿)gF$ à pFáü…hQÎ\Êkœ5ðŒ§00ôU]Aúi+’Ï˯n:r?Œ+‘"`@ÅÜIÊw;Ê=ô…GÜ€ˆi�Ç_™uzÍnc¦žêt&鮞ó/Š8óEbæ§Ó®û­G]‹íA«ª;ý¼oùY¸ºÕñ¨š´Pl¦[8¸iMÀ°ÿ¯6 oÛk¶HSµî¯8÷N‘y¦Žæ.W‡¡[j©f.µë3šãŒyîx†Ë¾k}%‚<­âÌoL9†<¨¦ÙèEBgרŠœáÎ]¾:F? Ðæ•NQ–Ii69<úŽŠ§ÍdV$³_.žÊ´Œü^ØíE b¨©®F|òÆ*Xc±ÿ0Ô+ò, |¸Ë;â q\øHÆgA>«þ=¡‰ëãÿ|ÀÔϬtå0Ûèôk`;UøUevèØ´QP{XôÐtBI Y¤1#ò¨mJ.çì+=õnAqìd\ô,hŸb›Õ§Á ÐSÅÍûÄ>d´¦½×ÞRжµ×îµignÌA—ªqëPÈ™%Êþ+¹¹(e&` Î'4åâíëîÙú§;›+î½'‰ãkðTE+"9vn˜ŒI¹þ“ˆ<mYÚ¥Fåê¶wïD6¥«›ÝÛ³m=Í/Ø+ù9esj»»¾ui¼ôW*�¥/^놘æS#åfñ²“A¦[æ_¡`‹ÃÔÌuWêÖ=-`f¾ñºë’U.ãÎsƒ‘o~±ÀNôŒ„ZäLƒ~=åÍ ß‘î—Љ¬¨g°ˆ†ÿ‚MT^W%í²³'—|ƒ\h5¯j¾fø½ÂŽ£…{暈ԬŒóÙ8ê³óµÝX²Äöÿ/Û%‚ ’iᢆºUt ÊïÎÈ 6�ý î¦ss=O”å0ý+dÔÉï&R‰æâûMu¿cÃx4ÇkÈÃ(úŸ4Ê®*äy^maóI`¢˜ÀB¸çÀmi…"uƒlÞ;¸Âđϸ \­ Šb­âeP]×Íņ0ìÚõ5s8Ï&YÑ ¸uزýqýÙœþF61Īœ!—ZY![Œ8›±á }xР O° Ðñ€WÚë_ Kâ43ëˆK¸=åáéI*öGdª£´…ãÈC‚Ò§Áó™ý‰Ùß´nO‘/‘Þ•IÝì2U�/†u7ì&v.˜þÞ†1W· ÙÃ"£æ?ZÝi:Ûf7;˜Ü\ž˜PǪtÎÂK¼HöÀö^ /žy—ÀÜXXÊÏÖêû…>ÓUCõþÕ©ñÚÛŽ4Tg`jrâ”Êû×WœÌ̽ÀèëW/PñÀ€”)—œ¾èIáPÃJ{ÊVÊ=avg[Ro[Ï. ÊÝ\a,¬l:‰Í¬¾6ìäKã&j%GFäy>SœË­¡`e{¯[H …gEO Ñ<ôEƒé&°#^eFz=2eÁ£ø^;’,ž,)7ü×ËV·¬üj5ìàÕn¢ÜÒs2‹|=¼ˆÅ”©lÚêFa™Úö§¾¯e¥Õ”š ÞÒ\ØFuáQD›Š[Y¯r:YmŠNÅ}„ÒðÆ»XÐ’ÌÕuÃú·P¶˜¼ºh½4êÕ(ªzÊ=6€sò©ðå÷T®;©jªAW|ÎhÎ ñÑQüMd8þÜï9}_º¯ÛX16ªÝNAˆ>ú vu¯Xè34o­îÞòÇË ;óíV<IÍ·aÏ…[ ö”}'"“2ª<‘æ�o.³‡Œ¾�‹‹Ãß4§ªÌ×°ª`¶Ÿžûẏ–N)̯ÝÕ³o¨F`" ™0X) ª£•úB¨l®FŽ ;v_clî`•"îgà D–««ÓyDº´uë^ê]Ý)úµ]‹Õì‹ÒMú ÃäòW¨µ¢šü/ÒM˜"â5ã–ÖXiAÍElöš×¸wÜ݇|•Çx`¢Õ¸<ÓŒ?|ÁýéÑœ óD‚ºŸ!²Æuð(ÕèƒeîôfåícÄSí g`ÍÌh³¢vÜZÙrÑèLÝ#G' .ÌdõÐWAx<*B¸à¹p$—J¶nk8Ââ ß +=‹Htr“˜çyN¤ó‹RûËÇ'†QkFBJy=Ó]¤¿Ê@.«Ì^†þ©G–>÷&ã5ÞÖŸÒ•õÇÞ¦G2)÷Ö7åb "Üä9j‹¶µè QP°¬ûÍŸ?Nn5d–ãù¦”<©g†ÐÅ,'H9>tÍlÐ_»ÍZŽKpÇŸ—'Y=@‰îLbЦ‡Û×›íiáÙqX˜FNl:ªDÎè¶Ø‘ÛÇ‹•Ãâ0!3:ïr‚b!Io'¦¥Ô q¾f�Ä7‘€‰A `’9‘q8¼¢Ò×y:ωBOo?aÇرŠóèi¾Y)KUg©¹Ç//]­ÐY Î…V¨ÇÙvúd©.¥ €2¶|E³ðéù!ÓARåvíUÙ»Öül%ŠNk1lêzäüïmh-yBfaEèFAòÝ9º:$u;‹Ä�»Bf”òúH[КKŠGLœÿ¤AÚè ˆYUþ0Ñ:C% &JTz‘Àç‹åO׊CéŠ2%˜aÝÒ><Å–¨G¤î;;Œø%>ÎÛÕ›mÕT|<ÚZ¡9н Õ(RyWôÙ»ŠÐïg•ùÅ:ˆÞ�p´Y”üFæ‡Ñ*ƒˆ =ç? —IŒûŒàÅa í7 ó6ŠYÏ0±Hs¡*|ñ”Øöîéa3H⑬aê¡¿Ùº½úsP~ª˜Þ5ìä¯]!šÐf0ÂRKæ5Þ“ÝC L#pÆYÉ«jN ùæ4Pœ§Š‚#¾=Ó{Àä“Ã/Î}í&ŠmÝÕøV6§0]}ÑèÝwg€NÏý æõ.\#óVTbw]­ÓXpŠéŸïnº82©ª˜±Ñ®8Y¬‹`”"·>,°UéÃ÷®®Œ/Ek'cd�$Ùªo­?ºžL\ÒÉ}ažrZÄ�"&ñÐ1žå$". p\êB&$•AÔ»ÔñÀˆ(=ó 7¨/½ƒ s ›z<Gqž9¤@Ž[FÙn¢SøÂÖ„ƒ×Òmw ‚Ž§±ßu§ÅØÄrƒp\€L–S+QZkŽPq7[ƒ§Ò¤qnŽ©XÚôÑD˜Po=í߉çôfdFãÙ`< ä qY‘ ÇêG‰ÇåáaµÈ48mŽå¡Øôüè3Dœ±Y©õ#5Ž>•/Q„’Ûþ~^füv’œ*J<»ÐçÕÝõ{yìô?›vª ¤DÍܹ3ï}6‚´lé…ÐwѸËjM»Xz°_K%ZJa1;Jl¬cN?.¯ìÆ|hÞKrÛ¨2Ò !³TÃGbàˆ§& âµí³•P³o€ª7 vª¶èÄ|FŠLÊÊW{•©ë[ë~ò›ÂÚä¿`¨§•‹Óˆ©A»-ƒ|ûéº÷tpN”Xv¥áºÖͳ}5À >\£\ša¤ÁöTÕéèd ±³èåÎ.,,qìã=Í–)è«ÿHtìº\L"�o¦l..[ÕC-_ÄÁ·½˜@ 0©@Ó&”D:ëÈÜPA8€ºA‡&ß\Ü6JB3Žbp^³Zê·'xlTYÎ:³H[Ôp‚åz´G¿ûêÝ#ÌBU-MÚíà ‚iÖ4|;LCØZXÕ‡QˆYÏLUÒÈ’ýÄ ™êÏ ªÏ–d!µæÇ¥öÞèΫö>#Áá͉>\ný Ë ƒÑIÂ8îŽøæf*Ë^tü‘mÛ#‹]läñÜÒÖL>5$NCd^®¦öWBìó–ÁW¨ãníìµÊ ¾EùÜœÅúâ4ŸÍ ÏᦧÀ店¹!NhWý·ƒˆí»žên™¾™ GC«*Æa­­IŒŽ ßpbÛCÖ”~"bœ,4Âœµs³ñÇÏúzTœó¯dsÑQ±ÛPë¤Ý˜^¬ + ²Ñ>ðñSÛnmL¬ÝÕ-ÄÌ×™Ë ÓV¯˜˜ÁTY·9Ô®kÌi‘îŒsNagÅtèàÚ­M{…>cïÉgPÌPsó]ÖuoÀ¡7òˆÍÄÅÜ=Šù›–Jø9øÊî;£­³ÚžZJ]0Ûx‰NÂ'¤BK¨ ’ŸOOmlÓ×;6œC3–tB/^i”•ïå’ —GíMrj[`8‰/Ô¨ ~˜œ˜;Á¤r€sþ’pm¬"°×ŽVòÕפþ…^êJù:ƒ„ü<3+r×¥äÊz`O›¹6wìöÇþpùègG°Mû»êg®ÞÑÿp+ôgšM GŽoíÃH„¥î""ÛâÆW³�Æ(¦S;6}v0¥¥ÉkJãl9éqWÓZ ŽûM­-*+|ýJ™Wî–'3O!ËžXo‰‚ËOÒß«ÔÿBž=ɼ”³ŽzŸië5¼­$€#ÑÈ©éF ûö.Uý÷þõ¯™äá(:û¨²¦íÉJÀÁožËZ€Òó%mï ÛƶoÊõ{˜í»ÛŽ3ûV¾+ N“Óˆ›/Ö挚:_(35×m©Z¦ ±$¨²1\DMg!´ç®£JÃ7º˜–¸™wš× \7 oÉE§e_*¹s½`®á”…¢ŒCƒä£Ä=ˆ?{s”£—Þœ8+Ô éïy2^“Aš§ÍDyCf›%_&n®^ÿ¤Äبg³&Ò2Z “¨]½šš¤EîûÞÒúsïõÚ3)kQ›µ»Þêj½ëïí{Fˆ,Þ¦ÓÅhëYÀ¶ïWÜ5‘J¢Ã,…¿PÖiW…öLî‰uWžP27.Ys<›&þ¸¥¤ó~¦zÜOÓ7KêÕñHºK.ÖRL:ü€ªe=•ÉäžçÝ<¨Ð#x‰Rot¹¦"ô·¬Ûûج*ÒQV,tr3á“ÇÓI™-¹°X&i…Êøö9…<ô2(³Q2ÔŠpÄcÝ sÁ$+#wÈHÚ$çw‰¦Elƒj‡0èÙÙøtQŸv2Úsþ)CªAÐ-ñþ½ƒ!ñ(¬Ë3MyPv³Þ)ø©‡á?ðñú³[͇qg”OF4ª¶¸ #¤î$r‘’Ï<n�üXk‘e†]ÏE­Yðz’r§%Š—øÊEŽ™v àÁ{ z¸2ì\Gá-è[ZÆ™§ÀŠ¢6­Å—dy`ä‹Ú)ÊMUu¯\+«E¹VÀ;£ °vñZSÜ%XOÚŽD„o€ì÷ù•nZPÑâ î6-¢™µ(Ì‘sÿ]Ûw¿ª£Â0žÏ@ñé?½m×tC÷¯‡§kv½^´½UÿòX2IâÇù° ö_Tn”Ôþ~߉Ûñïìh’k“àí‰ntvôÕ (RIïÝ€ö\nã.ÿýç•[žÒ|¡Ÿ¡Èx×qHfs6>ÁP /Œ”D}ÒUaWª´ÞD#Aλú“ÄA¶UrÝŠÞnÖ‚øHÓD6¼ÁTÃ"Õ†2äÇõ&ºNŠ"›ä%æ¯7MDuc]TCâÙ×_ÌEa[ÄU¿Cü>tÞÕS´Â“pŒ™�†Ysvø™<6ñ`ª(¸Ì½×-{¶Ù£Ò6±#Ï׌A£ƒ|5}p<¢,íÿ®‡P‚µ‘\wRmõN’ÆÞk±Ú="ЙP˜×Ö­ÖÀ{öÙæÀê )ˆzýVF_QÌ Òqðlds¸vc¦2+wuÖX):1ÙÀ÷UPŽ:Ùå¡™îÑÁÚ÷šŸ ÍËîƒeÿ!&4Ö#ûD&%¨bþ1Ý™‚Ä¥‡»påc+ÆœõqÒž•Ï•ÿo>÷ÉD( ´k’“«�¹½½@²Èä ŒS‚g§wuŸÒX†^Ú€0(í< Êñw7lŬ¹†²ýaaˆ¥‰+±YtÕÐ#ícA*»?H£ÄÎÅYyÉÉÂH@»R‰¹Q—tÁ é“þD³ÕfPX°”ÿ¸®´KC»”c)XŸœ§Ýö £4÷c!4)÷ÿTcÔ’ó Ì¥Žöâ¡T¨§^É-#z=7žÕ¯õ95wÇÈ^¿T¿NÊ…c^Ä6èiÝ»t<©ñâuÆjG³øLSV3³fÃìÉGÖ+à~p”_9Ê’ø±®wó¿ÀáĤà+¿c9!)}nH°v²$3Ÿ!t7º=ú.`Fu¯ÏñïN « ®t‚~ª‚pè­~q(# ƒ³ée:[fþ…R“qCO2®¿õ*ÔElóùux¾Eâ›ÏÐVjëˆÞñ³÷zo¶4F fŠ,úPæ kÝÀkÓÈG€Â ` œg«‚4×»……©¡Xú�¿h'Š}’â¿¡ûb:TF£àsª¤øª;­ûÞH«ë¡´“ãÙ{ýdñ.r™üã=yAGYŠWCo}Ú±"#€¾R蛌쬌—uŸ[ÅõDY¾¢í4î´³~9)-K÷PÄAZ©mýb—F0)×ú�(Ÿ-M„ÀÑ〗ró=±?<°fp°;Rý6¬=E—„¢ SF ËC†j`gô?™¸PЧL<båQ¼ðÇMsáiZú\ ܃À€­.Ç ²ˆ­½ÒâöæÓñÑ$tÎktl[Õp…¡J{8mhùk¢Úªö˜½x4yøB¥'DL MÈ"H¶“§˜.±®‘°ö'Ré¾ÇŸÈÈÐŽëÚS3äEºt$ú;æ¡}Ô;QÒ¹’á|rØX#‰#JS`~œ†�¼†áw~Xʤ½—³4ljgS­$Ì_û,ýßнL¼bígÞD�/¯?M¯Ûx XšEú”òªÁú¸pÎiÚ5•,[ÞKd°±ÝJgÛÅ£»Ö4Ì,)·•©½±ƒ…²Wž-ôµ2£¬bpð€ ã$9ÔÜ`<mŒ£ÏsaZÜÖÄÒÐRYàà[O> ™üÉu>’Ï$ „ßhDqî›'ðS€æÐÖA7´+o¬‹ÁçÞÔX·µ¤Èµ‘ mëîâ‘Žxžbezê†éï”Qéy'pÄl¦2ˆ¦µÕ%f’¤KÎhqÒý$�Ï÷Ñ<ª–1œfuŠt*)lʪ±([Ùm훂Q¹î…V{íšJLCKÁ¶ÈEPOhfíÉŠ'´§aOÑ­‰£ÄøJ2*ݨS—DöÔ3è€à^Ô Öͯ©Q_$„zD³&)Yjx\¬Ý£IÅ´¢ú¬îο”sr1t¼ó+_ü“kbÄÔ?I­m++ ŒqØîdÊÞÑÛP Q~5ÌL»4×ÙFê7± v¬9™Q­9P:pU4…Ñ4yϫÊ›TF´5S+ã ±WŒûúKÝkØð›ð„Ü ÃÄh+œk@ztÜŸ'¬Ìq¶(~t:º¡p·—>Æ06„˜#ÀæÌ82ã黧SÓ7êÊÿI‹ã6©{ÓgqmtZŠ?…C�·¥ÕAO•–Ö`Xaw.Ÿ¢lçNé™v ‰›€ËÛN€ÄBXÝýÊ '.×mà¸÷p8VN _#–{ç\K úKQE-^ÜšÅ]*òpÑ“,(¼%A²ùö$&�†Ì¶Åà©ÐÌ{úû¦(…~ Ú·àøj ˜Ü¶ïÏð=›îÔSLÈö<ΗÖ8ç‹þ«Ø÷4cºwTWC禡”’8!›é(æ­[{S¹Lº;°&›m~ þÀi´v7ýCœ¾ Ö6uüöNî#Ž Ö2ï"˜ Ûƒ2fZÐú†ós¾pS@ùÜòo홵:Œ´4GîØË>²ð°T(£éS÷ôQgK†45®5â}`•›ä®ŸÀLëUSÒ!¨x½øáú4vVœ¶;‹Z„weæúá “¬È¼q*Ô2á“lÕz!/Y ü‚ÅÅ’¸Û E*t_¦ù uœGF8T¾eTtÑ™vžò?w_®•ž¦… *­ Áa;鋪ñ…¡dºt‚¥m>×Ð {”ówV ³‡¹ ÌßãÐín€°¥3òŒ¬«{Ò«ÊóÌäz¡Uö[EH€ã£~*B4X “öé´å8rµW“ÜïËRÞ³©¥j&Ç4q,O:([˜ýHõ©—«úÐL�Ûv ƒc°@è~¤÷Ûvflñª¬çÉ‹¶«ñpa^ÆÕëípµpfû8Õ¥E†³¬;}m…Øø…±y}äŸV.¤¬šÖ`n=)EhÞÖv?Ù€§š”òÊWÂDôÒÎ ÝÙ9üÙ3±Ý/1|K ˜éh±ô7ƒÝðG, €óI_Ó!À*ãåÜ·eO*ÈIIªx¹´µÃôù"9�ø ôBÇ· Ç�–ë®Vbž›³33Ö¶§5~&`ô�Ýw´½b PT£ZC8!Ol•]Ìè]ƒ´±%?»WT§îaêû¾¼tÕ¡86c2œ§Av²óX’C©L­ÛË”˜Êÿ+ ø¤fˆ“˜N~kH[´ïr`œíH›ÓÞ#Lé5ÀïQÿ–4Z‘Ëcã–~;./ ~E§Çú_×8¢ð\³–Ç™ÖÆ™‡œÏWÉ‚Žs“(H¾Gò=í»ÑÑ‚(ï5ØwuÝJò…¼Z 0bJOÓ&�©e&ÊÛvFµ›êóØÐgâl1pf¼&½sbÅ¢’0p˜Ju.8(èù•óI è{ß!ÜÔî~¬Nã¿6±�:Ž©^Þ•éEÇeìæ ,oߟ¨æÞXýüЕô¢M½)¼c?Øjøôï¿@—¿$0ååÕÔsž"¨/o]6g´É…¶D£˜×žvÖˆñ7Šæqå9c³àÙ†"Û‰mÝŸvïÔÔoš—oµ1#‡¨‰ÙËþ ä+©£ `ƒ+ÆæÉ×Ó‘L§»·.¡ /ÌŽ£¥;)2dŒ‰¦³u'j!aî€~b­w®Y9õ0k®à¯¦Š©¯…WÝ~!E˜•lK·Á_}ÆH³)„Ò©0aÜw A±(róC¡E°Wy¬Ý\Ÿk|¼þ…BäŒõŒ¹jŠ­Dmm½8Š%¸X&É‘ÝÕ¾cóBÇú±ÓQp2bY²jg›’Oøi˜-Ü% _G7sRV ž<’Šiï¬%ÞT¬³ƒòДÂ{—ªÊ ²öu_Ë EJÉŘ¾ô |M¬žè'ä ¡ï©æžzm­…U¸ù”i8>WII|ñE›NPÙ:}ꇷӇ֌jÎÖ‰ü‰ä[âÒ½ ­õ%ã¸é¤³!1UWã¼Å¢“ÀÒQ†qçWÀôÞ r2O’-äöOTƒÞ” ;é‹*"LŽáÉM²!õ vhœû0 –¶§'\X =… XŸzεo}GüMðÒK7i¿9Ñß°±œIk‡Ã^ª;oÊwÞ_ù|{zÖû/[?/^ pÛýØÅC»B8˜ë‹už0À‘'áÒ­ªÂ`á’”XýÿÊÊ_×Ç·’"_¬˜ ÙfAü©-x„0ðöþó‘´z©Xà'®y8dhðèuJ¶ ñ³Ž=„øN>q¢F“ÔiØ.éã K›Hó°È,Ø€ŠˆÆ|ªÈž(ƒ®íñõŸ(ã„÷"$iUŽ|­$ýOê52.=)‘ŽG¯Nk&ÚÙă&CT,ò·0Ç*H¦Î ™àÞ›Ù9íÖÕ×–û‰‹ëdzèôšŸ™¸–¥AÙÚ6Ýî•{Žµìf¡@QOFeÞ]†ÿS¥.åȼZ§e1»:2e'ì–ºñbÕºöèž]FÚíz׿øÑgLòô–%û´öŠMÎ+J ÄÜC€Rž_è3wVMe‚=©ãpPUs¨YÖí~7ÒZjÍܵ­ªŒ¹Ë÷ºÏ±m„¬EÉAß#ƒ«\)Ñ÷FŽí!ôÁ-¨Fµ'ð~iô@p IJß= yÛº#>|]óEB°Û¦Aõ`p;M 1§;ötÓ;U˜€Ö[SÏÞVý¥Ž´¹!Ïâß ¥bŸ¢”ž+(Í&e¯‡½ \¬Á£‘OòŘ¡UAO‰æ´ËËÆø‹–+U+Þ…tOØ@Ï!ªE²@Þ2Áâų,“¤Bg-t‹élÿý; K Üé« ’OF”lßMµ;·ð–5M.D~ࡹè9ƒ»úFYbMQÄQGŒØ{µÐõ‡Ñ`æc7g<•WE³Î 6µCS0RºÎcW¬h%MߧÐ9¶.þba_çR¢Æ?ª›q›„òº^Ô¥ŽZÉ(2Ú>ð¶É·>Eâ >RÓ\üQ4e\”ðì'—ò¼-ç9AŒ(5Éý°Á¡Ø)à É}[Ÿ' åÓR'…ŒÔŒ‡ôhï ‘Ê볪)à^|QlJ˜- †ýÔ–ò:Jtó¸Á–ú²p§cÔv#6„Vò9i¯¼­yÕrMq;ŽIòÐóÜŒ mEµJxÔÚb=ĺ�S–Ú_B—&}©Í §£“6صWÐÇØ©LûØÅAñoí¹G÷t’ð<ZÎ3†þZ1r/‰¶MæwéLØmr†p:<wU(fnçNÜÆ®5ÇÙí½*Ë2±öa*S¤ë³ooqúñ!³v”¢�w2Švé6…ž{Ð" ƒdsö‚ßÖ©ƒ¸ÂæCo©RÅp®¡Ïã×æöÞ‡†*Çò÷Æ 5fi•u78Ìã›øh_²Jfü‰é¡VlÀ)’8dÝˎμß0hb{f£­q÷ò®8w°EÉÒ!VMÑs¤[±aq9Q¼¹qÃ&çÏ%òÜ€œyñƒŽ·µ’iÃHu UDâÝmEÃÔŒ|8Ò!WŽ½£²¬v=cݵæÀê2ÖØCtàA—GòºîÜ+#=ü³†¾<EˆÒ*†J¤Æ¼Ú @Ì°r1‚z&ÊÒïì½ÑŸ¨&¶n¥QXÃ'ѵ²C­)·?èAì&îÖz^Ô^wémfq®Á)·¯‚ôûè”5¼z÷tÁú÷ÛNüô«–ÅV‚³Eâ"_%îÀãÇý¯tj‚kѼÝXQŒãSóövoXŸ:ãyçÁUð<ù\¾Î¼"_E­D”î'xØON©a†$ˆóíáçú %•__PÔô>[H%•—ŽÛ "Œ,Kï£J6ÞËÝ$HM½,Ÿ’OßÜæ@ ‡ƒòe»áç*œÑ»Oa7RlÞ8æN*êº) ÒþâI­Çzò査¡åìTÔXÞ†jù®ï˜õF¨�Š :Úeªx jáõ„ðxºâ]>á°í¦Ò t¶GúÕl"1j]Š3“Ï¿½ÓôyÝþI’pAš…‹Þ¦@ƒjÉäžßÃœõö¶-à{rÜáNdn¦_qá~̃ȖÃÊÌNTŠ°Íé3šºüé‘ì˜Æ"Â'B(I¿/Š@`#LÉ&‰¨Ðc­%ŸV]ÕqAºò9BŠÎÕè×ËQT+âã¿a]y&êhÇ%‚k.ºÖlBÆ2îÆÞ1`ß3+™0d¹Y¼Ç4HþíµNKX×ÊýVϨO„m§X…Ž ÂÖD­>dû‹fÆ tùâ=Ȩô™ÑÒš)‚ÜŠ'êrn¶l-Šáô¿?¾ÃÐà zÓã¾u¼ý×Üׄ‹öÑw¤/ô…ùŸç>NUf“–óň7 ŠÖÊ”3Üèc sô�8ºÑxˆ¬óˆË¾’XX\tFPJÒqã!ßöF‰3Ø'd’8,Ü0}æpåí·ëžÝfÞŽ¢¸\ÈEfà÷‹íä¸EÇĆݾ&Œ¥ÜeÝOüzUéÞþC}ìÓ<{Õ†ãDÛËÙÎb˜Ey¥;LϪ~p9¡ÜP ZÛllpzpÜò²Xÿw4ƒb mQã¤f¤>­=³ ,cWŠS‰ij%wõ7—8µ}iíö=×Ò‘AËò•læz¾ Z¿:³ó~`â³S¨á;²šó ë{Ó‰²M8Q¸_›ç°¸ã‹Ä]Ýiƒ—Þöáñê»÷0dˆrºó!Ü´Š‡n†‡/C €m@eŠ,²Wˆ�•SwazÛ´~˜—©AvCÙªŽíû?µpÐù÷|Й% §†IB%[_¶¹,d÷}†PTþH  ¸Uú›Yû‚È6°3="puŒ¿{i=r§R\ $(“Y+‘í"Ƚ¬8LªY"ûà©Ñk“$òEøâÂHí·^ªz:]Z¦"ûÅö}µóÐðs@dª:­¼¹gôaÄ- "hñGXR„¢Ò™çc‘'Y" žMOK)9þXO2gÊËÁL½É)”mºÆâô.X8N­¦Â‘݃wÐÏZÌ"`°÷Õ;ÒÐËPƒ”>¾ó¿¨ÿ}ûví×Ò™JØŠ€)úã£N3б°4L.°9´^þM™o fbíD£íèˆ-:Å AÐg6Ñ’^<f{d Ñò÷oâ#o¹×¼9ÑJ­¶vŒ!&=žƒ㟶l2[(‘¡¼�iÙ$2 S§”á3{F9Ö^J¼Î²¾ZZ²¼4ìESHÞEÎDyË'ÔÙ“¯†Fxµ™<2LCÅ“ Y®dWßPa-Õ£š­áèݺºã“g !>Ò(×ý0]ù¢-ÀªôÕû(Wh1Y=+l63Ö£­' ¾mû]DP°æN8^欿ç×ëÕTâ”ÇÒ2™EƧ¬2J1ngECîËɼ!-S„N¼’ÍÃEéúèˆwìf§"ï ]G…§O\ r*ùë£Òjd~6ùÇrÊÕš9*ÚøöÉSDá•ÉÔÑŸ 7–éáR@ #º&нn!©ñvIJrô4¦röcïÎJ[ñÁ=]°÷ÍÝ!™cÓÙ,Hkˆ‘ñœŽRr5ÿ³?Þ±›àbë@A;ÒüðàÏz%•9ãèg'×ܘ¨f/ÔeÍؤby^w~¯"g´ ¼GªSg*•ÊÿLWüëH\ZW{Ñkì!<Ø©G;2u*ì[R]âlBÍË] CˆºØŸ=ÄÒYPV\ZRärÀ£¢×ôP¡Ì ¡ Ä™qÓ7»×H‹Â«–)?ØòsôX@c¬ê£eËés}ü€qÎg I¨\°èÈØ­ø1¿ž–B®Õf¶Ì¤è†NÇâÛÂ%ÁëØÍô¿ÔÒv2î/ ¾…¹Ž#¯QÅYÌÑTsúgxŒb6ök&Hug‹ÆYè kn'A:m}s0zª\5˾ÿ¿äõƘ´[ÝIX·L1¼É:‡ók dÇŸºÏ›œV$¤2¶R˜²Wƒ6yQ”adE›ØÄ„_ Ùˆ91çVµÚug•MIÕ¿nÏ“w?&_d™¿ìéX¡ÛA9oÓYvL€niË=.¶ÒfäÁžžìËÛ’f>,‹›²1ODõAÙÇ?ŽçÊð$dYÓߨ|^.*ÕZ^•Åp®œ­³3*?*õ¶F¸FŽMØEÒÖ„l½ÔîêŽD„ªÕ ÙøhäMk: 8öÈÛDNÑØWþRSK³/% ï»2È/v¿€Å«ÒéÇl„I€sªÌÙÊ1bàØÑ­êM^-âƒP’³"u‡3Û Øä];‚¬pIK¢óœ¼[{£Ì†"µù+óÁBrÜç ³<ˆÿ0ÒSOzUT;JWÁcÅ/B;§ÁmS¬ùswŒ2ÆW}ØÐÃÍOGÝ(\ÔÖ¬PJ½ÔmÞ¥‡úh%ÅL?DvOEyñÝ-æD´õl±OùÕÄêsî0žêþ‰V¹@±BŒéO’Õhi#´h¤1¥3³�+¡C1QtС!˳ÂkvDX9çé+4Ðlߪõ{XQL§ w7p&ÁÉ=Éx¥÷ù}0&5ì;ºv2zº'>¤¹‹µÿÐ{Æ9òò=I\ý¡ ¿ßx¦ÕtX,Þâ5;:‹k "«ÜÖ¾ÈWÍîarúÙ“àwȬ8É<nÖY ƒ)ù¶³èìÂ"\ùLÒ’z¬*’*JÐâ œ­ô G‡¦ëwÓ—I ~3ÓŒ7‘¨Gúà­?©ÚN}ë³ì�&Fîª!U_—zñ©Ÿy�0XCÐÇQÀö®O£“ð`…óïã3Ô¦x¡8%'A;àÜùTd «ÄN«úܨ!¸\óÂd0úæm¹�Û4*9ýïÑøÚxžŠÀ¶èqía)±Q_°¦ã…t¬/yPXÞÖ¦•žuý_z€ ÷Ý?2Ϲ‡@Ï|ö!m£íÝ«GF+ñ‹'àºæ)Ü­ëûúÔW4^ä0¨(÷E·òoPK ØXVÜ]�ú42ûKÛfÉ“p¡˜œã–nGç1³Ø¶ÞáqÌû]¿>xce¿”Ó¤ÂzÉN+Ð[ë"™ph,9Þó0K=·±^Õy,~ÉeD37Å™+_g¢³A�C  ˜ {a ý&`Ä›"•ÇÑ“’e­ENµäméäP{2ÿRêÝf{èAódÙû$ ²šH„CÂ}&S*ŸPÒÍ[ØE>ZtJªF ÀBd7L%2±·äCEvÞ„)d~óƒ-H6§XÈx±åØ°�&3õ21/ž‘‰‹c`!¢/šÑVY¥2²Qo·•‘–Awù]K´À”¢F>ëªø{07ÐÞ‰Jƒ¥»è,zO[¾ëg(rÝ´D¢Niæ8?¦ÝøA¥+NŸPÑþÙ`œ²åõÐM‘,Ql!=T1•)dØ;Æø‚…ÙÂò* úž`~´bà‘Îöu7ßWûú<.®W‡á|1ÿÒÓ¬2»yrÉ,)™¬Žgûa9µì­øˆ ³Ü\s!gÓW'©7N¹×´B^¬Öô髾vùþjÜ5œ›sÝõß/ƃY Ó¿vÿ6zùÜÒ¢€Ü®Ú¿tt±R'Ò_?Óî]¹Çl³ñ7ú7‘í£ÉÄöŠÖH™¶Ã.VþÿV/Ì&ð2QãNj¤ÃìMfùjwŸ‹¦«ÎéCq€8^è”èØ_·ž’êôµÛï;ç½á¥YZŸ-oÛýßF– ,sÊ=Ÿ9 ŠÍÚ‰Bb93.݉ôþÂÉ(¢»U:¥¥Âpˆ² üùq†õisšfÀ*Í9ÄT_ý÷}ÈYÏ«Ûït¤Ïþ=ºYŸݸÙÁ€Û„”ƒ3| ÆE µ“¹ïýC¨*ÒÌÙч¬–L']ÛyB-üðLÃœ¢wõašý)§}€Ìh¶µ:qZæbª …E°CtÞsGêì©èYxíêØP^Ÿ~:oHÒb¤À3 ~òJ¥¼½x.š«B@Ï"mÎL7ñb&ôfXs0P^…ˆ=íÈI¹nç9 u߶BIŒ*"•ôx)ÑáÜrSølNI ÊMa½§ˆH ¥ê{J9dúƒM8(\h!9M×R4D„ßp^š§®÷†*€ÈO[¯7LGʺV] @[f“ß« ÂÄ!M¹ÍÒâ-p¦ê/éEË™¿PC #WüÓLg•±ªÆ<žã‡vîa‡¬ÕJ -~uZ˜û÷2‘*taˆÇEça¨ûñ¨Œ«±îÿtoè`îÄÖO$¢–?õÝAÓXJKDý˜Ok{e.Ïñi;ÒŸjoÌp€I§GúNöÂ(<-~BáàÜžš¾rÊí[Ï;üÊV€»ÄœO8‚Ñ ªQzÌO&BÏbúyq¸rxø¸¤ ó죌’üË#”ø¸ïvkΧÖ"ÛH¯j³˜9Öõ<›^ÅoêüðõË€:^m‚a’”=Â~òp‹ëjÕy¸(JÊ`¢L³˜•Ûh™f€Z ñyØFËñ}l|êÙ•Uè:6ËùÇk±ž™áÑÁ)þßL™£©¹•;GpŽtm§³ó£øxî~åˆ|¥|~lâ›Zƒ)rÜÛX¬kß{n¾vI?å*Ø1Ïé-”–ù>Wâ0–)µP¯)“±ÊKDŒØ§ºú“P"×)I&‹¸�tºcÛÝ‘µ “­×mR+O'Ȫ­VMdkçÖÃJÃt;©`ÆMyO ŸN?GÓHqSh­P6üy2"ügÌÅmÜîÍœ¤¼cscÛ9•a™Ï¥·¡5‘bñVÃ-—D7`¹V%šÄ‚¬¼EXüµ -ÛHËé�8—µNåáº7õ ’ù±ãâͲºšçt*–~ŸXBÄÏäè¬vÎ¥V¹Þ:@Ñ™[z#Ö^•@ùÛrËN¡*³…º˜Ò4åÐ55¬¾P)m„}Çý»¦Þ“kKbò;¾¡ ²öâúü”Zã7(*ÈÚçé’W?Þ©¯’,·®Ù(ÙY1ú5ZÔ{0[D6üL>…¢ÊÏV=´òþªS˜-Fx¬GÅvðp¿ÒšÒç>JŸ‹]È~™‚FqyµÌ¦–ÿšXG…Æ?ëÝz¾˜ÇT^¹O=÷¸òáÚºSy;[÷MèÝŸõÚõ/Ë}R+DjƒE­žÜ“©,–€·•m…s^¤a=ž†…‚§è˜öÕ —¢™] î`g´KúûFô‘/mt]°‡ž†vgyä ¬[MÏuÞÃ(…o1FXen]¿>èâyRîO(6”×}_¼Ãr ô\oT=‡ÅXî‰-@¡:�â›"CeÑ7ž°J_N¯÷7G&®§9P^ÔwZPë¯vµ£ÌX­ïŽ§‘õH)L¤½À­æâ±U›0"|èЩ‚œHh'âogDšïÚg%žû’´—û‰nNùù¯§pÅÂSêžu´º—‚Ø÷“Å"£ÈkÿUuŠ8Ñh%®È€šŽeéÞþf{G†ÔÒOŠ+‰þ&OèájôNÙÜSoG§£EÚMÖJ|`,VU>Ó3d~;•4zœ­?ÜâžT�|1´A "âðe¡öp3ʦ…@ØøÀPJ‡º!âïÞ)£ƒ{p1iÖñ03…‰¢óâÀZvz¿E_ÇX*FÒ»é³<?;ý °XŸZíT —ýg7@-kÚÞþÿƒ3vá=S莔=ŠÎ)Ñ rÞíyŒ¿8U#“¥/ ܇°$7FJ=r„3Ûì Ê2pKÊØGuG¶O´ûÃÀXùàËŸ8V¹§œSˆ ÄÖ6FÙqf¹ÆBbþF"ÌüÙxÄ Ø š”jAÿgÇ-¥9ž›ãDüD£–¬ª»/6F™/¤G¡jÿ_ªn2B h_¬(²cUñMƒT$³ü¡ëY™QfÅü4H' ˆ°+ÀDf¿µBtÙzËwy›†éÃõbQ*˃¤µ¾,&ˆíáÙL»=*ç�hŸ…Ž+ $RG¯5ÕÐÖpˆ@ ¿ÈŸ89uw¬Ë³pÙMšÏ€$«Ô-"80oV˜ßI¸Aº!(pïòMœ¤ðÏ\:bAMªæÉËÝè\±ýÜ_“ÒxÁ˜¬ Ï—°sœ)Ê� =8Y®[y¾ß öùàÍ2V°ØžüyøŽò·…·ÊfÇ~kô>Ï7kÙ]”úv¬‚âóä50/è¸.ô�ÔNçK÷¢Å‹3 9€BM㺊Xfuø[n@¬Ã~ˆ1÷ çñÝšïQQÑÎ%Þf¢|"Oý–_@fS®uÇŸ!È­H5kI ìžò€äçì9Û/kb7rþ[ çÇ(^åãº,¨¦ÁÚžëyrm/h@ G^¯xEæ»F°gKŠ ê•8Ì»étŒiëÍ—#}§Ö¿|_‹È¯©K!“QR0[8Ö›»í‚/è®›ÃÈ9ÅB˜ÅºNý5ýj0ŠT ”¬O0‚™Z7�´•”iõìz¨+]x:™Ùßø›:~w½™ª úÖì¿·ÇJ˜v+IÿÇ�‚o‹Íx‰ŽVúBõYÂ…œjÐîZÊk^flqæ£|doNiP¬;gÖR½rõ-C-€DÉ=¤ÈŸ†AõÝyzb<ŒsŽ÷åŽ|9ÛÐÈ 5±Wþ]^Éñ²B£Æ�Qßßâ^~)b¬‡¾ ôRƒºcHN›Ú–‡‚¡ÿç¨ò?=&´·¿yü(ªÐSÛ§;Ôötô[gWLXW[ˆHps ìÖø~›†IßK…·åÊÉ¢Û–Íè$[Êô=ÀéÜ/ V´o);çÊ°9Ð38Óǧݮ¯jÞ¬Å~é8 {'ž°X‰­Šî=ÙW9*ShYspÜSþg/ͧTåO§s©ãi\÷¬ôâÝ+C_+‹r¬v†WçQcÑ@ÎèøÐjùc²í=äN žOŠBoÉÝèëæ¼C"Tf¨À:8ɦUMˆé@„nDf²!ºŠÐýP'Â…¤ DŽxhôm3¸šu®­PŠˆƒr¨¿§5‹X´y¥ç¹à‹3² âµú0~Öm§Éz†T–˜¸¼îïrPOá]帡‚=Ý*í˸1{y"æ’�Ó„¿¥±EI¼ðTÌ@Тbø´ötÒŽÝ�o–Ë]“ùËÀOJÔ{@S:‹]Zþ,òòž-í³íý·~v¬›~w�_Τ@Aþå:'YšÓÿcÔ®bKž¢NAð ìz¦ _©¥=’6±*ÚÜü¦ý®o«ËáÝ oz<ÒýYmŸŽÃ# mqæË„hØC2ÛÒxàc‹sK0Ø®1·Cï §ê”¶çNá'‹ƒFdztcÙ¦Ã]Ýå}¹A¸´§æ3ý.V »6VX#ÿ/€¦Ç¡§¯÷ÆŠ¹âÄUæ•>uPG<õÞG„‡'£ËNAwÞMwsÞÌs'ŒEt»¤àÇYáVÎ[PŽŒ˜éüÞön\osÂÄÈè~¨XŸ¬"²u©ý¢8£xX+‚sKÁ£úVraÉ& íŽ%­Œò’L®n^¯{@ Ì2í=0ºhåçÉ×`ß œm©~�‹°uƒ…ÎSi4‡âÉLõ2hÑ&Ö—(ÏÚôy2ªcf;0çµ>¿ïØ1zkǽ?/åEé#o#ú<Ð1>Zà0·ÓǼ¼»4üq°mò¢F›H@/ˆˆº]o¢ ýjë¶'°Éïýêm�Eæ:%‚üh¶F?ÑÚbƒÒ¢ªìT.€î§Ç4‘²Ò¹qlúšã ˜µdÅ(Ý 9÷ÿ%ÇÁ°è¼ÿËÛèh?[“`> öpÜž[9U]Ç£v±§÷ï Íäê§3»Š×¤ÊðQêJ÷C_nRƒu´/�d$9+áÜ'Ÿ»‰ôÿOÛ›,·®$Ù¢cÔWhv'y®¡o†�6B�¸)»ÿÿÏ—{xD€")jg=³ªMH™I‘@„‡7«‰ŒþäÁÜñ_`I™fW­«eWQ§¼ <RcØy_Ä¥Ò‡3VŽÆÁÎk äÏ0� BvTÃÄ¢&8¢þµÇ6àJhÕû³¿8çÖŽÑz2¸0Xq¨~åéH¥¦µwµž 59å ?fG€f“Œ•xÒĉ0D,¢²9ÂÒÊÒñÙ{v<6]VÌ ½c^¬e\ú<<@º"Hþu(øUc×^É ÓS ýx®4Ü!‚߸Ñ2öóÜaH][±Š¾­“Æ]¨–Fþr/õŽ’ìÖƒâƒöm¯,gÌSð-…̆©ž¿Ê/«µƒP÷ mtÔÖ— VDZÓºÓô3g—îõo" “"/Œ¹)«/ôtŸUÙ:JYCmºÚ ñ^â®Ö™ˆ‡"ªÁÐ%yZ:r0<µžètœIzÔœz§xñЭ@ð%‚t2Ó™„ï‘øp²šAñn¶¯ßó‘ÂRðeØÜTE zÇ™ˆˆ“½ñšo[PÃï\X´š=é+Ï,XèSd­"lò´ä )¢¤='c奯¶Æ ùçA5×ö¤á›ðP.EŸ ó¯{Ww1áÙ WtD¡¥½˜[Ýõ»ƒ‘^¡²JÒ‰‚vñAäÎ ì`¥Žî^®gèeîçqȺTÞ;HFÈüò‰b„ÖæQ÷g7_‘âèvM;ʈœ{  §ÆhI¥æÌ´ðÑ+&ÙNï“y ìn3[2Ô=JäÖ Q�=U‰\# ~ÄT±Aᆆ×v” ,ŸªBÚF‹l€V`$­Ð²¨€{G"ÿ~¾±Š½0WI} W*‹Â‰L¹ce\Áèa”ŸyŽU§)éÍæH´#6à :ʲÐjtÃd·¢¥©Z#Ìw=ÌUaûx¡˜/SY»œæ™n€o[Æâ_tÁxk‚[_¿¡íòŸ·È´ÙèoûÎA )oü�ïÛF¢3¸ªC[8±ðŒ°¸7÷«ájHï÷Íÿ«¿k˜éf:™1T zo~w5:…”·+¥¢]ìPúSRŠ¦ÉþðƒØœuÈS j÷UR–hAXý™òߎ–¿ªË`s§³©ê¾Œ{ú×CõØ •äÆâò‡R1;ˆ@/ãTµtìcƒ½œú?lŒçlÍßÖD†ï´†$[[Æ„²ÓÑf%MŽšÀÝ ÔC-bçÀ] ¼Õ©‘Ee测i ²[Üœm¨<ü[³ ¢?b¯Z_ôõ¦Ú.‚goQr㈠K¾U€àKÌ«Ó£ÏèÞü†=lM—“ï§,HšwÛèX{l}˜Á£¾>ŸªU€o;*h ˆ�([e€Að=/}wŠ&<¦ô* ‚6« Es3Æs§DPÕèf–‹èÕùb{­î~nx [¾¤ãÔ3[Ï-ª™ýMN:l•iZ§'a<=Õ&`‘z_c!ØLç–‰y/*)ZwåPÙêWº±ÃäùˆPuÑzt=†ÚÍ€Ÿ IÖ[ZÌœvW+QñÜwðUÜ×(‡ý|²¿Ò/K?¯c”O$¤êÑÁoè¹ëíWå>ÈŠNëf€¾ÂÙÇöt¸+!l™r÷ñ¥;›Ó8[ÑËg/ƒŒªœ<›ÓˆAð®[y…QÎ÷ÍAð¸MU±Yö ÅŽKJvÑ–dNýüeë«ö«j¤ô¾#r7G: ¾ìè]°º¯éO)Xv¶Ì”7Œ*¯ ô ÏÌ'*ñÓÏO÷�~Ië¶V¯ycS¥ûCÓÜ"`ݧM Ès˜ÀmU¯˜Âî!U§ò“x— ûìZOrlÝüèZŽžÄ.V%}J;Ny6 \l'ú` ‚žµ ì^ :»¯:Ž/Ý¢áÝÝ( /ƒÉò‚ íÏŸ%ÍâÂeÄ¢¹)HõÖ?­ð<ë¸#Øtõæ¤Z>«ŒÈÌyC¡ð{Ÿ?¶B‹™œ›,ÈC À°AÖ¦wør¸£;D;Œ‘¤ß …ß©£=p©¡üf åÑ™øÎËÌm_“SwŽ—ÀŸk³?áåN§eU‹æ>ð?ìi}ZwÝ­.ug»Vv(J×ÌQ³ö-ÐkYšÔϵ¸\óYrª©è çõÞõ)1€ãÖ´ª¼d1ë"¶vWs-¾-±— Õ5MïÍ-»ÑST€œ¬lwõXƒÙ7ÁàÖ÷¼PrþþålæÃèìZø;öæG«2,ÁÝW…­GþÁÝL”ØmÎtðRIØ÷'I–¾[åDQnå‹…ƒÙÔ0=ýTAXä3ïõ|t$Ükwúsèõå±&JYZ‰‚k¼…e/n÷SÄâ­VGKÝÊ­·Ï;@"cå‰/?2ªîíp72ÇT·µ"]ç}â-ÿæÉ•Jcâ(ѳ6méO,£}õ¾«e*¥’þ<bX‘þHÿÄæOf Ž< z›Scòo#Jo¹°õQ={ÆÚÊ5ÝÐ|Ÿ-j5ݦÑrä•iË\¿xŒ)Aå=– WQqŽŠAæ¥ì¾Ué–ž5'öÿy3$‘xoþÀ¡ÿx.µŸÇ>§†VR3$AÜ7¶gf„IAÑqÊ4˜÷¸ q•ÚžD„‘ÞLk?koþ‘¶”¼\×›zšښCÄ]}Ce&~Ó>ß}ÚÑÞ×N':¥÷\ô´?S™œ­Aa¬§f:=rkÎí 0$Tœb&Ï3šð…¼yÅwÜ(¶ÝÛÔðˆ½Qáå°³‹âŽÌw]˜(I|¶kË †v&¡‹d<îð˜I `Îöì'¨ç8)*ŒO ,~Í-þƒMÑèùˆôѲ$ýკW­tÙØʤ*7ŽGB¤9—~«ÄîÁ™ñJ.~iíÙÑiÖ"ÛÂ垊ß'j¹ƒÍÈ]‰MCéÐÕš|•€ßz›yý^|-Ó©4Úå—º¤¿0ªÈ[¬ ;&º1ÍõrhHÍ˾î'Õ/Æ΃÷‹‹uGÑ;iÿu¢œ ß5ª@(üÊ Ø"™¬™ËfOñ®S¾b­¼óÿ¡›üFežÈL¸¾¯”r„â ÌÿIä†Â•±›èéÛU–ŒË9éÊM&>Êìy³Ö•\þ„ã›m_ÊšÜô?só_ÛÜY]°°0|#ý­ÄùB‰5Ñ2¯pЯؗW•“øa°qkÎðÊ<höúP©;üª´¬Kæ{ 嵶ÿ‘6ÁÙ¶þC•¬B¬'²§îp¡žÌÝúíΓ8ž†Åà˦ÓU˜r/�ùiÍfÖº56-f žMã©‹Ó–?ô^"Ë}„R„I8»f«ÙZjvȃbéÖí¡ U›çÃ"§÷U^Ô)=¼±X‰Ì´pÊqg: Wp‡uSy×wr+‚ñ,$¶¦teˆŒÀ¼Aº³^¹±ÞPhb½ù8žpþ2ù¶ç,GS8žhŸ ö‰Y—sšÇƒõ“¼oµüÈ€9-­ürp(Šçyž/®œh¦óFñ9RÏ«zÖèd×&n'®äg=ÈäM£C㸛§©÷Æ) âÁÄVÂœÁ¬‹Á94ç¶cÜ„®ÝžqlÁ¬lZÜ Ll{ šG ™ç& ÃëNTAfïpÚòý÷7 *æ¶Ï#eR£Ò ‹ ©–²â…•k¹Ëþƒ°OlÓ9 M“èóÝ“aÙœÊPjù¾Žpìëne¹Áµ€mÍ¥^swÏ"SðTFäãRSY;YÞ+cÖ^â><®onV:ô6}hoÒÿ~útç-ãq4A`|ÕC’¦?¬béôým52žÀøJŒ-HËeêO±X¢»ú «<r&³�O=àG‹iY[5iizÚ|,þ÷å¶Ðhî-å"Ï‹•Õl$EgJ²Båz£ p8ÎÇö›ÅY¦„X˜' RF^“ Œ@IL¨üýЉô=·—çÆ/©kƉtÝRƒ>×yåŒnIÂDëÀöÜõy° bw+} 1ë‹J³¬ÙzÒt.;ü/®6ü¢43¬µ ×�Cu;+²šS½,Æžå¤dÅb¥ö°£í¹XÑÊŠ5ã‹þ3Þ½/XøæN˜!d&Áî àµÑš°Dã†þëµJ÷øæ ô/¥Ùñ¶g ‡}Ñ<Ê Šz3%A^Ûù¦Œ ²¡ŠÞþy‹Bp€†±è[©d1þ3þ¸Æà2ÀÑHbßc€ÑS)e™:¢åö¬i©H¸l<pT¡e -Zb…¹—iCe™Vy¡JäúŠ›#|Þ¬ø)ÝavY‘j¬íÝ+}ï$uL‹ýEhçÏ!W<È_é‡+i>pa úãÙ#t<½š˜dðsAöÍÊ Htªr‹ZÛÀDZ$†ÆR¤™È£§ƒå,*2‡¹ÆB¢sš¬ Hˆ_x²æ,xõ¬òýL%X÷]Å›6±FŽx¦Bá‚èPk7覯›ëwš~T%¾«r]_£G£‘ÇiÝõî ;>Ï¡fîɽ±4[F¹_çéÐÔ ”ž«ûoJ\}-dv†�¸…¡>Ÿ˜Z4Kš$Kò…yW¸Å$‹§ïP¹më Ba²¹3 äÓ³š«J'ÀßVM (KäŽ)$Il3Ç)û/k|)¬ ]¥Vúox¹ièÏàú3®kðuª§³Ûöš<¯\>{¦Hb¾™ó4ÚŠHÒùhž»r|®N§a»a¸JµÑQ<•®`{žLë.,œêû‚ ßf/pT<hˆ¦•ÜÕÒ¶‚}:ÇŽoMK!—W ó'L Òå¬#Õœå[€Í¶ƒ‰¦?} ×÷©žn\x.+§_è["ºß=›,h™b§'ß/îP^<£&ëð7Jº/jÀ*úC};`~JN}ÀåÎUuï +Å1ë0;°+³Ëø­õרôŸþ#UÞ'›²6Ü9—Ñ6n˜öÖœqZùSȘÁ'P™å²¶ÓEfå”Ew“œ¼Oà'iá‹^@œ©xûÉSbƦïwúÒG§åy˜æÕ5íŸQšÆ VC§ÐƒW´J×È€–CËÒ¯#}¡ñùò ³Á±Ñ6=ü6Ï[O‹Ýdø²ÿ°öÝÌ<ö ÃÝ! eë™*l4@¯4~^˜£V®ÆÄ6ŠdŒ~ªŠAÌ|ÄÓLwZ3‘æ°’ærc¥§dQ­¾ë'ƒw-,è±Ò'cVMߨ€*#ZÆÔZCÏêF¬·)(Ûlõ†lúkÛÝø¶r6>9s[iXЉê^™‘Üþâ™ GâÆÏ!Kß6sZR½:zÿz@¼Íì y§ßFÉÛ?**Égµ¤†²¯ZÿFž›ª˜i%g„$ ÷ò Nz™<q›R$iè#;açy¤’¾ïoZXQ69§ý!e»éùÜ ŸkÙ*€ûDøþîM@Ž×¶•‰ÞÕIdŸÝrŸù°rt òOÝmûÏN'%2mzZŠ¬Ÿ«?Ýs5jŒCÃ晓 Ø)ö¢.h[ÎKFÌÁK3·È�¢—L¥Ë¥ 2ãˆçY àZ%cøóiºf®Œ9Õµîý&Z¾"Ä C¸VAÕÍv=Ö˜â45ûÂG«½€\K4VH+ÍžÖb×ÙÎ5ð5¦mÖUŸô_¹F#-ñU¾Cƒé˜õ8)ñÇåIŠ?‚sdžî6‹ÇíG:ëéËjG›|_Î V|{j[UÚ´Ê8�Ñô³¿ÜiIíî‚0ðhqÇž¸„âŽþ ëÚ[ܧúC"¼�õí¦¾wõ]~eŒËò.з։oÍÞi%ZÚ…étbAª¯Ghúõü£[}¤ÜHr!5;éHO‹2IÖ‘¦,g‘lãYíO>éoù Ÿ¾{°hšP$d£b -ŸGK÷ƒÃuZ¬D*ÒÁ…)¬‹sbð™‡aå8ó#!&‰àÚâ7sç"ÈÚ/ã]QxîPj×UÿÛõF ãEAäè¬;b¨dífO÷¨Úë�*Œ[ÑxþÚÞŒŠÄ÷Ðé-Ì|wöhŽ €Sútµ*Qÿ½Æ|’;—3†ÕÑ“~N[He[-ºQü8Œlˆ#×Þ§ÙÚÐ`ÔnJ†ÏåÃÞrb¸\cÃÎΕ&>÷#ŽÎ¶î9Œ 7†BB«#\"×µG!–ý”gZeP>¥Q99³Ýe¨ÁW;�UÄg)d‹;´Õ€¨Ñ§›N¸˜†š‚ãðM»ž¯‰oRK7Ö|lüL£† ΢Á€ ä¶èᶳ‚îXEÄ.¢Q“ÉÞv^Ø+ø`ŽWˆä¥ è(P°Ÿª*†ágòô±LäÕZ£2°ûÐÌ=èl¡??Žp¿­Qù³øú_cšÍHÿËU„½õõûé’D~U‚Ù ä¶õÔ‚âó– 46Zœz�H)ëÞÓd“Õùm:®>Ã-†ð=òlyw߀§žo#å÷s ]Ûú0@P°Þl@š·%Ëc;Ø8ŽíÀyIiä(Îv4âX<ØYñJiâˆÌ2ÜžŽEPZë× ˆ‚zbuaÛe£êUä`W~w·fïSà0¦A:ŒžR½Ù‡¦ë>ÎœkܾzŠÝ¡Çöâ»Û•TêhCj•`<]\š·Î~:dΑQº×Åàø_½ˆÁ°:{;v`Z¾šk€üÓû‘ÜC)ÜMf\\ÖžÚÖh#¾ª”Q¸‰‹ÐM.øVk§ÖŸ¾œjÁ »V1p¤ÅÉýÛ„Säuh Ø ¬õZYÒèÀ0©Ö˜ôû®Z™ùVã�$AöÙÜØ~Ó Bõ>t½×\û™±[*&W ŸbÑ­OFEOfÙÆ/ô§Óï¤ëÃØ_°±X‰Ä­Ö…Iªâ™î_ê¡;‘‡¶"‘Ì‘ë³5ç®Oƒì½óÔŠßÏ@€­nšîÊ8k÷'ï_ÚüÙ1ŒçòH9b1Y90›cêc‹/Ç kš‹ÉÈ{8Zßvéú?™þ€vã9ûÜõmêúê¸ñL5ê[ã +.µhîÌ ±²³ÌÇJ°Vx,JM§ùRóY0»V¤'i¡Ž»‡ã(J]tvN°ñƸKÁ]÷ù –Ÿœ¨88¢iþ®SGQ3Áê“Çé‘-òu`ጣäÙ,T§Ü-§¯/ôÁL™Ú¦WQÎïÏ%4²ÄÙap@šSzHÖçÃ*”c89mÇï`ÐůvÐŒ(¤ÄÎÌÜ<ŠðŸ³Û¹ f¨œò{“mYØ´â»~¹1Ê2]Xï-žIú†FÀs^èŸpQ? Ts}¡%ñ—RÄ ®[{©os³$Î,!¸PÊЀh”½€”áÏaSO0 >žõ½d<kw¬wK¥V¨wëçrK¿0<çùQ©¬‰ÉÓ`N² Üž=œ Á˨°(VíU¼o®Ö6¹!Lîiãw{ëaûÆöz.Ñ—mê}î£xÛË`³MÁé¬=ô‚Ù{Ö´r)°Õ,4íýðª^fîùÞ Uu™è¥mëeÑGZ£Vo)¨ ÞJÅiâˤÊt&´2'b#ŠƒO¬xE2êÍE2dý¨~^>Æ‘3kÙAw:ÒºÏ?µ³«Lzí–°Þ]Å8r ‘¹O#&mïõ+ékR‰,ó* ò¢Ú«]_×>¼¾ *k??0ðÙ«:›,H B¶Câ+êaê€ÏçrùŸ{HQ¢®(Ì8¢Ì’Uy¯H뢺Qí;7Àx‘ª¿Ñ#-cfEû²M‚øݺP–«ä÷Á™Åý@5xhp–d+WÚˆq Ü»îëLu¦Þ ¡ò”xÖš‡0ù³èpȯ½§•ÃšÀ»î4YuØ™ž1ôþi®<?¨Ûó­,FìDŒTÞ@Ë2®ž.–GðÑ4¿÷‡q””à>h¯ˆ²µÞëL…6ŒÖâš©f;p dZRsV¯n•Íìœ-1€¦Í6O‚´Û{Z¬Çº›¯”"ù Wó/2¥/îúúHw :’wëQ‘b…F´Ùâ½Þ([k¹©ß⥢3÷@~9Þx?Âíº×&ržA,h²…Öoú±k™Ì"úê¯58N§æêÁ"þ¼`¡5ËQþ5N(t,VB€ûÝÐ2;^DùOãÈsÚg(‰\NÏ#“#Öy×(ùÓIvuvíß–r–Kéu/á2ô3;JµÚŽ¢ðîìÖM×mŒ oôOiµúÁívSwÁ±µÊ®ª¸Ê¼ÎrÄ2HÚÆÉ+£ƒvV hA»Ð×é tB×ú8¯"}]µ(XКÇÁ¥Õ耬½è­ø¢¾êü7Ž²È_0æÂü1Ü4óôwáI cî÷8°ð»Þ!-ª›òASt¸H2CÚaà@G©×i´€þßaÿËÈçi‡eðäü]%ìñ¦¦‰Ã 8§óé(ÿr«ãRÜYà%Yì‰@Óu¤°X –g ˜4ë6Œ•ÍCÔóþ&íõW꾩ǎÈÙ[e BêËzÌ�îÉ/ix¹}Õq›m; :—y[—Aô©uL¥˜›#Yuî´ÀqÄ6Ý×}^aîMKYKä¨|Ö$ Êë*!‡eº:’pÇš>ÝS’”YƒÌ”þ;½©•ú@œY6tJv†GÏbÏ<=÷\Ыª´®Ó©ÐŽKJµ[Sô”+#®äV*ë<‚‘îÙc¬ +Ì(<ç#o¡\x«m”?5{Gî‘:-³ò*ÌoצÇ÷®¬Zöñ;TÐÀ–tÁ³-0UŽ‹NÌÒŒÉ:˜Â Ûå·T‹Ì«¸•¾ÙSu’6¶I­—x¬à÷ˆàeú¨ ¸ˆÏêf{T`[ë óQ[Ô:”eœÈ‡¬ð_-¼€±¾£hká°æ‡j_fQÚ©of4ÛÛ.cwÙH510²¢“Yg>Óad¦¨¼ÀÙfz“g}£‡V+³ÝDoP¡ôÙMèfH& å�H&ƒågÿÌúŽó•A&1(<²«ÍÈòìÆñq6Ê3<íg3'—ÞŒJ¦¾qç'Ðulùbп´¯H 7ÙàdoÚrf™Èd<ƒRÛºÜßÕ‹pþ€|iï{¿´ sk^b–A«æ«öD¯€œõ­f¯4B'ìÆ>Î3•ügÕ -DXC‚“¼[é?©ùÓ(ó+ôCpçŠaðš–0ƒçÚsäÁLòöµ5‚<óg©ô¡; ™½vÛ·<k:O;9Ý"ý©­oµÕŒÅil.TÑÚB&ê*Ù S‚ê´÷ÊüPôb§ÝGˆáJ¥˜r‚ŽÌ ,,î!¶ÿ«ž5Eì2fîVûš•óxðÜ'ÿó%Ö+kî!´p¡4bû+'ˆÂȘ7µOh“ÖÁ:9¯áCñ4áŒW¢ŒˆãÿW [XW™µ#̨§Æ' xJ ~ÄŒrY 8CÒmª‚r?»Aýñá@¹W_[e‡…ÇR´)÷bùz‹Ñ(óÌ#ìs¨¡e‘MeË%Bs6ì Ùý”0ôw÷~¼dÔ¥=ï¤ >~Ð3+¶­2NJÇÃ0Å‘éúžRQ¤ÀÉ}7”A±­M¢jõ+(è®u}'„ XY-ùïñï°P¾Œ$ÕmE^™ï¨Zã oê\ºQ¦71:5Þãûzø ÍÊŠ.Ü)FFtóûhH:™6ßfÖîç—RÙEÒÚÃ×—Î.1|4ÌX[#á±JÒ…ïð…âg¦[ob L[oê¥ósp¥"V˜¿ý mEæià›:Vh-)XnEù©Ý²Ìù_ÁÛN·´nÂ"¸ž"`B.žè+E9ã¸{sÐb…6Kƒa�JëK¬}èvcÔaVÇo-jS‹‹,¬6‹Í�7þ&[ëþ™2¾Éà¹Á`dîؾèÀ[&¡OÞ¥²¹¦ÕT«0TBqFŸ¹5‘¯=O‚“áüß0½ËgÀ…óÄwmâÄíH)ClÊr^L׎éñ¦pšæuì§N©‰—srr<!b¼ë¹»gÞžs¡¼B\’•ŽbßI*¿ïþ´ípï7÷ü»«ªÈ<h1¿|H¬ç"`¼ÉV©[�ØC ˜+ór³/˜ o• °ê&¶´5 õ/úÖ¤  y­§Ïû˜DÂçÇ2×_´‘µx~Ʀ‰OŽý%æ ¤­E—ªÚ ÞyÚœf+äñ“Çeµ:ÜÀö‚,w¯µK ó®feqíÀþ7§²m‘0+Jć<9¿;ID6U¾¢vdŒùˆäQ¨¸µHáÀøô´Ùòt^ qÝé 4œºCè=š QšêŒüÔ~RZúunü¡æžžò8šø’¬‚ßVÚyî fÿ΋§^˜Zé€J °Ý«4Õç|’¤ß“òàüF;ÿÒ€a(O¥ØV÷8&‰}K4l€T&kʈùíÏ?µb¸Yó¡JÍ/­ÀõÜA2lT¹þDiÑÊ=÷<ë˜àº¸æÝt|îÏÅáD"VXÜüßÑ Á ƒe×…jº@î≠\I01Ê‹>øÎÊi�t7B‰^£ šsño¥S"yÍO™¤ýHºøÔUS˜xJûâRûÚ×ÛñÑÚ©²Dç‰B …ÖU‰¡úXÝSwQ9Kg‡fØ3ãh«þ§a£¡2šG§P±?ÉéLEØÕ¼ÿ†ð¥oÜE7l¦øZ~)C9Ç|š&ëß4Tcs9öWÆi컡?’WAtn¼.€Ôbº6–ß·ÿè눖òCdUé»…‰Î=m“e¯ª9ë4óØ˨!ë0P9v¾e;wÒoÜñ¡Ñwt¯¶;'RéK^Zá8%Ú޻‡¯2C€F cÀ/­*6ÇõŒžß ¿«pÕ¾gÐYDÖY�·æT2R7åïqg•O ³9Pp5pؘŸ-ã؉BÓžIçWÓs‘'#‘oHÊÑ„±z°­dÇÛnàT{ªvðýâE„Ðka0þïH·*2n‘È yº‚ÿïE*òŒì°÷¹yÕÞÿ>qì¨ó<ÆÜ:Y¬X]lË´; ¶‚ééÑKšë&×ÞÕ7ij Ï ÷dhqe³îo¿-´4g+Ü“šxRÔ÷¯{ æÖRÆVîPœ_èý/-\½s)ç1%}8œò¶(•ü²G1ÉãŠùûˆ8óÒrö§b£ÑvöÈ Òóì¯~cB]…¾r7úw?w>½}ö½”GŠê¢òÃÄ<RZ¬œ!TQJ¶l=)׆nçåàImoh2ýu*ÉÈ|òØžÒ²˜EÏ"ésR®1uT6¾ p³Ç èÇ“¬»cU.MŽØ“ôôò©3Ñ\ð¦ÒlÍ«yÖÑcy²Øò¼J£•´iDq'µ¬š÷ssèmßýÜý®7'ÑOZzUšùY`¡›ÁJ…‰ò«±^ü»ŽMæóÉ(k[XÅ°Ö:ˆóƒ=Ü‹�š4óXúÙø—wLöÎNøIПi%Y‘´|ûç-‹­_çmv¬xfnƒ÷¯³ÊRæ6YÏÊ öÕÞøQŒ3>æ›B¾l8[>ðᎢ\>«Qt6§ÆÓÁhL âÔLÆi0Ó<ñÏâ„ÈŽ“Ìk ðÚŽÞ3cÙpƒåbq[OG Zmè¾÷Û€Ê÷©3zÛ3›TÞ‚e6¯å¶ÙR.›[oÇÄNͬÒá€>í`�Œ®èaæa×þ:½-WJÎúÛ=5·Xðˆe0ì°Lë³GçÖl¶"ûÚØ7°ëš8ŸÎ{s¹ßÚc¡ôŸ:œÓ>èPøœœ"4â©æ¯‘´Çoƒ)#†CJ�&sZ–©Z¹Ù5 $F×3oÙ^yƒÅH% ¤ëmÔWéF¸Â6Áùç Ý¬FE×guU”­tX‚'T›+Ô%e1¢SÿÆ´£‰º<— ºVI,rþí‚VwîeÎã!¥÷´pÀX]d‚úȲ#:î¾s´Í(œ÷›S¶Hܨ‰çY@”íäE¯n‡&‹3⺠$¸[uÈ=‰¹¡‡>HÄKçI²a^ØŸ:%}ë^‡žݘ–sÁ¿7DÖ6>q°Ôe¿+‘± Ânôf–užpÊê­¹ùñn/ÏÊQ²ê “8°òË9tæ®·¦·ë’™Ù•÷¬Ëi¶Ö”!w°Mö™×,P WÑÆš!Óãd[f놇SÞÊ ñêøAe§£yµFÛ»�ó³ÂöÄè.GšCvÒ¾>21×e8Á¦îïâ_´ac«�©™9éè.ç‚;–|ßf8/Ž<soµà˜Ãç­ìbgÜšÆÕ3Z¤wBJl ¨ M¢±oQ€¶^·íêiÎ0+•RÍ}ÜpœÁj—R;0Ñ*ô»?`K°AÑY3ùL uùè‘>Í_[Y‰ë˜…àè+\QÍ•[íåf·é“›¦eþ6];.ª¿KÿE‰§Ï:ÏmWdAqÖ< Þ£ÍùË+Ñ÷<qÒ—Çàˆ,¹Aé ׶UêPTeŠˆ�çæde’þ{¾mžÝVŽ ‹Í»=Y¨(¼áÇ?ËVJé@`”AÒ+�^ÊYŽÊQú-^"JJ÷‰E«gWy£7+ÉšµÁj Fj›Wy´ë‚궼r-ÀÊø7œ¾(\ƇÕÆ(J*íX<Ð/‚X¬êå‰eƒ7Z+@!/¶ÔHp^>ìÆvÞÅ Ùœ‡>›N9‚Òk³k¬ÏeûEkÔ' ˆ™R}‘ðùº©kz÷ùˆ©BGÊ¥˜§2Èögo gjïµ4>)¶P˜ ¸v}3"VëŸ|3ç·ð%šQî½ëÌbG9ÔšÍø„äÿ” >h(êNgª—§«È# ­€YpÙ–>¥âKptN¯ãiXºíToÿòIß"NW"±°žfÐËØ:èmºPubÛ’/ýñ-X˜õ¼;Å‹Œ¨¿§µ #`ô uºÅôGV èÇ?|u#›ÉÉhª2(ög`2‡ß{ˆž¹…@–·U´ïNov“ÙÎFwNÓiqœÌ¨Ç»Œ¨\È|Ö HÅŠd¿ÜhŽ8•ÙC?K¿ùnèZÉÐC÷é’ù¢€Þ¡ ÿ[Å'º—x·ïÁ²Ô±””±i°¡ã7íÞ=í趣cöìr7ÎÙ<…± f]y¯³.Døà)”Ö'ùÓŸn;×ꯢÊÔ‚¿ûœ=#ºÛ]má*öàø- /ô-•¸Eaªd^̶âÃwœNóØmô‹qŸù™vA{:cm‚nW§µIÊÂÎh—nº•<! ‚éYýô°ÓoQ–2'¡èpL©2~–¯µ"èY;UÍKmYÛŒŠµÃO +‘›~—$OvP¦Kz˜ãˆN§ñ°ÙÔí%ãFTx<>Áj&J™;•åQùl¦µÒXsoŸµ˜×ÀBK¢(]É¿À4Ë‚Ø.eŒFºs_ïm}÷DX:wåœøKÒãNMNFhs'Íó°Ìܯï2MŸÙbùíAÖ%»ÐíÊöç3µ·Ö\䧡ñù•SÖÌ[$ÆŸô¸-Å)gí`1äOTâÛùçñƒ¶UÙ\¼h¹’À•@Ê„vÃO G¦ê¬ÿJ3ú´Ž»¡ŽA¶' ¸üGÞf)žN¡üy”ÛÌÌP‹R^ E·w´’Èöxë‘bè¥ûúÚÍ?»ř׃á.éRÿ»O7çÜ@ Ñõ‰¨‚³8w©JyºšÐRÜ㔢šf÷°Ž,[mù³ùy ýœ†‘ïoJŸq_xIœÍ.hˆHO£bþÎæuKkÙ” ÞåQOªúSTõ—óÆžÔ­a¡1W@Ü Ýå7·óØõ·¹Q6H…Ó®üypþÈô“»L^_uùK}cw•¡Ë³ ¬w®E9äÆnoÝR>ݲ¿õ^þfÅ\(ÙJ¼#M)’M¦q‹H_œqFˆÉjÿP•¨h®±ÚŒ) SÉ?µ¿UBENHÓ*€'û%h§ƒiRüÝ´;»vˆ ±@À®ÚvèʳûÃ? yyãüÕ¯ìÅ÷În–®NFàò ´tvÈdY[Ký£/¶ Ëx%¦Ë^t*^ Ï™ A/îAóÊ6÷!¿veyCË¿¡½.ÎJL'vô"±?¼$Ó�Ã)jåݧ3îB±Ä}ÌL/÷/º Åmcã°+ƒ²ó¾Â©þ€©Vpí™=‘¸÷õ xö¶9U ç4ÇRÊ°Ùöèèñûºÿ¾;ŽéJ¦!–Qí2ƪî‰Çç²ùßØ„EáŠÅ^MC‰³ 1¯ø…Óp€ƒ¦®Oy]sØsÏòNÈzpܶî1Îçþå’†«÷ ´-ðP3À+ŠÌ+q»E—ÚLSÑýOÒ\chnW âÛánø÷[û<rÎ úžîLÖj |D%A)ÖÔ¶F.SÛ_×cs¢„§céÛWÆŸ½Ÿ=ŒZ>Õ­¤éê3óCØbžo2žPü,t¢Ýƒ…t—ÐúÊ<hš ÃÙâ£Áù êÕ€²Xåx©Xؽ#!]ÓÅ„‰ßäõ…ùm™fÞX©Bœ©?±¤Äºoêáê·�ÀŠ2L#Ý¿ €æ™ËÙXe„U‚£^‹,›s¨ûUÓ¡bZòÒ"càç­„ðOŠÂ‰]v±º7±VY»÷htór¶rS¯qóâpelæÀ•Ð¶zÐ`äq”ÓÆ<q‰«Œ0¼%¾þ”þÏ�'&$·«`næ%úÄ&Y6´èX‡—󳿵ɲw½€²vÄâfE*uÕš¹,‡¾ÙOë)Ém§çÝÍÍ„76×”Cçù±«t……Ä!KPÈðœß´è¸5.s¨Y`%•ÕWOt…7ðzžÌH2fw±~v¢2<›No™ìõ  ‘ÑLž®Â£‚4ñ2zÓL{ØeìÍ‚—†Ð_{í.¶iêõ'ƒuø$ï c Òÿ¼S¯¿ð¿YIié[t‹k+ü»lÿ,b]Â-äÏPª>RUð4wr¤!n–· OÝ—ùÚÿ©üøEfž’H½á£ë¯öõb$o&¹¿GFFV¶ñÙì`¹ aÀ;ZüÕO.¶ÑÚ­4\JØÙÀÐR5<ë~¨S¿&AÏi_qg½|ÃRMg.8Z[/î×ôa+/çåe8\JÓ âf;[ëòN\î‚}Ýþz½ÄùÊå7¬p¨žýÒ¬/)Œ]£lk:º‡Nz€Àÿ˜?NW) o2Ê £ñË”\˜Z¢m*Þðø#úºÏ”N–½¯(‡ÙŠªä”Y°vCê¦V Q¯¥ó*º)=ŠùË„QÕx1M?ø1,´ ÿó–ÐÜžw»SgRB:µ›ÃÌô¦´Fç»ÒQ©G8ç‘Í ЪŸ¦ÎB$o75˜&3Þ^]¼ëï³ÕÜ9õÈ=Z>©:¨-/1µÚæ$\NÓç™>µ÷Ú¸àxb?LRñ´;S°-¬§a¢þr]7Ò]a 0W !ÑÉ,²!aêã„Õˆc»ÞÆ+%4M÷úkÞŸÆÿ÷�C8I¸#áù°±*}ÝŒ=(©|ëÙ¶>Ì*³~wQ<-÷ÜäŽá}èŠåg«Pü4v O�”Åó({Eò¤ƒ¢kj{¦)J™3úÙ@ö+âæ»|æ!ÍØs0a¹¸aWÙ§BùŠB~Æ\Yáo‡ïò.5¦<ÿ•TPIGF»=‚xgÜ-€Í„ä¹ÂpZšBÜ뤳|ó¡]¥¿¬UN�‹’öýõœQ8!fËÞK-~¸IÑÿ¨é´q×�p=†EÈ¿ž %—¾’å� µ€Ç½™æ$ªcMĽË©)õœ.ØG?¦å¯M9nHæVÁ/6|–øœ?x³€$ž[Q·HUV•2 !#9·ùèÇýxO¾ÁFFÑ‚ y?Ѷµõs2Ò¡ Íf#xgǙةȡ˜ »;V4ĸ_ãä)ù ³ÓËí; ŠÓÜÑ80«‚¬ë=}ÜË¡§z¼?ÙÝ#³Ñ<öÔpº`9)ÔQs!-Ov‡¦1Oâ´ÝÊg¤å$ÞcÆyê’¤ }¾g_«ÜQ:Y™ê`F9Š{ G†8±q3>)ð¤ÛÚìYàL.¨˜àŽ°üVnÖåpÑêšbÝAnkó²&T©ÌÐ8©áƒè…ÆžoT!€Å]$ëN?9Ï1ëåΊ™/ôÙTHAÎÎ÷äi£$w)$÷ÅögŒ­þ ¶ì©GÁ®c–ÿÊoÊ—¢Ô,ËÍ© ÜÀòg£ïË ˜R‚ÐÉ¥º\|/Ó¥s²1=‡*¨œ.1»GµsOŸ@䕱H¢:®eÛœíͦ“Η›ó—6*ƒò¢Š9°Om®¬ç¹yvcdÒ4.»j§0ƒ³ >„ôô"ÖÙùš’РÞlÌÈ/Ø_ÐÆõ¹ÄžE ÔHþEVØ&eæa¨o”÷÷Ý€:Ñ¿×ÔÿÖ8°Š?”ÕYbŽŠ§a©7g­íèH¦ÿã•õ£ÒÏʳ­bC(Œ¾Û#Dýµ9pZŒ¸³ÕgÁ=º[†…ájŠ NxæÝ„-ú/ïì¤Åâò²~¹Ó:ÉW4ÉÒŽßÑí’F+Ù¿gctw—ËÓûiú­ºceúÆ”…qcŽ“±µ¤[Ñ5µaÇ0¥tq­O™Ôc´ÇºŸ ;ÕÜÝ7’ŒœÚnH?_êíVœ¬¿§OQåYkTÈ5Û}„³ –‘ƒ¿µÓ@ d±¯-&_ÃÂy“C‹Ežw;+±nNp•í½ÄÆüg?L\ã,©(”ð˽±K›‘…ùQ,ºÿ'kFH,eÊ ,D†Y|$V1"º-QCžìRÊ1»’ŒöÖtRÏvµû¾{åôÿœ¿ ­»/ÐU6ÈeéðK¥j<^W/”c ŸÅË/˜n2×p´¨k÷yosÒ+êv<맢¡9Á (§ç¿qó%_ѶÜ^!ø·xÊ”>f+SYÈ( ˆ™fÅ÷W‚á“ 핲åuÌd-+ÞŽhïrã´óZ›©>*zÿnðµÃ÷mäe–9z߸”|¯%1¶{Ïš‚üùpWèò0˜RyôˆŸˆÙ'Ùêï`˜“°˜¶ž87ÈR¦Ÿr:ô?FϬã¿a^Ô Æî‚(L<I&zÇ+üQs;ÓaŠ•oHøÌHù‚eª?º;ÑÊMÀ qÊ¢ÏUÊÂÓ¥e¦¤i·›o¬Kq‹¥Í·—ÁðãíßvO©@Ú>Û+(µ¼挴üONe†ûÒk¾N·ë%÷D4(Ñw)ÞwQÖÐgÛw‡£­í¹höjml7†­~w .=æHÄÍvX¯P)ö;ØPöNËMç&Ìã[LLcw2þç…&Ed=}RÅg\(Þ—³_è{‹BŠm*1mXzzªo+­–Uëï5×€ÊËÙžZÓÉö­ïƒ2Ö™Ž¼Ö± ¿¡È‡Ubžm;ê kdOfDfe±Påa>ä+J-Y¸²A¸ePº1œÞW¦3»´€gÉ<~unqYN˜8ø-;(úý[CˆEo<„ŠûÎø¹½&Ïy½tIÁE§t±Õ-âÏÊÒÙ=C´Ÿ«•FanáÂxÈËA‡ed9õÖ4éýÈÿû“"*ã›&[ ?ƒÔˆ ê]RñþÛÅPØìvÿftáóWºëÑ£÷7²¯N!Þߊ屻q¿oqdß,æaçZœ¯Þ‚"v·ãq© “©ƒ«|îG®¶J2ÆAT%íàuÛhë:‡bzm±]¨røϯ ±Q¹îRÊ¢jSVœ>g¾!x‹{=¥ùŽãòŽÑ„Å:óèö>¨ijUªbˆcþ¸Í@_žÒk^ý©)YE®˜a'ª±¯‚°ñü²QH»ÊÈ´uWAZ #ý;]g«ÞÆ£iDöFI£ 7@ç¨`‘¬ÖYà _È‘!¾Å}s<*|'QZõû)òP(±ÿ`õxÚvp%Ðúòµ™Œþ·èôH¶¨š• bc£õý,( K †3¿§ …e:C…!«Pòqwõ¸±Ü›evBSÖýÇ]ÞñÿÉãÌkS(l a5,Þ–N³#‚½:TËü9,U6‡1¢÷Ô±z«8t<�Àº–Fæåÿ¾uíñŒcMò1‹ÜTnåJ!ÑC»ÆÚ6õÜ1”š•ÊUJÊvU~û lë;4tjþ–%CûB§%Ìo´`¨Ûì{C9õð¡ì0ÁÐdºùuåËÅôUâ¶Åã»ì„÷F¼,îóÓ÷F_A¿À‹ÛÁî¹Ò�/‘†£µ­œ3CY*éu€rUø0c–j8õÏD:þg*U<5¡š»#§îï@a™jöÒß°tzÇnb¦½©t ””rNAÀHÓç‡Y^æ‰Ñ }~†Û@ºS%ÿz‚ÌÆIaßw¬G!Y½¬¾à é©‘¯{Š ûwß[L´NV•V;ÏRÞš3Ũó×/C|˜yYUdü©2ª]g[»Š‚iͨ •Q7¿}ý{­á"!‹ ÐÚm/»=rn¹“Cºˆ[س£ë,bj¢zbÅOJ#Ê1„o“ ¶è¾ñs°`ÚÓe‚·¶&Ÿeìž+3@žó_þ¤A6üëÍ:˜KÆt9o)µý¹ÈD>¡Ûrú¢¸±XWXÃÓf“­N='϶ÆF ¥ïýØ)ukØ'­–*HëÎQ(DNDQ_ w±¯ôÈÑL4BjË*ÃÂX‰ üP»˜‘h+4Ü÷´‹ƒ$ã"‰Jår›v¿Ë‚ð²3 ìEy»¡†þ»)LÖ?±À1äïq­ÐªÈÎ:ªá[ÅË|ža…lú„6žYôv3‡].âíÝœñ[‰,jO:–kæãÌføÊ ®ódd™=½R3F´­Ê•`ÌsH_FÕ—[¾©Ï'eá‘×EuóÊIqz¿9<ÒÿkŠÆÓ†mOT2gaxWë.ÎàÒŠ@ŒÃ>:H€Pe‘Ìž;Ë öŒ* ÕŸWýf˜/2X*¼¾tš±Ÿp÷Åc 7´g"öõƒ!: ®^”ø£zT½èúóéfÐ i¬B"]Ïíù¢ä3.U¯,¯Ã ûJ)¢Y ê»/O©ëAç3õÁ,´6Úš5ÎÞnªý¥¶„þ΂Aa’©»\yæ ‘õ…JM·} ‚¨7™ªý£Øú›ét±´[ïúŠÔfxq_(öNzÚ¶ÝEàʼ2(×JÁòËÍm/gïé°å±ŸHûY/Uæ¬Bn·VŠ­ÎýÒ ¾-Óá(|9L믯 ‘FEe Dy2 g(œŸ|ÆýíÅ@©-¯âu\Clm–¥¦5Î×£‚W€G6À÷Ît }[ QÝrL�_s*oN4–ž²L£jUÇ…AƒÉC7z_ímŒñ9¥„|„ˆ¢|»ø>1µvä™±³yªéÓÓ.Ei¿=Ì{ Û(U /ç5ª8Lµ@ý¼K‚|?zle>öe| ]#y»zEÜ!wÆ™R¶CÕ»e°4IkÍgîhµÍÍÕ¾ÊQ1•[ºï¿÷aõ•Qî½Ô0·ª=#®ú£s"»´ÃèVIgÙ˘î^âÙÃSÂ,;©áÏE†«@‘ÛÎ8ZÓMùïæþÉ 4*¸yn<I|FVt‡Èç¼*‡RE¾1-³fO‡žÕ!ˆ¬útÝŸsÝ9<ª±ÿóæ ùñD«§{é¿ãU aahkìö7ýëiÜÖ×ÉÅßþ{þÅž)JÍ·1U9š$–ÜxŒ:ûk¶Ô¶UùÛÃ4 ½‰—ó•‚ùõâÉï´õŸC§]«Kw„ĉñ ë¼+à­êXà=[ÐV¶¸ˆPÇÖž`Ë-y‡ÏPÉhHõ§õàMN¢7÷·ZýqTd+TŒÛÊwm'è PZÛ,øÄ­Í^h`ÕêÂÂÈz±‘Ú^'“ äó €—Üw™µ¸Ç ù‘L“dáz|û±@cfh=‘–-%^¹·¯y¡œI]wu$\zá%‹‚œ(ñˆß÷ž%Kš{¢¾órnœ¶5³íëJz¿p~$Òç\ zë³ç;¹¡'82µdu?Óþ™nÍ»¾C”f§.ID‘>õt*"1¡½ºú)# ’¹;WßÇ:•!þ 6Ä_¦;QKdŒ–±ü[fq¥~±™H"«N>·+MŠÞwky‘²ê¨)ŒAãTˆ*‹¤ÕD%–ThØtšé5¼ž¾g3W£…cè6¬Á5wÝ‘î2QËZ½™yßuè^þÝ-·»ð¿X‚ÛÕþ_®ï0ƒ¬«oªbk®ikcÝÕˆþ'Ê#ßO#Ì ÕH1mÔ©-B$áÐx°¶ÿQþytB¯ð*÷Ð&kUÒ8alHT™µ"‡Î÷à¨Q‰*´Öì©ÐŸ¤gÉÕóƒÊ%ª<ƒ ŽZ¬±Y~þëùß5]ÿçt˜l$ŠmÍwèõS•Í*Î<kqŠ)—?ðŠŠÙã—v™bëM¾Ðò“Óý÷ÒpEž§‘™“qÛl1ý&UßΡnÿ°i)òKîD‚ÑÒwøöJϳº»ü¡í˜uµ×g½tCºÀ¸8²ò&¨yn*sÆŠÓ½ïëˆé† 3Ny¶=@p øá•ÆÂôVßuZXyÏ‚mßý9wfå<j¹æQºšŠÉh8òfïšGŒØó�1“¡fã|eû®¹‚ÂÏ´Ÿ“�1X÷ˉs}ÂN¹âôk¥8/ê¨ß_:ý&>"šý8—šîR6*#NnñÁĉN»¦÷PŠžô;+ó1ªOõ¶Á÷Ý2Á½3¿2 +Pè]ŠòÁ½.vì©ç°F!ô£²¶ñ¾"Öϱìýý(×× Ì¬o)NjUÇ[ôú&9ƒÚNÂE©ëÍw‚ÄÙå:›ákÚ%¶ ›†² «2Éôyw¦ B̬LØó+‡ÒŠW“Z؃€Ë±|y¼ÞÝéxÓDbY‰ÖÔt.7G¤U6^¥’C·ZWC#`:l(€ø—õ|@p·M¸¨*übˆ„kVº4—©û°WºÕçI³3ïº)ÕÛÚ’ßE”¸Éž*ÎÅ:Dü¸Ìü[ÙõÕíçb{E‘y†´*¤e³tî³{}gªó7]߀J²ÚéˆÙZcTÌy_ãȺî)käìꎭ“ ljœ ³¥Ì¼¶C†ˆÇ{À½S¤n_WuK>«ÌÔæI­rÏ8ߎç^F`FˆôwþUéNDv.ȧwO(¹Ä‡ø(ééó›Ñmš8‡ï‚Ó &éä-ù±¯™´¨)À/iiî�Ui"ø/äŽS(zçî¤[AÆc·s³$k:›‰ïÃÔ`æ<Õ½íÌ›ÿñ#ж-SÓì¿žPe®žÂ&³¢ b:º7i²2ú° )9€Œ_^®î—ƒÅH¾<”8Ú>š»ÚS>=%¡tŸÌüïû�Ä*ü„¦å9vôO9¨þnäÃ;¥ýº?¶^ÌB§Jy‚×]mÀW¤Ð”¡N\¨\”6å_žà@ÎÆ•–ƳÔ˜gþ‡$.•¯"vkÏ> ¨ü„*Kn¬â‘šxõ]ùÒÇm?õúNU!JfŒt³¢w-Ì5%†=e;æåǾe4<—´l‚bú*ÙM’cã·º;ãtÒöù�šÁ=ãK¼5ýðEZ×ò[B”œÒˆè¬Å¡5œ €EUGF&ÈèÛžÿ÷‹ÇøPÇÉÃ6ȳ¦¾�H6@ƒ\æõÉÍ’èßß0 }v²¹9aÍÅØÚ7yN§ĤÛušŽ0¸þ•lJ’Å®§Ì=˦²…Sà#‘#¾‘ ¦*†õ«Äïríw~óæ•$«ðÕ§Î2p¿ê³Ð)ÌÈtA:ô%TŸMÓa(‚¸nœ‘W5‡Õ%êgׯ[F¥EæO…Yuäçý¨âl1óëq: I Ðä#E³$ª¬Ÿ±È;ÑQ’-Ú;ö¥ïjÖ于‡ÅÄØöÐ öárÐ`6¸öRlììbPÒ(™Š¬‹nÉOúÝ¢-@÷H = ¢91®Ø´:/U·:ŠX'ˆ¬–ýkz ¾ò¨Œ¿anùþ¯óso&Ú’f^wùk?¨$õž#óæ(_ bE˜–ûZc‹”Hò¹A ÕwÏÁX„¿3O>’¶»Ô­¥êíb¤”ÆÓa°Ý+z¥-¢~45¨<¼BÎôµ!¥²Sâ<yãÂ4 ïP@ ómw€pu>Ï?Tçb¨§Gï2Qóó\îÝ`uÒL‡naç/†{ŒWÜ2œ5°‚ 7 EâßÅet°M»}|ëF¶“ö.}+ ŒYñÖÕ`²Ý²ÊV {³�–!(&«D¢ bÌJe‘ï»þ(ƒCïR+¨Ê;¥ØÌfÓ}ëyæÍg. A~2åï„ì"›¶EhóÎØÛtƃ *ÄT:¶Ö¶q{îW<CàK˜áÏ[Æü§w´hDm1xn”f*)·³ïÜ€ß_Õ”bGRýÙâû¡ÛŽoMï«œ@æ)¿A¢äœä¬ EÛ°ïðeš¨\™˜ežòr:É@Rþ»D¶¢ÿÉ KÜ~ÖÇ’É^ó*øGHkÈ$1гôœeu#� à]®§‘Ø"¶j4J1pö ò·ÞYé%…Iñ~ ƳxKA2¡iw <«nñh¢E—Úv|¨.™Yê[{ É–Iz“÷K»¼ }MNÊ©Úš¶ç^Û] öQEË&GÎswg$ûk£:bòÎ2w+Š)5¬qò>ìgžî†‡²8®ÜÕ}X¿ëÏx�˜î„Ö÷„¬Iy”¸#žùð nêåK„ýÞ¹²tøx‚¢ˆ¯ƒ7㉵þéÎT+N½Ñ“ùŽ ÷Qç¢hƒü) Ó€1˜ôî‡'蹘Hå,â[ÖÞ2éãOˆâæ >ç” ÐŒ8¹d åË‹sÛéÔôÂHÀþÞ(.Ýäƒ)¢ºu¢îÛºßh"öê É߇<O9¦9Ú†S—ŠO¤'~]ãÔºÙ3O¡¢[™ 'Úèï[•jBGz»XÆߘQ¦™²J¢þth Ë»ª®âpå:«‰*ýf“Yaüvdú© §CksEhŽ<ùñÙ ƒi8swvÍ3 gf I‚D+zÙØ>Ê3Ý<O¹B‚ÔæOÄþ&åc“ΞŽô¢ÿ+¼Fm kå,…‰˜+TÀÍΤe:55¥}sHÁ7k iæ1†8‘~ ¥=!KîRŸ‡þr¥ i.F-³¯»¡>¿í.L<[ý„6¥™¦<! æ¹²îÓiåqzç éiØ 3|”TR÷b»q8h604¼g·Alæ»Ð} <Ùí.b(ñˆ—ù 278>‘ÛîµA@™Ñ�gu„E‰¾/R€Á¤êÚÃm@y[�»Ñ±™ï%^‚Á t™ïy´r,U`ôí´}»îgz”H†Fy™)îUïNÁ«2OR¥'º·ü>÷/½U ‘akCÇࢺ E~Ú·�1DLøuFz/ˆÉDVÊwŸÙ%–çÝúÆô{ÆÒÊ™p§)ùˆz ‚]ì¹Ë‚r°âô!\ÅU¢÷ÕÑDl'©‘q©l*z–ïÚÝ›8‡×„±©E]˜—¦ùÎë†tÙ‹‡¦KgÓÐmUÝ<G@é6•YþÅÌ͉| Ô”ŽÊ}ž°á¢SÚpâÙÂÓT÷7/«µ˜Z¾ˆÊYîGÚQáçÞèÖxNaO§ŽHÕYŶº\wè}ý.Ìë‹Fs ‡1B<ZDZŽv1>öFH<H¼Óv2ª5²`ŠbßåmXüeœí0`AO{åpw÷—¾02s„˜ÂF=nG3¼.áØ·Ò…è†þÊ]Ü¥†da¶š=…”ðäAÑÏÞìɯ^v=§ŠëqD¡iú·u$µ…\‡¢²¸]|N^÷Ŭmyù^Ž)áLà1dIS iÖ$ÎWOD¯i[M¯Ï£•#& ]B¹‘5Âœh™x­LaN2G¬Ýµ4€cxÜ¢d¢(ò§ÐàiÁ4*þÜ»¢¢Î’H+T$×/bdÙSÆÎ)ÍÝ_zÍzkä z”ËÎ%’ôØ/0ªíŒ÷%Ê(S ¾Ôô.ögÊõZÁ#Úï2zP#>ĵÿ î—®+Šý™ó±âAuqtã:XÝÄw rW‚HÂNyšÜácìëe± ¬Ãðuciû@ì¸EgŽ}„ó~ç:=””}tôITB~îôÝûo×QfŽ›}]PŒÒ™àtº*HíAÃp̺3�P:™5Îa,`óé>+ýœ¦ÇëÀ(OÜðH0»*H†Æ“ÉGÔh š(w¸ü;<¾xNýÌE†MI'ÖÜ^f:v×cõQ#ê ñ«ñBì 0)›½7T:õºøŠ&`¨F¢’*³@Ë~Ý»ZÖLD̦NUµ_æ ¥<±ŽT†¹:ÌEí‹ëgx’Φ‚¨ÝåýNu)rԿô?\(NY gÄÞ¿?*:TÁ1\gö¡—@^"Bv}_+#ÿ¿ŽQ”ßè;:÷MOô¯‚¢6võy¤[‹Jv~&7˜yC€Xº”°lÏžj;-lÐŒòÒ†"îü²„Gf~zõ‘ÏhÔì3 ¶žyÛö§Ó$Üï–öÂé·ÔøÐEòPŠJ[Ê×U¥b»¡Ã®¹:ƒ'© (j“ÂñàX)bCÁ¡:·Öi¢ºZ1ÍÞ))Ûë5›2Mn —†âdù®~º8ã-ŽßöJÁ‘Ó†—Îø¼Ì¼ž 4Z蘺ƓN¹¶ŠÌQøwÐïÂsf‘ßÅy¶¿zÀ‚ ´A¡²Ð3®™e8Ææ¼cÐÍn6Õ>ccŒ*Àž~óq«<ôxã1çŸ!7)$ÿÜž¾w@E E«O[*h¸0gå"|âñ<5eÂ6ýtú¥6à|ø÷­çeLÅÚ2ŸÝÛ‹¥Rò–w§Þ…Êk¦0€|€Lí¢ÏËc××m73×ðw@•¤¸,ôÁÊöÓ ZKLÀífžå|oeF‰£ë b™›¥Ÿ_Þþ<SY3ÿU§´,ý­Þöš…Í‚Q -ôfC/�?4(L+ÉC1€Þ®<ž½ÐQl ý°“Ú@/nåV2[1 \÷YÎÜ*—•ÐºÛu‡7ZJ‚àúìÊýáž‹•¼Òèç”!,©À¤Uó®>‡p’£%R/Îr 4\YÝîêØô®/ÅòÔ¬K)‹(ŒýIà¼õ„_-zWªÝýaè¨(ú Àm¦oflÒ¿Ù¥gYæ­Wt¼Ž:ÈÓ eæŒ6 œtýòm½+;ÝÔ–jº¬_´d´ö˜œ€ð6â•DŸÞÀ¶Ý‘Çí×ù&]] “«àu5i­ïçñ ·†ÂîŽÅù“äßT¿–û%¦%ÝÀ$s²ÑáaBXv +ªuJ-^„¶Åyæ¯È,è†$H-@ ÂØe¦“±¾$t7O5óú=hxö’¢AÂIì6;OQ§•"SëÑõ_4´ËuÐ%y~.ÛïV\7ˆRT°uýËvR–…× ¥§ Bsü¥©ùx¼ö•Ü(n^ýŽÏ…Ž{!Xý¥¦¿UÔ½ÇZl¨>ý�žË»z¢D›•Ž®2Xïç»KŠ”õáâ¢ýEùþÒ—ìÕÉ,¨ú‹óPëzO�€CÛ|ÕJß{ØX)|±³TAúÎò£pv€ÌÚĆèÎÇ¢+oôÉ{¦ß!Õ'~‡ÂF΃È*%0¶†IJÃodÂ>‹­ÔǸ+y�«Í|³³cë¿-¼ÁÌx:õïæf}žë^¥}g•‚Œ'h¾:#ryŠâ„Ž]«ž.U{ŸÊ¼î¯ÜO”Š2òÊF9o>Õ^ùм0¢¿ç~™Í€ßAÉC”Y·uTêõoñ;‘ŠZ…¥Á¸n¦0È?µ@8v½cqÝÿ§j‹‘¸2\ãæõû²R£A'™ç=ûÎÛˆQÛn§‹›¦½:îIŠÌ‡üªH©4í Þ‡¬¹sJxâçUIàÎÜü„™Oá)*±× ó§·†Òâ…qÿ0a>�bë VöÈk!ñl"¸°Ù–'¨=ѲfºÚwŠ\”ØìN]Ë®Äãž]•½K5TvËD*ƒØÊvFJC¹øà½õmqp·L°†<Æ_¼ –KÆÎæÝÅY—›eþ…¼±ž@¹Iš •g¿…㱋ÒÔTÙ§iÔÊï±ÕR¸JíCúœPOÕ  û�k>gúÒºZ¿|žf7ž—ËD'NêÌlà©*ï1B!m(ëù-·¸ðà ,V0tôÈÂöº’uð€È{ÊaX¿Í]v害±gž(€ÜÝÃbט„ó4W.ÖtkþM1§ß~Æ™céþV‡»ÈV¤«ŒÊ ˜?vÚ™n__” (Ûö¹‡-CyWšß (²,¾9æU–Õˆöœª o”¶ø–^øúÀ“‘1JÅïÙ™:5Æ‘1ݘ³ï­r Ý-*ZQ Ïô¼f³óÒÜýG¿Çx&¡ˆ+Z[)HÎg/%„nÀÛбÊjö±wæhô–‰o~œkºÚ–Ñ•Xñí$Å’ÞÐ}üT§¦SLåæOÄ.€,4º”ŒÏ·îᗩꃪ'­ŠÌáæèM6[”UÎ~%±Zd²‘› °åÚHbˆ»íÍ’#úÆ$Îz<3%‰·8ž×tóã(÷}¹ÑW€vs¶;û5ÈmÒðÑ]Uää5ž­E2.(ÂÀ¾ªQúž©Ø¨¸ü·óaݼø©Àíƒy<ô�ë¨I‹Õò †k3¸K 7gîÏEf Oèžt Líöõ¶@(gs„ö\LË£J+»zá¶Åü¶­§#Á;=h,„%4\EoÝ4¿ßa©þ„¶ÿƒßÞ½þEa’åÖ‚Ui¡.t»ú†WRƒÆÇüíg«Þæ'rtÊ÷Ç‹kúìA©œÙ.]•D¸$GHxëˆl;dìž>–(NWSޔΠZVÑûè€hÙëHzÛŸ­¬Õ,(Ê-ÓÚ–ñFÃv¾tÿ2û q*í„g‹éb¹u=¼ŠOÃ($v_d6ùþE£3µRðß?xWg,›ˆÄÛ+VÜ÷Š6öµ-`~öèIÖju˜`÷èÔØq_ªe„FNv8÷;Hb 8® ¶WúVFjC=¼–-¯XFÈÜ»BÉà œÁ%í5Ån£ ÁH~‹„ÖÚ*w0üîØ®`ñѵlÉe¢GBû+¥¿²W|š6Œ²ÝN]ûFåN©Ü…H']z½¼wÙÊZgkû–BðrñøÌÆüCŒ…¨°Bj`Ò@ˆp{÷»žUèÝyÆõõ•/ÆÐ 9Ø~¶¬Ë<¡[.=>–’+-¤= ­ÓEh³ï°uïAT3Oé.JÅîÝ`n.Nð诪=ËTU?²£™'FQq‘¦Zâbââ?. ΦÔ+DdUÿóE††‡¹Ä­Óp}©AlòFR|¹ ±ªƒ®"çóÞöûâ"…wùš_@Tr¨P›{Ì5;xP0 7rýuÈt�QG_hèN0};ÄàùL†HÅÐж*¤mE!lG«X]Æ«•T1ÔöànùˆvàRe><5ÙÖ¢ðÖÞ˜êV´÷6á.ïRš>20kv[az*³ê³v“ÔÄ„ U­9ò'Õ×Çœê´ðB!, ÝûÞ»€¹ie••ëË'l¨\ÓûOšg`´Lùh/Ý6i~*"Þ^<Âû©N`ÓHŸzz×XV1É—‡*µó²¥eä a‹MœKËFà*&Šò3ö^¥ÇÂn¥r`ö’ÁøÅ`ÛµðH¯1´ýÕñæ9p;.=~//òþ ¾ŽeÝã=»Ýa�ËŠlž‘kùÿFÿ“&Ú M÷••ŽãQÕÏ t$Ì)ó²¼qêWǼÇúæy­(î¢8 z:ù+”Î¥nÅ—üAë8 }0ë'—Aù®LØzd;'Ã_ÉCU¦3úc‹çêôŠ�|Z:We¶òL+ê:çØ°v¶9îî‚[Ÿx&ºY™:nÆXô±UóªašT¿(ïA EI³uîøs¥Š 2røtDïP|)MN+$ÓoÕ;nìbÁF;ø™Š°m‡H׊3û$(Æ/0~© ‰ýO!ä3Ûß–fá½j« ðo>ÅpX<Tãà²å-Õíûú"·å¸pµíaýÚgIÏÚÝ0æ‘ ¢›"õiŒZ´“J[‰Dø¡ Ø} —g°1Ôu6§1¾&¡?– LÐA0ö„“ȇ6Ö(Aö©ÏÓnÏe/˜8)œˆ=ùÑ5ÏʈÓRf FWK?xfÛ°[ŸÎ0Úxe©êI`�<h ÷“rÞ›g< “Û@ -« šn†ýìÈ|ì¸%}arÉ?óy즎µÁµ¬c¦N:KºùÑë¯Jh$ L¦ÑãY±Š’Ròög@ƒ¾æ%w/ÔŠ]Ú!rì½'WŒvLÓÕGUƒVšÜí«º ?¸4äT}ì<!R´,®7E'¥±5}Õ™Áo—s_B»i¯â- c¯?:O•ð¹znÕcÛà…´ÙBµy¿ugŠ¹óÂ<AÛË~$æ„¢8 ×Z9Ã@A2lkO=ÄmÞÑ>ÖjÓQ$‡Ùi\6+=°Ô”ÎÍ„Z¡TF·í[=ùã€Ø£Ö³—šó®FaYfqælæ!—Céch)s½”ZlUž´ëQØP^궭½\óŸ³ØÙ»qàvTÅç« ê¢MÆ�wØ)ëá«WZ³^š‚û]ÑO'¸‹ïHŸ¨îÔçu:C|´¯{TÞdÅQ‘…EÝ@·«£Erí�‘SËN™ÿóf”2˜ºvýŸŽjÕ»°¡‡ê vL<Nd&øb“s!¤pŒãs¶¤ÎÞ~^ßp׵ƹü[Ó°Z‹Ü<kL›w“„”Rkü·ŠvÙŠªŽ4æé<˜”áCÉè‰ÊÓ[|V¾u%mÍ–rµù ß!ïæÎu—Ã|—_©Ë@So †W©Ç•Áhƒ§Â_ ŠÃ€I#/Aç¢Tšwêùe‰Ã-²zÓbxóþ¯7ïÔVšá¸z´b^ÑäNÒ•ÿ­ð¯$(›/ÏØñÆø^J§P°­¿ì+³ùÅ–íÛÛG ´þrË@´ÆþõT°(hšÂÎt‚8ñ¼šNRÀŽÖ]¬Óë$ö æy575üåubRdê#ìŠñŒ&²G¨i€Æ?¼´<ým{†>ý éÕ³¥ˆAkŒ×iÍ*æÍo,È¢íôÆ¡¥a߈ʜÊɈ#ÄÂ}7_=¥î4íÆ«½Ó'ö.œÖAÉYöDŸmÔ¡"¼ÒÐ×»1 úV;þäa¿(‡Ð_WåVkHà÷[‘ss­Ux:öy7µH²xæ¯ÉT¥Iâ÷Ûit-ܪÎsØÓ°²– ¸ú]ÿ)KV®´”?,iP~M¾ï× <Ö2ÒÒ:S˜Gø¸ÈJÿ3R'Œƒî f´Ú2¾EXS-FµJ±ZG © „VÅe„-&âÄe‚…íU|—´A µ«ˆÆ£:ãl³ó/)ëY9ß #J0–T æA´¼ÙŸN½Céw-kG ›UilTB¼)•ÍQÚbßE›#|[Ó[VÍèœj¬q$%|‡vCi»yyÈÊòÆܵµ¬üì½¼o;Õ³%·]ÇF=t?ß¹Q¸¢ŽI‰üH‡ ¯2Ÿ/KÅæ± òóÖ}~Y+�y²rïÍ‹’†ÓjÝçg¥:zz¥÷^¨°l¯Õ8ZÄÓ…»@›ç{o-À*V¿ä¿ zQf–B{Êu)tè2kQ"êX¨™Udù Ï^7'J'ÐÐÔ>cÇ�±Õ†þ¶¿ã*÷ɼ¾– Úš;öõTÓÓÙ•k8;F•aä€qŒTæ7zù—-}ðî_O.\ˆNM-pÿêÛ| pºyX»JaZ»_–;1+F8Ù¦£Å’룉Â%ð·_�"âlÓ Ìl¦Â¨æÊF®p+諺þ‘ýQ¨ãV©ëÆ°ÊÎ\ÓÉÏ‹§~:t¸…–‚ñ:å&J_ïÏ/Hƒ]Шý+ FŒ§¯=Rúüú£yAÕU®j—Xä¿Òíàq‹Gª|6fà©ÍËTÀòЄbL¡˜ƒsi¯oK?×á:o®ƒ»Ã§á:Òž¹Óžîf[¿ÉŠƒøÞ¯H¬íg‚4u‹%u+šê¯„VfD†gÓ%d�L]ýýØŠTéH€ã1ħ 1û~h,iNÉ‘ôì|ÄÙ£ëPÎC‹é¦c—éÑU#îÓæe4ëâ¶Æ¡¿K¯Ô²,7b¢´UáÝ<:®HÄke}<LFóR/Oóœ»JhhY=«\ŽÍª-8 ìØÇ aô–LæšW8,¦ø±ëvQú²¥¨¿ºJ ;çåv<ôŒ)PùIEsW÷LYùnü:”=šd±x&Ö})e™€K­ª×ª•N?ö熎… E±,–z!K¥ïÝ•]wÇ>q¯fþî?å>ƒÊñXI[:cz}¥ß5’&êo­¤Mè/ìÎ03¤{oAPÿKÅL­æì6|óâˆ3•G)°{ç˜~f¯·Æ-dÓMµt‰“¹-/µÜãÌI`±ïô¾Mƒ¬Ö‰g"Äô™oŒViþ ûÅvZf¾e ‹ä àõv2­jWˆûj�Fô[ ejäf–ØCäŽäÝiÆF»�*0ŠF!û”š šÎÚ°{­!>-åŔѬ²XÀl¥µuÜÚà ö‘ ª|Wg&Fr*¾¦.eE3ÄI–"ÑaLdL)Hz†’ŠÑI9ûÄ»7xÒ³j<w­åîý$Ø »¦ËÑv´dã.²’û”Øwç£k‡%É‹A(2;rï'ܸ܂·etÜ�óQØÞ%h?Üb¿€c´<~= j:¢o­ƒ<`¡ ÆFYu½0’ýáµX=Ñ-sŸ‡æhGÛ.|ï¼æ3Š+€@w†‘Èö⊃ëÛË‚MhCѽÉú/O`i§lr�‚°dÐØQ€pêLk §7Ýr·åþ¾¹JjŒÈç9òå3ÄðÍT/6¿ûÉ òg«È*vÐÊ ]»= õY×xðq(뱋·6n)·5¥fçã7앧àA!ÕfH‚hßX‡¤Ÿ�úÎÂoî·ûî*Œ—Ö€Ih‹=ðÅq½3Â] Ûµ#!{ÒûiÞËðÄ¢ðõºJÑ!¥0X¿‰#躭ÐÒTÉŽ+éÑæQú¦±7.- •£Ãc7 ºl1×gX^p§gÈúvÏãПPÚ2\`§\Š7§\rîœÄ:xdä¹YdfÆ𛉋÷g×ÚúlbƳè�>*4Ò4Îœª•þYr@elN=¸ jg3,t€¶gè¯"ƒxß¼b°£#N±þÅ`ШLQÝ<BZ\ÿvjÄ»©§¥ûÙ’7rŠµr PhëgÚ©Õ¤0~æÃyQOÚÕß4æpÛN(©u«Q]oýWÇsbw§ør4M„ÛNEê¸ïTÝá|š¡åI%7SëÍF­„ötÀ~qH=^`ÊÅð o­†E5r²¶œO}’Ÿ»&{÷M—©òÚÎŪÍé&Ðítâ‚J{X¾ƒõ­¨5à~vo³§j “D“kV8lVeàG‚ÍYè9°?EUr6D?Ñ6÷bñ¥ÓºŒŠãÊGÚyJ‚¤QJÌtJRún¨•É~Oññžøc¢Ì,^:´Ñv=$'š³§þÈÊo3A PElÏ»ü>øMÃÂób¡Íæì³WiFÄÖÀ¬z†C ãؽ&ÛŒ ]¹ê¯âIÂvpç­¦¡þÐÔnS÷ƒþû Îfiq<ä£01ì ~q3[Ê3¯Â›ýtél3Ÿ• …µ ¹¢_YÒA<y# Ã8zÈ<r£ÉÊœQ›#¬/úÉë-µÌi;ïî£90H>fÍÿû?3\" ªíŽËs•úº7”­ÑÂaË«ØbE>8Ët$ÞÏ3òrþÔ¯ H£|¥ZH‡íT[ç©#°µa}Ðþ¶“¼/ùÚmìô0ì()°-㘵+»“ O=ç²/ 6­Äš+Ó}_P=öÞmŒé{Â# ã‰¸5uøîï`­|È0êaÈ‚l§tษöú#µÑù`‰a^<†Sø9¸˜‚ròüé:'»ÚΓloø/5®+__ø†JU×–,J4¼¹‘åõö5{j#í€Ãe¥˜'z—k¹¡(Î<àšŸb� •jŠ›%둇nÌ|Î;:Uåß›ÖRQe+’"¸$AU«f�´†xŒÏú–höâ£~F’d~»EøwM}ÁG@-º±™ïï,ˆ­Ñ^Ì…Þ#-«Ùž‡¦žV×f š ½™¥{j¸i¯i7XIb6†f’ØuKëé}Æ›I ê¦{Y�YVrP! g›À‰9–Ü¢”p.ƒÒZ¡Á´ï¨H£ÿÑÎ(t¼PÊsàöÇ·Ÿîȯf¥Ÿ}SÚ$C¢ ›LS•*·{}ðª7tûêk e±I@eXÃThèÜêfÕš%EB‰Fÿ'täK#rÿ°½Âb±Ño°íXÿxí5‡d¶”ušö. ÀpæJˆg÷Œy¨ŽÌŒ|˜Ÿ;Q ÎÎ=Ï=¹<|½³èìyT„eÆ£w-xÇÎi+N6†e|ª®øóQ4˜eU¼ªB^è�S¹ l‹/ Ú.¡'3èè|cû<qNUô•�l³¶FnX;æ84°ÖvHr¶b´J5t¶7r›æJ3w–Mø_›…‡•AäÁt¯lí!òß6žsöo¿½»¶{Q;& ·šl^—E²L6=žšÞ­ã3!å~âk¨Ð=1\¾U²,—¾fã#㘣Á\ÜÍ“Ò•ðb’µi¢ ºÎ¶Q ‡Š±ëXaÈ2/éFe©ÃºhYO{T}m¥s± Ù)fÛõžÒ¼þ$ ÀaEÑ‘Nƒö†Â#7ÝãEIí­lßwÕµùÜvžúß‚«ìœ.6´©„€zçòbË¡á ¼P%~i~%^ÖÃÛž­vÒá__—þôµÔeЋËÎz ‡îüŠÛŽz/F‘™Ã6{„–³ž”®E­ÁÅ"Ì ÓôçZ¡ƒ÷u5‹Ø''†bRaã‰ßtWFj+v1ú=à(>׈²ÊÇ"Rº?#L ­ ³ÏÈ zeÍB*ü«öc²rÀ£eÇƆQ»e?ã©ä“ ›Bz¤0¢U©™106¬•'6‚-Ø)6‡žÐÂÌ]zŒ ׈êSÁ0H–½Ëm·°PF€5I–ä†2üpx)ç_¬@ÿ1¼ÚëMÑr³«× `À_Fò”ëØQ(Î[•âÉÐï葘߈ªAÚA*3úÉ$ÎX8G1tuéSîs¡ñ²§Tî5I“ž¶«áRÄIê®ôŽ»ÏOVyše7eŠg§ÙI:P €X"÷û¢¬{Š’*§ÞöJÂ%Äì9ð´ëëÓ³èÇ2D@»ëf/ek{À\1·D4œêùî•#ØùM:UÅ5ûjÖqâ0Æl»¶È¾qÊ®bë#–9ËLË,Ú)ó•…ë^Éž?Êݯ”ïc+÷šA£O[ ¬�ý÷ÝœÚæ_—¢O3{ô‰äìŒb+4S�ð_ÿÛwNKóVÓð5C£4 oèÍTQ:@ˆáÍž„ ç“åí “êÍâþæ£R-Ë\ ¢àqü@‘$\ô09^__PømN<@ãïy@Gn‹ =²Ã¯/^Wäø;%­ßÞwüÑ“ìNª¬8ΔcH iŽ ©ã&°§ßÉIÚ„ÕPÃ`¾ÒºŒ>•¼í ýu;][nsPñ²©Ï¦7¯?5 •ór¹cÔMÌv”3îÒˆ‹$MXˆ]4Ž6¯¡Û¶¦Â³r÷ó«´†8\i}SnÆ®«Ñ^áÚ¥Aòœö¾Ýª÷n0 xÑd§â±¼‰x‡j"Íg«zÃü8&ur‚‘9mF(´Å‹ö•˜Šr–Þ¾m‡ÏÝn ªö©‚C’ÄVZ:b«Á \¾`¤ÉÎÆšè0Sgï÷kléܱ_…WwìÊ ²ó@KY Ó> 9»ƒöâ\šÈ[Ä•ßg.ÐÕOè-&òÂD‡"Ùîd8LÂý’xðä«÷JóJ%¤`…زâ`k‚ó‘9…?*(X°f”;qZú¸Ÿª2ò Ø[ä?dV®UapØ•¬:©hz èÈ9wOÏ�ßPŸ34Tœ*&˜CrÑñ½‰U:¬³ X) ù¨˜¥ç³@ÙŒ ˜N>iÏ>`4$áJ[AxÆÛÞœ|9m™#(¶ÙŠØ{Å›0 }y�Zïô {õ„F‘ÊÚ=¦±8ž.¿éI¬®X3V`•eÎA¤æÐÊŠÅ%G•bÑ&ü~c4Ë¿¾·¦j‹‰ÆÞNTÃ\UÞ]‘õ¢ƒFù¥*Ƕ ²w•Â0¿¿NgÏâø¯°FVY,¾—?çÑÍïăøO}þâØý÷³BKñ‘ƒ®Ç³†³JR”íæÚ–ñõ¼7B7ÆŒK£°Æ~+9 'QÆ]MΓ¢ÅÊnÒ¥aäÀ=ܧ]-å­%•LZ&aãF?¡¼ù ¿w‚r¿R¬ý‰C™Š•2Ã`i¢Of»?MĬ´H‘RyÖã–Û§+V•b¥­Ë_iÖyæOSË ]`ØóéM•oY`üy¼@_¬3o œ8¢Øä^¯ åŽrÄäKM1ò«7…ë¼üß7CÙSWq`‰U0àrhám½GTö˜=ŸÓø$õâ gYCfn;èÙVÞÃÁ7£ƒ¨ðR.ü_\¢w«7Éâ‡Å î/û}_ ¼EþTœ%¸OôLó/U(` ¤=5Uì`ZR8†ÍËýél±ŠAuyÌ‚dT^ĸA;ôÛ\Qøþa—¯ìsÑ?½BË`}ªz7sOïÊ/týòÐãÿæȺ::£G¥_ìË7ìäâ5µZëj�ÝIpNpkz@9Ú|V2˜{¤™î†ÖºZ‚›ù%´;öz½ÒÚ,iPì8÷€J|ÔêÅè$žísŽÏ'2©/�†p¹yPÖšÊ0–F…¨åFf£‘öô¤ï@rJQf>ÿ…}Ï?WÝZä¦õ­ƒõ«ed^úxtÃkÖ¼ž]7³f3ÐiX£»ÿ9 ÿl!¯1Ï/ýfsF“˜ÁtåÊ™)6[*$#;/«ZÑTœ/¨ˆÂ3±¯ˆ‚j¾»ëëãi‚…åýßúºÈª?’ èÞ]’[g»ÚÊ=ÑÞì1øËÛGäÓŸ´<=i6º¢9˜ {‹ƒ!ÎÒƒ-&æ[þõw˜“}wñáJ /ÄnFú5àJOß9]È[¡:)ùíXbö:˜tAÎÊ]ÜóŠg­YKZbqûyo£¯¨ÌÚ9¯jOØŸ8o¬]In³6ú ±¿=˜·‡âRÚëè܇cÎÈ©>Rˆ˜·àßÓâiQý,KåØ"ºÌt…ÛÉëIÑw›ÚÜ£Ô*H… mãgîÒ2“}<Ÿ²„ee³œê1ãâmË‚ö,Šç뱧ÿBßMÀ´†…½”¤xWþÙ[!þ£ñÙöb{K1)iLOÔ’oÿ‰—E4i•Ä™Ëb³ §“¾Üé ‰±v‹TÊÎ ~¥ Ud7ú´ãDÁí]ã?£!اÚh€¦6=1 ñöJ«ñ è&öa§†Ì37ÔóÈf0}¯ü¾naZ@ÊeÖã¹3¬Œ(1vmZÁØ‚£’5­æ=ibÄP‹öywî™âÿ„-T·e.¨w°z¤úùWHcM¥†K•U£Ã±‚ŒçÖ;_CF¾VKŽkß”=|ª *— í[nU0–Ýà®_ú ñÈ!ÙcC6OTyWö¾� tb¥„™Û([Z"¢Wæ_>UÙ."£9ÿC7çóÝb¤XD½mò¿@’&Yæ‰Q±ó~ë£÷¬5†¡‰l0Ò£ç~ï'OòT䤩:Ùt¸)"-Ä ƒZT¯ |èØ 2šç“¦z{¦Ž§,“‰–—™RÅQ›~)«æ\àâfüV)Ù"ÎÌ)áÂZ_oe˜ oXŸbƒ]àÄݽ[›C_¸Õíµ‡yoœ²ŸøeÇe¶â\TÿÑAuÚ2d¾ª¡B,hÅ¿Îý•Þ±9µ”žßåã&k2d0F$¶1„åßô§ÓñFú§¥‡€,f‹À 1Ì š ^lj÷CG:|×Y Š|º¹J5b¤SÆûCéó'®©¬B %Vè ƒd#y²h-6á).çýmäô¬¿YÎx†ÃÍUå.Äf97müÞít2:)yíï|É£`]xæ‡LEéÏtïÆw§#¬ÚZ"\ÐŽçó¹Msþ÷_˜Aò“ÇAbÃð–;5ü_Ô~äãKo~i¦£-Uú"GÎ#¸>©ä†z<Ðjl³qKÕ™l‡M/P?—{H\³Ñ Î9�´Ô†³S j0€–ü.m€&nˆÅ“±h¯jö0¯*¨æ/7Û™g öM׋Ý#,€w™(ñ,ùÚ·*8ÊR7$)xAÁï©-NšÅF Ã·;‘»%€÷—0„Iû¨[‡K„,ŠC¹±È`0ÒÜ胔DÇÃrê¶ö\c-[—ôès€*9xqÇÜ4™ùWú0”¨ìx Vó]J·ªy÷¦4cÝ»ˆ÷šBgÚq?;%X‡žÒHžíÏI|ÖN@¦>ìhó,ûÿE;Ú¢ðk¡)fT—N­SÿiO( úÞŽ(Å—æp=Vú‘§Ô!s¦KMëtø¶yÍ[Ñ}âY ¤s-¥ùÞ%βHØ—Ñ{V zdr¿wÓ¹iƒ9/ð ÷Ƙßz<=ôãvƒIU‘aäæÞ5lóoQèUܦ@xd†Õ_˜“±ksˆ¥—sÞR53P¡(uïêýKepDÞ1¬  ÔTOfÈÅPâ´m­ÓDUgs½ñ‹ý•[sOƒß` ÅØgArޛóËD<ýU¯ØJH…Š(ßï’ þz÷f˜ŒRÀÖí/ Fþô¥D€º¤ ¢vòlkYÁ< Ê$Š£šºù‰ÕÒXƒü[.yC´P4Ã�ÝZ—tæ~E°ØÒu&S›Ô‘sFóƒ;è 5rk #ÊqŒCÙ ]ÏùCÌ7 †Þ¹'YæÒ‡˜HÑI÷J,‰ã¢{â–†mÿß ÅQìœLº1L ½Éûè¡ oå¬xpD¡j»è\ï›$P¤çUbü ·Õ.&µÙ\}™Oøk”xây× ?‡ÜrΞ9&Ã=Óš“v-åCFlà¤}çç:YYœùN\9×ëѵs¡Ò8˜ë§ß²hnçO±îíLGô¥†fJÎLäŠY|š¾ïb½ß ÿfëvIÝ_%ïÍd¥¼^jãúPù7r&&‚÷§åFg½Õè‘Sêþ°±’÷ö�zrõaÜ€úÈç«ÐšúÒ/:®gE…{ÕøÖxÃÞí±3Çð š“¶òç^uÓÍÞ æm‹ÐóKby[P<c+o‹Âe$Šp²´ÎžîÄ_©D”nËZ…3ìmZÃÛÙÏÒ­èªÐ7ªB]5BÊÁþ¬Ü½@w`ýÝDì@†3"E€ró¥( 3 G1ys¡e÷®déD òƒrªF˜%úÜ@'÷'9cJ&¿DÆ“üN8å|Å,²Z»¢?«-Œ“óO•øEÌ£ ñ0œÊOåEU9h$«?75=¶ÔÎð~Ð"£TƒÁ`™õľ?äM=ÿ4%©®¦müùi¢nê o««}å†äéȪ¹Y¾ˆHÈÜÞ¾ËØõÄ„ç0ßÁyW \×½ºwå¤tgôPío,7‚9Æ€f€›ª î·+Û ó>jÂv†r”�FnÁhMûž¯:ÿ XuæÍ„x´q™ üô¼ZŒT’¡7mžížÈ— ,™m’_Þ+4Ç2—)(¡¯|bn–ÕÄ2Áô[T´ªg:4ìÀ9úµƒ‚Î$J~úÚ˜M‰…á7vìó6y™­À’ŠOƒÂ¹)mÙQ“É(z8¹| ë šœ8ò¨Y (_`t Ä;IaÚ`åMVŒ†³¼a¢ÿÉ¢—þTS²Qµ•yÒ5+‡%}FÑ]™ø¨¤%Í‚[$#CÁl$g…™æºV»¤¹ãa¹ŠR¾Šs2GŒy‚Ž tŽŠOm°³eqÃB'µ�¿‘¾$#V.éOJåEVÅØ—ôÿý×tJ£äšå�'Ô=m�»¿æ%yÑl-EKŒ¶üÞùÑÅ1ü²6¨?¢ ïþ.|H(÷´èQpšÇQE7Š?Y6; fcÂ?Ñí§mú¡}‰¸aé©?³£ÊŸ¡ªnKJpUÇ4UðRFUgí;N^”Êé—`2LlA¯2;Þj_^xý«áa”ÇÎç³DçáøA‘4t÷VDZ§—æd‡¶×Ã\ú[¬½ô̸òÌÄ2bÒÝ—jÍp ¹CKÁDÓ[JÌwj ¯œl±¤¥QÒ‘ IuV¤oÿ¼elj„&Ž7Q²ˆÍÇð=‰ ¶ÈP�S/ÔÈU÷£Ç­’âË¡g†ó"<“ç¹SäC~Xe£Ý§T‰Ó`Ö/¿éÔïM{òŽˆydàö_QqÕšÞØ71¦È=ˆ6¨úå1ðÕš…Ð'š_+‘Í»Õj±ri¡·¯ÒY'ÌÔUmUíNé[NÓiXNß K5­¤„Ôs¥l7Z½gÑ\é^Í’r7y“±ç8etk>=y}Êh9Ï.‡£eíÁ$¥ð3ØÉu}©MÈýžY ¢Ñ Ç»õ|Äá¢Ç–[¯IA¤iæ •PØŸbÄæw§ät§Yû3gƒüȹòèJ9*¡Át­Í‹Gö²»ñSÍLÛ›k¿;xV̥ϠC5ž@üµ±Ï6Y—ËL7æ_9ñ$N±¡£>¶*WC•p½xšä„7 #¸þ¿¼»:V@µ¬ÓÜC–2½p×&Ë1ÁøŸÖO£ãóΰ¬Ê<uAz¼íú½g×m6+—ûö&ïáÐGX\¸ÎØßßÂÉ:›§ó¬ÎØsÀž<•¯•ûÌE⻑"ÛÉm¯™ž¬ ‘Þ§ØÜÉÐ ÌÜLGp}ä–L‚eÌà=j³$hsïéM㜙ïNѲUš�œIg»K&4TÊÍ øö’g•§¬1¨¹ ªÏ ¡`7**ÿ”Ýe {üT­XSQF†ÔÑ6¥C¯Ÿ~ï#ÿu ]{ö‡ BᲿNo˵Ýú~d‰ê2ÏMV‚hp„ÊÚÖ<ÄšòSxP\T¤6æq˜Í•j|{,zc ïò¸›vŸB“ª5º½]k `£T ƒyÊK×Ï’ri}qJ¶ÄÓ©§ykyPºÝÉbtÿ JçƤ"­)d]éÐÀ…3ÚÇÐO»núóð²<q™xzâ[)h#X§Š²Òa~ØjüƪßJÒ8Ò¸6ƒçA}ìD7Ü6¬}³MÅv~³‡›9 ’ÑvŸCaôL~#âVýF~¦OmºÑQa0Ê›-XßûÁîX5B×$£i«"Jþês( é†ì1‚FÍÞo;Ò™:1ƒ3Ûzªƒ´0¹-VÑÖa Ùϸ×!³±‹º¥qPNÊbÄ:X*¸;’·r©x‘Kr+ìÄbØ«M îê|¦lqþV‘u»y+QŸ¯N`ÅÅݼÞÕÆñJ¶¤Ü‹þR»óâ,'=ø“‚ZæöHy8;žþjF§"`Œ9&Óøö>Ù2oŽû±#_ój(™m« ·úŠBD…ÞƒR‹öÒö�øh{˜ø¤|TŒ¹GéGñt1ÛÊN¦Òv´¬W^CôøzL(|µnÙTy{ùÄ«…wœ­Ð EД«|¶N•Ëñ ¬’WÙ‹[7“È F³ù;†ÓÆÈ,NÀôc}e±R[¼ê%‰ç{Îçè´ƒÓ*±cÚà9î¬R-«idÿ†ˆ]¹RhïO�•heg™x!§–„ÊÐ]zOþud×£`ò †—™ªÁnç‰÷À™ÐÌÎíá-z}÷¿9ˤNš2d—pÊÒÉštГÀ ÆPΓõRcˆÐëê´±Oªd«èýnÃcïéSíTr lÁFÇæïÄxÕ[zFx.Ç<ˆ¾”„Ž1ñæ4¶:ànÏѲÊ;zz‘9fè¼x·[ÅГ–J@ßÙƒ†I*ô²k{žÜØ>³™kßx(wåM¹þÙs/WKk1(°0hhÍLí7¢„:ô͉NŽâMús5à.œÚ[öu«÷wZÏqáÄìxó®Œæ‹g oÇMƒ®†²÷m+þ~o:IÛM³ Ü϶SCQ‹Â ïNI&èÜ\Lî`,HlÅVÌZLN@¾¬nQšz&àw ‡ÕWzzP ïþš3ˆÝÐ7o<} Üæõx”¡r\#F¢U u«$ˆ÷³ÝâñáD²ŠÿBÑ*s“0!‚nþ”AüÙ;]@“Ó hxèåðx`*Åöåæš‚ †Y;`—ÒR2j‚j£õÕ·¦$¿ýÅ3ßiµ¯d7“žã ë;×A76eÛÉ -g{Ay>ÿø³JIæÞ£‰„Ôšá¨g½©s¸=EÇwènu _ÍÚ­jpe`MC·1Ÿöfˆ&ãÇáèZŒK³¶©y]µ˜ 'Æ*~tÂc~ž=ý~ˆ7ÊR¤¬Ãô•Ü•låoz÷"/áJ°ÝfÀí§Î$¦¹ŠÚ=÷Ý,÷7ƒîŒMœp¼¥µ„AÞAÖzBЕöÌÖÊ}þŠ-4p×ôiPŒ:ÁÍÐð0é¦Þü-3&öŒæ*ɼÜÏFÕ¹ª0ÍÄaJÒ êÕç]WËaá‰âi0¶14²ì+l“VßsﶤÂ뤭¼¯,ÞÔá~_5“vHVÿúA#(öF<L aªèŒÝ¹’lÄ!»Ì²¯9UÀ‰1Ò[ÃRÅ£{'ŠãúÀÈÃIÇï ºÕÃr}ÝÁé½vlŠò¼QÓ»µ¼¶[ƒb*�¦ö>{阥gÙùË Œóï#Ø°ïOÇ\GÙCWÀCÐÖ”0‹?³†ÿ_ìœ4Ï<ýŸ-ˆ,Hì$;â^ðºÉføŠÉmå²_c©A‡lüµ·È³ x¯çãÁFx -zê.nõr¬jFßiPZEðú´–Œº]¹ÒQ~Ðw´©—ëðÏõŸÝiØõ–éRƒó†¼ëÛ/p,zç"VƒË&ž‚ˆ5¸TŽ”Q¶¨]§$ɼ‚7ƒ¶ø‚…óK‚w™†M7ÊÅ[:¾¼äx¡'Â4�ÿÚKºTXÀû*ð·ú¬Ëõ!Q€Z__¹däëˆæFÝ0ö1î9|ô|ô Š#�’˜Xd¥Õ–1ÊËh5šNõ÷/3§�@Pèp†úUÁ…“w ýäù4™µŸ~ YOyLÔ.T_õ»pSnš®tžÌŸgÜì¿SÄÊ*Û™e˜ÚZ=m8•xÐãœf-eæ8½_ÄW±û*©H Aò~õ”|�†˜fF5µÑ¯´V˜‹¸¡ù¥}ê™ïÒ“1Š®Ã2ºª`iDåþú\“þ|ä:ùá&G ‘PšõîŸÎ㨓÷+Õ­ŽÞÊ«æÙ%mÑiþV¤+÷@¼Rªu®ÕŸúþ×"\QTú߀%)y›­+†Gú Cg›}Í<þcײ¤¼à“~Ê ·Ï#ïz€ƒMÅ:¬—D»ÓN~ï\jkMÓEá5mo·:KeøŠ[ÍB€lyj†÷^0HœŸRÂzö§<HöWOäx>z³EaâvÓnO)ÌÝ»"u[†I• €Æ¿Õ,4¥2=póêhQÞ$ºâZm(‚´Sؘ‘¡4B#Fg8¶á–¹£UÀP¼§*gy …ih2t3ÄLÜÊù8ŠÕ (æzÓï¨à¤7£W¿á¨ÄØGGUk Ê·±l5ýÇ”ŸÖ½ïXu ^f m/?Bÿo§š ¹x'Š9‹TüÓ\©:ïDëé|„ØŠÊæ¨R¯Š ÛZ øн)•Õ·bgËfçâc*ŽR_×™­†50"Êë€eN:Ekló~<!A}}´`¥çÀ+“" ŠyòÆù»S?;ÖÀ¯ ÒØ£Jñ ê²eÙÚRft¹Zú¬ {=n2;A+!†Ò›¶¼vƒ—ö½šW‘Øv;¤´7?.{ônqFOó÷mæ /”Æü© ’AEy�äš02³€·i=}h(¡Pž£÷ƒ7‚â2Jž]BI~¿xw\4?š«rÁÞ„£ïs`5Òˆu¡S#kí-7lwA˜àMÍëGˆ_T¶E±è¤B_°þ ïçæÀüe‹ÍÞÂaãx�èãeC¯Îú#à|]­ý¾\ðÃQ{^µªjíå++ŠØ½vøÁeòðŒ?ØWYaΨ4%׆1KÚ[@wKk M}¥£x9·< {Ê( Š·€éüðŸ˜(n»—´š–-vœ5ËÆG°$]7´ `> 1ìæGzóQœøh";§ÌPs€4ûí¤vZwåG^ÿå”b¶�Ÿª òöË!<pÀb¿š£MÝ»úF¥ÊãÌ:™ù—e?ƒžÇ>ӜҮ×ÅC$¤§ÿÊs…Ë õÖæÌ]ì>ÏŽiË£ônK5ùòL'"ÎnèìÃDï·»X½Æž‰�]†Žè®;m·°(Ð62§wt¿ø¸õ^µ²µÊæ È:7`äükïÔ®“r 8N ]º¯„9`ÓPY‚xrÙ)Ì—'ÙôV³+f—¶/õûÏgòröC³‚t ¿Æ@ ½q N� 5UœÂ͉éRï%«æMÝyýȦ«á½"翦J?²g¢(Ïü§Y‚ìR1%̈¨qaÉÚ½ú¦·VúŠhú­N˜�²³½•PÈíV«>#Pz”—†{ü|–lã¿r•Û¡¢ÐY{ú-¼^m†ÒÒtrý¯N÷£"ñ'2lσr§x”‚ ;öÔS¼Ø¦gmfï- 1lÎ^™gË…*kWPÀß:ßé– Õo°2bȹùš;Wîc«+¡‹Ñ§Oz=F4œ¤oa}(Í«önáÊ؇ϼÍY¿Pš A•½¿çÐuïw¼5ž;¹<?2¦Çó…Ê¿ws@š–þGýáëÛ ‡{Ê]ð<±À‘éBõŽŠˆ@—•‘†1ܬî/“™(^i©a1t,§«ö{T]ic)3Î8ÀÁ Ñliÿºé¯ô‡ÿÀ ÷úŠï*-fÓÆÜ@;(”C­é ¯œÞ¨­ÑýÆfô?Y©3=24mo'R™‰ÞÈ`¥jþÖ´#ÎnŒ. ªQgLÇ®g¬«QXH*rØ[ë-ïïG1rk" ÈgjÅ× fÇÎ:ëåùIlÛïBÐŽÁ~ËYzÄf ÷‡6çÑ´ˆLä=ÒÍ<ŒíiEN:3@­¾Né)Ìž!ŽV ¦-H_™Íƒ¼«L²ÂbX[$ØïÒ šÎ¯ §Yç)ÓO‡‘…µGi=&©W+ £ôÞÕ¼³p÷iâ$£uÞo%]1zÄ/ùŠ9ip!T…Aùùî4• ùf¦=tLÒú@§äàLOñûo vç1ɲÄõÏ*œÿÛ+(£ú 0žphnU‹8±§Ä?}÷Ÿ¿ýJŸ7çugn`Ì󱈭A¬5e{�d ·IO—æbiäîD¾D±u¼D+þÜ÷3Ke™û¿£ã† j^%ÂÅ…s|ge¨=•Ñå—**L¸Þ|p»Ø¨ÊÔ0žh¹@‘ŸSTÎï9g—¤SÅäØßQN%vϺêÞ´z-d{q}®y|ãj¼)d½jÌÆlʇ­- @ ~W%ŽÕå9¨ÔtøfËìÙ&l±’ÇØjçyÙ_j4pM0å.£yù�P±©1|‘N„F½É4µñ¶`Š¨GO­¸üúP@QH`ï.²2q# Lb¾–ž­Vˆ`Ž:Ú;ZôÖòô§!›ÇáG犎*’ÎŒh;ûä7+èr±‚½»5lï:Ö¤€ žøSg [`êƒÞ©B[‰*ù°Ò‰Ãd…LQÚÒÿj=)àŽõº¬TMw5Ó¦;s'K*Kã=ÖÌiÅ\'åÃ3�)Å…eÚ×"E÷òÅ ¥gÆŠ´é¡É°ó¼@°+Ñ…Q §U�z‡œ3…ÀÀÁæ‡TâÛù`Ý0{Tf°‚äL)ÃGÝ)®]«¹Êƒ6qZ%ötãnî8AjMArèݳL¿x¬oNãÈâCû“ð™×õ‰™úR\@É·P"ì 1Z³cp ~‰™¾Q3½ËÁ|ª5S,€3Eò:3B%ükÄæãé´¦%eî«Ñ‚›ö VL‹-õôýØ3€îpz'¡ØmÀãýQ䙯}šC`9¤zX±ÊøÈ{J°¶ÌÚ¦£z W{!ƒ¶“á"}×}ThÓH£5Ðeh*²4²ªFzÃ?=—ÀM×´ÜØDQsæµ ]ìm%ž<Ÿzªcwº ÁÌÇP›ÇÓ<s£—Eúÿašß?=õž‡Ã¨,W9tt_tÂă²{@HZê‹ü•-ôL®OU¦qfwŠû’z0EéOH¹yQÙ¨“¡H8b>%Aërè‡Ü0ʉ/’ƒ£¥‚‹£`Êþ·ZRo\™ÒèXäà?ÒܲȨ¦x¾ŸÅ£r0vs1ÓÚä 'êøΟ™}?×ckl§È@C«™ŒÌùã0rÃê/ÒÍ"Ê|Ù?¶’¢Únþ4ëg:˘Hl£·àËÇÁ¬‚çË•£§q[•¯bØ"ßÔŒýÑQ¡¥ï“Ëx¹ê̬þ¶>‹’pmO’—4ˆû‹Y¬ÀO«Báfnü@ˆÚwd?ªˆÇSÄ­ÎÔ •ÌËQà^æY¦ò¢³Ðk\8SUÿÒïk*Š™;¦ãÕaùÛ3d[uWóû¥Ï\÷ÂÄÙŠ‰@%¤£’kŠÝõ,{ +&™£O… (;qPöƒçí·»ÔgnÌ.†5u=òæ@1´w.`Qäðr1°'zWzCvga ANJ-…×Êq/êÈUUæÉJ@­N‚ÊrÁi]/„µL…æh^H':ã‚̸4ž¾(µž¶ža F[ý©õf0\°MÚÛÌ#]#&RÏp™eéçãñÎÔJDŒH�e�Ð{ý‘˜ŸŽpǸ1€Ý«¯V5c3H÷P8²´ƒç@w›Vűy¿†2œò³¹Ñ;R¤ç1•_ÆÇb`GÙïr¼ñm®©èÃ}Ú3ž¥fj&¸j#ãÔX©Ñ^ܾiêy&ËPñcGåìiqÜúÿgܳj”Ŭ¤räl×h• ºUnbï ðþïMÌ;T‰Øw„æ·¿2|P¤IS_¹4EÚŪèæá`ƒÉ»¼<7ˆÃüFo{î"PQµbU¢ëÿÖ肾m)þß;hžõ°Öz€÷”BWVªäÃY$è( =êHvús d)+Πnþà À]'å´²Ì|qÐœ¡œbùÚ»þÔHf¹®…2»¤‘°õ4¯fâRˆ^ú½oeõa.‰ÁY¶WEû¹»@nC;eŸÆ*·ìúþj24Ù¢£Òš¯˜µå¦ßfø- �ª¬[æôãtšÇnc•Ì„Czòë Gæ-Mb0tØ‹ÏÉpL˜>, «Ü»øI'Úš€Ê7IƒKK‰[½5Ù'ÇŠNFÞ‹;n'–¥“oâ]?6,3”z`€Y yÎÚ“GÙ«I®ÄßRÉßÌH¥g ü‘N¼½0 _nW©NKî8ýø+ÙÊpXÏtÖÝjO  ”ÔD įäDö<4­ZZ¸qPu³'̽jìo»‰ ÙÀnõ‹à°£ÃØ*Vá´XpVžì™)¾yy¢º[“„Jý‰(6ÅŽm¸>†=­jTÖS0s6™·{úw ߃Šò‡Íˆd¼o=Ä8Ah·râ6ÁpÄ.N/¤íÚßÆâjrÓh,MG™ÁkÙ<;$â7ó-æQìîåÁr˜8É<â0zÄZKΆ¿‚<¿ðÙpâ’aC®…Ö»Õëyõ<ðà Êc¬ßò-±î'K\`hïçÞCAÒq°] ÊϨ†ýÜ©å± *)T–”‹XI”nÚ¨d÷KZw½Ç#‘£'Ùs·åÆæŠjZšãÈxÇÇà:%A2~yÓçét<÷çÙn ŽÏüaզʾZ“ñ4–hÌRÀÀu§]ã±”|Á!wþ×íP´R±Á3C¨¹sC( )LÌoô(1ÆQéÐÛ×U?)Î<£j Îê”ó—â|#§â€fþ¥Ø‚Ïo °H‚±;6ÓéÃ8ø¬2Œâ•;D�ðY&“µ†ùÅÙhåéŽÒ­—èOî÷VLãòŽi ¼£Ù cøK»•Uf†Í ´rßÛÛó§o•v[F=,§Ü‘ Äè4Ø 7zS¸Û©6•Úgú¬í꺭7§é|ü>T ÃÐ7”‡UýZEŸgƒßåÍ&,rZ‰gºEÚ‚f=5Ш}Û˜Qá¿8[»Â—½R"ì{Ù•Fý•våœQ>=ª€YȨ Ü$;^‹‚?ûÉ·KY«4¦²(Êó—ëv,û¹2êô{€¿í ¦©+„cfï}äAöîוWJye~¥YõæD{paf;¨0ÄìÕ},±û Cƒøçþ¾±"($›5°J%õüz„Ÿ†¾²c$:(Yí;·lXmLõnèŸ85‰’‹;SÈ à݇‘=¥E®ëor~LŽÅ0 r+´¥¥¶–#÷é9蟈NLV}èƇV¼‹>ö¹­åµ|<#Ü&›F+µ~/¡õx¬)3]ÜõN\½íêÉö‚ÿûÉbúfñ QŠî²ß»‘¢õ‹ò`NÑ.5\ùe¨‚¸ÕÞ3G{æYºÅx~Ÿu Õ+s"²!·žÄQXºÉ]ÌcWEÓ{šÌíTÓ9d–Öy45Ü|àY·µA¼ì;û¦žÆ/Eø$dZhbq˜1÷ÎË•ñ’¾úÏœÐ4÷&¸ Q;vt„d‹-‚ «©’f»A3š )dqîÊ|î$Ë]…/†Q´a«Nï3P[ú„ÜŦ/üOªÝ °‡ªÏ+þŽÖ+mߢëœ@Öxº@«e:R‚�{¤> ÐÙLÿÑu6ÿëKU$ø.¥°¿õ$ؤ*L{K+¼¹¾MÉ3ßð=6ìùQyv‘ѲÝÉŸ·âö|“!?Aåeh»«`5gÛ@œÎt(__S]@nQ¹V“H; _-÷V³ ÓvÚˆŒ44fw´§Í*~|é¦|Yº2q¤x‚leÜh[1©Çéê;r{ƒ§Õכѡ•pÌ6ÜAõ­uœPf‚ëçÎT#ó^ò°y¢…w>ô2Hµ“ñ(ŒÛ@ÀuîÏçÁkê™Á,’ˆ¦qr hÒ{ÿR †^ÛcSSÂh \q],~)7i*ø¶÷.¬éj¢- ɲ`ßrCÏÖQËõ™Å‹`¹Û8´—paédí.ÝOâ§Éº¥—€ÏüõÈƸcºq Q–®NœË¢ ¢ý§u_ê6{;ûJR*œ˜Íé¼í¦ƒáZÞüøpú\EyÕÃ+¨¹Ëéôʺޜ8ò3àÕD*Õ5§‘6t#üÀäF`EŸ›A˜¶Ì<‚>}ßͱ(‚²km7œ…Ðwð%µüIÌü¹·î&”ßg•N—–ÁåÜ—¤”°¶…'Þ§ü·Ìûòv•þÐ+×¾NhêÐÝ=¤A‘�†]l¹5¸å¦x8´Ê(!ÒG‡ö HŠœ¶›e³wŒ<Þ|L£ŸfëáZ_»ÿl©ã†éÜÛlË„AT±Eja¼AßÇMÝM#Ò.þ€Õ ç»*¨FÏ |–EŽBäm·ætöwÞÕwŒœÍ“ ò4 – %kÉ4¬ î}ï÷™o; óØõ¨á" %™0H âŸú#ö¨) _gJÿ†õ–ZÿxÎœWT)™ù#”[©Nª¸LTtfº¶O2Ö5û €ÍØ ï´S[t¬Ë}gUºfspÆF/÷«)ô9󘕾p:¸œ½Ø‹Ö¼ê)í×¥|±Aù»2(Î*kØt  ²g©ÞR`,–ƒÃ§‰À!,˜ÌAÿ€-™wí¦]JEÛ¬`JÜå4êÞ¤ÄÌ$#«¸JÄ‘+…AûSÕ²k%P؃ؤ Ôø]Ò£ N8à|¹FT¦¯á=*O¶(a7 úÿ¢¶¼84ÉéðÏ-ÓÒ¿ÓÝü(-cpÒªÍæ>XE׎=Ll² ‘,Ó#T§2 ¤pDzâšWþö¥<C,Ÿë^'H‡ãt®=üÒHÕxþ;ßgGS‹L7ºŸ‹ U¬ÿÒ57`NZ3�>M–Ìîû6>aIŠF¨™cJ7±wæ:¡·œ à`.e³oT9JŒØ•4-VX£ý”ÚІsm±~ö≉ÎB#¡MTB@’æ¬ó…Ç{hÂtÒ£srvßÔísPOçá6aÍ++Õ/'ÿØÑÁ9{ÜL¢Ðñ‘PºúÁÎv~ü%K˸ý‚C=æ…EûéiCwÇ‘õ>QáçÇlå„-F@¼R7^=Ê°Ô梙i6mÍN “ï’57]Š¹ ™c€-,¬Šƒ‰’˜þLSXÙë&<èi0ûRûMñ®x<äe:ÕõȪÝ»rÜxèÀšËbv÷¥í«L€aµ“ýÀëÎ(¾9Åp:(Yw±Y)ò >7Ë›@'f->aô5BrœcGyJ2kþ‰Û»«ç,v&N"KC|é¯Ã°úÁœ´(ôṇ˜Äáª5š gÅÓT¥ê[áP¥óHš<‰VÊQX–! * Óad8£¯À&2Çð_ Éž9KIÁLu¶vd°¶e3ç_Ò¬¥°6óÛ!öô!rŒ‡Örºj×îñÝÕmüxÅê‹9 ¥ã³ó`<PÚ£m¸› enê@°%šë}'äˆ7¹gpçw·¼ÈêBŒ?í-Ö;JjV†œè0VŠÎTFa­i3Lý¹$£Œœ>?íü¥öfœ¹"±Ôù´ˆBǡpºrÀD“þRqÖ@S`ö1 ‡¡ÅŽU ßèžë½`‘¹”«ÄÛîΔe…‹¢àÀw4œ þä§K?3â*†È½”t¥QèûæBhd¢²éÝonè ÒæÍÛPÿ©þû`ÍÕÉ7"óØçßäAÓ—AÒX*K,‚k(æîë‹ð#“$,3R.Œ^©,Á ª€Ä0¦i=–3'ÉwÆýßzÇH¥ÎÎu^Òc¸¸cNÈlÝmÏ¥C¿£œûúÃd1Yq‡ 2ÔzuV�{8ü­É¦¤6z‰ëEÉ 4‹%¼¿l!¢>Ì0åå} ;z@©Îsã?@Ÿ=ãþCd¥\{ºøJo1åwýàïüîÛ7Š#"¸QÜö´‘Û‹ô§¬ æ¤à–ziI\øB8&/ãÙl*’z -®!M;3=Ú@Ú®3ðÍg]¯ÜÓƒäˆÔì¡Ï÷Þ{õ6ÅGD7¥ov˜_‰‘ÇdZI÷Á4Y‘­dÃ. ’Oý±É¤\7À^Ý®c8ê`WV~kþ#5•õm Ò¯@&2ÒIØIk;coþmº¯»†q¹)â„ÄR*,œ(g£”ƒ‹ûû&Rêl¤DèEÔŒÌ+³|ÝP*‹§#œ›®Z<`¾2_Ûe>Û¸¼7RŸ´%Ú©ƒ*�›ì‡£Ô]ð8Ó¤Ã"ˆˆÉ}Ľ¦Øµ»Á"cCµGI«=Þ7–r¾Áä<抗+édРX0©ÞzRCnQai';¯£T¢[ørQBé5´’Æ-É(¯ÅͶiA øÈËc~KZ¹á/'¡=òˆ³¢âZ1WHG½)§¶ÿœ Q\(íý#ØÍ@vȹÖ7µ°Û^ñþ2ÃNì?“d èÌV¢ÿ0Øâã™t_Iì?ú"Çq¹j~Ç<žN•TCúöÒƒ µ!õÇe†K8Eê¨MÇ“¬³ ý+Ÿ¸8­ŠÌ©›PÆ¿|f̳Òr¢m³P'yTk"7œ�üF‰¤¨hÙ}±Çi¢Ç¢/ÚYp ´Mh·–cNÛ–*f.¿äþš¦+IÉI`dŸ‹Ç•¦ƒ{p9ȽÞé³.j®U¼SÌ2 ;÷”Và¦|àžþ¢Ri0€”LêæÇ•ká·üSÚŒ´•ªæËwÝÔ<R Ý¸¹k´8[[ê¾9A:…·ç¿ñ&Ó¢j†ñÕñ48Qrfâ‹‚‡d%ȹ¢ªÿZqaÅÔ‘œ§DÃxvrm sÄòAbñÚö¼QÜñpŠ½I8¿?} ÊŸ¥\BÂ"iu—©†ÿBbÝÆi1—|§YþY{†¸bÑgzöXñ<ó½‹)Ýé©èJ—«GÙc—Ö™jŠ­sœ>MÇU˜4[¼ÆšÝ_æ, y=§ã|ëäs(ïá¢ÊN®¸˜ßðQŸæ†‰§¡Å•éˆÞjþ¥ñ-+¤ˆ8R*«íÀc÷§Þá\¿RÜù¿oõYf£l¨7Ñѯ,ÒÄë rMÝÌt'’­ºèyÜеà%j>»¶ð££]ê$‡çÌ+ï©q_ps¤½…‚–Š7Gèó @Í~Ùþê°¨üÖî·t-`öR[fŠÈso%PðbŽ•ÄZãÁ^‰Èyè‡7¶?¤|ï]- 9Z„deq4@ ãF:”%>5?µwh¯¶¼ÍŒ€âñ#ŠÙ¾Êª6‘MÐN†¸†âôG‡aÈÓŸL·×æ–ÐlM©Žž®6_+̉Âî|ª´ÓéÚ³OÌË¢�‰ö1#%üÌ)}vkA,©í*{™ˆ´6‘ŽÓ»i¢¯ÿ?xyϚ⛄¾"=¨†–D>~ùnJ”ÖÔbbÆht3ø­ÁG”§ŽQˆ¬E Eãw8{Å?{šB/\GdÆ*ÜÓFŒ¯µAdrÇI˜¹ÝBN:±¿üµ?9²ÌÓqJô?yœ­ܧE•ØúFÜüè|Í0gÞl©aI¬v Ì<*=•Ó¥Õðîdp)äˆîÒ¦øÝpõ¢Üð›oª 4t†˜»N DˆdÝÐA|T_Æs˜u”Î*ãnÝÑ€ÆI™èqLŸÆcþÝÈ‚ý¤æ|¹ ÓÊm—*È•, –L·à£›Ôžé“ÌÜù¹çAÁ MW½�kµ»bqZˆéÒÉëÎÚa¢£³´‡†¦g¥Î4ºÎ¿æ†@ Ëz(‡7$ëc’ée6§<pžàVíà¹ç*pqº²}‰Pô‚¢wUlså'Fæµ6¤<{¡øû8ñzÀŠ@U<à-íª«7{I®Dúæ4 ”ˆÚÄöÐÑkŠ©åjžŠ@ÀƒìzëùSseíÊÅW§Øþ¹“ «‹öJQë̦¡} äeŠžBªÿ[ˆZŒ¼}î5~žX¦kŽmLÇ"Åœ®÷Úöק ®ÛæÒâ᳓™/?ôjT«" ª§©éÙ'ïÇÙg¢þtBœû7É,mÿ« <%âÓáMëÔ§C»‡§¾µ>­/À2íª¥ÿœ£,Ênï¡ú¶§/~Æ ä2õc=³g“Õo^ýñ[!�žÕÑvÍ:‹NUmO;¶à;ßàçЧ¥f˜Íµ{Ê;GkS™è Š¥(8¾Pþ/ò˜ÆùyýE¬8tô(–‚LèÌÓ<ãv˜Þ̼‡ ÿà0É6{àÏ´²j*Þ‡D°o!>ü¯v³#k½«:X+©Õ¤\Ï!6sõù£ÐO¯1Ö=–×·NÆ£™·³³e>Ú0º7áîKU¼RU÷–àS|`–„+¯XyŠmo²ï MFÈü õ‡ð-Y™jœqž”ˆ€1©x¢7ÜZžP$§ÍÁ™I; Åú‡'I­“B²¥ôµª^[¸Ë(80•¡cšB’€?˜Raå+¯ÄƒcÏÞ o›û‰¶J¯øÔ £FyÇ8ÍèæÔ §ûEEçÄs1l$HmZ©€Û°? »<nýXõµ6ò-¡/%ÏvèB–g¤�âÞÔ”CôõŸZ1ô�7Ë¿ÚF¼÷“§¥X8Ä1…l£~BïçºØ¦Ôy·—Ý>ó•Ö…©ͯâݳ)Úw­lÝ”W@ò†çx„,ósBt+ûŒÒéÆÖT)÷Yê3/ ¾¦¥>m±÷.éÚÖ¾ZAiæsxÁ1Rô{7@‚•Í¬ý,À±LìÛw=+\Ø«UÏ3)†ƒð£ Ò¦ñb4W¯‡ØYùä§1…7]c¡Õ8 Ù⊕ æF,P3Û046ûù”½¸¯C¤¡ÔŠæCLϬóGâ,¸l³ù_T${/(¸ä,´•XçªûZïÉ}}–‡ª-ÙÚË™ªÇhÅ—BJEßµãEm5‰èœú8_Aïòy©ZD¦Œ“Ú TÖ(í$a÷PÖ7QòÖYªõ/Úý®LnP%zûÈAÀkTKm_!e–…ïf”Î"oÚÕ ÜøÁ®g:ÐZÆðÚ Îj)eá.ØMR›f«3•T¬|D…ìy³|èÖò›>zõpfB˜§yw¦·¼Ìf˜ƒˆ-ì2+Ø áq/ßw$€{t€“D  ¦7Þµ¢­Â“üñtÎЇľ“”q¶áQMEGÁyônÅ‘–ïáè!ä–šÓHóòBUUΛU°/3ÐH瓸@þøF¡úè”1­üƒ½áÈÌþg5½qÔ«i_#ë;ùA=ì(ãÞ7¬2ZDóÇËMÔ™™‰.^6|9LŒ´×ß©¢š½~ÿgúŸLêcOóŒÒÍ9§û=Ø1tVñ`ªd:'äþ鄱÷|íÕû®™t0f°Ù¾¢ý»«(Ì~ÁÝÍô¼)®liË9ïÒÀ©$#¡eGIr÷îúZÄÀùí~•¼ ²ø±t÷S/°£ñA;se®ó‹î 2!KA“R8lïX–6ËŒ_tÄÓ•™",úà:ŸLÊ Ö8­šý`¸l¯ûW–á¡K£WÝÕ§OuãÕû¯È¡¯¥ÑÓ8—‘ 37}a1¡h9¥Fì–ë(!»ˆàêKj½¹§!Í6–›… J¿¼[χ±§éŽb‹!%ô1†ÑJÄ“O y×/}º²¼z•Ã ±-x dàVC¡Æ>Cïá`©æG¿Á½VÆzçîák3WW‰tsÌSpºÐ`Ω�ŠWm¿<×9ˆ¢‡A÷EŸØ3Û¡õ{Þ°%œ0GÀ¤j†R% !­åÓØó_åŽÒ%Rk™—oÿ¼©1nVò—5€yaòý…ø[îÀßBî å@=mƒûÃ00KáÁš('_ˆ=R°í_zžÌ N`Æ`Ì´šõtßî5@ç-[]ðÍ>σx§|(WmO_µÁ°ÊÙ!ŒË�$MÐõügC‡Û{È^ Ft ©oiu¬Rn]È>9·‘3ßÈÓE„ÄÅÉkûcàF֜ҖöêÚÎ0"ëÀTimCäíèf㱈 ÜSZÏ ,OæœÅ{æm›øK•ŒØ­¾¦²Þf7{L÷xXéÈ$†<’ÓÕøyÇ°j¡­¾íœ²hsº`ôo‚³dÌÇŽû2L©UÞç> ¢&Ïmg.Æpá9gZ)³µ<:StÂò:Û9}ExÊÚ˜‹_L«=´›Ó¢/?û³{*ƒr~D˜ü[5:ö?µÙÁ¾6œã[ói”ÉØÕëÙWlgý±QŠ>~PÞ±U¶H\(¢9ÿl?º¡Ó|³ñß×G‰b4oÉ þ3”©ñ§mÍùo LNé$ÒþË�öÖ`w6–W`<JÿVè´(½¾ײô¬“ ÷Ž‰ÛÖʦÌq±CGeC‹ «æg'ÎRSi¦£ÖeA9h†™‡ÆlîÖ!쉰]”zfP,ÓÒ×´­jÕ³Èa*w¢Ï(A¢éd”áÒk»Ë–W¶ I0Ï!í¨³wæ‹1¤çpÉÈm~}ûŠ~Fƒ,vœž]½ãG õA•Ðp–‘%"ï7fGßwÁ\A “3oö”zš ñ‰�Àg}eðÉ›=ÿ¥ZáaPÎo˜¹:ïTr�m zç®·´ñßW£¸,üSµÂÀ2dò§ƒp‰T™ÏFúÓ¼65›’®ìÎ3å"ʤŸZõC6ìHw}õ†öÏœ²¯ûÁ˜-œØÕf¨—2×æÍY—’êMü¤;Ź/“þGŸñY™í9ËE]{¶(»þRz/Š²ÌC5!’&bxåá GÌÞ]ØBÛLªN/«Æ­nûÒÓÞú¥ Òôé}U �$¹ïvý{;ý*¾ã´2Ïö…cÜʳfÎ3J«99‹±ËaW«ï£<2ߨà²8ÈæÅCÅì9¸ëH컊ÑzFˆnÚÔ‘ÛäÐÕùׂñr¿üTv¥÷×7=¶ZOe5ÒÌ×kƒìßD5u¯³L*>K†)™îWDŒ^† ª—`¢nV±•=•r'g°Ä"­Ñ76¶x Ø´‘!0¯ýœ0 T�Ÿ¤ãì„í¬Ý˜—å²nųâܹ± Æ i"/F£PÁšS-«¿¡, vZ -äV˜yõÀ‘Û͆öH)èGÄï­ÃB"¹´–Ì;{÷ú“*VéY>»s‚Æš¡4±÷»e=o{Ü'ù—N»e•ÔÆq|ƒ{ßœhC­¯ÿœ6ñÑõ:.ýž ØGÅÊ‹Þ<¥ŠOÃ/Fˆ'FñØÇØ}ibï]>[(e¶r۫س»lm2´5Ý»ÓpÐèþȳÛf Ò!.¹9—›ª˜¹AÇó`Ž$!÷úqÏ:sqÞ°¾`F þ‘mrÏõñ¢ìÇ¿ÅWe«á´ÜÓ [Ë5M5qÞì3ƒÐ9ÿè}ž®ø@‰PÒ¾x€ÕnœOÖHòo¹;.uÎŒP$õ§U©é<¤ps-XÑyOü`C{§B1óÍÒæìkÀã½/›u(7gäÏùfV2£ä\tÝ­-ldtzçÖLñ<E÷ÄÝ Ïã”)xŒ¥éosãÚuþ£³\úç ˆCΊO"“Q£×Îb"<´t–¼pÄzºI –f?S´r²˜À….ô[ë2ðá¿ò€!9›§ö0hW³W0 rñBçþsùGv,Òù®Öm}Ì`C£M³ÃqìX;Rx1t÷Ý•s×X/™ïܼþ`0”™lp_gAònõË:0¶'.|æ‡äå8ŠVÚ!ôŽ¢ lôHsá{Ð÷ÈÌŽ«óYØóÖMG_oÚŸI•yJžQÎ~ö‘Ämªî!ÍTÛäeOû$ËV ^IÐ.𓻸úÁ>Bk5÷c³˜·¦sd}Ë}ƒÔ¸ä2¥qY:Ò½¾ìM¸”Û,žr½MÐöí<–·snÚ”µµtzé »=Vߧ“3e¢k:•Ö?ø#a×e•©!,¦2Hf%4¡…e“M=vÎ{UhwA u òÁà£Ö?ïNHî"קkØLçÓ—7È/7‘|^8Œ˜+Ÿ-Â:T¸%Ô"’é_ŠÖ–,·|òØïÌ£M̘sãT„iÝëˤÓ+Jbö×öºíþ†“x½Á8Ž(„Ö=ÙÙ…b uºy‘”Ð#8ÌýQC»Ñw(ÖÂq0_™!¢mÔØÌjÞX¸Ë1NéÛì�,¼Þ¨¦ž¯^œ}_À3e§¢¸Ó©ÃšÞ”`-?O|Ì¡åÉ=¢%èß~,8vC„&NŸV‰ÃÂQ§?!¤ÃÛ&ÚÌR’Ÿj,™VôA}ᩦdw9Ì÷ÛúÊæ^#�ØØ9élC˜™rJïÒm™®ž•¬û¤ÊV0È‚NÜ"È­mS2ØêÚè&Ñðxžp~Ò‘EÛ û7Æ^VxÌ$Ö´`Y‚tÿnJ.ø}˜.LR¯åd$t~¡Nà¸iÂSånĸõÌ’<œÃÓÑÙvõùëw퉤ÊÖ2QÃŽRøílSxœv›ÚÚ1ÇsNkˆÇôcKM´ÂK“ {Ÿ=¢°†m7ðПú>4–á!»vKDðt¢ªn¼ ˜‹1ß³\¦L]ˆeSV@{×Eˆôˆê讯5_ÿýx$Ñ j½ˆÿ½ñ¨YŒúíTëÞ.z¢ä‡±_PºË‹¹÷ÀsGåXë; M’VÆÎö®k•6 héÏSCåM¾¾Ÿê‘gjtF È‚ÅP‹pÌØ™7ÛଉçðE«óâ”í¯)Ý£µì™yýr Ÿy9qÈG}‘뻌f±JY{)·3ið/'QivãêÞ@úî]gýÐÁüëæPrÅÍ“ ']ù³bd²§§1ïœä Z_[”ð “5´éücJ#}L¨Áð¹÷1°2 BûpDÍÞk &m¬ìÝ©Q…‹ÀËZœÝ°MV~ßܧã88RBDndÁ²^¦eÊß¡"ÕðŽÄ/š® òIí9"´H.,‡ìëÕ¡pwMûÃ*½õ$¿RWkU‘y­åg™æ"œBwoþaÇ#K>‰œc(÷,/[Z”³ÎMXJ§fk2÷Øn.KCO?žÒMM[9J=×LJ+4º.”»Ààô‚ %£ÙØ–‡=›ÓØIºä„h×`xª–ø¶açæ_ç {و⠷?öÀY#IîqÖŒÞEû¯I[ªÈêö]×7"6 ÿ+Š;Ëi»x”ɽ³ÄúΙ̜j8š¶k0�³BËxµÛz€-7(+»>ccdIáä€u¿…wòÞ3z…ˆ©²"iß0ÄOZß4Á¬„™Ü�Ú„uÝ™^÷:PöÂð–5J)­>ýþrÞìÏ· e±b+§Á®§-{GUƒÔàb}W‚þÚB|A‚GÃá› Oáˆ$f2M?~éö*Šš-t[ôq¬75xòƒÐˆsß4F(¢Æï:«þèŽ -8¤æÐS4ª`'±>c/È3d�sÇ’£Ê• %EÅ<È#¤±óbk¡€þv'Â0÷/W¤„D#“]î˜ð†“öT’$UH+ ß ?aPy˜æ½yzMlö•¦Ú€¥Px<zž)óÁ³ÀtB&çþÄ|žF7Ù‹×Ü󢢤aöÚÝ€c+[äPÔÓGÚù’íÑ/ÆÞàL§âøŒ$¦N° $ìôövêV2PD1 ¨ ¿o'—×v¡¾ÆÄ^Ë‹u¾.Ñ%ÈZM³hÊdÍ7FÏJøG9&UZé÷0. Ë0u”$ášüÙ;¸·¼À·¾°|˜È²«óÀSî!-“�‹YKt Ý«³2Á:ªñVŠû"/”ŒrQÃVWZ½÷6Uæw^Ð!9"ÿU&LÁÈäújS_ƒÜZ¿|¿-jVdºHtì|AdHÚSË ÂÎŽû!ªöæ@7ÆèÖØ¥ ”jÛ©.Â"óD à±ú‹ãRáøa³7œÅöA–9¾¹¥>ý4ˆ}Î`‚•QŠeÓ0ÔÈæÌ>-vXb̲éÞ¯üa«•a)=ýK›P«$�à£9ÙÎ0€èL¨\ÿ„!GèíÎߎ¬t iž C¤Œ;Ž„aCÛ®QxƇÔ<üù‹þXJÄ‘f••1ئ„>@[;o‰åŒiÅÁJ„5o †žKç£(ôã€À#Ûªñ¤:Ò%yÀR‹3Ä †ÏKUI™æ7Zñ ÓÒìd$cH]*‡ät[y½Ó‚öXÌ(šƒ8[uó9lÀ›‚nôޒʗܯŒmŸl÷<üÒgnÚç­Ýsë!¨;öcè­]ÀÏÀlÛ‹;t:<6è(Ds'Qȶžþ¥¥ïÔaXèéÑ«E-ƾ¥½qÇͲþÓɪŒ]­³œå`P=öâ;Æײç#V!¤ õcœžá›º=íê•ÞrîÎPc @'úQã×NWM¹€>+‘Ë…µ>ã‚“ã»ß%s?©t)fBÎ:h`À€äÝâGsI…¶ù؆ä1’¿pÈ38dü"/SfÄ¥�FY›Jð½qž§7aFßw9?¶¦v][nö3¸ô–jg‹­”ÐQ†Ù¹EÕ¼<èE‘žÎ>L˜~Û[#J?ƒgŠxÇãÆÃöËÅuÊzOH ;w<p¬®|·-Ëð÷/¿)2ª¹Ñë‚Ô?˜â¶GZÜa,ÿf^BOÃ4ÒÐçŒ6Hf´³ƒƒtréÁ>f&˜Q×S<¾›á§œ¡@n>£x;*Ü•M‡„úåɤ¼üÏ®X«8»à‘Äè ‘yn¬X¹¡“7ofk¼9íÄ¥C´Ò �3ñJRÅ]|ÿë—Ú›:æ 13m!:À ÏÐRs£ªK¶}äsíìéð!üõ´ìÚtñÙÍmÇ`†º^MÛú‘*§ÓÌ‘¯‚Ë<ݱqòä¯ít˜ÔöoyÏdˆ§ª²§d1@–QT–ªÅ264 1‡ú†iÿ¤kš•žh2nz°;çA¹×žÅrnO“êô§/Ç™Á˜å¨êÍâ“š3ÖX±‘z\bZMWßà Ã#)~ãúê±ñ˜ÔÁdÂtT'@‹ÂÒi~A!LK[@aš™ŠANÖZ?“”Ûp̶A‰)V—CÛN7¶,còÀ¥Åc¦pŽ¢è¾©PÛùRÆHÄ�„Á2ås)ö]7JòªX/#M;Ce'\FuI‰ÙÅPˆt "”· äñ”ágÆàaß™[ôŸ·ÜÚ tµ6@šÓ·î— ³bè->åÓgÞ*`ËCàl³ TÂ`A Ò{Ý4Öô=×™UÏ-ÂvÚÓÂjë·ÍŠø/Üû•q@µŒDž^²ªéâNUúsÓú†×ôAÄcJŒ†7k×_‡öB1°¿\[ííŠó%/säïjÊÃjN'Zi^~aé©æõ•®²#1ˆ>ö´§ÇÒk‰˜@¦|Gãrµ¹:m{6*:bZlÎ ·­…¶®öâ°©þŠi_µç||çžÖ Ìû¦3%úG¸I«Ëå4Ù“C&7æ*”–Ò ¢C¡5WU«-Jm‰*Õ­×,æJZÊ‘îå~ÔævI»ÐC5ý5Äi3áÄ–4ïÌÏxEÑG;ƒ{0,\Á¥`â‘Ó‹þQv<ε%ž¶Â ‘¡Ä'ﺣ‹HаPbnubj~|ʉ|ç].0 ´ÿ²ù]ÄZßžgÑïÇOUœùŽ�áãR;qfúê m@˜™Å@Ãhƒü†(Lýîoį”Þ·£7ÐS±#ºIG²ÑÇÇÆ�î¯u{¾€|#;¸ÍX¨Y䔘äM=/£'¶Fqé|¶P.¤¨Ô² Y›[^„9ãe__éáþÀsß¿¡;¼L¯+Z‰T6…ÓП±J7ç…]Ì`‹oÝ^áÓ«ŸDµ2ÒÅ­X€Â¥¥Œÿä V ÄúO=,îÅ[˜¶$c¬?}ÌiO 'ië Bk÷ä=vE–;ü½ŒÝ.l;Ï8bÓmýÁêpØÍøüʵMÓ,tŸ›r÷}M÷ô]+⾫·~ËŠî<H/K’Å­BBÅù«H÷E?ÙÖÚ&€«:Ö'Á¨ð÷'ªV[Aâ‹È¶‹ŠÌJœ¾0ßúW ‚½uÞÀðÛ‰wš;Ò8íλ›¢ZfŠ iéÞï;Oý|œNóHûÑIãjôØÞ(NM'\ ‡ÐÞØGIPw ]\ ÍÌ€ÇeÏM8‹µË‚tx²F{ (ÝÐÛñú™ôvjÜóà%¾“|/pñEç ã;ñqU9]8[ûAî6²ciø vO’ ´âc ©Â,‘>ê¼݇m+Š¢Ž#ÍÌ#ÆïÂÌ“ñÃnÊè¥(µßzXó}7îYŸ‘Q/´˜¡$Iû !™ß›¦QZY]ÕÜOiP½[>3Ï6û#š¼¨Q§6mÁ: JÖ×Ò~mL±Sàz|žÑŽÑ?Z~Kæ=?óÂrîð,ePÚæ|$01­v@Î}  ÿóš‹nIú¹aÿ ÞkeÁ{=Õ5ŠØ€`Á£qη$‘Ó¡inÕ<íR—f,TO¦ Ím¯Š@î†&Ž›étåÓƼÞÁ»­�èÈ_fº¥ÙÞ0þPæ–0=¨á<’˜¥o?bŠLB„~zËÉC;Ï;Œ§¶éÇ×”~*O€ËÆ=N‘©shaV38Ûä·åùÃ:eŸ^­¹„kú$H¿öSN§€^rîÝÝÈe<SÍÈ´ý&ÚOǽ’«„3ÓºH²‚Àx6*/Ï ÄOµˆý¸Û•í· 9c0ôtðüÐòýGjfÓκ#l~;ʳXÿ ÁvgxµjxÎ;ÛäÍ\š÷<ìŽ.Ò…¤¼ðÛ¶tˆ /\Y§&!CõÍs˜ºv¨ûW^Ê[OÛªÌI¼ÛÃò/í.ÿ|Ø€ ª<©¸Õ˜@á}×7"º-§*¨êµ½Ö¾ì5Ú¡»ºc YÄŸø¤Uˆ‘­•`È£`KÅA ¯/ãåòhÕhªèóP ¯¬vlTˆJ§k_½èd’¤>ãSNKzC7°êŸ<î3 é©BÅcÏ„Ê í„si%Ô€•£Ü±¦…Èy P'k2'žb Ò« ÓT‹™õT÷˜€ SEòÏ‚êšãaª{ñ3ø‹q½³L.L#\dõß}£®-ïõ`G¹f  ÎÎ~ÐÓ/×òE0“ ¨=¶l{ÿå OG™×™Wü‰é.ÀÓr¶M“$d!jTi@WÝç—…t¬ÂÏ–aP=A4ͼ—rPhæ7®‚�ïæÕ¿kcùÈ:ž'ª€@ ŠÆÖæJUp«ò»ùòÑÿäIæ¯0²¤[ZÕV¥#:¦Û’á5l‚3GW¸ŠÒJO>½<¬+ĉÃÉ>îË¼Ô ë¹2³o+Èäù­pB2Plì&—<`Zi`è‚q§ô’2E8¼L™ö¤3p¤ÓM¹ÒŽÌ¬É±îæ®ÿPÍ=BUhA´?]l‡¨ƒÒî€-ã.鶔™§ßEç‡\Û÷° Í7sïW¿Š¿+÷OFbrU_Z¥è�¶[´[mϗÙvŸTöI©ô¥HÍ>`j—²/2¨s³¾3$‘úîZø*{R{Ipnϧé"ÿ9P="v,b«ærýÙeï™Ò™ySolÖ!À›}14l® JáFE¢E®®x&²?ÂHè='—\˜~?Ciúw¿Ç¢]EKMù/‘4Iú´ ÚƒDÇÑfð²ÿZœu“¹b¿ôlô’™ êÜAçe¾x£ö•® F^`ÀX ³È{T%EÖœ5’yˇ‡éE[z¶òâ押ºÉm§Úg¯0¶µ™éÖîøŽØ–ù<©$iCò4Ïëò¤™Ç%aÜã%…ñ¢•^YŸ=+ùÈ^8OSq´ä̵1 ò@GÀÍFSºihg$umÐú(Ûç3K‰‰’«tÓÆz”‰´WëÉ#x™jæ†ðõÿU©?벢˃°W”lšŠA*Jó7§za¨CSxù@‰‹eªÐÃ;@ä8vdN´ýaÞR¡ÕËÕi̪›í%£»‘TúQÆÃ6p¸+ •C¨Ðuº¹Î´âêõõaŽ˜æ7'ü\S$ŒúÑ #7Ýš…?¢& òÈ]PÜ¢s Z>úÖ?{Ã"©:B:ÍéƒçƒB}y–Šæ›I}P¬})Ò]~C£%~ÊIŸ½ïèVôšÿ#äÑës¯Ò2tKVO—ŒÅ:ߟ,ÛØø½öÃH»<jÛ‘†ŽØÀŸ¾øbº{ß½²$sj8¬Ã.ŽéXÓÔ’Á›YÀ:ÆÇX7‡~6Î_àŸä…??擼œîq¹¼ÔœM›™þfÑ^¼Q6Åî?«Fz6ç±›þ9ÖÓ½ßÿjÖ7?ªm…¬S±­>¡¨Qd~ÌG,}ô5ćÛsÑSUuÄʇ8ÔÜ:”높9IÈDqíôø‡µ…b™­wĈas6]<Ò÷8N¼Vû[÷뫲:/`Ýü„º²ò ±é9ìwôÙ›ÞäNWùÖÞ�…g÷®¾kw%¶ñõö>¦É´Öô¾ãiv"Í:á¦Ö€(­õ)ÀlFôà.ÖF2(úÝW’E§™|s†C×L5ÞزÚ#¯±Xr·?užÓ]­ Ǫ”†H´C”Ëì¹4`ŸX¡¦î›—m·-‹]Î¥lŸœ‚ß쉭pRÂð™Àp|ÖLŸ´Ê„=˜Ë€òíÞÅ}fÊLŠÂËU`^OÚ–~ÖÃ-z|åì}ohÆ(+‘'òŒ[ˆ=oÌãèóÊ7œawTjµžƒÊܹOÍ©/ñµ§óh>]ºá‘?ÊJu„¦Ú=HOI~Ó-¤k p~eì >ï]g5’yŸ„»—ˆYûa(¸E+Øa` •`ý¿ôßg"U7ƒõ×Ú�©§O‹"˜öEwWÚ¤]âf¯^ƒÞd>n2»2Za'K£Îbj‰ T“]LtÜNÖÐùu–,w^ÖoFŠ)ñVÂJ£„ù~ºú&^«¦¯‘C‹Q<êŠ ´´àÃé·tÃp½ƒ^xÆƉÒuVÁ48£Ü^£lÊâõÈ1”åjä6è�qÇ+8*ÔfQ\0ÂàÒÒGNGkÊ~òÚ‰RŽëÛ×ïcœ(\ˆæ,ÈÏ'›D” _½#w®Øºðìá´a;i(|›ÎÀ_M¢Œø\/×Á»2À5Èó~�.ÏÃyGX$Ä#Ë÷ƒáXRÂyÔò¸e >CùÛQžß«‹)g¤¹;_¿~À»Ä±EÙ—)öy3ë=2r@טYüïôþo´XaHw¤O_uj;T±×KwÏ(l{æïôìW.A´ìw=-Õrš< /ZŒTÌ]ëÉ(™ Z.ÝåÃÈýy—ß9|‰RŒíSÈ6 é^Ñ)PS‚#üÍð r%)ŸÆô9Ûš¥ˆô´«„zÛ22XÃÁÃF Î!ÀÒ¬ì>uKT{íSA©œ¹þš¸¦ ÓI�l¥Üw¯Íu|⺭4ä´c ˆT_ÏÀ­t3"½Éb‰Ó´ôþÑ~ïë@ÕÞtžÊîüq8‘y}(Àš¯Š ŒZú§¬áOÇúQ¦ÓN™åEuL¹”ýg¬A¦4÷ÒpúNágO¯?lö’ ¨ÄÔÂÝ1Š'çÅ8Ý`ì(¸T“þFyª·u¿S‰ñötMÓ›Q¨¹ùÏýÿýŸù­¿ƒAÇËœåFn±Š3¿G™*rÈ”éÚz?SAÕuRã ܳŽ}N]åýsM{f5j÷�ôhoŒª€YâJµÁÜ%VÔ€´¸†½¤ ¬ÖìOÒd¿}9gñ7pä‡Ps¯Y ?‰à2¡ÓÚ{S ®g<â'“Œtf?_®›=Û\}Ã)<F¨ÀªÑ&)fŠ¢Þ¡Úµw‡Ùï]X½S!÷^él/nö_4l¾l•„6’,(Ïž³ä'ì£g|´dwCý‰)."`ÂÜZ Q»w¯u»g=š× lŒ &$Ú/îJË´o¿P³7o>qlh|ÿ¡ÓÂð A” Ô‚‡jÄuSJJ=4›0ñ³õ¸PÛMOáÐÓ 4¦cl êûÊÈ=`¾ê©S¾<”ƒ.ª¬ìÀ¥kéÑ>m�ø§?Ò[—»¤ÖØÇé²Çò Û§a2ã­ì¤ºr±Â‚QNcpùÝa7HÁ—Ív–yêÜ ñ–ê¥S*=UðbÑéÀs9jO î7åJêU_|æS‚Îà§gAj›Æ-ê,*Ž —N0–ñö_#nȶµ‡ã¹¯­UàåÖMé±¼aå4¤d²ÐvYfª!UÉænŽ›[©±ˆ®¡¯eP"³Ôè~G'÷jVa˜‹0È›UïaB3%ð&×XB¹0wäv“•EC…2îsëwŽ‡SB½Ý‡£Æ0wõ{ã{ktÇæìASÐm²Û¹Š¥ç`—‘í§ÓQTÉ3Ù~jb:_=\…>;/ÁO¬él‡þ^pÏXºXEÐM)úÔ_: JÐÊ™OãAÎá;G1<¶øú/ªÝ,ÎœnVý¥ ÒVn 뜆©sÜÉçÇa’ûŸ€Úm„ªo­¾jËÛÕ–Ó"K…_³X,�XR:Pf’ Ýi»šW )!39Í‚¡þC»†‡ô)©”ìþ"qfâØ]väW§¢1(.⊉,d:ˆú1> éÜö›Ž–ÎC¥½¨\u{éÃwe-úIdÓ9Ýϲö±y­™©K»’¤t2ÎZ¦róëTP9Û¨ÜLÜ#•šÕz™…§Ò"SÁšÊÊðl1Ô)»(4¬©ƒcòhš¤"Òò£V‹d@r °/åó“üÚ:¯4æfà¿>Süo1å“ÆÁÒ‚å¬�5lÝYÛNЖMžBhoRØœ4¶•J°ã¬À.Ù�B“òØRÏ-VC”`ÐïèÞÄWÏ8z“î ¦¢#èýyXŒ-†»|4¡+Ãõœ?º>zoI›Ym&g‚³×:Ðlß°0ËJ¼oîéÄlïÛ×´ð–»öLFÈÖeŒeöY~ª°O3J­OéËÂ}E{Jýfdí“‘¶*(u¦±yaçUÖpoXØÃæ .b7Ôç·ÝEÜ\üŸü>ž€Ì²`ÁÀîݱ¿êy<Xm.ŠâT“Ìš@=7Daé¯ï°�_» ÂE÷ÆK ?âC+\ÁþCäãà½NŽJ]ÃQËGпÑ z5¬%~•J] ñ3 åøoúvá®[-0õJì}³æÝI(!Šo}ž­¯°‰‡ñ‘Z€Äì˳Y]*Oð èkVê…!}ôpß6 0N—Zºë¬zë4pïTÉ‘/ˆ-P7†O¶‰y=¦ð_ ˜¼Ù³JíkÀâ(ñ„ã3 bôh; Ë^ímy0(ýû²Çtd½¬E�Çzɵꪃ+A™ñÿ¿Òó("dzâÏ°ƒ*üÕSøÇÔz^V\ƒ×6ãØ“.còÞ1FÕ:8àþ—V½âWF%xªxû`´õ¶1… ê\£Ùë«“¦Uo»‰…™Ó¹½Ó_¬r¯«¢d¢ ´„†TšvËZmûe9Ì(÷pr¢»H%^þ9«îbQÁ Ô+ÈE6zÁ ñ¥HOýa¾—ëÆ+µfÜt¤]Þ=ûù< Ws:Ðúƒ:C/ÙqÇ¡ßãeÿ9Ú§ƒn+cø¬žäÁJžA›ZëZøþo„v<ö?ëZJÓ¿J¥ˆƒL¬lÒG¯NõÔ›F0@‹‹ \3IBσµ(ý)ás¶T´òOÄS8R˪ÇÄ•á{èøéx@È]Í}5¾œ´=ç®<qÍ°4�wö\JÞ÷žÂ,Eé=ž&Z§‡Ý/m—b_À“!§ÛkI»«5åp*:ó}ÇYãº.3wÊï¶×¾½ùÚîRaA!TsÄ»­ÇçìþÔNGP«ÿ† ¹ÈÐ_Ù‹;˜¿ÖK1jfª•Êëì ºù /ªåR‘mõoCÃýßz % QÁÑ“R5ÂHÖ*ø·‚‚IìH¹‘[,ƒ¢Ýi6Ðx³æìæob÷>ùÕÃÌ>²ö¹™äÌ'Ê“«æÓEBÂ6˜(8i£ÚtþIs¯ÿ›x†ìI~™)ŸlW“Wº¹Æé-¿þ‘´?|Õù}VÒÆV™ª‘b÷ßy§è`ŠÌµtj(®ÿ,eî¥ai  ¼é»L‘ú\ß?‹J‘Îü{Ätcô6'RššFÑrÉ‚jž=G.ÚуËÚ‚3dyäÌycŠ\}QkŒ‰¬’ÔHõ¨IT\ÛÖ¡ƒEˆî- ¤=ðÛ ¸¸4„ï¦ ±Ì.àïÕã0«¾+?¿m 0ÊN~·¸×Š#QRú­A¯èxKf-‘ÇÌ×þµãóIÓËœžQçï‘ðC¦7§AÒÎvÒ±&œƤö´ÙfÃí…5ðMo4íÚ}$ÝÙ;œ)r‹ ¬f�œôžÆÁƒßüÓwÿ¨z¯M +T£šSDÚÑpÂ#çSi%º½çfû½ò¹H]Æ@/–±Ê•kª¾#'(pç칂U”ƒ)‰ÀÉ6w®¶žÖ 68(M£b8F#Ó\šµk%å»H¤…Wâr lw¦>}êF£O~í.ÂS0~ÏÜúÚÚº?òáü]N'õÖ`ÌIúMËÅã"စÁf :—5S¾_}‹Âq¾ÒlÙO7${o½ùI-mu }bX(~xUz¦³x¶dšˆE#©b{›ÐÚd-ÑÓù÷_Lë¿ýÂ8ä<Hg¾ûW‰sŸSè½ì„>ÁbkúÓ7ÍT¸]x‹?ý´ÞÜ_—Ë3årï*‚¨¤]b~Sez½ðu…efï ,gÕI/W i OÙ8ö:¦ØÍ\ss¼œ¾Ø£ÄfzùZª{CË«Åb¤ê˜%¡~öl¢Ü×>ˆ!Ò“”A<ufz‰éõ¾;õoíu/'¾ÁBûcepjàŒr…ÚQû²RS8O ¯qØQN[IOÑÖ; *ü=Øvðæ]NU×sÛ÷Ú;£uÖr×ÐÍæfÀ7y¨je;Vbc~~9®KçOÚBŒéS7“Ä ò‹PNjÔX[³ÊÊÜàcAÄ2ˆiÿZ‡*doaâ븅)\©€p‰àWt`!L˜óÌÍõ/æ9´–t|3ÓWK-”¶P‘ ,ÔźWÿo€´­~º°u™éC´iï ˆ´{�±Û¹ïº©{ë³æ_Nµ¸Zºclåd$PdÞÃÙ¢ö Š¼9­U²«/ü—¨Òîx|´…d™Ü.ïzØÙšÚ×tŽ„Ó¿î$ñsC£IÄœSI[0 (w|å7N(?J+ÐyÐyɘÀif•þb»gmLSMÒ±HKYTÕÜÕ?¬öøO=~—¾Š“µa4RAÊCÐëÓuaTs¾Á«»þÈÆ,¯*´æQæ{î¥Áþ\Q¢>ØZ#âiÝU9ä4ð¯ÑX?ýGÆÙù©ÀV1=àËÑXšÃ4èÄzª™4e/ÓT߈ž&‰c×25F0ɧ‹FÀ_ãaÃM¯ç.0?›Â8o¥Êú;St¨º«>îÀ¯¤êq;Á`0RŠI g yæìU% ƒ^]•ê *”´®Æ9àyk/´©Íéx4ÎþÆuK~™%Ä©ÓŽØ(‘>B;µx+Ò7X­—½›Bž»Ã¥*ýa¡s<ÿIø½ðIÙGjs¬‚òsðÔ'»žsíø˜ìÐ$�Hˆí2¬„_´†("‡ ÊÝA{é•»\1ðˆÂïƒ]N„ØñÚ¸ HªbkÌ8œÊωQ ò$äë?w°Žþ'V!à ãœyŒ`žšrÛKªdéé+˜©ÛQ%ÞÂ:NÇTû¡Ã·Ê-ïþK7[Ù;•ACÿ_Ù­"‚Š}ç…ÎÁX•gVÉJ¯-|¼¬—³vOË|@úžM÷E_PŒP¾_߃åGÎ|˜KÎ!by!3FçAçu%Ñ yBàX å[ó¸€K ߸œB(.NÍûÐÌh  y$>òS}:φ^«·*ˆv­e4лuÐïÖ]EX•ÍÔÏÙôÍ~¿~»)æ2íŠEÜå)nä}c`?3iJiÁìœcÆ.Š”þñ—AμiIlÓûÚäÊ ‘~¨ÙÅï­Ò#O`ÍÝLˆ É®uí$@l7ý§±-Ï<§6¨ÒRL{·v[ØË ÔP€š¾cÔË‘Di•y€`ÞTt¦uvíÇ‚ã;´ Uè¦VI/m®Ì©· †ÎY‘.}ßy2=§Sï©??–£Ë=Ü@"\Êr;K Äg5ýÏqñ[Kå‰÷eäTj{tØÑI’[­mƒs—2f:·z7^õÜs˜Â¤1bž…I3F,î;0Îx‘KuñT¼3É|¥Â(XcÑé[R1@,JüÚ²¾h 4`»{ðÆgFYúz¤”ýï)ŒµçÕeV€ Í"ŠõήAhô­‰#�¡©šì,×+NmóÁ`svGv?PõÔ5EùÙOÆ`í¹¶×4Èj‡Š.´¦•ýÆn'ƳBÊŒ»wå ë#¡ÙQ¾¸P€I[.J<‰>+ašv¥ÅÅãdö‰6ZNÖk¯0"-Þŧ]ù,O·ÈèÒ4Öéñ¸ùR·\½-:ëð€†+Ìa™º\”}7Ùª§UâšQ3ó ŸqÀç¬ú§üOO†þjBh»l·ìL(±'ŒuÎ èpº_©’ é¼:&AüneÚDòÌÔfPB'eº]ïKÊ|wºO«Uò±‡eÕZù&°%óÊÅ z=ÿU´0Þ;€1÷Þ1ÞâÖOzvLa`-@_+‹ß�šâªpÍD%æ=—­¶€âÙÑ97žnÅÜç(/WŽÈÇ!ý®“‚Z~ DŸü2ÛÔÿÑ«?¡Ñ‰Ù\ôp§­Ê  Gþ@»@óã£:Š0må¹f½½¥×j+R˳¶Çžð¡X“rçkt;ûúr/ê{©8êeÃqÿéŽÁæ¼ôì®*×_©î%U²2Šˆ€Û˃È*{»-õ&’-ãz3lŸè]¡ú¬¨*4R(neG s¼ûôˆ ;_7T¿“ÈÑypýUÊŸ„¾³!$:tK‹NŒŠ¿S¿¬íÃèäZfñî– áâAr^x £ãö_ô¬§7Ufš’IÒ¨Æ8l©è­dvünØ‘îüŠØÅw ùËB¨Œó˜à&ƒ ìŒVXŠkuY{9…ï8àèаÅû¤,‰¢ép˜ÁøÛ#ØÎ. úÖC´ â½âp DÉȬš› Ø•ñ°Ä:°°Aw¹V¾.ý± ¤‡fJãâVóÏ”=Q 5Å<ÎM= |×äÕH/Þ¶¢J:µÓ(znþнgùÉHÒ¸þÐ[aÊÍ ·ëDÖÌ[}[šõDÉebãá|Ù¥G>ÀHÀ}|õ‘*ôz2 ‹¬ä^#b úþ²kÿŽÀ™ÆåÊ¡Œº¹‰E<2’]š¬¦z¦ªL ¿#îåÐw;””Léqž‹¾!ä$·{Uÿ +S«ÀæR›=UÍÖ<W^”‡PC‘™òTËz3vf+_H—B[ÛÓc°ÜHöì‰òKta½4Ž(d=b{&;ôaÇ«ƒkE¥3†þ/ZêXú̘Ñö/ƒê¢áŒq:@–P»¬”ÁÅ·w¹&%D>ý–mÒz XçÚŽÛcÏ¥‹­%¦ctOñÀá)Ê ƒ^D Q8À È:U%šVr¼-Í Šˆ12ãn.øÞìE½ÿö7¹e>ˆ8Œ€©†ƒüÅöüÑÍ~Ûd¿š½L¹‹ážæë4]©×![Ædï½µ væ5õ '‰Ý`´~ù‰ÒŸï¿Áïzä‘ë®qéÚ<l1×´ðƒ²(€ç8°)½à–Pû½lZHÊá p—€Z9j5¢d‡†]{Ð6’Ô’;ZV€2RŒÏ< ÓUÞOwk©)< :´®*åó3¼>3mêæÕøÉøã¡üV±ð2'AZéVÁ­îžã î’ t¯¡¬Ó²£Yo¹wÖ]yòlÃ5WÖQÃú~÷‡#=§$](M‡½À€ÐMßÍ–ÿx’]ñ³Ætš­ìâ ŸuÊ"v 2¾´æ±Ì‚¹¯ywþ¨˜.œ.ÐöœÙ?ø¾£ÕÚ6+áZ5õ%¬KÌŸóDogèyÒD–á@·?‹ÊÞSו8Ru@Œ]A±vgNdì§dÄ¥lWN<»¿ïÆEèƨ:¸äA8*ã¹i±MôÙ½A?AèßÆ¥†¥,•&dçþ>§#wæ?RãFZólÕ2§…)V9þaœyš¦¯ ØôE<ÿø§/‰I$­%þTGÚÿ½ I^8ƒŠ ÷‹õ}³Z“JÀ9ƒ¶}Û”«îàr¤2’¯ˆûzþµÒÔiáÑ̽%±L_³­¡sçBÛ0>¥”ÙÃtzA>}yJþÃáØœg«­ÿqýòëŸî¨×'áÊ-½bÊs>^ÔŸ¨Ý(›‚²Ñ­ÁÙÚsä{Ù¡Ÿ²Ësùn© V®±þÎ>nñ‚ÍséÉR±¨ÿe º­Ž©‡Äÿ¼EJñ¢„ìÌÙe÷¼Ó!ÀjMÖYþ‘1"¥÷”�I?&g= [oY UþÂlÿtæå1yP`õ <긟2˜H‚§æ¸`|¶—S­ìNc_SAöaZ̲ô®Ý7ûNJBߘ1,‚v‰ÙÝ8$#mlÖÛUŸ8i×RrÙú ÃÖn«Êö4­\·®IEî7t²F˜u“ù£–g){¹=ʸL'>u^«®=žqfÒŸ2—ÜÅöŒm­¨ «¨ð4=ÏhµyÖæhbrÂ$ Šý:—làÀšg#g}h;lƆªBƒ™þðÖÆ90¸Øºö(:�ÀßwK}º×•DcWÄ´a¤œ-jâŽÂ‘Ö÷fåRRËì0î¥}t—nY¸×p ÇOÂÝ—7_ÿ„‚‰®¦oXrã3mu& ï@¡•‚§ÕÁ@Y–Më0LO”µ£H|ÅxȼÑb–ý‰;cL#pðG™ù­Aß ‘aäK—aŠºf‡Œ¡eÆx³ògýEp†·ª—øô´¿„õkq0I¦!ÊAc6Úl]Sf€)0§¾—ïàTžê=d¥+ôX¶¾éi ³‹˜Á�mÉ ?yDDÿ¯­c4Pi£ûæ­/}_̨ÅsÑ·^|Á†î=kaÁ¡­äÉŠ¦?wL¥—ç»?lá²0陸yï¥Däo²(ç”,²}å"ƒ×ZŒmÙóÉv¸~–õÀW¡ïÚƒdcõúªÚZ•¨G°8²«æùtô©qxbÁܼz|ÙPldrˆ`PÄ’Ø"ÉV2 v9Ì÷r¸§"rÉÚk" 6ð¿ë,Ä´`çé$?�Ñá®îè´W¡Ï‰¤ªgìh½äã¿Ž, WsÀÃ7Ó_›èe¡¢Ø~‹Üð¬æ…þImcrdR÷Hiŵp¬ù.s»EÒËeú«´ž’¥øúf²{X])S'CÒt|ðù“F5ß3B¾Ë.­r7 ‰äm¯t/פ'`³um ÿ8 ôàÙN`D¤#mx€*Úw˜Ñ™³ŸN(cß.ÖæXeâŠ"dhKnµÃ£Þ¸”ƒ­¾{oÝÄ_Ÿ’fª¡¢'G8¢wÚ¬l ¯ÝfZ!d˜Ýb-è¿!R:6Æ- "~ßíYÚNDd4'/`¼ [%g)q<p:dì‘[)Ýù+®jŸl;£p%Q‚Yi}õvæØ¡5d)mÈ w¾v‰JT�6ŽÍ1¼Á·ßª:1 ns€j`Ž¦V±ë›X×íÏþ€02]­aªØªå1D¡ÐÚu ¾gÓÙSû+˜çY™¢pZZú'þ|÷‰%xW>Šyn·\(?7C„Ž±<b%Ä¿¿÷«oàëb%›OÛnþˆ0|V}A<ì† œ™õ8tHÖžéƨféã¥Dy{²²«¯¯‚ÜN’0~ëÔ ÒŠwÞF¦g?Fw™So ¯£ƒ>¦btà""Ïo®„¾=:z&ì˜nú·ã£JW]:>ºMôÇŸ—{dë.¤;jj-|gž½E“½BkŒØñÐë¶MýÏ®£Þ¾£ˆ--¨W+u_—k. Î ½óði‚dÂj~u{}ãí6YF‰th³wu_Ú3 o¬£6U‹¶=ëfÿf ÂÙº;Ѫœ!âgfçIü,¹¬ÙPÉî› ª‘±*äét4. Ú†¦ÅÅ6sÝÀvÖÎÅ&õÝÍÉo :ÞŒ•¥Å¥p6f Cv-ÄM^æmT¥‹é ™Ý,”FUƒeñ¤G¹æñ¥×²Òªaj”ƒDIœG  Òã‘g·ø4ìŸÀ‰¨I…¹š†Añ¾w‚vÛú0!¨rH]ÌÜÙk@=’Wå Ýîù˜Si°² ?éTÛ²b-À»|dΓ‡N ž½¹æ¨/ãÆhèÖ¦£ì` æ;W¾\{‰X~ú‚b¤5©¥Äbìz×*à–�j¨Õ¥Ð3ÐÖ;š ©çxÌ-´:áç/“_³f:Ú¦ÕMuë waßm%.O¬mâ¦w¥žŒWŒñ/íš÷É›—k “+ú쯂é¼côªÕúüÞÎ=¡¤sFÕ—|* £ÌýØeoh•²ÌÐ} ¾È:W±|b"U5žq�AJŸÅTF\Ãw ¡®Cw÷w·£¾8NbÏÇ! Ú+…ýÆz¬Jˆí”Ñ8 uîÜÎJ£éÄ ò÷Iy :á»+0JZäÜûû¹/Ä÷¿¯+O &¶\öq‘`Œ´ñ‘&¡‘öHÛ¾ ²ý¿Úå}†-eX2PåÓ:Vo·ÀŸÝä¯Ç4 }!rŠ`›šÂ!ÔÍh„?*z )9 !4†XÕ¬¹2ËlêÐJ÷áã*ó B€g(|Z! Œíλó¼œgc©ô —4³É kòÛ–A9Xlß]í@V;­sQÛ¥#ÍkœüdO£Cò°2È´¾Bd%ÐaÝ<ÕGî™)§¶ý ÷͆'6SNyÃ)»P¦+<ƒÿ…%]8?i : ¶vÃtä4õÌpw9Ê€mïi –èz¯(° òØšÌ5êx×™• µÝSÿv}ƒH ºõ !úgfiâ;ìÐé"xÙ³¥]ÑÉØ¢š6!é¿�Ë&Uæ©�ÅÆá€r–Þró­0è¿S5ø¥AXb5�VrÈÑþêuNg°+ÐÁéÿ•²q¯(Åæ¼8[|mÕkyÄB;jÀd{ju ÚÛ<f©mÇr²45ìyºA݇[<Ï4 Uw7¬ ù2.‰jÅ,`{ub©¯I¹ä6ÉÞÔ¼äAöuñÁ¦õÇi©Ujá7…Ñͬ[9 3Ìåº 3SŸ@ÄÁ›k$ó=>=Gp:ú)… x2¥‹w…aŽ²Â1mxŸmö)�œ:.BL'kmNAÛr˾3ô¢<ó…²Ñ÷ø@<ò1U¦HZ'‹úEÿ‹Eº9ÛÿÍör4§ÔPxè Pà5‹®)»¨‹¿ËSv¡éÓ©Nz$¼£V=¬’´פ®ª3ð²èU¬Zcµ ýyiiálm›®=•†ÿÒ››TˆÂ,F "ºØ-ÜÝ™¤.Y�¢»t´òÞeÀó®J¬oüEÞŒ‚üß(þ¤áÊQâøyM¤‚Ùu§É‰„ýº¦2ßìz*ƒjÛxìbZT”JD3,'†AYŽê€®·ÿ~Ï`²ÌskåZúc‰PL+8,2«G ŸXà¿Üsô‹ò•tS¸r^=Ô#bŒ�ÌnÝÔPùï8RÚ& 0bÒp·ÕçQ{XMªi‹ iÏž³ ˜Ü§ý‹îw®Ø6˜©Ó�ZÜtGé7nœˆæ³éǾ†Ñ~¢ME²5HÃI™Ä‹†ó…å€ÙTÿ¿æíæaè7°ÂL‡ˆ_FØÌèÖ1fŽÑÐÿÁùû¿2WŒ<ÊÄ›²,RlSÌ”:[Œ¼µ{öHɹcqFŽë¤AdÉq"2BqmäÜ:}z{±6éµrß"qJë¾îa}Ýio�'#Á¾©{ë–ÿñ³pVßÌqÛ…‘m• ‚§Ø?èLèÒ£–oœõhør3x­JŠX÷ûrFªÑÆÓ÷·Õçý/åÀrµ dî+%(Ô$A94®U f¾3›4‚‘T÷Â/z¦Âű?I‹€ƒ¯è0œ¤–>2Q¥±0làfC¼lKåEš9:#í€v_Ũ#^V.Y'é[wGH\ ‡[B²ï…P äµîÚbƒÜÓ_,jéÿcíÏ’[G–,Pô5 ýÝ{ÍN–¡o>l$¤�0)n{óÇóå`¯}ªRfRááÍjJžEÔ=üµ}ÌûêÅHË fó:ªš<+¢û¡÷C«X]¦ÿ|TI­®¨ƒ›@øn{á–CTª{n”7'Ì“¬$&üvìgF‰¤dÖLˆ Ú{¾gÄS–¡Ÿ˜Á=kSÙ¨¹<ݼõ&µŽ›%gùž³*Uà/?[GP)D9Tyu1°ÇŸ“íû@}–‡FÅ]¦SI°ƒöqÞ* ) ˜^÷Í|ÏM¾ÓZŽ,`\ôÐå}Cÿ:=%tAì>J²+ÔܶMƒÂ’hY†ž½hÝ’0Gò»ªë‘§~ƒ® b´Â;MûߊÍ*¤m°õ2°eâø,æxÑ<d¥,h5GF­±™|z¢bõ° 0;7*9ÜéÂméÆ~Å•L<b9‹§}Äð_76ts"<7UOB-ÜSóœgÊ ¢“¶µÑqîëó §n«;6£ú?&˜ßH¡?FJð†ù>”ZUR6Ǫgæ„TLZý:YOÕ,ÌŒÀ(Ò*J±áe>Ž1NT-Ž6˜°±íT›v+íƒúE2òƶ€Á᧢•¤ãC°/„9íf£;±ãD·ÞëWãšçÉ(]I\¹I@d´‚Û™ÒÅYcɸ=´FÔÂü=òÙwG–®Á£GÁÇËÒ‘0Vãl€¸(ÕYýÇsø`{õÚR0÷¬z!Aë^¨}be>Ýûê‹b 扫²Â„éàÑï›GûÊnÇ®þºª…}[>¹ûŽr÷þä ×nè¾jcpµeµ@ûºïà£/ ÇV„+S4[Ï—ì“ËÏÿfàxÓ¥Z…LIAÅŸæìQU‰­)Sš/hµý]½g•¤¢Â°%1߀(n¬œ €«\#Yê-J ßq$¾ˆ}%¤jXõêvÓNít¼B$Óýx¦P¸œÃŒ*ÄàžˆW¢%ž*¼ôoæo˜®[,8\ö‚{Ç[ëZäÖMCö=+ «§#ï+µ$ÕN/áõMóîÒ½ßÿám{¡*’BÜ) [t€ˆ" -ËBPwDGèq{(K}¹%I¾èA×½¿=šiçûi¯ \rÒx½¹³ü 6³ÚæAÞŸ¼öý'óY1¼M½¡»:Û×G|5{ÔÛÔ0@ˆJkk¾�M¤ä?ûå”õ>)ò@¯m& áÉV;î21dj£æ5ø’´TÛ¶íë]'ƒ<»ê¸¶=åNõ§çî½:ŒT#y’µ�äëñvÿ’ÞW3%ø¸Hk¦<(ÆÞ³ð6€IKzæÖ0×åïKEfžÒ1sðvÀß$Ÿ<Ö¡þ’ÀÐÐþN²—æ®­&TÍíHë¤V¼ðxhv晚¾ Á;ìø<šPãujÛ-�·Ý¢ô »âÞ`GéRòi}rQˆoÅcÍ¢VÑë¹FïÜ€y\O¹Ë«Òµ¢èb×.`·P,k–ã³ý§·†QŽë•šTãŠrd-B*ÑÉ2òiå´Mn[h±ÏbJϾ£‚/ÿÔ5T¦ Ñ´üZ9F»ƒ¾ñÖǨ”q5kýoò…rg¿pœCÆÐfiÌ»GtOõg·ØpX;,è-,4)½‘Š—R’éx2m£ö4¬ÐÁo0©c?Õ¿ë©œÿ¨â‘åMŒâ¡0•¤°I 1¤XQwµµ]ÓFÀiúR,AßÕ|WåY=¢æ©Û1|¯©(²k##-µFòûJ¯Õ¢£b1 '¨öúñ‡¶=,Wl_ò(¤²w18v9D&ÕlZL¹ŽúÉ 0!Ø-ÝxÈ!§¯OšÍ1'±*èBÁp‹ þîý¸ë1Ñ© ¬$§¯Ì%÷Eq™™¾©ˆÑÄTèÂjPÍzt„Q¤˜»lžíß^ܯ«½T˜-«Y5çè™! a÷dÞÆÓ¦¹,¾^ Š%y•y¤DL­»„Õ¡ëÆh $‘énØňsÙDI w‹¤-éÞô£÷'ìyX¡Z=ôÌ(××gB"qTdžVœh&ãÚ3¸BÏ×_äÑT‘HÎ7Öei7µžQày‡rGO†s׿úˆ>Ù„²TáõžVáqðÊÛÕáÔOæ9`âÇYµi¡‰&õ‰žë½!n¾0Ôa– %Áçoew$æΘE£¨Å kš³™ ?±£‚®õ¶�×ÌÚèŸGo&ʼn­ê‹ŒÐ×®ÖÈm»Š¥gbÌ@"ÈhNœØ®Î¼¥ÜýÈ@[s£/äa½e^OšUèŠÍɵôtA|t“æY¸è´è´.Þs´ù›> âíÆ”Mšÿ´¥í€ ë@% _ó^�$,=kÊÌ|¶äçì¿;ãÐÛD¬QÑE;y¥CùÞÉìŽË$ÔÃø>Û*„枯æΦœÝ†/KVT9ÝĞܨÁÖšÑs®í†®v`ì} ~À�,®_ œØ’ˆ¡> ݸËïÓò“q•-µ¦Œn«fc`™‚ù ò‘õÍ25ôÝ«›jº`Ž’z,Pét^GPöZ{ÓM¸q{ÏâNÚî,É^<qŸT©ù°4,´ù;aYûÈJéy§U‹T8³ Áúª b¦•júä³ÞZ¯ëŽ*øÑÄ t¥DCK/,<éá0²v C±ÉX­³ ý>z²ëÜgn?.˜ù®h…=Qñ¢Ä´½˜á—@“îo§ÍÎc·©§“%ÓæéSˆ®ˆæTˆ¥ðG<îâèJËuOÿ¯åSÌ»ÛCUCÈA\&Þ'Û)#Û W5Mp&t}`®Ïœâôq7cK€'׋¶œ¹°mÍØó6/ÅX-£<Ð%úÈ8EæÙ�áL>FOŒÕ,å74åäTAÕ[”VhöŸzŠD0`œ‡›; ˼ȭk�E Å4—À­°ú#;y0­÷ö¢S”N;Tö dÙúQ”÷׶¾t“Ú3R¹ŒÒDý€À*Dûóÿ–®*áÂØú-öÚÆŸ|ÐZÛZô FÒ§[Ì" ä…ooɘãë³d£ÿxgrBªcè\4þ Ü.¦³, Úîž<üƺM…ÑcŒWÎ NSÈECkÄ‹—¦¿È ±]⼇À~<CÿøÇ‘ZhO´cýÕýš¥Xªo¦:Â=½iÝ;÷Þøi 7KÇ(ùU슒ÒþñŒ`™ß‡@š¡ë2H‚„ÆÔô÷€ä¿2£¥i2ZPŠvé™ p~r–Ö«•º {—ÛËÐ2(m‰¦‹“Ìk1B'¬Ï’ ˜â× Ì©ö‚W]RYHѹïñ³`C™y׶öÕãTê!Ñç”mÕü ™}û±ƒöŽVŸ‰žé–ôï«*̼ú™Vh3¤P]¶=›”Áñý =x³Di 3œëŸæÂ4–šrÛ+‚¢UrÍÕC»¥d®²,¾X[4.SäeÓÂ/´uŸ—¸•G H¸ƒ?ÓgîO&=L]\€ûïð‹åÂ`3X&íºþ§+BOñOíù£ò*îLÜS6NL^£yå5)�¶¶0‘ô#'k9¾êZ;†Ð¨F·Ý£dn<Å’}7.°¹û+Öð£µC©C(=Ñ**=!¶2÷³ÒFGe´ÖƒsêwÆ|ÙΟ4±,·Ù/LCE[vPÉ7zÆÛC7ì~Áx¤<YäüBoƒDÚçpÄEq¥ ¹’ä{ôÖÍáô‡‚€È¡€±ÜÖ³´È^Ê’”®ï‚ì¦Î#Õµž-™Ñ楒‰£1¡|zå˜m‡Aáé@ Vȸ%ºRÀÍ»•Ù¬¿×êY Ø£“ª¤ðS!_»}Ów¾öf àî¾.×&oÏ(†<j5J"=Ü”‚ÿFy)ØPpuÅŒÍü)ÇÃêKß÷ý¯ŽdÛˆ2ó”6}ä–¹{ž)¸³ Î[µ…ÚÌ>t›£l!øZ€žR†{tD‰¦vLV89œöºÞI‹]š°Q´Ë®„ÉÊŠ¥øäÇ3šA•¥#OYÚêÓ[SܘÞñ7ý(ND·7¯­(g!¢œô‰Ï¶S܉°ÈcåÞ2/}1×Þr1Uõ<ï«Íi°¹g†° ™§v[’;`ŽN„ª úÜx¶]6™»“ íeH}›aå , ݃óHKT3hS>íá²hû`ïlßØ«»¹˜o°ôÚµ),£Öèô&¢õ+èQÿ·º@Þ规©“FËhë,HNGÃãcåÒzÔiƒ Khª‡/–+ÒöüƒKãç÷<wGzÆù·õMÊÙ®½V£‘¶k„e‡´UXJGç`næ]Aàä¼QËöÛµ±9šÖgVEspš„2õ|“Fy§™OdéA?,×½1¨!uôqÁm„¨ÿTÐ5Óˆ”ý…¨Ä¦õhõ£óZQÝÖÞ‹7„bÓÔüÌØðRìÊ{ƒšú»ó$Ž+‹¨aE&Ð$à ý>¹‰³=8ð¾äÎÊ¿»?È<î2%“°\ ¨©¬Mh™Ÿ¬€0÷ ð)øÆÒ‡ßYL—);!ñ>‰­çuý™;).J5-ÔØf¥­`ö·kD³ÔpM-5ýëÑI^ØÕ,ڔ²NçEÅý#Û/UÔ3&ä”Kƒ´²­tšFb»pwÇŠw=KáS½ê>€¾ØÒ”·”’Læëº(ROYÖNÿbÖ×ý19xUD‘ÀbÆ$^ÝIûN³àaueP}®=Aˆ3ªzÁH_Øí{¸ËkHQ&W²³û®b ü‡ô¼zŽ›[ðÞGie;YQ$N8 x@[Rp±s`5?Â]Ðl+¤3 %WßÑazˆxn”M­¾¤ë=ðÅÄBÂQ1žo`#íº®Œé(-=zxS}UÓ8õ ÍìëråÅ¥'â ‚CdÖ^<eSfŽF{ëõ °ø�À«™Ic¶u& %ëyÓ/HúÜË=/}ßuª¤)Í)ƒäçSÓœ¥Ö^Ó#³‘ñ ÷_V�'š™¾Ä–Û ­B«¾Å‚Œ‡þœý]]ù(òP»�(@¾‹– &13÷™šî—’]Q$Àr0âPXW¬™b… ƺHÚ¼íö¦á¡ˆn=Ö«ù™¡‰Ç;-¼ª L�ÿ |.ì1kúè&z&°ºÆ5„q^ÝÇPÿ¹û£ý‹8ϳÒ"ž)C:Ã08´e6r::ç· Þ1UöBòç껫Qd{}sLRƒ‰qBº'�´6æጘ.Ñþ¿µ~w/ݲt7�FÖ[X0F;Ñ�ø d‚ùgÀz›÷Ê3ª„çëqÍ*U§£R$ sîŠùR¢*÷jøŠ9 S”Ÿv«qŽH1â‹+bïñBRLDU2¹ùèÝí£ï¡u’yjÖ TÁÓˆ§:ξÔè|þRßýK)ð(O|µ î²À³T›,ÀõPöÅ¢cŽv¥ÖùD·3ò(Z¬¡É0é÷ÚwÆëLôÑÚ+˜8-\B™‚y²‚CW9ž<ÁÜÔâ鱆ú7ƒ`ƒ~‡§J3¿ÏÀ% ªf¶'O–2moã¹»³I §í¨Ãµãá|™ÌWJˆ#¯‰À~ÄÓæE½j*Pv~htŠõ0ÔŠÚ¤çÆÚ2d¦£8´°J§¶Û4(f÷Ã5Èò­´b2.„ð;ò]¾ó£gÊûªÇ(\H”mm’í`ʶ¶T@ý)ìÌŒ‘Q§Áý„›7vôyîS6á8v.ƒb«"E=`^-Jršdps§¢ÕÞ7~—–o}ObG²e Ԗʪ¨ž=cbä Íá\Êh´ô¼ïèñ4¢6{GY#Ë<oeª«ÚKdG=cË7§Ù(àÌ” êÚõ®i›žjÎê ­±ÓଫŽíUÀ’›{YÞ-ú0[óÎ í)¾7)ñ§0R)L{$W*ZŠ™w·á¯Bø‚tR$= òŠ ùÓ’nÖ&“G0ÜÓ!ÊDHsžØ»miÉO#þBžP}î£Bá7¾†Ü-÷=‡{⛳Zv²ª@äECàq¬¡Ô¶cõ€5Ð ¸¡ŽÆ…ŒdX M¢´%ú^,'º:5À¾âH^/-g?æ© ÊAU é>”“7ŸA ËÀ*$ð3¸§µ{¤Ô#ž±P8hýx{P'AU*ûIYÚ¾3пѢ_Nw¨åxzì B/IîÈÒo£5½0×P²Á‰þB‚²ð˜c±<h q¢ 0˼B¢Ë8ëK‡Qˆ¾qF}ÎÞOKß›²ªÚ>§"Kå.¶‡~/4$O®Ø˜uB’¥kpÝÎ÷&Ë¥GÌÈÑ¡Ý¥pìP¬•ž"cr%pg…Ÿ¯_Í”×v (ÈL%³6NaŽrdá& <¡ur´yè Ù‡2ãÊ&Û7…ÈBý¨an£üwÓ-§„–™ÌòÜÆ@'[­xÁ"Œb±fÜhë^ô屪ƒÝkF ®¶ˆ3óÆ?°.Ï;;:ÛBŒ™ñPîêöx±š\2ÏfÏšõh­Òëú ̳ßÕc«öÏO°0©‡ñ†L‚jRèfg¾·Ê«®ÿ ¯GY“m½:Œ§ý"ùB”ƒöÊydÿ®Þä.î¤u‹\kggë‡õZ’: ¸Rä_h)ýË•ÎU3Ïì’PÀr5¡xó©y ar5hž[§ÎÀ2¦€ý¼ýdzŒ kè~¤"‹2ÉRÔ ÝÞwÅ.í+3TKYmå² –n«WY÷·‡Ò“ãI•t, CF£ÖsÞØ] ‰e E½ØGú7°X1,õÁ˜;m„Ý×µDÒÈU~CæÂÂdÌ̦0šL]§Zq!ýE;Z÷^È_ÕírWÍ©w噲dÑ–§ w£â’ÔØÃgíâ½kôe+ô̈èöÌ•[`µg2Ng¥xU¨[-ùkLóŸÑLïãÆͶÌ}ÝyduFÉ–fõÀ ç==|“Ö²^×5²ú‡è+ÿ,Hr¢£ëÓ‚[@G`#I￳EwWóüÄ^Àªõ*o»íàÒ×hU›æ¬ü]·ÓI ? ªQX€‡3![,Üû[½\th3* iwGÖ8NΟK§4XºÏtw¨¼½XªÃ—¥o%I맑 :¶NüÑù?m”¾œÇî‡MÊ1âRwÏY»{€Ä@¯˜Ë4Á.®{ª]mžu_žîî¥gAçÅEèäÒÒÌVTÍ¢Ù¹ÀJcÙ¸"^]zH™Ä;è¹”ØÖ´d†Éó[•SZ‘RÓòQÈÏÒ]m¥+~W§6Í|8L¼N1WÍ2Vˆ„êªXuÏ<±y÷5üŸªrfn4\ ¶2wÀæN�ÍMÆ`—©êpé»Ã€™†m ÝùÙ¡—Èò*ãAÑÔèIvµ›rMux»YdÚ<Φ†| ë™y]ò ù`7”AUo,ôu\íþ­{“8dÎ{G›9Ëq½üŽÚyâ7ÇP¾°0�A«§¿ îuŠ…>Æ™S×_@r(¦*âþ�綥t<¦Ž}s+=¯é½Û­s4Ü×3;¥š¬•ÉÕÜ ´–ö•Súâ›&†Ë:±\p;xDîÔíŽG:­ë“ »w]ï‰ ‰¦Š˜m«¿«Oý®;éÒ|£€H3¼ðÛÚôÏt<ìkë-Úè™jãî=Õ·&29ìBå¡ÄÂ\‰­aYÌ_—ŸaOPù³a#Í‹~msʆXd­÷†PH‘†Ff\ØòØfÃ[PÏÌ—R@¶UÝ3CÁ n_9éQêý G­ê\4UÁ‰›Xðå8Ñ`ƒÙ¯£â—êÃ;7Ém/ölO“Âc7wÓÄÓ(ñ0¯Oϵ%÷üÕ?òí{CZš¿©8œµµÔÔ$°3 Ðú0 Z€G(ϘêGfÔy¯ ¶@V®7³Å;”g3kg sA\èÌJ¾ÓõÿvmÇ»ºoq\F�¢6»l†Ë”=•þÝ41ڲ腮×eøLRpX)M¼Pô”àvß•‘-9Âs.¡Ï´³ïÑÜn°êÖ9zÑ¿o¦OTaòðk¸s… Ýý€J?¨J1Ã4gãH&vóÎ \´W "*àÎ÷†]í7Qä6=fkßø³>/PDŒñrz2ªÖwx€ÅˆŒÃ}ÖníU§të©uðlðVPCœ_E MÊ<w{ )=þ›ŒÞ´ŒÇðõθÌÞ»R±›8÷]éXX3¥÷Ûn½߶Óu]®Òaë>,œ‡D”#“z6é…’3´Ÿ<ËW:Ê!²a’ûÝ´ÅÐtú…€). >#šp½ùU·ñ,ÑåØ«P­»¼™ TQZFÎU sE:^¢úÛßUÌms”8‰Â(1ù I”ÈáBá Áp–ÂÞ 86ƒçhLÛLºø÷d”œ¡©øèkÝ¢¼öÏ®?Ø1ûéÇdlöâYj›y4jæø ¬ö½ÂŽ#¸Îö¼ vÚsÕñ¸½Xmw Û<—†zÒ1œº›d®9Tðhï‚Øpà¿¡,n[_þ^–: _˜»Å,}μõLvjŽssD·su»UnŠsßUì=XN4?¶©C•äBùTVÑvÇÔ•‹k½ånÈùxhMê–NE:8§_Ía2‹ÕŒMÎQ÷ Õ~[Ï·@œU=‘ƒô®®óó8ͼ0‹C} w=é»R·••téI…> µ‚Ë‘�h<ê“ÌãÀÊ,JnÂòžLþÓƒq~û“çVJ±Bñ$‚£—í¦è²õ…g©FàÉ«(ë 3¹ËÅÜß}½Z¡ÎVí- C±Ÿâ±yM-˪ÇÓžo<eÇ0j⯒h?€ª˜(I‘µAÑN¶ó c˜ÃC9XŸ+ñâö¨û™þä Þ–Váë7ttòTÝëöÆc T{ÞYèÜv7ã÷6ƸN¯_ˆñ•Ê¥y9ÛëÚ e}RM„¢Œ| À¥¢¢…ɬ¯3¾¬ðU‡Š`·†Œjheè„`__`©÷Ì xoïÃ<\;:˜Áq,=Øëëtc@j'{ˆ¼‚¦n= âÚØŽÃ…™¥[EÁæ‰3†.OÏÖ'ƒÈ~ÍÐFˆ¶7Îaì zˆÒ¢Ûíp]9ˆ:Êy¥LàÕ/#õ¿ì6n,ˆ‘Ò2ýqšR,ÙÃÃzõ³Ÿ©Ð<poÈ]qÙÈpÕÛ¸é/œ§Û< ÇÏu¤ë¬ö�‡ôè@‰Çª¯&ýRVÑ!E!Û1CA¡—e(ü®ÙÃ^N;ÎCM3ãê»3>¸yóÌsŽá³ 6y»ñHRØRõøïÁSb’¼Ñz±Y0Üj$¯¿×ŒófJøMp0‚ —ÖM˜ùÀû#-ÆŸ³bOŽ‘Ö͈a¸µñByޭ牙³8HØwgÞ¢J×vã%r9ÀÚôS›X‹Çñ0»•5·òDŠž Eê|. ì#lºã9{OE¦8ÖÿîDÃSÈ@sÍ^=øØÇ“ * ¯ Õ¿dn…£ <–«±óäi¸ÏïIŽ|.jôØ_ZnZÒ5—Ö2Æ8~aEÀ c¢J‰1+§ ª°ãâg¦éÁôM½_ÏÔf"Š=*w+jûå<TØ ®Ï³NYkܶ7=ÍxžàÔ«Üײ§g?SFOÚre³´ÑÚµ©x(ê´ö`‡@ÀI˜sWtèwÎ÷Œ3P‰Ý~¨žMh×­ÞL™"Ñ—ÙÙë±Û.ÿ-,¦o™™~akM¡2î~Ç”Èçô~lŸ´Ói%òs0±vwf©ð þ‘k[êube¸H«`Ò@ÁÅ&ÚÊì|§y¬O‘g màvÉV'þºh%ñMýc IïÙ’Ê¥,¹x,Ña{œ\”f½EÊIa°§Ô ì¿ 4{Ž<¡ÙÖÓÓ'‚ ÚBÝ‘Áx–~¾z¹Z±›GðL±iÓ t5x²a„à¶:»ÑN‚dú1MÇÓ°ƒª¤ÇÅÛS3 z?NGéß7:ê²DeH ß§ÿ02 Ÿœ¥œÔ‹Áå¥s€ø ßµ•yËÒò—Ë…¶“¬»Jç—‰,ŒÒ=º<j}Ñ-˜.¤Ä,E1Ò_Ö,£W* �þ6”­¨$z¼Bøï.y…Qexbœ3_‡‚aÆPSôN`2í�«v¸Cº6óC|-ß*3«Ç¬Rô’ ðåô×5�HͳÜß÷µ+ ÈPýHB£a ƒrEÄÚðééCûÁK”ŸÒ£ …¢dñòÄRÐ0I¹ŒsÆÍVÝpá†õ¶z¹ÃܧF¡Ùâ¸íÏ_AêULsf¤ê"œúÿPTMèétw¾òô5õƒF¢cÝFÉ¡®ëú<Zwñwg»q²˜æˆŸbiã ²²=U0‡ód)ò/mfæN{h2wÚœBñ!ºÒÎÁ j³|Q¬‰«^XLQúÈ6Ò¥í°¨ï`Zäš¼#!ð7Ó#/é¯À²9×ePÙ¶)ûJm»Ù“š8ï £¦/"J§/fã{H”ʟ˜5ç-zä|ZËåŸë“ˆ-_ —Ä'„™?ý¤­Ãj^wÆ„C nµÓ£ýéiZZÇ>ôÂé02AÞÊgƒ’&hS{aÔ.ŠÕ§n{ðû¦¯– !¡“«~àÒQoy¥zP±¸ À9bAy—X*Œ]¼{îr Q-…çس҉|å(ü”G™G°cÁ�zkWV§ÉB[N!`¯¡`~ÂÃåúpŒ¡S«·ƒò µ›Cäë¬4ú؃bdÛÑqòB¯Œý,²Ý=mÎïZÁñ‰@ ¨bš~C^Ž,ÌHœ¡C1ÓÏ­c¦òXÀJÏDûÎÕ#ÿ7[ ‡ürÊh“ nµq³ÐtÛîT—00‚FOšÑ±¿Ÿ»Öñb©½v÷žÖ¾]ÚÛCÛb© ÞÕÜ@š8eÏ„Ëô¬òA…úú4jþŸ(¼;XŠ=³Ö–íC[c‡•<-ĦÍÅqê7.­4b`槦}‹ß|†ä¬ÂÐ÷›‚8ÜU+­–1L”Zþ\ZðººÃÅ=ÇÐE¸EÙ"5(»£W## ƒk+pÂsÝò6»åµ0J†| 'W»S3Ó¢]°…avûiæOUlÍi™+�Ó¤TöU ÄÈúEeè‹ùRð§J¼ ¢©÷˜¡üÄÍm¡< [óeá{I©ÀêkØÕÓi;…K{Y]è° í.†Âăéc·ë/ý)#iÏÛ>:Ç‘N—ÍÖ›·»aâV“äPëSÏ÷â8Š¸¾.Õ–òÐw“‚®°:N!9nù_¦C+Bs¾~ ”°®Ü¢!éó ¯ø)èM[JÕWØ2ÉÅÀg•œIí+Ò8μQT ©€µÁ|5¬VÈ@�[ÛBÂX¦¨pè.ÝÍ…óÒA­…Œö/RáÞÆÁI »$ÃuÁœzdØæB“]+ ‡kU]÷î @`K%Q3D%8}ø˜SªrW_œŸ\®€ ª/Ñx¹|eÚË°vÇŽRÉÓ§‚¬DkÙ m×ñÓ� „å²ìßG"ÒqTú¼nðB¿PÎÌ‚¶¹îRÜ Ô_L·üùÆwæ‹„hRò)£¹`­X$⽡ AÉ«åFɸgã‡?F¿‚ùr[€±ŸX¸P´¹Û€É–åead1æÁjXpøÅÇ.ow>lû¾ŸeÀ OúOgÝðÒ`ŠçJ Š§öp¬·1M _é9X®Ìôa9‹xBG½¥§:d ˧Р<üÐ]·pÏ(T°cSŽüµkµ¢ñ.aäÁø‹eL¨b‡ `ƒ½}’ÒŸ1zè¾ ¼4êNÛm}öå0_Ìÿª… ˜4ÛŒöjëî>ÿËÃIõèí»JÛ‰ß÷è6÷,Þ89¢rˆ:m?1ji1ÑŠ±'Õ÷æ0ñlèúÕ§{ZE­Ê ©Wç*(¿­Fve‡mÄt§Þ§8#àÁ?¥9uï.r#5–MÉjÍ6€@á¡Œ©å'gÇ2æïú‘ÙÂÅ8 ZX¦sm™8:ÙžöiÜX! ¬yé^…¥4ˆà¹Å ³ÖÍP-ü@X–Nj(óºL2£E§—ÛAÃm¦IÕã@gƒ+_¦é „5ù½ÑMìù– O-…é‘…ÈC²’ô¸§OêCfH'ëXdû£]|*lÏ¢¹ÛË=ƒ ¨Q‡L»ˆÞm<gµò†t è7°”t$Ê}£Ê˜ÞЮç<F_Ÿ ¸›òÆÍ(… ­ëd̶´B±6Üþ£V>¡Íîgù>6‡“…MŸpwË „`XGï¯Tê€�œ»tòþ¥Ûj…û%¢Ò5!ß꾈X¦™æêKV§^ÜJò.1tXŸkZ@Ã`p¦ˆšT»bë´ çrZù†¤UyÖ= {›I®ê³—¶ Ea1œ÷hšÏ›.iä"CÄ&cc‚Ó«umE6 2+g%éå3ÃM+  àÎûZ=fÙÔÅå}ž Ø/³¿(ò•,pÍï2â]‹g–¯›“œ™Ÿ¤{?RZ$£B2`à“Šþ†i¦júäaa˜VßB1%Yø‘Ònj( KOŸvÇ1ý–Eÿù(õ`O) Íœï Ñ@ëÞGæ…mJIQ;œ©üÏZò8|lXmRÙ8­ZB똢yG@qÁ@Aj€Õ·ŽµèÝùϨƒÍî8]~«rÒO™AÐ÷Sœù0;CØ™wmÜÑ |ü¥jŸu Cùð NÕhtG9;lw5ùP]üùQâ¡IYαeEáì»`X­@[.Ý)ùÐÓ3—DÉÙ1ÅùqëT£\ºÉbxÆCÛw—ç©q•gž»2±  Wõàì5×L¢öô\.ή4ך‰žZ1^\ãéŠÏL‘üß®µ² UgË™, ¢¦©èÛZ  ë,þéz Úŧ’©ø+›+,ÎaÐÎð2;yÑ„v9»Œ}§‚‹sD{ÁïwÓ1 2BÜÀh8h– ZçKë 9ô­)èÔóbUwã•êÅ¿ô&qd8ä”ûY³ñà¦^1÷šÅkŒÎÿÝKß•…˜i?oúŒ*™öÓ6ÝèÄñÌ-%FFQ]¡ˆú=Ý¢0[ª©„@<wç/Ó½=¦K4eÜêÒ4HÍâT…�™Z±M²ì¼£›×_÷Q*_a¸hà—“ñ씳½º S64QŸ¿ðtôÌGqóØ5ež?@¬JEµOœÓp­ëi»üæ]'û—jÚŸÖl‹|»`+9®ßPê”XçœÓ$K)2£ð©º6 ŸÅô?—uGkëb¸‹†…q8áª,=oÌ‘³GYãLk•A1AwB³¼w ³(s OqÆF :![rx„¥÷™§|¾ ’‘Ù…^É#½¢UÕRþœ¹Í_{詉µ~F£ÕÿK&sl¹1•¬iºxÔËsÝv†e¸—×ùÒ{‰SêC(sd}_3eÕ·Fh€sÄèÝ(Y°rr¶í¸¾¥‡dT‘¬hV:Ÿµ„%¼fzîa}ñ‚ÝêÀmsc7Òò¬ geh‘ów䟾É úIë¶TÿcS”؃” ¤Ìé¡'TÎl¬šUÎoã ñl‘Œ±€¯NݱÔØm„/Û}§{†új<ªM ‡Z0ˆÔV„%¬ ¾¿¾¢Ï=u··ÃI•‰ ɱƒäûhaµ0¡pV+Ðîïl]ªÔEfaì« ß~*#í·Ö7ßúoy¼ðW‹X¯(wÍ,uÛ^D¼§Z”Æž^2§`Ý@—ÕâAZÏÜ›ƒT6h_o I©À.K)òX7ybôµò’xý%z('ðþ4ÏS´§{K½Â›JßY{ØŸõŠ <Š³W¬‘¾û±¢è±êýõ.µJM’"s&Ãôù§~Go´K«ì߃èÔ*"…â+¸á0º|Ë°åwž@Fe°"ÑŠ÷llœm�×TÍN4Œ1¦ÚoʈW›¬ìåwlƒ”-ýJÚ �[ÏÂÎH´yQŸwï{$ÕeýR3™°Hf¿  ÊÕ–çºl¶ý×n<á¹Íq²~.;o‹g>ìVñKýnúêÄ‘Ô\P [s÷Äq€KO|Ÿ©LÍH›ò8z260Ê@Æ.ɪÀƒ¯_ïp¤<tÃE¦ lÀ–/%g´ag´[ô[ƒøZtónÈ¥ë[qõ5è‚X¡sûÀ„§Èrdïl¹ébŒ§=sÀ0 p^ëÐ^*wÓïÊOòIpጂ#Î]˜1Q('·W?¾ ²)Ö0Rb’Ö–¦®`ã+ܱ‰É]LœÓÚgÏBJ?ú]wnÑ"‚Ð~wTѱ²ÓR[ÊDàaÛß}PIõÛ! Š_ÚI¦Ä|§LšV¢t~ìÞ”RI´õG&Zm“ üTï88²ü4]¬Ø¹ÿÝ j¦a.¯&“zñOÀP]F)„ˆŽ…k]¦Í…ÒÙFŸuCIüaµ}æƒãÈc©¢µ Jpô(ÈK Ï …¦é¾Ôÿ3ìnáA6X-ê.ú¾½xõG´õ:ó<°ÕÆY5t¼:Ë»¼v7Rv†Q‹s,§Sm£Fvl7Í¢8a ûÿ®W¹amÂVÀ* Çx”aòç¿ê•&ÕbLk ñ¨Ò|Ûþ“|-À2ŽÛ ¨ÿ•Ø£íšª¡:€F©‘…Š¹ !»L€A ¿Æ¹;Oª¿ÚÒûµ:÷LrF-~ù®[ÆSúûÁßLÄZÀÿiPFšu:üÁ´_<­ŒŽ÷1¤q;·CÝÕ¢¾¶ÂÞqdŒwš-½ã·ær^ù£PÑÄv4¿†Ë¿‡¬»oúÚШà  ;\¤ïü;>¼2åš$Z4ù k²ÂG%JÎÉ“­Ú‡þíió½¡$\uzbïèD¢uŸ•UåˆÂÔÀY•º g4³âþ÷5´p®Ä—Ó«=™™mƒBæ³¹Èx ùK/°zïÅ-²È ˆpÌç©ZrT™Ÿ" 0£OÔi¬s¨–dN6‹ -«u’Y¯âoè5³•àj<ÐZcÛ…Õ¡ã®6ÝŽáÞ…Rƒewóhñ@·79^,»Çà ÇÞäрؕŠyÏ{}¹»ïÔm.¬L|Øê[ù° ·êP6Aþ5Ö×÷³-ý¦â¨5>(Ûgþ·­Ý½ÈoB¨mÌ„ü÷h¼àRÜÉÅï˜RnÞ8v¤Î,F+ºó‹t\ľ¼>%5”P_¯]öL‘–𗧉Ǿu*ò R~° ùàñê")@æCð( ÝðÁ}üÑ8™Õî2Lgüö±góB©†Â‚~wRéöJmßQz)“¦‚\ӚǨ*‹ŽÃÂ/¹ÕåAd%©p`C7Ä੸=B!÷Lçãªs€¹¿òû®³ª0AÓ478ÍÛ͔ʫ–LËô^ç4Ž*W–²žñî˜ñùs/5ê2Ò¦ L}ƒÑ>ýk“¨M›´du¨Pò&„Q–]¡]ç’AkLœ/ã$O†Fq:xÓÂò#5mÄÿ\9þYbŒÝo**—=ÊŒÉ4sµ† ”Yع¸fñ+*«´žš¾;ö-' If¦¦|\ÿ]{Ç*È  Ò¢�?=DÝYö\æW*æ €q™¡z‹Q>…ñM“-=c[Õ4QKGƒs_\³:±F„X<u ^/æƒÎã•cä"îGTW§ã0&~Ý â_·~‰å —ZO§Ù•[ª²)O͆‹u!­<¿-µiuà‡Ã¦$²ï+ÉÂŒQa\o<CÊ�&„²Þž8c×®h»Ë‹;˜œñ_q÷‡ÀFùú�ÞH›Þmcä8xÞ5Xã!h£HCŸ‰o$X³qt£È•ÛaWr`ÏuW“,ôý~(”Š—W¯]Z9;X fànN¬è¥¡W™_Û#ÖEýt¦öIE$™>ÒN¶Z0ž´_ìë5-FÛ¥Æ�.9¾ ÊÓdpÆÇ\½cEeµæ]B~g¦u4h*áM‚þ”éÚÆKðNCm6‹'Ú©rá i¢»?DÓ~1µŽ(g¢líÓ£õQ¶ÙÊ›>¿B6¢ÜæÌL'ç‘vLÞµÈdËõX†<k žÆK= +ü 2.XáÖë%Ù•í±ƒ û·J»§ì'7 ž1ðy75Kënà­qk=á°fø¬y°¾dAÒ}›–7_æE }1çÒ;8Q<ì„¥ŒPö¥%EäFuŒðÏYPmu$\Yzñ²Ò"Ï0­o/ngI‘ÇšåÅ(yfýÇ5Ÿ|DØ/ÓLËʈ"ƒ kâ*(¶­ +xmnÔÔ¡Á[éMå©|ñˆééGˆ)mT¢ºâJx7´g:«ÇXáqyv%š4)Es>b¬8Q¯gC×ÑŃý ;”¿wSRM(L�úØUm……¢Àº-¢áCzúe6ú¥/ÙÆ?%Úz‡ÇÈ …Q™»ð\AÛùdfZ××´s¬loÄòÆ@ÚjDˆ¼Ë^i_1ñyÐ';Gtpê˜Êë)*#–ö¢ C÷×~"Qšº œ‹“#˜½á¦–К¾ºÝOà Ó1v›£_ý,2¹Û¯ès0n<g"h‘Ëò¦“(NtoÈ-—:3bìT/Óƒø>käÁƒè@žv©ûm…|ØÐFÀiGIÍþ0BùÉÃUÚ,þÜ&A²m¬”HV{b]q~„J ÝŒ‘n :rFåf ¼ÈÜàt¥-ç3ÝPyým5µR™ªJi.P]t¨NÃü¾Tmì M³@+eÝô}×,±Olµ}áÉ .û;K/íf³%‰:×é¸Ãf³êq ‚Õ� NàþkPIæ]Sn)³EI>8E½o[Òr¡«Îo³1^ôÃ)±v&RÜ™O§U°‘XL?¾€škU»ÉÄÎĹìpdMJØ•ÄEèãš¹ÅéâÀ´9»cﲩ t×÷áAhóÌ—egGÐCµ£i¿p‘¾CRE’ wuí¿X„qæ0_J Þ¯/‹ý¥?t, U7J¨<óGIteLw< [Ðm^€Kn¼ù·XÂ.²â\ëÙÂø!o±7ƒ¦Q…þk©Ñˆ3ü,½vØöÊ<eôéRÙiÝS`´ ŒZ:&ÙF§ª=J| VÚ|³¸sZTiæÏÜ&Á¹S{6¤”5e óžöëG O#C¥ú`àå_öI¢ÿIriˆñ/ÚWaPš¨£WÓïØÖ¦§¼~˜âŒ2•�)ß_5„T/ÑŽ"Ö ¨z«uŽ½r¾è·ðïðÞ#(+_žšSœá|ô˜#Jœ–ÊSí¾ã$ôå%ho¹(%@šÆ˜u)–H–s={ê®tì¼DšFá’Ï[QJDù¢ýÔB(,¿(³Ö÷½æ_Þåa&¹_Q#áØ$IUL ÕÒÙê(pk’J î ×Ãì0`Ùy¥§ÈS¬¦HƒtTY1#¢<Uí¼aL뇟!íž¾5®ÂÏBwd Ú¥ ^ý›ÕÏÉñ9¾äpÓÇÜía<j8 ¯“3ïÔÉ=;²mý2JÞÐ]²c™ß#Í#OUîgÊ+G8Ü„M½]mö"÷¿¬}0l*Š{åì ŒÑr-åölpQz‰Í¸÷è!joÐt=·9õ¹¢×EEµ´óî«XvšÊ©`ÂÎV™’VüßtdLü%i ½×†Ìb—Ü% ¤b#kFÆ'Ü䫱€0MÙ"¤ ø³ä—Üiê̓ixs£IëÎSý¨¹1Ù±Hî/�sQ¦g[n\VÎkt"{LOGd¢Àßó‘M‡l°+LÃfÁQ†"Ák˜ íPk Ä#„óšn|eÁ¶¹qê¹ÛLÑö;að¹‹Çr”)…F%a•ªÏÖ3 ð½ß~±9c#°©²ÙbûáöäU“ H=P•Ù+¯„u­Fwipr"-Úמ2¾èHýNIÔ‰“ˆx!Åv Ò¸•—"ej…ÕH¡]¤®èJ9ÈŽ”lµVI‰û/XÓÈcßo‹Z?F¡ÔD‹£ÿt\¶¾«5d Äk‰¦W‰E¦ EÄ\ZÆŸnÖ˜$uABl¸¨o*ZªÃ™™WL…ÈŽ[·¼vPøº|ûŠ ¡¢Ã†»’K;#®§…¯¸.ê7»e¼@¬t·#«çmY²&Ž¢5# óõý½+MVo~€m;1ö¤ÛcÚð­7¼p²zºuv5cDf¶àÝ%b,¶‰eC“&^ˆ<™æÓW'Yý/œÅ=ñh¶Õä~ˆÎ‘ŸbµtA^ôBÌA,Å“ [EcÎg/}ïëæ£9íXÎe…Å|`QR æpÃo ¢òj!aUÐ1GõqeáWã…N\ŠSèpãàò*nß_†7N¸"Ï<•"Hå!•s*Ûv˜UÈD¦±¢2ncUw�ΊÉÊøÞ¹¼Fò89–r:÷l‚ÿ·’ßwÌ#ÿzlã¥ÚmgâD½ª ¦¦zºDY_êBƃ VÌ”;¤Aò³5튢ªy‘rð.ù49ÝGŽ‘­¶”Á´Ú¯KY¥nœä¸”nÍ”<;%yæ{`SöÉ°Òü¨/|TÛ®Ó¾&뵊*Ës\iä¼ÚÔGX`Ç“ªLaN0 ŠÎRó×&°Iî«Õ!•£J¢j­C}-|™/ Áf§ê€ê„Ñí7ËîMšûävãJ[+M:|ª°R»›Ì—G$™4²±Fh8«,Ô½œˆÎˆzøí É"Ýš¬ZÂB~ô<'Ëàʘ†‹¼ö7L;aŒU‹Z²»ÖØ•±82Ü«M†~UÊi.èZ:ìX¹j;7‰ÿ÷6(>×CNJ—º°6¬™óº¶¶ÆÒgŒ¡-°^qýIC(ž«ÿ–ôð0£cÝï]äXZ‘=Xh¨ª†ßG½9$™ .»Î‚Âæ¶ê C¯d¹¬»þ…Ù¡þ¬dŠ +?ÛÆMYÃèÞMu0n¥ÿǤô?U¸ÝRÆȘÓ›Æ(‰L´*ŒVwêã¶õ+Ñå†NÁô ÎæáÚ’Ò×¥Š+:Ôó :uÞgÒšÊf@Áç(¥•nÈOºQ2¹×%T&WöïÎí£2ó5Zð«}œi÷­>OhUŽàÉy‡Eÿÿ˜‡÷ QZ¸yz%ôËhÑöµ—a¨yiõÜ¢G2¼“yÌÓ˜z˱‘Ç1Ç&¯ÇËÄv 2»ÿàúãz‚_-<©niÚ"H‡Ác²ÖÓê`wïø¬VÅÂ'¤ó§ ÒÆò!3œVvŠsÞõ{žÛ‹Gqž\É*Û).4uµ9ýØe±x§Çßø¿#¬,Ó<bKãõ¥ 2ãT€âEž¼©Mè(åõÆÐ~È¥­/}Û]5þ"K:uO‘">êù‚2ã°¦ €(1ÅÆvçƒo‹§±BÁg¯‚3怓êKf¡°û¥~Ùš&üK+ & óÛ <¨¬Ó°� Ï1ùg±PüxÛŸ:uJ]œimÛ2(?‰ÁÚg#5ÏÙ°GïÒÜÍ[* ¦™âzÿãeŸtX�âåŠMÔÝ•ÅÓîoŽ¨(ýâƒ2ñfKÏ:ïlöÂN³ªÊH‹ڶح3švã¤ħJ_xÛ·ygÌò�]ß“åu¤·võ½|°£i½T~×hfªü©•t²ÚÁ1|"˜u&áÀáÒž!Ôªb‘ï¦FÜ6’t<P¨G‘ =ŠG¾[4èd¼i¹pšÂ¤†ISoE a“N‡#hÁš3Ò¿G‹�q­9›ÌfXÖö^ï$§LØêg'V<¦6�CóáˆÎšBc~E~Ž€IòéTð!ªi!å–c1<Æjó~AÂ2˜ÞÆ_?ØFs†fþ|ç'V¦W•Îè¹ö ô¼Ó„75ƒ]fé8÷E!K(kX÷-HIl¨³¶ô'lÍÄNEæü6´ ó­ßÚt­‰yËPäFK‘©¸eHÖ´ž*Ý\Lr­µºŠýfBV¥Þ8NlÓ °|q<mSV²ì†ÔòÆïæ#V1Y¤ŸSÚ×iõ¶®‚Òû¸«yzß½é$giZ±Q6hh7dz*…T0’ƒ“ÇC@,å·|ü”h%/j�%ŠX:7T™&·…ˆGb’ ¡øàyE‘´m}#çʆu‰çˆ29Ãò,Ñø™CUdÞ™Ò>Ú?·æh¯ŒÎ‹CƒÚÃýÍé~óƒ;Ç}TÒÿ¶p£{s<Ъd`¦ó©eÎø´àKÓé&kñ2­Š0>ž¹Ã¢![çˆz´ &UÜoéïÀ|e·‡ú/Ÿ=ryê’|u¦Ù: tœµSJˆ£$óTcYÙ®¢<¨óìQ¶ôé§QÊ£x1]mßg“¬Ì“±§Á¹¥ã¬·µ¡`­Ž`i ¦¡Š‡w‡›ÑÝË»‹%³6 6§"ˆzÅCúÂÎ(gd¨$æ¹›\fD‹§¥Z’;ÿ8•—•ïSÓÒ¡ ’áÛË"æŽn§eWêô@ë·«oïвÓ$ô0ÝI$“ÄrQÙ€NyC,àüëY¢EÉtm¢Ò“ãÙî¬ZðºÌ+3Ùµ¼¾j¯PQ !kÊÐ÷Ö# Ê(y¸Ð]I¹1ô'_Ž´H/ojÈDô©K«t+’g«Ó"?GG56­ýÈ’>¼¶¸s%gn([Z’ñçäI×OÇñ´ê¨êãé6µ6rž=õ%síaÜi8 •AôùÇÊüQ“’ô§û‘n_Yïza3¥qæ1Viéõpr-?<æ$“Þlv\¾R Íü|˜ ¯ÉyæƲô:Oè>¯é)ÅÉê± ÛšVx;Ä0×*»mRa´&·‰žèÝf¹Ø¢#ôÔd´´[+‡!qi“i¶9~ Ö âÐÏîâ!VÙ›fUA“WAÔþñèl{­(Y‹j;¦»?ì’êÎPK¡ó§Üµ©ƒàgÛ1DïŒmÜ?¿ºÕõ#OÛz4ÃlÎðÜ?¿Ê… û Ó"ŸtÆŠ¿ûò1Àî °è/ U7ð;ÅxSBB9n‡~®ïšWf c"˜‘Ñ=i&mpA_­ë§Å|nAô»ÙZw½ð#K­½– ° ªxÓ ÝvNt¢ÑFß}=I qäëI‘&Qä´æÏi·ª8 „ñòÑp+~ï§ÀAG¬ÝÕƒ+_´¤{€´¼ Çß©C~9hNæ"í¨…�ùÕŽŸÛ·ØÄ•âC¿(N]�)¹´ gT2v!ݨæb%µrµrÛý ꪩŠë݆v\A^±»c² üi¯”TÇ(j‚’;ÖŒDv(3®åŸñ¶ö•Õ'J&Ò•U<ËãÏÚôµwëŸU¡‡,">ÏNâ´xìñ—X�˜À8(¶J)fù Ï«ën̼†ö½Ô„QBŸòœY׸å8ìzû'•ÑÇ?ô5ñþ°ø?z×hQÒ†wp p.,¿½ÓQ’ù"ß=Û> ýÆãÕ-�3¾:°>>[õÎâ,&´Is3‡ÃÞ/é2J“³ î˜Wå:šÚ<T ¯Gõך' š†Âê÷Ék™OH¹vb2 V!¢‚ûÞƒ�?Úšmhîÿé@âB/ƒ.6'JªYIGYDd ­]îáPqÉ¢Um‡&Ó5z9®P”2<3Ž¢¤tþñàm&µ£Û—þ³Ö•OæÁ8‰* lj…øg¢`Îç$‹)Ùð÷þ©d‡®ò—2:Ož-ÄþYbü—Øg E.,ðÓ¶£×®ñ¤ ÜÇÿk*µ‚¯¤ÍR°.JÙúþ”&ÑnhEÐÝHØýF %òhH²”æozçAõr¹N¶OF¾Ó|Rvß''ig•íJïiópŠ‡ÕIBÅ“$ÌC¸B˜Îöt|yÊߢÍV˳5L¨¸Ý:tõòfˆñÂj9Š}«e`¢Ñ&¶¨ü8ÃéŽøY_÷šÄo¶‹óÄgï˜-6½H &ÖOßÖ<k/î {yþ§xm„É“ÕË…�̹ïf«A{ä­o^Owœ|Ca†èp¥t´`Tj@©¸Â–õqÕùåÿÀž"†Ž! Üm2ª݇ӘÁœ¿´ïŽËÊ"m—T¡·ØYˆÈZêÂÙ‘yTÒb§$AÁ^Ü)ÚØÑY;Æá"×j9ˆl—r9³è¼ÛÓY'ôG®$BãW3ÍÖû²0«+Üfã*Âÿ¨Q%Ä“LÄå“oÛÓ#ˆüó€UX±Ä¬ð»ápÚbÜ^zP†ºuê å}xF²ˆ9(Ô�*µúHëÃχÜm#Š†ây„1.2ßþ-*Ž ë:$Ùòæ„®¦õû­Ùv=¨Â)ÕW_Ü(’{^Váâ,F›ù³óÎb6—7†‡³©×ܕű,w÷íîl #ê¹ééÖe£b¸c–{è#fЄ֞F)…fzôíŠ==‚²`Fé7gÏE\Îb‡rS¸|çŠÞµÊ<»@HQâU~«ú`Îj¬ˆHî=ïÏŸAÐãȇáЙrz ³‡‹<^ö– ²k[8áÉxÿ;OMX=0ƒú^Œ$’Û¨ÉCè™O/örÍZIÖÒ6J,Ã@À:t€Âøb@µ°tkÍ=S»?ð¶÷‘b¹Ò41ð½OP? £o¦ë¿ÏQóØL<cì'Š©C5UžŽ‘1Ò8Œ;$¼Pu÷+"äÜ«éþ‡?³“Táѱ î…‘ò;UâbÁî³…(ñ¨Ý6Ê1Ú-UáÜ!T?ÃOÇÝy wÏÏ×ÔƒD`eõ/íÛ~+SQ„Ò€©±×œ9-^3lâ*ÎÜÁ‰ÆF›Y«#”)Õv»¬¿9eOœœ3REˆº;«9àÎâÈö·%b¸¨Å3Z/T®Òv �¨¶ þ&û…Ÿ/€ŠÞ÷¤ÌÔÁ”¤`xl`=7þåU �”y2(¶Sq›’Ú;{¾Š¥S‘&'oóáÐhÉñ¡œZl)}|„z¥Á˃¹¬QœÈ;:è‡Ú“$PÉk·èÇ`ƒ¸\@Ubé›6gf@‘cú_·NÄïÈ•QMçR<ž<ô±Û s!”ËàWÃsˆXbqôÐMÖ¦f…´"Üõ|*Ç t·Ü°v+B6e@AäëÙc‚õ¨"…öf¼Á¦K‹T½ÊA¿¢`[Ã1­7KŒA::~—.#SÖ=:±·É(PÎd`;z(¡ÝÜ|zº^î?Pã…¢j}¶¶Æ)á.„y]þŠ0rp†5µh)çß©òYv!Œ×x6õ®!izÓ~ÿ©N<Ïl�Äòn06· ëúR÷ÓÈg¥~F¡1ÛŠndHÖóbéë^V¹Ó”aTæQœ>=®**Õnà<þø^†¾p ²ðžÎ«}¹c7 †;/Á“¶(×SïÙGò3¾ã$Ìü.O�0£Ì¸ÒMãØ£Cýïn#«Ydz^1@ gµo¼œo$0g¥u¸ÞšeÕ¸ª‡š‹Ö¬âxìvÂ8€ÌWÇ“Ï;1’Ø(ZŸÛ"¨¶iqì@<÷ è´o‘Ë€vÛ±|Á½‡y~¢£ézöÜ•ee„*Ⱦ;Ûr¤eÈçw`ÞGP¦yQä…SSŽPÜÉFÑKÈ/öŒ«˜&ÄI’âôE’шŽùȦx}jÐzé<åÚ :"ó]pú15÷3WhÛÄŒ¸>ÜøˆòX‰.%39cF·nßõ[à'ùiµõŠPo”¼S'Z+âÎ íC{‚U¾ájHq)Ì]¢®¿Ìç’ktC=*CŸ9N‘ï¼òÕÊëÄ·¿†>»‘/y“'/TkB1¾É,C¹Éy[·Vˆâ/¦³q;³%ΰè$^’ϵS+:3û£>¼ñYæ»— sЮ©•j7FèÐL™ê/V(‡À.Æ%´" ºJ»ÑVö.|·D2ìSY¨…èPX}Ì'*n1“ÀRa<4òŠ¹ç‹ùŠ¡b¶*Læ¦ÁKqhÓBoF>è'OôEÚ´Q®ûµqŽ;jiÐ!;‘ÃÖïå®Qœœ ‚ëûŽ¼rsc©Ò˜R 7‰o7§d«ÏÚ¶¡ÄÝŠÃß&Y¸èê@øŠí§S°Ù€=äŠVúÏçíe¤?¿]ïúß.¥ÅXA|ÛRÞ7ŸœT‚P2å_w”  3*¡éêIñ¡øÛXª)U-TŠ»÷OØmjc@KÆD×ñ¼ÇG–›ÁôÀ½ïàÚtßCá)'piÅfb í°å¥ÏK’wNaËÉ·éñvÌiŨ˜�¤".$„,›¸;è‘6a· %tKp”K8ÅÈgèP<ÖN—µ×¸Ñfʧ‡°Ÿ¤ã&²±CÄg­&…bÆ´YÛvk#€xïêVÆ4‰3‡ƒûiKŸ7ë´¦/A;£O‹_qìy9¾Qc6Ã)+`òôY§‹…‡ü¯aO@[Š’I’ã¢p¼ ]ý#–eþÁIör€#I­N8¿ª7CñÕaßpÇÐûâ±]%Ùp¢œ-³MSÈ)  ÝrYøðLÔaõ=@Ô¾ØO7?ðBi&ìÛ6 òN•ä#FÍ×Óñc°ÜÊ÷:>8¡4D«ÕšÎ™ª»¸ðu¨¿8x™D™ç…’ €…ÛÝz}óŠ ‰ÃÑæÜP¾u(ê¾­«}igÞ,;Š@Бá›Z˜§Æ+óŒÿ-Â"QÚ‚]›ŠníÉåàTB1­‹!˜Ó²Uœ™¨qðZã|Zªoùvhˆ¢°Cžð-t>Þ‡L8 ‘ȨòL4hŽžö"FfóÙ7% >!jïíx0€Zз¬¡=5l�‚µ¤?LœÖ»ikçÝþg7üãTQod/î Ólá�•s³™¥Qifêø¾áThwùF¸m¬BkƒÒ7´ëüÙI/}U ±¡?Î.¦3ñR6© ÀOš“Zó„‰!æà3; ˆ¸Ù:�o¥„ß×nñqåL&:õèž«}³u7_È¡851¡u½%-f ÅvzŸ©K‚bÖz¤©ÙŒ•íØÏÃhËmç`Ùf¿0‘ùK·˜ o¤—0;'ÉÙ¡ÕÜô°ò=¼äm9g2îlöy‚ë²ä¿Òtp§s$ ³±Xù¿†lÆt÷„læ®ÒUèk.±@b™É·•C­øö@a‡j‰Mð@ýs!Zæ‹ùúƒy$“"¤c#wwZÐÂbø5Q Š–®OPåŸø~Úß”&3 U µ÷VÆÒO1F'ÚqOÐ@8Ú×gU\•ùâs`5t (HÃ/drH¨Ì‚ ñ@¢ô,pB&dƒÇ4«ö,¯árA#i®òº|ÈL‡e“1~0æ®Wô.Ê´lEI.š0ap†êØYG·ÀjÃAªÃÖ¿ƒ¢å¾j"àMª1%¤”…é…MUÑÅ­/û_9ÃÅf©§Ð¢þi]f!?¥�¬GÈ\ˆÇM¦R¦.3GëÔ°ËŽ‘hàO­×>RµÛ”òPYŽhf<毅³so¬qBŽYÞoœ®«5{k<Ì'؇[¦å}7û»ÆöùÒt3M÷ÊúÖÅh·_9 ?cÊYó`.±‰í¤àÉ~ª×µÂÏÿóÅ‘ÚùÕýiÏj2}תæᵧLËn`HKÙ 5­Ã=ûР˥­…w¼Oñ¼m{›S™ãÇç'%yï›ÿ¹¯*FákÜCÅغaaÒš³ H@ˆ¸�Âk¼ ã.s‡‘¸2ö­cWŒ’Ý0Ö,º2e|`Îè¼Âþ¥³3 9ùf«º­÷ˆAyîEqœ ¬QO ˆ þ<¢ßãkok:¿¬rkн²?Hy¤ºë‹ne«*“gN9eP½ŠïV<3CR àûºŸPÊÙfg{u{ÚæÅB«‚D~ä—Î㶱û„|ر»¸\û€æ×Íqæâ¢J›¡µ‹©õÖ2=ƒý©oEmnËŸÓçÓ×+Û¸JŠÌá2ŠiÂ>²çèö±ƒŸß@ï ÝÞa mmK[¡&ýÓ\þøúòû;Y~9A>$èoUÖ#¾;‹ ¤´ñþÖߊ©„ÚL¥_QµG¯¯ë¸Á î´]ð¢‹:Ë.Î’ƒÝ†BÄödEq³¿_ÃpXváЫbÉ"Ê訥ÝXz&úwÀà!xÈ‘l±{ß¡­™ùîFôgœÔU£ÂPݱüëÈ ,§k[3Žñ.ߣ —¦)·í© ’“vƒ‹œkqQë7Váÿ•fFæ‘t<F,×d$³¤Úç#ÓÍ'¨þ¼pÚ–<:öô âMí©fÀ¼{‡·v�:µ)‚率©K˜Y;¿I)?¬g"ê -MÛO™|Bªd €ÆZ£T°Ln¦(óD\ '–É"®‹Aíïš#9j#KÞ¥í.`Ü©�›n{ê9Æ$ô)ð5;0‰<)€ -îpĽ­&“GJ;zú:¯ž³jT™Ø:uô ËoíRGaÃŽ’7è’}ýÆy.åt(±@%Ó;7¥†ýßÌýY×b5zýê§z´˜&+4gAÑŽúY%æ2ŽÿuUQe>E›âƈÛÝÚÊ”¸´0uøºîÌ0h}eïH7p±R¯¿–q~4Òâ±Ö©QÂ\í%=Ò`¤6Vgø|¯HÈUœù8¢0è{ºó™ukg/ÓÃà+¯³¡Œôt,ð¸d9)‰C_\, )òÒfͬimÊPóŽB½m’âp¿m¢4u=vÆbrr‘Ûé:*é¸0mè:& 9”é-[)WÕ‘ê8q<y´ ÇИÕnz0²¾U‡‰–sùÝ 7 ˜Ü¹À·pÅ(0Ô‡˜ÉØߨ¹Œ)jæ,R?‰«ì˜C2qsE“S½;:,ÈâäÁ>òV$¹˜%šÂÌýµœÇúzß0ôzL%kQô”!²ßkx¢çr+¼f*ý±è@ÂV¡$ïVœX»´ÊôÏX2þüôt­ÖL¹™ò±9\¦ß Qfž|3=û.eôÄ*´oÛŽÎ8E±�ωmì…žisʼnÏ)¤ôc{JƒbÛ»>ñ Je2ý £… ÁÛ‚Â�<ÍFÏÉŽÐ-m“¾^£ÁÌëaç]©¤i õ�@Ïn~à²ÔpyVì§ba˜qÇÝž…Ìy»­­ª&…ÍsçÌ’—µüN ™7ü†M| m+´g&¾Jù ª¹?ŒÜÍž@tŠÐ×f¢òd w+V•¢Ñ. �NûîpÂ6ý§ïþõ‡Ûèya” 0ØQÝ6ÚBÎ’gÒò‘š½3SÁû¯ÞtþŠNÞ §ïF÷‘E}I 3PÈV>úÍCéè,É|q˜°ÄP™ŽŽíà¸ÙûšR£~æÑ/« 0žkÇhëãnm‡/¤mË_þv(#t´1ÓoU®œ“˽q Þš¿öÞ1x>q€¹>ð-ûÉ8åRQ8%`ÍZ[#Q‰3©"Çœc=¯¶’UKMb÷õ©pÿ§ø•Åb!VÁ¸á© b»õ¨˜ö»yËÓM~|sÝ —y’ýÿ%H۱—¯b^E>×3Î9RZÅNáëÍ\ïz“ÛÙBßÑð1#swþª{þ¥±k¿Ê„iè(œVìî…ßT”|Fãœe½„­à<‘lø×’â?DUX±æ°2¬2=´åT¥ÇöcØÁ£÷ÉÔt/yüC9„l½×cŸÊÒÌ»}àéÐÖ g5’Ž ÊŽë~º£HH‡š nKÄØM°Ìœ/ ²+š‘ D™ÿlºÑ ½AŠöÒÜÉ£D>¨FmWô §K;XEz$n^e¾3NM5nµM¤F=5›²õ“Ã:­ ÊlL•f¯@RJ}3q�/qS«~kÛ±¶Ñúè¯?ò³{›U–g%¡‡VaÅÊÒ¨ ÝþyÇ›ØèFc+`ú{ß=\©Š|ˆ§4Péçè¤V ™þî¯]çûí¤a°:q6|]¥½…#ÈÐ!tèû‹–UE¬Æ¨Bñ%^ÓǾúÎXˆ­”Kbˆ]ÓTÕñìQ‰Ž5íI©q=üKφÒ‘äæHËÊnNG9 ŽÉ)òîŒ=éåó^(åÆm°v™PZœû3£¿¸h°`ÜÓXáMè± v‘áÖ­¶€‹ü±ÅäTW×꞊'¾§×lù‚¦ó°ic‘csýšþ]`™]zý%òé÷bÊ0Ðéh­°£rŸ§aåá±}ìƒk‡ä5E²ùàPR†ì÷Æ<IÊ‘¨ÓÂCCOÎÝPËàG×îOƒŽ¡oÇ.‰§Š„¿ãJ e®y@7It´3ý8kˆ|X[*¢Ä,ZñÇËÅAfê߆Õ_ÈÚ¨'xœÒ¸¡wŒF{ NÊÖ}Ó±ÇF>èøM›Nßôê[ì›r!Y› -CééÖZ~²Fë™ÕÅXûºuâä™ÓïŸÏ0P©gŠ‚)&¿ßºc­¹'Æ›6/C[°£ÉêÙ±| 3¡t!| º~‹pgÑƸ™Ýuàô­šmÚb¥­H'óÁ7!§Â îk8Í,:õX¢Õ:5gFcdêª ™þØ Y,ÝG^ƒ2ŸÁ½ÚáH+¶ÚZò„þ¶Ú ëzÜëa ½ªŽ –* ó�/÷ïÁ»ágè¹SˆÎa¬Eœ¨Q®¾•ËÕ 2)3¯§­6îC* XÛ>ä_tÓ…m+0> Àý¬=o)FÆpv¥¶uçûlé¬syá〠®—oñ=>X#Ø ý»e1棴׳Z ÔŸ<lw•ußδ6÷Îç®Ýx¨ÙsgŒÉõ‚?<ž1ŸxN¦5Zˆ¶Ó[³žTÖÔ—b¯-(ß$ÖY´¯ŒþãØ4R‡µ>fFAÊŽãVÍ×7Ï:©q²ÔÊË_£Gi¥mÒ}WLŒÀþóA§ŸÑSÅ4{eæ.Óá],^‰öÞb5)Qr^ë�&dâþG[ÿ»k§kÞÌb)[Ô=ót/¶¹Ù`Gî ùü£Â¬¬^“wßÓP€NÌ=·e¶Æ‹¼|Žid«‹¢«b£1›&ô|)üž-Tü•Îœºù0ƒUdNa=CÙDû¿œSXã_výeæpM7þS[Ø»À ø“öM‡æêȵ剙TæÕ•¾È€gQÄ\O†ŸÃ>0qdÚD«íi\m­Q¨âÏ_@Ñ™†`Mm#ˆ,á±RR~g{Ž“ÊèñüÎ<`P˜ù0±/“Hç@ňNˆŠÀþqÚØ=ÝE§ GÐb¬6¿ÉÜ_ÿÐÛy±ª÷QÎDéêéÇuGd�lÜÓŸ¥L¾I);Ïv?ITŽÎ ¶‚³sov=è&xâþ¥:KÍŠX%éøQ ob:ÑiÈÂи…<¬6Þv0'DïêÆ7×È9»AÏãôí’㥿qݯçÉIQ„¾M>7ê›ÞÁТÿDåí¥Kü®¾¿5I¶×`){¬:pËÜÕ*—mÑãZ'mkÎ×®}aMNjÔš)eš¿S¡˜¨¬¾ü­¢­U#SŠ­Î”Jöμ9VH&)ôk¤|§A›ä±›ys<#sÏ7koV5¾Y1¹Áæ´³¢Žô(Wµ´ÿ­ïý²NÿB´«‚~iäçÆuƒHÃHláßã®ÿ4ÈýÆD¾t‹"ÂVAdQOJÇÌ,Ô)F™ŠúMÌUV,0¯Ÿ‡ÕE±'-%Nô§7µ=f *.•÷<C{]¤?/ËTy*¼u« üTp)T|¦¯ÝÑ—<{¡š”$‹®A!ݸ²?yÂmfãÄŒÀy;ŽTÉÕ§g½7›¥”ÝÀnƒ*bˆË)çÚqñ© ¢¬j¼÷CÃng€›O€f[åx4 DV ©ž·ã_ ëò0óÀ°tkö_°/ÞZ¹uA Ö#裼<×ýŽ•éí �>Ý‹9ÀÕP òý/S6 ¤H7ô¡òeÔñ+±f{ÿ­÷@Ý´Öžä1{ *$0<–òáGDÏhI\?‡Êú.,s“ÙzL$�¯œ/’ŸHoÿp`}ÁˆpRgþù éø–„lÙ¼ràPZÞl« ´VzšŒVˆ(È ­ü½gž…¡—<Ò ÷eýt^…qìZ×ÏléÑ‹ Á“Ó,Í<M¯š¹JØ^@©>äFá@ ø͸ÛOÍžzŠZw´oîÛòÆ]mÜG élzäq»…biÑXõ\)G ½Â‰àâò!$Ó9æ&=šæ$È>­Ke,VF$©à±Qêw:weŸN(òX™a$åQ;pU˜þÏ`«Ùÿ3”º»«©©0ö×Ã^Ús˜(@ìåBÙªzÙØÁ¼wùÜÛ÷Jö0‚b0ÖG ‰Õü Ó¥||0Ýž²A~€!OmŸÐZ½ãÈ«Vœh“S5xyé»Ër7ÀÈuÇAEñÐЋÓz½úú Ú¹œÄ:s@7÷{kîzÆ­Da?šEu8÷ÔþkÑ“BSm}͘XÚ"붢ÍF÷Vé8¬&ÅL–;büi•ÛYFÌ ö2 ŠoÝùÀ?v“ç-}jEÐK__ÉŸ‡¥V÷iŸÐ±öx ›‚ [.gE¼v¿îãû*þ*± à øÑd £ê¾žvÌy³l·½|uJÇ…hÊv (o ‚®šjdN_�eg„Am"Ma`SºÎŠÜ˜°òPÆ;*üA5¬K†ÄZCH°ÙÆMmi”¿hÄ;®zašB›ÌpGÙ—Œ-A´Ù*Z†!GÓö0³.SÔü¶M©ZT±qg`cŒª³¸ú0“îhœ)iQsàÛvÿL‡žÁÄ7?¹àl³UŒ`à½Ð£ì<Imvº»ZN8ÖD“wñ]++ñFî¼pHµ 'ÿáž^'C ˆqnÜRaɱvׂ¼f^^zƒæèS˜Ü"g@CC EóÉ¡˜ýÚz\`Røp2[úX@Ö+ËfMrßa ýÍɳe2~PpSÔdp¦wyÂÚ¹ýÊh'G*¸v­´²H„³'gø¶w¥Õ[–f=TMFx…Z.Ep>Ê`Îx›ƒvÑuØó },× ô¤ŠŒ/úMÃibÒñ±‡nôÒ‡Ø÷*YìᇚR‹Á73±V, 9gNšÜž,¥Q®‚Ñ,´œu æ™g®ÂrÇEØÙY.nU“#V×{Š¿”=v uht½W°gOÛoï„ãñÒе»Õì«>=¬’òâ rÔw”Mt:F/íÃÙÔ^›ñÐ\<èÚ–Nm–´eý›ƒ«ßÀØòÔé»…R²Aî,  @÷øëšâöÊ )ñ›” –IßEèàŽžHóºÞ¼‹¬™çŒù®Mf\d¾öa£*z¸¢‡)—ﻃ˜$â¡àÁÜìÁçf^¥­–ç?ò¨»ae6õ¦Ï8·•¿)xwè€ ´ÖµôÓ§À©t êô!øÔI#«‚ój]P‘ðéIHpé¤jê¼õ€ù›ÇÝ·jäS—UÞtgÁ4µ˜{¬ëU\µŽþ €C¡¤©·¶¹__zƒ$²W º-ڪʡExx9Ã/š×Θ•e'?XîÙM¹p[¸SŽö㡦ª¹¬&³Ú SÿØ•AÖ+Ô陑š•Ùu=î˜lä8I\ö¹zzG±5*cËH‡Ò9£úóäåT¼í¦ûíGiLáÞEEœá4ÿÙZ8¶Èé.ðù{×>*z;�šq0µÆ{“ ÷<X^n*@©½&%Œ'�s³·ÓሹÝÔÍ}}¾ÓmÈJ_e3N0ª {ZAjEä°£åÃWÏCbžœÅ•&âÒ²sí®g33kr! LÁ×tÚ¤âÔ#´Û·Ýð¥éOⶕ›fí¡lFÊ•¢†ÙÓ¼[»dÁ$<,ëf-í·àć¶HârWK3+vêhc&,ŠÁä \â6š$f‹4.÷…ºª…JÒª9 Òyö Âè¯<ô»ÁíÅín¦Ã°é‘? Ø7Øø*æ^,¼‡håÎ݈ã·'°™}=¿×뵶L§Ë3\Ò/ã®Óãöü()_þ’/ïêIçÙóT—CN…›•s¸â6)ìä?¬s°³ °íáÌj¦Q—Ž•üî8Ë,ÇŸôtço†ŠXîD­ý!>ÌÝn3HÛŠ/Mz«“Ÿ"ñ嚀¨Ú@~Ò†>":%Ð"9`9>4@ñòâYßš'¥ÿÞ8¡þ¥¼Ü6_�~[š]µtBó†êeä ÈÅgBÓÙaÞWÜì´µÜëê™j/tâ)o¸“0Û[5YX16TW;Áë4Æ  u¨zõ­ê ˜…Êy©EPö“Ù©Û–û‡¦‹ƒÃª»üælM=«9\Whñ…½ÞµÊˆz»AÐݸ[Õ‚=fëHWT¸bZdɦ’›j¼ŒÑŒ¦÷Q¿'3%Oª\øRÐsÝWA~l<;È5}¾Õ–í” üç~ãì>ß%+œÌ¹�¤jä·kÕL5s•Sª.<;Cìzzâ÷èïjóÌÇqà,<#ø¨ÊT¨8~jtêml1ÊuÆ¢`‰ÒE=Â,²¢omÌeL³ó|2‚àzþ˜X­÷Ôô+VÛÔ˜RD¦äx•Éùp†z`Ù¡÷s )VytÞ¥ßùÌŠa7äAÜŽÅ-AdêéÃ’ûl‘½¸~ì�i1袌G+y8¢«Ðèß±.7È Û‹Cç¼çú4X×#}–<÷SŠ„J8*œÃmç•š¼JØ–¾ËÜõ]½¦:“XÌî²^ùB=¥ý\áIk*è•Ûoãâ ù"èҙׇ6D…IÐ2ÓÞ†Z@aýx£0'§ëz‹rzªP:Œ§(Æw?´J¨j²ñz”}að“t:þ¤FCôÖùžÄƒÚ”AÜm?åñÀPOcqe ©W—‹q®!-²¥{b[g= #ø(ì{�ûPû8tÍ1U0Œt„}{ž‘Þ1‹L-ÜＪˆ‰‡€!ë†BhÚÌÞŠ° íùô»µˆ¾ H‹Ì¢£ê§Ý&AbqÍ1CFŽ˜@ÛF˜éÓ¸ä{…ZüòÑž¸ÂZ~ýOzFÓhÊXïo!Í ®,8ö‡ùc^×UíÒqmnc}‘Ó‹òªÌvG„C®…­=ûØAër6”—LàIÆG•}…há@¤—¿1S)õø‘¹G—V¾Ô,%LçäƒB¼”¬^i½?-ŠŽ&<l¨E¡§¬Ác8ǬµfZì0¬È4•öfÇåʘíQèHÂ4³ÌA‘ÊB…Ól=à!-¿Uu‘þ•À£Ñd“µmÿjÔ6&Я2ê9xZ\ÉÐ÷úÛ ¦8­¬T¹T,]¤?VÇŒ‚7«Í£‰TÌììz†ÜIÿ ÐBçFÉ/¤”? ªÏ‘OLŒÏ±Wf !Ù Û´gì½|¹ïÀ“ùUhÄBž´Ü'%@-¼´ bó8&úáAã„=#zïÊ¢9`ãPN•ó«Ù m·Šµ8+}Z·TA~zð€ý°`ã“·Ž‰m,ÃÝèF$ºî”@Qjå“P”Æ,!ukˆ ¤sV?)×ú­›z 4Æÿj  Y«Ê†`]sp:'k×oÞ2³¾Áªõõà'¾"'Å.äÔ~¢Ã+jk5D¢u¾åèÇ›q ú•º¾¼°ùM}œ\:'¤¹g«1î”ãEUÊ(®àáu^ÚÉ}dN¯SƒšÑi”Z9×Î ›C}aéµ'²ræ¼ÕWÌ,É2(êÙ¤u_õ¸kNmŸ,t6`ïò5a²pˆJQ:X­SJFMÓ3e"2l0ý’¿ä‚1+Ó i/¿Ý6µFîœU1«õ ∶¼è¯–¥Ô@Qþß•Wy¾Û"Uhy á æ«cëe'M¾ONÂm+ ¿!ÎgžnˆáaRµPXV6/[…‚ÅN¸æZɉjÔï^üäNx™[·&û­cA¯(s1ÇÌÑYß&jUЛvP’† ´I6\®µu @C¿³bš‘i¦d®“ªÃ×bc±ÓpĆG7QÅÞcàN65^rÊ7÷/oº VÎ@¤Cn£¦ëNíe"âOÓ…_ë£&jä Ì(2#gvùi6—g˜ÊÙ{ñÒ=$[€æ¢çоP‰ãZ ¾š„M&Ïõ½²Ð±$™q°ú—¶î|TÒ3ó1ºyV^Úméa£É¾µ8¢±w#ÏpE[0b̓½¸;+ðÊeÚ¦/zŠÃÖꨴÒ.v¹ðÁ&XÍ;Ww“‰Ô9FbQ±üEn‹ê™ghFvtøüŠ177åI+Õb<ØŽ‡$â<a“ÑÀüRyœ¥Ár“–3g(Rgkv¤©µ]eêö nºc—UÈ[éÜÑóƒù< �ok,{6-°$ïÒ4ðš†Þ­Ñ; é:´ 3·ð ªW«Ñtz¶—¡eàÃb癩> N[CG5â÷d«{ˆÎÖçÞé :ŃGÚ‘S|AÆZbþr^SuZ»>àªïXãÅV³¢©é]=Å_-Ùé™@ÒÊFå×½ž—é°±åÕn²ÂÅwqiqugÛ™ŠëKwrdŠ=m)=}œéË;æ/IäGlæégloa!PD“p ðs£ûeÿ ðÒâm!¹5Vä„(yH×EÈî©»<¶E(òì*hø*+þ dFî$êb«O<ú×RQõó#ZÍ0ØQQ ˆo‰ªÑ±“†•?í¹ü¤K0�[é.'köWÍÜLC›¯æG6‹>Ê“a¢%¼F‘!ÐNuBëìçh'íâ3dƼÁSÝAt(„Ë>b0¸ílú³ü9©ÁÒG‘ñÚ]mó cÓdP#7£o†V¨@êÝ ß>l•:6~iŒ vGZ'ùéèÝœãO&!CÌïihw螀Øi{Jo£UCºÈ#pg•/ìÖñÑT{1šRšÚ"–°Öi[º‹×·*ñ¼cc>­Íàã³¢cfdíTþÀ]Ýé!f±¸,´(ˆÖ)i‚þ·S˹|· à³\B§Áü]±gââÝ2j›ŸóaÜË7ÏÈ·ZÉ„…Zщ;yÚ8TjI/ûîã3º ”Q¡D怢͵¼™ãs2ŠHÝǬVgbU¨•t‡ ò4ö½0–TOÌ©T�úЇ¾²Zc17&ÅØ–¶ ©zÇ¡h^î^<¥ !JŸÔÊ�Ãïkèc™�ŽR÷çM@¾³ÙÓŽj{ “›i”,‰6KåhÀÞ¨\ž,ÐÅFî+U&ɹ™) dÕ+à;ˆ©>ü2ûÑLŒÕÉy1@¾-ßÙ/ìªI—LÁ¨ƒCÿq¢reý tàcÏ¥<€î•“ž@…¾0¼½zC+©¼.6wØ0µ/ ë³^Sªok½¡Q%ŽïÂnÃHEçñdQ"€MuX÷A§Ý˜ÅÙ#8¼2ªZË×¾þs1ˆ*‘ÏòAçNÈô¨1Wf, r¾ý¹ŽBóÜÃWæyÈJ’z°ÇˆEhÂr®zœX“ž…ÙPBÞò§Ë3µ482I§ñªJñ4ãæšwõ†Ön/,Wõá<ÒPÝåÁšHû«`Š1±¥p/óî¡;ßW™cŸ<OÅÚ{Ô¦p1o£i(–2¡¡àÌêÞÎäßÎÀ&3~0¥ÏB=жoâ‰Ò„ÜSœPÞµ„\Où—ÊhôÇÇ[Ԫǒ\i×½;µ‰¼”¦2 z?äA8ýñôÄ»þ_õ 5æ$Bè¹~Uìr-\å�Ôi™vŸ8Þ¸WD€N€Ô™‚ÐAÖ_€×5Ž úüŽºÒqí5ÑPß V1—Ùj”Ó€c€PÊU‘¼ ‹öFß ÎVo_«²DáÖ¬7f,¯$Û`?7×ÕL‹/oT7;>¿¡³A›º:)p(yˆ$.‰O›c<«è tótÕÁ¬N¨Üÿ…üYž-è¯%^¢¦¤øÿ =îèQœYå‘î⺆ÆÁC5ÄEN#0WÊ ƒ•ïš†%¢MiF)Ïúc:Bäu©¸ß§Ã^¾ò‡îخ׫ÈaÇBѵIQAÐïY÷^½ï6ÁéáÝ)9¦°ÝYÇw»!uîèqì ÐL•ªËÖ“Þ)¤æ‡/Õ÷w’}Eä Œ…F¼Lœ*¹ BY(¤ËVK‹Y^¢k˜%žh"-4½é6ÙöÌu·<ƒQ$Ó™gI·P×,¿Ò0–^ð¢$œvÀ}~w=Ï5…ïYªùßtƒ•�2#žR¡=(ÍñܨÁxÔ ÿ„­£–£/+ÏÔ])¬%¹6Do¦4dãØ Ëùi?‹º¢jûä]¨Uù¿ ¶OTÖЪ¿ÌN@ç^yyê L;üЃCÃ7¶37§Z£½³Æ ËÒ.ÆZr[*§ɾ´Á¹¥ã8í,Š1âDh°0«³°ÀìëM~_dW0" }a '§c×[¸x–†ç‘!&SxÛÔ]JQÅ¡R›6>ê,]yH”5ê^E¡æðÃèQ}Â:‹Ê…„/…€áeTõýA_BÆN¼ùûºx¾Î ~z”¶¬é§öÕS‹NùÒz¦Ó1ÚŽªŒØ€óí#6Øê,‚}ZÓÉPà qó-ó€9Πí©0’-‘QîEŠå–#·ñ™ðð_i'Ö÷GÙjãž­ŸêÂÐЧ¢÷ýÂIØ]ýýåC~DåõáëQRk"¬¾hóTa_{1Ûˆ0eÙI=†–˜ÞߨG•5íãΕÐÿþôDׇ úÖa©³ÂüßÐýXñ È++â<2ðpλ£b Yœ‘%\5ÇyßÃyIô)(ð%Aõ½ñtñ`yUŠ02܉1×7ÖZ¦H'Û[Û˜]j\A8œ89á„Õ#ׯŠ“Ì?*!C ‹ÄN«Í’=âÏ�nš»ý V”—×ÝŸ‰Ç§Cr¯wC__®e6ßæ9„¹Ëµ ä—›ž¶yî\ŒQ;_Xàn¸ù–×rRd ' n[ÓáÀÂ=‘öjé|í“@ì†Öè(ÔˆÜNf™3úZŽÁÔóÕ8SWA³äaôXÛuÓfQûý´1YHþÒýØ%LÚˆmƒ|:1µœg»yÅU¾ÈÞ|uÈuŸ~uê÷—Çu$ße¹ÁöùÜ÷û僪“>lƒØÏ­Jp«uN·ãGƒF¹ ’AÀ­Î}MŸƒiRçô|>©¶A\5bꦯ…(üà§>3KZ­Õ�ÁœÍ™2�ž#ýhvt®G“ȨŭëÎ=îÓ%õ�-Ýîmi46uLkœ àæ˜mñÀa¶,b+k"0ìŽIGý¸¬sYáï뜎ÒR4Ô] žÏvKOœ;Âœ´'ckôW¢>B¾bÛ¶D®äoRö42A®4³§&§8d­0 >8},ÊX¡£Ûì¦å7Ès8{¼ #­Ô.µþ8Ñh˜WŠgúõ¯ü§ò¤P›Ýù»±Œ0ûv“loZ˜’üÙ‹»G˜/OV )ÀéÄ ðqè±c¸ªõ­ÙT{âVôÈ÷_”ÐÇ­¢’3 v¡Ü†2Çcga%òŽ¿¶yÆ+îiSMÖ¬Éhú§Ïi‹¥çÂ|ÖVCðÎèÝíim¶—œØzåðÈÚSZQש ÂIsÜÀR™©Ayvß\>LËì7§ÄÒ *cÛzn‘»N i¡À2OFÀ ¹õ>027~‚¼åqq¢Bûbùæ ð>²½“P÷ع ¢Zˇ nE+l2œ¸3ýW /bvFx¿QÄ.Ë…J âyÌL:Èaöº©](¯l;LÎ(ÄŽGS+¢ÒÐfêe'LÊh…OB;@Àj¨½#tA¬zKüÀ ßYûa pÑ*‡0¼þ„r¢–…Ûr-äÃF$â½Å<ÍÃ…T û<!_Rà�µ­¢ éÙN~¯µ(^´1›‡Å‘£Ò‹‹ûê_œ íÑù|uÈ ®D©ôh-]kdK®åKl#3X·i_ѨŒ< A2™MSíÅ«$v‰>ßõkÎX¬Þ$ÞPœ£=ÁâÅNè46;Ö5^[Lã¢P›Ü®¦±ÿ‚=w£u+ÈÕA+j œiíoò¨4Ëã8’ZYÞóÞìg2¿Èd$hnÆkwÞíB@¯{L#WlñTƒ(M\KÈxÇaãØ®~%¹Ì£VǯæE´Ðp‹âTÚ Í§»VZlÀ¯RxáQäåïµ;mq.èC¸FRµtR~d3xGÊÖ³(>3]¾s±Ôs.<Œ “S›–žPÚN[Öêàbùs»ãó‘Yì«xqk‡ ÇÙùº¨Êˆ·¼ëèó8S™ÅÑGÎZ¡);׆·ªw¼qWÔàøãRò0¯¾uÙˆ…'ˆš%Š¨`ònöÆ[h樆6ULôŒ'Ñó¿9vm—+»žÄ³ëüQ°=Ò:ÍšÏWU>ÿ ÍNÆ¿àWf×HZe]ïéóõ®‡¼Ú¦­qâŠT÷¦¸Uœ-À[<ü/‚t^{"Œc}wå„jb7<ëû+ý> '”Ó4[(>9+äÜujm$TË_$¿þWÚ™ÔqŒÙn҄󊽤†´Ñ:Ì4èYâYVX:k§¯Þ0±O-Ã1AšŽû”Xµ\øD|ÕRjÉßÜ7EJU]TÑiP:B‡ƒ=~ ÍC¯qjÚâEPuª·+åæºÊìçóK’Xè[ÔÐá}ŽNPd lìi4¾&1«ÂÃó•sNë`*8MòOïrùüéQ’ål¡=;>ÔŽCþ[óù–)lè'ÉT6´C#ÉÉS_ E+ÝKƒCÁ-ÈéoÔ‹ØÔl¹á×pšS¦uš|Ž&æɵ§ñ«ýÿ`-ŸX@ ¯i¬ÆºòÁ*Z?s7;1ô×½¶d¡[ÃW”ÉMV79“,ló宦U\8ð~ÈY/·_?0ã1^ÿ¢ûªᆙŸŸµ­\Ù&š¢¬m Bþ\î罫‡’¨a MWZ6ëoÍžòØšf)ÕLÌð’I ¬6ÕòÊÝñÊÓm:g“*Ñçœ @ëC0߃9§E˜XøzQtªèDÚ˜¾cÌüèѺ²îh9?q‹x[ø&Ëâ?alÄ@>ktø¤²ô0}°cª,ÔÌ€?Õþ O_Cc=ž†kGït‘<aKÃÒϦéðF%v=¦a%³“ÝÀ™ÓƒZ-*«‚Ê>éÛ…bd{À‹ŒÜÛn7Ö¿0³Ïcƒ§AÇ]±UöÓ°žH“5�ñdéüöÎÀ%ÖîKe”ÇúÝ÷qö FJB¡#w6pÄ›+R0J‚Ôr\£´``Îà)Ü¡¨–&¸wõЃÐk]Œœ¨BíUè M^¿'xäedëyqn¶µanÜ;@Áw0·T3`x?z-}¾õù§‰±‘´P¼‹—“ðÈg•¬×‹6ïøéôÉ­n¢L$ßÑFõ™á"—ø5ÓzI¾•hØ0ýaÁ°†Bîu/Ù$cþ÷”d!Qe¤Àã®c–¥`y­ÄRñQGY¶“Ƀ7›)œÌÖçÅ™uq•AøsЗñlÉ„ÒöàŒ3Þ“‰þ\..‡É¢¶œP1ó”¸7V"®èì¿mt»!æžyÀVK'Å@ekæ3]åT§œ•U¡oö˜³ˆ^úí¡?˜¹6»{NoŽ"kÈ ¿D§OVvÒÒREëY$ðgyl×ú<Yîª"¦ ]Ä?³×ñ¢Å®&…ý¿”G¶j±Yèã&Í‚¼VÉ*ìЉÝx4>iªLwy>|éÔÊ^¡`ñÄ@º¡?¨Ú*ò@êDl:—ÈmëÚ3²Uh¥{)Â[–F~I€ hÕUPY—4¹Ø·?G§¤ê2÷gXP"ÙÓ¶­u†ÞÕâÌ¡0NBƒÐ›êö4ìçà„ƒUœ·tT^G5M`x,\N–cŠü“è?±êÃ7Ì`h¹RÁ…i[Íé¾jäKÒl7i«sC"J•;ºo^+xÜ䯘‰xî|Ë·­™Ì4¶š-Èô{ã-[ÔòHõíW[”<†üø‹³WJ› ø!w¦OþóíUÚ´÷Ö[ÄØg¸¯¼Vž#ò/qG‡ž^mÌVôýñä™ÜÒñÓ.$¶ ÒáW(k‘Y.û0€çf%ƒX ,Ž¿rô˜7©%KäÉC–ýO…Û&àϾÇFÇóÜFº%ܤðJ)ÿçeœ¹PM hD·¡œµå=?œo5�Æûã4ÒÙlÀ*‹oÍm[Èþ cÿ}õt†ºÆÑK ïýþßÃkÌiMBfõ†h›£Šž"Ï ¡ùp¤@·ßk·pw&Yeæ&Ýê‘Äö9ÄÆ,ÄÎìØûfy¾pª:/8qî)q%l‘R•AqÑZ4e[Ï’ƒs‹âÐ]Ü‘6ñ@³ŒC™j½x­88luú®3„³)þb<Å_Ù–íc®ûæ0ßùɲŠG[Òò¡ÜoüôöäXTu•÷Z&7ŠqÒ1 ûwÄœâ*u«Fíwé[ë–)®Ó‘˜ü3Hyê 1å®ÙRh«>ËoÔÙOZZ‡Þ¥p§®CùâFo½=•´—þxí:..ûkdÿ_8Óç>ßÓɚοÁÎÉe^Ë Êð¹¨xˆ—H½37ƒL˜‹@f'Nh�¬Ì¤ÖJIþ²PD¾h¥Špo¨Î³AxE` {Ìú5vNò¶ƒå˜óœ»á@_Âcë9D¯ÆÓDe§I궰|¾{¦ãhK¡äÊ|aS×°Ž÷£ÌLÞZŒý®ÑóQôùš�(“[-ÀkPLHó€‹hP7M÷Õµ,K*LD§ˆ‹ò0øµ§PNùi×<ñŸ*ôèICý/f~ÞÚþ5ø)®¼¹ úÉôL‹ :ª†Ñ×N5›YzöÔ¦0Ã}åfõ¸ï¸ÖEŸ]iaôiÈÝ,YiÀ ì©H55ÙiœVÜ’¡÷™à&)Øë/gþöç©æêߤÂñdnaîOçá9+ lh1“xþ³G–êCÆ–o ’<Ór® ¼ºe‰0xYlíes›'™ït‡ا5­—ØáÁä€ãa%|r{aå,³$ó,OX<—ÖY9m]³}…Óišw÷ݸ)A¦‘¯€ÊFÇôÎYsr혹†Ëä–'JÞëxj'žÊ=0<Î|F ,O´z×Þû<5;”ûî<I£Mïò "Îüe_§¦ «Ya ÛI2uÌéÇ°ŸIü,”yJÙ÷ ¹k76¡ù£/ãjܦ TÌZžäo0s8_ø[}õjãHå-¶'öË°N?U`NÂÇ¢<ý$+¢•_éØwTY"^”1iÍD:]€ïQäÿ˜¬—ò 5„ØcCl¸Ç¾x­KH€Í¡#«Þß>‹c§M—P; Ǿbâ’I¯ G¨6FnG$¬"—ì¥RDQ,Zß?´Êê¿�y·;+=jQ:ýN?(¶52ƒÈ‚qS©³É…Mcþ@Nó÷2WRMu÷]ÀóÔ! V:Ù§AÞ6‹^”:½è³ßðj_ĵ$õ2nîØO_0ïîTŽL iÇÙ½p…à”_ž»7NÖAô Ê„óÎeòDûçô†·ø>XÔÒ̉° ÐmilI›!õ;­4wÿ^L¬pWw8ôEa2Å»ø áÔù舨ŒžµN.ç]+:’ürÍ#Œ²4Ì+gÈJÙÜÁÖ "Ú[Õßÿ|”5,íi+Î?!Š‘'Ó3Ö£„fUq:)NB,7'º*¹æ4«^K^>ø12½Èýj>j©ÌLƒx;ºž ”hA:­2eŒÉ)Z·F»ýQ­éëØ2ôoHØ…ÜÂïÃÇéPf<$åq÷`kÆçرSù¦ÎÉDˆâì=MsJ{]‹(‡ú$HÛQ·~Â`±Mkyu«œs`wóºø¨<ƒ4Žþ<lóNå«×4Õé »kÿÄU†~D S͈v«â!œbßVíVœ–ÌÍÀgs*5tÌè=»ÿ`(gÈO,pÅðþÖdÞåç].ÜÆ#¦™}ã5çämJÏoX&q¨AjÞœÕxGû²˜ØnpšãeåiÅàç %f'ÅJ¡¸ÃéàÛÑ^9ºÔî-*_ ¿”$M Î'?^ÄZc1!×æ¼l¹Kžt|FëµòpÒZT£Ÿæw|½ùÅËåbZ™ø ÜL`#1¶7Óð&§Ü£»;‹ÞMšZ>UEgM[9ݬlT2@íxÜ)Ièö|{D™Š–4¾°DMÑ£k=úë÷©S5pH¸2ôu!xˆXÆŒ‹¨fÍã“Š)øžÐð}\DêÈ—’¥6iɪ.©þâÞf &|@EE-½Ãx<ì'¡ÜôØŠbaáHáoMqnÝÑhV3–þxžf¼>É“+ªî'ò”·ðïn‹«ÃSí«C|+Níöj‹^ÚO¤«J¢ß®=G]–ï™w�-¢JEpBR×ÏÙÁ‹€¼&<&âÿÝ Ïu°L|OïœÔ'íÁ¥ïbÊ$=Á}³æ|‘™1O5$¼[Ïꢞ˜= is{- 쉀 Cu¨D ª$ÈF‰S €~´ÝßÀBð:z‚ K×Ñd ÈjC–}íC"·—ýऑ¹¡+­üÞô_ú¬V†²Œ±ž|d;ýf6˜ê‚¡Bux-�iÙD™aFAq%²ÞªIf†mÚ-~(ºb/l†’f‹1Å59éði\J©”í²ïPJcH,¿Ç죽L§>Xuc×î6ø¡w‰Gœ¸6IÉvk³B‹O€Â7ž'@®$ô8B‰Q'£´ÒÙEL:"Gv“*ÌN÷´—€»âÙ‹°Á+,¶qÑ ¤µv¦LòS³(;bB8¹7¥˜20kÖ^è éÞ>ÓBîB”FHIyã™[£ÿUSu2œ¼ß¸ªaDH±þ¦—c«ÈKP©>làD¹õ,"ëyÜöÆ15¶æLÓ;öõŸú¯ìæœÀ°8 -šÐ¾´ò¨„#Eq3ìù‘úö¯¸vÎR57©;¤W“f°š29û yÊ®#¢×».q=3õg3øðûÇ©ÇD] 2×ZÁ¿e o}$ž ÜhMäëGX¡ÜvŽ¾ý·„Ä|t#‘RÖ²QøirB(Í2§ytÍ¿má®(¡NÉâÂ@ÉÌI/­ãw¡B1Kâ™Ø]0xbÈ‚üGßø,°¹=ãš_LŽ­šŸˆB�7MéliÑe‹É˜,Âx…îë‹àùà0;ÌÄ“|3Nl„;SÖ4¨†Á0OÁI‡ŠÊxšþï­¿óÂG‡0¦ 5U ÏU <þOØ;½oæ>kždh3Dþà aœxd(MM¨*h¯“½<øå³Ã ùŽ‘3¬'§Cú-§-Ї?’5}õS1V ¡t�ÓÕ¡6Nf… …š•¹PW .–öy<w3÷{mªˆV_²NLésVA±™œBí¾ž ¼Cš(t×ûɈ›ÿÚò4ñ šLn?ôô°>Uó°*dzÀÑÓ¸`ÔçwD=;–deàÜšòñ`ƒâ³_Jg>è‚í4&¨·„µ.,yœ=$íÇa0'¼™´°D»'Lx}a±L¥‡ÑìÙ ³6VÜEÙí•è,�©åË+¸TT8ãAi6dÉц(F‰D¯È…—4«çBŸÉ"祕Ü÷”¥ÃÑ<úÐø/ÄÄÙضp…hšÛä´&Úà†@ÇkuÎúÕwMÔ¹I3Ä[û,=:#+Ò¡’Z´úÍuué!VâÜd3l¡ˆã1"ë(óhße9Nk7¾L˜ˆÓÉX~Ç°Á.aÅ‘¿E(|µ @ìš!Wºµçò…#Tmாƒš¤þ¦[ˆõ9åÁ!ÄjQÿ•ßª!UF1˜­½îXÞËÓÜc1Ô™ýŽÿ4NëXn$+5솊Šœ~·™—…7ã˜iCÕf2ýñPF´Ê/|V£×(A’í9ÀQrWú+n~€[–úúªôžç)e‚¬V[ÖÔM) ½Vû=Ë-Û×Éçˆbzûž¼ýQ.ä Á»¶³VºSœ;OP32ËWèé8özåŽçó˜ÙÉ:$c‚»±¸øÿwOï¸íÎÓÿ‡ ¼ÉÅëbó÷žU¹fòË–ß}ç1–TÚb1c(е‘V?šÓ°©QjlSùÁüBpu&Ï ù:çó8½¤¢‹¦ÔJ:9 R]«ãöÃYÐB¯ §(ÔNb´›Žè/–Öœ›Ï,|†­£Ç"Z (äž©rhmS_ÃUõŸïë‹ž´i5ªÏÞ]1з˜ýT8-80ðI‚ìgm–#Þkª$&¶Oýãµz0ˆ!n68!/ç ý!!cU@Œ…~p|ž)””£Ã»Vµ6¨o] îrcÆ"gÛ: RÛJ)Ë€½z¡óðžŸ'ÐÅæá«uByÛVËtyo}¶æä«CÇ®£ôl‡{FkܤBÍ¡t$ªÏ&ωÐ$¥ws'…—¼LMTéEx?´Ÿ› ÖÞë`¬è‰Ó²CîRv`wÚŸû”öh§>´fîõÛ²éD)­¤šo‚¯ÒpÁBIXñ!®• °vß—÷éÎáëMí‡Ä‹¬ <×ô¥ìTh-öMÓu””ñûxFdô¯2úÓP|~± F#p· ö§Ç‹×ÐÀµýV¤á+ >@*QQº Â¤¿Í)¡³ãó|O0Ø5ÊâÑ™®ržâR†eòà}bèÁ|†<Äï>‹mÙjöºHÀMÑ{Gyb›¥:{:ÃN«ì4Š k0G“Ïð 7—“ðÞÕuVœÅ•‡Õ‚Á¡ ¢­ŽaDê‘u4è#sãªþ·¾óân»¬;ê;ÔÅ»œ-ÌÉ2@sÓwT°«"í»ÚvX™™†Ôå@ HZ÷ ú±“‰ &JL•öç_ßëwùQ›Þ뀃4úÖˆ㤃‡›¢i!uçâȜÜ=-ú J®Î¬‚ pC V놥yÜÕc_íÊù"`ñ§ï,‚ÒŽv�5_×»QdXM‡ýMõÎ$Ëý7,Ñ“ž>þ zàGô£_kï”q¸å!WÑmUÿ2g·#žA0ÍhRa¹ûƒ®{N6±oùŽMD™ ­îF9£†Ï#Zk„eD*]S€YOðÈ»ãăצn:8Ux-àÊiy¡·mžÕñÛÃSýÞÊ^5M&¡úÿ (rf¥ÚÎô'–“Ý À©ªÛKMŸÃXbÊ6²„¼Ù«ùY@óá{pа¢6>À寧ƒuBöð8Z£½´4F/binÓ/DH˜¸–Á¶ÛЙ~�tèÛåT9ØžPÌ™v@¨=LÓoÆ…IéÍM™¬3¡×W­?Ý�KøJšìë~o47èØ16)îÊ3’°zuPÜO-y†g¨Ý€Æ½&¤¢D¸C½Xµý;Èþ$,ÝÔ‘ÆM¤Ýä¡-j€@çV*o)x±ûL4-LrA—~«ãxJ€Á2¹"„=:°³l!šPÊð®˜ÈÄèü}–kùîyaçÿ,³D©¥ž´+ëÁáèÕª{‹e´±¯÷rN},®>ɃÂpÛ…†» øcYЯ\–‘\8+E¡§EýÄ îíOà•r©z¥Úr÷qL¼ÑûŠÒ8ôMéͦ ÉÓÑŒçP²€~•š×—¸ø"~,gÐ2¸ß„úÂ?·yãC>}vj+”.#Ë;íÿ b´=,Œ¸d© $“±§[ƒlò2ö¶&p²Po+DÙÈkÆt;/iÍ ý($).×ÄT Óv¤zŸ#QòÞŽ½KKÖ9-*X*k†ÁÙ÷ îl…Gp4Om9c4 EÍó@ïZkµÝFaÍ+‰ÍFžë½ôœíÅõJ«bËÞ¡âõ¥äÞ²L–€U¯Å¨H”óù˜˜¸³,ÛÄ’šO?ÇS´ RëOíq7C~/Œ¯I<Nïr<`VtÕ‡ŒËÌ7y£åØLèCw–·wájO°<"9õžPûBÉŠ5$ÏTát 2IÃ`ÅN©Î¬jÉÒÖñ¥ßh1w7U…”z°yI™¾vý^KàgU%ªÊ}—i({A¹Q³€”Å€´uHÅÌ qa§L3¡û¹} )Ìõ?áÒÒ;©Ø‘hw˜êS1>YeDZMaùŽCXYdžn ÈøÑmïU^‘5+y`’óQÉì8לŒK¿G¢~Ž 錎*ÃdÖv6m9_AìQb@ ¶<Ôï-Ñ-½GÌ7(ºÔHóÎ=~çBEÁ¢Ý:eôŒ{[‘óZŸÓ1sÃ\š”ÕGÿléy¶`Fɤ3öÑ€öŸê�«Ž»¸Ú…ÞpÛ$•‚R‹‹ö\ f® u¶™>xÚ£"xêpXÓꢔ,“›`A—nÁ úTb ¿öX6_tw=Ä:°_Óáø±/_à°Ê`µO‚l­C˜DˆÍál‚¨tã°ø¸ÉÞQ²6N,º½2»w©X׸È<8 Ï®èšæ¶ÚÇݸÚÕ=4¿æ‘#¡jpãtÛÒÍ·^[Ÿ3DÖÓ}O¸¡,åÅ›´¥Y‡ ‡·©§2’qs[}R‹ûzw¶_ÆUYš¦sž¨5bÌÜüløúØõQÅ÷[í®¾A.‰4D*Äýï¤YÛ:5°=%¾-ÒÁ]ïÛvxÕ/=0_Ä '*ŒÛÇMoìŒØqèb+˜ÿ†k²ðQ àµé³8ÈúÉAîv%ââuêÄ óMéø8ª²*¬µdõ'ztŸ'3§€ÒÑ™=ìlgù‰o{„FŸïT 7†5c¡Z« ;³|*$qL/mÆbûCCwf0îyì¾ 0(/¾øƒŸQ™íó ·¹$’Vºýrj€ª¸ÀÃòT_™Ênöb£zcnÒM«<ZtoèÓ^h·çí`Z~…àæ>V@U×ÎÀEN àÑ ÕKp<œiÉW3ÇF6¾muj'÷‰Ú¶îk ?|CÏ–ð?¾´ÿ%ïÿ;Ñÿ”eæ˜Ø žÖuµíÝÖÇöù¸|4}M‡OÀ‚(|à?Pf©ëZdlŒÑÑj­ÖX".‰N©õo!0‰æ "…ÃÇ&JCH‰%-Ÿ 6À.†%+÷òŒ§ª JŒh„5 -Þj)—Ü:e.[]yÐä©>¬t„Öƒßg~ ñ-3Ÿõ–È©ÿxJ2€†‹Yn ™AçýØõ§~/-„´+ƒÓÂ甄Æø1ÿ˜ˆYÁ¾JÄn·Þ)eå%VÖu”§Ø`þô­gxÄkÆvØ.Ý>º¾ÏJM;ý!D~­ßI¹"Å_˶L¹ s¬!Á±Ù¢¤ófÏo`�‹kß ~s¸?›Ð‡›L,&'bë•ô+³ÓË} ³Ì³�<»-‚Š©]Ðû…»Õ´Ì8ÌRö1fAغƒ¤žÈT¬Ê÷µÈ‡u7$QSí0È{¢,ô^ípŠê‹bù™¯{Cf ?ƒZ4èÖVv—"èiðèóÿEBœ'®À`MSEG‰‹›Î¦6¼HþŽqšE™ß”e~-ùïÑ·šf‹(VX§s6YÀ¨oÆŒÙÔ£ËZ†>¼(¸<Šnãš ”©!Ïž"hs1¥³+¢quOß,¶cB©¨%µç÷è;%˜íè¹¢òpÀáußIU“h¸ #QhÏ›Î#ž@–Ø ’¾©Ê^¡§²GGÔ|®¨bt…z Ñ»a¥ÃÂ$õ›£½¬òø= p^íéW4*]%ÎΖW}t(lÉ»æ‰;£Ñ,-®ð”Wr„²óšn|ý½ðöE¢ßÜ»T™'Š­–KÏÂòZ©Ì/‰•:3˜07þ çMJÍH¾;d®gݼËt8²´áY³JäÖ,2N½œZãß ÌmAkæ«eÐpöØêyîã®ßŒ»½@[v{¥+¹«ßëéf™SÌ/yì…³ Ÿ~´dAo…qPÜJn§‘9Ÿò–YzÃ… ë”Õ¶‚K«xhÎñ …²È¨à¹è¾``¼Ñó�Gœ“¾]gXÖ”rIÚ¼Þ¯«RFeË`! £éÛ´˜(SúꔿØ„!ÎÓöÐï»»î”Õ]¢ÐQÄåxˆ œl-¤Ñ*›{Ñc‡3Èi"5ÓÑâ½c–›ùya ÷{*i‹éSKCº7݆²A¥) ˼ø}ìó.K÷»Ù¶mº,Æ—"7`p3ô/‹Q€é±P̘Mq÷lZUñ‚,7P+¥ÆŒYü,GÌü«ö@;jw¤M”[21«Ìqe°³*[çšílžzûÄzFÀ»=�èåer9Èf×[Zõ÷ ¾»¾JûR±¤æ-^Úº:†Ì¯ÆB¤Ú*Þ)·Ñ¬áœÚÂÐßeŠUæ÷<è°ÝœXl^QÎflÀM\¸M”xÜ•4>Lqé3ªÌóe)ŒòasòÂ~;jL×~¾Õ<¼ãNYzFãÓ«§"ˆ¶µù—ÄÈåŠW‘»0Õñ°£Î…(m+«ZÊê_ú®³aøVËHz¡�v~ƒ`½õB`ðê”qu”ÇI•]µô!Üœ*ªî÷;zÿ¹†RâúÍÌ©ÁKáfÏÂ%6=-˜ãhqKQ ö7|‹fÚ~<ÿ´‘û—!ÉQ½7ׂ9Tö£¨‚ÃÖy¼ØQn-;qŽyÞ¹¤ó;‰*wŽGÈÂiÿ¯Ï®"?½@×Þàf Tt±E½†ÿý|<…ñ½ÙZBªZÃåxn¼3vÕ­4ÃO]ÏŠSV±4u߸¥mÔÖ« tBл¹÷# âl)Uº;ÒÝ*†ÏÓo>À¥[«”u×ï~Dõñ!.2ßò ¹fEë_™sïÕP’F³\,,UE–0Õ[ñåØ#B°)Aßå´O6Š[—Úô/An]„fÚÁÍ埶û§¯ÿùC«H¡M¢£µŒv7Á/Š#'pÎ*-Í€&•=« †+k¥„‚dϹÉ/) ±’8Eé)JYm} 2Öèݘig%ç«—;S0æ K’&¡ߥÛК\±Ñkúö~G-hó,•ˆ2Þ¢‹µñyìË·Qždꦢܕ»Ä©Ï [þ¾f¢T.l! Q˜8pmþÚ4#+®Ü¶÷ôÉ#§6P þBÔ™œþà߸‡ ¹,PñrªÏé‘TÅc€ Ïõe‰V~ÂYO]CK¼Eª"È.já>ížò ºóѺ·ÚžE>óÐ7ÉDû®¿Êµ/DU˜E…­þh»Ø‰§UTS^jD#UÛÚ)K3öý Þ¥K¹¡U­°¿]`ŸO-•÷GwjÏ¥¼Þ·Å©Ó#ãfÅÀËFŠF=g§@Ç’Ϲ.‰Êx›$Å‚.I‰~K§N6l½?˜ÁꜤ˜Eð…Nãs¿¨´ðþêiÜP$Kk"ã€Ï<4ðÜw‹pz ¿D %”ˆ ’ãÁBCÓˆadƒ¤Wï[$gᵨá<”AvüãøÎZºçÞÞ“79`¼Kð?‡Cý5Y7zßb°DÞ|<ÐÙeáOp‡­3T³Iä8ñrÒ‹‡V±7Ê ±ÊØf¸´u˜JY\óÙ»“¢§C#+lFw•{ ÕÐ8×´Ú½ŽÍµµà®Îøõoã ;ˆª2õhç'”¬[WO¬êÁÙsÎ5ï„Ô|1ªŒÎÅéxå˜(ËRDºÂßþh€[½Ó¹ "K–ÅMŠ5-[ ª=ÔT„�z^#UîÏžßµŸÉ6õ,Vüò.™¹.#:,…ÑÌè~<ß¹½gtý¸ùŸd 19H¶yè ŽcÖCd©šónéN›—¥�‰zïEŠ^<Ž?V½9,SÖ/[Ö2ò­¹î ” ‡ÃÀþ\Û?v*s” ¥ã|è“öZÐÎ_m9â[热—Àë*\ô%i9A¦ÆDY†ÊÏ w¢$оJúøD‰‡0H$ÿ¤@a™«%"…ÑU“b†r#/èøÉOjlÿ­ˆhCÐ-u‰E›e )¶fŽEÉ!C©+RŠ‘½ÿzbÆ™šgr�âyð:Ù½|iqt)êB|¯Ãj§…Û|§mÁ(\›ÆÞjœ>P:­òÌs»‚öZµµÆ,3,Àj•‚Çè¿æžþ‹ 糌Džáü/}ɺα–„¢- 86DÇøþå—èÀωÙÍÝ€5rñù¶žúÎOƒnþu ñ[ª¢'.r×?¶×‹–û×a®µi±ªû¡{€¦Nc/”ñ”vÿ…Û[^`§c`Á´¶Ú(ëûzu/=]NÓfV‰ ë?N1š3÷º~£Û37 ¦‚\;zæ‘›Óeú0ˆ:0¾ SKŠ+ÇDy’S£JXðUÍÀ”xè’û kZ/øõkM!äx(BéD6¤.5:¸|ŒÀ»úîù*×Ra’¼í‰p1©“¤´Ö‡Ê$þ5Êe T1°oþƯ¼Àrwq‹NˆSÅ}Î6ƒþÛÏÖRJi¨ÿ_ qbßÇ)íâh«Á²DCÎçÆt}o1MžÅÙoíÙcC/Œ:ÝWëÖÄFY hp%egè”Ñß>tïë‚ZåšýôÈV[ðµ~(ËÚž�†ëN,nÕcþkTf>lŠR èÁ—ÝŸþG:ž‚f(‚æ²¢»\›ßò¶8|¤öHÇÝøèÏ¥ ¨Ã³[á*éi^tw'ž†}%}ɘr­ÖS–¥xú®^«7›6¼±u€OÍhi·²cãÅRîØ1&ž Ф¼ú–Ša îÑ$¾“B6&)q«cÒÃÔÀÉÈW¼¡}J»cBy2*åMÇ‘"ó¡‡)2'[ÊÙª“(ëdŽÑ·$¨æâvJíÜÃx‹*t›Icû’PoÄŒ´ûø÷Ôy¥‘ѱð O¯1g©œ¾EÉÀïUDOÊbfñD¦Úh,¾ù-£…‘ ÝyÃU¯ÃQ´×’©:sü>\ÞY^„žB=®/ðOÀþr ܺɲ¶,fª¯w±™Qiz²1—YìúJ1¬©mÍð¾–›á;Ò‚`¤¬ü·�öiRe.íA‡ -…xRü¤9' ³!ÕÙ„¨zhgáCç>ä³[¤eW{#ÖiÏÜMÖ&SR!ÿ¬•4â‡IçÐ3:võ×2L&It»çyâ©6§¬©)aÊ¢QúþÍH1õdŽ®¯!´µÖA#<'ÎáÑï¹n¢ò—uBÐb #Ó9½KÙ_˜×Š(à ííšµBœDMŠ?§’ èõùßÞ(bñHwr„¼ûä{=å(Ï–#†¦‰ððצ5“3sª\©Dýë×EqáŠ×HPU«Œê²Ô®µ­Šya™¨ÿ~×5N½Ïµ�³Nh;§N· 0–q7ìXkW|?ñtþN¿-ö}~Ý+úY½ÏÓà~(jæ êO§VÝÿWû$a#mŽ Ãg!gYÈfЃ¿ïäË‹K‘8xn‰ÎЦÈЦú§Iøu¯èϯY~S±`kl—ÛÖS.b"² :MmðÒ'ã »åö§Ò_4R:bʹü_æÁ› –É^—ôl¬ë)*->¦%µñν D3Vu7Qu\üˈr0,Ëår‚cë¹3Âc݈sƒž3kÇüùƒ)¬,¬¦kÝç]|ƒn¼Åˆ0%í*h|ÿ4fj‰ó 7é Ýl÷é ë*¶à¤lëÇA¥ð÷x$·=LÙzA˜UÄ•­Ð2Æs…ÎðUw[ÕU‰ôe( Á«‰bïVŸºœ=˜“wã>¢Ø°J%a`'äªwãA$^©Ö%Ž{[ÓÁÞ|ZL¾À�ÝaÎa¹Im » ˆÂ^˜F°uÎ+�"Œ*Úö*òžÀâË€?õˆ++!²ÏSOÏu¾è\$¿¾Þ 6[˜z¡AÜ{1‘ÖldF{5 ysë(trÒélë¡ë'ôãîê¬T> ‡g¥Ä{7¨0hf›=æÏÞƸDCvh "MK¿£üi´üĮ̀lÇjV´&wøŒ6¥x’[xíÙ8íS¸ù㠱Ǻ5v³ç€–Ìñ@*è1öäïîø¥Yi*¤ºÜ·a Ĩ¬4Ý´Òøå¼­ÈŠÌ>þú*t†|ÿÑçE9m×ïþÔh6›`¿9´5½+´åÇe¾h'8¡™µ7[ªíÇ­G‚vq±3O}7FÈ4SJO®­½ègËq³ óÌÞ¤yú,Rv$è;ˆð7 óacžYiï4ÌLFÞdãöær¦TøòÍ>c·>y+Úöü¤Ð0t³{¦ÄOì‰Ó$µ)t‡cJ•n»QÔå¼'€½ù—NÎãa˜Çí¥½�"³:S”¦·q]wîÕ—*ÍyÍZëQ§Ov0ý®W…ZƒD¢ªn Q3æê½"kÇ1«¥öÔZVo £wRé_þß Å3âè·ëbw—±[n¤·Ãâ8µ¹ žnŒ{ä‚ŸŸž†/2²±¶°]zqÅíUŒHGÛ ¾Iö‚NÌÔ÷½SÎ÷¨ô°\{LÁéÎÛ×:aË¡F¾Ã†¾t\;9/q^߆*!…WÃœoΞg‡"ÿÂr§?íZ¶J-¾C§}T£²aò8Gúh�a³£v{)‚Žwz;‰¦,…‘Qã1Uü½µÍ�”©Ýþ´3¸ï×d•+L¬øúœ¬$&À«ä-[éŸy_ÍÑ]æN*dÀ•è[矩mÐ(ƒÃ¹z¾wucp’¹‚02!ô%Ï*™1³‹ zÐ3“•a/øàq¾RWßúŠ ±a°6=ÝŽvr‡›P0*7úäL¥L}ÀúÉι{ôS¯¿¦ˆ\Z•tÐ}kgpe_M¸s7KÕDßí`3ÝGk2öˆ&!£ÿ„êàí2ì&ô°OÒ\xI­b¿QJÙбÏBÙ fÌXÿ++3…C‘´˜Ô utá/ªPÚ³ <)¥³W~jS¸Ðè{œ©Ì_«6t¿áôK¥<ô~nYÏE,¬­AD&FdéÇêPg×–PkCÑ 6bKæ=Áë°×.{[/Õ˜|§L#O«†nÒQcrš‹Á˜×†÷w®ì»f¸QQGÆ»=»ŽT¡òƒ6+Õ¤½Ï²ß2½B©ì6IP}keÇ®îsl5kß @ß¼<éúºj˜ ¡J²NƒtšD»J„› Râï;6,¾1ÛŽ4#-úA§?Öawì6æs ýNnŒiYÓ)£Žtæ8hÎý¨’äe«x¤®Z¥ØûÛmq…q‰ð.%ìÛoU› ¼'ê7àé`€êRntQÃ?ìCõOÏôS‡Ð{»ÓûˆŒìƒâ Ü µ®T{YŠ<¸ÙPd’¶‡^¬3ý}{§óQ.ü(61¦ß¶¢e¿Àcm5v3 ] –µý÷ì˜ÈµÌ…l„FSšØv*Ï‹=Ž)†”Áò·”f‡Nwù�k›%Î`s£ §_’Å«ÝO¡º¿öµñõ+äWãÀj«ÃÁt¥Õ—à'‘úó_¾wÆìêÛ‡ïɲ%•€ÄB)WÜöž#‡xŲýÝ©3•üXÕFУ«}mmÇ ýüE…3Îhû\}gÝДŽæè¡ÌJH‰q4qÆ»Ó$ F¨ÌmÿG°™7’©¸t?Brµ½xm/Š*@ïñ™PläL E”®¤(-+Bu3À…ü[_îÄùºÌØþ#€?paÐÛõ÷Àÿ‘Õ‡e©FìÑ ø±Îb ¤ÂÕû<Ÿ¬¥Zë/¿7`^eù…eQ¢ÈSæÂØd}â ìÞ¶'(üprvõê·j…¨²—NiÝpùÓS´À„9DoÜtÔS'ŽMKÄpÕ+㕹>›vüž™zbù§èëÑ#FZ½Û1 òíÖN(‡/ÿmw3<—0œ¸8uì¢ÙÖ`×ä½¥Ìs-ždãÓ3«îÉÃ[Ns¯†ºq©}!&Õ£¸ØUb²å�¢õ 1YE;~çóR¸á<ËkÑ: _ Ž’Ãê§ú-&Ãm«Aì•Níp`Þ½ˆû;·á8u:™ÈG*ftxYãJˆIžõ§Ð_B Ãðf~è²iÚÎ6Õ-‘r§IùUŠûâ©0ιiÇ96,ˆ–ÿ8ðˆŠÏ(‹E¸@Âë §HBw54÷êª øÅIôt¡!_ TÑãž×> sÖFhÃÝý÷¢ëjãÖ} S””NÍ ­Ñ¯SÇ…¼jX×z€t³.%ÑVVØíõ=:d.5WpÞˆO͉¹hrfä1·5yîÈÏ×½K*2økMär®Ûj9Ʊ¡Uê(ôiñ°ôMÄXâå>Ü‚9‰ ê§Ô£\3=oҔƔóïåæ?`s˜Xöåúõ¾€¬8Ä¢+CűkɬÀ›þBÉF¬¾Ë{¢/VU75<ä¡COù[§`FÑ^è žé²Þ æ…&ÏeûpÓ"ëoÑ0æ¿õg{ZtËü5ùÔ~p”ïæ õÞÓe~k›'¦ÉŠ`Ø¿³ Eø4nPËø#8ÞóÇ'h¨èÓzúà_ ¿DÿS©k^e¸ �…ýÑ#°- ·[V˜º·­¦3_¦Ô.Jƒ¬QoÏêžñ MsDÛùp¹ÏE}Â%*®¥ìµõµ¦pÀìŸìÐïfvö8Ÿ0HH•DGmaèµâª«RFrÒ0‚à™ñu„v0…3­àßS%QŽÓ!f Î$²K¯aðÉ€Û3° V¬÷Å—õ*Œed{¼:%A®+*¶r²ïØ/!â*ÕØjkxnû’¥¥ýÂ,øšS*óué@Ò˹¶µ¦yóèŽÓaÏ+‘ Ä<]ß8Î<Ož˜y›I}*&*‰Ùíw½6gà\ΞY¾·Z_•)’Æ>y†*¢cÛxëá¡p:—hnà½döÍ–…¾sž]‹†H_7'ÛC}Å&n<44ð9ó>ÐDÄ!q{ƒ­Zc¸h'öS>gW‹¦qmL|dö£*DÇ#¹)Œ‰c_…†èê²XÚÕasØ°RJ·ÙMwK…üÚCÝw¤ïŠR‡†«¿k¿Ç¥ãd „I,ÙIÉ”f'¸3›?×¼ÛeîöK½[ïOHiy%âõž�ÚõÐMz<%Y#bÞƒYtë<r}lÁ?+î?­Á˜ Æ-®ºWeÉ_²P3ÏI´`ùÞ±¤ícE¼sð„µŽÈøiÕÈPãòÑžXgùºpXË ‹’6Ò`%ˆÁxÞît#© ñ¸IHUy;2M²Õ6­‚r«Ï»È ,ÄÉÔòLÿ)!&ÊÓ¤rs'äOrQÈ(7Uz[÷IÝœòù•!äY¡1&ŸabyÔUS,+¡ˆßw²(ve7Þ³ æ3Dä,Q3Vt::¨1ê8hÝqKϾ>ÔâÊ©±su®“ }D–œ®° 7º¦w>àUZ, ÿ(†§G}~š„m?0_Ù;õ?ii¥'¤/ ÅÊ+“«4v y9"vGJ•C;J§£·sE4U%k ‘Nk¬Ñ3Ÿ�@5Vk]»‡¸Ôƒ©Eá{ŠdÌòÑZC$LysKó•A:a|9‘Vë’ŽøãÅY™éˆ…yñpOÞ¥oš ‘°ÿ8·Ã¡Eaß¿ÆM¼i  ÷}Vqûã& ’}6<³ª‡ÍaÔ-À]!žçþÔÎK--éVÕ³Sl ©ÙBuõM ÖLé%áÄBŸÕví™  Mhõ79›7f@¢|͹;wƒ;¾aUzF0<bÂI:h,5ž˜¹Pn¯^>DOR›J°»ÃÏÆTiÁ*ŒgJ!/L8À'ôc8¾Þ½CQX,Ï2vÅIê…œ-ÛÕxXK?÷™N›&7B$ÓLaÀŽ±âð2³¶»Ÿ·l-rK€Ó‚>£Ä/^v5]# óy¸(2})•GBÖ3äpâƪÀwŠÈB>Yø 4)=sÞ³ŽÛ~¡¯ÇKÙËŠµ”óÉ£­oë3j+ä°ú¢KÊû ¾}½ÐÅŠÓ*µO À¶:èm»‹×?­' †VøôáyÁ}ö”™0F g 2j}öoÆÍóúK}‚nµóž©è¹ÖµHÞ‡Á´¡snîœöÓg‡ YÄq¶;V¸·¯ïx2DIîÓŒè‘îó <Ÿ="¢u8ÓÞÌ[Â^‰gê—³ˆmAoøsòts©Äl”_ö]£òp7±�üQCl—êR4“ˆ!7ÚïèîÑ–<èYlpíŒZb²A179!øb&vOéËió½^¼Âã%>¼7c7EÂjR[/ToÛS¿Ð(~“ƒ·pgʯRVÚ;^Æç·U«*¯b[iݵä¤ û?¼ƒ¤Yô¨"£Oç«í–dÖ ¸ùñÃTŒ `¤­‡= �º³‹×ì4UA4J[7†£5Æ^9“)M÷Â@™¥t7âôË}9Ä ¦QΚ> ªc­‰Ú–~KOùå?¥'òaîK…~¯Uxy5>d{rG5`AEÌFO½ @¦ze…è¹³Ý=¹´HM` MRý)½Ï§²wÅ…I5¼~üè=¸úö®q†åÓ[Í ±ž¬:RÌtæÑa{X²r¼ü‚'ùL –ål; âI§½êJpÑÒò1ìC}›{ßáŽkó‡×Ũ¾Ë úÜ[‡8€ø¢Ì˜õAî¦]þF^)IíìN×j f[{®Z›]¿®µ ¢_x»u½ëùÄÙ¾-€å&’ÒÏÊ‚í‘îRv>;{ní%}!‰Í§Qh·–ðüšúœ®)Ê’ÀŒ²®ÆÚëŠZ8ˆ*M¾áÑ,,,!¹¾Éƒ¢™\f*£e#™aŒª®_y†.Á¥ídbiŽÿ *¿„Ú wC›i€›j ¾¶F±{µ£x8tV(>°P>À{¬Ùc]âU;q Œ×t†�íH� oÜ­Õ\{Áº¸/%rr ~ÃyòÊÛ°Tlü~£R}6ÅkM,M+k/–{G‰,¸_;šZeFIQpît'¶ƒóÍ6¾æ‚;ð<nô ”¥Ž '8gø˜“ÕÄG’¸´JWï{îoÚ ˜p¿VÆž÷`…¤S4˜¶~ˆßƒ«ˆà‰øRêñ]d 8ÑYTl>=:8…XºsÌ xH³ˆCOŸH \¦O%e¹?nẹè ×–´Ê–.ŽÀÈU›µ=jPéS,7ø_Kãåž)§Ò¼ iQ/3q¼¿´û1//Y^¾¨[öÌS a¿~úw·šéO¨õžL"?¹óž¹ïøP¿‰C ²i™àýö]dídĦ¯3øÌ•ÝÁ4ƒ §‚é�a‰íÓl;ìa¼°¹¤²øH;;·}Ó8ªoýCÔÜ>g ÃÏ—ÕaO!G_ïˆ^ä #ãÖõ: òí¤Ùk€w¦Àn¢>~iMUåôTÜ'ô{îhÈt^}ÏfXŸ$ÿ|$¹ºúE_ÖȨuX ÛŸþ“�½óy]%&ÃÐreÙÜÊú2v­/ÍôÈ@ö¹™¬_0³ôÖÔE°ÖÕ\¡@<n)œßÑŒ²Ô×à +0J/GªÎ>áPtgü§_½Hv˜O\¡G£Ü¯bœ¾P>ÙIEr 6‡5‡ø¯‡×2üf©`ÿ Ís牆uûüä£&¥µ·¯-l;úgt’Ê{® ’ åï_Y´ç �DÌß´~z´Ð†çÊ×»fœÚë?0ÙÚø}¢Xá½6îÅÌᵊàSæL7±šlÈâ„­‡Kx ‚Î ³0ë.ªóÅcŠ´õ¿;"HÜy€øÕAC‡^Ýä‘“jbv%}ÀaL‚dð¬Ž]o²jõpçU[Ã¥{¿”[6´Íj}?œ³×]Í;ŸghŸØZ“ŦAÅ;U…“g€ðÉPoÑxEš —\.>,é¨=Ym)(7t5­¾W?\i†7óýb)‰SC-- |²ïÐÅ8jSðã>5ÜV|WÂ:-Ä9ôG(—é}ï.ÚîöÛím~ô’‘˜fN©$?yú´­ê¾G˜µLG–ÄFâ%³c¿|¹±’÷,.Åkl`s´1y>?šáGG‘b'6ÍÄd·<¶âF•™’µ¸<GØÖ«/ …¼¯ßRV:÷¨î\G…E¦e‹EL?Äq‘7´èU}Ú†U°wÉÞÐÌ\•)ï¾JÏ™Ž[OçšV‚3-f ¬nvNa½WõêJèÎ9¥ I“Ÿ¸Öõ› į ź»~ìsèEø*R*íÍ`½ 4|\È|‚$M“*Ïì`"®¨  Uqš-%UåÖôŒú­³îgGÜ+',;‚ÝØ–Ò¤“Š2–L/ýÓõfÃ9ù5ùüF¶S)V[@¼åA<ª ßs&œÉ7e>fÎ*;¦¹óöMóœžiÛ:UIÖO§Gʉ:W|3ô>> ®÷cž¸ržýIéàÏƒä¢ $ˆ.k@41™0üÆ1%¢´ qænk»Á`ï6;_Ç ¯ï ÇÊ*[jS~€Ûïݹ4†áT¤A¼Œ›yüûì.’Ã+½EK4ÂJ¬ð9ô>M™Ÿs'ÜxÑkCîiijÙ`i´ó»›´ZŤfNˆ?×ø×»aÜ^¸ßìáw»+_Èí»Z‚ gÈÌ6\Ó2ÿ ž×àñž¤mS‡Š2‚Ö5<£m� vPP@àñv5(ù¼ wtRº ê;Ž�Ø´®Ñ±û÷òÁÏq}âùƒM^õu)¾éQþ1j$äÓÏS⧳¹çJ]oÃÜõ9¢¢7Ñý¦Œv[3Ù¯£çwu°T¡¯R@±tšñ©½´èr8q›Ó€Rx[ { Úüâ[¥ÈòæÒ²ÅŶSƒ¹cÂ=ø‰VO÷`yØõøgè'µL¨™­4„;¼–‚lÉ"t³âgAçÃÆg�¾ª¤žéò¾ØgåI€°/ãjÓ<LÍ vîTˆ™r7@ÿþ²å\-ÜŠ÷{è ~jZ¬c(&¤ ¢vta‘*å]ï[—OÜŽÚìL4þ1éˆÃ7ÝÔYC˜1oK‚3%+å÷ÖL‘¡ÄÔKáô_"ʾš©FÅrÈ—!CÕ\ýéÛ°854q?¾¶£¹gKS,åô‘…ÝК‚z‹Ò›·¨J‚5eC+[4Üå9DÆ Ë"+*š¨P?6^³§æ�hƒÍ£ÊȹkfFqìØSc¹•Ø²G"÷ vkÔÈ–]\|ïiCydúL–œ•-Ó)ù˜ôžÑÓ9gáa?¸\>OT(õ³¦è|Q)äé4ýᇫ£WøÌ)¬à­ ¦¼—õ[ïlàe ãÒÊÑ“õĨ~ǃ/<nn¶žÑÛ®5à3;ÑôE¼ª˜EË/,õQtêßI•ªÈ2YñÞ*ȆµmB?^ rW0EïEgü…×m͹EšRìü<ôÜñtÙ¦ïéa8À e 0ùa[Z»‘&‚ÖÉ`b)êÍŸÅÅ•oËÊŠ¬¶Ÿž‚3 <õ5ÊçÝpÕ-î§U…þ\9,�ú§ `VyØe÷´Z 3.3"'¨TÖ‰eýÑ¿¡�¤‘³Â …sOÒ¢æXB`_‹$žÈŽÃa‘u<qû«2×)hÙêQ­C¡Õi%úÌ­aÁ, TQÊÈg¸(z[$Œü±<¹çÌÍÎùöM3ðàµöj ñ ˆãiíl·ë¾–c,N¿eÅ^·Ò0[�OË cð¢Uƒô=è)¿¢DxÞþA™Ô¸¶­¡™YER¯ÝÂgW%°Œ’\øc;Ó‰ÙmFTùד¤DµFEUˆÞéx>m"CLMÐq´CÏ^ÜHN®ò'lä(ö&�,‡û5ƒ\pÔéxn;Rì~r8|aAõÊ·Õ)ãåm Eì6>NZ”–,çøÜ߹ѹ}>cNÂÄ!³BѢƀ̚wV€fí&­6M_¦3m™«W# ¡û;AÂ<ÈŒk÷³ugæ/Fìñr®™ÓT•5 @‰òå€îz²¯jz´—Ý$òl÷ì¾â8qGJlˆ…tõ'�ZŸ6'Ì ¼¸<.è㷔¤\Š9Q•M'DZõ4Q#{ÓE3ŠVÒè¹#îù“L(ÚÖ*Ý0-dÊ'ãg§è {“Ž,ûf¤|^–ìò;ú´¹}wTÁtHÿÐþ°™6”6è“ÑÇñ�?ËvëúÝ#ZO¬z 䬜sSŠõµ;R¼j6¶é‡û€§Õî&ÇsTW@}õ]3»x”L „vÁí70GnwæhÈRC½e�š³ô œËê0DBiNÄ®.œ ¸„Ž¬W góü±é0圞úÖ¥E¸œG6 ²8kCf81AÃb©GðÏï7é’ÜAЄðÝ œl°¶ ‡kt¡¯Ü½ ¸òD«^,("Šÿ†7$ j:á¶ÚÑOãÀRÚ@˜2´,ÉYÑm^‹ ç#ÁD Äçç ò@‰Ý÷lGœù’ »‡à•¼1»ð‘Ž £ai–á€Â5Ÿuƒ"æ OÐ|‰äŽÈˆÞåå=Ÿ­ÇYì @Òo·TUžgY†V(¼Ø8Á]¦Æ5o#*âù„…¹3:fT„„qyÐUtù<&�ï5 "[,•*jgµèg´è…ªØ”WûmX̘&*A;;bùk·5Kr7¶¥pQ¢Vù“ûÃ@å¤ÄlÞAÛcC)ØôÚvÜȶ8BzÒ{}Ïž™Û‘J†¼¿•[œ òéË œ}‘kܤ“Sgì1a ú¾ÎjBÕÝtŽ˜¶x†Té§2Ó«¸¨˜ßïDL›çÙËý´ÝaÎ7~}êï÷¼ª,JK››CÅœ~SÒ|úJ¿è;˜)¿±Ñ}«B±âKqläP™g“ô½çSb‘8FÍé Ç&q€¬›Hä&RÛ½alÛ ­ ééÒSÕûLn¢t5ë( ]BÅþg¯£¤4õñbfoñ_JŸŠ…ä»Çp›4tlN†Ûœ‡"H>OŽØA5Ïà)L3ô)U'ýÅ‘0{³ìמ݉êJyõí£¢;[NÂJª‚ Šjõ°zµ£\ººåÞ•æ]Y™1&áq ªáÒ$¸:ÑŠh?x¼õßJEXKW)@f¢#±ýô¬Þ÷È'é\ÙnÈÝ«ëj©ôˆ×g#uaRRš@qª;ôÈbçm»ePcP'qv‘¯Z(‘…îMÛ{ð…Í¡ît *†ì{K]LüçHÕã0Rrn½çâ’](»ãÃÁ9§ ×@޴̼pg°•lh[O*rÖæ[3¿cÙ‡÷žc¹Ê7b ú¸¡=Zl[Oaq ÷n.<7F 7"½Ò{róC7w|:<Ä.N¹mîØ´M·ú:;uß7@0e•yV3@¢Žé¯“s «[–®ž”1jÚ ËÌÛ×;Á÷Þ½RõEOqŽë¢sJÃÊÄÀ–xæ5göÐü¿n2û¿/†´ y‰’¥ë·t”õhþÎëóJØÖ§¾veÞÁ •�Îô«6ÅtMRÀZ)1³ZÅ9³Ä{ʳ%ì?nŠ6bìµ)«‘¯"W3/U_"/Ï}Áʼn’ Zÿ¨± LŠM ¯½åÇ'Eê ¬æ5ùG…"¨Ä®zº+”º¸qøCìdT¸Ü×¼}Tl¤œYùl¬È "ä5*>˜îl`­„¼$*~§1!£%"XþÑÍUÓ/*Upu‘åY.¸Ó”óáï7/÷»{vʪ0!{iÐ/¨h¹FÞÙ÷“’;èˆðI¶Ô§8äÌ`¿ÿ™N” ý³¯­$Ûcuc͹C‘M+ƒöRÉÉŽ*#Ø2Ùô1èé]?B„¤™o.Š¿NÜm¼‚ŸÈ²[r_)Ê<—îÌ~è ÒO•I‹•‡"Œ3+H½ ÇiéË À–ë@Κª¢Î/V˜}®y¶=GïÒ£¦‰¥t‚XÿU²pœ³,]Wègõ}eB‚¤rwG…?¢€xÉ„4´ks‚Öü±ë±*™¯Wÿ®æµ+*⤈×8ûZ†çvÿš¶ÿ/Õi ~Å‚ÏèŠX'4–úñŸ;·¼[]‘¿Õ±Ò6‰aµ}Vã5YñžUÞÄ™WŒ"?ê‹ŒIn¾Ÿ:Ú†·¥ug§lÆöE Ô"q:ªÃº9¶òœ½RÕ­‚§ë!úŸáÐÁr*«*Ê6[ªu8C“Õœ&í©›†5üüï:éàšÃ^—tâ a–ByÉÓ ýV‘Vîý€2µ9Ö0ÎÚOÆS!À4©ž>Ž‡óeúå$ØÁ‘ÇB¦‚‚ýÖÜLßÇbúþ¤ÓC‹ÔHõ¹ ‹7 ÀLÝlÌAMÅyÜî¤Oÿÿ磢¤©²?¶­Íwè“‘‡4ˆXÎhcˆ%ë Ž¶ê §¿¸Á¯‚;fŒØ7FƒvÄ},ÈV–tX9ÿŒR„$òO )Õ Âù0?µUuÃÜÒˆòlNnìô#ë `ž'#.!Åž&1ýXӑȉÀ•%@dz§¶%ƒGe]ç”r=m¼x EuCd„SÛ.ʂ𨭰Œ©À[z`RÖææbÚm€ã)¼ÂBÚc–†Ãð˜Ñqyqü2~<Ò£Ó¾XGU8¶™–Ž6¸ |šî( y]†èŒ{¾¶';Œ9SÿNŸ¬ôu<0w@Gµ”™TÒoáhÚ –)ì7Ußê¯BxÕ p *¨Ø>À-, >_å^4»Í€¿Tœ+,í(ZAÝ}wU]Fn)X€$åÞQP5GO{OªAåý†ÍÄÒr"Nc×ø9ÿž¡é¿í}å£Ó`&S" {1ð“;Jð.¼E&Yhç”íFKº3¦FîÇ�"n.øã”àzÓ‚ž£8Í<CJµ÷t•ƒ…|¥ˆ©a]•Lãk[Ò®]1áO­½Ëû,¯,¼2mm kùÝû·fú0s…»ºjÏ$Ö¢lñþ‰€ïâKëh…"§7m÷wgQ¡`0=ÿ³õâÈ¡þ’CÚzšý‚œ¯(fû¨W5E»£…´U¬B%߆S+ÈëAÀïÎ…DÙR„?2‚±ËÈ×Ä´©{Gã#>B^!=2Ûýë®e—É^Ø ú÷öf/ÒzæyùC ppÞó/X5©ÐÀˆ®õG¹z†Ãó&~oÄmþתÛÜüÀ)ß„ÖV–Yº‡§St{„®Ç¨r¬àä¥óeæeÁÉãAëåö âm\úúG´CÏk*¬¡:jºÛÃÉŽ·ä˜8ã1xµtë±^ÍÏåØ=>E‚±í× �£U±]ÀÁÀõNNÅTÔÚÏŽÛ³Ø ‘Ù6ʨ|(ž{¬¶‡ƒE5Ñï·.qÆ¥Á¶Î¬{Ë×îÞe>Å–žØþ‹ªãt\L¢¤dE)Šþ¡“ —Å«ËÂùìîÝö²L‡5%0ýÙªf­Î…hÍ‚Bg„€¾€ÙŸÚ¦(Kƒ ŽçV¼LxѶòpŽÒy~è~’†~à –éêG¿‹{køØzãéø +2vf0MyP|~z>KŒ%—Å7bÉ£ï.«íˆ½\Àv¡Í Sb'¶K‡½@0,½m)sa‹“ÌáêR6SÙÐâJ¶“C2j…)¹(á-êRnß?»á('òG··˜¥ØŠ|ôïŽTYntJ·™µ } ç'£ù,r³ˆÊ:E–“Þ‚¢Òyù¶ìy¬EüßyE&…ƒˆnÑâ[>*ƒd½?f&·;•ÝD‚I7,†8/=~£Èh$1¥h:úUÍÙ k©y!—Ð+hÌ]îqÌ\ôÅ´«t Ĺ̦ÏJf6nçq H)¤V¥‚㲯rå]ÞA'YK Ù>’¹&¬ÖŒ¥)~Ëô¤Ñ‘Ë4q£±šã¡E¿ºfSÍE*KùÆF�•¾íµí¹äF±í huvž,1hŸLÇ1Ô*)¸¤çe {Œ)&ª�*|‰êò!]qðß ºÒ2\hŽ§˜ P-Ñz¤=À®è?-Œzƒ—…záÆ;x[ªm¡CµÉ}M‚gÒ®,—§qÿvg™Ý{ø¬Üƒ )„kš‘3¼ñë<ʼá)LÕ"Äß—{ˆ�¾ôFŠ!”q±fÁÙ1L¾œ£üKxo´6[&sÚßâ±NQÛ„P7¡BA9p‘çapÇ1xö ç Ã³úb7íãæ F"·0ÿ<^0ÁsQPÛÙÓ/xÕ,l¹~'¢•îÞ‡XŽçÀM±0ÈôPIª….à ±Éõ®óª’Ò“‹çB’ëÙ0x…V„1U©ò7”Öã"^xΔ,÷ÓU}½9X}_Nö•¶lQÄþT�IÕ9ÒAû»´â77.×ÍG’†–á/1 âçÕ¬#þ,™â\˜˜Ã â‡xéê€ÓÿÖeò2DŠŠP¶Õ"‚Åyÿ ‘ŒXONò`Ç$òŸHÈ 4(æ“åpF¢ßOÅí´5^»þ(B¼3EU“Ü>égaK…Á<ý’p{4ø‘jåŽ廕•÷¦(4X5: ó¼ÎÂ>V[ü-&øJ)ÿî¿càý D#Ê‚£Qá´ »gM°ƒ1&faÖ¬™Úà¶cþûœ'•^Ñá×tpµ+“ÑýÜ Þ¢ýp¯â|5r¬\°dš¾ âapÃÙsÝv&Ų ¹‹÷åêŒNÝc#9¬¤48À1’„õÎ;Tªi9u—ùY,£˜1éI¶ÚD,‘E‚¤œ)y¼“qžzsàãà ,kƒµÍm­AýoÑÖ¢ÿòbH›êQ —z«µe2¹Žâ±OEk{íÓMÝîk«»h$<}YWÔÀ±¸䱡2/‘„0Mé7;@úDCéûÆAÝÓûY¥læáÑÄÿEÜmZ^êÕÍœÈSÛEˆ¯Øù<Þþø–RVÎ$Æo8œûŒîª75Žd8ÚÊŒ9;Æë™réÿî4Õ·ƒ:ob§Bï³%A /hGgYgF‚&ÛØ.¦ßÑiŒ+g+"n+t¢ÑIÁýkOûëé‚Á0Ô»qZ\S�€:°é€êQ*HjdON­CÐ;»^;¶�Ì´ùÏãkiàˆÎéÒodQVÝOtwÊuëM2×hœõ$ Ž§v²ªÝ·ølO)‡]ÓWt¨©~ÖÜ¡ŸPYú½Û‹oD(GÞTIùi¿oö �X«À`s‡mY}{aóÆÈuÔ°6èfµ5…Ì‹k‰=mo^omÃT5W"ñ†ÏÙ·.¶éð‡3÷yDæ͉¯¯è–Ê<}\UÄiì«áÒNd·Ôy´';K‹ó£¦ÿ¿1T?!º3—Œ'O`ƒ‚=.©žéQoñ×kÍX•¾¾$ú¦cFc8fÀ"ëT®¾XÜÔ¸—Ó&=ðLD_”è4[6u œÕ±¿§jõ¦`šJ&JÞ@[û¼†òÅ “þ"¼½_¦5²4€»ã}®[†°FìW=AEt#j¨(ˆ—}›iá_¹ÖD™cå\~Án½÷ܨéÇ™¨¿ðÞ”ýÅqœZi.‘|Áœ�6±“öÿ²ÜhN´ÌfùªÝÛƒX~ ¬`OÏÐÌöë `yõ°}äÀ¯áyì³+€ä�ö¿|:P.ÅÀL±ÒìÙ÷M¶“ ©¡Í ß²­‚‚*ŸP§ÿÂßp�¥o1ð­É(0ÿݱf6 =ƒûGÎfN0B(ëÿ̓Øz¨D´gèØ¡�äøT«Ã¿¢]j/nÝ|"pf´Iè]›“fŽ!‹ÃtNvîÀžÛŒO÷GXø¦À´æoôhço7N6t4“¥In°'TeÌËoæn·š¥—º ]Ä!œ›íA‘gë¬ûS¿œVjîí_Êš¹ãöyí œdW!Úé§Ír6ó]¡äÁ{êÙU.Ó½qC÷ÈòÃŽ­“gwð@HÔ ŠÚxe4�ÚšòÓ¤ýôä €üÅX:¼G½ëçÆl†9'I?¹±î×£Gþ”râ&©,½SÑõƒî× 7x)è¥w Ÿ”ÕÆÊ32ôÚ×P‹¹úž…¬»Zlq—šx=×3'e>„"C’ÔÓÔÎËW#³0ù"=D£j(½ï÷Ì÷×¼<å‹_èóÆ¡‡ÓàQW^ÇVêRZ÷ØSå¯9fbÝšÙÙ LêI›”x·Ã,y,b¬bRÇ‘në4uc|ÓÄ¥È×ÅWÄ2Éü±p‚õ¥ínFœ]{Ï°__úý¤…£R4oD.Á¦CI»qN ³é ý9Ín³Õ¾²÷·d,åÞšvÐçè¦Zq@ ™ÿöé:/çÌ Ö§#ÝŠþäè°Ì<À"κAìÌ÷ÎÕB’kat ‚YMGi§ãw–ɇöÅñ;÷K¯ÉU01q‚ —]ÀbXÆèâ¿ÝÐ’“_ Òt:¬þ…%ZqÁÉLgÄÀSξ«÷¦£9ëëoÏÜ^þÒWû sç>&xÖ<ª9F–¨“Ù=d©ˆ°L…1Ю3:†²W„5"ÖníPcÇnøBëÿ5®¬r»›}é§ ¦¯š²²a*öL—…vçØÍÊØŽ3Õô.•õ¦X7+¤kþÔºm[«{ý+! '=(\lXÓÒÛ®?¦æ [Ú3 S(Î÷åZ„%iÛE£°ÎÌ´8¾£rþ† c¾8¹Ã<øš³ Ü~/eÈ$ïæôØìð@Þ3( _¡5ŽDð7w’étvpöNÚ†Þdÿ¶æo”jy¯Tl=§Ù6šÌt–°…™‹Òh1£+hå%¬d®vðÈùÑÈ’V‚#`Ò"Åì®Eù{èYÙçjUšKþµxÄ-¨%ÝX½qCYEÜ)»Ú¸)» {åí-Ñ×úX©EíïD]3_ȗ˃‚ :1Þ _ÊNHUº;‡o„($轩pÁ£]#=ƒ c85Þð%}ØÃÔP%]¿½¸S€¤¥Ëµ¹I!’ý}íÑ)qL}\> Ùöß(öGÎú3cÿÂÝ®nö”QWõ<‰ãõ ñD«÷ZþDµN;e’“»=´˜ºÖ4ï0ëc­wnìÍõ±×ê*ë‹3_{¹Ù)[«Ü}þÃÉBÞ8£]Ó%…€.¿{Ʂž-5¯¦y¬¼a4T e:¹é. msÚ7wѤ20KjéÆßáˆQîæÒë¶DE.@óz‹Ó+- ž«ÈF@Gå'€¤ˆI�¸* °Ÿä\¸y{ªÜ×¥‰&ÞD?ÏñnÕ­vÞ8û º¦Ó·:áU·NÕH/²/é?¥÷ásÀ»¼;.O¼Ö“ô&¿ £þ´^)Éó‡Á"Ë;õƒ¿ƒ³5R¨Æô~UºdŒí„�yb�-\Sý¯÷T©¸w"¦œÁ™VVaá•`ÝÒŸD•úhhÎ0!mÐs¤½³Üc_Ò R-¦ Ë!Q¡[Ú¨Fº8×Ýæ£ïÏ—Ö˜û O/t.B…pAo «Ö+ Ç»2ã£/LZ6_zòΑ'wÔÇ´X¬-˜y€zÎb‹¡W ÝÜ˯ðpQé[iÍí±{›;u©N>D¡÷>–ø¬8Í8žñ™Ã¢¦N©ÔêNgT'þCj:“©„„0ºäS/¿ƒÍR¶½Å,ÇÏ è~zŸ Jg*PÌ"¢`Õ³ÐðjÕwV‚ÓûÆÛFEå«Q =¹¡ˆ÷©ì8LT×BÛͬÎQ3ÝN¯n¢•7“­0“ík8*:~ÌÇ?ÌŒÍê/ƒ¿¥MËH+ ×,umZÎlû¹Ð‘¯Ü *êƒm—ɨÍ_]wd“CøaÃÎ[jÜÙ˜–弌^Órª\UεƒÛ§& ²NG¾)Há§vò̸R¹­/ÝÄ’»¦Ú¾íÆÞùÆ1D…Ðב<úÝÊÈßMŠ5®µßŠ é­»ì áK©¢×ãx‘è–ô4yá°u35ÛgCy @h¤ƒÞ%ÏÈ" ®O/XfäBÕ"ßLþ3¦/«¸D·ŸÏˆÇú Iâ´ò…Å=ˆûZlK>yfrj>²_ÐWª¡Ò…QÒã>§sxð´VèOC²äÉ2=ã' ½�5*öÃxõc¦ªdÌѳ¼ÃrBK[wæG«# ïê¶ãheJƒëB*‡¾›ã)šþÅKì…š-Eùí)ªÙ2ιƒL«Xn5Köñm ,‹¬WÿhoÃïK1ÖI=•29T*‚¶W9&{ñÄG3K>d”JS©\ ëA™å”i7}‹½g Ü`a­†ïqw³Íà«{šuà&ˆb&Ê ûΕ/Æš5Æ ­-^´ä#°¿ §–‘¦wò¢˜IÉηþNn)É™´jÂê™ÔÌwÒ$ÛÈ4®‹´~Ê ÿxÙp/èh¢ªJ �´×à÷Ì=]Xs1_ŠÞ2Ÿ”¡Íê½"k3 ̬Rv?d±Ãê»Í¦k âä¼Û7ÛŠ¼6bXžrœµ<ÉlµVç?ëH·\T;´°œe>œi¦‹Åð.dï:m—³7ÅiÜÞÁµâÝKý;;§iâ(4ŽŸšî$…ÿYí‹÷ü’È6vÐ5cÙoÊmÖ:½ÂûÒJ‡Z¾±W–«,‹„*ûžò·Ó•ôhSC�¨ŸÍh:‹T¶”5”Ë5§ÁRsÇE;?]êgÁîHçŧE¤ø›ÿ¥bm!,×(ø[4|/äFà) 5ÔU[ OMè×\8uYË&L»‡”èZ(zR^ÓÑ OþÊb7®®]e¤L¿Õƒ´?�È&\"J9E±øB쮟3¨aI"À®¦m±é˜Ä¡‘±í¨r§”L|3‘ Ó¿Nû²Òë[˜È#þFF¯£§’75Ãõ›û0݈$oG»¼>‰„ÙaÜO8:$Ôx ä•'QbSmDå ,„ŠŽ'Åöõ™‘!>84ò~lô€Þ !,) Iî¯*føuT}Z^Œ wË&ï”1w†»É¼joCŽsóv:ÀXf£“Ä­á‘z¿/ä;3Ųþ罧î¹]CÁ±ʶñ¶Þâ<Ý÷Ž,Q…Ù‡Õ•AÚmT–è�Q´ÕŽŠ?æÃÿç# ó*ZHBzGV%Îéæ<:Ì…PÜÏ:R/™jÉJ¿6²VèœÒ®˜¦Â“e+Ø¢Ò]¢¤pÝ#g¾î³ÒÁ‘xdãÑ: Γk39¶@ŸÝû¡Î¢-Þd¶kˆ–ŸªG‰ëi¸®E/“ͳ¤­Phf$j«Ã9awZ“ÆaFCn¸â}„2OâÅþ¢›µ=2¤¡vD JsÌ"Y˜Ó]³"oY’i’U•ÃóÓs÷8wm{ b<«Ñ£J! - ÛO1Çz0šteÙ›R, ’`ð…ÅÄûŠšlàÏ.Sû»r‘Iâ&!¢“û R®l¹È²ñ@]S|¼«ý¾*óñ‚P'c•–iã5¼ÔÕWúïtZb[ñËÈŠbÖ9gºrä‚å–ÝòœÄío%øg…ƺ”Ñ°ÙÏäcÄ0ª«3þE‘Ci–¬¿r S&i| †ìLŒü”Üÿ×ÇI–©|/whèw…rйbi(9ß]]d$úèoš_@‚SÊeÊ@·nØ?Q™eÊ2Äð:b¨Šë{¹™˜o¤™½0ÕVâÉåUl\3AÀíÓÙw@â¨Q¼´L¾‹}ôç¢Lq §*(æoOPBÆL¢õðPÄP²fó´°Ó¡ó¨NÖ6×Ó’H±ôÈ››E¶ÐÞƒ3tHšgÁÊ=kŒèixܹº‘”ŠÔôeš(X…µ¿¦¡îØΪ :×ûmAJÞŽ¢½ 1wØáÂÃ/d÷/Ê1Ã=áÈÓ°Û™Kc ¿ì[O9Áf —éûa°wr|cP`Z1¶¦´ü¨hõñÀÔLN�>:o¶Zÿè8È]Ý¥…§””ˆäZ·ÊKBÿæxàÉïz·ê–øYc)?°ÐW=pˆ~·17Ò3º¦ª7 ²Á9Õ1Áæk8œ{ã#mD–ÿ%ghÇÓ½CWh$Ú®_¡"ØþäA:j¿‡uµG4ÒbÈÉLîâÛgŠáež¦™Ãw£ƒ†[c`[€þnjeµ)åÊQ‹°[…½8ÒÈÆ5.EúMžóè5 ¯ßèô¢ê§•0½4at]ÅN=•^ÃÖ›òÒ®Øpn<TM¨ø@Š(lLyG3†úNº%•O §gpø‰« µÞÛYÀÊ>Y»» Ò›yO;.^è…D©è†ÇOgK©dŠ¡' mã tÉáqúXã°ð†š•Ñ‹ ’­ÈAJƒíþŽ•Æ» ›LÈö‡”¾?·žaý‘O½”Oºâ»,I [g&»~URy£ÜmÖé›Þ :­¹ëÁÀc#Dz�/õz#åB²28Ióˆ¾ÅQKÅVUèüZ1t‘°‘怽X¡²§íêÍ­(é´UÁ¸¥ÀPͺZ0„h;/·„-LÒx·‡Ó$}K.gZùÒÀÞ|Q«F2ýÎ@°jƒ‚%h;ì1í®xD…Õ‹rÝì#’Žò[õEž¹.óÆЇ•µ=øŽÛ”¥ÊŠF ü[ª{>¼ ÿ(²GÔ}Óí¡î¤]w4¹Aå®uï’ă›À Ñ™~s¯’íQh_R6êþK<<väò|Ê|a�[çué±$1Å–±3=j…ì½'¯’ÄK€W4-}ì¨õ‡ ÛšëN>1§¯ÝQYÙîN›,ê’2˜ÑûM¾5€LÂǨÐ5¿ î‚6–ÑÀÿ‹`;¸’}”ÛŽu´Ú…0(e-ÈVtVù¶M]r…eB³’µæ�P¡FÒÂwj{6Æx•o;…Js“®¾õdö¤Í Ôd“R‰Ø{ΉN’Ü™žìí9{seߺ}Aeú¼컢ûô×e'$8 öluRùWt–8òÓ¸0�ÀŸ}ûPGîÉ6c1;úÝónÏco8CcÈ«ZÙÕ«Z¿ÖN 'àÖÔ®ÛlòŠrÁc·é!` )åm2'ÕW™‚ \´Ðf1ëÂÈ5³|ƒf§<‚÷†ÜfN±J[41{EŠ7¡Ù&”Iiý?ò.í' «…ÒV,ÚñߪÕËn_\.hN÷wâñUìtõ¹1t�}Y9 (—I3º;Wÿl»Lj}}%®_E&)HL+±Á¯Ù¨báÈ' ¡bñ<“k»!ÎxÃq.ðƒvK!±ÓV°¶Ý ) t¢·›…'·ª·‘퉢läæÀ˜0†-H§O;)ü•ô1¨Gå ×$3ŸHÀÊ)”Îœ”ù Ad?)yKÉ—/7åÊ(_0=ÉEÕ2½{ß1á5?)Y<S`bâ ­¬'þ˜N ¾¶™sM_wC}úØœ±˜–ß±³+j9›njÚºi§uH˜+èf Å¡Í,pŽáíÃ>'Œ�ZbòÚ eêkûDLsɃÊMó ~—ÛÌf$hÒÒy'0&ÎÖfEUQZïf†KCÑmRÁtú|piA†;5�ˆÐÛ "óΪ;Z×ϽÕ_µ�oi‚íX—AIKÅ„Ñ];ÐóóÔ‚û•{mØtí¥}Åçéîh$”U²T0î'Zó‘SMY.Öt¼Ÿäëƒ9°ÓíIM®My›ëU©¦Õ^‹Iù¶'lúÌ^bxÏÅ®r•?ý¸4õ·E+9àߨ-fÌ¿x7!̯Aíéw^ë"b<Pœ-ZõàI ñYÅÂÉ9yF”c·6½¸½o*d[˜v÷Â?ŨT—ú/)mZÕ¶ ÿèúNoMsq!òeÁž2›ªi”Ïdb„¸ tŒ?{Ûe2C s€×3Ê -±\jHþßL ª0ÎVÔô|ðWÍ^û½„Úf·Oäñ£©ÒTo™ñiªè-ÿ讯ø–µlì¥ ˜~Çè™Û‹#WçŒiŒê�ËNkMõÓÜaUŒÊŠÅ`¿€cÛêG¼5h;lÌ3‹^ˆÂŠÐ¿Ž¥¥Á/¾¢¿QT¸°5¿^5YPZRà]¿î»VÙäoæÉ¥O)Tf¡ß—¦éê}ê€Óý/ÆŸ•çÛZˆHZF ñÔx&˜aáR#aÊ2ë’‘ÍÍ¡Ÿœå£kÜI; ù¶±ŠEóx�Z i SÑk lzRè)à´“>‡ñê]"Í!ÎŒ`JJž‡¢#iÂb^Ëá'†…ï B‚ ËTB6íPQEºp€q)1N~DV­1ºJ\¨Iè„ÐB�6…Ä«ˆ‹‰H¿`‰Ç…걧&u”n›Ú42a™G{v‡¶ÿC‚”ÇwdbXDZdã=“§W5WMÎ,?¡”�wøŸÎC®0ÚJ}MûÄe>Ò¤L|m™q´¼¸£Ô•#†só{® ¯ÈÍ”¥œKöÒ2èœÈkóÚ¶t¿å`öCØ5Vª/6RrUX7ñë®mús îèCû”®_Y% ±GíBw¾ƒÊ®WJÇ5èŽÉKœ-ÂSÌC hÐâ¡L™2çRÚ7§>™/•Åy# “oëê„; ‰F)3Þ:Ñ6Eâýñ u˜fNd“3ÙfKéÔw­4±Ã¾;Ô_“kÒ™ô*±°9ËJ~K·É_< QØô­óaôn݈¦ªî}%Ì碘qæ£vB:š~hÕ|6Κ¢ Ÿ‘†h Oß1>5úÄ £ºw{¬XéBÝjã–6J¨vJþ•sÄ�íß¼5°RWÑs*šµg(zw{ˆ"ÛrÆ7bZš2EI‘-›u» ­Öd|vHßýÛMV>Ë@¦ìÅ}ç ü/weµ¦c/þ}ø˜ói=™ìA=¶»õúæÕp¥´$ÐR·ðüTÐÀY&‘N§2â9àæTš°«øAP¬úzm}šYh9£Xªá§uI¾¡.âoô¾dƒ)ÐEØt‡§Ö"Þ²NéÇ¿»îÌ8fŽÂhõ¼‡úN"G¼.ÑBd¤}«møhlXÝþ=²›îõìtïã*öÝßèV°"Uv<›d›ÞÖE¯GésiªRõvc�WO¦o/ªžúÝi² ú1`=s. œÇç‚ö¢ÂÙP`RJ>ѺÐ÷=]y¼á’m¸ïò s’@P‚ézËí¤ÜwôéÌÀNÈ�"Åa` ù¥VÍ„¶õÉÓa´ˆæ*{vZù!¿HªÌÓ¥¥7£<ÈL¬@éìÚÈšXÉíùúÔŠÐßP“¤(‰üF&+§AjuÜ@Ø@•ºðí‹ô@îP`JZZ=ƨîè}ÒËÙ¤UÕBµ‰¢%Œ•€6~üiÁ‰·üµMUÄYn"FjÁ9šƒ´9Z›Ü>âÄÄèNÏÆÃÅNß‚›e‘›aszh­”l¡›iozòrNëËßøÄäDÍ”@äãÇ;C¨¬¸Ö´6§ÿ %îÈmFòá3a™ZF2ËÓ{œâ{ÜR Ä BY4Ë=7š¯âÀ8Ì¢¾åÔ[ª�ŠÇ¢Ö7ŠÏ/æàUyá` WjË&‡FA¾p#M¹¸¯¥ Ó0‰m$¢³ãîf·Q|—€_^äÓ2ÂòhwÓô°[%±ïó€˜Ïëͧçõ-Zî ™l†Õ·Oçcî)ó?ö|IiSd˜¡…1[4ªËàñeY(uo5hÀ;_u¬¹ò”ØYe xQÈØ’Ø×ÂþwGY‰“Òú ˜$J3ôq3ÝôS+Ñ*ÒÖ%-¼£Nxu§> A±ïœT±i5‹WŸ<©=ë*=EkûoÔ«­Ø¡t{yµ�€º­=‘ÜOeØE?­?huÖùõH.„LcZ2°'=ûØq*è/¶%ÉÀ ºk?`ÓñXðK#Å^Z4ú¾ Ø¥ðY„H Ñ­¢$[ÔMè{0ý> 2 käWmÒ8tÍ,}Ým0“P’›Ð®Vbš yƒø}éËØéÝ»ÅÅ;RÛDÃÓ•îa¯Û�9 û¡ö‡ƒ9òw|OŒÑÕwg¬YeŒŽ8'Lðâšzo4J)Þq§Â¡0ej8µwyƒzM=¾hÄŠ>mFµqãUûÍá·C Ïw:Åè)w6J£¬B|Ì»±ç‘žšBŠ0æWÛj[P¼y"‹¡Ìgí1./§,ƒ‰ùù|l즦£Â{M«G¨N×}¼Ð˜ÀŠ#C—ciû¨”ZSä5MŸ=P­Œ°a$½~{£ i¦&83ZèãÉúp# ô€ô9–D½Z© w¹¥ó„ç‹ŽJœ%ÙR.å¼óï¼1YQ6Ó§(ŸÙ´é«ö%0«0€Å4ˆ.–åŠóèà¡p¡fŽ%/ú¢Í–µìÀo¶sfò¯Ô—ã¤r÷¦™J„Öï]5uÏ0vUT©÷{WÍ×–2c¬0¿[ö{tòÑÇÎ þ¯9®q‘;3Çúù }‹Ø¨í¢ŠÄ6tM}'‡‡»ÚÄ^牖òÛD4N~³Ô#Ñ‹b¥RÓ!%­f~¹fn¥ á4ÚJ»M”­•C EkÏ—¨•ÌÿŸµ?Ùn\I¶À1ò+4ªšäy }3°‘@À xVýÿw”m37wERTä]ï¾ ¤“Á wskvóc¼uSHe› ݇⳱ͭDš¾€¦è<‡Ú7ñ®9Mø¶cÕsBòš ÒškJîÂEkŠTÆxo¬Ä|ç·+àŽø—¹Ï:vm¨X’û±þÉ´èl1¸}h Bï=wšÎz’Ü´‚Þ�µÏµ¨¢ÊÉ8‰@ã0Q®6ÚDdƬ¤<¤KðŠ4Cµ‡à*\ê J¨°oζ¶ÍØXÜÓ ÷r]êÏåa*lÿ {†Õ3`Œ™�Oâ‰í…CÊÑr c±<×EP͵çk5¨Â¥[¿?\ØHof!ŽæÄ…ÛW:ù¢Ì{…ìg §'½/h&@\ÁÜ“ó¨ëÇ”8O›(Å7Å°-# ó‚Û‚WQ>j‰¹Ö˜›‡‰ÚR�ó–vÿÚµG}˜×YïOžïV—´n�·uë¼®Z'«§ÁüqPOœ¨áe¦Çô©ðuèÕ0aõÜpB ]¸?¨K×m�ÊØT¤ŒÀàLuJö¹õž”òUiŠ7Ãå°½ç%Ò›ÅüË/bQ<,fcÖ\„ªù-­ÈbI¸Ë‰IÞŸ,(›uZÄ96}·ÇM”9¬X&Ó¼œÐr[±~ÞÖ·ëÛÍ‹ÜÑ-Hߧá»Öe¨(?ÐÞï=ê¡ö9:JÇî~“¤ ýj匔 ²ŒÏç*@–[SÄéÉÞÇÙXIiYŒ1J±ÂÚï"¯ËôƒÙ7¬{°þ%Â%t.GŽç!)‚ªdG,Ø;!´Õ½sXÿôÎ'€ãg%CÝûÝžÒ"\óí’¸ðmn`-¼‹à¢¥Ù J�¤š)Iâ6ëB.üŒÕùû[½e˜ŒZ¥ËÐç"ˆßk¦O«d’;c²äK×_®ZL½!Ê?ùÕ¾^d·ÞŽŒ«(öÒsø¤ )P_­§ŠÏ —W†oÉ |QóD*Ýž§›ö};Á}á÷gÚš‹×FÝ [ÿa×ñ²­NbåᎧ¤ ¢ZYܘ½a$bÑú@n´Ì8=ãlŸóæ§è?yžùº;ô ˜çUï³sÙ"±DádÏeopʼnþ �:^Ï]hËÕ=„A¨Âì}¤r³6Ò½«'ö"êLÁ}^–³>¢îëà½c¸Q;¹£ñw8þ”FEáò'®"6SJ{@Kú‚GÑÖЂq˜l¹w¿ƒ#9™ôssÆN7v¸…"žÛº£á/Œn\ë26‚‡Ë¥ ÂQySp#èé¯9šYƒíjÒ½zœÎGþì7Æô«ŒÄF¢i+Ý“±>÷nHò¿)¢W ÝÊ ÊV¤û/æ¢>ƒ‹ÔZ,Ò¯• ™ÓGz°•Ü-ViDkZ®?³hÃÔ·9¥$XàbuÇQCƒCóF+\Cd C’hÑu—NþäÃz€´2+ zŒ¨r‘&2 Û½3fP¦'@ß @¸Àh÷Îôä„¢¤±Öì¤<s;k-#ô¯ÇCËL÷YµPÁθs‘óüñÓì&ôjÅŒ©Þì V[î;<ÊËœîý½Irùô Ù¦*¶A3.=·J­GÕfUîà7pC”ӻ׃í1®šVÞ¿¿ñâÍÂUÄ/ƒݾQ‡>)o/6Æ\ç?÷®‘s­3Òëq°‡X¨…Þ0ÈŒ_aa\‘ÈX|DÄóË•%—º•ÇF·¢ñåŠ:5’²™qm/F[ E~=têè®9Ñ­L¦h¬¬Z)ƒÊq؉·³ÖJ+` Œí{QÕ'×f£é¼´ÔŠnôŽ©þtþƒ p¥^ãe^»2Á–a‰£dÿegÉe ’Ìfüëi½*xdÅLñÍ^Ju ‡÷½rQÊÊ•ÞH™SÆ Y2¥A‘ƒ¦$°RÓn=QÌça£½0ƒ¤;BÅÙ Fs™(é4hч¥tXSs ºaÛîí¬îòy®¯w5mK³¢H4Lª j9ÑžñypÆšæ+“)mÒŒØDIÈ£Ÿ‘幺š¼çT$}zý]ql8 ˆm×a4¸†ýþ rRf«fo.Z$õÕ`ã+ÄÁ÷åÖ D…¸ez÷ÒH‘Þ6¬ó•éxÅE”gÞ õ¦.g晟[õþÑ-úO”­ÜŸAë_"ž ¾ JocílÆ«Ÿä«öDuØ YëƒBXö³¿~€€@¤M„=‰×I3:¦€q^­ëÒ¹vÑ�½í¸µñ$§ŠóÒe›L¾Úi餽m9b­jîË!LVõ4Ô'Y§ñ©F,mB·ö°+‚Ì°C•9ºÎ‚¥ìiÇrÀ÷QTÑZù  ž. 2ë6Žâ¼éê³ALÏÁï]`°2 ö·.—Æuu„ÉÐ\m. `íו׉Ø/ìW£;›ßu°P±ž°²ªÌeò<ðÛ4UPìTÈ¢1˹i¨Æ]8>^ÝÜÀÛ#Å#_ï,Í‹ÌËß)q¡ü: òyvÓDZ_ÎweÇYüùW ÉÊÓÚ(™ÄÖSž1ü«0“ —i­™GYwéÂèË݃¤rÎ[2繂ܟ,փɊ‹côø`Þ^>‰™rBQœ>ÝùÝãU,\†yöÃ?îï<ñ˜Ú™èæÃ×äÝ·²öfã_¤±ûù÷¤ôãÐïtE  ÚrT!’¨Š5“îŽpâç}£ô]( WVÑ€C÷ëýËÙ,³ý• ,ìóm¸pþç0ü[ðn~í78§Cí‹/ÈØ: ¦E4ç›Uj$‡æ¦‚˜F±K‘Š÷Á>ÄU$w©æ'…ÕÑé-åÓgF_-‚„Û5½‰3Š½|Ä' XÈÂÍ3ÈÖÙôî}„³­òþÀ(xFQ íª]+~ßÈ'¾L©PI'„kMˆÐ`ߘ•ž º”èKœ^Þ O”=ãÊ7OEp¨¶Ýî<'6XWZwLΗÙ0Äö»ô‚kÒ½€©nƒ{è�ÂFØ5²¹ó(v{ Á×æ<0ÞÝ3øõ_Þá߸“M{ú®£B×^¢Nj”‚ b^-S[w`7g÷#ï„ZÕÖ3í<^Ñ-°@ÚàЈêêCˆCìPè Ækš"ˆj5GaÄÓé"ìMÁ ÷|þSç]Á@»×Rk=Ò·TžÚÁyNèVÔV!4ºãàŒ‹aÌNþ©ç1ÿ1k iTZDp™©DÿLl}½ˆ}¨„h÷Ž¸®ÅpU¾^ ™îŒèï¼ó£†]¦…Gµ¤O},‚ô_õ@«X¤–qñŽ@a8‚?‰ð硧ßÀŽeeª³Æÿy_o—7‹ú›ÿ íNéÝ„)ÏhѾ£s6ÉÛ«þ0«æ U‡»`÷Š0˜¨.®’Óm•²™ê “Êo^×mïÒ ¢›ÓzɃÌ2s!Q8__%øßòý*=BÌ$œÕÅMGU¼Îº]§¾6G¡Ã¢‹ÍÜç?zæN‘ïàCÛ}ØÑn©\¥ò,Æp'Lq„±=»1©9­ý òÀ‰„­Œ½v#C¼j9×r`|ÀàiÎ&•-Då™öÍäUø,[ûºÆöD™ïƒC”ŒŽädÒL&yóCcshܳœ¦µMfégùX®û4(÷3!Nœ<Û0‡0×,–ä:ý{þjÿ±*!íȲ{å`Í+BÀá 9‡cAÑ›ø¹ï˜IpÿríU.ü¼¥¦¸ÔíœmÞ¶>¬NŠM“temG1éÒ¨g-nÊÒ Ãaö’WJÁÙäoÏžÌßîCE»Ç¥:CŸw Z` >vï ÏP.έJ"îC•Dʸç«W‹ÒóÙRB²9¸JšPg@'å ÙšZ…ÖH ¿©ì/‚êÜ{´ Z¦& Ó^ŒŽ‡¿_8˽ҵ¹õ}äÁîhˆ=q²[õc’ãv)¹"R³ñÙ¢½w ôcE”`<tVWY)ž[RX IÖö ‘©¸ù»õ[Û—Kå`Û«£#âÊÈÄèÞ JËÌS<Få>Ó}ŠÛV¡@[!HOòþ‘ð}ä|0áÌÙ¡0±˜Ü©Þ×Ã=Ö•pÛL¿c±Ám ‹*ó$H�§2ÙŠƒò¢¹Ây±ÈKþªÒŽ}Ò ÄÍ'zÏd²Ú$‰ÉPmUÄw‹Üu\C…m%3iaoíý±£#l´§ÃÒ²5ÄIÎp$]L} {Ë¢U_È•2H÷½õÏ3èdÜ“B\¹žà8À©í:ûù€|ƒì<N,é€FQü-y°J.3“2æ$}·4º¨¦çÁp’5^ð·ÐkÿÆ33$#}ųW˜öóŒï#±Âëy—FàF<ÑRwÅSô·nmVB&•îá6!Ùæ|…%@ƒÛwË’4ôDiùìÎô¿:çû½«éãðlew>ô’ù»+[Q”·Ö3,Ó’40~ÄàTZ?ò½6”IJ_UJpPðˆ»É¦-[Ô"ç+ÓŸ¡neêëòQ…¿ nvwcꧦƖwöœfy¢ª ‚º ’N5GdÚ3éÔDÌeŸ[̦™$Ì,÷[oòŽ‚™*À Mð9[°*|5+v–§çæ ?ÙÑ­žúµ#§ÔOYGU¡”¢ƒ~¡8}YÉñ@�o7àCÚÊÔ9ÆÙ‚©¼´v»Åñ°ãV¹àK¼ê¸ô¥'aZƒ¤Ï½'îâÄ×îqKŸ²Ló*É2‹±¡u}ü ”*ªkÓØb<Â'¨¢NCY‹2eY¿îÑQ"ãi²jÉpg?8#,Ž9ž1%€£‚… I$òÏ´ôEdÙ7ø®²õÔzÓ€¤ÕyBYv§ÿ¾ôâPê)‰È=ºë|›ò$y¤˜v‘¢‚—ìMæ¯Ñø^°XÕ«óx\òð!EªíM€»ø˸Ã/úOšÆ^?5¬(Iƒx«}ý$6Ï]„¼/§7Þ~h³ø²Ë^ÌX¥3yg¡6Gº9Ñû§6OAmëVd8ûÇØż¸y†§¸š‰„Cõ»)­RÖ¢[œ,ê+Ié)oL©A+¢x×nzZlÐJî¾ ¥W¿Âü¢eyé¬ðÞ÷ÆC{‹¹\Û³émÐgj( B4£ƒFîoz½µ¯TlfN¬@Ë>­´IŒùMg-ã^B•´¥m1¡³ýžÿtµLhúéIE‘¿¶>M�9FYêª,κ/ˆ¹ÖÎ €"ÀiЭքTKLâ³d¤OÊàô€²Î®¶r) ÿH!7zsd‰.*ãlZ¿¯ GYÉc¨ÃPÉàÃä¦S¿í|-´ú@žç·õ!%¯+Å8rR¢±¹>Á÷ënêÉãlià—x,qèQèýû® ’ÆšâÆVÿZlÎ΢{ê惔{ùF›wÜó(-?G] e çœ á+v„y™[}5é‘Ñ΃¨ë}ª6NËb’ÄŸŽW95G¤­Ö�Å;è¡J`9÷‡QPþàñ±~–Ã!±VF` d®m}˜®¶i'ŒÆ”{k¸Ÿ:ÓÁ8k"†|aþö³©S£<òåPÀà "¯Ï逦?y~Ã/aî¢0öÀ€;ÅA¹tBÈŽ°]>jW€­¥ñ¹K êqúý!vE+9üÆ6)-ý˜—š»cÌ‚¢ŒMCÃÌ×R¤UuLél4ihÌÈ�T¿ÃË=…È+¥D„ ‚±y¿_=Dúæl$+Ö‡Ä#œ{ä²\ÑO‰¨€ ¼y´š§±×Á2¥8å7t�—ÒëqþÁά+¸»­“¥ÀŽvDÚmU.¸–é­AQƒLÞ¨y%Á{}¬©ò\PC¾õûI®›pqp(”w½°aO#æ+{b¯êå?‰%™÷öËäyñbkIß CòM.’£*Ã#ý‘X0v‚¶°õ¢E–^˜‡X›=`ë¥Íæõqæi•šiSö³ÐÞW×´ñðl•ý›„¾ %øÒ £¬Â¢M8gu «ã÷Ôk³J.³o©û´Êäé7ˆüA¯oâcu†Iúü£¿fúbúô$˜3í„!ÀB2˜ß1¦ËÄMµ –ƒ›bþôŠOeœ@½ ±pègÉÊ nýÓC„\…¾dÅŸ=$؆³/ÒNÀH+K;àæcúNœžc7‹5Þ¤ š4 ªzT° Ú-ü™½õõ[¼L».ÓL§#÷”56aÚ�S+® œÿ¦5žzŃ*ŠR'šX0С‡Ñg£‡¾øµµ³æck¡k0í¯½ÚÐjûÔûá[…N©? &õ_ž²!`j™ß).N/†ó FR<PÖßRDyè)¾uïØö¼ÿë,&Ñä©‘JvW.s¦ÓfÏ›ä>¦ÓçäǸ;0Ο“ñ Ç™gü?¸ ;ˆJl¯e_æÁï?ðÇT @e" K@rÌß±½öí­bžûT8g YñÕX`v¨Ð–‘8ù#[k#ä^ÓœKXJàzW:@kù²‡‰Ì˜ï ¾Ú_õã<çã—?ìƒkŧb3 Ù úˆ°«ËºŸë;ébä|L&£ªÏA1†—‡Ö(BʱtÏj(\¹”Dl[JátoùHpž9 v.´íúÃ×ÌÐkïò±DH‡+‘lx}VA<éùÀ¾¨ÃÌãõw¯…ÎóA+MÂ’…f|ôðs±#JôWÖâÛægß³Öé‚Ûj€~¯ß1ŠE­Îè=­Ê’ØÇr–4¸Y*~2»‡–ÍÆY”ëtEÈB±Ìl¢±õ\‘W"v&P=Ü”ñj-À�؃VA˱¶±ôîNÆÙjÔÍuèîþîV¤J|a¨PD5+UY³œUobÌûü …¯¤±¡VÊ2 RÂ&d¬{vh¢¿? k"q#š¥™¥†T Shz_Tx\Ú®ƒñŠ©Bö°£Æy¥.•ëÓ *„ýy†¨DYËÅ»ˆªï¿‰\:eš \Óé½S\M×w”ŒÐsÁìÝ¡H"JHY; à·×$•²^-q6zÏÙ£“ #È@¥½õ꣺X@#à3½$…‘±ŸJÒ¿ÓÌô`ÊúKË|ÌŒk*U'¡‚w0²¦µ.‹ØöXo~ô±¥\—Sˆ¯qÚ†gUÝ¢r€N³ù4Àü#=d±Ï ,§ô9Ç42žÌ:N3:·’ Þ-¦tƒ¼-‹£êR…¢6ûiݦ‘kóçÞAÜlΞ:ªŒH|´`ÌõåŠi£³gƧ÷®º[Ú“¤%tŠól*Þ+¯uÓx û¤JM‡øx2å…/QzõD»°œT^FܧúÒбze†9°oôæÞÌõþô5ÍÖ¾˜ífôž}kïQ¿˜Æ.ìÇÅðÅ&U�HÐz}ï­©¼ Y¨…«mÈ&POhºUýþ? µä©;3NÒiGä–îÏVB22âéU7µ&þ¼–ŸÇ…‡ ’­ÒÒÖÅìÜÅN–Ðß›—ïŒ×oösGÇK8ê‹“¢›ûc£�‹'öF1°;¡ñp÷epÉÛ?o¨æ¿ ŠÿÀÜŠJ²0“Xˆm@ALU3Ï­XýÑúÓEÛÔ/CKjc¡þMo—/“ì~PO»«óo¡ƒ…Ílå…8ÛžA<âíéo±‰ ß…™öïþ ÎNK€èÒ3lŽ 1­‚vÿ¹ Jý§„œ¶ÆÉßïLþ/&Ž»î#8›ÐQýÚw3W«Ü(Ï•Ð$V+=–EJ%Ó lKËXª·*ƽ®üÜ{oÊNŽ'3òšó‚WM¹«…KCJÂ)¼t5¬a QlªçÎHG>°¯ °r¬ËÌñ€BcÖD…ŠS>ë2ŒÈ´Æ¸‡.TLÓ‰5éTâÈ‚ºC $6+>¼?ͨN;*Õ§óî´ .S÷ÅçæÕ<Eë-I»ìz*i—í}ßß½šÿÀ¯u~.ö¹ÅuÉÀÚH”]Ʀ%6yˆ¾=Ô¬¶E5ÏЀמ³ œ¯kIF¯ç÷ºTn¬…QeôWš™N•bZ¼Ù¾ªdÌ´ë™â÷jîc»Š2;§Še™ Äku_á;Ô)Ý€Vz›2ÙISG)êî.]%¤_úBÓ–$‚µpÓ,¸ƒ ü•!±/"c­ö«@c)ªœzèœ{G™8v¢×'‰-©{ßvJž·Ln†xºm„¢®ó„0)é`xz1¹Äåúѽä­Rø²»ô,/3…þiö̵©ìb†-'j¶°¿}½=ÉÃÊ)X³½Çñ#¥÷œFP�†4Ðc¶QS,ăוÆ4?y¼Œ¥__¾#/}â­;jÇI˜Ø·¯7Î ™/¨>¿;±ïGs*É© 1w™î둇…¯Q¼Ëò£E¥?ýƒó»cÙœjV"žƒ‹ýr%nNÑöÜAø®êaœÑø53˜²ÆYU€Ú]°—ÎÓÝîoRz‰S†}ÚÑiiÍ€mÉ©IO°?Úúÿ™ì{ú¦ÁPü:û¡Þ‹ëçÜAšÇ÷çlwFnÎßšsG†!k2~º#~„«€+ž/j’E¡ÇaŽKGs«D à¨q^p…nã :²‚¨øq0d”§¬ñzŒ‡n·ÓsÂT¢ë6{Ž¶²¸ÏÐEdgÈ“J§XM#0ã¬ã {ÿ×á¤)Q»DoƒÂÜw÷.,ÅÎV!&±H€®*ØæЩ˜ùðá+ÃMÿ^ˆÅ¢BceÎó³ªÖ¦Äeàø¡©Üc³(,\OŽ}¬¡dÿ5Ùª† 6}åœËs©÷Û«t\Ü0‹=7¹ ìÓ ´D†ÙyMf´/‡M_¦û|£×ઉOåa@)Ë™&u§Â1™&ÛÓ—&¥¢HÄ̪_É›e 5.ÃÖ…6ÃBeUÜê?¶PæÓÚ�¢M‹ú�¥ }*hµræééÈjõfЯšÞò@Â<X>i©.úDòY<”Ó$¶­T±&ƒ÷Ú¸¢$Œ3g`PU•ìw¦#‡ë‡SMGß‘õIøT(Ííë}þqéweik´ð~-w£§oÎ8c(ü{Â÷-ð°»vöÕx³8 LÆièÌ´ï$R©c‹ Û|¢{‘/_^g<†U')¹RÂÃŽ®_bø½0Ʋ¶P¶YôÀ Ý¦¦õy°dí†K•× šqè‰s.5\ò ê¿lŸ²çPíœ|©�ø¡¿fe¡ïV•Ì=”f­ïÛ©g7Ô0ØVÏ=¥pØØãÙ‚ î[²XÛ£(1à’Ýce«Œ‡õ´8<ŠeœPžÌ$¨I~×ú¯ÜÀŧ6áuËbo¹¤•x²ÉéãP ?É\FQéwì[ÑäAÑh–‰¶ÎåêzT—ÃòzÏ(óºðêå\Õ^‹ŸŠeB7‡Úrוx™®ž8î ¶ÊVÉÊ®OƒÜ&Y‰È[ʹ É}½ Ãréû—6‰[Ýp°wÏ´È·Ú–AFÝI ¥’…Û¦óßÒà<–·çíù¸e'%ËÌ¿'â—j ¸0dÿë)Òî݉ñâæJºh„pÐîzîié6­J7PõŸåä ž˜¨ÅE3ì4üœÛ“{ýMx»˜N´/ÎB+lwêk•ÖÓ¨ë®nU9òb ZcQÊ]L³b$Eže™_ƒ=±·\¶rÐdLƒª×ì­¢ù‘ 镯ösÑ"YYH<d•rJO:}l‡ºIOÃÿ² ® EøRƒv)RÂ�C9‹ èöLך-5h°ý™"d¹Ûê�*¿m=í;ÑóZË_ôAÒµô#zï]ƒŽ>èó¿[ …Š%aPÝ*P<ëЦå*ý*¹,ÈöR‡Ò}Íi áÄŠõ#BÇûؽZ¸$¯4ê]CGo\ÚÁ«¸# 3—Æìs¯ øöJÿßUº“U— )D©ñ^Çõ¦¦ðæ«TA½‡BÓ®Sºñšy—!i›FU(ÅÉBÛ¬÷$©;³r±cEU›"Úi¹ÂçDËð£Sãïpú¢ûïfg7w˜‡³±À[½x°`“Â5ȹÿ:t´hÁöu®‹ÄMùãGŠú× àZf79ˆS·5.Æd OIâ8ÔNç#+#É?ô !(ò…2ô— ô ;2x4X8+-Žšú:u:1>Lñ<ô— N‡ž–º†*±é/LfFó;4µS»ÏL©Ä*ç­C´µxw_®|­ê ³o|¦FT­*é.Ìî+&áC6û+< tbèð í‚Aäwt¥K?K•¾LnQZ ,µtš`W÷ÑÝV?¸áta‘±Õ` ª|01å~ %!i£¥Ñ8è¹mQãpå ¼µ�i[(¹º‹oñ¸òâg,®YÀê4W«CUBw´Ö)?íÕb7Ùcæðº§.ÇL¤¶[ÚžjÈVÛÜ }LJqbá*9ÔÎtŒX•ºªðÀ|£Í~ÂñK‘`:]¹…wvü# ¾×j^)øpATÙz>´Â5Ž!�L$²N_o‘[¹Pî‚Ê–ŸŠ\ÄP”}Þf*D§îU=‘´Zœ¨¦ú ­Ö[u̺cǻͰèë~8/ Æü•scB‰¤@-j]FÐ(zŠÎÆþ¢@ÍWšt—X›3µ ž¼§>K¦‹Méÿ›§CëC¨fN²ó›x§Ï­5æ{LÚ{ã(Vu¸úÁ$3ËïmÝ+WI¥ù“ÞF0MŠÏÑs©Ž¾ ²:Ü\™yzšþÂ#+ŠV€ÐŸôoM³Wžì© ‘©³Ök¯ÍÌ㸬<Sw*}Ž £iëú©—®æɾäK¥×ýqó3U6[5„R[Ù@HÓû¤Ì•>zR§ã|Ãh¢Ã}û¸ïbY<˜á&Õ>¥ºd™ŒÚқ“pë—UhwM¶˜?4Üa3ºã;«—0ù¼çY“üŸÝ^"»sÃð‚HUñùét·ºUv—:é)ž†ý_KV%UìuCØêÅÕþõtYú°Z·£~ãohø`¯)痢·[¹Ì6ÎÙùêàE~‘Ò@Õznܼ²pöÚ%¨{ñöp@U|k_ÏÝEÉì¢ccX›ÏUàl?) Íôx?Ñ]=Q;º%Zæ.¦s¶p_Âÿ€wŽ.©izmøÒ‰¿ t5‰]ç–“û¿qý´ªµ µB´Þӆ̿¶úL˜VOåì¤RÐ2¬gÖÔЋ{Ò¨ô¡{aÅdÆìº(£)Pt3bú‘±r1‘1QË6¦°¢Õ}^IÛm¨›&XDʽ‚h2ut“‚y?<`­çˆ•³Í>f_7çyà*s€¬ÜœH¼©Ü<E~óOßý£Pšó$K©ð’ÆS(¯vÚÏn‡W¨û0†ì²\Ÿ˜õDqìc*$Ô}Wq·÷ À¼J”À$ù”;ƒž¨=ûý.æ‰jêvôÚ=×S«xÁfô”“Ðè 5ßyý“‡þŠ #uA ;=«AŠé†ÙÌ°“êUëv)Kióîõ¿<¡Wfaæ­g¢ÅP vÊÌŠë$WF¿¤ÇÅ…#ZÆFjZ%áÞ˜~k]‡Ll–鱑e¨Í´Ç“Õ±°‰§ÿÑ‹b™CGEÿš¢}zÙióá)xñ,fØ›ô/k~'^ÅfDcš¾TGo½1QÏþ(bècJúøZß>ŠbGÅ@臤½†#´yJÉn{  € ‘|É3+¹5h<<Ún=véæäÄûXTSì—î]}ûyºòȃÍ ézë¡^ \+³òÄê* K§`r4ÅÃN÷¢YfJ]ͧ#ð+>q'¢©+Þ‰K×sƒÎc&tœŽ™îxÄ{ÕDÿ†4S”>+ 8Ç´ÎÞ+ba ÿži:´¥é€@áý´°)W䧌WM`¥ñ®G Ä¡6˜ˆ @ɽ¯L¸e‘ݨ B=7±ÎØ>/àO*31Eœ«uÿ¾æ° >I¢!™2ƒP£Óå(jX‡n±Ã•[á—ŸëÛDQ¿V–eYð¸×§&†ZâJ 9$×21Ù›¹@D”ßÎ3ýÛžq\f>ŸÂSmL™Ü®v¼øÓÜ 'f‰PPvå©'¿<V³KËÔg»PØÐÁ–¾7®€œ[ÂxæšyyH£¬b'@“c71Êð³UŒ9Î ß“û«ÎÜ&ÊŸw¦/‰Ø íŸnÍß}[£pÀù³1€Lœ©™Rƒ3 î·…ŠãÓrç7ž'e]Ó€Û8hRÑÒ^GÇ\%[0ŸÑ_é bh­Ì,Fk¥þ6$¡Õ¦…¶9ÒóM«f”‹�V´í¡:ïO#R[Z¶òXe­ò·GƾäÎÊ,ȬÁ»=‘ù4º¡ÃOjò…73OøÌÀ4îÞµâÀ {Z:ƒ@lkM1ëùЋ“Š¹Ð¾VáU�"3H5b”½RÇõµæ3¤µÊ½ŠLHñ¯ÙRд»&óŽÙRÜ ¡›Ú;¬ ov£MuZØééêúñþ*sŸ1–Á~„ SïÑo›Ó×Òéb¡]�ìg§Êœ-<ŠÎÇï\qäS‚¯ÿ‡2ǸQÀÆ/{Æ»à,¤ª—ß›æI¼¶›oæ”ÎÅ/…{BÚ¥÷žüa¶s†—ÃnéD’Å@‹’H@!¶vÊŸÿW«`û¶;lM’ó7ª^IÞøþ«!ïÔO�˜YJOøàÂ}´N ?X6Äixãð6Ÿ€â~WñJЉëhG+Þð"b$²^!![Ÿ iÃü?ÞÏÖ–'dMç“u | ‰'fä#l¼$!ÖÝÕpñÃ[“ZèúÃòÞñ®gÕü\êm$ï·ÿ"B¹ÕÞã)"2êÉ›gujÍo_¥B¾BL3_”ŽùžV·s}fR߃f;¹wµªú­Ã³¾ùe¢­Ùû[š?¨ Ò¯fK¶çWnc¾÷Æú Öæ_VŽË ] ÈêG2mZ¥¹}§7»lbªøkEgÐÑç¦7— -:yλú/-b×!—ix‰ÄÙükðôã‰äÁÎú£ÐðŠ›Áø¯•œÛthÅÌrzøŠÃ(ŒgàÖUFŠ•¹Ìç™ü—{#™4[9ªæìŸÔ;OAµNc '#í :J~ôˆ/*Wp— Pæ½­·EV`‚©] s' Yþ:×cƒïI R£]© fU¦½öNíæ<êËÃio–¸ùó%— ©^ëQª¦/ÑŸd‘îÊ$©s‹ðäƽ. RÛŸk>˜±‰)y^‘Q\K*ºÕšiIÞ@Œbñ›ôÝÝüô%EðH­¬DÛ²*(šÎI\XY³V mù6[Ð_ÏPbk*žqó5¡¤ÊZ#¦ eÌ®•ÿÔ]ŒŒï½Kþ'kqá\õ“$\ñ¤«`¦§žm­ñAeg{¦Í´©˜9èõòœýa¥Kèô„•èŸ|Ô~:Ø«Òa§Ï 3½~�ÂÙ3<* m¥…Ò^ß”³W졆JÀ7D‹:‰Çéä ÕiŽb!{yÜIB|Wt&ñ4 ýü4ÉTêa2OƒIËV½ýù8�æ_Ež%Ž3! ¥V«Àm$?&í³®4´9»©¯×øQÛ+W6çÍÇ`~µâtSÄ;ŒU­GÉ¢'(ê+¦XjžŒ"ú0Î2H¯)æ£tÒß¹%~×.Ô§úÐS�qÂó?ª'‰ÃuHÕ}UA>ï9p9´Îb¦;¿Í´t„ßpGÓ Ö™h”ÑÍž"?egR†æΉq¨µò2jÓ™j;Öú¤î00ïè1oIVès¢E•íÛ©Stæìy¬ý¨'.¾Ìs»/$Þü™ÕÏ·=AJ—Ï“C¿¥›Œ¶ ÞÛõH*gÅž³’HnÛÕMŽ¶uÌZÞו’*Ö[ÊÝe:œÀªê½¥Æì yZTh_DzÑrŸäŤå攞N>Cæš ­ñÑý`Ó‡Ý.¾Í-·E^Á­DÑJ§ YÌ5Bë2”°ÉAv˜4?07ÎÞ˜pŒ§3BF)ò/×éö‹$±¹Sì[‰Æ:2¸3Îß¼âÞ¬êÔà©t[… %òÝÅ+7ס¶ú~˜Öˆ`”»º'†™—7С,‹ÉR±Í£­éV[éÀ—šÏI´BÿBn¼Æ¡ÐZ^1s\ÐÕjFhùþŸ®íØ&êAN•·Í§% ’Ï/­L»co!*ÿ›ÓJ¤›ÉÐ s:tØæäÌÔ`p�Øôý½+-U¿ý9«KZ…û6Ðó¨¬s!{šÚÀ è½ïƒkOL³»«ˆ4(,-5†Ì*ƒ§<‘ëûTþŸXý†""qŒÚmóAÑü<{n~Ãôs,Sý✋ÒÈ´®NY¶'©CÉÚ‰Âv-)íadtÒ\>¡}«z/èäUˆÑþÝõKeêX´ë›ë?m÷O_ÿó/%û;¿‘ø,Döuø}Ä™»ÅZAlr =EÐøçCÍŒE4~y­¢¶Fö *0ߪìxeQ½çK_'L|ú–÷¸•'³ëŒwÆwøFî‘P¸‹Ê®³®Ö™ÊÜž.>ýw¶³‰=Úx¼ˆB7©\vž‹þ+6Âr.¦/žt¥7 }±\hŦ_*¹Éò±öD,%öÙX ÅÝì^ïÀb­¤u@Þ˜Ò|+[1êÀ‹«/˜eßàe岇BœË ~?k'õH³ó¦çFÈQlüe˜ÜÏ’‚NœImºRÓ—Ò:ƒì õæe:/ŒÄÔWe}Kk1Ää¶J¯r+c£°2‘¼îLk sΡDµtgÃ+ºíÊ&V%3íÄþÍ­Ò~Šçb»‚§i´ÒÖNþ^(?˜wðY³~zªêÎúBAÍwAq-Ó)çå¹a}'…Þ/qï©9Ž¦GæLæ²Ý8ŠO§‹Y÷qCvº*»!Lk"´‘utH §k-QÕ˜3> §0Iáó ®XÑÅbØб\´¶£QêôDJLÈû iT©»L=<•<H÷Ö<ÿè#Îv§ºEaÆíÁŸѥ=¹UmkÅBÆ6ÄÆZy¼8”8Ï>tHÎbã¼à9-{—œ÷œfJdàÐGp…2ËGŒØ˪îX T•… ¥ÜUwe'ì~ŸÞu©õze29P|»œñÒÿ=å•ïOH•ãf›Aj­Ès4P__¿»ŽT¬.'ú_µmý¶¹‚Š‹)ɽ_¥]§ïŸÑm§¸þ©A b©ã ªS³°ÝÑùø£È÷�¢çr=Ñ{Y­}¤F—@+¿ï–¾ie«Ómö9¥Ø[ÊF¹² ÷g¸ÐÈ·ÎæÉ(¸ùgãÁ·@@›ìhë'ômáÛ£†àYPì©>u Š©Æi¡tîY!ïØóºÛ(šÎà qÔ‚L…mHGè¦)‚l×:¥4ÛîmkLJó û±ëÎÍO–ùÚO+ŒÒ¶íì|´Q~^®ý¶¶æ ¶%2Ä¡¨4çÔ0a$ñe9…±™A7KªqT+¤ê6+BôŸ8Ë<ÿLtæˆc‡B¾¤µëo¸ãƒÙ â_ÿɳàx »eíFÏäÿŽÙË­ýËŸðh%B…Š"TÛm@œÜ"Ó;S*œ—^ýøŸAzî Æ`=�™/óªè6^ØÉyüסª›SïìÖ‚þz<>,§UÓÏ@tJAV:T+mœÃt˜ƈïàʧèÂÈ =†ðø‚Ô²Ñ{mQ£´{€‚¿ä+J ÿã̧»12? 0ñª€¯ëÌ«¨Oƒ”ìT˜jÚݲ˜Î#Ç Î?9`8Ñ}_~_ü(´rE9 @øèµMÏ}?‹L»ñÙ«°ÿ*ÜÒ}Mg…Sˆ"(?µjRù�†=Aë t¸›ü-¸ó»µŒ¶RÍ€mž f+«½q½Ö+ ž4ˆò‰’ÂgqfJQ«¨UcD$Ñü­°�¦‹ŠÍÅs aëbEFïkÏ¡:—Í<VüùﴮŰl§:iîüp¹53\ЦyÒâóÔ…£{ Æ£?0¶ð©¿²µ…@Œ�œa={o 5y‰ÖÐ 1‹…£üb ìŽK½Ÿ~ác 3Âhgï'5ŠäûÚÆhœ(2B}åÝýŠ ‹÷º$dº**0+Ê�æ\k kÕhlÒ.¯±Wyè³R¹¾—8F´hˆdŸŸ®?•ŒÑ.Þ‹gÏf==òåÌ2£q[âú‘M´|:·³…èqE'�rcݯ:RidGôÒ‘šá[6,&„T°´¡Zàú¦gâaÚìMßð!нˆBß °Ý^[j…0UœêàºÕŒŽap­‹îl>&¢O¹ŽtF3¦ˆ0("EuøðŽÒÍØcÆjÖ€Q:D.I4èÈL÷ˆ¦Ï¸rh‹v2Ðõ‚e¢kÚ8žjÉ-XŠ¥Oûú°›W™? ­„Çî-í§dY1L|ÇIþFdÿM¥™WýÂœ ´µAUòSÈ™ÔRïÇy”½ðŒñùø8tˆ’Œõ 7™)+– »­½ {«ôÔ·¾¼Ã<—ßUc› ávgy3#±”P*i¥Yÿ R”–Èe.•j dp:]*±Š<ˆ¯£<ú;¸�'ÙúÌ#ö-CÝ^«¾r“CßÖÓ]ÓúGºWÙê,¨l}Q[»„ù\eê ú;=YÏòÛ2ìÛyW�¼8çZÒÈZ1w/”Öm>±þŽÊtw&™ÙÊ dpœ«*ˆäÒI*ˆîy‚ÃÅ=aþQì]oîÓþ ´wõ4’VÂü&ctÚ»“¬¤|Mgdý…ÚÍ8LßÑyL2¿0£È;AROÄ~{úòÕv‡m/ pŒc‰'ן÷Ϭ¾Þ÷¤´"x¿ËuÀVR;ºn;¼]a8ÒZñÕGƒÝ¨Z+1&âó•ì¬bú–ü– #é�¿€é»Á÷y¾s¢Ñ è]7‰©¯[¨ê@JÎ"9EûõÛÅ3}üuÆY ¹ :ÍìUót§9Ql¾EkwA©ïvÞÝ Õ÷úg°N¦B°,ý™6]{UÀš<æ]OŸŠ3¶ï:AV-(ôÈ0»,wèÖ{¯óÅ°‚z¸Ï_x,•“”Žš†ˆSgèA9¥Mºõïç†îº²®:ZCF µLÕÕߵߩrWåñ�u³äA^kÆÁ£ ÏYs™=Ø/l¿ã®n-ÒÁM+Ãuœ1ôMg+¯–ZÓ9Ê?m¤“éãØ €q¿ÆŠ‹ÜšK5ÿA?cÛNnôg:¤W“wo­èfÍgJóÑ[CV‚ÄEæ«oÂ-y‚ŸÁY‡×#pAhÿ)‡ÃýÂÜ®šE#èËüKg£@ ¾xâd¥§X䡪}ßÕ­‡#ux‡§Èã²­Ä\ä7ÏÖ"ª ¤ÏˆÿƒÍÖ¿ º™˜¤GDNÉVR=hÕ$Gø8ŒöÑ9Am€š¬»KbHÒÌÓlñü¥×ËäÎoÚiô¿WHòY,²¾£}âÌ‘ÆlÑèŒY"É*ÄпÊíz‹Fôĺ]ßx•ûRhÒGȃë3++>àAAK\N)$[:Wye7ÆåÏþò±¹^X™ïXeÝ«µ{—õœ¥A7u¶v¿(4,‚%7ÇÈ1õ{@.€kÕÉbžé’×›|õ{ú&Îá ‰`°½RÐ4ÏÌÀú¦²%8×.œº0âôù•/Ž«˜ŠºAÜì¬ÚbÓÌV”Òöð7Üœš_ˆb©Õkèh<EY´Ø¹iƒÈŽ,A in¿ZõyQiÒÊš%S–A´¬�F8ù-Mü£}¥ýЀRó²™®|Gbá 'V…Žn“3}Ia¢†ü378òm(Ö<§`“´8†¢)¨Ž´ó¾ÊÎKXk·:ÅÆ ×4H­lUjÄòd¢dE±&XTõ¯´ÓÂFy±Ž˜1%ëÊ-Oß¿íÄ夞èRLa<'‹R“˜[-*È ÌàŠ¨ò¿ð³ÌA‰Š`×Ó—®žbQÝ4'Ƞ脶ýÙ(C9yÆ¥»|àË\jQ¸¦`ç 9õYã#ô¢úãÉèC/^Ž‚¾yÔ¼”AñÙxøÐuýK? ì|"Â_¿ÅMe+j³H"eíÖ£¹-×Áá~OuíÂÒøÔöí™I'ÈépÿYZXçÒÖ¼}UI0BËmZp&“NA‚€ÐíxzìéÌ>%Kú"Ér#öuÈtò¦Gî@ÌéÑWÌî؈OÅ]¬u°6îÜU°´Èî-ª©t£Æƒv è,ÿñpqþY.]×þxè$‘O¶ádOID2Ξå'ÕÖ¢…û~ò§>­{?¡«Q8L]†~×ÇR±»«MlÑÀá­2èüë×”eâÂdÿƇ¬ ½¢çúé‘A Ëi~SÅ} ƒÆÕÜÀð—îÆO6N*—È°(ÒØ'YÖ½ßÃê™mÆ"† h>Í’ÖÜÕAÎRÌÒ¸ó%§…£Àƒ¨Šé«¢$}Ûö�&á¢ØÀL9›À_Šz[:Ž"¶ÍY/Ü"é`÷”klOŠ qb•÷®´fcI²/ÝqSûÖZ0š†Ãlu=L pï†%e;í‡fOïòùneœŒæ¾Ñ×ø/KLøÇpýÓ9ÞÈï¹)ùÊ´––4kåÍèÚ匛G¸®7-–c;QjŽW¨d‡.# )#mAˆ<¡\(3Ådä1\.ƒÜê契ռðì�,s@_]-aíÓÄ>=áG’ŽgUCÀ)`4VþöÆG®s#ÞsŠÉcíR¾…òy¥3tèN°‰È‹ü–U{H´‰þ$yNïfÉ<b¸$huL ÚÁMŒ]\è#;]PüJÒÀµnªàÆ8R7Ü:’/ˇLyŽ [—ø„imO$.NÓþ܃+ïdÔ³x'¤˜øuÑpëæxsRP¹¢h¿„F ¤įˆ¨Ç¶î®ŒàdÙþ) rËt ¯ Æà(n/Ëž*vi`TÔ2§ÓÝH’{˜ï„ål(³(¬‰6èl�?²1߃”âÛ5]UÕ•ôã’úÓ!¡6u÷Öžé®ÐúÞ‹³íuÛµÌ@4ÓñÊ,|îBC‰Óidôõ¿×·…$ºcöÿÔtŽ3ß2†Þv¹ÐY9\<*Ÿmh;íDå%;‚òÓ9JJÛuÛ‘¾Ã�°õÐT›©f†Š¡}>S@Xk!¤¶gcà)Cd<OŠÌ’¸ì»®wÖ1#•ã7Þp¨ûÝ1§˜ÿ•ãG ¿Ck‰Çlñ=·T·²Ô„z Ámå'tk.Tä¡Ї$uŸRvbí–CÖT¤•¯ؘNß¾¾ìM =ò8±Ó|@=)ýF+ï=ñìRd`FQhpBÐéÇý-ûà5¾qé©«³:Î1¡¯:Nvpúöϲl—)˜¹uw+ȶ`a ÷ÜÁÊ6îö•ÎÞ'os »€ü}Só³z¾»7ŽEÿƒÊ¸SÎ+LnÃzXå¾÷Ð7Ÿg 8ƆŠç8²eæS=½,ˆG«*éŒá©2º5ÂÙ)“ Ü"ì¡a¿¢Q'Qæ»cÐ:»"H¶µ×„Oã¨I͵æ1/ë¯YO Ÿ´§á†Ï™ÓFëš[ŽùÜZá 6ªêÛ«3Öý»žc”yBi<OÝï`¨¤4Óf<²0 }† ð:£šŠöKá‘q-pç‰M».ŽÔÛ ÎPÙmê!d¢ù>Š “I߸o°°VV÷ Ð+V-`rá'Q8M÷;[¦ñZãúz¤$2ž}á" ömîZZªî´ŸRä.¸[ÓÐÅìX‰uÞ®µÁ·–ªv•À±ÞlÀÔ·ù–W³´¹ˆa—ô†6SRAH*â->ìÆôN9é”Çp'SÎ<è’Àý® §ïß *¦z®‡Årç-åÆ@óS’Ö·Î]’y¤déíäXë«h-ä¾`xJå¿hwq•8@ŸþÓ Ÿ-º3qÚ²¬óm� #»é wå!]ãæÇo…éùäüŒ¯0`o:¶È±S&Ä0ìÙ-ÿÒø.:*úZÝ2rUuÔ£"óSEòòæTm o&5?3J­j¼Ôc”ƒ¢w–XŸ‡RžÊ†¢ ªNïa vÓrϘ E"<,lßÝFPÚ »tÇNÕÓ¥™Ø¤ÜiöbaH‰_–ŵSu½n®ðèOÃB{âڶȧ0â!Ø]®&Þújè_ƒÌGaCR^+\7Ãq{>æUóWÎ œK~_™ö3²¿7˜Ó([ì †•Õü¯oëè«DÍ'JAqá±áµn©FZ£Ç“Âã¦Æbã�ŸFëQàkz:@=å_8ŠÅVÉ}YMV;Ú6fïæx¿˜�†+dÿCò†M+Óhê€&µ†wYÂqàÀꦾ1zÑåb"ÍÆLø [H‡dkéì ÿáÅÿ’OV­ «(wi(}îÕ|µD J{¦Ö‚ž)‚¼±5|m‘¯äÊ`Žü' rÛ¹Eç•­×ÄZËfÝüt«,£4‹Pfq=¯$¨&½Q5Õ°Ó âVD’å|ìäS¦þÐ!4¦Ã¹½;ÌÑäNƒüµÃÔϦÅgæRðJ¬Ö£”!<²ÕæT/F㮈} 28žÑ-6ËÉüðµæî|œmÌJ“sѼ}3}ümòêv¢H)}¹Ý:,8åêèWÖÓÑt§6gÑ¥`ˆ$ç öâŽ4«¯™èô11pjñ h÷ÈÏ“RËÒbŒó•*8…^¨ËNgÓãa*Éá(¦¢t·:*¡;£¬rÓy ¾+Ã)4-ô¯^ðz¿t^±ü75æöµª·x­›?µ§ù¿  l=΄̀côã<^Y’'`äÒ?;*@q¨‡NÐ*b"^A‡íQ73¢X‚á¦äpsPýäõ ùcYSwéü?e’Gù'Š¾kCâ[ĺ\ŒóÒ~º«ÿŒ$—ŽJ– VØr²Ì’mô¸O9Õù‡dA±UgíyÙ­8{«úðíéÖ?Ýá[¥kçO˜+GÞ #ªW™C\o׫˹F –½£NEMBÏaqfn{K³1ûZ·˜¡1è¯6‘zX†,9Ä 4ØntœÛ=FÔ%„¥»ÜÙlÎÒ•Èš@…{N™á¥è„k[ÛÒ Ìi°Ð&D(aμrñ‹·ùû‡.â•Qb´ ½ë»BØT·Öˆ£À:‹;k‘Âwn×ÝÊæ¤Ñy<¥DeÕûpnZ¾:~ÀCžEý““wÅïï§D7ælIè“©=Î)q´àf¨¹SeáÔó03ç• "OœZ3Ç^ÝÚö´_XS§]€¦¯UPØ÷þAäøï[žØ%ÍËYcÕ=v›Ø|»{N»:7õkÛ¥A²o< êQñ¿a”6Ã^±ÇƒÑW7`ßây=)HÒ¸HhU+NÚ%¡íŸ–!¤ÎôŒ(Ž'uZfZ óxX(ùÔàq?ˆT媹ž›?�Â6½+<º?µ¢Û(çÈp†À®A‰ÚßÞÌ Eꦄ:£šÁ{êâË£0J[’þ§¹þCOY„îünêZZzÂ#ƒÓ­Üû%cžgÏGÈ”Ûõ‹ø«åð?!=Çkr-­†òƒäÝV•’²ÊäïÔ¸í¤47ªgó€ ¢ò$gÊéÀøÈ'Ûùe§Iæ•jØq'*²OíÅkº&ý 8 sC]`î®üXÀùÌ V ì¸Ýv”µšH;Ûþ­z´ù×÷ ½Ò즟½;SÛZÚJ<Ë- ú«"&pçÊ9Å®(q"6½Ý§çE²¯ê/}Oäÿ©ÜXÞˆuô3íÛøÜz�RVÉñ'ø¾•ègk£˜—¦NƒìËš›Ufph¡”ûn”æ;Ý¡åöÇïܜʦeî<w”Ƥíhs M·ækËøHi9¿ŠœŽU Y$Ï1aî×i;ìÝAi�æ¾lÁ àó Iéú<bizè´6fFœÇ3ö'tä$çÚòàjAÌžžy>åkÍÈ4èk´izﱚ„AÑÆW¾hTk_‰ÇL«SèËB°\=ØÚN°r ô-%ñöÿ/…s£0ñÚ˜*™‰£©ó ˜§Ʋúõ›ã”fF…¶ï¡kû¾s™ª ±ß£,KèœRžÅí+óe;Ùó0èÏEPíö&ž'¼½.tn1J6 £PÂ8‡/ƵŸÿý·†åOõ¤\AÏèà€ØLi½P2´uz~‡ ý¿Ð™ñ]¹Ã°ë !=±ø+±‘ã;Ý$n7e-Ò§[ÖÞÁüÅJUŒÞ?-Œ˜>üŽuůɮ©ç×½«“¤ðû–ôþ5 ‹Ÿ ÄMÙ„ÆûhÀ»C ½º½™SÄ1ô† ±;ëáZ¨>ŽmÔqmŽ{ûÚç.ãx5¤Kònñ•¢™Œkç’¿Å+ƹaŠfL0С˜lG³@AÏ-û ™êsÈìÆ.“j×?)ûÅ&VN‚Î:JÌÜqŽ¯Î¼¡~S?,ðPÖ‹Û{SD.€¦¨Àç‘bÍØ�o×Q0ºRÌÙÚSÈ!¢eÏnª‹–æMÂ\¨, ƒ?¦BÞªb‰z[AÆ ¹ò´H®,¯‰©Qš¡ ™Êä¬âæ5E*1µóœ Yý­zÅ°ÃÀênn^¹~/…È•µ–DÔØnËTÿJž=M<U£÷âôEË$ÛíÄ‹3è Zý––1?TZ‰5åU¥Ûi/$uycüu¡XSÂ|`™XÙC§Óañ¦¸ï°`ñý*R~D=2Ž)Úœ{O•ão„ÿŠÐÕ$Œ›m¯Yvšbs?neÌ:x˜uì«Áq²…Âë÷žzSn¬BX ‹z«ÔΈ5|XëÆT„†òAgy®IPí¾ r^ŒL øMQ8å#3[‰åòjä98 (Ì•Zá0Ðrì]Ž8Œ ‹0♋üeï>M#J—$õÎØKw¾·u¯‘ ÕQÓ¯ð.uúøüWžï­HgÓ·ëá:ö®‚•€ÅÍ5ýï×ËÑpŸë¢çž€IÌ‹j …î~jIçc½LHr,ºápœ›«}õÐûwìb¿ÿ^m¿ô+)ášöv·3ý̆B©¬ç eÐ>L›³táMù ®Ð.>ƺkŽfµqÍ“ö×j./@Ð~G*Š^G¢…Õd£c¢ÿ<QÎÛëŽút˜ùþ·Ìm¥Z+Z>…0®ØûØy|z“cy—”äöö»9-©ÜQ¬0¶HÑàN9L:…ÉÆóÆ(ɺ˜ÃíAóºÊ|—°`ZµX-Y¨§HÓõm׫» _IÃÜÏš¾n®ßǹe’y4\yºyPmÙÊ,•©æ™ Öý=ÙÞç¾Iâð »PÌô/ØI7´“‰¨Ó,zßÑ>åªr/)¦eYØv8 ¬A7@äÜ儧eãë~;u¦&›œºnUΑݮƉN»d·>#k’+îïÊ=!}}6ñÏÃd%XBÇsE•ðNíSRµ ’þ¢µäyéŽýÎXl,e(¸Nÿ::`ñ–Äñ{‚¸jå–7ü‰»$(¥‰ûžóÞERž`îkT™—gcË2Í<ýŽ"8¡ ËÆw•E²^÷$:(üV\¿¿¸?|òÌÆ"t!#íϸU~\.-ŸÕl€þ9í¨wJͺUP3²²¾Ù¥®‚äSWdbC¢gÈü?JœûŽëïR¯VGŒµœuºÊèTžU‡.A„—¼*ú÷:•Eæ“uèîÓA–2ÑëÈ°…ƒ©^þ‡,^¥©ô¥æ$ ¢Oë@˜'¶852«5»Ç^†…½ã<óUé á„L>/?zôàHÏ¢Sóßè`5ÉX3 = –îoeÇ ¬&ÆwdžrXYt Ò—’-yÆŒUÉÝËoª®yÇ*¸‡‘BLeÌcO6@'v]dUV×…ì¿øäÌŒVf„cHXjAÄxŸ<ÆúÜ6æ‚ vA‚Ï]dÅC0�êŸù<vÓ?ÇÚ®[bÝüˆ§æº:‚Xšö´8â±v•�—”?S“>[×û¥!-IÁ(R HÅÓšåï�·™É..ÛÄ ì�pŠÔ—/ܹ驢‘ ð¨²ÚtQWŒ\oNIνˆ"åÇ¢Ož´Ö}Íï{òßÖƒGZF’#H:)J "é·ò:wDËnNå…7Ž`—Óù”†A±Ó oìJúS †R¬,F>Š–þøÒ¸³\ $A[g̵‹¬ò²=8ÔšG´šÖ/÷¿M²pjW“êS‹ �í!ržÞšþ0϶ Ê­°G¯ÐA÷9Ý”œú8(§/o%¤¢QGPûú¢Øˆg ë’(ÕJl|w´ÌŽÑø#娩ý­ëN{JVÌZæŠ-ætÓµõä ºg K„­>÷œ%ºáæ³Úðü˜ª |WuŒÛ6·N ™×ŽõÜÕ={ªÜi_³˜mq/ŠtîÅGH´…3+•‡”Ü+’Û½s>ws™I±ÍBñ®w ãRÿÖeÁº­˜XR™¿°çq®�%Ž‚ôa‘°ºÉÏ<þ8ñ%›$Òáë¬rJ<F6ÿæìœÄIVúÚìky‹-çæTáøî¸+R㽑|áõ¢ßÒ!ŽSYam3œs±m":—Ÿ_(±ï¬·¯t©j\îó(wã#JñŽhs…VêĘ2jæâ;gÛX¦jN›H,-ø]‹KLºÍ—GRB/E`½šSýk™î¥ØVáÞÂ÷ÃH¦FÖpjlÏ®L9ÜÖûrw‰i¸¡¤ËÞMï·ç^Ú%ÒBTÓFój0ù~+µTUéÐàíöç"HvŸ.¬Q…Ð ,‘gÌš–Æ!.úý×dêŸþÈ'éMEDÅmʬÈÄ*éö‡¾ÞXwñ©fR¤WѾ®v™$N3'a…ÔŽy«È×$ùï[iP÷)Ë¿ks3à®÷C¢@’F±ç?ýL5ÌçÙS,ÀMclˆñÑýyþë†i…‘Þ¦„ÞÕvçi #-u4/m]ç‘n_m¼LEA³0UO; >÷ $ß~X³(ÿRÑ“œ9¡5QÀá'²‚¸8¹úúÊY; Õ0^¼%ül»£ûw¢Oéjh$Ô‘pâyïÞÓi88iå)¼J_°Bæ¢õEÉô2Á¤lðô?¨øA·›ì!4µÞW©¹Ç”nÅåê‰j´|Oi¬$f(ÓíO§B,wªû5#ðî/ÑŽÉm˜°×ÕIx?³t3ØŒÃÈÎ\(皃DcžKýǧ·ŠÍ<'9æ ]q€c<âK}EéööÏ}M9NãÀÎ|­¼ŠÀ5n^øC”.YaœËt„3Ô§Ê ×ÓÿŒÁ±ú³íòÖ×Ùü‰ô€-wAU}åç^TÐcÇ%½¢[Дviºµ^ùa¿Y¡»H¢CŽ 8]³B’Xæí0 YIý!m_¯BG-«3øÝ«¼*ÙΙq€ÛQTÛë˜ 4>>Ìz:Áy¦1ójEˆÑbÖ™ÓOOzwNéY¿[wóùΈ§éÊ‚Õ¢¯°#\êen-˜6{ê)Ùìtx—¬+í¼U)]|ƒÅ–~NÓ#«kÌm°ªNeÕ²’u/‡J œ?ôìæp¬wƒß“Ý;&àw·%¯KÂn‰¬ªTš€QêÀÞìé®Z}=xXÒ¾§ïÔvt¯Ðóí†úü¶Ccûæ'©YÀÃf‹ùÅUsAZ†§£Î´uÐL×aC1í0%ž¡½sá5`D>Ž?CJûƺ@'€¥YŒ­AZ/m÷[I»Q‡}­3Ýžm£â`µ€Çq"N”¶Åc¦wÊpù&÷ý')²Õ¤¶¢ ¤ƒÒ×qÐI3Á"lðµbÅ?K@x—¡§ô&Ô�#”f ÆhØ4£-“–UNŠž ½M g³~çaJÇoQj0áë‘·gZ¹¹xŒ¸©B¿¡±.•X]kF]QØ€´^O[G‰ÁëîüéK*qÌ}T½eÓâÖ^öWÚÜu{U›šÍéÄÞM?ÈòÊ+Ï=Ü äÛ¿,çÌ¡z°ÓqØxHœÐ":R?ôöøà¶(Ä ·§«xz,E’¦Î¶Bt ë>’¶µP ¦ì-®Bö�/¡/Q”ù²Zq(}×Q3ú’21¶>ö8†�f]jXŠcÿüÃýÇ:§Aù²üE¸‚h‹. ¥:Z‚6 1bÕÏñIN?áJ"xÀeÜÙ [´¯ÿ˜6­²õfƒ[ˆ¡ðCÀr×WÈMÒÄ/2ÄSŠŽù¬Ÿh!¯ø Óü>)„ùЖ‰ÁIu¥e Ê8YÕ¥Ý]±ÂI5•™ÑûbjÎæ°ÓO¼N.±�¨M€åèá o}ÆŽYºirß×?Efº2iÚfŸçA:ë1-‘qâÔ7‰ä‹B½ˆ¾cBÒ÷`”ž"Ê?¦ÿmÔ÷ýL2bÏ@•Âe(‚ô]§¯îa*;ˆÁR&5|¬RêFÓœ#Ò~Þïhÿ5Ú^gE;t]¨Œ„D'‡‘7½` ‚é0J5ü*Ÿ¸¸1ÂYɸõô[¶X”[–Á^´@ޜإõÂ<±µ9RèZ}¢*ßv”TUíâFiRÐ!‰Ù|©[¤,Ýúú©S}Rõa‡¹×§Ž¤©`&n;ÆÅ—ÑÝœRf:¸x0òÂÏW½Ùï8Šd©ë€0ò¢iÑ¢=RÔñì¥`¯�?KgØ*ã”õ¼Û˜@\¼wÛ-ÝiOC}ÇÇÎïe2`l0EÏoÿ•åû»ý‘ÌÆÑmR‘ŸóÝ4q½æR.°pÊ­A(«Ëc ûU3— zx*0œZØ(ý= ÃYiÙRIœÂ1wåT§>CSŽY7wJË*q*CÌ j*Z<å*ªØ>pÖV¤–z :•e>ù° Ê ËÞ™„EªJÁu ïb2Ÿ Œæk‹ðŒŠO¿{ ’y*²i1n᥾6ýmâÄõÅ– ŸsO¹42ìu£ àüÇŸ7e"O=±›=ü µ¥¿ èƒ6X:2U•)©ŠYT‰Õþü§ŸEpgw/Ì›Œ;ƒÉ¤2@jªW}±®’ŽI%®üØ,LüÖ1û`Ÿ¨ÐŒÇÞãé[î¯dAƒX¿|ãˆÙ l?úÛj…@[`êz¶ûU¥Œ6xpp “”“ž>²¢XÙ0 àWç-„4-éi‹£ÚVÊÁk4"_‘…0ìH=œ±àÚc}µ‚„^ßK»¥?ÿÒ›E©N÷EË0³$l(t˜7Ê*«¿”‹ë®°»Rï*ŠÌ›ÉA<b¦Z¥ÜýëJçîJqã­Gúªò³{ïFÇ…é5íé©óR\Ö·e§“;`‹“ª¾>ã—”n¼Â8›…¯›QƒYD³ÑIàµc0z ‰í–ÌV¤7Þ)íÓ‡¢­sŒgw¢±N£yTâÝŒ’ßã-è±13dÈ»3¸¤öx·P™TÈdÇÓ}½7à £A]"Ó'!ˆ”²ZœŠ˜Íô 9˜ë³Ó,b›7¯kîëªñÆÌÿ<ˆû«ƒ�P¤3œlíEÿ†:R9ÅbI»e®%›E—[PÀ#xuÚ.ÆžrÛ-­ìlÙ{d x´!µÒ@(MbCÜUpÁwrV¾»£w½PöÙªêò"“19ÖñÎ#'_ƒ¿Õ/Œž×ØØM?)Ù¹!3Éñ‘þv¹$OÌ1¢§uéh/C¶óÌ;n€¿�° â˜|ù£²@¬Bä"ÏùkéÚà¼ùЛ{´W™ï�›£Õ Âi§ŽK†;˜"Ó_ “OQÛ¿ýÇÞô}¹HÒ`÷÷z f•Îˆè&^®ƒzÀÝC¤Þ\zßOóðûˆ û¾9ÿë)½t.9pÅyÚAgXr8ÿ‡Ç; ‹­¢a(ÊO>[GÃqÒRÜhvþ5³,WR§Qp‰>hOX ê+_b>N 8nõ8ÖüåT¥™opA„$H¬ç”âå<ÄcXŽñîö+ïu0c+Ÿ¢Ü1ë.`? ›,ɉœæºË{˜'ͤ¦£ÄBY\÷G Ž„{)MD(ÿN*÷óRï[¼‡qëM Æ€Ð¦¢ôp-0ô<Ѓº  ü«”§¯+‡(›˜f–Ü‘j”EÕêÿ¥…©Ñ;òjŠ}]Õ À8nc"ÁU{ɮݱjÞÃ~¢E²†F2 hÕ ÖZž*' ~dY�°4qÙ"žFÜ{QšÌ€—–Ö›3+Ö"DÂØÑq>ŸFûÊÿƒ±«?Ö½‡´0.‹Ð›²<{ï½q5Åã?vøm± �Ä܃&DNQÐŽ ˜…µ5KXàã«)Ë<ŸŸÍéØt"«=c³é¤eF_7ßËÔÃ_ñ MªhßY¸@nÈd²¥Aõc›*K1<aCÖdj>=¾¹iâñh%êApšæõ'�eT$>K‹nx[ÄEwãjk„—;µµYïß/´{2ûLœ˜vePô£Çkçˆ{:MtƒëagÎ!º­,¢ƒÑiRsó£¯-%.¡)k’99� 70¢ñß/*’9–Š‡$Ì1õTü"&~Yg+óæGH†=ÖP³Ø›(5âË›?ô>ù»wŒÑ£CË"$Uš–îè¡çy«M°ê£¦öcý¨J¨’ñfѶ¶ñœ{¨ìèÝêÞÐ¥Š\žÃêŒpXÉ>; †äÉS}dÙo5£ÜAئxÓPú´¨ôNlÄTëÝ/î]ÝÔîYÝio©)9‹lt3·Ù6çí–•]½6£Ð:ò¦}½H xÁËÊGQч;–ûµ)晸·±†Öø¦¦4“»± ÔÁåsÿ•<~\xs@Îb62Š ­Ã_Ò;MV­ýg’m¬ d#ÞÑ ‡tï,È1>Pñ7œŒЗ‡¦Ç¥ãg²²'»<¤ïW4 œ œî›Þ½ªÊ^¦ž*ÓWi_AѨ”o†ãA»Ñv¦¢õì¨Ç…ì#v&6e1Ûœ¶óâxxA£2' 2z™æ¡¿PjÆåZ¥€þ‘)ñ:ƒ‰Œz˜ïHÁr) Ü•éO<ñ¢. ²Ýƒë[{Äíys½ÝstðƒÑúÜ>QmBéò÷|„÷©ßViyÑ7’²( ú±rü¢áØ’¶òØR´s±0Sö³WŠi"£Öæ*d‹ÕœáÅqÃÊAŠi ËòÝ»…e‡kƒ½qªÿ• Ã,ÿ»'åM¶íŠ ÛªXYœrÅ9¸Åxè?¤›NÉó¥ž÷ë„È*ÑIŸ€Râa <ଳ?Ì'ŒSͼ ãP¼ÖŒ¾Ÿß½ÝÉòJO9/( ü»ve—2BÞKÝ‹›¦»²u€gu÷Ò¦zѪV§éÜ”AÜ}ynªTºÎ>™­´ÞÕÝîºÁ(‘:'ʇ[Õ£+¢3ˆ+oSEÑÞ‡^x—‘‡°æÃÖ.,–no›µœâ];N6ìëžvÎÜß ™ÚÖ3¦oCÝÃiñœ`=ѯÀ£¼#’I$•(¸žzúÔ³6B˜çóÿ,ÑçÛ/ Hø“`­ R“û ]Jvº:¡3×@»STiBZ‹[VVAýîÜ\VþMžAš˜àÀ®¤wEðZÀÉ~|~ âì x@Ï�¹p:\<ï-.Ãà ¯Ír\­sà‡Ô’(öŒ<€‚«"?X½Ÿ2séÆ*&}7NšõÜ:P?êRE®–b›øî �œóäE¬ø§Ì¯XKí^>ª2yOÐÕX>éس3a–p9m¤pµÍ+)…“ñÍi‚)¬yANìqb f®œ2tà?úþÐ:éŠ>¤£ -kóòÈ#Æ—,ìÀBÑYc€L߯~ƒ. d˪b„E�ýСÒë:±Ö 4ªè€`rÚæèoÎþ”ê/Ô Šp5¼¢““ž:S>áÑŠ2å;}±¼,²µ7õ‘žMרC»œÍà!«°ÐUÙÿwÊ®Ç롶ƒgš|?Ö»YÐ1ÔÒñw$B+e›zË©g­F5³cÑ|ã+•m§ÝÊw}ß]…~`^Ÿ“‹ËhUà—p+IöÚÆÍﺠQå:±’“9×9óKÝɬðñ›(Ì÷˜8Ž;Dz„·ëOz²Œ¯ÁT_°ÍôuÝÌÍâ: õ&Ô‹s ÏÛÔýVQÝxÍ©S3`üˆæÊwM»xœˆ:8Æû½—Lu<õÅŒ#Øÿ@1Kß|,Â)Iç{¶mG~côSmqºXhÕ=l¡§!²¼lá ÷Ĺ1)}[»T Sê·ÐzIÃíøµ`£³ì]”45ÐN}8[¼E~GF±SÚ ±N—9g½Z'­Eᔶøk~ß³Ÿh«Ñ]H¹)gm–£á«áÕl>#³‚¤æ8ë®nÛþEé;_¢““§AÕì=Ü,˜Üäž‚Ê—¦ÌÏ&êVÚ(5©M av»h9µû“Õ/ßô8Y'‘Ì\ÿp… ¾Øt`)óìV$˜¹|ñä>8û3½”Ó3GãëƼV!ZäV¥;”ÉÐxØ>J£¼/p·=…©L¦÷Ù 3üë• Û~}¾"6¼2Ãüva[æÝŒêý+Ì‹¹itç(OŒ]pÎÕÐÏÜõ”ûÉ[.RL@¤ã5î°ô£C·[ÒØ«=w˜ œ•5Ø"*áG,ºÞŸ­üdÿàI~GyêøMœŸ¾èyZ×I„®æÌ:¢ó~ø8´½³!¸o|£åUyТŒA“WÚDoOtàœ¬òóbU1^}ÆY嬨qsØ•AÙ¼ë Ü«¦~8ÿTœ²Ê„fzóãÔµ&]¾cÔ®ä݈¡HSÖÖù<ìj”jjÓÂÿfwÀϺ榣8ùZë.rH9ÊÂX´D’Ƈ|1–U\xù<×Ér_›ˆ–Õ‘“È4å´Úˆã`JSÝò8£ó“¯g£þØŸÅŠ÷gºOáüîª8,cÝÂÏŽV}G«ª3Œ¬¿²‹œõŸ¸©ÏÂE­)çaÃò)²ÏKh¨B³ŠÏþe_­­‘äÆÍV%ƒb.0 bƒvy¦£Òµ-€î\|‹¬ib¾ƒŠ³çWñ~öŽËíD¤w‡Îßy~űÇjyRFÅE:.ž‹ ƒô@Œ4šUY00f¯jØu�îtÈÒÔi‘ì1¼Mª ²ÔFX~ n812/LþœötÛÛúms0–¯·Û{¿Ò@ÅùŸ�>×¢¥Eáè4 Nf“nLKkùá«çaç-Í�%F«ƒGÏYPãûn0Íþ»êäqœä’ªùNÇöÁVdÀdº‰µ8’2œÐ‘m­¥“ýñ¿Ï6¬×©†«Xr]�¸=?#úà†‘h®˜k'N„[裌¡«Æ½ïMÅôz9ªyå¿£³â�ab„±»$ˆkêb…40jOƒ Ö5 é¼í†^æçÖŠâ lä#/ê@­Û¨ËUú9]¢ œ{c¾›ê-—{¶ñ¨%V}DŸåÑ¢rÏŒ%¤Dü}ë™Ï¹2óèÆä®i7šÃòaã>õŒÈkZŠï)K(]—išLôÔ÷‡‘²æõ‰<r䥄•”ÐíN>wªF‰áÀþ ƣߢºËžû1/)jEaäúÊL£øHåÄU¡œlAë–!—bñ>¹ääoN qg#]“¨D–'Cªáƒ%ü¼üÍPÅÊlFeŽY#Èiì°¦Øs›…zWã‰8Fféß¹ùË'Ò”ÁsþÄ©g‚ý&·äÐuû<£ûÖv¦yh[=Y’­½CÖÍþ8ýß›ýn^Ÿ±ë ºvíàÒ‰¶¾ ™UÑñ¼xÃÿ!­ÄíxªSľæ$ƒÙŒ¸ùt [ì·N œßMˆéü€È/êé¹þY»6ZÏÓÛ=‹Ð€bn©*L]Õr©Ì�;Ú|bԨܗ¿-Vm¸EëZ¨GNTA,,|_6ÈÍ~¹b]ÃË i‹†Çr#=Øj¯3´2âfÏþÚNÖ’˜þ'W™xXˆ÷Ã_h«_Òö”‡S] oïš·sÌÜö<ô½SHäÏÇu»Ë–¥ÿ—Á†ÃyçæÒVQÑÒ.žC<¨`œ£ºJ(_zÇE}¤àÞM÷ÂQ˜„;2+HçTÇ9ŒYA4E„{‹8À¤’ýúÜS< ðh¶¬zlG˜‡±×/‡8ÿ…ªÇy0‘†ç5+á²½q­mcmrÇòA²1.À¦›ý›î0åËÿüâÔׂT»§§¹MÑ’j'7PõøÙ!Ê<ý÷‡×À–‡V[ÄâæpãñüØáLÇ5âÐÅ:Š”CÖÚÝ€5áÇaZ¬ÿÃéÂÉ)£¥è¤#´íÀ°å¨›Ä±fÙNþ ¥œzg†xdîéŽ îr3¥faö‘÷¿ÓÕÎo(õÀLR¨e ºÍ¿Js9ÁfÚYº~Ïmc‘?Ù1ÊN‘©£Z_¼NC¨š<gê¢À¬ V1·ºž€cr“&9?QƸqF’ù 0 /¨g·½*ž–*'ÜÉEO.ì¡e^ƒ‡ÖÈ8AVŸÝ¹c”)U8â4Ž¬CdÎõu¥üêp £± AnLPC€g'Ö¼×Ä™çLAVNõƒ5‡‡) Šù]“0öîc¿{£881×›¿¼ŠˆXÄè H)óçO…å€mÁÉ*'p¨^fm£ÍۛΥ»¼Ï$‰Ò•þ†Ñ7hþõ´Ù12CRÜž{„¯o¼¯Ìçæ’šöH±}W5”˜9Ï­ÐÞu.[‹tÌ…Ü<€Ž1£ë1Cìñ¸E¤û*½¡ å-ù‡2z%ŸÚ}ɹ{g<›ÚQ‰4"¦*æoƒ¶1˜<=AöW ‹ôÅ«Ü¶Ò Føl1ßi{Ã>Š·ÞÐïEs{âN–4eÕ葵d•Cä·Ž‚^²³‚o¶¤Û6²ˆmrï'eû*ðŒUV0rµÓO<Á3#ŽìIÿ Äbâ‰ÞŠ˜Ö{´ˆÌ_u¦)y`°)¶æy·Ÿu5˜pþh‘$‘äˆ!yBßâËÕbÕ oå×r·Žã˜;™S_É»ß1þ@?ˆ;óÂÍ3¡Á¥–vÐt“ÆWª˜Aàéëâž €XñÒXwÂéT>û‚n­ZE°o³ ll)¿ˆÝ3ƒP¯#~»þNóÆ‚ßéו#˜2ª”é´Ûz@…à þ¤%ŒX�wåar"'çj?¦£Ý“luÃF©SHÕ�0ÜQþy$Ñ%±oÚÁ ¾¢ Zk´V“ MM&ÝÚÑæyÒ:ñ> Û¢2†ŽEK<l›µÐÙÃPwý ?Gùs:U‘­G>qfµ!‘Ùwµ ª¶³ê Ms�_™²7u;£GµÙV.“6ʽ:¨”2…2ªý×S_¯í�Ãg£¥./{F׫éýÚ-úOb%à3GË ŠÝ¿žò؆v(ä„ ýu„”bg!-Üuéã·RF‰ŠtâsLÇÔË–Ð×aÃDÚe• §Zl‹�¤‘ñ :Åwù±5‘+M¶wb‘€FE`lÍÚ(ˆ÷ÂI°ËtõÓ½¡²ð[”alØOu“8`3Êý-3júpS`xåY7­«Bœ¸bæ§E±æU¦!”¡—™¶Ö!*‡Nœ=µ\kê'˜?·Ñ²ÐZ<ÊwLwÞ¨}=Í6ž—s{¦ë­‹C#Cw7Zü. šÃ­ì< #¥=ïÞ»y] sÞÈ&¶ˆØÈR ƒJD›z–!ç‡,ráÛ¯ðU‘W §¸‰»>‹éß=˜}Ó1~ZÅÄ„ƒÒƒî»“õ‹4Ö–îòat¦¿÷â4u>ª‰øåR°¬¶;‡y§†§”/u?9ËÁ.®•Ê[áplÜH;Ò›†Ý¿žß¼Ä�Ëæç‘«?6{"ý'®"‡)fÑš¹ËƒxQy: ­S4wu¤!“¾fXÑŠ…-aœL?Ÿ¿ö�™#…˜]¹/¿)[]Äm ÅôˆóÎÎe`ªÖM¶Ñe¼6“‘ÜÚö ŠºUÙ‹Ò(ó;Ó#³F¡yQÑ°2¼‰îöDý=2 c'±U² ‹WyuÇ“ó»1+ç‡v@4¥íÎ…¬½CÑié½î\ýç 9™z³c7;?6)ÏWÅãú§ˆ3ÇŽfäðYRaĉÑl°­¯—%€­m,è¿°\عvïÎRÔG+㌬ÔÓ$E;¬\Î3N: ’zïIÕ0ðRH7zZó(BKƒ—¤eæ«uÓ»¡ˆöšSJáQO#Ôt”n>r³µ~Õ‘ s‡ äžã±5þÌ!Ž"iòUÏq›Q§íÍS7ò,Lâ*‰rc“=½xÐåÌ•zsXNÑä *Í5˜­¯u¥jr)ÂÚ2ëõÈ�%£ÉÓòȲœ!§$ ÆH½.Szš QÙC§["ÝvêDìª9ù/·P¸’ƒìÞWÎjœ&N_N¡-’ Ú‚a½7äH3ÿ ÁˆRøbùTà8C»ÅAþó Ôè¯ YãÔŸÿѧma™M{Ó9�ÄÚXv˜;b³{s4¾ÕgñX:ÃN³ü‹’Kèæe ýGËÆ‚c‘£ òÔ!î]}cÅkM´”ýÜòÏ/,;·sèO‰¦=Ï¿´r˳b†Š‘8¤A2h[‹þ3 J"‡MÒœî"ý=¯Ñ(Î}} ŒŒ“<ȪcÂ(ÞĦQ+[¥Ý“^‹<MB¶Ò ÆíÃj¾êΈ—>Ýp=šÙóÎ!Dö"_8-ZTúÉ»¢l€SÀrTž)h¢³©8¦ÿRZÑ®¤ÒÔ ã‰âÃ^GdP´ê ãEpáGZÌJ§Ôž.,ü…›t©ðÌ¿Tf;­?gÄïìx}b;"ùÔüX!í<t+R‰'U Ä4­†8ˆ'•.¹Âaq(éXzj·¯š®e») Ï"‹;1ùŒ!«ÙóÎRK•zûú27 ²í¯Òø ] kå?ÍgPï\Àp._Ì43L™‚Ì7¾LT+Ö‚þ6-«æËL\`/GÏz¦û}š<±ˆßÐf<—5¥à\Ù^»¦±aÿ¡Õìl!ü b?ñ²AYbðÇ™âÙš$Q°=LFIbî6§5d‹aš¾ìzüu˜uvó½ã™†¡O#c8ZsãÅxæõ´ÅÖs~H\x~§«.ÎfØ mG‡t9Y¾mÈYãP;‰Cil¾ÒúŒóÕI Ò}ëº1I­ÏÎ ž ÌðÔ:pRѼdjùüj-iЊïƒ –×îÊTâi¸VbM�ø£dtkš&0X6½)ZÏGÌÝõV’Eb¦@w¨.d¤ÌA¦ý¿k!VB~˜ï\•jüûmWŽÔÄÊ_\çÝ¿:C€8ËiϳÓwçÚÝË{¹žÄd†¾ÑyïY”â.‹:¯)~qL®³e±TóÒ:}ÿ×ÓoøSSñT{ ©‘roªœÛs_fèµ¾}õ‰È(–t%Å=€0ÀZ@žÿ}K¨¾•r™.ø¿8î[Æø,r{¥xxÅAå‹™Õ›óÒýmîd¥d˜®­ðag;!a¾–C‘t{FÛCÀu¿u‚²Ä×¾�uhFeíÎÙÉmtoî/àÉCËZ2ÓyÇø=)3 ¸Éï#kñ©ˆÇÃŽ‚Éðî€w2ÁÐÚÿ°ãrÄ^<C_W‰oFbìãÈ•.§i↢—-÷"+|øs5oûlÆkå¹ã ˜¬ihˆUËÔD°ÞwG¸ÙwÇQH—mM[ó|¼©i‘þŶ°m“fO<a¹.¬ÇÍtF"õªÔhâÌÄÁ~˜¢ÂÊ¿Ðõ‡릳w½ö›««îzN&™íM ÙcF7›*bìűYP#ëe¨å«xÑÖ†ép/¿¯V^«að±P~ù©O ªàû;M'g–‹:â(ðïò¡ŽJî•q ¶›0¢MÏWW ù¶ð›º‡žò«²2éJ ä}¨«E½Bl"EnH7¾*«o#nÌ· ÊwÉ{ç±Ù(˜¶§7Ãd{dRyÚ7,Û¿aéÀ­úœˆ8Ý ƒÓÚ<¿'Piè}e«’ŒU¥Ã¾6 HƒÏ3àðÖ+ЀœÿJ^:Ž¢8ŽaÒhÀÙ8�6iÄôÜu˜L߀û‡Ø\ªuÓ ½NQÉ)ñâé\àBŽ%#‚n;ß“èØ�&d,…êoÖ~\AÔ»·ýUö3í£ ÷o^ÄqT¹t–² [”¼z ”îµ~”.Šã•Ì%Nð~šÿ50aô(õ5/³½sñ~-R¥qæã@ïG§ãS›« œˆ’›&¨ªK€ý·Ïœ{øÜ”-Ÿª jw:‹¸¤±Mº7W½;aõyW¥ Øÿ)(‡½\{ºÔFHåƒ2_Ôý,J`É\Ãy`J<'zM×ʺQ†‰ó[ªtO™w1wžNô �ç.Â)9-{súÛŽž9>¾Ïr«•E8àV3í÷t[«-V˜¯n  "´¿Í‹hìY÷Å»¿ôTÌrã3ž’œué샠ìM=cÀ£ÔÀ¼RÕ1ó©ÌÍO +¶¡:^h¡›¤Œ,gŽUK™®Ê¢?æ¤Vyèiºq# ª]c–y&Ÿ•Áîßîf¢ûÌgŲRæä=Æ°Ö[ñbš@oôïvgš„¾).Aп½ö BNƒÞ=™Îf«I\˜RΓÐsk<ý6‡±x1áñ7Oeòy¦ÃÅfͱ=¼¤Ä±kÌûüŠûš·gO‹oƒîÛa4KàEÁÛÔËû*· ˜PϾo�Ë9bÀ:›“[Ç?Æ£öTÌ?ØpäŽ%è­Í’ùÜx. vå5TÉÁ9w™Ê±†óÕ³’y®Ä–ÁO?WTFØüOAÄúÙTMðGÂKâÙ©ˆâf¢è±¿ZÅI¦¶íi0ˆ­Ñ`Þš“ClÓøȶ®Ê‚eêtÑmèÖ›A¶ß7ƒN›ÔYöª{϶ OÚvüä\ð´ˆsÝ’œ)ëþºâ®=²²‰F�:“éhè. <wöÑu¯ŠAÇež­àË›} Ÿ[•»�hm³¹Òç¨^íõe}ôÙeFúe<AÂûSq¼”Þ@æ¼ g;8ó415‘窊\9EcŒŽÚÓ §5XžZ×GÿIKïMsî‡WEïçúyÙwômzñ'3 3_ͳ¼-e¶ûÅ3ô4®î&î, w½þìàež:WŠ]û±Ð}­›S)¹—…Æ9Χ£üÉ!¦ã‚Ù3w)"#«‚ž½—¾ÎÙp¾njvY“Lœv‡¢©¹+|ûª–4Òs‘ñõ€ÄÓš¾ó•4›¸žÎ­ÛæÌ›ó`i£Ø1w45nxU¶juæAÏ Vçð¢×_%uºñ7Bè‰ØÒÜÄÉÈ`×X!XÑ#W`8ÀÃj¼cì0+æq ,aru‹ûÌt#†«Qîÿ¥°¶•Uãêख़¶s,([ci?jd'âÉ»xâÔœ$Ù©£ü–²«kLùÁ®¿ôæ;Ηýuz[®íöÐÿð#Hˆ>®DÝ?t·#ÛP¨†Ã¢Å¨ùÆVékÒ¥™‰†´©g}RôÁÃZÆvÿ¥ÊPU¹žK%Ú‘ôÀËóÕërRRN¡Aì]>=¤e¦óù']³…­ÈsÉ"Ϲ5Jbnài²±Üµ*Ï5³le¸›ÓºG÷ñLê–’y8㚘³Ä¾éjÒdå;ÍŽhy7J`H’•+;û¶Xˆ¼Ð¬ k$O–ùŸ$(jÍe@¹œ?-0Š—pµÇtóÓM šDigÄÅK’‹='ÊZêè"Qj$ ÅÜkU]ù ljû :×ã mNãq2‹Áí?îS¿ÜËÏÔ#6¶±ltÝn=cß- .);þ¿u»¶µ¥W1ù§ü¦ÚêȶÅ ™H}VÎèÚ]ÝÙEæ“4hk“ÖCÓÑ›±µºó—ŒøŸ1bª"óÏñ,¸´YîÔ_·çtÈ=×lËMf€Þ4'quãþæÇeO+üM††ßj¢Ìr,Jc‹Q¤Õ8Í6w&©/L­/¿+Š—šCö¥HííYLûäK•laaŠ�-0�ð­:½\M%Î<­³8ÍV¤0žÓ–tôE,ð8¶7rž‘Ï7ˆy²œžaôgäXj×…�ƒ÷Ý j[½|sP•?µ+$4A$rÙMcZ˜Úô´¹½áKg‹å!s†‚[5‰MZa:á[9Q;¾ƒî6k�ép«T´eZª'‰B¥d&x¬Ûi/øɪeÜÅUº²äƒÈTnÞÇï)ËD­Ÿšõݵ£/8S’úãGGØΣ%¹|�8Ä£4÷ƒ°s2ë™9#tH Š9òe>‡Í]3µ¶íVû˜/ÉWb ÐjT_NšQ£³³GCœëߧ¸4Ý>âZBÛg{-‚¢ÕAP¦¢Q·1€;Ù¼Z.ש» j6%mVû &,Éî Yüô€w=» �<#ç-BúãØö*"uÞüÉyÐêc´ëâ•ö§ž§nó+¢VQèÛ‘Óîf}ùâkòê *)Rn ›؉/­ 9›vÊ—ª0Œ#ž ¿æhÇ–Peô«ÎTÀŸ¢Ì\zÚoF^ˆÏÇÿíhM½z‚gôÐ -:å({¶ú¥,^ʉÿÙQ£¤¤Œ±¨7‡NÝ ÍÜþ`ÔdåV.F ÿeõæÊÉCåL/(@{XîéxÙJü­6c»•ÌÌðí¢+i!¿Ÿ‡ÃhCÒ/gøyæë´Rhh¯)Mƈ€e&)AÐî�‡OóòëžÛ©€ê[Ï—èO: M‘¤:–Â}!ü—D=étÍ<õMÊLæâ-W+£˜‹o„rxjù3©¹Zw"AøBF[ýÉ`EÛ±a›z¾5ór† žú,ïÙÌÅqâaWS¥‘Y÷q6•¨·˜^²D}÷í¶<UŽ;ÒÐHG`Ðz™õѪ\7ÃMÿû'ÕÛ?oq)ð†¼–‘óœõ*Á+r•øSÕ tɵC7c=ùßðB¿âçÖˆe^G¢“#µ£\ÞJÿŽˆP<à ÆþÌä†û{6Úò¿ >(v Æú5áYÞü£—d5Û©‚ݹ ²iò°þ º.^¾p9p3fwjëþÈSùÚÈÆÙX‘®X¼U°ihŹÃ%ç¡r @yæ òÝ%ÄõG#æiUÁ šEÙY{ð€øHµr1ìo.|¬z>˜k`{'-³”š=rùX;3¿e:ÖTiœ6W{+þk}f÷Mò§NáøAsf„öbí©˜Že¡ê_4uºeuå…²œ¦mÝ öà8Ë/ÆN[Nb4cUÊ‹o iÅ©½«ïŠqUèsrÔùUe½¼)Øu�‚Y…ü_Ñ«¼´1æ'Ö8%`™åöD,·ôçЃ†Ã+Ýg²Rç þårªAxÆvö©c:hB‰C¸_)´è}Ì]K;x§êàÓÞh»:ð›2EÇÍ{o©Ýt¨3+ï¯,c¢2ñUåèîìwqP4ïž…ºhlj‹”ü‹ÖÚüÞÕwá¥(ó$<¿˜?¨‚}_<Œ±2gŒ@Oeó!Žw®î>úÂÓ‡„RUðA…UVë7çýq­ÑÓñt²5,­‚‚ö:[C ÔÍwÀ™Ï³‹¡i§š¤U!íÎ÷Ó~°ö[/Éë$å AŠ·ˆmcàqJÙ�S·K¢´0}àʈÜõt´FõÅ Ô@ß×TV ¾7×x@XÁ'î"lPý¼·2Ü<à ÝRÆÄì„)¦Bîÿç0üƒ–!G{qÇ >ñØͼ×1ÖM-` l‘@^cMö`Wï¾cA£ÿd¥×îâ°wì(ìeÃÙVç¬]3ø©1WðRÁ´Ö¡˜ŸÎ‰EÁÙ4R ÓÒÙ˜vŒ-Zâçs1µÛ×ÛTy´~f·?Rä©n�h(¼"á÷gœÛ™Â÷CìøV©ö…Єj=AªVÀ 7câõJd•±¯7p]—l¼iì™Jœä3(†¢ÄIwP¤‡«ç‚ï ¹ÑƒwC)Gg±0ý»}<»ñÉ-A¾¡/M»Äô>i}(ßwpýQÊâ›ÿ%õFû¼24§\z¹g½W¸»èËoà´\:,q;â¹fuä€BL-iggžúƒüód+ø”-|²ƒ´Z‘ß6‰D¦¦m=±1äŽÜêÁš6‡Ê$?Öª‰þ“—¦/ Kèz¢"Þ]L5‡µF[ØUs#Ðt¦}Ê*€#étw8ž£µE™8¦W‰ñ®Q±è©Üi6C×bn™ú= 0ÕkdTƒ°&¬hÙõ‘þºŒOìÕÏõL•››— òaG‹çìhh!?îàÂíùÈæå ,;Üx/7žÆ9å°–Ÿž„ÉÏ`@¨>Æ©Ú[.pá2¨>wžI#èÖÒ#Àb?±û²üyÇ›Ö.õÜ4o»„bªNñÕœÃÍUÆ‚¯ŠÌæªî›"ÏÃËÕWWÝ[Y#£ÚÁS@ÿÏ›Vsî%Ewî*Z­çÃMùÁÐØ—IDIîÅ­\´)‹·v¥þá(ÜŒqëa‘û«º5òTBS<Ÿ¾à,;ªLf¤M "婶V¾rÕŒSÊ{áGin"F¬H1 0•;ÓoæwPyé¬ü•¢üñ—HYŠ(3_"åY,2àϽ§ ÚAˆ«Iƒ’{-í =VTÊ$èSý›Ök–Sp8¨ ÷Ñ�míÅCpõ ‘®0íú§÷[‡^f¬ÌìŠÏMsYfþÿ{¤_¬¤1u¤¢]F8zkŽ~!:.¢Â¦‹jY:©°� GÖ†MûO˜F«H.,DSR‰Íˆ.~¹ùóÐp}å 0¾iª ïg+vãav–Q€'ã·�Á¿¶¿mÈg‚<µµ|AKRî=«®œ€r‘)3»@kùÛ2¾ò¸%fÖM’³ “Š&F+r¬!`ÜÅdϧþÀ]æomù4ò-Ua9G\ºª÷¸iólN”Gxv3¯KH839žWBêzNƒdþWÝ,Ð\®ÿœ®¶gÆñõ ˆ]ùÍù {“DÓÎD„[§É–’ç ùªùª‰nô°ó`ûGP¢!°LçédþÜ`¡Ñ1æY;FéJÙ„EˆBÌê£/…go¤ž=)xZh üíψe¶Ö%D;,é­d U�ßÝ¢(n^öî— ²8vG-J¯ŒgÝgu#,à8ÑÇl®¿äÕª¨j3”a‚´]¿8mÖ²¦»xÅÐÞˆ1°o.˜r\ŠOúOãYV‰5³»^r¢,c–Ï_‚‡ìNËDî�SšªQŒg±€‘ã˜î§•\?Ý…{·¯ž¬X;(pbð 7§E4líü„¯ò HƒÍŸ0i;Ü…¹zÝ[z=‚õnø6Qÿ6Y·¥Y¨ºDWÿk}²ôÅÛö@ý:´tr÷õ–ò‹sã?…²Õ£ãérÕ?²D9mñÝôÖ§/pNöŠ²ìiù¾ý°ìw¬!Πveîä´­ã ^%ÏTËðÛlEe*¢ÐP.º/Jà²ZY¼È5k¡Ø)'‚6XÏ©ò¿ÇN‡k ’Ø>ØÈøi³[qø¾xʹûƒ�ó¦Ãøåhþ…kq;Q5Ö­8~�M§¤?Ó㙞‹³Ûž§ÙBôv—’Ʀ«Ùbžu:ÁŒÞIW›~“É(% öûþ·JM  ¸‹*(ÎG€Æ”4d—ú(ÏÚ^|ëîú²V,$&{5hQG?t6#ƒÞCrñ<½ZJdáŽs»Ï=b.š3í©m­`*ôʸ9fä^ºzVAiÕ‰"S–ôý×jë TãJHSF!àœç�~ƱScŒ¹ëíøu-Zú#:Ó¯'ú¬éÙr²ó¬³P¡R·)¸0w„VÞ5 •”Knë�€ÿ Ýaõ“¨Ô?º7:SmHgß_™¢<¿ñvºÔ”g5‹“¸âý¯Ø©}Ç ÎítjgƒÕ“ çVüî7Ú!ßÿ‹/l.>ä0‹©ÌØOž"1Ë[I¶gµ£Åˆø’,äËÿΊWiÁ†5 pÍNý³Úø¦{#u {ú±"òKYS 5õ²±æ픀 ê?Òózƒ®á©wf»ÝËñÌ« Ä£¬¹³v˜@¥¡Òb@À2¢Çùs‰•í¶(Sƒ>•íŠaöÞAHÍjžètïñ˜/ÑÔW�€Q%&E­9<RxaEѱÎyßvF–¬|oKø�£egká@™u:«ƒ;kxyæY)ÅLÚ)·úÜzÒ›Ó8{$õnfÛˆgQì³í˜œɤج�[+òPL5ÀáÍ&‘Í5ÓÂ\Gù4Y1ïbˆâùôqgèh0(ÑŽ å*:Øó® t0®¸›¸9þjb´Lš)ªéÝÃÛR*ÆŒ‹àzÁ¢'«VèøhœŠ 5‘M™‚öÑ1èùNÎŒ\äï}¹Äï2@)x`çÖãÄÔèÌïÓšÇâ9HIx¬™æÆ30†íÃ]‘îôúVƒV½˜¸è$>vÕ\»8ñ·^E~¿.Y?Í‚Â*ºµnKµÓ>]ŒüŸwÙL¬îAÏß+¿ý‚ª}þüèkdïçi o‰Ã`Jÿ*óç’/Þ×÷Y¤íâeçu7íσ³²1¿�bw¢÷½Àß¼µ¯7Øf®‹.­ùxÐ]nèé‹)JùB~¸}åTbþÎ )ÜÍì2aË¿ž€õtj(RâÆë”+ ­œ4 âölñÄ“Ì-h*ìædÝf›ã®~XkyŽnf~ÒÁ,|ç‰{P&xÞØÞÉ AQR8ˆ:s~@ç,·vÍx¢I.aPç3:g‘…>'2°—*¨¶µv1ÒPýYØÀt´rô?ÌO<Xç¹D— ²¶ÈQT&õó_€ÊR;jÌÌ yž)Pî´¹ɧé<´Óò˜ ]s€Ò³½¸å�[äMXí‡ÃòH¶ §õt6á÷åFTTΧ4td«~ð|Ø(€×v„¹{;#’ùÜòókjƒàðÀ|Åc z“V_ú©8ZÐ l„¨3í!olÜŸNÞ¾™»-WVþö‰SÇBò˜—¡¤4HO¾y¨G£É‚Y <J!EÅ»»ÐGÞYø+‹¸ŠÝÖŒ<7› ÇÈfOéJØŽ®>T%pˆ1éÜaú°XÓï,Ó8¦“Ú˜ÃLõ§š¶ÞP1èI8m#Ó–ú;@·®—fÔ6íè©”_Ÿ>ÆžÊ}k>ã)Z?º~¤t]e7„±ƒbâìá\éoÒ}±Úƒ?ªˆãr¥Ã)hŲë-iRö†qSÖ¦Òßâ# ÇÕ”J´"(÷[ÃmIeæÄd ÛyiÉõ»ïÈoîr_¥™Á!<¿{LçDgúW 0…ú,|¦“ü?Ô6™•h>¿-sL€Úˆuík;ÞÑâe+ãó°˜’»Ô9íMÿÔM´4_á½4íÜvë–6´í!Š4ò«m}™Ä¡ë¼\®uõ»b·»ô)Œ©ÁD§ŠrCíp§qÍ0|§p·¯ÿÐYõíÅ-ø,Ê|Lè¥Ñ²Köƒã_ª?M·ÊÜôpñz¦FîQÊß ÖkQg³U</·y-�bËÈaD°ËÒûE]y`»-ÝÀåÀ»ðw1™ ‰¸]\ŠÒMiwª’ü¼Ö>@R¦h±“ȩ̀Q¥¢òE€‹®ã°4ì6Ϫ5I2Ï¥Š¢ë´GÓ¤Y|R}­’§0A'ÁLëdb—-ûzCÙ_ó@"ýfù¢d?@ö§]í„Ý,9Ò^¼Ätâ¦ÒƒãFäã»"!hÀ:æR‹ZŸUç øØ0‰¼7g×Á.²ùÓ 1ŽÑJ¿˜ ³Ò{¾ÐvT/aáÇ’åÎ321~ò®éRl3º;è‚2ô”ôèiÎ'zÕ»"V+<!S6h²Ö±ê Ò§{W+1ýÊá˜EJqýÌÊ¿¤k2]ÛÈl:CÐ=™Ü,ykœxkÌZh¸ûó>x 'c7B• ´$Oéâ'ò»³`´<87T)|*Æ ÉörnOVÿ¦¾Òi¿/ù»B$`"‰�ª>ÊÅ0¦²ÂKY ŒB‹kÅÄ·¼«Ç#ò8ÌVÚÌ8«¨xíµfBGŽ›¥ƒïäÎuÀ^•â÷ÑúŒýŒZ`P±ÐNm\ÕLÌ(N3ñ[ʨ}T‹E®žµ®àýüªÚoe(‚<äA䣢žÞvkep_úÓQ"”äŶ\©’K RÚŽYPö{+ˆ‘îo íý%Æ7)Ý3dW§ª¶WÏá‚>X7Ó Vœ,Ú78íý+I´Ù,ÌO¹s7k¡¾œnÆ‘­‘¹� ;w6š¡ã Æä´�ØBB¾ƒq —ÉÈÛi`b.9Á먞½Ü˜“#‘Àk ²ØlU©y<ÙíÂF¬è h·g±¯w;Û°0}” ¶FTi9](eü ÜK´onßÞZH!Ú€¥,xy½‡æ7Ó]³Á,êö9þ6‰WšÔ\¾SÊb”WBÚáìš7¸í‡– žáXÎ-ëSš™íÅ1FŽžF×T+­=4gðÜ”xÛ]t±ûÁ<÷ÁÉ ’A‡#ì'Ó2ˆ£‡Ls8xH™ŸûôW3¯‰HùÏ´O‚¢{÷°âªYeêO´@�{åCþn&”ä¥ïwÃP%º%ÍÞÓn’Ê]¦\/Å^% ÙóGä¶ANŸv9 )·x_ÿ‹&ïÏ—ÙiúCv61¥¥·ŸÝ`ûÑD1)ìd-ÓO5›Ìûédžžw ×ËØ4èÀ¡^T( ÎsfL§án'øQ–✅ÂO ä½¹Ž £@€úàLÂ�~»~ä'yÚA™`êv‡™[7· ³Ô, |aÊøîáÄHo2Ï’[s‡íøØ;/ ³ÌãÜóÔÉwsõ¥VöF[î§cÑJŒqðÒ,M>'ϼ°éÏ]Ó9c¨û¤‘8¹b‘0Të}ÆS›¥¥4ä_sYâ8ÉÖ*Ì?»¶ŠŠ²2'vý¢­c…e.Mð,¸PIŸL‹#†´Û¸ÇjóÂM"mÝVEƒ-/�'×>ÎP¶wk¡+åÁ»‹K×ÃÆý‡[”`âæ C5¿0CÕ~Èãµ{°ÂLF׶õ—}•š‚sŽïËÐj(Äæ[°t°“¥ïFHD^·÷—ÂEjICÂOh È»^Õßš»E;:6u z/ \=•Èﮧ„´˜Ï^Ò5Q1໸×Ü2S™_Ïdí©ßš•ÐŽ„ÉÁ„>H—‹¼`D˜=ÕÖòüò5lH1ý‰`>Š²v$‰±F}î[ô{pêš u©öÈ3¯#¥uÝæÃa)³hÕ]§P|Ô-º}ÐFòŽ÷zÇVœÒœc\§ÑœF¯55tСUdZɘ¥=bfÄ‘‡ã›I¹XXÔ ÏPâ“Ëä÷j¯ì½š\)‡s›³T€væìå�gM·átƒý5øRœ2Õƒ‘ž×8Ñaþ¥iSeH±<\tœ75ì¹#„iš¦CÓ|ØÆEæ¡(@ ƒèæâõ8¯®ºŒÓrN€~NiîÙ¾ÞÍ^£Cè½´<ÚžöÉN·aÆKw:]‹) Ÿ­ûÝKä”^%3ÂíB'M´|™ÍCïª1•Ê¬'RÏf¦(™9×´£O½SÚ¡XîÉûs6XrÐÂRgÎ#¾ÌB³•(ài96ÿºØ–)‹ª]eQ:Œ–ˆ¢´×ŒJÎÖ£kÓÛìŠÁƒdÆ·ŸîúËÆùZi: fðÿ²þÝsUÝÖhÎ”Ö %<Rúo-60’ú£™8-RØψ×åÐ/&ŒÛ+L• ¢ÏsA_f±2ù,”Hß¿®B°›é2]2 aL²ßhÿ1ˆµ\?D`·ûÉ#ôX)â—9ETÌ(8ÑPÇðÊÒ«ÌôU–2MOpó©\¯ºÚðZè,†³–Ÿ<pœUÖ¤'±?OÌùÀRHÂ<\Îl¶ Ä/÷Ë ´§ç¬±À‘ä2ðžÞS B‹¾¥Bé: H§#ïÞ¯03¬¬)¢QRåe2\<tî °vÝ5¶¼¯bÇ»ÁÈùÍ`]†BÖ§›;õÅBgrÒ?{EQ{5Qœù¬Ç,èg¨ã´‹ˆ§V*왊oêññØNšÉOÊ.£uÙ_¡(FŽUÕcc¸ë#&²³p—=l1ª;ËÚÖ÷!|'@<p»ó0s¹‰Áø×ð?Uâl„¤º6:|×£êÄzhfÒÖ㛀#¥qÀ#˜ËU„nP¾;¢Xd³¸³Ñnšö@ëZÁ›”Õ´{_ ]ÜéC€pĽìÚÈô:ÛI5ÌPHOÀ›§f¾M¸ùK/ß$q‹°`�ú®2—þŽ+ ðÓ·ŠàImäÙJ¬6ãÜ.Ù+)¼¨ØÁŠ’àÙ Ó_ѹ“èôÒ†=&äÁMd®hc_ÿ[ÿ÷-53#JxLËÆ‘|žYeFngêp|†ñgñ¥ý¢©>hÿõ%kÛÈâätò´¹ÐI;{v¢…§ãè°9A!ñ*îʽeåÙ‹±ŽV+ˆV®L ûs:XíÓ=tWw^®< #1ˆ‰[-Î%‰ÔPÎÜüK¿r‰±ã¿82b5—‰búv§f xsÓ˱E¶©e)‘?,œ¸>©³ùpxÆçI™¸à„3›…[ÚâWÍÇÆkë<ò˜¾ØIH0!à1ž¼½×¿nÜG™s'`x(fŸÖ&de]:Œ-àgëÄÈ‚mxê âšêc’2r|­ tŸöÌd(Kܺ¯X<:ã`Ï›u_ŸákVbùá™Úxœ‡áº¿³;;zÐÎ$¬Óòa„.‡$/®`ò{¡IUù0¡tÑ,(šÎAdù¤`Œj�Ñšþ}aE{sEl}PÅnÀ½¦¦<Ô½xª¹«_7~_6=ãþÒ‘ÖL¯oî°²¥m…Ñ_çOæ‹ÇŒÅ-6ùÔƒæÚš’'6.dXð¦«Ô$—X'æå>Ï)öðZ,ÅרÂZß` æ|ÙÌ'þ[õÉä–6Æð5šÜ:¢¼zbn?>¦PÅqúxÊ ‡2¨†/J3½vQž"ý)QïrM',|F7«kÏÀFäï£Å bûÔWi¬†þÏJ>KS¡8xÜgqPµz0ל‡ äz·¡¡s5†¹­÷{ŒttUwŽ ˆ)îöN¨~:573w)Ò+©Rœ¯F]8¨w9ë|HBÐNzúÒcØuÓ`S£ÞÌ¿ý†ýi¾äºCøM %ôê)ÒMïzëi.¨kÍ”­‘öwÜG9@n<ß=tˆÍ¾c“7P‚x#mÜÆíVEíÎ¥‚"+ÃïŒÙ^ …‚Ò×F“œ”ѹÒñxÿÒZšO*Î,L Mò3”O‡‘âs5u¾?=ЮWÎÂãa Tï­kg†“ßâÅÕ•Åv:i7l;­™)øœf)ÏöìwhŽ›Ó¥[]>wJÒ(Ê2çÂL7jG?Új%n§Â½Òä¦ØG«ì0¼´¬œ‡glʉý™nQB=¤-y„68lÌÊþy'Ô•sVA_m.©b-ª…¢ßö -É¡¹6õð‡6Öa•±›Ÿ€yOÊØ;rsQ^Æ ì»+JY/œÙ l g¸’þƒuɹw¥ÚG>1É56Ê»z»Ñ§Šém9ý÷­’ŒõìY<Þ(T#¥îˆ•2(ÇïdÃêÄW¤À»È§¾—6>I ótÅÒ¤³8•æË$¬==îk[Ä´0ŽD[€‹Xx}½=ý-¬NªÌ£YA4­Ï‚°>øG ¿è)0\Å[R+Πž1—ø­4lž¯=¨ÀÂMƒÊ‘$Dm~ØL§íâÍâÀèŸbq,H:1¦žGZ±…£@Dz·Sm‘î[:¦N+)ø*£Š|èLÅÖ3Ñ.¨æwSž³ñÌq<yÎ3¯ßaÔXø%UâíB÷ÈŠo€!ä&'Ö•<¹L¹tWÉë×Ñâ°t•IÎÎ îÒ§¾5ýµaP‘ß⥊æú¡­]¿º£4\„¡Ôu!YÙ)‡Ø»`I;%¨ˆA¾¬\ßuòÇjâÄÊNR5ÜN¢²4\Õ‡à?!÷Z Q%F¥rÁQbLV/§-Hî\!&E«ÐWÒ'Ê1îï»u³çúkÜÛ~h8Ó¶¯Ø¿Ödÿæ§gÛÕ‘A,ôϹëæZK¯EnÅ6Î’åe:/B?5¯Þ+V¦kÓ€ù¾×Ò<aËgàMkg5%ÝìµsW„$åYd„, ÞÃ’3Ûùm91J¶C wV¨Þÿቱ`R9°_Äphn¬¦çÉ! Ì1ÂIwŒ ÞËÍÕxUVEÜ¡RîüîIÄRº5ræ§@Ð $Ó¹?2¯®/¥TîV¦5sv=ƒYÕ[Qˆ õ:ÎÕÙ@¢”÷ù�û‹À_4ŠsnÒhGÄjïÇü×Ù�îú0=Ãõص^£8¶ŒÒ\½n:à7·–Žn©` º#Ô•îj0–RäôÓsïºreª@«’VUN­5i;KÔÇ4¿d÷öçF¦%û„xYXÞå·•ÅQè!xÐjX Ý¸ï=á:ûM©Âß©»¶Ÿ„µupË=•;ñÞ¸$ôvêå)mf{óáßîñ©>xô½+VôS$|IÛ†4³¹£9PþwyøÌ3G‰{ØÒöîŸlùƯøp¬jO@B¼òý7kÝŒÊànŒlFÆfjÈÄÌÚJÍ4»nq`é,Õ¬ MhjM…‚Õyž[D¢WT±è¡t‘+Ì)@{4Z[w_¢û¿oTФIð1\ÿt^—·„œ½®ÕÂÁN{è¶ T36:`eü*�E‡ óžš»¤mÄ°G–Ìéi±gËÖ‹wKw{5ú¼"êü¨¤IÇ ©¦øA§q¿õ¨€5×í’ѳ/Mð˜/€Êè³ø2a‡ zçAheVø±²„¸9ƺ~¤-ú˜ÖmC‘ˆAÃ΂ŽÇôstà@è"£wÌÓ ŸeéQVÐ!ƒ$ãQy•;(¿Râ;ÖÓ‚a0- °‰ª¯PÜ37cžÑD«´Ê"g�IgØrºg3H-4r:°‹hðH~è²ÐÇ”g†¤pÛÓâ¯k‹ÏlŒ*Ý…¦­^€-¤^ ‰õçœVÈû—WËŽÓá8\ÖÀ²RšU0*f#.ïê{ÅT¹e©\— Éç/íáÙõÀ\-%¯¯á.ÊÐæëðýçÇ7ËóéãÛ…á*E3'%Ƚ¬¹X­N]~6JMsÁßÇ£Ýk¨ ¸Z«€\VUfôºŒ5éOÎ"ôÉãtÔo.UPtJöDlèñZOg²e8<Zaý’ét¥ ÀŸjÅ^g™-{/5íµeòÕzF®z„JJ p†ú‚Û$òB9rú ž„›’ 7 ¥ŽÏ#† _îh³©ìar)ÛŸÒWàÖîM=L—­¬f¬ \ŽÄÛ‰ Ó¶»榣›±íÓî¸íØEéÊ ­"ó ØÞ fúr”¯ŸÚŸlk}Ç^e‚Ë@q¾W Z–ó<uW«}ùó‰SÍʶœq^L¯ªÉEa&†�U®‹ûÒµƒôù—wgªèÏd¾~hXŽ)ÙkˆžsÀÙ+,4_ê`'Y²âʈÊô¡ëÁ„e­sãM6OD ][00]»îõÓÊQ~˜"Û}QêQ+@«Ü8a™›Ó}uìv¸z±IñjÜIŸy©é=+kCE7̓Ƞ¯Â, n‰×ìŠzm%{;¶kibtÓKCYë{t¦Ã;zXLšù P‹ézlNOL]cklŃì˜Çð˜Ão=22Ýlœëa@­l^c÷7çæÆ£“±§»·Wlq½t éñÑ]ñ‰ÆÞ4>ì„íá/lÂg=™ÇË ¶höˆÁ‘Ýò¯ëÒ£ÃJ^'tÖ]<”6’sü~€šjgȉ¥Ä̓´ë­5oxøË£·¶qÝÄBekµ9wúëñÙà1VW_=­ëÍ‘nš×ÖÙíxi3¡þµþ!"TXOWBÖš-îHCTV„x¬”QÎiß)Å }ÝëG7 ²çÐÌ+êlieÍ0#®Š@«MÆÝÊ›²›¶¾ÏxÆ­cw$È•;tU 'Ïù½…ª"êÓ‰±:¦¾ùñ',±EÑÒnÑ1ê?½eØÔíÎ)Ÿ½Àu´3ƺ FŽ•i£g%<� ©=¦¿jÞpFŽ®PÿÇu9ĺ›mRÒ§U°lÊõ¾›¥«>3ó þÁb/C· }É)±GŒ[chôÀ&rðÊ•So-þB™§ª,tP à™XùÉóôå_‡±A¹G4Í\iÄö–ÃQ~kÅ{¢šºëêÀØ]ÞÚóüËx”Æî eI†T‹tè]D?üÿþ¿5Û0,­öã IsáwÄV#&O¾Öå·‰m{ŠGçb<~ALJHKºbŒ¶îÏžèŠ|n"¾R³Xý6ÓKÅ;¯Vý»"Vƒ—5;ð0Í«BC·b³O)Yl<_qÃ{WvË ûßô…]ßÊ79ëè¤+¶ªfÜÔŸç¦~k·žaÚâ;ŽÔiðÁ>öQt”øÞ§‡%™oãŠÔgZ[ÖlÁjOb›ûRGñý…ÖgäJþgöç4È»Šð¸ëùƒ–¿Þ©ÿ¹Weå¦ã©‡pA=xxZÖ•¢,ÚRZ»nöÌ¢jÊA¾\µÙ‹Ðç5ÁÄrF8êÔ.‹´Èƒô·Îa/QœÇnúçX*Ðú7?²ŠÌÖƒŽÓ)¥½^+Ö.fý•ãa¢¢LZ¤ô¾ÀJœÚWø¤Qê6˜Úe°o+ ì‹·¤qOX¡X‘;ôVHp¡”vÜpûŠo-»e HXlÇ¡¤7²ˆa¤œ'h¼¢”§8ÛñL~çº 7Š*™.X)ôoPÁ•½M·À݆oOº!LSO"ÊõCý‰_J€-AâlxšB%ß{9ÿ7ŸÆ¼ŒÓÜÖv J Çi $´ø„Á¹ÇãPý×»/¡Ç‚ŒAÕöJ1r².aÈôø¥·“µáOgìèúîŸíµo»;®´‰ƒ³JiÛî!åÜ{ ÌtjfƒLáŠVõB¯g8טO¹þÉîuI²Ó¦˜àŒ;Þ¿ŽÊÓÉçA¨‹~ §×çn8€yÃ8qû5ßy-¨c‡´;ØßYük׆L¤>Êñ˹Ñ®—=`ú=šú¯K}Äžn]n<ïßÿy¸#ËòwŽ÷)ªaÓÕgцÎñtž<¯8:>çþt±ýö^œ’{¿LX]“*ôÉÐäèMs[¡¾×ó‘êúª—a Ãb{¦Ú*ješ;ŽÂj¾ÿ´û +èÄü©¨¸þòxvÍÔ9“¶5£ã74GGX{n hù©ìŽMÛwÿEgùþêð‰–Æ,—cþé2Ñâ…¢jM9Q*N©Oj{µ%ëìN—Ú¦!Jð|ô h^år×Y1?Öakòû"a÷Üsˆzå¹æQe1k<=êºÜºÍ’Ì£+(ñtú€u¤æ¼Ì ŽÃÜŸ¨Ð©xi©2 m÷ŒÄˆ¿³S³³PEX–ÏŒ6¬G‰¹Œ%üÕ¯ýˈ‘ñ+=l5æ…JÜ­L¼­X^\u¦Ðsä)ç+©š‡¸= ŒÉŸóÆU¿çðiæ±Tyü±ùÑäÁ ìgOŒBœ¿ã> …Óã‘ù ÆÓûá(®(}ßpJW/[T]ýu�<–E4? á%§å8-Kë pž1¥BÐ3 Øä¼=”Ö³¦j5OáÓBw^¼êÞÚ1(â÷(Ô¨õë=(Ïd€¶-ÔÕgíÙC×´ˆß(Cà™l×v×ix²%­¾Ml4ZèiŸO"JlSÖ+è¶5%4ÖÀ㧕ÕM}·9ÂOÙ’Îrâ÷½¯Ú&a¡ýªm7Mtžý�WÍrçýͨ۾§ERí<Q^ãJñzØ¿L=1~ÑÒm¦,ˆê­V –ƒ™U˜(2ÒºìWT™£b%øG±£GýÁA›¢6]}¦áMÀÒ’>ž.Í„¬›ürÈÃ4[Ù†/3%`ŸïŽÛŽ\¡Þz<QGü•È½MíÅð›êà »«‚ZpäÕ”#È(Yý<ï~àû[ëá^/"L]Iq²6�/Ò(M*ãI9•zÞm«p¬»Û҇Ѱ?ýþU<Ù‡PMëdØtV LŽimr<vŠ=q±vvô/D­BEÅ6bY;ÁLu»¡CzÛ½8>‹gJÊ÷Oþó«Ò4ZAé+ÁW4n”AÊnz ËÞêÒ=i%f‰+EC{¾dA¸x†—G!®æ/‹0JpSM6* !Ç[ÔVŽ7ä ‹Þíô²’B•¸èÆ-ËŸ„Š¶‹gk -Nd/cNo²²›Ÿnªj5A)2ÊûÞëNÔ­,Aj5ü,’äã2óÁˆt^/•>ïöÓ'£ñý’!tkn†wù íøì²ì“`³�5Ó80*n§kd$û̱í$¦¿«M§å­Ã|ÄõèiÔÚ(jò#‰h?i{çYœy™WÙ‘ ´ b ª1ÑœP½5EçAdYëèÜÞ“ÉW>ï‰x‰½_mÿ%C ç%ÖÛˆÿ2_¯ðæ´ìŸ~©Sº;ZÖä »Yˆ*€Ž²SÊv'<{EÏ  ƒsì�jë¼fÄYj¬ç Žu#aÏrx÷ ²Ì?+ó`ž�°¾z¤Æ=Œï¡Ç 'iô{—·€Š(--Ã4)KÎöšµÒI¢ "þÂ7û–)RࣙÑ*÷nžPIá œÑfùDà·JP8Q0 sÝ(Ž`0:\ÿ°Pj¡Mg¹ö¬g~ò.tFå•F!úiÓ±nkeg­ §ulœgkGFšÇãEÍ0!J¸?uÃáK†­/ŒÍÓÌÍÑÉs´ÖVfPïNXë_Ò åbŠynþ-3˜ýïgÏ<›ÞÏïáÀG©ï8 Ü¿ô:¦¹:³ÿwÖN)u©¯ýir“;žß¿³·Z~Âø�¶+ñ—Ç/•šA¤­N?’\Tú½ÒÍ•"÷}�"FµÓ=Ϭˆ=]0šÒáÂÞóþG„{^¹ªMö³ø®„ úåê ª¾í¦ƒ!Ú ñŠóï[§Ðpe³DÑB¿­Mè}¿;Ò29žæú/È(³¬‹µ˜4mäýÞ áð=<Z‡Ët~@À€6qíxæ…C.)jô´O#å:)Aºa-7["ÝÑNºÑPŠrÝÅ™QúveíOYt¢®¯éà•F”—z—z¯žÿ*trœ¢agÐì£iÍ“?F``w‚ˆÌÉÝ2 ³DeààKübÕ~ÊÜ: tžt±)áeuìØûç°ì¹'DìÂsñbôàx_èâ lñ4)õµÀyË!ã|Dx½#}Úé_oϳ‚âN7U¥luH—wÓ]Ïù¼Zé „ÐæfíVÖ«ÀâCß"ZE°‹ïMËîG?ž¸,2Ïä lG`ö +“XŠû²ïÎÈ­WƒgýoCwZæ4ä£ÄI>0Œ`s–ŸöŽõÕ¨DwÖxX™‹ûPÁ$4ôFk¡'{•£ÌdDÜ'Ø|ôÙLòÕŸ[ÚÕúbº¥0’©xÝBÿ–†SÓâaò¾ŠßÖo09}¼µ13¸09äÊ'fÌ+¥¹T¤Yiµ¦Ûw™à‰]ÿ™Nû»g!¥WŽO:ž%¡ ˆM§t7šfMsº0 ¬äÌEÄ^Ð:=>ó¡ŸK„Æïp«‰í àÊ °¯ã ŸäSÇ|žÂ *ÁâŠ-‰ûâð7ía«Tk$x à,moø8Òt•N¤I°kQâzܱ)<Pe!¾Ñ‘h&Ë“O’«Ø7³Ì«yï=%0ü³Úø?´~<—¸ÂÌ®'8ƒ1œ^ÍÙ»'?ì>¬î]ë öúoˆ¹”×3åX LN¨L‰mý «íéKv¡‚^F¬ÄñÊ4tLJêËÆ [©Ü?Ïd ìN;ÚÝŠÉÜùI`ž®„í¡sÉ)T)Ò“'̘GÌûÓ²<RŒ*=‰Hz—`ìfOXaÄûtuÃÁÇ=ËÄÓi`.í.*,ßUƒ;g¹ùis UãrÊÇró÷•ç“ÄÉóĨ3÷g(÷õg×unºžð´]†£Ø߬EPF‰ý‡þV{Ñ ¾Ò0 ¹kX¿jzDî‘2æ³ï38Ò¨5$׎Ýa‚CÈêìºí•ÎýKßSx:Ü1!KsÖƒƒ˜akX¦¼‹a>öß"#H]a¸>\-lˆ+–Ký~±Ê[Êl¥FÿäRÓ'赜`å  c§6¢ýF8ÞÀºå>ž¼[–$fô¡‡·ˆßšŽS(U­M•!±ƒ”o2hÙW´ŒÒÂz—ˆÒ–ø]?^¢™ ‡q»¾^)̯݊²bŒßÁÞz:Ì\|Ï<F´U?nÌÈ9Ñ_=©ÿ«tå MyÆ‘6Ç×l ï9±óœœne¼ÀlgAÅEfc¦óìTÔÞ1R۟ͪ˜·;¯ÝÃy²chõn/heTÙ‹o‚F–>)Þ Oê­…‚jE1°J…áã$ÞHßó¥É¸}"ÖzØùf�7¸ydΟ®3À?[ 4˜—{½ã¨rî»2j÷EP~]U‹YR§Ó¦›@ÐõŒÇ¼2K;¸‹´¸Å]øÖßR·O;Ï/9EÑ;ÂÅl²²Uz’ëëÒDZ¿Š€#­)[µ~èâ;@9×›ôyëy¬—éPƒ {…¤@Æâ›3áÚ ã(ÍýVaéØì<Øe7hFAÛŒACÀšŸF©Î¢IŠò"Ø·eP³OŒE †9sa”Õ¹mmñôDø< }Q¯°•bGZ ê=É¿ò²Ó]êÔhDâ K&·YI©ˆK+½yX˜>yàì¤HÑq ½ïîÓȦÛ-áùèüivH†‡Ös¥«ë¹”¡ðŒ†%\†Â�oÿ6¨&ÓËü<¶wòqp*tèÀ”Í31ìé[7ëùѪ0R(3�«ŽJß~YçNHu7¿ž©Â’÷½‘e>lŽ6ºêE§#ðýÔÑK÷öÀxÑKköÉH�¡i×±œýK]öÔËG 죙Öa:*I´€üOÝ|\úût£DÛR¯¾ÉµájŽ AdÔ‘Š¨§ƒç4ÉTcý_PÙÕ?Ìûϯšá¦eèsTiåt/ªDÚÛ�x$7Åu?ÄwÛ*,Œ%ó ¨VƒÐ,ìæå«k³m ó9UþÕ^êϦ©¢ø—Å´xJ,—rs:çp„‹BÍg©@H–Y%ßè*iæ� ‚GÃT2ߪ£ÈáH©õkmªQ’Zx{þÝ%G:±"µ?ò,èÌ<88ý«›c”ãlUç©óü¢E<\Õ™Ÿá,¶ëE–)ùWÛ Ç®g«}oJ³/³ „èNJ%øIÌ�^+‰ìÈðØÂOu™ÝBeK†Æ~>”ȽÇqÁ“³Wè(¡¯AJ™ïÐF­Ifv#}™±ÛØ*£Éeø}Ðo¿ûÆ.=Zû‚O»¸ Šýì蹦@ù-&x|‚šF›wù³]fj‘¡Ñ„FÁ}Óiˆ0l<a'‘ç Q¬€‡Â|…žV¼ÿôB*Ñ-2…ìÓÍ*ó ÿ,vOeÀY K¯¿¦N´Ãîä4îõuuÚÅU¼òÇB¿ [ûÚ99_öו‚þuRb#-sò‚óOÈë)ï¬`ióžPcàSyTôZZáÁ9‚K4èž5:‰ë¯Ó e¸ÞB¿Hƒå<ýqR?/Òè²Ì#Ρ îä<zª}GVT›‘Úu·¼Åø‹±/°Îàͱ zfëK‚ÃÉÉR¥lÍò½zÉãÐë÷‚³Dy­–-‡¾3ê¦^@È‚úôuoüØÅðÍëý–Pê„~e–ß$´oj+ÉSÌbÚÕcð#9éïÕ`SG^š´e-v[©B�ÙxÛZT~dzèÍß'af±%ˆà $2#,»Å›¥yIÁ: ‹n®p–½3 |6̳ðV°xæ^|÷ š®Þ )âœn{ÞRa7ÀB×Y|j½”94¡é…ï:¯ª3ˆ&˱ÚÃè7"Œþ´Â*ÐôÚ—Ah9^19]�‘™uNý³°ÉZä$_¾3´ãßÞ·Sý±898Ý+Àº¼p0•4 *:¿t²a—¯…)Žzoë•a,$%OlÈä½Ø³~eòÄ�ãKtf—Ó•�ÈDÀNô b HÜïÿf¾™{oàE‚ÃHgs1x¶`@¾ZÍ�8õ±z.­0ã…sGUÛb°ñFG×ØQHšz#¦€Z<49”Å´0ér-hü@î�ªuiRdVÙ1†ËVðø¿ê8fŒt­§ã.Óé¸}u›9ô\”â÷CTŸ½ÃÑQßi7B¹"²yý€f©æãæ·ðEAñÍ­¢03)îÎÑáÃóÀ|ÑÌ+F4ªÏìëÊÕÖK³À•bW„?LEZg€(eJ8÷ÆnxXøö9ÆÞìpààcIXnÇè÷Q` ×|T&8¨];$¹ßx—¯9Uú$ÝÙ"÷.ëþ�s€±•šáz—/)²{ά¼|0Õ¡ˆdÙ˜l¡x–"NGvË@ëëî9¼ó‰qÇ«ÁSggsl4uÒ ž¼ã¹?ñR pªxÐ_ö�ÃB‚™vTΦ×Ö›G_º¦¡ÔŠŽG<ÚZ¨ì?u¯’Ä-ñ=ÉÀ¬wè¼kW÷‚ÄeζG/4÷=Ê$,‹¬t> Êzxª¤"¸l¯QoéÈugQGÞ`86lÔÝ©µèŽ"¶Wž<¨Êº¼~†IŠ+Ïh€§ç XÔé—5C†Èµ²eäó¾æþ›dÞÜ ³$(·{ÕmâÒåúT÷(CÝ„¾ÊnÕ×^5ËK_“4f+\Zdó ”yXE×í•‹y¬ýõx”?!ýr­¦Bcï(n4V(Ç76øê z͘ÂNÄ>¢Z…íd3cpúÎË@5ÌÂo‚…–©ì~‚«Šªñ'—Á‰qߢT»î½Ñû³!|úð>ŒÊk,FûñÐ÷à}×îDG‘¾<OIV&´t}œ37Ûb ÑkÓ{=/H&†ZÔgÚ…¬^o€c·ªö“4»’/Ÿtûw³1T¦¿\‹ÑµÁ,¨ íôyvÄóyº‡‰¡E±Âk>XѽD `܈#úíµsý®èš†®èe‚›BL–ˆ“ù"}’wJ'mäBþ¶Iô´ð¼X”Å ¬MÇ¥Çð¿éû{,nReЧA2Mºm€ ?éƒûÖ‹ø2óµS £œ'A^{Î+td5Ž¶{œ˜ÏZºáS/*œÙ|:1 û‘>qÞibûKÙÐâ­Žë†.nh«î |Œx° PÂñ¢Ü°E³#üòˆ%·¤§ì¹_PÇæÊŸÆA™›àS´bHZñ>ùäc×y 1MÅpq§DÓî',Zô»šXùeeO©l¤`æÊ£©‡•†¤’ìr]ýéß‚ÜÌ76ûÈóÎz ·ümåcþÔ¥$ Ã5€·èVîOÇ·ŒTmÇïÏõÓ<\;-³ŽD_{SƒñÄ•¡m¶½&%a-DÏŒ§ËªèÚ««èRØëë¤à)À ²>œ^�ÉN9ºomk²³8Ë«8o·Ü€<-|´…$u–*ÕÂ1JXŽEšAælÃn~óJ�¦zñ °‘ÉírWfên^XøÞ!?ùœiAeŸ‹Wsïêê9†|Q_ýöb|`u!ë…' ”ß¼7žØÜEàÃRx5õæ<š?éSD…';ÃˆØ Eæò¬ .:øænëµçOÓă�–—{:”³ãÃßÍ)Ä—Aµ×LCFµõy"ÙfÉl Ö2¯fµYåX’ cü]~¶¥thA£r£™þD¥¦!YøX< l\;ú½å¬tâA2°=ìxííy˜4“+ÏE ›±_Âð7C9› %xSû±á¶¹‡á¢ÕãæðѾíkJìtò‹Yˆˆ6Í?˜%F‘SßQáÒ8 ’QÇ ­Ô¶^›«¡Jq—üuÁÒ8õ¥,éßa7 Yí¥YCp;Õ³;_7Ò§ þ¤È²áì=„þô§v¿Q?ʳµÚA–d§µa“C„©ÎyªšûÏÛÒ°vxΆ‘ü·_8žpT˜×y }y9ýÊ0÷!|*²ôJ­A"óêÓx¦„î{çüsyU°°âŒé–¿4Ïinè«®¬4 7ÎcÄî G­œû"û>ÇÅÀJ{Gjn½V‰)•Es,íã¯É#×/§¾çV!g窸¼w}áj“÷RÓ„“÷w«·r%páNÞïyî?ßpÔÜçgéÉa�´ï_¶3\=¾éf¤é>ó³ï’b³•×-ð”ÞTƒÊ®¤ÜÊ;õo`‚Ïõ°liŸÐôŸ›Ú;lòT®¹„ Z5w "SW exì궅ü‹Þx‹kÎöZá0Y"J¸þRúØ1i†À™IS+ƒ'qæ‘íhó^ RuWT•Æ·ŠÕR£ð‹T%QJc;ž¯–° ÎæÔûH¾±§‰+õâÄ}ûå›r8e-OƒÓÕg´¥!=äYÄF«R™Oö¶/˜Ö›Üi¸é�ùåb'&d"Ú ,»ýýú«l`‡ùBÙIU+H#Œ¤"SàïànžšU‡¡/àK›5<-¥£áíÉíŸ5<‹õü+¤ :2›§ïØfÕÌþûÆÜ/DZe~�&XÿÉ]}'ÌV¥ïæEË´ÔµlÕm‹s7ÑÝVÜc’"#„©¦AøŸà¾Æ„M{…ñªé}}s*󲣊§ýSRtãáV6ˆn‡ÑOŽXTlë_]°Œ±ûV•eëžèîœÑf»j¹˜¥F©ùÑ;âV—ŠXõÛžï\=݈•+Gʵ¸U›¾O®'Ê®&#ºiךž­=`"uWî¾€kZçå¨æ`–b>IÓÅ,haxZž§m!‹k1tr ”û‹'ñt<XèŠ)3­áÛ+ÛÀŠ=¤4ëƒ Õøí§‡"¯M–&ˆ´h·=ðšxeÜTº#-º3X.ÅeÿÐ{æ‘Ê…7åÿ}[}‚ýïn×9‘g;+r:³øv"ÔØQÌŠ·£‹–b*c šècð(œ•Vì7º÷’7oˆP° º­i}ub:Æn ÙFØ»ßõu+My5}`Ï^8ÇÁú5tdU{]ìh1nhãOf:®­+L2e®ã!§)àXEKIŸ+ bÐ\Tä0eý9ø<²òKèœW;™¯¾.Ó°]DÛÁŒŸ!Ë@• K€ËÚ: 3FÈà5[Â'ÁöšѾ¶à¦ÃäChã2µ¤xQuA:-Z$hB׎‹£Äo´PÆQÀd´œ4”(ƒþªyè¶"8~ÿ’&³<ãCž´{dž[)z;þGüx•yε%+œt´ v£Ùïõ´±Šå¹:ñ”U/ÍõvZó¤ËswØó¬|׳áÔ§wÚÃBðÊévoNT¿™àþÚ_[D}©^e×Õè§5žç)*`R´;p#F>Žg+Mýz–í$8Du`a}vž:¥6ìkåÄÉœF2\Õ¨¼]ëI@ 7?zÔ•- 0u¤»•m{-Ðïï†Á›­¼N¸ Wr*ôVÃ.ÁWq ˆJ“ƒ,\äAòøÖ(Ú,RSJá:A†Ú±'æÏnÔÊYÛ{ :m-«Sæ-b„¯W¥g',2¤¤Õûà­¬íašñÜ3à~“¢âmÓ5@²ü«mƒÓòSKŸ¡ÇˆÅ=maÅv´œ™NnWåû»U­qæP)AYÍôÑa7³Î ‰Á,±#ñby*ÁbN›;ñëί¬f¦weEÚÕ“6À¾Î‚x^\û•²–asÐÁ‹èË3eïÌ›'–‡úÆìÑÅ lF&üó bÀye)F3Í‚rþÒ¤F>Óq6•`ªé0é{Âg‰‹‰Á…0W,¶ôí< ¬Ö²éÍÿ€qŒU…ÄB5æ¬ögAÒ^çŽÁ·ÒÝó[†®qƒ½Îyft~i…4WPó°À Ûƒ'qzñ£˜oæ‰T°–ǼPˆï&y˜¬=›öÆ4pWÿ0åŸþz¼E6FBÔriAXAp—ò‚~òËF™*(H?,Ja jPÈô/9†Ý*­7 >°Î€ÛNZÅ—X“ l[ÛV¦op›€£‰¶t5´¤evƒ#ú ÛSÖVJ,’´­3âø› àÁ/âcrO J”TšŒläóÖÃý¯ÍQžX½«­gÈ=½8_ÎA½Ùè¼  {ƒòMŠÌ›tÌ�áºaç5 oÊöWïJñ<aåÙ³C¬Z#&’ ùúôù'órž@mãüthô¤Sh2ý }|CZ{LžR.,¸›a­`KžTõ=œ¦ß¬îÏãÓãÆ{#}Úlú×Bspn Iù›·ò´¯±ñ2ïæWŒ’¸&T4Õ†3_*;Rsãy?QÒÕÅÝKþÇ Nh¥c`G™"cs²CIäát`tA¥uíkSS`[úúrò§ñÙˆEå˜&SBØ[uñjâ4`ß).ÑŸ£hÁÜþÜR­<ßzUèÒ(&˜lúÌgëY€"†QP-Ò,Yæ¥B9)V‹“’üé! ¥qnþ Õ£l‰ZZ*€oÛ ßÁ]œ6 huѤlRK×ÓÀ Qç¼|²üZäßÁ%@·d¼x¹tw•ŒCT“4ú%ß^}îÈLûæpV6áÏ«óK¤Q5É»WV-N2U O»"H:MåcO)²êF’Nåâl!øîÍUí…iƒYPîœÛX4fŠ«ÚhõØ‹úÀkÜ¥Ÿ]é(8Rtˆ,Å ”õjÞ„ÈÅ…º—¸ó†½›Ð'…Ú»¦¦.™/8[7IÆ_c ¹‡Ï¯¼ß3ônm²ðˆ~%ÑÍoèâ"»«XíOýÕ¸¿òý†wlî÷„¨ w”Zß8óvH¤ ¥oÑäy<]pÚ vXú"ÝôòÑ11Ì å¾±àÿZ9·W ¶€W¦í šýPeÚ÷ÀB±RIìú‘V¿ÃÜ |¡ñ7vTf£2a0¾®§z¯»zhm zêÃF®¿ƒ¹¢ZÊ%¢'è”9c™‰µ ÝÛݲg$5ÕhÝ(ç$ ¹WCÚµO7nãµvZ‹QmþîoŠ©}^Ü+²8LýQ(Ò8"ÓIo5Š!Ší: ,õß‘«T‘ôØÓ?X|j½Â®Á=V{ƒFfI¼í4òßaÉEaä{†¤{­.’¬17Ä–èÖ]/øÃ#‚rîcï|ìwd>Óv´›­¦.”HÍ|F¬8RØùá+}¥¡ÏºD&N³GºÜPr|a`àÌ)9Ÿ‡ðéªZÙˆ”hÐ]xߺ¶ê¶›ç9ôJ[ßÒs¢ÄtAúåÐhË¡Pä¹Udê ž5…è36ôä#®~ð(3aaH´û± ÒóâejКYSVL±¸ÉüÿÀ ïüêÐ/`$´%•V£±Qɸ5Ì~k8X&þ<…V74åç§w¤4pz]–¿%Ð8@¸¤Ç)F‹t—>‡S÷$„MAŠ^¶b|õêNúþÙ=TÏÙà+|Lݽ^_«ž“¨²ô‰ˆ�·°kÏžŽŽFÈô‚æ O‚óѸn£¸s½3@¬2_Ë•pM“V H˜fdw“(ÃØ<òÅtûþðìÚQVìT‚é}}Ñ|C¼î»ZˆtzñœZ²Rï¨D4£Lx68‡Æ¬Kï½*¨¼¢ åžïcP·TTƒ¶ÍðþEtÞ·ß:L÷»Niµòü¢Ÿ~)U'FÏåûbÕþå<Öמƒ™×(f,îõ'ó>WÐm´Éinûýñž ,͸`ºØ¨ÃU”ªƒÎ ®C·;‰Ýûï4œ2°†,²¢-O¹Jheµf¿4­¸ Ç€fp{ÔǪ¤n‚w,Š¬ÕçÕë#R)&Z䪢ÈogÃp=v­W ; §Ü’’êhJŠ¶wæîcÍêªöy4ŽNºçkG›"»AœàxÚ¨Ú>@?úT쬡5ºÿÃrX ¢D_ùf$±G²Ë-: üT$Ö ØœÖú¡»zšjŠ¬–Sÿ’Cìúè-(ÑIƒ¼Û:L3°7'÷gõ¡||rê "TÉ’KÑî²–sþ÷àj­årâÄo~A{É —Þ_À‹³¾”­S±-T•©¸¸½ñ"׸f #׋©1½ƒ›¿Õ?W/>³®NÖ2£%Õú1H°£7ç*1³õI€œZâË¿xSèפT;is†‰Êñ5® ¾ë¨€FSŠŸãÿ¬¿ç»³Fø¥Íƒ¸ýô†–P¤¡Zá„ïa¼Þƒíyú·sc4 àŒ(eÈ&:%thMßqqéŽ#¹‘èÅWWe!ÒæyçëÊdÞÐ: ÇV_ŒI¸2ŠVó ÔÈÄVûn¹ç\Pež¤ Ì6dÔ4š*Å‚h2äiý§Üåÿy³f–´¤Ò›¾`®ó© ;+HöC}vTZvzÿÉ™¼äÀà$÷[$Pjy÷N.*@(–t‹—54§öxî—åZ2' mÏÒŠ¿ kz¯gþ; Oâ¥ÖS%<ß)±ß掙G!‚}Î¥yz†ny¸‚ ’B[Q›aýÞR¯2ϧº}Û*HÛÑsQ†V‰Ó"oëC}ÝESOxÎ"µ¡¿üN uÃe–7D+‘~ÞÙlóvxš\øYógÚ&s¥LIŒN •T.Á)Jq"Ÿô&ݧ2¹Sþçö@0PE°ô  _‹E˜WÂkÚ^j°²&Kw‚ïå>ÜýÄÌ/‚™ÅßEVÐ ›©¾ôâxê­O%O´4’V,=ÚŠh£¯ÓKßÓŽw×ÐQvù)gIÝ ÚñµêrÑßåþÐÍÛcpWN &ƒÎO3>íÇÙÁž°­Xb¼Ó)…lk ÅVQnPF±ûæè¹ÌvÁÄ(n¦í\¹ä1æú9`àÇÒ$òø^7oHÕUL>>•£´ Ð;|YÖN�A´ôÕÔž`{Ì¥xßyõ4Å5 ‹±'Õ1=–%¤-ñÅ6µO $nw”œ´èFZSÆDn0ç¨Rì6¦þz¬‹žen«°EË´—åå짖kï™Iïè`o†;Sš´Ì|G˜Cà€Þ¤×IÜÈVˆæ4ýï[QÖÂ+rë೟FŽT‡y¾«wPzr5%;DÕiY yøvz5¢Aç3O½«âÆ– %"`P¡™³ ´ ;©Ùp+힧æKëŸ(Üåëá²LŠJCëÎBöÙêŸEâԷƯìñìÜc,Š¤zßåEoÕ™!‚Î[k )T«nNu/–K”ÂÑimOõÍ­*)3¡¦DË øT% j65ÛK7$ƒW¹4ô³yl)ò$žw‰%Î<„gl¶),/›eTÍ*¢·èóS’–ÚŒ¹¯ºˆknaÕ89·ˆKQ÷äYÌ<ùI^a–xAú¨¥“úÓG2Pä>š‡ ßà›ŸÁã œ;þ²¤û¸~ÛnKÆ¡½1ÿÝÈ/NJáI Q:Si*öPÄ<Oo*-F‰«±ÒÆ ’±Ì4báÝ;zBëö¸[&daÍèu–é<4 è†ézÿΧlUŒè+! ˜m’ÈGgîšÎwÍböä?C÷µüC‘‰Í}e|Ÿ8•½ÐŒpwg@?&…ôRìUl:4ã—·÷Óž¢ŸW8€R_XÊ—äà‚vµÛÆ䵉™ÊYåjH£â1¯Â¸ JO#D½Ô´(‡Î`àPÏá¡›Cù‘ A´Tqì-ÿ– ºåøNæjÍ›.C/à ‡4‚í* ›ÒšµAÚ¯5¦¤4m¦¹ËƒtÛZÕ‡ÓŒæÕd=ššž±ïþŒt²ÿDQÀ–žC4Z ÿ3ªÏ¥Ú¥&høv_wµ¬<“0˜#�Ö« ûTs=±ú>ÐÁˆÃ¼Ÿ;´Ûè®òî_ åÛe¥oL©ž†=¿3ÕT¦dwô"Ì/ûcqú·:,éý’ ±H»=§ S‡í-ÍØ]j²˜zëŒo.V}¾»þwÓc²~8*f<f¬>e-¿á#Þü„wÎýKÂMMúí§%!é(é"-c™¾ÒÖ ý3¦ü;JûíD>* ¨hLø+æ^ü…µKT­5•C*.( é5ySaqhÙÔ<`£\ߊ”Þ¾~ËsoFrfÓ: 5à:íǬY”x@I„’ TTâšøB¤Üœ]€évc}û㡨(,ªÌe@q6­4­AV¶9 Cƺuúè@G`½wugqÈìÔD¹ß¼‹ƒòSS\È.uË%î@½"e뚬Ü@£3“Ö$•4»³v±QE+¢ÅD«Í›ÿ Á_t¸d$Ám49ÞôÝ#¿¿’D§[ýøvÑØþ*Ïð%*Ä\ý °±m9Ð{žé:›ÏßÀ¬Z-î~‡ŒŠóÜQpœ¶\*Š6ÚQêë£@ñMSè— =^µ×NÒ«-¥´È<ð=pæÊ«e¯bs¸ˆXú IîuÊœÍýåDAãÊl<[V[Çÿ^{æü}© ^:øV²ÿ]ú®Ðö´âQÑ°ù¥ ^Xø) Q> !4Öî @YHOA“Í+%üÇ‚ôàn7%Ë$b‰9DÓ—AÒï•ž L1¥:ð«ÑRt‘€É4J=Áñxmw®œç2b9äÄê3Ô@¨Måü ÐnÕ?HÄy�Á¯¶“Ö‚ €ÙõAÄU8२g‰BRTåPÖÆ ºóz?-+ºM·£œsÄbu ‡7Óa‘7_ýàÉë«QkߥAºÓVVú¼]—¯Í Rm,C™1pü[HÇ¢[¥\óÖW퇎FÀArn/!…Ò?8RÈ^’¼Dq@Oÿ£g›)z—9¦4ºµ’Γ8™4Z˜š“‹¥¹{½-± §ê ´Ôž}²Uð$T÷×ù­ûSÛµŠ:e˜0 îv{n‡Ó.M\ú7zÜ}“q;ÄŠª/–}_­4Œ~‚úÙÀ&ºYQ°§ 4êþu™VM¹=å|zòÐÁs„WìÞ»zâCPTnç2�OðŸ*6£™N†aõ¡_™é™_‡—ÜÄM'E£g¤¡@¶4*|ïêEt„^êßÆiYåQi’Z4è4-‚켘ae½JÎ ¬†¤ÐnW¿ÑµH ì“,·çÑ9¥Å\µò¯1L…uv[@>¸¦3´†Ï!š™'I½ËM}ë–®w ,ŒÇ]Å8&Ø^!ºûé@ù‚|°OõŒ`° ¡Äw¦u;¡8ºU¼7ö¦¤·êÛ[þM^9ÃÆ’ñ‘3ØTóÙÉQ©ahׇáQ¹Ò£ôpQ·Ô�Q-VS“';`ÉÉx£lñXá"Š+ã@¤0þy¤ã7·oßÏ‹ˆ0jE]«´–y]X`ÃxŒùlæ8KÑéd$‹—ˆ¶û—¹õÛéPÃû‡"äÖ›íe.Í0=b’ÌxbwõÍQg¥qI7PÕ`®£Z@¶Çð y¦È㮳R%êŽjû¯‡ÚŸ £¦ÀôZâ^”büömÆ8ÅÅ£óÕ3OßË`\)«2]*½ø®¡]®Ä·Böc¯‚|Q5ߺ.ÓODé’ê)¦ªðþ ¦Ìnȵ?V_Ru. (•2·e¢·ad(m§«¦Á䞺´±÷zea¥È« ÃsØõ ÷u öØw.¤{³½æAaÝ‘ÖBciò Ø#âÞiø§ïþ‘=ÿíßy¹‰~L8W9a–Ô© ÝŸwz^‡Î;^ãWù/¥t–ó„’ É/j†ÖûüMר²æcŶ(Y5Êá“rÎÐh|?2±/ô°ÝqÐÑöY,Çõ‘ºAnµz¤7Âó—‚Í»¦û•ë´ûÐ9§ÚÈ_kö'ßß(öÍà&ÁÚ„{Ol¬7Gõ¦úKmÂ"uB>†¯'tQYY Y¹éFøêR!ÄCG¿•ÀöÚU•N]E¶ÔÌÄV%¥ûžr¨=[濫ÿÝ­/Å>Ð[ üÄ0ËW `é 87n—QjFÙ‚à UÖë‰B®·tUR™=ÑŸÕ8*A{“ûGÛÓɲãDê\_·#_rˆ1‘Ýxô³¹-†\†*Å´" u÷õµ›Õ ïÔr-ÔyÖék•‹Të8‘† ãj†jn\ᡬg¼i—>³g©2_|$_î¾uŠ¢�»]à+Hª,U®«_vââpÝï ²åœ}ícqÚ¹vË,�˜³º+YóÏÊ£8.üæ¥8\Z'n¶¼6!ôoøf!JèE>?Öv” Ö$X:S²^Ã\\¥R˽Vñ¤ya·êï·`O®§ezè…åv²}}8•Þœv<$ìv‡yýC=‡[ù¹85‚‹¡I­z,§|o¥r£ÍËÔùp=òP‘Ðó5Ä $99 ¥m¯°;1ÆBæªûÆb_‡ÂzÝ-,ìaá¹¼)/{€Á^u€q�‘Òx`\f ³ÚɃ®UÒÖ“P^Œb•¨•<(BWÚóÜ žk$=ƒëSíßokV©ÚŸf*+)=»CB„<B±³ÑëŸ×Y·üO½ÀêD“T%k«Ù­µ–÷{ªò—X¬ myßÂ÷{´ú«¢¯!Ž}ô9»ôþôÁ¬6¢¥J±§‡Klæë¦vÓžÞëVÜ/G…YÌ�€–bM+:aß\éÖF¦J;z–Þ­{á®ZËsõÖYkßrŸ¡¾¢¶stâ*Ö»b]ÎÛ„&uy5 XRFóV;ñÐÈOvŽy!ÿZçb+™‚ŒÉvp'Ϭ1‡*‹ ®«%»<¶[7Ä“žv°Xʺ)å·*P§¾\|Õû$(:”žˆžãˆ›Ëߎ†^‰67‡¾5å#õ/Š†”Ø@7EI ›Ž6¤�!8`1_‚ïGÐNƒÀuW?õ«-Áö_Š Þ+¿, Ü~‚eyWeeÞS³x”°Tá*Ålч:„”¥ˆz×Àæ¯Æ»¿ŒàLå«P<úXèž–g·F²®Šußñ¸ŠëÛãÉ‘ÈÝ<,|è<F1GŠöïÚU*S6ÆÇñ/”õÍË÷ôªðlÞ<v:ª¨"újÍQ…ÀAa 7›¡áÔÛ;³Ïï¿ñ.¿c|ehÖÛ¾ÐVy·n<ˆuÃI¥!^{ž‘¦#Qjæ6Û”nK³õœ½·ÙœºmDÒéuLš­¤œŒÏZ¶ÕqÕ†~¼Z<õä,f%OÞ%Lñµ²4 }B<4PFz2am}´Ãµ“…Hü¬ £¾nÞÏÏHc©—Kð7Üõôòiï›×׋£…£Ä^%{ÿòŽ^Ráû¯Ãdhf¡ ÅY�_ØÖŒ~ï]J€v·0ŸzY«Bc¼^‡éètñÄЄ¤ýçý Àr¼5W’|šQ0ŒËXe~P‚ÜE‹l;,ÏAiNxjéà~Àèô9Øpå°"̺ù—Ê©š±žWG‘âëÁɦkë…õKuW¥(ãÜ 1›U׿d›Š×XŒçÓ18™÷Lp'µ®MŒJCÇV:N†Ê²0ò ,ófÂKñè*>†T6k¯"÷~cˆ/Ú5ä®N`iŸvHè3M„ce�Ùf>C„-½Or{¿ç÷è÷°ÖõŸmv¨'û‹[h œ4…6…16ùQ8º™´²|kÄ–|Uq§qëê‹™F¼&=à–sh¼-š9aÁœÈÒ")î=õÉ×ÁÉt§W%z£Ê’»wßé®> +uÅc½Õgƒ›móþ4ºŸŸ›7¸›É Ñ h‹Wl )ô9üïQ’ûœ«„6 :Eûn=¸x\Tüjb³ù:ñ|²`—ßü„^säÚìj@ñ†~ÿé4F½3ÉÄÊ_b£ò5p�Ž„YPn­ÓwÂØ×ÞW¬'(Ùù«l×1éÎ"KÖîðt3Ž)¶î;}eÂGÈúè?éÚ¯ (õ!Æd' ™9a)fœ¡T·ã©×ó܆Ûù"SœÛWoù¹z–(¤«V?숎§LعCÂm7ùÜ»ó0ÐDSà.A']íÁz±Ë�àD«ÓpiØÞ×£êÃèÓ1ƒxÊu㈑¢ZšÍÔ$;:³ËFçöô‚ÖyØÕPÁˆ•Xh¾ÄŽG>z:;4õz¶e§5{•Û6 “ðð g‹þèìd¬ ¥ûlñRZÃ5( ^ð6àNìO<\ð“±!Åâ—š“»àP$7u£É[;yÕ˜W¯ÿ|<íªO©.Eú×v�ÓVƒu¯ìþ0Õñ(çîK ðF7 ¨@±Õ×YPYY¤¢4·×1+Ýâ-Ÿîêk`E­Ö9ÐÖìÕâ65‚–f~ëþØ=<w:2_O€õ4®UxYŽ`3v§Yß7¯þˆ¢Ln”›<§<åÝhyÆH‚ Û]ïΖˆpì–=#UÚ‚ÛÆL$eu²šr¼½ú€žAKøxÀ6•>DÌq™¹gNOjÞ¸zêŽæxìv¨ˆƒWÛº�Os« vù£ã}t�u:Œ¬™UŠæÿ4W‹óžº–þi¨ÙÿáÝ_]»çéÅ0B@ÃÂLQ×}˜Œ9µÏ{à‘Ö“Ó|J’•#U¾Pµl­CH3JüF“~f n߸0|l*Ò ]t&ÅÏRp&œF†Q\d_0Œè{½P„ÙZ}¯é‹ 2ŽÈ±XR‹ £ÿ» ä^ÈzcmXîG¾th3,¨í±5¨&¹/§WEæ[±Rvuļ>Úkÿ~ƒÝrà•cÞ|àðcò€›Ÿ.èVšsÄ*“²0+;>ò ä]‹ÙöÔ{¬Hw^ ¼#L¦{aôÊë³(M³µøØxJƒrš¼$ªÖYHçµ±ðíVà,"%Þ%ºÍëLJ°YÏŠnPMl™®ȹþÒˆ†AY¶}à‰XB¯<è8X.°fQ(ÿBå¡hîý÷-M>«L˜¢L�òY¥ž(ya*{ñÍå’Z¥±·¨•×¾M¸¯ÀbK„_É–'¾x‹ÉO».€jå¬öÄrj:½{6ö] €#Ï%9²êdqgû‡Y›1ºÜðG 2+ÞÛ瀢£×C9ó¾Þ.†ÐkΛ-EXÖú7¯n<úzUL‰ƒh» S²€(}¯ÇÂEÝ*Eµeg‘Íxž¤>Ö“’iá(É#…¸ºö9 Føô„Ì.¸%u~'w:+G©$Ù‡c…sw»H#Þ沺Äï,ö(,o q™£—:ŠBXXÃ]™žÿ'¯pðQII–:NÍ.Ï’}ê%ÓäYLhßÃ7‹þëЉÞaçƒ*}t¥?ß ™å“”A9Z¾Åéñ`4ÿ_mBD™_„†¹�zÂáâù©RØù\*#_„𫨞(óûâ'—¿wæ”_.×#óþùQL§‰¡ÏTãøwÚò<´µ³Ê*PÇÃO=L5N–;$˯ž³UÖYÖ,†ÉDrÞk=™Ïu©·[ÚˆH¸Œ.ƒV(ƒåÕ©¯æü*Ö´óTcJ³ï Kƒƒ×÷ÏK-³ÔãŸ(ÑJ§«‹¡kœ›„­�U¾1¸~Zã £ôÏ'M8'ÅÉa�¶`yïlh à˜ñ›(ЇÎü©Zì÷"Ê|E§7Þ׉ÒMàQ°$ìh{yXZ©iîD§v»‡ï€jG'쎊wðXk*öÙ[Þ´ù �Z:KÖšÍöŠ…HÄÀ‚<ˆfí"mNÃa 8(]F ]y™ÿΆ+Î<‚[ ó³þ²sdaP¨¬š¶ÐGÇÎi|g~õ#ƒš]!›s*òÕ95PÉßY¯²ùÌò4ü.™GœV'ÎÝ46WÑÚ…‰e@ Ó{Îñ@Ë\Ÿ+öI¬­Ôy^,I¯NOïÀ&Ò›øS̾.Öñ)T¥”Úµ„Q³>Ï}±y¿ú]8‹ntU$Ü.aì¢eÑ¿Å¡ÔŒ"~ID¾ý.« ïúœ#¶%i[‹ãK0Ô‡^Å€ánõåû %ò&5FF…ÇÚï¶Üc5¾n³çV’Nž~?ÛŽÒÜõ PÁ¦¡[7ë붗û¼ yHÍ)…— ô ^¡q¹¦”&A÷EË,µÔ_…°Î{»=fçëÍ“*Än|‹¢Ì‡“RAÚQÞvÖÉJ׉Z¸üTöãÙÇoé²[ ɵEçtjny‡9å¥ <h�s)@è¶2©# r̹LX|µPó2uƒCI%% 듨•hgÒ€—SÑ؃šGLž¥´.²ZõvÀ¶tmç½Ø° 輧ºìNv—yæ눶Â{í gm•î¤FVÃ]Y£î•ÉZHEpŽÝ«U{ÊÜ[)S¤·á,ñýËo"£‘ê«‹lš*Ÿ¨¿Tx+—T®açfÕ?ª ¸mmSnÔwœbab!Ñ¢ƆVÔ4ÙJE¼Ÿ‡Ãèl7_á‡xÁS€E颽:8?#¼ìÊØŸ™ÅéÕ_$Ô‘ìÜ@—Š‹]Ow-ýÔGaÓ%Rc—çÅQ¥OZé§Í rÝlõÊÑ:øZiÞ&¿+å‘A7ÅFI˜Ê ÛþkꯂëQ´ýÕ­Ø“LTåKÕuGÁB@*“Ï]&Ú¨“O+n»†Ÿi®ãˆœ@ñ@ǶKóÞ•§„“ÙôŽ9MP¯-ÛÚû—Ž`–z¨^:D(êGØž7ÐJóõTÉùbÖÕr9 ìMèUQr&Ó…Ý{Òé#½Ó²òõÐy6Lâ}±gÌ4£/Û"¥­®¿1:³ý«¢¡VÄDò#ž}ÒJÝin öL¡ýùÈç·vƒ)ŠÚ |7RÇeæ£ïÐyè² jfëÆÀ<¾CÅÏ­‡4unFXÿ˜<râe?rjá\d@ªþ´ûùS£¡ýkK´(ŒWìD*Ž¸äXi2ÓéÚ»‡Qà }8½;ÿœãšãl0¥ã7ŠI×9ˆ”eñÓi}ú˜-Âl:Uö’Ÿ˺—+g¨ƒuúçBÛ„OD>Ä’«`7é �PÊç}7"s1§Qæ1Ø2æ9í(¨o­£5¦G”ÁȬÐ(%­µ{aï}³ÈO?ãZ%Ö%’Ò¿’ÝÎU°QÐÆb•(÷õEU•àüçœWúVkt[¥ª{_%¶î7ZÖ¿ZUFL¢4InÎSÊÉAG¾œÑHfƨrß¡qb” ^艩@v(ꥡH6,ªö9èšg0êKÁ™:+ÚºC*XºË‡%?ºâj¥JË„‚q±ª\¬»1ÑÑhJÌu–ùÄm*öJnÆfïÎi”ÝÅ‹ö¸;3 壇`”™oCâƒyT&ƒýö ´ë‹•ˆxIqŠª¯üýÓ‹h3Ö•²\Qó-ê0ü³Å`Ö}‰¶Ì­}•¬¼•` ‚¶ê§ÓìVï­;�+lÃ+Y±,<·¡ø¬¢4k (·¾úÒ•¡º´T~WKç8ùÒ—ÁhG©3b•ÃÎh×- ¢tåëL(ðRi×(œ¡Å>Ã{’—åÍëš>C‰Ä²êbø|¥qg‡cãÏlÑÊ<{´h¯šòþ[¥rnY‰{+\”·ÞE ¯£ûÞL·Ü•i%ªÍ”UÍ//™(«ïw"ZãTÎÐï9 n›‰÷˜þç®î¨B„ì&e±žŠÜ^KÔi`ÞS<æV-·màSè „<òFil ú±tcF×ê„Ʋ#õl¤_¥QòÖòbA ÙÜ þ…¡/rʶj1vë”—ûÃQë׺§û*½@ëY³šIgq•¹Ž äx炧%±5««'+ÁŠEµ°Ü€»êéqä›…`xú)â»í5 ç¡ŠJÍ1Ôk*·çV þË·~uáùÅÆ9-ˆ¾¶¦ÞÝÄØê¿ý£0îö1­ßp)p*q›4>7Uf?§µíM–š²WÇþ+T…uöDæÙ%bc 23ô«W¿`´‘a;ƒÁÌrobøÃܮԙ}e°sÍýðÅ̈@˜…‘ãi xúø¶Ô½¨’ áõü7ˆQžvOl)gA4ÿëI¦mÎt¾«eà':²²ÔŒËÖ¨:Aµm½úïÄ6»qìä{WÊX®¼é3?½Í”ù¤- àhŠ¸Bµ=­Mm,õìÅ ÎÜC`ÉP"[,ú;‡ó‘n}¤ÿ¾Ñ?íé�„étükýEG2Ž5 \©ÞÿšµÂ±…®*Ϙ3ˆvULæE\«´’åt«ƒÒx*h]¼Ð{¤»,[Åj3Ðn–$à,"ô¸qìòÓÌôvUÿe>~YB>þðoÅmHÃî´˜¹’ÖÖòn×Ñýß²óÒ 8|l¶“ñ‡±úöôåóRni©ƒt´èô;3Ztƒ¢7£À<LoÔpijk(WwTb®DÂCÛ‰Jâyñ¨wè›ztüî±cΊwÑÕ†³îÆE刃jí HÀÕÐxh!HxŠz¤ÁØÝÃ'¢$ÖÏ!íHð µÒûzò±‚ã¡g³j�ûr>2KÔ`îrTâÔ©’a¯%t¦2Hˆj=kOñ'ïÆùtôÿäÚB\´¼þaæéy²½%»ŸW_Iõ4bR žàö§“´³Ö?Ýq|pTÐÂï˜Ëš_wdO§K­‡ì‰µ•f°–Eš93‘8‹ÒF¡¥ÀÓl§Õ«l()íŽCé+^¥VAá;tâÎ=•…_ZˆAå–Q2»338¤ç¹õýìç÷ÐæÏšMHIJ™T?Ó…õ4Ë N~8®èZ«£÷Álk„Üh9^fX2½{jO^Ðhð“L‘…ž°›š©Ø­³ö@ *‡àgXN½X½²ãˆ`Ë—Ü“#åöp?Ðy²¨~@!3«Ü£–ü•(ˆ5åæÄÜÅ:¥úbçË-Èðt£)'éêo¯žj¥°ž#ôGÒùj&r2À‚n¦5†äò"#ΛÏæIòjUøËÌ?“>@iÒ§Þa Ò³&Ø.¼¯·ÒšæŒ.#²©«ÉD’̧ŠRMPÓ>÷BéROŠ]—am'Zÿ³xV”;";ÃZO"Ü ¤ÒX6zr°?)Ã:aK+pÛÞu"ñjÑXÌ×2ˆü L´$ èyúª¸«è\\õkfÓ\ö˜?’\Œuö-¾l]OÙ÷ÞvE`…²®áPßjz¯*#¯ÌÞæM¬à=ƒ"‘¢òo¬s÷ãÂ%â¢æq©‘tÌvC°]f½ì- €ýã&5,¾ ȹkA0Öh˜DjÙL.À„9Ã?Éjé?¾ 7”Ih§ì¡M1:øº<#ûm ÆbS¼~ÃzIwÈz¡6e©DˆL b‹e!läÅ~ü¬0•>Àbßs‚neë´T »Ýd<¹ãö—é¤>�ÛA°­2.oyjAy7ôøF̬r­ß‹ÍPÍÙ º­è´üƒNè?Ë…Ž+Ùsgöá�tê)¿bʲÆsY7Núk´TGú‡¸ ôþ«t>2g›ç0(–ÚöÉ ÂÔ+߈wb À<,²µÚG?[—â šg­‘(zÿs ®±A±aþ£ ‡‹ë&¾ÔhtÅF̉i qP¾ËÖÞ ùðø‡ë"û‘¦wì›ssjþ�pEªp†žæ†¹häщPŒSÊûÉó$_1OCð{Š Þy]$—ñ£×Aqoì9uùøHb_Å€Ÿ@‹‹6!à+Ý„,1Û~5°ŠÌ‰™ÅÐý£ó¯Å㦓v™— «`ªÈPˆ>G¤íÅÁ"g\¡ “CËÔ}Üo²šar2P4øXò ¨uÇyQS<ö¯(ýÊ–Þ€Çøó³\ÐîK*rƒit=ï=¢éæD˜²¶ç@·’˜^.j7�“\œ מö“Œ¨ä Þ+ Š•–5gqõ‹çt¾›ê­×>~ `ý-mLV€0S1]Å)Ê43^«¦ÆSÐÿ?k_²Üº®d;æý ÏjrNûfHŠTcS”LR–µãýÿw¼\™H�TgyߊŠØ¢]çÊ $²YMì ìÒ# …‚Æ©-•Ú;ˆ©òš'“ $è£Ô.sÒ]憰 \gŸü4)#-ÏÀêiýP,íD°%}×&=Ïy¾Â¯+¶¤¥+·X FØUlIS?Ü¿L“mR‰½|`;úöGÛ“E:ÂСîn&Xd¢Æ (¾×`ÙDÞ…ãVÛ<(÷?%ÙvVÜðç!^lÝë@V» àyöÌPÒÝð]Ï¥"°l–;XüÜohFðèM|¬i3^èQRÖ4 ´öi*¼6Ù&(ÕÎldc¬šZ„å¤{†U=øÎ--ÀáqíòHÚò1wÇë N’ÌS¯ÊŠºE]Æ%ß:F8‚¯‘GáÝZ ܽ¼£RÁ[3+á°@ák;Z…mÍД?v=hZ–GE†. /O{‰³Ë®+adŽI÷î=d/Ö¼,Nšþpð%S6ã±c…,kP|qÅdJ1öÎíÞ9þÉ<nZÈûYtY®toiøO;ÁNš×²{ξyäÓÙÔeP†µCÉD\¼ø;©ý÷˜(ñ^A¸L¬ºz×QõKŠ u{ÊI÷ŒïÞØ Ø^@s%&Ñ'FÆ÷ß)ö8œÂˆC:&õÛq„z2g¿!ÐíºÆÏÍ«QA1YgÕ,íR ZƒB®XV0ŽÓð{•—¨ÌÊ0v‚Qi°ÿÈ‚œ‰ë‘Áˆs ˜mÊœÑÕ2H^J£Cûè�Eyú·¼3ßµ± Ú*M퉮¬¥±ÀÏŠÖÕéøÐIÅrìB¢L¨mËÙö•j­q·Ò#ï¦@ø‹Š¡rÓ>�xã`;í®Ù‘º-Iø¤ƒ|d!v¡ÓŠ'½…µüÉS(‰Ôq{áâ5”ÞçÉúDDÅ(¨Ð¡„¿F[ÿ¿û zÄ}kE…`Üa6`§×)KïÖ OªŽ¢D·8D—Çì5·=s&8b)sßSì-Ul¢|¸F³EÕºƒy×sõAuå×Qw-9-ºO]TG“‚ }×ｩÀòD¢ÛpK"b¦‚„gÂ)ƒô[kÖ„‘$¬¸Ëä+©÷`GÏ„×<Ç£Ô§ž�,‘{bH”€3ýºßz9ƒ,¥,qó9?Ú® Hò§a<\TWáiÎèèÚ"|Xà„N‚ʪ*‚?u(ÏF÷~B¢èþ=ÓZî°Ë¡Aàø¢U°§\ F³Å"#2Æå†Eïdò.ïW¢Qìd7þ;ͨDת8 ìÃñx1:Òh’oèyE%¡0º«5Œ¬[ÊÜ4lg6‡ë í±su°õ’&ñôu˜Wu¤ÜË™?Aí·vh¬(ÿ¶á¼üò÷‰¯ónboʈ]*2Ê#ËAi6ä y™5¥€ö+çá®1éʦ"«,>]¾Ó´Á¾WåCýÑw×âÀ{‹° •Ê‘F_%•Xªõ]k÷å…Y×e:R^{>ÑýÅŸœNu¿3zš÷s÷páGEwdOÏ%m[¯M Ãz;[~Âïȼ²¿Do<’d¾X¯‘+³óá$•—{ϧºˆ™'ˆÍÌó§ùf_BT9_è MŽ¹ßÃõë› oÖ"beÿ} :/¢Ë ˜)�¾Ç#®À¢K¸ÄÛ0ÑÛ¨tã…{/ú¥|V#ôQg·P2Æiçòõ1‘YœœL¤Ï§ÉÍè0ä…)cÎs¯z¯…ùÜ+¢Ñ·ÿˆƒ¤¶…�¼´Eƒ†1Õ*HÛÍ+IûUâ”.–¾Ì˜ýµÓ·ßÐb·ÖK¿ÛKqzðÐzÓCû>ºáÊ•‰Ÿ2r2iôØ‹;òÒQîB‚¼WkJø#V£¤…¿ítÎî(cåžæx1ÿ§r›ú­ª`ïÿ9M’y}ïøà4’w«±›8=U­ñ¶Ý7Ã(ä _F=Ü´¸ çbˆ÷f·Ž ³ fgî®ÉÕ+~WQ.þPξðI­œ >‡fêƯš=:îØü�ÐÉB¿ÈcA JüíŒ šnÎ{aŒ+2Iâeb=àî^b*ž^t�¿JçÑÃ…¼(I±_Þw ƒ*^æŠÊ<+Ë 2Æ B2[1lÛ+甑º‰!W?kËԑɸ§Ò`(žvjÊ.>(»Z“ëR„ܽ&íz¤ªbúÐîŽ~Ÿå®•Åí÷$ì²Ûx=½i[ýÎN”^‘3AR6ŽL˜ÓöùÛsžOcð ª$’ýuÊP,†¦a)Ø=Úã°bÓ >auS©X·ùëRrT‘9Ç™„Œ ¨ Ò5TêâJþo>_LÏLŠåûªe^µáŽ‡˜>ò¨b·ÈËçêæT‹¤Uæ S„\}AÒhÐF�bÇ‹v“Ôœ6ÍeñïUÎTVž> Ìz(AÍhËûhTî§rqÇ0⣨š>S4ÎâûÂÒ“‚ž°óèƒÌŒ窓¶Íë=³í«‚ƒ×5ÑV6 ëo}fo¢ø´Ä–&lô)[0ůêª1°è_ pÑóª”̘XÖÐ%PúÚ´iûêsÊH=À‡&Ûè^~¢ØDaú)cC_ü_•ê:[Lï*€Ë µ$·­#¹fÎTÔ´2\N{ïÊÏnsoè , â÷ÚxëÑf>ž(tá¿0,u¶é‚äK‚}¤½ %aäÛxTô9©àYý¯ê¾rI2Œ±©`=Nf{à •žÿï&Ó« ’5¬TJæáÎŒœW t•hºGk¥•bªv¨g9+ ~k’?„¦ÈªˆU¥E[º9½’´“×îÓRçÁYÜŠÖ¦Øýüðÿ‰è”~‚ŠÒ9–ìÚ€zPpQ.œþø_ڬÅê]œ9*²t¿/€û§NòE(&ÔÝ•ó‹±I|¥¡q9OÙfÁÔô?¦Ø¿zk@±¦ÏøÏ[fæþY ¬‰á1_Ï…l©rŸ RºÁo'_ n¢ÜÙk‚bÍ8¬Úßê [¿]³a¿m:éòO%±Å:õ‡µé¼Ûë´ùï,Ÿ|<¿ÕWDÛ‹cøåáiQ óxq×]'_ì®Àºíû¬ ²­Ê)}ÞŸv#CIŽíçÐ^¯wof¾µøá2\¨ž�wÊ(¶ÖhÀd¼9#oýB:M ÚOqÂNËN¢M¸Ð:ø2òüÍa²Îšø”Íå!é!_àS_Ó9<(ëE¿ ð=i³2çCÉÍ;;Xé‹‘|¹4w¦;ã·#׎?vSÑ ;78LÚ0çK÷CÙ9– —¼ úìL¹0í}ÄȱÖa'œH ÕÃpßß”§QXUqæã û)ÒéÓü¥ÜT]­8\ÚCÆ%ôIk2- þQ9ZÈu_I3hÛ**×Èÿs šhé¨T-Î(ýÕ¶–Í|›0±Ra/ b¯ÅtöŠGJ×ç?|îZUû¿¦VŽ>š#×a͹h{t¬Üó¶ë81‡¼ÉÝük[oé•Ò¼N˜/eözh³†`îúÅëyìèdÒ@|³EU‰$~Ò¨RNa@>ËÚΦŒãÙã‘Í‘‘z¼,wV>BÖngº gå]Tœ”1ÕÍà|¨’^ü+èUÊhAèwp½¶6Çyàà {ÿöm©3åâªÞ1üACCêÛ¥¥Áqõ£Ë£0—äd6½Ë·z c˜!z‹^÷3÷~-SۿЪ }¨xlwäóÚAøʦÒAºF¬õ.,¸;NîÈtªotÿ§oËûªQbÂ~Qg ÛŽ~~£W][¯ãi§$ñ˜A<‹§’„ ¦öèоs÷Ý–ÿÜAô@¡w¥&¢<‰3Ç—¤›~ì« :î{‡DÙăü¿¢YIÊ0Õ¶ù¾ ¢¡õòÀN¼_ñÙÏ;¦æ˜—[ÆWâxób^Õp±«8evô0©ȯCQšø¢‚„ÛEÿ%’®ð›¨lX:ÇÅØmMÀK­Ðóʧú‡ðK-éUº˜^²=6ÞëîÒ`(®Æ ©ãDÆ.uê�ÀmìQؽ5‡zÖ9z![‡bÝ×ÉwXæHB¦sùÞéûpzŠóP¨Ê·£OÁþì0ÄÍèãiSªH}ö+“0…þã¸:m}¦ý¶}i—ººÈüP\oL×=ã*òms®»aM)TÛÎLúíý4¬f¶^¢}rOL1»nO%ÛÄV¥3ÏÕpi‘fßžz§³#þôÿ¢e“úVaZF…ñ·r=#Ûÿ[¸©¡Q`à+Æ->N–"m€r ÀÇÒ®ö5TŸ‘¡ÈîT²þ3íz忲H@„áJæt¦j:{{0ú9-8-<+;—蜠ÄQMP'5šß}tó ùwÅ;HBÿ­^¦j =ÉZN$¢·ÝEð¦]ð®á¤´~!ãÈò©“}vbªk©g§N{5<üa{Žt}òÜ›z‡žc'LòØs©p´÷à».£Ÿ$E…›p`"ŸP$§?aíæؤº5XKëõ³®ÏýKëVmM×r󌛂êáï“Ö!7ËÝPé«‹+šLÆëæÏfÿѵï(È2ò6c Fêy%ØÎלÆ&÷7•%²f±ÚA¾yw3$À¢Q±3³¥Ãñ ±ôÈ–B4yrÓ½KÇk“FDÃSM¾µïqw‡Á¨“ŠÌßÛÊ8y"ÙyQp†çqí sÚÉFäÀ‚a~9íw†µ>õw!$‰gw_"Yjç”Þ\Q. ŸðG38=ÕÚYuf¤nHHK²¡üw¤à¬Sß°ì8¤æl žY£Ð~¤ù{H³IÏBö èB^¾^%-‚ZÖ§$( $+ŒÿyÓã7á¹ýÄëñÕ9©×Œeµ. 1¥éÙ*~_o(Úךú°[×lš¥Ó\ûûXL+³+dŠªMð£¨=»{LÛ(0LP]ð:9÷¡¬V ýª„×GÕq\:´H³eP¼[poäÐÄÌ ½vmñ•�à'ñ‚�šöw\imuä�0©ÿt jöJgÙd2ÌA›'´´,ó“`8R’•l5¸ÂMvsÆ`ÀÅ¿Žv·»å™Óÿ7W?ÙÂG‡]�È@¶Ö¤†1n…ù¢„¿”­Õ¬Åöð§LöV›?—îÌæÜ“4Š£-¶íD<qµÝRyÞ‡|,¡çôü¶':ƒÊ“&q¨T•yž €èx µŸØ2–Ó ùt;møbÙ`.½VyÒÐR˜Õ#YgÙ¿f-Ç‘ºš&¦›"dÕþâúA3ˆõ=m>%Ö@uˆ¡äTΠ¯ö#g•ÎCù+qhv{ßUAÙ¼{ƒC”*ÉX>;:ZVŒbâÞÁ4nxUá”K„­¡ËéŒj0hKaÓLmÜœiyèI¸G¯]¸i£?Þ`�b=á£Ø€åßô}ôéa3¥(@ó“FwSÀFÅ|ª[üë Ŧ¡:Ó4Èß$”£K{B¸:Íš ”{Uu<SU÷” ’̯äÑ2…?kluÇ ú°vÄ­¨ë;î•xÔÜ4½v³Œ}!(Ú•ý�OàÁ•Ý¢Ìg;Àâ§3ÖS7,ö.V+“¨–çwû´mÐœnÏüéñ¶uËXR‰.èÅŠ¶ïІ»iV‰á>‘ü¼.Q¬Œ™HVÀ¸/ÇÖŠEU–fÿæ9UýļþâBvÜA4lÍŒ je·üÑ̺·tÿ㢹}˜¦§“¥è?Uè?°?1‹¬µ‹½†8þB@÷Ýd$\K«$ËÃc¦¡+ÞE “ò‘$¨šõ69“T’t«v*nªsÞæϳ?$ kT¤ƒ÷3# b%þœ6ÅBIáÎ.¦0´†£Ví”rn+¨€´UB˜T}ñã½ú,N|^ù!‰“—.PQµµÍwc3ô ¢Hê'"„qd'¹}éÔvδø¯8׬_t5ð·~s&†Ð½©¸nÞ.4NÑ€ž[7‚.?žÆÃ}ܹ™äP ¥2OT^„Óày%m¸VÚ)‘=ÁÃýû—�BªåÊn¾±ì{]‡XÀÆo˜VC°qT3=~héƪïÎ+;YáÒMîáí;:Òí»£w·µmö®ß" ÷LÛ¹Š\›RÙ²‚vvEf[GZÅ—ßlQ/{a½Õ:ñäñ¯ä_/Àù¶�™_&‘Df¤¡ ÕÐ@!çSÁ!@Æн~?líT›> 1PsWw4+"5оh)A¶ ¼¿kú/e4g¤¯ý&ûÐZLU¤£ÅdsTŪLdœ©¢ëh2¡ º�‘#½ùŠÄÌÓΈ‹`5CcgkÉØ%f&¤B¾3˜INÆz/È ,x¾ÖÝkûƒ‰ $wwzW`E@qOޞȈ¹ùyÄ+žU´ éÓvß´S³IUm:Ê…0ÃKòüÑ9SÓú[MïaA3ÏïÍ}×òx2µÂŠ‘MÈ1Þêq�©Z´˜&ˬê§>¬-øßÊ"ÛFëš(ßä,îRŸ¯‰ÐEáCú 6t»5À²¬½è‹› Þwð$•¯P|eæH‰,®×wô^ïžèÒöÐïW{¯ËÈ@*Ò©éµÈI¤*Z<e¡ÅÅ-ÞõÖ%à =>íÄ­ÚÿªËKG\–jAÌÍê=ÝçÍÖ”ÞûzA¡iË}:ª¾:s•ggñ7Ü<ñž1l¤Q6ƒWføÈÜ€«IŸôb‘pĶK¡¶ÃùEOðÈ!*ìÎÿØtmñWü–yoì\šv“K›)ý= ¿1+M}ÑÝÈŽ4NÚ±úÌœ…Û‘õ½4݈Ȩ̈†VÚ×ÙVg4Q[ÔŠœ’Ç%Ôí!-8Šò¼XÄšÕ6 Êß CVo”Õ»ÁûèxÔgŒ2S™r/«ÎË <iõ)ãÜŠÀ³_½iÅô›nžAµ¡Åyø0uÂò'€a²%˜Åß;'üûE„¿~£r¨à6£Í–RFÇFÿé Ö×8=¼¬_FÙR¸ƒn¹¨Ù&øþ0Ô»?lOaëk‘üÔãqëj€*ˆ>G£6°îza?¨!¹<}s«98nÆÑå_IÞ‹×…ÀÂJ"FŸ„žkÞ*õa2Íðm11øÚM³é#®úzeNeÌ/®~œ‘þ!h+?öÌ1cã9©Õî©J<ØÓ긚‰½ª—oE¯¤ùB7jµ§gZÍ=æô8hX<*R›q·ª/,ePˆû¬e¶ð0ÿ¡?èaæÕ¡öŽ&LMpû…ïcßðæÏu\\p&¸«V5Èþß]‹rDÛØK$ߺ~³Üƒ %â\KÛ¼<ÚøëpR™íHig€‘Éœ÷èt4³S·ƒìn¢Ài§¿:c [sØ›SFÅÅl½áÐøù<±÷º Õbÿd6 é±‘ØdÍ'F: BÅÍß"˜JâÖê» ü¡©ŠÍ=y0±t“Ëئ³"Ÿ'jˆ•u9ÂX”ø÷"ód>à¡èB­ˆÃÑ‘¶Î‚°Ùxb»›]Ü©YB»>ñ#ôw® †°mŒ-4.*a ÕíAS¸¼jÛ¥±ß$¤ÿˆàQØPÍŸÛÚÙ))WȘ)_dL¼¾.„ƒ²ÐĤ?§´û´u,CH3KGnÈ銘«~1XÊ]^;,G™v`—ñðÇj“Uâ«°·}•W•ô«pá<•­‡ù챪­¬½™Žý ôy^,¹‘”›‡ÃŒ'<ÕÐÖ—Ú”jÝ7¢†â«ÅâüÚaÎcu`À€‘Êy³ëÞjA3M_ðåÎÝËJtcJ×1§Z–þIŽZ´Ñ§‡Ø—+K´ñ.åÝT^õ8Ë &Ïm¶®¸€ß”u8}ó //L+8võÇ•-Kì•ý©15†±¨M ´d ߶´}¥Ma 0¡—kš"ˆšoU‚ÝKí¬^V=l ÆCGY\Ó8áÜ…øž»ƒ†ÝØa…SvóžèTskþâñt~ÌrO¡_ZBÓ !Äx„”)©*IXìc"ãJ!«©[ƒDów3ró]üx }(Íïã¤nZ›ïÈ 8âÚzgm­÷±Íá”Ù^Ê{߈,8‘v齜”C[=W™i¸†õ‹j=žŒ0+ö´ÍPD[TͶ»H¢zº÷ŽÓŸNÖ8ôÄàùï06Ó­RÕ%¥²‰Æë°ÌÄ%¼´`¶‘™å*'ì:ÈFUü°›»'ÔñÐÿàµùBXœ0(òŸ¼¾Ô¹î‡Ól'\˜™ÁžàîÕÒ£ýÏfIi}~:EET0ÃÌ/Ž$~ïêq<RdVÄ%{d’éäóÝ•.®.7ž²æ(I3ßo™r¼f½× £Óѱ۰ݛy’eù+@f¦¾]_ÈÄwØoXùÚË—¡¶ÃÅî«ãsP_A‡ý‚kº{RF'5 )eEY’3Ÿw‡£k{oëVs$vê6 i dzYd#vUÆf�;èÀ-55ºwÓ±cÅaªùó5ð}£$¹Ô1ÌÌh·0ž´ Æf]cø]Ž^Î5uŽuŸ$›$ ffy:ÚDÙX{ŽƒÝhRëÃÁ| Ö:7èÆGhQTù…#¸È—œé7‘ôl´¥põvgŽÀvaeùs"ž=ÐÉ÷¹1bFàϽӢ¥zŠò´äß' (çÍ°0wFºÓÛµsìêú½„KxÉÂÎò*͈+1]µJ˜ó‡@ ‘™]ì¾.†ÌöÔŸ«\ñš–IPŒµÇ“–+}ÞnÖZÖªXÞ»ºQ¶L— HpÊþq;‘WÜδÊj? yŠÐ÷²Ú”P3ûÉ:b¶GDã€VÃ$IëÓŸx’oò;ÕŒï{ºãåéèA¤ÛCֆС‡Ú($¼°9Úº62ñψ¶Çt„gA:m|Ñ¿©š‹ìjiºþ€$½6 ž>(Í6âYB•Eé¢ïó®ß³K„e âݯ~rZ”QiPÞíP‘ôÙº1âú„V„—Þu†G9ýœÉhÄ*Øä2¡Ì÷øíY>tÃF<ðö{5^¿`òwâÈY²@+%€úÐ.þn<Yæ#…é QÙ %µËGgj¡¿zZyæ3C(½™?i1X7�¼Võ—`S‚Á²]ÞëÂR5µH…´RÄyÎñÅ `(¿ØÛ~è`Ÿ"¿ú`ZFCÿûèhŸ9üxèn¸óW@ÕDIuÆ$Žºs”Çw5éŒ@ñ|”sO]`ø0¹@ú“­P¹¦»’pÞoj—Ïð^`$ùÝ,ûç„»*9ŒáRæyù &j”vœ2¼Mg²;„ÿEže¹ D ßž˜[WQgñ°Ü£ô°VnÕß%Úe^‰5Om·ðh½D²ˆ5)>:J;êñJ÷‰Sg¸pÿ,(Ò¶}=Vš¦Ø9­¶”DË7�rš[½´€¬ÊÑu2YZÆglp‘(_ݱ奈FFÊ|á,ú“Ou’º®h<[Ô­(òš±Ûï¬ÀY„¯n^oiN¡Og‘;ñ¨sð¸7ZîT·lâ¤r¹O’[ª ’õíÅpÞ€E –Ü`C¿W†ìŽª’¸{– ·†_qËvAµÅ,¯w¸ý{éÙÿ‚!ZF‹˜%´Qþx+¤8| õ;í9ö._T?Í2‘##M=l‹‡BËdÛè×ÊÔEªýŒqdª/Ѫm•2¸¯/¢hî$§¼¦Hë{^”ìC"íÿ‹'ÚH_ë¬í¼îÿ“A€´ñ .RáØyÚÚ´Í&)Vû»«¹8¼ZrÑÒ¨,T#ǘµÑk,c:XïéÓ?”äJc/—fbú¸ ~óîc¨Ýlíîë3£Ìëõl(/òÔO·°›^ëZñ-¢Ûf„Xs˜QÞlƒÇK‚œ‘G(åþc¯Ê{0Õ}(€ n¤}0ëM/äÝ–?yŠQiNãÝŠný»‡c2KÏ ŒÙËŠ+DÚ¡Æ·RæhRqºÊ3Qš*Ú‚lÎ1ŸieÃ,¶B©+˜€õÖ¢„ ºÉ8@ˆ�=¬‘6ø‚±§³­R`°² ´PÍu3^£üÄ0m†[umÚKJ@ð5òÊÃS²¦^;Pä+¦Úk£7rø¢ú) ºFRS7÷õùŽ±°{ *î5£È…*Jâì–ºÞ+—_€¤¥Ù¢……s”,Œcñx�r½Þ¡& À©fÆ«e1?%6§¡!¾šó ÃISRÙ¸,½êV†¯‹ ÿÌ/qÆq¬{Bù%ÅÿîÓ쥨(q‹µöêT*Ë Íf¥}(, 瘶»¾'+í “'ðaðô?: ÝMC‚¤Æ…ïLÕ4X9áûÙ[ëшo©Uˆé,]sSó°ô‰Ppôé(ÍKj§¥|˜÷"]j§ Û7«‘¯KñóX:DÏÊ*z…yÐS\*׺S‘f/ ÚðDÝ­ÜÑÇp8‹Ò¢?“/¼!37±æ‰â’=Q‰žšÑk¨ÿ¦zβ…'OL”²ÖV7®¥g+´vC^#…~Y ¢Çþy4³U†ò)#{£Hu:±²i;g½Ÿ=¢ÿäÚ¥ÇTèú¤´2¾^MFëëÃ^ïA­ûT™/7Àå(¯ Ä‘Ãr´I ^¾ëÓø§³ •­¨^U~Eº`ïÆAO»Ýæ••Û££¢<ÿıŠ9+ £üƒê¤,Nèy!ÉÛµF8^êÒWøK¢0qÚß\oNtÕvšž%òµ€Oœ±Ç7º6´ÏwÑË$rdÛ1âlÛ(V²l‡é^Ùú¢ô¶ãfð ¤2úa­úRi’ÖÜ\¡„Í=¾—Ë2¤¹ÛJ¹ðêir2›iª¿—¦ihZ µã² Y„4¾¾>šMåÙB-¶ž# ÊA#cÎØÀÓŠÿ7¦„µˆŽÇп´d‘½ó”ép¶Ø0a*§iûª_a¤Ò÷ må©zCq&ÿVøVV™ÈeP[g¸¢Ý,¿«"þ¦¦“bs ‘D‰raá¹ÈÇ‘tr;Åb;ë½™›²°QG¾Òõ‹â2‡nõþ¤ïZµžÀj¦Œd˜PD-$e˜¨r¬7ÃOú;*ñ¤Þ± ù€ãÁ Ûþ<ƒåÖÿÔ1ð©àÉ—±x›-ª¸ë>9x’Ã¥>¿ÂT+[,w§Uw½½¡L 3S+Ù«À>O 5¹wu}žæ¹p<Qa‘Õ¤é3ž “@ÎA“ÐIêõ ¼ÃҧÝ9¡¬¹1 <ƒ¯ëž­9ˆ5ÞB°í®¬S8å‡3äÛ³m§²å,zùÖÖ_»v2A}Â{ƒÔB¹ ßA¤/ŒÑ– ŽT-Åí·å:C¡) v‚YÛ‡>ÿúÒ·ÝU3«\<^´+àŬ•5­÷Ýø…Ü ¼ú÷Ào/nB²€ùÒ6šò 6æ@2Éh`E>M¿K8”Ä&Ò›8¬ë2ˆgë³r®8uÖÞ ½8º VyÛ”ûÞ± ŽØ±+”zë¡eß°Çór¤ÚÁ<ºaw¡)–î(¥3˜ÿY5ŸæV€oÛcï´ô¿rs¨Ÿm(:Þù˜oEÇ‹C.Pàÿ[h—ë¾2àr·¹ä®{´—*76fõŒŽ¢ ÒëHÓÑg:Ð:“ñ9¾¡Å‹œ4,‚Ë!£Óûíú¿´N¹¢”ÌÂÙR:H²Z›Po†•å‚î4‰XFÍÎîNê,:f£$…®ûÏfQ6 :ŽÞz}øÓ3Ì\ózðÄÀ8Àáûޕ߇LH2Oã­½�`ì@S×*HC' ïï_ #…·çåÜÌ+FMå{Ï“f+®~·™g{zi\º}ÎY*¸(%픩b>#ê�Ï Ü]¶%÷†Ïëhùô }yZñv ç¢Nã)>ÿîî,Ôo@³îhçg­Öçت+Ê%&þŒÇD€…¤d{SÓ­>î|ò|¡zvÀ7âAA’Çt¨æŽÿ¼)zÚüFF—@Âä cÑRG‘2b#�§MçA<4®g‹uÙvÀˆVJ= pr1¯*”z5HN!c-¨ÞB@-é•cÐíqôLoì(M ŽÈPÜ;è<òÈk²iU~uNEµ[3@­Bíìb™¹Cðî©òä|I eÚKʉ^¶Vn:m—Þ€&¬Ôë‹’yÑÃYREçLyÚ:lÆ£fÙÿE�¥bÕ[M• Öê§d8<žìˆOföÅ“Á¸ y(%aø&Ó¡ý¥r¿íäçFÿHªÒ‰ëæ :Ðñ5ö ¯ƒ©/GfœÉ™vg î¸Sö€ÄDÃëÓƸßÆO $¼AÕ©Çq¤î&Q�3§Qö{—ŸªrE:÷†2üNµÐ!šôüôS21?!"Ý×r¢2<k0Lm Ìàò}ìQð]ôî_XÂþ«õæ­7°OTd¬Ë³v0ŸÁ<7ø9- $9º¸!ÿw.æ‘”fu33ðMµxøô]¯˜A¥�ù›CKF_ämïñš³raåKá$Oƒªþc GYÞ0žÄ–ÚwßJ÷.ŸÍè⤲©ŸØsPBóýGžþ¼®X¬”R7ñ¨ÒpXØSYæ»F7•õmm÷ä¿# ÆNðÆЄ1¶s#ï(¹2ÅÁŽX¸ÞÙ°jƇ™QæySÑ›ž„,æn¢(È*/«Ð3 AZèÓ(¸_(UB/­;˜qC©Dö>Yúì4:nÆ »A˜yÒÔ´ ˜ò7× nûÙ»8* _º–¾YßSjš´Ê©O˜òqA.�ùóó(f'ׯ¥Í|X%‚qSÒúêÍ^=v8™½F[ڣ꼉ײŠSÈï«EQ±€Øgô9° td—£'M©ŵò=³6¤žwJ"ô§ÜÏÈé+ù<é…³ÄXϾÚÉ«"4I{€²˜1ü¦Gѹቅڽï)L`“\0ÀÙ†Ì}Ë]d+~§àr •ód—U•YB‚!DRE,uýINq4»Õ\O¼ŒM‘ V§ ¿qÀUä‡|&Ñc|ÖÎ øç160}é5D~¿YEbQn¹rmQá4Ï–N,?X¹åP§ûƒ<XƒÆaBÏ–¹+«ÃQêO„0ó´ªö}Ç.öŽ²¢Z½¡= 1H¯®¯”ú. b+€”°Ëð±óç?vÐÒÔ)x¢ÝG÷”òËìsã!#)4(ñèüw7üË}€ŸíÛ_-GÑÁ)úwÓ\ˆÁ¤CÏŒ~Ž†¶ÈMú¼‡�‚Ï?Êí@°?µ�{y÷žû¬ôçs Ð,³Ü.ó¬/h⨱0´ò7ÚDP½Ðÿå0~sa¨Ð4ÿï,™§Û_Üiu¥žKïÈ Zy§ojA7a:AGP-Ѧí¡Ãd]ª¿’ÜŒøɤ%ß~z‰‚á K›ÿæWóuôh7hKÒ³µÜäî»ÉêqDàU6™H`/n‡íEu5›.tç6­. ²·º¥Ö]®tQfWý%‹YR}™ð8oìæùzFø'‡QèÛÔVÁL¥’F\53QE2W½#7•s‚ÎÊ·· ›Ä;µ97×€K˜ +:Pê‹fÍqÜQV÷³´Õ#‰÷Bq\[±Eô—OôqlKLzåžÇEâò¸Š;í{ºçï¶yÂs“ƒiêiê8ö2wCļ[Y•‘A$ܶŠ‚¦¥xqùT'b„ ÝD©¥ÒÞ£õâWý72†˜îùÑú1œãtT̈÷Ùn†Óž‘Ò$óÇ%*çŠÖucy·YàD&°s.c·®w=s™·/[5W µìˆ¹é”XËáÒàí¹†1T[ãítŒãŒà÷í&µ½Ã÷SadZßÏž(å. ÕýŽ’õ·­I´L;ÃàŒgÞ+¢`«Ò8†�ñÏ[jêë" òë´W\)Ìhìb˜Îú(@g²öÛÇԭ_ög§Š£õ{(Äu‹A?–·ðT´;*+æHŒ7ãJEƒ׶îˆM({Yï°0cé1£¹Õ÷Uœ¢§šh«¦ðE›fWýµ/MéY‰²Ï&\ñ»þWûr,y«´t…÷»;éòǹòæ`Q(zWM:þºÇÃŽ²&�ž¨W²»wÛÜü"÷y©íÆ}ä~œfæ ©øT½‘ÖZcP%\]é/o!‹¡SXËÄØ„vyfÁVPÀ§¤ÄøUçRDqA=žDÛðþGÏ3¿/AA¨ûG±ösº( Zõ_¿;VXZ¼X‘¥¨ôÅ´Ùò,§#Öµ ¨r˜·¬_cÎXä5!ž÷Ì‹Ôñè¹<l(ÌY^´´çY´× û„åÃñØ‹>¢¾aÎt—.ø”u¾‘2nm›†­áÇÍiš¬—ªÁ þ€ŒÃ%ø–v›¤³²îef$d6wù}».ó|L"ëäéœÁşڞçÒ"LÑÛdÓE‹Dõ€ñ÷/-æבÒ8)ĉVÒÆÒIcsR©2WÕB¦ob²×­ÿ­¯”U³6ˆ,ìJ-?^äÇŒRûBÒÿ7ÿ‘mzqvOÇèæ”AxÔïxFU=.ÉþØ]´¼,­]&ø #Ó¤Áâ&ö&ý»ùê-7Ée¨oCyMñ­ ýá´›:;cÑ?oeUEðb…L½´Š¬`a¡íyP}j’|î&'š«˜êôIk‹ Zgƒf´WÒŒÁ&³a"µ1¹2DCdó¬(> Õ(ymßÖýá0¾á›a/¨Xí\ ÏK_['×”:n·86¬ö`™.”+îÌ SÍqö®°É}5&�‘±TrÒt«V[Fë×Ó‘ëÕ3»¤ð¡êT°ôEOµGÁ o4 G ô“/eâJØþ<Ý¢m=Äñ-çI7Î|½>•ÝHjÝÈòí¶òŠÎ†Uÿ=¡ùŒ‘· ÄI®¸QÓo˜ŠÛb2e+¨ñ[N–y.X½ØEâ½÷<·ø3B¿·^·¦ijXÀ…é3÷5%c½š "X—l‰‰‘þÒ¤´LÓÙChŠ]5Ž²ôšÅ8œ¡Ò2Z˜šÿ—Á!H—ªØw¢»²O3:c-8•'÷gîIzJ5Rp{k—O ö^½s2ÓÅAÎ1_%¾B_3å£Gúüæ•/”@i=Âÿ³±›>-WÇÿ¼%j‰@‹ëx˜ëùðv¦²þ•<“óÊQ2W{ˆòäI>ÐLl‹'Uª<S%¦!ÿ¶\ºwçPÌT'„k_Ø-ƒx”÷·@L¿.ä 0¥S åþžHÑo½qß¼½ìÅËÆÊÐÛ d/¼el‚ù¦ÃµÃúÍþg’ÓÈ_f磙iŸ|Ì=óÞ³»1dÞç@Þ±öýq:ìá÷aU]ì Y� 1ƒaG'g«3æÄy¦ñ‡ Tåï=ÏÏ*·$rŠÐ¹áz"aîÝP(¹N¦8´ 0Yì”#ÿÑm¸§•è=Õñ,sÅ«({*ÞBZÂðÀ]D9"yÖFi,ô ú'SÂÜÃQp¸÷t³Ëƺæ„ÅBVè·5ŠeW†­Õ×´ŠÆºÛ¤(‚:çÊI§àG½Gën `Ô4q›ìpöã]Ry0.VEÚn ±Üzö㬦ÜwVâ×Aªž‚«rûD…"=Íð^üã~Vu?Öëib?÷®þ…{ÜøoOûäf*ኀÊt ™buiBnh½jè?3«â8ñ¡¡Õu ° N¨>—f¡J. Û…VÿKÒQæf £õ ¹Zãî}Dîü˜“aé¹ý£w‘]ÙóLEÂð/ÙY(¯m»½j爦ƒŒ,ÍÅvåøQ*FOÉFÿBŠâ´ÞP˜±Ê-ô@¹•óZõXù–·Ü 0<)“K°èÃâ üD(J=±†q¯ÖTOGÝlÕ˜3gõú±….æß_â`JÏB*g]`â^¡*¦ SãK‹Ø;m˜ÇÌÏúNämXM›Ò¬Ø:é‹É¥ 7¾Ì2ú<Ñ/¤üJ›ÕòJ¸WYTLÒòy£t¯z®ûc½¨ÙÐæã¡¥Ç&}AÆ.rôyNdŽ +6k›å}«;9Ö e²¸ˆS3TÔï¼s"\‹]Wn½Z9lÞ@‚ý©?;È ý†è3,XŒZe#xm ­¶ÄsÐበ÷±¥º£nÙR {i<ÅO9X•<[µD¹P³Ï?^é0eŽû¯12Š‡Êeõ‘€að1¤Ò—­, xäuÝgÐÉ–Žfa·$-Ϲ‹9¨ª)øT°ôÆ5Œðñ‹q]ßÊò&-k¶;Љº.ll˜›Iï çd¾^›‚³CwñT²›ÃÀ#Cqà¨1Wox²Ê_á í±é¼;/ËláiK ['mkŸw½€MxÅÿóVš\¸„\«€ö̈ã× ª³.¤ØŽ´Óãàp|&ÍduÐqÝc3'VZÔ¡£¤¨|÷èCFÈ·|£UÎ{?=æEª¸£2üJ’ ­^'?£~Ö¿¥ÎzsMõ= e¿FÒqþ[•‰îçu¤ŸÇ…�ë Lv†=jnÏͤ3Uƒr缫›p¨ºh¢&€Sµ.(íµ<·íõÑ Ú�ä�ˆ ÍOÔI¾€Òò逛mŽÖ�’ÓáèÀo¯Ž3›NŠ:æ½ =t$&V©¥Ð•åAdGAQˆ¤òˆ®·f­M×AG{èÂx5^ª‚݆Þè]ÁËjñù6jüÎ;QŒÅý‘•{{¾e±;JCpG4íÌ›W îo×úpŒ«ñ¾úzÝžø>ËLé ¾aE†c jÎeFËÜUw`“ÖIûz©‰?^f¼-Â*qG|oÙJ^¥œl“ò¥þ¥c£†F˜…NB¸@ È^…¬”7‰ÃdQ„âdnõ#ƒpéÚºØ^53-<Ñs&æv”¾•ÍdWFÍÚÑTŽñt¹~½#ø²p4§§wøNƒx}ò°8#40¼áóD&Ë4²piOiGI;Z=´v’@jReP˜^‘ I#o‹$œB¡÷–uÚË·v÷‡a~•÷ìÕ>Òv¤T©çÒ§S3ê‹ï°Í‘37XaúPzûÑ+© =C3Ç”^çh[( |Îé«ëNKËp eà!óÛFéÿæGwJGjmдqÌbsVôŒ{ýk‡ïŽ›à´’é3p½ó0.RsfZI–¦¦-♢ëY×Pð˜þ/ÐÎ P;!¨òïË ù>y5uñ­yžÞ̳‘Èõ˦C¤]™ÞGÐÒ£ýuŸ0Jê§Kÿe†"Ö«Ú»º’Ó+UNÁ”½;ŠEóLJ›j®ô95“Oß&QÏ”e_§òJ0¤ÃŸ:%Cqô\Êd½3ÉïÉpþ'?kÚ±éQÏœ¨GPc8cY·ìðêFk2ïêé]jOzw½½fã|Z¯YÄÚfó÷/mo+wƒìˆya=®ä[ù,Ȉ`à £%�ÖE†Ç?˜äÍõê½Ì1]Üaú‹a¡§å' @äœWÑJ"%ÿ‹”ЦêÇÇ7ð ¦,hFÑÄ@éX¢ØÆ.C~åbØõ œ“þób·š°cžN¬^ Äêñ.$#Lâ7ô!£­o@©Ov¯1,d¿úÅ ßXˆ0\5A 'UUZAsìU£ÀæúLÚ1YÄ(¥%‰7&g¥S„Žhî<møu}ê?;ñ²áá—Á£Œ}Xè?o W;z§ ­Ãðþ¢1N2_—ˆ’Š=c³­ÃWÁ»³£’õC%¢¨:Ó@~%på™2«(ƒ£2ɞ܆ì*›‹Ö³2p§ºßȽòÙ±UË-xÅG<´IO“g„ùNßÀ)åÐX@ÙùgÙ¨»ÍÒRJ½•8TÉ‚sQJ{òTãÛCë”4l¿×»Z¤Ù²<¡jáxÈØkÖ ¨Ü™GI|f÷‘E …ž·QÁs´‹†°#ÀõWrÿ|Uæã´éT8B¹š7Þlz:ô† IsM[Þ˜WbèÈ @ª®~òò-“~Çt2@XÊLòNÚ™á1ƒªE‹'f»[¯o^}]ûÊøáÑ]Kü¤‘o|ØŽA$ÝkiëÝÊ`XïzÛãü¢”køã­Ù³Øu(¾ìg¹²Ê<ùa´?FÊåßmå ÓhÈ®†ýb ®_o{²‘m™1Ÿ'h¶Tô­B„’±Ý¸ÚÕÊÞú·¬£G×8®ÞQt’Ô}äÝ·&É7žZtJ¬€³¤ñ†(¤¿ÚRÅ%Éu!•ÆIæ$Àqwš8Hº­Á¹‚ŠáÔnB¢lûùOY´ìÐe„ò£ßšiµUM¤8xìª ²“-´35%·0i®÷Æ|O/¸}óØ:ÅUšU¥Ïù ¡¡·UfŒX]s˜wZm=qn‰ãE\ a-Ý£*‘H±mψðÆ^Õä47„ÙÌK_ Œ‡‰r·è»õ6™¨uêñ¡ì*€ôßäéqXdÞ¸6ð¯Žæ£·ùl¦Î­ku¨~Õ¸Z˜ê ž;„âkZÎh‘’-ø{ÿFײ°QÄjŽPI#cAEÀˆvªú_�„Œhþcׯ8ô¡Pô4Î` ¾«teÆxq”Ó³ûFÓ~gÅúÔß/fl%+T¨² tz\Q!ì5*™Áß>g@T˜ÙoS'”[*€w¿³z§ÐÜvot–àéF‚Å«‡ý@[†AýWk. 3wW3ÎQÎôÍ®ñÖÜxØ …óËS™x¶+¡øOÓ]mC³h).¹~ÆEm”iÄ«5?{ÅCtsu1ÛÕVš·1Çn`Éµß äâÒaˆ0ì@³+ gi2«O¾‹éÜku=mzåa¼ð3‚7š‘1¢Eˆ±o,§7ùÍ5°_ìt½lë¯z¸šg:ï(I÷t ¨™¾·n’"Ò.g ’æÖA|­í»ÐŽƒ Lé‹•¹ ¥œìLÇ2Hg«R‹‘.„†±qNºÞ¥1¸’bL ;97ŸãXQŽ6(¸/“5odÃg”àÝU·Æ&ZÊà ‡qøI¨V+šÎ Ù?|^`Åtõ79¼¹xq¹ž¥tîgAv>Þe̬=YPæAô¢ßÅÌŸzµÒša{Ú[½ƒÄÇÌí\}A±V}Ú(‹¯H¯1¶‘}—Ò= õA¹?\°Àw…€†ŽM*Ík¹;¶‡F÷ë8Î4/L7èŠÛ¨a!ÆL-Ú;]úp0 ‚K™ÉZ >úÙÐNLƒ,å]1SVê„ïaè¢ÿ›6cä«7^´]dÍÚ#(lexåî®ÿîÂ}/É$ò}d(‰\T ½[ W.s‡`a„ºçÛýé+;Âß›¢øâµüÎTbEÖù¹;v?È{'Ä#Ý k˜ªµËjÍ[­×ÜZhø—aužAWBr#G 5û¥ï'•¹y|4)D¸‹®6`w×VʳÈÏ©Æò Zw&+OîK²úaæm{ù`É„M{” [×ÀHüG2œ¿iPŒ­9ÍV ë–veÀ„-ßôÄÜØ×жyºHCHÓ) Tø¼b> @súþ �ìŠÏÝK%"X£ÂÌŒ+Ø®ª¶N¡±'JÆ5ô¯«‹¯Ò Î{ùnë@žíîk7`›!”Z1\O”‰‹ÜO+@ª=F&´}– •œ¢•/U£ñæ5úÝ9ÜJ`€M•Y­mšQˆ%ÈÐ:C‘™ëAà#»á͵-¯ú'ƶK·´÷<|<+Ø6ÁÈaêÉ‹»z êwÉÜÛÂîë—™s\xFÌôfAO»òB:ßvÎp£$ðP 4SÏAQb±;Ò“é.Ê ¥jòÄZñòතRqC7ëÓcíiÌÝþ¨C™'ïTæ¹çÐ 7sÌé’Q¡$H¤yÀ£‹rÛu=Òw@Í›ŠÞh:²v©Óö¶-X‘&Á|†÷§÷ ¹•‹”ÀkÆýêHÊ ç×V¢l£µO5ÉQ§!�.µ•§Ý÷[Ãe <Ífv#¸ $Rv}zÛœñ¾ËŸ|=ne‚oC¢´’öè§ñ'L 3¿ e»€N¡Ë4Éç-‡8EÒ—waB…×ËX\B•€Ÿ*â,[R‚m‰©¹õ?äÞºÅtŒÈ[]j‹©l»þ¶ÒªÍ…™i+mOôžÝqÈê/ƒåð_©í,íæãœÝ:ãV¡‹qb粬§çÜ:_òíŒ2…ßå†cA…?½ëöì�k,Ž,chl_¯îRV,�%å()-ü?nK!l¢÷rëžR™YäÒäuߵ¯åL§ÍBEÿ+ÿæâtôàÜ´ž>80?ðjŽ+/ÐÆ’Ù¤UŠ„¦f 7föýó–DoÿZvCØg#ýãå£2ÇõÝ_Þffyg#ï‰NªÖ§°Óáf€e¦‡[Ì©ƒãn~ñ³üD”{-ƒD‡ñ¤E*üx('¯1CùmËÐ ÆF_ócN‚¼õ»|6ç×¥„1 ¥ 81_¼{¾9¸/TÐAÒ<Ç„Ó†af_o¸øZ¨É¹)äïTö™Å‰¤†™²‚jÑha¨3^F¥Xé›î˜€ÛP‰ò!Àœ ÜË$,J6‡FòÁNÇ-[º†˜,JN; µ#«yè ¶÷:'Aõy2€ÐE¶ÁJš‹°¹ÒÔM´U@z8}û¹‡˜™üàMã,R3“h­ÚŠ§µ&„™6ü Ô*ƒ?½r…z¸˜Ã3Yƒ2«oU”Åì–Îî‚]†H§Õe2ÿÎt§ádä.B'AÇ 2ø`�CY¬jnúapÝ÷ÿFi½<Ôh´­ ûo¥±i�b‰ÿ8{O�"\_!®j+3Ög¢’ãè˜ojáC)RqÌðòÕ{³¯7|*¹ùûÝnLåq23é¬,[e¦fÈ}ìv¿S{>,ju{„róáµ$­6&ÑD²Ñþóyô·„Ä€“-$ÿÎ- £År9¦ÛÕl<J:ƒº1TÆ C}äãZgz›i”Ó[ö£çòµ£ª¹¶Yýºëwß“'LK 8moÝÌ%¹&ðõ5ݪOÛ«�bãp`ØMpcmwcrWU¾¤ eĈ ÑË]·~c˜Â?o(¹ þS(ä¢#ðKéU›AÇŒ¾Ž šF<û<[k=,ýžUÓÔm¢»e«FïúŽÙ}Yº±1wU)I¤BïÝXÝÎ MýV’ÃüÅ@H=šó~ãÍ"Η¡TÇ~ƒ+—æM›#O žEÚV_YP¼m#BíÏýVDIë`T_˜SgHª^2Œ \ `úÑ'0"=ö¦6dlmm¼'l¯0œ.h™W‘× ÂÃ0¯Z«tÍQeg,c„ÆîòJª…ÌZBå(¸ ZȸKEÿq·ÁÆŸ:.&æHž®^¬ÒÊåñï¼ÑѱÌÞ£&ùÿ­‚r^øZ!£ªéÛ[ÊGž:ÞÙò”8ž\½þ€ØIJO&>æݼOƒ´uòLˆ½0Q™ó¸¯ñ04GáBó#¥ÿ2£<B‡;iÆ›uç{ 5ý©ãbT’jMþŸÛž[û³Ê`DÌ¢ï<ÕŸUÝ=ïUöç2\¦¶=Ù.þ ŽÌÿÒ�Ý<Íõ2è¾³ íΖô:Ò‡«ñßžXsS%\`--#UgåÁú]T[UA´|GS­„øŽð»lFæÓÜþøxÄÅ¡GʃvUS¥…Ò¡>oO8É&ǽ4\HwÅíg·úVÖ™mÏ êqëÁ°kJ`3 k9s{a¡k@2c— ë,¬‚±©Í ðª6yôí…®•È5<æ“FÅ?’; uOÕÏE12k¸ ³8ü20Ur¢%•.m¤ÐüÔ* ²¯z§e®ŠÒÁP7ÚAÛ2Võ �9—ŒLèɨ ZïÐ U„Ì3Dœ,~x`RÑMÖ2:ôŸ ‹øÍŽÝða¬xL¤²B±~àºqÏ< Ê÷…Õ,ôÉ׈<37¨ßô,â|ÁàˆyG%AÖj·"Qß©ƒTq?õ*ü÷ËpHÁ¼ 'm#Öãªnw5êTÖò—бXY²èè¢õ—Iÿ힘ú–šüz×yKêÖ5Û@íŽôÍ:ÊÌýE‹HÓ!ð½uíþ„óÜ] ZÑ¥E”-ÛfTÆ”º_<tö%À@JÒ :åbò—NèQZ:»¢ë;0»MÖnz»ÔàõØlžNqi/RÔê•áýßåõij\3>“`®1Ap†¶FSJ¤v½òÍ^PP†‡ÎÅ#O¹dÜÐýë>=¿Z š®¢Ë^‘$™‡´…7@Ž¥eS&¼ùʼnƄÝY„ä_à¦GÚJ6ôx³ ³ ¶’›7Óä9hþ4i²Ä1d”FÁ•wm…Eêq­C £Ék)1ͧ¦aKqæKŸ¡7üýÈ|{£@„£Ö¢ìwt£â¡±‚ÛBµ-V8o[—še‚ÿž´éÛÿˆÎTû¦4S­þTÑ»–\•7•mÈÀüØœþü©.wõ ct,Í\ù;‹|IiQ4­ ¬Ó©lÉKŒµÎ值½Ž K]:ÐÎe¼:§"€À¢å>ðûë.¦„:ºÕ5ÆÄÖèVþ˜*.*%êw¯G�/áÃÙè¨eÆI•Ç�=+µ’ÈOÐ㜲Ÿ‚ÕŽ‹[ææ³Éo»AZÑöÂtêE(QßUu¹'Í)ðÑ·�!èZ¾â0m[çàôš_Š-.˜&ËŠ(CJ[dq‚ÕkçBýaŸh¡DyœyQJ¯š4 ŠAÓÛ,0®°_XÇ'=?Ø«é<OúÃõ*H'´@.ûŠ&Sû©udy‰2»)h7SýºÕ¢'Âq{€‘ËpøÄo7Ír—Fð­ý˜Ó hŠÇ}F+ázk¼%8DÖâá’§cáCÇ[MRçÏhùiƒYÖQ½)M#wzò!Ín³é;*a)ðà7cÝ/wÿÝ_²`BæYªÁ cF¹qé …a)l½?÷K—$qÇ™$Ï+ú+Ñ`eÙªì#Äg&½OÃraÝ9›6Û§˜YÙùC=*P#kEd�q¬¿R½ Gèëò<ôÒî”ÇÂë$ òõ·(b±nX24ý¡­Oÿï@Á>aƒ�;þ” –;³qíFÚ‰Õ¥Öç™ cýM¤|´d2Ú3b·üé–·%ýRëJ‡SM•¾ÍC"æX¹ÐÙ-BénxÚ ‰òd¡o» }mcõÒjpR}3Š�N)áúÇglðÜ“`ȱLÚ¹ò ò¨2ctn!€eÕýk½º{N8·¹ØÈØœá^ßh»‚¥~d˜—{Áàe•M+C›UÔL°cjNÎàÉsUmX:ëb|8þΛ·Lœ+D)TÚ ÙVkÞ¼ SäªRÿ�óœ]!£Ú)ŒXþqë?™¡ZDN�’9͘y߸Ùñz7¾a¥*CJé'ÞÕCÎIVúª18'@¡(7=†°L×výï'‘7'4O }/zÕ—uÏb ²£·ËìòQÝwµQØ}Š:K&‰ÐïØ©²>n|Œ5†fRä tì(ï\1fšêÃÕÇ’“h­ DªŠ*˜Í‰6HTŸ=RwÍvGµ ï±1áT°‚—¦%†§¬ ¯>(”æLeoUÐ=ÀÌ®NÊ•èÕý„:M´BŠ…ö“à  âwkW¡ J>:¼jÎà6×ÜáЫµºÊë—ò½hëZêkO(6(.!Ûµ+ªœšîûî2Lâ8ó•Ts‹dI±PÔ“´äòsyfÈ¢{‡[�ù…µúÌ¢>–õ}å.X‰wÓÔ)D:®«½aªtÀ#ç0¹—E\Ó-Y…’ñ6ƽÊïgÂA#ƒgƒÒ5m–|­<iŒ9kÚ�6!À ÀŠpNý/Ò…q\‚±TA%†v  Vä,Vx{'—ŽãßíÍH½£.á£åöÛã¶ÏõDŸM…‰ÿ‹Á²Ñã;­Ý¯<(æÉqÏ´ø¼lƒ¶%‚âyPF’|0d(ƒÊË&� Ë -›¿cŸn/®$ <r"=0d{ïÚ Äät³Ñsý¨�˜†¾ybÇ1 ÊwmA'&' £MõòX Çä.J#_'êåµt»§Bs9Ę]ë”-Ñ®;º¾g»P{2ÃÄÀ"ö€È ïøŽÞ N˜¡µ‰‡ ¢®qÇËhÛd IXnq¶žjóóT[`ä ÷·Œ ”ë:@„R J-]„çͧôàA¿G Ež?–àÐ@/쨂› ã¸CÆ ªÛÄýŽ.žf>¿†C$[ßüÒƒ9Â) 6}²W?Þ"Uå•–ój¤w·ªHQ¡4:ÌÑ&OÍUÔ…5ÛÌë-ã+÷¹ÃtJâ­“wë¡#Ÿ7ŒŹzˇoítæù½‘ÑM”4:€þ;•Å7}åd¾L±rêEÉ´>çÖŒØëøÔ²»V‚ {,à›‹åš<NãyÝ÷� Ô*üþ[ÈØDÂœÝ8 Së@¨—F•ŸÖ �'á°7x•á]¿È4ò©²´£Ïk´÷‡“'µ¢ãI3ÔV=„ìÅc ‘ãA_ÀÁU•  Œ�'o¾:÷µÁ¼µ·Ë¢Ð9‰0îîdåÕÕcòÅa`š-X¨Ý\ ¥5?gƒŽE ˜ ûˆoàx sõäè#Òª£}s>›ÈËv·êü$?¨vÒÕ×jÖ¨¡$Á¸¥ê<Zkã2:“µlpš¯-»örÕ{<é ä$7L ~'RÏiãaÜׇiÒªêÒ¾v½¾<žsäi¹è~—´PÐnýT=äš½³Ä|”µ÷€ÐÞ½øj‰u²›oƒ¾§ÆÒ»YûrÝ]®­ø~n²s2­�¢Ë¿÷Bk¼Ư$Û*t5Jn&õ?•d…#é³›ý±£5—ö³S,9Ô^!»9Lô.'ª%<N‡bÊxU ¦I¾°>§ó`.‚ð}tÛí€ܨ..¨%?ojNº ³]¥}æ5¼d¼4Œt¦Ä¶Y”FDVojí—õ´yVWz“Ö"!‘úŠž ÀÎN©«ÙòŠåº~åE>Ý꺉 8¬e=@>褣à­8]»Ù>R'ØŸ2„ÛQ»I…îœ]™/‚@…ß@%Obeð¹?»ÓÞ½¥Lµ×#$Ý(§øSÿÕ”,S1í¨2Ã�Õ³µZÐÐu°™üå´0G†3ÆHäïaê,v-3§Ñ±£m_¶®½» 4¢ú®îÁw£]0ãßÃü; ‚ÐS‰`‡q“‰Ü€ÌÙÔ­Úwâ’Íö:!l%?{…c»tJ±%âþ¾cžºH왣žôÿ¼¥ÉÛ¿o™q'£E$ A-iô¶8&ïJ·Q¶ÀAѶ¤¿GÙÙEᙈë°qÛu"7è]ù>¤v' üŽk) o†­…*†Úhó�VÞ/Œ`ÑžwÛîˆî‡E§~/衯 ªµ'(½!¬hó+-Ö‡Ú¬•SágÂÌžžkuTˆÈÍS9ÛY&H·Zõȱ]_gªE2ôþì>÷¸zuJ†w_ízP÷aæãÍOOöȇ"Ÿ!huTƒâBÑ7èiÕ­êd·ÍŽgmwËE“: ºoø½xSâv¶ré$û¢Ú­´„¤ð´€³ÌWÜ…ÛË„JpÐ _"Ýæ Lj^}èñ‹´î/~ó8sòy ¶ÜþSh ¦Rlè®w&¹zºç+؉¦A¢vñ¨ã&˜8Á˜à©dÎ#!(Ì3OƒÄë$瘣›ApÄ^um¶z\ÕçþþdÇ#ðDtE»¬×ž…4†§«ÞeƒÞ0ëÎ\«Hݧd(÷p¦\nP¥¤<k°¿8y¸‘é~`Pã·±AR}Ì Ô>wZ~;N3í®ïõÁË©qó‹®W:†ùV5œ|Nf£‹ª’NÉnvÿ)×”üµ¿nêß&Ü]î² ä” âÑ„ƒEPòâö Ïõ4±r³¹Cüæ¬áwgÚ[yþ.ôH§1¶ó»Z[öº—¹îÄCPNî_^wæ,WV'^÷“I@L>F[÷µvm ñ7{¡«ì¾c炬±¼4ÌOÅ›˜Kš×5k©¶Éý<0h4cD3Î/ÌÀ“ÊYøH³Pâ ÑÔö¾=¨U@Æ4œÖë7ñ“šJ¸2¿(Í]3©0îð«3z<–ÔXšÐj ô(¥[*ÁŸl,O3.u¿à {Ài,˜ë<È-0ûêÈA¸/¦@Ø!Ê]²Æ);ø@4ÏB‹í@Ž=%qååäñKŽh�Î[»`ÝÏ,É_ŸØ.4àîæ¸ï*Y¸âÌ¥ ryH;ÐQãêÏ”ÂûZü¹%kD_y`Ù}J1D_Y1¬&fÙ‚¦‘£Î΃¢µ³5Å¦î ¶±#j´š×ÿ *± c‰ß«£uê¦ûQ_^´|¬>/Ô#ëë=6@õ¸³$Q_è¶ñŒñùžÈûòp1Ôg)S´,~úSÜ8 T ÎÁÜÍrîÐ3„ðöÍD9J=¡VæÑõ8WL(À8ÀÒÍWmÒÕ¦«ÌOö±¾(UË?µ€G« ÐëÁÊxÉ Â0•/áÌö¼°œ`HÀ é™CêÉ@Ê|·+ƒx³1Œ¹ú8îŒúãUÁKିp€4pÂÔÑ»ºaú…êÎÀ%h¼õiwÖ„Žêƒ…¤R·>"iVzñ¿™M½Ðöøže¥ý„èÏoó­ÆåG6MàÍß©¥rÜ>¿AâYra€M j[£ž 9&LO8›Êæ}gþ¥3ºÝ­¦Øažùl6ò²ç.$Åëa¢“PpO«aÊ;èžØÚGväm÷ü�†OãõFñM…Öëcr°êgî©v ß‘Îd‘ª)È]‡^!E³ò}VØó} ƒžøç-ÎÁC/©KÆuâ‘ö¬­Ií0«p¯¤(¢$ ¢æÝ!~÷‡33OlP5ŽõFßkÁvqŠ™1ÎgÚÑ£ Ò%j-MéÿK»V:Ö¯ißP†Rd&®±mÁTsïºö°©8™Ì0‰úÛ\÷Ía~x-3eO-.Ëü<)%Å­uˆfÝÐsS;­Ê~kì.¦ÇØåŠJ£•Š¬DCbu0ᾆî#e]õh ª'̼bÇŽ ¹ïèÜ‚. ã†cOßGU„^þÎ(àæߪ½œ•\$­jÛl5O¿ê«Ô¥Ñx¬°=w”Ó§ƒJ+æýÍ´Å]ÿñwÆ—³3ÚÔyo!†!`Ô0·…ä—D[×,µ‰i&*]H§huÐ'okx¿Eq´(¦è@¸dA2Y9ü ªÏ%¬êÑÉ< jâSIÇ°ÔÄ|0»+¬ÎòjÈuFЮ.úþU„)×¥×6ø¶¾´“(>W‘N“,ôýƒáô…N\gi4Î;Wl³×ï#šMä| 9 :Ó@ùN:¿{ª #$ ÚçaË'.22†ÙÛ²Ù½U Œ¿/nb\ÈR~Á#Ǽ>’Tt­ØV4--Ù´qẕ|Á@NL÷‚yÁ£B\“Õ¥ 1ô}R‹?ÆÉå³eŒàÞÿEç'÷:ü¹¨!@ÿݪbA¶»i¬»~gϪþ�ûWïÛìmîÙ|å=ôÍŠ ¯[£NQÑb?ìßô ݶâå^7—¿ùJ›ÑZªsŠL£Ê °æ½in!&…T£ qƒµ¡€o‘dv\Ôé ½­aãróÞ„uw±¶ÿk•¸¾¤.g£ï^ÁÊ¡¨ýa�tF B_Ï—ÕV„ÉnœsÓÊW‚ T†íÃÑëMÇ®k¹‡Â[LýǼ×{’¹ATÓ{|ÚÝ  xwoü(^?…Sǹ´D@í˜Y}vH&ž?š©3ÝÈ=÷e~`àX«WnäÃ5xˆcî-¨“£qe=Kɦd–ö‚òz†«,qKUä§Å<1¥ÛXžìò¼-ï“ ±â?(ÿêpï'�Ó®5›šÖB<ê” F÷Ädô™—Á›”ìÇqo”_§+BZ�ˆ.åÆhI)ÄÕ»Änç™}Ç™)§{²­ Zšc‹Yëxø/Vº¨hº aÇßI“Ì7‰cÀÅšoÉÔRÔøC@51$_á´(¥Cìøîé°©hjÊÙ¥ßtᢠÆ-}¬–ò¥Ë€|·¦\éίxÇdž/­¾3°3åZgWèdï”�æ´VÇÓ ËðMŒYP”å4ïêz°žyjÉl«8¯iÿlZø*E»¸>õû l‰ÇÉâ. ÀÕ±£gMUÊxpŒŠÂ{˜ÛÍ6g³ì'Û_’NÝ?o)*Ÿ´ ؈—–¤‘b…‡¸ìÞV[dKF$ õ5r›î¥ÿœÐC¢Ð1AQd¾Ôôž*‘f©oUDñ¸Å÷ýTøc.>““”Ü–§ÓæMèÉ´ÇïþH®S«Ÿ]?UA5 Ηc#’frË|ǘZú±ª+Èl;»*H7µ'qÓ¦U}6iP¢DËoFG·y³«¯ºó9Ki}¥ÀͶ B),¼ïÌ a`Î"/èçŸ5-Ë=ŠB)ìdôM×”ÂÂñжP,µã%paQ\÷ƒèo�h­¼œáNíž …¿h•'ŠÌÌÈ–ÞËw¾À lyˆoI¼ŒX_”&Vïª'g˜£ è»~àîír£Ïóû.j¤Ò4æú½Ê‚âìy-"lJïý{g !驆Ðî¡ðM*2U¦ªó}>ôSg»B\.÷àÄýRÌǵ�+cZ?åAúÙ+ï¥bÏñÖ›Á½(s”bjhý Ð9è‹œ¶øe¾óƒ6ùbv®½·÷K:Êcú® òqëµ²WPË›lÎ…"¿<ðC¾ýÐÖ$¯|‡Ì3©m,ÎòiÏ“Žm!)v85}ÇP%~íŽý÷ټܚ) È9À3Æ”D›‰˜¬¶»N¬FMFv<Ú{€ŽnÎ ÄÐÚÆ¡ˆk’œöÚìL5ö‡zÞ [së[k 7" ={laËÓ/h¿wóä­”_©>î‹Ž¨í @rm+FKÈóYáå”SiáâÛÈþò¤ÑJ‡(j,fçë´Þz¨Ø5­j7=•øC©íÕ-�­¸)¦°Ú|;µè~·ïÞª„ÁÍ zë…iÁk{õ£áè‘Ä ðþDGôq©%$•¥inÉ잨¿¡Ô汥߽O‚bn=éx4#<ö1åvšYýx‰±G─ÙÛ×ôW¶1.K3®¯U³ÞÓ×à’ð„ÿFZ.6=§â¬È¼Ij}½gKKÏæzqšø…°R�öŸ&½ýLÞìâ¼u @—š þf÷ı¯á‡¬c+@62‚‹AMzŒãÈÇIæ9€ˆÉ2UëµËöŽ˜iXq0«A 4×D´OÄ÷²Ÿ¸£´0 ˆS¯{#3Ûwtê³×•Ø ¾`÷5˜–æ®\ÉéKÝ»"˜ë8ÈO wÅ{M�袟Mßß¼RÁɈRÏI‡=‘Â]çÏ„ófëVŽd›Þtߨ!-_ìÑc½Û ŽR„Œ)¤e”ù¾ŒI ||£2lª¤K%Ò:<š#Kàs~úBÒU•ÙRyª™`Siœ™<Šˆ9ƒ N(mÈÊy‹[yþ“òV9ÛA& ‘‹Ýñ¦�þT•ñlrøD/óHÌ’Û ÿ© r?ø„ÜÁ·–HgŠáåËt†×—Iprû"ˆz-#ÄNÑ{ÆÁ¦;ŒÕ€ÿÕÄ1 ã…°CHq°Ê£qrÖ¼sZ…æ£_ úÞˆTnµ¨]ÒbÑ»Nƒî›NóY›¨ð Ø·¨ûV!£à6w´›%¢.¶Œ0V Ä¹îó š.Ý ‡>¥•3'C,—j P ÓóD Á›ö`^¹L° �:íLÝçé°«u½G¥J˜Ð±Þt«Å‚‚`Šl•ËxáŸÒ!4œ¼[Õt=ã±äؾ˜Ñ»wõ@H(­Ò"×Wª>Ýù|2­ÈÓ°I g,V‹<œ‘i>sìŽóHÄÖD§˜j¸~¢PP«å<?2þÕ�ÔfÍöÿá Oj`7U`mŠe«¯$ȇÞ¢£[I50}xÓ~A@3÷0¥Ü è᪕ŠxÈXöÛábPã1À”Áþ\p=.Ç>Š‹,œ5ãQÏ7$ܪöLI*f¾Ì×ÐÁG^›qî¤{˜ÈøLËÿ/�¸=º¼£\þ%FÓƒ¡3MõrHè/9gf©ÒÊhƒVÂÒM²Ÿf™Û£¾¾ÝU1D‘Ó”§z<œÝØwÿŠ3ðÍ/ΗñÊ/8Ò‰EXé·ccb¡«Ü€·v7îè^@Spw­Ð�B-ªe}Gn'Î<@…@P(­x×õ¿‚˜im-è"Xdhؽ¶”ówð‹ên\õVÃ]·¶ÒsÑãv,wëj-¯¿vßÝà:uªÑµ>|o”Kzôd3 yQG!×<J2ò48)¥„kuŠ¥MÛZ°‰KUzî{JZGÓyßa¦,ÿÞMó¥Ö$Ø9tìç'Å ¦Ìô&€]Îõhî{T†X ‰GBå.ñn“å»Å§sSû欓ÒÙI#Õ¼<G±•¦öWvG�ì;/ë4¾“_ßï'î¤MÀÿµ¢€÷)»YåÓæbäËUÙa¶´ìTÂEVZ_—<£¼ô½•ãArŸT¥Gœ,É£ª(† ¯·ù‘%™®Çsª¾ÏbÎY™ÅzæKÛÒi,xpWPžìV«\71xêÚÖ¾R:çµ| nYOIkGQvº¦Ê¯òËÈ'›Ó[Í”ØeŸ½®»qsrnÐÛ %yæß+Gœg¾²'ì 7ôµ?'÷œ¾v{:«™¤/ÊÐ76D'þRRÑ·q¬Éñ0yÉ!eg”�1~·?µ uÑ[v‹”§[jkˆ¾l€é8±–V˜\Rh[ÏGæóš÷Ë,ø,O’ÌQÃ8¡Š)¹Xw±˜[‹YÅ”Gl>À "KœšÊË �4˜N´¾jOŠœ2îÎÌ9Âó)n_i× ¯ÑO§b˜1xÜîIx¾ î0Œ¡é;S|ô=ää^ìÃÇôö±C+y<mì¿WMöL¥o•?д¹G5áÆî¡+\½p{q“ùR#b¶ÇsÖV+W ;ˆƒëo�e¸H‰¹ÛšY¦v0v¥·ç»l¼ÖoD#S³r€C‡!nGo„dÜ ²fåRo)Î_ô)O.Ñ9¢G3ÕVDêJ©ãê§ë´4q^ ¸Õ¨¯ð |÷æ¢hŒÖÜ©n̶ ç2*Ø„Wû§ôx`œÄMLjÍmtšê~VMäó‘¯ÚËÔ°õÏ–‰_Ñg®)5›œ¬‹.€y4:ÆØdI•U²8¢HDPéè(­ÓÚÌL¤Û±­çn-‹à÷l õÅ)Èà‚Œˆô¨ @Hj¶Á§3ÜFö ²:Ç»ùy!£HcðYÒâ¢åwgOrD§•êêè¶P�˜ÁÍ¿î�æ…õX•¼žÀïmר”t‘ÁË0Á™Âz—/qÊ|/J49 óÚÓf“e±ZÅILÉÁ CoÜì]á"GͱƒÐûÉwé>XVïb¸“o"Èø¶¡;P¹ðcÊ—ªó€QÎYi²²C{¶–ñŒ¦bÆÿ×L²X ŸINF™É¡0Lw¤:ôÒ¸VïRÛ8¡_×Ú lÄ´BèŽÓ¢Öûäí¶Þ—Þ²L n¿ ¬š'|hz ïùª$%óÆ6 vž|Š¤ÿ·0¢mÜ¥3\)?ï¹dq•yª¨"STvQ ­ÍN8Ó¶>óÂ8r4}ƒXŒÿIr¥ü 1›æMi¤FàWßèÃ@ΉC_ã@z‰JFhè~O8óð> Z\˜sëÉÎlÃz4Ó*^'žŽè…Z›ˆ«“ñ°Ö¼ô: 17£ötûûoŽ ƒ¿I¶ $ÚöÆòñÔÖò#K†ÖeA»…ÀÒhð%Q i†*äé(¾GÖâ½ó«'\ºÄÚE$ÆÏÛ˜1ØL|"EÜû¦m§aé°•t4î?häÛÎS¢•s`¯7|EyIs¢}ú•ŒPl%¢Ô®jÿ‘0ëß9+ ñsZÑr±9&Fr3.Ó/E‹rWßÌvè)ýäÒBÖ<GóA¤­jº¹´�‡†öœ,ÁÅlqOå;[€vØÏhÁ-Kä¸lþ'ç?+C€@ÇtËz“VXû“=†¬UÞÎB’V<uz¢)*wbO.e˜›`ÒÍëÔ)¼mÕº{áô¹EÔY¼±&¶c¦U:¥œtƒ/§vMAe¥ \[›âíŽ|³ý ¦€àÂxò\Œ¦,`%ïÙ–“ö‚˜sõó‚Råáj¸7³‚Ýözmm½ ðèIÕ§ž’›­’¬˜bKQ¦³ŠÚ%ÓNDöÁ©rö'îEßük‹(«óczÛá4z >ºè†ƒ©µ—6˦ñ]ýs;Žb{¿øiD{qÚåëú›Ò¶óôP‘»ãe³ƒh¯;.dXXÖÅÏÔ[;'º¦)r±Å‰Èò¶ð D5h” ®ZIìÁ—ìbÒWAø>lÐ }`;rÈ9/hý©ož&ÿs'¥ŽÔšF÷¤¼ë4ÈG¥#òöqé=.Ab}¬>œ¤þÉD[é8R î4¤ç9ºÅã‰"ªË§¯‹†m’f¾¬f!0–¥zšþƒëq0‚ÿ•Q[z&¹åtuBC~†4BÞuÚ//€ñ;èšÎN-YnÖá^|ä\"ÜÝyMK¦ì.JÎ ³ÐÍ°|Þ5FfHõ~ VÓ¼x#Á9±‚ [ Š€×j^ýIëãÇ£æH5YEH–¾þBHN2ÉÔÀ–YU¦;Å8M…?,tQ¬žYjzh¢gÖ €£¯áƒ at W£hÅFxÝäWÞ¾ªÆSBwÔ -xFXñõл@òøݽ!HñU}Û™.ˆß#„z­È_ªÜÁ⇟µ*¯ÍÂÊã^TƒêO~\ès.ârÌ–0]ç¤÷4Šƒ½¸çYV¡¯§£( ’Þ†ÞBõÛ•®Ž÷ÄðÄîôö4¢îÛ¹Âñ‘ožì s9â4KeÒ½ÞÕM#+ôÍ­)� g ëÑ0{Ñ:Œ;Zouou•tDÆ‚eAœ‚Õ€<úö/*jËP&‘fÈýØœ<ñÆ0b 7¥a|Z8h¢þ"<ŠÑ7\‹„ÃgfÊœ`ÒÓ‡±ÂQ‰NéôkûÆÄ+ $õÞ‚RUY nÔÛÈ¥ û@æ‘+,ûó…#7Õ·‚ÕQ¨•¹ G˜E&Û‹“1‹øÝ&Ñ’¾zõãléAII9 ¢’skñB‘HºÔ_»vº^3kGÑûQÆ{¯Âµ:Clß3ˆø›ˆúît®Ã ĨW²©ìÒïâU%ú<\ðÛÒ`} ks »?OÚãEðmÐ+D…ˆ¹„¸kü‡’¸=ó• Ì“<άÝ_hts£AáÓ¾!¹ ‡T>ï_ÐÍœÖ2§%´Eç‰>v9½é ݵ°$þOD’B'ÏÄè³àü•éìSs‘8‚*bí׆_usÉc`B%ÝIJتzðTJÜeM³ Øûæa{oó økÄ%­ÉD¬à¥PmÞןð=àÍž…8Îy—«Ã°d§b©ÇÍ�Ù³"H[Å.jŽ©‚'£ìãg,¦¢(�ÏYÎ#í·fãºÑX­ìe¸JŒ{~åZ?µž»»MUÅ÷»'Åá ÀNÇ®mAwp7oœ/p{´/z: ÛØçk¡ŒÕ0êî0î'd#FœÀ%ÁW�o\ÄT¦¦wF«ûš|õËá_æÝ^r©†½ÎÙ1š‚‘ì:¹÷Š|úÿ¼ÒÚgÙ×ÞÑ•MYm<´NŒ¯ãƒ~< Ã…²ÎΧ,ÎN6:ÂO} <ôÖ9xÆy6ôÜ>èÌ)ŽZu³ á¶>v½J—ÆX½š!¯O,ó'Ð^ Ç®þð®–u–-Ü‹â h[Uï¾B)Õ´u™7 ë¥# ´¦¿À‰+¯ `hô¹®‚„6Ih3kúœb+ÌF±fx3?åGÿI®øÐk¤U½bÏP¸¦ýi”•mÕï~~ÞTpj‰¹áÍÁµXMÞôµDU>aøÓÙê¤z†¨F(FòmZ;#z ŽN¶Tí.¤¡ªL1 ë_4»ÿ•Æ9Ø­;¿¢¬=ÏüUVˆãxj]u#á¶Ú ²´¿v/¤^F‰»#Ø› ³ôÄž»Û¼¯aMÃU,[ºM×)êëñ4ñ$™…:”AØûClZóßx?£\º6cÙ~rt°ŽàRïÑMoZè}½ŸfÉÄ�M>¼‚?Æ”Ï ôUêÆ“ªÉAŸ¶VÏœ¸Âwõ+»â€¹°ÑõŽíéǯzXæU2Ú©Y¤€rr¨–%hz5qÎc¹‰¹ Ëܱ‡8Ý]Š˜íÜÊ|) Ú ½yR˜‰²¡ƒî™XYjn[Ûbdì+;sAÔŒcó µ6h@DÇÖeÒÝ—Õ.xwxÿ¾ù +·¿ñ*cX>ÁN¾þöÀ:t³9—£ÍýEÆÜè»öyÍ*Ic®Ù&>ß~{ 'º‹á1ÜØ®þBü=[ˆá–¦«¸~wT!ª…zZÒNÂÖ5\k~l)ºI—ÕëÐűæâwÎ9È ëòžžÔãÆmœ&™g`Òbœ² mþxÞ—hïï,Sq{`!{îë𖱊{¹o4nÙé ÇXTFtž±éoeo[QêZHlIGáœvÑZw'" W#¬û sË>¿r­O™¡dÚtézr¼Ëñ@‘d§27ý €oaø×OSåBÁo‰!¼; CÇwoÆc\F¦ãß(OîâÇ´k!³ËFXr5–[MܘU™zMÁ.Ž}¬Z'Y‚ñÆÃyðŒxoŒtžYêÄVA´! RjÛÍ‘Š6ñXŸ)êNzgVø™ÖèõëRú>ËBŸ…Aù™ÓQÛõ¦KŽÝ‹n•Ÿ—ÜÒ`DUû‘¸~TY`„,º6Uwôz4NU÷ïµæý_hà—ôxÓÊzµâÁ4¦Ö¿Úñg5m¡-UÞý?o�N!‰Šç ã™2÷‡)t”ˆ•ô½;n5cŒ¤Ó‰äß™0ÇÑÀS…ƒØe¾üšðÀb†ç(˜Â¥P¨™À ¡·Š¦o×߇ü¼pÎW§¾ëpÿÈØ¥ØY›,”f!<š»2©d¤HĨy×9ûǪ¦V×>7:I§õ´!`hÝ JZøÆ0¶Š.¡ŽÇ6¬¢¦Á¡H–  Š6“L"Æ—ðQ¦»A‚556Ú/cùS‘Ƈ³³ãôeÞÃÕÝo;Ž™6Ô0&ðÕ~½xªMÛ@t,@ûy“·éú=W|§aS_ž1°€#`:êS¿l¶GtX¨�ûÕ5¥ÈšÑî]^;!{@žDx!){Z˜—‚Q•å}üà•ŽŠŒ\® 0yNøqàL;Ì–jõ\……B�ç`ËqÔ#Jˆ‚öE÷ŒõMó x·}ÿÊÁÝĘ+œ¸ jŒ®«Vv”G´J÷i¬•ð€\‰åŽ“íD°ÊøöÐýzQTÎL¬ä´†y†¶%0·njñ«‡GÞpŠv 'ÀøÙ}Œºjàä‚Oà·½0&NJ_h<*M?à³ó”x°Úi=|`‚ËÎsÒ  ìLU"–»ÇkGìb<1,Òu�e"ÉË]°GW¤[¶©‘-Â^�¿ -v P2_æ8΂.å"² F‹ö4ç;„?8ù|qêÃOJœôÇ>ÊIû«pÆ<w»Ñ¦ç'šênSÅm\ ïrJ¦u*EelqSe)Ì:Ö6ùÁ¯"c1uQ¢cäÐc\ú­b»pEF¥!‘R:ÖRõ¹·j.øÀå ƒ%¾¨ Só"NA±ÏÍæ?^xÚgò¶Ú ;Šá†NÄ—.wã´ zDZæYêHt«øÂGa3n©XšŽt[º7ž”¨çFÌFQ;JG®ØJú8>ò Yd™SÊKî¨åI+CR¢·[}how¬}ã;é=úPõo SS/Cˈ#<V!w&|ܾڊôš{¥ˆìâÁVä­·g„b<ë—bïî¼›uøÇ–,`uOº4±GBj fzW›d�÷Ípx?S½2ÅÍ ’ªVáz ¦#æKÍŒ:¯ç—ÑT¶…æ~ô• ¶‰Y€”þû‹:×m㋘ðÏRï6¹©Ó’…<5:”4ÆÛµm@žšR߈ z1)ØsEU'FVP!EÚ$ˆzk”´É7‡Ö×Ré„k …"ôuÍ(Œnz ×¬5<Û'åÆm½bäþå2ŸZ(룆Yê%-[JÔv{Òâéäýmë…Å;{Wç·âX=¥nñ÷háYÏÎf»³¨žÕ¢Îp8ã€^ªŽF:2‘$ âùèÖC‘½>©åÝ‘вò¡Yhl ;Àb…+‘Z=X!Ïÿ†" ÙƒÕ¦é©j&#u‹­UŸ±ü•"½VŪ‚dVƒ%`iWI˜t0Š¢[jËìg/@¢Ûƒ¸òMÏ¡±ñï³ÉïrìëÍ¥=ëiàñöí…à“»VÒ¬+ôFT™ÇnÂó…ûi¼µðMö\¡GÈPg>/—‹ó È>NË+·Í)òºÍ˜ý[;r¹3ÎóúŽûu‘f¾5{„îuB%{cýyB§ÕëI™ŠFÕ´©8I®”fY$)k&¯(=wÛRŸ„+¸³bžó…™y*n­.|ê°©…Ð /`‘Þö _÷—+èhæ]£“¤,÷YÛLÔ¡~˜DÎaX$ E½öÌŸÌ GÄ\ê~4ëæõz¸§{ÏØ & ÌANµu´Z4ÝÖ/ñ)SÎõPÄWošŠ ?=a,A ‹ªŸáM7ÊÊ^Üm}Ç> „í=¸Ä¨Ö z¡d6~6ëÉPÅÆ]qËl¡d°~<NžA¹t–øÆ‚`Üó{¼"€Ÿ™ofí¼}”ÇÉAò{Ê1 mÁ瘗;êžM•aÍ,ŽiòiÖÄl×Ëg‹ö£*@&yžùïUMSee… KÖyó$øèfö;–ò×+ªXxm‡%¶dÙ¿Í"€)œ+ÓëÀÁ7æÇàØ6äÔ^<BžÚu$aì…DìÞmŽ\ôlrH¥1CÊcª\kö”åòÀO¡»q¬¯œ;¢H]*TjxõßA!0ŽÚvƒ-•¯l;^sñ°aaÛšÖ\V÷Wh‰ê‰Óõ_]Ûæ]}÷wá³paJû{\ç{g‡÷ Iu“é½X.S½™ÜL‹ äæNüÅMEªÛÒršsSÃÍEöè¤"š(ÄŸYft¦ë‚Ü_t3Ìí¾Q,è d< r_AY"×?bÛ&¶] Ç±ýô˜ÉTíºDò×¾ ‰×Å’žn!¢ |бrUÈãÞÕK’n|'aŽ˜ïÖë01kÎ7•Àý4NÚ,û¾Bmë13-¼Þ #`é¿îêop2±ïàÇBI]¼‰ˆ_ß øÚ×¥x¢NÅ‚´”ÃyÿîÕfãaêOnp“ïó”mGG ^MÁS Ç{ÙÖgN@œJ*6ˆ’0ÉãE*Ú'$›Èóˆ Ô ²9ZäRÉ~›nž´ûó/HÝrŒ#fŒ-}þÏQ%ÏS)ÑX¸q¬×,j7–ƒr(^Ü�Iú§Ÿ´³ ±¸LÊF;ïR•%Ràœ$OWæS½WÕOŒDÕ,ìI??=ƒ.ZtgG=Ôxâ‚˾"0C ã Ê£® ë}æËHßtS挟Þs*`RŽdn¤`æj³lèl–ÕŒº;h… ªw.–ñ+Η ¥¸#äï³ç» óæúióÎt¾^0G(2ו<[^•Õfõ ˜"k”§ïÀÙ«¾B €A†·YâôJi ªÁ÷Ú¶· 9ex3•|Ðéh¬›œõë¯f™> [¢l£�™W»ùä ªù`_•eYW?œÅ> ˆûM“RN&^AÁŽzyóÒ>di+æë`Ö5uƒiBÚËÅŸ(êC›†ÞwÖâd˜Ì~ôêþ׈%„™™%Žhì»D‘aí »þì¤4VðžæÃG÷èš÷‡ˆ.’e§ý(ºÝ7• Ö&*ДG™Â:H hcZÝ¿î[²PÞË)£¥IÔb¸áqmU]Š´‘!BÏML#'!òØöõzD—†É/ø€˜ö<ˆg³pÑïèkÅ‚3AþsF 66ŒŠ £›Ê¬ôM?9-9§Aò©@dˆ%ïëÍ@ùr½|Cú›b *KzRrŽŸÓ–v—0¡†G1/N6<aþ'ý»Ÿä�ö.oQ»Y¶űàˆR«”œ¦ËÎåNÜÚ_EÿÉ"›9Øà~ÚE ¢E\O ›³â-Ÿë´rúž‚ÆEuáï¨ÍWÑ‚,CÛ+箨~ô"´ÍÓ2«{ó Ø5_ˆZòÄkbx÷ôÔ¿.*\û÷û¨ðÊ$a"Ngú–y†`ÏÚ,íF‰Wjf ¹BÍF0ÆëSgu†²:í¸Jô Š ÍFxuÒ±(¼¢éÀw¼¿È½‚ÛÜ o’ªÈ<˜?½y3Ñ/.ÊÊç(Àv˜¬Åž±eüw:»ñß}mA¡Œó4ôtUàܽëâ@K8’Ou×+ÂÞÔ“öUƒtäßdʽÿûÉÛ€_ŸÌ9ÿÎ’*àÒ±ÝXÒçx�—ËÚ2&°ôÈ¿ò=Ë gÜÆÆËó'%°…M0ÉeC ¢3I7JŸ¯@ï)€æj”á§íwTmÙaìO‰¾AuC„d·®¿¡ìЋ“[â_šzå!½å0�g}eØjóÝDÅ¥ ˜Ký2¿´¡ž™Î÷ª©‚‚Å!Œ¨-FGÅß²e­uèXG¢'ÉCùfI\¤V;ö* ‹y¯ß"­ïLÌŸq£ÔKb™òõͬWÙ—”­^‡ŽŽ£º×R¡ÃtŽý_^âTEc$Y €E¯…[‰j°þÚ1ƒÇh ®Ðå4MÉ×Bfâ ÖK¶Ãº"e­¼géÝCµdˆ*‹êqœùÉV¬ðB˜ÀÚö´ç{Ò…þÖôyÚQßOož*- GÉ ðŒ1‡¾c´è¡¬KnØvèØÚA:Rˆ)$ãN¤ÛPo@§ç˜£3âÎzñ‚ÄÝt«;* Éõtz{Œ›Ù ,Ø.Y›Õß±µa,[[Ñ«ÕÖüéñN¬Y2ñPÒØÚÊcÐûb÷ì‹âÜ‘)žÇ™6uÕ|ªõ_åÔE-pšû²/´T#!bL�”xJ"óF‘0åÛ¿o•ng)Õã<¿õÝa@£LIJ1c, Ðx¿l!ÇÞyj‡»¯‹/_.mI…E>€GæñUÿhÚЇ_kÚ*‚ lªh‰èë+ÒÉ…W±K7"Åxöt·Åb„�#B,7 ¿vz¿¦£ì‚Wì¶Zò<~h·…åä0ÍdõÒžbë­œÝ0`×™¼mùbäÌ1ɲNMA«ò}ëû̵뮊líiž`-zX¹Æ¾$A´ùº ²õ7 1²}ld¯6ú‰Öƒ ±/„×æ˜ÙÖš°±™Æi˜—[Ïð_q˜]’†.¥|°=;ÝþjœKIqÅZ¹Ûîw0xÞ¥7±Æ à e–O”’ä[…:E1¢² šÍn6>1¬Ý)Uùuçýþo=OÙÒŸÑ”VAv ¾xµA'¸×wíK¢!©7ø˱syàš}«Ò²« Ķ­¤ÿ_Ž[ãtáiEÅèÇLË'}×Zw__%cJÇ4†…Wªn;5·•ª3¹Â„ÖHßéyç˜|Eè+è°zA$NC¢2`« ³‘·½ LGúËÛä#t6ë²ef5äeœ69aH1±¼Z`W?Fo©2,òaȃpP~t’h`Î@Å€©¯=ã·¶(2—y_汌¥$8F­ÈpîiyAÌLÏ!¼‡‚1ÍÕ—xi^êÞ/âÔspËŒv&f?ߎ4Ý° ©Ýß/IeñBóŽØ#üÍ•H‰d޼ş'tûu„`wwÆc­+ÍÈ"é€îVÕŠâÈônù­7‡õZD#WýøÒÇî6 “˜rU:Û¦Þ±‚ ìä0λŒÙ€lñ£Ÿ™�=•€q›¥õéÆÀ ÃMJ=Œ†iò™—çýݨÌ|dužcZä�S%‚ 6jgôÓ«�ùPL–†Yù8>hçæß6莀l±Éз½–ºzx.¢N2A $Vë’nôØ8QVÞë=§û<÷‡ÚePˆ?t ‘uãëâ_ú,/i®BÀŒ2 ðS‹�F<ý¾7@§ªô5RiN}–â4žÞ$‹‰6t|GÓÚãûo(e¢2à¸ëVÝï½Ä wŒ‹ÀF߃‡ÚýñÔoÄÃËœŽ÷LH¦±½`h3œ/æ_ ŽK—�2–¦£(•X½`UªI„•ÄóqŠ2ßqµðÆ¡ì)½Ý~«97¨=+~§ÎÍZ­Pôúѩׄ—T†õkSJKM·~ºF'ö¹ ÿŽ­EMZ9þT±Å—È?Z*EÀg5NÕæôç*–×]£"“ÔÚfLu÷„±MÎaôÆÄõF×ýa Ÿ•~ÉB }ú 5™¿½èUc(Êj¥êÝ|°êzûšõØ•ÝåýàŸqz††˜”Ñw(Ö[‡Ì˜ºµ£»aÿð?Ï•zóEä “ïê—ßÅb:A‹=ñÈòVꑾ˜çFõÏ›9>híƮÝݸ<ÞïŒ{‡¨ÕãÞÖôccåµb–×VE-MòÁ ¸ØײCIé7È!3¸¡p»Ñ.@¥íéà 'І8,ÈxÁFêô;ü¼H§Å¡šÎµ�qZ¯ýeÄÑoq½³±/W¶S˜ûú|çí•Á+ʼìèãÇ–)„Øùpèé ¨2ùrºÿ÷?Ó[†Ç?.,m„Ûó$NcÛ®~Øê@1´¶DŠ”š{ŒöQ7é¿c½ƒ—@gÁIgî„ SwÕ§U bA{£#&ߺ"^‘º\?a UœQÕûOD\Å ‚ð4+2ô·C+u(–;�WÎeÏïš WH€a=Ûñjصí©?nî󻿶xë·ýá0Ê!vý'#_»dCù#æ›õ§'¹¡u{ÆûÈ ç0HøæBÞtù—Š¿Í¶¢µ¦LYY´éœìÄËÖ%^‘’¢xXm);ëzÇ!ë ãmׇ̹¿êÇ#VdŽYb&ÂpïÐî°%c X#�Æ*…’+˜ÿW�± þ^¼zxÑ’ömË*&4i̾R× §{Qð²ý5¿:±e‰q÷†Tqó­òs&ož_»Õ|u8¨¾áúú|‡ÄbIŒZ7' VÕñÝÉQíëcoQ9OE3>3­%ö%ŸŽ®+Æ Ñû|Ù”¼Ìü™7›Ž»•²øéÎcƒsÇCAïŠE:hC-;™§÷Ç-î?N¡°>x‰«L@�¯~n>;NJnêd–æn­¨gˆfz=€ÑÍ‚Á¹ç7òØy$)3߉:¬‚3­—I]ŸP’4ýá ºCW4Å®îï6¶q@f¼.‡"ˆÆ“'³ÐÖPµ4Ç ääÑë:lúxê>—úü6ñ¿mZà·˜À žï*Ô8LÊôX'2<!üuDÝSùjå-Ay4¯¾,q¡øxW×÷Z¦ˆ’80Û¥½PÌ9n<dÆŒH§9´&eHmœ=üŸhïÇeè;­ÒÝØwUPµßÚl<õ„» —÷ÓŽSS}/ª+A>:ÝãZ §l¦±Œm~ê@Ô¸^™>º 4—ÜÅ3'µÄeÇ¢!tž`VÞ)l[0ˆÜ̲0Z`QfƇº«~·Úšùê¬K³ÐáÀÐ~ Mã@Ì¡m®©%ºØ¬¹'9󲛦>íA|[Ågm)¡Ðˆ¢´àò&ÆG\ÀËG£’ûÂYñšþFºÖ»t.$&C£¤¦…dËIm¹®DÖ´©/oÊGmÇ¥¢î+#QÚL`/|êD©XMÅ0ÛñÄ×í–¢(õ%´àÊŒ8Ù˜–W_â…E˜%®5ÃÊ$$.“£¢ËÊP@)ôŸ ÐÖŸlœtèéThÀï-méE¡iò F‘?KrˆéÅrS–ÖO5bdòþ#¥ƒ~{r ¼i…A CQ<Kßµw_½:\ð>žÇ}äíÉSù¥²Nü_ ÑJ'‘¯õfc'Ø(bn‡*?¦ñC'B)Šõ¦ê¸¡Ä>çÆƉÂÚN VoÔž|—ôßR¼Â嵩z¤²>Cრ“óµ›óÚœ6ŒXê-_k¼l›Þù畯@©m_«½‚yºèuRÖ€áè¡WŽÑùP¯ öXf´¿J;×° FÏ*ƒRÁ·Öb?ƒUÆÓ˜§õ|å‘:K¤‡Ó˜3˜Wmÿ Žyê=¬gúðÄÿ!Ž¿!ðø"8pÝê,›ÏJ NþyK)éKc( æAxꃾõŽ[ôXz=¬ÚŽeoÔC8wBÜlÔw/Õ×ç)mYºÒ‚k–vH ßzôà3¸7øæ&½ØŒe¼ØWOoñŽîÜíïM«UqøúO=œ·«£ò°€Ï)ÃmgÜ‹ -+9¯I¶™Ç[üÛÐÁŽh{¬x¢s<I•øFg < GÌ” Š?þH¢Ž,ö4럌EIfÛ¦/M]H]^¯)Ž¤ 1ÃH}pÛœâu ýùÝž¹bü‘_€ðÜÛÛi‘ù‡€?NiEååà N*0â¸p)WÈ~õbŠù¶L²Bö>áÎ^Ö£gçM]÷�”ó_@/„±éæõ Æ$ }ú9¦¢, ßŸì ±ßOÝeÁ©‚¯úô->¸r<-á%ó‘³4dÚ~¢ˆ^žkÑ(9–Û?oy[8o<<Q©¬'bCq–ø§Ìöjz<GX£c{îÃþ‘s껩¿{aá%QáÚ¨XÄ%h>ÀE}:)&´¸ûNaß”ã1qB_kÅJb°yý ؼÞZ鎘dŒþ¥ùƒ:Ö½ÜÐö­„[G'bAI‚2Ë"P-Èe/•n†©üoiã¡7³‰Yhñœ²ß®¼g·A|Âi3Qf‡Æmëäm¼þåz CßÆœÖÓ¶­‚è¤2xUj4r¹Â¦šëÃêêõûõ‡ì_€¤J=ÍÏ$X5˜AoµcŽ®›ÕJR·¦ÊØö‹ªŸª‘KÚ˜|A;✡üÜÇuߣý"̶Šš/¡àyQ¹z„Zâ‡kbù«`ÙÆŽ úÐÑûƒdov”ë')Àh÷§R€«³úʆ\ ¨ukL·OÞÒ¢°, Æ# œ¤Ö­¯ÛKÚ/†K_fêÔÞQDD †_Ò? 7Ý— o<`c™a9ã.mfeºF§VFþ 'ħ¨J-z4ÃÒèz`õF5½Ñ燎Щl‚¼Úªš>jmCéØï�§íßT0<a㹑wßPéºzQp®;E ³Û¹ ’zcÁ¢à%$Y°,f ò÷ô.ù ÿXk#›F "L°{�”}ìÀ§|݉'T:£GMŽ­/÷otúªð�FwII·¤ñ Ié<í!»Äoç�PŒHñÕ¯Î=’,ϼ‚¶b (dÙm|Æ�óî-Íy×®NLJ¬Ú(óˆ¢1³æ::FƵoË9FŠAZa_…Ûî¼›îîó$ò»0éKi­ væÏlT£ZÊøó‹'N:¦äc OzŸfA±¹˜Î%cÝBÏcݽ RçI±•·Ô§úX„#«ŒT¾2é“Ý}»Æ´ÔÒži‡FusÚ´á Ù·“'7Z, _¨ ¢ÙÕ.I�ŸRȈ‚æ®7Y"» ²Þ«‡IwÍÒÐsyƒò9únéÑ™VX7x« ³ˆî+¸ß;Ë=ë.™ÁN3íáV‹®&(7S¦_üèk¥ÇLùÔ ºÏ*ó#Q¢3èN¨†ã™‹Xzª€qòíŸ;± vÏÁR@ #!Àtÿ¨õ4'U¬=`ëw¥ùd‘¾ÀòwX¬ÄÀØÛ›bêÝZ²…‡Á÷Û¾øßV„VaDܺ#d¡t ƒ—FSN8l»Ýþs@“º—”ÁHˆ|3á]ó!“”>ÉN+§â|ˆÎíÀR=k9Ï’2Ñðë¥ÍgОιá…à¶M‡‘#ãÏ¿Ž<ÙºJç(SI¡G•’âZ:ùÅjŸ“Š“+è­ß½mÚ×âÄ«»Ôµ~Ÿ7ËÌ7‡_£‡F° ßJÃ^Æ_¯«´F.ñü R�¢Na°dÝàa:8 à/T`‹åäŽûAò©ðKô• ç‚‹ÙœJ´fLïÊ]Ý)ÛKO!™£ý±Oƒbk¹¨”¢ßáX4-çâö˜p#oBÍ}…Úª‘œúÉ»Rq¨„??µUPN³É{©pav”oçE¹/P©&%¤;ÉF_¡x:.0·b­&Ó ‘ÚÚu!1FüÒMºŠ^ƒ¬©y(ÛÌRÌßmAFVDHB“¾2õéµ÷Ï*¦‡Ì­Ê/¶v‚rѸ£ÓtkÖ¿é”>I¥Búr PkƒÑUá¸:¯¸ÑZŠ¢Ì÷w‡ý؆²í¤¹xCIÅKØLŒK•wÿƒãôÃ^Üï,´Cv¬güÇ©¢mØv}-Õý#ËJÿz)£‚óÀÔ2­«ûš­@­mbºXéýŽ2ùćï¹k1™jMõjGï‘gÒ)´›ã n¾=óÈþÒ²ò½Á ˜Ý¼ÜáT;© Â`vwGZÜù÷Ùô}­ uú(„ÏgñqàØ!]#6¤<SQ6Ì£ â-”í½Ì÷ÑÀ:+3ÞIs„NM~ÔæF#½¼É£¢Þ»y¾Hæ(6ãw]ú¬%£•÷êéœpn¶j \$¹¸€¹w-_œ€›T«}TýÅ“f< C }{Çs°iì½+«‰í5pÒ±;ÆȨ¶žôžcð"¶³ fìVWÜ’¨òö÷Ÿr–Œ* Ù8îKt�¢h dìÚÊ_΢0Î<ýJÔ¬Pé°%pÌ0=¶Wѕபʵ‘±%I˜l¶ ÎÜ-}+f‘ŽsçtžË Uñü”­y¿¿½‘yD´*¸kÇkY}B Õ;nèÁUëÑù955Gå©ýŽ1î£6€†®¤„áb%Gûy·zû<Ñ[S9'£Ô÷‚q†êð„‘á% Ê.³­b5Á¿½1oúpÆÓ´ùîºJîñPž;ôÐnü6'X­ØéTÎê/«ƒ‚_Æÿ$?T�²Ó!£TÝêŠ —þCDçTq2G#±x~X®Ñ«âD³)sVdˆÇÚ#&È$Í`ïê0<•d°yNiŒy&(§ëÚH™9ZŸÜŸ4àé�sC©\þ†˜-|:�|„üXZ{êNÛîпaâF’ŠýTÓS‡Ç&q Œ{¤\õéXþl�Øn¢JÙtÝS%m©ÈhýØ£ßLõ5ªnxçI<åPq^Syõ“?§5ÃGAGïÐÞ¹à•;‡J¦EAcÓæ£ÙËÏ1£ôh3“; ¾ã=ÚýGJ_{Ô³m{Øw< 7# 7°50A#ùÖ>C%Ü@WB¥œ tµ}÷0 !bHIÿ[“ÿgZyb¤\,6[ª-2ë5ÔÚ†jSð‰õl¥Ãš?µïë½üÁµ#«Ð÷ªf׉<(Å5¢Sˆ‡ÆT­ƒo=|¬[ƒ§†ª¬è¨Iìú4þ錩nDáH~VnoYƒIÄzðÜØ)Œ± âåÓ=8­õn Ñ”qã4xO=B…Î,NŸî¬i’i€ÀØ# J+` ´PÓÕ+n°¾×ƒrTznn…dU½ë&dò?wvP¸èÊá=J®d)iÓ{¾wîü;7~z°‰ÔÇÄ”¬¸I”Nž8Š1¸ÕwC'C,ßÝ•¢ç Oï‰+ÈÖ¿y3[ÈoÈŠO¾_Öë`«*vÝTvË8¯‹ x·p0„íT”¾¿ <U«[SÊïG§žWó±¤4IfaÌ&6=僙=b.˜Î”C^\‹óüa„Üï_ÞQÑÌ=¨÷ð o‘}*`9‚0Ûöôý{‹¨¸2i]}a†c3O¸¥Ògwhè+ÌGš™< µ®¦œ ÅÐÕ°Ÿ—¤}:óW½vÙ.}­ÙÊØqÐYÜ(‰•¾øpb¬ØðÏ[šÔ¦AcÔmk›Wx»¡*‹ïçì¿=5_z'zLÐg0XWÜe1“}¥o²¨2¢û*vä™"Ý‚ªÕv_n_e~UÁ‘u;Ò‡·Ú±Žª k#?#Mªˆ`ý"ÄÙ ‹oyI4=ï²þã^ -v zôC'½Îη\õ½WS£Ûdš½Úz“'ÀÁæíÚ†Øõ¬XÐGc[åH¥ô¦¿lx^SÀš'N$D;C(ÀyÃûÇîüÇ1 .3_^Â]T¶M‘·vaÚÄçsýè?i¸tŒÍ©ŽÁh£÷ìíú©ù+ DK;W·0nsÜØ¢9²@5*5„‰†ë/¸*,i�#,qúÌ‘Âb=EÿÐ 8¤ûf °¿<ÈÔ“‘ Û©ù©¢c7{ízb$¾.rwÙÖ€˜ôÇ¿|ˆ'²ÝÊÜ0ÈÄùºÙzi iY࿵½ÎS'À±ò9 ŠvãiÃó²Åæã]3?`°¿ÎÝ}Ãkß²X<‡#·O«cÅ” ýOk€",KsýŠšúÆ’¡HMeʃ$¶?Mì|5€ßÃÓ¢<½Òì=¯á-³n<­Žz¤"Ìw˜g!fÇ^ŒÂ5šbúsa••¶¸AŠí\ù3Â*�Ó¬EÁÇ ùFHÜŸñljÿaGü…–´uØ…uUÝs™,Ž¤?*L-y˜˜¢¥Xž¶n¸ ã&mðüšù–Å  ½§²&Ì}eFXÀÃ$)9^ öÄWÖ¬ÌóÌ]V‹)ºÅr¿ÀòŒÒÅÀ&ª°ø›5jOÇݼFaîEÊïöÌ"²ÃWšÓËFu–ûHFøQléÁö³¨¢BwârÉö%OǤòRoˆ„ÇPq’Úö7”e±Þê/ʽMùt¿IlçN*ö¾uqöZ)aŸnN,âmì*Em¾R ×Êæ4i¯3].4-cH“&´_•¾–>Õ œ`Éwõ+5¢ Nö¥ 8<…¼"wö—<ìj¦‘pðdöÈz<u 0)=áwŠ‡I;Ü ;tCJ'ÿdq£’GiWÜû)bÄÃî‘•Ü„ËÄ7/ž0<êûG9v@×ÖãtÃò2˜-lœ¢J�¯égç>x¯ê F='¡sÌ(çPÙ6ø½Ÿÿ^±Àö{w Yn´Y�ËJuAP4tijû[ç‘_q†‹ÓÖ4“õÔIÑi~½M½}‹@f^î§,YèÏ©@˜“ i·V¦vèã¹.Ó/…gÕ*î—IP}öž$Çþ@ç¡À{0”‹Ô{Ww¿IY.ÔÈà‡öN£ÑÀyNº<7ÔVïGô»”øqMYO<cAV”ú˜Á`<Ú¨“TS‰ÄIcýëé¯?8�Dþx‹–(ãÏooªj’'i'nYŽrûßN*SÏöU ·ßPñüôxÈÛîâ¥p|8œG›ÿ,½Ûs³42×]LÁCAçïøþ”!@$b^bÏ“àXÏãî0«Oûrß³¥Žû%ÜcÀ°‰Z±Øe¦ǵÅ~]—+Š"#œ É‹hY‚’¶½ßÅY>ÕýaDg„ã·d§Uàã òÄÍñrŽEÊLd'ÅÝ0õuk±EõŸ®7P€—· ¼DWš}²=Aogn=”©zmk··/Ó¤]4Q+Væ<Ó¹eÎH3Õ•m|\1‹9^%º%ÅÜË9¦÷ÔÀ²­ÿßÿˆ|º íœGQ>¼«7ÐÆŸ1Ç™'ÙÇ⌇o”t[kPü°‚'2T{¤w’Z%L1Ü.ñ~I¯µ{€!Á‘Öûè{}¢ÉùKÅœÈ 6©JþÇŒWÛyøÖž‚‡Ah™m6"ºlíV«Jå$wË6§~ùã•Î'Já¬ÔÚØÜu³©rf ½ã‰¾s²ÛRJë}DT1è±þ®#J¿åæªq¶¥ý ÃEÕ°«–X é\ GÞ¼O#+§ÚÊ% =øb.„_p.;½8p‚el›"€óC’oT*è›?cˆžg”ݬ"¦8O­*°ÞØ\<o|–’Ûý‰·þä-àf䆿I¬nÆÉ:T¶Ä4É—ß« ¯œìØÓÝ€ŸRGÐ̧«D©;0º8_ :ÐÀ®Ø‚ÆôRQ*ÀÌ OÔGšg鯵²+—H‰a³õd:Ù ÓHLíf9Ï‹Yk^P÷ê€Äc<ºÞòÆ_¿gQøé@AüÍj"3ƒ7M\#næÓéß;¨øxeçøÔŠ¼r‚[áôØ v 5›)È…‡;{$®Çã‰ýSE×î®—E’¦~~ÊÆË ±z¬Àqm‡/,¸  »ËÚ8õdìJñî¢È[|zp™V:‚¬£zø­FЄnÔLÆg†µc¡ò{«ê‰ ppXí¡0|@@I»ÙWef Fõ´¿GS{ßùÝKŽí™oýÉ.¦íTÿñæÅÚ±X‚æÞè=ØðF~|‚÷Ï ×j‘Ë´‰åºÊ ª;£Õ€Z„º4Çe.º›²Ò¾}ÞÁrušÙb0âýƒÂêR& “"kôD½åî¾Üèb†š&snîžh«—)V¢«­eŒ4ªÉãÇ3N‡¸ ó6§zM ÄœtÑW`¿‰8ÿø½PºtûWŬ\V¡ö —ˆòKµGЋƒéÝm ‘°œ�4E4 Y r Ä<V¸ë®V–NsÕ°û. ò­6^ã”l­:¯ºrö¿Ï¯`vÙ ‘û*ƒ¸V ro^Ø£HS}ˆÔKæÑt..SCD/Lãru¨è.ø„*<Þ#¤MÈÀ´Ãa¸íZÓ¤TDH ·ø8F*AzšÓ iÖÎâ LA*lÙ¬Ô`vË—È*¦�¢è@Kæ¸1ç³í8 à”öEN˜e…†"p ‡LŠBñ»j•¬¨Tê-:áwkm;îzì#{áN¯j!(VðH.· cx“›3§öædI•¯NãÊ…4.åâ‘Õ;«ʆ·pžçöXQ”û´$ºãó'#`Ož")Ðmæý~´³(—pc´¡Î¸Õ—Û.Ô?o¹jB6A2…«Ò”Ö½i%ðÆG› ó·]5_^£`Óîž²ÉòxvŒÚTbt ]oºq¸œ©ÖèÆM×wWb¥9<ºm‹yc¤Ÿ¶ÅJþGªv'Û3Ó¾Ê×%×*ºÓ»Ò‚):qU€™"h` f[hÁµÍ}«ZìÿxV0()li¥\भû²aŒFQ¦­¬n-ÁæÅA¶h °‚ P`µ+sÛzCÏÛ>ÓÕcRŸ©H ÛÐQnùm;£à ×óÇn˜ìïΆ�#ý¥ {žö»ëÂ:¼d:oC¦lè_oH~Ó÷2T³ë×;²Õ]ð8¯\OzHA¢c‡=3®áò'˜Y`ý2$IPPj._à4×[ <½pçeö"É€s*Îÿ¤JF…HŠVÕ†Aiafˆß:1¯ßΞ²Ü;Ðy¾uì(fgãI%w·»=%m“)g·µ­7h‹sy{fS¸Ë‡,õÜW²c?%:tšoK^ˆ €+u9LÙý u¨<¼>õ× ûÓB±ÇüÙæ4]ÛÖ'®õ.Ts¶m0né9´õÛê2`×ëõ½_¡öñ1LôLPÀ–ëµæzÜPí&Á?š?V“Wµž­µÖ=‹(¯*Ùpª§Œ£èK\®m¹¡güóf]¸m©eÏ@ÚžHYå…÷$ÊPLÞöp½öš¬sNÏZ•×ì¾J†šdûËd-öý"lt OwžY3ãöæÃÑ ã@CfÃÇŒ}«g“~Šú¥§]‰‰ í©hÒÖøÇ”¹.æ3X‘µ0mǃ©&½K_¯RI—ÒþÄ–-ˆý½ëHwWÊÿm½ëÇ ºÜõ›fQXó$¡`ósÏ?5“J¯ZL"y€uÉ)Þ¯4–™/1‰ˆF‘¦µi¨Ãv›fwתíaSÛc|≆èu±aÝ‘±yC<>DñWzÃqV8˜Àí))\Ož—Ê §s‹¾ŽéÚKM1SOG›õÏPÝúl¼‘y¿û2“m˜«/£"¬9Ò½K³„F·ù/hë„nžÄT}˜‚õŽ¹|Oì1uv n�)ÑR>ú°è©´ÍjGH_—ê`iaÉ�¢yF@Œæ_õt‚rWÝ”ªŒxïê’ŸäWr\$D£¶¡@bÃ� 57!ž>™98C—$Abu›°�ÐÍVYK¿gh›òÓ㦇ÞàH?ñ¦§µ÷GóåÑSÆ ŠÏÄÏŒÝõîRÓç1 ¬![WE²µÅ—KÆ%ÓÊURš¨-Ô½ ªàOy<û¢=crÐr 7[BŸE˸yF §ñƸ`z‚8ÎÞñƒcu¦DU˜JHV¬·we/3_ÔQˆôѳz0EÜ3íêN90Üû—­îßDšõÎo<É•”cjŒégõWËáHmtöz÷ê?Óó‘â„jµ†]í¨°Q$Öìb{krÐ6—Nh”:\¿zèî‰!dV¤6úm P†áÍS-‡îî•Âä¾ïö½ÚT8cGÉ�?ÇM~$…¤EæiK„UÐO”ZæŸV …ãõ¬]0‘bÀò8žDÉõ>tÌi‹g_0B¬íÝ4›Ì¸Ì4‚12ƒÌ{mÜ‹ýZÀ, x ­«KÈÃZš ®… ôÛnEoá_^ǪćѦÌ䢊ìRó U³:Ô^«|yܾZ¨;k°Ô >�¯);²i�ÊYfR*ÎB–ÀšGøš$5Úq¤ °ŽNøôóÓúò@´òX<Ÿ.8þsåSV~ÚÀ6zãíÅË¿v¬4Š�øŠ¨ûRà½(]!R±og—Y«ICÂ�õÝž*Ò´üZ/Òú°AÔZïˆ<à~ɃEð,ç²Ø¶Ýdì7í‡èýÓ³`˜NÃpáãÐÚ;½`“—æ‘ÃɱÊض¦s¦k=Ìýš9)v žÐH¦?RN7}1Ug¦ÃpÜ¢©<)C©Á’$f®ÆúÌ3£«×e“£LŒ²—È>‡¬l¾ke†÷E*‡^5×µ@%üNÚ<*=(˜¨¨ ŽrŸ÷7š gª4%üžÅÒْݸ2 Ž9tA8lôŽð|•Ž)£adÎt3?{&j˜d®4f©ÆT¡ä½ñÀ¤hª8v-CæE"Žæ~÷‰œÌ‹sLÿFü™ÎÖ3•¯O4#¢ñÁôÌFPe¥E„PYú Éû»ðµ$Kž“ÿV“Íì­æ)þ8=YŸB@ù iÀ@r±Óéíe6–9‹µ¾Èö(žb<vÎÙË5+Z¨*ˈ“vPs8È\G3:EÓŠŸÂ@“ïžï;‘8?åíìf ŽMía 8ݤðÌ'½ñRºº¼L½<V$dZ`–òñ¨ÕçÅ»±wªKFyì²4_(–dAÓÒþÍçoj~âi²ñiè~ÿدØêH^q6¦‹"¾JŸù8R•xlU³sËém ”@Ìbñ)ob�’ÔOª§è?yx…°c]0Haæ­*{õY03Rw8XÙõÖ“¼Øà »Lº\¸¿9‹·×Dv= PÉc)ŠÍ”;„]™qB8N!¯s­Qç“W¼±ïÍÏê«V a6\ÖÕžÎeÖ–S ôÁCé¥þó†IäHEðy¢¯ͭᚶGE&xw’"‘v ׶QPtx(S*é¤Ïz� �d«}EÓxºãµSd¾ÌeÓ›> ’qô¢ßxh!¬°)V™×Jásrµ-‚ØÒb 㥠r韤ÐÒׇP¡p¡äJ+¶i(w›7ž<ÐŽ˜:‚k_¯>0ÂvWo¾Q¸:w~‹žPé١õ¥Uú<ðœGæðTôñ 3ÜöWÎä¼\Ä£ ÝÒ£ýlU<Ìu Ò¡ÏMóYð'"³él¯‹IÄQîîÌßw´tÅ‘Ä)£›ì W»†xxU»;{ñÒ°Sû.PÓÙ<XÔ”'‹ ·xß%Áydc\5ˆìgýÍÍ«§{Ç&£~*–ÖJ³:ÅSI¦öÆ}ÉŸ³·jѵ­ÐP R›P°5=¥±³eðÐYeô°õRý¡Ï_áÒ“®µª€­³Ò(X£õ yÎ ¼ õƒi%ÊŒÍÓ¹¥2cØzªþvè°z„0‚ƒx×=ÓÂÇÊá(‚³»m8`ÿåÇZr‡¦ŽX}ÑqÖ[UŽNÌþè9_¡=Ež†„=R aŸ³ëRÒ',Óá¹Pñ ãÀ½·Px2´Êƒ°i­7 ]tFpUjƒQ%xQ° «|'8æ¡ú®ö ó¹Úñ¶(iC,{dæírîY½£Êè¬Ln2G-eç©óÅÞ²oÞ""sBÖ}‹m‰Ûœx#B6xÍÅ6sÞ~Ì(¦ ‹×ßFO¥¿ ¦iFcYð2Î;‹—µIj*@õØ+~_�fY¸P ·<Æ´†·—ÓøH ÖƒÀ©à—±íÅE¯Ððéî$5¥GfñnyÅU•»ãN«Q‡Þ"žj/ÆUæ+É¡[1Б7“GQðx h DëýÙó·)ŒAÊæD·¥ºXm::_Ž§ñÆâÚ!ÿ§Ù—}WS(ÊJ§\ÀÐk¸XW½M#Cuáæ7YÆÝ·$U>ô™´3ŠCW:ÊÖy”­’7¸Í ÅŸ ¢ëÑ»jêbþE¢ uú_RdßÔÃßz§ˆ˜•†Ðç‹õ[QöÓ¥ÿÚÕN»Ñtôxïžw{ 0ƒ‰»ñ0˜ApŸz90ÊÔ¹JKõ©¦m6® Œ H!gG!ß «ØlP¢ŠÎÝõ+î\åb4ßSräÔÖ¹®rŠ„&²àÞõëËø¾ÈRj*3k^íiñUõ·'Û{¬G„¸—ÊYh¯ôÎxÝGQ¦[­Ó2ˆúµG`á%ÊïVô92ÁÉØ^Æ·ùÒ®wý?ÒŸÈÝúŠ ™ Õƒ¯¿fŒPÿº¡¯îMÂ2bÙpÈäJ¹³üÉžŠ�Ÿ)´{ôCÆWdÃò¿¢Pµ¡]ÒŸ½^ö±;Nuó”×rà4É£û4€,P­‡Kž›gÇ;{ÙY|ÔíÍËë’­ËIí™ë}GgÂtñÂSF¬ç¹'câß`nÅ"HúwOÐd˜…ZÔu2ðbV sM[<GÁþ”´“·«úÃW=Ïz<öè(¤òöÑaBøô'ÐZ+?fVãÙ¤ÃÀz*ó®ã¤ÏÌ=p³ýÎø#U „¼¦#—âsöäÓcËom\a/5hc—ùû§¯ Vðgê­ÞwA@€¶&A*¡ûã/ýö‘¶JØzrè=‘öвB�£aáþ+ ø¼ZìqÖeͱ!ÿƒöÜH_ÌùÿÁêÍ´’äâuó®ÔêBFÆŸ®™Ú*V±¯2íÏãnL·JÆ=¯Ô‘e~@ßïx€jFÛxj¨$k˜ø²„Îw²6\‚PzÔ씑ÙC$ßAOò¦V+Yª¤Ñ‘bá`�M÷Í〨1á­Åw=‚@™üàyP6�äÕröþÞ{ÝlH7`ÈL;½ûôjÔéŒ}ø¯´Ò³8^8®TÁ¡HâÛvŠwDgøŸ·þ+ècð÷Ü_áRG™O-‚=¯ƒ¦Šf@Ë[ŸÇƒpyæ,À*ÒR©Íü`?Æm-Ó?œ#)u¥"u#*UùöP*„„Qò¾q[£w '1hx(ìÅêp” ‚ç•'¾Ÿlð šk§d\>ãF;íËŸ¥mMÏB­h›Ìë8¨F-nYå`Õwõ`…©v aƒQN�Î|ìèÞ.{ ïÄÌ8X­tÒ\Žé(/4É]QÎJwW/ú#EVý5€€^8SÎ^Q0ëN ÁwH‡åßGî0©Ïg¦Dy‹ôc«âb¯l¸®ê݇† °J$±ÆZÞÕ™¿È¾ÞDÉF4Éi³@_ Ö¡è9ÕÀIDæVó,+:*@®bbÌH<MÿÅ4ëWC-«ÑC£Úüñò4Óã6SJYïk!ÚÎu«"ö]o-îÀ¡/|û˜È0…x´‡þ¸Ýic´Răۜ¨ýí…UG̼½$ˆÂ!ÆhB·~„Þ7Î"ø qf]ƒÎxê0„Tï«ï‰§‡Ë–¸ÃH§Rr<ZrOÀ0Ñ2ÌsÀtõ<œFªå+½“-AÀSt!„½ŸšmX­ŒŽõ©7Ê´¬¦onÑÝK�®A‹=Ê ë/›qµøfJz§üÓ÷ dÈZPÛJB´}$«Z)cGA­êf‡êne·^dƒæ/^®7‚çj.öÆ3%û÷—~ºI60Ü0¶˜i)t_ÓX8ÃÄé/ cBûµÙx#ÄBVx–rÄálƒŒ¯ÜÝ«ÝSMmÄ~RtBÏ#TU�˜ÿ»©ÞÚús Ñvn Ìæ ¦½�‘?÷;£à©ÐÙYÙÊ‚²KÛ´R6‡ÓS3Ý«ç „æ‡†ò¹Ñ‹�ËN*¾ÑôAVYRñ™Eg\cVkpP2*«‹SKÓ›ª3¢c¯ð)Hpÿa!ž­B¯Ë„5º‹ÿ^|§ôôm ¶Q¤l?´†¶Ïw(+F^Ê\¾ßÐîœ3ÏwŽ‡"ȶ§¼WS…ÓµbQÀraýá ²VËŸ¨\Á3Y UhÛt K&ˆVÝ»'5]VµSÃQFèÏ yæ"pÊ“©`ᶶÊ„ÁÃ4ŽVhëÜ åÿ#CÖcW\‰(†Xâ–¾†Q÷W®…ÂJ`çŒöÐ"ú 2«Ü½üS¸°MeÕ}ÖZ(??Õ < ÅWÀܵkÄüXx!VWöúN !”S­óGÓ’<Uœ1žÉÿËF¿ÿöŒz*Xe~«2d£ë ²uÉWû¾–¡6ŽYà7{ä±1ÇbZ|8O–sŒÖTÏ`\µ¼VZü+ôøÒóRà¡ý4P²V6NR¤_£,ƒ'Žœî1ôŽPÏU¹´ë?„-pœ$®a˜Cç<È¿kÇÊæ †‡ˆ²ºx™ö­Žá4OÆ kµB‹ÓZ¬iÑ%W"u-fr½æ>9ZT½í:¬CÚ?·×OµLn•g (•—oÿ¾%¡B$¯ò:nõjþÙ€#ŽC_ãÖÖi58¶˜$âýr‘FJUÄJXa•Òþ:ꀨKúÍdTPË"£ë4’¯çþ`P”Ÿ‹¬ùXãá葯2­^€!ªƒðž2ÎÒÑ,z‡­¡ñgà«‚"®ZZü¾òlú®U!G9ŠÝ sÀ¬á&U·ÆH3㤘Ðÿm.ÿÒù-ñß$êIåQ,�ÐQ~Yc´{ ÍÄ(1£�¥·Šç<w�©ežyúÿmŸ™ÅCÔï£c½Ϋ„)¨ Þ‹Àôn~ž:J´Œ¡æ‡Yê©KUèãìŽô Ü驇ëì¡…~-¯×·#³íÑM¬[ñ²ì.‚;j‚Ér70t‹ ëÏÑãA5]·Ú²–¯¿²™#eÝ‹R)\û" J4DÜ¡ôX¶¯Y¬î¾ÕØ1ÐÒ¢ÔŸ2°/ÿn ­Šª˜îàp4•n~Šâ¯;¼cf«eÛ£×MÔ³[!µ¯“Ó"÷æ2®ÝmàÞ³½ªÍÌ÷‰$¸ša·aÕ&{q_ ¡*L/ZuVñöäTWgÕ‡óeƒ2l}Ùœ)@µ­}Uo.=“ц@Â^4[" £åÒý:c/–$∡I3{ú­ç U¦ôPÖÏèoø• ‚°ÐebÍŒ#3½ óÑJ{[MËÇâ–Q#Ÿ3Ðl=v€!§•¾AçèÞ¿˜øú^/°&ë(«ÍjlfÆ°w½¿«íŸ»èö¹k ýX ꦣÅ‘›o@?¡#kkM˜*tFk3D€ ,¼kÌ«î3:§W?¸[дf`‚†OU€ßaåïj•7¼y­m‹Õ‰'²õÉ´6DÐTL}|ßù2§³\þHÈ*ìV¶Y;/A+zÂ_ÉÁ&©ß2¡”ºiYJMÉ_]²š³®PŠ‰}}, ’sOª@§øwÏ΋Û^2ò“‰a¯ÁŸº§#s;y30ZIßðuý ì_f dYÉD‚`±I(ä'Ð ­“!w¯ ”ÉÕH%Lï6¯tïvÍuõu\UI¢GHÂÀâ: ’­9 fñÍ[eÑrCáNÂ`cC¹ÎôåO£&•Hqqb ª_X:tWbܦ3‡àúšw.êeÚº|ßGÐìT©HüN0¸½(<E¢ž0Ñ?8vÅ£µ+NŒàÑ”ñqkʧœUMpT4§‚ý”Ý~}YTô1/T†G³RbpK¥HâMu ,vãôÜ®Åéß–¦w�tBþ^{'-}²îZ¡|fö©-¿Ä&¤±—W 3kMYó¸ÎA ‚Á- J–Dì¯.ôêbžj÷§$HÛÚÝV”Œ3ÝuF‹Ãš& 5ªâŠ(´®wc¯mƒß©íY0¶¼PBAüdÐò¶6ž€Õbœð(¡­<ÞJÌ U”ñ%G{²äµôâko$Êf³Üš„R,*P½¸C¨ˆ=Oô›°Ê ü^{¡­e5MnûrÉI‡‰½'”~N0<|ÀÛõt·Ì¯,dÎm„–Ü\Y@²œ/xýW?Î[è(ˆÙÍ_ŠÓ¼Lb»ì€ 2¬×Voƒ£ÄÀi`ÉÔpãæ>€ï/¢ŸÞEêh%’M¦4§'µ’䇨c$Ü#3¿Hmv­FÁI¥A !¨­=ACsø|*e§q³õLyŸ<þ4qòŽxü9åˆ)¦½Ÿž:"ûŒĜñ\Éð#€rUý%\z_‰+©<>ZelÆiyß•€RÁ¥ë¹ÔãsM’ÙmÍÂù{a§¼©g#:ŸÑºi¬>ÁÅM§c•aE¤)œ“[–»‘¾ν=ÆgøHëSwwË?ÉÅÂôÌÇ�+C›ÃN_£=ºF—Ì=¤Q·ŸN)ŽJQ0—¸5;1<è²7©êDoû>°Vé'³h_Æi¬0Åm_Ï3HŸ”AP.ðƒ{žž©‚dŽ ‰µ1 ÊÎ*Œ2ˆ=TŠÔ 9{llGË 8j¤¨à }Á!sjÓÂdÆ*¨8'fbþï[×îO(SŒ¤”®®®xÎaO÷£}+ÆÇÖƒÂc›ÃaîíË]S¿Vgüþ�ì1eS¡-æ¨ÌÚŸvê½:>X~7´£1ÌÇ-ùò½qã©c½áÀ,[µÛ›˜FÕ­›ú`ÖÌkß&ÌPŠ:ô…hj,úyÏ Ð'¤p!K[¨>±êý‰±NÂd«fAÓÍçÎZ­M?ë^=˜Ï*(¬h;UÍi¦[^¢GG ÕÒw’¤›«%.!vy•xH2ë­ª ÈÄñC¹lø ©¥½­FA+ß „dÉGÒÿ3Ôd»£I31P’ÃWú"j½J8O“…Y µKös±ºpíîÛÊÉÜÿ÷öc Á\…Ï�+’ ²#dDþ°opºÛ,¥5ÕØk鉹 ) ÂÖ:“‰Ã†õ€n¼0·õêc¸×ýRjaóPšŠã4ì¾]”ékt7O{ÃijºßØݧ =ˆŠÍôIk+àªËÄõÃ<wpsÁÅ)Ç`§?¼Ðo@Òù2E>²‘l__Œ‚Š,<Q®Ýíg¹ï‚…&òFy=ìb±eÙ؆ûtd® ¶ N¨÷Œ˜ 1Kd åIr£ö¨¶WFÁÛ»kwÏ(=*¶ý`"m1÷.8æ §bE&ì–ŸÙ´öÈ‹p dVùi˪Äý¢ÿb2ÄKÜýÄëÖ1Ìg .mÕ>Øn%Å8$8|ffD‡G7^ŒÛwŒªêj5ŸpÎձǙï3z­rûŒ©)œHÑ ™3¤T™’®Ú"ŠèRò1óú�·´µƒ¹¦Ý;X™ˆsüÇÂØV=}|1©â<³#üŽDú§ ã”Ò Ý(«¹ðà¢üŽs=söŽDAÑJ L}�¬ÊÐ3tFûÒN”Eš{g¤ýÓÊ·„Jɱ÷°Ÿ.‡¿ÖLÿ/lbç!"º£{úø¸‰ì>fØÑÝß±]üÉ1ub=R¢Rµ•ZN ÔÞOýE1÷·˜¿è?ÛµfÏN`sSÀ6í.Ë+k6ë%#  ,hxŒÖc5^$èù³bÃ<Y’-|ú®›¸[QµE‹‰7ú¦n ¾�̦% âÂhåÍ9"Ö.Á‘Õùtþ54ŒêËÐÝ>8º¢<Î<õp4Ê0H­s„jü< 4Už³›xºqÆJ9Ay`ïasYð~ž¬½Œ¸úÊÁ¡‚ß’—©º?D îxQÁž £'c·¢€báfßÙØýÃæ¥~bx”+%ÛQµüC(Š ;¯RX<áÇ´²@ î6q—7þìÜÅ5Þ÷ª,Ä,+ð¿?µyiyÇEæéÊ€ŸÅ?Kœ¹y|DuˆƒØìæõ¡“–u LM‰× å}[` øbg¤Ï«Úé·§cÎJà©Õèxž•— ­ä�–OœÎ=Ëó8Zt#8¹æÜø–Ïnø:¼¼b¶}°ï´×EPò‰\tôŸ<¹²—€íHl©6‹óî;íÜÿþÖĉo»S¼í *ÿÞ­Z%ÎgÆÒ×wVõóþ¥úG[õÀÌÂC<´¯%¸u;�F´—åŠØáóe'ñ¨ÈCÃ<è’ iT³:ãswL,† •º~eÓäTJm ‘n,„.¢:y¤äÂÐßÝz†îxĶnøaEų©ÑÆẈØ110ŸõEÃåŽÛË°¹0fQ}œ~GqLTµ3 CL…ž^5¾W‚ ÒÇ…óyV“þ|ÞìÏ×á$I¼º‘¡Ÿç–k1Úds„­�ð'kE"ºúzK‰·M‰Ó=ÔÓY›ÂÊ efæP�>¡oæÔi8̓ÜܱSÁj›Põb‹ØÖ†Öo| ž˜D õÀ4sm¸Oå)'*(%¨FœNõøEÉêÂñTåÑðm'Uüß[D|J&™tsÁ­9˜ŽÌ­jcUÚ.yâtÈ’ ¦…ß’ó~Ymé )ä‡ÄZ0ç¡ÃJ_ùsöhU¹Õbœ¨."ÏDà"ñæ÷~š7—¹ŸF,s™ñÖÆp2OÛCÏXk‹~Bæ¼®êõ¢í{ÝŽª…­J,²g¹_ qrŸÐÐõÌ¥hCHVø£†FXøNÁ1Ÿ}A8¶ëÖqpĪŠå”o ú`¼yܡ€3•Í9PQÒm ëå2/ ä³ÔG°·1ú„V�¥dPæ0P‰Ä ¾Á6O ŽõáZÕöBIØ»íõTÅRðÀ-´ êá'x q;¬=µV ÎO̧͋ Ý;@•ì¤³>8Öݸ9YÑ{ʹwºÉ¾Âº³›I§S~֮ƞ6V¹Pªrx'½Å¿(ƒîß!þÀ¸§jq<:è¥íЛOMQ“Éžö¢€rˆö—wP˜©µÔ¤a]û¨>:±fžZ[Y†Ñîq|±¢Ío£P¬f5¡¦Ž–d}ñؘ¬*ÀÒ­÷|YËF¦¡/Ì}WŠ>ا‘UlG¨Pê"knæ_uÆ9$¼BôŒŠEDÂôxâŽíd#’uO•bò´›º©…eQy†�VÐÒÌ6*ŠŽÈÇF{æAtckú0/Êþ{MDVï=S5_żLB$Öœw-ªQóò1P$bV´_W§‰+|K6©o2Êß×h ðö­eЂkg `g½Z©J6åElt¥J‡ ÷p"Ê 9jûPÄh$ 1 êL)X²ŠÜ`“ïŸX±ß bÁD tyOjç\7 ÚñÆ›3T£Ý{„0Fè2åK,b5ú…qÌgZ1黾 Ïe´†ŽuǃqûJ_u˜ú»ÇJáÉ’°®�Ï)ÂÁ¦‡ôHΔ£[qÜm}i!oöã¤"[AÆà¾0–hðt˯ò‚Žºæ¹S•GKƒy(¢ÔÇsÒÞ…0@ñ®¬×­h)婇Ðîó‰Qþ [µÝª,UW<£ äXÀq£›©^×ãÎááÒ(ÍÊ×.ʼnEg%—L=|÷ T˜vŸÅÆîõô<γȑöÙæ1 ²É9 šO©.=PZ€²_ÅÔ^+¤,<‹åÔ؇€êÛ£•/Ø„Ä+Óüg«Åìó_¡“ëÜDÅ{„°Á0y‚”MLN!e¨¯·¢?•Géa½}XçÄF‚&2‚è3Õ-âkƒ—ÿ{qòx¶éB–ï)<ÅÖ6=E[ax,jÖåöÒË?Ï8fQ™øýmº!#*Ž¸Si\SÜÑÌž\{›|¢)W:n¸ù…§E…Ú°D}œ<\•0ÁtŽ´oZÙDÏ›è‰×¾e%Õy¤u>jÎ<Cgiüª·þî-Y5o7owjí7§ñ`þe“]¨/: bê«Ìð”j‡u“ÏZ“mê¦ïXçbÁ$rFô�éÔßM‚ca#>ðòŸ>hô:¸|¸ø61òhJ¦ÓáÝöuwœŒ‹ö %CÏ\\7L¦û—{lü¡Bpùµ4A5¢^õæËü–k“§Ñ•Ŧ§g'‡@ uÓF*¾-h–Ý2fɽË;æUví„ÚåpõSlÙö�yR¥t–5bÆE Øh= ºùl`"Žn½Vòµ.ñGs À®©@›O&@àYf`C•†Ío˜üæÅØ"¹±RÂó™ØÊšG°”@‘?o=aÛ£DY8XÊﺡÛò¹¶nNxWÊÐ|bÓËœQQ6Í\›ˆñªT‘÷–)²•ô99ŒÆö&@Y/®ë¾Cæ(Z±tTò4¨f½Ç°ghÇZƒÆ®Ø™gqjð‹ÖÊíÿdz;ˆ„o–c¤•Ò"Õ^pƒBWdÑîs=8UŠ·5ÀÊ´hþÊS<ô¦¼%Ï&NƒüÏÖŠoF½ÅÜK庛Y­WþW·vXzKC‹ ô¯®xÎ`h‡£×‹®ô3ðìÔRÃ]ÞÅE¶à7¢G™Q£Å5ø B!žÞ<àÃÿ? Oüï4i¬ZQf´)L ßgO—‹cU¬=L^vn<@9 ²0²ŒÍnÖ©ü ZAj1¢‘ÿ;Ÿ];)‹ŠÊ Ƹµ í)‹ªÒTo6H ®Lã x€oæÂ"Ç(oX,/ת gý¦v¥ëß©âÅKƒ`±©Î·º­réÓGëΚPHÃï·j÷<XØ€…ð):X礊;˜ÝqÛ©¾ÇOÒ¤"¨+G맒Ï}ÚØŽÖÛ¿oYéÉÀXûÀ©¹xCá{H»Òc²nÓp¤7O§É5sìÝ´ýÅñ2ìëótMs6Ò“==§úô¶9 …÷“gž2¿ R9ueÝÉjw¨Š¥l°¯'§1=t¥Iî3ãEÛšÂ8º§ËyƾvÂJ/Ø59e°ÂhüÂ+/J×mlN™˜ÓQöÑ]^ñIJJ.qd’ÿöEÎO>/„q´s*¯·]+öÂVelKÇ%§ZwlßTv#5Iîj¤·>Ž³BÚ‡S+”tùÓcÛIÿ€ Ù„ ^Ši¯<W#7ƒœðZ<«Ã @9.e§¨fC²\Cdr‘¯ìou¨™¾‹ Þ¢þÒbüÿ£‘yê‡XNª¦>§g}9‹Šù:ò^óð=ÒÆÏ´ŽÇJ”éB 'L‚s´¡85™†”õD‡Ô0K·Ýã?Hu»,Ý´èÄ]ֱëLʆ}Vc; ê/P©j욀—ž†*CmÿßR(ÝZ°Þ÷bcO!š•2'tSJ;³OÀS:{Õ£Gîâ…3KþŠçKÐCø>l?í_‘û0ÞØkÑ£|ä'â;ehl¾Á…j•v±-[‘Z‡6á,ˆÌÁÈÿ�ð·N±ªÖß´~ÒVì LEF^²À©2Z}l%©õ¯áCÄÈ›[Oˆp±Ò!bþAE×»CcT''ÆGj£ìë<xó"Ë/**¿†òhKÙд¶°aXþ|Y‘Ë_›9³Ez²¹eIùäÉÐYs“†ò Ö¸}jÑ=TÎÈ}Iö2Í–nQ-²Uit,(‚Lo˜ûèwxA¾È'?2õü…SËZn2LRœÑAèÍNˆ‰†=‘W2ÜiÞÔd¼ª¦èùÊÿ¸ 'åŒ3£lò³~kT©£ÉšgÉ}Ì“u•Äøò¬öy·^“QÌN¹I¤0ìéÞÓ&ΗM‹„jSZE­mZX`/š>Ñê ç*R†‹p³Íéh8m}`vM[Ÿ ÐF»s»›Q“QmÉBù 9¾úQ<l–…㵦ÓV8c‚÷Eh‰Ð‡úÃã^‰jgý,aŠþSä•'È¢"§µ]ØÑÒȦ«Q Ûqòö´úÀxÙ/ÊëiûH?Øsƒ1íGˆwôÚÄ®@³»�sû{í–±pº){*:$Ùã#2Ç´ŽÞV–¸œÎ§qÏ7× L‚×!¶y±pˆ£`ܤq½k€çƒwÇŠ¶}Gª83ÉÚÀðÕŽôÿk™ ›2ȶV¢7„šY')“ó"ü‹Ž³ƒk ®¥²öÉ ­éá| ß<?&ò3Îwo´oE°êïOÄjü‡•ibtÈ'ʵ¢õW`Ù‚î±’O´Ó×õùC4Ç?ÐZoÛn’†ëãý˜ËžSªVÑ2Óø %<ÛžľÊWõkÑ(qÞ`ƒv$Å…xùÄ"(ñò‰½éËF¼éÓïáŽÒ±‰*ÚŽ&ãgœåßôfrÏüˆ¹ž«5´K­±w MÁÝðŽöÉ$‚ÀŽœx~=#ï§2»£Æ€³uèùžè‚{‘‚]zêðÜ Ýœ ÙŽC«i=wQ£Ùñlu!ÜjiffeÅE´ðmOè“4ˆí¤›pÀ*h'RÍ’&Z¸ÎÂ@5þ줳ïY³X›5«®¿ Îe]ª Ùâp¾,þÅ™yP–ˆåec¶B0öZ=ø¶Qù6XLTQ2ÑI·€‰‚4:-ý¡òlôŸ$Ê®€w�0“=CrË_e‹[´88ãeˆoTÑê&o üïÞëQPû¯™EÙµ'ºÍE–„r¶Ú­æpæ;duZzÓ‡ñÊéÇú®U/½œá„·tÄŒÞC6kDÁjAqBdžGµ0°NXZ&aŠ£<a0ɦ®-bŠ/´ÅýA[r'‘‚èZ+úêJž(R^–:ÜО´ç±;LÐèm\ScèÎʹ¶WèšEe^‹eåtÛ ¤§ ÷´¯Ÿ¿[<±G2côIµòSš1^`–lÕ"@»áLôÞ•7ïÀŒ…… ÷ ˆ÷–¾Ï„سPüꇳ>Éã´ÈL&.zìð$Í›ÁTÝç+ÎòJy‹íÀ}<ôkg¤ó£Ciä5¾9•Ë�ýžìxVD3_•½ã ¤ËÌ葲ãN‡ÆÃÅ×ÓuïÚkõÊ·2†ˆ(U \‘þ]£Û%ÄÒ!ðˆmù>-Ž‘uÓ@'ä0Ú(p6ø¶‰0¿»º«ª[…ž™#å½Ç±à"Ä1žpê²jWоÚØDš×%¬¦ZOŠióˆíüé1~éïs_õp8Ð’‰ìU˜*ò„Y™­vÙø"É=dõl ÒÒ`F$)Ô=ˆdæÉë è­uN.ë`! ¨«þ‰˜rá4¹Ž·µíp‰Ì© œÜu#zƒ*Q,3'¥!{tdÏJ:…UJ&Îz'J¡I͇ãÑâ“^T#+=Ç\VKœ? ØŽäÁi¹ªÛ©ð\#¾èÞ3Dö›+¬È}ˆ²-ûóM'ÏñW-9øžüÎ6×Z>YÿåsÊëÓÞDRyóy·?J·‚Òt°ZžÇ²Hà– ´‚pC´i½q%?RãÖµ:˜üÀÍ%Y;fùš,éÕ¤ L+@Œ”ÕÐô8ñ£Ö¨½çmÿþ«ƒäÁ]Hã}¿-eTP°(e‘Ñ,ˆCÆÅ9�m©baLWèwf³ó ò·}žfžÜyÆ0ȇ£q‹-ÓåMápÝ,µ{Ÿ:f} ”N§Q+ƒ#•Çn5[賂]ªi“öê‰)Õ ósŠoªÉ»¬²ÈÇÈà÷òÃn£íâ ¦dæv1ü?(5qÏCéwc7 ÔkcçóÉ":aÊ„®d­º<²¯˜æªc:ùÌ’È8¯0 Ë ‚监&ù™ëUE™‡ ç§SΞ±…³Ø2ý‹óÎ~ƒû— eEžñ”àÓ©„T)gÈ\Y2äñžQ(Ò"µÙ(ëZûÞŸZ·`ôE|@ ØÀ[í~7è‹QŸ»£ö]¹ñ)ã#ºw*™3ŸÚø°Kàޕ»’Ñó ÐwÅí „‹ «?Íž¬@áꤳT¬ùK@><‰#Ì<ŠÌ‘ì²jJç“ièĈcîJºTÂö¨ï]XàF^&Ö«T¦ðUŠïÝ|;j&Ð/]brE gÝ#x(L£úÝÓ—Ü×çu­é×FÜŠz6<pP�Oµ÷šºoiåšÞåÇ®¥ý¬Ó󅶶i+ãU¾–g©‘ñ +#Y3Õ&GÌXç„öbÝÖûIµ¿ž*Ö„¾13Ûé]óúèÁŸ}Ì©d’*Ý!Û‰“¹b¶hõY£ü  N¹þñÖw°m)=4ùbÔ?eÖû¢-ŒU¢}äǵ7+Rˆ:Ôº·¦Öòéá/|LQ¨†ƒîYÓº4†ÖÛfÝ97fPY›¯^jè•™Wžc¬Œ©À€O,ÏÅŸ Á\zcW¯B ª1âv¼(u"cŒ9h�óÏ?Š2d,Ž$ÿ¼¨‡WÃGœ?5âÇNœ„_ž'Þ½á`€ù yâV€Àœ+•wÂÅ8º›Scn<qî6Ü´µ4½¼9 ÛW‹àˆÓÒÁÜ×:!§?°c ¤^0ñ éà‰ª„7Ó½M ×=â{1Uµçe4nm7Ù´ãg/¦È©ø……AïSJ'×'máÑRê6¬çh†³èX÷?]÷\Þoƒ{&Í¢>XC�zh¬‚{ÛZedÌ[ f]mõø Ö¡ìyrž;ÃLuj1b²˜ÙUÝOÛüÀ»‡IºÂÊý1áÛ Ðä¡Th1³|h«LíµVs¥÷n g©ŠDMűsj¶ÄÐOþê•ÙÎu—'y{(oW£Î Ø5‰R&F|‘ïŒ wÆd+w¯,_9qgO‚ÌqŠ¡¶¨NímOf ñA®¦­8m½ãFv·ž!J“t¡S@ õ 7’bžÅAV¨I Ú“ fRÑùÄÜ?ŒjÁŽA˜úŒúˆÏ7*áþh!_,êM•1ÏTäáʬsùrsR”N±.bé´¦Ag«Ã9l@Ú=ÜécwœÝøO�§+ub¹öݲlHc'Öq;±©(ãÜ®~œ4ÀÐDô4™T‹y:ô»-2!{qýñ£0ó'f‚¿¤EÔ¼{³ÐU×r—*;”Û{ðK~²?¡/ãÄÉ1Xj8çù¾udX£áj^»yÛîF.èW-h“ô¾X‘©^üKô]' bÝÀR?{š >;iÏÞGÃõ+'ÁÓ &)}ÕØœ|¬ÏïÆuœ(L «]/;y2Â=¼¯S%*¨¿|J=±”ˆ'.{h)꽡(7NÎCWš” 0–QkMµÝ<ïʧѴzô„ÇMŒù[c•¬øýá�7£Iâýka8òxݯcâjáè²UJ'ÜV™P89 ÓZûÔÚâ±ÖW-ž(Š]·+᧰Mƒô{Vȵ QÖŠ!š¿õ°eÄYgþ{7âœPCªÜSi}¡ fCêíؽÃ?ÒžgyÕ³Y áÇ£Gâíf[!ýBbÇq?rãÀ0 0½¯­RêE1m _Ïjï:�‹ë{´Û¢*ŠÌºÈÓÒÙœÒ"[{o $SŒÑ10$¬( x›U&Cëk,™"ôËK NOÐæúãIþ¡-!¥¶É¹î(g¥¢õLEÖA.†*Ð#—»ýºr²ÈUÄu…cïKÀ\(Q£]ϱŒ®i<4€¸«§ý§ˆýþ+}Ýq Cê­gHî)ÊV(”ÂõŠ¸f”ù,ThÊl!Iø®÷”ÕΠVr<ÍšG?äϽá%« ­/uZ{r¦IêA÷À¥Hr‰˜?0:)U<‹ÕO=ŠW!¢Yìú5Âëe<Îgï茭ŸÔÍÂB¦£˜ŠréC{—÷¼è¾œÊS!D?[…W°4@qe‚ãÉn2øaÙÊÓ©w†î¹³º kÕÑv€D6Ò*FüE-ªÒ¯7…ÚqIþì9’2˜ˆûbgä" "¶—Obh o¤ÈðçYð‹ :ˆm¤â@1ÚLÎåO¯–² >�\ߘÉ÷»7“i jH&ÃœR 1<ìï²´ª8ôÑ£÷M'-øÁl`l•Q¦/¡Ó¸©G!+®'¼¶àVðâ/%tr16ªã¦Äf\g¬\%”üÌK©Bß)[ªÁ ê‡™ ²S¿§iWU,¸åÍŸ;õºaC*ò¹ôLŠzm †08 X]'nzt>˜Q‹»zÝüÙáÀEQ>Ð>­µ§Aëímáúüø*¥\5Cc¢ZO$À „â+d;%¯?ð$ó‹XPI˜ö£–lÎb÷Q è•‚Qn﹜—Ó% ÊZkk: Þf*[ÙÎåõ0L2»œ¶  JØ^ò¾®gžÿ,�ª.ãõ1P¢j™FØ䛾k·t°ž•1’øálG»B«cYÎ òaÖ-¸‚Ýèa;¼þßÿl€ðœt—÷Gº½ ñ²>  -¼lÑ ý^ñVaIì?F=ºè®1�Ö¼.{È‘‘ßS\HWEÏ­IH!nX”a�*É22-Rî\ÜÔqèEBŽ6�¼ëû75-iª8mâõÀ­4ùè»ÑèŽP¢à$VÑÉêø8»û‰¯ ®¦ePv[Ϥ?|Õ3U³8^߀הcuïw[:.±è®ÎÍ(/¤•º¡Kó ig§K¨¹6ìl%;2/8x˜4ycä“@F—ˆ;I][ë/.ë7?÷(±Eð’à$9¥ðŠ;€ýÁáÛ–-L9èT|-“¬| 7“ÅXO;¶FÙláû–”ÈÅÿ¨œ…nîkî2ÂVÒ*‚Š³¿/úö+Ýóè–Uôü&gÇŽh‹²”;7ãJxA-(rPĽ™I¬:èf5ÄÁ±§T'~W«d°ÙX“Œ÷�œŽ�ÈÍôI<‡©9ôìr"_= Òê]§‚AƒcP´ÔÇÔÜìñ·éHšõJuå¡t #6Ý¢±ëåZÉ€m×°hÅ^ùBÊ=„¤^É mÖ*X4>%ÆÎ Zhå=@ŽÔÙU¦ÝhRN©¾L¢l¦è€²nè&×ým±(Ž~)‚-}ìùè©z²ÿãëÿé&ÐÞ ¸è¶Uþ¬›’‹=ÒíáÛûˆÆÄìªÜ¿IÊ,Ü63uÏÚg³5), ÁǪ¿ÖN“"sî”fýzRá Œxœöó!Kê0ª)t›k9ÙÐÝ)—’i á²ûn“Uϱ˜—*ÐK²"z¢1Eìfmû8Jß´Íø¶ÅÆš§ÞPUbý©ûœžª/Má¬8Ch\V [­'l /8 ¶n›9q·ÙMA=ž†«úÊÂn-rašè<€¾¢ãÑjCÍfGÕŒûƒ”z`úTßý ¶8-` µ�Ú ö}Ïü,;’4#ÛŽÊßÄQº:l æéz=«#€ƒR9–ÃY×ÀîIcká‰ö_Ω—(É pÿ‘U¬åxº4©9ﾡ˜üÀXÕÿWFQ•¾D$cíi‰á›tŸîÁÇtGPaø$ÓGypobÃa°úld¼ýx³ÌãI„:¦Ø“]ìÑ ãÚ¦Îoá(Ïoò7¸û(É|½'ZŸt¦éøÇãÚö×›b‹™(ó@8è¾ú»ëc§ÞÃ1ý(J•N¯ ­bt·ùÐú¿üËQ’8í=¾Í=¬·Šñlÿ´Ûùølú ht ðø>—í°¸Ë†r^8éºPD§aV[Õ”Ôµ)F\êÒefÁ™>lî:ve!¥40ebk¿µýˆ‹ÂQíضdÜçA6n]P|gåKóÁÇÞ·á¸g¡&©é{7-åJëµu¨aêeF”7 Ž{õBb›næ5ÆŽÊêÒ7¥5ÅÞduhšÉÊ¡þÚœ,[xæ2-ÛIa«ÁÕ«¢â+vœx:Ã%c€»ŠÏVkÚÌ>œ†ßz¯îVæâié§ ÀË?Òˆƒ¼C³Ð'ödéžÛ(*®½}EÓ{½sJº†é ¼öCÁÙ怋]mÒÐ<�èf‹6Y« æ‰ÇÝJcÄd»Ò4ö¸³ÿÐâ.ÃÌãÄåÕÿFÁ2’Ùã†Á¯–¾Ö¬8{;Ûf �¹¡rš™óèéyP–•"óU{kŸR©«Õ¹¢þâ uõõ AØÍ›P€‹Ä‘^°*Èx¸Ôýâ<I2¿0cv8h"þä~u¨W[#'º{‚Êÿ¹‡’& oôiSP~¶¾33¥FÝn²Ñí ^Y, MRö{NûÞBˆs!´ÛÀð:À:ÉÂ…L …œ‚B樶rhˆµ§ ªÔ¦=ý¹ÖàT'‘N KÄÀTþ[û…Quò…ç™\GµÝäæa/‘’lɇ[ õ_%„Ï»=fÀ¨ÿD`ÄànéœÚM”§\8I£?> pÞÆå Ú,‹==+ò×ø´m ¨WŽ§ië„iýl_/b}C€òן=×&V™Ä)w™·?Æ|”{l”ª¡k˜¹Ž¡°¹gûá=öèKz\Y.HÒE0u��è€Òؤt^šüªÎmÓ×V²8h:PUºt¦¶J €#á¤3âCí¨4`4qeÛßý ‡‰þ“W¾Ëf0ܾ7 ³:ä¦+¨_fõ¨Äq$çqç÷U‚+C}ô"Έ6e=«Ò—( ôÒ�:¢ÇÁÛ{€îíá F=wám>iÉ�ˆ4Kïch÷Ö¨P‡öFíQÙì$b¥&®FÂMoÒ“’³{ /)Æ÷ÝWw‹ÐÅ“ç''¥_çdXí -nG{ìH´;×KxX ìhæ´TV"½a²Ã$!r©#‹C ¤llΚ›†H¢K“Ó‡3š^÷Ldœœ?€âÍ1…>EdPokAÀ£U~èE ¢÷sÙEÿ£(3_U0 ¶Ç$¨Ö[ û‚³ô¤r’U}dE¸}‡.Àþ(Øζ¦ÅrÚß2Sò+·ÂóPIóÇ”Êhç`ªµ`‰@–üû¬Uëü½¤§Ø¤” Ž*2 °sæÅÈÑØz­7±ÜdBÅñ@aá¤þÞyV/ÝÃV‡ó±¯1õÇgív¾ ˜ôUËÆœ¥ëI5ç“npҩѾæaTm\·[“Ù­W-£ÊôtD „bÌü™\ a¬OãŸnƒY00"XuÇz·l“ñÊ.)ËÚ—Jè£+N*Í=²z<ÛT ékˆ†ÝTk• .¢…ØÃðROfÄYÁ*ä´¶b{M­*}íCôÎ( T“yqåT;:\tÆyÏÎ ßJžJ•Ë›áí.Âbôù?a\´"óºñÚN|.Èü†òÁÉW®Ž}t}›«++Ó£&PO¡õ© ¾$S@«¯ßl„ÙggfúTG%É]KPÜçz\ùQÐbæò›³¡çP0÷PÆöÕG`†#0m裲]¡êkÐY#‚ã†5±ÅØÌÒT~ÐcÊb 'Hמ´ÊÝÈ©fv|JÙG•"^“n«tXš\rÒ ZÁ¨^„^ÿÊ—¼‚½„c Äߥ'yÔür=vº·Ý0ÅLÆÁAc´j^Sß3_“B-cä6ü §«“G¢“ts¬/>QÓêè-Žk“°/êŒþkÖ¨çWºòL‡ðÀ®a¹_Fʲð“Ê@aêç_€ê&Ö XÎyP•°TÂ]£,µ o$åîÊA®l7?+|4 ·1³+ºÙbñ:z¢zŒ.…¡ôÔ·3oéî~h0ûÛ1 ’­¶ç%ô!}$衈‹úe=µÑòGƒ™!ÓM Mzí•$ Úû`w>1Ñó‡KΣÆ?Š8óí h™©)�PÁB¥>õ–îó;¬f»Ñ8w9Vëä­•’óÉrB¶«úÜ{W÷D3ÝÀ©Q(ØÓ‰¾›tªàLß´îk˜—^Éû<IH¢Â™õ*vÚ°Þ]cÖ>&ìýáÒ¾Íõ¥}Î�A™™¿­[ÂyÍâ( 3_则öðI±o¨Ö÷‡iòÕŠš]Ûžz:ü9p–=‹(Ç;I‚n¢_è&’r1H:¿lõî•>¯û7 ²¸,mZ! ¯ø†V š˜˜Nò×Á `ìs醡ZÂÉ ,:±n•1Qf‡v¯õ&U#ƒq„ºüÑ] ð'£ö$T´@jP€ÂUì¾™¶œ“ë¥RŽ|4oú.+Ê “rVÁdÜûTÍ÷ÞL «¡®Í‡ ¯ ßí!0CI¥u3tb nùsôŸ2õ¡¶¢½S0ºÇnv_N{Œãvrsúó§ÛÛ_ÈÎ4¥˜ü¥Åêo²Êé– ™ '®éÖÝÈ…ê—ìE æó„°÷Ãܪòª¨„gì–ù¡ºQßð\«UÛØI™hÛÔ”'™áí©ßKü»×EŒÓxaWÊ(ç½Ó8H;â0X)U¦2ÿ/§*•O–Ó\ve÷î–x×+¢ôW´Î¨ôQg˜Smª .^§yÄ´´óÅšNä漞ú0ŸÓÔ‰|‰]öÓ:0f~èKñ¾Ÿ­`˜…jº‹^Æë/]ò–¥âêÖXh+t-ê“ú<8u„®§ E¿Boa¶ÕQ{¾óÊô ™¿=¡aÞÙ‘3_©�Õ¬ÝþG œK¢ßOÿ/߈1WáøºÊvcîÃ!OSmÒÚñ òW»‡Jô8wCx_Ñ¥ó¼TÀÕ©)Ôn?iQó.Eâ¡)¢åè#±С–C!ll "§¯N„ •ß„x[·jÂô#<1šL6¡bõð¬­}í9Ñ6¢?'öÛú§ÌçÖ‰ùOªâˆWÞݧ#pϬYÔK*ÑrbÁ¹Kp»¼+'b.ØÌŸâ“ïx è,<…¼8y ]µ.)Iƒ¢¨x×- ÛyNñ鬰š•/{ÌÆþÉÕö3å� ¬Žèm­B·£óÿ‰Jé«íBÛ@Çr…îժͭҖzPœAô¢ºvÚ2íàx8_&ó¯¯i‘ž&­ó ùT\ž› Ýk ?Á‰)ýúÇ_“R.Ê­ 5QEçŽV�X×»ÑûËWå³'“³¾ "wý÷Nlý$$gÝUíªNSZú½×ágñ –*³ßBÃö»öF˜Ì+†ÂÒ¤P3اV°jfº3ÒS 4~Úõ´å¾£¾Þ§Ä¤…#55ØvkÅu`_ÿïM ìæ‹•t0œ3ªÀT–Ë`ïé; ؃µ)NKDå„@SÞ,-œ]m΂¥”Ú€;*ojÎTw–ÕPhSÃ'ßãðWFòaèkQÀ®²3$‡ÁIëþ’EW.ªð\vó jÏ÷ãRûѽòþå ÅZL2 “öãVÆeßy¡à£ë¿vÚ €Ì3+Uè뢛›"´X‚X\ æѾ}„ »²�Ý-€4‰œ{“%³¼æ"Vúø¦Ûnú<(>5»áÙƒÙ8,èeQ@²/wÜEJß))„†emï¹àè” Ì4 ~2#Xúd™/*ré@å’uçüyCÉr±ÓR·¥ÝýK'Xᥬ¿ÔC6ÜXMÀœ§"½×;ž·OÍq£2u\ÔëpÜ£“eÝ ¹£tÆ£UÌÆf¬é¨¹‹,Ãrçp’RŽ®Ÿ/OxîÚ³íÚ²1`H¹%¤—f7*É]a°hÚzÂ`XÝÄY@`1>NAÞ²D}¾¨ëu¨Þï¹¥ÈZ_<mt佊´ã1·çу…䎠óæ- /t'Æ[ýGiLÍÎÚÊ0Žójå#Än¶#3Äfqmÿß·®Ý³éÍ/Ðç’KIÍìy$Ùµ{R ˃x»õuÎ`d»¹Ò5¦@öiO–£ÎúÔß:Êh%è”>TFA¨ö4¿Esv6íp[ Þ»ú—ãÝ¿ýe«‰êZã"YTÐ* Òjô<uʯ*@¿6_Á›hÛéÀÓÿ'˜¹áÒ¾T »ïZà ÆBõàôtnëºçžï”2'ºH‚êh«Œudí8ÛZEÏ̯ÝÅÄu’§žÐ+®MYA\ëó±vKþÔõÙðÕõ £d=R8´JÆ)Ù:YáÔÛ ­ñ— ÿåBàŽ>cÛe”sÔ]õPXp·ðõ:”ÇÎ|ô{¢p‰_PS(œ§$È?uc €QÊ;È M<”õµ=&¡?ùÉG UüHÓ`ÜÂPúS[Bt¦œŽúLÉÕáÈÅN€ÀöGÀÜÎìªË‰'WXqU}Sèè[•Vc [ÝÔƒ3ÎÉý4‰]Îß´(S~ܤÿ¯”0póP—¾Ë ´áÝ<(íBå9ø×á*'n€E$ß ú¨Í(y¤Þ›¸{sq4"‰‘#ø¾AóìÞ½Æ Ãxû›#ðL…:húªÝ9…ëQp¸þ±‚²ªú2(šÖ$O�†Áø|*—êÍý¢hÉÇò(N%5']´óXïú·ÏS}qKªXßÆI¿"NZ.äòÀ2úï~e7¶r¼ÛaKÜþCÒgæä#iÌv2¥³Š$°Yeuµ„èf¶þ8qO’ÊÕ] hû"'«ÀÕw×Å@Êliؾ4—·uO?x (3ô•f9üŒlÏíÈÚaˆD—N¼¸óÉ,CA`âŽ>ñ3ŒLê¡Ú¸)s(Ÿ_f,)õPA’ ±‰ã¨Œo1œ'&ÏüÌÌcÜÊ ªí¡³ª[:aåêãÒN<›ß!ßüÌDn9–œ$xåÃ…Ã*Øž¨ŽÿÔÃÝØxOXíªÿ®¥˜ç~¤»Õ´Ø%ç§pQƒ¢Éˆ /Y4øíÅ-ë·*ÝÌ“" ËÑSØF—nw¬+/_·šîʆ‚¯KK÷r ¬0ûãÛÒ+ Ã|V¬Ý5–˜%¸L‡ÒˆH0Q`õGìSmN*0óC§vwÚОòÿ½²YŠýa4;‰b­ãѯš*¾‘5ÿ÷{=^8…šO­ô>SGŒŠ"óXCHŒ©4éTØ,¢ŒÂ|ôǶne’±;N2Á¯›ž½ž€{fÂqhd?Ï­Q‹2ïœK^Ôf°kTWíëuï× 92ªªfôÆMW¯býÁߘ:ø媧J™Æˆ(f ¥¸Vð€6ÀŒ äÍîx&œdq^q¬L‘šR±÷Æ÷Œïý[{¡ä#`ì<ê`’úÿY{³íV•e[ô™õ~º÷eÍÝD Pa#„YÖh÷ÿ¿ãFÈÈLTYsµsÚöÚS– 32Š^0ñêêÕïèŠ*àTœ¿+½ þc¶£Å•cžÉxŠY§öÊ»)ðB 姊��±Nÿ×ÝÑQ9Büÿ«nb”¤¾hŠV(ʬšÊWâ誽ÅT<”¡Û›zŽÂ8 !ÕÓXÉ ÞΫ)BÚž厱ôï•H¥SsŠ(³Èƒì{t©.ª{C‰S£®µc…Ý^ð¨8©˜[ qŒ®¹k݇(áä ©€*C¦ˆÈ¢›úã¹ætÝŒGþû–­| ÉB#„öEÔm‹J‡” < 镼›È×CSÕ*#ipóúr{P–ÙÂ( E;€"ý¬s–áqùDåæ„Þ%>éý®@dUøT·ýE'×îÝë L»¶Ìf€…d,Þ¥d‹z_‹¥j^¨:JÓVÆgÂÕèç¶éz Yu|*ÜSËEV Mâ2È;m­Nó~«j^Tî9'¨âéîaOtÒ±³sWw4CËЕè\#ºo­'<ÐvÜã0{msb¬œâ—íë’^Zx”…’mº4 ²fk›Ä‹%MéFG§µ|קü¹e¹:ñ_åB.ãÊÁ"‘4 ƒ(>šøT96QøNd`ûmÎzåÊ;›Î3mñ-ۯ؋gž¬ŸëAô=ÏtròÜ ¥ÄÓ0 Ë;èL¡?e^g:£«Ö½âÄZXçQ8)nGÖ­T†ÀæÎN˜<€ǯú]³~›•)À–�ÔF“`[ö Ö„Dž5ºÍÂÙ\¨½BºÇ¡ËØ™D9Ý[õeˆ¬çÏal $IgÝs£u_+ô¦I¼Jd çŸj¡ 2w'øÝ4¾½°uÝt"3 ”BÝG! :VâÒ0ë8VkX7 ¹Ém!Y˜ZOiÌÊÑFàÍÉ=üeáòÈ,#²è M»Ùv"±$1 Ôv€\Žf ñK߉,w7‚ý1·v•?X–±šöÅÙÏ•ù}9Nå~tµ œ16àéLcU;ô "± ž1 ù5!6÷Dr±£¢›ŸïÔöí°+:GÿûFqš³Þ„5qÜ×âÌÚPJ_zÄs;zŽx •0é£Bu㊄ͣQ&WBÖ¸æoׯ ¥ÁþÔ©¬Ë:ÌÊÕD'äÑlqt.h˜Xc]{Óo¢bÁV õ¸>RìÚX•fHvt¿xã‹£•$K=õ2V) Ë G¯·q8NÕ~­¢u/D¬eô ÕØÍP°(�»«ZÐ圆¶‡ËС=OÁo[í¡ß,f?–ì™sƒ½¦­Q¡ñ~¾;¾ãƉ†Lݱ˜ñÝq‰i¡õT{¡ýÍ¿ÅbJo.Qâ©k*z;+Yê9N Î%µ´¦£" XŽ‘ÿЫ7̃ßèh;·~«„íGqz.ƒ¢zw^T¹/S^teq!$Q0qG‡mÖé1ñfXNìŽí¶5»á�”xa ¼çÔŒ4õÞ™š9’j­é¤n9çf@Äì ýÔ[£®Ï§Lsäá†yqF×/•„!*¿%Þ6À"NÁ|>¾¡54=IŠxåk(¯ x‘á§ê¡$…ÓךþBk…ÿ™!•sä.,µ`4Ñ-¬'s!³45 JÑùÂI™žµÆÕxÑ)¾î«=†‘xH ÀÂh&³—¡Ã!÷ñ½¹u ¬ßþŒŽYâ9ÃÁŽ²çlÚº— 9xÇÝ è‚Ò‡‘|aÄ]Òìjj\r>uܵ5FaU÷U‰™0(¶ùvï'÷Ð…PŽà–þÄÊ6 R¥iↆj›ôFË„²FöðÖkG® nÑŠ*?ª `W!#þxÌqnEø$úñxþgßÿ³9ñ|ðÎoJjü“S.ÃŽ |â Zæ£E±=í»Æ¹ô\ç‰÷óÅ g‹>˜œ‘arJÞïYÖ3Ö%‡ó.—3‹¯|›hµb7)+)âî,…f¤Ç{“ÔMûnq¡g€¯-ɵé!d¨±¼?|+žäû(E”8U‡SÛ½·Á·´_èN™OL¥¥4Às´5©ž!ô±¥¸Y¹qÝ9@ŒZAäܳJ¼Áß ïZ×IÍge r³Vö³$�» ÛßðӉτֿ\Ö¨‰›Y Ä}î)ú‡Öß*Mƒ+¾¯®¹š€~d£S%îx„±‹c3êò½÷iø†T4(w÷ÄYä%RºM\VBNé»áà­,99±‡A�óþ¹z¹ã¤gu'¹Œ‡4ˆßß=ŸëúùÞGWó CWïø‰¥WòOó†²ÄSeiÑ‚ø­$ŒPq!kã<¶"j&n»êç§SAY[gÍÔ$†tûeíoÕ·W‘ у,‚ÒÑË’'„ÚÒΡyx ’ÔÇ·SLˆ%ï?==FïÜX"W~cÉR£Ç“NÚõ&£BÏ*s‡lEÕQ!m =Xš€4ÆÁö“‘[žÃýßÒvÍ=¢%Ï kíymm²EäÌ…¡\!ifCõêŸVõ€t=Æ;m]g9›²cۥૠSÆ(–ê@ y6¯v‘ÒÂ7K£ÃªžÐÑP}–Bzm³†|­õ{cˆÔë�fqœsðt,aª<â¹÷BO!ª_’[}¬Ô`%â}ÃîˆòÄÆ3%¦g‚råös'o~$ÈsNC;þs¨T$ù‰×‘eÖdFO¡ë)ðYb [‰ ŽË#°7û*o÷P®’…QYNÇm”æÝœocÕÕdƒ9MVþ!W2`×/KþRR»ôè‡ /d2«wmþg¨´ö°ü0OÍÐy¨~>›>ÉývQ,”êéT>SÒú©—ÊÜ%Ýì0h›í¹ò8é‚Ù5Keg´Œ¿i�a椊™ÇopK7öà ÜDkìºo "Aò1&Äy=3s¢±ÒBCQM¯w—ž–u½¦ŽÖw”€„¸'ÿa}jÂÈ$výB÷d{Ué‚“Ì÷ØÀ YøÎsûÄ,L…§<(›‹MGñVðõà~¿ËKg£$·ùÐ2¬¨÷ü¢ZÄÀ€Ã‰Ç´zø°7 "d V1,õɯlfCuQÏ­XmJµGÜUž)ÐV€+9¿¡)΃b¶~+™ºMø?G™ú—ØЬÈS¯.¦û²û†?âl˜…ÝEHQÃxlNëy¢pËj†Ó[}šöŒäs¨àý†2Ü5XnÂ.ºqsÕ‚TŠÁ›¡µx9ûªe{`ŸºÎŒ"Žކοۋ%¦ÐÞwÌR´˜†‡yr—Zy˜Ê‹N¦¹F‰ö7ÀŸœ8>fÉûjúl®9µl’|rM”|4Ø°ý³ÚP¹J=l�C!"ävz€ò¶1ª÷Ä2©Ìºy½çU‘nmŒWÅxIUÔ÷cß™ú~'­I¬t ?Æ7‘,M\ ÉÎ T•¯~«Mºô+¦a-�1{>¤•ÜÞ`ÐϪÕÀ3阣ß9@üìù‡>ÏJú¾HQî„ÜTžv8€´ªYx‰xׯ¢ÓL>CèMRc9hiT›=¬ÇD ‚a)OO¸¾ù“q¦WÊ:›ÃÕߺèÑÝßñPZÅÇõÎü»i9¦Þ‘»Ž_Æ+FALI}§¸0P•(1eT²‘¦ê¿ÚËÛ~2ï·üéÞØ>^ù^˜ÐíÏ ºxê~Æ(Ì© yýLSï<(a:Yγ§Aº£ÿsãÉ!­´^œQ&ît`‘Ó‰2ˆÉ›äjËìWÐT"žŒ¬%•ù·?[—!‹”mo·¬b¾1[Í_*‹Ë”Ÿ“ïωy¥Q(BçbàoIæ¦í^R— “ÐÍ,™G$btÛO%S®À(£´ÑàŒ^T¢ËK×–MY‰n€TYm9Ù±áä¢,�牔\ «½0òòܱeÖ:lÓM÷ˆÏâ`©CôŠ• ø_o¸O«XEþg2¡—Ñ©ˆÅæé"•6³–{¶¯8|D+GŠg¿X†´Ä¦U1a†R¶ù¨ô[ÈÊCìJV8ÓŒ˜ÀHoØÚþ‚Hý´ßôNQ´øÚëW5.”—8vä}šowÓ}Þ¥m·°À…·Ëô^BW]KÍH ¡xèJZþç~R·˜.~PôÓsø;ÇÞ؃'ËÓž©t¶i‰!fÝÈvüâGQ®×)=¥5LV£3Œ=ÕŸ1G¦a«³½÷„Ü•†õ"ò´öD…“¾D;YûÁ•$ű.xm.òáý¤ãöÀ¶M Ò¨ì¶ %€¢9žêŽ§8“ŽûA .Æ#‹ðÜâ‘~óìÚSñŸ6Ú'ÁØÓÙÜœzúÌ %¿”Ö/j¦åWà»rϦ̉=–¸ïÇy$˘£fθO¬¨�Ó_ra’dåŠÛ.Má ^-ªåË­˜(õŸ�l’ «w§A…Ù rï’«Õ^‡g¥‹ ÙåAÅÕ¶-˜½ÜÃLPçFW( ÕH1½·œ¸ÂM1Œ“ÇS†rfKWôÕùS‰½ü¿ Ú•~»ŠŽg¨:%­¶› §Ú‚Ë@ŒÝ„ýr e„î΢äxÖ´YFÍéGñ° òÍÖ ß)› œDŠžêÒäÌ+n$Þ‹„‘¦aŹ*‚UÕzd\»›îÊyx BátÆ¥QmiBCÓÇ15êʾ7fLvá»yw|›-÷ý‚‡^*·èH=ú½*O*蘲<ö½u†–€gæŠ,꺂ûïmâYsFjª2Ê÷gUèUkwì¨ú åt:·éñ„¹©4´–Ž—7_þú2‰�®+ÔÐvLV ,q.¤)Ê^ZlÐòüÜ+ɯN0&òI}‡³€ =q[^4N²`aSR>äÃÎˉ֧y’bY¢Ïk:œqºÀsQ¢ò1ÓjO鯪ûéد9e3ë¸Tð;Þ‹“V¼f°ÈË’OFqU¿c¬%±¯ì´ á¤WÅ i{ oß¼WêÍ™B¶Öû¾ï>˜`ø0ÜåBõƒ6ÐãF™$ù2`Ý«×lÏCO—#ÃÃ!}rª1ÊåHÆŸv½ö‚ê�pÒ®=½B@+$haP·škx:‹€¼¬K• 7§”ýA‹æâ¡êËh)ÿ ÐÝBà»ö/„#Î4—Ð4^ ­,¨T5Íù‰'ž¸sKø¼)CËìV‰[½%²#íË0ZÉ`Ó)xV¹ßPô¹EêTÙF*=ß"ô)Ä:„²Ò;°¢m”ñ»ö¡ÀÉ u!5ªåöÂ�&›cÿÈ ÜS|_›5t=2«Þ‚"ìkúb_)XX®T‡aUê7Y-ôCúú ÊZ~N$"3®¿Š–u5±æÑ8VW„À¼\àÊ ;ÑgùT‡LØ)U ‹ÍÒ–¹qVâ(õቔ³Ì=ó°ÞšeŠ¹m5.5ŽjQÁ”èg/_áe¤~Däò|7Ðó+kÓª§8ÆÀÊPö¡Ò4O* 45™É0ðWa˜«…#FJê^SþŠò•{¾ãŽÖ]tªÌ±‰ åx|íö3¥(¼¦X Ü{SÉ žµ(TÀŒÿ—¾`²€Ó­(DAò]9ælÍð‡j¸”]½Þˆ; Oz¬!ü:mž˜€‘Bÿ}+¸­¾å d'´ge[.Ž~KĬ#kÓ<îk¯ñÇ_Ÿ·çõó›€òo÷óÈ÷ÖÎÙ`/³gä³ ‰ylöÿ¹¤ÂÍ}e‹ž¿’ ÝéáÕUx0§ƒ`¡@R•R � ÎG ÿbzõÓµÔ÷ÊQQ{D Î-ëÉúæò²G „#¢3·çÖ+eÙt’umb×ýßÜ“\I Ï$Z™NÉt†<G_{(xŽ�\€[o[% ÓÇøÁöp쌦›±í0ôšý6ë®b‘7ðÐ,·±¿†IÅ}+UïCܱmC‹’úÅe×'½Æäo• ¢ò׃3¨ÈÑÙ-ù} *¼0w;ðÕO´P²+•©¢§ÖÔž¡i <†%”MÈA.ψ{‰g=#¢g*Tº?¶‹KÝFhw1®/›<Åyæø8¬E¾OžÁº#Cˤ‹¯uÿÞigD6¥ÕîD)ý÷Æ3Åy¶Úwr„wˆÁÒUµò_:d+ ~”Ž9JÃ7£—TÊÄ¢Š†tuaí£ßpN ve\ÒÛ5Õ6eçºIþ"¢'¿;N{…m_ÏàÍw|¶ÖÉ|(Fô{K#†DÉ^U¬¼r<uÓÓ4“É®©:ˆåÌäTïJÛ:ÿï8ï,^pq˜Ëê¢ÐÙÞ„JIèãgVËßP]ÌسëdSë(íç.,Òº4‹l.²ZÊ— ‹IM ã!Ïç°¶ç_óU=‰’„»—"ˆ?[Ou‹Ñ¢ý Ð(ù™‚¯’\î»’ZÉ5ƒ%,¤D)›“3šEHRË{åÉÓB%-ÞyT§T”ñÅïê½û6¯VËPqp?»‹õqhe:f8­V·u(èX pœÔ öVgݸ—¶’)óC›¨ÐS 奸‚îmÁÖ!Š;uBð[›+ï÷æ¼i¿® ºÒ¿-ücÄئò^?8”ŒÃ—õPí{›þØtÉTbTÀ{Ú¢ƒ¯še„ÚîÌNŸt”cíVˆ^åë=ìüŠVÏ­GÂâÆäršêPÏú¾@C‡.O­ãÁ®öÜΨ—ü¯ŠÕÂ'0¦ˆœÉV¹&2=8¡çáT[_×ã )×Ì €à‚y˜k#M"°�÷a,¥Ío¦™™ã AF¢§ŸNݼ1ÆXHÑ PôÇàtŸ‚¾2S„õ1 VŸgÏË‚?(Ïvm6ïÖ xÎ’Š²<JÆZ»†2‡?ÓãÇ>ƒ°â0é€@Âd[ cvm{ÏVÑÇ벓xãZ[ãÕ BˆFû†Å%(s”×ùækäÝ([ùF8ÖñiÆF[+S©8‹‡x‹Ü6^´šYGà}rŽ |]¦·M5¨TºiVINº1&LH1É0Š¶‰Õä¿–uJWÎ6–J¤å…Ù ¾¢ƒ6ÞÎvg¼ËvÂ]™©Z߀y|*503¾öbÃTõz륵¼Ôdé•óTA÷w4©BEÿÉÛc«.ýú4žÜË=žÏ€shëKeÀйðœVˆ`´Çêo RÖIi[`AE¬øwÅ"K}÷æTîE<ª lÌè½S?±ð±tùážÎÖ¶T!ì6è--"Aí ʶ|»Žû—êðé§Jœ»®Eí”ö‚ÙŒ<²0. N䌺vX-lãàÜS(lu사 1Ük‚¢ïòs=_2\rîŸÇŸ'½E9'íçæ¢Rµ÷Ò­'™Wž§žï%%Œ‰5if‰L£¸aCÔ‹Šª^ÏcÅãcGyܸn #ÏϦ毂ãÏ:Fâ™—ûÎÜ- .Ðé¤ËçF]Ä ã iPÇG5ˆ¢,²Ðæû±¥Ìk÷©å¤`£^¾ ?*Šä,°ºL;~Pn ‹üˆj((µ:ÌŽcqÈáΓy ¯.ôX% "îÙD™ø+—íÉ#R:n´£ýÊZ¹0àˆÐ¨çö”Õ„ÛÖóm�rØaM{ö5Fö¦Å)”¶Áù‹’Ž¸×ò d·®S]_Œ79+˜±Åoz>ÉBª„2ž7ÇÍ`5”TznÔ!O…véíÀ9´`Îó(Ï®'ìÝN—¸òÚ<Q:¢¸´Â™ÿ¢M&V…¹gMO?zßxÝ„®:`PëC×ÁêßX³dá®H ™›WñçÖŽƒJd õyô±YÈ/Û fwG"!ò5‰CH(Ò¹5¨â€D(çTÑ¢åÚÂôþ¬?†jÅYr ®€B~dïjÚ‰Íq(!¯Ôpè/aQ˜øB/«ˆ•Ó³/2B=.‹ðªÎOD#ß/æÐ`uÒ7N&ŸÁn¢ˆ‚1ë=ºƒ¦^`Äâ¸td÷f:Ó樴†Œ™î|ÿKºw˜�‰d#èd›à©!hÓJʽðïÖRºû×jóâ/ Œ¬%ß{d\IP˜Ú;>Vƒ&\ýòÑv®dD<Óȃt§ÍyP¬)fÓ©¡f ãîÒ\çKû†J6äͼK„\¯Ôcêý™Nîùd=ȨVúZTaæf·Uw—XäÎ(@¼ø’4(‡o/‰.¸@&ÝlÏnå­n)8…©J‚s|»½rv à–ˆYñB=Ÿªþƒ©ç/èŠ{);E¬éödýÎe[˜ÜŽ5ô8äØ°ŽÎzâ©…•góáZ-Aصºt(äƒÕÊÍÇ‘É4ôZ»àvJÿg8CSeA^]< öLß ÍKI™ëö›BGž;×÷èfÉ"ƒi#ô:,üuÅ€³}ï¸:jÌÆO-ôi­bgX]¢,`ÆàëúªËGý †C¸¯ŒÓ¸¥Õ‚þIèÔoî`3žº»žµë'9—ä«ñ®FM»SA)ßì'q+Ÿ5'¦ÿ…yOèiWÆœÞ4yPôêû |/öôÆÉô:6�jól_Ñ â!è±ÅÔÓ³„XoÙ¹]àÄG&ÚþƒVAÇLP®\ßöSU­ÍξGW 9#+aì,H{« »ÊçjJíŽËñØÏÒضñ¼2¶vu¤£íÉãÓÏôMŒ¾:Û5™îÅR(]-)a=™•6Ž2a­ZUf¯üʵc&…öËxuC‡hØ;›ïcõÁaÛMÐ9<E«4Žµªg™i ¨ÌÆ›Ã|ôm-ºÌ }*'‹¦Ü¹º¥PB3ûš‹ˆi Çº­‡O 9ØÙ–‰"ƒéÛ½¡Û«½ð‚5DtÑ¡OYÎ9¦Í»ãaP¥_÷èÃ|å“é<@c´ø¬<øö®¥t‚R]üF§<ŒC<E0]CZ˜ŠAâ œÛü]›=$‘ëŸ3 ¶"ˆªÞKÝP Ü›¡‰ÀóÚYµ�üõ771Ú�dˆŸÐ³,‚d<qS¤U*O¥Ô»»+Í›´8ëw‰Â#ø±¡íq;ÛNoèΛ¿Òw̲ÕÂÛQ’˜_*Á ›IgæzOüžÊ¢…%±:%Kï�KúÔ©Y×VÒ^ °º\c^øý]»¥ÊÕ$Bçý¡>Zñ°ëû®X.É©MS¿q.9ó¥Ùì;e°5g:bÖ}z”Η—x¦…“RUÖ;ÐûÏžJ}RóõeŠHrÿ Œyü¿xæRbƈ•°ž›—ÂqôÂÛj£X¬g ¬Ð ^çÚt4®6ïÓT‚Ùןª±'Þ@M0YŒÁ ­“2›Ka©R¹/`oB«UŸ3µó˜Š¡ö<W·—a2­ AøŠ¬Š»<W­¢,¯1¡«(uÇ…i~†ã)]nÛž{Ú Ã$ôn+½ßp¤wª>­pkghÝqÑ÷â¨;RËÝKO™¯4ÆfëxbÕ·3!§³¹… ^Se�–\yÅG+-rm8©“cÊb¬Nƒؘ]ÕH>3 ãq6ÑšRbÜ{xYØ«{ܺÜɸX/M›°û¬ñŠäÅáøˆœ=YY19T3¾Wú¼áXŸ–µP””neŽV*†¦‹·…$ëã„•ßwNÒ…ìnè ˆÉÀòiÕÆôGs•fÃÐVþk8¡ûÑC!ŒŠt9§8và U*¯O o\ïXýáÃf ÒM ˆg–ð?%ø®«Ûý‘¤>{œºÓXï-Îs]±hïJjéÒ¸B"O}&�fÈtleóè„ïT§!=Q®<}pÜ­¶ Wó³kÐÒêL, Àz–0ís¸x@U# úHÔͨ•Q5nzËɺו™ú }½£î+ˆGŠU–Ì% ILi¯ ‚Æ‘*»�ÞŒÇK7 þ2º¸HžS0·é@L>{ žQš“)z5AÖ­ ìÕb¡{ˆàƒšóà×¾?Ibüû$Hà'«šsxª¥×í}›¦G4 ó… _,žÑY¥mGx52wqç7ÃLXüõ'×è<Mýù*EMZêC£ƒ-K!ÃÚOÁá‚yÒ<ÿ°ÐC š|t ,3 äF9ˆ8Ê«MU ¬y‘aÌm6ñlS®Èúê½Îa±Ä<C4p<Š;=.Êá‘©£ Œ‚õèyŒrÇÁ^𠳕;¿a’óÊJØI±¥$³ŒÛ„å±Y’[‚U µu×ÜET_¼æpTøºˆWg;{`®g¨£Í“ã$%­ÿrMÐãEÄŽCXÒažvjÖ.íéåñbÞB9"äî_Àßûª­9K[¥A4êÁ̇ ÷˜y°AËO„ºyš=ê#Æ+h}›ƒ@n1 *7”h)Oò—¤Ì}Ý(M}ÝeŠÛóD$¶¢£aæéKú˜sT¹Þq[É3GÏ ñ'h}£ËýíTxv¢ £xj¬±i¸¹X•D«…WŒ IÄV¹8„<ÖöØ8˃W ½ºÎž¾QÌ~ÁIíË:w8Åà­fæú¯™{Ü¡XK:×Xɼ•7G²â_'tQä:Âk AW%«Î¾'ô¶b‰PÝ/,î÷?µL­Òjd4açsä;KÚÁF¯†½fÅ°0–ïç®v´c¥|gÀ‘_uù RsD×]SžìÉÞ yoÄê[ñ§0gˆ…é”!,MZßu)p­Ž - tˆSN†FÕWm·«è›÷\IöE0Šôgº)Mc_COšC�k ¤i¢ ØYAª80ÈË¿ÒÕyXeÑ|Àí~S°ø~÷Ðîr”0ùJu…~Ö/¢¸Ý87Y¶*< Ѥ5nw_uvéRf ‡.ò7T­‡‚p`i©REvª<#ƒJ¹Iﺅ ÇØn÷S�=Œ«¨/¥ºé£ö€üïÜì…Â!Öïx®öÖèäørã ;±³íæÛ›.ÚþϾպ÷E…î¢ô+½0ÚÌ‹Âbµˆ-§·Ö|$Ú‹÷%ñÊüJ‚rèè<ïÏ^_ê$3N¥ªP: 0þ̶äÙNq.c—Ocõ{Oò(Ë®ë7d†«H³ýû¶¢‡m!ö´” yúSZ†™ÅUH™‰ÛøóÓ´]Aü«ú¯ÄìШ¸¿¢qk‰Â, ññA?í}¶ÈG@µÈ4ý¨“˜âpûH ¼Ë\§+ñúQ)ߎyPZí¦ï¾ÐoÝÃBéø#¤ÒæÉ©Ñ1¤}· Šîâa­…ææÑŒ;¶‡=”àCÀ`Ù‰\(8ÚMÄUQ¨:ȵ ¤*·g©‰ÇÒ¨‘çe)Jð3Œ[Ÿ« ©eg éæ»täôÊ úy§à0˜ d[laùt‡Š–©C+± çá(+p+ÍB=Èl5Ïò„{®w?ZH =ýÉ ãœET„B#7€´�ÏXÔ.°êÖæMx_݉Õ Ä"‘vO(ÍMSãÖXÓ_‹,!d·”F•dþm-|å2¨°R þ©FeFT”Ÿý÷-Ž•Q¶¡oÈÀ/ùBí´"7â™!3eAºÓ~•qÀS4Œ(N¼ª¸›.hUGŠ©q@FÒªC,Zηà,wïjå²Â$\c1ð>uržxœÆ/‹/~.®æ©ßêåLŽ’¡öÓÃv²:ÀÙBlâö8ƒK §k+7ÛQ¡C±fKœ¯ý©…‚)€šýjÆŠ14Þž2odVFȦvÌ.T­ ú>ü£öüàF{JÂŒa3·bÜzv®ÍñÄ{ÒÒîjþ®<7ÑÓü€òœ-˜`Cײbºdhc¢i#gù¯BÂÒú…–5øxi¥îU¨ü@Dj¢80™¸»ÿå_±ôÒ ÷Ü9(î&ÛÞ•†8mèÆÍj}¤è)ê`h•Õ³Ý7}'ÛèDŽ­ ¦·šÀëöW©p”xÂÉ…`Ô)ËÞÍ^ŽBÇm+N«<´5h¹—AsyîAÿ¸PØa¬ØNÞ Ä<K®€¹ýFx¦oÛ=:ã׬ó[zê=}ƒ«L¨ÒµÂð\üC§\T|.•á.ï'™d~Ñ+û.Ð ½Q¬é´Œ«þãàë­ÑG«ÇãñÃ3_xà—zh0LŒhfÞÜN­%Ï8½–†2_‚åºTŸ€&ö–SÛó†çZ×3Ô€ê0z@¶F•áìÅcºI;÷6›ºD”ík· ¼ñ‚�á~DóäQ¬\oÌ^Û^Ca`Òd;‚¿Áõ:q„ÂŒ){ÊþÓñårW³tVT.&¢¿m^PüjÑí^2I=QáÚz2e4óÀÊG[»yà‹SÀÄ°®$…ÒWã-úaÜXÎÌ Þ´µfßøñŸ¹U7[ Ç;n#dï¶Åm’jUx<û¶‘™÷Ì‚Yì~Á0§)šDãÑ?ð}uŒœmºQY×¹jŸ»F;TH´n*¤ÆåfâEF·oöPgPdV‚�ûNBy¨9vNh<ž¹“Á…:˵÷Œ8=%Q>ƒªv[O/Ô¨škõKûjØÇó(Ôû³ë¯ Íz—€õá²!Ð>ºöKð‘Ús¦½kæ ÞåÝÉz–.ȶ¬èÃO– ™ ʽaÄÒ£¡íÑz³¯¿3óÜQ·yŸ‹ØÝ4zâ›kºóLf5AïE•;ëÔËÞH€’B'¶Š^1 2ÏCü·Ò8¶Ù­L1¸þÍ}§Š ¨ÛÀ šø°Oü‰t-ØGp,þÊ‚ÐoEjò,K1ÿBïâ.n–¤Åe‡†X º|·õ:À¨$ä#šiéµGÝOrÏ™‡‹gìÚ¸¥œmÝØ}ñ‰kXÒ©.Økcüü2r‡]OÅmšJgŸ’&ŒUܶ»#2k0ýƒÛ†ƒøp{¼Îâ š¬X$ðkÃÙ:[lzs¨á{WøåE¸,ë#Õ­‘,aO Ú íµØû+Vá¬e#C{кªè]'¡.Jì¦÷Þx�hJ{Ö)q" !;ì*7Xcºû³Y¦:¸«¦¡}•æ±Q{0÷ÄÒ =)š_I°Ç„D³¯Y¿Ìë/>h‰Å+ŸWXPÏvUzvÄÜŽîñÙœ–U7zYzÌK—þü d *ª—Âìñ œû¾}£'ËÀŒ‡³hï¥^ì«“°b(½Ù¹vš2†ƒ«3¸‚>ü·ç„Ö–x[\>T}óa<Vþ˜£ {W Ð8—VØ;$œ×yyîi`æìZDq)ûVRw¼Rž¥1‹åÅ®çBSz‹iB `µx¡s ‚c:7ÔnñÃÏrQ¢mRã0?ÆÑNÇ_åÊtËñˆµC3ÎSW5ío'Úe˜.»]—‡ì÷l›Ž‡ =µ­“K/cªÖ».ÿ0®ÁVÇé[õtK¬»ù÷”£ÔÕšTŸ§<ˆOª�‘«d‹W‚@]É àìU·_ït¢ºdÔ„IšzPM–‘†g²íD¡ÛK¹‰û/ëãáÀãdó OLš%^Ïx Õ—p<üc4ÍW^ZŒhç´¾gvËzžÝqÏXÞ6jÿnûßí(-g#à+ؤ\$gL,î!JÖ×"h¯Lb8Í¡¥Ð`ó˜ô'Ϙ[¡s­¨e§-2� ³fמËì 7Ö)0¥JÍðÚýººÜ:ÜÙ1¡H}ÂÔ ì߬kÇŽ˜@Œa6õóù³ó±Ö‘[z¶cŠ<i¤£G¥jª{€¹Ó×W43ü\qS³Åo»^Ñì–êÿgwÇÁ¾Â¢»ê|ÏÎÇâ%¢NgJþùéë®çÓdY%ô <bû‰nO·ðxN%FQ²Œ…Hê“'ò\!¯¨ÇÊÖR›ý´{Ùëæþs×Ô(_(�Ñrù˜Ó ìvžž1årb€ëÑÅ¢÷â‘g©O«öb¢óÛ³”í_Õ�bûÊJ¼ìü“F¶Ù,}þË‘þF2éNhŠ‰L|ãýNï¡ã°Noµ"Dî«›ìVŽ+õM™‡3¢ÿ_ 6I‡… ¢LUw¢Dwš¤å±øP KW®˜+߀­‚ #ýhÔ#)”0bAÚþ¬ÌWxuaâ7zÙʵ¤lTkGx&Q µïýoN_çZ%"!±¹_“g¦»©NÝG¯…ê_ܯ(\]»¾  rëºúJ¶0¡ËPãÇjjM¯é l˜¤>�®{qäÃÅ:L%@g³§˜e`*¢½ýÒPÉXCƒSF)WÖD ‡`ÝV­óŠmŒ¯çE¥-møTÂÜçÓzµd_9^ç=‹Âa«s·Õ¼Ü ¦Wæm”Ö"c!.ÔrtÓ ¦+Y Ôó‰†SœŽL©^u”lõWkÊË_²1 ¶Ç®áÚ¡š‚ÅcÄÈfþ9ɶ6뜂 GìÏPmV\]h'ytæmn<¿Öp‹ºs³ldÞ0Ý«y"jÐó™Äöx¦°&_ÆI_‚®Sõo2„ý€Ú! ]w¢ìö„¼gš‹`Ÿf]5žÊ¾€ð ¥’ÐVtƒöà ºAÏLL¬{çMÐ!­:™f\"¾Y°i’CÖx^þ’k§©?ƒ@[e¤l¡V:JÕ™‰F.€¬vÆC¹~á'lX#lÑtFÇö§‰^Œì©QÒ»~]€0’|å)˜@‹§Ïƒ¼jµ²-”[Ó½ çøL?d|O1^–õÀ­V×%{¥OÚñ¦cöƒ¨ÓˤµÃµ«½¸ËkJ ·­y8P×i°rÃa MºýŸ Ôý*Õz­§Šw¹»ô g&KåÁ8L½’²ŒH‹ÏÙCïìö67ÖIåõ4tùãØ6fqëyð4èû’’ñÆóŽÃ´l²*ÀŒf¨†þ0ËDà¦Ïðà×+OÆ17.sÝ)ñŽ½ˆµ;hÙ§ÑÍeïêP‡Å‚ 8µ,ß;OßLàÙælØØÜà®Oä³*#Îœƒ‹Þ­!kîcÐ äÚÞvW½Ë$ q•òZ:xò êÎjD„&ϱf¹d«žò[]†<õûjf8„wè,ŽNQzÖ,Û$R ó3Œg Ú+-zTlE ‘}_Qà‚¬râRu.êê›*Ûë|£Ç†˜T°³6A"¶°¹$ß8{WwøK*äªê4H; Ìi¿ƒ¾à™ØŠùAé¯r'¯3¤ªÇdl§Ò`‰á€ì<¶}8³Ií•a}ðSV[–¸‰ëµ0ú5Ûu^-»€ÍUw™~À¾ª"†¶JC|bï¿[ Ÿ«}©$7üñ.¤žÒ)´è„lY5&!³Ó·ÄíJŸ3KËÔ!hØš¢¥¯œtJé-¼Ät‹kLùó|Êúâ‰Ì |ë*JÓ`SìÌ-áEO)º¡ø[»§Ö%Ð0t †‘ÍÂ*¥CG€ †} [Ç]¿ÞZÉEÉB"‘WHò—Q%ÂþìpkÏ“V’ÜJ?5ý‘B|¾˜¡œW^IK7H-7z($¼ÆÞ¶íU‡d­Â—~ù_‚ÆEØû—jÖì Ê6=­‘ðÝkÈV£[ž>™ãfñóúDH”jþE÷¦.)[šu¬ÅÇvGEfF²ÂéØÏÅÛ‹[ÏÈ)ª Z³¦eYt³5ÙÍDÑMøÛf[‹²ïkÅO-ÚCå£ôP>Un 3³Í¡®9Ï>ÃYÀ&vgfÒ¾Þ@‡¨ž=c`�,[ ä›ÍÍë•ŸºzTéÛ’wCÙ=Ç]?i“íåF†5ø)G�¡†<XU:ƒžv|#ßÀ%„žÎŘÇâØÌ­ººëûäþpeVctÞÜÓÎ)>k'úϺnÂ~£ËÅ¥¾*ïضjE€3 Öç2È·•WcP]ÝÏ­Ç9V»?suÿâf©‰1[ê&�`ÞÏ™ó :k×þX$Ùw¸J Ä z݃ªÀ¥¾Ò8}ÙØ¿’ê6âA ÍŸó:ªƒ´ß81Ç;P]Ôí(j=*#u°ráüI9ìNáXø?Z»\ÔžÝ|œ¶3îcÕa²âÎEæäqVŒ6al5˜((STnãC ŠÁ²²á+Þ½ "ø.¤ oÇÛ>Š„8´tJ$[ ‹¤ŒÁNjnÅ=Fƒâ;n…§éCÅ>'‹žw×'A8^ܸÏÚÒ(¢fÚy ¾Ú~ÈzØË^~RKÉ&DBòmí•13…ZWÁøɼ<‹ºm\¸øÁÓ8±ö¿/FÍi!Bâþ 5î—3Å,.Sg$æý. ’Ïw¯¢`Q¶¶Ûp|Ù÷Ì bd­Œ¼ 2ÉËä™|há�øø.°¤åkûÚž=ÅÁNþc+êT«Ð&h¿ãŒSQyèöwm%*dÖƒîAtŠäi˜Là\Š —«dÚ¨‰§»­r¢Úqöy/¶öˆ™poU< Šc”½5•.*Ÿzt–ÄB¶ì匤g ÆË<ùsÁHL‡ŒŽkA^¨—°³T2Ë£~_¶ò×;-àûò®ñ¨ƒóx™N"\ÍþÖ÷ä§2 ¹L_?mÎ^* ß^‡é ª_kÝGIä´[˜oÁ_¦µàoãY{!ÐòÃÃýÕ—(â°XÅ0ráTÀÍá Èiés¿tàd™à ~¤S²<ýñ¼Bìˆî8q‘¨¯‹=ŠSÏ §~Å•HŠJI§¾Û_O*KÏ)’%ÚaÄ“L[Í»KŒÚòóÄ~s­o®sÿÒiZFWv‚›KAGñÉ!himo=ƒ—�œqN'Þ0‚Ÿè?è�5¸ï—!½´(q*«­w|±(tå:’Œ6ÿêý¸÷ ä8!NVPŸÐeHûÙ¥)7æòGX^‹»ö¼ŸîSò¢e# –ô F½1)ÀXó;%ñ¿æ÷«tbSOë/ÙØÒ8èƒxê˜Ýú@íÔS=ÓÕN¼ÛBË_‘·(ÆàeŒé–ÚP E‘‡îéÕ­*ôÌ%8ôDÑ,qïWAi݇£ÌÚ‰Osu×Å) íí =ºµrçó êÏèj®¾¤uÔ3öV”Ôåxºßq¼†:-ìYÐ\è«$'¿w2쇽Ré?ö€€™âê§ó…3ÓK¸IçJO¯»D7¥£„89'sH%ø<O"D-è‰;B4$iò,ÑJáÅÊÖ&gªñ;=)aã<Qv‡ú;»©—&A^®t×äÉ‹Y\1ÈÅl XÉ¢s1 ÓŠ…Ù<Í„Ú¢xµ8ov1-…Ö“Òß´" ŽÍ6 ÙSt›œ’7“KpbeEê)]Ò‰0A´Ýnöà@g3E Óyyn‰ÐTÛ= •`lA˜;’&ã»®^K*rä+'JŠ‘YZ›[À—I¡é;çvÑ€…Á©Žm&ý¤Èy„'']ŒnÚFÛÿr (–&¤ˆ<Ù§s–‹æ'ŸL†Œ‚ÖöSk†GÿYIg1æÀ-³ÉÙaæ n¤seÐRMIHJb@Hù œªÙ¸Pz$BäÝ£{;ÑéáÓ“@¹nVMþRŠ±‚ŒSã(»þ¢l«è{ ¨­ Ú å±þ‚½èO=}jƒ¯³¿½Faaê÷§hÌEM<U  äªé³žºa÷·bÓ¡õãʃàæ’EkY×óÁ�ááßýÓµÿH’ {=óæê)j¨ðÍÓZä]m¢ñk— ñ ƒ‡<rëØ’ºO4D¯¹?ÎF¸ÔfÜZg¤Èó%Þoé6Ì•e¶Ýé�ÑÝzµyy2Æ ËØŽÐñxá7›qûéäÃÄñ°›¥£§UwíÕ<ëÃa50: Smœ˜´ª?­Óÿñ%mŸ)ÛÆ+o€Vˆ˜}duçñHØÕ¤WKRÞ•j}fÜø¬’yO‡lÒ©'v–W<h’èÝŠÓLß0EÝø>—VzØæäŒ#>vhÓŸšæÒ{môû upÊ|Þ¥C OT+eÅ9«Ó"2%¥©u‹F³yÝ@¯¨on•Ž¬�›˜§QÒTSùZvƒŸc�Çðù#!{µ‡9 '¾á(¢w+ÁË€¡©¾ö ^$%{©|p`ñÔ@Y::ñV[pŠP°¨´š=w\¤»}¿†ã¸ÄÀ£ÑºI3Ò,JR+§D!‰Â9„6kÅêó´�b¦©ñŸÚãǪžPÿNG YXƒþ׃‰Pé®B¿Š׉±üÆH lúèŽåêݳ¥ÀEtEHfeÒÒŠ¿°•GW‰nÑ/tI“Â5%e8sn`æ¨ðD0w`äáÎŒ`¤;„c\îÿSžJ[µ11¶î)© w½GÎ÷ƒ×!üŸ ÅŽ‡/-+$œñ¤R¦ehŠ%ß&œæ78°”ijeµ–=tïê�°oOg¨š=¶†ˆçUL Yw{([úòu-è¸[{Ê8w†ÓÙaé_ÃIÊ4£"$ +åHµ$ï}õ¦yá-`e[ÁÆe§9-øž¬1¬çî;=¨ ­ùñ€ætë_ª6Ûòg“ì{>E°WA6÷Å“²¤nßz‚l×þö HËÌéõ±\ѹ¢Ïß̞Ȓ¤ó<Êv†W?B#½{öBôLgõø;Ó¤Q‹f}_¿f(oj,fsu¥àÀÊÆ¡*É0-bh›1øÝM·ÛMTœ ÇœÑa6êfιµtm8x1ÿþŽi}kîC¶;ÑgO;íO$UA¥ÌЪ%ì£ßxä׋Ë�ÿé°î„þ‚ëJ<üX¢¨ÈSÇP˃~¤“v¬]+¤ý®Ú¶¢¯ŽNßô•u”CÛž^¨öWÍÇR¡þe9K×]Ä{ÝÄ´ôg «’óðÜ’ËÙ=ª‡¬†˜ÿõ—A,œÿ6 ÷z¡¢ÅFé •Cíº—h+¹¯—¸húR„>LòþÝ‹ÕœcxdWYi¾P9¢3¦O¹J“\Jxz]óàŸ™É…NXÍæE•Ÿ´aå:qìªæ‚žê«}¬ðum`ÿ@©O¶�Zñ kðËú#öŒzXn<hÁWí<”ë¦Ù[AÑejû¬N°¡7Wû¥zë¼ÖZywüÚOŒÖBIxê-ŒèP­×:=þÁW +Ô2›=Aa74eA¹ý£F ±IKD¼ÒFⱺˆpèÐœü[´Ù*t¤ Ưo.i´;¯¯vüö;žõú°È)·¹STFþX=efu åqûYA ˜¸C ›�|23×…nýE_VË•·bÜ7}ÌÌqN¡3SSfw\Ⱦ RŠ£Ô'àro( ¢­–ñhtìÇ·wŠFÃÎà,€·¡ÍÃyäk:Ý©Oú—Ìo:‡ßAQµn¾Êû§ ¤õ €¢_t“`„þÄ<Åæ-9‰ %˜ßµWòê*1åI³öaÙ<Ž{c´ñï-áò¬´µ3T™™žWÖ‡ŽÙ Š6ÜüÌK(=à4K;4-¨Õnãá¼ýY{¡rí_Ò˜}ŒJ²0–£ˆžâ»ñĦ˺≭Ԍ¿‘à±¼£Â€A˜+;ÑFòBïC{s_‰?¸mïïõj¥ìA[Ž²ÿ7Éçû{›e;ï«Èd{»!¶Ç‡ˆý€óÀðY:£”mп-I€t¯~n€D<nJ•xeÀc™á¶Ð÷ âöâìɹ¢Æ"úò¶@¿YñôÈèÙôÀ‰f§{çÍñÛ]Y‚2A_y¾4ûÈÓE_§„ã4å³µµI<ä+U0½ålÌ]ÉŽDƒêÚÃ=.|_?ØÁªî½µ¿£J³sSÒPui²0X@â“ʱõÌBU|صûxe^=¾ˆ¼pùFìÜc.º«w iEÓOíëÐâh( òs®A6ᆟ^üM¶šyR¨ìÔC Ë-—A°€›ŠÑÐ[uZðý¿þÕ­VŒvÄWº!1=ˆ„‡>•±] Y‰S'è¬öÕpšû²«¥¢Cîô®v¶ùrN¤ŠJÑݯ´{-©?5Ùr?�¸^{‘ja‚È£Cy@=ê.è˜�ÿölÀy™Ö•E:´ô&¡­rùÃvÇ›™>Ú-[©kÄ¿K˼ Ö™Oy¶®á+öé6pn1;à±¾aìg8T$À”3™ÿ˜yUÈZ í(ãC Ð_pßslåÚòBuuQOeÀçΈ&Eû4I¤|Ýå+üOâyV³@YÄÎËž»w]ëX¹µŽ£$u<<I_QiÇ¥“µRìŽ^›ë…ã5DóÌàY^a]A8ì\u´—ðB)Õ„õh¸‘ñÕuF —;áVf¢ Râúó¥-¶òd½ŒC ¨¼–áTªsŠ¿„ª°8U® ¾qwñÍæÖ�™ëÔRÁŒO¯œ¦·ÓŒ·Äޕزò„¼p#>Om¿¿éŽð¸³†›©q∃2bšÏ!èìgsW¦ÝhßdZúß7ÚFœ¸fYÅZ'à ’cyܯw7šçÜí"M}™*YPX¶@fˆWDzDP(þ]ÿüƒ䕲åäÉ*ˆ[üDT‚œê rúf¥‹–R}«Õj)I/õ¦æ˜èüÑÉGåö/ËÍ(Š=K‘/áBbüöDŒÏòMÝÇþMEyê¡Ì *ƒr:[¡äÆhRj#™ÁJ;A:ÅÙ—yCáŽö±Ðž&OeI†æÊÕ^pžþ‚Uf‘µi`€á”ÄAÂçKhF$t u{4ãéM! 1vnæ?úûr‰Ï ÏD63ÊYÏÅf¿­/Ž FÁ‡²0ñö#‹Ç-§tµ÷ ìÎäó!}2Š~Ìñ¤¶þ;¥R‡ÞZy”郵­C-—�²wŽÛ~§o!ÀƒåO²ySçR”ÀP¶ü‘0GåM5Mmw>ÂòÑõ-ØÊþÆÿÑŠê¡�ÒWŽ¥Bå€W>z–òºYžÿ ƒ¸,mÐ!¯Èu@ëilA ®gÝÌË÷Wò™8Uü!÷t¤?‚ud<ÑPˆÌ®A»½€ñXâ=’Â'qÇ€#ѧÎ- ]#»¡û†óL~¼LÚÓbu¯)û›§À¾†*7ˆëbäVœ µ9%¬‰¥)É4‹´ÚÏ‚?‘kçÌȃºfþ9yú©[Ę®»˜ðZm÷Z–=^yë+ņü˜i‘åmç¡?=;–ú²éX±ž•ëô‡+¸R\z#bKMÿDm£Ó[$fô¶Me&ªÁD¡mä®K‡"öJñ´èôŋˆnì!BxÕ†3v‡}÷±T²=_ïð¹¦bì«Ò0j 9~^L^ÌFTTîªôÀî8ÓÝ äµ\~¦Aª3û¬ †Ýt£mqTízVÝ1¨aâAÄõëtÚƒÇ0ŠR_”‡ŸKí€Fï÷â´0€òÊÑ/|¥FÆGnO”±U“ç\¦ÖÉÚä?Ò½=0Š­úò¥¿¹ÿ›¤v ˜‡4ΞÁû" æÛ†üä!âû³ã9<¹²Óè”’p$ãdy%MöªFYÅh¸ýçÝgüèðbVu'~ñ‚ò;¼âl',½[ÌÈÇ›ã“;v‹uÚcOTÈ”A"C”UZ½u§ž¼vú/˜Á0)…¸Bx ›Hb¥[Âr,íF0ß{'MSƒ=ùöujdw;ŠÔïÍ…U¦j=¶dµ°˜/`¾“i£­m<KSœb`Å„rá}ˆq¡¸Ò˜11 ¡•àrÍIvYƒ& AO[ÏÎ7ÆlìwÎ)„`$Ïâ¡öêŽq@â™h¦Fm)cô¾KЇã@²ðß{ÿèðZ-ØÐEëžôD1 o ¨àÑÀd�qqÎÁÌoïm›È‘mþá$JgXÛš%ä’ŒŠçfÑ6¶uù’™¨s$Z)%1„ñV¿C.×E ®ššÑ襌å ñ®>˜ã¦jÝ+ßÝ<õŠÕ•È'­m‰¤S1n’äp†¢BÿŠòÉëêÄ^ÊÍ6Ì{h7‡¶;›¤l*.…(ÀîZÕg5õØšŽ†3çu’ ±ÑЩi ó¨_$’–5Õò*ú³0kš&qjúdâÁ>qíÉ xµ@ýM¿öˆ ³h1Oäî§ß£»û †½ž üçýacá廾”ï§ÜRí4ˆ,ß f%¦½S]Cñi ½ë¿iȦŠ+\ÁHLp²Oýš¼R�Ø£Rѯ£ØR¸ÓkxÜ|‰£^ƒ0óÇ—$]žp}¤ÈC ¨ ådÂé_.Îñ,‰¼Ì‘ÖíñŠÝ—­Š”,£ÛXÜBU›¾“½øYrÇ* Š 7Ó€´¯o¼pÇMJDj £oõçŒÕa:| ²ÕRwŠÝ½™µ®¦§+”[uõ˜Sw<¯+1’Üa]0ÊãjFayŠF¬dô#'¢¾8˜ ·Û€As=QàÊwô½·»óbÑ°¦÷ÜÒÚÁ+ fPHÄ:æc•@†ýÂnÏد@‰‚&‹,ÂÚZ{A0†8Ò)|c4T¦ù¼§]ÓÞ×VLS{ìH«îr¤V'û~+Tž'd”fÓ]\æøbÇmíQá¡–V^Ó¹ñôvÜo6 /tpžAÂ,me[¢nåÀ¹7¡‰ya°Þ$à¡XªãîØS¹až÷(‰!¨Ò™nþOÖ—M> H÷~¥ð›0@e‹¾P«™&¦âö•#v0Ì¢ob_XË:î}h¨UL÷»X9mÜõÓø§•´ç÷d¿2ñõ¯Æ^ÙE]æ2Éç÷VR,õ†Ë§åä ñé?Ðîšè¶wÊçˆyµl£Õð“ìá ¢Ä«•ß£ #Ý:¾[éõ@QÖ‚n}¦áš»S&däÜÓ½Ø µIkØ1V#ã/·Î[k>)Å)×tó³*A¨µš…¼wh¬º”Usê¥ösÞ\\çîa÷;Ô©tiš¶Ì¹,¶[Ï­ýº£Úy¼2H±fÌÙ‘rG^yQmU‡ö[+…qg*ùèj­þÈ2ï^ét ¥1Š úT ²Ü(àf‡©;À÷EE‹ ç8³Hô—·˜ÐÒMŽX”ö@±"n,¤…¥áÓÄ4†lBrÿò¾y‚ǵnj-¡ú™²•xÐà/ɲé¡þ÷-­m™>ÓÓ6ÎVL 6]IÿZœeíQ¹°ÔÖ}®FAÓ€Ù^å4±„x¢AÊúÞ½òõ -Û<7ßêØ¡‹kýv,rÞof¹w”¤à,_î;¥g Yæ8˜bx–6±ôP ]« ‰ÈT'5ÖyÑÌm)wL5ü9¡|NE¬¡ܱܩÉ;£«f?ÝõMï0c¹ëKlA¯2Æ|†ÂäII ÷Á€Q°éyg/ºóºÈëÏ/I{…¥f&¿›æÌ›·±qxøp>ö7àÑ_üH+ sš„|ð60OƳ„yxl$M%¹°Ïûvä`c0XÝü¬ÓuË ü}´×S¾™‚M© è³iYLmg[‹'©gdÂT‘¶ÆøiáŽaLú¾Š´ ‘Õ ó‡©~ì–k"ÝsVŒ¢ÌõåBÎ0Ë ·~ ³à÷èæ]áþ²‘"Ë#`é;õQ°æ»)«±ªþÊ6!òT�6`‹ŒbÜx@°õ‰¶Ý|<vJÛïkƒ&|Ñ"#]þ�zPGèiX¥ÒˆG€àyküÞl2³Yš \êž;Ö¦“ÝF;éPþ•ws†Wþ3æ½ÖÉÔ•‚éšM•Ñ@:õýåÐ6¾¥i¹ðö(…$›U£•DR^,ÌzûF響Ÿ–¤¹s(H €0ˆfÏo™²•óEE(x{¡I=ħTD˜Ã*¶¥ Zó=i¡­ÎóÜÑY$>Væ�¥ƒl¤T Ýy §ÎË¥ Ÿ´ìÜE[MÚ¯²\ßÊ[.#DU{­)'5Á¤À„¡>Añ’³É㫾>a¯–f»V}ùþíá”)í›^iŒöÝ(EÒÜïίÎÁsÞš.Œ@Ea·e??í]Б¶î¨öj a´š³Èa7´J·ª<ÇCwÏÁÁ’Dd’8ûÑó_Gr8M6,½(3†Eåc 9k×Ã+•Þ+5n{Gã®»_^®¥güÉ@ÌÅÆ"| ølý²pöF“c<èµYG) YÖ2¡’äÓ“µD<ób²õܬdØ]mK×gS¿ÀŸÚû Ykæ Q}Úrhøü… Fš]Àê‘ccº†àÑÜ‚”Ùüõ|Q-WÎ8¯~‚ïöÊÇÒnþ˜!Za—I5íd5-f®Bù!ÀMp\}=ÎP†ääÊÙëýÌþÙó™°ä$B‡ÂåѤÏÞ¥W’Ë´õæ.Ë(…×Qž(sI6 ¯Ba€i(ôƒ'V¹ç{´üQ¬ÕeöæëúùH >ÀDàÆ:ã¦I%¦$>Ðõ*1}HY‰²•Ž GL9BCkž3&PøRc ü¯N“©Ä˜Õ@±Ãa¾¡rFKùÑ0h¿‘÷윯ÀG·ACŸ¨±±¸ ÆìQÛ¬]ÊŠ¹»â¾CÆ¢î gPÖ°L i`ü¬×á u±«Íp¤ÐβÀq<ži)Ê„W’´ä¡ã|áÔ›j@iGãÉXÏ”‚g_yÔéå¹Ê*O½4Š€``¬Pw±‚wÚøPFM;ë—x±g‘zà ™N4R¯Þ½ªLu&Ñ{ÙUÒ¼üÀ35"äè,pj¥Ñx†æh£o?!U2QÁï“Nt¾›Ú´ÆŸæ#`ÃhýûZžQš:hÌ&ç#ý‰O­YJH0·ggâmO»‡§žÛ¥¹f¡43 ÊîÝ“0@×Șhü6ÇŒü™�ïð\Y³qÆB3,:sk9xýª2kŠo€À Š¬¼³PäJ/úc? Õ÷ª¡…N•>-ÌÈApÙ‘7¡Èó%ÒúÈæê{TÑã Oµ nªþB%æ~«È'åñ¿XewÝù×ÃM ¯¶ý†™ù»6²Ø°þeIsÊz¢óÛ�|Ý%úò×Ò‡©£h=;„Íô F F’;ËGi›@™É¼Ê˜¨ê…‚bÏ·2Œ,z¶àå›—A1(R§�T‡Î0E%s™«ƒaÝëÅ&þÇ—a Yc´ JòÝchtûf_9ðßµÁ<×!¹%CSövR¡bŒŸÆã¹RÛœmuQˤÿïÿ¥àÒ/0¼}!ºð˜Å[¬­»Qr\ 4ÂÉÊjvÃt­×èÐkeö&!ô²Äè÷mD›Æô Q3Á£ˆìÉÿ©JŽSV‰±äŽÉ*(+õ–dFJ×)^a3RFÁ37ÿòy––[Q4κéoPaK9§µ+R_c³¦ãÁÿ—?oËÈ—›…é5˜´ª^9Ç´’ {¶´Å¼8ã¸õGéq¨{‹l6ácgÁÊ ‘¡Åä•~ßÐ]AJ¤¯ËIcês9†Õü~öº5;ž'K'@Ë燬×±;Ìíàã´ DxÅa|ÈÇ?ÜȾË4¦`�XiÛBX™Â=¶9u\u<Å…«þ œ¦ ²O‡Wì\#¦ˆ¦yIƒÖ*Kdf5°ÌUÙ©^îÚ^ù['öýRãÊÊ6‰#þÎy?‹_öô£í¾öNTäg=‰ÈšËF©y¹­M]ÝvíÇ 4㌼ñ¿o¡™Šä2•õF¬žÝ’¾ðÿ5úù];ßósƒDìtD}‰a6v})}ìŽ(Téx?õkw†ÿ…FÍÑš¸L}‰T%ç<HÇOÅTœ:ô»ãðH×÷Uüv¦–Îâ`ŽFý–޾ܜ ¾Š­ŒèÃùnÝÞqjËâÛoáúy’¨¥‘‚ýbh~÷—l éšY,z²=ѽ^õ­*Òʬ>(¢ðQ­_rØÒV4ìö´ïdõ;\l¾àkÀÌfÉŸƒZ£¢Ûfg3´2™7W#å/ªpÈ&ÞRæ.düoÿZ’°úy଱֑«ë™Õô‚KM´rü1ñRî{¼Gw±VJæ'¼±»O†0fæôþDÌ#,<~ôSötP@Ô„v¯±Ž¤o¶Þ¡1-ÐŽEõõʼnä•ðòÉ¥ä�Åk³3Ox¢îHg¯•�>Ð×ûîîB±ÂÏôn×�Q—ó»Å;–’= K¥l±êDœÑv¥ŠÜ÷F‰VFaîtñ$¯ê|›Ñ;x]c.\yÝ©œy"tþä'íPC‡œ…|<´r<ÍtSþnæÔÄ„y‚euö¹q]. 9ùŽj/š«¹]•Û³i ãîsç˜r éöÕݱ¦ÿž©7#è{RÛu+)Ízo{_Wª~q{u ]I2§8ŽPš€UI½Õ=¾ýóǾÛ´PŽãÐ]y©?D“,ÍÁ•…ôÄêÛJO'õ±bªóC,TŸal¹éÌ–:eÇ’¸˜©íi ;÷Ü5pµ¾¿¹Î<z ì­æ[ÈY0b³%ÿ2Èy´h&¬‚¡KƒØqÎW¥á²x‹aè.Ò³±Üáa5¹£Îìþþ®]c ŠOœþ_æÿ©Ä¿šB׎BW6ÛÂ~$ÇsƒÑzÊœQ è«ø´Ý³`^-{I •­ñ» 3%üxæÞ)Ÿ¥Ï^C C¥Ć¯°íÒ8(¬ÍOl¸Šýi¶rPBds)çï_Þ‚žR7|‘�ÑoË :oTPX4Æ|\·’{�´z<~#;»·“Ò#á1‹D6­µ‘æXŠÓW%G 3±¸¬ä°¿.¥óá ±àj�yÓÖž Ìc; Ýž“WˆÚ4Ö–Á:B]ý¸úʃŠå6TS)Å*{›Ùg"'Hz'TÌL)ü^ÄÚ¾¦Sû! "KÌH¬=¨çÛd6æc¶K§>‘d‡$ òéÝ4›˜§Lu‰oÅÌHP—5£áCà>Ö»ôû·”¬í·”3ôºjâXtºãàJ‡dYsp²,@ÅÃÍa&ƒ4¸¸>R¾\Ú#e9¦lŸ¤÷HCŸ•!Ì¥CÌÂÓ±¡ Pèe¹ ÏÔ¯·Õ6„†$TÓf:ûê ÷—D>›–aM1;ý´lRÙ¾“í¯g÷¢,*©’!x`gAnÅb2nªÕ¤ÏÖ¨å«Ñ•ÚDÉ­º÷ËÈÚKÃÝ›² žÕ0-ämæL”^Ãå…b‰1Çúå /¦ºÛÇq€Wg®*[8ßÛ³w2üÖ1ÿÐqtKŽR'%z¬Š7ÍóNõ~žmŠW¨Ü™ ²+ ~çãIàYNÏê©yPù¢™!RÖ6ª»ŠVš1òk:ž$™0›×_�ÍYo<vk¹ŒÆD€?øå£}OàÓ„ö@[(>•z®yP]™ä€Êø³z0ºK~Óû™#ío7²f¹q‹Ð´Ó'+Ó‡á.½²<ëÖs—ì �•þºù­®ÒË}¹¢ìÀÏ{W„«suéŽè¨.&älŒvúóL’ßÔÆEî×dôÝÖ_ôÕ6³TÈ>DvW °ŸH±òÍ…á66¥A6m|ìÈ~ÚQF¤x„D–9ù…]\˜EÎU÷á}h¨¯Úju1ó ,•G§úú¬ ÓÐwöæ©yÄíÎ:s=ýáλê«êç›W\[ilT9ò<øE$…U–<jöHøgˆ"ò^R¶ DŠç<p¾öëj¬´ÆÛ±øÌφg½ë¯]*41¦ƒz2ÿÁÿ!覡]Ï,þï ž Ÿ߯¡ðËÀ&(.l‘¿±‰ÄÊf8à]|žè¸`õ&ðø¸eýtÊeG¡‘±˜áäþxýÐcõa fbO+ÚêË?Tê2Ž2ºÑr«X†œ‘»¿DÉáyÇ–Ü„…˜³Õa ³ßJ†©ËáE]IÏÊEzÿ|¸˜çƒHû~¼0ÃLú-•«ÎJª”¼ãuVAçAÚ_Ìš‰ùØrâÛ·tðµ?N©|1ÆÒŒýøw`m`` ¢°·ùÀ¯0Ú‘GÙÙôò«Âqçæÿô-·øϪ@ç̾[t›o˜\z›‘ÝëÖ ÝZß_•›+ulSuRhÚ‹5ä†éOxUsœÚ Ôœ¹(wƒ(0Æ Îûz1æElô#ætÑ$È‚ö»¢AÛxè•¡ý°oùt÷0ª¾"ó7ÚÁ´ïrní;»x[ÙY‚Œ´7Ÿn>ÅÐ…±qÌFô[©;Эò¦•¾ÅÞ·½4q}‘²oaòm‡Í+eC¶Áce¼æ"¬Ñ⧠ÏÀ6§¸ë¼å"§ÿi Œ­øÀ Fº¥,°švW=©›ãKÞž¢\Ô4žÈûxÚªþH0­O½!­ÉivGÃòJÄ,‰{²‰•À¸ ßv;ÊÍQî>FrkxÒŠ<~h�²W€ƒn_³DZÓ"îJË@ƒeöMÆYã"Þ4(c®åy¶„Iv%Ó½=Á˺WI pà÷ˆ3A ÉîxB°°½5#4ÃOÅVÝzÈÀ1s±Wxû,ÜÏ´¥:¤´úÒFð[œCUðßK ešq‡©ëÛŒþî§6`æÄM%:¡c®Y™€{|›–oÖ+k66'i)÷ÍõP8Œ}ø%øhç•à±÷ÇÉÞ·�ñiéwäa|P –:“Ï„F‰;¶XpuúbzÙ‚(ÚêûZl³8 Þ½+YÍ['YÿS¼¥³ñ4±¢ë«�«ÈæÀ…¡žm;¼õÉãøƒ ú)Úµ½ÇbçÄ»…kv DBá‚öM¡›ÄKÝ°8Ø–VÖ1è?Hðù³Ô0Ñå4€¬ÓÄ‹ *Üoms8‰Ø¸^ ªÒ¶lbkþ³2Ê3ù+ë½fMQQ6Õ‚¸Ûƒ]kµ-–¨HƬËÉiŒ?wˆÊèÊàÎ) ¬}¢Š?2‚&!Mœ³'}š®ñ™8‹ÓþZ¢ÇƒÖ³ ØÓ6ú¾x$Bc6,¥Œ§7õZZ—éj©­(æ{}ëÒ•LD§ß—…Ë¢ƒîUƒ­™Ú‘>¾Õµ ¶\ü §>I=zZ)$¬˜þŽ¦ÃƒpƒI ¥å ”ï¤ýü—¢`yê‹&RìÙ !þòÙ9¶+âàôªdÍñAÑöQ÷Yá;ßFŒl+bŠ([;›6ú r§W>òM$Vî™å¹ óÖOÎ…ûgFûHoÀšÏ”Š|·¾€ÿ[ߤ$Ò‰òþà2°ûõ·.gåÊí§TÑÊÄBr#\J²­ÓQÏG‘›Cfˤ”¶~›É66ëÖÐøÀÁwi(_dÉ”‘áÔ‰d'zVAÜ[±zgÌ`”˜´&ÿ>ž¢%v¨qý¶£i×:»m+IfºÕTÁÓ颟l½gá)¼ót†ă o ô|ÇS£)O–RÎst¶ëÛÚ`†,à(¸Ìpk°§ÚºtI×;op'©¦Þ_îXœ ¢çö½ãÔ‡¾Ó}æÉhX«@VÆžL(©O‡{ïýpZ–|ÍÀwz~6 ‡Ã#ƒ1;Ö Ä.õ±ÌµƒAù)–4ˆÏ£€J±WdD» í7\·ÕSH©€÷n`×KçŽÚû)Ò ÑmÈñTÕz6Ê5$¾9×¾zÅ­üø‡é-ìÐüPد¾b—ð›NBè•#™‘ãéz8jsETÓ¶¿5µ”ªÓáŽ÷Ryñ´º¯§œx²lÒÏY)¬TV¨´ÃÞÓÑïl{Ê]ZP„ïàÌ ÿcGñcÕZë½ÈftDod,¿R Þs%9Gc Ç|þ¤·íx;e'äoCÌÝæãu¦zª7rå|¦Õ€-óo•ˆ¤hãð:š´=8/­'±F?Ðä&‡¾~½ÛH=¡NZĦŸXþ$œî7èMØUMñÍD‹Cµ—¹¡weRÝ,q®«èQ=É>�ßž`ø°|Ö¶½ï]=é—ËÆFÈB³ôÁ‡“×ï\Óê­vÕxí¹AKPZ<·&QêËÚÓ¢ù˜©ÆxW0ݦý'•U”‡JÒ×¾ûËÛ±¼§ÃËòChöŸ“Ï„¨ˆ7^¦ŸÙ¨ê~¿'-}}¤Æ,(:?ÎÇñk!üZÅ‚qÙáÅëÖ¥µ:„dh@ƒýî@ßÝêÊ2ô¦›Swß•»H}H'í*hdœœg6Åö¾À¯eFÊpáý]Àຘ¾c ”­ÉDÅ'[R'<ò7ÊCo\àh®º„Š„Îk"ÏíÙYÑ;®öÖvìÁÇ"&\±­…Ò�ÀQ‰þ <D!æþ}^«”0T¡}Ïìû©Öó¶|sRCc ªù÷¨/óøœL”ì*Ú@Åðî²c)¢ß MÙðšýgßÿ³Ybšîü¦f8‹ÿÏ"Y`)ž@¬:¥!�Xn„ Vûzs£ÃÒÂp¥Ä \bËÂVÐŽ¶œ+éѧ4%äS¤^ìaåb,Œ¾d,{âD;€M¹»†r{ÂÝK“W'Å™%âÌ¥}B\oÛ€MügâÃýö7O²¡Üx£$=áÓÂJèu¾“”À~—~ªº'ZpɺÑè­êÆÝã¨Ð^ᶵ¨wGl¥''“³‚W;äðꬶ;“˜>­î½¤øZ–ü¹±Ï7bº ?»ˆ÷Gæñ¥7Ú’ã&Ï;-~–çÅOÿ%dIâ@ŒœPúAqæs¶Â=e6ðl–/èÅzÁ%!|!ýþ»)ˆO¥ÏYzuŠâ i•ýœ1Šo)¾( ™‚íi Eu¨lúÙÝ+R–BÏæ}¼Z1Ì91$kì*yì»êÂg ÿûÄMÁ õH‡E6´$ß‘ÇcÃ5£9úÚ„-Œ=ûdæšÍ›ÐŃÏ/­phÛ‚9‰¾ù$w]vÁbs¾ 7¡@ÈàV¢¶F¯ºüœQr #ò}³¼Ý±»ðÂU¦ ûÛ"ç¾ùEè9_‹+W,ôúÝöi™u·7©Óß1УÔSg ¦þ*ƒ¸ó! t‡EÉb»Ø"•E%¹óÅûE` Ž—“3‚ß l…>·íÍ}©èsÏÁ¥g 0òù¨HÞíl¦ã7#æ¥êÉ/긅‘ç•#:zy§méÝi¢üì+Y¾aõØyTÙ´fË»‡Ëõ¼Àd¶Á¦ÈÅ®÷„ü÷Á•ª¾ü«Äi2åFÛ{¿ÍƒdÐÄ‘Ø]Ƕ_œQ…°•ž·^<AÜ•Å" Ñ0¥ó{Ö „@h^<@óóªeè;J}墛HDAÏ^ÚK`Å%Í.j€ÿí?ÒAsêN6Ø=ýd&THEG‹¶´ëÈjj¼…ƒ€rÏΡ \ˆm `ʨû+œ£j(DI–w8âÛØ—GÝ–+Åö¾J°M×VÁ»ö`ú¶ø¨{ñ?NÞËUöìì sˆN—$ˆêö[8ÿ§ÄŸ20Óý««ÉHÌyzæ|y úP†W>3xÝ¡… å ·|9ÁéÓÚÄ{qa±¸ ¡·Ÿùt±ãˆâ²0Æz/“sñZÑèdM óW¦-m%‡ÓŒ¥É¸_襁S.ãuä^‘Ã˼÷: ¶ýW>Ó_8°‡¬. ÙŠSOA.–PÉJ9œqbÌfjÃæs)à0Ïœ~"dmàïSÐqª8uô­‡¶ç®‰é_Ññ·G%< ­"\è’Êæ —rÕ¹Êfëdóù–×XѸ™ÔÞÍþÐT‡Nß;ñ€Û+@ á íµAËl=Vg£ �(N,°ý Ðeëmέ@; Âqö¬ðdáÙ~ÕϬ–vypiV¦Æ)ŒÐ}ÓÓV“Óۊͱ±6±È‚¿�\9Y±RFÊÊZj¾±‚#èC² ØK"qºrã¨ÕSa|âYÉ^R ½Ÿê}ךÄû¿oy¡:–gÊ’×W÷;¾fáû+Š:–jÜk^LêG”éXÒP+P]¯÷4ÂÂbÁÇ¥ +ó“ÌCø¾öjË4Q*HåÛ~¢ÍqõŠlÒWm@qØAÖÆ_<ÆQÒWàÝ3ÈvGßT<¬WÝU¾Ÿù-+‹1‘tÛ‡#¥¼±$PÃ÷¤®5ø0 ™Š4v> –žÀOffYž[ÛYö_[ãk9òÑ4œ²æ^Lu™Ø‘}Dfd/P ä+—´*ƒ¦‹½ü¨8‹Ð³ýŸß}FêÐ gZãÛS“°6•@óéKìùÆþ÷-1£P:E©Bƒ—;òËkç‘ÍÓ «õ…~L‚ü½óL—¿öÇ®Òä =\%Pt›¾_‰-”™;&Yš{èbx¥ÔêAå™Æšn.‹PëËãÔ•M‰„ÔU¤ÝÆsñ0ÕÕ:~�¬ ¿‡Ä'œ8ûf?,ØáêŠJ5±ð̬ØT†UòlÌhku<Õ0ß|ýÖ‰#óô@b9Óí/†‹ƒëyþô©×­ˆ4Ìãi<Þ§ÍE©ßàޔ‰E�fÈÎ-ƒèE:¶ÅxÔ>LÂÔ?Kèóº^‘ ÊF½Âb»z„ã†ÃœÀ,ìß9Ø…^”@{; ÎP³”»ñaÞŒÕÖ:JËRAE CéìÚÐö›iå´šz]ͺ­:º±ºL9¥»o/YÇÄÒiæi}£¯"Ó¬vTšA±žó`+„ã» Š¶†scõd“§Åd…'_1¥,~dÓç3ѼӼG?D´4@ž>z.vsÕ‹ ‡œ-ÿ }üǤ÷ò¢ÜK²ÄŒóåI=áµâ626Z†+…íúõÚ›Âó4ì÷em³šùûîãÍÍó®Û²ó=ùš%LsÞÙl£T®W8UÉÂŽÝ­ÖÌ FMí>²}!>–"Þz—ñdYIܽSƒ=½%»êÌç:fŸœ¶mè0Ìïo¯í:&M»n«Ý;J1, !¸ÐÉ|TÅMº¥=!ýçàæ½"nŠJ»P¬Õî&'J}­,"'JÁ�Ѻɂø<h5†¦x ™p+op)O4B,!ž“PdÊ`eU#>Ö¦NR’q5ú=m0v§B×fàS{½z¯W¦¼ë{ªÂ¶þ‘«»½wpñçÛAÆk)]ÐTjòq§—µry–LŒ;8¶u³ þuKãÑø ¡+ÍÚ½XzTL^—Æ=aèÉ˱¤CM™`^m=\Û®ú#êšZ®;dø €Ìÿ¾{Â,Ñ1�¬w<«4à‡ývÛÒ-â#›-Rö”™2ûèæx ý+, G‹m·W•z`âZÓW14£e¹G‹y}sñ¸ó¦D´S?$^Ço{rÝl>Xþ†Áð,(YM3zT¹RòšÙh©0õúªÓQà+.<IX³Ò7\^…t;AôoNž’—ú™À$un{Å%(éUtW·>ÕÖ"åcg´a·}òÈ'óñðö~¼¬u«L½ˆº‹§ÂHIûFÀÂõ0a«Í4ò0Q:¬ÖϦ‰ûm%܃(€4Ú)ô ªÂt6zCc¿èËF¾Ý7Š³`s¡¤ÀÎÕ3IópÀK·-P©!Z~¨7¿ºµ>·”íÌ$òÃHißâ!KcZñhÀp°óž$Zæòý£¥ÛA|é²íÉm¹ò Þjz ú♕’2yBßø«T„¡9ƒ¯ðm®©êDÔU³¬Qý 2R–w$"¹]Oë?Þ}#pEÈLØ@ã íÓP=7s/ sÌ©Û•ð¾Î昋d¬Y5]; Ìñ¼© ã!ëÉu]ŒÕ©kÃ1-{èt×~; Ò@>ß´”•÷×?•x1ÿ Â9X)™5ŸžÖá­vcŽCgÄÚ´çÑ"¸úqF6Ž½ÛZ…ÊÔgñÜQ^:*œq‘.[“ó²€þZÆ(œ)@£¾«å^`;Ý·.J§_À`“ÃGäíä¼fûµ5‹0‰¸lúOk“ëJÅþ¹LEff*G¿µGNqtßkrFõ…ù™›¸ÿÊh!,<¥´‚Ié-½b¸“XœXPø.à¡ŠY˜yÚhl× y¾ÓÐ1JÝ|¡Jº}³{ç‰O*ý`À† ëïÊeICVˆ‚Ÿ¼)îίÈë:sEá­ÑÂëiYWj,z§ý|`ƒpV+È(ã)R+a>JÓ÷ÞËiÕvØ·“�;•¡ÚÆûщz’H™©9oBÌî:Çû„Ç(c‰'yyì©[_F…¬WµJ,Òß Z¯/¾\&ò{ ØËÅüù+ Šö˜ñ¦¸wœÁʱu<)Ûó„Žåø9 )T®ˆDÒYÝoÁé,#t¹ž¢®+Ø¿!ûòÔ–Z í8×€=ëÞ1[E¶â2ˆ]+ŠV 5 ¿6Y‰Œ±mmwçâFÅ W¾À7èóVŽÀzªôŸ\~¡&ÚD#3 Ù<BºûóìuƸV<ÚQ©¨d?^z}¹G*=°*&ý€1g´[í@ù"Õ{ÀÃvfüó^ʉ;2¸éÊEÎ Äö+ —ãJ‚9 n¼µ NÁÿKª‡…¥ˆlõ*¿²ÿv½¥Cµ;öûʯðp.,ü¬ßÄ"Ô)™2@ÁâáEC\ù[‡– ǽjHÐÊ¡ëK§ÐC"ñF¦u9¤ÍÚ #<HΖéÖçê—.XIêx8¡:dA²;9wyœ–‡V!//4ª¢Ô7¤[Ãë(k79åL ±M©5OÖQbÙ}¬Ç:ª?ÆÞKz Á”{3 X;8½3ŸKS¿ÿ ‹VžPí’CuA\Çô’þϤ ËÿZ¶¢*y„ѳދӾèÙ“³*´ÊV‘¡Ÿ+J‚¾µIŽÁÙ¦ê(VFÎ'ÛçD¡4*”åî¥W®f"4›´}wóÑîtàŒ·¾Ä®àŠ3jqÞ ÑÝÉ‚ð}ë)|‹w§ÓBbuë{rß͹¸˜ÂÖ-íx}% M>® ˜á¯­cœ‰T0pÙ è ÏÙ¬µ­>¦¡­,èqü\|lž¶ ÂÌó åb좒™ŽÑç:0ékwì@fŒvôÌņæ²éØVtñƒát+(†/ÅÓØU”Å[U§•!.½Û¡áI„Ÿ{pº…"JÌUDk²šMAsñEuËAYŠçŠNQ|4}mý^“ßt #?ñƒúî7½78Ò±õ(éðxÙÛäàcÅñ >5Ï€OYù‚„p5.ƒÐ‘¨B]1Lß²v÷)Ýïžnæ=ŠSì <)ûÂçóTÙÕŸ@ö†r!Õkï÷†Ÿ‘Ë“(ƒ6åòÒŒŠ Ðtä®Ø]Lþ]Ýmÿpe9,(AÖ5VY·Cµîø潊øO3_tEÝÃÓªvx'D fX!,ŸK“Z‡?± ×7+Пeɬnç!Ê7z‡<s²XîêÐ6Ü»•[˜›Ã2Imåé2 õ% PÚ~¦.‰'´î×uA{tc}hªkßÌlÎ#¨P£&·T¿ϳÜÞ»PJJûG)hû˜üýˆ9­IœšKI ¦ÕÓòZ~¨»´¯¸/…«…!-Äõ. ŠJE* ¯±>0BDlœDXÅýæéÔ'+}( ¥‘k)ɧʴƹ°¸�5Þàçø\"Ç*;a’g¯`é1ú€Úcõ!šºñ) 1ÖÀtNþNà.ñ6Œ³œ(ãI6' œ·9©®xp,R^¼Ô9]u^¹yê·ÉPwÖÍ,fAžùÌŠØgЦžuj*ÞÎóuå‘ÑmÇ zV…»íQ¦<q3s‹Ê¡xØS]2i×#ç-_ÍÚh~™1—†n¤Ä3ÇÍ%ŠÍ»v ‘}öƒã²<ãºî]a¾R¸dšAý9„äûÆoùV>NB†ÈÚµÝ=ž“l¡Ú‡�•Å ;‘;JÖ�Þ\fÕ(~iizòRŒ,‰0®¨1²wß3”[îɯ VQ´CXAž&ã¼ÎLÛËØú“÷Õ~ÍÃ{x«h}v+Ns_°&\å /÷Á�ø«§ï@·n¢›tê÷5êÜQÚEˆ©ë s5h®ö¦o˜²Ì”cŒ žIÛ GôÅót! ÿ™Òí)TãŸrþ½¢â¸½,Œj4Ç©H½@­­N DSmü9ªÒ.¸m%XŠ¼küt8GlÜ?”_?‰.b÷áÙJ‹Bf–ja!hëj~3†ºF¥j„÷�C¼¿‹™©ã¢‹˜AGùSÔÔ* JÿcÀ¼×N[¤ Œ{~åõ‡Ä?à[*¾Ûo¿VY°½Ì€vÁz'MC“C¶ù`7õµ=J“ê@å´ ¿C2Ái¨=¦ñ†Mé‘SO@w²@¼soÎ+Ó÷¨ò™¡u‚sdhϲ<PS,Òk5}JŸJëÇVælé"6]û×r§ØëJL¡;…<¨vz2àwòîĽnï_0:œ1•eë/JÕ³Më9=ö¨*S_rûˆ…î®Ôân¼JBG@“Š:ýQ¯‹9.¯LmšeªŒ"Úɾý †(óàӶ〉¨O/”1ôYƒ’¹KyšŽÝžIg7™Y™¸e"~Î=æY¹<9Öô"UÌ´Tà9›¶ôæ®5%6X3¦©ö*‰n)åÿƒÀx–Û¹ á,ÓšQ©œÊÿPu¿?¨QXèîN†ÍåkQNx†_‡•ÆÚ/¥§#ú÷ÝV^ªF³È7ˆ�2aeA<ª3(jô_;zÃ÷áû§/5ûë “ºV¨wžZZ’®®ä(ûLº­ªµH‹”ñ^è·ù¦ ÛûÍ8Éÿ• ™¨ˆ àvs¡¿>m<]šªŽ¾òÅù™µ+Î5‰”Iw­7A{?õœñ1çgbGž¬ä�qŸ&oÚgL€­ÚÏ£SßþEérSwöУ,*Ÿƒˆ.’õ.UÉ[ÿÊþ»ã´–ûÛ1€­´NÑâL÷H{–6s0>‰(P¡sgüBãSÜd¶ôÍ‹öÝC{U㨒ây<þñ4íÄÍøΨ'Vˆ&+ßB 6¦ÓêSCDjoªÛFwÈtu3/ el&‹JåõÖ3i¬¨×ç I½¨*† ]˜ê*ôÑϧú5 Ò?2Ußû®¾¼$­bN"'`ÒQ ×XLª5çùßØ¢[tæÄy9Xà»U[Ï0¶ÕDdÛµµG O|ý9 B”ù)y%GkÙj(Bo³§ƒmÛxºM{Ø%˜°,æk¯z®æé•FZûöȦWÄ#"s¢ãÊ(I~kܽ'–ººVs[èð² 1¨Fûc…7S Óæ¿i¥ú}ëP„Øž�°ô;5¤¶Z{˜Ç™Âôk?n÷˜Œ ý¥XàҨ(ª­}Ýäæ²ÙŒê"¿… ë¾çñÅ#2ŠÛH"zMYåbÀ<«­Cd‚€¸7o„4<Rn “$õ÷e&t‘¬×òs]í×Çé¿oè<mÇýÆJ îd,ý¶;aŽúŒ)Rª'›jñnQ³¥Û ‡žÐR:3ŸK«æ$Ã@}…$Çéž~Wh YRÃs¬«"Xu‹‰·…E$ñÿ~l‘®͔̎;´¶v[Oºܽù첂éNgRLëÌäå œš¦ [Ü,˜rJŽšO<×àš�~´úÂ@#LNÌÅhŸE*vÛ(ÈÛÑ3<(Šváäü«éÁ1'Ú]ÝBùÂ«É ô8)‚t's^ ]*`=ÒñÄ‘‹-N`è¾ô RÚÁ—<â‡O:÷L 1¬.~!š¡è5š«ëvž' ü꺃 ˜1,~!î&Ù• súÀXvÖAÛcÓkõŒa[÷w„¾Ð±g1ÀÎ(ß œ<ù®Ü„†%Mi=ѽc) íHL}뫇FŠö‘þõù“ŠÂJ‚Zh|øÄ(Êî9 ¢GX¸yÈÊ—eýìŸȲÐàÝÁW*Aºò¢½ï7]๮ç2H­¦Dé<÷4ëpÃYJxuÒy\Ž9ÛÏà… ú6‹‚t7¸½À4™½(Þòî¸ó[qÞE{”™o ä$;O XYMp¿wíÁÀŸ_#ãXkxÜ–œeÑÊ|«€KÌ™^g@>6½xMJ×ÇŽ£UÂ6H‡Ñ“ßì0 ™^5rÿS¦©ÏdŒ!h”çâ¾ø»N´Sñî­S«ýÁ4;ô(ò¬ƒÚµˆÀLÍ_\ƒ'¼>Ýò)ýÒª{rUŒ”ôÓÊ+_Fƒû(¡ÂÆ~YG™¤ó£íÅ•©[žÐlb°'Ÿÿ³’~Y.ÜŽ)ëm)U´®Á »Ävt<Ù¢íõ\¹ò'tü±ÀUi ÚƒÍÆ-û‚u m«‡ WN8/3Œ¶a6zÿãÍFT;ãõ·ÂòJEfhó þóéà®@ ³á¥b›Ê…[0e2³Ôœ†~>_ÓECGµx-Ž×ûž£”iKõ:M3;=f ZKUQÇ€Êpa79êTSí§‹×+|yËìç.‚ôãê'�½y{RjpD1´¤5{òômÅ¿W⡶ã?cw:‹7¾ UNf¤íÌz‚=2Cój&i78ÇÜsšâ¹È0‚q2zúÛëcµÞ)ψúX=ç­|~…ô%ÁÎ_aú-PEÎ*˜ú#>NšÅƒ»µæ4“¨zIëDÂøâ‡Eší›»K#¬Íò ÜÕ^s¾ ¬ ©ö�ø‹�¦?N¡žTF\›ëÔe8»‰niáûɯ u—yØÂ(Œßþy‹¢P›d»v<X/×tïâtiÒ eá:å½'[r®ÃÍf²åñ€ªzfÈ®<ƒEÁk§¥|€@f²b‰×ÈÇ{²ušhvVL4Ö«ˆçv‰H²8H6Jcß vÝRè5I±úæm4³•gbÅ­h`'›OOeC™u÷’l²@s€·Ö—AÙ«²äÅHYP~PhüÚ‹®LöJX%Yâ\¢à<R­WYËl)pd!64 â᪺–på ÉÔ_áaºcO¶*N½íC*Þ'3Bk„²­ÑòX$E¦'±a§^ÎÆôdá¸{ðÑh­QFðgr`àŸÅÉ ˜ZÐ+êæêª?å…ß„uB �Xnÿ¨C¸Aã/ Âèѵ˜ô9?+jÂ�)ZçUD§ós Ðý7É!öÞrØzÅã}(³˜8„‘ZðRT±ÆyQV‡Ì*q@ïRS–ç¿rtg™S ]‚³ÌŽžêÿÒyçzÒТgQÝ¡š&1R|M Î6bCÇ¥5¿«œ’ŽÌþØ)¾ôšú€ Êòu²èü™²ƒÊˤùtjüœúl¦Fë*n yÓÔïG¤:;å.~Ú ïcQN•¯ž\SÈûPSçaºðÎ@K‚ÜjK§úÐN ‰j^Æýzw�€å©:ÒÂæ å§MÕid­nƒ™ª¯ãÅÂ4^z¸¹W_³Ú%~€ÊZ;ž„÷jS}íE;@žE4“ï]ÝK/‹…+“€%Þî<{Á58m­zÙhT LÍÜnxt?¯QÁ\ÞŒ7ïò'à-}£XÀ¶ 2ô®› ÈàñMý­5‹û?Àb°¦ò¸{²8ÌQ䜅ü„`$xø½§Ø Oy|@ãŸÉöb?ŽÕU{¾ˆ|¸5í¹í) VV7LÈ/ºJÏ —¦³ Š&H]§´e´òó%mä,(v¯ý陸š@o^ÆvÒ^3•é¥Ùw¶ÆÒ‘VçŽR†lè½ú¸iÏe%¥1¾)f“_ÝTK Þì\1ÿ¯òÔôÞï¨Aóþ09Ån1ó“0W;LS vM¬fE cc¢7Ò ´h?~È/)ÆÂ7Üðw“œ”³f\£!LS+LêX‚*e5,®%Üì{@X2ûfÖíïá³é°hÜôï·F6ÅÍ ìý,Àc™*ü›),Õ-'6d.èºGµ5Q+yšØXGÉŸjQ¹×­‚áHÃ+#ní�WäÚQü¬>6.±ñ|X‘ܘ)'ZYŤõîò†þ^Ïbâ½ìMÊ1h»öw�î’ÔÏÅÃÞKTHöÂ;¢¼ë·ßHÛ”¯ [G½Øã2-èJàø)>jQ®yãZ~w¾X®hhhÔã6 ’ïO¯€‘¶´þ4æ°¥Ù†iÖQ ’„?A¿( ò³®-KX±àû°™þ-åf2)ÅnÒ¼úª„⸑PòL76‘_qW™³£´ Α¯_åÌðž*ϹçqÖ›‚v¤QΖ¼ÑþF¢ÄÅ—ø~(?í8æ¹é4pÖØl=¡eðh¢û7»3Œœ´27¸§§§à>a¢¼ýB–b…ZÑh½¦ñ“ñF¢ø¡ÈRR+¿RoÆ_· HSÐJ¿1öµa" µ­‰ÊÒȹk 8Ø`ÓW{&ݽ*|ØÇÎâ”±²¶MÑû Ú”…ZQoR†[í™'o“²÷5ëQ·µ­<n1)ŽqB›ŒÿùáP‹<ñ.Ñü™ÏônÊ1Ù$<™ðI¬€Ò‡€š_ŒyìÈì(QSŸ~*•²ûJÕ ©3μ€–Å;IŠeüo~cËc_®>!½RŽcvyã§Ì‡³¾ÍíÅó?©ÁQ˜êæ¨â iF³ÌóoÓÎ:œ@%šž‰f«+ʩ˨ÎØzPµê2±”¹�úEG‡5®½K´7¦ãh4H~úõÊI_›p‹,>}Zo,‰µÚÎaRŒgÏŠCE'@J¹GX ÿ“ç>M–ÊÜéH'\ù®ˆb¤@SNÂ]ÐÍ8 {”:äņ‰ï7Ÿ X„Ûì°OÊS?;®üEû_/ΛZ¹©×¯?xÜÆíµŽ‹ ¬Oƒ”‹—ûbA%Qá @E¬Ú–÷;‡œæ=K*:²…ŠäOÊmaR¤^ÍF§gs)‚¸S=I¤A-Ðý䉒8BÊ äëµ(ØeJŒ#æ°öøûavR^?£ÄÂ2½“02s£šR–ÈúZ`‹ÙÊÝÜcRéÀšQ›ÎS(W¡–1¢û^;yÁjÚ±h¹J_Þ7ˆyâ1Ý¢S(°N,º®ò 8ÿ;lÄýÁö¬gªiSòÙ l#‹0ìPï˜éç‚`KWÚ¿ Jò¼Óz2cý­ñ£õ»"1ðŽR]G…‘‡aeÛdZÈ~Çœ XûäÇ6Êid‰¬ôŽ�ITçìïÅÓi:Ë=y ú¸~½#]¾klÉžQ’¤ºˆCß@Û.{JÇtÝ¿t([º‘d•t燎ríU»µH¯cݾíûþ¿oŒsuV0O30‚ôÞ÷Kƒxµ`˜†ÁåHû·¨¿½v ¥WGQ×·LùºeSÚkæƒÿdXy.JÌH·:}[Ž{{QF,.ç ÿá2ü¼ð[ T¥Á0ÚÙDœc ™R}aøš9`x#pÛÂdnô,ºÇÖä»\G,»û?*¿D®NAÊË\;¾|:iU^Õ­¢ôN[ë‡á¶'À'Ú—c£&30ë ZÇ´Ç[À åß;Põ[©2(âÍJ°* $¾‰ý:•ôZ·7YùÁ î<X5“å¥ L¼|ARD/XþtGÁÀ•¢ÐHøœ7”µÎƒzÅø³Yä|ÍéKwv·à@¢4|ý]ÜæyYŸ.þƒÉ!=xU/ßw=2k‹÷“?^ìskÀ„Ä,!Ûí¼N·‚¸Õ%Ii%œ)ú˜ƒðÏÊG*Ð RRhÉ$ô§½8`ÄŠU‚Ù¹¨Ä°rÌ‹2©ƒÍá׺VÖ¼ÓíißSÑ&câšÄPÅEçd ‚TfòË S÷pRt ¯�^ØóxœÕÝèÌ÷T¡\MÒ6°ØUÊÅLlõã"#EìI¯xµÌ¯Ëš$Yè,¯Q´ŸžŠ î­á—Yƒé%E_+ƒ—-–>å…i²[÷7¤Sg‘î’Åþb_ݹxÆm¹®Ë ¿Ìú¾<34͉i>–&‡¾Ñ^ü¯¼¼œä°òCÖGzåPûîÕŸ¶[žOÖs’e×~”_Ë¡ët"JÕè­wÖŒ°xûÞ¢RÈÆûqç銼–©iÿ?TW¿á¢PµñÚÍñ»uÒŒÐG8÷?èy2F"wÛo1<ê¾}e)³÷¬ !³™(Û3ÖÜè Q**!Ì^ÜQzŠ=ŒHieé¡nÏ:µëýd\·P 4F÷ëÖYq­‡ÚÒW*ë‹ ÇÉZ©µ&©åsHˆ—V«·—Ô ¢ÜéXWý±grœÁŽÀÛæÈãPapÆpÑûÔ»xeÈîrnƒ„ðhPÌxÉXŽcߺ ßÐ;šƒûÕVi»*‰)» ÖYK)ø ü–ŠŒÀ[ÞêQø’±‰áåÍ#êïgOS‡VwG¥ Åê¬OEHþ<U—»Ifœ- Šðš9¦`øxšÏì<Ú² ´‚Ç2á™ €|>!—å®Ehæ4vÓ²`?�ÎROÊ(XYYLÇïn>©œ@ M3lŠíIb{n(<Ù‰ojéÌÎ>[“~ kAÏŽ[ÅL»›'ÊÃUéhíÙÓÂÕ”õ‰ƒ|âÉïˆõwż³NBT:6Ð|‘P1Ði+ ÙØôï%‰ÃÐÃri|ü†‘›ªìNln€pòß·$FðbüGq£ÜwïÅÁR_ |XS*>6~…i“fǽNOKrÚÎ÷,’V¶¹,ŒŽÓЮgÓ*¨.Ý‚©ÅÇÕDÝyY(�¬î£8H+Uö/˜SqìØw° e£à÷øÒ S2w“á†ìQ Å;¥ˆš…ÁÇvˆ"!i.Z±W1áNµÌAû1÷I‚Cij|Ef”î ©]U(êUt}ÊÒyf}¦lêZõÛÙPþÔƒW9 OЧ0²‘tÛ¯6×á\²£ÏúòFGât¤èlF®žóvî/.|è ·!‹¿È]†v*£w|æ~mÐe÷„œºSF¼¡“Xá&9Ñ¡¯Þš/鿸>wdô@› ¹­el„\­ÁëÞ¦Cˆ?\-›×ºelë-j/Å¢@W¢4‘ND™>íˆê°_¿±¤Äß2¹GY†vÛÛú'ëköôꎼ%Bn1ê—2Hw*”[ 1á[wíúcÇ¢OÜa›Ö` @ÕC<¨5Ž<X¢F×#nÃg–^aû³%ag¾L5­£í)g_³ØˆŠ©x…ÉÜ/Œù‘ º?’PDEiäæžP£ãsýdäBȈŽ>®šÿÏ¡×þï' [¾T£+Ù­¨h*¯)F{« Ê î8x$®£°»Óf¸Åõ\�Ïóo-ya¡LuÏÌ'†DàíñØé¿ÕH²’ª4m¡X7i™�eéú²ȂWL럢üåW3>ç£J`ãŽg‡=Ãöëö”— Õªz§ U¹~}�]IÒ•oRBõäñŽ'½Ì)ŒåeöbÎûÀ?h—‡n9#5–«iÚ<²^]†PÉó±Î=1é‡Ö}Å’&tŒ{ï'+b­c>`˜OY[©=¦†Ì†síô_ X“EË .dßQwò(ÙÈ s~CeçwËäQy±ÄQµ•„ðÈâ²]o&“À‰Bg†oÇö¨®²‚Ù§õ$ç«=f_Öi sBÇMïh4 'Ä­è­às(^éŽֳy”…9WpŒe2±”™ßôÚ¬4¤-áЗ1½CtU§n[”Ï”/|f,»#Î}\«]c½Ò‘lÆÖéi0(ý!¸IÏè]âÃöˆyîî22®+:;ãN+Sæ6ôí¡UyVx_ë²ÐÊ)¦Æ1~â~ê¬u~‘›=Ôä6Ý‘B5Ž¶`*•ùI <Êsß/' v#½g½Uõ|x*RˆÓÊép¢øдgcªIg‘ôÔe ?Zé=rKÁB¬mM® ~ªÉÇmBwg§®ÐhT” ˜.×¾dÞO:MQìM°J¢qG;¬ülŠ®6Ò©›r ÒÉñxHpR·ŒÙ?f×Ж›­caÆ„bªm<êáö"ÜÍA·T d×õÎ#¹ÖÐOÁ™*¦"öðf÷—’×Ä\&¡r€*åV;! |‘ŒÄŒPl„Cêÿbté^˜O(þ]@~´ sÓ.Û [&˜Ç›®y#H05!„N.dôÕ#€EèÚ"(oÑû»·eaMÁõªÍ¿`ʧ y)®”ážòǹ]‰še@V4,#–¹â“¢8\…®ÃCO~óîÑØ@±¯À/5ýènÿ¶Pë_>.ö¥®‰ˆ3Ñ.Êù; xi1߬ݶÆe·ó^îf‹yé[GDà²AvktÝnß4ž¯oŒôµ3É<™8¨IM« ms•W @v2wò€ñ•XñC#òÍ/8 QšüègFΧžÂH,ºMÚ³)š¢~óÖÂO;x"²b ÒÇÁÀ|ÂâS m`S?ZþâNõó)ë/<7Rª`½gåqPwäG ã ÆWO$³Ä¥"¬?}¦7=o^’;XˆvÈÂyŽ#ì,ÇWYPWü€Î6®[H"`¦‘ f Â9ï±o¥Öx,…¹æ¼l~:R!‡ÔyäDq¹±¾÷¦^ùæŠØ¹ˆû*Èñ BFÑ’ÓiXÐn=¹U¿©Æ÷Ö>Å®§}½�ºµ] Ö¶'Š®±^¦yÍ]¸[)„¾sÿa´èf 1G”ê- e÷éad-ÈA G¶d3ó;…¢õÏIîõ ‡ö¬ `1Üå³ ïìŠIKÏ–Aði�–ð?šk/«úŸìA%½Ä ¾WDíÉ ù]uVHŸÈ\ì¤Ït劉ß.\-=¹C3Ì·0´-鎧ækÃü$w‚sþ&ây¿q.ÊNþL6Ô»®èpšéëÝ™f”qêÇt\eAØë`­, òÀ›+_‘ó(yžî’£$N½F·b]G”¼v:‡¼ÜN†£I ªAp(XìêVÙQ5ÿßþ¤8æ…c¨•F…ãÎB d„¢¦à¼nš”^š ÿ>‡ôVÊIOSh“ðw¬éwêÝ^¤1m�»hµ;Æ.Ì•=§LP5´]²²õ¯ýüËÐ ¬¤C2ÒùÛkN쎙çON¬í%n àåV][1ô¦p¬†Ë-ì4yªˆ­mªü‹fG‘úy…‘¦‚¾iï©ð<œ¾6ˆàò÷šJˆîâQpÁgtü¸¥QÿÑó7û|Ô¼a|s/빜aôåçÆöB…ÒÛ¤ð‰þ°…%¬8ÿæ6?“:#Qo *–¢ÞÓ�“ëQ ¥ŒáE‚ñ¾As’ú‡Ã*ŠLVA"m†]®-¹{ÒÏ;ÇAëEÄ–dÕU䣕0~Îé^[oõ´çFí` Ä.´¯Èû¸‰<o2 /ôO8šn"·Ä ^‘“Ç ûçÙn<šÒ»¤M»ÃW†b}›…¼F¹/3îr©Ü °€ð2¯f'é7*Ñ‚,Dñy÷Mo>X[ÎøI#ØÌxÀ]EYkõm_×@ .㺻‰"£Ó°ßBËÏòxè­y¢æ ⌳ ¡aùíëןä¸cOð+g÷Û/:kí–)÷F?&+ЇçÂ->O–õ¾ÊÇBoITU!YÖ­ªìÂ¥�ÍØO°¬5ƒrî]Y¥u—ÇÉÆ­‹ ü<¹0b,dóLÜô ÀËócdD¿M™©³@RF¨ößs”ã%Ú( æ š÷ÓþÁ ©qœ”@Ïq‡ÕŒ–f4~þ…Z.hAÂ;‰H<W^N BB;ÕÖ½Šå „Øn¯î[(‰¸©%B‹Ç(Zխ骑²Q»¥¤ ¤½´Þë“,2>¤_�f„FàÔª´¨c0ñéYXi„BÕÁ|Ò+}Ø:¢xàfb®jmgÜ< cúÅt= KGóŽÐ Âü#c$Žåñ,0oh»vÖÑšAa˜º>û ƉvLô­bêèQ3©Õó¦—ÔT†'lYß7”•0›+¦áN«åéh;]ùó †˜%L{—ý!€Ì:#€Ð_˜$ {Uã(¤3.öƒír'ÝÙ£œNZóÎ+º¯ ÔÎÓ‡3¶©,µWe!0Îv¨L•âÀ·}˜Ô´V0Ý®MÛ 5î&Õömغ¡¦ûVZåî‚|aÈyÁ©ÆÛðEÞF¹E,‚`+»ÛrˆbÍ‚Äÿš¡Ó…È Þ †h!¨^¶m<íxô£|Š ¬£b^‡ÓÈÚg– í„£iѣɺº(| kƒï3GÄfÁåÑW~†7 œ{Ø'VNwš Ð)(Þ˜“®ôaý¾Õ1¢-’ »¤-†¢‘ N%Æû–I¼«œ*8vy*fëHõ¶Pþ²YýÇ×êä*‚|E5X'Iž›5åž.©(åx(ÊW”WÆ=¬ÑÆo…éQ=;­wEè©°2"?ÀIüqãÕöcRZ‹kÈßBzbö“gKëO«<ÿù(oeg OßÜ£½>,B?€@pé»R+S�pÆŠ¹òÙÙGmpŸxÓäQê4VìשÝ) å-DÍ,_Èyœ»#n{[îzbÙìL| 0ƒ€|L|=Kè<³è„=Îz>óùß7,Þ·¹êêã|ç7ªçd½ (ÕÏàÔèe6uÛaòn ¬Cû­Kñ©Zoùà§cWÐ[íöOíðd9l½š¹féB‘èƒ8(ç­E7ˆ2[áL¼¬DEžèOÊ3C`´ŠFi‘ÑŠÜ7–îÿ4+vÉbeË܆ϓmªN’�Éo°Žö±Q1›>Ê nj×ÞB!£Aú¯¤¬<ﻇv #_ cÿ L·‡‹‡ ñ]çY¨5ÕšÌÁƒV¼A”ݪ7¥ÅBö/C $Sïl7™.mU 2áL�ï—¾}ùw7ÍÆÌ ebJ«hüT|OUÜ×ìÅÌ™q¼Ž$\æZT<+:YúÑ“õÅÈQ ïÍ@RÅJ'?zBÚöKÐ|ÌIP|ŸÝn8e4ì!µ@•§ ôÜ«Ì}„–¸|T0ùðõªOŽÀ±£d×ö-ªnæÁÇ3¯|ç ãߨôûVE÷ ø2r÷H&Xl¾|öaº=%Ìö"Lh«wéT0Lú»ìÄ[3ŠÜBE0.ì0Q`h¼)·Yº²†õFúLOÎÚÅjƼëå§ ‘üãáä¶CÎùuvƒÝNB®cz€^O`p¡5h›BFž6†¼+Êí»)[âr7NÎê®Cõ]û%¶Ì±¸ùÍö8q‚µÐKN¼"•EГŽ6ï̪Œm.ίüC}<럛8í¬Œîü€tCÕ0ä¨4˜]KµûÜEÔÇ(²´ÿ¶£¿`Ç›¡¨ÎHìV<Ÿ6›ßxL:s‚•'E–´“ƒ�£3Q·-n@ÀBb}+Œö_¨Í檈ª_7¿‰1ç”,ÝãV¼l!¶ògÜ<M‚û°õÚ»üÚ¾ºè$ñE±ÃT1ø¬sÌL[ÖQ¬ß=_UöäÙ#îû¸<üYâ+5bq¤·îUü4sÚNâþ“ÜñBÕ'w*ÂìCƒÒbE_V‹•é°×j`’ó"ÙØ#Ûž¼ð,H$XbÝŽ¸u|È=—´àGxWè9 «ä "ù§ÅÑ£ý²Û÷­µú’y¤™~6e~ONÆ›ÇR,»Ãfm鮞À{üÝ)ìSZå§ZC´ŠÄ„É*¼à“ÒÑ„BÆ•’ «œcsÒÁT1oKõ!*Ùƒô-n­Ý\¼®c?ŠD¢9‹©ì†)Üèuã=ÿ}ÕÆMîÉÅÊ´Ñ&šÉõit  ö»g2ÑOôÉHEøDŽ"„rJ¡ºž<£/˜s¸I =ïYzÞÞåC]Oµ|7ÄÌewÉ€Òb?~™FØ®=´�2 Ì ©¨²:nâtîÍt¹eÒöy~Žž8+‹£’ŒæÔÏ–,&•"jP³÷nŽØéÕáñ…æ¸Ñù*†‡ÈŸœãòŒùʼnc ¬,3†¾�D!WÕ‹0oÛú 1orâK èŽÜ@`#ÿìÑêЋ;–Aa¾ò=q`c¹Ëƒ¨ï}Ù~ôåX`¬ƒ“mCÑÈ�>¼K»!¥¤.¥™O£É¢Ö„_ ãi‰õm‹ÎÜ@Øé®L?Ëm»¢š{”XÚ(HêoŸ;ìf݆ËÐ1,æÀ³è­6›Yl‡{ø?×Q4#lÿEó§L}dD|w¼´üp [”5½,mmä[%<ë»j5ižºÃèitÿí)ŠîÙ÷PûÛÓ\ ]˵õÆàÖ°0LC?ßbvUdß:²‡ý±ñZd�·S#‘‡h}Wë9´Öw“se¢U²…:UJi+!góKË®Ü(V¹Í<½šUÔ´éÚw¹Köy>)ŒI½.-ÞŸæVú�1òÛºÙi­“h œÁ;·µˆƒÄ7 …aýÑRóô'&´ø³LÉFŠ?E£#×ba>l*Ã2¿o;Fç{éQµXº¹A4Ì:,Id ™Þ]8LjâIÿA×\ƒ× —2ŠjCOÏ#OUÎCCŽQˆHÒK´:ì’òHoûJ†=õ„+eýåt, Š0])CÛÚEÝîì'm×Ý VËj„TsäÖù"ÖT‚Û˜wÞœ¾Þá>®bUºÑ/óœús¬Þw`R¼îÒ?håß7!ŽŠÜL" ³yЦÈÛO5{b‘“Ñ“7.Q⹎‰òÏ= ydb ½ó9ƒ¢–ã^ÕÌ*üÎv^Ùvì6~å.˜û®¥a&YâûÖ˜iÿaòÈwíqL¼#æ+ÈL ghË f žqÿK/ž¯Ïf9ÎRŸþb<±RÙÑÒ@•×;ª«"+Ï΂w~wç¹þ®kªü=€‚{#¡-‚—å ð¡ÿ`$(|Íž!»MƒøS! P4=œúñhÕÁ^ÙÌJ/­�³O·ø]ó lÊmÍm+V^?nŒröhïl$S²ú·ÛHÛohÖ¸|lÊ„±0÷½0© Øw?èŸ$‘߶§›v5h(® ØUÆ�éúÏóaQWmª£0Ž-V ﱋæuo‡ö<¹ùðk¶«È¤�<ÓÅ݇§AW¹‚–âTÕ_Ë ò?˜ÉÜú s‚ÅÖK«wâàfŒÿQd}!Í´Â:¦ÃÞZs¢býª¬‡Þuõó|€]?§º¡»Xœ{';‚ã×ð{Ú{¬fV"v”b£#´Ýqزr›Ð`Cƒ†,WH)�ŽÚâx`ÏcO2iVÛÖ³û<Á© íö*t0¤S/ûM_œžQäéý†ŽHá¹Ñô;Ç¢µeÇ~?Õ×C §ã ÐûÀnÎzC¥UÔ]Qâpê|«` ê!Dö¶¡)3`—ÖqCˉnDS½­/0®ƒÅ˽_ùßJ›–uM1ÕjV#©½¾K6¿ ªõZϱݥš¨_¦I]”™"4j÷­,ßþy uNº¶Ò;rÐäGòƒÆ†¥ok;>^A3,ï|!CEŠ:™ŠEMÒÔoÑ>hú2ˆ¬ü0RºùçñâäŽZ†Æ=ð—åúxáš?ÇtºË,¯6sBËOM<i·˜Øh–?Ÿ¥‹-TÕkHLßh8é`žÞcö“«K 3ØžÐ×hu %œ|Àþ“…kŒ_ÖÐ÷ÀÁö€=…+ßr•E¥ÑEõD]d”]ktÜi9íÁ»{ypsÞîÝ"Ó†ýŽçNUü9;0ã*<3,X û™ ϵ}jm­|¿„­iÃ[°|Ám{!â(øã¾ÕÒkœr¼yÄôað\x·TEvÃn¯TÛq*¦¯d`m>×ÆP ÃÈC‹âÛ•Ó˜­ ¤e‰mÓº¢,Cê$ójZbLkýÿ¶…­¥eÔyIY°6m'¦§ à£ôÌøPUíGN´5(¯4 ½¸v¸J3Ÿ „în–²Ô˜›è³Ü°S14Rí¬/f¯î„ðUáš`¶|¢<{øÖ)<¢éÐíÓѬÖOE‰B°J‚£x]£ ó +Í6Wã×¾~öPyæ®'×pƒétª“*s¥­FÛâo:_pßÌaq¨Ø®RFk‹¼hš/R¤Œ=ŠÝèµq¶”Ùo­rïF�aÚ{eìÀ(ÑMf„ÆlvEQJ ! TYÆZkßÃ89Â…Z·³Þúi딀¥Y¦²B¿RZ·yùª02±ÓÒÜÑ*ÕQbM FP¨+m*æ›ù—ÆØ…·2ÜdÀA3Ký/ñ÷þ¬ÿ‡²tU†©§¥žC¤mç)3Òt3XóÑ«å½ejŸëWdŽ©'äC¹K¨ïjŸæpôYi¯ª¨çIêy¥D°Œ¢ÏœVêEY"Ë¥´ÁÁ{^5‰ ³•õpW>"4óMmF=©lÌyO¼¤_tÇ"OÂT(äu•E¥™h ™Dú¼KfÑ]£¥Û7ûÁwZ¶¸n–r˜çA´±i>ÇËgt~a†Ú8ñÏPÊ*´�òwo0±ÞU³-Ö·âvþ‹YµbÄ@äÊ nG PB ¯»pÄÑ¢c‚9ݸ Êβ¨h×±ª×Ô/ÈgN^Û"±¶hØ8*os÷k› ýV¨Í~à̤$Q“jç¡â;þœ/Óq‹Î{_ã]Ì«¼•¾‡ª  iMÛü¾hÏ"«*€AŒÂ0;bH<}UÓ˜Êy=HÙi«ž¨šo´ÏüA üÂ×)¥Çx©ºåÔþÊWåó¬¹Ðy–Ì[Ï!hè€5‰=4”…·üé)Ä+õ]@b~2¡þcìç ³¦·4S^àªx´¥UŒiü\—é"3aëá(Húg|€E7+cBQ'ׯþ¢Ë 7‚‡¨¼Á ì=Ç8°£jÈZ*xfà®™„¯V¾O ݺ6RëuÜPmêت¼ O[øEå¬tåë™Pp+*ÃÏm‘$åFâêÄî²Q®~œZJ½VøQ7Ž=ýeÖºšÎÌbQ*(à°ÂÁ9²yþ©—ÑÜk”?“�-¬}#Éla–­‚¢=JÀ˜ëê£U‰­ê‚]¶©FÛO•6êÝnê*õM÷Øn•uã áo ìö=?bO­ñog¦Í’o;åâ@D½q]šÇžðßáñž™÷ÿÐî·ŠÜ´U§ŽÎŽ¾rÆ–ÀŠŒ-" Ž9–¼ÿ‚yùÊ÷(ˆCL Ó`E÷Hîóc$PQ´A€ÑÀØ­ó„‘o$’³pqPƒtxN‚Ìy—@÷nÝU¢Çšr÷ãîûÓÄ–âë5Ÿ).„µ5{{¨­BÔgß3nʼmlj³§e‹ìŠv*­t‹NˆBm¼Zú0Š„6“µÔ·v¶+²Û $BÐ’[Ÿ€l›=ŽOT ÓtÄÿch«å»Ç¥c3­¸Ÿ´«v¿«dí04zͺCÊ++^90X‹7¨õw{jçZˆµ8¢wt‡Vƒ¥bÝ6ã|n/?o›ÈöD¥S> âo{œÑF¤s2OxfÕy’ráwÌø¸\»$tBÒZ‡ÖJ/è¼0¯Œ‚ “úòØŸ¤žHå`ÝS­¶Ýy'òy׶ݙm~&«6ûH¤MôG•“}çwœî-SöëÞ7í-…Ж¹ÝÄpF®ºzï-kÎùÐzvÕå ñv^‘å~W‘îÛáƒÒœU»ñ@”pTŽV@%3†jÛ·,�õl´­<_"î  Ë•4³§øòµ_ÓÙW&JòÖ–~Ÿ@¶„‚ᰠƆH~kÂRz~ ¼ Ö爭Ec›Y0‹S!µÕ—é¬ÇöÜþ�´Ë…Rp”‰ºXØ«þÝ'Ó;æ šƒ¢ýíb á_™á¥~+³*4V#V^òeMÀ<J}KÚ_X:ïNenÞ¾ó™TuÕM@sCÄ ÷FiÉpÂ(3/ÛÆêè­çÙ jî)<RõçšÞŽ¬2öÕ÷Yºô‘Écű’—ÈŒp‚õ—rJ±Ûdàò±+ƒrL‹ gØAôTµå@»Ù5ÞÏ ¹ŸÎºKöÆ)™�eG«²N¦#&ÃL677jí ü¾ýÅ«¥Æ°*̺CuT™/ÓŒtп¤d¹¤ xEáÊÆÞ‹Á¼ ²sãé'HCÿKW´,_ÀŒM–Ö[-¢ÓÊ’wï‚3î&U7èߊ÷³çKj»’·Bö‚¤\›MГÑâ�ÇK£³¹^¿¡þZK­g­(^Â{Q+S1ž·½'‘·®(w<AY d´ŠÒéH…Õpîº]Ûíƒ-ÎϦ±¯H"#G”bÌH7QðKZ§ß ¾;¬àÀ¥œ¡„yÔµ-D¨ùß›Éi»]à †óÀÅÑŠ—æBl©Ì-»ŠÅ, Añ å[.ú‹+øiÅA4©_<'Žû‘ùmlØü[3­0,}7X»vqµß®„ ‚ÿBƒÔÐ]LóV/,Òïá/˜Y”.Å'Úo¤#Ÿº]�ëd{nƒáðÆ*Ü€e°ž)ÙÉÒúÊÍ)Jcï3C =:Y÷ B‡tæTÚ6Ug>÷=c”8f(ÚÜ_<ÃK³ÉOãaºj’=oqÚLÀQPzú¶6B+/0`ºcc ¤?N^cçÜ+ýHÿ“•Y ÅÂù`Á€m+åC»ÝO좱p>¾…Ò±bÜèÁS¨f?´¤‘OxÙ HL}®?<’Å^_&Î0°'…!sôf÷;§öšzŠÁ3•0½<e¾Të=]8ÙÊ·ZÁI²Oå‘B‹öPË­Ók<sµ¢2sH‚ÝwÆ…š£¹Í‚‹µÚõåͦø‹Ÿ©º”‰cS—h0ð5«ì|GqEµ.ÙÈù8ûuØ×ù¤™$6ýä‚{á—¶Ì5ðiÈ(›ªç^Ž°)¹�a…{n¤ræ!qÖÒEÛÆÃ`¢IZvÉyE”Ùzý¬ïêZJßóêäñ?mÒoyeïðT¾oóT<J∽W”®Ï9ƒ)Vü7Oý~~ 9øò<¤jÞ6 Mˤ‘·}ßœè;îé”0çšþO5 éÈËlp— å<Q6׫b{.ÞÑäþg“ãò¢0?¸×ëÇç+!G† ›…mÄ1¡V�^·c»vA‡÷µn¤‘`èz¼  £…>iÑrvƒZòL›ÕL2Äó.g˜N¡%ö ­»FÅC)%y·iB |ú©S[±_¨¤Ä‘ b"V4á­m"G«’‹¥„mŒ}cÉÕ÷â<Z¸ à !÷¤"®ªÑï‹54i`>RF£¸îöF-ó”Åxñ ˜E-\:ï´ip|ì!¡d/-›¦koõì'Ͼ#VmAÅdž…t×¾§ð¥Èø3UÇÁ¡1¼«[Q…<Km²Æ­ X”–µú2‡Ð’›Yž\ñ¿Ïª¬9llZïg¨Ž–ïŸ:µ Y„pÜOª~ÛžQÕtí?B™îüæµAºZ]Uøsƒ)í7' ötKf 3[:mOœ¼ÿ�±ðÏ|¦äöçmåWä»#ToÓz6¨b`òQ"ºþæ˦~Ii­ÑEþüðA©V¶m´ˆ(Å}»Õ~’é§F2ÿúÕ Ê<û6²éN0 óÔˆM’úIÛõéÏ o~!¸Å_¹ú“Yì&× ¶ÍpÄLüT;_�ä)2C0¼©Kcþynæ Ÿ+n _¾ž­ æTÆfÏ2ÑiØB Š|æ wO[EQ‘&æüâŒabب†SõçDqUErÿû––VÚZ­Z†ÒõËÏ}$B¨N²–.•P|Êx„k†S• ÅdäBÇ„91ÜÕÃt1Ìu)…Æö»™©¬©/^{òKÖ´!z(ãÜš’E/x_«ƒº¯ü:aÛ˜Á²%Öµuý¢¹:s³Ýš\VÝLáU´ÒjÁŒf#TŠ!ûµo¥v-ÕÐm#I–…õ¤Éé ¹plDì9—´³óœ££îԛŻã¬Í\«Ç*Ø\Ò ž|j?Õ”2þ×´Z=ÿÈBqN�_ ñqWˆ±ß„¦GÐö!ã…Œ\knD>,Ô$�ׯwN+ß2‰îÊnH‚x=¸zwü¶’ÅÐHf3¾vyýˆ²i»`Qh" JÞ{³yƹLÏwš…Ù«ÊA+uâ–?Bt±`qrgº7b²×ó|$¶èœHij8a×UÚf«ª¡Ó÷4Ž”f‚læù²Ô¯»u÷«²N² 2ô ×ç2ÈÙ‘÷1$ׇÇ7àzìïÀs™Wh|šn L£ x6]ߎֺÄT ÍÈ£Øò¡T¥åWpUö:‹¿Ú9ËÊ’¬~²:Ë}3cæip”:UWó Èêä ¾ÄüõÕ—%N—³Ê ®s¶Ã32]Ç3óÁÖü)ßЙárb ’¥Pq)·£´lMË€vÀ‘ÑuÍ5½ÍRäU·«;Åt¿}ù"¦nUßävbÜŸ÷/&ö¥Ãs1T®‡¸i¾S'’Œ}£¹wbIæ¿ÒôQ¼¹úAÜ{ ” ¬k í2ßDú‰•ôÊG•§Áz“a\jm©Á¹ßv•_ãFi8v°ÚÙÓÿ•Spðºÿ[芇–6‚‡*>£©ñ¯‰Ø�^)¶/ñ>£qù’Ü¡xt†•ÎaL½Ýwsòs+ŠRƒ9ªšžéɺî¤Ù;5ynÀçî\½þÖPpkýÖϲÄT±yŒÝ§7¨ 2þÃÓÁÔ>F…¦o^Ȉc¸²ë1o´ñ&€šÇ³Y±´®¸Q€™f[Ýå  lXc–Ç•ªgœ–òé¡ùMÁí|yâwäøcÎûæ´ÞOoEËß5=°O±+fš!Uç©í1æ´Ù$äeEJàw`Éî?óÞ#à ebA×À!tã‘ajp¯ß¾NºGà'ü…,½*ø·(œä�—›»!¤óe´T·%XúÅÕ¥3V¸w®ŒFèiýq} ;ÑCÉHyØ8cJÄêjô ‚Gã@q‡÷ì‚i©œÃ)Hv OŠ2ãÛ±âEáKzõaQF©B¡(ÀkR8œ µXž*‚HqPq0]š^Ó£—ó®0[ ¬”´¤A¶©}X„U§Á¡ƒX'}ݨJ¬x¶L‚t»u@_Ø?c_gTpF3‚äà0J|•ʈm$ß­ƒ†4Õao+1§µ¯×Š ¡ŠŒË™»Ê週þóÝ›$Y#Æ%ÓÚu%ýëÛc&N]§@‚y>ëLŸöl%Ì^hÆö [3e{øðýäÙ·Pzióåã &™ß\§4èoU£Y‘h Ð2>TrÂP(¦æ•í×’xŒ/”…'C‚½2]Ü¢,‚`[ÂR”Yè‹3ŸÐó¢·¢uIåéÎ-G>u욉5!¥ •w<ó»ö-ŽÏ»ù”&Ì"]NÏx<dAj%à’LÌ Å¢»¾5/jº§™Ó´áÖr>SlUÛ8o£}´Ž,EÈu×>e´–‹6–À£ °åhÆú¶ bøÒ¿Ï�i²ò%}ØÇ:¦à®Ò (W¦v¤Ý¹Ïr8Ý ºÔLQ:}ÌP§õ’œ;Ï„óó™áÑqŽBn3{WðCíYó\'HYîq„[ƒz0Ë0ÖÖ=·Ó~ðÏ…Há{OCˆu›Y¥“�èVòÃÌ‹æ—†D&<GcEÊ$•ñnQèM[ú-•Grœÿ÷ç˜ðbÆ»m5r¹ì¤WnDXòÕUS~ÊWA2|únÇ‘,Ñ0ÇíYÄ.Oè})Ñ€ç(ªÑëtw'†™v“§"C±†Ys¿Du„‘矂ÑiÐôq$V;8w­ÅôPšg’ox&[L¨Àä5{õö÷‚#íR­Ù°dSk#CÃP6‰:úÜ“8o?^°a–¤ú” èò'ãÆJX¬¸U×%ª2f£ôOw¥®ü‚ýÖ Ã8ñ<‚醱\QóirOWüµçÛ䋨¬`Éâ¿–,¢ê#‹…º‰NelòæÝé9RÝPï-Ÿ>57Q°Æ¼ÐœŒR/„gæ@çzùyq‚2#þ-¿z¼Ò©kòËúx¨ï¥›IžzŽ!ÂÆåcç´ŸeØkª‹SWóðÆFéGÎ0a±30 ”i¯n<Ó\mÍ’y†¼Ñ×;6pænä/dÁœ�›lQDåÔj<'BŽ�‘qÿål3÷pU”nÑF{>³Û c½n£óñp§ÿù„ñnÓýØ89ô=Ýÿ­ŠèÆ=ú¶§¢¡Þ›Ñù_Âö¬e˜›êb{Š)ÝéüOÎ6ýü÷- Ààäóª Fw1pBJ®-–|¦,m+ËóXÒòR w05y[ÙøñÈòÖ;ïŠV/åaH©¯Y8Yäf‘h-¤ÌÆŠ<®ôyo³ê–IÎ:)±EP®ß:Ø!èa¦˜—–Ûò康ðÀ ±„¦,ˆ*KO ¸vÐp*Á¬ߟý½«»³±¨ô¶\†ð:U´îóQñΔ ^(êæî|¡³›BY·¯NoU; Ê–CZ°¦l§Ùo¡Šç]RÒˆŒÔ8#è$TY·3¤¦ÿûÉÑuš£X�éëáصZ`[jA‘¸Ëón4›Š¶sszÏïR!~/¬œæ‡’«³,ˆß+)¨€&‰¦2©2t[Öic´�ßø¿ëG…®ÜLÞw[$Â'ËÚïœTjF©H²£„ ÖÐ< >ò1å®n+8 Ä Uö ˆË£Ë€QÎÝ æª;5ÐMWwÃûMê8öÝ �˜íã ÔbŸdÁß úýΆTùNZ¦‹nXƒ%¥´VçSØ–ÎQ¡ þ¦üÌ<…´BXØ"kp.eà‘­Íþ6k`ùrÛËL=ÙfšÂ.qNÓ+¶ƒ®¡~c4£¹#ò’?\ªy€t;ÔÒ¦ø¶Ó1$b'˜;ݵõ©‘ó•Œ6‰<F^$Ò1´uzÂi¿d‡füú£8qت}ËC[E7XhUÂdLÊOp¾KYí¥Œ”ÇýÎGâTgyÙo)3ZMÖ*ÂÈÄìKiª�˜QÒ…cš½ô`çÌrZ7ƒ±¨X"DY2¦Å¢Ì•wýpÚBÐH >"?‚+Î8—/~pSáÐAXãž²6Üpk~ÎIõË7c MQ| ?ß‘ }7´…�% 7ëTÍpÞE¬ðøö~Üõ΂€Ã›¾>NƒÕ(ëõtÌtï]®ê\ÓžazŽÎ0Æ O-~ÃÌëÛ°ÞšnMò>{-žÎ¨uÞžî.Šy}´CÃл=\ÖIÊ™®;»¬ü¤Ü:øúª{Õª"õ„fØ×bhÙÆÞ°/njçŸ8`aê‘ù8A?@Ù²ò8e‰V;ptÿ£V¼£� p³;Áq²÷F•¹3q3VÓáZXä®ÛâËè¡B‡Âô«Ø ²ÿ¶š~?7N­¬Ahºxìt¶²î’¡ ¤cèUZÓÀ³xdZÁ@€*#)±©·GS"Ÿîý_™ƒ¿ÃðåN_2òÙ&°‚g wÝûÑ rßdžj¶j6{ó÷BÙÊ7è•a:áj5r£ü'hÕSþÜ$4©ßýF@èM¸ãEÛT˜fZÖB¦fsm«úþÀú=A fÉ•CØüIµÎ4Z8[ñ´Öa Ó>ŽŸ'ñsÒ×…½“…Èä,­ÉUs�‰æ®>þ8Ê·m{·­¹ßp€ê^TÏ´'E˜�ÎT¡tò¼ÐݤòÍdP³º°Y˯^QÈ.”Ðc¦ù—A\)#?c2n=Ø)ïz·wiè~á¤aS«¨X(¸rëªÒÏ?OÔöí@ °„؉ŽIôNæßeºæâ*#Jéam;ŠþQ¥Ê#´ý>Œ.…¤t\¨ÐÍå€&âS‰ÕÞ/Ìœf]c¼·½˜~âÐ<œ«x¬¹j³yÉwС?t²Ôá·Öo–dQ3Hþ½u-ˆe,HÛ#îÒ[}ái+GwÉåôbù ’…†­}:¦Ó µ¢KÃX{ô7N*@A6ÜÂV‰½îêù!Æ>eÍxCÀìÌ¢} þÏLr #ÿjvk=koQdÄ`ê)Ì|š™®«}g‰\¿PŽS_ȘʋŽò¡rÚ9¦¬©¡­œš¶“wrW=­a|‹E»ßç¢2ì`ÊÁwîœJ€!7èðð¥®pt=>œŽt[ ;¸eÛßæÔµ”™(Éocº5¯\c‚æ“8@ ßÐA׶’:³'¡D÷©­ÿR¬—%£lá·B $¸bøtÜ×vúP\ÏÄéŸ1-@d'ìï^óÝñò3žmO´9ÊӨؕ‚ƬR3̦Ãé_cdÅBþ{ù*;vÌÝ­qç)«Ž†wÈ÷™+Á:\½=_x)ò¤«9¦RM‰¦£ÔÂ’Û"Ì‘Âl*°L§v²©ì_ånn´ÄI}€ã7t*>…ÒªMõ¹áÝÊrª+Q“ÂéĥђÿlmIň[?ÀÍbÑ„ré¡L¥â¥ànØnPP3\b­+Ú”h1\üK£ ææ´dí(EÙÔ&œƒÝsz'–c¨�"3aŽm´Õ•(rÿÒO¼ÔÖ“©[µõ†7ù&ŠÇa<v{çÏ}Máº#ŸYF¾eKqÆAÁÊÅšoN”Ù¢ "HâÓØì'Öd¹~?ŠÇx>U,ôÌA8(V\#>} Í–YP<²â®ô`Ï=ßmõW»Jäona§ÑêfX™ånöิ·xÿºq˜”¾�¥¤—#m»è{°‰/�@P®Æ!f&R¬|‹p—•ð‰Ü*ÏU”MØÜWC¬!Þß^\Wpy³¶"‘8$æ•.wtA°¬‘b +=ïÚ%†+gˆ aµ9qôr˜r]<¡³{çš»Z ÷ä+¿å‹¸m”óàQ’(æ¸÷‡6�ä¶8ã××WF¸Iá°XÁ4¦AâIâÀœwbo/BÏA7N–-©ÂJË4{­æ±úžÛÆôÔű˜+ƒt®§mËÑåvÐA7;HOºÿg: í)m·Ú#àêG7yª'a~ßùK§ R)Qsמº£Î¿ð ªE.½É=úæÎ-QWŠô7˜.´B­‘vPmºïzëwc{ìÙÝK¾ë•iø=^Û“ÿ$4R ËŸf”‰U»•f‰¹UÜ›âíïOüçî*Ô$d…®äÚ¬§Û¦£r€ÎHº¡Gnzi¡9n˜™P9](ëíÿx¤*¶ìXèÜü{cžçƒÖwî±h{ (Üì<®EW˜?«æýT‰ ­¾Þ¿«•/f œ^EÉO4mܬÝ0(´žÖÆw­º)㣞’Ç­óʨ.tqÆ6§T¾>ŽUç Ó?äÐÎ956Ôeg] Õ‘]ãcÔŸ*Ž†¾D ƒ…‚ÁËê43`Mm†™Žpä™6ŸÈ#Ø&:â:胺üé…¾=CZxy>½"ïÔ÷Îèy;V—‰þ(ߨQí¸Pé¢Ý�§Ò"XMÚ9Ëjê‹7 À "½ü¡³šMVn+I}¿Oà~°S‚e"éJ{„n ç.Õ|årñÃÔ"ʽ©P”æÇ,ZÀ97|3�F7V:Z1r8‚�­éj!i‰’…–v2üÑ7»DÌ3­-k–÷p@kñI±¡þqEÛ»iÅV¬”µ?1óE? )¶ž°±S–݉¹<ò)g:‘äÖhKÅHSÆ•êÔЖÀ4xˆÈæL ùyÊLω•Â ::'¬mrl#¦W÷>f~ÇœõÌèÁu'OgÙÚ¾«G¬–¼$ž…0n2…8£x{ˆpäÃÆoO€¦=©”óiÜ.¡'Ô&R¯ÜãYH×úøÝøF" ¦{^+ç±eÏøG¯PË|1z›zGiIga|2B¬áü¨Þ*œ œÿ•kú#aêÕªt‹æ = ò8àÖŠ[á¼þØbÕ¿¼«XiÍ¡¥Ž€ž1XEûÇË!Њìm& mµn¹Qô XºµÍÄõ gÞݧ³™h;¸!E°¡Œ™ˆ¨GU>¢ƒÙÅ ÝÛô]ÅzĶ†Òï‘7*( z=÷þ7éßâN.¼BºçV¥ @JQiÊèøÙ eg'ÙŽÇÎ`3)WXí»•6ðòV]©„߃»ÑÆà%Aõh•úbßHo&z€ï:XÅl§Þ±ò}ñðéØþÐ šâ›SZùègžµ¹6þy!Bå«h¬ Z*ÐC'òéÀFÁ<QàK·Z4#/AœÒn4U­,²]»ù0Ü&º–3ïÒöãä.I§ìcÙyvxþ†Ö5z†„ˆÅ)Dy°5䢶‹"?s+§}bü~Z‹È“qsÜw®¿öüyàý“, «+‰ÑMh{óÒŸÑ]ß~3Vgù¢B5q²°˜‚Ìè‘îu±³ó÷Ì Ê5R±Â¢°00å‹n=µšN˜ø]ùaÌî?B¸À4áii÷ªhZèͯ2œ ,•UöïžÒvµŸ.V0òU©¬HÝ"Wô#‡Ñü}“j³Hl[‰ª}}ê·Õå1ÖÑ+ÍD•·™“ w°VΫKp)gîšaù#™<Šý¹=ÅF[à£û˱™î»5Kù=J0M½æ/ÛýLP[‹ó Áº¯†ÿ3ÝbKd3"ï%à¬1¾ü?­Ç¡í̆Ç^bìØzt™®üw„rõNb¶mR¯O˜èk¢sD»€NÓ¾¹N¶£…ûÃJ0žñ éú¨œ;ÑCqÙ6§™.÷yë'vrefÙU$ýwÄÐ~»¼mÆ#÷QikVçÖ{°ðªx¯ö;¿á6›Ï±¡›Ò² ì{W™IÏTÃHÃ&°“tW?ëV¤‘KëÅîw½É(;OØ�ê{몧€ Üa%ÞßÐPËÔ'ýRº@o˜u€…%sØSn#§¤è�+Úù1ê9]-l}A~Ù! ²Ö ˜ÙÎ{žõ˜£ùyð¶G¡ÈxäHQød¤ªO¸´ë�¹–C–—ëä!M›ÍrR.@ódŸŸ:愾 €º¸oz¥q¾ZÇHŠÕ­v*r·­([„w´‘?Võã48Rá1U×LÀ'Rÿ±bÔD+5„û3íðì4x…ðñ̃RAÉ;~ïØ^SˆQOáÝalÌ<» í ¾°• q¤QÐÿP̬eœgHjæѸù:o‹7¤Çr˯=/g(¹Ïº¢ðš1DK…YÅŠA›¬,9²w¹>"m´>¡À¯ì J¦5Ü[§” Fm®­yiÏžê/Ú¿jó Â,˜c`Æ5 ®ŸfÂ+÷P§t˜{öS¦Œ8ÂñËjNŸ…¥‹ãþ­”S¨2xáJ¥¦"X}.ºz¶ÌÐíÓFúÍŸ‰£Ü„_%Ó5Ú>»o“B¡Qxªê0BgÄüÃXVK~^ʇÌjÆ‘0%Mý:Ñv­(ý§ÁæA(KضŽ ÙâýÝ+d뱡²'…kZ•oIái×€¦ÝÙxUå¿wµ cýÇ4ëĽN­ ½òN%eçÏÚ-Vàh’:¯‚ëX1k±_²txèñŠáMv¥œ€‹ßÏf¬»_³Ê“j…qª•hVíÊ꣫ú,A²¬fCó`Ñsÿ>yÈçÝQb ¼È(å¡+t/„= 6žJ:kÙ,ˆŸÞ9ØRÕï짖² o:íX°ô•Š?E".¨gh…y]ZZ—ª¯„Ë‘Vj9ªd�=7Ø8­2 çô¦ ˆ‡ë:ð±ø5ï´Ö± ­unx…:c­¹hÔþ¯´Öm7>2µÓpDsêsrÑ•îÖl±¯˜¸„ž÷�r·]è3ÌY^µoN{‹ qت/æZ–•Èá[ åìé•1uo¿0ÔþIá+Ž¢ÔcßBd€_ÅV%ˆP6ñ@!ª]ï6•š°QŽLÌ"–gªÆª¶·¯> 23°üi‹•Ùk T€~šœAæC³l|éVýaÔ”VZ̤Lé¼™ߊÛ=W¹Kâ‚“ÕÛÊ ¼¨A&z7]uö§ýœ[í £s+½àœY!%¼¡ó ßnuy³šÔ…!‘Îà“[[OU­­G¯adg\•–—ÉYçÑ×s„±’:/£Q]SÏyZ îi'‚6Ü »�nµó“Qa(Çb"Éh®¼ŠŽØh»ü8œHõ‡:e›è¿/[?ø໫Ïk8±£¨yypÃ([è—e0h¢4~PGáâVÑô‘ŸóâsÈjõ \CB"¿½1)à’“kÛVÒuŸ[TР»Ýà&WƪäøMŸ3›f¯1¶«ÎÓ½ìj7¸ =²@Uc½Aþ?H¶•«&Ð:ÝQ Ü£fÆ.À~£\¯Ñ—;Ñ+ìT$A=Äš¡å§…¿®Ð:Ý"öê {hšáÑÖkª¡Vœ{K(-! »Úµžæki?h#ùc_Ÿt¼Þ•gúÁ‘­ïù”ã2ÿim{’‰Ôt¤vݯ¤þc›®q²€%‘ceµ(SÑ´è¬ ¸üdµ‡õÒò5äˆ*›h#Ñßu^ËÍ-Š'€æ//a™ãdá*%A×Ãvwò–oU×p@Å:cC9óÞ玾+7=mŒþSPPÕœ$V„k_M ú¿s›×Õ¡iû'"å+uùë)X¤£Ê d+µ˜M2í.߀ 6m»—H&rÛ唎Áw Ò³bÿQèPá:½­«fC4YQ- ºÞ¾7ÿÊÍð.é¤ö`a<¡‡Jcâl 17¯µ–®wïü sÌ«¬/õ '9öé~›¡Í2€Õ¬º´`L"x¥/`ÍJƒïŽÎ}êã,â Ži¹tö­WÜøAæ5UQñEPžúæ«’>#Å=[¨�(ù³ÊÁüß[ÕÕ¤ßüK½ºI8Ò…[(pW%e2ßæ@ñzÁ~×£¥àq2¶¬ ÿÔŸ‡Jð<õ`-ŽH ´žT,EADoŒsü¸uû£ÄÁ,ùémO&ê+‹³ 6§ñ¾ =v‰¯üy§Ý‘ê*Íhƒ6M®ì'vPÿ›>­î] ²ÿ]éšyá„ýâ»Ðó‹Ç"¬©*Ús˜I4/`P#ßœ=Z mMkçÄb&Ò;‚ Ü~# ìE 0œ§~Q%äÏIü·iëL¦xÀ¸í;n¥xY£Y—ceüx™Ç^qÏ~ 7G‹Þ‘ïîœÏŽÐıúCö2™'úÜå\¹?@7u­£Ÿ �´üsã]ÐìkÙÎîêÀé¦+Ï=GR ˜ùXùî‰2Éj!(KÁí?栗j.üÀÆê.}o‹tŸnçBy¹òe+iáŽpí¼Sªnû¶Ù¯gKó`ò@«–Äí¢i©RéÍ Y²®©Xˆ·g×{¶8iéC Õ D˜½cžú[˸PÑ_,ZÎ2ALZ¬eÁ@Ó#»ž‘!£G¸kûû—úW–?#}ˆÝÏJÓ8%*C/LcÄE¹†)øé,aæœ%@üKŸ>¼# Ù-.ì´…*Ò O^säìKˆ—<]Ú  K<ïÏn`ÅÈ6ݘ/±Ãóô*™¨Á‡JÚ³ŠÎ¬,_ÃÞ6ô¯›.w›/¡•ÔMÌ>\“ n+§®v27­ê(~Ø´Í]Ú!ó 6Û ¬øïÉ©@Ù–]®o¤m(Þ†'Õ›ûâÊ{ºòaðbù¡º9b8rÿn�`>žÍCµcßeyz§^]ðŒY6 XËp¶@}ðÞw§‹•µz¸d9×…F@z^|Î +®m_u“êèÜKÎïäé‘oÒ‘!-Y˜w•È>rC„±—±üÀà4ÀKŒŠÄK÷‚L§þ!a‡Bo?»HEÏzgÛ;ÇîÞ¿@a…~*;) Jc C%KýPd O‡[iA¨Ó®Ýȱã]Ýr¹bo¥‚ójÀz'ÛL ^ˆÌš(ØÁë½ØBrqRG2¦­ÿ8 *k M†š÷›ÙlìÃ:‚õ‰kÓÉäêxÖx@E­6t}¡Å#œ w©ý£dµZÊPôpÒjç¨<Ðý´N:9â€è4R†òòï®ù�¶²â%•uOùi¼QÒgÊcSߪ¿­¼}7I#tÏ+ÐZšúv]Èx1Ž¿+Ϲ^;ëEw=¦¤HßoYš…±tä}JŸc×xT»÷© oD|RAüúîPº€€š9¡V ¼‰Ò øÖÚ‘ ¶M¶H5@¦8Ê¿TÆ\彶=fi/Hªm>ýäÓ$ª®c»i«ãrÔº~’Iæ–½é6ðƒUŒ-¸¦gƒ‚8§úÚo ¤¾”ðö“âmOØm&|ŒøÉ3ŸÍ„Ñt³4md½*§YTv˜#2Þ¿-ÙlgÒ q G·u "”2›û»fæ ´Øôâc™t§bAlâ ܪÁã.Û€·m™qFgƒ¶DAËú¬–X…úí@†½‘âúØŸ•¯~£ ¢¯áB…Ê8u$Dþ¬9y†ž k!Þç퇪+ƒªŒ7 åz“µ:<—<æo lë;6ìÏ~ˆ€¾ÖIÜmßðQO³ñÑ×WnùÚº™ý»>á­.·ÒÌ€°/8œŒTêØ”ì8’· ­]6¡b+Ê-ºß9œ�¨Ì²8žÐx.úñŸ j…fÍXÊ£Þˆg:~ÇûWŽ.Íó8Æû›™wh[ÌRŒ¾¸Á#ýßÄîñ£ÕÍÁ›yéÝèÌB2Cé·$A4,V+BãÖ¬ºùômäp½RW¨çŽžþâ3^¨9€àÓÒmé¶UfØw,«É q}ú­1®‹¢Ðk‚2¬žè†ä\,ñÿ‹±ßxtv¬¯ý‹eÎÿÄ;³ š°0sÅý@õmú©ÎrÌÊ4xL;.¡Ý°8Eͨ±3³:èö·Íá$½ܳņÿ‰â̷у@[ô}ê(¡”tlº&§þÒ­/õ*]nnt,0ß·ž†.-ô·Ë¡½Ûv­»à fþõ\Ö¤ˆ`_åà#+åŠX$@õ£{}4P Ã|¯Ïè¢ ÏR¦ÙôÄÓ`)Áíhåß4«àgèµÞ€³óëËÕõÆ?«!ÆÑ•õ/Sš«ÙAp¯¬&^¡I'.‰LEj™r£Úê裷»Ÿ)åüšOìŒ$å:Z€µžCX€–§Q®â9­½°êtᇹ4t~ëJ‰é¥Ej ü Æ F`5Ðy—·ïö>$üî5ïŽAŠà¿¦Í]÷4dÉŽ‰RF;öJÑÔ z€%Ó¬\ñ½JéYÍ”­ü!%Šì¾Cؾ;2nwã{ŠÈÚëó¡«þοpÊ™‚Ö>ÓCHÇ‹IÞre±eí'Ó~ÎÝrÏÏ…:b%¬˜U‚( ®©VTŸOfgòj„jÄÑ-ðh•û~ôôÆ< «gà0² -TÚß^›‡ZF~B×zZ¸½¼éÒ>3ø¹1ò¬eâû³{ßÔÓÖ\]¯:2®O+°!Px—rHÝ7ñ& ÆÚSË@)Þ¨²é¾>ž¯=¤zÛñ±Ì™ŒÈ¥p\pùŽÕ‡—{\‘£ïRÃ,^@ž “ìžýÎÎ:ÐC¥ªhåµCJtÖ#ÕÓÍÅ›Öm ½¸£¥hX¥oYwW?®Çãå.û0,’Ô£-ão}Å9WœÑ-ˆLõ™GæŠñ#kðºßéo®Ì¿Â"²ºÒ›9~Sö³éÕ d×ré™è îxµÀn|PMj2ïòÑñÄ% ã ¾òž¨ÏR²‚Õ”HÇ{—f¹úßèê륹/óŒz‰‘µ|£XJùBÕ½1_„ý8çñ4áA ÀÔ]k®Usýî:w*ùŒøhvtèPb¸¿eu­»™÷¢;g㬛ä‘×¥xá¤E¸æ<ÒÛïj×ß:ŒûT`é2 ܲg×Ѻwu£êƒœ”NY)¶TT¬ònßUk݇¯É ¥NÑñ©¤ØQ‘u…-äaoí×~²h¯õa€~ØPºVTÌÔ¿©z!hàŒê/c»©ö'ë¯k+ÙCDLh‡´=íV—÷²¤£g™Y’n._n[C*­¯ênç/PÞ¦w†¹&^õYîÒ–ZËŸ®ÚB‰GO ÙµòÅi¥ø~lëáÈÊm:Ì ¾„b ôY‘*iïæEc7­¡ÀÝ@ßË錂o[Wô†£‘òÿÓµ@A½Ê‰xÔïý–*Ö¸îÌ3/ò:УާÔÿ³§è7í$²·å¤ã`䦊§j,6ÙÈôÅÁN:Jé“©$„†Ý¾2ìóˆNoOAdº]ÁQ´¯3EŽ‚n¢½6ì<´5¤)ÚyžDÊÒ€Ÿ"üìTL›vÃXi«ª!;u€UŽuÏ;V4ËÛ ;x/$’ÁäÜ\?=­šóþ ‡z”ŽmÃ(M@L!/ƒ`°lk]ƒ+\®)íõ¹ãÕðùÑž¥YFá»ÎøOÒ"9XhuÝ~ão)V,X¯šÈ±×ÌdŽéôA˲o<`Þš’Þõ¾µ‚¯/+¹ç…öäÈÀ:|;8f¢ù±ÿr`ÍÊx@ÇÄfès™Ý8÷†IìñÄ>ˆ.3¦o°µ¶]‚£&JãI5¦|_DH®1¹øžÇh¡“ŽÐPú‘6Zù®c$ì À•^æR•¸nIô S~®Ñ®~ôE¦R_ Óð#FV/æ¼þ»Ñ󇡥Õ÷ÕEjW•A6*g/•Æá ñÖ œCS¦æžû}¤µˆ Ò¼ñ¹l+ÓdÏ£¥Óô$ë¿‘"ʽøÉÌ%õƒ‡ ¿ì÷ HÁH‘oÁ ‰`{Já®õíi’ï‰çŠÀ * wh%QåZüvHÍhC•à:W´(Wu#íI@]§£r:wՅ͇œéùûs'±“ç!® ¦Ú« ø÷M9_* "¯å±¤`‚ f6¿;8?Ëà‰Ç³DyÚ‹Ð aÐù„†ä¾œ²¹pΞ¬\Æ0HÒ¿LýhǾ237 ‘Ð#Iäi.ðûÛ<H¶'sþAâoÃÞ’ªZWaùWÕvÂ(L}%¯8hZ kû›tèè@ç´îiψÔæ¹j8;žuôùHArAHÙÁo¢oaõJ"ôé#S¸1»ªê&pÆo^¯rŸråëRÐQuž`8fM±Ð@Q‘?{ú¦a¸r§TÉ%öùI}h™0Ù÷샄Á\îŒÞD·¿¾òËê,veµ¼o¶ âβ8TxI(/áÖeü™ßx/i a²ôÓ§Êvö”¸@+[ÌCcÿž8CKfjA+õÓ?QÛŠ’ ÛÌnäLrm¦VÒ‡ù<'YX"°0È#H?‚,­”IaåQ�…ÇÚDÏe©»>nŒÂ#öÎVÜ»³;Ùj£'¦Ey9F!WB¶Då$ºj8 1^ÀO­£ÈTÛò4"hôÀœÝz5rÍb™DPjŸáy€ü e^$n´)Œ.æZ‘¿DZí[´¯ì¡÷ºÄo¹†ud¨¼9Cü\æ3Ò£º€éözrah^zPV´ÊÎtCj­âPpîÚÄ&‚ÞèZñ{} ïöRu¾âŠ³`KMÑ೧؎Óúù»éºOó[ìsņ£P(íxC§*H±@ªBûŠR h­¶M{û'|h[#Š —+NZ$L9SQK¼ç¶¥ØkC¼×í_€ë%‰§…ÆÝÓ.G3[¤ÕËN€v± ø$ºWXîª/F©ê}›_·ôuÊ<_¨ñ†Áñ¶ìzûãc *¿05ÿ*!ݽ۲ÅäUÄ1¨M´'3]RTàŒ]£?Ôïg> 2C5¸Ë=í„æÄ¡uùSˆÑ‘cüs­ËÈ‹rӘΖ®?\©ø2è"_ø[Òú­»,ÈßOŠ”Ù´–nÜft–r}A¬%ŠV¾#bFdI•³SìN‡AòxÂ0îb_×Ußc°5ÛÍnŽÔéVÖ«"8¡ß¶u`à“jífþEWÃÙ¯EªO]åYÆíªæÏÑð]TóéGí'§Ÿ­ö°M›'AÔvŽ׌ՖÿãV†f jš\½-ãòM˜vÓêD%ÔŠ`õ©64.ûXÊÎ:%v4²2ïç‘’Øw+c4ut —Ö^Yvô˜¾à&Ù*©¦~G|/Y"ÎÕ<Jup\ÞÐVUi¥Àh:´×Zkp›´$ż"ˆ­u °)ó�½ÑߪÓÛtW?‡½ÈsRLPZ—ï\ÈÞ‚~úßò@ÓЇ“a’ÓòWH–V æ›­aÍ%Cù0=O"F÷v5{ë·Õ…ßä+Îý–³Õ´ŠŒß„ïÒð3†%Œ“Ĥ�uܯÖ‡õ –¨²×Y}—!êÉiÙ-…q™kRí9´t·³ï?žä=¥$ªwß2œ¡Û§¼Ì °"¤B ¦˜Ü·qX ÐÇêCúTRêþ/•Qiš2Bõ‹Ð*,‚¨þc7y(’qÒ'ä çÂóN¡HP{uL]”•BAšñ´–&NíÎWÕw¶²Ê<-Óžç~ä7»òz!»µá6Êöt1æ#rÕcL_ŸX|¯<–žÂ8(XÚ«íhÍZÿR¼_MÛ\´�ž…ÄÛàè«š³Ÿ^A}ªõúö8i¼yå/6z¹Pg¤pÎOú}°Š©æAËa•«]uù‰òíjL‰­3fýç7‰È¼‰z7"<¿øxo”ÅÝvŒAhµû㕵 ú<ÞtUbjâ¦@WufäK¿³"e®ãÉÆ©L† ‰T$N¥É@G~ºôÀ$‘â‚>%úÆ#m^15ælLÐcÏR^š DÀÕ•‰ cEŸ«Ð–›ÇÚª1Öb"òâx$_¥¶óãÏ’UP¾ï¼5 1DèoÌ+²rá-²Î;ý‰ÊŠ€£D˜Z¦ø°êÚÞŸÚÿÒ{+.’+ÿ£u zœö�YfˆÏ;OgZÆ-¨çYÐGmgä›âI奦ÎÅ 6K¨Ý)l]ÒX ß”îæžÎ­·áxæ‚ñ7"8YæÓÀ@ oFžLñ@ËËÙ˜ªßßÿî8ñÇ\L~åæFx²Bmn^mMG[~`æ©Û‘S2X³'ëmó÷O' ¶šóñÜSùVó�oxZíÒ¯„WzЬ}a(Ó\¥v:hLОj­ñ¦3§‰ÿ«ûŠ­÷ ·n°Éâ÷Aç0¡ºµC‘ý„ÒΚ3A,—þT3# _(̃ـù#g­æÕ62–;ð0qëMN÷¨ºxö-Û–UÊz<›§á®~©×çá¬sq+,ƒ|®M[§`¥é•gùÌkk?žÀ¶ŠÜ— ­Øj€8YmO­?K-Ýo¹·ÏuþošUYd}#Ù6OtÀ¶9DU°aÕ*væ'.êrjêfr!×Ñmî‘ÓCfx[݈×è"i¼”I(ƒù KF EÚíû…83¥�,ón/îdà©Oò¦Ä¾ž0–·"Òa BX02*úzC_¿ñQX®–óìs•²e²Ä4€iù.r‡S6¤1n®úÖüÑ`ÒÉi佫ò iO^g¬¦·œ/¶É¢ŸîB€|÷ À YTš «Å“0€ôx<k£¿˜®êôÉŒÃ`Ê2Zœ½út�Hñ�Òò&da¾27ó‹ ÿP[Ì⛲]²¢‰"xJPªÞÄw££„w8O±öÖ¯ÆH$AÓÓçE<wãIlÞ-º Êq€Wµ@¨&ßWl zô{Óp r#Ù—´:Wßv�.^è½)f³´5ÃïdT²Ðíû…ŠŸ×î6Mz5–ÑÎFZ”wè*öqb¯bÆbOœÚ¤RGZ½ÑN}óæSsÝH¿ÛÚ·}gd»c'--h…–¦¡ÔøcÚ´X8ôÒ–iè©üRÄÒW«àyûrÁÕz‘¸å{J£+·;aÔd’Ã0hl»ÞüXËë6‘ÑEÆöB”qçáÿÀ’£©/KIõÜÓ¡Ùåe·¶¿È2[ÃRõCÁ”ÕÜ•ò(Wé‚ËÃö /-È †OnÞëÚ\ËC;„ ¬y­R åÊ!>K|Ä åáÕ|>þðJÇ–ë5fš¾\7MâûQ0ñ+ýߣÞqä¶sQ`Õ3ñ˸m=k+k— G©B´)íåPS¥Çë¿×÷(ävØ ì(ØZPæfjYp÷a§ãWÍŠÌG}!ßRòŸœ.ÍbðÙª†šôš9yX.=PCEúÍ:õËpŠ6Áä7mñ¸\8 $ ~ÐÛŸ´¾Ïsчþ· ;dž¦”¡ÿ³œ!áÈ 8ÞÉ{&Jœ=°±`Üž’Äí4ÕýÑD0‰¬ºiÈS�±ÊOeµE‰Iàç«çø-ëDV˜$tÊ©Ý7ôcµD÷Âô¡šÐÿ3.U¾ÉðPFlfD²œvmÍ8h“u³·‚oc¡/½(ZØÓ“ÁÏÆc?Á¾‹ÚW;､Ú^ú±<óL*VÀL0´¯ÓÜ–õ99y©“ŒyŠî³Š¬bf�ØD€ŠæE—]ÐÕB»Ò<˜ªCoVv÷ßm«Å½ÒÙõ9²a6Aqh·ÕtšäÀ�<!1~œ+v[.) ßm ÆIz“™†`\) «ú™Î1ø–5´é'U@Õ„-¼,äJù•ø£æ&íDi!ò+{TÏqšÕ ƒ)§øÒ|zT kõó+[Üty£r´%VAÜœ¼|‹j¹A02¬SÆ„¦Uò¿1ìIlA]ÏCã.± `ÐTX®±:ý¿ëÛYOH÷þPï_.Öd�$N<Íë×…Fé3_ ‹\EAb9% [)´|7„–y«Õ}+Úljè¨Ýs]S(L‡ÙÍJal~ìtN}ì^ÓáMSË® Y¶f Ò°õâ@!ƒ fß[î-hc{÷ƒ&#Ðs‰¶È˜™r Ü$²¾;Qh43ù6P°¼Â÷ÌÀE!èÜÝ4¥Û39ÓqP̵RoW´iè×6ülÆŠÅ:Ê´$?uW·³é"µ€36Ȫ`çÙŸ<RÍúØSf5Rªc& €ÄZÐò+ÒoŽT›û¿F´ íç庢GJ‡±‰¢ì·ÄU˜©'‘¨ÊÙâL±Èà@V¥Z(®UŒÁ²;-)½ÿû–E73P]Cwü²ò’¢þjbŸ¾Û!…²n¢Óke¡x\ ­¯ RÀŸÅh ¯’~ÁçÍsõ#pŠ1Ö¶àíÅ­˜„M3Ã\ètq,´b2ž–Ès{’;‡jïLŽVztÌœŽ¿ÕÝt}µ«4hÆö<*D¯°¨#ßû‚ÊI'˨ˆŠ°ðzÍÍÿ$ñ}^BîÒN1Î~­CsRqá|™øf‹ì<Œ‡´ý#gÉuÀ¸ÿ[lÅ,MÞ‚–2<Óâµ×ƒ$ŠóÖãþ�sN~4LËÒ+žJ´³ªð‚³HÞ\È๙v1~SÙêã,guÞÐG.Ûƃ•¯ÛX¼ö®?À=ï?Úå·g)¾¤Æ�@Q4=uñTÝ4ßé‰ìè<6F†îòÁŒ#*SßO ¶ÉSIÜ£‘Íãåð&"(¿hþ­–ó"h©¬u.”–5£Pè9­÷•õX6EŸòe|Na$5×Åo+[€€½æî?ÖúbµñÁI¶HG]I(ËV¹E¶SÓ1ë<ÐrQÇGÝ—¥šÌ™ZŠ—YûÇ tÅ ”’§–}¿£ÒáR|¦ ÎHÝ»ooÕ¸aDMÙ¤ÑGrÈ"<•é°7>V›Swßò5 }%c€o¿’ ¬7ÚÞ xì˜e�oë#/lb.n]qîp-ˆpÎÿ݉Œ5§ÑIwÕ§¦•¤ixoÜZ¬}ytl ŽÚLÖ†àÿÞŽ#°v¸•M(mDˆ(í*­Q÷?0˜¾õ»j-`œ+&³9[þ–o­G#e‡° \hãõì}Ý�ýì7Ø ÕHVT†F`{R‘ŒÂÛ쯦Áî0ô¸õÚòz亙?§ ñ1øËÂhÀ¨/"ý SO ç bs&ýÞÓHbutëH[êcŽ‚üS¤öÄÑÒ¨-{L (îÿòvB–^ÖNO½î!6½³>¿•prNõð¨ÀmŒÇæîþÆ7 >fê³ ë6>é[ Ñ ”1¯¤Ž_w^=‘Ì°0TÐ~ |0oµ"g”úéÛ¥Ðs™_ØoË {<,ZÃR˜^}¼‘ÔãñÑþ®";³"ÕØwÅ&"iPNšÀäŒÞÙ"kÍšéñÉ‹¿ê«µ…tÊ¡v‚žMÞû�¸C5Ø.¹`“%1z¡yãpݜғ87øjõ»G²ÊDæo¨ÙÖõë ’Úy¯ šÌ!×IÕÕnçT—«¾­k2îDZêôeÙRw|\ Ìi³W(y®ívêÃÚ[Vw„ <Ø{×-ïJE+³ô :B±\q¿úÍ2¹Ò ™æ<Hz«lÑðÃñL±l0LùáÈDµàV*>¹€ÑŒÄFaCÎÒÊea¸LÁϺկ«Nκ׆›î“¯¸püÂr3.´iU� ?õ²ùo.„jÛî×µäCù(dQl¦Èõ­±žyçª'©5×Q¬É«nFÏáŸúòµmJ­ÊcÅîþR4Æ ÁkZUï=Çv[)‚‚v߀{ãˆn„¯£„– J<0-B¸FÖ‰×b(¡SÓrË^H† ¥†Wsä… ¬q'4’³šRþ”ÓRè¯u‚¢Ä¬E3p+�ÒNÙ™ÈÇî@ºþ ÊĈÌô'úŸ§ŠÙÀ7Åeÿ(’•®ÉÆðGq‰h¿½ås†ýÚ´á*}@<ÌÑßn1)±b‡L‡ãòͬKß4Úä$úŒú¡ÕÝ*ƒŒ®vë˜ì1ŽÔ¼×­;uI¾4Ðç=pݶ5V¤°ôĺj²ìàé B3™öÛý®˜Co"*¤ÂK;›p†‚¨BO ‘Iþü2…,,Â<uá½Ó1áá­É>ÊÒòcEjNK]"øüØØÌf³ìMM÷}èB¼ýäg”Ðg£Ï4¢>¡Zí£…Ü¹½Xƒ‘ˆpì!+‹Ì J#¢×M·ß*nG7{ÃY6Ú¾fJˆ®ØYçèæÞ§r ‰ÉJº)‚½¦ãtHQäb¬úÂÔÌÐc7Ò «f]Éo;ËYŽCJWÎþ…§1—/¶ãUØhuX‹6§­Ó±éÛÑ#¶Áã±Àyœû $›8HÅÑì²ï'-1pè�Hè´ädCxW7COø™#c]ñÜ2+ƸÐ2U:õûù-þ¿•Õá´¦WåpC ¡cw笩ѦAÒ(Ò©ÌØ¢1 B–giåàï]q¤u[œµ Ûot€zk_ƒÍ!ù¸Š¶›aíŒÌš»àûæ*#J<NG)®”¥ƒ"þ€Ô™NÛí~¶¹î}ÿô‡®êirm'x¦OöÚ–ÁxK,ñ„ÅCûR€Ù¥ñ—¿ ^þ÷=#<o§>2<ý>”Ÿ­¡…c&_,ßÁó–Íw€ûC…i·²íoà÷ Γàë2Šfð¤Úƾ ¬ÍÅ/¡Ûó¤Ò^Üè)ûs[qáeÞo«ä¸<o‚À JÈ;¹ûBé4]*mHäa×[°>† IÆŠö<ýE§ÆqÄÅ¢?CÑZ9œÙ‰* æ7 öC7¤"O}ÛÅTx'ÅÃP¸™•á§3Û·ìÊÊ$Kfð2:ÏÓ3³Wú–ꧨÚÒ˜”QØØIÖõíÒi"Ɔ1z@uö>:ÍšÓ‰-‡TùGw=¼C›¡Y÷çÂWùŒ¢DhtÒŒ¾x—˜µ{؃CŠÙÍKó‚|•§®°ƒ˜J|G[‡Kà(®T°j?펪 f^ Ê³…™¦¡Š`Nfб•€f‘¡ xT7ãnŽ¦"yi½*Ý#qx¬7¨†Z+ùžpBÒ¯Ñu7¶ß9ÕÖ2Þ(s”P¢“áS§­˜-ò ¥ÂÇå¸`ÐoÖYJ஦PhŸgh&uy;{€Tv„g@†Š¦ý…«&ÍŒ´‚`h ólÓ)0]ã4`üÃv-%ïóÚÄó™…ð_0yµoBI¥­£íñ*¢¾r¾7ÚEß5ñPZªƒ^eÝ:¼?Ý[5ü–y8RÒ2&I=m´«WFNòˆ»%}”ƒõ¢ÃÔ‘nÁåpß4ïaºžét<5¤” é Zt¥Òû÷%§Õ,6š´%:Ñ« 5©6R$¢—ÏóìãIl`dm:e¿ŸßFM“ÒƱœÞz“™‘ˆøéÞèôÞ]m1ª~¶?œÞν®+”¦]Þ­·78ÓF*Ð)Ö­á¿•hU¸ý"â¶pmþxBbT…í7ÕÿOÛ¿l§Î$[Àh[û)Ü;ªè.Ñ”@ØBÂ’X˜5Îû?lj‘‘™Â€ñªÿ4öBö· ƒ”—yù2ð¹ç=ÎÈSQ)¸Fš)~—­öN¡Ã€5S Æ?Õz,ýh8džªÝÕíÂ$“ÖS.G&ÃëV ˜xZô@ø@dÿ Œ´ŒýÙ}r lfÖ·k!Ü£ªÿÚˆþo³Š„пÂfE6ë¯R`I™Æºw‰¾b`3@˜ñž(7–¸É.™t~S,¶ìyfß/nâçÚòpõžÙûÙk‰2ÎÂC¢ —NãÌUÎÍ‹»Ñ'Ãx¢…0]¼]V² ´ßv‹Që‘áñêËY‘’tzz)[@&š´ýáo–y[S*{II@eìžrù-ÑÔ‚EE w€¸Ù©)œx§ú >Ýø%¼MáZ7Œä¼T(cªO×J˜Ïœdr­÷1œ2¸«»¬©•¤+KdÓ{7¯cî]eÞ+íA�¬X}œ†Ñ65±Üü;Ì€ÛFŽ¿éh¬ž)‹µÚQMkæ\Oíõ_©,ž§ü” Ò[ȨPGÑmÕ“âokI‹* ´²º³“ús@ãCëáS; ¿Í°£=Þa´˜†WΞ3Ø‘eû¤Úè*É^¡áY= @×5 6‹N–4é/amc‡ñÁ",÷ãtÛ:G<1„êô&†“KèQ�š=ó”ÞlŠÀýUqOgžpÚGl)AuR#ì6Ö|c…EWòq¯Ôµª9ëefN0›Ýy`fNéлŠ•¢Ó]õ•¨5úƒ=TC‚k:ì÷´×.”pûà™‹TYúMȔκfåKxD;@‰¸œÙNæ¶|©#뢙»‡§ýO³´Ä»±Üù™çMÍZ‚3Ù*¸­–}§KCóègϳMj(ö£‡ÖwžkÃ�èt>Më2á伨Ÿ:9yx×1¡øÈ!ÀtGcwfg%¹³|¿nþ¡È›å³zD=SL/Oƒ‹»Çª©Ž³Õ£%z¡¥º*¾*S÷{t);…xúýŸ1Ú§'¨·gíÅ—Nã©éÆ´ìD«5ùÿðôég˜‘«¥7ƒ1—a.Ú£)xÖÒCÞV[[ ‹8rÑÆ~vuï·w6ZÒ1\ô@ÎêW»kˆ_Þè-(œQÄW1.I?aQ¬'±0frqTÜÍ^ª 4ªtš�‚ÿA4_É0 7ÙÇV¼zãÄ«{M p3ÓÞ›#Äè°¹\§Óâaæ‘–S±ßY5<æ) òWÑ©ƒùñÊX”SåºIÐ}Ñw>Yœ6à-s'Âù¶ì4iûS^DìéRK镨š½w®ÛêÌ("=0ö£iÑÿÏ~t�½qC S%xÖe ÝhY`ÏŠ¸9¯ÚU9å‘DUæ+x=[} L;@ G¥’P<¢¤/€yü©Ã§Å(­j$z—~%UÔÜúä'ó%‹)S†¡NÙ)¨qƒ,(iú_6Ö)VI:÷–!)ƒÐ¹‚‡¦P -š(ÛÈçw¶sSF$…?Ÿa!>¨Á¿ë,”Ýæ% ÿ¬ Ÿ§+P_Ð"ÎEÂA†Ì"Qîõ&~�:æ®ÃŠjƒy¶eéªãqŠ¸§-% glpU_íëqZ8ñ ¦~lweÄ_“×Vo¦3;®ÉÔä>½kÅôŠ¢"óÕsJ>¡|ÒÙ½4ÄÄ ÐU]¬=‚ùÙ%ŸOp³¾¥.Kz#\t•71;Q¾Iõ¿QNøgfp\x�pFÙ\Š y× 2ËlVg¸Û膹iJ="(mVºv!‹`‚U¡;mõáðelVó)Ì|“yzßebQµ/SKbBÔŽ¶­ÈÁ²¹ŠRã/Ú«¸€¸˜ßësŠ¥ñF†›bþ®qšÔ¬U­­YÚuËŸ¥ûžKfíߦK•F}kÍ×é;Sù5´7M4£߉ í£éMæ[!ñ6e  -r†ôð8ƯïÌ>OAÅDS›Sp- Ê8{o==Ò &ïó¸; -;-#Hµ±só㽦r¡Ù€&&ÓÞåÜ{Ö‹zÛõ#Õ&ÃÛSùᙂý±¸ñ|{˜(_Ã:°®ýâIdD›«V¯XX¿êo{ë,ÂÙzüHÓ ¶ópZí`ìÌ´™c'? çÀf²¦VúöŠX[x|pýémkE0Ñ€nÖ7½å†Ñz°¿6åËOš^– +‚žtŸÚ+Ë_¢M·D’5Ñz¸sž¡›ÒÐoY`@æÛiq󱦚$c»s"¡Dî©KZ¹ô03`±í²Wi…”¥ FßbƬ¿ÑCŸ#kjÀÜ: ê"a£ŠØÕÇêÃ):üoÍøÒeß\7\¡B˜TV8Dó`«F_ÛèÑõwü†ÏáNËΆv.6 È{¶SëIÍÊkâî°H_ÌÒO6žÓM‰&…àõ.ŸŽ(¸ŒÓcª2H3‡!ˆŠ¼û_q{‘òjP ñgà’Ûqç2¦l-¾–Õy©Ô.<[^&ÇÏW¨F¬ª"tH$ûæ-$d(éOWað\è´b.ùטë8Oh(ã¨>ir(• Y5çÁ‰ýªV™‹G:x݃B͵—ðÎ ;ñ|ˆ^þ^1 )ÝH©4L¶„‹iR6«¢)Ì‚ñ ¶7½6 ·]O¥~ßVŸï{ùT`ùq{»®± ¿oË•—…ïÆÁö:IPžµîËÛì|Æ×0©gmöÛ« 8îÛ$¶¹¥µ&Ê|Þ\.Ðb†÷©ãé8ñú¦*é €æë¿ñRÃ=œ°Ú,xSņ’*£UbºS’AŽíX!õðm2³Ì§Æ@áÞp“Nw2è¡Š•7ýGc¸8ÒP ú{°¡Ï‚lÿ×K%Àˆóx噞½Míþ0ÿʘÞRó á4 –†6zdå¹éI'ʾUNe1hŒŠÝri[#vMm;éÓÿÑcëXßN4x—Ú{ ÓaÁ#¼p=ÒEÞ¾µ Ý™å“îW~<¤6ƒöd+Ž"î¬|Àº¦½¸´‡ý`:¡Æž»\=å„#Ý‹Š •�Ú31àße3h³[&`ÄÃBúùK‹YH˜õšŽIJJå‘0=gïåvnRxù`é ƒto›é"ÈGÿÛÝÂg‰9~wTÄΤËLà`bó>{GÚá µØ£9žeÈ•ì‘÷½Íٌڋ­E)àñlO'´£M¯Æ™+VX½7Ï‚p?™·Bp®«£+›Ð G ˜˜ŸÚ¥ûaGÞ„07:UÀìâ³×‰Y1Pcè"£á.;ðÆ-,×…g/î$÷å €ªÜ€´×n-l 9#fC6Ø6ÿ S sJ?¬áH· ÖóKç =Ž€ÖÍöðtÒ÷®¾ ݧ¾÷ “ÿJŠÅƒGÖ½ ÁÄ÷ʶ ¾DíÁ¾Þ¡šDÞ\ŠÉ¨ì¼\-ÍŒöèX·@‹]ËoêR7ÐIç|†æqm˜º®Ò²QT@¼щb'†ÀÄïe¦eMŸŽæÉvý>Ô*"‹TÚª×2ˆ½Üåø*9øA<Iˆ >ôWŠnYlõœäA<k¹›²QªÎÒè0íO5æýG6y‘ÝHàoë$ؼWžŠ�2…‹ß)µ#‹{Wî,|A1 Bݸ’I—(²…–žËn „"!ãYÿ‰–ëŽ+ÌÈácÁ€¾û´V¢æ«<¬E"·»Â\Ü¡G&QæëèRþØÁ=yó©7h“éÜ>'¦R‡Î ÎÜÃl‰*ßõX‹Ø±EvL|Ê%?ßdb?Á¸DŠp³ ‡ï§K̽LJõ ’«×²Ñá—*½<û/Âì0 úÕº%B/ÏÏ®Ñ;Vø¿ËtãYŸ¥™7¥9áªèkQ"gJ2FÏÄl €lÕKʹÜGZG‘ïËžDA .KjËò8×É»Üd¹ Xy†*óøÒ5Õ³Ø|4c“ ï& ¥±˜ÞyÛó¼Ññþ¡Ï]º!ît\v0 9y“ÏÊ–N’ ÊæêI×-ò;G\Öy7Öº~Ã<RÚ(èÿÊýßö×.™ÊõF«†"CäøY`€õhµŒ.,<T_ÿ],+J ²áVb ÞùlÙÇ ᔡLà_$vŠØHI"J?íÉÆÁJx ¤SôðÑ]Q"ÏE×5ãÞŸ  ¬RZöô¿æ©ÌÕZHÆ‘¯toÏîßq¸²Iö)sZL_ºrÖÒ|žõ•X?zåë¾eÿêg¨F: ¦=Ý¥bQ5Q ì0¦û±ÆPKIø€qË#¢…eéwÍI¤ÙÛÂpšyƒÅ˜ÍÛ6AT©5*¬Ûeœ•+ù^´]_)[2Õ•L´³­*à(0•÷­-_/c"L‘3´_KEñ³Þyê; ".ýÕÌ5‡Îd©Î†4%Œ6¹?¨!+Ó8sK ¶dyô{…ÁB/…>ËáO¥6 ÿ›¯ö…m0"ù°ƒâ¤ ìjk#ÿó–kl„˜¨§ÿì•Rl¬2¢ Ô™ý•³Vª³CþãcSy-Á5çëiÆZ†ŠE].E[ƒW`eoÀM‘4Õ]=‘›Ž³ì9c¶´Ôßò =-^³Z Û)4¬7•õ.£µ +ÝeÓ~ùè·V%€´_”º¦NW/YŸH’E]iõƒÁ‘®ª’"Zó–RÞ‰å3�N<ÓZG'ð 8Ñ5!ç'u»›™°‘Ñ9ŠÖrÇ9 ¾ð½¶­´vª«õ½TA^_:íVHÍòy$C©k�†µh ˜c0È­¨Ý8šì_4…“U2Æ õ)ûêyGÜjf8¯Æ¿»Î’O(9›ØÅÁœg@°÷Íí|ÉGÛž¼ÞdnTek_Xß¿¾þ$tK;: ÚQ¯{í|³×ûŒ 4‰Ø…¸ùÐZå$]¦[Í™eܾ³G\“píìÃÕŸËñ„›9±;7Þ¼hã¤ÜÜtÑfààÒÞ‚ÉKÅUhþÚIçÄGµ|éL\Ë*æ¡7z ¾)Jô ¯b)SQþ1°N õqWÿåíòßþzü¾L±¸ê�±Çiñû§*±àßÅ¡(ÖËŠ¤c\Âßwèq#òãJCΦ¿Yi‹Q‰ê&zBŒ¥Ñ+R¬Àg.¤ 3š^À7¢®íÄ k",0ÀY§¢ibà4Níói§?Jr1®ŒrÓ±æÂvóùå}n+`Cÿ§Ú6õøÝä~¦r¢ÿkž›)¶ÕÞboln¦Ânþòì™Ê=ck{» =z*gZª§‡2NÐoòŸ¹aêýK 4s$)¾GÍ€¸`;Qˆtû°·–¶S»˜^^Ÿªé'ÙŠ¨ÂÖÿùË5×ÕìÊ69)¨ ¡¾™¢ÙIa$MÂMp‰=°?YA+£šj[ß8/á–Rå³ÊíÜQ‡>œ•fSm‚ÍÒê¾Ê¸q|áO®AYˆ%TÆË­±J1‰ ÏâŒy:ë‹gd ã¹=ND¬úci:Ñ´k([gC»È¸8Uý j-Â)iÖ—Ÿ,F£Mä! !Z$¤ï=×êxnû·÷±L»û%HêõXt¾«�ÙŸ¼bIúpª°.¼ÙõËwíªØW’€9!½stVq ÁdÏ?ø–ÝÊ‘2¥Â,Ø÷}ÞëÙ½³YMæój¢wˆ?-+n.ªŽf/ïÈÏæÞ#q(À²¿¾ÌgY"a uúÛéMK_*“ÃÖz%C" ©.=}Bsð˜´ý§Ã(Yù|Qý ý¨©²8.nøTVUç·(„>}ZiYF’\*8l_¹<` >®@yŸ¸z°¢ΈGý(B”ÄÙJj¿ ög¸65WOÎæÃêòØÍx?Ø_^^lï1µD1 ÚC ךµ¡¢ÁxŸµÞ.´twÅÝÉ&yn!YM¡Â .®#Ééç š1%e�‰”£•Ü>˽³FJ§"Ê´ª§›;k×7 óC¥¡ô`Å JÝk"Á©×[Ã0—q5ñYr®J ¨}µA5¶ÎâW,æ~‚•­Ï�_{¢cjû£ii˜©Š=¿}à܉*J³n©Ê ^T3*æTÊNSÑ¢wÔ“êæǻʭINÇ—§ ›Òÿ_»Êœ*Íáë š°ETM;¸ÖÚ L"m­G’nôöôÆ_V‡“NËïð¸j“vžÅéúÕ¿•g¹AâeF-f¾”AzÒƒ˜ò¼ ²L€zÐn{nêgþTR‰¿&†ë?úlbëŸD›,gJ~>\µyPˆ < œª.PNÀ~ âN¾/6Ê yP?‹§ÙI(õ•Èƒ˜?pj‡V&‹?EÛ6¯Z¸oª“•V¤Óº©ŽÚ˹77þFCU' µU¶Ú8´ ÁUW%ûw”ÿ9BVª'3§–bÃ,ÓŒh².¼©aþYìËÜUᦀÁ žtÖOw>HGðÌ—rcº·²V^gî”™Q¥ÏMsˆÂ?Úgo&¸kÊLÝà,ý/ò›yžAåY¸ÆòÒ1@kó¼xÚ�p×T—³}̵ŒÖ šr÷—¾å;74éd9×›j¾^²,k;hÂnªTîÆ÷\e³2´'.Ĩ)*e­Ò¸IºÐÑ5:åªä©DÿWxÌm†–\f8,Zp$!·÷÷#þw*0%~ì·¯üÙ­”»ˆkB.‹â^^9w°ÀBî ­U¤Å)ûá‚õAÅ•çÎtÎ�ôÿ—¡öå#Ø0Œ ÚÈó{ªz†¤þÆD¬}I÷+N²JaÎIX)eˆÙÑçÇþvÈ'aéº} ÷öÐU«ÎNmñX]bFåéÅO„ÌÈâÊÕöº¦Õ¸9YPb\ÄЂ“~\_wôy€¹‡†£3Øú›oú¢±7üf/Ϲ/(©WÌÞ{5YÙyÚqû³!BÚv>·{ÏqÓÈ} 1$A?ïTÂâÒÖõìp‡d`¡@ÙÏ)³ÁYgô'æ;È°ºemrµ6íSÚ¾“¦EÂ0ékï$‡óä§WÒ}sŠyptf×yµåé@å©›`þ#™[eÂBÖÄ?�`‰U‚„/K]ìøÝÔ;u¶r¤ mšQ§È3Úp8^º7îTuíû˜È " ¯©oð»(I­Û¨"Î×$(ë/Ou˜"‚t©ä›»‰j+±Ÿ»wÉ! 5”„|lH¼â-¢E½ÛÑûÊfËì“XŸ¹Hsiwô!–gßÄ›àD†{o$ÃÙåÞŽª¾›Ãüû;ëÔ4[Mcƒ÷Í'ߘ9Ò¦íúã›xâö’µŸz¼ßàky~ž,‡%2:Гðu�òƺ§‰ž¨z»½‡Po‡ÕIjpöa¡,ãå%ç0Ýôáƒ}Îûújþ½A‰ÅV¬(4F6s‰÷ÉšU”÷w”ü£1q˜rÒ*Bg”ùv ÐW9âœW{©‰Êúç›Þk¿{€cghÝ8P}Ñy·T`€EzdôÃÞ�v*6]ÑWÅR,î¤ö‘ëã Ç&‡ÃeŸzútTÐ0Ì×(ê•gN9”Lz%ìîÇYœËÌ«ßß$+üdLZÊÖ­•g€Õ߶¿XàPÒ úº–"(ÛyÜ\vÒvUÛ·=`tãÓ4Ø zòmWm; t”RæXF–à§GCw)wØMäBñµóî’L ¯˜PH†«Jý£¥›?j)äN–'µ5Hô¾¨Ü*k*MÕb=~k2­…Øi¯ —((Oçõ<È[TEZ™ß¢e;Ü*?ÔÓs=¹0’Œ,¡Íœr.úç™+RJº ì¾^ÛÓF¸Ëˆ 3¾9×”îõ×c®¹ãÚˆ&ºž¿L“ c c.r”yK°Žb+»„„µ:ŠÀ£i‘Ÿ™¿+èä…o˜Ìˆ*舯—m™¬2fL¬Û åwçÆJ brkB¡§ZP–ëÿ´®ÚÂ!Ô}Jûh]=­ÙF}RsöÇ”ÌØœNÌP¥X†Ha^žÚ` ”3BvŒ®Å¹²æßõè{¡>W$õµI£0uNsFF2Uó§)û¡µ°Œ“i°±x›êþ¶;Q…OI¾c9õÒéËëpÜI‡æÙÄ:w칫»¦vQ\ú3R<n:VãÆÊ’cc·žJàZ®Df‹œø m:µF<U–G(B½˼ ÃuÐÂi 7>á‰ÿ°úÁ”q¢‚vc{‘d»-ñ÷ XUÙô–UŒ~úh�E>ƒ^ÚŠIä©üÄÌ1ìÐÜo-šŽ’«Óy’^Ïj¬ðD¯2?c ìiߧAv¶^zÊ« €¡ˆy8÷ñm÷÷/mm‘x@åÞJ¹Úìè'5 ŒšðÁw˜oŸD¯rŽ’óàñc°\XMU]êÔ:ɘËT]MZ»T‡ÐLjFÙGJ+èÙ°(üý_ƒqpë†ÜôözždðlÒãjY† c´˜¬ŠáC5CwVñiÈÂr´Àœu'Úëâj:PG4®ƒ];ˆÖÄ7Ès¶jñA�·ƒ°ûr‚T8ìƒøga,ôSa—{ȆÕÔ5=åFQæ)Ä€0_¢ÍMÏÓTíp˜·#%4³W Û«7pÒ)Uc‰”û¿Åt ôù˜”W bï¬ÃʈA=PWaµÎòJïÄ^¥af]ä!<¼ cùkÉåazâÓ@RPX<׌•²2‚Œs½æ¹@,.×»™ÇïØdž(6'„ŒÏ“C`¬ttïvœDÑzšÿ;´_‹e“>ôJÊ ßÀŽ‡¤IËÎk9 ‡m7B Ÿîåˆ@Ê“ÒKµÛ‰fKåçZÓ¡ b掀6V›¯Å“$DIÓ`Œ÷+Þ˜›½Æ*ÚyɹEf:~¸ÿív\ ÐÉ|cñæ["iÍ Âï-I2_"ë2z¤ïz6”!áÐ'Ôžå“R,JSCtJÕSt¦G;\x¹²·ÕD›SÉÿÎçS;ý÷XY;¹ùÑv:T2aª(å46óNûðahøãØ8Îô+@ÛÒ‹Œ1k*:ÂÉNÀAá³åôŸÃ~Ð!dhÌþ€¤¹’:ÐòIŸ°SêTš™»a⺮¸fn %NÌý§×Ú½øm7abnXÿ"«;/b–�OSÌV7X|²ôIFÖ/ëGùÔ(st|i´r÷3Þé°“yØ>àÌcôSûý´ßZ +ñAî¥ÖÜ×ê³ÇÀß_{x‡þ… ÍVÖêy°…ÉmâŽx¤Õô-¿–V'œ3m{±ädí†3ª9q8¯'ÉóµšNÎèSlutm¸ nà5@#ó¢ß\b}?l„ƒ¾ ÂÙRDz î°ØTáFâD\zÖDl|¾=fÁ¦úëËÀ]w=#=ÇRQóï}bcáµÔRÖ=ª¡’< 4rf 7Ø3€ŠøfЃ2Æï’é8>sœfkÓQI*zå3˜´¥d0z§=õ<±H؃§p—FЙ*­ÔJêéh>pܬž^K/SM«ÂП "˜îÒ<È*mÊú#u>Qd…}�þÄí# T—Áhd“ƒî:½-×fwèoÄô/¿1kbYÍ¢õ»™Õi«Tþ>¬eñ¢´¦ÓÝ(ͱ¹ýSñ§`ÍA3¦äÐðâeS¬;ôúþöR]}nŠÄc1ã/˳E± #ÖNØ '¦ñbG”Þõ¥•mz«Çe´óäx¦ÐÝ%»Rš! Ëth±4Å4ËÁY\åÖ¸`e«8Z¾©1¥·F3PRý§W>TÍñ0U½UÎí²\E8„›W×{3”5ø=NrítXÐÖÕUÿŠ(?½×²Š7ÁaOw£úkph'£BŠö·2,CX:»Oö¾ƒûa‚u‰Ú ?iªârqe%æ¤KSÿ?Šµîo €Išù6`Øb‘N=–·”Ñƽ\ª>[u(ñ“2�…¡ØÎCy‚6`äžÿ®üжtxB=Iš”G^kxw ûÜ"ÛdÈðª%5§J% þ"q#Z¹òÃk2PŽLªuó•ÂFÒ(ñb¨èX¡ïþÆæšËñ<dB¶¢oHßër…<EÞæ°?àa¹KhžäΚ#cŒ¼E¢Æ ÅÈ {‡$.F•3 IÔ4#ï-gâO½0­þ¯œ•€‚Ëd­¤ª©Ÿ„Ï/¬XRÛE.L®³í’`³ë0|@ÃF„'<ð Ý26+{§JœÎó˜œGÒª1Š.?ü?ZŠ]B ¿× ë*ŽY;Ÿ-[.=Ыwºõi™yzÜ`žIÍVÏt%Œ�žßO1ž…3’\·›èTª/&þ©ö•%ŒÓR?Éõ…EÛµ«©v¶Ž¹:詨(¦¿NMÛïºÒ&‹LZã°†»U¹Œ=B}$ž�è4Mê/_ <ÉpeRr×åöõåæŒíHÄ& jÐã Yl”±caÓ_¢õUy$yÖ‚Þ 2:­êv–|ö¹u‚îýÇ:}CwÔȵÞÒ<6·ôåš! ŠóÎUí cu mTo« d!Öº»º'~¼²v1"­±…@¯nñ¢·>;ÿ(Ì©j5ª¨çmÕÓ].Cš¥Xf)šVÐÊP–ɦð+?ØZõYV_^“©ûT`õüzA¥yèÍæ!bµ§tªQf`Îb ôz>£úv­8B…9#qè>úµœYÏA°qºñå¿áŽ¹d¶³v<ÈF§…È:Ço ®,O°«Ä¹ù¥ NVš1Oê) ÒJE@aϧE ¶gß�z¥Ü·ÚÁ¦îØßU—‹¼3+€\(ƒ+êwS€b¾væþq|Çp™s§´ˆõSÃJ…#©¢k±Õ¹¸|È–Pµ÷JJ‚ˆ)ŠåàŒ7BOˆþ÷Rîü‚ èuED¤›ò ´Ù)ÓáøxEø°òU£¦qÏC{îŸæ96ãpÉx›Ü‘år˜›ß 8£x¥òBš½óòev꞉E”:™ZÆšæ=qϳÝH€+Y0L …ÙKí!6àHp«z[Ý°Ñ`άÔ- “­_{›gGŠ‚å°˜u—…Ï„6š^W*„n=Ÿ´uóÞ‰¹'-‚3 ©�˜tÿÖrætKS~í܈#§ZÃ8fmµQä¿CÚD&Nt<®{µgŽxÇâùÌbÞ¼_¼æ¾Úa`²/Üfèÿš—}+3çogXÒgŠ¶Ö´!fur—1ýFó¬ð1Jkv\ÐxΞœ ¸¹yKEz-mVÿôP8ƒ‰0¿²F1¥¸5¢f Ø$ûNxrnl ¨HúŸaq\H¸´)SéˆHŸ62*h,ý¯VíS˸ö_tBìt"ᣨ.ôŠN^„! ¶ "Æ´æå KáQiÔ.šNÃûÖyRѽ˜(ÏQÛ„î�wOàæY°vÿ²§LaƒŸŒ)À> •d ºØ¸Rkúcfd—…Vý¤«}غÄ#9ËmtoT[")Y>SJÑ•”QßêÙ®ßSuØ‹ÂMÚ7u`É\ãýâY!tÖõ6ømOÀéèÍÑÑztí³OcãÑÔŸ º7_ž¾Œ<3v >ÿý˶½¿€p[è(6$Ñyȃ¢±Mµ"Œ)ƽÜ`7]܇%Vì €yóG,/²ˆ‡d¬~J€/uäL[ù§¶úð®V¶ê†fŸ-;Ú`‹ÅEÖ ¥Yˆh´Q…zt™Ú"É‹6IË‘°$Ç”åß-µžï47 $q«9iäCçÀÇÛG‹æÆÓŸ€}NVŽePÖÖ²<R•ncI.Ei.‚^;ÒÂ?õiÍL{Z)ýŒo2í¥¬Ú% +<|]³zM؇Î{Ý8A´mu¸~Ÿu†î¦ë€Š´|oTb£$u»ž?å2ѧ´ÌÿD](qæ:;”ÿ2§iÈ_+môÌ7Hà°£QO§˜qšída‰`BbwR(á¢ú[¢^þí_*/= ?ÛˆlÑå‰íºl˜9<ý±öWð‡ª%t©ö"Œà]yjñ…ëÙ2‘®LúܨX<Ì×A£ó �1ü(ò(Í<Ö¬¢sŠÍÅg /ïÏi6ß/ŒÚ¿›É=—'·°«B%‡(zCë·í4›«G3Yxe]'xAÀ¦‰eíáëNmßYÎÅ­éƒx— `ÝZ$‘'ŽÅ•ñöÅ29õÒÁï5-‚ ²à'MùtBAûòéŠuNI'<næQðdØ"×æ¿´¸ÒÌ÷¹A•‚àòþeRŽ<÷•H¸êzójh±Ôù(3+iN©Ö,*«€Õ¶ÕÑg;–‰’Wµ+(?xuÙWA>É\B"d ý™vvñiçbé-[ÊD¤é-'âŽV¯ÌóùV˜±}Xèát„ÎS_™AÁîâ'Pq¿Nçi‡˜»�teBd/|¦sn$áátš·*°/9þ¬Ž©ÿ¿¨¬;Ó¤ÐXQUF´[V*7˜ûð;žY/çY-æv™¸X$ÀyÃûYÛ¯yÊ0VÓ0S¯®¡öâþ%M}ë½:ãc*ÙW§ÊgËêÐîñôΊñHß ÃÁ<cÁÅÄ¢(�P ³õRÒéjtšq‹Ä ëÛ Ž|»ŠÎ&ˆ“ö.%‘_¹_¥úË;eûÃÞLœß"ËæÈ”}múï8vS5ÓÿȱÀô?OÖR¨íQ.´®À‹’Ö¹Y‚¡¢'¦ˆûÞ<°º#¾_xĬh6ìq4:0ua{ѽ6/é! nð %—ԯ c„‹ÎHl®3^KEþà?¶o•nßdÊÕµWó¿¾Cé¯t*º” žÕ–.ax^Ó¦J@T¯€4–J˜jEÐ,ÕÞkp�L¢7ÊV¸ò÷ >€Áià&¿E“ÆÉm0ZfÐWw;âJߟI!ö-:Jždm[ÍÊŒRw5=‰•-Q7t:Vª*3BRf¨|x8rqëÎúò–N7>ÐÀ¾ Ô®wspÂɹi½æ*U¤¼J_#>;ƒ¬¤`@Ñ3uccÍ 2M?AäfÈe½’‹~ª!í¤÷KC6¨³ [:s¯ØnûB ôÍy\ìÓÒAž= .5÷í÷.%Qîk�az4Fè`î¼IÚRd²b’¦›ÇO-,_é~F j ²/íÅc�5t ø¬bdÎ_Ÿó|g_ ÕV#úöíoÐÈ—/c!÷#$ß2KiWòŽ„Kýù£ÅlV5—0fy¶»2°¶¸pRlÝMÐæ´$KMtÐÔÙ<å°.à,õ� zò®ˆóÔ¾a€´àšlŸŒØ Öu}²üd›§±¹)²>K›ÞºMÔô?™_fÈK™Üoý¢Ð1Tv2úߢŸðiä¯vN° ÃØ/OFß샛E[eû½ÙHà$½“ô¥ѵEŒy«'!¾éW»Ð’É÷*^fTˆEÀÀ N_Ü…©§nÂS{ºœN&”1MòÒà ¼<u¹qaËXŸ$‡Äæ<óÚÞ¶µXÊέO•c£TÛ½2}§ÐÛЭH';Ó6ÞÒóçù0Mô'è}¨¤¸ê KcS-ÚÞ¿ÉæTCÔC“w‹’; ¬ØEýÿPb¶äúR¯VE¯— 1³à"ˆöÚÏI!¹t<¬ŒÉkÊYâ)г ‡ðëÎV & îêÖ|º[Z©ªTù2º±«Æp¬ËÚÝúäC[,ÁŠ¤`Nn‚|Ö¸Ì"ä§ÃRõ‚Žn«m<¸\3Æ6ÞŒƒ5^–9Àrqð­ù�³l}˜×j:Ê?0¶æ\YPv~ûÒú"óŽ/¼“-×QØðIíÔÉ*Žþå]ý›¸Œ½¡rÉ>§ph…7–kÓ\‡7ú™Û= aÛcÕÎ`Ç°.+B_…¾„3¾ýO ó•’èO4 H0ê´DÕ$ê@H²}ž¸,­~Ë=»…»Üy“ß¹4/N\ÿ¶Àz?Y±™+ײ?νö‚é6›%óçÊ]‘›ájá©ÖæbDFy_vJüu»¼·G«AD§j?ódÒ^<ÒLŠ²ÈwºÁz†ã槶Ehá�›èæ$ªOÑb4‹þfä–*ÜWjáˆEhâÏÊGÑVÓÊZpEäÅ=Ud¾M4PøÍÙµD)líºç¢üû/ŽYá’àHp3Êá{ÏÈŽ’«ÝhÉ-suÚŽ‹§â#«¤ÞŒôœk +\Ò¡4”ÜÛ•àÐöt–®8ž´j®îÔ~•Ü!l ›ÓPþÙÑSÈ:+`”7ÒeQ¤¥ÛýÍË:Äçj»™)Õv‚‡ ¦ÆR°ÿÿyƒ²00¸Hj(™ü±îºÀÆ‹NDïrÁŒK0s«­¯'§CUmϨëàÎïo�¦W‘Liº2NQÆô½±9ˆ´ÇsÊ äË8Aý(ÎE¥Ó4ME©Z~­U» Ü©ªÉîââž‚Eæ)P‹óÂ% ’SeK�J\öÕª�H ~óOëŸ|[ýUˉÒËM5YDg]ëh‰©¥è˜Œ£çg33†'®_WùOžZDŸ€Ú�ãCôϹΞF€u-Éï^Ñð­|ˆ²ØÀ‚µ&}î“6ãìÆX•ª!Öã—i‘ÖHó'1œÒ› ‘hZ4eè¶Cš…4=>ÿ…kgû}mÈ¥½|H¯ä¯4Þ˜ÊÂ4ˆ(¤*swÖB]¥^ê~,ƒ·Üìbûøõ–Å™§t8ÖˆÕ­¥®ŸY$Í|†È¨ý%˜Ô âÅÍ™( Mks¦%ü�Ñûf@¯ÉŽ­¼SFÆÊ´¦¸éd~×TìÏÁörïƒå]ÕºWo^ j°Ž©Jªßí÷°#1ä;–]½Â!Vw–ü ªtò8(Oèãt’ ðí<‚ÝyWþ:Î:ó´ß�']8“­œJ¯4Ý™tÀ‰™y|÷O蚈"A¼Ò¶)ƒ6ºxßÛŠS[¸tàÊ.•ô¥Wž2¯i¾G›Ô=s®Ø„Ùê ÅŒRšÁ«µú0X‡ö7–WVr#3mÖLµ_.}Òµ<ïÏz©X °—†6kÑè±9Ì­RÌ,–þûÄf“RFm¤M…/¯J<OÜ]ºØÛ?”²Wš²€ …ވM Í^|WX½ŒDz`9îÚ ëé<´Öwb«²[þå«ØÇaÞë xªrPöú¶¢·CvŠKÒ „j³eBD¡ƒÅ&ÍÉipD·g»‚˜™Æ4mOE<0õNLËMŠVøûè—[:Ð+ŒFŸæ3oè^Úîs–R€Ó¤û&­OÁ6N 'ô†½(’w›ƒcPXô%VïøQ02Ž[Ðî %›Sêa]±ÓD ÌûÙkfŽRÉ ÖÚD0µ$××Õi_Æ«¿˜²A›1"Z†§ p�ÜÆ&õ†¾qèÍ4á¹NÈ&ô©˜ÐÍ™b Š²O¸‚ª¶£xû(rŸÎ^Si¿rq+ :^5tÞ~N3—W‚|µ6k›{Ww;Öü˜-H)ù)‚´³ö²²˜íJ«ãéqÔ¯÷YUÉŽâ¹FOñ2Qô9 ž;­ð¯ÕþýÙ=ù~wn¬YåÙúÉžÌ(:L.øpôöO£E1ßrîÖ#é¨0Õ‡1¯ØÐF§Ã.7úBø ze{¶“ `æ€üfN…j ®ÆÑåZò/ºò4[^ úhZ–«H†öl^𤃮¦G@¤¸|ihmg­¶ƒb@¿{XÝ8Àñm¬óUJ^xcô¶b˜ý¥D+ÔW«.ÍÈ>kÿ»KvéZæì$2Ð.&íܨ'ÐÛd|3•ûÓ&úaVÀïÅGé;¾CÐbƒVc+fb5ƒ(êëKš¹n\Q$'-ÔM°±)dÊÞÈûÞæ”—¹xDg)ÏíＫÛÑiDë61ë67­Wø¤g_W#”¾˜OpXáA¦³J§ó“–²ÌÿÖ?¡¨TžLÇ7ì ˜V*Ý•°¢Œ$Ó„_ X¹L/y}®yÖ •ïNp™=¾G‡&ï¡ph5÷cõÃsõK*09¥’;Z¿y£ðù›ëç�БËXÒ-Asÿ)ù×Ðܹðrq‹IƒMªÖúä%‘Îa¶­ ±#lXÌË=G€$7Ör—õëŽò¤x7›Í€8ÌcE“Þ¥…)ÊoùØ]œgˆÂ#Ó¾˜§ë ÔµÇaí'’Óž¬þPñÏU­#`ý¤±åAYduh9j5ÓÎ7"wÍÓt¦MÑþHtÍÜThÊQ1†ˆ{-XPvð}¥Ç{­† ¤•)á‡,à¹ãÒ9° Rˆh`ìíØn¥rÎf¦Ÿ~7‹Þ»ºô²O¡4ø·e*è÷ꯣÒONŒGÖÔ¸§S%·²I#J÷“Ã"ØZôÝ)X£Áû[7 PÍ�ÇÆ=»ÿÉË•È"Šÿ˳þëÍ”�ÿµ·'¨`*%™Ã=ÕØü5Yæ¢j<à‰]ÍíÆ*gtökC»8 }åˆC7°98í}Cì?€ˆi’|{L.g€g~Ÿ7¡ŸËÒ½Ø.PÈš{ßèibo§f¼ Ðé?Ìý�4ÑTåV¼S0A¾CÇï&(æ‹'äFñê˵o¾¼2ž‰ Uð‹TñáD©C5cø@yŠÌLå©N3#õÕ‡•~-„6ÂGäýâ™@Ìh>Ò"<ÀšH[oÓ©o_ßCi®(p Xð иܘ�hÌ1”rùúYå«ÂfUñâ¯FqÔrïЮßiŠ»]¹)š{A2ï\Wà<G‹%žz<7úr§ƒ—„þ©„æ0Cþlv¸©9%8Ì–æs<Ï¢¨†=õó  ´ÚWl˜blÞmÉ’K@wk´n·[V"3¯w€ŠE^PŽ'½†ˆsœ‹_TçÁjõNåþ‡LÜ2E¥¸íÓ ´øÉŠÀêÅ©I.ûÐÝf]Ï”–ÂØöv¤ÅßC2*ï<@žQ3÷aœm+òEÓ;ÉñcV²…z§4:¤¨=ço*¶è*›ÙîzÎII¥ÎNt&´e]Ÿ‡¯ìÈÙŸeôÜt1á,( æ#­\k¶.Vq}+7Bguâμ~ùNÈ÷fÒ ‡Z"¦ºŒù“éìå;¿¬;8ti¡ÍPµq^LÉå?�ðö-8.,¡¡ª§ç¿R^#x`ø#Nv+¨äQ9äßî„¥§s!,VÌ·ƒ)"ƹq²²¹‡ Štƒ³¶ÂÛ€IþéìPÞ‘ èOô\2Ú¼YpÅÙ¼œ˜ŽÎá‘ún”:¸v0kÔ…uãƒTHVûöwuNùEÀ6”ÔRÖVÇk§]%²Yvd­ˆßjÚ»x¬UW3LùYÆCí«EB絛óÇçš–+@šñ‹nGÔ´žtÙ¶££N ¦K5ˆeÌ YÖ_ ®ú#¤ý;·‰plœzx¬.–®Î©¢ð§Œúâaþhy¸t'ÁѵÀXhVuY~ZÆQÈ{‰iù3[|ªQÑNEüù4 Ü)*çý·byê#Lé™Âhdþt¤Öžeܾ 'øbŸ‡Á6}Û?°³íÑÓuF“徉Ө‚•{½ýtwO³B.J?^xÚóâi~-=€~°Êì’BPÊq8ÁïÙ öiëQ:PßÝ?ùÉ&,Šy¡ƒÌ¦ôˆ2âÕšçðƒ¶Â¦<úe‚EÅ{ëÓñ!#rnZèœ[ýxÝp9ã˜T°ì禷B”!Žæ‘Ê«ûC뇺Ÿqî†z=Ú$H}c nšF¿›FÅñꢷíÏ1¥ýZŹQ?pÌì{®›¥ž(ÚûMPö'IhiÖV:¬qÿûÔ¸3¯ ý*Õ¨Bî' bÉزuØ2~ê‚q£iáüîìæ[¹q|^æe¡ê`9N”?ê䟳TV¨/ÑDRpÑÍ¡õ¼–ø󒑇ÕY®/ÕTæ‘š!è¿«éDŽÑÁNÓ‡a¶²hå"ÏÙ4J¨XZ·^ª†sŠE`ÈW›ŒOWX“ﵫèY£Ê÷Ó§> R:‰Š12zBÞÉ7?Žñ}z̲ZÇ@é§PªêáðËS½Þ A±Åªá­|ÃÖ$¡ß�§Ý²­pT5Š Í"ãf9#T0òÖ]¢h˜Dà *)N1Ê $iêò`3œ<÷3$…Öå²]zãÌ-”;¨£ÔC(¢ÍÔ­£Ns“$IG#NZ¤‚£T×XMªÓ#”Ë,ŸÐ•·LšÜÑÍž§Äh{¨­XÚÃ~0#g+’„áJ §d$Óç—oÆĉ ›µ­C˜Jï=™¬ÎN§YË›Ð}êßè×ØcEÌž3£}kµuA \f*ÌUcëØŽ' yepc‡ûYŽ9§eö©pŸs(Úض–¤*ŒÇÈž°þ3‰}_̈-}о)UßD?mÇŠ7†êÃQ0ÆÑ(­Ïè =¤ØgN† bÔ}n‚ì}vkde‹3ŽÒ_«zÌ]iyþ‘ísƒ> =ãdV9¢ô? âþÝ›{{JlŒ­þÁ„:ʽ)‹Ô2l=¶ÐƒxƒÑžd/×ãع2è°d¡S“Kã2úúXR[?ÀÀ¦¥­ä¤È¢-ŧïÀLyĵmwÀléeÙŸº(l{LúS;VÌãNò÷(ÍÍ|®%÷Ž}m­Jd‚ÔÍ�^” ?È%�A–:n +óÍ#Ý€lRS HA¢—¨eçvÿʵOðVé3Ž_ =Áú«â™…(¹écþÏ›A‹5QÁ4h_¾µGhÙî÷5õ÷(},¨{ºWÍìIM`,YõV+„aæå~W=Š}!¿0Á´>do«|gÕˆß6¸%¥ ðõOȾ^1Ë<)²8¼â¦«=ø±¿6Œì*Lñö•Bxâ¸%|Ö×täw•>g˜ Z‚ÓcQ†(ÎW†v†9[­Z,‡åï…uLÁ¸û pœÝ(º9S}Ñ—{Ú׶Jg¼LÈÊè—ÞÀÎp‰µQuh¶ç“¾Ôí×}1¶Ìè†Y\ÑŸ.ŠÝoÆ “X‘{ã_|¼x[hN0IÐ ÙõëŸà9àúE‘¡&A²ïU¨”Q/ë5«#J±¸Á+s€<tºAŒ_¸Ž1ji+ë¾áoX›.Í÷gíj|—JOs·[¹¶¡³ AæË0�)À܉%ºôQRŽ&9•wùÃ\Ê—•g½ôö $™ÖkCÕlÿi¤=ÁsŠ¤/õï¿2š¾xš¢â ‘%Bk  `¿WŸŠÌ¦ÆÜ¥ÿ#`%W¶BãJ ×KÙ4ôç!ØPÑm»~:óèžÚ† @hÀN{y"Ô…ÅJ?.’ ¨þ:ŒçÅ@<,jÈZ ÀOºIN³o ÆzCîK¡@âše"<–¯añ¢ Eî Ysƒôƒj›ZÉ-,˜Àgù@YÍÞäÚ¬s ¹Î•þòO^`Ë/å9dÇØ~øò$"‘ˆã©A—¹Ÿ·Ðùæ:ÍJ»›$ðFêý›ò{”zÉ làE6#|?yžÂ´íúëË‚YægótÆNT]'}ãët[it;‹áwß±É3¿M+õ^ꩤë´x7�c7ª¡h ýî%1¼Ô’òãåºÂÓÍÑ ‡@у§Š ×Úv̳¶š o¼ßÞukØ®i£.ÛÄùÛºÑßÿÞI—y‡§ó/þ¼ÓÙs!gÁk'ºö讞Sézg¹_oу:×q­‡åýhk7^ã· |å±»sì¦Þ2ö©gÌxÞ^äŠËW•lÆ ýføY8ƒ@D릤0µ·mî@/¾†Æ bEækšA´<ÇÒF?ÀœØA^׬¨Ž"+ÿw:)}`$ ê;Š{“Â[¡áÏ2…œ�ÈÖ}YÛ/Ê1°ñ~§-¦>g­`b.çX¾{2¶uÕHvÔC|€:+óŸ]Í£"2p³Bå”þÐñ½«ô¼SÒÉsÔü^7 ô©EÐÞkC*a½, Ì—ù‚gÀ€Î7±}]þŸ·¡—WüØ7¡WEê_)mÕ›1–âbÌ,äoÌã–Oå—ÿHVzh¼XDehiÖ£+‘ÒlÇ¥ÈÚOj‘w 3kM¢* uGk(W¯cbÝM¾ñ1 wEÿú)„„=_:_FŸÕ©»s$Ö&Ð8óŒ‡w«[û,3¯ ݶ¢Y«ó§ÿd·ƒ×þš .SÔ_îIPÚÞT–?ĶÉCË�<s¥bß~ïm<ï&ºýÛ -0Ý%žˆ;‰šƒ l ¶¯wáà`žG®(3p-? u�¨Tx†¢í^­%Txç&+JÅ˲¾íÙ¯¯û3¹³õw¯0„g¾Ë9&;ˆüRÅ9 6ËÕŸ©`'ïS!à7¼@U„ÏÈÖ ¥ÞþŒœÔT~Œ{�Ý}ˆƒ¸šLÙÇ lÊCÎG•é»‘–ÁOÆBy—žçªäÖ(¬é蘭;×xW`«TÄêƒ]¯¹£kúU?¦Õzò´;a™iÓη>}Ã>Ár£(|ÅVKnõúOÐstˆ‹¥cÒ4(—ÎÃVA¹j¨l+ë×â0ž 6X 0y'Ý`r¶³JZQh)ÛNS ØôWÿ“³Õº±¤ËÃÕü z;%-1e‡æE¥–hæ¸ÿqe¥±üoŠ<DQƒÇnI¦™b¤E+£+#]P‘hðGŸÚO@ö6W"}c#è~D¯€žÉ?ëñûm/f4=mêâZyClêÚJΧµƒI½K7¸²#©X=JCÆŒJÁü½žee$Zñ¶l{ó¿Ùç»Ä »c.ê“*èmLFä¤ob—ËU ñ6V‘XDŽ÷b“[ëqû=½’µw l»ÿ[Äþ+AĆrÑxÑ3 ²Œ¢? Šæ0 v<ÿŠn¤Þc†k· .ªœ÷;ŽûëjdÕð#%ñ ¯o¢˜ÿ­sždN‹QœUkH„õìyÎ@ÍÌ ±x.&ò#z±ö|Cß…à@_¾°@,–ô9ÉÍíÃôÐÌ9äÊX/ƒ›P$ŽSšù´Ž®ºóó!¯ñƒo“2’~ :Abëþ*ŠS³4Õ½Ïb{Ø©ÍBgð,J@ª!†Îk{Òr”HíK"4ê58µMR®»ø>Iëz)¦%õÀ|K<ãE_ûC{¶…:bÓuâq(³qïù¥y‘­´î‡Sê%±òUßÌUXsK®t£ Ù;,WfÜ}ç'—·#¡î‹Þ·RgTAúÜúŸ·8ÓZŽR¨Ž5lÕ¾±:*»»ê+àN‡ÌTï ‡×±éMcy «,hñ,á< ®G<ùʼ‡'h� ª:+¼@H[Õ°Q-ȵ‚Œz²Ÿ$„É@Á-¬{.–<\|¯LEÑÑ’¡G£Ý”é÷Nó‹#  o‡äfÚ]ä<_Næ¶Á«uËMïÞ¥+Ér“-™�û‹<+<ù(dI0Ì,Š6Bï–ÎöQ  ]Åõó‹áÄÈòœýRQH=kDIa¾Œù¼Û•û©:±þ†à?Ï‚u¸äDÐh T+ª-:—g¶,üU5É®¼¾ÙÜñWºà±Gè0lÂöMÚÚª¼ œt<óµò»˜HÖ, ½Ë_OÙêmN`µÊ ÚS“¼'.”&hÎ|PÚ{03è>ï'TÇ ñàZABåÊ;÷ Žq¨Ê¸ô¥‘PE–ƒ¶Lõ¡Ü­WØ2ôYBôhàR *¬qNL»u|Ê[æU·8ÜlòÔ ˜R‘™iußÆÑ·‘ïËr2±5 ³“Ÿ=E¶…vÄ ïæTœ`{eŽáh¥ŸT@²Ðò…60Y·7#Ç<V�Él‹&ªéKG‡ç'e Ç`”ϨG;Å„_®T›¿1w*[üV!a ýˆ)öÃÙòP¾ñªü­ž0×›òñÍûìU»t‡Ž'‡×¡àÌåƒxìxÜ„§Ÿ©\EñP¸ìÎy°™gÏvá�ò¢a„üOÝ ëY&SÅ<h@“ÿ|÷�ÅxÜè/N ~H‘x%Ü•ãðFZB`¤Õ÷1ÑJI[ÚýŽV=[î[Û‡€>Át™Áø.Wó/?¥Ûdl¼|Lé].un Û:ЩVtÆ´vy—wvYäŠ÷¨0|ó™R¡dÒÚ°Ôgô( ôª%ÅÀ¯~'áWøü6E*ƒÈ¢}•¤¼ª­­6}û%‘Ѿ~ꕉS…âÎ{݃vuöH©œ9¼SM§«÷Ïý ;'-î^û"ˆNWO 8¸i®z‹Ër¤“Ÿ.m ‘82'Ö%%ue¡ý‘O}õ·úÏ[®R ꆣΈ÷uXï*³Zí£L›4t”wž.¨aXÚnÞ+vfÞPR0}b6K‹¬ù"ýŒÈ”íßýØiŽâĵšEEr¤óµèýøŒˆ§b±«4/ž{W«Ã0w®eÅÁ�™ï“ö. ÀÄâ6VJÊ°7 «Eûp?wJÂÕ@çcÕ'T \<¢$ws¤sι Îqßﯩ¶ãt>~wû+V %F iž4=ØŽ—¹?œ\‰÷ rÆ$�¸Û–;oíž«É÷z`ø@ö¸Q$L3_Û3Ž‚­¡¤VÌ"«à‰Î4‰V÷CžOÕ¯4@¦CÁ•á€­AìàVNç6¸ÀMÍÖ’ªR@öLºÃöƒ÷ÚL�Ç™‘»·Ule~Ï ªµ=›Æv.£°bPÐËf¤‘‚¹ÍÄä2:JÒ½VKtߥeÅEš‘öK¸Ógæ¿?ŸmgÞ€™…™â˜-;§ÇƒÄ‹KºWY‰mDH€žÁÉÎÏVÜÅxñ˜t装"ÕÐVÜ}«4…ÝSQ?NHêüÒ141‡EÐ6>GÔ!<ÔGiÇ}°J€Ñ/ëžåž¦š—ý ’VvÎvÃßÅ‘½<Éâo¿W<¡£hÍÉOƒº)‚ÔÎGк¹´=â¨Âl^uFyzb8‘Y¿_½Q'×Üú^µêe^n/QóÒM¸Ê%PPÐcM??íò‘–W’ÎH‡ji›`º «‰'A˜s>zª™N¿0=ÅxSV¿™9N´Šœ1›ß¬òœF…äÂ*„ÑO+û‘Ëxz;j"5U^:0›™ŒÁ3ÿ€tÿE[Þ27pní*-+Œ ýÿÈ,“sùA¾¼ ­J_L†Š60ãÓ“B7y ðíâÅÛ ÅÈ®].*K& w¸±"ÍpK‘¡X¦„-ãøÌjAß;p‰cR±gŸ¿€ÛóÄ@¼d†³MŽï»÷à4qú¡:JTâ—£½Ã˜ù8ôØ5Elíº¶•ð›êÞÈ5HÒÉ©ñ«ò¦6ñ}Î9óÌ5¾“´ú½º¯;0‚ilo@T‹_ýšÇyhü(„êñšˆ­µwj†o \³öÝ1ž¿ ñØ ‚ZÖ“&)ªzxb J˶i3*5l›yÁZÆp×”êµ�}×IÞµáUW* J¡oó,ˆv Ìb6­ÿ«Õ£½ðúߦýo_ý÷/èÎÎ>‘I¬ñ@ßáAå•" ½…õÕ‘�¹¾gg‰}Û0ÿü%a·<ÍüÞ ’ÈogÃ_GóV*¹ù&¯nGjXE¦?u™sZ»Ÿžg¬¥© %>LüáO»>uoÏàÄ“dIùËŽži6Yûf€.A0±»‹c’wùƒ’F¶K%Àñ:ˆ®6çë¶bj§Q¨‰(ó’34ÓQVð´àà_< ¯0fL FªaçH’F›Èï&çî×,‹ôbgÊÙãÎY?£i­‚¨sEA½zߘÿóÓc¤tÛÓyçéRy ؃4ÌÚï¨/×îs‹ÊU)ˆ¶’lÛ&Âi=_dÏ©–'ªµ´§ÏþyR<™¡uê}rA÷®¾£ÊÊØ/>C]dV3>BИ6s2•ÎkK,Ò¾·h¿¡‚†Iñ¦öT[X'ÊãDZ+,Óly '3áxÚjZ(À£Or2.‹‹lY$ÿ<Úlœ‰oˆªcêh´'ϯoGa]ðƒJ"4RŒìú4N³Äëi¶‹ÒEŽ,»±oža³9=JsÇè¤kZƒšï%:hüø‘e‘y W&qÝ øþ³v)\3lW ZTX&Ð…F:¾irE®MÎ ƒTÀsmimØ°•|ïQY$ÉDáq-ZP󊕃Þõ,pº~6fV`²±Õ‹£7e«NbJŽ1P‘ å·ÌÜÉcÀÍä#vsry(?F“-™Ãáщ¤$÷„ Júÿ¦G;©ºÍf 5§éÀÙ¦ùóû>þ/l)_f±ù®¥q ˆƒ¢W£©4wdÕG{(²u/¥¸™orËŸÀÖH,³«èf9ÃLÆi:ªTÈKG¶Ó$ñ¤!ͦ|:®NdÄíšþ*)ó£Èc\¬D;iM,´1¾öêÒ(ƒdãzÐl;³ÖhƒAABy9áƺbëGªïú¯í‡¶ê6P¿ß …¡$Äò鄲ú™?§êtw`µìꪆìU] ‚îª]:î²½ÍaxrÏ~ÌŒ¾˜Vn*LµÅ6NÒ#Ï–ìþ¥7ïÈ Ùe®’È«MbU6¾*ª _Mt®vÿRöúg”ÊѵÞ<$ì…æ^Yäz¼H'äñ�/É×û6 jŠiÙåâ¹mÀæÒq/mÝqßã°A’®”{—Ò¡¨.vbƒËÙˆÞ$�‹œ†ÔEñO¾†…”ÙŒjºé¤Œ±”ݤékŒÍO”L³•Î:emu”;5ÝÙ!!ˆzÞiÑê¿Hîà3ìZÿrÝûÛdžATúÌÒ?Ã_ˆNQ=÷K9†!o-˪æ|›½§›ÍÍ´ãc)ƒèsç9„b FÍ×$·ÅT¦í-)ÁbòÕ‘Ë’@°—Rᢴ!^ïù]DŸá)¤Fg½ÆÁùãºCIX\¨6otù{SA&lBWÚ½áNÏ7µ^¹›³"iEex»xiíŸÍfŸ_]×]´àx²bââ&‹âÌÈàqïó2Aw­ûëÔT‚®…60K…)[†¹ý„²,bÝèÙ]Gøm5~cÌ9Zè±~Cl3ì¶Mè6,‰-‚¼¯YAŠŽ¶·ÿ¾qܪlÃéðѺ_Ëò /†Ë¡_䃺«ÈÖJ£#Å_é{ªÎAÂ7˜Fd”üÍÛ¾¿Òà ®oTô†ŽþY]ï/×¢‹}µ#}Ag'˜½·_ï¢þ¯ã˜uc]Ï2«d4îxu¬æýÍ8-Î2AÐó?œ�¨õ\`@ ã ¨hì@à+Ÿv—@º‡Ë[ÛÏ(Çñü&ÑÒS‹ò•*‹ŲÚy½HüEÚ´i_^a' ×·ºÆ…†¾{�,¯CËíŒö ¾aï•÷F—ÎSVŒ¨%ÊÔW ÛoT¯å†3NÕ -ñ“âp¿T,†MÙCab¶Ù7øoñLóæG±ëzÀ¦â¡RäK—úÿóü!ùÿqên âZ,Š œ*·’8 NTp çjõm£+rpŽ{W܆~ £EJ+ Z¾'£Ô–C/U,!åP@óú””] šøï´x²®s&PãÌž]NIĘŒüª}˜Æn"ÂÄãí. ’Á"ÀaSJÿÏnĵ…ÛÄn÷ðóåÈ5oÁ¾C­¢îÝÅHÊ3¾æQÔëj/Ò*Û‘ê+„¶W½Œ";ÝJŒHû…‚³ŸÍóœú|àä|¦¿%eär°w«¹‰ë>s5,Š:çÁ×xàs_ê5m]~¿øNŸIÍ抵11C†&±=R¨?9­Ï/æS„èÿòl¥õJïüQ2<Ëö$¸ 8UÓÚÚW‹ØIüÆЃE鶤êhg*,R=[øe%ø /Íz¦›yL2÷CÄÝäi?š±«@`%É  C²¾¾A׊½X7 kÓ±~4é WïsHh¨Š»FÅÊK®bÇA{Pò~÷eMÊíóS‹9à»'ÈÊi€Í¹þ9˜¥ÑJöÀÛË&•¤GãL,N_Â:ÓˆU"[[µ<5 GŠsLâð$þ ÑRŸ= 6ÜTˆì{’8‹jÜÿ4KŠsÛ@w$…†`ÎþA�*6½kÁJGíik$ZéeSR2"ÜìZÌ :~füñ Ôp%G¥¾«-ÅgUµ·m3úŒh|±¶“LÔP‚´\®sJjŸæ½Ÿ|¼LhÜÍê.àƒJ!V‘·›ÕÏV±BêÝv@ÆÊÄwýƒZ&yæK5FäƒåØ¢HŠ+ÅI¶ 1ò Ò©TT̨ 3”ÅaDa2þ À7~\Û‚PDÁ€tPnK|Ü´yìÇ#öHˆÁObAeèß(Ú[ð¬m/:Æ®:]g-Å,B¬å ¼Pjœ;f„ƒÓHI}kAU±V§ž4¦CHZê.1gIm¼K/’ p'¨_Ù4*bîßÄi„ãå¿iƒrõ㮥—ý¡’d¹BÊ¿¯2Ãó:ïÇæ¢ät‚W·´ü÷ÁéÒ÷Rï"ôí„aF8бºìÕÝ„‘TbriC1º^×&xšXk~ûÐþÓï¥L‚訤**ýðQ˜rx¬YÈáhŒJõB s7 âHÙ²™ðñÑ þ´“ÈP ‚ ßÐôè‘p“Ç]­íÖf;"y�fyçµxBb™(€­épä5ð[J²N$Ö¶\PÈ® ï±­4X>³ l­à|,•ºiÏ+!õðÅ ’q©Å¼LÆmF~,P;j¾<?Iü} QÌ-hO””É¿œxµ¬ëf?ßÆó`ãµvÌ‚ô¬tǶ?b·ú£­< DYûÍ¢j`È"c óz³Y†™ßÅÀßâD©ÒfÛ Ú’·¹åÒŽEw´¶Ï½7·y=Ï"nmcÈC¶ !ˆ{Žûqæ”ÉoÂƩ⣠£h0u(âwê$ÞV\‰³±hÓâd³àÁÉìuƒ'.³lWë¢ k„“rÞÂS,Žƒ»êo+âGÉ¢íÅmO6÷eëYkŸòŠ¤­¬6)@i»vbÈ5cü%0‘ßVüt¸@»V•¢Rã®×˜¾7k¡�$÷µÒÂÖ®Bže¿Ä¬µq+3¨:ã˜hè´9 4ñ‰kbâIù–8??–$H: +Ú°»amrÕqÖÔ›-¼â{Ò]—Õ%øì×± òÏÚ©‹c¢qýãaòÎmOI„üû}GFóAz,ÒœÉI7î2<>Þ·&Qƒh©ëtBC£].hK³oÃ-ëQ=ÏÄJo¨–ˆ:\”µŠ6(„Á·æ¯©ÃEÖÝ+1Z·uGÅH£F™2¬¦¬Ï­— /çô+×P?ImöÉiõZ Ëef›Ÿ‹køß;N,Iè—"ÛAj¬8i¢&‰P!ÓW»¹¬(µg_[$ÙJ¡§ê™@þ>¸@qb‡/ƒtUµ⺖ª‹h8F1ŠuŸV£;UC>s g;Öl‚ö½á\¦F¶0‡›«_Í®S³ß¡ªRÉÃDw9íú•y­;`ªiÒuV̸rÒ¹E}#@”®¼c(“ŸA}÷j¦ã¡a­ê¹ýÖ! ZœT¿vçŒë×¥€aP½ÿ “ÄejXS¸°PÀ¶Ñ/–'ò>vƒéÆ¢ Õα»4­Qº±”·U½×*M6«ÃÖgÕ'ÉÞŽ§À$ê«ëi'óý=|–IPMÉýi\¬ÍqÎ è¬Rul†ÃÏŠ Š±5úª¹Îǃ…qþŠN2¿›bÐ�½äÏgè|—Ûòúo4]請¦Y–*±Sd­gVa>)¥„ŠÂŠëMþ{&e”%®ƒLHvj«ÜµTà ‡¦[Yî¿à÷…æŠulúíN3¯uÍi0'ˆ¬' ÄþÊŽz`¢ýlGE‘¹Ô(†VeÄÖ¼“…¸ª©÷Û0{§Cx[&æ¶{Ÿ”RfFûVQ¦[w°NX ,&á÷\Óxœfô}샑¦ v,Ü7/E:Z"nÙ�2)ÕžŒ÷¿°·ä�k›u¼ƒ/|H"@#}±l±RSLÚkÿÆÅJÔM»âå_€.ýô·Ü8R0×è3ùYg…DÒ½´Q²>óópÒµzS´XæňÞðôº½¬l –û„™ç¥— ©9ƒ&ÓkÆ›1H�}t]ÙÍ\¥iž›äDq–Û€ƒ‘C°ì�‘ÑÚ j$ pg]'B,­E—©¥@¬/¶'í­‘íŸ,ØX¦hK)À�<Ý.àCf®#~$#ž¶8‹^è mÌL]¤¸Óäìø0·‚~†}ÿHB6òeÞÆ©Bž_åãÎh•AåÛéÖíŒ\ÔíëªÚ*=Wö zÃD5Ü´³©SÒ°LŸ47rnûè©ÞàaZVÛnÖN@Á6‘yÉÈRå:„Êë2w<îÇ #¦Öj¢¯ù˜/±3íimá ÛhƽžÖd¥“þÿÍÄÿ’$ý¶â±cÞ»%8¾Ëý߆žc µì®yP©“˜ã.íâÁ¯èNãqø¿ªvWª“¾ÿârn‘¥ƒì3«’ªè²3%Ù´Ý{"ÅiáÏ!P@ÒÝš;s2HËöÿ¼%©•4”µ…y»È|áL†¯Ì´ÊÁºGšDGzomF1lB÷[ì0ãþAp6/ û 6â—Þ6]9_õà®êéùUªøTÁb´æåBîΣÞÓFŽÍ¾«+ŠËäÊÕ¹ú2Ž¬§¶šÙaðÍäˆôÿŒ* •�úLžÕ<ri´<ÿÝEæ÷øAoÛàS#¢2øaU ,VÑr®ñdô—.iÉùm½Q¤¥?&…çÇ.æþ¿k¥É`Õ `S ÐB¶!Ý‹"žÏÝ4:?¸ÜU ¬ûx(à¼[ €’Íì)ÿª¬]Ûù¤ðÂùƒ»n³6ñ6Ìjï¹[v -9!Ä—íµæ ,³Ã,WgÈ';$Å]kÏÈ«£`³ÝQÚUV‹GtÁ‡~kF:›Ús¾ó8,'JW†êüdŽ•yšy5€ @Ú}µ¶;,ÀꉻNvOÎV¨ìÈÉe?'+=ºžô¡kép• RõîlUñ‹Gëý¡1á`í¹9G¯#Ü*+µ³!–„ßÁ¥d}¬•m<U†f,S 6žÖ|9¸œÐÎnrÌ?Þ·eU†¥óö©˜™Ry¦lfêªÇþÓÃÙõp×y!:UO‡Càys ê»Cpé[‰ý<3{=”…Ž¼á°,„8P|&óżåy8PžÊhSý94óU%gúÈ o-pÁÐ,öHù‹Ë즪N8E¯þe$øN=<Yð£?çAl^ðg<µ ö²&ZË‚z& ²MÝŸÔÜñ€vþÀÇåPͪ“ç L‡ç†ù <5*"!Ó™ /!åß*jŽá'ãKÇe´éç±ân½Z}{?(<ÛGžs¯ øïA¡ÒœÂR½=g¾ÿ4 ºã®”ÝOj\+¸pI2 _V‹¿C—› aüç­4]À ½KŠÒÖ×;Ê,õÈóÜ8›G <›A bqlý…‚2EW-b¶³Îs¼"é^Ê)¥F4xY>¦÷Ô­Š›eTß±A¬ =#Öø=½K‘ÔY£WB¥·m¸É²äh^«É\Ofö ÐÜõ™ÔèÆw!Dl‚ÞÞâô×$D`Éžb¥Ü‹ƒœwæjVÒû¹ãí–­MlûžV}lá}8’ ¶ÛјôŠ ¦=m;óropéÀÁÌÿaXžT&â1:R‘6°-cCéëÃ<Q K3WÜrÚ€ eOŒ V>ì­úa¡JÄs2‰úƒ|=½ÁŽˆÏD2Wn†KyüÑvØTÕH]žJ„ÎÅNY[%­0mù÷WhIY\˜� J =Ù˜¸~¢2œJt]ú+7­”¢Hr¾Ê-"]sÌ &i”Ï_* P™¡¥Ì¼rn¯.VÔÛIXÀ·~îÆ…ÞàÐ {ÜG“8óØ×´ô&n“×J<AÛ‚;ý²°±" â MÚfü‚ÆND¥ñëËÓââ¼g^òq¯ÓX8ká°^þ¤AfчLwÃIª…47eg®2ÊÄð—Þ4²þªÐgWê#Zg/ÿ¬¼X$`ÎXmXÕC>4‹GR¨v<±˜…rN¢™?Ðï [Ae;.+9TSx/—7ŠÒÜ`/ Ýü^K ì*ãåaÉÞÕvq=£GJðiqc¾ÙËëëNú5ù„G¸ä¶<ªYGÃØÄ™ËÙLNÂùÙþÏnqQú.K”CµðÎÎwªl q3*Ï(p*-r¦ÁàKÇ/–÷.ouV\‡Ÿ… 3éþɉA’i¬>ùËiKXÞ`íê™BMÚY,^? Ú�³ùô¦¡ý?ÔŠvË�Œïž£ÍY—rÉ5-0Òª>,ˆéžÎ•@^X2ôF¶*òêîçlwôæYÓiÈM’jAJ±(,Íê»=4w.p£œú³øy|,TòÔÚHü|u¸°§R{;\~ý—ºBÏ.Áà\†8HϾWÍΉ·œ/ß~7ÿø³‚/,F/6Jû3 :²/åQQÞ0O¾¦É&@ë€ÑùÊ£­$êJoõ¡r}²YåEÐ[ºRùi¹q°h~­ñ]ëíEØ£^ݾ*á]ÓP`È›`{A…bê%· b$–О¹æ?(ƒÄuTT OmäýÔP¨ëày¤Ør민òŽàÍ!Ƴ�÷Ñß8ž à!´ˆ‡¤¦œå‹ÉKµÛñ™§wÍXüÛîyª€õãò–lD4§3€ïÿæ_%˜cµŽÔ¸dê(‰gálÅS›z1ço§ÃVúœ§0É+ßÁýÄÐFw>p±Wµ‡(7’ $wC[þ²'%}XB°˜]ýHk„ƒž¾ò^‰þ/QM¥ÁŒ}ä“w¶Ã,—gPšÎÊj³C áÇ–aú }Úæ‡ja;x5x9H>Uf\#¯ø/™o‚Äjó ‹'g¯@ÓS8Ó#䡺gDÃí¦e€Rà§F ‡¿ÓaîFuån yuû… F½n~”lîF6) çcÀŽ¦=(âñbÙ_FË:m¼†ÏS ø€²^¥5ľJdÉ[ôÍëÚ5‘"ÚÇ=VÌ“™Î"z¬¯ FsÏ•£^Óf%†*å]p@‡c¸0ð/ÕÀêߪÝC!Ç<¶Z H:냓æ54[±J!ïÔ]ë7åª OÏŽRûÄy,e~ª¬µÛkŠYníP•‚€Î-ßàÎÛ_i‰³_ì‘¢¾‚_Å<û'…Pª£Üc¤ƒòÔcdûʪC™’S_¤XüÎ W»˜Â<ågeSy¬@ÑŠ“Ûñ1œÉžÜÕ£fNî lËä;hyh#½94”îÿˆé—‡&Fqb|GWÍf+Šëz+(¹œGªõú×ÍGC³JÙÃjªœ­´*Qp°…Ô8Íl[ˆSüÅ %Žß ÂÝ{´ŸmecJSÏGõÇœÛýÞÕm¾+#ÙÌøÏÍž÷±ßüâŸ|è< R!yÔŸ­obÆúCoýù£½ŸR=4—5$Q°d�Z;tÊÕg#¹Œf·ŸÔó€šöæKcY”­­Î'ÊÁÂ2à }e`®Pò)çô­ÚJäk ZCi6ßû½÷æ¬_0˜‰ÿ®¥e`;8ªÓ8¸£óÓv +"…yÓ8ˆ÷g`¸[ñ±<»A÷ ¬{“·1{—ÏZ“PߢhãžçÃÿàÑûEZ‚E)lFµžNtVëÞ˜Â+[Û`ÿ(‰<6ѻџ–¢öÿwÕÄÜD~Ü` #Œß–Þy¬Ï€UMWacÐêüX#QÞÐ@7yä BEUo#xR62—të:k‡*Ǭòk4¨Ø=}OfûêrO“ví*L;zßÓÃJ¬ë|ˆTxÝ,YO¦Ñ»üù³ýŽžûvWÄA9]½8ŠØõ 3Z—3,~½íiQOm«¦zÛ^±èp;îýÊ+cDÞøx)}YjC*Ìi…CßϹÿà¦T¤n JÙ<CäùZ;-‘I2ˆ'äM<y{ÚZŠËÄ»ˆhÝþLÇÃüåÑ¢éÐaè®Ý$^KðNs0 7 `±ë혛õ`d7¸©±¢eêÒ=ÿ¤$Rz °ˆŸìŸ<ˆö>±¯«0¶ð|¹FÜÄq±Òí‹X¡·¨Tœ#0$õŠ//ØðÛ‹÷ýâ[‹î £Ý¬Š’ÚÿŸŸXí¹JK­œMp®7f ÉEi¨¦+ŒqÂ_idߨúŸ‰þHÉç{¬¦4uò‰¹Ø;l‚hù4ídˆ Бȟ×tóÍ[ß¹âtû(‡弄Û“µ2Hê³5qŒÄŒ©Åè]Ë5Oh÷±ä®u"äžz:g‡ÎÆáqüàÎi}öˆÂ"VŒãWÐTWžóô î™y¹Ïʵå¹QÛðÕfï�±%ùNY¡ÌŽ&ccN¬«aîGì–yiØzk-¬¬âŒt108@x¯z³ŸÖ—›4óé<!øì° P¿]æEÔÌà(u´ü;=Ì,wço±®i½t–о‘£cßólƒGW ®º«· @¿M5Aû÷þoé¾—qæW(%à¾iŸ”+Y•jZÙþàÔ]F·5ßé{ã©óP`希ΞEeùxuVåÝ=#>[ÝÀ¨4´§¹‚ojRà¬Ç~~¨Aj -æÜW‡ù‰}3¯æÖ³-aÝäAònƒ:K.Uƒséù®üD28*|³™0¦ã‘j k¢)JF“Xiìè …(ê¸î®LÇ…ƒmH×ë:b|UiW!W^fæ3 ”ê ¯ïà8T•Æð Ò`{ÙåùjÕÙyÙx<º(ç)?±åëñ»2ŠÑ]ý‘;{­z¿Â+"ÿ±ÐY[×fkK5Rk>›v½ÉóÜþx¢eîH>bïH…RAÁ»,6s¹qtO‡¸ÓÀÈÔï÷†gÙŠ•£Ë^ÙIS(u-åVû‰Ž¨k¿K6ÁÔøåÄ*Ê6eéŒì®„Ë êzsªAÉ{ÛRÐ3žHûŠ0®Æ A#/ÿ £>î,í-«ù¼l4³Çƒ~ĈŽ]g5â䤞éÞ¤ûÖôk£L¼ýÞä“Ëóeíý먺ATfŠR‰UÉCú ¾ÎÏ=½>ó+×.KÌü@E+·ê©¾,­„5wMKί‘í¬°jÌmìÏë<ú¿lc2¬Ê6â>8Ï»'ø(›—"‹ඃðôœ×¼É<‘lo鉇C–Ñ1t>y6?é{0?ÐÐJ#%½5qäƒ&E3#äé2_¢Áßë5ò =£á‡}'2%Î- bav!œTµ72Ìݪ°n[dBfä$–†v°³p�TVŤw醰úÿ¼õí8Ði4Û²åÎïX{yæÅâì5´ÊA>=CéÚ(×ü^ª÷8é3>˜òæL9?ìé9DõÅQÖ8ñÓ|ÞèÜÙ‹Ö¹>Ë‹©ó>öŽ ÁØúÂÿÔNÙ•ÔôF_éFYò©´£b0*‘p_=ýäèoÆðôŸ©”îûÄæñ7å'd 1é’ôx<÷íŸ ¶_´€ƒ˜†½ºsTäC=“¾yLE ídÞgÓ“x® ès¸˜šsúqØyt¢ª¯­m¥‡y†)7+µð2Ó’g&gÇ I[@ú'’mÕ…ìu/Éîµcî›> Ê$”ep»ª­¸"Ž9c¡13“œÎСæ›´6Ô!d ˆDЗNoñ|‚G–ZÿÖ#8O| ZŒëIæÎ3î•òÏaë×1¯�|bÝÆé"ÊÑ°óÃMU×£ôÉ­ &ÀNóËnGozÆþU3\c:Å÷ ˜‡âŸGB™¹(î»—ßLú¨DZÊÍb¸€²lhVR܈{'K*›™?grƒXRïØgÇÀ¡o…3ŠÄ“ƒÁ g;gŽBMk]‡ì!‚;[•”¤KÛº‡µx‡\ô‹Í 8K¡ê4BüämʾBÎz>jz_¤e¥×’ç™7±#¨Þ!|ÛŽ0Úý|Ó¸ŽÐ/ÿªØ]イ÷¯;º›Ÿ‹9¼=Ó 3¸L!V’ÃõOkQÀ¿ºOZˆe¶T—ÖÝ4F b]`„ çA¯´ì;WvŽf+»•˜ö4Énç:û±o€74þ?PàyÎÐrª#/¼Öé¹OòŸ¾m1{r\9¦w1 Mª÷Jnó¹QŸg¨°s±móØû—¶‰›®ó¬á9¼ÖÙ)ïª=•r|¼ä(åÔ²µ|0©4ÚÚA‹ªã÷Ð3´3blepê‘_Úõ9µÃ‰ë!nægÊ5æ} ÚXØ¥Ow|>€‹” 59¢ž.jÂÇT}LõãÞ÷á{nÉGG`ä¿"þ|¤š[Gè”uðèÏ]ߘхê·úµ÷¢IR’mVzN%X[eu5L@¡k'fÝK=Ìz»¿Éf…^ °~×µ²Eçÿ¯TïwãhìŠ(ËSt(€£æ€¢‡Ç2=ú mZ—Ú‰k¯ÀÀÏhè‰ôòÛqqd¥…T€õ58Ð�—‡¶P£²Û×Uy~ä¢#çcRÙy"9†üÄ_ŸßƒÛÞìFÅ+àjl,¹¬!fT¸†õ#[.³§:¾§SüÎoŸœ¹É?KaPz[+ E¡þ:x¬Ë_òèm'V|b §bÖ´3+Ãy¨¶Sëë$«y6™rìÿïÿg~£O2¬~0™€ ¸øLñ¥&<3 žÓéÐHÎêòm¦°r΀5ñ?w˜<Il~*(7yP^´_Ëu>1œ§+ÙòFØé‰À“¯uÅ4H¸—€¦°ëhVnü�µëYRYœœªß\Ys*ó°ssÜ-—,m·P0¼ Œ©®#}5y|{-é9s{Ô4Y0Ó‡·’43ö·tž©Üào9©þ¶f%¹‰ß¦×Q+N؉˅«í_ÅR\f-k‰�mKºf\:™›œ?àŽ¨ßl¿\ÃÇÇ"7‘Õf’@$&åŹv‡ë…îÔQFSVEé;QèÎïn“åMlw„ˆ¡Ö5´ÏÞ{§Ô&³poù¢‰DEÖýhÅ4·"î~Zˆ‹*”ö³­V!p}ÿï…ÄDGœQp|2­y2hw^6Áædå¸Àõ;³§lí$,€[Ë=7’Äe@Þ✧¼Zeºt²±ÞÕî_ù¨ˆÍ¨:Ôù1e†ÑE·x¢Y׿¬¿;’9úuiÐS oýÁ÷Ç¡¿â?I0­¹%Šü9rH¢Í@Vô´2ñÆÖ\Z0&†¤Ÿ¼¯Ü@güÛd1Á¯6”³•S ãA7Aþ®ù<­ v7X$»7F|6MŒÂ$ò-SVëÚØ~ŽÉå<À+Pœ~ Äf‰WðF¼Žôy ë6œ&¾¤¡�ÊÇí²TAÂ<sy² O”˜þLúêÏ羟YµÏ¬²cÛ ?åRO¬õ"gÊ-²ÌJrÙjƒŒÂú݃– ãpÔ$ù<q*¹BÏÜwjÛ7ÔØ0ξ*ƒ¸Up3ô[¨Ü˜ÏÖÞÀv=QÚ0Õëød›põ¦tò ´-ŠO{¢DÚž±�¤=/]UùçuðPƒ¥}ª:6IÕ]ãέ%¾›ãÕè1RIÔ˜îöÏ›+ô{˜°ÏdRYPM&Ô¸ãÕ&÷¿µšt<ƦG¸g”¼_ÍJ Ç)êm•¤ö ± �oâÂL‘­+Š„íì ºÁèå`Ç•`tÔNþCõ0ÇXˆÖº+{eòQ~Ìm‚L'áf¹ÜoüçmõUpb"¶/ýÿ¬2‘A¨+P6.žPÑʳØÑÁ°–;ßn%ËĦî¤óüå¢$„†N£¦ÿÝ"±­Tr‘ŒÐrî‘­ËÌ?”º?ð·;›³>êôŽƒ*Žx }q0#«ÒȹvÄòFIןj&ßJoÃ0V y°ÄjÎóøØ°}¨Â<n°Ï“¶ódÄX“Ï-Ç7wWYÓ6îÄXýà9„¥ RáI¹Ëgå)ˆSM(Ïùç™DæOµ)Öo;4O*ϧ“50~4c-¾oM+Б]Ñ:LïÒI bz› m¬=.%Ùj„à4:ÅFOQ•w5yÌi÷´`Å-wØo():»éMͪy¶I6–Cݼ„»e¼ÜKçòÔIä0©|ÙQú>ÿõ”Ü´ r’!Ô Ò"[uЭ„çÄ^¡ž,—ϳVôVw«±×9Á÷*ÒŽ’!>̘Xî«6Ú=H2l÷‡öìd+:¶Z¡¿j¥YÅÒÍ XÛ_žsÎЊ¯6øÛ£!HØ‹®úS k½±ÂKõyŠ{™ÙiײøÌ[ nô‡m'KàÞÕm]TÄvþ!j:=˜1W±g,*â2WFLüMæmV0óˆBeHŸg ÙÓ{sê SXŒù1Ë›aò±‚ g‘“ cö³Z³¸D|ìèk³ù›Óï/#Kä—¼1Gÿ-Ôˆ7=t„cUЯy–Hjb­vZ¯tãÒÜ©†|öM¨3VãëéSãór‹A;©"1¥tÂzÇ|ÉóÉDIŒþ‰í�k8‹ÏÝ»òUÐîrß"oÝ3”y;BÖ²±bŒ«{竾é¶gv³¦z7?.´áxÒe»Ÿž,îK†™MfJÑHu^ûýtP¿•©j®Ó“¹MÆ+Ï XsA<¨sÕB,¹’Êa|ãý:µ õg«È“ cyr D”Gmí(“X8ór¦½ÎÕ¼ÈÍë X‘ùîÅæCIl¬e}Î.€hM¶ ¯=‘ÂQró“çÜhõI/”±o.‡Ï3D^›Ò€o穉ç/D5bJyô›SN|’©j2Ž|YQÃÜUU4ŠJCçùº((dh5î­s{‘ÔãRcã‚Ñ —èܬl™2¿9ï\1ágÄj¯„hù=e˼~jă*’óäj;®qµÖ§}·¿eŒO?Í”Ÿiü0Çüú'ú‰¿T°7'Z)Cíµ…¢÷ò(rÌ/P¾qÈ+}çMnÿÂà}ð´L±žéýfn B6ô0;–ák¾Öâ4ô,!#¤wŒ‡/§°& Ú‚ºâö`òÑß¡O N{ÁšŸÎwé{pIƒ¤·jÁ…Ê\�â¨ð êüqÔJÞ—êjŠ3¸ªÍªÃˆ€>Éa‹¢Ó« ^è~æž_Ž©w]gAZ÷¦×Q/r>z-ùu»5Sª » ãWÍ»$w'$¤Ñ• ôéKo-«t¡1?Ñh­Ñè™›Ïé®þ…©•©ûR|^n/´êwÏŸ†»2ÃyqJ†Õó¶S{iàGq¹"Q]ÕAn¥/bc$¸·Ï]_¤•¥~ÁRûÛcB9ùÉe `±›jà=îñQèˆÞ¥³lõZªŒ©îaùYª*:|» ¢HbŽ%ñ}uåéXKkOÅFï쳞ZNYO9ä�ƒ¾B²üÝË¡i�>WYˆÌ8ãF<Qȼ1ÆÞg=ûÏ¿»¨eª1«ŒÅB~çf½«‰8v`™CYíT–2âXøNŸì°U³ªŠ·Wðµ+õ!†˜QX§ÕhãÌæ^-ýèt擽©¶ ,¹…–%ÞÜ^:]Û: âSoMMe‹thjÍ^ûú ×Ô<2s=Ö{¶Ìøü¶&C7—¢ý¼É §à›aD=_¢S¶½Õ _ªëµšT: këb³;ºË}Ù$#’ƒD;�‘ø·b]¶Ÿ.Í+Éñ7DŽE„ôëé'›È7cŠø!Ãë¤òô];|.¾Šîг·)îºvEâé[ç% ŠîË <ÝØìé5;꼦`½I};ZhfþVᬆ½ ä+»XYfAHNÏ…v\X+ º¨/ƒ¢·HqŸçÃ<ÿ“Óƒó¡TÚï´‡®/¡ÚãS-Àyèmâó$¶ð_½7ÄÓ`C)KB;ͪðn„g4ø¼):Ïù>T ìx¦—í’öL“ö€HíDzX½“Bh) MðZ¹¾ØŒµ:ýÒu‡ŒUe§€ZXéBýÔB¥À¦êšm€à|ûźuÍí—í}»áâ&‚ÇjvnB‰Åø2ØÉ8uÞùóë˜÷ \[®d‚€q¸Ð³HûI%ѵ…‹ø': 2IDQèc=`Ÿ|Ý›æ䱑ÉvÖb¡¯æ†Âöú,]‡7SÔ©£kÙõSG€3csSñݾ> Ý:é&‡8Õ'h%,Î’õý|:¸ÑÍá43®D_=>wRfk1ÍîD÷ ï9h_5®öâÑ•¥Åã°z ·Nk]œæþ"“ГöGA¢»hªé<Ü9Ùg˜òj߈/Ï4xvvЕìZ¸EYì=¿ÛJÍWæ`[Ôí ‰Y£­ ŠôœÎú«SÌÕ׳v°D�÷ø®àWb[]±ßÁZëAezCx.@;¾o¬mTZÁû‚7£E×ßóåúæЕˆb‡õ2OŒ‡Ùirú1â™l°îb`ö|Ý%‰×Âç sÉ(gøòÝ×ûê¢ìOölÝÄ$;WxL�¦ HFVI-áUƒúA]7ö[Üt®ò6~ÈYRm®ŒŸÙÆä èâõx/öhktâ¥'Ïó§'ý_ߨ`O{h|V&%¢ª–ò…gÆ| PŠÞe×ÖukðÜe¡÷4c¿‰ÒYÔÞ\ioîÛ/üæCnf½ÛŠE•ér™A² G諵·93íX¸;³U&Q¢îédN³Ü÷‡Ü�ztЋ¬HNKË÷ r¯«ï£kŽK¾w*PÅ-(FmïÓå€ÃõP9X»JìŒÚ'ÿôP·p‚q!g‹Û?àH Ú¶/¸/Õbiòsγl¿_Èv¡ü—K§›Mž¬¼0‰ÝÐrî¬ÍÚì¼Ø–j±„s'Þôæ“ø‡ô¶²ßR€Ò5™Œ|ô¼¡íÙxÊ1Pì˜]pmŽ®~xAà ´°@Ñ †4ÈëY§ zÙ¤†)æì¿á±ÙÓÉØÈ°yc­€Â€ÛøC{ýñ¨sòÔ±yàí�g).E|«È,l{ªùˆ›1üƆ³…|J 'uG¬vq�F1Eç,…CXýh?½BàÍtþÅ 2 Nø+æe ×BW¦½ŠŽó%וYž³a‡b-U·Õ FÃCOÕžÃÏíÏÏ æQ–mu›Á€o^ÓîÅ N–ÌÏþÂQTÄêWŠT(ðœÞ¬o]gµª&³…?RÛ³÷rƒ:/3Ÿ$§‘ ȘÅJŸ½M–:üsØÏ\¨Ü|'5¢2`S5èîbz žŒe«ýù¾î@¤&K†Kß½‡ðh»òl·WsCOTÊ„Q/¬SöÃ_x¶î‘4""ñoÌÛ!é2n‚÷£6jð-YçeñT…̤?¡³½Aÿ$DŽêÁ @qIý_ñÅIê¾ ³áµ’Y?:‡ã©e |žr<@ª8ÁØxóôh\—ƒòVsdQúý !WÝwÐŽ_­-r¼î[S”;á±TÄCn²ìáªE±2·N|Ƭ†VìѪ셼ãú'œqæõS@8M)=ý´Âñf‡ ‰üÉc×Z™À•7Ís‡kÏY !§'Óû¬g ¦¾ÇYpbT´Ž,?ñÄ4¬\©=Y)r_Á ¼Ê·±ª¨Œø&y”GEiÉÑP €HûîwÕ¨êµÌµ\©B†)º¤”¹N{ãåeoUMY}ñ«èùK›+�UÏüþŽö»År™–n"dÙVɲè4£K_ãÅfqz–Ç´8–Ï‚â²vÍðÛ#L¼˜x-73W:7h9šFœß@ž¶5à7‹íZB eÉ“ÑcD`p}Py×›nè·æhG¾oFˆèCûÛè,1TMp!¢±³7ÙpH s‘‡¾…# pæŠYHcVÙomLƒ ²Ž�&Íܬi¼‡Sv¿ÁæÜ{ÄÝ®º¨´§q¾v&ÁTëTP’ÔÝ—xÆ‚"‹Óax8 `¾ÈXãDñr25¡Tœ}¯/kìñÚy*–[Üøµ:-ð¦w<½»íE’ÛÊ/—=ofÚisö`¡Ì½ØgÆ8A9½–1%a¸2ÃŒéÿ‡þÉ[›l€zѳ¿°mŸÚ&à#9¸ÌoÈÒ o`»Vú�¡CTz:‰ìqzaÃÙ·¾•RF¢É›æ®?X©9òTnzSÃD©ûWç• cetÁ¨ï›Ü“ï¨(J&ëÀŠ¦;5ƒæØÀp÷CT­ôXû~q¯ˆRkƒ'ÃùáRñ,ÆæA)-¦£qcŽø@/5Éœé¢Î Ò htrë¬Ø˜øi)cŽ ®7?>tO<M_´­úePT•C¤rŸÝ¤?ñjMô'=–Â" a tü Y ÐÛ}£ÇÍ1Kr&wå/Ó$òÕÍ!ºÖÆe°™¾¼)}µ§ç;ö® ¾‘c{ñƒWMâ#‰XÿcÚSÜùF¸G;(|²s3Ó´¡sí®ù¡3»Ž½¶G²ˆ!í\ ¾iÔJêÍ0ÀHO­É@¤´cx…… D\@ôT†oOsÏK¤«Ý(ógW‰ÜÓàe…†z C4Ú{ÂÈôí)ªWY«‹Î6ÊÐ ¾? cÜù @NAŽù9ËÌÃä“ên,D’õx©[_Q%›nåL¦º`þó/@öuߎ½tYŽ'³e$vTÿ?‹ñäa—+ÑKE1°}W?DŒ�&va’JL�Hþ¨çYÊ×(ÁPÈ^Û•rü^1•:^ ?p1õ7†Öcå”b%CYÊ©G’Òª˜`!š&ÿoÎ6Ûü·:Љ¿êÒF×®¾nz¿~«&ë3ð"Fyæåºl °T‘Y‡÷‹‰ÖWë¿Í©»Tgcœ"py!(âÎÝþ—[]þV—<Ø,J „l/z»2\8TUÖ”÷ºôÏÊKñ¾ì~?·;÷w±êiºRæƒy ÕîÒÀP\n·“eVîÇÝnæPm´fXÅg’ÔS›d…QÖIOW‡Õ  ýAS' ½cžcÐi*XzSÚØY.Õ?·ÐŒ­6„*)H–Þ]9Ùš"Žvƒ1JR_mœD2óFÃ4È2œÕÐÇRÉ:ÊÅ%k³:™FÃã®þrûRŸìσ®L¿x²)õÁ4Òõ_Û‘¾ƒ¾<ñ䱊ÜX¦g{)”åFÓDŒ´¸z¶^A7i€”ñ`ÊÈú2¤Æºž3ªÔ,©\¬„&Yÿ 3•ÎQˆ5צ#ä6®æÓ=d;P_b/ ÞÏÃÖ5¯©ö¸¥y},1c4‚eMX†¼Ê~ï ×4°PÃøžKC×èˆ?hËäža=Ï8ŸÎß¿<9aÔÜ´0\¼_fЫú±{0dk³­*ú lf 4u~$˜ºy.?U¢ÙÆç 2bÐ鼆ë­ò¹Ïy­ÐuÌÖ8 æ4 ÒÝdàɦÑ`Te©m‘;Û‹(hnî7ù¦â{v£öµö"Úй=m¹Po(íµbtH{[øÎïÔ6 {w.îÀÏK_5¢~§Éƒý,•¸"™u &»œ8V¹áq<ŠÒÄW3²¡=aÇØÑk§ìq:¶ž½ªrSz:F›’»bÞ¹¬‘NÿåÚ*v¡kð=d©/*5Z]@œ9, DY´?›Í”|’‰_²cªóÝêeYìS!ÑÙ%Á¦ÑÑ¿üÿWV8õ´>Ì€[ºŠR™ÛÕì½Úçû<Šà—Jçöäé±+ºÉR—f•Ú‹Ç Í(É-^Gg$ÓÁͬ'tÁYpu]F-89Lýf‚hêíA9Ý« §D¾÷_°¿žfclM‹´šÙ^Íik½Ô')K¿…B…’p¿÷'ÛsݾŌ–äøž{¡ÖþÕ,.+`XL í×~ZÆ5ÀHpC_Ú¶÷›¢Â@»àYá?*¦mw@ûËËà(,ô˜øï®° 5K=|ÆumݸAäï7m¡EÜ{b毺AÄk‹º4Ø]i?~êDzfIõŽyÀóDFÉ=¿ÂÀ£ôåÝiÏOû4 ŠVm²xªÓAÑBô9/ßà]¾‚4ÈâUêÀ"PÄJ§‰#‘ôXœâÝjw Y"!ŽfÁ‘îN½31«,<ýÎðLO^óå,XQæ!CbŽaj¯*Fó‹'çd÷¹½x) Ðã‰lŸ<EŽ^wQÄö¼÷ Ìj{±Í¸ÿÿ0” †L“0ß¡pÔV.ë*î@ë}åìd_Ÿ%Üq¼æ¡¦ÁÜÓÞl§`rÛ Tþy.xG±¯¢Æ¶!nR5úÓxjÙ^x¥ J¿Þ¤,—àþ‰à—ºÒÏ ù…¦ßU7‡·ó ÿEG1ņ¹ÈÒoAÑzÖ"N=: "ŸQ|Ô!Ý×ÄP"ߧ¨äA ü[G‹xÓ-Ê&éž¿ÁU–!GôÁ•Ž„4ÜÚzù£4¾ù—”2aÍNSQÈž®Çö¾ÃC˜ YȆ² &g97lo<ž‘&è®@Ö)¸ýß´­y›hâ˜_èÙ¦ÖªZ NÃxá[ÓHžËÿÚá‰#Љ¢Qßç!U~š4@§„ UÑ•£+Š Ó%ØW-‹ã¿Æeê…k´ƒ`xxð±&ÆMîxCE7;HØ ÊÞÚÏ·Dù]€dupS \.˜cN{¿ÌÏ¢ºšè¶ ›OmoNozñ‘<Ùn»TMÖü51b¿‚FSÆÓÓÆhéy$²bD?ÙB«é6°“^•ËÉ=S]´»i­å¬:n ýzú~«zåG÷ŠÒm±ì‘R³(ŸˆÞ] Ÿá+³2³Ú ýVVG¥B”ŠPPä°5>{ÆÉ{*vha9Û³¥šàóÕ‰‹#ß¾‡÷1€í÷kœ=äÌsNÑÌÒŠÒsÖ‘"$F îbÜv+R“–`Ë>IÀäg.™€ò&å¥fNÞßþò•vm¯Úµ‘ÐÙ2«Üa:yÑÚQöÓÿKT¶Öº¦‹À}œñ („ÙWH›ÁÊž€^NHƒ¼å¸ ÊÚr;)v…á-µè2`N/ø~±Ï òdq(‹Õ¦Sya6Räºñ[`F{«ÐþÒ+ÊTëLܱb!¯f´7šKuíL‹|ÜKû“ñªOçÏ3ÆñiÛñxªæù|V“Ý›6 K7C’qÕx¤�8SP83_ ¤ðÙú[«Œ©Ë[ýÞc#^áï 4îãÏE÷ GÖj²²¶Úž�—ƒ´Wì½÷N£ïðrÊû?­ù&ËW‹í±V¼ºäõ–Ö¥±ËY6ÀµÌ ݨͧGã–bÛŒÔoÅòËçEÖ绀�{A@¯°sõ˜Ý 'ä¨ ýË3º·-¿í“QæE ‹Õ5í³ä´8iªý8 ¤!â'#U¦þ¡šé8æu-i—ùvé±�Ó/«Açb?6—ƒ%÷L•xµ>Ä5–©?O§à× T=ųV›·Ûž} Œæ>m)íÉ­~xîh“;4½ÏKd½Æ?µrRtí7AÄg?j<²ú ap™ayá»È£3'fÅ¢á[õ3sÍn_oÏ·0‹ ýà“åŠÜñ~Rfç6JŒ1ýrÄéÇ÷; ×âA5ÕÈåY Ò”¥")®á³rÕ0µÍP­µ²ž`΢0õ¹œµªË |Ÿ´‚OU·½§ÇÔÞPL¼=J§c„µÒ0ò° l²gåõêÄgwîgwçÖp ñ¶c³:ne4‡y~ˆ I<®¡hžu:-¤°Â"’’<ZÊU€5 ηٿ+Ÿ=ÑœÉF#w è‹åûÅ“ˆ¸0J%!¿û-düKÊnÇÂ?Õ0­Ú|Ön¬»£{¬:¥ìE‚Qø2A-û¤¼‚/‡ÞH3¹+¥£¨FAª¼ßÿºÁ~=U¬Ÿ¤µæoüŸb¥Å‘±”Ýé>œU %¦àEPñÜÈ”Å?Î=ñÓºïqZêLè١׫2›¬j±[¼+ƒÞ÷nv &k;À$ ´«:—}Ó™?¬T‰ÌÌ\Ší×òãÌ<ñðøA;>:M^þ…•XWªZµë‹(œ RŸ©…Eq™y­‰«$ÈëÞÌé›|ˆÊ‡‰O m«ž¥¼vÔîã¥÷7Jžè€½u~× 1ödæKÇh¿T­SY÷¿ÃÔúˆJFté�ŠÞ«„ýZ3—ĸ…êô%Žõ¸Ô´*ÐÚýa¾ÇçK£Ì3#†‡JžGóÈ“ôVYöˆ6Ã3ø-W?à¼âÄàö™ž *ËœFzîÙ§Uf†žÐµÿS©Ñ¥¡7Ø×ç“ÙÔ:¦ì73À™SéDW¶ÕÑë ÝCÈ»Z.ÇüK�—6N © ¾”B¾Åì!€ŸèÑê-P¤ìÛ}Ké=½îˆ ã_â‹åFb> Í£o¿Ò ~_œ-ir˜`$”pÛ¯–W,tj$©Ð]+/DøRNôœ£ÏÞ-Tƒ 3!îDôfw¡ÔM=å¼4\ ç%‚J ûÎÓÕl9ñ2çòoinöWIìS›e»wÊðtŠf챦m:AkïÏP:ÖÞŽËGöWQº’zƒ`õ˜†AzÑf7È>Õr0f‰ÒA¹e3ÖZ[æyúÝ®¬pÀLXˆbXnf?íÂÅ´Tÿœ(�žÚ­Ã">fЧ©«5"i7Фƒ¾7à[§L|·×ªæ½'‡H«ïj î\xˆ}nÇâ¨iË úR¸FΞè G˜PúK ª›Å‰¡ÀÔEF=˜ÇÌ“ÄëiTÍeU™â[ÏU„Ä…/+ÎÙÚniË€Ù[w³†¸tÚg§‹)nyœØ9ØÆoFŠÑÿå…åkHµ¾?£¹V)õ FRì9X›¿â§«k´•Y(wÝ1M¸’°IÇÂ3h‹£õ¦cF²›Ù&á›[¾ñX¹|$·úð;§F¨"!œXr»…^!ݳUš”‘5 )›¦Óå}v 1Š’'xˆ •ÞÃŽïï™ü¤p(U¤ƒ9ðCAØ*Ö|º¶ÛÄÑgûƒé€ü úhKÕp_À?ü,½>Å=ý¦ÄîlêÞÒj¿Ôt3¥³§ÝŽkÈÚnüZ $<žGÚ ¾-†ºaí_gP¾«.ÄM€9Ô#P/F–p¹YûYœùrT(ØNeuJ6dÅ:Dåñ2‹ú-%é¹w ðlHTÑ|õ™nLZn…\ÎDÊK>)¡%’ˆ¡ˆ¥WHÉ7e¤sçdßRrgã¹å”ÁÇSÃ4ß:-+\s85ð1¡•¹½Pýç-ѤË(RÉ—1ª|¯©ó±Ð¸)>D˜„}0ßW}€O‡{ý?�n‹/Á<qàºÛOoÆ}‡K¿O›xÀ È<³õB´èè̬Îó¦B¯djA62ÒWféë«”—ßwBùvPùûâ=èº~½UÓ2¿Õ°V§U A£·ÿ¾Ñÿ·Ä+Ú?¦/vWî‰ng’…+¨ÓÚ4uãñMVjkFçyšMüz66q¶É±q,$í}w:žÈo?lå7ÀÈ×(¡Ã¨?§´Š5qÊÐYRÙägÿ{ÿ"«¦w°ÆRܲÛág£}“‚±�X+%3,yî´NK(1Š´}ªüÜzæÃñTõ·È™gÏÿhsõÃØ >û§ÿ¤»*`ƒ„¢×‘°ak±Qk¨U€~â§æ®hVJŽRˆÞZ^—'áÆߧ9JK}åSåÛs»K¾Ùø®Шe·×ÞP¤[Ü\?  à$Ÿ_4~-ªèÞ»'%oBœ³Ï¿•Ý[)J¤âŸ N»—Dg’ÉÒ²_sÎÜlVm¸¿›ÆYÌmö•ãëëÖïåÊZ”nÊö•LýΓ´´]úÓp¨ìÅ7•.?ÉâáÃÜg²%fÃéI?å¹Ð7E}:SCN©™và4úÁ¯}œ¡ šPjƒCb•ñ¨ì4\ÒŽ>¸9å‘ÊbÉì xŒâ~¸O£ÂJO0«žA±¨ÂÔ7fç[ëñ­e ÿÞÊõÜnôÖÜZ’vðéb4²_W5s`<n O{ÊæŠ~6À5oTf0€<× ðóWp‡ˆIÐqgäË^[‹¯n4-}ËüÇKˆËYÿ(±þX’ yÿë‘_D¢RÚ/ª…£ÀK¼Ëu8•~È�¹ŽêšKñuJ™låXi ¾óÒ¯ýCËüFN¶¦ðZ^$(¬vÆÄ‹ È¢ôH±¸æÄÍÅ£;ÀÎTz²©»Èíë·»²ñCøÐÜ÷qÈhâX3xÜ>ÁéM…¬—öòa LÞåOso”)·‡=D“{‹O/øj°µ=2‚�P^¢DÙÊu Þ’c¤síAF¼ÜÜc¿½ŒÇ(½Æã^)Ïód¸bÖ.¤Ãgò“•Ó·È7_`YôùBüó¯Š×eßa©§3E‡i6Ãí;©WF¾×+ʸ`ù„4éÙeõ´×<ÆÔ8}žiõÒkí^�(VâQÜS ›Ó^¸þØÒªV4COÙ6ˆ‘Þ¢¾ ±î"Dy±É¼A•Îû½‰"à_†åbzDèGý&ª–^ÞÌjÃPé©öÐ{,JÆ ;¥¹yéêÇoQäôîCŽs bbTXﺬ4£R>×蟓€Ó^•2œ|�¥Åóì©kSbHûòÔVÖ ¥‡^±Óytç©Æç‰ïQælðôŠ6Àr_/X «G¹)$ «Ã“:>õ4“‘ºBÙýߌ'Ÿâ £5TÀ˜}J h#aæj¶ (¼,”îg^Í‘è÷R´¿kä`r€1è̺j_‚ùTjeôß NèX.?Á0THÔïµÞ[YW|ö‘Õ› Ë´ÑÍ‹í ûúª¬“¾]èã-gÏMôðÇ §·Œ¦E7âî¥A,¦±#ŒË><AÑ ìkoYà¨à…Ák?Œs¬f•‹íBk6™´$ŸÓÛûØÁLlœZ>”ܶ`X¾Ÿ5ë/ Í*¿‘CŠ£p-8LˆâêÕÜWç©íÕ¹2ŬóHo>ªTƒJè+Ln-)ügɲg:¬É»Ž‰z¨ÌRwàôŒzß_m”D;XjÒRù'=ôl¥A"s”Ÿ–ÇXdèDf6rZ¼¡Àݶ·ýÓ©«™Ã„‰™à2ÅAZ{/JXÚžísNOpFÃÂé<Á=¤8÷]! …_póåΫ Ë·;Ï¿N²7Yæù”Q¾{Ù%<§V$dŒ!øì¼w "ÅŸŽ>ž“Z¡Ó˜ðÖ2[U*lÄ%qkqÓŸ¥N=¦°(í-Ÿì^À š]Ülel0ÝfëP8å-oÎûª†³ï½]j¨sûeÈoü®w <EÖ%ü ë›eÞ9Æ8ÚåBŸ|°¦g›4Ð>€í0ñˆ]2Á‰¶!Ûª?­�Ü$?4ÃÑ]bèš±´rËš¶n=:/÷Rè¸Ü¬ø>‰ŒââZ##ÄÝé]m[oyÃæpq¼¶@eYcʆÎ{ë)Q³ZÍpõ00?¹“Š’‰"x ÁbPÕº"ô„šªŸ®Ç“súZÃñMÿ^&›y‹v§,óÆ5OLïD$ÇgýÃÚÎòØ–)û×togµ‡ÂØÿr¼£°J4+†Ë›N8Ê{Ãpøíéoíj±à) ~sàç• !‹„UP5UéÄ€¹!ÓµeÔï–šŠad=bžoôô5–a¥«>,žºäÜËHxõâ¡Ï7¦ÿÙÑê‹{¥$°€Ø8.š×ªÓP"+çúcÛ‰låÜ‹ãgdKô©æêÄ¥¿™-ß3üüÑÿÓ)H‰´…D*t *×äFLí–ª‹«¨{'aÿËÈ×3õó2óG‡aVdc*Ϥ…âúID¦\«xªjãâÊpUG•”‹gAi}R#àèÕ>Q‰ ënÎk= ëjdB<e·CµlÛ`µÐZÃB_`v-²£Õi„<ÝMâG+6<dáÛMM ÙBáW€v ¤–e}ançb@V¬ìÚbþÏöD¼Õéßvà˜[‡˜dÆö œ6Ãe>-Š†½y½§"æTÛµ_Ò·9¥w—Åk˜Ûª/²%ŽÖøÍ]ut·¸£ÂCtÃ’¹³‚‹ôÆ©r˜"�…´ž¡´ wsU¹d£°XŸ¿lImœ,žæ“qêɃòA@OmƒkP²šçÄ ý»mÓïMiõ­ä»œF ÖééÓÃVñìµ›Î5•ëôãÌh§Û×UVc…°Î”ˆqAÂ*¬šç•Šþ=©ûjS›(óº£(8ÆC\cdÜÿÐ.¢yáíµÐ¥muŸâ隺L.Yæ<È[-¦ Gë}©lý!$Äjø0busm@m³­¤¾íÛ?-?ỿd•4×Idx|¸òhŒ\q¾nÁ«±:c¢;ôsÃ#/d‹Ë8Ø|fŸ:2Ætõ4^8TIÈu¾ž?¹!E™gI‡¾@ó›ÉSªñlýþ –o2Ï° 3‰Ó,6ÐD Ý6ç¸Hy×¼íèx ÷ÕVàœWÂ÷¤níD‡ ÿ8«Í•ˆeÝnU´z_gp¾Æ¶ÌC×e‰€x§P™õùàACr׌ªYeÓSzUÀ¼ýéN|’,Î\1†[Gk9,uA-zlOÆ·ëƒ~âŽX/€gv߆\+¿7ìI¨"GAYYˉˆ™\Ý:‹Ó]/·õ‘ãt%³GY6t:Ýå}>YP<,«Œò!:óÏ~eÖ)"J ¼Fy°±šUìøÎÀË5¤ÿ=ûQ4çé&aݬ”¢€ûiÊ ì®&a-A©ëésT–N÷‚ºwèeì/´7AbõnܶBýO͸l>Ôtº¶1ë’°àÏjd5LrF—™¿î)ðtû4ÈZ­!!Ÿ´çÑóeäÅ/G(£¬èŒŸ'©•ûÉgÎ6ƒ•¸1†2æâ‘0UL;ΓHXÁÏ£è$vÑ(’¹w”Ÿ×x´–ìóüGõ±$ô”,ƒƒ¬äsðP°#Î|Gœ#Êc,Û+P’Ùe(ƒÜÚÕBxzךgHœïþÌÕ†Pxܺ^£Ñ6^ÆŸæm ’ž~RVƤ°.û]ªU—²lÇ >/ƒE}w°mŽgJ­ùütÈüت5•F}ø2AoÅs±¤?”‹Õ©hé-‘rÕíFÁ9æÞ•ÓµÝBÕ`“¹¡¶¾ |ˆÑŠjÞ ù¬ÑÍ}¿XùÍ•aæ!3 çQÑ©Ÿu ¡è3Ûþ R<H‡¢ž}Ïž`Aßµƒª6­öÃNaöÃþL™ø2Øi%ðp s«Œë¡ÃÐœé£Bz¼…D+dNõo¤Ì#Z¢™Sûd±ÌyÄhÚöݱ« ÿ•ùFXº7Þˆã4¸©ZÂehOPÑ£8Òß{ZoVõä x€b³ ´·#ð np»Zªã?4Y_xÉjü%0ð,“Î*¶$(�›µRš´í_kì{§A)ÞÍe[ɦ¨°ÊÆ–ˆõb¿Å9˜¦F§éˆŒ(²4ù<vŠ—�ÏÎEŒàÍODsæn ¿å Ì|áFÏ¡ ê‘ø2Z>ÊV¢´©öYس¬©ÓÕy9  e™Ô u0ùw°ãsˆ•ÝòIŸþS¡U [°™=yzýèÓ»‘çÝÑç&5H ˜!÷ÊBnś֬lA«¾Èòí– y²EMíÄz›±Q#—õž]µ\"uƒ£t-§ÑY{ö¤GÄ©èëô‚þÃ×]XATjLŽ€îv„ãA¥1yƒNTݤþ¥wéÙZoÍš2%WOØò ã |²µ4òAÍýæ¿}û_Ýâ*äGåXgV@5*ÅÁ¡hzí›â7YzMß ¾ÿæ™wjV¬œaݶO‚Í×Γ£eê?•Ÿ¼«é H³Õ3Å�6HëÎÓzè x76ó#p˜�ÏðŽ×LÒÌù¨²ö':Ö˜sXÉ ÇG£sØÒ¾æIé*Ú]p¥åò½w]ø‚œ!è·”R껳 …nèjfñkIŒ¤¸‘Ë¥ýFÙã´7M ¨~2å$+"N_g0½üoÒ¼?„Ã<³à$–¨£â Ž¶O­cQ¾‡NžhRó‹ÂgñÆW H­¿.}»“¥« ×…¬Ó §;uÙE1cL=ûÙíx¬MCÊö _hFGY’y:ßtÜSp ¢JÏ Œ]¬?±ÜÝyú‹›óÌeè›çP„˜³(QC·üêõ¿¶ãÐ^k~;s�°ÎŒËlm°îü®£5šþ¦0WW‘‡ DKÁÒ„nZéäÚŽ …c*'Í€ÊÊ#NFÓﬧjð•Ñ¥RCožTL‡ùW.PQš:¡C&“lQÙ‡_µ™›ó¾«øÞ¨„oœ¿áÑ Ó5?[6ÉÔcMŽ…¾SÜeK>‹¨vH‚²µ¥Zn+˜×ê„2öaæ {CIËRGSÖÚ=ìÒé§p*¹I~ùÑ]à­©™{KF;›€Pÿz øÀé=ú¿Mì0I@(ð€{cW|Á�ÀК‘ÎÏM?U©³:ÃÃDõ¤"B]á8~\ÑóÃT.X*±ï}Ò’ŽŒ¡Ÿ$UŒ’f1¥¯Á«ã¡ß\ ¿ŸÃç±õŒ ¸aOw·¬µâb‰÷¶AãTB<Y}e¼Ùàƒ¼>Üß9€’‰í„>zE­åc6ãëNÊý ²ë0Í7¶(Iæ‹ Pipt8ofxf4 Uï /ѹ`Á.J½žqÛ¾‰óëÄàû "NÃ5Ç‹âmÈÞ²ZT›S1´ï­–´ J¢S¼ÒW£Ü [“ ½—0Ð;UµÕ›¤yЖ÷k¸øÄw’IÙ|ó£²c˜¥T`m^| òK¥—¼=òÅ ÂtäͳWÞQQhÓŠ‹ºòñºu)š}¯±¥–¤êÜÉbÏv”md{à‚Q|z~'ôl}ÉD�ýˆœãŽM­é@¬¯®±5tØ¡�†OhÜÕý™Gú³o¦¬å…™3F‚ï¨i/‰Íév¬zæ¯yW¿XÀùÆçRpâ N§S@`n¬†‡9ß;ÂIåµŽ× ‡Mëœz1pxㆦÛâ?6d£X ‘HØ`Ñ.ž¦°¶=(û÷‰hd*ËHIÍÙî]óP;R1Kw5ý¡·^T”+‚(D! ›ÓXÊȹ[k´¾éãÊØÆŠCØ‹ïêP²Âó.{íí<Î/ÿ²„þ¡–+ŒÇŸs½£0v·ŸÛ6—&ÂTôä0Ž_]«9úE8döué¸ßŵoQâ(ÍÀ„N÷™Âê—EõÄRñán3šÿ'!¢´XµÖAÆÝg¬r“ØÒ¥©³—ôyz×è`"GÕ¯wi@7)ˆiOåA<íì´„±w�Ž‹BQÕ˜9ÕKû)Ëýv½{O_¦|¿zŠºmEm@Ï~LŒ8pGþÜî±_÷i.¿™N rì)XMp¡©ùä¤/Àž;3J¡ÿ2/ã¿=Ê­¤Pr¸ 8F.ì0œölz?Q>dZáôÁñ>T¥#÷+æ„:Lb”«–D&óžJgGþ{º²Êÿ/4y’h%\ïÈ3åÅ(/“öQZ7«$å—KúEf­®t´1ˆášRˆb²€M„–UÞ·1ò…(ý_´YÛ³�\Òz™M‚¡gú€·ú0¹‡B¶m§yAf;C«Ô«È»—[¡Ã´ ’S§Néʑˆc=,Jâ~t-ˇ©1Á©7A|<I;| ¼Ù·äºó°˜jÚ]>òqÃýîÏù©w@Q*Iàfvo0W†+ =“R"ßµ€ú>C,꽸¼ù;èÑ‚v:n‡™>r;Qe»Ãý›?d:—A4™ò`w-ƒÔ:ÀnÔâ!@+¢+»Ô°ñŠñݵonFW…?&áéìÇ’y¯ ¹Rf=cN,ìWت<õ è¶wMÄs­!³*oÚZý¹™ôUfié™–%Luò`cÖ»±ï ¬+l«½Š˜Ó~‹£ˆØ³Q¶: èYW´!N‚öùqßÐqÉåÀ%ÌËy¤mAU¥c¤“÷2ÄÜ™±àºb19E»]•ïæ8ùfu0_(‡Ýâ± ŽÛêº.¦ÂšùŽi*B_Ñ:‡Å 'V‰G ÃÓ–ðœPYZ[t”@3q=mÇJBÆåm÷[=@Ú+LouE1EÜtÙ>¯¹îvÓÊK—kLgžSu}Ø+ÝÕôùs_凕4)Õïíà(É$(²·ö? /F–¶¥BBõ §»«Y14v‡å/)žRËo©±jÀ!7ŒÁ¦§ üÝ¢‚Y˜§>:«µgF툩‹jÆdÞ)½¬f|,ÐhPt~Õ:†ÜQÀjU®ˆRó³à®‚=ÑtýadÚ¡¨ç“˜¡õ5\­Õ+1KE‹Z»h]Ñ6áô‡K/¦û*±i¤i{¤•Íg)‹ jâXi(âÜ_úïaø¯mr<évD‘=Ž±N¨„7;Õýa5ÅíÈ­Z=Ž+÷¡|­’aÏÿŽ2 �3§v]õ‡NìµdºyÒ_¤Ó FB+aK§òyé™Ê(Nl±ô"-9¶îþî•Êß‚ZS£st8u:Ÿ¬1õô‡½Ó9ÐÒ#ÞŽu  Kp×ö‡/€ZÅ6Ð]©@Ë÷%7^€eí–ŠÀ“ ˜Þ”8:¤“1h3Ðÿï Æ8¼ã,ÌjÛ“…åVðÿ•sb7*ÅüìÏô†<£³G¸0O2Ë�ÑJ°Ë_˜«¯ú:¿k“O2Îœ±ú° ßØPØU-í÷¤ÓSŠÉäT1^E92�ÿ_¸¼×ÏL`dêiͳSSm‚M7{"ø¾­ò�¸ÙÒ¡úð/›Ê¬!¿i§ç2{Ý´í¼¨„!¦¾æù)Gk6D©,00ÏO$ú˜@—¢Ö=2JîÅ,ÁøüAó Õ6/&2Ò÷0êˆ6¡ðÔKƒ–aߺ–Ô;Äv€*½òÛN#ðÚ³Üp7(w¸¥ÿjúÕ5vÖ iœ;{LScéxfA·§Ýí-4™nÝykJâÐaOqb'¦€ÎÄ&˜á ÙûæÃu…¶–Y›j²bt.¬T¢Õïñg­ê•4U Šù8[ã\pf\ø‹íÜ# û>¹ÚZZçjÁ« Å!÷¶ÔÇ»_„àä]ÞãÖk—¨0…eGyÝð×5ë„`#â÷‚}‡ÖÏìV÷eÐAu$zúÂÑ3Î<òrÃX^(X‹}ÜŽYÜÚ›c—˜ïÿ"Íó¬°R[\u Ï[¿;QíÓv’¦+1Ê“¤ôÅÇåÍ+OŠ²•LÝÐ,N§{²°üÒ[Óó¶)Å+Š¸¡¤I¼ÙþJ÷Üû.Xã2Ã~eþÏÚÊt³­É¨s¥¨ŽæWó©R5¾[‡Ÿ(ôË’‡; ©“Ì+¡5Û]ƒÓÁV%†G¯Ð,ôä•QðQL§’Œ²#Ñ\XðªšÝ€ŽÑ7ü4å¿3¦Jnˆ voœoÒ1‚à÷ßD«?11ý„Ñæ\;?QhÇTÖgÉ’°ÃÕ¼‘üÅc®lsc ÙRÊŒN /Æé=9ì7¹ùïTršçñˆy—çî )y"ÿAéw~R~ÉšW70§}9Ïãɾ2'ùÔV7£Ù4É|c½4¨a²SZ^¨¿R¡á,…q^tÖãKw ç¹#\0v¡Í™vlÞ]Ô†åD™MûHhŒnÉ]B¯¿ÈMš}i Qµ›<‰S”9æP?ÏËàóËãÄÙwD†LZç�?|j¤/³Ê4ýlêl‰3=Ïý}AõgÚê±ö£M®Svâ¥v=†óé¬ßâ—$\g$À§¤¦,ÈÞ+/$±¿èÛhe\²*ñFS¶q-‘øï ¸ž·ËÙñ¬‘—´ˆµ´-žÜ/ì¦JG)ÜVƒL(>ÍYÝÑ#ØqÚÈÄí<©I7ו²$Wzë߬¬ðbl6ÂñƒvrnÑ…‘ñ† ð}uâúÉ`æn^ÆÙ,iÔ…ÁaO¹Ï§ª9Š¶òy€nû‡ƒþ<êO2+”#Bž§žÒ‘OÛ‚uÐ=)ƒÑø•]öŠm’aú)tXŸœ¦~×R@›C�}”Ì÷ê®ikÕtã;mAÖñgåJŒ“Ù17†w+\ë*4 {žä£z`”á5 ¥{,Ϩš+»ÛtÝg¤CÁ¾!¤Ã²býkv“÷ÝgŸÐ:³äÆ{õ-RÓŽŠ1ʺ@ km"áu¤žõ¥<Ò‚(vŸk:éßßW21g2%3bœË¢8ñyÆ ¤ÀÎ"/£Š]x¬sGŒy¤ÇÜ‹ý¶3Ö­&ÆìÝA”Åj’‹ã&6s¥}k ‚Ô»Íy!_‚Éãi<p5OÇõŠgÉ âoh!E}Võ¢”Ïœ¾¿z‡ÃÄÓuù÷1:ug~ˆ(ƒžÎ›ð<ø*aÓ€â‘ò¬äÞŒÉ.”Ìô¢ú*å¬ÖàkŠ`%§&Gí†þÜÍÜ`<»&XÒ©&Oi,jüÂnœN&y¨Ôe‡Ø —F–ßM©çŒdbiÐq¥ý±A!:p-m.lŸ¤õƒf¶É½þäÛE»s%cìxÀPyjЦ¨èØ]ÏŸΕ„Ó»{)-ÝÖç–f í¨×ZÛÌÜèÖÒ×R·€žñM—“ÒQ¤ªtPcjïô|‹Ô'k@û†ÝxÛ/°R·hŒYêÕïÜx£,õ-Ù¤¦ ¢ÎŠD˜[\þé˜óíËnãfÕ«Š ±#ßôV_ˆã+çP+£GëEþ;oòÔ³’͸“ˆÌºg”°bk¯%}ä{.åäßQ¡Ir¯a zúî­Ï&Q§2ú^)iÕˆ¤;À]ªO7VþVíÛTèmX„_{ k~A»ûÔ.Ý÷Æ“k%ÆÆ…­îhÙîö¦©²›L•¥°ÿ¼åœì¯ÔÚâ®ëê§wl…¥H…åæØ`öíÀr9@™VgZDàøy×ìS>Û•lN±r%pºŽƒ¼W$F¹¿”ª½•Å¸wõ’€F¼2ÂÕ§‰¨îü<ySö]5yq–ɉ$æõ ô&Ë|æ=ºNUBÑP ì.‡™û䦉½É½™2 óL¸uÑ—ï F¡+M¢È ÓèÏœµ9š0s?ŒýÁ†­o^iPÛÄÏPl6ÁvÈdö0ÇT®‰]¼yÿ#ð L¼?󊼲´mæ$ØœjU =�ÖÐ/“ëÒ1ò 0`àmÂu µ\螤{•’¢=ÃsbÓ•–èMu' bïYïZn}Û×GxXRlÙ9(› ì´=‹¢öäå‰ëjöá}ÊÝØá 79Ÿ\9Ëã@ZFWúp{ìóe'»¸‡±íõ©¹4IPN½b¸1E{•r(£Š>”†÷°þé)P)J’̧Fo  [›æäñ‚Y+i¡JîL*þM…³üs+ºhÔ&¤Ë"|„£€X«ÁN'ú•8>»QE_¿Ü³WÈ<aABQB|ýuLÙ]ÅÐðÙ"æЬ;lQkz—·å„uëS²ïeŽƒMÝy»¨£SQ“¹W­ã’²ÈV:IuO ý]ÅQñHò#Ë®{ñ&÷_îç@ùÊâFŠÉ|гDA]Ìã9(±U‰×ÿ&°åä¯*Ï(òè:¬Èxù‰B@»JºzæÖ­'Ï~ºUÞ‰âU/.`´V“Ac)ëC€ÕBáÙ†æíT-µz^«I>ùÍžPJx+�Ùáœ2)K9ò X’.°$€,Åþ/yM\”.–€¶Ô3­—Í{ï9{ÃÙq³"1©øï|>µÓ€3ÿA|¨åÍO,U³8˜º2k­Ë7‰ÔåžÃD0~--U[PÖY÷â•Ç(h¿Ðˆ°¼yx¨,¸”¢„÷}hä1ð’V­6ló¸°é>Ï¢– ùxýeÉÓ_Üà5Òç8 �ã”2>ö»z_Ú0´Ô7‚'n$Ži¸ FÖÛî<õV¸:iôð½ú z“Av{h)¦ YH?†ŽÍ¹[ñÿd1Nââ1¼Ytæ…;´¥ ˆ²Cåã,c �ÏÃÿj3œ:Ñüõ)5ÝÒaò|x†ÚWU‘§Ká2Ïç¶Q‘ù^%ÐB¹.ïÞÁ#Xzg3{8tüe/Ÿó²ÂgøpeTçÎC’7ã…¿;ãÖ ÈÆ'®{.c]¤¾h WZà‰æ“ò÷,)Wè{p�“Òìõ—;—4ÁÜÓ¶ åÄ›¢Jñ$\ÆnðÂ}Êc’r§Êô)#–[¢ƒäà3Ù‡› þülâŠìˆ=¼X@°µSøŒ3ë“Ó/ý‰Æ^zŽÁ)ªžš1gÅ+c‡íÎÎÉén¦úŒº–GßÊ ÚaRäª �v0ACïOÿ0žé—ê‚éÕHM­Ð­1‡~zïNKÑzà£'¤A‰"*ôDûí$'ìǸ4÷­‚y,B«ÙÔ,‚s�­f¨pYñðÜ°0éíœg«Ó¾„­Úe0„‚ýØ7ÛÉ"bþó&yª§]ۑΑg9Ì|Âø9PækEj2.˜Nëÿ!h´®ýï<ö¬zúí7÷dÅrÌâŒçº ¿ru ƒVŠ:à;ÑLBêYýÐÉ´ö®¿U»±]�†#4ŒÁ}ëpß®o”¥Q p9V8÷žÏG¿ÿƈŒ(ò‘O´aȃ°RœÔÀwäÿL¥”]på“Ì—§ùI‘Ü«8-ú4n‚¨šÜÁéQÊ-¢kýâžCgžV$‹Æ xØqW ¿"xn¡öøþ”)¶7×ÇQ¬Y=í�às×2ʤƒ&A¶?{×”zâÆðdK¬Ùf:É1¨ûo}e¨ø&Û ˆTœ};Ñ"ê>Í\œ¶‡¨¯È}ôø¦,`ÊRYŒî{àý_žÞp{ç#­¦Fã@oÖ (™„IÅ^îH¹=¬¢òì¦ÿ(˜¶Þ:e&2ÔmÅGŽÅ°y—wœ‹“lż *›¢bvòÌï¶ç©®4¦;H æxÐ8iíè¼é÷j'+ÓgZˆÝWLwÿ˸V5çݕîúbÕµvrZGß´¥ì|šbÏ¥¢µøYyat®¡Uc¾q2| í>¸ôdRíé×1xW;ÕYOª:4•ãÝýï=´Èºq�‚èü�‡·«VÌ·m&^›’yB m”×J™×ZÉDX·¤øÖ™J”Þy¯Üùò3Õ_ßñÇîã¶{ËòO‚-él¶ƒ} ¸|ƒX4Í‘ãµ½Ñ8ÿ‰ Y±‰ÜÈY€Õ à‚ÈWÕ/º½#Æ]¹Æ'â+NW[PbeÐhOª‹iÆ Â-"ˆ!K6 ¼_YŸìÙä³,{Š“»ùˆP÷·—Œvwï¹ ¬X,—k}6²ÝœySÓ ~‘9šûUçnZî=óœ¥w€Å¾:“@|å‹x†M?[:=tz²¢’ƒ…I0OeÙn0D§ëª§|¨êÁ†¸”ü0ʈ<‰ØPáH¿ÿ4£_$þ�“õÎÃËg½ËûÞZšš‹ÄUôøøuãuÎél›áR!ÙŒ¿x ÷¸U¯IY¼â*A/ òÅ[œi‡ÅþQš.ö–sãB@GÜÜ{7}×Nû³õ·Äé©]ktÄþÉoÀ²”Eß2 ê.Žù¶9Ä„/U L>×böBŽ¿Îij4»š¦…xçäÿ,…déÿ€÷‹—亊p$H‚cÉ—®&Ì÷@ëíhoÍo,¥ÏÛ×ûÍ¿Äsä¬`¦{v:;ä­ý·ìpÉ‹™¾tç7wtõ#5è–F##ÿ$ôüíV.´S¥-Ï‹—ªWÀ©¸ÐöwÖ‹ÿŰ쿜޺ßéon†¤‰-CífŸË XÎŽ£þ1öýù¨„jøÓ^•G`fq‚?h-P=ñÝQâ••Yºž(˜2±õ¥˜¼é$ñ¹¹È¸jv̆¶´Ã-˜9MTh™aºFÕž÷“åùvÁá°xÚíoð˜ÇC¿Räù²OËG-ŒurÿlD»ñœÕK,¼ãG«³Àl"ÎÇQ¢jé4rb2‹ªÕMë¹nY†eàKè×ô÷ÂOK_ ù¤éGûñk©¦xÅ/)8kÍ?ßÂb³’b˜o K+ÿuÊjÜ¢<Ú™nYØjíTWtÔO&(×u£ˆˆóÆ¢´ˆ#Яÿ¨¯ãéW¢�?Ö† )·®±ÅÕ¿wèÓ4ôiTè8 ¥v6S©cŽ¥›j?XÔ÷–¹êÚˆ&.T]àµ5÷Ösœ÷–vA¾öÜnëçZףĴ}®#¥¸ŒÉ”à©Dj¾›7¸<À‡05À¸fAÚ+·»¤]³ú¶ñåC(ž€×Ùr‹€ñ8ú2‰‡XÄ´Çhä¬N˜üÁ^£/f#˜9'(&<,G7©kmóÎmýfön*`kZL¤ê‹ ±Z¿±4|)ÜÕpÌtÃ/WÅÑ¿áÔ|ò«®ZÔí{=®,<i‘ÜøÜÒù­¤,<€ÃzûHl0‰× )4|®bB•K—Oh6çUN=NŒÞ”ÌŠ<ônhTö·(-³^à8ó&y{>TaÐ þ{ÌÌUK-ª +Ž¨n¹êÞDoÿ}‹1ºá±ý]:Ýהקü¢ˆ6³àJÑ·ôOd}.’í(½QPø*º0µ<X'�I©å{§œ\½<ý“ÊUÉGäÅya¡áo-Ž$ñE™è˜€E>[ —[ä&8d|R7È|ï‰g‹QäAêK³É4 Ò’E†D^áúº©YÝð-Üû°Ò5ÞUÎÔ”·7V>þò%ÝÎ2sÍáX›5ÅûÕ“<ÆDøÌB‘\²û‡Ïê‡uoÆjùÛº:IƒØL¥DôŸv»í]:Ĺ¢Ã_z�¬×iì{þÔGA67ên�ÆdÛŸ:±1™ÁËÃuk_(Üì(�¬6ï«cå£gb˜æ+¼Æ€°¶µ~²ƒÀ’A³”%¿œ>ÆK¯(]HQf;©x�Nbª™õLånœÎ“•íhN˜]¸ OP„iéøîéÄm¯·EZÕ Òc‰ªjÐé³MªV:UskøƒR6Î2ßU+’™XyÖÄ\T Vp Èi¯StaPÓóñ˜eF‰q$˜Q#ý‘ÜRѺֆLhŽñÿ1 ‚ÂüÅ©âuÙȉ.á ÅœÃÿ¨X& 7ªä�áYÑÚrë¡»Š ú!d …é ß í mTìHî†Ñák�åxâDhJd†È=œ\a·;`•›ìóªváÛõ‰¹€]á°sžîSš/öšóZz½^vªj¿(ˆo›Zfe€é†7YêrÁ:7؂䦽>ìá¾3,&€“ÿW­¢éÍÕvòÝ8h´àê¯ã_Qøc^È'š²ùÔ¨àBiàÜÁ ²®i)’Ù?+Žœìx`§´)6Aؼ›ñƒq”ö7k˜XHñÅB[¿ë;x,¶¾”c;‰œÝ“Ñ §?>Ñw³œÑÈH8‰¬j0]»ñÔ¾è‚mÝ ”PÞ@´Â²jAl¦»s´Á —|öBt7ŸØWQçl~`À:X)ŒSús[·Î¿„î? k?¨¯†ù…¡?ÉÎ0LI(®4žËýr=aŠÀÄ W­ÔRcc©7µ,X¼4þ¦ð†H«Ö«€¡ÃeŸ¬g ñÄ"J£Âb~b6rø“ÑN¥Wbf9UÃ&³/'¥‰ÅhlŒÿì2л~éýíª¿­�®9¢rQƒopqUÙ=[ÞÔ3»Aß.è¾²`ÓýÕù¾Ú, á‘ýôåéÀ'ô ¼”{B- ƒV·AÌ|Î@°’XP’è¯Ã°úÁ¬aúß ,(,ÌÔmž)€Nʱ¦¹´G%ÆM ÚÁªÊ]Œ[YxÚÏJ}a/±ÈØFtÄœô¦p’ Üçö|šusÇ ¸ÇwšN7•Ï*Ïé—²÷bfï Lšçc¡9íÌcänX-é†+ÍüULïËœ x®ˆ”ñªc1?G|0‡\X9‘Z÷3íŽSïz¹6Uæzà�Zªòïw©4L\9KieN›ø•,˜þæL.~ßm²bÍ<î†VÆœyš 1»‘_TXyíÿõúO˜Ò'îWB hV‘ ŽÓ•÷ Ê6‰‰œyM€; Á<±\FV>àòªX>``syõnEJÙWóÊÄñ‘©_¼qr"ÿ@}O)TÒ{ èº9.Ïëž\ÖèE  Þ:ˆ¯ <o(cý ÊݧÝÞR“l–°@o49Yÿ¹'Uhfž¾1…(ÊÊa9¥”ϳ“êÊí«.øÒÚww?ÞÍÑó•8-ì gP’»O«Kz…c—…ÌØ=ð`'X݉غ¼´a7û“3ŒØ¢s`Ýy_ë ç^ï†ybÝ2µç5HÆ¡%#jù²¬ÕØ~úO\ñêØ6‘iÖ•gBRjAÊÿJ™Ð ³Ø-XOWËÁ4˜Gg!×UÒ0ÚVòˆo‘‚÷ë¹lʃ‰ 8‘¤AyÑ&(Ýä»~ƒ P %t‹³Ž÷Œ™óµ}WŒIBBç«‹=–;ó®-8MlBïQŠ¤LóWƒûÿ\UY”úŸ�wì½,ÆŸ{ÈKß~ÉjîXv n‰·tÊïÄÊ4[ÕP¹¨©äVu ÌæAŸX\PŒ!é]%•DUVò¯´ìºS¤;åœpb,]¯°M“ÿ˜Ì¨kmÿæ<¿šŠªëóñ;È«°³’ ÛGAöi•¹² ùx^aþ^QÓñÐr¬¨”y£9K‘NduÕ{e’'ÙZéiÙÑñý>xÉ-ýÖ5«O%|¾/g,>1R“zJñ11jœv[®¨ ³x”à§><3FŽ±]Š`cëîâí ‰[mU)d@r— ¬µÆh”zLݨ;虵‹›lÎmåµó¶"…Ì žüà’"ñ!‡æ˜ÅÖ+í¦T~êíX—#;y“œeß쇖%uà³ ’ù;à8ŒŒÇ(çæ'æsd”ö^ÕGBÁ´ììŠUºm›ÐÍôâ§a3²ÈÌHjØSB»ß;ì ãäˆ'K‹Ý· sî½2ÿû¯<A’cqú„ƒ–ÝAf$juáR`8Ã?´ÒÈåZ±èƒfûþבÌê¶:C“Ån¾e,˜M1ž?u§de`zãéË“yh”y»Ýò²ÿ‚+µÅÑ%aŽsZkµƒƒÞ´ÛX{«­E^þ'†sè Dl JI­ó°�j[ô¡õQÞ8‚ÞõÍWE<ÌmzJvŒ‚]Ì‚s}eˆvp›¢l°‘žÒØ7xór7È^²Ì¹¾g«…�‡ìgÔ¼÷¬ÏÔ?õL#Ó1rSöT�û[µ¹ºÚæ°e„>7�ÃÖT€5o¤Ö¶‚ŸoŒ°½«oû(½Í2k(Þ?/ Ýt¦¼m×ãôƃX¨ÑbÀzVöÿæG¥ÝÌ€9PìÜ”Aqz÷<9Çê£e£ó妶iÀwußD}l€Y+ Ð'£SD0Ný’¹Í¯HR×`™<üJ‡ï˜ˆŸ&Ê„¨ªkûÃߪn]Ê+Áüsnu¢üªRŸ¶ïD}dVè3O˜u·£ ßبðZJ›9!ƒžÚ8(¿¬sUî; š¾èB‡??}ÜÙÁŸÒü¥WqØá>ûfïƒñB` «q¿>"ѾîDè&ùBÄ.‘¨CÿY‰ÒPÙ”q&­Ú£§Æøoyº]ˆŠ58Ô`¤XÂ,"ž»" yæFk­²Ó0ó%¾¡J»1²ƒ÷H@žÕbŠƒ†TöÌC󹈌êîZ¥í†å¯yÈ£ux¸{¹ÞÚÅ–áJ!"u/ˆ,'IöÜ\Ó>uÂ1ÈþÒhÕ™Fæ•í½[Ÿ6â3 >\(©Zök{{Ê~‡½@ V£äGí°(º•j¡§k‘»`´­ÆèëaÎOâ¬ùºÙç: ²¡q¹‰¤²ËA¨uu¥|îñ$Qâ@f mÖGJU#/ÄõŒŽ)ÓÉzIÂIã/w”p;¦=ÌóæÆSÜ’jÐôå«íÇÀV߯ô®|ûhÓ®ÿÏ{çp㯻/¢”%Aà÷ %$ܾz½ô°pÇ&›‰ô3e å~§ZŒÓø^ }½@±šËã8 (àIËÄȯ(å=bgDÊy>k=çK€*Z{ ¶·j’7eÇMù±’¦†$Y0~%ô†õ”Áv½Ç2crcT^ >²àu~òDö–g0!egE|´¾#¡Ùßÿ¹k<÷¼Äür"Ã�ݾœkOø¾=ºKh\8‰»§d{ÄmrÎs$ÕÅÚXA¹Ó íÍTl?RjŒ“ð›ç±ïúÄ¢F!0UÊ©2SõØX6 ÃálßÒÜ„úhýkNc$j­Xh¥2Té½uo+`ÔôÁWY?3u¢¦Qé5¥r!éQ0l4®4±kæ8…Ü7k¥I;Á› íÅ#¥Ë‡Óš8ºH€2"ˆw­WLn ûl,eáÚoã4BjR FÏ\ ´Pqáð·+ççÄ7Âà4y¦W_žêÚTá@0Ó¾¡:ñ~7êík÷Ès9a|#ìš``½ïÜwÿh¯¼ã‚ÝD7íÎ L”r"RÑ`ƒT› °£axýJ"bVÔ¥=Ö¢eÃ\Æïg¶G»Î8Zîé[ÏðÆóAÑsûoÂè›)qÄï“ó¼êÚ^0;<ظ�—s¿²ÍL=6J]è~`(iÃþŒNÐ Ü4ó¡½Ë»ØÄo†$¬ò' â/›~—=œuàïç)g”…gMÏè# ¦&ªï”ÄO£µ;xzä�7©âƒ(%pÒoÍy [@ë?oyR Бb =Û"y„tæ)5ì!a,uR(¢x©Ò o®â•lO‘c…c3¾Â†K]MÌãÜ˺˭º4mxBlý®¥ºâ'üÌ%_™ÔÃ3zL‹•qatU5xF¨O4#oR³*Óò 8[c3vð½ ]`ÇËmÏl`¸A³*¥ß’4èë*“²x]ƒ<ÁÜ ¥j§Ñ6»j€_ ¾¯ÔžTjÍi©K~’÷(¼˜År¾}ŸÒ­¨&;þ…Gc5âûªªóÛn×" ?Œû;.=Nçƒ'9èÒÏyžön>„ŠŸ'9V$õyþdÑQf0>3rø÷Éñ}æv;®[ 47ì*‘Ð…€ÊgãB˜j«;ãÀ#³³{yPç#‰­^%ÚÅhm+Epû’Xp–¸œŠqmÛ…ÞÔ¯�‘ãYÛK£\jB˜{µŸ¨¢U”ë$ÎG¡°;/gB1œ’o6¿Ç}Ù‹(sŠ¯¢|ÚŸ‘µ¯2ÿMðjW}æiî·UäÙ2wèkï(häggƒÙg­¢Ñ£œÐð ‡ÓToÛ+2@ŽîýÊçóä€}m² ì+ïB_øVEÝêö¹+kúvü®0¬ŽNQdÌN€ªT›ø˜¤Õ~p]ÝßÝ,:7¥%k2g—/õ~„Å8 uk4²DÙçm9Oâù Qæ,¿)Äa´”}ê‰ùˆ­Öj‡(d?+ÛÒÓt߃Ù%=z²Å²hÈÖΟÃv§C%Ë‘•n8ÏtWR €… ˜ëåE~ñ�¬ ŸwV6 näb¬H€/™ÿš‚¾kC‰ `Ü/–ïXáV-bh¹=LÛóø=|mo=ÿ•žô^j’sË"±žçœGÛj¾‘@yÔ«H6¹˜-È"„íª¢Þ9ÅüM_ÞĦ¥�‚?Úàÿ‚hJUƒYFŽò`¨œ¾œMÁ[btr".Gˆ˜ð ý'J`d)ôê´ÌÝßë_®—ñÂÛÀHký>éÛ† GUډÞêÒx±ÐQ8¤˜¸uâ<N°²å…oš’êï Œ’4ôaF%¥h¢XjÎbv#ê^»÷ºj´YÍÏ’ @Ö«½B¤ÜC£æî`ÐÄṩ¬8zÁ:)¯ÜÓckYjÒúƺ મ:ô‚!ºáKüB%L)чúÅ3§ïÔ4–öc×/£äÆ9ÒÿÞ _Oý¸¼Á쮉–r[ýE9¾,3»š’í NêÑPÍWFÁ¥4è‘ËLË»í\¯bªþŽÔß^²qÕ[Õç9£òüÓ5Y”X5- ¾"àw`o2×1TïªÊºÙøf¯T}©«É ,%‹NÖMîEséN•hý†)¸ƒgXëá„©æ^‰3ÌÜÎ8çŽô(cDû[XFK\:{®ÃWæáš_SÎZ'­ÏêˆÚHݳU4ûùìž›Ÿ°)*>µçžñ“_ƒˆ^ÃVÄ+'ŃÓDÑúª >øcYªýXÏm¯)‡a{]U™‡ºÊ€ ì-™Õ¡Õ-)»ð<ö&™~‚o+ÃÔsOö©¦l×xßleb)2#F2Íi]ä/Û­„ÝuhXÜdõ±µ9†}Âhe¦6Õ_?`Œ<ÿ·PzcÂÝ¿4=!+« z6}æ¼~7€Ȫö…<{ŸðÇ[¦™Ïùϸ— îöÍàIäKÿÇ6>¨$Ö‰kÃT’> 6Uc+RÎíaÑPjÒ!‚ tã·åÆÙ†VÞ+±¬ ‹êع]BŠôúQ×+^1àÝtΨàÕµpŽ”¬Ú†—'d9'»ò+3k¯¾ÁS‡Š}«éË4rŸ@tò‘X9íÕXâ½ wÕ™B̶Ò"ˆ?w&­Ï¹³Ñ—7†ZëñèÞ{ÉŸ3"+zþÇáD÷µ°vX©Øé` éúŒŸ¢5bºß¹Avä*ðp¢UéÔ Ja íÙDŒŸ0q¨«93¹ì·žZjT ¹˜¶àÁµßº¾Þ¢ÒÄ»ë%¶Év ƒ|¶À€¤ ´½¢tm–Ä]Õ'Evëü;ÔºŒÄé¼E¶ d*4̃s˜ÇWšˆyè éE såAfEWrqKÉé†Að¹)ßÜ¿¿}~YèÃ$Î’2-[²£Ã00ša‚ãñuð¤Ÿ~†³PBTš‡¥\g$JzmVrj" þ2å5¶1É6C*‡`A·(¡9ZãK O_á´:1¼Åhjtã×wÐ#¬ããõ;Åy“ÝœèÛÖ˜{=Ña!CŸr:8kæv†Þ´¢q¹£ømš)Þ¥§Ò¬HÖ˼ 6.QW 1Å0ò/JKGå-¥âHçxiGY!¢ W·«{݉ŸNZ 4f=”tdjºÚ!äC€4ì[ú¼Ú°”.¿{PXÞ¼é¶Bf m›Ç¦,`²˜ q‘Ö(7û×ìÌÇ`7¯PäîFñ|¤D»¬Îžƒ$e¦mð#:>JWPÚ”½æAZõN6ì4ó©Ý.jçÓ·‡ÙŽÁn3×ÈÖÜ*"3aæ#Ù‹ñêæ"㉕ŸÀ綳 ’ÛçÞC#Zp•!þï"ÒQ¨õ³ _#H³SuîXÓÜ0G³­ïgÆ2ˆm‚÷¢5M¾ ýñ0ÝY¦‘}ê,º¡ÀxØ¿-í™±òëmDÿHæt„ʼn)挪ht&{ù• ü]H¬“ËÍ6%EòYù¬&ºÃÉî¯9ï¹Hî«ýÛö¼X9ˆD+Éóa<Qz>0Ë\~ê-=ŽÃÇl(îºõbï·Á,,»‡ÔÅ2óS2ªŸ‡‰‚`Ùiþˆ›ÝVD(õ˜êõª–z­›Ìå )…ß{"â~°õ ±¯±y’<öu=iNp ÷“o­ -£<ÍèåmߎÓlLîŒÃœ,¾_¡nÜ‹Mæd§aÛQël§¨tštëÁ5TÅÓ¡Ÿé$××g2nQâµW9ì‹ a/ŒÈ%0-°²~»ÿÒm´®|¬ K_@–ÒÉ+^kÚN‹:�þ°r\ïr£ §žÞ?=]=$æ–¢ç#8¥ñ«ä‰4±Æ ’EŸzJ¢ÿÚ|b™çãQÚ½³Õû®0ûä®Ûw3Deäºú©sAþ®Þ÷¢úh¿Œi«†%Ç£NÑ–·W÷EÚ2__þ¥-=ÜüËëÕðÊá³?èÎÃbjÀ»—ä+“Ò.Niù{Hþú¶Ó•ÎCóá½%ñkˆÊÓ SŠ àñð)û@ìÛ¹¯¬øâÏ(oL¤f@ççw›µŒ»Å¥À¿UîμçñqØÑ_H­,2ü)NÓ¡eÙuxýYtc-À‘å~ÿ•}è{ÛÑ+Y%Š!¢#ªöáöâ‘4QäsÖ³Fy”ûVÇ+&Í…ÕzºJÃígm+£TšîýøE»6~œ—J]‰ ²iCW\;éoÍ{Sͺ#£¥j<¬xÏ:°Â--χ!*BXÆËð+;\n€úbÆ ²§–ÜaU¢[SÕ××Å•’Â%3…øÌ`¥+€  •H üLƒa¾˜Ó‹¾:[c4çáHqô ~ѼêØæÅŠF¡Œ­â­}Ý‚…5ùˆ4„xË|è󯜢´ð½X©ÒÞ ž0@âÆè¾D¢Ù¶tÊS CßÆ»²Š©9F¬xTSŸjO:útv£5äûó0¿_|wO|†|Èò › œÔ½"Ë™ž£J—¥w¨¦+,æÑg[ë#$°NØjšëdž36¯–¢c<O朅- ýOZº÷ól|š^ôIã"s:ò˜â`-µ÷ a¶_nNAz+>7½z–,˜l Æ†Kd…BÀÏx®¡³³^0b®+%P„0˜hA§W¥ àQ°¼Í#s>Mù dPÌ!Ö¿Ã ÿÙõv#ŠµôHçÖks0lU‘Dˆ)κE®î8pF›Âo³±eh’yõד€Òn &&v"{,?Az„ßóVƒD”¡µ aËÖí®ÄäggÚ(»“Û†�ŒBø?o°‡”UI'§íVíÄÈÂëƒËHnTh :ËE íó¤ β–v·ó°ü¹EoÇÙÏ#€øÒ„‘UË3µ£µÄf˜F: m'Ló«Žké5äxŒtê)Îß…gë†õ¿4Ê< D ¹°¾µë*å*n Ñ‹ÿWêÜ<÷5d›Ná;Z<Ò"í*õ,êÄ›Zý8ÀŠ}Ãڌۂ—œó!u_©ÐÓ½Ø\e¤aÒp¥ Öø”ù§&Aýuà® ´œY^`:O# 3¸È­léÒÔ½ÛTöP¦ûÚ{ �ÊkçY=rèˆdíÍ«à¡)Ô w£j¯mÚÅ(Ó5bAð…–Å:Fû‡0>ç‹TŒAÌÃö¥¢dö¤Š70Ãqî ?F>†ÎªQ’ªïRèhKNœ«Ä-õN³³D¦–ТSYx¢³þ×Çc4Kƒ ‰,ˆÞ'¯tC;×)1|´�%ÍÏëÎ̤8qh`;ÛýÃipo;Ÿ&ktIï4ÎWìƧâgø‘3VetìþLçá{íI/º¡„nÍiëë4~^ú' ›¢•°,šÍ Gf¦Š/3ç”È‚iu5ÏÍïo¯LÃÌSæQK£yG5¡FèLlýq…”2ÿýß`-q¸VMË‚™–{´?yF´4uº3X›6ÏÙýB8óÁ½ Á|¯¾xºd°$+{¶FïAñëñ¬€U|v^!1Òs¾š‰žŠa¹½$•X$nf`½ó®ÕýM QJ( k==m/wºGiºò×Ü3<¼{ëËš�Þ>öoͬKÖÎ> xžô$°ðo_ü¹·,•ß· OÍœñÀOöÕF³*á<¿B ~ãNÓHÄúÚ¥*©ØTŽÒiët³žqð#çé«ç(ˆÏå0¨~iªúÚÆïì7¼ç$,oÔ—‰>îûÎÃÞoyÖ'ë‚ ¦ÿdñY÷®o7u);*Ï EÆÓ⹈m¯@DÌoF¼*¸(1_µýÊTEI†,Pè¦{6:ëBþjEg” k0ñüòÿá;ÀqÃo€—´Ú® ª’|¬í?f‘p3\7ÝòÆê‡Â’]­YR¡´çQ–<ä{›ZÔ$W­ù^×SðéhÂXJ6AÑ]½™Ù|>¢‚µš óGƒì‘Â$ÀûF Ô'V8ŠØÒA.Sìöß*Ô™å–Êþ¼iÈȼï&2i#þš™ÎÞ)OÂÈ)§Fúäí]xŠ²¹³ÐëÌú¼…ÞõbãtÔgÕpãÛysnužkÍl|ϯœÊnè{"Ò2šö)=눊l¬©†+¬Å4ó8 P±îî†þ±YêziXñâ <œýAÒHsSžùûz6óhJ@/µ³|n”yùŸ·z$H¯žןÖRb1GžÓ:ïZÈíiׂüê|Ã)'¢j ìqhÞ€51’ùb§«ï�ÎM¹2ÜP`IË m¬ØNÀDl�7a{£µ_?Q½¤/ë¢6*}ìk‡}d½N#™«s­fÄ3øÝ ¨ïgl_\„¾# Å‚yŸ黳Рy]º¦C˶P›¯Ñ.¹ÆÖäV754ÞË£1kJÁD…®EŸ†~i00&_ÊMwy©>Z O·£X1–´ðö‹ÎñIi:È ªiÕš¹ý‚ìÀÍ‹ ä+ÝÑ"8¦Ð‚Ôûœ¥C&ù°ÿ6O6ñJî¸D7”nËû¬‰,<U¶”WÖÕb­ pW(`=ù˜ßtD—u±™wÄìl™(X‰ íá˜×ß Þ÷X¥™/=wÓ¹t%Ê ‹ßåu#9£^¬@©¯sÎÐ~´BÃY‡_ÆkÍ8I¦ªa’R*Ñ_[×5z©jÔÚWö®]E‰ê ½Ö†ó8øÒX}¹ó~+MÚNœ=5êósÉ(Ü_U¢Ï¯²(ëµ›Ôo^Ê Ÿµ ²aozXJb½ž(ªˆžÎ?Hûb…*L‹0Ö;ÑÙ’ì<_û?T +G$@sþr•Áê}½cTe«~o |gJ…ƒâÌ R:rØZá¼à+¤gæÉH¦ e„ñf·s´ùª?uÕ?ûƤ+ à 46Y[$rkÑX�ì+:V:ZÆoP ×ÍöL¯ÅA{ë’DôÒ¢óÿ*-PMɬO·ð¦wMý1ì\é{¿"9Dqì+ „ðR.ƒÒ6óÁ.bZ³ñÙ¦w¬+L5*¨çËØß•*sßÌdŠý§‰E!q¢àÝ\ý;+JÒܘGAsÅ(Bé™qÎ*„JVWZÊz×üZ,GŽeÂ4¸B>i-‰žÙ&@%4•Óï¡·TqT¨g>DÇC^u T‰¶·­úÃv´jç¿ð$s`üŠóà‚Ini’)ÆFJó`8.tɶ Í¿|Dš°íñÔHtíû ÆZ* ‚!,”-ê¦yð)}>¡šéZCÆ} %«¦LJI,påÔͺ+ýì nñÑÿR¤Ú,]uMó„® º†nºe;ç’Ø)‹æŒãÁïOØαbS…¨Í€xwv…¤*ÀW*ó2د¾ÖÅK_]îí`O2É€_§"(,<“sö¸.ú­-ÌÒ•B°gºk-è…E¦úæX9Áó?>̺îÈû晽Í<ï<œ(8„Öžl¬>àáƒÙƒr×MïaªxP‹æ9'¿t¯ÛæxòûúìF;o^€\¨Tá.5"¢õÂ+~‹�Íì·;–­WŽŒºc�oQU^<õ;Ö”:Ì îg·™ÔÁ½e ½ €Ht³×¹ÚM¢öËÏFÉÞî\R÷íôµÈ|§Ìk*Ê”º‹“tv~:‚dD�¢ÎÊ°þ‘¯å‹*_«ïsªBì¶@zMI†§š¼Œý•ÏN{¡m2Æ¢{þíV2G:!Œ ›¯tPo¦½K‡”fÅ#ž… 9NtB#‡ï®Cßsoò»>ÙÜ�&†…¡3‰å&Çìü?Uï¤Ê •CÕ=-‹a¹r´ŒÓ®jûêÔ�Ä®ܳ0*Wbvçi^VÊ7p§€OÖÜ  yôGùÄ×—3pß_{$ÜUìAYa&{í‚—x/ˆúÒÑb… ‹Ã|lñš Ñý­šu8´¨|¡Û0Ú/ Ê“5½âCrräÌzœEÓùµÄéÊ™=Pq¤'O¤q:‰õ¦û 8žõdÿ?ä„ßOÜÒxÝËþ¾ŽÐI }‡\ù¹ÛuÆÏãÈÿ¯$]»ý>§UÒ·µ‰Z/=Ž5EK¾ ëëf ¡‘w›/ÑŸ nTJýÒÖL¿0¥¢ªcúdÏöÛjñµáÆÓÁ9ì¡X>øÓ ‰›²<®÷j;Öó›`e-³öÇÖnÇÔlÇˬ GšJxô:9ùÙ2ó´:b¤:nãæËÃJ ÓØ™µ1:ú‘üïPë‰Ñ¯ª�á÷‹£€£ä1¼! {Qt2âËú¡ïqBÒð&mõ6™¬O}Xˆl•:dþHšØlBKpsylÞU2ân‘Al½8Hò°¢a «¶xqšrèP{jì°j¦@±ïßu×úI÷.š êÖ¨€dÔº§®¦ú°µúuôåvÕeÛ.Nø›3å&Æ@@IH�©Bùtó^Hg‰ƒy/ÍDÈž3}u†^©ÐLí¥T˜÷"w–8«jVí÷ôOØê]O‘?O‘Œk*Yö8i/8DÞõO†±…ïÇ]Êà{QRÖªu'ú1Wu,»ú#öÍ¢òí‰R ÿ_Îf 좓ÕH>?pO«à.{4²ŒžÈZCêÒÌ N=Õ‚ç¿󑲚XÍúZoÕé4!¡ÿ%d¦Ð‡°1à:ÊéXzWï‹Ø$! g£Í†ÿŸÒa×róÝ ø¬íwàÜ”ŽEOöi$·è~F€ ½‚É5„¨Ì^¥:ŸV8,Ï|Õ*oÒgÞï6̼. ü¿—M÷“R€Cí|°”Ùµµ‡n?cîîÛKÙÑX”šàR×Ð7¨ôEa¶n·NhI$¸~)Ñ•ÅñJ@  – ¼u‚˜³‰ ˆ²vÖ°ŒºT»¯9®ÑKü“Ü ÅŠÝd=QÏÃ’­ kkœÊsz.#Ñ-VqBÌg(ʃ²¯5‹Y¾Ü‚ú#Ÿ5µÌpy?Ö;=­ŠÐ½§£bù¬RqQT؃: ‡¼C#“ŠÄœûÔõ¸ÜõÃX‘x<Wô ËZÛq©^¿hÏ\Alw»Š¿? »‹mK±ý°? óp—7oq5Þpï4 ¡2é-òõ‰ñXÌ7÷d­CQ® ¢ëóìq4ÌAéQL_åækÑ‚î­øÄÂ’`Òvþ2%¡êà'µâÊ÷ögaÞ¬ÊÞo’Láª~á²›‹;I¦¶”ôj˜u¹ý‹%¡-#gÀFUwŸ@kÙNå Ã7GKÿ©Ç†"†¾<>mZn $­?SÖÔ«¼JÆ…•ó•’ÞÓÛrªø‰‘,ÚV´[ãÖ"ùóvâHfÔÜV{j‡‰¢Kв[€eMƶe%‡vÂVÞY­‚Ê,ƒ„ç"³A é¿0óvX…È ²)w¤ä£ÑÔzÃdpSæ¨^3…4äŽUsžn³EEƒˆŽ$ûF%A9X¶m‚ðµñÐã¯SÍ<µ>N*æ" r+Áš€åäµ Ûjxc/î@L|zmÆÖhMɱAµ0¡~N•á|êÅÞ`ìÐ}èöÊè5®_ù”2Šav²LžÅCª¯BJò&°wéˆN"ψÏÒ®¢àØ6ž+'ÃcììdçIháí= º…ô„¯¼ïSŠ¶Ö¾Å·ù”ÖÝù$¶3o=U®ô`g¯ä{l%‘nr׿c1¢}Ÿ{¢bæ}ŸÄç(Ðt¨Hòóž¢â�±æjç\UÅ_Í´±Ààzà½U÷àÑïÞ‹KŒwPNgStÀ¤r¬±´MÝÝñÍ3˜™$:m‚˜äí«ÿ·FžSYƒ*çýâðÜT&À¹ÀhÁV½$žöâ˜8)3Ÿ‰k\®7½úþf “1ݳ÷¼­»\+M ,=e¥É^}¢#ȽŒÐ•Çño 3c¡L*àÙ°nøtzåèê²%ÎË!'R•(^B ¥<É╱ƒ;”¾óÒPºžþ×—•Î¿†ëx0Š`óé)ý¢ã4.]õrUl¡IqdT†‰nÊfhÝM¡kª*pEJʪ'J+»‘›sR¾Œº‰¹C³nÎu'Ì …¦¥À•ÌK²óQäa¢3<ÈK•‰#+oEˆØS¾ÝK#¹] Ý>ê—Dÿ'…ë÷”l8‰¨¬q»‡ào5·Gô Xß´:J?öNâ÷@ÖÂWl( ¶û4Âų×(”&ì“"ÜYœ) ÔgŒ×Àx¤'œHk�Ùüº’oÏ7úNQètç(ô™@·VÞQqg8^(Ò1÷ë_Æ—nà©< ãÁzÖ—Ñ hý×ýß³ EËŸïSG¶fC>T§jZøAep±µš©í^ÐzŽW¸óò¢ô”º½Ê‹F¾¢•j(þæ(N£pj™ËTžtï [§õóvÞ®3-j´U.Õü3qÉ›ƒXýîí GY«“~¶À ->!Ç#½X`†¾öM=ü@‰Ð}¡òbžæ{½QæÕÓ:<u”>Ïý=쎯 /)]ÓÑ ê+cùì‰j0›Ü…RNþÌHɯowÂÞˆ\!Ê]ºsðÔâàPÕŠê‹Âȱµ uÞ--z³öä¼TÔÀwgÐßâUEíÕc׸ÑðYÐ#eàj9Lž6å|ªúFé=¯U£hãbwÆúL#4I®æiê6KJÝ9«·@öÞj^ºËÖv‰5jG ÒϬYÖxœGHäZbú¸8ηÛ]æ><vä©éà²ö³13*SïZî³,¿$î—“õ ú¶`€•îaÂÈ{Û?ü<·ÃA'‰Ž€ÛÆà²;>º‘ßæ¢÷øA¨RÒê ñºmuéM¸Tà­ucû;ÿ 5+]•}ÄTL×Þe)Šôù/ÑþiÙÒù ©³)Á€yíüõ2Ví; fB'Y7`„—± yæ;v%è;Ò)c]‹ÐÝíTL/ß° GAõ}O†²•Xz¶jdŸ–E²™BåºÅVžÚ4速¿÷»o¬Õ0 ý³ó·A\<eÔˆS%VÇy; Í™%®ú7Z>`Iü(¢9Z£V”Ї+˜òã)gõFýc û·oUº-)Ï¿Ktip³Bü‡Ñp~X±ÃïPëMä[6Òæh:½'—ñbÅRȘ'AØCnlòDÙxûY“lu°@—«xò½³sjöñäâô”±`) }í`VF±Ç¡5ÉÇ@¹Sƒ4œ,R"j1ð4Ô'`²šó•‡‚�NGõàœÈk:LÆ£¯Çê¤÷ö)„Z˜Jzj#jÒ W( 2áeýrgxÛÎxÜ×ài¬õ¦£[pêÓ`c«PžÞ #Æ°§ñ�ó¶_HV‚Çüá™,½ÙÎ<¶w;´úØ’žåý %µå¸bŸFÎd„ºO‚ô¢8K3!ý7Ès[ÔÎ dí Yj14fZ —'ð€ÈÀv†Êúí­¿ïi@¦™×håô 3†ÜjO¡y\õõA#–7_øý¨Aù‘N÷YÈ©lOnƒ2ꛡ­…›` �FÉ6±3Ê£U.ô¤ò\H²'zCŠç·ԅoþ㧚ùHrIà42»>¤îW× |)V’›@ýl…Y˜¢³½ßÕÜá͹§ _]Ò~ÆñøLT›CÄóÕÃFµÒ²—ŒÀHbÝÆrã…È(ë\à…ôi-÷¢­±´vvÜ÷ÊØWÝ:¢Mæ+óS¥G›Fuü¶Õ¹u 3Ýý`×l{¦>~ší)íÒ8e™¬>™C]q|½Q¶Çígû, ˆ]}ž¬"Êb?ÉÌDÿW”ÙŠ¿ˆTÓwå/¦™óìž�#ö\)yóÒxãTÌc1§oß“SùoÈþzÙg»2‘a‰Q ¢{תíÔ6<·ëZŒ�Œ[›¶0{ ²ÅÙfÒ/;¬¥1ô£ûWNîûº‹ÅøO‡/avÉë2N1/œfø†`{T¥´öHŒqßá-,tœ±¿xÀ=l“8Ç08fA:k¿ ÇÄ6GHQ\w!Í!¶KÁéBe÷’±zäÊP–8dN{Më«l-7…­r—•:[]MN]%'͸›òå» Yg>×bCg@dŽ^`6‰v´›2O)ãywõ¸XO±Ê,€„Þ¾i J©f;Úa·S¨±h´·‚(dúû}cíÍÚ2ÊZYô‹'!‹Ô䧦QÉú•ßi½±SØ‹Ø˳;SÕØ´vJ(@±Ye¨¸ ÆÿXþ0’æ÷˜Ö™\5 ÕaEÕ¨:ª¯¤ ÁÂùÿ±ö&[Ž*˶h›ýÑ{µÎ54A ¡„”€R¡ïÿ¿ãÙ4sswTG®wǹ)"öÞ ÜÍ­˜Åx#Ÿ¡4i3ïÄDÌ[úgzô…Å·¨È—@î~‡yÌ_ÆqÍ_@QêuÈCàßi£ÎvU¤à©š¹;2í[�áßDÅ;Áæ �62Ažåâ@¹};1f«ë©pc®`W©é,À 9›zM¯rÎ.Nð_„ØyÓð½]x/]vg0@ *ílC*âœ=4>_¨v¼BîUPoLD¤X§Dƒ¾z¨ŽÐî+ªÂòdÝñ ó-ZTR¤žç3Íœññâë}X‚[å>/PÛglºwy`yB¢g6l¡W:ôvdßòœÉ„|Q&Ý�jÎnÆðÕJâ:Ë¢Ôc.Ñ_8|§´„*›Â37À.ÕhÎ,ËÍYƒÄØ•ÇjYú’ߎׇğ_ĬÒ°úËÜë{Ýi噦ÜôEZ×r¤`û"”÷°K”¼tLÃr�¾E ðtÄy/Í›$ˆ­©2èë®Ú ûê ʶ¼äbxÃÔãÄscÅ(·Ê˜ÀH”*»5elW˜¿¤XhÒ¥�Д•fQ%Û¾~L²»öRzˆ‰ì¬;6 éî³`Õ_LÌ=R Û„u«ãbeSsk«U}¶r*þ¥ žï<š”AC RAouê(G:GD£Pq̺Ì/ö‡ñØŠ.¯g’ÅÓö|—âÙú ¿åɳNVë…‹¤ž@‚æj<ªÇá%QRäþ�ک΃¼Òùe±’¢îìQ|d׋êý wëÐõ“Ù¯ê)¶7¿<ðÑâÔA«lÌ»ºi3ú†\lª~žhU6Ž?pþçðÏ1RN_Ë=4"h;º`‹{€p¢šƒl«p¢'Ì«Dù,‘<,ÐC¹§V"ÃcÙIqÇ8¢yÈÀG©zȾð’ÍbH1V£-C §cˆ§‡¾½ó/&iyê xA¶*’£S%(™µýž°v?`žwSÝ®»·óÿ8Ê.瑸h¸0¶­ÿù¤å‹ª·gJ–·Ce gv×ÄßñÐ6µ{úŠ_êP\è~Ÿ)¶••Nªàµ,éØú(pºt×'¯c©�ð·Z&–– 2,àúÛ:>zÞñÕ¥§¿mû%?ò¥c×—Ô‡Õ¶Vßê톆õ©®|>_ ³ð™Ö–ÎjÄï}ãmA…vãÁ’0xt‡Õ”,S¿ÏK/;|ÎV­gîÞVHóMoÏÌï±¹ç9<ÑQ§ž9EÏÝ8Íÿ|ÏRÜç™aϽÚ¥}[Sz¢ø¶PSBU…Zæ#Ì#Sn.QÅ#cžÝãeЗ{â~êÊk¼Ä Œ‘-ã 2õåÂu ® ¿K ó'Þ2ÉÀHZ‹”IyT‡˜hùHZÌܽºc®§aQ&ì(“ ©†…ý4˜} Þx8ÿ»þÝœ¤õ~û‡,=`t,²Pp2íʈX ÑŸpÜ œpÙ‹×Ђ­8RUZÍ–ãâÍÇ/Þ­ŒŒ´&†Õl^eØvGw!³½ÆÜ@sæžõªQ˜Q¦—L½¬@5 8z2 °S½.ÌÑT–åžÕBœùJW´·ç Ê…vn—ˆ‰7¶ù™ÂCá‘õ2ܪ6£¨y_(íc%H½'é[xÎÏìkÖ—öªÄŠÎ�#$YtCß™ª:;Ÿõx2¢Ÿù“¡òQG´!v{¦ŒÚc#Êè÷ÃàÒKp¡¦Eºü F"T~g¦êÊÍ2¿îq3xú Ù{ì÷;ŠÄáT ‘êN)›ˆ¹-HùÇf¤ƒØ‡ñ&öî¼ÿ“ÿ(´Fq+Æm!qƒgá°µ†Dˆ„‡ 6ï&m¡ÿ3 ]nÒÉ @QXiìIÂZûÝ…¨õK=‘#-=阘u´1¦¿ÝôCà 3~üÊŠú¡J‰ïˆÎIxMIlÞn<iôÈ/yò[qŸYFäq{#Æ_›WÕp,lOf™6Ý7@=•kZ«µâõëmZº>,k=ìi®>­ ÆåÒš“§ ü£(½PÊ'Ó¦|ågý=… “•œ.Õipí}Rºýëñ4u@v^¡ãV‹¢*¢ÂB¥Öap|DðÖòé•'á.ž?þÔ€i½ý@µá¶ñ8ŒŽñ|È |¹ùn*OÓì0åþýHèP]¢P²­sþªàw¿ëYÉwšw}ëáó+ѯ¼º²M…ñ' ôCd­• ËYaোbSȵ¦çuÞ‰àõÕ+æñÂLÇpÀ=jkè‹ÎÂÃùrþ]wƒ|¡¬V'3Ý8lâ6õ"Ë{ÄèÔðl%ÐË]Q½Õ:V;ІaºO}»Ÿ áWR¥NçÛûO!‡+6!ƒ6eÄÖš¦7 À ±¯þTÕûöwd>F| Þ»Z€¬ ´É†WT.QØ í€ ·¦ê‹/9óÖh¶p:S1œöçOµey-Ñá'ûèiº§ê@zjý]ôfG…â(pÂãÌçAU×´ð»O«“臱ÆöÎJkjØ—ͧ7ÝWMC‰­6£?ªIù-Î|µ°4£]IĽ.IÖ*Fosê ¥õ D›¶kË{À]à¿i#¼K±R?¼³±FãÖ .¥ýÙ!~8¬ñÄh+;ÔИ£G,ÿ[;à2æJ>@Mþì‹NÀE:ÓTR!gÑé«L¡¸bn§j‚‡T:š›°tÈ=úÙÇM ‚–Ò¯­FÒcL-+ÚéHAl‹E-yÑc@íì(R®7`´ƒwp»]¡y|„DZC- “N•~ä ÅåF`ÿwD‰ß*ïŠÔÅacu´b¸Xº77]½ä²Àç„ï¿H¦³r½f-å†Ù`ÛÞ9VÃþ4^k,·çÝt_ÆÝÞ#1(Š¨TÊ‚âWå:ÓF?¼#`2¼êßž±`h€ ~ÝwYò¢2ºõô¬Ó ¯”¹ N¥”Á#ÍÉïÍR!Éëõ" ³$,r£ŒÆ£ÓÖó¨ZøÏŒ%Jz.òMIOyÈ~GÛÙ(½\ÉM<.¢Ýd'|‘vÍíã”MŠBØ—§ÌõðIw¢¡P]Z®½•N‰ÙØë_0Ë$]9û1:Žû‰n[Ó{Ci %þ¨!`A÷ŸlåKôyÍœEþkoñ»Ã4’ÔZüt€:tã—žjJ-ZÌoã.™J9Š1« QØhf06&†»I•˜qRlÐÚn]4¿ž:å‰ïÂGo6Ñ—OÛoß. ,E9øYÁÀËxõ? ¨ 2EÙ«[.‘…]‰„ÛÇAT©vŽ˜(nuˆ\ïdyì¶êp&ü_¸fɼ†¡è²°ØbS™£ñzmb®.{9BZÔ;Ä©âö”+¦TÖH© »ÀûÐô+x\¿Æžy&=—˜×ºÁá¦qn…ZÜa2¸Ôèw —Ëþ÷+ãc®z¼oƒ¼LÜ"àšA<[h.ìý.£$PÔȸ̋C/Z:¾GVªò‹npbÁ#Žs½3×$œ¡÷µ±[¥Æ0¢.aWy�=Ã…±þ'žœË3Q—Ä;Ä>¸î :$uì—¦•7P±ÝÀ›¦9ª„Ê»°ŒrÖØÎ'¬þL:9K<0ða FK†O¯å€›±no;îoc¨<š_ÆcÆ1¦;Ò«œqY²+ÎB©à8÷lY¯÷!³-‰].26 s'«³÷µýg'fÉ Ú¨DŸýäçÑRc ZÓñ¢ ­OÔˆÔ:ˆ™b˜Þ„7%›=gha †_¦)Š©ùaš>œ5XðTæâ‘ø…3'Œ]æ^ÙQ‘— ž/æŒ|sìfžXlÈ ]ärõ·'üÌyÖà‰ÿ…Ú¼ÍgMß„ÎWúìÉØ(é˜ pËLAÃ]Fsä3HXAY-ýË}o•” Â%”ì)‹ZU� ÌLß¾;W;Œéë¶ZÓl)ùH ôd·ráB`í”{pcªa0ú]Ë!Æ#0Péq_ØΣ®('¬¬zŽ¡‹ˆ¤ÑÛ¾B]Îô-òÊšA…Œ.‚• âÕ<;M;–æè.›ñқ͘r¸öÌŠÜâzdáæ‹nΊnA•Q‰uRŒuÄIñÜn?N”QnØ-�äà}è>¾ÌD|ù“/"”Ÿœ®¡O}œ=užßjÚÚ3xpUßCÅ+•™ ⤩rZo¶J»¾õ×äòðĈR€M)£ÔW[[Fáä—+ Íý ¹ šÜ¿G§Ž çË]Š¡Íè>ŸlûÞêÒÿ®ìÁð�àpƒw»Z™áJ?PdbŒ•ÁŠf?¸Ÿ½ß0ÛŠGvJ©Ÿ·­PŠAûçlòh9lÊ<¡­ÐUƒmH¿ã•G~‹‹R¡¦+}D~ÁûØ@:éy¬ÇL-C4žÒ—ŠÊ«#-Ô³2åÑÝ>\z±¼4Z²7­çyPš¸fNiœ©t©\idpM€]Ÿ÷køkª-â#ç¼0[€ñAò?¾éè9¼ÒnŸhF»«Íl$‡¥z6 ;×—"½ðXy¢¨gºµ;Uh¼®ÿ-j^ºtåËÁ‚qïÙC ©0f\e›»†§>Þ•š1— ¯½ˆMj‚ÜÉäQZr}Xä+a#ð6ÿ/ð‡h¹[!â€fý|r¬üÎpæõïÛ  Q&‰——{7JR_få瘂Žö³HÙ5åo»?¦#ýž?^šÚA\Èh žîÄÝÑw‘Á„‡x«] /]ç|7?^é“g¯È]Z»Á¢_Ó™vÖGûªç¦ëÉÞ‚Òra–rјv–±Šf\SIuhÇÅ´™'˜<¾á‡kÍ6Cƒ®…*m²GŒK¸ãÁê"ž›ç»˜ÑlEGª”`©`Þ’<ÈZ…IfK‰PO÷ÔΉÁÝüÐaI+p~¨ç"úÜ®KQß“88մݦ£—3Ò95Hi~®úû†¹›Ä^ê¾¢Î'Õ蚤-@™ Š˜YúÑ×Öº‰7Ää³i®è5-*YínÜ‘ð¹:‰\¾¼Ÿ‹ŠÛ”ÓÆ'U‹ÔÞŠáeüóaÜ5°¯»Ãaþ€p:÷»_xËÆn¢#Ií¹¡Í“:u¤äª“ƒ´ÖøºÈëÍp:OýçEñ±éR¯m ÕQÔ–~LÐŒV† SA¯î„¦ùvë2º}µ=î,C‘"Šq#üÙŠÌ ââÿröO'¹ Á•ýø!¸Å}‡p{¡ÌÏåýç2�²,PÔ5èrÖût}¹Wƒ¢Ücv1†fšh=F…Æ’(m£€Éz^7–¢¿òúøUÇæÓUú3Z×JÔ9 ³„ûôÈ©Ó o�O9‰œL™XÆ‘±·S«'Ëcßß,ͯš‡Ó9£LΚ ®¸ùqè«Í•7mkÜE¶óâÖð©¿ß½ÌŸg'k–(µ-æ=wLÈæ£_à‚a@)Ï¡á‘gBàI%•+‡þ«•„àÚó:’ÝjôÁü—þ¤­ï,‘Îò´_æËh¸éodÓ1†NC1‘훳WM³rÑCIÃǪB^ ¦`6gË*z ò°ŽJ¡Ã HolLŽÞøñ”bÁª¶Ê(F™žî>U/e3x2K5>â¡ú2Ïû4à<ŠJá#EôÔ;žé3cXá·ÊñˆI,åz�ÜÈîoEuG_ï1tãb©½VÒYâØ×nÂLï!`Ú½Iµ…ZIjóÇ2ú6ª¯"…ê)#·ž¦àö0ZI´.¦Ãxýj(ƒ€Ê.þÝ_ƒ{íÒ ¨œ)FWÚsLØV¾õÌ®D0ÑE¶Á(‚Ã7ÖâÐùJEøœºXÒC>i3@¡ZèÜÙaQØ^;\jZr«›”âåvkÈ•™”al\Ï ¡8°á •6ž·Þ$Íoâ%†2‡—"›Þy­ãoG°95H&Í‹z Óc÷.Q ‡N’-& ÃZs=Ø…[ê’¥K{iüMJÿ8Ò&é•^ã0@!ÌzkFì/rdnÓíékÕ—Å¿ü²e9+žJPšžbÞp¶™|<êÔ v*­"°I1_”ÊNàAÕŸ/‡„Vè/5],LãÆ6µ½à±æö_ùö¥Sþæï4Ÿ=±Ÿ‰Òü¥…£òw±ä¡ OB‘§wO‚¢R°h»=å÷8’äŽmZ†>¡l¦‘‡fû­¡Í(‡ûþåÕ>ìþŠÔ3 L{ò£BÿYf¶R5ÚæÎ+2˲…ó>úÿéðíµݨÏÔìg®ºüHþÔä(UÑH!lS$Yÿ¦J¥8jÈÅégv<³åîPùBcoX(d‹Ìs‡Xh'ÐI%ž"£¡zc?¹ÄÆÏvÛSåu¾xB¦T[Ñ'·¦`MŸjОÆS®È ¯ V§è-Úl| E÷Ì8Î „èÉ(ZL‚Æ Ìk’^é{jPÍ;)\¥Uï ·ýÅ©›²bÏ4·(ä›–¾ãCI3O8™—o°ÞPºZÚy�x†lr§ºÆãe˜€œÅ{eÝŸ†`¤§iªõíqÈßûVê‘PÜú ¦Å/õ»E– Œ¬ŸÖÓ ACÙú/ §U„ì…Èe·Ì ¯ÇËÔ~¤ÂûØÓÎ϶ça¤N-À'í¦/Ü·¸Š¼QÎÀ üõéåQS¯hõ—:ªa’Xs+±ÎsºÝö:Ìõ©ïÀl'ë¼ü_„ž­Ñ"ã×À˜À/¼üqÌa®gôÔSHßhŸâ’e°GçÙQÑðéGº£bì®<Ü ÊvãD1²‚J®öù 7Ffñ*¢(Ë°!YŽ0°ß›˜I»Ë@O¤ž’ %ýìeoò¶U§ Ç `Ô1VjNöt@ð¦3x7³VRÓ´“t `ÏÃÿ%¥ƒ½ÇÒ¦Û i2Ë]âTX°Úþ}ô $ÖÊ×íÁYC¡'Û¨ ÀT= @Þt¬ØÌÀØß(žWîËMRñà×].5ƒ§©‚§‚s dÏASÑ÷tNõýyÍl¾="l;ø—ÍeÓ6~3µVeP'µ°-«PùÇ‚’^ü‰ß’£ý„¼ä|£E2¢Ò¯âÖöW Éò¸é¡ü.aÚ¨'Ä|µi‹)T6dF\âIüG<Áé,ÏÿÊå=Í ,[)|H —CL«ñ×·u”î7ð@cx\ÂéÎKdôçÝv+ÿ!Jêa«Y¦AD,'+þ–úù¯¼y�cŽÃñ£:™í…Bdè|ò8˜&zã£æsÓ˜"9àÓœäke'©gŸ„Œb¤ólÒÑœ4j$>ê‡ý¢o…®%ܧÁoÀ±u-[ºÓTãínð›êÌøÞ¶z­£Y¥¢Ü0|A1H?­Ð?äÜyK"‡¼ù¼!‰qîë,0m6b4Îöå@]k"^Ø�gN¹Á¶0lýì]së0±J°3q2‘ññ¥ƒø¦*“Ÿ˜qèš²Áĉg×Ú'ëÃ0TÝôñëÄ)¾Í·ÓåðHº5EY¡6Yª¦Þ÷zÃd%,rßoúÏçgVœ‰&¹ GùsÀlF©çnÎ*lÖb›‚¢nikaÖoz©áŒ–ÉAw*ƒèT9^4¯EuС83y|©¿ã5! Z¸]@&b²±•¢>œa®¥-; O{ ¾LÊUêÕ°´©ôî>Ý | � cëÂ7jóÃ;j‚å*O=Ú%˜t—VŸg½Éër—„—Nåp|“Úi$Ñe§±çȸM0ÓÌAÎâç©ß RŸÞ]ÞËŠ}¿§nyy…ù2Ft•¬0šq€6X¼ÔSYÄtiÑfu ëôÉ̤’î2aAÓ¥aK¹»?=쪔€D›¸‰yšS3C܉DedGbïøM?ä'žXCê†Î­jrê™ÕÔI0£5sb ìû"yäúÇ2„×@öm7ËÅÓ‡’\®ºô“ðÃG&q}Õ, ÕïÖ Ó§¾ ’aö,»èc¬éÖ¢N´¨F(TÓw@}˳_/Añ“Ã¥NyêK'By7‰é è¦ÅôJÒBŽA pì<ë7”Ÿ¢Þ£Øé4<_Ôj½uì|Iýy‚À, �ìïækÄCêu™V"®I V;»§Ê²¤-\û<˜àÏ$6‹ÔK ¡T3äAÚøþ{Tí@ –Y°¿Ùð!ãšÏðCqšùãzËþ”ѬFÑ ¸­µ1€r2‡ÐXŸþüá“ðª_zÍÝý¥ï‚(ʬP@‡—ž;èªPzÕ3wš™O¢ªfˆ—?=Ô%¶®çÀÏ„<D«èŽ}:Œó7ϺðÁì0ü_¤â!HßX²yÈ<Év:†k1~YHVÀ<o&ë¶ø¢l…ÃÂ3T²i­IzÕÍn«¶ßy+jgZ÷æ~ šy[9eˆžÒòì×䯆‹2*?ó{ÑQ^3ÖqÝíŽGtS(?2ÜñqO+/6œO}&ŠfG­1è^›ãŸ,WŠ¶õùäÇ ^š?¢F…{<‚zo¿©Â ?OèŠÃÁpšmŸžbÜÍÜAÑã7WûÆÄ,VÙX(zLåd+äKE\æƒÕ›NÒ{-¥$^¨˜å ÅAlWVD?ñ]Zˇ‚Ù›l¢¬È-Ã0{oºá§v/óÈщœ’«úiz—¦Ect /½×²É´í$–¹ dU2Ê0Ž^€ÚÓg^¾-ffM¿!«’-T ¹üÝ;©*#Ø¡=Rž3Ý}±w<òˆ¼Çfà~³Z'u B9hÈ3¾ç³¿l©ÿ£–¾þ¸1¹{jWú¹­ë[¦¿óÌ;ºZ‘•‰Mh–Œ:<I0+; عö ®ª{B´Q¨»…W7­0 ªãOåÌ„8ÜáÛâ¤`_©#ã Ö²ʾ…"qsr˜:¡OšPøžgñ¬‘•ö16²F–™¨*­)»8î*–Ço+ãºuûm­æ‘8d­J€½â l}x,ãÄ>PlæFMßV{Ãq˜ŽÕëD”ùò°&ÚÁqëÉøqbGg;}¼j˜ÿ†Y±ôŽáSSEßxÖínãN´ú â&Nql·`oÙûTæ¾”Uj,\>+Oˆ| ±=óáË“,{±¯˜µ!i†'l†™;åAÓ„¹{T͉”bD_í¬H–#=§#Ý#(¹érl˜çtˆÆAQëúÎ9ŸÜÙl^°Æ2Ô4 _ÙëÞ1ºDÒx~AÒKàÄ—7[[8#²*9A·åWË©1këÕ&ié°•²;)WØý×r@·}kÈ'|” >¶$ì5Æ5®ïf¬a®á:2 "¤z`ΘzÍœ‹%œß$y7¿ûôÌ_8LŠ”V¿ö¥8„Ó2 ©šiét ª¸W”q–€Ë_ËÞW(‚rQ6Ð6þš©l¨U)dâÈbÊrŸ2cáïrÙIxÔ?¬ˆ‘ê6¯g4á›Ñ±& 1Ê0Ó‡¤3%Ÿ Ž,j$7ëäœq20røÒÞüDú_lÚ /rûûêK$ ="J¼òIp¯Ž0βD߈Ñ^è³ÚÊq*Ú¹?RÞ£Á¹|/Û+}mʯéÉ®XÈ-´u ¥·‘t‘þøOžpæ!Ø_l>Áª>š¥Ã£PnÛM”Nš¤;3¿æ(ÅLS>ëÕã|¨•k`{ì¶ Š`\ªy½Qe–Ù·yybEž+_¦çT@„§³çµY_(É6†;ÇÄò�Oƒ&ÈáÝÑ$òòŽ„u_ Cí¬†X87³ë[0$Çö^+¿Dò;c¾âÜžöîöb¦ŠhþvU¿¾XΡAë>í‰sg|QÓ‚¤ßŸ=& E€6x6›ƒ ÍZ$ßû‰ýñÀ}N††Ûtâ)(í'JÇežè~fã~89ÿ¦#ë趽‘œŸN@3z#¦§rIÏÅ“Ô¿%,Œ—lGa:®Zí`§>¼Î9†q§â¿õOÕ2eŸS~Þ°­táL€¬èN¢)�‹ºÝººÜBX}ÒZÊèì*­ L@•¶×˜&ãÿ®g‰•—ù‚D1£)Üø¼HœÞ¬¨/@¯h.Îzd/-éÖ»-šÓ²Mþ5Š¿gç=ˆÔ†1·ù*‚äSÑÈÛ¸ Õ`°t˜[¦‡9.FòUÏ+É¿då9ò°·†;"·ÿ8ÝÀœqFåóÞ\SV”a5ÄO¨±:ÅvM_ý> ðÝJ·!¶U6« ÃGn[;/;#'&ïÒóžÅ4ð`tqí±c…ãGùІÀÃ}””¾w<ÒÕrž'ïðç^¾Vq,1wõ¢«ÔÆ7ZE—Púk±UmªÚéãBéá©j†½Lçɾç‹þ«|Ú×ZÑÛIÞÔ,ÒNpHê¶í÷÷/¯ÖÅÊ'A†¿Éi‹ú‚PÍX­OGÇÝCögr *X±Ì«ÿxu<жp%«¦ö]{¼Ð£Æ›©VKkô«²¢ƒR ¶� ‡Í¬ä”×Õ™mºÙíwJYÑÆÄ•jãö™Êàû;Úm:n¸mý¤áÊ×ñ¢¬f€˜¾x46 í€(˜|±\ñ9¸þY½¨¼€.*`Ü­·+tñ`èÓ4—ÍØœã›èË¿A¸¼r‡ÉFë9 ÒSk’$iÔW§íišY/Éx 7ͨSwµ/Wê_ëVyBPU`W=<Íf„Åøä4¸ÜuŽôº”-:µx·Ó˜@ ݸΘõ™ñ—Ä‹0IVžr"eœ› û£ÐÄ[‰¨nµ¶ûW<×èí‚óhž…òš½±+“CÏ&CÝäyk7»ýþ`Õó¢{Åú"¾!ÌýEaÅvE­ =@…òNs‹4»†ÍU'–²´ä4wq§ ‹¢L½" µ«Òj‡"¬çÉ -+þ£Ç¶úºª{³dqb¼š姭*Œ<âtYW ÊAQ³Úw‡cû|¼ç‰uÛ‘6è™í²'ÕBÃs¼@¶PjDzh¢íu¡hÄݘkÄN¬çC¤½Ï!ÀÛÞªATͪF_J—Ñ)EÕ×p&Næ2tw…4QÐé¶)Û˜Ä*(Ö€bšO£h–l,9ÛPѯ¬ÁØâ§gn#ÙjÞ¢›µÛR0©œ‚ÒŽÖËoËÝÅjôf7OÊ”0‰œ>8XÓÁ­‡îgÏ,½²V\˜¨»ü»®¥fÆõ}܆Ðuh½*à4þ:AÞÆØ¥uPvÀ b!Õê}¹úúƒ©ß,£ˆ”ÉÊbx2á1Òeú¤)éhç'æx±Ú~¿>=. ¦Z^£Pâ ‰~!k'ŒYo~ƒ„—2‡ièXµ¡x¯AœNý„Ðø ñ6‰áPaŠ#·~bAZ¤Qê©¿Ph«„!§2•ÔÃÌaÍM³èæI½ÞN °ü©÷•Hu¯€ Ëhå!0«ÛRœ.¦²>UwgaFªnp@œÃ´»ƒ9ÑÜQæh¹¬ç<·pFât¾«6¤€îôNŽ¾fm´–R—a^hy Žs}òBÉIîÛ1Æ¡EàÕ: ö@q}À”À IžTAQæòM¦ v å›Ö*QhŸÛn6¶wËfzSÃIz¤fȳþ]Qo£>;üžû(nèòS�Þü(/¡õ»æ×0þ(J=Ì€[˜ [Âz˜é…ÞkÏÆgÞïçÓa¯wÂR‰çq5æÌô@w˜t“xÎÆ%ûËlÎÇGíΰæ9rß=í¡Ä:r3‰zÜU~Ïà/„6ž†Ï{nè™$ŸµR;MÀê†2 øE_÷˜¬ô‚dX´ÆÖãŠ_ Ú¾»@M̦j¶(£ž×bU&+‡]W&wíë9¡`ºÊdBWlîǬî,uóIÞq`ú'Û³i!“—jL"]Éé‹Å²¼$ú'eä\¨é!ÙWZ@ÖÕŽ•¸iÈù‹h‘sÈÞ ®ž)ÿÅeê £–ô_¤zÝ)ß`V}#©=Z²«D|/ÐÝ»ò àR…ihÝG'«-ÄÖÙhõ‰;–w¥iž€Lœ‘&«Õ(<h!¸9|# ÿó‘'&cÑñ_‰ò±yŠªÉŒ¤Þ0Ò¢ÇJû~JKý`á<³ '¹IÆ<PñyÆ_j/Þ€ÛZþ-ˆÿÇ”BžlkúÎ ¾ZgðFU2Ðx“»¸KzÞ\2¥‚Ü@2XyŽ¼°|ÏÝÞNΗÈïG9iášÿ"³¨/ç°›§ø_Ê} áÆ»¬=@/¬95¢ÿµ4æY�"¸È”¡ùÔ¹vîG}obþrtúl]Ì")ŽVJ,áS¶÷TDz(t[6ÉüÑ6{ ¹Ä’Il‡(2d6¶ˆÆ?ž(BsÂåë/}-œÜÏ¡ó‘…AÙa¤,JgÀ÷¨÷<S¬H’‘üÌ)Q*(MÖú0bÃNøL³ð·Ðó.ï‹õä:W×éó†îzb]íÒ\¤ù<e~ ãŒÅW«.W‘ªˆ|3ëÂ|y°úeQ8l&øÛÌÕÏ )nsÜú‘>Ÿ3¸Ox0Š)__y©Yæ¸öØ~hÊG¥¥¶ÂßBEsªLõHß\ç«üؤ“}b"7É*e¬.Ï×›ÓvµºÂUô9Ò_úÅbnk®&Ÿ³;@£‘GÀW?Pé}5Lâ$ñ¼{¡×ÐŒþpÊ[<[vâ[ÿ|Ä&ÊѺàYIÿ.Å_K{6vÒ®ÙÕ¤×}8u'Jì,7Ð` ïkÿêU3Û¿Hz%´8â ª9ZÚºj¨¸œæ×c%Ž°ðÎÞŒµH\ÛužÜ9Êù¿­ÊtµÌIê2(ýrr*t©ÀÚYÂ5°<##´_‡;±”¥ ©¶dVõk:×*:N´ýç YÄî?“'jäÛ®^mg%^Êô<czžU:�RÄ‹µ|§¢EhPF�_Ž„ë¡òýßzOuU˜IðqŒ9²ØBïó`V Q ±ÏRóÛÞžíK ¡+ zJ«òãÖå=ô_=º!ÎO\"ĉU¼%å³âà™ªãÑAù„…Ô¼m·¾°ÁÜž¿ŒìÚí]±Zb!K ­BIªVJºˆwú?I¡bÿ½Ù éÝI§’Ôן:,·´×y5  2¸Å©ï‘g)þs_suíd"ßaö­Yøtëº\¿j„yNoo{tû×{˜rÞݯGv'`¡Qâ6òn”ìçàÈö´°¶ÒÔ¯QèV×iU­p£hçÖëõh€ÞeG§Ú&ËõèÔCbÉj!NüË6Ä"¦£œ–#Ë0£LŸüúõŽ|äÌ~=ÀÉ¢ñýs¨†°ëÏ*Ý?ý÷CKßj< WØ1 /]øu©bÓ´íŸt®ºò<0¯¼0#µ½ s£ÛÀQª¬•(šÀ¢•Î6ŽX†ÍE_šõ0×å˜5·/p\©Wf6Gp·–ÖÒؘ×qW¡H{•?èæÙÂ`)bS²°¬&¾94–¼È7¼È\p‰ŒÔÔy*ƒÕÔ;W•^â®ij>·Ü\Ø´`³GÁ”Ó'ý´ *Üi¸txÅ%¾ô$øÝë‹ÛÂÏŸVrŠ¼Þ$)K'oò³ÙmZ_v€éþ‚—LˆöwÅ"ÏŠ¸0ªíô}&§kV×ÿ¯lRÏb…©$0º-›“§óƒ‚Ñza`[:ñ >ÜØX,<Íž¨ ÒFJKªÿ?Ì¿,+L…t#Nþ)–õ¿¼?IôàL9긽ûL=·LýU¿i6fŠ»@ü_fwÃÐŽI¢f8¦Ü5ªèy{üôäPŒÇ.˸R c i1ñÃÏ7£7˜• Œ^Ñ gQøXNtpzž½þÄ.Ènµãeq‚ËCGÕÈô–?”J]žÇÈI9ÞŒVl{†ØÊ·ƒ©6Z}ÏÂe\.&B”Ñ3†Â¨°›éPÔt€œ=Eî ±­¢EŽÒúÁ‹nüd˜7iq©#)kÿíÛ)ŽôÐ ¾ý F=:‹T*†~ŒOP¶€:hzÓ®-£Þ¥ÊazjÉazzžªh ûxj.•¥ ½L³h!®O%äPúÑ!xå9;{ÜÖèì¿Råejl’è÷¶£#0P†ÝËCK°Ã´? \·x,ð§ò®ËŸPµå®=ÎHaN¢¾w„õ ½%/'ù# ¶o% yäÚ²âCŒlê»ãoÀ¼Ê äõuö””ŽÝ—±Í‰mbrÜ¡ÇgÇ–÷Mrï^º¹¸Ï…`ÓÒñ’ýÙzÍ -L+Ç7–ô]Åí{ðÅ"YùÜʹÇ=ÕoŸúh$î%Áp:ŠR*å'È=†VÕ´Ï牢Ö^2X¡o¶nki+_S„•#/Xƒô•ÊQë0€I1êëÚVÚaKu@ßÚ„gëݘԾ-[â¶Ã®—Ž²ÀH}Xù…5UÆt?R!Ô0TÞI=ã4æ¾C°‚T) ö)†>hÐJUm¼íÅk‘ºOìÈ +rúôtãè|mmñ3I‹ÄOLЙfRÿ8»@Žüt÷Ÿ¤z¢lUzæâ”OYƒò_C£äâ.cpÙÏ–V ’0‹‹| ˜ŒSo°&þ?\Ü.ª²ØŽm_a”½h–1õE`Ôz¡<+¯Øå=Ûg ñ·.s£ Ç½RÈðÄ`¥µº†éd´=Éîpf1=mš(ÅÙ9ywŠÄå|rgsIgüà=T:Ré&ë—Þ ?áJ¸¾Ò‡‘j‰{´:,^Œ¿1â8Φ€Ø§7ûIƒí yý!oÞ‰6\A§~d¿þ8õW/hy6ž`Àu|ê¬é¬2£1¾=Ñ­Œ§ÆëúbÖ&P¬Ñø´Wnl`AƒÖžVÁ‡oºÍáº1XÍ_þk×h’í]R~42pn¹­ÓÂY¥âø ú7§“küHÑ+ððþÄÇÙÍ¿8„#§ƒÊ…Íq,‚Ì’šbvæ†QúÖ é|×oå/S†4N}ùÐ4Š›­-“JÁñ}¢é!ƒ8s’YØ×;×–cdÆe¡À=3*“(clUja³d‡ª? î^5âǶYW¢M*@:4:ïþÒ3¦Z¥Æ7ª@tÕC~ 'pÅ=/°J`ÿ–ÅîñÙ»`„â;¬Á ¨´µDÿCU¾Û2´§SûG8æU?3Ñå‡6>©N°ûõ¾-ƒâ³SsðÃ7»ËdœAò0Ï ¦§FÆfq’Æž>¤ç)æ†Pdk´ñÄÞ–Üq]é?¨øÝD36ÐùózåVI‚c œeì:iý;WK! %šÇë#LtRÊí$´2M¿#âñ»5õ=«~å›â’¡­œKCN©Tˆ¿< +*ó×gOˆ7pÐÖ³*3 1J{sÖ¢pœ¦yg”¾¦«D÷uÚ›¬|Æ•¬“ ï'¼}¥TIqÏÂ(U/4}‡Í½V"š7P ª=P±}üVt:àÏ­ÜU: )ÑU1Wwuq0Nƒâôé‘è)Éç5'ÙmÃð^8zû›gÔ<³pC ªh¯ÐÏŸg%01‹cì¯Tú(+®‹y}a'{œ£ùÄ@­¦íF÷u`¨,MRüå´bµZ¸ˆçP¯âmåIOˆ›-ûVŸÒy¡Tªg³8yAŤN‚ĨçÑÝb²}K›rtQ-Žo�?ÓļÁÖ¿\ö¡m—‚êt›¶§š‰ƒÓŠØ@çyGKV°Ýò¯Ì6-2o)ΰˆÌp—ç+´´XPÊìœAÑ;µRû2b`æÄ•JZ•»áÑûÚ*›û~“rÞ­X'¸£ ݲڨÚBÔíú× )íÍ`-•Í³šç²sÌX\žÞ6WÐèÊÀ!&5ŽÖÕÅ´cé ­`ëÄurœ‹¹¦_í–·?š6L‰3.µ;B§ùå¶Æ~§-Ló Õ“Ú]ÜS[OWE–$‘iJ18±îé›:Æ¢DžÃ9dþùHiSÄ¡àì{—ÐaÉK̼ÜÙã¡ U8eý©¦Q÷ŽŠžÒôÚÆ‚½¡‘wbKvà´:ï ÂF×U|½6–Õ–2ãMÄTQúÊœƒ8½õÛ´m¿—¾çϨÓaºLÆ�ä2:;u¾‰ñ–âôo4Ã"i‘'q -cJÁTuíºcµþò˜ë5ü· kÇ°˜éÐï¸Im/n€VêY”6€óÊ‚üׯÕ3CËÁvÏá£då“¡|Þ&Aúyñ͆fŒó¤oÅ•I5b¥¿£]–}5÷]žÚ€C ]g,"œPÙ0(¥¹sJuú^à)a]vú’~Ekw£j¯J9´wʬLÓRK]‡$¢,¯3Lç­²ž`¤ã¨H½$ ƒÅ õTå!šù³+s¢j4ô³‡Qâ>~0šè7V yµdÇ`^vÎì @|R§GaX>ÏÊ’q\s§ßz6¥WºÑsÛ4æ¯x—ï ±&×CÇ6¡}Ý꾎£ X¬±/|hŒJ¤yñÒ´OŲ²%G–Õ¿@ö1-ù ¦�Ñ:„cÑ£AF˜ Ýø˜1÷Q»õõvUøK5É~àõfG§\Ó‘´ÞÐúLÛÞ#àÁ@­©xZwëêÜ{Wr»¸²Ôaít†‹ÑüiáØUüÆ/ üÏ4;#¿[›rÆ ];Œ Yk”r;Ž¢¢kõzx¯MÈ=oc(H[Óöy [¡¡j˜ejc.^<F lÊ ‹¨§²5l™À'‡ŸuÁÕ6Š§O¢è¬ö…GWB™F‡€NÁøƈtçÂû”±7»ÎƒîN†èÀK±ê‘™#8^ÕŽÝÅIϼø=ä_´ïÂß}ñò—gyYŸ�0Á–GHzÐÿoÞŽ™®k&CjV+£L©÷1¬¬Ï3äIÔÄ̋Ⱥ,ÅÊ"ÏÎ1’Dk”ÝÉQI®)”•¯¬öf‡ý+iêpåF+"+ßUqP~N^llªqíy.´Nw“ԯݙú˜ÙÉ– ißtFCRò›·\áÿ¢Ð B‰Â“^Nµ A”¤N£ÂÝ…BI´–†�ó+Êb‹Omé&…Ð?DaÕê×Ýiþ?cøM7h}Oû;®m¡g ›‹‚ ¥ÀE§ã¾§†UŠ!–Š’=%]E”º'm‹™Mˆ{õ'ˆè½š!Owš£¶¼9äߪ6û¶ñiÝ+¼Îéö¡gÅòF ÷PéâB¼•SóÐì¥ïå®Öè¥ódî6Ÿô1KÌMhèÖg­µ)†î7g=Î2—Ö¢ö_^úiplD*¦3=«ëU–¶]›’J\ÉáLˆ›%þU7÷¢¨Ô(i°ônÂæPiú-’JÛÜ #¾›zhÖìÑ{ò¤ÇãªñBÿlq«—éØûÍÎPœ¹ôŽ±¦&}­ Ÿ4„p-éÚ=©Æ8ÓÚˆQ @¦tóJ_![°øVÁå€OoyЫ€c–ÃÖÓÚ9þõ-]Ö6üW¦)9Í!</‹ƒ®áäÙ¤¡ý¾~Âi‘úƒ®c$ÝÆ6~û^TŸ>ؽ]Ïú«¨ÿFÑ›ª~gp¼ö X+{Pä ~´@FTiVä"‰ÏºÜëÃx4kÛ]=¤w!ÅI[Ê‚¾5íÍ‚‘9ˆÃ(šÐšØsAt„|‚=ëT·öå/}ð‚”µ¥(;gÓ/[#4Ó_¦%kQ ?Ñtc3]•á íéÃ7}«£ZÄÌ”/# @õ`W´xõ|}*#™ÇN˜7£9ôÀȨ´l(0|¼ LMJ{áŒZ[¼Ü?zÓr¡£¥AÎV×W–ÁF–Yo²d¦<«ÐŒ€‡£(h¸~{û‚¥¯ºµê�/a¦—[^±´“<Ðí…ã…Å6;@‡ƒék×ËÔ°ù¤i~‡-G©¯ùÁ¾Ã(ê?Žq³f€É.ž×aæ�•Lñ¢ÿ>à“§~³(†ó>³›‘Ýåß±!W…ëÓ3#aÿEGdºŒŠi)x…Ý¡×>ýþ(nÓfæ~ýŠÜ¡ðmYwˆþYYÔRl8¦Sh¥`òƇÉsj¿igE,£ ó£F²-§ˆ5#« q–ówýñ$ñl)Ù™}]ÓúË·^’=vmk’*™!hU_Ù|Gˆ¾ú³Qœ^þHçpì ì±WrS¹ªsoŒùyËÓ©:¹ù?ÊÇ™‹ ©±,è&þñT=0):HÿÝú¬¾k¸š¤Ë=h{ ÜŸßNXI Ð5»(îtùòXgVô” DüUñè,ú¶2Sü–ÎK#&ñ¦ª•m£ ‹’ÃîH!þ¥5mZ#Õ!qÖ+×å1í%=˜Rr:ãWgkæž‹gž­á*ܘØD¡‡ç9”ÜãÓ3Í¡"3ÀÒ /Vô!×rÿ™¢û*q¹3±*sìt$Òe†G ²ý-EfG%ög f䟓›#�³½öšJ@ØûDìŸ.ÅìþPËl3øN³ [i* ŒåO~�e ”¤¤½"ÈËŠö許OÉQqèËíaBâ6Z¯¡xXÏÕï]å±ÿM!øÎ5NÖØ&n¢ uÄxØFQÚÍëŽâöáù˜ÜæÄÜLþßÿgúè/Ãpw’¤®v,p´@� Ûm²LÇU5s;\ª—Yß?ÑRqø}iˆOqw:ÚÌŠ³ÿm{·Î÷í§ämß=ác÷7 ì·~šõet«–ŒN¨è%¿VP^¥>k-#ž|å›Î3ÛUº*•@ÛÛ'>gx$®å· ú®]µWEkšþø¤êM�¨>Ɗ°$!ÆfQ¢tóܬùi‚ž×·{¢Š¢rö®+J#.»I™W?q¿÷xØ ³G9òfŒkmKªµ6v6·dÞǦ?Æä¯BÙ¥|Bæ§èŽëÇ'þT2ç ‰Hñ¹õ$y~ïPÂèÆC8–¸¤Úú¾ñú÷œ—³…¦i ˆµåÃ0””R>ˆiAÉ~Àþóô®ê}y¾\ñÑYzVÌóN¼T%ú2„—ð7ó4ÍX¶} ‡£'ÐT]§žî9ÆuäMíàd�ìb¬®´ŒZšëÙ{¹òóq”“#ÕE§£Y­à4³º3Êw§§ûžf`¸Êâ(4¦Œ]»é€ë­eæŽÆQµ°BúÛnŒM qw�0ЖÞ”óœãd£Ãz<�Âh›PaX‹~‘à2½ÔùT×&ÓÛTâå­¯>¦ ¼uO DFùD;91tn (èݬ§ãKKN\©Cêú\‰ch8ã0ÍKðóÁYý¼~K×ùBç²Ojóûú¼.Ç=wûjo²1ákÈ PÏåΉyeð]Ûî´ôQ+4²Ðk”¥œ'B½ù1qe§DPDÝ•HT,ú×]k $t {5úKš É%ŠîHÍaSõ,àô„¿r·ÖèE§Ð»M>gE¤Å¤‹éÞ0ö]ôµÆŠÂ1ZŒÿ‘ •/äéÄ·ô÷Šþä@»‡êKnܹZ˜V<º~`f®¢˜Ï#6TB<ßcà|<;¥FHÉšð Ý!Êëqý¢/¾ýÊ´ý›6 ’þè ösœ;guaÞ6Ù–…™Ôn*`×ÊßY¾\©ýå ¡Q0°¨˜OfÍSy¹v§™ÖMûcò/Ìó°”/–IŠ˜îHoÙkâ’Š4»ÓEh*¶ýGÇ•qËEÈòçGMvà)goÝ�Ñ×m<˜ ÖTB%"� €‹Iâ#¸`˜•NP_ _)²V·ÍÅa{+—z1G¸§ìÕÞOdÛÒôJT¹`d9h®˜m.ÝJ®¸õ€6ŒW7°úÜq̃èWç66¼æðy„Ò°î£/_—‡Ú jº¯Ÿg»JCñÊ3‚ly'E* ƒªÞfeÜî1sbïàL¹dÈ ­n™™™E˜ÀIJ|ΑéÔ_íÕ\q¶h ��†$rÖAÆêuÕeÂaV#¡ð�‹Æ›kÑÔCoA&v”LÓæoµ‡•Ñ‚¤¶Ff*tt¼4%1 ôŽZ²ò @ Óq„®„¢GÉ":ƒò¨Òñe_)+´ &�W? Ã~åfk@Þ1ÃÃWÝkèù|l{V |ÌìÈ=}›”­{ë4HGMÐYõ“ž…Ù;ô™Ñsû`S{˜]¼$†…iä³öatÜR”a½D\Ò ƒX"ñ)náì,€IÃdèí¸ ïÿî¶=dBF¤ÿ¶OéÁœZGßkðDíXÒ“ƒð.ïÈA¤«…`Š#ã#ï¼>€ 6¹7¢ñŒ qXh7EN€!Žà.T˜oe¡| é 9Ñþ˜G(ÆÀp‘¦¿K-ÍKDäIÇ‘³rl=6Åx1²8ÄX­k1Zxwˆ}úh%"ÊQ ÚšZÚ@rç¿ÕãH3ç\òt ›|Ø8ûrºÁ¿Ýô.ÍÆ'Vó0QÜ#¬T!6ÊÏí#íµ„ Œ¦ÀYC!+•½ }Ç› óÝ™iÕ¨ø· l‹¹U¼Zp1b4§)h~+c ¥ütÚ³ŽÐV²ªžò)è:\Ép—º»ÉjAª¦ò‹ŽÀ•µ] 1žG[Q(=®x b í!‹Cfª†¹µV@ŸÑsRƨ§ÁúPõÇÝl”Œ@3d®¬Á]¼Å.—Ê !+ܧÇOO›Bµ·¹Ï{OáÞ Ý»±[a8UÛãhkïþ9¯K™'êôä× ¤ Úå~ÿÒí4/Xð€o¸ÿ­¸ÊZ\FïÉÔS¦/ØžéjbÁ9æÈôùB[Ó2cÂÜ ™¸–=ƒ§PV6F NSõð%UÚÝ[*CFH¿cf¤{ðæYŸ ßp÷Ïë?^K™a•˜¹í„LZ� Žç†^›€OLJBa§ª8k`y7t> b–ƒà¶å\%dßR"'“½Çâ ¹cV4bîa¯Mzšó¿Mû/“ÎÙp9àß}P¡òññÑÛ-þ€“…ÎÿHœÞ§*+é®·ž–9¦Š{Óæ� ¯–î•EòQ—?±ætèGæŒgDr[†é£ÑRèÏBp²S¡û—Ò¨ÓA°8ï~Í×ZkO¿ Ô;…ŠwUx¸¯4ô¦OÔ*[L:¢ ÛÒ_´¾Î0ûßv"社Ÿ‰~‡‰“ÃEynâ ÝŠ6tĘÀ –·Ëp2n\l×_HÝe <wô_øYÐã’{Ì•Ÿž* :†o/w4PaY-[ÆIqã€Â Â9eŠî“?ülž*­k¡@ Nê.”²»Ÿ%ó6‹" óÔx<I@viEsÓ©^ ÿh”P†×Þ u¬ªÑ¯¿ØæÏLŸœ”Û;¢n †µ€W´d©mFLjÿ¼ô1Ew¦å,])wµhE„žQż í ‡þ,ŒÉ\[mY3NÎÿFCwղح¤ð‡Mƒø¨}àÍN<K`»câìtÂue(xÞ•ñ¨1T‚[¨Z¨z€¨™(e‚y)E 4‰˜G³®zV‘ëjõÝ,'¡ê‚Öž[ZHjTH1öEöÊUAy/dô‰Þ‘ ÿgKO&µ�ÙUAÙ ²‹ ]es[¸¹ü¸ÅÆ®]!öÓI}´£GH¨0Ø[¬;мð(9z"%B @úÒ(èA7µéœ¨H £ì¹êZò~ÓüyŒL¯ã`ßÆAnGîMÕÒ©†¤ìÐ{ª¦Â2â²Ô Û®zleéAk¦:sÊÁíØ…ª«Gy,l¸fe%̓¤tRÎXÑto«;GGêmJ6™¦/‘Ì•3l‡mOIòýX8³B‡æÆ|wà7n…É6ÓÞëŽ^÷™8“Î:õ)iï]ý˧ü¿@*ß4Š£pÁue…ÌÈ46~VTvƒP¾<Oöþõ;±O¤?g¤ Ê(r#ž7JqÃI-œºýatÀǯ¤ïU/bùä"_yÃqNbWG&¬UÞ@mpTC°pU,ÝE'|)JãŒÑŠŒDçsÛ6÷~uËæ°•qd$Æm§+íùei`ÅõøÒbæé•éC™[Æ<‹¦£ƒ¾®½y'˜eèé”�û*öl¸÷+³› ïdîAsÍÍ|CG´KctÀ;'*$ïÁˆ^ý«Õ ¥`sÞ¦Ÿ‘~!JÜ E±HáC£ý<[ÆS(ˆRÀ«Ù±ÇÀN~$ÿìDIùŠèxüMþÂ8Ž“¨}T¶¹ìOKõUñ®ša¶c øUûéõYàå44c{–ªo�ª^l´ùDr憆™·9ÂBºÆR3YJÚ‹ÑO¢)ÁuØ4)dú½ö1ë X}ñ¶ÂþheÒaJsÆFS")ýâ4œŸ…gl‘gîœâ7«!7W ‹(¸I¨nlÍ¿tà6»ã6èe;Æù N±¶’žˆdknCMqTD£Ò¢wÒ•±q˜QŠ>œœöWÝö «4Œ£Õn;8¹t4èÉcåÞ'·‘–´“ ºI®Ÿ;%‘ Á0‰„jSM™6è#Ù™h©æÚz¤³òŽaR:Uë/Oœà¯» eºp•ÈXsmåAŠ Õ–gŽñ†˜ê‚‡‘á%Ô,@n Q sD_¶ó¬ñþÀX ÚtÊÀžhÛY§’ÒzTôºþ“]RæÉj0˜5-ÓZiÆ1 ]Lœ"{Uå+%Ë$öPœ¡íc*)­ßŠŠG°¢3žU˜æ¶¯ú'T<ª¸›8‰ŸÈ-¨aÊׇߎÞÍó}£èð°Yyj,|:Q; “eµ4b@c—?Ý©ã ³gƒÄ~ƒÑ—”‰[@ì¼ú5ÓÂ;¯ ÉɽÒþS«@M¬ÿ[=ÑqXŒŸ=džb™%Éþ0ï¹t]ZV˜ªåü}l¥†±EvÃÚÇF„}_æéðæÿ`v6M·àŸÄj ‰ôpÈ$†òX;¸*­€/;؇»G>ˆ}wgy,Ä4,¤›<öÿ‡N†W£wÆÕBpQSòØž¾9RÌöùd\YFehU71%ËÑQRewÆ¥Œ”09§˜¡ÑÝãcù\É™ËíçέCBäÁØÑ×ùì¼^¬]Ågxlw|„\½ å€]¶ÐPÑ*<Ê°˜yAd×�Ô§»‹ÊÔxgœêxŠQlC¢ ÐÔîíx­Ð}yˆ‹ìÆõÉè8£J¶Pw)“ÉP¨½¡¢ö˜wæL¼j)5ôΧé(ëó=Ÿêôª‰= á·^¤q<a ã, 5ŸYà@îêŽÔW±Êì7IX4f€B§ª PTÿíKTð½ÇûݹXE…6J£´ÿ‚Í"w ÍrsøV^›jÙþ$¡*K—»…@¬ÁßZ5¾Üp¨ºéÝ!­D)Éÿ×$9¹×:ØN“síŒlL*h<ö&|c*6o/¦n<8'º|Áå —òßè³²\ptVúz&´= q‘5ÆIïиÅøçb*•0p±;G´ SU±ç'‚±8A;í'RLò¯[#Ìg/þ¦Ë[ÆéÏÝÌt3…Rá2,DÐ%åHÌampÑznM b/y%^ÛJ§;å0—‚nÛ¬(JôIwT\ŸÍ{÷£æÌH�Zq7¿Ø\ú檦Ò,B¾§¢ ÞêmŒÅ{xë¹¼'i­¿X”}O LéLïwwç˜8Õ›qGaò}aßÜó˜äRˆÒ¨2ˆýè btJ8ØDÏ´}—&cêtÇé…¿ØšP>s†Évkf»ÿ´þ‡¿[SSPiÄ! c‹3"úï1¯Ø‰”±.^û W=K$ùÚq!kѽ� ³!ùáË*³ÉÊY’èSot¿b½ã ò˜e ðÅûÝÆcÑãÐm<ñš‡çê*KýÉÜàQl l2~jloj}Ä3ÀO ƒÌÅÍCûg¯­ Ƚ§¤.´ÂŠôçÙÄ|Д•ÅvOÍpð®èOž/æ_Ç`²àœÛžI?ÛÊàãß ûª¡ØÙ‘›cÝý°÷iÙŽîè¬]ohe­¢ ™êzÞlZúöT›SÊ»à–Óç“ûâEÑA‹} êbQÈ%Ë»7-'1O€Ò…Ç"mÍsI dö¤ÏéòååïYEX³Âc¯Ñª gUGÓU'Ùݨ‹�ð'Ÿbþ;8¥¿ÔräÎÚz=;“ŠÔ eþ–`,lÝí%šR&sæ{Í5ãó+àT¼T?Gm1–úÆtÄð iz’ Àõ¡˜ÑW=¥#¿ÿŽn¶=ó!ˆv©ÆÃ8˜Ö´wùL÷,FÞâÚiKîC´S¶º.@šoÁÙ'BŠ˜^ìŠð‰\¬åT÷441)¯)2Ÿ^4í# L,ÙL!=ZÛAŠ#ê;±fkçóÌV!4K•J§'´ÿJè~ö i½Šã25I;pP¯dŸ gº2 ÐÐ&« óÁ˜yÝMe­IFfÐbãM`^•Y! å˜<8o訲¦ñ™0\×ì¸^©R~ÛïYö”’ñ¹ÝP28?v$ ÿ[ßÂø©Ô¥mµHŒyBÌJ_g+‡<H¸§kFJH‘òJw­&ɉѱàÏ8 0 P IDýKcwæÏE ÌÔëᤶ¯2 AnC<®o¹ÙòÁÀKìã›d¢õªûŸ°cêDÒ`žŸ[þ_f´Ù«ìVÕkÂÂCC@Z^ÿ‚]˜Ê45‹Œeë!ZPœÕZ+fìJ’f‘ý½PLjtÜ4R&9«Uj€ËÌÇG¼Aßb�{è=ÍÔcù“zV+’jlý“Ÿ´Ç„ l˳üÊ8GOÃÌËúJ¡PÙ-+fÜ”l£k¹ñýe_kÛÕíÜCÞ-2kWãÅ^e35¬¥Êmå�«ôÆÆTL„zþª±z²@…i¬ô$:+âŒdÑò”TvH5n1÷ÏGm½ @ ÂÄePG_ÃÄX_}È,äµ|wäûeð1ÎzCQkGë‘áo99Þ»zC¥7Ʋ‹¨À:[r*Å 2\!s l¢ÿÊØ#‰Ì¨<²z(�ä«û`MñóÀÉSß³Kš§à#rLmÅáújäÿÖP8à@ãA¬jsFd•çØ~¬FÆ›ÃëêDø? ÇÈ7VŽ-H&c•”þš¦]û—Ây’z}SIM--Íêd>93YJ}æà v¨’›O†¾Òt”©wŸïoeaŒ¡èCÿc‹Ð6�ˆ …=%#'»GW¹1ìãÓeúÚ5¨?ãÉß!¸<wm±eÚÙ÷Eé/k±žh‘ÒŸ±ÍbO,‘ÑtëyaCÃ^�mE)ËäeÞ»?iyåz2¨bM&ŠdÞ›£¬ƒŽƒÎˆ^·^`«"ÕûX©Üæòny«>bKeTÍÎ{ɾcI²Z¹ÉJ$¨-zÈß½v‚aY‚àìÖzVüµc×Qd´šû>‚‹‚w'ªb>ꪡ4‡ÂOsÙlÆ %;#•‘T:^ÿ¼=S€oûê—«¢õâ”Ê‚Õ¬Ö¬[²Í{.²Ÿ²@³Ôw›¡ìk¦#¯líd ÓPŠí =N‡½ÿ/? ÍvÝêXa}’{G ÜéGMíuÅmæ.·MÙèGÆ߆]wƒ¯´cÜÂ/O_9ÕZ6m_qFÆ…Þ?Y¡°(‹4ÿi{ub·Ê/48ÂÈ;YXâ£éáø³õ¶’hò|L¿N•ìF*Ÿ(ÁôeÓ‰q ´ Èw©Å¨Ë†ŸšB‡±É¡+4Ú=ߟe}|®zn¼àÍm¼JFmàyv:®Ä®ú½ZöéºÒÆ}T{‡™çºÁ¬÷õ¸ ÊO]Vè_Sù6N|J¬µƒ ÍÕëʆ¦â…±Âž¾è®äΤ(PÚ–ámì+–˜s’µe7Ÿ-&÷ÈÊŠaÐØ›³Š¤Ë¼7V‰Í]-,'²Íª< ‹úu¼z åôat­¶®0f>ª“AŸ<OÃ"·¡¨ [ºE1ÏYU±Ú³z'Ÿ§HœøP–ÓT^xïB“Eþ£f ógוù}?OÜ©¸;.ë‘žZéëžÎVeÆÚØàX±‰Áwô'*w>5=‹Ë*0¼p3ÁBëO P;ýù¥êÒ  ½cô§+!x¾AÜ7Ž–lfb­å1’QÑ9è^åÌéøO¿czêhÍ1†MU«ï÷%}&Ú[’c^ýèM{óÕ‚*VЧÌhUjÕÔŸŽ;¯;;0J]ž±\ÄÓÔ¿©GÓ#}Üú­­ÝÒŸ/_j1~uûµ/ˆá<ê@0‚1¢Üfpe.Û~¢õÀM()Øýˇì}«< Ï„ÐÇH*Ͳ+©k• . Ûp€,Õ¾íűëL_ãb~¼UŸ Ãr^>¥@½Uì6D8:²¥'�å¿”§©çã›á¸; RÙxô\/7pÒ|ióæuYŠ†eêãú`9Bö¡ê­ìÞ€<Í®/×°éwûc;t‡ö©üPR.ÐèŒd—¬I?/JC&öÿÈ&+ Ó+`_²gU)<õðÝÓ ŒøˆÞ‹WÃWGôÕäØèf*/Ú´Ïïó‘hæsM«ùi|frv–Æ?sÒš\@©…-p¬-ê3gK JJ•³ Ù(2�Tô£1s²¬ue¬äÍ맯°\ m™ ê¯Ñîˆy›Ã·Óu=AÍW¾³ç - Èä ³%kQM—­;Òµ,xk»ñI–ØtŽT»û¦¯ÞŒê°Ã‘�ð^³0iyjc›gŒ ñ©šnTänßGb-‰öÝyö¼°d›¬¢äOãX{+%b­… NªZ„&hjñ©?õÖ zßKÜÚqéÏ+…Áôí¶ZÓ8íz<+´‡Üm«Ò’ê9­ç›Õ3<X¸Ê® óÔýñœ&iï,Ðœïjje íaÆ5ÐAiªA‘eýè‹> ˆ$A°Ô»r[Cs¸Â›Üñ9® ‹î† Ã( >M‡°* ÷¥.v ‹ÑƒH‚üSñ8ÎÄ;£]à ÁÉS}Tsp_éÃ:%` ð)~U ¼g¥EË^YaæM¿:O)ßeZF[SÝXÍžŒ"Œ‘‡Áyƒ1ÙdkÊb¿T,ÉøYc7˜_sV!×þÜáÑã¦'^0H§x5W*Mßa€-ÁåC¤¤ø'*´/}.d…Ó}{wü鞹ᣯk@ý´âƒ³±]í\ÛJlÞ¹ZXȘʉ!u“ÒΨ½FJW]|ŸÛ,ëqºUª{fÌ*Û¡`ý^'¨ý{מí~æ¬B¯ÍŽÖ�±?­Æól•.�Ïu ¯k¯`MÕKƒ†Ž6c'{i¿w½¾qÐ;7aâ›»ó¯ ÏA<ŸìøÙ´°#ÝÅ×jkþ=VOe¾|-”ØÙ wž r{`ÿ/ƒ®I`Àí“þn±ºb£3"?ùÔµ(X'ÉkÂ=ÇäÛ:Jz,�¿”ø†ã/‡°Û°«ëd°!ôô¦™‚º=}ÓÚÚõ&A7Vi&jj”$¹ã±2 ½Ë ßhõ-§4º5è‘X*^ˆ€í¢ƒýAç6{áb¡Iv¾ðjÝmYþÄ#áÔ“ø¢?»îè;9¦X•Õð¸ÊËFþyˆíÈSŸ.äÈžÞîl¾W¬mÊPõ¯èO·ëî•5ÔÍŒ6½(Ô–A—Toê½È9Èù…ÚÞ¹»”΢–Ckê'D:Øö«ï9çJ¹Û£§;·,úFas êåž±nzbåεz¤ªn£}³±;4­!ƒüCI’LÆÃà“àÖ×~}»‹c[²ˆ°2¥Iy56©Æ@Ó?¿‚'Ò)‘ÕêåLÊrºÉ£º ŽÚÓjs)èù°¯9zË >I}½mXÅ€ƒ·ßžIõº7 ›A©Rxä?p¯€{4ŒÇx1I sdž€ƒúD±Á›r«•¾r×þ;zÆÝü†Bw+-Ý<É–òðëßck4,$KvÜn­]ÆÓ¶¾˜¯Ãþy•ˆ*nÔÖ½í×p8÷š­¡q¢bïú~¸ ­WU¦’Ì0ò€æ®Ó¤²¦‡Ûª¼[ +])ÑÛ¯åäƒõ$õ½¡U–«kË9zì‰u\öÍdÔsæY26½„ô™äU›)C¬ÄyØZy'À„€<eµliS­IÕ{"., (ο±˜|F ª¾tOô¿ù½÷ì§k—x¡\Ò+jÀÆ’^±AhïOžQ¡}à®®3‡ÈŠ¥¥¦ô®áü×j�Çe$0;¶ýŽÿûh™çä‹Cp¦ÓI>Å ‡xí`¦‚$}kêš™A<ŠågïØ'ÛÝT3kÖÖL¯¥(£Øë|syú¢œ5)‡<Ížìvжƒü‰4ºèXûò®„±úÁ§f�)›ôóÓ3.€Ü…¤"ìü{WņîØáÔÜS°‰Ò…\m*cì¨ ´Úª± Œíü x)€¬O‡Í…‰³Û6|ú”ÉÔ™’[ŠñJâç,›*¨E~i÷æ0||Ž‹ÄL ÉÂ�<1‰ae¨¦ãCM±ÌdlU/ý\{ó2Ð/ü/“:{R,}*ºª0 ²cçT®(Ôº<mfS¯‡‰r²Z$ƒ žìé=ÓYñˆÔ†c¯Uøº%‘f©/›ByÅ€¨S `m<…¹û²P¯ìÂL·™å‡-å&hÙ\Wód[†¼Ì fC—) €“Œ«ý•z,É\ÌgS* Ïs& wq—ŠOpyæãMWQ0a÷ –(#Öta†Ëa<ו*c¿Vzu¤Ðd 5(ç‹F‹9gquè™êë#4y¾òOlúòcG÷ŒâØú$Âc[&(kJ¤MáOV€ñA9õÚx̃h*èl¨#ðjŸ ŒÁ·P!¾ïf‰ëŠõ)Œ½1ò<!¥QhãËõnnÛ8± Z„¥ÉB÷_E¢f€‘a«O•ðþQ¸IKâ'äš<òÄûKž i“¤SåÑ Kõ³ðש*ƒît»C—”²Ì-l»*G¾¸tZ€!ÛËØä5¿7ó�Ìâèñ@7"ûe5o7Áº’Øo6õa‹ olé4[þpÇ¡=TWÓCsiî·Ú…`êM3¸½cÎ2Þ3{ú»¼\Þ "v~ž½#æò½L@ ÄÅ+®o½'ì…RT8ˆ×åA3 ¯ôÇñ<w¿+LDÌS}çoÝG ³ä–Fôùi[Q`dO=3Ù·Z¹7ÎlÄŽ¯–(ê<=±‰‡žRÏÑw6y§»B'Å€üÊÂÚu ¶Ï´Mƒ¤ú£ór:ÏçêÒ4–ÒqN9Åf†ßîkjº@>ßý¥o¤Î@x?|ÑŸŒ?g¯Û¾¯¶Ç€GÏ;ªñ¨öuƒà×#bÛþ4§f4à:õ7’ÄÜ\lÍ4ƒ;ãCr59Ó6ݽæÔ°¿ÈÕÂÌóEÑÝ·È~:BQ Ì[Wõ»Mõýd "ò–©s¿]¥A?%A4¼ù }gl1g?íÃ9€:ã•oéÂÀTe£"Ï`Ëí~»çÓ÷²Î¨‘áÛ[3B¶@Úî�Y— þ¹ÀàxõØ¡Æã"£ãpà‰Í­‡„תç,s=Bç—ÛŸgs›ãpꧧ j5 TƇ­Ñ»(­ïYˆGV]¸àõM™î¨ÒàÈeêoN:ÏSÊ8y7í«Ó°–š”mU?ÉPáêõºH³eŽÞrÒCÌÇõið&€ô7ìDâõaŸuùpeH@ ¨¶ÅVúyÆ-œÁ×µ˜ÖT¡°u–™ˆ.žÞ_™²Á2ÓÂTÔTW§ÉúuðîÛêv<%U_TUf ÷4DzÒkøpqu9ÐMêƤ„9�K§Þè»r; lT#˜Ò ¡ß”Ž*ПZ> ÙVÒSnîøCÛH+À‰x$Ý› ’ßš'¢VWN$ãáoE2G¸¹–Wj̬"®§Sßãü3Öž‘ºxу´ÌS01ƒ:²¹±*³Að¹«Í3•X  ‰åOwŽ"2L¤Üøn5mNéÒñäAh7‡oX… .§Ã�˜KÍwª|+lT¸B˜IÇAb§÷sÐÓ¬/?1“.<+&Ñôm°öäÔzä‰€«WרK®´zè†É ‡x€,¶öÑö»?UÝÎÁÎƺ‹vlÏ(?—•µw¬ß!Ô×?]p?T_ÂH6¨<˜@ýùa EÄlËålèN'ƒâÌ�sE¥;‚lŠ{—O૧ÅÆ£*È:k†S»m‡õÅ#Ÿü ÏEÏ )a¥›B@÷ÇC+³^Ðت5º'‚ýT;IºKÌÖ¡ƒ"›´UÀ‚Ûȹ6¢É¼¶5ÆF„ þFp$‹µ(ÊeÇ?#•„FËn° 3„ƒ¶ÖoZ÷¦%Œÿ!~4÷ØcKól £9{JøS‡þAa¢ó”RöÅûœóØÒ7Ó¤íyêÙ·­‚îõd‹_‹Ì9"¹ ¥3ÀÍä¿¡„ŽÈ…—ÓyžP%øÇé´P øpZ@{ʱY}Ó»’I‚çb&äÁ3#5ÔÓ–HF«ÿ5×óÊz] Zñœwv(×· öZqnÊŸ`Q‰¡Ðqb¸¯R}Q”V³¾«ýi³i¿X‡’œ]ôœlU‚”ÊW3\@YÛ»¸0M¸ AE onqa\ùóÈ]Áe1õÄÿ*ó|[øfGˆ§ÕÊ(dàßËøoWm,‘h=žö V«yÚº¢›Î&ôþ%³ÌìH¶@0Ϧ/ÙÞ®v¢iß²'Ò—õ(Ÿ;« QÓ…ž^4^uQZ,7ב~,§–™/D–M6j&‹(d#ØnÛ…~ÃÕ$KRßdð1 ò±uª',Âj­ìRÑó¤Ø~L9Po£—ÅP¿šÀqŠÇÇZ5Ì2C°¾á‡^±ù?À»,PÚ¸9:V»êÎÂã*Á{3kHWŸ(±O]{Ä©£ÝªÈÓ `p@wL¨ÖýåU_S7žjqQR^9í6T³³(aÚë‡N>¥oä µÅ¶ ²qëcõñ ù6{“ÌÇ3Í,[¨»ÒΠä.ì:“&eÂZ ²–©ræÂÙ#U<±@óË)×Ä:ÂîVBÁ¾4µ€ˆÀÏn-ó°0j½‰Ë`Õ*Úƒ³§|+¦È›MS}¬/&ÀÕfsïWžïŠnÔ9àɃµÓn¬Ö’¶Äê–§ÌÆÖ ãôh îúOÚcT¿ùÜ6d‡"(+mĦ|« ðöè.è®~ê*Jú—¡Ìk³8ÿ¾…Ó¥÷ò{d*sµë?DÙw_íqŸtW*]ø�tH,O±' "êXV©àèÑ>màX ¨ûÃœhûˆ7uRÌjBTPÓÄ&Š?þý âú­åwÕø¿Ã;œÇgJ”z‰NÆý펨ma«Týùâ@Ø™<xØÊ-·)Iiü7¶'Ê“£Z\%{Ûíô!ÂçœÜš�È-|÷ —̱k¿îˆá·fì‰Ápzm›qï07ò…C*¤¢N[êX¯‡ Ák‘ßv)Y¥·Gá<n<—74¶,d<4Íð¼çXÊÙ»YþM¦ž…4ÅŒº¢“ÖrÛò#1Ù4<¬Ãq…§:V sÍL†g& EèXïéè÷cSÃWŸú˶ªF«Ê‹ZvœT* ‘eºùYñ›«ÈºFcíwäMÜ(D(C€ûtA˜Úrò:,4ûÖØbaL£×ª\ŒÔXR1ÄœîÓ£bAF±÷Õºšƒªw¡¼¢Œ`ÓÆ öjy°jFöÎÎÿ' 8«2~:,Þô¢ÇÉšÀš> Ñ3¦Ü¨ùå9Ø:9�)íëˋ•vV Û^7î«(È6BB¶ŸÚ¶,ñÌR|TYs«äªv¸©"ß!•á¾,Îy´«6ÌHÓVçL#7WgÁÝ´ÆÕwk�Oè´‰X5ß"Œaína5’sÕpocÖƒÜkD,ñ EäH¡2QgºéçÉÊ|;‰™Ò=&ŠL~ó½£?Få%ý×´Ÿ¨W¼1_¥@¡A{|®Ë§mD5¦õfߨFÏ£Ýí%þ½Šqë´ôÜÒ“•4Ìyf)Ö‡-ÿC ¼‰#F ½Áþ⚬F·Gqh,2ó&ÇÔÊJ®Bc9ÐÉÇ_ž• ý&FKª!Úšt£Mvo õTvÆ`à–™[Çù•ñEœ0É„#²ü%úH»u Œ cóÕ,AVõygÓLïr1ìZ9ž(¯aÙ–ðt!”ÎÄšQ$¥×%ü"<‹çû‹áOʈÕBž^eþRŒ0‰£q¨Ò‚RGp<›y¨½¸ë;—8(¦ˆ|Öe¤¿Ž¦×- Ér½6íú«uSj@ŒØ`slž »‹+Qÿ'qš™c–yj-‡Û_æ;x¦ma©82 �è}[Š¹÷2ªW#O;æ`Ï„R=ïÕÆxl¿yŽJ™}Õ0Tz¢ÓÞfÔÈŒeh~篃2õ¥¨ÂAœ³^©%LˆpùÓ·<õgåï²°É!¸‘±"­É3ÏRÕTTEP¤²:/7¬¸Vdž=€{‰smÅ™ÇÈ3«½ OÕRzƒ± @>i‡ÐzM,½JåÐÚÇrçâ še‹mHoQ uCàJJVo²bùQ†² _‚hB}‘Àφޭ¯=kƒãÎR{Öf&¦¯ÏmrG‘‚µ/‚xšt±ÄRA` ˆÏ-Üe^*²§ñÊwà0î¶Ã%Ýåù2N¼á>8æ'è´î¬!“‘² ´ÉV_%l¯Oz¿çáÇÒZ­ÌûêàéÂü£ ºo*è<ì­dŽ,Ö'ð©®í7oŒÆÑ‘ñ_ùhCÞZZbn*bsªëLøenŠ±¤IÇR´“š*Mçõf�pæ%håŸO?-À:ÌLÖ͇}ñ¨rô?¤MNbgU@diÊ‚ìÛjâ…Tï†Fm"E¹—Sy:H||›~[€Þ¶(èDµŽ`J`ÛZ¤²¶«²¯`!7î™ü`¯–ô¦cO÷jTÔ>l zh°Ï³t…"÷æÇNÒyºµ*1¦;ÔzMq¾™.Árê­Þº»þ= º) È)óyƒFÊ0Úô)¶(eeC‰à\ÿò±ËaáÑ1C³; óÕ›«ÝÇmý‚üMྺt:/¬&šÏŠ€«O¥ç0x=>Ûhj¡ à}éûx—ãi.{Jœ^D¥Þdé–l-.å ³îô?6ðG¦#‘‡•dÕãmŸiguÓT·,˜ªÖ`Û°'<~;)ú!(:Š 5˜ÈP -‚»ÄÌÇs†N(K&à Ûj7L:x\üð”#ú€ãDP°€äm=¤G2_~í XÆ B{ m?›¾€¡’¿Ì«=IõG×·zD+3“:öÐZ¯µU‰ ‡>g„Ä$§)‹üÊ÷?hàŸ5„Ï|,9mìeŶ‚\<}dí°!ZÕ>Ûò'Ÿ;ò´F¤Þ Qv½'VÓ6^+�-Ufäàü†–—ÕÞ*Ô“ ȯYïMÉ(Úê3ÎN^0oྡྷdi‘áÆÄs<°Ö„cr 9`p.îÂNb–·åÎ}²s°I¬Ñ·%Ët8,ÅÖèO{Ž‰Ó3øàsrÎE3åFžC…ƒÄ…aÏ�›Øîan!¦ç‰ˆmŒ±íÕ (™!8ášÔ—>£ÛO»hõéÔ2ùkæìÇ}~…b­°¨9¬Ps6wªYÒE @6Öié'‡²'Ã'€eþ3ûgB Q¯ˆçX¼KðÒ›-/|ÅêÄF©Iî‘Œ¥ÕОyGߣ8ì£Ì7Šü´Ë6[Sv�Ó-Òg²Öûîp•7Peu!´òÔý,IþÛÌžó ®U#=W«?é™÷íºë¡´H‘{‚–Ìðïäb£Ôq„!ÆÊ2 #)gÐù]'Œ ©ItŽ'ÁB-{ìܵ¥YW‚«6æ¯Ä+ÈêÙI5yË'^•©g#%ASAbÅ3Ès8[ñ*:=…eÚTRÒÊÝFõåzÉ6îr ¶»¿3¦¹«V¨¤ Çé=?³Ÿ°ÔB'±ÂÂÙÂÏE(Æ$2؋ÉcbòS•õÒS)e7†õ&¦ÊÝV0ÇA÷Å0seL¸®Îý]}§ «ð—é@7$nþx¸ŽªŸwkÅ÷ÆÿÔ7Ñ}`PK¶°[EŒ^ϦJSf觕Ð=ðúS»?XÉ€Ö\×hÀ}jƇ=â¡7¬ã‚Ž[d?œÓ&™ë-ò_dX<µ^¿¯ŽçUo˜÷¯¶xî¸Df¾ò ÆsÚñ¿../ž¾vG60¬(?Ãt‹-¡õbyd‡®Ñ³2f—\]G•BZkÈþÈ WÚbF“<‘q?}¾Ë›¥u¹ºR\<ÿ†öÜ`I§Ð%ï*QÓ`Pï„s÷•zjN ù$ÁöŒƒýüÓ±]Ïãi¯S*±¥AëŨÂhÓ•½3õÅ«¡×ôŽÕ"öB÷8x:møÈZ"ÒiÏƾô‘Œw±ò«œâ˜Œjp¥Ž†bu^ÉD¹»Ë!«ïnálÿKïr^°| ¦ÐÖ_n®×ÚV…Þ{’{«%¤±IQõN\�£ªùp”ˆÉþøõrdbúTœ/s¤›”ÉòFxa<šÎï!) ³OVZ”ÎÃ[™¥¶–X‘e¢)}k)ÿêÇ¡Ót¸ˆ¯b5JóÜÈH?WL(b‹ ¹9Q–Q4­õl(ÃøWOÁ¶2š½êÑi'»¹hc,à} ª@o£È5ó„Ïà'He`Ÿ°¦BÏ_¯DÄk˜cDŸ´;¥A²Õ( V“—üw b¾¾¤À°®�à¼ñúºgôún¨ìa¿†‚éÔß½pŽ®ÞfeŒ}ˆïóË&±”" éÜ¥d_Á~?pttÜÒˆYÁ¯ºÜœ=/f‡æî‡g&ÕÙ•4–"Ûc–R¤X,üYB?±T —¶2žAØËÖU„v_‹Ë½Ô‡?8¹Ò% �‡ $ý¦s5¸øt ¼tÁþÜïfE?Çy{žÊ øU«_$åŽu«Zêtv™£+‘ÏÈû˜Ò9CÉxAaIK'„\ˆŠ¶,È[µ‘í¢uk+Ï}ó2Oö„Qàå%Éñ—'FeiÕ¼óœ‰^k‡„^òÆx::ò†3³vÎK€‡J•R jOGÐâZÍ6ÅÝPóì‡'ûJHd…´$“fvtq¡»l¨JÓÆðíD†aìŽPö9©':îÊY3j¶ü¥'y,Ÿ\´þNGª²ö•mtÛ"ãêG'˜k2º(è{8.^6Ͷ»Ã—Ù|Tóeð®¨(®i=+0ÀûÁw=]™›Ý¿Óar ݆N3@+¦È0S÷Ò�<C³Ø ’`ÖC§C~ÚzÃnʸ„Ÿ;´¾= TÃOŠN»÷»ƒ0MO É ßTM{ÂH&M:îÚµÙ È¡õ‹~"¥zk‹»'öC!ÈúÚPŒ:èý- Œ½ß™¿À{‚¿ˆ^ Ü™LkÝ]Z¥M‰±œbL1ŽJ? ø]KýYm·Ö=. ôO!G+'ìðMK@Hⴶ互8Hfå/I·S|p²¢Î’Å t;-¡zýÕÆÑÞ¨ejµß°··ê°°h§o3ÐÀL¤ã¨Êëiû/-ÖÒ|A½¡ÔdÛÇAd­‡À’\·›aQP 9‘ Ü<鎧¬§±. ¬“$È-× ‚z0²B«G¡Sý½SŒ%p+n}>Ó¹e… ’‹X+ûžÁ þå{ª‡º•Êâa`Ò:?–½".;1</#`•'ÜÕm6Ÿ%î‹11sB_8>N^§œŽ˜Í#M÷‡2†°«Âu+ö¿()²„R(Û1ÿ1cÍYž‰Þ²ßq"h/n}lSßž˜Œl´m‡6í,Ã_kˆGÉ5ÄY)”í6››WÔdØV)ž¶›}mÿ.AR 'Vf§ÛÄím¿¯(+m–%ˆÖ7­úÐIåáÁ?¹õx¯©¸d½a ^éê?–7“Ô7¦J‚:Kƒ¢»˜Ä.æ Ü+«/‡A1Ö0Ë',~xÈꈲÄYÄ2`áÜÀk­:;Q<‰õ̳ç(ײsÞÔÈcÁ;X³b¡|sI› Q‚ˆÍ×&Vž7er[±{ãaͦË+”�&$"ˆÚ6„C„¿§1 Ò¶õÔ†FvÞ¬”:Ì}ZNo½ËkîAR¬®@Í€ ¥×B±á4çŠ/{ÖU k[¹UuEçìÜÓ-½ÝÃTÓ$©š:P³œlF»82™Ü§\Û7“fó?RÐH ×Ëä\˜yÐEÝ8SäÞ<w´r½˜†y èûð”h!ˆA ÂñE ‘ôÎ}{$Jð~ëØS®p‡þTÌ̺íUÍ82šG«Sö®ôoî5•¹bã¤.:j[ ‡,=æß­D¾ç‰Ü"¥‹]?6æaØ–¨œò^ãQˆ<YZM¿[h‹³üÔ…ñ;óaÜTí`_Ãÿ© ‹ˆ+Ðâ™ð®“‰Ih:ëtÖ¯ÑõÞ½ÈJ W!’…:³zÔOõÙÞÍ:ÃÈ»9ëêC©jlœ:“¤M�»þ}öaY¸•˜²×á–N•d«ÃÌ4fñS?5,€òòïnø׶ÏöÑBÄ™œâØÒùƒë£Í;VΙ[æ›yÑìu` ½V£7ƒõo)ZMÏHmøÊ{£³×x£ØkmM«Ÿ² ´–@1Õã ®yÐýAx~ Uÿg+¿ÃJ÷rÀNÓ+›5q* h¿ûfRZØã|¹iNÜ·¯¤ÚL<ÕY°j,æ*66-SeõÜŪÑоÌU[õ÷ÑÃÜWð¢\mΚ/  =)==Þî"QŸR$1}CûLä kUQþâØbì•îë¬ó¿lûø1W}}˜ïüÆãÀŠ]¸áA>QÅ&ëÃôeøçtŒ4bĉgä¾Úq„æ¡7=‹qÏž'º)ÇÆâª*Æzp™¼È™Gk x›ÚH~<y¶–C¿âíOYøz,ÀZö9ŒÀ'ôȬl…È+±¾<dçd‰of c˜Èž=Öõ‡oeÛoéA•eêy °ûe•¦¯‹iÏcv¡sVá§?¢©/«Wd_0hš=Ç£`Ãù «þþÀWJ¡ºq¢[á°T¥.uSr °Ï„C}¤Åú@QÉ65a¾ `<3IL_]€ÎÂ#…¦�+ÂY’™»´‚6‘ï†�¢<(& /FŸ¼Ý£I3YÝxm¶¿<âdå×Bco ^÷dWÆŠAñû¶×Ë&¸†µ¶Hwo’_… Ru9ZÍèXß„*òʺOx�H{¯^‘Þ¦>D9ät-È,®«ÔC ½øÉÈ]ÿ‰þ•E ýx`û‹ ü¼hìJdN$n¥JÍf¡"†½õûB•™A¤œáå²9É�9?Œ4.ó:Y'”Ié/Yñ׎…jL2° Nf+ö8­ûÞÍuߌ.áÊÃNóÁGYFFy¢gçËGé5}í¸¯Î]v;£ü=X÷*ƒÐkÍ2�c2M´­MŸ ;wªö§VïÆW»—n²°‰ Rqa"¶°ÌÌ@+´¯ “ñù+ëùS·lÁâH¯h™]¥r™ç†«Ø«6NŽþëÇ\˜ùmä$ó‡™< ýö»°'¼ÎøýÓûÕ8È’…À躠�­HãœÅµ¾ZÆWúÆÖïx\3°\½,fÔ]I·N‡YÎ4Z<¬R*^ üdåçÚ×-(L69´Y¬ìiÈŒÂÝd0ùà†tÈ€€ªXâf>”zÚBÈá3ôEJ¯œd9jÔvbhråü÷H]4³k?ÕäéL'WÞ=ÙÜú€Vºg)Ñ—Pü, ú |ófKT¤‹?™J©“9‘P^êµ3ÙÑåì½{V:%Ó Áa;×cuÞœF Rø,ÿ¥Ÿ;kTt4q|é"†<«S„ÈežÖõð^þÀË Ø"±^ñÌ|·¥šÈÞÊ, |P” Ù t‡ Ói¸yJEî%%²™y žÕµíõK=IânŸÕE{©݃÷dâãtå WGA×äAjÝJ1pÑ6š}}µC u7£¸kKnŒ‘wÕܨŸMúe¿uºǾšç UA¬ê¡Ò]†¾g€Î•skø¿(÷©‘”D6 C8—eN™,äÊÐxÃN3õ÷pYy|eÐ lSëØ.dëÜ᣻lÆKCßlÝ5—Ṇ³×[åÏy@'çsëŒ-¥Ù®DówX´áÿÒÜ×!÷è@q¶øeiÙP$™)‹ì[Oøÿž}ð} œ“Ï lx•b«ãs0Aψ·h.R)vä ¾€zy8ß¡7'©ï´$ å\ùñlâ @Ýè.‚ÖÅ@ôm½"ŒRgÖE™ÅîÓþü¬3KÝçlP?E•Íˆ>ÚfBED¥í¡ äè«Òs<yè=T:ÃYÛsxH¶5KÇEœºZÓä_ùILX„éØXOúóÚÃòB¬†©6õïO§ÇØP‘ÃUppv²=«2,»×Ø¡'¥ˆÃgÀR5šù”í LEé0¿\ÊøûìI ÒÚêkþ„NiY¬RgÓb)¡Ôª ³xÊ®oÍãHnûØ^6K ݲe Ø7Ð*=öiÚ|G$k÷T ›kùPvR÷ðË>„ ¥mÄCãÆhøàT4Zªß&ßÿi®ö®`{‡>F ¤aI1ÐtŸÊY;n”/É,a2 TI”n¥G^‹dÞÀáõÌ>…<ÁÍ/_�9Á®ušê ¼rÇ¡éýBf-FC$ßô:÷×Ê–¥ÓfpÓ@[Ôþ¨ºÍB¨FpØMÎVúžûŠ5‚ÍœíÆ^÷ærÒ,Dš¯›cx9t>8àTTçuk9T¼©d—)^T&•1!~04W¯7A8_]Ù™N‘'«d”ÔÎ8ÿùÈb|(.§Š—éG£‡¸X*9Ñ‘r̘ú$¡ 0¡˜¿‹Äø‘3sØ^¬a+Maóβ £ÅÌ@‰Û‘ÙÙk[‘’#KõÀà®}ßæÞÒÑ QG›}lxbMÈ6fsÌ–¬MKYññä¥ÿx¨Óšò=‹ƒô 3ú·â¨áQLxv¤éàŒäõƒ{$æ‡Wæ$[ôüJ“ =ZëLŒÃ+vLÁ™J”ƒèÍ€#ÂóÄ„ñ»E™GîΙ]¼¡¿þš<"0ÚÖ]ë9>œ‡g^UQ0êÚã¿´)Ÿ&|ê[›ÉþDxÜgÿ#…Å|…JˆÚÒ1q4òÏ·Ákwx—Û–kÿ;eAHFÈ:Ò?éÉÊQæ``¸H5`wR Èþ0Èáqs!ï¼ü‰¶w¸ZQ ¬µ“ø?ÀŒ³rÀ½ÃaÈáž°ŽÅª–CÝP8.~ ίg’¤OƆ]%…èb¡a¼=r·N< Æ\g ¹%7‚,ŽW:¸ÒßÍBxý¹¯ù¢?©“ÛªÖöPWýiu€«ÐCñj3K¾£/%ë䥗›…7ÆgªâSD³äs†ORÍèI£<0‚.hÐ ·—:L[þŒ ¡¶GRd U¡Èo>Õ²#chØA»^ýnúj+–Z¹GË&«¥Œ.,x5¦ÝYJýhhç颷,g]Ù2Ÿˆ+VñÇÛæ-(™¦gzˆÅh O�{ZK‚T±À>Ú{~ÍÍÿ™Øwá០ô¯JK«‰Ÿùú4þ~. øL/ÎÒ¸Kc[°=Ñæ[u¶‰fG=†’q—.┲E›Œrή‰ÙïZGF,o]AhKñò^Ñÿn Tm\¡.¬úÌ© ÚLK’•H°xéG©çŠƒ*v0¡®lx3žâFŽÇjaCýßú"ý¬«Ÿ«æ4^KÊ…Î%lR˜¤<:uGÿÝjœô¼ÒUó G$ÜèǺš Õú4u*¾þS‹ÙÕ‚¼3 x´ÇÝlõœÑ¾l¿AØuç€Z#ÞµHL —¨f,[ …زW‰5–ß9WÜP5$nÁÈôô}U2ñ0ø˜Lº?³Own)+þØTgeÀRH¤;6ëóõñ šÄš/©*8Ô/ a™ÿR•-Q‡Ì|`Ò/µ“8PDÒ‘#–)SÝÒó}[|¡¢G9ÅÌÂœƒˆ'˜ Æ/†ÍÏ~’28ÕÁÙ|?Aåºÿö¼MÖcµÝZnÕaœ;ùB«Ï¶ÀÓÁí –Λðx ¹|ì[k¸)ÂgùBH‡Toÿ©Ö‚ꙋtô èß<X9wH-pí~„žy¥ ˜Ò“0ƒr‘üÌ”h'MQÀašûM­U(xPVJÅá3VâYãŽ{ëËk·bká·â‡ }O°'MO!ÞÇ›j7b-§ÝÔïŽöÕ-„;E[îK1Pßã ÏÚ§ ƒÁÌGÕp„PaÎSUXçý›‡þW¯Þcf¦2örGÃþYMÇö®ÒØОï*·&žœ�›}ÁQX5–0)½ÆoÌÕïH|º+!- Ý® ¯l³¾‚Ͳz—GÆ[‚Su“÷Ð5@æ4ÇTK‚³ã`å«…ûb-“•‘®SXKW è~ºB¤EQ{—wTL’ÐÕ§·ª€²ÿŸBd_™”#¹Ñ¼ô:ô5Øù/„ñÔ5ÄÐk(]¯‹ 6#÷BG’¯e¾9œzc·Îh.€wúk{åråë,¡g§,Ûm¼rÀ§ÁÆ1­‘}u¤½ú¶£p‚UhÕ'èp:ôTX<&‘ûÝ0ôÎßJüT¬ L<›‡0–.š>=5$.y…PqÒqÈO�u6´)†ÅC!çt¼xtç{fMR1,fþÍ/ÚÞÒ¿5¹KR÷' L{:mi³¥dúzT†áê(P)y¹Xù¬&(Š2†"<J¢Ñ7ç„E€S3ʧh˜ÈGDÈK§> ŠÏɯʄz-Lï8T¦·4Dև×3„(6ÔCq#ùÃ}éW¿Æ9qøAš˜.ÐÐé”T¤½`„w‰�ð8oÎ3cÈÙô»:Ïý¹Æ“ 8­¿<™»ì ­4Ýðÿ4 WqêûÚ¬WNk¶»ÞoéÅÞÀ=‘º;Ö(ΟÜ@0êŽ>óêÒuóJwV³… q³ñôîÕ—óöü9l@VâBëŽ TN£{íq:(2ýµ{Š²#΂’°<H>G牷íÛ¦;œ%»°pg XêÌ"sQQ¼øõéáçhíKö¬Â9Pæ3ðz¹zS>õÍ«H$Õ?5§0Aì¶ááVRÝP÷u9¹µBOg�‘ܲûîÉ1†J„ºä@VGŠD=†MΧK»$VAN‚xܘ†q&»eþÌh2žŒ1ãåç2Q™çÍʽ E)#ÃÌÔÓPëé½Ðç�ñõaþq¬‰¢ŒþŸÃË'Á¸§t÷W£%A(wë[Êx©ÏcËáЦ\™13ÞÇqõ¿ì \aÝ iGêalqþgå~Ü?-ËÐA¶2D¯æËùðé0$uÛv»ßVâ| ‚“Âcg]Q¤ÅKd'mYž7^­×¸z2¿Y<?š¸YƒIé~× T¤UçÚC³dÞFßæ}©¦4½ÆÓ¾LEägg.˜;¿Í;ÊÔ”‹D2ÂþGÁ­Ã4»i]¨™\M¥w;ü�izíôÒÌë`´²˜ß0^º´Ñч/~~•ý»‚.aÁÄ’ê$̶Ü7Š…1K³k°›Ì‹,¿¼Z–Zâ.õ¨¤Nï]Í>`·TÞþ«eéF? ãvŽdLMBàý‚ò—ÆývãýâZ†óÊòM«ÅX ]«ŽV÷qv(¡*¢c¢ÒUw¬>8Á2I‡àÛ·þ;Ž7"¦pl…ŠV^ÕžJªó]˜Žòß1úËÆ tJ`øüã±^×ÕPÙyŒ o„‡°p”%l¯Å4xZ¨B6Ÿ¥fHFùdXWV:�}j=ÃZ6(zÛC'Œs+g"¦dë:ÒÍ`©œ âRÝ6†¦~`]”þ"'Í+I¦È²c3­©$\5šk¢Üá3œfƒÀ lLÕRßó‡ÅbPFaßÒÒ«¶^³KÍrÿ <åïõ`D!ú9ʃ2s«rsnÖIÎD'¹¯Œ#·5Å`ÓûÃ&ÊÞ€©‹4ö=Å2‡EG¾½6&³ì©Ã„²±»Ü“ó4ÄÂ$õ±òTÓœa V£ú%Õ…Aq,‘Œ§-»kÓr0g]Sâ}›GD‘R&CÁ· #þ$†Ïn”À#j¼WÕYÿ!A â»Ÿó 6Rýè’àªj˜­œE ì¯Lo’Ø‚×~A:ýòº@<J5=véP|K ²¯·ìûÒã¨3–¬ý¦»±š6ÖN SƒÈâ{À;j׈XÕ®yøÞ¡—² Fws‰ƒ¢×ðZ2°ÕˆòLo’@hÍ…¶“?¶zHU{Ž“¼1;Oðciõð¦ãC´òi 0èÞ¬ÆÑêI ©ZSˆ¬ƒ½ïá}ÂÄ‘Ë�\d½F‘ÞöÔBwß2³5¸ÿ³8‡“§aapy¥NYd÷.n'—Qõ˜‚˜nÐTÑwàYãã*ÂJª†¡)Lº“/|ø 8¤f‚ÇaQº^ÿM×)‹n˜§1Ãúxó·'d©¢õ£©FM~€"–ÞMØÊÝîôŠÒ6Óån¿é…­R 4'A\쟔¤0V§ÁñÌ®ú IiUž‘!šÛ÷§§ç„–2ã÷ßµ• ”s-eW�RË¡Ûúc·DBæ7kð‘ôØ0xÃNü½Ÿ@Iç¾Ü57½X< ÚócS(ðTææ�éS-®½ÿØ$Qñ{QÀ„ÒÑ!¡0øçÛñ~ï¾|mÄÊÈT.€BpV3{ÝÏà#zìK´5'ÎÛ?f:ÈŽâã–6ÐÝ/›£+2*óà›Û_*­™‹'¥÷wäHå>BL``Q²J[1kÛ Ózú¶„ýfÇ*z”d‹sÂÕgwÛ=è[ºIÇÑËé–OÜ•w~_8ö΄X,¿Ó ûÕz ƒë8é¢Å¢aüû•_”,ÌÅAóì’"(¿µŒ/2uj€˜ž?çÝ8V½¾,Ýe½Y ¢ÏûéD°Ø˜->‡ñtVÃáÀ½°G³Ûº·tÚãHÇØ0y•Ûj|pbs⎫ÕÔ×¥³nä)ÇrƒFäÓN¿Ü³=І‘ òJ3ÍfcV,‚Ç:ïÝð8££kð.¾5_ˆ uŠè;ŒpWuëÆ"]Õx@>£I!Òs/Yüt;éb5Q£þ•·<IE ïr[uì/TÀœ˜ÃÉØÅm·_ÿ%кê÷K Íú¬pkš§<k† lòêEÕö­‰@묑Œ´õff€Ó:”^HÙššDÄ&-¡ÄÐÿÑ—Ÿ8\&/tÕ±i»+ýáz}gn-Šu;\q³ÊŠ%¯¦:º~ñó^OšÆȪšŽíkKùÐx±ìÐÝñ¨#@{ùÌîÆÙÖÆfY`hå½íèy¢\gúç#)=nÎZ§/%Ž,SÏ·ÔñÒÒdû¥qbÛÁ�*Ú|ºc¦ªf)/XÞ`bJ§Éi TPÍ÷²BëÆ"ò ¼TôÕ¾µ�PEÄÃhU f“Þ\½~À¡õ…¶Ã°´ç‘¤Ìûë@úÕks˜fÆË¿RF±7,”*OT´J;V{Ítû&oNÂØèÃñ¹�NQø¶F´”Æ-­žbª¬ 0ö‡9,(QfY`|p¼¹ä«_­Í“Ü?ÕðÑu¬Žco£¼æ‡‘uUƒÉ÷ Ûiéª!nðL-ªY5Z=Ë3š›f>æ…"¯¬¿ï;1VX.Ô‡HÁh¡¬KzÿE‡TþKEºòœ[´ë/¼«æ«ôêæ±…o¡MUÕý{¶ª”*èã°¦âQùýÆó¬­§QÍ„ÆMe¯Úßý·– %ÎœVWeՓך‡¶º…²Lõ¼¡\Kk ¾/Me”ÆJJ3ðù»‹ç™àÎÊ$ Ú!òñÓS<YS¶àäñÞf3„‘òŒ8þS¸ž+˜êZA’öü¨lÌf�lç6Ðøl´J16ͧ(¦ IÇyxÔÁÛ¿žöûÖk`t°Ý8Œ=&­¤ygp“ÍnzÄ)‹W™›‚pÛ¹ï)À­¦osó1º¼í£¹l6ãeàÆF5UÇî©Œ§øíºÕNt¸={Rñö܇G%ÂÉèÆÑÃqïÛަ颵 (}âIk@<ñ~2ÀÇn«7¾«Ö,83gT]‡¼ =mMCZ¶žô¨Î�1½wEÇ1*hÊOÚG¿…´ŠKÙ‚6Ä£'CiïK³šæŠÉæåu¤¶òð‹cýhñzhtØî¯é‹²ÎñžÖ<Õ¼Õ¼Òeã§îè”Ó/'Þd­¢lŠõ`F.£ ¸äE¢’Iká§Çˆk÷”®@³Aå² OM6ØW+D¾kè_êIÙ°¾!/Ai¤Ã¤ Ë-B†ð*„]¾oÝ~߅߇e\ør(hp'Àƒ,îüQ1DÆÄcúAñçD¬VÚ7ø Gž¼þz}¶˜¥h±æÄy„QÝ)cŸ¾’ N_ŽmõµäèXi{#Z '§åß)ev#b_Âßö² ÇÊp¿Ù÷‚Û9`”@ÿ«ë$Ý£ëˆz5,™æ$(zË-¶îÃvè~nÍ õæÂŒ „7ᄽ­(/Ÿ!ÿJVlÝj-¶¯vü?²ûúÍÃ=òZW e„éàêdé³ ÊÖÚ³!é›)ˆ()JGAb¸KñP¨»æCã òq•ç~Kƒud ½»;ŒœÛ fèaúSxí[ædõmdgÛ…CÈ\.«¤ßµŽóÂæiµ@‘RÑx<ÐÖl­ÄÝ£–âªmWÜ'^è[©´ˆ:Q&ät:{½"Êy*‹~œ¦ $8ÛÆ�³1™y3Ybš²»Võ|ö#¼dÏa±†ªò§u[Fzùë´ãg%©ò{3·˜ÎÛB¡52Ök îѨ@ÒｯäŸB ©¢ºÐgÖQ É óú„;•/dôðoéKM“×è: 6H@¨íû*ê J¬¥EÌVLƒVI±m›„)Nj¼vd:¨¯ƒtæ‹ÏðœŒNZÊyz õ•”Ù†KON¯¨Ñ”¼]õZÓr!Z_ a™åÅ& 1‘kJ¸¢}Ѥ´@)îp[®%e­UHÄ ÔÞ¹‡š›hoñcßTŒ Ï3tîòo½°¾eŠ/³tþlh3bEÅ0zHuòB¼P.û›ýžÆëýžúRÊ´ß`_öÞt¶>-ÙKÐû⎭ºÔëÛîiµ‡§³3Ž’sÕ°:_OŸ´çž9ÞšÂ'iꑆéŒm:zk‹+cÛ2Ñ=–n”q#¹ûBÁD?rfÂêt »c9L£Þp?ðŒRõScK͈”êü£—¨®±4p´?!¸ÞÝðïæ$J·¿©YCÃÿ‡ŒH$"ªKÚoH]|[2iÈlv“mÃÜáÉA²çŠBÌݹ’ËnB#èz®Š Ÿ·6¶„Í|Ïܱ]þŽyéøÛèËÒëQÐiÇÑWç1œŠÖî÷ 8i€\(ð,gls¹v³ÑÎåJÅV¦"(-¸û ©ˆ¢«5~³v-ì&’s¤@žYøX û":0ÆÂz|ºë_PØÞkø^­<7Œ[ú-ð“ò8#ˆñàFt_¸QÿÂÑÜòw…z°bJ t…B‹Ä·�!¿ð³ü /%´V˜Â ôes³õÐ,¢c!ÝÊ×HE¸@¥¢³(H&í¤`Vªyå·2–3•{£•…Í53Ç«¾¤³Ùê1àc÷}DèÄgãKQÜiQL¿EÊa¾>7ãÌËÙ·a`wg-ÜÂ{e4é¹ú½Ø”Z¤èä½1©w~µwå¼þ7F^ÈE£ °öǘï8Ëzu3ÙçÃ,4ÉòÅ„'f˜°¥’² ”Ý/ ØuâŸ=ÂÂtl{N}=lKê)ƒF҄˃¨³2˜™ÈËYG±o̽êw&ôÜ4ál*Ê4Wq`É‚lp6M¦ Sù¹ ¨Á¦æ<ZÏtCFåYÄ"0Æ‹RI‰PS©AŠ·WwÌä©–ÈTh8Dx™ZŠ_ÙvTb%ÅÄs;ZVjòU’Ó×S(1a•ðÁÐfôÎß)³£uèUÙª§¯k>û>ôÇÁ¼,òáÓ8^¿è½g/Ì T ÙFÐ_½J€AAÔC²þòËó»é!·FoLku£�ÕrëÃp¾˜}³¸”—vJyW¬¦­:†ù�XÜ·f¼€F`Õ9z‰%3€1ü_œn°ÄÓ”³c½‡ A¯»•¢QÁõÔÆÍ®„~Ôá´Ç#Â…h­îÍLÙÌóç(È-a-ÏyÇ6@2)Þ_„î]Þ –«ÐK±Ç³Åêhò»Üššv‡^Òp.lMcùï-M,ó£0S–E§°a`Þ.•/”J·¦BW"&›™Ø«ÛƒÜ7õ±y¤‡‘5Z§¢ üjÏ,_&ü6j“–álbîª&¤Nˆ•ÐYÐ<<j¶õ{°·î|CÑ<‰œISI×›4ˆçO+–�à<Ú.À#Ñ'ž…qQ”VÖŠ–ùõ‘ú�oªSÿáIÉÀ0Ê™wˆ[—e ¡{‹Å²ß™ÏæÔß—+¦™×R7°D•=q§ÈÂ0èlc²¸Ûý/8|a|%kÀö«aëâ`g¹Ñ^’qï´.žÏ=r-«‚e,iEÒ’¡å×Ö‰±ÒúÝ¢‹\}°·V BåÈ÷l‚äãø@ÜIã¦÷ À[ÞêÜ‘6§¾fFµ<ÿ�tƒn`d») ê·Ò΢nxNnˆ,Ò÷ [«…zYLÊÆÚÂ+#´p&Úz¦§Â=‚å«´Í«­!ÓÞð “"J­ëmßõœÉQ“ñ,ô¦ýÆš¬ƒnLÝWïòö ŽUà 4S˜¦MÁqµR²)Æà /XÜ>�+øÈ9œžA«Ú6›•+Œ‚ù?œi’öäYI7åošë×ëijL¯,Ië& Ê®ó0†eMŽ/fûK·7Yy¶p÷¦€Ôtqþòø„u…ÚcG3Ȫ·5 Ûâ\>LM¾ü‰n×DV #R‹öF%1Ó‰æù¾o:”dQg¶ÛB«a"'ë;‘"öOŽ‹±Å7C"v¨} ý±àUéfefÐÖ¨Þ†¨6¸Q&8ëÎÎdߟ·E¥£yaÒm†7–vtP-\)NBKó+ã w惤ÄÕGâ¥V¨LàŒ.‚›ÕñhN‹8¬ž&obF{ÞM÷yAaâŠQ÷T5–“3óa׋p)ÚtÂóÒEÓªq·kš¤píbžûp õ ü¤?íÙíòcAvxD[ç06ºÆé¹þM!:ŸU+Š]ÛX¢ˆøņM«êúÕ¶ºãÔkúÉEtæ:­à ɬÙX ÛèÞÕMYä@£Â³î¾¡:=8Ð(ŸçæœY³PE—ÛÙ¬Çgœà´ôp?,96œ)S´Pè7¶k˜¥ ¶Ãe!bçÙøÜ4U{|šÛ’9Y˘Û3Çhò ˱Ã/=r†ö,…̽++°oו ì°%*! Såä *Œà÷Ž’®ÊZ®Öí|žþ½ü»>´ÍU)’è‘£y6—6E¯…ü1š�/ªÝ–]ãšæÔWÓ£òÆê÷[àÑ<¡­l[>©Ñà„“/=ÕûÞWãôEUÈ…ÅFY¿m苘á‹p'ÞÝ_úqC\{9ËÈ‚¼Òbmª0-H=þ:ö¸¤8\jÑÒ“ˆ+ÅŽPͪá^Ò‘Æ©Ç؇CZ•åôÇ<ÿ8jÐÜÊM›ª}€ÇCft\¸,z×䤩ÅúpF7ÌÓnט¥HO˜H&Þ€jžM$îÕéåâÀ®TeÈ^ÿïæÕ¡?JcWñÃ7ì~õ&ÙDòg&¡¦@¡/FÇÆkf’;a†˜ô€‰n<¯FT8ƒŠø½ö1 £ÌïÃ$%„VŸMñ€†Ù¡*†BÄ_½oèäy_\ñ*Ȭú&&éÀ\ª! WLî}ÃîÌKGWÈfÐAi}l3æ½K×ï ݾŸKÄ™Cuˆ|{˾vµÒ1(O�¼€vÓ,È,H5 È‚‡÷ÇÛ3Ÿ­oŒ;ŽŸ©—Ö‡ì°SOE÷gœ(6ï‹é½ƒ¡ÈSo„ã~󠧫®·0ÿ}â†TS‡ ·‘¶™½X¨l„«0²7‹MžzÊùÊ­JÐAmÅ�P´ÃEËOT-Ve¾ò¢Ìb€$1ªG1ªˆ›Ê[8œ›+}Ð÷øBer…Ùï‘Ë$sçâÎ ûíón+­y¥§B±œù5æ7·p€|¡‰†S P™lò{÷¬‰f0o4ï­ts(¼ˆUÐÒ¢ÙLº\+.»ûf ¿¾l×AÿãÏÓ°Æ— ^B1Ü°*æn^ìé¼Ùœ”ÇÉ»°o.Vð@PIW¯÷90¥ ²šê)R‹,/Sâ}:õÂùÉòOJ´ÀÀsUâÀX©¢<š’ƒ&Da#éïÍÅ‚#”Å©¯þG‡¼$\®‚w¦3·e¾èµuÉ#7¯8õŠKý¼AfKÌh΂Ö=¤C”ÙÿÔW?Q¢Û ^µÝáw{ç7ª-¦Ê›‘@ãN)>è›P®49’Ø@‡)¼wlNÁvsAÈ;¹Dy¤Ìž “ 3<Ô­´zn~±¹PƼ|ûÄIÊVÎŒUo럕H(Š”­’ª~ì‰cµîÊ ÉÞg°ªŽf¹ ,žN•ßñ ^y‘y._K?OV&9“Àmì]åØ%À–„©òPØ‚Ÿýi½ãæpê'[^ øÂÑëu´õ‚}ok••ÑE:öqL ¿,™°> ˜:#ðŸÅÑ…n Ôe«Ø@>y 1j=Vƒ³¤ÑIúúKZ0zœ²g]qùé7ãô>t>¿]‰“Åó\Eµ°©Äš¨»Œó¥Ùìú?bpo‰¾‚Âm–TŸˆ¥#x€ìû=n8úWVðE²àD:ŠZoÒj[éï"Žâ¥·IWAa9fÆ[榚¿š‘ºÉk® Ò‰BKl•|Œ KàkÅÖû³\Uï3á%°žiΟŸ' mDÂ5eFæÌÕ·ØN«X\O…s©Æè{ÜÃU¤?`'bþÖÕñðHÙ>Jœ¦EÈX±õoðD~Yä(ă£!¼„yî˜9,( ç¢Äê<bPg;äƲóУd}W±8ŽPlL‹±Ü¼â!ËGßV‡†j×ãÖê!þŠ¢ç4%ccÃЈ¸í</gúH<›œ]Ôóüʳ*;¯1¢O‹rcàé(“âÒfaª¶¾òI<îÛ¥òw¶0£-Îè¹È²Wê¶U­ŠÄ´ÖƯÖ*¿‚Ò%*c-Í“PÌÔ¢“ªÂÿϼ•bò~d¤i'Ñ8ó•A]'ž*}ˆ‰Ãë®:oÖŸÂÉ|µþå·…&{ÊÑèn٢͊"…ÌC‡ž¸Ç¦zSøÁ‰ê–&yYÿÆápÔÜ,å6úè÷¸ëSÿ¥â/m#ííá4ˆ¯<¼ýíUS±Ðƒˆ“�×Óiuú,ÒŽlû½¸E[r[3 ÓÆ]½1Ô°þëg=MÀj­ö- Ûã{Æ_�©Ú€[Fº¿[¤d¾™1+4t' Qª_Î1‡– (Pù0Í€µ+¸þÊÑSq y½íSZ§Sk&à%ÏÖùÎaä=Ác°£:Í°±ÙÉÁÎíùËøçÜQ‘?¦ m_«ƲĻAe@Ø.´ͼ½ÞµŒxoúm}ä=Ny¤ÊÊjöœ8†GÙ-¬V[îÙ´ÛÝtOˆ ô‹ Ö‰h(—Í[í(Á*`l›=[èC(0¾¥ <LÎ[*XòÆj‡¸'-“wÍ«©örâ~®H]IMDÅbM…HÊè�d¹V{*cþÏ÷–`'V o°Èøf+b–ˆ‡Ï‘—¾W…KÜ—[{8ÅL•§1Ñ:=(æ¨1Ïn’̨>ÞV þcóâ HÈ¡ º+ ‡*Û „§À¸=MõöÄÄ7²%,+v¬D<ñŒ©í)©æÁÔ®½h‹‹¡ÑQ?ú¢æ‡žª‡Ý ù¡_â“ÕÂQµ¬È÷<Dîk(« ÈkÜÕ˜?UGˆ-Ö°0¤Ùö; ’Ó·²šŒ7Ç E¿-2åï–WÔâÅâqãhµŒcÇGÒÅãU0'‘\¥° ²ÜTïªË™ kfš|7õLÓ%Ï(E‹8XUJ((hÛ58Þ!1n„äeÇͦ‡hñÐA[yrâÛ !Þõì ¼^§ÞÜжúC¢ÚƒÇ·3æ5»L¬Ã¤f™zu³¹‰ëkLÉÕsôÃþË„â>2£ERt™æëi¢gjĶ8}¼Ã&rË‘ñh DŠ£æÎJ·»¡Ò<fZSÌì€Å{p)Ø<5_-Z £If¡Bx7´ø_˜læ¡*Y¹ Î)fKôópò˜> ú>âšÂûr1FúÑ4ÉYQr²Ë†LYSË_¬w]ôAÅóïÂì»j˜=!y…©ïM—×kÉBDmÝï6›{vÕÅB];¶%ŠæÓ…��¨ÁX½¾v|Mâ•_<BcpO‡ð¤µØ9rîEɹHk9­~oußôÒêkûVÛ 'ÞPH³-¨ì/<¤FøPK·‘² Ñûz f휣ÕÂdh³,Hº£«B„Îx83 W_Õoù¡ïr-ºÇÌâ‰�†í½“™­TÕž"ÃnÔÑëñ°*ó²­‘hw¤´4ju£AaŠ— ªË*¦Õ$p{QíúëJ³ØÚQ¢È y¡é“CË91Ñ¥ÿÛišJËÃÜ×æ£füi´ÿûh|År`ñíq𦼜•È»®é¡ÕxÇ (]±ýV·ÎBò·™²l¹B¡zC%Ξ‰ƒ5D~³_“΋¡VZÇÛ~ÚZoiá#«BAhgÇÞ‚("Ò5+Z«Èw Ú‘†O¬øÈö謩ŒùK,m—¼Öqf!2@D [Y5èÏù]Aùp€¹ñp@R‹Fè]«†Ò[äŒsZoâ =ÍNš¯=ç­Û<,:GÁf˜ž:ïevcŠ$j¶ÜêØzðf¡Šz‰:Óƒöt\È*Äž¦kÈÉz\yïmLt«ÆƒÑLFM‚–ø–óºûrÉÖ-ZnÈ3f@­-a,„³Q¯SÿJì«VȳW&°Yì9?rÚBI¥ÈÍIŸÒz h4H­øxúzU.•®ð—1.‹š¬NŸ=q>Ð1ûQÕu‹Íõ€ôì·2K#‹;o@ô.&OA¾pD6= ¾Tq»í‡1Ýꈈyrï[i§mz,Z2†óÅ:Ê&JÁéÙ»¼Ÿ_æ«ÅýDI}BêPéîda/\1›3C~¾ŸàN19Ö*?žË ã¹¹ÿZô*m–Gàôp•AÛYÙM^öñ¥÷äá—¹;ÑÞ,N<kÔäuߪtOk>ê_õÊÌuËØYn@éãÆâ` \†…Áük‹<{rˆ)aB•j]ïûíÐÌÀf-Çáé•ëd¸h– ÿSc`}´ŠR,ýäAà;ѤyWÏ8‹Ò¥ï6,Tê ‹Æx[õ­slx5§v~„Ú¡õ$ólÕgq€¶4Ë‘Y>49¤Ê’6åö´ëe[º+»>³2õU^)À÷t¤Ú9ˆÝÁ`åý`Í(Zv¯ÇpaâÙí±¥å@E槳}©Ö4\hµ© 6‹¸ÝÛ=^A‘.æÎå¸M)÷h¼b_gáòex�õµª¶¡U¥Èñ©>Ü}k®“è÷è'Þ~HóÐKâiá¢÷³ìJ&! EÃøX!);|Ãå§Ñ>Ö»„ÿ¥FF'@¿çÌÓ¶·m¡¿/ ·Õ(/T_ò¦ƒ6Äè%iR/N{ýP¸W¬[fWÝíŒ]÷Éb2Ê…É0 ¨ë´Ž¬Ì‰:žïx»¡¿IÛ–«¦ß2Ïâ«žûÐÒ·K&Ûòãþº'´|¹eŠÝdüa¼`îÂÌ‹rül¼øÎRlLkÃ]efÕYa¸cÌå\´Ì‡<mÉçXÑƶ=! €Òl;!—®Âta0[@ɆvbíHÓ9„`Î=篛±ZOÇG{¶—K=q(²Ðq°²µûú€þ³;7… ¾«k™œÀ[™ÃF'U&4b,V“Å1£ø¯Ð Ú¯-îÎN:QüáµýCë‘G­®®x‰Ú,=гð»&¢̯2dòÁÊ è×—wgz‘ÍsÃD¬cPÁ+¥9Fæ÷zQ1à J™ªaœÞ=‘žÉÔ3vÁ|+vü¥âie±ÈB¢wö•™™KìYÖOF’ì¹]zñ”¼;F°tÝrÏYî$Ý™ ‚ÊN#r0óD¸©Ö¼–ô×Ç`*ˆ¨Ì¿èI™1„¯|‘¡¨Ió'º2>¸8|ƒ“aõnI)¬c„¿*OÃt7|µ#:ñ+”É-Vî ïºÝª‰Å>ÇG¿„«Sx~Ó÷ T#C‡)‚þGœÎºl¯ ÇÕàq-IâÄýbï_œ¹Ã²'¢»š«Mgr¦%ÎÎlÞY¿é¹»šÅÑŠ½6 Æù逿wkª9<'pˆ ˜ˆw=7ˆS_´9¢SÂt{ôD›Çj×£„W¶ÏXm™bŠ¦…ió³³ÇXÇ>®ŒÖÀ¾¥ Æêr°Žmue¦÷éÎÜ)žÐsÁxÆÙ`3EDÜí'xM»ÊÚ�ln/ôn¦nÖŠÞÎŒŽ×§Õ·Sg`ü·3 úѦV2]VÆ•°¤cu±–ÃÆ;“NŒVŽ.[Ì«¸ã}‘G vØLÚá£x¹+þ ]ºÓçâ†hOæiNŽ$1ä°#†v@ã»A&ÒCð9Md¯oÊG¤Ùvýã»öº¡íÏ2­‹êŽª‡—ŠçˆEàÂS*a„^OyZ^êÕ­™²Êì3½1bæë@P1Rˆi·¥êÚ›?¿·D~´å=?‹fY¨QQÁ¶œ1&¡~_”&òð†òdÆÑ H04ßUÒd™ÚFGvxzÍ¿È#—æ²4zYYÝÌ“/tˆË\ˆ ô1EÖŠÂê ]±‡-æÒµ EÇ®rv&’2o~`tìŽrV™Xp€òÖt›«“ÑF<¸ ãC¦PºúŸªEÞÿ-x¡ï.·×}ž{m‰P»áãwÅ3FBxCZ㳑þÚ åÝ•£þ{Oñ’§ðת,Ëæ›2&›IÈ—19I1¤çœ`T€y¡0îLÄeS×%m¨Ù«ø(ÉÕ׉ŸýŽY'öâzå[ ^„™ÌîÊÚ™ú¤2Uã„„ž)ÖÞôŽJã f¼×0”ÈŸxàÞ1gá:ÏÝen±hp®p ø›u•Ò–ÿœ²Á t=‡æjú‘?–^±(ŠÜw‡=64N%ç¶Ñ ©w9Ò*݃ Ç£“rGÇrA8?°‚Õ§º‘%%ˆîÒ´2ó»WÎ?,+Jt´ý™ìˆÁZ~Þ:L ¦Æ,»22ô²Q·W tºùú±¡5¿ÍÐf Enþp¹!Ñ‘1Jvz`ãXÏófùÃSÿp¿ª(زê&;š×A̘¶¼I@#ȃ¹§“ž:‡!Jz¨âÍ‚°Ñ sÓ…¡'šÕb3wyew’¾â, Ñba®� Œ»m}±Ì[<+EÂd•zVÓ`ÿ50¶ê4pæ¦kÍZ/¼dæsÛ—%Ê%0—û ó_þýëú=ÉýX„¶û†*‘üSOšÄñ>ºj×`¶ÿxÆp%WÌ ¥k×l‘×·¿¡Ýü® Ž-R Œ#ìV³j3!m?î† ʹ2îX~¥²n{/$mãxå w�Ëù˯?^>Kéžj¦èŠ¤»I%ÙÀþb<tÄh)_3 &¶ÉD0ÄõŠ³Ð8äyÍ>©:9+÷¯÷°¬ø0òâ…û^Ä*0ñ¹òì,@™›¨~Àæ½TŒ¼^hº G ŸhüЭq{4ÞU÷Ç|¥ª1›Ó|1UR.ÿ©†æᤸñü„Û&ÚpOMo¼Ÿh“ÿš¼?WqïÙöúC á%A\7žxY-ÚÈJǼÄÌö×xðd}®‰”¸¸„ØQbð¬*å[gÚ×°ô97*ø!ÙÆ'“ ù]a _«ÑwÄY­Ô‰ëÄ4ªpü¿5š/B3Öt»4HÛ­§¢Ø_&4MyÜö¾ðCl£Jlæ‚cÓO{Öñ¡ …ãnÇ„ýkÔ”H·sv5ÙS.9§#è†Ð®ŒmºÇéÌx8Cc¹˜g¾c¯i» fX ÒbÉgÄ°yçédlóÌkÍqAÆÎ3L°duM ¦ývN8 [‹Ôåý¥Žz(â6VŠœÖü<Ñ{w—'Y¢²ŽŠY"C]}Þÿ ŠÉN)Þ "R:¤'k´±óâB† 7S½Nÿpjôå¶Ò‰°ÏJ7ºMpf¤T6Û&Rä96[ªD6í XÌë¨g(¬Ä„wì)½k•€ùÓ2ùÚä’(ù È"Oãâ<ä~ÍzKy]!JÓW,Ïs´hèFõÕdã zš€¶ˆô.F¿®½üš].�ä:kŒ8 UªXìÔGôB7Êe0BZjC0ÕÄVŽ¦û!;P™¤Ë& KO.ÿGÁŽ?AÉíÍj{ø8öh@ògÿ˜ªá a ^ =¾wÉðÍؤÏ�f¥ÓmœEÇy×ïvÁ’rׯ$æŠÌÖá8 âà¼A™ÐY%èD’ÔYz™®Rkæõ¸™~%B–—E³tS{³99Å×* Ši£ì½â“{×41ñ¤øBækWܦP€5’F‰júªö¾&îÍ/žÉææ+Ä‚!M± ’Y1,(:9ñëªcÛ ÝÄ ¸¯ÛµÕC†Ïkt¿ —®k”¬œò`Õn<l.š„‚¢[ó¿+=Ä^K]Ô$g(Éð‰J€° $¥]Ž¾–©ÑÇþpÕ©ì*eŠ’…éL ³›’¼æ†é­¿7˜yXÂJP®Â5ØÂï׳Çôñ’Ñ®8(ùB¹Ø¾í¾bsg#—ª·ì ºüÉW˜* ÆùÜ`j2n=)I&¸ÏÄfÆGÜ4­úÓJ†1¬¸’)…mç!jDôINô¿bm©…¢èqÂgè{3öâë_ Ëù]-öT+);˜ÍîÉ@_w{tGwÄ`’ƒåúyÔ†p8Uux©)䧃g‡sÏVõ€»kïG_GdÅŽ¤ ïÞl\µ ·4® ¶ÆLÚ^NªïÿÖÛü &†�&´N/6 íEF8¾5ÃV«ÖáÄ;÷eãß(:V }WÅd‰«UæŸgçkôëÔ:Á5ô×O´Î­XåZV@Jºl!Kó0úþÛåáQ¡ŒyŒ »·$XðæMêúË~§9†:¶ÝR´y>7ßJ´hc4žäZÈÖ7ÝÉ÷ÕŽ§¬|?1"\ÉÕÏ.ñày©&©k–ð»ÕŒiTŸwAvµg$&Íx¯”¨Ã^Æ5e‰Û*X}W:†*™n|`!2±¾;_ fü)\&[-ˆšH÷@6êµõ‹y%wöLœŽTb²k"·.àä…•»è\„ÿ+‹+`ûMÑqÕ}»¦ °Œ(ǬPp…Až$ª*íÁÜSJµ®ô!·1Dû¢-Ÿô*Ú¦²U>x¢a±b€Çì9ûq&9ìrìÐS`†`vuŠ›£×{‡îpôô\‡Ê$){:÷ªáEK­]ʱÇ-z\½xÌ:<üF—"ÐK'¨7D¡’ÒhZÅô­ò ì<cCê°cgp«AÅ´ Ó»YÞŠBmÅB£RÔh‡1¡){ÎÝ'ÅØÇ Å*ƒ«TBCШdy>yV¾qÔÒDÊ7¾D˜LX¨|õkô¤¢$R½¶^®W’åo ˜;ÙhÆPu®(ŸGs62ocP 0E,¬ù2›·ú‹¹z# yVaí=îlXÍ%ÎÉ¿çݶzçË‹PpÑSOŸòûlO‘BÆóœy¸¼mb鼫3ž³t\@„Q€ú>f›ùÏxè˱SÏt¡Ïn…GS+®Ö_rLn/y“T󚙬þX0¾sÕ=Ý[7‡åÍ´w‰¤|¨L²d!ª‘}“ 1‚´ªö\ÖSøœ[ÊDîÚnõ·"Óy<œ/úoø¿(tD9NuJi²¦)‹Ž.:Á=¡ªm/I.¤+' ,}‰šöS9{3œž}G«“.Êë-"'^½A¯œ(¾{§Â2Q’Ô:a—WºJµ•]/±“²#‹U_|-ô\,ãVÁG¯ì­î†ì(R˜N6ï¸À‚-ôóX6_}Ñä?Sýÿ·déÌA È¢ÅIsìÈCÑLÙ;Ú¡’óÍb‹Ð•¤Ìw>YcU¦½üc>(Ð&:ÐP 甃ØiW#·6 uGE'Œ¬¡5<Ú­òS©¡Ôÿ Þ퇈ý…"M©û´t@7iÇõ« xâ6ŒÌÒ8î-€~ +Ô¾·ÐÆÖß±4(žõ¦NF0 x¤ŠÀc³]¿Vèƒ'¾‹f(ªWºÌsoTÈ:ˆíwL»‘¢‡CØ#gáðf–Þsž$ql¦X”>�Ç›¹Š\Ie49ñØô'&¿›ª7)œ\p®u9XáyäeèKœ×a”¿tª,€¡å)ÔßÞ•|$К汧 òaÅõ‹Rù2«¨Ð>Ñé¤@*2§í®?à+P|¥äʶ$—?+2KÁ1pûQšcšèïOëƒ:/¾#<“æ©/f“³ø>0i.åYC?„c¾TŠÏ¨S«4C^ÏÂ]à”ý»³ÊûÌpQá}¨ES ¤'ü¯=¼@rÕ>žù N(KµŒðiê{€²³7­Âï?ž¹(z’lÁ*íŽÃfôõvf­|iÐlt«ÛÁëeŽ‹f¦rª¿!-îŒæÔÂ÷ðÍNh'o'Š¤T>3â$hv =S}y%SG+_D³¦± ª±ñF4[6˪4ELµ“»h+mœ8ÅòÌ—F©Íh…Ì£SZÛ¾?ÖÜt¾Zݤö6…™«…CZ|ïÚõ×jÊ=£íé­JÂ?¸ì%ð,ãKÁÂ!ó$˳R,ÃÁàÈehŒå RâÆý\@/ã êŽÎŽáhe‘ë—ÕÆ™ù ð2Ïm:šË6â®­b6ý¹žuO-Œtû{<ï(ôÑçßSÄÆETxhùBªQÑY¤õÖ´‹ÒŸG?œ^ Ûb‚/¤l ]x=S¡sàù 89˜Å™—[(Oèïó@¨"±\lÌÚ˜d,#f#nàq£÷ï†Yd-ìSs¦ÉäÔ‰ã¼c6-ÛÁµÓûcÓ(^-à ±Þ¥°ƒ ²–.­2rPX±°N9v>™á-ì¬Àö¢ê*Ú¨£ £µ)Ñæ=B1€ÿâ:²fÛ^Ñž2©“lчÌùlVBˆøÿ÷#g®0Îü§"þÆô¨?”Tˆ„-–04+õʤ©ÇÔýeŠñ/íøf¹CŠí› Íü P¸’!ÔVžñ׆ÎO ñ ¿oSÊ£–óa£“ëÈćªŸ ݼÞðøBkt›)î$A\=¥.ãÿi–%³¸X&ß P€#xOï×ý$çe°_ÝÖì¸7BµXk•ô÷ ¯—ÌR`क¿~9n/Í`0Ê]öv¢ÒiÇؼG~š™¤Š–›¡`— o¢ÇXÀѧ1²«îêVªÊÓçÁ˜& º2Ý@l3’]pƒÞÿ³ó¡é\ð¥¼Q²2úlGd™P­ÅùçƒÖ*'ÄEà/|5ðJgÁ¥±møŽt4ÐC…¶j`Ó \eÙSãïD‰ZÎ(Xc¸Û·F"8å¯æ•8w¡£å€ÇûH,"w ˜)ꎂw÷©@$XáÑê7Œ¿,�mG×48¨Bm“,ûÆñæÁµ…ví7׬òT$kðÝd@IQ¦ ­Üó&¤Ȫ4…Èëýgm¦ç;ãœh/žŒ·­wj1øi$]çÈ»‘rñ¾êô.AiŽžÇz‚È­XþŒ¿`z±~w7ÕY˜˜\k8Ó³èõYd†Ò‘Š‰Pá¯ÙÝ0p0ؔٷfç9k™&Û±ù¹T{™úqR5UN;Eg.qT¡Õtž\(¬¦c5cæ~ÞIÊK·DÌCÜ0>JS¿>)˜:V‘4Ä]˽¾–VzÄS— ‹ºÌÃ-BÕš\SX5Vpœ7-»Ñw›÷SF½ÏåuoÙÏÆÄ'À“hBø·…Açþà…QA{¤ãÉÿ—CFË /Ê"õ`*ØÍ¥’©'mO;§&Hò˜a¤Tк`› ó<%Þ^'.÷kÔ»¶Û]%K˜w¿ýÎ|³X´ãf•Aô.os¦,¼^aÓz^½•ÀÙ`;o’âú V?.Q‘ç–Š†áè5¤ÑÆœ7-hÄ¢[i¯á¿¸Æ©Ol huž¸×N'òc(KûÔÓŒŽÚYx?Óë±ÒN&—ʃy(ƒèhv¡Ìå]Üõ½¥ž1ý¢¶`/ŸmdÇ‹Äœw "0ó9ÏÞàç{' ù‘o�Xåô©Fe%™bw]õ’¤½1®±vÒL¤=Ù~ÓÝÙüR+Ë8>a-¡– 5øB<áôÀ¨3)WX/ÂfòieàD 0´0h§`új·ŒMâø#^C¸òÇ¥+9ÁSKfÙQ-:l%Iøç#VÕfókÓc|ë÷y¸ ÁÐÒ?«£ÍebYöåÁ|ùS"äPÖIBGú+ò0•©;‘ïn)}ÜlL4 E½×I S²79½%ç+N>2S—aKo;Ye%¼;×ÂÕñH·iÍÒþJPbÛ2ôü®L`ác»D×æè%=¸3F¿‰Õ¿ßÐ$±sfQ]Ñ1q¡5VžÆú&Ãô¡NÔûwôÚ «¼’Q(‹‰õg¤oàáêCiÒÍ÷’*À@FÈ.!c ö`ˆ¦x~|…œ±0-=ŠFs÷ủn„d»˜w¯n–úšý pqOµgÙËRˆvš7»Š©8ó^"r²,¹ ÛÇ%aSà;R*»Û,çpY€=³`S_}žÈ„³aÔbÒT0Ȭ¶' ×»ùÊê² ¯m£*…· $C=L®.u~âo-ðDID,LˆxÀÙA¦ýÈs)Î_ÞnùÄ:\Œxdå싶ڸ0ݦ«XÓÄô’2è ?ô0ÌÜŒ8dœîÇÖKê©5Õ_Vì¾~ø¡¤[«­ÒÇéÿ¢’=♤ÆýŽ¤¨ç&‚AÞÜŽO¶'úS(=žƒžJ¯èaàcO;*>}×$6©ôÃýn‚BQs×Ùêd–ÈXeÔI7r×Wæ0ûj׈üŽ+MFŠ<õ }´Ë–ÍGÕ¹ˆ0@ï½P5îÖÈÄ¥‹å‡Í™áîAø?Q²±Bg¿ò í[B`× Dƒ®úÓjOö}óòTµKc×9Œlßµu½ ë+'xªS_W£9êžšŽZŠôJüR“ ¹ÄA<XÅÞ˜§ÛçaÂ2Ü÷¶Ù2PèÔx/×­/ëüeŒbZZ”uÿ/›¾ÿ| �ô·i½c+™¼š"Æö'LES&ÈÌ2l.ir¶ŒÇŠÏ-�ïdŠ#¤…ºÌûŠ¥Ö¤oõàû8â\f4†.‡<H>ö êÅ“ž;îÖ_ü~°ªœ¾PÊ×½gï»°ÅÍlõ-íwtÖŠþÛË5ääôôð`éç ìvÙòÔÀ-àó’PYi½|VAp.Sߟ/®€Å¯Zqìè�jªõà€¸ïýÊÛ»Û¼ ÙXebýXnÜ{è+ɽ!Yþ¯€CˆÃþ¥Ÿà;þqÜíOÓGkíGèH¬æ/H5ÚÚÿišce›öEAÇA9hÌLBÁr» ü¥Ÿ'°ÎЦ †¸F&UVVÅQ|ÙT¡ú±8²Láå.ù­Ï»Þ€ Ý•7¢O+èzW×Öï`Ø¡E[](�߶ÐYA®ü@á"6no3éªþ5JËÐÔˆhF:è‹ÊŒWVè[ésIS­ù§7;ÄñjÁø¦ÅUîzþ¥Û¾éy”†ãÕ+…붧ý·Æòë<S ÑÉ{Êx*%©òoZnT‹¸FŽÇA5pEX2ªÉ8ðUÿa´; ‚áÞ/�Mý¹ýe º´ó6g-U¹;¾ÔÄÏr2} ՑÕ‰·‹°ËÃCͱ7Õ®ûÙSA²þrNh}úV¡êŒò8境Oi'fÍR„ÚÍ>ÓÚlXM܆GŠ Ào\6›maDŒfdB‘mo2y ‚½Ó@“ÿ»:G«HtXeúk{ é¦Wrnù¢ž“áiÜsêÿÏ+%ËOÍ™™ìÞøN0²ðUd§–jþå;_¨Tµ|™5„A]‡AYWJ²Ê‹€«%l–A¹âw¨Ÿ?"zM8vòZ){ì³³¼I#ôÁš”¹c?uKÓÅ9�1»½'­�+›ê7e›ÚSºÛ©|Ú´ #ÏèMì!Ù–áÒy�­é²®¼‚ñ1::)}íj`I¶HtÿÆÆW+˜‡¶Ï bOP`Æ öCú{…wFàWu´»¿làT«¡Û‹§æCŽW¹2õ4cæ‹O?ɦ‡”«·øÔaæ}u|ÌgÆÝF'\bÐYí«ï²iÙŸ)èhÅu§s¬Ä°¹×{z¨åüGW( s&Ké¢ë58Ñ—­Ì~ؘǼجÔÆáºÒemG«ø$AQíÔ·¦/°]Y{ñT"L§TÆ$Ça¤²à³óôƒëƒÏ¼ÖBãΫ–ÑÊÓÇl[Ä­å˜B>šçñ†VáµfK¦¢ƒ}ókôêPQ2bóïdhy‘ÚmÄr#_ºiÍãÃ-¦ÐÁ�YtÛ~Gò/FA8ŽÜ…j-¨6‰0ϛޛ¯Éãßi•å©8,uÞÞcWFQêÛòÒ—Ø3JdõÆðw–ñU€<Ï雷x”bùÌ0˜²• YéR`‘`¦MuéæÛܧ„5Àö¿ñ¿þO¢vö[™AS¢¨–9k@H<4íi3^]ÕÔÕj¿ú�Iî bA„&Ž‚bžWÎúaÊc¯Ûyf3-dãCsçÂJÊËh5A„a­út8™L›#©ýN#Â=–=8©,²l¾ƒêÖëë‚=·ò憒”·t„Øi V`?NÆFòõñ¤éha¬+i㱞Î*(šÆÁ>è£{a§q¦Â¢õ¦Ä¯u¬>-·M#dâÅ8Ë~Lã§êîÐ_øoØ ´ pŒsøD‚yó _(83Dýf µVå ¸Îmc¹O÷*‰§¨“Èã¢ò¤sÿ•Ò–ÐÀI_¬…M¦Ô*½ºæ¥±0þ}ö“_‡%ÆâäG÷•þãîÓMɯzÝnhQV¶—}Þ5úD_"ñ\,AM¹eÂìs¯7cKb·vl‚j¤àÁ°­û—áÿbÏ`C,º„Böh•íÐôd%� ÜÆtg¤rçêe ‹Ê…—÷g2z·Îö›L5†{¶–ŽÝ©¾H±ð¬K®ÒÅ$˜&$½g¡U›º½Åz¥{N%—(0=ãÉgÒz}ÏÈÒ,DÀšnöÀú/:œ`Ä™ªãÀtâ¥îNªOë/åÜëfGJ¿ Uw” qÒÁÞrèkÞò½áô®N˜x§ Cš ëãvÑÁn,$Z®aPÝpÊ1+hà‘'dT,Éü e"h^Í®÷Y·_×òw²ÂÛ1 ÓF÷@j©cHœWèè÷„µ‚=Íbè¿ÜQµ7ÙžµÞj#qÔq šÎl—-ýPq¾ñYN’JªƒòžrÕ¤ ü kÍøEŠwD'*âé}†š2@½™Þ!ÝÎláæT2ßkuÚxŸ•;—tÍFÄè%»ÉÂeÄ[ŽÒtöüœ50rq{ò}Ïc0O-t ùKŒÔ? Ò¦÷ÂUÍ*U=ŽïgþoTaZ.tCÒÉ•+RˆÆÒ«óøÞ¹œêæTš¹CZ^ÎÎ�t<œ$³)�("3—»jô˜¹;@-P8iÆ8®«8(7½yÿ˜=qñ–²è�v>ï¾yPÃÑ»pê‰#báe¢Õ•Xù´´²õéTêØ{1à ¥\òf2¶·(UVF:ÄËZgö?™Ý‡¾w" ›G�©lU€u³á?ã&S&‹yøê‹™¦<ò^7•u,cb ÅfYÁ¥Ÿ×§?xàõv#/ôx™Ü?Ze,ÓÓêÓÆ¥¤–ÿÆ Èï¡>Râ¹14`�ÝqP™…8þø÷#6�ÕRG.Ñö(¶f‰ƒ~„9èã ïf 9ˆ–NŠ ÇTTŽÖ5eOn0ðžg­‹ãQÁ§Wn£/ø®ô(]e–ý í‡m{•bhwçWh”0öHq2ËÛfÐÔ2OÊ)bK%ý{ ·Z…êc­¯Œw÷º¦gh‡BBh¶x#WG¿uk478ÍJjþðsë£öÕö¸Ó[óä´µŸ25PtJ•(N£Ù­Œèé Û‚jž¤G¡Q]±òdÈŽè™5Go`r¦U!ú1².Z|òM½Ë Í:{' …«nM@…9¦z“§O©üVÅ,™JûÉ…m.e¥%`ñä­ tr<·ÂÉÂÕ£×´Æ8ûúõvIÄNö!1 gúNSí‘°¦uGÙ·· �µ2r_­&76˵F÷T#k’p˧ªýgójÎY¯ÎKS_†è#³B¬—$šª­E²°ú‰N@`X½ë»æój˜#�@èBttV}wžÈ%ÿÛJãúÍÖÊTLûª/õìáKì†kÊVÝÐìnLô r¼ÿ¼£ïª5;vi ?Âs[ÉЕìP"Wýœ½“V´ÌýØõð¦¥k%Б!Ëda: ;ÄÝœn³óâ±EDïñ¬öèÀc5nN=·­ou1V¾ß²Ù~PT!êh;UÕU÷×ô¡×>30¶ÑkUà5ÿ`·VE”ˆrxÉדþ¸WüçcÝ¡7a2.üñ÷ÿ;`‚&¾ iȾ«8ž­@ïÊHZY1‚3Ë›<eG:¦²#¶ù¡wLЪ§ÕfV0²9Ô³îâ»/öŒ°1F¡UžéT;õ­-ÀkH×øÿÞQ´ Ãp¡7“õ”Qíçi»‹¶”Õ6Pµ„w9Qžúx:JËç3…¶Ôú¸G– d‚³Ê¢ß^<W(³}dûD§c„ÇÙ#"C'<ªÔ ªa¶%³ ˜‚Ý£@9m03R拺 rúܲ£ê0a! ÃY0”ùŒ"]«ì¤75Ù“Ý++2„J,¦·žÙB?TéBL¡‘‚ß:â.!˹;u,@³|¤‘m S+çK„…¿m³®­yô§¯Rò?ö¦ 2 PïÜücf]@mÒúƒb«¸r¢þôGþ;ƒˆixÁ>\v»X•–•%,x&‘Êtvλ}­šï/”ZmZ+¾^˜ËQÜúTŽŠÑ2£…mâÞ<‹Ä—Û¢ãliˆy›v8÷¨Àh(¡ÔszêZ3½{uÓÓt¦¨¥I’xôkiz…±ô%÷;‡‚âÌ’çvö;îà|¯§áBÌÄ¡[ Óhn(ÙHk+ÞqÅÃ"žþh%¥Ÿ»0‰Ý³Ï^’¢‚)ûÝKÖeîw'žgAÚy©¥¦ H9Ldcç:uôõvôšÛíaPTž~½ÝM“_$3IQFÓ¬Šq¾V=}bgB\\T?µ£Q}q‘\¡ûôæj°ñÂèÊ9Gï×ÄÜ8ñ̟錾ø¾l4ãg!ƒÉt«Lóx8¥ÝzÚpP–ÄL5ú*Š<Uwèlp é|?õ=ËôL÷où#ÉBÕQv¥ãŒy§wÈŽð‡o:gŠ£Õp3c”΀‚û–Dr†qã‘ùÿ0À‘Wd,L~¼}Ú§ fˆ“µ™~ Ê`» íÒÞ­ôÕ»R½è[KÂÁlôX5×@+&‰š¶Ù_p½LŽ¯‘ÉxÐË úöhÂÛƒqPV<i;éúºEVnuX[²9â«ðþÏ8 vœqÓ"h.£nq�¤$`n7cµžŸV>ÞÌðU:FÓ l1™%ìt»ñæß›Š²sÉ^½³òÐ7~½„õÆ©у$J_Pº§&cÀî(íÔÂ�ÁAŠuQðÏ3ÉÌ)•fÌ5¢Å%L•xäÞ`k$m(ó– éÒSa´0ʦ2¤AQiÍ ÕËcÛºŠó•^SäœáX¼¥‡ÐžÅ@¢Ý:ÑÉ©)(ã¶Ê'â²mD*sY/†¯PTŠ<ë¾XX<ÖÂjÉÛº¢oåi’:z=ÀÆ0U^mF£ŠÌøV!VŠ›Wõ^ÞR~fç@ b“P…üÇÍ ›ÓÐXö ªì:Ô›=³ÕùÔ¼®ãM”¹õÆŸÿx€—N­Âëã9<baô·Âëì¶>èP£ÃmñC5ž†C¯uÀ¥> ÍY;»g‹²à34“ÀÉßð­MC¿mC‘scñ‹‰,jJZ)RÎ@9—¾[õ ^à{•(ž¡ˆ-åKd?ûž]³¿Íf,Ö©˜ãÝG„ÚWVn÷µßbF“à]£WR”_Óì­¶qF µƒaù]å¾"qHÏçíñò´S¥ßö­`€|®Ä¸ùzš² !-ƒôx6ŸwÉçÇ-Gi’ÙW"}ï10Ǩå'M2ÇùˆŒ!Öˆê>µæÍ´­.\ÙªNÑ•bÝ}åº(Œã·Åh+¥AÒtžn"· °qhv<T«æ5X;È.®öPìôGMí† Pž”ø8"Ë©zcªô_‰P÷!Û±õEH Mô~+·�¯Bi. X.£¦~ïIþ ø;í*Jrj°í,‘½Ç€ùa[½ðr5–O›æ8ˆZ Ceº¥:Ùœ~ŠýIóÕB³B唹–GËk2 ص Ü뇷æÜ+3Y™¢PÖÖo¡ºIÿIÊIÖ†Æä°î€0­îo½lWý\AÃ:Ôr“ÄhŸ%,⮎TÉØž?8@B‹Ô5½'ÖlëSVëþÔÂ1È ¥ßÌU„I7k»Ž.AQŸ¬¢àaO‡£`-Æ´«Þ­«áZQÐt“ÄéØ”ú“pøåÎYPü²n£ zPXtЖ¾Õ0e£?Ò>Û^˜1‚sKGkGiFÑlÓ®¯N#0ª¶rí¨HÜTÆ¢Äuò-ÍÎF©¼3NâÊoÅm$P/©ÎfZožì{Ò¡¹§™Ë Áê×ƈXbÞ-úÉf']pB3Xü•,òÝWR±~.(½Ð¶Vk˜pÞã+`Öá2Š¤ªåµ-¼é:ÂÅ@LIki1CôϾ¾3?N“•—]0ˈ¢™Õ?dì¾”‚ °Å8 :BQÝWõåZaú^ùb'± -T¬´';Ÿt£ˆõÍ Myy Õ·ºû¸!ZhJ@}»¢­6º¹Òȹ–´˜uýóaät×lïoÝ›àÄ=™»£?Ú ãÄÎÜMIV¡Ú<ûä/>ÛYÓ×M ÙʶzK5;ŠÂÔ3_ ³÷xˆ)§ÜXLjyÄlÄ­¹Ôý¤f‘ß«L ÝþÛSÁèìçÐñc` '°“áöìŽTìMgÍ„ÔrÖrŒ~P`൸¦§Î.õ¾Ó E6RT YÍ•A·˜A Ý¡iÚ‰AãáÛxÞà'ÂÈ•×+n†'ð%·ä^–¤dì:O±ÅßÁÔžÎCÅþ°�6¥±óÖfV2|©K›ü®«D”£ðÌ‘:L=T'£!œÍž{ç±;´Ãî[»O‚~ì`Ç,Ž ¸¼É ŠéåCåXׇýÐ1tàevÆt§©a9Õ¹¡ìAõ và‡±àÛÓþ})y'V¼_>ö|ƹŠÐ[&–¬±Æph‚æÀj6Ž–8#?ñédb[õía²P­]ÇÂñØÜ•¹ >âåŠÇzˆÃÍh»\”b‚,r̓àx§†Ä8)1ÿþ«©žZ¾Fqr¥çXqÔ­=°XðÏH£Æ1WUEfµð_zŠÙ°MúÔ ÿ·§$ òÓ·ÇÒ²™ªè9]ª™Yøú íô½ÄÜDI0íæ´+@–žkzoÉP…ò#(cXBÁ §2~×/àà¶gép`{"žH·¾ÁòÏóy‘µQ°þœëCÄ<¹ÑûŠ+]üëTqWÙ¡÷v>ï.íØÔ—ÅÈ·?c÷ÛB€²«UI!©ê)^CS×EàZ¤º†Z½5C§Ô‚±Å&·ÚÛ=y¨k^V‘zVAl´J9yDµFºy·P'õ}H×'É•l5js®¥¼ê½Õ8\²â kò ,ô­ +y†LMÁ<·;Wtî¼-yˆ3,µ“R®€#Ê\~©êNq[™µ–L¡÷Pî7»Þu¼ò´<‘ßÖmu§ø/ÙÖ>ì—’u1¢L§@´Mi˜t‘òð ê8ÞÕA�K~ M_gª ÈmÇb1[›‹ÖOg¨ƒÍ‹k€ºç¿á2 õTwÑR ’ÑŽÆ(€;$­æ ‘GÒÅ{/.9Œ}P;š^P‚ͪ£ysÞêFçŽòÔºƪž@ODBâÒÃ0rcgw,© Øš‰ÐoÚô´— äüÈ èH6ýXTœ¶¥EIÓ®ßQ¦Rn¬¯LÈj/ßó¤¿ÛcYêisój½ßµºÙg>úŽ 5¶P2"“ÁÿÜJ”¾=ÛÇÊÙÖÒB-Ñ}”­„™TU_‡É4è­ ±mÙû¿y‡½Ê ¡!½@”ŸþØ„j÷ßàt˜ºo×cVÞyÏiÀB¨%;àŠMyQn“dçô!»o:W›œt†ª+še zã`Ÿëß”$—›“3˜þîéÌßôÖ†õgôÒ¬L—N~=ûx»s™ËP6j·]Y­ŽÞÊï0“Ÿ›:ÏJ r]aþ hS…ŽTàZó:û¦]®|‡ª�XP ñtËÀùe+|`t;-ò­Û”û^<žÎ¨;­ì³díÙÄ€C|Osya� Zþ@ÅVÞZˆÿŠ°‚{tb$挗ö¾ï£E}g&´4F‹DCo[Á±Èç?¿%cG¡xC´ï³ i¬y¥&¦ð!BÔJeë]âÜ›£QL|õkzÊ…“,ã^×”AÖÕžâ2«_ÈêttrqßâIì,ð8‘Zˆ¡5ÊÛ„ŽÂ ÞAÏ¿õXíðò ÆŽ"n¸c…âÕ¬¹ÏyŸ—ü—j9LÓ¼8¼>#7é7¡:Q5%Î&ÒTºÂSõ{GwiRûg•“_C%žÄ¼t ñÃÏOgfÔþI[‡7É4çY¦7îêÎÚ “h!ì["éóèPnæô¶ä8}ã!<t¯‹:q+੼è'®ö˜ëO‡kQå@<®ÂC;uªˆ»üy7{d|nOìâaDVÊð-R?i  ,ÁÆ:qgfX' S{È#râSæ5±.ÒÛŠïñ*ôá–ðó�䯟\'ûF¾ÆØ÷ÌÏJ;`å0©;Ññ’Õß®+Ì!QY*l ¦‚±ï_éVX~Wa¸ëS–±î~l‘=`ÌŽl3¾“¶%W­Ryša¯î ¨C'm sç¸þFy§«€¼Ö¨2xæË ìu—/ë®BòpkG¸Al!f7YÎÖæfÒù¢ê2TÖË°®¶ò˜×‡ªgw·è(ö%ÜYñiÅb“¡eÚ`¤ÄöHY„djø¦Æ hàj2Y«ãŒÉ!t‚ZÕU€‰ŒÞ»%-ÜÐÒ"¶„t0&ʹ@YW £”]QwÜòC3á/Q=á²ÓHÆ”§ÞZŽ®)ÜFâP.Uâfi.nוÒ[!©)¥ÃÇÊSsufYGÜ`,èF³µè½³tú½¼ÔŠÛñòÐ&âæ)÷ž?$«ì›JÄý H‚ÆËÅÈôZs¾Tf OˆÙ…>¡T´aøIÓ]2}ÊeMNf/î™ÓÑÆÑZMŸ‘uóuēæA`—pžÃ)2=CYfä‰ ZKÄðº¿iš¾ ©n?†êO{ëÚêD°D0bŸÙ¬ßºf<�"lÄ ƒâ§©ï8Îbiæ~.ŒA^—$AÒNž]+ÙœM p–Z‚w™ä¾ÈYŠìÜúx²qÕWß—ú´ãO÷χaÌc Y³ûg3«Vv¶ó�ºãrª`Û×\˜ ®hi°Sæ|n½?ˆ°Áâ‡;“î²töG!3» ÝU~Û¦ÇSV)5¹$Îq¾Eß»~‘øYµ&k­YRµ³µ°9+£Égžüý4˜æ#Áp¢hQE-òe$¥Õù!늾%èýÝa<¶ÏÕÈÂÔŸ¼Ò_5ñbneH´nMÄ 2ëË|Fy¼”HKß3‚§}ñQ­º Ÿ™*á–“Ö×APÖœ\™ÆWâß­úKãàË6<ØüMâmgEÿÙÎ *‰hÌów ¯¿L”'Qêh ÑI}8{|� Út€ºÑÅëü,*#÷x.w<ÄYPn>õ_<~XIçá<XÕ3Ø·W?ù{;3H4Gý§_r2pñŽLÊØ6fgÝÉK§DÊ:e}›SdÞxZ‚kX¢+¯t:³+5úñ¡+ŸùÅ'­v–ybÙ³é˜ f¥fÿ^éÍ!¯S#ð…Ž`ÙI²‰Ò߉e}påµ7É¥““Q‡bpœÔYC<³ŒájÅÆi{À¢ ŽöÄ>0?"yäVÔíÍòpscÙ ;ó_ Š¸92R’ê9æ®aqÎaaZ\Ëj×Há"Ä£ßãaEWÖZÃ@ßíWåÉà ˆÐZý£þÑõí4_Üë#&q‡GEq&¨G!VÈú3ŽnäÄâð>e00·êrt¾›B‹6(ûƒA¤³~!Jr%žswKJÂC7}ÇñáÐçþ­­ÎXP,¬¤•ê¬àégêÈ3jÁýˆƒý0ÍÆUç­kÀ]ªƒŸ¨íø+*æšg“™þ—×7¥Í ü„ýàHL¬Cë]>1Z*8Á¼`dƒÒ¶ø{|qš4}É`’³ÏÅ2ìtC¨Å<ª\rëcZ—ôÆÞ;öH÷¢…RÓý¹µôœÁ˜í}n(>Eµ � åÝ0{NðÛ'zÔöèægÝz0„ùÂ'æhdŸµÇÎÆ€7í($ÛÝKu~½F.æN5ˆUGÛZŽ'OÓ§B¹ÑzØ­× Ö(_…éÒv£¤Ï\iœ‹Yþ³a¶­èÃ| ¡ˆÙï¸ú·7’w^x˜òzOGØ|±îlÝwÞ…¥|¤Ëá„.¤šŸ—é±Äî©ã"(*=`‘8#´ÿ\ì8Z ØèO \µ{õ1#‡@ûnC1¹ïs9+Tí>Š~öÔ[hŸxéó] O‡"^ð›3®�ÊoEк¤z´¥Ó|¬ŽÝ]üÚ«t¿p5FÈX¦u +˜îâ¡“Ñ;a Š¡³;ÄטÄ,õcþ¡h·Â9j›y§¶Ò¿wãv7°÷¸ôcÙ¸ŽFk´ÚsÅý! @™¼§Ë S3·mCHnG…ª3jäÀú»w-1êöû¾ì5sä)ÍÅdCšÌ¹¶îñÔ4È`ÏàbŒz„ðzm b3/Óti†vèË`5¶Ìu>Ì8c5{@{VüÞ8´Ê…J+h¾ÛŒ¶„–«9ÀØ[ØâXù¿žS+òç@ï(É}`'èW'Úu+ËLuö4VÖÐ$éÛ¿ì6&®¶`QàsN©ÈÑ5…@C`Œä¥­ú»Ì†p¥Í †sÿ{Ž‚ŒÙ]!óóÚq‹ôœ9[´ÂT€·–ØË ÚÕO�_º±'>Óyʘx¼ÚƒÑ¹ß›Ø…RÈÓb}ûjRãšžce)0uàÃý«,ÙÛS´F7{�ת‹S³uç\Ñ_YH°ì½Q6£ãa,áo¹o¨±ªî 02O÷(|fM+Iį¨¦áÿÂÐKe˜õ|®Ê =©íCÌJûÊcRƒÛQÀ¾¾Ô«EÈœ‹b u(á´ Wáj­XfŠ^=ííÆ̯rNmÑén{åt«È þaº‡*% ’í¤Bí¢²uÑÑ3† ¸QUvûÉ*‚ý¤8‰|ï­œ3q7ÕÌEÓÒÆö»—Ûöm‘7‡bP?ÔÉÏh¡X}ý˜…h¦]¿Ó†ÆŒ„HÐtoê6ä^G”}†×›(œÊJÛáB¥ ÿïéßME x —uÞö·H ŸÇµŠ Já´>úã/ÚT|ßl®H9?C8L›É?›çtçÑ]—”–ÊËóÚ™ÅYçÂTÞ¦ÚÈ£®ŽÏj`±3Y±Réy,XA4´uê’è|²–ÇAÄè n ‘„ß0Õ}ºè$]`55­‘Õ©¢¾¯<öW¢ƒ!š"Yæ€:E0ÿB°þãÅXÜsDÓþár¿•÷ÃÜeÁ,ÑÊOÏPdsÇtø£·dóijœEÛ.¥@æ rýÊ( mŸbº|2ÖD&ñ¢#l,ƒÆ×™ö;÷é|ÉùÃ<ñïn­8s¯ÕŠZI'%ãkŽÉÀƒ7ÝÒ[Wõ\´± ¥Iɹ2C:�tØ>ƒh£ÒªfˆuÅóp ÐãnBsÍìw,ºŒ6'gÙyFëBÒÈ/Ô&/xÖ,Wkè!@wp‘úá« ¢ªs£à†nˆâQ)ß³ðûó<#Zyå+Û€œ“ ©”u‘¤!zî&®yš/Ü>T™Ï `8�¥Ý5ƒÜNŸÇ¹‰Ò*˜w=cÒôtüxºº²l:º?UïLÝF:9 ˜üò-BohpµK}„¦L15â›÷3§ ³i/”+[ü`6€w,¯TÆWè=ȧý½¤ÚZ+bFŒ|ºÁJ/�˜Í#)\¦u–Í‹±¿uÔbif”çè†'“mÖ²ø$\áXdBŽw±áÙ(}ôší$‘ÊŠ\ mBnÞy‚5>vWlÉÕö7/#ûŠÇûjî÷uH–f™–БL ™Óï«á¸&è•|ó=ø§%à__Y&U¾±]ÑñœÑ[ÚÉÌxÏ—ž*f{ûŠ>.èë‚Èùyùk(5qÛW"âöà·¾ 1›Þ¡&*7í|uiVZA{D9[È°È£\aMªy\¸0'Ü™NÆüòéqŸ)/›Ú/ÕdF¸ƒŒ‹ë‚?TX£…Øt‹‘ʆ¿¬ŽBÄÓ¥½ŒåoÜRÙh^éZ)°5ÚÈHŒöÐ:Àhãà¤ü®H”ØJŠh½Mô2_–²¾Øï8VŒÀ$è„HC ‚DÜ!øÉÄ¿Œq¿Óß\‹Àyþ²h#¤hA:[Z^à9ŽÁÛêŒAúOúZ®¬¸Eì¿œ´ƒu.†¡¸˜ëi^ôÊnùŽí‹¥óh Рʽ¢Feº�¡wv"†5(zHÀ•=çÒZ••‘;q[{àáT†ôê˜B™3~ÞAæ8áyŽÓ€$!ÔÑzY×Úpé?€"ëÚ}ÛÓÒÜ0ËõÏME»ñ´¿íý®Â+cœ©Egÿ—ºû²ÏØPÙ1¼!‡Lí˜>€ß¸Í…ûö¼›îV+Q™Øl˜K¾º4úhÙl$"z‹Nó;æi°L£¾ÜU(_@ŒKaû6AtÉÑTЀçFϦt¤ñ³y[.Ïz [Í—v(èá(d˶;ô‡={£Z™tÁ= L•ùaÀ;i‚ñ*õùSpü…úXaE뙽ñÍœm ÆŸèðXè8“àè®®{è.×PÚÐ@'P:Ù¾!À¿MCÂܬ׳Š¨X]ͽfhcFó§§ôv¹ô´Uœùúúfq¦>Ë—þÊTÁÂN;õ0ìz�̽§[ÅÊ èà½~õ„ÍŒg,¡ÈT**Î þñÄëTî:­AnvóŸ#¶ºjUþ®¤JH5®ÿ^¸‘?œ¢ÇÀ´ÜæK.5;óbd"‡á x—÷ ZN­”Óoúó™'ΟvJÀJæ¾ÝóLßÉ<â÷F’ä‹[$(˜c…ž¥ïFÀ½LüY^¼hžqê4S‰žÕZ¢#Mà9¤â|› o箞xJÅYRúݹšŽÕ´Ójbx_á;ÿ|¤Y®›Û„ …Œ† 19)Ÿ oRÏÆŠååÏÀ­Ê˯"E`à­ùPúúDÒk:w>Ã6"û&@1Îa&€¼d‰>ƒ‰¬˜¾ Rãd5Þû)¤ÃªH= Ê/ñ¿\­[£‘Á¸0uXtßaDùn^4+p“êŽcÈjFÎŒáPC[XƵøÂ]†ÄÞqMƒí 5ŸGO§Þ¢Fx‡­U[æ!n˜x¶õ,¤ÕfAü©S%v Ü‡{T&û].ò¡=ß?­BWfÄêæ3-ƒ‹Rõ"±è,ÆήäÛ‹Ûµyµ1{œ[£#¤Làñòîg~,zŠÓÀ�M÷"ë' =­Ã¸kïnø½Œtn;gž¯ƒnÃ�/´ãA¤å¬è´«¨ 5Rq@Ù5[¬wÛPÒe˜ ÌvÓÃåê§ëñoìqÑ™¨:T±¦íÆ*=ÏðñPc¾nú[wy3±wŒgÏ!„óKsŸ˜uê3¬<œÃºcؽx sg6!ÚX…Ÿ¶ž—›‚Óžg+7ùÄ%<.r?d‚ÃzOñ<µÄÞæy2Zê–câýRÛjè$(YCÌTÐ@€ §h‰²–Û•®êê €‰§w´Âî´pï=8É ×=zõæ³`{ð›bûæw‡¨†øí¤´éö^ j ÕçwLò"ßqxþ5”“Å$AêÆš!Ñ 8@2Ž«o@¾þ4áókõª/hÌ­ÝÝFxŒ¯È·ˆ–È%¼:Oƒ|Þzò­ü=y™ßœj?9æâÄ£Ƭ^•{$äiÚšRgºýÒУô-À[˜¯ G54_„&‹fV"ci¼ªé,µ®¯=&SÊR+‰¾Ä˜QÁRy®ûê"X:„=gˆ÷/oºÓ¾F«ÄîèÓ·êak·Õتg’G}M Ó¼È kÌK±,07¥íÛcW Æ‚ˆïO—üßæÿVéÿ­’èÚÕ}ã¡Ú+\)?†3þ§7s«f¼¢ |þ*([ÍÊáC/©š‰s§©³´³w(øa¦ˆÛ\í¾h¹–­–®LF>+ÊVwëÊ4�JäÛþšfç_< fiô»;r쌢JÄ—Lüøj¹él_1i *G1Í­‡Gi½çuHËkÒcn®~ï&±_ê8-™þù Â« úùpØK3^ìpLG©Úãf>ÄÈxëý*k;ÈL)žy.?SxOVžF—rƒ¸Òò¨$AQŒ¦Ø~ æ“™‚÷õÏ*DS¦>ï1DW–²ôì—z=BO¤=} nD¨ã¬R~~†gE׿ÌSÁ Bz`¦ [ªFÚÕ®zã8â»®¿X6ýþ†õxÇ[÷´Æ›ëqhäÃxš‡ÈÀ=Ô³´£é(2"éë*’ã·C{Ÿ‘ì%º1틪®iç3¦ç¼ã²âÞBöÙ- aù í£¡š¥=„÷líç ôH™ö7moC½’ƒ‹ƒ $óÎ÷ue)^øòEðïÌâ .î›K<b줂ðRo žÕzÇè‚U舕©a»Ÿ ©é¦¨í€Mã¯Uèi‘«y[  +ûΓŒ”¾Çâ=qˆÖ-ÑOýå,” ª ‡€o’¦‘åD pb½Ï©(Õåï¬+_íuV[€~H“Âá ï "—þ …Ž0¡Ï¶a^Ô¬bÐxXÂu·sö1÷.—¤qV8*;ÛÍ#dÌt¡'Ì@› \öØW€¯f8§ñp7-¶îß|Û¡Õ‘'Ad‰³ÐÁ¸ø]%Ì •q<ô—Ûü 3Žê5,ÜMy*Û§A<ÿrõ•x”!,üÏ;6{£kꌨs3¬q2éj]µF•©brŒQ0½³ š'9õ Ä¸7v#½µ¢øfµVUŒwe-mËB…œYîSOZ.d2€Û òæ”kN2f{¬Ó”,ìééS{ÐMZOÿaƒ l,yû‹Ñ½Ó =Tÿ‹›±© Ñ?5&¾%^ÁÏ1ÎÄ{Q¾‡áz`®Š…+ä Á~×ý0·Õe{öBŒhôÛôÄÅêƒî—F<Û¶ôú—IîUW1‹sVâVbU>šÓ—s*ÿý! >t÷^¤ü(¼•Þ˜ˆñ“šHur%L*òawPôéÊ#ób©—´·KTß|íÙôpe[ K˜ÛJt³ h55\š4™#êMÍ‚äÿcíM¶[U–vÑ6û)ܺ·³÷ÔE*l„0 )kûþÏqã‹ÈÈLdI–ç: {ý[– 32Š¯ð,Ò¹w7_è½ãv²’^8°¼P“¤ꣽÏ?)}&ùª,«ày­BS¥ø|•VÆ¿)?ªôFûèzJèù}ª0YÓõÛIÅe :+ý°Ûqaü—^7+EÝ4ïb®¶[οכ¶¾X+'ƒ¶¾{õMž1÷ÄrY"¡íP ^t©X1Om}X£°ëéÜóˆ›öØGÇúÖÏVÃ) ÌêØÁ—X{´U,æ/Ç7OØ !ónL]]ñ%§w%Š„Y{õ Ãõd8¨Pqù3£Iø[ý§BŸ$ñü™“qkºÐß5 ÓûÀ kžZàék<RÚH/™D§…ŠJþn}Z T ½&îÞ@Ì I~ùI>Å‚ÃHKlaÌøã)®)"è™KÏÊ^ÜSUÊg/�K-*Fèì(æ³–ô¼·{¶_5ÀÈ‹AÔÐ]LÈ•J ŠS÷~÷­‘–«C¼ Ú! B FÀìAæ?6:N�–|MY5N½:5eÒ1Z 6cqPtD``pP™Ï ¼€Ëc»;f7ƒÈ$2ó©­ECbƒ‘úÁp‚ÁÛEÍŠ¡foâ¤üë¡•±2è!‚.B„– ·Ït 6‚J˜÷wQ œ" d’Íœéð幫b xnƒ= uºüúºôúÓ<g›v´ ²ÏE;‚ô¸ß»-¥'³S´ù• qz[Ì�À—T_ÈÙ†g•èFAÍNC°Q7¤¨Í‡ÕRf‰[XÌRfŒ\7tîT;%X=à†êLZî wPYÍoæ]Zè„Ùº<CZIɺ’‰B_v†¶gËàËàåJs·]dáR¦²r™BÁI÷žVBj5K okÏ2‚ Z4Õãy‚d©c»DIjÛUXc·¢AÇìhùK¶oðƒ†ÈüŒPÉk£®Ð—?¦â~þH‚ê³õR̵ÜjÚ÷®îæ✢î&m;„úYÅÜØ0ÝE½œ,ŸŠb¶§¼ðš:¹Øßëþ²0Å­,ïHÚ‡![F’NRBÚI×K{‡¿ï!–1@ J¬)èñA;è|ñ4-è¹j9®Î´¿"9¬zU± ô€ä´–ôœ9‰•ô›žº±šÁfÂzÊÊz6`†z¥äó¦¢-«Î”ëöoû—á OV'4³˜zĺ·€aâfÓ'dµr§Òt½¶»zEB½Z Ý(—Þ4´Âý—°O§]§úb*møÆcK°Ç à'¾žLC&t*½êÖ{ø0D@ÌÖ · oh•iØ÷lG]¶¨'3¦@8G�0i. 6$~Ùf�bZÀîf—ŤÓÉ2cütÛI¢%NÇ/ÛÊUß¹݇òóê‘UçåÜ85­v:ø3¶²¬5û;Ÿ$ã%u7ùÝ I‡Èxª‚h²bñ"ð¾þS3Zhýâ{þ®èÆ´éú™S96¾Nkú NDxV'¾?ÏÅVcß"ÐÝXÚãXòÃô^à„…Ï®Iàˆ”�˜³óî�« :Ÿ/DŒs;œÞÞÏÆÑæ4\®æ_O"ÆÊ�ÆYLW5#¨d°‡Ù&GóÎÖ‡ýUCöÄó@nE3Чτd€´n[¶è!;AÒô¨Ì¿óþô§»óåY‡]J0‡œŽÐ‹¸¹CsÇJy®h¢‡~Q^}_ôÐɘ(¬÷�« tM€¥"�Ñ䢪¯)$½6âìE'þ…FÍÎfD¥óv‘ôcr«xn¶Hò¿oeòö¿·R5‘hƒD\ëÀn—üÃí«H´AöŸõάlQäP7¬7¸\(æŽW/ š>%S~ ;ÉÔpÉ@ŠCh~‡  m!}<-ÜÉ@Øjé!zuîýïè?Uœyä¤}3¯óÙ¹9óžN£ÑêÏL3/vdî¡Ø¸É»ëAMôœŽMÍHR†³:Ž»—îòÑI}ý=Œ+ÇT1Ín² s‚`:}wšõf£Ø®ýuh™æ³¶œÑ¼Z„› Óµ…N{¯ ¾GÜ£|°¸ÔîÔ¿]åW”Tµª¸½ÞÌñÙs®©èÇQMãS xÍ—è“É´ä'Í+ºªî~/ÒÖ6Š”ç${<­VTÒKä﮾Sœì6 !ä°‹DÕWŽ8&<0íy…%”?)þ–ÐM¥;~;´ îüî;̶2låé˜Yûåì}ô!¥“ÎòžÉ!%ÞXZÀÎm«E©Ÿ9;8%m[jþZ ,òS j R~+;PÐx=S† NÒ:þ„Bšxk+GÃ}¸T”-·:Ò¯ìDesúbr å²}÷‡Ex~`b:¢le�M j)•`Ž’.˜"é ]»ÓŸCÿ¤ç¤Né›—¾§ªóÎ%÷Ít¥¥BŸ”[Ñ'pŒ¤t«é }èùžÁ_À²SV j~qVΟˆÔí`*jfÛÂÇwÿ>$4ű7Oe�@C«$­Õþ»·VÅu æc·ì¿�Òw3×K$úO&îÖ²ÏÕBy‘Ó9ŽBæ ú5¹4ýï©.˜9ŸýäçˆLr¦O (Zj`b[Í*Jˆs¿CýS³: e„mtj„‰e3tL&´Ù˜"—ÒoÎõïm¦(óŽ(ºm¯›éØ”@F·íÁÞù-²¸>vW—ë­âPœzŠð’”å‚9p§Ÿy&½ÀrÍ„pjM¹õ+L!Ó&£¯9PUÒz ‡IèT·„÷µ¯á²Øü74'V§`bzÐFƯzÐw–q¶â»°�íÆdi¼“p#œ8—³Öä¼?-Þ�h¤¬ª8Zˆp4Ì‚èüi]ïÌíáü@ÌŠ­QórdÁ…;·Å—™(^# ÊâÒ]Áï–¥×õa’º ­wÂ,¶ËxìÂõ²þò=Õ€X–è³35§ÐÛ–zw¶Úº€aÎVëÀ'\Š¼Ø*øE•/‘˜6�íÁ½vì@§BmN±Â,àýÆ:î©ýÉ戢B-•²B©ô?r#3ߺ„inJs–×E¿g -jç¬XUË·®?üSc`¦=JÀÒæmþÐÐÚbLXƒajs¤¼q§ûÃ�b[øV4¥ ?º­i[sè’¿& žäÍ?|¥"ñ² ¡”ϪÌ»N:j«·x‡ô˜ dܣʀß#2ÊñêMÚöÝ0>”ÿÐv,UÐçÅ) !ýM=Eœ·Häã¬K!ÐR²ã‰Áæ×n"K…¬‹¾±r„:˜8€î½‰g‡ö'Ý ŒaiÒN’}ͪzcíjQLlí²ÙŠÚbÀ³Ô³B•ÙCÏSý§š§V‡¾2¬¾ƒÂŃ܎§ž“ñ”84ÆÒQGvNÎ’›yrH~ӳ̜3½8ç\píZ£/YøœW[`rºEGºUÆYîr�íWþ½Ïº‹ŠÌô`X_Ð>³.Ÿ`n0 ÈžþßÕªŸ ªâ<¬ßÂ){”Ýlí–Ø‚pÅÁi´íü¢l¤]é.À%iñÓ°ó•G°G9;|d‹.`gþß±²š­ÜÙ™é¶Wù*i™ª˜·è/º¡]Ý'ÇÅÉÄä´ÓŽÖåtõxØk¤`ð !y’P¬y7c¾Öè»!êî¦zPSÓ™öÍkm›€Ç‘ÉîÅ+z®=n¦Cá{|<ôF~ô¹]4­¾Ì·Ÿ¢G‡¬mn­K–}}N&;gè^UØ +×%ÉY­uGa¶¶uöôQ®ïÇÐÉžõ®^Ñp‹m‘(Z!xEQ}ö’óË•ýa×è”Gt"WOUjðG¶úZÜ|sãêíó|$æ© º¹Gïµ×D­o»ƒõ›úqµ;Í2P2¯+ƒ=û v ªâ¶r�—J|áW¢kØì=¤Å™ïñ Ø>ô°f‡gMÚ‰%Cé{ý÷-©Þþ÷–ç¯(Xë¾ìLVôÃïÁ–-ÌXÞ¾ÔÀ1½û–­mm½´AAšäû�±r$+|­ x÷2ˆ÷–Æš ˜)r̶’z:8ß §…pŒ¿ø.í…`²øyè d]faG'èر@íèqs…x£¢öMT-J"ßGž@úéËëÍŸçc.Œµ0åáªC¼úá±8q”«2.ÏÉΗ}lé׿°—Œ«Ì‰l0á¿©c6—0Í æçq¤ÿ cò=—wúd“A£äåDl/áéD^;«Ž\Æ¡ežw*[ ÀxçO"”+ÛÞ~öã½Áh¶²š§GÔ.”Â:@ Pœ˜¼F7Ü5åÔ þJØóüøÝR‘YYÅYا�0¶ÒàˆyO@Ó;ÕÜ3Ë îEÝÛv:€Äûp¨Èý)¤xw«W§dQO©3ŸßKpñüWžc‡iÁAj( ’óE‹z QƒîjwéO˜~É(åQ÷'Vx´øOD•8#œu@Ëbs¶€9mâbµh±òš:jfžB&=€öʱüꈻˆ¼ªÒÞaw‘Ôļ¢¡íŽo"º¯RÈ,Å€¬MµÏB&NFóÄj’½Š‰UH¤ïèPî ­Ÿ[Ÿ«!QÒN8hððÓ´jxX÷`“VëÉVjä–€Je,‹þc(JLóñU|2ÎCš”‡„74TEdÃÅŒFbö“–·llÚC¦+ösæŒÆŠë«`ÆìÏ”µ4ƒ‡EbjuÜ–çônH¥n¸?ý'¶p3D¼”«ÅI­Þ}§²‘Æ,ÐÉ]MÏÑÊ]*5ÄC»·=ÂÅM¦—úv¯ÌŒiæ"(÷µ"²¬íú_/¦<¼}ÜÝ@¹z§Í\X˜Bùÿj: Š~Œy/î æ œôÀΣÛOK1lÓ¼Ã*´QÖóÈ<¹1ªk;:É«$€ÁJwëäQäyn¬Ú6^è `f[Þµ0U²ò‰-hÁS•µßûþ½hËÝÕ¬|Â'‰ü•i9(FÑotÊϱà<X`Ç0Ëáî]¶µ! +Ì÷¿ËxôŒñÇ^Ó”2!xÒ På}9éw,d©+æ‘ÞÚ1æCkGˆQÓå l•Çó®ðŸG¨Ê3Ï{Ö0§Y¿·¸ºa¨7}§cå<‰ ¹=èD5K;«À9.t·íÅ·,Rcž%;-ƒ°<–þÚòpØh w¢ÀòšKqlíœKÓ½©`©j%$|ú™)©6n!á`gi "‘ë£8ömˤðÖ¥p{úä)ò5˜U‡TC¦vü1±EÓ}a»*¯úæÇ»D}¡ZKÚÀ¾DMSÅØ8ãä«™ÚötîeÎ…ÝXšßz0›¯,17é[WþÍSypr0ÖçÞ #ú/ÒG5ˆr—Àˆ:úÀ½éëÍv¶­±Ì1óWŠÕùí w˜Ê ë>MÝÉ}³ÓæÃ5¹6'zôó,BÌB¬÷­° mGÆHÙ�·UØ>4ƒ{€ 4®¢wÿ¿ùL¹ùÿŽµ•½´7èæGk.¢Ð°#wo•v§-Õ‹q Éj^5TÖ£2¿E´8gÄXËuôUÞ•<˜QDoÝfº¥tü4oŠŠð†BÓ âÊXíY(³ LËÔi=½)~þí7I=ʼ.[øtïr•Ó±?_?:‹Î2Ö3÷T}ÐÆD( – ù×°óç§Óü1Y/Èñ˜'”"¼8°¥½eðù+ÝÊlî Y&3LÄFUpͧŸyÛ(§P˜ç†îíÙìã«qÁ­÷˜§-}ï.Š´[’KlÚû#TCòëYu¨�¯ÚMõÌÞBd¤�ÇFx”~ð¡kq§s· ò¤ñ)ÌfŸ_ÞÁÐÑΦO½óºÃ¯«–¹äGè— SAtm< ³à� ¬êH¦¾zà3 ‚¸}•dÀ`jóìêþÏë¤ï(I|¶1TT&èPŽ­)çR£ú‚ƒÆv̺«h<ð×™Mó-ô§Eši¥Å–à3ÄÐÊÚò]CãÇñÿ·ªXŒÈq¾õ‘¤……“¼ =Q5Ï·‰ »`À®Ã_ã3c‡æ઼œTë3/˜ú´©¹’6;æe@yµŽQ%F—´<öZ¢”üáOh§M‹ñµ™hÚÂê©Llœ„7ÐLë<j¥”–ÆIç¤êҔĿ¦„’UWeIVYTÝ•cW²¬Vdï wà\¾¶sÞ"·Œ­(w'l—(ØlK°Ó[Oœ†çÔº5ÝC lºiDJs}pé»Pëp}C1Ü*¬  Õ4ó¥Ö5”ÆÝmîºúþÖÒG93MJg¯õlj ÙÀ>ÙOâ7éwe4©ÈXá#¤ôòj‚_ŒLÏ%¨T87Âmë_È{Dqåüã¹Õ´ƒ\¸¦"d±v»†è÷ýâû)VÞÊ+^ê$HwŠÎ E°”J-P4\X¾*: ć:¥CoÎ==r1ŽÿIõ-‹B_4¦ï—8È‹§¨* úø[S€lå C›v³À ã}ôìLÛ3ïÎ7§_7ÕÇY@©zAï?°XÊ <b—ësãqw†èÔìLŒž‚À~óbÑž“¥ðÆ„`N»ü©¨åbYJß/<·ÕÊVoâò󮙥E¡3Úµb󌧫=Ú ø\Ì<Šr70¬XEcJ�tªuÉÃjøZOÒ^Õ!§¸[ ·)Á`Õ:¯Ç[žñ»sCÚbݱ#ç å¤(DÓœa“,5mžÒ@^@6„N¼døEÉ7Àlwø5žašZ»ˆiaâµ|ýô šš29 ÿ…ÙrüÍâ ýì³ö¤î÷õ…ƒ¸bÖþu'ßåEªZ4Ÿh}gm諭5Zý'°5Ž³³Öu »xÆ F?¯0ì 8$VSíAªÐÿÆ8·WšæoìÀ²Â·o¡°™(\ZMmV¥¸ØÑAºJ|ß”š¿þé!aßòÇE£Œ–ÚþƉõ7ÎÙJh2Z´&FkOÙ8ÒÎûN¸0h(õÖ6'Šf›!9`Qª 1ÃèCÚýEˆ¬^W&Âkœ{ˆXZ)ˆƒÃÄ9º-éY¤Y+DF7ùZ\D.Ë·ûK ÝÔù…Šµ g–‚S…¬\çÍ´n¥!7ÃÝ¡YÂRÞ˜@ÑÞ@¡Lº³çÈNÏM•”Æ™ƒC¡´ùZÁ6C°{´ŠÖ3=¼î ãíéóü¯SùCÿ¡÷¥9·Ý]y›1F¢ïBÇEDÓì‰ K’áàZF|é5DRd¾SSÂ^$(”ÿqIÍ,R› •1X=¦+c@ò”[à'hx¦PÉŠáà¬þJq,xÏêÙ?/ô—ª¥ÌƒD0/p™‹ ê:¯; S2ØiÊÛŸ&ä”×t/ÈÛMBÓºãÒWýÓéÈØ÷b’Ä0ÁAuP¥õ”ÙQÀãÒVU±î…ÿH;‰ûà7<ýØ_@\J^ Jc§ œÀÀ:R’Ëþ:RæѾQÈ”\Ï)¹¿ZM,»¦¤|¦ ŠI…1¶“ìH˜sq¦xs'~Ž¯¡¯8á=aÚÕ˜M ÑP짃yÑÊ!ãÆ:úœÜ"5Ö�µ ž÷]3uèS±XÊÖêSén˜7Ð͘­0ø/”œÓЗ€Â¬¡¦½|*=¦7Ì8;:íºjZ,5*žéˆIwç_*Ÿ`ý3Ûz^T¯Eg9cçž½…è“QNñß·Ø·A§üÒvºäÔíŽæûÜ#*3bžDˆD?Š½nàíV˜âítj9ªÙ$Ðêƒ;u«GÿÅï±ÆF {ó§ •5xUÿ¥^ðp¸j6¥˜Qˆ²*¦É8¶é.=‹8øXò oÕš)ÖÙŠ7œ¤5ÙDPÉ\¬G„ŽŸ2õº \#Í€Ý'ݧ“®ð–°æ*¯ŒW½ ÎâŠû6§E¶÷,…7|Öš¶$?oÞˆîÇ8Ã_ªš¨å‘äÏ)y ƒrél{˜(ÒÙãýç$'}/Tˆ_|Rúa%&Á"ýÄKÑÁÞÃÆiä°v@MÇ4 ò¡×'‡µÃ‹`âjÕøt‘ÉÉrð:qféK”þ§[õ@ˆÓZöQJ[—ÿ‡‹Üáó³Ìò>%‰Òʶä�¡<ÑÚˆñ-Ån¡ëÙÃS›+ #Èuiê(!«†Ñ£ëˆrôÄoÐû|,Q„U}MØèVÐ)*:8R–/ÿòFÙŸ;Y‰Yp™S ÞŠy·Òû ¶t²bF î‘*\î-o>{È’V£?ßk“!Í™w=C÷z¶_›žË‡œµ®§íÕD‰½ ú¡ ²q§vº§úã…>Ìéˆ$m‘šçøgæ‹R“kÎeP,µ72äò“ 6=~)·òÅMY¬·?Ón_¶æSg1“ây¿7Öt´=÷3oØt­kd¯~À©Uú®Sô—-4Q¬œ›Z9¥9þ 3Û¡îí+·¶EÁmffê-•',•ã|„•£àáð³6ð3Êuë—ïÂïžÌÓÉšÚ(šƒHcNZ)1tÛv*/Ïç2Žúú€¦¹³ëúóΡØP~¾{žžÚn˜éX¿²CÎÌÒè¤×¬±Ù1¿ï´ívQ–ø„YŠãnõeê5ä´Ÿgë0½ÿ•æ¼ËŸDñ ¡£² ª~4i\Áo¶›%w=¸-ôH‡„!(ÔnC-ÝëpÜ÷Œƒ¡«mÎÃÕgfs²þ q8M9žAý³,—ι: ÒIGËe$•‡Ô;6âÕ‡:øNÉ­Ä3áLUv¹Ô^G”JèC/ÌëØ7M´¼ÍË 8œÄ•ñÂOK»+ƒd·3FK{Æj:E~§<Š¾úö–l÷ k’…>è!ƒé+}ì÷­—Av¯çmý¥ŒÝë¿°}ÍÜ TÎðšJÿ¤Ñà‰Wm9wÿç­îÁÇg=(¹º£9w¡ÍûkAJ{be$JLJoÏ”d l¾Q2<ûñej knó à#Q†BÈgëÌÕƒ[£¾ïåÝË{"%¡Û­Ò YÊ ·ò™¬,°¯-ÿ¡¡²ðÜûïÆÏ!éÍ %Ý•ŠÊ51*,ÚÈØp5³VѨÛN¬ÚÂx±÷8Œ³ ¤{ óaú½ÏV*BŸûŽbmIƒÒº~Wü„ûÎÛi¿ô´ŽÂ2ó%'r4»(Q˜•¬(~‰ò ò¢æŸÝøê§h'ë%ÊJ°›‰¾”Y®†5áî·–3‰'¬ÃfÁø·z´DÁšy”Þ „£¸Œ3E¾ìÏpFš=ZÄÆ4ju�ùïŒYuh&ÚÑy­Q‡qÇ—€Ë 3Ûã÷M{ô·?z@–Ò‘óöØ·ôµ:MÑÓ0e™ÀÅNEÓüø,' ÈUE„³ž¾I9XH_ßÞÑ6ÿn»AÃ[ž¾ƒ‡³>պ󷧙gKòß °5Ýе‡Íb1¦¶%㽚[’Ä©% ‰˜ sLQ) :Á°µÛŸSRü –iÝÐcÆ-¦dúÇ'„z®ŒzÐ5§;t»Ã|OÊЇ^ÑÕ­7ÅX5ŽÈ@ð³ì9WíI¶ ²êz#J áÑ sRÖ`D Öýv€°‹³<ŵKXƙԌ±î)'Ê>•‘‹>Пç‹ã;ÏnœO»mÖšOšÌ9­gªí…Ükæ1 ûÒ°ø+«Îüµ(f’þø•Î¹MCßc8{ÜoÚÅè MF#­JLïyOzBw®¬š‹’ý ô¦ARÏÎÇà rÖ)ü«>ÄÎ"Uœ™“àrÞûìµ[ÿ¬†Õ¿“@H´ë§éÊEáu1÷•ú#×¾œdÿZQ$‹o\u¡–.[¿Ì9S85brVQëey´X­‹Då"íCJã]ãž±±^¼‹ö˜aîtS!é½®. >Pæ® òþËkÌ#ñôMÞÿIÞêdH #G8_ Š¯°CÙKw#"€J¤›¸Þt@­ŸTŸ£ÈÛ\+³¨Kß{=x°‘¸Ù8o¶†6uÚX¡ÞPô®,\DÅøÐ¡Ú –ú(UŽ½¸Mîò4ôLæ(¢RR_Um…»‚²‘sþÛ<¾ }'†$AévÔ"“­´º«Íñ^é*ù×&¡q¢´>O_hx~~yR4t ûîpusÁ™› _ù°#û³Òe‘zH¨ gÝŒ¬,œµ-íá j§tC:±,¸o_þªME'Îu25Jžõk'¥µÅ_¶ñð7ÍAۨ˄##ßÒ~ïÙ3Íãd%ìþà:ëìWpE’yˆC¸€Cú8›|3²}×8ã°Ó¿åß¿ÂOÇåjä Â;Pq®tbÓF¿8 ÚѹNY„Ó¶§ÓÂLm'îñpÈSzŒL&ànþ$YPÙ/‡ñZúBKÈq »Ùà>}ô ÆÒIáÓ'é–m¶ô•âO›ŠiŒÊÎ ÚÚÒ/ƒá÷ ´¢ƒXت§/Z¿Ñ¸÷(¥Í@¥{J°¯§ÒíÐ6vÚr]΄¦Ì¶ÒcÁ£é·T]%áŽÁĬXz¼…ŸùB‰î¸Õ"ã¨yÓÂùÖÑÉãÊ+y@6à¨8Ξ$$VòTÛ&)Ö“y*/Ý!VªLia0oó@™ö»µW@‹·ã)ÃÉù ù`³Þ82."=ªjÞ{3#_°í̼;,ÑSý! ÂÕW<Ý´P A™áL¬>;Û7ª¯ð²f4ž¿Ž ŒáÚ¢úÑÁ˜®Tnà_5ÑÃÎl¼B‡±ïŽ¨A;^)x½™ŒpKi‘Ø| ¦]áã â•FPÄþô³Eã§ìAG¹‚öÝ•Û¢úúÜ�2ŽcÛ8<*)9ícK£]pNVšGNŸ”RïS³Ø_<ôÕß[Ìï=9£Ó;N$0ôc†âZL M e™!ÒŽ>rºÓ(îÿ‚¥kD=[ ]ß�Â^ ï=ŒÝYâ$±+L�»/Ì™¿:Tcï�n¢a_bbpŠè÷r#üÊ¥ûû¾ÊvÔfºö©Üù”2ãÄ—skL¹ôÚÍÏŸŸKoÙ.ôy›ÑujóãNk%PüKñ&à%9ìQ°Ÿ(…m>=±V)f‘÷Y¹m€ý#Â_®ÝO¦<j6‰ÝVŒ}’0x×YÙJ(4„¾np^Þµ"ÖÞ‘9ÆøYÿXÊ#vg¤+ÜË3oº5jìúêÿeæ\‹AÐ̬QîMΨS`êò£·=Ìzð@Óú9E ÝGvÚ²a# õïCF²–U챃*oøÓ4šžÚCQ'¼—›ëØQ(Y.¶Õ0OöK'ŠßXg­+úµ%úñ—‘sÆ•@FI~Zk>o½’šÂÔý€ Å‚X£, Â<Öëžµ=àæU‰›HP5}Pi1¨½§?2ø?´gzf›oÐú­¼®Îw=ºÒ‘Uåͬ ?öªDëu¢sç,ªO3L^¨›±:{,ußP"öý7<aɽ¾>V4“Ëß­ LnF·C°¯Ù*h~Ü—+<àŒ™5ÕHSëäÓ¡ yÝnU¡ kaf}�!Ú)yóŠZ1ò½…«“Ò<k=C»t·­‡`¡O|êZCI³6>ß[ÄX¥²|ÂD7ºÓóBâ㧮]?)lë-3ýí†2¶ª·<´˜G´‡ÉYh×6Gx±Ì-Êp}SSè(.½9S�œO#åß'Á[-š–á>›¢ôPr––ZßšøƱ|8+Ê:ÿt+ ê<Ò¬oôªfV8H æpêT…pZnèhc£pîïzŒ¹øs:L/tt£8.,;NŠéÊ„ŠRÊ€¶# þ˜g¦žH§POà1 rCb)Cb€ª†0/úŠ¦žè §#Ýù¨lQ|ª­VÒÖIÞÎåfîbí×ÇýßËÞe;LýV¢F¨'Þx¢<pKÕÏò\ü+öÑðòl« U´[v‡q¾Ú´ã—°¼ð‡°•€žª?=y[«È,Yå/ˆ1eèg–°ÔýCyÙ¸ó¡YHÑ©û ܕ΄\HC:±‰ÍWõôy>rðü¢ðùiÒ˜¾yïž*Ü–òG¯ù¶¿s@ö.¿±0óÄvZeÄ4w10v:(S¹c*¤êËtè<ÍM5Ó]ó}iP;“Ž ß`³¤Aþ¥Hi¥¬zOxC2¨ij)P$¤¼Çë4†3âj,¹µ£˜?LÕƒçÈëŽd{§öW*øŸÈ@”H‚EèÓ〢-¨Ä×ðÈËPc#Ò 3§Ù¨`:ŠàË7Üla,Òø Ý3í!E5jAÆU˜sw3­`Sœ)ÞN¶=|¿MœúÚ–Ì3ÞTqOgoÄΪfŠ b¸'OÕéhè¦áŽ²•¹ ¼ÊîLËÚªõC’ôf˜×‰¹"L¼yº+'ÿŸøS V„»Ë~ô‘÷sC ¤š•sš¿lî’xjœc²M`¶Â—‰`à˜Èaz®ðLÿâæ§#\É0AÔo^¶ú-ØÖñŸ®7µ5Ë~2ÎèÞÕí©rŠèbFÁœSþÓ¨&bãUYžÇîK“åÇ<§è?Ešù‰;}à1Ë?7!ü8°tÌ— ?zצ]ÇÞUtô¶ÝŽ>_Ó×Ý@©èîÂz/«Ÿ¼!sÓ1ª”ÀZòLÊРa>Óâa%{ hÔ~ƒÁìVŒ#Ð…ã†Ó~6ꢲlºáãEúb•¸ƒ'áÚ±£X}î0wà %*³?‹Ñr—,€ì�¸0@Þc—rYi† ‘/ž;Ûƒˆ2ñ{,^Ç©œgT‹ê×穷µ0á.çÀ½RI‡o¿X #vë€YN¼mU€éÒ}½±| ¼r OUPôÑ_?½;Pc¶{žï<çKIâ›~Òû.5z"ÖÉJçˆ?—KÍ{¥£'Ä †¾$‡÷"±míè=’aç68ò6|ÿ„+ƒ1nê,Z9‡¤&Ù›T«yîÞk +Ö¼×3q–äïq X„>ë:NxÚôƒû¼”ˆ­‘ÿþë!·+É#ãöC1²õgo ÙœÑX0GÍþtú0ÿÔ7Šœq–yŒù‘”ž^Ùõ¶Á˜MscR¦I°¸@TDKe/À×{?=trÑ…é³»ŠjAMURÈ}HcXk…å$ƒ!ÛlØ}ûrOß×zã¦.œGìê‘r†B%,„ÌÛ›DÒïÇ?¬gEVä66´ËýŽ¶f?{“=Q"y3zƒ¦@|ÍÄÄΊÈ×BÏ*<×^òßv8¦YNá!ËTõû…ëÛy¶·‘ø¦Ckù]9t°ôÇP¤ ê¾q_–ð3\_p¤X;ܦA“Pm­ ‹Ò(`Xˆ«¿ST¢Ð‡²AŒ6 J‹ÐªßN Y >‡Ñy`f€*6ÛKßõWú2YÐA£8Ú*ày5‚/WPž }Ò“L,½K¨Ÿ¯ÛÆ¥ÇÛŠ˜š4÷9ÝM™T¼šÔRê=¨}€&?ªÏ>¥ÍS_è-L‚v©¨öÒ®!,ØV "u¿Pì¾3âÉîêA—ÙË€SéðW>15ÆfbO¥"“‚£{m[WáÍ9ƒ©JÞ¿[çzªÏNT;)Té$ ÖŸ¼?õørxÁ9¦cƒîCñjoÉTCç~ÞI1fÙ«ïL…H½EÅ-RÊ0O8Ô%ªÔtõytazÝ憪>=ÿ¿ÿw~£1˜0*®—ßô²f5bšæöŠ~´6…Õív¶ÑÈ@JHf “îÉ=Û‘p‡Ÿ<…ÐÂ2B¼‡¬€yßûò{¹-¾§FÄùeKq´Ö.3[þBp†‰{(é8žOÐN6%ÚaóÉ ÀIÖ?-{WD�ú»ñw¸&yTŒXÈúÙkY¡Û/àwê=‡,܃/T+DP”]dŸg§a`ëÞªÆ(ôµ$á¥ÄÁ3¥ÂC, Îߊcƒþ ç¿R¹cøàæOÄíÎÕ¼¬qÄRŸÖ‘Š}Ý~nïDá 1 9sJ×VNDzfV —–”Ñ8ñP?�ØéÒJsî h} <jù6·L–˜çÎt¶=Ž¨WeÖôío<±U8ÿ®¦Ý),?šeD^ž£Äi–¼OFý˜%ÈQSКTZNèÿVÏÛŸ'IæS´cx@Aò¾S“h ™ÀpIOr±Œ’üûÌô!óñeÚOÁ}§I'NÕ±âÕ‰‰—Ã6 j×æz‡Ýâ*m÷A¥ÔX+ç§dÕ”@Ø#ê÷Öƶ«œŸ3&æçEƳhø‡•‚ø FD\&>›mþÏ,('[×bÞÁ¬\ËJýb¾ÿ É3Éý&Îi‚¾nóŒ! X§¦Ý—A¿hù^dÞè® _jÎœMDâÌâù¿žluž¶îVU«pÏ…r»Õ\"®­Û}tã\»HøRxdAa;Û¸_êÁ·ÒÆ£,á©ñ¶³1‰Ò”>jÄïŠ[é }àâ¹eG¯ òØØ 1ËÃU’Âܲ ÂÏÑv(»nh!ªh6jÖ§ãu319dý‡°½ªTå‰oÍ°½§t¤Õ¥½wkVe&q?rÔŸ²×=#�Á"¸Ì Ø~iûúTÓ˜ÐâùN…}”6TñJ4² [ŸÐRµ3ÐØZŒ˜Î.Ë1:ÀϨ@Eöl…`·íØPâqü”ý§‡”£òàêDhÐ8ŠüàK§NV•¯~MKñ.ß9}ký ‚ EÆ£µŸqZ„¾9¬GvÙ”öq ¸—myÁØ^Œ‚ŠÀûÐ báè…绸YÉ äÙÊï"ZZIÅâÄkøCëX‡þ‡bÙCVÔà½Á°MHB·Æ=â6:DUdÐÆ…1®e“”H#É¡çÏÌyÖçxà¢`ò4äò¢Èøö|,”þ[~ËÔí(CYUyŠ‘ïå�€ÚOw•^“Cˆ"b%Ƹ AGþüeëÚJ4ÐœuÕa"WöÒ�[7»ÓnÓÛÚF|Êp‰9~^$Ù©¸rPû4ˆ­˜ÐðC]á$¬îÅV¹¤õªÜ-ìM(· µë¡ÑGq/U‘€ûv±šÌä¥ãÀ‰¦ÀBÑÚ:ÀÆèIDgÚ Ó-WosËü{öš•9’{0–QÑfÉwƒ9_ªÝ¬>¯/ú|%>F[x+¶­Ã‰QA~˜áXkiï#mŠ?LøƒÔ[¢èJÙx3î5‰Ì=Rº=xŸy6GiêŸk‘˜VÅã»åGcá¨xÝGŽUι*óz‡2JÝ ›¾–µÔ"f‡K¸©ì\-/›ø&¶ÃŽÃ)8&Iµz€``²ÔçÁÁÿqùŸe2Mµ»ù¥“¼)¡™kŸJï@«ýRýa¼×idñeùJ‹Ž´ï>µ—“T‰z<üÖ¡rd<À~2À3Ë ½nUäCÆì¿h­™¨Ê¶J"ó#;äÜcG7:¦©öít^WM` /ä@œT˜öòåˆUœÈÍô¸íË ê®^«t¾nê#Ú~ìjKŸ¸‘Mþ½ëäµE{¢£ô»\,z5U©0¹óŒo3æÄë—ïÒš*ûs¡V�OÆA5õ¦úĸž{ùm»òx«ùäïØHh]ÚrŠQëOGúþV²¥¡X¿–BR(uâ Òôþ¨;5Ì*¦»aÃ*íéFow_ÔQ$œfËúG¿Ösûëžàc¦¬G{j´}6[P˜èh2htôÑ¢cûð‚µyV¬Ì‘éÝ: y‹®5·}#IÐdÍ|ÂãÈ?szæÜ‚“ì^¿7’ž«ó}¤/ 1­b;«/ÊÛÒõÝŸÃŒ†:Cûé¦Dá ؈.˜u tâ{G›ÇƒžÜžûû‘"UÄ¿´f* Ѓø,Ò¢¬m 1/{Dœú–¡ù«—G]ç‹E«¥¦xù¾¨~f¨Üaµ!‚}ù†¾,œ‚¢0ƉJƒ½²ÈâLÇqsÍÙ¡cs%µþ=óºÄë¸3:¨…Ìa2¿{@mW¿ë´wÞÐê—ºY‚ÀÙ \5*¹Âèˆw´@“z뙾Ѿ٘æ¤ håÌîâÇÑuz)*ËÎÏ'*[SÛAÆL·eFG¡nïԆŧþÐW¬4l=3e^S•·/PÄÇ°ckûÇa*Î_°Dn®lU-é–ýáF×¹óeF]äˆÎQ:éì wGdåÌŠ‘V°Tëè“›¡¬ 9ä·Š )•ÐÁ!¯:ïNó–œZÃÏa­ÒÛQË©#}þªÕ Å °}ÃàÌ~A½µ)BT5tž’MŠG¨ U\CPUÀk?ÎÈ`Íî É8‰¾´´ƒBû‰)l‰„×2”„è/,sõbJ?}ýÖ0‡°®ö·™¥ÐÛ‡‚!C´,ÝÖ“B¦ŠîÛ‚³´a³§ø’X#ˆ‡Àï‰nöÈ^¤ÀòƒP%¡g\ $K¶D½NûT¼€JTÒÓ9eÂa²(ܶj./»ʇ3S†%& sµßÜÕ{Óݱ¶3Æ ¨3)œlÒ€Wš¸T‹GM”ÆÑÏõÎuDü1.~]}3£ãí/‰U™œ¦>…Ú†rž¢· ÀÀËâítà:¿%ŒG©‡/d¦÷ñpuž/V%yî˜ùK…(Šœò¶¨AÃü¶`é‰È ë¨æÛvRé˜È„Ãæ �Mœr—)Kç™Tñ$Áã¢hzv¼>®–:õƲË÷ZÇd n(0²Ê‚ü½ötvÇ+-‹z‡�’„¸{Ww†U®'§'TÄöô7âV»‘e‚Âhì°Ý·BVCd_\ B€ëçŠÂ§"£•__(ïÛ»aDGKÀÿ÷{c+sBÞX)fN”ÿµï¶aR�:²klë¡«f~Ç4Cb½¡¬Æ¾ÖCFF$LŸ¶ÿlÆëÌr˜ÿû–*õ WǦÿ™ñÅ´”š‡¿` x¿Â“'Ø­;ƒðhÑ$ÿ{šq•¾\¦Ð ïÚ_HR§àó 9‘7q'WÖ“˜i7|³?M7…¾Á|sÈ:Sέ¬'V¥e Īh+ƒDà]Þíµ$7ê½Û%;0¤Üþ0óÇî\ùû+ƒ¦$\‰ôäT)Æ1›9ü÷Ÿ+UY�œmˆÚKÙ(6×ãuÀÌ~<]®³ùןBD¦Ó°;SB®»>é°Ö’-mø+l§“Á6µA‡šPo�¹.Í*²uãÓúˆ×Á5“çq:o\Ñû#:»i®ƒ4XÌ–¥B7{< ^¹gÏ÷_ÐË(ó¶2}æí• ¦öX@ŠZºˆˆ@C€v7Õ¿C¬j ¥Æ63¨±ÝÖ“ àã–W;EÖÝi1‹¿´ˆBÿFÑi ÌYÎ;Ï.œ7“¡Ô×꺺D »_ûª%7%Tû¦°Vµj9ÿá@oA°Â‡Ah¼Ð:h m;1ÀhÛúý,ؽ_ùpŒÄ¸.Ì>z'ã`D…”TuE#ÿJ†w—®•ùÀm†Ižú*È÷Ÿ†i—pÅžu6¤¾P•ª9,£;[j$XgÍíLö¦í‡D3Ú_m}µšj”ú‰ ¥^H+ù›â#êš"óTScë/ƒÄÞ$D¤úêùô–ÿað?3˜Îà ŔÛÉÎÿPî}C¹K0+Öı73ãߧX™7·a±ï6)¡cû�¼¼=sƒé×­Ä•ÜL²‰ b:î‡<KñùÚ¢lryÏ,yÌÏn*ì47Ä¥Q)‚­NÔ©³=ËÈö<zó×úÓåwþà©v”ìbˆ‡wU;Išªjh ºê/ ¬{äôR4¶éžW–ƒœ±Ò }ö¹Õ?A•¶2 íU׫&•[2^%µëIh¦Ä®Œ“™¬–‰gŠÁÜõ¬àï4<ãÒbÅq^%TJRâ±£vd<¯l‘ò­l|º*ÞF(·t¦l»)·‚òn‘\Ðö$}A“o…Á*ÑN`ŠÉº„X¾ŽK¦ó¼g0ùŠû푺³Î*+‚ˆþ`ë¡”PÈxrw0XJí¦ìw)Ó!íDkSu¯¶‘-<Fîò=GþqÃ˜Ý «óîË;6¡(VS’EœúNúÆÞå ­Ë5DЉÞøDõ÷û§çÀhK\5òìíüÿî¥ÎY²xE.L)ñOƒª^¼·TLn'¬{ëÌ�SýáœñŠÁVT‘†A2¶nøŒÁÔ£RqOBÄq_ •qîQjØ)ºŸÁdµ•~¬á¤õÏ¡óÙQPEÝ¢Âpb¶Ïêš,uE]ÉŠ#jƒÇ"óÞÃøbÜåc-ÓÄ×Æ/Ych 5sþòˆA=íÐÖmf;¡ã:ó<‰™XžEì+*TEìÏ]AˆCþ¸hþ y¯9»º‡_õþt4Ûíõ 2VÝåP]ã–O:ö÷:íÉØ.¤_}¬;ÎTo‘B¹§„Œ!·Ïdm <l¼“ôÁ€Á ¬Ÿö“æåò>6uûµãöÊÃgl)˜XÅ ŠÖmãÂKܲÅpm¿CVœºµ(Öñ"TÜvÖ-½åz0Þ ž`‘Ùw®ç³jÿ”®)ƒã�Ò< ÆîwN)ïÉ4GÚN÷õ¶Lás½Y{k¸$Aú®s¼bÖùðaÇÞêí üž9®iZF‰ŸA™­Å‘™n:ŦîÍtÇkŒíº¶—ŽÉíˆ3²ÔÛŠ“ôŒâYÉè) 4”è½1ýCŽ®w™‰ÈH•K,Mn 8s{EÖ÷õÛ…]ª¥ð‹Ü!²Êå|<FàUÐݶ ' =õãÞgý@ë>¯bE±(2Ÿ7­šj¹z|S’fÙù¼û»t¶\IQÙÑí·•+ŽÌ‘m0~É!Ö›RÓód³¬YË¥]˜¥dHOåËl *L“d.èÈú|÷ÄÊiáÕL„·.tÓ0 ëÖ\ÜoÆ•O…!5C5ïðî!»w}טµ}ÿ4AäÛË™õâH3wø2,öM|éܾ‘å [£œ»Þõ*ø}sŽÐ[Ú�Ó²6ÊAŠq8éŒæåÑMûnô¦=…ÔQNRÍTÒ‡w:ÁÑâî<1ÒD´º+–0H{Õ¤ê?T\°´²)2«Â›æRÈ¡ v–v«_€À'Þ¾—ï�?5‹ÅÊEÈðª©.ÿÙ·(2_0…s¦nüôléúI¡µ£m©ùð™Ë²oÿÒ©Œmkfùú&p{»B2†ÁjI/7ÅÌÄf(l ¥ú+½<wÎ%|N甋¤åÓ° ¨w³Ýó‡'l`2É8õV s3N_<qPK…¬’}y˜)60HÛÌQùãú}³Eµ$uSxvSÞ@Ê*±vʱTót ª×Þ¦¯AÞCúêÚÍK‡=JëÝ9”ÞØ,‘Ú˜5ä÷¾¶ÿ0#³æisº´l½L0“ÄÎe*WKZÉËò„_G8¥ƒen¯L‘v¢ò÷­Ãáw^×ðlè)\[3ÉB­[.Šà´~.k?LJÌæeÏÖû‰)±Ö4òÕý…¯…ë'�ͪQ;”)êÃâÜã ÜØH×=Bùºƒ¬qß×´«DŽõFYé3Àþ¨Úѵ¢÷_)Z¦ WÖ)°‰£C!ÜzÖ,Xróf$¦˜ÊC·¾e™>ýŠ\ŸÄ¾Ž.Ý¥ãGDN`HAƒ&8B‹^*¥Èì|dB¿2r.5ò°,=’E ™PÎJíñÁôçxžº_™YFizÒèô1tÜ—ÖLý=ŸÛ«¹( Ös}ÙUœõë7R¯tìQ¾Î9÷Wœ²Ñxê ¶äÃÅ?Rìûe{N{¥ÒOÆ¡>@Cu]{÷xe6„iª3åÞ¨–aN›=í‰ÐŽ¯žo ,M5ïP×Ë0ižÜb™ˆ +ï2$ôlgmç&_÷?¥4÷ž´øòèV§ P£ÆÚÜ&Ù’7eÍt:,<”rW—+ÅLÖ¼½u¬ÂÕŠ)ÑTÍ<€¤Ä¶¾œÞX Ï;œþ®½d …Œ)�o[ÄìöìiìÒjÙг‡Ê.¦<O¨(Ñ=‚îÔuÓŸ‡×çq¸2aÌMïl<{0HϼϤ°/”~iœ­Ä9 ø3‡œG4žÑ¿UŠ´ÄYÍæ¯Ý‰²ˆ'M‘_C1g§¥”!Þ¿{J¯Â·¦%ÀËB§µ)rø°'~|3û[‹.‰óÊÙY`~ˆ1PÄ»É#ÉŽ”:!Ì*g1ˆ ý‹s 4,}ÓIHH]Á#®5›@Þ.$³78±bÈ÷a0Šu?ÒÿãŽäázðSB Ô mÚ m>Õr@â/!“s/xtVà±Yk<¬Ú†ÅýÎYã@¥Ääãw~ "W)¢¢·lî'J¡ÝÐ:’=–)°>(ÊÍ5Ó”;ÿÁ!®B¯lŸÛP€è=äVÄ›:"`±‘¿Â $y¶¸%AÓ¢ýþåY,Q à7ƒo3>' •®Gá"mâð|ñãm=¼]9ŠÐÍé¦úL« ¡hw·ÈõÑÞìÌÔ‚I¾ïœ0%}J'1NËÞd¸Âµ¸ýY”¬WÊßüÂØç!ÑÞÛ º3:�YX[i”âby [d¿ª;tØ Ù]Ù|MPêa™”)~zr‡ýŠAŸqbáõË€üÿ Ý×ò?ú5çñrrG¯»gœtË´KƒâÝS  dþÀÔc+\‚˜¥ÄS&lƒÀœù…½¤,ÌbE•v4iýyÄþÌåÅaö„eRT-‚ÄöKÅÂpé1ÖUR¤Ý >ïò¾¤„¾¿ä±hÅ@XYáÔ £k»ä…ŽQä5bb>"öörݺ™½øû½µWá»°(dNqîËm‚ý õJ7õ(LwõDÒJ:ã$©ô2ôKàZ”«ä¼5¥å$>>È\>æÓ”ÙÌü¾5® ýZ Â1΃tüTÙ)v@8õoKwظ2nTÅÇÓÀÁJÞiý®ÞbÁ S?*†ÕuÆ=F LEe‘/?a`ªå&†H-Ã~ðDÖì^ùËNcœÆ™ç •Ì!FfªBRc½¡{²¡x‘ÌšöTî¦É‚%õ}‡ ÷à_Ñï·a¡2³ãv@Hí½‘Ÿ˜ƒ@S—¾Hÿ¶HgáoD@3P5²×ïEZM¾Wë|æ‰ûÿ¢Ò´bÎæŒÊß±A>ý2Óέ†Åô¹”¢Pl«fãÃ$Á/aÞ–ÚdazÑœÒÛ[6ÍnðNÅ¿Qz²¯™Ñ΀ ”K["Ø¡Zc}áñWŠl-"ÉõÓ»—^cðã¥/ùÒÇÙŠ±á·ˆ»ŽNbOÊÐŒ§ê“ëëZ ¥««pø&ôæU­ºï®Ùd:ЇþÈÎWöâXo6}7»;d Qæa(W/f-“Kø ®Lín |ôËîVøEæûÃ…{ »øÝ»"¸:ÐáwêëÙÈ Ý…ïÄeê>ƒ¾øû¥™ìG¶ìšìa‘yÛî¯0VAÊçêéšßA£¸Œ£UlÞìË 8îX•Qü ŒTû+G|{±HOÞÍ»Dú\¬àaG•y§“Ž<‚ vÏ®3&¯¹½Ï¯“ª|eí”}VN§R�lQHËÍ= ùé's ýI£Ž*-pI­ŒàÑëO“ q×KÞ{˜4/Ø×4]ØÞÖg*Pª¿ëi‘§&š0Ⱦ;BSû¯ U‹ÐWÁÅ¡Ž“7À–“u9ºdö…™Qêpf†Qw¢}5éiYrÞ#i§ÛÖéË°h ¤#ÿ‚-–-«4_Í­¸rHA R!Âmt—O’¡2ͼuˆYzâ©À£²­“w¨ûëí«CLTEäÑòéCÏ´Ncç•VNÙ쇶ëFZg/Ú—Ûd(6¢$KËÍ¢OÏ\Üìît X7øÁK×µ/þŠs3çNâ³ãðb‘±§Y0̯ÚÁkÛ5 Ös~ßÁF‰acÞå³>_M8#(a&¡,EIžjŽ©´:È&¦“ÿP"ry©)R,&ú¼Ó§ÇèC:+ü=«þ öìO´ *ÏVƒ=<Žt¾µe¨ ŽˆÿbÑ¿âyyNÑ"i4Z]9ün‰^é¶ÐÜäeTËÆf¡ôøÌ'¾ù‘·YæP Õþ¢f”%„Š)² Y5$¾/Ò'Ë5¶‚¥÷è°¤ç¤v„åÚõGÙbÚ ÿ¿*Te>³-¥ÀMüGÓ�ë%½i…hŸ7Ó|ÒÍ. çÃ;d]ý× ™»·}üÿ Ø:çi#ø+¸`#^[9–+ø¨î/èÙ˜N¥blˆz9á[ü÷Æÿ:§ ôj«8ñwf›Kìù?¢2ГV±«©»tþ¿ü à&" —¹::7Šù›Îòàå줤k©=F¿>ØÙD”ÿmðPÌ)à'z�ÕÖæP‰íüþ¥cû~§´S–‰¥Ãíç… ÕtžN"¥:vº^æåŽÓW™®ZiŽeõ ¬›1þt wÓ29Oo#ݧyñy‘Æuê¦R” åŠDÁ vÚüüjPì; Ãé$ÂZp*¥Ý´Ž9Ç?ý"òLöD˜(—ú­§Ù±?µ»ÙÆÃítÁÊŸX%•×`–öïX>Û4j,×?gðŠ„ï–ËbËÅ>ö´j‡ä3TGAd°â‘ûãi¸sñ\º'×Q —&ÙçÕ›cã¤Üÿ®.ÉJo±Yq­÷h÷-e³~Ÿ—Òîj§åób5œ`ØÍTz@¦œž¨h#)ap¡)k|è¿óÍp¢ò œ;‡ñ” s¼ÍFû/ö%¢¨Ì¼{ µë=ü…O´q4QÍ8eêàëfRÉ©¾È7X¿®‚â´r_ƒéõÍL;9ÿTó†QÝ°¦˜ª ¶˜eåT†êÅO¬Ð“$JylÊ)Ǭ_ªJ-[‹ÃÐCAºÂîÅA³ÏÙ�Å4£º¦¡‚ò¿oQùö¿7:t<u‰xHé:ɨáѵ_ä ö›”µ¦Ž|Éxü£Ešp_°ûÑx°º5Dê19-»Î 8¬¸[»ÖÓs8µý¤¢„¸<SM0×vºNìb—ÍŽÂ4´%Lnt‚Ì!`³,ÉnhóÓÏjx-•#!ÚŽ"A2,Þü ¹å7ÁÖ’ÍIwx—}í¹ÜïZ�q7[rкøêäáÓñ÷1IÝA^±°ÇŽò“FƯ˜Ð *"sצÒêå‘“(hOèþ žQ´hÏZc 0ïÐßU\Y»P Áa÷HÚN£þÞ×.7Ô Óº;þ`ô…ÞÞâ"¿ó]añ‘<'¨,Åÿ,)6'ªµÞ¸;Ó¤ OO™Ô|ÓØ|„eléŠñ¥ñ ÕtŠ2UÀÀo@mš- ‡Ž¥UJiúH¹ò¾»Èäø½›ù(üÛ|=÷¼ÞXkasÉ(¢n½TúH…N}•cLîÞ…ÉÕ<±ÉæÓüÓ¦*¹9Ÿ ?Óüãã³À­s×ûúÝVfJ’ãÖz, ß2fiæMås»ê©"8#M¢b·A>{WÐu†-P«ê´<sOÓý_ˆÁ»8›þÛ¦)©¹˜“®ŠÌDÍò„éaC ´3ƒØ›Áû·9|â“žÔz¼ ¢Öj꟎#Àf>[&¥p<ïv=b0ʦ_pJ_ƒ/,ƒ~ ÄfØ*ld•+#cúxÆÒã„ÞE ßímªçnxªäœ'N ÏŒr*£¿tö!uÒâQ@#vL{N¡þwþÇEñ·ŸöÒNKß>>á‹ÿ$ók°^(¢+6"À‡™®za ,_ W¾Ä…1JƒŽûh×f<†é¼ƒ$¼}ecˆ†îëùû>.†\”N �mÍ—æ<‘ÙkÀˆ-½Ôzȶ]€x—2Ê_fx„î†1”Fè‰-K~†ƒÅðúÎ|§'ºqwg×ÿ?ýÿïæ4ÀÆÌìò}×RZ`z“|3~¸)NÆ\š“)ÜÝÓ °È#aÕQØÍ®l뻚ÿ†œL¥ŽŸ jÿøWVsõWé=¸MÞÔ¼¬éľì!Ž-ŠR·§*σ¢yWô](Àa~ºÛEIå E:Ð_ëÚÓ‡8¾SʯL6ƒú>û{½ì‚ãúŒJ¦A»S sŠ¼s0ÂêYÚ+ýaÁFg䬶}/öæó0ôµ4]öø.½ÒÎðP{ dO¶hä¡õÔËpá·A;ñ|/ØòZı•bÀqqÇÁvÐ=1Ñ{WÐëCÜt²ôû'VÅ lgÈ)Ñó{â4½±eÖwµ?;ºkäËìèOH߶e&bÐÿý¡w&ž 3éX_&gp»ý?ï’îcC‡¿rÚ¼¼$ê¤tÆo¶y$çOÏó¼½Î®Š»Ù»}EØgJ·v=d%±îÿÖkH{ã/z’ig«aEò;‚¿s2ˆTEÝ8ï”Á1®(Ø,¦¦E`b¥Ñžõvê“-\f>ñ˜¢�žGez¢eDKÆŒ¿æ¢¹>–ÎYÛWAºŸ5®³‹ŸQäTNël˜øGÛ–ß~¥Í_²o5øª|¦-˜zS !–œä ²Î£ ˜(Òkîò†«,<$"Kow%Z”¥J¨"áŸ&±Î¸ç¾£)ÐÂó±=»7ßS‘®ÜÍ”i^ß¡¿¼ß+f‡Óô¿òpwÌ>”~>QÒÎÁÉ‚?YdÅʆG!|ü>ºÐ@]¯†Ög,Ï~C(ˆ"-£ # Ù´EêÆLJ¦´ ,G+©êo i#« Pbâ<Arí•ÊrÛGjºAä í…)€ÆÓEm$•6­LJ¢ë¹­ÒÁz™³\Z¯›Ú" �­Ñî¹ú—Ȩ»WiÞú2N•Øe’”5Ì-2“GphO¯Õà˜rñÎM¶½>BÖ : kAÁ²þgûÜ$ÑG–Žp ìû—Çn¼ˆS¸åúÿRH/Í}Ã0cašªSÏæXÀ &£¶]Šuiª4ӮϖzÄäÉbÑZo»/ |¸£eþ@Õ<ÜñRŠBx^åΊš‡ï!Z!¥'š8¢OðWÔ8k(B8”Ô ¡ÛŸ!›L§vÐNï_´ÊÒ™¾Ô´ÏƒÊS¬—9‡|ŸÀh…MÝA|¿(¹Á£]Ú8è^éû–¢hL)f.:÷áÆ“Rþ^eE²"V΃c4\ض6¹‚ópXÐ(m©*ì±ýyåc¦˜ä/àÚъĹ-±nÄ2£q½·ã hõš €&çGG7«’@^ÄLƒÝ¹0-»ûKŸÃX˜ÉÖØAãªÐaìhÁˆxcì• ÆËÛ:0·EäõÄpèÙæ`óI÷ bïí?ìŒfB[njÛ=Üâ{S†Š¯¼™¡™$6lôÓ¹Õ—ïYºÝ Qdzšw š,¢œ ÈåïÏÂŒÈñͩò½¶Ô—Tà€Wbª€Žõ«žCf¼¾™¸^-3U»}í壔.^ãÉhÆÍâ(ðô'¿afI¬£7xUØrßMk ½WûÉ·÷¾i0¾šd³1³àÑ~±T*�Ø<˜>ô ¥Ñë'r Ôv)ŵIÛBo’³…ÖÈ7hÓ—† íg>¸˜ð½‡ùFç´ôý2(˜àÕœïšæFâÇÁæ³ÀÒtRpw»¸#‹œ!1åvoÎZÌœEyÂìÊWð0f¨¯›‡-T™7¿W¾Q rñ¯yó¾qp¡©–N‚rð”Ôv¡•üõ <ì{ö‘ÊÊ9fQ-À„Mˆî¼\Zg«‘dÕæ$(ÚO'êCky'ÝHüjõ'Uæ»~e¢pÔ·^¯sáѦ¬¿@º9rŽô¾Ž”õGVÜ+ÊtZ ¾�ËþÔS:Fµ°†z6Qt#ì4´s#zKÜ÷Ž¢Ó1õ¿»Ãf¹ÃkÉp"ZÞ÷télytƒ­¥õØò$¯¨àÎÌeqæ§fÐù.‚Èb ^ÑZ¿& ûz)ÀT: ÃÚED¸+ŸšƳ<Aºm¿fÄÛaj©“˜ÑçÎËÕÆ£[§ô„¦>°ÏÏL+«Ád©Vì ÐÙ%R[û´¥ ÿ‰åª%&Ádä/1·I™­*Ò,h ´Ç:σ>6Ïz­Z![ÂÃN¡5˜ÒǬˆ¢tÅ'Ž-F(ñ·ïør&š–›èÐuõy‹Â§kš‹<?w·÷ª«‚lûÈÃŽ”9OÊ<‘›ýR“׳e¬V?Ã`»ßzxRwäÉ!|4Š¸O¥‹ãï@@JsSëkÉux†nÀö—…}}~ w®€…Ñ=]šºyó‡*Žm­@!)8úú<u=ÊieÇiJ q;ˆWvz€ûSÑ^,…bZ0lhùWXCfÎË%¯ùûÞÁ«µU*ïo¬¨=¡&¥AÞQjJ| ;cL{ÊLÞw> œŠ“^ù §¯¥kÍ¿w4r¬ ª‘V+ƒÍRqguŒeÕ=ÀóŸgH±b:LŸYê;†&.%XÌ êñI›…âÅÇBϯÖb·þ!“•'¢¨4´ÉNÇù_Ù’•km=*\Ó¯ºÑeæÛ©>X$Q³·åz¹RyMÿtmk_#oÈ«w%ÌÛ’ùËÖíÈô›Æ ‚ ⑦¼¼ÑKwPCÿ²˜AnePN»µ+Àåc¢¯ðoY©3ÜH5XŒ_¨MÛ2¼oÌ'øH¾¸È‚åBÑäÇÕB1PllWHNOÊ[.ÒZv¬ÝÚó`l XâÜü{³EÅ*TÛPôv›-ÝÐa%…-› šøa¦mÆö£gŽ3i‹ Þ‹…FkE;Òñ¸Ý²d ŽÊí¶>’…'5úHp4 WR0|¡š²?[‡“žBûP]õ%PýK=0�çæFï¸cÇ·a¤[½kf Lê†2îéÍ“¤¬’ ƒwµ#wûŠþStSý”دú“ð’ 8Ì\I‰fãa`FœvUIýŽ~u寇R²=}àóèµh`0c:“”§©tµáôí8W –…á,~,TR~6¾¿áæj¹¬¬'õ<Q,á*Ä\¼èi¨5*žÈ‚ Þw†õÁ;º–àpbLcÙVÃ2¦åWü?7Ó(RìØj¤5Þ Æº#2 ýiin>^òR÷Šy•ïðM/r½FQ䤹PR3ÿãT½÷õ?Hh8åü?ø]؉ó³„è&ð‹ËÚ³õ&é'ÚªŒ€óB>&wæ?­Å6 ¦?ß·† ×uE 0 ²¯½Ã§Í›zÛ9¨¼Ò˜|ë]=PŠó•²4Ú^=‰pÑ’‚‰ñ#{æp.ÒííU¸uxc&“|w4c¬£{±æ×~¤£º/*1ËgÙSÜ«Ý(oç_ðë6eµÒT´Æ¨ú§¥{YÌ…êÏzSojh:u­1¥ç·¥eÛµG–M}°Š³ìæ¸ê¾h«_½6ÝL«óh‡¹‡žNZéxy—÷0kvdj21°7”9µ½YEãúNµ\Õ ãÔ0ó9ž!›¡53ûŸ•³;d9ͽ+O2»”^¶X0£ÍÇ23=ãaÃí®é'wÒ¸ }˜9Ýzúˆ©™˜Ë”*f´Ìs¤â›M�¿_<0oò:—<ê9RÉ6ï^I7äI ¬Pé/xC±µäÎL¹0\ÀÓ}‹‹›t¬‹ÃGZ¨•ç ˆ!¸üÐp×{J8ýéb¸gÚ‘Bž:쟙1Çžã0c&¹¹ž-ÊÎJpKPï½Õç™’%kªóWEš{ªê½�²t‹ÇÜä ó>fL½ñáþ[{žLg7¹7‚Ôýc`ex0|:7ºß|:\ª(tÐUaº¤A¾ï4#f?1êú×\^Ïçþþ ›TK$È !w×TäD_Á^üÑLTzc@Ç°´qa÷ÄÖê¿(Wµ‰g >O%Ž£ð»Oi$[ &fÎE=YŸ¯(ô.uE=ÿ•”êÛôô€êB¡ n ]­cõ-ÏÍ'ÆÎÿèå”gáj[rO(|·6±¦z¬ƒÓt≮ñk?ÈÊ9‰ýL“ŠõFd£¬¡EKôƼÕèÆ×½ÁüUL<‡ƒ 㵨ÙжÑ8驴梑W@²Ü“Ú8)ý»”á.-à¯Íª M¡1 $ÖIN� EãE.Oäéáþw ½ä¤f@^3tdów†ó`ÜÓÌ…Ì7;1R_ß«œH4þHeô¹?U‡¡¨Ø›†aÅÎÁÜ5Ìø…fw\ä¾ÂdCÐ1[l#% ¼ÞÜ *›QQ¸) £m/m$­Å7$þ„_=´g¸MÝ~•<QF/ÃpêïÊLf¿‘ÌŽ6�–0]à×°Ò;ô2.H¶´a)gðnf#c5ž‡k«Ï—¾öu¤Gz}]#/Kmô“âóŠÈö ƒ£zžQÃRcž#þ9gª ªŠ·"¼±qàwüÒ$² ݘvl¨©Í”Bfå€R›^îËDâTb‚Ç ø4Øy,¢DYk|¦"÷0>XDqêÒj.Ûš¶X6ibš²î¸t>�•ÍŸ®í¸!óus¹m+¾ÃYÂj‰ìt ßîóèIúk o’ºœ]fê¦IeÕŠ¡‘Àµ† bÙöÐgÅ E±P5úÐ=sëHTàiµSÂŽ]ÿ1Ûgú@0°°ÚÌX)”ÄÐí?ß\྾¶ü½…bÐ}é‡ö.ŸÑóâÔKÃ24„Æ"Z=)î,r: òGèOb¼Ikäûèj®ü[¢Ì³ídäpCÿ—¿P7H"jm%88]‚ö‰¨FÕýÏ{úœ伤øäÛ 2¦iè`,e Š˜¡mÓÍ.Ëoú벿Õ]ø&ÃPÆN ‘S™Í>Ï‚ê}T€+½3Õ‹Ö€� M–Ÿ¼ùQ82jÐçt£ÌëvYC(ùœaÇÙ¤û‚S ê\ÇÏ/ÒY²›,&Îe¯ª2š®» Wâx½Ïý›ãÌwK‚¡×@ur2X«{œ•tãOÓUMÈPUìæ;kÊU\f+ð6«ú'ÞàüJg"…µbuâµ²Yîà¼çbÿJ© •1íµX§\ÏÿRxÈäûœŒ_éII];ŸRº£çò×Öƒ†JG%“y–<Ÿ×F$8o!ùy~š¡è¦ ->©Š‘0x4–-¢”â½òˆ’yK&aÞNG7g·øÞ@ÝM¼À…θö0÷gw8èO” tÚL0cœï€ŒbýtÌI¸ÛS²þè?Íb_¾<‚‘—tpLÀÎÇ­,Qx³ ésÉhõÎ)™{.¢%p¢Ÿ‹­¾3ò5¸_uƒ1¿b¼Å©þà.ewå?ä"óœaØݺ’Y?zR¬r,u�ô ÜúgaI7¿(ŒeËæ½{ÜÍ+רnÜwv,ëO.îÎ/,À؈ãT ðpñ”NÇÓØד¶ÁéÁkúK¬|$”c‹Êùѯ(*²ÔºÌå•—?¿ýlÔÊ€5NZ…Ñ©!sÇG‘,_õP;RT´Ž²"ãɌõ .è üs¿`ŒWÒñtwÁ,ç‹í²`”};ªº´Hûþß!–i‘¹& U]sN{RÓäú³G È ÷õÒ?Öý‚ÇlO§çH˜¯XÛ”Î}£r«Pç}¨e6Ó¡¿¢Lsò¡ÃÄ»¿7¦¹óÒãvÓÒ³Ú}:º]Ó±p§>°ŸÁæ¹' Î-7®-QåkÙÄfOÇÑÿVY¾Rbzòj‚pÍ!àL)`ëk -5';õûç¨ôT z> ÒÎv?Kfž=š/F†NR/ôVÅF‘Hy{a°åF;Ÿfb„nFäûú<³Ø¢GCÿ ì?VkJ+Þ@³#l´ý^„Òì”JF\¦äè,ÓyW±³,]ÀrÓÐæí6T¯oÓБÃRHT0Ÿ†;(Èè?‰EG¦�ß\0ÔñDjYÜ£­ÏpV)Ÿ§ÚßI™¯…)BƱØ)Ü`:ax¢øîJÊ0•T#6¢uÁ EëŸÉ;:Vf¦lME?¾;[yž¸ÐÿÀj:ÑÿRížKr¯5r…eM‹* òO‹{JEÍÜç†ozqÇ|a1Yª³øœB×ô“ë»Òò@Q¡#Âê„ÀÒƒîÞõ›ï\º|A£ŒÎZ¼²ÛÂß5CISs+dATıñ>U…Ž$ õÈ ûŠá¶s,B†Tòj¢å1Wá"È+¯ñ¡„2ò›L蜟üÙ[*"ææãvrY–‡Q±ÆE„Üûl6 Û­p‚-¥¶Öó57¼ÿ¹®3¯ë±º`"Ô&‡¾8—(c­ ¦,ÉTþmmE)%ÊóbÅ3 c 6p“ 5¬Ð^†€z à‚`/ZÚÛ®§}ß×ß 3åÓ±ÍYѲ¶aggãƒsÿ÷aýeܲ_E"dþ~Icm}þÐavµçy«oá·¹6Óç¤ÊEK vk„Ëþ߯@Dý3†íC в2 ¿©µbqt,¶,6 ÷îw¿Ìi%·k±‹›éy¤šÚ14pîT‹ÎÁiF±@»y?L’î]ú›Ü¸:u_Id_Ö8@@ˆëÁº·"šÂÎAºNËÄC g<ñò ª•Ðmù°ãaö,Dú"’WK‘dþ߸‹n„‰ g÷'žzQLba�I,r’íUߧŠŒHœÎºX—EþÄß,è?þTYܹáL{«Íâ f½pºù0è :þN=‘iÚ#Ú×a”‡•‚§¥òizz.ø#Ƕ‚E&íC?„âÐãBe8 Æ“ˆFeÒ¡#|�2'²‹ÍËs jˆîTŒ¢»+û <Zl�dŸçn8hð%þqœ–E晨ܒ ß*ÃQ0fïñ']اÞô•9Íùý3 n£„7$n¤Ü‘le»"É=]Ö¬x*ý]ü ±Ü’ÚfÁ1Í‚â¬Xf¿àþðÀ»Åü)%±ñäã®*üj€z°_ªÕIvUl•ç;3±ùõa´¶ Ê]ý¤;fÓ_ám[ŒføµríZ«0þ’¥wî}«Œ @<ÃÁR3t7神÷Ž ^·tG¾ó׌+ J¬+Z °¥e;C½õ‘óB<FÜrö°FþNç%ò r%2ÅaH‚²ß{PÙYcÝJÃœŽ×ExåÚë4øfº˜ïJ*B´‹‡â@]Q±ÅUˆ¡£P^n~œ:õ¾Û Cß¹'%%ÀJÕdÑÈ~Ž‡¢¬ X&‘`®ážª’®~69eÐÓ›(a>íD>â^h+ORn概»º¥7‰»G,8{\H§4ú¸Ø=êÇþÞzêêþ9½IÈ« hO‰À_l-ê…'˜æd…85AÛ…öÂî.9<Wšú`õÒuàÂ[ 13\õ¼3¿ånà‘î3ÖÉ¡ÿøÁ©§ðoåÙsIOqјÐiž¹ó¡Ö裦û´ôõåžs±ZZEö‚Ö>P¶Œ¶}*®Üm!sQLÀëíµ²r¾@|^^fÚÆàY“¸•Õíª³îµ±vûz[èÙ·ÎmU?—Al]èðÖ€HÖ»³=Š_;ŒQhŒ//´RÎÖ# ¬ÇÉI§PÏðž$§™‰Æ\Êsþ@9ÑEåM2Ëyæ*çñ^­x~Î"Ò4\Á¼*zR´‡¢ZA8h¡6§Å>S㧭˜¼¶5ìW½d¯¸„¢WD£ »gŒô"öÓxù‚F˜úÌ‘o¢€ãiÀròIÁ–Ž|•²yÊ�®W¯ÕU=Žƒérä±GSü”klG@¹aFï‘ö³uÄq[ÓÿجøÛZªÇ“ЩÍÝ‚8[#C—RèµÍ“DÙ‘t\]ë¨jC!¦�úÅ°(;kUðg”q´’s )u§ûQÎ_ÞQµšA0¼V& ¼ÚüÝU‹^Ô¥=bU°úBŸS^ôO@ãçR˜¾¿BÑ•& ÖEå3ñÒ÷¨wWŠh*`÷éØÿû/pà®=Wá²rVÒêP™)¸)q;ħ€¾­çŸ•´¬Q± ×h)? †·=;*ÓöôEËëU±˜dÿòGàræ)R‰†Å´8~ÚzÎ}èÃ'¿4±ù)×XæJ—Ú·_�\\®ÌÐEí¸¼ŽÊ‹.’Ú@¤V6»?å^q´²ÿ[(:–Öxh‰Açæ%ã6>DR¹Ë8ïOË=lq•­ü•‘^³’}qÄNÑõ°ØU^{U‚MùQi(#È‚íâI°Ù¦>ÀVƒ Âéó x�·À ‘Äe`d<´~-Y¯“icÊÌe¯-ÊÐÐ¥š ¤Ö]FÿÉ¢•¬7[ôÂõÁº�ð<©—–Ì °Â’ÀNV&¼?ûÕdÞ1Äd»žN¡ªmLÛ-Y½p:Ú\Ëò¤î5Ú²µu.¨€¸SQÖŒ=ÑiQ̶=õ2. (Ü{³¬I÷kšZŸ$H»/0�k›-Kþs”“xõÃ]QY«V)瑃‹¼(@[àt¹ZäV{à<„_ýJi,ò4•CU‡wu¸·X®Œì³Êó#‰é4òfWŒêfÅ缯=œu׃mÈÌ™t£ˆÁÿ ûl=‡älÐ9–­e&Cy7'÷â0,wXõÈ×?=T)·’f(–€›Ÿak±¬Y»ýaê)Ü‘{WÚOÏ<0'ÐUð{ÚZÙ Ú¡ïõ|Ħ2§bÓ =7|!xn× 0+ÈÆÞëEP> Õ3mc‰Àñ©kcVøƒ�8ÿéfO‡tºÍdØPìñ€/w÷RKâsX )èŒÛ+K$Æ=1I¼ib0îb:ÅZyõÓLŸZì o3KF©ÌI´GÌ ßkGÍÂÖö _ ÑšÎâé*M“ïQ+ŽäªÌ€¯Hž«f²7¾²jfî¤û&o³…9¦ÙTç¿ÞÞ™Ns=Á°WÓ¡ßÁzútái¶áĽ:¾ÎT¶ZØȸ7u½õ×EðÁý6C(géÜAXº°ˆN4•m5TFFœ~v,™Å…·AFL“é›Þ¿4^D.‡¥ÒÊñÌþ B¼³-˜³“îñjXƒ¥‰Ï‚+U¾k» R—íùóYúÂI§zî7? |áöä(íŠs¯tº(Ò+ƒFïáØ ªŒqYÍêæ xÅð’Bäa¿X‡îÔ~¤£oÒ„ðÄäغµù-?í‘þÕŒT리yÐÚ[Š²Óùø½«W…¾ä#¦P�‡óà”Gö¯óíóø—IéCþåœjY­Hµe0OyPY¥,<!ÊÅ[í,ßÆ ã<ÓÈñ ­± éÄKh?ìuèIqáÈ‚# ÒûÙ(ÄγüÃÜUÁ~=lUÅva`aLö P">D%°}#%VH±íGÇ¿Ö¹Eå·*Ì‹ÿT g»5û$Äu¦K<É¢üD8<¯ëãÄk¢ øry_Þ>0V‘]BE–U7Y糟<ò± ¤ ¹w.‚xÞ{Æj´*ÑøØŠmЛsù­9ÿóô»¿ýB¶ã3€ÌÑ×é¡›³§çž JèŠJcQ•±¨Ëx�£-Cçüƒõ�*3;>5Êcûœ@ç—xí…”¢ö7/ëØhÑ’Úé¡QW¸)™H]yé+m3Û2¨ŒHc³§—[jå}@r^e±Û9ë$©ÏA«¢±¹±eˆ„«nŒWMA­ìh¬]9<ǬýÔ錿ð¶øu²8nÔÑ…˜ñ¾ò\#ŸËȶBÙY{ñÍ©–-Ðß;-Ì‘u<óIû s$Íü2¥m ¬þû»×¸›ÎðÒþc{A"vÊ–g³Ôƒµ‰,Ê\/|c 6‹¢céýK¹þ™T!—­=Ó~b`ýb••OöFÙØÓ§«úÎkv3”×ħååÖ¤ê�)9 —«ù†JÑÀéâŒï-gW؉tÀ¬§ËÀÕ¸÷¯ ì8wç7F¦Êâ`wÊçÞ;à òiµ6XEM 5w®<ü¾W•2æòØeAh£YTû$íŒÀù[”ÖäõVTËFã84}IØpÅ]ï ÎÊäé”´ó£Á:C7¨`Ô£ò=EPZ vÎ:ZðÛÁØIì¦Ó-h‚¿ ÷<ó)<ÿ9QÙdOñ¸×¥ÊOÐâ ñÈ•»8j:2S®ØO†ö[ã H³9Ï`Ú¹í‰ÉŽH‡úÿ/’_¿RëEΟ…E[¹š¼ÒM«µUÅç 4@û+K°ÉÐåæ'ƒÇ{€*)ã³¾ËL›ê|öÜõ¦Ãhë™Ç.¾’çmcGgH¶ou‰G”&Y€Â/¥?ÞÅ*Ð¥g_±½Ë6Iƒj¬}š=>­ôNÅïÐ0^h¹éë]rFéôú¤ë8ö»Òñâ¦Í uè|ÒŠÐ×;_œÂW©È¼’½`ôÔ5fg“I˹wd4<!µ(}ˆʲ"ÍÌfôþ<¥AÙöJb&Wß îÊ)¸½’![5ôÒøJmþTA\«qr" €ƒ5꣫á.– «Vu^$¦vÑØzd*ð¨æ@¥vv?ØÚeÙj†”1–AÒv¦%—,D;riê Õ”VâM×/÷§h+m)šÎŽª¥ØR=u,$aìÇ’Ôõv£“ ÖêR{÷bÞV]&¿”_u0öÄ`SgŠdѸ³i ½"úÛ0‘Fk'"‹ÑrwõÃÏÖgQ˜ø6D±Ýk¥þÃe´¯÷Ky¸B…&+#8×9¬¬¬@VXí|!l±à)2 1ŠSgN&̬òì‘Í AX5d3´ÈIŠ‰Œ»1¦r›ÉæôµXOÂþò»SFžYçtâÓ$¨vïÞ,|/vŒÜŸAs˜@¤0UÇ·WÎ\WU"¥w}”Öñ.å²Ç’$_¡{§‘D,º-é-ÛOŸîmr;³Né_tó)~Ü—³_)ÛÛñ'1Jµ]ŸÁ¾k6Ÿ™{ ãiÁùJ1¦Sé#Jl# I`G5¶l&»PôëïÊ@‡ù-eæJ0ú\|Y�ñiÃ]§z+\9�Èì«tàå__á"fp ÈU8g­pÒÜI nßyÞãsê+Wø¯À&’Ê)‘„ìüZ÷´Úk+þ_K€>b«£ åg%}§%™S*Ú¯¡%nA¡yScϾ$;®ˆ ÁºÙ:kfÐöi]ÎmW¸|UU†Š'œ6O¶> ®]ûЛ ©ò‡¨7`E‹M˜K©~Ã8ÁÑ Ÿiä†=Ͳi´Ö»*(º½g;ÿ󖊹y¹ ÀõN™Å­6vAëqغ¦‡È‰ÝOæßi±¦ÖØBžk†æxâ rsÐúlõ…µ åßG½À$ó|Sç“ÝÄ&{ifŠz$LŒlú­ŸnZP'ê>Ú§KÁÆ)‘~ðåÐ4¶O{Ø ˜# Ÿ»‘×±þ„Æ1»¿ïsåÚä/à UÝ%EùÞœî2sr‹”O"FÈ#ÔEønMW8±nƒ„+PQ ˆúOþ0Š}=ýqáK†âuÇÂq4-=ßÑNŸb6p²È¤W,Q’ÜoöRJü± –Úž&Ñûé ¢¥êéR³Â6Ä ^×Tczâ¨6»,slŽô^MçÔ YŒö€õ@·`@~+ÿºÁ3e¸±63O –AÆ—: òVMŽØ‹ÞÈÁX@¹ˆ>™zï…¹„õS0nG·„4Og‡L7˜õ}w]ŒÌ½‘¾žt½«l%ÎRVàb-]Sñ<+ÃÝ£þ¬Òë3ŠèÃï[Êêã±üú(ÜvTþ”XHÝ`ìRNýq{@1ùH_-rÀŸ¡ƒ~ÕôeÞìOË[ÑM8£- åðKVTˆ§>ô9:BBkSP`¸z6N™ü¾šÃ³@éé•siyÙbVùåËÆòñoe—úà¼ï^}ÛM™«‰I~ä½ð8;Zfst¡Â¬·)‚dù­¡1|ÊvðD¼7 &‡³ýÂ'JJ_̺±û´à\áÃ÷ *ýçséx\élö9ÕïÖè:éz ªt¯,dÎi�È+eÓïÿÅÊ,º·Sî)A(j9OÃxø°þ¦/8ÛÅ6µæ¯A[õz‚Ó{=¸gy쎧éP÷c·;Q¨áš ¨æ§î¬§c,c‹Óeöx룯Ám;]?âãÐjºî]>À[$•MhdŒ4£:‹ö{§r¹âp¦L÷°ðð³žEÝÞ^ØQÿØ–@¥¤Ìݳθi¿£=Âýc{!7�Ý^+ßÚ™—ž²›à2Ðó³ŽìÌÂñ` ó`â ¾ùüãÏÚ¾N³ÕÂa¤{Ÿœ¯ÞðÎL¬TäîÀjÉ=»›[ °ÜæõOþÚ‰ &b{-éýU1¸2Pè=ßþ7^טfm¯ n‰Œ•Ë®#ñC(Ù{Ç©@@!ß’DìÕߣz×G7Wª¥wàhYic`7¨:l®~7ìÌ�OG)1Ï!½$ I½)2O®»!§ÂetnǸ²yB=1ÃuýX0,qêÜ´¾l+Ú›[¯ç€Y‹‰æ!RºtS]žñÌÓfbhjŠløôû³d=ÐË8£æBtZVL†¶ø ÌÊ|¤&CgÊ@±·’Ezc RgÇýñ åŠ[I9$ $ùmÖ'A^_=*â±Âë?µV‚<u7(36r("O£t¦$w™ýr‚ý0Ø\P·—kO¹Èǧ2¥¦eYö¶O›TÆ6ˆ›=ìǨw=½\½¡,Õˆ}" -ôû)o·Â¾›JAßÓsN÷;‡%‚Ìõ­má’fQ.“�§o_×óšˆñÒฦ]ãüP®Ó»\¼¾ò¿ »ºr;µÈ_½+{<MDçk°nH"âýÑ=º–öU‡¬gtÐ٨ا% UîüH¹oÙtNy0°_UŒ¹oZQyRÛœ®Ž'ÚE»ó£½4Ô)¤;,e(Üc*DQèã¸àäш6å6ÞÊ€êc0mÖuÇ'Ë<eeÈ9A}Ò–ŸÞ¸@Â:ßd29—-Ò89f|Ýð pv€–xMö¼^>³ œ¬—[È7ÒŸÜ™!Z?‚æ¿‘ˆ²pÛ‘®_èíÞ­ØlhÙãUtYÎÆ/É`±+ÅLô³‹íÖåæfïé[£.üªŠ¶×™d°ù«wÒ#† ã;ü÷-ÉvA«Åõã~ ô; ®ºéíJwõµ¤ F Œ>;<Œ_ÈX/ZF²,ÅßhèÆJ§ŒeìKa„ÊÜ|þÇ")Ñ`¤gàûÀ½V÷$I´’%«‚¡J›¸a6Gáòy³¢òPï!\?Û®WœïºáHùÞ÷ˆ0Qže¶ /CåPJGéb–ÊW¢KKÀtFÞQÌù^EžU$æ‰Enà�².+Å0xý·õPìq*Jà{T4§\‹O’5×;÷ ²Wø‹"�¯;{WÎÑtmoõ_t*e0“¨ü«ß° Ç‹ü ¤ˆ} m€+Ý;—{A´g©YKŒ»ö¿weåBCÛ°K™4$AlíÔ1Rz! R³Hÿ–1›;Ú¦4’Ž´pã¡÷Ú]¨jÛgøÐzê4ù‡>ï¨H.ž½: ®³G•}ì«Ô2ë¼ô6Kµ/+Æ!;4Óûï'Ï·æT¬Ñ–À±chÛJ†o0±àé>µø!aæP°Ñ·ÓiÒIª°iãZ8ÑbÅg^@û w΢¼(|%†ÏÈ¢ígƒðxÖ†Š¢0MÍ ^ {—ù]²uÄx­/\D.Ec-Zè/fÊ é^ÃÿVœýŠùTl!Î2º›!]£\ÜrX½îíýܼ“½>÷f+Ö¹µß–u !JI÷Oÿ£kŠŒ==ºþ ɹ«7~‡QŠ”ºμ¾ý aÌžò,q3/åâZ¬Ä¥@øÔº¼³-ÏoŠõ^»Üó'¾m£±oÊF+º™èc÷:uô¼Æþû¦Ãæ2ØÓðP…Úy¹}ýnK¥–²x2+¹®BXÖ}T¢nç_>t¿,3_1 #ˆœvÒ—ö|3N_dP.ºY¯*Û)ôÆHQ•»« Ù©7 o Gè´ê­ g>}'ƒ<sµæCQT™»Ïâ›?¹¶‹gYØ×8=y®‰ÂÏ®¢Œ<¡1A-‚ª»:é`!þ€}÷ Z×nòÍN`ŒÅK¶Vc‘q §±‡tZ˜Cý+ ^™äVÅLpTl–^+:�„Õ#àŸh,°—ÿ¿þîwÿžÇÿcцåS»Î³/QoÚ¦>(Tq Ô|³ó0蟸¤÷ôQuıpÝü¶£ü)É,ëÓiqfÎTó2Jl¦7ÜNŒ#d´ÐœØLk+ìÒµ“ÍPüB÷>ÝéÄ´žv`‰¼- ¼¢ßΙÂ7ZçSÓ˜*vÁ•½È{x‘‡Ÿ¾™±DÎæåOG²Q”ûÖEl„™Úô®ü?L7©š¨¥QrÏúç ÐI3í OÕµÕí,M{F4FV÷ã1²˜ÝÍ»ò…æGeq˧úC Jæ -™Þ¥¿ ¾i€üD /]Z•Yóîìhic|Q‚ÅÛì÷ÓÈ{´âÖ†T¾Ø¶L…ÈsQÆCÚ|Ì ~ЈâÄ54¸Ö ›ü>x¦´»Cï’C£ªÒv-rh ƒÃþŽÍÃÐN u“'É1xA [ô÷Õèé�v_™>P5B%ŽËð"Ä‚7Ÿþ9¦WUŸÙÑÓY$á`?EÐ×VK4Ë¡#5¥è$žXåE¯˜ÄK°ÙÕs½;Þk­€ü Áfö›µH¦£Lüi+i'õÞ +²Æ„¢ÊE_¤§X¹·ÊøŒ%¯VâòY·¯/ëÕZ¬(Ç£auÌ‚¤{÷H'”–†¬­}±ÇþÙ&Ûrrlâ(ž�V[²¿ÒéVt®í� U´9~ðHà?ä˜Ú‘œ’ÐJ17ªªÑE¸¾-ש¦Å2ŸzÐÓsT:1ÔØP„©$É‚jÞ¹`$¤8yç‰[pfà#'ëÙd‹Hm˜WÊR—²HiÓÒ­Nös˜3·Gg·¬§å^cRÏ„[Þ³ƒ¶ÎKæÚÍy¼ÉáØÉäÒï4vÞ,b<>sV]‹TYu“çÑÞ÷Ö£ý¾žwqkQµÙAdUQVÒê°Ðä{G�ØøŸ-½· x—Hˆ ßYhm.”ØVo2fÝzÕú¤”²7}ç_nà;ñi¨s°Ò3§feùcWRñðîPC=-4óí_³î.òÌûªE<8ÞEsØ]Ê®Î:þJ8^™š±“Ýw¡ÁI„›sƒçTus½c öã/X(3[+ž]¡ÅµÊŒ jÇ*"³qˆ¬9ª¼B$“„ÿ¦9Xæ¾5ÝÒåâûSì°[`€¶Úž!ÒｑTð^4ÈEŽ ‹•¨ Êò‰FEã5ê'„2r, ¯”µµé+Ð3ÛM§óZÖž{7”7rãx÷ŠìRžûUlÏCiØ`õÓcæÓplò–ÉhÌäλýF¶V[¸K@f=l0Èæÿ%ì¶cñ k«æi!"¡ŠqòüɱO1´¢�ÃEÍ~S_zïê'¢(n„|gx$Y—IØ€Q+Ÿx_‹mËK¨/.LŒ'ʬç­‡äêZ¨]ôXyÛ±)uÌ•4g:4M;/V"¼È.À’øüô|š?$ZýO¢JV˜Í8è*¼?WCäÈ–Ø”UÌÀOتûœßÍ~Wr™´ óÎbÀŠÐ\eØÜÅëúkY’ùõG(”¯ýÅëñ¹quÆc/4 ¬r"ê_ö¯¾ÔœµjÓË™ØI‡½E±ýØÔHãUÚVÂ?xë„Aè;«ôMsÒæãd«P!|1:æÎMT{¥^P‰¸ZþÇí$ŠàO ®2Ýô…Ñ“ê{Êÿ“m畺'&†¼½ÓMV—±¦=€Ô±*ô¹N7ôE'Ð'øu(’i­ÒøÇzž•1›s?*PÓGõÆј1Üë‰ÿìCº¢OÆÁþ‹æU—hÉž$FDÒ*rSÑUÙ× Ë4‰4áwØé-_›¿ÞÙ|=:¿÷õÿëAÜâß½$]¹…ÓƘŽ´A½³Ùª(ò›E1Õ‡AjÖ‡ÅíÄ&f¯1'¶õ–aSÔHw>ÌÌð)6Š#?O§Ú Ö¨l”€É³]¡ÁNîß.V;ÂŽˆ˜‹m´Û[ ål/)ÃNéàVN €ÿœÊ ¼";¸(Íò·ÝW’q÷å¦-|°´•Ã1ž‡‡¢J¥“oâa‡2¦ÑDŒƒ¨¨XÀr‘A„G½~Á®c Ý=•LoàÌvT,Mq¨XH­ ís\˜çŠôÖ¦0ÿe΂²¹(€Žá¡ÌóvæÁœÁαh{ò“ïúž›Nk7`(¤Ï5fæðaùçý´·ÇXYbîä½|ïdA_Ýœ$ ÏLàª`«j– [•ÕÚ$ÎýºÁT:%ôËӠݧAQ«$ÚWBൌí pvðŽ»ÀÐ]¸ó.}r¶¯+LŒÝ\�?]ñs¬¯[Ñþ“— (®#í[lÈ Çþʳ¹HÔ.Z;û3¶YãKo MùZ÷°¹±ðÍj?3H®þÓr K˜š©ÙeKÊž÷•øäz’4¿8ÇÚ‹`#ˆ&èvµ $(­ ;Wu‰Ò#ÝÕH–Ý´z[ž—^­w†¸<tVc_úSØlZ¨ñ KZP«©Õ7*H˜­:Ž•‘ œT %Ž%Àn°Ûõ£ú “uàa­*–,/[·¬šnp“—mT…ǽ&@˜yêØbë1\rßHšîÓö€ ¼WEpr°YΨ…l…‚L¦ø_ÿxÄZ&Þñ¯²äË zŸþ¶>ÜÒÜ»K6ËP±Å(�HÌ·åê1xéþ¨ÀÐ÷+ÓädͶ7’ûúþ ¥9•g!Ö•îúãk’fRj¤e€¤×hí1R-¾·¾õ P5}wsn¶ôÙ;¿{dYh;ÀlßFáöc®ýìª~á6ÃyjÒ–2ëðð°Ê³ÕƒÈ‚¹È˜1¬§¨!¼°úÉñ¨ùüŠ ¦:Û‹{n¡Š|Õd_#ßÛÉJœƒ”œØÈѱS´ÜÁ¿ýZÞúì~?ÓC*ë/oFÊ”þ‰çsfÕ­¼¸«‡ÝZÏkB”ʤ:wÇÍ:Ìóá48Ê–8±(ÑÖüQ®#òÅ]™Ì½A'-ŸÎ^{ M4. 6Óin OWÆ·Ý/·Fk ¸GÃè9± _x<M¦Èšì(CÞ—ŽpZ´.ªæÖî¥ø¼xÔ†èøÑý¬Àˆ"5íJÐRë=ÉßQFîÌHNáä:a¥eœ9B%=ÞÄË ¦¡y+ÿ—Â*ÁÓbüMâ _"S@RÍ›ØyB,ÀI&„ Øswšùéê«?A+•<•¡¨¡ƒjƬ;f1Öâ1‡²ê†¡Ž;?=djÄþáY°oØ{nª ·äù=ü?öDGàgÔׯ)˜ßƲ/ƒÈHÊ'é%p³4)ú_t]5Œ-%M@Ê›KÄ狇²‚r·O Hù0ˆ@¦½ø#3äx^vXU©}gVbkzú2V €E3§–¯({Þj2ÜWPN¥j8Fêñú± %ùþéùiâsãÛ< ¾ �|æ€u‰Måm7îÛF¼ûOG‡¢œoD¸ãá5퇺e‰… »²Wç›BB|#ןʅÔI9Xõ®”Ä“17Bøyÿë»ÿqwö2ßùÍ#äLé§üp­ĵÌÀœUmýç >ƒ ]Œc' .t›‰nS={" •»¸[’‡ï¯€¶×Ûο\ ;|ó´ðrí ЂéuÆO ‚W5ŸÀøÙuO¢(ië–G¶`}møŸ…ž‘åÆ3DM·^Ër;Õ3°¬ZmÿVâ#*Ö†Êí0H­šùæToLG´!‰îì@ýâûn^¬<5(/�ξl·>§’ñ«Õ(a ö ö™OMæœö¬É¬˜q4Rð†ëv`gÿ?þYkÞ˜Öϗ苾ÛhkEA¹VQ©þKÅB8²q$Ƽ1Z)#ŸÁˆ�ydÒ®â2s³¿J0×FTÐC7?ŠÞæSDmZ…+t3­ø^‹ÇV…^„BtXG¹ë/®óܣòÐLÛcÖÖ–4ŸçÈPrÜêØ ¯+c!é »"7¸;ÓjwZ‰19Ÿ9{áyK',8{OOÒŒL•5ŽXʢݧ0±ER«4Þ_7جªOl<ä)‘ƒs¤Å¸å¬j¥84Q5¬¢¿JèâÊ)ðHË® I?xrïõF¹Ó¯[‚Æ¡—f1–î7¥FVï ¾pþ#m³˜ˆ}Hé»hœ?Q¬Þ\§ Ön,ßÁ4X)ðt˜ Ò¾éÀÜN«KÜðxeZÈ8»Ü n�2Qáh;ƒÿn’m»Õ‘‘x?Ò:¬¬ì%ÈœÓxJ°%¥}ÇtLÓÿewW?Ëkq{¹ŸíÆ™oHà ‡}¯"%'pî } ’¨Ÿ0xR®ƒyùVÁMP†æ¾Þ­7CRøî+!Ô~!eëŽÆ”v{îy‹é Q_WçE‹RÓÇ+©ÒH™o’Øbr[÷©õ&¤CX°´ó`úiþÜ“‚C!¥bDÀ02T¬KëbÂæÐ4']£à tRƒÿ†Î—†¾;í±Ö$ŸNH5Þ0B•¾`µÿÄÀÇÓû`1Ðë)ƒø«w•Ø°C±™¤gó¡(‡p7C¬hLÆ–•1(–¨T':ÕYNXëQüÙ,›åz4ïï®PyÜä wX¬ÔpÃ*h¨°¾;7«ì¦êõW‘¥ývÁ·|d­K«ôj5'r#¡sù“ЪŸ=Tæ–ÖðÞƒÆ_€ëš4¿|úÓ7 _%%8^TŸz<"Ãí;7­ 5Ž° Š9Ð÷ûö›=<<šÒTH•~½6ñð>¹¸Û›(KúŸððSsÁÄïV0Íëc©‚¸ÝºÒ ¯-8‰+«Ùª"¼Ò$rz¨‘!z7ud»Æ,1|hx§z<LÎA{e‹[{Ùh:š»QòHx† í¢ÊùʦÀæÊÜ¥è¤\| †NÖ ´®IuãƒÙð|Ú8œµê¤¹äU[‹äâJ€2IüˆsÇIJëÑ"¬x­6Ðúîït™ÂÌÏ6ÖÁ›«v'¦=ŽÄB+ÉdºÀS¼tævÎ[šžÁõ„çÑi£âÏf㙂‚]ç¹!<œAÃ>l z6º°Ø‚ …¶è‰–k£_V"XÄhX+ Œ“ëaq/^ ®nEn÷#…ZµÓéy}º`FÈ \«œ%‰èÛ¡‚Y?–úwÝ:¡ÃC/F`qàXmá³îÎfžþ°>72ÍEå@oe.AbæcÐwÑÀt]B‚ƒÑý…úá¯Nô$ø˜¾3¢³*ÿÐQµ7;µ-‘n1õÑê¥x× 48”2ñÍ-Q¡9c¯‘¢ªúÃVí²ë€³íüQyF9ËxžäÜËUôŸt•¿DBߌ¶­¥êÚùŸœ%±@¬¤Ã/e˜y¼j¾…)aï8NÇ7/%¤TéÜîOݹȷÊp4´}¤óèøO˜8‘£¼T_¾óóÜ© ¼çÈì Ùº÷cZ§´Ý�›÷µUµÖLX†o¿¸Óý* ¯÷a7ò_Gab5/¸f»zXáßÖ KÓ6Bx Òêö± ñtà¼Æ6é|I¡G×wÔZë%Ì‚Ë ´¬­ç²Œ¢u‰Áž5ƒþ`ò“o‘Û«"Ófœ?ª k&wþ[— k.|èðêr²NL«[ÿ„º AÐó"Èòù Üiv÷êÿ¾Åqc†G”}Ž"‚c$ðî{ ü÷ÍWå7‰Ðù¯üÿÐåhï‚3O9‚ÈZ<f‰ñ~‘Jïfz¦2ÖHðèg„ær¥Ÿ W+~×ñe³ÁÓ»»õ‘|BÒÊ—õ²‰äس*”•pê“!¾ ÄéÔÉ?839 9l›˜¤�{¤O[Ô¾éeÓm>ºeq®UƒÜZí'Ø´ôùÓI¡Dȧi« ÆAöâÚíÅ mì 4º,H¨Ø³ºE”Ö æôś☄Yó«¿û6Y±ãRîïÒS™û8Èög3òÑGaš8s/›ÿÞ "Lêb0‘Ï ÅàýÖ³øè8Z±õOýâ.ú*‡Ù”ïå{X((p Z#t\9Í>à\æŸ ™ØǘBŒ•'pCççWR`¿YC¥g™©wiáÞøéwÒâÑú¾ã2­Ju—gšTIe"âVÓ†µµWdfÎÎý( ž¿Ìyð dêÖCj䄳i1]‰±'=Ö°„£OHË Lî®3˜í_G‡2u¸%VàØyØ|™ÑèñZõ$‡³ÿ]¨Vê6û—]ËìSÐÔ|„S>éÙgÚ<[/š®9|™>:vëÑ‹;±(Í«–8 † £VavT�Ÿ åÒ§ Z$†º¿Ã^j†GQåì•b; l*…0(Ül[úá°»In‘m}ƒûÔ¹[D2)>Ì ”n=ñ­§‚&"›z€ÎìÁ`öo~âhÄúYž:Vá‘œR7 fW[‡;iôp—l'ùEt@ÊÔu%P‘ĸŸ½Ö”¸=âàówˆŸÂ„Ü“½ä”pÚFTœ¨sÚAÞ_ºq†È’�`ñW¶çþ®¤{T:h‹(P‹ÄUw KÅ™î€(•ý_T‘Hn\:)o§ƒ0šU©aõ,¢/NýefÕ"ËÐõ¿öC·Þªð5š#îäA6[k'Æ -fP¦3\skþ¹þ—q+°zN%Ý=Š—Í?NyØŒ©êþh’wþýû9Š<·ˆŠ�ç<¨¦­µF¤Š¿¾XEÖgøÚßxÇË*•50í´�"£ž‚àðÇÓqbŒÍ¿X¬Âe´•ø‚Cœs¼>#¯1ߊtF¾%¡h$›°íÆ4(¤¡œ2¶‹=õ_ƒ…¾Ð%è<`§&ÕŽÍå¾9éz ó¡ÆÁ“4=%%=|Ù³NS¡*c•>ÎTì�î—)©V?löT¹Jit«ÌåÃ{ =«ˆ] ¨'… n× ¸â˜pÏÖÒ]­ð yì3AáÆ=Q g55#ãcéiØ3È鬦°ÏÌa£Ò9£û¦ä›Ý—ƒ^Ý/8í¸ž¦æjþ½§Þ”…>ÖBïõDÏ3.2NQÃK<¿{© ØÁE@ÐÑyZ´“‡Ø8Íð~æ¹â.1ÿ X§C€¤ùc›.¤Æ>õcIƒb²²o”ìœ<ßx¥ÎeɆ¿ùñE¼âšŽBçbï­"ó’„|÷.âVÝÝ+ªPËÌ·^¤H°9Ò#ˆ/jd”® SÏýiDæ¾ß"&¿?OäãÊl+¦D¬z¾)�²Wn*ššåÝìÅé4 ÝéÀCòeÈ‚ü³÷ltÑf]Á1Y• ±gx GPU¾gcTq`.?µPí`¬¶ƒ䶧˿ώo "¡=…wíë1ïbÕÒƒ‰%ÅO Òîº'º{eéZ¢¬†ÓôÃÙyÒY›îØÑÿæª ‰W¥³œ2k¡g6”|FËîF·µë¥2ÛM°%b/o}6¯™§Å’ò#bí¯/•ú¯01Û:láëŸ?/M�­TJ¦­<Ýxko€™P’Í/‹ã¯§UbÛ½ùCGcÔ[ú"né:XÕ›ÚL'ßæ±V1ÿ[Qÿ4*œz»‹ÑÁ¹Ý&™wÂFÐæéû‘Ž®åŽ÷Ý6ĺQû­o[Æ.«åñ�½ìsïù™5ŒÝŸšÿƒQ½ª€—ÆWè¨NôÁ»i„¢”‡ì—‚L'b·6u+#ÖÈYG²_5Õ]UPÚ4/•{Ä&¿FÆÒN¸«-õ¥›>xsˆ;´°ØæØŒÁ‘"^ΣúHyJƒaZónîñu¨Då±²+Žð ¯ï.¨B‚M$B¦ûµÏ<x7S-™P²µ×¹†ˆÇM ë²1#Û= ÈûÉž~ÝWfN$Vlâ‘6îû•Í�¥V¿ÊO%6kõ0Ò¶‹g=&Ä^Žÿ}cID”ŽFЂ%z…kúMƒÖ]ʼԩ™å^ªšÕeë¹^Œ °y0Ó™6×õůTxÍ)ÖMŸvð¹o¿<ØîxûzrVjB»ˆç:0P~AܹXAr(N;Ðÿ»ÙãIÐÄi¨ìè;µœ_ÕY‹0s!dAq}!'ôÒ‚ç •¹ RÕý¬ƒ;˜;w@`áHá—e -FlÎú ·§¯=Kï,ÿÇ92Ðg:vk'Ç*Ê|•…HÌÏ¢N—S†»,ç'ϳ•ýYR@K¤†ÎcGk?êµõNÇ:·ÓL#Äø‰Ò~îNË æ™y”ùŒí/”÷Y¿_¶8‘ÙÔýF×ëªÏѪTKhe%A1ªÎ6*kª–¦ÓÅ×Õàúåæå»YáC�ÂÊ «=)¡z扮EÐûúŸ› §»ú‹²Ò¦–Ægx¥½ãKžUtÇ¿ FN˜˜ç*ŸugÄ° $s?þ|ê ô8R´ÕCñÒxê§165¡hß!«mº~¤;óX)°HWw¨7•fc 'jj›²§êêR³ƒµÛ¥Ç{ƒ¶JKÇ‘ç¹Sߧ ž+¿sw¹Û‰owÈgz*ô1ž¯»¡>¿m·Úç‡ÓŽÿ»¶µ¯¬Õï°ðic%³•¿Kk×ÌzÝ?²µ-‰(3ú%-×óÃÙV"˜“ÕL7q ý§@t ü‹’G–ÛÁ7'gƒh__ßÌT{ý“‡T2&]9Å Xôx¢uuÿç ÍØkÍJu#2|íWü7|9dæºÏ åYó庾#¥Oc·Y¬)ü‡üóªjl’¯ø˜yp¬‚|¼ñÈD%ÔÚ þ/‡„©×‡ç!a`þ ›T¥FGmß VÏ5­nØëz¾PêG òÆý1ôúˆ<Üig2¾{ΉôÿÜ9bo(ó¯ö%ïýD»-Éü{O§Îéà™81S‘σÍtºòP¼>#‹³Ì·HD¤ëó Ý}™VŽw A‚½¯ê;¯”RÉ ‡^’”õÿ8t‡(¯Õt·¨flN½¾CÐªœ™87Ô}ÅÎÒ‘å³j˜É©)´,ÊSï)¼ÙŸ¿ù^:3OÁì zåå¾uúÁns⣧ïf/Hz¾ERü5s”óÄÌheá,D„ܪ†ÕÃîd,RþòÈœä£/‚ݯjx7ur–†N¹K ‘ñ<_0A¶g™Õ•¾�áPkº^a·ž:訾jžÝzëmhÿg­E5xaùGo[O­_t¥¨™NÄêä!÷œâ ýôµVXVÐÕqpXúÌ÷~“5•³ˆÍwtä%Ù¾;`NÞÛFIÊ UËoØtÌÞ; w¥þi¸B9f K³ÖžPàÆÖ‚0eg׿óJÎS×%ÎÑ>¹ sZ '¿+æ˜3F÷ù÷AûÄ9ÿ$¨7Ú;ËVmn˜´Hÿ¯ýédxâõìðvÝ¥ûI1ÃŽ´ØÊ ÞKtDtªÈ ©«yÓµü©¹±ó’¹çœ´û2(Î+Ö7'ëi®3S:&1ë×W£åÌKÅ!Ïòr婃 ÌjãñŒËÕ “ô~f¿w†¾ó7R€Qù],d${zÀgí?D"2y•I+$£^X½ÅL˜ß€8©g–~¹Ôùk¡Å‘¬2±äQl‘ ‚_@)óÄ/ná? ûËjÚYc'ÀQêEU÷wâ‡-Òž¦¹à…Ô 1>‰ÁçÊ ³ˆ3_à%Ž™ÃeÖ}ŒPVÞ.…fvm±G“†¡ßa§ïÒB-ª;5 @º¯GÊ´?~Ñy»ðc‘gˆhF[›v»‰¹Ë¾qZUÁ ‘•I‡1p§»0Á¤±hCÑ Aî鮾uêC×WeSCzpPÆtÝ”µ‘œænJJEûYàzarŽ;H•Ì× ¡GyüHS^3Ž€v2Ú˜×Zï+0wÝÍ=—s;žJÌŒ¡Ò ²ÄPf´B&EÒ)ÔK@BúAT%=šÐÄ ·ÖÍéËeø#‹TJu~áøÉX÷Éb6eÇ´Ò°" >®"Ó2ÂRÄPÑŽ×~ãÿ\V}R2ëÃŽžni¥l"�±¶j@ætŸ˜ßvóúƒ½Ó%cÊv„OD‹ò#9èuÃpµÚi¿‘¹”ŒFã?ìqVLúô†Ø<ùé»÷ˆ Œ‰±ôœ•‘Á ‰Âf ®õŒ©¢P ×íø=Ö…HçÖŸM81±pýÂŒ¡Ì·Á-Q)¥AÁB ‘aož'�l¬¥åʱW„‰R¯S²²„tî¼£ÁFA‡GÈ$ÿ0ßñ ÃÒêz³w=•¥VÇ>EÖÿtŒß0\åºipd±´’©,j(I]þ$¥Ú¨‰íª`p¿í&OŽÍÑG~�W…Çâ`Qå¾Oó žÏÆzxG©(Ýð‡Ñ؈=ßt"+ÀÖ1O Ðí\<àŸ…ë^+}Ä7õ_¶ø,Ê*/‚Z÷L¢•) eÌ&£3•ÁPÁ¹£òPT]¨%óz&Zz$óyÌ2¡|ÖôÔ uápy@û„óŸšÂÏ æ^§žŽáûMÏ$L}q¾òÚ´­ó¦U5Æþܱ¿ŸÑ0æ •9 Ãeù%Ñ*NpŽv÷¼6µ+d¬¥çvÚ±j·;Ì÷X>Id Ç"Ø^)å³³7½œŽp¿ø|íP\®··Ü"¬"õ£=Á 4±“0|Òá#aXúµ¦§Z]æ/KµÆe®¹Ø?e¯Ã˜,T‘)v³H®LX [‹={Mé”Í´\“ñm8Ä&ÂÐigçeßm¿ù[ËA#~^€¬²‚_b9ãÜ–šdžÝpØûîøšÐÁ6[˜E‘úÉáì}Tñ¾P5‰W=×´IÜ í<yÃÕfX“êšz{µôØ;êÔŠ2=E ý.Â"þ÷˜.{زÚDq{ÊØÎ[y‡ÎUÛ9â±7´T{¡í¦Ç¿@ÇÝPœ¹ÜˆMÑÒf>X¶ýÁ'�wÛƒ'ï]¥©È‹‘ÇD áƒ"Ê»öúb9wGä˜*Zc‰‘§4´´Å¤Ñ^= ”—¾FnX#ÀV¡Ñ˜û ‰5œ,ZsBDé<aåµ1àKeèKf�Çmþvö&`÷1”ü¥Ñ寒гU€Ì6…`º.Ÿÿ]§ÿÕú1]h§úbeõéQíÙ\qÁ%ì¯Á´§8ÐÖo›ë�@�å÷~Å3èÌê1•x³¥?_NêžU@lAü´÷ü•G°#ê³èÐݾb Æp”«ð&¨ê¢ID•öP_Ö¹vÛÕ}ÐÂM+¤*ò±ã!C¤£¶äYÈY¹ƒ„‰òÅ› ï8áÓÿo¯´<5/¬}[i­(— Ò»Ãébá»S¿YõkLÿ¢ðæÇ1f §/ÊÆrÛ6OÀ\ ÞÝ�ÍÌžãÈÀE^LßSÇÈX°°Ê Ø©Èþ$èBÚÏÿ}‹Kã•Šþ…çÙ§9„å曟�O—6ýwD•ùúoÐ6é Nà¡í£ƒ Œ‚ff—rÂn/èÌ™/°Ã¸3ñòÕ RØ$�êù‚†y lú­m’Å™WÆ©x[—VØÌt‰Û3ÈÕXðíJ¤ÅÙ‚ú]r'¢–̦Seó›ëÌt$@ŸËd£þëkMUÉm.¤]©(3Má³¹ÎGkϽ8®J±?5óé>Vèù`**ópMwßC¬¬÷žH =ìªñ£Ú»þ”Ëêu¥fèBÁ/²¡vê ()¸òcUgï Ûfè+Q-ÝßþÈÐ`_ �è-Hm~Z?ðÊ 3œ)VþÐɳþn¬’Ì–¨J ÒÅA¼kM‰ˆIÆiFÕª$®e–x:٠פ%ìe¦%Ô`4Ò4Óel¡7A9Úl`þ<îŸû=,Efźܧ=-»ýèÍä¶Ü˜°£pÊ£ùLº‹us®„gî©”¡d±ýtC)ÈåAú>ª¼0dõŒîªgeü<ª9Ý$1>Œ‚e€€L§ûßIÅÍb¸nÁ‘› ä{o>^ñX¡ÅØQôJ­ÙC&ˆŒ7_:{Åuz™øä|ms cEDíYWu¬Bñx¢mb3ê£\H¾¸êxÞ¶?€hi† ¢Ø7ènM-Ùk# 3ãaéi½¤Þ¥é ¡Ù£æïGGá@cQy,XÊ÷]¸´þ¿>F67šž=x©ÕÞ¶(S=6m¼L˲=z5°ƒf`ý'ö$ŠëÖ.s4­¨~F^l°™¯ûñ‘gÅ0Ÿì`›ù¹˜Ó6eswçëZz¹Çæÿ.«¼0fÙù™‚Þb5ÜÔøÖ«A0€ª ¿!çÞa0ôaLÀ?ÿtåTÛQ¡) ó×1rUê×-ôÔ¦]ämã¼çý­Ö×t:'n ¾âˆ§‚¯,ÃÚw-˜Àñ¶£Dwç˜i¿áï%ÑJÖ4d=Ê<(/“³¨ƒú+OËÍ_ø΋4ÝÕ±fm,gsÏILpii“;놗úÞ4æ|î;˜(µŒm—AÁSåœH½“£Èä`óL9L§¼ùD3>ÑÜB_`öÚr¸E¬¸ðº6«“=WšÕ8UAÕ‹šiÌo ƒÿ¾%•¯G™IÇÞiFâ¥ösWS¾VÓZKQ•RÉ©N·:°Ê«‘ã˜l#n1x¿ÙTÇw/ E1s¾‹PÈʃ¨~·Î+Øÿõ›ý°8N¬oû…O°á g#wfW#TÜéÈ™Ïõã …Eb3x%(í&WØKמÞQÅ°.l‘Qeƒ·XtÐ\Ï{¾ïždI‚#…5¶ï£Ø–Ήcß-÷ø+v�‘qØñTa£œü¢¼‹!UÕŽsEAè&¶Ýã7~âÐÂBQºÀs7ù°ÛÆŽÕâtiÙkÁŽèXÛ>žé•¹?Ñ…yß1†¡mŒBF7Nz·3÷šÆè½88K‘­|¯–™l1:«Í¹GAe¶ùϲ}ÏÝ?’Øk¿UŒ½èOõvAÛ͸l›?ù²w¤Î%<¿Â{OGzÌÙõb ù…ŒßÔ-c7ø#ÿ.tdO@ÕØ àê2W¨p3x{µKUõÐ[Àó³ÉÖxbò,ÆÕÛkOqà{Ç6Ê‹È:A3{?FðÉSƒŠ±kÕ¶lZ‰NΘS¯ËUF³«ôõ{¡’¦±=²#£R—Ù¹õd6´ìºþ Šeí¡AD¡çYzc †•Î§ŒöÔûÙ#ÁÑçÍ”u4­Ê¼,øvf ¿j¥&ÞŒŸ<T~Ò²ü´SÃÐÒ¥Å<”¶ÆþBaæ Eá”Õñ]�]lô—={W¶¤ˆswxì†I^|öo‚Êâš8iô¸o"cW«FœC:DŽh‰Ñ.ãF›Æén»ÞÀWÜ#Èh”Ä+©:hk:­v“'ÅNÑ–‘ *d-@î_2œÁac8u HŸno‰¡!=õ„YI—ŸWÙùObLƒ�õr.5‰ ê[ÉyÌÄû°—ý¬±!ïFzD£Èã™þ·1•Òcݾºœ2NËDg1 ^ÌÓaHçn?¥oÿ^2SªË'=Ö;Ö„u„ÚïéD¤b#«Ù©g3•A<ÌË8amƒ�ÃïmúgÆ𘗇ÀˆH‡Ð²�-+(Y3…Áà2qþk{ë <y @q²¶¹Q_{Z¸UcÉ è;û3ÕtÌE¥ê0¿âqç þFžœ@¤ÎØÃ>?}š Z8Ïû$~½áË(µüÉ໊W–™øLvš÷ªØ 5Y›v^´˜tº Àœú¸UmÁÅQÀòXè›ð@7vÐë`á«pf¿XÅ°(eœ]d»‘q8Ã4Y0õ<²@ñO8;Wºëi»ë™Õ߇…Û©îýƒ,ZeX^ûôþ¥Ç¨ù†ã…Ïȸ7o!½Ñ«T1 ó7Œbÿcÿæ†6´ÉWP,ÐnA̱ 5ÈøŽ?TG£â;Ø„nÑÛatlÃ?Û!ËLúxø[b:ç·?"Jå Iïº* Ê.».k ?ñøzU²=ªß¬`›E9ŒÜ]mw7’:t>l ‡ºáÀ £»rƒ¾/2÷ˆB]@EU“[N“™GnÇú0¨žùO°»cv©`¡ÆîÈýùëŸTXå)P‡ÖU¾¦ÎYÀì4tÞÿÉÁ³ WèŠ<.ð›X>½tbm¨u[=0£ÊrïÃ2kòñ\+t% x=0ÉœïÉ ¬Îé#_d¦ TÍi>XœX}oT˜GÀMlŠúÌ …Îg3c-Œi×–Zãl§)GþNN®)î-"ñYÌÈœ‚´X²l蘩F+”,òÂ\ÁíPø÷®Ü¾u¦ñ˜¢Üƒ–ý§6úpÔìO»|ôŸRÿ2ÎÖ¬Ãy¢OÚ+¾cxqß08²·úˆßG· +)£Ö ¬kOîåXÏ]u+Æó q¾ÌÉA&|VÖiPvv.;Œí`§¾>ð\´žÚöL?Ì–`rûŠP\År›òFJ›« ´FÕ'ŽÃÖ Ã*×ëŒpéÕOɘ€*ŽŸÒÔc±øë„îm¶¼Ÿs>ìT0Ä=iýz3}²ó3EÌÌ´L&Œ§UŒcþËöååúE\{»S^Zô»sJo_Û@Šˆ.¶4,1vÇÛëëw>šÍ̸ År Ý ·f ÂÌÇë)ýÖ{ )2g›‰A5ôšÛÅ£ö�bVoj@ùþ_6[e µ!¡çI7fÝc>žw´µŒp»¶÷óç꯱P¦"‰¶Sý¥ÂÓIˆŽÖÿ¿Ð›+*Ï ‰–`ÛÑÎ ß/V:A´Ÿwæî×ýŸš¼W¸U‘õ›ë EÚ^رîÙ}o¥¦‹£èÒMW·«4ÝÀhTŽç¿»›–¨€†grZ�SF+Bg¾R_ÈJÊÇƜͩVs%cÌÎRhj³ “‹nffU’Ù-'X%¶™‘ÊzQÊôÉÐJ³¼¡/¼ók¢-ŽàÂ¥dK¸QåŽ2qEº“F}¡ß›ßêä6 ­9ëk —BŠèÎÄœÉV,€qçŠRØÔàt<ø-š.†hiIx¡l Ñ¡N ÷kűGÕ +U)Ć^áh­ÀÚ#Í,¾‘á†& œ[,/È$Üûn˜ÝBJ§¼ 1ûW8³,ñ[ ”°íêdјÖvýŸ®õøT¿·\½Á G0b5'í`ÄÔ£Z`SÖÌÐ�™ìŠ"Ñý{˜•……Ø‹löå¶Ñ‰{ ¨PK¸yuSšÈ?CÆdôÔϳ®ÑIlêœÛCþývÎ$žìLʹäD‹öëìá‰úÓe |ϦÛOI”/k̯){·D…8ÉkV›§mÆ0t~êà´Ï7@æ'B“Iá[ñB‘¿I){æ9?Õªøè¡pšgV©íüËõ—ÈÍT63zl§/ÖõJš„ÖBkùj,û’¿¬Šx,­eÌSêÚ©™ÑgïL¨•ŽÞOÒk1g†I"åÛ4t§G å¡©öJÒ.³¥]ÙRïùÕ lõóé®/5�5ݧ‰  ïÍW:�õƒ'az„‹ø¥_)²Ê<2W²×Oqi<3:ÚU lÈTà—Æ>qI þQÆJGZÄüæIf+Íùàíí_“æ=y”ÙŠUD±‰O°„¶œQçËBnõñ•å®¨KÄzrû/&@R ªEØü”îË4½Õ;ü7l½*ræÁï£=lšye7G¥äÙjLJFX€D‘8¡>îÙ_†ŒjÈÆÇ[]'@OÓÔ½ÔpR�”µ©ÛaUŠÔº¾¾5ί€Á !D{ª°Bj¬6}”akÍ~ŸKÚ¹+ œ“Б˜–ýÊj®nÂRi9$±GÏŠ}Ÿþ…Ôoì};¶½™s †tÜ/Š‡\;Hʆ,{‡LL7e¬ƒ½ú^ìHûA ‡‚+Ì\•ù]9cU †ˆÌ¯§£á±úúh懹o=GË…6@·Ú£éŽtä²ñÝ¢-ºY¨•éÔçO~£ÏhD“ÄÉE§èn_þ¤AÚ[õ‚Y»Â¯5}ݱ~gk%žÇ”X,^—ù ¿—©cv›¶(ÕNZZŠb“òšÞG”ç>#.Ù$´œßÝØV¸6f‹5êÉê[‚¶Èü–é®0fœ–®Q ¨?ZíœhŸa}rß¾¾pG ÇE×{þð–ÅãÓy<« A;±åMn!¬lú^2T>[Å­ <åQèXßžq•fkƒËPeÛ;& æ(aÖ Â.Ÿù«ž2œ²Äûäâ8ÔUéµy“AÙ„Iâ䉉ÈfEß÷hä)!ÂèLROý»T™@�C.ìjÍ,‘ô‘dk@•­´—ÞíÇå©åsÕ¢ÁÀHžWj×X[zqdD<‡$ìÚ£Q€iu‘Å =½ÝiÞ Hð/=òØwå >v£w×ðMXìÄ~3JaÎÃò:R¼Œ½™CD?–:¹ O¤e3ó&0}.ÓÌÜ1]Þ¯yOi+àQG±*ĹÏ)…6`—†Aºt&¥*¤cTEt";]9:Ђšùoï‘ó=ÑmèlÖê§Ç €16ûø*vÖM˜´Šif駢 …\pm m¹m=‘¿µ,(`à®t[&vyÃߘÐD½7и϶ôz¨ L§¥šzÌtcÞ©ê±ü^Jy{ôuõÕMæÞ°ççõ¨.ý.5·c2Ú4Öƒ>ü6m‡˜¸¡ › j/¾…Sf?iJLê× .úŸ�ÃëRôái{šB€öP±TXfœ['&¼ûÜž#)WLÆÏÅhë!üË Åù—Î^E•yç%,+ë4Èm„Ù¤H¨9®3$eGûúÌ”"Š“12‚ÍWH{·÷€ã\Y+Oói|QcÓ·Ép×"¨öŠ(kYÞÅ8J‚'ÒøSo´!œ½í®Z¥VÇ6¤åWúÔãÖÓׄDÇ`i7½ØûïêKÜp!Ô0}ÝLc X³k«—L«£Ê«ƒ¸GÓw`cÍŽ+²©'J¬0 TõŒ^%ý]öÜô°Œý.Zß’€AyÊFk{Œ|ó  ¼7Ë¡ð|K÷²Çiä=Sw_bžPidðý$8œ!ʸÏÿâGvw ¡•HÎÅ|n\Âb¶:Cz¡Sî:–d.Wó¯Çt‰cVÒÂ+K‚lЭJÛKXª8¯—ºþ/ƺµ†^Ä®€UÙî¡Wá]­2l¥‚NÏ~ÚÑwÈ­Á˜;oµ¼e §J‘æY¹Ù,Èöÿè“(ƒPVtu0sL‘»º“ï&¹?¦¸9ì’ ®ýi½÷†¶«‡üðzTÞ¥&HÏ…ye´2ÊèoR5û®á/ÀCF<²|VÉoÃQ°ë¸øÿ¡"I�lÏ”øô%¶ìaÆìUS•ŸMøâØÇn‚¶ãp蜉®hÙšÅÅ0Aªp/ëªÅjK`FþQp„�oÖ‘?«6Χéz{YRùlŸHÇ­îe”™1—úÊý¬.—QæîA3ÓºOöj¤ "v‡–K4ºHeÚ–Ò3†D¹ãwÁ*ß*’Åé‹ÛÝÕCY[_#žÅé˜eõâ©@§êeƒ®„äsŠ+–+Þp—vO¶Wï;«$ã®ç)Ÿ(ßdãÌuzdÜSPÎÞ·ž–(,æœÆ‘nÖi>ô/XI”…OD@EW—LÜsËšµ‡QÞœrMÑ©h©ˆ§àÁOμø§‹ÎÒ­'Êê:må2ß ’BŽì݈™IÖµË-§öthšþ[q{-ô8¡0N©|²ÝyiéÖâ%Í.¡ãpÚC¨Pä"çv8ÝDö¸XH‚󉟜™lrxªJy6ÿ¥^®³QúÊ8Ñz™GµÐ‚Õä§o2o¸¶ßŸ_h^×a#ÌœÒ%£öŽ¨ªÏ‹¦¥ÜEݬ±ã|Ô>ûGdßÓŸ8 É|BfLkª Šnñz#b–Á½7¬ø\‚ùÀ!É”ƒ8J,ù.Žòï&׋Vº€B/qª¶©?l7ãôòQGžôÿ+_K[EÆg-¶ó$¢:r~¯fk(#gyÙ¤Í8¬j?|ªÞhtÆŸ$yq•ØÞSjL|² œ¬¿c0gXkýØ8îKøíxåÿ“Ξ¯�ŸIp¤Ûœ\tÔÀÓ8+ù—B¬¨Tæ»};G½c[dJ±ÝZºË‡¡ß¿üŽ`Œ]Á,.1)Ý’œVãP}  ð§½ÛÂ;ú_S½{<QÒ¬„ʇ7+òÔ–퉻•å0YC'61°ZB­ÒSÙŠž>¤âF¥#m‰Ñý%Aº¨?HZ5>°y~tí²Bò¢ÂÛ™öÁY}#X¨íw„œ©êE¿n,u«òÙT_ïøÉV±›TAî…ÎaJë¦ÚK!®bÑÏ›¾Ú‹;~j™Oð…<àTe«÷ Š,&”»½G3¯²-<AÍÜüø—]U•ȃTW„Îœ•¨Õ0B´ñ{¯OöUÅ«D#g=ßdüôŒ¦øI2³_J‚A߇Ÿ9<ÕÝ”;Ð<qJ¶F¿V s~V«¼^Óo‚˜åˆvÐùÕsŸŸ¨pY¤ÔÄ#ÊêV -Ørߪh:ƒ¨Ç6Qqè[]ÀŠšPÐ]5î :g0îðçµ?IBYû\©gaŸ;äAñþ®"mHË?»n:9 7Rz¬ Ç¥…+Elúw™aûÙ}:EQEÕÌÁtÞ1ôL_7”HàñP 8ww åÕÉé BÂ_ZåW�žfÖeâñ¤êLéëê¼ÛY¹¹(ðò¥ÖÅ˺ífŠ‡Ý}OD¤V÷¨aIì™HpY¿½–Aú®ýÕøN'•‘ö'Ì„ÏusfN["åÁiK1±²Ø%úG™ÐmÿŠÎ 5nT¦ÜxJ@Á·MÎÄp†³*Á¡åHKξBòˆ§„€ßüä‹ó35C5IXkN=ã{œG¨Ø¨äš-¨>ÓÿbÔ2¦+ݘçËŠªj¯þT·jÀ £õï6ó·Ÿx°+J¬ï']ÕËŸ<kˆ¥¨ÿœwŽüb¶ýG+=iš1×!àXíÓLÛd @_ŽÒHf‹¾mÓæ¬&”v/"Yyÿò{Ú„·”ÆN0x` UôÎ’¦CœóáŸÎ çÖ£ãúˆáΧd¯Ñ[a ­1@$K kNôþíUA¦çÑLÚö•ï)š]0+IêÉšq8´(}û+§’(Ž3Ou‘Þ¬‡ÜFÔëªÂ[¹gJu¨pÃFÍ™Òí‡4w°Š< –4hÝöfïÉéSŽÐ:€Î¢ ô,3hù<zCJ×n¢Õ!PÙÓú_Ïc(—†ÿPÔ« ªñÕ[1Úq9UprД=½Îü;ï»I…ª”—«À¡Â²vÖ>˃bæÒõ¶_ÿ‚[dá‘URömÝÃlC1q¬]ÃÝ®³=½GT¶ÞçImXŠBdi0ìGáÉwgå$F'¼2û´Dö-Ç�ã‹’W‹úI53:‚ F·ËÐÃ;lë/ZÒ˜Œ¹áóª!­À(aбµZdÃè­ÀIñ [þz¨š¦n"“³f=ÑÈ›¦\?´bb§ªß&^G_¾8NöÂfŸédMÛŒ¨ Ã)7§a¨÷óÛçD¾NŒ^·èèË­ñ.Ñb¸ÉoþPèZ4>×S½³Ä$‰‘©Âž•öóÇO=„oÈR2t÷‹ýU“ˆ‚=/¹e¡À‹ûŠ^©‰'PQ¢OÒÏ´!âýE¡Éôþ�{?jŽì–!_3#þ©¸n¢ü˜ˆa5´[¹pù´ŠÝÄgÖ;‘òj‰’y=# ¾‚y.(kÑXDñLÇ TqcDeóã}¯o? Ç"L]©½ëØeÛÓ0r<ZœáñFè[›®RBto Z2Ób=ë‘°<©…äߨ]»,94 7Cg%—W¦Ýl}ñd¤ù­# ƒ³HQ*—A¶›œö*àÓñíè|!·µÆg9áî/<½±²êû, Ê«üTM´^Ïq´9µçzÆKßSþr¸çu”­$’à‡ÏÁúö5h]MÚ2 ®rËЕ0ótöCƒ¦qÉú·h.¢¯ÛÔÇ]£ÆäA Ÿ�ãÌë?g,Ì}¥o§r`«+3¸–e°8#šip‰óm]ä…‘² #r «FÇ:À§kÝ¿9·y”ïú—DeNŒFXzYÊVœ±!àͨ ݯ{•§…kƒÆ [¦ó(:[F1Ò œ .ÓÖfæ˜I{>D…‘V_jÚ*µöVp>pyî1}…?†¡ßµB¨™77ÜSµ»íNœÂîŽiâ8¥''çdŒî*úlÅ{çh—(ëë§À‚_¶ÚòleÍ^1ý°´t#ñ<l{â¿Ä<Œ¢Ê ùÙµòOYÃïžÚð8µB _r«sŠD¥†žgÚ„u㜹œ8ÐMEÌÝʼnJ?_߶§Ä=‡vȲƒêSH%[¢ ‡Ù)°r#‚e5¦v™::|ô…Ù§®¢Îñ¦¬Èºœ÷ðÒöR˜àƒ‹×kI]sHŒ~ZZ´™²–"tNI;’ •‹U;[_Ès5‘†%Ä@‘nÝâ©ZœOõE¤äuÝcò`õfÀÿcô¸ìm§òÃtv;'8žƒýÊZ°L]úÂ<.ôoÒA³G´³0­ŠÍ+}›ò&\^OiÄN”‰…r´}Û‹¨9ƒA§+Ïït„ÓÐõ!Xy”QûÙ±.Œá8¢9åºCÝ¿úõSoFÇXÁŽü¬žEÚV#Š»äCÁ$m;§Ü ©N%â”x*RüۈżDF§Ñöàò6ý7øËìH¡zLÍjd¦#DýlP÷øÌ‚DSâã[QHåë!»–³ S¸W…\«':]»gܲI¹Ïã¬/p®øú†Ï‹ödçÃÑÞ Í;9¥ås•³gçÊi·Òyt <¹S}EÉ‘±ŒUiµ<P Óþ<p/Çq¸_²²ã^Øö$üî,º;í¼†B¥™Ò;ü×3Í]›îæFn­§ü¥ì0íß°6tÛÓ‘eÙ]`Á@MZ¸þ+ÎQšùy)…¿å“;0½ÇÜA‡¥ópj´Çxö>…ëÃN%OEèYÌJO*‚U9¦,WÓ¿f ŽúúÆ �6Ç79/=K6íðJ¹Ÿ¥H³Òïjƒ®†ýÕYKZ:Ò(7×Yˆv¼î¼ÞZ0[áeÆ}™:/Ñ›|ʘÝw@.ˆÂ´ôàêŇ™_Ñù úbúÇØGqóä8X§WP-q’9TKÆtð<È·JÅ0ÔL0-‡JÌlS{½Æ”·Mµ’Ä™l?¹”'_¡–dÿΛÌ"¯*F‚Pè((RwƒC9Ðén‡âBA翪w Gqdä´æ+Å$Àß$¸ÁÌóºíZ0wóß Š¿¥F@ ZÓ³ŽþÃaw@ ä.ÑØ+Wó-JeÚ¸ù~ö™Ù|ôñÄ]×*¥ ò\•Øsë Yf¹“b§yìª j÷ÞÁ½«¤rõõQ ìß•GÖUÖ£ÖliøV£0™'OLoßú·+R’+Þ`þÃN¢eúSço& v„Í÷°ݸµüÎ 6J<•RîÈ #KéhÑÏ|9ú‘aî`ðLfd0 ?<žw[ÿÈžùr)ûxd{ÏÇôê=%”ÿ+Lê8«|O Z@sæAØú*ZF™Ô,H Nën‚N¥½z´HËÔu>D§|QßgšÇ®j†Ä%ãü«.KF_Û¾ÚŽ×Sáòpþ ÷göÐ÷ªDð…‰î,ðLÿT…šØo¯0fó{åq G8z»Eá,EÎ^öãÕˆv?²€3¯. ¬fÆ‘¨j”竓Ž?®mû |ÛRž¹'A«fØÅ€.ž ürnO:à¦0€´fõÂkúF¼`ïÀ0£5–ñŒ'¡Áy@atwu.A½Ù¨ àþ:´,fàJ#Ç"È ?•ö%U´u¾æ"VC C`Äù {ïÊ`æu5{Ë:C¯yMºÅ|íx—€S;÷µ&°P2™é ¼IÕƒ•²…å€xÞ‘¬]Ãó›0hÚ$¨ßü—§( 4Ùùµ\W7Ûy·ô«¯I‰²ßX-tu$óœÕú5~-›à�EäÉX1p`i°ÌÂTܤTÀž‚’(QÈõgäIæ1 ÙH‰VÔ©#%z<{êáúj¦k(†H "–¾_݆eYWÚVë%2Ä| ú´@í°º*Å;‚£"RÃmx©ÄdûêÑÌ2Kª²*Lç¬ûš¯Ê—\(^±H-裞&QïÅË 2çÕ‘ã©ŽÞ±Q6à×­&!9’L‘4¼Ï5þIX9Ì|õz¢,»›Ÿuøånì_TÝ*rÿ<Ǻ£çY]ÿñ¼mÇÐ “ö=š f…£ªåâ䶼­r'ˆÅîtcG <ZOñ}w>š7ççzj½ÜØùÓÿlUQ]”y6ce°½Òø|±qÅë†ÍÕb$yéðˆôù•ï{$¥tÌ>Õù»Æ‰½†[êÌûžEµm]I/—Næ!ª‚tГ§ž¶n¿ÊþÖ+ä`”﬎$ódÙØÓžôU«�€¶'gùÂ¥3`ÁÛ×ïÍ!oÍêw»žnyÒž­à[½ÛÿkFáAþ0,‚"$]­£5 µÃÜÅ·Žüi¢hÍèŒkœ¾èpÍ/ŸÇúh@Q Ü@ §Óøž •GZtý¤Qa]Fs#ß8âx,?ß]_Ñø3šæº‘´YßpJbLm²!²ÌtGËéŽ,'³4‡ã±ƒ5íòå^ô:Ž¦ ë)dÊÓeŸñ P£wÈÔ¶G Í.+ƒâ¿lÓ e‚„â C„éFœ©—úÃèÞÕwØ­ñ|¡#xPõ œ &vX®Ôï½ uK”Ô³ eø¹wÌ>Ê›å&!N¾Ÿ{ÞåwkR> ãÕsæ¾ åŠüf]ç¶5t�ÁÀ+òêîÕmQTf>¤¤â#}äÏÞSáP»=ÃÚ<I}¨¯ež£Â Ñ<ëÝ@#7¬-É ƒqï´:ZÁD™+k?,{ú6‹,•ÈëÀD&>lNð<9{+˜vfŒ~¡9ìO€ô¶üp—5‹È·>uýÿ½iMUÆç£ëÆ·-L¸“.ˆ—–`eò™Ò@MfK™e:Ÿ½ ê:\çcwž;Óv¥ã›­ñ¨Î¤³ Ê«0}ÙH/ŒýyôµkŠCŸª O_êT˜ÈÀKr`ìI5�Ò]U3†(M“ð¬JMZ¹™ýÇþ`lÍ[””¼Ôi½[YiT$f wØ°5Eö:t?Ï ó<Ô:§G‚Yô®‚ÃTHЧ ÃXÔqº•¶ ·–Ō橥F$V.V &ÐQj­æ‘I¶E^ÏŒR­DákS‰2ô9ÄjZz®•¡ÉXXàüÇ*õª…ð_ßFSUì!d« ¹j¥ UÈåòQÆáô™ºŸÏ&›Á‹NAF‡pÄ}ël‰! @ Q‹‡^Š¯ý”~QäFÿEСUô…熨‚’•WëÚîcý<[‡}ÎØ)‚´˜ExãE‘*yì"èb<ŽÎ“5˜þTØ°Ïz«ý€‚ZßÁ^°õÈ7#Ðm*ÿ²bQéuWRéÛÀ“ϛΧGc´Tïè–,!YQèI}2}ýøM¬V©H› W:tJ] AÍø7„¯Ôgó²Dé°Ð_ôÿ ã€~czמDÇfpƒ;Hý®“Ø£ÎÜÿ%\õ8Ø+‘‘ñÑWç-34³o¿ü,>ö`—¬kÜÓ­ ­ v¤'"c!M�ýwi3ÿPÛÕ”£kmºü@'YØ¥hŒµÓiPÞ®í*z²k±ûÒ3íÊ°áÀ -¬¹.JBpA%T¼ŠÍ}@%ý@ÁxñĺŒVg~0?çÑá¤R�,£(þQ“ÚZÈDl {öÍý²ð–\Ê ™è¯ü ×Ü,[uÄrPô‚ôý¬ƒ9sÕ.å03ÒI…Þk³AçÎóqˆD®SJ€ÿ˜¶d€"Ôòð'­ñ‡ä¾'¡™ï‹ ~ï]ìÁÙðò5XÓ ð(r–DE °]†¼FNŽn礮Dô±šVzq77¶ãíÂ8~°úx­Âzì惥Ç2;/ÊŽ§jðlõxXŸ_t½X¥™J_Í|VSåº ôqcù°È{>&¬™®w+ÀW«Å$‚ÑåýX•™O6Ρ�Ñ(¢"ß\ì\]±ˆA¯h¡B ùÿÿo–Ñ .Ä{q0>ÜíòÁ‡0éhýŒ­7>†ªƒ“íDô…3*wykFê`9 ȥ;6½vÂÇ”dÃ_ì Dê‡Ç(ô—3ñqïNo|Æ„÷t¶ÐuØ,Üû´Y’ù–ñ”¦ €>k‚ÂÊgž° L\Ð"ôÇÙR•Íà"Ú£ß{Ÿ¢JKjùLØFLõY•º¤ží5%¼ŒЋå4Âk^<5V–ióŽ¾Dj駱¸âmܽÚÁ+²X\Y§³ev;·²®ÿcH\ß~q—ÕÛú\´­N=¥ÊCgþ $ÞºÍÁ¢ú§ëpÑ~À#1/¨Æ™z‘æw—йØi«¹§Á;è ÆÝ' < }!‘¸×¹x±²…lØíª˜¿´›‹¢ÄÙæ1Èúx¯Ýj†:ÕÐzXa/v¿ŠÄ7B ›ÑvEÌÜ ÄŠ]ìE7Í7ƒè|aõŽêº«ìê`i9Ünñ¥ÎBö£ï¿¡Ðàñ~Âí7…FaÒ|¡0OV%¿ôDx€ô’¬üÊg=¬$ŠØæB¹K[ŸW¼…Xƒˆü("Kºrm Á¥×\} Κühšµvìed[‘•-P0®å\OËkFdq´Êocp9ÃœÄòrE¯Ï,ÆlÖÞÁÔÚdxŠUþù—¾8˜5³Y ßúY‹iMÎA'Ï¿³`Ê ï†aâ|,¸aVç ‰}ÆíÙÞq7Χ£üË›áëŽÜ”¨y™˜{Ðñ3±�n=õÃÐMjªuÄ ð®ù9˜5õÍr1Èj_G$…‘,ÝPÊ1ŸnxoÆRÉÊÃÊ;”…æµÕÐæqODUMë–hñæ…U§VV±ùÜkk²—+j„ß[|¦±:‹ ¥+›SÄÛL™U˜ë\‡SoAK‹‹¬3J+@g7ÚLò'-�=Ü ˜¢ò^ ¯q|cÅLD¡Aˆí΀¥¶ª Æ¢+L`øï[ê¼çR ¾ÊÚC±CŸx jßÏ’í|ZCÎh·?¾Ó½¦QÒÈ}ßÓ_’g(({‘}w°(Š0R[ì >~×;–Î 4Ž&­xÝÕ#_É{¢sÐP±gM+YŠ2kæ§ÈYUÊ&½ÁžÝLþ¾ÓÈ??!úßç´N®:âiðÑ.Ãi'°°©ÛÖ‡žAat1`NÍîÚ?ø¥>q¶@ÉçÛ/¼É°Ó—Át¤rR.ˆeýÕp§øO ='¿ B èX—MyÏ@ðÆNs³¥Ã%'_ö{¢äe×_®N ®ý¦¾ôÞ•ÜÁ¡uÞBYO›îãaÄÔ¼Ws³tñOãtêá6¢YýÇÆX-4dN[ÍÕl=ÿèFœ‡þ4* ¾ #ìxä‰Ï<Óâ›÷<oêü}ú,3º-Ý1:Ö4hý¬CwyÆ!\þ˷α“ŽÈÔHk[ÐÙ;üã0Œ¼<GÃÅçéB7æbúè؉j̲ëëãi êþo=ǤyË€¥œèO¦»Æ³.d2ß$Óª~æÅ"·*Vš”¡z¯›Üëpc{;ü¨KØ;š–G||DŒÝ\O$Àveob`»�¹cÀ5kÛ·»Ù‹çÌÏ÷Ø¥A¾Ø!sæ){¯í´ð~¦ý'±jj™9Zú^WÍÅë$Ðþh‘ïù…'1ø¤”ÛhŠco,e½ÖÑü&«éj<Rå =¥ˆµN<«¬Vr±¯ë'lj;} a‰ÎU¹¯Í®•Ž2cö@¥#(1˜ƒÔôr†••½«s•—>”‘¢ÂØ×Y[¤ôPO“lZCü¬å6»•,yÙòRl˜Ú+½ƒ5û@EƶYÛs‹#qýò-I½”Šo/K8;„’û|ܳ^</HT^V¥3¤• ¥° •Á,ÓéÌ„ö”þB=9®&Ü‘£®< Þ^;YPYÕ†4«½£õžªÇŽYã¹+§P¸°îÛSÞÛª|‡º÷æ`Ñ™ûA ñ¾G&ÚäUP,ªÆžŒˆß2ØÔ#É jß»º­¿K/‡à%~éÉfßGBˆœq 䟹܇èÚãY ½¨=£¢\wQ©>¡yξ.¥½Ö“Gp…_Xs}ÑÅ¡Ì3Ï[S½JÞídHSí†NMH÷Ý•ñm í™fß=qL×^V«›î•O‘˶ô…©nŠc)5¤Cvp†)ÝþhÖê¹?̾8Š­Ÿ·}‡TÇÅP/Î?E¡?Á6FºÙûb•I¡¥zè¯|\·ç áù_“8rþg9ã˜Îpñ´¸4Tg2÷&ˆÑ:$³‚¤æa½g¾êZ|e[�Ó3v }WuˆîNíå`©"φq¹ê~RÄ톂iÎ)™-9šN¿ß·Dú‰T8ïÎô|ãvç9\9ºªîÞ¡f¨ep9}ˆý;¿8©}¿saîrü¨ø]TÄ‘Öá ¬›<ŒÍ‰T˜Í³=lwç¥M{ºõlÍ{nJ¯ãe²…Éš1œ¿Lh¶O%Ï3Ú¥;Àè —>8Ìy×Ϭya)ib/,qP¬íìÕ}bòJ´; Éyë"(1Ô½q–Ø0²÷Ýsß ¯N:Ë>÷ìs¦ou5¦Óe€À3+[«VÌ¥5wiv­wš¯´¹h™€­Hßÿ<é(`ó§‡WT•¶§‹XÄ^ñVao0–âÌÕÜŽ¶–‘ó5;?Ç”ãø2•AøÙ9³fa"¿aA&QxqxZÿÓF…0{–‹ÇšÝïmk£¬\£Jôæ{¨´Îžp@ÏEåÕ£O‡?–ŽÁÞÌã½›¶j墑€Î˜ɧ'µ!)šùŸ• "Ãz­îHèE©O–³`ßVA´A%H Ž=Ì&*ïOýq{@'À]=–‚Ïs׸“tðlXÈgÛûŽjœ{Gæ0™ÓKPÔ!ýQúÐÕ’üî^^“ئ{ôÝ:Э>÷¦ãK þlæj]²ŒH~B1�*zÖŠŒJºõ�§éû¾ºý‹$¶ãNQ”žXÛÑzƒ¢HÙÑoXû[åêÍw¥<ço¿0”u¯“BÀ0YL,üfvýC(ãÛ˜ü˜,`§V†BEÛy¦Æ:I”'2eäjJ1À Х³Îý³ùeIè¿fîrQrÕü4–@‘Ùf–IÆ�Cæá·6¶Qì9†çØãuOµžÑ0‰AÈ°,�&×—ë°â‘˜_QÕ)©Ò·s;òPåçÀÙGg•,ÍX#¤ÆÐLèwõ?cìs¯¢ç®ëÕeŸþœ‡7;A¦ µ8}³gšu‘—,E<3ÅÓÞõÆÜȪÿ¬ºe¯ ÖDÿ‰b¿§If³O#Z5Ê/A™2‡ÁuaSbÞå]ó@âáÏeFÎÔíE¼yšGsâ­¯µBâ= Tæ úE¸„W¯oo-6†$úo|1âÜ 1ªï"`]°aW¯zã=¯ =6ܽã%’D~í€v©ùÔ9L?òS¬PQ ¨EòéºYy`ð8osʃh;x‚®Œ5tî#¢óÛÂÃÒgˆã$Zs Ù.îú´s]D¤ü¢,7â›=Zúä xÏ]éû;ßÿ€m|è̱ñJ5Àþgÿ˽_]®·6iqጄ˜;\2–«0Í h#³õ»tmuˆ÷ˆºÏÕ*Ó0VgV™ñ²ÝHnÓøL#¯Ì¤ï{¼à;bû,¢Å€õIåýU…7Š€+.w=-Hô%BdË¢Ê$ÛZ±Á~¤Eö®rË9R Fö«ÀÚBéeK¥òf¤N§3å¼³û°ËµÍP™•Ðmàá«ç*2ŒÒ­]¤çΩæ�7­—óv«˜…×xáQ’8Lw7ög;ï?Wð£EgŠSÚ sßýû?Ž ß{ºd‚J£»ñ]0¡oðzei 1¿Òæe×ôÛºPÂA,(÷Ù”q gÕƒ–Ýb)ˆQvAÛÖüG1¹v˜D>áºZßÒÜ,ʾ†ŒMkX0YX{v.*¬: b¹ç®ø¼Ø©dÌ´$ÈJäT:YÐ@nXõçQ²Î`FÍŒºò€"òbye4³:U³­zÇÀvþù¨¾)öÞÓu¸M öMK·wAÚê†Ò>E,áÅñMæûžî·¯ž”á>´5ÊõæFÙxÊ_é¦ûXÝ•v)VØ:ÚLýg¬µà{{†1ŒsK¬'óÀž8¬ZA˜eî¥i-è#±¾ êss@P¼ðéØš¯´8ϼöfÈ‚]?'u«C9q@b¨ü†rûzS·­Õ{ ô6G P§º<+ÕõjeêºMV«íîd+?þÂÇì(Z2míæfH¥I¢î ë²pWÖ»|¢ñWúbôþ¼.Ã%°ô§~™·§Ób‹^^›¿^£´¯"BÝ&¾RA¦ôƒ¶Ûžºß·ÄŽj›zx ·è\KoÎ\ùÅ)Û­½Ú­Gf˜©*&S}^CßrÿŠÛzbó'Ʋ y¤ãÖƒò[ñ)tNfëb!IÓ:î.\¾>ÇE¨8BQ,úBôð¥÷�r`]ž•b,¹é%¼¢%þ`MÓR:h;P`ʉ%­-“ȼ¸Ï⎻²YoЩþS™%ÖÁsôŽŠFo0¢ìžÕm‰¢ê"áVJbõ¡Ø;~¢ì™îïô 1r†ï€ÙG££B}PñÞëŸV)ŠíËžd§Ò ƒw¹Ç˜{ÌË*gô̵'ÈE?™³½äVº¶ÿï°ðâÒ@!eyÒßtó·Ÿž*×&s^šòZÚæ`@¹™Áp4´]ñÔa½õM¼i}Þk&ij°ã±q¼ÔèO\:µlºêÝy Ð—ñ¡Ejóp9"7TGÅûƪ°¡E·±S+£Èº^oO_êf$ÿÏ“ˆÕŠ—ÔCO”,^‰†( é -­§‚�*c=Í&Ž"L~‚çîkMRgjî«ÔÅ€dÒúl´rzüÁ•ª4H̶ 3º[l3™{E¦íz‘©,!úôËœÕ``Ùòæ°4¶n8Ìb‡õ‹ŸÐÈPŸ)®Ö#Î’ ·iflKŒ¼šq¢Lg.$/x)W c£-Z™Ì¦RúÓ£"ã`ÉË»I]#Ç£uOü5z]µ h4¸"H¶Jº(*‰€ÿtœLIȦs8X>e¾=é$¶U“ÍlJS‚¬í´¿œT˜ŒÂM@É4¿x@q•Ý¤ —6 ’±õt§óŽÖÖíˆ/Û&JQ`Íat®÷ôË7¦¯ÌßâKâ–\IJ¡KèLj<PqM¦l§ÒxÓ öÞOQú«é O¹¸1—øTB4àmÍXoD«óac%M=áx–1½€J8Z©¬X86Ýlu(oœaú9ei¶f&7töŸªÞoEw¡†pÁïäPS§((ãƒy_Âvïµ'—é<T@oÝ ~Ü6ñO"k ìwp¿ÖÛ»‡+9 Ö¢ìãé0ŠÎêtb¦üwaÔȲ~JÓt úL‰ucîkÊ~\¨ÓðDÉ@*`7¢c°BZÿPúWžÚwEfÔWÍà ¶DŽŽM� rÈçÍô¾kZÄàpâÔ{[êTñï¿îýjœÀà°™þñôy)§hT\ž¿Ä+>~’Ï‹}K¥xkG�€Ê45k^˜³áxê[c�ñš)qâ)ËòöÝlcŒGkO…®¦õOgÛÄ`¿®í®ÓðL8ÏñVîadõÎóå)úatΠ£š¹Ì_ý0v° ¾±Â¼±¦¿0Af½Sb§n'> ÃÈÑ¥)øP5Ê|¿d5”ƒQÊþù®hZΧé¢ÈÎõ¿=žf®±ƒdûŒ Y1štK÷$3K3¾ÅEFöqÿNB^?x^ÕGh/jÁT[Œ}ɵqh¹‘EŒ ™NÆ/u ²‰¶ßõDÿ¿W1>ºÓiŒÃpePÇV1¹Í‚O|ß­qûN½Þæ±¾ýш¥ÞŠ¦Æ¾cEÆRE‹GÞûIâßyJT¡á€xº`bl×'ìéÀ´ìù›Böaêy8çä ºâ6¤Žån‘mªôPWÜÁ×D.©¿AçP˜'.^áJQŠêlêÈDÿö¹PÐsn•¡ŒÊdgˆÎôÐ8Ö‡ù4Àñú­FM€»qWvú+'*ÖRwÜ÷É“ç¼lÇÓÂúÆy:ã&îÓꇇàè(R?$“À D­aöBó¶›vçÙª¼ÿHÔJŠÌÃpÒç^hE&ï£ë€££æÐ)Kd‡}½ ­"·j˜w8ìÊ ­õM!|q”ÅñÃ< í¬@f'=ø|Éû?‡›yàoÍyYÌí§O:ˆDítºüï0üo PVß~㸷© äÆn»™á^wõrjÜ~k÷Ë4÷×Í"b[×&¦9µã Ý*ü—‡üUCOV©û7³ë'IpªGXÞUŽîðÐTÒìj ÎýÆTš.èòîD•(¹ú#ÅCðSóSûBaiì¹ÚªòùË+ö)¹ß³Öº8[ß1axjÇ`åÉVx ƒ†Ž€Ä2 YF¯¦÷·ƒ÷sÚgÂ2‘_Ñ“†$ˆÛÆ s3|_á^áøʵôgN Eœèèÿ²ÎêÔe¬Ø<Ìî4û•¶~åù•r?ŠN±õÏK_WÖȃ¾ÔŠ¯X‚¼/Î:V³‚R§ëöDËy ÑZ‡¡žŸ¹ê$•JB „£  wüÇZ‚^ËEÃЭ ÏÀ!–«émOϵøÔ¸U/ ¨•#¯n]«ö¯ÞýÛ¡Ø›°29[ÓTûOç.80asÉùø kÅ&ª2N^:N.½œêQTÑ£mæ÷‡Û+_%8Ö ;Š’‘îbUcwÒvÜX…x à8™Õqõc7¢VÒiÙ€‰WƒÅ¢l•ÎÈXmaÆžØåé¿oþt¾v¯ÔÔå—÷§wØaêVßS’ÖÚM9ÌÛé:£J)mK7F ë×ö¥ÏQX�ŒÂE5Yc ó\è M<‘Ñ™äÙ”²tVY@ÖY¤oÌó°’2þSzB Ü\Û\è1uÚOrß AccPóÿˆÌĵî}á̹— ÄúTn,TÇbežÌIIS³Ó^T©å}/Ì59Ò!kWš8dì˜ë¶·LÌõO³£ÒIµòéÖløò,-٪ȹ¿ü$ÙùÝžÉé2S ó uÜ#³*{7¸K3ÓÈÌMŠÍ;ãZ«ìcìu\ßóòò¯²ÕÃ¥M«$¼~º'æu£Î{s‚ûÞI¶òñ O½Ôt7Âm§€ HûÅ5ÌÂÊ‚C¯ø±'Š×™§|•1½j ãjÒ¬dC›ˆâÌØ\Öi/íDQÈ\p{c/v‚·¿akÂÈ›-£ù J¯¯=ä:¥V¦îŸ®Wmž—‘åž`%ˆ,úF«{˜›E7§Sk˜-¤Ã\÷ø»ŒÕ/øSqÑCE±÷&íM}D¥²wAM•¯fÊ|ûó=Hœ%WˆDÄãâ1_÷̶²èuýÖO¦kYœ<˜shh,€< wîyzbN³©¾ë ²¯¼q.sý7[Xój’˜Bê ý¾‹­²)ÍØ üQ_ÉR CsÂÏPy¬µh?€Œíµ#°»ÔgZý5E‡ó„æ^}¤E!ö¯µ÷ÒÕD_"ú“£6Ç°27Fzô×pÙÂkPÊPcOQa·×ý‰¯™S'9L¬s­‘È) =&‘‹Ÿ<Ó¢2mf›IS¦E™C7Ùâoq”NfX8èfyP8æBºÜÚ¶3iìÒq¬í\ïò¢2[éÿ‚-ƒ¢Ãn,WŒ]#\çåÞN2÷]ñ…ù„6òÛ>*Ϧ’¹V䯿M„¦+=¯ÂyÕ*ÞÊ æV4aÛ•£fî\ƒèß@\KE€ Sªqñ4“Œ¼B˜¿s�’âÔfñž~ ”¾Úî\‡ÝÂØ,ïEù÷™=¶“f( .pîhe%Í?Œ2ùÈ°Æ{;ïGYµWÄ;Ság ·Z;8³2‚ä÷.gyèøv•`?(`4:MJb#Máôè¤9ô#tB£(uÖŠ‘Ÿ‹ º4vl¼Övdpp…îŽþ ëÜœÿù‡‘Y@•ÔýÛÊXäî/‘ D6ƒç¼®ÏƒÔ:s£ã;oDbF…±^‡=$…§Î¿¬º5ÌNìý¿ÒÜÊ=YS±dZèöíkÏ,ˬ?YI‡v¶ù…¿¥¬ÍõÿxüIÉ÷ ZnIl¢gд”hwŸÎ0â tZ}8/@s’ÒM<DzsJÙðÖèôAýs¥{k9ý õ]zHûTå/ŸWik¶…‰ÄÚ_ÑoïêÙ‰U‚!bAåe¾è,£%Òë8xGz~s`nÅÛŒ†\÷âÈ ŠÊl­4= ¦_A• ì�hµÂjÀãŒTë1‹Sæ'V´¸H•¹ÅàŒèÝ:."5ûÛ° ÔÌÖË—üο~¢””j}ZürÁíäý`ðZ·Ö\nÒÊ?,ÅfjCZl5w0±šb|sïÂ܇ ±ê5LÆÎeè+¶†Xí&Ž”7sîa/¤#ùïé$X@4 ÊÞ¡t<± #¤Ì:®Ùðn—SÌÚãúhøþnv %†xX T16q ò]¨p¯‘›Pµ¾íQ“¼¥ÙŒGô±èÄØõ êx ¼W1U˜O­Sò¯7X Ëy¨¦né†9w…W•]ÝXL¼ÿBú€tŠ•Ý—çZŠE|°>³¦èÆܻܜÆ[¹Ì,}K2:½êž¼5D-‘ž  v7Ûé´C’Åât0Ö™½«o@‘ÐóG-E%% Ò¾µH‹†«ùðÑcÑ‚òæhÀÚpÃÉ„ƒmÊž‚¤uNfHëÀ/‡DÑŸý½<m•¯æX9Ðþô—>/ŒšÉðHIÂÐ"Èô“wñöŸÅÙÊN0¡¸“¥5\¨Ï •M.ëÝ}몴náªê–OVϵkGÝÃ\Øšk²Ù¥W@}*åêÿ¸çü~~ä¾ ŒT¯Ë¹= ÑÓãw·"¯à5ô×ÿSëì©•¹½»¸Óœó&2’¦Ä�¨—AÜ.NÁyêh Nª;}cŠµˆ‡�|Üüxך;Ë}fåÓì2˜O{Ãp,X0l~c( •¶‹YWÔ–¥™>T† 1Ï‘EÇœŽŽ}=¿ÑA{m[£ÆÝ ­ýœ?üŒCQéRRÎT�j¢÷qU^&ßšv:/Þ¡ø“éBYdžÀ4¨zÐÂÂÔR¦°îé÷òsØŒÌwžò<óÝ.ñÖÅ Úã� 5Åü•gЋƠ–å¦$ÚõtFdŸïŠºƒU “Ûu¶qmÑ–S3Öô»rNRGÕg<ìØÓ?ÅçäÔ¾fÚM¼9u”Å–Úô ¯Úì\—v¬~þ‡…Hÿ¬¥ d¬_¯‘\v±R© fËTôaÏöÀáÞ°½b=®;”zzv®!ÊÆ3ùYy°Q›ŽÜ/Q¼š‘(†üÞ[/Üsaõ¬+§ïÀ‹}€õpÖNž�:ëŠ (Eì …J$`Ä©G¯îÂDC_(0¬ t$¶+—dìwú,ô-^ùâìÓú9 w)… €Nj`0wáea–-–ÞüãÛU'y±’ö“þB«|ÖN@bÕGhkL«Ù!ô³I…C@þ¸¿Ä N8û™wˆi7Çir˜m3Õó…Ao¤ÿíϦþQ¨à#I•31i®Ó$Ú¼úŽij@!Ö£˜¿ƒ¢zmïù?VæÞ^“ êuÆ ¤ý?2íI—Ô.h*˜f„2Ú”ä½+*0o~ºŸJ­6Zt©Qxõà !;,€‹Ë³ eéyðFì0ÍëÙîp‡ôe_3þܼ ‹;å~vƒa£´÷Ñ×@Ùw#¦<,‚÷“AZD7¨Ì<]Ê{š!R«æJ[a…¢ü‹e¶¬W÷/YäV4›q,3„i­ž;œ~(»qµ ÕF”|ñ#ýñgZ‘­ ¯çbUƒ �˜~? šÓq‰!ø‡§o]ìV¿®á­Èµ}WRí^«§S€ÏÒÄð²ïÑpp(rZ˜Íõ{W4õ: ðà öð÷W츙!¸QÎÁs$Ú>˜e™ ë×Ù­á‰À E5°½Aa'·À³±5ÔDõ X€mO7žï·Ìmð4 f,#Â2hZJE¢÷ëškîÚ-VÃÙþÈŽ¢Åä¤Z]Ö)ÐU>hÓm‡·†§ÍøWxzV·Ix; -ép§pa¨‚r÷ÅÔP®óAÇaoÅTü6ó+×¾R¢,î<`í£vòMâÎYæ¹ÿSŸWhÖå0¥¨­ð2ä}Ø ê} =<èŠ;ÉþZ;õpщÈk¥ÓÖ5.xn‚×JMëVTËåDÁª©Š GËêbbåé(M;5nëÚÆÙîâ;§ºXu#B ”böÈ2TÊÐúý©Jä³yѽ ’¥kš `IÙ" Õ:Ö€#*½¸^n<èaŽm w›Š6À†#§ à@É™¤µg;Ó¡in!Ö¶6Œ*£õqüH©Nù²4(t÷A¦´‘ãÖ– ]oÏêß´˜mV®D`H-¥ÝÙä Q^s^bgÇø^À³,ÜO’K‘“óË>$&;úŸïŽa‡V°­Š&pœ†§ì†"[é½gt¯�àk팖-)kUG�AÔrãËoeiÃè/4y”û³ÆÎ3l˜gîtC÷Ü~²¯ Ò*\ó3$ü±õïDæ¼:�Z®Vìæ·€M‹úMší0Ò’Î÷�´÷'8³p7J.k¶ÙÖ{EcÙSñíà Ýø}kŠ9)'æúÏ’´»åÚã÷ÅŒbG½`½…a�Øgò&üPïž®“?Õ¬µ‰[ì™C½Î¶._ÄâHfÚxe§]ù„a¤­‹›Á¡WJÝCÓï•Úº…¬ÍX9Vf>À½ý*DP`•Új\gY?ßd%R eá§ö¥Š@N¯¾– ËÎbˆ7}}–„c(Æ÷hú.ñ’® (䃺VtÊ;‡1WþÌ¿ «Å1çxÚ= ÈðÒY8*qŠñÏ@† ´TçAT†)dfý>»¶ ¿0nlªiöWSe²8²R%ÎãzòK=ölÖ­€(*íW!ÆfOkc©­ õi¦"‡Òɵ¤çkr$š˜BòxåÚCñÉ2 a¿CLÒýã Ñ*è0¿l/S®í9¨D='A<Øœ·Ü—Cí”;ÎÌ­õþÅMÉWú‚”# ÀÙ)ºq:v{},xVòÚW'…ûUǽ:ÄQsã¬ð±ÀÉ¢wÕ»x¸ÙJçC”€Œz";Wοøåðˆ2Ý „!{íéÑ®¸R¤P1éŽ' $jÁû¢•w.e7{¤¥8­ÓåiϦq ~›„Uå;Îœ›êÅ*éÎÂò¿o©QD­X›CEÐ/ì9?fEÖ°±4màèèË—A…x¯³x§uÛ\Í¿÷ðáÕJƒ4¤0È[-*bÀ>[:bZëY¢ØƒÛ×ï‹8[IíÈ2Jâ¼øÀg´¶:9ÁÒê~—:T¡¡R€âå½g ½9£‰ƒ»¢­øy¡ÄÐHé."-mð_n‘ùx™¡×AÞksŠ�ÅÖ* (5g蛥þ:§HªÔ±|rÔfàj_‹;2ëmzr�9j××HÚV@*Ts ôçãkëQ ©–¬è· ú;ÝŸ2óÿ&ê’’*ÁÙK=Œ—º!ÔPgÖçÉqßý„‡Œ³Ê €§£$‘X#7!3ÄCiJ8²Å+Ndiêt ý΂РWBáisžþq€¸uâ‘ÔìCi¡C÷S˜²­:Q<ŒUµÞ©Ä6#…a@ GÖñd¡ë×Ñ ‡±[ùv¤fê.È<z—ÓÕ>{_U¿¯Ñý;{ð<$ÖÂþ¾Ýj’Ywo¼olþP¾ÿãsÍ{¶8[µÜëSü(ô½¶‘é]ûAÀ¬> F-iG/4/¹¸ÃýñÀ~X6eÐ.´ÉæÁ’Ù‚¢ïkÑÓ7eD›K|y|2å8ñhͼxöò@yB10E¹ÃÆ#Õ`YÛÚèã|¿¸—aû–h,Û̾át1`Cÿ¿ÝtÒ³¨*ô,b2™°;D9Æ:<õ:(ü‰†ÄÆHÁžF12nHö[·§ïæ>~fLjO_%>=Ñr*å‡}w8 ñO§˜ucØÂêÁÂH€7Èn³ËØWú¢hs¤ƒ)o54�ðÕ�x7Ôv K›Ÿ°·Açºâý–.ƒáÊäHUfØ]tòJ‹:­v!Á¾È¤ùÞ›=‹E¹g<Í5USéxq4=*2çΠú_¤§Å‰w‡2ìcÊÀÃÿŸµ?ÛnUIÚ…ácê*|öÔÚƒ¾9 hÊZã¿ÿëøã‰ÈÈLdI–g½{ìw »ªd 2#£yš kwêÌ5} ZZ-ÿ:åNãl¦ «£S`«¼´º­w‡Q-âÕ€ ¡³aÉÏ#žÃ7»ï²[N4^¤.g¬Ïa«Æ51X3ø_ý1œ©»sÖg×t¥£*‚j~wÙù|<bÔW€fÚúBù*PÊ(›uªU‘ï”ÈcPv*p“fB Ÿ:c(ñ›±gšù >qPÎvÄŠ~àØtôé>$ëýKÆaâk9ŠNôBqf-BBBÂn†²&+iA“~ “~œ±.Ÿ1»óÂõ­ùÎo NѨœ®ž\©{Çg­y΢nc]Ë*[lŸ<Þ*˜)!ΛÉúKp¤rÚC¶6˜ èq0²Õv!=9„¢µ’™GÚâÉ—…5sק¯/hXuo̼¶±èyLŠWn‚N˜O/½›�¢„O½8Œ÷÷/ï§.¡"û˜ãF*£ÂbÇj v7mÎ'YË‚´”FÏc^h”e¾n=¥¬°�±2RžEm}ì{JKL i¿Ù5Yá .”ñR*N½Ã»vM7tÿªVèãRѶóŒ~z&ÒõmãÞJnªüŒQW¥´˜ínxØ[ À¨ÑSdDçÃ$rç ܸãØ#@C3ˆ"½kTk3ÙÝ0ÜXLR¿:«“º‡fÍ«ñ¹÷Û;i”ùn*´J'â ÂpP¾½ýË /2ÛÒ=Ò!™™qªpÐ4^¬°é Âa2Îí«×�çF)’ÎÃäÞÓ¬TüzÙk 5Oÿs=º…ògn0F€¯&‘#³2FˆòÄ8(,*êË•ò&c,´Œ%IÚ«×õÇ’ŠÊÌÄQ­cÖ—MÛEÆ:2XP©± Ì°ÜÐ…´…Ú¢³‰çw.Øló˜Ji;³£ˆ¡ÕTÌ^¨ö8´¾u´Qéº:c&#· ºtøÙ:<Ѭð-ãT‹ŒQÊ®PǃţòÔÔ,^îéhÑ:ŠJÐB¦ôªJSÈ3`›wN ã·®Äõáidn’j“më©“¡¡q2+†ˆÿëO_W6EYa2ËÄl.YPì”Ú™rjm‡·w:ÙÔ¯•ræEôô‚êÇ‹4Eݯ98±¥¨À÷}ôNÁà“pƒÃŽ¬^›í‹ªŒÕîKE™lºx@,Zu6ø­‚CdÅíJ£¶Ú×�“++.™÷0|`A¨±Eö‚õ®ˆHÛ¯íÉË6âYGa1ÓF6ÊéÆáI‹9—Ì5*¯@L8éîécŸìyKÄGåуÿ5‚8)¼ŠŽM6û„BËÏ£J‹%9ãÜôìVl³2ÿÕ¦±•í2ÈœðøáÃ6Øèñ8Á’Uy—óÂçÕ¯ºŠi´2œ‚mY”§­Å‡ÔÐM¤3úƒ*ZÚû«ò#I÷xWOÚú©ò#þ†1û¿v~£_¼mŠbe>)3{+×Ú¡»4°±a¾º‰@Ö˜î¹C]Z8ek~®GLò Ë,F&s>è$òOš„-à. ÕÛ½Ùw·ÌkM笅x¢à0 ^ª@ÇVžlc¨V(Ë•AOßgª¹çzTqÁ<Ãû ®=›c}]ËŸ ØôŸùLßéŸcm:l¸¿ùÑ·˜LŒ–Òx—b¶-i Zkvkš5Ñ>´R&Ü»Rde±òW‰ §Dÿ¤Ÿ‡wM(`z(!Á]}÷T<”Цˆ–8›>I&y8«ÕõÔpuïÂ&“Ièå¼Ükl …•X³Ý„g�h ÛNã]·Ò"ôñÇ ¢ÅÒÅPðÀZ}ŸÌ\÷v`ÜÏË“k”sÕ ž4;-1w\¤ÜY“CX(¸˜`ø:eæð!c0gAþ©@Øt%¾ ëà¯%k«Ì¯UCèâÑ_xÿ²|Ø$°’Ò–žgõð,Öéá/üÚ àƒµâÞ}ú9{öD"[ÜÚqì®VZ÷+û(L2F äÔÑc(•Ä�¢¨¥lßÿb\9‚fœ½—[½ÌråË -™ÔÆAG?Ö½„V5Œþ¼™ºëÅ7:¤oQ›2œŸy¼½x¬}ŠKÒ[U—:K™')Tr%ÓQ ÏŠ@w†x¾—Ò‹è8-­šðVØlǪhn‰›gîðfÜkIù ~8TCaµûcSµ,0ˆÍ[`çGŸx‘±§Ü ÌÈØSØ{à7[ä Es÷—êã! Ä„õzhÄî•|ßÆ«=Ÿï�á*Jè x3bëŸÖíèˆyµ-ÚX O/#¥»R²%¹/Ão ÖöÈúeÁ@ž †w‰[Å ªÞ`¿`\»…•ÿÞ4JŒà´˜û²) ±¦ö Àˆr 2d#¹æŠf;¬Øiº2êüž\•Ãã]”Ó¿»«'Ï”æ/¤þœ=¼ ò`™è¡\5¹Dí°Ù_±^öÒÝÙA»›ÊÁN£Ð+LB_ì™Òú¶£ é,çÓ¼B•Ö vÎn“ßÿu¥Ø ™6s¤Óï²·"~ÈàÅL×-­"ôjê·ópXÞv´èðØjP{­ÏW¬á�Z¡{÷zŠí¹ fœÉyqIK”sï7¶¿¬Y¬½3쑧Z¥‚ž¥ •I*vZ)Rœš¯ÈÉ'-…¤;JŸ\8ϺQ}È A.£Aï²’†Žú†U‰AA0oPU/jÆK·iæñÖ÷rÚ‹äoŠËžïÞW‚¿,‹™ÒZÖ! -å 2‘ÍyÞ¡ùa–˜Yh€]n>üuæ�(^¦ ¢{¦¾ñQ (~¨ëoñ*d`-Lƒ ¯Û«-}öŠ èd¨áyM{ s,ô¦v˜QœzOteK_¹<(Ÿá—ñmz-2ž²¬AG·¨SFz‘Ô(â롹«Zþd&dýsTrö2äAÑÿkŠ—ªÔš/¤÷³uåÈ 8Tsäûaî­árÂ’}à/l4#½Íñ#«æÉÚþLß×jÐ\8!ïæý³À±Ü›8gÑj&Ô†(pÔ|^ð7eóEÜÕ?ÀÈß®°"̧´¾Ã™IOÚ}Ê­<W-Т\êØ6Û{Þ%‰Ë^¡OtQú’tKÕ”ñ�;Q0¦woïûy>–ª‰c_VO(žL©Þu¦e°=@uÐ'øÔË°Øu¿óUÊZšZU{“*Ö9Ý©½Š, æ¶nÇiƒÉ÷ª–Ëú§œb`„j=ó¨Bœ?`^q]x€›ÇCG Å�ðz6žì+èSW¬O³Ô’¢xOF¡qWmÕ6~¡o.Ð_“–ÖÜn¨=Iä£,ê*R}ÝiGÅR4מ0 ‚öšöö+·\‡ O&Ä0àè²8À"¸A;[yBYů27Ït€¹ üwÒýÉ*O=²ÀYÁ^LA³Þ»¾n¼VjôH¼“º2ØöÆ”á×ÝÏØR®#“`Ð2�™G‰1²¦™Ez^ÖP“Ô· ;…ŽÅ‡ãm/µS1 +˜¶øDIú]ZÖª‰A?× …:‡}©XzR½ÌAfDÅj/žxJù¦… Qæ0Œ] ¯ãÔË,ÌÇ3ffž¿ÍÏçlä ž.bA]±W’Q çÀë Ž*nWe-ŽÔí¬œ%Ýç–^Q¸Æ8 ÑÓQx]ÃÎŽ´6½cBôýþé»d >ßùÍ#z}årveozºefoÓúAÎØŒöI˺VQz<»}d…­ Té±lF:?·'-nðMè¾Õ½‘<×R(a¨Úþ‹öÓþê06^ cN¢6Øñ2ñD¥?lë/t¦Z“Ú~hYèÙ !i“ e¸ >ïö‰Ú© ¬¡?O7¼€_°ü¾jÅÕÿ‘ƒdþ×fpêþ,Œ÷=»~ݼXáÝйó2…9ntÚ9„Äkae,k3µ¬=M”Ç uÛ÷¼qïS—‘V&˜¦ŒÝ†MsÊX}ÃÞ‡úÔð”šk×íaÞ£k÷šMsÞXõõÌN›‹Pc!É8Å ·Ý¿~*øç=rN8yºÅ<Ö@µçÒå"’‚þ¥˜¬ÓÁ;­RƒÑ éî•A²Ó �g»bå©,’}s÷ ;K4vïæ¹åÚ`>º/œ˜V„¦¨Y "§Î¸yQ0€E‡FzmS'Auzw|g*æÎË%ÙòY»Ùöo$ }ÄdEk¢›×ê òûÁ_‘†Y–1Š'­/!$„6][›^®Qe4/?cÓÂ;±R–«cØ?ÍÔ„}ÍúG�_€PfM­è¶C­àuSÃ:.ð.åŒÁ¡|#Œd÷°˜d`ªÐ唟4.?Á<PÖ¢ÕD3à˜_ýÝ7»+«h¦€ØöJÕê°÷Ÿ¬B´µÌˆŠÛúaUЦ…tóc$Œ¨vRH=ȸ¸-Í„þtð…!žÃ­›ÏÂëjƒê¤‡1$ zSòšl‡Ï^{!x˜Lpž‡+^7¯Àa[4 =¢1YÀ]nżs˜~ü”ï3'õ^ã¤(}þ,$ð掭ÁSj¬§ÝU RÜA&+(PÿÛ/^@ögÞx9f< áuHI¤±T–PýûÖ¿‘³sS±u‚-EÿÆ:²ãË![1yâ2ÖQî5™2„ã¾ ª½t[‡LQ͆B«ñ£öc¤P$AÕ€õ{¦,9²“Œ ç>ÁzØØx¼Ê_ús;S0yè©‘%þôýœÈÿQ’ضÀ£JµŠŽTäZz ºZôõ,»ï8ââ¡7Ž3N¸t Å}ÒÉŽ_ ÎÎFìw›ð˜oÊ4ZÿôıÈëà‡lÕU,—YÚ¯ˆùqbn¿„s_͆=v">‚a¢[•Øqx×(z¼ÜÚ•)R0J»ýÑñ½2/ì°È U0”)ŸfÏllX©“·žÅe^¨^ >2-¶é˜YÓzÆ <Êô±xFSSn}/ä|C\9…ú é¶U=ÏÔ²ëßÀžRòr=ìŽRœ‚Œëé<ÜÁx¶¯Â×ÃîÞ â¹ |¯×<»J:3ýæý)ò÷ÆÆ1Yæ«T±×‹UP¨‡s<t¢ðYZxÎtý Õ €/å¤{æ×Ôv€ôüêf¼$mIƒì£[Už4!ʃE$|QâÞÏÀ+?èî ªµV®ÎÝJ¶Ný/„ìMFF¹:·ÛÙËDêis¶f±»épœ›«}ý½jå³]K>µ�‹.ßß=ÅI£ìà ¥yoËP È!Iì£à1)æ¿ï'‘ïòì‰o̲ýï_FŸ²2f;í‚»?XÏ‚®c•KäÂç{lU¾ëwiInÖ& ëÐfýò‚ ý¯ÞÇýC› G2-k¯z &ºµ×ÆBª€ XÇŒÇ{I™~°5cD/Öm³Ã‡©“ëóÝ#›»‰c# ÎMJ9¾­qrv©šÎ2™Úaþ}è\ÃTG+XÓ  ªU×\4ÅÙ‰•öýÜ­Ö[‹Ì‡ B@†ù:ïÚ8ÃM–i´ ‹¼HÒñP4š0Mz döþܹÉÆï¥íXFzÈAq·˜˜’·H©qéôXs6êD÷/þ\5½|h° ^è¿"[‰^Á< Bë\33“c‘Õ–c|ÿÒSò.T[îœymâ*‚ 6‚km}+˜Àÿè(pÍ°ÿé?Bžš;¤/ûAÏÐIT[�Ë]¬¥äØ›{±§½÷‚OÓê”b*_C8óꥠ÷œùŒ1½AP=FRE•ŸÈ¼Ÿ>Öu,XeÛùØЙ{™-6‹žÕü2“lå*ÝŒ¡¥ºl%Ýû*ŸO«:ÇÆ™(ÃnK±py¹-ŸÂÂ>º ÒI× ¶&ÊCúºƒÃK·‹{W·t¢hXF™£.h‘G'bñØqÛC§TœfìxséeWYæÊ„}[:,Ϋd$BgJ¿Ð£¨jQ¦KYÑÚr"q#WéÙ±�OÄú<Ž‚‹6S™Q'{¥Lµ'!mSCàà*iàAÿkÍâ]¤Ujê¹ù:¯,ퟲæËx%/‘+æ1˜Ü)$Ü9 QË’˜FàÕf“<ßþ„yÀÍÈãð†²ÀÑ5Ÿ¬ì;£öTšnáy@›œ"°qç7'hK<|¶tÞÌ'þ�KA-:+×íåâU#72`?ëšfÜÅðï±ÚÃÉßÀeêªÜ û‚jÛÚ5@kóxê&£ø÷òlNç»4öãn·Ž¿*.Ço[ª¸þîXÝ(£Ô89r¦Ð*ÿ‚ÛHR’ÑJ@O×õœ~ÎÒÐ5ë3æŸ €êíÜ!Æè›—aHcïwý@V:ÌnÔØÛd_³Žbø”Df×ÖpàǽþÞã8%_ºöÜ7Ý4PuW@&ùÌaÖ½½is»+ƒ"1“-×ñ3_‡ˆÙ>ÉŠ”4to$MéÑöà‰´4¡f“義…”ÓTy¯½΋€Ñ:O^Z$»ê¶‹ø{]# œ3U@ l¯Z:“¹7æô?¯c½ ·à ëßÐ œo°h±ú¬TÆnÝæÊÝàëö¥iÖ߸ÍEebp;‰Ùæ}ä]ov9Ýa%ˆ'=U}ÿG•4ógW(ûç¸RKìê¯Ôò:ë´ÉP†=h,¹ëQi#˜ÄËM~rW’Ë:ÚÃŒl«ýb¬RŠÔ+Vù7ŠS•C`òcfNaõ¥…. ÖNÓ:Í®Y„/² «<óµÞB4Š ùì=Ê63W¸è™üب²D>|iìZzødsc2Ý9TmQZ žñ%b‘‹ù?<;o«,ó'Z”> )ä¯jO¦FÀðf³Áv�j÷ÍUZÕ7?×ôÄ¿õ“_ó*¢åI•jºë|ékÃs’†¹�zÙj/hNfagÎ];Ääˆj©ëY=ú`lȦD€Æê㺜ä®îJV„ž5=Ž]¡O«” °ÆÆ ª.x³R [£[´89šŽ¿Ì³¢›Ãæùùâ±»p“e?ªŽó¼0ÁLˆ?Ðs;É_´„t„”2À‚R'|%¦–oÿ ²£¡€j”…»ÆédåuÇcÿ ý'ÉW!¥ †]æùžšÌ”`†gt×¢üî¥ìE+ný XN­íJ&“±Raß#gdäí×ýÀ,3²ø.0ôì))¨eŒzÊ^K€ª4!—ó&ò1ó‰ÃÜw=aO•2(ŒÖƒÔ‚ÇúÊËô—ëð¦I2­O~EyºÍß0ìQèO¢Ñ›(#6Þ­뇜ñ6ú�k x›¾65íþ¥¯/wñ§±/?MOl_‡^å–ð¦:O½â�è£Ð¼J/ðNó'¬|²~%Uɵö´¡ép: Qd©óøÕǺ úÀ±`„GuÏÑõ(é¾è³J&õýúÎà¦píLõOJØêD6{{|3zQqÓáÍ"„#Ì©w#ÈܦÖ×â€ñDnÿ_£Ì¸öĬ[â�8@…QÎÉNV¿Q+‰<ü #w÷'JS¬‚q’Öô Çã¬":¯©öãÔ2ÁËܱ’*‹‚‘Øžú#=Sà£àQ jó»¿­"ʇãï–ŽãKKzX<ýÐ/Zò£m¬ì+¾ÐÌÀoVG¾K§½ëÔj+&ä½Gç ¥'–Ÿü ©k)‚ÒŠÐé°Ñ”‘áê+û¿0ÐŒ~³‚Æü'~F~Cb¸06›Â!œ ŽªO®­tÆ÷µ- ôÌÐ×Ƕ.­'á‚í¡Áô[¼Óð¨¸s¦RòÜñÿþž9tây¹„â¡A™tÕèÿ€BŒÖä°Û& ­vJ½Ðqj{v¿åoÇáº.iRñÙªMRX½›x?ow?Ïj[+jäj c*3k6ÏAvœ Ñ]kµ×<eŠ5}‹²ªÍ³Z1†˜T1�]†ûzæI5‚‡+|1L/}O™e±£³|™S«ÔŠ‡z˜¹ ®±xèaHÏÉ?èüZš•ë÷-Äx\xQ'šö´NÊZUdTÑùô 6ã…ößÂYdÅåõ&¶Ä‹Ä$ªÇ�ã[UÁK™µ “•C2óo5¿c…S OU\e¬&ìmÖÿ…š­¸€Â°¹/ààÀdnæ=9Ù"ViYÈ!XÓt(–—A–´Q.ƒõ7„>“¡¦tÔDòÂ{dFŽµ}›5Dï»2N¾§.))-±'U`TyY}—Q*õÕüˆC}BÓî@m÷ÿûÿæ7ªiÓKø(l[6¾LÅöðŠ[/ÚÓÊ•ã Ñ Š¡îâÈbu8ú6Fväk•!=Ñ_È–Êñfbó‰#XP›M/õІ™Ðåu]¥np™åRÌ´‚‘9rã]æ<ß.üŽæõÁêCµíMh/Ô¯ØźïÁ …Ùø£#½Ãl¦ {ÚaçZ3]fô³5»_K‰>UõÉ9&&;ducàjˆ'¡!ûf$ökÛ±ú ã!ÊâÌó YÚÒ¸½dÛ±?íƒ*DÒƒ•�ó¢5[ý;?_Yú*WVÆAîB5Îp59œH¦õi 9«œîîüñ`v¶çþþ™y &Jmˆ,X)0µ‚kØÔ` 9·ÊþÚ"Ô‹µÍÊ»ÊY‘ ! TµÃìY3 °D« ö…Þ‹w9QB1±}.tíXH‰¡¹ðPë]-ºâ´{ ´ aÍtÍõ•ÙVâÄ—%ÙÙlYB[Hîh;¾]ßDs)�ñq~ãƒbÀ¦=}Ò¶~Û\aÁŒÿ½_ùÒÜèj SBçà»þ5(RL8²fº,¬±õ¯àã8°£•«-ã>Ò ŠÝ`6GÍôÓA¹ÄÖå÷ŠŠý«’/ß3zòœÖÁªw¦¾*™ß/}å'ñ×ÅæXÑg§ÇQ*ä¹¥ó‹×käš—ïìû( }žjˆûDÅÿ^ç¸ø8 ³èé>ϲÿzÔi³ý^¡: W ˜öàåÅØr?;Û àøfµÃö Ö¥~ýÓ7AŽÐŸåa~z‚bîðéõMp³²£¡ê.&?¤+~›š";ÁÕ¿Œþ“TÞ‡ç½~iiÃ¥–Û›Š)ËlÛI§Ñ'\T…jí¿…¾Âc¤g%CîþjB ä¼!p:Mªžy„*ìÏx ¿±¯\Aw-JôÎ!ßÍmîá]"›¦@DÿkÌ\ëÄÊÎmê/&:š6ÂSŸ¹•ã\î $Ö ÀJXv Tõ‰áL˜Jíé‘N&ÑC¦¾ ©ØC‚8Êͤ£4ûk^RJ÷Þ5bHåÍâG@°øôù¥úZEŽËtÎî+©‚¬éö €ö€ýúfe 0eã¢Y¨­è™}“_EÔŒ¡ñ]–±Óz¬Ä#ò2¯î·S'<z½`Å{cÚ¶žYk ÖZÆJ<çA2øíîæаè‡7®dWLˆ~eÅ…ï\Œ£0¢òdESQÁqª£ð"¯¡éÙXZŽß|[ªt%ëRR¢™ƒ?¯˜™¢ăFhD±Ý<*${}Y§z±JÙØd º$µªyƒõsáù¹0Œþ/I…—€0³úò' *ûÜ08ë)”ôõ2 †cJ Æu¥fðͺÞ?[û³ Q£eëä¤æú 7»éM÷…@¢Oã.\Ái(eF\sþ²ëýÏïÉãþýœ?ñ�^¼CN%ÊéµóÔà¯ã2‰V´ A§¯‡5ZßG¥©Lö_ôɧ=mQܳßâgªÄI3`Âþ€IXùw̱°â í1-Š¥/bÁÃÍ>M‚jšäBÁµ×h*†)úzw¤®’Tû©‹ Qñµžˆ-ÓÁ·À6{è(¸yWЦ‘‰·øÅD}%\ÓÝæÑX¾ý×Äë þ\=»ÅZt×OC±¸Ðª8cS”’]zÏÏÉ‚e) ÒnµK�­h3¥WB®¡_ŒçV_¾§ŠyáƒÌõ °0MžÆã“4ÛC»í‹iz}ý5¢8õ¨9íë*¨z•¹Ab-¶TFaÿé"*’9°߯©uê‰t›' i|&þ–_Eâê{–]õZÞ—‰ïªô6ž!­§IÊaV»‰ïß"è×Ëó’³÷cl7>;øø²ÉùoNwÏ ]<¢{*³ŽëPN´}¾×½´äÄ#síîÏ»s’ecUûcVêWcSÑM»22. GЪ°²CØ­üX5‡[SÚG›à "ù<³úÏìÐiHŸ¸£FªôÞì2öËJð뛓ikŽÂÈã¡`29&­{ì=mŽ'Ï·ÊWŸ08ÂÆbë<‰èLŸ=ÎËo”É«ø¶çĺÛÙ›ëÂÀBZ¯ù]%}>4ü€}ï5Ñ­¾ËŠHlû#ñb¼èËAÜJô7L  ‡qï—£H`T¸\TÚfý÷àtK_ˆ§³û|¯–`u ýsªÛ³‰—“îIà’Wþwu—"\»¡l¶¥ß•wP2/üX[º– 8íezPÔy—Þ&VhÊ;àx?;Ïú- ”ê^8Ñæ¹}>‹ŸË÷*»ÊVú¡h ¥ž¼ÒEܪqvÝÃJµÆïð÷…ŒÂݦ²S¿vi<ˆÀ• D~vø›ž„‹©ìú1ïÊ ´@ÃœSC©¾}¡™Oi¼zà—›óýÛqŸ–™?q…ËNIm]vh³û"¦ ,£éGêXÅ‚„ÍÛ ø[ÚݚÑP~Ç:Àæ)üäm]„.Áä"iȘ>hp$²ÜU4°°—CœíÖˆn$¦{»,ˆz¥á|évp¸“Äâä‡áµ±P’Ýò}G•Qòi•s™‡ÛÁÝârvâUi^éö4WÙ¬æ7ß@NÚ55(°ÍRQ ©ðŸ$_åUúfºMv`µ)¦ãÐ׎¤7«{ºç“7äeÍJ-!AfÝÓ9?¯/õêö¶ñª!Sä‡}¶FËs”Š•ƒsý[zŠ-kVýµÙÙ­•zúX@_ôŽ Üg3žÐ Ç°>‚ûÌz0˜¾BÖFפEh'¡·"ö³¡Ûe?y[ZŠ2æaª¸È´¸_ªkîÛÿªëmäÏucÄêûÔµ?›&y__†_YJÅI¾jåASÐÒýúr ªÀ5UX‹¢»¾¢Ôynº¬5ßÏâ³mBw×,k ¿\ˆõø­ôåÿû­KãÕ¶ÆÔ™Á*Ç÷ð‹ßI&ˆ »X+Î]:£0sÚ ,­<t)ÜfÏšDÉEJþ8Mçv?š£™ ¹¾ùñF¢@†½?Ó¦Œ½³9€‡Ž¡ ÉÕMì—á]þ…= oÜ{$#ÙÐ{`Æyßè´Z åÊfL¸]!K§ó¼gT[w˜ç§Sè#MŸq-3Ôn]gŠOhƒ•²¦ìþåwnì$øØMµiÐÂnvžã؆?±mÃÓŸà£îæuía;õ2‘öëçì%¥ƒæIh8Ä|f¿°zoàü-ϪÛúŒyzG/ž,àÈ&ö.Ž˜’!ykw…¥ûNËÀû0¥Ù;Ù—†e⣗çÎÁVsO¹v­H‚¸ œÙ‚=‹pØŠ4ÓŠ^€[p"‡ÚŠòc¤Dô—>äY•yŒoº±mMëùS|*ªºë«±œ@ ²§ÛZδ;ªïM…™@··ªzï1˜T~‡åUu¶È)ú&*‘ÑÑûõ–È&„‡Ã¼ûÀ0yxñÞøŽ±e̵ÿJ¨Þyý; ½Ö¦Úd{IW+ò@ <Z½Ìh̼k®^éØPšcܧ†Åy5üÛï‡H–­)ØÈ’³³2x¡pÒõ#jQϳÊ|þ2MŽ=%Wdq‰T/e­ˆ2öÆse¼¬À˜gha3§• Ýœ®=¢›#?š>2)…‚¼XG¹Ãž?iš‹Žù‰ž'ÎÿM'2ÅÖ(JCØÌ&^LÖÂúTNd½ ¥±ÅŽë�È7ÚÅ)Të‡kØZ¶´@sßÓ9ä· òO=y³HŸÌ§”÷0mÐÙ]«É•«=.ƒSuÛmº¶ûƒÿ. -@y*ò½Û3U†ôë#eîßõ¦£ÿXiᘳ…ØÔò­mPQ¬©ÈàY¬ËŒ‡…½­K“!œú‚}d,w 6£8G%£¶Jÿ¿2HË4L¬ÙN¸$(ÎÛKyÃ“Ö ¥›B$ýæx WÊè ãÄj6Q˜#„ç‹úê]ÓÌ,ã}Š‘¨´³HЈ&ðr½rc:ï8ÓÔ×Ef,¼âÈX Xo¸ QñŽS*ƒ¬§Gk“§AÑþëu-7£è‰+oé-J>³þéá1–„q^ÅN6µà€‘,gó'ÈçÎ3ô 7”-êÃ_»?!÷ÔhI@°ô†‰âm­‚³èLñ;ÈÒÚŒt²ÌPUœ±uA»ÁÌ¥eèŸgPÝ:&T hÞG• +Ìn6è£IóÖ  vÁØ¡?Î|òz—Ú&*Õ›R±bÉ‹;í|Óó¤°ða͹÷{½§ÚyQî¤"Ûj»‚þƶÖú»Æ aàí>ºœí¢So çÙFh]Û/õ•P+xrJawgZÁWÄì™ L=vçC/Ã*we‹¼(‰|ùóT~J â¹ö[àãŠï{ ¸¼í+‚E°|RpKÞ=w7æUÏž û­."U•fð÷]X‹jÕ؈ƒãGJ?OƒŸ�¶]’ØN-ÌÌûÛ«' ¡Ÿ&´IgUJîŠ溟¯Ñ HãöB—O N¸ÑÎnÁX ñ#ì—ÆAíA]Q¤i2› Æ»ƒá­wv^âK)*8°âЊðСŠÖM›ÃŸºw£ƒûÒwUlÉ´Káí¾«nVÁBE=¶ßËà{º%RËœ¸ê}6ØRŠÛ oxõÜùÊ @ZÇå=-ÿ¬Ÿ½‚‘þëÝÄ`M›(gW?XGdŽM*6LhaZñf¬<cx`kßÓáK¶µ†¼÷JËzÔ”¡ÏeÊf^ÙnëÉBðäØ»ö×E\ ê^„~0Vl<\Ú¹Ãïöžß±öŒý¾íñ8»57<~ÐRÏœ¿ š˜G6‘ðXä”ú =)ÖM5ºëÐØkË)­+w»×˜jA}Ôx]XIçŽÞ°Ö¼:5C«!öºƒƒú1·k6~m}@ ëíÙuÃeá¡›À©Æ?‡áŸ-6%¬b¾ýÆ—T-|-ò0ÈèdŸz{ {I ¢s³tó3w~¥¦™›¤SN¹i@‰ÖdP¿Ã*&#³%“wõZmå Ï2H|™éö µ§RK×鯌¸ §ó$¨|]U}\ ®eðŸ¬ÿߪUÜĈñ цí—S7íë‹g¯³qÜÔß7å¢ÿP¨/lS–½‡ ¥Ë.åØø³7Á®>Ì¢æ¹nÝÐ�ÞúûЦZãŸ3&ߦ[í“3ÌvêWòûHÈŒ1ǹÝÑýùýÛ_lyÊ:gäó2½èyYæ[Ä{ ãçæÛïòìÐL=asVœo¯�ö*D´¬v>3ò<éÊõ®ÈÚ: BfP P /w½ëhYE%ÅýµFxÄH7Æ®^fTÖ<D@ Ò Ù�*èx;tD’Ì4ç“^˜’Ök„zYhJwÛ‰±ÕJ"„˜+||¨qÚ oHß»>Íkû†—!-qì9¿²ªØ´GúäÓQOÓátˆïÜò­îó®¾Ôm–˜~þR“ýxìX€‡J§uÁôQ^L8ê;q‹ô.Ñ+—ìŸÛƒyäBç¶óáÜ•ÔŸ²r­t¦ïÑòЮ%òÒ—ÌHnþìÑèPsâ?lŽ†IÚ¼ 6lè×Ã2QYräLÇS-kõF¢/©2O†„ç+Ý°Ü"‹@¡€¹šý«ÀLJ ¿qi³¬™Êì›> ’©v£qZ‘t®¡b·RH>06!be /¼NíÙ‡®-ÙÐÌ߶ˆ¹=,ÿ2íU‚ú‘(ôå±[êo¨EKªÈ@pž|È×PžcãÚíNGUg&v³Qü´g9C=6T?ßÔ¸VY‰Ð”Œ;–sV%bö¼Öû¹†§üùSŽ©q=yrŒM×)\ê•8j§Í¦«PÀ!(¯gïü¬6Bã¥~•ßÈ<oþ@ ¥V¬hÁQyðF&v¿¶ØãÔ#IÆÈ„'ös³€ èSoQ'éê'ɰ褴VnøÒ³¨á|Ḡgé)<Ù ,O­â*hBóµ9ô¿ò}CG~—@¿;ç ^O=²?›Éäfª‡9"S€¦ÕØ»ˆ¬Ø’œ\ZŠ~F´Pø}­ód ½Ïö®úò„ÈžeÞ˜Š.Ï‚ðäc7ì Š /H\Ÿ`#HÙ4WH߇§Ö^3TEE¸¤ž&øomïþÆ%Õ‚BMJ“ˆEØ^± €æ^7LÀ¶èćaÅ &®e?¹yF¨hƒ“ÿ#üW¹ÈÁRçA~˜aªé¥COÐÈÅÔ.ï|ba31ow,C(Ž0†ZiH”¡/ðbâLO·­M3¶â¯S؇N߱깂|ôŸ"LlDã‰ù¡n;Ì@·Ú¬7s’GbéNãš%C¸×@O&j|{ÃŒq2ÂßY™±WÁ±p&‹ˆçMçiÈ} ñßmÑZÑ=^$³¦->$ýo»o>åùËD%{ñT5·òÉ´Ö÷mNѯñ´V…+*Ž}–­Â  ΕÜÕÓ¡M_“¾@Õ*9©š_^ {9ƒê ›{ßgÀŽQŇդßñ–¡“kÉZCÄY³Áç¹æÅ.Ûí5¥å(-<maúð}”Íà îëöx�;Gû𯋮Y\@4È©£¬ýj³Æ„Õk [¡[x˜ö×ê%Qæ/(å‰îQê¸IÜcEáæA’E4À_Õ·|¤Hqé <-ëÖOTû®±LUÍõü ä´JÓ¸pG´˜àåÑ©pjÁ Ä3�À& ü¤±ô³cXœa &h%ŸçýHX¸Õf;:û—¯Q1™Eäp¢ìog}?é«]» Ã+ ±¾›Ù6’þ‹³ c&!Q–û“PpyºƒuvgI {©œë ªÇ-ù™f%ø&Ó‰ÙälçS\ ›ò –ØÇ£þµÎx_ê+W‘¿-ÊÒwßYy G1©†ª¶Ò`7ö­hq±äUà¸eÐ^÷ð_qX:¯z6&Ûõ´ýU®ñ… ·’N–i4(­]„·î]Þ‘|+BO)žâfˆƒ¤Ëìh5óÌlÑYRoà“úƒ/ +Ô,¡.°Þžú[œ¬XxhAìéqíjŒœƒ±j8Þ}ÈSé±1ÓÓé© 'óN�/ìp8_µ ”›¹{)î;^ò~3zÀ¤µ¶«`\¡Ý£Ì�ptl'ÈÚj˜W6ûDgâŽs©w[˜`°;§”7Y}lD£Ë»ë떞ĕÞ·]_AX3¯mÅF\}Oyp<L®ÂÝòd"â~쯌µê)X;1düö O ;4s÷#}ñ»Udsñ÷òÆøýéñ†¯úâ»2)åýRú¡³…Ýçqn€Q4êÝ=øj ¶õ.—I†÷F>y’ù62´xb 5l€ q˜EÝx_´ uKå/6Êç“È„@ÐÖtÂ]Üm#™; „ú<—A¸wm;Y¹¹©‡?´éY‰µÀú'Nèy’ïdòÒU£’”¨ú»Æ“xŸêg—èÒýÄb¾'¼©²ÐÒ[CþëoŒ`¹ÅÃz•ý§J®¢½FÙЀã¤úœ½Y‚©µ<þ¾g¯ãŸê–4¼^b–oÏÎzÆ’·ŠJ…V¨ZüÍL-Ž"§ËÄUeßÇd+€¿PÝ_®Ûz` ÷f„ˆb /o mtBõ_,Áè¦7Ôô(¬•Â‘c™‹™Æª•õ¬£e[ûqh ƒaGItÛX}Þî‹Ê°ó)ßøÐæÝèu÷Ÿbx¼|fp„co€7ÜD·Ï-HÆrX„ðó‘oYø=S æK´A…5.x¨ÜºX ±y¿WG‚_éæ«3‹ŽÚ­ÚÞ«ÚŽõ{ðuY§„J%ÊŒãdƒù¯ÅsÇ,n±Ô˜–:K\Í0™ì}<P¤rø¾áäœùr²Z%SÁ-Ü>R@vÀë#ý*r>âÖÜ• ú0-%�ü¨øGÆinøï¬Ê†ÑfC÷:o2Ó¶a9*ÞIFŸW:¯°5ÿÞ:É$žwußWX Œ½æ'ºý¶¯*|y@µÓ,;MJÌ�¯3s¦M†qüUŸË2Î<T@lp 6%cÖÿt¢Õo˜o¼dè¦( ül®ÞÄ@ îcO%…±qíÀ>åËcû 1ìžf¨=-púÍáñGžô9#!7´PwꉖŸª0tSSd.¢b&Y)¿ùÍOÊŸ´¸ÀãTAÖ«ÇVš'*„Œ<Dûq/û³Â5«3´É.³œ%½Jõ¥î½\9ÓÖ†Õ+jqŠÌ›mQ6¿,ËêÉDlªÖÃÖOý‘q g ˜+ÅârYÒÕ…­U:ØÐë]®Xy•Xf“0&W…õVUÙËsÙ³}š<Ê™Ui˜ù˜ªXô«ÒyïZÌßÉl/ XyVuìW0½vR KÊ4ø¾“rwy<júÄaju(QúÓºnò ¾Ì¦—”Æfzaöi×›ÿÃù€ž:ž¦øRS¤'E“‚Œi2e6&Eµò× Dê67@¤¤r{E@1� ;àmÈJ0¶ó2ïÌú½KàµÐçè·ãi¥QkÅA0è¬c_ÇšŸ¦Ã= Ý7íy`çšùR3}éö+ÏAÖÙ2HŒï£½Öuà½ÄrîXñú 8¬šp¢Âq^°P^ ·Pôòg脯›[É�@¡™ñçl1ÃAúDw|>äŒâ5ç‹BâîŒ}Õê$o.«ùÔø!Ù¬UõbKóâ ž>ašMefž.4½Ï·?´›óiÝD}sïƒ2»òp¢·ÜM&˜Ë¡:·¥ÍhêöÕmÒ\»Ž1+w…1&iPͪ³9z(Káôƒ}ð®njêQ8¤£,S+#!-Œ–-b¬…êS$Îœ¸U„“à½lÍ×GR1&öë{û@õlmG!ŠÌZ_•}kIp¥1.È·:Ȼ͸j{¿%ÿ}+D(}˜}Ǧßp3g¤q«·ô.mÎQÙù¾}xHу–Š”-šÂËÙ'¸É<UD)6#=„ØfÕ8«ÐÄeáôõ…o=y®â ðMƒ*ÊCßi p‘Ò·Ð1M-z»JLÿR(‹.lyíÜþâYv–¾E} ´�ÔOZåGà»ùv—ÃnǺß–Ud‘²"¾s™‹ ÚöÎÆhÊHÈ@o±º|¼ð“Øó}d€·(/tJT=«SSëæ̇”%@â§'2 n�ªvç¦ rÛÁ2Ë:±Ô±Éx´½4t¢¢%N,&t·3í1†«F :4;=s“‡#ÖÈ÷$س-fKå{ëpnè_ó!MçMË«véÖלÂyxª´J€=j/B!ö:ÆT…mã'4B&É´h ëDwÅy›‰ÉT[‡@¡#‡F š<A=}°º#wèßœJÄÄ*Nˆé(ÝŽî ¾¶•Œ\�Oím•ß1~XO`ïòŽø·m42‹8L`uD?7*Œž]=˜j”ÊFÊY×/¦¨êøÈâû¿DCü›�mùç`ZË•Lh‘±¶í+<Î?•žò#ðÌ©¥ˆ+)eN5¶ÔöäÙÔ¶h†ÁLp Üiòþ}cuɸÖåÎo¼£ZŽÀìÓ"È¿.ž@B3]?º\)$^‡kÛ¾æuK©}Mù´Þ¥âÚìD¬6SHÕ‘¿S¥ÃôÆ­öàÖÖû¡½·cºV†éú±”L²1 2ŒDûWÛåãX:JGúŽ�º†ÝtêèVTmg»ä�•—±Å­gé‡ù/7GOd³ÇXgƒG:& ¥©hJ5¥Êýd§^V®J\6=º:¦ƒöÔáîÊ”äÑžÿ%K?öU_Kd`ç& ²½öbÆšó~‹ªMòÐyИ”ABÄÏxŽÇ[¨å9ç­nÄ™æeò†¯xÃFŽ] b¬õ#‚ÏÉ’rÂʹüΈzQe‹C‘Í1%R ’LdŽçkqN'w¶LÌÏ´²hQÎ P»gΗ¤®ÐÙfŽÆ³ Ñëò.mšy¼!Qêé³¾OÖîöË‹üŸEBTí0b’%”æ*ˆ‡“m‹βa€¼Þ,J'ë$³Û,{ßw ž,ÆdézA®LØúâÝÝ84HÞSŸS)ªÍ\DÆþXráoX±´4Ôþ…{¤œFp4,­va™ßX¬NRt4 óéëÊG•ò‡Ìu(82mîËèðÇìNÃe±Áˆ21A`¢¶—ò¼Û]d¸—bEÏ5E”ýâ¡m6<6‘¿€#„}|WÍQVùNJ1¤¨ÑX].ž¬°QÓä'ÖŒ;®³ºÝaêé<ÜŽŒ¢ÊŽ „]ÄúFÑÞŽŒøÞªÙ±ü¯k•‘Ÿ>à&, -vWÓk­ïpôª¸à7­Á(Ñ1¦ú>_æ2È›Ýʳ€î¹³ž[ƒÑî‚Ò¨üL}øØå€M½‡(§«ˆòR%{<Ö«Ì#,ñá”>öLŽ/ ¤Qw j:ƒ¤ø±UîãQEåreY.—tÉËŠÛ°¨Åe¾zCb¥åJ‹N-myÐ3ŒDú¹÷Bá–6˜Såç€÷0&kõ˜EU‚¼ß댭bhcFioPà 3úXä¹þ¶=ýmÂ"åaKU BÂÁ35ر¾õ(þÎTz0PéÑéùÆ´,.¦ÒÂF©ØÕè¦ü9Ðã3:æe0]²[Q„Ð÷ã“9ç<T*½Û“ÙX1vÓÑêƒS¤á ¼Ü³ö̲uÅ nY²tv‹åÌgi$%Üø;ì²;Wnxz¡Ï–AvµÂE9ºttk§Ë¬º+³iêS|qTçTø4¨�†éc^¦Eí›^¤Ü?v_nÊÉ-pÖE8ßšE¤¥Œe1Ï L¸®jµ¹ñm²•ªR C2X¾ÑKŵ5qÍŒAaÕ•s|õ£þJßécŠ€œ(P7Šõ:v<PŸ:6Ó힘(ëžÊòü®°…Ÿñg õƒÔÌ� yÐ X‘ ¬ ×Q ؃›Ú1¾å±$F³ôwÏ Âhس¦:]d‹†ULÈÆa3(ÇÕ^Õk8ÑÊo¹As›ÃséìM#úú<նΌù—[JµÀzv}MÕÉ®ü–u-ÐUx3»3+=í<0#\�S¢‚’ÍÊÞ[>À>k‰%™W}�ý^Ó#˜·^sf‡EW¡Žêøm Ô‘W¥²ìÜu¤V|Úä‡0pBiê鼩Qøƒëï|œÒ£'ÌreÃŒîÝõò׌M`¾±F^£¬`F) Bè±úö¿ Í•X¤2EÀ¶± ’½ø7X75JÌË'ðŽ½Ç'£‚vèþÕäåT{ƒ7ÚæË&w™sH:íé¡:w¢?Éô©0åùN]+J¤Ý q|CêAo‡V:æD«¨m¿Jšê=iüO¬¦±$¡TÜzS&Š^Š=ÅðhÜ»,PÎÖ§ãÙbUsS±ÖöyÂwÅ' h%5ÇpWÍaÞ§·úl†q´Y®oæh\ÿäe_Ššªì-º [¶¯Oo¶Š£†y±7¯¡“7Ê ¬°í(—.—Å]‹9 @Ã&Þˆ:‰ü«uÕ½Ÿ<.¦LõãR|O·ê)²¥ÒX½¬€éƮǙ¤b/Øž–NdÅ p té|ës pºA”Ýû®ûVî lY2ßåÄ<ÕXˆh9hTߦëw‡aå\èØM–ÚM›ÝʽsSÞ]Ù^yèñÇ0ˆÂÔ² Ê­ ûúB爞í†ËM_›ÖÄ0;åÃé*Vº1TIÛ’ Þ½1H‹*¦6À’íN‘UšÉñ‹´§$öö¯QùKƒü¤-h#ñ†€¬�Ü-f WÛ˸UüËÓðF1w™¡V+ÔÊ*@îh7ˆÝ£Ö¤çÈ] " ò µ7dr¿ö^Š³Òu0Ø=q^Š î¶NðØ ÁyHpŠe; WÖeèsˆK\”+ða$"qŒ§Ä¢=¿lö7º×L”­a6nˆ~%ýTf¾2�¨âcFAîsï KZ‰ƒl�p´GRÎyQTže�…êZhŸKŹ¦é‚´ù ™>ÔðögÛaº«`8QˆLO–¢ÅbìßèÛ²Ê`ß ñ@+“3Vy£õO¾2Nh’?ØóDÛ/‡ýÛ¸!å_ÚòØ.7=Üá”R챊ßP²™ö×ã`U)yÁò™²¹PùSóÙ½­;÷ªâD*A&žTaw­Sìb0˜ak­" E„»wCØÑ*–ëvJøöµÇn:ÁÔÇX4ÿmË2)}x:ÐJœ‰†]Ik<ºm­p@ÚÐ’Ý70ÀKÜ žR ;J“À›ItåÑ£4írOÎr,jÛyïWöâŽâE¾ša„ì'1d=¶š—ˆXLs-)âcóÞ`8xð|ç*466¶8…Éa}wL¢æ³ˆ&+!×oéýÔßKB7ÝŽ=Y:¯ª¿|ç¨,p£•÷—&ªQžûÚq ;/øçBVìÛ5ËZKZ¼ â_J¿žF: {l$€/ ½³:9G©am‚žÛn¯îŠÊ7Φää% ã&i˜Ž•îft›c–‡"ø2JÅ„µ‘–H7óÌ›5ZÉÖ0[c.èÆ6º‹«40”ú(ž?Ô+uˆã %æ�ïÀÕPVE8³Å^ýÈöa­l¥›cCµégz몿º {([§ÖÌ1ŽÆçö©Î²ZÇ……Qnz ŸgOÎjˆhzð2ð>wêCx*0…ÑSsÉc·›°"+î]i™Už.4ªHXKVAÞj æà,BÅbXàÿJàÒõÀðq}•b{•7?b´^†žn6ÜÚ J¢¬F RoîÞˆ ›3©û†¤yX¾>™Y 53`‘z^”a&ÎÉNbeO ÀPó‡·Ô„'qØî ƒ Þl)¦”µUQŒ¤^î)÷tŠRm{1 ס½s`•ú¦P쉚ìPgNÄDOËG÷ë/ÍPÏf—{Èü- kØ‘0wÀ¡wÆ«Ž¡%ôük䙫~ÜÔI8¥jäðã±Áyª[.ÜÅÿÒ·¤4k#S™&ïïN刄¢ñÄEé–0Ø•Ÿöl*Ôç œ(Í4;p¨Øî¯ÕùÁõooÿÊÿ{;üéfwñ#±Õxa¥ ¶cÄ®£‘˜›úÒh²ü\Ñ$©VÒ»t�×}d½ýHÍ+º¶žd6~¢gÔ OÌ72ËVÒ;0³›ÿ5{m7rOÁVŽ°šÒÓ™êñlVî!e_ÀΡ?¦`ù:¸Ù/µ7¡ïýuÎÿî¹÷X¡0‡D¤ÖÇ"�ó®­Úºiº«_ÃgÆSÖÑv~ÑЋþ“¯ÄÿèõeΞZG=Ÿ ôÉÇÑ2~!B¾ÀñOœ4—8×)e,º«7®?ŒCÍ è<盩òs¥!2*9@«AÚ]½™½ñC960bâ1ö7É#FI”»‹Á}öm׺‚‰5"T*8óéäÔØU:ÒW>ôñЕ —2ÏS`:Ó}žâ×*´:u6‰ý§ýÌ0&{ñ¨iÆÙ*‡©ÀOb@mcêTáðÛË9Ö=C»o^¹ó7ßyG‰Ë­yñðßp†ã%ƒÓÄpŽÕÒ~ù’8[õä"dŒau[ÛH¯øPåï  oOÒF`=óÌkÎ@&ú%¡M—’Àèz|ò@÷¹^Ñ.ÉsÿfÐ ßìéÔéOžàéÀ‡§9{ÖS±ïõ¶µ/eô=DΚ&5]}þÿV­ìÚÓˆ]z™º/®¶n^UúÏSŠƒù„Þ—6{¦ñK ƒó Ë-@Ñë‚+o¦ûz¶÷eÆîâBéâüi¥ÐƒàN†úèÜË~(Lœ­6Ó²ñQÙ‚â]“¥éT8<¦ûøJ0wn-™uÊiõê8»0ª²Üÿü¤:ÉVàGôÒ�û+'+f6N”ÕÔì¸à:*@…𡞦²À°éÞW°µ ÉýK“ÌŸ šÓî0$ØþEF`éÜxgŠ�¥‡…Ç©FåÒA´tƒËÐÇ_é;Šôtx[Í‘;¿ÛSNˆÍ­ýoâX”LÎâœ:l¯xßBEgº¾Ñ™Œ Oj,\ý%]Ϩ(JzÝn ø`åî•—¯‘Ê—X/ºgÀšÙîuèÁ0èK©¾éýÖ¤&ŒíÚá<<«Ì 8ëbòmBœ÷@3n~œÎÃp=v­CM=p++H�6Ϻ…è–¿£í¤ÓÂþ̓.xŽ þ“­ÜX>>þÎi7!92mZO æ£]߉ۚ¹Z%¶))@´#Ý¥rÒ†ºé»8÷’s‹ Ç`8«`øfpqÖ^ÞÀÁ,‰]Ø+ÆËÜ DÁ v¼€©¦&:¶]ê®$ XuHoÚ¥Îo©0ÞkÃK¬sãÚí””´Š¯ÇœTŒä»G‡óm ×À#rÀ§ôMË\ 9®¨—ÃGݼfųԙßéN­:>³áiåìú4(÷­­ÕGŽzŠ€@Sëq£ýòØùØWs™»½ÂÃP‘Ò‰˜ä²ÝÄ Üïc~klý�éiÑܱÿpR·¥ÑÐ;ÿ°w¤r¤tº·ô y/æ.,Ù´z‘âXÈé ºv®s:þ?÷†< HL§ä¶ƒMÅù"+³`a°»Õiü0‘wý“Q˜1Vð¤L‡w/P ‹°¦ÝüŸ\)­ƒ­�¯Ä¯6—fšwžh…ÔjÔ“†ÖLj®Ïb¡=X½¸ß™q$¡³ûeMàý„©b$Ê’M­qV&k/v"mc.¬ye·Úf©—DÉ܇9sµ EíD"òÎTÉÂ>E‡P|¿§(éšñ–Gº‘Õe6HZÂõ™›ã:z±ÒÑ™œ||ZUí¤Avö„\ÅÉÃDîÝt0âeòú{r»›»æÆ£¥r½h­nŸš&•q¿¸ªšÆÍÏ,Ÿh( °ªÖf«zëO ž£?@úÁ\«†ø-¼Œ_šäÛ¿P‰Ó¹N‚¸U¤;TÓ"ÿPóOÄkæ4<Ç«é=vø#­¢óÑ%›÷À¾ÌžÇÚ2.¶.4 #ðš ovåµ]•+KNtí|wÅøf_/ê_±^©O¿ÕÊÅ-6÷Ò6˹¿½ å‡"jeÍ‹düâÙVçi.lëé¨LÑÆ€÷Ø%@9hݪÑÛ!àŒ1HÜUT'¿{F4˜Ì3 Ǩ‹ÌKó(l~!üÜÉó’2ô (ˆnþÐ×/Ï6›¥Ú];–£ÕÞ�L9+­æi6êm­ÓwèUq蟚t¯;úËÞ´§Š2·À`®Ýä6„[@%¿=~4Þ°¬dÖ\G}/Ç¢4dcÀï{µóû²]žÆ>7 žàðÓ màÕ½Œ'=ógtO¸Ý&öÍ',˜º§.ÀÇöòqáuZ˜$>³·p­‘0…Ûµä*?“¹m¶"bJQÐ^é©:I°ŒaX®»<XÕW£îüH,ßZGÉü€ŠŠ‹ÊU¢d² G¿Àb±26Zà‚³ ÜmMÒoÿ ,ä!·Œ¸Õ}ƒ?²äú'¢Nê ã²ÝÂSëîAŸœ¥ ÑEt–ìMfü‰ïÏm‹ì¦IÆgÞNEÓ)Tº¦kyGžMü_ï÷yÔƒ ÑæH;6´ Y¬2a¡ïìSIOï2f•õÉ‚ÊÄ+ºïÄÖÄM†î>àgڹĉ2P<˜±ØÇ`A»†økO–¯¬F!³“ñµsº{ÍÄêo‡U•Oõ®ï#ôãheA9 UaôÄ÷ºW!ç©¡6Ý @¯ô>?#"å•×ŒÂ Åœ†l?{ŠÂUß(}Tßò'3$I™ù A0mó3úø0w¸èÛÓûÑ DUlc›èŒ»«ÇJù,¦šŒ‚ž–Wö¹õf³Â(S¹¿|u‹Õí¢£vùLƒbz÷üÓöØ çGàØ8÷MÌÑèî³"ˆö;Z¶©)öt§£ÖU‡æew¹]ÛÚW_ËO�Ú´@Xòøl}Øòà†Wp‚&OÓAì,“5C§’k®›ä´ððÁü†¬‹¶ÊЄnX6‡‡3ŠE{™¶Ýûé¡BŸÏ¶—@—™Ñ íóLŸmå Aà…á0WKÁ¡òR;¨«×ûÏÑaÄ.­?C>äÝôi45pýÇjz&!j#Ø 1'bÉ:&¦¯ß`ñ½Ðö.CŸ?Éô Л/Ô„\CLá G«ýh²Ôǘԛ””ÀI\ê,ˆ›Ù“„ô´b(“ÿèd®eìÉ\z¤Œ&ð�Ó»òäYo0½y°½ÄßLîÜúÏT÷„r³bRA8aøÆ©Fýâ%ù´ØæjÑw„åPÙo=7Z®ò½£õ …³wå[:»–jŒ±UüVD+âp;IÄD+ªVÔ†{=G Ûõ „ÀoºO¦MÌ ó‘Ò€NE2Q‰×Œ-sOÚêúrG¬(óô¹XlRĠؽ›T:ö‡»”ð/íîì‘!/THŠÌ–Š:{/]t½'ó(¸„gw¢Ë§FÇ6¸ ¿ç+: Ž城Š–�‰Övî°YDCY^oõj]¥^˜z‘̓Òël#"-0‹V·Œ*ŸÛUž×D!:IAGû 0²­Ï©eöÿ?4ÊÒÅÕ’yå¥õÖÄ TÓ»ØùJãlOéS¦«È#goMª \?SÑTž4u„º—ùOg–2/Žß8Œo8[ËLË#³ÂV<6¢C®¿z8"æQÙÈô]°éÊÙèxóÓ/¼rÉx/ CÙ¤ø~4+V¥$ÌØáMT îºæ¾:¨ˆr0Ï»ds¤â$f„¾0Ë »*Žx†Æ›hÚa¸¾·\4С‡3˜ˆ´ÉÀ@/½ÒÖÉ·_€ {æ‚Ð8ÝQxˆ¦ÖH têŒÌÙ³ »¯­^ø>Ì{Q¹¿‰MU 36=ÍgAb•çT—ýõ-ççÚú£;ËÿAßÑʺI±-m¬4F‚Í�Q–éÝ X•–œTTáÔÑ…òà_Þ{çØ&—†µQñ§²6t=ê }Ôûkä)(& ýY¤ý°,­([Åùû|ø·ï±»Ì7oÿÐÑ/skñ¨ëÏvïu®êþX?tþ´‚—bž–ÐÔÉ8ý1épØô…ÒD”XÜKh ålÝÜÕ=+7uÿ‘s ô¤Ÿô4xž-ì,å{7©†Ÿ½ð£æ£ê‘•òOÃØ•–&Ŭ#í}íüýºu¤ J.ò ¸jQ$RXÝi/è5ãô.”µãÃK¡jŽ,¢å(¾h-ï&'0óœÃ`ñlìBgþ5=ƒÛwÍbGwHP¨nö”’WÃÖJù°>H=9“2¤_ÐO¹ß ž)O OSzÇ`§/*•Q€ÛP_k+{?±{&ÂE¶P”NÐáîÖn¶þ%T((]êÎDy”¦™î]Šù™h:MÂÔ3ÂɃàë÷)àÍÕŽ k1öãµ¾FdýìÔÄáÔAè±ûrzÙM7øöT͉ÏÁ§G©ôck*f¦íì *gp}µhyÀt ¸3ñfl¢[XE,ŒsÚÃ/Ô#ݬAäü7{Êb>/žE ­¿5 õ~–R¨í¤Þ|$u+Þ×(½Òq@ï¼(‡žŸ¿ËÌÖjT)©_/ÄB#ne†ŒÂ—Ø ®HV¯À€¿¤Hä^+[Ô¬?(å®u9âY¨yƒ8íë»ÞÄyGíû䥂 MáàH8ùlôÏÈáÏ œtÝ¢ŸRr¬Æ—™®TH2ƒê¤ íÈx¢œÏú;Ygº‘öÒyédøòßÆúÃJÑhĵ‚°O‡•Y\ù¾È•PªÊåä›\w,;ï(0#ôžŽ¨~h9feŽ\Y‹¾Ø[¥•ì*Ï0ž,/-Š?±jIÍžŠý¼™Î>Eú®×èCÛQDz,—²Î p@'K´ÚcÓÈÀ‡[¥ÕW³i›’Eº½‡ ò¿všŸ9ç ”ZK ÜÝÎiÜXµ¿›å[\À¢]Pø¶¬1Ú§‡þ`ÛVð;Ð ç2óqë Š e¢-ÕѼøã• dh/Y©lõÖ¸wå!3¢ÜŒûúŽÞ&ï­DTeTö$Øк‡E„Í+Uðñj2FËz(é±Y_Ò* ü´M-"xpåßÏ~¼—ôE«b†ç7ÈØß5ü³$ÛB ­Îs½7‚Ht?Q=–$M2¿§CuìYr²1mGp§q>u›ÅÑ»+×+?Pøä&ÖËNTÅ»“›D°ÄÐyj¤8UÎýu•Hoo_}UÇÙfoQËpÂÊ;éýç£!hBÃúQʉ)r袳–…¢~ï-ìKÝ oÛú2ý¥©P­L¥Õ¨ú<yd:0T–nó/¼²0ŠMÏô¾DÔkÿ8Jˆv:~ã=þ¢KT¶VÝ¡Ý ôqmÿ1VŠâ–á¤@úzÇ2Ѧ²@ÊöJ%Á´X Ê~ë«1¸×êc<ãèþ§ïþÙ^ûöÎ/¾£´b¯Y“£ï;ì(Ë.jË<Éi*Ô_Îé Z¡Û™ ‹ Át\ ßQlí# Ãµa±Þ#p\ŒÔ‡IVgÆíëCŠ9ŸŽ -÷xÖ–@™›1.ÞY ÍßæfeYÙIn‰n£á‹ÚÎ\Ùàþ<ÌèŠp›òÆqÎaugãÈpZ–Uï%5èh{3âîD„tŸ_è —¥¯ßNOwÚ¿`]ª&h"š“ilÒ­?¾9âUd,&æÂV_]^¡'Ò®üµ–^!BÂìBB'™ÏÊ~DvE*¬¹˜“Åz&Uf+Ó'ÈÃ]Ê Ú½¥U‘w̓Oq¬¤ƒ#NŒÊæ•ŠV_J/ªüòvéøXEö•,y ¢l‚|c#äd’³~q³C©`ESâ¾uó*®‡ãB£Å?3Mmëáר4cER†Xp©ÁëРe^�ÍDÙ i>AUyña“ÝæƒÇ°µeH?Ñ WÊ“ë¶ÿåäw÷Ý0]Å¡çšT_ïä"ôWÉ”“‰sr‹bUo¡'·ëFøžÛ‰Õ{7sCéU[åo~dÈÊ=f*˜6GúÅdGÖˆ÷ã6†©½Nj77óŽÜ„°³½»ÃUk?»XÁ†7åí 9C6[®C4!c±(h\ß(SF_…â¡ñŒì‘!,3R Ùm½‘™Jšù[ €KÚ-P O _î™pÓýå ¨Í D‡3¾ÃZíϪG"­Š P:™Î¢‰­ÆfJ%ð¡°'Ú?®ÒUUÊï(î/^Ѿ=̬âQ¨—º¿ª‰ÓÓR:öþ€Päç! Òí x¨ÜèáñdòÄZÛß¹¿C£$õ[€嬞c…_Ä êíèøæ”ÏqJHú‚ãëÍê4>1|Nsˈ„Lw¨üš½êh__>f#opíÆ?륤ÀŸW\fá*ïša;XZD<@ëT„RæÚvù…~Uªt~uÌé»*H÷­’³µ /—ˆ^bÇì*·¦¯›ëw™Á$W'2Ý„†þɯ'ÖKäÛÁìlî¨=(°ëÍ=AÐ׃¼ˆŽúÜÍÀc±iBµü©Â§Ü˜>Ot‚Õôqx Åb©aïÐbòbµSà J%ÿÉ/žä]® ¸«Î^–E.«2´•0ØOô¾Ž­Ízç¶æ6ˆ+â^¶Gy•ùRy!DYpJ,î´lÏ/™ð}–öÒTMÝ">–)ë<¦AÑ´:÷Í€³*8ž‡¶¾ÞÃøýÄóÐH¢sEé-Ý°“žÓ ½/k»Yž"™B‰úc¶ ŒôPµ‹-öc”IV¸ö PT!S¢JkslƒŽ¥ƒKí~¶HÂÒ¦ Ÿšs»‚¥Âp˜G×y^ÑÅUaS-4—á—åI3=·žV‚napÜ Ý¡_7°‰‚à΄íÖÿl:–Ab 3‹&Tß9ÄuÐÒÝgb}rô{ù¶¿üî_\dþ¤?Žô±‘†Šu£™>Ñ©n À[&œ‹=èô™7ë~¤Z=|W¾,j.|<î!qÖk”Döê‹dí·,ÄÈ!îúØ`vR :ÛKÚ³ôñ ÌfæÛý!·€Ãî§å§°m nÿQ…„k±[f¾ U‚U”ÃÎ+’¤ëJwþŸÃ—¤žDK¸¯7‡€Fæ7Ã"[…ÙÖo? ðÝzt‹ýØíœæL™:ÕsÖæ²3ÕˆéLd5¤wß,T°ii c@¥DE‹½ó/o¹ý4SŠ!GØö^™N)Ìž/e¼âÆa½£K£¥LHºÕÉ}N &˸°œ,×ÆlÖ�W¤4ÙÀJÄõÅŠoàaB#„ÍoxÚþL†Ø)kŠí Uå»>„O{Þǃ¡>#7*ÍðB¸Ð#Ê îò;³¯ÈWÁÈàB¿z'bÞ]Úø[lhb¿B¡ù®p>Y- xp@Xð X l+,¹ßèÜQ}dØ8ï¨<ZÅuT¡5Ï‹¨6…Ò—¡£nÇ ì¨œ2®|«Ÿü£ÌuÇУID*:išI.w2œ-ÿE¡ð7ÜÅï•dôS7ä´Z¹ãA¨¥„±Üp—1²µ—Œ­cSe04 U‡ÇeÍ‘ÌCê(àô™yQæ³Ù 9¶‹ƒÊRÁà:9Ö‹'þKÏôAŸÓ«þ3 ,–üÁ dhuÓŽ¾¾ÆŸöüýâÐø Ð)“Q}µÎoæf—hw¼W5>#¿ù ýþ™ÞÖf¤RPÌ›ÑfUbù1ËÚùÅOª .>žÔ53­Ùø|µ0¯J­­l}¬*Éœ®ÿ3ŸiÍþs¬-æ±´WV®QcõÑì;+­òç°®HæÃ8ÌòwËÀÈþ‚Kç¬NòZ¬ŸeÐ*¥õy´ÏÉŸ=ºv=»8óuE¡íƒáÃùbùPLG«uùpZy“üÈô_zö5™V܃£s‹9R Æ©ÄÝ%~ÒÈm_a+NYL¾ÍȦ>,{G~ugòCÎHÙ…“­Ù·&“Ïý|íM Çþ‹¸H§$1ôŒíXÀs–<g)æí)ë¡e€Àsãvé†Rj=Ãê3î/ž,5bsM' ÝY:öÂù>z/viØ¡ŸP_=”7&’³ifÓ³ÞJ¤ÝgzCDY݇$1îžÒ«Í‚†PÈ„HzµâkHQßÙɹÄ<öØfß+%™w,PôkèþÏ^ô£ÏõæaÝ:à*¸ÓÐ×6ªùîê°È,‰É<=úÊ¡9TçÙ¡5}zaŠ9�|i�.Ã�n¦žhqa¬á¯À7ú… |—ªÓÐ(2*Çp²ûÞ ÉÍÿpÝÛ_Äò¤JJ¯“Ã)À§Uo 7^ØžH·ÒyüŽ TqÑ*q½g~WTƒ±“-DÎØÌĶ~¿, ¡½úywqPØ°M!‚?üJë çU•ø"p$Mý^KÒ?YÓxi?tXµUò[ê]ßh‰ïδ_ã³.V¸RQ`âLCJÄ-<èïÌ´RWó˪¿ ëÉ3A@Çi›Û²+5±æzfc Y º°‚É9Çu+tžzT¾›_½þËû a&Ùy®¡k×7Þyq®TÈz¨ƒ@d¿·ž,³•¡-©´ ’÷OÄjdZ6ˆÅ›Q5Ïó§”#IrúUFçô ­Ùlh\Iã¼K¾V_Àÿ » ýŠ*šáBOÍB‘¢´†¸ Œ÷JË3aÇa•ÉöÞ^=°Í– é#œ¬ ø/»=™Sájr¦Ou*}•”:½ú�±pYî©<¼òCFÎ=ñÕûÕ³e•x#ãÊ_`_›öˆôŠ®Äþp#³éeÉp“ Žô¬-žÚ…õ $w@³›HGg šË~t˜P=ý‰{¸~O;¢’¾+©¶²Ð'¨(€³AËs˜G;úA¥<3¤Å]}…¥Œ›Û3Ì&Þ[3«öN×£¹ÿ«$*J3ç˜#J· øj_ Wø%fäÛXœäg6’á]þ8ËK­PˆÌ±†‰kxžÍ°ÒòȾw¶|WL?ÝÔýN³#\ëTU€WæAÞ+kh>£ èûåèqÄð�‰qðB¡O—qÙù£²�n°çYù {îAÏ@¡«¢|ŒxÓäÜŠ7Ýpœ‘õ2[ï :…ÊÂ{,¶`Z¾X %•…/¶G7g³¥û‘5'ãwuغÚS Úùm™¸NÖöa@§Àr¥ÑR ½§‡ÑÖo›ë€£¡Þnïý*úOe>6¶5å¾”·Vѳ ‡²£Ís`üÉØ©HÉDhdë':_Š»ç£ëN–F{: "÷w8Í<@kjú0÷°8ú$ZJ(*ÓmJêÎFeu¸ÇêYèÆú^÷¬Î¯=uÌ£TÖ0UŸ4ésÞvд"ö�¥‰ý§'t>ËÁüÑù×¼;V ô‰ê6YUFm¶0H­‘¦UÒx›Õæº;aŸ)µÁooÉŠô&ÁÀõŠÚ­wè[¹>ó\mÛŸ}Îøó”]ž6«Ü|ZË#§´ž4äXFûiÒŠáÄ•ÏîWâ³V Äd2mø¦¶gïÝcÙÌ{Ïî1º ¶4‡ÜÐÖæK¤Ö×(@fK¡ôpWh‹î�ÂiùénÏý݃9]û€`¡&AU¿›­!Æ4v¿r>6^Bàá6ÏáD{îúåÕ}=í0”[þÑÍ;h$Ùfvp5€ÞN‹*Ï‘ÉhÏÓ)ôÚC‚¥$—‰}oâPb  Ì£àrì(¤ÎžßDZ³�w2@ä[è.oÙ·VdÊ™ªÌèÇóä&2 ý¸Ì§³Q’ÝŒÃ�Ô\·üÿÜõ–?»2Q¬|C@Ýq~GƒEC¢€8kÞ †3OÚ excÅu©Ë êÞ½1_ÙÙürh‘®˜—=3põ™°·åD] Æ }°]‹°–¾­–¸ôÿ_l戡–ßGWEn6– €^À‡L:_ðþlpúq­Jß½«»Ê}Eæ+÷ÁYx¶Y‰(€D°F“÷訢ñ>õŠk{<–,+.˜Ätê€je†P$ƒfŒ±Ñl -Ћ*ù<Pb|`<¾Ï§y™\GÀÛÞK Ñ­Ëƒäsðƒ¢hìT»¿.üÙŽÖ}¬k¤â)+qÐÖl¯”º6ŸV;%e(Ѳtê^É܈.ãy2æ‘ÜR®RXÚÇÑÕÂv úP~õÏV ,øäȇ“2¿¹ Ö³«f§Ànð²pó!dÍÞ_VL‡"ÐÀiÄ @Ɖ¤ ÆùaSÑ.TòsYS3=7X’ŸŠ»¢[ÕµÀYŒ¢ ˜™s‘ÞHô¼k‘]ð9ÔÀ‹ÀLlnuyî…—Žˆ&oÛ.Oßß=]ø7õ_gåÍÙ€½¸tÒkâukÛŽæî—±_6¢ºÐ±DßJd)>ºÙÓƒŠ×H”{*°„*·‘Óï¹Ç$UœêHËï¤']wN<^ò„LË*Îœ;­Ò3=ßìt2›ý3Z‡‰d™¡×rmhDV³Ø:ß)Ùóæc¾ãù3#ážõpCou<žV^³p2ÛAv|…ŒŠdåð”3¦d“¥UU'§½z¯ ¸ôÞÕ­]CTæÎ’œ1&sA¥è¶5w% L™2/gðO1s;6ÆßåÛÐà0³oY¡§í,œÂ mÜÃÀ:N A†+?ÎWô$ Ñ”Ø|*‚p¯ïÞÖeG³›½®ìK!º¾Z&ÝÆz»tÑÅ^§LÍñ†.‰ƒd<ÍëFZ { 8}gu2}ùAÑÈŸ˜‰$ÜîL÷«V²Tž­¡U ëÞŒî ÒtåÞÊÌ9Ìáš‹kxC³D™“M^Ÿ¼áͼÉöVJ¥µ×X¢„ ôsìë+2–'ÖÑ.Ñ3®z/7<Öm×;¹úäV 9鉴¡Š(F©ÅÌ ¿'­>¹=?Ž=8›žö¯Ø 諪5 [J¨ÞV&"Qˆ.ÊÊ¡yffA0N'Sù<>ä³ÊoÀÐ.ê܈?Õ¯4öl½ñLÆ^9oý04«Ù¨q\%|,vX”î6N.Lªöpø´—Ú9]ÿ Û÷Ì«©è™^æ"H¾¬…W~cš°¯éâ^0¥è‚zîõË»°¶Fˆ™îEyKvU7NãGjÛpÄC¶nJ,ÚôGÈÇÿà–™®™EЃÖeìõ—CÑ@ª¼Zɽ8óa˜±B$Þ½"vøBšwÜGÆ­±o™ÎN ÜS`k‘•ŸØ³ƒG!—Ã:iÞ-Ê<\Ûöu¤óÞ‹ˆ´ÆÞ|£»Mgž¾<´eI}%[æ6-ÄÓ»7Î7ƒ"û~ E^ÝÆB¡Mƒ1îôî¡­¦-8~Û×U_. óÕ´=Ç»ñpòdØߘY¦Nôô i)š¥×ú³Wo´ °Ñ=ú­)M³m• Ýg,×ì©VuÂ’uÝÕÊ6>';‚j“:=þKkYÓi6e"µ/!hʪè€úûÅ÷’B£O¢°ÄÖž GÀ°ã–f¨P»7] ~ßÂEIñ}A?(9í\†ƒÿ,DñQ3ÈG²´—‹=}éÐ’·c©l:PËaF»{Ë,øÊk³Èªr™WÊ’wMâ <Büx:Œÿ¹?c}³åñ?]VLlÏ ±’¤{[Ñkmpõ 0m±È%³ûñV¹Ã3¤|¯´(X­·&gÔ;•Æœö<5&‹¨4¨BC©Êf‹Ú©œÖnì‘(ž¡þüsGÏšæcÚÏ=‹§ã=¢®èˆË+²ŸI…žT�“ }ïµíìË€ AL'îß ð3Ïì…ó—™–_çwl©Ìž`´êìq`T5Ñm!ÅòÝÿ%îj­ÒÚŸ‹ ï<˜(¢W2¼:øMÖ×SèŸþ#ã³æ…hÁ€Ö«”vjæ” «‰À¼±>QæÞ¨›t—ö¡i &vl¥ŽU”0¡è欵ßÝoUTB÷§ròª 󧟵‡ 8´µ)e¿Iñ?“&ŒÖ~µ‘Ä]úÑš1à±Óƪ5þfË–þÈâÍ`3Z—uŒ!ÑÔÇHBE±F»Xo›®Eå’˜R µ˜&á&/j¢™'˜òiȲ“o^£Ó[1ãV›íÀX¼«'ÃÂS<Ædª.÷81†õnΊw’NÓ]Ä›¬ =e~Äq¨¹C ·‡ÎS$¦ÿa½ÛNW7˜¤Âœñ¼8ºYC{8ù<²Ü• ‘àé–"(›‹×"˜é,¡BÆœªÆÔ}Fƒãã¶î°¬Ìøÿ§¿¿ {9«_f®@ˆ¥CiEÑnî¾6…'³ð”Ðÿè~A(ËÊ4÷Õ<i¢°ˆyk¬Aƒþâ5ø)sÊ°yåÎÚ}SdÓ/Ûb¦HÏgsÞôÅBÃ̦õ–Å™bKå-LÞ Ì•Ò'V?ðw£çõègßû(6ÙôtŒè ~ê´º4r­VûR"Ü°2¯¿]ìt…Ήí”êÍCë’cWЭ÷öÅ´!]ÿ!¢÷‰—¶ÄÈ üùVº×®!QØ>ó›SͿͲ¾g[ äKP‘]”³Y"ÓºœŸ·¥Âb~*"_ÂëÅŽªukºEa¯a9u@ÛXÑŸŸ£ê¦ÿ5t”|éÈx©Ù+]ãVûŒ-@óË4îW¨Ý6ÆGfÐqA»`h½Y /¨vŒÏ¯l‘û-{öæL¿R—¸‡Ò^RíÍuõ¬~þ+V tûéËLq ·6´öw°à<ýš_ë­Þ`­*g†Í0MAç¹Õ›(3åʱž˜‘¢óÅ"/äõOÙæ.ç7ÅçT¿en¦ñ3Ÿã³B¿ *ˆîÎÈÁgeK˜ßI&°^¢O˜€åj¿Òj¸ í׫¶!dcÚ!ŽL*Ê€Rù÷rØÕÄâ$öc ->Ögz?;§Ðã¹—É„ýZ)ÏnÄEN#s¶—ÇD·i|¯m×>Z?ŽräP˜¬‡5Óx ãN"Êé“åK°2ò]Éäå!pSÊáe|É64ŠLýhÜ-rxéPð™zO•°¡„‘ÉÑšÞÑÉ, ·û€Ïœ×´¬)4çIPî¿\Ã]´>f†˜9( É©—<i¼ÇÊöŽb50œ©Ô>Ø¿]Ï­‰~Ä,C…Ó:ó oR÷†/÷tähé1¶²À,µÄâòxŠº7²Óv2¥÷�[IQùÚ [:æŒHQÊS&�,î5Å^KVA1TóKÏ–Œ¡Ln ‘N/5oö×ì“ösdYÛ2ËÌ@›,ƒ‚¥òxìœBœí¢ˆœðèËàœ5ŒyÜ9ì”kª% Lq(y϶Ÿº¨"îŽ]†¾Ó! „`L;ÿ5aœ(.ý¼‘Ÿv[„z½€De½@ž vG¥¯Z¦”w&”ÄÕWÃò‡ü‹�ñ¯3Ï‘á.BÅo×eœÌ Ú4TŠÌ?åÀ2ÌcÊ?j/ešFLòpç¦úÂL•W¿}™éa©"v §f;…¢s¢Â ­û„2>¦pì?„RNuB#ݵJ•Ö¢¤Q:<®8KKDSÇ]=Ø—Ž1ÈæÂò²»ÎÎ  Ï€œ˜ pw65›”ܾ¾q3þ»Vp®nN4ôäÂYÇ?H_êiœk{_^ÒÔʽ¨ÂÜžîx:,NQr3Ž³ÍåïТæn+´JªéÔ+µ*ÙAÏ·½¸Q¼µ;uiŠÑž~¯›}kUvs¼gT;¤ß=†ÌV•Ïªeã‹$œ8öÍ80ûr # ð¢0´¦©û©¯rÕ‹#_ eÀic]~ynñÆËÝ~üm7 ˜ H4( &0ËQm-éöO¸ýù´¸|c3‡-Ÿ¬s› ¨·¯ÀØ{­ôÆÐ3ÚÑž)zí?p§‰´lÓÀm6…%ëЮŽ Þ«ÏmÇ'ÎÖÔ‚ê3mY³Ç=R¬á¼V#;÷žê3æÑ“Öó›=hRVÃ^?ža„^sŒ™›?qtŸ^ÓÌ }¹~`27W<{ñÝ;ôurbx㥞+à×ͨ•WýYç˺îY¢ý9ŠÙ¡Ê-Vá}d¼Á­`Ýî_ñc¡?€�Kéµ[§ÿãRíŒÄÁÅ¢<(ê®Üñc¡ê¥û²¢¨V¸³î"‡¸†a§«©0�ŒÆ­·Žvý~nî¤ÝÔc‚ø›DáÊ>© ö'ð l‰ThL-²)Ó=�Ëøp:¡Lñèê;:%­‡¡3ð{±5WKÅÆ˰Ⱥ?‡éýô•Ç¥Ëº¥•7¬Ó ÇÐ’¢Ëd1`¢‘M àF³¡¼¹Kö}qê'RN¢ÉWœ´å¦Ð<ÖR�Þ²þ➟xù*³Kº�þe¬?æ�‡IåÆÌE»Žh»Ø.f±Žñ~DÐð߀n™êçÑõwiîu°Ä”¨-è–ÙÆnæ×aúXé½îydù:g?u±Ž ׺îö¶§Ðvpoê/.p ûUžjwFaµrˆ.h Ñ^Ë?5ù‚¸[?^`yòcá„rüÐ%ÆBmYò•AßQÈ ]éËçϲ@Zo²GÐŒÂÝ¿#üŽ"Tr)/(©¤´´ix½÷=·«ì_ò¿h™Äå é®Ó ýÚ¯ÊËë°¿n§«éÌìpŽW{䇛Ä+™iZ³û–Öîv±žòTCˆ”í©¦L™÷žUþ¨mùïÏmkQ5´{4\îXlyê­‘8¤ArU1*zwø¬‰þQRµm¾6�HÃUùO‹ Å²(¬– “&ëÃl„=àxz©g“ù†ùcIœÇŽHŃÒÍŸ2ˆg…œIûš¥—4óq"¾l'†“˼ºóÈt•û4Ó}ªìl ÙKÙýq?µÜ½×ÙfI‚t÷nÆZ,P…~#)N³e¨Î35ž¸ræ› óýX ™·¨vPÄ W¤Ö}W¿ÉÁßKqÌ%Ž}¤€©綾ÓÕ†£w¿à(… ‚³K¤z²St¬Þ:ào° »¹xÒút¢Jÿm», ²sí<¡Vš‡sì ÔYÔÙÙ[¯$ìÍ~C‡Ñ†6Ð!ÒŒÃ`ñ°O¥ÖW¢ëiiZN™*-SÔN÷VÎÊ®›ýÖŠŽ£b¥…‡Nïl߸üœ©¦"oj;4͵žä¿ùÑe<nÍfFRn³ÐW´¾×l£Xo¯~Ÿ˜Îõ‡Uë)=JB5ýl‹‹´\þø¦•y8müþ­OZìu!qêå�u§<ùwŽØâ󦂬¯€ºã0óŶ+ÑÁÊOvºYó½9цV Ò :XqYf>Q-v}ð—F ì¶?õ‘¶Ö ¹AG>ƒ4 Òô© ”MÃ̈¥ŠYÎöÝq*¤µÊD?ûã$U:sȈ7t¶tG6ádŒùýaþèÀÔ°œ=Ð÷1B°lqâ0 ã'A቗ޅáy/èùéÊH–™÷Ôø£ ²ª…¨p†Ã@7§.Ã×eS_„ŽÕ ¸Ü°’+v-Ȉq¼°º•¹`Ƹ »iæsÚèÍzÚ!ù»=Ù€cÑ/†0£mÈ‹ãø8gä�FÎej«¤­Œ{2®ÐÙ¶-Dh“íz-n$ûóÔÂY‘²$S\‰×_ø9)ž?Lr× ›«®ÿŸøü¹D75H禂ð«UÂNX]E;Ðõ‡À¼©4n¡oæ.¾Te®M¯ðvmK%BPè…¶Íïc©¦¾jÉ?Ãpº*(›«ëœöµ9CÔíCMYè4é|ÖJ™f¾?y)�‘«S@ÖÊP/íÂ9„Ȭˆåy+¼kyl§ ÑðíYæ¿¡¿Ç:¬ŒÍ ’M¾èlŽ¢åqj$fó[¯0õÒî\{{TAQ–ƒÊOŠ$/ƒÏ|i;V}âàRT7‡H‹Vþˆy[=¥"´)µór©YîöæbªÁnóqÓZ°öeLAD†Êr´ï<ö0#| ¹ô7²Ê•‡rgãôåR±“pþósÏÍí›­ÞsmËèfÑƼ%¬..L¿Ór  áø¼/ŒV¤^nÎtßiO5¬·^YñÑ!çuÍ/8ÿ€Ô/À >¿ŸִMâ—@¤[5ŸÐpÙž¼¼ìÿX;½€ž"ç ÞǤÎ~–P…½÷̬ÁBT[FG¸>¸.í_Z,¤*Q•CŽî‹þÉ·ƒÉ²XÖ¸õp€}'Ç’ë÷éL””ð›M_¢Hi÷•lÆk$☘b<Ï*ÜèÞ°3ÆSëÞXí­Ìp<…ÜrP°/»óÙÙ¦.8#Öú§›]¼}õd®Xkh½*\6᧶µX¾ÑcýIžÕj+„LxnJgñ¼÷0ÕhsQu<ðiùmû¼¼¼?Å6‰læT¼OV£t7Œý¡V”ú)peK¢F‚å‡FONnVü©hnèôÏë=]»÷®þ7fþA…-[Ô8¥7 ¯ð…Ë_pšhY.Š8‘Ãx2KÔé—šöîíëÞF¸¢ ø2 š­³Ö ë^ ƒžbOüÝ×à²áGÑhå´™D:³F‡,™àÔ'h Ú/aÙõ"”´ÍñJ–‡è¼*ôµÙš:¡¼²ñJ—õ¸žb#ÁifO»Z°{Ò(FéýY‹q|úúD©ÌD…ÄÞâbËóØØ@ïkš0‚cœþÊ‚"Œ}#Îú)ì”í»7'òg’’ЄâãÈ ôÓ<=NC«2,éè�{V‡ÔwÆAoˆ¥çù—ŠuqìIhs«pßVAˆW¼?kºYw0·Êì²)ô�,½= Û{ÜÊK<Cbv¿k»ÂwC/Y-I‚à:nÀ›V~Ñój-Þ”§.eJÄÞžÒå¸î}EŠîöàÓlM1‚9|¶¼µ¯ÞXR6 ÌÊö'å¸#¥©OûÁ0p5±Y(»Ùª#bˆ5€åB®øÓÓ!\Ãrçüu9M²ëò58®MÖ¤UNQ(²Ò’1Ÿ± -á-Š›F¯ÖW€È7R¡WÚˆÛ}9hIet+—ÛT…‚ñð³Á°xž~ó•"VïµYNõ°œû­B펴D§î"}›šFó†Þ%>yæ{©Ãõ㬲èj½ÈhÑî¶\AVŽCC¡[í¨¶6#Ï{bIì3M¹ s¶/ïÐx}juøaó=rG’237"x 4ÖijFSèJ%0œBÅn¬3 "{1œ!Ÿg°Jö·7Íä¸Xi3¡ÏÊØ1-U'BJA®o¢oj§Ï¦‚¶}&Ý:O‡Àó`¤�sïë %ˆnÞ__Lýè6ÀË0á*"v}e$õÂb©÷ö˜þÛB¢–SõÿŒÅç.=‰PL³ ëT½±@²5Žvlcª–Á¶¾>hDÄnÎÆᾇiã¢{SMl�ÃÄ‚\×Á»¢b¢¡Ó\Ojï$o±›9Wˆœ”‡â£ëMcqö[–ˆ,jP¯¦¡…ï’" Ýõtr—› g–Õþ“ n‚žœp–½N!…ÈR­wû„ÑŠˆ•Ð‡öøÐyæñRÙì€r[&~öâÉÈob8×r´”›ÅÓ*ÀÖlÈÀ°9ü‰â:ŠöÙè–=¬ê*ÏõJ²Áu¤Í5&UFú 7hL2ÅýNJL"üέ›¿8¡_²BÌíV«Ã„ ¥9ߘÍ4n—WÑWÉÚÁ6ê©£ŒÃÒ7 k†=K±gGq4r(õÑ9â½} ¾~í³;2ãÝÝQ:,¢ L­ #Y8¥Ì°pýò]36ðÛÂø|NG@z[ëc)góÎ [býšëLµØy‚•»àž“„3H¸ª Þ+öuKÏÞtSf$5‹ŒRíè¦þ·cYº_X i(qêN<Š7¯nÔÒ{ÖcÜ[ŒäšwOLƒ{fV¡FóPçÈ‘YLé–P�-¤F{9>½—­1êI2Ìæñs†{C,ñÛµ0ˆMP~Z½‚J4Ƚ¡GÚáÁÇ0^漂ñÝøMGbºQt_f‰\:õ=E[š�,¼l~ýÜw£òpo–Éþ ²+e‡Æñ_V¼‘ÂþÈa[Ù×ç3/ø± Î‰‚_fÍf‘ógµë»Á¼ýwYh<þ§Üfm&˜}Y¦kg¢th@²xþï[Di­gU¸ƒ^“žoæ•hmÅ‚Ðn®Í”!7Ê š¡&ÒÝ6v¢æ+Uþmô¾ÿ[ÇwSC[aéØ&U.CÔXËŽ›Lgw,V/÷ñЃ7ó©I –¼vhM:.6uKíú;AöÌÓ¨Ááͺ£ý—§?mùu¿Õõä0Bf%æQ‹ãš§ý¿áUœŠc¡.Òuƒ×9ÂúÂx ü­gÈðC°J”e^Xcœo`dqŽœê¶¡°(·qŠªlK½Æ˜Fëá2—°›- Ïnºœ˜*âHãŽ<žiêZ™q™¡ÌÑ 8Ì a³¸Ï‹òý_™â|µÔ!¦<Ä”í-ø­^hñ¶¾­ OùÜmúó0·žãí«‡ 7ÆYiз%㪊¾¯·#{N²×µ �œ®ÒaŸôñmCþ×AµãÐL)75¥"U={2 j1Nd¹ûìGÌdOß*¾,‹Ü•=­ìhÖ6"’9™9¬­x$µâ²®Š×ØKx¥Oy2ûÒx¸Ѩk4w«ç½±V>ÖÚf“ñä“!eƙפG™ ˆö¤OQïíCÔÑ_ÎîgOÐk|³ ð¥¥Û”Y gl\·9X˜À¥–1Ñíë7Q0ÌI%ëf¤Ÿ½7\hÇÝZíÿ‰rF¦ „DÕMÑŠH,â •þÚöWºw§~щXçà©à{Ò~çzÀ‚2D0 'Aè­Ù}7¯’b5Ò¦{¤8jµÔÞ ˜nú° wÍ8¤@2-f3#½b$ŒÔåþ‚2àæ'&…™é˜IŽsš¨H²I$BPÛp³M &-K}]C*m3ó†jÎP|ƒ}½;ÛÀHñ<'û*ßµ«?Ö·(÷SHÆ­@]Ð%`2wv¸Ù‘mž)¹Ñwã–Á˜OÌ顼íõUÙ6¶Næ™Û4 R€›O3ÝD« NÔîâ›–kUXW„®C|ªÔ¯‹éÓ–’EÆt0£lwÅ¥žK÷g,IsØS†{‘¾<3¬÷ÊyG§m]aÊñû¢ØRäµ­ððÂà~íÃì©r¡_dM2,~AÀ7?Îçå®Uâi¥"ã™QMÙ9ù•#$ø­dÖ˸¹4ñì™8ÝõYM H{–ˆ4 ¿Wá.ï4òÐ÷¯Œ©Ä£Ó­ý×V£±²ðîÒi;C ×u §á¦˜Ö7·*ÜtNœë�f)¬ HÌë\t¹LZ5N“fžK=àÍþé»ötœÞ-SAÌœ^N‹Hê¡7bº[NIæ¦`Üëñ(ÿ\dŠÆJFî’2¢ôÆùn³§-ß+R 'î æZFÿÕv}SC"ËŒ鮧OfUÎ3£QèøÛ°nB{©{d÷/]×¹4ýÍ1¦û¼wšnü_^¶Ï´Šhm$«:”ÝÔ² Ú«Œi_Ÿ'äež,¿±#ÛÓ‰.qÆ»úQ7^Ë#ÆÐ.¹÷ëäy~‡ÇÿwJÅyäˆZ<2¦”v«uÛˆÕa˜{d¡Õ›E&ÑÌó.=%aN¡ÝŽó'ÿÚš³dw_=ȹ¯<QX:;µL†ÛôAÛw¯³{l@O‚Iú³6º·ã°=V%ë½æ‚¤AœÒVË8± ÷äï2uÝ'æÏŒ[ÿR¡‡‚ëåþ:wåä™üÀ°Iñ%¡éáÎ  ­`γȇK骃¨ïî¶æ¶Ü“:´…óÁ%œ õi9ÌÖÚ€Nâ+Õ=àÕT^Õ´”†;ó;›€Û²õøžù{«]¸PeN¹öÛŒ³Ž|Ÿë#r§«x;> ݘYÐ2' 3wïžüT_z㊔¿?·;†ˆÐST0Î Ä*\ãS/ò ´©DÄÇò€®˜•ÓÁ¸PS”§?Ývec%—"a˜:댼0’ûúb;iÏ ­&\iŒ÷šRÍøý_GìžF`\Lÿ)Š9Çn.]gÜñ#KÃòìèÃTV%•.«Ó^¯óꤪ<KÆ Ѳ@ìŸÃRC¯®vFwTº“|ö[¿Ò¿€ÇG´ÑRÿ „ypØQ&>)v±LÈEA|T}Ÿّڦ,ä_¶E}ênHøãû§“¡V~¦.Ývª7È7>:Sš~ë9f¥SçÉxVx.‚¤Ÿœcèèn:ÏhL¤Ïþ=·¤ +Œ*¬i+ýœXItó.š»hvAˈÝ),;`zκkÞåƒL6úOª¤ª˜A‰‘(fV&ÀZtPTÐÉE-f¿V$ûþoZúÐt>÷%e+JØ,"@. þ¸ìi̾rmQArX°9óþDû²”�™Àɬ3ž{²0êko ùw®PØv÷¦¾V}ˆIðPâ ú·ób#ÐÞçnm‡(£+½à]²gÔ·ß@‚ÈêóÈØw›3Ùž]ª¸Ôƒ•Û짓ææöR¡²VaäÚ:ÜmÙEÜ pM¨=«pÛžÅKÝúl¥óÅŸœÎ*­AÑK¼qº8ÖÓ©ï¤±Ç Jwu_Ù1 ½Æ"G(á}?{‚0³Ãï¬ç2¶c‘+rv‹LWû{È;LOàà‚JcOHõò®_: ]8‰/SGËf Ô¨´%@¡”ÂVDƒõòcûTy¦g>Ó^ XV ½fqL€ dºX#¿¨⃟çÐu-÷þ¸s¶¼ÑßœöòË\Í.MmJ¥éOÌ'GY9!Õ}#‰COïï²j«º( ïPú`¢ÈdsÀŒ›öX¦ ár ¿¶¾Œóí>12IÕ§•-dÜ‹)Ûu”wè™ø‚B’3ñ®¬VB•±?É~Ýíy˜Åæ¹IäňÖýæÆ„{•ñÂ1È>W&¡ ŽˆFÎXÐð7ÌË[ÐLáèmÌ´ E‹R»·í/:Ò‡š|ê¦^pãå\ã+3ÖTLš“o3Lû’»ë[¡ Ó¡ºÛUaŸÂ,vÄ=o=lÒ¼—mª‰ýo|p£Ôwö ÓeÓ@ceRô% 1Àb<º Æ×>ØjÞŸÛ+°­§ù׸]Ê¢œoIŽ…ÙÓ‘“žÓÉPV*Ù %)¹ûì~Œ _TO<Œ07ozH)ÆÎÈ殦-Óuÿv6œ(Y£¡üStB•þ'jF7Ší©/ÞGï}ê©4*í&ˆ­¿3Zz£ 60ûùoõy†OÀ-bÊnzŸ¨f• óM ½ ZKçcÐeöã8Ô`ñO²Tvâ‘é¢Å¡‘©™?Àe¬¯y Ô)O·ëås-[U+!8-~œa.0$2à³ÆS/`ì‡&‘ž•«ÕQUšy&¼,R‚ᕽÛ^)ú´*-<(2›Z6 ܧ•ÚÅÝëÙÁÒ^ÄÑX½UcvX ¸{ž<Ì1ÃŒÞàˉÙcŽ~‹ç¶ˆ™ˆ¡ð,À‘À%P¤n™;uò 5UKj©Ã‰›Tiù¹>ŸPd¡Óh1Ù™µ¥†ÉS~kØÂM,z΃¨*jýNCÍÑÂsÓôߌôžÑtñ[Kw<±¾ï¤-ð½lD«o@s’¾çH«Bctêb#ï±ß;ÿ~|¾lðo= ›‰,q“Pq55¾O# Ÿô Ç˃åól%Å^(à&ÆiŒƒò´³…”Û:G®ýU�…z ²²\)JÇ4å£fSS±þ®Â„ÆxFx̳ªU¶øè±0ØG~¥ÜZQ-f:}Ü@l0bÙ¿› O1~Së¼,öUÒË(8ÒYf½~}«lò[k©ý™bÄùÝme Ç‘ɽžÿ­Àu©™‘Gï² Ü«!štÞ<ÝCk \Þ§<2‡£`ú2Jª ýw2šEðC? ç£|ã íúR¯VuU{Å C$!IN–^^âN-WþŽçö/2ª2 €„pÉX/,Ñ ЛðsŸƒßbå-èœ9—�» y¨p¡ê‘Q;Z™Êžns¡ŸK}zqÂ,é¾(xtoõ-¼‡ 1}ظ�a×íp°1²Æ¡‰táÛ/ðîžfÎñº ’VŸAYʨT$_øÞÛÖ¢f^4[OÊ›º~ü‚»fë¨ã¾­¤ñ¿@­<Õ°|xgùMìuC;Kogi¤§Æ•N&7Q0ú:ëÃíÂFâö@Šû�=·rÖ± fßtx±Ç…!_}Ç5=·¤Í"ËBæÿâ(¡(qõú—ýaðd)9:ð ÚL _ù~8ðDj&©Ë@o›µ[ß”qéFw®ž÷|�ê«U`)ü¨‚AIJ+ã]¥˜ "#uÜÚ]ÔU Z&Va‚Lú‡»•‚±HV’4²ÖWùÁ¾>ÏòÔ¡¦2Sp¥A5/Ös„k4˜ÍXöx˜~’Šñ›Öìô¦ád¡°¡Î{QTæ¦ïÞ¼n»A‡ßKwʯGEçP™Ã=s×H9[*Úåoð榣½û¢ïi¸© *7œv°‡¢É }g™(òÄ‹x~JJö¶÷ÓÜ”:ó|o§ÙuÀi;8dvl@ȧ± âmëš’ý¡¯7V§Ôh7¯_#Y£ÿèýæ+íó¯Á1‰ŽT å^]9*ÑCQ¾RùÙ#‚'Ç×S–ˆ²ÔwÚyõð7¶,qQ–±‰T9G!¥Yã|Q÷Æ}“#Hå~aÔŒ¨F,œwÙwônf*© çø[O`‰ž=ó.è$ù_× ¹}{ãýŽn!™Ûºì«ob.>Ì›)dµ•…ùérnÇÉMPc•)L5©»Hì[«ÏÅ›÷m¸“oÝü qLÿ×¾n\WÙJ*nÿEuì©6‚…âP`i³èu¼¶õgŽ TržË hNn‰öus1ðFæ–Sny};Ì&¬â~èi< ØOÑÊ?í¨x«a 3+‹ccx¸²‚¢ÂþÂDO'ºÝ¬¬Wô (  lá;¸/tLp-Ú×ô=¾>-n~^vÌ%RÖ n÷ÎhÙ›MÍV–æ彫ü³�9N™ VìÓ;`uMk ¡C:²ŸIoQæÙ,Ñ`·p·¥)HÒÿøÌå,m¥}ðÌ%ܱ 9HR]¾ßeTïìÝSÅá¿9Ÿ´üjúpº×?ñ½`ðÏ÷Œ µÚ˜…Y™mÙ¼¤W•éÚ1¾G•×E™²é¾Ø<¯|(ì`ž—þ«MkÀ¨éˆ@ Åy¼G„¸ûß*gYžYÕÝ9-‚ð¤ê’1[ˆü9̶€Ø@!Œ–³Õ€Q¡ÛÚ°“LôÛ/°dm‡U§mX­Äƒ sð¢à/Ž€ §á!ï…Æ ÔÐôÊî¼Ü›ã…¨µ'Šy_;7–jÎ js 6BɳU0-GÃQûU¸v¸ÄákÀÅŽ®8×ý‚äöŸæúES¤¿!;:#ÌÈÈ< ,ž_+bUX_ 'Ê ÓSžÂ>upŽÌUXEu¦Ø%ÿF¾_’ƒþY%7D»WywiìÏËà>ÿ‰>ÎuçÄãæô?Ñ"ÚãŽÛNê¼Õ @b {³)qâÿ*óÞm¢cw*¹¥Êø`m¬ò·Þ*õÂÑsvô¬ßæÏ3|Í×°: rî¾…‚²+DßSåPv'~Âi§â%PnbG þå3©mï”F«g˜¨0·r°�óôõÕæ—Ú6¾óªªlqâk¾Ò;NÇ‚Ø»'Uh’Tëö“«S\e+Y%àóª üüò8ë˜çÍo,²%uíAdƒ´ûÙ�µ^r³øF©îàJg4ÍkÀÏyDι Å{§è“ó4)W6ætc; ð[‹Èÿ÷Ð{œÿCµÆHíz®P ªþÕõÚžÙ»C¬±]‹!n[Ÿ—Ãæl¬Î_DÞDYìjÒŠeÏ{:*+ó[ikV2\ë¢×-Mñ¯²èÜ-O=Û©d™,—¡\+s¬ü´žžòE¶¶ ÛüIƒr;{±˜’f :ˆSËÍxA*½r3cns5 d&­ím$ Vþ]³ŒWÎïE0Oe.ÖT0d„E\›¸cÍ\òNt›©lvÖ÷5p²IÑŠL¥¢�žtš”ÀÐbÀÝuv´¨à÷ñYVø˜zdৄýŸlFÕtT{s>Âç˾;K †þ K‰¬nëÍ8ßÑ7UæEKúØ-mèj¶Å?>{·ÛÉ$IT![4©Í=øé”xGeÈ°jÚcV“dÖGöOµL8MoÜmzcÓg-%›^Ѿ[þ2’ ~³Eˆ×Bõ�°SWYùi’0H1Ëé}¼ZÞúµm¦qü0œ($mt»ŽµÎˆ˜‹H‹k*yŸMÒN÷,HyâÎ0˜ ]vÞšz®Êyƒ!æ'q±š¯ôþ!m}ÅÓÚ4ŠrÇ1ÿK°ž+k”ËS JxT8LÍ¿(¥,þ<C®"èþPⶫ½C¸¡lõ_•%L]º!h2V;ýÚz@ZªdÍÿª$ñù¢$þ‘‘±‚–ÒhÞ3*i¶iç)îóÜbEØÅÖ¨³d‰tè?ÑíŒé_ù7Dé*LÁ¿!+Â… 2ýEdq6þ4F:ò¹¾WæÁ‹p˜1£éØzÖ0³Ïønþÿ/öšP‘ˆ}ïè†eÛÁ;ÖpDN¤dñ\ÔXÂ4]ëßÝ_Fÿ±<ÀÄÔ¬B‘îg><úä‰)s tå|¢\ 7žEµþZ†bÝ"áÞ=«ÌjF¥2=7´C‘ аA“‡r8òRÞoýZÈ·qÍa)›\œ¹lYX«Ïz`Ú6È_^ZŸe–=¤­s¢L9k”Óž éûîFoS†Š?]t‰¦#gáe*) yÿ×)£Ó‚†/môÐÂC¯b@îûxùŒÎŽ¾¾ÜnØB&–Elº<ïÚåq=+Éŵÿ{?kóDîÁWÝ�;štwõ�JÆý옢?¦WQ™ûÐBš]˜‚¡3ŠýùxÚÓ]òh5 ÁÜ9@î·.½.xcÁÞ±Î2ß“ëX@'¾<VÐØèkX/ÓYÌ+U‹Æqb1›"({[�(Ì©»ßÙ›.~ñS}60ç·í½Â±Œ=¤ƒ X]ï¶nDà¯/WÁ:_†›ÛÒÕýw]GÄÛæ oFmg”¥è7¦œ§GK•&7sL¢ûk¤³6Á¯„N¯2(ö'·ãècZ4Àj´ùögô±ÌO?]V�Sìd` a*~>9ßžúÐZ' úZW‹„ù­Ð`ê¦SB`ߟèQ Ú¨LÂ,”Wçž;·™ §Ž—ŒXÅí+á'Ÿ ËkÊ)RÒ]A/OÛdòK,“­*˘qEÝÉ)b Ýu¿†$™‹æŒÂiðÖ?¿GÝšÙÈ· SZ™GybÎ;ÝÕ|óÖc’,ñwDÄÊÌIPvzVF,žßwke`ÝÕ|ÁÀLaãÐ+ ÊØi£e¨Ÿ0^žtH·¶¹ù7T´äó§¦hì=¼u¥ÃÏu³·Ôä°šgzëȪ×%’[ªX£%,¿pæUD¡ÐÛ—A¶WÒùòåoÝÐvPìm{þ¼ËËUøŒßY±Çdb œeH ºÚŸŒsõÌ0®ÇÈ¥ïFxÞÏ:d¢ÄGàíÌ,ËҸı X£[ñÄ¤óª– ƒz»ÃYŸi�ÊLWp=‡›() TÀwôÆ>òË»>[PF ã®Ö/ƒ#û Â4EVdN/9÷‰þ£ÜGÚá´Ñí<·–õ¾¯~xü0Ò5ö«@ñ ë䟪ÊF'}3öÑ`3?VŸQZøüŒ(f_€h^Üè¸éÅÛOk‡m�Š"óu(¡P^û»ßÖI†{’­Ñ“e¢:’_L+÷J:Š+«}Ÿ¦á+2Oõ§¡ßŽ<0_wÐ9'¹ße}¡$¨–­o»@hߌ¾Jů»FÕ‚ÍFØ›#…–¸]\&.>Q7P¢´’Žyb_é)A6LyPôŸV©š J=®§~w$#Ï- šœq³ìµò ü Ô»ün¢zLšØ|û˜ì/Ogl'`OÂýÙXZ&›†Ž¬ì¬ŠN£›j›I%­”ÿkd|D•IxÒÕÏô-ÂÝ^]Z¸«~ênÔLà]Ë#Žçn"ÕŠKUA»¤A1xgðµFßFKL/8ËA–ÅÔv¯b;âÔÕ E³ørqc´Ýâpù+³ÌÇ'È)wÍh¹¼{V€Ø媼�IÊØéÛ‹mÖŸ$ ò¯^Ûa¬óÚ÷´WL#ûn‰_§2Šg>Rx£Æ3 ;ÒçÃ;öÚv|$šáØÒܵ EX%«-™¶‚Ê=êmO}’ßê…Þ®õ3¨µV’d-šÒÁŸ¹Û“ÌcèYÁyâÀÇÂê“Q'c¬øÓ¯ÑÛIüܶÁTÚG>Õ„í#¸‹ÛµVÊù×1N}ØLl8÷¹åpÇŒEV“z‘ªdaý2ÔÑ"®‚¤ëÝùp9°Žä?Š�Ž]òÀW]])OÙOôÍÎ £Ð*±$‰nêT¸©[qT;¿6Hroî•ð®é³ jwž!6eÔÇ‹Õ[ j\ü탌£ÊsÍ mA+ߥâI;ûÞœ¿‘7›ÍÙ¾ÈX›8²´€ùrØZ1V¾ã~ï·‹{Ö1Y¶2Š«‚šòÞüÔ²$wÿ¡°KiUÂåªÕùÌ% ¤ËåPyCÓ_íëÅÈÊ®Š7pÉ#€$·£Cu(ƒè¤ž‰eæi¯q!Š;ùÈ\D¾ xœ < ¬•eB†T·×Ù o>Ç¡ùÍÃØSFÚ5N/�3~;ïlðÑ~RÉÃB¬Fà…@Ìt3ÏìzËýŠ S÷�'C÷8ԠЛÒ� bnUŸ¡¾x„–Žûú?$rQù£JˆxŒY¤ÓÙ“J…ŽŸ6ŒèHj)¿@ßÚKKbûÈÛÅI’gF~´?gA6Û®QÊ-©áâüàÍ=~›ºÝaÚ³±¶þE#Yù+Bf ›}‡~1`®Ï'o¦iÝæL¿]‡§4_è‚øÖnÍÓµµróÃr^|Ö(üõ�ñÉ´ï¸=>s€ŒUE-œBŠ~}-+çRi¬›“³¦{¬tqWô¢ŠÜScݘLÃhöh'=% L«àüµ³Šm/Ú±'«¶m¦Æ‘ù~ñôc@z°°ºk7þ9ôú"ïhe„<=!=Äg ƒŠk”–nUìˆM:b*ÙŸÿVOGUfy”x¥Åjö’0~' ŠZ›y˜[+ï_Ï{ÿüÁEF^(* |{¦t¦¢jšŠ–硚ס÷ŠbðoFq±§‰t2ýüÕx“ô#,Ù!ajŽ=Lú¸Câ7Ç\dX)F~šD•èlx²´ž¾Œê ©DcúÅö‚Êç1õó†ÊáØq*«Òá_L:`xÝ&ú™Ç¼v­‘„Q]Ö¼[ µmŒ?4úVI' \JÞÉÂB{ºáÞW°ÑÓ?+|<aI9Lö¨ÿÐJÃ~ýnB!–Qæ^i‰v_”ʳkl¤ÖÌ©ñä]Ý=»/Ó\ +ÌÉï¯PU‰¸; ŒÝçÜžt<DHѬÌÜ\ž“½x¿cÏI¸-›&¶ÐàMPÉçïf'CÖõWù¿—,‹¬öƒ¸Äf\,„µJ⢢nPû\ò-õ©Ç¤ÏeŽ†Ÿq†ÄÓ÷žTåhÕH\`ˆ‡†ÉYýÂ�0àîu\fúÎ9Ê(Êí,"¾ªu3¢—¯s=Ó2º[žYKÈ°°Ê:à9V¤²ª+?œêEõóLûW!'õà·¼ìéÒö¬»)¢9ž)Ow%a`Œmr¼ì¹„mxð?X8Y°± @Uŧ• CŽ½ãåíø¡Ù%ÇŽÂFV‚¤꥞;K 9ðԜͫvžó? È4“ôs+¦CweGKû<¦©Cb¿£ì°^aê;tŠ(NÓ¦»xê–‡?õb< ~’ŠsNºr€y¦,»÷ú¾X@²/Í”„7 Ÿè!ý _Ué Ã. ’wm8±2”y¼†Ù_H‡§ÕŠQò?µZ‚ ñ2þB.)Ë|/¸0¶WºKvPƒö-ˆ/€Õë³ékÌ ¡©rçÊóÂ6€%Ü"(BŸ7™„ú&6ŸA8¯.Ÿ ^=ئiÚç< ¶„Ù¥žœ™Qô5//Ð4c— þXêôkNté9Ⱥ‘øuíq(kéÊÉA#™)cÊ”¢ÌBYwøI‘¸rM\:“*—=e«Gl�ªíü÷@NÔ»Œ<û=ÝMË\QÝÖº;ÁÈRºÒt•iùÚ ˆî\ÃÚwˆNš!1~pÃŽ–<¼RSF;ÈùîÁ *ï×*;ô?‰êÐB±&¬¡šç¬òlÍÌ6cßâoÑ*0'O¤ÞLÇJz3TѸ3{ó£DnÁ¢øwUùí°êÒ´þ<׃ZÖ‰0ÝŒ*Ö,)HßÃr¿×2”È?!²8­¢,> â­}DÜXm:ü5µsù?CH'ÕJ½+†bbµkÍqmsÑ<Ïé0‹²B¾`°¿-_¬ I¹› Ë¥Ê.Fª'•²óõݹ`FÖÏê}G*õº38h‡~––×½¶s†æÄœÍHh´ÿzÆÐ3x/oàÊêI°²ñý«¯ï©ÉA£ï¡,{ºø0Þ¡¶l78SÒý¡øse.B{n‡‘»Wó¯~9'i06.%•àª÷cëáJßþyËÅåse…¤^ÇæŠ6ç0#µ|\v“Ë ª¨TðïOš ·ÙYMÅù¯÷íÖ"÷¡TªÃ4D\ßtŒÎÖl¯4ÈHn/к¡£{”ªµÈšÀ[¤Î¾"ḩud}|ö×ÿvžC6%"Íuõï^ ÿíƒæÙ¾©ÁÝœ<=©Õó—¼Ï"öŒ¾™¤6_0Œ< žÖü¦nÎý­,Öc´V”Uîæ0¹¹CC3ßöf-w‚ývQŸï…6®Y2V€û‰w¦Ê‰Ú.ž‡«çÉ»¡“ TQ„»£bñ¢÷£UŽªŒZ|†.¦NÝ“°W$íJ™›tf\¡÷/¢\r#ÿ3whrQ jJ$D‚§ØÑ¢™¾åâFÐeú¸ç™µRS)d9ÆNØ~Eõ…ê7Û˜ýa!º²NOš}”r¦ ݃D~u>þOH3kÛŽ{”²¶Ðâ ÝäÍD¹‰ÚÈÒWè<Oèß"í_l÷'Ð(ó{Út¢?ÖÔW8×DZˆW:Œªr¦fH‡åˆ•�þÍ­?ã­øï]à8sé�êy* ³ø¥JpÕšë/¨_¡Šý8L‚Lš½—[ᵕFƒHx„Aº×eƒQ6°¦b|ä‹—ñã÷s)Jf.ôYXG™ÚMƒ!Ã`ìüMÊÐœ$©¬ùÓYü1¦ñzUißZÈ7 Û̃Ðz6Áÿ óU@UöìágÇœ?«]¤¹z³Tt»œµÈ¯è©bTÌ.CÇÙãôßã<aDq\iÿ;T…ú4(ì„lð^S0ñ¾ùg>Ÿ(rjøþ›ê [B÷+•üFÁƒy„Ò£ïÖL´x:ó/xìý Ü¿ÎPÃcºÎÙ:Þ6qŽõ! kt› ~9êÝ{ÑÔ3ö’  ‚ žLÙu®rîù¨æ:];¢Y÷sýÈ̹‹£“q¬¼?ù]–æB)Ÿïá(WX÷ ü©æ³•è›Ñ†UcQ“šÎÖý¾îãƒ8In-T6S'=()l:¡pt³=ÜtéÊâ:C5Iƒêêó.ʹ«mòxíë¿Ç|×ÁXÃ*Ó^vr÷EAâ]ÏŤ0P#V»é¾ä¤°¯wÄUªÐ7gYæ<È–ÚS!ë•*óÑ KíÅ3^«ó©ãWJIÎþ0â¡]¸qwÜ6ºûâ ÝÐ÷éCË‚0“50I]ƒR:kï3�º‡/l#XŠ“tÅ÷;Ëͨ[HÙú»2ÒßR*BûÿȱÑ^árt¶} ¿w •€ü’Þb- €Ú ¬ÏxÕ¿‚ñ‹â<ó¼·!ØW#kïõà ¹èƒÅÖô¿£ªØÑÇç‚ òýF#øI2MWMh´Š ¯ýT žÍ§QUî7î^z.'+ÍÐ m«C¥Ç à»k‚bKÕ)SiJ�Q £€¶¿¼³õ]p—‚>õ†¹1„™÷€Ð¢è½Õ¼{ØP sßvžÖý€mÕjìbÆ’3Óå•”™¬UÈuôzüÇ OJ‡™ªíB7(ÞŸ-§68ÍX34بeFbRÆÒÏ3ºÈd&ù€×‡+dm)q¾|o=/;º=ðƒxéó,óûzQÐöEPͪ†R‘~ 껎w—$ãÀ;òâYw̵ä&Ð!¾'ã8gÉüL zàgW6ÍÚÁ²M‚èSu€ÈZjº…CmRp«Dn^¹yñ¯ š< ¦Ýê.³£*šå°¤ÏƒvÏ·WZÕ ,RÊÆ)†½ká¿×›±±uÎ/7N\敇E …·l)›Ü}š¡Ü;f(æã™ïCÍëÃo^x6× BØi‚Qäyï¤0èS•efj‘á4q:4Ím’å)Qˆ|Ý�ÍÞ|÷¯Ç¸dÍÕJªÊÅ>zÅšl¶ÀzèÃE+,öX ›AƒkÀݹ¢�‹ýVÃYýÁoý$¥2¾8TLé¬à•”Æ®T›tìEH#ÊèFJ÷idŸ9tèÎè¿®)I”y§|^·”¾„–‹ Ëæp^TBøX#ãÜÒnZwá‹r%:Ã](+-“ì$á浚[ÅNïd@2Og1-™Jjñâ|‚&¥Oú¥<Ü¿kô-%í÷úê=,R)¨Iøø³Eà på6F §qìÊ«€y½Ç3Þí!G©ð}„h«6E”'õ×òâhïñù°ÔGÉf¿_Ü6gbmÀ)ŠmkæbýÆEDúe«¾ H᱓D-dî K7œ<›³á°ëú{éø“ »§ik ”ÎF5ƒ"â„nàŠì v¹yqrd«”vüò™•ã@“Dü´NÐ2®ÕX‹ï/ 󺌚ÂæíØÜ?vÁ¥ú *!Ü Žþ:˜GÍÊÕ¨ÙäæíHϽâ4~pXæiã·{Jè泧:¹åáó‡íYIù÷æ¤Ï4âÌçÏ…{EßcûiF°ØhÀØ52®<£‚ãOo»¥ Ž­åR™î;zÁ1ż=ȇföd_°ôÊVÚYÐBw¿±ôˆ}‘'«pp—ö ¡f{^V A 5½-œs‘8pyÃÌOvv¯§®g6lçJ€$ºÑ7€Ïu1i¢~EA†tðo`J=t”8¨òýxY6Wd=ô®ò ìôÔ@;ŸÞuÜxí1^~=ü‹-sLÀ!À¤0ôÒs1çÁ’Hr¹’nÆ+£XÇÌ"ÆîcÇÒ4ó{p!-b,Ñ9=¥‘‚•‡Ã@±j3ö¨ë.mŒðTÚ¥úoÊ×-±9æN‹›«ÈèáY×î»HøØt„ÐÚ )ò„Ë])DÓÀÐ_ªâ?ëšCÃй± ÑM3Õúɳ{%´“¾`ç}òpuÍU¨ýLÖ0?<픙ߓ„Q°�ݾ<S Á§½ó°Ô1®J1˜m…ç‚Tí¦«êú‘a]ÇœÞ÷SitãýQÀS¼¤ñTÖ´Ÿežæþ±‘ —é>xT ¬õÕœÝ@„0¥|Ä”, ØÄZ8À¿î M/=­Ý©]¦¡/“iúÇùJ&†Q…²Ú8 ‚íù$·Œ-^š5—A Ÿ+Jò¬Ä0Ø/ÌÖþµzi®“!öDå®vRnÒ^XÍ~ImÈWV_Æ£Ðdßï=>&,øÍg†ñp’ý5ïýæ^$õPp¡Ø*¥A±\¼Èvøs5 êŽN<1@aÝ¥¬~ø† ŒU$â?AOc3‰™­ö¢o„%JPߨCçbü4MÆ÷°’Œ¢Ä9ò<g¾ÆLï5˜ÕD–’è¼B KSŸ.ê-Tí”-Ý0\gÿ7rÓGݦz>!ŠòÒ4RJCƒœ/iP½[T,­[3´«›¦“AÉ=_Їœ®4ô±‰°`ØçAÚŸ¼NR JãþZ¼!óþw8æ® ò~oýiJGšã 0P\”w»/(•_=v/tEj—ª¸[óbe™¾jryvæØŸó ü\< @+åÔGµ®À¹â>“ y·àE&ÏQdŠr$Á‰Šj6‘µ· tœd¾ ¥oÓRXÚ!/X³æ2/0ø°Ÿpba淴鮎_à˜·­ú¦Iðìåó |¹[‹¹é}Ì#ý¶ t¢ƒ9#ÔA¨¹5¾^´;Ñ©ûI+nž½Ú,ÇÏw O—-®#íÑìß‹s1Ù`Ôåe;S7ðˆ†ÅéÚ1,掮å%<)Ž­¾‡“µ»ã®ÕÔßТìZ´q/mK'Õî#`‡çqšû ^¨k9q= U©aØÇ €�ëi-°¾N¨`„Ú¢.+ONÉ•œÿ¾Eaüöý›2Œö¥kÒß‘þÓÍë·¦é‰vÁ¤¦§} áu9Ý]ns—˜å-•Ñ”æÌ]Í‚Rëak#Cäó©Úi¢·[:‡’ÜÀÕs@øgЕazÜð²›**DÏþDKf¿õ¼j÷b¸*9Õ«Ú,Žä™Úy©Œ¶îW©t%¡“Ü[1)N¸0ùE†ÂHFnò�œÿtéLº¦� |„…û!‹m/ÞWºÿIô¾ oÚŽ›mRP!Ùz;t›–NgÊFãÚ {ÚÜmý¶¹HÚ©D½÷+lf¿V”Qªò9¸¿ü›©nz�X,Ø÷‹ïC�o¬”s+f�8¬={d*ÊAé¤SÙûMÝ[ñŸûãJœ‹Ìåÿtàî%œé FmË6ëáì1¯-¦–?+hx°éOˆ“¿«,eŒq¯3óú\$ñDÛaç’Ó³ÀÊ°t<®…Ø®úîÕ÷A¶Ò‘ ¿°Ù¦§ê®lÀ†ûÕ`Ø9�'‡/BT‘¯®!ç¢+}ç<øXh‹‡õì€Ä�ʬÄÐþNóxôÿås³c¾®NÝžcZÖfŸRÑá�úÂú6‚µrÚ\T ö7/k{¦²°ð3 µì¨yõ8˜(Œ¼‚ýÈ œ³Ð±©É½ŸðÁ«aÙ"tÜÏN k¬?x nØpY¨îòÇuZ¢Çd‹Í–Nú¤ë9~÷Z ÛÀt–žÖ£W%ƒ)ZÕ¹J ÑÇ>8>ÓßHQT¹Ëjd›‘Ö¥µó,1::Íû}’;-“|e)Eá¬?ÇAyî=»¡m>Çngõoî@ýbo¤! ¡ÙZaÇÍ•Ž)Ê¢‚OÔY´È1Óî4-ŠÐ¿»¬š‡AÒî=ùŸ-K?À4ûyóXÆ Vȹ Ú+0M³6p8S±>—Š�õ‡5‚hÛNg«7?]®S§œ·o<_‡íãCgÒ’I½·‘—= &g¸ÔwË2³Ÿ¦)hÒNA¨R@Iè 'ptJª q.ºèiΞSÓ}¡⺻‰·Àî"[©ì%ÂJ·³“Á-)Â5ï3Ä¡ŸDáÏ–×ÈYÈùGy^l/ëU7“çyDü®Rœ(¶MS¨Ä<8LÆ+êp7Jq™“V·° êj[2{SqÎé¯=VbKâðÆ´, ŠE{Áª/ƒÑN‘õ[Ì]¬Ð‚Å@HÄïvÀV4†|$ÝÅ×l­”A,$š&¡¸­hATiLøédôѼ4¶£ŸÌض°�ÿ©ñøi=sÆ2çÍ{Êûeæ#‡¡ÞËÝÐIk&�Ù­Ï´A-ôþµnhäÐ1¼ BRaÓzZ §ú$æ<fûÜ•’z¦*e'™¹Š³ pï5»æ Ê„¯7#­À†–‚vJWÿé+üOÍ+"k&«Æh°VÑ3ŒX¶¬[$늲:<û(DâÓ;;ÆÖduãPÌH è²¢¤é<<±'Ë7“àÃE£Üê(uÞTiA8Ïf:¬5ŠšÐLˆÿßO#b�Â#GΘ¯‡|êÓÁº}¿@| ­Ã¥ÑPÇ7³~_[º †1FµB×é‹Üú>œæ‚ý¦B퉙Àž¦"H%eâ`8ô»é „0à£Òl^o¡^%ŠqvÐî¡ ×:O;-¶ 9õîÈóv�š¨±F(.ÅiÈÎ×æI–Þ¬×Åå T ñ¨ÿF\dþÝSºe¶½‘éŽ èð‰Ôœ|q[EͼÛ.BÜvùu†¾i „û[Ziß[碜K|)î•ÿZó#ó¬Ùç4‚aÞy fÑÀ2íú™ŸÙÁIâØ˵Äd¢ ¢4ãlª›RZÈK©¥ðÛûÞ(žZÀµ_-—’Üóo-kù×ÉA³†ŠB‹©Ãf›êHT¹}õ»RJ7›ÒŽâ½Ñ½ʧÓߤ§]Ü;œ÷£Á<¿zïcn ‰ç.[E¿wà:D .:Žé™} g±Ñ ã‹qÄÎAÓŽ4|@D(¶'©DÄA& bµ³3[+·>p­|æ¸ì¤Uµ'›+Ȩ™+_5!ý•}–ul, ¢«‡mî§í¸²é)´ðysÌ>zu=Ëd•¡™êº´>œ€³P ç@mvüPW[ckËJu5œ_¯3¥þsPLÿ ì<ànïÔáÊ0mgtáºÎêÌÖªÿÆ5µö;o»pÑ–KJ§§Ä~ÝMAA¼·”,ð_Æ‘VŒª8ýž”f¾ŠmT*J(¡zï݈AµÈÀÊÑõ€͵»W‘@‘,βwÂdØunqAзS×ÚÖTSîÄs½ œp@1物Zd?mÍe€‰Ã¿N®‚§Ö³¨—³ÑLycè6¥L+˜V Š¥TPÛçe)a_2á¾8„rågšöXemIÌ©ÁiH¥ä†^#`éÄÀhk´e/Æù·»íœnæF ÂY°‰÷#•Ì‘Ö?y²^¥q'ç*3´zm�™f¿Ñˆ~­¾´Ë* Â{*ù´v)jøãT\YÄÉñiÆ“¿²o×yR%Q™¥K¸à5éŽå•ù"žÜ‰(™Tžž­½B/tÃ-ˆèØ(|©5<‚Ž¨xwr@–å<oÔƒ’½Ý¼B‹Ø©&bOŽ‡¹»8RñR0)r[÷{q‡)iQØè´Â_Eaï{LTgï;ª˜�?;‡ÞiúXa<A¦ÓÁÓg°kRÄ=ôžúŽíÃNl¤'½:Ú‹ ›ï_~ï&¡§|ÎP¡fþF[{ÂÏLȳ£‚±ïVÿÒVq'°¤š}G÷"¾<9˜#¤É­lŒPÑñ´F±(zýŸo*U<Ç{ÌèqÕ K4ÓÙÙë~›ëþÀ8ùSÀ #³C2‡rÖ½+¯*[·2ènÃùC[÷pØ¥˜#mhVÿâ^ÇE鬟¸ |x9»Õ,õÑÈáð¥7ò,xŠÝ¢ÛÓY°¿ÕÌšT½ñ!ÐI ø0ƒ:VÈýì?üû{¿â…榱¯ôh¼d–™UÜv¶YJ9WK™–üÊÐHãKÇ€Â_ÿûÂcR O‚gOù©°k€ŠQ0²…¯Ùp¯m®o2›˜ìÁüîüÎΫ½Ø\Šµ0ŒÆºÁóQ¥ 5§y+îdÂzñ]´:v <¸RxÂɾåÂŒ;gÛñk‡‘©êê¾Âv£ƒÔ`RO#£“Š†$®²‹á(Il¦„ ¨ýK®W3Ïfª¾cÖ}¤éq&ÖžDdIÿ{ñ}ý o«ªh¬Â XƒTAÞük<ô¹>:¡a.—Ñû³tP´ç›ôkùºÇÞ2 ‰G«— n³-(p_M±é´ “‡ù |h3x<LeÕÅ—ç`ÅZO",´’“³- YcxÞk‡£¤D‘ë 2øü¼ýe–­túª­Nú,7}NœÑfé ”?)K7B9±À!¥okÄåXÔÓð6^z»ÿrj%fŒföÑ´¬kÝzA·ì{]êüãÉ¥¹Ïp‚Â%8×ekÑø ƒ€ê™x/}ǺS?^ú0k™u¤ôQh#¶*ûalÍ?ulÐð8ÌX]Ï»öÒq\újZô~,KÕi—ú‡ùÍØýuUª,Ë<¬#|e*ï.*Bb¤ú=WÇÉ9ÖÓG·Øy!šþ‚ê=uV@21§®þX«8ÍT©ÿ2Šç”O}^½3ÌÒßïB×Í7 Ÿù\Ü¢¸KƒSc‡¿lÚ»Å�4~4Tü•Ë_\®êèÔIZÁzVex¬pF«-·Ó8Ó¢+ æÿEòÏ~±¸†7iÇLsù¤,PÆš®óýà¯òF¤ Wïg:õ;Ed�ÎÙ£v[–ûì׃8\¹ðÁA² ªýäÕ)ÒÓÔ†ÖÏûÛš³ª¦ð\„íš1�Ç“!Ïëçdh4Þð"é¡ÿÓ©;Ò û0-§õO€D«ÎgÔñ# òÝ—ë,vÃaw¬Í²{³k2†Æt8‡žþäå>¡¸•±IÝ*£åȲž,¯pÚy3ÛüèÅg^ÞÐ8€_ Eô\¦ú*³<[É$”åª7}gü!Д9Lõ9p]:\¹Kßdžê (GûÁ,V&³Dz:˜)Ê7ê~—á±  oãw§Ÿå>IÞ�膖lѺ‘ƒÙ)Ýq(ëi×ø» üÛ·ºòÁ¯Qn¶~Á^<øÒX4$¡Wˆ�P9žÛ»¥Iè{{Óî9¥·ZP©©MšÚ:�$2ñ™ç®¼î^ôŸh­„ xãŸ<¨lÄ(Ð-0Ü´‡ý~œ<c~úÓÍè»òe¥ØlRvž4Öä©ÖÝ ³\@Kb¦È¼~,« •¥N¼ƒÅM ^¶ªnÆ^¤²T×.¤CÝ=áe6¨UÌ¿èÄ8_íü«¶G“Sàñ ?TO˜'ÜŒ+ ÷:ë@¬Þ×;4 ÕÇ·»65öm"6eaU%'Nª­ÿŠêY†«@P:«l6yÁÚ´Ž„O¬/n¬Ñ×÷ãC̃˜KQÅ8vów_F0Ò­ ´ôzˆûÆJ{‰r¨¯eò[Öˆm97Ê“i¯ÆóI³Œ„h+Q\¶Åãf·Ë'³\=Ïk‚1æÚ‹k•óÒ�SFE¥0Ë âóÅC“°h–ô.ì'Åä nŸ©‡?bT $hÓAAP[Æ‘ÁÁXµRCNñ²´hêßIÒRtúl¤€Ø·çöžÒê¾î·o5%ô´{Gó‚û*Ú;·øƒ“ZëíŒÛèmdÅ:¢R{„ýÀÊ¿Oü¦¬E“q󥃾«‚rétòÉø‡5Íw|Ÿ0Ýž‰;¡Ðˆ`N:}RZŒq2¬ãvBý¸%d“)“‚¢=B¬T)¥ÊF2ró^øZÜù JzÇÖ"þŒœæadÞw³°µO(\ÞÞÇý`‘wÁý1×=œR¹:…aiyEu§õ¶tmkv†w©›ÄÈ †ðûÖ¯âÌsr/0ˆÄ ¢ó4^¦ÃÉQ†„¤÷OßýŠñ‚¾ÔžRú§]Qø¬T–Š¥}Rï<쬰ØÄa¨÷F·¦í$)ÛÒ7€eï22Gôˆ’6c$ƒ¢JXšfõîó¡í¶kÍÞ£í#)X"<þ;¯Z‰T1œ�Ëì7D­å€&àŒÁp'®œë×·ÕW5Jà±.ê^=éhÛ‰ì…'í@÷ý™ïá7’¨q™ùV¨@cŒe}ãã¢%ðÉጌN3²g_!)=<–mì¾4ê”ÃUŽ‘eÒï°Ô-á&`ßO–¯²îðÇ%ænÖ7 €È1 ªZ×aa;yÉf:nq#«ïO2JrŸkElõ +%o ïõ™v‹ ÕÖÊíW®oQîuK´fZl¤èÝn¤$¶†H8Í÷ØÁˆ„«‘Û+Ü~z&>¬ Â8‡êS;( oÒÙ$lf0ö�èp‹˜RR_alt–!bk½]Ï{9øV2å:-›×LãÅò+½ëŽ·™¨¢€C‰Ì¢­Fá‚Ð_[JDiì–ªôÅaV5(N0-®¤|¥¯Š*“eï$ëb…… ª±)æ† æ›ëjÖâmj1úz­“&ê%ÃJ[ ”îtÞÑÇÜNîÁÓaœ ÿ(©ñy#jožNâ7‡Ø¬¡Ÿó 95ž×eGyÚsž÷ÐóžÆŠØÉâš3ª‘hÒytÓÕçþÐ]%®6ûr¹š!‚í„{—+Y\™‡jªŒ¬à§NH!ô7ŸuB¦Ò6¯HùzŽ3ŒLcšª<ЉØb%Gª$Ù?…Xѳ¶!M3æ›6éÏjÖQ^øÄ ¥"þ´tÓéMÎÁ°úUÆ€kOËs][ˆZ"}‰¾[æ{ø_OP5f£¡ ¹mû„Á¹ŒB¹Þ{ûG&©s8eʸ\Ah­]Sî)Öí¸±”IÀ2é>?alDIæËÄ@@‚há ŒÉ W9qZ´¼Ø$F²9w¥Élä‰ö1µ¯ÙòþÝ}ÞzSo &.“-ž¹ÿsþÙžEð•ßlÎ`µÅSæ«‚4f•—ªÞ›§7ëSÈ5L†EnðŒÐ*_‘­ syÐÌÐ$Üï=ý-JS>ºƒë+*šR_õ0}ô³ªâË3çbˆ¹o¥«B3æõ>s1ñígú[*šMÈàsê$(¬?YŠÑ̓µ$P âæån[Øv^û'JºÞ83BRÃHu´Í\¡îÃÞ+7Ñ)ÍÍœ+f†yÀ2cÚwRiZ„3H}é\ÙL/—épäM*¯o¦`ú"[T7UБ)¶‹‡¢rådÙŸÿ›•„ët Z–)´Dk¦çæB›ùCìî?SKÂ5Ú ð«²#êB´õ–ñd)Õ¹Ö}¢¹^D~dƒî#D¬.íˆj;�8þ5h.~<ÊI¶y½ñi\Å€ ù#ô�®Wb]SÖ§ª5øÜ¿pèC?ÒüÎ/Ƭe´­ºÏ%±ÖïÐŒ�ñ·†Ç°>žµ:Y ÞRBåA¹?{3cƒèüËJÄ)¨ŒCOycecX„Nœ1`þÙ‹Œ˜™ý±ÂÎeðZ´÷€×±º&F»|ƒ 0m?=#m[áÛ~U_o >ññæÇo€ºÈO‹€6¢Ï Uå«ÂÅ1R¯‡aT­¼×qº•gËw³§u9ØZ„%¡èã)ÅÈyþÍ7ÇSð™âÿ‰Çl‹TDt>ŠVtjžÍUt´ÑjÑ.&­†ã¹çºGGFfèÍôJÂÄî‚ê ä!¦€dem¡‰óÛ]< àæ¹HoáOû:cSF]ºÜÖ=N‡a ïn^½m¶¢Ñvnš"¨¶{O¤à ?�ñ©êH››Å�t|¼X-}h…¼¾+˜å[«a#šmNàYD_Ö q"ÿ†7Ë ‡SåÔ½IÀðµÚ º\ Âû/Í’Sã„¢ˆu¶äÙ“óê“`ØøŽ³¿Y)ÚúR¯nCvZ9^5j ƒÌÕ`åz; X*žuRö0z´¹çIo±jFlJ źš>¾¥TÄÌ ëgÛº„) W6öBÇ2]ùötK ?òéY: ÛržßÚCmÅg{g*§'!x[ð.“e21ˆÛãѳXyñ™k7¯(€yù©ëV——ƒ§«·ÎþÚ«K¸hÊÀúµ.èŽôÚÁ»T£‘*�²|žó—§èçóë¬ÌVÍÅ3˜âdÓMI u²"ƒ³¿¼‘ë¾d º§d±êk½wûÖNûsûzg”æaz¸6ô4‡/¯­kó&‹Lx Ž"7jEÓ»„ .¦ÇŸK{Øv eµÿU;¤ V`$Å[Tze÷lFãdEt‚OÎ&¾òpZÞ¾¯Ï¦ãùÆ…§z|Ð85ŠÆ7O@SNã¸ÙªYxÃÕ‚/x>YLDÅŠõ$ò#|÷)‘÷þŸHÐ嬇ëyoŽÐ;¿zÑŽmÚ­ºg[FÉé™ „á²ÆE¼rkOƒùDq5ÿÚ© 'aZØ™Æ'bËÛéÐÑz¦ÏÌ" \¿Ëбé„øB{$yo<L ø°e"&•ÂÄfž{QašÆ+%ü{©LètȈ+Ä£ÞkÜü$,¨à+ñïGTz•©†H•«·ª:–Óg¢ê¡ç†ã¯¶}^ÍL6=ë(Ò¶?ðV0êˆvaF,œð¼ÿ ÝYÎ]aêÎ¥†‰îÞ ÕbCû²j X‰qep×O±Ù©q“l(§*®*bŠn>¨/m™™rÛãu¿˜�d+Ê ºôqTµVâ ÈdGÊÿ[ºaæý®Ö5Ž™×õq¶Q¥Z§¢ô¾-,ŠýÎS”ÛìÑgð%©1ØœOPE¸[C‡ äÞ2†¨±µžF‰‰QÖÁBmÿNµÈ–" qst‘ãÉÚ´ÑBø£…"‡¿´×ÓÃ|'¾Õ:§ŽÊþeöÈ ¦ÉmÖNw½‘X´óéy ð:EÍyBõ<Y°§«p¨vMξ ˆ!G…Ææ òê_*uH5nècÏK¤ï½‡ñ�Ê–éI…¿¶ÌûÅžÁUdš33Ïj¯ªçˆêÙhl¿í—Ò +—™  Z¿®‡Š›Õ ë ¡µ£ä´ãªzÁ7?óf—¿çÄ¡ãØ <eV»¥##¯Õª ¥(=Í 6žò=~ÔÁ)ŠÌ#¡ÑÒíØij+ßÚk17µ·\TÝSŽûÁÀÀæF³²ïDÙ•à] ñ:HË^ufØ'ùº©QùA´«Ñ6öLØR@Âïv+Û¦£¿^ VPq­ájÀ ­ëké§V8û˜w£HÒs Í™G"žñÌ5¼Ã!¬rþ2¹~jGÙé»kù&bq"@‘¸¦Ò¶_Ù y$Cæ°T¢v"v꺳¤NúP˜9ÿF*1ŠÜÌB¼ŒçŽöBÚé 1{ûç­#Bvó]YÐ'®¨’Tf™Ðdþœ,¥Tr»B|Šð`ý+ DÚ‰ç¶ßÔú¢ÿ±»GL÷lfØ{tž¾ï~d3r' Ãx¿h`gÑÊ; fJó‹ýÉ×fe8ŠL¸áb¤høEÞå7VFé:‘lä)>xý»¢„˜F¾b¨¿â…g¾ì?T&©ln—¦Z +¸Éðž_Ùþiìæ—)«Ö.-ÊUD¹ÃžÿÖ¦2ñwMÌáóAq'H¯ •ÓÎãôU‚°M„¼Œ(µ.ïâq‘]JIŠ÷¹Ñ]¤SRáIðýÚÐÚÊKš–IÓ—Aú¹3À'î]c]oG«þÆT™ñ ÿÜAÔ¼:2»ˆ¢LDWOÅ’ÙÂù b%½ËÇÑ&*R•A\¬‚#Oñà#‰(E¦ÊålªÙVˆðÞÇ\�RB öîW(²õ1àýÐAÛ A °lÀªY´m½cÏ…Þšw3ÆØw¨|+$$U…í@Çx5\¬1 l5‹‚®ÉÜ\í«GBXm«G¿_›Ø0ƒyIåþÝcœÃ©KÕ~æ$¥¾°{Ä«c­–]¯?=$’î‚B8Osßµ7ºV÷…úã¸\ù¨¡a—¥sÊeó»Ù"8@ˆ¹ﵤ ‘¸Öô”îÆe p»3ü¶Ò—@4RÙ­ eƒÚ_éï·Äj\‰__I§2*oP¤z@qþ²«ïøþ.kgéäQa9—?ôáêÎ× ›t ØbÉh¥þ¿å™ïéH¹Òñó“vðÜôíÏÚ$6ñc õS½ƒ¤Æ·ŸŸ³)_V/Agíc¡û^õƒ¹ï˺Ҵÿï[™ØÆýh|íÍ×¼tZ‘¹«®?j•æ„ ½,*’º;/‚Äá£`MÌDUU÷rôš±.nÚM*ø-3ŒÕó/R¬z3Cúòsï™PЀ¿�—ð«`¶Ù‹¢?¥§pȱfàvg@°À˜!ßèúÃßë–W©�wK3g&*gÂ}mþ-]µ1ÓÇßúWßý&mó7´âVôÈ÷W/ëßÒÇþÒbû4sãF_Ýi³@ÀÝ ðî+ ýnr�÷·”…1øïý³•°MÂÀàìÝB{¬fý%Y’†ˆsì9©­}·RºU½ñ»ÎL3‹Ë–‹~ð`%º~Y;¹›¼vú¤µŠ°Ñúªx6ó†Ôök4‹ÕG÷èZÌÛ:Á%¸Ð\™',DãR#%œ[œÓÙ­þ<á0ÿ>N~â"òý¡aõ£äÓtéWâS3Òyú&¦,Ó¶{;ža\Çf´&Ñ·N*™ë©ëaî©pøTÑ•JK û,ž8÷ÜQ¸û‚®Æªª‚LhpÖ;ÁÛôÆÉ)»ö‡¹¿{a6Q•gžÂÅ-æûÆgÍ£ „“ºo/íQ½Lðèàv3Bö롧kÑMU„ÉFرîJå{W&»ÐF7û¶(ªAe[€¸åÉ/@×î¤æÕ„Û@ȯZ*»Œé[G¹ÛKüÀ2«T©ï¯ð"Ë,-2ŸóžÇ‘ÂÞP×xÊënËkò¹…‡#`uÚòxå¬è8è6ß-çøýž¼ø»o ‹2Påƒá®§6»…³ FŒ7—Ì{ï÷«±¤Öˆ÷ºÚîq¬2O ¬FŒçßUHÅC({” ­b°í­qÈQQhëß· /‹T&Ñ&Í Ó{21Pô a¥ óßòÌ, 5ˆ›^óî 3_ ¶š8ð²? ý‰‚“Uj|Å€×=­˜;—19e,'æü[^ínØîkhôæÒÝnëy1of ùå$ìÁ)Ê#ק]=!T?Ý•‰ÃpyÓ¤AÒ D+V6€4k“sïÊÙWø>@˜ M”÷|êíÈ#k£méÊMÑÛñÞ‘¤+åuª€Æ/4_N耂3¬ Tè€õž¹yˆÆýY(| ù «uóªp‰KÄŒ¨¶£Òëýìà™¾fÆÁðvÜE7u(¼¯Xü¥+°³iS çÞšnGÞ*O0WÁ&z+<X::Ža5Hmüçæß; Þ1m aªêAÚ¾{6– dŠ‘'lƒ$/2—B€@^uÚÙh‹¾öf?ŽFå«î7£ˆo¡;aú†îÒ¶Þ®ž´òè”3Ö„[õÁr –H²›ÆX¬ rgå†ûÂp(ãÌK&Œ1nÕ[cÜRx®ër¨¾Õ¯¼q£Ðé¡þhÁ\/œ¬ »3Š•£e ¿"–‘†¢W-ŽùHË°Ó±[‡¼¢–“ú¿o™õ(G[Å‚Ü~O9‡uî cV8QÉ=¿{§±¿€ÕeÞ‘Ž3ŽÀ÷üN¤´ö>2eDA¼Û©Mp¦ ¹ô0:Úž[<ÂõË7SVÀiÌñŽ?íl:;¾T6æLkø˜Æ¥Ö‘öÏ—¸Nço×J:þ·ªøŒÎ‹éc(º†I{æß¾•yèqÇEÃò\ét1ýêóp€êÝÂ#¥×É•Åç%¥Ïÿþ[ÿJ÷8’Θ«`X,¥[ßílk¬9 Òò©éþÍVšÙáêªÂûäÀì„0âž PåeÎj‘–'ƯŽ–Ù,¹ù‹ã­ÈGë²Üåe!õëS³ÅPÞÚ¨™u&P]®´ Ø»þ›BŽ§&{ƒÞu»³ ÝŽe|77ü# 2@C]j¢ñÜÏÂ.Ó‹Gx‚cÐõö‹`8Á¢Îo…Aâär…?ñ¬?—ìû…*¥ºì«ïÍ(t“sÒ*H•O%A‘¹†ÅòØs0Q»&ñ&ƒ{$FɧÉ$ctvýX%èÕ4c3xs-·½ìû�­Èo.8½,‚ýíÖÞwìãà¥ÊÛuØÖ_O…·Ks$éc_…é}Äl:ªìt-hMï7씾ܳWk¼*`±‡Ùƒ¿m‘Åb°¶çžûDjÖ¤¯kŸ¦Êõ*D?âpª‚¸ÞúTIæÐI–©›„ú¤Í²J,Xú´ ò“6lhaѧx;ÓÀúP~PÛÛ©fÏ=Zv”…Ù× G�f;5Þ‚É»‚À+„ï‘[çj[÷Ã.ŒÚ¯)'í¾†RÜ4x=·m'§�é´Åé@¤¿ø Gÿ̼é%jô”q…é*ñ¸t †-4mdûOoÜßž@ÃNuóoµr‹æDJ¥‰JãÕâ;`Þ#¡ä´»áðµ¢ÒdœÂ[Wï<š}‚m¿f{~|†¹ÌçRµÐ¡qú×U¢8DÑl”•Ÿ8wçQ&&fëdÖ—Î÷*$LÏ»¢wóáT›Ìôs½V á®*Âylþ /4·®9/½¶C¦ó®¹®þ¥3öêø´™UB©Òz(Óvp°’Qx¡ƒ¬å±Ê¢H /#_%ç-­¬ žVg'ã.-Ìö7aˆjnñbA¥©‡³ö.0ùnÒ¸]¢J;Sqé’I?Äk W �< ØpØ Ä(Œr溦œÓP{RŒ?¥-ÖžTrø_Œ¨›ëÞhmº ̉ùÞ3Ÿ4·¯+¼×#feÜeKeèyï”; Ô<€ä5È“ë=,%;©ö/S=Aó‚>kä¶(í]1檮Ÿ®Ù´g• ÓD÷§Ý§Âw›=8µÏQ¤-ìwf‘óÖÐÖp÷t¼«µ†EŽ¥õµEž¥rØv½;WXy“ÌF••.U¹cKiW\zÏ@¨šíš-yWîJ(c׃Zòþo½ÑŒ\ä´‚Sß‹Å7GãÃ`’×y/ ?X0„¾Ý:ü][´ÅûΣ±;´ƒcúSÖÄÊ÷zñ$hÞ±ËyÎt̃¬®½|R[Vvch/˾v†¦u'ÙKVþ±´=ºM\i­ì–ØŠŠnÆËÉÉÉ­ƒÇaÖIôãÚL¬Ê)|€¶ê€¹{nùЬ!Œw…‘).eqœ­lÛkï{oGp%6r¢ŒØ€l¯”´}ÿ:Ü·®•ákåf¾–î›éŠÎâåŠffTÖh9L…º´ÇþÊýû’ žj¨!ÆÈ¥µyŒŒ‡”‡7û_`Œyª 1´/JÙáñ®6ÑòÄèj󠼦f¹ŸG>×mÿlûGy™yVð`o¢ùì Y€í_?PÆê»Ëa¾Ûɨ†„ªí`Õñ5; Ïh¸û™aá&–ÂÎþvuЦi\ØèŒ4dto¬‘ ÕЙ'y7!:‚’?o¡Dz^ª :=7@:[Þdt’ßXQô· ÎÔ“6cvçLŸ3^l9�rg}YTM“cnF½¦Á§ßFÓðDÞQî„mè\êc-î­—ñCÓO¯|%¦Ò4§7{¨–Û~)¸»P'7Lf*÷Ù >kaÕÃHÌm¨ä¯¢5 Ç± xÕ( 3CJ¨LqÞ4´Š‹­:U•F6:³ Žx*óœç¿'ï),ÙíÉÓúš!F‡ñ>JYÉ¿$ËBDÓ‡PQØÏè™Õ¾Æ7vŠ™iœè Píöƒ0F¶Âï™Ú+í”®¿Ý|<°£˜Å¹HÖLW3ßÖzì…îHZÄiæèS9·»ÓæËÜÄûaœ?ØfMñ/Ï{ÝEì;(®Ã¦9ƒuPdq:fe”Yè2<ÇWõö’0 ×ûg>ž<XXà\Z›ÊúFþžnÑvé.ä_Q¢›¹´ëP©ì|5¡½šò¸ 2F½™ù—Þ†#{úyÏMžÓx¹Îæ_Ï:FœMöj¿§âUQä¶ôÇßáÂG‘¥Ùè<ÑaïŠWô©¡$×ÁÍútÃi„’º°?'ûƒeÇOg¹�Šï¬=ŸY—1¼¿œè–œ',IOâVhþ‰â<ÿ‰µÙ¥Mƒr¿7½TUB”áÄ[ðäoj;rbyNO±IDOøãgmÞƒû€Ÿ9PÚñÂrY¢ë|ûã«zÈYúÅFh¦³•€Ì�àɬT;}øål"wgŒXÂ6ô £FÉñQXIS•ÍZþÝœå¯éÔX?ŽÈ@U7Gú'a?d?#óëý°•ðæ÷^YÂó~<áÆÑ"6½{¿ãÑÎú ~ó.C_ô˜Œ®H¸¦}ËÕ±á<öÈÞ¢Kû’qœ”¾Œ2 „<ò¹tž6…‰ÑCfÙ>óS _ÍgaŸ—Ñ·kHcÖ´ëÍOZS¡üìoÁ’@Ѻ»l>?{3Žã¡V®­´§> IÄ»úZâ ŸužéŸÊr34¿¹ÝÎŽŽâÁIŸ\NÉß©=Ç&/‹ôkô=ד“èafs$(þîF4 ¾xõÞ¼E*«î iò–ÎÁ}çÂOõÎ cî¢ï®® ù¾Ü°õÚædºÖⵤÝ;ÚpV”ÞÝ0ãæ.ó÷˜˜d+U ×+úˋάËïÒ‡‹T/³hÌ AóëUìZC/`~×[¹Fhy‚r¾óë'cƒJߥý?¾ »$–G r” íuíž©nTøÔ ÿÒbfÚ’’ÕØ1óÕjè>\G*ªÏw§(»«O®·?T97Ð’9Û+=U9. �ææLËl²ÖÚÌý$ò ¥ï‚J¹tâ–q᧊e 'SƒXC¸Íùø6˯qQæQÞ4Ãò‹V±oÄ3>»¶x¿¦Â˜f¾—8}*)ÂM½#ía¨v„ ŒsVÆ¡y:˜ù!ŸöpR\vêáà7âb.o™·NöÉ;P{½L:yxÔí½6î…•­jŽhlQÞƒ€]»…GË”îÁþ`S{Jæ¬Ûלv¬ŒWbrž|î4Öå¢5gxTõ²Ù›´ùç™·•±“iZF ‚d™0jgPwTæyšÆKfýâÆ%ÞÌÕþæBOÖ Š;÷=¬Á€mƒÑŸºt?M,L¥ý0!‰mÜã°yï¶Ûnrä¡'’"^ë¤Â©­ ª½=ÍcÖë¼km wP�àÐvcͶ6 a(ÓÈœ:`Ž!"…ÞîdK¿B‹¼˜ÇTMZW”Ôª }á)*™PŒþñD4Ûó0sT`_æ¿ÙJq±ìPµu¡JbÑÑ:"ä0p„aœ~€æžIý|Ǿ×:“¹'Ž$Í”ù§%?ÛÂK}]•¼ùP£Lý¬Ÿ*ø¦¥g\XJ̦™i.9­V!›¾ÐwŽK‡0°ƒ‘>gí¡:)»iÛC^zY HÚFNïÒ†ÎÒ£e”ˆ g‡'U2g%øÕ Yæ-·¥xýû.g’­¼˜)jŸz ?í§IóiûH¶{jŸ ÀˆÃûwú¹NI¢j“–Añ©Ûr–˜4LPE 3¼7IÏü߬ʗ'&é+|!˜ð¼Rëd–ƒ„^ïê5c“1ÇógkÃ88ì0“û×^Æ¡-fø ²4úòdô`Í×rs_1hÇvâW².Ùâä° <š’üúñÙ[€…ª©},ô~½…CM^;ÿ}«Lû†ÎM$i²ÿÖÞïqýú/¿· ýHÇŠœó\Ñ^Ç ¸ñ I@Îÿß·(zûç ÔfPÔº‹nµfV«^е´ì«ÊRôuÆ&<‰çô/ý-æâSÍù ¥”p I½ÖnâÚ—®pº‡ÂL¸ ´Ò­ Yƪoü‰@Ð](‚ô° A™öäÞr=jÉc¿š¢ÅJl¯¦8ÕmqÐÀÓÚÌšŸûée±Ö !‹éî]1DTU8žNåA½ô‡“URË iÅ÷%^º»Î6^ËÒÏï¶#æ¦ÎP¤ÇžFúgZ4˜ÞêØá )ª>Ô»@QG½çªPÝÇžËK’åk½TÃz{‡ÿ+[q»PÃYÛÑÛ†»/ÏPtlšÃ 1¦éú}P©òuî¿B‡~E ƒÄ˜‚‹?˜¦äónͼ^Óïµ}ÝÌ×ÎWú3×=ú'Ë 6r?) óî%×µHU1ñRÅÎ,x^—ƒ"_8` uaz�E‚ÑnСþ¿w¿vÚö¹PmPÎ;Ó5Š•{Ùß p”ŠµL0 Ndg؉ӗêÄpëÒ¹@b5…ÕåsPôˆ‚HŽƒywNÒ Ûê°³d¶õ颾[ړܱ„ݳ2{ß>ÃGjä¡|ŠÙb2 ’wÉMÉûÂÍVÍfç=í}YwÌÄRú_(J*?qf F”KíÐ>Ú•JêJ5Éa{w?„óbu†�£M[<«-<$h,* Öü„©Á‚0øOsý‡~!Ëæi»ÀÚR;Ìh—­û*¦õÈODºaõÑÔêš|?ouÆygÎ&ÌÐõÀÔ`ñšê!…T¸Â¾êî;üÅV²¦…ÂêÔ”[â�?hx¢êC>ƒ³Ìµ »z ÐóµùÑ^¶tŠÎªe³jÚ2½UFŠËËò¬åUª¹¦érY¾SkåÄ>13È””Pþ wë¥'áÃãùƒv‘a Æ "´ºiò`ºÌà¦{Ww!¦VCSjC˜:Ò‘¹Õº±”þ›‡ía­§þÆÑñ±WPU+­·,è!ÍgF<1—Þ̾äBÖtÖœþíÇ0^Ø~``²tEȤJ³¥myöÍ 6�£\د­5ðîπ߷÷ÇŒü(V,Y6* ²öä{s(xÜ(ÔÝ%>4§K} ô“÷EŸ7ŒÁ0>aÜ5žëÍ$š: `’Gh‹ ÒË”§¾š+UâËŒe¨¢YP^ÙÔôDißX CíÙôT™ó^9Ú¶ïæFBʳŸ°›âVGü¸ÛyæM´ûë°Ñ!÷Ï¡>ª¼¡Fl(yÙ–ã+:°7¼â@øRhÕËKÓAm»dÐÎ[ùM7 P¯27 ÏðêHæñƒí;Ò_ -‹aT¾ÐÍ÷Z{h`q¡ô³ÖE顈5vz@ç¡oJE®ŽÌ­â“˜¿îÝQñý7û;ú®½ŸømŠð›&Ž8ÂÇ–úFUχiì°R“Ç•Þ ãê;ËöšüEÇü„Go{ÍÌeTþ•ÂF+dàSKõêå~y¦±'0€‚$Ø\² ´ÚŠLŸ‹Ì=„šÇvlÛÙ¯óeR7ÔÃÂó‡faf¾¬cJ»…‹°Û:h¨˜÷2døÔ-Òë±›ýÁ¹T®ÈeÎxÊóŽ‚a¼x˜Sz˜íJ½±Ù¾÷ÓCÒ¬Ì µáà {÷õˆô>¦º•:Ž-ó¸ÄòΦæˆñwO™ÜwÕ€°îά+V‹Ñç…ª…í4;óÑáäKDaéw)a÷2Qllµ•ƒ@ÕÖøw«ÔPWsU /]m‘9V .rÍÖUf¡«¤œßš`Œz&Ý}Ñ¥ªså g£Þû» k”Å=[ÊÖD²_³þ¿%{GEêÈÞ(7iE’¿kÔ¾@p�·ñ X 6ç…w®ßm6î6‡‰ ³Ö”-Ÿ Þì<1VƒSä“y€Ca¨ý¡(²¹®%†ÞåàŽöÌVÜùãèäÊßÞÕÛBë3Ú“*¬želMÖ÷ÿƒœk\ÝI ׊·[¾gÔ%ùíéèÙ+ŒñÅdËSËÌøL ­Z:QåKÌ §G7Û ñíZO’ Üüè<?¢¬pý¸ŒÁÞ(è7‚ÑâSó<Íç^á×fzâþ7ìÛHÉSŠÂ©ºJ™ÛçAÜö¾mÓ³LG›nà­¤m@¼÷Ï¿ck¯™YfNõÐÎ;ý±¿zÜ•½"±¾Bu…Oš›a“=ºR8PéR…n ‚–îxÒ¼ù*/dŒeáð Œoü'_.vºë®VÑ%©œøÛ >-¾ÁÈ’pe@[òAXØ=„©›¯¨£¼Ž-ÁìC|ú\íªÏ J­i bØkª[fH¬iV ¡ÍA_xf€jwÝñËr_ûÊI5-FèÆ*LI‡%<ÌÝXàþ&9ˆwÉwä¾]‹Si‰ e�ÒeäW×Kjn€qJ³F9wÇXN*Ø㤿:„Ç^‹¸œ~¯ÃÈŸ?aŸŸèÈIm$©š@á7ž8È]¦#b–©¡wg¿¸Ì8Ñ·J–NxxÜë¸ÝU*„Ð}§)°[S£=Ì(f”Z®ÀðÔÆ#™ÚeÁ®/‚¤Õâ3K…žÅž~)%ÝìA$¡²ÌŸ¿ã¯°´*N]R‚#f âh‘*üïaövè29‡IPº®Î6ƒiü"[ÞŒ_¾?qŠãÊ׺¥ÓÂÖYïuiöõ…û 7öÀ¿õ;Žë\Õ”%>Õ7bm­ÁÅ'S…ØÁÐ_ß2gT'æÇUp«ÕIU‰éï&Çè½qЮûûj.Y²ê RH)FüïEÅ|cÞC+ô«BðAŒÝv^<»×¾«˜ùx6µŽ˜Aý›ºÏóáDEuG¹<òãÒôøÒë÷Gž_1‹±ï!’>l­2‡ #%ÿ€dýlôꊥWË2`èzOw¼FT}"ãÓ;¦-žÙ».X8vÕ's4Igàå.À·ž€7 `{¿`¢t»êµVTÕ^¡×3t¢Õ7äÍ9†2ŽRŒ1Ç7HÇÙy\JwR†ø9ï5¾1˜È` OÁg¶¯ß%ç 瘎ýœGº9µæÀ3äWœÚ¬pÌtwÜ =*_~nôL£¹s*/ûîÚ©‚áª)ðè`z/¿a…üÍ>w˜©˜eW(B°6·Ù°äœ¹ÞåóàérØKêèõ¡×U…Øu°|RmY5Ðtæ¯>œu2‰³Ÿ·P¦¢ômq°T1¢@ûÄ:°qiIÐYsîmŸGô?ÊÆ™ƒØº 8PåÖXÿƒC;Ÿ¡ƒ¡«tåíÝñrd–=θ6=f7ÄQæK)ÁbNƒtÚ›È1™S âo@âÈØn€é2·ÊÄÉ” "Q¡¸-X)BÆr«â΋† EèI'¤Œb^*f€èßÁ¦n¡‡bVæžO€¡»Ÿ~¦Ùª’P.}Cm÷‡c'Ž9þàvõ jª@wXÄÃuuM_“gyëŸÂÿT‰}V€hR<§›ÓÏ:Åïú£$PÞÀ2G_ŠìIlŽ[VdgGö#ý¥Ýl†ÓB ð¬cRXŸN”ÍÐÿ·æiæÑ2Þï\Zwð¨r15æâXÌþ»Ìoþ�ŽÀ8Ñ¢áb©©@èÕ?ÔÊ?î²’µ©™'©npè[oëŽø { Ov^v ö:E|– «Mï¨:¶/z¾<Þ§ç3ìYè…šÓ"EmˆVßþ«rcÕ³Í#$^¸óJ¸ÁÝyÅè<õú—9†÷í’¹udÜüˆþÆÅIq_:ƒ8Ò þØbœ/Û“¤«._ôg:§&' R 4³wßz LÝî03ân©Ç—ð¸’ì¹q᎔³l#‹Mt_TâáËóÞä& ¸’æ ÿ¥d-?º•†ðÚU=«ºÉræÝ6ePNê>›§"Iº@µ Àê.†Þ"z@¶çdÕ¾Ëxå­‚ÀSy4x&YM?ŽG-þ’<¼3,ç™ ‚ºY6­÷©<.·0OÌgüþ¯aÝèç,Ø †ÐQ}¶æoõD]R>_‹MwÚ`Ë$ Ñ-~â™W´s!- 9¸©"#·Ã9*Z $ÒHÌc`d¦½ø&†µ‚~ÒâØ^KzKeõ`N. UÉƨàˆûþ ak¯É"q¸’¸§ÝWA¸·ÞT¼§†3ãý¸+QÄVüg¥ v˜yÁ3OŒT7tnAYéNn™g•çÕ ŒWA_d~÷$Ô¤«Ë<!vœ[¹ç¨ù¸`/îÈKžn-Ý&ú”­ŠŒMYšR´ä„Õ_¬?sõ«4¤„FÕZ)$N1„.ž•é ëâ¡=l¨NwœE2Œ4Àܪ(â¿ÏÂùB_3“ÚMU\(âÚ‹ï*Š}±rF“—ìScæÃe°êƒÒßhNôÖ²ÆeÞÜÎ ”‚Ú«õæbœ‘JHÅÉã;\ŠÇ7Òíî·fyÖ²-¹Ì— º|y¨xá¾urxhÙðàÒê–™Ç s 89?Ô{n9,çVÌÜþû–*ñ@K~Sã¾aÜàM{L†ò@Éú¿ok½>¬^ùï`b[¬&¶Q0”þOÖÏ}Ú¿µiÁ΂å¼e‰@çÎõ²(Eù‘ôð‹É‹=Tç,Vðˆ—üÕÏ@ŠWª›²' sò 4 i,à.,Væ Àéö0ïÒÅä¦E–¹‡IYH ÷žgá¾n”èšG#éOµ#Fþ/×:±­ò<mç°ÿÒ}W¦¢w] ïÛùñ¾öµN˜qqü ƒ%ú²#ÎRr†Sݶãæ`ü²³Í>ðן¦%qåÍ×E”Š2ÝjØyYÉ;•¬£#upG”S@ïQ<v%‰µ‘Çyê(¦¦‹v0 lo–Õè k¹?Šs€þ³Ú4?êúÁËÌR!Fñ¥Âšý0Àé±æ.ûÃq¦`Æuá¯Ð8qßD“é Ò}ëÆ÷b¼lå#�nÄÞðH4Ëòº&(£M—QO=¬Æªf1å ÝÓ‘î,\#=@~I»‰>Üä'/ψ¨V¼Oœœ@¶®ŠŸ=†²dŸoÎÀÀ#™~wd-»™MöÎRSK‘H3gh¡rÁrRÞµC ßE›Û0¦LÃÉÓ«[+·µŽy|‹ÐJ°âÙc.Q7MJÊiÀÈ—;ò{Sƒ,\ùÐ#;ÅŒg³ 9¸ýàÑzJ^*ið ÇícJ¯Ó >k`( U3Åœú½«Ûn ç‡%×n51Ÿ@�\‰ß™å…ë[[bQ•‹¡²OIû—z,d1°ˆÁ³Í ÝU…¿x×”e3tÊÈÐMM›*¯-Ý‘> ·²¥/©í‡t xzÎ>ÂÞ%UÅ·�H‹gÂñ ztqzw”妬ídsþâ| xóSW¬aßNÙ4âB*ÏPœý”0zu÷°yåúåN¡ºi6÷Løí¬×9«£‡a󶿋¿i±j²W\Õ¯e¶Û¶^å°é†u;VbWߤŠk·ve•ÏBz;U 23’\¸ØXŠvr@=ÑI‰f_Æ[,¾úÿ§íO–[G’-PtŒú îT–¡o†�6R�¸)n»ÿÿÏ—{xD€(åyfç$AeEÞ¬¦Ü=#ï è'c¿(¼&á]RQù6,,F0/‘:¬&±0Ù0sž›�Z–°’Èó}-„W“‡Œß³œ‰Ã‡Ÿ –8W‡ÙrÛ-Kêa*_J,PùÙl½ÖˆÖ‰;w¢8Mà1ïX áL hý*ïÀ¡ÒbsN¬¶Tð矪œ‡Ù>NeÜ+N½h’ÿÌŽyQUD¢¸Åðé‰a›4\ôÈêÞÙˆÙˇRÛqè[ÛF¿fT#öÚbwð­À Bh¯)þ ¥Ð,¬Æ'³Ø$÷^p�9êÄ) +pMaiœ Ö/f^yoÝÄà;A9©¼©:³·GZɧú ¦1ZlH«Xé8Ü=‰k:hz<pÊÔKÍ@ñ¾Ùz& eFŸû.~MWËqVù^˜1Hètc²Ú/ÖÑë¥eħø…FŒžmÞÁý; ƒÌÂik�ç’5®Ya^ö¢t9…fÌ"ð=ír¿eÿ.Ê2`É �èOÞÀ’J¯È,Š¥ð§,,Þ=-Í«Ìc…Óšç¡e«¢¥èæµ#:àF•4  ùÙ¼2J-Û"ø˜©Ò¶â†•ò…e—‚9du&FªÓÐ,x‰>'‰ŸUqN‰`2èÑ[d¬zÒÛ£—Ião] Œ Ï…Ì¥˜l"žx3&v¨ Ž=—ŸŸžÚí ‰ê þ„[&þl”¾ô´`ØÇPJ´Ì½Ë°½P¡Ï~á3T®^ãÈw\DšzF±LŠ€ fº¶-šÃn›S·ž…ÝäHIµ`IÁ<úa¶Ù†ÏåeÒ€±a<– øk;¸ÂM5I 2²²QVdýFJMöMê•T^{:çF&ÌZ²“€�B•ÀÄgÔ¢å×pyÛ×èf^i̓wDöç†9xm^ÿ©ï¼x ü"¿Â=P¡Üèýhõ1k¸Þk»@ªi¿R(43@ïò6, ¬´ÿœesÑJñÐ>äð»—½OÃpÙw­ÿèÒÌ?@Á"¢UköÌrP*Â-ëëÉ2Ë<RNd‰Ž�°rÕŸçÍ’–‰c‡ä‘]Õ8ßÇàh¸x7Á óXR”kTþŽ‰8oë‘Jžœ €¥›9³R”óÀ@>¼úðµhbåÅ"qRPy’ŬFŠRóö‚~¡Š¹É¨3 DÃM`gDžôõ±<¬ÄŸÀ6 ˆgu3D¿ ó\ªKûÁæx;k}úå‡4õà–Led¯ÆòøîA€¹0ù°ôκsƒÒ•Rõî Ôèßø7Fiå†ÈŒè?!ðØZÀ-þd¢6žS¶cé3ýsЂPOVkÞž}‰Õ6̓x´td=Ý:¸ô³=/_–²Ï>ZñEí@ññó¯÷p@vé;èøP ˜ûK ”Nb%3{¸½d<U2ŸÎÒâ`X³ÑŠ¹ w#j2ÜûQ9;ÏéÏSÄ jPa1Ë«û©•!y½À¥ž/&K`wyXj5– ö™á÷¾·„Ò9Ž ½MŒ‘ãl?2”¯Í í¢iþ ZoèÊ@d+?=Ö±k½IÌLr+.ëñ¡Þ0Œ–»sÓÊ}5$´÷¶V=&Ì™…E¡éÀgÇ…µvr°Þ¼½9`;MÕ¤„>?n4 Føs Ä9ØÔÝE¢L‘¬Òæ„@CÓàé³ rú«{k=ü¡uh¾¥™‹”HZhE^\µe6'úœÐz: G@ ™ð.RÔ¢Æq$0Î]êÎÇ®–ãC·h†µ‡)ìø|Qô;(î›—;!Ø`Uˆ†MC…ĺщEft(=b«XÛ«7Y½`/~Šu¹<V¼Ò)%,Ú­ëžëÓ@ë`!Ø]s@òò8%\Â8XýAS_=‹Ä3Þ5ãéÜÃŒé™^܈»Å‹íÎüˆŠ‡Q©%k‰¯ö|ÞÁ†{ ¬YWM#òM ×iIÉ…Ò=E:¹ Ö>sò·—ñm¾´ë]ÿÍ[O@’ñló…¶=:„ þåæ>ÓWæzd{Wq5]oñRÊ=C…ô¼6Må èÈ”þK“„@•î€·ªø ö I²Ä„h$A~´;’bÃ+醡µiaiµØ©Yß·}€ØëÑ _M!�±¯wÃP1`íW×_g<b¥£å šÔ£ÎÓš’ ={z(y_{äm:Z<;úámÍšËlá½^ß¼ú„ÑÈœ!œÉdíɳ<>ø;ê´ uÆYÒ½ßd/Ê剔b?}�ð¿]+(séü¡® ,¥ü9ѱ¬|çeúƒ_ô÷4½§~]÷Íî`«ÆÕvw<â¸LRvõþ± 2 —–˜�Äï:Ý*LwÎŒe9ývfW­ °| ÂBÓ¢²¿à†ç™k†–+”ÊÆB-dã�˜øï1éã+²éõÔ"—G=Ë+V;?ÿ)³ EÓÞ9<‡β ¼=ˆ"Ód¯(Ï6»¼:ÿ]î¡E<C„NBÎuùRΩd>u«t‘Ÿ‹Ä‰×ÎJ¸¯~¦œ»³yHžSš³âq2ý?Õã©m__Äûö|ÎT|:°"Ͳ ÀL¿­Õä­ž~`.œy*váÀ‚·ªà*F›š¶Ü¡©jU £}ôÚôüÜ׉'re’-çÓ }b6µÚ¨‰UJ×äõ¯­F#ÞEøÔ©O|ö7vb¼´K—ê±™Ôþ£ŠN!'؆зì;Óø¸Y÷@ ³è„~­©sÙ�­f`áÖUI?“³ùÇCsšè¿<‡;•ÐçMÌÓ085Y_¬'kʲ[<›EÝïO/ýì.¶¢(y·‹ZyCc†D6CJ÷Øz€ákõÉ81Íê¦sÍ‹+#™ëŸ YIýØE%PßÓAºjÁ‹R!}¬d2„`=-üjÃ<® ÝáéØ­f{¨?`¾”Ö–eúfdÏSÇ¡£9$“RE(s(­T`%.M¸wuõ¶èœyE昺ÆÓP DDp¼ž˜¦ô«#>õP>�ØM›åqöœŠº¡¾XÒèë6t•—^tž, Å´Oûz²Ýa4ˆ ëñ4\)XZga ÊPÒNš¿—T”Ⓝµƒ³‚ç·÷¥n|UÕ|½Í‰¾oùþå[ ѽØè<V\LôÅ‘Ú£lA*h¥AÚÖÞ`Ú„oÞ-(åÛë;{µ²ØSS›êÌ $nÁò hÑ”°ßÍQ*qÊÈ‹nÞMÊÀ²¯‘þ`ŸßÝùÂUedÄûŒ#-Ýêqs±ö€\IP¾YŸ/ÈfY]Ô;Л`Û½+­ÅÕ[ÔAØu3§_¥ýðF鉵ݢƼú6ðú§g LgлÏÓcÈèÐÌ¥í“Û†VCu(Y]Þ0ÀŸ\KëEšNœù˜ÌÆû”.Õ4ÏhoÒÆi½,~ ÀøЋrDïv—àµ$ üèô–x<S6 $PPÞ*Â~7XÞÝâD›û‡Då˜*Cƒeõ{—UæÐrλþBÞö0±ã_ª…ƒP¤1÷î³ 8~š6FÂ".hÑã]æ«�8–FfÚ€Ó…ÂãûÆQ̼z!¸’T‘À…^ Ó�“º:5ÊïÛ¿z~(W `DìýÉ÷ÈOPµ:€{àÐiM~˜›a`ptÊÍRÒ¢Árõ–‹…ÝX¶1*Ì ÚY0êL±(;ún«íE§Ÿ/Ñg-oBbsZŽ”5†ï*â‚ö0¦& ;·Í¸ÛOÍžÊ=Q¸[‚~î£m£Ó«¤ÝÚ ›VºÏñKÈ�°§õzuê÷Ý7s«Òå t_Ò}wQ ÕňJ%ªV'O{—ò'Üù«nþ E•Có Öø×uƒæú; þì6ÏØU®°Ç´¢Šc ˆä NqÛÙ�=q„r¬|“@r°P%×mÇr…zŸG¶ Ô¤Ñ^’.¢¡43víˆzG_!&ºc±c;銬XpbV¦4 ’ÑšCFf4‹„áU.Ìâ¿YÚ´êùœ‡¦ Jq::Aí¾FfyÚ«üèµÅO¬)<ñia©GŠ±¹ý«ÐxÁ¥>õšf­kn}ÛƒæÒ ¬ã‰‹í=‰‡'úÆ[¶Ê²â+a}cP؈jÚ7Kðœ¤^zhÕžG©Õ‡d]Љ*¨Œö‹tæ*yØÆtVúþ_ 4ŠkZ§€Ù"nõz“`¶÷»Õ¶îzØùüaçùm×pü©ì,ÿ2Ÿ¯Â8héwž.ÙžåŸ)Œhþíëö°zÒñv!J•(‡ 8`μ-ö¡øTöÝx´ü;ü’Ð/4 :ìÀV u§y¬g*«¶ |3.î¿o™qG£ï(p°ŽÇÃk#²2ó{˜ÁŸ,v‘»àQp’GYù®÷øs ~¬.Ûí }õ+‡ÈËØ*Õá¢Ú¼:^ •Ç1üÁf›¼â–nçS¦^+iÝSÚ|lÝçR¤8Ëv64týÑ9[}ÜÑ#‹}è?ÓªŽ‡”Áó‘EžSþbdž²>±ru`C=xº/ZöÝÉÓ2á±15nùbçeèOéûí6påÓ^$Hw‡úƒ­ D†žNqVEz"ïÔºylÁCÁM[–Êìćѡ³Á)Œ·¿M_b¯ἑ³ÞdüôZξßÄ ·ñõ\7K‹pAZ•£<3äÌáW0E¤„,À (9\©ð- µ$ÌŒMŽ*B «ÚL;›®™þy·7¬O{qgàZxMÃA¾b¸¬è,†RƒóϦ/æ0Ssj5/¹md±O¼›Š0 I鶌ƒ7"…¨¯=ܼªX“x— K¾~¥AyT€ötù0xx« û?äÚà¡ÙŒ¡ûݺþzJᎢ<óMr0úhm~Zóx|óq±Œƒc½ŸXqdébUÆNJœmŽèΪ61ï6ouÚ Û¡–}Cº'†µç ?Þé8{f~ o mÃÁjùr{£V Ëñ³åfÄÕÛ‡m„$rÔñya¨ÊÚɼžþf/ÒÒ‘Þ«1ù«¶O‰»Q©;ºë<ßší…;´WügŽþ&Lº„ˆDͤf°Ù;…äçæ0®=ºµ9ôpÔ­ƒvuÙ‰o½w Mgod屑ZÊŒuÙ°É‚òÔj‹ÌªúŒ:%§äðªâ_lÉ�‰iM¤¼–¹Ä–À]}Úƒm,¤æk½˜Gùš5fµ ºKç-Ç ‡Ê˜îhEâ^&B–¾:ÆžC$Û/SëË°V•‚þûÆl„]”ÑŠCÂv¬©ÄY¾yÈ­)±`ùá¹M ªÞtVeÒÐePIôè‚{¸J=@q)¿ôÍYoLQ@?0¬Šï ϨQæUîÜð‡0]ÿõª”müTl}³°ž¬µ<u«ò É‘lhJ6°æ¾,ýh…žc ð„Sg§é Ç’úо†Ï|d.•¶ƒp˜ã ƒ¶ñœR =‰š(]å˜÷rMv€¥{±ûÂè꣤ªY˜\ŠŒ¶þ³k-ÄM§¾ûN=ÎÄ,ÚûÌhk=ê¸>Pi¼éX5ˆ…uÿøl… ¾ôb,µÍ-!N=÷4a�g5Ç„1/–n4s› }æ™GBÞõw$]g•£â¸»cÉqr-6¹û.uFÙ/ª6ø7Ê›”;ýwtÔÒNóÄ>üc‚™ÿ \xO:qÊ9Ö©²¥)¾0Þ°îÄ•QY„ ìÉçƒÍ€/«Qòb•%žD;˨›8È6öþ£•W÷M7š¨Í_Žï×Wµ“­Î)Àu\×ï)Æ5G¦NÐ/̈Vgf¬/)–•`ÃàÛÌÏ.V\¤V( +§L̲!Zˆ.yßý+_134‚ö VJŽ£§ä¬.ŸB‘,#Æš6÷=£+¬Ë½ÜéÙñ]yܧƧȰPr!:5Îi3[ÒPkZ wá0ýÌ(¬ ÄŽrPª”>cLjZ±—n=è»Ú.qÖãë?ÕN5Öuj�&#Dl*뇈* -ÞÚÜ<Q‰%0ÝÅa„sT\FÈ2ò Ä)ì®þ`P¾ñx¬K‹‰ßÃø¬Î£H&$L¢¯…Jµ †öøRÉó¥‘z´—*Ïj¹½?n{ˆå© æÆ�¡,›÷©¥[è‘×YlsÊè“í´Bý3Ýعë¨üó4§>"‹n¤ï9iŸWê>hJ¬‰§^Òt—7séÔ#k&¬xs¡»®ß ƒ$Ç袛9@õQC PiÀÇS‘,]È~–˜¦¥´âoóm<ëàûç”UêÙ3swD sÒ&WúÒa¢o·;¶¬:øLó¦H¯dvGÚì}h G{þHÁM´Ã&q¸TÉ„'‹®ržÑ,•rè¡•¢˜t»Þwúñ 3SU÷ÌÈ2ÿPtšl÷ ñŒ8í@ wßø£œ@”Y ¯å»k˜~èA<ñĤ°zÔHK]²ƒRqÂ|àˆý'[ˆ{Òj黌NÈÖ9Ññm7®zøðÍUøŸT{qdA íÝ=ä&üPv «!#Ú‡ …¬ñ¡g¸;GK¬C.p²=e"£"!Ý‚çéÀÑ<ËÊÀiôÅ#öne6O䲩û¢º¢Qÿ(Üïñ´Q$ßó&_æé< YÚžþ‘Yš1åÆ–éqI{áϬ–ÄÈOà9¥”+n=�J±×³IYŽJ½c¡%ÝÞFã@§WoÕ?Õ“ëêÀ3Î 'öJòrMý á— #¹Ëkñ\ÏmÅ$Í}”Vb*Žk‰kaê3õ¦ÎÿB´>YäÒô€‡.)<{½ãYîq÷‡ƒ1S@[ áöòÙ)Pz-GÖÀíOqPZ3¡²qõ„c'îšßü_9óø ”Bïi{e[‹h¯ùË#GM¨Wøóh|{$YÈ}± ì¸DLlcª™ÝÓÇ :còÝ D§+íLŸ¾&2kº£Ñ\;#Í®™œnøPÜ8c/‰§Ñ†R¹Ãˆ^ÇýŸzOQµ�k줵uI:'Ã%‰B½£Hâ·1óPeÑÔÌ&Ž0�ÊûÑq0¼FIŠ€µ¥Û¸›¼«‡,‡8Í]_A „Eââ%¥¾ºöwr!¶…ÈÒЬ¬O©rj%cö-ºˆ ä¶3 €W*<-ÂÔ›ô´jÛÎHÞþy+*Eb[‡ÖtÌ]-m S´-]™ovB±qTüEsB6îl‰#í'Ÿ¾##ñgØB˜yÑA>,Þ˜í(º×ÞK]Ñs:JÝCË·ƒgû-‚ <⤕å#G,G,ã Šõ¸§¥Yž:OòØŸö¢ÇËqº¥ßÁö¢¡¸‡‘“×ô‡·RÐÒ°ÉüÕ:È+žM® 2"¢³ Ÿ°ÝÐý¡|–"×R}~©:½z‹"[œVÆ Æ6:J‘02Pè§þ0Uä ‰~è{×r�Ò¥["w<l‹ß=Q^qø£Ä(« ú PçѵUúÿ þ¢Xäj”¨´$a·5ÙþðÕ«Z"díA±6}ðÑøþ’9;'OŠîr£bgüJ:ígJÅâ_ØÝô}ÛñÍáW{¡ó{«"ŒõÇd ^w’&<`¨æ¥Òs–òDqóW½´J\›¼Âˆ©¦–/(ÏDÿ)s7;°!8ý³S! ï]Ûîu`�GkCvÞ”ëSwKf¥ç¿SŠD9%—OËÑʘWŠ?ûÇhGÇ7+ Nwt]£ÔvÀÍJ¿[µ>I]Š²ÌœcKélJ­!&ç r<xª˜' AÅ#qL?^(Ôƒä„oÆØùê÷—Ä"X^ÑNçá»fùFUÊ�tˆoÝ‘)“€-ƒyº ÀÆè~ÇF˜©xìF Y‹:`°¬A\<맕7ºg9–eRû:QLqu|²u"Ï´@t‹Ðù’Z—JÆF%Âü¥%Ð9¾w±èU�ÖX“7J× Ÿ{Ó¨4HL.@ŒŸL+ÿ?:¤ïýè|¹¶ /«p9¿ç/íUnž1{èm˜¦Ún¨§·ãáÌŸÿ“</ý‚«ä\0kÁÉ~0;- h$'åO—º_¨•+¾Í*u¾(j%—³î"V¤<Ž§Ugí´ô}`W•FÚ‡¾dBË9 ²÷/¿n? É÷µ5óXÂÖRµû]5Nâæd±�Ñ÷ñ�e/vE1˜ÏLîP  ÖÚÀ­ Z,gÚ#NB°…4Þc–•Ù2è‚”îQBÁéÓOÉÛNqØ(ÇÌF–{¹|Yäv¨ÅÔ=¾w¾¦ÜÂíÞ` ú=ktO×c½zî9œ…¾¯Z— QÕ³ç’ü‡š#Žµõ¨z÷/£ÿäYæM‡bLdó üœ „9æa… ªH:=¤Í)ÿèÕ~ßp±/:&�r?}RÕHyº•è¾Ûài¹E×2c÷Š_vÕìgV ´+Åf¥o¾{…û ý·1göfån–´+dÕÂ,,¢ xý»Œ€ ¸,SÎÎr[ö÷RÅØ‹{2.ê\)ýYŠ(}O'rj©U¬oFÏãòF•î®¥Ê™þ—«í¾Þ±97ô0«ñû1¿ùÚ ãmŒ¦àbý¹ö`Í  6Ñúáxl~°£êeÚÞXÞùÙ­Órf²2 PÔ× =÷zvÙ¨´Íp¸N غ<ž)àÇ ûhú}Ieþäk¶ õqGÿÙ™Âg¦:ËòåHOÝèÏ¡ÐZõ£ÙA@ÕªMò¹kEÊŒõIæõëÕ�Új¯U†ˆØw´E듪=áÀìÆÕŽcè~ lÝ5Béff='PÍÁܪþXµ&Ž Z˜ó:ç.«%þ¬žŽõ ¦1%KØ,¨ ^¥d .ÑR)MÒ lŽžÜ¤ahë(kùl­yÍs™µ<¼’i… DÞµ^ ›{Ùî÷Sˆ{bœ‰ßàÂЫ7žTÁ#¤hõ˜Âoœ7uÿGÌe~¸v“2ôÌé÷­/”¾t­Á'ôDíç2Ç‘;ϯüYü!Q@¹Ööþ ˆ„‚¹=®~è~j7úì»i }÷^{ÀT.·Œà´e Ù¨åýÛq/Ô„“8ó\11gÜÒ÷õä.`(‡üÂ�~! èÿS>Æ»ôÔD…– '67†\êü�ÁÄÁQGØœðd‰¥ÈxvÝ<Ž’2ó8ƒô (g¿iÛ]ì)Åõ¿.2W¤ÊúZ·§kÇçHÓ·Px^Ì$³ _+íiÖL©øÁz(Rb¸¾¾úM!Jœ—Ÿ éøFõ7çE "{·éµ[–úìx·më’*-;âˆù7 Œ¨ÑY$l¬€C©G,•;¥‹3F3§[—ÓG}^ûÕ=Š ]ƒ{4ðh3ê«‘Ò·Üê8±ÄØZZ%É:h“î;Àúw ÊKÑ3\±«o —‚¶Q7²¶0%©=5©.BOO#D¡ˆ g½õ2__zîcw<Ö_ßT‰¡“TÈ@X³ZÀÑ—ÍîÏ—2ž¦ ZˆÉî‚òÌÌè¿Q…åå{ Ôz3hYî#ãnÈ¢päHSëy2Qh m}wÝ£¾3’òMs#vè„-HÜ«ÉJ‡9þÛ¶cg¿ÿ¾•ÖÖ-©™G·¬ŒŸÅæ(Îî!ýqPÕ’6zq;Bú{`\öZH•gžÌ3FzzØÉzãä(KmkÖaQÒýÑ> Û“ˆ“ȯp¨LXý¡Ø»=˜(­çy··DZs»^þRÚQ¬2c^”&ô% !Ð}@!¶vv3{MûŽ‰e€–ýh¦ü?F)}©?Z¦í–"èëêI[Ë+,"¦<ë%‰=XE¨› ¡C{’d±8ꢯ®eÉ«ŽÐeî«£S%Ø}jSû´´ÝÀ‚ ‹±áª‡,£„£‹ÝÞsJ¼Î&ˈmzÚR_Íú<íƱëÍrþ<Á…†çî¶jºéÐØU^˜Ä hʱ‘,`­dÕ‚±Û‹ßïÙñ�‘u¹½ºç‰¤H>R0b€O:l¼š™*•®·üüÐ=qUøjŠ\aІl}¹<Z‘Ȕ҅°Ä¯mJˆ;ÍfŠœÑ!õ¨Ìù_¨¬¹_X¢+ÛTAØéÐ ìm8H¬¾­Ì5ï'†wóË‘BÏ5ï/ɽ¢’&b£=ëÇ¡X‚Ðk­ävýшC{>Ú÷½ŒedCæéºæ…!$tŠUòÑâÏ0ã…f«±òÃ!؟϶–Ë4fº«ÆóÚÆ>* 扩zZ$<ŽÁ¡ôçÔYw4d†SÍ×ßÿ rî 2ʧ‡ÚRF˜-j ¦@îÅž€´៽úÀMc½éG‚=¶>D &óOץƟ?Ô펕¿å/ñèçÏ©è‰çÍÊ2Rý©âËÑ”·èlݨæLpâ&ûéï_0o~ð½ a’-²ò0ö1Ô{G{>Ž€Ìð�œ9¶ÝªyŠi-K$YÝ®mí¶‡ã‡«~ødz£HÓ0ÒC/çùOp§IZÊeAø; ªI;8À/îwó¨ÃUö{ÚÍ7 à÷}x¢ÈÓzç~ÿ°ò|RLDŒè‰\½°øM0õ]mPÅxÐ`²@«øÆÊÂNÖõˆÎ¥7–´Ø lÂ)ᜇkDsµͬkؤÁ÷Z6Ñ"Õ¨‚n×æ¯É©{ P¢Ùùß·HÐ |q8cý²sÞB×¾DH%Bm­ÓPX?°]´¯:tgSHWâ2¼þ³›\$÷ÎÁœ‡ehž§ïVk4gñÁK±“á·± š5VŒñ†«~YýÅ¿YÕp·ÕI/Zúa¹±º?/Æì·Ê˜E¶P‘ÀB§5/S3Ž"5_aisZðé{U†Os¤í§‡gt·—?BJ†á$?~Œ~Èó… &«êi¯íz¶Øùd³=ݼE‘赧bÖ5+ÚMsL'Ànªë•ô:g˜—<bH™)WŠÝÂ*JÑVݦ3¯eiÈ}zQAÉ%š‘‘ ŽT¬ÅÍ¥ ,“[!G>ºé²êvýî° VgZ(˜™ÆuݹWÏyå4#é3¦nŠa”̧ºð0o7ÑùwÖ˜jÁèži:*|”þ –ûì©QgÝwÜ»éW<’JBX¸ âIMû¤:P¢Z^˜ ”-î5Ÿ~ªÀ²xû‹‚å£÷>'’‘êa i:'¼&<®´ÃfÔ9­…þÐ2 àpøxAg:Ž ul·sÆ¿Já†F�ÔØñ°gÕ;éÖ«šI¸ÄµèšCËÏp4‡/8áñW=Œ´*[çÛÖ—3;» }õ!1ÁÉ#&¦-ÜwUO_I+˜o÷­F­#u¤×Dw9ÒMçÜjúFë¢ïRF¹8Éľ¦Lÿ\‹`ú}/£˜­ÒIÄ­ñþ€è¾n=TíŸ]ÝžVJY4°ùçU%_:9¡:OôlãúìÉ‚2JŠj +¡ÿÓâÎRUecdÑC-®¿X†"ûž o—7,–Œ¢Õ]¬ÃùbþÉ¥‹?Jåaàñ&m†A…`ßÁ;žÑ™5;V hþßrØ“Ü£“1M{hÆ[mˆ‰–§S S¤íiœ [Ëÿ &8C ‚ùdþoØ+“¶õªÂIÉʨü#eB²ó·AX߼ÄcÞ»º¸­æ`hR·#Ô>ÂQAœ…à+$Rˆ•ÔnßhŠ3ú'BØ©7>g¬‰LtŠmçÀ× »¥ÄÓŽ¡7Ë[{ÊÆÙ‚<·žìJ‹Î‹ŠE(^îò, 头fjsy7xŸ{ÆqsžLAƃaŽšôaôE7‡ñ¢Š–VÙR‚©/ó‘…VtA¤‰Yúæ¨vÒ©Á ©ê§š76—+TZA㞪ç% :ÞMRñØÒ1Áa³£¯,|ÕAñ›f· rdT6L»ÉÐusÛÌeø.­UQÂÞ®Ò+{‡ÃÌ,­hA’ eð œ) Ýµ{ûN@�èèÒ©È… O�«V‰¸v¥ÁK¿´ºò9ôqPÎgõÍå¼Ñ�Qů-ýÊÆÆI‘Û´_#²‹¤³öbœ5«ëšã¦ü(ƒp”Bź|Píî7~‰8¶ªt•1·ú¡ËU”-ar¬äIwÊÎŽ!L@É9 ÄBU€–9·›½dt‚lY}ݵŠólaöåÎN»–åbïrì.{#M'Ðw}έ† ã¡(ëY­S`c/nN7€¨ä½úS5ÿÄ[î,ß6}Ð#Hk >`ÀÎ56} Xâs²—…‡ÿ èÖRA„9¶™¡ù˜vÛ Sõóó®›þB;Ë� oæ[Y¶˜¬‡ì×a}tìqµT¾$P3Ê” Œ;Bm¸¹vÚ*=ÔX$Ž„à»Nkt Â63ÖÎt|Æ6H»‹kµ@wßÞAÞ¨.B(Ûž¨ðøÛz†Ž,V)ÆH—ô‰â\r~OkŽþcGîÌ7ÁÙ3Feg¯ Ø;·TìÁy솿 Vã­âEò’ú¸<Rj{Ü:®=ÕìæoyI¿ªYž€¬‚šG‘¯µò«p›Πè-Ð'ü^:»Hnݘøb½,{w0CU—]61ϱ@?Zd‚Ïþ¶}e çH…Ño•HÅg—¤sbº©Øú \’tÝñ‹˜PÀ±9m\èü´VÛùسqf0ãÚk6y𳈴°¯Ì›Ž+ê†L±g$—f™Ìÿ'jƒ‰öA˜ñŠ¯?nRúÚSãõn6´˜ºmFm"Ìwç ÃLíÜXm6`³ãwyñ³$»‘ÍŠ}È|Ži¾±Qy û­b~� _´%rˆ¦gó h1Ë|ßÌbä;tªË'Š+ݺ÷oÍ &ø�nîa[±Êqj"ÅäY”d4scŠW.ÚÍ,4ÕAEpžbD¬¼JiˆmME'q»q<f·zu:ô;ŽR·7¬üÐùï2»5«¸fY|¡“”oÿ°l$*¯¥š¸œGÿÉ+¿?Æl Zús¯7ÊìÄ%Ó:Núfb/Y‹¥eæƒÁa0M ]l…‹ÑƒÛÔOÝãW¤­¸¨| ( P!¶R7ZàEçÛÚnÙv<gëMÄ¡NþÏ|rÇ«[Pììú%<Ê«÷àB(É&¡"Ím°¤ˆNH‘-ûÝ©à; ±‰Á0æA6L•ÉªXšŽæa.£›|•Åe™nhAµÅ¥µ‰Àï­ÞoÙξ'52óÝŠüÖZÓ¤\9úžr«±kwœpóE¿ÊÌèkT”3¢µ-@x÷íM&FñàÀ"/3ÿ–BR=ªap:³KöVb Èq.Ýî_*Ï5­2_"•§ìCÕï÷Š^¨h:n¥¿6ŒJ 7XF-úMd³Åj z¨úwœÑÖk2ܱ` #7ðåyæ¸óáë¤ (”F�‰+ªvæ$Q_^èvF…²ûЄ¿°W0K¬¶˜ˆ´fJ4ê[aß½¼“x&¡ÓÂeà⦧_Ô[]$ZÕÝqÐ6ÆL7ö'h µüŒX^(Ôö`£9w&føû°;éìUˆéY2‰Ò‰ÞF,)Ú÷;/R>¥RFQê4(™ee䤘9\€,î=wá¡Äeú»ßëk¸qhaTn¦$ªÑŽñJ3T`õY5J¤¬¯·B~¦á¢àÎ…l9g×Ä&4Ú÷Ç$+[N—�RÕ˜}ÒóAp¥Ã3ÐÝD?ǽ§£ééXÞMNokûÕóEq…´mMO€æþåM/£ŒÕÌö(dw:u)°IOl´HøWdz¬›dî´´ûžnv¶¼åBgÏê…b/|î)oàé±½ôWÞ" ¾Œß¡xe§¡¹úaH·Iˆ½@TîYC&ÞØ­dŒè¨BëÓøppÏU¡C~Ɖ›]üÄÃâ“+¦œm0âkóÚÙej•é 4€Ozëx�ÝÕÁ4ûó(,ÿïŸÆt©£K!âq ¥øÔªn<±µÙ±¬v¡üg7ü³> \õö'ÞL.öª®’]¨¢ƒœ“Æ8“…+ÿifžxÈ7ñB÷tgj onöƒ²‘k¦óQ4‚(³½`¡1ÉÔ¤@ u{¢˜±Þ˜«`eÖ£ KRÿÿ <]hUØ %$Wò >MR˜ÛÇȈ@SzRÍ?\ ÅßxP¶ÏgÍâ˜&eN¦œù!´àNvTž2×ÙhèóünêTU.,èÎPdnJ Kªú¿1½ËœwŸðƒÏ”¥Özúf©5Ÿ4wÅ ùýF†•Qc«§Ã…û²éè,kÂçCõ7kÓ£=}JÀÊž&‰NAϱkÃã1í·¹ô`î΢~sx™yÒü˜I›T…>­ÿú®¦J§– øeöÞ@ªË`•URÝ»rvFV 26ÒMgø ×VJ¥»žÑ‰¼üv§pg=’«`ž2Úö6z§&B1g_ûy(&£pðú»¥úO21vÍ?;gHëèËâ_·f>8Ùs¤­úß1°êx~³n¸FÓêÆ\Ýgõ–ÙbÌNÕaž£¶”¦½:Ъw°ctjáwÿ¨6÷„ayvÆÝ‹˜¶­åÈ,i¾oN8í\²åÁæHÕÖºE`Å4t¬MŒ6ó"عk³Ô¡¦Ìh雎ÂÍ8º¡Ï+? ÅfɨSÅ`J¼©R^Ò/½ÏGQÃ, Aåˆ%'û+~l…E@˜1žÃ‘‚Ù§îª46ˆés½ f(ƒõ{a´É-H&*ª…l­”cÄZÏfLOeX½¦š2M9üïžûÖ\/6’/â)4t6Õ4†E’þ#?¡(ô2YN0ZÿôP›£jÊ~èÕIWþ”Z/´›8+êVÑŸ ª!EÑeÈP !n-ð€ÛPQGéƒÐÔûÙìýtAQ³­èîbÈMòú ¬*r­“E3n³míÉ)ìë†RD(rCi–eÖÞùÑÖmls±ÐtצCFYäÖ«ÏmO–VÛÝõ /i'Xëwµ`D—Ž­!£•ÔÈÄ+i‘[Åߘ¦cǶçCçË︼—›°ù­Þÿ:È G¬NÂ…À ¿ ´ô‡Ï(€r˦÷ R—Á5)¾/¢È‡ÔCϼ¦#êúswà¿X�I ¹8ª6ÖxpYÑÓ|äã›:"!Ÿ×„yïí‘s Ýz¬V½ËìÅü¸e+ªîq,‚ü}V™Œ;Vî½½¯=3&-›×åÔÖŒâàÚ’wCE­Õ,6gW÷wUêµñ85:Žð´™ŽÚæ HÓ–oŒ¢ÿY¶T69P‚Pm œkÇÝð%X› ¾D¶�æĈëÐ’f6ñi5ž¦*Òë]ÈêsSËÚ¦ÿÆøÇ)0HÉ„æ=Ôöè1>˜ÓiT¯n%tÂvX¯ÞÕƒ®º­óŒa}ì6ðH.žŒØš EG£bÅ°ë×oÄò¬òönT IëÉV#Œî€&²ˆÞ5‡Év[;dKÍåI`ˆl´QøÞjOék𴢜è Ç›—û¯Uê{²¢e4Ò˜Þ=�b‹ý®=©5£:ß h}éÛk¯¼òeèüØ© ËzÍi€ï>ö&J¦¤w­L<F&Žž/«Ã¾é}½•Ž·£<c)[!¬³¡žy¸Vòºïšz€è PElSoªwùúËV@¶˜eIühl<nžÌÂøwA4s=·“~õtñ=a4ÃËÙB.î}òêfœã“SìÙ7«5öЋ[2ÙiÉn‘/~:™Åy<±S…yydkP¹B™Á,¤õ®Ë¹‚)‘mFÿc)­$ =óPv6L2ŠÐŠrŠé´¥S‘u89€P5÷¦ÅõÏ w:2Á–œÙZÇþ€'Yú?íf·r®5/8tÆ‘§™É.ÀgªGÓéË4^JZc–¶ô gM}}\ºxå‚é71º›)Û38?Dk1¡›W%ÏñC0CHÚ£µÒÆÜp*Èô[¨øïħɻì;úŽ×Jx¡;Ýù0 O*ËæŒ,=£?|Ðý£‚d`^È™"6¬+5oÇ©Í-SSÐvh£‡áÿóP[!ë?âìÉ‚m–Èt-ŸjO¢ŠÛáûªNòÊ|Ͷ#1¸DíñFG‹in¾›ƒzRLE™’Ü,1u›¨ì)ß[«¤g\5%+—>£JXQš.!W¡v ×G¥t…í~Ò!Œ=0N¬.H@FZš ðÉRDNÓʹúÊKŠ7²Àk½íÿ tÜó°2ÜÜÔN{p›gºb52oÇúȧ², þàw9²¬€:ÚråÜX“š*pzþ»êþOÍ¿Žçç6gº÷ÈÃÒý-¬ÕwìÚÚÝd¥(”ölŸ6£´§<~žiËÈõû»Óžb1" ƒûˆžd<|º1o[ÿ±X•™B+Hn  Õ­b‡˜ƒ¯bÚBíTa6 ±—aœ×£íÙÕÅÜ™n\Å‹(vÖ?˜(sdÇA?¢Ð5¥Y}ý§ÖVõÏà¢öä5ú±$ÕÉz³#•$Ëô µUð»ä1NÌ´73TÆÃW³§·ôçף¦ÿ >6b©šèþÓJ/ƒ²U f.>%†Bƒæ¯3ïŸw–u¹ñ S¯ ŸOš3Æl±Ý‹Ö“ˆXÛ'©h¢Ò“ÜÚ`Ràxnµª¦¿ðØ £'¼‘W“-V¥|B-‰«Ì•Ü%_5qPŽZnÄeeÓ†±g¹†O¯ÜEê÷:Í% g>Nws^9Žy³kÛSÜÞRô<BàB¨œê×DÁÄIHŠìM^v2¹òwªŽ¸sh+VQúc8œy–¼� &¼Ë]&è”tØ·'kÆú¿·þô¡b{ÿ}£Ä˜*ú (a¦ï.×à*3¥,é6©Ž}"Ucåüç)‹³aòG�QÛÉušØgÀ쌖›CQ²m×uÀLÚ="cÝCM9Ä ÿÖ¾úÚwbž ^`í·ecgú XÀv´E”,,!H¿ŸÜI —DíR\‡>áØwmöcyˆ¶Fœ9#Nþ D­-H „�ûÃYQ®ÿþ™NÇnügéîíO¾µJðÆéCÐKú="Á`X PÜ·¤ø˜GÀh&Xhžï ù¥^ß‹?w{}o«ÐvLIXiÑHU¨°õ/æ§Ñä©ÄJŒlŽÜø€mÇQîÁ‘ë~® C˜àL¢ çKÞ-òeÖe½MÐÕOͦ*—7yãœ^Øq‘UÒÏ ²v‚™Sú~t¨ ñ°UZ⊫|+ÙîË*s‚8lè>»YIÌœ:ôx¬.«¨Ùõ“úÎwüeå…Mµ´¹óˆìòü¦ ë2¡|YÇãlÍH¿ámuÞ〠–¶5ZüýåÁ¥/[¨b_ÓãË?U|AÔˆI¢µ0T“An”õêŠæ´¦þ™$n?jžÂ~�$j} 邈¡^Ò5„Ù¢-ÍÛaê;ïÂʦ© Æ2§'[Ìv¼ ¸1=1ý°uÍÒg7¯‹Ö¹d£ÂX •Ü( bÛ£Û3hRçjf—oņHÞ=01÷GS ³b\‚éÐÝÂ0Y.ƀ摓Ñ6TK=ó 0kŠõ+úó>ž¹©eIfÿì §à SkNÖR¸U–ÊÝ0ìÞé#Sô»�ÕÔŸùÅ�ò!ÍÞzþ•ð í«Uw’;l< ~xe¡(%6ž§gŸu½¢|ñÌê/fIKê×±®@é˜Â;âÚÜPoÒ4ôùßЦ "§°4y¹bꪋ¸ôPÏ’®£yÓŸh)|5JNc£È·—؉aVÜãFV]~õšIí@þŸjf¤ÉBÝê’SA)ÂÙ×Ê·ø>ÒÑ3ˆ·šùX)¨:ßGÙŠžÒýá(4¿¢6©€5Ô•2ÃΑß&Æ ñcx“@µhÛ©nNŒÞ]=zò—ߺ’d…›lH‚|ÓY*˾ãÕ¶ÏM…0Ë«ÐAÚîT~yè{ó¦£öä¤_Ø4{k:kŽÐš2û‹ùè…–ÒÀ0ßГ楦¡t$³^üs“çåôíŸ@'‰Kz£ùg~|eæÃOKÚtŽ6žÖ¼Ïÿ %í-$…÷·!@\†%PcMm|¼¦¦M%žþK†bÇ~ÓžªZjÉð×S< µ$º`=R·?W^½x_� »š!Æ>yí}¦ü߯~Ç:ÒvÿexDgõ@%J=+_ŽqÝ»A%dØrÊj$ ß72C©wžØ$«?” —ïµ ¤”  …*ŠŸ‡ºÁñ`<Ÿ¯ú~×µiâOªJ¬ƒyÈ‚Âj«a?ö;¡ûsècd0s$Îu+ì~ÞÜ4XCßþ�4é?Γ¶Ab2X Ò5Â{Õ¶ª‡ždÕªÆ(aTôGÆDiÀ/[»P˜TkÁ«Ãñ&Š §àrÀèƒÞ5cçv‡#‘“s‰W®FräX‰Ü¼húúÙp¶ÂQ#|ú…l'tV�þ(ö>:¶,xPz(ˆ/[o Fÿýºëw-nz ”UÏøça¦ºe@âË¡Ü^>:Ê‘h?LIPÚÂ4f¶ð BMü×MÛC‡·¢îú ]û–¾EÖƒNFa›mŽÐVÖej¨÷B1” §ŸúÂ+Õe›~ÞY8ž›¨ðlàË7B ãUG°múçqb¬[¯ãi«}|寊6ÅÛ£¦³HìV =¨X³ã±ä €‹Òi+°é—a,Ú‰6‚ÒØRmòsºâ‚¸¨óQ0„0,hxÕé⻞O<TÂ<Ôw¾QmŽ­ÕNa쯦PéuíiRz®ÕJq;Ì–†`öÛ}ìHøë*A~Ï€¢QÅ¥ð­;ÖK3߇חzñ±·ÊÛX¯¼ù“nN<ûyÇLßkXä‘ãiÝÒ2ß@"ÿ¦Ó§Ü*EQ ÈçAØ5Þ´|/*Ž¶añƒfU–„ ‹ò²C­ÎÁ±Ù÷+$_*"Þõæ;òVÚŒ |E"x‡·T†>æ7`Ÿ0DXnSYÖïº#­Û<^r•^É ×mѧ°UY­Âç5k:ÿ¹ì¸/€»ñ ë¶MsJw¢¶é\ënp›ôßi ¹iieHWMUitäD±ÎÎaa?Õ‚ßï.ns»bá/‡Ÿ¬9­"QÑðoßè{p)G…”¬·8ê¹êO”âmé¾´õÛê:/÷~ä‹1åÆÆ ž™áÜ;õ2Fà›öÆû7¸[A¥¡WÅp;aÜçAÚØÌ4€ù0:¨¤Õk¡;b–å­Ù^ä@M"òJ§˜>M3+¢<›Ò<&2¾^/!\Ý WéèÝW'‡¿^ÎXÜÈçîzÚ0²D’À%2õ½±PÏjûÜhPa»sQ_rŠÒ ó0^®ÆÉÙ›«7Qƒ¸ýŠ¨… DÄÎâe·ê§DÑÏ%ÇÒè;¨vþ-H:Ž¢Ê“¢@5nbx^zÓ幞(í¼I¸å)¾ÀYtr"ÄPÌ6:6ˆEÖiáV¶k/ªB÷^pL'Nú¤”áfd}çq‘Pª§ðk;Ë •€ª“3�ЂÚ]mQ«­´:ß(kiq?¡í$ c^zpÛ¼w›¸„»­%L+î# çŽ8‡4]t:ãq¤FnáädîK!ÚPèx!Ì:$dªÆÜèxŸŸ£2±XÚv}§Ïn¬ ¡ý¹wµh ”‘(‡<PÎUP5jXrw¯[29É·"×é‚b‘£Ù5YÁY†]&¿ý¹òÍ|ïºÂ<ÒùLÿHZ½çÀžélCqª‡æLw¨›þÁSüÇÌ™ÇÐ2¼#9UÈ{nÝJ„ü4«El¤¶ÕxÁœˆ’R@½Üt)pøÀÂ\4W=Vnß'Ì,;TDLö5(OÆ)l™{ÙPd'ñ©ŽíRŠ&_:`† û¦çÖ„riNã~º’B~î­\.TViù°tföùדͲ³,'Qô½zfç©t U¿¦t´nM´¢_Êž¯¼Òó ©4£L-Üæ.Îu2+£B!ÌÎî³ø÷¤N§”Rç9Ú² ‹. x «dœXT—þ¬Î›ÑþBÙ²³€?qƒ@—lg‹ïÀƒ02µ‚{ ¼GÉ¥×@îð¤k9kPªxbÚ÷pÊŒÎ÷lÇeËùüÎH(.$Ú^ø¼ním\4£éñê8wûW€{QœøŠº-}rÑ7ŽÇD'âÁq×Ñ_>ï¸B2/!{ñ2çM9çMkOõÿÙ_:c‹Ì3ÍL–NÁʺ"$ ßÍÕ°S~ÿèP´[¹ÑÛŸ<Ó"]Ä!6&Š ìŽ®ÿ‚GÜv~Z•ägZÒA}A6;Sa¼Â$™x:åIY8ÑæSk^|:•‡%¬pœ‡2(¿!ìт颟ãÄ\þ,oH³ÄKWÙ‚™Ä†ˆŽ£*¦r¸w2Auct{¡ÆŸÜf{ƒ"íaá h™ r^ÓvØ^œ}%ÖM;½Yï×€†±OÄ‹L ýõÆú·ƒšFÑFß²Ê?ï¡ÓÔQnM; 1ýw³4Ÿxqk øí‘È&Ž¶ÉâÛã&¥ØsQ> 8=Kú«æÔoSý(M®”äWkÊÚ­—äÒN ÿ%ô8M*Š%•z^=ÊbTðÃúRé©q,s¼p2’˜ÜyȨà§Ó=@¿ë!kÃw;Rq¼m—†’]ËÇ£D£«#5eV/Þ_ 3±¥úÈ-Ìå;S!j?‡©…C—ÂÎD'ÐV_×ýêàïƒó¥g Ê󑥓ӗÓ2²/H&=³F–3BkôàÎÅõü߉kƒyyRä&#™Öè4…l”â`Ç—îðg׃Ù2]H¯_o¿Ú3ÈxdÃÃŽü÷µÞ&îdÒñ]7¶/ ††\½ên“z—cÃ@«/³}(\™ÈBi”‘å•HðÍ´‘a®îgό¡ý¸%† Å$.dZÒ5’ßÐqÙ'‡ŽSU/%Î6 ’óÚ AD/¸Z5}àå*%ÓÊ/~¤_¥Y‰È¬â¬ïèÞ@7Ãi 6 Ê¥|ê+ Þ¤ŒŒBfTVM$³oö ÙRn^ƒ#&‹i,Åã)©‚þë9F–ùO¼‘•%Eôô52·óhçuN«î»•B)Ä ¬‡+ž‚W½æöޥκ³Ü‘ ˜¤9Œ `·ƒ£UÒ¤¿²ëú¥Õ¼ÞÞ.°ó:©A’{ë)ªúå3/st)ʳj; âڞ5%:>ìOx©+ú°yw4i¿0[ æ©J =vH¡öõgÞU¸°¦­‚ó„‚ÅîOîOv é¼sI±¯WIM–{~ÓÌe=¯"ZÙ–!wøÿþ_ÚÂ|pù¢Í‰Ç©±gô”X•üžâE¹@½ÄTí±@åîKÄõÃažV£ê£, Ž<Š¼¸¹™2H5RÉÚ)b¬ãœY¸õ‰;8T/<¶W—Pœ:º2–}lÛ<H†Ai7!·‹VÓÌþÉ\¾ñ�bÅuË —*NוE“WA4_<Ö×q§õ¼û³ãÏ9ôí7Baµ@¶U€™ÓÇmµ¡±¶Ä„W»Úz¡髲[oLóp’^É—ºÙ è êÊ>†€@çر»lÉJOÝè µ®ƒœ‹‰É´c'¢<Y³ ìY<ö~b,ùíEZ*mG ÍæâÄ�†Ó,sK'F±ë?d­t SLÛå1Q•Ž¨Vq5•@«ÿ¯÷mñà|/qÊ#ö£µpš»*®aæ{›F° ¥OŽZ=è“ -óÁa2 ÖuæÝåŽ]œVÖˆµrÉÑ%ù²PŠŠÇLwÐiþ7qÅ), ó6î:fùd7Vör½¾ ö8h¦Ó|Ú·ÐÛ¢³Ú±×Ý �;-®_º/(~ £ù¶%W<"Ôe¼keß3,´îY$ÝR$gk_ÁRÃÎY$² Ì Ê26‹-FØÈ¿Y«8ùD0GadÃÖ³Ù:FB¿œò걸xq6‹¹«Rø khKŸV‰Ó1œc­!ÁL7S–â+•8¬\3†uûÚ.˃hÝ9ñqç¹/º#}?8Žª±·TM}3\?bæ1ô‚0b T0î¡Ý2}“7DV_4Öj_ò΋,†–6~ã[kïfþ›å¥A?™›ûH‹Öo;}P‹¶Úó-Yüû0MÒÄÛut#' Ó’wìêåMˆC·ØdLu¦1ŒÎ¥´WÈõßð*ÒÐj=2ôØpÇ” €<66r6ZÑJ×ðê2…ÿÏOÅ|‘ÞÓße’ò]¡ßŽ_5¤0^Oƒ^ûððÆ<mȃèàj‹¸î9P:{TÑøGmð(Ï}Q&ÊAÚš­¯Ï–Û³såmÖä©]ŽúÒt_w?:M …¢4‚çàÒ'Ö¸&6:—nÏœ™ò”Ho—ai8ÛèØ$Îe6aQ ˜ ¹µÝžÆŠê/5m¢4rVë þFzpÙ»g× ?%ªæt„!&+ýëD¥îi Ǭ1‘5á7àÑm8áÛ¯La×û߶]š#óeœdPUÎî&UÓL\ÕtúPvf^M=~Ímˆ«ÐuÐa¶Z§Y\În¬ÎÛ‰Æíî¼êv P »ˆ”áÕA¾›Ë%ÆÀy{L9áWÿϤ^’€tõÁ˜»'ð'«DZ­×–  |h= ÌY9Öh5k­¾¿4„cë$GdÇ¥ ¤ l;žÓÍöWU¬C3$B F:V)¸] Û&Ô[T+®>X˜ädÀɉ³ÅBBå€ âb¿Ú¦Iž¶n6LߺeGpöaf»ónë&› – hó��¶šV!Š­ëådg '^¹ ‘K€EO°»ÁBÌ‚�`aÛ*nN3× ðl•”P�¨ôtk^h)‰wß•ä³Gƒ- ‰Lía˜À_$%ä²æwx`×Zdž0•7 ”8ßkåÔFXgH–ü¢ê©¢"eÒ|Hàäöå9^¯w㻿¨Iî´¤¿Q÷/�R¤¶Ù6qVs…˜™1VÎNIý'ƉI’y£~ú´Ëçödy,…:©/Š‹›ëýƒê’x¡/G~M;rn=yñóp\'y6ÿÏõÿ÷Í„_åuÂOë»0³›Õ;’O½™Q泞ýt`ÞŠ»º×£$K¦!TŒª»ce*>LÇãçIK–Gv§³ÙYÓÒfˆOÄrjNú( Þ1Äw±ö{A¯()|¨vÿDCò©e1ýÙÃà¬@JP3ÐYðˆ ˜¥qÙØ„$z›Ó­µ×ÉäS =jØ?ŒnôŠ„Huá8é2ñê^ØŠ2Ϙ1dSš¹Å9²7}3ƒ^9ô·RMZntªõ§Ëô7]¸õÐŽÙwôyï­gr€±©ºúi¦ï®ö!šó‡1Sò ±MåÙ#LØÁà˜&”]2ø-¥b?üí�ÁöÜ­õs—QF£ULÄð:nªíZýÝß|y‡ùÔ‰íŒz£ 3AŽÀ’êÍ.Åé¿o±) ÒÀ`rïTgFpõ–&—ÙÎ-’¤ ›˜UVMG;Rc©µø€*›»ã–ã�åOÈd‡ÞãÀÿQ4�—ÛúœÁVš–Ä{Êf¬”ÁrÃ|¬_*_뫳´u<Úæ …Ê%aãî`£ÜË8þüZž¤"ºYú˜�yiÛ®÷ÜŒ:Ãÿ¾~½£î><c".@ÝÉ|tUv[ø�GºBUÏñ¨¢þöRRðû²šQ¤:r<€¼ó@™Gaõë¦é.&¡Gavßæð%|r‘Ñf$“ìóÛî¨(]õ-†Ò‰Ó¡ÐúÆò;,à]mdˀτ˜ï(ðT‘8Ïü€Â·rµ­jgT|B -ód ¿ÜÌõv™™žGh½82:q4œï‘¨Ik8e¬Ñ|¦µÙo<_/ÀÔ—Ö€[(` Ü{ìŦwèå´lö ´ ;‹¥Mßbû8¼fÔ¿ ÀŠŠ,:Ž žq;8#/Öº´z˜ñWdúÔÃnàÜN žèÙ;|>:+˸­/b¸‹>9ºÚ?˜=|€^uò†¥Œãž¶>¹íçî¦Uìwÿ‰‘þ—u¬’"…5¹g0ž¿önó-yA|ߥA²U ì™64í4„Rà2½í„úètr 6F#QžÜöÌ7±å ƒ'd1oÆ_¾aüOÔRv3¨ÌSZ™S‹~æ„ lŸ.NŒa7}‚É"0ÐäÐòàr©¦–-Ô$p L´!Âfôt{ÞOÃîhäÔ½Ï`œ!œaøŒVQån‚­çÐ8¿½¶Ãä•Ó¬X)/ÛË€ÉÍpÅàöÔ X´b°ñFÛ_h§ñ½äì ̤4óMp(Og“—¯³U‘dÎ^‹ÌÑl埽,¬ì¸`™6eÙƒtÚ3\ø ÄBæøX6+®[¡™ÎN³EÒÒk!—ò¦ âœ_ŽœQÜþÓïú§¦Šn·eŽkò±’Å�Q@9K_MþÂÙ²]ܥ߯a“´™J«ÜêØUœvÿÉÎòŸP[bë͆3ÜŸ¸#’o; "º_ºáó˜ OèCià>–ÿ\g^àdqº=íÉãeŠm …þiK»QÂÒ·6ÄQ¤kœç”9÷u¤³Ê[&hÃ^Ö˜;«Cä6ÜÕ„8‹},älPélf@]x¥¨ïž1~†êq((i%lë2¨Ž–!ä5÷ŽMÕA×et¯tbOS”—#¼ßèƒç/—u@üj瀴ȑ�Ú2Òø¯º¿¥Î¾‹¾¢Ø_é4zƒ€¥,™™Ì¾»d Ø›ÜbïÒKÂ*ãCÜäePö:‹Šr4qVtTthª‹â«éØ;¶ŽLGÆ{pØ `×·ÀÛËT[Ã5ugYyÄíÎ<µyöÝÜ)€„_6;åNè|Lr §UAØË«ñs5ZŸŽjzxŠ M  bÂËÂCšëpz|€Ç3é ø}>æ ‹Åò«‚-ˆÜëµg©Jaé4bÈ Ô¬ÀÊ Æî;è]ù KDð®¢bÍž*8=Z-ž¥¬ÇtFlÑ_,UHlíº²Fž6Qœy{>aIÿÆìJ{Åë|_sÊg%rÏrƒ;Ä«mN)Æ—eAX¥kY‹ö> ìÍp—Ý×滑{î‚ZÌ‚v†¤xoGè ›‡ShôŸŽi†;CJº–ëãÐý@ÆÆ ¦¡uÆCYc¥0Wâr¨?jéýFT.²D9ÆiÁ6”A¢ràÅiµ=ô$äÂêÕ‰²}:¹Ñ'ZÍEP *"‹<µî×´j­ÍÅJÁ þ5mnÄQóÌ“"õUziÍΰ‹Ê¶ÚT:_ N§@<ÖV˜ÚšØàT¸žÝVE¥kª`É€<=Jâ¸1Ãë|Æ.W¯w&‘¥?S¢»ºGEb™âÊ,_¿\òd¨øûOß¡D(®½/hcg¶Ñ÷ñÃ’Ê(û>Óë0,+À$\)†˜Ãi}üëuøŽõŸ]¿³¿î€¸tÄèI‘ó݆íÚ?"Ç~×Ò7þ°F}ç2.ÎN�–öAyØŽ#¬íZåiŸ™eMïkUQŒñ(jEGšÇŒïëþqŸÍm£%¯wà’ fφ»XI8„è;ÍjÙøX-Ó·´G¤®(¬UÆLjˆ%1ÿOñöÍaæïæ;\³úËCRXk¦cx5Vð\êjŠ­ÛÜO'—­1€¾W”ô‰¨›wùjÛ(I3Ïá(LÐrƒ|ÐÁ»õ‰AØ>¢ø™æ"¥4n+7ì"zÓî7UÑVíoA­,ÒT¢–Sõ˜†´ÄÝa ®°_Mǵ6f ¥#£UXñ”ÝãX)Åá~øC‡#•^Ù4y`ü­Ó¹™N­±ßBäñ¼nåæ,ß-è•œoPSq7:¹€?À ¢ƒLydr®þ­eSÓØlf•^“-Ã`µÆa=Xu$Ïêtl¨Pêw¤„$^8(gÁ¶Í‚r«®U MWŸèï³ÖRÛSë°‹7ãDú £´¬2HGë¥KµÉ“íðœF“Zø×\š}¯šŠ•½P¦>u‘”\ï÷ª¯v2HHwt,vó…¢R¿ïžÙ Yhq¤B¸ìwR[q8ùÒÃáó÷Ç“¥ž 3Ó”±Èɬ3=žw°ò;AÎtàª=Ú d˜çËAÚTÑxTZèwCT3ô'Ãeæ‹ùw;€´nÇçYÆ Æ¶½ù!ã4Ü 5ïÑ×yˆ³¥“9/í°¯Íȯ­ÿÔµŸP½î÷ÉêÎ<è§Q̃¸Q4) m§ÁÐ$c 78Éá‡ÑgQRâ¡T¤UbT›Æy]ÑürBS“¨H.gÚ±f¯äGTÆ,.ÒÒ$´gV œ¼Þ#;f‘ ô¶Æ«/ñÒt¡´} y}ò òØôø»M‘È=D¤da<0N=‰ ÙŒ•G‚:QL5Œ,Ç7¤1æ€1[‡¨6^ëk­Œæ2[šÐ;ZÈïo`A ®Å$Û¨¹mùÐf§ ŸFöX•;ò*” €«qsÓ­pÒ83”8‘¹æZã]¤_œdž;#-lV¿LƵÛãs½{S(íª[FÎãÌÔSÌæ=8¹9~j#…ö`‡eqSöèÏÜ>Z#æÀ^³¦±ËW|—ìÙŽþ&ìvHòàÒ�MŒ ö£/¸0™0•EP pÖôeñÕŸÍN¿¾Ï¹ØÒ,¬¤ú¨ÆiÌÞ2šÝh’õ?ã)ÀÝ%·Èl˜¢•0›.kç˺§bæƒÌÞ0›ž³Jídü RƆAyR‡d¨À!heÙm#wAE™&¼Ë3ÁúY‹öÒ¡ÇBo;O'Ûp¤-¨¢¾õYÇλW`HOE¬éŽ=íίwçM0Ñæ°©'ïOeA–5wÅüóäÓª¤„l%3¦—Yèì®®½È{èðýˆ­žcJX¾$Vn,Å<©Lù¶úDÞ+RoV8 ¦®¶)eæRš 6ï4 þ /k)ô”P¯ÀÃ'Ïctüx”öUš^΄ÞjÞôæ ¥ê¥ßÕ ¸ðA4 ºÌBà e›¯””¥ëˆ`ÛöH‡Ty© (Rj¢žNѹ,}ï·TÆ ­G¨{Qêr¶ÂDWû’šCÒèzÅž¸aÈÔ¶é\ywqS"aÚ]l%°,¹ŸÓ¥œfxU-­*Y€M?h(¢_lŠ{î龺3wºž£Ý¢Èsb’i€÷¹E`¾ƒ2Ûª“¡‹Œ'—.d¤Ëíƒò" âugûë<0ªû7#M.=nÚÑ_Ø· w~ÄHñà£Lbn(S€‡‘ÙÝU`'‚¿³YÍã…Û<°Œ«•ý ò€Ç@ŽÜ¶&Ø€9ùN0¿(®ÎãfK¿&éÖ|,–yëÄÓùéLÌ] fXè~^eÌñ Ôý–2Ì÷Æ `óÌ:³’§(Ñó•k¦¬´l­|?ˆªŠ:¿I¼¿ŸnúuĆ‘¾ùzc=1§6¨îûñ0OAì¤"…~‹>d€'ª\ëÚê€ÙTã]¢æ®QºÐƒ:_w7nάУ÷pG(Ò03u;_îŽTlֵצ¬°ÇT†½&Ãð|6½ØŠÿ®FXd¦B_`!™ Éø‘KY®ºO?é»ónºkpc½É+3­ûˆ•ü"kŒy®g6y.@§Âv â[${¹˜š×ìlÑ/”ºìúÎɆü ^—^$CIÔÀÏ1­ö¬7%ÒYݘo†am# =®ÊFwL8DòÂcImN»©ë­GßE¢"s™ç ç5|Õ‡£§âÏ´RË0`Þ¤ÝÍÅÊÐg�‘.ƒr«’’P4˜—}åÒz8õ†Ÿ•àYºXðjÊ>gŸÆZKÓÜ$Þbze]Yå9n•S¸q1{o¼@QmX“çÄÿ9Ë@§vVtž½¼…J”^ïŸÉ\©E“­¯x6íéÃö‡ÇíaBÛ­£˜2ž6‡Í“²ÍnolŠFÇVÑûðç®y›Ã|åã •&V¥èT¥o*Æ”~Ón~W´M^±Ú°=­üÄ#2}x¥½9ÍY·zî¤Õ’éò1È Î;ÜÕ?œ^þC9ý-‰ÇÎ’OžDb‰½£ØÉVS¦u7ª¶òŠ#–S)LÖ$9ÝëÞêú½– ³!iºœb:ô;na? Ô*…”Ò¯Õˆ¬mÁ„õÍŸ¬z ”.µOÄ[síwÄfÜ; Tô5ÇÉt0OÖüÊÛUr%N øQf ×€ï&œïš1*•!¯¯â¬¼QdRa€ša›$Á×zükªƒŒ_UÊ"îì'yÏààÕÓ2´¦¼•·ô�!SIöÌD`ËäΫ;Ï)ú¥´6÷ 5ÏjߎÝE-™éË—Fª—¨ €§¦=ÔrÚýh8G®¥Á *Ç>bû§Ð*8¬ºÚ Ûÿ´¨Î|`Thÿ#ëºFÏ%ˆ„÷÷åþ ŒÖz·E,ðZѧŽy›îÔ×[xîŒL}<ö]{ÙiMŽ³ù0.u í¸IEz)ñ¡è3¨õÕ ¦h¢Ú°Õ=´Ì»µ COÌŽH’2(Ü Ñf׶8 umª’Æk´ýÎÐΕ5fJuv~7dðƒŽÝ|ÐÅq^riÂ"éæXg_ßí ð©F‡ˆM{@u%í3ûCöj Qô(¿Ã)æ¦ ïOiP9ü/ó¿æηîh;/ªÔpo …_Mç*Ä=þ+ qí߉á;ö/›ù ö´ª[/Ë¥Ý),3mlþ_�P³Èy`GbËJûêÔ;…Ìz¿c fá ýˆÌ™[@Pd¼q ÕЭV´Üf9îæI{iÇîgœ£3‰GŃ ’³ºÝs6™*¬:FŽ]?µ¾ä×l¦2•åÍ5a«XCòˆIûÓdÏýW·JžùxoªBŠÖ“ë¾Ð·ÝSBœÿó{UÔQCKË KCLmÆ”©#S`3¡ý®Ý$]e¾ÉgCƒ]¼yKÉ=ÛVãnH»;j•.H ´÷aGtjOÚ ˜;fág¬Ú«D]&v )žµ šá¬=\ŒöÓ¾vEæ‹­—¬\´^¢̲4HÝôÈ5A‹©azÓÛµbÒÎýBw¥Ãعï ú‡ûkQ7z2„«žÊ;ªœÀ+í´Ü÷¦.¸t†©¶5^ˆX3»ã½n§+:±xѯ>Sbšðpì@þgëCKa°šÉô¿§Sqç¡;ÌÓ÷Î#Et¥<O`}9fX¬¡©5¨jÕa™=víªyç®úîÌ@ïþ0tV¥!}±YB4}zýBP,/“zÃ_™$\½•Ëûj–‘xŠ3¹Ø�åAünqh[Õ ¸Q´àÜ_h]å•…ëá ¬ˆõÚ“Ù_Õ`Њs‹Š³ZpŽ œ]Nª$v°Y‘AhéÞ¤ŸÚC©søÚÚdæ,TpûzSWÉbÌ@‘¢ÆñgÐa¾??C­›-;|Q`8ÓmºÕ,2É6^è‡háñôÝ #"—NÒgð­3¢Zõôˆ^É(-í¢ÞA÷-7wÅ^vÑüî1,b4—¼ç¿`ãã b8]SA ;Ù‘D^6n‚âoÞyƒ©3 ]üãÈ©m®MAbwËÙ¤i ±µÖ&6®a¨è¯W+¸z—÷y,q¶pQ¨'ÌÙˆœ>wÊ4 ¦9Ôï½{xÄçù•þÖ É˜®wcÛƒÞ¤½Ì{Iˆǃhó¹kæäAÄãÄé‘‹WßAqRÓQgƒF°?R€ ¶\<À™wp«]bí;sƒœ`ß™[µ$­ï”9Ô{«ÿæÛï¼rí‰%ÂtŠÎP”µðe؈ù$…/Óß2`Q0QíÛ$ºó3û-ÄX(™Ø'Aþ®ë\`úEÖBÌb9xÌëT¥×÷­ìª°ø¨\…D¹sewÃ+(Ï»¹\�©'‹ùå  y½œï\-ÓÂcE±ðÞj›Òýîb }ü#`¢6Ù4àrárðÙ÷í¿ ®ŽÈX‚ÀsZ@¥¸g§-BorzšV¬‰bʾ 9;¡j`dBÿKº¢ÞŠÇ9Áp¤C°8¾{¾i‚]ÙõçÑXŒÀH?ï«@‰¿®;÷Ê"±;À½!žl­Gö µKÙ…¯÷ûhõ_ºá¨ÕÌ|‡©œŒÙxå¿ÈcgÜ8ÝÄAñiuC2±éÝÕÂãþJÍÅÛ«ë“Ú÷ûљ톞Nge¹-;Ögñ6àI‚".AõæþÞ•œî‹Z= }©l ƒhƒ—ÖU&ᘋ¼Î#6/ý¤u&‹Ê÷:cû:—ïl¦Òjp¿óøtÖ¡" ç"Hë/O6ÀtË^Úë±rÚ"±• Ø9‡ÎTƒê¼¤M¼ÐÃFÄt`é¿·x˜×¬"yÂyÂjÃúH!eÀhÝ _v'ÂW§A<J.N a[ÂËKï3™H3¬š3Ø6Lɸ@úŠ=�Kª )×GÀjüØRœe©“eÀ5zzŸ‹CVÙhs™öQ ½¥Nú³�ï?ø…]VæàÙ¬ŽtCd½šOsWä$äÐ{ÜÜäÂ&¡júË(7ÛÑöÒr=®jªÕ»Ùö�A7lúÝ´•;)Œ^¸µþ+?WË0Š©{O½ŽÔ­ÔL™Ácš*,ßÕãi¸©Š"7®dP ëUGn®Î¨™0xÌo2%>øF®(…¯ke÷Ë¥tǦ³úPT €ßî~:9{ÿÓy¬Ô®32ÇÎþƒò¢vò†!TuÍË/ Â›ð#Òo·®?¥ñ] Å»i4ä^ÅÐîHs˜pë©Ü»½XÚ’„Qœ•Ft•É‡·6óHþ`ÆB7_CŽèî yµÕg|bÆ™ÌNò n·€~’lΞح¬­~²ígVÊt™pÓ×Íåž‚ŸGõáÒµ§Õ`]çøìoë±õÔn{Y¯ßlB#’ i/tsâ©ñ*m¤b‡úCb+%¾`è(ú|¡œË|7j] ñ_{Ógi—b€åb³‹Z£ÅGLJyb3·;½ÞÔ)Ñ3zf‡©nù®X¿ ËöÉŽCì2-RãØY�]¿ ï›âêp¼a»ŽQd˜?ÓG ÀòÆÁuYÎÚÀ,¨¾Í„’zz>ëÔ+§…ú@ÕpÅ)£FÇý¼ñD¯‡ú¸ÓZüÞ?ѯdŽWÙ&K0²,„§ü«ó ­ûS×t¶ìioOÊèõª¦uÍøæV*Ž5\èÐ÷xˆ0´þTXbε=Ú}ö™ë']¿.÷Uä+5Ð:mŠ<ˆ6äÓjÖ–ì©[ Ü3Eå@XY¿BàáúÓÄWØÀ@öŠÑÑ ºó5ðt®[¦kÍÝ7® I¾�“q­ŒíÖo9‰Î講ÓØpFk8i¯‘Ó˜¡éOÚb´Ðà6\<µXŹB›½3ZºÛî"ô-Wœßí¦¹±°ö>UpU~Í^´c*ÇO¹aKí= m”E¡GŠ¦U¿§ß’Ìš|�gò‡*ßà iúÞ—+dŠJ#êº=ÑÉ_LµGœYÕƒ³z3a!Ó–÷+)®Ì›ß±{Ë©)ƒ„²µ‹¥a‡sÔœ¾L[걂OôŸØ¢£BÃu›>Ð'Dz¡ Ы�ˆiî.,CáT{lõŒ?âê[7 iдU÷V¨»„ƒG}I з `í•ÕŸ$Ò±µb4öÿ¼&é»ãdZwLJû^«3É}d™¹8§Ùz ÛW‚•™;J¨[¾{(ÅTž8¼V‚3”c·&µ óø üšZÏŸêÈ‘¯a^„ªãÜ3œ-ù o"I¬=•�ÜtF…ЮÝ@ΟRÇ´Á–6Ñw<¾Ç£*ð4.:`¢w«ã!Þ¢ZóÝf¨‘ß&ŠMǾjþzÓ�¶'oÐkÚõß´í­\eªÞa¤ü7ݪˆ€Á=ƒ¿¨õŸÙ†š-ÙìúAäÇ:òá˜0B†× ªa2Õ |t³Ÿ¦Pl µ‚0vh{êëÝDG�–ÿS”溇SöíO<ããÊÔÕý‰—æâ­w¯r™ÌðS±6{4XDÝÏS‡Ñ¶É0­?Ãs£†,»’l©´’M8¸écò™ÓQ*r[Ñú$ÚN‡Ó½D­J}¬›ÌC~Æ·«»IáÈôw½nÞ¥êô^«òªÞja\àÇ=}tòÚ;p§Õ{b3;{ñbÞ—–îЋ=)¼Ñ1î9“ÛdTð¾uˆÓ¢(Ôñ4gŒÿøæÖVÜ, ”£¢ð¯¸zßæ£H¡2ƒ5›fJ›6Ú†AyE‚õú¡ub’y\¤TÄR˜c«Ú°7ÆO^»9Þ›ÏKøX?TWu_´6;�Åhé?«ÖäS£«þ˜ ÕŠœé\ûæ,`›[1oÇšOZ‹ó,LC.7 ¾{PÈ*¾fPŽHÅŽG«¶Œž â ‹ƒò¹‹˜Ê˜×»ôeË 1,Õ„ 4ÒælÖ͹Û1ß�È°•ázÛ»QÏ£{ä)]›V ý~üÔíZ€6Þ4;5²ú13ÄõèJuõ™w1Pþz â7 Yõ ÷"ðpP$·Í(ˆö…á³ÒûJÖX¹9äkÌì¨ }‰tÚOTI'A9ª°ÄD|óΤ4HcpFHCåÏëéÜ©¸^J#a°*_ÛfÞÉ_}}8õ†ˆŒÆ"ö× Â4uU<…T¨ki·6‘ÙÕ™Äú¥'õ‚Z‘-ŒÏK¡&G[|`ƒÍ´à§L,8@Ó·!~JßñÛ)já+ˆæèðN˜L•£ÂÅ™I„¦th=À‡ 7â¾È€T‰CC$ÚwTÕ;…ÁJ2ÒÓF<ÂíáðL‡9Ê®!Ü ·ì‘0­¥©ù ý'*½).;^ˆMÌÙÓœDæð±ì— b”#)6Û8t áó©hÀ´¤)þ¶î¡kÍÌqq^û©¨Oªší•égOe5³Y`ëºÁL7×ú2&1«(Ú ²t2mOý¾ÓwßÊŽV ±~ºo3º½Q¯WàµT9Á{M‡ß¤2¿§Vy ÷H¬™Oª±…uR,T™/t„i®$ªöXun$µ*‚ÓòdHŒ½¸#ùP]K4¾xק×ð‘Mmý_׎%’Š¦° b;SŠ ~«Æ~Ë/xi`%£Ê¨Kö´»BLÿ$;¨gT-@gK¶3zï*úO¢JŒ–o1n3º9Ê0ê28ý4:|Ù¸3Bíú&oÀy¤ ¸§h§©škžEËŠµh»bj€%[ÿÁÌ|w�çèà8"&¨$[xÍÌ;ö´tvæ‹ ªgÍ7^l7¢%ÿóÀ<HÌú2ã> #¿–_ÕȆkëÕ1 Ú)éæ€áôðÖôÄøIž4kGMÐá°rq☵bG¹ïh§†v½l0ï¹Ln,at³«(ŒLÝ3\aZ<*ÏÓ‘•ÑÚ˜gGíßÖŠö éúúz:z‚|{Zø2ÁÔ)âòúþë§ÃÐ\n1†¾XÓ‚U–ºN%ˆŸHýÚ:?–®ÿà¿[0{Îß»ºí—äÆ>wçÒù"Óï]ç¦õ”oaÙß 'ï(^掸–£Ò™¦hU7| A¥ÈßfJÿ‘ÿqåQÖsV%ß�*aSîœÇʲaL 8t©�íÕ+¢¸qäùöÃUÉïGŸùzâ®ãÝq:ìÍ?ÇnÇP^n¯Öé aY±À†a —²|‹št’[ë8»2Ó¤„4t<³‡ÙÏ`_DÔàÎÁ¹pXÂLl ºaö­röõ;ݲÝJåÝø‘²žâI÷¤rÅ>c [6A"Ëñ­ ×¿Ó-‹ÂÄú•¼Ÿ(ÇïÊáAÇ‚JóAŽH1ß~FÚôÄWX \Š@½’6=÷/ƒ£Ý˜Žì‘EÈÚÓµ.G’,€‰¨‘à5Ÿüm}Ô±� ÷'óÕÕ7^­)Û*:ăÀr Zà{í°¬ð4¸1nb(Íá®gaii>¦ˆ¸ƒOÎ5ÿç·hoñIßé;z j\èjåeåDòZØð7| ‡R qáòñeŸkÀûô¬¢ôœ“<ÐÆí¡µx�$d¬ù}ßƆœÐoˆ|í8\m(f-1ö5øÜ#^1•tÜÐÂËm¿,A·óìàç¦bt X?ìú•>4Éü-Ãk»´bÊèrh‡�2Õ üƒB8øúÀ?ÑÆž+ÂFV­¤2¸†J›°û«Sº ÛžœÄ\ï%úÚ‹kyÔÄÊíg†¦ùYtœ¯“ŒÕÁ¢~"1m rŒW#>;§Š½÷bîáë²éÇÌR«,„h.aE>§vwš{±Ï%e¼Í‰ÂUÜ)+�™‘Yùq=§ê#gPçÇX¦ð‹;4¬x7×é˳¤Pñ5yÝÕéˆÅbšŸNKh[ÿŠÇŸ…æ¹â ¤­Ñ½ô(Ÿ•œÓë3Æ(6ŒWQoÂ4{¦<Å"ù+f�ÃËEÍéÌöûa°ˆ\ß%e› ÊsÃÓàfU´~™ÖÁ<W�KÍiùz£v rÕ´÷TX¢1˜Ø”ˆËsfÍççŽ=NI€,´—7ÌwÑ°—ã!‘'{°ÇÝ^wüèÄ,êf¢l"o'§\‡‡Þjü!¦  žxXÁÖ|å©öüqå`4ÝÙì2#WHJDÛž1Åf¶£#:’'JXßÀ”l¥h~ö-®ÀŽbA©äÁ°Éƒp­Uv1" P¥9(¶öŸÿȃÂÄ¡4G*…·kÛ…÷ëö8z)w/Â"O­Z„ŽL=CQa¿ë,²Æ°Y‚÷7®_}N(+AÒZgѼâ³ñJwxn.Tã^Ìó“Ô;°8ì?­qJ²À�¿9™çŸâ§ïFC3¥VÑPé¹wÆyïÆÎ :öÊ“ºßÕKËÅú¤Å8n!óaYp8?V‡zµUúÞŒ?n4|i?õÑm˜Ì›gÔ¨ÌoMñì«£ZÈè=›­ôΊq6¢ìþšéeA}ÊÌ·y 8M€4ÌŸž¯´J¡Ý°u„gæ¢2Ì|®žŸ÷Ý?¤€ÙÈÖoöEH|îA Jg›§b¯GÉÂ’È‹¡%­,=ÇûÓZ ȦŠ`{¢ÕŽ½7ŽiñýEl^Í ºiú¥7Zš/‹QÊ´}³ñ¯ó3¶]‡ðÛ©Xº’våÖÑÝQ"QÇvW?Pm0'™ƒˆ’S=ýem_Q…ήX_fDôk¸YõIÜúÔßJ†¡¯Í˜wM´Qf©S‹2 ¡6¼h3/§AÐ5‚v5JÀè7œ}¶ÛÝv¶8‰“èj— à š•àÑî›S_»h{ϵöÞÏ®iPéÂg6#øóáI—0l[?X±SÚú·“w;/¼ÎOy¨*‚°Ñiɺïpµä }~•Ñ\zAPÓSí`Ž-äè&÷*°•%F´.¦Oã„訫¿„8ÀžAz¾]5J&)JŽ£¶:¡)"tc¹úü=ýÚrIn&Ç.fës7 fl'º²ÐŠµ¼„oèksçÆ'ջʨ”¡˜l,§ƒ¿®è}~‹-r-ÐJO$À: lÉ«ßj€¹60pä€\ïÙÎ�ø‡wØ=ia¤žö½´›ÕËûìõ×�ëè6‡éWØ_YúWŠÄã¦dEb±_û‚"lúdºÕÇ#Ñ[ßï: Võ(ŽŒÚ(;ç®·:$•È¦9ê+¶¹‘#�‰A4à”íƵfðœêý‰Àúðeq"t¬à;ûÒ8õt¿ŽÃ`‡Lï>ŠC\ ¾QS|(w«®…€8@² _×#™¼¦û âø‘kÆäF¿ç�9™ÔªÒp¦ 9|C0çÄv7 ½éEY³<[šzž×ôd?ON“ÃLî}—Ê6éK}_‡8}º82ã%8U­XÃÐÑ{éLGDŒ¹ùt¸t¢2#–”™¶ïÔíEŠ„ÿºÔ^2 ŠlðL&EÖv[ùçÖkŠfw(@¤bB? 䌃ÚòRY/±Lñü»îÞ»Å9 ^ŸpŒ§½„ïìVÔ<1ßx‘ éI\K ÓÍ؆ ½žÆÃ=B°…™xœˆßmÖ ¾åu?¿}ìz:ÙÅæö÷f·ÉÒK!f@$Cï€Õ }øe°Ý'a๋îxÄì…ŽÉS_+‚é|@­Åƒ5Øãöõ™‡·ºå¾Ç«%ÖË°2·h[SI2)U¤B˜ÃüMg‰çnßÈýóDT- [°4Ó™ò³¾qX×úx¬WÛû²v¥ÙHó1£½Ü¨VÂñ�P-�T`kº(…=ŸYLšëVnÄó±Jœ^Mþ°eÂO­(ÑÐSv¦R7ºzO«Ý:w£¼07ZÈöª—œývÙT/6É1°x¯d¹ýÉÓz&[$Ë"¸Nõþ`¡ÍDºÓ}ªcj–VÈ‘–OÚèÔ¹f¼ 5g„ùš"Ȧ?]ÓœÌs_wC}zÛœ9Æ-Þ¡ÞK¤<TVÄ[;_ÉMê&C¦@-ŽOÈ'�€î!’ýimC4½¬Ñé]U¸è?Ié¬@õvj² m¬+é‹—¶òiwèç‡8ë(]XÔ!+Ò ýTt.ÆaÜéðí  ÕU¶p«ñÛï?âžxóhQÅhëˆëkg~@iFðÛ?‰ŽáÙtEï÷u915ÛUu§EDÄEÏT�Mx–ËðѽrìýÒ8ÖCV(?-¥—ªµÚ@ån@|\:ObÛ|à,¼“zßwót‡ã&nD$õíD× �xô£X²†Ž%Ln~ e±$߈w{¤o^}éL¼íumQ“wDÔ¿—S_øÍFÜvø]£ÛØÀ e¦êV=‰ŸR$ùL¡Tÿ­é»uñ¤¸£oü®SéX?~õƒvñ¯žöÓÇà‹>•Üšc�qD¶bD„9S™—>bÝ^¸qæ§ÍKWѬØûbåw, |ÜmT#Ü0éÐjÿtw~É6·Âš+‡>aw—ØÒ£#vBb»kä4kp™…´¡/÷%8b  R rxxÑ)Õa„§µÂ4C'oi6rÛA]Î6ãn?©¬ªp˜ï Úoþ§ ³“hW † ãèÉöô?Þí­L/U;‚õ±*8"²T³º·2šå*íGÛ ”1y·F¡8&6}gHðVQüΫá`8‘Ô4$�vH†ÖM‡(€Ó™K öÒîp+´Øq0ThðL™¤jñ¨ÖÀ€¼®K¤#=X�¾ÏR\÷æ(ÛԚ^¤Fz4°o…ã2oݱå¦ÏƒüK³ÇmݯK½8ÀÔ LõÙ “GvÙã1‰0+,¢´Ìü~‚ŽçßU]3Ê ùÄA¦W'ô¾ö$«d¯1÷(ÌTt/¸©¬ŠEß`OóÒ!"¸Œ™�ÀÚØvo!Ì,_‡òNþ Œ­nãþž xýS“˜*ý·àõ¤ð�!Û %Aõyv´,ZRȃU‘{¤Líª³hQ€ÇÀÓUA¹½8Y>&TAK¯Â,¿žÀ¾¯ÑÞH�Y„Ǭ㶤*éÑaÅÂ&K?ÑØJ¨ÀÔÓY¿<.²ãºÉ¼’vät¯_ aÞÎýg×?†Hß’õ£H §Wfú¯œ"­ÝReœ"yúê:oÌÈ@'…)õŠÓûñÀÕAäpËÐ=»6Æ.ôˆ `ˆÓ¯@Ÿ*Ø`³™7T¸2õļ\…ü4ô‰[p‚Aöø©´‚Íô‰gfjðˆ€ÍY_è]ÊYÆË°ï³*ÈFmúáq3Ê» 8¸v›u @ÛPïÞÌ¢ü·Àìæ¾4meŒ‘†. ⯭§2ÅÊpFë·s€ØŸñÆÒ—†«øY'ù¬¦G»¨sôôßúŠû’MèJÂN=ŒÑbWu³e¾£GW©oû_£?huwz츹Á4©¿íÅpDÎ’+qýéU•™‘¸ÝœR:¸¶C'Ðýö]¥.p™¢‡©¯7uiY¸Ó‰§à”œdAh“0$»©®WV1’rii1Úì„“žï’“ÊÓ<gQ®Í‰nL<h-‡óÅ ŒÃSMKÐ$ïê6˜¸‰"²ö軞æHíIŽ‰®Ž‘é ·ZßZ(\¸òäßhÙÄÚf« ú–˜E«´  .¨F¤ÜùmÍ!FôYNxÊõYÕµŸdÆyl¡Ar~4C¤kg‘\wXÂVÍ71LšÉà‚WÒò{‰z™Qa35&XÒóËg¯u{øJLúû*£\ÙÁëFF;¯˜½ÅV“{•´IÇ-ळJ« º“H°{X‘ü~¦�U‘ùr-E0]Ð4´+]sÁ<àš^:@§]ó¢"÷í)£4òM؇¾h|ì½o-“cvãšF]»?!¹ù}{sÉ•¬Ó&N}ªû¦^b¬B¬ôÚ+'ífßðÏý"ôYÂô§­/YYhra<‹<99ÁÁ,:¸,ïýĺåâv‡9 HtvÏĉ5ºÂº©Šjx>?­—âÈ ~܇7yn/j¶Ÿ«í®[Û5BTW󶴴Çf¤ö .óÕóhËì?Øç¡uC‡ýÁñnEÙÄO`pV‹Àœžló¤½â«&0]£}-2hÿR Œ²Ô—^H _©ããl‚S7¦á0¡‰Bú2ÈÈsÍz탪y·ÈBk2B»™Âi4L®Žž€]aG3×ÿr$R,¸Á1mèªÔŠáÁ¬„Aåƒ/J8�/×÷>Ì rk¸ùwGu„Á !¤ˆm Õ“€0Õnü`ò‰ëQAR{—€WKµåzëUè£òÂœ 2HºZ-Ž+Ê® ²²]Â6uk^€ ùo”‚-�Mz+5 Ç^Õè_¼¼ÏxÀ0}& ‘6”ë „uîøè~‘¨Ç®FfÝ£óPåèõ.8"ql ¦.Y" ÏßÓ KKŽkiLÂ2£ °ïÀß .’4|²äÖäÂØáuÛ®ŹáŒ_¥èïÜëtËát¤}VX µ uëZ³Ãh”±oSÝïžút'Ež{8!h�TAÜ6æü†¥s·ÙY“Œ,L‚’n׎©øv¿®ÃS†WÄ@f-“ð7u%£Ÿ¯zÈ®°ÑÄ5¬f)ÖNDÙe{‰`膒‰Z”åÆGXE2Í´0|‘¨—£¢%3šŸŠn>¬T8Ý´¤Mò‡b `§MFÔ]b¤™ï‚º¾Ý»×UÙÄTMª:¢ØÙQ¶ˆ®Øt¬{1C翪³¬ZpÅʽj‡ØçZ¢¹ÁÊßÒB-ˆÖÀ·^Àz$ᢩŽ1G …œ³ª+!¼1]ÚΉºÏ[€„tË £ÔÚ'G¦©Ÿ³ÿ}ñõÌW¥E 7pèEÜ™æ½äàÇž8= –nzz i{ö|v=,™<gŠÅÂ~ÔLs·%˜;¼d¬¥Ç ºk_S5¥uÝîø;ßµã¤ôÙŽtH6SMÍ­OÕTšŠçÉW[z±Í¦cm£#P™Ö¿{.h •ÐùÂ?—dó×&snötÇ“ˆ$¥¡§zõ«[ãç 8.ÞäiiÔWäð‘$ƒ47êdµŸ÷Íòß'ž›9:|–(«7c}tf/øǵâ’u ‘„vðe£]wÈi3ýÜÅÔ§Ã,‘¶³)nÄ¡ %áôkY»(q†œ@ˆ¡ŸF ̤C¨’áh©âä|Ù9»ß@«’Åà/r$HœP0âRÝ|'BsO8KQ‘8©¶íí§¾ _žhͶf­ Óg‚ü7w;¾ñ¬tš­Wöi¿7ž­ÞpøSç!´2ÐM1TöŸœ¦*l Z#‡@Tß=ò\_C–ã´·:)»£`Ti¾9îH_:¶Ò˜a^®€ñ¥Ø¢Ä‚ U½CÜ#øA3Áu±JcxÕ´ÕwïVw'`1õž¿’¬{¢]W.©"}¢³&¾™4Xÿ꥙…]1j87Ã_5ùª=þIsšÍBäÆÊéÖ+I~CLk,/X/Ȧ©›¾}õÕ¡îy@é]IJ2ÖåƼ٧–&ZgÊëe¶ וÅåƒJ=Ë|aµhE´ùºÕª×Óò7*¬EèK®S9t´HËYÐ3øôØ ÄH\BÝ—Š5wñ —SàÕ–×°}j½ö 8?XTÜI®Î<;§�`בá,C›Ž‘>K¯Oì {ñã;´ "à9b?‰ÓÂ2 ߎbBò® 0)Ej’tþL & ñ‚ë|èOÕ­c–´® 딼qíƵ&Ht]¸´ç*èêPiSUqd‹ðLHk#iÿžúÁUÛwLÕ^´X‹C#k…fMåv›,0£ @[n<Ù×'ä}W0!‡ ÂĩÂâ…€áCŠmvÅxŽ‰ßXÆ$¹5í‹dlq.Ùë,òîΗ'4®ÞÅ[ïê(Q_êÞª‰rÜŒ]ÕQ1Óô\•ÕjÇú‚³ÖÖ‘ú#s4ã©ø=èÊÃáu”ä>u…ù:‚ÑÈ—‡f£[u¬O½e”%9n‰ôˆœ·ñ?NlÖ. â~ðD¨ˆoT«¤Ù ¯ù^EqQ&±Uû¤µyþCìéhõDé,¼i¶# ôA¿îö9Ò@$É/à nª^5´©”¹Ëeû/š9ç…/ )­VCë̉ĽN™»q:­¢—²‘ãùQsRq ¡%:iYPmõoaþÃqÒiîˆß9q‰ïuÑ6]˘·;M´É´cI—Œ°MÆQ)9¡‰J¸W·x*÷^·ÿû•ë›ur3£i°Ëß&{2œDq<Ç� Ê°[¶ñdÍ´Ti¸�„lÀõoŽ(|1tXß…7°JøO8+S+YäÝ6˜ìI‡¿ëRRg\½uÓÖX@E{?ü*ŠÁRìÁâº] Ðߣ¬ŠÈ ¹Q=ŽYÓ•Ãt|×+ ëÀé÷úØ]iYT¡4͵Ÿc…§¦™ŽÎÎDó²6½DVuèT±ú±ëÍ}P8@—ßoÌå…O’¢½¸E×ïÝNØYgž§7ä,[*@ܨ}ý¾­W‡ñ´¿é›äŠ c£,ó1C¹ö­Í¬ý Ö±T´ƒ ð¬Ãš«¡«Žt›”ööEÛŠM×á˜ÑÈhâ"-�ÜY…çR¹6Ðyô"¾'\î2Øœ ÅLâÌ [c5ò e¹5b¼ íD;ý^È7,lhõ¬ZúŸ[‰t>õk4¹%·£¦§W º³U‹£ÃnµÍ³ kß=ØØm.éd9¸+ÿô­lnYÄþ±Y™š: ¿6˜?©Öþzæ†]#&+³LÕd$³ìgÓF¤¨ëtHS¯AS°þ3˜é»æ;‰XaÅ[åÖ~d˜ƒÜï '*¡ÎC  ν…Fb›ܾÑú°þ‰‘Q–R¨t}9”mý\#o=Ó0Rç8¾í‹ ݈¹¦uY¼ë)ÁbH8¢/Á{+º »BÈŒY´©#ë›ñ¦SÝ Ù´ÇÁ«[ë[¾8.ýLƒ­2©ŽÚÚZ ˆ¢÷F1b×d£þÐ §Z<‚î9vƒãçd±‡°bÇ.¥°ï›d°Ú•ƒËwV•eTøBÏI°;¢ïøU{Ÿ»¦¤‘"-V5VÆLç‰dÅ,!¬»~÷5ñHΌӡ2@Ûº÷ÆëQ¡²Ì©i4ól®h¾Üˆx$„KÑŒu3¹o¸bE¶wQŠšé—ÃPìs_EщK¦Ò#æRìýr,¹=5a¯GTQZr‡x øg?Lˆÿ((Ám¶{Ú»ë öœ/!í5Z½Ë;mØȳßPÈ̸¡z&9uŽöÿ~êwúël¥:GJ©°âÝ•®ž› Á*Ý_†Y&vf}­]àý½Ð¬¦ÿæÄÆ æõ5¿ýçeæÀÂ’qrQ«ýv$€ÍÎå¯!å^AÏEÉ’P’ÀŒ“jÃî ø)BM°ú¶™ü CÎ*»8QÙöþåP Úyf[–W÷áY­¢2î7T}©¤ÊÒ«eŒnöæ8>[¤=›¾¢o®UH 0ãÃŧhŠÂÃñAi‘yQ. :ÔUŸ­áE£9O£5Jƒ´7ÞÀX™8Áâ_DÏ?†pñ°³yŠµòÏÈsJaÕ :;Èpæë³f>”ÃÕ«º¥Ã»Ö¥ ƒišZ×·gpeé` °Øœ(”¤£Î%0„¦j¨AÎ4 )0Tš¶‡Ù»‚ø'ÇÂ…Z'> x‡i„žÕÚÆéúónðè·^wÄ]^¯ÿÊ!Äï MkbR=s+˜ltuû¹Ê‘q9™d_K³IyÑÿÈÊ´ãÞoç¾YVùÀ–8èc:m.Š®ªb–åÆ!£ g'‹ð1Îœ¦, qYyª^ôi{¸œ7 0‡ý/ÝŠÙä/‡käàUè¡ø‘*ïé.ÇW/ø àБ«°„AÎÁ¿Q ]Æ©ŒÁãFý˜àÁ¥E÷Cçl¼_š{'Q~¥ûºvÙþ5=6‡’E…ø¿#j«Ó²è¡ó—C¡Ê¦ö!¸µ‘6¾g,ûÌb6‰-ºUÚ¢¾lý¥ºO�w]hÓ×öè}Ô£ôz•iá3ËÃRàMùF‘ kà  ?XYNÖs'ò5Ce'ÄKN$Ä+LªŒ%8Ûx¼ÍÔüè%ûÒ¼òy]QŦ«éñh�b×ÌdO#ÖRÂs»;Ì?³^Ͳ…¡…E*Þè6>õv™¶°%?ç-ì~ú§°ñ4ñM´!ªåíÍÆŸk¦¡™'»ßa '¾–vY|Ä™ot½‹æ¢nà„\Œ‰ªI¿ªw‘.Ôv`~„îy:ë/çPÎ’’?\‰Eéê2vøž?‘Ð[oˆ1!{³ìòÓêcÍ Ñn³½zw€éûç0ÅlB×|º(.®¡Œzúb „�_ìa¡/ÖKI×™îíéd=>(9XfDˆ"ºl¿G¢èä73CZ0Jb÷ \–³Z.$|Ìîú†iB¿+óÀ;”èQbÄÓèŒR¢ ãOíÞ·+)®"S‘‘…3‘2‚ô-¨®õ÷ŸñOµa '1œ)–[ †$š—ÜiÄ(cw€åHbmÕOTÕx Îåz$ï•Î]‹E(š1 R'(Ë)åašnõa¬ÜÕ#€¸ŒýÙ3ê}೜þZn§œÜûxÁWÔ'¿d€35´Ã2kÚUÁp·9(¼kÚw<9ú𯙮Y h™jfÁy(èYÏ Ù©„¦-Þ³òOú•õp?ÙˆâÊï3…ðŸ(ƒÒ8LƬAÁ…^7p_Úy×bü`^¶Òü3/¾æ¹ßæv›ý_WÇl/>‹†‹ÂNê‹žà×îÐ*&‹ú™‡âwj¥>b䷢ïã§ß™œÆ ¯J`‡(=¬ÃbK!b¶Ìzé¥R5üöâ–?¹èÇP¡Óã³ö�ñœMs\ggʪ‡pG·tÐOÇor|׳'±= §gfÓVC°¦êpî¨ü9Áïïv"—f>€ÎÎqKÓÚRI¹R¡3×øÒ‹ –‰U`soï ,*Ž]´`ÀŸ'¸ÓyØžQG_mw ɾ0™ƒè™]aØ•²i¦èT­ü¡]µÚ‹GbÞw5»¥ÚûñúôÐ#Õ›‘B¿ʈ¬6HÇ+=ž £È*‡f'’jÇ÷é%û†¢\ÐêØ÷' rÇKŒ^ÂyÀ¿¯ÿ!ºsÇ£,vƒd¹ï{tR7t”d“R6Ï«=©ˆ‹˜n &õÀ‘ëF¤ß­L{£ƒ,ÄÊé©7CJ'½mܧÐVß­æø«½²C¥•C¸'n_]7ÐO˜$¶à–³â¾ÙvÖ0«âl\8³ Õ8 =Ä*Á€®:yV„#ÕL[;£\ŽÇ+†=¡œ•Êjã|›æj{jaP€V£SÌ¥DÌB)Æç.1 œ“2Ð%G a¹9”c�ÿÛ±³oûî<½¤Ôh‹ 8|Ñom”,I®i‘(£Ý}±*ãøn<Wc$F8AOŽÑ³ðúºta;SDÞ ³§]tv|Ðwf¸Uç–Âz>i[ HéõáKæ'}ýz]BG^‘.hóŸêN¹2<ÕEàXmëNQãiÃ,Q}¥ 3°‰ü¶žn­ƒ"+—%ª›¡zD–PÇšj#åÏš#:C>å:³Í&Ï8Ó¨PŠ–‰Au)µÉ “/žáÚ‹û8_¿€Kpf®f dìœ.ÃèÕ±Ë¹Æ  Ò�Iã©ŒçÄÿ‘öÊ}’85±ñ| þzçÄ|h[£KÁ-'ÂŒ×(^§áš®˜©ä“Ì:)¤ÖñjÕkƒ<*Ã%¼Yª¾}†³ C?«¤LeÚTAµtN.½êÉ`Oêzr¾ïÜÄ•öÊ™ýUsãélÇ‚Æ‘£²¶)é¡šÂÍ»ä»ñH:ÄM¸}ŽÎAÑkW¤4âF¹A& ÙÆh7ˆüqýåi†ˆ±Û"Ƶ¯ Ê…‚IüÀ4öø$œÎ4²’Ñò«b­·<U¨iÛõ\¼69OBßÜ*ÌèEW]ç€Ãc½éë«þËw9—ŽfF”`bˆÄéà PL¤ý0ÉÀŠj/{a ÒžÝ#f ÂWúá Ê#kY­qúDñEO ƒjzt‰M~`YˆõÌŒñ¡óɳ¹Çßbºþq3˜B:tÁ§ÍU%ø Uä…¥…˜/¯¶I{ó™èƒwdÙH€P#«Èâ½ê©[Ú’JZæ·,7Ÿû,&‘2m§úŒ"¢{bs掆ĨR­tƒ“Úº¤`µ±Á–{Š*¾Î´yÅkÕêvän×ÈͶ_t(öÊGGÕ€ÙÿºE?¾û ¤ßö0¦¢0Ò`äiÁ˜$8ž_íç‰ë ³ÆY»iJ³EҞΓúâ€q<3òDüŸÎgm½‰èœoº“cvÉ°Æõ¿õ»qRr™AìŽpñ^«9ªún¾7m##wÇÛÅhr³=ý<x“üϼi,{wX�ߟgŠßý+_€–—!4ÆrŠNžá•´‰yv&Y%Ó¸íðZŸ;‹=Á1Át£l)-§(1â&b ”Óˆ~U¬ä™_¬K‰”{�Ëh]ç�êÜ…ï]Ýùe±¨N Šz´ÚÉ#mPõoÖÏkÞq`^6Y¢8r Gœo°­dµ¼ÞôS’;]󙇕tö„#}ÞZéz’¥Ùú‡¬‡ês·¿uœKÂئ5 ÇÁÍXÕ$ VO‰ûq!ÂF�çÚ‹{Rɹ·ˆJDª‚bÔ¶,ŠëæÔƒ7×j,67Ž­†cYF,ÈqŸÇ6å8yZÓ“M{­®²Š-š¤¥Õ;Ã>¹wïÊ·odÝÉΠOYIôÓuÏ'¥ë‘Pü¼µ°Œ]ÃÕ�.IPž¾’ªÀª†×HÇœÈKÜ»äD½žW¼k}µ _HPýýÎ(x÷‰ÉëæpþYS7ux9Vß\+ß­¼{Y™E2›u¾ßÉw´¯ ‹‰ÒmL‡+ ÆM$ý»ã隈¡ŽÐ­ú^êÁ¶'D|3Lƒ} éÉ$ÞƒÁþÇÞÓ¸çTÅ+UæÑÈ1Þ-cŠØo°bq2°×^Wžv%d-!ò°‡”“y™L éÌßûEe‹{ÄwxË$ôÝ-•¥N,M>å½Ùì(«À‚µ·n(ÊlµI…¶Š¸&2âFbÀ+Êø.OOÌ]Úœâ úl< 'D&§$å¸äwXåUäTÀÖX% R‹íI × †ÄŸ³•Œ2n0 èØŽß•Ïç@_zk=5d±¸VuÛÞ@RúD{Êð™"ò©zŠÛzàòÖÖ”\õr6Zotp©¶ßÑF²…ÙDì¶9-Çiméö¬IÜ9íÌ'¦•x‚L~``i´±å’þTêœ_"C¢¹ :ãlŠ³>�JЋU±ÙÓ‡¾ÀâžWäƒÙ4^ÊïR @™cvTÛ Ù3'oœ*îybã~êùúÞ1øM·¨öŒá_t²&I²ð\2ó o¦|X)²ïS#ƒ×ŸŠ ]Ÿ•ezý”¦ÈÃãi ÖysúûÖ;7?0‡§owåG×&¯Âì[›É;A)÷œi½_öšÇÒOΗÉüSUÕ€î3}Û£= nmõ§›ôÿÈïÆ"Ïog¬V>Alkh{³G®XSÙ1æ+ò'Iìw# Z! ëÌ¢„AGÏdðJ�H]Gå“ô?•-qÏvÚçÄ¢´NëñóÓs;š/¢bc ¿A gñb¨eltUΔ} ¡ÃªèÂ^¾<7Tœ‹´è°.ìüÀˆâÏ2@N’ŸìÅ¢5[F^bD&J¤òFw;ÉEcA™Æ¢×ì:îW¿R·@;ºöÞ¦µ±µbU<Ïa8¹:;¶(Åp9jÌëƒùgºà4—Áyi­“xöØòvÿÖjÓhUíý— :v7Œ´ŸzÀ÷Þn‚˜÷Ϭ[Y?pÒÿÐEªòÒ¡T«‰lÒjͲÝï«¢¿-¬ÉSX _ ÕÎøÔº±-¬VÇáSE²Ãëú%ݹH`Eª%HúŒ´$áŽvd¼i:,Äž³iQ; ÏQ_Í2LÕƒ5âê9”5ƒÄ‘5Ó¥/(îÅŒº)Åç;:%{à—�ÑïnˆR_k©ƒ‘-MLç6´‡)úîeWzÐܘ‹G[a°¬Km?ÿi'ÎÒ2÷Hßv»¡"í¸öx²â\#gS˜ÝÕíYlq¬±QD›tJD ƒ~EÙxí(Ö?Cs|±-Ê:[ôå;S€o¿”Ðìz˜Tñ)áL_—\³²ríyæšö5%Aá—²¹‘UăA,MTãϸ=a2ì±Ù@æ–†Í%"†?8¼l!rÔ¹¥‘$<µ™:>Ìî6ÌŸMÞâ¨XŒ¨.„æ]t9+æJ|¿.RÍcªûŸ˜Nšg2Óæêð·3G£›´=aºe§Áh! ‰¨P ±1/¿q²‰«Âíbž§m7”¬tj’‘FõR²ùµ…š*³Ð0¡‹€›^í»Ç½\š¤}׉f®¢Ÿ•Ï…œ´Õ亪òh‹ëãݱ°Örfœ¤Ö§¡*EI±¿ð\‰ RÑj1¯}Ož‘Q’!”'é#ÏKXaö>xOûi¿Åï¼Dé£J0¦ÚÃÑÓ›6ä]‹|±JU1Êj Á…£:ê 1áHëÚš«îíL¿¶,š(7q†^=ðïŒ òb¡ ›Ò–(‚¤íÕ„ŒóÈm9k8/ ÕæÍî#ch#}øôN··¾«!*ÇvÀ62î=VUH%_ª<‰††Mu^²¤³3<Ôb[cM vý†…(ŽDÊóåÓ–ï°‹r[bÈÝÜG<f†=¥/NŠÉœ˜ÏÞhú>žþ;h=·EL³ 1›" Ê£%ø•K?kñé£=ÄÉïòÝã²m½¤füD]á;\sËËK÷éŠÌéF$b¤ïƒ‡ýÛT¢_[÷ÿ¢Ãݶ„Êïõnþ‹ÆÆ®ÞÛJ퇞y”-³W–[®èÛ¥=ž¡V¬ùϤ–Ò—Ì…k1*ˆ»w³PEÀæ´ó¤v§Õi0öæÞ¥Äÿ;tö+†B¼Ñu¦î¢Õ>X8旅óM{É!(ñZ‘KäAXëì fH_–Hݳըl¿o%çüs?C(]Áø:>­½ö(:\YZhË(,i‰<‚½ÒÁbg¾(f„µŠ\¥î¼–ç\/ˆ‡Ô˜ŒÃÀ³B-»Ø–-æã†w3J«ˆö &0GàKyÞðŠ^€5ë–†>=¿hdŸZ!§¥:ÿˆ ¬6;Oºåð„Äõ†¥Ìoò =Yß„°â¶voFÅŠ¦ÿ±¸Sºðë¤G1Ÿáfz²-Fv6c¢44&SŽo¬f``¤ˆ)\AØPÅ™ôÆo*©<@Sa ¯³ |לÞh³;‰ºùðÁÍ¥eÌ'ö‚ʼnÀ¿õ$ø}õðË•Q�h‘xÇ®U’߸i 7ûÓ±ž”\á“uÌžf¦»&†hô ×)ìåµ–D"ÏŒ®nwZHð4‡~Ãïy€±½Œoó¥]ïúoÞZh·Ç&6Uv¶.C=LMÍ=éºk>Ϲb;Ócû,h’$(kí.g¬Þ¿²ãß¹[Iü¢¢d컉Qà6T†½nt´Øê‹,.åb´y8:@ïêöëGårÈ–C¢nMÛ»²gÍ”tæiÂ:Ø0Œ¥˜SlÙܼûC_Ì73cÂã¼{·,bTYÔ•(I^9–Æ;V™öw�Ö¶Ç%8G4,ÎEÕö¨€ö—EcYº»¢Í*j`·°–´È|%(CEËmDÖfhk bžã+†‰iäãØYS: ÉÉ™UڌʜÎÏÚ©N@G¸Hà™ùQÛ�ÊÓ²ãwè̘ ªÌ™`‚›ªl²€mÚÆûËtîiÙè¹Ñ+”æïz2 øTP‰&Q6´g¯ëKKhIw²ñYtÍbþû“ µy òJ .ÊšK&)3Þ›fSý¥çÌ ™ÏM‡/çµ=n(Ž'«^ñ,brƒ;ªyxª¬¯ßÙM'J’ž*$W{€äO£úÁ¤LöÄX€'{kÌñCŸØŸ/T¤èût¬ª:Š¾»ôùÒ ¼èCEó†ËÕ¸îí]õøŠÊÈ€»M!Ü4:T0‘\ûHφBá‡1Wð.ïÍÃ"˜Ø‹ÅRŠ{Qýì²0ú 5_x¬Ë¥Iæi¹Sú?Q¾+q‚õÖÉŠÆò®æÞ·¼tµñXó$ç—`ctÚ)H Ÿ6 7Ñm<í—îÍ3«F,Zk¨ ÜpÁÏ<톥õ%ŠóÆk)«t†t”‡ •úîŸõ¥§›yk6a¡Mh�°ÐG?ÐÓ?Ê–T™aëØ1³ä_å›=ħ+‘mOë€U°Û¾ ²AèË\0r¨Ç!Ã6žðÒ½gu0MüZa1|ˆ0Iª¾yŒžÕGç\,¬d§<¤ß©'ÅÒd²‚ê,ýí_Me2îßËüDpÃß˵–:}”a,È´£îâ¬Ú@à†Ëžm¿œ¼W4?ž,”ôØ>tê"g† Šj´ä;×ï%œ­•x~ÕCÖNÛ< ye1SÃmnF¦±a9%k Ø~èÄÉÛœG9öo„uÔ Þ ¬GT×$ŸÃä?»áŸõI|^ù‰×/¶Ql–Fñ~é�D—Þ=(J™¬w%HTîóø~’Í»6ãŠÓÌ›n%¬=—Õи8<Q]~°‚Fv˜`V¨L<åo6ɺá<ÿ(­@šPoœªþЕ(Ic7€bWùLǵõªˆp,õ—¡•‡låc~Vê –s¢y’—CÉZ%©šwƒªX1.U/*õ®§¯+ÿ¼í8g¥»AŒSê¡mW¦}5³¬ˆË½–çƒægá)p ¬g>SÒªk,T»Ûní$ô†Ü^<¿EqètópâV,û˜ÔK z|Ó¡¿ÉyÈé.ݽá.jÐ4Y|^LG I¬)9±0ü[z¼` õj5šƒñ¾ºc剫°Ð4¦Aþeš„êÞzyô}ý“'R(™×@NŒ[ZšR¡W8×Y–ÀŠ•Z´¨·¨$»Â_¿>p‰Ï<þ5C²yfš^ìC/еd}çúûT* R¤f—ÓÕ[éå#ÏÎxålßýëÛÕi—ÊÈÊÁ¶­XÀ)5q›œÃ|‡Q_ï°¯ Ïú •IÿÄÄÆÍ1Eœ^×=žA=ñˆ^/î¤~‹>`Ê`ßK$*ø’ú!U²ÆvNÐÌuP8Pe6a¡b~qKß²bÑ;‚9LÉö¦½OÇÏ}>àïKKaÚþH6²±³0æ,T5Ðcý«"ÃJÉ÷Ó°;²áVÕëE}¯ÂB>„0ÑŒ–š<ðã£ß,ÿ!?v%–$RU´ ­MJ(t9S¬ï,"ìúî¬(~<Púc?ãV…oiW 1»31pÖ—}dt%ƒÊ­ ½uï6Ðg�‡Š¨Õˆ7оr”/ã&ò –\î©#E‹…Ñ~a¹­4_ŠœBᤅËcÞëW–‰Ê|ÿ7@GöY~ª$ˆ‰ÀvÙ»ßYt÷Á9Ð U¯G¶Æ1ËC›Ê×s ›¾Eõè+Wú=“—¼ÞÒ%c "v[hg}nÜHÅüF1¦BY×™FîêëS8÷=½qnÌT÷¼÷.ýÂ(ñ¢`€‡t+–ÒbïëØ΀‹‰‘§Nµxg=wõÍ® «}¤ue2úØŸö.ºcR}ǯ:óŒ¥b¤c=¦·ÅØzOÓ-JYiÞ×tnâ¦5»ÍVõ;½7PÞðdž¶Ô¨Ò±¾} Á8‰ÿ·¬èŸš`X¯ !JRåFËųèÙ×ÇÞj¹D–mÌT8—ažîõé)­ô’÷%ÒR »OÃ$@e:VJx¹­’«¸eeÜç·G:\m„C±…ºˆOnt´_ûœt!ç éë‰ÁÌ žv½î-¨('0UúñÄûÕ¼<Ä“YÅ‚ÔHq²³Gd‡ÿ€J±E›˜M[qçîñC£å7N#UÑ =Ò¼>)Þ¶b<p 5«½Ni$ŸMW¯KËL%‡FyE0V«�þñB†µú£Ê|þ+(Žë”¾ýdëNÜ®ùD)‡=éå0®(‘·tÓÛúmuÔ×ëõ½áüŽ¯œ1d3X",ÃíO |=ïç0w'2Îv]Ð}T¿­ÑVÜ*"´nŠ‚Å3ýS!µkGsPÇŽ©¾àØŠÃpA ZQê|^”Cæ±Å›g¤ÏØÜ¥áÁ¯ Þ—m{zïM§I<š¡ØUî0î:G•tæñ`5µp˜;:LÛ-‚ªW…½ÍöB¿ÀôÉ™x`î4º€Û¼ýF>6Rz¢ÑLàîyƒ,28fK¾±ö–¤ö‡þåã¼»L­â»Ü¨f ë‚›Šu$»Ùð—§ÏäÛ ¯ÒÞ¾Rh‰³«Âj®¼< úi£ âÆ"‰æ•JV�³ôfØm“9¶a~àø×ë@1­�ðš·ã®[©ëa=Ïé¡Ü#‚:øxe$V˜3E½E{±‘-^ÕÖ+wÑà0ÆèØN¯Ý,f”µGb©¶àÅö´ØhñSÁ´fÛþþòijÃóVg–¦ÉE¶haR%ƒˆ|¬=“y¶2Q‹“¾bdóŒpU‘ß©ÝùONÉûÖ+ù.1ÞU3òûÞ¤*¯²>±¤<L2“#Eˆéÿjçl¬C£±pø*‚¼SRxÅn?&4u· ÞΗՖ×=kî 5ƳQ !_èd)zù¾ól¤ÚT`lÖ”"Ú®£qù‚Д¥i‰iq Ó¢þJ³ôŒŸy\--e3ˆ½~Ç!óíàOþIƒªÙøòËôûñQSðÂSu²ÐôQ†.NƒdT0€Xóˆ¦ì¬‰eÓ_f³ÖOûÆôg®Þb^[øR’1SÁ©Øþ»q™%Ä~λjœÎP~g|ãŒ?¸µ7uÂM”vœSEÙPìílñ'5Pàõ©ŠÝf4‡3º¾°¨Eß¹C7—M¢ôò!š¸ôÀd¹‚ !¦ O‘îý-Ýè ”ÒÉ5‰Ý&à™§€è¼\?…⢠ò®ôóŽÕIìLWÞk*æiùSXÛZÝžøA,BÐËËÀp®õH¿¿›lýЋM¡ÿrŸ ]mÌÆÀűÕ1 ðìø&ªŒI™0'(¾/æìÜ¢,±Ô ±3Üôôœ­C*ýhOxr{‚óÿáºéZfέŒ¹ùA‹&” Ð…¹c[P”Ì=û`_ "/ßa §59ÕWü…Ê!÷¹I2•ažŽž´°ÏnßZƒ­;#/8ñ|&ÇfpwÊ™m‹LÉá ‡ºâ2(Ñ]žÏ­góO£÷0@ƾ[\)nqež¼Áä§à£ntÐðüGˆü±/¼ŠuK¥O1®½?<�ó;õ‡@>t>7LKß=‡qŽ”ËIÛ <‹ëŒ'-ÜÞž–ç±>7®r7?ƒ8ºV{h4HZ­»zãêß"U“‰x²Æ¾•%)=—@ÑQºdÛÖ“d¥#›~tœÍŒor|nD¥!×o[ø‰[…Kd[–i¥Ó¥¡¹ˆÏÐöÄ^+ß¹˜-!v±±L ‡/O "ó¼ìaþÖ6)¢¿ªôÍ[C®¹² ì¬Ì(ŸîC=8.?ݲíIóòˆÒ—åWŸcßï­ÇšëaÓó$‹nĨó_°vùæÖW'[r…ØØ@£ØbÝk3]7ôKðýì³Å€¯„‚3›_oïÜósaYü¡£:#þ:›)>ºb+žUo¸iÉJ]Ãc §Ö~‘SÆûX¿§Iž{ϨgÊ 96-ñ5u{{O|{šûá ×,)&™L5åG´åë7oÿÏÛçÛ±_A•„þúÝ [ûØ (*75íÅ"ÏKI¬M“©•@ÃX”¾$² Ü>ù¸MH÷ò0ÊuQq³—‹ u Iºqm]‰Õ@‡Ì\UlçÁû£ei•°ƒŠãL§fóiЂ>_†aA•Çô¥?ÔÎrÙ§zÏàbøÑ¢Š»s‡ÅXkŽ±Ê]ºiŒú¶[[ïF£µ¢Ó‹RwETy>0hă#™µ¯­¬äÐü}êZ†~ô‹#±Þ‚(¿{Ì¢É2l,ç{ã-'å*^;n<âFÏ„hÛ©×·wnÃóûE¥ïãJÑ­O*Z;=fã\cÎåøŸ ¬Ç­Ã%ÄÛ÷5L™ª1%Y5yŒp’fÿ³…˜Ã‰ŸˆQ}“ poÝÿ©/ÙC‡ŽV_$âªor1úç n¥Ìh(])·_j›3tÜu€~Œ³Ü.ùˆ%WÎë2H§#§Å ‡§ÔÇ9·¶éí(«\ÍO©ËQìÑoz¯gÏ/±î¡iët�Ff P~5‚eF ótÆâºÃj¨²eä™èÖ4j3±ä_M·Wq‚?e¯,T¹=ØrÔX”BúÇŠ¾:óÅoD`+'Ì)ºËÇí×tœ½CÑI,A¾a|·ÙM÷¤(ËÄWã¡Mtìhë'­í¿—ˆé¾Þ`! àýÿþßéªåsþÑ/¹EÅ69,U#¹Egþ}ë<CYÂEÀjfUž&HÚ‚ekÞð|‚'â·�ÐÄKØù €Îu~ÑûM\&f°¡¿ä”ïÍøBâK lÊË4ô,Bݸ¨²Ê,a(]\+ YØNjÇÍW †žàð¹ðáYo9ŒÍcW«ð`>öêuA"wue˜JR•5ïž"PØSâ’äSqä5Eùó7}F·¡ýt]3+ɬ!áe|é(üâÃf:Gk¾Jí®§ƒm¶¶‡ôGtÇ-hàóÿÞê½ãyÅé‘*_Né¼ä¦5ô1ÓÂ(ÛÙê½æ"T$#4«BH+‘…ua×µ̹y·íH9ÕŽje<ßY¶…ºÈ­Šõ“)MNò¤° ±•£¦É@уä΄eR½&vW- GP? l"Û…ˆ’°ævÙ€šÖú¼Ö»aÒöÙòN,¦?4ݽi¦ŠÊàâþH`5 E܂¼r_“>,ƒiÕqôtÊ)xtGQ`!ñqÜÀ]ÝbÊ=èaÁ}ª†r¹l«LX,ŠU¿[¯vKNžã$²áþJÁÛ[?ÚÊu¡�Ùn)ƒ½øf¢”ÙY…»‹`ZÉ ™T‹»&#s·)÷oÍëâÊ9-B¤%ůŠYß*n ïVÁ.Cv»Ü»¿ö¹÷{šz`æeéî˜�TõWG_Ìâ·øù}zã ½…=‚æ,Q¦›®,wš²žÈŸA,öt#gíÉæÌôï.âÁjæ´÷ÄU¨Þ*K§~ÀóÞaÄñÒ·žD„A p?žjAÖ{Ô×{£¤4^öÑ7ÎêƺŸf%XÁéhÇÙ¢ŠŽKöåvT…L¹ìÛËÖê|þ�Ú—{^ÜQ:¦kÏý}ï¾xgf؉°OóM+2J’Ä Uòxv«ù|ôŸ§#ôŠßªOÀUÿI¸tF'…ëG?:¦L|ÞahÏjJˤžÖý}w"[ܨߥA1XˆŽå£#¶<¿‹}'[2eÉéÝ#õŽ,¿ýàNyMF7¾JºŒ°/fðàÖ \<°ˆÒØp T¡vµ¦Ì9mTaúE´ jÐ[VÝî­­×—¶e=Ê1>׬eÓ×ûÃ?šû?ëýꞬÐ/+¬_:F–ßg½ a>ËÈÓsÁê¦(¶Á‘1K¤ ´†Öקz2Ç–tˆcºA=|Ó¿“Y]&q‡¨QO<…Ç Í4«×Sû€t© ºô4Ëé°¦ªxÐy4s•N«BZØFSÀ»|t~[c™çJ*CUŸånU—á\áŽ6ðí#Ó„•ÂÁcsŽ£ç´lb¡á[©[Üí…òæ’8óÎÂDàF‰5OEË2Sgÿhd=@ŒiIŒû"(ÞG7±‘a‡Ä”ïEX’Ô“õGûvUPvŠœ±“eé¨Ï–]ÁÈÓó>ïæA½|ÏRÒÄ™Jðw:úU9cx%ÅŸ:oÏ5U°‡ÐwÇ\f _Ÿ,˜& �µÛ„ ^ïO°ÄÐ|òÇê¦îv±í•NÌp’nã„XlX¹ºoQ8ö—gsÃì%-ëÔÓ›A½ ½L*‘­F’ÖØÔ³*y:žÔÂCÁ¶Õ$¨wøÓ™§¼.ÔŽ:’IQ³èwMõŸ]=”öL=úO–„žyš¤aA8jºÞʪ¯ø6íŽÏy®_]Žå\B£›1„'[·–Æ3Ãóz{‰ª–þ_Œû ÎÃl)ŒÖë½¥ÿdèéâuM¶]FyÁvë)~p3òÄ]+']Ût=ðò ´Œªì{åEŸøŒÈ}ÁB ÑzµßÑJ·É.â}¿Œšw){êŠ/„vé“Y!ß~ÚºÛc—Ï>”^°k¡Ô„xõpRñ‚×ƨfÚÒ°¯/o+s꯺b÷Ö´ûs±P‚都_0r1°¿Q+œN63@æKmZq‹²ƒxk÷ïă¢$÷5¡¡ÐåØRV53®¹‚pD9ùZë?J#_­™ÒVJÝ)Ýzÿk¹ 9LâৱX¹”"v“+ìÐá774RÕÀHÔõó`õ‡rÒ÷ÞAhÎ"po´ý^Eü˜Úe‡ þ¾­wçšb3ókäoô"çw—78á¼Â¸ò®÷0´XnL¯ÎÌ„þ)¾<Sl$sVàM :Bæ°‘�æLu½š]ú–-žVWEUj¦Sú¤ÔÁü´ÅÖµcë¥�“y�¯ "ß¡F”TQ–&…ϼE•=³[­êvÅCÿÿÁ^ûxEÖÒ÷åV›Jr:££„lqdËwÇQVCR(¼a#§3GRå9`÷£Ê0 Ž pâðÓ‘â2hœæU'÷w9æ©×“äÎÓp¤¥•t‰sN™às<¥¦>¦á$¥;I£â˜©µ°¨8‡\í\O¹=}ìŒd Ü–9ùºïÆú,¨7×  ^Tê+sÞ—Õ¡kµÎ¡ÒmOð?›Y ·Qâe”X®Þ»RÇN¥…û}´uŠa7ooGfOxß”8l]ÅR5}á¢?9ÑìÕeÚÚ·ËÏÍW㮹0锑 t× 6²Ñ¢w‰N˜ÉÕorØ�sh4œbQáŸA]Fñ.¶Ù´>M7�|Tyá(€íÈùøm ²Z±ùš‰¥r{´m¡ú£z+3‡ÜöD©Æ?t“»;?19¸¦wWo=bª¶›»…’Wü9xÚv˃ǩÏu\ý<è»õ_ ÏjK_a=V2—–×ä‰Ú=Ô w1 CƒèËPzξdÆt­I×4‚!ö…Ø �|ádéiBГ§ÊšÅÔ²W×u?‹ytí’t¯¨X“ÿÙ—jdà&7#UMR:ÙÑÊ“ý'*¢*Žì¬,fã<YÝ‘ù£«Y*E°wôtbQ�›-ñé1ÎnøGl¿Ž^áfP¤ÒÓÉÍ\ZzOÛ£§Ÿ%¦1ò‹þSûÛIá°¸½ˆí\ÚƒBç¡•$g-²µ#—jOøØqáDŽø¤ >fúüZõÒŽ ðñy@øþ÷b,kOÙQøt›ôCÌÅRˆó¡ˆ€®2*Mb+‘±̱=>sÂlÆ!Ž]½•¦6¯ˆåhØPaY¶ÕYÀ¹êE•ß ÇÓ„ÜÒ¹ûNžÏRXuÐÖ×[Phá `*ŹBßši w_¯®®Í ;æOL˜{×Ø rÞÎÛ,H¹ÞmX¬x>Œ&õ +U-ÊÌŒ­,µžVÓl{#ïi˜->C܇ Àf4X®LÉê«póq²£G,Wñ¿¹Çß}*Ûzä4Ƴ r$›Ú J{,y›€ÿM3õ0 Ç·ú²ô6œI/Ý${·o%{¢(É<ûX.sRŠöî£$-áx­ Ö”•v™U‰{^÷T 4ú94{zWõ»Wôß¡“ÿÌÏ»ŒN0)ÊhZ„Ö7$<XFlƒ¿ÝÃ,“q䂸ˆ[U=Öä„Óî‘Ž±ÞÞzä…æŒ6nã:Þ¥©ÿ¯ˆRIR9([Êà v*ks.Pn…Ry1cx2Àý!J‘jVc]xf¬¹™xìÝ”Hü0 :з˩ÀŸ×iüEÅ‘g‹™fÁgÊGËÖ&%w$Í“{M§dAÿb×;ƒ·åÅ£ü?^¥–usñFFWï§Éi'¡Û#tÞ ¤&®Š¨†9TgJ©iu/ßèë-ë6ª¼.&ËÝœYi¨·Š®`nèÔ5§¢P†ßŠ{í]>wµŠ¢Òô°–^—é7_æoÁ0[ìeT‰•Îø¹¦ø8l¨D €ÑGÌG.þ%«°:YŽ\wJ†Öê3gm ÷ß;ÙxØûºÂ’Ú²Ícë­&;²-¼Ñ †ïëžEžqaøÿ«}y W5œ[ªJY ­s®6&7ð1Zûˆ7QЀ Úvr>ßF0b2C AqÉû¬ÙùíÅRM,* ]9Ê É÷rˆsÏÛ•á <''—w+§ij»@2iª©DÊßÕÇÝÇê«iw½s~I”C�ã²9ðå¨Ía¾ó“«¡-ƒ:úž½î³PÅ|ÇÃþÚ>÷Ñö ä&Óç�zì1û<yyØA],ЂÏñ°=E/àÝÅ2Á¤ÅéB?í¬”>¶w=ÇuV²Øö›W·?r˜H×Yâ؃`ýæ~¬+§î¡•~Ò»ŠJçKÅ:L}$}cŽX ¨ ¸8­›þÏ·òT®PÌ „™ÙjV#—‰SËøo^v?cª¹05Š¿ŽòªÕˆ“‰6CW\�ø-t&*S_%9¬y4žl÷§ë/¢ÉG¡ CžÊquç'±TÙ¨YU‡ÜheNgÌBOb¸H®îÉmÑ'ã)Pbºå¯¿>õw3!k­Yô`£A‘�e(:sX,ù~×õe2U‘ú¢t4Oý¾ÍÙôŠ{xƒ?ê ›á%ïÊÄgËFH¹·hý~²Ôpظ+î)ù¿ÔOtòý‰ÑÚœäKz=Z:´úzÒëÂmiv› ]3°íÌŸm„Ÿïk9sÒÔ¸}M(ê“ÙŽ:ßòjòêÿ\ÿ]ê>öTV‘m‘´‰Ò`³ µ.åÀl/½µ»~Q-÷:ˬ]ÝT—fSïi&Ò ¨1y!ë·œ*Ÿ0ͺ†¬!�§ý )9–éÍ‘·AÛÕýÒÇ,ò‰9såþ@V¥whèÕaÀ`ÃÜ“ne"É`ȤÌSµ]ÿg·¨²ØÇŽv÷—²Í*–ŦüpMU½t?¡hÅÉ5aú(ƒb«-jXgeг~‰  ÌNtCôg t7‹L<4 ^Á¢/j­â>¬QéÃá‡é– §àw>´ +×^.ñ¸±0uÌ¡õÈÍ"ë4•®ßK.4KFl�4‹wØâ‘?3@ÄÝÓ3éíUZ”ÞÒÑšwù@“V®IÛ?+q` [Q.קÉ(Õ¢žÿ‹?'ÏÕS’‘#¥ÞéàÓo… Ý}FnDkb)1üÔ”wòЃ÷ÉÍ(,(GO„Ç?°Ù‚n JQ_tš[·ŒH¦*À;isïÒ²|¹r‡àˆ1àÂH(ùZ»&…ž¿¢;¤�²+ Ë‰s÷€iqNßÕÂß+FA:6 ƒ~ðVÆŒ‹wßxääΆžÑT &A^ÏNP¿=Á:Ù¤Ä÷Åê¼Ëè?%Àðf4Äj=fó›ÖÔ´ô2ð_GØBM½»]Þ÷1Î"ì'€ÙÂ÷´êBŸD´þ@ÕÄùô°¼¢÷i LÀ|"ã…gÍ3äÙ‚5qú%NÂö™3^Å®ÂgUÍMßõ®z‰c·AÄ—²ÍQJ\‘Kí.Wâ9mB³úÌøÜÀÞ!¬7Þ ¹e1G¤òc&XT8“*A£4(„ŸÕ˜W_m‘ñ·4‡ûöÇ^¯E¼˜ÛQñ»Zqb¿R¿g¡09É\êY7ªˆœô•x“Ðýµ¢e i¿ÝŸ«)âççØ3!þq‹i­e7‰#ãÛM¹ÀÉÊÇ8ŠôÉŽ˜î«ƹù!“*ƒ¶O‚bš=ŠMMOéÐï½”§­Õ#æÁ%Ã/²åq¾ÕÍÎ#£×3@#)l'‚ÜÚáK=ÜãÚeÙBཤ(G9“U¦+T�ÜŸåäÆd;ßa®µ¿ŠÛ¡O0n‘/Ï_¶Cx`Faqu¡© ‘ìêíÃ)H,D¿9Ç\+ùC²&ôN°—/˜õÈõtjêÍ´=Ìfá™_éõDsßo›nO²xû×›çÐ͆÷TÅEªOñét{ò£Ç> J÷s¤nÇ”²CK4�¦~õ±SÐUL(¤ý¹»¾òG YyÅ'\­JךVe÷9V·Üð; ó…6nÛú—¯JÊi.e$R2VæÈßµ‹üÝ7ß½ä7Åd®½Fña©‚ÝŸ[ž Ôisšf€“Õþ >É,iùÊ[¤óekR‡«©³=h2Q»õä’¤†×^,HL¢åî]AÎÐÖ‰Ä`ÙbþÌøÓSàk»ë­ÜÊ·ŸiѵbƒöaA‹ôSk•ÌaNju™ë½ ¥ìÅ2ƒŒþcMnBãö9t ³~ÖžU ðõn'õ5ô�8MEë=ð‰õó¯+ÃÂõ¸%àÝVÚß} È-åÓ‘þûÎÅ_Y_1ݤ¿Ÿ“ K¢Ê2ñÀ˜²óà#í½�"ÁC^~žêÙ8&Põ$–ÂQöžÌ1ÖÛmÿtîœlþñÀÁv½ãß™½„é‰1§Œ¹~½Ë–Ìepžbˇ2=qíÒ‡aÏëçvì+çrCq¢,*jø²c¢òÖ œ™ôŽM”&»¦ÆVj^æåŽÝ-–%X¦%66‹\#“%o¦‚n¢u¢ÇàšYÀýi´©ƒ^hÅIáÃ&)ÑÎt&üLçd+Ífôo;õÿ¤_·Ãò� ¦+âš&s³oü_“ÂYšJ´‚XuùéÏø®ùËïèœi7ÏúZ¤Ö”™ÑÆGêY÷,Ø»õÚfûß'Ï‘Ï-* à)H·_ÖMµó&UÕø}löòB1ú÷ÐNøÔç`¤ë¤aFH=rjmÖ/¼Š'óOX[`Ûº åŸpž(˜&J‡(ê8 ;çuÛbB �úE`Õ®XH%[´¶PΨ�jŠ2ˆê‹w—­9'VåÚ+q~¶Áóû–OZ…Eæ7ð©þD`úkQBÉLùìC!]Û"´R‘3Õ³ÝÅCµºÚÃl$L»ö0üË×°-N1áT¨ºèL)ÂRG…¬áv: L2ƒ»þãíB9ÐUEýͤ&Ž“8s‡%¸ypB‹N³›¸®ûc=M,£îµÖ<c™¼%>6`Qž88 ;”µoÿÏž´øt5§iÇ:}â¡ÈÃËí’nþSûºÌè"¾äÅ eCø칓C5µ3�$ü/ÆïùëÝ—²&”:;6´6º�ä&±¿€P'yµð!¤_r¦¯Ý¨8îîÝÊü̳Ü+5ì¤è§Îš®Š€øDCec¢¥htVÖ0qºøåsïs¯u,óŽ"9Ð3ó=%`L#‡©â|§ï)jÇÚ6¥ùÛ?o€ÉÖt37…¯Rút_duÎúψÊ’á¦5—¸õMåE+QWï—4qÝÅw›2Í®Ë;glsè·à 1ÚGËpË]ýýûúËþN;4N|b=&½0œKjEéÑwçνiÂË•o´‡ûàºÎ‰} '5¨,Q­3•Ž!ê7ûx§ÿ‚Ø@_ÅÅÍþ{‘¤[z®ŠÌ`œ&xýõ’NÀzÌ2¦š°ÃÑ,ÙöÉhYá6¥JjGA9m=$¶¨?7ÛQ9’Þœ-Nˆ)XiHºeݨôö³ÑÏê™ÂÇ–SsæÄ¢»ü¢(ªBÏЩ9‹°¶ `¤3Œ’½ZMª�@^~æñâÔ¦|æðE;"_›=†c›u \Q¡=¨yð_à÷u£ÿT©ßµGéÓÄV„Ê¢9·ÐL3Gû wçê Ù:¥¬(+ü”Çäe^šÀÄŒ<:Ç‹ ´&HEÅJ/Šâ;$+`©;ÎHeE¦J1ûœph÷µ;ÝnË »ÓºˆÑsF59q£5A9µ€Œ¹}àáj[³•¹6|¾w#Éèí<膊Yöª(²Y<°LÖà[`jàaCexhe#bv\J0 /¸Â¿èQ›Z¡ÁÐ80â*­ÕÀ©=qÅ€¥ÿ¾U¾ºý—Æ[îeø•ÚRE\Ó…@ÂBAÜVÀ); ÕŒ{óEž�A¡Ãìr„µªäQa„§ f0Úº†5ò_ÿ˜F/Þ 9äÃY°”²×#]åú’ˆkWÚ6ÌÇ6}-bõº«)ÆÁDÈÇÜmÊÄ ð4†Ø{¹]]h+¸ Þ'-VëR¼5ðxž¸›öÀ=ÍÒ(¡„±™6²'i56N% :»oì¡nö>,†ü¡¥V\JeìÈ}Ê&‘Né\kkÙÎ)À%?ô-¾y¹»€²8óÅhè{S$¥ÿz z)u5ð1YyâßñÁó2\â¼öILå¬o´¸­ÏœYÓ© >)¥Ë€ÝLç|ìfãV`¿úó}á7†">6YõxPµh½ð£±Ïý¥âq|Eþƒõ% ªíèÚô‘×iþÄO¹î]ù¦¦Œ�¥‰aƒµVûÜ@‰³jD„iN ;¼7팫aþÍlßb],õlÚ£3gg.©ºuøÃœ‡£i»ƒcS MuJ‹Ô.ú|ùÂœ»IQè[Y¿”Ç´ªÄÃËäHQhVcíõÍ@déÉLÅ´xäåZ¸¸póÕÅóú’Éû¨j‰lT¾›}¯MLÍW}Çô­éÞ<K5¬‹*ÓêƒErÙz§Î vu/ªˆ™ôÁ"tß“"ý2 ª‰'ú Z!ž«S/Úe2[¤“Ρèï©ÅÜÓñ"qd¨;”ánNžË$g—l^7áŒÒÒvÚ…eÑv˜ú«Ò ¨òõi¤5aŽ—|´/Ƙqcd‚½âKFºtvÔ´ŸRY¼ÐAÂøÙ½¶3 ?v”õ)L®É¿¬¢ ` I ƒ=ÒŠ‹-aû]­DW?©Hþ—6ò'wªXÿ+jzRy3/ˆÕ¹¼•OÀD L=§´žÅæ^¯o^ÑŽ)}ƒ.ø@¿ñ8‘lC:™Ü¤5Í$³È翲Ú¥ÚJðˆ`áî)]; »ð`TSíc¹W@Ç>/²â1m—3³^ ëûÝ?Û]`Œ"·t«/’>Ò›…YóS Ž#ž3$•…r£Æš „‚2ìf ÄÐp2ÅÕ[ ®æŒ¸£%«9La„ÖlÎwå°¦®äöåӓ̃Qjr3‰L‚þT04$Öö›:&‹rõngšHk ‡ @óUÔ?À¶¾Ã{°ÞHâ Ž3Ó¯øÒáJ|NiÑÒµ -Œ® ²±»c*d-Ö 2Ľ‡MÀ×ðÆ?°ÝŠÜ/fi7¬š"HGèÊÍL^¸g”оßwç{a‚­dÐ4¤´:šl%…áy×ï—i¯ÊWÙŠ¸†bü©'3+žœyRAÇE׃|&•U×›ø*K1®<äÓû˜ÎŠ/ía‚è:Þ!¼û=uk¦ö.n{|…ô-„�eé¶Íi2îñìfœÀYD–GYFÎ÷ ôÄ*¥ÊiGß¹Wø}¶xØTQÊöÙÓJÃÅ¿~½å ÄÎø¡5 :òËÙæG ±7ÝN³Å¦keÔ`/†ˆÅoz=vȯʳó�_Om.dÊÄOó8­óÿy_M õÝ `ò0¤¡‡éñy:ÐÆ΂»/Ôb—¯ÞŽŒ¯8+en»‚"è¡%ö&[‚Õi·…¾5gô× eÀÈÆü䦮,—º ´ö{º#HøÀT]eöîJCš$½©¥ÁL 7e­œBôå&ÅfóÂF`ñÆëñGž |j!ý)gÝóÄ4/Ã…_—¨ò� ˆf8:^XøtÝýa´à"nÓò÷®SïuЇ¡ã¶×o¦…VÖHÒ3™Ž•ÈÎg¯úQ‹ì]u‚è?¥N#33ï¾Ò ´zcè¯è™®G×@Ùýg,a^\WÔëó„ZêÎ ‡£l9�¼¨üš¦º³µ«ˆ¥ØÍŽ;ê#ƒ¢øÏ°Y€&1mfX&Û<Ò_7ì¾üÔ©þ_òOñ†_Ï;”´üÂÔgÃA­~Ki?;e†ÕáK7:çG.}åÚXa{'iBk‰t<õž‡é¾>©Ú�žËî/l\,ºÉÇ9%I槩¬­_ÙxvVmãá\ë„ÇÎE½t<ì'‰(·Âa*bµ(§ ûc­l½”%¨Æ<u¾wôŠ72´t½}—2LB5K¯E"W@cÐ7ßw­˜\ñ @r ÇÕPПi§6¥™4¬W¾ú úó'ª×•3}BÎE‡>m¿r­D24¦ ÀpáäVúÙ?ɺ|™ 9EÝÓ-z_n‹­k· Õc[°}PïáÕËà0¹ºžMYs»ÐÌ;çBïgoª ©j‘_|Ð,’(sC ˜²Oˆû³ÖK á³Ø=«4HáìS#$œ˜bao«?ôå¤g))B¾‡rjÇúÂöcãiÓ\Ì?¯…(÷ŽSNØ„uçfíÓ®ÿàï*Ýù‚CÛ´A÷5LÎ&w’=Q™ð½`8}X!6iO³ŠÇ•Þˆ¥U^a} #Øt¡DÞspÍÑ$r^°e0 ekߺëµwø‰§‡¾x{Gé¥tõÆW¥˜vX£û"æ6¡Øõý¬íÕA¬0Ol{oËŠ²Û冽}Œ˜h×R™n^Ä ‡[\,øwï‡,õáhøašp¶O­¶Ïu+‚±þÀ @®Åœ30ÀMv½X”�¹'ÏÎ\[¨‹ÕÊblàfp±b_•Œld*í°%ÎçvŠ6,šš"Ð4™%Íç»,MöÏýŸ4è°Cÿ#Yú¾“ ÍöžþKTC‘K«¸¹=PŠSûøÃéÄîñ9"Ï’…àdȲ ¶<Ñ.�H 9s¦bËò³w“Ío{ QèÓ°cÁa¤ÃÙŸê9¼ªvèÛVå™O×㡇ݨ'='f°Eqj›ß[@ZAkã6‹ŒœÛÎubxI¯:HòiõÀ§¦4Þ?:q¸i?'FýD&PhNÔ”Qt¾NËŠÛwFsIÒRc‹rs}¯ô•Ã*hò2¨ÞO@|×O:¦£?ƒQƒú 5ßÛP«ÌYÌ@þç2ìÇùªS]®~ÛåYw*sJX¯¶œ®žw–'m_cáJœ¥|jìŽ"~e0í“ ´Â¬Œ‹’°ôß·BÕ+Ä #µcò Ð÷ß?"›Ü¦F±‚Žé"(¬»“îF±QÓeùÂ9íDÌ`5ÈœÖú»Ý›Em2Å7›*ò1-Æײç;ÍÌ礭„þ"ænò)™À+]s…H·À(5¹«[Lmå–ÙñtµMó m!΢µ…â<y³óÖÔTÇ®¢¾óv‡:©spÌâ8½ »®»A,q¯[gVCNdJEæ-¤…is‹"`é4SGýXÊv銇Ñ[)s-W :µ×Õaº6J­é`œûú|Oì9Z8úÑnmàé×V8TáO†H3ÄÄ,G|¯1}ÿÒS +¿õAwhÜÐo²˜$Kügðø|ŠåÃWf·úþ.”ê² ×xñÈ­âÜar¯Ÿ qÅ©ÁÏÊü,¦ü'kwˆ¯|©"dvÿž>Ù.·–XÙ^Ý.ñÔ"n?¯þp64xzë ¡ý·×qQ•y÷<r(ØsÌœPyÀtiêîF“S¶-‚öâ>Ô¦Œ¡ñø8v ]§Ó91/…½¥<ŽQ-�¾Ï/»„EQì;ûEI°=¼½œÓ!À¢ßë°´ç³÷¯èË°z ÍûʸÁõ´2]ÓeU³�¸YX‡~oû¤œËÝÈ13¿¾§Ì¦˜¿<r4þŠCý1Á éÏa àd±9@!Þ´_œ»›WŽn]o›-f¯ïzâÓÄ^) ·«ùí¶HA_‘Èk’²SlÇŒN“³i‘áΛV´µƒ–#W_ŸcÄÒØØy@Ú ƒÕu¯”ŽÙÄåŸ4F~nI˜†þX…˜áh¯É_ªEÕ™=ÿ"käq#oô˜M™-ºÌ „Q¤Í|ØKž¢@Ó­>Ĵ¢¤½«û¤À4[ŠÜB=®’F9F’Ÿï#‡@83ªUÐu µ1´õî#Ü*Ž•k•…9δ£K–Í CåJçÉ]!˜Ãi˜`Ûò÷‘˜,«¥4·]½„ÎP3ãç=qÛFf©Þ%¬¦emQUÑõG£†úÉsWi¯7WKþÔÅ1ÊãÌ“«cEÔ&Ïï·Õ±Ú9|‘`‘Œ©ñµaº5åúc{¡¼YÁ`/pÖKg»À"’íŒÞŠ¥«ÄÐ@Ú Ñ©Õj‚–ÁÍ'Å5½‰"ÿuÀw”åÐæÏ”AH¦E‘0ÝxöÜé­´æCͨŒ|4½ç‘"n•è9VJÿ¶SÂs:ô¬E‡1[ß¡üJ¹ ¡!M‚lPøqƃ�ÊbFŠ‘_Ûèe[cæß\¸{ZÓB¼êCH!dmâ Êw(¦YCZÉéëoœBÃ÷9O™úCW–zzúò‡XTÖnüÑh#ñ1¶îòÁ,8-ý¼DðØô‡Á÷{p¹¤ê˜ËeµW^Û/  hyS{dü|ÿP*ÿ¼àI¹F×Ð…™ÙéÓ+îá½4N˜ã ç-åH s´lÑǼQ—ÝËØ4÷‹¢Ü ¢ž¶œÊ8s»csk¨Ï=ôÁˆ<¥ãåI9†MÊL¬$Ž®Á·mjOGxã}G ÎÎðÑ M>;sÐoõQšúì«ØŒ\£ÞhŸÉ›“CCI*¿¾FUä ÊÌ/ë(^Y•¼%­T>¨õ¶<u8Ó$ó•àJ¶ímW½€5… ˆ¢>ûfk‰¥ñ±†‰WæÑa °?al‰ÚêÏ ¼|Åê‚Å à†ÙÛùTœ‹d5ßm‚­Øn]tóÝ¥…¶{þó‚@¥¬= ª£Þàu½¡ 3ˆ³)[Óþù²:ç¾Ñï=AÌ­ I.Ö€ieÐt=óKTšé¿oôŸh;ÅþË¥ëc ’/™mÅ`Û ³7¿Œ£• ”E¯Mv´=ÌÕ—‡Ãþ-æxq~ÛZéší p^3Q�á„ÁÑwü¨ —{'ÈÆNM¤GÝ¿˜&lëÞyÉ‚ÏÏCï]<òuö{ "?îÁ)¯­-CXzŠÂ$_9¬h™2Ññ‡UwƒøE³…+m€ÂZùÀ/ú£ûĶç0vi.ÿ'iÒÊx&Šwm1 Ìe™¼‰a­#˜lKd¯ná2ölՖ‚jž=*î{7|ì,ûß6òÉ aàô˪,ÒOhŽF°°aTß}¶g¸yš¹s=‰8`•˜ÌUD4²í•\°ü¡W€»MÄÎ÷†sY!’Púòdg9Õ-á‹TÈÀ‚dÛ9Õ'4/“˘XvçÊ`9®—3±pÙh×&gó�ÊPÞŽ=-¦zìÝpìZD¦ŽŽ¼oÅ€m6ª.Ùû® òYfð3Q›÷Å°¯ÇÚQ\ $ôgVHïëX{±†Ž5@´ÿû†)¬ƒ×V,z¶YÙ'tq\eÞIéI¬{¸'gRþÛs8O­À½ü ØTõ LW ÓÓqiô)^a×DJ0W(àú2È 8å³çUFq6²GX¹Ìâ^ý?±›ºýÁ¥Ò•š¼Ý,¥‘Ó6”@» vR3ö¶£ '<04_düç•(,Ü*Ï°áѱJœ³!‹[¶FìAOžÑ´ŠÂ8]B7Žð¶…J,eëꣻ`ýH&¯ðعŒ”nª2?•²XZ¬ìheíÝpAbíðÄ-L ÜÅœ‹ºD'FÄiw„‘Õš‹ŒR²U"ÇâšdÖÂq‘–M*Ö—´ˆ=ÐëB@ž£¨•‹H‡Ë©G?X6Oˆ¾Gj¥¿ãµ±¨ƒ¨zÍÔSrõþ× }}Ö=ÓÖtèc ŽJ1ÍXYûšú«‘?öS¹ÔàŽ‡œ}-\St½ó¼W×NÚë[}>oR/t„¯#šYŽŽÑš; ^I¿9³Lv§éÃþKy°Ëw”µE~÷SªÙÆ;¸Ž]ï9-Œµi¨êÅíä+_ÌÝñ™#mïOu`áãY|Œþ‡ÿ#‰”F÷úõVÀ¸=5o1D¤÷GÅæA¼vèxxjȳ”±)ÅÍ…ôïÆ­ã¶.¬þàw¼‡ç§V9Pzµq›�irYLÌ“r ð*[Fi­/ð^°.‚\nm×—ÝoLçáÀwkÙQ• *A»„ù‡±ÕTí.ÉY&Í-±Ý0Ù‰*ªpo !$4\Ò§ÃÞÿ'ßòŽ‡×Ns­ô´2ž±}TAÖº©5Õò\v:W)ºŸhr>E¹ ‘š‚×5hË&‘©»$YÓ»l.ß?„9Ã}Wõwj߸æ¢<ÅñMßo”2)âf^M˜D*Òo7c”¨É</³Y®túU¬_E;Dª•ÂÒžncs6\ûäš½AIÂñD‰ÝåuˆMdêoÕGI_Óam¡±'Žtp×ÚWó jŸ{Õú1\fM*&A~>zF*°wê//Ãïʪ09×^á×ÉõŽévüA`³Å—Uþ‹ê+Ëœž\È3–© âw55¨ÿ0ÆÒ¢­èßwõ ƒzÕŒb–!n². yôž¡ª™?—-Ñ÷¤<™Õæ"#¾Š!{'–Ѹ¡“$5-~:¬ç¥ Ïìƒ%(C€¨±ú §97äLßbè¤5EŸx6sGáŽ\ë^yz9BnnÚÔø¬MÑ«[1»q Ö«“éñ•çŽÙ”0à|,ƒèóÌ÷¾—Áûá²RVƒ(Öº‹{\rŸ6RâñBš7³*?‘h{™ß·‡ÿ"ˆ|KŒÊtœÓ s@•ÔŠ/[Ö‹àöÐd‚óÛôÑm˜ÍøÌÙ²tõÔóœ0o{E­F<¢4b–ÖŸAÿ*mN=R³ˆ9¶%NÑZÇ9 ಥ}ƒ‹]\´X?äy.?—B3Òn D7t`?=×B±iwùææÍÌùe¡©ø˜¶ËώôL+×ÂK5£Í¦ °þ´ßu²ð¿oIéó>éÀ·È5©~{L­ã»Ó1wj F×YÕŒ& Ø(’ |÷vèSáï:©ðÐVJï»Òc‰%¢Â¸ÄÁé$­·N¿îÙ¦‰«?ò912=ªæ± Rêë`±­DDZrÞ˜µß1(ÑœZÃÛ+§M*3U:P§"ö¨!Ì50îƒ<œŸ¶õúUñÁ´È|žŽ¨ÞA5ÉšbÆ(’jî®QS­V�¿Û|ÌÊØbÈù dGáäÝÅbÑ“¡³ +מÂê,leµŒŸ<Z™ìNA¬@¢VÔy‹ÆÌÃ/™Tž Zʃ-%/ù{ç([Ê Õÿ)Ö¯‡—V³¾ÔñÀ¾×v²Ðgh>›jÕ™WªßñÐôÇ?0±Çî—Š8hŠ¾[$4›:uâ™°KIÓýñ$Õþ]è‹­ mhÐ œKW­žÒh‡¼×ÓÞB¾Ë Ã®¥Ç¼;R5aùÍÖ9F<}<H ý©³hÜk‹³a¹³E«³Z@ÔYŸ1tTéÁ¨”æ¬rµ�jhif`œˆ„. -Qìþþ\Ú„ôÙ\{YÊL{}½5Pv< ^l©²e>užèT¼ÓÉÍÛÕÙSMR_¯U’ú3¨ *Ã|Y¶/Çdèp[å±2ÜeUߪG•«h ­çeP£-ÜRØðΟ‚“pÁ´ 3XØ¡ý¢HN KtÀ[ƒ!ñhfòGY÷÷\î¨rÔãq s1}o¼Ñ¸'QǧEæ™óg¼PE´£0ËRN]½XÀ̶ÿAê7 ÊËäáWÏ­+¦ÙõÒžzt,–ÖÚWï6qPX^[Þ•,›Z÷ÙÕ¼t¥iãKµPæbÛ©¯3¡òÄd2Ò¤?Í6Šg 2·ïöX'H0(Ù6ÜR{ñxªV:À„ø�÷=ýŠ°Ÿ,ÆI(Öâø¬.Ãù´ˤµÝÐÐCRh·÷|â“踷�“´º8Ð-ë걨™rôDmÿúõŠo&…*"ù‡/d®ZÔqöÈÅ3¾ñ–õxé1±CýN))Ü$˜æÍ°–tf[Ê »Ñö_2G u<ÊÖp9oLÅÎg²�Êø1ºÚ1ÿêÆÕ"úOêªNÄ+ S¨ëá¼é»V€¾”—õýº ÅTëôËr®PêÚÖ¾ÚQÀ>bqÈ¥Û�Jžj«°�Åó^ü–eŸi/=ý;Ì“ÄoÃFu¤Üz8™±¦£+œKÜ·¤zâNåÑ*620¨éX{ImýáËçNu/ žÖŠŽ¸K×3÷8q"VCz(¼WJœ†KŒì´¥ƒ|Û¸wÚl­£ÓcX`Uù>Wt¯$®/ë¶ÒÈR,5Ÿ{M63Kf¶ð EÔ=Ú’I—9ŒSÅ ‚‰C{ç¿^Á}¸é�AÜNa^gMËh;t˜á÷ô‡£äq&ê>Ì,|i^ûlR_ÙqøÎõ ³:Ðl©€�áŠÃpÊP¥ ˜ E#èfi—;O¥TQwÜz¢‡q¸wa1!iè3;Y0†b§§3Ä7Á³P¹‰—çÇ™—`qçz{¢Â´þë=ÄÆiÑiWõßa·=Ÿ"Lƒ¾¥:n« ”-cÝ‚éeçÁ@|‡3áòOXª/n e}ëòHQ[8Èôpg5ú¢áh^Q‡!ñ\…ŠÒH?óÃ÷ˆ!¯\Û:j4W_€úÅ裕„µ C;tóÕcÌ^>³ÃÍ®‘·›Eä¤Óûž£¼Ýµ˜mÝ¿¥C-qÐ3v awÄ–a¸P䬂s´e_9QÐÖä‘ÇSWÆMç¡ñ‚ tä¡UrãõÄ.Ýõh0ïPÔ8ï†_Àgq¸<ŠjIå»ÀM)|jSl(÷ÌôÌ`z¥å8 ÷®øÜ;}¾Ò N»¯*È­s „Ãad],JŸ[Ñå¤Ãe–³›sWº¼ÞL-ŠÃÐÃîoÊe'NÆ«GÆì]œ€-­Sàfâ\¯{èYÔž0Ò–/ÝØÏš©¿æ°• eL¨™êŠÑk³è…^hÔíæ2ôõn²„Ñe,p¸òØà¨ÙðÅ]Øg­…áO­^Ƥ…øHƒhý¦àLÚPh[CºLL-´réä1Yn…çµé³ ë4'Zšs׸^¦§ÝbÚJÜä2{pU¡Õ—;™£óÌ6&%ŽtGº“W¶°ÐiWFäbsº§oý̦pÛ‘UUX!ß~¹…ˆF)טÍ+ì&D"+›[@:vʃôxôÇHy0e„"¾g]VÞðP¸Š5Up)Eµ)´Zlág›ÜÙ/Š! S#×; ô¡Ÿ–µh(ùm­@Ÿ_I¼Ð"†GÓ™*€µæEh€Mè<‰¹0|Ä °$5ÍjìÎÝ7Ьr½}p™ƒ&‡-—5—wNÖÄ|Úw¬»ðá_=l0hQF…aõ‡~K¸~W7æÐMÖ¸9ô3]^Z´ðŽúŸƒ§½¢–W;ʇŠTæü¿·¡;ÌÓ÷¸{pyØÏ6ƒô 7j@Ðô'î9÷qkL£ðNL.´<¸ój¶R’¹–#"Y*îÛOçF¹ïz6Íó-«æØQ¦FdL²I¨!sÒruíHg`è¾ï]ÝAyØgN:'×qž6ü¬c±”? »u½ê¬¥éao*œ7ni<ɯã4[Ó–À½äAÞU›™Ï+W'Ò+TS³@äâ9üÅÖ‘�Hò�²½¥ï@Ú²-çfÖôP0ÏüÔ5,Ã÷Êšéê äci7¬ð•\{jÙ/€Zc»/r½îhWŒV‘ȇs^8oÀPŽ-€ãwÃEšûÎïp±½CnÜ@ASKŽgM ýOWù§Úê´ú0~w/ÚûEaæ‹!mÁ¼VëÙÈþ‡ ^2?Ζ£0ó©ÿIÈÆñ¤Õ!eh\‚;x|š$µyL‘û×r_PîÉ<EVüÊ`ÿðeÅn¶¢ÿÍ;[Ê™ÖW úÞ±ƒ‡vüû>}g]t­Üm4mÇÆAhpÌy&¯ ºâСgR.xé¸^+‡R}�ÛÔ"ü%Ÿ5E®T·££¨”ƒ×u – :^¸eô€' &Lµm"6Ùãþ³Îø –2¢c”œ”8¡›ý\Ÿü†2y¦¤6ý»uªPõX7»Émœ8¢²¼Ô«%üÇsÍc—U“¥M¯ ¯Ût«­ZˆYÙð§W è¿Ÿ”AWÉäK˜ÈV3È"!ã›}„É öǔȭö!CÁœ½Ñºî?|xŸSé]Ñi€VÚÍOpÖyÍ‘(Î}³\:š‰n¾íÍc´ºí†¾«ÿZ,¹"a®_ë?W°úÐÈ4lÌØA2ï 4±Mˆ>«Þ•~” }l%qõ6üO†¾"¼0i±X *ΰžJ@îŸ}o4Çý,·£BZÙgëÅD�Á^07áûN–c«±ø.êa�³vpÖ†€X³Ši>U>ñÇL±à»)Ñ_ÿur<ÆÕHƒJ û76sI‘ù6EåQ°õî/nòŒ…Ì…1÷ÏueLì;61ä0²NßtÝ,5½ö¬ŽiÊn•&î±½&OÆ1ìëÚ·îOMyûöí Ñ®ëν"EÎ<†.Û÷PJ¹mœ}5NÇÑJlÝ—¤\$L Ÿ?é»å[=[†7ŽÇ"¦ ‘ xž“lø;,un†¥ÞXí;éRÔE«4™Ôt 3ÂÕaœš]çPFFü›‰ÞíÜ´O”žÅ¡!ã"pu.‚dŒæ\lÝtÌþÛ œµ÷Õà¬sÿªùL«£œt€…'á_[”/ŠªÊ]×8§›àÜs3ª±’Gy ž¤;Úñ»?œá,eÞÞ£ùnZÍhD˜ G–7[†(“h¿ŽÆÏä7®ÂqâeÓœ°…›_ˆB#¤/ìi²™Á2;|ɼÍö~ÄP1bL”…±h»½˜¢9~ÇzÇ­¤Ç0“(C/Ë…ÅMŒ&XíL6eDÀZ³`>è†Õýf3¢ùP„JÝÛ"ãà—èÉÄ–‚–Æ fª÷[v?a%ä:¦ÐïØm ä¹Ål"+#¯C™<ˆÏµj$ Ÿbh¦P%’V•Ñ‚®Ê¦6Tæ­g)E)¥ ;pš¾•Êò‘›lâG:}äAd¤cÖû2^ñ›Á0‚w:¦4l=ì®îƒÖŠØ äÌh†$(6:5+„ÆÙ_èclãÈ=M82ɦéHÓ€‹áð†ÆO^U^•Ñ°Ú¹éI6fYVe. v”n×V%ügbM¶6M!´÷bÔAŸ.½Ð×Û°C˜ÙMjHÚOâèˆw·r>YVX3^Þ@V:™þš«ŒÄý┆/3ÍKÏ—™–µ¸Ð“^¼± Týkš¤–ÆnqU†’±,g79¨Õ·$ŽÒÇ5¡xN‘¿³Y:t¸Ïôõù~í‘z=«ºwýHd#Ï–´ÆaÀèØ‚c•âaä˜ßka›Ø‹©È¬¿åjR”º\7åEÕWAù¾6ØŽ4±“Q¾t3Œì¾7ÿãÁ6Ë|'OZLã6YËÚˆÇ^ú?õ@w³5Ûf_Y¨Á€³²—`a$óêG ¯ËZÉ«?e «´T£E|4—ή_ôþn”´"]"e˜×qP¼=©® ü«õéÎhm)Ù‘9éyì>vƒ¾ ‡ôÖ ‹¡Mç2ˆ-¯gOÿ#Œ |íìýô›•.ƒÅc«?_‰iÍ[P¹òQï¾U\ t<Þêãq„”¢´{G3Næmx¾°CƒYfÈ«Ü‚±’(\€áÌŠ„«W¡}}aiÉŽUÓ÷!‡°y;ƒ¨¢åЫ¤ÿÝ¡µ§€µ>€SÃЮvÜ»%¤ÃL‹¸¿7áˆÓÔïF€Úö¦X Æ<|mØO•í¨Yœøô‚WfÓé1yõÖ“/¨L&º‡põ|2rŽ0N‚öü�3hí°#a¼VàŽÅAÕÎæ�…ÍÑ™ÿëÁ6Áw¥ƒãr('Ö\N¨=çQ1+Ÿ(>h2jÈ#oèw{OÖ\¥yÞÄ—ñ†šfWôàA­’9¸QõÝþ :K XÀþ?µ¬âPgiðŒHôˆoÜ;à:&[7Ž‰ƒ¥#÷½?è»ñðáÛR&²Õ2Óæi§ÑÙLÅáÑ4ñ³Âð2×=Ô5°³þ}‘¿ å^åk«Hsë.�ÒÂ|mÑCDÛþpЦÍ|2Âþ@TÖ’•--±Dt?eAÂ~•ø«�êë¶gâߢ0òX9³)Œ¬vuÿJ-oí¥ÕÆ°h÷EÓÅõ¼ð|C -¦EJѼ”Ãó5êŠo’8F0¶F²4(M´1yj*J¸ªéq±êz«OFòäú=ºæ<‚NäÌ3ô)ýŠËZç HÙ6ÄÊÇ>0çxäÔÁ:=¾SZ„c„â*±gQScM9v3‡ÜEõ-w¨n÷bšy`RJÆÚ! ÊãÙ›U ¤©ÿìZõŠ½§ðúLëÕGóEB¾qú¢Q0å8k‡ƒwÒûoý8öTÔ™—:Ÿ³ Új?%­<þƒ>DòÎ¥z·wÔ| 5Ñ–?ŽëÖc8çI ¨Ì1Aq¤ŒüQzQúº�vøÚì9·µŽi¿¿|¦)€DÔÆßfz`@\ùÂc¯ë¶PôŸ"ömðè€h/I7jB›' ú\3ÊiÇRv�Ž\ôåf[UŽàÆâÃã& )lzŒ¨´j´ãÚ£ðîQg|Méº62W‰<#ÿ¡DžÇã6Ø‚‘þ‘5>RZ³#‰GûË�I’¿5ܪè^ÍèM ¬9ç±ü<v^W”}Þ�q…Œaðâé(ø³—,[tËtŠ"=ÜÝÿG ¤ Ûâe^�÷/=Øk¤’\ì…£Nm¥X—ôðc¨2ÃAFhÞ½XúEY‘y=_ÔÛÛ‚RÛtJcMu}yR=ïËQÿ÷mñßâ`DÌ+ÿõk“Ã&ÂÄš‰kÕ{ëM@ÃŒ—¤¾D[S9n™C¶|-¶:$¥Ú€­£ 4RÕm¿ìš—å møqÀÎï.½[ÀÜê¤WòÑ1-iÄ_Eë[*£x‚ùOÙßz ¦á¢=Mñº>²¨µ) Í.ÝY4ÌIÿÁêÿgâ¨!‡XxøkÏdí€i»gì¹Û´¦ßõ;kªód£;d…(ЇuyžzáÇ9ã]¸xß…ŸtÇ€¼ô%(^쎀*¯kÃé-9à]d«Ã4œÓ:éTߨ¶ú¸…º«â>WÖI-ÆáË<'Äú «¨A†Ð\áë«Ž€''΃ʩc‹˜YÝr`x¬êru/ž�" ¿+<CST”SiÑ×Rh;;.9¤›Fëåbx”sm¤”o/®—aU¥™g)LåQ•Œ@‡m··SÜŸˆTþÿhû“ìÖ‘¥KmãŽB½ìDäB]4,$¤�PÏúç?ŽgÛÌÍÝÁJÔ‰|ù­!¸›[± üËUZòHk.íZ‡—AÊ«-eýÍxöõy º¦9ºROçm}zÛ Qõaë]þ„ý4ÌßÁÉ‹˜ höüƒrcè)eTܾëhóTƒâ@ 4Ÿ`÷:Ž"y̧©—×Ç1éæ¡Ý5”!_(G¡ÈšÕïžèPC!Êz¼ h–åÎV@Ø(Û åš–CÈ‚IÝ›éì¡ài{Aõ8X5C>õ¢7ˆ3› l[)'Ühàcgô—mâÄ¥Ÿy+D#Ü9’›óˆ2×¹€¯Vœ;¬s>�á^àÜϵ¸”_¿^OP̬QŽfî­¶ydÓì ö$†=šÌ,ö)Î)öÌ4AÒFŒÅNÙæ·îNtó,Ówu§X(ÎBø 1#Á’£@…Õõ»á/ÀbµÅ3tˆofô¾Ÿ–ùƒb¡E9ÐÝ“Ócª­Û~±¿”§¹ßA‰˜$KÅ|={‚6ìåæTaê^y¾‚ëzk´®c½$­’21o›‹ð?«0ÚìÒN^Ñ@áÊù໹Ps?ÓŸ,z–Ñÿ²ôªcÌUÕptŠ<¦ýE•¦û›S²-Z¹V ²}–ÿ_m)I1¥á™X6çwnh}Ñœq„LA#ÖdI[kQQdõÍüº&KV:æ‰Ûê+-‚ø[I»G:“Nûém€4>m¡ýa´=Œ5ôÈé8“›¾ýôX<�ï;ܶí ì›=IÏ_ómP[Ì#úØ}ͱtîÏÐʺŽŽ-·Iþ@3jó[¨ÒD+/_oMuT1E÷/õm¶LÅé ³5… HÞv½eîÿTUš-Ù< ÚmEå÷ÚA=Dô]ÏÐv'÷t†èEGÜ»\g% }‘½]ƒ˜nã·';ÞÐáñÎ^^Ú>ê\¾fõJ‹˜ˆØÆh?IYäŒH&±<×ð±¹ÃlKCË”1žQ¹qŠ¹4žS ìa÷¹0‹±%Õ·˜·;Ñ×ÝÒhƒNT}¤“r‹²ÐÒßn–\÷küÚ×F¾qêNœU³¶Ð\;`´A p—“ê¥yôË’Bx"ÓµT¼@»Ñih5#ëÞú‚Ù¯Yù¼™=€¶§'uöI—Œ<9 ÂÑ -µ¥\¶WP/½¼™uºüÚ_Ê›ŸýêÞ´äaòÜwCѸü rv–¾f0¼|ØyNIš\±ÓÓ5xº'íÓÑŠÙüG³¹(QÆ_¦¡ Êcëû_ åBZŽƒ‰ê>¼'W‹oøä÷:a‹¦Xš©@)ÛÃbºFú²UÇÏÊ׸ᳺ ×N§ô(ͧЗNg(mOåE÷‡ù ø�tažÝ!Aþkÿø®gldX†VsW^A1ÆQ#žrjlYsã…c»ºo…áÙ¡rÚ"šçŸƒÕ›Á¢¦b”áuª÷£îy¥âѱ¡WÑú¢Í÷>z–¼,c$KwøÚõú"áÃ.oÝ$åB †&@–‘E Áe–R4Ä9éZ8½ÅüB¤,MIPZäôÆûÙôœ3P¯.#æ¹RmüÂk4Q <3þ,(®Â/Vo?¬ËDðZúäa‡x|ÚIŠ|J=b ´à?§KEHÖA¾‡°f·æ.bê4ˆ9½ÅŒuhT&EGhž$Èa`Q›ßVêfÂê^L¡äC»–bCUïLLø…\_fûú¢QÓ9:áQ ,“†bJÕ¸t]~ËEˆ}…DÈià„0Fq…}ž&ªAåê"RN?‡m=Eµa ¢Õ\õD]ïæ?ãá¢Þƒù°´B»kô /üW™×[‡rOàœIü«3…åZñØTG_4•A!ü.÷Uâ?….Ý=ðcæñYÍ‚y°$ª£ ŠŠ£»â"á#ìb¯ŒwÊå@Û3þì”…‹å΀ÍŽƒiå§ýëÛv@ä“|2ÖD¬é‰&Ý»×.ÕLXJ´>$’ûo÷½Àã2õ]³ØP†~GÎJB÷ð$Ñ–ùœ¢÷–ßÕãi¸Æ¸¨'n7Ê¢`5çAYë¯@Óº­AY¨…µq^îé¸+w�h€O=`³ðÑáÜÐéfB:ÎÙ´Î*ƒ5²ÜáMÐãK¼Ô#D¹ 9ÖcŠ–üŒ^;k€`¼ßºÜÝû°÷/-hÐë0’ø8ÒŽM/zH¡='<id©ØŽž EÒa 9äø+eøRõjÉ0U¢g‘B—Pÿ0}YbâЗw�Þ7 ¥D:d-«úØý:=,Ö!²³˜y$‰µ_Œá93š=ñcäw$ NË´B.9 ;9^�ììÌtó6E½þÞ$Ûñ`àªÞ¥ßÁO•^ó‘F €åž¬öG6|×°À*ôÖ!|² 9)ü3=K>Ý¢n8dWíË{ºã¾ä|*ˆ–Õ[ϦÂ;zä>-Çßø¡7öæ¸%»œcö6whÐcgÚP¶SÅüé|ôw°vâSj§�[”GE¼`ô‡“­‰)¯¡‡È§)÷­þ FßßǬxÆ®\yßx¸ƒæ´Ú¹‚òÚ’ë‹.[%‹(C¬0ü‹†ÑN>ûÞs" c…J =…´®¸ Iù×ë8ÐœØHv¡¹m•¨Ãmá·š¶V¬1Rh«€£€¬Ai¡º©X!,¶ŸÑ.qáöiÎ o:›³~kr]CƒZš®ëlH1a<í¶*[Jo^ ÍÄY4Ó/bY¦²ýã[í"©¶`ꙡr½œMøƒ%Æì-ÇBêf]¿H”õPñSœ�kÙÚN #Bú‰=é³ÔZþ'6¶@z=$"Ã[ÿy‹ÐOhšÉ ¶èè1žŸê?ê'éâW¡z®‚|üãËuƒ¢ˆ¡ßÎ1²~<““ÌçRÊÕS@Ï?D„¤…Š°Iúꪫ-`4h_ð}uGÏÔ±€éUƒb1t@ s†Îª5ŽçåA©O½RÒÉÚfæ|$ÓöeeÝØ8Œ–:1¡­%ŽÀÂZì¹ v5‡Hä½:‡M—iÁµy¬§yÓÅȈÝQ.a3[3žÍ¬´ëøÌñ.W˜8ÊÚÝd¸Ö» ÄèS39uÜŠ¶(Õ«¬Çߢ-ï†ÏžØ˜¸Î­i”° -T#éÞP¤þç-î ¬(·žïHÉeyš)þŒIUCG»ìC±3ùØÁMðÅãxj·‡Î¾bhÉ%Ç 4.ËŠ¥“E22¦± ¢qöò9èÔmg“=' Z’]®JÌô–Ñv2Ÿ“ñ õ^ºúHÿJk9‹¬>¯Œ‘¶Äço±jÌ>6âg71à•„…V<à ÜVc|Î ¢°Ù¨«™Dýµë­„N€ÿT”Ü™Ífôf¿Û-c.ìÎ0Îúl‡+´äFg>«‘¢€9Mé5vƒÙ¤*i!™â5¼(òC¢:˜Š»l±Ñ g€ifðštu®²Ï·–GÆHvža­Bú°¼W i9TÓfyâéYU¶°1§$1§{~4„˜‚ݨ*ï­¡ìéØr�!³ù» %ñp•!û7N´ ãÏÞáh€ñ;ì‚3¿ò._‘3ŽŠxa-˜ »óñd,[ÿ5;­<´<7˜‡.T«öη|GR':‰ j2ùíe¸‰·Á! }ù4aò¸µZR¢Ho02ÆÄçî h ™Ò_$Ô·ª«óÙsÆ":äL´aB¨ý¨åwð\Q«î¨®‚)€Fª šOáe3:ˆÃ_šã¸¬âÌÊáÀÏä+Ƀt£ˆf`§ÝfÐàNš(¼X&(*ßûÉOCSJ ܨ‰GæÓ@9I¯í%P1¨ï7„¦kY² ƒñü= Â^kÎÓ,åsÝì>ÔÏ7IÂ+-Œ¾§] g·óšC úlÛÖ"VàÔò"}šÃpÖ¯Ú…ðDr§ŽNó´×8”ñ0 Hëö.©ð1˜-|ò)ðµyT[¿Šü`ÅN%üí4ÇØÈq-i¯n†yáËŸBPî@§Bܪïo… ÂápÄôYNÜå$ºR¨„Àñ&6$„…Û[ 9ÞœèväGE>nèž®ciØeh;˜6Õ–Ö“ðíÅ­ÑdZ�$l»³0„ù¦üÆåi9Û ®æSmaͲ¦·¹>[ÿ¹>jr%³—¨ût‡€±e’:€Lrc!n¶Ó¹xÖýzäUÉÎñvŸú léåðÍé'úòÁVOIàpSƃº>Ë*y&)S…¾ÉEÝž6clѦÒÖ¤äË+œ¥Ù#¾z|ŒŒõí•yß}wß·VT`¨€¥?aÔíDkcsb½ óûdñÑyf™“E2ÊÜýÃúmCÉØjƒáÁOŒ†k‡ŒF -£™wšT⦵"s´,íuš+À,iÄå<ņö¢­y°FJÎå‰t¾#$‰1Ä$h)$ë‹v%ÏÞNÓÇÛ×®;³¡f߉pƒ$®_±b_’nä6òÆ»Â,Z‹Ÿ9Oð\ÛÂÖ]Íxø†lçWËÒ2°Ú5‹F%¤¹D …ÉId¸šî›É®‹—[ÎXAôB—*è¯Dœ$Ffà©6À`<÷" ' súv[(ɤí=”‹z+ÙAô ô¥!ÆB(H).û8.4aùF©€é´"æ>”‹ÆD(o®<f³cß”7¤Íä¸Åc(!è4[Šv7Ð U7fj©»ˆ§o®´ÌcÛ†. óêx(‚bÕéGtJw³–£<ýë˜!÷ì(©éíB× ñ ¨¹Üú2(?õPÜ�Z¦ôî$¨O›ÕÖ°Ðw#D¥WO¨Þé š@=åë›o“¯cý�å0Ûb¡ìËG;órj*`¯ä³¬0Œêɶ‹ÃZØ°€@öÝõ!¾|°ÊöÖß Â"kÚÆê+ì�˜ã8ya¾x­°IÀSæuñ,ô”—õ 9Æ5ÐŽ6÷Á‚e ôÛŽnuðÀÉwiê›z±‘qzç Æ -ÁärÛ]øC>NaA0—`¤0V_¯Û€IâX àgqÇxÔ±HVȤ0þ¥ëŸÏŒÒÄËÚŽñbzZ(ÕEÛzÑŒÖbkµ\.ÏVMéŒÂE{´OƒÜ¼€çÛ×'JêaWk·å§QQTxƒf”vC„vˆY‹¢sçéäìê –ÁݨK\c:­è¨ñ-Kél…^ýÖKz¶fø¸t罫ÛôHmZÈ!Ö ”l#£ ¦{—Áu©¦·»P·Jó¿«×ë{?bI!»…D©gÞ.ÚjI±…YWS?yÒÑç”'®6eÛ²©dÌCdõHkØËkýuË÷Õ—,|| ¢NÇn5;á =]*XÆf�Ì…Aƒ³Wdª³ÔˆD,¿Û%A27Î?m™yzS;,Ž7¦Ä5üÅë¯Ri.·ÚFéuÚ»ÚR€î,L)³M¤Ö{ò¿Êûx—ê~±yO jÛÑ•ŒÜÀçcJÑŸ¨ŸY€)Ë'SútÓ ²~£Ð¶Ù"s”µb”ÙŸ9¬ßv| ±´�C([›8ä†ð†!´ìäù04¼ÕßC½u/r194ªì +3¿ŸU8˜¥<j–»ÒtçíësZÊá/©HTd§Ápö·e<øÐæåA×4ó•]é©)â k@A»çvš*FÃÏP§‚—ÐGpø,F±äT´J2ƒÒ¶fU€ò*ÒÉÞ”ÄØxî)).wLMh€ó ùv<\ú SHï.<of ‚-\ß[Á^œ‚Þ‡p[_jJÝÅR:=MMz’Û6b¥CGçñm)â£Õ5ýääK¨Š×`?цɛÎCN*~Çv—­˜ànxÎt6å-“PîÕcaúì»Âˆq”i’‰sëXü•Wå5‰X ½�dNŸÕàm„8¡ï-bH¬ìÛ~çþr0i‘àßž÷c)ÊFjÇ> Ò^‹Úª”b°åÞ¦Xû©üí…ía„± gjú JöŒŸ›Ý+“”<ZˆM@r †÷ø§ghXÓ³œ·T5š7ü¡èËB×:‰�Ã鬋›q'Ýj>PfdzšcÏÖì6àÛáxÍS-T¹GÞ”)÷=Ú7V x€¶Û�¢ ß½¡¯×Á‡ ³©åÙÝË‘ÕèOÚˆùŸA4o=õÑ=ÆT+Ñ«Ó×¢-%EÌí…Íä±�áMÄÈZ„akA!šý%K0Š + n j足ÜPæì]‹[âjÎþ¸°¿eºm/Ô0Ò <}{ú Ð&¹È‰Ñ ­•U…¿Î雾ÂÆ*=DânHŸû€tbfÄ£MãAØæÍ€7z(0.»ÿS=”òô¹äJâ±MĺÃz=:ìÃU­¼øn[ÕòR³Â12/�r G;,TI‰ïGÇ3nQÙë5ä]‡ýÝmgÓ¦(4âÓ«4^mš#½‹ƒLQÐôÖÓÈ»ì®ò‚PƉ0Q…÷œ®ÙœõÉØ’çÊ£NiéKVª±¯Ë‰‚ i1±ì;—ÒÔšÌÍØrhÐþ02kt¬­#_a<ºï9zb¥fÝðøÂrLÆ®ÝqØÑ @B–ÝcgŒ™™‘-ûXF¶°,SîR¢x7°¾Ç–é‚ GO«ïhEGíìy4‡ =a‡£~Í>,J½ÑTÄu6Ó¬þTu9HÓ:»,¼¸¹ðÜ‘1Š3ç®Ì]“3É”9Ñ[ Z™ÔبÔ-Ž/¤ueìà9£ã?(Gó»1€cÈXS̵ä‘Â×Ï“¯4w€7SAž¶=˜Ü÷ɉ{!ÜxwõD¦ÆÃ% ¤n})i3þѺ±`ÑÈGë yaR£¼0r‰4ô_Rľ*írGga…¼ ”ó´V­‹¤T̉­ ï1€×}8Ad­#•LéwãùˆàCÊŒ¡;ã¿Üø²:²ßæÎâ£ë‰°Ã¿¥ Û>\Ù±»oH"–z?¶fFu#ßKÊÒW‰ÐË :~;)YY¤;«ü}ùNrÜåqè©ïàûfÓjfc²IC+µZÒH†‡‚SÓè|ÕïäÍ—ß¹îCTͺ¦À^錂öè±ýDúŽ p<tCMCÿÔCŠÇ­¦S…‚ˆ{ØžöÞ×0J“Æ�ؾ{ZFå°qQ˜ÿÈ®‘xwàœiš-í6øÀH­ôVVñWÝ/œ‘o%ÄÆ– ÙHÖ­«™ö‚Ì༙7þ-jÃ6E*åsNAg¶ˆ¼ˆs�̤sÅŸ¡ßƒ u¿3ÄÀõ© “’ºþ<›ö§8(;q꽇ùïO< ¼ùê<„x2=7 ’ã옧†öã+q£“ŽÒñä+6ùÒMº@„Ÿ‹Å·-y‚ãô«lZì+»ÿÿK›(w�r½oN)=Ÿµ%§l1^¾:«Óp¡%¦¯hí,E”Ûá­°™ºï$ ªñè|:D&P›ý»ÂT¬ùyo~íìÿ"ЛÐBOæ‹C0ÊÙ»¿ñ-èÃZ_4пI¬§3æ!Qhí;óuO9þîè÷OØÈAGȼd൘ ªwÐÜxbÖšÞÊ¿¬|ŸQæéµCB©‚kí1÷kC¹wûÉ6!8ÊßußþÜ©ÃhQÌê‚eß™#=.Æ6{•‡ñ ƒUšùƸU°Ã(üX{#ÈXõõNÕ×^ö sM"-áL¾¹¸ƒNjIê-3奱Kä€8ÜòÃŽžÏm½ÛÚwÈ)Ø`ˆyºúú?ÂêÓåFøsèHÅÛ Dþ½k¹³·í”|öUr“‡5t–;à 4l‚¶§ek‰·˜fÀ/„«H¹E�Å›öþ¥!?˜t„?ﶴ^¥™Û×W9¼ØžËœ š¨!6uħ³ƒwß+*ËPöi©C§4oVuĦ’«ÿDHO“+Q´aÄl¯ùö¬OW‡óQQúãÀ±¯ÍØ$œ“°Ë½B.bM]8 W[…! Sì”ý&Û›]Îþ˜9ÓàL#=7IötìWŸšÜfsp=xÛßA‡mz%J ›¢¢cc†×ËôŸ°©‚ö0 ïág)®8Ž3¯6ç*4õœ~À“§½Ä0sÆK jez£ºEøv, CÿU{fÓ ~6Ê) ‰Båt†VÊæbÀ¼o¸cÿy¢“®ÿyÓ:#Ë]ñ32BùS;>È|ŸÖï4S| ×J—Á£OãAzz+n/nÜ!Y§ ££™ÞÎ:,ùÓ4ÓªŽ„µ0e:|{ñ 1{þÑÀ‰œu¹<qP ¨0½x9#àš&·Å&á{K¸ÏiwÖ‰qBb "‹%[pf½EIá#†ñ±qŸ«ã§ç-žó²;¡H·øjþ~kâ môDÜš#gèZ X^¡ö—æ8.}`?Ðg ¥•œb€Þ-6 2j…BOêGñ€ä–¤ ˆó¥"qíµSEàÓøC<]ÅYåψ% ¡ÊĶÞ"ÃYëúÝŸÒñæìcô$xƒ¿MK\âš�Á æø¤šé•r:¸Ü L–¸àì/@+ eˆóº¤ßõî­# <ý¼×äVÓ<¼Â¸mzÚ¾Qûnu1o‘Ìsó²}3ß™sèXâOF1¢-XwtÆ"ßp\„h?é>uÓ·ÞŒ)úø½­fp½ÛˆËðal˜¬Æ/ÞL`8hîn)–¥GµØ‚,Ë–¥ ‹Ú³<¥Mø†]‚× –׊'Ʀ@´>@þÞ´4¸¬Sܵ}Í4JÂ*Ž, Æ5¥ã@ÈȽ=bl‚¡éi ѸG(¼ çKO;cݱ[/¸¿[ôtì¥.Åå÷~PSȸ‡ÀÏE'ì¦{Þ­çé¤Öž3¥î •ÞR¢ ÅNÚ�WCÔÈ]ðRϬæUÌu¢­]—\õ(_œ 2»yŽ¥¼Ì1+<QÞóﾶûø±\ }ëÈFØÜŽ8(/ïž3Öv®ʺz{é•x—Ú6©R«‘ŒàTgLšˤP�‰ª¾[#L^î-J4±cüP\ævytøŽƒ¼;{:‡fêƯ3>=  x÷Åáù«Ìsö¢|ÜÐ[6Ÿ&žI®¼ú SºuD:ö.ì{w¥SÙ›\¸³"ãH79ûîìvýâ° O9¼ÿ?oyþöï[ZkЭœ]¶Ê†Œ`º[U¥f½M ÒédKOgÅÂ.Å+µ5ÿ‚íh^^ñœ÷]„ýÑ£õ»½,6®må]^gƒ±?Äeµ—3ë·Öœ•Õ0Ó$ŒCÿ c•eû2¦pïNÙÈ<ÒY(ë"8ùÎ×¼³…è<j…¯$ ÒAç·±ÐS-ðÁ˜ózÜÉ4(Çê*4 i÷nV «¤îb )ûç'‹�aîPpYñiô´ô(*Ñ­ÑÑ ~Æ`ÅQâG*Ê÷?å £Ò’‘‰íf7¸†_CÕ.wZ÷õ®N¡»ÒÑuèÃÊiØÛ`TÉœ„kamϵÝYr¯' ?e´‹.ÖÑVïù²6çä¡ß¯w2xÑ«'¿DŒìÚ» ,oN*…Ä>‡}ßm<n:0Á”>KW}÷%Ó…»?„A˜ïYŽÜú« ¢©õä ÛÎ#ýó$Cî³w©ªîÞò»½{~É£$ž ×F[t™˜Xïôýí�€-(üTž¶LæÁ4µv,¦n¹cV'ëÿš”sZùLT�œ»ö\ï®ñÏq°À=ž8pÆèl~Ô HT×*Žӻŵ2±‚h[äöPt9ÑÿÃŒ*ÉCßR:~Þ{õÆ„qÔe;cðôÏÐc·>ìT“µ±{Ùס¸I'×ò,#×CeIßvKËv¶“ŸR5%yañßL¿R‹KŽ8Ž¾"?ù·ïþ5?q‰.;@AWÑV!ý5ÆÃ|Da* —ª)C­;Ï`|óß“)÷TYƒºéi•–ï'€†`ß¡ð<óT[œ®ÅmõEíà4t~Ь3%i®µt°Šm²¿ÏrãÔÔÀ²™ÊN¾QSqÚë;_03üçN;¾©k¼Oèœüɲ�¯ˆÕtÞlNH<·ö@g/,[û‹o‡¾x†¦žßûÝ16W•WNóh\ýe°mg7ûÐ ¶+¸E§×¨¶¬+|yÏhœ¬‚$?hgê ׉ϲ°Á/L£bÑï,ƒa“åöìÅ,yn–w{êÅKê÷ÞÃIä±Ðc¥Þ%½Eh@‹náV©üº«W—ù(^ô©>*'­=qžRúƒ¤[m¢@ŠR+wz/™M?–p°djÛjY):|×ø;c„õðӦÚÿýY¾ÔBäÊ <n{èp:;LICAˆ*[G§Ç¿£ÉÄ @úUý‰–™UЊ ªII­“Ô¼;»Œ“ì*5îë<ˆŽ¾ÜâÌkx0þMø<pýCÓ +”kþÀ¦™«.jU5ümievAÔãæÒ÷K=ÑŠÅù|;æÈãÌk·�mGÙÜû 0¼ŸÙ,—«‘ñ3%JŸ5Í‚Æžgÿí7rd/ˇý› d1o<@^ ¹…°S¯›„%xkI:ͺ1H$z›Á˜À-¾7ä¸&]}ç«"eF±gk∴ˆ…yk)h¥oMc÷]s / 3æÁÈq&ä {e}ê“ØÇd„ê…aK Œ:Ü}0Mà_˜a¤ŠáÌMØ9%Ç“î4È vErßå'<v󤘘àÈ„±dÐF0ü:ai#4Ĩ€¡€Aå+ì±2Î<|(­«¹±®?¹î|î,ažc€èÅq²+¢ûü¿¸÷£툪ò—q˜Ó% ²ËÑ;šÓÜë؉òhÝi‰òH/õÌ×yšµ=¨ön›žü î9Š×g¹L%~ú'ö.¢(!V =vyPµ£‡Ýfqò­'ø^(ð}X 4¿êçBŸÁHéD©1ÎIPØ 0QßðT,ÄnŒz©þ.ó¢ vU)ã].0,Ì6<~¾ðC {ܲÔßœU‘ÛŠ›�0I©>u2–ôØ90Âc{+À'ƒ©˜=hËé]kG à,?ÖäöûÓ7w‡UouKç·ˆ¬.W¬JZR˜bN>FôéìçŒâ´FÐBtøOÝ æåš&Ég%ä^èyŒ<Ì+î’ÂÑð¹0Ÿ‚׸MVÞ^ành‚Ì ï†Xº¾GúµÍÕóo=[1(£°¢¢Ï.÷šRh3›2*¿`º‹±ŸU¡þ©­Zåþ±@1µI“ {·$–‚Ñ-m»tŽÑÁ¦GêöOʼnß/a6ÅVk½2æmévý†ù""É7R%p´rÝŒ_HÄ^ .þ6ž-olôˆC{€‚ë\’kèï0)´±çöGj\|ëWUKh)=Š†žö0z°þK}¬žžÅíÿׯD´Hš®ãX££'ÊD¹ðçi§jÒk.y:Êz~[¨í`bÜyWë<ÒAÏøN³à?àø†©; ”Œ—_jcX=V¨Å06kõE«wkµSY¿Î¸[àÑ…Öíh]r{q½p+'s(Á£¯‘Üû-<äÝä›q÷§)pÍåßÝðïý“é‰Íœ¥ï¨lßQ`-Ö–e‘ÊF_ïÀ3Ð pn&X÷õ¿�À{NB¹`õÜOF'ªU·ÚÙž-ER$büõfÙ>¨™zC™ªˆíìémCÂãxÍ~-ÔŒü+`§‚´Saò²±²ç²¯­([TÖ·ü“˜aw´¤1}Æ<§4ýVQh~…ÎaIâX tH_Åت؄xqB൱b<cÜ~ÙŒú´H2Á×zaêWÕ¹ßUA¹Udw‰l|FÌh¨¦_Õ3}AˆÏ(ÎaµÊbÚ@³ñ/>ÈÕÿï‡ËÊWU 6]Û‹S×µÐJVh­Þö+$÷ëÙͶZ~° ×OO¡›I‘ùg?œ>Xlª *h‡UWä:æ\<tÆÅ=Ñója+OyünC¹Tëа¬ÅÔŠ Œù¬?£p!‹OÁ’¼ñ§úKAôN°zœ8E‘¢l‰Äxl0U:'slÓ,@=ןŽS»„</Þöɇ¶íE³.€e§]ÿnÛ6E NDzª?ÈFQè|ªÙ˜F×ýÙ© ñ¤ÇÅ}šÉºU¿>ºŽ3î±"\ ¶>.ºŒ9lv¬qÔÓÒ;�è?p¢)kvùÑ­÷œ'áDH·:kÔ›>Êì&YÓî7c´ã]=ÖÆô«x´=bDCÚÃʼnb˜š„ÕŸYsSc§YÜ‹1Êc' ±ë3…Þ¼ÓaÔ¾ë9—ñÓ¬\ÃLC÷ dý¢ÓEè•Ga&Äêxx÷d ¨ðîh˜°y•žj£F©©3@zË­·ÂbÁ-¯º}mhç&Â¥a‚÷&EwpG¨×ÌÄuÆåßyùt®e8ºw³_ßOÀRãèQ¦G:Ÿâœ¸«§–/Ihœ<6”8Ĭb¢{rC…s7ÖÍYå…»ÔÈ[Ì/½ŽüQ^¹qd®^Õñú]Gß<þÇë¶ÉG,b*¼×@T…]† ¾ VŠvò\TÇ-¶Xû=B¥ðt YMcw¤ yTî\ʺ‚â}%àô­H#ýÜÆr¬ Î_yP~^<ñŒÎ˜™‹JØù�)�…Œ_}wÃrò ›¼ŠŽ‡<ˆç‡¨Z%%™&w>°f#ºŽ“áàß½t6†’4pO“‰ãH¿! ìEŽ,³¾&Æhª�ôõë‚G’{²d</ﻘËW !þ†;èÿûHù^Pîò?»“5GÞd“=бåê¨ÜxãDaùöï[¤ìŸ,âÆ ôzå¿•¸ö•=ržG~SsÚúŠë›ÅÅžê+…Ïõ»uým_ŸYÈæé2ˆÑ’ÑèÛŠˆ|-¥º¢/lÓI=i¤[°îª©‚ª¶ãÿ0³S"°á!$÷ ÊÂÖ?"•g+5•‹àŸ`”dŸ±,Púz’#”ÊÜ5ße€"»+eŒÊšê2YÕ@°ÛÁQ%?†ÃY•vc°oÀØ”ædKãœiƒ:ÌêÜg<@.µ.šÝfÓÃP·í× b/üDnÌEÒ…ÇMB÷«¢ýaù¼WZ¢Ô'È’cw¤CP7Ø_zf²€ý¡ür@¯"̱âê XlÖfïoOûã–69ÕåÓy“!PÉšp¶À¼ëŒüê€2NTèC÷’ÌkäÁš Ã:½)lj'× Iíçÿó–PÃ?~ãCšÃ…û†póí”AV,@ö”­¾bv”X­ Gž ÏŽºå­9즠c‡Só¢€<Í‹‹Ê wùèhÍou#•E`5Ïxpi‘Ùò3óf· .€,‹ë‹0¶IQJI¼ÕsØ!‹õ×¥”ŒcÄÃY­‘TXYÓؼ±Þõ8.­Öè}âŠ#°*P¢Æ¶-‚ô¸u OäBÞdŽ‡¨¦W5¢…:j˜›É欎攕жGí7¹qöîÔWO¦œiâ!*˜,?íD²f–TöѧµðÑÅÔ—ÛÁ©sׇ´aDSsûÇ)«Ñaõeû)+PG}±N¯ Ñ{ܘrÑ»,dzõµ§‹ñUÛ*ð…q™Oºá9ºYž û¾¶¢#´k%Òš×¾;Ãöz!éeíÆ`‰î$”l²M£VÑ!û¶´¼<ÔqüG›8÷ò9;.|¤a~ž=ÝÒš*¥¹³Lé¶Uñ’ûQ¾5ziÔõºïXZ‚‰¾ë–I/˜;­[ƒ–ßúÉ\·QŠwËx±4¾Ìè¬îá?ñ}ô$¸³DÙµ: ²/*;æ=µ)v«‘Ž‚͉òˆ¼ßxŽjLùœãõ¯Ùz˜é‰¾JL’ù‡ Ýåq“FÖ €×-(éväD‰+Ô0¶ýÃLü;WŒÄ2åGbú9ÃƸ,»þ/r,ŠèEcÝ lo Ÿ[Ì)ï9ŽðJýªÎ‚¢QE‘ž ‡8¢ro áÖ§È^•:¬4K l¬’¡ú4ÒÇvËy#+Ï^P:ÇŠXœéïÌB|'g^5è;¤ƒ2 Ò\õ=» óŸ{Øm^­èuõ_’xÎ è‚*IÒûÙ‘hÅ;Éà|AÃÿw“ÇMƶ§$t_i£ýž’;TÞòbQ¨B)ÆöáÊý!«ÐT´º€«ŸÓ j4¹‰T^dßÍãáxèwðÐr?a «Ðvê"n¹L]ÅREU}¬'R ¼ÿç3$É]ïÞö›ªÒvòš)†d?åoê¨ØŠޮhÇÄveãŒEèH¶·ê.–nhÎàMèNMŸÉÅXASÖ~˜-bÆ‹*µ±ªÛØqŽ™è]#ñÉ «ÑžûåÏ÷–ˆ7C¬ÇRk£²>OPÆÛõ ±Z©–{'VYúú´tü÷}±šMdm$é/Ô±ëק7 AÅŸÝasïG·o©ÇÇ‹ÀfÌ9Á´·EÑAvðx¦™øp€¥¥ß¥bí0vó½*çxêÍ}åý×6 ¡ŽÝ†râÅ7÷Zñ±‹™Û°3nëµGø“G‰ (ƒ¨ëÝ€ŒÒµÃêj°E~<zBÀPMïwÝɳðzÉÐ"It Rôû-ý;3G¢œZ+ÛïZ(+ _á¦séÂêp†¿³ŒtÔñ-¶Žâ56SÛs¹‰üMKåœõ DÂx†‹°]ätd²9—îVdæAOÖyÖU&|ôél::Ö¡J̇œû ½Þ%J‰sž3Øͬ 0àšúlÇÂ<4y„÷š‹Há88ZxéûY½ 6C‹¸_6ý!èšæÌÃl»77ÌÏ\~uÄÌ3…¤ ‰ÁÔÝIVDl¡{û:iþ.Ôb”M+ä<Ħí%ùÕÏ»c–Þsvùú@->vWζc\±ŽánaBN+÷( ÛøGßÏàG.õ( ëo½ã;ÆXÐ|êSÁm ¹Æ°àá¼p€Ø¾ZÆyã0‘Q·p¸í/Þo‰¡ÚÿLUæd\W¯¾D&Ë�U™/å²eíù®qµG£48“Û ¿jV‰Éž ˜Ä&|칦©4¯°ï]ió†L]Ìûœ?\ï‚U…šÂœ(ÊÙ°Æ4‰‘ÝýüclÈñ}’†~ɦ÷‹àD,�¿näŽvmvä û†•í0<ÂgL‚ŒùÓ„8`ÔmNÐ5ü 5×1"Ÿ?ïþÐwjlc9eâ¨h—&¢E³µ'øÞŒÏ à$É®@3Ñ^Êk›I!W…l³B)(âÿóÁD”yiI!^}–[¯MåËÑP€Ò<™T«ÇžëTpGÅ2×:暌Q–¿‡ Œœú^"âxÑ£ËÑ-w¬h0W§k}},Ž'XLí~ã„®KFñ9oº‘o—ñí2m °µ=LìR„JãE……Ò㪗bj…1¹e— |Ý´ª¯ÝLfßÑÒƒ‹…!é¡RÁð9{â ´e;³­ Ìú÷Ã'LÑDRs¡Ë!‹XÌÝ8¢qäïÅáYÑÂ5ˆqÏS _àƒ›kƒ† LÈÚÏo«#{‘v†3•8Ì‚QÚÒyjb¤Ú3_wŽˆ4ôþmð™·ô.³_!ÿBî?Q— ËØ•®ÝF¡í̪Ðâ›Òm¤˜„­eþ+öÀ“jËZyŸ£žk”ÏG׃Üô—¶ÙùáMmÕø¬YšFTÆS3Ñ’l{ œÉº(µ§l"OßÝBAuúþè{ßo°2²ÕžÆM¯Îìá=jÒDÅ-ìéØ ö˜—;ú„yž-¨YpŽ(GoÕÉ£/7<�×1L»ƒÊŒÓ†cx®Ê€þ– ÊœíW“Ý�ž®ÂD‘?ÔÛmKA14ׯ uK«»­ˆƒdýÇ›¬,ÏbÚoãÁùû>pûÍC¿;‡’¦¡¼²°£(§«INÆ–)Ú¿=K'‡+Øúsy÷m’«LPèô£PíÒŠ�̨Êê…Á”æÂÙ¼ñ±ÅÇÓøÕMˆÑ#ÎdV¸–Äû!ª“-¥0Åÿ<íp¼Ñ1κF2ömK¡n²ü3 oJç £rêóg$³ßÒàˆJkÆÞ¸Ï2{ñÐpÍ×Ò” ¦X¤¤,qI89 6¤ú„Âý×úQaŠêû w«è+ˆëÎ= ›c=ÖBH„!xM¿{Þƒ ¥)ú(ðÁ£÷\všž0§âй± |Ÿ§ –FÀêïFÖ3ô‡y…sÝ“ ‘±�y~±ª4‘4Â9ƒ~ª=þÀµ+‹\íÏ´œÕL RÚ®M!Æ|³Û.”š¯W^Ã>P€qÕA;ûB£5ìZ ­j¬ùëKÛ ® De°T‚ŽÌœlTFu<yzog¦cYu!~Óäyú+8Õ4öÙ‘ ::€?¿-ð·¡«Pv#À ‘; Ï YhÓLw¡Ñ‰è{Üm6t¨›ÆÁoÑÁ‘¥/TF+uÿ{™Nq )AcÂówæf¯NG&hœv’îzŒ9tHºƒË»?DÐNl‹}Û )©FÕj&až€Gȼ¯üD28©ô£äS¹)™,èhuÜj@6E±úk·“_4tgÊ?ºÙ»z¹G‘z"•æQ5Sû‚wÇN3¬GÎ8±Ù­ Z2YU×4ôû?µwò;™`ÅâPÑŸÆ»s´bNŽé”[¨Û¯ÜÛµ‡ƒ@*† œ™¥Ãë†á†ë£ßŠß(< þùr-ušlR]ö8•[µóA’¼bsŸô‚pM9'ã™ k™µGÞ«/ô øÜDMd&cÂ÷úwœ"gWZÈX#$¯O¨=ŒªKýšú›ƒ4KŽt)íþÔí™G„<žaª4Ö ÇAïª[³í€/—c'ãHì*ÖËA¦:­Õ5‚-¥8Ü-‹fZ€MÃÂ’ÓÕ()]^”¢fÛwTâæÝ‘cŒ¢T˦(éEËÄô„‹Ç$š£ä °ôµe4$zô¿×…CîzU^¼J¯<½Z>±C!ƤÑ"â~ŽŠ(óÀ”,]\TýÇý '!/½" F(†ðÜ:tÖW� D»óšN¢~ð^,­ãIÞèÉÍöå 4‰Ôttãë$(gýè¹HM©ç‹?Cò~õr[Än" ;6Šu§%xb^ؼCUʘèúŸ8²Q’/ô`y÷^(^¨Ê^‹ÃpQXŠz ¤´ >ºÿP^UœcÊJæöf;Ó/´¿„bFÝ4‡yòÔαmÒ £"#qÀKyÒ$ó&¡0O¹¤Mü>:)‰Õù@V×éòp(‹8©L¯ù©V—?)Ø ï‹-¢y”i5Ú§®]o«/«4RdN‚»?Ç.‚Õ %•‡ç<gkÖ75ÝŠrÿnøÌdá1. œ ãžÊîq²1ðºã]÷³òZšyw (cO‚jœ=o§îì¶íbLCž§ìQæ¼Åùu_xÔfNÌÖ‡®A$‡÷S¼Ë[MØÅ8¿2­ûî›nh1}{zX´àO4êYŹþÖ…ÌSÖ+!XÖÊ7v‚¦I­G9¨l-rT5@ßñ_ûè`îGŸk‚Í|y|÷ÔÊéo,ãÕ÷j{åÚç †–µ¾D¬ÁæÝ ”ä¶Ú⪀ž_a7ä¹íÑ3I½ï\¯ f·ÍÁ;¸gH¿nƒÁoï)å nRæ~²–9B>¤€negaGõ=+Ò¯­¹5!"¬éà~¦?¹ ËâE?ñÐ;ó Laõ2ÃÏM¿Ì Ëy{Ä™{:¹©¿xBNvÎSƒ„ÊR{e†‚7 ‚Ä"E"båAuþc`š�î\U›(â{->lEEéÓ¡` ϲM« è&û1´"äããEÎGMiçÓ º<]ßÿü½-˜3ßP26TŸ¢o­¦|ÎýËÍ´­Ï¯¸öU±•¿‘ИÖôbóØÄp¦ßÀÓI–qÃõ®n“ý* —§C3UAZëÀ§߯§Ü1±lP¬ÆËþ7}ØбÛqøå ‚CèJ¡çÈ$ŽÝ@±ò?ï„cÕ±Ö8ö üÛU\+¼Ì€<Dc©­ç–‚½ë¬&ìoä•œ6·Þ†âßm”&9-„è胴7':±!ô8}æçø­•P I¶[¥K‰ö Þƒ‚>ømhóüÔx†´°¢²ÃÙ,ZJu?wPàyiüöÔâG×1./ÜÀ#wxÇÙl\¨dQ¡ÉEÞÛôýd{5œg¾ Kv»¸?9mcÔ¾–ž‹ÎÛ}ÆSE·-­ ¾#ׯf{f¹+ Yχí¤ã­' ^÷Çmí5o~o#mµdFÎâYX@2$Ý¿vãfç¬Ã‘æQýÞ0.r˜ÙQÕ6á¬ÌNb¨^oÊ>µ|ÀM‡µ¨ß+ó@œ!æTzîK 5Ž�ý[ÝlLåÅUOáù4ObÅ°íŽÈþ~.ŠbµÅ•=æápäùã¬çq Çµ…g«þ0Ï4@"–á’ñc®‚ø½÷Út¨¸XŽFµgé ™ÔÔ»~Q)0Š3?Ù*˜7o¶Úm„]ÎmU²¿»ïmé< }‹ìžE¢ÄjÙóYÆû韷¸ LPÚ ]ð‚×t¡BÅâ€ñ6ìe/&€–´Ë„¢©’–'¤tp!z¢C°ÚF×}½;çVKnƒ—«yÖ®÷0}ìŽö)ÓV枬þ4X '¼c%l k•|ƒšLxÑ– ŽFaÃ)­ú÷=Yâ0wBqû¡�fô£iÑ1«yAüú ¨�³¸<Tä�I;)GÚ ÄÂO]»9m÷Kw ƒ]Îú™Âª ÚF) {uwå Yuã}äÖE0­(K\¯Ž™1\\Ek£¼¬lÚ‹®!kËFýɃ,dž_‰Ë¦™«]ÙP™‰øŸß-ÖS¾6mÉü“6záÖJÁ‡ä©OKÞ+p/)&Ï’ ¢Í9tæ«Qì½{k“âJ7z5Òïùôqä"ßå|B¬ÀÃc®ÜÅÉ¸Ø §ÆegÒÀª³Çß_T\v)hNcµçéæ$‚ȵ®Z?»í¥ž+BM ÷Æãc4P2ä±…aè›Ý^ÜfÄ»šíTÑLÞ­üw&Nk`ä*^à….ú_æÛÔ2ôò½ iT­f©rË@ç@[u/f¾/pˆcZ*‰?õ˜§„]IÌ Ävµ; ñ÷ ð(ò,˜-H5e Vô™±Ä;…Ë‚æN÷s9‡IKæÚ§´«N •sƒV(ЄɅ'Ì–ŽÎå§lÑ|Û2f‚t­Ã "Ø%¥›–S3µkTLøl…)ƒ7ó뫉f¢Š‹ ŒnXUêt îò*Co¬Ï8ðšÃ!d4:Aê{—‹ã. #×`e’ó@ù´6ün—*{ú'H*Wºà ³.ÅrÄ‚ÝÀï[ã†ErœT-ŠE0ÃÐ÷S;ªy¬:™óx²„Îú$.(ËWÃ-ö®¤tL¾2f‘  aF�F¸ªì®!gEô-R.3”Áí1 ’¹óŸ›ÃÄòy\vQí21ŠêŽ¬SHß·õê0žö·j·¡ò¯C¥:ŽTT££Ds¼{cääúÔóäÌÚĘ×åP¡m鑲qÖÛIÓç\À°‚äAȶۛ‰ÓkÚyåÖ0ˆ‡ &›g…(à ®ªO–tKÄB…žÐ ŸãEâÔ™î ÓUYª£îé鲪9ÀñóÌ$>ìB Ù 9C=…–_‹µ¤ ñ' 6¾áh7ì¡NXH2×°SÏMfóòŒå³è»2Üuê�™î´Y=ëR6;HËI!¤<\½ƒ|-‡ˆÛÐ3‰¿·ÎH5Ø_F ê`²f¶íkò%•‡Z¬Á}Ì®YÎ^ÛÎæ[`¦_§/w›g%²çÉÒ¦I‚r´F„®ß~)bØ XH V"²`Q‡úÃvżàÀƒ$±‹kk%EÛÎ XC‚(ÇƯ<Å_¿5 [ÕTÖP Ýz|Ï1î3ÓØÓ¨$Ÿ [Á̸–°’ðQn‡ ÏÖö÷0Té¾ÑÚt*DËÍtÊš÷Ár!EÅ`s¢_W4'k›[¡N[Ú5¸h#·”g>ó´¦R5[²áJ²0–½Ð½ÕÓÄX³TÆå‡í±ˆL/æØ_hHgO¢LŒd­¸Îià鉽àZÓ ù÷ºåsprê:s²skœããPò¿2Çq×ñç–pôgÀùnˆ\W“gAõnÓƒŠéãA‘Š#Ô2.†Ðµøæ¡t¨“q( çNJ‡—ÃTf7u×ïîºÓ=J–ª…›­–õB§Yq•>þW¥1Hcæïkž”¸«%>!¿¡Ôm)DD'µ$èï«Ûîk§2ÌFí"P¥AŽfV¹è„¦ ÄîiNƒ¸µÜ•”wN½¬ý Ru‹°ŠŠ8ó0\9ºTä$£fB¬C‰ÎkÍ"j 7K)såW0^èv€¸Ìq‚å—ßyE‚ᢓŠI2Ѽv¹zå7žsdò…B5Êhþ…Çw÷n¦Å "lFºåØwâæNÏÛ2€¯€Ž"#¾”­Rií|ÊÃ[íô+¤ÜKSuKZmV*‚ ÷ÑêP6ËdÔ@··W‰áOSnë‹«4ædVÝÅO·t ¢Àå_p2£ÒùM¡¼ÉA®ª(S°2¶p‘Ýúùb‚ÇÞÍhÖÍõ·¹U¹gZá÷°˜[ñ©[8/b3+2Ëæ%·Êà°·b°¦ë£iK" ¡”“ªX×Bx©ë“XqË”—x*bñ¨Q~¦¨$a‚"Í?Z.&è?ÕµðéT)w«>h]6¶å€$ .‹F#mxÁVÙ«»9Nêèè ô„`3T\¬&–ãÅIQØêáæBÃc^CZyñQÖø4Ò ™ÿ¨mÈ´ÒVäìß:tù ñš£Éý›¹t¬Žœý¤æÁ:déV#Y*v‹;�¸¼ð¢ç¿ÑZwVâ™ÑÕ·.Ñœg/T0ÓÉ•í蜼8ú·Öe¸Ï>+ð¬MVÅ)¤$¥õ#fÆ}Í Õëî•ÈðCF9)Ã`‰Y+>´ æ‚’Â÷ÃÖö\~V±+¢pñª`1R×»ç´äYå-µ“Œÿ•Ÿtúd<À%¬úÑÂlJE<çûL}0ÏøÁðËͦ3Ãw:Opô=ªX�ªúÔ{³öU0¹†s1øÕðnܘ+«9"]à&†gŒÕ{fQ†o)|Âök@•9!8=Á3zâµÂ¢LÏ©‰êؾÞšºHžèÍ‘Ô@‹wÕów)îYæëãqUK¿0ú\¹§ÞkÔ5  óµ±_ù‰/˜íºÈ2kî`§j»°™A’Oµj .Ìs¸J=»G 5y;P ³VÛ HÜà˜£÷Ña¼&Lš³K¶„çI”† wÈ1aÐ?êP†ÍÆ£½¡‹ªeªœ5=x»=TfJªÐS€£ÄjÜSf¯…GAe ¨mQB ³¯Od‹mºUšÛÓP€-Ï:ÉËCŸWBG?UÚÝ‘Å,‹õ¥vs%¾FTPÙH!°Óäë0ÞhÑ‚|Ç 5k6Ó}KsÙ¾ÞâÀì U:\Àm]Ò i>Õß‚göpêÒ=C±ŸÏþŸÍS¢Ê-‹Î \‹Á Ð2–çÄ.œ?Ÿkq;4βwã<[y¥RÎz½ ~yWý3”ìànÆ÷€/O!0™·ZSÑb/ƒpÝš‡]zÏSd*`L»\OVú$RÑ�{Œ½*\HW¢öZ~‡Š€_ MXeoÓTùLgÍuU®ÓâÇMs·;*žçaZC9¶]íÐÅ7b„Ò8ìyÓ-¿{\ÃÆ¥óçVÑ ùÙl=h )Ø$Œ¶vÛ½ üG6΋ö<…SQ…·’Š8èØs+Æy‹V™!Ë7Áy7Žu¯/‹z6òŒÜÙ=ªi"14B È×öœ¦8ƒ9Á"]¿.çÝH|Ó¼v ¿·ŽŸÿî»Ö©üß»ÂÇvÒ“ÉØÚka­´U~pdcÚñœÞv»ÍÀàªq‡èÕ|w&ÅÙBÕ�òÒSA••í¦…K|¾!â ÕÓò1ÍÀk¥ÐÄiOä‰N‰¤›/g50ZéMìÃ&BÿîJ2GËúQxr•ùrE0W:$e´''¶$¢¯¦57¾¡�³ ºÁ?Ôõ*Í+¤_�q`w5Ÿ>ï£ZyXÊ!µ—3{¿Ìä,9`“ kg•ÐW¹cÈ“E˜gÔíËÎ8Τ-QWÙ=%•ÝÚËÿŽ®D£ÏL¡Eúþõá:y›a=§ïÓù ¢&q$Þu-»ej[±C{nº~z:†~¾BTDîì<”AÞYy\´û.Ý™»üÓGÇ·ߜ Æ]÷ébËZ!€PlQÐUA±U2wÔÙ9'º|V>  Z 6 2Ñ#m­ùqÁ4ËÚâÉáB<cè†öÑ÷K]E1ámÚO•ÕŠX) OÏvýv(>y=®NƒôwÍj¹r®Õ“ÊÄW¡Å³þ(‚üý'\!’y:“ýÓõæx~½JO¬YÅ“ˆª»o8÷9YîÕ–ÚÍuW·ºQ¼€R)‚=ìug¬Ã¢%©&ç/a(ÒÌÍ’pìR΋~ü¶ê;´sY¶²÷Õ¶9«•ÎfÊ€K¶iTŸk'¾`N!;M~|âåÉ•J‹í¬•ÇReã¶òLÍd ¯+îTž)K±6èÌ÷ŠÙ‰*åñæ¯ÇzC$ý€­MIæs6t=ýGK¹žŽHcaX™4j!‘¤¹z9Ð;¡3ÐÕÉð7ôØOÙ6¼¦âö8ùù(ȹ҄04d5t>þ¿ÿ3½õ—aX|cŽ�úƒn+Øó:–¡z ^Z9¶ºµÑH† ÑdŠ4ž˜ ó‰Ý‚=„ÕÈœ IPv­§»ä nü,x‚Xv•Pn’v<£¬3cè^¥œ\e t@íéçu£–†n€ xøAÅßûÝ•©î“¬‡Bl}GÛ¶]ûé5j3kÅ6›ž_!kMžFˆl6OÑûÅë:mÆUÀÎçé×–Oþ …'Vkà¥+®–HÖJ*þýé¬ÊíÁ΀òù“|«õÊ÷‡•ªÒÓ3qèXSfÉsÿÈn©yñXùªh=³&T_{pŽ-Õ\oh‘·Ç_h^ß É9˜:* \Su ™v}ØïtBÏfã57€¯+ämgÜ'½« $ÉJÍ{ oú‹ÉÉ f¦a’LÙÆ›£êý¦Ý§úòŒ–ÃÓ;ö\3(†hw! 5À\h9rh÷»A_$4Þ3Œ´žrF2,§ç[P¥£Ets€úèèùƒKoG~K=ëõ�eÁÜ\„$1çTžpošyP ^zÈ$×£÷LÏìL;æT7µc÷Í‘«W­™mÉ'>WEkO&HŽyhjaëú#|6ß“Ø }Ì0Ò—: Ò“Â'0caTŽ®Î• &+ÀuýjÌ’ü³oú�ÁýÓ£aÙ¢ÈI…¼šU±#^°ZØᛎ¸bT"nÊ Z(fXaä] ‡'óò“ÃA^y3´‡)æÓ#Œ·<®KÓuøDÿ¼i¿5†ú¼ª[^@ѲæÜsªVeË?i�²:o•Zf‚OÔVÀÈ‘ô•³€¿›øÎà¹AÌÔ=�ºP=3 Ó]êM:g»o|^ƒƒö]Ó_0P/;%Ö´t+×-ú£v^Âj5é×R*ZÐ×øWîè¬I×ñìüºfq T¥ŠyP56På¿JªwyÓxó Ï%–B¹zßzYþÜõ=p%¦ÆI’ y}šN37—dï—i†dÀð­Êõ¹¨Ÿs2%å(¥²tÐ&þî,ëuÙ`¸™K„î`‹ŽúmáQyg\žÀÈ€„±V¢üßPîô®Šl!Ñs¥?Û@~cóSa¼ö ¿“¤Š´'EFm–à$lÍbïõ·#ÑÔA–ý vÊ<Þ3KÔÃ^ šÎ¾ß´q‘rþì,qÞiŸfõ}ÁÞ°ÈÅ5œ”ªºÕ7ØÒÁm>¶»| …/ 2ÆšB¼%yÅL˜ª‘yñP÷?OûûL¢ÔsàÉôù‹ç¯ßžoän0|åö*4q¼¾¹ì§Ç¹/JO»¬½Dl"â·öÈñ=0ƒrõPö¢4óõA¶¥#ùü£šh¹ôf˜iáA”ƒ_ˤ£…ªŸ±¦é0¡k>­Üa÷v>xÀCiã4õ»~ÿŠH€7öf:DJƒÊÚ†€^ÕÖ瞊-ÅÁ—ë}Uö¢çÅÈå2Y€ωöràb~ø·„ö8wr}ÈeèP„ª¶8ý ÿÖÔäy&²"úÿü€²-ÿ’‘Çã¾[¤zqV¹‡ÍŽç/ Ûƒ/y»¢‡íq#~實žb • Æƒ„ó»GâUïrmùü\ãE^÷ñMãÄüiðDÕ)Ír€Z€)<|…º˜ŸŒÁ,p[Þ¢LGÏ{{Ñ è¥ ®o%ñ3£MÒwÚpË–T´‰š¾3]6íß·æËΚ¥®‡¦&ßçn5z€w'J3˜â²f~íIŠR„ 4ã‰è¿Ô‰Œ--ZLQÒ`û ÖõÖýù7ãíîx¤eu é5OÂRZASéwc»…Æœƒ1{þòœQàÈ/" l¢)o‡þŸë‰$ùEÁ‰Þ¹ò3œ2õ•â‚ú…ýIÍt‰§%LpœÌYNï ¼îçz‡GX+U¡ž,€» Ø“•µ7äÁû¼Á8­Bç¢`ô4ž*´ºòcP5‹gàñbï3ažv4œýÊ—6Õ“ù€ÓШ@ÃåwçËØ)J°%,9)<iPÖ¨·´VÊ6F8BÂéŠ` b&0ïéÐoàlÒ+qœ8LœÈAÈ”…¶¤CprŽ>LëÅ!¨ê‹'¿Ì‹/C_c„û<" gqD+Ó®ú9¥‰èÖ” 8ÁBxØzLl§e¢Ï\·¢¿ø£ë ¦c¡ÚIõŵw«=K瓱H�ãHsµ'&ðyæÀØ6hú@Ü–é†9˱Öå-P¼üeFC òûz"qäÝlv±úÊØ^>²* c}ÜÖg0i"´ôâ6è.ËÞÙR„cï(ŽkƒuÞí…ïÁ&úYž¤þ!"PG»³ûNƒ|ú¶´ÖHº9²rú¶Þ­é¼fÁe‘i…—Hµx±C*x#….›>¦QÇò%¼È¿ù9JðìY� ¡ÎÓ¸éèY•OÓa:ªFÃãdÒרb~êÅõÝ~â“%˜©Ø=Ìy4’µ$“nª€÷L¶Ý ’^ÿd Q¤ yô �Mèw^ #`8�®¶‡ƒmXêC³ïŽaùrÐ!Áœ© ÕnXð‘€­Ì)øcÌûòÈ?OæF‡úŸ·Ô`ºçÉêͺÞ~d&çÙâIÀåA=aǹ(¹\¨t_iɹ§_/Äìzd+¶ÎoËïU•Fûs ­,‚Šêu‘I0Ke‡‰SvŒ {㵶-:Ðëi¸NWe 8èn7ÿQHÃY*£zöF‹ó*—\I†˜/°ÖŠÊÍÙÎVènçÌ,T¿?x?ÐqéJŠf4'B³ƒvðùE;˜ª =þ=ÅÓé Ôû§ÁJqXm©š¸rGÉŽ{jÊ®“Š`BïÕéñ82µŒÿp:–P-Ã$Ât‚ju6«’°Äº¥Yèô¡wˆeLvèÖòt|b‰IÆmË^Ü7,­Qp×Ͷ`Ú—yã*opH#àCb¤¿&ؼW® HÃè?˜æUý‰•)cÖ±n+Ë÷ù*‹o(ãÚ¶~[]ÌŽj:îïüHŸµuæ!:ÕvU7Ø&æ×a5bæ–ÁìVÎCáñ"ó‹…n´1JF OYUƒ<Æ¡þPšÖs ªèe±Äl5Þ=$­ûî«î_÷Zmã652Ç}àxÖb�J;´'òh¦ò*I¡»0‚R2Õx×UDw@ì/]x»ùOÝ«ÕèrÀñã¸Ãße’’cÞQ•µëÂØàÒ¶WúÁCw68©nß_†›ïŽãEi»Ô"ûß_ÖbüK‚Üâ¥Ú¿¾ îLú±u:ìZ@K¿&ë4!N ˜ý¼$¥yµÎÍrÅÅjÿFYO—n”ÐÚGt§¥÷¶u6/˜kºä*Œf¯ÁQwüðø¿÷Øb?ù FIjE[ÑeM(If¤ÑSº§½cRØVèâZ8š>ÉßNã­”OÛÅqŸ4‚3ÚW½L ·f!jP _Q}q~Ä¥as ôë%Bj¨»µ'®c¤¦æÃyø ì×¥Ü廉`>Õ‚œg]oøÜš× °Spw7E¦S¹«Ì wO÷'l.G+ÁµŽ›ó‹)ñBê7ç­Ì–xÖK³3ø:ü²pÆZü’}¿æÑû:(¯HåDïÖ–¢d�é/–¤jŠL™ß÷QL[éÓÁ2yjÓ¾±sÐÃÉ°›[iÛÜÂCÃvâèµøEèŸp_#§åñÌe¸ýž!ŽŒ¨¼gZµÊ`ì:àц‹›F{ [Y.Pê^ÈÐÝÕæõHIL†#Gä(ñxGú:œðm8~°ä¨²E~ #ÌîFõÉÀ(z=]p˜í»óä~H™Ž±˜4ûÂœ-ÎK¿å—S¼W©¨ãáãЪ˜ Ä®ù9|R’ÌÇ8‚Æ8—Aqj¼ü„–ÆàÙQŸúãö– ì}æ7R‘_ÿ-ÞŒGœ ”" ‹Èp™T)êw*)VÑŸÇ_ÀÇõ¨egËtôå쀚knyðÀèg/Ø([5-†iÝeíiLFIØhJþ8¯K6GhT`ßæ'½˜GlÁeû£32O}•Tuðge”ù½é(X5¹çI%ÑU5ŒX+hãþ"Kñ' Ê9îJCëcΙ5¢¬(]¸ðÖ)ÅilvÐ6¯ÉþE–QëñC½Öj¹š±@ßžFCS¯NLJ B…ÓE”Jcûå¶3aÁ•‡”gÎø@ÿ¼Ñéu¢åø¶® ç†kˆò¢Bþs׌$ÏMƒ6ˆ×Rñ=úãGæ˜sP‡Ñÿ{.a[úý¹à Øi7[Í Q›¦4=ï¡s/¬"ù·b§›"êL9{;TAÜÏÞÜQ?&®›LM‰UÔöäá…_@gIºà/4LŠP¬–¯ãbº†æ´='q´¾¾Öµ}[Aû˜ÊíOEÿç·¾hŸÝà!½Q¢·vTððì‡ëò ½(~gÛ­g�C(M¡ÄÎ æÜÕ_ñŠ³Ð‡Ó¡®Íƒh[ûJnNäÎV\# nû×À°°£ó šÅš8ŠÄ]ô§"HΊ—£>)ˆ±¯Ü39ýùS3Kýêrî.ls®<t’ÜSæT:™r®ü!Íç5ØG´»ðÙW¿‘n©•Æ¡­¢SˆBY5]¼Å>ñ‰PÓ…˜·–²6ƺ6ÿzì†?5ĕ³`¥‹ö´Þ“öÛˬV”ï<Ž°ùÓo^)š%¬øU°ú‚cv¯„œ<4›“†Çñ´¡ŒY¾^Ë—¾þ0Ãq¬}ööï[.%0‹h7 BÅàœÎ€«)vÌf§‰j€á˜+Y ê# I�êðGºTêû_Ð"æ%Ù)#ć$õi¡ˆXëXa/pHÛLw.®ÔB­4œZXîñíVɪ{JðѪ~;vÃ,ÎhoÍ?oÑÒ"½ý_Zh¢i¡>m¥f.²‹I÷jK…§W¡ s®çw˜c^Dõ¬íÌÒ§øjæÞ¥¯AÆTS¥e í†R¾=P}i:…Üù0Ò Õš§ë!l¨áH_Š£­ÖBVìD˜Ù<ª{ø9?zõñ•õ¸iõhAC΄îœÆí¥§;24fäó-¾‰}‰O#4TtåW¬E·BT åÃÞ×”xBB‹3ßÁð4Àìà=al6–—c0>E<Ç“Ø“'Ꭰ9<ëѳ۟zg7Y¶43­‰Áž\ïB¹×Ú_0Å—é#e£Q™ó”Œ„Ùm,Èóv/ÿ°«“¨rBTÌÙŽË20°ñ#ÛuéLÚq¦BGT'À6sa ÐÝ–»”Š¢-&AÞ –U;*§ò^gtiGêþ˜Æe>7ô&§P¿Q¸PX¿…gEÇS ¸9>tÀo¯´o‹þŒ¹që;ÓÇ9Ö§ÞHXXÎÀCò€#ç‡@ØbˆÚÌá5 ×ðçÔgÛ±t«1xeñäÆkÒà_Cdc>GC¡#>v_5ë. á³íJá.£òSHZƒSqD‰Éo`@ä„gCç#öUT­yãšŸÜ ÅÝ(¸2‚ǛƜ–ƒf$”¡Aƒ D ã0Ní½alûFV1Ìß©fM»Ö»ûìÛ·éXåáKâó›‚'wc–,o,FÕºýűõ´jM¦#¡€U ˜zähÞÕ"wò’1 öSM_ÊwEÆõýeZ×í§`Ž˜Ç©Vz¡Ûm,‘�ïrŒP€Ì8zÌ0îy/ÝqÞÄÏõÕqJ-¤¨(“­!¥Þº¦» jSͦL{W¨{ÖqA�8_j*¤6‡ê°ï aøDõüyOwl@ö—¦ä®bcoðÄJPèT)‰_˜º]\oñc:4™PÌžï4t“([ž[MCyýxrbÙÓ‘jSAËža e…÷®ø±¼µ5~êÙØ„¢ë£\¦‡` ÑÜpWMÈLÁavµòÏ‹…è 3S"f¨ü&Œaë‹È¦Sè(-Å£dòzº�¯ü¾qJ6"L®Æ=c'ÇÊ™bñá|™ÌW'eKyãí Ú?^ɶXNµPþ› \è© e¢*Dç_W{µ¶qàÑΨ ³/Úþ…~£”vÓjÑQgGàÿµ›F½Â–» 5}æÍ:Qh [3"£ZÿBg/‹hVvPˆY‡Á ³‚FïH+4—øSCƒ•~ÛsÁöÌ—¸+°J ¯T}*Ê)gHÚ”èﯩ*9uÕà„©µ6j!ߟÖÂÿŸ090±¨&Áp¦im@Yd·TÂÇËtïzÄÈŽ*;x`AF膙,ÆãÁv=Pªlÿ,Î,cpžš¶¥ØÌÁ],º‹§…ÚfÅã.ãÔDÌW¢~*tà„)CC~k&zº›Þ”‹(DL=úø0:Æ6õ$b¼NPîEß'§°p[S·ýôZBæU/AÓ}ÓZ•CýöúžñŠ&ᱠ̨“Z²P9qÕ}ÕÊË4Yeð™žIVë´^͸¯ûÚggl;!CÆųé%ß1WL|l ŒLúÓúO甲¯¿ùCÒ £›BËa†×‹I3Ÿ‹)Å™7ÄJ§&ôóôÁ4F­Ò ŽÛa0c ü™ù|‚ 2ueÕWfr¯Ñ”ÝrRš2B¶¬mxû÷Í÷nø¸¤&ôûñä_EÈ*‘QdîéŸ'ÊójKöÅ—…Íf*í½ÉÉéiM5«U]½^ ié%36Ônô­Ê“ ,ßw"¨Šj,„h^6[o„î}"àÑ J´{:q³Ï‹›¬äS¼ƒ•õ1¥= ê+õûïÄ‹¢+Eôô·%Ç‹‡¦_ú¶¿ õjk¹(ÒÄvj‡Ã•@f\xéØvpð=\a ðÃ^­åë™ø*[Ðì/ õÄŸ`€>ÑeÙÎüš˜‘õ NŒ2ÁÔÑÉÚò Èu,(fÙ±:Ãò|yˆO-Àïtn0(„�ÝöÝ”ž¨›é¸íw®W÷1œfäÙ׫ÜŸ­«‘åÀª'Ajz 7 ¡À5`ÿFŒEüÈŽÆ€üÞÏntŒÓñíVðOû*ÈGµk® ݸ† Ê—ûR˜qjåë€ Ë oSÙf4Ÿ¼(Y£=¢ÚäÙÈ(Ò²æöɨ_LwI=ô †ø^Ð’XéÀ®& |2L¹¹·]~çñsŒC%_yn-Õ6§à³8“_tÕÒÜ¥YB:]}QŒË­h ¯àüØýH8K¦ï~ýº€õ™‰»lÂ7,ïT÷ûåŒÝ‡v¨9b¬m˜¾.Ó ïœbm�Jw­—à˜Gq8²k÷¿þí»Å ©Ùô„�3_êß$ùBô„ñ3TNŒŸ69Œo‡l ¨|£#¨ž(G¹Â˜?�(†Nj(W¨ƒaú£êo³‹Y”©ÔŽ­”º‹LL¶ò`;$ lÈgtz³ø%þ¾J“Ì©¦$FQÉÓáD» aåª?ýÁ$õ…=+M³®*pêê¶=À䎷!N¥7#ìïPÑ”°CmÙn« Z˜YÈ�6«d]jæ´«Õk$‰(K€œL¿ÛwôÈÌé 9êcX·â¡žœÆ÷¨ÀÿR9ôÅC;-}󥸢_àÄtô`5$u¬è&¸)²g—®#+ʬÅæ°IYFό†¬1HK*c~ê?ŒMLJàŽÊºÎÚû®¤ãM‰Yð•§Õ*“lã4¯•Šx!;•Ñ®§¤%ë'ï^lÐN{k§=ÕöJÆê¾~c±È'*:ø!²o7€¦QF¾„!œß×_dÎDišm”¦ ¥S4k?-ª1:àVoü¯ég2z¬§¡ ]à7UŬ*“(ÝëŒc³Tó÷Mo£ÅØŠþîn_(ÃUÝXît->!Vm³£CòºÆ}ºY–ã=În™|SYÀa©³QbãEöb’S%ôÿÌ)Wª­&=¡1ƒAäáÍVdRBäiõ¡Úwç¹±›çF¬ÇÖléЈ¬kb@µÛµÿÎp¬<!Ö QÒe­áÝúà|•î§(¶dz™WÕ”n´P¹–üÆGÆ<êüÅ.ˆX1$3/4¢ÙB‡¾´¡þìº×g™ó(Äá—ðyušRâcOcÜx•+¯GîÐ=;«­+ˆq+QT¢çõÇ~v DD§êÈÄ*ÇÈ É–¿Ubó|¶ÅKo8‚„]o=“Aq®‹0×Bu²kˆr†—ÓªîÆ#:+ÿÒ¯VE”›ÅCèÈë ÝYÕ¥—åO—Âìò…Ï ¶®å™ëÝz*5‘¨4ÅÀ]ÄAñ~ôãH{ ¾|t{ƒ&zˆ¼p·(2Äöˆ=feñ k3£œ„˜Fðï¿Ð?èð�`/Z ïûÂ`”u¬>L7R.¤ûŠOžfKÚ䪦¿¡hÇ©îúÝŸ!Ç)BíëñÂCÜ{ÊU¥;D¿·Z'´3Zë3 7§~¯KèB¥mýËWi6Q;'—Œd߯gOªs®w}sq¥]ÁBœÑîêžÆ‘¯òQñ!»æÁèß0�óÄñà|XŸÈœdÎ|Jxñç˜IHK³@z»FÐÈ4×/¬a¢4¿b¬NS¤ÁäQÛæ¦ü$Šú³hjYe $.hI9©COÌšì-¼ýÄöÍÒ³£TMkç<(ŽZ;BÁ÷x8öµõ„Øâމȭï·.÷ÂÀòVkZŽÕVS°Deíêì†K[c'¼íe¤½]ïú¾E‘­®fv£ç`-‘>†®`‰—WÀ<Eðܾ¦àš¸NŽN,•¯‚Ü]бÐ]©ÔGˆúÌs-/ùÁS{1ÌëìÍHÏø| ·Ü½ºY·ÃÂ&L*ß”AÆb©óP!ßx ¿^9´±&+ò“°}rMˆø˜)6[Ùå¨qO”w˜ÖzàTñw,Aé®ïz©¤žXf@ê€>ñûìÁåø7§]ϧ…m¹ÕÆÁLÕ·FÉK_¯xF™—§€P6D[Wo‘@7ÑlåNùz¤ˆùüò,QÖ'ȼLRù9[²Qhºäôk‹ tþš39¸ò‘nÆÓ÷‹«l1¢È‚ݱ G¡6{IŽr³\XU@2Τ&ª¾Ò ïÛø*,–Gªx¤´&Úí.èa³ÙÎÿ{“±º2P4í摶tÖ4žnlCÛš™M¶ªw¬×‚*„b¤ ‰.°G<iæ¾õ4jSuSK­lCÕnZO^+ cszþXh¢A÷Òt¶J|_/Ú"uO9ˬX`Ñ¥‘(zGÂò‚N_V-ÎLeÐòj½ù=‡†á¤ð§ödðÎtûŽ1X^wࢥá FÅ//¤œ; ªËÑÕ@¡Ï`H Ýg9Õí$Ï ¶ùO¼b™§ àb”ÇÁKë Êá„B—ñs7éÚºãáÄÍ 4G ÷1õXèå¨D¸@ÄͬÞÿ+ÊÿÖø\î½ÌCR™Ýix¤Ød²ª'¬Ñoäâzn ]ýªØKK74eùƒfb5ÄÙkP~ûÈN¡È –¯0ø/ 2•T ŸÕò²7ŽÂ&0›]ý;æÞ°™‘skuµ§|ë¢àÑ&�›~'#I"žßç®cˆs‘ÅFª röÜ?7m _slèóä]ý,¼—åWB›P°Šœ3O&ð0ËoúÙiË9Á¥¦Ñ!ÖN…�ÂÆ㻙ŸçW]£\çH‰‘9×Ul<Òìxà{ßšÙ$ÝÓi^\Þm?§¾7-wÔÆm,-aÛ@åƒrzƒ¸1eŠ'Uk~p�—¥ëeFbVJß6zAWÇBaÈ7ÅóHÙËöØãa?‚»¼IGQì7=BžçAÖ[þ„©éSh"}t£( Þ)èvƒp%"Ãê‹Ê°pTîZ‚N“;+Ôãr¬9 Ë ‡y4Ϧ?¹fø g�SÍúÅß> ¹¦T¯éV«šGœþ,Z/à}½u6÷C1‹ödýÂþ£Û¹lþ—b–K“šé~ÛÓ/xw²ÍÅGR4äjF_ïjGþ)cà :Eƒ¢mÑÄ>û®¹ýùÚ\Kíïs‹›—�p̪f““ý5¢Û‹çPƒ8ËiǹA^ ™§òBQÏÒÓÞy±ãåÃ2ñ& ÌE™ÀTzÅëAÜ…÷ÅNsÏA~0_áúŒ=U¥¿b"¨ü´$7>'Å™C™1…b Ò6Ø1 ì©Îo”øºÒèHÀ¿+í:/K9Ž»ÃhË`è€H›è¾6νQ‚âš ™Zí)ˆWŸï&¶æ9š,ÒŠ³Sà ƒ>jV¬1/z¢-,O*ŽÕëÌS¹L¡@T‹·º=kñp&¬e¥¯F'Sºé£’˜•õëÁ”–ŽÔ2ÖΩ¾Læ+"ïëD{ñæÐWè¹/(ÐÖtZ‰NÿáüÖ@.u¯ßÞ4ßî5ãª8‰©bͬo= o.·ÞT~œcyþfÑ[ÓcH‹-ѺäñeǃÈ×'`‡hüúj¶¢,PmK;¡üâ]É'IÞù òmãÓ3qƒ&ÕL^ Ì%³~Îgwó¯ÌŒYæ´OfÑs�QáB7å*c}%­r;!âY[�Šuzq ËÞ<WP?ºu—‘[fàê> ÒãäMè¥ßÖ›¡v°h¯^z\99âfb4…9çG(¤ñÊä¿oõHÿ7ÿ·X^fþ¯ƒììTÅqmÜëã¾|LWš-€Òl¦¤ðÝá‹N?Šè¢²µüŽQ-Ì’³a†B°2o4†x7ý•ñimœæYmq‡#U,%æŸ2À"ôP™pnß=MЃ¨g)2czpVzîìy¶ï ÖáL¼!zŲ4æ;—Çv.qú³ú°›‚vë‹BÊ`JJAN+kî¢Y“6Èw/­ÞÕÈ5*MuC6 ’O…2¯y±¨C"mµF_X§£¶”ÈSÏ4!cQêr,õàèû®—tÕŠ€¦ý Úk‹ë»r˹z“ñ ž„¥Ù‚ë鉞 |û&c(sÿŽžñrçb¡ž853d0šÔ%… §¿Žt©}"áÏò.y˜f”a«Œ kTaµÅöZ¥IÒòÜ<¯Ÿ‘¶]OÑtrÇ•)zsPVBG0ú‚8gл¡ÒŠùZÝÐlÈ jÊõ®nº¹L[•½ÇfÍ�€¢pßßzéX;¸XØ$U°=b¦uѱ÷îëBÿkÔh´`éF^ïŽ÷Ùù"u/Ùaèo^XòâPΚEB�Ê‚¾Q�½ÕÖÞ*Ûøƒ"†% [£ÖÍ d[HSi¾éF˜yLŸ'سŠì¤|»Ä*+:\p픫‘>÷¬æÚè¤L«úØýó¦u"fÀ°›´Ö Áɇ“jckËÐaÄLÿÛ ÂVÈóZÀý£° M»bÑ4sÆÂׯÚm¨|K¸Ç¾# ÊÀ#É»aÕ©¼(=ú2ulⱄ©X¿™J©ß $Xá@6gžÃ觕Œ’áàgfüÖ_ö‰ÑlYö˜'À˜3{èUS ‡EáÇ*ÖãÀ”›i>©œò›q¼12‹W@ˆ(öÚ%,uÜOyö~ä“L5g¯ôöãr›ƒ„õ––M>*£¼‚š¯§Ïˆv Nº4Í+õáÌ£ƒ€Àã÷Æëº\2‡ý†±¸J–‘ºÓ&JËš1ózÊNVÌA¥õ‰SíÞÕM]VdW ï Vem|3ÖX.1²þò»¶"‘–´²ØGàê;ÚI>í—Í~>f pamK×·¹*Uö"Éxî.&àÜ!.Dq±�‹EÁñó¸Øbf}­rµ;@°CôJî^ íufRV¦¤Ý“µ'+¼õöï[lJy4À(ÀŠ‚¢ È?Ðyò$IJÓÍ8µ¤,?½¨:§xˆïhÒ›\É«ïs5(C†”ûŠi«"ÉØ(yjݸSŽZÀ>ãÏIebr82“ì‡UÒjg Å5FS3ÒeðP¶¶jÿçø­ÅÓÛ&RWßEÿËÊ…NìŽyPÕÊÓ ‘±5ÀîÃzw媷KQº†4´×ëM}3nÞ‘ï@Ìgk½^)%Ü °Ô }È p8éјÞwÙ(€'Ž V')S7² ÐtXqóðõöwžØ!:r¡4ÑJÖÏx†ódŒ�ÿ¶žW¶³KÄ«oÕ«P»M!ˆ,EP:M‰<Pg£I©ãG_}ûðué–äs ËäGó3Ó5i~вçŠEeaÕña,Ízî´QBbÒèâEúp4X@÷)UZò– %¦c™›6øA/ü[ÝׯDwžòÓb{t°:ˆ%Î@/r>êš!©ë?Hùáÿq^~tȈ¬û‚wyÃÄ·B¹Aý4máù¥±¿Wv²r5o/ÃC½=ÃÔ¬'Z‡qÇPÝ»´ÎrSAoÆëáØyY«c [G1;øŽ{í}÷ïöpìî6Á<6ªÀs‹ÉøÐxŒV>;9îrú)à6îÛKo>Ó é S<¸¿úÜÙÐ3K£{ëò¨G£¥Ä›ƒéEÌ•/0e³ É“¥PóY&û*!–äÜqwõÀ´©Œ½„µ£Z̴ίVErF†!ã :LÀâ‘–Æ>°Y^z:ÊÀ+é¾ÝPs8ÑaC¿Èhq£/;³ ß+ŸY¸™V÷9î×ÂœÚ0F`x5/zH¯ˆ£Ìº‚Kw‚e¥ŠQ3†ç0.™çiè4yªR÷µ¥"˜,úhOˆ­dÇÎi4ÍTã®N&+ÿ¥ÜJšºžp ùÇÙÚ¯G,=Ö�g:ùl{1êUÎoJl(ÙZ¢ÞÍ3ÃRéŽ[QD‘?CL%~°–HµÙa´m)Œ YP­- ‹‚ }Ò¾<r¶mUZù|ȃðŠbèyMK|êííÈØÐxI—É!1]nÀËÏERfnýŽìC—1Sšhµ1 çIå;?qCEO<¼»!^ÓúÚ·#}jSg¥Žbª¬¶§z–ÈVÜáBcŹýªçy”…áb'Æ¥ 2ëÄm^Ž&‹;„ANë¢;8ÉW­JsņÖF!ÔC¹D±h(´†?¹ƒã·P‚°¶èÖ®¬í¢¼núzá¬qÿ§”8”>{‡¶ý ë­|lÝ°þcÇO` ý(Ë‹+Ä­Í/¾ÏúvÔ¼Ò ï‹ þ3_Y˜—°ùn/FRÈü®×4Ó"Ÿ3œðT5¯bkÀµ…‘ÁÔÁ,O„Þuß\¼¦ÿ½–C•…KrÞ<F¹5ͦNÉÊ+Ú(Ù”Ñ|‡$nDýõA«x‡†®§˜,³…HØë­G;’&m§ÜÅŸ5ê­­º�š˜,G±åsv*î|£[n:í÷»Ù¼µf^Ï™sEä¦J&]Rb”ÍŠ›2ŽÂíá/CÇY´TéošTÔ& € ”[ðw#§’#ó¨?®k¯ c¿ôG¾J�S�Wuâ›5 Lú(½{‹ï{¹{ö½cŸøÍygKmïYñaµêTâé®È#ä¯åFójž(³´*PÙyD6YõŒòãƒÃÝ©1úÌ ¿K/Ó#ÚÇÛÎŽFQ)½&—²ª·öàOŒÂÝ„RЊ4TS.ÃD8ztçFµæe“[>š£TpïbFüõZ¯õ#rQq>ŒÚîwÒÄÓ‹öì8[BŒY@‘•_A¸i:7í9ïpŸ:7²N+³}žüŒlììô·é/L±_Ey“ÂÇi‘fZßTÌÛÍà µšo�ÐÑÅ=<Î"Í7/ÝD>.«Â˜¨ïò"ȇÁë†í»^ &&즪Ç1‹®,ë¾[A6Û.¬ Çu»¡¸Àj­¦ÕY‹Æ¦$ãîÈ»‰BܷÑlyú¢'~¦7jÔÐRU»áJŸÄ=»ûøúG²ÄŠ1¥fœ6ƒê÷£uéF顦é- ‰ŒŽÇ®çv„×@\´~Ø#n^Ó‘õ®B„fr´’Å@(âÔnÌly Àì}~Øø#v’X­s¨&Í^+Ò3èzãmu/¿ÊH"Ïj34 ‡v›…eE³ÈáB¸øYyxíò-z&ÇY8tN$RiuNKeTf*£â.£žT¨Ã½1žŠâ¾°öÞ±£ø0Éüò;¯ë&æ÷lá<jG½IÎKH Ya/ô¦bÙµ‹ë–¢ÚxÚßA…‹a,LJ˜¢rŸ2˜žö%Þtï]B׬étã-£„†yUß@›ðh He`m )$÷K’è·ŽÁôô;œ’ž2ûb¨â붓‚Î=)#2?°¿Wº{Û¼r=ôÌí³ÐÝRŹWpYÃ0I5G¶ZCeÑèT|ÿ ™x]w+Óœ¡í™@ˆJº¼"Æ~­â®þåµýoÙß"l’2ôµó#"Éú“íÏÕzTV<榇5¿ÆZ=kEù¾©¶­ I*E÷À½Ý3ºf´kW‡ù—t«ËmÍ©™‹A¾…”+r~îËQ_]ºŒ8u1sðë|¶*$!Ÿy´NLSÿ{ÊZóýÆ–<Yô§*rU†¾Ónœc<d[…ÒÛ9?ª ØS™ìèÔ =tÚšïfotÓr’„þÉG÷À°¸±D¶Â€… ǤÝ?¬QBi䧜{ëÊÂìôќ۪³À÷µ¬oÔ}_44ŠŠþ•ŽV‘g/_]@ô•së<¥›m&ý)†Ë«mšåûäzmœóòüÊì_T]5¬¢ÝÅ=)Ûä,LÉ1–^m6žñ/o¿ÚZŠ®>äÐÔ 0FlA–Uæ(Æ ”… Kíˆp/B2ئ/¸hßk¤ò<ÒbHT›k¬šz["˜Iç™þìñîkq–„K¾;7òD¶ç’+kaÉ Á¢²43«ÞJ;¢bnû©¹¼ÌJâÐc^`4×ÁØ|kÛP¡8YRÄ,"CéÜŠXñ½ïþqeî+çˆ:2åƒëu«¥ƒ|Ú;êt”Hù’;—Îyå�¢h1RxÛ /âgèzîõüó…Æ-ჶV<Îaü<9Qg§íœT~íÉ|uÀn¶×Z¸ÊÃh›Å7 8^N2¦ ÿòcÎÎtN´Þ¶Õ{£àg/ø€è ãxóÞ:ˆD“ÊKôØÓA!I*€-'ôqŒBŽ¹‰Y×J/òê`^f0§¬!7g³M¸•úþb1yƒð;ù8!¯ùÉš³´à{2GƧððãGs5üh³Yÿ¯Æ¹4w#÷¾¯ŽÈJ›Ç™AÖtßtBnj“œAͧn÷;¼¹w|ßqØW†*rI‚Ê)$µâ팥ívìÎƤÝ^ò6S×Ü®ˆ,“L‡«mŽ¿ºñÜUûšJ†ª›X$›ß ã Æ$¬y|õ-ÿÞA¸}þ¤Ä· a[ä­q§-MhLŒ"®ÃI¥9Æ:¬F)xQ4ÿ&}-\¢lTQ”ß6»cT!7y¦IELîà £ÄSñ>fú’½^#€Ê§É³™k³ÞŸ£8]HP…,\l}0Öî0]Y]›¯°M“«‰º�%kì&§ÁúÝÎwX=óÉ]^òxyéRͬà¤èÑøY¦A!¿”ª§Ë°bS­YÍöêL×añTäû¨˜xOД?yÍx6î!wò¥§@€™·?Œ+ẫ—ÅYÐ4”Å=õ 3¢Öèf”²ŸÊh?×άOãbŠÒßyu�º<ÕÑõÕŒ2ÀdÀ%Óèæ§ì”wBó7G"Þ”“™€Z“$Ž¼ÁŸŠíæ•ßÔ¦Å:l@]lÿxf«ÃáÓm6ý¡Œ^›Ww~¶¬Øõ’Nžy`ªÖ`ïV>?3¬àãÒ E3ª•Ñ(TªPöIÉþô¼vȳ¨*LéÀÖ>gʹ{eÿ×}³;ˆîu²5?»KK~I-$NÜèU#Æâ ƒnŒ¹:Zß#Ì·œ.ÜZM ŸŽÂ#9ºõ½Sä6Çø\³>/®°ŽÈÇÙAÔýŸ¢I²sZöòÆžÕ‡LÂú†ï¼@ Ys”èíð/ñ–nïûQ ò}7RaÿÓ[¦Í§ÅdÓ9CúÊþ «ÃÆ£dYBá–˜[ø o¨#“§šÖþ°>€�g+ ýëÛæfé™RÇFæ!¤`Åß+1O÷¬ÎŸÇ¯ÔÚ\ Ù ˜a0›£Y=ìÕÇBÆ>˜ –é†é@ݪEŽf­„(½¡üæ¢4:^àv¿Á\"ð~À:Œínb“ £,Á©±„0Í¢<vx6Öïf<[Ö*^d覫W\ŲºƒwRÑŸc,Ε–ø3¦Í ë8´Ù‚<Ðéø„>ç¾s ɘrðo5“kAœº¨îꪥC§GL^×ÚôÆY&o¬÷½Øß‘xýª¯6±ÌÍ éiþÞzbbәݥ¼Žö2G½JU•”#Jëh¡¥i·ko²Oy2Z™Š$ï'¤K(©ýé²’§¾…28€< *èt¤ÞOÍŽ6‚=äñˆ(…½+…vé5Š5¤¾¢áù¥ŒÐ¨èë“ _‰ÿ¹}ÈFgXR^ÃÿUá‚bZÊOß{>@ t° Žáó ×ÇœärñÑÀÙ‰¡*Çøè88{Ó[òŸò“4ô-iÁã<³¡Ì虹ÒÂãb, ¯[iÒ(-|ïxuHǶû1L@õh˜ú?7qò2ô'è`í©TÿÔ¸´åA+j] Kî{Gêâ%³c"ždˆI¯ìe"Èý‡òZØH¥š.©DjeˆõË>R¥CðËüvŸætWÇýDÓèȘóBE¸éÿ¡û°�§`X™pØ ª°P;ú¯fG@þŒG`$­è©üXÿÙÒ´5ÉüF~âfF,àr€Dv2¢  ƒ´vcïu… Ø„ßc^îþ)e¼Èá>N+ò<˜·­ÌøIží|¡´˜ýž^»Oq´]Š¸=ƒïÖ÷óêk­ŽØ{ÙÊؾ֚‰²ÒŠŸÈi³¾d”SØ8\XY½»Àšÿ•y?æçËm"nçÿ€Ä±°~pÄ:u÷Ý¢ïó!ìaŽŒX¬ô÷¬gÕ„óPëQ^,8+P°c Ìá³Øáá'*×"yÏD.“4õ%~Ó&Š]Rd¼MÇ ážûÑðPõ™y_Ïìïÿ}õØ7h†3ùíØíìÑT·(Ð(è´Â|�|ù §|æ.›->ÎJ'Zö±å½‰¡´™àÛõ,_ò"£ ý./ßpi)ÛµÚ·¡Ç1v_\Ú(#â?ÚA9åx1ìœsEkçÍ°“¤ü’ž‘·X»œÂ߆ÞåMüðªÏxì|Ÿ¼nÅ<žÆƒ6Âæ·úDÿ±oAç[rÇ~<Ša¿FÕZbý³ V¿YÄÔŠ’j!£\ñLÂ~6œÚ“ZŒR½Ç]«e,í“à!Á: ”ºîM~7Î[–Á¡kK*wi9Úq¶ÅÆè¸b‹LgIý®Þ;¼•¶W_hºFV†1ŽÍñÓn©š²Ü&„=Æ Ùé®dÛýi/ª¹†Dà´ãž—¡q¬÷IÀ?«z¤ïžìö†Ýåƒ<XUýUkô"=§=úðìßeÉ Ã}vVÆŠ‘DÿÉÅ+ñ°QèBÂGÓ§'d |E¹Yî`˜Tæ/È´ãP]èWÛ´ üôÛœp@0q·ÇÊÜü¬#/YG˜>�pX:tÃBÂf†:è~H Ír§ÎÏN]Ó”yÓxù³‘h6O·Èô©¶ÑÊq!àUz⨅ù‘Å'+«ÁCH¼«VÁÿéi±é‚3H/ÀÚ¢Ï`9º`³ÿrFbØbûÃ15:.ß­i0χ³u"á3^LBþê<Ka—@ϤşOµiEiph'£d¿‚¶\W¯ qN· †<ñÇçï霉Øß*Ñœë‹--S à.7¯Ü•®½š#¬$•/‚qçt<ÿ¼éæi‘üâYÕ8EkŒÖZ© ù«ÙHo%Ó]8M®všYpóDÌTx^Å)ßø¤uo“žñ£h!ˆóý#cý"Ï}ôäÊÈßÛïæË6WqPÎÉ!®Aþ¿øÞK?RNìÓHÕ¡Åm–’­Ý†Þ¸óðþÃnÓõoûî<ÁNphcgDTïb'«Ì·ª´ø×­“™ópƪïg5dbZ*Î7¬ôèT<9m†˜²­ƒOË¢øp¾Œ":ÊäIãl3p+bp×?ñqþ™vž®n·Ä`5Ö†¬a’›¥—ý=Oû(ÉÓ4³ª½Ì]£Õ^6j¢ŒÖ ËŠ°ò[Àbzä|4‰…®&Eà(º:š1²ÖØæÀï+M2¹¦:°nN¤&Õ‹E7/ “W¦:‰,1ÙøÓw+%ôÇÜÀ✛éÕýÙëË>óÔ^Ør má§hˆ,¶ô§˜Lí—í)«­*3.BoÝwq¯¿M[6]ûÓä"¡ã¦?°¿ø: òÎ!ѳw{žàBë@±_"ý$Iá+,ù1SÁÙf‡ ujé|óéÛ§ÃÞÿÊK¾ã¶›:¦^ƒ ”¡CɦÇrÃ]Û‚"®-P€½ €/\F(NÍï?Þ=¨L÷±í€P;+µ ÝÏî4vµÈŽØ;¦d˭̹ûI« ô0‹¢_Šü¨#ý}}ìYyÕÓÝPiÇ¥ŸÒp­E*)a`HÒ(Ò…åÔyn33râw32p9$Â×°X®Ë9:È{Þ7xÉóÔù´ òª)ƒr­ �7.@BÜ –ÙWÿaÿ‘¡; Ù7j• ½Zþ' /4šk‘ˆô -b#ÃÐèQPõt-ñD©'Š=¿€Äù(§ø¶šæ”HÁ­BZSê;j z¦i%Ü€cÍzof‘l½ô5®¼Ï<’?KL5ý=Ñ°vçÈ ˜ žý¯?Ú?[KaáП3M)­M<R{ìób‡F6%¾É£8ZL‰’ IabÝÿ æ;Žƒ'‘ô Àj†jº[$Aö©üUЩ®¤Úñ(õ¦Ó=mMÿþñû;ÔheŒæh«YKø*¶½.@ ”OW”}Õ^\múœ°k¾AVx°Ô˜•'@!nÁ—ª€ ÜîZ½ÿEK_ ˆ$—dyÙ¸Mg ­üþh&‹‘ýc'}ËÊpZù3ˆ!2™# Ì'º­¦º¾|˜iS;w‹ëkò³sÐbóN Z«3}àYá s¦Ô x3kæc²&úµç(ñôñÙ ‚‚"åeíÅcˆc÷úª(\“}ÐýàCH4xÞê›g¦_®ìE;,2ÿp‚M&‚ÉQÅyuêÀ®:X2†Ýé@Xƒ¿Ì ‚Ú> òOÏh¾^Õ«]íA=¢ÿã%ß™+óéLÉ@5X!Xl/àçfµŒ™÷'(#Ÿ!¶ð®iÙ;·áÜ©zÕ^³wC'F z!YÞWäØ :EŠÌwtKØ,<™7Þ[Ã;УÛý`åÎ¥JŽ¥=9ë`Ä’¨½äÜoþÔ)tBBÚQ6U56[Œ¹š7¤Ëíè¦+WhÈ"JÜÅžhk/3H�²²Óà÷öDÅ­z‡¿ž.–^æÅBl ¼úZ ò"þ8Ž¬ùZp·9è¾oÛ"H­voʾìܸ“¡Ò†r:T^6!†‡i¡³¿gßgIPôÊg:ÂVþ| Š‡ãzÀØåxîûm×ï‚ ý %•öÕŒ"ë å GEH Î_œ™ ÔqÏó ˜Ü‰þƒ¾½¶’ó:KyiZzëä´ñZ1,õñ& ÁŽ ¹€wàô±;J8į½“ÛæÑ‘hw÷íq¥»o`I“4d9qþx·ºÊX(žž°Ð/€4¥U¾¯½úz÷uYˆéaq;Ìi™ylÌïŽÑO§Ýí÷Šìx£´°…'w’?p\³«â-¥ÓÌê•s”=j›rÀ»éì¬ÝßÀìcŸ¢Éìy©{[IŽæßEZnr_4õ‰LiÅ£¢Ð›°y™[IëÓÈ– †‰?¢ß8×ÜÌÖW*_8yua7[Ì €HH£ °N¹ìîÀ‹ÏLdÿB¢Ë¡wÄ 2 º! ÒwßÍ–MýìPa‹ë×Ûc4W'–ÊŒ'¦s”GÍÁxât á¿­• hS ù£€¾ ‚K•QªQÑ6Ód2g»Ù#SK¤‰lߌ¸`^î¬üØõ6#`Œ-<,eÇÉGö ÒºE*ÞùÑ3£'ZŒxT穤¿BÙç0áñÕ¦èîFuühÔ©“!ùæ &AlYÕ^¡˜#¢: A_odR–ŸT†òÂC1v|w¤‡�¡ºÈN‰LU-LSPÛl•ù%¥7WNè±ð§8íOÛ¢­{øÒH“6Ð^~à–H¿óS™ë¢*RGè�ÏŒ’šŠw¦‰¯âhG×/È\Dr¸X<d°Bs£|´©jáˆjèÇÐœÄ�“ß} _ÔdÑðŒrªp¶¤¶pÚ9†Ï_¤‚¹!±äò©µB@F d UÜ­­N‹ËÞLåÀ‚­4)q=|£ÕLž¸9Ðñ«‚Oûƒ¥x0Q¡ËÖ2.ùç îrrÞÓ.‡‡¦‰N|ô{Á)©dN‡ŸƒXðW)©§®+´O¶\LÕƒŸ;̧ía<8áß8.fÖò»4ö»Ó²Æp£ÎLç±?+lQ¥ià‰BgÝ£‘¶#–&FñàÌBÆK:泩AÉ¥=÷º‡�OèѬKÄXè«š‡Gú’o¿©Õ~¨é¾lúCÐ5ÍÙu>s´H5G°xQkh‘I¤‡êô‚îZ  Î¼ÏÂJ3áÓ§–ÎÖhòÀÁŒr CNý-q:ÛD—Í»ºÅz$ÙBOñ± 2«€‹ÊL0hºšÌ5� vN#7j*dDL™H6Ö¯BØüÜf²=‰f<É_òIí«±2koºPâ7j-Œ.„ôM¡g¤æÄ&EÕ,�6eâ̶Øt{¢øÛ* 'ÊCnÉR‰±‰ùoÃc;•R@@¸òΣ{}#ñŽœO²ÑÍ•ŠYÝüÀÓõŒ23Œ/ëµ;Í9l™Q°ºTZ }Õ…_µ$æÏÄ3gÊ ±[Ù[Põ±¦Žxk/®[ØEáSŠÁNñœŽ ãiš(åÉÓ°›ß 4BàŸT[ ôà ØD‰ÓO‹Xnt 7[Äâ„=}tVäꥡì©Í™Á)æõŠ PªrFÈðâäó4È>goÄ´0Úà7—ìÃ]© V%QlANîè0Þ¶v’ ßÓAŽ™Þâ•ö«öô¼V«ƒž?Û¯¦l€xuäNPœåMß5Vµˆ–$v!*›Ø«W¯Èî{ž(5´ ²ÆJë22Ã3ÄÞSrŽÖ¿z$XáñY/$º¿›>ƒˆ„ƒfÞ�< ]s·ïl…ÓÏ"gÿò¢/]ºO•˜:Çô@'/“gÜŒY+´5äáÒA<Ö+ÔWqÍvohåÓú>®mO<ñ걆£èŽÿ‡u/-&sqßy#,}a<:5¶ßIPÙ…p’ëDÖÀ (-¨{`wkÚ´ÏH_UäX¤9»zטê[•^L <I1„åŸjÔ$ñhÄ.Wkz Õ¶ñðøŒ¾Sþ=cZŒÿC æ8 5Õ³F% b¶»F%{š ¦wEùž+D”t±Øæ#Ç=•×LXp†wç§óhëÕCØ‘£>ÒÌ=½&q$‘Cr69•ô¸¾µˆÝ·’¦šhá€T3Ž@­Óôõù^IX9sÂX鞶:ßù¸`øÉåÏd5DU÷/õèúKÆÝ°¼¤c²SKÊØNa¸’¡Eæ+>BeäND†f°êCÖýñ´y‘ôàXMí!œÏ1kZSrHïô~ñ [è'Ö1Ž|ç;QCøìÈ£PÛ„ÒW¢ÔsQÆ^¦ô9²ÕÖÂh{…°66üЯ]Ó ¯o¦Æ¿q&ô=ïrãOGÙqýion"NǼ;^ðð»å<zZ­aúd¡ÜXÃàЯœ0ÒßË‘=Ý^­J’ȃri?eI¶óŽ9N´¬f‚•­|–l ÝŒüX÷‘¥bV3èù´ŸñÉ=ÀÂ|‚¨ds˜¬×½i‹õw5 öGò,êÛô¨é'-xJ† ËHTᣚùXTǼܟU„ÎE�™Btß”vtðÇe¿©Æ̽¹Ï¿²pÃÏÉŒƒÂöìh#b¡, Ì«Þ QåJ§ˆ%`{Ú0E×^Û‚qgLY"ȲÙäýú2XÑ×–éC_%œÞx nø·¢ã‰{MVï¹éøÉ·*&ð\— ¬öíÃœ[IÚùU¡tµèýÝ08ŽÊ›: æ ó„ãÙ!p蓶kQæ{³³F>¡_ˆ¶+7?`ã‘ÌW ¡ª›ª½ÂŠ4¤ƒò¶8G¸Ûæñ°›ù麫ó…wE®ãJ¶ôíÎ8Aˆ¨:Melž±U z1QÈck„ˆ:’žê˜ùF�34É'éQC”Í¥ÍÆÿÙ: ½¡V–Ûþ2ªuㆌ„ÁF#ìþJ:"*UÇ#7øŃlÓ˜?þ¯Ý¸Ù Tĸ:XÜfè¦Úõ*͆÷H…*„¸ãÒV@#ÁöÚ ÎÀkÙ%¬¦§¤8uûýXW_´R‘¬Øè�WÇ]m îgºáÕ•( -ú,Hº£Ç@ ÏãÝxöEë;Öθék°i7põE+|ÐÄGìÃi™P˜iBߊ.w7ðÄ+#› ´gJ›þ&®Î=œiM¨äºžev,$ª÷OˆÈ«Á䙡t¬NG="XP‰j¦Á°�ý±þÌœÀ-h¾ó%·Q2h¨” G[€8?ï¾±üÍ0¸r@b„t8XÑ™ÙZMiD-®M•'†[9±üFîÉ‹°câ:kkwq¤Û ùU &Ò*z.àVånGfX~—CJ÷ù4(¼½àÛDgÄÁkMÑã3 cÆÉÉaÈÎëh︬èá?x `˜ÀCêè‘dÇÙ´¬¹[|B$>œyt£~®ý':zä¸i2±¦ø3mè÷5½³Xñ&:^Ö0$9\&gcµT¥¼Õ¨,̽LÛ”SÙÉVò¬ÐšJ÷Šç6Æ„¶ (v³øß0³ò1­ti‰9z¸kdïµWÕ5´ Qwa¢üc+È«’˜ †’vw„óªçµ¦ÿ店ÑÖ ¶ë¥Çàläð 9‘ã7î0p*!èQÕíÈ@%l¨iÙÈy°¾P<Ÿƒ-.ðÂ-sÕ®…¦€øüj‰ƒ’–ùÚètò$«ÓÎIC½„ˆ´=~1‘Fovy}ô´Œ¦nœgiEÜ1øzeù•×MÍÕR ³jÏ—l¼RŸ>©Kß3|QT¸Ò“…/Á¸p}}40‚×øÅß�}û߈UÚ)‚dà·7¾ b±V:¾jgùÑ÷¾Lpf ÉÏü+ºµ3s£¤9Åìü´è¡®ÌÌÙ]ݨ‘f \”’eÈzàhYõ^Ÿü…bÒõ.b5þ)Š =öîÃQs¸¸!:FrÏõ^ð#öâ†v¤aP%þ÷T™f6åÈS6µÙˆŽˆíѾ<¢Kòk9æÕ6§ˆÞž|Uã7qj×óêÇ.^‚ÏsèTãýzÓ Ï†VÃéÀ=55÷²œJ_,ÁÓ%‘éxÓ½=ºæ÷ñ2Önluùè^1SJ—’Ë%ùù§£‰Q”¤}1œë°ŒÒ²CÓX\åºëwß §õ/ŸXžEN‹ûœÅ¤7˜ŽÑÞ³¥î+ÝM?K2"côÐFM)xÝbË~‘}—®úJä¶Ó›o[o¾3wÃ+LÚ!ÏËVVq™Ó ï«x|ÀÂ2´“É"X�yLÜê&¶Õ–¯·ö„¹>©¶Ût¦·N.£y¨”z­ºÿïÿL¾Rz±d g+ç«Dõi¿ÈƘ‘ —'«ù™r„¿€G¬šTòÝ—eT4ê»onú¼‘Ìq¡R$îtÔ}Xà éÕr[Ä6GçÎ$.ASGg|2).©î™®€ÿ”E‹|€Rdþµ¾¯ãõd>c9¢§K‡ÛžÎ„І-|RZ{Ñâ@ÐïÛS¥æñÔ^%šKdö§ >±¶¹&€J /ï†V=Úû½ï2˜‹â#¤°bËNõR7X4é$[ìêua•ø</Ìè'€3¶'_Z†ØvýÜ@y¥Å’§™×²¦TŠÝÖm⤬æ¢ê_»ªÛJÈ*+6ÄgÏmÁUõ÷‚ÿmZº]^¢}ØwY6ÊÖÌ@”5°‹ß"‘+tÇ}Õi“Qûmãt±œ,‹ãƒùÞË<úñK¥‰5NOÍçá›b×»š•¹Ùƒµ’;0$ý^¾8†dê 9º¹Û6 ²¡sÖ§ûšÉ-ÐçqÐUî˜ë ûà‹ giÓnb‰ä¢€èi‹ÂÈFTj EúïLc{„GŠÂBcnN»?JkÙv{Z±ôUdÑÚT±O'bË,HZß—°©QŠ{Ûv:‰ç3ƒÊ‚zµME½½ -C˜—¬n_¤‘û3N4êÆú ñ® OŠ9gaþ{7sß’AÞCB‘¾qVh3ÝÛ)µiÕ°Ý|‡b‘ûTcºALƒ°`¸8�‰Î�ʇ¥Iœûø#ZMSßy3±–vù\[ÚS@Ç¥¥½‡ã÷Ñï°ú#!k¯F*zzµf˜¶õY ÂéN€õA‡±†²Yêw{A ½Î%œ9b=¤R`‚òÞ_µÒ#G£6)–‡1|tí0ñ­k-ôøOmve‰¼ì<ÃètìÆ÷õxï'f ¨7êê[p$CïCG˜¤½[½”ÐËo¦¶ìî_¦ºþh­àe4q´=´ÊA;7_–L÷*vØÑé˜.*h˜ŠÎýµÑ£½*i)ÿ?oqÂ<Z R¹Yù:UB×k3îŒ1j Y‚eÒÒ'8„ÂâËZ]Ê\ïvvlãéè×ø´=ù^¸ ;FVݱÊ"@¬•lBᩪ¦3ÝÕ >¯ôL=°®8‰¡Aƒ#õÐ29P@ã">ÅEìû4À‡­2>µì+Õ1§mYã·N‹¦v»ó+ ª³ €˜€PH›éïîûƒÁaÿØÓ®@À¡°*z¯‹7.ém-,Zõž.Üœ4Ûû\ì•Ûo¨ÎåW]—áQ^ºhXH­Uy­yAVZEQ¥…d&IíÞ~÷SÑåÌT+È'cg"žk+A”Y„añK›âÜ9D±íV >$bö–á÷¥Ï ó2EÿܬH 7Ç‘šzÜ�—¥Cio¤ïk6ÿ :<ÔTiÀëWzê•ov�|<ì?òyíA7Œd¿G˜) /(¨Ã" çÁ£@àr¿³³8÷À7‹ÇÍ4ëÞx+õa£ Ë²TÂè³££mø&Ó«GZo0`ÇÜÛ‹ö5T7H´4 ¿o¯ÂÀ}²e.Š§X­fÑte/º‡Ÿžnㄹ’ìòß!¨¶¶ü–ÁÐVc7<«µ÷õXû˜[.ÙŸ]ʲRg*_:Íô·ä½œY`lKõ1{6‰ÕªÇTž•= ÔûæÂ…u#P`•+Z(BÇ÷ï<`†rÝë]cÖ2]@¼£àÔPŠÕ(ìrŒ|ÞÝZX›«®îïÊ­f¹• N~ÝgTiD«ðý°&kßd Ì‹-ó–°õ DÅšÿ79y¼„Ë° ³…mß •–~¾¯w}Ê€Ø@>ä>aõÄIêç,ÀPo(û¶BÝ ýN5@ìZ`çØ÷Ì»ÏÙxÊC‡é@øÛΡK×µ.°JýõŸÎ/›8ŒZȵ—<»ÑÐ3'ç†ç:d tŒò>o÷fåQ™.4ø*t‹Áv={LfH¥v{ž4‹ó*Îú*¸ôÈóOËš¯IãukïkÞlª¢è}ãÙlñBáÙ/ÅV½4Æpo=îö¶xvªK?é/EVT-<PÁö%Ÿ'U‚±„´ Í-¸ x¯E>§l)È…”ÖxR²˜žl=˜¨ å÷y‰ÎRã© ȤhM²í5çlˆ]WßÁ¶%\C–Áù‹~קJãžq#ííÐdûC=Ëj2Žñ­ò€ò-ŽÛ“it-È¿ééH,¹S5Xtß{ 4Ù⋘è¸ðða³F6lÍè:JҥΉ8Ì ç»²Yhð:Ø…×v7ýð|>•=¶ÄãØT²ÇžÎ„æäÙ3„ÚƺþbŽa½ÐÚãX»+ ÁÂ^T0zl,Û–´[îñ´ ›âj'AùYe¼Ï«‡`‡'5Ìÿrìê\]1 Œq—¡áo}vëÙ@ ¥•’ˆ„‚¤ÝYÔ¤Ø}±ÓP|õ­$ÂfÁlàÕ:Í‚tì<ßPØÓz0C<ÅÇ®—¡Q™[³,¸‹Ó¯ÉÖk]ê+Z‹§aÅaÖã¥;|í, ùŽdE¬6qdZ­Ç•ÄíÆuÉ pÜA:XÛ?Ûú NöÅ“j ½ý‚.¸üYP~wNH»Žô·IWáÍkbæ¿U csÒ;è ÙHݵ¨Ýâ!;Ã+¶ýêñ»’|·öÆ<Ø Sµ¯›$sæ÷ÕcÔ¦ò´ÍHÏëÁñ–®,p36±Q=k>ž^©Hë÷b£øè/ö~…°€@¯I[ lBÇñG8ì¦Iw¤=ÂÉÂe­]H.¾ë‘À&V)“^I)ö]û\ÒáY9f'J{*²ËzÔ¦ìÎiû€úÍçëµbûýÙXz*Þ¢ãÕ€òíAW™V`Ý™¤�ø"¾^|² áZ7àÓd0¨ðé}÷SÛ;@«™áVÉ`×Èžå= %îVx Ê|ú(‹ôîñhÙ :]ÚÁŽ ~êûú”;V ÷ôãÖÚæEäÞ=ËEà:7h’mÇnDuR¡ÆBJíé0jJ#Ðç€ X´Ç]Ýêd‹ó¢Âz­‚°Ÿ½Û¼ëáCm‘~e¸˜g™=+˜ÚPaUôŽÜQ¾£h²Ý8´?´jOC‡ððN?$´:œ!¶¨ÓwµE„›qÓS¤fš-ô8Î¥Gu�Z‡Jè ¢{Kð±…f.·óI¼¶sêQv¾jt(?hwœùmNý•T þ¡øÖÝÕ)¢Òù“0‘!h믵P¹áÇÓ(,3{A‘e„·’»p§M¤™ÊúR°DQÐJŒ;­Ù(üFlìpk5çUgVßîþŒg˺…&êŠrù*§Š<m_³Ñ@l‘"ˆ­O36µAŒ.öö3ØB”{Ö/¬Ù^(&UÌ”G BGÆt°}t´Ÿi)Œä™~ŽPæâLßÁýÑõ˜¼#½SheŸ#:4kmg¡/¨â¯i žJ.ö#r}t£îÔAÀ…² ¡oÓZ‘Gü'4‡ïà°^ïVÝ[¡CuwÜ ç„ÍÕ‘!ì'â{—W\äýq‰ {zRé§Æ4NÄù˜ý¢ 5ÝÜyïÄü~±Éˆ£ö•{*ük}Äskd¢°ü¶»ÐR]/ØŠhukœøŠ G�­ˆ]2þöâî—ȸ²^›â11Ó ´8¢€°“èÕH¹Œ€ÑAˆ×È@àçø®»Á¾r"z‚Yµz¢ùÛÓXÓ#Ç ížÚ¶¹7„’μâ-ÛÞ å¦tÌB¨ÉØ´Ýá4HÖ &âççùŒj§Çì=eJû¼ÿ•<»IáØfíºÜÔšÂV=¨ m Þ­¡•Õ ‡Hú+-k7¯p÷ôõÐA–gžf˜‹æs8í¼š7K§B?(=Ç>.'f¬xP?=šë·‰Ž€U§‡½ï µüƳ?þÐ`S-݃RȆ‡ƒýÖ Î+zÔ eÑÁ8Nÿ¼aùõ<-4Ó[ŠhoÐAÏ.Ï+תø‰‹=HÐ7aòlI7°á2&_g–uÚ­—vM7¾MY´àþ†l<^­'žO¤uß¾NÝSò(‰¯”ðß´9bKS:.&î¤ Û1Æ—Ò·i|L™?Û»žó• ÖnIo ߟO­gY|›Ò.NbMÔ)>DÍ4sñ˜oP[o’»‘‡ýdŒÝÕr­Y€èÖØŽÆo–øMMwéÌ@÷Zt)öuñÙYmÓÇ—TCDT£¸d1Ÿûz7ul’åBE0wçn2€…>~æÆxžwÆ(F·U¥‚Õhnî¥_;ó*˜Æðª0 æ!¡ÀÔkL™8$)ÕΓÛÖP£ØLîÂSi--ôö)�vyXæúDûzUŸzåÍ/?.×ûœÁå‘Åzã°cwTÿ@•­'ãa`ƒ£zXŒÈªàz~'Lì±;[KÎ*…Ji á_Ç™#bsP™:J˜>•Í—”p¦¥´„’ Äm××Ëtì‰òsWnêÄú«{ÊKÓoAÄ܃ZZ7â l¬[°0Ö ¥PY€weä+'ØÍr'Û6 r£0ľ+Šx½sù=ú˵ª ÓÕZh…;#Ý{—EšÁï]™ñ;ŠãI^9÷öI$ïŸj“JÿA‡®8Ö÷ dÙÔ1eå*-É| :ítäÑC¥¿3´<€ãÎ5NÛ7°íþ¥bŽ;Ã7`ÎÈÔª¾OƒÜ¶´¢œm†ÖŠTS@ÁTì‘Òm/±dv=Ó.œ¿í;Öh0ƒÄ8‰ÀÏM¹ª÷ø%7ïžWŽ§šòƒ›³ rø,¸ Æó+3 >hG¢9å]®XÙ…— Jzâœ,È…ÖjA ÅÚ¼Þbs£†‘ ðv½ëø–2Õôª¤mê”ÝQ垻΃xÓ ›6Af¯¡™÷*¦óõ·w fùb´‰ëFبšÝÈöïpf<„•øü;Ž,ó¬)KõRÉÚJ¦N¥ë[=‚~%eÙ+•ŸEÇ«µÇ•ùr<Ù7¶˜6d2[kðaWSwÞMw£{R:—`†®ó=JZ[±™Óõ{ƒ‹þí=I|’?ËËÎgøAwg§ã»®w£´WFö(Ûj‚«Ü–M–�?í±e温‚ì88ê ¯#_Ca25"{VthLKL`D¦œ^“¥ÄÓó༧' ïXš<N“>Œ¡³wÃ$~ƯڵÝ>Oì™ñ0ªðØÓ—|;yiZ u»›µa…~„N ÆÜè©BÍGü lW& 3Ï6 ‚9}ômç…y´K¶§qš_>3wW„L6l`e¿V.{Îößh6šçja‘ÞÕ=Ñ8[lÛŒwú}!3¥œ™ê#‘,RðôÏè¶XM0âÐèWð<©=¿ ¯ÝÌiV7]c*¼grøÖŽ11b}Ã9§Z@;¹{Jôg j¤ÌÀH9ˆêY«5Â2òßbZY=U!G|¤{_ök=±ªéŽ¹¨àD«£Û<Ñ™I|»Œb÷ :Ecâ´9¸t³)!ö#/W/ « ð“Ói` B׳ø¡ºÕ,îÃkê"ò¡fô›öŠA9óÈ †:‚jëVƒ£pì~5‚° tâˆYÂÞ»¶XXá³Ïe˜D›Ýð(ÿÃ0ÂNúeüº•ÇAûUúcÆ? Š*Þt¼^Í?×&Qb¼¤K9dÒñSc]ÈGþÎ1eúc#_‘)œ¯œ`ö¶€0G³Íd¾¥Í[_EÐØ¥+v¨ÌµŒ(^ôNž™/£|Nã~ºÌO…>ã(õÇ48ÔæÊÏOŸÐÞœ†Kíî7›®7�É£€°ˆ Dwˆ¢sî…Á­Û°·Ýè ¼wüPìhs˜–V™tÛQe”Šþó-šÔÓ[fXÁ Â×›µ«/h³Í(ÓeÃÀwz)ø—”»ÊÂס;× =í.%NÔ‡¡ÈŽËê¦y-ï;Ê�—4}êš’5ïFú+²­ñSv!pYú= wÍÞê÷LÞë¤ F¡võq-(ª=U£]€ç˜U}´vL—7îêÀ£lƒî‚DqfÖÏ猧a¸ì»ÖK]\&'Â59g[0ÀÒš@φ2 7Ì?\Äý­#\ª³/™òä8öýƒEÂj¼€@K =Î{%È“Yóµ^}tß”UG1ªtäÅ¿š!V{ú³†Ãyð„.výz¬es{—ò¤®Y‘Eæ Â0g¤ X[¸ŸèO Ý…o³r!ÐÈm!…ÙQÀ}¡(ÊDS¦“±3O«CYF7oëÌðc7 Öó×=¾¿9Kf;qz÷ÜWY* 8wÛÁFMŒbÝ{¢!“Ò',˜…o^̺z­o¦Z¡Ûšq’ßÆMs/wãŽôCúº7­w>3Ì!E›µ¿øŠ;œœËËi™Üœ¤àq î=8­J|Y(ØL P{ñMâžže>7‘’4ACu:ð(*åˆAAý€†ºRé ãtKçSþn95ƒ:ƬÖ/ãI¯¯R^ 9f¡·d˜…ÝŸrž3:d=ì‹ëOó©Âò ÅÿoŽ&¿Œcw&U%ÛZ›9�¡uÃxù—Ê C'ÜÆ \ù#EVc½©XÆ Þp’,©ìxàØm>àÍ+"·Ë“ iH•T䃆Xý 9MãɆ ÆWÒBþ¿ë^û-`ÏprSô £Áa÷I+¾µlŒ>j”F‡aa"jµÛ蘛ó¡`�ƒ1xðz-Cm¦¼ðÞ£¥ô©+4)€E÷§ ç|æ,ê×o<…³+±¿#å•ùdAð¿Àì‚Mp¤3ò«›îäÿ3C¿=×U­mk¨6¦û#æÿKgBs©WWÍdP‰,oBõÈ6ºÉ (§Þ¦ÕöpPóªƒÕ´ž¶fRà_݈YŽ\¨HªÍ‰Î¡Â ;‹ã àSûÝq _A}}æöë!ö¤Ï3Þðh‡`¸A; ]F;ûw>¼qå°}iݧ­v’[q¡¾ea)¸‰ËÆ^uüÛ$?†r¦ò„‰aX”Ldx8ã>X𠦾>›Œÿ7T+WÓ+vúˆ­9†$¯T[µ“7ýù ‡ä*ö-ËPÌTB–ö©¤�òé›3mbÒ½H1ºËGâÁ©£€X@yÿÇSëDÖËÍU”ý_D\x"c<¶l/´ëfuÞ�æ‡éúLºv¬¾a+Ü%-Dž#àªÎkjÐ!bž\ùtr…_,ªÌÓÜd~×±Çíït·, 8RL5»î– HÃC>‹áŸã¾[  b«ŽÍZ�ô÷Ï°6ÎßVšÀùóI´ÝU¬ž)›ìãå«ÉžTZgùdEå²°Š­~ÂÎYzÆ$Ú””leÞ!ïkð.ªlá V‚`Guï»%ØEÖýÒ˜>ËtøP0#ã@¡Ä|½C­ËÔ’.b8/ž¥ªð¹áÀD`å,0wÒôû:^õwÊ«¬pÙVÁýþbÃGG¾ÝhMXw¢EËâYç"-ùš– Æ¢V èŠ0Aüc®�]ÏQ î\Œ ›œ–`¤ï½C€Ã¶‚J35vU= »ïáðr›YÉ�ÜË”>ìqc]\AÒéjuYd½–7¨w5¥åÊʼnf>»šTùÂ3¤dðTζ4<üÜøÈrÇz9¢äKx9•Éô„Ÿ“'­‰üLÒ}“¤Ý—’|"‡–è¡eF‰90ýATë /S6ž³IàÆièX@E‚rè~2g à5íÙ–‘²¦zøà†È¨Ê÷/}É ÄôC¶#&Go9wLE´ìëÆŽ#ÀÍ……uKùÅ(ô0¯ì—œÕvpp&°J¯õ¸6ͧg*lšŠÖÕ¦sJ‘æ¢�yJÆP¦ûTEt·wGëåi xi]}k’Õ;ÈCO‘€«ʉ(vöÚŸ‘þ«Ë Mqå‡ fc·ÙMAMaèÚ#ræ@CȨ‹ Z'èq„ß‚¡`¼œC'±7¢NÙIvÀÝ·$sî–¹‰¥Huk̦›žê>îæ`èyçuÀ")‚y¢=7®] švàŽ0ía8 FTÓä wíéwHHŠÌ÷Q‡²Ì&gb†c8¨ƒ´.×чÂBðɪB¯Õ•0G* ÊZ-‰QHrZ(ô½iŠÚ‹Õv§Ñgù0ã¡ÇD¬ŠOÚò¤ÊÜ@aÛ“O']/Ÿ²Eè' tCÎ_Pãµ½ë\Ò„n0 ùÍ®çlV_>SOŒQ;h•_|%e•À˜Ìò£›˜¡|-5zG'$‰bGüÁŽ‡$ ²z6á_Œ–Œ� /r¬°‚ÿùËÚ}ӉÕ¾>g<FEêë»cB1Ò/í¿½`} Õ·;ìÅãsùz;ÒŒ ‹ªàcgÜAõþmþ.íÓç‰v#Z:s§Oàë’Ð{#ty}<ËÓìÊÜ­I+ ØßÞÈR}Æ6Ckÿd¨Anª{Ó3øÁJÎÏIñWPº@‹ah½V –+ç݈o~Àø�%(¨Ä`+yß›ÆÀ±¡§‹¯Ëé6Ý ›cæ u8¤tH®¿=äìêD‰ÐYl· Y´•¤,QTYø¼ð¢æ5Ø1ß» öý¹S¿€ò,‘C;*!ôů­’ÝÐåt ZsX£B ¬‡M·ðh¤íÛLœìïGƒ$]Òoï°¬J×â`ÉßÞ]QÓxKß7^°€3äu¢›âFCÃàÑn‡ðV6E5«×ú»«¸2Ã{<œ-.ä'ùßxáüQÁÀÊ5 4É3á ²š9�mÛñ©å®`sÍ~ï·`è*ñÎGÆ/Û,ÈzmŠB·nv¶ +dµ”ˆ`wîNrÇÖ‰¢dC7ôt«VAèäYÍ%ý’ù½�¯ÊÂgkÑ9.Þ`“æ´ 6õà“¡0H‡IÝoÐСÐs§°j!jNϱiPlá7ª#ÑZ·(|…Ÿ»"GVý°0í°ÂâU­€íج Fï˜sÅ ‹aØ‹ŸÌ¢ókøÐÞHFYôP ¶ò<Œ[EÅðe×äáÂù:ìÖžü‰¸L¶ŽÑ�ûÙnËåþ··¤8 ¯T$x jq°Ãভï þûih–û$SðÜÿú³ctÑÿ¾¿; ß“ŸòÕëR/öhG©³RúíéŽë¶5@W«æb\e¼WuvP‡ ãŒò�:à©üB©VÚ2Âû feæ˜+FhCw½lnTÄËÎÄFs¤ ÒÝ]Hsö£…ðë¦y^&KÓ(«¥[•áâv6­¶ƒjY½æªVz"ñ(I(÷£p³Ué>¼é\_úƒ}‚”aè‹…÷M(/Ì-}è> +hÀÅÝKÛúÞ‹‘Ÿ–Æ™lþÕWN‡´¾S w`Óí…mN#%/8`D•k/”ìyüzâ±õÜðüΟD‘}=Jnlû|/´•“…»ÜËÆ”¶MãYuꆻ{Ðsè­á~“*[±’ £¤nP^YÉÀaȸÀO¾í®¬/L*ßSY¶ýÖFtTó¨O¡^¿€Ç'vò£&Í6—ÂÊŸ‹âßÔ92$féíá<<Kf>œÞP¿ê‹G˜»¡ÑˆúÊ”p91,+×㨡÷8‘‹öÓU©ÆAK~Óók:V¼+˜lÒâ‘%°øNê÷"Ð÷Ò ìm+;³½H��8ÉÔâ‘7Û‚ZÖäy×ÏFÄÂ^ù¸‰Ð ›·u³‚¹úNÅÛ¬é¦õb|ƒIººvs®ÇîñÐ<Ï3ºÁº?T¶C£´[‘7Íã(ÈÕ‡¾vúv±Øщg͇0+„ÚálÔ é±WI³÷3s.KdyRHƒ´Ù˜b,ñéz)v;JöÝ ôw£ ?ôDŒáÞnP%©X &´]Üîä›ü¼qëO¥³nÄ¥žÉL•ËÖ¸eAÞMžÔêæ0î-¼ì7 ¿œ‚oÌ“™äsãÄÚ™ø2z’�Ϧ2þÒŒlÙj΃ì];€h)£Š…‰¨Þ‡€†›©#K£ Ji,ÖÜÕ-Á—ß2¢‘È0ËY+3qEØßÞËž`—£¨òExð–КO׿?€ÍºñxÍjWexW×Ü4ë­\™úŒû~ëÖ+]÷â¤mnõË­?Ï\$îŽ]ýì~Àžìyº¡t…s3o&ôY‘y€7�`’ \o,p‡©ò Á¾ô6K·rJ¦·êµi·³CKÍŸ…)Yeú"ð³L¢ô’†DÊñ�{ ¹dûC3…>ˆa“ÊŸðË[c}Ú?† @´\þÞ¨¥…–œ,§¸”OÔv]¡àRóP+(ó‚§h‘d¾ULÕaØ.4¾ßG=ï´ Å”�Åãï–®[P$•%fîÄ.GUç÷|%Y^¦ÆÐ÷‡Îb!l‚)ÜM^wFM ny¬ÈMº@Êú½pîW[|vƒ_Æ#{ýiEëð€“ƒMhèf}¾{nð´91´Ããv0ccïò¡7t”»ÎÈ+¶sBEÌÚ îEúK$Ö¶å dE/Ìgîò8Ör;— &¹lˆ9'³!Ï':È'­¬õxœç<ýªaìb;›Nô=•§©U4ÃY„Ãn®‡ ªOĸ¯;`ø© 7uwØÜûÑæLõ}ÛÚW˜¹x´®.)°Å…7Ó^{e;óˆ¯ZEW†P´éÆ}ŸǃCQkÐ ÅMVÍ]\Þ·É)CŸ@’£ŸRùûÑb°tÆÌo¥_wüç®JúoÃîy^ÛûV¯yú€B00¬•¿òB¢ÇÓ7‡ùÎO|cÛÒȈ·hzTöàƒfÝnÚ:q˜O³°¼Ù!ÒED9ŸêFÊ&ä){8Ö‚;j6]¯æÝ°\|® ÍeÃHÊx­·÷$˜ö³´ép‰ ¡q¾ÀŽ÷¡àMC¼Ûh:{ݽN71FŠE¯î\Qêüq=âßÿ)šêEæÛ]¥¬?šLï*ÉB9Ä;±ù*ëÁ˜mvæÑ¿–&š>’ ºŠ `L¥ªµ…ds¶~/ú� ¡{ÅÅ$N—@X4k²ñ]‹‘ݾ³ä%­B6»ãt¹G[z®Sf~ý“ SËzàºGgI'¬ �Ð#Thí–ý¡í™¥K;+vµ~kmYË‚²Õ¼;nÝSy�ëAQšu-‚XÛÚs~iFªëAñt/ia%¹_¡RþŒƒl®íàØÜý}×Ë Â|úù0~žð¡Ýkã^´›Ùn¤ø«]`Õ3X MÅQŒÒqlLøó~dœ™.p´Úž6_ÿÇÕëÑÓš ¾ØŽ‡#äÝ€Eôiœ¡Rél¾ a€!@g%Š8^C`뮚ÁcÆ«™DXRlX\“BnPW¸rîÿ)‰«(|;ô$ûåøókÁõÞ>Ôb½—iÃœ{%b=Uö�·è‰qW·ñÌ>ë‰ù#øVD UÙP_—]á2rÈm4ƒn sÐî¯Â tÓŒX/ØA§a¶í[át?™ç8= ¡$Vô RŠêŸŠ2ŠŒþTã=.Šï‡Étû^v-´µ`Pûì3o\ÅÿyKÕE<Dÿdo)+£¬é_> $¹7¦çŽ¬à?+Žlâð11ðM‘_??óØ)Œ¤Ø‘}—ÕÚÌÕ\ƒÀÉÐz—>wW²IÐgN½Ÿ¬àª¨ºõ^¹ û¦Ý0·K†õõ‘ã1;Ô²gÝ@ojí¼¯ŒA(ƒè¡ "›7ĨR±wÿù°r±y7+, *ͧ#L¦m½;ýófDÅÑl2&Ÿ¯ù#gžjCÎEÜ@k-ú<zøÂ96ˆÙ/ݹ—d¾i6 }ŸÄAùþéIÂíõ©/ÿ6—)9ΗÅWß­µ0"ÖÓ•µ·g½ Vð/ƉIÕÓô.m–/È­7Tpsز"bØ#†ôô·O¿u³˜ñ¶‹àÃL7'«5fÅ<ÉÚ BýÆ2x¹²ù²ûâ-…6ø¤ÚUCr4ª99…ŠlÐe1Ú^¿£…z]îywßeõ²;ä·)6Tû/Ý·™Ò¥_pè -îó´3eFŸz\ó,¡ÃOè'r¿EÔB‚ÀƒI]�Ë 7ÔýÕ:OƒìSE ÇO)h¤³:ÚÒï®f‹’-Oáñ³ék‚?ø©ijús¿§Ã|xöµ‰šU²úQÓÁÙ…ò›Sá¨Odwô)vÓE5<0_1ý-ÕÓ½ÒZyû8Œ3¼iÛAÖm½10óƒø]ÿ!‡¯½ 3è •‡Ë,IwR²!àö• K BÃc]Sé²>Y<~EÁ(Ž®<¸¥ýó¹µ³²Ó„q2Ø/Öë±í:„æÃ7tº–ƒYÔ�&Í€:«ÔÙÈ°5Ðú|¤ïCµGZôÞHT3ý,6ê¾È‚d´³`ß¿œÄj¢ÏÕø{]ý(oEK XAIþZ}?ò½ £s¦ìh¶6g•V 8=Í4iÉO}èÓ…n¾+FÓžYêѦ€¶vtã43‘4ç!Ü6ðü"èéÿ§ïÚÜ€{v½Û :Þþz˜éZ¿9d:= §œß^g† ¢·ƒ°hµuƺ'ŽõòŽ¤yã´ð…³�Å…ÔOÖ+L´Ž½/ÿºCmæÁß+„è3%×Yÿ®@qH¹ æ)*Òí„ÅD_Ÿp\#õBJ¸“M°ÊY÷VE§V»¹.ø1Ë°ÿd‘› vZõÝWçfž=ì|¸T¤žSªZÕH*ƒÐÚêq[£èT°m÷mÓÞ'räIìšð%)õ°µŠ ÷à©ûýï¬âDu”£Œ½jb¨†YÛ¯À Z,ÓBŠëÌ[ý§PU8ä4Z©LŒ§NWwc9–Òº]‡Ã†%Qî+²…ÖY»fHñÎ;VÇûK­<ñ8wÉ'ŠQÕ¤Øi´3¥w !룴|ö”Ršò™÷¶ù——„²RÞr€¸3ýÝè o§C«—f®žºyžÿëø¸Œ3Ï›œBðj¦AYš~ €1l8È`»R´xHöâUCŠ¸ô¦,¬®‡Dv\»•·é(OB ªöï:z¸ÉÚ´¼³ÀÉ#„k5-„¾vsøÚM<ª@­ËPŠÎþÐíYÍHl™ŋ¿€þC:M>­!gÂUmg])´°xÕ@µÊ|í¾}3Ê ¶“çrÓ±[éĉv‡’ëNY’þÀš×…^Ë¿-Ù<•-9ž¢¹ÒØ%%ç5y$Îó0A Ž[;}Jhˆs#Ì̧ Ò"ÍØ&‚ÝÏO5$Iøl7²“�ƒJ‡§¦câjžÆí•#žXX4S§)õDK²ªõ‘càHüõ……GåU£“­@ÓÙ¶gSv*éÎD|ùÊíóUóϤ,3=I™ˆ9}dAþÝZº’Ñ67ú ol¹Ã~]­)¡,ÞuÊá\Š˜Þ@ÕÐôPÊ®!ÒvV¢ç¯*ÛÃIÎ-žȽÙVC«(ì*}À˜Šôxæ:ueE¥£ÐÝ•]¿‘ëÀ �Z5¦û)ô{§Þ š×¤"Ù°Œó.!â›ø¸¤œ˜z/W£»íœ@þs‚ïùË}ÕvHò »hE].M]{{P#˜(гÝí§æò<íóƒ.“ÐÏàHm­ò`)ÐÒƒIËQ+7µ§Hfp×y|. ›cV÷žv™u¨µUÕ+Sê4ñ¤{SF³]² èÖF+æØT�Lo ¤= ;VÑ<Òúä%U›æwlǃ™y—Ñÿ’0ò céÖ¯0ßõ~~S€ `öرÎÉY€?Ðôða?× ˆÒÅÂ#‹ oN·'o?§?µðyšçDÔS0åD­ØZKÒ*pU€/‚ÑÀ~—àx’Åñ€Îè6EióøspHlA{Ò”zý‰ˆ}^rµü5–Ï#Ç*¤Z‹8¨6©–¿ºP`Üõ'´¢8ò`Äx…þUO÷çe¬B1¥Yclòf+V6¸es&Ѳý%2¹°f*ÂÄÄÒ„¤f;¤¾ôç‘¥G0Ü2¼¢‚÷5¤æa© ×¥„î? 8¦\ãyw^i{!ô¦ê|ý@4îuYEa é×Ît0‚íd‡§Š Q¸ '€ÁM{7ßØ¿à²BM>¿ç\ Ú2xŸá4O¨;ðÿjºÚÐæ’;âµ š½½g^È3YÁ †ÃMë‹!UFüÌnAÓŸh¡üõ$=Ë…¼!»deAÖXtz.:àìEº\Ê"#9(A…³é“ ™•dr¯˜o "LŠÝ8€áL=O°¬Ä¼äuùÐã–|@³BC§ÎCEÁz+ÍÅ#ÈÎ3îAbWÔ›“ÂB;ÈmcÎwZ[³É—nðk¿ø–ÊÍÐõXÎ¥Ç`$ÞªrƒÃÀS{›°pdÍÏd>_8Õ{•S–WZ¾ ¨å{cÁƒHM‚L€V·;F,-ÿå1_Uš„¼4¨ë¦¢ßñyô,£ÙMÕ›¿às2ðG?(çž! (ì×ÈÓQ‚Ø–ïÄcDóæwvã+³  õ<Ø—AÙü1÷, œU¯hýeC3ñ êœå›©² ­(Zd F ××°m¥´zTbY蜡\”T›ÑÚºhº BQkÓbl¼‹N¡Yêj»)î¶Ã@çx±Öe{8.TÅSù‰UùC¹²={õíæ†ë²ƒE,ÊÛÒ ²Ù ºLœS;KY—Þ»ºÎ U¡“uîÙÉ8™5�K™~¸gq4óÇŒÛË ?}×v¾<)`ÿÒ£¥É‘…ò”Q?ØÉI¾4ÿ4½¾¿Ñ‹Ħ¿óÁÐ’È¢@ñ«Þyàr«bAùØÎÀâ‰Vk&ö)QçŽa¦6öýÂL“úYÒˆ§®)‘ãöÄ‘16T×g­¶áfFµ^†¥ÕZ(CÇgÔsbYª)/#D€�œÓ Ý6ž$/˜þËàû:õ,¥xÄ '¬uZÄ’•“Ó+Å:];v#l/t¾kþÚñ9ôÜ|½úklÃYÈKlë)íÈUU½Ò|Ãþ¤ãï´÷b°‡ù}éÚ«{ ¦- Ϋ¨ 2Û lzdªc!E¾ƒmZÄxNI«k„Ák® ž)PÄ®¨ÐpkeÛè8Ìò‹Eýÿ§¹F–º·dµƒcG ;klƒŒmœ•ú­jýß7zWä/šž­¯›örZd.»`ÒÚÒ4Ý8Ί´5³; Æ|è–š—‡$¤,¶KZ”¤.‡2¨>5—ˆÙ—²SDƒÊ<Ö®@»žjrùzik ÄÈéž[ÚõEk U&­Å#HÂ"ÜiX‚g‘K°¯7è£$YhÝ”Á Þn§§ìȉ’ª™&¬f:9YG_ÅK¯øHGg [G‰.>I;‘ö%%©ïó§jj¡Ø·>Ö» •¨_æµ(˜ñÝe¯[w(Ñ›­×V´ Ž(Ìg}¼±žºl)=©î;î»,(/:òÈ#“E->°!ˆØWRc…îìî;]ª ‰Ó }‘Ãw$߶[êúO×»;¸½ô£‘ƒéš (€àü•ÓR´I YÓ%[LeŸ~wÍ“J}¹dÐ5pÖ£¦ƒ±diýéÃÁ6ÞAÿî†×Ø @ǽðÏ>L™Õqh_M BçúÝô„sy4�x[|'¦Àb@ü³]uùTv˜†}Ñæͦ+x‘cUXMò› '§ÇÎiÅ•V‰Ðå1%ü˜jÀƒGKz­"/t*íîÂD•Ÿ•<+ƒŽ3j…” ‚¸ë<%9»±Ö¦Òßzd»®�?J¨¦òÝVÝÜÆSûïå_q@è8ÄÒòÙÐ¾Ü 'a¹ÒΆìå÷äd*mãZ5é@4Ú¯>:g0ø ¹»¢ò¬|Tú–j4{è¯g=Gcœ¨h€2Ñ ,\ø!lرŒ°RLSTÖ® ¾3g¡¦š=Ž-Æœý×!e¹WÇÆ¢ONéGÛ{ ôt‚J7ÆÝwÇMeyÑù•Õd”*µ9A4vNK[AñâWïº4…Öî—H/ZY Á’®Dn„'6é"w¡MÉg7m-*£iIï2õhëÕa<íoŽ®4õÇyn鯞l™&µ¤e¤<¦¦XðFiŒ}÷U7ž­/G}#ªðŸ¦¨‰'ÅÍŠ—´,,ШäйgXˤ®ÐÓÊɹú×w·jë--Ø,ÐïHš‹âŠ1ª'Ï@̲±$"±ê:fY¡”RyÓлƧÁÓQF´šë]/ÒE/ÉB5ô³Ê6ã:I‚t´E’XÎX¦b 0íAµ'©ÇÐÞ¹ðý·E"&b+±dì –Ýn¨%c}jæh…â&X8@Cã@Iì¼BŽßÍèÎܼÞ‰¹hpJ1d«ˆÝÜÂîZƒX黺 …Wiqÿ|7’bÒk‚Do0ìR[(Ñí¾'„½'úhi^§`Ü=ã:ÀÃpÝö´ÊpÖãnj.¬Ò´íÞÎôQ?º—;hE¸˜æ¨I)¶­º$Qq}“Ó`}ñàþª"”õíM æi_ÑZëœýè ZvÚuÊgr<óâOí9¢D™˜×–óÚÍÚ]’m(žØfUè¥ °{Ìi![a8À·7B¸KR~BWº/s=×í‰ ™Æjs‡~‡O?07 µicÎ~ú'³”¬%:@¶òGx´uÜÚTåEáÓJ—>ÕQ÷ÿXÛ®øa¢OÏ(¹¹³ç{ÅCFMIÌ¥½D ø΀þÆf'’ðÙd]Oªtû Eü}í¦ðÈ»!&\³ ­!ÿ‰•Ç¾º9¦ë„îTßytæ#ò‰B–Œá›ñ2ì»á2üãôÍ à­Ö‡o4?¨”RˆˆƒiÈ7ÿæøw€îÊ$MCá'6X`JÝr–Ï™Ô>]íŸÉ4Yä¿pe‰œûݸ"’qü·¯Ø†…‡ñw“Ûç¢\VÄ(ᇋ)°Îœ»lõz6pâ;àLJÎÙFáÅóƒ¥#ŠevUúh»žNP˜† æãГõŠŠØµf%Þsoõ›õ ˜¦ê¬S†L.#w–ä2eÒUîõr.æ¹J˜©3z5A-DïTÊT›q Ü† L–9ŽUyYõiæš*°íÑëpÒ­Nj'ÒìØ/[Ê\Ÿ¤i ¯lŸÞ-3K/@’’a`¿P_HЉª›ÑI¤¬F´\òœ¥2“1éÉKOm-K—¢�ŠúåtÜÔs( ²uk†ËÎoß ñºýó¨ d)ZF…†} Š îÿxRªh¢ðZÎΑî¨ÿ•7OÇÞI f–æBBRY·õ‘•ZX2×ô&ÑÌÜ!ØÕ¯z|.lšDèi‚TóiW ´îX B¢ Pu¢0ñï ÐÛŸüö5po+šžÓJ¦óøÝõO }Jt™e†Íp¸#fäÝ› ?)„Š~ô Ò´Ã]Dâ›ìÒÍi»,§eutŒJZ°œII×tý+òÂð;Õ}\r*|„U$æÑU}wžî]‹ÖK·úxÙ3Ó Å¶V3A6Bí‘V”*Ý×M>.!.¡±Ü„¦k÷ |CqŒÒ8sŽæ`DIoG'œ5S’X["ß0é ¤<]ÔjP÷-#O©]l°9nzjôøGû*ÂY}}~˜tJé#†‹Û,ˆë‡¬;ôÞôùÅù@/|‡àØ9dAÚÍ¢ÃwÎ1¬O"-릀®˜IךF{ƒN˜ì]ÁÕy0)îJM¶A`YXwªûB¼ôj¡#féV"ùhmA‡]üâÁêĉYMÙˆï>dd¹ M’æNÄýE}°k´ådÜs¨âè¨9«çØ‹;Yt”øa´×—$(œBNèÅêSýA\6ññ7¹˜wåAäèO<Š ^&UôW³èü¼óLÒpÑ´Ž5-wÈ5Û£±é/ ¾á $½«º¯÷Ýnè8|1hF8o2 ‘*)‹ÿXaŽ(¨¦É”‘°YŠ''¥Ï)7ù\·Ü¤ŸµîE²eP³®õ•IÐÔJ¿'³,KÁÝ(m“4áAæU]ÍÎò:JúyªäYI§iRªÙÓƒîá2ı>φËpU9L“È=ø—‹L(w+,ýX(Ûƒvq)ûGêQ5ÄÓÉËvs‚Üu)<Ä¢†Êl%³qþðÈßòörŠ§±“ˆ !HÙ§ÕqN2Ua²xÿÒË„ä}!=ù ÏÊVs)§÷èºfQc‚ØŒd§¤]»ÈÝ¢ÿʼns)‘®½@sãÖ;5):cÌ36úBe¡äà•ê#¿»J÷b_Q4蜎ÒÔõ,læL¤_F¯ä¡ï ®>æpˆlUÈzž˜ôšÓ•c¹ úYŸeŠå É•6ºâ¢Úí-Õ@ƒÙÞT\×€‚}ÇF!¢_÷ZŸ¨,‰«E�y8Sª`©Æà¢Òo�ª!'úˆô“¦N–;î<wÛCƒâôÜ9Àõ«ëwEqå„OÐniN^»VX‚*µEqDÖ„Î�Ý9k~òoßýk~âA<gÅÀ1£Mm5waŒÞî,_is�'ÚîÀ· œœNÊrßzÒÄQîg“8GfÊïÃíìô¦ªïÎ2hõ«±y¸ñ$¡—äÒ?ÈèÓ6Ú¾EïcK)Ÿá”Õ'_AÞ\êØ[Ä\a€…}—‰,¢ÚyW�+ÙP‹üW\ËʧpCE}yf¤€l–,ð[σ(Ôµ¼&2q÷íÍ&ÔuÆTS‹¡ÌÕlƶR¤-ÌÍO8¢hK.] Ö;{[íÆÕi üŽ§æÉÏdŠW+ëGÕR»­héµ*‡V4v¡§'$é…¼Ò) ,÷SìŠ.<Ó<tUƒ3Š÷oÏëÕón44hiT•õžÄ fõ3¤Bv¶Ä˜y†>/fkOìí£Â5dXê2, Sšèð§]ߺgf¥r^/O*§œ²áSC»c«7j2^ƒÄ †¯!ÅW­¯ /"ÕMU…ÈT9«xð§6íÓ±£øAÇ»¸áB••”QQh¼zÙÒXðÐ=²z–ª2ºñ¿uLËÌGX@dlÚ'†8s dKAý88Ž´Ò†“a„DùÛ¿o˜?ò.´iJ=ÑòÍúd_§ j„Ayª=Ë.,ds',V´†U9NVQu6<y¢<ñ¡h$ 1œz­ tÄZ­¨¤5ÿŠJ>jÞoÜ€wÒج¤bëá2¡5ªa¥}ÿÑ=ºæ&4Üá¼ZälTâ]Šß¥õ¦‘g(Cø[ ,öÔnÝ”è¼\p¹JÊëá³kÑž9gœVK `  æøluÈHâ‡Î()zï9Õ,­m-ä ±¬ÛÃʶ0˜…"_I|‹ÃÅqš{JõÃQa¥2zc›]bßØI‡ÏKŸ{3YÊK$"r9½I”›‹©Èb®^¸Eg¢è/˜™ãU"°æ"¥lõø®æ©¸¼¤šìì&RãÈ3n(IÌ.£G­<wMcÚaçƒjå?¿òg»©ÁÍ€ü–ÚVOjDùyZѯzêfÌ^aÂYC$‘¦‰àø‰úÅze˜¥ü×´|F§O¸çV)Øã&ÁÛï¸rË Àn¤aæÝ®0 &Êâ÷ÞS$83 ÄÆÁñ€È" 6½º×æÈ|4Gºeù¬ ¯ÞÙ²lDùòHÔ+¼+³ƒ‘$„¯EͬŠ{ãEOIä×Zw!oüx 7*Ê6= v'Ob€îÿž r]ðû]ÿaœ'{ñ4|Ú´uwx1nœÆÆŸÐú¢Œ5}¿¸‚¯9L«CÓõN7ŽgŽ"øò#K}ûm:¸P¨Ö'¥ªÙ9°LßqZrûêå2!_ÖÙ ­Ð݉†µלæyÙƥӦﾠùù7ýôÔ£´•¢FngiôtvPN7ÃRw­ÕÀû—JiiäãƒÃÈú =êÄ8I”YÁÓ!aªÊ‡'[w_œlæ+äÁ þ«³@õoßôÝ@)æ…?)«ðqw÷‡,WÒñðì“U±Ë8d%Aw‘ª™VŠwI';‹ú*9Zâ0¨>í©ôíµ+ˆ<Ž^ , >ƒùý/T­#26òéàOÝžŠ÷k{÷â/“©œ¹ê֓ͪ Ô‚¢«ßXÒ KÖüÛM|o¾½ñwË"Ï*ºDÛJ¤‘u;ÀàÕÔJ/ëJþ!Ï•SÏ.:ɹ1w~_Ÿè诇]M;rǤ…h¡Êz ƒwzÌ6´láý æ%©O�‚³¼¬Z´þðÄžú '£È †*³9Q±_Ík×;À±§$¯W%PãØ£E.·¨Qm'éØ;Aó’k|éK®^ÿ�—ˆ–¼ÛØ'Êz«; k Wõ#ñ[Ø$Ö»~æÍ^ÚW‡h5mµôûW²üï¨å(qÞÕÍ°ÞïX—Ìïo9°×f-ÙüÆ䘕P¤Œª3Õt—7q3ßð/`8ÐmÖœ‡ Ïô,ØÇààlÔR:bå:ó�e˜K•jJß’’@(oßz ª»A‰�Zx¡¯OI•«¡b<l–ߢz‰ÝúdÄù0@áÛzî!¦úT¨þ`ÍG‡Ç-<½º§!‡~Äá•“娽ç”ê£zU¯h{Û³á„æû‘›'fVq 3)²+Í›Ý.ƒ~òô£ÌZekvN¥gí®féô ¸°ùãÔ·�šhº€Hu¨âØ­PdΗÉ| ÿW¹BÄ(äuvÔ´r`ï0=šTvâ%˜ï'‰§B:«¿µÌòU#%ZC'pÍßÕÑYî�Xu: ªw[‰Ð?ý"° ö¨¸?†Ç ‹p¨8'y6“§§J~¿Ô4ýþmy˜HfŽ†‚„8 æO80Øj¡ ΋`&À×^ŽQ“b¾WÀ?Õ9ˆi]éb´Ò¶ƒdãdÍ<9§Ó¹)‹èª>ë÷àLäÛ-ZRH¹]ýñð Ž;tZù`Ò–-IR˜)AB5feÒ}uW/˜�”ךoz)z¥Q¡½Áà!¡RIî¹Ø‹É´¤Ë[ws¢l8:Þüì¸cÅU[^ÕNâÑ¿ºÌ÷ÑZ%>lSá°q–œÝp°Òa¾}¸Ø ýÅüAyËïn^Óˆ¯Á�L×CÄK[ <²ÿ§žÌQd/nñ”.SÒLΣZe‚& ¥±:}~40à„¡¶`aÏuU²Ò«`š"T`¢OÕ=£B%œ•ôj©üä™ “6Cqpì¨Ø¨&íÛ1¬ ÓýepRN´yÖˆ‹¼7ÿ¿ÿCá‘þuñÁ5ŠžÝuÁÇné2QýÇ…|PxpšgZ9‹9íë<„´Zš‰”À€Ñóß(Íf{¡Ü-äÆ ;úFÚy Ùzå™nþ¤‡áûÛ¦O;²£êF'\@Œœå¿ÁQBÉ·Ì¡ìÅLŸjÑÊ^øc… Nè*;±þŒ1C»@9Nœar¥à]ÞXÀFåUŠÑO´¾ªskN©ÊâÆ$zp„!]Ïuk[‘H£ÈÖ £L,¶³†DÅðï«cmþ Yag÷¾óç]‰ SúØ£&b;w íXotlyÿ”zvŽ/}Äcf¥ùçäüN©*hgÏ–õ÷—$€( }q:uÏq5Š´L’[–ln ßGP&– 9½Qø Šf»]­•wx0¢¿©†ô; 2>U ²nÅóŸ<à06;ò õ8\¸«ÌF‚ÈLàÅb-|A)®'#+z÷ÒL‡MrËÚÞ{:tÊuoÔ³"£²£'aÍ> €Á¸/çˆÐ‹þWDî /© ;·­ŽPß[«chŸéOu«šårØËèÿ!ׯþxÖ=ô7ÅV¾€þšÏÓnXuoF¬Uˆù%8Æ°õÕœ�êD.�-íˆñˆó)C7ÝîÌ"Ðñ±½Å»üŽkkß;*E ,¯·m…ô¡¥*ڪ꼪–UŽü)î…uŸÉ`ça¹ñWR²ºGéW?®PK7ïÖ™Röm$Æ/‹ÖKÆŽŽ &¿BDf¹?U¸¢K‚Ø@µØµ–{†ÄÎ`ûWi±¯Peœ¡ÐJ´ r/õŠŒ91�´Ñp£¥¬{½‚gmƒ,YÒ.(VR4Põ‘µÚ!£lTÒ ìîþb˜€ŒÚ7m›Å8/Íý6|¸1tÞj"Ä8:Fœ äíÌùñðÙ6œBÓ<;¢ñ1ià Æ5gþÐÖÍõ7šÊIŸ²H}0¥i: ?}Xsi7ùÐs©£6ICíOÐà ·;�E0€;¾Õ',B¨°!u‘ˆîÖ~ç¸ø#ûqÞ»X$£ .PXÑR }}Úz2O*•,oL¿K¦^fæ1y8™gk*.<fS%£z*¡s«)ÅHâ` O\¾Û7\!>v ¼{nÏÂÐwzÞ96õÈK”ƒs}*¿Ñ‹¬Wãø(MHÙ!ÞÜ—XŒ$èn¹¯@Ìêcõr„M×öÒ®¹NÕ,2‚QU0nr¯¡ód24cpÂ%}ØVéÝÑ£¦Ž˜Q9× xµE½¢ˆaàæó~¢²ÛC·íü Y3wDŠÜ)�ó¨ã¼¦ZÜGа¨7ö|lU¼ë±8Q^dKIµóTU£`Ÿª¸²:}膆ÛàøJ'%|1Ù‚<{##vîZT±K)¶wÈ<h%Â… ™É½T.ÛØÓn?®ßr¶ÝõL ”ú=ÖˆVˆ'ôÇ[Æ^É4úêìô"k’âΚ_½`ðå˜âv6î)exWhð×n5@Ÿ‘’hVFd¹þáÏ0¶<ó“*z €µÓV“*Æ"N¾.ÞË-»ç-øqü·Ð>×i>µ»Cc1™–¦ßó°Hû¿JœL >ƒù³ Šñ¤&‰!zœœÛj¯ïM&ì¢33ƒ«pGß;Š Úô[‚àlú,ñä¤0í¢ÇÅÕþÑž§�ÝÎŒA{pyGS1õ2sŽì«¹ÂîÝÊ…²‰&¢l¸Rþ„-ô5¯LrÏ;†S©ÕžÞ ±Þ[ØçíiØSJ`Í"pCÁ|cˆíéä¼ôTa^Ç9÷è!”˜5±­1>`Næx`>ÈKŠ,¶hN/ƒáHÑ°ÓX'2î8mNp^5+p3RQa/Æc°,Oi/¬ën°¯` h/ åuB6–[‰HKb@ îKd=éAäþg7±Î¡Æò¦viÀ?oŠæ ÙÊçºÛ±¥ãu¸Ïð÷ˆ<ðEº×j+–‹Tê¾d#ˆ…#äß9BT‰kM²hëHgl>ÖŠûÄÌâ@xᦧßÏúE Íß0gUÛ´ùccgÀÏÎ'ó"¶‰+´°¨q† Oß¾ Õð¡ÚaëiÛAB8÷‘bVU6xª tÀHjåÞŒ ø«V#I¶ÀhÐ_¬dRÊcC:ZÜôhVÔö¾EÎZÄídù²2VVUyf -L«g{·t¾h{DÝTJ1¯LR"cö£M d@ý!ßÚòæ4Ù´@ùÚw ¸ æ“JÉ<áú{ÅÙ%–Ôì´¡æ{ë0œub kÐÒWy Ë#ÿº„=¨/k%oOtÓ¬E»åŽ`Ežþ.%@ÿIH¡ÊÝÉ‘1v êÂÅtñf9âýêÎŽ¿-fs'ÌDw0á e8Gkõ®å¡Ç9ÏßО ¢Eø¤è¿î êl¡†?æh-)ƒiÇYºYXÐ|ïnš+ R;v®¶šêÂ8äœÖ¬ž1À˜þèʲaðÇ¢`rcœŒ(9”/Ùh„Áݱæβôψ8¡GË+ØòÉÈ°u§•ý›¬ù*òé�7ÑÿŠ4ÕJ^L~{¤x§V7A 8ت¼ëË~UiáÞ“P4Ž’±³ÄY*æQE3ó ÑÀ`&!säÛÜBž°«‚Ò"mâT§{I1`xzÜWûR€ûàÊjmã»sˉKg8ʨq›Óïê<¸ÁžÝÈ…äjDЦôÛ±˜ÿŠÚzØ‘œ'Ø/Ž–ôø©^X7F¤çEÀcš_A¢ÏkzËi²v“¬g³?NVãÌ>ˆ`ÓÐ>øèäxW7’Y±×­öPqÙ®b�ìµ'=öÜ[4B• ?¤|–) ¿vŒŠªÒƒZq!;t Ƴ^9܉¢ý¶ƒŠ†Ñ<Êp+R}‰y¨?&ïJóéÔ¨j) |ØÐrÛ(]ç†P§œ¡ÂÑ€F½Îì€Y^éÎì!JÍŒg«/Š{å»ò"bÖáþûR´”DqÍ@ Æú,ÖÆ/ #£Ñ¡U†Qd¹§Ø‘&Nm,DûýŒ€WM O+Ímc=ò €�D8îOÊj JˆýØÒí¶Õnœ+^Ü_ÜÁð{]ÝÈæKo¤¡}žt MÁE/Òþ¦m½ h€Þ¹Í‚ÒÒºà×8Öv†ú…„»LX JÇŽîNd…Ó«¤^ºÂC\(®_pžéAûôö¨Ä/¡§l¹èæ «&kÐñášIÊãR†"-K)=±¢qÂBN€uqí·UZK¹>(<þuÌᾄÎð!á óÐŒyIb:¢tÍñ‹Ï綫û@8ï&B”KQæ‚â)ÌÇ…lÐxjšN)áOÝ©î¸|äôýs*¾è`…kAªS úìZ]hÑõè•—¡ÕÌå½v›0sÓôì"Y.–›ÝÈ Ë[R+Ž·‰›Ž×©b–›à H–˜~å_Ó3ÚŽÅñxs óg5ù£Û±æ‘T$„ã·1;Bé…–eYUÕàf7ðÁ³÷‘I¼î©l›š™ñ“œ>@°îµ#“¦R „†ÊEÀKCäž|Ãvñ*àÉe²é°¡0—¬­Ëbøj‹´Ý¼™¨ïΗ»ö¹ÎðWõqªy¢µb Xí.ý ‰´ˆøBÂ’±©ˆ q—¹ƒFBÓº½¿Àt ®Diµ½g¯� Ø.Ó¶šGõ"}Yx±È|1 ÍöEÔñÙ•Ýã8À½Š*¨=çq8nŒc¯IëìÅó¤ÏupKD}„­Zçp»¤ yÐ+¹M&ÿ2’äßž ³ç;Qúþ¹e°é‹ :)°Ôʽ¿k¼¡¢{Vt¿‡•BÓfJˆqÓn;•¥'˜À Uˆ¥ïÖ‘-Q…ZFhÌÙû{ ­¤ôU)((Ïcî)hŘ‘ŽÝ†î€‰ŸGà‡#'9þ5ç{«[hû«Ê Â[ØÕTïv^‰Ù µŠ§„Þ×êt¤•õ}÷ó:XP©L¶Kkó¦ÜuS J /†­Îï_‹¾¶'ÍZfM˜.ï41ÎR‡ªŠq \ô%›¾}!Ö „ICê­Å»mð‡âu‚¾UÒýhÎt<q®æ´¤àÀÄÆÚÔ^}w‹2K²ÅH¼‘)®¨Q—% 9CdùšñÓxÃ]ÿ!~ÒE ‡¡ñboª‚n~káÂr܈ƒ6`aíofN¯©Îu,c,6v×[îHé]â± >òY¦çþwJa‘ß±ü¿±*2§± Mþ3é§5”-WàÀy5-$[Y~ô‰Ûµÿ¬C>Å Dšn´ ƒ.ø¹ªˆC°oÖýõçI!Ò;hÚŸé­'MØŠäíß·"“0šñÀëºÓýf*òÄÞXq0Ì‚-åΕÑ< ^í“bé NmæÜ]|óxš™zBú,ˆÐ×tŠõÚ+.RʤßþI¶¥‚…e`)ïDÖÜ=êCÇqâ4Td€Þ‘Õ/̵�Fëîõ8Ê‹ËGš¤ZÐLÙî–jÇ⤒¹(ɸ7a~Áj¬ªßyN1K…C«’ÃÛXIÖé»_Ó2:µ€ó*žèw= ÓÌ„¥°´9Q^»Õ=ÍI?€ô�S!r•fð®ìA«±Rä‘Yu´ƒãy4‹E¤Í½(ÁwæØÍÛç¶ù!-WJ÷E|çhsÃ>On¸Ê^}Qz'Z€(ß<ík{¸rgnÞ^FWþÕ<õì ÊãHŒYsZ³äÜByfõ~Ì©ÝÅÏ*þV°0EÛÈÙÞîÖ\„[:èš(¼¸IãTÕ¾RՃ€scs·šÇÇ^ú–ù}<õÌTïE,»¥z”&Mª8>¾;m4Èniôü[3²2óåœ VXO†os¯¸cG©S=¸áï ðÙ¼Z`Ó`ÿ‘ÒÊÎv–_:1X£¸Ñ™VÃý×ÛyunR‘ÕWEɳp>²9Iצ\H¤ÑäÁëL]µ©ŠrQNç2MËÚµ'Ê…ò7ìèìåZœ,ÕòàÔt”è燛ùþÔ7è‚»ã]"£ñïY|óŒ•F ?2:Úw0;‹jU¶=_jK§NÇ#÷5&S`ëžãDÐî¦É¸A ËQ±¬®0÷{éÙž@í³ÒNH³jƒå7aã¿Ï¢äZãgsŠ€={8P ³íSRœw%áÚ0 ¯b·U|.b•é¹ÓÃ9É)C’MÇï0÷¾LÝzUOìÇÚ{MT~e[Ë×aœêÌžûî<¢›¨³àŽílú§Ì}ñ¯èi¨©–V/ÜGÔ­“Åæ°õúë ‘ÌìºKû4HkÏ^M5£sNŸÇ¯ˆØt™Ïþ.^9)ŽJçÝCÎZÊNr­³Ë gîS}¡g¡"Ûzšè¾MÍÍ#_>cÏÔ eøuãj”#Q9€\ä¼2£’È&F¬™öGE™}líx©£?WÆÀ];Ôý‹ñVœQ•)ÏRÓ¹ Òa´v¬ÑïÈÚ E`é&Sˆÿ<uP‰´È0×פ·—~þ=Ù]gûÌ)帡PÙXìißì0Í54j }ÑÔÇÂ2]4* ¸¤a«,R!× Â‡Ã–Á"wûæ`çüí#®y¡Ð/4ç)V t‡ªÍäàen¡–0•SážßÑ+bÇÚ£­áµïwmõB‡$ر6™ðxØت;³Xêõ+‰¡oðI1äcÆŒ×v³¢fË>Y´£6Š¿g#PèñÇÊí |û÷Ù×ðYtÜ ƒu#)«%ˆÿ]²ŠãÌjôð„^1z‡ŠxáE£Ø!èýø››áAžØ¡0Zï,ÞFÏýtñJ/ãÔ ¸o»§áûâ.IpO5Y£<‰E’ÞÌõ,5û_¡|’|#çž0úœ½ÝÞ½ÔçÜ…w똢¯LºÌIx<\#"jtyµ'Ì”«ïn£Ðƒ¡ÀÆx'9öžï‚k Jª<()ýày <Å8BÞ¬‡z¶Eâ¼:î>LÑu‹³Z,¦eæ«)a”6ôŽê †ñÿöÐ7šl·Ðnf[ÌÅõÃn¡í G©!O¾é~¤{þ‚00J$ÖBDÛ›è±p…A˯ÝÎSMí|Úh’š]㘻Üó5.Ã,X_äØv¼/v•‘ƒíuè( c»ø º§L)yßê’w¡õþ^1öØ /üe±âW©“ßë2ˆ¬j¢A<?ûf4­¢$}§…÷wbGß\ù„3éóZñ¤Y`dfÝ çe"}‡ T;,J"þxt ¦E¬j'’;Í—/ÚH,ÒOKh˜AÞÕ‹ë¿ðï¬\3œcZ0zÜçü0È–x§ØF8bÎíHÂ!ßEoÚ\«‡ã¡þžÇ*‹LÿÑCv=eJ`†›»Z„�«C$öüÂÞ¬{ž>ÿÿXû³íF™¥[�½æ ß›µÎ o.A ÆF *Y5Îû?lj‘‘™È’,×ÚcÿÛ®õÉ2dFF3^€Ïèê‘Ñ­U\%€ÿÛ,û”Ñ€n§ÿ½^–gàûÜÐ9�A™²(t-+Ô w åÚw"Ö¾N»ò¥>HÑ{‚pˆž@Ù=1&JµYHA^ºzVqj;‚ôlEDØí¼|ôõ×uÜ.WI„²â%ƒá8õ‘Ðp¶(hcì¯Ú>9Y”V}xEe|‘Øh‡úŠ{Øl“,ȯ>§ˆ¢åÛa[G±kŸ å¬L˜Kf̳û•µ’ŽMj!þcŠ~­7æ<Fy³€8Œ[d•TŠ1JÌ„hØÑ›b’©^}&1ÖÎe@\~ „SF>ÿ7Æ°�Ÿ=—Fžl¹’ É<ÉÈ/’b1o§Ô®Ü^L— ¾›q¸î¬š§�£h›s•<2íš¿Þ3i/<&k8îO´•§½†ÛzšŒr ¿ƒÐ“0/ý`vj÷ØÝguƲ`„QåòIïõ†ŠQ±ûû© W¾ÖPª„PQž:—¬õ5OÎ áN D~î@¼Î¦HŠÌ“le(&ŒãÞÝAÞµ—ƒÂÀjùËï\ؾìÚCEKEq~ïÉo`×JONîöš1ðH²<ñ§óû5nsdw)ƒØ؈ÂF=¿‰xÎïZ¾+*=Ó7/-­Æ¢QI®§Æ3¥«6q¡m{ì–i<=ö’›õd}:ÑB”yÑl(Šõ‘$GIO>â÷Á³9<'ùð/,šÜ =RfôIõ§!¢Ê°)ÃÓZáÊú½uÑûæÎî–­6— ³×ÄÔ^T…¥½LûÌ^RÝs{3»Xâs#y•}Í9[žÝù¥›D”æ¾X4Eøžö]¹·`�Ê•ÿœ{Ê 5Oþáë'Êâ1Ö ÀÖž'ôrl\˜˜°Ã‡§ÈMéüðŽæJe?rl8Ó ý¤).Là0V�Ä[3Ž¬¸ÒwÜh>äØwêGâZ‹± ¡õKÛ N£<Ö>¨.º:)ß ßæ©?=Œ²˜Ñ12ø9'íÉIG”¸»Ý¯´cK¯ÜÌÙÑ„*³ìÜxÒì€Ø²Lï? šF¥u‹-‚ný bÛ­:ÀJïP÷¼¬ÿC…DŠr"Ž­À ¿é*ûzb bËBÉÆ…CTç¿ž50&M·ñ€¿RòtSûP]2/tó£öd©öLþ¦%ºíz¯cóBÛ-Ë$I݈¢S!Âó¤”Ã̸NíÜdè`ÌÈï]™“Æbççwêl¶SІ–ükØ~Á7e¼PþÄ 8áîŒ#Nž±3šÔƒ‚‰#Ïõ-к!UC5ƒ1bánÔ(„$Ɉ5éRüà:n¹)Æh¬ig‡–·‘²OP`¤ý‹ï¸ôŒ3—ZÒÃmùþ|ž=Š צá)”-ÅFa¿@ý[}†à#z8ñ®o&Ÿ_gô¸\_ç*ˆ»ÉËÁ™Zÿa»xí?ÙµçVî1T �mëöìz”˜ýpôó>ËckC!êq›?PxŸíh®‚…÷4«$ÙtÞÑ轙ƥ+—~jÚZÑ´è8îÏ®ìÁ÷/‹ã*õ—ýžó™ÔbÓ™ÎX•/èÏØÞƳD<M¬<€ú™¶Vi) _æ¾–Rì¡5s*óô½â¢2ª�;¯É»eãMõ°%‹Û×— ŽkLŽ¢à’™Ÿ…¦‹tå>X *ét¼¸áHo©Æ¨AmÇî^}/†23^9Œ_ê4¨>{ç÷}Ût¬0Ë…!²þ] 5* œ<²ºy5ffNªB«6µûI°œ;Ü/‹/¾íÒþC×Öù ¦¹>\èPx×AÙ†ï6¢èÞÒªs à“Rh«îͦ>BËæ1-×¥ZmâûqÄm·×a`ƒÒËá&¦åo‹í„ý‰mÚ+Æ25èì• ,£û/W6„ù¦ÿ]ÞVéBW sÌw¨˜t*&&¸Í¬'ÂeÍÄÌѱuÄb B±ÉÃç< ª]­zîl´WŒ±•nÖŽògÃ@râóÏÌör0Ìòyû3-¦¤V VÎL*žÅÂLºàÐÌ;X­4ýî_¦'Q;x ›æÑ.U]a”e¶Ö‡5=Ì÷ñºé^SÉ+‡ˆŠY‹ÂAV½ÐÆnŠ6Ût] ¯+³ÌîŠïe(ƒÊR$# ðÁKøH æ®ÇñÅ%ÆêÉ>\ѱª?²Ì— ëv¤ƒ4k¬´’xàysøwbú°V»ÐïµëÍ–JVÜ.ý·2 2 Œ£W@—ÔKzZN1êÀÝn³Ÿ½ƒG6³É-ľè‹Ã‚‡¹;ªY�lèh›”û1cp °hK Çm•ƒß]!¾RÚüñ©¶ò/˱„Z*wŠ“føÓ^1Šq\«Ø½þ g7|§ñQLí œ|c~Å¿ÎÎx#_}—{ŠC—d´²Î®W·eY˃mFô‰ès�ƒ ÿ”›ïeÿ?œa9šCiÜBç.âÜÖè•—–ŸŽ2Ý&W¹þ3]É ð(ù23ÎE èß«ôîŒa2ÌšÎw¡‘ŸwÕµýILÀ3žå•<÷aîo‘y^HÖQ¦Ë¹Q÷ó _8b(À¨N#Z¿ bs²PIuQ†Ã¯¹t±g"!9QKisµ×VOQ}® (uÛ64hjZìßÛoyæOÝ1þ„šl¹·ô€’Ñfbxeb ä´k( Ü‘}*,kò2æÒ•A;Pîó~ñÄÂjÆêXT-}Åûº«;Ú&L‹eY`º“7:Ä3s˜TåìÖ~ÑøÖŽHâÂW|ÄGÑ}i¼®›N­ÿµê¶:à…©˜¼:§:PZêz̃Òý–¸ê›R2©|ÓA6kBÊCc*àù ¬ƒ,å™Ø‰‚"ên°“ù_]Õ,[‘gVÕ\««ÓŸ‹ ž/ž‰ÈïšøÑ™;Òœÿþ…ê#þ:Zësäî$6Î[3ü!wPKš³�<•rš¼Ú›‹½åË~sý@çHÜ*À)Ã_ÐÕÞèìX7}gr/ÿúI3ŽòÈ£ÞѯùX’ ùÔ“%kXýu¢ -¿‰â‘Q¹þåYh�2ß!¸¡·s˜s´;—AÖK ̤² '„­ž}ãH}¤\åÈçð7uì‡ .G›ÖªohÔxV't~§@t]‹¡ºaçuÞ³¯¿•?½á>{$Kç©BnÆÓé°QRç¾£ôšÉd»ƒU £ßŒøo^À£ŠEH²-Z½Ÿ{õ|Šy$;±èêoXxü´½áiAA‘òÎ|ðÇ »\¸û¾ãF¦|ý'€’ÏÂáühÚÑiX¾ÿ5ù׬w8¿)¹RüFéUW&N1O¬¦¦?¯Ø/žÍ¶Oâ’b™Æ‹Ary—œ ;+sßÔÜ«±Œ‹`ù¤„~¿xŽò@ÿ¡µïFS\c¯îè”%eæËySú3a=Ó{úgûn0†»lkKéÊ`j,ìB¹1úÃ{8ÃÌ…£2HkÏ#¼­!©ßS©ÿ\Œ6Ž«YCló')ƒ)£¨¬ðò^,làx8%ø/âÄ!õÃÏô'·çˆVm¡"‡6{*t‹/U”Θ—\/¶|šDm[_ïbÐÖ“^à6> ºÿji4ó툘=C†^õh/ã"N#ÓÈ0ÒÜláh'§t»kÌaÕÓcÜá¼Ñ DïÅŽçiI˜Uî4d¢¤Zòƒ(­œzJmë¿¢+û¢+j^­ K?)›­ã±éü¦oYQd>~533àÎ5Él$[ #ïlBXÌ3Œ`¬Ùr( TýH·Ù½¿Ï¿Ó•i-”öJéؤ~’Pi€.˜§ü-ìoÁœ°Íø·ñÄ£úÉ€u¾ }ÚµfSÑÿÑiOo¡¸U!Æ9•©Œ*(¯N "Ü`?…… j· ‡2ˆOzwNtˆÙúC¤›a�„(XaP…~ X-«ØI©’#“²B"z‡êŽ)ƒµ¶»cÃZòüÂóʹYkC íçòïâ ©è± Î6+²F¡–s®)ûÎþ,ðØ=FþŠœå* ¢¶‡‚'=«í!R]Ï\›8ÇŽ>ˆâÈ—½£d…e€>µ3ãÆ ü Øö—"@EîšÄÒí¤?¡˜ÔcG4wÅçA˜éÉZ?2s‘•ý˜©J¦»;¯õܱ‰Yy“Y‡¿Ð“üKõ趴ÃN³dFîñÄÚ4žƒ1}XfêÍ!Ùˆƒ[ÕkìI×Z,2ÂfÈá«Ž–6.31Žƒó<'í ÄÞ\O\b{êfCjÛm°tzoÞwÞåOK‹õŒTJj¢ºÄ‚«Ù) ÇŽ“ç~ÿ §G¯'k¢òíhºÍw4À“µŒJ"Þ^Eÿé1ÓA*{ÛÖ‘r¥³ŠŸî¯œ½lº$΀zQÆWÕÚ¹Àéõm‡Zˆ"e¶"Ï°D5×,£äx]-NÕì+ o&:ÇÓ³ïQ„O‹n‘íŽô#›jnï UÌÀEŒÖ®Iä_%G˜Ç#‹¼¦-¹¥%·£(;´Ö|âLÈ ü†jÇR€ž÷4àíoHLp™:µ/ìH5Ví¦h¿¹‰Ê•(=!ʵºªK#þÇ#ïf\Ä‹ü3.Ž´Â.Œ‘aß奭' ±tx‡H x<}`Š)´PYsÛp¹¿½–†»£w»zçËÊÚ]´J) cAµí9u<EqŠˆ¯@Èãì_9ö¨Å,E=e—p-U$$.#rv Få=¹¾ýªÌ³GFlGù�Þ\Þ½3£#(j¥ÆU¤Þå+l¹Òº¦¬h©`mζÝ) …öÛZÑÿÂ>Î|ž"ý9Ü©pj D((§² 8ÿK«¢È}5J"š>ŠZÕ³3N;y¥)sœ +Zbúr¿gP1¥ŸšÒÒ­acBûCàm”X4‹“NtXU7ð÷DÆT:àM/!B8 L*É:éMúÿ ãÿo\üç “.úˆ'ŠF²^I¸"¯­+úqþYPî{O[c¦‡‹ë?Ç—Yi1M 2:1š‘¶b>µpâdÐÔõ3+[,ÎÝ]®Qi…'6U°ýøœG¥Rš~¶Ÿd¿ÁIµ‘…|I2 =+PI"à^´*Ý ½1VÑÞT—kgdŒéT?#s‡×xý +ˆ²Ò¡9^pÖïÿz-6mãø«ÕñØœgúž§Ñ¡<ØQT%+3C‘.›ÎG6F}DîÜwéè;êe…ç«Ìoz‚æmØÛ ƒñ;ö" í$ªƒ�£!,àŸ[–šèˆBƒQ›ëœ1²wØ_ç7:™©ÚÞ¡èæŠvxzpÚ¥èm†$(ÞuÌZ¦¬ÝVÎ/ýùòZ¾€Ôš9ÊÍ Óf÷éɹnúk+§¥×‚‡`¦yŠÚ@•2€7¸Õa~ÁÍ 64à^ ¼)ùŽÜE–ùPôõ@[¿Câ ÔÚ©>Y\<oDëÊF÷žáÏwÜÚªÔÊBh½Å½¨Þµ¢Ê Û£ þ¸÷ƒi·„/uË7`Q5ÒGÕ[ÞÂ3'��âaС#ætסuÀB:M8Ïþ)C=+2ASÔ_£ZÊ‘XïÐ¥š%‘D+í't‘Ž:oÝjÏ^AͨºÈ\Â]n^´¡‡…IgcSÂ?À³íOΑ=`è¦Ï“BæjÕY!þÄèþƒÝ§ßñ¯Ê|Ðq¡”ÞÞèT;‰ëïkt^ËÐÃHƒ hjOÞ\ÑðøýKs¾*rϪ †÷nýžèÁö°üÝŸ™¼#Çн.ü“~|æ)ü& HŸ±Î§­#à£Ñ8yÖ£Ú{{½GwãyF‹»™üÛë0 +œ-çÄ%–žÔ,$ó›þ«:«¢Vf"Å¡bPÁKä{´ëŒäFe\ ¾bˆ§¥o-Héúž]’ßµßS*ñŽí ]µúæä ݾ؟ƒÃKvM¶eÎðJÿiS¨”Ôå ~Ñÿ¬Cž$ÖƒåGÛ$z®?(ÒžÝ~D (}ú—Ö_šy¤…Ü‹•´4öVX‰nÓt:hjø/3*½/bzbOaM9ÎÙ Xú²”n)êó>^Eɺ¨üóý³fj1g,ôºx¥ÅWºÞ—v¢Uh>ë—ï3”h%[|OÁ—3ºÈ°ü—=Òö÷ðÏeA¶ý¢·¿ª ùTb#gë lu‹ÇÁ¹92_.d~¶çð~‡ ÈögxœY7tH^áC¯üJY¨Ô$Hÿ(S­Û<)Ý)'ûT<†µÙ6žG202j¢z1Üò©¤§ñ}œÄ.Ô¥zTŸ'¯vßt7Ö^i=MGüµC!ò¥AØ@òoƒðrQ1Ä0Ði•k—Š¯¿ÙÃ^`´ä¤�}™S–vRL¼%Fçyùƒ×7±†}]2²ÑÔPy!ÂàLU|s PÚÝÌ'}•LâN¼2>¦H¾i(2wè}iŸ7ÕDÀðD«Un7³"ËÐÁÆn<©�üW£ÕA¨`U+Ä”à¢8³Â*B ·ï)%Ù^M"+ì#…×E¾¯6 ±ìf¶4ä?!,…p’(Ù{¶§©o“!0®‰~ÛV› –m ¿8WéÅ™_™Kf4ÐTcá¡ÖB$¶w2©ãð¦¡|£´%$f¢æ¶k³µ?ð·ÏËÍüsC{^ZÒùI±ú¨¨ûžÉ%íákQ p~4TWßÍØò–q|˜:£ônM€ã[ª¦­­˜°=7ñWcq1MôÎñN?n³TÙ îcf‰Ñoh¾%Ó¡inI{qµ6’]‰úù®…@fõÓ­ªñ,ùR/1a¯i ‰µèVG¦ówt]7¡#À-<è°£À?s«ÿžK@Re™Ss§;t¡`RÖ³§£M¿‚*Qô¶‡Eí-ÿ½Ø²˜s<›¹MÉOTÌè¤ 4 ßëÍÇŒQ‘ç6¡>ž‚ÌáQlÑÙ;ƒŽ(\­kÊÐ'ËBì\°éõààê—ŒTgÎLo¡aß~`ÀšOÇqî*A^³m—ÑÑÞ:,"mñ“]³”ôŸX0šáJ†û¸ªZÓ<¶O\öåT%»5&J:3 3@)ÉcãÝôK¿€ØÇ;²·ó³ÆFH©.À\to丧/÷ç»°p¯ÎÒÈðOc;½Ë¡b>ÑßÁ¿%:½Î@“UˆE >Üßy«ŒÕßýð:øAÉБòÓéóq¯rªI|£(ÎTbùî¿¥F+Ù­uz„­õ±/$_ ³¶Áù©Ð1%ÃuE^_{2räÃÄ7öÊY–pˆÃÙMA?†Ñ1„%_@KÔ»únþS…~×â y¤V’éÌès™Dê+mJú­Ä]Ý«¬3#ĜӑáEìsl¬Î*QšX:G˜~NóÏãpMêD³2nôic�A9ø²¿Î‹ø_/~°µðÏŠ «iûÄlù—…øŽ«Œñ´aë G+^Ó∭RØŠ¥ßzœ Ãz3ÿ= ÿµÈê;?z‚ºŽµ6¤-Ð9‚j© r±™ÄN—×'nkñj(g*LûƒÆ’µmóꛄÜG¯�O0…AiÙznj©lVÔëúCá­ÝÈ>ò,e•â& Ï4Ý âû«cæež‚FìÛ2‘—´:JÍ)u1-zÂ3÷h-®û`€R$VC™<@.µÊPBŠ/Üîõ´M(}áÚ‘cN¼Ð j[39àÆuî§Zz¯Ëš¥ –™/=P[q£¸$vÖ¨Yì“Õçý©Ò#iìÑ2AÃÁ�çsçÙ4uó‡´Ùe£ñ´~øïL‡ôôß#Ri£2uŠŽìÎ6í) åÖ›%e¿©óÈ©¾°fŒy½QÓÌVÚ}æšE¯Âu™xŽ|+µUæ.8“~®«™V«Ó®Í¢½ yUØI§¾Æx1Ì’›Úãq b1"déRÙ:+¼ýÇã°Œ‰Z†¿Z~±r¬Ïwh /3tRz‡ Úôõušêô¢£u†¾ˆ4…‚åIÛA‘Ì€Œ°~pŒ˜N\]ø+%(Ãõصžddš{*K ÀŸŽy~jæ^•ŒJ<2zìÖþR©Ê¾­<³·š1×› ãlav•Å\£aèäZ¦îÒù_¥¹K·ý¹y›“,­È¼SUêFYãf¬ì¶â•r)ßaÉ#=uoÓ™^,n‡UÐ^6Å:ò€ÜöŸvùaù3#Ã_ŸÑ<~„ºÓT#G«®R7&¶ ¼eN<˜çÛî[¢P™Grª]-Z­”N²4ÂŒ’z}½00^(.¥v]2¢åõèÖsòƒ¥ì¾;ߘÈbÊ,ÛÈÛÔí¥ÎÚQ<ñ¥ðˆÒÒ>¦º&gŽ›YfacHnhJˆnÓõEŸ7¡ïô"\|*š÷Zp¬Šæ}ý·ë ¯»¥‘I"?WÌÖ@š…‘N[ë ‚ƒ…n9Ô¶ÆÅÄçÕTñå £k.„F‚·Ç”§œ4ì•|¾ šO¯x­ªƒDçʬ‡�î4,KT6?ªƒùÚÿqƒi†¹²ÂÑ©^ó”)†þú‚ðÔ„ùt{õNML@7(íŒ/ÂåJ[“aüß°b±g™˜q€¥³†wUófwŒv…Iá gý»ˆ–3ÈØ-M„k£Ä…¼£+§×±¥K•S7´‡ÓŠ‘e¾–,-ÓeHª YTB‰ jG5©çÀ84lƒ/¬Z•Ê»Ûì*VXfÊ­š¼ ¢Om±b°éÄ{–ßãÁ(âæÖc±ÀÜU,€{ê`†`yR¥ÕÑYhú¯‡n\æÌÓÜä‡gý6ÒçÉ\8†Û7Ь†aœE³>zEäÌ|‡8+ )èkãx×Ò´Ê®£"ô!ÙNÓí-N£l Sñ÷½÷Î0 d§‡ºÀoáþÖ?ÙŒgN«—ÛR šƒV¦Qh¸ô @›XjÇâ’ÀëšÒÿwœÓÛs—ösÓ ŒJÊ2XŠbçÙ²0 I‹õ˜#5ÈH¸‰w¦aE¼®d†"È'ðVxì‹Û�Œö]ý O4p˜W©ÙŠè€^Ôî<k‚ýØ_'ÛPùÅϳ*c™šK]°Ä»"•ÆKŸØtöÏ lûzÛÒŒ,Þ£0Ž\ÝWdÖ¿¡Åˆ{pÎÇG2c·éNמî«cˆõ¡½ñîIBωá0Aýæ}çÝ-†¿“w û2’Gî^+‡¦E=øØβø3ÓÖÐÞá«Ì§Ø³ZCûVÃt|X³(;oþà†O¯¾)­ ·1b^v¶_¼`yÄ4À%»ÿ)ÛyÍ&¦«;÷IPZ·¬°Ü$s¯z1Å^½`%> „ÖÍ@¡óÅL0J$šø5Uç/sìÅ3óªFÝ9›òIÒFHÿšf#í³gž´¸Èëgt.«Â™þ ÷H†ŽîýI½ùÊGàðx‡[šµ?~Ñ¿þO{k=˜Ý×cÄûO;øMÝOoÎTZrºšïsº¯ee‹‡4»ŽU«¹W}ÞѨƼb4Pjc€5­Ë꽫Û?h¥ÎÈÅ&àÅ ãA0 |.«Õ¿ XZæ7¢ÄôWDï'æé»™,äãöÈÙ°ðj©0&Fh6ÈÏ‹§%I™?Š{« P°X‡ß½´è´$Î|¯„Àsk« ¯$>6R¿ ù]zâ[,š3œ€gUŠ w)ƒn©À4ìJñtPÇJùbiË•™! Óºì«×§7–לa%Ìâ“÷ßõÝ þ,C¦õùJû 33Á<¸V3)gIâ’uqµò^è.BHˆ+€ÿ8±ÇœƒÄÊšÁ=W,¥»2ýÖ¶ ãŠ6¤ô·l'7�XÙ"4V†eèäОò“Œä£fD°Ó.è謕MÔ;- 5Î’¦4teZ¿Kíýà zÒ:&ãÛŸic•ýà‘#ꕼk Øþ;òųïR9ËvŸél¹ŠØV¤H xzüÚÝO²S3Œ5Çf ^P5ÇŒÈ鯗±žž“_Æ<wúÿýæ7ÛÍ¢iRƒ¯BªÇã.(GJ÷:@zÔc µ¶{† ¿¢¿ÃêÕPE|O?T\dZØ°²<–jQ±¸6Ìê~ZuxdFÌ:K5B¶Ýdíy˜Škª§ ÙÞ@×_~ä}‚øfie½ a¾=À¶6G*|aÁ‹®‘ ¼2J dèX:¨¨Úù<9}>#â”1Îr°S»ÿ@?,"'¯Í­Ç]O5A«­ªÂ#ær^›™”´"€äíì»—ž,²/úæÖ™l­7 Þ¬%rý™çºÞW_‡J{™}tÃûàæ¤DŸKïØõÜ"žöWLņËÕ|¥<!-é€q•g Âk£¬˜nÚþÔ½ÏÄrT?€XY¬Nÿk™W\ynõlTuAE\í«Ín¿‡±‚Ü ;Ì´ mj5áÏžÎ'U¸GCgô\€UìŽ5ûÌæÔ¼†¾‰s…áWà<b¢Øj×à¿gR´R¿ý÷6 ‘…ÃG÷ .^BŽV±+Ò¸K—•l8aNŒ¿èLÑôun¯£sä®îÏ<Š²î+#ßôXûß5,³äæ$8¦”ÇLz¤°­çΣ»´Óxíg [¼<ô¹kxáåk¨]é­û½Oÿ¡ò{Î¥y?Ñæ“–‘½äG_S"ñú~ÝÑPF~/Ž8¼V“u£Œñd¥àÔw³s){jôYq Ô<ëyʃb~÷TU< ··PýËôåÂÂ÷»£”šhåûÕB"!Í<¿ õýjx–Ç™¯1¿é ­ÒÚÒ CñÍîfsk4ÃïúÂyËT@Áç& ÒÉê E…'õçƒèÆ~q]ÝßmÞ”Yìs1r€èàê'¯§ åÛÅ—dC'L†ÁV‡M±1ÏD7È59—NR¯A ŸàÎ!g5*£ŠÉÏ´÷“4ÎV*$‡ýáuò4ÉÑl¹ì»®—#d·Æ”oBK½B<üð5³«ˆ!S$«!âã‘ó2öðò”hµ=?Ú n°„5='Zø%Ù»—Þ¦M[õ°K8 òZ�‡Íž}Ìcðnì?< W]F¦ñþ± µ¬M‡Œ%-* áeö0zý›6õzm\É6Tp•Îö,•±—âÓºA)K”ôñ÷/ò¢TÂ]Vs¿@6ëÔxæt+hƒŸ™¹í®zºÍ¦¦¸‰Þyâ=¤ŠÛ¶°ÕÚ¿áÔáœïÆÞLÝUPrxšê®½/iòš¢Í”E©–kÊ<ÈgÏ­ÓÉdèc«™ˆ2{W‹ÊÄý£¹—M´gô¼‘…j÷j˜Kéúû¹}ôWý$¯,ì5x…)\=4dK™I_Ï¿m¤iºêeÆÁ´£h¹Ý+6Ÿ5»ÙÍÃsfð«å¥Š¼+//{EG·[ÂÆËx Â-éo)PD�éñԌΠô»÷õ} Ü…1¶¾…6ûD-ž ÌŽ}íÛ %›`àhXÉÆ<þÆÜǹcÇFì3Ì€ÎtPNAÑ4šJÏ@œV9]Bb ^G’EÝyj·$6º]ô–r¢Úªs%<zÝî˜9CGHO*QAuÌ^ŠÏm=Tv=l3|?Ú»˜¸<ñ»^𕘳 oÏ9lËdl‰>Tïk~?nØÊi)6ø .3 CQ ò/f±a²M¯œñ†–¤s„y‡¯¯|¾!«î@­¢<u©]ÁÂ*”ìGí§GD;^¡žhyŽ¬ wßB¥¬Œjó)h;Šù1‹ÈF†p‚ÌävylƸNÊ`µî}çûZJ8ØÇLg’2KÄB™±Æ–›£ýÔ·h9i°äÿbT×M'šg»›mAÑ¥»87†õ liÊæšU™†åºéÏÃd´v^Â)ÖTTÉ.Ú‹ñ •É‚xíúI’¼ÜEÔ‡™çFEÛpK‰:ä?œÄA{æiÎ/k§³Y™š»¦,%Ûžý]ÝâÍv|…ii{šq¨ ™> ¡ñ\4“Ñ„H,­º™¹Øô£Pâ,ý¿=÷îŸ0iîf œ õgÊ…ö.*Ù^àx:î÷÷¦¶lÍ*B7”�œ&:ËÚãIcH.Þ†tHTr„Fàl´ùuýÔ¢d5“/ 2 æÈCˆ¿Á }cw3œÇÌLD½K›Ó=MŸªÄîTñ3Ž€ µ Ñ4C6)¿Œ¼—'û$Yå› ££ƒ²V±˜vO+)`Ð,’;C‡G}™ùrÄ¢Â1ãÕc«Ã˽p§y¯ÒÁ/ §•““HÕ|mðéÓ¬Ê,«yìG|]r½vëKÏ:ä ¶�o¿,Èmöfº�°Œà›pkªx˜Ø®¾*¨--BÏ4Œ>y[A>Ìó‰V’of ä½µàÁäúAÛÉô&eÚÊ¡Ê^·û_>5Ý¡Ý0ö‡Ú²çž†Ê\^ºÃ¢G(|¤;Õ(ÜÔÃ0êÌØvÐÊÙ×xHÌóþ<>q.Q$í2H?õìK34Ñåté=3‚û®swœ?Ý\]Ùñó€Ô}:1¬ù ˜…ÇÜ(Œä®6l”'™Wƒ„ ã‰:7†„MÏèÏ<Ì®¶°ÆÞ1•Ç¥aŽÞ†â"uØ~>Z{PE§Úg"´<¤7wúgPt\z–"¿`‰°xÞˆÓØÌÌ›nÎGÊQ Äñô£µõ2ÌYñ¬Í¾.fÑD‰Á¼ÛæÈ‹0rªÌä2"´Z)X’¦¬òòÓâ!ú¿ØëR#'wi™e'è"ÈC‘©†O7…Œö<­�÷Óûrc¡Z Aˆ’«½vo’@$Ü|‚6Œ…í,·ó2q¼²N ¬—jhëý£ëNóKÃ}éÚÖ|ü×"¢•¬àyMœ"å¥üê<{8_q>ôTÂc/fP`«‰“Þ"s½#‘5âƒÝ™Ï,zÉÅœÕo YÑ!„i •,í§×ö:.ÂÖ$I”Ƴ.¹•dûŽQŽÂÕ“îüþ ŽPۨ΢ö†£žâÙ¤¼A2Éüø߬lâ̯o(’¡ùø©&â $>‡êSȹqÌð,<þ¥3QÆ+öMFt2o‰_Á±w Ü^$¶ùž°"*7•Û.Óú§µGy£hÎó9½Œ"×íë…®ÈúóÄ&b_ôÐÒá¯Û3J ^Ó_"¹=Ÿø}–6Sä¼ só¨ÿ4r÷Ì›¼0£˜^'bÄHøW'çv¼d¬R:ŠË nöMEìÌì$Ë^×Ö‡A¸Å<áDÊ”ôVÎÀŽö=S^ºMGÃÚ… ÝÑú'ñøØ“E`\Ï<‡Añ®V'iñ̓ËŠÑš ­å5NØ£ï}J³åhÿŸàu]XµŒþ®~ë+—XÅI”ê-}źÐW¿¡*i%VZEp¤ÿŸn3Ê¡€Ž”Ñ< )¦²-žÂ“,0 4 ŒÓ“"àº3&IšóEh䬹Ë*øÜœ™—§ããgxpën&Úµ,É Ù?‹Ù�àÇ7Îêv¬Íˆ&‚paÄnH_Y÷Ô·‡@7…²šÓÉòì6•ù9’îed’:°Új‡™•“— Ïø‡VªSíj¥!XÂk '¯—d>E»f)OUŠ—%'žÚƤ?X×Ós ^îù_…8ÁÊsóëÕ“¹¬§Ý†kÚÁ\€Û3O¡ÄFP© %[çQaèKœRƒ<È?{Û=ª âÕÝgŽo<â”làÎON]oì‘]DõDŸ$3kú}å¼[© ‡-ÝÖéŸÞxzÅã2Õ—æÊéÍδëWKïÎ|K/ÁáWèBÒêY®.‹ÿèDbÚ< í>éAÆʱÅZÛkÆŒ ;ÀÎáåhÖ nzT"P?¹÷£éÌ“hf~jª¢¼vAÐh`Á‚ÛçÅSZ†> ØX¨ÖTÛY þœ}hY¯þÆ£T@ÐXVßk2sGp®¤£Ó|qýñ~•%¢‰øÓJÄ69En f(qXxV’¥Õ"*ˆæ³ÒÉ¡I¸“»zFO}457óö,jð÷ÝŒ 2ÛÕóÞÕŸ'!Ñ[Úü úÔësRΑ2ß»¾mbx›úXÆÈ<r´a†˜Ï)@ q‚)Õ'h.ítŠ–£))‡pòíj ÀvM_ŠüƒÔŠŸëKc‹}™ø}T‰ÉõP¬ô ©é]g¥SbšŠ"‡î'¶Ó40-9œz·W–ˆžù³Šm @çÓâi32T¥)Çqù-ó9^#{b¨÷QDµŽYØTpÌòd nÕûdeÞ¦u÷JOßóh`ܹÎiѶµ'Xzà`±Jk„ç 6ó780÷èÔ‡-ï»þCz 3Ek¢WwÒF7ðVõarò±·Ãù»CúÕüÍȇAÖwNüX±—¨¤¾~‘n?ÇRÞ÷~È}Gë‚ ’ ­,Ù{Ó QV¿e€/Ó%~iªb)„¹„íJ;ßJÉÈ‘šºDÓª¯ßæ°f¢–MA%ïöâIË!½oÓöß _Ëع=²)Æ:¨4ð ZH²„Qò¥>óÛ˜a&6¡¥š6oÍØ˶vÇ˯kô…¯¢¥âSÌ£»‹%í x=Ž]ïls¾_øŽ©Q!†¾C¾SÉ ûQüFEô°¦ ½MæÿaPåÙC"zdÁ±Kƒ¬¶–~¥ACºI>ƒ9Ìë­cXžfžÖ,€)3˜-¨mL€7=p=ó¿rØ|«N´!iA¼Þ®þºfe› ýÏZŽQ‘ø'(D ö…ÒÙÊÞ�²=pk]Ó»Í!ÖÐ×<cËÿ¼ùÿb¬O ~åÃ^ï^‰VÆÝÜÒ˜àêùç°YFÔô ›}ÑàÜúDÆ¥I Š”DCñ`7hŸã·j³I’ù<ÀßÊ üÔ…žròÐP,ü•§\œ¤vÿ;cî(qµ2vej;85}±Ê^Ÿd˜©'./ @6¾ü:{>Žð¸½º\ðךJQä«ÓRºl¼l‹1‰='»-Œ$¡C=6×Ic˜I±œÁ’çÉ5©·´ 7¥]ÝÃHÞAKf¹+?Ÿ ½á NqkwÀ˜¼A»ñ—Bø`‚êžÒ¾2ßg%9^]Û›>t—#Gº|àșߊaÏ%y–ÃAí›z¢ÄÕN¥ïb<¿ñ¤ŠÒu²ýô»­A¥þH¿d,–ef›ÄæìÏá…LoéhÂhÎÜgÏñšQ‡•ÐŒŒ˜h;�ÙÞ5.Kíú#ÿ·MÍ1šMòD¼òÞ^­—}}F"w­ôIÇTUÊò”K DW}gl±n_ïtmWr¯”_dzڣnÎÓ_UFèåf~b†(¾nlÅç$ìÓ÷*Í‘¦ÚÑÔóØè£ô¡Ó“qh¹Oï µ,â,¯wp§”>ôa^ôŸlE(w:óû™¹;U†Ìâ¥ÝÀfõü‹L\ÆÎÜjfEn%‰$­×å³bSÜH3²Ã&ÎŒÍÔf\ ÝvÇC2/½‘“YR7¶æ/0<äÚÜðÓ5r¨hLà›zž;ª;/w>rb ðr§|R*¦ê:Eˆ¹>¸?ì<.Š§Žž2KSÐD?º…¿Užq žº*ˆ·­SxÙìÙ´ÔGÏjçÅ%NÂÌW.a'Oo:{i½× H`s€ùÛWß`61Ð9L‡uç y9 gž“= ÿêmÝfª ü÷©»{öÕ–+áôëýïSã*˜íY¬²¥¸¿¿{¢8ñ›ªÐÁƒ¯_ûåDX!ð2¨ ¯ðÃäÜS¸[©ÙØÍ·wêâ,Ë|[®T´TS;°I¹åIEù6m™}È`›EU­P÷ÅáByRoÅ™ØcqcŽ3öŸè°Qê•r Ë P]]_]eÚt"5mvwÎN×ØMŒnË2Ðê¶Pæ €ìœæá8¨/í÷+Ž*Çš†?–^¬ŒÙ[¡£Èn“ %¯Ïs:AÁ<ô^�P÷¾{Ȧpm^§AJùX<+Î,á À0[îžòZä·Fv ņâø± êw¨op¾NãUñ@Iˆ ¹¸#·%€>™x�ðJpêcd«zœÈ» ¿ùQœ:Àu—R½¶S‚;S1.ñ5vÀ;ÕJ¨À¸j[³¬ŸgáÂ2Û¢¹ý3É$*VM3aõ˜UmµuUµ*ÈÚLêÔáVÀ`ƒTèúfð/ëﬗô5äPêw×bBÇOƆfÊ,)(DnQAºòÂO6g<óÚgþD¼jQJötÌ'=²Ø+º²:×yhâ‚‹v}¤�Ûž)~êþ­ƒñ/bÆyØ€ïû“Š …Z¥ÜèIX“Õ­úÞ¤£¿`Õxt”‚kñ!Ƀtÿé5pL–ÌðpNÝfQ@9çæê÷fïärߎÖ`æË ÒyA;0&+u›¢¹Èƒ³ª†W³–))P}o«L¯ZÙœ¶!Vø5ª"cä'•ÿ/}CçyŠÓÏ´zÊÆýÅÞÙ3 múº¨à¾<ïö¨±z˜@âŒAo5µ6Dâ;Ù)Ñk<EK)go(ZLKÉðåU©´WjŠ·”ìÇxÑ-ãÔZ¥xój<ͽ;a…B…‹PJ…>lC1ýÊüNslüDͽÇÒõ„ Å™j`LŸ´A3‡rg•}¡§Ç}^yyLOÍÂï8Ó$ÈÚ½%wOõaîXqƒƒÂEFkºÝ_ƒœ&±‡;OØʨK¹²‰µjCªÑ«©¡Íßå,zÐ`ËJ+ "4^hÒ…ÖN$æn×̜ߚ‰f…åó‹›Ó\Rf¥Ðq$ ¬Î<`X@Cëô‚;=žždên½Gª¤D½MÙ<ØGôà±aÑ¥/¨½¾vR¤4ÇÉ5ª.‡#2ßYŽqè¹ñþaO¨ÐZ¹TFéòÇÁÒ^^2†²$_QÞ£0r8Á™¹÷™.{´s¬\ƒ8€‘šCròÉÏk—ù¾q ¯•ÆåÇÐ5^vWõžôIé3B†6çôá¯Î„ÒÈ„µ íÕôâý.U fCЪ ®Ö\1^ÿº0¶´Ç…#w¹N79yW¾= áñc©w%`z”‰Í‚“úäñÅ^pL¸rž€ª9 ®HÚ�0>(^d·cjf¶H�NZ1„<E.kahí®n6ÒŽ¨Ñ[þÕ½>ƒwy©ãã8Ïšø ;Ì\Èž ël„Þ×é$¬Ècõr2GÂèK¸Ÿí[^O×däW >E£Q¯Êõ[„Bh@mMïzšœ¢în„FÏζ6Ôi{aê”8ÎL +_lþT1æ‡F»ý�g“`¾ ç#§¤‡=¡Z.¬p,ÍËRãVšW­ìžþ±SËÈ'MŸyÃPˆ0 ×Ö*Eラ®ÂKf°™3r0ŠþIöÚ<§„ìóôŸ·„n•ãePªÖVmG¯¯¿È1e¹;Õ•‚–w§¡�ØwZ(b2#õ•ØNã‘;õëï*MFI‘y&Ap¾¨Ù‡wÕ yþºÌˆuŠ°Ý?¶ÛµãÆu™)¸sYkf˜¡9]·WE4:¤?u+s«WÑ„ý‰Šs‹HùCJFîê mL3jõ¿1N ”ºÌwäÊÌ;Œ)Hnjm< ü9XjNÈ6|é×OV·”míd‡/!«²b@Iÿ^a=`î¦zf9À» aj˜(W!ÿØ8gôìsõ®ÎpTo'½Ë{ªH˜&©¸ÍÞúæ´mÝ3JU†ii=Ôgµ?P´¹ä;¢Ýb&îÑz¡Œ–¬èE V¾Fÿ—ÅVÙÓ !!ó^l•ä„þý¹mÖyé0Ðh®îâá°[×taˆÛkÌ’6Ž*ÿ-×ßÖZûeöž%ÔCR4ŠÒ ¢’Ù:»,xweÆü¬M!¹·ßkصÅÓèÜßüWbÓz¸<vbüÏÐ èo‹1#ÿš-ÊmÚ¡õ•[܆žõòÓ®œ!è<õI|nM­Ð0îè—ë;¿ŸO£häê 6ca¡˜¨±îiîEº­®ÏûÓ“ðØ_(áRù¢Cu6ÆCSÑøgJâ_‹ÓŽ­ƒr ÈbŸÇC§ Šir.2HŬrtMnX?íåDn•hnL;&¡vDûæÒC5½§Ún`)U–"´T1î¥FÁ„ö×·àÁê>. _“’ì Þ+˜•Â¼t˜þyæCC_]fmËEƒ”+ƒª|{o*…qZÓm\d´ÓKƒÎ`,ÌÞJáɈ•tpEKÌ QÁtêXùÛJÏtÊco8±uðåÅðå$Y-ó=°úÃ÷uˆãÔ™ ‰Mû~Šƒü¤kmF3ô… Ð&}Û]TŸ—‚z=t«’¢[ùP…‰;÷YDvó')‚ê«÷P¦ÂÇ4]4Ê0¢qNK„b™7²œ·û™þ䆞‘/ø‚æTRzóåëæ_‰KæN€ÑN®¶e&k`^‚&®UÈäÛ£¡j‘{–@{»ìëiKÙRì%K9¤ké}üAÏ/ö(Yi†‡°g¤_í¿<‡¸¾«£(XgQJÓWKŠÜ×ów<Mšy*ž—63D`­»PÈ+}rÈW}ªè ̼Žq‚$“0è βb½‡3çVäGôVYWÿI6f¥ú9v±ot —Õ‹×_8ÖgDÀ!BK—=æt¨¥ãgÖi6A·Uºç›KΊĊº4˜V â@OÄz: n¡{Óx­{_£,¼Z†U+¦•e£Ìpèêy.Vœ ÞG˜¹ñ¡Ô\²æ•JÚ†cPºx+AE_èžE~›r¿´Uat;Ŧju5Èø@2›^¬maªÌ÷Z¤uÞ÷tÃ}½2ÃLŸÚ#ÒNbêê]í.סk[û •Õ^ ‰i¹TAú®twæß ,šajPb¨„/r #K[ÌŒ##íO;«,áJz†»ˆ-¼Á1¦ ‰ü¿Àï“8^©Ûet<Ñ–Ù·¶ÙÍ——³&þG7ï`x{ŠÝ鏗£³\«ÝÎŽ mfÄóDãò°Hkë›Õà`s+(¾_P<èô¢­pŠ`Ú šb "d9ímûˆ}LìŸ4=­qºö3‡F×{;êD²gæÈ‹ëàs6%9¥7%§ç~¡M·>y}0‘L©fBÏ>W¢ƒú„©]à>W+IªuºÂ—5Ê-J1œvËôUŒeÊG‘ÛŠeÓ2{ó÷͹Q)à_ˆÍ¹æ¦ðŸ x¦A¾Ûz0­éÚ™&ú¸]�F—²€3¥µà³ïcôïÈúÓ¥¹ö0áãÔí½æ7gké© ¤˜õôH ë”UHc¶sÚgÇzÇr¼®¡>w¬I·ê«ÃAݚѱh7Ùò¯Þ‘‚½¿—ÞjÏüÐe«<NPfÔŽ(ÖNª °&奶S€Á4ÓéËsº‘ZÁ‡°`YP¶ž,1´U w‰3‰"ÆbÕýç åþëNÝë0O†Kfì›-ÈVá´ÛZc„ç¨kì²; r+1 '“ÿf¶¼D%€÷1±îUzëùîô[ËŒ¹a«Ólh<z7ÒRU÷ Ú„¿ñ9u‰×1@Nõ˜BïªÐ”\±Xƒ±Õ¬¯ á¹ùÞ­ÖDl€¸EK¥RC;)nþš€ëoªÄ>èQýç­\÷úRA(3ýH”^RÅóµ^Ø:{³ «ý©óŠSMïy•Z†8ÐCg;-ëHÞå¼ïNÈÚõéG…sÇÔ6X:}2+y[3‰µ+éj*ûjí¾â•uoü -¡÷ÙÕVÇsÏg°ieïKsÕPÄV¥5: }$4»�CñÙ¸ÂDD?¼^ùql±›ÿ΋Ց€?6öÍw¸'±SêNpž ±¶­K¼O‡SÛ”†eÚ‚`ÝŒ‚Í——ÛÍùôÓ$ä~GÚ}z¡ß‡örÿÉI¯†ôU÷à÷Zˆâ4œé;€Ù*ýZîËYOŸ¥¤â|UçÃR ç­7I e�}'•îx"ÑQXº­Ëjqý9’Ó—{?ǃEž3íäÐ2wõ³³ÏÆ(Ö¾0çÖ¥Wõìœîm#ìîš±k]‰²àž’ÍèýÝõû6ÝæÐ[ ²Ñ__Oç i‰+‘Ó(òú¹ÎÜõ*Éúà¹þ0PO‹UB Èc Î^Ý" °ÔñId¥I}øëK(ØPºµîcÄ#œOÕɆ¹¥Ð2Æ Uî<›ÜXÁ#ÅÃ�–‚=†­Úi:Ð{ƒýíŽãå+³2¯=‘+‰A2ÏjÏì$ø Û(ó,8^-È<´Úø&•lJŸjvÅvPYŠæ³ômžÑ¶‹•¹ %u_Ð.²ž´H@΢+„›O<•‰&p½¡íðäGT)ËßõmÊ]ùÐ8ªÀ§¸êlÒˆÒ$›g+Ü+0µwœˆŸ¹g¥ïà¥2¤þÚ{kºÔhÛ›)5­ˆ#E‡ùߧԞI¢ˆS­7‹UâbÏE#ÊêÂ:/’p¢8]¡K ÊKSº“šŠ!IŸÖSÍO#;d{WÜff«C$ÿöƒu6‘ ,Ÿt—Έš@ÇB¼SDönœ>ÏôÛ¼×ƽPD-WӼȨHŸ¡®U$Àq|Y–¡I»^Ã7#‡4ñÐÚ4¤úòZß‚Sô‡Ã¼m]üZÏ5/rCÜoè¼Ì§³7Ôk€nª'%‚â£ÉŽÅ:Þ`}—»X2^aBæ@¥}o‰¦y Ò:@ý%ªŒÕ…ñÏý ƒ…ÉK'¨"¬Ý™ö” ZºGʸ•~Ž« ´KQìaÆV§z*jNtdží<ëЈ‘ð#�RžÙ©2rÍP‡4(‡³›llê…'dŸé* ßjd<B9DaœùJ¥ ¦N­G¤¼tƒ*ºšDü'ÌTd•åm㜩îÙIq|¦ßj\ÖÄ.áU®{¤2 BrÀlãŠêÜ Ã¢ÁÄ Ë€:£=ºˆ�m¦!=ºÉ¿»tf™í·ˆ G3CУۻùø®ïGÆ»Ä×êÕ1˜åe!Ñ·ŽƒêºõppV}ÈM7¤g…kêž¿ 'fì}#û‡T…ßåC,¦­YaœÔš¼ºQsuܼ*M^î cËŽ­ŽA­@hcy«¾?Ð $é „MOä^Ãq'sžœm¯œ’•Zý(ØMÅŽÇ@ë^Ô(äfòš¹‰‚ß‚b–yÊ9× {zÿ~Rªv˜K»{E5#G‘ýF©hÇ•>ø‚ò´¹¦Çq²ŒtÖ­‡#¼Eô?Ÿ¤¼åÙ4n^qGó›Yìù û¬YÆ`ü2iõ=k>ëÐ;»4 «" ñ`}û¥–»` ¨¸™qU¦ãúŒ!`ènÔZ蓃¬o C? 63ú²Ì:§LÙ’áL‡²"Ž¨àÐ!¥$ö¨U8ûÊ(îv$çð±ý)Y“0Ùi¯¬­¶3miµÓN„±öaªí)ù M¤¬²ñóDÇcÔž»mº:©S•õe“©‡?P-BÛ· Aw¡GÜíY¡‡áð‡µÛL=w;Þl¦ú¨ M¥‡df¼¼™ÎÖK ýÉÊšÚ¢3„ðG§piëÕÔØPsc^øÿIè#òO|@ùv°úô>¥Óéø·¿·€ˆõØ…2P¢  ‚ÙóKpøþåp<Iû£îø…³–ñS>e•%™“a_Ž,ˆ.*ŒÃZ^uÆÙRª#ÐâøäÅ„©»¼0cq^œ±‘Á»`znýü »çDÞUæ/Q¡#~øVsEHN”Ít³ç„¾Ý‘î f€FØ|7< ÿÿ¾êœœxzé`�œ@*ùËs'䣳5Ú“4’çŽÿ¸ÒJ¯sÂø¼#wÈ U8ÛähPT°Lö.þüµ¨2olL‰yCÉP:t^ÊlG_J8Ø{_ê?FÀ÷üv2M<jÌ "@öX>™³†0T²¢ªQl¬‚)üWl`B&~…Ôl^ØLRÚ2BÐÔÐóÊDÙÊeD+œOUû¬ißf$I ͦ‘sÞ“è~ö;#_§–½;OðÎ?µƒQzŒ—üLÕÎ×î¦Ûͽqfõ¿敨åÔMèa¾ëid.ëE-ú”_½§q<¾µ×nq-:ØÄ,Âúž1š†™Oíy¼Ë­“¨‰ˆíSªW'ãï»ãaF ºÒkàÇUtí®‘Þ »‰¯õð‹ØÊŽÈ¢¸LUPY9£,5ŽèÉr¦Iëœ{Êì)R36ç[l˽.8cò未¨“G¸fí¡›µùÈ‚‘tö|i{ã™Èšõâš3údÂébZ‡ ¡E¼°Nþ…R{@Èg!њו"_èá*DyˆTçïZY‚&Òœ)éR#N}ïÅötËlÝ8Ù,P}¶J‰|ÆNÉ,¯ Cxîkë &´¤b_bNðêfäiîO›ËÂ<÷\eK¥Å]Öº_:ÿM¯ â¿·•A}ÓÊçÚÑ¡L ZFŸuçÙŠ�DɆ‘ ÀÑVŸi9±d�Ý…éØ­¨°vh”[)“ ªÑuì£q ÌúÜ«t«Â5Œz-éë}•ÌÄsÊáS¹šÆ+N%p¢nÔ>Ú~l[ö¢ó®ž(¬W‰7a£¯ Íò÷ÚuåûCﴽ؀»Km¬ žËÛ~wT=N�¾’Zk ê¹ãØÁ„8•iSU?1a{æÉZ»Ò#ŒÞ÷WÕŒ‰#s«ÇÕkßcb_]»Àƒ¿h_ÅýÞS†µÆa²QJ$¾‡sñÕj+¿.ž:gq8?ÑrËëÞ#¥Ñãác¾;Ió] búº>ºr™¡aS÷t’Y{–´r}éYšÐç„jo7<›}•ÞÊâð±+)i™=íqx<µ³X0qŽw$=€äm¡È|a*è÷÷Uª ©Æ ŘábÙøt,ÐNFjÏÌór? Ò“œ%Óé¡ÒÛGû«Fòʾq¬è«þH~´¹:ê])½žuZX¥?^ì¯ô¯Lߧ=3‚àÛÌSL«þHç |ÚÓ÷½•çÅ4ŸkYã¼ý;kö(öÝ5¢\XÄY»õz J”;mNž×Èı·’¥.ƒ9Kõ®Fs”ë.k;K¿²g ó8s ý ¬Nu­}EFZÏ‚9ú¢@U»îsú›†Nê}ë%î蔓w6Ý% ¡A uWo è½QþuéýÔÏ^™cD;j^² i¯ÄÊ4Alÿbè.ÒquWÖ èø›+²½!‚¢™<9 [® 뻄=g3K…BƒO›Ðn=ÑgtrBß}^ž{¾8 UYèx)Sö³HìϜܣ=ú-|[ 1Ë¥·<Ù¾iÊl¿Q0]æ U§h¿Òݸ â£Õçw9 döM>Lž6èØR¶8;ÍWÜǢЗ Ž èûFܱŽm‚°:Œaíü¦o¾²†Ñ’iëÝô~Ç —-å¢ !´ "ë0—X ÆŽ™8òáéîõÝ‚lƾ)Ú°Òæ(>•oL P‹q…!mÙô¯w9Œ—·ts6QÛÃ=@›QÃ…ãaS?ï:¯®6#ŒŒÎÑfŸ&AzöÔiù´Ò/?AæR¾øõr�²þ†•ŸÝÜ—KÄ­µ9ÎÙXj½ZÛ%£Úr˜é©ß¹xlî+- 5 ’½ ô�LAïÿlU-!Oì8Q‘‘'>ì€TTŽg’”5kHõü'˜È( }ybQx†˜ì¬6@úÛzU¢'Öœ!ÜL:­õ“ô_–ƒ’ÀIÂ\HxƒÎÝ|#T™Éàô3 Ê’ Û_TÑ(\ÑßPú>@”¹9mªVÈ•û­×UÅöà¤ÝefÅ{WÖhYÁ¥ÄO˜mÏyPíl£¶`á>1“¦rWnmy·®’‘ ÏG•Ùü ¸&Õ¤"EbÖn )è·ˆpŒí¡üc3ÐF5Bá¡žè$=½{§¶¯÷ §Î_j‘¾¸>�Íæ–ížO˜be½ÎT1Ÿ„8ÑŠX¿·Û†ª¯ûb¥ÉÊ)†~ÍWR1Ï%²’Ì Lð¬óŽÙ7”¬µÂŸ¢:Ö$–FP/õ†S »bø¾h ]ÙÞ´ùñûŠÈs‘»8ÈcžfOÇj´\½¶ý'î}YµD°SÝE'µ+ËÔ0Ä ˆÏhN¤‡‰ÖÌ0x6¬{Jè­/›Å ø¯zÄžAn>^äçÆÓDm&d¡62ѧ’JðÑL …c+ïƒò´òs2­3ú7iœò©žUe6› Œÿðºãteþ”¸û‰>ù²÷Ňú4öý ¦ë~<u/‰ŽúÜÊP犖Eí?¾ú<üyí뵺g$†ºÔyPX9 p¯»Å3³àø'ý#³Ô—?\÷ÅœbeÀ­¥×ÖÛ*ÐØt :]¸YýåáKÍe2FÎ)›Õžør¹v$úŸ·ÌÙé¿HŠûÂÙ¾>ç~ÍD<ªY Ñi¤…LÓ ã/}qö·^›Ý%kÕŠìbô›vöø«1eÅn7UCº”¶f«JQT]ðG̨‰<^œÇz˜[˜C}“Žnf~éy•¤øM#§Hüvc;u˜†ô?‰(€›K.];˜Ú¿¬û¹¾£ÁÁ¦XÆþ!›?=ã½ <Øæõ!æ"¦L3Ï4Ž–GÓbbóÞz` þ0NL{Ów›½ÐüëÇâVeä5æß ' júÚeœ§nx£SºÖâ™N°Z|G4tU§ˆþy:a$}õ/ýÓ87“úéXÙ—§?Üõ‡QaB-,?„ŒÈ®ÏBDÔ~/é¬EBn¬M»Š¯ÎŠéGÓW´¾éN–Ê®òóyÒÂD,€î´¤ã ¦ÓŸþmdî¼R À|êàDlqœu,»<÷uÛÝWÐw>IL#M¥Rù‹DFŽN)§?‰ãÔÁRíú?„j_¥¿öýFy¹(ËÒî[Š\Ë—²ˆL**\ÃSݶðíݟѯ3R#×el[j2Ò¨Ä/8ÿ´Þ6ë7“Õå¿—ŽÈ--ÅŽW̃ÅÔ—›ïE/:½…;Ó¬-{vªwÆî÷^§nè¡bäÝ&ýdíbÒ†p_eòúŸ7ʾ©€<ÔÓ­‘Æe×ì¸Õ ýíLûay§ÿH†K�hSæ Q¦s†ý'w;>Éß3˜öFû”ì5I7³DNáÎ_¦Ò‘bS*>!#k)ø*j5s³svU¼ŽôûËFÁ¬°HÿùH5®œ¤â Fïg5÷µööÃóo,Wß&F“µ“Œä-L§Ø2|tºº¿UOJrŸ3uçXHÜfå¬xÅ8,+Ñ~¥¸À¾äÞ;]ðt¹ONL3FF§àÑž¼_œÆ˜ÔS¼W9ç’ž®½8û@Çâ1© '|Jõç‘–]rÖû¢ …K.LÌ65 /:FžDE©þØèS¥~•pãž1y扌?m×?:þîþþ"ÐÜ—+½™l„g�ÔfnÙeiÕ`¨Û·"Ètã4I'ÌÝÓ©PƒéȘ€õçŒ2ƒ³Ïoª©êG!'wÆõ§nw˜E뉢b• ÂA  ²Ï½'fÞ¦ÖùOm0€<¹?vúÝ Ðk 8²zç°Õ¬-*Ä1’~+šÜ«b[–Ñ),`è<l·Ú,É™bÜÍÅN ˆLˆõ5Ô±µµ‘­\ˆ¢Hˆq§k0 Ä8Æ–hHÕ ñk)O¸æ¦K�â^Ãæ˜ÑקW¯ögPîͦ'z/úÂ{z^µMŠÜ‘íPåmO Mûî¯ôq8ÌåüG¼‡wÉN™̨ (‚tnmÏWÌHiíê©[æÁ4FY^™•}d;úðû/sÜ¥AeR$Úƒcﺑ/ž¾Û~?åTN6*MÝÚÃ^¯ØöCq»=¨§áÇátª¿~ è&+LiTq¶”6:ËÎXe”ŠJÏÞôÇÉU˜ƒ=â`ó§Šóbª&6~¦wèú7ÐçáÿgøA””¬þlDç±?0mü[’dk¿Ë–²¤æÓ‰ ó*æÃrWç˽«o’©ì¾é‰‘]GZ¡ÙþìÛÑ2µ¸f¿úèúΉ›ç+ÍæBöIPؼ•PÜàFçüeÈsèéºúûº1L3Tƒy*mÖÅV˵øI컋ïcH ’ˆ\‡îîÏn[+qäéI1°¯ò±²Óºâ"Ãáš+s÷ú™*á·V97ÞÔ CO®ª˜ûn¾ÓÏLÜ]_X+ŠH°à+’²L|Yàü¥j§”n`\yj§Šéõ°ë¾ný‹—En*hÆoŽæ½³¢Js3Õ‡”ϯƛߋ°;éí³Ýޟʉgõåo†Ñÿ%aä¼ù=D÷ÂÿDrèèÐVúâWÑ*Ãóe¨(Xª`k¬ /S~ÔgQ(¤?Ô¬wu¿ækæ •‡‚`µè‰]ÑíÿÒʨÕ߀}ÔÑ@£Çh43Á±9Ÿºé¿ÇÚJ1<fÁT™‡ÒáÁâaï¥Úӎ稧6¶‚2eqÊ'#ÏqŽ½’hQŽÕyšê”¬´tä$ü[ƒ¹>ƒšEGP¾»¡=œüD6Vƒe™Àát.ƒè¤*Óز=>Ób\Qž'ITú™¦-eP5:$Ä­5ŸâGÒ¦ýØ'k¥¾<ý¦†NÃòK»¢[fúðçRßã·NËØÏù4SkŽN¦£ìœO¹Òÿ°ç0ú0R\rõ5�#W^¯zÔC¾¿CæoõzÍAi/îŒË"ñeêJ@…ƒülßt½Ô ²&s˜¹ÃÍÐuö_W:MÌIc,LàE4^”¤•€t“k:Gà'¡–xÿtlæÙ­äÁøÏáÎüN:'Á>Ú–Fp¤š‰¾¡ÍØj†¤è[­Ë‹ÐŸyƒQ8¤i\Þ=ÖÙþªõ³šm¡µŠ‹ûªQš¸®E"sŽ$HÚ‹ó#rà…WÕÊÊG Ó§Û€‰îß-rS$(ÐjLg …yÂOè[îú6ÐÛùúŽF“(‘ª£\"¬{Ï6}¬?€ËVí矴̓texÞzÀcÈÓ*cCe åv£úkÐQä ÔÔàŽ½k=Ý]£Ñ(í «¥¢ÕúíëÝŠ1ó<Œ™ßw´ukí<ä¬Ö+éKÆOG«!Bœ­Ô`sЊi1ZŒJ¤¤<ˆ ø86=º›K·ËÄr½ÄÓ´X²þ¯‡“¢íPÙUV;ÿ÷6ð-ÓFV=‡Û官±óª¨¶Ê©R·ö)ÃGŒFŸ�ÊU}åîÀÒ>Â=Q¿Æ½SÊGeìÒfÞ‹—0wó‡ž)pf|ÌúÌ3ŒEw±#” x?÷d(ÒY¨‡?tòªÅÍwœ:ŸÆRD½%RYŠþ¦¦„´¾Xí<s7¶m¸‰Šþqc›Ö-æ ³EÑüëÿààÙQ€+h'ÁDúêéýÖÓ€éÑïÕ~SÜÅ}³Ó”¡™K‰&;íZÁêF öMÓ•QÌE”m½r›j6®«Üõs÷bȇÍb…b.î¤F™Ÿd„‰¤‘ekÕÅ …̦fŽþûì1*<€Ê”#°o:{<8i÷]jÛTÄß´ü£°ÕHŽ¸wAoS°“=¯)µ7rXn·­kô¾@"dõš×ØÛq䉯åÌ÷d‡ƒV5¡À[¤3ÄÑE|ãq¡/nAäpyé$E¶„ÒúxlÓÒe GÓùäQ-·u¿1£Î[Ó-”)M_"v«Téô$Õáuß ƒá8¿ñßlšÕ H£S9›q¶»´=«Ç”jN»9œ¨ÂrFãótäðýºÏ¦/Õ>BÇE…ù€êòFÍt=6c@UÕ?Ç›W¿K(eešÚ©·Á<o§¶øÈÙY=ûßøkž~±¨à7Ýèúd3·Œ–¶D:N'%S}{§'™ÏL‚‚ß³JAPEA[¡´¨ùa¦!£<úÕi¿&ø<ËRR]&*ÄèÞÌ%à4ŸCg”µ×½Žó+ÖBžGW†Ä«£¿b°\,Á׎Ãr;‰Û³¦Ìû¢Í«02¦Æ‡=ÈÊB8W”|Œs#ÅÙO8 ûÿ}ëÚã5”…5÷t9(Ç9%ø"OR²{Ï%ežˆ|îîˆldÆ‚TöÐHBÕæÅ2_u¶6R cš’ Ϲ•A¯‘îd/¢†˜¥¦ÝRlúñ{2IŠòÐ<�ýÚГìm‰eë5ױƫ­ñ›ø-¬»ß¼aº’©àÌ–ùl§Ì_è–iQ  5vísc¶ØÙËpçƒ"â%§LÉúcðÕ!ùP+CI3a1âÜß=hoÉ#hiÁe¦"|ùtŠ`âç!„‹[¹}½­ícOY€¼]RåÜxŒ§}}@!ÇO`x%¼Ë'%YQæ™tÆplJ(ºužJÅHèy]ì¯t’(ÈR:QéÍÓÏÅ‹›ºÓiV¶·À%¥à»Ö“œ7ßz8BŸX!òlþ$Ømº¥s:ØÀ³V­ø&(okrƒ=8õPTl”ì(é œß7€SƒÃu8tWw\“mGfØ}Ñ©šœwþŽœ¶Á¨XD7ôHþ–úd•Xä}õÝm«VLi‡œFŠæ•›ü%¸Ël}!‡×0çSÇ… èð7ßEŶ2m¥¥.)´_<ut°{ýõ"þSßÇ ¦é ÝMyÐm…ÖÒr4T9‹Î\Â}û ‘øØFrTU „&Šeð4•ü ˜ÞÌsýI&CË4^Ì£»?‚N‹Õ¨’>íÏël§ÛƒYæ]×sßÔ(d7:ªA 7ÜšQ'éÊZ,†LNû¿Qqk?0â³ßcÅ‹ªÍ÷¯hí:$1Ÿúâ‹<k[JŽà"4ÆJ®d;äŠÌ4�ÓKv“•'¨Ñ'ý b«ÿÏ[LAO¡˜æ_~%4WDÙÚ¥/‚p¿x2é}v>þÚ1I½ŽeÅIÜžco…Ò¹x2­Þí_1Dâ8‰3§u‘hÖ¹Ý:9hð¸O8_M<“܃£Æ¢1Gk»:íWããàÑV'GÔ,Ž=Ñö�*ƒ|Pµ0QcÄZý†1íÞvdÖ’#¶ŒÒÐ @ÊW­%PT¾Ñ2ÛÆ攞ô6[U–üÏ[¦‰å¨“7›ýK¶³}T-ÁyWÕ¼uGþ‰v%ûß5Â,‘5ïú%Ãd׫Šÿ�Èd«ÒZIÉ•ËîíúÖŒjÖÄX{wõ¥i‚‘iz@Ãøéô�2ˆ/÷Fí—û?ƒkÂŽ-m„ø½ó   ×Î K±Œ®ãñÜè9ŽK_û!¥²âN'g }¬šÔ¾,©‘ºŒ†¬s¬—¢ç,ž4\é‹ÐÍÑ©œüº}?rGBn‘BÀ~Awb]+'áèz1ÊYj'"Oié©ëßØ -˜?'t˜`ÇKÉÅ:cË,¡©ˆüا\ÑßÓž¼¤wžÚƒ eˆý—C<„Xm)ÓÑÌ‚&ËVˆ¸ü†NE‘Ö“h÷¢ê·C‹>ÝæH )q™Ç%ëÑ*ÆÄà òO_Þ\™Gbõˆ#•å—F*48ÕoWÊî,ÔƒùÀå¤é"¯IUq¼â?çÁ1eÏVC~B–/‹ÑÎ'ÿó–jËD½CãÀlÿäΙ„>»“²ªù£3kñÊä¶[BiÉ“ì“'‰´Ù�›Ä‹êñ7ž¸‡…±îüX€é.nŒœÕ â—žƒLƒ˜eÿ_'ì{ÇÈÛÒÂÊô ©®ªÞúv¢)È˦³2l=ºJõqc�¬×†îÌ秉¥È¿EÒv– æ‹wuc"K¼°îNèS ô®ÛA±Laº8î34F™ ÿ“âtž 8À’'з12ûúŠKo”¯Ú ´_›*aýb}tÜNXå}/8ZóŽ žË‰€yNE´½6Ÿ2–ÆGÓõiDÚ<}©<N#ïô•‚à—úNÇì{ãQØé¢,ãr3¨Õ7úú+U.«Ãƒ¥àŸYcåShÕÏ|@™Õ÷‹°ŸVnëÊA—U}vèÜæ`4ŒïÉK=ìÛà=V¡•ÉŒ½1·¥G€‚x)•ƒÝrûž‘g «x_!ÔXi}ðiduÌöÓÒh?3w˜Ìà˜ÅAµÕ¹‹ÖÂB¼é }[–v7¶0·yaøˆ!ÞzXIÛ™Uwض—”;cM®ÓtGL댎úEŠŽþôVœ2õNCïÞU1 ô2³É¨ø½‚¾³>Ѭ¦Aôµñä:Þ±Æybx¯NÁSàµ_°XÁ¡é…%ø.%ÿ¾ w„Š¦Ã“ïßÕ9ŸFO’òñòS㘌³˜™gÏn’ÚP™<¼uúoù3Þ/yC©o0†7¿¼p«³D Ì:M‡“GåŸ Áh>QêùF7vª=ý¯©7GT[G™ç¥ÇJGXGÖ¯!s+êCFã´Fž#P}ï²Ý»fØ¡Ý uÍŦœHÅÎWæ®E;_ jj{×8VVÁ@%L¹ÕL=@ƒ—;KŸˆoŒ§Æ  <žï´Ù½�‡š;¥;@›Áj;—«E�‘>±aœ´¿ø„Ú�xßöj®s@mT –ŽŒaßVº¶,€I<ÄÈÃÙƒ?è"Œ_ÿ;­’?fý§ZoèJÇ–]ÍîXžô˜íañ|Z3° ~þD‰O£ÀdÚê³Y*ÖË»wV<â*X½04¨–ËD_ ÆKFæ-ÝiOŸÜD‚ý8tWEPüé$•{¬ÓçâLhæe3,=z…ßR%Þõõn¯$¨äí¿TªƒÒ×_Ô±.hò‘? ˆ)S$öÛcš]ßC`;ónÓÖŽi}ôÖ$'2òš0†õ—Áöý0ªÒÐGA‡b�VK¢ d'å‰ê•&_1»TÃU±øa˧tÌš:P©óS\Ï#´}ÄQb`V›± "+� ¯Œ s7š,Oæ"2èõaÀ"¶È —¨=AÓS60k ž° Û@õ´ÌoyCMŠãñ§Bdéö‘axÍ”œ‡“vÓ�ÔÃ~è)Ë×®km &¯ù’X°^lDË›$§_¡“L”-lÒM烜­÷k×'Àü8ó¼hRa”Ñ{çáÛX×_ó:r¢É8Á1—VŠW ¥E¶:M‚BLÔ6ž¨ýîµ™åOëÙš³M*‘ÖÅŸ Â[i_‹?ƒù˜´(‘Ù…lP‰{÷‡q7ì“K]ùpqjŒmq7•ÐŽŸ<N¤ÛÉ2V$ÛvË‹2½ê³ ›DÍÎ ‹Çzáv“sjôââaV�äШ¶™Ñë@?ËÛ½U›•¯'ý+—–ž¤¼Ð‡Qz†F^®îaöήBé¡x^a/èÛ¸¨žðÚ.ƒe”¦™•E ³ G–š# >XÏE—¾~ÐÉu`Ë*«Šé$LcSã²ʶ3ïZܯeÙ©P@q˜¡ÙôØðS}‚è6ðHÞ»ã¹ÃÍŸ¿‚¡ ±p‚®ÜS¢|—j¹Á&wz7vFÞu/'¡n—@ÑRC¹«ßzÒÌꜗ­ç&ªÓrãÁëÉ}\+k\m¯eÕöóTç¼» O7•N2þþƒ-Ȥ·fÞH5bo³?iA)áâ˜ÂV…`I¶¢uØ ÖÚiîÓdxæœËh5ñ£Ç’ª¢{Ì|þÃnwþÛ\ÿ»ì;žÿÝÈÝW¿Ï=>cä7â i -€ê¬ê’:¶•½Xu*ƒã"¶‡¦ ¤£& …OÄ ñ�5 §qøV#òœ³'ø ëJ§?BŽL�ÃÚÝy¬ÿ –TuØöô½UÈaº¤Þ&•žO=ÜBÉtûíƒò݉f|SäZM›©J28iký‚‘téõÕßBh?xŠSÒä×|ç%ª‹ËE2=.8ÃÞ;Ç&dÄì›Si¸à2óÎÉô ¤ìFÑá¸}ÿëñB(pòÔ÷—Š„ÎôšÃ3-Âs$ù—+‹(—o¹mn›…ûúJ›Ö|•¤ò®@ê,Ç¥s¸o³ lÞ•VòyâñH_•fpº>’û憡k—>þ 65:“÷ýDÙ-<5¶š¹ ù´Ô6ø¯Ršu ðÞ,bíµÁïjÐÉ o_‡A2œ<H�S‘xyXrRÏ…ëýQ~WdÞ² ©$£ºæ¤Þh<cßvÓp ·B©<ÂÑwËÁb^¹Y#ÓfvËë/^^Jî0;`ôë$ #÷™¹E3íén$½µ+å”·nØy}*ZupÍFÚZÀi\ ¬!î+>«bΕɿ¶¦šd¦Óò^ýÂ7 ìŸUyô+Ù•÷Q/NWÒÖH`žUœj¬d0#²)ë^!?šgåÙêˆÍ Ž¦µÂUG:Õ‘IõË@šØ«Â˜¦³Ù¦Ã)Z)‘n‹]-ô–ך#ð2ZJ`7×iJ9îýÈ×ÁÌ*·hWµ×šb`Ž™æþ?®ÎÖ:éq°ÿJƒ²ë,å@|Š$ $rû üaKñnà L]ï°Žcß“WŒkè¤]œ{ÎÊë¡ÿ˜ex¿e?ZëâÇò¢Xþk„š·2f÷Yd¶w‹2–‹œ~„d}*&Äãu»m ³‚¡>èXDñS5&’3=®o?€#eâ¦N$u™B.lm²ký¦¯/3#ð©p`‰Û÷ Ë$ó�Ö˜&ƒâöÞ®è´?edz¿j~2üµµ"›°Ì*ðæy7x²…t—“1×GÜž»4GÐäV1åRóPÑ»k£Þ;Û 4*ÉÓ?Ÿ8£=QàíiFViå!ñ@«#ÏÅQ>҈ɱEëüB!Ì÷¾`à`¾Òmq](Ì1)øõ×'¤Z”àr4¡Ô»q \üÛ+ò§Y³ä¤VÊ9k€œA›ÙëïžÛñ•‹<rÜcöÌÔ°B[¤mÇ‹µµH«õÒ6¢R­Ò#3hl*HNh;Ñ™¹ƒ³5)Vÿª¦y?Ž6SÛZ”QX,µØ°×\…þ!Bâ¿l®NþýJ²¬,2§ Eá¼èQwÚƒˆYæ¼Ço1ØÀuΊl%­[Ñ‘Pénï5| ¢3à—éÆ`§/ߺ0a±r¢´âc‘¦þò¢Ë7¼yVŽ›±Áþ¿3õ7>B g×"HÔïWäAô ñ7Ý«¦^UGaYHš/ â,è%ÔÁƒÌ Ey‚*„®ƒ Lß|Ç#£·›R ºP6Fc»vÿ2¨¶`8cú‘ P,Þê#�@ûP÷ž®1*jOëDGÏvªÀþˆ3s*þ뤣ÂdönèœË9+uû„0)¢, =ƒTLÅÐÀT¯Ý(>Q‘HjîàEM}†ñÔÙôñ¾*HbGS’ªÒ9–«ö†•cúr„º7´¨{•× JYc4’Æž6lJa°_…ŒJOW‘å8…g²WDÂCÔý¸›+`tŸkòÕ$ÍýÛÃÉ*¨–³ÊŸ%ܼþè&¡”ˆ q×Ï<kâ—{œ¤rå ã­b} [øÒ¢\0 6…=< ÿ¼' «œASØU�;å,#±ÜCs6)H3It|îžæÈrƒN¦/žœì;ºçöÆ¥ÝÞT/–NŸ"&FÌõÅú/ ={9¬Ë=-œÊŽ>0Vıä:PÃk·If˜ ÓŸYg·+¿³G³Ù@éà53㈡wö{oÏe tPF† }šÒ yï<¬5eý_<`±´J¬xÿÜ9 .¹­Ôã |Øâ–Œ@Q�Ç‹hC«Ä†W—úÂg%žKx[ØSFf&Ö,k]ÿÂT2Š<ÝUVùnúœ²ŸÞl«T¼Ð.f¹×ÖÝϼâ4Ê3_§—îÍD5·•DNIõØîÔ(ü1Ó/ÌüNejóH·%^T¾"Võæ_Οô“˜µa eûe¶¢±udU«e ì€l§MÖŸµÿÞ‘q’ÅaW¶|Ó½´œKaÇëéõ¢wL¤éU¬†.ýSÙzi=¶,j>FÂðŸs4¤îç²2žR!GÎÍH}Yæòtyô"üwZšð�âi":³=Ï•!â1ÜeìêÞ{o²9èÜu– ÷OúщuT·SGµEa…†ô= Bä§"®•%£#SL|º•ñjb”3Å5zׇXìM炧nYh!­yìZx 'ú×þzg=l/µÑO…¢ŠJ=ËåwÛ Å%»Ž´)‹½çCŽÇ.Q‰o ¼µÛüñÀ<öJ8i¼¥1¥bVÄ(au¿z9hºl\·AEø>'÷T¼¤i­ªæëN¦èo–Ò¢j€Þ¬hÛY¤ÿž ýzã:hÓ%A£Ñ¶ jè-#׸^àæ<=¦çÌÝV\½,<÷ÚíƒikÚ;•æ³õÑ£Aut·v5ò¼‡Ýt⬲§2îæ‹Ÿþ§Ç,Òü¾dÐ%¦ÓcVîŠA±¶–†Ø1A x~í˜Ë²Ub]ñ2;;è¯Ó”B ÏÆÂà¾_|ÜD¨”v5\³¶N¡ ]¦õË¢n/+DYáP lƉd:u”¾0æÙ­ŽÈg ü8ðÊ­‰è0ðØÛÌ̼Ѓ=)j?·è8G/ܘ”™À祚O¦ò‚ƒôGŸ姕³ÍçFòO–â>B„ņŽ1-šÈP‚Å \ITg 8QX*ïy8OZøõ.ºi•v!²ƒeHS|Ò¯€G&»½¬ç*’6K·þ¦M^ï#R®,¹G7yóÊ>)ércô©æjÆ Ó51å¿ç•F¶¯ØI»-‡šÒãøü×3‘¢LgÃ]5VI=2œ÷m©ûf\ „©Ð|ú¬äÄ,¬8L¿¦ ’OËÆIDûðJèF½½Žë¥VOLcî¬GÕú{,²äÆguþȃ²³Ý좌}‘‡ŠçlÓI�ÿ( äº9É*æÍAtR/”$QbZ#íÿB<Ê5JF;Ò‘çAt™ÔAô딂YWšøw®¾Ïü}‹ÊWfsu';7ý§úʦ®vóß„AQøúbéÐ÷…w9ý5¹t.[3¿ŒWé¶ïÌB䌖½\áo2g’Ä¡‡âÙ¨8cQ«û²¡zqD cê¢m=uâ %¯+ |²’÷Çà¬Ê¯‹ã¢Ñò”`+o÷+„›oQfÄ¡'ûÏðÚðXNŠ©„_íù¨ëõÚvòåyín™“¢-E{¹i)FåÛÖcN"gfn1@´ža¿ÍÙœŒŽ™?èFi; 2r�ÒO¾»~ØX6 €~èVÄ׿®ÀÎB ‰ZÛÍé>:Èû‹ Ÿ^Ý“@,W"9Ë@ÇÛÚ³a¦ÐQT1O÷mc’̧4B2c"+ÿ‘1äÖí{ÛÄp·,µ¨u8�J¸¥åÒœœs À˜qÊ-Â4{†¦Ç,àò–È`x Ós(çÖR&Qõõu¶Dž1_¸{ê¿´:i·òCК+ 3Ï“T"è&Ÿ:ÖJ :œ¬xƒ ÿU›šß€NÖË$zßf�yç9.y|QÀÝ٥ܻµ‚@ß²›…”£\Ž}Ýïê?ãÄšU)ðOÌ«`fÒæӻ׺ ”›©¯æ¤úu›!öX¼’¬L;d(>)òtØ,çIé)ˆX ÿÄa& ¥ÈB_·¯‘gìGA!AžþZ> ‹¥j¿Î‚LÊ•ödEb0ºf9¥Â½¶(Øa*Ì„Uzÿ¾wÀÝ¡]í2g¿C#IŸ<ò‡Ít8žúΉœ §Ù{~O52Oöƒ;$—?ÀÕºÁ~hpz\]ÆþŸãü0o¾»Iå£R ¸©1~¿h—YïQ4ñßâ4äeìï½8¶áJ>ßL7÷éz/ÓiÔw@IÏt)â.=ßÊïªa  ÷ÍM#þ[踲 sdÝíEÿ—WÎ_›œ rÛä}ëS쌥”\¬‡¥8) u¿bNùp¢Ì#­Ðy^ EÉ£Ž´Bƒ®i.Æ™¶¯»¡>¿í.èxßy8•Y£%O’êI'äŠ[rÅ"´T+6ܪ!É3zãWÈàIu+8L1ÿ>•çD ¥sÄÁ{fqè+gV”“%U¶Â`óM0^F‰¡ UÅþõ3ý”{Î�[¤!€D¼ƒP8b"{0RRÀ ߟOXmíˆp&Ä[Š�SçIþ9õ¥a’üÕ;S9ïyÃgÜÖâ§Ûñ®,Rž:¢Gppw9°¸ãqœN ºš<[¿ýv ªÄª@yØD¤ ¢E•Ä21¢ÿÖj–r%GqJ_רÄ$L|Ž,'úŒÖý~ïY%Ã" >%á-úô*ÚÖ¾ºF”HÓÇÛÅA¹oÍ6߃ëêyÛ³ËHµgÿ3h*ÇOÍŽØØ q3XM�¤÷Î9ú3(¬ÎtÕWpÅgbûQ¶RÌa;Ewgwqý×é<Ó*”XãÕä¿4›Š=æs˜:Šê±ÁîÇ ÆÝý tŒî øæÅJZùflˆN; ¾N½ðñßÖfVb/ä_¿cËЕy¼\N#Îy-fÌð¾â6s¤Ö£x;Kœ²ÉÑJŒ7õÑéCÓ½¦S³¶àéÐD\Ç€‡7{Š3Œå_n»mê1ó˜! Ê“ö"QC5ô鯛÷ÜD|(pàg¥Ñv9ªï®ÌÜÖ<|œ´¥œjÅñüG¾„L(Þ@˜ïKÁ´ü)ÅÝÂc•´ÅþÀ(`Þ¿†ÏK×`f÷žS—Õiö@©à®LBtvtºúÆVR?þºò®Jƒ ´Ãç¿fò³%wË­<³&–O¯ì·ZB)¤¤Èwuý°ž'ÙÀ½š¿‹Áú²™Æë]„ºõ·5‚9[‡网@Æ\‘9’fÿÊ6 ©ÉŠ¡-¹I$ç/7h¡›Ò[ž?eªhAÆ—v&€\ÆÊX‡1Ž÷A8À�Ò êµÝ²£»Ð²­=234¾×µÔŽ†ä§#+¦"Ö †Õúÿø^²ÂDɃÝ94LKšíaùK»`V> ."ƒ²þfOEè~ø‰ÓÈo^Co@iµÂ04þÓ.o§_#þµzáÁÅ# 7|°*-‚>¡Çß~zÚÒ 5܃ƒnoÇüŠh?©$J'㻉òS«°õ,ï+K;[|ažOTÝ(&T+VÕ¦B•ÐôT~Õ(–Gî_1#çábŒš)%­NÖ÷8_¡tŒyûúÄœj‹˜„¹Þî<2"5“‰ ñÿ×”õ;ö¸*ÝófFå,ö°Õy­´õqû,¥_õ¡•„Þ]Y§·Øí#k§�Ÿ¾/�¦qÍÕðÈoæ6õò‰w”o=i*A­ÊôÎįàË 7OÝðö « P±WʸòmÞ)öAq/lþz…|=<„̽jÌ<9±HnsŒ™{ïQ—P}ô�øÐ2­¯jGç®è&›‰<~pÒZ”´8³„À¢Ž€8˜P�'Œ(ðµ9}BÿrOŠÜo¡"LbY]Ì+b¾›§ðŠaÕž×S~]‘¹ž"«7·{ZwŽ©M[ø3€ÛN5Û?¡d`>hpWªný]ô–¨ÄpÐZŸápµ‰ä sø6fW¤Üǵßÿ¬òЋ|1‹‰K…[cNœLžñ¯ªˆß¾®¡{yèÉú>û»×I'ôûñØõTŒ›Ó¦b¥ L§ñ*жûm6|ö›ïx²î@�èa9~ÒåʼnnßÖ“.Qª8ȳ}É‚¡ð]Wb©oÓýÞÎMWŸ…kl&¼'_ëkÍ“8û*(:…xÅYù}sÀ‰KļÜÏkÒÐnCc:úòwEº{Ã6O�<9áãþazm}…ae ÖI¯- sEÃäøvñ®€—æ×ÁLó0ó%HÑüíé]'m×5\‚ke,±ë·ô¿“$qJ=CÔî;:z¥‘œódå„`rš<­]Í5|ßÎåüöÕŸ’1!L %N‹ÔBY)Á ÏøÉ=»ëp¹¢ß€ç¹»+#îx¡L‚Ä;Rµb!5ò¡óÕÍz+¾½ÜO ’]ŽÞ°ŸEàS&µ5îŽéCVœgÑ�yÅéÌb (‘Á]6]­Òg¸=ÿËé]–W¡ó0§ÖPþ–_ZÅ: BOìgëiZés<«<(µ(‚-Œî²¨AhC@Š;Ý ²õRw_Jâ5ó1Aº¬V¤‚Wqô'�/CûUHDÒ(¤·]¤íÞã%ráÏM–ƒùˆH{ Ï¾†m媧(ì'J6#ÕFNY2ƒùt°QżNXOéÚÛÊÄ]ê|«Ôl5æŽm ‰"ZMïÝN:E›Ü¼Šò+WgXÄ=Ðé,ðœˆoc‡V…8HôgLå€Ø¢|¹ÜWÝŒ´ÍW Ø©KÉX}•m0C+’2y¥ÇÆäÙ¸þf8#è1^.ws‰Œ‰yç"H®ºØÐ*»jåÔ£ó‡6Nsþû·æ¾þÍ~6†v†ÊB•-·g­²cÜ@M„9b¯Îªce"„…â.%ŽMqRª×ï¾»ržvwÐûPÄ°ðc2iÒ%"–¹,ªCOQáem3ѱè_¨uBKçË5.pžEpuêµëâ_ÓÎG§ØŸŠd…±‹Â (±˜NÅwWûpÔ[²Öcž´ô7eð—ò¢­;n8wÐÔ¶Q–f^'`†! ²ÏÎù¤¢jã[ YОʟǽ2]¹¦ÒÚÏ>ß=¯yƒ@µ‘Ë¡mUìíÕ–±wJ2³†ªÙYã ëfÇZ›Î¯ñjâleÀ´{Šj­Ž›ÒD{ƒÆ–HQ:ëåüª<³=)ú ¿¯ ’îÝbÀŠd`vÓÝ­óÈ|ºPëWizRÜ踟¯t}Ðß|<R<€!øU`mRÎgµ¬#©ÊÆQiXÌpi‘ÜFóWq‹•ã=Ùe€†¾õ²GS˜v¼J­.g­QÅÜõö{s6§¹{[¬Lû1^=Yj=ªùÌr%þrØí û`v&¤) �Â8¾e÷Ç’Ù5óLÛ©ûôÎhŽÃY‹ ª˜ÄÐw7û§Õºò>Âfluvêí) a‰VÀþ¨û>´ÚK£<°oA <™ƒ�€CñØÐÈ_˼¨ b›ù¡a~˜fÛ(ÍDµ²ù¬¿Ð´¶<,É©ôi@¨î?=¡q$¯À·" JAýòo6€¦u öV§úÚ{ž ËÛ;YñÜy±@ŒLû-2èÉÍ‘ˆ5ŸÊ§ˆ/=«û è;dh+A+)9}à}ŬFí(= ýO0³gtOöõ™®LâÛU3¼áªþËpº˜ŒƒQ Œ1xĶâÄ©ì þµo:Ó`É`Àõy†.1Ò›Þ)y<Q}Šè$²7Çp4mäõ§‘)I»¿]¿?C¤ Ú³¿Cº‡•ëç&žP„=kj"³]§Â@ûq`g }½?"ï®È êò'çΨyr1¤è±,<›³WQ1žòlÕ*¹MšÏƒ§HðÑOw;Ô¦^YY&¾ AÉù~zÒVf‘j‚x;Sþ)ãOÓ!8*xh…Õ*gôz(aῸ­|K1ò¼[ý8L¨ø§e”„gAÞ¨÷ &C.Ã3»o•µ´g(¼@ü7ˆª*μÄô“"aWt³ßPUaZ™*…ªû‚C'óØ<è¤ÀÄ¥Q°bV”¢1gš‰ÿ ­ÕÖó ‡Êb½pA0U-f?»ZgjæÁ?zu$öû2!#^a—~õæ4õ¶±ñ|íþ²ÿí¾ßb D5BGŸ²"+XŠùÕÔý9,ûƒzË.ÓyÍ× T‰7k9ÄÌG.SÆ6 EY©•( oHW›q× ûqE@ø…ØN™úƒpz†ülû¢±`³§½ƒ¿¢y¦Í÷ÜÈùXî"¢ÐØë"ú?b¿«l¥Þ™Ó±ŠîÝëò´ÓùçSãÄ> Ã__Y±“‰;=ýÔ3±ÈÞ¦A6Ÿ<ÔÞ¸Œ“qZ~ÞÛÈRËG03ßšUuf‡VÀ•R”E’‘Pí=%ë‘eÇÙ  ÎÝ6gŒÜkŽ¥n'8 VÁgE.®å(Áf+ð÷¿³`3U­LU)M‰ÉuÂ7g*Æ&e°ÿ¾ E±e³ J…‚ /9f1JÝ–IWÔë"ÁUêlÌ›R³¾®5‰I±¥ñÞz¬!«§ Ç]ü̧IŠÐ·¢‰áGu|R¿{R•3\"éãíúšqÂèo>ÇîE–ïXœVÓÓß2iIbø LTÅa¾WW¡W¨àIè;*€ÛB›Ê:‘ ø6IU#¨Ìb³Ÿ<½0¥-Oi¥pl¯0¯=™l+ Qú°”€ä…CVŽ§XÀúò½C±¢ËA¨i¦ðú©óª7<2 ‡r@ü9/»Aˆ3wmÇm›FÌã)ŽÖI.[çþ ´ª´iäDFÿ^œìÒA‹4ô­B¨Ü³ ´œíÕGÝ16 mm]™FúŸɚY­£ÈQeÄ/¤Xs~QÞHѨ2<ÂAM(œ¿=íí„ZLRc à ílÿ âQ ëp­ÉÝÓña”ÆÎl€íµ¤ÃR}|U´ÏSS.ºçó,#<õÁ rž `éÁ²±Žå,gÍÐÈTƵ¶*`T²Â~<Q¥ŒóÐ/lá3³ƒûù_O?Öó­{_e¾EðäÝçb°uØÚ'£‹qìúYôãÍÅ\v­]`Îu´*`W)÷t˜ ­:Ú»´Èèsnÿóflš³$[ZmõË ÐÈkÚ0U„ª¡ñ‹Ûh§­I€n¹È¥¡éN;^ð±ökÜ}fÙÚŸë°£#|ß{•¢t˜jÏ"ô'yìÈYdEbNÄ“+pþšC *˜§ÚÈëƒRÏÌ ü=Ãaú‘¶P”~o[¡¶E£=²øå‹çŸ{ÿò–QhJã<Ÿ ãuUR;ý’wº-’Ýx.Ø*L[K¸RÏg+aßt:å⋶Þ2èµLiôsû _žkžd !ãýx¤¿è/š¶R¼îd™ßÔv`‚>ÕúÅÆÀØT‚!àlÇ¥ñ©| Ïoùs{3•×/š×TV_]«ÃAÉÎbH„䫱vDxÒ®ü‹Cã×v}âýÎSZÇo¢pª%UÜNíx<dH㨹öTÚFŽpÇöô0N׊ Ì_ôX»_þôOXëtPTŽÐ\°1Iüy6ÙÆ©¦¤PµáL)·ÙŒãÇM‚ñР$[Y†)4£Ã Üûˆ)_µH@æŠ9ì òmUwÞù‘'ÁÀyŠ5é»Æk9Ôó/ã|š¬(%U°ùCO~Ðø•‹ÞÏ}è3õ,gú‚yzî ï+:™®+•È“8z¿YžÃ”r¤Á ʦÅ-·ÂnÈ28ÿ´o<ècwÃ+$ZÛ)çB=V›»•xåµ¾¯ªýP5.‹üi'²Ð^”_©Î³ƒŽv�Ê{=ÞvÓª«¿¿î¬”ï?\ñeFFqù¤¨{Ò$R„8kÙÑŠD gRÏܱô¤S†‡ÎäL‹VgãôyfÐÔ¸•“3…­6O`f½gúGÇѳjÅhT*÷è„ëv  ÑÈ?È—~kÇDaâ@^<*€>ÛÉ ¥‘$ KT—Œ~O¹+:·ÇíŸ'ÓçÚÓ ŸsÖ  wÕD@a¯J½Ä¡góÆløMSP¡Þ«f¶1à:0éz3ι¿CÃÇ–•JW³)@4>¨=ïZ§/C€¬%pß¹™÷ŽŒI¼´æXQ$&7ôül°üß ã±µæÍNßT^´F©õÖµÃuÛ!8£ðé¶Ãá%ñá(WÇ›Øx£õ3|ǵBé°PæÓ°+–éç=é@C&0ôŽÛ+ºvÍD9N÷ÿ¾ÅT韇寔¦ªÉ¨ÃŸË3ÃÓ0ö`¬X+¨lì�dÇοh¡¹Ÿ*—†TöÐÈW‚}TcÒ X4âãö1–µû7Tõª‰ÆTû®à`-¨LÌ{ÁÖû/XâMôØN�Г¯1\cä@ÉŽµ² öÙöIý†ižø¨j*¼Û.¢ùË(2 º€×º¸ …Î\wuWÏ ›‹•£lÙ=¯›œ×èR½MçSÂô¶FØÝ»úæï’Ei•;¢ý5•:MoMçÀÑ÷é°ÍECé¬ ŠN¸ækÓ}ÝÅç ø\�I¬3qêPÂi¨Ïk S6\Û]»g„¢oqÌ“U8~7#Ý÷´¶ÀƒÄZ[ó¨ùÓw=ƒÈ3¦Œüi¤S6ÿ¼zJwF¬Õt£ëáƒNwñC¬tÒq¢•³;c²a%¥›i€Xÿöé<ó¼y­6 °ò03<–ÉÒh«†wy)i’W­Ò鶘™`·ù¸±P‰S#Ji¨è3Aù©ˆºé@ Æ̧üõ‡IžA,Ò:—¤Ìö¿ßì"Í<7:3§0÷Ë_Üã"jN0 ±P;¨l cÚƒ‡®YRŸ¨Li7à]j0k÷L ^ï¾{šú‚t?Ò¥<B…SCm›Fc9åO×Mÿ›ýuT¨özaœÆ–Vët}œ_Ãj›ææX^×$±iI‘ùN !ŒlЈkÎf±Çö™*ƒËlh∠H)àê0ÑZÚPV8ÃárÇA3ý>1o8�óÎJ™?à¿ ôH&Oûgs‚ÜÉnT8ý€5¼Ö¿˜YxN1¿’pr‚Z¹IÛžb‚¸å©sÂ4̸zÒ&ó—¶Ï';Bú”¢#¹¤œ[pFÌ·žVEîY®®+ ZMU‡ÐeH‚ÄY¬MZŸbˆå¢VŠ O`þiÈ4ûžB}6LXc¦@©pÙc½ãšûyl]L"åX]þ°ûÉ›áͧÑ[(¿D¹'ûÈuÖu,ó´µâ�¢ßö§ß—1L£ˆiEYŒtU óQŠÅKí M*ÙŽvª ©{¤úÊÏuþn2På>[œþ|98Nºkʽ4Ív÷ÏŒÏ423](1°N‚ÜJi ÿ>îyBê„É6ê*,¯|m¤1ÄJ(>`Cuùr”¹-ÊK—O;�ù7,ùbDf‡7è„ôçP–×Z˜}z£ÈÝÌS“nô½½›oï íÅN¨8g…‚¶Ñ’v´i<žBN«•µ,h[(ŠÃíàáÂ�%-™˜ÖÑÖÖ½ïЪpÈ aNiŸÎfÜ‚ÃqHÓšxÐÿ`ælI_ÓÅꋨC„>9å’ÃÙŸ«ØdU|6¶®)îu‹ÜuS"Žßõ…ÇkAšÞÖ+‰Í+oO7{žVnÆe¦=ÏMíÆ8ŽG'¯â—sÓ`T%„ž*Ò»?>Ñ"ž9W¦êbÞú|P'W7Ö=SFŒ¿àÊÁäû%W¹õÂòÛ+_ç“"7§†JÜ:|Ç‚{…–Rø–Ù<ì\Ðf*,è)EfšXeXíR¯Q"¼aêÙI•õù¦œŽ>Ô寎óJöjÛ°'(¸¦Ûí(ÇTøwÎ{qnݼ×îA“Ý{@ª™ª�ÞÍø¨Šé ®_|¹×ÊD–Z™ÿZ•Zk„¬¾+¥ßw¥Çsêc'‰Xßw X¦Á‡a:ófD½üÿ}«ÏL·X6~:v«Š“Jø•´{ ;ÚaטýÑS"â^ÁT‹{]Ç„‘±ž|Á œ¦Hÿž£Åa|ãk¸i¨®í'Š(º=@±r–¸ü!Ì­x¹åì÷r#Ø.tðlßM£oÜÝÈXìèéŒ:Ÿ^ðRÁ‡àŠÆö¥âÔz²Ð<Óªl5�RJ%¢4Bså1°OÅøÞw•|Ì9-šA»iÈ)(½a,âN‚פ=©%g¶ôÐÛ!É‚Ò*(S}`¨Û ö Ì¿nûØØÜxJFªÊÅšê”ÆèËt†‰Li¨;HW|¡Û^âoÏRé^¡X<5¢BÙ`Œa^ˆ,Ói?¾®|ëÇ4N1†%£å»7±×ôKjý##oõTƉÕ7ÒÎCôm /y™ŒAØˉϸ„Ü n“ÕÀ ÅKg°tN9 úÙÊFsñ(4"¤§꿶æó�„·s„1XÒÛ—‡×#+Üo~U•û r˜Ž<÷Ð>7W1õ Â^#â5­Ã¼Zu8Ê ïaÂ8oM8\5T>AßÃË©*b{^¦î‹q7¯ž²@iÌz㥵؂?ØVú‰`•Öl%eÝí^›ç¤fôfþéèÎ<goΖ� ÔÚt©û«ê&z×ÏÏó,5½aU•�¶ÆA|­õŒ]‹œåG`%L¬®ŸÍTDJ!Ž!Äç¶jTö9ê¢6̱n´ÿõGUé$_™ PÝ£àT®b8Lê¡þÏ[¥É)¼sNÂá/ÄVß5ÆyÇD™‡xÙÔ"Âˤc•‚-k­:Â3g«?˜Z¬g»t:w-(zÈ¡=jüÙ.â\ßM?�¢Ä–ÉO ¶’Í\QZƒìÝé ¶wâ¯ñÅ K¨j{­‚ê]µw¢ ÑÈŒÙ]eŸZ`^1Y“<©²3¦A6xìòÏ3Fp{…1ô忇á¿[´Èa´þí' 7DãÓtý<Î#f»­‘ˆ�žLÐÖ�üÂvhî÷á~°¼I=)•ŠEl0b<Û> &rØMúß#}\´€7àà¹SX¿¨Ã]}G»×¥uÓÒáÙPYhîû³'‡è³~Ås£Ð,$‘ÆÝ)yªhú—VQqÿy£[åÌ iQà€§ƒ³¯g‡~zñŽå+2WÎEÆCÓyÃ4çT1˜‚Ýœ�MÑIïÖjò’••/HIA¦)‚¨½r09ea±°Í1J§‘ÃḴWÓ¡¡¨ªo¾6BÔ6»ZìOqPØ1W’‰ÜÙÖ©vЦrྞènsƒ‘Îãóñï0Jç–øqƒ^Ÿíú1 mÒ™o­˜fA­f¿…ßäÏrzz÷¬xw|²üÒa¹òûê¸ÅUž- ŽñùC­ôâ_ï¤8©(2D»”OGwÙ ˆb‰;µèvK?èuËJ­ +µihM,vaÜ}ê»Zù³êá…ä SXwõÆíô¶fmû?õŒF-Áy×Ó¯H>U¢öp<yâhF«fè$“8ýü¸?"Í3†ã­þË3à¬ÿ„‰¤õµŸ O|½poæIyáÚÚ¥ø7ÐÇÎö_œYHL�-'šÑ ëÍ NÆ8ÈûFqœZø…<ãLº‹÷ÆÓBÙÐá5Z“ë®?|ÍH„üKÓÚ¢{X#áò½ÃÌCüQÔjöð…Ô))º¯È ™M`FƒH=Ít÷‘í§bsÏ6[YXóÀ�ë¦é®¿±tøÏHiìff6çh÷f¢íëàñŽÝ—Up—n¨óDæYó$jŒ–¿:>¾ú˜s©�’5ƒˆ?6† –˜'Í {å†ë2ˆç§q:Ñ!ï±ËÿE`3*5’qr4(SçÆ$ÐÜ,�V’έ÷^<¢b3ȳ:ä›}šÕT;C!ΛÍ=3’ƒ¢ÛwO¾/‰Wò}´dj„j«æôOh·ËÜ4oï.(«…Šˆû‡›³¤ˆÜQ¦Yp©iÅ;³{!ás¼ªíºa™ð …¨e ݽ´4NE¹% £�„dí2Ìîé¨ë¤çC»õÄ·yÜ à]w»ÃÔÓy¸9UŠ4[»ÁmöE4{Ow##}q“Zpþòº¥èc�èÞ¥¡Î8O²XÐ@ù¬ÿD¼ù>ΫÍùh‹†7&g›-­ˆloýí½D±è²—éW³wÁ„ýuz[®íöÐß~ ­4p“tìé‰Mzø”?nÝbùÓ¬ˆñ‚tW’D¾a7xÙ'$Í_ï“×Ww¬ŠŸá?ý4Éâ¸ðÕÀ‚¢NN[Æp©MµðA).V ¨0 Ú+m6_Ê‚olç,gœyïÓY÷îiÕܺÀ%>ƈ57xL—O³“˜õð#Œh{áQ9·7|†! òOuçN@‡µm2϶ÂôO^¸¶ë±(V>!UÐÌeN[sŠ6nÍz÷dü í6KFˆcR)~ž\¸çÎŒ‰V㥟Å!—b¨Î¶¹ÁBÏÇp‰¾ýÀÓÃÖ'e-Ð O-+>HÜ„ò 6 *DcŽz·»óD;<õ, °)Œ wcǨ!?ê£!þ<Pò®b§ ÁL‹#Ü%£Oû6eªh“høð2©ÆÍwV~„êÜ õãcâùyäF=IDiå¬ÇYʬönšà®öƒq}ìO^Ôþ¶¤b,™,~uÄ À ¾³²ºØ\›ïG:?ÛÎÈuN¦¡`oM¸âÐG"0SÖZÔж¥ƒ¡i+ÔË#Y;å°Íœ¤A9)Ñfæâ8`æv<Ú‰Jç?T-üßdña°|Rp²–”ë}@Qmœ#ÚY<ç—¤Q~§“m)ðìÒyžRÕdð]`éiæB&Ûþ9=]§ª®¼,Þ|ÓÒA˜Õ;Ï Y:È Ü®Å«•nÁé(½EÇFÂ3‰p# k%aÐ{']êYg ÅA¿mÜ1Q’‚ÿè|æ)qRê; ú½‘^+ yN=¯èô›%óJÿÔÈ|VbKÂﾑâ‹aI rÃÎ*ç4>:7AyVAEyì4%ÒÆeP¶ªvñç0íÃÁSèŽ�iëÜpƒ®Ž,T¹VÒq[ 5 ü}]q¯U}Â'-S.´A §ªKÓû3̹Ü㻄¾!ÏHaa_{¸[ÏÖ²*ÒÜ eB¹=l ©¬rÖ$ ©˜Ÿiq÷g'È…e$“  ÷JVÄ>îëi*})AoQÝDQÎ]ÝA.y–Ä‚Æ:ZjW­™j‰þÎÙ"﹩>öUµú©B eÖeéIZÞ ¶ve Î6çƒ/þöÀ'Ì û 4ÜÙ]Ÿé¶1Izýs}: @ŸÙ¹#&S,Jlcßã†T1õýeˆ´Ÿ¨êݾk>Ô¬ÜÔC*:@eJ·ÞêV °2[ùKU¨µ(U¯U B þ¨èØÀ]=.¶¢,wôÄH°õTN·–ŽVb´rè…ØkÐ#?£ë£<O­š@ăˆ®@ý»©á( ñqÓ¾M®‚%KM[.ÐOÆZÖ5Å ÑÁš-÷³Ë´ü,âž ù7iòÒƒåç¢Ú#Õ[6½5ëYpG¯ “T-H„áÑ°„zÀgçÈ@ÚÏr9Ão$"ŠIdEŒ©VaÎæ®Ñ> (´Ã=¦6~ӵЪØXÕ6mFÙ‰–,…hà˜ÏŽØ÷ºDSšfNnàÇ{ RñçÕ¬�—ê/kC,Ê—úú¶0ÍÖ”ð$è:Ì;u0J ßÛ­ rI1Ū±Î.¶þ— ,߬¨¢ÂñtÄp‚,Jã3ƒNè2ÿ^Aê=5äÇîIæî<k3h.Ùy!±]2(úëÎh uYƒ?¨–Ë€á pL›Z­Á V·Ò)óì±_S©Yá¦ØõÎwð®èmSx¾t¾ ¿j*À2‹Üž¾êá΄_‚kè°vµk6ÝÐѲ4™=¸†;ÓO’i5:´ÈÈõgzÇúìñÝ�šÌ£ìÏœ(}ûê™p„¢ì‡]T“•¾×Þp6TøŸñ¨Æ2&i'»U»Œæ”‹Ã}¥%‘Ï‚ÀCEeåbçfFèn†Pš®ß[;F*Àˆg€†*Ⱦ/);‰k¼‰S '>­¾ŒœI<YÕZ@‘¨¸”Aù½Ü„°·Mo[,w—Ã|Ÿ…•V7NÃDw­<[«DQÞâÁ+ ™i-UŒb(õL{=ËVêà(.tê%µb, ‘t¯í³‚ñ‚‹ƒ0ˆYUÒ½è;V1btBÖcd’pAì«@¬ž«„Faìˆ )#*Rú¼ýÖ­yÉ­mmãμ:Íñã&"ö›5ƒ,É<þ¯…M:ìn …M+÷ººÅBtÛí+¶ÃÜßKðÓÜß°¨«Qî|:�©:1jWçÜ›’ê‘z”M ©jX##<ÜÉòÀRb Põ•=¸¯xi}WuçÖûðŒyÑ ¥Šµe ù×w(ò ˆÔæ¨+¸Íx-Ù§Gæß7)v×Þš ½€žHÒ¿8¥Tþ/EZéVl0“½ ØÅ ¼Î=SN“H©ëëZÑ& }Ácº3— ü‹g){“=Hë¬ „™ ü²šyŽ‡…#©»º\7{ž&Ë@¢Ðw# ‹ ÝSn67–w;®ÝÛS5´Dï0w ç™0Ùä³ÊzcU-‰RÅeïè_´¹žJà ŠÛ;~ ‹ªm¥WßvjF¾É:¥=øž Dc¶ñÕ«V$Æb…‹bè±é=ù‹u <ïÊÌ^égAV/*ò ‰È«8™Á­8d®gš;W@nHû¶ ª÷¿Vç+òô]M7qs˜ùŽ¾(“[š9‹˜]ÀU¨ÆÀZv±ê„hÏòsßñäÅTì¦\Ÿ9Û¨·'Z›‡~áÁØžª·°Q“IhN îÒY€Ü[ú„œÜ=Õ2‰èÄ+Ü_À@³#ÅÞjo}¦¡-mÁ3r“ÎÓq¾1þyŽò¤¸e´ ðVh; €£®f¢¿o9×XÜOqPõÝdKÄf5Ïu0¤ƒ;W~Àù%rÈd›i¤¦ïê†\oW³šÒu~…ã¯J'ð˃¤vɹø°“tõRDJn¹Ø‹»³‡.Œ½Ï²…"•'uÌ‘ž[«˜rk2½t’\R1ýA¸yñ�ÞFà m*dÊËÎ;¦y Àí+ÁEQmc,ÁŸ$v²Üó¬NY½}Î)$~:9%êh&3a†vçwõíDÏ|š² K$Ïlhz žÚþ"püÈ‹%Ž|øKƒ‰î¹%ÔÃIaPâ¨$ا·úl(ÇÏ4[� =ç[ZGÜî誻†~ü¡Êe¤”Á/»N Þ•?qƒ XȨSr3½…è­ñΑ¢£½\?=†(Ä™7ÍN¥H¤7}¯M¤b„##¢Zk-䀠?†>S(z‡ÅIéa1D²€3_êÝÙÊZq-§ñð‡ÊÎÊfÉ1<e,Që“ÙLǤ:Qœ> ;ì¡7gíÌÃמmWϞȕ’kÌÿ¢ÞnæÕJ<é¿ü¡Œnß¹î­oÿ²¥ÿÚ2 ^'‰®Ü–ø”`FØ\´þgeèöle5þ'ö…C˜ŠI-‚ndíÎ+^i†XxÀ`­sÁE{KõÛ«ÁÙi£D~a¥­Ùñ'ËŸk–H7S¼5²#"bÉ/˜·ÈXÖ“–O+¿¢:îAȲ3×®¥²KŠÇTtêmç±xKx— DÎãd¬ú~ú±©xB-”ºV´jU#0J ªá?]è>¯æk”¶cÚ+ _ñ‹ËÂï5ÇÐ Ì<æ%e>0éZ ©úã`%àÐ!-ˆK|×aAù§ýÃÊŠéý7ç‹ŸÉ“ÜA¦‘oVÁpgœ>¯Ø¸ÝÔà«Í‡¿²Þ^ô›´R¡aÓíÎ,Yù=€¤ëÉRÙƒÝH5à‘-Uë?Æêj‘ቼÑ/«œƒŽ÷6íFuÀÖèq9{òe2ZV†ž‘!Ʀ=åKcöwª¿`aЃºWMçg½çØ#º ë~Bi.Êj}ûÖʧ¾êb®AÕC¸6"¶]‘zSÏ#M‘{€kªvÍ¿¾¬”åqf!4ðÚ¢dM¤ ñ»Ž’:éy?_ $ê[è¡ ‚¼«êañ>{6[f8Ïš¨ú wOç½Y‘G€µýöSÈvzëØ:À‚i²¯|a?ìŠÃß �“•ªe%g€Œ§V4ÛÓÇã­Î^µ;‹=YÄ ŒOþz¢$ÜØ¥ˆ&ú–—zYfix)í>Ó+òÞ=2ô©£¿%ß»\Ú¼ãÅ*Ù3éôT ,ømèÆ.)Ã"V¶HU8íRn©nþÐÃßn="þð·]7Nô_ÙFÒØã-˜;öã4,óÌQp› ˆ{VY2Sàãª-/®Åï²Z œ‰ü› X^xzñLí´ûZ§¤ ‹R&,¿» ³R6^á—‡vWYäiõ¡ãØZ²ai„‰ÔÄ»k) ×È–55ð¬På:C騜˜ž¬0vµß¿{Âá=*ú¹µÂË8.üXT}@ò‘s`O`VÜX…nê,ç%˜û:Øcôu1º"óLY¶PÖÓ—7>ÓŠGBI[ïä™Ó¯äuÇõ¥þðûyúÃxªVè`̯XŸ*E_ΜƎƒ÷ÿÄ%ºˆíÎÅõãš Ÿ‹'à|ÒͯŠîÌHðæ•™ZÒBM·lÙ¦A¼ÓjŽ;Ò”‘wC0kIkÚ‡µmBÿ/N쨈J·¸¨iòHM`Ÿv‹9¯Ðânžwfž£]¶¹à©~v (ŒÚ´„XƒC?�pɛػ¤äm'½3øW©•öZÜ…N½½œÉ%û¿É꺺¿+ñäzý©Q±f‰¸¤ö-ÌNÝP« ïKÙ‘&=lŠþUÿå齞5Ë䢥lÈÜâÏå~²e¾Ï}Éã2ôz5LŸ;:ÏjäB©g©"'6÷áøßQmsŠ "l²™’ [¬Å,ƒÉøÖ¦Á"öÍ`³64‡KBÿ˜ŠA0Dï}Û™DZýÓðöçÐ]ìt©FÉŸ–›ä8¥a͜˕„Éo¿õ”¥}`…"ùI»ŸÀöñm´ú¢û±oºEì©fõ?i=GÙ›"ͪ@gFËm?ÑŸaYá1CÞvô}½Ñ€¢8•'RëŸÃîÎÍ}… ï`¿¼µ†ÂhÏ\±ÒÏSÏZ0FGÂÊþ~…R£¤e`”»È·Ž¦ÏøÅ{Ÿ;%¬vÅ:]‘ɹ]Ê ýîe®ÖZå”èYнßyB�V] ÒyÜàÅ»üöÑm“Ǫ¤ Sdý_o4ÝôáÐ$Oç¾ij½â …éDÙ¼+!$aÌZo(9OGQe¾çtF'l ¬ñ-+dm1ì°  zV 6ý‘½›§ßy^¦‘PCª ƒ!Ä—Jk€bFŸòÍ3ÕfšS2 }a0 ¤ÖM<Ú8ý6¿<ÕâÊŒJœ ´¿g+'¢=*\SMô^ÚÐ~å4É“•íðttóöŠ§Ct¦#b`܈Ïït^_üÙmgÌBªð²eß~J™Ih<Mfj´÷VÔ¿Ýß�kah©¦â ²ÌeP-¶FŒÌïœÅ¥è;OÓ@9-çÆp¸ž|ç U4%9M”Ͻ¿«Ø>ó‹[ÇÇ®½F…ÌšîÎœ2^ËgÝfKµtjëhHqî;ºMšŸÚöŽkø¸»LLÝõõ‘*‰z°vE*SŠKÞûò×[\8o¡cÒ´$¶¡!ÎfÀ”:q™\}ê<ôE X’,Eç˃¨"9“ ±íy ùaS2|ØgŽAyj±(âß1ì(Á*ºÞfK‘Ì©Uj­Ô2––FëªNXÝá¦ówÕž´´‰¡ ˆzø¦E§½­ž0ŽÃÿ¾«[Py"[ÉÃÞ~ÑI´,°zè;³‡ŒçOe:îsýëžs„šÔøoÆ„³R‡3ŸÎíÌmΞ»^¥*¹†½;cšUz£íø%DN3nìÀs?8'à„Æ`ÒlvSe+ÚFIÙ=akvÈCwåç{½¶µª­i4þüC„Šì†ÜÐ),V2âAÅÓ·°ÂÃHC)åí¥¹b†Ö•ññ›Ž}‹¢saˆ¸PŒ� •o?Û\}9wïRÝ[+é<Æ{yøôÒÊflAJ´Ÿ>ô¬•ËÈk”æ~  ¾£Û2t  /¹+b¦N0‡°Î‰Òƒâ; Q‘øH €fúÜÕ®ñ êiªex1æ¡îÓPfBØÉ\^ØÔŽ‡«Ã'®¿ÿ¤©?¬w•f)w^£–…¾­1Å€¦¯‚l?û°7dµr´0úÁ—,öÛ2¹œíàüí}]·3Õ½|ôòJèè8Ï=ë[×AÙP¢¦êîpwm¬˜OeÏYPÚ™G‘I>½j. ¨Í›°º«ÿ²ÑÌûë±û¦zmÅT"£S:aÚ)ZB+å|:¡›¬ M5á½u¯|bcé÷²ŒÏÍälCMig€×ÕWH2OD)âT:ˆ‰*‹D/CÑó}qá—žc™ªÄ€q½‡ŽVx©=ª ê‰=eAÃÓ^1MðNG4Ž×O¸x:CMbÒ€™VhioÚ†ÜPßDG÷þÃzú%½ås“ù¤óÇË«íöðva¬ßûåaÏÀci\Q:Ó–ð`åì·X]¹×\+Õš!†ãÆ‚‰Ý*̦¦Y%ùŽHoSÖ¼p¯ûßl@˜£™­Å¶ŒœÊZé¦@« ‹gˆ¦üæ_±VRÀ¢JPWfAèk Ï¥@3c1Ör‹�5ljºÊ±’5 sÌQ‡cÛœé>® ÷ZAŒ{ƒýüfkfž”[,Ÿªw}k°äÏS;ªë¯!>Y‹\ ÙÑK›vidmí°g¦]4+3t@Ê/åÕ‡-´¾_†o¼£Òo=Ôâ &ôEÆN¹ïéYÒ¨ƒ_ÔãƒØ Ò§&’7…×ýä 75Å=…nbéI í,m/¾ÍŸBÿˆ�hÏÔö¼mêظ×ÕÉñ®(®âDþ/ÒÎÿ.Êx¿K$ÅJX)Z™–­5G)-xðÚ3¤êQ¿öÖ=T€é½Cô&è¼)&Ÿ  ò9€§š¬Ñ:ѪéXåøyå^Àµ×p©‚ü³vâ@ä/Œ¾“{ãŠ-#ŒïmÀl%j pÙŽö0ÛÖBÂŽ•øÝÁäÂb¼¿°•Ž,…ÆÚO”FV‹VÈ`´é('1ŽOa¦>ÿÖeIe•y}^@ Ð"¶Î4­G§’7RUÙ ³—ÎþÐ;9Œ3¨Î ÐÙ´ñmµ_å¼ ´¼XU sù\ŠdùpJ`ìw²¤çÚ3W¶š¼ó[Æå.èçœ=p;ºþ1Žaðr´c ä­ox¡þ[îâ_ãÈ _†fAmŽ”˜&´Ãl ªÚ—Q}z:öÿûÿ€;5 &W~ÃÈzkÿ,©q°Ù‚Ôþõœ Y¼KÆI:g½zF2!OsÖ‡í»*ŒoDeŒ5ùy0ãõ‹·µô®iÀ* À—ì `rÓ|ë©"ƒ‰Ìf&Xphõ™ÏÍDŒæ ûU84PÜ_‡gÞ5Ñÿe©Gû* Ȉù¬¤£´lnøô?#Iœù·a[’ k>°ŒjÛx}UÃWå <ÆêH-þ“5Á`•ÎPµ"8¾.ëeï‹À¦¡òB‹³œÅ9fv;^˜L§ò/ZyU¡×c5è½¾ŸÕ7í™ÃŸõÒk^Ý^ÜWf‰<@³pÅkJ?mË$»×óÇ‚Ô"lkzà•„¾fyÛ4¥²Ý¢ô3#ˆMqR?<}Ý\<`[hEO{z(mýÆ?~C]vïGêyd+㈳4Hû­åNû"£÷|õf_šw^&:¢÷Á·ë£ªš-Úr Unz²³»¸;çó@J¬B6È°së@Ø' ¥ˆŒ°Ÿt2Ž[»÷Ò6ÝDKt³‡€×ç§WË7U¹ÝÊÉ`f‡yù7„þXí0éØ ßõ``Lå¾¾`Sñ§•ˆ©’ñ9ôå®P¼‚у§i°7gF‹PÒ«+æ–Ì…/B èG³VöUfa¦F·úÒEÄ&"µn=»WŠ¶­Ï]}ò1#‡5+ ûcZé^³Xt5ª™UKq\¸ U_$¸@’w:Ãõصހ5Ën8™"z=tžb÷V¦¥ÆÖý‘æµ¾šÔÏ:€Ãž»GÔ½ªrÞ“U)d ø@Ü …]ò± Y½õ\.Úñ ³ìpc¥Ëµ°–Xª¼ +™#¶<*:¦'TþP³<KWrˆ”ÕËM@%½¦ÉE{Ñ?mŒÆúå;þLÏ4Æh¯YÌ'3¤KªFôÄœ&îtûSî#?t™Ïn 4.bña’ÛxÃo´�1ÊHÆ7Î_¿ÉXùs"oÏý]XM^†žè62Ý¢²UÁ«¶>ÌWv`1Ó©794Ïa4ß^?:•„€7·…­¹ò¤8O¨ŸºÓu~Qß'^§·Iî¬�GnÄ£c 2ÐNþÒ°oÔb ïþÄP{tÐʤàm‘ê¤7`ÆF}ë»ZÌv ŸàÂz{{I¡=Œ¥»|˜Úw­ŒÜÛ4�ËL.ZZov±.dÍ�WŒÓ8-¹éIæ‹1†É&¥åf‰Ž˜MþØ&*<¯€è‚aG»ñd…7˜b‰\ø�`m €ž½YdXŽóžu˜Cû ‡bd|muä²²ëR8RâÖ2ÉÆÆd%Þç HÇ;-Üɾ¦o{í¨Ûh;‚1or✾ë£SܺêòFtڡĪV8n›KŸÙLgXߟs± 7‚ñ¾YÝÅIºÒŧõ]•AÕŸ=!vè„0ªÄ‚ [@£ï\|×…HÕkt•gÏãyé¾XòDý2ÿó–DµAï”Øð A—$ ³Þ§? åÇñ*’C'ogµ¸)cS⚣ö�v¼’Å[ÖÓVÚ/å`ì‹BÎÞ 9às\Z–¹*ßw ‡Ð›÷=üü |ú–#;ç ä€q’Îé8�ðà%¿³‰¼+U>çߨù÷ Q´òLC‡_ì´éS·ÇÃT÷Ëõ+Ò ÍndÖqÐÏRÝ¿Œ<çT%`ÎKä'½{ybì3ÆÞvliSŒë ò£c4$ïÕ,†ó;9¸ng4n+¦†¯²YŠ luh½:¶:²3,èÿ+‡oeÈã2sÃD€!–hçÉkPå Á)kYïá ï]9 b”:elÁ]àùVÔ_žG0+U@Ÿß"åŽ „fî»ÊV>dLÃáäncý!ù¦•‰}4cŒŠÈJ.ˆlÏe(‚x’ÖnÌQâD`^¬néAPU¬ üÅÝMUªr·ÌÒà b töw³ §®¦ˆ¢Ìƒ2ˆpãé!g_ýÒÒUl?üÀ€f¶îéŠ s…§t¾Ù£Î´p�¸ê‹e•Ø<< æc”ï[×╽Òõ‡¿5|3gçÛq„wùˆ&éÆõ‰ÚRÂ>¦­•Z" '5àmÖi{ª[cÎäÝóÇÚ2vΔœ¨Ž˜©”êj.çikfÐ_¦ãfU3Z$Ýê»ç}†ÒkųTÈA‰õñœ˜× múe9ÞwML㵜`,˜´[[¶ˆ™î¼aÞ°çm}þýâ9ã#ç,óêúžJ…¢U»ð›áXO¶9ÂYB½\ïªí††ö†Šyßx(WV9âæ`GO"·$€ÏÃå0ÜmZ<‘µ†™ÝW¤'ëº"†g‹Ç¶é¾$„ÛW6mg¡H+©Æ’Fh#~™54ÖXΰêEvYy‹¾iÍ,(–ÆÄù° Pç–NÒ^Ÿ¸Uï“! Ã@'SeL1^oÏvé9©{WwŽÖx]П –%ï]¶üc{ýµĚ¹i«‘èiîggN€Ö Pm³u”…ÀS§€GþI±âH²;_䃞SÜÑdç¸=¼%÷1®P¨_•K*ŒßNûù7ßôïã•yAq²ÄíJz;§ºÅ<”ÚÛ-;ŸéÅ][j}I1¢CM·*ä[U%<\OÕI7¿¶Z#›^äÜ‘vBZw–>J!úre.If# W.öÞ© Êýä;©²šOÝç'G\ß"3gëì=íÚâìO5æåÀCCkô¶lÃIàfª/Œà4¯7FmE±’„RE°NÉ*yÎé·@äþ'gë2öýŽ%ÀoR½™]7tjõŠIµVGîDô6 =΢¬òÏ*JC–j¹iç¹ZðhT†M?/1s×ÿ¤ ì§t°›(Äh33Õ­Øv¦òé–½ûjûÅfɱˆR@‰‡ÂHxVT2ÂàFˆ"L¹â�¤`7M¾¿_¸ƒ­Zñy£ èaâ`öHXÅ:R µ*ä\\#dÔíù[o­È¼ƒÈÎ}G+íf$˜'@°QG+L”ûþ©FgäÛBXù êóƒ‡  õŠÝ8¨#¼…’NgHÍ–¦ø`s;«—¾ÔPKPa¦VŸÓÊÃ2r?½PE¿ TøÆÖ‘®!û/ŒÔ¨âØ 2¹Ø8M´e|±-)½”= 02­×ž‡ ¬MC䦃žU™Ã–†q0÷ô”­r:|¥ ø(ƒÍŒÇ¢âñgQ¦ØIæëoYüNbEÄ2pvŸÞhëuggW ä¿Šß´ôÜHPÔô§e‹ß-YÆ“Ü8Ñr«§æ+ƒweÏãï³æ2ô;=Hý ²Vôªüåfþ@]uã�{$»ã_K`WÅfÚý´¬é"º,øjÅ6A8û¾©¯Js©ˆÛ×õöÌËlíMIEmÆm<ýÃqj]pXQ•;!Ñüè&tª×¾µá*~TT¢¤Aj-tú++zÑÝ·jNÅTJö”ZEþ'¯ØSd%š ÖIÉevc2u»X)YË9:µ­¯òô;Ý”²ZMÓEK> 2;Mç¬gÜ9qàvd{Œ”‘OólÍ'n(pNžhõyÒ¬³Ð�¹Á³óyfìãL¸C#FÖÏe׶Ø0ÚíÞ°_uò”@àÌSîST”ÐnŽ,(,3´ÕsÛÕç/̓øàºZä&*cßrƒ‘6l©1ƒ²Ã,´à‹çn‘º'Ä(˜ŽÕÒV¯</32Ï*`rè‚Þºð| _q+š”…­YŒRâ± ·¶¢Ô´Gù¶ÚNd£å͸QÚj3QfGÍ×G¿£”^ä~Óz;3H» •Ü^YÂô»öçégƒËÌ¥lø Š O)Q¶Ô½‚×…}OZ‚tàNÓq†ŠœuÐ#gÍÃ)\žÆ¶‡]NK¤sÄæÝv:“G3s‹‡îrŸûû‘�640u†’TCÿ…-äþ÷þeâó]ä4i-%uo¹+`}¸£xíT—"¦´žŸ¬£¬¼Ñ¶mk*}£E›¾GÀ­ûúºJ; é–‚^k'Ü» šî«¿Û‡Ïï‘¥g†‰þŠ²× Jþ4[j3µØ†žö2/wS'†ý³gvjž¾Ôö´Ñ-;WÞÕtk®cœùÞ5pÔÓŸ¹{S£�ºõø?§“tx¿u©¢„îGiǵ!|'Nåtfæ…Am“ÂàXBŒÙÔˆd8 5yy½ú¿ e¿ãGš0‹(±g.l)Ln2á¨|,�<¨Õ àVÔ©£wˆ÷ª,úYÈf¯ˆá3>¥LSfïå"—Î¥C¢Àþ´^; §NDÀØë‹ó&Ó‘ÚS,àï•Øðª‚JTºš”Õö'H,h'!2™¡q“ö_„ZŠÊ·Ëbü)4”XÁêj{Ô½”]™¼çJN”ùu!7î(¬£ ¶J„2‡aºÓWõ/¹=ì,qE]t7hI¥ÃÖSiø8œ¸î7‘Œÿô½g¿6Nj¡pOy×50EŠ<ƒ±WÁ,&ÄW‚šñh1'zï п‡YOÖ;?z|ÛóâÊŠ¹íàáœ#]¶l‡ Hù³ñµüI>7­V³Ê.”˶ïú�rÎ øÇäš«¶ì#òGa$[-ïHµYzÖyôf~µkb �@'͆뜤ÑjΈÆá”á»Â!ëåFÍŒMùÏ[‘Ë/NÓµ÷ô8ÌJ€~ßý3 RéõçèkªÛ^@•nÒ~U.¡špØŠ¨@­)æM‘™dëyÜ<¦à“Úù÷¯øYÚe<ö^ö”Ò¡7cZz«ÎãHöÏ—íd�œ…A¡2W˜Ÿöo§-Þd’+“%ªvvÂÂ2 Ò;òŒ´èñ°9Ñn¯iPÎ*Bww¨—ýYßi9ˆ^ü#™ÅÈ×Ñá÷kœ}µÅ,¡þ0“ • Up}ÇõU4`~ߢà2_î‚þhÆl§ÖPµ9úš\k x¸ý¯`î4\ùDt2Sê¦^¾´SDëx:s²¸¬èFýlçËÐäiŒœïTž‰3nNq@/B„œ5ue¼;`0¿_¬Iêd)”‰ÔC¯{RĆ2gŽÓÏý†â*Î|‰•2Øõç>}½:ñï2ÝXó<tè‰óÐ÷Òc°>-E»u5†©'î œë ãbœ¾—(±'ÐËY«/'Š¶éÝÊÉ(¯zIKÜS Eô{y,ä …‡áhÃjpÁ.â�  —ß~À7ž2—Gß›ÊÈ9bbAÕ ú‹¢é±8ëÓÁd[‹m^+!Ïvûžþ£‡¶ï.0fÇŒž‰ý•ø[Çúƒ ü;7`Ñ™­gw úﻥ©¡6”Áås5“f¤LCÞ7 ›-:Ò¿PXõ!<‹GÃ!ë,g¬`mv?^Ïÿ£h›êäFœ¼û‚›…廞Ý$Ö–Ò3Gdý¥²Ÿw‡§Ñ í³hdöiÖ )3¤Êp¦0¯ –Bï³3qe.‚ô¢) @ü””|ió…»Ó:$]«þôO�iV¦ò\#´wžëç²?ÌŒ °ŽQgàÞxx7ðŽ¸y5“Å(ÃpwŠºV‰ÀœÝ¬R¿_ös ý¤‘ö9›¡ÇŸÚŠ8QšÉì,´•6×é l—ŒÐ£ØrHK3œúXhñ„Ó_ûñ¼ÓTó#à혱té®&)íúc³ÊþÏÇH² èØG‘'ð[±ŸÓК˜ú÷R©k $,fÿ?ánr};*NhØs±AE}ùú\P(Êœ¡>r¥ªbÞµ}Îðy òö.ÃÀó=£M ­zKºíZ~Û@æE´2r€̨ƒvOEÞ¬XÚŒq B,צÿéoNýÿáOþÛwÿUW2+ÇTf«¹/ÕSÛœV~}re¥Q«Á¡»§Ó¿•ÿ•¶Ò·œRÍýŸÒ_Vf„‰Î:¼79Cc;YG«Vç ïÏÀïn DÕ\gÊv;ë6B[wšMyù{ EyÚ&âÅBË3;éôt©O³Y‰ôƒ+%åÜÄä•Û×'ʺ‹\~è«× v‡±tÓD,îdÀXl­!‡‡9ÌTCòù•í®ä®sÉÖÌ°¿M¿.ú¤er6ÁÕ±™!}Àâ&?9ߦqæU‘™Ê¤ïWoZÂÒbþÿù�Æeò‰i¿a ŸZåçþ|¤\b½-=mߺê£æ_˜IéE(V&™û"ˆNGÒ§LÛ%Ça—ú°ÈwÍïL)æðNç.H$ʪ@MúZ-¹;Zè¨"ïÐëVyo^z¨m–©ÙŸ�Ò®ÈDo'ðúÕšqëMö”yÛp’m •]Á;ý§Êã2–ùÜ[ˆZfªJ,—ùÄâ>Ô"óù’\IvTlkÓ?È S·G’¶óljUÁÿ¥¶……™º  HçÚÚˆ^çHtëràqU¯ü)h±/Sû«#àv³Mz(Ý  Ègú_ž§ñ.ð5r@íØ�¢æKôTÝ_EXiÈñ2´”ºÝ%E¶½È|½:˜Aß°üDÝ3pÂÇjÿ¨phf§ŠßÃvtþ÷–¨³ºZe0ãøñˆ¶iˆ ÕŠvÊO 1yµ¶®òœu^1Ù±–"B+¼h½DË`WxÄ»æQ›ó FsáŽÂÈêG‘a ymÈ°ó©¡?B²]ŽžÛŒËÍõS³FWÜGêþä^ÛùÎ$ð9»Ì—x£®šH)ßiŒƒòÝ2d2žæ¨K©™Ô!„Ô—ŸQöÐ+Í\‹»L¸RªVΊMMãÀ‹Læ�É g†æ*eéÍ÷wp7Q\e¾’37¹éìµwØU~lIiG09ØÖžÔö›ö¹}³êµÑlbé/°¥#p“½Çñ�IRÈ¿dë:A•r4C ¿£“Ýa™™ß»Áï+TÏ,óÚ´L€†Í†wOY©=Ã0s¸×&þ[e¾¬À59 ӽǨé)œÿi~E ¡´>Ú:à•XT”>™¢h?Sñ8/îðfœŒSðy¡šöY9‘¥‚Îj€ îúf%?ɆŠ¸¬ô z´§¶×ÜJ q¹²½öm'SKY€'qD:Ïÿöýß'k6¡‚’d4l³¹1µœŒ�˜µ³;]Ÿ'‘grã2=ƒòö úK =¯hÍ,†oy³jàl¨©†„ÝcëÞY=e¶ÖÆg›Û¬Vv$p ÒÞåD_n O¨_r¸£•5’.%Û/Eª"‰å áæ|Ò*ů ØI�ºk»T†>…šBþþ\RØ_œÉ×Þ‹/Ýó¿õ4bO¬/½}*¸Þ5UлÚ)Þ3­Tà—gc¥VïþðÆ‘ û#f®E_{öIóuƒÂ°Óž>«¥‰<û¨ÈRÆÉ|^+=Ë™ÍMlð'Õ³` õD|áJ=µð‰xþ ŒõWÊöUòªÀa(ž~uÜ“;¢Ì=Êx†4î« šk!y¦mµ¼JÆYí2ØHl¬xK?ËÍÕ™™uA™ð‹VfÔÖ§Žݼùë¿KÚrº Ay.m™…¡ûª:+ÎÌöþRì*ÎT1@¤£Ž‚ Á*/{”ÊXÓwD¡Û‘¡YÄ×1§54h;'5ͬ•˜cÇ–{€xÖñÌtÒ™Ú«ÍFÉ鯳olzàâ�Z; ìõ|aÐ^žü«w¼kµªhë+Ñ?ʼòÐ÷Á‰Ç`ÓŒýœÅQcùŠªZät²yPˆ lÚçAõÕ¸ÈÄu;`<6/Sw`Ä"˨3•*wo¶Ìh ïÛ‚ŽœÖsä8±ƒ·œnÀX€ús %ò¢÷æÊš±7Œ{®æT;:y(3¾˜¤4gZ}0Šbc‡F·òÕ†=—×]¦èÿ × FÊUÐÿ„ÊÓýÅ›ý©A³¥€²u3¤s½ gðëÏò.9œ¨H–wW@ÚN3ŧqw`}¦¾=�[|Nån¬¿Ã€<óÝ)|,PèO^ Û4ªgæ½áÉw'*ˆä+?ÕŽG¬N`£ð%i({;Q1Yq‚D (¢&%¸ˆÞh}¿Ðp™z˜déz-ÀˆYÓ´}M…·ê%)¼Å&ÄôÀ쓺©gG‘ù³6NlÑ|ù4™'`ýùx‹S™t•õñz’ë2ÙŽèÜ$L7uì4dX²YiSûúJ+|/\Íû>Ük:z|—?Üç¼zê»"ÞhÆk8HEvÞO£iy—¡íÂËÞÇ[”&Z÷Pl'<Ûá—ˆ±QY¬šEªtZ›xÖR¨/"íÙÎ󈚄kV@&2:‘ß/…ùr®|Žíh™K°oj˜þX‘:3|[Jåû’Øó ¦%¿ Ô Žf—¨*›…Ýß5¯‹J “ ©pØʯºê¬ŠÉÉnã—zóÂÌiné>ÑVà:'a½ i´’×Ó©Â-I]këä»?âgHy‘FЛEJ*õ£'¦ÝçˆÓ@G®��W߀8pK³(s?:µ3]¿×s׊ƒ`eÍÊL'0T±L£nžê£kœÇxÌTCZcUö³§sä»·ByŒ ‹ÌÓ YÉ(¤¥®šC•ÄD’j>³ÔíHŒn‰ãêãcb¢¥ÒHâ¸F´6ô>î­ûŽïšXIÂùܬpû+R¨šHÛ�"§ŸÖxóûÒFQñ¡×å`¢4YÅ”„ Ø„‡žæW”6Bðü°L=1åêòù•?æƒ8’‚Ã_GPƒä–FS_+‘ñbÛ ñ\G¹x™vtGŠÙ}xi1]y4Й=¿`üœB#Ó¬V¶l�¢šÔ²,7‹›35+,úŠRn’ßJ2ïÎtög¶UZIüíL½im«wôÜ—ÿ‰BÖBõ›)QN§—ÎÙSÍf@\ÊôæäÜ(¶îôQ¸2WÂ@Š±œJV[έµ;ô<W:SO݈M—L–Š» Ú‹Ê1¢YÀõƒÖcÜ=à7F6(ç~CʇS9ýF”¾Ãœ.³líÖÙ U´j5˃ÿ‘ÊŠÚr)Ù)}TÎÍÙp®ÛŠ” ½:/ˆRì_¤ü‚Šiñy—ß e‘'j(‚�5¦ü25ÖÆÆ'>ÇñNT¤Glaþ¾§å“w]'ÜP.[þ˜úQà&7_ž%¶({m¶I”WuWR–jú­½­ÍthÙ\‡;>+öbåÈ ¸çë3¸Y3!Ìè¤<õŒëÓ‘ŽÀøÌàÀÎÓN3¯#ì·Þ=ÿWQ×�³GçûîwŒ<,¨Úˆ—GŒ¿”œ`¬E|7±=¦»ÓÁ£‡ÿ#Q}C£Äì« PQáIk‹ Î, LÛ÷H'•»çâ‰3Yô‡ß·“ð*»ñ™8œ(:VïkŽÀW¨‰ÅY"¢¨þþ–ý-í‚COHt1Ì  ¹2Yy-h€ä=$õË£kÏ@\DœîÝ¥A5_•zWƒf7½<šUÅìÍöP¤: öUîÚó§Ç¡s¹gndÈ4¿˜Â³0U¥È)1PQ‘AëWùX)#Ê×Øû $òÄÁ‘X3œÒcÊöxEݾªÝmå |Øò²Ùã {‹@E²ÝŸöè°Ž–AAç¯Á*oöhܶÐê0VcZ&Øœº˜ÒØÙ*òF .Z•8uðÌÝ~¶†¥‡nýJá´J3,R™´Îر&žÙÖæ¤ûÙ€¼§"RŽÙ ôäÒýÎsNõèx"¡ÂY¸ÂtïNÁ2?‘‚|È® rë“Â~pt÷h¾HöNŸÿm Âñðx¹ÿŠ Ë=2G!å"Î7EJ`iš"÷< Qã[(‰}+“ "UZÇÊBi¬‡= }¹W˜DY™d™&”ÓûYI9ørlÑá¿z7†2A4¬p«_áæ¦~Ë#„ì4,˜NVr†=~‡eFµ(õ_³Ì(.VI-y`]³÷=L6X ©›Úç9.J=‚4·8çNnŒ†«±Oð¹/·˜gR?kŸÆоFcÏ2Ãœ5ãÀWt�‹Ã0Ðý5/$G]‰ãUPZ5Â$®u‰UòúhzÕzñM"òNyýýÀDÖ �⟀Úr^B«õ•}½§÷’¥ž˜ƒ™bÒ^/æ§dMUÖwßÂpH*'¹Â8'§}õa�éÂû¶‘Š¼,K Œ¡^ÌÆÉt#SÉ|¹ã{€ñ.“ÜûdVV~ü/Ne×r(@Þ¢IgÓuÀ‰wõ$fg. «EîÞ÷ôü/´|Q £Û·Ì1\ÊÞý6®èÚÜ Ò¡éJSí&ñÝ_ÏÏs{X<|uœ¾}åÞYš'ʱŒ>‚ËøÉ !áI7€§Ì×ï….ú•§œÏ]a"%cÌtËÁ}ÎZ& '&)X(ççÌ;¦»ãé b¾9¯²õ8*§ì° ¢­Õ°À楜mØ ó†òƒ°=üË8I{Fv™Aê;dkÚf‡º`dÊíðvøGÌ„žª—e±ÿ(é´b0iÜõ*uÍÚµ%`o)>H6_2:‘îØÀò/5Òž«¡gáà ´P[‚”¤ýí„Sà1ï^úµAlš$ ­õ¸¶²¿™WO:³Yîk=n28¹‡ aØi�J€««Ó)Ñ’ïjI$kíûÄk*î:KvÅÈ‹îËѢǘưŒÛÅ»úî“zh@üZ©Ýz%íûzqÁÿVæ÷»ÜoZ:cN¦òÑ}(©ÎÓÓ<NOÇÔÙ†>7{éä7¾Ý¢ðvnÆB´à»_3½@P†¥Kœþç6E‡Bä�üÇüsð“J€Õ¨™œ©º<£ ﺙ:Õ•cÌx+¿„®HRÿFâ5¤A¼xîM›[D àÑwéL5!½(ƒ¥3«ç=á[rvT–®ß³`›ÉU[˜OÝnÂäQºøzb<9:”-RÀô¦Ë'Uósoõ)gQMgd§aG=NŸgÈiSã^<ñ÷Ç–ÐÀØÅÒ¡½|UÞÒ Éý°uÀõEsÛÚ(5ÝéFe'‚§1¸ï_ªµÏ»Å1tCÓg—ÞÄ|×'é!ÚÖVt£$ N¬2+ùæòWá#ð;w@Ô¿ñLŠ‹Õé‹ŽpG©R¾ÝšÍA¡QÈ.~ï<.b ãï¼Øj6:\'§OLá1 ÂŽô7^¶pCÎÎåbG‰‘ç`"­ÁλËKýÑ™Éó·š&³qJäo{¨™FÍâ$](©îyË›V+øLJA_ž+tÆ™/ÈGJ¬Ê¯/‡M`Ä|6©‘øäñŠ˜¹–ÙÔ}è|è{&$ˆˆH[;ëñ]pðæÁi;üêtpŠó™™”�û0›‘å€'æÞê[I9‘wk_DšKfZBÑYmЈ� DÇ í4 /Ö·|ø,tÛU¶uΚ7©.”Fíáµ;i`ê. |j°ÄK$X£jàKÖÙQsÊkÛ¹þ"ÃI½¯÷4µ-õ+3‚½ýa3{l(²¬> Ï7¯v£Vk]|Œ˜•í/Vd2S…Ã?õÐLL,cEˆŸ7eºV[Í‚žÞs©=T5ÝÛe:·ê¦Éóû‘Z©™‡*Ó7Æ<¥±<Ä#ð€®‘ÿƒ³Ï&f¥ÍôôAKÛel‘íšX•ô±°S$Q6ß0tÅùg>iEéjé/*y|M!„>µì$þVðçÙ·È€R_›úÊÆ,íÉ/«¨ µ‹ûfÝ]óÝ„¤rr$¢ ÐPIMÊ�²â³ÜJýÏ[éáÕÃYʪü¹q{ÓÄM2Ÿ] LÝ Q~R*¡bqfxxt.s«m`tÊC„ATxÏ#eí„Èív²]Z ¾-gJˈþ{gÙÃp6^žò¸{:H8môg.+…Zaûúâ¤-ô˜AT8ª]Ëß¾£uܽ®G»ŽOLxYõ½kx\ý= £ûËE•xA)3r¡µª­>=ª¹O)ZË}·˜fÙV¨F/(eÄaé“Jè wÜÐõ(áCfƒQ�O0¯E3ñíÈœ Eî=¤NÄ©UŽ˜7ƒ‘©‘ä_<ÕšÍ4Uæx—fxBY·™œØ+O;K6C»èRñéËóV ¶žœÈîsq—$[3+SÌaèÞÛ£Úî›ø`Û©h¸R$^ÉD9�ƒÒ¨7’J;Ø<¶ž¾QÝÃJ3ú©ÇEz}Œ-uWw žqêΟˆ»¹¦gÝŠ—{Ìmt ¬›7ºœØÐÚÕHx’¼“Ò)ª',ÝÔ/Q¬z€Ï²®çUØôæõ;-Éîä˜ûÛˆß3×ø]Ë™Ü`<˜�‹Ïo»ÃvmˆðÝÁ³—%³©)XW­âsž}Á'Ü— ÖoKÄÚ˜Sz3T¦^SÚÓÉ6X¹7t+ÿØIy¼’²¼KÜ×Zßiè3£ÊÂ8hµ‰÷ù.iÔ†44Œä!伜'…ëS@pÓÈÛ1³mm«¶¤Ÿ/g¯e~ìz£—ä�P?NÅŸj¡—ÕÉá@”Z=`ð˜Oû±Sý¤)á`2‰áRmp¯’¹±:ÿìòԃÉi™CÀ;‡á¾T£(®­mDâlmÀ”Òÿ6 Ò÷OϳÎ[ëšÜ¿ ²”ç¾0ó×$ÈëO—d]®/O5ï§îbbȽK® ⎤ȇ<Z|RÄcyZ”MA­õ¼H¾[Ù‰¾;}t¹É”‡J/eÀ܉bË_WWQb'ˆáöññMY4ûfà `O¿~ý©}Äÿæ–kVxš»,PÂ>ò`lÅ7-mÌýmà†vÿ›­|æå)Ž騟Tò—é¦-y]ǘV£Çý|¡Ë^®¹œ¯aÈxq>z,~äšk7ÑäNp©\ë+Ɔôݠ軨€eÚ ‡·û{çÀH™é±[LÔ(¸ 6(”Ó÷<a¹K®{,ðž¤V WëO`.åµê‰•ðíbî7oñÍxi”tjfΛ…€!îÆmÝ–­Æb…YyJÈEXEkÊê¾°ÜTè®f—>m‚4ˆÛ‹³ Ù°·= �‘ 5‘×…ýaÖÓ㎠‡[ 2<ïé³ç“ºG3§—¸\ÌË´³ŒÍ_Ñlþ/‰q÷íð8>Ê�Šv¯°J¼@b»�g“ñ?j¥‘O0¡»×÷X¯ö¡�p`üêP¥€ÿì®ëÙÖér5_ýø¶ª”|¾›OR »§Ã‡iC6X#fê'¢Äî'ôå||p¦:w�¡â3(1fúVä&ëtê8VºÅOþ–¸ƒÎƒHó;Ž‰§Ã½¸¦J‚òl{Ê©øDÕÖð½… &ÃnUŽã¡´}âqö8*P<*ƒ¼m\3¼¡"Ìó–C…€nãÃásV¬|œJzÈ�=ûi…‹ÕN·B\äëwË5wc#ƒ£ %h]ï¡ê^³Þ×t_,àÉöÉ*ÏJ“Ãó…²rîL0Þ.v iÕÚþ7rgæYC3•ç¹ ×ÁÁzæ‰óz]yœ´íPÙVÕ6Q®§­kc1¥{Q&<-B?ù‡ ½ý—=|E­_RsãóÕ$::÷õ{©Ry Lrµ dæÅ”‹P í*0³é¤T‡ãlߌ£Å5‚ï?çR>ÎÜ̶âÊËæ-FÌQä:§nAל5Zo¾Õ>î}º‰ÍJCcm8ØôgÏP³}£Iy4„A½Xg£‰?C£\®ûÖ°¿–ŽòkÚ o§©ÛÀ!xë†ÝaèDTšöSÓ˜d’%¡Tæ‚N²3 .ëþ ¯º¦ÃF.†i‡Ößa‡<ü³uð¤þL§¾3t5gOwBÒ¬= -Ø*3Õ`EÕ`TÖÁ5>=‚ÃÑŠìM ׌™ÙJ³'/ò<óº¼YÐcÖ]îjEàܶ~Eß>©V:žÞO#IJ»Î“ÿÃfpxGçJ™&¶ˆB,ufíæ;&– §¹»3”/ 9B’'.é.š›¨V?ì«*¥›Å¸j­…† ˜ÊÂàë0ZˆšÁo¬jŽ»‹=òa^šóÓž ÷¼Ù¹Jc·¿úÎ!¯S$‘s{!:ïÊ9IXï œ™Wô0b5ˆY02ÎMò¸RÍ„:ðÕv/ŽB­1´ÒÕ‰9Ÿš¶`0|dÕÅ}‘]‹éo#Ù'À%g?‰Z—¢Êž[åLSbLl8@iE‡>\Äïzè°Š¨C˜p2aßz ngk6׎mkNÐ#ÄÄÑ“†ì7˜häQy¥.ßÓ1·S+Dpø$k›Þ:J†ú@0+[cåM¼K°'½žFÀ1`EŠÃѯMK>ŽP–¨³ˆwõ@fЉ"g¡»;Ò3Û+•Ã6:@çÁv__‡°k›ÅˆR�(D8¶V’¬`]­Ù@<¹¹öq×®0C¶:Íœ+nº*ˆ/ƒ‚r™1É-)]Ù¬Qû'sÁKûØ ÷E”ÐQ€˜LFÁãì»@ú²D Úõ³¨û塆L9%•ð£uŸÑ)ã/Ó"1ƒÀÀTbÒò6tã2ÿŒ[VS+#jR ¯øÔX’•5wò"`'}¯‘îò(ÏÜ{‡E0œèñæV ˆ 3¹7žó¦+Ý cón:1׿Tã,uM£t˜(°¦“‡$áîi¦4ýhçµÜÅá&× ÞÒiœ¦í7íè ädjŸ,+B€u|ôŠARîçrj›¬ÞôÏ’‡Ú—H}½ôÏrw7r^2ŒtÛYVKïÑ©í� lý t ×ÿ¡3 %×}QéºRÆqü(ƒðÔyÀöù`\M‘%ó€·m=ŸŠjÞJl¥³Þ…ð¬*§ÖÛ¯ì›8žzŠ @>~±JÓ(D�· ¯ÈÎx¤êREðÏwë¼4,kýi-éM6ôL¬èŽÑÿA$ܸT†¥<Âå§øÒ),'Gú±µò'í¡Ÿ_Ï^s‰™.èÑb(šõ±ØWóœóÔ£vA§w�-(5§Ãr=‚fÓ<• ;w­—ãÌïñBX¿(ƒ¨ÑÿÓ¯sÀ–WÝUJ¸/ó LúªOTù[H?`á“}çÀZußtÓb}i¸!`Fzƒ ž_«öˆ[ÔßÑBsPîú8HOÚaf-ë©ëéÞ!Ý3`M‰«ŸgLþ¸ome�ï_~5Å‘¡Ï5Ýɤ·Zr0«¡3¦Œ“ ³ã#½&4ѹ‡¥q{ý=íß÷0å¸Òç´/"iŒÖ ŸÀ¸°�Ç@¦v^ê€VžùÜíŒ÷ûÌ7S”»Œèx¶ }1>;26B§iüƒ÷Ü8mƒR¸ÌwY`’ù•áì;¿0êñ¬AÊou¬7¨qt·èrn›¬¿óõÖÅl¶ÀÁA±Ì&Š˜ÎT ;Oñ+ é°âû9«W–ÕzëÊN'ƒe+¥†áÌ–Gbo "žÕT…×I™8YÑÚ�ýôÖ ­ËÛ~ïi=ömôuo8¬oþP¶Ÿ;ï^ÐIŽ7—À¸tÇ 3;J”.×N{‡˜E»W$éo²0FÐè EÛ{èKø>»¢6œn0}ŒŠµMyÀó§Ý¹™Ñ±Ï/ r¿³^Þž§ïÇñÍ™#½÷¡æKÆCbEK¢•ÝÜÊ$)SoJem³ýZà,[5«#eØÍçnÓCg`JY¤îO”V7½ÑKÁ–/–¬R[fŸþ�ˆ¬a)¸ ÏHµKn8’@ü¿‚nª•=�b#&ÈM•ÂÊè=YðËÁV*÷/We~šùî—I0iP¶Š•+æ¯LÓU†È&U£¢èËЖ±|·L©$¹¬XlMès¥ð“3zªõŸÎ½Ë/ãv/ûóZ¢»0·Çƒ×F9wcóºözþfq‰°ªV5¿[ˆÑÿ¥UåÇйDp°ÞÛª¦Æ¨÷:Ô¯›ûî£ìW>Ï´a¯jŸÛÍ'Ð5¬!:œØkÁ¯ÛúÑ…âg— ›qØ=F›þ´óÕµ´açq„˜ÁK¯Ô“�a‡~¦ 0ïm;¦`´$|=ñ@XŽ‡Å‰0´(Aca¼õ£vpR¬‘%&pAhu1wo)/s'Ý.#[ºý›qˆ­2MUÙtñ¨²3|­vo®‰‡Îg‹ƒÙ]|s$ISùɼ‚Í>¥¤²ï¼“ÕC>îòÇ�ÕgvÇñ-Biž@Ûÿ²E2Ë•<E73wDz¸ù miùPq{<†ì-¬ ®.E¥Äæ/>›òŒ;¦u»ÃÔÓy¸í¹¥™göœ|ŽQðÉ`µÒ•6—tÃï(˜<Ã}–ñŠm‘Õgë#ñÑ•®·Ôµ»3ŒÅ[žü8€=sDó­ö_t«NC6ã\#Ñ+Ã÷¦¯{ڹɪ{ ýÓáÓÓ–ì¦?bü¥ÇÐå°»AóJ?k¢?ùf”\y‚LÞŸé¶Á¯ôûÁVÀëÑêL"§=-I”ª ?í=ƒö^:˜Øe—OõEð³Ï<`ª"\wGç¤FI¤Àˆ›]ý+E%Uõ0Žr¼¨èµsGÊœ?L”ñ*ëœÎô}[ª(, …ÕÓ¤Ÿ±³9P!Z{T†wÿÐÏð©¬LÞ øMÊL“Àእ6s*ß¿üæ¢)sB8*žÒ ûÔ‰W ÉéJ%ع‘t¶ÛòŸ1È€düreø }œmHn^ÑTÏ}¡x–¡û7N PžO¨~D¦h>·q)¯ |ÌX–„¾KåZ=úÞÕéËbÆ6 $Õ�sæ!óÝ1e?‚~"ã0óêáÝùns°£Xoc{#y�\»£° Ò5GÜaí<íhoZ<•iÛ,5ØF×5Ì{3)Õë€=OsQÕ3mÖw—O<egàñƒ¢qÙêT‘öS £9× :û¡idx‡–<¦()ëýœÈô †·ƒ54ú ·›([+²oão'sŒÄ’ytŠ4%-EGuñø5Gλf9kI:£§[Ùq@Y8LW¦z·ëÚ·Ž²¬ÿ8>ñ@-ò<‘JAà9²‚„}WMK¡IáKí(·þ32ìŠSg °Ø‡ì£É’„^}~Ý ×NüÉFޘç‡*Ûa:×tÝfoô±Æìw ];ÄÞkd…¥o#Â~Pò“%qÁÚÁK õó¹ù/½^¸+1•úâ¾ f>ÒñÍurðÃê3ª <Xod´ÔG!'Ü7h²6èÜðƒEßA7BŽ„ml=*Š%¹xWß ¯Ê5³P®‡0´Jö5²m–÷d`ðÌîU*aÏ„÷™‰F?š~x²\;l.¬ö·¸N†<Ú•ª6¼ËÍhÚåv§Ù&‰ô¾™rù“ÓizQZʬ Í9NÒ]ÛÊ™‡»¨øæÌJÞí…ÊÈ7}º:2¼Õoú6w{¡¹[¬qITðÁ*}¶V½‰ `­}ª\+ïþ7ëñ„UìNŒ³y[S¸nôÌ¥ûÄ“ƒ9¯ÙªD”®ì…¶”*Í ôÜyb=l3ZôÌ N]ýqóóÜV?²cA÷lÛE;2ÉC¯EÊfÜuÃ~\‡ ×åçÄEÆzç±²`¤íäÙ½›sœ±Ò¿ÑŒòÔå|ž PösçeÓµ“#÷÷(Y{”KÉ¢i½J¼wG*µT ˜ž&-Œ_c{obÓ¤Ùõ2²wW£P�Ú²3âlëî)  ]“Eè-KEñÉý>È´]+6G6z½1•Í„±¹»_ØSEUêγ’») ÃE E{ŒLÀšdßœOÜœ=uœÍ´ä¥Zˆ4œ ”͵wÀ’£ÿæðý›©X»_lK®TðÓŸÀƒe9Åî«G:èWj6Á §Èóà)"îF fÓ´˜ uÿŨ>)s…Ýx)OË‚èsp}÷º(³æªÛžS?lZö’yVú?ƒ#Ô½®Qìˆpgzüïå¥;/óYÓ|éUÝÙui=ÛÕ2£ww9Ìåmöò¦ÛÝêÞl@Ö[O8²†ŒŒU³âòƒ¢¶É Å µ,(ΊàÆbϧÎv!÷g˜ÉÑ1ë%:hZ›Áüm¦c}zÄ6„ °M†“ƒ§ÍçãÑ ::eœ^”iè¿èf;§CÓÜê}Y1ù3Bô¦*z.ºKaÖÓ×›†¥^x÷£¦ÿäŽ8’fžN Þ÷¨Çq¾‘;ºs¿…1@oŒC¢ê¤ÒN“RGßô›ÚÞnŽ¦ Ži÷÷©@é(èÄù/ûR­‚ �!.À^„¸Å(*v5¢ÛjmÛ"D.ÂtyÝ8Ö‚÷}¼„C¼Ó3/T4Y38EŒ“ªpmÒ¦MýØדƪ5{õn‚—;ÅkloºÿpþªÎz´Å°‘f`ƒ{Ö확YßE¢‰»ºíSŠê’,iyÙ2•Ï6üRÁRí1>Ì~CÄö¯ŸˆR8k:>rè7¶ÁŠœ©Û/?<llxßz0Ì\˜Y ; š(•†VaLÀñ"n¯èd Ž­ÑQ|œ¾¤™Çw(ñôéHƒÈ¢ú9ÚóÁ ÙêÆH@Ú u7åºá øö/qLÜ\yr9œêTD É|  góªv3g‘À½ù­«GŽ/Ío´ëSæ[šø8ŒãPkRù½Qÿ¸cŸ;®&ý Ýî_G¶K·ƒÈîÀj»-ýŠ+$Ìñq9.àÒQ“^7}Ý õùmwaѶÕwLÿõiñ ;¡$¹¶¢$è€~tØš^jù‚4ŸÎ0H<[ù…è3°� ù˜Û UÝ(çÒ³VÉêÎ eH ¿ék Û¥,à ÄÊβÁÓÆûëñt¨‘j²²Ìî0÷u™@sIèŒê÷žÁšòûñ¤‚wsùgi}˜û’`ÿI©²Õ®E�pÐêRð¸ýâL3é!{ÝÍh„ˆìÅí¯ªâÌ×E!\LõÃVA$)ˆv°mP§óûÖ³w\hÒJbd#û3½éÉÊW•¬êKQÎŒnqª·ý™ç�ÞWO{"å–|b8À-’9¯T%þßQ€‹Ì"àÅZá»ÚOD¬Ž D˶õ©÷L¶Èëqeu„Ì΋Ý6kæî/ ZëÖ9CkOq/ºô»—²^¯M—„Wˆ&ú%çöAbϳÝyhõF4† Z,£ÏË R^}ß¹h…OË@ó|KŸ6>½»šÜª¢¨¬ ¥‡íöÛ+ =ÏD› %—‰>]¹U‰-î¿ŠRÛ8`�Æ.\61Ýè>o ½ÌE#»,N8µSTSôÐ`|:O´$ϯÈ_¸ iòÄkòåÃR(ºÖÕ�Æ�Á¢\… Ýiªpó­z+„ãë‚MŸW_ÎÀN±_šÕÇ…‹ ÊhÜ|ÀåYÜ ¾ýÀMCi)âq°¸ŠœLóžuïý_œ¦¾­Ž‘kAÁàê¸óáë­vLžflöC_YÝ>^hÏe¡íË}îéb‹Z>:g¼¨þó'uà~ÔhTÜ­y™/#0ÚŽJ€í»7>^ƒñŸž÷Æ5À]=—þŒ±pªrzÓâýS‹©TÄEm‡uš*É>jvx±˜û»—‰âAÜ=¡p 캺?úz¹RYËà´Û\ÇGWȈnsŒò °n @ð‹½ÏìXܲ³áj= lùzOÌ"?(•* äÇÛïzH.ŒNLbGÄ<žìëƒÞbÖVl­– MƒV¹*tKê?ZaðoèúsÓPÁA•þ_º¿÷£ŽóNÍŒ1Ù<S&¶·˜ *¬­d(f •Z=Ÿ~za(Q ¶·0ö§ê�ªwtê„f°³`(7BÀ!Oç(v™7ä‘9ꞟâ¢Ôá+XÚ2®YP}:ù‹š»Óâ©_‘i•zÛÕ»ÿSp…4V«¹C¶0['¦8Þ0 ‰Ê+'ü£�V¤êæÀôšþ€÷/OgɪxÎs`†<ô¤´¥*S¡pûl³O©ØZÎÌGõ%&:?M¬Øg_ïÂqB¯ãÏC Ô:eCÍŽy‘Pø „ƒùö°ðÐëŸÑ'ÖiDà'´“»zE ?¡Ã¡Ì8h‡àöõÛCðz¢Ï0áìmeíæ¬÷Éoðv…òðYp¿uPâ" ½5KQᆣ÷q; Ðdm@t {~½»hö¹Éº§ ‰“o©A§mSžg½²ÅìA?~hý`¯<»7im`$9Ãî¦Þk½ JWŸÙªJ ¾›qÞíAþ\źLo”þ.5ý ÓÉkšm©_õPL^‹'‡™?„` ÎV•Í&¼ ΂ðgyÉ<]É—ÜûŽíxƒ0á´·û¼÷88!_t`%µ÷ó03L+&YÒƽoSç|ääÜŽƒf_•eG°ÃUO|ã÷ðÞÂÓ¡e ?¹v2Mt¸qúg>ô–b¹P^xje¹Ò)¨D1:²‹(-×4¼×£óÒu%JFàçIZQ˜þŠ†÷J^Æm*iK,´E&(Ñïýï¨Û¢Ø=YIƒ¦ÉxžcÇýµÞÀ"U«³ýyØŒõB‡æFïÃþ:�Ý3¬[ÜE±¶CÅÍ„V ìf€ÓGÓJ5„VAzâ°ý_R9”¡$7EìW•Œ}¥]ßmé\R~èÙt¨_TGžJŒ”ôô`Ñû°ºp±Ð ¯NÔîñã´ŒSK¿í{Jg`¥bí~=Û^îÇYͽéH¤Òä 2Î72*:¾·®!»> ÒíÅ 0_L?ä«D¢*½!9PÎÄïÖñºdÁKÂzïfVî§Lw~ö­‡ìdbÖ@’ØÂ36}}5˜Ñfª¥?MkN87ÀÓͳ"'RíZ£Þ�cJ3çÅ©« ªÃæÆ´èY²¡œ2CЬ©\³… X{OË>mu’?u@ø]]U›¬03P!×=u:÷úûî+h‰Š>töþ”Ñô×Ñ\›ñëÍañX@”šzû"á)æÔ'*ÖÊ¥u-Ä™>d×[C‘Ž«údï@à¬ïÔssl-b”øÊFL è›Fš¯ÃxqÁù±õÒ#¦Øq½Yýg¦à_õ½g°ÆÒæÏ_mFÃ÷úD{1*Œ ¹I,Wý΃u "ǸèpÅ`﷡è aí÷«7ÎÝÔPrBF_†×ÇÔQµÍ‹Í QÞpbþ„YäŽòUƒ» ìÞ½B€¶o_S‚#�+PØ~Ò¢*âÌ—œ§óÈ%ˆI$NŸî8^îJ¾ÿÿYû“íÆ™dkã<…F÷N2k¡o†�6R�cÝ÷ŽkÛÌÍÝÁ^‘U«þ ¤<EîæÖì†Cÿy-IÀ¦è Ž¼õ¤>O½ísÛNù‹+ìª<óÇËðǦ$µtŠûª±ïí¢„úÄeä*uRd¸Î4ûMb(gu,#©dÑlÓ¼6Ëæ46Г¤2Kœ õB&®Ãx¹Ä <\uN{â�Éim°¯ˆßGJQ“XªNwJÂÑu^†~¿1‰Dñ>GWfQ¦sè÷ôp§íá€ô¶’vìqÒƒ>ü`KÍ^¶Š*k¾­Œ«çŒrùr#{G¦}6QiÐØ«ü¸aÂ>†Æ|XµH»7™q˜:Ü Û«Œ›˜°‹m¢{Üͦ]&ŸÜè•vqn~á5MãÈò°ó ˜lª š×©—ôÏ|+Le„R(Î[ª"ó)ãBàϨhÖHÇ2Ve€"±‘)ð[˜Ñ$_õ8ŒÚ¾<ÖýÞ©¦z&¨8èøz÷0´]Y=ÈX�3ðø“ÆŒžàd¹Àƒ= Úм3Óx„<°HþÌ»Mƒ‰áVçé•5Ì öõëêsá¹êwX:‡Î»’M¦X´Å^K=õ†˜±p^){çûQªc  Ïz'½¼»WŠžaqeóÔ9sæyÛÅoì÷eÀ[N[þåt-¼Ò2Úž�*i[O ߨtÉÇ­)‡j.ÿÞt‰òr!y@5pžÅ¬Ýj?A ä2Š¤-Òq3ŸJ›TW?B¦I‹Ìœ5´Q(\×½Þ³ðöFphJ‘9Yio«Œ§I=$ow‹X@éì;®© âië0¾j妆êÆË‚þòÄ}÷Òe‘¿zéq‹s»Š!®@„”¢2*“`>õ“°¾iߥð´0ã˜ÉîŠ$áæ¯JßAC®õ8‚¸ªBSÓ†žûú|˜•%™/ÚBž. ²Î‚ù0fÁÂdN÷ö`Åéþ]¤.ÎbßÔn–ijÞMÒ¿j™¥Ê<ª? åš”º¥7G³÷J·#òÁÊâŒ>Å€©¶:Þ¨‘éƒuW6—BôD^߶TIÝŠ4VÑÂò'V UÝ–-Šªãx�¦{GÙûé-EÕÂ9t㱤A÷ Ĺ—ïéÐ8œYÏO  iP_�ª_¿&‰?Â@îÞc‚Q;;1ø›‡½h_¥ž&cˆÏ¹=QRd5Ç+Ÿõÿ ½.²Älù‹qПò ézÏŸo3ÖÇín¥–‘WèFý &EEæ9ÚRî´¾ÐþmÓáˆó÷“A=Ÿ:Þ»«e²oRÑ])ÙšÔAY8ªe›DÇù_nž ïŒÈë*)[vƒ-{…Gj4ÿ…^XXD6#覥A<hÂÉ'l}Y"^Ý«4÷¹)½Ð’mk7¯…XÝ…%çÌÿöƒ°ùT¬ÝÆiÂœÃJ!0(ìƒRoO‹^4aå™Kœ³ó2à4—JývxèdES_ w§­ âó…©äppý-àÎR᥈EQRÿ1ÚÝÃEðŽ½¥tŒÔ‡ýîÚ.ëñËÚs±6§#ß«3˜7_r‚+éÆi2<.T*¥å¡ð¸’Þ>鵚ôò :`¶©pQô„[d qh<ÍÚ- kÀÂò𴡘ì@;»X¤¢ëê?ÂnRMšDÒBŠ"#é8M0<· ã™±ÞŸþêɆӕ÷úûÊ©ç ö©ƒÖ¨FTqD,|_s•‡ïÔõò[FXªsË\æ­jo™Y4ªã\f|‚¡:Ò¡O§È­ ñ3] Û:Cã¯5Ího*L¦ õܨ$âÚÒ¹íí$Uꔢ@Ö\ËÑ ˜8Pr•®n|jœÇŽþW}1³+`rÞD,(c°5ìŠe| n¥»Xö–¾ì_—6ó4ú–.À¬˜¯i‚ætØ'ARëÆ+DŽd¢÷Ü {Òr‹A6Ù~…´²2ûG• Xq›î‰Uƒ~è¥JÆI4§0§ŸµG)•miÎæ¯u y0ÏrªŒ)WA1HJaê]o.-žž =zH`®Í|bìv¬ÅÏMtº±uS)YPBÌQß5V«†iê«/ç-øþûŸ_$¥„éæüÊBŠÏ¥Êž>/É»¼ÃKòKtVô¼èãGŸk³A±0Ž‘^‘[þ€ª»á;ŸN€&tV>»¾ìŒý{q×-_õ¦™#³Y±Hw¨ú¡B…¶öüñ—À`EïØ]ùˆ·<Íbãï.j€Ðc,‚¨¯}Ü?ô†Æ·J»&oAà52w\芫ù ðQcí¥cØ0X ’<¶—ðª{mPâM§8ȶª›aw|]º ÔÕåw'\ìÍNÁ¦ �ª¬qšsëSï}ßÇ…¾�qÙK´ØÅ&Žò<µbøSTáÔÿŸ©›êýB6¢,‚LÍc"_zB,;6 YPØ0O*×:ߢø=Ž·S_LÀH“ÉË/קÚHêÁü{ß8óJC›N*¬Z°·Ÿn”ži•ùø A[(m[O]Äô°ã7ùÍ#èh±P£Ôa{¤¥YMú4YY|2ª¡Û¾w–&fáéYOe€v»ÍÅ:g Š‡=†…?Ø:y¢P?]–ª.Ü®8´ßtè£ÐÔÌ1Jgä ‰ÑóB­GXHý›‹1a—” õññè}pÀl/I|QßåÓ£»l+ð"e×›ÖÙ¨Àù²öxRoÃéãÊ;˜9è(hÔW7,Þ;Ó3»â}ßÍÓþTá¦Y?¦§w7GÏ$v<P@>j“OûLnZÞ<Ï+uºÛò}“s‘cýl[:è 2 ‡±âO/Iö<ZWše~: Úº ’ok•ÊÚã'pèK»§=òtµ†BëQoCk¦ø±‰B|‚Lh">%\’ËêÅ ‹lk…§¸ï¾áðÚûŽu÷1_Ú,LÖÆó4_ÁìŒ:1^ZÇC$£%íà!}Vý•mMQ~¾yqaÅ6_… <N�‡ú¸Ól]Òm}ìz3:0„߶Ê…0l,Æ#©ÕÔcY%[ÅÇ€€ø $ vø°ý Ê;ó=$(´——ã'Í°ƒì\l­‡©‚#c&Fát5†A1ŽžÁ xn�â°;0VôÕëýZ™ç›–БCq`#ep,Ú[0ÈäÿÌDËwàved[f(}áÙ¥óNRö21à]hË;p—ˆ4“Âs§¿ïsH¨Çk{bª;ë»ÍE‡b� ”XŽÞ•ÚUÔ`Q§ró úkN<D”*€+L:M¡ ³¢rrg”w&a†‰/[ÊÇñ|†4Ú¨ü-¦5öC§Š\‰àòéí‰v‘ñ½±õuª!‹ý–ÝddY}–60€-¦-ñŽÔoz92_ ‹é¬˜1†WÂC²?–4s óÑrp û¹Õ¶÷qoÌPçÝð£ÂÏnÜ_To)¢£JNâsƒRâå–ˆ«k f¼¹Õ¾¸QXµJ‰/Þ0¢PäYrë¡û¡[sìLäçñC}»~’IZÌ )TGÿ—Ë\,^´ƒŸgW®ìWÚ¡ Ä`¿:J¿={Û_˜ç%ê "Y ËqI™ýYå82ºªfÓ_bÈßÛ¦ò•ç4X ;†wbT£l©{d$Îé½¾º`­†´oû*Æ _4z¶MMù÷¬�²¼dg¾ŸE­›Ûÿdéå¥ï%dÊD«2üô¤Uجªc(�TkjÒ7Ûõ My¼ñ"õzBs3Þ}ëÝ@þ4ö¼9w6Pß$º^Ïì4 ™?ßP™b;å6Šáô­R‹+¨ ä|å×(òeÕv–M„b]邾PmíC®æt+  “ GIö<TAô}4 €É˜ô½wð2çg@DG¢Ò+~ÚÀáÏêŸÉ+ß²œpvÊZ§D{ Þ{…eÝÁûâ£9\Ü@¡?µÊŸ›çHGæIK_$¬ê”b“•Ûb:)«¢ˆ¢ô?r‡«¨Œ3ëìfÁüMIw£Â%k*¿´ÆcÓO÷§ÆÝ¿¹y#°µæ…aµ®ü*«'æmí@Œ†£œ—ò¿þ|iƒ¢‰Þè‘ŸóD[À~Ò(1AD2<-;èfN¸Ÿöõú”ÞÂa,ë�~ZnmxØ‘i>ÕJ7ª/ýdì¼»‘d¥záM¡i,ÚrÂ0ÛÔ�]E§#}ñg· )<Š^ÄHy¸j‚Í{·úbY¢¥Šù›@O.€M“àÎ3Ï“§×1ws-­fS)²T‹ù÷‰=Wæp><V¥D¤ ʱöTð·¢bFå¯sÜ“®a¹ÕöRY­°þ ® ã¥u­Û3bšñM²\ÎP~—‹qÍÏܪ<¤²Hí¼ÃÙIê?€¬0å’Ï”Ž³ÂR #–©ÁN.¿Gÿ.,<Ê~½í¬QEÃVàWfÇÈ>8Wbjn½ÝÚ˜òñð±9ˆ˜U¦y'餄ä°M! ·êÑÐ[uÕÍÙ#Ð=“¾-#áPVrìX­ï¯º(–ëÖŠÖ†0\ÍË Û'OL‡­]…5;[)¯ž¾£dæÌøãtzŽÕF'/t¸µ$Hm/ $¯Ý~ hù¬NLJͧ UÑ©m[ñgãyŽ÷ÜÈáÅÏÀR*Éæ­w—ÜÜ­[utWÃ9ͱ‹¹Ärâèglß–êêàÀ¹–Ѷ¾ÂúÛ*úå/ÕW–SÊFñÛ"¨NkgqJâBí"´ü»Ì³kšS£MŸ&0Ás2³¼õá§3l €‚XòÈÎ µQè·GRñ}àS ü¨¼jK6‡ÜG‹ÆØääûZúï!È¢æYׯžH¦cÓ!U~ŽÞ<EAþœ[RjÛòºŸ»å5o ‡¼ $Gyâ[ÒAÃâ�ÈäÚÒ݀砜egñBoJN§@û›AH$¢ %ídV{·f®¶ß=쑧X” åò&Qt»'Ͻ‹‘á¤î08²L°x|éÛ,–Wʧ}—aëá ?*:ºmƃßã|7š–…O–§ûþCÿs4a<ÁĈV*gl} ѧ?]™ž%w\a±#Mi=™Žs½¤‹…Óo¶ÀE°XÖAQÜ_‹~ÉUÀMâÔM�Ø›`{„wÏ_«Á¿Ã±þkw°=eF{Å®w¦ eä—zbÔY±7”¤”ªGiø<¿O'nöÿB¾ÅfÜ™y±ìq^WHéÜq.¥¡¶9Ñ£I>n@E‰\;×»Þöî/$ÿB¥oipâKÙ¥<)<€¨ì&é©ó#ÿ:þH² Ì#¾?9ÒÄ—I`²~‹ósš=‹y y¶o=äÈ× g¡óA?âb xÈ›]ïÜr)y–V¨»º!š¥ Åaœ›Z2ÛoïšOðî±®Û¦v2¼ÂküÄÂÍ¢`Q5ŸFg„«Ùw!Ü^ãF>d(ÃÒœ¼,îA$£ä(Ïú$?Ξ­} eÙÖüù{‚ÿÁ�O–¾ËVJ‡3!mîé@ì.^yÂE'+ yyôŽ›{Þ•UZŠ­5Êø=½ã¸Ñ6ÝBô(Ì8‘ m0¬˜wõßž[±Ï§ZG™šÁ B.ÈEeê]€q9X½Ü¾^ Ó4—?ΰvck<š¶¦Loó (÷õ ‚ÝÁ*©TÒõ«'øg™åîšÞUA~juHÏŽ¼=7í^¾'ê÷XÞÏú½ELà§Ø·ƒ$[Q~svWP{ijÍVÒ |!m J¶Aù<mGª5\öaç‰ì±L Cû£9> VMykÕe ‹1ŒQú¾…´Qš‰ny\_œP(X‹‡­µš®Ìç´wÅú£Èû°©ø»R©Ylý5U+ °åî»· ažâ,_˜öÝSsô|Kãa¢2y–#å5Æ)_™À¯‡B¬ÓrxZl;QcæÆ5×tJžpVÓ 6RQAo­|irî´ gú¤ß:θ‚R$¿ ¹bÚ¼ƒqÉŠp¡öÓ€bmÔF,¥îªK3 Ñu2°¬|t¥wQ+Ü»K¢Ð7,¡Å‹óÒjýÄqX½+©Ð+“s›¥ ƨ}ÆÃäˆÙø€ í˜)@{gƒFô•œçSWÁ"^øp`™ç¦ñ”÷ôàÌ Ïi{²¨ ü«7þÞOR¼| ŸõM{þ{¶ˆDºÍ‡•Dö‘ád½Ûˆh‹^Ü6Ø<Àºˆý°Ípûmuÿ†/Ã@¸fQjöSS"Å™Ä=ÎÖ£™‰-œsÓÅŸZ«å¤#·­—ö4èÏo €M¡ƒï™Ñ¿íŽè˜¨qUê [q›’wZ)'ë™ažÊ?Sÿ2yO<L'=i«ˆ9tšD,ŸïQ¦<ž¼m%¾ž³¦áÕ‚]Í€|[,°p%…€¤«?q‚Ú¶™mg»,EZFSêÚःFØèL¼w_÷3­¹÷ˆ–Vœ@ÖN¬/EÏ&(¸ÅìÎ[ˆã®Î—ñŠÞU‰Ó´â„mÕЩã,z›�Ô¬Ö¬öðÛé ¿f¸à60ÞÚ]&Ü&8Š. Îò–0Ô;ô�?+i§»ºãÙ‘gþ¤‚É~ÐÌ?ªUœÖ2üu]Ìñ´Áƒà¯ý4—cŠi e/Jθ=FÈ™1â§/ÿ¿sABâLÁkØ ²Ý˜ì`½c,¦Ù¹ù$9ª Ú¯"ôË­gùÚ¡À˜#A8ê†À!³g‘YZ#–¥±"+Â/{Sžmˆ‘†1FáwÒ†û}ã3ÉŒuotÑßUtr™Oi´Š.̺¿}ÆŽBÈÄ}¤mœ˜ê7ä°É¦ yšAA”Ÿ@fÖÒ¹k0õì’kJ‡ÿ¨—Õil˜åe/ºÞnü§‰ë`ïjK½µV8È”pÞ ÿÏЈTeþLª�¥–ÞuúôL¤½µ$›£ÙåOgd`&ä 1ÑBecsºØ1@*‹¶¬w¦<>^òð /=À2,ün¼I Ès[õƒ‚<« ün¯î%îpá꬯ã ßÖ^»ÅRþQ÷`Ö׬‡¯×v¶Žù­¶Gl^˜l7ôs¸t2’0­“Wæ…IUR:)}õŒuù;º±á4›â Õâ» Œø¿eûŒë{ç‰Ïw>¿Ö¶U°Ã×»¿QRúŠ‰hO~•Al¸€ ”Y:Q"áÃé.:eÜK½_³f™ßuŽØC:n=÷ Z|ƒMÏÖµN×_k>E\dŽ.$ŠG?)˜Ž€_˜ùñh1Ïzš<‰<²kj™w:’÷Ôe†Kß4T˸Çhzþ3×¥qúV²ÐBÇÔb<¹|Ïí‹Y›oNÿG‘àeѹÈê3CìOfFjvàãàÁ°È7©æ,¶÷9 0\Y~¸' ãµÕ– Ò_ØÝ[8a:R*}Ƀ¢Ñd›"ÙOÍÚ4 ÇDƒrTäûñpBžðß¾ûïúÒÓ»M¡òÈY³pðæ”P½í –ªJêž÷(ÏOLúâ_?™Ê–‰e%œE6ªO›…`Öm¤ñªbö72o nÄž‚˜¡–ÓƳyVÅESÂóxøy5aOUP V@Ì€ïÕ½[›°hÔSZK"�Q0)ßUð)~šº-Í_ŸéÔõ\æÛþã#OžÍë€e„ed=vØ‘…òæA“3Ú£©QÐ$¢|ŃwU 4|þ«ewC¬- ÑVnfÍ£XFÚJUi¢Kaâò¶§’m¥C°È,¹ 0c5³úØ~8.\ñžSJÁŽ‰rªZ[˜<úÜY³‰à7dKœÞ4 ['çI‰î·vY9‹‘»ðfÜc -×-ˆ§ýòÔyÓÁ}ÍðæÁz^þƒ¤­ëœÄ|H� _Õлò‘=ôn×Òþtc»`_¼9µR™]0¼8 ’qòŠTLþQç÷ÍA¶ÉWü˜Y%‘cà… D$'µf‡<dÓõ;U¿nÆŽÒL‹æ®™¬Eì‰1¤yPµú,òH"?`‹`Æ Ðaõ?ϸ£,7†¡áOLôƒ·g3ÁÒg~›jyq¼“Èn~2Ñ}ñz…ï6¯òóéÑ<±fØñHOòƒû¿ OíP42•q3€£Ú;8’ƒ]\”͸•E…¼´üÆ×>KŒ­ÙúBG{§º£l>®§¡3ÆÕNóÿó>Ãtû 9x—‰¥•€Œ•Ð2Q¦w³s@°¾=G¯TÆOÁŽëW@ÖnUÄ ö.,)ÐjI«ûŽ“zË*Ï|©AJKZx³ußžßõ# Dµ‚TçýñêÒóÍÌŒéò�ñááì)\[gšÓf"}h­ÕòWi’ù®N´`ê,b5¦Íi±²0¢E| ŽôýÎ]йÄ~7hËhù³7öŠ•sxi«ÑÃnÀvEsï?”ÐÑ‘;ïéIжKÌp#Þr<¯²E|A3–+0?&cäíÁnT³x·´V;óïU!«�àí‚™jÃe|0ï¶î;Øù)¿¦pcÑ2’L[ÆðÝýé¡"»­Ìx Û×/*t³A-‘2ýô¯‚¹í‰êC9cŸ Ër¡\œA{šþÐvãtDµèò€á‚h~a(qÇa"²:ï©q¿Üœà¾»éLŽErǬ$0E*mý˦÷Ѱȹ†XŒñµ²~«sµvâõ%#8MäT® o(W°Ä=…ú¨š •ƒ hÏÜÀ÷®î>K=z¢8rAôÓxýnÚÙYî;X %.芉O_…`kYhEæ%oª÷O»ÞÀOl2ç¡ò›|³»ˆbAÐE÷Àp¥ZF·Dôd«¿mÑã�™Ó°Šð¸ 8PòÈX<ùÌ,:¶çÑñ›’ÂW\(’"ýa§I ²8FA¤ß!Ðc÷?˜Vâðõ±Œ‹ÓЧ‡™ì§êÒxGÞ–ò'“üÜ@©úF*ñ{ÿUåqR5zÎôèÙ™wÄ÷âïÊà?C„þêÊžþ´4?”?ÅJœÅggGsðUêj¬´ ñ½áôy|-Ûé§ö †kò˜ mÛM2]}c¢XyÔ V ìû,Òþ✅šñ[7:³‚àò±îè†méŸ`s¦/߶öÕt5<žU@#1ºlMLlwòª=™üŸlû0˜Y ]«¯éJl²Å;Ú27®4ǃ‡CíÖs£ÆDªÁ£#Êõ϶c,‡ùœ½O0Òþ]¨:œ,‚œõÉÆ]†Së\Ï€€6ö ä<ôÉ;·ÉUíÇRÙÝPÓ ›ëÓ O@ÎGôúñûȪIÜ�=U~wÖæ52ŽÛêQ´›¶‡£©ÈÞgÌÆQì{êá0?–Afõvœø©RUJS‡ÉÓvb= \½í:°­üª¡rR½Â=òZ& +>êC´ô¡P#·^Íê7¸w›f¡ç<ÔeÕ üŽ‰Ž/Þ³wY4ÆÖYuŒ”Cð2�ÞßeÔ¡âÍñ�w´o ²9Rîí„&À)=Ɉêþ¥•KLz³¾Ä,ê`ä FØRi¼úòár/•ëÔÀÉj¹45Ý”hc« £ë]!¡°/×#-ì;BŠÖ[3Ê´ûñ@Ë üT#ÛŠ3d¡ÿóa&¡Lw†SÄ-E÷Œ’ñê'/‚å±X¥Ö0w ¶ä¡5i^´—Ñ/ÿØr)U/2q†áeݸ¹7(¼—±ç+ÿ0²’ÊëÑz·&rcŽ»c§m×Ò1'õ$•½”Õè+…×zºÝEþÜ•¿ð9é¬ûWÌnEtÏ8ÿýÕËý<2õGdôÐÑŠ Æ&fö˙ǑÖñ|M:ÒŠªÌóÙCË®Ælj\«KHô_ïƒKwø³ëõå±ÇRœ>îÂɸ¥…Úê»ò,†Hå oì n^žËOÅ°pÊÌ\05@$éí7J6™õ¤(‘W Hë:'$6x¾b&´ÖVŒl™8K ¤Ä@z3!¬—º¿¯áî{Âñ¥+×æ¢Ö(7Î…—Š¶Ëêеʟ¹´¬vÿØ ñd$™DYîìÛ"g¡¡gs„õ;Ù†HAèal†Ó@9¿çõº›4=˜«³˜ÚýW”z¡oa̾ƒ¼ñEtŒ5ãx?|.ß’”¾”mùãÖ`Ø(ð9g¯óÔïŽJ88LRÊ]½úÉuUxì¶TÀH~¬ÿRŽHN‹•‡kÍÀGZÅÖîÛbž:ªlË­®îX\¿'üÞvMoñæ­ ¯aÚԟeÓyŠJbj$·À4öÂJ/Lµ6ÙÉb\{¿¬Ø5‡l¸x8mð[NQ‘%©S}ñMO›0­×fªgM …9"È8íi4ÄDø=Ý©÷âÒ³~(DŸZxßúÄ ¹Oξüç#ñfi‚"¤/¿Pò»RÝeš… *a;'ôGW]ÐÊ·×uf“Ý\pøÃGàBÓf†L¬ìdæ1¿lµ×óŸXŒÛ=!ч#ÁØrA„› À©ÜjaD«»›¾ÛþO, kðË]{°B-œB0ŠŒcG‘vô¥>´Ot2ÿw_[™ìÇ·?)}:05YõªÁ/mìvìΓu#UáL2ÕmVKòF«W抇nþma&‰ÈBø®Sß…þжžÀ«œ¤·�©Բ†l°Z§”ŠV8%½ÂUl¸›{D¼ƒFËжõÇê2`^K ˽_±*b¶4.è~¨¨9~zj†J'êÙò¿~äëÛWiùÊÙ‰‡1dÙ2:åhõi³ç…»Â:îÝR€ÇÏ2+ñ:v{Z´_¸üɷድ Ç ^m×N>b]ïFÿÙ¸mÀ*ü‡³b¯AQVe^•Öëy[çRÀžÔ+ •e0ÌÖ8x|“¿»W7íî²ò=¡Ð#@Vð9xóq4íj;×l7¬7tŸ 5’¦4‡¦st¦ZÁÎ0£ÀêôR‰ú;±Ç8^꘣õ `âZë`HCÞÊêí@ÿi. †²Þ¿µ “Ò> L:ú ¼Wo={ÊÓëÖ~+TR£¾<’Q¶8¬ÆÎ1¬?û¬½Nœ„LZèƾú9’ß•P™‘Ãt+í4],ÀWîdáŠþ/‰vv%íz»y­&Ï‘èŽr[Ùi8ÐnøÄ#£È`_Åï¹;ÒŽZí‡ó)N« |«5FçïÄùA»›¦lÞ"õÚJì ‡Fµíu``âÛGø‚w-¸S__Ë/¼ÐÓ«’Ì#Âh I¨p¨&9DL¼OJ�Ž·;8Æèy1¿#O^³%ïi3†á ÇzÏñ¨j @;зjq¨éßwÈ`€›ðExG›o#4wÈå¢ögHB„µv[1DºÂ$�¥ º!gÆoIBº6]fl*§. «¤5Ÿ€p–¬œN¸ü¤5è\½ÛåM<hœ#4§k%�ÊAÛE P»§Žn|7\Úö-Fs¸t …v ÐMGm­ºµž•üà5søÞ<zk«*Ã%�ú8«¬1ãÅSµÔ +qñÃb¼R¤© 3sÔoN ÒÄê¹K_ŒÍi× êÞÕ­–™8ôEÆzzëWêÌ.€ÿ‹û´ë$‹khì¿ <1hYIyëY7<ÎM€_Œb7ÐÅ ²vatÒóvX¨\!IÒb«Ù_¾î¨‹Œ{¢ Vž-Ý´ÔÔ‚þwƵzÿ¢ÌË} #ú[_)S‹eOš½�V´D_÷;V( Œ×Ư 9ŠÐkIqß«¡:!³-q�¥@$á^4Ÿq¬Q\¤’JÌOýkzHûû’éÂR.†ÀnÅ泆Á™õÛ“ÐÈmøÀ^ÙÖÅÔÉ Ø¼å¦k5Î Œ5©ÕÉË<r{Ù ¢í/¸~´¢kR7>,«ÐÇßEä¤eU £„-Óa72ß­¦L¿ð�I _©–ÖƒEˆð0jÔ±äõ‡i]»%ÂÀãMìÁ¾Ÿîüæx8_ô_Ÿ9*Eqô ¤$t%B¿eÜu¬xdê0ÐH Ç` žÐÊ »¥ºã¤šf"4%§Ö鋳ø$BD€S¨cÐ@Ù^ý„†,«ÛßN…‹˜– •ñZ=Ð…i'üv3*µ‰%Ÿ®ÀbÙlM“K£r¤óf/yè14Bx@SÄÚžø#U¿õíF]O#lŽát`^·Òš1/á"s+XÁ¹ƒøÙã @i»÷ìóh!ìBBï´Õ ?|Jéù±€ª¡cPý¶g ª­Ö5€ô ×úq¶IŒc7ZÆ“«¡Sqâ_0¦yæ{”ÀM¬£Ðsš<è¾?\Ú ëé ̈”È„-áô£­¨ÄÍèƒÚâN×ÐôB·˜%ÝžŠÂWKgê‚5Î*ÛP-*ZnΣ§Øàó™ÆYá\ž#–g€ }éÁœÐµ> Qß±ˆ1NI½E‡êj®-¬%óŽ^3l½ÁW?è¸=ž1Œé‹âbd;eÉzƒÂ¾`ljžã¥â,/ÊÔ$mQÔÓIEQOý®s¢¨I0vÊÜ/–®:¸ ÑO@ 7^PB¡·<t ù�•‰áó®­áKjÕŸ \h0Ü´†«ªi4™¾9m ZG‡úk²ÔáÌc›sÎåÙ§Å.P9fÁ\´dB³zâ5),2¦Eéò¢J³’´1“ÛÑá@•Ö?ùm¬;¶t2sæ7e%Ó8ô„CpîЊ¬æO¿ØÆÝè†ö_uÕôÀ¤9lD©üRúÊöÀÃ=³t2:€íäWDf¢õb²•úšdüHšrÙÍF™% –œb7£5ÇQàïíÅsppZ,hDÀD¦AÚ+» ªVlKu½óXŒ9Š¼ð<š8Hº­×°`7ÊÔ-üÇØÔçÎÕ”=? Ø=ú­WŠ‡™iÃ2šª<Zí„ú9ë5“^>˜ê%°ÊÀ_mØË(ÐgAú£YGßÓ’½- —¸mÒ À”¡îñøoŽW„gÐÊg«'I•Âæ�¦Áò¡<±ñ\NŒÇ9e|U§‡…[”©Œâ’ìk‡MÈ{û#Kܧf½Áóš2¿¦Õ²PÅà ”9p“å­æ(m>+´ÅN9ª 8êÏðö¦KpÁb><0½zàܳŒü.i)¶‚I÷zÎä Ï$°Ú™uú!éÿ™LîôˆKÓqD[9'ÏÞYž(xïN%ièB!R€à<R"»m1qW N Œ.À‡ÈLœãJ“�Ÿ t™Üï-ÌÐG¢0¿JÚlšyâ¶ÙTÑÖ*,‚KžÑ?k¿çùêÜØ™õ‚8†LÈC†t&¿†Ë¾k=n·S-Ì W‹jpú¼ÝÅï9Ñç8¿«e÷ƒ×kj£U¸9vŒžÓ)*+æîÑggÃHµT9îz˜Â>•Ë½vtQ!Íüã“=õø‘SSo¯¸òvG¦¯š)±NÈ ·˜`K1š¿U4?˜u›øχ™%1S—å¹YPÑ;hþÔó¶`­Ía Â³Øª…-‚+v* Š©,Å3V7Ö)gùã=ƒ¢,Î|âw)TGÃèéq‹ š`àa¿j¡G©:zOÛ #Ñi£Y;彈-ù/wÓÓÜ3pá$oÜ#¯öÙÞmwV©Ü¤ñ°çõ¨¯<2C^ôX¯?b+JŒƒŽå¦5íúžØíþ í]ý­gÓ¿Y´ZЦ}lô[ªídÆQüñß49¶ 讈Kô±EΉSÝ °IÍÅ«˜¿vÇ#7¬+D¸8ä~uþ5g>mÇ*® Va&Ã/š\Þ£'’ÄQa€‹ òå«{GiÙ©w$ I•Rdõ·“½O<Üש3]î çWJ÷ÙwñB„6ÀÀå`U×Д¤r—òå"~ "v®…3uëYæ ®S.í+Aê‰0¡×æm{èÛújhX’]LÀ2Ÿ,$ô Âù38DhQe¾‡r º^dãÉëØн[S͸کs¸“­2-"ïU®BÓÄBŒÒ„’%Gcç9!`ŽŠÞÖç/Óð¤À$ZmHMe…bÅÌf¯Â£†Íbf,õç¢KPس,-Êüz :¬íÑO‰¢˜Â Çí,á–o`—sÃÒ“Y6¤”![ 6¹[Z [èæÏám„gðbx(ç<Èk¥_§Úy`Ût(ï{¼ì±÷;}YŸú»ý™"ósBD°e®½rÓõæäõIé¡‹PVúRrô¶P©êÖÚIJ9È—ªÔýÛç÷Á’ŽÃ<®­ydÈјŠwÄþOÉf¨/3ÊElØ·L¬`ý½Îc‰½vë‹«|+éþ°¡ä©°ŒC€Ó!"¯I™¶ƒÜÅsqÏÎ]èé=hemõV¡Ü<-á„×l­àaà]ÞÊ/A´gªV¥f‰Ô!§g~—ø#éMvF•keT téî³TŽó  ‹·LÌ)…hÎUÔâR³[Î’�AšOGµp³CÈ7˜_Yé m�˜"êeTT´¾ÙÈAÄÞ~#ˆ—…¾c]Û …‹~¶™TµÉÎUN¥ÆÝÀDþ—-Å9i¸(Zí©84rÓ«eÌ]í GŽ­*…y/˜[µWpQâ9îd’¬r·³Ž2&²ë¯4GMÕ¹HDÐÎì“ÌX³ÓÎu6ÈpD¦î`»0ÿÞ#É<$9e®ó”l"Ñ-Qh‚ÌkFËõÝa Ôj²æÚw~·­-ÞLw«k'`?Пªõ@îjhóyoPÕÈÌm#æñ¼¦J ko2Ü ¸’Ö'€Ð»A—Žå*_¡gÓ*¶Šë){åÒâ ­#‹÷³é›•ÅÙî¸Û`_ea>(R_R4ªà4¶ñ-𭧃b"¦”jjÑ_Ò°ì]^ÉmÇþ\Ýôªc i0æFi´ódŸþÅù(Ž<ßûœ>„ïغñߎ Mq ÆiðfW+Šª«féóòFïJqŠr\ôø—yò̾ã3ƒ5¬àîg&™rÄýèX0ýb9[íóÝ™5�õ•·õH±ÂO•-[Hnh Áé"cŒy¤Ò#ì>õ©‚ãndë‹÷§O &°U@KÿPÆ™Yà+këkrsñT^Á¹BO XDw*춥$‘In¯¡l(=ìƒÃ/FQ¢«Õ;ñ¦A<*ô{“a„àTQ(I”ÂÍ`Ë}Cÿ½éØ–‰ÞL4z§ýƒ¶¬çOÌ€¡}â"Ƥ¸t4IHÓ'¯k™ªˆÉðáqÏÀ[@ô| «¾!Ïaƒì[wˆÖ‚Ä’JéºXyõ³JûùÊèì\´=Âüš=b¸WØŸ@&ë¡ä~¬‡/y‰B|(1PJ ÷;Š5ÜÚfd]‡³é.—Æqæ[¯¦2Ý8½®!wëœFÐog¶B3Vy_µ8›r¹®/ÃejÛ“õ y)Ë<¼W8™N¾-ê dÓ^˜]ût¯ê=nÌmüÒÛ! jlA0‹ÎZ”!Q¹¨Þ¸æÒÇn`]}eã̉¢õê9Ëš“–Ò^ê—³9ÅE³"/î÷àaB½@Zéï;˜þ²Ç×<õ´Ø52ú°ýyEÿ Üc÷W9ãa?±Fÿ4qæåLÅÞ€ÂÜ�f¨`éÜjøó-å+^2T¢ÂE A Aÿœy¯=:h}RŽ4y¤š N»ŸK^Ç™×ù6´%|f«ƒŽ´Q­Ã/NÆÑù5/ݵ †ˆ&²'<D'­áGÆàÊÓ8/ÅÇ ÊÖF13DîcO·‘Î¥Pá¹eN'ª÷~÷3r‚t5âJöðBD)>Óù ä¦7 C+æ0lÐ}“LÞä´¿ÞÝQ~e½0%AÉf%êÒµÞÍaúÝ·àÚ»ƒ?K䨤ë]9³¨Šýy>@ÊX]|ê(bŸ2i-O:ô•Ž¨¢2 R*„®*¾M0¬t‡—×ã~çúVM¾0µËôEŸ?¶6¶ix% »­/r38BŒä]- *É<U#ŒŽ!øYü|[û`HŸ0y§;kð’nNù¶tê?äGQ¥™on0lŠ ÙÌÎ~‚ÊþØÃŠÒ †þA»¯ZXxÓóFHEº­\¢ã>ìí߉õ=“í³ªø‘‰j}BÐV¥ÁQ�0|œœÂÈxª%cÇÒׯ ¡rT6c-…ø»UÿF£ï{ì;ÖƱàWqØÚ®' ©›³ l5´ƒ=z¨åyÞxQß»²n'û[¢tšzú�•Pƒ©BHF–Y}tF)5þÙ¬Ê.ÙÊv{'ÿu¹¹¬ ?U,Ÿž߃ÚÈþ¹» É`]¢78B²VO©1~wn|Båÿ°çvDðxV`{¿¢r cÔ3ý“Ùæo •>Ú:ÃDKOwë 9÷ºãRÖþÏwŠÙìJµÙBJËÒÈŠ¥¤Ê;(Ü%"×-sæ)£x6™ €R˹Óô»Áhœíwm Î…ýÏ~Bç.óôß#¸9—´v~¼ˆ†ù ¾‰ûýÎjÆ7àýKee6ùYiÉl8AÅV›+™kÍsýjmâ<w:?Gæcd;{¼Ç¾F¿æ´·BÀ/Î(Œ|p7c5éËG߃¹ã]¿û[ƒrlé3KY¯÷TÞLêHF†î”¶r®~¼šÈ=v?KZ¬š*¨úOºØ²ê‰í>òdoì]Á~ËYùyÔw‹ga$X”ÂÏÝès¥¬x0{5üÌ“‘6{eRšAGÔixÇÂ]Ë›’È0g¡*ó0b|Æ‚• ëæòo´µ4ö†¯ rFÖÝÞ¨¹2D00 íé]Ùí"¹Ò—î;Œ+Få­eLs?¡‘^¯VèâÑÿÃaF[Ê*m>&UÑ L¶,¨,jOþÆ š«Æ}pçHJsõH£=ZÁW?È®Õ/ÖúZò”°(YEìžxw}½XS=¸1®Õ8(:zó¥;Zæá|,³ÚÃ"Z©%td¨Ê`9€è±ƒÑ2þ5SëøþY÷…DE¢ÎGS„G':¢)L^~%³+•¨7þšæ<(ŽßÑ CØÃàÄëÞŸ]ÜŒ2¢8]ÈååBeœOÖ�†Õ˜–ö€e6k·?óo–D/™aL\¥í¿UÙ4lØ$ÉÁŽ¶ôŽÿ‚Å¡‡ÜÔ¸àLƒjÖ{w<íêXZS«àò;—õŽkâ•-ÝÖžE¹@ÖÐsï�FíþšAVrspü²ÓJc±{ίÀœì;;­Ñ;ïŽ =oKÔ<ïùü|ó©¦f.`ÁÜMûp¡÷u3öðAÌ Îh‘]&Ol{¸ôõ—©õÂ[\f*¯ì™üTbk#C? <eÓ+®é~·Ý¤jj/„D›oÍj[‹êø9v3 &F°,mO2 ÔïV†95”Ìäßu70ëàÆPÇu¼Cãc1n°h[«õX²†þ¦§Ó]’ÊØæ•Í]у4,âåX´Õ–®DŸ.ˆŽk‹Qd-“£vηݾë?èߣ̴®~ØâLÂÌgÔ¤A)Erj<¦ ¥V[dq¶µ9^Ïô0¡Ê½ ·K†Ž¶ðQ737¢úC=íûœÃ7wý·}¦BÉS8)Ƶª”‘ÑŵPÚ—î‰ÉÂüX<*”úÚB´’àf¾àÐ÷¿gD]z –’Ñýsâáâ¹²;²ËN,(»¤”ÙQ¦3sŲ}AÛc¸ /€~KïëÓˆµ±ÓAÉ ‚5¢%­Ößž·sðíèö Ä£_2x¢<½b{Ìu$ßZ†›6 ÔܸO)úÝ´Cù¦p‡â™S¢E†ÇR:±rzãÙžÄàeÙ«¬³Mg*˜Õ¸Á^Þ `évªÌ0,cTß—™1ïLþOe6,‡1{Iod /bWúº8¯›Ü”R¥)Ý•O/³‹ uèØsw÷Qq§¸Ò_ê’F¹vé3ã›3 /YYåÁ¼à¶|=HdX@ÀVï=¸t¼wE›? òA;ÞûÙjdO=ñÌý›í1ïx@ÇdêeFÌG f Ó‰ƒF&¦õÐ ΰqD! R*¢”üeÌÁI�K‰ËßgU ä̪vò�­+:B‰òl¯|j {­N‡ƒàúuÙ¢É}1á¸}ʸn+ì:ÑÃÐúñ}u9Ÿš'MÂÇÐjé§è•´B7QV”×eÇÝW¿ˆ+ýÂmhTXΑ3ÎÕ#pF!wáäDįßlÍfNU�¡0øš¡hS÷ÈŒy=«^bŸSþõþЫy¤7ð=0+çqÓ š¬µb…ð! Ühò÷ßeÖEì”À/n0‚ýÔµ’—EÏüHñ¸z]D _“7«º-ImÝbp†Óÿµ4oÔðù Õ\"< Ñ€T§Ÿkdi`KvLõOl{‡°¬8CÏ‚}“½‹w×7õÅ‘_°ê_º}EáX<D±Ä;í¶ÏÝn3àüƒ}eÉÖæëìq˜G°?Œµ;g‡_þoäS󥶌ú‘HÊxôÎŒôæ7Dg×\ hˆžÈñÈâ8ò•¾(ë¨U]¶äœfº ×ÆÉÕ°B2ÌþZbÿ±·Úy ƒüªS?prPî_ÏìöZûæX‚Š|ë†F$û"o}@=­Sª—œºà;Â…¿$*Gk`Q~30<·¤ÆÈ°ö<ßXiè¬FÊí}zðãgÑÏKY1踾öwDì^[o: ¾~5 É%´6Ú×?Ž4zýcKÒ_°j Ça|ÓƒѪ¸z‰žtËlMg¡ñQ™gadÞ•mP÷_)=¹YyYPãØï4‰x“îâ„Ëe\A}¢Õ§*Ôýæ‹âéda6ý̧éƒË[ý…¼ô+5&À›cô´·Î8°mA,ˆm‡³£ÿm15þ‡ñ™]:"4�Ù© "›ì§<ð‡¿Fdöˆ¡´|XüÀÛ™vö£ŸqÆ{Å£Úš¡¢ùÓ¦Çqwàr—Sõ3ìYøß+ÇÞ¤°%µÑaè©Ÿ´á ÏFÀ.×_NcãÈSõF¼®€ó¢ðv©f ”á \ëÓ<[ŸÅ7dàó¥&k,êönHLv𡬨î?h2‘P„(SC„_{*ÈáÅkF>ùv'Â׿tÜRE$$F†èÑtòH\N8Ѫsn^ {åFåͺª”x—eÌ>HÚVhý¢Ñd/èæñ&sù¸1 ¡OJ'æ5’y§*oçð²ÜΠ²aïùùnà³eÚŽ“Æz—>T¡2¢]{ªÐÓ¡ST:OE†«q0Ë7Qß‹rÏÏ~k^Í!›ÒæÕÒÄ‹å8#¬þ¡ãÛI›S2o•îR�Š#?±ù+2jÉÂdÙ×;·¥^Ó¾œœ9—ÿlÅG™Â ­¶tßs­žçtev%š^÷¬0{°Ëh•1 ’ÉÇÀx\›ð|PÎcèº_*>”[ÍA�ôÓ&U Š÷*FQSX‚qßEÆ¥¾ô»xVAy¬=ì ã—‡lÄŸEKvp΃¤;ZºGÕàîSýĤb+Ù°Ä·?ÀwÅqá„Ç9O;5EPmžK-±Î`óÔ/¶¥˜[©þ[± x�ú¡å]™ƒŠ‰ƒÛU[Ö“€+ôéèÑ%¨Æ¦cîÐï»ÿ‘YÎÚ(dK >ƒ0ŧgò,_ëÕ!þ‡üvo'>)^Æïý &˜Z£,Ži %†ú}W†Ë ebcßÐÃý5l¯­ „âºé£§]üÞ¨¬(Ý»ó<é8ÆA>Zâ) r§ž}i‰Ù->™â¡ôu9$K–²ÿ ­Ò"H¬6íà Ò ñ(nXfyÞ>’$/Š…4Q):É¡•.‰«Ú*ð-ÀÝð)‚z8¼­ìË<gÌåÿ΂ÒÝ#¸qwÐÜ$zß rò:F4šÌ‹¡ˆ[Á_Q¹Î‚ÄΚ®—æ& ;JïèP”3[ÐÜŸ±9ÿúŸœ}¢*OS«&Å#Ê¿¾¾Äb´«zð�ž»á?›".œb™JÐýÐÝÍçÖ£ÊÓW¦¨>b"*¥ è œbèÆAK!ß(Zøƒ`þPg,ƒ¦Ò'ûn[_ºiæ¢}o›FìÐ< oçB%NÊ'ð4î柵£3_Úö2|4g:“D•¡ïÏÈb÷=®OwÝy2ûž 7Ö{¨Ônµ³ŒÝÎù…å=ˆi*•£€Ž²!�œFbÙ©{eèMK«6.•å"\mà@:YèV_[AÎCN­4àªÃý_žúè1Kp‡TkŸeE•*Ë”*ª£Ð+eŒ†Üöü…2wdíÎGÇj?•AÒ«¸h\ Œ(ïˆŦ;Vˆ»DîµUÕ‘$ NGL­¸Ë‚f±Ýκò2-mhßònI"F�êü:¬­–Šœ– AÍI—�Â#3±«e&Ê7ç ¶Y9™¸¥žòÖêÒ9Ã=Ä9 Ô•Òò­_‰ç™mEËt6^9:`Jôq“ýGNb¼X\ Ë|÷Ò{ŠÜÊ¥›`eyN?ååÔ©''ÆBs€Pþ©Cu3J·=}‰¾0½´aÇzø±Fâê­Oyešùà/‡ƒp0›–Ó>Rå²ELëî&Ë6@÷×tæ3º¾=èÜþ)Õ“´xá \,ÃÇ s‰"¨ =4 ZÖ+?õ.é g9æüúÏ hÂ]ÝAˆ‘M»�z9Y÷cAl¡Ù{ûX¹Ž*sÊ9Ú ÎDÊ׺ùs7é¡x']˜yÄ•(æÝÚMìàËl -QDqÄNî䞇œVÀ·‘ô‡ìFúq†¤Â´}Mi®’+ üaSÙúâ1ŽÍŽç€ð¿y‡'‘Ú¶ˆŠNœ×«º£Ç¦¿ÂÏjy¿%&9¤âa�ÿšôƒ3kéOTD`~v”ycjŽ«?I”ë­AÕrCñ‰ <5ÅæþÏ`øÀƒÿ¢„ø/+ºßéo®ùcáÕÜ¡iaÝ49¯œéLÿ—“ܾVå(ª®Pü(\%­}Ò•Áê=Wý{KPf¼èÀ½4ŠµA;ÙðõÔßâMäa˜„•0À~%oO¶Î5ß7†Ÿ’Eï]ÝÐI}Ä ªyX;ÆÖ¾ ^h ã²’äïú|f7ÄøÍ)…T„ÊGÂ{<ð@ÙsY»Ð»lýÊ“Çžü±qsl·ß½À—Сv9�¨dÎͣгÕüÀOÿø7ÿí»ÿªÕ³æ|I¹h<Ð g‡¥ÏÞmÕþ�¯Nnó)ÓbÏkðW°<Ëü&p¨vT½¶l@`ÃûK–¡a5°ÿº‘B̲T(š)©Ë†OO¨é~p£QñqBá Ï< k‹tÎ[ô‡àƒ£íw’·$÷El¦Â„Au´Úq¥@ º50SÀú|VcöfùÞYÏ©ÆY¬9–“XmáÉ3xÞ²€øµ‚…`눣€YÊ×ÿ ¥ŠW18¾ †wæÄÊ­ÈÅn4V¿huhXö§·fIç…ïóMKc}A!¶ugìá‡g‡Zݵ 8°}¦{¿:_Æk;÷4sþëwMÿÐ#)6ÊŸ`æAÊO(z›þáÜ9ňþõj'Aj¡²ûàŽn ƒvóÅü‹!B}7}Mÿw8áïÿÖsRy—¦�”îä±í›®^ÑÒ‘E¬ŠOŒÉ{ŽiËŸ U…5L­ í DÁ“¥E|^Ášw”ŠÎ°.íÅ?ubÏy‡hñD½Öq¶Âha¾‡ž}WÂ&Šóí*#ÉÈHƒèódF?U(� á@Šª9ôÞÁäÙ£›nÜp¦-û£QE<ä-âí<½Û‘åRúˆ- »ÖMp·‡¦™Lv÷{½BOhSTõ¦‘Vr³õL|[­¤[ƒ„»y=Ñ./iLW D[ Ѥ€¤Â¦û÷žøl.;H¦ ˜vVΚ³`j„Çùþhqæë›–@dáÄ>[MÖ·`ê •hòwfx õ†êÆ^?Ãb6îóN�gÿ«¤ïc•ª³äÊ>Ë/ÐßÞwïÒ0bë "ÚÀipj £¥{Æ}~xD ßKÄEW÷w•ûÊØ!8OÇ<HjmîƒFË‚£`%øÝYˆ‘ß‹j‰ž Í5R4Ëã…!vIñ(ÙOoLAY+¤<xÇŠbþn½¾y…pJ•y ¤-’*HÛÉ6xcI`¤YÏ·„e[ë?µ…/^¦W ì˜âɷƵ �[n§ksLñ�ëÙP½Ù}°òÆ›@ñ¨HýÝL™Énñyt ÿ2Þ^ÑTjòÝ»þžKâÙ^Š¯3r‘Ê–fð{¤·“Êl®gž‰`ó?%#VŠÐ°÷áÆ©ïOoØ Ÿ‰íe=^ÐÙ~T´q>Œ’à3Òxé)£ Sõ¿ eKÕX›Kÿ/vÜmP))žÓ“ºïæLž¸G ›I¼-ΕŽYMžÀ%‹ÒÔîâÙüaÅp椓¿é˜w˜Î:2Šõ°Œz÷íL'¶±ž: Py«|Öæ¾D«ÕB±DjSj­Ó®˜=­{ð«ÜÎ~³H,R·ÍQH5Ú¼`å¢Ã¡µ&Üo—ÑqXø‚·`œâ è=ÚãÀ5 º¦ ÷5p Š ÷GVB?4esßgt£'‡®ºŠÅ?†šÓpg®„g…ZjZoÉFÕàY€KÊ3“óˆ�t;Óh5€­øUð$qÞ |ܤtOŽªëÉÝî=î7å– ôý½+•½ºù…ªë,•îHµ½ö µ6y"‘|:zWwÄEã2v›”eyû®`78ö£'pb­bÛÞg(4‘8Ûã«u2{&ñ—dKõ’R=*–Ž $-X$O ghí‹Oç£Æ¤™§b T0h§ºôŽŠŽŸÉ›æ#ð7 §j¡îúר×LUY”íqðÖÃßs>mÕ!»±ý_saµÆºErZd‹á7 "gÃÖéÑn¬unöÑyg# w¹À¥g,ãÙôH«3ý¶÷™>ÞÅ:ìëq¶õÄÇ…Î~n\ýèÂcÚdQ xÇŽŽá¤W‚kÁ¦YÎ0\G. 5ð(ÿÿ÷ÿ¥dõ2,0µ4nÔ'<,fÌ\ü‰"% ã­€ÃÖðN-¿Y~ÞvÃ(Mª¾ãYOW\‹k%E‰GBŒY;ì» ²õÆaüa>Ì×5/òõ�ðqF«•'#ÄïG…&Ž­'?.Š4ÿ‚·Îñ•SaðkÔ‰íßH#ITŽGn@ÇŒÆ*EórBÿ?ʉ‰’päid?³ç°Âµ³?‚3_Â9 Ãô>ƒ!ÀÓêï9¹&kn€ôóšrÍ­ˆ²ŽHä;‰ÙÝ >Z[Ÿ{Ûè¥=v´ðô%t,N£ô@§…ÔÐú;$ìï�4µªðþÚ¬¤Xˆ$°êb$Íä-°Ó¸a!a3œbÓ®õZ¤:ÀL­†cš^‰È¼Ô½DÅdº2B§€qìbñ5¶£)8äŒ<_A'4‡É{¹*÷¢¸´•1æðxtØò[[XOßô¼HÑÍ E@9W 1ŸW!:–s”®ó^ïªZêW3Ø·R"ß·AÛs–¬w,z«Óø×Ã,R÷ˆ‹…¹!©YCòmÄL¹Š¬ZìÀØ»”YŒ ©¾ßuÒLô2ÄØ»?áD™Ø®(²%Alë¥Z©àÖŠµ?Ö»†W¨žÂÇ<qíeƒ¬[[i´˜¥B¹…!Ý%ë¡+§õØé"¼-ì*Ï €åPx’Î[K tj=;†þÛ+²]ÛÌô„è¹}šE®¦óóN%É×;ÁÄ~6ÓÝ·7;½rG -÷]d£-Pñ=vítBSÏdkÃAÆêö⩳Ò"²eÖt�±Ùþ‰„g”%»z°ò·®AÇN|ö+E¿fKÇG´mœ¶ÎÈJum­JÚlè6É–ó•hþóáÿ/ü…dòÎÿ žUæÏé|™kÚm©GÜSö°Tä–ºX$ È4#Çë.K’. 0¸_±X©wtÆö°ú2»ÚàmL»Ôû÷vÊ[IB>ø£æ£pr<2U˜†ôϧ|äÌ>%u¡o1¯)4•M³ †ÒB¥‘Ýz�‘ɼò*ãJr‰ÏÓ…´&}qPf§“ôA�¾¨™8Ë÷›§ÿØó¢È4•"ا™7®­ØjPØY/š8ûõÊÿÇ Š­Ef€G,AÛb[lgo¢ füPÍþžV'?ò.¥Uº8ÔîüÊ°+ÍÀ,cãÀIq£ÌˆF·'úbz ¿›mGåBä*‚Þ×)œ&±eÙq(­§SWÿÙ‰zöOǨyy±HÂ+]nø8A6¾V$+‚éÐú0Ö4Ô_Jçn¼t4‰…f Á¢Ö*[¿×®Ô£( ¼t¦õþ?´ÿ‘Wßüb}éÛë, P ddNÒí*ZŠB†)áñ�Q:»L­HùS¹òhÁQƒì%cðÈ&›>ööÍ!^•Å¿SªØS€m«øÜ$YÎLǼ½Ï‹ÒiÙý¹ÿÛˆJÐ*Ì3`TSxi}Ä»|s¼ò_ÄTE«¤·ðMîT ±üŽžD|:Ûó›Õz7XdÈN²ñ'Y@Ã5B'‡ççèI‹1†loQ ëÎhp;žÈ­€|ä[£1ȇY]?³…'Ëóä ±ËÿڬɥÃgïùðÍò'ðï• ¹oÍ°ƒy„æ°Úèˆx¶ar/³Ž§ñ€ÖÿÈíH'cÛ!•À2BX¾‰ĉVƒËî2Û«›éZáôëLføXLk3r”©ßŸè/¥”þ7¡dßTtD†® ?øRJímGìÿM “ØbÄBã€Æ*ÍáÔè­„CѨ_ñßt™³Ê• na¢Ê¦V}²øW÷>;¥ðšY,¨·G&ó˲¾ZÿÓ¶C±>M0P^¶LEþaÌ6�¾Z­Xp)²s<õ½7_»VúD7¶Ä^ým^qâð ã¢VZ ¼ÎÍ}¬¢qÛ¡ºë³6ß›;Ö€PõΫ¢,5-tUÆ`f6y`,鈚ÌW<I€ßZÍqÈÆY†9˃/ý«a„¿JATµ»è ð˜Ø*úË�¹‚=s—B ¥3Ô>­Øo¢qØÛÖ%ËJD6§ƒ~œJ3ëÚÍòwúú¨ %©Y®©1“›×1-×o]®ÜE1%š³³!óL{2¶‹i aJà}Z�Ç+ÿ¢Ä ª—vÝri=FúƱfˆFÌj΃ü»÷d\6}74Ýøg×ÙÁ6� ª¬Øi—PÝúa12Šÿ5´ò‹›.`µ³£PÙ®tîµ°¥pWj6EW4"œÇQs¶ÆÎôÆTM觜kd¥ÊF|îYã4 Ôðr{¤Òæäæ\(=¡ô Ð?e{;n Ô—ÞxÎÙ+‘¹#ö’¦qVZ_6 [Ýü5â׸Õû¥‰s/¬ù«ñ_ä­áòÅ %Ȇ¿¶µ0€ÚïÜþ˜ /3/³wáAlG B%”5Gwb‘³½D´;Y]âã6ŠOE#â¨í¼ÌE“ȼ<Ž”o=R�­ÐV¦ÿ¿v=;ùw¤[è!ÝÐ÷? é8ke Ã׺÷Åö7‡InêÕëbX‘z‰5Aü^;ù*IljóÓ_yúEF± ÜÖýñ¨Fl Ao÷¦.˜• ´;=²þ”ÙipŠu/œN;+ÍX*�é» “‰†ÞX÷Kë¼»¿dí§Ð·§e~¤ÏÞ+qàÏn5Æ]mÏÃ?ŠC×sÂ,;¹aú’¾IÄÜuÔ'½¯g½? _þIþJ•Í›-¶¨¿Ù;ŠÐèì6Ax½Í{°*]RdÑv=üÀÂa<zD¨À¤}»k)‡0QÒW#]*“V¡/|AËs¢]øÆ—Ûúo׳%±Ž[8꫈¤ÙÅïoƒ,[hϧ";”´Ÿ:áQbžxˆâ©¼VßUEò†”vlsJyÆ¿žÉ+p“,:5+9ªh¸sßMpŸøà»ü‘#9kèbBTÙ˵¦\-·ªÙYÎÜʃc�ðE§ä îÿ$ï¿üÉ“,à™?ãâ{zÄvüh6ZèÚå1 e÷^pŒ—¾‚3EMi†œ´àl瑈’µ!¨Ðù0Õ2] ë²Û Û!y‘ùÒèªæ‡ö}“S†,œ#ð–ø]–yˆøXE£VoFj07hÝ:TÅ›ÂÆzoŒ€ êOø¢Y%Ê’KP–fSÁì�ÚÚÀV=S;;Xú?zC³Â@:&:k£yã™oÂŽÛB‚ÑŽ8íkSÓŸûú|G„!S·àE^@ËÖÃð1jGÙA‡Fñ ¹K—u3j¾C˜»S+¬ˆ) ÜvHØ]³ÊGÕPl­nsîì6´©~42ƒÆ‚”•ioŠý6ý•×m–j!¢ƒ‚5k:„{¨)ê{’‰­ø"¢`Þ¤½¸Ó²üÔ”>m—e”ÉwšÄaÜË ¨ðn’vµt£&Ê)ÖcgrA¦Ó.;îÅB/:.Y7<¶^°ß !‰jU&÷qŸþtU?R6[yiH\ç"ˆœ)½»5Ä]7*–‹•Y:B¢ ÀEu¹nkõغz0 ›Ž%ú’‰ítäróDëk¢ã|Fâ¢/øüÏ´Ô'þÄ¢´SŬ2'%g‰“›I;¡x»ž"/´â¸Äº”ò9늊€cTÖÔL úêG8{/”I«…éä*Ñqúüv“ôî´êw­ë]<¤{Í+Nwš*¶2ÇQPE5ƒÏ)ó<ÔÖ~·ß±ÒÆíÅí 0+2g±û$ Š­2ˆfCø ŸÓÆ´>®µt † ´Ö}‰²øJi¡ûüôϬCûTÚBøïÖ¯åe&9Y°oÙ¢D“è¥Ð@éj,Dý’ªµ2È/Vfm˜m}æö·³–•ÞßîRê<}alÀ£Ã‹>ò¨™-ê7zTÒ9UhÀùð%8EÿÅ)DÆÙBY#«×kÅÌv«ªÇ OÈA¥i(1oÙȃƒ$7ZΩ5® Û;…n¸tLƒÕ>óŒÛ0t¢=½1þStUæߎv ö³=ê°òºtrÂí‘Þëó¯g$à¡wšÃÓî{W\º*Ý òiµ?Ž‘ª!Yí”øäûïnøïú$ÝÀw~ã<Ðò…òS˜‹ªÒÖ¢ÚÃ’‘µl“ª@«·e•òʽ9Û2A2²½H Þé¿ ‡¬NÑoP#ËÔ†Äa°èØ­=d8F¸ÍÅÓC¼3-y67qTýÈ$°_Pšz{¤„5¡•©mBô%ö@µ3¢ó><Í9CEÁ J˜/ý ‚“é‘’Æí¶Û Ó ß"Ý¡Î{ú19O?;:£J«–]$Ô87¬ ¯ç è„»‹WÊ‘iâ6·èÄzÆöfY €¥—0ºÁp²…%¸èó^ýĺsÎU#b¸$ú¨¡¡Ä.|ö1\Û×>±9¨Âî» m‰Õ©˜Ì¬V«û ôÎ\,õ;R´‘XB¹üi\1ÊŒ=·_k$išysæ§*åh§ogDóy°<¬Ýñ¨2QöRžßýæB™G¢MÀ½L‚ÒrE¯)Sbé­Ý2/£RG¿…qÈj&z×´ï½ì¥«OÐMó'$@æŸ(±ÿﾶÓüÇԨĪ¨1=1Lƒq7àþÛœ°è¤‰ 5•V“)£¤eº=w§ÌëÂA [àÒßÓÿ ZÄ@”ѽ§GTŸ;5>¸'^úJÇ´4£$AÊaDÙ§l%[ôx ¼[»ë­úµ±±zƒ…‘¡®5k‘‰éð…ËØÇ*2 ä3›EXWÇßì‹(»’Œe§µ°×‰­t-èA0Iëëã½)þ=z‡ónZÓ‚xi¿–¦>ß²@qmµuˆí ¯¨9Ôâ¿Ëra·QÁtþVóÎà D~Ä–¨sM ß`ä4Ú¶ETúÁ1¤w-¬DpÎÜpŽ×@½Gcž4÷§½1|Th}n4a‹ÑN›0~äÄ›¼®ÔÊ£ªŠÏjŸxRe® ©%Çáƒë X†Ó3 =Ëšuû‰ ^ïÒ:Ç#qÇy.ZNåwmM°§?°]‹UÒçß*9E…TÅàý«Ò®_è!dmD“q¹¦Ì‹öLšwYGÓŽè¡[nÅ^° ›Nü¹0 ­±âÛÓ(5ûL·¶}*ò§ó§qK7,Þè¤ø‹V²Í§ÿó‘›83g™¶÷N½ÕRs—÷=s’ÈÀ'Ë Úþõˆç´j&fÔËãx¯ÚÈ_uGf{¤Y[Ï*—2ɉE¨ZÂo„"’(Y™K`,(^¾=Nöì ÝÑ·˜âû‹±À¡$õ xæl›…°ÂŠ·éëãìÑzP\ˆÉ‹…%*kÊËõ_3p­‡yw8Öjûå;¹æ¼¢–º†}½‡×Ý=§×ÍQv_°,izצ¤q¬Oýäb+rfïæ_ù„/Ê:¡ìXºŒ*º6A[Ÿz†a<UvŒ=-‘Mb2Kþ£˜â@7ûZµÑT¤ gÖÂ…ìN*¯SŠÕ\ÉÖça´/÷îsg_)G|Öé³ïnÊ¢¦ ¶KªäœP’@MM"´6ž²ôW¸£öèL¢Å\"D ˜Íäiº?&9A>-Yƒ»zléàH ˆàˆ•SV¢Ÿ9k¸5zADÅê]oRl´Æ®*qÝØXŠÍŒ¢¢§ªø?]/&g6Jù_”£¢ÐS½LP>°@O¯’(‚h§ýÝÞï“ölìM^QÜ}Åèk¼¬PÃY’-ƒ fØ\^ÊÛ¹†5³” ½A%Nù}²õ8UÌãygÓúŒ ~ ¾Yn¸°sCc6÷þ)­þÌ:ÝzÓ -+ý=Dïû5§ül#Ö8kæ–Q$b¾:19 «ÍÐëŽ)|¶2·ªÖʙҡ?-R†Àè˜ÒÛRê€~Á3}½çN‘¥WóÐãåQ×/ä[¼¯ÌéÞ®;Ù‘ÒðF)Ò&,ìàTçGœ¼Îzü*ÎÚ`[dž BÌ&ª‚èÛöÙeF`ÉKôQ/¿:Ϭºˆ%F³qfùy´ç4Z³gFàœ³êé@yô»ŠÀQâmÔ‚A::=ÂÞÆ0eØÝÝ©¶8Ï]¶Äyü‘ÔS(Ë£ HO–ÝÛ“íļRi%l?…BãEcÔšÝð(€>ùê`fµ rΟ! ‰>åyS·:,4Ê)¶�2\_ׄ_\#Ÿ£íªs]0ŸÏ£Owh· \é»sQùhíH` ªÌ˜GyA,¾²‡4X¾¶�GŠÅÖÓÚT¿Ëõò̃>ÂwKzh½à‰™ÓÞZú%kù‚J3¾ê:­˜iq¹x¦pg¨ÔR­h¸w ÏíV ÷.ëiÇ>8NkÀ¼µ¨Áj„ò¬Ìò­“0¯™PÜv#Oõ%×`{ç«)ÄxXm¹¼¼?ÎóX¼áu·Z§´£>k7áC`øX÷›„Ñ´Ü^Fª‡Ûõ®ÿÝ^’FešMâÊÞ ®] ó‘o’þÑ{â¹fR–{XkÆÂMg�íêOŸïÒ4|˜Ú_……,÷µŸè­}TÇ­93ñAf®"GûÃħ5%¥hW)1ƒ§Ó 8U^!Û£`ú¶I¤/(ͪ$d[½q{‘C„³BfK5 è(Þ×ÝÁ*Éîí©åíð?úwMþ(-2o$²A>èYžUCökø¨¤ä¯LQo2À}ßQ›uìóûëÃAį p¶³±–+&Úh­äÖ‡MA´ ÒÒá΀Ëö/¸Œ® ÏÀ.(×ggÚ抰²J‚‘i³Îêâ½LÍNùDF”ïÔQÍwéÝ×:$—8zþŠÑÎå5ÞÖ V™¶K=;Ââ aìíý/ZÙERe6 }œ*ˆç™'TOFÆrE:'Œ«^ÜáˆØŽTaîIC‡mñ©Œ®Š™jÀíªòÞÝŽ}`3{‹tCTµvÚSFö­UÜX `<lÍ…{ËØ‹DŠ©Φz!…Iåά¦½ôm$Yè#�>°«÷�nðuþÖïvî2ÏyŠ)ˆÁ¸•†Mb«¾YŽJýZÀ×’Š•o`”¹ôêúœ;Y=·õ ¹î0Êb+º³¨ŽA¤ ¨ZØ[äÖËMËOp®V¢ 2L>£}–È::ó6迤öÌS¡&öãdqL¸úK `†ùY]êÇwÔ  Þú~ìmZËüÃ|£?u ’÷3ÃÒÇYFîê�$ñln€€[¤Û“Gsø€'uöõy º¦9Øw_wC}úØÀ8òê'£%ª¥ƒiÒFú^{袙•+‡ÿ£mU$Ê» UO'mì²>K7®.oSϢе—dz ©Ö¨Óa`ÂÈd­RMõ÷\}¿ððVÇ‚_žÚ@Ü6ŠZOÑsmTª‹(³!&n©™k¾6]±]çïSG Ÿ]¨&•$cMi€™ßy—ž´˜ ¦€?õ£V: 8³¤2§3ÿù¨Tõ­d…l_ïÝ é!“Å…a‚CxZ;[3cB^»÷„Œq9äççŒzë$V7 ABÌ#Äòµ“:±NÞMÓA‰†!DáRÎÝžª“Ÿf¥:¼1æ«ÚoWF‹ñÿ•?aìÆî1Ë6R^SÚ"Ö|Ïožó536¸1ù2É)™Ï :ŠÀV>.)nk/Ý¿tüÚø„–'Úñùhh3\ºƒÉ‡ÿÇ™‘Ò¼.‚´ù±Zh¬\¹om† ûºížIŤ‘×$Oøè[-×RIçù‰òÁ©¸= iîÏ=À ‘nè–R§¯Ë”Sbçñl6òF_‘Æ´i›Ä^†’8U»ÌÂSƒ$”16&µsB|)k—§ „½ôÒ‹¥qThöý4£qX*n=V޲ÑoÍhQ]ö©,°èƒí  Ë%ÃE`~·ëVŒ_ވëvúþ«Ê®õŒuW‡#[ÀZ]7ÄF»“Ý´: XžþD©N’–•ëÑ[T“tÏ£}¹>4i'„B’Ò×›ÇQåÙ«½Ú¦UÎ¥Ç&’djµ££¦×—E“8 ÃES+Îm„ƨΤ06F®aÈ%ìòÇy‹^>vÚx«¨GŠ¶*x‰†´À©Rî×*‹ce¸ø³!¯y஬xĵz6:Ö<b„RT§)Œ!õ±9A/µ¶­Ü#e˜âó{o†o~±‡L„(6,qª±¯–ÃìmæšNZ2#í_< Þ²ÕñZº¢Õ ‰ÔÇø#Í¿hUòŽ+Pè5ù ™¾ª ¯GOíÝÐcê/3䣂aσ}½ZÑ‘"ó¤4ãvnÕÙ©x§­Z,Oð¿Üvíûm\O –¹MKŸÅcæUzÛºõ¡xlH‘™§;�Öb˪ËkGŸ£09áTú`Ü2ûÂø˜ñðÍ.¢ÊÑ9³Ÿ¿Ó ˜õÆ$â6 ÚAã‹Õdz(ÎäZLÀWâÙ69®n¸=ªl†i {Ž‚ü@ã0»Ê¥ãÜèb3ó7¶¿±sÛÿ¥ zÚŽìÝÂLòí«òAÍõbLSd’'½73¯¯ ^¦ uY,ƒ¹dÙï¡®5¨Píß^§UìƒsBÿÄݧ§9ov¬ŽÙN“šªŠ~Òêñ4\ ³f…}îiá:1±QÜ©³†i »¿“n~S-úJݳR{Õ+J)­9{刜’~ý^±=Ê#¿¼ ÌžÏüæÓµ‹ê¾Ù9&Ü/Ï÷´Ê®Þ[§A¾={óÜ ™NrŸt<a.s|ªª'¡“…Èy bœOµ+ðx.曨¼† Û%1Ðp 3E%æx[ЦÑpa8|õð¤@d5Ý¿Dâ®®æs„ßGo¸‡}iÛ¯tZ‰¸éÃñ¾›À„†€<•7 >[ÓQ9jSû³Ê¾Áàr·EÚDgZùwí ÃhSNÃîˆvÎW×#­á/s/?¸Òôg(›µu8§!¤|r�”„ºóŽN@á$¿E•~šÓ n왈~Ët3Òbƒ~ã'y:µ©a0¶—<¨¦Î;8ˆQ  À[³¸4òKªäø‰¶"’xÓ"®#pž·£j OYˆ@Måpcè4?ìý¹#ß1éÄax³Eó¶Ì±§Ô4nUµ™vSŸŠƒ…=h8˜Ð:n}T·(|áI¤_žŒ¬`,Æ.#$Méuø窓‘Œôðærd RÕŠ©ªÿB$ÄÀ�(ûÕÂþjòõËB¼ ƒ;òú[mÿ·Ìgø€¥ç>³� ܶhèv¿oå–äÎÆBDßÄ;þ´5Å–ýb%ݺ=×þo{Ç»0–ÃŸé ¥±óä& Â6¾TÒÝô’‰¢W?¡èq™qΪi tnÌðv6Äõ“»µ\‡\Á8¬§õyöèÍŸ˜Òéá$Øû×|Ñ"ÞDì j*ÁcÂn.lm"ým $pNqÂ?vs½e¶ïÑ1EšqJŸÖœweº 2l©÷œ»-}"æàVIKçh[�°‡»?ÐyÅ™úoMÔsdÜÏTPJØuÎ|ÎÌ¥d©MëšêS¾ªg‘óDø¼ÎZ®”w*òºU2ð»ÓˢГ�¦Û1OôhG=°@Õ£ˆËï Øi™ÄOFòýŸ0ñÌ|±Ž(4†t£=’ŒsgWÉ5%êlÌ|m3ðÀÒëãž°ƒgcìy çÑ­v%œ§2Rn/Ûýiµ¥@8ÀJuùÃ#uʲÈ<1ð&_ýìÉTI;!UîØf–uNßÛ",€êÔSRn³ ëÕ·y¸tJ54Fåo‰㶻H…©íT ùè[fÔ>²/e­ZÍÙ<h@ Ö ýÈVyºuÌÍK¹ }b²šþHlGÌŽ> …Qè/�fcÉnÑ—Žr2×Rå‡ 5Ÿ´S¯O*Éio|ž†•1àŽBoÞ¡“$eì)Âä b ¿1ZGÙڰܽNh!¨7Ö^œG eåî;ÛEŸ' K/³§%N¹'¥ÏrçUÏÃéݽºÑŒÖR(ߣ„JwdÍ·ãW®q.[[ÔÃy)áì_ÞG?Z6™ulFÊTc+ôîC§Ä`·F%©õ*¥ð$—V¾ÖÓÞh5Q0¢”üô}à›Ã´¢úz8HÇ‘ô—_wúfž7–_WåÐYQÔŒ}ôü·µI“vF¾Ì]tcw†…Ï‚õŸøŠí"Y0Q–^o<ÄóéˆO8bâ±£¯ì.ôȬÔ[LÁÜ#p¼44³z:O»çYåEÔýèL^’…‘†±Ý“Ì“‡ùù…þP<\´ ‰`ËŒ[³¿(²wj¡Ì’¢J¾ÓËpa1’°´gÁäȺ¨ÖZtI_Ù0B^ÛJ¤Z™ŒZ¬È¾­í•LDЗ5Íàð"K’xÁm,¤_’~n=\ ˜f‰»Ó°ÙËIõ²W"»G,òª‚xì�+ÚÀýå:ã¹O°¬é¼õ¢Ú#]NÆÙbù"±{ƒpžv\ËšîÇ• ¢Jæª4]Oѯê}0àB#f’\cÓIsG!¹â4¶1êí!'acŽ|L—~Šu ð¸‹ÓSÝ?±„öÛ Üáä•R|ªtØs»¿­2è?¬‹x9ý‘R=ÍÆCuñÄ, zÃ Ï §(½Ù^Éf{eŸJý@ä¼~ãCú\ªóöJ "ÎâQt›-­”ÜúìD¬d{´pòèo]ûÕtd KÔ8]K„žíaÐ}wvB$Ú™3‘厤VìŽdîü  YöLå7”²qêfB׸Ý[ìLŒO¸qýªî©Ê:frmd›O’v8QE»1ïÙÕFú®núãìJ„ÌüƆu õ׉ò ”ÿǃô‚к°²É+NL|%@‚‡I·Ú™UC¯œ7‡à9X+ ŠÛÃàí›Û¼xÓÜ1Û‘¬1úÖÞ¥±€VÜ‹z8Öì"âöÇ·{ÑVRX”k©´9×”’ôŠ±ŸNœ)s—Ìš1‹ö  S΂°~£§+øØ 6 Úk<CÑ5Ÿ Ôàv°F©±¬¦LÅ0“€Sà»øÔ !ö¨œäRyJ‡Å \ªô㿹ÊgŸ½ŒÔü¶Ö|\Q åíóeøØÖÒù½ãø•/ˆœÒFÚmLC4jOÛq¼˜Âƒ–k=Ig†‘Þ«û©¾$ªÐ÷ø¢›3O|šl|Qj à$êÐâ]Ñg–±dåqätwéÉû‰­ƒ@�‚xúq£Ã/&\0“§¡í]jÖ¤ôžPau«uRñ<xMc3ï6Cò®mëU/T>·ô9·aÚúcu–ùó½_1®ÙÌ OePnמ êÜ¿,ÓqU(JK÷PGµÇÃnpú*Y/nF òoM™!zJK¸EÕj£möš­Qx3DvË7tÇË“òb–'Õõ%šŽAPìNÅ]ÿš¦€#<uO€YlSpgŠÚúA²¢¯€ò€¬·oOœT ôO,iöÒ/n…Lþfj9+›æpˆ†i᱊* q>Tì]“(Õk‰JCYm#V“‚ ¦éz.l?¶‡ö[ylìþ£’v“¹Cÿƒµg䢒�Ê0óÛR4¯ŽÖˆ10öˆìO<“î¿wÐÇQ¼h›—ü5ãºsxm–Ũ¯6"ýO~ýª9¾×Žg!—é à¦VΑÙÅÁºÞ~Wâô#ܽчº«¿®ÌQ´Ÿ‰X<ÅÏ‘’AkõÍîÛ—ÑŒã-5m¡cí½µu[�Åiá<Ò î@—ý“¦„j'h°:+€è&¹‹ýaà»,ï¹ü‰ígæs9Îkúì›É­[œþÞ(Ž²Å½«kL@\D>ø¸ƒ)”X ÏÝjëO+–…G°p_cX쵧> 3±'8#šn\ãnJZ¸¯)8÷.Ùÿù0šSøÕ¯ý¿,Rp1Ü=©µf/UΖžíé£CMCµ}Ž‰²Èàxîûm×ïîø|æ9"#j±§@nk'‡$¯¼qÄ{¸¯üÚôF$Žm»¬"ļ=ìë ¶…’Q�¼ÇÈ\©­ã„4ÝKQæì=ûB´}‰'>¿ €öÕ°¹ÙÒSúœŸ¶¦°Kƒ>ûZØ#—5‘„aÅ¥~¢Š¹8é�5ÕÓ•yéj!„<ÁÅ™ JG%PC=»óå,FÇÝ9°%Ãs§4tZ‰)ÂWÛ%¾…Xy1úþ¸xXedÙ®ä]W§Êséd“vCJŽ¾’ôÚ€>u˜ø–RT• æMìÓ((çÑ-çm=ùƧq?]K>ê!f©ŒX~Í0Æmµ+•ñZ¾;Tâ¤cXˆ~½ÿËÛn«§3Ï©΂²UB‹´Í7À1<Ksó‹'.×± šÐED[­ysa¼µœ×Ž»é:n>f-Ù-kú]YÐLpjþ´³th׳»>sºïÊM$Èk#CºòשÊýßz´#ërÙ£©ÛC²’ª²‡v f Û²ì!cé…Ì0F+ᦴBÇŠÎ÷eôGÏ3Œ*0ëPG•ÌF¾èœÁC—tTyûĽ¯w4ÆÉAÜèØàLÚÅd¢Æ“ ÏØŠœ=žœXâ]i&e ½EŠI8¢O@v}Øx¶â¿< r'O.¡äx�¶~ò–Õ'ì!¼FçSäæRøßÎ} óá§)cÓb³ëÕ4ÁOµÿÍó5¯·Ml_¤ dcñŽÂRlÈ, �yœ¨Ð~æºó¿ºúÉÝþã ÆfÌM,ؘ|«y  ÄS63u¡ð™uFgy…ÊQ!l•Õ·k¤)K)×U3¢î gLkéGS˜È“Wd78P“·T¦‡ãhUE·À;_;œOpѱå24ŒØ“;ÿ™úÜ]{ß‘ø…wfÂCa?Sà!Ø¥�»„Å\ë‘¡àÆZÙmû—7Rc¹ß"Œ¸»NáRñ69ð+ªSš¥‘›¿&ݾɾ¥¼È@+JL"nǶ¥µ`óÚªUþðÏS[IW’¢ ʉ¬WC+ ¬{Ø¢óê³À2SKܹ²Á±ªlQaöE«¼è­PaQà-~yBÅá÷öõâ½£1*=_cð•àv}¥}Ü à 6Ãaì+ä(fµ[fŸÙŒiÒ î‹PÒvDaT‹ÆžV ¹xô³GÝ1³Ç$8°ðTûׄÞ¹P‡ÖïÊù¡KK@[”Ïå¼-ËÄÄàü' òúìcØêÞ:³þJÁÛåœ/ðÐ& ÊõäùjÑÍe¼y†e†~ü‰Mz%,fÓ„ÒèpÍ õ)Wâýá`05¦~愹n.«?J–o˜60©xãÑÿ¥Ú˜Œ„RœÝÔíl„¬£¸Œ¹fˆŸÊÝÏÞ’–²Ï *6ƒŠbi¬…Cȼ=Sþ›!v’-ÔÆ(~v?ô7NGƒž ÜÖcªÜw±ŒsotÍUáô…¬©µ¶«U­püWfÙŽ ;Aª³+¨vûëÔ;Ú£=-â“ž)ÑÅáRa, z:83 =²`¬h©,˜4¨ì!ÓÉÌÔS~¨€ÚÓ›˜ÖH…ÎÏC„Mmjà ӧÝFç Ìœ‚NÿÎü{¿¶H<óYBX­³ iôÄÚ¯úúâ7Q3ÔÏëzSëæ]s³^?|ż¥òÏšûI~ëíg{XI_¼F¥:”×f‘fu¾âxé¼1î–Ú¹ëQNÜéžTÙRч‘e«¼bÔì@¨ùNÓùY– KaiðÝ>CK.¬¹°ßL2tììBÇ‚*bÝü{lxgÑÖÔX‘lOÝS­”+–àƒ°šM^dlÒP™€ð¤S‡åi÷êò0vbÛB_äÒô|ö†ü«-=²ÞV¥ß'”î,‡ì˜¥•+ÃpAŽ-Ø?±°X–ÒªËøÖÒ=ñm+Å(‰ü/5‡:âfãz±†!µ5ÝÊÝD[JXt/Äy‡a>ˬýwésQÞ öjÖœ=ÑÐ¥½ý+æjd+åÄ€Ï[8å8iJ c{ú¨§N{—_©ì«KTùÕ‚çc R¬7&ªjÿª9»8‹'Ã*‹£+ã­|ï9ìÍôì{Œü†Ç¤×3+¨°e2:©CÖ¦öŒ Ä”üößhDÅά×ðc¾ÿ÷‰i6&FQŠýyvGGx©!i²(aœ)¼Ãž5*wþhèÿx=Or«Œß¨2êT(ƒ5ÏRyxê… ÊÍ-Ñ"¶ˆiäVÀ¹¤Aj,ôõ:{Z ‡x·ç,µ'¨| 1,¬sweê¿4]øjaÿÐi˜ôkGšéú=˽šD£í ¶Ò\̇q)¥ç�¼lï ]Ã<a3néÒ³åU7£!y6ÎÛ„òùq âx±Z"x›P®žg×Ä…#)…$4H 1+Kº•lûp劉j÷¶ 9¸2Ü´N%2Yo8+tî_ÈiIjDÙ¥cèHùÀöÓk™*§QÅ[èH=»w¨Ž‰?‹ñö+È$“7«=„yCIÇáˆÆ:-™½í˜Å$þz.oÕ±iÛSAÂàF`+E3¶ñSkϱ*ZùË—ûcñϸí£*Ž+6ž<·>zÚ¡ñ+ª*êžQ+òØ ÁþŸ•D¡'~CY1×>]g¶xºõQ§ÆÿRÿ(mVÊ ŒæÅè~ƒé,íÒ¿':7âùØ?ÇZn¨=7eGT)[’wÚi˜xöÌnñË è‰(Gâ¹°Ér߃§0ÚÊuà¸=µøn ŠØ^zxè4´4åŽ.~021ž]å£�Yôß@çæÃbãw¯n תå¦&ï ÕÛÚÑ‘õ×x¸¸ÔŠ2lÊàÿj^×Ý`&óÆõÀ*È, C¡;F÷{´ÂÉ¡t Œ¸éÁ<õ÷ŒHü‰å«¢.5!Os8³Jš‰˜+*D»QŠÈ[zôÞ*?gùÑÕß/ù€‚Ö§hnkYJ™t?1x7én2`Å&4+ ŽÁWh d±aìp)Þ ÁÇJ‹E1^æ)FRƒn>ÇëÚS Rqf¸t ETqŒ»æ>PID¯OM”ßZîé胩È<:Õ1W]Ýß"Ùéqf¨UüÁã“¢¡SH P3Z$Îâ¿óù£°pù4öNÐnã ùLw™Ò\üw,Þ«!Ò±í»+�ÂíoþÛwÿ5¿±º˜ìMf&âÌz÷0vD;ŒÚk´”µ'‚©ƒ¤o )"« \IS×[]e–«­Sý{2ó±gˆÊ* :Zè'Pd¹YBœºÙ¿×ÒÄüÀøBtÍéòË‘GYSdV›¾e- Ú]8„_» >0·’ÌÎÖQ!dìG\Ö¶æÀ¨Ë¹²$Ž¢Üy‰±ß×ÈÙöY™g_5Z¿ÜSò*ù«³ÿy^wýzM‹¿Ö²_5t—¢Zû|eÁc M=8±³” º&F^ᛘl-ð^4Cš™³µ*R¦"ÃcNTúЀGý·¹ðŽ«iÕ_}ÌѨr9äôV>bÞ<§|–õèu£Y$—ûΖ/ÀJÎôGw@õ‚õT:Án<¢‚éY×{zRÜËÜCãõ ¢Fäåâ2üŽ¬jUJ˜ ImwKž{Ö,mBßwß=³0®<eN–ŒFÊ’ÁÒ~CÎôýž-ÖóM'=r³y³^ '¶ú¹6ìë ;žÜoH<‰çà )ç©`¹“àd˜þƒ`ßÙ“†¢ø,™üCÞ‘¸ýX]bq¨Î[Ûø€ÛQ«ËZÛjEo-ªeñ/Dº¯»³|Q¹UŒ6O?µéŒ&•5N‘úS`挳zyNÏ ³Y Û$5S‚V´uº*™!7 @Ή2y†QþÛ$¾*’À•dÊéÏäIoéô¹ôzÉf|”+»œ9YŒiÑͬÑ/ª-MÖ$EF_Îô¬i‹»‹šõ(îP•–?#&þê c^]Ñ0Y+ NÜQSÀQ=¹yü;K-Š#›ˆ‰Èàåaœ8ik<d\Œ¡ÃN+A©I]߆¥¦oÔW¢`Ùþ,ÖaîWŠ‚C æ”èÜ&/Z±5šS‚XñâÅž¤ÔòDÙû·Ââtñ*Øk 'F¼zÿYMÇ/ŒE‹5qŸ9Ïk_éï^sø•ìªJ6©Íå°á~˜U·}J)÷ÉCtwŸ»A;Jò+&Y3Ð}Î-ìÆzãxdq0ïDøj§sÖ#¨G�aæ¯?`v͆…W¶ØÕ[£ih?LÖb¤ į”ESx“ÑvFvgg½Z)ë�Â2ÆMv1ÿH’ï 2ÊC$–[qÉK‘ˆk©_“ù}GËÄü»üèe[K» 9½àM§Oï}­"™ýoM³ÊôegÀÇÚIboø¦ˆþ>ï >/•ÙƒBF<°ÁSØAœ„ 4J"æjÙÔz?Þ—2e«HñO{a£Vx3 g]x¡J™#0cþÒ»røÓ†dkØñ}4--¢¼=ko®©fO¿kµ=`ž¾ê;Øðüê1`½íke×ã™fKkÖúµ«c´9̹ý¬Ûß 2¦kÁê7>þt[¯gI´ý#£ûzK[ ¯*û†*ïÊJñ¤ …þÑxvè[Ñ£gÍh¬)˜L1Ðz.65%‡Ç­Õà,aá‡ÙßZeòÿÕ>IâÔž="½Ïç ß ábÅI…QaáÐÑžr˜¥:{Ú‡'à–þLqìtPDãcU˜ùÆÚ“î»ú¯%éÂر{j¤V•™ÊáúØÓªIŽš[7ã…°ŸÚ ­v¿Ó<ý»º*b¨±(¤ª?©{Ü/²íç£5òDKþ} ôŠ,Á 5€×ýìUÿ |ú>ÑwSË‚Õa½îèÆGû¦ÚÞ¬GŠ›² tt§¤ 3J$(”î(Ôï‚Ýqâ᩾z˜ÜH~&;}|úáEAï¾uÞùx ø[cm¢ë³ ©}fk­²¢Ä(M}d¶¯ Åãøv+r%Èù_ë#5”°j]ÝöÕgï§D´l–V�/Œ¾B" ìØ­ÅÑ4ÑËÔ~`Óa1("GäA7# ·—¡å‹å œª{eÄVû2ˆÙ =2*¢ë¾Û-"O÷¼›ÅðùF˜_Û‘¤>Y0×�!*@6‡ðãöÐJ¡ˆˆ0GÀß{>0] ±™Ë4„E01ûÉÇìþ36A–ökÌ]ž{ÒGÜsßœ2LT#ÿ¸3`² 2 ô¤jÍÈyÀ»)ÁÍ`´®È£vŒÉRôtÌŽ›4Ò“žx,ˆYÁê!3(N™ûAPÑ+-Çn~ÁD–aeÀ+}NöÜX hÃ:?T·jØá~D>H'í…—²Â÷YiÄÍ/¢Åˆ¡”ž,&Hýà9šà SzVÖ%w¨D5†ÖïX}µ˜ÓÂÖÈBPŸ0Ò åZi9Ö—\êµÍE‘ú€qJ<ŽHûí¦ƒØ—Î1ꢖ>²I2_¶þãxio¦ùÑÎï+6.²®eKÔÕ_ÝrøtÚ›å sFèˆ&AùWPh®ë~u€Ü±ô²^ˈ¦åÂŽU ³×GÍÂŽò?AOi[€Oî ;ÌtÇÂÎOS²8h¬Ö(´4ÏìʳÑfåÉî ŠâÌÓzû¦·=zmçþ2°À‡‡ë#O·nTYÃ$UD¯xà‰ nóm%P SïFâ~p®þ{5\eèÕŒŒl`2;½¬Ye4_&yWÁ¼T[}‘HýäpíÉï?þ?kEBUáÇ­ð* ·‰ÈNŽÔ¿¼jà†áBàŸŽÐðóâ†í¶Ê4¨µÿ‡;ã”ùê(ãÞï”Os=àðåîÑj�! ¥ÿàIÊP,œ€îñB·ø…­¼ÅÈåÆ {‚ñyÞzŠq*Ë  Ÿ®û’-—œ]òoZ1EêÓ¿ào ÿÀÐÚÊD1ï\î;›ü A«é–9ɦI‚øsðŠsh2ÖúÁ[ʺA_lVðÓüãéo¹üqä]nÓ#¯‚´™<zFûI®ùñUf¾a=ݯ™¾Me]e¸¢ÿij•An<ÞsžÏ´ìgÈ” ¹^>ªL"•æÔ÷Ç¥FÞš¹‰Fã­ záž’ qÚÖe}k+)eAϾßM“wÈv×DÿWª6<ó’(h·%sOœ×“Q ÕÔÁ¾›gLf‡ùòaFtËŸÐ:+¯ÊÌã! ÊŸïA³ƒ÷¥Õ æž=´GL™2_Àã#,‰4ˆ­æP Á1¦CèÊÐ1Íþ¾½¸ÚñÙòè@ ;T†#%L ši{¿@ŒDnVÊ3ÀC{°ZuÝÓÔ:ýâ™5ŸÐsWϺ”ŽRQ}ºÕ–°ýä™SAr¿ÛaZ;6¤.,G"+zhï\xþÌ"O9×á‡NÓÄÙ çÀËÜ.|!uçÄiBãмpûã‰ë`nËÜi#¶ýo.xí,sÝlM #³ÓoÌDí\+¬Ü‰És»Ö‚A#ˆêäºóî¯q3žp}9#þô.ß¿ðq±ž¼óÉDÐÑ B°¡“ZÝÈÞ9e³<óY˜q\`�5©~ʪ[£ÍK‰©YQçËHiñÀTíË4Ÿ/é¤MÝî6;`6Ü%eh…+‰E›¼­}£Dš?»©†k|fTh1ß۵Ǣ½K+ºK4*Tw ÍÚ - czí¡?nw*0àF½O¯ÜD(1k©‘u˜¾ ü³ö0¨ýeoOq²ý‚¼‡±ЇÒýeAuºxâ©0úêþœ\×éŸÆZ:ä 9ÁsÙÜéÉú&„ö-*ï…ˆ¥ýð2âÍÄ>¢ÓÜ3b¬u=Ož ‘óxνHÎæùKèÐÞx‚„t¯Oól=$~…Õ²£ûP”¦™–M¾U|"cYUóÝ ‰LB¾â^—æa··ÕOnšÅㆾHYzäñ¾FBtRï/5`’Œþ?S"ÇØÃç1 ŠÏ­K”Q`4ôÿìQö”wKˆK=%¦MsFyÙ·7åC^=Ö0Å]Ùø½ïîÌË+o¢é+·L¥;Ö­Ìð‡/‘© Ìi'M×wwYêA NñYdë[KhDëÝ™#2„“Ã傈E~ÃY…þX~ÂÄàÌC°tPÞšiõn¤;kç¶ÚÃJÏ5Ä0˜áØYÏ CC€®î="ý3¶³M¥ÙB®¯þqB¥ŒÁí;eí`8`f\PÇÓÈ7¨=˜®Zš%þ›b–A÷¸ïýñ¤q½µà ¶˜²2Ó°n‘r§­¯Î>¥oo¸iû×ïþÖ0ãÕHÌUƒD÷Øßž› K&ô'Jµ·V§I祵Vp>!à×Љ$¼2û˜Vdù÷ÒÁæöBÀµéï]]7­É`d$õŽ] À„JSæ½–¹¾,îµ–å”# .¬9œç‰Vy¬;‰O‘ºptUz 3ˆNª\úk–i’¹ÌDÌgæSÔ<J»f7°§˜cXãWÝ$\(ú¥z¦g‚eçƒÑRßø%dfWdƒ"õª´aŠÿ í±%¥äI0öøæ¥4I¨Àë£KÍ¡m7ÏÖ:L´ ±¥š?o&ÄEîôî¸3Іšfϯ“›¶Ýà„ï 9–cb¢VÛGÒ¤62†šõÙÍ/ðNÈ M¤^¦ÚqÍŒn;¼cÂvVÎ#¥¢´ìWÌ0é|Aœ_É8×ÈRÅAê¤ ªÏOÓ=®TÉÝQþ:�Fã9~u{*9¦¸±¶ÃeP}ð點§L1gSH"ÆÑòe«ÑúàÕ%š•/ŽC‰æjMUÑ_<sú=Ÿ¹¶LH¡ŒÂjÁç Ñ‚¢vÝ:€p[ÿÙÙiÞã¬æö춵IjfmMÄŸ6 ý8XŒÑ¯iÂÎ×*3dðUS©«e¹ˆHòxËQ›éNqüzÞ´"}üîì?‚QÚŠ £øµ›çéc]{žÎÖc-˜DŠ-½!R=ÑF•¶Lù„ NcPS?tVð´ëV§8ô(بŋlÙ‚ëŠR¥Ö›Œ°X°NÆo–˜ åŠ*ÃíO9-äÁû¤’ ‰H†‡Dàë~yàÝý¥GÔ¶šó9²mo%j1[ßMƒfPmù’|¤:–'qOEÒláÌL_¥N‚¸?yâî}}µj-Á» thoc•t­“p!SÓsýd Ã& Àbã Á' ó¬™æ«Ÿ½™dȇ=dÊsò£ÃîA‰¸;ørSo²î‹l!/”Â"¤DgT0¤•·TJÍiÚZÐÖ}ˆ¥Dšy\üD¦ØR­ýðIÍBGª¡Z{šlN»^rJwåNëØ3NâæÑžŒìì9ÁIg]vsKê6�D^ý!þÓÖQVx!Kz¯þÐrÉڵׂF»qpÚãiÓ\ÿ^YÆDqâölÅ–R[ÊY18qïú%ºÎ¡z¨D`ÔÜ=ñ™¼p5Fê·ð³6(‚½íÎ>K¬é~˜­'/÷¶ngFâ&LUjcÅÿ£k@á¦W+W·4=D,î{5:ã+:þ{ô7ÒAK „,QžºÞZBž®}uØï_iÊEiiGù¢P?n@˜z§;µT¤½}¿5ÒÂÄ’dÏ#ò÷æäÙ/ÐÏvUæö»a¼ ÷mr“c›[�:(›¶DÏœ›0è9ÈàQcû®_Ó‡c³ïò¼£JJÞ3¡¥¤AµU$³É>X.øƒVç±>è3Sú~êë ôe7EO‘oÙ <ö,‚¬¶ô~¨qÐm•Ê"|èu´7Cí»V qBÆŸ·CO=^¹š—íJµ`÷í1x02ó&p.]ÜÅ sìç$,I)ê§7YQ�`¡v&–™‘ÚÍë¢C.¸Œ°þ9Ó ›}Ž¾‡ŸÓÞ¶A}Ýq¦ûÐg/ú¿<μ¹» Òí6ÞB¤O$]¥×¾§ ÒeÊÚ>?\uéñPLBðYÞwôŒ�âxnLÀ¨ #ômFȆn¥fNs= ÿ—ŽxJZ0È ~Qt;66' ¸ó^mÞo+%išùÙ:ÕØ|^j/º£@·ˆ¶[kÄ•`f›#¤£ÿ–@ìp 4‚ÕLoRÙJg¬ªÁ&:~aÈlƒ|e•í]Kþ÷K­§jeêÞÕ:Ù}í)Fo)µÔ:)Sp¤‚õùÌ(Ë*Å+#‚Aµ°2Œ{x{e`Ã\üDåÎܽqnD.¢a]ˆNÉIç@0†¢ïÒãÈO¬5ò¿É”dú÷scÐ4ì2¡™†êÜ$–‘îÅü¿{#èD;B-ˆX˜«òyb†ÚmªÝÃ@«M€5o{b ë$`7EÏGÏ�⓼ Ô=v–y£ç${[çáI ³ŠžÂðéUb™¦ãû4øÜ*s#® PV‘D%€ÏôtkwCÛXÖM=Ž]ÿ¢ÌMõ^žfÞô#…àGŬ9QïÑMÙvý~²a(3‡#eY€`œz×rÛþg”%~†²™+‘;ˆ8¨ñ[ÌÓ<žÆÃÝü Ë®¤`š6Bmöítûpã=`é;;1\·¯ý¨³,óLÈè“Ž@ËæÖz¢` €õLÙxg™BÜ m2´cÇNa—‰6åëXOö|<ƒéà¬2ÌER9šfTNóÇ6ŸaQœŠUe\»Ú Õu?[oÿˆ£Ó…ªZ/ZßFÕã¸Gî^W÷ȨO&Òæ g²ÿ|¤QàýÒFÔ#kÍÞ–`2ìÍŽJ<ÃGžŽNyuæSè˚µÿÛéV–Æ–"Ä@¦­hw©˜u"ˆçí†3U‹ªãË4! SîKÓƒ?3ªmë„*™xŠ¹†0T>xÕs�Sµó½œž4âØ~gPÿkÞf÷”±\±Þ^Z^Ü(¸;É?þû‘ .úX”]ÒÙha=T`Kmi^ïñzló9,ŒØдÏ)«š<²~úM­=Ös­•Š)GÑïyâTxúðUG“^©…¥éj™çÂ÷'Ò¿˜¨[XUX‹”i\ŽŠ%ƒò­#QîWrþ¡Ýñ1½CÇRžNç w}u9¶ïæñð¡Ý¡-”æ‰b,6œÅäÇéëkéWÓg;ÿF;$®²…�P46HçÖñ7”p¥¬NU—/×FÓ\¡Ô±YDrôí)æºÓ¤­Y ³(örÓáÇa/¡X^ï�ˆ3‡lçÔÀ®±¬m÷!DùI=}D#'ÆÆ|ǺÄÝeF'ˆ7f0$ê4ˆOÖ­%cñ"ÛpÒ«÷®–²µiê;ÁDÆÌãsã«9­‚,”éØuþ=C*¹âñÏ#´õæVթӑΟ»~h=ÅIm*¨Tó ×i]1T÷n!®šPÙÆ`£¤ÖA8f!MŠ‹,3!Åë5 åÅwáLD¢á²ÕHÌDïi×`FuìÞ6†/"„mAõC)>Ž WÅKnW¯Ù±™ÃÒ+*HÉÁË‚OÄ\2šF£Aˆ“c픵Á—ס´h_ØLFNY[„DpìQ%ÖÙ>SXñV©[álˆW¨dåm‡á•gÝúÌÅ7^n¦,è©îÎŒûUNp烮³ ¿uÀ$ë®6s’,Jø‚ê¦äèC ‚Ó㣴8>Ú3X——žÏ·i9 +ZÀ:Äù ×xÒpÈ _˜Iº¼ô?gÏþWVVͩቅª1’®ˆ½¸×ßõdrdÝ´·ötd€ÃøÇÞÖÓò°Ÿ)&éò&ÐÁ½§ƒ7ÿV’ Õ,ÂmP<Î|éÄÃáÍvþd"g}±Œ¡PìJÞÖHóAøëáúmfFß0Ô†ÅuG¤¿úÑ“H7¶R\±C›eðrJ—'Ö)´CìNPîRÀmpG³vgi•yí)h.üd¬…ê™2Y¥<Êß@W¬hî­Ðo\8SOá À©1Ù¨¬Ú"âf.Îo¸»­û5ß«·Ñ(®ÜÞR^ÀÃn½.Dg±EÊg<ÕÍÅ+xŒqõêe&™>nèfgVÂ4*Cf-ïëÁs¹¾‹«zÇgË&Ä&£XaPm7vð¸ðD©Õ­º~½YòUêwIcØ!Q";vvöøv×ij�n‰OáVìCEëÍb¶.T”ýñå†àÙ•HüP2kï7ƒþpbz¡±á{7Ñ¢£-ñ¦Eg‡2–£“(l‡n»…oà, Ά±:ˆ­AÙŽö¸¨>K Ùä&ö2NøÞïnT­ÑYer}qq­µ!kNC^ybÞ*¤}ehÑÖ9×ôNQo¡I¹ !©¨›<Œ¨AVyWÞÉý_Zy8uãþšÑm<Œ1ª­ý¡fkMX$¢ðô.ßÔ¢WŠÑçç®}úm¥ë2œûãhí}ý>ý»=ûjqüÇð„†-ÞyözTÍál­G|SíÕÝû Gté;2Э_ÕëãÓg@›q=KÑßì6ãn³ ºÔ‡” Å*Q%ì0nüa&4‘jœ¤V®P0¸’z2RÂÒ|b£%Qæ‰QÐí»¼`Ÿ©Ø&ãpz´:{uÏód“®Éj\ÞØÛÖ©uzàÅÛmñVû ”oObd;í@<Mô7a©½ÝÈ ÃÛö`ecußåŒíä© O_þpi´Ð¾ÙhOWˆ1kór }ONöÏäüMm<L,¡ªÿTa&ìû ‘~BÙ•o<_º¥’“T>æºoØsP*xþ›ÐCÌÞýÄ#ÐZHO~Ôj¾Þ´Ö´ë6©©\WPtž¦ }Д-Ð#–¨»}­‚ØÖ6õSô:¶èS²g/ìÍ"óÂ1+ZNÜ¥ÕŠ¾ UnX+)”—çÈ»¢ë…Ç–æ¾Õ°¡ïÓ®µ¿Ö"aC¨'g£1áù¯<‡ÆPä¤3Š˜›éœ‹vŸì8nc#çìX4ˆ4`ò¼ +¢h©-ZóDëÓ©Ió8’ÞśʯwÓ–Ùò·6Ö¨Ìi"F¥¶r2š!΃ì8{†É€&ì>õ)}ÇúKöâ¾Oºƒ&ŠeøG_"úžãóáŸØçÝ<0@A^žÿÜlBxŠJz\bºÎŠ¦‘‚Ú6 ÆzכćØåƒú–R¾C¹Ý²î‰B˜-ƒ´ÑÀÞèw Â[rÙ7”A |AihTOÑHÆfÁ‚¼W¹»kÿšÙ9*)B±?Ñ[o-É}M�µ1ÐêKsúû—óÍ_à¯Ò²È<æԴꌪe‰¦©••WÉsÏŒúrŸT€©¦í'ÖžÈ}ò^!ÓY&Ò‘O»b žÉ8ñaöò,2šøŽˆ@‹ss¢[ÏŸî”YÑç¦'Œêä‹ rÞµâ®/Uz#iÑBÞ€˜ÛzP.º‰ç#EãÙÑêé0dg4ùÔ_C×HÖóÊ>º´³V,iP9úPÁ°(#ÿîft¿ªSJì33ÞM˜Ý ;¼~k.ñ¨˜>¿6êIÙhnöüãsZ£-‘EJ.ö°ÌYì-q4þ“%ˆÃШrß»ˆ}æéõßîˆ\ºö£ƒNèàf]}Ý \üˆ·4:”tX¯k&TÊ+ÝþÔw]¡ó²!é¶õ´•'žnÈ+ ‘*5¾³êMpi1Ál"“UŒ©ñÒÞ™ì6¾ˆnˆt¡wMs­Z/V'™Õ6M‚êǃ¢tÚ厼ìë=à˜ëŠ…fv?À·ØÛ€Âþ öt݆å\u²pQZV Ôñp²+"Äcñ= 'èDh*¶øAÏé׿–Ä ÉKMI. ƒµúüFü,—">‰Hߌ×ò•d…¹ä UÏ+œ´‹üÇWeÙçAŸ@HqtØiÊ$øˉB›~ÿÒX•æE,KV Ênc#DJ»s€{Ú1L¸~õ­ÓšºÍÖ´qpŠœ1¬œíÜú‘>¥— ‹ÿäjKÿýñ¯s€·6)º3÷ò;JGyd5"Ž± í´è¸8p('µæCíaš9hÏõ^⪽¸aÖEå•€êöðÑ*›•ìu^[QmcùBÏ›ûàÝF\þÓX­Ê®ÄrÏë"È?­EŽ¢®­GÓÐZcåA3->„©x½ù±)täöªXž„T¡ T)­£/Û|÷‹%DéÝ@Aõ«ÍÛ¾öpÊ㛜-“O5Œ‹KÕðpIÈ¿zæ 1`ðª†*È-7#uùÒŒºB/yJGÊ$ÀÖ€Úë1 ™µŠ,8Ñ2°6묭vw¥Eæ¹}ÅÁ¶iyÖ¹\_ë#}1€=Y¹Ý/DíL2„9LIÔ¥"`aË”ý˜,zl^<½ëj©Ÿª ´Žíã¡¡(8}œ)s£D#iÏç““y–ùFžª¢i ~ÍÀoltzœÐ!-趮VåSÅH›éŽ~FFV¼”Ï!:PX«ääÅoÉB9W4F 3<[Ød~Ô?ÁMwcRédžëH‘‡¡?ЇäýâF›h´]Àdço‚1‹¹ýá€nèë=6µöWŠšÁ … +¥¦˜Ó|z$ ù»?Ö»FÓçGY´e£ç-¦©2kÍÔŽ=û4+À¥éi7Ù Óð<vƒÓJŠ|KE‘îé+J=[ô qM%è¾3ÄÀ¡ž%@2–wú©XªßQRønrXo€¿a”AÝàè_ÝI6 “M¿0ØþP²nÕú Q�GÒḘk»[×?Ïes‡Ç`áMª«c>HÌ›c×Oô¡pvã³™„ùñ¥'›øÆ q\€~«. b׌º#Y¨ýê‡B0èÁœ½aóÆZ*gÜJ^AZ‚7¼µ¼{G£.ú?;à r°lz}ôTðö»¶Eûn5vÿHæ²ëŒoRðÈ»‘dRâ�ô±>ü˜]?×'Nf¯^MéãåàeäËžSž±ïÐ5º¨äc¨c³ÆíÇ–ž±gæ%'/„+Šºñï ›LÝQ7ö/d*Špј¤¹õmkqð°“Iè Óü\³rœ6·hò*ˆû§4ïþ윱–þô†¬N!ãÈÄ©Õ€[Åá|Á€3H žC8E$#­ÔSuÉP®ÿË †nD9Z�ú×øÕ0œv"7|$ ;ö #‹x °xu Nmr:1´ÕÆ>;ÒRü€RÛ>’):ÚÄÁ¢{q¤ ìm6b’Æ™S$¢@ ññè§÷æ/À).J:Å7úãªBnuEÒ$¡!c&¸’„B¦Mæft¾XoºeIæéÍO?Ç!Ëù¸Æ×€Õ¡.¶Õf8Lo*fD:”Ž ©á Åa붟!O”öõn¼6ü{J˜Ä¾±å=ôs·Vs%gúÎŽŠ&‰—}Ý¿¼Ÿ¦¥IæklÇìЛŽªskÍš Ç›‡3¶V½-{£Âµ(3d8-3M<º<ZÕþ=¹¶_8<FUlu‘Å“g0ÇouTš0u³jý Àêð–ûê0D¹ê®î KJKV!“‡:Yþmù¡Qª~šŠ’7Òdò ±G ÀpN;îy¼`µÐ›°ÍjTÙO¤(f¶Õç+T~«SŠo§vó±ïÿÖ,07ó¡•Î¤ÌZϯ˜²¹6¼¡»hnû²Ä7.…WÅ%BßË‹ üöu} ×]äÎ5ó¸~ÿ§c’ùŒa Ü¡ÐXZY˜†¡`ÚΕÍ0¸~z‡T“ÿÔ[Wäaq⣠Ó+÷6S¶³9Ѩ„è›K ³zbÀÖ@7ò†sïwâ–ÓÞ€„·Ùz2= <v5ÄiK×…Ë=:Dj þè¯$Þ€‚e‘Å…½¦fÂÞf+Çß Gyµ,T_CyfrH~H&,Î=¼«G“°©Áó/Q”~#;¤'ÇA587hœƒåtb^¯,6RÆ3½á¤ÞCMÐÚN&{‡þ²ñ|.¼Á ±˜tÝboâÌ"ÿ‘ϵíƒVÁf‘‰wÕ?Êt„)µC®Ÿÿl<‘;Ì V§£Þ0À&mLb…šHsÖgQH¦{[€ Bâñ¯'qfH¹Šx’©1½Ãñ9 ¤ˆ­hQ$¹± ’ùÛuPÖÝ�ºŠñZãŽlßqµc̓tNi¹Ä‰¡k¯¶ô1[múqŒ6 »~e‘7à†ÚÀÈöÀ¯iå�³w‰Æså),уki»a üŸ²È¨E½—ØXן̬@ÖQ-;M> ¢:P§X;½w„TÓØÚÙî ¤§ªéÛÏú©Pu“tËo¾ºæìMfCšÊ1“qgrÃŽhÿZ‚Ó‡œÐp`÷vQ’\%ž2$²Ê‡bàÏЉSm¢3üÕ¬ ¹ sr"Ž¡Ù»ÚK¨+b;YšŠÎœ Ÿ®÷íO'’ôú*¹’ð²,=Ë's¹+£îËF:3Πʳʥ ï~3ïŽ×®àqS»…bãàd€ŽÝ¸ºxuº� ŸêèDŽJ,J Tõ´¿ÂF[9`ppÕhPŸæaîþ\®vPü¶¹cšØS õ\¬ÖyÄÇÁæ Î ^Åÿľ‹ù—»[‡õǦ¯÷‡]fUÔŸ1ù¬|7ªû¿ã Ÿ´GÛ¢yôžœö]Ym[Ù°M'ÚYÛšVÄQ+ œüõwæ¦[Ã=Ã[ÍØa1ÙÆ}u “³ï<à pÓýÎν­Rï^jó-÷äT+DÖ¦¦�U8ŸŽJYŽšU3}R†Ç2»Ïèp² Â�@›ºÿ£&¶Y‰¨wfEù…!5Ô)\ïþŽý`”xH“íƒqCÏ­°^™¨ ò½µkøÌL!ômýË×Sk+£*¦h?ð�WE;Ü!0lÚϽeó¯,·'À“4\ˆ)•š5vhäM®R•3:³ÏRÇn}äëÞ4¦ãiô3{úÛL¶FGÎÖãµñÇC?Â,$Ø ‡žr<ýÕÉBiˆà¶åηzìÅã塉hvÙÕž¯DÇäu‘ÅÁìG²ÙQîQ,¡—Ëê°WvŽ ÃGAÞN?œ¾ÞKHu”æá²ÎÞ))ª:«È é t¶6t)Œµþâ› Q$8À ûb©MËœec–ù]5TÀ`Üh_0+>þ Þ—ú–öÎÜ|™–î&-«o»ž,$µ@ÐO)½Þz9^3^†¹ÛЪÁ³r¯wåœmÊ5[ÅUAl ©³Ü¶vÍúh:1ôôsYcwÔ[È2sýmîÃ…õ6ICkp°¨¤ß¸v3äÜM·™n AÍb8únDu?S;w®Úpê÷®‘i¸É’Ä@\œž¡m‘"êPvÂ…¸ÆåÓ`$*ÐÓ˜n~V€oV¸Äp“àÜƘÇ[î­4÷ ¥®æD;ç¢/hèr‹ôŽŸWY¹$½«àS´Ô 5ÊZßvŽ¶2ÓD{¥ ÞV1ñ"»fö¤¸£ØÜ™ãïM,íÕz`fŽ¦¬ºùƒÞ›ä¨ ÚëÕy€éžÇ´‘r# M;�Š{Ö¸ë½OÇE¡~@È% ¢ábX–}}f¢'Ëm帞‰ÒGþ’ç°O‡cdŸ­ëCP¥ ¬-£œ‘ÕÍlHúÎY˜•þ4Vʶ¦Åþ©Ò9©AYIÈOˆ$GûúŒaeA"‚ÑÊâoþ©0FxçÁ2Âßf²8ŒLnà´TvÑ·*}§FB¡ NÇ#ç¤tÜÚuÿ`ëê(Tcì=~P׋m*Ì-³‹§âLOâÏŽahÞ'?Ë~jš:ƒÍ”ívbA«š¨éô ŒôMöîÇöŬ‰ê™í‘Þ½bÊL¤ •CZ›¶ÔÖ)Ÿ;pÁe@ET@Lö 2pn]}]yúD¾™4ˆ"¥åC'l¦2v›qç†">𛥾 ´šîRâGБëêS¿ëNæ>]ºÃŸ]¯/’_Ù1ž©Ëý‰=œsœ‡Ñ3·c’:¦¼©¬iuâÐÜþ ú¸••9Í�/ßvVNR>žzæà¾fD•‘ß¡áyBwÚ—ÃüêØ2ÚÈ~üæŒR_Û²h¯?½þûö@u™Î8…<è·•O3?ꔩÓÁdó›vN‚ü[­¨SD4ZÕ"?&ï}î �àæ‚7©йš;‹êCtf*æÇÙãY#5Ôêçó¿ð0-R>7ÂAÃ1…Ž×äéY"ïéù2‹nÌ¥¥wÞ#¼ƒµ,Ý82® ¨@ÑZ¹èLÂÂÎŒP¥6ÀÛí¢=ú¬CKÚWë Ó«VÓnÃ,] EŠ­ñ<?'u¦¸~}áT‘øV¬‰˜ë áù­s c•Sþ“¬í9™(`eæ ІÁ(·þš¼+M|ÒК¥²ÚN€¯È=¡Gq|7Ñæžüã!È2õ±xa4ˆýeæhTäwƒ_sÑ*@q'–¤Ò ø%ÅJÐâKAK%XíáA7XIg^K‡q  Q»c¡ ÿ¿ÿ/¨~ÉàîþŽÌ‹a¾GáD¡Ÿ{ZÑÙÔ8‰Êe,';®–›&ø ÌK²…‚o!êt©SÕ¡üã5 i'uýŸÎꌩLÝ+¹:_Ö;7‰ßæ„øí‹øœméešW´*ß¼Žñ× ÞGå7°Ø—2VØ«ºØ�œíEâxîîük«T RA/éað4Ç88ó 1ÈËÆ$]öâuì}f£ê4ÐÇ,·[/àçôDz-‰;Ê<í8ÎyP÷tDüXÁ΀©šó$JœXÑcÙ"«8˜³ÉyŠ3f¹Š:DNõéçIÌG-êmî;Έî_F*Ùá󔌲¯é¦—Ì=rÔ‘÷]ž,æ´2í‘y¢“3µ~¡È·§~²•ú.ÖË_Øq¨v¡òq†Tßç_=ús–NX|ÿÏúŒÞ§ ï(jf¡7¯bƒø`)Ï:)c¡6M¿VÚwÕ5{)4 ‰mÎÂÇe¯“ÓŠzk±ïã#‡Í³þèñ*·õY¤ù­3㤇·m'?2ìèÕzß¼í½œÓù¥õ$gŽÄÉá4ˆâÕÍŸM×^ÏRÍ7-Üô“õ§z:âÊyë}):@y×ãæ6'I¢Âã}…`ç3©“s°à£ì?IÙóŒEšŒJp·od®w·«]™'1F!�ªûÕh­rcÖ¥uº¿—Øwâ6lÚG™c ñŸA“"l\,sК>Š¡JÜ#ÖäKöTRf¾?÷ˆ –P5-ºíýnš$C»X\C‡Ã;⤥7f×ÊŽŠ ²"�H‰ Ãœb¼•qP<µÛÓß"ÊE·ýAK¨JSÅÜšk°Þ·g£ãÉ÷™AF†®@ t j*ʤÜùèö"róé7Ir—Ek™Ñ0�ÆquA�Õ å pè.6£;e>¼t™ù¹9ں瑋È'|Œt5ÁÒåÐ_öÇÝJÛB¿Pˆ¶ú{±mC±&šþz…íàNünÕÀôÝ“¨XX•dì蚎ßÚ‹ ô§ÃÞlªûc§èÿ¢¢piãå­t&Ã${†¿¡'-öj–åxܙќQV”Moh£6@¨›žO½ nîa2Âk5hõDG_úƸ=z®Þ&7”?R¯©€a±côÙNÀôˆ§o…¾<%LÜzºËéñÓƒš¢Ü;%ù°Ìæ‰þãÝ5kòûnÉÈ(+ˆBI-'ž¼g:L3Û]ª8â~u@21y:±ý‰ÇB¸ó›;¦0¹ßà4[Pà?HOÈ@‹Ñ9}Yè8Ú£t[D"6÷4ߊh點S°ÍƒÊžˆ57(;8‹Ñª*äõPI.ö¤(·ƒÕ\É·í^•Æ b-oº¯GnÓÝ=Œ3ÊvBç¬Y;•Ah›q~0Ìò›¾ Ï{Â@ižyŽÙPa±¤ï‹×?Ú»oþ¦JRåB‰Ôþ”ñI—KÂTd¾à(m˜×Êஓö)œHÊ pò½œgœ;VDsìîg`˜cw¦ÛûE·õÁXiaêÁ¬Ýf¤…wÔ eZHÂ5zv¯Ä³Ô7ÁHÔyz^{c¤ãîhA,¿wœö$åŃ`êÊ Y뙳g. ÿSÇ"دpD׎aúZê.R4…HèQ–1ŒeÛZ¬Õ5ýç¢ÀßgÆ@§%�ü¦¬)·Ð¢ƒZ¥Sɸë†Öè+amÝHçŽFQw]}}h§TyS·ˆ§n•¥µÜá-8ZÔ ^s1ÿÞëý…ªDÍâ<t»Jmãáh=£O@Ò‹yùF2vëÑ™`ºæâžúŸu˜±.6›4È©”N¬âµñª²•(Ú±½ú`&ËörAjÎÊlacÚ+í"ëbD ‚‚üÁ]ÓÞÁ ¤ù­Ô×WÃÿ4õäØXо­ æhI±J‹¸ȧSêØÏ­s¥ÓÕ)†f<|×<#‚Nù•­Í¹¦mvšÕS>ÆÊ_CËPÒºZ!ý.±þÍ4"ùRŠîxm;@<jÀø²äÙÀ+Œ9i<°áWû©š’Ц9ÌrÚã H=ä¡î?ã(Ê Ëó)ñŒëÄUí½©ü°6ßYôrpÄî-ˆ,w<¢óŒC½ž£1ÝÂl�ʨ'ÅÓŒ‡ ݼáÜœÇnÛ,Ò€NRV{½>ª¸èÉíö–û3NÒõ’×+$Mê¹£¦BÄ¡lÚz‰mSOÁÎëKúM.4C`ñw ðY»ñlK‘é5žѳ‰fáÄô„Øsët&š…ÃƯÒ6Í[ ÊHeG˜ �Äã+ëNÈ0e5§v€oäÏøX:îÈ uxŸè|ŽÅÊÖèB¹pBñäâïÙŠx" @ö€³ži­dÑ’½xQµZP}ÒÊ]yj¬JWx ‚S“š¬@‰î7”kʬjkÿ„°Ÿ¤‘'¼™:¢Ö΄JéG\ØE…!ed/î©å®nPàp„¾”]L‚³vôè Þ‡®„Ôõ@íÔ •†.z„]FÝyÃÈÓQn×¹³AðŸµ"Ê¥cZ±òmPôÊ`nĈé“éoGZ9ÆŒ ¬¿ÁQ$ñBª]Í~DÍæê°£,‹ª9å:ÓsY!`$1ó¨ÌÅqQùS‰DÚ»%L­Æußí9v[}TýÅ?õ_¬3ŽÂˆdøØþxÄxHÞ×(áô—“ò6AªígxceNºNZÌ«=tÞ¯d§w]†u†ì÷ÖâÎeg=8r‡DÍ‘ÃoúŒÊ­ïÁ ßõ‰Ff¡Ãañ%B§]ßÝð_$ÛgÂÕ¾‡Ì$Ö—‚ž}ëõ AƒŒ–7 ps²}¾Œ×gªÛ¢Hqé Hh‹—!‚²D®áÕ<Eü:1Ô #Ú¦³†Ï¦?u0gcENß3˜,#m>Yý¸g ¶5@Ì_¨ mpÌÇV¶”Fºy×wÒSÓ#( |lå~ô(•P{9@ÁÓúc eèrø)ÉÚŽÂdfÞ‘î²Sy†w \§§€ë~ƒÁpža‘á†t?€¡ZÃYž£ôº˜`B1¯þúpÚåääq`Û‹{<ÀªÌÂE×}:ÓmO§;UŽ (²F×­´½Pðo!Ò©Kn¤M9Õ¿šÕå‰Õí¾(¢pjÌЮk鈑1+;Œa•Üý¥?¨Ì¸�ž«;Ï,‹iËš¡ß<ÆÒ ë"T¥PN*‚j<zGÖ5âž–‚ÑKZ¾,m÷2oˆ.€]ÊæÇpŽ‘Ùò9;ŽpZÞl{Ûª1Ä›Hš<Ïüþ Üø0¨­é1l\X¢{µa}IÅ–n>ŒÙ„þ/O 5e•y*y€À Iµ³£C2ÇÍòP–‡ôÏثػDḠ¶ETðV<‡A±˜ˆqb}’Cž­'öÛF“‘Æå̧û¡ÓÕrEÁ@A<DCÖÔÅ*„½xq•ojé­bßyØ[(‡M'ŸC²liÏ‚3<|˾õ„nyJ¬èù/ƒ­E…é_?”Â-ˆ]s`{úEu°i#Ìh”-Ž•b†]ÝK÷èL'Í’I”ÇþIJѰKÛÞ‰õxêY:9}iœT>'_e7?ÎËHZüÖ²i!Ý+常}cS ÚÍ–¢Fú©Ò€1ÛW8/BÔj‹¨á(<þÁ9:Å"’l�ÑñÓu‡gÑcO‰±¥ýµP:ß1ã]óFayMµª’ œ\kAL±f§èÇrð÷;ö±wm¬äß7cÃÍYQ2P¹ƒïçÅÓ˜ Á¹Ü«[!ŠÌ²ì…4ݽ¢ûëñ’E6Y*§÷U÷ä³KÀá'¾4!JSÐÿ«ÝPf‹vXƲ½]ŒÀXʇœ|ÿÎäH=Qf·”ÒÇV¥'1õÚwiÄ5•>zÃNéwÔݺ•弧4(.#NˆÑÖ£oû‚•XØ|¦j‡z°íUx#BºE{€vâ×È8n™HpØ0‹§Û즠†Oܲ]R爫Y¤Ã·RjæUP"®C˜Šß§íL–Dçß^äú†UZlÜùc™ª ˆ=7c­)ÄMêþ ÈF+¸G@},“-CÔåP³Øƒeºÿ¢7 ?OÞ`cº;ÕTÍG*4Ðô¹þÙøÖ~u8,òóeÓŸ£¤'ZO&F`sü‘;$¹ÙDì9¨¨|Óë8åúÉý:í®fkni¹íhú§ú¿òy¸èÇå°Ž(ƒ¬>éØ?ç¹Ðx1k—²î}‡ªåŒÛ æˆÃùbþ¥w«B€ÄðôcýxÎÞàg{iîœD•ˆFŠ™Š,HÖ½j™±Š,=ÇS?ÙÑÄ�;‡…þÌ3'‹Ï+ Ýc:bˆ»ÕQ¬5Z~Vxýyx~êëŒeo FýJ»p°ºOIDíÆãwíW»a¾h+‘OáIëÊ÷lè\Pscžo‡?ƒÐáƇÓÝÖ:z=àÎJù�H(²¾ÏÞ\ÈÞüßÑ°¢2öâ´V€¹L»'E ‚-ÎИUÁö0wsmb¼�ûŽ ÅwQ™Q¥ë*78 RªõÉBIÑ5Ùˆ�}E÷÷¡—“ç$ò¼Î‘A3>0íÁŒ ¡¨ýÛ³èοѨOÊÂù~ó«{¨ŽNûì ªíÅ姭tR¹Ýû1²_#S®Õfý÷ä5Z¨Ôüèw¾3¤À‚>V5(ý;`½™Wôã¦[Aµ"ùÄæ{:0Âé¯ ²•�D¼Ùdb›v¿ÿÌ­¯ba°§ç–¢ëjáf¡/yJFŠD°p0“™ÅOOýâÐÑPÄfO‡xúÙz#g ÀTH“ûjG±²‡£TÉW�ËŸVIZ*„Yýf´8_zÊôi'øÏ‚£} ”e„ð-R£b™ëØú‹'5ôÿx_êÚª@È5@T \]5 ¦yɹ¦Jæïªln‰pͺ4Èls ]·5‹ÖV—cm¼GB¸+u‰ AÓB|ú°v*Ju°°zœººŠëÏrWç|p®é¨„ǵT÷˜fóH…[¿ýW`ÔÐO½U¸ÿ[Çù‰dŠŠ§J{ ?œ}{–¨P¼bݶ݄Ùó[1‘²B˜«ŠÆòšžg«BôP!†ƒE#®yH7)sAÊŠ2µÝz}óª>NJÃÇÔåt»»ÁÓFþÃÃ-sÇ9aGCùØÑV­û)ùœ�Ù™'ïžFY…Sà È]çƒMiå p¼wÀ=ò°ðm…0õˆYÔÚH2ЖûVV ëVÈ윓+j³Ÿ„Ìvæ÷1Ì:Á>ȾҚ/™WÉ\í«ëŽˆn²Þ{¨67 6äx ø·*þ‹ SõÕÄ„’²ÅNþÁЋç88F¯~Bz´ÐP,è™VÙl\ ¤?•‰æ„jÞ*TŸ\¸Qa/ËÉɵç,T,DÉBÃ,6µ&@Ä挺×_6^ÇùºÅ|ý3LNÊ«nöy¬Ïšìˆ©nl»f€¹íxØÍÜÍd(-MÙKmá$Vʦ ”Fo§Åà ™gúf?‡h‘[@ %CŸß:lb-ÜKkûùõj¥“Bïr{Z¶W¹Â'™'Éq'§ *«k@Y㎳qOh›K¢¬wyW[&.=Uv_l(ClŸ% 7³3Zï³/Ž¢MNqó]}œ39Óa`ätÈèoXb<vç|8ê9ˆŒhKwçt4XƒýŽgdx´FYøa¥æI¶Äç®Ø%¼½(E$¨näÏØ©…Ô‡PÆ:Æb›ùYqb+]W×ÕÕº ¢uú¶š ´î1úTɲÝD+]ÌV=Uõã–b Ô½/&¹”¶Ýû•ÿ—ƒµmÀ³39@m}¡ö”¹M2MÝ™¤†ÖéDßd=˜ t%îð–—Œ›Ñé-¬‰jÄCq¾d8sì±€íÑ—Aôó©zÿ13ÐÁÏ·ÌD ýç~ÖæüÈEôviW$Öw/÷Ü‹‚Í©§U‚Âæ/½|èƒ<´›PW– ›¨‘Ó9£óè!_¾Ou Ž³ªŠ½ õ—¥/º§àOë™±±NØ/¤L)žY1+ÆÇ9b(ÙûÖY(„]7˜ [gW4†åßu7ˆeÜuŠêÃΙQÀ‚ãV?† -ëŒøÒfYyW"ú�Š}iý×#ZLÃß‹bbôâåV°Cà—œ´—hµ`þÑzh…#$1)Q‰ú¡2¢ÝÐБyýªòdÞìIæ± ¡¼·¡[|Ôr ôº¾›W[Ùp®²Ôî>!Öµ Öµƒ×ŸD7 Ʋì˜Á„câ åôs¼<õn3±::S;ës”¸•Vw{Ï«¯á^I®;óô±«Y³Y[�IQñCl¬E­èMÍæÈ›lG*þ°­ñób=XÙ¤æ�÷6ZÉ€£<Îxã0÷­ÎÄF& ‹¾Š^«…Cù­‘¡òŒµÍÇ]{5¸Nª…‡ ׇ4dÉ)u“ÁÒ áÖò‚±o JÒÊ“´ÊÐ?ü�îøã[­¶¦¡=s†‡€,µÈàæÎCIg¢õ1(Xþ`Å ÚéKÎ['Cïe&K÷Ÿb1x�ëxNƒbö¡ñÀ Á)p’š ³a&ô¬jxßð‚ð.m-·pŒ€Ë|xüÑú}À% lYE·½ÈÓ̳(yçœ)eàfŒD™ÉM aäõt”ñžª‹Ã>憋}„uD:è˜ïÏN T¾q¢Oa{6ˆ ­uD™šîYè¶BUŒ{ÃÌç<‰BGìÊÄÚªÖ=t­?¸#?¸×ëÔ teWÉ ×*H›‹:º€‹t8yd»-ÖgŒŠr]„â0xTåxñL)�pl×íKh¡“<¢ùUea%Ø#æÔT‡6fo-Í ³hDQe¬xûL•ÆºÜ„:ƒibÈá+>6œ•")°;²åW¬˜ú!Éli=˜»#ò1"fÃLÜ(%'.€ôÕaN­Á£ `àN¸äd1‚δ«é[íêáJõ Ý}À¶ë3k=šW,…º-¹Ùweζù”ñÐqã·7r‡ñå¯Í ÊÄÄ(q®fè-%Ÿ§¤bÝMµÌ”|ôR2†¾úÑÇweU^Ú4‡ƒ*]­’¿ŠXo-/¹$.m¡ÔM;dQ­¼¥·žë*H>S²&Y vù°šwF•ý eIX÷0ظh‘x!#75 Âš5IUl(Àz=À]ãbß25Âva×€œbÝ!Mq‚Ž’ƒ—î;þ9ùøB ë º|ñVO_"[ãÿŽíϤd­wã´¸^²½âD5³øFQÝÒOuµí&/<Ô«­²TEMF7Ç“Ø3=À8¥W8½ãXPÒ¨Na¬ åÞVYmE†èúuqVZú«B$öô±“~öŽJ# bøy2|{·-¯“ (5j£MCó»1Q¢Îk:Í‘Óô”Þq6i¯>P}´5´éüVgq2*áñS<’ÑgÀÒÚ?¦ÃúÇ£´–¹Ö�Arô¦³Þ‘VHémÂÜ• ¹:—ÆÖ0æÂj{±6«W¶¥7¿ÓlaXzå^JaÁvýc¶‡ÜЃè.Øg¯iç!^]Úó.]H¢ÐŠJ‚¬Vj· 8Ÿ" 6Šš–¿µx7‹ëù"K*¾`/Ò9 *kk¨¾§¨’ )ɺܻ«ÿrû_˜°ÜŽ±Š¼RÝ®E`aÈÔÛM¨iðo ¯#‡ˆb#¨¿úNúi9Ü`Cvûg^Ó0³ÂG³ÐYÎBMçtièyÚ›ÿÒ8(‹­y'UlÁ½<YZg*É̦¯¦!D1~ñ³…G§V½§[T qé;uSNv4°žÄ¢Q1!>³Ù/¦Ã•/Î}8ت <ÖY%ÓÛ¬èÇ?º—x,:®E*öêÁS­yhAG¦iä¼k•-]§è Kƒü´vcýg'£[>'[LªäF6hQ{Š›R<ò‘Ø« ‘?ñ¢ì¾éVHÌÛ-€œÉg½Á1ÆV‹qŒ» ¨µ‡9‡Zæ=;ÙúcךÓüÖ‘ÀcuE¢ó¬Áˆ0M[ÎH<Þy ¼ã5pjË9Ä¿Ù)-=®cV¨G\h|d&­äüÁí—¹áÛâô¥7(‹ItTGmp Åþ46õÆ^ô¿ÏDPmºó›À ·—4`'#-­Ä¥½P»<}u“¢ö`¸5è+¶¦ëÙD›œ†0�ÏПT«ÒÝø`ЖŽÏŒÓÔN´ÅË´™`¨Ô^¼Þ¦U¿_¶Ó3:>Òm·aíêGÌ BŸ¾ƒ™GK™Lr±¤ž¾ ®¦XõÝêk+Xaÿú±Ã¥¯ïœÉ–‘–r<ï&ïdü¨_’{é KMÀ 1žÏÞ `ÏÖ9Úö~Ó±ò&Û²tôñóïOÏPhˆÙÍ´^›8ƒœÂȳ£Ó™›~zÌm„ x¨ ½Ìµ5ß2yÓÎuÄuCR² †Ú½<Ìæs¯ë]o�"Þú{Ɖu�ÒÂp…&z¬“Z¬ö0x“ß6-²…h`yRp‘j,©£%i§zš¤j ; ) ú~ž~õ½qP蔶i»ƒ¥¸EUø·â¼0–A4tŽpg‹ªÀ7u\ ¹ºg­T˜Õ:бn"ôÏÜÅ2W]¶–ϸÁ—]M9Ë…}pdzÑkg¥\ˆì|~y˜<DÅa^Û~ˆÿETXù¹&å#«5mƒêS9ƒw1ÙÒ½í.˜Ó¢¢”ËÇÝg ù’V,QPZ+Ýs<TXXöÆ:ûµ2Aç~—(fýÛï¡ÕZeçunû=ÏF €gËw†@N9olŠÉqkõL³ô4^Nƒ¢°r"݉¸’ÓªîkºÌ}w^ô—v‰—¾äixm*1ÑmÈ·v ÈB'PLZÎÇåz_w.±Îà©æÛ`DVõj¬GQ­Ò|ÀÌßÖ$/§»ÜË,[øL§8L)—µR,q‡“‡iæçӑŠ¦}­Hä'ÇiVš»Ÿ›*äðC ÞL$w7¹•ÒXù+½xÐ�+3_¦ÝÐÔWdr²úâÎÑ¿M§#Ûq•1¥F,¾~Üx²³€Š´]¿¯'JÀáÚ[¯zë¥Ö£f}.¸>á¥[ÿ¹±NJ&B·cPã•"Ì“îC™:8+íÜâo¯üDÿÌÆâmGÑž|ÿêŒ-«D¾€15˜¢S:¨ð eFPóámÂ* \¹bWa–g”}—§õÛ5éÁ Ci"å\ @Kj£‰~diºnk±1rm¥û –8M¤é=Ç<(m½ É†¨.¾¯Øe »¸‹ñ4 —=…`O+ôåo9­¹ï½Óièú‰EÂ.O8`7ETš/Lé3w`ð(3ì6ðr4Þåjö&£©%ÿ…7by„r¦}³èwh•½Tt!AúHº¾7¶}¢úm`Œ:ö¸ùV)+eGs)’áw¦ȳ|ÃÚ‹K*…ì-«×9í¶³B<2ÿÔW:Þ·ÌÈ8‘vòíGO³…cX„¢, ŠÉšïDI8¸–šS:ÆغŸ!˜ƒHCaý¸Á•Å®¾d>ütN©öS︡Ì7z—…õxe Áop†eêÔa8ê¬fJ~Š¡3SYŒÑ±¥V¾ Á¶>ã¸ô…ÅX +Z#„1 }õ¸)‚ÄšžÅ…tÝ-âf³5T‡ýÏãM>»ƒï†ÆØxs*ƒÌ*0Y* o>vþ¦>ïf):PF²ç?Ì0˜º¥„u+:gqö~êÖë&(pÔ­µïTùÑœ¿¢ýŸƒõÈbÓ Tºúq†#¿´ÒŠ³+#úÕš¸¸µî6i$¥–8Ýq´ñ¬mÊ,ÎÔÂÕšõìÕÌbBlÚÈ”Htõã;RÜv�Ímú(ÿo­Uà{Ì$Hå%†_HüÛ¼"ã.@ì¿(­8}* �XVä[''è+þfBåLÈ+õ¾YWtØiOÅ‹4ª TóRiB¢fgÇ»oµ³Â«†™u>K>Ÿ<èÄÕé¶Æ~LbqNp¬ºLïxã¦c!† ©}˱€(Œ}aYJ‡ŽÊlã¥ð²q#w>ÖLµ¿¯¦´´Š‰+Äy>:¯‹ ãîrd‡,·_{¯ž;iêëyì€u4/¾BEh¾p“¦²`5ôµÄ|Õv¶øay‚GOµŠ+7§´4“ª<À‘#¯õ˜¨W¸ÓI�HMMÿÓf!n˜,Léé¬jI›>pO‰i¸SÁl›¼w`ÓVÙRYfûÓ+O¸ðá¹'’&¡¯´CͲ¥ÞŒ5 SÞí¾D²nl%‚@Ô!Ç`h«¨ ‹Ó‚)‡ïôùx.¦Gú¾««~ž¥¢CaOK“^3ñë̼.gžÎ°P`tÛ¶`ž¬knFqúfÓàU}ì6ä“8I·§–6ê$ ™Ç =Û4Œlg†Mp¬Ïjˆ®z=+àÊx·ÀŒ‹‰áÑOŒ$^»Ö l(L«ûº°TwÉe~}ÿ·,&’-Õ±(»¡‡ú9xòXÇŽM‰t�zÙï埇j|a’yL0˜¼€YnkW|`uÎ"G«ŠX^ý$ó™(Í;ü¤Añ·ñTrÖ‡Ÿ ô}L~q—vUKæUìÉä¡Î;Ò2‹­b‹h–YhøiúR]Ž -5üLy0³$AEXd K@JJƒô[ý79._ÛdÔ2ªl»î€Yð%ÛÆ»|3O¼[dæE$õàä9,ËC«î±cù&Ã#¹+sázTÂféYTHÖ^VçétkfäBÅðÎ�ƒIâÝËÉ"OâL¸›”ëFß'„•MU£¢/´?õ¬ÔvåSòPb4Z°wé¯ìŽ u:ó2j1ã†öí‰Ó­QaZÀ15d{€'%À€@“Ka_¯æÙ÷—éƒ2ÿm AËüë¬Ê|oŠ´Û PÑ“ßøðæÕ‚zT¨Ú—‚œú^˜÷¬Xì®îh„ ñoE÷ôOÕþxS ¾«ÿv¦ñ¦Ó¤ú´âÉX¶¸ŸŸÙóâzvraù¥ähç8<¤`쇛˾Ò^Š«(\*4v?°³S—Å‚!(L[ǹ‡‡ÌDZ*ÝÜêD¥eæÏÀº˜é[p ~ÔÆj`»›Åè¨Ô2Ws3Š÷p&ßjÑ1âi¶oG‡Óe2ÿÂsudC6½€RzÝÁ0£,.ÂZé&k éÄç˜Î÷ž—øàF¦5øºCªc̱£’ñǃPáéL5lÇÕ1BÎzQtá,V>ýeXþÀƒU>L(çæ–öotðM5¥,ÑÖZCÂe²=ˆ‚+Ó³;ÞŽ>#¥A‡/T]þäÉæ±’ l}Qir²¦Ü@vP0¦cîJAz4¬W„¬,\Ø„Ä” $A1k.PF>8]í'hý¿è7' ]ŠŽç*(¬TyÂLÛó€S«mþ¬pÇë5c¨&sJÇÃ¥îí¤ÛÇ ÆwœVcb!ûUläÏ÷]sAþükÌ â[îÛÑ6ý‚ yøyö¹q»ÖŠkÝq:ìå_^6÷„Ô/öT�xè´Ï‚tn !ܯü´d¤)‡.åeÈj§PúÉêU )¬ ZBÊÚ9Á@¹—¢! ]?Ö§…:0 2˜bÆìûUhäË–i…–eb[®ðº„³CÅÔvŽÂJÏþaf©RÇL¬Øµz -€­º‘ :ßÖÆ)KzyĽ‡Èeî@¶?é;Š•'mZðHäØuL½Pë½Z¾íKÚ$wõÏ+ØP¦8®­mÁífEÆéqÏU&,|o&º¡›SÁ@Hùœ(^Ö½ ¼Š~Ò(JÊÈ®?žîEfjžRÙ°i­¶zL7ÒÚÖ"œã}Ýg¥g™¹y, ^´w¢Nuû§ ²D&¿þ j1¤# ÏÓijsÍãóãi„í›ce&Qè‰ÞA΃×v«q7e‹°¿³´Mï½7F¿é¬¤©û;l’„H:X“q"óò¶Áÿ#%¹ …\k¥nÐŽü«Fm9‹œF{â¾mæš$^’†Âa–…UExYè˜|þJÿÈhÊ[X%4±C¬ïÙF›ÊL+ ‡:èµy5•ÒÓR"É 7¤P þöïð9–kÒ+_‘ùKiPö';K-sG¬ÍŸ šdBÕ( ЇùròdNSŒßÁØ>ó=P]ù(7‡îêE±.Zå0±waç#‹ØEIÉ%§y‚®"<_¼£óR˜U{ÿ…Î×ÒwCfx=:2ßJ—3X{ÃÄ‘¹ÖA–ýrÿ¼–Qµ&Dâ½L% ðŸcoŸœ¸ØÁ…ã<ÙJJÝ°o®,“«0(ÐÄwå-˜†I?eu`÷Si„Þ ¿¾þ쎯°7ªõ!i 9Lêñë¸ Á!ƒ÷& ¾;Òbáw7’"¶]¾¸IAìÛˆ„b½žwŠ!ûØúãÖMo_œxYâTnØ>úõ•Å­rÅmþ~aËM©iŒ)¼a~FPºËâ ü¼:­ç ð}ÿù(2ä«è‚m³NC™í±B7í,1vÕ.Œþ/«| :d›œmlÅé¥; ”×p9®¿õc«eœpT,ÇšŽ[¯¹ÂÉÑR]jfq8ÿ#Œ5¶š‘õ=×Y´[Q‡@ÂmXköŽý;AÄìòŽyEš]}¥ÕŸ<È;—F¬5¦ð:Œ¥K½Ù’N)ÚQÅ©q½ ü',^¥&³ÆNÛ]Hß?àînÜ¢ÃÌ·?¢•:tôùK Lj8A¥Ïí9#‚ý€‘©qòp©s}¡ç—’Vus/Äé«Š„¯Ü’Žî;ÃÎíÅêpÑdOU$Z˜z@n‚Š°º!¾¢ë»Õ<îVv$‚ÛÄç´Ží®å®6“{.éž\h-6gã×™qaäHÆz`×:IdwÍ ñÖ†ÂõpþžÊsf(-®?¬Ê z=ý²]»¢sμÜwsñœQB]ZÇew1‡ï Ê3{MÀ<ÀA¬í啈թIMô‡²Új£1ómêõ§¶·É”q’f áë@Ïtd J†ÎcÀZîbÙ¤£û–¦ˆb€h5à …Îj8“Å×EÈ´ù7uKAŽÌÕ6 òæì™,&!FŒ‘È’ÝG´[G‹pŽƒó�×zk§ˆ?ƒG*Èó¡‹(Æ>ýéú h7ÎphJ Vé“÷½f€«žwª”Ïžæpê»?"àý¼êòIÁ‚#Õ²¹­º[oDÇx¬š½}.ÄŸV>£ S—!M‚ìóè¹—³A¡t£“ Ûw#d{ø—tHŽPRýos‘ˆpõsÝžnÖ»ï€Å½W žYP¹Q?ø~â:a#Ñ–± Ü>~>Cç·‹HÇð*ÊÇogmˆ]+r=.Pôõž Õ­«Œ.Õ$˜1lLX¬o¢“ÐvŠ‚OQ€•HýðÖŕL÷ÂfEÓ¸ömkˆ&N$iX¼\NUêëÓY2nè.ÃAæ8¾ZºáÒ‚TõúÕ‡Ÿd™‡eb=­3­=+f¹Ì—EþòjTÿHp,V ¬pV©J˜ÏUv Ì™^²[}}ÈìOÕ y2t{ñbV”ø½˜Ïu”ü&N·K-¼…²Ù�óuƒ‘ã+F  2_?Å¥":?ÙB[™ ·âê~2�5iÇEËÍôÎî±Fé¼YQ¡~ÍôEÊãÆ-™m'H½^$‹ø3û×ûCß©–“[âÙÂ2/d~¦ÎÓÁšRùw^~´€š‹Üó›[ÀwfJKkÑÔêGO,e5²Kùµ]}˜†óŠBÊîXв×9àš²…Zð*nº©¹=#ö’£sIþ·˜…Ò|ÄìÔЃ¶–A(2gH‹«,ã–I'"9V_ `ùðŽT~LøÜ"š××Û£!4À©7A·~ÅÈ›G°kô¥<n*zO_öA¢ˆª>0ÁÝ÷C}ᤅIèi|„° G¸™¬x–² ÄQîJays±ÔâNÝ檘À÷…tx«Z˜i@ÛùÂ]'<§ûm ‹Ð#†cŠwµ˜ôf‰7 Œ怙Xc•,<*4Ä+ìxXîëU3°nÚä<ýK,|O>²I³Ô÷bz‡ûcÇ&2¶ÎEò{Ö"Z9ì¾ÄÈùé_4¿£ªôáÛ@l¨‘Ú^ æI*åÉ&v»^æÕæÂþ<¾F‰Ëxý§'»¹é”‹ªÃí+5£Èjñ†Â~ã m&µq¢xËql }¦8SBß½+§äÁ^Xí´è{•[îŸÝÐ]¿S |g*f²Ó‘òÒQ˪ÑÙ?ƒZ­\oÌpg_s˜’“ä?ÅÇ?*9P*žý9Û(಄N3_7Eyb[Q%¦nk4W9¬×eyâ±Þ¤µz†MP§UYQ1}„õ;tÜFK®ç;u±Â9ZúúíŠëæE©¯Ò¨Á`^­7Þäxñ‘¶…,ýðú{¨ ªÈ|áÑÓcéÿjDÅjhó–Ö’ÏÙt¡/É@Qhÿ•Ò{ÖG7�ö+3õyôêî…£Ÿ¬×j2œsÅ0H¨¤Ã/„áœ#¬L¦‰6ûc1? æ¤p”Z@ËW7ðûÕr¼]žQTeþ³-‡m š`†u˜ Sl–¨"#ÔJϵ5m4 AG`–/mˆ)pFgy© (–ƒàöBai¼Ð;|’’¶ŽPröè iD…»þ}ok[wÙi (1¤©82«sÆÂÚ*Þ…P:¢{jÞo §ÃYŽå~ã»úÉóÌbs »â,È¿íÜ ŸŒbÛÄaÅWÕ<^¢G¶éWtýDáZ¯îy:¶ÍVv¶TÑ£ "““Hã8pO@Ì¡PÅ-êi·È âùÒñ€vøxò0u ××LâXoÞq(Iìfc'Új€âdƒ¢®pâN°Ã–ÐZӈߙùÑ­^dE`JSb°®^î0i©¼$ö?QÔ‹­kpÌÙx <ŒñZí# obY Y-Gî‡Æú@þ×k1¹L îÁúl™†v4#*iq‹KJO5òòÅ&YèWU˜F£?t©°%S”Qtì«ÀÂqýéxº¡Š½eÈ™²–•©ƒxˆT:ÚhKk×ÈX 1Ó‘Aqrá*úP:®t‚¢�³£¬Ùz=¾þð#x R|Ûñ(Qí&©c÷ÃN!>:%:×F‘Z禾Rç[® qµ˜g2U š§Úoo1ÓÙ˜_Э”voÈ[ ŽpÓ›®‚Q¶€Bd›£ØÒ}Ê“·ö¡~íµY_æõ‡˜!(íáþ¯Ô ð¾Ði«ÄñÀm®÷Úűo0ËâxˆÉ¹Ù`?|¶¬9ÍÚŽ‚~…L†ÞŒÐQ¹p8ƒ‚[#õ“Gu`€aqéø 7$'�›™.Õöˆ¹¿6¨ žD"/¡{L‹8Oú×w_ÿÜ"pÚß..k#©ªC·™Sã#iJkCX³åòÝñþãžM¢gJ}Ïß Õc³ÃcA QôšD…»Þm¸a/æÈ~¤y¡ƒ%ñåÏ¡’‰ÅÊ:ïþ¡»Š!0«‰D‹¤\”ÒªWõ{úx‚ÉÇÚiË&Ÿ•Ý–ù\B%#ìÈGÏã°VETÍEѧñ®ïômBÏ †™ ã¾ ¢Ñ¿@û¸ì}÷Æ–NfÆoÛ J¸†?eyË ŽŸ§š’›¥õ)™ä±€xkþÅSÕ––ÝBp;³z‰°ª†»xQ·Þ”Ú8˘g¬ŽŠÏ,Æó°ôW*€ƒ`–VÛ0çFMÃÀ‡v ä}BMbÏuLôäà¿Ùh“Œ¹¢‡³GI¶Q„Á4Üß¿,rç)KŒ~Í´b6Ö½âq•$ÎF¬‰ù2x¿«z÷—·á»pö~RÎLüÂY3Þ¯ŽŠIÙ ¹3£RV·õÕÿÉ’ØKyõdQ+êQ ܱéóÄÆxÐLeÎ5”rZmÁââÝhÐÍ¿P,¨:%"Ñ“P‘ÕyTE»áVWà÷J¥gš!Nr N2©vÔeOðâê^Yº8(àw n¥$#)EFí¬äÖCtÝoŸØ1¬LDÙ^É~Ц§”?7ÙÀ�qžU&CžÿG¶�¿©ðÈ~ÈغîLÑÚ6±¬Ñ‰÷Gð×O›Ó4î÷ÔR¯›á>žë4Èg4žfŸŸ"bŸï`(€mY‚{öá²q4ÂSÜWïÐK<XåwtåøŸç¼ì(Žt¿b¾ôº¤ú`š]•°:l6™–§¿ª»ñˆ÷åõ%àanLUàíÇ EÑì[…Ç™°H7å¸CÄcÖ^=Iìùê]ËÃR~>“¯òFW…ˆœ'ô˜Ë£*˜™5S…-‚[°¹Ë,Ž²8óO©YiÄÛÙÆLÇÓÀ´7 /a`Œø0óv¡]Ü1DüêGþøƒ°ú¼ vzðq£‡G•Õ·þQôÎÚzè.lµ5Kd©äêF ±*~¥@B9P1cÞ=TÏgnˆ‡ÏMê8冺Z§ôŽ£ÞHëk _z×Ë$â7:"GOŽDs"¢D!©ßzµûxiÕ^O0³°çöÍ rËÀýæ;¥øs¦97UÕÁô[ˆ%Ý ðoä-ð� Z³°Uú´ª<ÐR@‰´=@¾]s8þÖÆ…V¢?çƒöxú?FV±âÆ€Aqã¦ñÝÒYÌÅ4ïµiž6l¢$Y(»•ÁúB¢¯í¶Ê¹“pD»Zžˆ·Ìùx~eÔÌJåÅ4R*W7vV™þ!ƒÚéS•þ—×E@µ¤ž‡�ÕQɱm<ΰÅ)YoÝWú%‘¦Íöl)‚.òí§·ˆd̵òâ¡Åu_4.*ŠÌ ò ¯7ÿì=p$-o§•C»˜ýÏÞ¥ôÚS*6:4»#Ųâhà*0r*òy×]¿ûS°ÓÔÐt'zŸã]x ¤dÁ%€Ùª“*óYD¤Õ¬0»K]Eùþ^ºÕùOœë£Ø£óò gÊcluV"–Ñ¡‚–RZ’ãK¾c™þx"fAŸà ü6Ç`Š­´ëX”Ȳ¸Ñ ŠÓ×@%+k$,Õºr¿½ »5¨òŸT75jpkGmÏÿNC/¶f;‘Éû 7»O]™ŽŠÒòà•qÆ7:]ÿGª4†ä]td¡‡7‰(¿YÇAñyñô©ÙlR8òžký½«ëu™†>dÃ.ËO-á€åã¥ø›eY.ìžâœJÍ<ˆìþ„lí$³X$öAvÀésèOÏ<¶ãl‘x„ŒE„4u³Ð†9X{î—3JT® ÌÙÎâBÔÿÏ-åHQýí!µØ0×gÇ”0 ªÐÀ4Ñ3¥õráþ '·ä8ôrž?ÒÑ‘m&=­J'ù:_ —·Þ›Io•Å**VãHLGk*BsuhêÑÃv¿!˜F™/ˆ“àŒ ƒ°[[yNÈ¢Œ‡½Ãùqñm§i7ŽeyŠ¼}M;òâ¦1I½Ž-ê©á{þßÝðßõIDÅnã¡sm›%5 É*7 Õ>:¦%Ôúß3Ê8sˆ6éé­Ö9ÌÑÙþ`Ð; —ÉBC(A®Å?ö7ÞÎÌ”«cÚÁó|H£Ðf�ÓjBŽ€1ÛÌkÙ!kRä÷ÝÁ5ßý%ß²ÊâP™Ëk ù Ë¡‚ ØšÙïTél?E~ú1¯-êîw=ãòØ“JbŃq0p£9@)‡ú+Y(´¼eôºjI¢…,,¥~(xLvyó {Æ2Ý‘û<¤ÔÁÞBæõôU[s»Ü ­d9D Añ•Ödé©0BóˆyÀzmTlJMŸTº`_·#Z¨êg]á<{¸(Šf|Œ!§ÅÂÑkÄlÝŽ/VŽ?øèúŽ @™ùºÓ1sò³ ­ujº­§s{¼ˆZ­$÷:FYŽ3žµªÅsˆáþA·+Ûjƒ˜Y¨”Ô,Ç4Á\·Æƹۡ¡Í«î§;FNî‰K°÷1Ý·"('EŠ8Ë¢2.Ec—&s˜íåÑ—Žñ?wîYîúNâMù=k+'Xâ´{÷ý+‰xŸÞ•È|-|À–`yÛ~¡¸-æ21x?¶µõ–Xo¹D˜'`¡•žôXzæ\Ù9³ØFdêÿÛ %Öº�‰°(ÑYÁ*™â…„»söÛíJ·g7CRž÷Ñ‚b(ÄÕ+À¬…OÁšõ ¯ëOmmæ+ä¼ûɺͿêT(Ÿ6 ¡<¿”öÓd£,2FõéEn‘CòýÊ5¥H|3” ]¯Ò¿,F@[[yïêó>–ê-zŽe°j(}É·‹`±Ú„Z†òz·óZ“A_Íooƹy´è*³ÂJkó›Ê�úRìKš+ÿ S©Ð¶_Å÷å1ãÚª " ^F#®iÐ¥/0¦‚ªz©àþIe›…‡B4ç£m™¼lž8ùåØ4 ‡‘ÑìŸ.4°¦™ÄìmÝjžSÐYùå«fݑLj·¹X ¦ Û=¸·¦`Ýwœ÷ÈôâžÉçc»OTÁŸÕQm—…ˆ I±‰žY/¯¸Ó•ã°ó•¹üe«ÙV%@{—ÈŸ–™ß’ƒcrbRJ-¤¨¡X9I¾çz½9¡5ŽÙwèÁ ?­;tÓÐï„€Gb¨‘ì7Œ¾§¿v˜?ŽÛ6¬h“Ò)N9„HXì–TµïVVz YÂS¾µh*Zª s‡}[vVÎ}q²6£5Ä]-«oËÓéÃ.E-‹ûiˆîèÇeü�–Œžu½§€$œ{E÷dì¶tË/¾Z\çHøÂNù ¦‰<Lç.ÞŽîˆQÿ…N â£é¸«[ú{\¹¦;gËÕ0qgã`š0zÙ õNêìú䇥²•%ªÊ<? º¨`«ÄÔúmuR{ê2¿ÎqzIj¦ùĺOmVsEOäÛ`â¿õGfêÆpQ]™»«æuU: 𘡠ðS{,é™J+16Ì÷ p>¹-ìþ¥½ÿ‰ãø‰ÒfG&ûQŠÈç©ÙõË~ÕÔÐCŸ>dølD¹–/wüŠ³ÐU*¨¾þçÊñPšnžQ¥˜hð˜‡iœæÆŽþÀº âõÚÛ0#� mc¯ìn=Ö«ùYÆ !¦ÆÛ–­s³ïÖó8ñ X˜�<2´œ›oøçFY™y¨gŒ& –ZÏ&dS›ÜÃÀÒ¦ïcN¹Ðí¶dMf7z¼_ø­£ß¦[Ñò Uh„1j ™3£ÉÊ$0aT{G‘!v%¼` ØW&­u€w®ºé9À¶…ÑÙùì[~3ÖÆ&LŒ¸B;PÕþõI£èP9¥ùnšjtˆß<ÓØ:Ú°$Upâ 9mx5Å ¹ìí„êÏÙ¨}�„Ò_þ½/(”†¾¶4”DÎUw½ÇJ¡Ds犬Wšw±b2 P¥ æoi28#Ò-x²£Þ×x癪ˆõ>ɃêçÓ±%ÛÉÀ«v¯R²BïØø‰¯Î¹,�D’‰Û›ž>yº�¦ACyAnÉ騟Ï;¨Ó;‚ßzØD;5åZ3Ч?j®TD •î­®mE¥Ü^<G®øÝZ†jÁP0´j•PA2‚†Fª¯;±䵑àk‘¢ô%Á0*Ðø<zN”Ðþæ®*‡^ìÍj¨„c}òsÖÒŽÕZ<hÊà8Â#û/ÏÕ ‹ì4)ÏÎ`M1ÅdÒúsËK«HÅ^X€®)pVãÖ-Zªž:g¯Lÿ5Ý»zà£à²êOÃÛ-0Úà "š»Tng¯µgk'^ŒÃ…Œë`!³Þ5z³Œm]¨ðê )ªŒZnƒvtµQñ®”];X·ÁN_ óËâIÿ¦›z¬ ùb”j„õF‘•Â}+#ùÉQhELo§Y”-DárñŸu>'1;oµPk“þÞ¾kÍQ÷lMú„hÀ¦!é>Ûs#&ZÇneòî=-÷Yûyúu”—um†ÉÙÃÍHõΈ7>¾~÷]Ãû§é¢^‚ Lð�»“3Èí¨}ë¦é.BW{óλa§ Å¢�©A6h³ ë¶néC[ˆwSߢÈ<O –±‡b;ºbdJí§éòØËÈ÷4ŠŠ¥;=´¢C î…yÇöÀ½PÆsëéÖ §‡ž—ªDËbwMsÝ6IÂÐwl̓óTR¥f øø];-|Í_Zšç®þ“„è'–°wH™Ê�z9×7mz®ÝŸ0·?Ö=û"ƒË+OÝH±Øb&4iã×LYïÖÚÍVy`Ú)îh jï¸(ç¾Ñ‹[Ÿ×0ôE¿}"– yÁâ8vïÍ4“¾2fì›SœÕ Ý Pµ{tûL®=! ÊLÆúÕ~™Ô#çVØûÓL¥^§ÓÓY¶¦AûìÚI²÷+á ·´üÓpá Њ§z㉧RŒ÷¼§Žôq…Íp–âõ«73î°>ʃr»uðs`¤1½ø×t&Nœ 6û†ašu[jÐÁYC½}›CKï¥/’€Ý›e$ùµAê‘íæ>kÓ^ÄëÂÕïê!•¨,󈂱Ñw¨”§Ó¾o¹&‘oÈ‚[#–¾•¢4e,adçœøíG÷¾gÄ<zµüàíMÀe –Õ6b­'çÐ ðwËOÁkƒÒgÖ¥<{´!«¿ ƒtX{cgá?óXE²n§&* cìÛÃP²ItEýVJRùät*[&:Á‹îâ1/haRõ«,ïëêf×=”†b[lÅÐRQª@2f29'ðf_zQˆbTÔÓCÙjög¬;×ïÖµ¢+Þ¨ãã¤rZ£œÝ6ì#ÝüõÐ=–à j't=*Aë¾k±[²½ß@ÀÎáQ5úa�á‰îñdP=Ü—¼ðÝO±ì)ÓZŒ;ÅC2h‘êŸÝ(”/ÓÁî¿MW Óå<ˆ*è .V[ÏØdËø;u}ë\Íb—á©t«V¥QõOÍ°mòôDo”ÑŸi¤WÎ÷Wà&ãž>ruù6ý$¬+tÜ¡gô?1?œœZlæÜ—C”Ÿ“G ¾­I�y2É,‚2U*òåß;ßÁS±‹$y¢ »S%�·�ÿg½uc¯Ív ÚÉx#w*ÊÄ&ñb æ–á·’õÑ¢tÇ©Ì>RCo(‚ҶcwMW|eX–z²Ï 6×þ‹–ëØ{:´€È-ÿ†¥$úÕ Ÿ÷ÓÀ&¡'2ªª£X› WV*ѯäüq®Ã>$N½íBèÖBÄÕÄDåDtút‚e} —»“@x_45/CÏ¢Å>†ïY#jnóº_S%\A‘y½Œygq|zói\KÊ8XQè U€Òà ³p[»-)DO’Â4 =ìæX‘À9>u$ 4ÂÒç²zª©,¬û(ƒK@ÉÔf“>ÙalvôÁænh./dçã8óÿ�팞Yµµç¼µÅàÉàtY²Ð$;pËL‹=Óµ’z†V¬–íÂvƒLam»»LÔ6¯·,/|.eã>ò£ªÍŒà™ÖÿùˆCÊÜ.€ÔÍÌbjú–|<ì¥k÷V \ÚC„q0O ýÝ‹GP¨1Ö<ä¹ä.S#Í“g?)HÓ èék5ë¡]Ïø-‘^Á²x¡ÌSò©'Æ–FZ‡àªüØCÔaüU¬…£É«ê:­\†Š ?æAüS›X["MokmñJ¯ b¿ŸdÈç.™û‘.câQG)ܨï%±|î5jEŸçøŽý£ç€”« ÔÜÖÃ^õº¦>6½p <K¥e×v»z§ â¦þzàÃ9X€Cbs£Äµ{?!Wö:è ºQÛšälu–À¿Te<sXŽ'8±íë3äA”g¾ 1­ðóX¡¥wŠ¢,L}Í<-Épêx&â¤y^MG,+ʶŒ;€”\û©ÛãxŸtÖ|‚„„‘ ÷x„bÛ*(9Kƒ†þŒãÄû�XÅ–AŽüóå7­5çWœš>ÕDÅc}ñ´ÛÈÓ÷`á‘Z…*%ÉøÏhú1ë‡8¢Ãˆ)§›EËM[õË"Bÿ û¶%ûP ‰çÒX¨I£ !:\od•ýÆ>1¶v¬?Géˆø·n ‚ŸKÞ¿ö¬ŽýE4¤u¯<þàw™ç?‡.|×¾ÿzº[ LÂGç=l‹¨Û‹;eUä£éÍßp,ê/’ܦüF„ª5cÓÅ—&©UÈ]é áb$ÇýÿŸµ?ÛnUY¶…ákÖSøî»™ó4êâ*l2 !k´ÿýŸã‘‘™È’-{îÓÚžkËdFFÑ‹>£{dñ xGnïÐ zh®CÀü=zÒ[ìï ¥ŠÇô•;q¦0‘œ1b™�(T§ªŒDyvg )¿• H"ï¯pˆ0UY98¤ô…ÅÁÃxÛÅ(Õш#c×;Ïtö=! ¨ÌÍP¶0ÒI%ÛˤŽ+\ÐϤÊlÓ…ôVĵöKÁbûÍ`ZϽDømÛ2þqy0C­j¶ k˜ažßì¡÷ŸÇéö•s`))yaÇý_kÉë™N>M^É‹©ô <@)n!pŸ¡pIá1L˜•7÷E7:ìêæ°¯U»PÑ ¬&c^.WÆñÞù%ÕjÈ¢›V‰Í‚±ž,ƒ@.“Þ¿UFLÃUòNñ j‘é¶çÞŸ¬&6çyêaö<¨rQá,-­.Z}:Ñ—£{ó”šdžùc*áö1¨ÁªG‘Ôº5AÝ$J˜›É’^ÿ`}Sln‡†º$ÖÖ½}Ø)»,Ãùäµ6"s«Ø—ÖDÝ—³Þ¼GÜ{C ;#@*KÿTJ‚¥ô€liôÌ9¹ô/bÑ~°ØvËú}á[Ðôva¦ðìÄ~à•”®Â­ˆ¶ƒáä»:Îeȹú§Ƀ^35g«׈¿ýY@w_êáŪeˆi°½–´å;Æâ/ÑQ«Ž•Ùú+'âÜQEK`{íۛ·5‰c3$múÈ‚8 –z &}Æ˦ŒWL>täÐ>Á—ø†N‰|@4Zámg eåYÁö’”½)#Û¥¥ÃäCí»épœmWIµXÜìéÑï¹z#˜#:IbéÏ‚>¾Ô"íCûeyÎû/MQ[Ë ® •.f¶³SN `g(ZÉp?9¼ý4šV¥w‰ñBá�7Íáÿ—žuö [Þ…Ò”ŽßýïK#À,7#Î7ñYQºYŽ}}áʉ–^ó#Êñ]ÄVع£>R8(2¯ø¡£Už,‹Yò ot4lÞôÖl�ñ7¤y~´gö®Õ°ÁýÈÍß÷ žÕtsþÝéwQ ’’^Ež¾…3ù˜6¿›žµø–‹ejËï Ú¼¨ÕÃßžû­Wo`ÍÂ#xÅé¢ Å$pÚÚñŠ¡²êÆåg}¿7zóTÎAÊزw £ª`Œ2Òÿ …Õ kÊw\ú¨\n<Ââää“Ó*Ì|I윕<òÓÙœÉË¿/&YËÌùu ì{J%. #—0KÇl¡¿cÀ-`’¢†OÞ+?ø`±8ô$i iÛ”¯'óh2AÓ?ê6›mÜ')Uåè˜Ì{—«dæðÄ›ùåÈ.#_])Éظ™SÌ8Æž‡; ùŽœË¼`›£®ÞâþßïÍÜiÓØH&O•ŠÉŽ=B†A¥¹ÖMöíDÉ1]•Ú i–¸Öù@YrWF,½•AÊs;viå6ß3F7ñZ܆òW�¾¦Ú3<0t}M^<ù‚¯òÄa7X5KôP{‚å�0²¿¾D­Lˆxz–Ár))WyuÃÇžMGØG+ÖÔ¯zµ§õ3#õ¾£dFʦG£‰G:·ze ¦�ßP¡\÷‹µ<Þ"Ób6ô äù Ivýº¼ Š«E’²'ˆpóNTl1wþ6Êgi‘¹X‚&ÝÓ³Âb ˆ@Å/ŽeÁ}íoµòvLn5N=Ì!o…›¹/Ky™¦µtJ5ˆ÷?ëM”ÕJ™´À¡]@eÔX ÃKÓŠy¸Ï!iOf~rhxžÓEÖ¢/o«3(ª(|Ôýü‚ˆe¹>ÀzÊ/æ»GV±šK†…Å,/…P?Ù ¼uæ¿^ üR‰YQ qhH‚°jDWO‡9XE¸¹“Fšg<­`—h¥T-‚lÚ^\»Ëô´=4¶Àéiƒ¼QéÍ&%ÜÔ™Eåh¸|þ&œ[½ðæ øŠ9™{L ‰8÷»ÍCÄø•‘ÁÇÉ«Ži?;I<EZ;ƒ è(½JÇsòÜ÷6ãîLTïªü a-ͤeìgÙrý+éþ7Õx\z�ý§÷RS$έU¶±­™ØdtÁ7#·_Ú³iõ›\ü±Iœg¾k+(Z#jê6tl^éå†ñzìøŒgTš8\‘xÃÎWZ–a;˜Ü¦NKM‹%âËƼhßu‡áÀÎEý¼ç‘Îi¼\góoô¿2wòÚ¥‘ÛH¨rÑP±Æl‡´`–‘‘éž×æ¡Ã`\ÚŒ÷¥TÔ`SD, ˆÁ<ßùlñz´?ó7ån¶’ IB¡!–ûÁäþ P­Y˜ßÒSë·©çL3•œ19zÁreº7µ¬³êoŒ6$x»LFx¬ßf= |ÉÚ2H^ÃW5·¥?ÌÜÀDÌ)³Š“¸¼q’—Œ¸%+¨ÂÆÀ%XÆÄgÏH–¬dÅsP¹2óÔ³qsá|Wµ¾Icƒÿ±óœWß»g ðâÈ÷Q¤{½Ì ôu¶``qÖ‹iYýbIÊx¡@àè¿ÝL\x)Œðö^­‚ÎÏÚâh±Ðà0ˈゑÅÍOº(¥bÄ öm”g;ÈÏbc=ÄhœºGÁÅAÿIý¦D ôÒÈÂ| Žƒ²ÖHÍž€�P@Øœçý™NWúŸœ…ù"¯F‚Â/­R×—&ßp¡Ýú®=}ˆÎÍ⚦ŽFœÞÂZÕ¹Ù ÏÀK ÿÅ¢CÓát:€þ³©§-Ÿ:ØŽü;‘b¤Èèã-=àe–úc°dê)Ÿ”‹›,Þä‡OfF?ŸjZS ;Ðÿʸ´Rs£�è¥à}TõFÿKàÂeaÉ -$EP¼·ž«47­ìÛ¹-÷ÐpAÅ "n P\û2ˆ_;oq¢îèÔ é׉¨rSß’³’¾ªföÌÒlNlx}5+Ã[ðpï7KmŒVî[5Å^ÊÈ£"¤å~öüÝw}Ý:ðto!3t“UìkôÊ×t‘0u˜/NGY¨º^<råö°ü5½1»T, ”¬ŒFù£>¨µÿ‰ùaóÆÚP¿gZå:ï* õrØáDžuJƒ4ˆò;©áƼÕÓŽÛQ”f$.aWÐço·Ýwk¼Ç€I³Ñ«–cYP’yÙX6-½¢'g¹˜ ŒkK ÏU²Ö* HŸý§>o¥§ºÅj‹Œzï?<Á¤/¶O¿‚¼Ç-ÄCJæx‡üuµU϶¼¬vay}ʛکc=JÛ&ýÜ1-CÇAâFø2ÐmꯚÕc„f8†adÂnÚ^È–³™�¿ ˆ˜?ýlþn¬NÚ€¦'4íQž[)=˜äɈÂYÐQÊ ÙúVÝ7™sn“…WÍ#Ôèvv 0¦tpE3ØæÚØy™ÕÌ ¡#D jÏ°¤ïj<Ûç[u w|ºƒE±´Ð"Ñ«)Ån¼öEïHö^€ùÖlÜÕ¢àó©Už¬Ðz\çaíûÔAä›lY_¿„?”Ýñ‡dàé?/ ¼±Zfû4.Ìúïr \ØPÑâ«_âM9 VÄs¸n~êpöï ö°%&ŽaprúBZÙ³í&!„‡ÏÓ‰ÍCŸd'»¹md|à Õ¯¶ cóƒ)ã.òHlÝÔézèè O:ü�±ŠL“y°üv»Ñ œïùÜûÝ'oQO҃ŭN}”¦@S·Ã#Vü®Á%Óò0ÿA÷Myè„�?˜{å¡uNÝpu®ƒ†à{”ÁCðX é10ÖÖÓŠGL"=]p¦xÇ%3*å<sígb£`´€êö­kþ¹þ¹ÖÃlɧ©þ+:Bl,KÕÜt`''›±Æª,mäªàHk;wUOÆke¢øˆr៾¥“‹jÝHÉÌ$YŒ'ÑwôY~¢'•+»âJ½£' Ï-§<÷câ8te˜n@@µ¨Õ2ºbc³£ß<…ŽóÇÆÞ=Ï‚jÚy tìgsXu‰‘ p§8uËþ›¾r$w>Ûa×SŒqþä ºö€–Ÿµ=`šäEŠžÝ£TZ†œˆdŸ•L2Wq26q.(oÜ+Þ€WWOé2þ–Ãn/îá=ÊÏ–w°Š¯½{;ôƒ5øCxÁ^¸ªÄ/[d|LK RÐ{Z¨D ‰uTÿÖãóGþê³G™ÞŠ³PßåE1"5¦¶þs ]ÐYg –fÖñÙŒu/Õ‡ô18c¿†~FŠ&k¢‘ì¾èìÀqv«ù°}ZÂ-[™kƒÔÕgtvuAd?N’ömG/”<ÑÂÎ’ÂWG‡Þ*¦Bgë~KÛb;°³z&v|Ï%ÉR°¢Ø8Ôv¨×0H<Û“Óª© ña¨ðÞå''ÍÔq¥èà=Qu;+¸§Èp¾Õ3J– •Í,9ÇÓ0üẺVý>yóõO¾[‚ÒtÜNºÖ5%M«öʹ¶ÉK¶çžqÅÊ2Ò×uR­€QÝx¶:]<W` WôéÞöÝ(Õ“ˆÈƒo&:húÛ^K™G‡y»:­åÍÊœ¥~Ë·ý‰5(_õ6¤˜5Ñ EZ·ëd4ç„9¾—èÈâlUÛUTÑ-pTR4gЦQârýìò®Ä•.?ýßösn z‘¶#§Â=‰¢>CùèüßÌJEÞü{ÓžóŒ B çÈ¢ ›ÞÍRd$;ädLÃð”åe¨ÿÔs°E;©Ç´!Rkz+­ÜÐ7È>66%ÃðdŒa@XOÛı¾yj"å0ш5 º/b(½Ö�‹›šº³Í‡æ<ì¸|k¤dUÛ…”‚x2¡™l¥Ã%&ªÔVlødõtt6&×ýü¥|`©#²Ôdà›=%ÃïâðÇCÃÍ…î7kùl¯"•7ðÄS‚ß#ò0½Kîûå?ŒÍß`{Ѩ”m•Ë Úž‚@I±Í›n°À'\ãj&e!÷2(Ú«n­"0ºÐê0vî¬cnË­j»GMgu£Í±b«Ø;Àq¿¥áw^F–” ÐЊX¬/òm­QØ°³B=¯:øÊ �˜1¸sXJ­~†´õa††uMA¦ ŠmëéËí…m¦H?0NÈ‹û ´Ù 38‘¥u*Å”f¼‘¼ÜS)wå_aHÆ3Ü6·µm¢÷Ò+¥¨Àä —?+ò;©P¦Ï5åz±ULf:Õô"wc˜û”z‹¢.+8®ú†Ù—yò)‹ MI-‹O«­ßtž‰#«fáw¥µYëõØhÇÌ¢¹ºÅ±ÎHÛz7°75 ºE"âa9Ügº4Èj­¸©úÛ)*2cmöZ]D~]pç¡ï"ŒîÍ\qk[BI\l¯Üý6Ù-u-¤Ð‡ÜðUÃ1ÃF˜(mN$xæÿÜø‘;4Äw>¹q\¤^¶GÙýiŒ¡®¿wi8PŠ*êx$ÿÌôÚ9°t:”4iµZQ’Z4M;„{ΫlòÑ8)JÊÐǮ۠·~Uù”;,vNe[T{~¥Fæ07Ýæ ×Dû—Qe|x§+·ìTñ§í™?û,HêU+ÑÂÞŒRl‹©Ïi[ ÛQäZ'v€‰‘.™µGßwÿÉ >Vw3©š³>9Dt¬R¡+º¾õ8øÊõ \y`j±ò}píÆš¾€Eà”pŽ”ãvÃ3c©"nÔS®i³ Ø¿+*‘ÓÜ Ä¤m:ñ«òü Äi{¬¨x´}5DpÎä<ˆQP]cz‚Ìæö”±0щþå€tÙgìÕÖ§#åÐÖí+I/Ȫ=¼n•i¬¯LK@Ãä3* }pŒÞCFï8}ø:ÊûNxÓFz”jˆEðÞåU­Òø/D2ó„º!|1__WÞhnD¡K÷çæ‡q±r"¦h±Ï“{¶|LŠã0×¹ýÔI!ä®.[Ýú›0ö ˜otùC ³¾zéÿ§nÒ"\cÊnþðYÇ£ˆ/ºó¥I«¼9w"GB¦À^:¨¸*()us¥g25ÏøìÕƒAm"Ú¹ü‘fÏ8mO+Ts>ÁuŽc³¹ZìlÚß;4’¤t´üœù4oPA½8ý3‹€q\¹g5qÊÄh¡åÓ²ÿ ß:Eµ½E¢`÷ôk(0`ÚÎ*qŸvt»NYÊz™”ªFƒbàKãqÚ2ØFìdœ1ô¨r Ú‹Ûa™Ø÷HØñ �É“úx$ý<4ó8¨jǾëdeüD´#öUQUé¦4ÖÜ�†�—ºí 3ROÓ‡bE®€y ¶yõµç|C‰esu 󙱊<E•éìßœ”Gî2ÁÂc:' ››`„eY?ldYóY­–ô_vM¬MÓ­Â ˜Â’ÛÝVq¶"B¨Åþòöæc áM�R6½s4«M/æþð™]Ó#Äm¯<úУy”—.±-gÅ«í¸E'9íåÏÙü-Nù8ÏøaêEk†?í2H¯“Z³fx OG#©ÌëçšsNfŠŸJÆt÷wÖó{v¨»µØΉ×5% 8ùÛë„X ­Z9ˆIkPí5‘© —RïðhÔóy„–T¡ß]â�U÷ŠÒs–Ä¢©óÜt¦+4M<)R~Ö[P‰ ©Ûéë¿;€ûÿ56Yà1ÜîpݲÈc4T˜~Ó›QØ}×øag’ög¥¬ ŽÄÑ#}éêâA—yÆÚB%K¾÷ýgöíã ³Ô•èf¥´m—wßõâÀõ»qfCAÓÕOk#—kÉZ,ÇŠŽöwíäL#f¯ÎoýM¾G~ÎUˆ:oµÄi pxÿÀ¿F}lĈSG¿_L’ ®Ê¿Ýg\~8à”8ˆR‰$a18~ÆÌ©Ý¢rö•9f–gžØ EdÖÀý8y ÷<°ðÌîÈàB‘Ùô_î¤ •ÇQçãww¦·ÿ8¹2�4ÒM‘¸{‹ÿÎ6H=Â8cÀ6[:d“îäJוZ*Vɦ¾ôÞÕ¸»LŒaö%+ìIÎÍgÀ®ó ígï§Ä†¡r hÖè{¾Èü|ÚQ¼·¸8nñuãvKßÒú²m,5†Ö#,n_Q %¾Tp–hËŽ~Ùo_Ž£Å¥‚…¢=v8ΦîWìÈ»r—if|2uà{„äk:èç7 ˜Þ{ú‘dÑ]é¤>\ñ{l&.¤ ÚM—)¦ä݃b7T?]'í˜9‘˜;WŸ‘6¹ñNq;k„C#ÞÃ䪔ŠÚ¥©§¸ÄôhÒ‰_ÊŸó0[íÞg…" N‰*#ÿÇ<ò²V²‹tiÿ‡¶2lªê7 Ë×ñê·¨z‡O@fî´»8`Õ4 ¨Ã¹ >2„Œý%G ¨¯éœî·Þ8ÄŽB¶°–p)Þ*QÔ†"O½/YXµdøR{ÈOè§Ô4¸îïÖÌ‘5{JÍZ9MtL”'_€¶»öÖRMúB50*3Ú:¦‡xèžϨð"¢Á÷x¥¨Ênà í(#=Yè³í•ÂÆuxEG×*þQ•'XüýÇŽ§½¸«Ðwd‚yÞ)Šùd§Á‰æmy ì äfºÕ†…~çÊghÆqâ;ŸÓ{ÎSDç“K·èôg ÔêäãÃ-Šxî[ÿ”ZÛ¦üùeGu‰‡èöcËÿ R¿8Õ·§Œÿ<ç DtËh±·gÛÎV$MÅ<?MŽµn ¹aT61}}õä‹ëéÒ;ø99Ê3K‚?0åA¸|x3W¬¸fœN渠ÜU¼ó>5£òÌc¾Ð–b_ÕdÖÒ dR=¼­Ý0èxßñƒV£ÓªˆŒõâÐÑŠM·šWrkŠ]ÿÚzV7ͦ¯1]à0‰†?†½3ƒÍn—SšÆ™çž ¼yóiÕx®§Á �ŒXwlf´Îß\xnx2~ÏF8ñ°a™èjqÖêqÅ6Ñ%õÑÇîmöá.ï £ÿI‘ØÜ‹I‰ÍÓ >h¹@éŒÜ~‹·g1•%øà þ˜ÞÕwùwš9˜«ÒNTñTûQâ*¸ÏÕ0ša¼@soPÒ™sòÿgÔáçô²Èg””²¨RV±"TðS¨­"„}Ñæï)ÎG¨4ÆèÓŽžovþë**„·š 4|È.‡¾c›"›ñ†¢/ežè;´€(†TÁÓNx×îŸæ«â2bˆ<?Î.׈PøÙ€ló·÷àÅÓH¥¡×ˆúÞÁ<*nœ×étÌ‚x;{&µ{ì#§Q§çã÷çd‘ßSóàu¼>Aá|^Îía”³&‡Ãlw˜jÑ§ó µ¢rWôÄ?BÕ½i¹Óµ·#en~xêpÏ¡ÑS_½ÝŒ‚³&çìL+d¢À©õ¥°*Þ%^‰/ÜÏËJGM²1«¡H2°¢m±ÿ f¾‡`›ŒÄs\î;À|v^úÌ µHKßÐ<J*˜Ö œe(ÇóüS7U­—7ÌÚ,:ýKæ}äF„&-ÅÅ/Ÿ_= E goL‡·BÀO8÷E±‹lFs2 ¢Fó}áEnÞÇöSÁ€ˆKCŸÔÊ­ØÂzAFÛÆð9ÐÚy®ïš%þûÒ—¿Ôtn½+›>âÁßزœ`91@eÌÏÚqQ”"R¤eХؖ PXgŽAwUŸåp<‰¹nÝ/-@LR<j¥Î —y–-íâ²™½X]ácyÞò–%O.S÷‚™¼øÜwų4 ŒÇƒJ:=‹à@'[6OÙRÚÓÝQ«)R©âY²žÓų1ì%ÊÐ ±Ø•ý«¼GEÕB)] ãM÷¾¹z­êc׿qÞf$q~žZÜ÷/)­jëÌ3Ï€—ÎÔPL¤-cnyÓ}0FW^î”αÝI*ØåͪJ®_<šSGwÜ°<éõZ8qY•Ë;-ÅI`'8´êÀÊ8Éš'qy¯«Î\šx.H cí;°4‘JÐY<3£Å%ÉßïúÐO[Ñ“P´>ä§3×;ÈRÜ[:¾ÒÛýWMÒÌ×¢¡§u韤ù뤄‹xó…¦1†½ïK7õ8L\’Ê[pÚc îuZX`AˆNŽêLGÕ…µEÌ«‰œ¼ ‹#»Ó œ/=uv#kIsFÇÛ*lââQ/?IŠÌW0ŒÔÝò8R;e2 ÷I+ö\Uµ ÷&FK“öD;xƒ³ `äÎß“µYîÖÈdzH|?£Àh>¼øf2¡@DØL’nÔWæSM·âæz¤ª&À‚š4€QÍkߖѼШèSÜ%¯3žS(ëÁ®¸ÊOâbÈ“`Á<Ïé®þsÀZ3}°b$žM„ÈêÁž<~ÌY•cœÑõ¦Èý©-¹ÍŽEn‹¾k»‘ÓNŽ(Œ‰¬¸úW³gÏžŽ'!ÖÞÕÙ_ÿÄ'³ÛûMÒÍðU|©bã&0 Ûô\B[&ïòSW3‰VCÔð'JÖ*‹¨±LTée�_k¼GL~Œ¾æÿïÿ£•sÖ?˜M˜Ñ·àÚÌ D¥xaµíl® ( c aÚÁ“âVc;«|'8è%T}í<IÙ N6@]úįˆ|O)¨qöØqþœ É&{%ò´œÒÉü@oO/õyÃ~ôX'%ºÚçœè¡(Çj­º ÊZg©G€Ž§1�pG_™–¡Øý™ ßJzïö<O£Ð—ÌŽ mƒ¡ý°$¬1!<»³+øÒrçùåêvXÜ$• ×4MæD«i*ǡߧ»Ü÷I”Ý_ÕYPƒ³˜ƒ%Ìñ®…—ÅåºúWÕJ¦a“ËÓˆˆòn¨ÑX`çép£²“sŒÜÔCÍ@û§–ITº¬’³ãÍ:{…ÄYbž¿ïи1;éúpÚnÍYèÕÍ ”smwrçð©?UÚ±f‘?-Dý ~X¼uÜá‰/€©¥šï¯.3ÛŒ—ÞÏZ`S‡bëó[W‹3ú­[¼Ía•Ar™Jä­«;®oÞ8+1è³îFQ’®0¥¬ôLg‹ÛàþŸƒªãþ¼•™®¦™¼¿=óq2CkØ1ÿÜN®¼Uw›©‚.mB•YÍlðè´N‡ßúפQzMFzžäÙ*ÍÏ f¯¼d¼8ûõt£Šm=Âb£bQ‘?LCŽ,*>¶2/-ÆyVÞj h¯°“ÐA{š7<«3=sMƒé„Ä%ök·/¼•QžÇ g¬€ÂHÀ¢#L6/ ÞÐDëúÅê÷'¦ÕÖ¡¨ÎfbÓ)_D-Í$3±¾,Ó7>N¾®2JeèØŒwïøÁqèFÉhG Îü˜" W∠,Õˆ¼³Â· ö²\/*+Úé:÷±$=ÂÌ¡ó/å.ÝþÌ2ŽsÍÆ$ ”ŽC wpƒ“‚…|Ï­cT)`zûÜkìŒTÉ0\TѹÜ×ù ǦœöôW¢¡¶yMLýKO›²¢/oìJÂåtî5ã jq¶{×"ÓãЋ>\ʼnoR¿ ˆÎ¤;ÙÎéã9!º4‰òÕ,â˜éǤ+E‰¨Sˆ"#€[Aó’ü?Úðx‡mÔ|ö˼6ŽswаÆÒ®/‚´œ!´š¼RqÂ0Ö‹/ðžiê×gtŠµC$–~–2%N1Þ׸SÏ鱯™U sØ4Ð6µNO4Ú4a|MãbQÛíÄB…=@günì€Ô?;b|W SÄ3h?gæ†iÈúw)}3khàló ·.e£”¿5–æ¯ÔMÀ_Pð’}ÛªŠÊзŽ�ÓÌpvr$8r–qDÏòeå6úÄø2.<Ï ¾)ŒC,§W¦\ƾgýG*ˆ:AIü|Xz¸µ¢­‹ ·îCH“»n³z‹pIJåGݤ$)“‚Ž4k¢V!] ƒ¢¹±DÄ€†aL§n™Æþeî¦?—cÑIX™cªò?6ö7Ÿ%¨"Oo_™3Í ÜæônYج°L÷\G?‡Àg©ç-ÅäÉ} V™&2ìhcä+ЇØõþd!Q-[{aá‹÷ªäzÁs¼6gÑñ@2u»ÃÌîjö Ö“z0§ù#ÓtRKù”¡�ž»šáæ¼›ï¹:‘:æ eÂ|¬.’ÁÞŸ’♞°ºW®pŠZwa=Iááo`:ÏEÌ=÷Ýz~?<¦¦%Û»ÍÌ?ØÃÂñ& ´Cù•Ãr×ÅÈ!Çì@2ƒOĶ6F†}dŽó\’¼Ð},R@ã kžƒ~°‘„2á¡nL]g/ÔÉÉPs §~ X¡#†¸EË@ϵUÐV, ÜOlú‡mÕ$ xR¦ªÌ}gk¨¿åV5@„ª w:T EsbÝÀ'¹j)H"JÑ’$È=ÚrÖWL3ÄÿfPQæ.—áõÓ. �féNðyÁª‡Â  jÙcߥŸÆë°ü¥-mνà�‹¯Å»ÂÚµ¨¤‰ØjÒ£g#êpÒUƆNãÿ@ÂÌp¾´£FFîuDqm߬© /™û{FTwÄÏ5w¢,uÍI–r˜—”N¿ üÒ%|7;ukã–V3u8Cq÷L{ñ{Ð[”®ç˜µ1KƒËæë¦f{`«˜dè²/˜yC¥u½³X Ê ’¿Ö~0Euªéõ ‚Í¿ÄWW‰«~y´²ÏÂð鿉gEaâ¶MÂœ~ž+T¨Ê¡|5šì¶LýíÀ8Ë|KH”ó�ª>>œÓñ:-öë(NüöµÖ³¯<i§ÝJÌ!ÛIÛáЀ¯`øó6œ·¦œV&âF«ÑÓß/ŽkNŽâøØ;‘|ë;Mmá>ߨ`{m/UÀnnâœà �ºf%@p£F€T3óÖ-‹Qmiõ, ©ÙŠ *L…¹1]FV‘‡ùYÈ™'œÁÏËv6÷b=]_ïkµ½ƒÉÜóƒã$^©EÓzEy︕ˆÒÓéJÑ JêYxXÎ £(Ô¾57kP¼ì©x,…µW†ÕÁÉ«¢OŒ«°¯—Ã4Õ·¶««‰='áܘ-êŒÄïˆ$öêêDr#öw6Q䃦¢ðE.*)ðE;“^•ïtíag᤯%a£2öûü«û(³ˆÀƒ] ƒŸT/Úk‰#ÓÞ¾�›—î‹T;±&¥6gÚ_W–šÙŸþ“¸PìœãB†d\æ’ª K/ظuøïZŸEhL*3ãžwÂ%i-1Œû«geAG‚øÃñþ¼aUk7ª(I2Ï÷š™MCß?²Xkؽ4u»Ua_Ͻ’tÝoþÊMð9ð=K3iÖðX¹ÕO§Àܤ\¿itŒw³9%¹ãÜÂêX®ÌáJÿa*®' ×soñ³’"Hg_sy8X¹Ž BX#¥kñÍ‹Ae.ÖÒ,}­(í¼bª0²ž¦¬T]i¼6*GÎ;N„F"‹N™U¬¦"‰ù¡É\gªSnxô_ÔºDÏH¶Ç˜/I½ÿuÏ—þ×X¦ŒÁ[—Uôu ¡Xß–Ù[wx¥?ëø¦È‚¬µ–%€2ÂÍÓÛ7™1-þÖœ‹·¿ø¢io•J#I=㜉͹º³#*6V€.ÜÒ¤r*ÿLËô²ºvýAÞ3ª¹'³z‚gëöh~qE9׫;ÃNT©œºÍbV¿¤U2óŽqVf~7‘²Ó™öD²³ôBn]X’ów¨Ä!>pnæÁ± ÂÝ«vN2ÖhÞ[ü'ªa^Å·‚²¡9¥;¶3!DZÊ/ûv<þÈNÒ”¾ö¬¤³¦¦*k×èÄ ü<`šÝX¯¡¬Ž¥oŸ€ÒÅ™?IeÝ£ ž~&EÓKg¹(Ïúê'%i!–bUŽ|q%?ŠF¾yßïµ&"yDF· .Û4H»æCV®CÓN&áÃSäk¿uj"c¯>9"Û jaŠ,ýIç¯é�`6ëKÈ8ŽúO—¤wkØzçgqÕMÜÉUI76´ú<5*ƒ"ÿÐñ[F«®§2HÏ“Gð¤uÛQi{'Žwi¿¤ø·=€¨(ò4sä`ø@Œ®•�ª?ãgŠ¥3¬„ë‹¥ }i•FÙŠ¬í’I­†³ ªkºúÌ,~§äxh‰[qû‘ A¥ ^ ô'^=‹y)ºvüÔµ}õ¥¦†ªuù©ñq à Ó^4:íÎJ§² ÙûNý:.ãÌ«'rFô¦“åì—Òíõ¥Û©¨@)ôœ®«6iÅ› l¯?¨¼R¶$ÜJLu·6œ‡®ÖÓ×þöÆ5:ŽUÈQµK¬5‚üþL+`å¬öHÈ< LPŠAñÍ MÑyÑE'Öò;¦ÐþY5×ÕÙÓ…–‚ÓYY!DHé„ ä¥iT‡CiN‚¤ÇˆKWzŸ·pÆv¡|`;[át£"£ÒQ¦šþ�ä®ÞûÛ^œÛŽÑÚð;ƒ,8½õÒú·™Ò¨ëЪÐ!ÝÞößXè$~mR]úô³…9ˆÃÆ<CsU²Ä—Äèžö",Mé̬¸¼›jÖo—½ÍâRÿI—Êy™J8Uô·^÷Î]óe™÷N‡¹c~•èþ•‡v*E¹JíË`Î)8ÎVBˆvÿûÉ¥uyBk'22äêôƒ§º‹ƒ´kÜI>È8NïÑ¡7âë_)(ØáV#ö ’“j8EyÄý4Ó5­—†Gdµé{â#vÅù×èK)wúnñùì¹(Óæbed=>~ œI×^0ʘþn¬ÓêÓõ@íô)K1áåMG`_oÞ†{ãÀÒ3ÌL±Šaoœ ½sEÇLÒÈ"þi²¯¼%ˆa'Á¾-ƒrÑž~ªµwÛa»ÉÐÃýâY''îýe$"™’®Ôv£?µÊÂ|–èé‡$tafªSöžb;| äè’0=ø ‘Q ±û5-µô|ý„úAwšNW•vlÖXŠu¥ø°TzRVÌðÀÇ«¶5qÀîêA “†ÅmÕ7¦ YÞšvW•é¾”-s8ѹ I5€e ì¥5ïKiµP©¬áa!Òú¬ÛõMïR¿ú£rØeì`Ænð~‡é&yLð=N}¡|Æü•ÏÚ‰?£| ™¡Uo¥.u¡»ýÇ&1·½ïï…'õÞˆ, $£ÿPf×ëˆ'-¹æ_üYóÈje£ Áýx·>!%cpÑl•0u'ûz‡Ynn’â¦÷rM¬J,3ú(±h\o„ üiææÊÅ}{n‡ñ}êªí\Ý6áOo]¸ ~Êß°sLîçFË|Än`Y×T0µš0ZnÏ´~_lÉò#Ÿl–FÊLqš‹÷"­¼´]<Üæ¾)µqÛ³©ˆè¨fæôÀ"}¡ª<.|«¢VEôEºw×;ÙÑ>ñE›îÒr4€ä@5#9Ûö+3³%E¬.(ñÂÝÉ/Ò °,ŠaÀÐͼ¾löõüyª—g+RI„NÄJçéÚjÛõ‡ˆÿ¯.o÷(Noägö5} «È>>{ɶꃄ“Óa蘗/ÕIèOØBäa½ñ{ï © ¤½�! PÁ?ÏêÃJ‘8 Úâîxyø|Ð’datènqìœ.kgÏ#-—yÀ†2‰®¬gë%o·Ÿ^oÈÕ\-±K±Ÿ,à.ãa.îæí~(Äb £ ›…fÒTA~ÖQÝéü©o<fƒs¿éÓ£~Yw~%Bì²»Db1ƒÜj·"Þ E5•û} ƒ¯Ü oÿ2ìºaGŸ«›E‹4¬I…�ß/Œï­’Ò‘W¹WÓCº¸ñ†…»É!e~…³ÛB¤í鮤õ‡BŠ¦Ã¸ò&.)é®ß¬ÆÀgë7ÿ¬³£$ôÐKà-ónÇ'íìý¡¶ÂËàãò@ò‘‚l”'þŒü3†Ð/=JÔ'×5;G$ÉZ.i€‰ y×;ò6À9 ©À?/9h~ŽŒkÒÛpýÓyÂÑÏ!'¬ž,ªïŒ ·:âëÖLOsê ýM;2™é/[m²cýÁ•³e.Bþý2Feª `];z ñ^³’Q{üE™½¼Iî©*7ïî.ŒœbÏ Y&|Ã.§L¢ñâíµéÝ­aý>´±åUX»®íÅmè–ám¥Ý8ͧ˜K¹q´Õ)«V+LÉC6<9°×ïÀubì ƺÙyëAÂ÷õâ›ûÕ—… bp§²3!,)M‚²_œ.‹-©zá·ég$ÄW«´<Ó�B…ƒÆEÄøµ£·ˆvÓá8ÛØÊ'Ï�ûù÷Ø…osBÃÌSïá=ên¾NõÀM¸\éY_Çíèkv�tz—^0’¼‚àVîÿ®BY%ê¾¾èøp3ÕÇ• ÚCÃ'‚žª%!xïÙèñ`Z$m¤4ñF—1àÚœR,ØäWÃyh&%¼y 2ÍûÅ9ëé‚ÃTAóJø˜/<Ã~÷—©ü‘˜9ªaÅüÌhP Ð�çeLÌ ú­¾b”Ü8û^GºeI§z#;/£°¿·n¡=)p°�{îwIPäÔŠøxŸö”ê`l`âw‘Ó¡Ø×W¨Ûͦvó£è×p¦»v—•Q0ä _Ñà<éèÀÕ-þ€Et-fºœ”zÝ…a4B™‡ì;¢Yé¯}úk¬—ójù¨YÀ<€¾sFáßJæd‰Åʤ›ióªìz6*îíAös4`^–™g#&Û%r‹w÷¥j6¥Î÷5U¢ÈÀ™¬J{¥¥k½çÓaci³IA©ô¹´éD7ÿ<©‰Ù¹µ¿ÚM²ÕÂ5T™²ÝYpõ¹7+'5 jÏùà!9&o³‰––Kl}BÁÛèG}ÃNø}…{à×=îËFXôU[,`Áø$ZuTÃ}Í _»”ÊÏSçù2³Ë0xÁ–]Ñ}È37BÉÎÁ&Rè–'†Ú4EPmØFãEÚÃfÞÊ¿ 6ýçØ¢;¤uíZ¦/ ­¬ P–�¡§õÚøéŸvÜL¡µÐÛ[´ägÑ­uÑ#tŠÍ>§ôÝå+p�유˜sØ�ÁîáÁ"ßÃŠç  Èïj¡‚°ËÍu†Khùý‘1tj¹Ø›GïãÄ 9x^—÷]?·Mot 1rÞѶȶ?*ÓçeT?£–¤à:eORZ¾ñ{çñú1|›m„%œr‹S¾g‘¥×ÚVM*µ$‰Û› NùZ{ !bÒ°ñôÙè]:ÿ_i¿Ób¨Çäuöì-ƒ¾lMyIk; Q C<“Â5ó ÖÅÀZ7¯NYËø&ÁeKÇY5l­¢\-åêa€ŸElÞPƒ]oÝ3j‘3£O'j¯óó«tØ:éw N=4å䲡µ1ÈGÓc9ZcÙðæå±N«¸ý‚ã½¥ÝM³çRÊšªF£µççƒeÿ:N?ÅRæž7¯#Ò×½®€)7çé/àÎ 3â”Åýã#EïíØYuÑxpM[˜óŽ†B‡øÑ€¯XDÌíô×"{3£óº t”µ²¼ r ¨Ä4:6òÃÖ‘q<·#ÑØRÊô VöŽ+U7z»sûA¾çÏ«*tHp.9¡Mš}²®—É]¡eÅdk ä9†ç…ƒ|ï±)IŒ ×)ÁflyJ*=NŠÊh:æéßs³v‘=hÖ9…\ã(9•!.6ýË—ú…3B<ö)EàÓÕS×�Z£ÞMew(ï'Æn~nÅ”îQ`K•AC"±ü÷?õÐLà2™êåß—(² (èªÝ³Û‰HŸJ¾Äƒßà •«ä —2H§Åóß°Êa6Ô2~Ì rWwŒÜâÈ×¢!åG"ËêÚm§ŽÕ$dšß<𬊜ô£Ñ RZúã Ý Ë¡¥ô¢k¯ÓþpÁ‡[ö×ée¹¶ÛCÿÍ^ñoi‰ì\deŠÒíúÖ^�}hUduOe†ŽÒ9 âË`eÅ'sˆÎ+7$Ž£/uûíÔ6óZö,@»?gTQ¨ì `Q¨*Ñ6d0Çd‰SC‚ P@z$Ó`IŠÍa‘†Òíñüäùºú#F‘ïÓ÷´R,¹Ñ;¸ÀBLí¥|ü9,¸vkDÓ6¤-Iµõ•N+ˆþxŽ•ÃL9Q=mM9B_Ää¸öʲsSÐÙ«–¾3!u— Óvkñ…ýÚ™ŽøPŠ(¬p;½cë8ö}<ÊË£¬y¤»WYµ×<Cû´Ðïæî äß1 Ãë{W+K¨ÂÃ\DØ;d#“ëÉõ¸¶´B{´Pô˜úBú5Ó´‘g\!}‡:£ ¢r€°ÃððÄFòÿrl.S_‘ßEžÑ…Ë(¹¦Gýª0mLA)ÛPá‚(>¶|\(£ß‚®ü¾!KäG¯×” c-žb[Cµçp±Wq²ÛfŸæ¬Ø>k(ƒŽ#tUÝ-‹òÒ ¡TQÔšW�lèeV–|%ð½Z@’ûvŒ€ˆAU:Ÿî+°¶n®O$ø¿Mݶ“c¸|°QèÞO¾SAfžç†Ê—íÞv&j Á(%¥ÃuÚŒKúöõõ_4ëÙ¹Z“ÜðuÓ i¬Ææ?üPÿÖêžîÓ-íÅz~›N„[ÃsG'ÿÐú®Qzí“—T}òEíi¾7Dˆó|Õ Í“Hqj>1Á_¢×À7Êx7áìÌDªÊ‚Ùx¢}5g}Éôâñx­­ðÆ‘·Ð ÓF¤ŠºÂVJ¹:שËØÎHÝ¿&²Úú-7èÄ>‚iPo»î\šþt³éKü`hW•¾˜9F@Ô ,p›9qã4Hya5rŸmFWQæÉÔÐülqáèX½YiħeðóØuh{!ƒU†0Æú4_å è¥QðAÛŒëªéÚ±=Üçt6Q‰$É’i-  {uˆ¾¦>oœçý·$Ù8Ný20A»‘•M:‹MD çHì/(R”E�)vD»Ë ¶'þ|8Z¯šÂZzøu„­4à)ÒÛëôýË”ßVŠ-±? ºÒ¦ñoFçØ*/©áòüV‰Åx¢n»2—Æ°ÓºÚJmÀ3Y±úï¯8/•›…yP[Ouã)V[béÐáeÜ.:@Ø;éÓ¶6€¦; –/&B u ©wzTt‹”‰åżÀWbð†^¥úw®ï.‡ù.¶¡H3O +Šy²´m-èxJSµVwÓÛçæ¸EîSéÛ,TñÄVl+e]úþèT)X§Š>ªâzfLDêê‘Êtår‡Í[o�©ÉÆòXçÇÐÿª c]]ù¶)½F(ÇÄܤ׿ w3NM·,·Ö=ž£¾ß§-Ëâ¾b±àr%µu_@ש¾8 ´µ3Ê[Ç [Éã®üÛ\ÿ¥e,p'¦'H5nùwéMCUèÆ_Ï?”»§+ÌAQ ®“´¦½¾á®t”ç®nQIá[ñƘÏ6wdeÀ©¾œù/ E#…;nö8¡QÂú•7"þ‰fbQi:£ûSFuçÉk¢suìzvÜ´`¿ÙC æ{>íÅJBž }fz³Ó»9¢qò·]wêmïTsq'\DÚ Wöi ÷V612•Õ}ÝÏ"]áÔ|d*"(Ôßœ1pÛc¯e„­"ž.'¬è›ØòÀ[»K³ Ûïÿl·~ÔÁ•»À…þ(;õm,Ó4£ Šú½sš—ª�†öjþýNPÀyî2çö(·óé¯5Îc͈^2óh‚Ó™u¸à¾~_ñÁÝØH!Iû]Â3—Hã{Öä9Ê?Kçµ½¾j€ù˜3£I³²€*γ±€ßxN¸—C žåž‡£úb,lW�dØ’ÑÚ:2ä ’üÕJ¹›öØ‹ e˜;½jAó ¨÷ž;´¤(mÖ ú¿´Vò5b9å8]½ªÊTZΠʈ?I„ÆŒû¹ íµTM°z*jâ]m ZQ)ƒ Â…;³¬«ƒ2ªß´»Ù¨ëEuU[z}SN”jæµµÚ­xêµw0‚¤`ýkL½qk`“{Š³F:ŒŽšÞ3.¬ûÝ®³,ÅYÕãJÍ´ 9[¾¾QÔQÛ9:.Ëàœ›ŸÔ~Í9§T9Pî=Ì.S4c{ Qùü?‘¯±²ýB£.éòµ Øv=<ÎXù ( ðÁæà¶=*XÞ¥Þ¥/­ zMU­<úÝÆúÛ5ÉB#óxA!ä%·ÖAM â¶WÂFÅ~PÌ_‘˜eó/¿p¡wΈŒØ¤âº"f+¸Mt©[Cÿ°Ótc>üÐò9J †Çp6 ä–ƒw|Ð#dí{m1Xèí¹±ï(Ȧ䛚Aú®$5”'ÝD @àt8Ò4zû1~l°¥ºÄJáá)eû"fa¥¸ù°½‡É3¶úçÅ°véÈ™Oµ­¾­XÒýh®à -ñ´×¿‹–ç£p/} ƒ…nÞ½.¸¡çXô[ óªä¦wÏ”u:P¦pÐI?E1V§öŽÓyÞÑú{66ŽV-rýûJ¸žÀI=lÓÏ#0=Ëf WRøl>èTóÎa G»Åià>;£ ×^âepLà 3ß –(× ^€{GWf+GtÈMÅÀ«Û»S1Ih#–gnL�=ˆoÜÓ.Åeæ÷.©Î¦[“~è7HMð1÷û0 ü(µõÛ惯N2xɃüÝšº#ŸºÍ­w u0geZÌg‡ÎÅË’>ëu¤5Ríµ:B[ó(·&h~é&²ÂÃrSr³§˜–:¸N«WúLÆÏr–üïòŒg¬2¹5>n†5!o¸gv‰iÔÊJ{hÖnéLj]5 H`¥¿ÇÌ*1>ʬų«e“µ!r îê^—!õ‚ǘy¦?Ð÷V—^ho;¯ÌŸžÊ3[™ó³•Ü“r…­ËŽ1&ë5�è ¤�,ÇÚ,2wõI'Š3‡cÕ�{Ÿ<8E–nZþ9Ä¥°F‘ÌÔ@;užHqKŒ7 ~QuÍ_bd¹é2LÙ”RBãñ§“±û˼—ߪØgþX Ï¿Îé‹,W)®˜§¹¯/VÑéÈ p@Zÿô@a¹|±(UR°±Á†ž.ÖÙ¥ÞnùãS y»ñ‚‰³Êe x& H2é»âM+Î/N²j8k,³8s&Ún‡ýÛ÷f§q<JÁ¨ÒJô6»¡F)°ˆF´MÑÅ–ÖÃhd¾0ÝôËBt¶o]d¦/À£ 4C–å+“Èv…˜”SŠ’Érr³ÞyÁÄEq²” šcÛ èâªþ¥þ;§ÊÜ‹¼ÀÀÌJªE€ìÙœëy/Û8¬¥GØ`—M<‘ųÏõŸñjUªÐ—⊊†Å8÷Çtóâþhcûs#Òóç¤dy—¤DZû3Ö›ªðB}رŠÞ­WW’­ô’ØÐ9ˆ}¸+tÛg_sf˜ „¸T[(ûºB±’ë¥)7#-—ìÕ19“‰r³n»ÀÌë5ønúzc ºñãBq™ÏçøkÒô(4Z Hâ÷½êx °u^EƒT(ß%®â²"Ì@.¤xÒœLWM ´Ûz:�©B·q`GÛŸë#Vɛ͘Q£ç&ÇL§ÌhØ#›ñdTé{‹qr—Ž|ž¸ü¡’¡fŒ§l½ï<ä®Qa9oÞt«ÊÈwÝ%)K_Oª+eöóÉ…“3p9�V ¤ó~ê.& ØKb¦­·r#M=°KɈ ªrãwe•‰)páß0Jo”‹Eóú¨Æ K¬¿»ÙP5ºÛ+‹s· «[Ú´bä¡—Hà]>@ZíWkÐu¡´“œÈZ=6ÎÕ£öužr…Is ¤\©˜s[Ä‘éÞfCÇQrÜóm‘ÈÓ2EŽ@)HAqØÚÀ…Ƴî O7þrUŒÚ Þò‹_)kë¡3ËK+"zÜo U@ËÅ?Z±@¹­UïÑsØ"â`Ãmús\ÛW¶Þ®nvÚ™¶qì”Ì+Ö¦¦².œu‹Öê©[œí/ àeÝ5b•l\’1gÀqø÷}^T?#}iHôÁÞ^Ò„áÞ…# #g°ë3 šõbN0°ìåHR™ KÌ/{%§b ½ÈÝð.ï¨Á¦¥ßÝŽ€ß¦?›ÌŠëJsFX,/‡‘Bóë¸g>ÏÝX’u®FÁ»?ç”°[7ŽDú¸GÝ$Pc”Ýž•7Ál³î×Íú»¿D*r½‚°¼ùJ x°<H1áó©ãåÝ8øLH´�x1M¡µ;L<¼~8¡Kvƒ6$ *ͺGI誴dÓšcšr;=¶ kÂâaê¡èù¤“`R¬tâ‚«iìÎ*ZÆTΩU’ Òg¸>3Ùà‡r«eæ£i?L{:®÷µwV çÅzãßÊÛ×>–N_P&¬‰’©}{nw°%¼s4å|è+q„"ó…Ü©vé)FtJ `#Žzºªã¼ýYlXëS?^XÓ´c‘Is›X©îÞ”0÷P…œhI·MV ç_@áŽí'­ñZÀ()üA…´t*;Ìæ8hã5Vx®º# jNà æÕçåš³…â߇Š’ãóÖ¤ù}÷#IÔ¾MV*¿[ÿ«I­î¥T÷²«¢°º\Øø” Pôiñ,Al‘9ÅOºG(BÊEg|?iPšš* ÒœÏjÍD’ò+׈gÐÂäÚÎ.ùiWR"ßÒ¸¬U©7CñEìN¯›ÃŒ˜°¿_¨Ú¡soøžSâ«œ" ÿ•`†§¸M¨"Vl¤ÄjêÞÓ›y ±Ç’±[Ò‹öâààÀí¼(_ å.ÍÌn“†[_æû¹õ4G ʹVÉ*àOt'³(“}ä(=_ºýÈv'`<€ujÄ-=. ÒýÔÙ3 ry¯‚ì|q„#g¸'Dže\0k5xi îÍrïɲÆ`Ûi·;Ïïx�[´ÑþÖíÌQÊÍBù¼ o,M?9œFiìƒ_!¾QŽ%åã¯uýÕùZ1¤ûÑ«1…¯çÁ0$¬‰à"÷8£Ï¡½ÓÉDéZ) f:4«“¥£Y¾Ù¼jxŽ0'÷ tÑÿQ_5Í’Ü™ÓÒëYO³þp¢E@þדR \òDµÌwÏn^¿*çzÈ-ºy¡•½ÚõÂö@<øä´_²ƒšùâÂ˱óÄûWAú:˜v”zAgœ]ŠñSMÚÔ;÷¹hîÛ„m¶º…T5ÝÉ ç@B}ÆËi¼\gó/J¶"-L®"öÃŽöc5ÍnàüvU2=èZÑö]Íß\á#Uµ4 }‘Þ6=høY«':Í%F³(¼Pö©~ž`HÏt%J Ÿs;ò•:úû´ ÂÉAi4ºNR}bw¾°]¿ÄQìûW‡Lg‡0Ü«‡‡½Lã‡óu¤¶[ýkD§ômØZ¤™èè¡[Ì[X¯YÕà‹ùw@EðáXYá <<ívžà4–>UF• ¿Ņ—™mcÕ'´ Þ•±‡bb^Γ“²þa³ÀÑÁMÛg›Yõä’Ún€"h‘Mgf>–”r¸0‘ºH¨&¡wkÏngCÛ§¹©E´êX 6æÖ>î%¦ýj[©5Kø ÓaÃ.Žtù3áû¤rM¦’ÙkÝj³†ÍZÇ–¡gj@È ¨ê¤­žƒßþÒàóM”Ø:€€6³ÛœÒêÃ0 98`z8íO}‡ÅiD&žÔšˆ•êb¼©Î¦¤1ïT`ßÓÐNÿ۶ɓSßÈs‹dôç jm8¨º]–ú"ŠÔö4GœöÏ/«”Ç ïÃëÞ?œÇnYfó̃ŒM¾Y¼ðœlº¹,Aýý/Âÿ ÒEK„yyPõ×I²-à쟶]Ö+ák¹KK¾}'Ê,ó½1«?wRÝ)|¿Êò›Ù£3kºU‚úµþðÄuŸÀfò�Ñ·e£ÏÍN gË#f7X§×›é³h÷w Š•?ì(³`!D HÑÊ4¬”§•9íöbRo±>EúzvhÏ˾ëú ƒòÌnÞ1ìmxNŸ"N3߉Vç¦f µž®¬F#0`ú¿ü ±g¹<@Qc ˜ñµw9âS]†qTwñ(XýyÃH�+Þ~ØX–ñĆÍ7’@V^&5v§m]Éàõm9iƒÔ·æ¡º‡nž•'2Â�íÖ"ˆ¶:|ªÁÒÒŽ~ìÇ‹cè Ç‚~ÿC-€¬ôïq,êgY²k§16Yë <zËH¬EÔ†ÕÝSo\ bˆù|pïKPîü\^Ù{Ï:Ó ñª]]à¾ÛÓ†(ËL²5ûÑ·áï6]yJ7iXÀ~g%ëõO¦›hIÜИ°ƒ‡Ú!Áš3,îÌßÖ½HµØ‹ Ü+ Æé‰ßÅq‘”VÃ> Ò®ÏSsð{/€»ýÖ´[!E5“¾š)°m=øµo·-=§ˆ]|’Eéõ©HÅ b.k Ö2ã SŸÂSp¯°ÿ¤£¾×ÕȳgnÍLî{êIæ“èO =†tùëYÇ�¦zèÛZY–¡òùâ^5—­¥ç"ˆÒ‘<èa�=ú´´Ùkm„‹6Û8¢×0vwu«Ô™Ôÿ4&À²êFÕízàoiãoܲ4Ø µœ®£³é!TÞüäcÖă²¢M¥Ó^a Õ:ÁªŸ`uÍn_oä5X篯Ñ3¬mR]I&Á…‹‹…þ= ÿn ¢R÷óo¼p›…7ÙÊ÷ü¼suW׫ºeR¸ø—êp?aMó,V=ká]’ ˜³2œî <«â'ŠþÕHßj¨ïd¯ ‰„fc‡†"frQí!öa@;†‡í„Mþ³&}îÝD6>:MyPZ0s§Yä“Ô¥„¥O„s¯ˆû|áh¢æ1›RÃkbF²aµž $5Û™x|[gœlÜ¿ôæ4Æ|(ã‡dÐÎ!˜J{Cv²ëëGÚàݠØ{R×Dö-s¢¦*¦çËÉÑ|©[Ηî;Ô[V®öJÆšáô×sÉUC¹ûûr–âhìRva6KU¢ÕMÑh®—Ùݧyùœº¾Ô«Û!lQ8_YžYS”¢ª¤×ÁìkÏÃŽ¾4ÎM[îëáî»ø&@ùV²v´w¯^€šÑž±Ò I÷í aRëÍY60ÛòדgS{rªžcý&8`1&ÑW|N7 —Šp¦Uµ³ÇÙ�¡0Ië/ -~“û—Ÿ JÂЇgÓZ¦2Èf¾¡<¾†«D)뺠݅u)î7q–ÝÈË]†,(v½g »ðÊY|#§ú–¶YbÜpÔb¯ïSZyWÝnàýòë2Õ—y{®-påý¡­¯Va¶™Æj¤HÝPŸ_¶Û¬ùÃHqõÂUk_Ìæ|OYo6ØŸfïõ‘ú0ìYG“Õ‡ ÉÝLùšñ*Â>iÿ^*Y¡ïÀ~®Å `OˆŠ£onšu?qpVv%ôMæ$ ’­b•Àž¤ÛŽêÊJ¼qLðÌO¶CQU|¢¸ésÜiʨ[«×ø£ás”$®Ìb-ånNÚ¿zÊü¬LÁÄì Z¬¾›f\Ö?,Ýa§F;sb2Ú1èHCrñÕ“£Mè„ùÖùÞ•y2ýõxÇÔ:‹²uCs�‰¯¬=u6|ÞË€ÇÊŠ¾0†'³NjÔ½#0Zd>Ú<¥“ek¿‘øEÚ–'œ Q?n‰°hç×?*É[ú?1b´M[ïî.”ñоô*Øo< y—°îÉœ–Adqp¥åÕèu•†úÀ½=Eá–™]j\¦SgZmZU;:ô[Í·SÀé#ÌÎwLš85ï³ÏW·»Ù‚ðP˜½ëÓË«):SqQ쨼Ô#áëúÄ)c„ló¾u8ôu{ô½LNI»J0 Ó°å^°l\tgD#Ô¦Ã*g!„º˜3­$ˆíÁ=„ùípòð]®*{¦ŸVié�cn?\'blT‰Cß tÏçwtOœàzl¼Œ‡Žòƨµ‰©šoô'gõì²®¦¸3;©ÃÐ@‰v=…Ðjš\¬“tŽOÃíGÁ¢ýC5 Kõ|ea¨Y¼'Ó™ÐÏtŠ¦ËÎkBòâ†*S:S’'Ïûk5‰då[Šdƒ-Ÿm«ža²Ý°«[ìX>Môuô»Ð¤ÙG«;§,k q¸ÚÑZ'nŸoKUx”ÃEHr¨{Ž½5;—6%Z\\Œ,í3ÚÁðº�OãÌoúÓm}[bXú)W•§×¬óÑ¥sd²Žgf®Eè¤SÚYME¹ygY"ˆ9‚/·æ‰-ÊË;ŸäE¢Ìœ#ÄÁL9Bú:Yú›àpƯ‘Ïj½ÔüGX±%SP`Ѩ\á"B·Š€g1ð<[zhE™Ò]1] ò¹!ùoŽ¥×ÞBuä„Ýèäí¬“7¾zß ý1Êègö—:RbŒZYå(*ŸÉ {Ò9¤CÖ‚ï«L(Š¯öîða„ÿH:UèWѬè¨êßÿ5cÅ46®#ð3׉‘… ܽŠD×Ê)ÒÑÙwU7~+˜¢<ËúÉäCÔ—ãù£=€`çvã2šú �‘§«î{ŽÁmT¯ zâ^Åp˜-p¸¯Å7W/îr¾¢ÌcšÓÆÛ.²­hñOëØr_±Ñäšžÿ^Lp ƒ PâÚM=¯Ê™û[Árè;ŠÉó‚L—eú¾Óq(³²2„!KU¿{9Fµ~.¿ÕuJ+w.I@|[Š üP#x:ÞuÙ|t:T€Š_(°|@oQŠl `•\¯¤ OEõC«½óYþU:fJÖûÞò8ÊW jJ Ú}”‹?Ók˜!|ê裊¦+Ø%€Ýkk¯ŠÀ¨ÍüÎ0%xH Þ˜&&ëëJŠËHÌ9=–ÖC§I+9!8. Ïö»,/>òÕºL#éç¢øYœy¶V&'Ê*ó“*ÅÑâýgr3xiZ¢³®ÊG¯x.\ŠjÆp¢U˜½jSõ5äV.Ýa’&Á ÇqàÏ'ëzýÞ5¿Ñâ E£rIIº’7a²pïé<ñÚ:ªúF0¨ê!¦Ø¼ûÜå •ñÆåü \žúÀØ bâ¥ÕFM-º Ö»I"þ‹”áWæ7 ý"#*×*§|w)·ø°„�îakä÷Àq÷¦ ã¨ÌÓ!ˆE(i<u¬e©ax]ö’K<'“¯¼#Å"ß…fkþ@ÊêxËãs!nC-èët7b¤–˜ŠpºR­ƒ ÛÖIÅmoÔB†5¢ 7õP3I²Õ\‚ïr½^V‹4™w‡”¿Ûóô—Õ€¥“ùÖáÓ~ùj…$r¬eth6©BBÕ\€8Õ6aù<4K ’ô1 òYoÎ=mH™®ìì�ŽÃŽ:t³/£w“¾äÕjxMo=¦AòÑZè)òŠ‹“x9¼nèbÓÇŽ.µ6¦)àþh§’bhÛw|ë]%ú5@ ICß~7 ömäöä,,3Út�Paþ¤jAìÑݥͰ;öòõÕ‰Ü,È õ²†Î¸™ãB}Ñ|˜I™ÝßÒ(ºCGyûaN¡˜ø0©6k|-ñ@3Ùê,rùÆ„ô,Èm祂¶©þlÏê{ èÝ "U×€Äq®Ëpʺ§;ñ¡yVv§=ö\w>÷pæì¬Û t$g'Å]QHâΑX³üó½ük¥<*t`–š’Fç]C ;ŸcC8¨)¸‘þŒn< aÀC2îöžúyôV' À§q¿ð;ö0óc[ž;}15ãŒ"s”€Á™ô¿¿PÁ/ãI܈ŸæpFIé|D¹hšvUf*N˜i°p¢Ê+¡ÛGom“ÓñM‰çö å¤3¶fï°ŽBeö®&ÓûήœyV©)[«4Lé|Úz–Ù¶fx™Dj÷Â2'ŒŠœ‚ASÍËõ÷ÚnA‡¹7ê.„ÍNùdwñ{›Žm4Ô`ºzÿh§Î7âÿÉhÐ'’6vˆåÎ]»ñÏ¡7±íCø ‰$Î|’D ô$ {µí!Òîî¶JìÀÕ†ŽðËô 5.wÑ “iÀ¶‚´WÀ‚¢óŸs€žX´4qëÍËÝYD†w*n ¡%úo²/˜b}]üü‘²2p㘙`´˜¸(o€µOIõÆ Pb2ÛÂõ‹Sa¹àË"ÕcÐs…ó¯›þŠòDr§Ïþp7ä¶ ¦ô±[+^)]œŸæÇúl½<_®õ$5ÀÍžîB F뤋8Z'A|Ò!gÆivÖ›$¬ŒÌË'ïô—¦ºå®êš×ÛrNT•Yò'ÉhÕªÓeÊfä`NIatÇÖùŽ¾€6þfAµ­Ø™˜hž« ˜­ žj?ŽìñµŒzX3®ÒdÕƸG ¶ó Q€¼4gàBmËn3ŽoÒ)ú³ôÊTdëѦ¥éZ1à¨qfM7¨ÐðÅjKέ«÷‹y³XD®)Ý‚[Lg,È‹·&˜ÛéæBôN+6žó…¹– µªúm‘tC_‚ÕÜ]%ŠlÕúƈÅÈ겂»ÐIü¶¶W_ãÓÈ f¸ã ¬Uôn ©¢°¹eæ)Bæ‘¢ší¥êo‚f¤{­7 S}ñö2ó1Ÿ2>À7?]p©æ‰µôÎLä;¡Q÷¡Ú b´GëGÞôÁÊV1_b„E‘Äœ£„yð¶d´>”å‡Þ ·ê üÞò´Û…-ÅxâÉÚ¶ÛˆUÌcddZÈ ÊóÔTî]=¬§sÀê"=­¨_4™Œìsϵõõ9ÐEWNœýëO#¼«w¢lÆñ̓º£éÞ *À^ãša‡»m ´Nv€NMª)IEŸº~ñi+ÏüEà`Ã¥ òaÒDú ½)±ˆód©oè·?ÒlI«Ð§F™ŠšˆV«³g©~íÌ÷‚ž–ºdNJmûšcûŠuŒ×£"rXŠ¥KnÎnn øYõ;o¡•ÇT³kaáÖbÁb}׹̩Æ2Йftõ÷ª¬Yîúy®a(ƒØ6Ü 'ÖŽVáÑ0šx(ª÷ïëïÊ—;Â)§È™Å” [k‚×tÍøWJ®­½w‰]xŸ2káEÂÍÓq†:ú $ÒVŠp“è¹)ýW]³XÛ[â D÷åò‡×7çEÐMÓ)þÃ3'®ho~ºiÞÚ44A°s8;Õ«Jmç#�~ˆ=ciü•28¾dòª<6ã£4À<eÚ2W#U;3~Õzª¯”Ä1ž…‹–;œø,r–" Êß쩦îœ'Eš¥žþœ?«¬Ïÿâ69ÐPÍ¢æcÊ*Ç9¾Á8iƒö82¡F_ºi¹k6nÅ"£(p¢ô¿8ÛR²žÃ– ©*úZ¿É=.XP@Ó…¬#`<ˆ­­Q Vå`½¯PŸ¥¾! eáínHUµ©SÎXÌûâ@b&ýŽ³TÆH?PœÍ¢•°�T2`/ØÞ‰ý6H>ñ2Ðv¢a õæ‡îc±"õu?ËÛÅEå»;Rd¼Ê —ñ¼qÏ+¨#áýØþ.ñúê‚Ï¿Ž)èuzö©üN€®ëÕ²ã7Ú Vœ#6€UÖ•LN;O P„·Ý±„%7ÍMs²’ñ”¸œFŠ›' ßÊ9³“F7_ûþ}ÞØÍXÅdîäÝ7¸¿°Í5'b¿íã•™?n YÞá_±%ÈUëù¤jnjyôùÔM@•tßÊ›f¡'çV°'+°Co­Õ®T °C¨ŸÞ/„"°™‘çPû#�Äí*äß_=t,ª^³ç(·`L©1CO²sEÂú'æ§ÛÎ-瘸央Ã܃ñb;&l&£Ã;W*T´R€¸adb˾IvÓ½5,ŸÇ™?–¬P™]Zº/6f ]1SÃf ÚšÞÉ P¬-K�F°’Ò.{úz/¸ƒÓ|_ª§hiÈ œ£EmÃ=š8È¢UÈm’ŸçiÑÿâ(õ¥Ú O+ È‹c1æ ÛÎ[Ìñbº•ÚS””à>74òùWÐn€ÎÀ¯TVÓûÛ±eoDqc‡úowGدðTdÙgnü€UMg-""&†xÞMÍn2öõAiK©•+Wx¸HïL¹ÑäϽèø=±Ní4uÛCËRø¼­ü÷\¿剞òáÎÙdÒZ.–.m.Ê{j‹A™ØÆïA²‘ã[IIÁjñkc€Çghº‹Ý ¼ƒQð”@’Ú¼;âÎü†*¥´µ*vQ 0: Åe3ƒrrøêd›W:(|#çp¥œÔÔ˜A‚_G=lI€%È8 .Â�J€;´ZŠR†�À‹yY¸ #ÅÕD)ôMp«N8& ~C¶ÕÑÚ÷_è½ÁbL_½uù¸@˜HÎpou´™2ííÈ+•Êÿ–Sån/1! )ª t„dgˆµŒB§õhB^|‚:[;&¥oŸ°C“¹õÂèö°ü…ñü¡¶ŠB[ƒ0¸}]íþ<[©|2Å9 JçšbÉ ^­v è©®¼õú†÷l…TjŒJ›Ú±ÃÐcY%ž~‘/eôø4pe43«kW!=Ó¦Ç#°0:Ó‰v Ü/X’±'‰/F€èM÷WϾ©²GGjepýmHÈŠÌ7µ`/pßZüM]«ÆH¼à´˜‘ü΢(Ô0kØä·`^ßÓ®©tÂ4c°V{8KF#ŸgàXŒ[´­Öõf ƒ\áþXsÔ•ÌP\A�Ÿ–Ín2Šä9§u=Cš+`$�–BšV×ÌêBã�u$Ó(6MH‰ÎЭ&MÙÙ°²®ôø…lÁܵßQ@“ÉWƒÊGïz�|'&&Ó  Òµ¦YÂÆ…m Šw<,V/Wº <Ù»¤ZUÌ“ðL wœYÃ;e!÷Bk:îàû•>ƒ+W¬_¬ë×õÙvíÔYI"ïrRqnÍYM_  N/ÌCO"ծϊ&Ztæém0AãR Æ ?«EéôÿE¿¹BÆZ±wh…lù:¡Zæé…àŽIT"ª4‹ÌÉ2ÁÇÚV£6)V¸-&ÌwýUþ?ö×wº†± Ü’±Püëà©ÿC(y6þ´âí–, M€cz8i‚‘17f2kÃe¿ìNC³4Øa†‹­Gc œZsö?m†Yº XpóLuwñýAYÁÉ‚œ~jð‹ìñJ©žÜ›wïöÛ{­²ù¼ˆ^¤ÿrLJÐM|ö'z“•Ä€”âíÂ&œ,sÃ{{–ç,’RÓŠköÈ’[ζýç03TÖõ#DæZÿ)N WѱwËñ-ͨšmÔ¸ÑÚöóÞ,¬ï;5‹\10 f:Àa9V:C&ùÜORëâÒà>¢Ää9ME?^EÂÚ¥WU2;0“Ú¢aÂb*nl'´ÛªFHšæ¦œI8B±RynF™§ ǽ= õÖùËZä8ýÏK¿üû’¥j§&œp5ìZî=|-™šxêø€äň®T¡l}ê2=¾ÙÈÎ185c€\®]­ÌäÚ§ÞJ*‹-Ò·’7tgÊLñGÖ$'1¢f±8ÐâØÖ‡‰³íŸx ÅÌç~p‚ºP­ŠiÞÍ£�û¯ñ5n ÊM8¼A§–]²QUAˆS¸KÕž)üu)w¹`J‰ÛsÿKù(6ݸÌI7äš1±píX[þ[is‡@L>ôÿc›µPäÉ¡DÐ ÜÝýÕóÔ"p ^²¿ìõĉ&ô1_Ðv›EFŽ6µ|.RXx‡YRb¼\p‡óU0ëåÿ8f`´ñ‚Sy a/>ç^Uá—´›¸‹Q¼¶ÎÂn__-UÇ4/žìa¤¡?/¦¤£í X­Zå}ŽGú+‰V}î§÷¯›·xƒ]Œ¨Ä€v·²:é‰f+Í™ª¿ ãø¾­hžö¥±HÌß„ytM’“#pžÃB5$Ÿ¡,à{žn.ö2@ù̓ɱ§}Éøý¯*×±Š tävJAøžuP†¾U8´¢sú˜Ó¤=%åQ2f]ºôšs=ÓNŠ<õ™GEÐ}Ðæ(»W¯'¶§2êàµÛÎèGâŸÁ°)>kDIì#0ñ¹GŠGåÖfB�S �™ñæàôVü¦ã3×ì¢æ°÷\ÿOwïžÓ¨™8š™ÚÏ!Õ©:µ > "¡`=œ-v� œ‰ÿ¼T…Y½THñ¾:µÝ¯ÁÊ‘'E,ÔôE^µS“0Xãà@Ðœc¿09ÇR­åßÖ<÷»¢aG‘3 Ú¿z´J!ækm‚ìÅ]…yÑš‹èõäcë5k.]Ó˜3ûÔ]Ôîøt’ºíþ.+Â5Š£��!òE›¸ ]•€á`gHÐ&…"ž(eIžû&'™§úÅbÓÌemv”á-~þ êPäá´RÔ"[§Lžëq= µOýgôg/÷®ÌäÂ~J¬cà0NÖ™,óÉÞ¬ê{‹EeúÚYü0QJÚÖ^÷Z‹u%§Ç®­_}Õe`‡8C�Òéö*+˜Æ²Yó±Ì(VÅ^ˆ¾ª[·ÒÝü¡·kZO¤eî0º2_ú;yt#Çbr’'d(3°s ôîõ‡S+þ€"ú¤RØ ¨_<i©üì¢â“o'¬Fìs}ïz:·xý8ñIYa!¼·½æø±PÈNõ¹ŸŸ>x|`ÔÏ`ÇûÙ1¸¨ hòp5eHÀæ¥> ¶¡Ëã³ÊP<2£°‚a[Q¯Æ/][;Ñìõxíö¨T˜plª ÝÓ}ØvŠ²‰ òJ²E™w7áÕ溱_ÊÆž5¢(—Xƒa­x×3óÃ9!ïpq5…šÖ<Ê[Fz¸tGkzƒêç>&ºœÏiGÆ7}»a—€LâYB‡ e\¦C,N€ò@ôÜ\𱬪ÕÃÊŒ-ï JL嬢ŸyR³ x+/¦®‚˜Û¶D㶖yx6+*Z5Ê"«z«7ªìœˆoFÿ˜‡žœOÅÙE£Ô³«_úÑ¿6÷K]S\φ‰ ÕÉÂ!30.Ó¹u}òÛÐyB}«¶œ;J˜zTvÆ%“š¶ÅåÊêÐ�¸¹‹ïs\Å’›ŽÉfÁûσÕÏf}y¤L/-˜¦ª +óÊÔ U—l(Ææ=ªºzç¬Jé* á†ICo¤°ÄJ{°Ã]œ“§º/pm9ü­ R$uê11ÄžößûV‚BÊ@Aè’*ˆöµCÃKì/'CÆSòˆ@É‘û"FÉýe÷½¶¨µ>ÄWaæ¦Éƒ¤Q@ Äzèã±”¿üµ5s÷+,Ÿ)¦‡:y¢èFÖŽÃÆöÌñékP˜rU5ª<³ {?y*7ˆŒùÐðý‚äêaþnBŸ¤«QÚ:ïÞ”ì„õ†8)Çð8”aò0YX¯äJòjÕé(Óu×QO�rŽ-‘©›—Kdδ©F>|¬`Å)ýŽjäZs(MËÖýY¶bvÓ vnbM[²Õ U`8jô\¸TÂPàá§Y¥s ñj:œèÓEû¿jõÁo|ÆìÃ|Ðg)Œ¼u«K9Çdšã›!°Ö<¡Mÿ=›.[–ÀB:¨'ýæqÊËÓâgIèÙ®1mœžAeM�RÃ%<�:nŒ‡§šM~Diöe«X³t˜ª yµ²a1`‘ýléT"íòµØÈ.þsk"Š< 7“ aJõºö‹j½J!õWÖÔQûpfJc›=ÕLÅõÕ•ÎRJ±OÖ ÚÀ·3ˆÄo3´¶s›ÆbïL»~Èù­»t€µ@ç”ÿ}¤ée©{Ñ„»ý¯DÎÆJð߬‹ í–ô”ï±Z’ˆ¤õ·ÚÖQê9a±³g?Ç‹REvd×Ôbjüõô„’SV–ž0BmÀY2þ2¦fõŽÑœô ~pú§£Ÿ¸Îݸ’Ñ=œhíå2Q3f÷,Í%9á³ï#“ßÈaÉ#‘”MŒ©Óµñ9­”?´wDGò‡”}[_—¦€ŸAàÊUŒŽÊ—_bSfx¬'#³®`›:U¡Ër ©à1Þ½îÚñX_ÎŒÑÕÞh~'I“YÜÛ Æ€ â÷–=››Ê}eÉ.Œ\ûú©X©Ò•{l´ÞùNºÑ€s¤ËcLèÐ×ü÷®›Hd&Ñë¡o m÷ÈŽY¹kkÞ½î¦Ý…6ƒ5 zäªê|]Bµ4§:¥˜õvG¦Eiœ²ºvwaE¶âBYº"}ÄBxÏ/ꛀd¿¿þiJWkpkŽûœw[›–F/p³M({· à~ak1õÔÁ(c!zí7õ¥¿Ï&öîzÄS|Œßòæê¹Ò½×]çñÔ -Ž£ÌW7 ƒ=Dí„É0ßsÍV),r|ïJZ¹~HË=ÃNF‚žŸ6êà1¬WŒÊ\´|š¢ï¼À' ÚJiPZüñ‡¯«ŠÜ¯eo %¸çs½ùéËAšY)ÙP8€Çüámƒ¼rb£ÎèåI¿—(]¡p!Sh¥•¾[¦ËÚI’Ï“”Tàôiëa´ÝïåÂoV³¤q;Xmh™\ÄF/ËÐ?6”Kpúó…{Gše+s<:Õ:Zg{Ÿ Öl{¬”žèSÉ÷àKnª›yé- ®Ê c…w9DmÚäÝ`€_P˜Øǵ©ßfÄJ},[GÙJ18¡™¶Á»fyp^äIekzl/é¼G¨ Jë#-@èÅnËŸDã~3îø~`¶u·m'm‰9Œߟè»[k_8ânÆËI×ÆoéJ@ú–v3(1±]„:=³w NÒ€­%;ùBº25,’f¦0\}èàffV=NWº«e\ò˜R½1pö_Ì-¯Ñ_KMNxZ±AÁåeÝ©÷S(ž……ÅŽG<úæyVÒYT+í×3r}Ùc« ì»!VQ¤2ž–*)Ç3 ƒ²ßiò tÞc¸PæÁ|¾øô¨¢*vJty³SÕ»¢2Œÿù……¬ï cŒ™ãÝ‘Låd0#6oÜŒÀ{üU?K Lºq¢Ç`ÒIIŸV·HÊÌGrQF0íª ´1ÃZ¾š¥éVhùòóâõ§_| æw< <˜n…ÓIUwúú2+ %TÑå—,s05L*}A™­íŠOSdWÇÔ ”7£õ2b<Ç'íÌÈçI²Û6ÓÝbÄ  b”O¶'رá ¢f9v…ÑcGYm³”Õ|§ííL8ðøÄ&¡Þ8Aç˦‡MßýÙ㻿„ø@¬I˜è’mþÄð·– ¹¶­Ì¡<w”JùÿÞêƒEk~==Ç?E´=Þ˜°óä±QªD›õH‡ÏÈA ö¾2zRÄØ^Ö‚ú ͬ²©Ž¸FnÀüÚ/ #Wç(œ EPÖ‹§Ü#éÞv—*n+FðCU'�•~c;Ð*ÛÎYBŒûzè=sÜ·‰w„In뉗Zp•?³4Wãíi¨”³…™ê s(çaú9€âW£Ì�¡šHŸËÎSâ¢wj,çƒû©GÑxyþøúàË?„ìßá”Râ:·® 2î¸"=ô⯶7—#þt°ŒÓ¶îÜ«/§"æ‰ ·#;åèÏÇ” |bÊ‘úÙ.1— ÏÁ·S?µ3ì³$¨æ‹s”Å …N‡j#´z»·Ç»-Šó8t<tZ¢ÀUÇÖ6ý[†ç×Njæ º¬ôëz “sŠ “%ңœ²S6ðƒ¤èô.?¡æ³ÊÕ›La{[bª¢zs|½²ê«&q-»¹À4rDÌqãî¾zþ—wÜ^'œ»0»3­åò¬ùF^±"Þñ€‹uXg= ¢eúâÉag~&@G«;×uvå¥Í!ú w¤hÃÒ(ôMbiQ —ŠNOŠ’8ša~£0œ$kAMú¤h­Ožb'ÝþÙ)R÷=“ì;OÊ[^¡lÒ<ôÌÄ"VZB{çÔOœ ¹Ê¯9LoF}È»¼GNb}£”ãRíˇ饧!HgÚZ։Ʃ|¯[  XÁòB¹£š&ÚyªK<f6ó¢þ .ÐT7õFÉé99ê(OÝøœG®sMW£Пg¡F´Çâ±ËËæ:Œ»à ºvwúšªAZ[.'yV´Ö¦3ƒݺ1 JýÆ—­¤è/FmˆR*Ü ´À%Ǥüc qäv%X£ô™“G?VþÓm5Þà¸Ñ–ß&U™ù»€¢ò"(¦WSØN#6† N‘}Ô{£ø(|GV,\DŸÂ2èó ­{Ëq ÒvÇéùZ;B=îâ †õ¤Zß9à¡+ÕAžY>'[ Íûq¹¯æi@yŸ” „¤ÊéÝCq“ÔLì™ëF÷]Eµ- rÖAF¶’™'A¾w Z 9­’Ž˜-pm;D™'‘q™cËò!ÃÕÌ©§?tÚšŒ„‘nêúÐÒü>õWãõ¨È쇿`\ŠoK¬ MØmç}Å3d–™2-þÞ`Ž^{g|TÙÚ }×A|R~ˆ$†ÒKKÕ®oô1iߨ(˜ýØ£ŠÜÈP¬ûæ” ›¸PŒó♵¶¬8Èf/I„^X¶Ž3²C—c IÑxRnH,Ã%¸¯ÊãÝb¤:³¶¨wiæôMkÜ9Y|Šiʘ»"qøq%‚þ¢èî}‡F´sG!K…PóÙšÈ ¯@âfðqþ2³8gõÂø™šßº‹Öý!'ŒÏ,=Óo®ÛëT}E{‹Wf„[}¨@gýÔãPÛÁÆ ÛFw†š¡üæ#«‹.Ad³xh“ñ¹|¹ÐÜþóBUžTL rÛ7ÚÆH::3È2aPþéo÷Ýr¯‚‰ Ó_d;,kØþokÛui`¸4Âc“¨†›#äwuk?c»)?ó8h`©òÚ{vØ·~H÷) _°"«4+ÖðÑ?E÷áÉÖè\#à³Ú×Ð\ãFfþi�rÿ^Eò ¥þü;’K^1ë4ðÙš5ržtr®äÁƒyK~ͱ­ÏýÑ—ðúÎrÓ¡€ØK�ž³{Ì¡»ÅRÚ ó ¸åhx S}a=÷›×›1Pê»ÿa¿G}÷V ŸZšžÅTH_ÈâÜcaEBq„FʵvU)7 ç}  /dQr wϘdSSeí'“;Q(­,#!B¹Ú‘e”'†v¾tȧºïv#O%>1²¡ç&ªÅæNee¬”ÙÓTë9þÚ<¿¸ðæ³L§[0YZÔѦë”ÇSz”*’~Sã7G¿œPlúô³"ªÛȳi² ìµ/ã-acïçÚ7r°ª{Wnü™Ý̳G½û½V*—*Ór8êÙõ ’C•úbô´æ·×2ȦÆÀhJãÙÔÛí^ÉÿmRàW>ýb{¥,î¶{®z¶ômZ]¨ $ú0Y?àìqwr–n;Õ›å+QÊÊCëð˜f†hØûzoÝ‘ÉjwjPQD2tÇðJǸ•ñJØü¡c¤Úï|¿Ú <† s…Á ª™¥0Ÿê'4´“•ü’Q82œ®ªàÏ�‰cór^:8H -ž»ÃÀíªGZ±E,N›/Ó#¢êÁ"l˜Zo k² H,p|pW—ëtûP“Ü! ¸GÙ×t/ö½•¾¯Gvû˜§Ç% ûù…ÍFo½@î]i óî?{&´¬bgÒèшžŠ5AÞlv* 0š“ ¯XÌäMÜÈ°n¨ô9©ÃËö­DnE xµò�÷Ž{hï‘tŠ‡ Kg°ýUôÍ[K�èGVýÚ.ÞÕg]7ãOa×U�÷®ê¢î.¸¿ÌÝò:{Š|‘oàš:Ïe>q†^?‹"Åþ'Üýl¹™E®§ÙMçö Ãê4“ mîSqK‘·ûå*B!0Õ[  v§;‡>31Ì‚·ªçÖCÌ]/ê†,› =Ø™G>»)¹©UfÆG:‰·g×êhσ'î&Ê·¯w;‰¹/¿&t6£d©\—æ>C7`ý•'Áyå„,x²ÞqdI”HÑ/üQŽ¨wl]UciÇÞ ùÖ‡X³p…Sbvc¢L{õ‘Uiû}!ŒP[,†Á¨^Ê/t´ÑÍ'º3ÖZ~ÞÔ–›üèús ùž±ßRºcõb­îд€Bú¢<–§ýÖî…Tü½ÌÒx¸-‹î‘ºi#þö•gp�û<àFg^ý”qRsIƒÂòìõkìœÇà>‰O‘~ËÄç8Ò¦ »ûÞ¹®åDïåé»þDóÐ*®¥ÊxC7®øpîs•ÎÝl`÷e´RÌë\ ûéž…‡±(@Ý3àJïÎb­8,GI�hýaë7â´òèg†ÛD™™¢ð£bcO¹ËÞʺ¬¬_ÀÛ¼V…ƒ_lB ïQuSúbl°[™éˆeçFGöÝ ¯Ù ŠeãÛl"]ýa{]ô/wÐ|£€(÷)Ó€an¡”zñlåë#åWÅEÒÞjÛíÃ×óÖ½(Af]ó4°:£ö.µ¢û¥4A¤úGzÊl+ J«)Ÿ•·Öïúl…ûå¬¤È ?H˜•Lã½’Ëc8*Ñy ™þÉNç±l“yo…Ú=¨zƒg™ Fçyu×3C©žðÛã\,óО° CiŸ,N41¤o–}v¹Šh–ZÇ}ã(çKŠ r ºá~ò\·60Hè`Ìð»öDœf~®$xWQ§ ò(1&S &}:÷G|løØz°ghCŸ·®º½¾³ëðë_…ÿ+ ×H+!¤0œ0„è´E¸p~ž6ë &)P°2.ö°Ô^n~R;v·ÏŠ®M—eó¦nGžâ6G ·ù¤íHرœša:®…­VúVÚŸÙ‡hòŽ)Ý”ú¯×è’i†¡úð¤øj*)‘‡ñç•qˆgј².ÀBGÍüîv×r°Nè2Aÿ‘ ú'St'R˜›ý>w¶h¿ ò‡}ýq´ß£cÀ7NPq¼:ÔdC¡¢X”ߎÞÈaRBâ¾þ 7TüdZ_ï(”žas­š¹Â÷ZcZÎTJÇz:3.³ž_{Z ühŸ?5ãÒ!&"a-ž nPŸ}Õ@dD4‰’žºíßÅ!µÆêï%æÖµÆ}îJ™T2ML�ù¸|r rYdf¡¢ò§2HÞÏ %ßt £<hi"dN3¡ÏRt+IÅJ4° Khõ’‘ȉ³µ²Á¢ÚîË_ýCÇ>î²Ñ¬ÃÆ&Í3ÿ/ÈŠhÈdGz§‹‡†òy˜˜’áæÒõ7-Î͸ý [_õ‹÷ÍØ !ÖB•0¦"†ÉÛE|ÒJPjÕÏÒß1»½Ñ2غ\ë„š»nT&hñ0a@ärÆ_é#ßûÝCø¨4°™²ÊÂzû% ½oÏàºòé®B�õð‡Úa6Tcþ+œ;šzµ¶h‚í‡âõ¯:²RÈx톃‹ñÜwj4;ŒPmÍßM-“\ ·PÜa+íÙ“£t‘1"y^¤H·›ÒØÑg‹ÏÄÅ…  O @*«3%Vâ‚'.ðZ¾ì§úánAᨊrt4q䆸Δmzøû®÷ØyGô¿2\‘ÙoS8¬/>!ešpí5=Ógñ“B³¡-Xm¯¦goÿPT`vØ,#äæ¥:Óš:œìë^À wi̱¡®>“à¾\„Œö cȾ´þ?[UÍ'±9í[ ¥»É³‡°v[¦wÌXc¦v‹ž“Þ¤{?9{ëôÂÕŒ D#m·FUæ [�ttŒwífv4øÜÈ*ÿ‰ivdë×Nú©fQ€– ÖÅoy€_jÛ‰¾2ÕjššËT˜’’¸VÃa$íy€W‘E·‚úýƒ‡¾Ç"F„p;ŒOŠŸ‰áÁ¸C·aÛïMS¯E"£“n�{öxÝ{ÏÖÒÀ«Ö/ŸÖcétÑe‚±ùƒ¶ê«€SÞŸo—Ò–<šD<SRwO§CuÖ‰kbj7™›V�@cØó§vÐ$$Øõ»…*%QìÐ0l�<wg*P›«o þyQ¹È(t\®é×9…±Ÿ°²Û©Oƒâ¤ç&öБ1wt&¨ ÎÀ!€ªŠÌÛE”ÓÍ*¯ï^&rŒòZZ겫¸hçEiç#¼¿–eóý©Øë¨O‚´¶žœqjº”dèîÍwDw!EF#Ý)£« ze~—¦©ÔÂB–ëÏ#u±–òÍ‚}K÷lò‹i5hÓdœNªKYìëYËã,¼m¿Ñ.Éz;âÓmú àý3é âˆ6û„êÔzR1‡ŒžV¨ír/ÿï…NVJó/õj­pYV¶3"f&›cEÛòQmuGíﻫéH#ì?lÛCå0&àT< qÁž [½”ßHfg™kÌ\Tói2 QœëÃFKÏÏSUŠ*3è¿ÌôùÓ­úc$–ÜÈð´Š:† ÔÃ�2†Dì[µ}‹R#%(tÐ:U®(g~pW¿y”ÉŸƒC”ÓoГÑFظêöš¾üûË×–*CÎ!!I÷p¹Gÿ«�&s’±¬„’ñ¬`t‹8—<dX:Êç|ÂÓ ½—€¿ø§æöH…¬ÐE¢:oöp¦iwî9¥ÜÔ;²¹òR³Z.[4ì.¾ýÌ H¡ñX¦n®¾WGaêÊ–×â,$bµóHøäNyÁ,ÉÁð ŸóÂN¬ö_iÐWóœ³æ²äcò„q‘Á^)ö3’ÎZ̉¤#œná :Yº|/ÄŒMÝl(x0dú©åWe•]ì°uÙÆAy¶[‘Hmp™g‚ÀSV•ÙÚk“vã´Ç¬ôïänó2;Hø…çÙ3–³ýÌžVåd?™ÎҧЭPÊÆR JÄ+¾–íÉ7oÅ80Z*3öŒqpSïõ¨A–ƒJkù:Ò’Ìþ*â‰å膿Ւì°×Í?Hüt#år¢ðÔ.ž³fËq§çl”æiñѺxF'KV“‹X$vX;ôÉçIñ½•ë0ƒD§#"l»S$-Ñ ì£ÂC4³™—·¡ˆ‡Ýô\q¦¸ œ®JƱŒuN!CÅ/ÔÇZqªJƒ(r¿tJˆ·Ä†#ÎÎãÁØ7oÏýÝ<Ð’åà@p£{«Ã¬Ÿž¥'¹¯eΔ õÌЛÇ£Œ<òT4ËHCàÆ!þ?-~Ðý¡T}ìO[Ÿ º?Ù%·m­_¤0 Lè�`&F‹€MoMÞ¶Ök|,ÅTÝœ\‰æ‹Ÿ‘XUÁo¯½£1ûŒÍ”±¸ÚeÝÉWá{ë‰KcÍ‚§*\J4-"32¸pJ~º+-Ÿ²Pî‘{ú˜OªÈÉk'~@8ò4²´ê¿ç©{iÎöXýç%«Œ…Gh —PÃsÎ×Z7 Þ.€[°Dßu‰¡Ã,ÀPWmûìÑl1öŒ9—m÷%`‘Q`t1´ùò�ŠÅÕÑN…N2ÎÍ?›Ä[NAa" DÍ’×Îa»¦n‡é®tMž5+=´ ·bMÝÕnÑ°øðK¨Ê|Ó"Úe°ªÚOVäÂúl<,‡û“žBž ¿;­¶<(ÛÙëêˆ4¤N¯~FU¯RKIG £{<ë9Ï":Ú•í½púPs1JR×1Jí£w}[&s "Ì,ãïêLnKÍYÖvYäB…"ÖQ€x±¦;YRu¿e³gjåÄùŠFì´ÞCo×Õ™‰9̺¡vü!X¸Ï=wŒh¸áŒïV£ë†‘'˜7¯µ™_³ÕUkü¼ì]Z‘~»“_ºYBio¦=­•áÝ„ì“SG‡îd©I¡ú_C¥Ù[Dâñ4MUdž‘V!ò*ñV½"Sœ»ÎÆÊßè«ø˜žàîÏ9Û™+‚z‡7õxýOÖ8…Ú(üpì!1÷ ôwŸ2ñ•fÌž}ꌶøW"ãÑÿŠd%™^MJGñÒ{ÃÛæ wú·sûÊ“Å¥Yw\+kçM ðOÔE˜9?)¹Ç¥;»˜•2/ Øy(úHpXŸÙsD}•åÜÚ×W~ÀZM¾ð²k߉BÜ€3²°^gd1ìÃÑ"áôÙÓ3c'‹Q]s*%.(´õÉ“cå£QIv¢šg~Y~AÒL,Hõ…“W®å¨q,Ñs²é?=µª%UÄ.×tÆèSè8@àÙ+©B*,¶.Ž8}YÆzÔA­Äc† Yèªyž@Éqr¨ž«£á h•ULW¬/4;O%>Ú–>iõ˜? ½“¤@(z?2$gM<-’ÐЉÙzcU"v6Ò³~~ëvìSn/”uÏ_.VÇ1loþÀâ¯Õq‘Õ<îlFK b­D,'¡÷$C×óé0í+È“ ¶Æ™M`6z©É#]+ajÒ‰$XÞcÏF„slâ t'FˆÓkã^<LÕpcÓg8{+éöY"MìÛ{CkjÈñÇÎx@„©§om:ûtßL5ŒùÏÄñ×9Ï[iþ°4þHÇ·4ò(| VZQŸkê†=˜‘ߢN#¿¿ž@ØYûB±#è4]ãlú I––ÃiY¦›jm¶-¶h[mž9ïõþÅ@Ã8Ž#’qF#ŒË“*Ñ Mžâýs4Ë4ôP2‚5jѨÄx’â Ëð0ÿÜ>;²¥Rf<§'ztåyç4ièÜì?YÇ�€Ë'L3,ç:ÇGíÇEVVƒT”Žã j.&_jºåµcȧNÇR€ò…d²'ß¡n T Í©[™¡$t¼WŒ¯Ê`ÚÑ=ˬ8ñµ»¼ Šzh}Ä=†}ˆ~¨þH…3Kï5õ,ÙË›œ\€t+ VœèÀ/5á·%aõPÍ›èî]''î,×QD³½KÁéÜ‘ßôøé,(Ü´”&;Ïÿ ‡†0ºùmõå)9«Üƒ°°Ö2ÁôXÎÅaCµÔƒ'1nÌÍ+ß¹ùó±{´�v¿0=«Åg&µ¬I£†ÁOw­¢ª´™ƒŒOfÀ.’ºöuU$8«¶ûsø‹þü}»¡Äóà”VéþÝvé³¾Öóñ`ûßÏ—£<ñI!E—Jì÷‹çëÉuŸ´gÂc§‡á—¬ ³áš [0ŽBðN{Ó1oê‹*IîÐz°øãïâxVÄ~Úó\Ù©÷&ã‚Vä›Ë½sm†­~ø¾s¶r³*X ÜâèÔxV²”Ðöœ%®2?šO5·mÌÍGE‡ô–Ü]”«ÖfFá€N#ô8$ãja8›þ¢ç‹V¸ÿ¤Tó;ÀÅû`FÛl_7Jj÷ST­¶¬ÏžÛ_Û[¤É¨™õW„\Üw£frT¬u.À­ò÷.7…C¸÷Ðj¥`üѨaZŽâ_þ¥•žæ®Y³4ÆpVÍ¡îÁo<ÜD”;ª†’ü¤Ó>¨Q€„ǘy÷Gž–þ5 ·¥ ¥Ü„º4µ™Þ7@MFz&o=1…rzæ%µ1¼¿þÚAŽ¢yÍ !›ü «Ìå‰ä%ÿ·ƒÇr¶Äc›D<ôð¥»s!ûÓÍØ¿[ÍXPÖûf™§âÖ©ù¦c™iSÅTÁíÜðæÆ4Jp°kÊM¯T[ úD‡™þ³R¯›þLÉïžÞ Míë€ ŠË{¿òí«*S‹Ÿ¦”wx¤é…é&¾Øl~Ë\ûÎï4Þá×VÎÎ'LÌ®´¹¥¾f €ÖdÓW)ýO¾´žC òq*›¡­Ñò¼ý²~©µñ“óð8f ‰—(Îç[ ³d£´©ï‹((kšl¦+mKJ)~RCݶ—ë v%tî]]Û‡Y’&åc}þ…uºV’H¦0Õ«…,+>‡|øžÜT¢ŧÊ0\˘-xp¯J/˜MŒ U„š×½é¥Þ±ÃK,+5rVËTAÒœF6†‚¬:5Ëd(úü§…Ï”€€n¼qp‚cŽmØTWJ\ö_P¹€5™¨¤O?¼8Ž¨ï¾‘ÃGàNæwÀÅMøúo  ±|Œýöiî!Àx°±;WAÙ¶&›¦ûØ`8¦´BÃû‡¿(fA¨†%ÛÖ“ˆ±˜_{ ÇÌ'½‚-Õ”A±ï= �ÊÁ«™xwÛåvj^ñ Èc'tþm'"–ŽmŽE9ŠûúÊ’UfÄñéGÀ×:IIìǤ-;€ãæu9ì&s|ˆåÊ€{WŸ„å#_ý ¥…Ë“'J÷É~x§ˆð¸K…ŒDé,–Po*}¤Ó\l79ƒ ,UŠS3ÂÃryí­—’ܱ7S¹·““G8L\ Ë iÏ”„Þà8fï@Èqõ«e$@ðä˜ÌÊØ6a�Z–†:�Q…yV–», +2!q8ÑŸÌW à”΢̾fpEUÊ©žqg˜ozûŠã)Î|›¥*Ød, `MUÞºþvY;É5͈¥»8}þ”¤eæÓNBÆ` «—»§oÆ}G¬‹öPÙ.]«>)èçÒcžÍvzhpgÚQÏÌ"ºÔ0 Ýëy¹<DoI¡ß(¹µ&Ñ"öËmÏõO¯£Óv‰J‚¢WÆOŒ¥Ãe‹5šûI.…U–F.ËI¡ÕLÉdõØ8VÓG¯a•Z^󽨶ÜÏŠ§…Z�HcnbfJbDgÚ"æO·?Ë¡±j£ß6Õuî ¹1%sA·ÿ]¹Ñ¨fÞÏø¨æOî;Ì ÍÄé:˜‹;æ<qæ #ö8/(éo<|±ä;lb+>ˆÿ†-Sýί¾`±g•_G`ÈÓ¢:]Ål•¤™[ª’õ þ 3FÕǨ¹¥´[h¡µ6ÝÁ5±£c¨õE·löÒÝ=Žô9 :Ýé¤ÑŸ'*C—'AùúîÕâŒôÑó9¦)íNwt¿>OÓ­¼OÌE�œ)v�+ÚªY³ö»EKÜ´—žh5ùénˆµµßÑ1Õ.§áqœ*ÓáĜߓ`fŽ(*o6"v)[È+tZDîÆ“I¹)‰ýY“Ø/øÑQ¶¢þÂ(, ²ýÎ3mús×0ðJt!~ij÷ºK¡8jÐÂ쥹ª£ùÔqŸÀÌ®`jÔÒ‘ó"…#-ÖóÐ~ï®!Þ’±ÜÁfÁ¨Òòh9«`ô…8wî‹ñ‚ïéGù"Š@館ëwÆúÆ÷ ƒÊÝ×±.RYqq“ƒŽU›2þ(±Yø�¾pËÁì™ï»ƒE’ùó9HóP ’ö' €¾ÅbÍfO2Ø·Î^È[­Z PVõÁ Kö³ Lu¿Úç[zxðɘÂÈ´~®…‘®º¤ B«ZÎRß}Gkl:(mõâoz{9Ÿ-á-ÿy”ûNÊ1ÿ•"Hìø¼8·ãê=ù¾Uì›SÅ¢2�£ yÙf&³dÄWðª.±HᔽÚÔ®¾nåñx-ûŒi{”‰ÎÑ/lƒ¬¾¼HN€Ü2¤AÒ½ jÌ3ÍÖ8²%œ9D´m*Aî¡¥ªÏ ‰°öN}ÌÆò±Õm¡‹2ý‚wbÚqÏ’M{UUª©8» ÖÃIURƒqßI±¸ö7ßËÍfE¸š¤AÝS¼²~}9;IR@qrÆ8NÝ€ÁR‘ “OO’­Š†Œté»~•œ­¨ÎýmCãQ âdûT"`˜7í´€òLº£&Þ«ýpnp€òYƒ €ÙöOÈ¢ÍÞá"œo°€(6­98σÝF6dlíïüFãÑÿŠ(Ì•Í„ßÝ9†í×äyeïGÉ×®}_=<+]¶³¶pVq{õ$}žÆ¤È*é¸U58{‹¹jÆ~vˆNTò@àìÝ6~°npçyôÍ°+”"²=´”_}ëæa5Þ3Ã2è¨^J:§˜kÌ£ÂA2žh;1WÑ’ü»é¯ô…ºnÑfÌšíAý°b*Ê(ŸÚï`®©Âuæ5жõ‡}ýª,ó»],…Å’ï–Žšx&Ž¦aéòÏ!ƒrOýŒ…MÞú²î àPŸîáý#£òô<X©¥³ Ý«ÎTƒ†ýhKÊqØ ð*A±{é1Ds+…Ù[óÍÒ)cwj"ïa¡¸Wõ((¡­BÇ�°3"�$jL@œý‚{–M%Jœ—?Ð!ÝíL¹†:s3[ö×øD%+ž•AW…%Õ[ú1·7ud’„ýf}ÿdãÖOÆR£ÆHöz2©)N±QG¦ <ŽÖãåI“ÖÒw¾ 1T§¼`Ð/”ðá[¡ïá»/ÎßÚê¸M1éXÙlƒEÈ.£Ý¸ï7ñõ„•TƒÙ͉ }UÀ 'L£Ö·¯ŸÉ·žñ`Ê°›8ìËÖu†/˜…ÒÙ"w•/nÄí«ˆ ×BàûsämëµÍ.—ê† …¿ÿ‹Œ£ÂaKCœ`c_Õ¼³®çÌÑžYÌPúȨç9‡ü·gœ¤ܽûIáÏheöÐÙ ­DÙ9S¢ ýrF}iÙ•4›·ï~µ9¥¿Fi¦{I€ê6 yF·æ×`¶DUYùŸ(”jFèÚ…BŸÒ�Âh#pÂéSM]«Ì8±¡%/? –± åÞ\˜°±S¶Áà …Äèeê–QŒ$~£¿xÕ,žSœ9ð°œoàEîGŠ·N¼ÿ“Œ¿•š+Mͱ‹ ´ó_` æÓ¤í¥Ù4à˜áE ¸g¶PvÅŃÒÞ2]$³\QÕwÞPs6óe±°REߊÅVÑBzdgØä©UÏ8T ìS°X~ëòTx:¿,- ¯òr:{Û÷tØlêö�û]Ã5ü¾q×´<÷×(d!ºÿ…ëc2ÿû< ¨+tñüáú([QµK(ÌÃø×õjžÒH5Рé /´Þúp&v«hn+0 ÕI'K5è´v{`JãDÉhFÎDuúaèµoå~|.%‹*WÁ ¿ÔVc5oBoÒŽÜû2bÏåd6ŸIx)ÁöJéö«5Âf×;Ö¶1ñƒíßXÅSª­{¿ú,\PedU0윬D-tÉ-¡M‡s¡Òy~ö¥âÄoB¶'¥$`²6#`Q]OÁB˳ñMÛùnñe†J!è%DÝõßÇÞ «Pzà“HŒæ{v¡ÔAëÍŸbŒe^Gúé{4òÞÂÏ [Ò¡§­Ò_BI‘ùþtUpØÑú ?t5€üÆE²"V7Qè0vö‚ª¸}•¶,TFî“Àò•H€�¥•uo«ÃšÕ§“•œ:úZœ¸û—< ºQ¡µóíÿyGÛÒJ4¿²™-]‘òÙû*Ñd]åšr&Êîe,(\j©ÀM{Qˆ’J* ;Gþ] ˜†N¹Ž `™ÃYÇ$yÂ1Z‘Gÿ˸œyULýÝŸ1ƒkT?b/”ñTNïµéÌDÜ^𣠵ŽE@©›[tÿƒ/þΪ…ô€¢GÖu²Gâ‡f6ýz^ÚÒž$h! [ò<êìÁ$¸p°b¿˜^¥Q—óde/bǬúc#ÏWÍ ÏÑm°6+Ý4J §³—p±íMw˜@lœ)þÕ=ò#„€HŒÙÒ«*æ€)¦ž 6­ÜѺ¥rÛY‰t']¸ÿaoöwOê­é: Œl?¬éZ©ð•; ”ýí'Üxì×t;ÀìÿzÚýk'Ùìå†Ô÷ÈСòj˜Šýáû—õ“CcóZ®Æ ˆ^ "U<³®É— ¸Vñ+2Öò—œµLe'T¸Ùý8Õ>ð³¤î"vb@Ãö[Rܘ ³/[¿z–Ñ°¯÷0¿Åʃ‚¥ Áí›wc ÜŽ³ ãT(Ñm zÔVý!Ü>ŽV4ÞuÀö§Ž¾ÉKñ2ŸºÍsW—“$þ3²­é@Õ™òÈŸQOwƒ¬ÐX)5T¼‡;4˜:õ+&’áV.™œKæ±?p5ù)[(Wä1?™˜}¿Lâ Ù%i¹”aDÔ_ÈRû ÞŒ7®±œ|ÁÂ>êÕÈäÍ4Æíö°al½¡l…v m¸5Õ(s¼âˆÅ/O#\Bk7[ýƉ܂÷Ä3oZféÑ{—ØÉÑM“Z!eÿª¸ï”Õû®³í£8­‡¢!NÑ71Œæ!$ÕÃAñ å—ÃH9%(§Ù7›ÜŸŠDeA1ït Óײñ3¨yTyÒ€ÿßú± ´ýßü¡š¤S)7!Ñz¦ÐŸ~qÇ— öçæ¬Ò÷9jØ­7òY®m 8ÏuÚÖj¸ SÁz ãèAØ©r¦MæŠ(²Íî€IÌ/$Á¡ .厨Qº®Ü02²ß+­=ðÒ7l:É:v«¹9ŠLÚÔÝtëê_ÂUÉå� ‚Ú^SOÕ¹ÊäUz¥ lAlâÉÑ×W8û=Q<À°Yz ì•p‚ Ê©§#~ 1‘-º™Fv€ri(7sÊiuçæ`ˆtW@v¿lµ G¬·7­âÜJðreæF÷{×gt»—«.&J[º¶ó2=Ɖ.’Ï{—Ÿe“¨t*;EœFÚÅѹ×æ;}õ4™eyöõNYlºÒÑezAvsó‹je覴Yáës­=AmF%)ÃC¨ŽŸ/¾³'M<SÖù³ÊîïM;&F§ñ9ÃJeÉ´(à´1äÀQWDànbr‹$õ$‚i’ŠŠ€·Ç¾r—LÖ¢ ´–:§„À¶gC€­0*c “lÊ–EÖ,ƒeîت!6<Æe†(ØðדYœÏÃ`«–]­S:òÊdL»é òø'æíÞ‰â@JÞ^qW;›ÕNÞÿûŽ”WV+'�ŒÄ+UÑgîú™EqÔ[÷³œ,¼ÕõAe?ÏÞùÜÕKÀ¿ª(þÖ`ª ½‚ai]Gè-© <À6€ßÐ#T. :5š¦ˆ¾:n…¦h«£nÛ»ftd}4%©u·ÿtñ &ÉVÁ¤@ŠOßb;¸nT^]×[ûmÖÉ?ljI VR‚QQº†™Ø»sáÑ»™Å?]Ùy7Rð;rg¯>À£l¥‚¬¨§w<ëôo8³2Œ±z+®&Uwò(5ˆyy¬ÊžÆ+U.Z §Ž ?v¶…BŽÈᵌ,œèÿ¼cÒ)¾ÑLué°a`w)à“µ\ì˽¢»rJ•Ks¥ªEÙÀæwЄ)…iÚ¾LÖ<ô_t¶­ß‚ð¢bŠ”ËLêTI ztL”*M Ó2‹¨Á—?ù¬JÑZŒ�4 ÒéÝÓ2k3£Óòj7ê‹êö—J é üNiÚ½¦vgå ìÛ FuöîÕس©©yùb(¦Dz™éËôv¼C÷­õ2pJ,YíøÓëM½ã1gјÍØ,Õø×D™/uÿ©èÖ¦Hì£Ê µÎWµøEqß±>êÐ Rjr¸¹«ÏÀÛʃÈ!i¥ç”†A²ïàˆú’qc(õM˜˜®L"~h·j%Ã2† †A“gAi]ÙòŒgìGÏKZ}»ºÝa^ÿ€¿ÎƒÁO̵âv†yAÎíN^_Zv’íwÒì³ÍŠ(6ëü:æ!!OúÀf¾ ÖP°íöÅx™óMWOÿj<øè|V:ÚC¾:ÙVg.€#C*Dãx ¸ËЩ۟¿°sK‹!•Ú©£2ÓÂøU7¨±‡ÚÞù¶ëNâØþÂmÂ5œO²¡G ·$«¬’8]ŒºªV÷¸"`R‘ØFX靖ñ‘¤ ßÇê£Qû^<X\Hû"ˢ†3„] :˜s‡½úVª *K‡¥•uŠ 5Î]˜…h¿<ªTè_€{«Ê ÷1V‘­<õV[)þ/‘-Ҳ̓0DéÏYMVdßPÕè|±IäÞHÛ˜mÖžaÑô*I¿’ŸÑÈH«ÌWŽRRé:Yá„1îÒ†IJÞÄžží3ó$¾áÞÌeaßzšt8AèŸhT”D+`;åñ3ÚͯÎþeéê¾1�ëçËÛÃ3Iy‚ùÅ}Îpk·ij*N|¶ÙÕ‰gœÚËÝÕcœ h¥p¡ü—*Qªu{E²&™_zª�•ˆjRЉež–£Kw¡§ÂÑ;6¶êe‹*zÞã„�ß6ÝD[©B9<¾Xµ nL õ½Â†ëDF2‰r9µU‹¬¡ªÐ6ã¨â™°Í’ï·ÔM ;›ÛsÛ¼YEBÒTmO8GNK(àßhi­+J%öç„NÑ/·ØX]§Ëö_0<¥'«Å„ðv çíê0¥ÁÆ3Àeå”Ò_æ|p^]ÿF¶Ñ"¤Ã© ¢öìá­Œ;¯3ØÂxQ?¶ñ±Â€‰!ý=j³whÆN·2m_éµ1ÏÌa&cѨ¢‡¾ú\ö0ô:fw}>³/_QÓ ]¨ ­ “%ì¹=°>ñ'Å23ùˆPùÀïÄ Î§!Yî•/ ·³&:Wë«C¨îÎ]òY|g½W;Džž »δ\¶ïv ž�µF÷¬Ö¹ÂSÁ,ôtö+QÃI©ÞyÝ99NÓX9RŠf<4d¼(Êpà;¥Êùô ¨kä+ÌFBߟ]ÒïÝÛŸ¦Ã{¸Œ%1)í_®z—o~t·%ËĽÙ8]LîG¡£³|ÎE¥Í*¦Ý˜Úfó?çögž TÉÃ7¹VVR�rMe9”V•lßvWÊù3¡²x¥¾Ñ©\ÕY¿H¤üX#²´·N^FvÉ´”–} ‚½#¹aÓD™¬?[A‹DòW …p7ã&Íîb†—@jØÂ:iPZá_ ˜¦Ãqଂ‰“"X‚ ›ü®¾N…~?œàòžÅ°·˜ñÃÔ³¥ã+ )û¢>ìì~+‹–ùýƒ\èÒ ï/ ö·‰úf¿eÄD¡6¯å”MèÑÓj¯šÞ³ûD”¨ÿZóÑöÞC”A^xZ±‡‹þë™T‰�<„îš:¼úÁÚuü ÙªŽ×¶ËaÀM×ãS$²è®ÄØJ7UWU\ÄÑt#O ƒ¶®ìÚ(wñ©…–8,’`Þ›&²èá˜;¦&OZ %Ð$½wõrÁœ¹­1Hxð[p»Ô­”7#(÷)ƒhg5á"6›¯Ã}f!UȽÓ+ð Qjxç6‰˜éqg—Ö@ÓQLqW¸lÆÜ%x;ôƒ‰»]F_õ²-É°2lú0•¾µnͦÉJNêeJ™jL8•Yk?þ•†éÏ™v˜ù’eN eÖ^c¶©è‰Ññ¯­Yktï : =׉‚þcÛ¿žjO÷~ƾÂû “¢=°µè%Ô7{rf—žp(Ô¦#=Ÿw]Å-k¡¢æ z<ŒGÒ>bG*»j¤¨7Ae?¹³Ñã~C°WÉIG̹5Í<X‡€!\! Ö“f§YùM¶GY<ÿ½3ïJC_xCŠwÊB’묀ŽP˜l‡ö…{¿’¬v&œ è…­Øþ­ $ÊÀ±ÅRaÚ³ðLÎ^g{¾°SG7ÕgSo™œ¦îÌb±¹’üèÔyd“×ì ºõžr´Áˆ-¬¢p媥›@{©ò¢»äÅV!%Ê&*Ï£ùÔ2ÕŒ‚ûiü¿¬"ë~§¿¹Å�E¾G ÝAÕíMAÌÔøfÖ£ˆu’pQûÎÕgŸ$±¬Ì)CÆýÑú…™OŽÑ+YÚs œ‡|Èyi‚M~Ú{#.˜®Ú²QÀñÉý»®eÓçîeê+ÂJÊ#ú“úÄM š]¦�¢Íß1àõG¤ø2óé Ðù§ÿµöîÛë05à)-ÿ"w”xijˆB1¥ê=_ŸºUb¡Í+ª�Í+Í{-L‘¥?ÒwË«mÇõàæ- ñƒŽ�ÛŠ˜³câ´gÀh~ƒñV¯ë ªÞxî7|ÏIPü¼vgz¡é! Œ72tœ,9Oæráuj#(L˜«ò Ü©"Ⱥ%(¨¸Ç$¦ œ )•»t��›aøi¿òµJRçV&>bÝ�7€W¿·Ö×SçÒ_ß{râ°ãs?ŒÁë-6÷<D+–ØÃœ4ìÿšþ`¥…5™Î¥@ûÓ߬œN©wS•PÞ=Ûƒ"¿½hAX—ÌÏ�¾"¿ŠÔ´ƒ#uušÑåÜŠl«¯X¹ó?/:ìÏÍ‘Æ|89ív&1±•ošéFž)"ÞéwÇ�aš¾g)”ºm)θýÜYlº«üˆn]%Æ]«0wmJ¢ÚmoŠ+X#P€E‹UÝŸéK¦…zU™n×Lë=m·Þy¥*¨‚ú$¾û9^O0M/ݱóY3ið:Þ:±„RÄ’J[|¯fáT1­*ÑÚ Î$Œ½JŽöÁpÃcÜ}`f¹*E©,bòÅòº˜i±ÇzèþÀy<rGYÂ1\dÑ~ž,!µfùž†iýßä1u½:C߆’ÖÊØçAe][(Yf¾àÒ±J­¾ü”nWùÕ? 8�õ¤@0\Ûº“Ýì@—¿®SãÈ3" ‘b›4¨¦ÞöYæÒ7îÂt¦¾ðØ­V^1ü¤ØTuuâ‹ ´ØwLNr·Ã'"Tg7¬D†ÂßÜ çK�Rà˜k•#b˜ytïœÅ'»„Öä¹7iTs›ž]̹@²Éä7jðm Ç<¬~0s/±p¾Éùm£44ˆÒvHªèUø] –g–Õ ‚y¢w̦۟« ¶T½T‡nÅÿ;C5)2Ÿ¶ƒ¾Üyýê FÓÞ•óTØà_¸û&Iµ2H(ØÒ§|WÌÄüvð?¶°áM›,kªÃ7®>iÞøÌ65m¹Yß½¨Mwõô Ðù­ ÆÝ»ë6Bù}”}fÌmÆäÚÎ-#æMu¾ì^ò`*~Áþp-g®ø„1©³ „ÖlÝR ]\áû%Ô7ÉÖ!b÷[EUÀÅu±7ø,›Ä‰ÂÇq´çká¸Ärú8 s³©éì|½˜ÀXpª)DDîÎPÚŒñF/1Räøø¼ÒÓpáêb×A2·:Τ‹uPx}ý;‡~˜óvw¬½³ÌßI±ñªÏêÖÊ FœƒÁãÕYŽþ ËË=7„õ ;Jëâ«R™lµ-¾´<+–=¡¿EEúB[ºî‘©¼Ù×OBdq¡°‘ÌXªÌ€Þ9@u*³íì31‹,$üxÆ(ëúPzèÝynómF6XZ<eŒ8ê«+Y°Ç8ÁúÄŒ½ÑGÈr9 ;õX'eM/óf?Ž½Ëwò€Ã° 4él_dü÷»€íéYËXZé^-§±(B¨â?/¥Ž"Í1§Ñóë ËLzlð‘™~ÎgK—˜`’¡e&EÅ"ŧ¬Æ'çÃǶt¹ä‡SÕ.¥¼Æ#ëMÓ¡ÿÄJ— ¶ýG½„ȃ2cαÔùàñ`ü)Yº ]}•.BÅäÆ~}–xŵ½¿Ës¿»SM2A´ôäKv_¥„4+¡«¹»*/k1èYääÁ°BÅj?ìø.bZbnk{ß]~2©3½É sÁ0Èœ¹9OÖ:€”ƒ¼ÍcBv™d>³¼…̬¼®$|‰ŒRÐ2O…Ì€_ƒ†Þ{cBt8zpv„´¶wgÊ5ãô!ùmm¤Ìïaó!‘š~{ìtTÔD;§Z<¡ž{�o\éѹi¯¤‘(#˜U¯vx·¯Ÿ–z¢ê·e‚랯TtD'ÀHð3s¶cï¥e:O£îC_~Ù=^1ÍJ€Câ¯&·YwÅfóí™Ù<æå3=¿íÌGÚ˜–ûNŸá0sW¦óIËÈ»L7 >&¨+áÆêø›yùB/cOݽž=”¾ëÁ鹪°ÚÍë§^ žáÙnöidûÉ+�EßÚ2GääÄß©A馩¾QE¶Ü ñøà®md–Ç!…3=ÓÜ9ƒP%dMësq÷®*–5eŒîáÑpV9äBÀä»Ù( žf§Þ§½’4Ë‹ÒùªTŠ ܉ŠÉ5xe!ªÓéH)–Iš¿Š iUy ¨ NP½ÖžŠ$ÀX|cj¤ºaW?ÜÓuŽò›$h8a Ù[ÝÎ gƶcB¼wã´ëØw€ò趣¥¡]7Ôç—Ý…Û–«Ÿ|®ehÌ+æšžC2hR†íØiªÅóvZ›Ø€iï;‹ö^ÿìì9Ma¬ âpÂ;52úŒªŸVFµ# öøŒ¯\Ydº$B•¢}þÞ;Ÿq<æ-nMК*ª öê7ŒiÏ×CŸ(¸lË êÿZ¥ŒÄŒPÕר…aÙÐméA-þåîáqšøÎ)˜ LU6ƒ“Qj”Th:ž”7àŒÑEûx ö)¾øÆh@ùHU¯Â2Ï(£ÕJ®&1cà³Ïr'Y‹UMúÅؾ¥±I`«¤¤Q Xi\K-Ìû)›$ë`ýÍ@[yÚ{R¨†nvê¡¡û ¤‹¬ o¨�Žå’q«h“*µ8L…f.èìÅçCçÖwÈÒsY¯Ì:̺@­ºZÄÀ32s†h±³Œ Œ†’NqÑÀ°°a·¦•LÿÐd(ö-;rÁzSÞW·^Kæí�²¸£Π|ŒèΦ%¤Dîtôª)Í@Ÿ´·)|åËH%œyÆ©>ŽõÑ"Ê×7>ñ!l@°>ú»ו)è(M³¸Š§@GÉŒ"V ëF•ªvŵV:«ÉƒÉí^¸]7‰LŽÙ ÂÕ/?·=ÝÒ± i¡¦Ùõ^0àÅ­Ëž'üægœy¼¶%Ë[}‹¶¥6º¯ÿn)}@§�DMäx&¦SQb ^ÖLô¸ÌÌ@¿4BÈá§Î "cë6J‚b~Ò5ðc§%+‘ÃMæa-U¶në¼…¤²òô?õÔ=©zV‚–ô“/l^®œ=3Z”Ê,o³\½1<CY9œÖŽB¸^ýp§)Y³‚Ü”̇4ƒ(Ëd(Ìÿlˆ$ôYæPðÞ&tRŸþ:†Ü®›Úöð²`ß©£wèZ î]àØq(ýŒ FïSY‚ùdU’¿/Š=2‘ºmñnVÅ9iÇôŒoýãÔG¥A«-p¯ž³'¤:q ­XÅòBÙ-äÉf œ0‚®Ã™šîŲ¥3¼î=fΞbÝÌ4‘ÒŒA¬x–Nt0.²G}¹7´v´àÞ?V´¤š¹öÖEñn9þ´Û€Jç ÷0 iƒÇAùzuŒ0`Æ££n#ò×—BkM ;ªÊŒ™àeK1;|ß9M†š1×"»ÛÔPDÄôÖc´ý¹Iy¹B†# =ÍÎòœ3Ó.äA—Ñ-ø¡Ï¤wÀ—+{:³¦±²¸È—)«'¶EÑàtéû=eèÁîrà6¥¯n.ËQ‹Í7j((%\’¾°¢ÅÛZÆîw.,ÿijÕK‘ø;ªòV3ÇÇ3Õ“*ùíéÌDîÎ>ú/œ.bß#¢DQ8í }uÚ{Y¤ë[©°»`•g€+ë‰?=ÞIæ@6ƒ¯š+’æLoÜ$š© €X?d·7'¦ùEx¡L+M  1›M“Sá`-®Ê€åõšzx3CŒïz£€õº4µßö¼êÀ<бÿql96æh˜è1 Ã5~;–ŒÂœOÌmfèÆ©:}áÀ’&Qù¥&qî4ƒÅ°Š…¤Jçp ç€ú0X“peÊÿHL* 3r…ÏÕäŠúü?øÏVòô=†Žr‰´®mB³ÌÇ<[éÀþŠÁ˜ûW=V> ²q“§(´Ä:E²²fÝ…Y[vû¤V€,cÊX“+é ®Ø88èM=à›c®qÿÒÄ—ŠÿŸmbÁ®¤*ëtQàL;”%8Ub]©‡Y;ÙŸ;¥£K1iîp›`çµ°¼ˆÂïª œÛWÇÄ©bç’É–x£'ïÊbË\áe D¾N©ÜÏ«Ë/5³£<²ÞOâ±ÒÌtT³<`ÌŸ08šfטŒ¼¥}ª’œÝÎÛîÿ–n™'ƺ'綱Š-¤ù¬84ÍVU³³q²$\ö9Ò'a¹â2¡ê¤?qí¼}M‡ý4pÛΖŠØ×ÿ˜RBI|æ3™Áä¦X’¾zN½Üsº¾@/®†Ð/¹?C Å:õ§Íöyü§Šÿ»ŒÑUëµ1ˆ¦Ú±;Bë¼WÀß:,þìi¥ÀLË—øÔAr9¹¯ÆCÏRõZ l¬Ò·Ú TçÞ¶Ç;B¦k²˜Ãž½—s;NZ³žØ@Â�w´µl/õÈc'PŽiVì'Ú¬ƒOdâ´‰ÈÚüýâBæÚûáo¤…)~ç+%1‹5°®jd‰D)=Yæ=Ä·èr4¹„w‰%P­üÈ3,ÈÏ+è!K@vÿñ?a¨£„86ŸœQÜÉ{ç96ŸØLP-0¾Æq3L>I3›ŽƒK†ÁxÔ¶ŠN¸Ü¡ªŒ+;YA ½Êùþ`&þi¬ˆ{ÌØlKú3Ë«AàT¿Ôçá…ÉË´”¸V¢\%åà¹YŸ\ ŠôëþÕ~éqZ—‹¿¦‰3¶Çà]N½ù¤,uúÈr[#৽,ó_Cƒ”6'¬Öƒ¦!ëF ÷/.ùÂF1)úÒR2Pœ4o‹°ä7ûÃ,òR3_…o_oºqµ²=§`¤”³¹j>Qü“åöªqè'ÿЬXÉ´'t°¦AÖž\?èDÒÓº‚a@ñåѪ³¡}Ñó›wU"›%¥Â–dƒ½Ñð#=C”�ºWÄÿ»¿­tD4ùO±@µl•;¬áþeË̾aG¥×f„¼åí­VŸÌ(4&¹�ªéjöM™!õe^…L°i!ñrDžf>w,ÎYÀ(ž´Q‚S'w”Òqš=äåÆ Ïæ<i£ó¡—– m8)èÕÎ)ÅÄ÷³\Buïåv?Ð2NR¯4å… 1ãªSoA‘Õ¼nûëO5í"Í#žôLŸ t«‘1Ù!òm§ÈÚr×ƺ‰²¤É××"ß ›p·*qâæd}ÃÀL÷¬çÄ(T¹È»Vlb‹žß-F1¯n@ÇÍž>y|úð<ã1,ûC•ît@äpl˜‹l/Ä$è–…9¶4‘õ°ƒ¨møNðyD°ñ;@jœÇŽ#AApi‹ täQ²EÝx4B#;ÎƨÞ1NÜ=(XŠzŠÙvÂz‚ÿ‚N3†;ÌiÎÝø)©¸?zö8x3í?h¿N‰ñâÔRbžE+k#ºß—-HIv*Öv™7o5_±û\.SÖÎ榙•NÙC¡uК™&ÚâaUS¦ \�¼j½V‚Lòâ þR½°¿œEb;-wØQê ?ä"›JçÛ¬1}¤RÉgÅD(õ§ÍÕ742§¥ì代•Ï öµ0^Æ 6a·õ¬:úäÙ³%ÆÿLÄÆ&|anîZÝ3ÉBµ9ŠR˜6o³êŠÐZ2˜ö‚n+(Ðî?ÜäYè¯Û0 Žot$Ö¿8Nn02©·j<46¦É_ý3Cë¨Ló÷ †žá¾µÝI,³Í›–äLðáî7 âÇ®õµl+oÈȲÓž–lóázîR+{¤jîOÝAÑ$‚�fW{'WRÚÔO"ô\T…*pÞÀ˜€n1#$ffœ}áNïj„ÄàGè‰ñ»•O‘°ø£òÍ—ÿ§6«Ë‡Þ�u�•­3zß]2PÇ@&µè|G[eŸ/¾lž©£ HûQÅ`µon›gûŽO×Í}×À¼Âò/G½ÄõŠ 6 Âäuñ€dbp§P²flEáÉ ‡žÏ'ãvpµïgÏ x¦¯Â+æ¡`ÞÞBÌ(Îû®%"zÔ ü©ˆÜËObÑt¨‚Ìjà$¬6ÏÖöD¡šAYwÀ¾ó »1©t+/Ú}Êaµ÷Š&ÐX½; +¢ft7ܸ飀™t7:;¨Ôn”¹i‚½ý¿à]•e˜¦f͇e Zp«+ö4ÒÖbú›q‡‹½‰~ ™.ZA[s—³aS¿\X(ãöç7!5¹È*¦l-Lß}R¡Í"Ö£¢¦¿àšÙN“³ð¥>Ló>HTÅqæe¹©H{›ÙEàÈC’àúózÔÂ"íÒßçÜn#6‹ëêóq{XÿˆÙg\ô,#ˆ2;¬3 Æ7ê �èI…Dát¨û•sÎ4gAŒ|V|CßG=Æí?¹÷Î�x’Ü™ÆH(±Ÿ.V>¶y¾ª#ó û •d!¡>QPr"‹jƒ¹zQ~TܺÚÌ}çz™¢ÓB±M³xbÞ}ñi!ë…pB*ƒÄMkØæF† ÿúÈ Dúü‹í•ÂçÚ )ö<^2&ÂhØ»|sI³8~dM´¶¨0|Ƀrw5-b†EœÅOWg?a‚´ç)øgHª.mÎÑس‹ê6:ñiÄÚ˜¹,þõãb òÅh&÷ï3v¼’§°¥¤qØk0»¿õŽ’(d`yÓîejö}Ç{ÌÔ­?$­ohªí¤1?š ÿ£~sÏjª–ž€(§ÿó1 ÒÉ2+´Î;lâÉY[N<x6/æÏjÉgšC1Kyçû³—ÅN{:TM¹õ€·C9ËûQ€¹Ù›%õÔ7–Æù¶ž´'|ÿÒsC VA_â–ÙúT¸¹&Â/­‘2?¥‰QaeAØ6Þ$j}öX@g7JÏ/�…ƒªÊÈhž!l¢2y\6:ÎrDfžŸèãÓ/¾|ä¡ß´Æ‚™—vÌ‚¼ƒaá¢8c�ÿ‘}Y%¾Â-å:›1 ª¹ö,�¦k'ª±¼”¶ÈÁxvˆ ¨…ì½myJÙjìÈ e"ÓâuJ!3d´» I©ae½åé0KV|ˆ²Sª¿×v@Q7{ë3í|•0ÇÁ®6¥³jHçtõ`½ýTÙˆ%š<½#ÿx‡C—$>òˆN—žêëú¯oÛÌ:<–øµ»¹[ºu‹¦,ckZ“UJ§5¡Áo>ˆby˜ùÝ(J¶³ =kºëA&»°ž¾d_YÐm6}7¿XLý­µÏ—?qì5ø¼šŽT¥ì-݀헡³Ú‰"Uô„dQèæÌŠ‡lTÞÕnþfìn_q¨þN0j¥FÀ F§‘½`><E<áJ"ó83hD_ý»¼Æfz¡·zU™}c¨ÖÔz¦L›eešøTYLÛ{ßCW:ÞC'Ÿ™Ø#Ðr ›ùpÙ¤¢7¢´k/”€©Äß1ã¢pe@W›-<Øk/ ê»Í ›Ylú7BJyâµ4¹’­–½pN´Ã&KRý‰EAîé¼VL3@ýžL'ç?A“Vù…Äœ‘: æŒÎ]ú§l,«9aêÿÁJ)QdØœOúÒt<PþÜ[ùS†u|£"í,ªç9¯Jsø@ɦÕT†xð—bËEjÛrÃËë;øv½ûY>´–9 5w‰Š‘æús½³Ä–[¹YDÇ® lfç©öYEW݇iñQXf½ƒnöñ |‰aç·4ö­z_ÞÅ¿„ýwtE]ì3B>JÊ•¾Ëã‡AºUØ-è–ΟÅìéÝ‹iÿ80ØòTUÜ8Ô;wE¢í¾¢ú­u'Tø ß8=6¯÷ Š<× ãÄ÷ð|¿ó0r8i6*p¢Ø=¾ôªæ85m·ÂøÕ°IpUï<î][Á©jp" ñ_Ä!t~”š®Æp©‚ìïÞt5::kë¾µ4ƒœKhwl/pË5~¤¥’§ nCÿ²×Nëi£µÛZŸ'ôwʧÒD;¸º6V¶Ã!k;2VÞ­žÝqw§-ðØP·X›.ÄA{¥ã´™=ZÞµ±4ÄräyZ q®Aõ·û*ÎüîCEË ªÔ¢Î Ûõc_È»Ÿ&QœMãʾ»Ä¡’™VQ¾ö¢§¬í‰Övž`TDŠ/Má(¥Ó,Å ¿ñõ´û•Ns�)é8*à†¶­_6l|†[rïW<•ôíF šO‰pÚo½l{D‚îŒ;žpµ³ËPSÓfOgZµWᲸldÖ-{ØhA?q Ê*z­VšKž’El"›\3“ÙÜ3âëS·­@Q²©?Í„üQ}íÚGÒ Ï(;šƒ”ì†Éh8qXJEgÚš—G®€eº2u ƒ¹æv2¡Ä·h+–6Ô'Èeð!xãô„”öîÁ7 úù’å»ßš[è cõ¦gs©›¢H»å4Ñg?íL»%Ë°ã`j4sC ;ˆ®ÞÈãb}]m³Ò“ödëi*ƒ¸UÞ64‘lfÀ,8+ž»-«nø•Žc&†E‹§˜Â_ÅÉ ˆ>&'̬7û“ñ—Ý¡ðNÀoÙAUÄSð’úKK¶æm¼0aöú ··PéÈc§=À-= bï+ty~|ví¦ƒ™~!÷2ÇæMkµrTs¦_í[ZØC§zREOîúŒ9§ùjðìI>ò'>Mt¿‡I%×J!ÌÂ*S›P¬¯«Õ‘+§xà]¢Kž¬§˜1+ 3®m&&ü¸¬É_Õ  ¹Ñ f€è8ó·¶eEåöPÌ“ÈõÕf/«ìRMÀGãú‹<Ü™–Ðñû ýâéj× íÏ|£?ý‹è^d¾.C(¹Â ’@182”îããaëü(-Hâ*ó4/)´nŽ´oªÅ’ÕQ£°þ…XwÊ̱gÒ«º2«9³búª5£%8< ªV&ô?~YÆÓlg˜’söGÈ©ÕŸuú“=# q/¼Æ«0ÑMŸüd™NìS0 £YÕèÏî¯ÓËrm·‡þg?b#™Ÿ•g’Bg§Iu`�'ÁDzá™7ÛŸeÑYæ‹ÑÁV½/©¬Sôf‹eïà0(kŒÃ—~=©ža_zá�íë0Tp-í–¿'�¥‘WÕ±:ˆÓÖ7£aõAS*tÃüâÙNVT> 5mÔðõÃæ´€Æ}74žd“4ºf+ 3"´ñTÊ^}Ö0#¯Éé3FŽÑ»Ò‰g´â)™¤PéÑüÚ×ËÆàµo­Çå ‘OÚÂ@ZÔ,ó“N$J˜Çu”óБ.L„,¿³ÌSW²ê'ë:dƒ Gp·Ž‡ÁÊMý?ÒvˆcÏ|AÔL¯`åXž_æ#À•‹Ý2Çí d¸c˜ ¢ zôtf«•*tžRRWA­eaæËÒ Ø ¥ˆ6N>]­0E!5þè75å¹ ãŽý’lÖ)“R•¦?w/¦²2'ßžãýE¶^’3 ¢¢Q´÷Dñ)¯üèÅ?–`Áç;Ë)IWs£Œr€7dCÝÄÐÀdÿY¤1ªVãEŒ¿:ZO¤ñHQµsd¨è&­öÝïýÄf=n6Ï‘k×Óó¨wn‡@’Šêñ‘àö¶Ãì î_~v!çȘé¤�†‚SöÚZ¤Î(¦šë3xž,öšÚ÷÷IPXFNV°‰&R–%A““„ŽB””Ë÷Ç®…ë·` —¬L]jHÚŽp,u²9€Ï$÷á }Â$ÏÖú# ¤]ë†é¢ ¼üû²êüžê ’‡¹¸^û—^ºý/*Vwc–!g¿@7/F:ãÁFŸ—Ž,ú:7 fT_Å~ö[7íCuØ…¼4f1ÌŒÂSýª"˨žmZ ]ÅAiRƒ°i%ˆ¿pŽªÂU¥ †¡ ¢öê⤗¨óRî¶jíþõ÷ôÑ|dj&º8I~hµ`º¹þ¹™—0·¿UEùFKÄšŠâ%„ã„¡¢ìc’¥?ä³Ä ágF¶€‘õÃàÑõöçÝhÑ㣑›|zî䥅[“3=ULÏ•ø6Ffv¤.±‹ú‹?i˜år ÕZ9bùôz>Š\Üu[¦^²• K hg½4^ünòïƒÙ]±oÓ {Õˆ—娊a`?ªr«[1‘fF_°U`&<þÒ¦jjs±³7“äÿC¹síº[/—¦©‚¼U5 ä<õvëy³ï¢¨MÑúgôÐö·à£ÄA\E‘r¸P Þ÷¦[µtÇSßÙT”ñ|© 2 RÏv^}ý©Íï8LýTž Ä–ádïïŽjã“ܧúbØ©»‘Ž‘_e‹Ž»!(‹Ó qf–1§‹ÝÒ‹¹<îÝ÷äâÂAðñ¦HbÃxù4Û1sc[¼ß' kÖ~n$7¨ÜeþCdÄô)k°YÐ [TVÖâ]®»BQÙÁŠ`R/5å¢Í_5,`Óp:W«ïWbVò1ÌÌ™>H{ÍË#°ÎYODzD"Ƙ±ç3×êéãY¹³ÑvW+Ñ/ú/n´™§`fÄ¤à€ž¿¶Fq¢Šn ößšžGÿ‹m#7ôæ=ú Kkõ+ÑÙ§ý{TýJÌÜ/é`aÁÕoÀ1š¤› †4šj²úì©päó& ÿ-ƒ¶;:4ðÓº]±­ ÐNªç®ñè�$u”¿=ÃgöDÂÙvx3Ò~mÕr†‡EÂúú ½`ß^ Öïc•¼Km,eô™]¯›>ùpÁØÕÎ9R˜$ÏðìJ}Jf/ WÐo ÿÞàßÔXts(é<Ì›.µFžµÆü$qðÔÕoëynâ$)¤³ÛP‚’ï5ã‚$'¥ä2Hq=}ƒ+¬²žlâYŽHÜÐß,8þ®³ Óas°ö_rgã8ñ×= ªP¸Ìöï¾ãj7]ÜHþǾ}•spJz_Ó<k°O š.Wš¶ÕÚ©¹½ríšÂŽ£Ñ`uü´Ó´<Ãí*âºFBEÅñÿ›B~á±)x ~ŒA!«½äš[A`‡ü˜¹zw&Ï <î­]nd9©u+z›aäÌ3ybô¿<vu)÷$š…½uª ÄE‰ß’¶Ècûfb4ýg#z7íÌŒ]ï¿ë•“°ŽØ4X#±o¸w¹`xj{P8bènvÒ¡L*w}Ûèiü|Ùµº5àÜìsz£w"Wàé¾3ÒV¥ß{‚¿‘ÎýŒž´õ�:½zN‚ŒK±ÂòXÏ�ÆÕíùSNP¨Æ/sý°?U—ÖcÔ0ÞÄhüŠõÞ0.fn  ŸÁ Q¹R®Í)aYl4uT»åœ±Ä/=.}S‚=ÁÍ>¥” Þ;(z;ej�W·øîöA}¬@<מž€Ñ¶·:ü?ÆûGÞÑR;d "k)¾©Ó¦ÍÂûçz!2fn›Ãÿ•i’¤€õjJz?j§¹·¯§?ݬ¼²cÏMuUÀZ6áC¹@Uí±',NJÅš˜¡£9D·«C{h=ç€4c~o4›EŽÛ2 ®ŽiwòØZªÝh€ŠßZ9ZùVTè<YžéðN_íóÆ0sœOÝƺÀ‰Çs…³%3ˆ)U"ûSN'¡½<ÀN““Ä4½êc7}§±J‰µìáXnF õÓ$H&‹ºGGÇ ÷›”Ô€m¬e°i,!-…VQ¡)K 2žìu“0´h1+Žoì ;Ý«¾h€å™Ï6¢#c¹ÐN.guwƒ|õµ‘}Iaù{t3ŠFŸ§Õš)Ó9Z0…)6–»h‘BéEjåøèרå(Î<ñ*ª.54ÿz2/—îjÎÙm|§ž-«|Z1{Äßh¥$ïÊJÈŒŽ[D+ýön š^?Y1È 0YöoÔ¢}^±Õ˜9Iü?ég¤áéüÐQ‘v“ƒÎÒmfiS5­÷‹¾þƒxíÉ=}-´{ª ÇAOÀ´δ›;>}í™)À1·p¿W«š—Îâ2HjM q¿Òyå ¹u/çæS©x¯Hi°ÔU¶ªÙÂ9ä�'œý›Š³‹+“—·aÄ„„ M¢ïr€ÒÌOÔ`ÐzÉéäÔH ûÒz§'ÐÓ¥žNÚf6¦Fü ¸b{þ ô:óГ�-§Áénk í(IѬDŽw¥}ø­î4Ú(¥÷Ôé|¸LUP¾ï|Æ3û¿ì»A§„í4îô¸«ÇÂötû)­¬+x8{sH‘a0 ,€M‰+ä·t7„Ì´üþ QÅúÝå3ð�î^|!k; ûU—,Z^€/™)r9âVÌþ)§“¹S5‹§àÐqþ5’ekœïu\Ç’âãÞÕðfl¥B§¾¹¢nµÿ~®ŠbÕl‚„&ì@¬¸.ËAÖÇÓài­3™=…y„AvÁœgøp‚Îó ¦.Z:6Ò¤7/·âtÝYÐEJ‚¨µú_±qMdÎfŽ± X¾øÁ*º¾­2Bh0ÏccFzÛMÇÑ|Xiñs¸ü…6_JUBæËëé«%jŒÚÖ’D5kù(^Û¿ Ý‡ÿ|˜Å]ú96P¤ìPç-ÊœêÃbh)Ïaƒô™=‚$FñÞÐN“‰†,œ; ðÛ\Ö:¿ªÖÅæH™þn2“ZLgFV€bŒ�µ3§o‹ž3<³xbÊ$ªwŒïŒSoq@Ъá)Š† ¤8™ßÐZïÕ|ŽNR&òº1ÛO¤j²Ê�2ÓÞ昿Úþ (ǾvΛ)2ŽtήÐ×;Yjž¬ä«bÊî ä{Òúß “¿ÇV„oíëcç…ÔÓbg^ì°C,¶–Ü JEdjx‡ñ d¼=€éj[ÍŒ@ìxãc ’¿7h ÷ÅŠÄôD‹'iÏ^£f/^ϵ¥¿Ï²ö‚‚WE Ò_~Q(%5ÃÊË¡YíNô”:; 5þ |¹ò0b&Sæ¹ÙR‹÷úç�÷¤·?¾�&= ­«¯¿ƒþ—dl¨x$eãyMe:˜ÑB[·\¿`AäùjnWPZ˜ÙÔYÀ›opÍ£p…±—øí¿<9–V«@XLtâo䉉ãÇ ôÜ_«ÑÓ¤´,Dþ¢(ï(49šn£õwûJ ·Ze‚´rq2]ôdÊ–ï¿ÌUó܉Q¾9Ã\¶²UðˆÌb <£ø…Q~ó8=2Røìœ9_)>‘¥p;ÕšdZ!zÝ1~E‡)³u¬¾.¯u@¬|‡ åä部³ù&çIúvô‰::åÃfŒÙœªú;&PlÝx„lŽÙFñzõ&ˆ2ѧ»³Œ;c ËÁŽÙ+&¤§Hõh2éû*ÛZ\¢Ž(¤ó"HI•¸Ás…i†@í%áN¦Å¢#hc#/ý…2ßvêÚ/À„Iì@Ls«Ç´VÖbFF6ˆæv÷úF ]â6ð¬E×0L¨Ä¡dé´³©¬×”PþìØËõ_ºo \ãÐëêdÜç–·ì, ‹ .oÀü‚7öP}¸)*/e.ŠÓÙ"¢+•$¡=#@ùà‚ƒæâX}ß³>âl…jÊ ª„Z\ყÉõdUgƒ3! Äçþa}h9&xW*±cÝY؉¥¹èmß휭4 æ±~SMl:Šúž_¬J­½Ä^% ø•UJDAÜCC‰·øÊ£‘Pÿp¨'0%m` +Zˆw—"]i­ûýƒ¶³æø.BLÿ)W)vÒbû4öô½ªå¯žiP‘ZÆV& ´æT’ÿ½cSj‹:þ áÓTAñ¡ ¥­¸‹™‡l$_�IÒȬ~ØA ZÉt26™þX´ÔAR æYÜ¡Ô› f]Ö0MÏȪ¨àcÎ=}<æhõÖ•–i÷œ¬gÉd Åx2s,¨†²:óP‚v@ñÕÈÃöU­ºIJZ”Ê®Hñ~tŠ÷ûƒ.ÐW‹Ô3Ac£ÚSOO¯¼j,îêZ,ð)÷Æ´Ë—úL‡ÊLµèô¼:“$öt˜¸{L;éÝÙ¹BMZk1õ¹cüEë¸ðâ×/ÓtQ•…ƒ.ânl½”µ´´Á 'o\‘’2^´ h-äAa!eàÃEL)Q³ÞЧWŸiàš.¡YoH€âëÞ#¶wkÐËû„“ž¼cã”~òˆ‘"Àb^¬9øÌçáuü4?|ÿÒb­ÎÍ,Í2(_gc`†QªlÀhÌ󟿽Àålj¡VÏüo ö³Òô»oLbV¯2{úß5WC\ÛP ½b²ñ/÷vLÞ—êæ' ÙJ–o†Ëà;ùü0’G07×+Ö *8œ°v½Ái¢ Æ&³-B}÷¦äiDnI¢F´ÏŸÑb<„’¢‡s˜íÔpÄÞZÀ‹²ò”ÚžÅtS1Rç©9HûÊ\<'{êè¼|ú±\#©¿xíÝ-‚¨G£–AÙ¿}÷/ P·ùüº…” £ˆYËЄ7Ré—ux;xfÔè¦:ôéJ¶ü‘|yæYâÑsò íK¦J:=”… Æ·F1Á gÝÓË¿+È#Óù‰Í‚Åè#;'qÑ÷¦ÿKQ½½X„ âíõÅH$¬²k•¢BA{_;›P´q É‚„ALI¸åð™ÍUd…ýN擯¿EUßó mõvàþÃÑ{¼Û¡œ©DÍöêƒj›:Föêà¼K/[„Þ¿\Åè*[yFéödÛª›ý-¶<G¡$|9sÞ—b í 3qouu™…Êûs‡æ‹´×G ¥pÜùìÛ²oÆá0{\gA*ÞÀŽ—mpLÒ [ì1•0"‰w´Ùgô ÍëUü "¶íÝn@™¸�;Ђp´¿Œ3«9Ìûñ4#ßÒsûåÔHÌuÃQµLEµ Œ²¨ŠµÈÆ=n·‹õ•ÇoÓ±[ç.+²-݉å>›ÒBf®Vˆfo¿›÷Ú¸57Pub:Ðö犙ӮÃF»þÔ‹wƒ©æþ„2ñ|½<}î²U vó i›b¯HUÜU¤47u•ÆMͱ.+Òj…HB˜èif”ášM»L.µa‘gQuúNY¹U O¬_xV‚0&Í3+=·éÌâõD ¿Ó3,<ê÷*¸d@£N…Ãõ(‘·,`hGW0xp<¯\X«êD©O|±¡£/Z«LÑÖĽ¢:ÌÊ_J‡I^¾öâŒ|Ђð´ªý­íw¬HyzHÄ3°«ÄCÓc_a-5„´ö ½éýb³F`\XÕÁ|è·ÓÊ©_ÿt¹Nb?MG³Äõ\Ä° ñ°³“¸_Æ]¼úÓñ;¶®Â#EëñÑzè½S`ÙÐ^xùRu<Tí·ïÔã·ª!™óÛbeŒîƒöèY=œ® iT¬\÷¡·ÊˆÕÞE©$¨V…,wD /¸«0”|soþƒÚ‘/ñ‚š, æ·Ø£Tcq1'Ÿj Gc7o¢Éqçê¾BçZÚJ”†ÖÚ }1ÞëSt§½U¸øïÙˆ¯ ʣʱ‡ûø»b¸P[ˆˆûÊ3Êþžˆ–Ú雃-8!‚Z«Þ¤R£S÷ÁEÁÍ«—n˜–[Ö=²F®½‚ƒMãfoŠæâþ'ö¸¨cBçPÍéfnElê©Ö™Á…q<µÖGë ü6Ï=d tã‚öÎõ«ËhÙÏYr“›{Àn…rúúÈ %Ì|Q†0¡b Žpƒ~ îïÙq^âéIÐ'¦¥ÉÑe߇Ô'¥QWÃ1WL3 …­Õ�c/ ¯¢}×"i ü€¦¶y¥SÏŸ•­,ÉÐâ7hKÌJ2«›¦»ú4ƤOŸ«EÝÓÑ8,ÀÜëÅ'_Â,Z±3+˜DAÕÛc¾À;ÁF\ñ~{3#Nfì>À_DQéü¤¸5ÙCjÏZÅ#ñâP(«WOÛ« %¬°ê*¾ŸÅüœ=peô¼75mŠøõÕqÚñWÛ££çÂÓÍxêÄDíŒvLíyí2ç•EäAD¨®: „sôžR yCC;žÌHî§M㢲<qOã XvŠ#‡ŒLNpV°»¸ˆú>u™ŸÞ‹I”­DæYÛ!án‚Å­ˆˆ=eѸ”æ×#ÅÔÌ«ã+xbu1Lám{)we±ÜªzÝ\iõð¹×m´Þ‹F­.¢â7¢y²ìcz ˜üúÏÞÍEàÜü­EJîl+ñٌɃêõÝÊáQÍΩW£Ÿ­ƒ=è&6Òö.(ÔòÖ¶#¶Ò匕jà`R_-•kê=Æd—VqoÕHû¥zZä—(igz4¯P+ìLÇÌÿÑ™3‰S$(Zņ-¡‰"B‡c©‡ÿÎ)‹þWy®+܃›ö˜ž¬+6›œÒZë…='1póãC‘¬([ξ D˜ oOžu‚âµé(Ž[ú/š”Þ…‰1‘¯î(Y<)Ê[Û~´ÿpr½K0ÔäÉÒ-N«•;V\Ú P ¼Z®N¡üÉ[9b=ŸµG !Ck£Ã2þóRf¾™T±q 2üêIPWèÉü²L2¤[’^ïn·QFN cžBÖ.ªòÂ~/ÂX©¹Þ`™±Í›-åêÕ^›ï+¥hÒ kÃp°pÅÓ0™l…d¢ x;õÉ ¤˜ †"§ø Ø4wOŸ‚/Ö�ãÜG~Dl”¥‰S\¹Ëì1Ô_¨ ”[ ºwugVá(ÚâïB nZ¼ôFF@XgS{Í™;Õ­áh?e[CÑ«ìGf¦zÌX²ÞÔ'ÕÇHv—Bâo°KâTñ·vr‰“"”Îè.†Ë»£›qSAÊôðžOŠ‹U ýM'(Ð^&H‰ösBsyX¹Ó¤uiKz?;{Î8O06Ÿ(œƒ–RMЭ&þ”„ßÁ‘AÆ$ZI\¤Á0Aùn5ŸCÖ_i€Ï¸87F†ÛðI-c5eŽ<VÏZ†”Þètr*F¢ýù¤Ÿ´¡Šˆ²=mQ.¯Úyz&tÞ^ÇC™A͹å;^ ÇaÐÐt;L…´õWà,É<K1ä9{¿'ö˜…Ô =[$ßã}ÁÊ=EB•Z¥ç0kÏ6Ôt”Á¤Eã¹LÞ>ÿ‹´ÇÁžXe@{WPUØ–çÚG«Þ°;íÅs¹Ò74È„ÃRð¸A¸TúzGÝ_}+Åq!rºõºVŒy« IXƒ_G¶ùÌßà¸íhT̸«-éÓÙë7w¯‹pçŽö*=úÌ é5L;Zûy½UAd*TÔöt¬Y¬ÙÄïÊʱ3Ù¨­¡&»ßÙ\([Ä+8*6]ÿ§k»i}uXù3 ~û…+Ä÷Îç~PÑN!×£“Ò‡ÛBò¡·¶ï¤Æú¾ó@K¥UH1úK“ Ö23|<Õ›WO]@pe©é“”FŒÙß™3*Å&Ð[S¤?Ö_¢ÚJO嘋„¦f0²¶tRCá±Êš®Uv–Qg“lò¾û›uÂc…aÄf¢V+VpêZz ·wp:lÞ¤¡+fÆæ/M­i<Þ}Š±E…(Óë½S¸£0· àý-Öž˪:w'!Üîý!Ûõ7&îºÒJï?ìÜ ðTƒéRPÞÈúîðQïƒù@i¢ï9~¬g½®¾}ªv_¹íÂ&˜ss“6”£ÙöÍ6ΫÌu#‘Lô®gÛŽŽ8Éì{¡ªá7øêôs®7\QÀY.¨#,‚AÜÈIëûâ¡ÊÑ»œè/L¿œèÇIèáFÁƒ§s)œZOB§»ào©”w¿çFÀhÏÿ¤#@;-éðFt`™|­SO‡@+œÉÆzKÌAÕ ÓÒh}xØëÆ$Yì Ü@j¨ŠÛš“ì[Çç?æç½{"kŸ’VYÛ 5F¢²±m@´4é'|­"kÓd}öZ–lÕŽ=¸7"Ik©ÐÔü^Ø@MÎí)rêh1Ƽ4#•åCBsîÝØzIµ“Qù^Q¥ C* UkT¨Iÿî5væÍžr ©V�J?y5)§OML<]BÆžP<M‚üýbþÐelká°I—©zm¶oéƒ_ ã4q5Œ¸]Ï�ˆÙ„› vŠ7…¿Ã ÌûålÓÌq£ÑPå”4Yvê¡Me,R‰ùŸ—,õÊi*ܹgnº¹†/ºg™îgmr_à¶Aåཟ÷¨„¦=Ì×)[W÷÷ ”ÒÕ‰NwôpJ’ ùXÙX2HU´éØÝê.»K)Ý-* Í0«á‚XÍž÷ž¥ôa5S}åðK†`’•+›€J±ZEø\£z–®ÌñÖµå{ÿ?ú³LËØñdyž1½ @¬ßŒ3\"Û¿¬ÁúoÿK0F•®ÈÒÚ oÕó¬Š×Ž _6ÂÙóЉDA!sN¹œu$*bÉÕ¬³0â6OÆáèEâá>!Ô\¢× ÛˆÞ¸g¨n*õž¢ƒ%Y×Þ‹dEÒ¡ EçpzR y’×è¹o·Ý]‹¯jNQâÝ{fš6û4(;¥ß§…Ñ™ êþ|4ÙÛï:»¥ç¦É';fBq[{†͈ N+¡ïg@Öš"öøF[¡¨gžLæ›óÊÃéÏ ?0K(¼±«Ðwg*ËÓEqtì—JʘHÓî�:ž 9îÈ6DYb36íϫ :Ÿõy„I!ó4Òž –ßDi³I„¡¿Æ­ÕOs1«pU™~B»§[+à9å^•ŽñØ-,'×±€˜ˆRÒ/¤ÛF»™÷ÚBwÅŒëɧ·Äì?ò$® Ûj†ôÅ‘;Ð�Z³TÀc¡Ê8…ÕˆUàF™u‰þñ •tlXŽÛ�y¬Rh1BÒó_˜(X_\™>@nUÙ^qmøßN‡næ’Tò<ŠC½áDỪl=õKÅG/i}l›‘1å›%«éK7½(» žó© ²I'í8“®óÚDÖ¡ƒÎÓËiÿŒ@¡¸ñµ7†Œm9ÙÑ'44C•³AÛÛ±‚ £‘?ÿ °œh×'3²A×óÝr$ ,ZxéZþ1ï v¢åV`eÇøUgvp4y™ö:&Ì…u 5Ó³yª jY=!g§ho“,Èwp†&•fÒßQ®z}Ù\/_1O½®„´q)©n—2H&Ýöf*ºžçb%©.ÄA>bÓÕüÄMªÛgYè)~'Á¦¡He¢‡±ôØ! ­QÜŽ–ï\yey”YsL Û¢Jo·äÔ~.G/]sGn¢Ý±`V×fºw¬—ºV¸[êÕ z¶ç€Kÿóó ORPx.!¿ý/í…îö0Í~Ú3¡éÃsD“F-º…ÑÇEÎ(2Húz3Ê+=Øsäf†Ã‡“˘(ݪùÝÌꑉ²iW¹E «"‰Wr¬ÀÜcð|õ¨"¹òezË9Ç”0¬Õ‰óáʳ ۖØҰɵŠòÔY'O@ƒ;bqyº¿Ç?¤¹_.ÃÔðRÅ»•ÑËÓ6ï­Áí7ÊÁqîC°hc½-´äãå¯t¡Ã„oˆ‚dwœÙËë]%z;6j(*לSjïúÃ.÷ïxk½c¹"iÅà ©Ú8_6:u�BÙèლ‹¥ÞzÓ¤‘kìó1ß³þ¤JJPdÊW×ÈûVÓÒïO²‡ò<fŠµGZÝó íPδ¨ÐÐX°!Ìm\!óÓ,[›ÂP”ÖÍAÇvÐ|àïõ–­—½©²à”É¢ TdÔ$2j*¬r̆¾yÇ;œœ(ϳ5ZŠï¯|³é‘äY‹à‡6KEêK4ÆPK£švòðqÀ—=ÎMp9�BÉŽ…{°ýr£F_é4ƒÊËØœZ1Ͼ�f2;DÌ ôaK“Ô§â•/=Ș寓¥šùju 7oÜçÛûŒŽYâ7˜P°Á5ì4t¢'¾è©­ÚF¸yöø†"e®†q‡Vþ҈Ɣyä»(`Zû†\»ÑA0ÃÒ$³êØy˜ýX#–vÔwã¬L3o`‰LRѽpÑ×êÝIu"ÕålÈ,l¤o“,ï;V7èÛçõ‡'œ KOíç×2Ô^®õü´“[®JÍŠmHÓzð¼\65¥êóÊtvU-?8b2 54 ¼t÷§63ñÝ0°›’a•êñ.å„éi5ßt.ÒÀS£Šs‡«Î‚’‘™‘,ý•­ÚT8¶ úƒ*ÕgV©¥–† ¢Ö]€Þ²‡$nF¬üúÞ_:L|iô>õ¬:%ä‰Ñ¤Ïƒ9‰a4š[ýx�äML¤óÈ2jsï-Jö=î´«ò­€š_%‡¦fŽ`˜Î­wDPjs|zÑæâÛ¾ÞsŽ‚ŒY!,hØ^éñ}|xNò].Ûž[&o¯^>•õQáR&Šv�%[ !%÷VŠÏŸ^?w•2‹À\ÆrÁqÞn=WiFÑÖJßkuVè]>7Üqâ°bDYDøY5>ܺ¿p—ÒteÌ{ä8÷®n»¾á4í":K»:ÜʾóMT¾·š-¹Ôgª%c5õ/3”Çú:dž‰nøat…8‚ù^®¸ŒØRÆ-;q>yºhàÊ–½o=¡àJi«;‡uúh8î\¬RùØ/ÄßsžR&‘»›`»<Úp-žû—Ÿnuæ…ò-É}KkréMu•§“qµ~n;¦=Ç£ÿå…3‹à4®™à¸°xuàRV‚«YŽîêaX‰*£Ü'a…΄¥‘å å¶O¼µe> g[}ù<"‰¢<ö¸.ðˆ�ñÌÔ1#ÒOôa!lWwÛu§ ÝÎç05±ï_œº<)SœÎŠX‰kVß“P¸A"É–wù°\ŽB_ SÀ"¢‹%ŸFl=wnšnR˜™¼Ö½Qøÿô‹/:/y´¶àÊQØRô±VrF–÷e,s÷r2µçfª1~\ÍZä�ãÆ‘ÎÌ=Ž½²µ“¨7y×wH´rcXÚ]ó]˜ÏJ¸VŒPß`®¶U«Ñ®£Øt×rû)Ϩò„”8Cž/`çXðj”1Uà0ÝýüDq¢ØsiLÙÙb¤ÐÓë¡šð£¦Û¢Ýx|ÀYZùß^r?çµßÌÔMôýa2Åx„ýØM±hñ ¿œP>4*Eó¶@ôë!žE¡Ì%?H­Þ? ú>ÁjU(}\ºþå:½Ô[ú?a *:χñåõ<là<Çåjþeyå ˆ" k·­7¯n¨œ>bÃa P}p5*«f‰¨£á÷¬ÎÜѪ™“sêá¸ÐX$ øŒ²ô4eÀfV i^ÀG£?¹º¾K^Ž½A„t¦—! Š“:‘ï)« íqÐîˆáâö‡£Ì5ê–ÇM÷A“Q’dë)ÇfOç[¿³Ó0xKדS{zÚ}üOã÷,[Y(йA™c¿îÍ¡ȵ•Õ‘sƒŽ A¥? ¤D«ŠE8‹@eÃâØ@HÂ.Psˆ y5ú²<^µ€ 2\é†ô¿ÏÂ%£0¹q¡—ÉðL·‰j‹î³GËÉ" Äk™Ý®¤µêä…šnè#JÝó¤l¤Ü"g…·ô¨Ü�Çu°C…býÝÅ3´"¥™ÄÜv‚ÂÖB›-im–˜Åë…)^a//ÎV\2ù_³ùØh³w§óÙ’Ö#%SþÀŠÒÐë|<X-³B4=éÙc3·|9»¶!•ëì+ùçÕæhÖ‚Nƒý¹9\FÌ»›äÎXƒTn<C§o|žx¨eéÈôpNÀåV­-ù ¦ºR:ƒ˜ÛÓ'ßìÍ¿[aFß™2äŽÙ”íKo›pÊg0,@aþÌýŒ^Œô|Ň#Ô¦ú2sÓA8Û¼>ücœ:MòZ²¦&ÕkÕ¬j“øÛtWUÁÙC=smÿNYy�:”æ#ðíéVšvòE":Züï €–º‡cÄçßø[œý†"xiRz–ïl#…Iî´PÐaÞÔÖ@sSwÓ YèÕ¿Œþ—z^&2êycÔ«ç2j¦U&6µg: ·²»üSb碱wÒñ‹Oꋉv†@?ÔÐaªO'‘¦yλ`4)ƒ#}GÉ¡g®)móúWN‘1ìº^ïÖÃKè†ò´ñ<È̞݋Ñü„âo×mç{·)Îlê÷Þ×ë7áB1œ1´,“a®TËàÓ/"ÇÇxGVx!T¯[71à)…Eç£*ÏØ÷AøækD©g Ÿâi\fzUß{MtÙqÀ¤šlù°1–Ð÷®>ÑšãÌ×c¡re¦Œ&;5ùJÔ^Üjr¸GÐo·Z:¢i ¶ñŒ±ÕVKÑĵ`ô·—·ëàªVOÓh±Üó@` –¦¥³ÎÎXª‚-E7v ô„ì•Ï»_ øþ# Š‹vB¶d¡ ]U·ð¡ÆËļÜïu»ãÔiy /•#½}Ùo=­:C¥MpÊ´ög¼õúÅÎí oBXñ´‰q<¯Nê€[þ”=\ƒï} žƒyâ”Í;ªrÞ·fƒvø‚[Q±1ê®Öô�/娖 ýÆ<µo²ïèEG$  ÊYÛXo%À`öb.>üñQP‹5¡a WFÖ¼za~˦NcäÑÕ]À¹¦æ9°ÎK×?£óìZ9…o&µ2äÌÜôgiÇûv„Á›•wODA¯¥å׶>N²vííztžPõÏKâ[÷V)¥ÓG¨kêÞ9°{]ª'GYâaÆ “ ¥­=˜kâùpû ê¹ï¤ÌyبJwÃ™Ä ¥poU÷õ‰ªNƒöfŽxýŒ“±Y¦[àž÷ù~£DâÃÛRÒ2V%Š„%Þg*Ö& ¤“VÜ–l³Úüpv©6lÖaAš§»^uèà5Öu”H<Ù;ÍC_Ë’N÷ã[  ·l—õzÐ&£’¦žžò òö5PÉ Ï¿·k¨d€Îºìíí¦ó®c½¼¯µ1òteÄsx8ö~¨'ñ-®Ù¨aîLÊ5 *ràÚ÷/ÝŸ[©Ó;]¶t,†{ßæh~ûÎG•Ìø›—è0<7ècªuâ <k½ µ Œ QC{”ûšÐwå¡}SÂÞë;ÚGÛ«u…@ÄX‰ø:ìw©¨¿¯Eû6uDdž|îÎô­¢ë_gô Ô¤Z\ÑßÝUñ2€&¾Ä­Žkî•à¼æëžÞRÀ(R'¥l·Óc×I>èÅwZ©µÍ©¼œÕ&RËBH<Jl|†˜óõGªIä¬GÅ™usDr§Œn'P¬ Qä‰ð#œ˜XÕó±þv¬Ù%}œ‚’N•DO¥a[ûѺí\¶È~‡èª@MÖkX\°a�AßQñÅ÷%2úe(½a¤kA+Úòõ•Ä‹Ð =Ö&Ï‚pÖ£,Š|ËX.aÎÒÔí Fÿº›z”\˜RP²|eç9'vLSɃkz—ÇŽûÌ cª6!´q¨LÓ°>Kh¥lD^ÛlÓ#åÆ}'íoý¼„r#,v¢X–/‹7ÎÛ×»]Ç‘¦ÜŸ“ªG6Qþ@9cK‚ÿ?mo¶Ý,²t‹^³žÂPkÑÃ%ÔØa@Ÿ¬zÿ91#22õþÖöøw »jÉdFF3xIfãè|¨^3ÞæÜ´DQ5)JF¯î˜šD™YÎ*0Ìíïqëhf5HA ¡ù7úÞ!tÔÜ„4DôÝÊæÇíHx¼±o:Kû*Šq¨ØXÃz»#·¯u£ŠÄaBlùñÀœÙÖÓA{¹rõ 8<ö'0s<µ]Ž´dAÑÚã¼¹ôM+¡ZZ.¿›¶E…Ûî|`32oì<±¦ÚôI]¤ú5”7GsÊê´ÓrÜ\(S”ÕÞí»‹õr°hýÎ 5ÿp<uFXœM!x¥-zK²”Ó;¥ö³SÚ2{ƒ.EÔʈ¿±ÃžøHïèä,£wy{v'^ÂÜ!V÷X ¾ ò…v9Ç€»þ—B¾Mb õ?YuŠ[À°UgÑïÒ3r•Ãä+ų¡-ƒèÇJä!I ÝÛñj%}òçâ‘inµ¹Þ¡Ìï/Žø´¸.O0hý:î«?ž™¢ô Œ‹Œe×Ås&dÝP†±¡ê¤êeÝì}ƒùùBg°¥´Mc_}*?½P¢yø©EUšr 9µ¾Õ³@zø²Ô(ãP]מª!'žz7_ŠN[èÕRfàå§Bâx€Yõ_ž±Çÿõ·¿ÒBf¾€œo¿1˜žÜåzÁIENÏØOt§Q~vÖ(©T2dǃUtz«º+ J|\KYïFŸäWQ~"õÛ´Â霩ÂúH©Üf§C@«–5!%¥úxí$2ÝÏŒs’Uj â,«µ¹$Aò©'u™ñQŠ*ÏR¥ Ýûæù•Æ)5Ü€e7…¬WOV¥ô8VñÔŽÚ¬yÓ*tåwiÎ%CÐ,4°»Õµ^<Ö§{ÑíÛh^ fù#?'ÓGÖHD¸3щ†u_QW«¯TF,[´Ö·¨bÛ�j{¦k«[F¨ø:ãg¤|ˆ;‰ÀÃ,ª^�ì³ìH \¢¢ªÇûƒ”«l'kaã*De™jaœ.Ç(X“síuj¸d¹ê”õE¿óÍ25YÂÐ’`jéŽ×*:/P#]q€­×$4Éob¤èü,‚pw±zÉת2Jºßs»…ìË|¡ã›bùûRY¡k3ÿC”â;•ºNh158›y¤dÏn±_ÊÃÇñÂ!�ÎPH-)cQ2NÍlU fö=^ï]9ãóÈ9>Å,¸ï´iÝ@Éô'Fíq»V, Ùhëö7ÚÌ^5ÌaXÑT›̳ Wèrƒî7’;Qì™TLÆ?@²öˆië±1zÞ²H»¢hÚH^u\aËÓ47¹ sy `û ìŸV‘é+>¾ÇSÒ¹ H Mæ’¿ý|%º]Å î~ eŸµvêx£ð@æ=ИDOÙHÓRnÿ`ÂæÐÅõ—‘rø¼ž\yã³>Рž€sc%¾]ðד4‹mãž? ðæߊ7á¿?ðÁÇ_WRçÓמÁë¾4Æ1õ”ÐöüÜx–s€q‹ YûôôîÀÅ+@èÕ¬ºŒ}Ãq¢O?k`<HÆ%UÞÁÃLåÿ�ê\QÁ#ÌÇ‚Ÿaû#úhÁÄÂÖÜñXOMœNü·‡iÑA~6AðN¦æIF˜[s\¶ƒ×m£„§'ÿ É»\Ì &r†¼Y' ý æ2(¬ƒ‹Ð†ú†ÓÔç‚ÎÙvàˆ¥ª~ÎÅž:e„ïT×PmF# ‡å/J|CÕì9O/XûêÕgá„!%G'•Ì£¹ä9ŽkZCìÆd``2TG«J¸)OìT XÀ}¥ãÝXzÛ©×±úbXÊy?c'é ¾ÿã``mCCMþfŠ'Õ-íDœ zÛŽÓÛeRo@\3P”ËÞ†LØgL[ÎŽR)&þû— ªÎ*-}æ>ÄÒèr}Dr6º%¶|-ÕtôÈòo¤ñ–%ð¤;^ ·¾˜û}«¢Ð4Rx(u'O–S0¡¢ÜN¤ß˜MÛÊOˆý¬†Ýr6ôQƒ'6Òd2v�Ä4‡ I; §>ýû/îáK%¤,݇[ -à£*¨�l\õV.˜`Ä)=ÕËÇ¢(c›So–¡bE)Ü|OF)ñ° 1¯3P­.) Ë@Bê_‹òÈHg¥ Ô“eÏÇKs3œy‚Ç|P~ÍÐÐûÔ¢…ËA°Çù8ÄàÖR± ÛÊÜSHˆ\²³ 3)v“„$WÎVÛlß Q+®€†(ÛlµÔ Û»ýß ¢²ðÇïç¢üù[;Fô‘Ðoyɨ0±`aþ™uMz-äYä©ïS”Ã$:ˆk(§Œ àè™˜Ø }˜ì 'ÖêÓå@cáx3ÎRóq{B©aIÕ×ÖÓÚ;¶‹Â†z´CÇÉä^€îì·=U“»êb=×~<ϯ§K-•1q5{ðQášÃ糂X¨¾ÈþQyhÎÁ±NÄŠ€;+UÑŽÌnéÞ ÈÆõïÆðòåvD¬x9цŒe”½Ý),Ž©·ÇɼR²T‘÷ÂP)¦ïìfB¶‹cç%³¤š}C€¾¼LKOuŒ‹(ÚŒŠl‡ðÈ’°ÒNMCZÀmÛOœÁÿFÕ#s=[Ž%˜>‡”klM®1í[ØVR”BÉvž4¸)ôn÷fçipa¸Ù¢ŠyÖÜt1Ÿ¦<$½z"�ƒ–'}")% bˆ}FÃ[ö5úÓ]\¡ŸµC!êc´~O5„$”RíÚ’Ù…uaB®Õ»é4›Â*ŠÌaÝ3¡7àüèìhк]ï-\â}l^–úT¶v_FÛc²Œ•h˜-WílÓ:5JÿÓ‡°Ô»¿»Ù¢Šå7!&5úYó·µ¼©øÜ¢í^] Jöc>2sü…€–;q|2:eïi·u£eTo]k]‰ÞUUÎ}-kLmˆŒß^éA¥¢Qç– LÉ­¨g…YøŸ¸¼B”ö-[bŸ½ÊÔ`N´UH©øq0ÕÄ»¢ž”~[‰>ìÈô¯G~ÛAÑÂÁ)rìY±tÎá¹]šT]IÀð4bñ_QgâÒ —ÙDm +:m­$)ÕÂ\µ›­ç'TÍI¸¬Ä7a¾chïÊäðYš] šÖ#e *—ÿý@Ûs=B`s6oH­¨Ä¤˜¹%¬ c5Û¢í‰6w<©vk¨c÷iÆAa𮢨'Å©½Zïö¶]uE=ôd}sÆÖhoFnÙ uÛîh©[‹£Õ*­GqÞƒ› h%2¾ Ó«34¶¥y-sV†=PPÊÎ kŒÌHE ÷~¿u*·’¶­LØâ®0Ÿ[aÌ@dÏW½à¢H(3·r˜«yù9(gm„ÕÁÊ<ôvšG+¬V&^”¡“ÊÉýæPŒŠÌ7+ 8Ÿi—”» £ÅZ[­<Pe²®&Úü¬7ïçëáRÉ8¤QÑŠ‡Ž³cÍiª@£7GNÓÝŠ.OEPÚYb¸ÊyjaTÃŽ{?tþò'ŽO¢¬fmO¼,«6ÌŽ ™Ÿ­çÞç8R&RÓ&Èøá¶.,B_Žm¿Š¦éÖ¦ÿ+kïŠÎ0WÃËÜ�g_ß犻ªV½]õ)OjgëÓÕÂWRÙÈØs±”ź΃tè]U„Ö!öã}í¶3Ú^¯4sâÜ¥D 2ŽˆDÞ€rÖØ©æC+@_Ш®n”­,¨0 Ó`½‰€î}íúÚ¾ášûÃØö}uÂ� ¡òæknåK«Ñ&¬+:`S_ªÂ2½ä/-@Iú"ùï½ǪÙKó— À<eñN‡]wŒ—u=ÿO<Û8õåŠ ¡~ðªýq3óÏãÎSØyÒŽrOp.Ä$º¨€îÔž|;Vû­Y¨gê£Ù—Ý¥©(q®èìÝâÍû Ä…y.%+eù“‡©‚î¿@%m4Í1ž0= ÈߨÈód4\•N:dy@VA>m=WdÎã i”4à’•¸‹{ ´$õ¥Sá„©â¤à¼¤4¾ñÞ4S4ƒ>ÃÈ‚óH°Ÿ=5VÎì—ÊçoÌ}Ć¼„Á0RØ|rR‰R-ƒÀñ®f½³Ãk¨ìyúJ¿8ò(Q_à™$[Àj©¢4I·¥hDÆÆDÀQ8æ8`ÿ"Ý^´%ÉÙÀ<´Ð.@ÞÄ΀. \ÍÖ+r…ý£”¾$¹r_l+ÖýQá/[À£Ø]µÆz“f­¹˜+(ú,ÑÑQ‹øpmÄ;m ¢ÕÉÇé rÑÓŒ²§»¸âÅÂ:Ñé§eo®¢"ç–øÄk«J8£<ÂFÃj‹Êñ p Õ ºqÝô´ÁúxVÉ躌îV­è´/M"³@A²©Æêy8èÐ[ ÕL¢uaÁ=@ŒèåöžÌB$W”rå9³CW&æd5…¯8v¢È¢˜_»‹%<4œ~õ�ƒ�^D¡³1g`WEµ¦‰¤Åý[,œC”dÆû}†gPÜWžÅ î…Ýz¬zN˜¹sGVœ‘|ˆÿÈ“2‹Tpˆ3nÅ ±½ËÔV¼¿Þµ‹ã…Ðéã–ƒ¶>ÄÉ”³tå<↱áòSU^PÆ£Gb‘!kj;vtø•Êgî‹@¢(¡’6J ÌzìKLþ¢$‰léñ½z‡¦ÌÙÉePY½Iÿ^¦9-�Õ4³?љ΃bVr #”Æ·ô öÕÕ˜@zZ÷ÅEÒ…c2-™¦§$$ª?ͺühLxDïÿàœ›BTôib#–Vžµao?6BxO!-öL[¹*ç®B\iï*5*ßL)¼à¾¿Û]xîlU–T^W¹UÙgpíÈãhîÐoÕá’|‰áQ¥iÊBƒÏjÍ{÷ü†5]c“Ñ®kʼãY¾�ÙP‚ÃOÖ»áØÕü~¢92@ƒñ#w ~ÛW¹o–v¢¿nT!­@«t¦pr(èÖIÛ…¨S˜–—dÊž? Û˜Zþ¼]_£^=a�H›þë–á4®­Î"?D#ÇÍMœ7¼oÃÔ÷�ÖÀŽÖrxñá4kÚÏœ)) ü¼?Ô\²Û Ñ ¹RùVj~›ÃõP 0§`Ÿßœ(c?ß}bIèpöÜï (xÞ™ ÈB©€w°€å/»Õ;µ¦°-q™§žf} ýÉØãØ…¾­"ãþç1‘{ÁéN ±ÑµTÈy¢=Ù™GÁj½uÙC•vÏâEC•p~v÷—¾j¾N[ú짭ÔóJ{%k:+.kÐ'„ú‘»º†‹8Q|u³¨a‚’ÛÉÌm' ß[‹[z!&–‡ O3Œf¹{ìfñhâ F0Þnª@é¯Z==ý•ôкnúÃpTÓ†´¶Œ·˜[ “¦OýÕGÍÊ+IŒu8›­‡ùãt@  ’JmCçZ¼úC™. ´è6Cï¼*1¶æxs£ËÐBTnö/ÏÕW«ì®›&WæSÆhŸÕ%ÅäÅ• ÛiñbÛ•;7ì¢2õYžÐdBeTTªTÄè ™ºq ¼¥ôûh,”ÁðHÃ%<¥:}þáìã-½Ò3 "ûšX¡D1\¦ƒŒ`ÈÃ)Å×ãÉê/wPº£ÇÎO‹žXtGnB$bhCKktõék'ÿ©N?ÞŒ¾>N¢D+FàW0€b¡æÒ—…¨q^µ§Ï;Ù×ÐU›Ý§·0S¤•Áœ6 ¿»­c´K±[óãÐÚx7 è¿ð½‰ötz¥ÂcÍ—ºq}Áñš”Îœ”ök*» Üú¦îË*7Ç…Ì‘År3yÚ2ã±Þ÷:ÎzͦB"ŒtS1ŠòªóÎcZćÉf<¿ÒèÈtŠ¥BK–y¯Ý†8å"«3Ö© *[Ê^>ÒãKË…;%û-¯‚ìä„9¸30í¼ V=Ò'}}ßÑ*.|ñ?t;wlæÁÆ© 0~¤¾ë÷òÏ:b¡ÄG_b=®XÂÕpžÁ뤚|ìÀ(ð{ÞQèˆø¨­frçë×;“ºØ„‘lazôµ…1B°ƒ»²2Õ=»1 gƒ„™§¼þeøŸÌjõ³…5 ÚȃmJòР@Ñú`-úé*Ŧ:{2…¿QcÈëmÊí'ض‚žÝÎO…O«/ŒÇ/Éþ›*Â+ö+V•(ÛiN`³ <n‰<_H}²·lç[¯—€Ù];2ZתÔOD5”béÞi€9°_d`º ÇI-o/Ì ™¿6µ %-‡È £EGi:ཱིex ‘U7­Á'¾+¡:ü…ª?²ù¹õüȶ]ÕÒÔµ¥ÐÊç?²è¯gas¯¡›½›%›²SEwûmí$—n„„ÿ£À’°–ýÊÓGâ(ÐÞW£ Ñ2µ\°n€…†Š“y�U‡¨6^•­i’§KiŸ†Ž ¼Q¸VÈ`,úB#Ñï .U¨£ÛѸÜ$Q·¬A|¥c|oTàÆŸþâ.Þf‡øB ‹ ºŽ¾IVë"Ï0ô9›µ×\¦VØ›—Ös5}9áó~ð=çÕþ¼cÑfpä-¡no%‰Ì�ÔÜ™‡éhœû dFŽt‡ÒÑ‚�·ó©·ã/ÚßBY6¯w§�ê»i:”ûw´øfëù›ÝÑÉu2CÃî.Ò«²øá/0~u¾éx°¦´ÝŽÛPÈ÷v%¶læùÈP8÷ÜêÙCliU»º•Å/Ü×’bå›9cDÄ\n ²bê\×ö»vo†£âøÐ77¿Ò°}{ jÇÍìЮSÉÎWëðõŸè¸9@MŠÊV=Øüë[´¶Cƒ³Ì�jY`›SËßú¤E2X$)í2 ôgŽ—k‡^ã‹3~ÝÓÉÌWžk9Xʘ4LÚµE‚bÏžH\Kѽ6‚8:ƒpc‡±ÝCԌϊºêåßÚƒ)YÚ§`N öK:{Ê\;Ö·Ž³©5Þ'À$‰Uö âÞ\ –rVÔ&¢p l‰¹A X°‘ã[ ‹4]XÐFAûí„o7¼æv“juœŒÖTA3ßb¯får¦™²¯mhÙ.ó+|ãI~˜’^½ïq[,ÔPY¥+ ÊoÍÛ ð/é³af=é¶I­£¼t "ÚL axš´½ ‹Ž²Éû™ÙcªaRø ب œ5?Þ£Ü Uó÷μ»Í.o "¥ŒÅÁjܸ¬|1_Çæ¤ëÍ~þ­¶·hkój†!!Î=™GîpËÏSu±é²œ¦­ú7YcÁ•ƒOHÑgîM¯‡¾Á 6”NϽ°œ‚›áDH–Ù0šäúI W'vwRôQ»5$èTrö‚rz²âélsv&3ÞÊÊ-ªÄ7¯þeñÒ¹8,Œ+¶m,‚V‘<¢ûÀï:91×ÊND¿p¹›L,%àUa…f ‰•Å xÌÂY"Óüÿ€.9êJaê:Ýàî´§HVõ_Ë ÐóÃ(DÞœ.³Šñ�°úÔytâN“]#=;ö7¯””}»øÔè£ôð8b�”Ñp¡ µ‘v‡h™`áêɤ·MeÚïw«e/1gŒcƒ)h¾ë¼^Wõã©›ÓzR Y0w¦X׬¸È"'öû/œ«½%Y (§ón¤;~T—ŸÝ…"ÿãò%ŠRR¡]Øn¶XÄ“/®CÏßp’0ÍÙ‹ ™=ÙW Úý\ÜìbÀÀ଼,7žþóÅ û踶Wz”Ó•°l¯^ïQ5¬²XÚtØùlª(JNhM€í­¨@çW*=m£ò±ï›mt¨2G๴Hè²þ•”.!îñŠõ¢l3¾í>¦fB½ñᵑ¶¶ûdí é8NI`x,CýwªYºté®`ŒÈœÌ3èSYûiÿà’Êä¹í!|ä#Bõ·z€’u³Þ¬(±k1°CèD mæ8mÃî %á6*7*ë¸*½âö,8vÍ`T’ÎU‡äлºQbóÀÂ"䪩6ØmC㮺ŒíáO‹þlÖãm¤Œý‚‘“Šf.iï«™!«Hõ” q�“q0º£Ìö®ÇzI˜úE?Ìg8µÚÂ9Ž (ôŽž_¬‰K LTUT~pŽúž»yò  IÐä꣙éYöµ[¢vƃ%3á#ëÓô.ï;’†+_uÑß8Húʵu†öØñPÒ¨0Ñî}ç«×ëô9¹ò¨ì(7ŸNsh°ý¨.˜ôn/#Råy£›@A*¡Åmç м´€YûR´ÆOÚ:ÎÓÓ¦Û½ê@½…ñŠëGzìemávp×;gP¶‹‘êË}nb€“æe ¦£¯†=¹0¾„!Ò¬HõûÜqsBsB¬q~OªÆD÷a>a ˆŒÆÙ™½‚CïHCZÊÇÉ|ðµtLåQ‘d±iç1l§ý¡L¤èLZiË èÄâÀ BÙÀÕKiÎónß�ÝcpnÞ‰api@# ÅóŽÓTøeîÊÜ žætâftún¼ô*ó˜œnçopDšúI½’-œ§ÊÍàá@†nñö»cÓ´“1Çû1š7ý4k«š¦ô~ zÙ‰ZDÉR–ugÜ›­…eÍÀ`ßÓ‰'ªL†áA­¡µÄ \ž:CÓß8,Olz—#eXa=ºÒŠoY²<”ï×ÿ¸1“é8LöiåbA}¨ šU0j1Éí^�€_ÿ·ÂSùêzB6ÑLŽ³1žÀƒ¶½ÐaÏTø÷ä2ŠÈ9a‡"YFžµ-‘›Ñ¢¨†½É§ÉI[>:z‹EŠñh2§GI`¥º†™(LKz:‹ÌRŒ�ö Ïk«”UÖbsÞ환ÿÆŒÐAµ4<]˜ºròu2ž‡ªªI_®cfZg~ì__QsV¥Àj5&Ïngã~{§‹xÆÙ$ˆÒ'2Ø<w¢<œZ¿xÈbø¢ów›Q¼dzçdo¿=†?m2 p<ý«Q Šž�ÙóÕBݘÞ#gG—ÅiöcIªùÒ{WO»âaâ²°fˆÓ ¬¬Ci”;ÒÀ g•NÑGJ'ŒW–qÔ¿éLÁì@•Ìt.W`cÜÌ[ƒ=D>v®—zûïò’¦Ž³%íÏzWa£Ùw3iõçlÁe¿Ç†qdN_FW1¡†6Dô­Òûìzù€Ò¡¶<yrV½2¨œ(QÈ*68sâ¦ó†|ç}ÇOçÛ„ƒœwÊ–A0ךüiqîCð¤ÀNâ2ºõââz;wfxÙÊøÈ^ßuÕvCy_×ôþq3yîi¬P9¯+xªÎÓ_9—Ë(šIÈ/l¶ ûý§µ¸bCYT‚n_Õß>B+Š’™ãìøƒÈµ«\1cð›V¥@:&µµ|ÌûbÏË”+d Ù·V6VñyâÝc;kà>I¢$vNbTÉó ì4Sˆj¶tœÀ³³•ËIŸñžpY¸*};*Z±5ؾá¨{G²ŒRvÐK8]œ¡}d·1¨†Û8È:e4ä¢K÷‡ 1–ž¡]Ð!€èWßÖ§^ÉvG¹ÖëÜ ˆÒ`{Bë£:i;,sâmL`íö“©Æ]tÁj*PߊuŠ@EeÊŒ©û=;NÃP^ïÒÀ‘5ù’1šJCÙ•í¾±'Ïí¼gÇ>ûJK¾¾H»ÓüæÐuCˆhú8ˆO­Ç<œºš£Â5Ŧa÷žuY\z¬‘’uKvÐÚï´YÌh3|ý>ÀÄáŸå´7p&”‹ Ðþ?>¢†¿ßûÿ—‚ \]<ÚÒOKƒ¬âT‰Ç¸Ã=¼ómCG¡P($á­~Çi¤ðc8!n{^ñ¢�ÐâÍ]Ü0^U7É(S"Õ#±±«Bœœ(p¢%ô®ëN*ß-á{“Á"ÞqÔ\:aûif67ûüÞu¿1ÉóÛ<ZÀ<ßÉüPðüHU·�ƒ¡`•¹ï@¸ ÑÉIØ{T‰éf@fXyªCÉvweZg#1Çeì@oòùé .Ãd”² ­X-3=rp·#1Òítµâ*#¡7зþ€ˆÚñ¬IäòÅŽ#ÃÅí…ƒrI¥À§–›Ž?Åk›=ÂeÆûjÚ5îâF Ó ­0H{%ZRaco›nQéÉ”S¶@ù ÅŸá¢øU®ãfOy™ŽAîEêëݼ$]9ä·¤nýB³µ×Ž˜XÖc ,Ç6� ‘/wΩÓ¦){¨Ai¹,èç}=íZZŠU·[AÃv“ópº·ò^ÄR:˜ÔŲBBÛ´Üj|r3ˆ|½[Šl!NÌÚ¸¹‡üb!OúoÁ½÷´ƒM£ÍjãB=x �‹V¾hþŠ>Þ¥’A»TelOV3fºÌ¢føÿÄuîöwònÎôj@Ur].¶î.gÊû¶Ö‘*³ÒÈÛNm®^}‰PkR©ð u 䬦íÇÝÅs†€\› ÙÕ¿ýÞçV»LRDXÎi´º‹\¶{sœ~éù-Œ!V”3Äð´Ù:G¹7¯Ã®¡Ku_>+ŠƒNbf±šz½…ÐÊ<ùõzè{} e4û¹úAKÒë•ji‘¥Y= Á:ú“ŧ¦•X’¬leùX„2©“70ZFžŸ‰“®rç’ n.}\x©~ŸU’£d‘÷àb 1° X“Ÿîú„²¤Z4•Õ÷­ƒÂj˜•ÿOë—ÖãØbÎé|zŠ,T³Þ³¢ÎV~šå©ó¸ŽØn)ˆ?õÎs|‘çŸ\£@¿eìŽâ¢Þêë»m[Ä|¦#£W›V:+ù —VÌN2“ôm ²R¯Mo ×ÝÙt@ͯjç!e$A²¤™ÍâÚú×ñàÎïì@®´×+¦Ä±GDQ*ÅqŦÔ# í©;n¡o}¡gBUÏ/ "BÅ 0/‘¥€'zT±õ\æQZKKQMÚÿ ¿ÙÜ1zÄÂfžÔnðÔ¨Æ#EéÙõ”Çñˆ•q÷ꉪ«Ãí«Ïƒô[™XØ$ó^ è¶.]ë3¤þïÇ>?õfà0Ò-¾=öˆþø´3ƒžq_×]k TúºDQ¦¾ Q˜qüŽªo³±!07ì.”UN¶cùûø]z¾0×¾ @aÌÐ1J Ç6ú=¦Ü甹sdg»ãÝ—ðÛÆ£€b§‘bßîÙ˜ñ ½Z«Œ¬4{¥¯¯®f©köŸùTjx¢™e0û¿êÖXÒ:ãËp{Ìøè<Ó5ttøŒÐ'¬IG§~1¿1Ï =3ºÐ˜­1Hôû_m@ CéàÅÂ{ßÄ…Zý8±%šW.B£Úš…c÷|Mf+fJo¸¨˜»³Ééb•Þà°­¯ˆn7Wä!»¹mco”\yMgŠ?Ÿ*ÇAâײC±§=˜Æ"7^þë¿ä\8MÄøXîNeXp áP¨ÖQÀ…r¥º‹tåø%ʽÈã½úWžÇwiüû6ž|jžÉ`ý¶©Ü¤î%fÜÐ/U˜näü–Öcs ÀgœdX5Tû­`#2ó^EùS‡E·“ÃÇ¢§5¹iéëµæ]'~M€ò°ÇÙ¬©zŽò2ãªØÇã–S?Û¥.ƒ‡'J7ª MÞËC¿|RÑùÃib UÆØF'¿ÒÜ»™þÙ¡™s3‹ÛÊΣè®öýdÚú¾½•õûñ.߆™§%Í=¶Šë|{DʬOk[ç=õ*|© úÊ›KDÍë˜Þ.1éÁGF3åÐw¼²bU¹ŠÔRj‚~l­JQ –.m± G¬Œï®Ý…+wuÓj[H¬ðwCd•öž¬o€Qæ ù7žÙî“8píxîï@Wc_jÉÄT§¯‚t÷¯GòöÒ!2ŒsÕHkö²<u'_ÉdèµgÕVÏMóU1©GY±W�E^+-fĬ˜OǪh²x©&F ¢z'ÙÌõÍWžP‘ã#Œec;[Çå(OdAy±A·P/U`sÁ¶àI×_æ%.Ï7¯@ê{!Ó`.Ç„îã·²kØu™;»âØzdezèK~©mºÌôŸlBxosœNcüžÝú{ø/< ¯÷†Þ«êÛ“5ép³ª2¯ÉO±ÓÍc˜®Ðù»ÎC [ÿQS Ý îO"¢$²ËEˆøÓŒŽ‘…DZï8ïAq"W Ú•2¶—6Oçˆ9ÝRvÝxàú¤%µO9ýÕ¾ÖþÜ{×$“•÷{^íöâ6(¸ž’ŠúŽ[úJ‰…Ÿ€N£Ú&WúlPV¸ÉX‰¬ûøCK-þÑÝ•dvVaF£êðe/d¨¡EVŠHuÆÙXi»Ñ@²Q’'Ïbs긙 Y˜Ü S6,cpê68Ð\€ñ-ƒÅ變w4”<øÞB}™âô ÖO”8hœÿâá±êlj’ÑљƶçMÇãéÛ=1ñð° –°Ôu Æj<÷÷z¤„wÞ`>pwž]//‹zXµÒô//ƒH>õ „ï¤Íâ]JJ?j£û¯‚@±0žZ—ñÖú”VBÙAù1'÷µ¤ZféíàéPàÿyl(h×I„õÆÃíã9ÎtèX‡8†^0}[7ˆI¢`à \æ‘\‰Çšï´„ ŸEOâ6Å£­:÷ÒšOóNP¤8|³U�9ü0iÔëÛ³3ò£ knÝÕ,ÂpE f³Äf˜̦pÒe¦_ÓötG¡§óJÒÌ&…ÿA3îHÅaÝzÙÔ¡Ú´_V&Š+1èÅ#Gؼ\&œ¹ k²Ú²Y¿Òë ßÓÄ嵤˸ƒ˜uvF¸“¯N^^ Ûqorªÿ5ð_#ò³Ô°%âišµ —ÀÍ2Õ‘HGKMëû~¦O­M‹è b°†kHÚ߾·¸r7LÝâ'÷gq—ŠE ° ƒcïÝéÓ‹ÍþÏeá9ÎgÚóNˆ¢ÈW¡¯«…Ž2¼²ôQÂöà©ôþåú8ˆ�ë¨fÞ!GCµž0hѸÍFuÒSSÇûtº0[pbÀ§ƒ S9Z`DqÅ"¬–*-8›Ê 7œ¯B«v#ƒ™«±¦FÍ蘚&šÔ‘V{þ¥½G)µ^›óZ2£4püzS—Ì"Ë’ó.ÕkÈÒK£åv&;Ømɲw[Ƚl­écÂEü»@ëز’ÎK«-6œrH€ÅM…[ƒ­2ñ¡Ù1ÕŒ­j![7ohf"–(ÿc%©z0zIck…³Ÿâò49iÝ1–“ç\³gãw¦#üR*QÏ­üSŒ\«~fÔpŒWÞð5EµÎ$ +æA0›#ž½ƒ‰>Œ†Y|…È­A æ°(ÿ³PÁ9Üþ.ÁY˜äì‹Á0û¸ÖŽç3<Âç¦Bóa¾ù[ÐzãLî‰oP¦¬,&!KÅÁƒç×Å‹ç‡F÷@±Câ{ˆRü«˜– ìäfpIôüÖuò¸€‚�T+"‹sEWºíŒtš²v~'Ya¹ñ"esF¿ ”nƒiOûqáZýéí¡‡¥K0.%aß(k„´ð‘D«’wÓí…õ„Ì–Ì1Û¤—v«Q±n±¶UÂ7¼Ñ-nMšŠE°Þ1¥»ªBÁRp›ÍyTuˆCEO´àÿ¸´‚ŒJé.˜ñLÙL<© ÿ~$k2z›f±H8[ü°à[ZOftíû±²Ê»ËgÊBNi›5cu1’!‚ÞÃ÷àƒÐ¡CrÛ¤ç´õœG‹zðB0«Wc•„Ã{ éÿ9•+¯êá²I­“ÓLqŠú°ÜÍ'y$%ïIʇ®çŽ’„–P]z L@o=\%Ämxöm71«­ƒk5=Ï‚5W¾frÚƼ+è´ÂGL‚–±Á²òÍ©É¿ Úa:äŸ|#ä·óšª °Pò4–°±µÌ"ó$>(µÀà}oì’lƒ ÍY˜×Ý9éÄ2â1…QD˜GÈ“nl+p©mãI«>î—Œm3²�Èxd“{™ÀâÞ­µ@d÷Õ¸½tÖΦ;ñhãæŸ^’ÀI eÊë3¨Ç7£œuãy:yî‰÷®îð¤�ÙMD¸ºxé+åsw­ËË…W¹?·ØÇóFµù½ùÔ(®R—g.\å>'ƒŽ•í ENc¥ û‹Wõ±Q¢Îqí- éÈý$¿Ð-"ÇãÒ½¦7 ùBÄ&2#{u*´ëñ&¦»8QléZPJ†tÐÔ˜þö(—…Í*kÇ “ÅÉêžÁ-÷kÀ[6ûi'ýýÆNœùüGÊ)«Ž>ýNÕJÑœhó´E¶ ÷I¬œÀÿ{Í> cXO;¾lÁ²q§“±HŒùkú‹ú¡,-%@{Û=‹lW[œäf»®ÕLòBkû^_¡§¤‹ÀŠ1‡/Úˆ>-Ô$ÀøÖ'}{7#¨[#quõê«LË`„þ÷ÝçÂ.ÒèJ®á,j ”QïeÞø@Ú²X*î²·7Èbºó©èξúLÌEÔ¢ªÆnQU×Õô†Ûw¸Šs›oðàæ¤Ñ÷èZ‚tÏ'FªéYxcK*­Asƒä?°–¸5É‘D¥}ÙI=ÅÈù¨C *®úî*·b15YÁî´Ó°ÓuÜUg®B&*ÏÇ‹tj rŽ–!š°÷2ðÈs)‚7Ø %…‡Ñc©¬+–‡jb0©jMþL CŸéÎè'Ë-BSà;ЂøSщ_=nódšIfTÈkµ;ÑYû1AÉ°umù»WÎ�BaZ<}cÝTˆÑ‡½eÔ–¡bXÝõ ^ÈÑ/¥éCoh&ÙÇ®Šƒtœx9Ää|'âzæ厾¢÷~l2QáZìl¾†¾BSIöhZE'3{§Ÿ/&Šrð©r€}ÁÅ!D‡êÔMB\hz¿5Õòû2Qä�€,ïuˆ‹ 4˜‹Á/µøˆ[“èÉ``…®yþç|ü|ŽC7EàÕzû ž†2‹ØÎŒòG(I¤’Jþy«#œ®ü¦)”ëFÒÍÎCwòíöÐmw<×îýN¨!‹óçö4rþo […Øb$]ãì¬éshµA|­³xOo1J Lp°&gÖÌ„Õ²­ëX]î.=¸WV/FR:ú°}[ñ·civó~ eÒ ˆíî†! ›˜#vïêº&ͼ.p„šô\E¦g.šê©‘ãâf™©ÄÞÐ+OÜÄ ä™„–ôÇ=½E ¤ZíY‰”žÔÃ]F(®óß`!y=>öïÙ"®ö°w¼ ¦{ŒÒÇVÅié¡×2öti!Eí<Dྐྵމù”Tß':"ÞoŽÝ|Ï ©ƒ|8y"C_TJU'þ5Ì�§vîªó=a‚,+£ÌÈ?eU:KjßFÒÇc®L½Ë7rRëOÌ0úKsìhP„,¦õŽjÓ‘¯Û¤¾ª«rõãxÄ_¿b¶Ùþ’F&“ïà3ºGóŽIõ¦�y&® *‹Vj«-¥UæWMª7Rºõƒ­·TxNîüŽÎÞ¥Ú{xW§ø‘ÛiJ׋ ³¢E!ÚŽ:z6Óµý 3}yNNôæ5ˆ9hªT.jÿ*ÏäÎw•o½¯ºbÿMkÂ%´GWÖž*-°ÙPÒž/ô‘›Þè­ÎUÆ-°9õ©T›ž V¶ÐÅšéÚ­µR½4ÇõWÀѼk¥¼0WWn …«Xp­  ÝoÍ^E¢EO’ê :"êú,jpîªîª¶¯NÛ3Ÿ?Q©)Ds`°FÏDѱܨëÉ¡úÙ[“-¤„Œ½åä”.ÿòD%=ò½J„ɲok—±‚LÒ4û’£ƶ·Öš;3z‘ìšEnîÿ†6Vá÷aÒ6Ql«]Є¸ÆxÜl(m°eÈ»ðõ<lD†Q%=H:j­ÒDQ`ñŸúÙs7öð³×—�ÁîÎvãtÇ¥ÓoJBŠ÷'Ý[¹‰pTYØ9#˧ xùmŠñ‚W”¢åÙuqJ‹uòL‘ã46 ĸïr‡?¤+ÏZë‡ât<¨ËË/Ò×æÀ¬´r ÷o…ýÜ9^ÉX‚BBdýhÞ“®j߳ʖEÈϦ"²¢/%جÀ!Ÿ­B©È®/êzz¬Žô€¯"òïáæ<#d¶Yw»6YÄ–Ñ¢¿±ÿ‰²…1}ôý¶ ²]ïiu¼‡…aE1_†ÕÒ¯YþØ,Üh`Ë–0“¹‰ gçM›¥AÖôÞ‘ÎC«Ã³·ûܸ~AÕÌV¾Î#ú›Èu¦rÕ¶'Áh÷#ÞÕÿçÝ€ï#­ø}ñ¹Wí§Gáÿ „íD„[[´—Çœý/ÚQ›æþ>ì,6îµ}ªO°¦„Õÿeš5~k•¹+ÖêHí¸†Ú‘rNÿìÿ…£ïݶJ¹�lEè½%t–W&ð›ÂJs˜Ÿéžè¡½|±ucè(ܥݱgÛŠ†déeê¡÷›Dp/ÎgKAuËù2™B'5·ªI¸Ç1Ûöe­Ê„+AÛÖŠMtN_Ð˱/üOyr~ðkSQ-b5@éïÑ:¦ÿëí ·ûŸSã›VÆCú•©aÑ’õ:ÐW§Ö3TÅý9žer{ÚÖËÞd«‰3ãQ=ü˜¢m£$çÂ{Tãé ò·ÇóuYó˜Jã>qfšzk.(­¾nR.¨!»J†Lú:·Âpw“¼UâzË©(£QüHΣÖAð‡Ž›ÓغÏkqŸyã†Qv%;ÓASâ¦ÖPl>6ÎáåÄ¡kð†ßÎbe^Qøf~Æ‹1’ïÞ òÙêK d”†9ÏŒXc_·†§‚õŽ–s¶S¦%@{ð'î§ÊÝE8Ö4ëz<{ÏB¿øZ±³U”ߪaS+è9>aª~kÚ [pž!) °Ò³¦e¸òÄkŠ<´!+X-v Ÿ“?ƒ%ü¥·ÇMs™òÐ¥Öª,dÙˆ¾0ÓL�< ºwE÷)³-LÄ©ÀÓÝÙ«Ý©HÝwb2j—FÚe¯%ÀÃ"±ä@A÷î~² Ùض½ t£“ >úBg‹æ­Å°Q·½“Üâx›V $Á‘Óý¡:bü%K3ŠKÇ5äÎSê,Ìàô§*(÷)=/Uñco0„£”éêgv˜:ÏÕ¨ŽÈ›þ/ž”É‘š0Ö°è;kØ:ôÅ+|aè UŠx÷0A2ž¥²Å�j³ƒßUŒ¶îHŽgér6C»þ›"N¥Û—6iÝZÈ0íZ.L™¼´ Ëá̱R ‰íq§fÃŽ;ÐØfeƒÄ×ä6ÏÜv]ŒF%·®âË¥êSL…*DÅšO/ õú·¦°¸¶™¿~Eõ˜ûÀBz›óH‡Å÷Ée†¬½ÜBÅôâ5”ÖŠÉéþ0—éÜ7q‘XJ,D¼=‚ñÔ›ÃH†°KuŠÇ¥¾ñ«?úðÌÈÒ9µ^ éZÚ+"­ü{eÂ; ¥8[ùÒh ¢ Ã×^<Â%>ï‰pešA N{O”£Xˆœóp„êñçɧÄUg+*@ïgJn¾Ñ^bî‹š>ŸQ¿_ýäw…YæˆÇ�,i6U~®7úþ‘Ó‰Öè Ón¦3‡@ÅPj‡BHbg4ÃePQɧœ"a1»ñÎÿ%"J� žÝqLg*BêΈ åöv³£ÄÏYqþŽ G+_¬g¹ ZjSííòi‡èÈíæ5Çf“ÉÚW$VãBÙ$²¢¨©Q7<CÈ 9õÎæŽÞ«ÙÏÖ䆞ň¹*Ú‰îò9h2Oœ¯ ÓRp ƒ,àž’B…deq‘&:@¯ã,[˜^–¦N>h�Ò%óí,¤Ëw|ÕBÏÏ‚S}KÛ;šƒ – ¾hÑøAQ•ÕîýôØ?+÷‰à+ÓÒ²ï8æakï�$oôQ’RáLši_1 ùìÕk=\3Î24 �Âÿä‘o« CÄ]íF{XVÒÕ÷¢)Mo\ßQ<ô“¢HnŒrsO }, .ÐW®v¯ Š!eÜ› Ø8‡yÕ]1Ï0u ‘óóËZ‰ÓÆé¼ò¤m ñ0³Yׂ±{ß·'-7™¦Êt†JŤ}Ø‹Qq9W}umóðDŠÔšEfìrºçôV[O>5¯PÄ"68(ÕO½ÒQ5yš¬qìœàÜP€Oš«©DV`Ž_œ¿Â,s(vúß*¿½3ñ'už/]®îÒßyªåÄn21:IOZ¾ƒþތ՗֔×F'÷ OXºÀ·¬KO>7ýoFÀìQ¯I{í~_çO'¡=Y ½=µÞÕì}ÚƒX*Yaèÿ…Ýn­èD` Æ‘6|¸k=r7teÚÎûögþ/-!žmÝùÕ#ár—©ø|¦Çä†Èi\Z·6 >ðÈm=}†‰êl«øö…žü³ØÞöÛ<ˆ>[OçØJZ*ÿÉ »ôþ<ÿ•zYëöõ ä:5ŒŽîÀF$Cê”ÿ¡^‰Ì0?ŒLÓëØ¡ë×T’›ò=“‰ƒFÏ]{áÍò‚Qã% ¬xÎ)ÀYç3 ÁéÇ�lLW§çÁ× m¨ØÏv c0“±U/eP;²H œ§AÝÝÕc‹™¤ôWÔŠª4¿7 L„ awüÓvF5ï9~^ø)-?\Ê<¾7n²mûöO¥È" 8[¡ï)S–¹ï$+Š+VXRŒÒ³a0;Ûફý8-®i+ /Wòœ’ÂCÑ@Î=¤…ñéHò,¤^Î쫽ô“`J — É MÜB´ã¢§ÿ’ä‚JU>c[Eñ×iOŸÜ° RT_ÚL*iFòw{ÔVç2TÖ;ˆ’~²"šAÀ¸Ì‹šz©:”.€ùô±› ƒ`Ëû*™’Õ5Â<“Ä2ÈŽ£Ô7 ™aùÖ…†Më–Osêùª²Ð‘æó^î÷^ãÔúÙJÖJ)f„uã¹=Ð&j…äsæÄîcËúŠ‹Ÿcc"Iá$Þ\è#WêȈT\ú|Ûj~ƒ-*3£4¨›4(-ô–_[ztïZ§z–ÂBoÁjƒ›ÌV¹¯Ü¢TFG™ãÚf€…_øØÜ1BSðŸGvÈxorWz0âq˜õÝs—$èY7Õï´ÝTvn$ÿ·½x†Û<I9N:�wÕf6Åù+üžµ™0œ,¨“"È{mpfœÙK§YZ>ÝŸÖÔ8þÄd<&£'vÝÛHõTŒTi½AÇ}h £MªõÈ„¶ýv_ž14Ô|$Ô¤~½¡õßæ ›¶ÛŒ—Çܱû¸|.=@ëvBQÛ°ŒÔî2R1ÕlöÝ‹Ma‡Uü`AÛŸ-t>hÿÐo%6ÿÚƒ¶°gchäh)E]±:ˆ|¹cõ…­òëã ÉŽ™ì/@ª>³øÈ£nœ+#IqpÊ­M°!v¤˜f3IX™[KtäÞÜåº q–z„˜`ô.·«À烱„ õ Dãöâ9ŒÃ ”p†Bß`F_®èÔ6Ú˜8S Gç �k¬ŠNx„w¨(>Ó—]­†–Þ£ØYTWŒ†?$&yÞ£¡Ébzx²ZqñRÚ$¼²)š¾è#šÇÀëÕXm[ÇçC|gïê~ä=Ð Z“Àñ·¹7Z{Ö05þÖ!8Yâ�Õ®*âN:#DV†É1Šź¡*°³§ñz­¹(¿’bÑÏ_Aëš–™»FV¶‡ €¾ùªLËÄZ‘þk8±]gÄ…›n±¶C?ÐÐmÝt¹ã!™oÂB%4)ðÃ…(ʶ6UÛÛWÅÅ8]#Œ€ÏqìvÎŃ; 5Jdl ÿý^ÇÌs�g³ºÌ)èX÷ÂUÈÄÀîÒì™n¤äÑd'/VŒ[¿¥³wÕýë¥81h-§@,[^ôïð§]VäÁñÄ|hôˆÂ°ÕÃQlÕ 6sêôÂtMÅïO'ÃÖçÞHA•ñ ó”ØL¥©P“ã—ŽôŸ^áO=-¿b÷tÜž¬.ȱ”5"{ðŠjA!ªÐ>Þ. Còi6³aX¾ìé„à»ØŒÇKÇ®èÞ6îYd‹Éåö3¥sôÈ- çí¥Ú¿Å¹EÚÈͶ!LЖAÔj#?“NDˆX?`ÁäáôÓ[ï>PÆG¥í-ØKmÂKH£fA|QÿòvÂm¦2@ ™û•h£®éŒó®îÙš„‰SgD# Î2Êq¬!Hðtÿì+M`ñW>1¶YP5>–JI׺IiäS¡/N§G¶¥³O@ä.Œª;„^¼´H½âœ‹~>›µ^DÑ/TQ±üÙôÙ›h¹'¸Ì€Õ€Õä³õÈè”xíŒ ÏÌ?)¯nöƒïcìlYJ#Wú5Ójj.žOºWµjX蓧gïºSD"lJ Ñ¹ÁT+´-hŽöGÀí•\k…„Þ«Ô¤}¤"—GºÛù8y±Ø´”ö¼Ü¤ÇíE_f]FÞoí¥ ¦À &N”åv¤îåÒ´ CIÛ|éÛ7©NC˜™Ó¸ß¡¥—_Y «WuZ´ZTUR$(…V±ž¡€ŒyÝžº ÃÞÑ"¸0V¤ñtÄ[k³¼ü™â{RúZ¿T¼®ÿÐ?ò[Gˆ§xȬƒc·±ÜRãÞóYM³ÌxÅwÄr?·î×-íIO¦ éÈHë·õ/eM€³}%{°î×@(¦»Á ?}¬™fÀLI-½ öãȆ{ö×w–?Ý3ì-é-$»Ö´»â¨PͳIŽÞh+D‹ºlgpÖ3;¬G„©Oà™­Ïló Ê2Ò‹RÕí06§û²È¢§Ü³Æw­Uô¾I­=†�B!#·š‰%svÐ’âÅŠ"½!(‘§¾°o”Šv÷ª=¹:3oÔ”õ—šÝeì;·‰—W$ãèA"š#è!N§DòSÚðÍûÒྠ·pê†FšŽ%F=P<vMʧ]#‡ÐC`¤Áþz]Š“6hókQè) Ôlûmk»Ô³bæe½£GYV*ÃN¥n¦>Ò2V b£7ÑÛ´#[HÈñÆ{wåõ_y]N[3x0ãëøJ€IJÜ4fRµ=Dæ_â¢<öu}iåè^“’bÙðUp5, ÎÖËA³oàŠ qç1&üO{¢)¿¹¡S³5_‚Rw§Ô=P«Ž»ó쌞ïR‘Â(¦ÿg²n6éèÏÅågÔ—QåZ¬=+SV?˱äº: Á½}Î…Âcƒ'kÐ�í Eš†Dָ΀DÀ„jšO£™|Ð÷³¬ž›Gœ{µ=Cá¦s”ߺŽÒB­Ó)¨m—þþB}4Î<áUvjGžœí¾Ðn ð®d¶š‹X.Qâx¹ñSwAÛ‡µì ®y“F¼ñÈç¢÷2Îó÷: 9B´›ãò¥¥|W½ÅmŠæçjaî¸l«±²S¥§Ôq¸&Z ’!?³³gÆìÂÎìVã yÓb‹õ?NVz/-7îˆ\þMA¡ÙBÙbþ×uªnØ]ÇŸ4\ÕQÆS¸Ë=îò®óß°¶ŸÅhY?¾ôvR˜[¹éPMu“_‚´oxªÀ#Îwú¸ ó”Qù þh£&(1fÁÉN“Gs?„t‡«Ë…yd™\M!!hßÃÜðMç¹:Vÿî™bm.†¶?ï}ᯪˆMɺ;t¦^¬Ô@úÂÆ´M1Þêÿ›J{©cÒÔÇ–E1Õƒ>lõÁàé>(Ò¹É@I‰£øi˜e"(kZ?THÜ©BâÌŸŸ9Qò·[ë±Ûƒ»‰šS:çPàèZη_^^­¹fažOצA:iW=ãÞí‚Æž6*êiìã.˜EB>ªm’ñ¢¨ÊÂUš¸y£#N mŸÿZ.(½ÙñG£b;3vÃu/aß×vyš¬( SÝM¬|úþµ>Ô¹¥ÌŒs5©’°X¬Q ]»x¨÷Ö!ä›RO,–‚;´äÊnvÃ;*ç4pü–„IätšV¹§)Á²ô}ö“GÃF–¶ Ädª1í⧱mÖp`?2(¾3GáÞ/MÄÔ¦[©OÓ*(íÀ0G6¸Gë!×5ÿé>²ð¸’–9Q}÷èg guì™ÖÙ™Vj9í<h Ä_=ó7ý¥ÊÂ)& ¾¾Å<›9àÇŠÿ…Ò)ÚÒyd\ƒhùÒ"óq ‡joNÅ{W¦rÉ}LkÌ»$H3lÒœžfðlàÅ÷ˆ2ÉÍiO=‹­³ñ,®§‹ÿ U Ué›KÂзpï¤Î<i‰qÆ°GKг\>žG…/) ÕþŠmÓºÆ1 Å0 { ým*Å7”šðq ®ñ{Qû²$t(ɵ¦h gþ+bCUC«7ÃÀ,Á oØ(+ŸÅ÷9/È¿Éð®Ö4­JÒoH³ŠcJ„‘uµ7Ñ’çôþ¯H‰'{“¦|Þ°YÞ¿†éZD¾ƒ®¢ÍfÉøFV à·£ó¨X°¸ 0,ádlm+¶µo Ì>+•¾Üæ:M;ëÏû¶L}äÜŠ‡1bßžêíº«<–÷{ˆ<ë#Ëíœ í=–YG Ý(0Ó›Š…ðvvûÃ�J¼1²ä2‘ÛiÚT‹<÷FÃp­hu“ýd ã莃Œr‰ _maPýÝyÕ¬fÍ.'=ÍdV³×ïý݈ȱ™MçÀ샹ï`PS-xT)¡¹jd•¼„ Z(ThðDCWR~lêæ¯5J‡î"|KÜzø‹es[øù,jòiñV…äæ7Ÿé[ˆìKY“0A¯Ìú‚C|ìè;!zUÍa?V%{ô&›>r-£¤Ü_W}Õ‰ÚÉïÅJÕgŒŒ¡ 9(XF}"òþsÉ<óÀñ¿ ¶ l/[ ^—ðjÌ°!²½©<îNlj…ñ:€ôz‚i¨x6¡ü £î}=_µ7EÍ=%aq£Ý€®C«çÒ JáŸ(´fŒGVÎ0â“¿—D ÓhÁ‹LÁ”Ƀ´WJ„(|;À. ®Æl\å¤üwT™(,|ôLfК_÷´·§–» UjHç.ðè–%õdrDóyŠƒÌòµE‰…Š“§<ÉÿžýdÅ\°ì;ÛõV¬[üˆ„°þ ùñÀ‚6ÔÊJ&²fÔMš ËØT s{ÆJï {£¢ôY1tÏ«. ŠúÇ“7h«´ëyæ‹P%s¬ùµ0cùp¤ÂðJˆù¿ÀzÚSòlzçúîâ Á­¥<#m‡Ý@gPÄÒ¡p{¶Bï„„´ì•JoýHC AuéŒÆÌ+£ârK&O<Pþ6âm)š›†;%kÓ»¥L0êÛß'’Me²ˆIˆ1 Ô¶ÛS­4îiÒq¸fÞÆ èå»—?"ˆ‡Þ œ‘ÀH'ð<±"úñ "?ô#øŸwü#µçb•ðÏUdV¸y™éY)Gáx ¶# ‹"—6@£­²E.…‡µX§‘–Ó²²Ý´½ “®+Ü"qá<–™Õa³ªÞÕU×l2ø¦÷Ôš|‘ÆŒÄ4ˆmKS.ŸˆCÿr¨.žØ[G_ºûÏyñ‡‘K¾Á˜´þ ÿs·'²Ñêà~¡r<=ì”ÒÙϺ!r4ýþtOSO#>ÃڞÀyì”­¼>†#¦® xàãóÉ~h‰Wl5i‰ͷ{ƒq×pܵW,B©ßÓ6Ù}êÚ{vjéxÖ+s mOà2}[G²#$Ž½·ÊfO;øeÞÓvNOÂzEãý¤£Pdpm#kQ!Rçp…[¥&mƒX\?¨À¼ÛŸ #ZZ}G8(‰KWÔ3¼¥f·lvN:‹6'Kô× Ït‘ðS:Þt§}í±´çMÓþqúÈõØ­‡X(Ćy•Oz—cî®íh¥ëM1d«y)$ün¼=#—,M»nÐQw"S,?rù`9%3~ï„Ùö@»Xš ”>¶=Ô¦À#üi¸3¨QýDŠÈzØØYáêi,!s`…ï{‰Î3î\dûÈ,kKŸÒx*!6Êè²t.í×­±f­»(šÄ#¢2c™Èßýåê?v‘�iWÁ^´™<Ê— ¾œp×úrÇÐÆöJ3ì¬wPŠ¯7ÞhDÊMűåßÓ ³È¡åØÏ>…»qç*Íé[?fŒÇó÷ý7'v`½ó/4Ù|¢–ïðfÊ¿u<ž]~TšxÜ4Ù9r¬xÄ–6aº›-KHÜ lËIÑcW[¥Æknúå¹õä§]u¦`îÈx»KcþñØ/ôÚiSŸ'úÌ%—E,‡§@,bÃóîºÉ|g<mY×›I¿ë/ô÷¦[¸Eéé.ß_ ^)ŒæA<7îö²Oge}:™&Ëâ›ï%X­XäPMã ùÝÛ³€OàMÀ ¨(¼ÍdµªßÑÊÈ@7U„ƒ:£‚ËQ®©¬Ÿ#j´ªÍ;OfÎEêŸã<± Ãæûìùµs…ÉL´_/¬â ™("!$/ÀýâsHsìŠùè3ÃÄXoè<O+K“XBƒ;xë\øÃp[•‚ණÇC½û¿õtÈÌ %Ö§éÌÚ™6y™ä_°"ÃX“ïÜx´®áð—WV¾A¢²X4:JÖ¦üFàêÇ¥¨ÌYŠìð4ÒY5öžð=£~ð¹ Oh EáÓš‘P˜oF•-jŒ){wL-Žý¤¨Â;M¨,õ¥² ë³ ì:C¤jäóÔíO2r”rfwùj¹Å%­ó[ ¬`¶qÓ¡ñYç¿_ôáU*Äb¢3I0Zš¼Ï;HW»d×´E(kjOn ¨(î®jÍ¿1 ·?ø%P:ÿÐÝjºW¬¯\Öfé¿{õÓµS¬iÃÊ4¿Ù!c5öÂQu�qh&øÒ#¶"fªwCA< ¶ön.ìˆ6£ÍÏ6£4a;Êø$–º«­rK8vï*ø‡Mí¯ÂÑ;¿©ïŸ"9–R*©=½]K)Í�á½>¨àwóq¨"ØPž uªw„ôxçŽ"Äu'*ò¤U­!ª–áJ®X%ù‘O6iÄë.¿¿?YJ½€€´idöEéo3uœuîäOŒÊí•ÍÛX[ÿ\ñ¨Š-”“ ¹Ò ÿù3öøÌ DN•ïSK¹Õ|<ÿ: u>EÏÌ©¹µ£Í8â“Npéa‡+?õ„Dy­ë&ÜÞ¡=±ÅÌ™œõ 1^«©*›$€$åÉœÙwP‹®Úéãò±Ù\ a\ú PÀaqó¯ÚGõ>æ2\ÁÅ|/–'ê°-ë³#aê¶ÚwïfÐN_'34¨“bð¢_go9uó‘=èØ"á=žiš, W‹ ¦ÿŸ~º¬S€*=~wK>Ùá*»jð×\e[{¨T³¾ yç÷–—ÅêÊBøL™[ÜZîžWgÇõÃÐo¨9q¯Ä¼Ð"JÜÛ4˜¿‹ Ø)¸ïÀ㨋"ü¸ýný'„°í.n¥Ñ";HÍ´Ž¾‹á¤÷£ÔA¥E¿töó•Od‚þÖHçrR ž„<ë¦psHB�’M“]ýè•‚"X°"°{´™]ËÒ4ÐN˜¤:˜cýåæ¨Xöeê+<±C’ñç§ãË+µ­uÚžÑÊ Ò+áó¥q‹Ðuw^ÉN»ü€ûºå”èï\ÁçSšÜuIËãÛÎYӷͶõu ®›[topêBkdÍuÎô¶å¨ök€MõÇV XÉ-ï<ù癲CÛø’%>·“%zÎàQ}z!tK8˜ŽkÐþÐ/2ŸÄéJy¶kè ¹Œžï€CVÞùȺ§phÐ�”_>ÆÄabawBºàº;uôqë›LL”[ä’t¸ªàÞ›×Í+èføŸ2ò�ÐÜtÜ TÝú0ϼp×Êh#Ö{€ö‘=Ïæáh"÷¸KL6æ\î´SQ‘БëÌÔãn8Øã²pÌvc¥MüS¥ÙÎÕ<Y”µ¸4ñè†ZÅ~?]{h?ðÔ.Š…§tJO1þSÁaÅþ½”õiKrBßؼüézœy5.ot¶„z½üÉó:Žzæ‘Wͧ$J}£‰Žñ2XõÊ&Ë2ÌF*V¿œw¿>È{fEªE1Ý&X´D_68få[$×B†F"åkUÛÉ`믪ØbJJ3šZÏ´”²æ› œd3¤·Oô$ãý6@Í:Oú—Œ›ð?a¤³±i^QµÉvcj‚;Üõ«Íf?}ÉÀZ‹ÍgdëØŠ¯èàØ:vV‡;µý1ÑûxÅ~wMýç+»À  XÄc8Äï¡Á ‡å€Éx Ü£QØ(p<D5&‡ã٠Ĥ¦ß2,çŒþò6;R_Iv;úÄÖ£„ÖDˆÑWûç#3så+dû&¨¯ýo2âú€æÊNÿ­ˆ Ïa¡q#¼Ì¶L«a‘´ÿU}ÜOFÝÿÈ¿Ó©Ì ¢³elŽÕÀAÚÞtð^(ýz žmSdÓÉÓƒj/½d¦ƒóV@ÍV~ñé`¾¡÷æb9gô _’ì;rOˆn÷ÜP²éÌg"–Âá`«±-Oþ‹ÉÐçsÛ6oþê&MŠãćíJÛž*ئõÆÓ00ÞEˆ=XÂ7‘ÓÆÏ8\HZ…²Hwʾ>뙿“–±J“Ìé± Ãúý#ÜžÌõ–ö§a@ìV O‡êúGCì¼&x¦¡+ÈYgjè0åWi™¨³¤gÜó+`šíªeÆ6m]çAúó¯§s(:ïœ!‰¿}Ðv9¯Fû7“~{& ›ÿ­7öŠI±M¥à Í0N¤T#˜Ï4sÔü#ÒÄ‚•7¢Ï£ÀFðK7—7Õ6pÀ$bxc()�iZåZ`"Ûô 6°.3cæÚ ¦><H 4ÊhÇfõG þõ;OÑò¼°Àßr=GÝå¿ÐèÖJ'3íõÆQÔi;»q&X}XÈ´GùMº`Ï*—‚%"A÷ˆ£çµþÔ¿Äõâ—›uFß š=×MÛñZñÕ!‰Æk©9êXÕ*-=] •ghR#¬ øžÖFf…~ïÚÌU¯§dÑdþo}<ÿÕÏUs¯‹Ø°XX2AKÙE¶Õöچ͕™hÚ²«Øiͬᶗ�~ýz‡V³ò¥c)]mæ$È'=·-�ß°= ú=çÄœŸÑG7;Y/ŒŸø(NN66õF$%ÚmOqÜØÄr)û¯ î·¿G’,êÚäë%zçíØDÐÿ¦†)Žcú¾8 CtEŒ$4€<¿r Œ*¤c()ZéA8©‡¥Ó€ÙØÅTG®Å‹úxkø®ïÃ#–™±L~ ‡ ¥2)E»œy FÜŠ¢ñëÍj6s‚ØÞqú{c7õÊ®VÝÑi­×¢ÔsæUuÅ·%øô µFØý6 Êvã©-€^Á0’ÿ›™šÅPˆ›SAi­Mº1zfkSëŸn•”Uª¶k»Ã$pwi X"«­L ¬tÈÌ'ÆépÞí{‡ò~†2ŒÁ‰äÒ!Q—A9hõ\dò¿n=ƒTèËÐÂ*x)(å‹^³´Ü0õõ¯§ÐXWÏàí&¥SG0ÍæUbö¸@ñʃ%\ùFƒlªM §üV,"›´2OÊŽoöº›zÇôsŒ/•®Š(ÊñÌò<Afëü0f'¥µ¯GKÑþÜû€Wt‰§!Ǿö‡óˆÖIT9OgkøÕ(¹öž0Z¾HM"@|£ 9mm³šjý%ó7ç~ü„öš=–”žh&ÓΊ ª5ßG ÿÇéB?ó,Çå±Bæõ{ùžH%ÊBQ­ŠÁÏOƒÄ½3Ö¤ÇËd¥.?R²ñ#ù´Xy¬(§2ÈFEYB=ehi« …‰9æ–Ÿ¸â pMHÎä#ÀZ;Þ|âòŠÀ± ÷_“ë‹I¦½+ükSžùÓ$ËÒ¥IÕ—”J÷ÿ:ᨱ’š¹#Xã~M'”YÑNa&Ü5’_˜›”Ð5]„uçIkÔ­ƒmTèJœÍ¯ðk÷о+Oí™Óôžr’r¾xnžv±¢ª=¿mšêªÄ³ÌYÝRÍÆéÓÐÆ‚§9mT]žÖ|C .ç7¢qâM5bƒl¼R`17>Ô£V£i}é³ ZwyŸ.e]Ç­õ Æ{xR ðˀ̷8­EóÉ]œ[àAûkÛÄ!¤'^OÛ¢O…‡•m ÍK/mF;õÁîÆ^Ò©‘lák«ùû¿e  ãüEh=Í ÅÙrM¶š*—ãîSi<YgóŽj›£<ûZ|›NtìçÕàyž/Ý^qÒuk 3ìÅß4PéPÓ,2›'i0‚®R¼²5„RÜÏã”ÑU3Ã;êñt8´Ú)Æç€Åßýo3ñYþ:µnù“اh¢Ä›ÍzO„òYÞii=BG ÓUu¤ÉÝ“ø›¯,P!ÀÑBfž;HRø ª¿æÿsÿ÷šîé•W.-õ ±5‚0ÈñfŠ1†zIylSø¿z·Ó^†Î£›«ïöÍ, §œ%®µxžŠ{h-\wG xÞˆ|9E  A‚Nƒâ´ñÁO- H…莙ðÄRƒOˆÎáʳ„>.ü¯jO»€B¾¿0dÉÅ‹ý|a¶ k­¨ÌG†qñ8ù[ îë—åÌÊãxru±k(´Ô£ï6Š…ÉAÒ<'7ËAÓ]=3Q ýª³/tÚësëý% /M¯L¼m Hã˺<qBO ¯ûÉœÞéL79¬HòÁ·äea.š«ò/î˱‡-Ÿ‚†I[AWà*À¡UÿMôAäCÎé,=o(!X}[ûm3J5oÚ´çɸ=:Du®æ‘›4È~Ô] Þ5§ouûÙÆÖï~{O¹8ÄÕ`eðWñ§"ø¨mæMÅý›×È+ò(‘ø)Å’;ëd_È\¼eõ©×$baa®ÌO”ÍÉSw1s‡ÕØã:”¬)P)‹#.PMÁ‘‰ÖÄ0y‡<úõx¼46{ÖŸôõ&z‘/æ¬gÍ£­³ LÛž%"€× ¿@X;›$ƒ5†,GevÜò³=î”EqçÕÀ&âÐC—X…ó™Ö_}Q‹sú„”ƒZ¡1OƒsÆÍng·r<õÚƒöâqHrÈ‹s„ÏOO. §Žs´Kÿyii…ÃÜðnÐd\}Ÿ¥ZWÖκB”¬7ÚŠ¡ î©õæÔ:¿…Ë빚=^6Š¥{o¢•]³ËÏ µgeäD Q2û!îÀ"åw’FïksvÏ¥Œ]Þê‰Nß|W™£8DçŒhsŒ3äˆa²ÿN”Ký÷PY3–':‰2bU%C„,¢%Ì•Ø« ¹ÿQI!ñ'h1· :£zÅSÖÇü!ªû×çÃåxa³ö-V,ý'‡cÏw_Þlù“*›©¨%íhŽoŽ¶Ža):…rÇ‚ Aîe¨K"'fVk0tyýëŠ&ä¬"2fa9ê|1{ÒÑŒ½°ˆ­Ha'…ê”\ãÓô¯P]RõÂ3i¦èüz[¸‘:ÒT8ÀPå[ß<2’BÖ´Ãu+èWÞQ(ö¤ŠËÄ÷ ´=¡-l¯2)óX3Û6´¶è‹cÞ«;H<¦¡ƒ‰¤ÉVß½T÷ú!°µ1ê3ܦ+Þ{¤R"Õ±] :ìPzš. ´À|{“‘ ¥3î©(ýèÚê_“3 ¶ÇÖ¦G½wvcörY»&™CmCÚ%˜¿¡÷[7î$P¡­{¸Ç[×Ç9˜Ûý¶¯¯²j•(5€‰ªÇЛ¼˜6è—sû¬TpqùJW†©—™QÚ1tÐ(<\í š*zªüNAÃ7¾Ëp¾°Ç^qúñLg1•G÷Ì éøo9L_Yë]ë(ÚÆ¿Á¯ÃÎôˆG.1âSO¼±<eú7ÌÔŸ(Ñ©XGPLwX½VK”ÔiúÀj™\p¾n£|!¹Ó!ý¹o§@[M;Ù�–üöÞÙ­<x�¤"„CW•ë–-í)}ÁK>Š!¬´ÍG{¥]”‘ÇŠEr?nÎòw‡ñ‰A gªò üQ‹ÈD@錸ËĈ§‰5ðúJ„Æ1Á8E3�©Ž¨H½ VÃaeÄgM!>·JÞÃ*«…ÍIX0 <MqaÄÛ­ôB,À—ºæD°c¤PV¥¼àõÐ7ÕxQ·gÐ܇HÝ0Œ\ªÃ¹Z×ÒÉÚÌV –+ŸnUCÒyi8`•¿CCJÜÁcyuž=¨ò¹ú¸CÁM¿Q“Pº•èœ,ºƒè<ùƒ'<KÚûƒÞð/¥tÝ›Ö[a´±PˆüVÆ7­sm|¦ÉdÇ[!!ÿÁ(´°úÜįºöLĶcu1 ½¹:õ,î²|5Øcßü þÖÿ˜Ç Ç®å¦F°FE8~#ðf=wCµ¯˜ ðmMƒ¶´àýP8>µb¤WOT`W¹ÉdSžûˆ]�Å¿À骗@/+t·ïÅ[÷¹À(ÞZ'Œ¬²¤<íÜ­Ž±–`Ùóq?0Aª§?ÕN”{Ð[Éèò¥ |çW‚òM¥µƒ‰I=îû/Ç÷�Îƺܽ4 ^Zø3…©fPM«³¢2^Sèéuż§k{Ö©I Î=½çncˆ{%RÀ#T´UoÜ¿ÏOî¶Å40È…ý­·eî:…¹”ÀÂ]Ú¡šlϺ½ Ò§w¤ÂÒTþA‰´?Ðí·”®ó~6“:“òŽ' rŽPœ.×ýÍpa@Yr±–a×yEÔ×~œ­ÊÌïy.™§ËlZP7´¢³z6å ÷´œ U¸JÊøtz,p a]ô4@Z‡AY8)±óW{òª”^{ìè–ŒûíoíÉRXñŒ¥é ÖÐþëðû0ÚÑõRï§BóÉÈé_ÿ ò«ÍêU»¹H]/Q<ÐèTɹœ2õ%å.¡¬GÅ,14à7§Kº"Y%A×–«óö‰Actÿ­•ˆ‡Èæ¢MÿåÍjjŸã•C´[}ã”yŠ² ¬+?»¿4UgKó_éò:IŽØMvt”䟶ò_11Úô^'÷%©ÌVTÒ/Š¡Mo6jbÉbMppùRg8¬HÕÇÃÖ*i?¦¡oùŠÃ ‚cíÍ_¶>8ÿ×;ΊY°xë…žðîì¯q2æ_ÉÏ,,þÒ»Ž“Eo* Æ]búwŠ©BGm³g¹j†Ñþ–jRQMGwüépµUáÇ{n„€‘Ó×^#¤»LÇ~zO"'*B?ã ÀsøJ¨’êß ƒ”fnq<ø""ÀíaáóR™XGñ ù1P›”…¡+å¿Ú§é#¾¡v¦ Ë @y’$(Zg œ‰¡nÛ{Èüw#rºüá¥íYØ.}Ìqææ&[@jÛ@Íqyúw‚ÐRwÇã/ô¦Rz¬Œ;ÔÆß½SâA«žë(ÉiÔJñúõª‘®üI)-¡-)WRPV§Nã°;Éüƒh…¨¯XÎ+E—/X".%-ðIOÛ®²)ÆÄ’‰·óêÜoômÄcåù¬BÒ»«.*Æô·:G‰ëÌ‹<θ`äS·¸#[{ r¬Q†cY„jýÕËèÿæJq*7¿ð Þ9¼P©¹¹¤´C;«'Ké*‡JÏ„‡„hðŠDv ¼»H9ÄšM˨­õ!X“mã À’,…þ¤:\¶uûjÏ¥…v0ú»Ø9XКޑNVLÿ|ĥܹTo1‹¯ûWØ|ë‰øá‹þøÊ:·èÓâYø?¬*ÐínegFÉ{ûŠ#ËÓŸØyÖýYŒ‡)šR™:Yȉ´:Mäh´GÌŽ_ÏÕ²¨Ü™ÒÙ_Ø@+ù€zÝ ƒÃ"’˜ã“µÈKï1ð_Èü‡Qä¢UÆæ4YDÝ¿Þe_m YÌÒž÷ö<¥£Ãˆ³¢‰–=#ÆnUñjQ äÁt†% Ó؈v°b„ý2n2øfç_<BÅâ{Ñ7B~qØ ôæÔÝ¥»”žÄAÌŸà+ ²ªuNÛ£Sù½' òBJÄg²°*“Óè¬2l±Vö©qÛÁ—Aynš»6=Ã8Ù¨«SLóOk…g~‘kÄKÕö2è&ŠÌÉda€W§±íL8p"Cîž¡ú,j%\ Z´@õuº+Л<q™*Ói<p‰æûEŽ2«xPt'Ê„ÎŒót¡;1í,Õ*ãÐÿáªi7ê ÿî%/ jfiúíÑMÆÓt¡„ë…— 9eÆY·Vƒ2Lµ'h¿]A“SãL#ÈA˜(uTh~ŸLB!Gúª3þ> yy`¤ÙÓC¨mã–d¾k¼«Èp~Š„N§²ãñll—ß9¦"^š®VÆ9 âͬ;Û¸T¢î3ÙÕlL1cÌïŽ_Ö +¨M‚¸?y2R8ü:÷|iiW�´î'ìXC²”ÈÀÍ ì £ÔÙ`Ó½·Yž´°±¢pé ˆ€IîGèç>jÙ¸*5mó é.j_·*—¼*0#X�”n8gcæué5]=¦*FdÙªN>“›'…´(ZvçëèO^éþRáÍZ“×h½ì.6^¦FT[ËîÄ‘Àû§ÿàØͺ!GúØ�‹¬LÖÒ©å·¬êZ= hµå uòbz:R {[¯Ï9Ëêé8Xî”aé dâ_Cf·—Mh/îËí¸Bµ0¥Û­Œl7¹=Ï&:Ån4t¡ûG¨¯¸]ËIñjÁØÅaÑjþQY•šYÃ~VnÌqÜЇ§e‚vÀþÀzf÷­ß"E'ÓÜ™ö·æ? ,î;°•T¢²¹…^­«|:]äQ4Døà@)÷ç†ïw¨^YæŽgögx×Ó×Ø«Ü]¥ö;ªbðƒ5J„Ï_}{í2~s‹Sù{&¿úM#P‰"ˆ£<Bçg‹üƧ}¿Ù÷o‡òER€ñqb¼®áFž�²a¯ð ßS®Ï=ÝjÕ`­¡¸ž=HpgÔlÐý+¡¨tÛMR„õÜãNóP9•ìV‰Â8±¸²½w¥‡_åéj!S&bŠÝ2K)€Š¸¿¥£˜–‹Õ“‡™loó‚Rü(&Qxç¦wù@,NëÞ^”qt§4HûÙË‘9ӗɧgŠ¬yc»ÝOÎÁ<᧱SuÄæö¥ý?¬ï¼7½Z´–ú}E¡úêÇ;ê,Qx‰Ø G´lò ì&Ó7æ>®ñ[ïÙÅDª¾ãLÏÄÀ[Ìz¾�@§ì>žÚá7„—6{Qu³Téw½L¹¢*I°}ocÈÐkF‚d5ýtƒkÚá8Ÿîþ„âŸ[”7>A¹7GîŒ6B{*Š±ÑÖPœ4$=Z:_>U¿>OePX_`fcai,p¸]#™ü+dXäéHR9A :›œ¹K¨¥·YßtŒWÎM0dµãi(( èˆçäÜ“i¦¢ä)ª['×vßÒ2Ë üPñv+KÅ´ uÒ»Þí‡A4+äïãSÒ,½rybTM¶û×'žðŽÆ`:؆Gô^c1„£hN™XèuÉŽÝQŽq„Ã0Ùíg�nÛ Š éŽ1ónÊëz?Û‰=} ¼òÁ¥‡$ãŽè'4´FíÒ‚³ ŒeLöë/“'™‹â“ÃCdŠ¯Ç½­®IɉÞx¼oÂA7øîB+"Ÿ‘B¼™QØL¾Kï 8ìŸö�¾·FÒÞ%ï‹ÈO–ú´8zDm”[•Ñ¨dŽå¥Ž+®1ûk¬úŽK¡;Zʾ<³ ù{xþÄÝàìF×#²$(Cú> F>rÁÿ¼ô'ŸH'8uL‚hܸ6;U-ûÅ¡¥ÐûŠë"ü w\¥‹t7;šÕÉR9SN÷Vƒ¤dðDÿ'®4y–™sñ3dø]k¨@¡˜pôǧ‡ú†‡‰EäcÆÁúZü­³÷ /ųpYèÀèg õâ&Â^A‹2Á‚°>¹Ùí•– çÜÀ:‹Äô¯]ï²›¹|‡ 3ªôâíRõ‚rEáÚŒœÒ“¡Óì‰ÿæ ðgA™RÁŠÐ"ë� fµE½—.½ÌœbíÕX¹…n*•ˤ½èƒ]­öâ¯Ó9¢”*öÚÅA<mÍ[g?ã•cvžõŽk|˜úbr)¦¹ ÊF‹)ÐS†X6E!ÞWÒÑ€xŸ'¤án?œÏðn–¦ËFÜy„½¨¬|7<öír“÷{WÍ-¬–QádT(L.f0ˆuØ÷½€è@á•CE‚Av8Lì¾Ó$›•Îú‰ £áÁ¹šì`eû:*FóÆó/,9#gÅ‚6Nâ8ÈO*=1íëÉî3b0¿S½ÌVþñ¼ÑèŒ-W¦¥"Ž¾à÷¨b6°!£3¹2¾�rÏ$·$kí<\‚ø˜íe­†3[ÈÝï”až¶¹Fcæøœé¾ P¬¦æ 8ÖÍ Je3ÄLG經Ól©XÒ–ªsœ:hˆrW.;i۵̯!…Ú…{Ô[èÅ3Îo½É#ªw^Z” ¼ÑÌ:ì\f٠˺;õo´©§¥Å$­šõ†ë­ç\oÐt*€úkÞDzªÐ<o¨¡0ZWÎh÷PýˆÐ§iv­a°¸™²Él}ù +-!_ª@:RõV~[jì×Õhí§iSã«°Vü;Œ=oóÜÏ! }-[ÍL°`+?Õ«%Í×Ü'™3…ëhæD‰îd„ŸxL _UÚÏ·Ì" ‡UZý¶£oeU‘^ã,Ž‰æI¹:ôþå R�:ôæ#Ô�’þÓuáL)î Óh‹Ë)Kߎª„»>¸Vé¡0°·8§Mk†Ÿ8é̉¦j‡H%m1ÙçÎp¡»Lã Ù}+Ø æш Â3qvÔÚ¼IWuÆ»xˆ¨–™oyDÉà4PBF‰‡· !n8dfe 8Šbê^®Èﮢ…¿ÔŠöpæÉd£AÃPX}5T§Î ½ß¨tB»-؆͚“ Ü©ºR<£Ìÿbùo'Š$Q¸öל0æE•¥3ÃÌQ.´•ceƒ‡ Ð|åÖPŽ ¾ëÓ ovf Á†u{úÚF«Ç÷ÅÏ×tºøàÕ!K‹ô.Çâ‹ÊWÇLä@yúº^ öG€ÎÁVңȷƒÞ7ûùßñxù1Öþ+ÌLFÐoA®/ž÷iíäA¨µ’Ž+lè{ÚE¡óôY•:Öþ‚»rÂháÀÒm™CØTH‡j½îTçXG¢æ·ü‰õ WÔ…Ý«õíD>Ê ¤‹5I˜f¶EµK€n”ÄR‰lyT½¸á¬ Bpòï¤âÜa‘š.oÓæ´˜;MâR|-Ž‹îÓú)ÄŸp³Ü˜IAJ§šâà§Ââ%Û{”Ó]uaÁuþ§t¤îSÃUê‡?¬#Z±£˜hßýI¤–´SÙ—,Ft}"Ž´ÞrpŽÜ{ãÄëúp Ýoó µÞPÃä–5omm1þ…Ú–õkIL-@E~¬vŸak³~Õ'ý›‚>K|ô%Œ‡,¿GHÚ*–¼ŠîÂG§–÷çEj?EŽ¤È†óè»ó{œâI¡vZbwýzcÛy›¬ ¿ØWYY…™=ºHÛYTgAî²9îtÚ0C_M¦æ„“"ØØøJgž<‡4†°3>äDò`¯é&qžù.Rt×wU”Bë¨F*ȶٞÙ{¾!'yk!•­Þ‡Ò¤ l¸³ezÜÒ~²”íÀzx*’|dàã¬)*Š$]p¥·§<ˆEÈiNõ~¶ÊÎôÅä`{¤<éÀ3ùUœ,HlTÿåA¸ù´Æä�¡`æì* ß —Yº„;Q8w–çÊÚÚ- §Gú6¤Èù‹ý /”Ç4Ú�Ê1gøcƒÅ„F Ÿ.°J5eü®=s¯¬¶Ìgz®Që—[Ê”ÕP«g$}wHô(!¤Ì[p"µ–y àbA\åôìZmŒôèœ ¶´½̨f˜½;¼ü‰³kiaÀÌÀ𸪓½m{ vg¾Ü¤¡@fòl»JºIc¡4ÕŸ½åq{Uˆy§è(WžŸ(‘äW$>V_Ó¯Ô¡Ã0q›§Ø€ –í§•]¨£T]žéÓ}ôaœ¯|9利¬¬-˜-Wô¶;øbÖÚàÇ©ýÔäN²:³Å9~P >í?ŒEóÆ4þ7~“)D˜|1°Ý ôgk©{²±5ç8àäŠ� œ¿AX Ù°QPweÏÚæÄs[€» A”«$÷ûý'Ï…M-ðž«Ý¤­S ÃîØö{×ñŽ– Š¦;³Ú£ î•jžrýœ+ŽªÉØ×E ¶L\#™5ÏìÙÿ8EcXØ«½Üåp<æûjq|ê GJÝË~t§ØÔVº¿¡‰|îí+Ô:ñ\Î^ýÄÈZd½Ñ¦éSV?.gO€Öižµ÷‡©¾ØW9ty,ª¨G¿çu¸Pš/-±ã`NÞŽ_.xдpÇ9"Úª­Ê49„šçö׿q½6d-¨©L ,>f«&£ƒp Š£Ir[™çœg•æñÏ{ªÛСÌóò!‰ÝJàE*ºÏÆs\d™6w„ÿuA‡¾AìË=¬XµmÎA2ÄtÓôwV¡zñÊC4÷Á<W8´pðÜÚÆImÛf#½|œxŽgg®7è,vt¢u0W8ε‘œÀ:È÷ãÙ0N÷µ~õãÅ+^k>wV F7 ZHqd»Î9ˆÀ¾ž’»J—/è"§£ ÃÿRúЇ_¤8‹úmþáäu‹6´ÖêîBÉú‹š:rëv£’}O²òTûðTÿzRINò›V¾Mçå}OˆÈ©G³zãy¢ç\uŽ¥Ó²íœ9˜_<¯ñÄ^ÙÇŽ>Zús6F+"p˜–áVäÜR´w‡ð?‰’®Â•Ý ´ô‡ÞÅr!ZN\ñÂN±í>蟃Ø{=r2Z*ª{Sƒ#Ý‹¼ê]O\BbðRiÑxG;Ó­ÔSàÁM¦V%ÁÑ,®gV7dJºéæ<_~ÚëÏž¦‘…§ÄܣеE„^ 5\”ˆa‚ÔpPC»”¯këßqµbK⽂ "½}?Z¶.:S­ì9xéÄiù“$¸—nc\º”ROE×äœã÷ždš‚_.Ú²¸ú™Ã„Ä7K­UàÝJ j…¨²wº—D<‚¿;$=‡ã¾7§'WÿRÌ ø|xSŸÝ½;t@goxº4 OuáÌr PäåÃ|åO¡±ÎUO à,Ϩ,%XÔóZí‹nžÕ“_%½YOØ VëUF+ Ô²Z‘sA/ß3(|9‚²îñ¥Iáô—ítAßÍ´—ÉûC­ÿ(NÍòL H x§Ä2§ÑÕ™1Ñ8ƒÅâÃœž"žbßÿ“™3pŠ`5 æÐM˜ýy÷íßè| [«“c¤,ÈN•õg´¸¥ÜB ”e<ž}¹s4ùmÖ"œ¡v™^ó Ûêì›Ïë/´¨¾[H»GÇîˆÁýhm=CQ‚Zílž[0¡/ö•Ñ¶wN¢8vØsnó€ØŠÚŠ ÅVÁÈFê‡m4ÚVŒí½èŠ­�ÈDªÊèjΚR'D²Âxê6•|·ØHÁ@§hÛí?–¥sÙ´’ÞÝàŽÊü0•Ìê1¥åƒ¾ûzÇs+²&Çðvóâ—úÜ „tŒq/vžÝ×ÐØ×Sà¥géyùmƒÒC‘³bÄÜc¤Ü[«ÔH\ª=‚÷syÓ>êÔDê]ŠÜ,*#f=ž¼e`zœÖÿê¥õÊÞ²ìÍŒ°×³¦¸!~gm™wrªO@1 1á]©/[¨>ó‘Á,®wYl²fÕŠªFϽ÷¼§Ü¶Ó—eg×âÐ"cÂÖUô“§ú¸Ô® „^Y/ñÕ•ŒöæRPjcéV@œ ”°EcúÂ)+3÷ض7¿Ø\èn?°]`’½i²p­‰™©¿¾B× #9aØKkÈ(|eiÂ= $v,s»ÆP5ÉŠ12ÂF‹é)ýÃúÒ‹ayô=¥V¶eµ=^ÌÜ-pÉ·eè;…„®Ïiõ;˜ÜÒûÓ§ûÊhÅöô9Y÷ôÅÜ,^ù-TnuDA¹Sª3>ÚÊò«—3æ%°Ö’H2£§Pÿܖt }®¿8u²üfˆØð¤Ùë Øsüé¿\ý§HìàHàÃXЭë=üdÚ­4µ¬7i>ß™«äIæS™ÁÕ¦%³Ú ž0ĺ:M-¤¬nðÂ0£Ò×ÖÿŒÞ‡µÅ<·$½eN»l1kM!}ÔES*(è# qIó,T1}x(2nšñ–�_QcµsOÍ`þ0ù±&°Ç«D/òœ"_Ø=dÇTϳ5h Þ³AÇÐÇéÑ{AÒk?'î ”w<®?·I‹ñ�T»ñŸ’8´÷vÛ„ ÞÞçycöf·Âµ‘û‹ZWdÈÚÔ @{,:nzÆBžâíÂcž/'»áõm©xœ=Â&]N�A—mZŠ¥ø;m_>¶gıåO^_!%P³è°)ÚÞÕD[^ŠÜË2]’3=ø;]¶Ìe +!PÀq2nm02NÁk Cv"û1AÙ¼½z Ïh³Y’¥™ï°%|]ÒÎæÌżU?u)­¸¨‘P?v{nƒÛ‹e"¤Ýì=V~f³ëtøqÈRææþ•Ïµ',*™jצtT[mvJÀå¾jíÐ;°:à QøŸ¬´¬'±@>$H°U`¡¦$1Ó´~(µ÷`6TÈ‹)Žžw¿@CÛ¼ÎÂÇ»‰öanùì²uZ.4Ê~퇡úyŽµ)R¿ÏL–}Ø#Û-E¯ÌÈy˜®þ»úŽŠú4Ãke�p÷V2¤ýAÚTÝ8®%Ì¥Ö@8Ð&DøûÞ½C²†ª«FÝbÍŒP…Ä¿Ë¢ø1ÁœÅìI‚G^‚Y¨Ø§ú¥‰æ,Ñz¶P'DÚŽ‚Äyˆ¯$”¢i±±ïì™ %CÉ¿’X‘øb°“/þ ΕØEî] Tÿæ•Âd tÎ÷Ýt©ê=´¤´*¼†ˆJ5µå>YÿPžZÂe¥‡Åùã4ŒÖ'ùìb¢ûuÛjsºI©Ö‚ E¸Ù8)mi²ýjBê¨JVí³¢ý?úÖ(Q«3“5/fPüø,… :°’=̵¦Ê† °+òº ~¼¢½ïðkÚg(Ü1ö´wd•›scî)…É­ñ|ÕqïÑÏ™BŒ!˜rºçøÿ³Õ·môßùÝ#¤X¸˜Ãó«*ƒÄjÀ—ìX:0³xƒû·3‡}*ðÍãè€cY뤕F“S”ÎÀ…oè$N7Ê„D׶]}ìØÐp¢ÿ)?I¡jæ=Ö/ ÿ%i*þP‡oK;‰(]Û€Z?NËL’Ãö»­±õ¶WǤ5-¥¬þQö梆4°?*Y1;´n‚h²À×ÝÜZ«)Ñzj)„Ü€a××¾ÛÒ¡ô.i3ÍLã—•I%u…È‚=ÛBà�@¾®ÏÒKsWÏS©l¥ŽBϾ³i$o&,Z[ ç!›jNf£Öm7´Ï@~¡åo¥fú=€ÌwŸ^k·¥"YúfÛÒÝ e³ 6moE® ŠóE…@YQYµqj@ú¤~ÏM¶'ŠX!€Ev€B‡{¿woüf�ó„è¥cÜu”±„íÍxÚ7VH‹ ;õo4P䤧{ò® èßÒÿ\_qR¸®£Œ©…ø£ãÜk3Ž4ëúÿ„ýç\#ãr7}Q»û6m< ¶ÿ4t’ö”“Zýé’* c¿ �}jÑÊ´}üC8Q“”¿shgVG}špe…g"•ƒ1[YûÛ‹Ñp,h)aÕz±UÏÙÂ,[xbåÁmý©sã²ÌT›ƒN ®ß}¡”]),O[ú|³5ØÊQRŸ]I,¼%œV÷®®OíÈ¿Á Ìw�[B>ˆË,÷ëMêQUÑžœDKY|ä,‡{yá!'áœjLå¿Ož® ˆŠrêðè ÁðôcnéÓã;rSI±¬=.Úéx jh±×­õö~b¶‹[IãYî s¸ÈëaÇ8öXt¤˜gÏ1Á·ï¯œŠÃ"uC¾WSO(¬Fmï2ÊìßÓØ~ 'a´%åÕ«·i$QØíè¹:°p”©þ±J ¿�íF 3 *FzÊ”\½˜g‚‚±`:ä;hªu{çÿø¶£ŒŠ“†êHàq$Ì–Š·® /[O‡ž½o™Ð—NÎ.d f§q¿ñš(T» æ_¨[±l‡àN1Þr“l㮨Дé•@kÓS&”5ÿºkSõ“­Ÿ„Z,ˆÏÝ Çó½_IOò ê �•øÂR̉?þP ^Y2-úŠ‚}Ø3e <$kö %ÇÖ„^.}åJëXQ…Ñ¿ž‘ß7ϧÅÈ ÛcÅùØ,«W¤Qîâ^ÒÌQg3l€SM륲6ka¼™ hªëÜE[uwñÎá*ô5¬ °D¾ï½RH#vN1Ö U?K’g.žSL³Ð5ú8ch`É0UžB ýçxFÙe> ½÷PÍ(ãÏy¿Î–/7°?1mì6ž:ø¡j¶¬`Q¡K=¼'Ævý³F·ÐŠ luä�ºÚ«ú»¬cåÿÀ:±w"SÖÍ�5Æf#ü7õCõ7 cÓˆiÚœn~uQ§Ñ’É:3§Ã&kýjM]#±Üp?Yré³xc»è_D?!ƒx$ß³óz^RÜ–¤…¡(¥·l6Uý~†…ð¡fÒÀϹ̺É;¶„º¨‰øËÐï¾ÀÔ �"ÞöÆÙ»à£.ð¸7,Î U·ÁŠ}mû®‚¶X¤ß“×>†ì‰ÕøP‘¿G¯Àùæ©w€iŸËÚšËÐ[Rý7YÕ‡e¯ˆ ³VîØ–®4‰yÚáòSå —£6ñ\`–ïý¾aú;πє“¹ö¸!F ƒ¥a®ÉCyyD ¹åoð|ÖcäŽM (WÂÔ齫ÔîË×ÛÝV—÷,ÇGXm¿No…%èp«Âð—+û¦ô‘÷ê·Ìå4q·ÇÆyƒÏ\»Ä¦¸&5 éô3ãQsu¦Ý¢ƒükJe’.©xë,È'-¡wùàäѶœ&&ûþˆCê«?Í"ùðb˜šxƒZ棜7tãÒzöà#Î3ÇÄ�©ýM÷ïñwò¦ âÅÕuìÙµÅ+êÐJ_2Ëh>Rõ*€-z)Çþ|1ÿ4aÑú»Òc®ÑfyÉÈÊTœ¿ä–¦ÿ¾Ÿ„Wô^ ·ÈC G×áÒY•é/k¯ N©O°îÚñKø.Ëuõ,X 7:Ë‚‰*)ðÜœç£QÅ_Þˆ¼³ÄèÌ ø÷"dº˜¶ W€[õ¥u“ ¯:•(|ãÌRiÄzÒi°²ˆ¼87oß9„ P°ŽX&ï¡š´Mf¥¥tG }§3Fdet a„¹7»óƒòX•¿çÚ/ÏO¼DedTÚí™–}ùm™ i KÃTi­a{Þ(í…‘i¯˜¼)žå˪¹YVÏ=©AlãUˆAQ‘PTZÖ ÕšbØÚ¶NUÎj:µÿrº7QÌÄÜÍ«ÝG·¬]ÿÆ8õ² ”˜_@[VŸž#ß´Þ)µ3Úê‹óGª÷ðw¸ÈÃo¯Í — �òÐ",š^!¼ÞvÊNàËý–6úÀ¤ð¦!'¤ ¬†ž¯+sì{@ÏtˆsÕp~=·/ 2�W¸¡.ôñGï)oG¤ø ç´ƒëÓ|àþDê22‰ Ã“€Njcó¥óúKî!¸íj‚îäöO¨yëÏjSœFòW_ ÜÊMd}±; USPÕímÛ¤ŸJë¼ygq[zv­ùçßp±ÔÑ`ò Aq[yä/H<·ól5ß—ÂM¿øÑW âæ=[f$A6馈©7§®öO›pÚÏ°æ—/¹´x6²Û=ì¬C)Zµûþ߫ƒ ­™?UÆe‘sûøIÎèÙ¨dø¶Œ_úç#²†´rdj¢Õop(a±8!úOaÊŠù–S2Ÿš£âõüàaºZ ÇAOAzÕùý:œÖ–aa>Ä}Ö³‡A Cƒl`$û0û‡W[óIò›æ\á±ïY¨KX–Ó¼+ãœOc;WPl}ÓO©(]û’á’ç$ˆGÍAâØð¾ŒG33×hx5¿~hñ{MÀb�ÆXŦS?NÀÙ´ª†[/íÅ(BË 2R?+³D™,#àÇžâ±Ö”𸲠nf×­ÂÚê. ד’ÿÌâ~übbmup;‡Ü_WqîGuÕ….æó‹Õ¹Gq1ÞTã÷I�ÆúºÀG… ~\tЃb¥¦ÝÎÃ|ÔÐvSϺÿ¡¦x•Ó§õ ´ç8Èœ¢\È઩.÷žG+ß™éãP·\Ù´£ÙÙ}¨m–{ “�Íó^¥WxÜ»E DÓÆ©+gÌÖ]eh˜l† ñ¾¢¢ïÂÕätI)››¶`<aÒd›$XfaQ–ŽdÊïû¶blDbº¨ÛÏ‹¹ºŒ%n›Ã YîÍ/(j›Kù {î°1Š—hûåF RŠHìù-¹’é<ìP*–z&ìÈ,&Ê’ZÕI­Ûêt8R"f�RYøñßܘ=$…u°rFµ/ÔünÕý’ÈÉîqñÔyƲËny®ºLŠ/I%úX]c&̺¢(\È÷İǦêßó�ÅÓ´g¥VÎl‚ÍH%à–&=q_43ðM:„*E¬Á¹Ã/dk÷”x(ºµ=äøe§!Vèý*7’¾» iŠ(ä¯Ì-.ô÷ Q9_½Üá.–Î%·Ä×êN´ÝÛ^Í6iuíÿ6;Åó—ÌLMÙPŸþýÿ7X:Þ°“‹£©-‚Ä.¸"®ºvéßE>”®rcÔ˜,®šOƒý�˜âL±Sô(FCi`¨H¨Å¿±Å{2‹aéù‘†¦ že£° Šlt7©ß“îw˜ž¥ Ç%JßêŽ^Ó³e†I?n¹ÏHžv\¢z_  ÁløtÜñY¬ô¼â1\Ùß³‘À_Xtå ô ë"X}[›hŠL¬G¡è·c×CÝ«%½"²¬dñI)Mȃ°ýô:øq¢ƒ²à®ÑP·Ÿ{¹„«ÜyîðÉà<­Yho<öž£FwÜ̧‰kk@†ÿ[_þKqCŸ]£ìgögc¼{¿¼²P‘l¼Ï(˜œuT ƒt¿ÌV[{ºp³ÄçZ\ LïŒF:—0NÃ`]çA:Œ^Nêd=Õõ¶3†+pÍ ÖÆ·B-4aÈN:D+xŠ|Z·Fªÿu¢à(L2ÙÊIJ ùtsÊ}´Ýþߪ¶$¹w Óª:? x‡''ì'ÚöôÌ%h¿’í.½é'DÁ1ý¤º×Êc�qÆ0Ó§ Tµ,¼1ü,#ÛY‚Hm¬ÇœE®]©No6Z•L5 4óc¾CîxªÂìê¦$ˆ¬‰×A@ª×óôÞè¿û¢y<†XWtGÁàs¿9Înwܨ¸š WQRÄ¡™BŠ?ÒÜ»íé‚ ;|™æó…›6\F!+ÜìQŽ@&�®ÜÕ†îƾoNôG÷”�#% jÊÇþcSGÿ½ $m³ßÂ|Õ»Dç¤4™~iÎä`a†E•ÜÚ4M¬²¨²»Þ¥y…ž53.ÇðГÎÓ«Ó|:ô]Kù×d:”"ZaÄÐDú‹É½"Õg<(À`T  :[s·í>˜)…0›ûÊŸ¥Ä ™%ÐÒæÛs,>TÕ<G%hž]ýú¯T†˜vÑÊ Ý#¶2‡4ùƨZKÍ;Ÿy¨%«t!}–QBG_¾û6UoÝéãaX{új-Åõµ ’eúª2¸ÒÙ¤Àç“ÙuÊÇ|+k ó•ÏÍ@Ð¥Ú/ﮬ¾$-L„b†í¯YžÔ¶sªÆÄ·[¶ò¸gt6rX éUÔŽ.`ó ÐèÍdyB]ØYÅŒÒxy° ÖþùŸùtN—;3mÏö‡*·h§¨»H¦¤½oÍR†Ád/ŒÉ ƒå2ú4¦Œu§KzÇvçDµ(kC<’)nËr)3R£{Gå=wh†PÚwy5ªõ«ðŸùܺ¹–ÅùÆXêœDc¦žhßZºL\¨ÑÃpmòöû=÷ʱóðùBOgÆþéÉÈxÈÂ_™¶æ +öMõ¶Ð‘kÏž0þcÇ(QÄ£»xC7ĺ`Šv<E¼Í%ŠÁês|f”)̸ôžc¯ïÝkÄ" ê&¢š ©Ü™|¬fk´ø… ¾cb¹x—÷Z;¹}mèÉFírÌFŒƒ[BuÛ4ÕItØŠþÍÛBì¹ÇÓdÕSøi%ÿKg‚±ñŒ=Û¬_hi€ WF&k®¨€ôvwmÛñ”krÎÀ¹%™ ˜-Oÿ=^^ÆUƒiK7=åÓV¥—ŽŠó¾7n\"®kfj¬ÐŽ3Üuwuobëö;û²QљŮõgpt8ù,ï—Bü±k{‹£*÷C¢Ë·ÓVhŽ'FZhSþQ;ÄìSãþzÞÐ}¨[ÃCºÔMÜ:Ø 5õ /¥v3Vëùb I<ß�N‚¶':¥³ÚsAeöÒû–f(Ï\¤ø¢‡&ö°×…Û ìÝMXúV=!Isø9ÞP)£•²DP|·7rb &ˆæ’Q>U÷ãeF_ûQ5ÔøÝ™Wçê-³J^•ceæ÷oaÒ;ò­†r(Fó†D` ê‹s)BùÜ_dÍßÑÿq*”‘©Ë°&ËÓɃ˜SÀÑÃÔz–¢ÕoO  ­îCÏÁ H ×~ R÷ =v–mwq%†aa± /Ó$8Op󬻯jÈm®]a±‡Ù•&ª;#ÑųQÀœq)Iö•1 Õ>}´`Â%‰a§è¥"õ-ï­äVÛqÀXd‚ÛÀùF…:4žó¾ …ʲ·Ð3ôöë=…E&ɽ¶?‹z¹W¯`•®Ì熙M£×ø1ΚS¦Ý—òÃÒ`¹`÷QÚ°þCÑp«¸8‰  ‰ÃÑâº^[=e!T&È$ÀénO)}Þmã\`!…3ZJí¦Ã±{cûjgõÖ(y}�ø㬵a¨þ‹ (H×Vrn¡¥—:þ´ó9?£oO‰xDõÿÖÄG.+Í"¯òØÑ=hÀBínc(:˜°Îljvqæð—µàw,3â4O <°g¨°m9Xä~²­KùKæzý¢F¾ûËÇ­#£¶b‡cHй´o~Grºkrì3 ù¬<"Œ&£ö\2|v¿}»5y; ŽµõŠÉÅÔ¸Sx¼44¥´ýCµ¥j6Ñõë­ódfbG3ƒ][ëÇþjûÅ%¤ÙðµГ˜æÓ¨BP’«ÞûÕ}_GÇíÊ VkºPJ9|{J®&0Ž§3aó"Gš7Z[Ú²{ú:Âišá“Q+O‚ojš•º#Žç´»è«A†´À¹jäb<"¹:#œà”‚Ñë1 V'+ÚÀ-êV-œ^Çq0(8wõÞšøEa„ûs.ƒ¸±F%«šÃžÉrðñÆÂÁ«c#É7Aë;±Å"fJ> E~ > ËÄ/Õ(Ai{ôuíd¨9{9+d­2 “•Yc¼†»ócÈS×=+ýþ4¶qoõã'6íšþù _§!¥OpúÌ¢hö;¾e©<ªÐŒëajVVö,ä@AÉ)åDÕØþºše‰•˜©ÆC cÝ …Åt¥æÎwOöFÇ7Øâ3ìÌH›zkû’H*$3ô»¢ÝÍGÃxÚ²¹íYÞ×ÙJ¤0òPû>uÑÔžë¨ržcü­YXÞåaµÂ,2cg°B³8 ’J â þ ”È I…ŠÅ NuTÿNÇ8òìÅq\æF¬m«yj*÷c[5{Z<¶Gû@¥Í‘"RÚf°`vÊä ­ ƒ.A©rôŸÆ{îú¾&žÊ+ÎÜL ^+ Èr_¹#yJ x4 òz}q2k‰iLômÄ»ÙɬªÓÞ�8Nˆ彫Ûd‹P‹Œ£Ð¹‚ÄÚ‰&, .`nIw{Œø.ꈺ‡ô‡üó¾ŠJ²òmã(.¬òôÝ»£……(zRrïGÐ3ZG:Œ¤+ù Z²ƒR‘ 7ù’xí@ dœ²!K™D¾–ÿ—ú/®p#w±¨\ù¹-ò¡¥/r±0„D¶<§QÎ’A,5žsÀÂlÉû£Ã+ŽïFYÈúl?Í&õ š¸y&[Ç�Qºãú7 ²ykµ 57‘šÇXUw¥�ÿHÞœÅÚ1ZEœ¾ãɳPiö<¡–Ut›¹iþ–• 46rà5R§ZsI2z?¿œÒDNîL¼AÖhظP²7EmÄ.«û²"I“ÕÒ`ÊéË϶ñCÿ2hlyv>jž ó\œ¹¸=óÒÂY¶³õÍá cÄR‡SG®±·<ÑñxîÍ<ý7ý×…u4¿ú^Ô¶aÍ–öl_‡éðE(m¯¬3*Ê,�øHMÙzÉ„:;¥k]c…o¤P^®Idj–püX¦2ÊÌò‰B£’}9²Å‘z´ÑCû<îúÉœ§®9„|‹nÿd#}ð7.+–—›AŇDÅÖT\™XBu­Ù²~¼|5³hå=bZõ»-¼ìgÏËž œ˜Êi÷ËO2“è<dðR#Šn«á~«WSp+Z-”¨th%™¯»rJÆð趂‹½Á{`Ÿ›4XYæ]ÄöLÓ*V-î,·Ãz1óÄ(1)º2H="1÷ק¯2H¬Ñ´n@¯Ú÷Šyºð¡¢Ë]K7.B,ìÚ±´zÖéû‰g©óàry–ç¥'Àב¬ ÂÏA;z+hì]ºã(õI'züúúg“¨¬¶øÇê€/²„}N‚é?öؽ¿‚-Ä©ï‡ÿi&’XÎO åÇ`«¦ç”a�^ó1ñG½5ÍÓ‰€A6:å!ë™V¢q±Œ@âø†é=ÐGš8›N9Ôi;ü âOëP–F.I¡`‚¨îø5^˜ylC® §6£Š¾³G<Nû‘­Äîì´Çº8ö¦È<dï`^)#gº¬+®L¹¾þ�1èr¶ p8®—HöØm<¹a,U”Oš–£¡r�(Èq·Î‡·EŠ,é½&¦dC"=unØÄ ý´……|;‚öàš©Xa™Z“yœô�#$ôÞâÈ*`îØó}²‡}uB^½«Î>$á9¤;V17i¤B0«+)Ïê!˜mzè<ñ…Pž,ÊX"Úžœß}ÆÍlð›ª5Co_­GßÌ0h)Õ¥êèÊÁ%O} ®œrn:ÇvG:þlŠÅƒn]÷ËžÞ«¥Îăd½¢ÝU´Ÿ&ƒ?ýLI.}À=VOÕ34ƒÉ5xžÌˆmm-°üÙ×A[éžp¯½ý€ËAN>¦×¼›2šrÌ£»”Pè¡•ôyæØMŸº–!(ëô[ÜÖ+H[çޯΗñZˆú:¢EUZëe\)áC{Nà’“¿Ü´–6d$®3Ã¥ž{ {¦ã={3«u+#Þ Eo¬=;š™5­Ù‚îšÕïâ þø3£~5û�°k9–ÝÕ­§¾cý°éôòãCç&BnjKYo7½Yº$qäbi¬üU·S2òjå±óø+ÆGøŸÜë±ÿ^¯âT{ZÒá†[Ò³Ñd²òg‰Àù5§tØ”10Ü¢Íñ8˜Ö`ŒZïñµßlʇÞ�qÊqë5PvÕ…»SF7ê•j@•ž&tšÁ‰¨.žâƒ¥(HQñRB'ÊÓ…(OÔ”Gsg=¥U(ê§úBG3fiïQk©L^(U¤A×_Zã‚7ö¶£q«m}Q†ÕH!ÂL8!ò;qÛnш3‹zQÝ©¥ÜÖêgbqÎãý%QîÑ}]—*5ÔõŸ2ˆG-G¹w$^©Á´¯'ë\³kÛáœÙŸ*ðFÿ;úÀ_Lé »RMcðFñÄuÜ2b´¥@n2�vÀ:¬×rŸYØV®Á¼ïLÿÿ±Ì‡›Å„FÇeêó ¯¿iM·æì\6ŒZÆÍqWod¶vÊ̱>î�’¶æÒö"œ| Ý!iŸco°ž¨ Kê¨+6eŒEÊw;÷7Öt R²á%)ô}ÿ�‘Ì@±è=ÿ“êÇ)`Au©gsg™´pSéq;" —Ú‚bWIÑL1Z¨ßùÓ Þ,Y«Zk©³R^ì7YÁÉ¡­T OõàŸ$6¹ƒÙˆz:C6àé êð?åõ‰Â‰gÓ9ÎøF<aÞÉ6 ÏN,Ÿ%ªY’¾µ|Ð؆VÊš†µhÞb©2ðÕ²´1-�¥È˜¹Düî´à'«¹½i&nVü²ƒ·RµÍw¶'|öA3(–]?ŽÊ“Ù‚PÊÎ{W¯S¾¢6 MKçž%–GÞ>U=í`ß¡k LÈmÚ:ã1$¦³ô{Ex †Vù}uã—u”·¤Mã¥uµãò4…$­À •ô1}óN%6tƒó{‘Â9žê ŽúrwNY:\ h3±¥ÔjظÒÀØÃkCßpöýÇ–nfÕ-N“="vj® xÕï_äFÁ-§@o…0VPS©„eÈA- !OÿÙåï¨öEáÑY˜y6 *4Õ” ƒÏv<MtÛMj9} ý2 æ(4ÏäQÃ<Zyp5=‰®ws ìÒj¼LVÚšÞ‡[V¿è†*J(Zp|¡|Ü«U2Ƨ=OT©88y-ŽIí}²Õs†\ß³È|F8rŸ.ñ̘ØŠ…³"Lû'%ׯ| ‹M³ìðû¿ög…™'­qדç`HA;zºJõqlÕ4ù ¼%N¯d‘‡6.‚UeK÷¬01”çH5ƒâ©Š—«87<5kˆÔ! Ñ° S£ha•eÄÎT:èq·ØrÉC·[ŸË ß´¦A�=»iß±s¥…[z3µ \úÝüJ>Êý®&E³õ& ’o=2b�{§YÙ•ïÊg3꾞Vñ©}ØÝ?]óÏG~Ç·­D ³ÅÓÆO« ¨OÚ'-TÑ€Òª¯ <áÌíÿí¨=t6ÃÒ EÎ*î5½‹#!¶#°æ¼KÎ*\¥VxÝÌ`HÙµ–}èåoC»VÝ^=<º¾=Q¢¥ƒ)­­qK»-j”®†îÓAÝmEiSÏs!½RK—›_x£V1Ò¦Í}wÌ4.©ôù�5dW.aá1FBU©-cõ/œk"u&5²9 wóí¹&òùÂõFM»"htØ_¬%&ÁÜî·†ëØ«8)#óæ,Ns4µ¢Hâ*p¼ ËâŦíõõC0³WìŒÐÙ‚§êa–³³X±€'ÑZý~üš-êvgÜ«_°ê/Ðà÷Ú.ï3CM²¬ Ns°ù·u†{Ún<Õ ÉYþÁ¾Áþ1ÏtùUºÊn-q^ؘ)Ó‡‰'l»Ú†ý˜»m=£Fec~Z¸WS!ƧŒßuKJeŒ1v~s²ÍyèÎ{õyY4æsSÆqiT :Ji#ZN Ñ8NJò|õå…pr¼òå¢W1­æ$(OŸÖ|V9b̳rØ_yœhÝûÝ bcuÒw[ÊHP=>£¤~è‹£PWm;|:$ÌV.K•&ÿ–¢l4(P�7ضl³âÚ{+“÷–n˜y6š9êÓý£´óÆ ¶-ÜTn“ôCïèpHu}m#­bY"Çžl—&Aj­å«Ñ“¯¦Ê³÷ôj»]…*ŠŠ"å ý}~d$eê³âö­Ü´­ …âžV¹™"J&¤ßáµ”H9+ôm‘r[†<7OWò{EjqýŽ¿KaÈÊ;è…n<ë[Êy׌,ТžÞ¤UòU» [µþ{©×f¹=¬d³Óöªh€|²àB=×iZ0VsA„9âæÑÿ¬úÀ»eqžúÓâU0]BQ)q"­»ËÖP½Î=ݪóe2ÿá|åiÒ±FN›b{ñü9ä·}cÉ”Šaà,UûsIº7CñvH0Y½½’™ö…M (m¾tÜ-x{,•f±Å�¢±ˆ$ýO[Ìà`ü>›•¹<8Ârr{‡yèU1çtA¶¾Š5Ô_BVwU}ñ¤Ô¯~vdÉlå¹6 .l Ê]•çVЧ= >_šêarlÚòÇ'^1ì iÎe®&5ÊÖ-vA-NFBÿ}g”(†[¸­ ÁÖ˜`=a«¢œ«¢=UQ6‚ª)Ñ~2¦(ËŸøxWn-½œ¶Paê–ydç­’ƒÝ™½]à pËxéïê¤à§ŽÔƒv6¾å¿‚²=vÉÞ(ÒÓiö0¾¾^鬒±)m/ªÐ,ÀùKë˜êy{œ„b÷·'d˜{Þ´1{h`¦5bóŠÿ~DÆ1¬°Œ–ÛÿÞd¿ôd~ F–~Ñ—ŒN%XG¬æT.Jó®_…eKã¡œ°„ö¯c¡·’Nõ~Ú‡5Ò|¥®®€î›K—ùlšPN2ûE÷Ó. Óeq×=;ÃL;€2¤”ÿÁZ7õM°ržlYØSÉbߧ½ô¸Ð×óŒðíŽUf*•«|NvêÔ™áÚ4°}TúE7¬a9ÆËô]ØXÅá…I¨XàÝCkÅŽëŵ6ûoÅ …"ÂÁães÷è­ ~Ökéî¤ãi^XÖ1õ”…Œ8Īª7v¦˜Õ¾zNÓh.W•+y²ÇŽô¹§¬Â`8E]ë©#c!®‘Í6æÛ–A‰4ccÀŽäÓº®ig+ÚùIdké1S¥y솋ñ$Kä†ôb1q*‹-ïO#i‘s瑱 ÚzÜÒ͘ugŒõ^á ü¾¶8Dc&•õx‚ tÕ ÞÒr¼_N‚âØ"c×QQËÐà'·jèéýùrW#ÿ¡dF˜Æ†Mh\ìÓ€‹ÝorC\¯½µt{hÅQ¤W^†;ÜøЂ—“TÁð¶üq¾ˆLøâ}½Õ7sj͹%D§A1zÀ†2wT-ÌEe©ÁÕ|J‚NýB–½q÷Cä½"¢ü`åk¼Oê‘Þõ›ô«ˆxá~˜¤ŸÌRê;/ÁMJ׺`¹Çù;Âï“gpµ;ZI–„¸ÈA×<þõÉ0Ëý68¬PY;m°;8‚[Ú¼×(sô˜y÷εÅnã]Þäqfu¤³°ÞP‘[ø${.ý’Šj›Ë°f!qÅ…óÈ€ßÅA2z„£3 ‘ƒÞ,)À™ÀQN0[dÛyæSX#ƒÖ=Sºù£AÜÒàž½ÎzžëÜ/†0¡vC¤;%n¼ÙoP"‰»–ÖrtEèÜ ,ðt¸­-þ“}-)fŒ[ þ:-SÓ×gx›á\~é"‡‘= Ä6oè(^$ó§Ý`¢B¶>Ñ;Az•…oöÅðu ®ñD+N).Yjz‹Ç}??ǵ¡§ùµ20ý~;¥ÕfY‹²šo3Aù=wªh—šœÊ›Gäž\23á¶ÈÑâVÛaȟμ2:KÂ¥<Ýk>¤Ï&ƒ^ ÃodÏÂ2¶a * Ög ”?=n¬* pWý1‰�çö…Dêùže,ñ 6WÑ+ç`›‘–øÞ1"|Q)|c…„IjNiòú9Y«XeÈ=¢¤CÒÔCŽš¬éþŠ7›zpNÅÏ ,=Ôîò ´‹é3-xÆL·˜á_?k,Ïæ”}¿Âæ[E­ {´iÇÞ³Ð{ X*×±oÇ-ãÙ9¼u|o¦Û±À[‚Piš¢•QŒØRÂÒk׳Œ/œ³Öó½–aéøu‚œ—âd»õ+6Ù±Ò¹.M®F=g‹j[¡äážÝ8nõˆQ—ÕÜ'æZ÷¿ç–Y. H Ÿ‘’JªTFmKÁSÞ‹ëÆí™ö'à“¾H"ËdåaMà:Õ§5ôM·Fœy)f”Öìë·¥JÒrQuet¦Ð Z|6N}q+@/YSô6¬“ÌcÇšS7¿¡Êœq?tÚ»ÍL‡~8ÆQí*«R‰U³‚ÏãPeéí¿’j‚E*©LžüKövEÞÕO>q:5p‡¹‡HaW;Ô#§3ó5]"Ü*NxX‹lBKš»"îÊpF#•íZ+PsÇ$(/ŸÎ!Œ}å&;;åu—Ò¦ )ƒÍ¯xð5|­Ï1‚_Ó¢¯ÉÁèJ•Kò²ëáþo~´Ð›¦Ñ¢ÕmÅ&‹Ò(&Xûòû/…C”°ŸPзiUƒÇ¿3Œï96­è«ýeÇ’«Õ÷—‡|áø¯n?xA¶'°øÓrÄ÷|Ô‡º›’IRCA$¶­Å0g;¬®©ú»´'ú¨NëVz]_3:åìÑp‡¸¨2ßåqòO¾ -Ó|,hŠ)6 &`—A>¡ò4㌞6G"VZ3xëæ»üQôõ¤cçq B¿;Ï¢âM$qc)s€ñaŠÜúŒ9Šbˆ?š#½%U„VUÑxK\"…¼o6Èâiyˆ·û Ø‹ò²ì̧N¡LúÚë9J‹§Ž3fã÷c²ê꬈£ºÞ5m‚žÙ„6®™é*Ô‚™Åvvê"ŽÂª=v—i{ÙTcܾ§µã`i´ç-ÅçÞ6û!ÃÄå Q€DÜÇ¥ºM¨“Hx¹Þ°inÞdw9BÄÇRï KÝŸzÁ[ɽ¸¯ÝéxE‘éAô”ÉZCÖ“vVÓu¢ ¯²ÒøÊ7onh—„»“'+kæ—Ú›k9ÇGÓùLÇÝ›¿â$…P\sš9±Nµ`vUNj`-ÍØŠMÎÂåê=Ë«Øi(ËVmZô†Z[è%¦_'v,*Jé1]¿q/ÊN­Œë¡ ¢û׳ZÒ¾¹‰jZ#—Þoî=‚÷ä®»‰¨_°ž|ÜŸ¼’ßXš?\iÉßüâµ ¥–i¤»Ù·NÏ,îv‚ŠmËŽû ײgÙA1,X3››^aŽÅJò˜+ »ã!–<ãŠã÷Š˜–jþ»>A8[+‰ŠÁ­td)Ój.\EVûßÆŽsJÏa#e:{_Yðia’Ï.l‚¶ú‚Í$=V}º0~? ;$š(Š‚ Í¥ V?•× “‰ýd­—N£[¸ëæÄV.·âj¡Ï­\±–¼©zÏNx}<è* cܯ«Ë­Pä©$H<ª«8ˆ¬âR¶b1Eº‰$·G> æw¬n%ÿOº³i),Zd€§#DT&;îôû´§£[5T|ŒË;×+§'δ~û6Pšçíªi¢Z‰ñm£áÖ»ÄIS·ë¯Û0§NÞY`NÁùwã…`” ¾g+´í\u?Ö'µ•BºÇ@Œ ;Úʉ±má픵¹ŸÉ¿¢ïZñ삳ã(yû¢‰S‡(p:£é•÷ÖW ];, µåí–—òV"Íë®j£ÕúX%·}¡7¤[Ã,µ†´2Ï:JœòïÞóbiGNæ anкêôÁ..é/{|›‡níX²dÊr(Ãeh®{úÿõ SIïR¯–Öð±óÓÖ}?Ò=NÇÞóYäsÇ6×Õžx —(Gðã ¸½>š>–h ­9'è Њƒ¬·<Fï]Yrîõ÷ wc ­*~À¹íýŸ87uw ³p qØUb®ð˜pGþ’žÀî'õäl3‹” BÛ™é>€Ê< ¼ÝU¹×4HĹŽ6U3hPX1s�Æ vÕ,ìèþÚÅ.u¨E1àZ׋QÄÖ†ÂQÃ~þØœFº[605Ç›yìÑ‘õô|â©öø2¦ãbž9ÞÖôs_zq¡×¢b6ZS^°±æ5‚CÀZwî?»ÓeÉ°ýêgfB-±4£)d%T°‡ Z}ÖÐ;ŽÁï$P£•§\Z&]òÓ{6aGþ”*#\u”H:÷¬'Š²f=]ýèŒ`MWml;ºí?³£æøhÖtÿ NÙÞÃýËkñÏ03­ß®¥-QéÖk )ŬÝè^ùZ½öß«‡¡EݻœÖë[ˆ®Ì*|Kͤ¡X´ûÝ7§þp<',à%áðæ âq}¢õÙÛÆ;4GÖ'ÌíŽÚ4x¨kT,lášEKqõmåëWFÝw-;YlÅæod‡œœ7l8EJ,ô:/¹Ñ3ºøÿKšädu3Ãa\ïbªƒ¬‡b†><ÕT^„ébÐÿ“ÎÅk¶Ä3E.€Ã <¶¾# RœÑ8~Ó¨J™@ad¨]³È†íª‰‘BçéÝ7\ãÆv}¼úÖ hPê2æ”#é D¼Á­Ô9î˜3ãƒçR½Z:úGa�¯ÛúØ­Öð,¸Ë� £ôÌ•£3—¬!½ÇUǼ‘rtÜ×=• £•Ý‰µ3rEn–1î·µÝ]”­ÙHª2É_Iï<…ôM+àq“PßñÆ}ÉW>ë sdŸ§Yrêm(xmP[vJbÒôÚj…å$”ضÕ1òŽuYàÇïŸ"¶òöE˜‰rÏb§Ø%À<®À%Ol81ƒÜ¼<°–¦RçôÕ² jt±Q(¯[…Ùš‹o+X¥5¤}‘§)Ë—`9±Æ8L,æY<hæ)§uÑ™Rà];3ƒ4ŸÜö ÌÈfª HàÉOì@ç#¢B )bäüVÐ4ç>ü<AèÀ‡Æ¼mÕXD~l†¿BnÀÉÄŹ݂ÕE¯‡r–«Ü§C'²Š‹ üTJíp¬Öà×+$ ]-aí¡»ô @’d‰‚W’2>9²T¸ª;©^2EÇõT…¤ö¬ãÂ¥t•Û¤b²áîlwväè5‹mm=õ‡×yQ¼Ð§õ¾ž¡\Ô*8–ÊYzO©±Ìêômκ ÎC°3 G“îv`këÑG ÓW"\o"ð7{Ï¡Íj›™iøkV]äÄrd… Gxºëñ–B»ý³WdÓ$ÎýKÓúÒ[‘#œ¶´Ôfk²±ŠxÙQzŒÜdõ%‘ƒUÜÑ«mÞÔ±+ ›Ä|ØAàHŸábõk¯;hB¨Á:»‰Ak‹Vd¬V<Æv8‘¼=l´ŸªÍf¤Xâ‹<PÍ°>Š 6çs: y'‹5�Fêó<–AYël¨,¬-oÚŒÇý̨)wu¾Ð­´éÎ\(SµdCžê¡õ©w+c:©‰‡^tÙŽûä¾r*îáX.~ïUW\袤’R£ˆ]AÏ[A¯ióÂÕ.¼ZXÞ×å««F-+è|1»Õ^ÜyW Ø 'Š,-}ò’ÑF¡µPûËUA5=ä¶ß÷Ó©«>¦ï¶zÄÎüÍèÝ»vžî¹ƒºšZ+ÁDÇJ|:y´Í~ÁU¦”¹“©¹¸‹˜_ FKªáÌ6zºûi?Y€—;þ ì>rÆõÍ¥qTuÅê,…®¤tYFü‹œã‘ ¢µ/ÅÇe½ù™ß¹Ý™ÆN¸B7#u§= °ì@ºÙ t¦hñnFP£@£Àå™,sDAÀ°'lö¸eý;žƒTã©¿6£‹V¾‰"s”qÒ"îjÛa«Ùèr;™šµ³ÕTz#µêûôèŽ]ÄUm&é1{Þñ‘dB¥ñ[¾Ü×ÞLRýî•òáI—vÕÕûcï3 ÷æ—¦6ý…þ`R¤>n³„{)2IkŽÊ»s¶GÞ=ÇÒ{¿ÃH¾®àÁÅŽ–Öo\êpXj~ª3O5 ilÎi5 ¤e]{õª›Ç¦Rª3¥âBšx|ÏÓ)Õ€€J{Üק£Ð~bIáë…Éq¶Ð.–_<«ÕßûÞ†+“Æ Å‹Õ9hÇÆ•¢(9Uà^²¶Ñe±&+¿ž%ž δAÒ üþ×ó±ª%«Ûn2ËËܵ‡‰Iq÷_´½2;EKL)É•$ 58ü0F¡ÇŠtÈW9¤Š ÝY^S‚&?¨<"R\#ˆŽç›ûºÃU:M-F -í½¸Up>6‚®d÷%"ÿðL<¢ôP^\{T[“/h&À Q©îA½æ´ÑÉ»ô˜äLÈ2NEç×q3eqBjÖõ¹ïcøŃ0p€G³i|êF�{S-Å_9±Åž²ƒ°z¢³…¬Ý‹¡‡Â+2CVºxâ°Ô¡ÜY(ÞÖ„­KŽOÐ ZœIå½Â{{Ùáµ”]sÕùhðÌLž¼¯mY÷ß2è·´½ãSç2‚™ƒUSÙ± Æò‹ Æ4ò¯n&®êÁ °Bn`6Ó¹Õ-}ËDã3u„’Ð=¶y˜GN¬$‘s*§“ÃëØ r1´·0 ‘%Áä©Ö"ýãé}Ñ{ʇ±\ë ê;süF< < +IøiœÖ\TÇÄó-äºH]râÄßz2bÞAwúsWÿ͹«Ã+{Zµèó x·•ÙDã|lGt§ŸjÒ…$ŸTà6Zéßq®æÞ”°±ÛÅ?ýaw¬²SLEæ¶Ö– dÛú㹆fˆ7b7ϸû¿¦¹SVâÖmÝÑÙý©7&f"¯°™¬F×$ˆÒ9†Š¢ÀzΨÊÑL>c¨¾HŠ9[^z¾=–ðÅCoiiŸ—nÐ)-f`3ÇÞK`é¢,ƒ{¬•õ ¹úWM›"È;Í)±iÕvØSÚ~ª»ýÚ÷+ÂKO‰·ŒkÐUy<1*¶Û¬A:Z1\ÇügEÏÕ*Ý_Š Û~H6þÔt,άXÖyïRŠØûˆ¡ÅПwÔz—ÑZÿQÐðlÏ×dæI÷žGÖÏô˜Bχє,”šužÏ¬> hÚúÀ<GG¯{” |xCçPiË<Wë˵Äæ#ëÝÐ,3' ‡½N9M1ÀÓÅñ¢‡&Ü°¾~õ9¸ª¤5Ñÿ~§¢'5\ì*ÅSÇþ˜,–áŽÓ®~s1†©‘¬KYZ"ã–>öVÇÐ%BÞ«Ø(YÚy\¯GâœN¤3ÎVF“)Z#ñgï…sÔ'—¿×±wM~t5¥îõÙYSna ”ÇéÀò|ÈUä|P„Ë3>®EL‰òFÈ`èxšmµ&6cÐ1Åà»è·¤_¬H·ôŠ¨<éò lþ5,µ$?0šÞ¹d0ÍHü»^Gi;5 zŠÆïÔ{ söË°9ñK_C±RÁx ‡–>yØ«]íxb¢£i{w>í)\;ó<2vÒâuWæ$H³Ô×˃]Sá°³ÆVôè¡n7Åîy##.L¤C}|G,Z »´³Ii¼³Ê@OM2ª˜ÙÅÌU o533/6³'dߥÒa2ÂvpTâ¿´9Ó¸"JŒätó¯wþÒJSë:þšf’Å>ï4Šá8Iû[gëªÍÞ£âÈ/dBˆF†28|”:à{OÚ,Á‚á·j!¯lW·-1Þ¦¡-v»˜?˜œ‡ÿ)BÅ’qƒ-„bÌ¢ôÎ(€ VSRÙø7l£¬‚¤ù®0¯¢å9\¼VK{òÔnUïO®¬o¦˜L€¬{ùÚSÅôœï1pQ™¥¾Cdl;”[³NCq öü8×{f÷H²å_ç‰åznsÏ,ö£íäõ.¡ud½˜ ÷Ee̦³É_Vôò6ƒ°¦ÐœkÍ%a½5S+gN°ÙØ¡b†*Ñ#œw¦ Oâ¡AIåndFcœ ¼?ûu¥Š/¡“á²yÃŠè  ŸÑn–hÌÑ3jX­ˆ ÑÅ2—qnïg¡×û欪®èO´;[žT´"ûm·ŸvÌ“×Ï¿ÿ*$[-Hä`Å”`;•Ã#6eEƒŠfµ—ëìs#óFù¥H}D §:d8s¨Áp¯ã~v»x¬? Ð‡Ü�:°¸ËÏÉãÀ#í×-mÙÎéi?‰9ãSkñÂkFe<ê8Pp>½™âúØ÷Ð)ѹʘ—Û6l¶°¦Ê�¿Î‚|ÔŒÂ;[PVzödT(6ŠÚ  [ó¢a;<‰WŽóÇE]FA¾S5n´w•æ\n#ðC“³Ã MÃhÜQ±ø=;ÔšÓ…Ǚ—‘¶”ÏX›Þhdøt*Oe ()±KJ6µ'­ÑU"Í µÊºÎüÊ:)MSߌ  {Œ^š}q¨æ¥KM'ãöd^o•Ò$õ4$¡HÜRÚ�ç+³ óÌ*7D øÛîDkÓ ¢¬®» t8¥ew·½¶Äð(š°Êßž´.ã¹!~‚EÎj WwùÂcsÇ¿aß—ý�Z_½sUWw\SP‘é :M`ïò¾¼_{è7qïs¢ì4Â$¹X'˜LûMäWâ [¶e Œ(ÁÐ!Eg¥“½DâµLiaÛM­z+tŒv¤!J[e¬àK÷§˜F»±Ý²“’A>í¹¡h2É«Ÿ`oîÌN½4¾äTGŸ¹í•¡ž<Œ06Uîá%‡Z¡eîúUCN…D+—¶É0B‹¨RŒDï´°f”¡¾$Øó^_¦… ’ ,ô�z£‰)/Ö Dz¢?–ìbÝ îT¸>==fó†Ê·´ÕL©}ÝU““잌”Sßܹ Å‘™Þvil§%Àé¬HïT,{‡é1®†@¡ª’Àš2î5bÂK‹.Ê·¸àHwùB{ò5ô&‹l ƒÏ1‹>œ;cÁ”««5Œ{—:Ÿzb|s÷3,ÖŽ›Më®eõáEÔÆýC…Ú—ë݉åŠAÌzû¿±í9°aÏ·£þb‡Ü;jWh¦…ÞdûÕ˜;ñS,z¹˜hœ”Y÷¶æ|Y|‡Ð2÷)¡«È‡3IS‚Œlœ:¹*í·ò¡F@Ö’˜ÂàÜÀéB{_,v×òSñTùÖr¸ò`½ �äÅõå©O£•I‹´ðdÆHXi²ÐN £TMëOÔsµ©—VÙ»¤‘(ŒÝÑTŽï7`50æpqÕ-N*¶—Wº_¥¬^¥ÁîÞj;z6±<¥cÃC+¾'‘‰3á‘5i0¸Àôð_(¡PgÃ+.H;ˆRÖN¤«ð×3åµÀcg�Û>+ŒS*Him-ãƘãMZÏæþÝkÊÜ´gŠ•ï¯KÏãø]þ™¶0-aîr› jùrÅ Ž•±ô€·¶?…ÁjË]¶ üˆ7¿5ÝòÍ’˜C…N@Þ¶n²Öí­¼Ñpzùüž´~€ï˶ÚJÂá馶Wæ`}²#ž‰†^âÌØzÓvAÁö¥øàgè{­c镤ÁáØŸ¸ƒ|EäÖÚÑ)À^¥FŠ M?t]‹;›¦€@qÙdE„LÖ=œS|}a¡²IäAã¹ÿ½®“ ²ðJLϧÎ|96ѽ+÷<7Šbu–SäÓ7Žr•Ë´]<Zílèðå_=j €Ž(‡jjd¬š.¥ÊbcnÒOüùþ;p<Ïk.†¦ûBž3ÉV ´eôç8H&%eñÇ?²Ô±þp¯½{&ès­Ø÷½°Xt•ŸÀz딌ÍØ6ò‘íNû;“À…ž¹°²´çó·¥D&•¨×y)Ô´ïZ�ê}²3f2”¿‘’‹ÂÒW©§¢o·Mƒ¢Ÿ¼á€OÚ;:7Íû~õ¬¨éëŠ å †%õÛS’Ùeô¤Îد2?5§ÄE$Úí+–æ“Þ°ŠG…çª ’ÓÅ•ÃP­Ñ¶J¨ —®ó+>§›ƒ)n•öŠÊ9)qX?œèíÆGÒÉ3£áY“heIá} ½®Å¤©·‘Õ,äãhóÒMɃÒö›€97“T£»m1úÑìüæ®Þ²ÁH—&÷q0¡²úüö²(‹±6w·S²gó²¨H=f{ÈÕejJ26·Z2T+«d+qÃ@R€¾­X9“å·7ò#™ÁiÂH65 ­U þ2�³¸¼2“M²¬(cTzVú]{ŒÎ3kNrb-;B$°®éY>Ëc†™‘º<�·ð]yCņ°ùˆÑaNÃ�Stµë[JõÅÍÑú5ÄÛ/e…¨BÓŸÆSeYé;%ÑÔ4†é/'–Ù¢›€‰öaÍÛvFÐÁ´¢%ÞR~ "_¿À±±tè|ü¡'vÿú*Õø‡¹™ÐxÇé8ËT’׌Ÿ -3£<½ÊÞP@—EEìúeå@ü²ù™@OTèPDxÌ óKƒ²9›#-c1ðfAS<Ã!â‰Ë¡E ‹#eŒîdY�Ín«S·oOXv]û|·&TV‡~%^„æÃ毜×á¥=:Ù£HÚY}Ħý³ÿ· ëJÅ£�r¶3Q>nF]LÖÑƯ fp­æô¶3ÆŒ«FË>•D~éÙBÒ3;YþN´U…öÎ2JT¨„Û8àYç´ù§Þ* Èt­×Ńæ>Ñ“1|²ìc—h“cÐ?{T€˜÷Æí!wmáŽr9?’Ìo¯_;Srɶ =Z6tj €tž˜¹Ó/àm«ÂßùH²è{Äà²q%}Ä ’@ûÉG¼@rßH§Ê;ZýÅNuŒã¨B6²¯ëÉà~¨ÔÞA™÷Ú¨ZiìkèÄAsÛ瀙3FÇûôÇž~’H)’ºÅ 6Q—ÐÓ=yÓL‘ ÿ¿1¬KT;7 ÍDs:²ªìªaýÉÍó@ÌÉ\ïü¶óÞž 6A±Pð©°¦(W¸¹cî ë›Ú°”ú÷ý7èHMÓßHkÆÿ«rbH�la0À4¯[;¬‚`ç™}_j£Árœ¼—+>Q±rhf ÔPÝ®kO€Ž±p\H9Ê|ê=œM–Ø¡€àxújÀÓ§"'WFÐßbÉ· ­ë³è×]Eõìéc{æÞÕâ'} '`ß!c6¥ 4ýªQ?OëjÿêrO¬Á7,¥Îy7g¼Q¤ÆÊÀÜ‘x:÷dÍIf„+ÂþâºNÖAΊ·Ð!šø‹“Ú*£c» [íù"ͧ­U¡vÂŒ=ïï{bŽa¾�³eîY³±Yêh¹`ïâ$õF…(ËÓÂ[µ•ëšÍØ8¥b?üÎÙÌIï+h·ëÒ‚2²Ù,½mÕt—bÂüd†×”JÐY¿wŠ¢< D÷ïæ®à7èv˜žÊÍšÒ×<¦ÿ@<�/'nTÊbÍ,Æ_~¼·êZAíJ[‡C¥Ìèi³h)̆ÞÔ@‡R?›1aL4Ä*6UÁ âSEù¯ô©ìÕÄ Sªñ›Ÿ'z†™1£*p¹Å%‚µiáwô%9¸w5Í’º»œ§ð¿F‘BL šÙ3"•„Qå}öNäÊ»þ›Îj´Ê Ú16Bë?Ø°õEAôPªïSe&Àã îíþ?¯e§3¯w£í¶À&lìÀ#eqŽïñ7ÿ8K_2B)±þPKqë©pß™#4âÓ©°iiMn­Â~\ûBÇZ<¼ƒ2ÉW®zÂJÀW\ÑZêÝ°÷8ò¦×f¹F·—½‹ŒV=¹ÕçèËËy:«†!n–âíšÌöFHîSC<E?1òpS—A¢kwÖØZÕÈ ÎXûÌÐK<Zþ쥒fFT)¯80™2Æ=ÕWë2ñv½ÆÀÍ«{i?.‰•'6ä_34 ¿=‚“ÜÝÜš=‡>!•Wªö§è‰0.¯TšæoZß'ß‚ÈÀ ¢ê8ÒNºø¯µ{¡|ÕA=ÄB“‘µó4“z‰7Q`k«ÿ ¹É¤ô4•.ðE©@¥vh@ÓšÖ "”ˆ+ô®îˆk¯1Wž0†ü9ý»ÈŠ6±u˜UOÖ{¦\]“áßlÜ\•©Cõ)é‹ k¬º7@…ÝÁpïÞå­ù’¯¬È�A½‘‚ñN+)p4PXœ»Ð{¾Π61šÔçðDï®uUjÀ›1UpÚ,ûŒhÃ"²¥J„*n³`µÛxÓóm{ÜlÆÖã=H'óúu‰VЩG(h…߸´œ]Œ©|ì3}þnaîŠMŒÈ0C¡g9WnðÆçƒQèa´‘èéPªp-Ä]¹­±Ó èË£éè߆uÕëðhŽÓ¯F3úªÓcÊvÃÄ×9]E¬×Ùyn˜Åk˜äÈØÙEÞ7…zⱌ2^Qþî,Z–š*µþÂÛ×@ý¸ÕôômY”†æ|ਥGÒ=ëgí²…i&³œŽ#‰3çÈÍìPÎãw iá’k,Íg`eÛrË@Š_=M[.�FÑCm¼nA‚^BcJ8ìÉŒêÑ´÷ý|ÆW €œLñöv=&+O¥g•#ÅFPûP\¢×"ÕµH¬')–dTɶKhضFjØÞˆè•.ÝüqdœøG öÃ[WAYI,ÐÀ‰Òà]Ûÿï£ê€3d³¹º†A”žKBÄþ£#­¾êÇ×± ÿÜMò=ë¼kŠÝîëä³ëS{r£õÍxÜ¢ b‡Õ¿p}rØ{ò”ÁzúnXÒ*cgwœ.¬wŸèæä‰;o¹5Ñoó ýî½=¸…Ñ„LÇÌ|ÔÕòºÊžÿÊ©hEL5 áÃœÑb™FgÞ1 TÇtn[ï·ÛýB@á yƒtæÄ4Âæ•Ý§Tt÷?Oý~°š‰ ¼~µnùÂ:¨€Ï=}âO%^³o0VÜœ¡ž ¥m£ØƒÇLÏå¹xJ’ ¬Ìš8@µ¸¥Û×ö—Æ£»Ž-$í.ï»hÙÖrdÚ¡ð„?]€1E<~ÄvÙÿi'öTHíeÐ4ZpaW¡È 6J`µQ$ êKmíN¹®ªù¯ž ¯ÜcÍÌ9Ñ7ßÞ�6¢±iû=ç@Gy½CbIl«/RuÐ Øn;oƒtEÛÀNÙô]þW¨}úœ+ЛدM3­Ó`1Íÿ|„eeð¡N´´êÍMû 2F>\ Ÿ–êv9P‹×ï¿ÐôÕ§Iã¡èÿóªæ=ig³t@ëzÏ—n¯ZúïI”@qÒÀŸv.ÑÖázÿýÐnŇå€NŒàÌžF„Èãnàý;Q¸ÔîI†ø+Ï<Õ¦û½Üô(¯,(ê]]‘1œÎû¦×|³n{xóÚnŸ„Î*g((’–¬­=ôë|øÅÐ"¯�ØÛ¿Ä�W2‡X)k¶Dµº‡õv·óÔ€|’OÃßÚóŽÕÞý=µ¡<Zèft:§Áj”Y3¦˜ÁS}Ë|� °·Ä•®¡$ä,!ë§æÚ1¡qâÓ¿žæ®ÈLx@Ï×Í‘ÐÓG- Ù£ßB‚ýS9‹qÄúóXY®ÝiýÕ#´ygN¾Ý·mî2òC&)ß6­­«é kðö–DäXıƒT")妖ee¦ù½–%>—ÈH/äÂ%Ž«NǼ©Ñú°ãƒù|ß #òÁ¸\dÇ8 ÒiððzdÓ÷I[D;Ï ¦<ANœyÐT  · Û«.d²ÓW)–fZªf› |Õ--<X.®høÄš/æÆ–°£=ú¶™@ZˆL'Oî4”¾$k†Å‚lšÝ. ªŒ-tØ$NÁN±Ô]-9úÅBIãYœù«úSi* ïY£Ò‡>òZ»O…q ( áo\'½V*1d¾/²™:’iç  ”á¢"€²Æª†Êe¼åÛšäeâä¹8XÀ>½qê´Ã1oFµœ½²y×í•)D¡•Ä,È°¥U•vƒs-£“Ì çZ\'é;EÀÈ ­»¿Ä©ç _FôÑѼê'³€yÏB ]Ú¡`á2æêIôÉxÛI…rײ-#²X«¸)øÄŠà8ÁÌècKyè™ÕÊÙ×”²n%›¬°’”$2Ì h4µ/¢¥Bèß‹Þ‡alõ¨”:š2ÄßѪæùì°³â_ÒÇcÜËò§)sèÈfHÓ‘¾R±Õ¯îÈÇñíß³Y°0¸1U9è.Z¨íŠçONŸ˜·ü€Øý½•´ü „E·™ÿ—Úyh~ñ<‚̃óÍûf}G¾2õG¬PÒ>» 0? ò48ûÂ=O)Qê`l‹Îh=î %Ý »vÎG¤ :°üéŠ=ž„>= 2}«ÈŽjQáWЃî)1‡Ð›«<±#[}€âvsòÔÜ6m·ÿ;®}kìså®Á\÷ù ù£FGI�< Öè}Ór3Ú¾R è'Š­÷ðà û[J.Ç j£š°ÃÛ„¤Ì YÀ9™o>“Þ= ±î˜ÎötRÀŸÜ¨PáŒKšƒfú%<y¡”ÈŽ-û-•Î³~!djPü2·j/ãó2¶I3nåäW«%s7„±'4+f³¤\8[þj`¸R1§Â0ŠÚªŸ*?²ÀÔ�dYâžÅUÌFéëSjf¬žÔ<tÜP3ŠÜ–Ad°Š3 ±§n%©÷ÒWŠ'?XµwÒ×ÌuWŒ`{îãÃ,\‚LvÇ‹XÈRN?‰µ¹¸Ó¥Mb_j¶&¯þr7ÙäXf¨¦Až„�Õ' }/UYõ·›# SOÁrÅjF!«Ùc_ ÿ´W÷FJWx¾ïì$ÛŸ¤1%çª4âL‚7µÂ6Ö¾X¦9œM‡˜êy:”Ü ¢¯¤„èxtmmÅ%~5°É#q›¢Z€³õ ìýÂWšiô­vî[Ć(qa¥Ç°bLÿÿõ‘™2Hî“.Ùk-ŽLä4s˜ ˆ…D³"XÍv°Ž–ÏâDQ(dgøß9& ÑPÙ3T¼Sd߃×INuÓ$AöUeÜH¶ŽÖEpfÔ¬b¶£ØÊ›xmz¿ºñ¡§šÁ8©õ&²ËÆPNY¸Æ÷P–4E¯§DÏÙë±${ê‹öN ¦}aíe(Íl Ÿ.Ä5þPCOÛ1ïñ&à ÒxV Ö•°5Ë&-¦cW{R7n¬Íè:K4²:ß3%[4i¹æKƒx÷íõIXMDz¥i=•”ˆ]w­—„9gá¨eF™òÑ5°Fƒ¤½£'Ÿø¦"Æm•vÍŽÍÃ2 ´·­P§Þw+ä—\=:º‘´¤#+!1k†S"Û5CÏ@{–?Æ-¥‡øègƒ^ÊøÍ. ÂÁ¦Ù¥TÓFÕÇ9¯q“»ßabÝð²<k)qªk€”mìÛoÕ½„æ“>JüL!`‹}];*ÍrBjk@ê«ÔÙw•“ŒZÛí’ó3êºÇaϳ•vÉ©U9›@På][Yüânß3fM@ççý¶ÒÞ`F‰¡›Ø¨Í1:;U*™1ÝÏ,žÐå£ ´¡eè0”×ßȶ’mãTŽlEߊ4Í|¸ûò.å¢{ ×åŸÊR*}rYcÓtî¥õ›êç©$héù†¬ÛF9<d)´–„úÖÏ›†9Qde„O5ÁGk<[pzAÙJœ$ÚˆZ3„3``Æï”óâ& Û{Fv©7IXqÁ]ÐnŸ=Y¬éDQŒ!åÜé0Ïa) 7Ùy=ä ³ÂÃLàÒ~[ÙøÆþp¤“À>¹ê·T°Ó"þû:¿pyx"Ê´N­|ð™[ùÚjU&î]ÝSžˆ-8PF熾\Ö7…­ ¸È"•pŸôõ)Ã>ñ2@†Ô5¾€•<âú¤t¹^+hÇ»Ü]ú†«°E¨É=ß¿ãZz IÖv¬£¾ÔL4¨[ûË`ñ^ĆyÒ–Qðêƒ!žEW-cσ…Qú6‹ƒr²Ú¹ϔ–n±‡ò£ùŸ:ª{nÛS(r#±2»¨f¬.¶&‚±·.ÿú®5A–Kš°â$vÅŸÀWœlN^ëœÉã{º7@­Y'OÏÒS¹«ÆS" }ÊáÛ3SƒfË/å…ßû—÷ãtêÕï,.ÞþäAù}rízJ†ñgÌìYuÁLr_/KDGÜ‘¹¼Âà½3Û6§ˆ~|ž*õSx ŸdW„ÒË1¥�ÝíÌyeæmm1áÖ¦y€æ›ÞÃc^¯;Þ7ÒŽÌÚ.ëð~wì­žñ´JiçQLõ ¨¢¸pÊl^ïøÌE©fC,®5 t"8‰ŽýØ­�]7 r†Xˆ¢Æ¯á å©Úô”Sühw3‘ED—~â;¥ƒ¾Sv—¸‹̪›!õNc–µ4'­*3Ss@œ—ŸÈ[I¯ÕÍ#Ã�¬'ªè²“N3!ï²ô•òú΋hüØbÝ]œ£Ãÿ0‹WÔ‹߆Án‹N¬ãX2 gZù»ÅxïêŽ.íÊQ#pȬÒ º£ó¾,§¤ 7º„©Aa˜û¹VªÁˆéàXÜiêw®è ü�µqm ¨ a¦-éÖ ‘Ëù £mRƒ§™Jꃛǰ»°×»"Ú†–nͳÄ(ñÅ/÷<>¼`³ ŒŸÔš§¶=.èÞwÇ#›^Ë;» ¾ðB˽°Æ,ÞQÑh© e*Ü ƒ¾ÝÑ{qåi/–Ÿ;Ò%͸Nè”Û–†·£å(z7V Ï¸˜‘÷Q3´èÏ…È=çÐDÃÅjàGGÎÄšÜúzí.fŒy_0îÐ×iî±úúÀ¢š ã2·ZþmF†òµæ Pžyê lP,Ý–AºQQE`øÀ¡tÅ_µc_ @õ,R~XÚè7cÛ,¼Éì/ï¤ÊÏ€©gúÁ΄õ‰ Û5b2ŒtÄ–_zƤ>ƒ­à¦.fÒÿ6Kï-`·› tšÜD·†nÕ{(sO³[= ë&ŒƒèS¡É‘éȭ⑘ hèµS¼¦ÆFØ¢w¾ÜÂ{ÊÔ� מôœ³jWÀ÷Æp œ½±#}¬ñxžDÌÌhËåúD7ª ÿƒ‘›‹i’;…¢ ”ÏʬNP*±ý™'¢ñL9)»’NâÕ;Q¯ØØô]©dù�7|–þjïåÕjC8ôTçŠ6I?8ÀäúØcŠîGÕ÷kË¡SÀ?rgŸU5):ü�þÉw ‰‚eòv_OžÓ½~ò {ÜZxghLTÖzÒá¬0ÒØa[¦áØÏ—>kó6–1ΨÎ6ÍJF`°}t=©ö#èI¢ŠÒœÖ_H6Ñ2«¡ úÐB:¤rºð1h€åPþZV­CeñÒ<T[Æk9äÅ]˜¨L=•N¨±Ž)cE¤^J8e!_ ¡Çq0Ï]=”o/=õ¦¶A;®ÕÜÅGÓRíËP‰¢¿Qzµ£˜ÐØùLíW+ü˜Èp­†{êÛЖc<‰²,K)SâV-zó}™¡s¨i`w&^ÖfÆÃ|ø‘ýÂ^;$×›ö+¢ªÙžhpò¤ÀÜzeÔûü_C9Dò1t �Z¨^¬<�¬7tã8ª¶òð¾.“´yc�9‚ĺc±èD T¬mÑúj¥Y— ró¼A$ˆNŸ®¿¶sé·1Ò›ÖÖ#XâîP|Ý>X­|S/`Qá÷©Õ÷ÙÞS©¥!oçq^�ÞÞ5ŒS(#(©%ðq¿8±ËõTm×sNÞÄî¹>lœ†ìLz$Rt£wZÍ^’8þ×džR×ñ‡O/[‡°}¸“ºT”L»P7m€RÙ¥À82kþ¢ø?R4j*c5µªøz¿ÉEêµ`V̓´ÚxÌDµ21�cñë.îÚÆÅ‚1?Ŷê£6Ýo\5Éš<aãvý­®å€û¬ë:gPKÚáH•‘•€…W]:û®Ý­_¹G+Óâ(,&£æE9Zò—f1ýÝæNœ,§`•»ŽžxÙŸ¼¼{hOÝùâü3?ÄÙÄœˆ-¥úOŒV=šK,Ò&ôÙQ{Ç0+š•Ö…ú1KÓWÏ90/¾·KbNãù6™•mÓ2î«ë\¶«ºzu}œ—?ÜëUE¥‡Ð¸NøBpR#|í÷]ÃJ´0'ÚUw1ï3ƒD‹óø~Ô.lwTÐ ?³Ošíö ô“¡Ó®=´€æRÙÉêå×?7Õú8ž7Íà( ¯ŠÓ©§bò{çMè¯ì) ~uˆ-ež\½‚·äî;wÆž´9ÙÁ°Î²¨8»ßº”BC°’#Ú¹“Þý%}”̶ÁÉ7&A|éÜØ Ø"öy‘¦0…$–kT4ùæÒ5WtW¿“(Júÿ…MØS^VÇšUÍeY](K}_+%Ê8z^§<ˆ;¥é¦ŒbaÕ?Õoº%2ÿìéþ`nšM=+ ·mà–ÖŠ“[Ibä8I×ã/À¸Î\,7äŒV£Y‡Á¨iÛµ–±±‚ôB6kÙ·À„SÚø*Á¥SÕXUörCrî�O~*Oí•žñÌܳ˜ŠïÊCZô�ŸE !G¼µŒ^Äñž"‹¤%™O¥+?Â|¿ìdcœ+3Ö£6’šÖ:»¦%Ü•zR¬LáÖCxbÕµ®7‡úywdD—ÖCÇê«1Z<ë/¾#ëŠ* Dž‹ Y—›“ó6Í‚dÓy5­§ÓœŒÌYÝvg„Ü®sì%j¿tÍÈ°ÝkT©T3{ŸFÚvDþ¿¾º‘„eü£ NjÓÃ3y»�C—‚…| ûÒ”»ntÌ®³pm]äßÁÏͶÁº‘ó‡¿ø+ÀþÃê4(;®fÕ4,%&ˆ(¼ÿ—ù¥ÿíØqìù9æK—Ÿ}íOM®Š‚³6Î[A‰ö§e‹EyÑó6Sj~nx;øÍÕzL¥(Z[@øybb>öo›âa”¦^0„ŒÏƒrÕѱàq¥G{GNõâD‘g2|lKïœ[Œ”ç3ÕZßœëS_y}6´žú»fìÀ悾2J)[ ¾Oôý¬Ü+JÉVH¿1pãܱÀ9ï)‡ª^dɦ¼È<mÑ¿6®s²¡qñt>œ­Ø£ŒÀqŒ:„I5"çÁùãAä%Â7"­/ÕÇÎ?÷kl#³ÊÖêïœ~Lêf/v"›uw(g}ñVZç|œZ™’h¥½c`vÇAô®96ü¥.rQégÛ1«ŠåA8ü”·œ3jkŽ~³ï&IEî‰?Úp†¦w<Weo¬78Pèõ{%b-§ñ{->«†!µ«¢QtÓ7'wëéóª/úvŒnØä­`°þH)šy5™õµ05§ < ¸Ò Š!øO;¡¼ßB42?kJ9PLeT­.OžÑ¡ø[d1¿†¡•Î¹‡•3æ šéÚJKrÕáø°¥¯†>J ¢¯»öã<¶O–2ó‰oxÆ=èq›å¤]–Шÿ.䑹T×Pa3Ê·rƒkÍÚix$S ˜nD”ƒ $l…`:œ°ä½+¨[D©­G«u“SÎúiÁ²…g–½7âþEúºëîÔ¿ÝÖM|ã×xŸ¯õTSDy¥’°áøà5ª;ÒH¹‡ cŠ ßÆ°kQaÏeÁÇÓøAùH>Ð_°®ÝÒ|D¦ #gÀc ½þ€`<é:EKND(•rؘ®¥^ô§^Ä™ØK{­µQ¦~'h•�èZ°ñ“ù"´ìéåi+¸wýk^c´„Ï_°qö®ƒ`‹,OjPp*ÎzU·B^ådöNw‹ôÊït±ã|!¶¹‚Ž1Þxç´œ)4áÔWd�@GzÆÆT…í)›£äÛÓ¾“–}öV㜃uȹ=ò<[@Ä×áÑ|ƒVU/˜‰+•Ðgº¡yº q¦"¢1Öžj(¥r61ñã¾8滂E±Z²Hd°å"0¾]WÁWÅœ®oƒÄ¶™])Ñý–jÇNGvðy RÅŒd#¾&Ö”‰ëçl´‘ ŒÚ&ÄÕ0HƒTÞSvÌ»GEzoø”LÚò+>¼tþד§P4P€ŒÿF{PÔÌp¦9ËwÚü—g�yU?ˆÔ|m)ß3âvc ‰9‹u:!(Tç´€–Q+¹/‚R¾ÑÆZHu¤"!™×ƒ§ÔSÕ ²+»â—Ê‘«È§A|ëòl«RHÆDR¼j0¹i™sõº�ìEÞ@Ûs=´Š*õ˜ &ïA|×LÒqã¥]ó2ò”ÚèN{\Ãîß ×E¾Èy„_qÞ¯5Û ·ÛOfâ“ã);7Û—}›6‡­-rC7í[ŒÛ«ÎsFªªIþ ou=V¼èùs”ˆ¬™@ñosö²AZMóq�3ºjgòŽ d˜”+ïô>øi°ÝàNn�&÷SÓVðÎó·à)!›ak1šrr¯R×ÎKÛŽ—}üEKŸ­at.eHg -ÛSÞ½T®%kYdèd¡×9¥B*„Øž‚à«gq³ˆ^– E‰2wsE(JýÀ­J(8êW¯<刄ö{ÛQÒÏKjÖCˆyH9kâxAÜÄš€›IÏ­!&Ú‚J(zèt:R†&ü5s¡Ìzß=_^Ÿ5È–ã¼w­œ70*ÑRО¾aS徚5"‘6Ì¡6 †î>Í9ôp¶™‘ÂÚ”6‡§Ù=;á\ “lvãšqN=ÂÛl>t»þR1¿Åe'%t»Â3@+VüD¶›–µT[ñŽÈù‡,öÀ”36g�ƒ¾Æ5Dçkè,Ob°©)?EKÛ¡½iÅZÊ*O0�È?gœ©u:¤€¬´t_’7>0 ´!.mNÝý>Kâ¹ 3ðŒm`£Ú—”£mÃ,&õ@|ßù5Z%NÁƒ øõDÿ(¶OJî³ à¢Ù+$˜²×"u÷‹QF±8Ä2øŸdAj³†¯KÇrø†vèŠ8 ³¹Î\ÉhƒñÜi”^U‹<~ Ó…­v¬T/;ˆC(¶ ¶:Q§bǤlÆåÚ%ry-fÍ® ò¹sñQ]cl[É‹}å ¦’XªžeVj{äbÙ(·­›X ûˆ¾¿8…îÄÒ'Þ? ëͬ{Á"Øÿé$Xv¬†™ÛâBŠ•a^ñ‘)OÈ°&K3§(sìh‘´ç(É£-~g¾³‡«—û ÀñU—½ÞQ<ϾmA•eC’-±Ï¼ý§N`=1¤œ`zëOíáÅ…‘f¨–‘ŸõOîì¿tu¥ 4 ̆VªE;´eiJßy²€•«íü1ì[Z´HÑo¥§H¡ÛÌË5 }À$ŽÞoð=úUñ¹ øSc3d½­Pä‹ðÀXÎñ»³ãÔSÿ–Ù1™³F‡ a<^u÷þÀ~¶»Ç*@`gˆuOqvÞyÂØ°æ!ÄàòÍoäôco£`Ú4b]Fz¾Q]yÈy=ß: ÚeÍÜ»ºâ&Å¢@ŽaŸ‰¹òô7|»)“gRx¤*ãòw2ïVO‘£|ÀŽ’“±vS=´,ÌÈÍ´;[îeïi§\ù‹)öì58šÔT Šgl»ƒTeN Ÿd„é£JD¼;;Sÿ¹w)‚øûâ2é……¬»V°¥¶$í(s'0%Š°qÉ>µ*)V•6´yY9§ûã_[º„¾Ç  ²2A)íM¦p{ŽÎ‡µ‹ðg(oÎR¬ÑJ@uM¡Ôø=F¬P³®::åíXÀZ¸Þ»úàyTSá”yð[V5=*SæZ•š]JJ]ÎmËÂ;ÓLÿû=Tcçñ4ƒ/¬y¨R:XZ¦Çî…#}ËÉ$È1g]V±MòtÞcj¦ÚÜ:t¿§Ð-%œ*Ï,²ÞЂ¨¸²zô&6û?Çñ¸„ò]ñÔ±ñÝ¿Dƒ@¬É!á‘zª¦3mÁµ´åú_ÒäÚºuOÞøh‡ã™ €‹ùñNRZd+Ï3‹Rþ¡‹ §·qîá sŸ¬U;6wÉ|ŒÞwÎЭ¡<bp‚r8Íz?€Ä|v´˜ xD2ŒÂDz<])·…îüw{G¨²~Ú©»~5 ˆlÚ–@3Wåqµñ†œµµG¦|Y’û…\ÌjMp¼<ûþÚûé«t±¹UôÊî2Yˆ»Òçì*Šz•N`:JÞºjIL m‹áæss*-“¦¼« ,c¡7QÖ ’ô¢ƒCh%tûîbÑ+SË„yä“(w>|%ÁÕfyF,S‡%b©ÓüÌ6ÕáúÕñ—5P’ýzBêûyrUúo$kœRàŸŒ0‘½2>mô_ýèášÃ¸21Ô'ý<ÛÁÌ0.>Râ]pO¦ ”fF1¿ÂoWYo&:ÞR°aÍÈ}Ýq)ŽCU³tRL‡<ˆzå3–Ð]hÑAœÑ{#e$å!ŒþÒÍ”d%K&1¢Êƒ¤ÖÙŠÏ©*äúè6ÃFӈѫû×r`tŸýòŸeSovµ”«MýÉÂÊv¡LŽtƒF éÃ,­ó _ï@0â8]ئŒ_NVÆ)f +6p½Õóy†V¬!QA3Ó¾êÿuÿÞŸ/TÌŽívƨdéßÄOî¤8Ìi™ûDRªÈÖgJŒNΖ˜J2ªCuŒ@‹¯C!*x*ïVWZ¢Æò'¯a\X¡þ—†A>iE…ÎÒ™å¾å/ŒÇ ÔæåQµ“§~ÉšaMÑé=‡ºÿ|i ¼¯SŠJ¬¶y6ª‰¬[§ XÅK£¤ J\Ó"–î1¬ yÛÊz4=±¿ÿSd ÷ Jm*Xœi]]²xÌÊ­† ¾Ñh€?çG$<Ï(€Nê ´¢„8Ž 1ÏšøÚÈý+<Ÿ³}Ë9¬P M‡IÙØüzF�ßÍûÑúJcD‡ë™Ý %põjLÄKK·Fm¦ûPYÉшåp,UÂ:lü6–GÊ*@öŸq^Ÿ$ϨͱBL·Ñë/óá(¶€&£}ÎvVœ.,ûa2t¼ûµÑ³2Éó”ABÅÝcÖkwózlç™k“½Âj¼ÆrD‘g_ âçÊsú@SÙˆpïƒä5VSM•xì&*õ,Š3*W< uÈx¿IË i@¯fwv´”?û­Q˜}Ù?q PQf)‚¶¤'¸Õ*ʤ©«\ùÀÖÀ1Áü!Ÿ/Ê=A¶Ðp`Ý<ªctÕ÷®MªfÑBÏÒÕY´Ùâ€^0ò•O.pgEìÍz<xÖ;ÁðŠi_Nù~ýµÁ·‡ú`Yv%^W÷ ý©­'ï·¥gîB%`TKY<…Ir¥(ãªoÏ‚õžV«ÅЃU|élH$%'£PAúŒ;¸z)ã뀸‘Á¡}ÍqYyZ`¡$Ûó ‡0GÇÌÊH©Ý"æb·‹ãŽL®ÔNٮśu{÷©™ç7[‡8*7í‚-wãêGO‹Øyi à\Qh{Õ4Ìuaÿœ:Ê�mãDî]ªó¸tyÔyì04ž•ÓIÙ ”úxÔŽè­“ÐsK!«k®Œ(û8Õ½q³Ñ_Õ~û['×:ó.’U탞ýÄø�Ë :-:`µ¬"|Ìù%6%“ÏÉ Q_2«‹ÐüÑ;Oè?TEƒ~>‹I-h—aí¼U_˪`ηJÁ˜ç'Ypè¤{°û4Ã,î^B§æ°ŸÈÿó‘æ9²ÈkÇõ¾ºR­YTžþz×Îw,£D§N‰¹GÛ.¿ çسÙÏÿî€ é²,…Î/1�Ö z0ÇSsÇ ©ÌWžá……áHo_Çâ¬)j¶ ÿn]fÜ0DÛõ¨îš9pWÈÔ=9ë þA ø³ó¼Rõ#š·V<ÛíÅS„Û¬–Í{èOQ…u1ìî5Mf>rªõŽ¡«À[ŸjØwxÎå:4ÖÿÞ]\ëCÛñ‰|9duHËÃáÇšƒd5ìšö•Š|¼­ÑfIöaižzK%Ü~[¹VJ}(âõô?¡PgÇõT6Ò7÷|" Ù!ÏØW3­FZ|¾ÿ1«ÒîùÇ–õ'ç÷ö™ÉÖ* ð:±æ²º{WKTf‘ÈTÓ7sôZÌ‚¯}¹[ŒB¤'.I×c#4§Ç+8«ºåƒ[ÉPÑ娃¡ºå¢A :–6­.4¤ï\,wæ/–5ï·ÕìØtÌ…2)Žø\Ö01"‡ÆÛ¶\Wݱ¸©ll¸b*R ®&f,~Ï_Ú‰Äiê9¯¤àq½³Äó˜ �”Ôžý±¡¤]_$¸×-—z& šS¡M?^ãvÿçòÖTÑŠu¯ Ñ*ï¥å•Ä…$å7Œy_äÝã·ŠÓˆxŸgT8mÝL†GW­R–xa¤=¥PíâBîéò'Oÿ•»×l(6A„w«ZÝþÒ,D»Ì•ürÁ¥e1T,Åÿ¶?YO]YÖ…á¶öU¸õŸÎZûQ]4%$ [Y3Ÿsÿ×ñÇ‘‘™Â€ñ˜çë dϵ0H™‘Q¼EÔö¾¥R½|8Y¬¥tÀÀ÷™[G+òØ{¯fËlvÑ£ª°C>i2GéBÁ×` ~…¾n$Z‡=X‚Öbæ&ÛØÑ :_û~ .S÷Å%åÍ«76W Â}M%ø§•â¥[$¶–uÁ͈G=‰Â3烖M¤cí‘Ò}1sú·í(ÃvT\wC}~Û]—¹ú ó[[Æ}ísC™Q£ZòQÅ!˜í-yƒ£ˆ“Ôý}IÔb5¥‰Øý$(lã4 !bÌÈÁf9ŠäÉýKE{dåüýyÄöbåãsÁ þ;9ÃJ¹•ÛÅ™¢í^Ùˉåhz÷ÛF@äáXu xÔ¾¢µbCN!ö7G™Ðþ®Ç”fn²_n Îj;¸Ö;© ãÛ¶¾ ´8“ä¤÷¯ 5Iz”ò¶6:b3 £ígž,þøü«Ž-ÐgážçªÒe‹Œ\ØlážÓŸ½ L�gmE>‚/ßÓyb‘-L#€´ÏûV^€o0.䣳9/‹¡"|tÝŸCO› Ó>†pp0¹úE>±»òdu"2SðÝŸÓ °ð06]«á£[[Ì&nô)ZŸ;fÅýôŸ<†‚à³álCU}ºè`ðtåÙ.{h‹ ¨–pŠÆhbP8x¥ºOJÿù‡°„kÀ§—hS–ݰ̾¨?ðÐïî‹u"È3‹FåYûf‹5Õkß¼Èþ0ÿ©=#ùÇÏ9÷Tmfø±Ð#¨¾l ˆ6úì·Aeªñì#Ê4ZŠØ}FÉ?mªÝ—Ñ(„½´Ù³<·y¶?eøºWåž2‹iN‚¬µ ÖDÀ‡x¦JÿjÁ¤¹é>p�=¾š2²dîTR[Ì67o×éíÔ^‡àý´dâ÷+“z[]í nez¾2oî‰kÖ ÷:ÂãÄÔ›|'¡/-K ÁþypN?F9ø0œ`$«×^ÜñÙ´ÚŸanÔr6Ç,߯žº–±^ò@ÖÁpÈv#Ô°T OO*mó‹%ÜdJ)ÏvÌWŠ~…Hd ®'1Èô $õ5)åƒk»‰2ß,ìß.bˆ»9°�ÐG)«•‚3»|l{ÇþÆÈ`.ƒph¬¼>ö¡ +;5g§1á_¸«2Lt«ð Þä…viÚé@ +³¤j®¨ÆþÆä~K/òÌ:ÄÛ/ v}”ûC¬›"Ÿ™Þ€2ÉÙ</ I³ö{CÑDºã©µ:™ÎíÕzØüç "äæk�F½vÁx&£ŽŠžŠ‡'Ýþqrc®c}evõ?üA; ¸yÚCv°‚Álj~N:]í]ßí¦Z=Êø-XªÎs »s‹’ÌïFÐÑ‘§m¼:áC¶¼ ×ýeKMÍDÔš–K{Œ³µ‘·Ž2By½/Æù\¾2Ï‹aCGiw½7î ¥>ÊM_OÀR¶ây‘çþ ÷½LB¯r{™•…Œ½…$¡è2@Zh¥)ôº¾Pz&u�™tÿ¨"¨Ñäa†–Ê,À(ÖB‘?t#õ/py²~Ûda¹"¶û¯ôÛÒ8Ns ´¦E±Ôt”嬙-/BžoÎH ½Ú…»Ç©¥Žšo÷y�{vÜ{ ¡è»Œ'Ú$' z4}9†¬Z«fÅ»ƒX1ÒòüFÍÝ42‹ü%H5ξ-‚lnÌÃÇ8Bà8¢[�r€®Å¹¥”ÝÀi{—±?–§·ßÀ’¦j´……¤K=ø ¼…Žêé€ó£g©œk`Q:‘e=X–K*§üÔí:4¸L#‚ÉtšŸŒ³Ó"ó§b%‹GõÞz[:ô×د©H—.v—XöcÔÊ “I Vhç˜&ʼa˜Áïm1 õT³¨‹ëK^„ÊYÙ“O‹øW€,E¾¹¥´ªÓ-õ aòÔ$ŽóÜa¹Ï¹stÚœ}‚K½ÛéL•6ðÎy™?Ƙ½ôClGIã—ÊAÁùFAN�gX6ôŒí«ìÔµØØ­ôX’¬\  v)pŽÆÜãØu§igï–öÌ®˜xR »ºc¨‘E>Š/DN@·,rŒ¬<Eaß«6Eic5Ë~íRñ3³ª‹ßR‚,óüˆrv‚éý«Z¦ÅMG‰3ÍÔq¨„ÞŸ$ö 3õ{î|Î,QÎÀëhr_±|î(z‚,kuÆSe~­»ó°i³{mU'}šÐ3TAÜè¨7Å�ÂÕ Cyþ²Õß¹‹c½Ù@Í–’.3ákùN£ˆ×ŸUß•²Ÿš9Ôírš¸Ž•š¾˜h¦Ìg–gÀýjµáTIÍGï‚…ôJ?8Rÿis2ž)ûÚS™Ú ÏŽA¼~>U›ùYuÆꪜTƒöÌb]è݃SÂhK¼¨á^)þRì±¾#ÉN†­+”¬À I5À~ÖÒ½X€mÃÕyBî¦Ã?¢§b&x”µÕ²Ò؆Åò€V"Oúý%a}ÇbƒÙü‰é»ÑÚÚf<Ðj×|äé¼k®æß›a]Æ·EÚÐMF{WEœÄ) ê*“Z“’ÿè[]hFi»}À¤¶]4}ÎôFšYÞ‡) 3Và©þ˜½+E¡GŽe/zisz^?1ó/7õ猤º1—mú,H¦³p’[Ò%‘óæøY²8ÊÒÌË#"Ì¡7ºõÔ”]¹€ÊÍ#ƒÿj¥•{d LÐBÔèæ„Lšõ·" .«Áœc‡¾²¸ãDYØÊ1§¨2OÁâI˜ïGýâXèˆÚœÈ¡ntå»g*(ÿ{”£üö7?!™SßÏT~¦Ô!&§¥îT“U.sEu<ýñ,z¹†~ÂÇhº±£`PŽƒÀS>Y÷æ&Ê(|>mPž.oCw¢äþG+.ïÅuåT£:Ø.Ï,®å¿×ÎÏrw×K %h­¾V-•Ú³èãw„ uåŒ#õ5íhË/ʆ„)'í>qqd´éß}‘çQŸq‡µ è%2œXä&ߟ(Wö·8æÅúÌ‹éÌÎdœö|•C·ý¨8óLƒ†òÑ´(,ëƒöbrÕvFË2b¹µ^ƒÐ…úÃÜIäsÞ :å+~\ÖgÄD#MEÝ…ø·<ÍW£8ñQ¡´–àzhB5æ­|ªòZ°Kîó 4fõ»Èw÷Òê‹”+à4?è ïžj"Lµöòðÿ ÏëRÉÜеú.§èZ+"ƒHÚaF÷zºº¦vÝå××EDªÜ ìJ“óŒS¤ï;Îb|EÔÒhœùæRÝ—rªÉ«¯+ÎL•e^Œ£µDá'²A' ˜Ä`W°«ÛlÛÿK·ÂTÂÐ3—¹ÒvZ+c=rÉ‚lôuôéH?øœcëªþh\j) ©²oöiÌšÚ¦cKÝÀéŸÍ? 1Ò»¼¨¾ÙYäãÚÃL´[â¯Æ3þåvƒ„ešæɶø×M¥ïd€¾ßÜñŠÐé,³ªHß;l ]ìÈ-<-Êž¾½Öɸå|[GYè ]ÆŠq´Vs¦ÏÓvËâóßa‹ÔGäÒBÚl©4Œf56…xmÏãÓ±žçzáv"·|Täa××G*YëáÁoÍühA¶¬òÆÎ~з§@µ[w Š~¤+N´Ôéa¡ºlßxÆŽt`Êj£ 4¢^Ъ«Â›ÛTôžƒªŒ"MÝ_¡ô"ÏLRÓŸ =J¯ÎÜ%6ÊÛ[fCõx°. /zâ±_gá¤Ì³ šŠÃFc@FÇR¦û<4ÒNÓ[MùŽ>iW»Î™ñJÛìE:õ®ÜÈOÇr²ÂŸÇ°·¢ŸO>gŽšÐõ·þVO`Y^/ÊEsDg›¶g�—/Ýë<œð�YâAW² ”Íî:%2÷j´´ê>¸§h–šwù½JJÛK¦ºyÔåǤÀ|ʪ(j}Ü—äpÅ=ƒk©ØÚ×ôŸ­SbªÎÅôH¸¹!·øÒA€ôj_ô*gé,GªññlÝZÆ艇6\tZOçæù½«YLŠ ëÌ"Ï~µ1ˆ¨÷)|öì«q§ùò ã§^Nro!À6•Aõ~õJ9¬äa4ÐÒ¹Ç�¿\7ûú#⦛ó?»1ÚjbŠuV =+Ã@Ô]^o¨Xüe×ò¹3ãÇ0Àv¸º¶’°"_žwxîD é©F™&dF3Ä;Œd.Ër·éýyÙ+×xÞØ<g:H‘°M·ïl´õÚ6óÙ@@ûÖlÇÛ_<¹aeæ;ÐSÙ^ó ì<É@)éHEΈ¾û¯¸"|ûÅå:Ý*ûù*i1ƒ© BÐï¾±R¥¨I2Í5¾P,4ÎiÆýËoæùJƒ¶àt¤;×nm½–2øNÚsÚIú±kçhà™NëÏ”§ÍÚ`çµGHîXJã6ôh�Š­]i´®'(¾þsö†bõ¦ÞÐ-0ãéú‹Sö›uÿèlJçìθë‘eC{Ç ˆÒW£ü¤ídé £Í¿¼-="*r<•oQ6^Š Ý+Ð dÐ Ù•1•{øqhgù¼7…†-}­fü±»£Ð˜®Ø+Àöѳú¼úÓe°ÅÎßaûRŸ¢”Ê</Š÷«³*Ƽê* j&E¢ì[ÒÑÇ–'‘*=™Ã) ÚžþÉg«"ç$‚¥'?Od«´o/ü¶Çj„Q®ìw¨Úé¾®wHän¬Õ§½ˆ´û¬«u$)€ú¨0k­ªŠN»G:m;ízïuYØÔU‚·‚îQj[]ÆÒ±5 …ŸÐí÷¯Š×Qåä,"l3xŒDíì4WY/ûê„Áà*ª —5°õ‹'ÆžaÓÐû]õ3<ê±ë8ƒ´UsmÓiÉ^×í³Ý4'¬�z­‚jé<_ù¨éz;eÆþ;O毡;d¶å·C¹,Lš&ú$ ÖlËNKæ #—0HFõoõÙÞþŒ[o};ÜíòÌ&x6?Lô4"KÁâäBê¸ÆµÚ¥H|èë=áB—*‹%pHw…Öï§ Ð&9ÚÁæ4 õ~<dÛÉÂÙb€.·Ä»T0¡G´v Ý›Ðc6€QÕC¡²J¸(z¡>g÷¥¹µiË|E“$Aù9[Ö9³#˜UcöÝÒm„üZB”DJV) dó°+ƒ¢uPÚ’±´˜"ÔM=;¡ZÎ$÷ºùñ‰ˆr–™s²; }©âò®’œ¡&ê`{Ê?·—­#;±#6'z{Å$~>ŒpoÚëÓî5ðß¿´"‚öìÉ œ«² Üé¼/‡ŽÞ0S²£¢‹tDðiôœ»­±jg¥ÒÒŠãh€&kdÕ×KûAG?󚃌à†*ÈfMqbžBýáðÃø@Ë>Adò~ä3á°ðÒ0*à`Ù²è…_ò iº©µWŠTØð©n,ZéÉâúÞ»ˆ3Èh7$3g¿0ÓÃUÞÇë]†(O}oJ*r؃;y·~t¤¢[cÜY<‡­¿Å'ñXæÓ�Q€·z‘n¼£r<wëöÑ8­¿l+*>}wÏy-¾.?‚Ý–Ž©Åã¶|[´G2öŸåÖ4ç¨<öìþñØ@ ElxКÍþ€Îâh-Q˜‡þ” º/ª–w}Ïúw;ãÓÑ}©«‘1ï¹'~èÜgCCþ[†a»uÊXc':ú€ô@!.<²FÊVSÀ2A)ÛµO—‰ b‹$Ø!yåšO®ð=­ X‘ùõJÅ°ZµŒÙâ6úF0kaßGnýÑcrêäÒ §T]Ó ÏdNƳs*÷ôF"Tdç%‘\çûßÔzµ”¦åÛ}QdŒÛÎ#<3Qþ÷"I«íבå‡1S^êÑvø×xé(«|Û3q¬2Ûá{^†óbÒ†I+B_›µù)‘ÛZ{ÈXt&€�tSzÖ½yE ?özK‚¥êô u²Ï^í½‚ã#[U·­i›Ãý‡3? ã[" w)©¨•ÛÝ`ÎÿV{üZ؃Bƺýw¤¦Ì3-dîúþL;´z\‰¸â ìÔcTUèóOÂð6#¨E©?|Ó`þÈ‚|×xfÞJR9Y6;´eb€ÿžCY“ÜI ên ª®ê Q!¯Éi2j§¾]aêÛÚÐ3îyÖåÜb3:„ªn¯úd'‡ôÖãO¾É=üñÃ~u\…¾í9œ=í¥·-0$£½NIwÇÃcÅÜlG‹¤Ã&*Wåï~Àë Æ°Ê÷rÁ)¤ aª–Кåiùâ¹}«RÍ[†wÆZâä‰ð ¢iétM–Éë/µ‘”–0ÁdQ4ùY_=ñZ,‘À´ÿt©½‹7H¦§ê/)ÿ~¢):W«I¾÷ÆÿðïzwöÁ'yikVóÿK\¸«×#Ø ˆ@­‰ßaþ¦DHOy„‰IÜ+æÁ}j¾Å<Ûu’S=Cþ¬Áð·©¾Ê;:}Ãàgׇꮙ•M ÍHâø‘†¬«®ºX™5:{÷%ù.%þ„ƒ>ð¥Ži#}y*¸ÀõÒŠ4àÏ&µ? ­¬Œ?YŸŽ5‚³áóö æôÀòÒüš³¤;zÁ÷Vù“Û%0Gn1%¬;¯/V³ŸjÞŠ¹ÄeLñh Ù–•$‹t®n¯QµdÍ’oT®Í`Àr]œ}Ü»B®X:y³k}:Gsë”E":ÛC.Bæn¿à9EQá/L ó E±d¹zÓM¡…»­÷¶¯/A óqÑr¹#éeQìypA”‘UÅMo—…êö\lN#[ͱbÁ›¸º[%¬Ÿ%ð­‚­@‰à]4Æ8…{Ïi™]zf§%)¤Ñ…Õ(§U…q¶*-¹»>(Q�“<J˜y¸o»\¿î§Û™ri¼£øk…­%¢gu %±EÏ]Ý?Å<*ªÊÙУJbZØ£"ÉS…¢YóÍ¿t³ mM6T€ÜÕÍOªé§$ `gŒñ-Å:c¦ã‡T‡€øîí…v OÉn¿ÓLªf°‹gZÝ$õ7sãŽwûj$ÁU˜ çÃŽ¶œ›bœ®b"^ mz|÷i‡®é™›»z,ƒtÿ®ãRˆ‡þtü7=ôÈZ+&[KÛˆQÁµ%÷Vÿéz6>—^ €T3Ë9š‹{û0WŽmh ó.â;b$iNÙC©·t· Ÿ9tjñ"wÍ,(½ºpee•­ˆUíRÙ¸óz1 ò¤gÈ­Tô„™ƒÊ;ð›Å|QúsY¨ªõÐDÜ[8k·Væö—j‘^8b@j_á¤Jäeîa!fkHË5¨ûçþ3ÌKcŸ©§ñ _¤ídîõ{m«)ÌXÁ``jÚýt¨Ä1ëCü#ª ƒDNi‡~™œ¿ò¡åoìOm+†/N_&Ä~ƒáY['ž'ËÇϘ¥çZ×<䶉ïŸ÷ÛbOoÇT¶t`%ïŸ+Þ‘ú:8=ð—Ì âÒ Å è›èìj¬`Ì=$¥—<iׯé¨ô:½,Z1NG¯VΔ±ú@U©¡`±<]Ç�R÷}‚k…­åFßCnìª`”M©RŠM0¦ÃÜ_¶µÔ$Ýv8ظ\ªŒÿíXŽñJÐé<…ÓÌ:=°o-å›Ç“ó yÿ_õqÄjI‚bi<ß´îM³J› ¿€O~7Õ¶\¦ÌH°nö šl“]-–Lu«îÙ(Ŷ¦½WK[ò @©ôÔÝnÒPÀ|Í>Ö5rû_…n;c)–‚Áݶ‡ë±°x7YVº'?cÔQC¦ ±N0ôŒ[,KI”)˜î€;b€*IJªR:´*!2éB›Ïle•^ÕW²öÈ�#=Ù°>{å5”!Ûl›ÿ}\ᬩèÏR +§V–·i÷è×í¼ìíi`›æûÃI;t³u¢‘LÑÍ‚Òjeâd¢r„9t:Õ=´›ó¨/÷MÈ,Å[NÐ k…ÓÁbÐRm©!“Õád§H‚�þvÞþÔÊþ¼ ‡.œM iÁ[) E�A;¼°›+ð}‹áÉ»9‘Ò4µ[‘`_dÄf•/‹ tŸÐ·±ìÚ gZF4örèÎ쮺m}˜¶Lìo”di•Zí/Y>MKŸ8·°t�p™¯ó=¦g~  ü¡zËbߦ>fmÊš»Ý *Äcz·½fœ]¤þ¬^ppæŽEcòÑÚµ5e�ô¾²YãÒdŒQešh— ðàíαÇ>Ø”ùŸÖXœ'¸2‹‰;ÝÎÍŠãÖA˜ŽŒ/úè~!ÊRFÒ£Cc ¿@[®®=’ô*§£³Œ n:3¢æÅY‘¯üÐàO¥}5îÔ6†¤Æ+NlËBá¥Gplëã}}ú†euŸÊ"õb,’Ñ1ÔPk—„௎T/c¡`§òlãéÓ-=S®ˆÅ¬æ¾¢O_ó~G©ëçILå3è¡·“‘ï“:R3›}°TÛQU+®Ò‘‘»¯Ït·f�ÔýVôYà°áྔU‘ÚF¨ mãæ§7ÌóÂ%qeÞ>%PEçÁs<Í”ciö\·ìÔ[Fßk“ä¤0aJTeJtÉàñ»x~X¦ fGù wTŸ»uä‰ßã¦[ÁJâ{uæ"ví&óÊg>‰h¥º ½6€ß)ë®ÂÜ3ÂÊËžRŒQYDZïÄÄ¿~,ÕåkyÖ,�¾ê•§•ÓÍ©¯ýÑÂÈé—«_J”˜êt<Q$+»OS]ƒXŸ'Á²íú‘!§Ý�×#Æ–ß±U3ÓP¢�FAU¯S!ôB8aí~AÊ´DÚŠ¹…}ZU§÷¥ï¯ó[wœÔËŽb�O8÷Ǻ=íu¥›úѧÍS8€à >û~êi£a«ˆ W-eü–c¬Šó/úêŠEFNtßæA²Ø$‚8ò:e ˆ:7ß)B¸$›Q tÀiɇóÅc%RöžfløÍ€êr�«ãþçöµ3y:µ ¶Â§ÁBoÇ"^eŒ@ê@VÈåûî4@ßÒª ÞùÝø%Å*³ÿÕb«‚cGÅ*;Æ Í#KRNA‘–}g®ž+ë K¤‘®jD� ý­Ö¤\PôüqåzÕú}ÛÔ-'È×î¾Ç? Ž»‰Áf[&,íàô«÷Ý©»Î»ss¢]ÓFÁ½þ|iÔ­Ç(½}ŸÐaau2†Ýó’˜ku¼·)ïÏë#_U/AƒøK³­íék(‹’T-´"Ÿ„EÆóþ4vßÏ9æÌÍëƒ/O3/™Ç~K+=«ýúö` 6’5¢ Çðcö® °¿ÒÿìJÕNû£ïûi/3|?«I§¦”‘]—µczqæ·?׉ eWªÛÇò´û®ÇšÿžXYÝPq²¸§�\%v?K›Z”Ì'¶°}ãŠþ/tWR]üOPå(ÛÙ!Ô—¸–£Ë‚oŠÁzNJKÂr%_Hfck =#¡0†UÛϨ,Í܃2ëßÖößC§Pó ‹rÜÔZèŒç¾Çiã[Ê%Lú¨Y=Kü"×n¤H¸îe6�Z<yÛWAúþbtlÛÁÞ¦^èÿiÇëÍI?ÂF[^ zl¯i5“©ÕNŽµŸŒÁÓQ–?Ô²­$fâÒ{ss$kÞ5±5dïO011µÜ¯É©onËÐèk×zÀ!cß8†-«˜ók¬F«¢rÙí5f—ö 0UR{nÅÛ éi]!Uå­‰|E¯ö<ŧ¼ÈÛÐò©¹‹óJ ºuÛÎùÝW ä�a5â©(TBwí«QD27¹hmœúzÆFp÷H«7<Õo´UÁ&;ñGÊ).�ÌJèK%£ié|úPÿ‹J©·ŒD+ks§k=p»s÷R ­_lŸ: ýÉ-~Šâí?žkÂâ´ªÐaaû {qw¢Q®Ÿ,îŽr¬Zõ6RƒikêöàÀ?z§™ßãê­u÷ݶx“@ sˆWš£ÛDãÞîj¾²é+ƒsgy;ÏAàÜ7²´- D¾ºœ6q±¼‹É‰ªt5ÐNøC—ín%’}¡U®mí7øñ³Ç^_”µL75s£…ã`Æ‚†·Õåp~‚ß/œÊ‚bM­¯C…“®ÄLS›ž®IòÏR/IÛ ÙxÍÁ'°¦¡Þ6J ¯+:Z )ðcˆ®¤AYOì—>ÓÀ’ºØ€’S»„ß)­$^®/ >›#„ì;Gãb¶¡€ÈœÄHFþ NnݽâȘÑ/5Üog»-+6¼Su±C|ƒ³ à%Ý@ÿûó ç‚|^ÑV@X¹ý/·d–¢˜ÈKUp ˆ>xÙqÉÅ! ÞéyÎï%Ë2UA>í=&ÎN‚æA4¤µç_Þ×Ic—Ê**=ŒxŠæâW\HHã‹®ä´A³¶í5Wò.¿+M8‰†H,Öjú'®¿<*ks‚ •Õ“fÍïÇõ……Ô†‚‡ aŒ[zÚ=íöë L§Q;ð¬Æ÷†xì‹›fÞMJÑŸ&J—Úƒ˜ R Pú-˜CàÛgé«NÒ"ÞîË ›þñð‘Òd `× tisè,öµEi=,\¸ØAƒµy3VµúÐ)ó"r‹j£ŠÇúƒ™ÊܽºíGW…››–Ü¿8SÑÕ)ïäŒ ….Šþô02/ó•}�-fnŸ•­=ÐÜoP ˆÌàržþ0üõ¹Õm^f+žÍ ÍÄESˆ(äÚÐ QˆÁ|ÅÌŸÒL#»€¤a0&âš )Ö;¤4=⺦ŽôÎ×þjIìHó´h¤í}9Poô7*DZÖd}H{,]iŒcÑiyM>ÈÆb³y²ÝÅ*ûúxÂQ¬ÝÞ(ïÞ÷½˜¦kéèF)FžbÁ²¦æ›:ÍÑyó’¥³®Sn%‹ánµ­,RôË;Ú ÛW— Ñ‘" ßõYÄO·°í;†¯{îßY»O¼dËT¹¸žUõìrÖ8Ðû‰ë™õ|3šëTNïÑœÔõ}<Õ‹6ŽRƒ.¸ö úæ¤eÌ!à–W®=ôcn`ã©ÊÏÑ+6È !fÙ·þt}¢õOûú0WrÕ±'<’±àÖ-«ÌÒqÙÆ †Ã‚ÐTòT(o¨-ŠªŒCClšŠî–öd¤Ðë&OèˆÊœeîH ¿¥ÐG+Ù Þ`éRA³L&}FVMœ~ÏÔO=“¶H9,·˜¾pÓY/p¦Xý;ó «,×<øXbª«&ÔQr+“Û 94ZuˆÑˆsÁúÍ͸íî/ ³=pË…¢aö¾W-`I(¤šÍHGí²¼©÷|Ÿt~mT‘ÅÁù. ¢ÎŽÛ Aïvê~%YŽ‚û.­¯<Î\# ëUÈ&,¦ÏÄ[Ú|›h7õÝNo^¦É¥E¶ºˆXÜ>ü=Wo)¹çGú6O4ím†™§å̯äýËÑ¿ÛëÑP›Íi©¬ZóJfwÛáŽ+=(yøCŸqÁô'ùºzêÓØÖxÅäd¯JŸõ„&þœ±ÕSÅÈŒ'Núèno,Œì_üä™ìˆŠ"œ­[Ú|Ss«pÃÓºóÀP/"0*7-àËK6=ÒÊ´Æ"Ò NâåÙÕwS9(Â<¢Yì ¦ª5Õâûõ[¡Âë'r3 ¸Èܘ ÄìÅ¢¸V1õ2òDCJƒ³b«=ëC#çòɾf¯g×¥Y69á”Å|nÕ”µ [1][õì|µ¥ªPY;” šëqñĸ¤vœ(—×±scúöB…Ég@%ÏMM’yZà1ºŸÃ® ¢÷¼òûÃà¸î3þî^º5“Ü BXB.ì­eI7v4¦ágñ®-&GÞÃa Sü«w5 IËþ¾ã¾—ЯqüÕÕ‹@xgz×tpvh¬¬T_¤E¥“²t h£ä§¶Fyd•AÌîô(—k^ ‡’²ˆ Ô_ˆ”Y=DÜHOœcö€DäµvÆպݶµ:èëŠ"‘@ÕuåÆųh07vs³E´Ã¬’´“”~ª2„”àdÖ± Lƒ &få²÷f…GØ] fÏ@Ê^ä'½ãªG–ùX>ôÛáÜZµV Ô\²%ãÍžôög9îV¥ñm¡œÆ¾Ø#|&¨–/xyþ¨/½–á/0oî±p|¤ åÀÂâ½$ÀI\¼ëä,ü;ºêÊÒˆþÈL¦xo\¥~¬¯¾š+çúÆ5äµC$ÎVLé7 aï[Cî£TäýÜPv&†Ç€«s7¡cu Z'ΨÖhéĵCp„´‹ êf›ñÕœþO¨ü sš¤r¦"qÖÔ¥édŒ^C×u<r©Ã̼¶F¨Ýäâ‰*Û(òô?g‹::>NDz>J³?8üÅ¿ý£Ö(@|GÙ› ú»‡ · {i[ý^j7ñzÐ"$=0Qµ¶}Hyû+–§Z»™žd_ÿ1ÇÓÃ?H¸îv]’<\ÙÈdA΂ü]ÁPyxÜRvƒjÏ`ä7hô²Hɪ u÷—‘õ‹ ãÑ´Â[yç(ç­z–âg?‘oÓÒ—£Ôè°£ô«¾8ƒLZÃ_K§eÿyó!þu<4¾ùñ>‘ÉJÇ‘±`¸ÔIïÎfoò©Ç þ¯òDúÓå–³ù’‡ÞHæÁ_¶GŒÂŒÝlg=ùÿ_’xó’šl4åVmR¾¸½'v°Ô=÷ª×¢aïîcøIZbLjwýeìð¾ÚâeEæ1Ÿ!¬ÁÖMNG‚—α¹Áf#Dê¼›þÂÆ©Ô|,2Õøf¡‡±U iÊ°[àŒr¨Ã;<¸´ª¹oþBo<ž B¨¼@x(M´€ÚÝ0oŒ1½8óö»Mô'ˆ?­D�º õ8Nð…ÿÏ[T…ÖC ÿåÎ1p˜uRó½ƒè‘ø¥¿Ô'A2uª¤²f;­óÚâ¾_ð•¡/z3ÿšÊr˦`…‰þ”·«,ž†¨Íi ˜;/¶ANEí:ÝvÌ‹ÕúÇPu†“›ªÂ#¼ÚÔ² Þg€Ódµ hS3ŠÏ‘¾aþÉí;eûŠ/.WBÝ°m¡ç;o`L®‡¡ø…2Qä¡Ø#¦ÈÐöýºz*ÝnvyØ¡§¨Ïè"ßò–§í-:[ûɵN©†ºN¶9{ü ‹\z¯HZÿt|*f¸ÓtÊÀáûÑòŒžf…æ"gÊ,ãwÕé-ΟôΞ±~µùW„üm6¾nù®I‘@ÍíÓ÷wììRˆ+¤nÿ–keœa%å°­Z­òè†QÍ:pú;d‰'…!¹òØS…`º ¹(UÒÌAëíÿzؘ‚þÜP-u<ž©ž–·û<Æ#—0oèØô×¼Õèâxe D •©²TË+c½+Ê‚áQõ¯ê¬´r£´šÊ�RJ-ÑžðÊ‘‡â°x ½"ôP¦™/JZ!1¤L—Iä‘ëúíëÅŠÎÕýЙ?ÂýŒ°ðF7†vì69æŠQûÃoÆùÓaÞä’®?EZÙD’©±P߃³ÞÕV4/XÖØáÜ'ïjÍhŠÃÊ—žS…ù¨Ö%ƒ°DSã?oÆ,3-CðÒøõŠÜ¼5,JÖ™¬âkpÒ—®a¤¹‘}B úEŒF¨ÏôŸè~Ý…#X ™‘(/ƒ+@}Ñ^o?Ýß¾£y”óSÇùM'u1>«Ñ£Šd­^ĸýº¢ÚsP }μ0¶{±ä`¤ï¸ïàç»84 ÷¥×Ê*}¡¨V¿[_çw«öð§”; ~Å^ü‘‘ïµîý–IlyJ©aË!à´?»Dðå5må²F¯É_!²v%üR­O‚˘!BdFdJ–ŠnÌ}±By#TÒAç´t/š>OÚÞéJ²ÈÀŒÂKo¼B“‹Ò-²£.ºÙ}Çgì—롬Ûù#‚ˆ÷§/Iwº¼Ø†Uhgk‹5ϧQŒÇ®þX÷ã0\¡Ý £é5 GQ7Š³xjwV*ç5¹Ð•Ü�Å6Ú”–½{ãÖ¹ï˜ L &:Ê¡;]Ùüí87ut+Q!mÞÔ½ÙØŠLº+V÷äù¿YÌ„°B«ýNËCvbé©8·ðÄWç#eÚA«ô´ê•  TÁá�èC0$Z|B_JÌPü¾W…ü2òï;{ì(d¨Aã–åvü2=Kœ´“Ææ wŸDÒDgoù#Z9NS¿B§ˆÓÔH;Tx1C³~ÓõW ÏÀ€�Ü¡=Œ>¾*N<¹qžo¶ð½²‡Tº.‡©ê„aeÄía»ýöê9߆'Ô ô.­âµ k}–±ë.&êØèÎÅͼ1 Wη9æ˜P™×Ž;—ÑÂÃ@Š²«ù?oYjô9”'áêj‚ÞÜH]Ü\º?™ø<Îðµ"ö‰Ä Ξ~“^˜~Ùÿø뽉l'é·¿q†Á¨nYfè2Q-ñùéf¶ ÀÔ«òÛya˜dþÈ9†#Iöy6÷²ä?Ð÷bÇ!„¨_N y'ID_! ŠýÖÓÓ¦ôað 1_øè‘iº ɉÇMEYÜ^;/9}t©ZÚYÈü%¦®mÁãußïL­JeA$öÚ¨„Oõ‹Ë·ÿâ±Ë 8=x Zàñf,ø¾¥Ø—Xr0XˆóX‹‰víLç[€Môî¥XMµ8žr*ž§z£œ´ávÌ+í—"»±žZfz_{m­FÒ¹`|©8~$ ¼áOÇüßÌçËÈ9Œ°d:Kv¿kÕEÜc¨åþüæìó5ƒ…izŒUûåæ¹¾ñ!d<d±*²š×¢èâ·4è¾rr÷àM}´lG(À÷v[ÐG¥ÀéªÜ¯¢_Ñ6ãÌj”aNXÐ~(‚Ð<z #ôì9XŠs,'òm}¡Å@¥“À¢Í÷¥„ g`À<•H÷ZÎç¥Dו È¿ŸK¤åÊ„9‘Ž~:©Ë^—žÑ%-¼ëHoy…PÎжtÂ_ôˆk:µîü ;²Êìð/ÔªòQ‹ÛËĵ ƒ¨9‘GÌ*ˆËü `•¯­· Zƒ®Ùâ;p7g®Ôí9.Fs÷üæ¢ÜÕ ‡°C°Ö® ZÛ\ÖŠ‚ÞoäQ)¹µi§äaÒ–Œ8Ù¸¯VrÔßàœOdzéã)¡tõüåºÐŒ]åÆN¤�2`éës]ºR¹Þ©QðD”MYÔ+²ÙŽÑO–¯ñc€]ÇÚØç 'êÍÕ´árq>®È—뵞`{†1FÛA4yð$fÀò?Y¹£Í©Åý™Dšò±>CZ†kªÔ°£w¯>{Ot§¯¿œ<6>× jÛ¯‰qeQæáp)î-›ñ^]‹ÐW³Ä¼Õyó¡âë÷üT"K”)M;j³Íã -ztJŠÛˤÑ0Ú1˜ _ë"h§ØÚjÛ×ePöú°óR0nO;>b¥§g~ÂßÝrâ‘U6t³ùò|¡¼¬Ûz¾Š1{uÖ[ùUe…4W´‡œ Ïê_¶bfj+ªÃ]Íc#î‚€Ã=ZØ!=ª>)CSÌÌ]EÔ­þô0êôÿ:Šu—YOwѳåTD>D—Šæí5³úþLþu…™>v•;þ¯d"CïýêŽ [ìµ®2)oh…ÙŽgêšµú§þ6ïªÄUR�VÓ®òwmýlO_ÂØ –ó² Sy>ŽVã^í\·vè"‚ÿí{Ḇ.t¶µ- °–€(÷¨º›3÷¤EòŠ8tìÉ™±„ÑfAoÏ÷ ¿èâ�‚8tÆþm€˜‡¾zº˜Ñ0yhùãaøÕùÿr^l‰Á¡P¸;CyÄõ`@4Ò¦b̯æ8—“PääÅíØg¼²Ùf“Ó{XÈ;|!Çÿ± ÒFWnæy~BϬ…\¿ÍJW¶)e. OL´RÈÃñГ6M9sÏ;ŽÉoÃÖg SmïîÆÏä·85ÍLjSp:d6 ż¨¾* ·¹4–m /jB5*÷k‡'W’fæ º I/…™¨O‡ýqîIwK¯zåÑyôZ)—SØ‚£jÿõÊ,R+Ø*î~”=VA1X"8ÅVú¬ƒ¶_äI;™—’—N xÉÎKó<rÒkåUVºêŠåX¼×ùvßÛw¨µív s (•'¾–O¦}ÍýH9O¹÷Ž­Ó䛀ýÂ"$JtÜœ«é#DŒRGÌyDÃ-Óç ù‘ØW:Œtw »‘ ª³¥;ƒ†ÙKTd@¹½f,kþ¯7Ïs‹<iÃ2]ñJ)ç]пz~¶ó•õ´Ô™aâ· ^~h�pínë˜ ò̦3Î>`í@‘,ì-¯ R؇aîn¥–ß^‰w£òý÷0ÖòdøÙe¥íò,Èe±©ÿd~+µùÂÃ'ÎtMŒð²ÞUY,§€,M+Æ™]qfͬÞÿªB(RŸƒˆ-ÅÎØž�ì£k·ªr‚v<]‚3fÂ7¼çÐk]\ô]0Kk+ör¥…BñFå…ThÊþ‡_ÊØ¥¹7„ÌØ&ºçïŸîöðÞ¥eêÎCWÂ8”×;TEè­¡µˆƒäb;ålB°AG—ùyFHä„Ž¥gæÉvSç~ú&1%½5Êr6 Ô\T‹E\£5ˆ¤¼ü«3>eõE¡É2÷uAYæäÉ*³$#RÀƒ™„é}À{„γRº L%št‘eH»áˆgíç~h‰n„é§}ÃìlYÁÌÞ¤ìâìóà9 ¤,b-üý ®s¤’.Ü<ÒCŸõÔ©«?¢Dum.Þ½Zñc³tÅ ˆ‚cDãdLK ä½]ï…›tózß|´ð†¾¬ez=Ñ]Ißµµ€Rä½›þfk~Ë£<Ô%B¾–bç¯|xÒÕM ñHà=0X½�fÂ#gÂIÀó‡Ë«=ú¦˜p®qúiîÀ¥kúPÉ“lßš †îV-|:ˆj ¯îª2ö̋ĤˆN~àöÚìŽù‰þ#ìÅì¼ð%:iTæ®NãÓn?&Ayn¬ˆxIçå|Pd·”yî»#ÝúwdHÝ·ŸÛzsšÎÇï åv¨Åݪ¨�†ÆÓ!�§»šˆ:'@DƒœÅ·�÷½À /”°ÌÄ°ƒdX³8püjD¾©¯‡‰¡Óâ°zT¥Þ;1“¦0(G è¥ù pc±ñ• Mÿäá>Fµ oüX›¹ â³*ËXž¬üÔý‚ëz~þBYäFé# †œ{ ©&P¼˜ VÆ¢ÇQ5½¶{ Ð] äj¥¼ìNGµA±Õá_Sž›ú­9S¦„TQD[ôOƒŸü¬™­ “ѹŽ“¦Ð?mêÉCŽã�mýŸ‡Ñ>‹Œµb6<2+]PZ+j1ŒÙY÷*ÊïN Në^À{,2`»ã`,«Ä‰œ,œÒ@U¡g„ƒëžþÉëwgÑF[qPŽé<ó FÚRWpض,pü›æ`dåuÁ=ß´Ä}ÜQe& t·í ¢ˆ:2÷ãÍ´=ÑïÑí‘C‘9‘%ö…G_7¸ûÓ×`ÏeáߦªÅ7÷QÐêâÖú–'<{ëŽ ÖŸöÍø%—.²ÄÞʨ ÐLþÜ{o&Ô»²Ó¬—GýGWåª ¹§¸– K¦én2bFeÊÙļŽôºÍ‡{ÂÖ52,õðêéÝÎz–œ›ôŠ¾4=AJÁ¥Úî/$Û‰í’3£—ê©e€D†fB,+nìKÞ@oÔ#¶ðÅùµÞk6[ÅÛPû³›?EPÔšÈs VŸbÏÃFk½$å,îlu°Ÿ¤s^§¿4Gp£ªàç�ãT™ßFN˜Ëa‘°öÒ¹e©ŸÑ–`§€x¥$=ÕW£Å€ç˜p ³3ÀÞÓt÷k¥mc`& ;C3ò9Öu°”U‘Õ‘ï â:NdG&õ ̇cwzÔâq0(š™lP¤ª_Y>êëQ©lÒL_ Ûo½-�·ñÁ ~‚Éç–R•™éÊÜÅ‘'õ�¡äöÜóMP¬—ùýŽú`c?SšY,£ç¼1«²cqmàvè)L8~ù—®0§Š" ’w­»‘ŸcŽÓ\5-‡)~ß.îàD¬Ø/AèÉcŠc½ðSÝrúç€#pìAúN°Aÿ¿ÿŒä“ÁeÞ©“£²ÈÖõÖa¤ØŸÿñzß|p7ŽA‡Þ¢ÍìûÝ,«|E¨€Qa˜~n5A€@Ý‚Òáʨ¿âÛ¯e~�àXÉW*O*¸Â'Ör°âÚMw±MÀÎtf)ÞÏíj­^MÉò©¦!àKÊÜíþ=Ã8Æ¡oÁý·S¤¶³‚Ñ¢8›ÒEà(þ`#¼Ÿ¬Ä 'ØrÒIQ ªÝÖJmÅ›µªˆ%=¶ðÙÜËŠr?oPÖ_ߌêÖú'€f=0C`f¦Î[}ç}7@IúÜrJ¡øÅù?o)óVh#"Èéñɇ‡:³«Ý/î¨Z:ø÷°O}ÌÝCßÚ|ê=XÕ ?¾SK,}¹ÏH2’úҌǧl(ûÍ—¼Ž­ üÈ;t½€|°¿1aÖÜ=IØ&ð  !Hû¬Á™M÷ÞøÝŒª¨ ®þ‹Gʯ~Ðt%CiŒÙú3mÓsë4dAõdàþ<NìæüÏ?Ðoù ï3Šœ�²ä<},øk«f9sh„Ä ;ÆÍìn~¼M»fouz~и±Æ{&ºACŠÅ_û¦ÿ|ž&øLØ œwÖŸB pz -}ZAä‘Ž£a(Í„Ïý£OâõÏ*”äôv¾¶y˜!hf¨Ü¹©> ØÞÕ7V“ÑC=$Üin—pÒKwµë߶§Ú’izGºdÀ Xä7²áº_HaÖotB“ÚÝ,6î6qá¦üÑ¢Êûíi€d€4J‚’n¹Rª ç·ÑC$å¿5 ˆ@Ž¥ü.¬RP”г;Ñêw|4l­W$wéÝ£Ü"ñ…€u…ñcfa†˜8 B0OØ4 ‚€C]`îÈ3æyQ8Ôx‡õŸ®±%@²ŸmÃâ0_%ë`‡AÅ{ë$°¢N“òS—§—ûEå f®YYË@vâ/zº˜B`Ý:{©‘–g^ÍÁ œÓ¦ì£6Oõ‡O°âf Vu?‹¾Ù¯ðRQœÆþpZ\·j^Á²¾‡é$d_K¶FŽ¬úÛÌDNe"CÚ ÞK›Î$MÿŽ„ÅNJJoèσ|Ø[. ?¢‡)ã¿8ÿ®Ì<z~R;ëL¶­Q$zvnýŽ-LuË5šd!WÚï:n~ô”>³h…^+$^Î:�¦ü„cZç¹ý5<$É|7Ê=A;÷ª ȼ¥áªcŸ8uÒ3TÕB±[†'<ô²òQïô4v}¤v»D`ªraÌ Ð}î±$ÂÌ—Ô.‚KKuâЫ¦Aº­kÉPiº"ã_ükÆËÑÚ½cZ™¯@$TD³'B?xô¾;ÖõÖöGXæ[î¥ÌG#Y™RQ.#Hƒ©¦µd„©Ì1ÉYÑkºUQéå+<™ëœvó§Êõf¸!L¹ØÕV‚ ­5|cìqJ¼Ž¬š.o¹þÉ«–¥›ø …;cOº 9Àƒi÷ÖÐIä®î°ý­:½z?nø¶ƒ§qÖÀÀëÏÙ (˜…Ö¤�äQôÑ·Ô3‘í¾¥€žûÞÊ8e‰Ak(ŽãÜvñ®.X9ïø—‡þf…^(=;TüibubBz‘¤°@ïI Ów6Mdµ-Tëw.ƒ°û²lòݯäß‹9*0ÞÀ2îÏGÕ@@´˜mJÞìëôû×M.H`¡ßû­ókbNèãG{ì:†àÿ9l¨?ÔN¿F)LVûqå *$0>wNñfé.È! ã‡vÁü}'[ÆÝs… }wL;)ígÇ÷ëaùíœ4.`š‰á-—íõÅÆNÈœ@ßS'Í }mjÊ –žþw"Dæ¡_XÄAÌØ­d^ÄR]Ç£ ã¿æÅž8òH‹ –µÓ‰Ä.ð¦40ˆ?ñÐZo¤_þì}Š<zò×’ÇEŽÈƒaÄL¹ŸÅ¼µÒEZè|SZÂý„,ó±^L{Zºùòir ÔÜ;¡\ôm¤kÁU¶ìøkSt0üøP¿Íß»7 tK*7-8Àv£w½‡yÍt*Ïà—xÝÄÛŒC@>–wJ×B%¨ÃòÖA=¯óþÀæc¸;Q‹œõ©¸¹6-½oÞwž\:ü0?bÉTnCîHþDE"NÝ,‡“S^¤ñ{íát¤#Å ‘œ“n>_«ÆƒÖNŠÐw.ósòí¿ûú*ík?ñz3µð²9žtTÆÚÖ‰RU[p´Ó}%¿‡·=K‹ÌÓø¯¯ ªfï¹AñùËÊÝm·•›ìÈpm9«"Ïœþ'Õxç&eW³BbÖ,®)tŽ]í0«ûúŠ‘»üûÄ•£¬<Ù^Îf,ÁªÑa QØ:ä_¼ñ_ùØÝ"?ÖÂo2Cöápt«…œ)~ç½>Âq̶*÷®î[ò$.ò莧g w2³·vÐ¥‘6•Ã €F˜|¶>XÀSy5ò)p ô:ßÇñ‡óÊ3{1_•Ÿ€÷äQñ-ð3ñ^…7ÄžÚwƤ»i”ÏeM¼Ý~9bÌëζ®Ý;:èïÅôÄÒtË{wcX1Qûi:>Qçþ\ϦNM…ÇjÁPá41•$/èaRU×"Þ8uÇÃŒõzBÍ^_×!õ¡!ž)ÛJôàJÅ]ë©C£ð¹ÏÝ 3ç#Óôµÿ³ƒû”>f:7=fõMFÐHšQýÿUÓéÉ(ËÚMÁV´4?­é)Pñèù­Èåÿ¢±iÍ iHÕíÇ’RBS{Õóuð‡l`’BýæÇG@p':˜ƒK(iæ]ïà…=‹É Ò¿ÓÑtÐŽH9±åÐ6”%½×…îxIÓ±¿‘6"íú’/ø»G>IˆÙÏpINìéŠsŠ¶¹g÷³I²Õ¢0g\(4ZmþEV}tYÆ-þò1è%˼¾*w`(ǧ]h» Cag�)ÕN×ÿ¼!×ä¼ENZ4š0ü7³¦u^ÿ3ô:ÍVºM{´ÊögJ•˜õb½ã»rë¿å+FL{ˆæt )1zˆÆæ9¶ž7F qŠ…ro^×.²>í…ÕyèVÃÜùO’Kâ±<ãÓ4Zo°»Øèru\e¬/¡FÞi'xÓm½`j2ÖºÉ{ÑnkO80 ú0ž.Wý×.}ÝDZ§µ“XWôˆe‰ÆN¶éíÂyà­Òmù…Õšœ´Wf�²TJE…,ƒ …YX#úç–ôÅ¡Êå} Í‹"(¾3ä¸uh7§E¤c¥]G5”ÉVNœKRb€)ó…nF5é¸5¬~ªÞéÜš¯ÿšŒ½…Œˆá­‘sÃоÙךƒáhß_5-³Ææç/s{ž%g‰o5(R;Ø%Ù( %~ý°:äFù3ÿ]¡(3ì™gîèÒÔ•œìxÕÌ0Ùlj+ª¬ìb“eHÈ-º—ûóN!®0:·Ë�•¥õhT užH4¥aœÅܾš£Ê„’Ñç^fºéYýÎÓÛ;¾õÛ m_ÂÊYtXpW Z”𙆳Jw‰qÀÊx"5å‚yÝy¤ ¦«Ï[H[´ükªiqÇ�Ó.~?{P’ÝT_=“dz{J¹s€Ä°±æ…ÎÈroM«*gü$OÇ9t³̬0¢Sû3ø Ýìì̘j…e9óòWú_–Ä™™æíüQù4OXP~y4•£‘é`T‹ŽÛÑþôS‘aù,éc¡£tß{J|2’1³ Ù~o-‹HÝ“eìœíû€iSÒ™Ð{å<XÅ|³…_Ó”tǪ̃˜Q]GûdÔ$_B²ž“’# ssµsÈÇ�Ò´Ì|Î�| èI‡{Ÿ{´{Äìåü%òþ×æO[aŠõÅE¦ z¶éÐ:8çé}aP²IP÷&ÿѵÌVN½Úe½M+ò È> ˜j~ƒ^QéÞ#¸æ¬·fByµTo$sÃׂýõhòw…æž‘p^±|à [®m¶ 4e¶žMÅŽ¢Éiw™œg;=d¦šÞ^xºÐ†SÓ±ª~ñÔ;U´]C¥ ü$y<cüû©è‰¶‹2¾ó?Vdø¦ýµwÀí™s_½ËÛ*9ö Ü‹ÿXrÚåŠAg_u/ØWl;ûG¦æ ºv¯˜9À»(á$âÈ~*倵<: ¤gsëÆpÏ•¡ˆ|Åo¸Âžh…ÖÝxÆqk¢mMGÚ©ªŠÌ”ÝÕJ5Ê|=Iª"ëîbšð$<¯„!šžµ¬—ÐÓjœ½«ïô‹Ø!Ð|Ñtv>Ÿ@»ð`á0ühM?Ó*ȃeKo¼÷ÍÔ¡j·¿Ô‡¥cù3³[–NXB—©£G«/¾)·X­e´Õ« îgO<bÓ¶ë³é„)òâ´!Ê2Ï¢”î6¦©Y¿óF�Óå2‹Ió^¤Z^Ó@ šxlmÍ@•ÁÆêUåʤ/¢`5Ç;Ãà¨Ê\RP"Ò~,tS²v4`ª¡`†ÎÅÛß*‰#s6¤˜nœOGÿ_Þ·Ûi–­äžbïiŸ¯*ÖßÛóÀD$™j/ßâhæqŸÐåìlC Æ›´N_tøôÿx¢#Ð[¹8±ªùñJjýâänþ…ÌÛÞj8Á!³›»éÏé ðÌ©ÕÒï5útìY ¤8¦ÅñüìPìZ%ùdæèÿF¡þ Z–Eþ„ƒ‹o夬5:Y-_‘3ÔÿÎÕ·˜&)fØƆm‘²•pÔ\¨d©àíržµðƹƹÕí+•Æk[Ò"8ì0d>¶{s˜jeõÿ°})Xïü~œ�qgn^E옾Äp�y¸vÉ Ó l`üƆ£§?§yq”Og‘§-*¹W%Ãè³ãÐWñáBÛúÜ 6õÉ,:ó´êy€ºÙ£˜m<,µð4·Òt^êe1Ìr‹±õ^oÝ-¥µ rô~Ž¥é²d•bágIg=8ÆÖc Þ9~Î-÷ÇÚ5%‡|ú¢JÀ²ÈÙM¸SOßò¢)ƵfÙ:§­(°îãÛ½še«_0ç6jµ/ 3¨KžNý7ÖíSÝ0vV¯&È‹. –’Éç4¼õ]-­µ„¨¥§Ôœ‡åo|g9¨»xXû¸éXy·U}T Í½fNk»ˆíÅkK<MVSúCsüïVÏ(‰ó„ßñ§Ôd8½E·«þ ‚¹ˆâ²4Ù5›¤ #ˆó—‰ð™å6Ân:l·‘ü(¿–+³êºA5¼Í+2Ä¥8Óîc{~¬­Gq¦5@¡5§©ËRª¿[ÖÐQ"F²ýÎõ¨¹q€$L ůšÇF¹ÇäJðÁ/YÌŠ„ò>±aó'± t›‹ÊØÊšÛÕýݼ5¾Ê=‹Šj»Ïi»µ†ÁœcŒy!†Ë^ͧ×/^’*ç˜Þ, b+2Qr©Ñ =}_œuÜŒS:Ž£Š#'Ÿù�ÿ–Í+k,â½KeÂ¥F~Ýê!˜©rŽ‚‡?¨˜´pƒERsóÞ¹p½tNš¦#Fê“'¿¿¶mHãmöw×J‹å.œ:å¬3è$ŸË ºÔzƒKöP¦;p¨e•ü+P\¬Ž%iÒ Ûé!r©[L)ŸÁÈœ<EW rHd^£�#¿ByxŸ1Ëö!(xN”RZb*ºÇO+£ZÀ+ˆ’»ËJuÚÏê:„‰x}âœÎ˜@F“CË¿dÄÑÞ÷}÷ûf¶ê‰ žlÚÅðùt¬Ì,0O‘ö—t•ãÔ¤ø6 ãôÐ@΢=Ô®˽Lù1¨>?ô—~þ…Ó@cZ*-.P§Xœ"f%ç ö`0ÖȖͱ?Ì®JYNöÅÙJTƒjLo]r)¯¤=ù†8Û¼_ýˆT:½Acu<;FOƒ%c›Àê×?¡3¥ã÷dÔÓ÷aÝҙΪÝyçF—rÕ˜x*a‘Ç>SšNÎå3 ¢ñÓ3ª1Ú öÌG!y¬»Áj}ÃBevµW¹ŸGIM§}<ÛéJ ´i6ŸöóÌÊ!/‘V¾RÄð¤iˆ�ó]†îÛÛéàTíÖ —NÊL"õÚ" ĈðEÕµæ½áõ"ÿ_-TÔƒ ÂwÕ/VžèœÙŠ{ÇÐÚN% 9¬¹Éü~åá‘ÎwˆÇí¾ +†Õ ºoJ~^êAPiòj„CøµGe®T#u*bsµwÅÌp!£ôû©Œ³V⥱ÓkŠ¢V=OkFÅ2Î!)XÍxúS 鈊?]ð�|~ŽnË 3eágRöÖà cî–-g„í=„ß<ŠÍ™çñÅéOxMÛ©›eí´I¼—Ù]RŒ¼ÕMsZîªg¹CnF"®ÓŠýô-ß) é3:õ²2øÃ0Äij¼Ä'ÏÁÕªåê»SÅÜt­ëƾ:7Ë3Ÿ%JšU ‹³v;¥ÿ…H˜>Ox%†®¤ o #'žÄ¬ d1#ð�çaCEãn{30îl\$¿òD׌ÛÒ=ÊSµR<ZKGfÒOžðp¦"QÅS ¿ýtZ´A þoÖ?˜üq^î”RŽkœš^öþ\P¶a{Ù´µ÷-¤fn–ù¯r´¨JãÌ¡Àé¡Ç}±¨3P¨étþ�GÕ$lFkAAö?‚ÞO5̃ßЛ¸�Ç/é×z¦Ö‚‘²º/ ɵ7ýb9+nXçóSªsvÕ Ð>Ý/3ƒ<‰³•£y“A1ië.c‚2£ü¨îŸyålã^V{XQU´¿x²¼ÞphŽ¿±>:FÿècU7M¸é–]§ò´©Ì�…j: ÑL‘"žDzƒ$ý‹ƒMM$j4õü… ð{á3=Ð €8 Bv>cæXs¼ }‚•ƒó5 ŠÏÆö¤èø¨)ÃÂ{¢µ¦î¼‡ã¹äGûéd–ˆwé+Öe†eÚEt³-‚y jÜ‚>ñÛ…ÎþíÞ’T= à�­@<ê_yfGÅMÑÞ£<*öŠ§‰ùŒå4\—é81†úŠRh Sj¯jÞ~ì-Œ_Ëô ËÙdÄ”pIfú6QaѼµŠ C å_!÷~Zgæ ×ÞiA½w^›ìÂ…õ`UeÐmÀ†¢%pÞìïüæXs jɵá KŸ´¡‡¾ßübè)jÎ@pžF£‡1JåÅÚ˜Ò¡9Í‚²žœÁ‰§œ2úÙëèHÕ ð<u´˜Ù¨4þJ|× ¹TÉò£ ÷?ß¡d=Ë)ÀÓ¥Htõ0óÇzá~°ú ^µÖ=‚)ÌÁçlÝ"vóV."ÁYK?£˜Sá~ÉMËM— ÖJ"}Û¹¯eƉÎ2PtîÝØ™C_/g…f ´ìögƒ©¼y„­šêkï&cØÕóÛ⊈0©%°(´T~'êy‰µØÆ�pü¤ŠötìxŽì}Ó88Lô«£“ýxA3ÎW N eû<HßTTÏ{åv¦êyâm!Gºã2¯2ì¼ýôkçePM€dSbµVáí»ñp:U5h´ü ;¥aæé2@Ý…U2mË¢dÎ2h~ÐÔ³hòHÏ÷‹ûNˆô¦‡‘–×`!>8b÷Ý @%iìFyóÛWÇß‹R¯]Ç´ÒgX…ƹˆuëéfl>‚à®Û¦å©o}NÅ¥.iÃ]| L:­Ÿ_;°9¿ÜöR¢¼rýÆ,²P>kè6Vï{£Sb^Ëð<ãñ‡ÂæÈöÉ¥Y¤=&~þŒ¿•ƒyùß·¡;-/`—‡ây¢ÜÈ:Ô` s~‰Ë(B_œœ¢ÃœçAü¥sÆ ¢Õ² ,Ôt]·x+³l§ .$uîêœ)«|9:é”ß×JŽ30±ø`ánîý¶Æ£Öyja0‡Iƒ> âÅC1ë>¹'ø@0ŠMO^TŠ"Ø=–l£lHGXÓ­°ê…·ÖÅNVû ¿²ò&$ŒŽ ^¬èOÛèSñÝáût‡? ·ýY½nå,eÄÓ¦=»¸ZÁã­z¼¯J.<è‹h ü+¢Ö¬’ñÆTÙPŒ;Ç;1W=ÐÂØF*ò²`7–«_ÉT ¹fì{ÓÓV´×î ô!NÃõKg óA¦Íȶ¥z½/’„Ê}3lŒ¹®Àé/W×ÐmÏÏ!X&ȬXN9jDÝ—.¤‚6‰–¯‹`Þ8™¥×íµoo$yŠ*‹ØÔ@¬©˜Ò~ì)N¼•Ù[™¿•ochZµ'*¬œ¾ì/:ãÈ)| #<x†ŒÖ¸Vûìûê†Ýò£˜Ž°#ìkhÆ$‰3¯ÓòN(8.^J¾çÕ<›ƒ9d¸‡ªaŸa÷í_"«¬=Ž^ckž*‚îñŠñ–ëï^ø¸á¬õµÐUx䎌P°§í>ópeªì9Ó>4©½a¼ 1 Ž1¤O¶–1„#h^lßQ º¨õ‰-h®œ2`ÏyI('Ò{^Ÿwçø•¤ˆÞþûÆv¯ŒAZ@ »Éc_uá¶øRi`cðNõo:û63ή©/m'ò‹´Å÷(7ÍÂo˜b×TRá®úB¨îü»˜î/@0§úæÑ•LO©}¬‚rz÷°B'‘¯¿œzm›™²ã¶>KÖ®$ÀŒî`MøkʦˆŽÇi»9ÑNß&ÝYOEÖ?EÿSÆ&¾Æ†Š7A ¯MÄÄz]†˜ƒ>ž†FáJqŸSÅtö,ÿézÓ‹¢eqùW>“w‰å\ùÞi´}åHÞ>f=¿Ñ•¿ÔPÏìA,–•!|„Ñ£W)¹¸23þõЃâ`DúPxµR•¤¨ ª­ÖÖ¥x¾QüÓÏüK³Í2ñ;ÁÀdPU—OƒæÌðôqn¡ÒEý y.Kœ^KÉ¡$a1`cB~j;!&¡³¨XC«ÎÐú¿’pÙoÞ„0$HÁ¹èJï3—öVvƒüNýò8› ÕãY n¿”èãLÅÇ­ ±•ÛöâüË.z¹Uð„…šwõeõÂf!9MyÑꬾrwãÛøót*¯,✽ï(Ο•t¿ÇûŒýdÖVKrè[ï]yês’'Ðî#€n•\„î5›½Zú§”7VM‹ÐÇ›v),Î-ª)CÍ6 Íkˆ  ²5#�å&mƒbÔÉuæÕPçÖâÅûÃȪˆt‚Ž;CšøãRZ›)r븡°Xê(ØG_d:Ægñ±ßb•‡¾ˆw�€[¬pÆsdÕÜZ/Æ©kMÛäŽË†ÇÝ/­ ºŽš4'Å –¶Ô£°¬JŽx·w#sëU~Ç “éÖ7\?÷è–C¹ñ‚Öˆ±U˜ ©ÛÄT_W©©§ ˆ?–Yi<ì¼9>O#tÂçæíëJD1ÁÔ¦Bô¦ËLw¸<_½\ÙàGgɾɈm®žë5�À¼ÔWæ}“¬\ó§FªoXé¾ìt¼¦“ÑÚCYÛú!°=tfqæj´#y-O±kÝûˆÎÈ CüéÀõzŸÍz>m(‡×^|®­xúŸñ˜¢›î[‰þÔ/ã•S‰^ÝHÙ¢=EêMO…›ßª£Bû(@É¿êwÆQ¹òðφþ)>÷~ |ê[ÏKÛHW Ê^=iÿr5 óRFF°ö´¬Z­Âö|îÕ!XpÓ~“²Â†_täA±ëœjº*Pm‚«”·µ¡“ß95âÈ9Õ#æ”fû¥ rô˜ïay×ÿvëC™‡¼l« q#P&§ƒ³¥v†vKɦÍQÞ œ,§Tzö9ÂeתcE6^O5&¾ì¬a¬Ò^p®‹WB¤t€íw°‹ÒzÝÿéê Zó³ìv¶âí7#±)kÍ£Ëgx ,7%ƒWô×ö€wsëiî¶,Âå/+QÞ“g�ÅQ:îË m$®^#<W]k]<Ô¾È8‰h_Ô=øœÖ>¶ßÒÙéHÓW™Ðë]=a)ü'–ØBK2è‚bàá}󧊣eœù¹RŽ TQFYß-Ym§Àþú—ÖY‘Ï0(TT';»ãÃ’'ÙŽnõ¢ÊDúDE¤}=-‹ÂNs =É€OãðÎ}'Öðó/‡‹þ‹·Lâ*u ;¤Z„Œ%1Ã@³§Um‡ôh¥–OošÂ H$y¾-ÀHzê!ꉂ½¦A­*±³… »DêáÄ¡ŠR[½–8á@<«þêh(øêéªB]Ë y nyf³Ì?å +o€|'vYÎ}lÌ€Íã}g$ð++f<ëÈ‚K¶íxÒÈÊæuݘËÝ„.f/Õ-ì°[;âàDÅâÁ XÞDžÖIû²ëyVd7b‹»3E³÷Ù é¦Âfµ;xíHÝvçêŽû)Gz Ýi?zNÔ€ HÑÖ"»“<2)ÉVüjZïÇN€€ªµéë?ž äî`PGè;]õÅä©aˆqÝ_{Ï)‘A´àXŒÀ›ò‰ð´Vˆ-ì@Êñ(øXbÏ iêv{¹�S´gF’[èÑ-ÿôõ_ÞÁýç>Ÿ4ŒÄ10Y,TLø}j,%õgü‰·ä/"žŸ[Šå0ä¢ßuôWpÉ~…L×ï`„ø'of/n7·åïGªâÌ"Q;©—¥h¯J#À´fÈC”¾=C§?ÈZtÞhû ®NMýwä`ÃQPf„ ]«Qlº#M=w° ærÞj¡ß9c [YÉëôÅ:,ô}¦ÖóâDGN‡-Òrk\>•`¹ŦAÓfAåD@¥ð‚÷üæ/üD80R?ÑÔPú‡ e“&l…‚êÁN¦ž›YÈ¿è²FlZHçÁ¸÷‘²I0³þ¡¤éL_Ýœ4p0FOz=­º‡ö„Äp‹–KÖXF/`÷t²9 T³7J?îA3ü±’™‘ a+ b‡§ëGHáù‚¼“õk½g­e§Êµ—}‘NuíQ<ö§óp²p›6}½íGUœyÞñôfã Š9Ý?^›bþ î¬Ø·ïþ;Sˆ³ã4sr°R.È£"”JÍmÄmãf{€‘šÖ®Ü.“k£ z©? ªüÁô<÷TG¾±ÙSîU쳘ç&7¿4Wçuüaawœ“ÃÄõøS®2>è^”MkÛ¢ô Ð@dAGç¥(9»µÅ¥/CÑ_ºRcWÜÀ˜T^Y4(x?¢ýƒŽ‰!48œgDN*,÷›ùpä+fÇÒG¦Ï[ö#\"‘ttdÏP¥Jeü±oé‹R³žySÇ,0€"=óc­> ×îD¡Y_Œ†¢2`=*lzÅ-g²à6'@ÊF~N°˜¹—8ÍEè`� ¦\¢?AÒõÖ«A3æ‰#xÍ÷ôA_j]PH]¡=¢\fk›ƒÆÅSd‚,±þ¯ŽÑJõuW]IÆÈÙÆþØÑFûõjØëlñSttÿé0Iûk¼a웳VÜ‘û„–kç*i7BiS¹å4áSàµq/^—'f‡u^Òi»u]7:Wç©J QÖ÷Hµú}Çëòé±Ç>¯Ð›º”>¬…^!߯§#=î“ÒY^õxÅ÷ÝÒ_bc¢t™SÃÛbws³ ²1#Vø¼z½e(D¡¯¹ÍrE#K]ØE»Oþ÷6úe2TÆ®`éê±£ÜXãcmèj?ɨjÄéfùù—6ÏÕb;fWòœÊ ­_!É'\,k3%Ã"û®¾ ¼ppæýá¯Éêh³6I‡^ Ž“º$g¼£Èj¿á[=úõÏó[_vR¸Õ"r·ƒ«€›asÚ5­âÂóhfPê©/‚jÙ{ 74QE2¹¥ÜZiûÿ—qaÿöÎožN“Ü )–çe†ôµŠµHúCÖ•nŽ†§Jd.IJ\uXØjë[³f†¦Z÷q9ñŽT•Äs¤ªG#4„cÁ­ÃÓHå"Ue}:!#å®Ç#] ƒ­·ù4N–É$xB¢9t³Š¯ð Ý ¿xÒm> 8Òûï)�N»8²eð[5L"DâWP;bpÆ•rÝŠàOìY_D=á>ú ’W«Àè0Íh+>ö bRÍbÆÎèëAtöÈ|5S· ïùÀÛxXæ[BŠ Òví¿/§2 ×êS}T®¹ g‚ÛÛv˜ñã ôªéK”òí Ù5&¢5ÓÙX±Èó¥{¶ê;a•ÌŠ¦ûáZ+e´}Mû¡Ó{hÓ&5ŒAÈ  ¢`=nßbÿ ¡¨> !¬ª-Hº)´"Ȫ ß×ÙãDÉÖ¹ZÒ#õŽ'­¸«úÇ&wÐ2wzžl§™¯íCw›rmZ{ÃE³z_d0¢Ei¬²N²&MÅô›Œ›!'NÓ²-ÚËNÛ∋®­Œ…,]ïLÂl%“Uði›Yl%Ô)ÐеºíCüåÁYÁM+à|‚…SÜYõë4XئÓfÏ0l{qÿäÉ‚-âÅŸ”Žž‹ë.ÝðÚ‡ºxà”¶Ž8/DŸ¨(C_*Š·A´«mÿ>Þ=m=! ôÎcù—žN¶)¼tŠP=ܯ«Oe%~P ÊÜ×NFÙKùüª³c÷TߺbUú,ÜDç2HÇQ-þ«d˜=‹ª_Ú¿Gê³&Ë.Îõ|³êC´Õ´CÞ؞Ϭ‚¸(,WŸ? Ž´ Ãn°Ç,ÀV"%°¦›oFÊÖpÍNuKvïö1 É*TÇ¡ê¦ t m%aÐb@ÙbÛ‚8æ×€«6êÊ Å·ßQ¾?+DƒîÜ:Ê�ÉKƒx¨©Ö×ý·þéÙTQ4^­Ô }%õz7ÀÝ�29C'Y¥<¼“\ðòÅÃá…f{Meœ­ÅÄN_h¥¿ï\D–TÏŽG‡mËL••ÿA‚ÞQ,²"TÃ[ºé›½ZÜ“p»U‡Š\kE&hm t€u!Ë$Ú9–ÐNŽ‘5Ô6¯±£µÎÒEûÓ…*Ì°9L›þ‰Ú™ÑÝ4eYÌ™<Îáaôšl‡Ý(‚KHÀ‹©N Je×›WßYg‹”Ê﯎ޡXf;€G[ÝdsBUc6°<˹@^Y«ëaAe´L¨’)—Öh9#@›ù(7)|U3XÅ EµÖ!Šø²®T ‰?ä3wÒl=…¬Äb cšÄJ›zÀ¨¦G ´Ò‹1'©›š„çØ¥A6 ž˜õΦªË½éT‘ùVÓt#yæ‘ š`»ÒÇê7ìâzœÍ£áGZ¸£ä!¸2µÖ)XZZ×[«",{"ðiè‹ÀCµ£Ì7[®žÂÚX×é,¡k®/À£¸éö ƒîÐ)ȼfÞ•An ¸¸ZJ”„]Ïì :^®ÞÑøSV8˜•)vôömçiƒÀzøM»0+VÝ(s�~4ÙÊ™b�rúú�j¹¶ö/dQãÊEF¦Ž•8³bY¹>†ÀÖv-sŽ7ÐÙžåÀ‘Yeu”J&ñíq¨Õ‰éu@ÚF:v~¦iêÍÄSv<y’©hO™aø]ÑT¿èG5äA5j¿N* 6À1ËOÜ4G®CLkÆüö£“Çsëøå…‹ØšÝíü®æ üºÌæÙ5e„õé ØúO‡úä¯'º-ù§ŠàÀAƒ]¤´»yã³kÌv+¯úð2hàýÚ}™Ü :B:Ï3¨ëœ‚Â@{^9È¿vl/ çAÁvhÄeMëÐ�—kïðxÍ hË!¸ëÀºþ)¥M³CÜ– „×ÒOë(PY åÃÌ‹ª^Û6²½Ñ™éy ]‹Žä<ÆÙ˜Á¤ NuîÞÕmû5¯¼’Š§“‡ÔVŸæѺvÁ‚¯™†ô"¸5¹ÑSœ֘œ©4ýJèï]œR®Þ!ü´Cù÷Ê8¬ü%ã=4cm&…å0žÀÃp94Ê!v`WîÿËÂ+Ë6® –KI{¹ö¬A;_Þ‹½Wu[™+ZÙÃL‡î=­)×Àq•ùH_ÆOXM†bËÓ·~¹CööÈ6¬ëyüHÆ(9·ÅÚÞv¬>Ž¼³:3ë¾yEvTÜP‚wgºýù°¸)¯óe°báÖ-Å¿F�eÿc¿ˆMb×þ6Öаi‹öªàvè)•µ¨Ä•)|ËŒÍç"HQàÞßdÙʺ±„¹bNç±6ÐI¾Ã°LUGÌB®ÏóÂŒ^ü­‰Žêµ“¢Gu,„ÈPe{QN úˆúÛ¾m]P¤4EïÐ7”bŽœÚœÅ{2í)”6³WžâŽ\`Oݓý‘ÅX'É øn_¶tµk–á µÙÞªJ *úxñïíÊ4\³’¿6×ñ[ÃûÚ´m8º²‹ü¶„iZUšÜ¤ [XÆ<ltaÒþ7‰ÿË¥²è¤JøS€øZï“œ‘ }·SÒ¿ÿÎÞåý2¼tèzqžo‡4(kÝ©;Ìêhê1êµÜÉÓHξYèqÆ]c»?FÉAÅàõA7~•Þ%"#WéÆ&Ï3ß9:H:±JWÛŒV î{Ê‹~¬¨§+(.N”.«^gÐÌtf<Sæ`²L×}Cƒn^7Jã0§‚ß7}nŠ*(-·´iVÿš<òo0¯‡x¯"[áV¢ iª |oÍ“NPœMõ¡l_{éC×Ïà”ÐþíoØÎNÿ³2)ëe¢º±Ø÷Þâ§ÿ5²{µœáìŽÇ#:qÿzh¿ñ1ç·á�›[´CÄÀRQæ·†¡¯Á–¥Ñ| EÇ÷x½ÄÛ´˜MÔ¡sB·ðaÝfÄ¡0…J!…ôªÒÔµ‡™…�=Dÿƒ´@À¿é-/äEFH’„7!iÚUA4é\›QeŠÙ5 xÈìoÕ·_Èö~bmY¨Œ@n™ñDß3ú]ÜiõY½5~6ì0ÀÖ)±º;U«i(:I[@€‡7qD“è·^ l‰W²Çb.Zù—š õ`¶ø0ü]†k;œÒ S:Ó“ ·ä3¦+CYAe²zÓ´‡¿ð€ê,Ý×3µmk¥U�Ð8§¬1b¨Ûæ*ŸÔüæ;ý óDr<Ð#¥j9=O{jë¹ó’Ìv:]ûœÿ\{2‰Žþ'KnÇ·mM§}h«ÒHîâô»Ó(™¶#†Fæ ¿Sžxé=¢‡žÉ<›OêÙ`ß VŒ…„Fœj† ènTCïí‹Ùâç¡E»Ô ák(ršªüïØoIæçŸ�’÷Úšb ´éÚÚ4êmûë5¡ô$RõroN”†gƒ‚U ~Ò-圵*ʲ3¢ºŽohíšOŒé1ÏÖ’eèwƒ! A{84¦;±<aEX߶äïm¢,q!Ç’ÙìóØÊVŒ®i LKR.xÂÍç¡GWHA‡÷°‡¹g U¡{ÑÔ´Z¬¬MèÛó l�³è‘ºxKyU¢…Î=ý¡«à¥=ÀÊà „FÛØ(„u"ˆOÔ_5/kùÏÛf)’!2ÈpáÕÿég®¤½‡Ž6fQ+„r°p3«æ¨¡)§AÒÓÿ™.ûÿŸ¿†mÙ^k®~ÇÌóP‡ëX_·"Î+yÇi àaþ½ßñ(ã(v:ÐË©8Úë@=Sm ej¬äG£RÝúÌŒ/Äaóª:n†ÑælÏÞ äUŸÍÜ3’dÒÕf[B¢øâ朋p e:·0­»i„Rý£KžfI@0¶ä¼’ Û©/h±¹fýþ¨r¾ryÏïHÆX¸­GF¤&óÙ+û¥gð&¿àg(ªëHvÈ l*'Í•èðëY¿Q°Tà3Eˆ_ÐWžé ï�RK‡ßdÇú¶+èð[¶ÞtdÞìi³ÈÊF„íyRòRÿ&WȽ4˜Kú¼{Ïõ‚n%Ô† Ǭž8û¤4š Š–é¨Z§ñ¹£_[{F´|‹ ½¦AÑ_MS MÍã¡…£ˆoPi-0ˆ‡ú¤t…h(4G�õwÎÜ(p©„³ÊdœþæT÷€¸hßû&ïø–†X,g†œ¾Pc,ÿ¸莎·7i—²]­¾ü”³°¬j̇ԢgÑñÃ4¼Y=¿/­¿’ˆÿU0¡UÄ úìhx¹ŽI›aGQ ÿ¦ª‰½®ÊoJV.Wh¼=g«'{øIIªà]¾æÊEÎ×\äà˜6Vs­Ò‚_7ð—à×"ñ4X:eUx9›µ]S¨×æ}aþpf‘ÕŒûµŠ*–ÙŒGëgú'¬•šÌ Æ„¶ÊŽsBúÆqt¬1¦ýF×­\Þ=*ëLuüdZ0/.=7;WI#˜¢3Ó]â{‚)¿WJÉb_ˆ˜Ò¦nƒ¼SÁ*:‹'íüç-wfv—Xt¯ÅI^_åhåÞþe˜=­ð´×D€V<}¾®È)6;hÑ/¡ýîyV/þr<)Š�H0Êp 5k[´ìáÏ –îx@¦_ð@\ ÇJN€¯YäJÊÔž‘«ö4cÿ;t_‹0‚èƒßù•„Ýïú@"ÛÚ½4d”íÞ—@õü ¡Yꦨlð…xÒ]Ñ )І¿wK]‹ˆW^C'P9Û6Ë<^ëÙ ¼Ñ¢âÅ©]z£èGÌζx)9ð Bén×õǬFj±KGw<Ò6ÑÑ°im@DRÁDø°¶ïSO¦C³C€”Z§Àíi†¶ãuu�eœÈëú ÐZ^ºù<óvg –¶DYªfÀÊÈ¡fV‹}½ã9­ÈÔ”A΀ÁÅÝÎü:)yÊ7Ô×GZ•vGK‚‰a¢÷‹/V ef‘\Ø虼tª‘ÍMÝvsYžy:„ÜjʃlÖFx›TÕªÿß3]¬ÛµNi꿶ƒ@âx¨(n@ÅÀgI<þÕÞ8;}'MD‰/C!…î)møöâI›ºÓtš7§^YoÏT’Üná› ‘œkùØÙ»É󬫈\úîEOŒŒÒÂ÷不θöbþ´ôÉÛúKç’«™þ¸AžyË«v{M8®m)yü½§¿“?¡w¯?¿B¦_øRŒáþ$Ýnoä½= N)d:]œÅgç7¯®¯{ÛL¾l¡äji*1“ˆ§é­é¨ˆ5#4±ÃdË8w鸤ߒ *ömÍ£<¸PµuÕcpmV-žíÄþ5yáÌS‹fæ%0®U¯óŽ�jo ƒRNL‚þÍš¯‚8¼”¨Ôj:OB{ÆŒXaN/Iá_íÐŔ÷ڣ?Ÿ—]0›ÎÚv>×ÃÿÆ„çLïï'º/®Ò`�™ f¨œiœ7ZAZ‘ßü-\;÷™YG§h•»… :Ò]>Á´Oû~VAüÇLæ{>^…+ ´5èXûÒ)¸p|ÿ n"›rª^6šwáÔÖý‘-{¾;Q˜¬¤Ü)rïz®»Ù Ò’B•fèið2yŽ”ªªÌã�Qyéíã³vY"æîêãi±LͧØ(ebG추°–ÝêÆ ÙÃÐéÜ NJóË£šÙþh£Ä)A8c“öêQfµ›®‹EÖÏs~IÌ+æÉ5 }‡ ±Ó€¸ªÅ¢¹ ¯z(DVfPÈ\LXƒjøÇ*‡P¦nµw¢ÈJuœ™n/ì„›ˆcÄœ¦{Bê;µÑ†íÓ0(ÎWµ_´XPÃ}£…ºápšŽ3` ½“du¨X,¬mNQÁHo»×¶EŽŽ:u6“ð¿×âßÆ%U:QKóÖ)•P³.ïOM3»¨…²…e,€¾úf•œ—®*7pO”dÃ×7…°V™éÆÝìýç®SD cm´"[¥ {oؼ©)…ðFRFŽóÇ:%ñ¸ŸÿÃ…¬ÓþþS¯û4IB·†*0I(îujhy£Š¾ÃA\Q‘á´Û”9yg�Y4%§¥c~–ÙKwìzJ){]º;?·õæ4ßó±âVP¯™1`Øk‘ƒHÇÛæï-Ó"ô—-IlaðE´àl½tšÄÈÌå3ƒÌ?ª[ß÷@B_ßYµ™8ÝžÚà‰WTf^l¡ªzœ(#Hí馰7ü7áÑm>™Êæj3 vÆB c‘P‹–«Fñ- c§:d¾†Ú]%µ¤Ê—€;†»v ÊÍ Ý·÷Ó~˜ß±Ûì{˜þQ†1_NBÈ»óо³ 3ÆeAºhÃÌtdj –ipºx²—/—²`¬yv]næ,È›ÜDµF„++]óWW[ä ©fþ—™ªË½ÍGù8¢“Òç¾ÿDØ,Š+11{<'kñötÌÓÊè;Öú5 Q£·rûº*-“Ìw?ÇÃÒíÝæ…˜$\[ëóK˜újJ/AÊ„–ÖAáQWŠî'$\XÙ6ßÓïZAñ¾ÿß;U9Ë #3• ‡JXw”4]£ºÌf‘Nyú²-¤C&‡Î¤.²ìÕÎÃþž’lMœš´— ÓÖm§z³< )±o×T!­n{ØA-WR–Ú ióÛ^øXà5-ºrJïÌ,`Ý™ž{œYÍJä/2–sy÷®¾Ït²òF2y™Ð÷¶°Œˆµ†?Žø€v q¾ÅrÏÝ„úÕ‰¦±7“ÊQ+-p¾KmÓq<Ñm<Q©²éœùM á?8O“{³;‹öuÌ3mÜFmÞÔã)f¼¾×sìêà·?û^Å…ÑË€ _Õu ôÞÍsM¥€ÇÓ‚4—#¯mùÌ%o“zÙ° …/˜šÉJÍ¥ kA³51ÐÝ#ÃAg©T(ýÌ+"^ 4cïZ Ưõ-ËÌ÷œ¦TéÔç”ñîM ŠŠÏ>ÿ½žD”8(¦(Y`žYL£âOl6®õŽ/_cªõ¦q³¦íÚѹm)DY.ê²z‹h±³Cˆ¼p«]¿Ö2²võ’†ÁB4¤õ0{b“8© ˤoM Rð>f-쇱õâÎRª±„ŽÛV–ûŽ"$m$™áÚ;ͦz˜¦¢"Æáä&ðgeæ+ÈÓ:Ù)ruV¼yÂáËùLóŒú(úÕÞ¥b Š¨ÊœhT\ <ÀFÕbO³:°ê²»‘¶´üË; ã‰±«cCÂ6½XæÉç§;›Žõ¦>÷,Õ@¨{2ÞÂ(®^“ ÍbÄz&#Äwßõ%éz`µXXë™Ûu+nÖëÎ�•uÀ”¾Ò2ÑÚw&΀tšZñ¨3¦Ss¦Út:O'n”É(Ü¡ó3¯œc)Ûý"ùÞë‰&eVªö|Nþ÷mw�Žøî¯ýðÍ*84Ò– Ëüx¯ÞiΧë‘qÝÈ;¡!Ñ& ‡¬WõM•âÞÕ­¢kj²ÙÍ–6pfk ×y%MN “¸V%¥è0CŽ[׶Ûo¯¾¼†µIä?båÃXý‡êá48áõ$ÃAe¸Ÿ¼¯aÎ�ÈÓã¶TÙ4a+±V§LŠf{&Ÿ­{Y!Jˆ ­ßWm9f%™ÝœŒú¸½ø–Îú‚b0>:Ï*Ì&>ÐV3¤*wõ’O®úìûÚ…­úŽÆ,xÎøãÊ;u_|j=xElŽ}bzËRàŽ:@ýÊ€5«ìùo  ‰1ci¹<JÑ*γíÑÔr Qz*˜õ¿Ú R·Ýp‹Jd†iPì=A0Óbëo˜ýìÄlÌ£w¾ Sçw@žSyT¹y"™5ÖF«Kº£ßŠ£GERež ½õ¼þ½š‚N¤4”½•­ñÇ›—ï|y3zœRçÃ. ²ºóT~Ì˸ZŠ»yybÔQ%¾v€•E¡l´ö…©FÙ™ð#°?òÔð»|=AšáëKwn¦8{z–ÝbAØô LÇŸ÷}pà©ÈuQááÐhäS¡\ÓœçXåâ½5H}¹„Ï¢Øò²aç \ü<YU¼XEoÎL;^ ‰åóûËÉ"cÖýgäÍÎdÂЋëfZCm#¿PwòÀý^þØXv«`Ý(¦>=˜ ¥›SÁv5†Oz›Z%»h©®ÇÅS+P ÷¾ƒ™“Êt…l[7Óršf§å)t·¾?]æ é†mÏ|^½0«X¸ –n›xÎÍl|Mg�E¹~ö2è}m<µô¤…$>$vŲŠ´ñGÅÅ`]žêŽ=QF±›yÂ4TÚô”•[Þ<n)åú§ãI6í…YuFBµ9õÞ˃/Oü$f vM<˜y„²ŸíZÑó+×msÚ~‚Ðåîb:(° ©ºiôí§ýi†áãÞu]A £ó�R×{ãú õHòd" ´˜V3Æ(,5²~] `ÀÜ) ú!¢;½W8_‡Gfzîm+Y¹…Á-Y¿XAó£<è1¢³´6¼§ª‰›=rØ*ºÿYa-ý†¼<Fª;—­TÓj@šãQÎ߶µy©Us0ÖEg!´ ù‚ ܉N¯Ã°VR±Hý‚}›°vž¥@M�: í•z°(Ñý™Í .Âÿá E5ö†b¸}˜Ù®Ãe:uíuÚ.ü¢pxèiÖTÛ^çårCˆjùö°;`ðà.YÜW©‡”a„ƒ �‚ËMÉ+ûhS!ß‘ŠË|eAVH¼°³S(1ƒ^5-á¿rrC DÆ.öâdÜ¢WE¹Ü?Z?a¯&:àþ5ç~åwnf=*ã ŒûR㉊ÊñÉþ<ÐÁ˜]UÊÐ'Û=K-¿N4=ǃÝ$Œ|ß@ÚQÓž*ÿI™FÑÑy¦!¿2€Š­J,iiyàä9žÐ*”þ…ÃC)²Dü¤E19Êy°Ê¨±° ,Mô%“E‹I_.b ûŒÂu©þâ³ßÚ¼ýÎSѶÙ#£ÒîéYÀ5ƒæ0ïO£4CFtÿáT+Jëµ³7švÉ ŠÊÞó*~¶ð¼—{Ñ·é¸ }:L 0-ÜÂl·%1*£puö¨´åNûæQ¿òÎ<UxÎ0:ÿÒý—g³UA¿LS£Ó4„ú{7 ‹Ê3ôEƒq‘Uûéi{@x‡Ò*-¦ol/dÇÞÈâ;ž}É7©‚šX”Ÿƒ•½FÏÅdw ºõ­`¦yTc‚äå� ‘¡ûIúþ{`Ï€%u³GÚýèz'ŠöübâkØP„h‡<(í±ÈIÊp¶AC‡ÀíªM• ¯{'ú)§cKdž�ÜR¶ú1ëPhêálÒ»â²ÓïŒ «ß)?yÐ4ÀOXHɺ "màa̘;qçê½S ÏÔ=ú­‚”üÉ<|YèI|êÌ_8f§qoÙXÕÊ*r©[¥­›‹‰ŽbÌ_á\Å)€3¿ñÎ|#¥SSñY»%à.êŶ­¬Ü÷ H³³35)[7xíTÂ!›åüq®–ÆŽõU2|{ ª½úíy¿òVêóÀJ»>ÿõ~d¹Êè/ÎHä†Ñd*™è¸~Isf™bóòÈ&¡pìIÁе©:BYp 3[¢h¥yk ™ò¦`$¤Azî<:÷ríÅŲŸê‘ßnY:)Ã^½#Q‘®âˆh ZÄk*M5~€>f6_áf7$g÷€sµ‹£)!šMÆ"ÉóŸNä#|?.ÉîÆÖ²r|fžì':š‡½ÎM‹À¸ ¨EB¶käÊ€WAaÒTªžþNê:[%Ñ_K\ÊÈŠóB»*³SeJöÝ0(‚‰âú‡´_œØ :ái~ -=ìà%Ó[þ"DçÑ:’6µdD7¯¢=Kßz¸ÏƒR™u¡É£÷6ÅÐür@»±› iÕë©ð9(Юõ$iêͼՙTu Ó–:aS÷»z²çu §0{¾(ùé[ ®“ÃûÞJ??öYΣ’Š&‹´ÏÁÕô¦¤Êñ?DŽHSäø·ThÇ[ÊÌ첟)‰¨u8Œ“K eTˆ“©i?•-¯ªÛ¯BÅB;ôK£O²fû©~ûêEë“$)ÊÒ‰÷c‹\ ¾à¨-|§Ax¬!ñ öV/Á{w¥íÚýÚòP­|¤ÔÙ‡vKýå0»+z ù „y³é;‹-ð~ðt—òØgêÐÎ[fPtk[ì!'v fÒ&Íÿ&bàþ›ÍÕ“ØÃq¡©OUì´,–›}s§³ 1qš%C¡7Îrü.lä&Ý‚JY#¦x×ÑOj-¤·Ãú7:1‰I®bn@’özÒ(·˜ãçBŸE¦fšèÜE¾ Ó™–®íŽž,F³UPµ;O_xã‹Ï›Î>žÑ–îDríœRPìô™@÷Ö•>ÜÑÔæøskÉþ°´g¡Ø ³`ÚQ‚›Yì¡(1‰¬‚DàåÐwÒ£§Ð28Ý™Oßüfrb§€ø.‰i9›¥Ü�‘N ñÍ ÄŸ·óS`KŸVÕÙ2VûÎp4ŸõDžÜgb¤ö{Z0Ù¨q–‘ÔÚi7Ú6woZpN}=5£ ÓŨhךs/ÂXÅJÝâso˜ŒÉÏÖ^ýP‰E‰Ãùct–aT—Ðùªb„Èw'‘ëÓÖä¶g˜Ç„‘Ÿp%³ù“U3ÛÙJÌánh˵‡'£‰ÏŠe¯dô•ÊÏÉ£Vª6©¤ù?´“¢¬’Á†8b!ñCN;î¼lW]ôèc/Âx¢*ò­gP–ôòß¹žT\Ö*ïãmÏÒ¥Z½ [’9ñÅÐÀÓè=¶^[Z@AÁ¨ÊäÒYp9Ëë*³I¾ŠeØ…QÞý€5…8¨‹Þ‡ÀmýMxW Šz”Yk\õ×Þ7YÆT{îƽeCé©}‚µ,µÈðâš& òáSÑלæ±Û,v0Hñzs‚EÁf£úÝ{ú>œÂ­qúyézFÞâOéxõŠqdR®"û¥þ“O±“n]Ñ»ÎÈ13ì؉ªº»‹Â® 5Ó= ÂIàE£›fX¬š„"ɇÖg& ðd¬aó£¤{¢ƒéåÖßB ÆÚ¾bÄ¡vņ3åIáZPä &äU?â2«Ô§£Ò{Ê×òAái(¯ˆBž'®(k;Õªáwµ°¿“$‘3Ó´Š–‹Òœ€ø9!„;ˆ •¹b3òƒþ’…]žøv‚„è{|ª’0Z<õšýwSÌ¡»ÜMn²ÈW©£ÅÚ”bœíÈââ©<rÝM~ôv‘u–ÍU?s÷¨9{ýw€1Þ€°ô"8ë¥ð¿÷Êú8ôovÈ•iâQÕóTq®òA5ð±®=YâÚx¯ÝzW%žÄWÂ!§{Zšáz^«æ÷Ygµx—7ƒÆÈ …‹÷Š ûT-C˜É ÛÍ™‘Κù×ûºêº :^€°4T7 ‹gæNw´ö¼N¦ÓEˆjÏ$+ć 6¥¬²éÓÇŽ¬É*0XUo·×¾½}ËøvêxÙbt!õ88õ/áÎCy¿Æ±,ñ¨4[–.[»èðÎWt ÇÙIÈþ¨�ÇÁ…Uoè}©¶{¿vA›Žš†rÈPÆyZõ_‰#3–ë{íâu¨võ±wî4T1]{J­‡† ¼Ïê‡èrûÃ)ðñƒÍXwžk ¶›©±>xÀŠªý¾¼²ë¦%¾Y*„6ê2(§O¡s“Áí©Ö` ;¦½ÈÔ›láćÝÒÂgØLf~#¤G¡ÛƒÅçà2ÿ8“y-4n¹]B‹cY|áùD•Qïѹµ—Þ潟€‹à|û›JYèU=Ì€okÐ1•dÀÊÈT“ÖtžB}‰—¡I±l{ÚùH›Fµ›IçÆ•šîí›ÑÞ=ìs™¡ùmþû:øIºêÀÑ< ŠÝàÁY =ºÁ¹=AØaH_×Ð¨Ø ì§FÑ‚ ]ÕÜ$1,KÙ'èñý½©kY¹œžõ&#ðagûˆ”ù>Y˜œðÿׄ\1cwòq»N5wôæ!âÉ¢©¸Sc­¹ï¬;Ñ“@lMØJœ60­µ>X8 çz`q,·ö3úx«€ÎÁEÐþ̱22jÑÞ\tì0Ì°¾×¹õü3mènG«xvÏP#ÖÞ'LŒ¦Õ<\pñ6—Ôªò.péî^Þîž8^™›Ò3eÅ¥¼óY¾sבîâËrK™šè³Ù¦>™9Ž Ÿ·ËcøK_ :JËþ:Ñ~o·‡þ‡½vŽ"ÆŽl¸…nûœõsAh{öîW² k_§™‹  æ#%Wí?^+öšV´ÛÌÐìÅ6M‚^ˆÏút“âÛ1[]Éÿýµ@/ÿÊÙÖ2$”š·V¥ü®áÔýQ@µÞEé>–<á³&¢5O7S¶b´Îw;òãIŸÅ€Ü3½{Å�,—¬¢-S¾£ý˜n'oØ.ÒÅ»ÉBp.ˬ9 ŠÇK²ÐwÐÀ×9Ò{ŽÚXËØy¬é¬(,%âý�¥ƒ»’éjÐDOzìÈíííé ©‰l'îèH­fî¦1ÿ÷ÿÌoTß«ÌΖÙÝ6Ž•þÈÔ*{¢šþü©E +ãÌ€¶™¶ötºòÉpózgð“Ý°Bš *kC¦üM†ÖÉ@ÄDIí¼ ½v,( �|bx�‘åpè P*Ý^ÈîëÌÐûÄYy‚Gòá{XôªEMŽîÁ†x ž5ʼF7çgle6œÏ÷é;ÚCmÞŸ59¤Z_eõAx~µžLáð§'z¢’aki?C·ú-äš´Úq †û—V¦µpÎ$Ü°Þ¡§2Øn[b<’ÞØ$©Aoæ)–,Ý…âªp·¾Ñ¤W®XœL tºå;õEvña¹˜†�?bsÛï¼ê"ý*d¸ºÇ£ÎS«ˆ*—¤ÖQ…fg}Ùw´…nh`> *A3àÜ$AܨñXÆT¤…![Vãq__9/çEtêîJG,Ê„`&a8«„>5ÝÛóþâ_¹;*ƒVƒ’�îv‰‡Ý-‚Å)‚ðe}@Ï(LPruŸÑ1©½´"OÜ@Ë“>÷ȴަȔæoÈSÅ£™ð2×7›õ AÞÖдóyô/|SÏ=‘­À‚n¨X�À,qPºOv(nµr¥ü@Ü8òZ¿‚yÜüɃh8;ÃæËÕb¨_h£—Å °ÌGfýîdL¼= jp'7†Ÿö¬¹ßšz¨ü¥EæíI¸ë¥A¼UX ¬Ç+�{žEË0VkeÍ>`(ÍL rÐ1 Ä7e�ð{Y.»ÉÍYJž‚lhrÀ¶=YiG0x™ 6«ÚýÍÑýb`Œ*zYAÑ:[0±×Ìõ~ëhfÍ¢Eë!„å6ÉVéî²R/œhª¾Á ±E¥…Óz×wXõE¸ŽP äAy±@ìvƒ÷ìYÖ¶› Üå "ÀÒä*ÓÖh îäü@§“ö»¹MœùÈT‰eû<d½ú9!ëWÃh‹ý<Kc§"c–Ó<©X62ãÈÖB£~ôšsÚG^°i¸67@›œ¾zçÝæé¤#fs§[ ð}þÝèBÙÑ¡ú—”}ä³õõà‰ðÞ½B`ÿ¥¥6’¹17éfa[©gmæ3/çœåŠªVÁ°ÕQÃ>t_”KÝ)ô›Îɬ¦=%GÕáRÒ¤8vD…ˆs§»Þêè±›Æîà¤ØÒ¿“åÎŒ@:Cp�lþA¹­îjÜ vçA öP1ÎÏ{o“àÒ'ÑÓ2éá·QLVžJ\–ž&²˜Ûóý¾šþë�Ú5ïZÜ0ØÊ8Qx¦;ž€#q¤xf5ˆs>ÉI)åŽÂ‘òóIÙV©°"¯ øOQl½CÄ¿ÃÉ÷]þØ„q¢*?\tÒÃŒßtl%õ¾¾‘K*¯U)<«: ²÷<qUt F˜”½G>pñÌ&§%yçsìÄ=H6žÚlvèôA&%<Õ…Àd ¹Ðß}Æý¶Û™¸l^B‰u?Y{ÙR€Ô|®*VûÕb#bž�}x¬¿Ü ÞTl[°—–3/1€ìðÛãþo-OGíx!Šr‚‰çÎ;6ÝæÐÛÁ—¿ríKW 1ÉNdçb §Î6ìæötá„ÂR¿.<…q2Þ+n-3«`•ág‘ºØÇ‚pewŽ+6XwUmíÐ1,“2{±ÙôÉ®ÛÔéZ>ú”)uŽÏü§>í=q{ˆýò¼[C/rž¢eSã9(?²Ú € æ3|ÖaÚ#²è,˜¨4€ÝãÚhgS͉ ¥�¦i†N¢ÅÖqóî£Ã(ãéO~ÇI0E´áj¨ÕÛ£{^êÐ9ÄF‘˜ºŠãt�ã ÅÕæ ¤KóT¹#“2¶±¡§ï”{’8i5û¯¤Õk™xÂØHWÑÙ„׫C4žéòˆàÀ–°§fåIi8ËðqÓædPšßí*²j%¥‰,ðÍwŸNª9µZõFYU¬¹âÐaùÝ¿²ˆ²*Ž¢2–ý™þÖ»bQã·ÿ¾¥êPч7ïÏÜZøö/ûÀ¬<Í#¥2åÄ3D«ó¥œºN@߸6ü ™åä©ÊªÜ*%Óãž8•õ˜áU°N £c ½§vrŽ dY\T¶Fg-$ó äüúÊ:½÷t†ùüø˜uz§2È¿®aþ~¢ÓÎvðW|áðûBת=–cÇšt“Cz¬tÍ|LùÉtrb°†±Î[ ú;˜ë©a‚úÙÔù“ óP¥ÕÕý$É]ܪ¼ �ðêÀã¶$“vú”¸מ‚ì)EiMPψ»:è>´µv\å0žçÓæ@©à¼lÑÝÿP ¢ø~ÒÏ6tAüý�9MãÄ\*<¡ ‹j¾ë¡[~è9RüvŽ«‰Ä[Iã¤í]Ý"S(?ȪÜöp`CÜãðþ4K f5‡áO7ѽæL§ö•Žpœ8�IzN„çcÆR¹@2GÅ,Å'ä×~!ÆäW o$öèè,Z½ÒWaå7± ãÊ‚2§}щ¾¼e—´5@•t¸ %ö<iµ ¶µ©à]{Á8Ë}¶¯¯ª ™[‡ÅÙ!mÖÖKGf&NG“f:a;r8¾©·¬ÍÌOB(¦'ááÆŽtÞ·†zKŸP‹jûEpi±V¤‰ûï:pý+«‹˜zñ. mâ‚à5‹“Îâææ|Æi«f##i°›ÅÆÕÊ©ƒòÍ9¤Uk· PÚâ`éŽh]›ïƒ g–¹Étÿ‡¥4_34Óßq]x0z¸( ûkÛÍ\¸š/i¦9öõ¾Õ®5Óѵ9¢³`ÉÎ1#4-~‘r!ªè§Ã†Ç¿óÁÞ³übæAÏi÷QŽð¾·]‚Œ}”Ú~ç©èŒ×áçy’­´ sá¬QñAÙÓ椡­¥ëÄrÕôÂÂ:憆ÙeÆÔ‘q€su+`Y=<aóªû[­|’Y¹.¡PûY¤)÷j>JäákÇxjPz'‚üwzüeì’Q–¯;paöšbÀ^oê üƒOÈæßm7ðùû(’$+/PP‚¢|d'Ïf@§Å™½Z.ÿû6t§e~“b—chú´Ûª ¿î<\àC™Ø0dRž¾Úï¿ÚcÉŠ!@{l@z”‚iÝg’”ò)ò²™ ÿ­‡ ®XQ{al,©—Oú£ñ¢ß;gž(³¾+ýîL³þa¡rÕèÕ;§Ä¬rKšá)ÀÖ”ƒíXIM¦²šñþZS¤~W‰–ÚõÇAfÅá˜Tp€Üœ¬½™ëjÀ(c¡šèy»>‰+áùìzœºš çÂõ¹ì»~ä'óy ‡'ínD‹lì|OÅÚßSÓÀc-PÛGŠp0rûK1P”ÊMi`¦h5½ë”1!¶Ö9Õ‹T:�ð÷] 0ÈI”òr›Œ¤™oÆŸª< ’iðü$÷õÅêUïa î =·_·ÒbË|t!t30aßùߘc¢dU˨®fq^ÀMè—ÂÌ[ÿä³Drc†´L1ÜÐ ¾9GÊŸ‚4)N3ë ÏÖ¬²¡kÈ"ÑG¦?<÷`óQåAWÄÅ�»wè<]£¢åUw/ªßF¦^Hn7‡ž”©™+oI’zŒ"ÖAôí?+ 'ª(+wzÊ”'kÛâÐÁEd†·ÃyùERè%"V…© ݳ|ô8æ…sZ“®Ò<žÎ"‹3Öì/ošHÆÃù¶ÏÎôé¡ãNI`¹Ý™Ì¨dÊ&þ@Ë O!Ií·™wðÓæ{¶BÀcf<‡–b@9bꔬv’÷ÿà©ÄÕ Ñ¨]Tý»+kæýtn ¥dBÞtºò.ÖW sÏ@—p„‘Ì|J0?Û:&KµSûf*-¾Ï ›yøÀZ?ßDCâÒo•·@<gôý/V b�Ó¸K4ñAñ›ý¢>2Kº´«­Ð¾­hIÿÓñf•Z­”óe‹,ÖŠ/UÙš^Á]CnR¶*»ýXDËa£¹Â Ù|o§Š©v©˜nF…%¥oÍNÊÓÅè,3ÅÍ^} iVÜðÓÏMFIgç©Áš‚4(yñPÝýÀ¥JA‰šofèíëüÆÜŽK_†×{íF.{ºUoñÓw˜JT–Žº BèÆUÖõÝ£ý�eÖ]äÌÙÔýÐ= =Æ¥—"Ç¢¿“²± í§Â„ÉÚ›ýÞT¤]&$(2(\Eï:¬ˆ€€cš€´Ì7'tR™avïÊcY)½Ø€Þ‡„]ë¹roj¬€ƒÍ’1D’n¾^ÈÛ­ò½]"³÷pÿÔO' ¬ö *.ùákò¨Uê³V!y³G½`lÆË÷ÀTbñ eÛÈ0Ï'é =ïEG" š– …ìó¬eF¢”J\¤ŸŸz¿\åéá3ÐuäÙëðjá)à ýÞ\ … A¢·6Ý1k™àÿh±­ ð`LÍ®€Ÿ½FÇâFo˜ŒvÆú9à=v·HÚ›´‡ò ÚžêÄ'ÈæÔ»¥‚áÍ3Îpì’Ø(³Az£¯Þaéö~tóÈrpÜû÷z!Qî#Ÿ#Ô´Üy<S__æ„j÷f «®ª¥‚ùRÏû›ôyU/TŸ`@÷¥@§þ„Ñ Ì´òíŲ5{ˆjm[¿m(u¡2¬Þnïýêx›ö?Ó›`äeŽXCR™‡¬¦[vSRÞX5ôF±µNÌc³VØ¢øï°RièÕË2µÒ¾ >Aצt`¶ÏÜôë ‚JÜLõ ó•Žg-RoJÇD¸$ ª¦±|ÞØò ­I{Ç-•v­QAxsÃŒ’ZA ËîéæÏ r) +Ö¬ÐÇŸXô™sˆø4*'>«„X £`Ê5<g¯×aà¹k5³”Ø`OJ†©*¡«¬ô¸~ßÒ¶bFqdX1›†’åüŸÖ"ýá×Ï×M}Ä­Ww2Û]1Áí'ÁõÜ;zÑ&Ún“¥ÀVœÐÖ­ôáöÝ—ðÀ^R¦‹DðË—~ºÔ´p¦³‡jŒ’b·ë^–ù+@8[Ý%J’ë*ˆ\ýÛîDg:½åR_ºà “Ývw˜…3_êA|Ü.×Ùük:&«”9~—лYƒ?+u¯ÊƒŒêO'Ûü}„®|™Å`ís"Æ3z#¥M1,–7ÁZºG«üôWÕQ~ß vý}æÃÜ«¶Ë2ö‰‹­ï¢QqÞ~;q²ã.ö;¿Å»"bÑŽ¦ éÓꆋ`~2Ö2ü—¤P@qôµúÔìÅ÷Ö„— ‹àR²V¢cKÑ ¯¯MÛöÜûï%Ékœm·¨øÞ÷^§³ØJÅÄ J!àE¦!òc [Èbžqä‘jˆøbåS&Ûã´=KË@Ô•kìSëëI$ŽWaÐÄxÚªðh7ÝÐаX¬½Óz•7tôÀ$¿zTën~£;ÕM¯QÚéï~ûyC¡žPvkÄZÿìéK$J([ ˆýŽ2Áº±¾¾we}‰Žß%墬ò¹‰a%¸Øª«=™lï@EVŸÅþ�¢Ð4•BÎq îí»V se?Øù�9Ú#fƒ¿& j{Âùƒ¿†KÄÒyÌôMg>í åçÐ ,ÑsŽàøÝÜÓT Jß·”íÌ‹jU¾EŸí¼5b°ö¢œuê"Ü›ú<åQŒß §Šx’á=ÖiŠâSU@!X¡fo÷õõÂ)•L‘(Š¡ Êüøãâ/ØFw;GŸ…û‡)¸a³@ùÉ´‰ÖBÖNY41æ4—ŒÅ÷,À7γ„`+¯fÅ?™\çÅ-‰rÖ¤Ù›ì¶y´½è™êI÷@<Š©»äsn¥ý+ùd$jÜ.á ƒe΃|¯ iàfÖîÏÔ”§®¥�!ú™}÷§ãªôî/= xd.q/ÚñÄ _)(ByÛ]ô4Di†*•Î©v²`àú'°-�‰gÄÈ•²ŸÀso§|ï$ü|%ª2¿ÕÂd�QÍ艙w˜Ðjûqš—+­Ýá‰EN櫪¥è×=: SACDÙâ†ÂoüŒÔô˜ÞÉlU‡‰ eþ¡³/ w¡ˆr¨¥Ï}ùoÖ¶Û™N•pYìmhȺ@ë3+ënÈ˪9ßBKàÅq°Ð& ßµ3ZíBîXÓ™³âûÅ÷".l1’uÓ ùÒ{ò{Ò}c“M—Íß¹úf‹U•¶ yó®,È ©N=“gääÔ’þ£Ú÷¤ÑC$2ôd£Hèí9òš:dú$]t…`dØtnŸ0dXŠ¨Õ§vµ)„´Ž‘ß~ñä°JSgc(â3=¨?Ë—Ëø¹=hèt@aÚ±üï@¢8Ç<;»õøIíKÌô8¡·"ýS³Æ¶¾ t¸I•lÑ¿p&ëÿÔ „}tÁÜ�ÍF÷Ö™Oh¦JàsÃ0‰E� «[U!ƒLø»z0ÿÞwC)B_–œNUÚ;”ŽÖÚ§ wìz§'à7Ò!FAOóù>2êJ’À•âJ¶W낦¯ÁkîÎ0d|»¿6§aqL(èPü-(‹ ìÔ\”5»¡Yµ;º£•ªØíb:iæl½•œÏ2'XlŸÒ*oG;­œÆr{"¦G½Vq²¿—ëе­}ŽÝJª‹»Ù�ñÊrnÜLO-j „­-ÌÅsÈ4sZ’pŒ%Õeô#@ÔÖœöGÈ~%&†¾. ïåKdãâ1Óä,Zé|}`åK?ß_÷¨Ãï Ì<ŸqÆ) (›–Å çï5¶K‚{4ÍÔ÷•.Ùa-§é¬!d¹L”¢k¥š,?©7–þÌH¬h/”ÚXè*@$ôT‡Í¶½w%j^•eÙzgiBßáÀØÏÚQ†Ê3hEQ½ú%ÝgöÆ…çU�‹³àRÑôiëGèð97ù²µ­Ñø¥ìœeõ GˆNnô/¯q³Ò Õ¸S 0ñöõ>:0Z'QPnPc¥{•ei¨EJ¶‹?±Nªw±Êæ«Ä„Øài«¦´:«\¶y¹Á7�ù= yâ;H'†ß f¹5‘A7ÝÐ8Í…ä?ß¿f +¸’zÝÖ»Ô8µÙÌUW/ì·T鈣](JAzµê^Ä¡ç bHpI(w¶îN [FMƒDÛõ¢~Tl˜÷´æ ypnèJ{g ÿ3Ågϵ¹î{wñðýÈ: àêg³_3òmãÝü;®~lù*šuú‚á΢¶r6H`ˆé ýÐp)gn²oV®ç±ñ*/XmxQ> ×­HͽßݮѸmy«@» *[o¼Åÿå”[eŠŸª”{‹}ÊâxJ÷¾?§Aµ·*9ð‰FÂsî‘HŠÊÇ$ÒSmtMl“¾§£Qô£³ŸýeÞÄ_<Y'вe°ûyÀZoŒ¢ [ª~kÿJƉù_KŸ×k~õÛ¸.ÁØíH»þSµjR–t`¹ëLeg£|gtR¿Ÿ˜EìË!Ò'•®Ïyë…Öãéj¨â>÷{=Ú{0†<ðÖ¥Z³ê¶4ÉÜŸ±–V5~žèýË"Í|M¥$Ø^s¦TÁ~ô`ž™ÞeÔÓîjåŸôß¾û¯hE~ûÅå:Ý(HúFCâ¼yÙR½7Í&\byÒc@u* =Ñ06/O$#o2‹@A¥ÞTx|cTOGVÕ7c3ŽH äžÒÍgRÞ¯õ_3Ó±Ýjžy>Î…gí3½ ˆC<À̇;¤#O›&˜­Lõ–> f7›Sת¿ÀI T_9âm)R›µä]®›*œV CJZ+ñÌ-ÄÓéƒA×´^¡Ri�£Ö’%k¯8i:Ö,ñ¢Ì(Z‡»Ân½q :úÜ×ô¯‰£lÅ4¥puìÀb'i®ËcÅ%'Å,4ƒã»ùiE¼J½6$Þs$g}#·hÏ Àpaõ¯‡Ô ÌÓQæOÝTA6-–ü™ñè '™YL˜ñJZ(ؙ׆I˜ù”ð twjß–²IÒÔÏÒÜå™QÇʧµ®¢•PZ$ØFO™…nÂGÇ’ »%ÿïþßýc¯{¿’?¹*¿îüÊg[$Æê¡£õà‹ý ²Æ›HO‚|ífVQêQæÀxe_t+YiZ ÈRøyU’¥ =ÙA6­F%]œ‡…à�¡ 2]ÿvÚ3唇ºë�y©ýy',=G¬5Vö ÷ÊíÔFÄi¥úq/ }!7¶¤[,Ù{¼4*#Nª@|ìºÅwè5®˜eê=ݵ<H†Ùà5°âÔ ·"¼·¯wDyc{žÒc®‚pÞ[‰)ˆOݺ~èÐãz)¬g ì4(ß;5€ß@ݦîYkIKFãfÃÉåw¦ÈÛíâëSjZ¥cÇÇ >ø±±R)&b™ßÑ ³1ÙG;fñZ‹*† ÊàY!eÄŸ¼?íW ÷þ{Ú„À8Ãã‰Óø©½ðHΗü)£5+o4=–2‘ûÞO(iÓ°6½q>û€°²¬Y­õôUO€0½‰i=¬µ‡­ÇWâ)½êNNŠäãع¢£;Æ7ºUXŽÔ›hèò ½Ö¾/y×ÓŸ±ªúëyî;2žiè[¥g{LÆŠL¤Hüæ%Kü–Ð=ãË›ÉuÓæð§ö„îØ°ONâÇ—žDzµ Œ1{ õãìµÎ)Œ àyo»”{AȽ@°Í_b§°¬Œ›OÀ}íNôÿqŠß<ûÅÈ,„¿ÈLÑÏRƒ`ÝUýNeà±ð骭ĦÝSÊ&H®{H›â0Òv˻š;ŒÂ gòÃåÄÂí´—ÙÄVe–#µ²DÄa—ù¨}OÌkªfÖ·“HPOà7¼F³‹r/ιŸ]Ó³\&3Ùcêv¹Ûé:@ÿxY®etûºæHU“š>gýå¬ÕeOyž_’˜!ã­vªÖ"í_ñßòÒÙ¸BŠ‡íæl5øØjš:«eÀZ*Sgî?+ØZª¢`êK’*ˆÛwÏ U8àÌ2V…jšhYî€(Ä KFßLäcO ‘¡— š+Ï{‹&íþÍ ¥ÀŸ‘šô—!ÄM7T¥aÚAк…o® Öy‚‚¿ÂH‹@¼0/ýc@2`¯´9û톛©•·öc0—e>0qp³œí~_ÿÓwÂOåÙö•ý±}mΛõr¯J û] „ -æª:ºàî(w ÷qýr7rÙþËfAóA¹Þ8êH+åF"ô‹e,Ld®»ÜÕƒ–¯í‰Øåf›Bi]…ò2¶ñÐ"³œÈ€bÞ¼¼ öâA˜™~ÈxŠÙ²ÜàB3×gY6%éœ@ÍŸŸ.Ñ"JnT–º0J¯‘LÐ>ÜÀ’-H7{"](ƒ…ÍE1ÒãÊßø…ËŸxbc h=Ýá+ôeÆCü4^(L%b{¾ý$Z¯ÖÍ}<°ù.QßÑ Þ½ÊÕ†÷¢™¢ z* :Ê ß[SVs¨órbìzÓгÐd{ËéBž–jß-óvšýK±©€æʱzÕ9À°¾ƒŒ…Úú#ÏýíÅ£¸5ñ“w‰Å>:›V!'ÃG8u¤ùïò«ù2̬¶;³70±b­¥H’.üwøýÿRbš>pf³f.{ögÊz­UH ÆC»A!4Ð_G2úW …¡¯[O_kÀ¤3|·Æ ”c-b[iþ†ê,Âa/~èDEäëÑ·:7eYGH†jˆ3XSzlþ,øüeN{ñL#9 ‹•?üq(˜[@3íÅö�IqJfs„QÔºHÏýGe/¯Uh$%)k¼Ðö©ÆÚ*žv:áh£¶a¸»Ö4%qèYÕÒ» J篻̈-HåíÚå7Öõc—Ç#`cŸ*NN©º5¡‰Í6àš­ƒ¯By†YTÖÌ/–îEúhxª¦÷; µÖCÖ>ŠVŠT&ÈèãÅÀ˜ÑpîêŽ mºŒ„ip¤•›, äÃ"YN£Yµ®õ‘[�!jÛú GÏüN/ü>Š¦…Cô0[m² ›&1¯ùšúyìëË;’•7ÏD7§‚JE4ˆj…ÉÍl9³B.t׆ý©ûA1ÑïÛ†êDÄvÚ È:(¾Ždt/Sø1gˆuZj 'Jæâwu틹½5ÏP­›•”åœt¾yêdáÊ[;Gj–PR¯òi|âÌÌ­3ÂcÊìwS­\/;{1Usã<=nª#"뙉N€´ØÌG,½o_MÖî¥.!ŒÀ…±x×NCÊ:ùê8#GúéÂT}ü »1@øáæ'P© ¡ ñ˜é¨˜š‹™äáç/ѽ‘ÊzÇX|~„©­'…©%¯"=˜…ÉÔû™™}ÊêØB¸"’ŽÙ⟶=K×>V‚Ê¿_˜‰` ±öñ+\h¢¹ð׬lt}qäh±£afcGŸÕJ_‚kµãF·“þ£”\¥+õ9JÒŠ<ˆ¬eFTÖ²€¶Ûv ̈“¾gß2ûãVuî©Qñi˜è-ów­ü`Õ^Œ¢ä@ æ$4ß!€V«.1FFø–/Fµ§ºüÌK’[9‡¾ãfºeÀ³˜#+ûª-6Vþ3B܈#æ³µþxG,²}t3EK*®Ë 8Û³¾Uø·è¤&�÷ÒtŸz}®ÄH^6ÁÅ¢Tx–ªÏ­jv°c hk_¤ùFŽ/ôÛ‹¬´•e­ªö v’_Ø�ìÅRÐ/Ï0#§Þ&À>œQ “ýâߪ@Úë‡Ъ§±Ê»° £eìX€ÙקÙÿþ¦±ïy^ŠÉJNÙ®þÑ<¼á$Oõò7¢£Ea$wrcY2'Aa'1è¿bVµ°è÷ÞÊÌWS¥UÖÌÖC¤¾¤cOß zNEïSÞ.Й-Ú¸9ýC÷”ai<%•`sóã½%‡Áuªê¹ˆƒò«1ÿ²à`á«0oΦ豂O”5rI³:ì0Á mÔóÒhüçn,¼‹;”1ò—ö£5}¹ŸªÄç’QY·;3ÏþÇú6VM²ú.§µù/6‘ÏrHŸŠÇ`©Ã[ã!‘Ôa±¦ŸbKŽ…þñŒ÷øŒêç¥ï†Ç0÷+XœÐª¯³ýŽ´ÔV£­‹£«}g³xM:®§Ú®ò½µŸŠØzxñ-¥ï³ïa“t:h†ÆrŸ¨nAÔqd¸üm\£O•õ¹[·ÓÉK™ÿ†Ä»}‰;ƒõ¨ ªw¹ž‘Ðr:Éá)}£Ù“ÁâqÊ%7è /!­|{ŠÃˆæfûÉC‘´ç«Rí¡˜©«P³M_oŒŽ0~\:8·Ñ"³É|gž¹PȽMŒy#ÉôËg'Æë…¼®Ÿ={V’<¦xCI¹Î»çºHÅÔdXJÿùÛP%©E‰¼pºÎó]NðÌ~Ù Çn†ÆžfWYß{º{ åÒ<Ö(ë0ôü{þ+úCé KŸýú}5¤,1l�PÜó˳¾¬7Xë×PËÖeÜN›—:÷”ûÑmd®› ÎùY3ZQ Ð buÖ<H>•d )Ý3 JN J BúÚt_wý٠ijvÙÙ3‰ÿC_yƒoÔíêÌåŸ%þvóݼMô3•4†Aá c÷7Ñÿ<׃¯Æù:x+^[§RÎ�Ù›~g[¥ó¡W†=ÇéXO|zC¨8I(B)†‰lŸõí9 }aJ§#´·^[ðÂ1ÐV×Ö[â5ɬðôðEdn ûÖë”±Oë©nu.è^8ŠL©¢r{z<e­Ý úÖÓQ ÑŒ|ÁÀÉ@öîùXKÄRUÔmçfÏ»¾n%*YÝAŒÕ:öX6º×¿G.= Uj\#‹ ½6®þ]è$Vt¦?/âë‚3ã!8�TNOa2E&<À‘²²è@t9KÇ×ÍïOò*o¼ÅÚdû3\ék/»iÐôÙl,±òdäèæåoºÉΕYE°si¸U®8J¤¾€·n¹úX•÷]ä®X½E‚ôv ñpÏÞ%ö-ç™uúJƒØÊ®¥H6§‹[¬2|Y¿|Ûùyt­¢^ qÉô.’*è!(òñ@§ÿ5ÔwÅF‡ í¢ÿ¼©[4ð~ä훕hÑx7¡§[#¼[óÖÛÓgI,®°¬–ÿ°ï"=I#F±¶W/ k&ÄÙýf‰#¶ž2»…;-øV1°“o\q+¿ñ\¡‘Ó-˜ÁÄ–qƒ)zÄH(ò“©’XâipG,q«Òf÷"‡³Â, 2³Åf+·:Vãú~ ›&2O€ÉˆÓ|©[ó_L½â¥±ké%+<š }“SÛëT;«j$4°™C#—SÙYƒÞå7=í$Õ‡¢¦ÚAÕûàµË(¿?:%—á íÅ̾ïò¸v+£“ú™þ©>]ùÔóçù`¯£ÑÃ~&.Y89�é¤l¶ åCµž(†öʳ0[ ͸«§‹‘¢Ú;áÿ”NºI°`Í •éº[KJŒõ¹ŸmRŠÃà¿óyì¦ÿk 3µ ÐÍk4GÆÐÚ¾Å)Œ!x±#l¿dv$–¹KÎÃÅÔ{b˜0c|OPø¹Û}9_5¡B|a0T7ž®mÝ¿±Õ1·žeÔ£¬Z6…y`[c¤Äônš=°_r”­ûMT# ¸Sî‚Ïoœc¡V†§{=1éªöàXôÕÙ©³ÊlLàý£zê¤Kg7:í:'…ˆ¨Ó*žVÈ__ˆ½‰çÖ„:» æ°1ŸvcK‡tÁ7ܜڋýaÙì¯I–Ò¦©ôààþfS ~lm€«8h0º4]ö_txËÌ«PŽ·ƒ^¶ŸíÛ‡HÅuþ@¥º°qCî–q‡^¸Én€ežì„;Úç‰`‚´Ó¶à]Ÿ.߈žajZh<p /y¶j§|üŽ¢Hv"„ÍU.mW®o8Sb¡ÏY¬¹“"“ÆÉfŸ…5;ÿ<wôôß<ÿ:Æý_ÁÈA=œb°{] ¨�$Ú:ÚëÙ×l¾Ð®?5ô±é³nÿó‡™VîFùôÀBekà… ùP@|OAr¥¶f†$}ÙæA<·.ª ƒÆ¼öÚÅò<Öƒ@½ÒqRKœá¡l°CýrV ‹¯Ñ°¿æ5ÓŒ[ÓM°µ¸Ã$[‰}ïæ½éû—vNšÀxδ©(®HWæ5_ W7&ŠWËP‘NK!ëHÁØ nºåÇ<gÊd…}fÕ®/ƒ²Ó[¿£¦h ú'½=¨–n–ãi™¤yÇ—®ˆ£U.C :ÿ’¯Á j Þ„‰±›én¦ú¨žÌþuÓ_—½f€ ˜–¡Z/Iî–J1R„Û^{5‡ Z 0íà8ƒ"Dý*k¤ÇL~Ä’è‘°'T íe±qes(Ž]AÏdM�r¼ 'Ï£)‘ëKþfkÿ{?‰€D$~[ˆ˜_ÙðÃï®;d©…,ºÉT­O&Éö.‘Ø®ýЊ _w`¹‰µs'AOR Èï¶^ÒÄ—ŠøȺÐÆŠ»½•¿ ¼ }êãÅ3¶Y=å….aäIõ ˆh>¥ÐTZôä&Ü [‚ µ– žâɽ¨L}†gÄ´^ªö>•u”˜Á¹§*eøºˆ»8X"wŠCÜ!§ÄtçñšÛ×=b¥3OË ãõ¼Ê>—‘Èœ”‘ð5Æíg…™°®,$e'[²üˆgÌK_ø…÷´§Ü¿¿šÛÁ–ÝÓâ–PµusèŒÊ–éž÷'%;¶bèZ.D|¾«‡;Ýý4²ýælIûëñ ?ºÆqà/‡®„æÅðlÍ ƒ‹3ía1RþÔ*@zœÀŸv,tê°‡•à¤ïûˆ?´(OrOÜ!Á;íh±ÃmÛ(éy‰¥ææÝ |ýÛ± ØˆòU¶ƒKGím¡uà2Î.ŒEèyç+÷`‡ ÕƒnÖ$µ`°³€§,_äÇ-$fÈrúª‚dÿåÚÔ+“ìÊÎü+kü±U`šÙÞ«X®µW(¾fOÏaÆ EªÝëTÔTbÝöß*Þ* ýÁ@È::ºO—ÅìOv68~–îán¨ ¢Ž©K9±: jGµ9et,ÿãæÍÛú0í±Ê|³ƒ7®ë`Vqv#²2ƒu³›=<¶OO4F?Ò8`§ºµàQ!R@éºd³Q,HŸ˜ˆ1FTš¿¸U…ë6 48§*Lõh(v¢ãßt›» DŠãw;ÌqZÒ1›_fâ:)r ‡fqkÆk×Á·ÕýüJÃþf^ÕðnÕ´ Óõ 9À:ã¦;ØKZŠ2›iÖ·u“åTU4�¥‡x°Â†Ôµ¶pú•]Y¸eÉžž-Ä@¹1d}`]»Ù“$„Q‡A(8Ç¡ÝœG}y4…±öL‘øàk4:D T¼»ÚÙ'ýßwÀ:BÚ/¾SgžNnˆŒ6™õÖð;­K+€UpSò¥\¬È]Õ)YAéV|…€Êkè~Rñ#‚?õØ…•› î½üÅ€íMæûÑh¥Î†ppÂCu,H§Nl;„Æ™žk©»[j5™ù½£´3ôHM˜åžöÏ¢“Þ6Ço¥“•Ê•‡zƒÈ3Àµåé=™…§b¾wÔG"oÎ$˽ï蘋¬¶{–‚ò”_tì÷ 0ò$š''Ê]ÙÐx#xÇiÄ7/"ÿJµ«L}(dÉﲿxüd ¡¶ “LXx `˜„Ž˜Á9@ßeAØ*Ù ZËÄ{sÒ{WÞ1[¥d¥_pµ#?è”6â)òk¹*qhÜ´wg$éU£Ûѵ¼äö§„O$íË,ÊÜT`Çœ6Pã–1«¼MÖéUFmË3J> èNÄ43Žk-¼Å’®ñª"q2öü¥TåþÂceDÐÉêÙãø^ø¡K_Ÿ‡�c¼ËÁ”awü¹¬¹"[ŽPTÝüM\ßúö©È¼uì5wôÑäߦ‰ë:‡f.Û}ÑJˆû­?¨3JîtÓfq¼êñ|Oa×I ©®Æ C»Ôj>—�~nO_¦‹s9Øäû\WáJÛ Û8íó* K uýãmÓ®±¶o¢©+C—ÛßxÞQ¡ú_÷3xÖ<*Ë#®¨ÎÔ­ÙÏîŠ Ýw`H6B 8_ß&A¹WŽm‹|\v0º }îµÀ~æy(Ã’2(g§ÚÃИÓc*r8ÛÁ;^¸‘‚‹4ºn©-Q»Ãƒoó1¥2~6wùøvŒ=„ƒÜó4i]­ÐŠ¿°ŸµSñkæƒ2 âíÅ£«cs›ãoÏÄ4½9º.sd­"¶ú¯žšïKÏT´’Ö¯·Ê>ïZ¤§À>KúÅë#ÈMv fÆöõ›ÿ«…"js˜jUl]mEˆh‡Y¿Î[Wª&™ðøØÝ!㧜œ¢éö°òÈœ�З:ÊÜÝ»ÔÏ›¥>YºèMKcÊc~Äe¯îÄî+—üroõeÑ*/iñV5y:˜Púyó Û~eu¬Î[±¢ç#…Žaç˜a¢B`?ó=Œ9Œ³HS|o]kµ$>1rÇ*H?µfÏÃÆPôf–`Zf³¶bïÙÜË žw¾ÜĬ»ÎB;£?uoóçSÍߪƒÆõ%cNªŠÿ¤ØRD4PwØÖÚ®ÞcVfÅHÙìbxuö¶ÌBëe-)¼>~ŠÄm{vÛ´aF«fÇ‘‹rs¦1XՎʶŽ5?‘ÛŸÛzÃrtßt³-¼¦4£…+rq7IÊx@5Y³úíå“üûÜY5M²(söxçÞ§šªqÈèøP“RÏlÞPD@…f5è•P˜0]€¿ÂÞÅM²ó ·ÐvÝ°ÛR&|(€ðÀìņx¤(wRqY8œRÎsU{5 pÞŒv2ÇÊ*)få6um‹ÿì.¾u|l,Íß8R]Tžµˆ‡p 0�©ãopžŽó­½Ç$Ééý `g ¹±}¥§¢îKÑ|ÆôLËíL«2ÊL†¿/Êb_O˜Jœ€µü}·ÒÒìÌ“Ózã#‡’0Heïã(è½GÚ‚•/•¥qPÌÒ¦÷Æç(‡;•½°ôê³vœëC@i•~UnšhP3{J’·yô±ÒFâIí_›CŽmÿdw«L3> !,³‡˜ÒçγâÏVñ:ì?V˜Ø&܇ýxfí|o.sÆî:fˆPž¢—‚F~H$BÛñ1²°‹ýÖ‹Ï¢®££‰ûéæÝ4É’ŽÛYcWÉ»ê[ÌóŒSؽEÕ8KQv”³ûü2+ &ÊÅ@¢Ì÷9IÓ»¯˜ŠpŸd¦#ÝùIzãDœW²½:=Æx8{È- Mð$æëùþW„Ç+”±þ¨ #ôEGŠúÐX3éX_ÅÄÝe;Çzõ-œu3}‚w‡W¹sß+£ù$ÃédDÖºµŠ¬Ò ('¹´¹ÇÝDL±¸ïÑÕÖÚëÄúÇ,AˆÓNf‹ß $‰ï¡†²ÓÉòúÑ$>óèÙ*¯>vI¸cm¯¡0C´m˘v”£ÙSQë)'‰ ø÷g™}|ÿbŒ¢ÿ©J_%š¢ÀeÂûî­™Â�ˆü“Ø¡ë°j*Ãí«Y¡ß1uEæ#ßÇÒmF3…ÎýÚÔêm6ª„ç]î¯CË&«”VAp·¡E÷Æ.,Ä-R5=‘מå÷­Ë­£Dfd/š) ÒÁRqYS5zO! Ýø<2Þ2 -ìâóÓúŒ$+‚œ‰Ðøcïêa?ÝÉn™Ê)§{ÝÛÙþîDÙCs†TgeˆïÜŒyÅ8ò:<±¶Õ¯eÕ½7šã^¥ï¦?£æÈÞÃo Ù…–dvÂõ:ÉÛÖ“ÎD�É ®"ÖØÀßÑ*eºræ*Äd.궞@sGi­¶ÝÞÜèañ=Áh•Š•’f­Þa>´ f 98`}ôEWïúnf§o£`˜J §~þEô?Iî—`|Ë ^>vh{òhÙ¢>¡/ÍD÷wÕ…Î$ö“)ÃY%¬R²…ÇÓäKÐÝW“y€$±2K‰yâ‚HÜnô£,GOpñ¨¨D-?Qˆd"LB9`_ÔÒ³¥nš+h§€û± r*IÂëÑ /«H“ç+XxÌë=µæ)ôÞÝng²JÃv þ…Å_x’ Œ×ÙÔPšm;Õ´õÚ_ûRod%˜‹ÍiI<ŸìsŽ(4²ºotµyA €Å¾¬ìyfØBõ›¡ß/fIjo vâd‰r£#èþ Åícù ³‰—º‡ƒú÷ßø•é%,´iãwáå#·a°<¥¦rN±º%×nœOGÿ_Ž ‡L7¶ö½ÄxžÃ­õÌL(]kæjohK߇ù¤óÏmö¼ÌÖ6B¬´QXå‘ÇìÂÙöÁN¥þF_#®Âv–9àhéQH©-¼ž-¤qv|î øÜr…¢¢cj³¥øÕª€àÅZà\Žg}x¯–Û·×È©í ¥:¢òŒËwä©[…‰´ìŸ¼¡yÂWøb¯¬.µßËO<?†Ü „½Ý›ESˆ>Êd¡`_I#V2$-™Óå,~Þë«×c1ddåŸÞüxrºNFÀ£Ô²êý"¸„š°ó¯\Ê8ó ÿ0þ¾b¹ê`! ”ÇÞ¶y?u1œq—¼Ñ xŒÜÁâ9!žÂ„¹¹£ô¥Ì}úƒfÐÐPÚôÁ~àóº£×w—Ã|Ÿ¸YTn}2lCë¼»ºÉ@§e¥x‚2m/ìæŸÆØqVº¬‡­ `,*«<€Ü‡¬¶e:É º1’Ä“õH×èËþsGÐ-ËÕ¹xX‚«6íážgÆåvõ²§ß m:¢Ó8—W™}B‹äR0¥/µ"­îÓ `ù·>HV„UÜ"ŒŠ Ú+ø,aT(};v¦'ÙÍæßõ*$¨úφ}¢ïœÔŠÙ êû0h ©¬tP"'•hx)! ·eBM+e¡m¿ÜoÄda¶¶k€ü±H”¼Äq‰íxò¿5F·¶ô1Søb´J`Ïm ÿ†<= !þáÏ/PÏ 4‘'°RTÞ|…̺Õ*±ÆeP3¦ýu^Îí3ŠÏéJA’bÚ±Ã(B»E;Á´òŽŠ^ýa|jài0:éÂìýj[ª—½Áö‹å¼0ŠY"IñŸý±mu˜Âv¢]ŠéÝß=È8ŽCŸNÃ*ZóJÍP)[ÁŠ¥# q_~„w®„ rG;K‰;ÜÛ4ZÐtî~:z²DM°¤ùVÜK ¿ðXê¿ÓÆ…Ïyó‹þZt>{LJøë3÷tÅšù4¸b7¯kç°ÓÔ[¥»k¹vé#}…>ΤÏèíïÿP ÖÌ° ¸@xùýv‡zfUcº¡•Õ?£tyÖ7×ÿó–+,”eQ>êûÈÐP¥b¥‚B«pĬ¾Úk5hhM'ÄÌœÜ+}àíS·;Ìëj 7^_e–yv‘úDLe`ØK†L1Rù÷vÚn›÷ÒපÅàÿoƒy¬û–XDE^„4n[%Qd‹.¥0,ˆ%_ôXÉQÛ¢ÊæžöÎéqøâ¹è)<è._^÷^ñ Þ¾«ÿéž*:ÌИs4®·†„dZ{êߺ¬Ö(oí¦]w ï²c×ƪZ\ ¸÷L§í·_y}¯ÉÜZʬ&„åTdÞŸ&z4Tµ#üêcý„k›”ÂW ({=%“¼f˘ž¢ó:‡z$d«9{¤Þ€h(Kè¿œa“P`¡sÇ\zt›îüEÿÐÏ*…\~£6ïB¹cÊÊ×β ÷z__>ºùjãýïW;J)zäeK÷w×J `t‡ãZPÅñ±ž%Ež\pˆ…~Å7*9£Hï<Òz £yy3EG0}¥hTÏ÷ Ü} —@Ã8úÅäÍÚNjUá¯u2ûÃCµ=RYyIÐö®;Óƒ¥]žC­…:„Puh~ÿ2”V“3ÆÁ‰”ÓÛí5C…Úâ^n¸#´!Nú˜Ú V€'QµV8F¦ï69J#«€ãk�ò¼!`'sW).3_Ð>a¾ ½zßQæg_äêöÕÊð­º–Qj&*Ï�ø1œ¼Üˆ¶®,c{ùsOéùÖc> Ú}J·F!‘¸‡n‘E n2oü›½Új`JÈ8ù§ZzYæó@¬é)³)-T‚Ì´é?Øö]µ?þ¼ò8oÀj•7õ…´C£Ýhú݉¶{3µŒ”øûÃjû £æ×ÕdRWæð¤N•„£c„Ôw —v[û«ìÜîá/<h£äÃô>àES|n͉W2’΋€£›«hjò½±?ܨ›Y€teåú. bË ÏªC=ùÒ‘©±ï;Ã2.l%?Õ^£Û'M¶_¹ÉGaºjºVÁÜ£ î45åì¦ëkVW­Þ^¨]÷^ ø”øø”>ŨæÓ“¨‡Ùe›Æ Á(Z®z¨si?¦¨É©¨A…½¨TYjÜUöŠ² *LNÖyM>%©æ ¢ÀVÉà’AC ­u?P‡ŠÛצó5™Ó•¾b† JtTâwoÑ!{¹7æè»Í©ŸÀÉóæî9VÌÔ†–h§Õ{–(ww;ºÁÉh®ïôceÑtmžU°<gÕY5Ê„·Í¤êË'¥ê¼ ÎYQw«? Úÿòæu@äïO£Ù9©$aw~dH û¶ ªVÕpæÞ SžÚ }ç®ë[Pû3¨Yæ9|¦ý[ª‘U¾2Fš2HGßÐàèfìÜ!â]Þ7 µRHQj{³Gw µšÞfÈ­½•L+Ÿ0�s~ñ”ëR›q•_g­p¾åÚœ‹ ÓÆï{úû…Õ^HE¯dÝNWëãÀhÀº¦§ár5ÿz\ 9rK:rË œõÄÍ ‹Ëiú&0~2´)© fñ™zúF>y‘9Ñ3ðÌ)3þñÅ> H‡×”õü¥£@Ü¿t-^O›—mdݤõǹ¿-ÛTî£^8ñ8ΰtÛ©Þ<õùL=?”nNt¯¶‹í»Æ«¸ý‚Åõ)/_É„QÑÒSºÚ\=sØ?‘TWá=Hwæj£=Ê |÷H‘R[Ž&;o¨ëf9ry¢Çiš‡Mã`ú�³æwý grJè‹Xj ÉKlíª’?&§÷^öÖ²21SaD°9«{2ÎâZöÊÀê«Uì-rDsΛ¡ú¤ ¢ÑM›˜Œr8B/ßXâLÇoè.žŽA#ï䌌òcT‰há^5W¶…ÕµôÑ !í€Qj£ Ø‹ïCú*Ë<¬ý™¦¡ZÑ4MÄ™l3*¥úsõeéØ7©G âåØþÞå ¿p7ÞæHïuWׂ‚yÇ&ÈÔ»é°AÆ»ü†ÃŠªÌÓ.§uy™ð¦_º%Àj0ì"[tF[]_/WZPŒç½EÒdyºBàŽ 2š—þ#‚SÄ“%Ë@£ ýç°“00 Û¼®nHZeáÊ]ë°+)aÑ–··´D¤ã[ð„nþ@áÖð�¸6uªØò½]sãà˜Ð^~ßš97¨ûS3Ÿ<Ç¡7¤To×>3oŠ¬ƒDi:EP1O…Œ=ÚP<¥„Š¤NœÎF(„5bð½¦ïýdÅã맳&Ô|Â4Ó")Ny#Á—®‘UŒTí«GEV´‡DûXOVX[b`M¥ÝS«NåyrC†óÔ#½S鑪*ŠEÀxíö8–CϱԾç†êÏ^ Ü%7uÁfKEñûì‰t \®*~>Â(ïј™KèOM()jjª€“ÞÆhT3HÓ=¿Ëkw¢zÉvŒçÍó’$ñ›:PpÐóVþûØa¸Á”õ@¼RLÔÜT¹N9jïÝ<Wd°,è(ùú³ù3g¤Ù,°ÙC#*—6 ¸eûz‘¸y‹IL£•ü:»‚B}ÏÚºÒ¨]ùì)Ð3¤@;z1Õ »5uã8ÿ(ð]T™/ö‡º§,¸­32€ë`x o³ýP�Eż^ÓTßè±V¡ï’§:]V±.MôµA‘SÁ×[™®ßèv¥¥ŸN"+¦"ÙOßßÊÝ©’ÞßòÞâÔ©fp˜™Ž¾·>%àÏ^ L]w:Æ\ÎŒ#ÿ…’š•¥±RÜÛkIiåÕ`¡Pnqs¶¡¾§sU'¢z€²ˆøЯÌlí6‘â�¢:kß©XQÄò<Dz™ ÏOœ"óq´N#<ö׈3rÈ|”!tûê˜Beæ³yØ&ŽâýþÓ ‘ä QËÿÉ*.²j×+;vô v Ïσµ2¸ñY››qÁ¼RB'è¬o\ç4uC6æ¹,Ÿ‘±TÑCã›÷6eÕt@]ý×ƽ`’úlðÉ!«\^²9ub”†‰}¼eÿÓJ›êFØž¥Yjø•Ç”2«eßØÞ:âFV„í¼Ú•›¯N:ædÑI—ô Ì/ðæ°ë¾‘Ø'Ë'æцò’ .±Z ‡A‘{p(Æ'Sk;òJŒø@;$IµêÈhøb`äÞtæ*©·%­ò¼cÍþý÷áz®Ï5ÊfAµ·¢Fêi%ODVþÕ¦TnÒS6Á,^é‰%ïãì�\õXÏþ@9<j’{´i{2‡»RX¼?›^ZeðQ<2V{ôì,I#âSMGT×½ç†h.4òžÏ½}-&o·óÊ*»<S#‘‚z¤ü…Òý7PÓçÿ@ðbÉÔþoÈ·©‡~çãñ](« ÈŽrfîyÛfËÛß2E@÷DæuÔcjdÏæíž`Kâä>9`³<Ö^G÷8¬ÞäëúXYåCv„…ÊI­™ªðTÝ Ê4Á^i(SȪ0VÛQPœ};T«2Ç3UeM´ƒôå BÛJW©ë2ƒé¿SÝ=F63B{s­XÑuàÂÜ›Ú0Ä¥c9yï’>½±§iØ0ånKÚŽJLºdúðÒB¸ßi¹g8—UÙº‘p„ ò eê5ÈêDFNøî’ýiõáªÝ™J-S ¯=Ñÿï¦ÿ+æ^”ç¾jŵSùE»ª€=/õ°óå3öÝÕs䬮ðïÓ’“ðfr;ž’2ˆ{ø mØ ºÜ]óÎZ÷s€.4×s¿8Û[°#Æ-Þ½¢®‹ÕÏ8Ú†Þ¯,¾ãÊç/Ä”%r3 H“w5ÆEõlΕ£¤8²ÙÌ÷ä%¢ 1ÝÚ¶Sv³ÙBÑäêýãfƒn¡e³?,ÜV‚1 ¦,¨¬J\,cœ‹]m{þ‡‘k’¬ý"ºEöíwv(ÿpÏm;S¼Ñ¦bu[_èhÛ ýÏUzÔÞ„4É|6;v5ÝæöO.DÍøÀå[Éëõ¸¦à¤çK«Êº˜‰ñÝ-)1³û ùr§µÍØ T£A;­C ¡ãˆR7†¢Œ(v¯þ%âCä×Nô1YŠÎ!bðäõ~£DùÚG0geí#:Y†I=Ž=e:–œüšöÝìX¤?CÂçqõ©¬á6šT&³¬¿!¢ÑmXt¦eÆ¿òn»ì÷‹ù¨§`[›‹x§y=ëhlk¿íf%s:‹ wugbTäÌŒ­‡K‚ÛÙ0ÀÈIZy\ª�ÝïÿêàO ¿°¢ð#P‡ƒÞÑSÕNÑú!=éÜE‰Fž˜c5¦Gôæùxõ*,úÿãø5Æ?†„¥¯wUÉ#«f£YiÛå` zZÊ’ÓÕP8?�¶0É Œ¢ÌÁEEXÓj:׶§‰þ±$»¹ÑR6åˆÇªdG5ãä%è¶ôô?j+CFnì{Ú´@Ów © SnãD§Z8ÏöG´jS%éÅ·ž®Ü’cJÚé™ØSx™]ß B/s ã+\2ýúG гU!Cß0gþOä€bÖqyÂu¾Û(Œ«bE¢H‚¹ ÊÝè:=¸­´V=þ×oÍUóØ¥câ( çͨn<›-Qg¾{'De}}ìTÇ„« Р³­69‘»@èÄx9Öå—7Ãf`ÃhSÓñ\ Æ%0•é¥²®Jogç9€~VKŤòû$¾~vÂÁ¶¸~²C¢” –;WóüØ#ÁÀƙгúäæùÙ2}!«V_>Ð 4.Dw¿ó¯_V~w$ä¾-ŒV—>.}XÐ.4¹m;Ým?Ev&šž/›B_^ïIú¾êE™ç oå3}ܬ³uÆdŽ]oÇc‡©¯q¨€Ïþwó™3ìÁ-ʃºƒ¤l×w†Ã„ ‡2Hæz%z~}C!Û»ºÍYªÒ(sK*TÒG-‚dwUoXF‚4þXPXrt|)=¶>DFiœïOÿÉ`õÌÔ:EpXæZ*v-ípµùY I9­ Þ¥'Ó$6SÐ[F¼è¾\¸¡Ca¦‚Æ´ò8a”_½0¤‹c'âˆ#? ºMú‡¥Ñ}œ0ÖôüËÊDˆ~Ë«ÖǾùñÎÉœúòSè“ÌTµ; ž´ÃmšÁæÓÀ*|b³@òÖØ­>ñÉü~Ë´Ÿ¾À_izw·•´Dþ"à(1¶ø)ÉŒœž§ƒÁœSÞýe¥D�çé`:¬F•õQ¤~æ­x »SlåIÁ*¬@ÇFM U­or±^ 0ê¥Gã ¥9‰8¸Ú›ãbçº_V�Ç ìW®]P›2$‰|´*¥ÜÇtÝì!½X“\]©¹ü§?CbŸø£ƒ ÈÓŸ<$ :Š<½}£ÖøؾrO\¾ý÷-QQáÈÜ&X<7¯{`fçʺÜh¯ÏuNeÅçâ‰&ŽuÛ"u@Oü@%;Z/ô¸p±V©Z:RAÿaºë럘°àÛ—Ãyk‹~ÃÞ"aJ±îhAð5:>ª[¯Ê²|.ad2Y+nÖ(ëÙLÝ<ùç(Èx5k Y7#Ù_̺ç¢9mvô êv¹pô³lFV…>u ô؉–¾õQ­XMÄë€X5‹‡ª¶Í.º¸ Í‚rÒ¢gx!E¢jvUœÍi1ÿÒVÞ|`Ä¥Šåß~á E¸”ÒÃíà;qj44Ã׎qš¯•yзpdÓ[²ë빿ÆXŒ“Qõ!ìEš©=µf9¯¥$ã43§'÷ŸèïGÚ/Õv0ÐnÄbäwêÑÁB?û/Hbq•ùzF¢Ró³óØ10üÀ€Îêïm¨T¥úÕ¾é/ÂZÁ¨( Ó̵è`tµ§¯3ÔV©³6-G>-ßvÐ!FsúÜvb@´…R“|XïÒw°d¨,eç›}Zé %@m…ÞƒšÈ¼øÞØ8N£*·¸ƒgªä‹Ø£ê+¨Ïh»šÒ÷›‚²ê(-½`bâµ [U‰f¨œ›|„ùÉ´ Äü€aíÏmo˜Y“¸b]�Ï!›é@²pÏ’ ”#rÔ /Å$ýûŶéI²’m@cúÎùâl6 ¾éËp¯›€ôí=ŸH¥îGÌÕ ³nì耳'Sfêv?Œü,“õH;+tá%bÕ–#Ùꢀ0–jRbp.×öŽãÄG¸A¥ fß•5ÜŠ"1ˆŸï·Pžªè—ž'‹ÎWd´V¥A¸ŠÛz:jZûÁ‡ù/‰övŒŠ‰qh´÷Š9áls+m ýKòã¿•IŒãÌáÈp@®£šFCmÀdF°ÀÈ >¾°oíTäÑt�èºqï&¹p¹i0ÔbGÎÞ·tdé¿GÈ^Œ>HM‡¤nsØŠëçö<â}¸7pÏö±El±’¯C“ª³ù¼u^›=w‰ÿNuÖ"2Ä%¢ÏžRºäüüŒ·á•Ë=ŸãtnQÇÞØQ}s§Š}eFYo¶T¦ÄSã=¨NêÀ Þn§ äÁïö¤Wíi7.·ç„>ONÕƒeþì-Ë`fU&¥r™Þf/®˜úºÊh’ÒçQáµoEÄÅHe˜JZò Nû"¶6ö°Ulö4EÄýY5 �y•Fž‘¶Œs‰6ô=Ú‚îòÀ[ð¡rÞ²– ¦b?zÕt¦vÓP/Tê²/ÕÝ,%¸s'Ë<v= ß„¨¨|áQèÃÆ£‚Æ*þ¼Ø&ËLe>ìk=8*ÆS‰Íe wLëwwbåî8w/ÖºùQú®"ßäyf>=c2Ü/:$…tAŒÊ»º't ù¹HA#GBtúJ‚ÂÚ£&¹pL‹ŽÈ`’ñg6Éi•c9q¼NYy‚2~€—d6ïëiD׬âßå™ÅêWUЩ‚ª·�ÒÒt»L«žVŸXŸÙ UVE~EBç„jvF_esõ +=ÌÝáh›ì?P¼ÕJ‚Š”¢ BK…¼íéÑ2+/,ù q9|Yž¯Œ|#“\æîAr½¹ë)kÉ÷ AK Å·ç›âÐÔ{ÚA"ñwÿòž¡ §ŽZ1˼†pì—ÙÓÚš™aŒ–äá1£ïæÊv/KwÀ³ãT[Ãltþòô× \} ÿí [1B…%S±õF°ŸèýæÉ;RPäðÌœ³nNÔ Û‡îSÇk[/¬ kwãÂê«à‹>aa‰Tȯ|³¬©¾@�{ÿb‹ç*vÐ'U{­WR–ÎÜì¯:^5òoc}Ø1 õJçz‰ÉÙ0Î/k³ù”fX°Eø¯&úI•z9EžgX^Ç {’OS5v´qâ#}`Ô‰»Z#iã¸NCgay¶ã!¨ýîOÍ›ãÃ"ñçRÿ5Ëëâ¶Ý‹nö #¶²áÞÁep.-?èe¤nâ~gÁöJ‹Ù*ÙbV³jõô”¿öó+<Ƶ*š¿)åõZû@]véŽV@›»÷®œ¼›7}K¥¶/igkŠdÀ3Oô1–”¢ ÛÓ€ñîÿ¾í=Äûîýê¡VxZ&9l&]ȽÀ‚¹êß}场Uµè½Ø /ÈIôŸkx;õ4ôVÁþ‹–ùØ{œ` ¥¿Kï~ØÖ_öuÆƌÈùžFy´æ$ïzZðå4Y§P;¨²ÞÔS½ëL‹R$ ,ö°hØ ¦îÝØ·¼e.ÆÐåô-–ÚBpÄ‹¶;cê.?TÓäIŠœjÓH\ŠÂ }÷œ=ãÝÑ'抶W êöÂç°è=\ú̆/³|?‚°À8œÍõxd‰-“ x—kâ %`§*ˆ¬íQŽ$¢ñžù=Oã ßUBãÔ›³5ÑØc:÷i&Edµslr%ža¿¢�&áŠ=öå¿V³}12=íDÒ#åtÆþÇùQUùþ‚´µŽ]äﵫÔø,µÕöØ1¢Ü¼ø%¾¤‡ÌÕ¡¶UM™‚]IDZv0ƒfº›ÓÌué©q¦Ò$EOʺCQÁøï*ë¼üŒ‹­ ãó©?ðí6ž[vQö ;ÁÖMñ^{ðELU l�VòÇ—˜f|Í`.öÖ8ƒõcNK\[uìAb yÿy‹!Û@‡ôÅxÅz˜¬\ÖA7}™7v»¡wäÁ¹Ð@¢˜v®‚¸>{ªkH´ÿwsË(Ÿù04 ·]•mi"x¶Ù÷ߎþè3‡—º8’,Ï/Ã8óøn†:ædî<õ5ì¼ß°2«i²$ô†Z<ñ[3/Š ÷>µá™—zTßdgé}¬­–M¢iÕ€J£ñÇ„®ìýÓkZuaIL„Îõ3«+ ך«ýL1´²­pè/×óçùàìxŽ¦¥ð,,çN¾. @©—W^EOAâWæ±×®ËTá-Ùwž¶€Ì ~çßpY+Ü؀ߨ ¤mð®Š(Èñ×.²)Y›‚¡æFŽÊ—ܪ˜D™—˜!ŠOÝh5¨sß±Wb©hèþ¨¤E*ÕÅ  LMÍ>3­©‘(é¨ÍB\(ïTCywÉÏõ¾ÃG”WN0…ͨ#ô“ƒnÀ¸¯UMþÅÙ[êÈDª`s¡G:ùõ1å^H—lÁ¯z,øWZõ dC¯Ùag2§…¹?—”ƒ|z¾N˜OG8�H_è_·¨*ühƒ¯Ñîªu=lÖñà£Á Cr¦å«5;qÈÏâûÝù)ŽVÒ·U0CÏ{é<¦ù¶?ÑS­­~µÓ4ºùMéÈê�&,Kû. ’÷Ñ›Í]í[©òÏøä÷”KËÌ(—ææY4e·¶HÉ jÚ‡gÁÐ=ùshN(ðLH¢TÛFö걧@¸²ýŒq+‚¸Wyò„…óÏÖø´™êú,aâG¡µL:8GEåÉe`AQÞ««pý$˜ç?R­˜ˆ tØ$âqF;ídô^ìÅí¦Ê#o–ÅÜ]îh…vˆ@µ= ÊoèM¹ z¥·•{Î*"ˆ<A¹Ÿ½£«Ý 3n¶ÄwŠgµ[Æ=ãAáG†ï2á—¸nÑ/…g2$:9tÏ­¤ØØ�ÈIºàèe«Cæ¡inVú&=ô)-Öé칧yœ4KØöLmþ°\=ü1Ç+ÎÞÝ_ª’ÌéjÕ l7v8\j-9#_O£2­Eâ>¡ËA|ùùÄ@»Ó©îß=l§9•¹=Ã)V;ÕW>tš—L‘Ú9“Ñ‚ù£ ²Ï^) öxú\t~é ›ÇN]7îd?hzzòb>2gAÑ[wÚ2ÜØ:ôºFše¥¦e«áèS5»ðÖËi\Å¢�ðÕù§±yfkŸÄl—ºë6ÍŽà-ŽR~:}ààì¥Íô#úº†½å%…ÏñEn×%Aò9zjèc Ó £vn²[.s2iT?4×ï“ò87G™ к&ß~ª.áíú¶;uS߶àQÓÛoë”O Baåò˜R¤Þè>¥Ûwgö%Í"%Q0ÍLô½ë½³ÎûöñËÒ7·馣ØXÖÎJ $Ú“±œ5 ¢o¿gàãÝŸpzr[ñö#O6EÞwü €œZ„5Ʋ´mûn‡Œ6˜ê¢$>Œåg€Kž9©V†Öñ£Ÿ•³ ŽZ§¢A"|Ã7Öù¾þüÄSÏO›}N¹ëùËkór|؉O¨ß s¬˜LµD‰{–M_‰ßÿ‹Wd©iÏØçAaWv.vÌ´Ž›‰*Þ;JJF¨—n˜%1å+{$Zį/“k>À¼â¸ø¨ÿàúIèëÚÁ<›^L^’ÁuŠ´ªEþ𥞗­LÃ|™ÞnÐTÆäCœ¦žy/G¹L©m,[ج}ÚImÇ ß@ö0;¬É¼ÍÖÅä¥ôiê‹éÊYDPD.ŸŠB/3ï »¯*€ùüt9YÆ® h¬€¶¤uÿ£ç¦„e¸ˆ´ð 'óXb /W…YFIl q„½ç]HáƒÓ;…+CLïZ,P*7¢¤à&TµG×BcR*^Y›ax°ƒðÈ|¹~¼¬îPež°'Ú‰{J¯‹ó—G¶@úu° ´º¡Áaãò ç»æuåYz…Â̪Ï(zé¤ÜzìWª4³ªѸ¢¾ªÞSÓEËÉ+ gw^¨,œ4ò:‡Ÿýwä‡äÕVo»§à?½;¥=@ô `c~¨„ù7˜!áÂôw(`�™ñ¼ãÉmÒ$(ÛÞëk‰$ÞlHM:xZ]£O6ni¨‘ž"û3ÕbgÝb”s¶½h!Éaô_V³ÖjBó-®L¬ž¦0Á½Ó˜Ûœ¼’~¬PÒÄŸdÁogpo'YEàôMDz+üî^Rx9ìꤛȞ»±ÁN^æH¤k'—¼C:ëæ{7²Ô?ÉSÇž#L&^óô¦áEKà¥EzúM@a½ £:žLõŠ$À´×ÊxQèɘS¸nZH[ìu$TãÄ”LP[F–7Aé}ÓuÛZ@B/ÃKóú7çv c!ÑOBDì;“Ñ£Uõ§v-ÓWç¡Qxã„:0IökëÓ{;^÷Rê¾È%M<æ‚€[cB‡n÷rKjîq˜¶‚»E©ý/–ÎufEÆ·®=žñ©Ý¥À ]F](eRBR/×7C£÷l-ârÚÚgù?x ŸÒHåÓ¬Š&¥êkœ} Pë;†²ZÇÃ! |ªÐ¤;7pÚVŠüÔ/•­lÃ"Ê ó¨Iã ®µÜ‹cRB¦ÀHôâ"±Êý"`Z}2i÷i¥\»hWÙ²Ë"%`†3îêŠ2(»w“£=º«9ƒd¤¾´ÞOŒŸ¶%$0(K¢ûš}éý-FAµŸ~áGêbOD›d³�„Vÿãñ\ÐX<p×I@2xX¢äÏ5|-õ§KÔ·„y8a@./]z;D‡yça“ï!)`*¢84Í€È�æ6(åÝ—ê‡f- Ðøù~0¸Šª Bº}µãßÄÁWra¨PŽv|QÈÙÊ-t\êeÁrÄ!’#JÐÚúmsØRL¿÷«È›’‹H íðœNôíäŠQñO7ðÕ#´í°ž<0:O||ÝAåÄ~úFëgì(Æn•ÑÌ´ž¡ûîXàñú÷ˆq9}õ`©€oè$ó?Y¢ZIY¦ó8×)â¬5¯Ñ_§Ôßýzã5I—¶ß9ŠíÞSKÆãƒiÀ¦aò›~Z”¨7‡’£úŽÊÓzñFDrë^S‡7¢ºv*#¡Î(`,ÞX 6Á óÿ¬~y+Çá›Þiš&tB)×V$BRÖ¼î²sc³±)©‚:ا}qjOõbtªÍ÷—ú7…e4K<½ü1cØ9ËOQ7>“–­°gÙï—œ‘­*ðú§o½ì•iWÆàϬÓ&òe/ á˜pÿnÈëæW🅯ÕLû€ØªSé:ÏÄè|Û#QD‘f4ÌD‰ûVÉ2çÜ9à.ÆöÜßk&ªdžàKìŽ[ZP²Mµ%Ûß<©¨X‘*XÆ“rúýÎj Ô¦`»˜ÝñÜõæåÔLCµ·¯‚è¬B^ór®aYŠJ¼^ãy”í¹­¥¡õ+ 5±±’ö—nجÂyh'8nîÐBÊFŠ…g%ƒíÐZ‰Ú˜Ž.í3h¼òq²¥¨éWß»º/{V†+Ü’‘òéð×|©::Sû…\g¢U¸ÏS¨]�§µ�Ï‚óF>DDE~P(#ƒùÕ0)<Ā堙öH,—2¨›ŠbIŠ§=w Ò†¸«W”wìLwG‰­ò)oê»"H¶ŠÞÝ÷Ïs7¾¥b¬ 3pvý½yi]2³½ç­ÒbÖá8WÈ)Q‹$†Ê³&ü“,Ê<¡ö<é6Ÿ=HíÔµ¬*n3á_¥qRù}$ƧG0âêÝì]"ÁŒg.ÃíÕ}ßË$„p©I\s¡€?m°°¹ïŽ7i<½Vô% .wZp¨›v"¦EŒR†Ù63k0ì™ÒåÑ2¾ýâ'–|®de@P�4fy*ãs5ÑŽÄÔgóaü´.Áo4d]Ì›§Òâ‹‹/Íöç0s¯ËôzùÞêzí[Ve7#ÎùŠâg¯vŠeÿ½þw !ZF—žªû+F‡¶Õ(~K±-VÞ¦håA1)Ϙ–æÉuŽþeÓÈ&{2¢§½@9 "Nç›ÛÌÎevÃéþ˜½+®V<qo/ÜxÖÜ“ ‘ºÓÿp£g jÐE (9'“/¢…Ù ÃaþUû·tbc"]Ûv@qY_- »Z î\¯.AÞµé*ªp%“–±!M¹¼Ó˜“"ZÛèø“ Mä!À#ƒ�?ŒTìÌÚ`„7¸Ï©LżmGÓ9UÃiÀk•Tl’½‡/[ô/~ú/‚·éÚ nWW" –§æVzYtP(þ2‘0{W<!�ÙG±[ÿ;&¡/îlP¼­Ã¸›¼ÍBWnìÅô=í}3Cw—J¤¸Zé(C¹öÖš\±_*UòÖ]úui2¥9D¡™o,Ÿh„ZÕ¸dOM·Ñw–mÝƇ6óXÎßSL|aõ Ó9ÑÉÿ²Î<}èFÄÏ“3&‘WQêIäƒÎ:S)ÃTØö§šå6<”P Û–Åàm?ö/W-2´Dßí( A{9Ýׄln,@Ê DT¸×Œc öi‹pš®G†€=“¶Fw•‰‡âÇRk‚w¥Ç5¤‰Éî‘ÙJòÓKn,–…Ê̯8á22º46Á–¾ÿP«,þßU&ŽpÏa!t6¡‡<©Ã�†�Œ³>P¨ÇÝ}¡¼V¿v)ŠoÐfQž­àIÙéã7¿V$bp)ˆ¡çOÝKg„¢uÕ:Ü©Ù 2¾âA­nÞûúʲ, ¯ì»¾=)sµi¨ÂПÏÒM¡Œ,³9ãNI7¢uc[úJé”YŽÌXS~€€;ø”àë¶Þ¨ B@ít”9Bvl®í`'eì&Sl@4cÊ9*È„ Š[Ý`Ë™š8ïüûHÓ8JìàFÌÒÁƈ[ /ÉxÛ›¡Ì+DŒÔjº”¦Ÿ~úÂ|Àò]",ã~äÊØ1†‘úSÒi1PÜã€u=%!ë?ºOÝSÄs2#a‚Xáýツs¥­ïÐxrÒà.¨ô3Åíþ¼ù<6Ýë ØË/Ñj¤¼5—NrlGÝžƒ¨©çNÇY”û—ßZ¨¸ªÊìí³Ý9¡¨÷éBwuþÏàíÚñ®Uݾ{eWý"±ôLSŠÎ ~ÕMˆÖ@O™ŠCÏ%v°+2’æˆþïÿ™ßúë0¬~0Ú¨wF Ö¨'3^"óááâ9U45’ÓÌöÐâÉ.z$ßFÔÞP‘“b©å¿ oˆgPH™¨ñ4wMõŠæ÷±»Ìwa§7ðÓ,uíú’;§<O¦[ƒVZ«‡nRäø/f±/¥ÄÊOÐÅG6ˆ´d}¾Fè_ËŠFv„ĀĚ‚rÙì¬`ÑuXºd= ÑÀø4Jãù€(yBÿÚÞl»UeÉ}¦¾Âo÷åìôÍ#$d#$Z²ö¸ÿÿ7fDFf¢Æ–ש;ª†…½Î–eÈŒŒf6!†./èÏ©}õŽéHacšxëJ¹fÀæºGqײ°T‘x¼°#vÊÙxbiÀÌ øÆÛÏ(3ƒ¢=¹ëLœq _ä3DÈ/€l>#ø à Î4On(ÿý ¢ ™ýw´úz%d$:Š¸y}JëLòµ¸b8%Ty«‰>¶hQˆÀµie—_bY£Äs'e—åv¤Üq£Ÿ-E·÷wƒ$ß?&b‹~¥u³øÎp!‹W,“ ¿) ÂO[ÛZi ÖR‚x’àöæÕõï 3Š"‘NÃ<Óüª46È„5˜(*©o¦x¼"<ÑMMN'„•{:Gú]Ä_Zcàø»ŠI”æDô çҮ䳯5È<àZ_ÐñÞ~¹±ð¦þcGØ”Hcó‘Š»ÅKI‡Š( 2{vDìzr˜y`ËogùïO‰ðqéñc‘G¶ÉB èr™AÚ,Úÿ¼EEˆã–ñ˜Ü¾-8qvÕî[ˆ¾ý¼\³"óJkÀ‚Z Ü_vð…Úša…:ÙÕ,1qÌõŒ; GºCõ»ÕÁÍ©±RÀFºï´_³$óõ~dBYïbœ3>¼þç]–˜‘¾ï†cìÏ‹‡Nš1okM=ÑÅ™šð®ed³0׫`©þÕ6DLŽ_h”bÌU1ó·üKÞ+²kÜù«>…XÍFP„Ų5lÃYŽgÂ01ý*ìELIëVDÖw¾ùÖ#6£uÁSÆÍ¥’VÇtIë´Y°Uþ5R7r3ÈXÅáÚQk(G¡ÚIÕ›kÚ2¿Ô-«¥ûQ¿|µß�NÛæ1Ìù†Z„v–\rŸý(ý{kGÿqÂLèñOñ«òUÿ½ †1 bë.‰å`rCׂ<cg:çÒv7AØ<%€3Ðë¼sáÑygÈ;âr]ö^A£;™nzüƒB&Ù›—ûáã ¤hE:K­êJ”ƒFOeTslµãd,ê^�÷Ñ&§ÿÞzÆ™†YºÝ¹Ôÿ 뤨«. Ð§_wÍŠlµ‘JJŠ2 SÊÓ4¾O˜Þ²G¡ôq¿s.4Ùß ¸¹ËƒÈŒµaNŸ4³îw—ýüpà[i¨mÏf”¶´ZžªÌþ“¥ Fú¨¿ƒ{ºC’MR²Á'%Ú Ý¢Øž,ô:ÃÜ͆»guîÌ!T£ß¤ÃXŠêX0 éÂ2Ôé<áœú·^u÷Œ¡MbõÖ˜„ăêzvMîœú Ï»ÌtíÙÜÁª8½9áù—WR§'j€^EPÌ ÙIXõíë¨tŽÖ ˆo‰tè™7/L¿¹Ð²îzSâ³Ëèn<Ò1oØb|â³RÇ|ˆ•—ëˆn<±Z×Åé#mº-Tæ„Âcº«þÏdÂÓSc”0rÙUÄjâGz†À05V¬JÛ¸¯y%ièïT4Æ”"ÎRÛŒ"oò–�%:]è·ÿ4WîöÕ”tÞ iâ,O«Üâûè,`éU 0 +W»‚©a9,`pYäéUœi¦¾ö0m ±Kà^õ¯™¼d€�cßÄÖ²…ä»'l¡…•Âf̨ jÕ:c˧ãÉ"5¦×Uæâ8wð Ѫ](8„uí\¤ñ|0(»C¼¤?fX»åUyè³äÀ¡JéþÓùádª.4)¾)2æ3 àÜiÆÐ"ˆlüe!Š ³F•9)J\�B…ÂÖ´ë¤> µ”‹³¥n¥;QžÆÚ|ÐeÉÖÚë$¹‚O(Û,/tld tBÓç<«n2Š*ã~øüÒ-Ï<µ¹¯È:Nð°Áqêv,®ÁŸ6÷¡VU2ŠOÁO@¡‹òAà-õËàˆ>’ ³¶…àxÚŽ±|z¸ón8ìýF=/  40&³|©"$kƒ£[ºÊ=‰=²j©µD ƒäýênH¡G›»®é4w8o{OÞ{碽S²$¥óÖ*tËxB¥e.ñê;ÞXœšâQ¤}¡H£ŸN‹Gƒ U <ÿþÓÚ^MfN–ʼn‡ÉÛO(n¶Uö#-Ko%½:ÊZ«vôÀ¼WRæB~Æ’öš®"œ;Ó»¸Ah„ÉgéZÊ““ˆ´úf•Ë[Q'ÑÕ‰+À-i ¾÷®!Á¢‘ûa´W#ã %·FiÌƼÞ¾ä%ߊÃ>a?xõZÿTi©ÜìfªGƒ¶ú5Á;rÝ cv_ŠYÞ[]<ˆlbMS€ýá$H—…ÈÒ(¶c:‘š`c£LÊba06±ãbu1þ_cc|÷ƒ¾ÆiiuÓEjf=ZÅ^&¬2‰;îèw¿–™ˆcÇê–Ì`ÜQÐ*¾j÷ðiUk Oe¢(LØ‹ê©d]¼Qf3Ò'×ñ+Ó`ôcùeòÍÓW_ο4‚º´œâ h¬mU(Êf<-ý£;œ¤Áý½Í¯­jŒHV sÒ*ÈÏV=œ§ _TÌÔ®‘ºwéä£ËõŽH¢x…º+¸N(-`y26°’ž2‰WçüTøN(‘Ô¹§­XJd¯s(Â./¥ø$V|qÏbtÃ£Ñ œý^ßšé:ŠÁ¹ÞÕæ8^®æ«æ2Ãÿ"¸Œ%ß µm­×sŠ`þè 9?;?oÛ¬µ—Cï>¤™8ž‹ÚŠàz2 Äͤ¦u:ÇIæO‡(ÇM.V±ƒ]ÌÕöãæÏ3ð¿z¤iê– €|È}c¶oñü†÷à´n1Ô›õ.-óòmú 5 l%Éç’ãV¬”ÓÕ5 D<PJ/Ús€  *–¸°N@ìN`ظFš/Gf ê²ß´’=J‹cÄÁ-”ø-ú”°c-Dbó'œºVj߉"x.y¡Qœ¡§Ÿt&œ±ôÒÆ ð‡cöð„ódIÍ&ê':pk%Då@¸LâÆÄn„L$zQÂ6ŠâÌsÇ…¶;èÈykWŠ¬ùý‡­;nWäÇ\ä(-VNßypH1ß)õ I¨°ªåVpã\ŽqïðüFW¹,-Y”`þ’6Ú½,cXµMcí–ÖÞ/OUˆDDÑŠÄ hJ¡ZÌF½³›B<¨ÿí~`ª’•ªw ðQ±„ ˆqž§eû÷ùh™:= ìDŠJHžóiÁœíëy £­·Ç?jV¥AJWfìt ì±Øî ã!5ÖÇéoüÄ£Ò“ qæ©ŠOG-Åš®O=uœ“}WßSÒo ê‘•Ý•É#¤ÏÊ ´Ån¢¤qŽðòiNŒDqãeò£ŸÔ% @#£ûò‚¬#AK|£Þ»zÃL¢ì¦·@yEÆ`Zk&Z#§8Ï{ &:wà=„5M }ûêƒÆì{GB¯l[C÷÷zó1[? á€Ðã¾²ä׋Ð+:üCÍHK3kfìUÕj; R­µ‘€RÉEtõþ*ÊÌ$ à“,H­’aZÎøºßÊ'ÚH5�pé·›„>F–]›“’…â5f–âà¡{c9Z[¾ô!™Yè›ÜÆ R=ólŒ[q·Ýfw—ýÜt›Þ¾>—ˈ¼Ò†MYB2´UAŒÏ9ÌvHñŠ~$sŠ-‡ˆVÏõˆ¾õ𯗥ÓcUÒÊvÏâ#å>k'ÍZç6S½|Uß°s”ÿ¼â%Zs›ã‰=G ÙijâN³ŒçÁ½p²EÜÚg‹æÌJð&¬@‡Ø3]ªß-–È:zäv˜ ÆZ[[b¨ ´ÖeèõÆt¿,?ôy·;/Д¥W.[üŠ­Ú¦TFf Ö~Êá´Ÿ#¶ubLy Ñ䃾30Ž¾à¾aN•}ýŽ&·ø[Q` )füv¶Ê.‰ÝÜF Nûqº÷ùY”¨].1Úò otp[$ôëF‘0ø•”óJë”Ã}KQà]»y<ϧ”q/Òp} K Ÿ«½Z´Þ6e&lò¤ÛzÙÙt¼Ö„€öK=YȹO*w—¢œz¥´ü¶;,5Oˆs&·#§þHÂ3)gºgž ¸tN7G¨Gîgƒ~€àçÍw¬ï—*¸Â›€MõúÖÃßRXnêñãïìôòʦ …e‘ʈ�Öì#i8ßr,žp-(»ò4uDdŽ-XâÅš#ƒÃˆ`¬Õù KT•(5çIË¢FïÖÍõf—ÕÃêzE¡ºL³[ÎÈ«µ’Š*&J6h?Ùæu^ A±…|åÆüaÁiŸ¿ï\©ï+jÁÕà;~z(ì+6³l®sÕyÜn,úk¡¦Õ׋jl,ÑÄZ×þÃ-%°ð�ô…%Œ¤Ë§×¿ñû 5ûŽØÆÌü£‚ý®`Þ‹™UË»LÇEôûYd/º”Suµ[‹f|-uÊþDë&îÕp:CSךÙs'ôN{ï¿õP¡”ÐÃ4—"_‘³%£¶L療À¬ÕÝ€U¹+tŠhñ¡¸ÐQwzCºÉ-rœðýä æe?¡ðFÇ,2Á©c8 ˆ9®LkVxÛ{ômbg¿Æ¼NÛÉ»�ec,EÕBÀÜ·þÚ®]S«F¯”¶# Op ¨Ž‹ëÌÿ¸’DNWBx´ëËeôì|RÁž»ßµìUY¥^± ¬Ÿ $ÿ<×*H„Ô¤„®¶(4œ‘t‡aÿ`#¸0êç34 ­ m©©£ÞÖ:G¡ßYo%+#ŒÝaºG£‚W¡‡Ž­*Þ ¦ÐÝÔÃØ=c/¬ñ£±@R’“6°(r°F"•/MƒÚ1Ø”WP*±¶â¢ÂæU/ŸŠOC_ElSÃõQÇ~o™Ëu+ûøºM:-"¬¢"w´ÜÛΓÐÞ %2ýÑ:ç­LƒÞRhŸ÷FîžœªvvfÜ>Ç‘žöÜxÎ*¨x/{ÃùW®];VÙÚ¹¡Ç·KýÙ¡Ór‹ÖîI´Ú㤃&eÅ¡À¼Àí3·±ˆ-èš™²BÊèœ]÷p¹ó_ þ‚œÆy86Ä’›ìdùu¡ç CÒ3j÷¾¾ø“¹ ÝÇ”0óY¥a[Ì4H¨¶–?ãÏIRÀG0g·v<4÷t–$³¦”ˆìöA᨟¼ˆÙ˜~€Zøp5«gꯃ|B!í=Eÿyßp7)ó!ò`²Ð›¶ƒ{’†kã|ì†n¦Ä’Rœsk{‹^ó¥ðw̽>|Гƒã™œ¨è¡y5 ½bÄìQ…^~Ñ«ÏVv1n4¬¼ÛOƒ"©[ÌŒÀ|ƒ4ï™î:=ع›þ`kÀtq<¥’×økø–OWYáºÈi¯E‰iÎ;€¾'ûÔ 1S°p72såJ<E±*¸bèÕ•ìÙјhR|ÏþôƒŽÇ¼ÀC`­©@KZX¹")ˆuÄ#-ú¬ðDá+F}Pen¤,ð¶`Ùâ–ÓÁ{—TËcŒCc?³„ *{gáZ |ZÕ¦g®Â¾‘XsX¦%î]ù-6Ÿÿcy¶#¤�­OÁºmŒt17vCG�“^¦rÄåÚŽ! >ôv¶ŠŸcÏ¿ëE40¸æúã­ÝsbµþŽV¦ÊD)ئZiæÑÛo¯” va¸UŠ‚ÍôS³ žvW»œŽgl¤†î™Ußýàr½¿eÊšŠØ Œ‰öê9�‚zî„Ⱥ>´±Z˜¡Êyo¯¦ª¢ Ô4Üî%. '¨•²°áTùùê©AŒgÎÄM±Ô"y„Ç èü‰7™³#UÄÊE‚@¼´å…žù pÕ“ñÒkFCex£6ÑÌtâžU˜ƒ¾£?qKe©P¬‘è´NÆ÷÷,ë¤r>129/9£g4Dù8=´â%͵nš­ ÓE0 yãËãù8Zcžº~y`Q¸V0÷Û>á ãô¡wEÈ3œf˜ÓtÕ„âSªFñÔ9Š“Ì»p&ú‚>Äiñh’,àÙÍulï<�o^¸éDÂãzß .S_2˜Zžé2ñYÃâV,!S Ó_}%wŽ¨^ÇÐSÝÈ*ßDàøÿéü¢è•ì¶¬|±oÊÆÇ =A(c×4pøÀq?SÜø<pa÷ -’ºÎxª�ïôëb-ñæã‡ÇÞí\»JãL·\èX®Š -LáòNwaÖªmq¤g*I‘ÇÉ/ÍçPíFËÉá)Æî"¶¿Æ¶I஘û°Ûƒo`œ}±4hƒiõ–ùäeá›ã8Ö¨%Ì@¿YøÜœ÷wºBn¾E<+$.²²o¨"­êÁ›’±Û›¿£rE½›^#½Ä¡UV£Ç 5ò3p®“b†0ÔZ6˜æZ‰pï• óvVÒ)"™ÊÅk,<r×Ë8ÔØðÃ}ÚS=mês�äãu^.Wt}ŸÐKËÐßLtã/Û*H›ÁóêCI »ƒ™’(ï¶TÉ#”yö…!Å.5@KŸ^ÏÑnJUýQ¬Š3_¡GRâ“¢qhÇwž£'B§Žêڻܨ«ºñ*EQ¸Èœb…®þ+e³ÙU"ƒt˜ù 朚Ž›Þa£U,|´¾bÂYz}%FîQa÷¯'pÄ–Üä[·Þ©Þ¡…üCþŸ$ÅMþ?�îxR9íÐŽ•Š("\“(E) çÏóñd¼9»úÃïÊ(ûʾP¬_(8X1#âè0òtA~<\­¶fÀhmGE¡K–,·‡c§(¹ ˜Óè«û„o¸ãóº‘$ÓDá²"Åf›–>ª¨¸9ûè> õžç¶tÞMo˵ÝõÇ–‘¡Toš2¨¬<{Ì^¿ƒÓè¥c÷½éኵ¢™Mü vê 5BÁ‰'§BË–Ñ»3:ûõxã!c]£-2è8°†» Äñø7B'ô€b‹Õ€9ÆSÕÚx’!ì@Èåâ´o�0ÆY­ÍëËUnšŒˆ;ÿaß3‡˜…OYÿsÀz´‡›—‡M«Û` ¨1}J}} 4F>)Û…RˆùgY^¯(šÔ™; =jÚ¯¬õž¶ªßSU7<Ǿki3 ®÷%­÷"²>–O\Ú8 òYu4K6êDâ[zT—Zšâ·¯wóZ*öpÀÀÝN?•{Ó\§[à„üÈìˆ×ï¾uì2:(©iw:§ûBê^ÞÕ)_ÍàõqÛ3Ž0ƒýOG�3¬²àÈ« †ªHîÌïg™o¾ýCÏzuöfñªÌ†&ú‚gÜXCúr=UQœ©>̨ry苾Rü…zrÞySPþƒá»d·äÏ4p_‰ž³×a¦›Q4ëÍ2džÍJ NgQx (ªÌsìDWôTUo• X\Ë€Y<×3Ñ2ìFÎ=vøü#e}ÇQ&Í»‹éµGÅM^¹ùCÑ·ßyâwó¦?½Êq h%>t«pÎÇ,Û!£=Spá$^˜P1 £¦…­A`”ð(í]_jÞùjÚÆ–r7ÝæùÝ`ÕŠ*v‚°GÇt`­n}y,P•{x)Ô ÁÐÆArÒL€ò»©ß_v”lP^ƒ[Ú¶  i_� €vÑZ‹1+WNÊYpBÁ4Î^ùkg£ªìñø@ºöAˆ*3̺ų²¡” ÐJiaêño¦¦jëÊ=H6<¡[½ †f€Êqì;æäu¦ó6]ÛN¾|?ÄO Ϩ!i*ÝóZ•:™†¼¶”'¿1¡þ`Q®2>±sªá`iëzigš™gdÉ : Ëwõ<‚,6Np– Âp"øvðùð|^\$VD sµ%ü؃²H®ã‹ä•2À…èÊhϧ_:;.Xðrt^D¿I¦iìwJh»,èTî\דÏ0ɪÍöèì ‰‡w¹Öþ|CÈÃp¥Š‘Ò/¤\¨¾ØÉH¡GËŠiçò<503xñ·8 jžÒÃh¯ô½·Þ0µòyov3�X¿ÜŽŒx‚ù´ô/05î¯Þ^šºÝ„jã4°îP¶ö²— hr†Gq0CáuPª*˜-s ãå·#M¯‚/åþ‡ŽÉÞ:e,MËÃ…ÙyžþìØ“ÒfµÏaB‡sd“’±Sw´ëÜðà{‚¸Ì}½Q¸ˆL]wЬPfq‚ëø_ÄIæai“wܷЮÕ)26.){:RT–¹/rZ’xåËž‰0bíõ`¸RqæN¿0kkÆ!\Z¨B¤Fwó`=¼4!«Ùö©_‹U¸B#ú·£ô²´Â9±HþMžœÔÒ-ñ6GèCÑ*{€A¬¼q†çÁœÀW©Íñ¸ôójz§Á»…«so(7Îp …žzZþP2†¡ïn e«Ž–fñ® ß‚Ù’óæa@œÌw(}é¾,‹}ÿ»V؃Ø̯f^Fã»uþ.6AðNǃ̮×#L¢•¥2¤²jº]½% Ô2 23V¨îðÓþÓžŠ½~~Îzk#íÌsgÇ9ˆi'δMtÿ[ô*¼‘_9¤hOï]»ÿ¢ÿõT¯ªÜ$˜Ž3½æ—Ÿ§'“þŒú[Ò£µé5jë@žQP:iaš =o¦ú´àLçORB±¯Y“³\ÐÇIwQ=edȶ6Gx;`̈ù¢øA$cÓLxr×e¹x:x¬S2ps¿N ©ÈËwkµôK®ŠXô±#¬24ÄÙžOýqäcU_¹‘°–ÆJ<t§¨\nœ´m€µ;ÒIrü¡ÈÈóÌë¹£ñøI+¡p­MÏ€Ð#+Õv>ø‚§úY€8uöH8§C”ž´Sß›5`(åEâvÇY\Ì«_jÆéŠ3Ê‚õ˜Ì¸ÉFf]ŒœÄCAéÄ¥“< =%Ièb€bÛªTfVrÃQÙâ$ü•õyG¾¸y„ffJõ@ou*RC%np`x%_¿o_Þ…¹A—:B:­ÀÃŒ&öQ3¼×ñ¼HFî®õfCÝÁÌlòbz÷<†-Î=Ðl¬½‰g³‡“Ý‹ÆŠ¯ßïÙ›«îƒ@LT쎟žŸ=ïF!vüìŒñ’%ã·D{ô¾PÆ>ÝÒTønדg²j˜FU¥‡GŠµ ÃìJÄëí•Ö2IœùVJ=ƒv_Új®Kd?×[¸[¸«+pæ[4]ñ×4�S/€CXmEZ˜€Úîg ‡ m)œHwõƒcþ¡zô¾–'¡o’P`Ä“…H••Þ ilÚ@ð;ãÈá Jægl«nÔTpè?o1kK(ù¡ü ]ÓÔ´g§íMCçÅ<{Nô°èöæýžgÖƒ«Ufcf’º£žÚ¤¸qw¶iû2»öŠ&ÄoÛᥗ½U¢= ¬SûîY ×-ÄQ;çÚË¢¼CèS#‡ Çá*§ÿà—ÌPé¨bôlöiÕ8j£éÜ;`S}2XÝç0Z§=›±?Á‡êsq)9OÑÏã®fçÕ-eýBæùÙ¶ ²Ç�—•Púèh¥~ÚÎz¸UòÀo3 ?çH“ÐWâŽYœ< òFùrÆ\ùÈY¬ÃÓy!}Ïú£/¨•ž½.7?Ú…n}ñ1´ J>¶)¥/çÃÝ÷1‘R#vyAY{((Ñ?¨?èÔ¿*—`*ÖÙˆô|¯ÜSE+:cN© ÝÇÌ&ƒ©§ð„Äy‹ƒ¾kƒî¤¿«ëó›ä)ëï<FžÁç3¡TS¯<é†ÖZ)™ï\oø‘éxh»iâ=ßt¢¥ÃÅc¬€•ó¶#üPMq<½Õg°ŠÄæ…zô}QÓçÇ‚­Š4\.«é¾ɲñq³mmZ��´¾V‚ì‰þ¡­Ú‘ˆ!òƒ6hÍíþ*tžj›7±Vm1\½fÛv8NNrÍSªý×[…¾�Ìu‹4ˆ—/[µb,cH‚QYÖÞ²…ðf¥žó£®8[ÁùhPè¢$aRôO}ÂŽ¤ßêEF®±²–£Î$ÅaPB– ]iQe”:a´¤ïMOœéˆÓÑî@Oþì–T+z|ÉäɨÖ>h`SÐm5yß$Èm¾dÒ`ž+*ìªå¶8#Aíw)c$Õ‚w[7¶Ï¾w6ªò¸Ajo ºá. É%/3€ÔçÈÔbåNÅ&g/:Ó ïx¶F>N—XÝp}q¬»ÃHF²MO•o«VÓ–fk’[Nz}ñ¬ëŸÙP=»ö¨²)¨ ç‚R7ûЛ 8:§Øq¦}ÓɳÁ:hÎÿþ[ÿJ>‰–oîº09SD« lß-J¨f6&Y}£_XÔ«zú×# ª4ËœBâ þšýšÝKâ)uØ´©)>Uï£Õ¯©6žØ‚ˆÞ›óCxü w¼v(§¿¡®å^qžqq>A¯SÔ2ÚŽ^Ë s©ZØû”™wBb¾§hY®¯zQv ‡§“Gs�›ÎݱmÙ¶Á»¢:ôËàÝϸKŸ®•„ÁRAØÏ^]·(ÔÀc ¦Ù’6‹#À¿Ç+àŸt•Ë•yFHñ|.˜à¢ò”ÿY­_#X)å€6FîpØ Z„ܸM Ê´….i0 À+û¯p~…òSÔXµ…¨×¤¼$ð²1c"BŸì<iKäÉ(#Ïn,}æ® ÒQƒG\i‹D fNaâUù¤ÑP¤Î1ç=fA8y¶"ôÎ3¼Ý&7¤¦ß2¯žo®È“¯ �|=”AqÚy.SžMiWßð4¥|óü‘º{.hüÿTº#‰U€baü-Si.:³™{Û綒µŠMC‹0½zpMÍm/dc;ÿÆ]9 õ°çD5ª‚i—R)±\=7gÊö°¶åèt¼°G»Ž×9G±WÚTD E±,¼²™}ÑëîÒ¨¼¾CLIúJ¯jçç€é«`k5h?|@òlwòЉl竼®½iÜa²²jPÉM»K]ä²¹Wms«9üTA抽pàƒp‹•{º•¤!ÕVÄS�‘* ÿ@i:r¢‹GÎÈkÎ,ô-C.#¬pþÚŠº‚´-´;o ü~ì}k5æ²Jñœyù¦¬l6roÚAßÒcðÞ¡}ÒZÇ`(²2bZ‹D'ž° …Gü’¢¶–€P’¤ÍÌ Œ³«˜ ù«ž)ÿwH ÍÕ¤2p;Iˆ¶Ê¨^Æð1/Ì«Z¥™âÌá@'YYkù–3ñ»˜Ã‹CtÜô‡s=<Ÿq8ˆ#“âTxxñ§îç2•½`"ÐëΞæ™Q<Üü¡¿¼à)dJ&´“½ÅÐÕÓìœOõí·Ûs‹ñ±µlÌŒ “ŽÀ¾öºœ´Y÷<54ÉhH+­sþd 0¾r.ôÊ*M=hŽ85sûj<{”Hü~ÅuÜNæ´çý€®ôî=+çLìܨn!K,=ÚðXÚ¨F¼$(¥zº‡ÛÑŸbÀïOæ†9»½»èÔWZ<‚yÔ+Ó¾¸³È©\wAt†7ÛR|·D <×9�TPÛ@¶è±2øZ$¼ôÄå¹#2˜B8Ûá(å øŒª[/Mà·þLû¸ã=|:>F>™„9~mGÇjËB øüÎcNöˆn,À÷Ý)Í<Û¨V�Š¢P7Â[O}ìçB",nÌ…1ÚM:^øõ¿å‹FVy±2Ä\–sŠæÎÃ�Ú´@CÙBN™ºdE"|Ëx[ç u ÎMIƒjSÓý1³7ƒn»ýÞ ¤ROD/ãÏ{L‚¬ž=áæÔ[ª"&p³Ú!ÿpéqL5G»Œt ~ªDz (ŪÉg[þÜÚ9 ëûT ±¥å¦UA ª>;XA@Ì*PÒø‹¶VUV O:ðiO¦Éšf±Œf+åœÑ¢,¹ÝŒ F²ò3´r·ÿâã&ć›vëû7=i�:›3Žñ@[G*ÉõË­€H»ÛÈÕQÿ•ÕivH)P%Gïp¯/ßÑ2Š8^¡îUVs=˜~ ‰•+gâ0Nˆ£Gn8#L ø3 ½pa¼]½7n=Eébµ³x%ýWÆÛþ±Ï~oÑW'mÄ­§„™y1Vúp/n¿ø—^Â#R6°µ,iSèU ±rõ”ª}Q=  à¯÷ªlUᨄ‡;Z{Ý—Á{¢†CeïúUý~ÙôûѾÊ[®ë¶Û*N¦€:ò Üé2gA:«úŽÁÃËå¨; *X)è+ú?,“sWJ{ð:ž:¡SÙÉrrC%¬LÐÿüìùo×z’ò ®•d¾÷Jõ…’¿wK ‡¬7ó¯uBpk'ù‹oÕƒNºè´Á©ÓJ³?݆•vèpf¾ÈÝWD5u“TÆ0ÐÍ©Øù32 ÎRUá[ Ä\Q’ò"Ûµ:s²ÄÒÆ?uTˆîF¯¢j "é7§ÌŒÃÀtxnoõ¦t§þøCÌ·¢…ûÊ% Š¶³Sk+h”r²3RŸ¬|N![­¡¦(Œ.£“»v?ëAöËbÂOÒs¦¿°.?{Z{r`L” xæâ«wâûo¥¬n­sC·ÌÊ¡w‘·ƿúÚÍúõç¤ }¡ÛõpäÃì4LEó@÷|�™Wqÿ™Ÿ”oþ ØË­ù×6}ų¢ØÎËÙÖVÌqÝdO|^§¿ËˆÂã}ëFÿhFÌoТ©AczXô)M¿èI:E¹¯x߯ÜV3½±c7uJ¯ÈùÐT‘^ÕôC×ÞàÙ«SD\à ^€c¹hÕ‘Jãá<¬²÷¶*š·b•¹ùŒ‘eÞ„ Ùþ”ÑûÕü!ËVO{¡Â@TMTHK×®®©æáYöíÑQ¥¾ãAŒÚ9£`cåw‹0à>äŽðÏðé¨dÔ·Rê@Í Ž:î£0b\›ý4y/n¿µÌ~dž Xdå Ö´ÛôiÄõÉ _Д˜Ž¬Z‹D.1<>t꯾TøCÅðÊ¥3‚²»T>M³ŒýJâä&�¾à)}@UTÃLç‡MÂYtA¼›Ìpù[YY+§)^-"zC%Îì/YnCâr3 ³wu7ÍÈŒÁµi’U’mgShã˜C?´é¬ùÃyQ$Ê(>Lìl–fŽLÀ\ê+ıýmkù@.tÓ[Ñêܤƒ§#›Vàð]¯6¶íxw¹õwØxy®ç†Î•VÁR7 \öþçÍ`W*ÕFµðø—dû“(Ï<a0N–žgOŠö4œ*Ç,=ŽËšTЄ‘×ÛvIô?yâ÷x­Å!S­ Ns^ŸÝ÷s÷£–q'nÑ!g ¦ž¾ñæÙÖl~s<1ÛÔiyœÎƒžRíl,Ã8ŠM‹–mxÚ“oÃC‰¬Ìr~%ëçt&$Kà¿D'¥J¥)·ELùÑùg5WÂOê¬Âó cÝ„aú¯ö† ü7j×¹oHë™)j¿m”cTÁ‡Â|/cÖ²hÝÝ´ßn÷`$<ˆLÏÈo±#�1<6┿yшF½<IÃrÀßqÜên˜EÅuÇ<°ýM¦û²þh*ómS©dÙ÷úù¯óf³Î{LˆÄ¥á?×ZvK‹%Eç(Jëg@sÎûJ ×Xç#»*Ñw§šµêÈ$ìø»Û¯Ë=ä̈TZàÑ Äú,4«o</FÊö{ï…iÈêMµ¬ÝšþN!ŽfÛm£³Ýð{‰»2MŠÌZ A´r[Ð혬?GÎ5r7Ô¦â_jÚ‹‹¡,CgãºÎ#ÌdǶ­ß6W ;€t}ô#Oʦ2€ãÓ.8ÍèáȹªÙItƒ—ñÖ¤xmJ>—Š W¤ïÇ¥ë>/@°¸ým߇ÙuNí\&ñZ¼œH4P‰'϶Šá×’^ýîÉvîE0$1Òj¹±p¨t±i5£¦ÆÏùÁÊ,IÀk-C÷o‘ˆI®MYeñD\ù«R†¦\gU¶VQ¢.p‘‘\Fa«€6�廃bÈEF÷…X¡˜$ØÂ#{¥ç®è¥´]Ùœ¼Õ±dkÍiQ›æ1ÿÌN/*_ÓÒ–ËDŸtnLÚ’ 3i£hz§ðó©û+7†Î|*yŒ:Ó6سD§E¶I•¬Žâˆµz¹‰0yá·-¡Ù´C|ŸDƒn*£ö›NÔ,°‘®üìVТœ‘s«ŽŒÅx¢íT,¾–¸§r01VÅݲp7ŸE_î^½–:ë<z¤tœvè—î{P0ø6ë´Bõ¬ã'vŸzGÿ[PˆpD8J‚b°|‚#{–¶ VJ­÷s¾”ùäÌXîwY–Ü%!Kj ZõŠ—<—Òì¥%a^¦®5yÞ¨u”‘ig–o„‘Ò¼œ=z}¥= .Q __ŽÇQ¤.űÉÛéDg™CfÇ …žñü<#»@–Z?ö#»ÀÕ#£ o^=v¨é µI­™­wbüUÁj•²Cªa òäǯt=«ÊMXf›]é*kv�éMl Ñ6“þû'ºÛ}bY'¢�Ý+î¾wJ\ÜíÅuIÍSQ03dæœH=H¾^Ô³ÏS Æ¥•­'{õäËÓÙPX Ün31¶Œ�íµuoÿÊÐL´YRܹ@ƒË4Xt1žu=ú­¢x锈e‚½Ì¹ÇYOb•"öOZé™ÌÑ(ëZÊ/Å1z€ZÒ³‡?Ôé€4Yèc:ÐjÏ. vn0©ög?9Ukõ´µØ‹ëüÍôÖÉž„ŒLLÅþ'™•èßÔ”Úoœš©ÖǵŒ@à‹@ì¿*µ·øÿ¡EÓç˜7nnÙ»Ùè8‹ õí¶®.EžÐ湌æhd¢ÜÜwÞY.¼DˆÂæä’ç¦B7Cx%–– yXô|Z7p,Åf˜®‡ß`sïœ`ROCO1ÙÕÆ` <ËyNÏ€ü~ã­ž…+òr M—2¨¬|I¢Ž²Ýhqf§n‘çøÜŠ² WŠPQ0Ïp¼ÚyØÁF&)–}Tš…+¥¢rH8öžz:R²V“KõÞãÜÞ£§ÅñÛtYëm¥aizÉ¢©C]Q¥Ö)ÈKe3ádŸ HPº!ú"Õ¦¸2ô<c.Ï'H9[ hp㘙¥:€©S³I­¹)‚^$¾äZ .P8>/’rîéóͧ®¶}11:\ÙF¥'ÞÆ´€ 'ÛÙtE“™î/µsï%¸À›-fweð¥O|‡]‰Ï�å°Bá¼Øä‰ÐcY±ÎÓ—B°³W¿3Nˆ˜áS–)QNƒxÚ:àfO± •Û¬±±ÆÛWF{̲ål5ÿ›fö©M"®´ºa6º¬J†|ÍFS-R#‘Y†EŒµÇe]çBÞ6·~0èª2¿ƒ±Å| Z'ƒîÞB‡êüâqåL0A®û¢�–½Ÿ=<ÆÞiVP !fTÂZé‹ÜIáF|×?gI¡ºëÓ¤¯§þú«ägÖIìg˜PØDKÛ⤧ãqî‹&ý´l@ž8׆CeÙoe虼±Ì)à«ÅW¯›¯žà= ¦*#¯œ§ˆ·aÆj—Ù {{`é°µ˜ÃVºÉ@ðHÒfA±|–3›| °”Ÿc¡œEŽ _g´þêqˆ©N}µ…¥âpÏ®Þ-ú ¦ª2ãã D³ëïH(²Ú¾- U!XäĨØà9TLÊ>¡·a«ð‘ygÇv]T¥a`ð~éLy÷Âå?3Ÿ Ïã¾VÆV€Oæ¸õVšŸ§´‡zºz3ZNE•ÿþW¬Ü8\>'¶Ìº@ÇŒ¢6ÅO {œÁ ›#ôìë5𒛯Ž‡ñNŒ%ÕÕÉÒû#kÀaC^cFÞØ#ï�Û„É ÿ�_šÝ ?wNº‡•˜«6õ OÊ\ô¸Ø%Ýêwq¶FµÎêÖVIøL¶ŒC3ÿfy=ðÈLaëHß5}JS«¤ÊYCKÙ6 ä6f2¢'OQÞ0èè=VušŠœF…‘SëÒ ÿÔF8¸Ÿ¬ZëI²„kœ¬ËÀÓ_et×ã1¼o¢Õ´ì�ÖºÆ2ýçBHÓÛ‚å;XÍ Ã©{và„‰ÑŠV!’–áLÖ¯ÒÐf k¸NQðÞÍ×qÖV^cÐ⺙B²¹ÂÏLþû,xKº,¨º‹ÃX‹CÃGb„š0Ü6/¢7³ów>5÷üôWXÿo‘¹�Í«r[›t1ÆS§ØÜÀkOx Ümæwî¡Y¦©øwpúd5¨à˜•±k¶ó û¼Q´SËæ—ÿìǶhóÍóƒŸ4œiø?q{¤}g<Ê÷;*4¬¿3~Ûþ `ˆ—{A‘_f8íx¢M‘5£'½Œ)67Pø.]äÍ…>YÍýÎmݹW]“rŒKƒeBE ¹î¥C-$†¦ó™U~x“P‘‡Î3-¦i¼ÔÌÀ5Èá¼9;°-Û”ÒßZ]V#S×´I7ý(ÃÃ¥“;q™ºý¨/jh¦f'mt/›ÞŽõ2æíP>­ëx°~âö|7¹ýÊMåäüñ¨‘²Èù<©'wFw§ùxð¿òúf™>O}Ó—œbÃÊ©föîë.53›|ä¡t)Ö/¯52ÊÄWwi{ˆƒt¼š"7Ž{˹-·ÛŒûÕJïó;ÙOoŠêçi�¯öJ `º5úÃi{Tu”ʼndíö‡«|< æ`{¬¦~Å tûÔ€)î&»«'ªq™W>³¤/«»}.†ŽHÿ‡¯¿.Y™€>øúâgÁ·ˆ‚eš­bLSCUÔÑ0ÀÑë'{§‹û©S,±%™»äõúDX8[‘:Ñîi(×,gÅü01€‹$�Ð’ªü/it±¯#ËìæHövª^Á@ü<~tÊ^ù‘é,ÆŠÆth¾N]՞ܲ£ÈÌûæõ^ý.4=óGä_“  p¤¤‡[ÇyòêbJC«!˜tªI鿾kîc´¨…à-Ò†¥ê¨HK}IŒnQ—Y§™IõöRƒ:WíWš¾¤ÏXy6i,# }öË•¨#  :§RÛUWcÕÛÈ¢3:¢:õžZÀÊÃó—ZTQ©81­ ¹wuÖI"æ@v¡Róñœ‘û´câMs¤OÝH!g«Õ!,<@Å•~¬aÅÌ©Q_W–Ôíëý/ËÖÞbQÐôiP6*À&"tRýç-µÊ¼íYq׊2¿‚•Œ’ÈÑì¹µ?A±ìDz> æ˜ì kÇfÕüiX¯®÷J‰8òR(æ§7´U««…•Æž¼;½=,Cêõ®<Æê$ ÌSÅçv …é|>À¥3›Åq”‹'ß½&øG‘Ka¡:À°ÂâªËE쇦ٜƒ¯<Eú·ô¬ºXQœÜêÆ'©]œ “ÔÈíC·¨ôÏX(0ÔíT'ålJ4ήÛ.9ñ&ÓÞå-è-^)öR>Oå%䤭ªUçÓ‰'¹vÕí >ÛtÀ!ôïû*—{çy!<>£{-cñù¥”C>ß×m+ ý/¸|N @ÎÛ Æ*t¤76@`™wÜcÕ~^÷ȉœašRÆ´.+ϳBT$ÂðŽ†™Î”q:§=D\\2œdúeÁÔÖ´\¶[€Üu°8ö ãâ»é¾Š‡2ؼ0è) «¾ZOõ)åx™62ý¤S‹…n5)íVZtáJDÝ% ÒZC{¢2ØwtÏðmùZÖ5gõ¼²¿ºƒ²äƒfw¿”γÊP˜ÑR@u÷î°aR)v–ÿ›©Qâõñ”Ǜՠ²elˆÒüÜ>:Æp…{õˆPçf!—FÝg©ó ®ÞÔÍAG#:Õ:à—å>¢Ê¨¿…‚ƒŠh»ÃÍ¢ÕmŠ7LzÀMfR·ºî=ÕLŽ=Ò ¹AÛÓ‡žbÈÊ™&#Ëosüê]ðPmêN{*^IÜ0ø”6I¯G&ßpNÙ×[îÝ›§qy¥ò++7Sâ¹ïe‹µcÓ”ÔW®Ì$o§ò÷Þ¼|-,T¹4 ‚à¹=ÙÒR3¤õÀ]1-=…i:ù`QmJ«êE&c¹\MCÁH<”±ÈßåCÝœÊÏOÏæcƒ�§ Õn¼œ~çídý¢LÑç"kWE@»èˆ”YhÀ f&>†œÿnRäh7‘vPN¥GÉlí²êi¸ªßÞªHñsgTôÑp'²ª ü¶Ç*ä‡+«ŠQ½ÉYs&„QÉaTu”ÌæT¯¢YÄâšÅºh9”ÓlEƒ#Y^ÞìvßÝ+ª]f¶$`.t†3Õ µÒ¶§ÿ’çÀÎQå)ëÍ×ÄÃ"£´c—Y}qñ¹¯-Jضï=[lÊßÿ(\Û�2’`è°IF{Ò-‡ ‚‰J´]dZ~w!²ŠG´¸kÖgk1Ò$8$ôKLþ'Îè7ÞëT -FÝ÷U=ï¼ôà Âƒþ,©tØ™{·­÷“ö°aa³£jÔƒ@y(-Æž³ B Ë’’-Ld®óÛ–Õ¤ïŽ:ÉŒô=ÑñÓ¾ -Ë2_f“Â×õHIJzn=¨¯ w<UØ-›^´õÁÙ83ö{žHRdÞĪ±Y:©Ëd”˜Z.7*5Î'äg‹¥$ WèS, kV­dï¨@뿦4/·üxŒ“ê¡„1j ö(ÙðePäN‹)¦”Õ?^z|nÛCí¾è™÷“›ûAm¶t_’Ü?PB²Øï<Q!q™‹ ùü£cå|Ç~N ðÛˆï"Ül5"ïÒ:g0›®4q“É6Ë@N‡U…üT'õT´Ù3j{¥²¿ë¼Oî—Œpe<þ÷WžtžHŒˆ)}èOe?#1ÇßÍü mXG#¬èÕ7˜ÙŽr—î|H“Ê”¹)±Æ¤ôZ%qÓÝõÝí…�NŽê)Ig6éòÂaÿþM.žÚ8—û }ÚRM_RÞ1xüb!»¸‰äKmŠÒ™Ò05"hš*§/m¦•|<ž¬‰e3v~MîÐݺò¿ =#1»hW‡íÛjŠb{#ðj¬Å¾ws =5™Ü l¶÷ÑíšÓÕÚÑü’(–yªm1cÒ†‚ ¹Iݹ81l06}Ô7žq¼dÐeåŸÅN:¥l? òÆZÝ�°y¤[IPÓñÊLDózŸ„Fá­/ïFYš8_Ê›•ß{‰%cû@‘±IÝÔ1ÚôïnL‚É{Ÿ÷´Ètc aêV›ãé8`×ô÷Ÿ:˜ÇE�;3ÏÓX )QË^<³FxŠ}ÙOÌêw´¾ŠÎJ!ѽñ³? i®oTÇÁž‘ƒž—¾<ø™-È=¸L“c8ÛkØÎi«„±ìD€}-Ú<ÕBm¯GÚ}…%WE‰ÆÙâ¶ç|¶?�À“ɧýæCªÜéÚñOîçÌÆôÂØDBߢ²`FL{9žòôÞ¢ò_—¶ˆC‹•Q<’,(êF ÓòÀ«u‰b4µ9.O4ÍlR)öh´,›”>³=õÓÈ´CüùÝ‹·Þr¹2C¸š ú”çÞëNnVÎCègóG´÷2«q’z|?ÊR†fxÒƒ“ÏÍãðVo™Éó¿´ëSï]}ç„P•+¥LTFQ$'E5ÅFòa³²”·科%ñ2wo.ÅXEePÀïM;SSŸ?Ò5äuÁíŠ?âi|­”e+=[Écîa­¹bÔœ&Sñ¼©^DzD…Sg6}zrËâ8÷èGî:•7—Î~¸7¤U7߉ g²²9dEõ—&è®óA‹`ºŸ+”ÛuYZa¢7øUìPwìÝH+ëpkZV~s‚ÖØÀmÙ»êûÇ>m®2ÎJ¬ç¬ xÛ"Êê¡ßÆ´/Î^¿u sjt¡‰žt€zOƒÞÂ[\zB%ÙéH‡Ôâ½L}Õ> µ;¨ ½÷^™b!yDp�ö¢ø~<·úrÖLn»,èw |ÆÌD*†¿�8žˆÓ €vY:«Å‘#�Äùƒ ÎÞæ|zÚsN#'ØÄmÖ &Ü‘Uƒ‚šÛ¦>Ïl)ë†Þ[ˆ‚“©AØÖœwLÛ¬Bü}CÎÓr×^_Z*aK2g!ráìÎûAz®,mÊÊñZ1¬d«^ÙÇ Um5ÕúgºXÖfÜWZङà¼`gå_c®ëbV©Ê…~]¬#K!Ì`µð~+‰¹IÑsE˜YN¤{ c€~uØe9yO% ­ìJnÎ>`nÊs§IzÊ‚(X&^ä|͇ÑZ|„|k�ñ†xм3É:þJþoÿóF·Íù %Rm †ôäÎÛŸT„r \±ÐÏ¥¤<»sп¶¹úŸÒž¼¼ÔþB«Ã"eùWÆ  Ê©Ûzªö,¦Ú*JˆZFvÊÌÞÓ·`(‹¼YlKÄd3']apѦ~}˜‹|—–¬4ué�Úé6õÿzA>¸è#+˜p°Î/•‚âÛ"¦R·=+LYssl±˜4`÷t¨ŒˆÎ¯%ËQZ¸Ù›¸^&Vþ×,,Äo³¯g”¯ù!­¥JSø~PfED¢Ü€ðûœ_ŠÃŸÖìB§ívµîZ‹xyê&2ÌÜ4YWE£žtzËü½[ÒìNáeø|$Œ•*cŸ²©êH©„5%s£7C<¼ŽÝßÝ-Î(ô½Œ"¶ŒlË2Âàà Vz<‚_EÖ<^Ƀæ–Qêìå}-Þæ/ú<w´š¶Ý4Aì_`8[hŠË]ò.=ø®HB¾ÊZã©3Ø”ЮFž¿s:ú Wô¢«?žDijr~s�!ƒ IÝðlóõ{Ñ{Òïî{7:®™KVÝö£áVlð1뗻ϭÖE¶«uBó©æ~49l»ýT‰ô/mâ4p�žƒz:·È5Öó±Ý„“Z^¡d>G8…â„ÜöËL'ô²¸ùˆŽØž‡n ’ðpï£g²UÑÚ‘ŒÒÝãPé{kÎ1x OkâéBµ yyŒ„¬ÜT8J;:k­&;GônpL)!Í°ÿfºaÒ]Ȳ ´¹i jÝ)NÐ¥-ßXì¥ÂÓ¾in[g±ÎŠS ~Gzo+l…YïÇ•„î²?±œÿ÷?¶¿Äôœ×?ø®î*ù»ñß½=ÏenøléºlL§mæÑ»Ñ9ßòÆüð0i­ï_xûý˜=;×l/=ÿͶĶØyƒ­ãL W;l§n<um½ŸP£µ;víóäË2æ#³CvgÈ'[ �Ôôf›©¦Ì±›)G±õpök Ù¿ÆЋ1«™Fœ¹³¾b·öŽžQöõeNKªfšî¹Îÿy‹ÃL­j£ÎÁH#«˜½Ê’¾ñ¨ là˜fY0$U[]M6áf1b¹qÇé0£{æ.d6ê–ðº\­8³1;Ö–AD©´ ~Ë\ùÉš!¡1 é÷E×Ú2ÌÂÐz>eA6þk:M%Žþ¶eį4÷_ì¼õÖ×#—³a&Ó•™7¡+ IJ€|Ñ[X4Ô7 x÷X+#•*Ò:œ7ôÜuJÏ“8ª {5¯¼T; ˜´t‘t¨mÈž~æXÅb7}=ÂI`øRµ7[›f &ɽ{/'°ÊIÇþ¦Ÿžîp¥‡5< Åߨñ¼å¤€[a5«?KnvÜS£9w¿0+¤c2,âR,…KôM „µÛ=jL©î:7×ãÚµ…W2ÃIâºüÙ7}J¹y÷ÔßÊi¬Ãm¨aIò¯—ˆýUèF&•h‘CÃúŽÆ5y,Š<:ë¬LoºI$¸1 Ñ êäž«HÄL îe[�HA©è•!ð!v¥ÅÇÏ×F{I–¹&°àÈïvF  Ýj½WJŽyN’I‹ÐSªæ¡^”£öS —¼ÿ# !ARõ~¨EªÇ.“o†yYé{JSMtšè] À ýIèvvÝÉý=Ðo_×gzéøK|î±Ëa¿Öªˆºªüç­¢¨eÍ •­i|ªé‚»\ü˜ÏðÛV{,ÿÛH„™VMO»*¶îLLãÔ²·zº:)~ƒ›|‹ÐGÇ|@ö¯>+†®öXɯúÍ[Ç£—šÀò î´†€P~çëoüÆD-¬2Ï}3¤» )µËÉEŒÞv�^Kï>+½½ÒßÏsׇ+‘‡”E"Ò3öî:8K½u&û]B§eæÕnx‚c±IidïlÈ> FÄÞf¾Ÿš”:·RäJ=ëýÞý„þ«ùo=žrò‹g¼ÊÝþNmX^TãqyYeT¶Ùð<îþõò¦-È\¶ØýÎí<J=% îè~'«y‹óeªÞvdzN<¬Ðý¯4ñY¼%sã•‹ã°õ¦í§I v¿[ëÚØü1ˆhµñV10†¢Í>=)MmÐ F$šá…âŸ`,Û}¾Â­NT¢Ba.ÎZ×±æ÷úźA'º˜'ú”ÓœzÈl™˜V_[ÝÜ¡j•ÙIOì[Ñ9zt¥DÔÂÓS“M”æQciô8b™`Óž)ÈZ,îôñƪ~rHY7{ ® =§Vô¡ÑùŠißþë�œünF=Œ‡A”¨ÿ¬-‘Æ3䥻k~E^æ«61"×_µc –äP€s>xªŠ×_PÆUè;·QÚÀJÙ GËf [0nвçýqœ!jD§±ý¹'«ñŠ™RW7J@¡Tã—''ˆîé¨Gä«Ââź3PëuÚé¡mteS€m¼=¨€›õè÷4òN0NOG:Œ“Z™¸!ɽM=±+¥{SØÈG¦ï›@Š9EŠWTg+Ok>nD*.+þ0þrϽkZÓh ©¢˜vH× d¦`©Üq֠΋-¹pK†[¿"ÖÅEæq+:lbÏo6ŠÄydHÝJÖáõs&R•®ŠSí¹YêÚÙtÜûgp0¯´ÛÂÊG€ XŤJJÛëv%6Ø Ì±cÆzÍôü{Ÿ3<TAè·ª²Ýâ†øð+4=xSXQ’?@OHBS׶€N¸‹;™Ø*ádf29é.=oÀ²; þ™ÔÖèzÁmDSsùñÎöœQY°nÕfŠƒbÞúPFqûŒ·ë¿)L`ýÝSð@žû]UÈ\lé~%6“À¡ùÑNGŠÝáíöé«A$X ¾° Ú1¡¥Þ|z¾‚O`göNsµ¯¦(ªÂí°NÏ~ÎrQŽRÆ\ú;@åí\nÛ Xä;·€Å…:æH'àó¿&*’Øn¶ˆ©¶”éÖWnVð€p8žxyÞ9ý=Ip«Ê‡?Ç:e¶ÖX9—ë}ÛSýaÀ¼š\³.è´ËX˜ÖQê†+N+«5ŠD‚¥Î¾e98îri|š¸`ÙÞЄ€<´ìrð˜è‹Rq6úƯ o8‡³&Çj6è/IOW'Ì4Cùk竪çQfåz!àó®•ãÿæ4´àÿœ;C)KiFíâÑÁë¹tÌò÷º™vh!)EX2‘¥ø<›ßV�šsê4…û‘È’yâ¯<3;P±Ûè ¶ž÷µÊd–@ѧN&MÓP¯fñ.W4Iì«Kñü*˜¹´Ž³W‘Ý5§Ö£eä/¨4t5d‹l–Q>Ò9¹MÊt„k™§ýÀÑáÙhpš6 hw¥]sË:‹D>åÝx{1mº¹æzòÒ’´ γQ,üF{×ú$ÌÊÙ¼\ÚCÙy²)£FÖèø )k5·âÐDâË\áxqöÌŒGÍN¼×ÆRwªŠqè?@ Œ'ºÓ‘%£XÖûÏXüRϬ;e‰lÖàõ–ȦŽL‘xbCSJv—A™x†Ó©ƒW7k7ýUz_úÂp€‰¢^ mòÇ+ŽµÌ‚v?Ï&æ$áÕ¬ùÁ4 uÎr,¦b…Ž˜™¾×ž–^=÷F¤ÇÄêß’0Ë•!ýU}}íIÞÉÚéãºný±yëÅyrhuå'«Æ&©­‘åÜ_<fÚø$%Á^þD{ÇÛÔVœùÔךîßé€îÜѤ=Þ%|3ÒH'$ îJ§`PÐGÎþ/îl#^&À¹è`çïŸn&>Òf8õìÀ¾ôï«ú×UâKáe7ê‚Ç©Œ²­UHÇ'åÓ³´½ÿÖ‰:J³Âú÷°–’áüüîMªêNûó|îsßçI°Óè‰ m�Ê&QgÓÇTÔț룕û͸¿Œr“tñL¢e“§Ã�g1¹¹ëaFÏæ¸r¤,ò‡ÀЖ:ÁHʪ Æ,-&ÝËô,L_eêŒZ‚g¨ûhSè$B|Ç·9m)çrã¸L?©ð¨º‰�ðe!<žl¯/²:v+:`ád‚ÃEíÛÓôœ Hù6°•^0Õ´N Àb¾RT  êó Rx’2L¡C¢â¶÷ð9”k»Smsdƒ]þú`=gñ¶ ûlT£zÚ%D7ûðv5nªàL ¡ºþ…ÉF¥nLKS—bCdŸ0O¾˜SÖ×WÇàŤP3%ß8Gû.5´;Qµµ×ŸQ.ŒM,èÌA8@%„Æ)•Œ¬ýH%LÙ[¦¶(…ll<•w·gÖøè'ßÛ¡8‹Êx’mþ$UÇJŒØÚÁ ˆQbWžéjo Þ¸OiðÁ5ïõÿ©ÿ0þ^¦?¹Éõ}&Ú:Y°£c¤°Òò.öõ)•Ðn(V‰Ôë½*jœD™c“R¥Ü'A5½›:÷µð'É»-°Û™ cAŠW·fº?ÿKä&»`C³r3SòŸô£…¯°ù-6j¬ÁËàŸù|¢v¨mõüpG¹cÜåsÑéÝ]œL ÍfU¿á†ñ¬åÅœ.Ê<>3_‚m› ¿àøÌ@ù½ÐŸŠ„"Ü8ÒûºÚ}s¼à× eýâ¨?®'³Tñ�o‹eô'i{YÙ²©ûâzåÉ+fSz.)s³« Ù-ê†w—hR!L‡ µ³ÝO2›Õ]vÒ4NHY&J¯Œ®< <Ÿ5CWI[{rn}š?åóÜ{K|e”ºÒÛ+°ewCF‰¢u^ËUDË`C}d2ÉãË{H¿ë€FKý@·4YTÛ›µá¸Ål5õna™óò`»ž;aÔo­JÓÒewLæမ[ufö¯�&æ"vƒàG�a0sëÜÕëÙWªµh,¼ Z_xæ‹U›qøx:Y£¬Óñ:Ÿ “|Oy¡÷vê8ÂpËiIìz– —usV­„MÙ}Ž“]z—w9^Q8¹2…C±Ó”fo®¯-àpéâ­9¶ÌÂÙÛÁFå@d@ÿ6S¥5þ£ á…1jâåø_(ç…YÄzÅ› íHí ¤ q¦ô{âÁÑa/"¦öõ™ÛZR¸,„iŒ³É꫃›mú½ !ÅI Ûhä²úh³¯É¨óÀì˪STx¦£(T›»~í@dÕYA6øú3Àè¸Æúêéâ{àé'Z 3/ˆµäÙê}n²­¢TÇIŽs£¥æG®{˜r£Î3™ˆznÇ£wuã­\„&PJó¡ÄÌŽR§ÆÞ¤øNdc4ÌQobG ó Ú|Àêq¸"APDì¾ m]krVŸN¬=#¾¦Ú`Ñ,æ{bB³ˆ»9ÝPô£*óÅ!«`�Û Í(dPÎØv³­Êƒpˆ½ÑzçcFbTШ0C°]èÓ ¤¡ýkÒîxiÞ*3Ú¶¬ûJOÛè·­§Vø51x‡MŸz¿…•#ì¼L¬_p;4r>KêYÐœE`h ž–TŸ_<k%gYìgôOóú½R‡ØKàÖD”M>ð–ô8ë¹6ªóèY°÷ËÉ|–ݨ },ð°òë°.`' SŠ`:Ó×— fcžxSò>"˜užX~á64‹éTAyÖCóI¡ó¤}YÅ€ò<|ö­¿.°ëWûÊÍÝœ*ô™d•è!¶gsvæöÔÃùð†Y¤9WþÂ8:ÊV í *ºÖ#73¯ $ÆÇÖäß�ˆâðFcþ P?]¬Œ¤(uzÃcJêóÐv:ñúM½’ÕƒIqì½LÓŒ% ÄÚ]ºT–àGÿS63/Ž—Ée�7°/t㻫™±|a}6óTÓHx…¾ºRæã‰:Eÿ*ÈGkÕl¯ìM†¦ú"7ú›àoi±Qi„ç¹€ˆßONO‰]�Úµ«ôöûÂoEå bÊóI™iÖ’ SôÈ Ëa>œ^QƧJ9oÙÞæ¨4çÎú¿ºP0@lÿâîl¬sc3Ö eíf3ÅãcÕ¨Ø+>c¾e¾<‘TŽˆaükʲIs#ÖÇ9”0ËPÏ eÆ\½Z°puÈÞ*@p@il»õŠ¦¦FxIü|™Ê&h“0>Ѐ^4d*=Oöo€H¶(à¦ÂT˜òHs¯^Æ®GEåÞ—ÁëË'Ö¡-diëÀ4áƒkþè<{"¦n9Ó“(>wž&Í¥»òߦK{ØŸúãñC:5îÈ\MáCo3J€â·x´n&£ áïõ)¿ø‘«ê5ÅÒÍÐo;äÇÇvÅ“…Üâ쟹Ôy|iÇ`Uä 3lå<Â7­ì;K0@äœÝhO?a4E±™‡3Èœ…%£‚c2[]T \íœyÀÌÜ‰ß F¢ØyN`ÝSÒZåtö‚ö\G+šýcÞeá‰!7t_`¨ÚÊ´Oà¬Î§N÷Õ1gõb3D«Y·®y¤µÓΦX à7Ú5´„éIž'+ïòßC­%f„ÉPþZoñpd£®k{#áXd¸·§Ë zøªCâñK™Î2î’ ë5=Š`ivÏQîCĪòÒ&¾²©.ÐgЉø•>Ó¬7¶²a¯óñîÏä¿u¢¨Ú@’_¿Ímç³u_ÍÌ”Ùâ–l^ú¤°{ÔÍʽcÊùõ˜`/_^ÖÚy쉦XlÂKˆ…$7<ƒˆ• g˜MíN:gÅœ¡›[pþjc»7ÕÒ[úŠȼHÁW,:d,â$ȘÊc«^ê Ý@†K™±t¢›c¬0\©V&‚0Š>}54êÏÖöà)'úŸ"»™hC,AÓéÕÁH¾«gù6`QîÒ «"5|e=ÚÁMCïÑÔf–€Ñ X_\+=;,Kÿàêí²§»ÝÒóëžý”~iZ±Sx¤à®v¤c;Ý©f83$"u±ÿ=,*.½=—š–ç¶7+}¯’¸“s:¡¢z1$qV~Zv ”Ô˜uí1: [͇›áxø‘/¶Ì°vI Ÿ½–nÉ.Œ¢x¡B ]Šì ¦z•y$c¸ŸWÞ.=¡>¢§&gÐßAÊÝ`[æ&1=*ZnE;Û3šªO|$P¡JJÈè T?Þ·.;ßR9“`5¢È†ž¦ð“z”ïœù1Ê×b9ëö|+Q™&dmÀð¢×‰ÆÞ®oÛ íSISÆ=Ð^™è7ìÇo•Œ¢4õ}³10õi½û²ôƒöµRÈ_V9ˆ3£DgÊôRt·­Y³™Xó‰þŠpcU¬œ'"œj´Ñ+։Ƒ…•ÐÈH}íSvWK‡™Cé>-oˆIb¶šxg„Áe†ìùN´·thssYæ]ô¸1¿ºÈ´À�[­ ã7ÒŽ…î‘ÁÚþDÛ¸Úõž×‡žù@agæó�É!›ëp¥N+¥k!X=?s /m–ïEÅ ¸V>e´4]UAaŽ›æu=}T©Q•+Zo€[„Ë2öq ”ißÖWÏT zçõ²·Ïæ,Ú¨YnÜý¿ÿÏüFËv\}c¸Æô—>À-…kËœ$Ø^Ë û´é´T'® MâwòXà‹6<Ü[2î�1e*­' ˜s—‰âóÐmzJvþ›¡´K: Ó#çIÐùÝs?Ñ‘Ñ?~ú¿e‰P§’=%Ayô”-ÌDÚøé©"Î/|bË? i„c­ÀÀ�vVC«VM+¯øf†ó!ØÊg½Ñ+¯„jÐ 'M†x=‚¥<5#I˘!΃iG÷¢´ÎÚœ·z¦q¼Š¤´ÚaYÇ:l¬ØE .BñÃußÖ™E-7¥ÛùVeXhažéÝS¦@°b8õàíÈ£�’êŸ ²EâCxö‹5OoÖ.#„ÖÖ<êÌó¢COU¬ÜsŠ`³$A:Ôë¹2#_5ŽâÍoqr—ÖØ;ÛXaç@Ï ìÕIˆÝÍ5i“3ó"²îÞ"ùvZÈ­h¯¢´p¦³§=a{ "3„™_x"¤®¦PÓ6tD§3ãb–½ƒ6ø€mÞ«Hê0ôy·pFÀÄÓù‚1ãSÚè–ÏerÀz1™ŸšËYÕ+pˆÌú$ìpSÄÇhŒ”i�¸ÙéÝU,©½¸ËâÌkV²ïs+°—p™î ?p3¿A&ðnŠX’ÉE3økûª‡™‡Œöâ†Ï“ÆÎU Bn-ʢǀ¥u&ãµÞ[á•á ò¦ú�MŠwÛö€…M× TØøïk„Üs‹`†ÕòI¿­,6(ô½9ËqbïBïuÕ“Kb_‹ú î“Zšûû±WKÍÛ âa&‘gŽ8ÁH©ù�କSúöÏ[žkÓ ÛqŒ4£‚³ôåäå>´ç©/t1›' Šzkð=•µowÎ-WÃÜá‹ÄÇØÁ E©gÞ)x8ÊsQæDÉņ‘‡Þ„cí£ïžFZFÙVA“ÓÃœðTˆwª@Iu0AÙt7Q›>ÔŠŒþ§Rf³TÉy0@IE[U"äÖfRùo¡éÊU:0h TÍÉ£ÂÐçûâŠÙF¿jŸ¬Î –Řó4(»Ñë¡s9K¯ÙÝ—•¹Ú¬÷¸gœZéˆ{u^¾¡r%æýì÷Ɔƒº9„AiJŒ)æý`9e&�nC̈»ŸPvÍñÖÔWEâësAâòÊæ·g/º2ˆÍH¯`z‰ *¶ã¬ìöèg—+fÜAH*ÏL™ Ç¥d;í,OߎŒ´XÙú4ˆåÒkx€ÜÓeXFÛ¥ô p Ì!‡àYgåž�âÄ”¯^�¤ ÐYtžh”‚\]¥§zO‚}+§ÓòW˜2ÐïqŠÆÌÚâ®ÊsW±2_DÖ‘S–ôyÕƒñìSSªï·.zM¡¯’ŒI}G›¬êÔǹŒ1~E}ˆjDÄP(¾U±ð¹b™!˜èˆŽïOºâÚ?~¹`pÓbó…q°l)NœNÎO¹9ÖSkWíÛ®ƒnÎüÔ×¹j®i1ýÜyŒ›ú‚°³ë¯6ÿØ‹”‘yÝpØx ÔùeBÁ ¯¹¤„c¶n»è=3;—2ÏŽBÒ\ LŒ†¹ñ¢´«ûÖ áÆèuèჲ¿æËøv‘å?oEiMÑéTIY4^Å~guéwD=«$q_>a*ؼ« €íÈs ” ’û¾Ò4{ÔNW"G¬‚|üU;¥G†|J–ØŸw@…ÑöéþÎ >ª”²Sšô}ÜQ^Zí´¹†Žs3œ»ó‘S`½À�0äÁêÕ¾‘Ê|Éî!MV¥iÔ¿Ûé=maNyÜékõѱ/3÷ë˜F½2 (ZÇY‘ö¡í¦ÐI`,y|¬æ3c^Ĥ(ó´Æèl;~ÑùŸ×ªpÆã7S…ÒÁqáÅÊM‡FÛ ë7ÐCYOæÓl5¦ÌécÐ’8©8+Á]jgà>æ—öwTÞÑÀ=êÍ%§yv=Eî–)l—‚È"Mosx*·0mîdžÓôøZÕ“õV6’¥‚Þe'äph.“`˜€TÀ•E*$Ž 2¯Hוf¹ S’Æ oëßiÖEð±/@,`þ6©”å§Ûýdès·Tc;л°18í¸Ô·£Å's8@°3oÀ‚;ÓŽ(›Á+’�”êÒp…M­üzMY3dÖnˆ€î©¨†Ñ$’nÕ8£reÍNŽ•<¶b†S×RVO™ïh£Oÿ£Ájœ¤N&ZÍÒj­MCZüw%‘ÊŒ)©x€ýA‹>¬h$’ê”[lÕV½,A½AGÍbš<~wfzJ#×/Iµ¢žaYJûÞå¥6oûþÊM 3_G6ÁØï¯ÎËœ»ŸaP?ð›W@•>K¦ÚK´cN3o Éѱ7¥!>avÌjm®nK¥8÷©ØÞ–]P‹OEÕdhÅPàßBr‹{…l{C÷y/ïøª#ª•ç@A«sŠ ¸8Ýfg•=¶ƒ�ÙÄf‡wÃþkæ´×»|>‹Šb5“ÃÐãB‘îS3Œ<ØáT5‹~Ò�Oa‡ãT­Ë`À‰j6œ¨ƒƒ›síQå7w[©«¼0ñFl˜ÁñMvª/_Ÿ§Úâr³ËÒˆ>ÿ†QpÓÕ)‚|<Š=ÉRƒe!¤ª*¼°÷ÜÑu…ŸËä¹Ío¤×Ö}%UOÆOŠ«›=3Áe<HÀ'Z¤ã±•"gº¼Ÿ6YõWñפŒo³…MÞ¬yÌ 0*kßÜMAÚÕÍo‡ú‚¾ä`P@ï»7ÅÇí(PSV ¥¾‡?õìrr#œIõBÄÎß+æzáâb'¦#þW­™îª×=®(ã´üò d-™ —‚b8U`2°ï€ZÐÖnÔ阔ï<˜3=\EÑ8VbûAª& =#J¦RúOY·A±Ç\;±•´V•¾)»9pd"‰xëXaü[h–ù,H×´ ¬àoºùfRá{CÊçΔV3NF¶ÝÝ8(ÇO;õâ¦êŽnŒtøök6±úÆÎÊü!F}I9ª†@'§Ñ#߈NÅFRƒ“â4ö�̤Š•¢.„fçy}4W‘• ¼¨àB…sÿåØço ÂFA)”`™H´ iòOsý‡vÅ?øM¿ñ I2¯dbcÔe‚YíÙúùRÝ>²ñ“ºÆÓÛ`žÇi ý¯ÏÓñ¡ŸJtÙ5$>¿»Ÿ½x:`…æ¾w É”-È(D•ÔY§oš0'@ Ò¯Äúv˜­ÒO-ºìÇïÕO`Üù^ÝÎ'ͺ…~,ìÛõG#=S=þ,¼…ùJ€ Â\Âw~ñÀ «#‰7”cîÃ/:‰|jËùUÐGÇ#"©¡ éB_)]xv/"¿­Çypd­F>ôÜøïåæŽÁÿ: Ž•[i讀: xïZçésÁ–Çõêù˜¼nhË [§WtÇ7ÊÐfëcSña¼3sÂ�È'îÚg;×ÍÈ-#Ozh#,™c *Kã›fgz ïÞŒÖk ÒC„÷ǺIçW•% ¾‰>gònqyÆÌv>jS¹¥èÍå0AL£Å°?¼—ËŠ•¨ê(h«Œµ÷H%á¹ÇaŽZ…?(È<·# cóÁV—hÑž™PB¸>éÐuòesh’6àÞȪWAß&to&3›)¡ ‹-hi±ýž1æ ^}=qˆ'?òðv¼b Þ¥a ú€cCÈ’ƒRÓÓV¾>OÜ‹ìÆ™§*å cG¡r´ûÎw&ü»qJbUµTš}©õ()™aüTŒÔSPoù­5fÕÑѾUˆ†’õ‡§Ž(J%ÁѾx}¹ãa°r*"o)(­þTÞ)d®Ø§E ´fzòŠŠnb…DURfs s7ëƒÔ›f¿Ì\ðYa!#A'? ºÓ »ÌL ,h]UtÅㆎ¼a eYqL–¡¶#•g\·ÇîÐPŸ-™Ô‘J3ƒZ±CÙ‚‹wæ­¬mÌÇ{ö)ýeIGBªƒÝ¦l¹Ç<xiä6WãÈÌO‚¤‹äæU){î ©Þ ëYA›³ëó²ßÔÆ×ý°ç·¦IÃÕˆ‚>#؉˜È*(t”‘-ç´k…ÄM.vÜ|ðˆFÂìã k÷¼h¶�ê›ÇA>ª#+ëÚ⇕âAÉ×_V*©‡½FeÌCçÉË»ZJ{d¼*{s0ˆ>ÿ%üŸ²¼ñ lf…ýç­K¥x.Tÿ(2Â]r¼ìC’tWHä<�œp÷!ÁTŽƒÛê–ÆK›"ã¬C‹gBI™ys{J¢¹ùò©ªNtjrîÌó…Œ['¥Œuûªó\p.q÷˜­’ç‘2ÆèS)¶âÔ>/ç¡ödF¿.-Vr“¹1}²YtíøÎù)ÆPÈœcL險éß-L'fCÝyE†¸éÀþê[NÜÎáq5âHµëT|ýÌú:©Ï/Üê-ó¯0ŽnMnò—‡¨‘†h¯H´¶·g¼ó[Ï Ñj습O"+œ»9ÖP²ý•€óoU~ûvÎgY\¦½TA-‹ªb›æì9|±M3çuù³ë¥{Æ^äͲi 幜lî‰,ŠÍ£œTb4çl¼ŒúéÚÌëÎÛËvñ è oÃpð¡´ŽÇÏO´?ÈYÛ=Ÿ®gôp˜ù͘[´”Á¥“žfÝ°ÿ·FçÜ<zLÀ6ƒd˜"pc_o‹÷˜Åó#A ć6¶(x3 ^h…‘êL|u*[úszj»uaiZRËãäYój ©¹Ö¥gŠ˜MuãB¡3êÛwäé4ôîCÈæC”'O�ˆÀÆÕtgÚŽ>¯¢ÔÀf¬Ýß#LO$ǾI¦YB¬™Ñ?ë¬Q+< è]0zÔš«f?UÞø¶ò’Åt›c=þ鉻tœŽUöïžØNãÚ<¬µùúÅ;°£$óœ`)+jÒ<ˆÎv*lˆî�µƒ‹ w;£ðáPff€êccnyFq¶"rÄìßZÙ) m†årÄoÐÛEï ‚¹õøùÉÊ5­Íµ÷)s¿äAì S²ØÈÄ›ÁÓr|[è¿Õ UÈÊæ€Í6¬±ÄÚ]ò™‰eè¥ !¬ôzýÍPø\:ÌF=±¯‡íi¿ØŽ½Ò§Rpž±±3â‘aœIÛýÜïÎìj¯Ð  è𶦷×m×ú~<Â5@7<¡]hýêhâé@ê"\ã¿là•¥å‹`© :@7šÂ˜;«Ïƒ. ú}¼èŒ•æ#cÙÂmNãeƒYy<|ºÒêÂÊ®X¶J$ÀLÙ=ºXÍÖ¬‹¥hÎQ~ÛçA:[×qFݵ07ßãW¤û{f×ú%t¤06Õ ½(Û‹Oª¯œ»½µˆ’Ü÷íF{Œq®}k‹ýˆA‡N'ûæú™×@ÖzKÇXiÇÒè_ên¾nàŸ^\ b¿½x™…`½»KS@C9ù}²½€ÝUOŒ)^…aåŠ5B) ‹žÍ;—4_ø{ËÜ|­½dî(t È¡Wq÷mYq7*S ìs¤üÌ þO0;î±×™p`ÚëwÊÑÿä—‚a]ç²J ¢¿¯ 6k"ëã°<õEp^_âÉKF+Òo(Ų·[íÎåÇ1X  ¢AG÷àíoƯíeÁþ”ó„Zî 8ݨ٣�x¤)tÙ/cÇ¢ûÓÌòžÆFmÍ3‚¿@âßv¸ÍLEÍguoJcÕ‘Á9)ëGàŠÊ×U[Øæ‘1-`zn¯i#PÏ E_=ÊÄí€rŽµ>|{5²]FF²(å¨>~{°Kp½X5·çòw~\•‡#c‘ ª§S¶o²µã•«¼“¾ù óÃS7²îåïªé´4æ9‘±Î8š/n†Ò×´R0}Wü3PœÒ¿¬ÂR•á{¤ì誾�¬›U‹«³OËþF4È›ÎU|Ô.ôŽU¿˜; þçyÏdZF—ÙBéþÂÊ2ßq>[% ŠæSozˆ2¶URíaåž»’¡'^Ê8XJy«*UÔP“rTrr@{tõ€Wš®³©$^F:QæÚkìЄú•û¾avüô½ù;â8537õ2¡: (úÞ ßnà?ë2<Ù^º•€ù6ü”‰ŸЂìkúÖ÷É­Nÿ‹úIIXX € b,s›;±Â‹¸«Ê-ÊTþòC–+¤½’ 'ëÉ’2†*Ö7åbÂÓfI™ùÎ…Èú–öˆÙŠãäퟷ8Î;õU×Zô‘¿{0¢ƒž}„ŸÑ©Q]µƒ»ôŒàûVlÈ-3³›2ˆ;Ù‘¡;(Ù}þZ@ŒªÄ'’ÑÖäæ°]Þ˜ó[¸‰ùÈgyd¯™ŸÆkG#Zdb»SHD¡øF›zVW'¡÷Ký#�Ï:ýK4¡.ƒüSQY”n4ºBD‚Ò;ù•Åû¿–Æë½(ñDf@•Þf>Yh&Jì®·™óŽ×úšÑ!2í<pyHß)¨M·ùÀž¢‡m¨þêÑߌ¢ZœËRÌø‹ ´:Ì<mÛST1†hÓ²íBô9&Ìÿœ>H ]ƒ%5væ,hUÚGcÇqŠ8€Y¶Ø¢éÌ„|léœüRU®ô‚ÈàJEáM«dÕ,´Ê2©Ú¯êiX˜ðè ˜ñ5Å·2ôUŸèWÌ °‚¹YìzÖý%Ÿ…G?»¶ùt)FÿM=¥„i¯©2|.X SÜï踉fÕÖ× ;í Éâæ[¡¹suxã¤^…« ´üŒNäV¹îø‹)뤧ןçÍê#¡˜[¬>­Ô¾Íƒ¤þ2oZdf¸Íx£½HÅ(Çwµaàã7Ù8ó<»cÌp2ª+N­ó «2lÙÍ°H¯‚+ô ëý4™ðpôRöž›ÒΉE.‘nþ ‹våÎ_æôR=ôœJñ ­¾�|ö–<(¿>½$eô.;QøïºöÎ ¼4Ž{ àa¶ÉÈí€;X¡�K'ZZLÒæþ‰;æã°g¿ˆ{š“Ë SÊBÏ$D£›9(i>§þìϨ 2Nãng²?Œ-zÿï7gTf@‘™ySÛÑ“Š§w}l@,ïÁiQÉÀ¸Åef†Ú_zô§Qhä§Ã`ù,}ÏJžŽ£7šA³‚ц»à;‡UìˆÊ0ó?}Îñ1Â9/;C Š‡oT@Mýq†#q86ÊcX‡…ÝŒ e­Ê £ÓÇO¥sCÈ ZãÌm9tL“iýo¯«¸H€¥õÅ"kÎ[xÉ7èõÄSãš%PŒIÛi >–¡7<zð[!Sî±€Yû^„:ö©(pÉaõ¨0 r �\mÍ0éñåÝÉàÏݸ6Žiz7Rñ°¤wð™­?y¦éÌÍ£ ?eAÔ*¹¥©¯<_)ÒÊ8í—z0§^î•Ò#Ð!̵,ñŸmäP36Ø~yãJæóy‚âýÈN'}hyâÑ‚å™8ºþ«I´¦=­‚ZÕ¤¸¾´à'Üd�X›ó‡?öâOn@ › ÝõQ»}ø=;åì†G"vê¾ò;ŽtŒòéÓ]’•>•LH9i”ù?g®XÀÒOœ“Ìãž³7æ²…ÉËàÖúM=«zHï+ö5xÊ,ÒгæEëâ’é—¢ÔOûÁ€.5-K-¯æþïcyܧ‹E¸Ò*.q¿é†·jÄóàz²®kŒhjïÖ>Ú§pØ+W’¾˜MÐ-±YC,îÅ—ÑÛ'Ž&#Cpo^ñIsß”>¤­?Ðöy=ñM:P»±ÖÁ,±_¯À(TœolŒ[ø§£'º.}={ûÛ ¬Ž/ž³UzcŵٖɆw-°Î‰¢ÛB1mÜ¡¡®¯›šªP„ˆ«éSds73¥Ùd‰¬åÊTÏs£uïÇYιŸ8'‰ŽÁÔ’iŠ6'+= ­U‡Ú0½Ô‰Â-FáÔŒÛïLPÂðúÕöEP}jçI!÷—íÐŒEþMÇ\+ Ž Cî쉗*"´424—™ÊâSc|j¼–߬aÁ…ÓçùG¼R}ÁY&xª+åõ'«³ŠþI7ü¡3u?€¢–©¦í%ß“Z¬VveΤ‰%™ ÉJ+2Æ´ É1¸Þ²Í'ˆ»º:+Ÿh¶Ö¢ä"l­{MÕ"àºÅöÅâÄžòaEœƒ•Ê, ?+0>¤ÓÝ^þ¸EN¼ÂŠëfè-«†K NÌù¤9ž„ÖP[N¢dåȘÛ2ˆ[Ëâìîä]à†{å=7Ä¡»/B;i»§ïì$ƒNÓi‘~2¥ô˜®j]5]iIO)Is™“aèÑQ0ONW_5g…Lý:@bEþE1×Äzé[ÄP~¤·ÿT]—4Y§Œ>3_Ÿ»SØ·¯qZcb“Öª¥J5U]G°ñ¿¯˜³Þ¤¾ÞÀ6ó¸œe°°lñ" UI5ô9-–uy­¿{JÀþK$;¶Œ¸óÿ p¬r3©ˆûWób¥EélzÞ8'P•ë¦T73äÔŠg%cóLÍÆ_U;â`ÆFé®*‹ùì…ÿ–J+mX­ Þ¹Bz–ž [ Î ›|N64!è'<wÁv¿ØžâÜš6IB»@;aþ4q#1íJîRÒ­vŸöi‹o¿ó¨«²Êènz*6­ù�}&Ö‚Ò‡ñöÏ[aºË¢`LÃ^ë­YáFãiŽ”…e dŒ&§²¡³-¡UÐý% Éfì…9O›‘~ÇII§YJ7ÌVŸÞ€ÀM‘@˜ï ã_rŽgš¹Obg¾4%kµ¹$÷<í”e€ÿôÉ;>úNDeÚæSgMáÆF1çÔY‹¹ºU|!hÊ3ËÞ àŸªä•å³‹ŽÀñ+¬ÞZˆ€ëg297Å@áÃ¥·ÿ ‡­* ˆ‡,ðÍù´0¬Jà"g/ÈÓ™æÝpS-¹¤3ŽãN�󈩑­«aš;íÜŸ.q¸ù` &Š¥ïïžrÞæøo§¢_ÖcØ{µ¤¥ Ð “™¨âJ®­9(Ÿ¬Û ¼§³Ñlδ þìÿ@uö!fëi¹å!|˜ 8I‰‹–m&îõϪªa~CÛÕƒùBër²òpñ UÁ¨…ÖKê¤ÁEÈv¿­E0CÎ�I¿ù¦=ª]_T®Ò˜gT!^õL©û±n­#xâ[:­ïÌþ{l þ“KxžfχþÌÓ 9““<Ùíy *ñÒ¬«;Ef{awÅJaVÓ¼ƒ6˜%úDB6ƒô<QæŘÅ]Ý!fCŸû�IçTÑ¢‹QÁø‰Qsu‚ùÔŠ&Ìwí»ÔGqÝEú+*˜»•Ã»=!eDNïû6ž¼Z ÝÎÛª¦Uð©•½FS@˜w¨¬@ÓÆèzCMH'r°?мÕ26­^Qeâyšùypí<T¿Ð ÒÛô_ ɲt%ÎR_²´Säš©z?x~;‡îò.o}zŠÜM'ù¤Ûùôî‘ N] ?[éü7õe™^õcŒÖZ{±Êõ]}7Ç¥ý/Õ"§èÅîOÌVé±²zKò¤[Ÿg赘Å8¼[}Jj5PÈ€}‡@è¿ŽŸ7ÕÒŠÔ Øú?»~€WX„%Ðojú=ÅÇwéˆ&“5�†z÷ Ò²½°ìåBq'̈FÖþ‘åû»7­c»gàøžËE”ùsí0I7¦‚ÿ®*AoÆ ºä®íûÑ¡Z·ŸÑ)„9Ûà–—=Æ2µo{: ´•±& �ŒÏ`€¹ºgaÇ> kÊÎÄBìm‚äÿM”Œè§x­ÓfzbÚ•©Þâ¤oAsÑc%¬þfåÈ~¶¨Je§Ì˜„[‹Ó¯1-B|Níqe8JiÜåÃðNØf¡ÏâšDͶbÛŠû³­"[#›/pp¬l5büË v;—®Ígô.Ñëâäð¶›åŒ•DOgOÉ£yç5™©')(ÇÖw_‰¯0d,¿›ñ¢QóP_¥5iÓ ×쎬m²§dÊýb½x–8F±®ÜDS¨D½ªRf0:NUã9Š£dD†RDY/”G ùÔ»–õ9îÅc«oxw¯/¦–Î3-ü¬;Y£™"0Îë¢A7g†9Ä~Œôö‘LCßüˆ-"‡hß½99w(pÞMα޷žzvy÷$5°~¸%V¼ÙôqY¢×ž�O j²V­ætÐBíèÃZ…„4ŠÏÛ¥óÊ0O’þÑà÷™¯|˜"—âVMjY¥¼ü¶Àžeñ›ö?3šÍ™A¹æ†4ßþ#”SLYªe[Z0‰QÔÚïE5Û¶Óè‰Výç^Ï&a/¡CI; õê…Ýz ,ªò©¼ÂªzbQ’iG‰mÒÛ*’Ïû¹ÙµHõ  ó xQ2VüCæ¡WÔ$ ‘ãJõH²úY9¿8’Jp{R¶ tòThö®ÖÂPjGdzÔQ¯Ôû<Öm¥Ì¦ë«Å^ìîèQÎkÂÑNí ¶ ®º\sj±ÝÛvÚb„Ôé£wµÖ‰ÍV#˜ˆYçt*ç(bÑê-µŽñ¾·tK*S¼3°g]Ù©7:SPáBmÒ ß¼'Õ£-§æEòX°DiÔfVQèæ°më"È>u’œi´éëé8´³ñ™zEØ6‹}£Ï0§r‚2֬ѷŽa¸èœÁ®iéNŸJkãS?(6­Êü ¡œ£Ø )‚¯UQxÅ-&V,cùSÝW¤ƒf~Ú/¨Fhh2ÖîKŽ1Ó2]Ùó¶¶h¾(ëñÒ ñ3wèx´$§S½@_ ÍߎGIåPÈ"ÐrLƒjÒ¤²`¯0¿™,/*«ù'[“y‹l‹Ú2Oµ±-ˆÂ81 6ßáUªè¬Ñ…œÌapùCá#\>Íš†z6mä†6ŸÜì˪zŽ}ûÝMæ”ġߧ˜ˆíSŒÊ¦�ÛÊhk÷Ç‹¬ÿ´q¬]A¾çÇ„wí¡Â1ÒñÂ…ž{ž©¨Ó£¯Faå8<ã§2Ȭ?+U0GRm•è)ͳè­q Í®•Û›$õåŽc–;¦?ºq̓; ùÊ?|<{ñ\^,ò]uxÄq‚Ž«ÕC±=Õ;ºyfqüʉ+wÂrWš¦ª¹ñ‰p/Š|»ôr_7ÃÊíGÊÜY@Jï÷yÇØeaºiWÑ¢­ò- wPªs\Õ^Å?ñü–â^+¤D-Ý•—ÎÅ*7=v¸ÿ[­ÃÀ æ�{t«µÚ[C Ù&—÷\Ç Ñ‹²W´W*Z¿¾<,Ðz–w%Ì{×O´ÄóÊá/Ö9ÛBÜCQt°Ñ 5<òá þH»…ÁnÏU¸3=Òr“0RxLƒÜVÚ€NŽÝ0ÛŠå |°¼ n¸»úV57µü0Ã/æ}öÒh±Ÿ9Ò?2SÉïj<W;Š´j,S¤§F &æ}ìÔßk7ÑGÃoùFóÍâ6gf¹™(ƒ§¿ˆ63§Ï¶+�>Rm £´£¯÷Ãá4óZÓôáxÛ÷‹ÙMèÙòùe[ /X!¯ÚSìÿ¶£#!ÿÚ:º&OCͨÜl'ÚŸTqãü%ht«*5B²ýêÝk…œæ/(æ>Z8±vŸ ¾¢¢ýû'u H³™¼^Ì m™$¿qHagA« W þP–´¥ÝÔó$YÿÑ–Ÿ W^4ÝÀyêÉjê)›x?³ ÿ É®ëHÝ8çKuð‹†eT(ð§¨Ü^7Ѻÿ ¿—F™/]jx3PÒ¥çtã×îÙ[pöýÅ(ÌLEWpe”%5£Slµj 1Ð:å­>o>8YD÷=â°uŒ°°¦l…äƒU"=ìd ºêkÈÿÉÂc…T©Š]ijÕVüfFøZË\ôNÍA[`À¹ŒT7Æï;wgäì\l ‚–¦™Ìb:¦¯ÊÌœH hÈ£èòb±j8¢2õ¿6[#ªHî1"­Ãw'°ÜðÇÞ‰¢à­ ý(=!�Ïïº=5ÿ’0Z©ÁEÁp6°ñÎ*’ºâ#“[cØÆo3Ó2ˆÎ¶…ÇfC_»þ<UTÀ'—üWp�ZÙºOÅ^]ïV{ƒ¢™1Haì.]‰BÞL2æfo2ÏVÚfØKŒ™}�uJk³2û ~lû,HVÓ8BækÝĽ٣†¬¤ Ž_<Eóò¸ÏŸ­š$•Ø»Vµ…”®A{JÅðŠÇkVy:n<­k&º5…fC]hG›P† T;¶Æ9vxRO')™:ªs§¹G¬‚³t˜‰ôÿ2ŽIÞ™öq™«oxQmÔìçÆ°ÿá$U76zYÁíxùg?þ³=‹FïýO´fŠ<c÷Èd è&ïÎKÏVãg¨Ý@ƒw8³ëÒ®k®œ@¢Üe—1P»˜U_Œ’†ÓôÀ}z4?~>Iμɷé×…AÑwOÊÓŒ¶›lN#j¼þæ&À[ÁBKKãzçß³ãW3‰!4ª]$n/U<qäØcòx—BfÅ«¦¦Ëá᜺š'—Ã~»íþ’L‰fˆ%ø‰ WËÝ ¦p<0à\;ÚA <<EŸ'qäÚJ7´;Â^J Â …•ø®Í¡²™ÆÛ)¡’ÆÖë'9_o9X¹ IÏWØbÖ¼¿Ž-_¬Å)<ÏÖ½½sú˜“®üí~z3¤#(Ï‹^ þÀYÕˆeȃQ«ïh”#;æ™n~~÷Æ–è³]ߨn5•ò_NuãÄW§£pFn£[b(?Øð“) xGƒ-À3l¤êpö®,nƃ²F øØôó¢n÷Ü6ÙÏج“ÏsÍ~™Pظ74°ãÀ‰Ù ¼!‹ÖºI0AÑèQȧÕh ~ñ;ÊÝW8ëý¬½Ãû8­&Ù¦FÌ“Ž?wrºG”køŒ¥Ë~šêA_V ñ߳̕ܗ^“>öM§´Ø®œ$ ìÔ&;» ½Ùu–o4%óÒ% ¢Î~GÇɲx<I‘¿‘[ ²£ÐE7ƒ{òÈ0Qøy$§Oƒá‚Ò0·Úô3þÊÀ# W&hÛ >žÐ‹™‹(uè|Ò€ÛcNùPZÇ%ש9^_ô¶QÛ[Ut|Üiü‰Cuµ?Ó¼“5 œ’즦›l¯…€¾ÒÄ’à¦{¥by?|Ñ.<m0.Ê6[Z'¹¥íBýŠ¢Ô~¶øÕçíu¸X1)p>ó,ÈvŸVçWö‰ U}ÍXx5 f›ISÖËç}'N¼‰Z»¤ âùÉëY½?VÑÇ#è8pË‹#{zóX†_ÚBš§ ½jßñöVdñ™Øbš¼«0½*zbA¹Ìž7#z>[øΉW ¥)]+f<Hýïg‘ÑZ¡°ÞžKWËÈr‘éÝ>ȇFþÏ›)äßöúÿ¢–Q <¬¤ì­V”'׈klá>ÔŠY‡ ™— y¦,~[û@ ðŒaè?°<cO·§Ohvå­ZGŒT¯YOðí®%ØCiú¬Vxcvª¯Ü¾1B/}Çpã²…‚ûØîOþεÄE. ñ– ­×ëì3 N–·•~(œò­†Š'ú’ñ¡ÊƦÞU U�ø}¤q0›¥:¼á7Xþø?Láýg¸º;äq®–S5Ø€8O¢z9`|©zò´G“©¼ºQY=u”J–Û»måÍÎ"¦,§ r»•*«3Ý7)±ó~M£.3"h{òô°Ì”Ï)‚U·¯€žÏ÷w!wÈ29ÅÇçMçKuæÔ±u±YèýyóÁP,Ïõà;á†8ôMu)¤ƒ1d=‡òn"g¶ç/Ýâ¤ô)d€·¢£³Sˆ¦ŒúÐ0ØÐ ô¯xQšøŠYhMô@§‹§t‰Ë‚Ö„”Íú:t—ýüðˆT+ÊÍA¿@µÁN¬’Œ6Bb°%¥äW躣.RÛ‹rYafé©šàH™Ÿ¶ãÔ»qÿ%o¯5Oú±/ôf}ev'Ÿ—˜Eä#‹³J2: úoNåŠFéò¥ ¢F¹Š ‚«¾?m(#9a– wÊ0WœEMÇk=øŒñ*óõuÙÀ& ²Vaxô ¥^üþž¥ö…»-‡7p.)–ý€¶P|¯�mM~F•j°Ëx‰ÿ"݉’µ¨JAÚ±O(&¹ópûÐÕÆ ‰ÁG'‰uq9[;<uÒQúZÑ»îMJ×Y—Û˜è)´E´Î ×ÜqiEKl4ê~“äCxÜÀÝêÇyìC&è„ýXDüA3’@zèÂ1²ê“<4},Fù¢B¥ÊG ‡ËãÔ§þõŒ¥ÎÖ~¹,IÀ¾8ñ¥dåÓLßZ÷Ÿ(6Z1\}â¿” ù×Çpl%‚rctÑЙ“}ªþ÷ßAä8å,®¾ÐRãûy÷ýÏJ¡8V°¤« z-%¼™‹£¯³ŽþA•<Í©|¯Š’y»IÝ‚iåy¬“D Q7 øo|ûªÂs¤Q8æ,\âLÐ ¢Jÿ`™dC<{µ²Z™c"*iÕ¾;üûfªß£Ù·íy8õ÷Áð5ßj%b$üŸ8Èš“ƒGãöä?·Ý*Ó¤µ·+©H2h&èé—¶ƒ#b#éÏÒOBaôFçü`_A¥…GdY¨î ÙÅöÝüBñœfVÔVuŠ}û!UyƒcvËnjʾ¾ìš4ò¸BÀ×> ¯÷)tœ®ä Fµ†´ÈÅEZ=ôžÍurvöÿv³}¥BŸ„“‡~•'Ƈ۪”A;(œãÿy+rŽù­w†ÙŠCI[i ÓÎNýPŸ¬1A=à(>zWßJ§ÑˆÕRÎL‡Dki[‰}˜½ÊðÊ »ëZI|K1H<ËoÌ|x=þ*gš˜²hë>Ëh#ñ]òÚ¦®»*²Š5°jO~ê5˜¸˜ Á8)º3Ò„o[}À7ã¦çc§Ì[æÈ�2ºû”\ôïVk’3¨ßêÁœŸœ»YÂøÏ �kÒÄc¸ M°C±'@ïbçgòñd[oWZ¼©€¹;_ö1Ëü�3ç“'¥,,NÅšb°Oì’#‚zî7ÇÓ=D4wÉ8ƒ^f(+ç½RêAè³–• Ö¡a±Û“Vܪû<IOÂÌkIRm×´²ÎMÓÏ“°H‹ÞFk¦X¸Œì{\‰uè1Sz ³ 7xp ÊGþ¦™ø×2‡ñJlœÂÓ�1˪ÖéNßÕC½ö e/-ð7~Â&¥ží³&»/öGÓ6nòÒ�ò,?úý°¥RƒEe¼KI2בÚj×Äòü!JDجšœ]8_Uë5ZK”ÄZPߪ­,™¹³´LeZã„ ?SÓíG‡ Í¶;O´@ÙîêóÌqô—f’gÞÁCM>§Ìgçq}¨¤6]]µ·x.!ð‡P;,1&-9”‹² jì/‡zÙ�¥£ýÁ6eéé msö7ïŽf‹gw̪óìÓøYߊŒ¼m÷Û“sC%xÊ(( ŸEÆvSYŒºAvS= -H>?ïú¼ ¨ªò f6ì™ôå©ëT¼öÜ­`U[Éðåqa1wÖ¸e 0.!¤Ç•táÝå GÁCÈDU+¢#Ç”{Bºt}TBüÜå_ sÜÔyPΚæs‹M�ó¹1Œó¼K´©‘¤qvŸê8¸gnìZ6˜ö¥ÓÙ[Ò2üµWÕúº@š–S?¥xbr’<M;&‹¼bZ§œÿQàÕ~ü8u|³wÝäÀÁM§!éæ[ÏùBœ 1€ë(¨;ß%ôGvâ±/mÏûO„ˆ–1©‚´Uü'NþY¦ÝÆ}¡é¾P›"Ág3à#ê·•ò¸‚‡’»˜PÖ΄’V[‡ÄRsàßOæH¤ò!KY{Tx]G Ó»õ@ò›i\®Œ˜³à²­üÚ›¨1lOF>$#¢t‹—%ƒ”Û¯‡;dl”ùx[VV¡ß2{´GŒôÌZA:åFF%Ì|^æ ]d_“KñÞΓ“Éùô9…ÿ#j$ÎW®](’ç,(­ì@‰xg3ÌSj|QË¢¿"S@4€bŵEÊ“®(8SvÉ :ÝXƒFßóù¥[¤NlŽÁĆÁ߬¶Œ¶°’…‘5£Ãd¨÷“Û}¿DÊEqê·QBh7SqÝ}yškôßhø¾ìA|Õtïø— /­„¹øì¡´³«Õ´;Ž @Ᶎʤ#qèv®B¢ã;lh2>Œè!§™¡2§F&"ˆv_ ø“o""ã~‘UíG¹Ä]äö‘ÐfcéÎek…×(¡Í‡9÷¿7߶ÝËÄðò†:FX­çæåÜî†øME,ªuf³È ‚’»zJ~I|9Ãô¦vnJçJxÔÂ{Ñ®¦KgˆzaÆ‹“˜ :‰“tõGÐé¹?Q@)ÆÞõI›ýÄà }îGÛ ôÌw\Çó1t0Fz¿V{ãèÚDV’}Þ¾>È]*†Ç†$YöÚ4>²?¹íf›7ˆ=‹ ñ¦_ŸhøXƒ…PHoè˜PðŽÏÖ­%]»ð™êa;Qö`¾>È'|JCh7Ñûâ!•Ñ*n|_ôa¾†¹‰JÍ´*ÞPEpª œt¶›Bö²?SåW~EŠ}¾t… ¿ µÕã Êa|Z±èº™ÒÞ”ub/ÌÈÆYØÉõ¿ÎX±–*˜úbÓUR6õ‡ð(›>Þ Bl°¢þU߹㙕�<¨QAkö<ÎìoÇ?ˆ½…N|=Rtü¡B½=7–¾3å·aÑÁ¢éj_p[üÄõªRú†8ÀØÁc2m¬ÙT!MXË}>Bò“‹¾GWžöon| £DíÎwôÁ—ÎâØwqÇ,¤g‡}û>�F>ð>gì$òmç•@ÐÍä®’Å×P&»7Û¯ï$n}ç„ísÿ‚4@¥;¢lÇU*¦ïv 嶓 ,f.Dkõh„)ïa¬6 ªÿ\3¦PíUR 2}¨CóÊfà ¤PâÿzÞZFNƒ5Õ.µƒ'Æ¢¢)nJ03gÛãK_ T{t—mN ¡ÖX‘ØìZ/Rk5y¯ç©f¯Ö9ULYD›TO´¹ØŸÝœÏò-2Òö.™§{Æ°Ì‚ØL…'gŽáépÛþ<ÍŠî°ÔW!C?å^Y¸ƒ† ‚×þ¯]–´.Ûý<Õ°TDÊpE"ì¾*ª÷ΚW„¥„CË Ó?úÀ×g9¾�k¬YÚ} IpYÝÏÀMÃLß*3¢:çƒðÐZóñ{±ÇÈ…lQ[†ªxŸBåäwPtžê–Ÿ³{Ÿƒ$ã¸\ÙÞSÆ[§Aj¡Il,r[I`€$¦óO?3*,nõÞf¢Qž¯£©oìF¯æfI2qöÀ‘þKðFV®‚y4àßÔ­'tÿgßX9…+¾Ã¯|p sEPöê™Îlëi¿ÐÎ0‰ÎJD¿ùÀ3î·uë·ß‰R´Õ*ˆàÂGOv\ˆ®IsµÎ»h«q4BAï•eÈÑuØp_«Õl¡hô[”ä¦Ã—§>Ê2 Z›3äº1iéÒP|9|ÐÃnmpGèÁ¨[9Wg5³˜ýæž9é\Ï,¨Òòì>Rœˆ7cøµyèiŒdèðàˆÜ*ž3¾ëÀ¯‘´èe#s«¤È혲×EÂn±Ž½Çtîz!W¤ôV¤Ž(~“Ä÷¸©7ø©ðàǎʵÏ/G6έnp‰Fÿ§n(±"Ãl.E²œQ>ûîqÁ èÓ´:è b&¾>šž{kÂ4ÊwwXyÜpêèØ€ìmÆÙ@UûÆP.йºëð•¡?À¡wfZÉ»×_?¡ïK·ÌXßXí×h%©AÎD66 ¬túRw¶öÛ“”IVk°gQ‹¸yUU~oQµ Nµ¯^~!7„»å_A› F0óáî{3Ü2ÓV›Uîüf™Ð¶ß×V(Bh¸:¾ ì댔ø‹ŠcQ”®-øÅÐ{OW˜F�wª4ûÿ¦•Î´SêÝ9¥G=Y„erûy/Ð%ˆq.ã]QؤsË \ºG?€C¯‹ñ aŸzzÆï 3L�cš¸‘;û0¬ñl -S×2h©±NY†@u0ªhõùK� SÚV<Çtù„…2ªûS³S8• ¯;EG¢‡+Ó°Pºœ® žÈ˜¡À!Ÿú~‚yÝ«Æi|#ŽÚŽô+¾SøbÂj£_“Ú“ô¦�£ÀÑ9Ï3‰¨mž]V+pùyñŒ89ìQcüõ3ŽÒµ| )ÜkKŠEÐÄ‘,îõ\_ªÞ“ÌïŠ"4Qá‘½Ç £Ò|6�ëAû"ðåDÜ*cšÝôl7vaJRWÆÿ¼¥ 8’ùi¿Ú´ò‹œ2†iФvÖ˜s3¹ÞYoDÛ×ï,à’bu˜Ûçìì¨þŒRç•'Mõÿ’ Eüº0ÓMt¿<ÆžŠ"m–ýaVKß_ 6YÀáÁ2JPË íÕ±TL¼¦ïšü8ñäM„w6Å0‘@Ž>.òj»_í9cñ_Wgc”V®¡ÄdcÈ*&b'Ø2ý~—Ûý¨™Xdázµ?Ñ =²Fµ¤§H @4¨(”„\)ö_3´„8ò¶9Ò‡Ö‘’¤Ñ¤Ì ˆÈVÂñt؉f¼Ñw›©ªìíës|PbB¯ÁÑ  Oi�ÌÍùħ‡GúUPIýÖ„þéþAJ]gQy©c9ƒÊâò 2çQ¶ѦÞQoW‘õîk¬¦ý‰í)N"á1Ùîž\™ãØpÆ÷1ø ”EÍ'ï¦#îà=ñkþßÿg~®ãøü“º ÂïFÊnˆŽqŽöaµâùÐÃbJ‚­ê_ê:ÔCjü(.P|j¬•RjD¬à¬X†àyõÕ ‚|¹¡r:ì`Ä¢V} õñÚ30ÞuÌÇR‘ó=ýÇêQùšMrì ð(h³M)r†-˜^½5 ÍQõåel+xQÒ-ñnv¸Ê¦¾r+‘ge¡ûª“n˜ùöÃô æ+Ý6ØËÆ–j' '*0(WX òy p—sÈOûárÍWão¢3ñbè˜3£=btµ.õ@©ŸÐ›¥}ø“Œi9I;‹Ë¬ãWZÙgãÚ»£¸(€¶§ÕÊO­¬(JÅG�0bOÙ;"r’$B4h _z±[F„&h#ë!-ïV@Y:æíú§4à`ë-ïúûŽ_”8’-N�€³ ˜f²¾¥ƒßƒþKM¤,q ôu$ìÕÿšáV%'¨«ùV¬"@³C¼ «ê¦›y™iGØôgòÒq5iÁ?˜Ù[u¨A2¤…Ðk/á˜ÖJ*¼9¿&ÆŠ{Øê„:–ÿóV˜\1³s¾¿Ã=¤ÊLˆØŪ¥cÄö$f˜÷á$'-©A=Kè'žqgÞ7ŽƒsÁȧOÉge2:5ëëk7kñ›Å+1[¨ éØŠmÍ£0°Ža{¦,i´0T¬Ñ¥[‰oéìad—Oo C¿ ²(øM§Öè“@ p{žPÍìk¼óZèqHÚ'¨ÑU#ÀoK‹ x% ½û, t’Í¢HÜlÕ—aQÉ!/’E˜/²#”Žç+‹a˜ŽÍžN€dŠñÃ8Ð6aŒ²HyŶ‰éQ8ØŠg—Œ­¶»¸Gÿe..s€vá8iÚ18aëI+!ðA1wˆpë6}åué¹…î]ZŸøã:»ÿ_w™¯ªh’qo<±½ð•ËO4¾@o^æƒîÊ…²Z jsË‚nÒI‰3Ýô ’<¾Ÿl€ßa“>¿Ü¹HãNÂþ<ÓÖzW`40�ÜHå[.2{o¦MvV߭øÝ̭󨀊òþžÑþ}÷›œ˜Ñ–:Ç_Ҳ̵9Ùžl³`l:4^áMsºQ®ÛÎ~½ŸæÕ5 4Ôç8Î}z-°ãDO·˜z–MuÏ¿5ò kpDwD!"ßJ¨Æ>𢔷§l¤­Í»ÃÁx_{Bf°}™<iNpþ5–×&!C¨³:1¤ð©·§ùëº×ˆu>÷ȦN‚ª9yC.!i2RÉZSÜûvÜxD7î‡t¤oé/j/ž‹8K ½­¶7~>.J«#~(’eë ™S}åÓe•ù¿XX˸°4„±ÍŸGŽr\­øGŽÎu'jTf4zá.ÆóÈjð2÷ןÞpõ¬RPf 3P¥“‡Ù%âÔð{«K+ÖËU1k“ÍT ÝVí…+¡ÿsKÏ8]rSãŸù|ê¦õÔ=øÉO®´YaÇ"kŦæñ»Åbl­¬<ÔWœÍSO&ÅÁÔ´´ˆ†O«åCó „£!faŠjèÈ/*USlÉÜÊ•Ùo[ÓÉ…ße20À ð_0}Ïgª!â>“§°:0aaÚg—–Þ;uXI„Z:\ÇI=¼_,‰+O<S $yÎ; Ú?Î_²¦“±¡ëP´çì/ˆÒèË7{ñ/x‰™kÙ‘wzdýä!ìÐP O�~É^[ JR¾i1ï½Ó’ V‹ªÞ‰6•œzÓµãVê=«Ô«Ö¸Ð¼üI‚²¿êTˆqµèTjÄû{-rZè‰ý} ÷n‹0(ß­$~h =;D?|t¬¿{j^rÏóÞ둶XjÅ€¢™‘r†”êøó´YX›zëݶ§ÿ`h[ª£&&8ÀatZU\PMXÝ …žùqòâêäÎ,Cíà–/Ä'Ólzë¥øä_¸“V¿4JKç“#¨l@e?J,E¾p$Ã(†3%×_µã/PˆwÂÏ÷" V Ô ˆ‚'éÒ*¨Z_î™5-…à,ÁÊS7àüÖ­i¿/+ÉÂX½S‚8Ð!Xk ƒiõØ="þöèÅ׬*MÞ>è¯>µê²Ž¼ xë¡ŽÊí±ÚVäõ£bó)—Ï$ˆHžº]M9¯Ÿ3Ó*^Ž˜^Z4îw ³ôÏàÓšßµ87mB:Ké¿ëo©�èöO؉ÞÜɬ¬9ó=‚Ê #±¾áÇaV¦txœnL@®?fëú×heÉW~ûŽw²3¨Ü=…ÃÓ+²g]Äþ èRy,]q:{P}å^”éUÜeDUxQ6c)ª`·œø*z˜ºªŸûíÛ+ýå“EÊb×òrúö°bƒÏíƒ+ÏÉÆL¹0̃l|÷Ü´Ñm1«ä—C‚¬ð“z°Í€¹(¦ÚÛ¬…Û¦ ·v$n_ýE\ÝH•³¿Ò»Çög¿ÐgÞJr´²Z¢wykeÚW“—Lˆuî…ÿµz¬‡ö;K±È~xËB<'@C>ûlAp鬀�²$~«&òÍ·ä^5šLäH‚Í6§lv«x™"–eŒ)!CÍXÏôÊÛE»)T¤Q´«Ç'?EáR®IŠ— uåçÕ©WwK<™qœ¼‹ËuÓ‹nÆqºšÅœ7M3Âùw=?"JLŠ'¤'r-t3R7œ [Gæƒˈ£FY(v ooûú²_$>x²R¡„§Þ¥C}Ýʉ+]Í�ã[á4@Œ?ݼ¾¬Ê<ƒRXÒ&iô:Ä×Yµ8XûÈ2¬sĨÇÅ ¯Ÿ„ÙL‰UöÃ=£¿_—þ+†?•ÃQ %D ½¢l'yPõãpºÚš•äBÖŠ/RÖ™ñOÿ„?geL®C91i3=a’þ~îwg�[îý­Œíù]«|¥3RPqWP:{ÔÄéx2ZèžSæ/8lQ®ÃÛÂd@G¨‘Ƴ(è‹í—9®Tµh1„6g+öâ‰__äá®±¥Czè¼ìxïwOƒ“–¢Lúž{äYæ;k'èËΗ†ì¾|xÉ+qÞ2ED:� ®Oúë£n«¡­¾Á$àÉq2Ñ4Ç…>-e-ê¼b˜ö‰§zƒÂia¤6 êȖª6]±¢åësÕÔØ7æJ§?Q W_̲Ãñ3kEh&8E ü*†=@Lï�OõŽî·‹Ûzðºu™­+f¤wÁ¹É‚ÜZÌæL&Øào0™7ǵã°P¸Š³&à%bt4š·Éi2.T›£|éÛ™ÿLü’è™ Ý2?HAµÝ&žtRo¶%Mƒ¯äÓtd8u㉲îýÔw´únÜ»ö¹®¥P-à¢ëQÙäkþaDv¼°²)=¦Ó!µŸ`‚KËOSª s¥—%»î}gó(Sö“Jíb&±9áx,®yeNjTÂ÷':9–/›ÎÕàß¡¯¡X˜3Uˆñ)§î¢âÛß`Lœî§`z Z‘@_u_¾VÝ‘…Šldž‹V:®y ³úF_îÆ•ÃËpQ*âÛÿ)hÎÜ¥Žeö¨”oRߎÖ,U¶2ÕÅåäIbC¹³ó{¬Æâo øõ™9&ï­KDÇlsÖR#R6Ùfª/'nD·4¨³æ”QQ¹?K*&‰œ.«´2 J`Ï0ªø´xF+½k®o43ÿ½êtG ¬æ<ÛF5þBÜ& DDT”å¸[dë*ø× àZ‘í~·__ÂÕ“ß)‘JÓe«½˜aä°xp ìƒé©Ú‹M¿_MÝ„&®2ßǦ0 ã×&€¦ŒêÉü®=œ¦+ž=pB=Ü„åÖœÃM¾ãœ½L>S$® âã«�›vÁ~q ‚«þ—œ¹Pú;YÁÞ6TÙ¥»ŠÇ…l .…­ôQä› ‘9Šyy¬Ïg¾ 6Æ姂êüÞ o ôŸ\ Ûζ#玵C=«Zà|÷†äMÏ£ØÓYAýH±t_?¥X:Ì4¢cš¼Þ:ðÄq’yäd6j¡Ãh´f9PæõÆúZÿOÙÉþ¾JqSÊ4y¼”/,ס¶Y…�›~ fÊ=a•Tú©°*ÕN@&Õ,ãfÖÿß7Smmf"/+a P;?Sl%Òˆh¡à£¿’~|H,Æ.–N¦ÓðDüÈæM¡R3šNuú'Á³ÔêQÌ\„Úã`¦xƒ¼CE:u=µž/€,ê@ƒŠ‚;ÕQÈ;RšÆ‚Ї™ÈwQ¾>´Ý”@™Ç¾3m¾KôD½j*˜$Ä}Í“š?¤f“@ýuëõ÷ÚÑr×">t%-t=õ“Š×9ÓB jÈt¿õ¯ }†­ðÓ@‘Ä Ÿ•‚·MËh~Õ.²pçHMLvÔ;Ô÷ˆ>¶z¡#“`  {v<‘‡—÷µZO0VドÿíFf[&ôÌ êxq‡ãÈŸ[Þxý¨¨+»‡ ‘=Hí< iiÝRúä³r_EŠå©ës\l¨VÐ(pÚ‰´Bgˆó¡<¾ êßÅö¢¼Qîl€`|”TQ2<v#™¨À­~­’î,`²ló ëΞ’1÷Á˜3¶äîó“ò3*WŽëaF‡-݉‹‚Ê÷›Ž 7ùÖ}e‘žV™cÒ£<�::¼k5ìèLèú‚Í„sC‚” ;W]˜Ÿjs/ï_ÕA àtö<Þ©><¶J™¹qÚ¾ëÄj5Àõ´8dÃJc½Û431AˆòœÓ´?N†€þ_¤5žQ"ú$Á<Ó¾ê¬ÃÜNµ¥wƒšùé{•\’îRºBŠqàþë KÏʨ¯\“p<¸âžçƒÂ&_ùþ0fï§Q™ÙL.`$»™Íx…Gýk9ûž S¥áJ`•½ü ª;'E`ôNÅ,¼§ë¬«Pÿëº)jW–ˆ³sIA5½êFVñÔýÒní¹K iªëf8/'(>º¢@ ‘^Ðhå=  6Óqf÷ðWzAQ¨±˜Î ᫽zèj¶ogF•u¼¡|É3xÀˆ¹%äÎMJ(‹ó�GëwÇÍÌ©ØÏ"£c±üI·ßÊ©Žµ5?,=ØlŠ? Le«h38©}p?wÛùAf©È¾—;º»3ÌLÞUÂ.ÁS8QaÁH#™ Ð}ÒÊýJƒÖ ¹Ø¹’Œð]èy~ê´gÍåÅ‘ÑZ[ÃßBCýü‚+SÐî² Üù½U9d‰Òg=®ÐátÛÛA ¢5`¦x¹® *Ûbú-”2wÎ&$èˈ&{qˆ3²¦–"Æå{Ñï<¥ p0<5÷…!ŒöW¥{Zx(œý0K‚hÛšª­-*™;í0V™ÉíØä¹5Xès¡š? ÞÊĬ¾Ö˜óûƒ?O}|8¢ÍŒˆíÇù\pÎ+}¶¶%ôüd§ÐVÝ”í&ÃNm?Õ{Ýá"Ä:ˆ3lú*ºü¯xOF*Ë%ä¸H÷9…Ò®öà›PFY,$-ªñH[£ZE~¾Nèƒ7ªBC¨ãò‡�ˆo˜CJÊ"€°8dÃívÛQº4Þ*^«õ¤Y³¬i�;7ž„“A².Tð¨\ãyYüz´;Ì6=¨ãÄ—O‰mw~>&µàK~KnÉKÂ{yÓ¨·'obÂÁP£Å37nÊËýDD?:EhEp¸:£œSå²Z^¸Ðζ§kŒÆ/Eq3µµYQFyM¢1*ÊÕÓz@§òÝÉöc¾pfT»GÛìkÃÛ¶´ !^îþ္rÈBÔ°¸?½ŠUôÌ"ÜXîWU ~$Uxæå ]Üï’ š8#¥ê¾XÖÜãS÷³]#TŠü†*ºÅ#œÍ³ù_T²bèqd<2vC¤Vœ,³tv=9>0^áÌû…=JŽË̽èû÷Ï‹Ø{¢µ¨(¥tfòíÄË´Í:(“èÌûš c®ÊºØ´; 8>€wði£{[Y4p6ëÑÁiEÇi6î¼›ó0¥d|`¤¾8EX$ïS22U~ëY, 6 _÷±F‰=¢*ÖúpöjIõî»×p’†m¢�îw<<ÒB­RKá ò 4˜³PO7±“,Cþ“-7˜Ã˜ÐõtoºÇ¾3oÛÓá“×XtbÛŠ77|3CŒ¹Ì0¼ø•hdÜzø‡o·-‘ún°ŸEqÍ›¨sGæÖÜUj %® |öIœ-”5´¡t•XÉŠ09' ®T®oæÓ®¿c1º²È1.1’ šáLËa„®å²{&üà¬ý›NÏe;öW3‘Dµ5ìÀ÷cÁè{VtÆì9ëîÿÊâ&ƒ…­#Ì”ò ýj] ÎÂ(²›hƒ›¯Kž�åp~Å›�$ðçÍœ0æ<þÏ~³i•ÛÌCÒ .O¾3ÅãöÈrÃI1ȲúRJ׬˜Ûtª/t`Ôç÷ 2 %•ñ,›P"#[>K÷¶è¬`æ¡Ña:É|Iûßú‰°:2Ê•ßcf¹‡Úzâ‡÷ªÔ Ånƒ›mžɸsŠ¥2êÕÅq¢ÌŠß�"Ê%S2V•8QnSv^éÀ+Põè*ñÁô‹ž‚K!3Ó˜™)¤ohdÆ;9$Ÿß1þ曵V˜XûfÉNd”¾FŸ¼ZŸg'ÀBQûŒv‰ˆJÞ ýgÖª2ŽAó™=i£ª´a^ž¦A<X䃌×÷¸e <üqä‰WæÐmæÄùF<ÐS _Uëó`Š|†Ñü7’%ÖÒXëV€u¹}þãÃQÿÙS™eª!Ú³¬Ôúì•NØ 90¥…2Íð¢m±ž>¤þw+ŠoBy¹šLceA¨œüž¨ð®E IaôeüºÝ²Ž¤ò*ƒËn¼[±œ0ðJ·7«lªY8Ö»›Ù¬EÜec6n­ZMZÄ9]«�aÏtÿ7ÿÒ2i˜­äça2˜D¾£8˜˜’ªß4X 5çã´ôû|ÜÙ€Øò»Wš6ç/›ÞÉ,ÿ¤·œ$I賊` ˜ÝêhƒÞߣtê±Ä°�YÂ磫U!Eš;eL뎃ùŽyñfüí´ •Ù–tÿì¯J°óß82R[\œã¥ö} ÎÙ4–ú㸒šZ!uÓ¥N©ÐiÓ ã¦F½ Ø2«%þÄYoy{?Ϭ/û/™Œ!‚׆ºªÜW¶§-½½–Al8(¢ms¸v`1£o²xhÐf˜—ÿ¥‡ Á»l¯ +1"“ÚŸ�•ªî&- ž\¿øLy–e7 ª±£–׺8g:…®”šbÍÌÿyc‚™aÕ›xa¿5åY#2;`rä†{®C®@®”È øT¹I´]¹_¢‰òÀ0È \sÊëM^ù*‚fT IûåùÄÕt¦MTëÌ\Ô‡ƒï¢õpÀ9ßY+’õ÷ìHozLJTåƒO»dÛ ø‚pÛv»x­ãßèLZ Mµ¶dLGø¾µ &tÓÊÄÙ¥IòK¸HÐ:D­p áŒü~v™‰É€¬d¦o‹ü£KrÅrÁ;û@«­Úþ넺¡sR õ>’þ´ñ# €Þ|Ì(Z7£K䤌±ÒÔèÓÀgB¥:üÃ- ý‰.¬›-¥e»³äÁò¶ú”¡Æõ�§ Þcûà‚¶^äÓ9З£µZØDŽ¦óâ“{Jù¤‚³úc<^Xãzµ«}ó!j·KBÏR•ÅÑ…²P¿Ùã<¾¨ïÇy;— Å"X ݵãyOo‹Ý®ýbÚƒßààë…›ä»[>uäEïÂŒ,›¢’I‘R©hÑv3ÏdLã^“•¥>ÈÑ^ÜÉñ±¯uFÛÁѹî\+}uìQof+7= 8øñ‡v&#V [< $A¯ÉKéö¥³d›©¿ÀÝ7…Õ—Öû°×È„L)m¶œ]?³9Ž¬Vh-Š÷s<½9Šÿ‹ÜÖ–¢ ¦õ–N¤Ð²1n­ŒÎ[‡þÓ¥¿No˵Ý5/¾nåšHi…+㪾1È>aŽ9ê w€½³;}!xZÉh×dÍÅãYš¼™çcÿIGÛšþÆú…-÷ «h|†r*Ϊ|*„i僈„bNd+CE)†Œ+ôÛ{!¥m™R/…è;}îöm(dƒng¯œ71¸óéD:ñ84Wë�)u9 ÄƈõŒ{ë´ÁòšŒæ™oâãC”ÞäC°`c¤ƒ&lÁg–ÄcDwÞnqÇ$¦tú±·”^ˆ•Üç"ÈmlŒ.¼­¸4 Ô3[I¥ìÕc°…Z”K³‹C ýIùçÎëMØ6 lr4_Ípë¯ôà¬r$½ä<è1%síõÀ9 õû‹à¬ð!”ä&‘­. U0*2*Y·î†:c·N§¡3fÔÆ‚á/†ØzÁŠšÉáç— Ôš» ùrò[ª�ZÔ ##(ȲÓCÍdª½ù>? fgXu.0áÓ¼= æþ'Þä'q0!v¢Š± +Fš”™jQ uç´õO³€”?ëiÁ3àꦸTp|X™éd÷E1·^<­D#ؤÖ)—Bÿñ˜[C¬CgöeJ¸hÏHÿé×óXßta”q÷èʵ‘t” ;áöÓAª-sUò€ìpßØ {W–‘vVâØЧ®Çœ*™áê2~:ãx ½æŠ¡¯rf |#3g«é8FÀÇk`ïê ]i�Ã¥©Þ̼5ól€Ð í¯‰D¸É“܈0§(ƒpô‘lô[ ém ‡ºí<g û-O)Únx4­ÈVJùP5¢Ò5ê¬m$ºõ¦ñ/Ë•Bc½ëg=œ0ó .�‹ƒN»¨ÿ$¯Î{t¬¹ƒ×šµýÊ%Küž"´ü&J®¢ÏÉÓ+šÓÔYc!Þ˜š«=2¡J|$ ß²î« ÒV[å1ƒw¦ÍY¹ŒÝ×S íØuä‰Ä.CÖÖ=Ix¸‹ƒ¡ÃÖOJÓ‡—*UyãÖ˜ýÊÆ”}ä¾³Ÿ•Ê‡”¡:Èùš[¢Þrœõ•+•‘NL÷,*ëWšs›ìäžßñ ¾"òz?7I=5_þ،֮¾ï‰1KS9Á~ ×N²•Gw\—ŠV¥¢¨e.A ï(­Ò8¨ÛÃR. `ü à´Â_Ä/¥$-ÆÙ’‡K;UwØÓoåšòDBû"R.‹ '¢3ô,5 ÁTïX8%bZu«å‚ej(&3PéygµÞQ]£¿0pBÍê^µ‘¶çQd€f�<¤_‹ê×aÄÓwû¡VaÒ c_ %JA‰ÀVâ‘Lº.õBI—Uz�öeä9ꇖ҃»W?ÌIR™—\ÁNÇ.PP Ej¡†UÿYz«ŠçÃw/ùbuÙ-×^禢Æó&[‚‚ÿ¼Ñ§P Ï$è¸Ï t•„oëŽõðêîTµ­eYµ1ãmaz­œÞ4Ëýbp=T\M&¥ó‰»hÿ Ý?TkvG›!í‹ÒW¬æ8(Þ­Ô~ÙÏ'ªX…íü ô];;¥¿uêv¸Ô†¶7”|æ´]f¾˜Åði—ÆAV«_Ëí±p©ÍÌ í¿¤Á/a9]¹38íbL¯NÇ8Ð:|‚š—†Çÿ²e˜R؉μךҩ½pÐ<ØeYAãy‘”ÀÜß÷LÝDU`QH¡:£w½ç{€ÌIz˜—ýn·g-�NŸÜÿ”dÿdÚ  ­bjÍÀše8¿öó›8×çqÏÆŸôÄþXg\8ruíGç]b4V¢µ¦FÉ»,(j‹ê,µîò/;×2\"@ÔRMZš‚êqÙ 4õû¹Î vçnàÙ½˜»ZOh3mÊaÕG7ʆVwæÞ¨“T�²¿·gâȧŽzQS„*v½…Öº EÄn¢ˆùv8â åu³ì'æ7õ�g {u~ë'd±*Q¡FŒLsÔÐ8© [ #})*¹’153ÇEñÜž P#4Íj¶+ú»^² òdŒ'V›îvžóò|¢sÑQ1`¼ËÆT¿ÑÜ°„1ãV\Šh>[øB)˜,£EhŒ©‡ž9Ú~fi¨amq5äŒ>4œ$›Ž/ÐÝòvÇᎠMâ‹*(—“'{Òtß®í¬×}ÿõy#ÖrÚ&”Ò}îsúà꽊XAGq;1àÙð£é˜8œGº�RÌËD¥-œÃ˜J£*D«Ì”¦ü)¿ns /™¥Âk¯ž>#- "íR4b(&UéG?ã4ÿ{‡Ë82#éF [ …q+TB¹È<Vù庿††ŽSçw'"FãC2ct¦HÓxžÙ3:ï;=¸wä „ÊpˆRÏ5ж¬·fßñÛüaÈ-È÷Ø×ײI,Ÿôf',@f|ªÛz£¼0»S ‹òÌç;„;gƒŠb5±,ŸFh__\þÒ+»J,EH´ÉtÌåÃÉÃLÎ_v‰²_}Vòt3×ûEÆm˜…ÔAñ)Ò±÷dXák7+ËXò”Ø´D·‹w ÷ȧ© :d¬  µÄx*]Zï)LݤCf"Èï|•œÿ͘¹1ŧ×Wò’ÂÈÕN—ÿÀËàöÅã¨PéSB^Èñ{Ùê„öƪgä÷òB+¥¡¤òÕèc%}iÅ3”ž ªýgE™ç™Ѧ$ ËÄŒ¼cN¨çú4XlàëË(W÷&ÀÞìé O,ÜÑe_ýÑ{Ý©=Péj;ál\(÷ G0òÇÅŠM!×oÑW¤¬°ÍׇŸR̓ ßà4Ø;@ö=À™jçD¼_Ç eÙWóí#ràšêBGŒÎÖö³àîwÆþö:Z‡¨þñö•æŠbaUz‚þ˜rPÙæðÈ‹ÉÜ3è1„€ur/úÒYÙ ç $äá¾MéôLþ4÷s4­W$£ÿ±5dn,’æš>ðgg¢v…ãþBïtåfÓ›qÇ……iøIY°ùC{#;eG±Ù’ÝÍP 8²6Ž™¤þE[´ÛÖByé;pSŠ±½ÒM'±ÅÄX‡êÿ^’Ð'Ì2Gïd(LN +c^äÎìÙÀô¬Þè“­×Ý«¤ÕX‰f_ /<물yfÌ[œ¾â‹\ðH Û’ôE ¶%ðøt†ç²üÔcºw‰ä<­;9ï?ð¡aáyë¯M9S–XÓfbAcM€ö b4ïwúã¯Ã€&b÷ÅÊÍ+#ñ‹L{;¬(¾\€Ðé4Äà¼é¯HþÔP†­s0Çñz \Ó¥ty®’éŠödÄŸZhà  Ázj­ßŒ¡ õõ×B¿²=Ó}½g´×T+d)ÙãÊ ¦;©½B¦g(Ì!§£ƒ¿¼ê :I¯çâ^i”ù4“ˆç÷tggm{&l"¤Óä Ü/û?A¤V7T("ÏïÖÁODËN æ5nw¯Î‘sùXŠ_=âAözM× qÝ@,\iî]j‡õûyã0A”AHâH)j|ê=ƒW¹ælÙgäš×uná±Ðbž°oéÝŠ“öPa`z¦cBì,Mžw¨¶½x®MŸ9Ía5túýÙjĆ,ì"Zzð¸xbœS«J�|´’–%=°‹û“Æߤû<¯òÑr'eÅ»¦ñGçmE&Nà ¦8BC ]."‚\o6Ö±›þJT¬ ƒÈÃr‘ úrVyu>í´]m–¿¥-ç+!˜ÿR*öjqÌÂÿo8¦ma¢b &÷ÀÏÒ*ŠÊN}˜Ý8'YqC8²Q>mmý¢¨YÙ¢ÏpEÝB&9xt~câžù‚ jû"(j= k0fÞáu 5y=1FöJ¥0=kø #óH»zÚ7xw‹Br|éF9O9§öíÛŸz‹(3ÓñMOÙXÒ~´>gvg 0:5Ðyh­‰3±+„Ý@ÉóÕ2ÀlÃp™LñyîÚ]ÇC''áB«òx~ÄËK£Ê[Ú´ÌÚ+ºWÓhÆ;haõá’Î,_SÐólÁU’IÐåŠ%Má»t2ñÖ$Ký;*‹ª/¶1ìد)í º”“åÿÂE.­n „ù¥ë¾6á Í®<8dž÷¯á»½r-&Û"2š:Q;°›Ë§×Íêö*E¶‰ÃVŸÍÈõ‡–Tå"kÜóUßõÙs62'¾þ‚Ë~8̃Èì<í–²ü›³GãRDY¶Û)OÌâ7ê3=Rèy×<½ž¨Tñáfž®$‚íAZóÓÖR‚íº±nÞúVžwÞн`«é—'¬Sn”5ò�ŒrÜy@·U êaìžXe �ÿOQ#òf«J¤TãUú½Ô9¾ã}Øñèêµh’z>ž¹´ð’ µB³ aÖÆèzäàýýÄ<òͲ¸zœ©*È­´&û3° ÍõF¨”Y²Üˆ¿ú&™ß§›5_)ÕGUø´~j¦Nºôû/>Çû½qí æ~:š”Ä»Œþ'M[Gš©ÁÜ%AµÓÙàæØ %7SÁÈ ù3ú §Ž ÑÉJ.þügÄÊS©˜"¾«°c w,7¾á¿±A´ÿÒhÏÏ)ܬò ‹ÇLÈ<E1Ú8–¿ÈW+CGðRÿý¤(Ð'q0Sé/«@j…o¬$Vê,y@Oµm½É€cÌšk–ïíÚ^§<ÔD î'DÆ3Ÿ`”¬3u#é픎ñH+«ôík¬5¼%”Ø÷­áî÷i�qT�Ë 8¹‡lbâ.MþüˆÅW­üãJ4sÓíèuã0„h9ç™R+Ž¯+ç&+KK@ÐO`öœ§w×y#3ºKœâ?{¥í9ƒ3¦vyÿ»õžª…Æ-£—¤½ãÂÚêH¯ø4E1­Õ§H~bKŠsÞ­#õCgê,ÍW’ƒ´T:Ê ·¾ŠS™®zÜßìô¬ =‹7ŠÛAÜ+ä»: /¼ŸWPw“"þ§›))]t@š‚=„ÁŽTÖÑh‡ƒÃ¾_`I•…MÞdlKÁªÂóÕißb"NŽ' Š$:Wñ|èQø½¼V¯ô )™Ýïò ¶.E YõzçrÛŸU-lŒod°˜­&†X=ÖlÄ1Rr»x"÷ßb2t4×¹ÿôëÂvöB ü¸,úÖ(¡c²Î#”›‰Æ,åÄ"0"êkM]íä>e×·‰„äÔ§=œyžÖvQ9›7½n¨TL?µõ»=Ò1Ï$?'»i€WûTƒ ñÆÄ~¤ì3«WŠGË#JSÅrøƒŽRÅr:{h5#{÷ßÉ·9Îrf<˜˜Cê Œ%¡÷ì¯èÇèŸÔ=dcÅê/’˜BôP˜ºÚîè´81±R¬ÅÑîƒup âµ°1ðf;pŽG÷§‡¶Øníã>Ïs4Fž;�fm3ˆ!·øvÜkÜ—öõ߀¢leP–S‘僥`w„ cMm¾éúEÌ°'ÍsVéG\xSI>s›‘Þh»HìR¶áªØª³sÚc|´çq×<s¿à°o­³FîT…³ñÎ�)V$ïµõL)ø£90ü(…%x’ŽÏX±¼3(1R"f,«P/ûUÛ}:¶¯L¨R·v*ü»‹ ÝùFÜ¿¢‡Õ Ž[Â$%Àî)ÈPÈýìŃœ¬ KÇ"ÈêAûH(ªè?rÇ ø®ß ±Ü„]‘‰SOkðÝ |@Íh8x@yÚLül¿'ÄÕÊ�üÅ ”C:`‹JìH,%—R:ƒ÷KÖšlŠNŽ×‡nϾ­<êy¦=•Zþ#†Y8‡µ€~LVÖ{6óÝqàœ4AbEDÒ"¬-éImºÇíÀÚ1rÞÊrw÷Ê·kCµ<P¦jånQð•†ôMkm‘<Wÿ3$rêJžò ur@ÛŒ5,TÚ ˆYÉI‡ëˆÚL:HOIn>S™1Ö©£ÅõŸ–JéĦRfÒqâ~Þîû Ê'%ð*DÀ¥uÚyÓÎ=:×Åd.Ë—Ë;?›øøE‚|êÀù°×.ºW\G’Mò)Í�h”kõ¿{§5HóJâÌ–ððâÀy+ZfFé|²®ù”Ï^´Ê'ÉGœÿAUWïª(p ºvËs™úS±še¾QÅYÈðÄÆaœ'©‡n˜Ž¯ÿ½ôŽztý4¥»2Ú©oÒP?E.Ú“³Å EË,íhïØcþÒòŒj=©{«ø7MoMWo�&àÿ¦©ÚÚß`až³ ¹ÀØSh æ_ïžäk³ßñÖÔ"„›Ú¹:QÉ83<ºYχ’î0#Fkƒ·ûnýÓ ôGŸ° ,zØ:Ëò¦fóÊl™q9š—ùkQ™ñ¨ðãò iiÇäÛѨ~çŒh={Gá‡xæ^ÝãR°(¯>íшËÏ°?k)c8üÓáú= Ýa~¥%iäÛæÞHP'Ð î÷ª]Lqú[ý¶()]¿0G©åõ¬?9,ÚrnÖQï'µõG2}i’yRPaÅGOdk%6_Ø µ¿‹~8{¼„[.—mÄma×ÊFò<g(%¤ IÌOujö‚©òEX™}¿;SÄî'ב’#=ðXô¿¡WÒW{å'ÓÔMDbŒ>)%A?pTÎ1K§€Îê-ž\²Q$‹"›×uvi1Ñ£7máGܶnNd¼_qn-uéøµÜXy¨É›d]Ë�ÈæV´.Z+å])_C±½SoD¦ÚI­Ù •šõ¸õ¢L�?ࢷŽˆ`´YpŽ¤¯´÷l"ø ë ?¡W>`„㧇ÃF‡Ó6cp»ôíçÀ›Å?èÞßÿ™J‘yx˜„Õ4Ȼ֓oßÖꪶêÃ<ÿæŽIæÍ Ð €¹ÃûÅ:ëpg]ÄlT ÊV0•0˜m§ÅÚVÔ‹Ñ‹ÇÀ’’ÚÄ’—L4àŒh›5ÿJ'+ 'pÓzú’´ú pꯃK˜Õµ¶´Š xŠJ–*(?­ ÁH:ôMGS nú4’¹°9&4íϼ«¤ƒl%YD)¬á¨bNi¢Bí3­JʧGŒªWA¬‘EÞª¡<{¨aŽ&ÐTÕ›ËámSz— |7 Ký³Z¾®eò o) ¹ú»¡JòYþšMk9m½Ó³87ã=eê‘1–ŠbŒ=˜L(>™V[/ õaMdÛQa¦[&eÕû—ïã ¹­@±?ÒGŸ¹*šŽ_Æî÷]%¡g®nq"ºÀ”Ø.Ö Y±ß"¼kb Á¬41_(%õ ië?û•L\®öÃCZKÿÈó¥tI;¤/2·ŽjtD’O‹/ôDrO,„¹;þ³ °g6Õ%“ÈÏó°?É‘"(3qà5_Mäϼ\b“¡ŠNíRÝ4ÆwʼnD«›ýûn¹Q9Riœù¦»µ¬‹ k:©Õã³Ï·µé�ï;¥ãëG·¸pÆ>%NoªZ(Îœ4SE5GKN†¦ƒÆJåfæö軧ýD@½+³‡X²ìøEË/Z,òc7f´u:ÞÔ`Ê$H¯øÖø@•5h%ÊJç6ÊÒ½ìüzÞ™àÂb‡›ž­­Â^q~ ³—Ñá Ä£åµb–}áêßVa<ÜZ85Þ\5Åcàx=Ù´ƒJ$<H~xiV¢(�ÛF%‡#x‹-^nÐPV ¢&b”e Þǯu{¾u¥Kr^pžóB×éìR°v€‹›•üR‚¥H̪ ÎlÞèlã*QÊowÇK=¾Z&– p+ Ok˜éÎN6Ÿ`mÄ¿ oFIî”ĸupêâ hlï-æ6øjIîuœt\qÎÇßË7%IvÃÈ]Ƙþš/}¾œ¯0í,XöÃŒÜÒ”�T”Æ^ÒŽà³scªâ{£ñ õõܲ_<È0�å4RžÀ,íWÿå6‰tØ{TìUýà¸Á±HÆ¥Öý>ùZ9ŒkYB¯­‹4‰ŠÔ‰>ek½Í1ßDL´xêK] ö¶íü˧J‹‹ úÝiY.µ§†!l}¾4úñ[P=9ìgÑÂxêú˜ø­iÖŠ˜/ÑWP|jŠÊúOÈÜöGJÆ(8ˆŽælrŠ¿°­ÇÐH #ʼn¥ól‡ngæ_#B7P¤çõ=d;)WHDª jJ;KZÉ=°Êw#ÆRñúèÂjÜDibc{´ TgÇÖ)a8ïæƒÁ朼°›a‡FV´™Ó2HìÇã¢õª¬2ùn‡4ëjQÐ?yØ#Vhß!7j‚Øɇ……o=µ-óM&1:Qj0Ÿ´O‘]¼7˜ÎŽ‹hS5ÇëLÙ$Ô]>s =6N…-Î?A<vVâ5Ö~ÁRoz‘ø{¿˜¡y$˜§R5DINgu€*Žý–‘- ñp<Jl}ÀÒŠã•oZלmkgI‚Ø!ß^ö"ÄùD_¦Ê3'2½T°6ŸšöÑ;ͪs'z“ýÅÂà,fï©Ký ·eñJó#dHÊtêØ@[À`rè“ ¡ÌW²t@}Ð-+›Fá*Éo²4ÞÑ›çãIþåÔÕ7²ÝV­…©gaE®BVNÝPf/ìÅZÈPy YxäT³âùêÛo¦K…ÿÛ`7‹¸PªdQ(>µ‡ó¨(øáàÏr_µ%„3/ŠŽOPÁú°iœ¿åtÞQÌô¿Þ°Œ²4ó áhCNëI«ûÝ‘êÙËuÞÒò ¶ôiñA.Û’ÇáÊ„„Iì*fx±|÷ƒ›áš–-åÀÿ¾[x¸ÿ¹Œ‚l| ;‘…E!žxZóê8Të™þI2ìÃaîzg,5<ûý“Ä××g7û8c3"•dJÚìSõ~j¨âlÅM _@÷ ©k?9ä)ÅìÑõ4¡#ß-�LŪ@K äÕ ‰Ÿ}”O·Çý ©ì iÜë7”7ë%Î’”±%`5\Ìû‚y¡÷õæx¿í×v)Ã~ £É¢WPUÒøÅÓßßÒB«Øö  •eÜ6ôž’Üeoúy»cëý÷¿9§lnì@Á ·'V aÛz>0˜Ý´EÓ!“<•jD,+œÕTå5ëuʤÖ(nt néˆuL{³|­‰T‚sF÷¹V h$ʸº!РL‰vÀ/üÞø#Ì ø,Ó >dÉ©5Mxé?‹^œ‚8¼ÇåëÓš§pÃ^Väú÷'ë·ÙâCtÍ›Ì3P PÂÆü–2¢ƒt<®¼"+EÓ³Ìе÷¶º¶Ïž~ó¡Žfk €“3áž)T–qMÎ>€FçÄ~€flj÷¦0}ÙRmz±ò(˜tÝØÕˆ¶æ,#3ö7Wß°™’¤Œ³±I0‘ɃÜj° pÐÊ]Aw¸‚èù îs9ms4ºÑLèM{bÜVÎÏ¿.NÿJóÇ~œÿV9?+c— 1rx³`üc¡ p T×[‹ ñ%±¾a½XuÖ’ÂÍi˜×vibŸ_CÃ옽™ÎÝÔ]¨H\'!ÙJN+uŒCï©îÂט„ÊsÏ{ú±¥ÓŠ  ?dZmŸ³W”Ø-'ƒ)ßYåT×Z Šžvûð M6}­jÝ Ží=Ì P1éùN')¯ü</Îéçå’Fy]ÀÕo§£S·¢ÓðÐÜ¿O•î8°]b>IÍÐ ê Üu°ô²ÁàAV¸z’¢í˜R:êË5çÖl‹GšGߪå¹±ióñ«ÒQÁ³ÿ‡Ç`ˆè¯à ¥«§ºiãñ•®dšä>ô+ƒÙÉÊrE‘¿†·Âoõs¥Ü‹2ì qÐDŸOk¸NVÖ,3ÿûÝ‘S¦>L GC¹î/Å{uèj5x¡�ÆË»zÖÙÉ=E0>ÐʱÝð ­6U4Sœù8ìû3ÈPzq7<-Ý$ß&:%@þÆ98›uÿ�¯x‹[Ì<ö%OìY×¹Slc� ¢æ¿ÐuŽ“ÐcÂ( c_ÛÎÄ,ûa¯Ù ÏFñLUcù Q+Å™+v9œÿõxË,d&ls¬)¶–~Ç5ìJxàN‡ Iœ^š$G˜«¤OŽþ€€*XÊiÚôlëÆ$‚jmÅù  î_ÕôE?Ï Ë¦Ð-°_kìê`î²c±ÿµ[·•Û¶ø„èèp:Y�;úãÇ¡>¿mmóš~!åãü°rù€ã± Q:0ÉGç%H0ÿA)¤0œ •‡Ì^抠58||32ñ¥¶8ï=¤AÁÝd½uû´@zô˜‚YA5g]oÄþ¯ôÎÒÊëlg S®é—~uJ•æ*ý-ØíÎcé¿”ð8Èœ^Ì Ï[uœG˜Óc)~u–dÏ0=[†ßM6<}±7�Ö%òÜêŽ%¹'ÁÆÓ‰¦Úlki„túu_+ÓÓv‰À›{‡j‰2Ï2ÆËÏ­ÁS±~mÝ£÷¤Ã©_Mî’Ê1K±“ ¬{­-pŠl¬÷÷D"ù¡h²óÊf®9%ÛÓ® "kþŠݬ߬5 jZüä”úq§©?E‰ÐѧħÞj!VÔRz1¨CóŠ U³}}  éeBÆŒ¸4d–“¶DmS잢‚‰˜yÔÓUÿI&ãâWL±ó/ù-™a¡4SV§ÎÙq@âÈæbËñä0§/p!¢²ðS^^e9…ׯ/•uˆ$k6ÿ–l5Û½½âÌdUOŒRëS$ú=Ϊ!™²ÉPo‚üàb5k§z$³m»v«'ula6|qPÄ®Ǧ£H‡<¡s„+•g8L´ÞO¾ §KS£®ft´¼<²`-2¶€Ùãfºº(ƒî¦?µUÖŽ­ƒñ§«kc®ï`¼Iz"TgÊ =}z€/ˆn±¬’¾éß~Õ[YÄý‚nNcmݘ͊©f Ä€ åt<p¶þŽëÈîAæÅžý%kôo.Yíì®·ÄdüÐG*Û%ÏÓ v˜–óÄþÈÁ•§”ðHíœñ à);` Ht;q¸‡ (€XNþD¸›YvŸ«á”Ê¿²½å›¢ /¨HŸÄ)¡qÚ7ÍpC\Ì+Ê ÔËfÕbÏÎDì¿Ss^· ã¾$Ankù ~ÇÖï¶þØ©ø>UÊyö[Û´©ÏÒ׶§­ § ô=J;z÷‡<ýž©œQSçAÕ]Lû †CÍÀt‡Ö à̶1Zµ¸r…§6À³ø¥¦Ä¬j'ó¦e¦�XQÐ öƒVÒîê9—<M�Æ‘þ,ó8Rª±·³½ÐL=s,-¶{‘xR¶ìuÅä¼^ýîÓ²”G¿¢õÂÈEÚZ¡Ä±×­ÕNÂhÌ—¬õ¬nm+XÉÔô«u­¾ùÖ¼º2l‡ÒøÞ\jªûêÚ#2RÅ5» ÂÓQ>¸§ó”| *rúâß\O0»? òÏuN–æfäiWÐRFŽ!¬€òf¤r+îkÏáˆÁh8‚¸`€‘Îí2óĸàߟ +Þ^ÜE÷j¤žÍѶ톅ƒ2e<"Uû²³P´ò™ô˜B àæeVät¼ÞÔèvÅ;âç¨Wé¬91þñ ½å§UDéfTÓК´û?oy®SV:W1'{Q7/Ö¶®Š£ßc¥cÊ¢‚q•â¨’í÷𘅈·:i:aGZËn$«.mD;ëÄÛXÐDzÔ2Ž.nF´êa1Ïë RZd„Y57•ÓxB©óšÊM÷‡ §Î\M~ßg Ý4s$nŒ]ZU³8›Æ ½•`µU ©+ësЇdy?T-ÎKgeù+â86ÉÆt œ¬³Nu1¯}A0Ø^¥Q–t å=[>õ²hgm.Î_V¹¾Âñþ$o,¸õs+}zþœJüºk=øYE™ø¸ôÞ‡ꂳò**qÉa¬¿!"Ö­èäú¹×s˜³ØÊŒ�òõC‰«sw}:7v¬}Óÿ5MàÈ+}„•€– ;GR¾›¢æ£DDÁà_Êlæ+�)E—2ÈÇAAvéÚ[.&ÝèËøÆÏ)Ìf|0FÜt¡Èp…–_~©µ2` ¨šæÛ‘/ž‹.ÊUªsPnj§Oá]ßÎ #gÏ©.áÇZ×ãÅÂLñuæã£ÞP[•ÀÄÊlŒµ®JµKçÎƹ¦#ÿÒ;®üi ˜O®Žd)WØì½óT”ÕÇŲ±Ý�Éý¤©=Nr±?ØYˆÓ·x‹,öÉ4˜–Δ÷„_‚üÛ-~‚þ)xÙxØæÑÿðÏ,B&WÈJú’[£OZ6ÿ(±Ú†>¢'¡¸o@¤hâ2\Yü$V2z~ÿÚƒ²‹Úzw¨Ò( CŠv×}×½ò‘”˜¶ÁQ.ýl¼8vÚoj§6ïP«úêƒQVYYè°èñÒ(¨¦Þ+ŒYÙb>ÏÓa¾)‰¿W8Ð…'þJT/c’‰•Õ…-øŠíuqãDWzÎX%;Ì1L,ìÑAgkG+‹NS}óÓž­T^ÄïÝq!ÇêçŽæ…rÎ0Äè]´BÌ‹„´çejhœ±Q¾am¼Šý™"ƒ¸}?îY’äÐA&óE9¼È· Kp¦v›h Jëpøï~·;O¥«n-%8áÛ?6ËÙýoNb‹A  ˆìì®>�:|ßK¼:˜¡íãÿÉ“uA沕{Õ¨(Û(3H¶&Ï+ÅM®n¾u©aš¯8À.‚èêyCZ¶š‘èºlÉy﹦�Yéû»õÏä&¤ŒûݤødT:—³*Gq?þî{3Ù®* 9–ùÔlÌè)®Á¥;vå±s 8º»-œäN92ÅeΓõäÁ©ã#훾Fy²c8Š`:G+¿ê<qC1v2‘LY^ê”îÒ¨‚­|è¢ÄyµD\ªµ å;Öä�¡5i2°¦Ð?XE‹V tO"îV” ¿+_=PåFË^‚Í–Ùh Ïv5´¾ö‡÷ƒo2þ(ŒmòÆžàHhéTU ŠA¬=©•Òtåá+}®ÙLKpåîTÂD*(¿V£QÊô™”iJÞ›Pšh?±ÀÃí«W?„¡IzvÂÒפÀ§\(ðè>Ð$3KÇLïòž&«VVŽ”â³>f0ç0Xs˜ð;¿ÅWgqâócé ÌÍK+x^¥z×4ñ¯’‡Ø÷¬b;©§ýQ ÖG=äi~ÃmRÓÖØÃ> ›È^q”fÞh]Hjyô:XäÊìd:RvÃÞ˜? ª9$†»ÃQ­‹ÀÄè–=‡=o—¾ž¶t =´88¶TkÖNªæÇT% Ws=ºEÝ¡ü½· ‹öšùëD-L,dSìÞgCI®¡õH®ìÉœr™1ØV+pÝ7‰Ë÷Î!DÔ¥æ¥ð0Œ9ëX_ìb‚öŽ~W¥Çæ<®ÑYvÓ”,󩈇¤êù¤ÐºÍñpªçÙ/Ùi3?ùR³z¿óíá…„-qû/«!/Ó¢èé/ù),l·d„ÈQ CìÌÍIÀvÿJ'ŬÞž1@ØœÏLê:|Tj‹�3„ó@g±ß%àÊMŽÕ›¹×wßyȮʈ;±ix§šnyåâ_QÔ€SÌŒ”„Äܘ–YÌŽ“&A΃›Žg3m¡Û4ùGó¯4\UST¢ È RU Éðt´þAó Uåê…Bì×Í`ˆAtÏAq鯇Î׈cuSª[;>Óöës*¢•”'ÄRÎœ,>»§ EÕõh¦ñJJT…ÑŒsW’!7]ëªðÕ7ŒéÏ<óÊNSä¾Äâ2â­�‡%¿( W{—‘óˆ*{ŠÐm² @Ù;î/»cs,L½¸=þ•ž#§)Øô’ j¬0K¯ÑÃÞRvlqà Nôª‘@0%×`6=(N‹e<—c,Ìg¶ÇgôÜß ÄÍòþ/ )>ž%¦Â<j—±²˜Ñ¶‹ÅŒÓé?Ò¼{$Ñ÷ðÒÅRbÂéÖi‚zö¤™;f%f.f†%´ÒEÞʼnŒ‹Û Å°t!³bzÞ ­ÆÊà”!?Õíæ@¢GÀ¢heb˜í@·¬ÙšÜ1-TЦ| PÑŬ¯¦û÷ƒˆyœ8Îõ†.™ý—S8ãZ¾}Û·l@né&¨Ø¯ðÛ¾hAnò­MCiöéìÒ:OTüOº€\ÁtÃUªøŸ�¶VdÒªwÈ¢Ad«á$Ò’¬p2Öëu]bVÇ5ŠwsÏŽrÞñ[åö§kNŸ7ÙIä¡%jÁÈ“~M¶\Üý™Ž´í®*\ÃÄ×�»üGÎ’—•Ö‹Ê7 cˆ]J!@[f<*ìjÂ*À˜õ˪éºîÆÇ;œ¦çÑ ž°-•ÿB€ =œªí[®-=8 $9•Ød0%¯V‚ÕŠ?éÇŽ‚z£•`T,Ñtušl†ÔöPŽ÷ÁÏîþšÌÕg‚¹_ò œ˜sˆvbwðO”_RæßEu%÷;Š gKt¨ÒZ`2ÞØáé_§>%hÐDÊæÎŽÎcÓÉKï¿«’ ëy 3ÔÝ̨Q´dæ³öº×4\hpnÁÄç—~ⱉ£b8Lƒ9Gx]<ÖÓ®UÓtEøëhɧ°wõÀ$¶,Áí1˜u*ó{ÊŽª¹öèÕ¸ [1‰£•ù‹N´?ăy”eöÓ?yóÔ `ÓRY20)gøJën5žpo¾MËOf¬±KÁ8ë›kˆ‰OÎ''8?YgÚò—[äwßC¸âPp¬Z ®PÞ CŽ\zwÖkÏ¿»‚’®ÿž¤·™À~W™u‡GºÑPö|ÕY(PtbVÍ=ΛoO[Skš‚ iݸ¹YÈCƒÂ¬Øãïúq”‡žâ?0ZÔnŒ¦Sýg?`ˆ+ÜßòwŠÜ·š‚TÆ9¥JM™ii *§¦êæ ¿ƒ+©¶I® Γಭ‚düò&ö”;üñ¼ ¨¨4¾âÿyúN¼ÚÁÑÖƲB½Ðú»,äú{œMå�CÀÁ”ÁeŽ *©‚p`±ÈƒÂ·RÕîk¯l½©I»»º÷öòH…Üaô¥81# Ä|Rº¿•;L|çL–;–m³¥ÙŠºýýªtl a¸ïØ|¯¶ç˜m¡z=Bz‰"…(U>K¸r3蚈6ü€Yó2é¨<Øc§·¦¦šõ™'åÏ¢ô—b;&DÏ»š½—¤³`SR\Á:«áz›ÿ⦦Hš}Zž8¼¥Ë];HèËs¨U~PŠ î5M}6¬—»7Ò?Ž²Žn_Ÿ«õ‹ø"eàÇ*ˆ­p8Šü渟!¨¸úFDëìEÂÖ…”„I¶–~?$ …ž«Ã3·º›î¹‘@¥+ÿ`(~(ïñåt›2”B=P¾ÙZÔoáËvÿuűCÁ  (Þv_/0À?}³ßßXŠc5·Xìx9oz,[,¶Ó’T+t#Å#øˆWV!ž›c› æÇP-˜u¼�gó ¥ò„•­ah#-ñ Ë@gÝWŒFBë9Ó’d ¤g;fÆ}ã™’²ã‹zŽ�ÿÆèýËÉ¢ÈÜQ¢`%ðÏlà]«”aP,²u’ÂœL‚χ|áze�èDRC�eN³¯„äh”�*ÌšEnñÒNCZc÷ߎWáJkå8Ä”Mü«ªôQÀmÞ(§SÓ‘G8”ÿ"s2/y]þ-KÙ§·ì}ôdéa!€ÔÏœ—y˵|„2P4ÇF\ &¢�ôç8£Ä7ªá`ÞÞ •;>ö Q¿r«ô4ÂX¨£#ªF.Në ~V%¿2z^(CǨ;IߨúÜzäÏ-,Ç1‘’æû4Wâ–ßPœJ'—i6 €[g§,õ¦È+Néºt8Ά!"È0IïBhâ͈B¡‘ˆÅs¶Òf5óo…óŸë!*"’[œñ¤EãNS•h¨Ëºó’Úqï·2»À#Ê0EùJX(9²®f [vœ�ûmý{¦Ö £ï©í™G?g%v¡tpn=(SÓµ›±k~¤ÜÇ¥ßé§$ ï—í7¾À;ÑC"Ž¡v'4Kûþßìø }vH‚q8óe§¿…}i§ãÁMŸtÇQl@âWE§æ–6þ¹1l­í‡?{«bn ü^Rü=j`²Ì^ª`³¥¢§œ¿ÌVÇð¥G T †œ»Ÿ!í‚ üºÎ#­,Zumý¶a)¤³~„5™¸lØÊ Éáq1z¥ÐŽ]u^qèõøñ_£ôùé¢;Uqj§Íài1Ž@Ð|«ýs•È{UÀ*óÊ~,Ç9+CD+àd>¢u¿óye_[˜¤Ž ' ¶2vn±¥9ÿ‡H:>ªòÝñ‚\O'ù­*}ô?iâd@úrkÿîhTèøuô@¾£ßJ·Fžc7äa VžGçËÞÐ&û_îÂk¶`­#Sª^(Å⢑E¬¸ÒB?Í|Vv9ñ¿>Á¨77ácɨ@µK­.È’s[V«ÊóÔì¹ ¬ë¶É3N{šif»¨°¨)À4ŸæÎp¯ŸÖ€Iæ>cin1ú7°:'¿‘ùÀT„°¶¨hD —´òÖ{äÜý’äÎL¼ãª†ã÷É5O'–ÎÜYlüðÏ‚ ²"‹ÏÿŒ8õ•Eé8è€ßxÿ× CP½}Ðœ¢àaµ[ÏÜž¬#®— ›È7„S!]üdw5A¦þ[½ÕØ;…x>L9tÌ–}N�K†æSw™][SrC©^Kùùq’ÜQwRâËdìú=À‚aTÚ;›²R\eÖwMo ”ÒóÌwùÚa°g‡z7ø¨°r¨I1ì@+Ó©' üx²;Îò(ÿ¶u—žÞ ÷.,*¸h¶›‹‹¢=ùèÆHÔzN¡Ö:‘@ßèp…S¶U þ$°%PA†³:qßX †þíq'-¿å@»º8«#PfˆÄÎQ•GßV$ýà|æzôÌ{H:Î 9eãý~^íÑ ^†ÝyŠÈ"]¡Òê‰R DOW‘Î�.³q•›nêÚýö7Þ%º/NN'äGû<Ú©·3¥ŒÖCSW«!m¤(ׯwþàJQc•úü}çŒË t=5“y¤Fÿ.}ä¡{‘CCV"PñY«˜3ÆfWƒÆ—­[#Ñ™‡D”¨P·MŒ©¿ÿ t´Í]˜-�Gi2'@‘ˆˆ6žó‹d†Øªm'*·A þ膃*ÊB¦~¬ešõÓI“X|„XÌGÁþ­Íô÷zEØt0Uýšë–±Þ þìO37 ¸zËH[}õÕ^ ƒŒ¥'Uo•eÐñÞ[ õä×bÓyîÍxúÁc.ÂÈç©Ñš¿@”oVcÎ<’å¹ Œ-•ÔÚšòÑ 2œiŽg€#bÌpPÎ×–¼|³AÍç™j¸Zé^©éjÕÁv²œˆWQ¾‘O f«CèP¦–¾óô÷<¶=-_#èÌžŠöÌ÷‰ÂËÔÓî ¿¶Ótݦç_Ën€®)‡F"0 c0 ûÖÍ$±’^"5!ý΂dl,|vú‡óµ¤=mc€IdçÝâø(±’ÊéºÔ÷0e¡/ú•é2Y° OSvãÙÊu²²—‰=úîÎö€6r]„´×&7|ßí‡ÅÌ—Ä]Š—€Zkb!w{ý+Y8sT�¥,‚x§È½ùÔm–é|0ÎE&®ZÙ—”ê-*Tf�ÅúRΟÆÄûp¦ÈjIåh±ÖÃÎüA ½òþþ†TdlÌ”€CSØJ•sã‰8‹õÏå†ó̬Sk*õTÑ5â؈… ª Ô“<û FF€Âfƒ%�mÞAÖE(Aäôvꊳǟζ]wÚœ–Ô‹}™Ož—]›¢V»%ŒTPîMºŠ‰f2nm^y¤È$ºï¬mÕš[a:�17i=¿eÎÍoñϳߟ‘'˜,ÐPÄ’Šñ d°A›£œó"ùëóIo­PB·_(TÙhÂzæ`¸Uª¬³$DlnöÍó&Y•­Tááhé¾X3+Xú½:;¨âË)óKit´Racõ2zN½òn�ßâ:RzƃL¦~Ô/³jôÂKDgê”0`ÉxFÒ»ýCÇEœ!×*ãkœæãñ*s˜½ÈÂ^(î½A{…ýYXMñˆ[¢T͈¨µÍj)Ûf¬¶‚pؤøòWhª3#%.�o|Ÿ ŠºôIŒïVˆBt^ƒÕ2ÙŸ«ÞNYã0ôqs ÐÓïi{g¡ãXš)úGniÚéük\îÒ0[dâö¯=Ϙ.¶û×: �Ö²¢{?ßlïÔèSQöp†7¶¶ä°•ßcÈ�@Ø ífÏô%íJ묀Gsþ÷ßú—UZF£45£Û£Öjû®-€s³:; ¤[䎺£\ùŸ]à£XE2%åOˆuU›½NWl\…(|™ºLìtD“™(†yhzÇ¡¯cDAn٢ǻ¨äIAïö°§{¡ò‚ý~;"泥™|x—7í � P_eAtúrSË~l‘ëbö ÷Aµ¶‚Íòw(èr톔 ÕÑØx;ôt$å“ÕkK:²n•‰ž¸Ë ²‚E˜õã6# ™{`ÍÝ@ “|½?¼¢s“…•Hî.SቱP8•!þè<€Útƒ?é9È_é#üa8ô•|”–.Øð£™(rõ½Ø\7tf¨ÎŽ'>åõvÇúÃ¥ïexã´|èPð4ïž÷ö cè/ØÕf²Û`0̽F–ͦ­Ç`[s¦ÔA™ù•âm‚ÏÛ|±–HÌÁ‡„ªªi½.ï]D¶<“®¾.ƒl¾z“¦{ì>k×î(íìëCl+zqÅ0·¨0äiªK:ä<ùO´ÊMedä–_¬ù%Œ{ TÃSýÁ>"fXy²ÖLoУ¬gÆ(é’ï´ü=§F€»iãÀÏ=UµA„—7zhÁ½ÖAZúhRøÒj¶˜ˆ©Ûáhñ56Ø/O¸?Ú)0 ²ïe:âf¥XOaz«=,@1ÙÿH'DûÝQ³·]åéy%µò²îŠ5OJÍÉC¿:¤YYB1Ër‰m¼9:Ÿþž×i®Ê$‰IZ“æµãÙÏf´÷ÛÒgKæÒ'˜(çUÍäŠ hõaOeT¾é²ÿ³ç69mtÞqOGVn”¯º ,A_gsD":ßžHЧ©w:A†4­”]8,Àí�=H††ÈŽ xÏ”Ð{ÝaÑ}}(˜%­Ñ—¦¨¾C^=ô7vö”al90쬆ÙÅ^í\ʳèüÆ­3*bg”à ½¤Œð‰Š-$TtMexF ƒªÉ\ˆ%'½·n<7¢*1¶p‚Ì2㘥3h×¹ô]7S‹dÆå>U,fƒ@kw´IHóÊ¿¾­w†{7]Êœ ¸œŽ°ÇV†-Ýù¥­†_¢:5%¾�þFqé­D®>–‰‚æØ;nüù$0Ý?8˜èŸÏÓña ïTKcÒÌÆ'ñû»7ÜÕÜO³èo\O’¬ðõ"442:ë¶a'£ ‡AÜX¯{ñàÊ" ³J=jƒÇUÚ0“þA_¸=ž™6¨çܽçª:¯F_@ðÐ?ü€Ia¯Ï‰Ç~Œ§@<®ÌÜAì_þxZG¥þæLí¤á|’ŸïþØ™×jäýÔ Çùºò \ ¼ZEŒ,õŸ=§^Öcì?o©_'%¬?{þPUª¿°uŠô™«¤m”T”…Ú7¶jˆfDpþž~ì=yr‰<ò ^ÔÿzšÈ[JÜwhD¹Ïcñ¢¸ô,˸dìO#æíÒ2•‚B´àÆ$>2”Chïæ•êèn<Ô8w³ã?ûmîoâÿ‚¸i0ŒžRR%ç_Žº‚Ü•ç®’^Ëf›”AÜ~z<Œ7ÁÈïØ„ƒê²D-ºš€zœèúÿXû²íV‘¥Íkê)|×7µ{‰.A ÁF Ú²öê÷ŽŽ/"#3Ñdy×éÕ »êÈdFÆð ÍëXÈK³ 4é7—"H>w¦µ‚ù ÔéÜœ· ÏÿK\Ý›_l.]s¥Qä\U˜yþ̃Ðê2ãu¦ª&¯ä´èr.‘ý\6á!4=í¥Òòé×%CGÓp4M»ù$&Žˆpü_у™Õ€d‚ Ñùî@#¼ò"Ùé»Dï­ù“‡ê¢"PFÄÑÉElˆŒîÊî%¼©:¼Ëh—ÛjUÕôíâvçXXsf½TÞùΚ7à¦ÇïÖ'>dåGš²Lô«×7Hß· ÙÉÈrËÐÔ™•¾¿{ÎÏ<ñ[3?âGÝÐ¥R+Î).GQд=ÂqöJ¹­©â6­õ]5m­€åyuÝ+Œœ_Aœ»@)"£ÎZàÿ[uþÂŒF- ý£'þ|J…]vÃÀ*`†k~•_an! Pl¤Q»Žd¹U^)Z£@#vÕFzηçíýÔ¯gž)/ á—š8 )¥í³n¬Dü|Ñ,0Óˆ£eGÔâµc1¥8T9ê%¾Ô“DãyøŠƒ|³uàiG[Ö:oKÜd î3Ž£5÷‰Ì­ý*X'Ô5=ºAtÿÌ;·_ª²¯Õ-fCÛž‚ù¤7©Ñ®·,È·•°íž´dmþÄZß‚3aÛ' î™,þ¥§ÒG â-ûQº…·íÔ'5Êáó†ÊMK°G%£I]¾—è)Íi›Ñ‹¾X»[$ˆoÓéYyà“=yZ¼ÿU—7söU¢CÑt´È‹É:‡†ìÚ~lg¯–Ç‹¬Õ§„¸¼ti6rŸ#³+oNÆH9ßQè¬~Û¨à4g1Z1¯´wƒññq ŒaôT-¤—õüsG‰'ÑGŠÀÓ—CŒQZЯ[ ƒ¼£ù¯Üzá1Xû„‚Û?¡ÑDÃd $,yäHÍ…f9;;EQÐ?NÕ‡ºBü¦Yž:ß×°P;›wügÀ ¸Ã–QùlmìÁÏ¡cK‰ÕÊñc3Z·Xª'DnçÌ"#æ¼~Yæ6OœÜ!›æN­Ñ|ò`͵ä Æßc`Ú·é‰ã&þêÚ_»á²êi„Η»°Ö’‚rvø¢¯áª#È×µg«‘óÂÁdmÂBÕf!a–_Ô• {†\r»fÞŒ¨sÕÓ°f½Ö§¬ lå>wjUz ² ™¤íÉÚ^Ë \ÿ<AGÞ($évÈ45ŒŒœVnWø~Ö»ƒ®:ZÓc¥Ïû?PÝ£r9Ö£Öô½çô,‚àkS½bä»áÿç Ý°òx±Ãl‰?3Ðõýhú±zñ––Fy”Úf2 .{È¢n‰…Ïn”I­/@Û}LÒê1ü®÷»Ì“° Åzœ‘^6¤€ØYÉlç±¥ÀÕ<ÞšŽ+jö/¡k{êÐúSçÆ õ<ÑùÖ÷i«V¼4 2ŠNè÷]¿Þ0ÙSKð”á)²‰¸Ös.Π˜p[ïа/$ÅjÁΈƒ.†m•Ö¸+M ^C7»76„Úç�sÏY{ÈŒ%ØÙ63ÖãiÇ3= ÎÎÏcâßë‡KÇaÜ•A?µ2‡—ÖȲ'ŠŒ·OQv˜šMÅýN¨Ó•‰¢e¤Û³štwå”na|ÿ‹ù]eÚï+¹zbrœ;t¤_¾<mdÜ^ÆQ›ÏÌâé0¬N\ ÃUê n¥¸¨¬j-Ú t€j¢“yÙ@%J¹Èõ0P gÛ€\uÞDæ'xþš®›ÜÙÙƒ_ƒQ¹­ËóÔ‘‡A'ˇ¯8¬9½Á¼¶á�žœžý¡ûqÁÄ”) Î#`õÖ&�&®«þ#hK;F_ 3hÙûÂç>£äªS^½Õ7–©ø*Y!+Sš—¾fóîͱidÝiŸ¨yoZõ›Â¸,Ã=!ëzÇÿ‹Q£W+鉛OéùK°§8mP è;»TÀ×÷)ãgðTù!AªèDçù¯C5~¿1Õ)S†À89æ<H¾¬ªjʳñ-€üM>öÍd-òüZÞ¢o~qÜùÕ]·(Ð3u”é£ Ò~ëM\b€ìûîÀƒ{ñˆºÅKÝ}z3ÖHi¾œ â™Çvü/)q”ú¦‘”ŒPr[éw7fE££«ZÿÈ!7ü'öxÀFiÝ× ÅJ,|½ƒ:²‘ܱôŠçrG‰c¢`³fô&ÐUÙèxT8Ã¦Ë þ ÖJ¢4‰Ó‘n7Œ7ž¹åNÑP·Ùã³úGeÀB¶²¡P±=Å ƒå¬ù;4.y.¯ãôΗ®ëà÷òUê)!r>òýȳÀ®ASÁÞÍ߀ç#õž1થ79+¢+ŒTç«A JumT,~⎤Þ<1g:AOÙó»ŠÆ`|ô€2—zõj„<u² ªvžÊŒØ-äN¬óŒ&êÆýBëLƒy¢M ùØw)F½fè§è˜ó? '6t.ÑkôhS¶,­ù³HíÛ¡3}#£(ðâc´Ús¦ÊÍ!ÕN®Kƒ ¾‘6¯I¢¾?£JW ³ß‚Wh5Ó£èÊ3üc¯ØU/þ×ãð5Ó¾w�¤ #øªìS—ѧï1µþ�ï‚õ0 cpõÊQ$n™§öà×+!5z,^¨>Ó—i.înI;¿õ¥ÑÐm~—lN3ëMQ¿/‚¨Õ¡yÊí¼Ùy>ÑŠ42 žRÐ=Ÿ÷®.I „aE…$‡&¬—U åOÃí—ӥ魽×kzíκT&Q»——³úfH¢ê¶ÝÑòQ7Ö§îåÖÞ85 ÛG­Z‹ê*µ«Â{æQ›ø&,šø€¸NI*9™¬‚G“Hì=rºªðë«Nýì³îTêVAÙkb^d£™g#‰ÄóZÕ=­?¦{“×ÜÓä@Qï耊ŽJUOQۢрwôÏÆ'?8Þz²(Î)¶Ñ»Ó ªNNoñ0tT?¾L*G¥‘ÈÜ^_Ôø¢?®çîJFM€)`ëùDùñ^”¢yõÿûc%QIu #äLœ}Áa/¹}}@¢ÎK;kn]†ªó<{lÊí04Š$d Å̘꯻V:‘y5F2gLÞç?Nù0ÐmUS–ï§~tQõ[¾Iè+¶syAE¡ArÁǶ£!#vÐœx k^®s´ÒÛ Œ ›Z�`ë³u¬ð|§ VØwfèaªiêÎÅœe]3z¢.ïÈ# `M솃ɛ½Ë[°¤Z!™¡M3Ž’ΫÑj~ÝÙ¼H*‘.›\°n¿P««féÕ¢weÔæ^^.¯ÐÉiZO1]…µŒ—fæel÷`A ħê8íx9œ˜ùÛú7•/9³ðCCˆ‚bëDH*ãŠÜ&Áϧ¿¹µ$‘ÏO_EÁ—¦fçá71Ëm8­À©Ä˜ÌÒŸ‰ :s#f2¬VúùdkÀh ×y¶IO Ü {ƒ™-Õäf%Xí7þèxsÈ/fn!ÐÂÝ÷Àq[7Œõé¨/ôØŸ¯\™ñæfÐh-%Å)ŽV óÑäi7-•Õv¶4§\mÏ0õjLnQCZ ÆnµSA7©Àt…®»Ù9må¸õ#¦GL!h€ÍÐñºàÇ@÷oš8Åz>Ž4N¦¬}®`ÈјCfçæ¹Qöi¤O<·Ç†(×ÜM9h@ʧmãµy&ŒqŒÖ™Š:pü÷0y'~”²¾M2vq]þ�ñ¨Û·6¿‰‡áY¡”8<!´O’ÆÜ.5[¾Ç xãÏ;lÁ}Ûí~ ªñÔ_éÙÄ>U•ÓÚ™‚\Þ7’Á8ËÛ#e5þ?9¾°Ô'go}Òcô~dwmkºA$ 7¶g¼_ž}_©Y-‡UiüVN5ý£xßØÐÛ À.5Þëƒ<}ÌN0–wa¶Š÷²SAÙSã:TVãαR«þ7¥³{-¸þ‰CöqØ÷ž¡õöu¨uN‚¼Q†ä¡úâGà{È21ËõÎ9ùñ¥4Iá€cð; V㧅J—HwºëÔv²ž bŸ‹­Ûƒ&¶E;ª½íÖëfm°‡[!bºÑÄK3ŠØwœ`%çö‹\:©h4j0æû1@(@ ÌœÿÕ—Fý;s‹*^)Rhº Û÷¥ƒ„#<;‡¾÷±i) Ü÷‹ëãp¾LæŸ<<p£3võmÚœ>éyôà$Í 1k2ysÛ‰çK^+ƒ pHˆ¬6%ëôE׊³š¨ÕtFI‰®·S¬ø èÀBhéFûwèæì8ù1™8ûVu ’È÷Zh…G?fQE…Äjܺ^Úgæâ¯HÐ8£'ŽµÙúúù‹¢ËÈ% 0œÎ¬ó†£¬¿;«g=ciP`êùd®W&þx™Óc·µ°”2ћޯ;ï” Ièß eý‘öJf[F0]2T6,*žÖÊé�>° ÍW~ZB8˜vx<êU`†]7=+S(3Çu?UÕú‰ bZ¦>Έlº½«^ÛqÇ– X£¡ o¤„¾öõ±¶óH•›Ó­ø:{37Z#T¬M‚£¤:íãc`ß<®±·YcºLZ°²:ºp×RêqyƒŠˆ'úõsù/¶ö¶]—ÂHd˜:|`¡…Ô ×8x©2•õï~ø ÏP. ¦êò éuBA¡¤?¥bÙOé‚¿á;U’ØE0×À½µø:ªÃª´X¸±+ ŽsJþÖ¼5}\AˆÜ:G <Â<¸R•é¦’vçBí›,VÍ"©«\A´îÒà»K0|]¡X*ÖÇŒ³ÈÆ1ÌgZì-ÄŽŸO¿ÚÞ‚-ËÐò/9‹wß$g‰¶Y9VV=ik§6cINŸxðt¯[F²®$ïÿÖщAæ’8ÈÛÑ€˜#Óçÿ~ z²Ý»Cßì½h sïnð8J=}Ú~› *Q«\•jÌão³¡¨Ì1ï UÛµI¹ò•`V:æ”ï_”—_ S,&¾ål÷·gÖ¦57¹kr’{ÒmŒŠè·en:ïe® ð·"�÷Z›Ù56Ez(d9¦âS¾f~ÒÛcë§jLQ¬(±Ë�Ú„“2KŽÔªB{ÙÔÞîêoÐ…ôkÉ <–bÊ×kÏzãiè® Š±xgµ¿&JIioßþf;L|�ú‰…*s…+#®»Þ$IPv£§† $Å;±ki0˜}5Š'–úŸZqÿ¬ ÊZ³¢õ 9±}Òµ|FžÅÒÁÁ‰çÂ)*dy×dŠ`§ãݯŠÖ­Îæ‹ó�.ÿ2››Ç$(zm)­÷}%C'L%M»¥ìðŒ¡Ô¢¦•¸×Þç@…^\h£` åÜ®÷˜‰ÜF×Bž…Û·CÏiìÂA®·ó5 y”kd’çĔ]A×S(ºhUo¨èX¹‘~–¾•±¹Â„ ¾|ÿ$K—ø®…J§U-‰å™i/§Lì* rúz¨:„xòË_i÷~P½úÑÇV3Ì÷%‹ÅvãËëÒº”â|´ /P¦?A§Ý)Bær´Š÷‰ c~8*¾Øú^Ñ ÖÆhº€`½ÑL¡Üszk·j ‡çeA¹NÇl`0ŠãZ¨ó\z8L4‡ˆðàæŒrƒŸ*�x«$G¼9€ùÔ~©‚i†Fó©·ÍÀ–1 /Ëó%i”;Mdí#-J‡:ž0_‚´âÇö:ø](¶–´È!#¶ªÍC·ùÒ(ÓÍþ§cýÁ›Þ\H÷w0™Ìíº[ÅN?‚Íâë: âOkbšú>íT è{ e�;¿¡¥ê.¨ÖkíÅí.}ÃBG‹£3NSOןN®£µXf Ð ¬ À~ Öí©¯z)lúŠÖso››®ÉéÔrJH¥3¥ ˜¦HBì1(rÝCCs ‰ýb\j»cÙBü•>ñîTѬ%dMj:²ãêãýïþ4a.Z‰À½žã ­ÇU·Õ Ð9ËB”žqöß\éÿ¼LûöQN%ºU™{µ²ÊXÇÕg†2= ˆW—zu]E”ÞÅÆ¡":oZËÅ}~+¸‰ÂxïƒùžÔa-<=Â`þD¡]´ãÞ6vUmà°LM5B>ÃüÉy?OÕŭ݋׮ÏÕnv§ìÔj*jTéíøûÒ«VÚzhÃgêï],•XG±NÐÅÚxcúúTÕºÓÞÃA=äÙçÎxG:¤GˆÅ•v¨ C„q¨÷P‰šÉHÐþà@+/×·8O½r™ÂKz%£‚`Gµ’EmY¾(“ ÏEçü·2^V»}µ2 ûs•P’zòìÖÕ¹FôÆ®ÃF‚ì˜2K½Ö!XºmöŒÔ˜¹`µBYêèô‚~má²t)•±aB%íJNŸ·_o1»¹4^õßa¯ªQ{eš´þ`Ò¶ÓFbhÎß¹ÝÏ—oF€C8ƒ0bÄ£ÖÉl@9á¥ÌÑŠ¿ª:ûÙW5k÷ËE®æ>૳šUûˆ*ªýV¢‚V'z6ÿ¾…Á©ß³‚/B¸7, öbõmgµùœuîÊó¶çrŒMŸ’Ï£)P%£¦ Xd-ÁôÓâ™fkhU/AE¾Ótæ(úfÓ§gµHégºžmïÐMœ¤›óÆ`õ·ÜÍuKhaxÁÍm4¦4ÿ‡Ò£ øb„óÕrC{ñbõ— ß®ŽV$|Ü¢wk7eÞÍ“2¿gáöÔÌ­ô¡¤l¢KÁ0²³}¼uµ=©VDœ«hƒpÌ>/M+ÿØO=À—‡×ÕO˱˜x®:Zlij'亃+kpi|ÿÒ¬âÄMzÅÆä ³—²êLû€éºÊÚþ_ :†öR¯hö8÷³^:Ù;ˆT¿«‘FbõÉZ[Ù´Í»ª» |…›„®ÔiKn,4ÖÜyONUkªÎ´‹m ÝÙ¶ß Õv6r—ÎÞhåÔt3úžŽ¼­>íÚ‹Ãt6§é‡ž+yéäFB ›>N‚ô«óD©ØË¡CÕM¥Ý¥rZ+ï€Þþ>ü§È‚å…Yº'ª¬®YX3™ìc ø ½žÌõŒdAõm¤58Î0Þ+ÂÈš„þ/Uíˆ13°§éüÎ{‚V‚ΠVÖÀ ‚Š|êö§ï¨Uaž˜É i HÚ1[U£BÊ!舷‰Ò+øñ>_{TØE¿-‚ðh'°«Ø`σ•8¸îפûù¯0â1`„„ݺŠƒd«Ì*P3‘Òh§–¡ÔÅü CŸd­ÇõÇ맢¸Ò©ï¦$ˆ:]èLwbÄzpø:]ÔºÒÒ±YŒðàGFI“¢ß£ÐXTIw§ÎèsãPÇųýæ)»c77lÃué©s¢ñ†�-î]M^õ1ŽÌ+²±tÔôîáçÉäNœ+0“«C.®»=‚E³q_ƒCoz`KsŸ„Ï@O¶Å©¿œûq„à¨ÈÏ]qÒÌ©E…¶{\Yd?³•Ô ®„Š¯ÑëÎqUÍžŽ³¯†úÐ0»«–ùèV®©wQÂBF‰”ªf;–µ<+¹0wÐ`%m1¸2S™ù“RÂN3}ÐÁkkieiˆ 'ë`•^×»,¢œøìÃpv@,*wnO‘°Ó—ÅAš%«¥¸Ê±¥Ì¾c&n»¡3œ6}SÜòâ;Iûö—Fb@DøËÛ+ƒUe]šÊÀT•ÞÙwÜ–1/§íqX$Yä´ÌB3¶šjÕÜ¢ú¥¥ÈcÛ2ÌiÑ•å×"2ú±ŽO]~Bç¿\-Ëi¦S·ÿc¥¾Å_x/ßh‹h=Êbœ ¶XP‡Ñÿ½gm09Üÿ7- ¿()íŒ2Å­î ö�êW/»=°nýëoøÊì*ꔵr(§P)RyËûÌQÂδ}{çU¸+O‚‘mÁv'X‹îŽ^ʸ­º EPÓÞü37“þfNS”>=`õG¤[‰«H„FïuWí;CXu¥¿Æ²ZHw¨f‡€A§_­#ÃHòqñ{_S3)Ȇ,X’ Ühÿ¼5ÊôÖ Ç1”³çV$“ï@0¢Uf2èÐè0¯9½©ÿeì]ÑÒcWä°Jß»²ésxí×€¬]ô[oeìªéz PÉœl¤sÕpò:ë±ãŠ‹šÑ*® .D Pܱñ½5”Zàú([ohÈíÁ4‹vDÇNôÒ�B¯ÅN-7ÕžÂý~ìqø¼Q¬­îŸÄcè¨B Û<P:‚îl¡/˜ÊD‰Ö¾=güéͱñ9_X:˜7Èf8Y«/)H®‡v îŠÖe7›´,rpŽWÆ) âSç(=í* 5‡àfêI¼kîêÆ×j]›éÆfÈ¥¢'';ìNQyïŠKí6 ^Ÿ7ĬôДï> éXFå³­à£ÚY.pªX­³ód* ²ëá§PiÓwß»‹u5@Io-4tù³§Y½’sR!”Y§×Â%ÀÛr”#÷ÕŸöÞ¯(œ4Lú¶[»È]•rK13È#+eµÝƒ Á¡¦’G4(Rˆìf_/äJ;Äjò¤¦¤¿à‹¬bž½7Ûß{‹*ÞìçD7EÀ;îša[‡í©¥•õJXÛ¡¦á§‘úÜÁ½ yâÐQ$+_ ç0ä³I§ õ~+Eפ_Ùß.$éy.4ѹ“Þ`¿ÖyH¢ãpØPeSì‡íNRÔë¡WO?v_îØâ ÙŸfs/θiÌz‘×gWämYV« ¶§”„Ó»‹G:ÿ)‰Û+”§ÍktG±ý¢ÌNQ™¦WÀ—º£eÔ–ì8ùH‘~.¥-‚Ž:éøw~’¸¨øò(ôÉ¡¡$¾ù®òø(ßÉË|9AóF«“‰Ë-“Z¿O„5‘*L¡ÐôÌ9ú¢•MËÙ—±0\Ÿz8G—²îïtƒ®fiäÒRñY›VAÙ9çÙ¬ ø`ÛT_ª M™¡[Ú«¿ùo ~f@Sð•LkŠs6=r=¯¶ßwr&_è©ü%Œ+¶ýjÑr)Dp?ÞÙºeeü�-Ãßx-<`õzjk¡áEZ<"åyâ `¦Uë]5ßS1Ž¬6Rb< ¶'¸'ͪ2ƒ­o¤�†›âýÎļïŒhò$õe¼è/œ›˜þJí8…Ó…ÞdPwTÚh ënó¸_`Ö*ÏaÞA‡EäLnýÒWÅ"_¡Å§T þñX @¿µîãÓÛŽ¬_ù’-Z¥WžCûcyct´ØLÅÐØð¼%E·7O…1)ÞRv�»+”'KS– .Õ›{:?ùhì%ǃÎQåùXϲð.oW¥M…DSƒr»ºÃôikf7IÊð3×®æ^-CÕ³ˆåÞ½4í0ú1? G ìZ&ê9{â—?¼µZ•DÊÇ´¬’Ί~zà 4)*™1°ñ>©wùÍ÷ÈX:}úÙÒCXH}Ñ~ª¯F<e£ßÿ^O¿b¾Ðï‡7òÌ2Y–ª1¿;€Ž\'ÓkÙÀ*/–†FA®;ÅAÄøU´4>hŸvðÇ’CŸ-”0o”ÔïáѼdÌ„‰Ðý³±w(¥ÐÖÌÍy)?—±(7®XãŽ>jm…‘”)cJÆâ· C“Ýë3úeX*¨·0±Œ}Z}6žLÕþ÷åGúÉ"*Àp¤ ûùÇCeíÃß+äöêƯÞèaPíÚS<ÛV÷Œ¾à©›-i®Ÿ™ÿ;ˆãæè]ݳ¸ð•öim×Y$Vqzrt²úåèÓp¦¨ì®p-"ÄÊ cQnZEð”v8: ¶ofQd4ÇeJE±| ËÄÒ™Ø]Ì8³˜»ü3ÙýÌk¹Qn©§,tG+2C;|1†qëä‘qÓîÁdÅl6j·½aÑÝÑ—[·½ôJ¼ðèS À oö5Ã?TuA ðÄú¹0~Qç1f÷aW¢ôàj8¾ÊKër¾^ç6ø ó®óÄM×8+,«f>5ƒƒ)ž]¼«[šu¹RM“ºCÑ©q¢”»¶qùÄ Ãœ0M\aÉö*´rç92úÔIÙP}ˆ}¨X¡ê+ær±P`%/¡ °®“ yß4dÌu;È‘V5fbZ$ÒŸÖ?;§û—WBäžj4›3’$´Àßû”C³ïÝQû�D’–nFž‰)aä+ qÕ\„í*YxÌï]¹À›x)‹òЃ*Y=4²l"sW͸`¥}c/y’¡¥ïÆ´kµ½ JåA ûŒuuî €ìxKÿ=2 ónúvµ;íÁÐßRÊ¢Ÿ¦?6óʽŸûútWÊt–‹sÆ”Aã,aO;×l0ºTT† ô_ DøÇ"gÑÊ—F6f­Ö\˜Hi^Ö tÊ•—ÚP2*Ðqý”lqW¯ý™t» eüPÝ•A9©–iGym ¡V<æW”‰¯/BYçͽS‹0w®°»×ô~(ûá’™’ƒmoÛ¡•ëÇ/{&DJ+žœš÷@ix¶{WHA^ìªÆ#9³< n (¶¸±æå~ ¬ÖxˆOËöÝr˜€‘‡GO3ù½Ÿ˜WÜÕ/²£8Õßãà;gçȨPBtuÕépÒBQÔ¹j{d£Ñ]|)7ƒºä”­ÑWß{â"ßêúGeê/“ô[ÛÊÏ°O¡—]ŸœÅFÌiª·¿¡m0бs§ÖZ.täBuFßbã«ú=„ å0—¤Lø`‘ëׇ÷a”¹T, SŠ±‘MÍA¾1 îßúÕÐË—6@¨úv šõ[€<¶lJ9röG:ròÎïiP€ÙTX_CHþ\ûÀ!"L£+åÒÀq«}®&—¾Zïåô¬iáî7››×e‹gwíWD}ëqÅ,RÚªæ?ðE«Ä¸rÆ»ç@gX´U¸f©¤VÍoüåSþ ât¨J‘S§…9‚äÖmÝâ¬N^5»kq¸Éðƒ…¿mk§™¨#KÔ5­¢U$@.¢X`…]ÊÔŠ’Ÿž¾Çþcï*IÁrËVDòMö_’•ó K±m§žåGõRV©[0«ÌÏ„)¯jv”­XKœM'8aÚ©Ó!’b¦mÞûÕ3‘à¼pá)'㶊F#¼¦»¶6-¬£´^z»µÈùFF6±¹\lÚ¯g¸2”çÚK=ÙìA*h¨*ìÓÅð“rØõvT2k»ªL%³ê2Ññ¨wå¦-¹oH/ñ >*Dƒî>Ãü¥ö²*™HÓ(*mVôO[Z!“ö'æ@æõ*CO¡Á3Õ{2óðõ³Ðª Õ‘ÅüeY&zÔ …ÖfÃäAÕõå >²3T×üm™¯Oo,Ÿ§Û¹¡³M§Aþ5RDïþ!)-C”=`h•`~Tf“ …s¿Uÿº–ÏT»Æ®_±x£¥ÖÃz“Q`ý<yÅú2z7¸Ìc3ê+Ž(¦~ ›·m‡f-îÿÖÈè.ôBÛ>cD=¶am=t,>+2ÚÔ(JÃÌ`Š¡ß“â— :/ŽÝ¥O‡7Uëênì&háS€°uüåe„Ñ�fÆ“°ú½Kp/<WŠ­´=¥ðÊV­øg¦D:x<*¼q{Ø®'ïä\_ÐÐ4Kâ¸(tÀ›‹@€B.ÝYeÝA°Iƒâ½r1êP]å¦_+<ž …+T'V&‹þFÛçAÚï|"êÅa³™Þ¨æ9.«à£xeîµA;\?Ìon%”KˆM£õÏ(Xw};Œú7žù3– mºÇ»#åwï_ó v k˜X™€CÛÑš�Ï‘ý®¯~nª5›Ü,Á8]Å4èÇ8 ¢ùìTTÎxŠ¸5VK¿{ÝúÔo«ËCúh®p˜È˜@Bþ¨prú ¿Þlöêösí#ë¦,Œ3¸ `š1×nÁà Û=;îéAØÉæ<Žsç)g !aP½LO‰t½ïÛÑØy ßt[­"š³¦€.Cö>:øQK%r¿c[5À4 ÓWRÓˆé¡;'~†mL;²ï<U¹ð`;ÖIãÞOqjažùÚ-ŒÚ4Xµ*J c:9ÆöÅ«ôИ‹Œ‘/ŽN{NͽAãa Ì]OÚ5”½¥Mb«ËyuÊéÖXú¸›ÓøLjÎmJ¶\<Û+,o:ˆŽojÎê™ý‘îzhs©5‚³†ø³¬7‹Pµ} NKÍph–ºüI:Ž©B,žÔ~åž%vÄJCßÊÅkൟvöu¦” 7Ó:ËãIÞ†uÏV[™Ò)Øì«y°¦¬] ­èªß–RÁ¯é ùêRLÛäyKl£oŽœ`<Ñ—qöZg;†I_¹X]Qy§>f6†›Ö}´ÓÙÚ·=ßVý *1, ‹ ©¬±À:ðx!”~™4fÇÀî×&I‘.j$P×ò ;ž}pGõ>wŽŒé6Pu“fJ…©TÏSË°„§ ?ѧu4¦ôóÔ¶¾æ­Ô–q!W¯ ä™oP‹y Ú{U柞ôUZ2Òª÷M#`óJWkcqºèël%žíZÁRÒt3òæé,§’ðÐüeZè–¼i8 WôØÒ½�1æaä9ÔRÎÄpI)ì­‡…"336¨ô ]¼EJþ@‚ õÔkZ¬Búˆ”Č֙/g¢,¼Z§¯éØ›aÃâz˜'0Qî¶`n@´‡Vï3ÜaÍ4ìumöãÄ/§óT/Ë%¤â5 É6:·ÓíÑ45=Tª–ž¼x”mf%]îí[z—þb²nJd›è );MIEa·º é}R0EaîëÓ@”�D†È:2C8¿‚I¼:²Xƒ½A¿+Éó(ºv·›fdᦔ]WŽ3yÐc„ÒŽ“–ìåES ;*íþ³¤˜³Ö¡"»ÈÜðýqbà·¾ºƒp“ùy* ¡ôtöñ`XÇ‹—æÀ YqHåDŸadZ«dVè–²hZœƒ™~Kµ^´2¯EdžPEÿÇØ#�5"œaI×Õ™6ö¹*¾D…T&è©›|²o©¨_jÕ~Z¹¤è1üo9®Ý¥×=ý;È]h5‡/ŠªÙ4[”„LÞE ­¶N½ Ý52{ÿªEV†¾#Ô*ƒ´åŠ;ý2½¦OÃÙ ”5…ýÙ÷ 1¿ÃëcÏ,Ÿ¶¡ÞÊ1ì…–r~%#}ä¯Á©Äöí•( u%§X®ýIµéÑæÇÎÊ]y¤ŸÐ“ûÈÌ@ß°œ.f3@>ŠC@PáôBïÐ ¿ã:eÙÊW€'p¶V½7$ËüX,Â2ªÑÛáÓö´\°@è¦=àjÅŽ<¾B¦s »¼U’fkúlËÛ¶@_îâ†ÿ$ªT¦ŠµfŒ G< ÀŒ^ô…ŒŸ3z¹Ã9@V1VÝR`çî/½RWÚ %Ú AdûEQh<›ouÒÍ™î+; #ÓåßÏ0.®ã±²¸Çˬ…ÛÏviXmº•f¾ËXs53ú©ë‚ï sžYéd©Ï‡„(Ü|Šz²Ž‚¿VFKŸ§?òëEFÎ!H|ϵÓ.tƒÜ4 â†p/yík�ê4K=î"ñ"6R5y~.å8'XpSFó�³k \¯^MkÂç=weRÙ|±äÝ¥eÖ ¿À±¯NÞÕ-ÚÂ6­.Zãƒwëó ]´ÝÐl*Vì¤Ë 5QOÛ³êþ§H°~K#µ„ C£õ2í’íþxÝ®+í}ËÓTµmãú”Ô*ZEÀG`3cymb;£| šÖnBŽo&ºÅÇw'� ’&­þw4·(÷á«„qèì(’ w°SÒ±<ísõvFÄlªP®û¿E#=õ´ëVl{Dâ¤ø¥8ÕÃd2 + Ãs)ˆù~ÿ ¸ˆ¯&…wæ›Omј>.›X8»Î»NÎéK)‡6 ’?½Nvêêåà YÁ6ª€17—zAMg¢ßÉàq� ÍÅ» ¼ÍTh¢Œ“ã%·•¿e¿ rŽV¸+ðËá pmç9`wÕ‘Û±·[‰—¾>ÈzÒÌ£{±ÒÄ~[)[’…L/;÷:(ù÷-ÎÎã«­‚Á¬F†û ÃlG  Íqo­~4C\ÏbÐ䋪ñäéÑŒa-ÓšEŒ˜Õ« ùÌU¤¦ÿi·qu ÜXÕwgæáߣoîm¹÷»î£ <}yRÖt´ T«Xæïߦi‘^!kÛ,HŒ"P/ÞOGQÿ_ÊT„I¾òÄA9¯J:Ò*ßÇ»)±Sy <šgí‰(J½î/pF5…YǼ\墧:mÀZùŸ…+‹ïY¶"‚E‘Q-Ÿ³œÕ5¹yc¾ÉR ÎÌlïþò‚gI0̓3E˜Vc#ÿ­á ‹ƒ Úílàx›»ÇIºrG_˜KY_З‹gÚ•ÿ®¢qÎN…²÷Û8 ÊqrÁ‡Uèßµ .cjÇ^±*úøH4õ\D8á·€¯m ±0‡‚‰{¦“³Û÷Ü+CWžïöGë_óú�Ïbˆ–y€kVøªw ŽV(WïwŒ£¤iÿħ¾Ô „Ô­GÁ ½3Î9¸¾†f¥Çf‚E¤ \XWð�k8ǨޞՓ¿~5ªH*ÄŒŸñ±&›~_@cª½U—ü¡vh¾ß³ÙBÈCñÓÙuùr3½îÔ·¦y#è‚!…š—ßô“ÓÄiîpMp�âd7i+#ÿm/aþ 7_^ÒQãÐW2”6-e?Gë¬Vš=-÷C¹Àׯ‹¦ÚÊwNЗ[M¬JUºi­ïó½´ðw(N}ß¿H½YÞ;“ÝX£–7ñ#?_¹àø”ø©w W¦ô¬ÝŽ¡±~«†áÃf~Q8—`ÎüX|wvØj­úu›ý… y®ü.6Õ°Ó™jåY!Šqžj¯TÊú·c…šõz>öZ Œ;aÆi,‚¸W‰¡<ŒT%0kVk0P( wݾ/¢†ÑµÞ¿ó"\vMo–"pSš,$6ªEŽ —ÁÓEQ„ž¶3¼à² <ª|´X¹ìÇ)š9xýÓ“•þû˜ÿØS[crŠ« ÜÍÞûŽ´yÕsö#Ø@¡9U$d@_òyqsš5R'Ïô ¢/²,óÕ¨êºV“¯KÙœ>œâN­ùç±í›‡°ù•ÐA¯/‚hÖägÈfàJPúõÈ2¸Ò˜eœvͯ ¯`aÂÝ–2çJß0áá9<ÝÅGxÜyÝŽã�ÂÒ=!ËUºÀs–˜ïäž-IìŒU«ã‘nàø¹/ñêæ—c; •d£Š |$­¯Û¿\,[ ¦uOúy Š#Í~»G?Ä]RÖûçQg`DÆ£/…€3û-JÉ ¶4ÍÃBrù˜õ†>fñõéÄ®U;ù!t–ôh^<^HvÜiCÀ{¶ì¸ñÌ@j¤W“<+sŠŒÕe2ÿœ©ÒÁÆpì©î>,ˆŽ-ÜÕØ/ ÄQÏŽ Ø’n!˜óm OWW¦@çß±ÕølÔk5 k:¨ù$ý‰wTîm°úT]EQPL•g˜´­x“]Z:K:}y,Îf©_/ÓLJ¦s<ÿñ(òmc9ˆÿMË™þLºœD(/M¬sT¹àvi°ÖTÿ›`þúÀ/ŠÒ•ZjÚv©µÛžæ¦ÚÒwšÇ\S�á ÖPÇîI†©ÓÂãåtøH‚h[;ÏÚó"vŶ-î3|NDzÍ€â?ßýô':Ê•W©|¦;Õ9#μ¿ ®Ç£6oá`$ÿ”^iÕK*çuKãØÙZç! Òœ7ÖM» œYÍØ5‹Uñ.ª­¡ÌÞø½†Îï•ç~=Ì­³Óè°FÐîïÞæ=n›ÙÕEÔ“Tý‰ÏfõTFvyM J ç‰Þ¹hµc$©G·c'\ª”©–¡øHqǼHߺ£òIb÷~i€ÓÖÅ™Vì�¹b1¢àV©÷¿m”Ø5ø=®�N ¯e•a"q/ÎzFãã6V=ú1Õ(ó%Çs>À&aö¬åì%ÇjžÊ™´ˆuí¯Ýploq7öFª(-ìPªÂ+ZZÇ­™<B{„A¹“¿Çªác÷…Á©óó öÚÜ~z _6ƒñž Ÿ¼‹‡CÝ.Ð×[{çxÁLYQÜ-ƒäÔûþxqª,tt4‚½4^ð/Q¯ROÀ‹ù3=öì«3¼£ -a#Vùvê=¤H11g¤TâšW`€ “ä›óÍ•!Ø>§b'‘.»R5ÛÎtS?kÇׂ$á0Ób•ž¢æút,¢Âx"X•\PÓÑ ü²žvì¯8|L¦óWó©+í#º?Û=<(Ö˜KfÔ8b‰öìî@Ä×1YÊBd+¼¯i:ùócí‘mç¼ôþ·ò²ž"ãZ¿x msVÌ ˆ‚oÕ[š,Dë ÑÂc»§¶–¤2¤~%‚°Q;{ôPZtF?Õ45~.–$Nå¿DÐÀÏÊ>Ϻ™SÈt*«Z=¬w˜p}qßöjåßѵÇI,–ÁÇœW¿ÁÈoTÛ_ y|Rè+§Yl³|Íw¶EœB‰'MµÓ‹}¥J&`_ȧ\×|a³ žo•ѧo'ÈwÏVOqÆk”EŠƒÐÝV­…‰HÌg€­ŸùXõÆ|„K¡ÔþoLN«ÊTƒzõ¸¿™Æ®/̱ºécÀD*¥6Ø|‚¢‘ÿµÜ4W¢é²Ž@Äy áçø-Ò0|wž´EÜ *5(‚#¯Ðce]¨H18ZrI+±‚*TÞ—’K‹Eõ�^VDÅòôî l©èl)½s¢ê÷K¯Ô‰ò…än&’Ð (<…=»tÅÜa¸§Ç°ZÀR¹GKæÓS<xÁuàÞFæGqiZþD[ Ž3‹.¯íNˆCBl»,XÍU!#‡GŽ`ήt<j2Ç !c>äd†Y´ ÍC7¡ôºùãYOÂoÂî%,î‚eÕ=M\s;´ñC›“R0.®»H³¹t¼ýþÒò¥½bFÍÜ ,“Ô£Ó“wPòÜYÒUé£UL©:³ŒÅë’8ú®7…ô—Qª¢;Bu”â[“GupèŒlä͸‰|¹Òl©ŒénÊ|Â6}Ð¥y0Ã-=3&Ö\jºÂ“„Aj'%'Œ5�kaÂß3‡“Ò)ï†Ü-=¶±ç"b„*�êÿ¥€±Û1…dñ})ßgÓ H¬r·êv°3§>r‡ ¬öî}J}µV¡©'J¡Â“G‡<Ý~ݾ™tÓU_oà㘠%ƒ¿U#ºFçÜÐý*m›«Èn{ÍØìr(�ÆˬÀ›¹v¹òÛã@2UaNQóöë-UŠ-œ—ø¾( ¶®ØwÝô~½ƒÀ~ò§ÿÄËÕ•:æ¸v±m<7ëymˆ‰!!BÀÔhcfÍ„Fæ{ÃÇ ³¬()üA VEKû/~ÿãY ÒûU]3Ù&©9Jùóù~;–,:èq°k’ ›O–Çz;,.q`¢þL…dÉ<ÄxlÅœÅè HI\² ”7Ùú;4$eŽA¦í0…ýpfÝÃEôt‰;ó5VÐÙÈ‚|Üy½ÝÝÐ]øÉk+…½ '5%0ͬýƒy¼Ü•ÙðÇ<l‘€š#«k‹ØhºaÞaÄ.´£„™ìövWþÓJ©H¶Vuž³UŸ>Ö+�V3L3?¹:ˆ^Ü`œã•›Ëä̱€µ{éÇÙŸÚdÖ=Ã@ïècŠó˲Æyæ÷†�›‚yùnɫа€UÑuœèø>ä÷haîêKº gZ{ñ¤™‚†cزچVìV;ZBr;¡[Z- vÑ ¥Ó¸‹ä—§53 :˜ºjT<e€¯î€Ð³ô Áš*Z±µ“•f±çKßœô†‘clÿµWd.¶ ¡cXÆÇλÿ‹QH¶ZÀ¦CäÕO×Y>f˜©€Á�.¹’è1Q•€ÉÆáꞤÔk{éñùèg¯lrå1®[ËðÌUë¥ê«q³ôwßú-=ÌVO!Lÿ@ÀÜsg ½òH;€ÿÉŇxIÜ”ö„ïÚÇ@q$¡~“[ûýD–§µ¼Øjž»Vv°»êlæ Û>€DÊ«›ÉqmáÑ ÓïFT@è<Àˆíö7¾Ëè•X&“åÚœò²”+‘2¨–Ï摹Óí-Íg·IvV®úl{ˆhYšÀ\ª?fƇùâ3®bxÅÁj3{ê¤mÅB›&•ñsTOvG‡Žù+í}xÅd²®/)¶Yá´R*œúWR9h¸.Þ¥´÷ìr³ÜÖí8 :Ô“ ž¿I˜ò0Ðœ•¬ör}—„îøbÃâ¨EóéAõ^ÂÜ%ø Ìí„ðã]]·ªŸ¯Æ#Üûs€ØŠ1ŒÅî£ñÀ, äUÓ@oÒa-û A(>aUÜØ~7Úhº–¦_ÂÝ*.Î$]ùè«#ŸÄ\xS ûT‡Äõ�òN-x0äge™‹ÒÞÄ uMÙªÁ¼bÝÜJš‡¹m}Ò&£»”ÔŸžÇ }æ·µX¿j@­Ç=Ø}YªyÕcÜûÞ–žƒ¨œIœÙC2ÒÇí*‹Ay*ˆã¬=DR<÷= JËCq>ÂÁ¢ukãò«¯†ïkß•·Ìº¦ÖmüA”ÉdPíI3œ’XfŠÙi齫QÍ04à¡ ŠÏ™©Á¼ …ÔýZû‰zO¬‘;Š Š¨¦òteý;²8 ‚E}Î]sÃJõ\E©Nãá̬fi…°ß³à8†žÆ84§ªÛK#Aj×Q¸ ׯ°©é†‘äåïé€ ÅxJÞµOtF¯œÿùW`ž.„€JcSï<õ ªGç;ù: >צHd€qÇ!§èë¥Ø-Î$›gM¨|K+x˶j€³;º›´@úq!½þsî¨ÅO¦£Ø²—A»ód,Q­ªÒëhTÎì…ܧ+zÙjµò1 Rû#l!ÛÆ”i=ŒY°9»¡³ŽuÈÌtà{&«n&C}�ªÎ”LöG«07 \óë© œ":¥xâo-P,‡’âó½ì,]Àr1³ñ·cQs×åG•š›N+ºªî² í+C´ä!ÃéÇ8gI(Úéôø;-Ør×Äå1ìZQ—TšœíŒŠ­Ñ9V±ÇØ6Í~^ïÜÅ­\ðÊQ~'Âj}eÜYÁ;|K *½Y—fuž°¡hdO Z|µ¨»¨¢hÖ*×Hép™è^ ËŠ…›Wœj:Bí( (<*¹AÞ´7—8ÝZwñHª1ŽÍiz`ÇóÍZg%ÞY‘k¹%—˜<9wÅŸûjWYÒÌ€pØ_8þÔ9mÊú° g£ž| sáｆ‘ïÆWêüM•{fyì[ wšftlZ¼3NQà—ë;SÒUäæk<­¬ó”–{gÁ¢¥'ìk¸×ÏõæO†ÍqûÝÊX8³x¯½¹a ò|Ýá:ã-¤ rû=Š…4Òƒnô§ò Wª‰°‚£OÛúbþyWZÒ/.Á9‹fÝBÈPôŽ­Â«Î{HÇîìë¦íàÎUÞQhò/¥ó¦ ¢ÝÙ¡yÆáÌÌzΧMG»;ðî®­ÝPé6å­ ejÅ{å `Ý‘Z4'ëØÐi1©v˜Ô‹ÜVÞn/°žÃÓNs–.ó߈AÌþÚ¡õ#9°žñŸ½O ¯+ïüP|#óòun˜7èWáÍ-Ötj-’ OÝ—ðŸ"SOŽÂ;º“µEy¤â˜”ëNz G‘¸#ä S ²‹·°'¸Ð{<Æ8=U|IK«…%’ÖܼêŽZ· {Âp‚¾ móÃÖ•Ÿ„œ‘méY·q*vþ´YŒõäÖ«Û‚Ë)Wæ†vµíROMŠùmS©0^Ëüõïu 梾÷î!Ö¾.‰Eùm§‹š6 d’)Mìѵ¡½U€l ŸÔÐôÜvXÅêkÀð×¾ÿeí îüê‰Õ•z©ÇGsú7%“ÕÙ|n†ÁÍPÖƒékÛ‹ ÷Ì£ð„i]±¼rô1Ý–cÏ`_8†³ˆÁz  :ŠR�„#Ѽ–ê»I0EZ•ëaøH‹š Ý ¨ä±J:xD<@€±ÌoH¢k¡„-)£]Œx½ZIx3Q)ƒEtnÍ cáÞ3îÂRö.Ž½ŠÛ‹ô.m€~¾¼xÿò'¿–L¹Ü+²ØNÎòAÞˆÉîÎê÷aÉA™XyñêqäŠV¹oX™#.?L[²#|zž>9ݬ„ç*1“TH&•zÄCÙý Š²ïߢʌ?J|úm;Œ[u4¹RÌ+à;‘,ZyòahOÕÀ4ŒÏlã8î¡ê§z h  ÑåJx9 ¿5.N=Ìr©šPi÷y#Oq�yƒ B9Â}e¨—T¢"«Õ.”Ð"ø˜!`f ?%Y‡lß p1¿ô.GtrmÓz~IVE(SžiüÖ�º#«Æ´°M£›Ïz84‡’ƒF¿ÅcÍ«+Ða‚ì¬ Šîb5$Œd¤ÒWw–À#sÇ*•¦fí´{kÌʸŠM”·´rþ~Èžg‹ÞyÌrx±“MÌ Òg„N»Y?Å ýáÐ~[ÊçVí—«Õëöw¥`?E$…õNÏLÜÈÀìXÔQnŽˆ¼ô_pCÑ Ó³ Lð\ÖüíÃŽJï„àAk@nzÔ[¾Òü`UÚ¿E¥-œ…+Àtl3t¨>Ÿþ}CWTõNDó­¥óÀȼJõ³\CìŠG�+è¨S1‘µ­kÖWtFòËŸ`©|Ž";úÓ¨âØbÒ_J¤ÕZ ¥J» óÅdæ°lð~×ï< Kä�%R¦$ˆÊTG«¡ª¦Åðlª^o¤ Ÿ…tË z&AéÔ0îCá'¿ƒÇÖäæy›²�Nì—WàÑiéCŸ"TªEÚÌ€õ ©’”nM•äøŸ‹ÔÜ«c†ó· v'ŸùƒZÀ$ÇñÔì†öÚÃãÆÒ£t†ƒâ2<WÐquâ§Vÿ\If©`áòÏÇ—<wë…•9µ^mVW2!|ªUÇÖ Öpÿ_̳Ã4J=Sˆ ч/'5**EzFŒ3ìà‡‘Eüg^ã«æéÂæ+ ê,ò¥Aâ¾;´³rOtµC¶á_Ñ-g2úM¢š,¼21vCÏ°ò%{€ûol¬°hÒÛ‹; µ¼à±&�¦mF…p£YË‚ îœdŸ%=|ƒ…ˆ37nãnsË}Œ/ëW5öd–3³ ü¬ovû+ò¿ê"yŒÛZ8º²3Ÿf02&e©²J´ÌA¸« Ǥ΋-r{áQ‹ü¼o_Ð>ýíæ h±)‚猕1h¢…ÞQÎx»0Ëðj*Oyw”ó»ï,@ ?±h!¾U'3”¾þý}¥2¹„»ô˜{+ÆG´tºÛ.9þÂ…Ù"Œï_¦(O¦þQ¹ÃïG´£‚²é='´CÛ!ƒü¯ÔïÜ ÿÆü µ2Îï©ë½;pVÐ L~ C×êýp“ÈÂ-¸c£ª‹+°ñªñâXUìcûàöÞ4›NR_GOÞ©iÏfåsw¤°<.•¤‰Ù½ŸÀ¥2&Á^{B�Ù fCÿ˜ÞU¨eß:d/ÊÙYm½¡÷ß½y€œfÐ ±r߸'fõÓ3èô*±Ù†¬µÝWD6ˆ°ÆD·ßø.°Ä£ïùf‡]c é; ׬OpòŸ§"ÈÞµ“F>E@m²¥•~ýzÝZ·ý]YE¸<›r‡Üd[F7`@¸…ê´’ïDÕ,wÖ`9NùªÃ»Z¨AÄ,8.få~yï7,'¿z¨ï_´o€g øèélk›…`nóÖ)ôzÖóÈ¥:]ø?³›r¹¸£gT„ãw6$¡W ãBϬZ”n&H4O“×ÎLGùeúä)O>w”XôyôCz¬qÀw2´ÞtÃÒgì9*²\¸Ž´œ"à4j\¥Õ(à×7ö2"²<(c£¯K`yê<&N…$"ë&+C™aê¸V›Å²$¼þ$•Ww5sŠ ŠzNVFpA7é‹’ ,0ˆŽúmÉEÍÄòRóO#SE ´õrðÇMM­™a�ì)·ÝYlhâ»azšóO<­_ð¼æcßy^GÆS¶mnþšRÄýú¡£¬7¥Fb•Am’Ö¹ue‘ª9…uÄS^u·Md5žú«Õ’Å‹q5¸¯Ç2­šåšJiÊlQ7xêtj^“þâ@îÐ(’°ôõšè.´ô¢ËÅ´W¸zKÞ‚Vý¯©tEÓ½z!ë¿Á«Ù[%ÎÁæLèý/¾Ÿß<žXÁœ¤l8ÒÁ䇺aaT¤ËÆÞÃÊø½·*TÆÕm¼´7jÒËÊÐNpgeêÔõ! J7wgæ‰è‰šz åéa2c%{é€N+GfÉ°½v'ƒ­‚w¿ÛÞ·4¶7î‚[tÒb­Q°tùá¿XÖª¬ì[—ô1Þõ‹œ1a×j¦·óä<FæD…†YmÓL·¥ô;+G¨±ØŽàÙh U‚ ¶Éú ÆQûròÀê)KÍ{}à™>pŠª½Oeá{cš!W—ºCG»—ŠCQÛNCÓaÞ©ÆàÏËØdu uFøn‡E9Ãj¦7¾c•v;\ÇÊ xØa£¬¿4‹…Ý<ktÑ&#×y ¶°ls‹Bª0C³H=ô„FÜÐØfª”1 P·¾Ý‡Š» f%™h)…4ìoý­ ¿ei•nY‘ á« >*׌iªˆ&p…?¬ÔÄíhy©W "F¥ 'ˆ0hz*°6;OXMNS†pµö²át˜{Î-3›ÎÀmï4€ÄíT"ø: ÎÛû+žG:׬”Ó¹°ÌGíè<µ-¾ƒ¬‰<£9d2làœL 7¿´Ì‘iiÉz×Ìu7ëjaçüÈÕ9ÌW )ð¼ª$È-[in  ™òª®_oZ§…7›eûº©…;§Žì™DÇ6,suÆ=¬œ)T(}I:9àM—Õұ»ð`Ñ@wÌÞv§¾¡þ‰¤NE *u»<(ß•hK]Ժ؎€ÏbÚ¸;v`ÔïÌñ›­Ðñ8c.ØëG ˜¶}Ô‘3ªluó½oƒ¦šx—8µ®4vúkoéݧwt;|‰‚¾.H6ÄÆ7ôŠW…öR¯RÀ.Ls=EÒ¦gZZù¾â—NÌ g#h eïTÅ †~87¦@z:š}.3Tú2ûTq ]DÇÊ°]ºs‘AA¾i¸!« óãÛ8.S`_±yCä_ª÷\x >™É«SçS!ÿ ŸÐ¶RlMN4UÞ;ךù€P••´¢*/««$®«$Uç\As³][©Ût‰ µ T¾½äûN[ g¶Ô· é¤5ÕŽÙ6²ŸÛ-“@Ð-¿sÑ\6í¢ãÎM%Z=çßåŽjó—Ò¤¢ðRµš£üý¢ W±/jÉ©Ÿ¼Ïži–ïÄy°éa½œæÙs?,ͽaÂJeíƒÈ€q63æ³FOQŸ¿‚0QËSã1ë@4&ŽÃPMo¬-ošsvº»Q¨w½ÒCuÙˆx‹éòÒ±ÑêùÑ.qíB)ºX }Àl9åAôéB>«Gàƈ¦t©Oþð0åFö  9ù¡S�þ»ak3ÞT$¤D³ßüÅ@÷ÓÜ•ä¬PÕ\hÉ_Þ²¦›[·îx¤8!FœB¢]üô@p1Š|»îúQ$m§™GºþòþYëÏw¶.yZyÀÔàâ!èX5Yd2M3”½o%‡~^´E¡×føõŽÎµ¼-˸ªmC8¼› >—:Œ|…[FºÀ^¶ê½‘?­þ4Ûªßè õ§Þ”RÒß^¡_¬;’OSÜY/^ëZÞý2|á×ÌŽçóFìÕ箇‘ L2 ÆE %ÃSؾœ>»¨¦ öhøš[((aPÌcj§–t•®7Y¤óųºYæYTn°è;þù3ÿÖÔé# hçA@+ÚΩ¼.>§íôÜGL>O©ž,ØÜ=Ùõšg˜ZB ‡Ž¬éÍ°£öîmÞÓÔ‘ÍBfèÎgŠ«^‘öcÅRhí¤Z©,Z„îi ‹"ŸßßšT쬅KÐ*—imZǾƒÁ4}v›?TûF°?îÊ”wQÙ™·¸ÿáD¹zo<\Q5:ŸUJŽŒO7ƒÿ÷è@¸ôË Y†îü­Å¨Ï’„xúY»Ü#„QèœÌïIðÃ5N=Ñ &¶4=¥y¥jìh‰Þ.í´ Ÿ à’sËbZ\ÿ…ìO¹ðÇ£:²NøÙëËß_ýÞ[òû> òžd¤`vi…q ”]ﺨçýv+`öšRöáà~ñ×@ägÌ,<Õûò?fø&糨|rTóÃSGI¹2îܧ,ÝãYU³„%þ;-w7¬ÔúP¯Õœ¾d½£›ü~R±"}ûõ¹�0×;$Úþ÷ ¤%wß»þwùßbI‹„û+ÿM¨>‰Öt5§ˆL¡À "^Î\Ñ�é%Ûêxê¬6ëÝG”.TW(ÿ>ÐIµjFOhÃÀIìinèÞ{ªº–D¾ŒÛØxkw6¶Š©:�ÊÒ\VtÁ´ào\úq¥áz˜m¤ïVªÂ„ªÇ1ÎxnMþ“*×è½²Ì å#ª¶4¨ró—ŠÂ¬o5ú¼œ ,ã5¢Dü1‹“mÀ¹†—¹m—©?æ7>™Bñü–ò•xñwmÅ…‰Õª–<öoäP˜­eYêÍÙ$œFTi§‚›’ÌÃ3'$ÒR°¸QÄ6ÌŹÅ,º¿ª5,üL‰9ý³Û©2R¢8šàl5RＪž@™úÂQp‹ kÏ=u¨¬J/T9CÜU»™Nêš’Ix5DìÊ k·ÁÎëfø¢çõ[KÝ{÷÷îi!s£O±¾í ŸxÒç˜1‡¨ñ½o™ƒ~õâÙR ô ZÕ3†cí_Ÿ¯= 7—A÷ÒDEµ(é·ÌÚ·"_ÙЉ§âÙÂ2V©˜ý?ÑžˆµÇª¬Û¸ƒÔévgØ28¯Ï&dÓ?MÇZàGÏÂQè¹m³(só5{£OšgˈWô"?~ÁF,Zz÷Š°‰æN×ñô«6P£·ÚÅp…l¤ø!ÔâŸùYæ‹èÑaq(‚´Ò—WNöò~áù] úr¹1Ω5ø­åvö(œü¡lO1Îp—tó¶¢}æÖ+·Êè̇°ÉGùÙÿvr ßœô¡V9%ì꣈öVC‘5dt ßéÒT~ç}?ùâ !?ªï,ÂòÈùE±Æ@×R@ù³qŒ6Z ]s²´œó®%©v8!*yëË­ñ°eËD,ù…)×Hév1*œUÕ°˜×ÊYSn¨ÂG…þäF‹CÃŒv i—†fÆa~šp³Ž•§Ú.ÃqŽ ÆCí‰e}¢ £…Aq¯7EL›ôäYÖ×Ý©ånÃíЕÃmfäpE‘ÛàòàÒ?ÃDoGï:ž½éì@ç{¿å=ûswekNJJë%Ÿ2J˜Þ“÷½XcLÊ‹¡CŒc÷RaƆ\i•Ñ¢Þ£Ñþe1IèõY(¬…:í%Ù[¸îá ®f§#Ë&$Ъð˜sážÁP&îII»ðáîì9«›SøH¦fÔ¥2BC¿ßsŒÅ³·*ÜÖƘh׺¶¶`sožy&¿¦Ó±àÆzû›oÿVN™).ÓwSÛ§y¬(ì Š¥súÔïáÚr<Ñ·QPÜëc=ç8«-¹™õ-‰;N�Êܽ“_hÒnÇ©Ï«Q‘ìû.‰>:kÅ€J¼2žaœûŽ³ôWôPº+z…<³,B8DAÙm½²Óe“þ¨vle~÷ºOAcêé@1lÒ¶è@}|:ÏñSoºœ}@2ìðÝp2/ìÈ iz£eŠ-÷‘=‘‡¢tCfÓ=x 5à™–Ú„=7“Üõ˜PÞ«3›°ÖoÀö欅Üõõɦz<}Ž XKÏ|´oΈ ù.û)ÈöÃc`Ž¥Þ%Vh´ÀÍE¨/謯Az-÷r.½ =´ibmqx\ýäõ—d¼J{=Ê0Œ’Z@Õ|püÀˆÑùöj/w®(ïµnÎëÓÄ·cÕoæá°Ô}ßzKR_Úº›„~>Ýì‹¢Ïöl™¢ô.—#íË‹w5îèÁ5ÕÛúңģMpïWÎwÆà9iÕ•A8Úa%‘ Hž£Y…”ëŠâKGjŽLd¨wivVÊN9’âîê[a=jf,®}7šØÀòXجMBëø²ªÙßÁ~9~˜Éá Bg©Qeû÷þLʼnkI¾õp8VH©ï{l?RÝ/£k#¥m—q¯ÑîPQÊ4ô{Îiw^0d0Œ ‘ ‰îw¯&†ùL¥V˜ÜÄ_™ ÇE›oàKuûîb9ÓÏQh«ÒíßÕ•l´þ+ëy‰ü$ÆzJ›pTäÚ‹b-´r�…‘ŸÁ°…›Ógú<UÈÎi‚†"°Nw¯û“¸8Ÿà£n.ß{/‘�gCxópÊtï 24¡Óp`´@9k]Ø\رv—Ósþü¡‚ë,]‹þV c¤8 ²f6,ˆš ÜÎ1–ñ»SÙÂ,Þwzùr[;v_mÅ8×MißXçE¾?”6Ð:¡ ¤pºu;ÚUt|àmµ×£í K§‰¨: Ê£NûK0ÁAP¸øît¨ÁLž â_.õ¹ŠÈ× `4),­>ÚŒ–an–¨‘êdÕO¸rÄéÊ>€^«¾<<Â:EŠÿæðÄ¥Õ@Œ–B9o°åwÀ晧ÏÑbš3:ÑN~KžÒE5¦X<Ù àžÿèùŒ¹W†ñ9Ú0[oþ¿?¹H4‡rÅÈvi_Ìn¿nNÒ… %=r™Ó~¹ò±§c¸m4º?§ÓEE¨)΃Âù¾¤Ϧ– LP£"÷ý:NÞÿ-–,õ ² ›ØƒÒNYq<µL…CËLª™>„XüÐìO{ÿ«Äľ~‹I˜Å¯Iï½³{®?z Y½Ô3ÁŒ›îHXJù¾µ<­P¤¹ùæ’@UöÍš²óòˆsšyóHfÕuÎ-’ÈkM]òk ~ôÿjÜ×µ#k-©ãùb@²’½ØX0ŒØî­«ñªxÓ+åz’-€•�§ÊŢڲΑÊYY§W�~y"„-IO(q˜ Œ’^¾œ9”§"'©3gT f֋þY":®àiä _® WNiܧvŽa(H&*[¡iÐä6û‘ÛŽzõXä%_F­ D˜qeí(cb IÜßÚò$¥ï1�$î-éŒ-d½èÞQõg.Ú«ë´Ä^š G¡GÈ�Q:èû8(wÖ§/4<ZT�fØmøp2\P„\߈D†™AÔítÓl�um©Ö6Ù'^YúêõŲE»–rš¹ 3V"³Ãsyèú^TaŒ{ Ï<-U!6¨8d£é¼37³fØÊ*ü «ˆ[3MǸy[·#f[/¦§aîÑcÄy¢Pn= ÙFc8ÃjÊ4æ¢ß°ï=8éåN"Ñóô'OA„ô(î²-H²û2²A"#%¨drœ¼šbÑؼ5Àí«7öªI–yœuÑá†)…:= º·½›Ùý#ÁuÕ²Æñ$úÅ÷ti´då­D!ê&³’A ˜~ìÛŠ7žþ™'ú¢$BâléCv»;v°jmSfÕa¨þ˜ü`Æã°ïgwAMÅ%‘çߧ~…B±¢Ê¤:¹‘Ý„”~\æÓî×’îX#‹ÿ„>ͯ¹Q@büfë°­B´kö*Þ2hr£”Õìb*ƒ/žÈó‰õ QLfã³zÛã9Nî-iæ9ÌSXá±õu³ÿrÜ n§(N ¡ÿ/~¬8,­Vë®ÏGÉXó€!ŽÏ‹1ñeè7¦ õ£0ËóÒ*v®¸£`e½ÐáÄ4l§Ro~¡õmÙeã«%ŸwàE´•]’­¨NfM† qA>Å’7ˆÐo ¡e–zÆ‚Ò³¥ ¸RÎM¸™V3צš|Vù&…wL¤Ø°PöV•ª2â±€œ/\:‡ý|´J=É#�­JèÈRøúì¼ûÎ4Œo•q‹¯Û—ÀãSÖm¬N4¦Hè:¿”QðHL_…Ðj€¼úhÕ(õ©@)zò+kiA8£§½üÏzïÖ›QÚQ¾•ì½6K“X;±ølœs·qº4€õoµçýt߈=t­lÂEÿmì¡MbLÅæS£Ø³çZ�¾*@ìãTž<}@zôø@ô)÷“S�ùÓvæÄzØf¹cyˆ@.ìø¾Ž— ÷…o¿°OÂ…Ç…lL±ZªRjEosúòPåÌ~UǸ‡ÀÓ›¨;Pî uîýd|ZÍ°ÞÖ Uçk5§7 RÚá¨ü«’ñÌK1'ßß÷eÃUœ§ž)&Õš'蘩¬X¦àb.Aߘâ7½Á{¤¥ÿœ£ÜÍ?ÑBpÜÚ”Ûîm„Õ¨˜UfÁ7sårËõÿxi:ÅÂà š6ƒl´aE,:°”xtÂã|EÃæÜ4ß'@‘ÓI5Þ8ö —ª{£Çaµd¶Ç Á·]Q´žì³dåƒ|(r² hOSZ­«õ¾R*Ä•èsCÐ<q_„} š =Åt·õô{¤€Òn1ÛàcMN*jøm–?/T™aÅ /ó€É©Á“Á¹SµÆ™xöêU³ûÐ r² ­¾Þ•U‰ÃëÂdª(ÇÙ½;*/¥‚’¿ápÐ>õôI-`‡BJ«…>ónVOŸ•qa«\«l«ÎÞëµ0SdTölFüþÇ;¼€²âxLeq'ŽO‹Tþ(@Ä©ÓŠYÚîHiP¾Ó \ ÄŸ£HÖž9F>z5œ‡¥[ÏT²Œ3ðs®±² ù(W¢Ìâ‡ïu²ÂWÀðªÐŠÔÐö¦ךfó¿oiº´ó9¶tp{þ¿`yìà(68a@(âw­C ô¸:m¹‘îžü XŠ"wy;ö#=ª´k<tB²S”‰°Þ2‰«Ø-iœx»TFòUêˆÛ^ú"ù‚·vÐÒçŸZÏÉ &>þ–˜ÐYÆÁRóôDR(»BKètÐÒŸuÒªQœéĸáe(¼À^XV^~±;»d£9n`üÔëÜCIpÍ5P™ÖA$‹BvSuñ$wNp$çŠß»¼õwNW‹cô§Áª›= *C)§t‹ PŸVrR×Í3²d¹f¶ˆÚ5Y§È3� ‘©»Ö­Ð-êÖ±Ýî§{凯5žìPf‰P(Ö…öäñUö&Ny` •4³| ‹ø)ŒÇÁz€-ÑçÎ5ÝT¯´J,ŒéÔˆmÅ# dͱ;ú:{HaÁ:BÎ÷ñq9ë7®†ÌŒÄ£>B4Ýa!†îþOe'¬ÜéŠ{â«à8B»sòªÆðE¡àµ>t5‚yÒ­N£ÅÌ8ƒ~v«³Åþ‡Š kÖ pø¿o};ÐÞßúY˜46½–Èz2Ý4Üm<u:fé*óËrL)D ÿ¥@ß|ù3¸¬ kÛ¶¨°‚hzïÝy2Š˜¢4(¥–gùš-jøO\:u¬}?0"‘’ºÞ¨HçͶšYr!o~adlžôÌc/2¤2s„DsVþtÜòméVbæ7¯÷EnEy:A;+ñ2îeè`§)ŒcÎ ·r—¼dxûÚí,Sè„ò Špé¸uf$Rvœ_uÍ~=ÀKQ(:òFËŸ<HEX˜rª›`æzœ¼ 08<#röŒ]{y.ôeçû™¢ù&Jwóvë„7ã�)ÃVUîÑMùhߨR`ì>Ú†–©yy·-íüÞýåÊMë S~e,G¾*o6u¤ËkØܬW\F|MY·‡¶ /dÉL@ªQ"k¨þ2æ3do=R]ô…„pLÙ*ýˆún¤S)‹Ý‹Ú©ÌkÜêé÷WV…N·-SFD‰ÄÕd § .ž*Š¥jÜŒÿáÒ_(fý hKmr"O€ñÎSx¶Ê ?üöniOØY¿É¸¾Bq~1pKˆ^ß »êB­Ÿ–ÏžéûæÊ´&‹n†cìÐQüîß½žwMç tD þ˜êO¼Õ J N›ŽAjTÉ‚á_TïjX‘TXµ”Í€~Âë¬EƒHF˜åîÓSÕàþ‡RÖŽžâ®Êb[]×Üôa{/CT2x®QÌ7й²Œ¡v‚X¾÷Ócã²pñ'‹`ý;F)«;¸µ I!öžñš¡ê¶‡­n×VóA¦c¥Dç3›d!ÂÓ-rk¦—JŠí¹e€{|ÐÎþÎÒ-Ò%–hBÞ² B£²nNz$Õ=¯L^íË¥™¦^7$Å!PïÀÒ¬TA<ÔùÜ083Ÿôk­ˆë$s½¡ŒµWÆx¤_JL@mtf 5‹çßó`7“ÂäU]t[&i<ŠâŧÎi…gèo5®I `×ç=ïDZê®^®Iž?a&Z±ŒIk»)®PßC·qŸ26MV™0Xw6c©¾æÿ]«úT?4X”{l¶ææ"ƒu·5…^édhyr‚òMÎ9úþw‘j^öº†ÇŽm`}ì;ä0|D©Ðë×IèÁ1´ÞQ™Òé¦. P‹ø Í`ìnš3HãÃûÛ³ú§Ìý!ºT}ΈLƒ\e%TXÒ˜æÑüó 7+Ég„wmzÚúÉQ·fƒK¡I»eù±çaªšÌné˜WÀ£Iuï0®¯ÈÖv8›×µe}m¼ ˜žªª:ûRxô$•ú·o8;EáØc&tÇ1 ²yô¨XCõáãjw™\T‹Svrésµó+LŽFP%ˆ»Ép˜1À2"Ò¯ù zR@‰Qûä©Pz¬=+]hQÞ¢üˆWç@Q”/¨i�€Ð Ù]C*Ššþíf~Ûþõ}÷|Ú9ž;g´k`ÒhÃnO:é»fI™_9¨ &+Ú¢‘cLj ¢9ýè矨ÿ%¾ROʬ«r_»Êé}LÕpCoŒ¸\¸Õ?º6B>JŒJªµ &β+ŠÚ¦¥ŒÇ]0ö´:½m…»úÉGÅH7¡£Þ3n¬Z¸Õ£p91báÙ¾.`Šñ–—Óߣ̦V-¬½beç6Ì¢ÿø¬ 黩2^ë‚Îí£ œ�TAΧ5Ï–5`7íì]ñfú·Ã:2‰OÊÉ"ÛDFö°@뵉2àÜzcÅ™ºí(_$¨îùâðÁH%/—6‚6N<#9)+9œpr=„y¦ ªô7c;œ±S~ÚzÀK a³xÑ×fî6eg¼*%—Œß/Œ]x—"h½È_K&㪩áÐÝù 8Ó«çDÄì= ®Üðü@_¦Æ¾§ ´…›Ò:¡p¬Ù§z 6DTpÓ*üÏó¬µÈ]’²=Á. Âæèòª£…»«6ðàÈ,Àô¬À¾gvm æœÇs£í¾«h Vºœm¯èo]%‡Áx¢Ï¼?>ï("§u ¾ÝØ<(Ž_ÄÈ~‹f™kÕz¿¸L[(ã/î@ÿê.‡;r³qzå+w€ŽBYP Í¢}WmÙ{ªÑî%VüÙO¡'©“Ý2úcY°:ÚÎSÆ28Ø`kI3pz;VÛþ»¿ 5{§âÂiÒz\QÁ÷G•¦;–QQ2c¡: 3k|÷lzkZRT'7Ït=£…¤ äéË؉å‡øÌxÓʼdlò€†CÿÇ(+x!ÏÙœº»sß"¾–#h'mþxmOL:öx@Ö¡ê!œö¸i©c⸥.:»Î:7š·úäší7ãÐ+®Û6=º¬x',S®º|å‹óBK¬ªÑóC°@¸òFM÷ ò<HºÆ˳٘mö]ßrÍ0W™ Ø‹¯lÑ‘Šˆ “°Öã–è0I‹±|ÊvÇkþyI죩(+ÚBHdÕ^aÕTç^5$kññ¤àoÔ±Ã2µÕƒ8çt(¶âÝV«gº÷[öü¥Ø­jHÕmÆîÿ�]æ^ß&ò©Sä‘FöÕŠj+/óÑÊ1¾7Ó²ÎÚ2)ƒt#üŽ CÏxËq;“Š)$W¯"# ˆ¶òò0]Q”Jõ”JíFS0‹¿¢°má3ÁÅöÛß„.]eï[¬úu[?é²ç~ŠÆVžù!Ì©†ÈžR9[¥U:r•Å‚/'ä@KÚ[ž_Ùʵ_ '¿OÎKê7–´*Ñv†ÛÁ]›yGR —÷ 0Zxªu'ôt~ºî$ͧg”C$Íë=QݨðÑ 8�õP5iÂÿCòVÙÍ—J…4ó8÷›O!›Mmç‰Ñ>"¨íà&F¦à;y¬<w9`)‹ ÔR÷A2§µe¹ AÑóh\,‘æyŸã‰Tã½ZéИ›œÚökZzþ¬ŒÜo3FÀ85F:x:><4ÈÿDWA\Ý€& ÒfTLX¯8.ôxî¿ øQʼnóŽÄâÞEV³½”&0Ðmµ¸¨(i½LóùBñ}Ý¢}¾Ý£±ã.=KIyl!»^$AÞŸ¼ѶkknôêÊS ïbÙ3KR¿#OïÚSAÕÚ‘/Ùbß:¦eÆcá¥0ÌSÀ¿8¢^eG¨@š4ƒî •^‹øo‚A…'@ 6Æõ””AÒ·žD7‹h™oAa\ºü/7 ¬Ÿ/Ÿ+è $AÖÚ|p•ˆ v$¦z†ÿøCÞàêš´þMYÇyãRÜ~_QJV½îÇ\f©·„=p¬¦S<~½Úò|X_ž½Û©]˜åš:΂²¶Ûh¶¶:ÑC(Á•3"}Ú& ’Vë_ŒgZxüt$Û¸ÝÀ¼ �ÆDOïÖÁ3Š#âŒ+ƒ¼út­\çDt€h}Y³e˜.Žhí^¬È¢•„g¸´î]# öÆ’6߃>1‡ EI\w*l$ú$¦÷¾xIÂü0ºcGnǯú¹JEµáÕþ·â§rœÑç­r´À´;Uš©²´£JÚžþ¢üóØ(—ü0í‘åOLBZ´22ÈR$ü(Mµ±¨™èYÞKÃY¯Œ«îŸ_åÕTt}�jUå Wu=Ì“ ñ=ÖûR\§mý/?½¶@>ŽÒòʺ]±óm«Îa”^^Fõ¸­›(*9%ô÷GªÅ²NiÁ©�œ¶X·*ºÌݼ3š,õØoB ¥¾ârœ“ }í雨=3Úÿ賫 b:Þƒrßs\bJJZ+Ã/aã/ð¾‡ö,èLç/‰)«+a@†YåV0sNë“Ƥ1£=XŽo€ötu»[ÃÂÇ´ÑÚ<”AQO–Yˆ@è€_R:à<@»t¸e¡ý$fòb2yDE?ªŠ±ðò§^`ãÁ´vÃÿúVÀÚa†Sƒ9‘,a<yþºêÖán=¡o²„pKÃéZÑÙWíÌ㧺•¾¯ †'žâ ¥>±üg?`#ÐÙÈ?Aô@—öAù>9@(oÊß«É ðc`Q‘~±' Tvv—ñm¾P1Ø}ó£ït,$wzä¢_;êà^¤j I´}›^íë$vn4;4^yû#=Špj½JpÄŽ7»Á½S~i:ÒÞ¥P!¯Ý, =5"$MG»‡Ml:@dvtðUªò=Òár€\ÿÍ…?T[hÏ„é"ñÉD‡»Q–RÜ©§LÕú¿Ä#�¤¬ˆJ %ôœN…fkV•õ¶“OÎÄfZr®ô I0´ÆêÊ·«¢ ·Öå¹d(¾$˜ñ\¾<ñ“Ô}°`û©äBy°ÇZÙÞE ø-@fNÇ"H¬/ŠÞŠ)ªê”þ²‚2eñÀʼè„WÎWyðA‰kñ¥£ØpUÁüsͲĤíêÇG}Æ$¿F{Àí¡k<€ÝÓ¶i´‘H‰êëâÜdg9Ä í"(vŸÊ!ìÚÞ”ê†r#ú”rö›pç]Ü*Ú%‰ÝLm›àÇ™v¶ ‘ ›Õ@“n•ïH$¦>¾†¾þ¹ BK_SG”!Ë4’eQ@ùx3tÇÝýSZ+ ì(%¬Üê!]?‰üâÔÕ€%BÙ0ÇNR1÷AVQ¼P[¡Â£ðî» Q~Ü»”nK+ %6:Ù ÃÌåÆ,E�žÃÞœþÛàZ7=_-0³ip†`e^·.Q÷$äè¾6ªîêf†/P¾ –œ£ ©;³oã”AbÕ<y†%\r๠Z®23—@G.ÛœÍu´ôþ} ÕN€îR#A2è?^uZôNù\¤ŒÐ¥ÛÎ^-`•7µ8Vì#©«_ø×7ÝÙF$Æ1²ý‚¡«fþ;÷Ç°•;�jÞÞOý¸°„ù¾]nÕkÃØ ™1B溕sHUïöo\SÜè17^lI—6;;ëÊ pqX”ÏgƒÿÆŠnUø Q@ÚHÌ­c{üN{m¾íöÀ‘PÞ{Y\Kd~ Ãó:ì¹ü V¬LÃþ÷M·Äý½û3‡äõ±Š îþ¨:G¾„’`5´^þ{è|’.mÝØ(XU›©ÿ5·~$@•Ã(LŽ¥óI[¦ÂM½þY¥ÍÒ•V‚y,ŽËz²bœt«€“S.� “1.û;6~á™ä²Eh½CC¯Ó¿XpŸšî<0Ÿ*ÇãY�<ùÁžÐÆä[µMé˜hYcôÓº|—FôÇTš»¡i¬L‹ú˸g^·9B5k Yb èmäVaBáçB˜0ÎH¸®Íßð7˜Ò{«†¥éB½8 ºNs±Ï>æ Ÿr&ÎcûÅÙàÕ«3Š²øËy¢'kM'²+…#ºùX”ä'Èö82òBaaS(o¡ãŸKýÐ,a1 Wñ|Së£ßrÃZˆÒ+=œö+ ’æÏÃ#~6zëé¿i¹£./6l¦oÚ¹aÚî¼"‚¢<%ðæÿlvèuM#‹]5óµ#îûw-öa%V·üÐGKÉÏÖRÓ4 Z«Ó”qçÁV‡cµj}ôƒG=µˆƒMÏ •0Ò$²þ Ü טÙç–ûäf×ÄE1Ÿ­Òø G6ÏÖ,\Œâ¸Ïaåî‘Ä®w?.•p/ópÅÓñx·3Ù§‘ù÷-1ËÔè{8’îÓÉŒQ„ñæl뚶æî'C�mj´\Cï÷®,¬ÛjŠ£NJUXY£VŸImkù‘ ~ù'o–v¼–%W™ºË‚ü][2òž£Ž"¤K²SºÆ P1¯£'#Bnwæ}åY“íX«Ø™<¾Öë\¸U²ŽeõQË„ºÇ2|ÕÃúš²M8˜íh礳•âOЭæd?ð–+Ë¿¼{ja+‡ŸA,‚âMd»“ÕDÁÅDÁuÕ÷°H½z5>¨×Ñ&‰8zçË@Gil±œ[i‡´/¢÷‘¨áx¨Œ‹t€Oíýcµ4×a{‘¯-–fè÷“¦IµRÔ"Lû ’àV^+4¤êsÛ•fRwŠ„e6Çálçpß8ãB±+uažVæyÅšÆJv­V‚Ü8¸ÈÙwñ½èœ±sÌéÀ*é|SdõèuÖ˜#_þ}³ÒüŽ8è‚5•J=B§LοÞ½1S!óIˆƒ¶*M;½n±8Œ?ñ±bÈäF%ô™Z¨½CªÃ¾>‡Ì6wGÐÀ­QN5ü ߉‘T¸%NœK+÷Ï©XÎèöì¬#"§Jõà�ª¯VÌ ¿2C²q ÿ£º6cjÈã #:‹>5ŒŒd¾$WªDqó z{žeIâÂ'e÷ao]Š+uÀP%SѸ՗EùR!²€k…œ¹„Óèíwí”J÷Ë2k¹N^2=$øì ¹‚‡Ø¹åóð±5È£I÷àxÚ¶¬Öõ4ž„…§sÄ,캡§–ô 8­Æíõ//8ØPv—ÆM xDqq¯5Em‹NâVŠ&>­‰÷nÁ±a„&÷=j×?oÝGV[™àˆ6P…Ö„°dåéC¤¦ :ž 5çÿÿLü‹Â(]v3¦¾¢VéÀ•Óÿº¢EЉej:•­E …ÛyÉ°¦™p¸ALDWcÂŽ±ª© þ¯°\a¬¡‰á@BØ)9rmÈÚZ툼@C¸GIˆ¬ÄBjÔS·'ªÏVïZòìªËAĵMµ´Ý?MªOÄõz½Ûk€¸´”fI«²8˜7HŸ­ënÎû¥g˳°ÁÄÜôˆÌ»q0€{ï Ëké°èúÌ"Û_ºO * M*Åén÷½»„eŠÀû¬Å… Oéš Ô¨÷“<Ñò“-yà¢`™6Wø ¦Æ=‡T)JŽ½E²µr¢ðÂZHàs¢_B“>®UBô$—bpÏ T³²YÇ[Ír´l¯5í†c`ž‹lª«ÿ‚öñIó×hI¡ŒµcÇ4«©Cqt…ŽhTnì‘ÍW§Þì‡nw?†è,Í=ÂyN[“öéxárlìa ÕÜo}½7Qvü¿Ä¤8ÆSÂWzoö’ÿÎSB5 ‘1£#GNÚ¨¢GRHÉÃ$aï¤A«®/öõ/¬8Žlì›cÖÞ O•¢psÞ ¿õß ïF¾2º´8÷ƒ¬Õû‡€7ÃβµŽnm�ˆ•„“+ô4I¬fM±Ã较YomÅ?…í²‘' @ëÆi|jAá¢qVxàÎ æí'sK;àGD®Ur¥-ÇyPñ9y5;ŒWÍY|½” EÑÂ`3¦ÈéI‘¨ ¯}¯ÌœÕ»ØÎXÿ‚[Ú©'Žê¬MS¯7ˆ:€s!Yù**U1{¢ãs3òìë1(Ry£4äÚ'uÖ€³ÙÈz¼B¥ ÿ)cg5.ŒÖz¢s¹<½«÷ ø$Föè xÅß•8ýû†väd•>¨ú�Žío”Ò;ŽŽ¦]µ ’J›-Iaè0¦yHe·¬»ƒ˜8ñ:f³·��wGöqmÃeþ×OࢹS«7¹ 4HÒzkE¢’›Pņ×Ãù×¾ÿµA‚4Mw~ãj§0 M*+ãGÌ/ó4È»É#gâ ý8ý+”Ƭ´°Ðgy²Š OŒ:f÷ã]dý——ÉÿL4®¦j͘ÈÞ$LüêÚ_Zz*Ë(Ìs¿mKÃþHÛz[™úƒµ²i²à׌Á'tPÁ]d÷x¤ë©r?Qé.�Ý°hŠxíæGVG`ÄiG©W+>þÏFpz€a6@|T]£÷2‡<ô¥àòR'AÄÝ9,'P—Îy²(‘ÿI÷춶´ë¤5UYêùÑ\õ7ÃÖúƒlöÓn µwõ¼;…N<_dí犪ºwMézëjö»Ð×ÃluÞºÓGû½ÕR˜š¼µKˆ`rø€¤ç¬÷ #ØôoTå^ÕºyõP-¼ž(‹Ÿ²ÑyãÇAwé·ü)¹;ô²!{•W-µ®¥0jµ×°à¦ãñ'¾SzÍW©-Üи„&LÂŽ–ÓÇv ­èŸè¿Øb¼4æ8Ç¡ �­1  ŒY0}ÅD:ÞÄr‡ }åó‘‡>‡•BùJ˜ä<y%yuصÖuû'ƒØX�t.½;¥ 4‚5¶3J÷P0cƒð„øK?eó{D53\p‚8¥á°OG:ogí9 [ŸÆ†“qi”4ŸÌ»ò+Tª¾Sßõ>£\;Âíè5Èœ9|,µ¬¸þ¥¿r¾ÀægWƒ2г^Žó'5vGOÚ ùFp•t=5Ëùè ò q½ë Ÿ9ä‡drÕÁéV<LÖê[ÿ>ÉàŒò†?­ÐÇ_½ª¡‘‚©¨„é&4ø,÷$ºEG§©´ea®y÷\Î*ŠS¿ëœçßp ±Ú°‡j×ðÚÞ÷0LP¿Ï§²=OE|œJ¾x¸ÀÙŒ6ëð¯Þ~½Å‘b¸¨<¥hz¤Ì^C·ˆI‚‹šÇ :xÜ2b,EËxÛù­q ©à�-3¹â ÇU$ü'µ(†’Q=ØS¸èvžæùïË]…íx¯°U­‰éÂÝ,ƒøsãTý,|Û07÷ÐðÛ ¸•áF'˜ù;ØÛ,Ï£ÄWkšÀ´ŽëÑãWÎ*ê-!~˜¯u8ÈFýËÈÍÄ6Ψä×›ÿ^M”! òß7ºQ‚»r®=÷9¯ÏˆõIâ÷ï)üïNy~µ*>…{ÅŠÉB”«ÎŒ±ø[‚ä*Ë£Ìk€Æ”ÐU꘎‘^w°¶¸/°.ìŽ@¹Êr¾ç Ôq/.hpž$é§Ðå¼µ?0(Òn(?yÎIm‰í¬‘JŽ¦µ²lf Ì®°Ý­—äIÃUì·°V7qYÓFv-C&:ëØ]À –éYï7›;’ÁYæ˜r‚6™ºŒåb; †¶ÀÏL^Ûò ^Z8âñúݯh–ìntléðÌf=À\bü‡:f™rtb6‘ðû¶t/{Ô9ÚTn˜pkðÂçÚû»\ûÜ? Ëþ›ãQ°#<þ“¤QšD'RëßhÌ_¾ûÐ÷&c—âfT|¢Ø‹þÔ €…é²úÛ+݈¼L=±j¬»Kʨ¡È%Ùà0Ï#OŠL65íF¬--Ÿ= 'DÚ„ŽBŠ`Ñ»Y TSÕŒ& Àrž¼Â“³0ôDìb#;0à°§Mì4gvŽk ÚYc-W|&x—•�¢„ª@à¥â`wò4é+קIKšÝÐIæô}ä¯,3è—€²1»ÐtÜ m¿ÿºÆV>h/±_ ›âË §&ì¾îÎgEÌVŒXã.öô¡[¬´”xŒ[*_âjgñ€ŠØ‚hÍ좈ö'²HTu™º+7ë! Š“–HÂج;2_pkÏ(Yªïà–š›6@^áÑBaBO�ÎÜŠ$“´é^xYʳµÁ_ˆjUÝ(�Œ6‘Í2p~ò’ÄÓõÈYUg¦:„Is¢•— ü‘…5L³™Ž}[_©à÷¦…#ßd¢ÖAÂhtÒKǶ¥”e²ùKOÅÔKæ qî«AШ.)p*R%¶²iæ–PÍ7ñ¶áÐX®¹aE²ò< H¦EAöi‘^x’ jÇŒ1PnÑóíªó;›&nê/ ‰gzǪ·Çm N‚5æÒ ôO`æB±@àûmAeMg,Ëè–“×¢oÅ…»Qø|Ôy =*ÕÙ>Ot—{m¢S®0;B¿¾UNgšŽ9«ìëUÚ“yðšM¥2uawÖD±ý­ #g—EåË®º?ƒíj¡W—^EP¬RO .K<­Þ)Æ3/YÆåŒÒÌi¾M瑽Š<σèT9=‚ª£: Á ÀÔƒ.2”·£ð]x¿ˆЇÁÂ62=‚ξLí†G>"0ó¥œópøµÄ ôxÍ÷3œóe¿g6§ÑÊg#¬ gUѤ%ÖÝn8ª>íá$žÛ]+±ã¹žUR¤WŽØÜÓJjåîÅ© ÑÍq lDXøA‹Ë¦$yêá•’ÐÞ §É™“@¦ûºOÝ¡Ë{”d÷zåÿÝeôîf«Y`¼sE£{‘¶"Ãd'2?þQ 㶥Z<Whˆ¸ý–² b.Â+s™ÌpËð)Ï0�í;ðâdÁ=ƒÇÄ6ò­eà†¦.ñºu¡`1BU†Ãg-ÐÙ¸€™¤'Åsü¯3»á} ú7w¾5†‘U°Oø™~^¹rJ…Œ9˜‘p&ÓÖëÚùzdÝ°™Oz]30à´~9áïqщ¯22^’Nɳ&±ÖS9¦ýç7˜$~×›^9º�†ùÖÇ67Ç´ÓŽ,Œt}ó­ã¢ô}OèæoOt€&ýèübÅÔSHtŒH6Hc Û›¿hžf®^’ÎB ªÏØzøÑåü^E•Š+…ùr@A¬§üö}ôºjؘ, ijÐ+FË,ÜÓûKSß–õèæ¥;ÅHÕþn 02°ð8‡“{ íä@†®:]™U£7"šÆ>…΄–Éý¹ú3’Lh$¡è±Ä‡˜ƒ¼wž"~Wá; ß™„¤ª+˜03#N¦“—DKŸNú*Oü»YøÞÕò ô”½¸>`¨±õL©ñÎ"û¤’{Ú÷d "ÏŽŠSQnû©Ô}”*lÜkþ]k¹=jZf9Kl£„‘*:ƒÈEçÍ5ZtÁh%!Ï3n«·}K•¥ŸÀz“%A4Ÿ=–JÃyÓǔľ≃ª ¾¥Óqq¸ÿ[´(õ|ßWI°¹Ð÷iõ@Ið¨¸QžùÎ=Eè…6´„É!u`±Ó¬ŒXðǸ]_A— ~9Z‚Ê ú\yW¯ f.°é¨¨`œ»‚gÙ•sJ±òÔ=(9lú2ˆnØÓc«ÔðŠNxx ©¨ôêV­*Š2‡Çeƒ«žþ/´ÓQÌ3¤qoÉ=ò®ÌWËr¢Æ¨í»wâÈIJZ{zžŽZ£°@Ë]‹p•-f¼WÜÒ¶ŒR¬æŽ0n¶8^œð`”º4‹v®Á‘iÏí· ©N(1õ<TgN:‘ÍÉDz&WKŒÌƒ_‡^6!££B¬âÝÉsîÁ 5ýLµ_xâÃe™¿¯¡²CoXY)ht™—‹¬üGR!ö<XefCãf;ZVÇ#+ƒˆ¡4ÞsŒâ˜Óý'¯³<qhã˽ë@IÙi7§;9Á2Ãöã˜p^ÑaêšNZð~PÏ• c¦TB·¬®M[pÁµëY;\ØÍû!YÊe…èjì�oÞ=P{sê]mtWB L›ìˆ·ß4„pbS—7´#×°ÏáE™iµ@ꪴË’Âì9P=2� hL!1¬MSü):ÙW¾¬/}ôË�ö£âvæ±ÚTítS…C‰g¿^W %B—à$*ã½… ¥=£Ï˜+J<”M‘Ò´~í M³{±2[ˆ©Ò†¤#75XƒìMKŒŒO73F ÙòÕOO8œy”úñNÆgTŸg³¸mǘå-“XwPRº«dXøìú©áöÄI•kÎEšu8[ñúKã–ª–Ê8S"Õ_mã½­3º*ÔpL¨ðÝÊqcH ˆšv"f[æ­¿!BÅe¦ž‹479«¯™mV±ÂàÇtÿ¼¢±SÞæ8«tµà~Ô5Å÷Ï/•&7‚©¶ø¨Ökã ì.Ü…¼«ð“&6þí1~L>O¾Ÿ6¨<f¸Û¯?¸*¾“?±'ÏÜL#—M‹ÌâWÖ¿ÓkŠ¯´õõŽ XXä.ýµßiךðqøÞV™2·¦êG„õÄBÏŸÁs¯—žÓnLbVøD%UlÁi¬,56g_Éà!D¡HÕw@M^q0qsáú¸Ê^˜ï*“m‹8M­Ð!xWѸ˜í9èýìͦ:º‚?+šW?PtEžr K¹éÞÔ åéè ¤9ý¬´’Œø”[ÐIõ¼Qh;)²\¨re€ôØÄ8[ CÉUn²ÐK¶"èú35€8õ\Íiáï¾ò hÎn�$qzÛ¬jÓ^þŸ5bÝó@[t†¢‰b¤UJ™î°!ud¨ˆ»L”â›·þpàQ9ìê©¢ùSÉkÕôyÚóš·Ù‘qôdæšïZi«È8-w'ð*õ€Ã ËŒ¡u*vGB:Jœ“e(Ìœ-<gà¸âÒáÊJæ€Ë—ûúàvœIÄ Á¹q‘Р¼œ’œµÃ:ÊèüÑ+v÷RCO'ÛG¼ƒÈ÷% Ï>tÈ%„^ñWCmë e\D‘@кhOèåõî‚?¹{£­™á3zªóx‡»gå§èxJ-éµzXÎ@¤Çvð"Ûo7ízGçx:èifiÌDUŸ‰Òûí©’Yõ9bå›_&QZïdWÒ×m‚í@ûãÀ�$»Î¦4s饜™õŽ²âðëÝ™§02Òcæ‡S×ãh§·äªòÁ 7/cσé¬âÔ)%mMÔ™œÉ-š§"›éÿ Òf|ø\{F­à‹˜eK gÊÍ*æ,²k¾×,Í<StzrÚCqPØÃÞçÖR°™o6OéŽ0i�Lå*°· ]ðnRØMÄHÉ]ù·ØMïT¼áÔB‚zôñ(Yô§Sp*àøêáæiÅP *ܳǃvǽ—Ä­gÞŸGrä”TX–-k);ïù÷¸tqäJ[ö#a—…âSÕ†"…V:ë–…½ÂÏì¢\e>8ʳ¢'d,Eî‚Mºê<¶ýZ³='¤þû û= Cßf^‘5CgnrH¹WiE¯PlΓ™—fG_åS\¸AŠÝ¦Çv¤P: BX3Ä®uú?Ï\EÂ0ôõH¨l�— 8©d‚«6I1§–kÙæM–/fÛøÇCXÛZùRù=Ýö®š ‡YzÄêŒð bLùµÚí ê·¾d¼8.Θ¹G•r`¹V‡ç<›á U‹ò…ìÅýšÅI^±8N7™’ªû/¯­\W)5LF ×¾Em‡îLÃ'Í¡pEÏ·WuxÌÚNǽ–÷TóðÅ©Z=зÊJ¿ô¦Óa¦~Væqr7µh[„êDé@;æ[5vèÖžù!°xßxh§gTúJøíô²×’P¼mõl<*ÚŽ¹˜*ÉH€{­ß^²ßwêùœAó‚Jñb¾‘¡÷°®Ñ\æi§ºÛÉ¿†ü4š$ÔØi.Æä7Ê¥7{妞Š nNVú`šUw‚NI‡õM0xcÄ©<6X¦£0xU“<]ƒ—e‹¦m”l²x$FÓøóŒ¢Wœ«”õ?(^öUþÆsœÈ:Ü·‚Ì5ÈLJ“UÓ E¹&ŒŒœ…"LòV?œH<œrç++¤S4èߞܜÖ7+<ãäŽöõVƱ¤c#~Ru!7øœß «¶»Sö®nnUœ-HDœ(!Tži‘ÑÒ3Aî ‚¾úñq‡¾5 é™Â¨¤¤bÂ7(|þ§Òôaû$=Óã³°³÷:ŽûaœÀ¹q©PagÂä·—žø»¤ÂªÃÑÏ*„‡ƒt=VgßïûVˆã¹"G¹Zh\äbú®8«3íDú¾ì&¥ÿ•à¶±K¢ í>ý!L N©ƒÏíǃ ö.ïÚ´&¹å "�$ ¤&-Òì­�†Í÷9±À1û)W‚Á˜`^ÀÕèhG±hÅ‚âbj¨Á½hçáöâ´´R¶XlŠŒàé(á#ñJ4K¦ò“)@¶˜@;§š¬ÛŠÑ­þ\ÃæX÷®ž’…ž),Îå”6F—Ÿýw¢ÄeÐÎUS±P/ÍC5w8¡Q“?]ñK™Â²FÇ.*‚bª0_píç‰U—žõ&Uýè»Å¬“ø,ŒÁ¡¥­UY«ŒRÄm< Êúô…ØþöÆo=ôi{16ÕÏ4émÿŠÖ‰î¦$DXÓ†;WvØæYݳJÀºJ¨´ãÚ•™SUè¨⑲¦Jï¶ڢ$s-õ‚Ù!ÓŠíœÀ›µZ}t˜€£¤®Oœ´}óèg[ÕKñ†j7yd;kô—èéÔO®uÚ©ŸðJyóÐm7Ǥ°¸¢²RÅ•}íRú¶×†{ìˆÇÚx¥W˜zˆ½‡,D€2k‡é‰ø( ªð¹0¬þü<Ò¶öÑæ°47Å<|¯'Æ‚ÌT¬¦õÙ!{E˜»ô¦M:ç]N¦èÔE¯Y…B.hzŠv,Z”160u¼Ñl?ŽÃlD'_›;]$îäÑ=ØR®‘î$Æ™¨-Xݼm7œ ßôîå’Nl¡ÜF¦€zÔÞ¨ê c¡Ï #/Cà7Kâ…µA1/µ…ˆØäT0´G¯S(QÚI¦ ͬâéô)•9¡m³§œßeAÔ«M,´VÅxÐ)–Þ³ÖzæÇ ÿMPJvñ9ÐŽ™;ÇS6œ?îü؉ÚÓþÍÂsůwàÿNïV;3’ß”¸)‡›¢ñÐW"™¼‡à̃/pö¢¨·$~-‘£8J½! |I;ÚEçG|mîÂ3û]'%?“³(¼¬¾`‡è —ÎqÑ)·¦Ó–;IVd­:s_äêu™œ«…7[b†Umí„yD¯ ª²x -‚é¶r£±á5½ÿäù«.>G: ÓãÖó÷†õ1÷e$C¹æù* ­Z•Þäoi b^Cü„þÞÑæ¥m+¾e—3Ø!༱¬GíÚÐó%“VswÿTž„Y]Û¤«ÄÝÛJ#ËË8Õö¥EÄB垢ñ'Èw­áœÐ£;uæù«ý–iúöbFä-æÅS•’Î CuÊ ¹h¥—p„<,ñ®½˜Ð~`a]}±îL‘’433·gñúr³qÇÆ~™§iÞ·vfÄê_T­·ÂFu9 ú1âãèÙ´›&‘Bxb§–ä~‹S.…¦%–£­IãÀ:ÈÉò²’VwÓ?<Àªoä£Ñi·_i6 ÚÁ°­MN~°G¾Ø¨ú�£¬\¨ÃFl­óYy2‚¦7bŸÆÊåHŸhåëæò9¹rêœÏé“™„iÔ}M/=](_¡Áyá›~ôTJéM9̲%¥éqJŸêÁ=g1š¥Âk¤°ÖPJ¯à´G"mN白¨ºîÚ<È7Zqå˜íuk=öØôâ©P<ÆËcç8Í™¢´uT¥-JDÍ@óܶݤ3›ÿ ³Î+ÏG&•IõnÉï'XÞ,¾¸¤J¬Ë¸¨fè qÞÌq ÛRuͱUV¸wu+Æšøy ×uX^ÛÆCÛƒäŽIÖÎ 5Œ¢ÂÁh¿é\5ü æö§Š›Ç?!8îÎÇ¡¦Â‚‚Ò¹y•Ûhaa©…õÌÛm B$Ä‘rn™Ãðz»QêV”ü€YCÕáüÉq‚‚žÎqX³ˆÃ>@g<¤šæS³,ÚÂÛ †Üá(»Õ C„¼ PPëÃf[ÕYõ¥×qQ¾�•ƒÉç—F*Vðj·•nnIIÙIJ“¼s•™mVFQzz”ˆØ§Åz`x¼æ‹>w›j®(:ÕÅš£n àkŸ¤Á‰†½|,Ž¾ä <:éï¤iZ@ƧR,ÕÏõalõ`5N×Ðú(måÇ?Ð Êð~ê…N”-d^9í§$»ÊZì%¼·F\áŸ8÷çDQ, ¡ü¡crÞ÷®r$!Œa‡FÌßæƒqé/¨ÁÖ´0g¥ dÚù`·W%ö¢ñÈ€´;Wog�Xº[í£ßb”½°A‚+”­[í(Àn€ÛT³Œ"d¿Iœ†´™EMÞùÕ3D¥í¤%·U×Æ[©<„Gé÷̪÷ì}ì}Ñû`¼0¾†9îz?‡ÅK@ê (O8® 豞6AyªGw‘§6¥óZÇt<#4:÷QçŸÚ‹ ô=ü,÷´µ¹‰|øHp„w^…IgĆ†Ç¾¯±uED´ÞZan¢øîH…wyl<‹ Ê œS…¨žAi¯õ~#˜û½$z°3E”ü]3Kn J§C²N�Úœ›ù× ”L]l.©úiŠÌ<kKÞOd¼½Û$cu€úœ§Tê®îF­tµ$£Ø'tÎÖ. Ãö«B§ØZÝ ÁáÏ! —>Z9g0Y«·±á2ÕmµxÀt›¶¼2©si%dE ³ÃPÔÊfâ+ñ}¼ógzØáNÓC)¬ŠH P¤½_f ýVðö¼é¦Êz¿&ﯼâûÈiö¤à˜Ð ùô‹í.«hïn?Mtë�zªt.ARôg`±ß½?±²)p%€1á|M…áÅãŠìqzIDZøÇ!Î<¿¤HXyÚ'X€oàtŠn6³ò!võÓ•}Ïó?æ‚Î×OoÍù‰•á÷‡° *¥Mê®SÕB»ßÂråk†j¨8ÍžLåðÿþÅêæÂÅèPñ}аN+#W8}d¾of\ÍëÑ0º_ÞÒQéZ<!ꌊ¬^•ä°ÿ¦‹Ï8j1 S“!2ß½´&‰NÚÂù ð.?‚NŸ7ªµ’«-™WüÔ8ä* Auç·¨øò´¬±“hÑýP¦²÷£›Ñ5ûŠk‰I ¦ŸºãîvÒëm<F(K{ÓœÒÅ܈VSŸ¥$+ejdöà0BáØÈ? »ÙráË §EÕù$ãeíqƒÜ~Ì®ÕlP<Ê!}ŠØ]=êÔRâµ¾Ýg†b’Hé3ë>3¤Ë$„dwÕí@Ѿ^Æ×—Ë Uì7Ù Fuf¡šÙKÍj ™»–µïÀ*ž™š8C®Ùé!ÀM6êj‡E ópø÷X¯÷ ¢¸´ª_œ”§:¡ºEŸ¤°7ã°¥ÎÒ,ܪÿƒÓæn' €ÈŽmz9Ò{7ïžî×ùªØ9šÍ]I±'êb¤1žb_tësð>úÊkÄ4‰«µ²|ÂáËm'ÿUháÓ| �6À~ôÓg#à™~§I2ž)„>­œýXDp{V { VBµ®÷fýPo»ˆ|ñ¤Híã­ é¢ØÊAì5/¥d¥ K# 6)F7+¸±ùó_j‚©ßº#,;¹Þ¡ßÞ¶žRÕ¸?PVÝ:_ã§` …[Û>nÁ-~woèrt£Üõgµß¥Î<«çŒ,¢­]áèv8ûâÓ–Vñ…ô @ž’)ò¼êÞ4 ­€—!àfÁy,‚•ÝP˜Têª*›bJ!Ù‚êŒ@¯§ úïð‚5ª›Ó1Rw«Pxt€Í…ˆÎ;O¾ZC•Þ€©F ŒÓ¢ùÑÏlÒ¤B6Òî žÌ£SoHõÑ ó‰Ï\}¥ÛY_$ ˜ßÜZŽ¬BkY.vXiSåŽ`Lìa­¦†Yøx£2E©¤mMl@ „¤ëª“jãBhn†¯‡¼bÀåqtÀóÒÓ0?TÒ÷:{s²(W{rV§ÕžÒòßyY–DS ï ©Aó] t™.zÙ% Êw [9 ›"P>DJÕ±9§•[‰›bÈÛ*·!CöLóú® W†«1$›7Þˆo+àbíqtÇFEwzèî¦ùÂÈ8¿5Êê諈’Òš´xÎßxi¹uyëdIÜâ¸%kÙ‚0„mKœ™1¤ý¸éM éþz!Ár0ùÁÍZÏ<f>6TA…5rÙV>rD-R`ž•ô¿çöüaRÿó…j½ßC Bg£ËqG§õ…¿QÊ36éÃcÖÒ²†¹ÎÌä„eµ’+:®Ðâ’ñ;Ïü̈#vlá^¨è9¡ä~Ljr.´ v aä +ãOëï +=ª9¸,ýäøD«ÔÃP…°5§úurC8úlƒ©¬ÐÁö>©‡ñîõ-8Ä62Ã×åÖ6“%¨‡Ëä[ ‡tºE>å¹£{L!€,;�•èqžƒ­o*dêc¯îšT¿!ÌŒªòøÐUcQfEejm­í7ª§0L}Æß*æMÉÖòV†Ä ëùPíM²!{ó þHŒÖ3‘¼«‹u>y{èÄ”¬:¯aП¡Ñ5kØyÇxö­95“bÖt¾0¶@ ßx‘Çž¢�JAMq-kk»ä±Ðä2Jò+,}?ŒeæŽ5ÊËÆw‡! ƒ` R€TR§F@,Ńxœ{ÿ¥SA‹q”7³IµÐÄ»Í×t¸of,4J%™Œd{ô¾ìùÊhìÐÏïjí®¸wÝLo<&} îQzú«Hœ…Œ’U¢xÞ÷ =w>4 ¶t®:DÒy(a¤ *‰Ó‰ÙiûÇ^¤B6Úö–©U‚q»éß6š£Î_ BÇK#x—tŽæ®‡,sFÍh-¨ÀðÚ€*¤EÌž“ÉsÅ‚»}ÑD¾ê('V‰\P«P†£GQô_.@Ì»•Ö“Mî¾Ñ†ÁзtiºI=Å®òp›vh÷êß¼­œå2ð\1ʽ,(›|³ºfoµ¨Þ櫯k舣ˆºÊ¸ròX‘m:°Û4(vŠ«Ì×¼Èlܳ”âÜqéu¹UÈL•¾“›a׸ Ê«Ô)z›Ù_« 󩪚ÄLÐÛ†‰˜îu/2TÈ*C:°¸L]%Ì�ýq ÷ˆù“-ä‚ÉhL ÐQ‚1 YÏܦIŒ>äÏÈr©³ùÁ!ÔÇgïƒt1&•PóØNÄAbÓСš¶6*$¬ Ó˜zF2軦kÖ{-\îÈàƒö‹Þ©Õh^S’G˜ßdc×ìýÔ†ž`Z[ËÝU ŽÇö€Eçø+¡Á­kºKÉ»Vn¡$™›7å&T"}X0®øü7ôþ­8·àº*|oÜÞÞìG߆õo «:¤n<‚ü<*ƒÌúEFlY؉x¥©Aí¸¾@XÝÃ’ž?Õ•ó|DÑÅ`c†{Û­ùc™=Ø&'Añ*¾#Š2¿I‘üOŒ'jì ¥e7À½iÙøcÏÍZÉΩ8VÓ_I¬{2*ÅÐut˜E•°Cº3)à×ÏUG‰eöbKÿª¥ª¯þ°°0dSÊî² ;}:ZöyÜãQê­¢íßHÏä&ŸK³+yɺÝïòsî¾k—ß8 Ü\ð×Þ Þã~ã ’¬&ùz—ÐÉW)#Í+vQ?¬nðcƒ{+¶d$ñ2:«7¾â6ŽéÝe3^|’ÉÂ]àÖm ´4I±Š8! ûÚCQRþ/áU5'®ÒÏe£¡/­Î®‚§š"ma©I¹Öê|ShAŠ°íéKÕ:ž4f³ÒIi¿à`ÊZûÖз5Ž6Fõ÷GçP”:¾ ÞŸÄ9 òÎg>Ppx¤>w?y.Ò•/òÂMýj Af–wÞU`é÷¼AR¿²¥Lšƒ¡íg"�(cÒfäßIæ©Ç.¡hÈbáycÍ^xë Ò[sÉïåÂÃ8ö'®)¶£@¬¼ñžoÇ«µ†ôýËF½QúQŒK£¨´Ùù¢g—Ã`½ÂÿÞ„3-Žó�ü‚if› `«KjDUÏÍ•<1ýLæð¦ês<ê…ùTÜl"[…\u<â°›×üâ%_§Ï‚².¤Åq­¼HáY¡ÉH‡NL¾ý—û“Ðl! òN…ô¤js«E´#6TÖÀÕXÕvÕå,Z�m<¦©–±#ƒ³áúwNEd­{¢^R€­@*ß`l±v/uøãÔ#ϱÜÃxHƒØêSƒzËÀ椇ï‘'’Qiäñx¢þÑd“LÅzÆLàzWßØ ëñdÙaÏs¹{ÉßËØL,ƒvæz8øTæîâ üÔïÉIz"k–ÑIuF»|Ÿ/<Ë$œ‹zÑõ#†2—³‘¬+ÚE£QZ—È«¤šv ŒTF�Dî¢t¹î =á4f0Ã4kB«¹:®ã°¸È<@£Å}>õËVQê@ÉУShõnµ›wÖíÙ¹@¿ŸG.GÞa/®ÇÁ¡ó½+ ad½‰›ÓU=W{Ô\môb•6öÝæÒ_š†í“.GŠDtîh±5ÕÛúÒ#¬QA~ïW¾!—!P„K>¼C }Â;þÑaS3{QovWû±–¿ht>VŒo+kmFR. 0w:š÷h— mÊý kQú¯ßÐÜH6‡8ÂùÓÀmh÷«S‡U³ «ýc¹$aid>F WŸ“Š– ‚dÁ æÑB㌳#À=óx‰¼ûĦkcN'Ë.aÅI„Ò%Ù1‘æ…ˆ“¥išØf š8ÈßÏž’</“6mÆv-)^–¶E^Ò„©G*ñQ§Ì)Ð{xìZ7c@ñ­…'°sÄŸîs&uâ~3¬-ý÷áÇtfjܪÇ°|92v¡0HgÔÿS[ñ§Ò×®=£õ°cq8{֡н?Ò;—õl wÆ—ÒªZ·¹aÖõ[ÛNhbÊ'µÎ©¶,­.2*$ ;*6j%·S¥7½&Zƒôì"NÖmS¦BÉ{å�¶l‘N•AM‹"ª­PÖŠ!&kòZ××é3²—{°�²Ýؘ×7¤ç¶é[µÛìY¼ñ¶ì«´–lxCgéê½Q�¡�f«6÷´¡¬¤=”3>¦‹)ÚYl‘îv¡±NW˜a<L@úšI¬›g.F›Ö753ÏõÜÓsÝ)s4©ˆ<ïöì·L´j(šòänñÃÓ¿±Pi,PÔB™Ü¤ó«t6€l=½9™®'?÷‹R6sES&JÄóNEøcŒ¹ºWí0øœ‘;|Ø2IlÖDƒÑ;Êg›à¯q¤\úDÇgñ%ôˆƒˆr´Q² ©±÷±gt½  °#¥ov¾‰.ÑB½w¯í˜AŽoE!“Z°Ì7cà üš7”Â$E4™B×yCqÕk‚æ°¾ÆᢴüFsÀÇóÌÖ‘ìbG½ = BxßîiÛ]®›Ç3縴·»v¾ÇýKWWº.t:i¯ X×t"ô»vÐRýþXݯǹƒ|EÌ#éÀ}Èí†zo“ïk$ò® ºî¬§Ø pÊ’uËí-05!«z²2Ü~ªªµùØï;,=aŒRFÜà±ÖfÝJmòö>ìúÉÙ4 "bdîkcØðKþ¿†R^« ëÕ; ½‘͸¯,ÿ{¯%ÓhUBG<Gìª?mÇxY%#¨ ƒ%úf?íþúøY™»à@/l³4H»/“ûqÓɧ<ìX˜Ïl¦çýÓÐ&ŠÔ{”ÖÖú&ÈÁVêÚ~¡ ×YáÕBe¾Ê LÁîÆ3Ž¹È*é�ã‡ðÞB1BI(ìš³|yÑX§\@lŠó9Z”>éHG+4¶_ÈrÂUº0ôLGÓ]j›�ÝíõºZŽ/›±úð”ܸ!ùMJ½ò̆¥m°®ié¶[O‘€Þ|g5ÜœáÎÕ­YdZ’3Ï+ëÜ TÒº»Ž¬Þ"rnZÖR§T ö^ÃùN/R‡VJçl¿Ðç¤!oj¦E–ŽJéú±µdBÚb²Öížs™6PjF†L#´"_¥5Ò»ñ-{Ðå«J•;7 b[û$·m¿¾8~Qôö‹þ™(Ë,Që#!?9XÍë Q$\šL@þ“m8¿…Ö~°=NÃAfZ6qòyÿ¼3IMrÏg›1–û-ô6-³ˆì÷[3ÞÀäÌïÜEË’UÚ³Ö7+¯a ý½‘Þ3Ÿ­†=zæÐÞÖéEe"Þ…Pý¥¬i3ód¢çÁ„&ñaX¤K ˆuEËûSûשšõY Ök½¡[á¡\‘œoÍm´H¬µ ÞS…L˜Çvýºì¨ù&‰)Zí`¸…6èØŒN>ßX2øUŠ[¹mÃZ{` f¶®€NšÁ¾9¶Ê3â2×M23˜U à3¿…5ãUg¦ìœ‹šØ¡0ÄÇ`Yé´Ñ¾/_h‘[¼|áJ—¥Š`¿©¾ìë3æpìãÙLfšÁïèÄÓZO²^@€Éó_íÉTüKÉ(ÒÔ7¯1‹ŠiƒžÔu…ÿ©å°ŒÕ4U§ ­ë³¡ßtUÛW§·-pW?áœÊVaæRÙU3Ý;+ Üòüð_:D¸ù©Þ'Š¹ñüRÅì�JR›`]¹9;º^";À…B6®¯3Œ 9Ðo›'žª~)“?Z¸­7¬\·M5Jâ÷A¯_m}–øŠ®T³Žh•õ¬†äNÅ*ôP醰¡I‹¿k%Qά3olhîAE¨ñòû¹:øʇ?Ý‹¬­°Î’`=Ã$¦±¦ñìä%3›�O†÷WË2Ó(‚ŒHVQF©›)ó-̓ìhQ »Ð.j@¨ò¥ ^sB+sj§ ÐE€äz—�3¾)DÄ B8¿ª 2%a"˜­{½Ùòü†–™ ,èüЧ¸Œ™‰S Š!ddhؾéD?O“ë7~ Wž,‹àMàD&8ŠŽ¨ŠÕ…¬}ÿœ|^zé —}ç1 Ù!ÍpEU^g1üPÑß-ŸúúzzMV¯eÏ­°S`RƘ=Ä «ÉÂ-œáÖKÖ[‰s‘!¡¤>þQ»ï!,§D ‹Ù ¦åpcƒ fâ2aeE·!µì« BXï2{pÖŸ¨7„©Ÿ[À'V"‘…kÕàæYª2·YN XVêÄÇý{†e0ž¹ E¿q=OÔ,X¡ÝuWYÓZÔHtÔf‰aU\nÞ•]XÙ¼:5L žìç/-7z4hç£ña’%|R±ÏhéþM/x].#ÅŒŠUˆAÖ''wiéòǯۊG‰€Ù6tÜ•jóåž>NÂl`ÅÏ•³%-Üà¼h >Ñ]õØïâkëYp$sg_¼a3ëêÍ{ JEçŒG&9[DgãÛ¦£Sþ _*Ð#—ì7<ÇG>Ÿiì£!P6qˆxŸ=ú”‘NVV{ƒ匽@{”þõ¢%¢ü}�Bÿ; Êí¤Î%tà!o—Ò 0OȾß^¶­¼JM½Ýu”º¯úÙkÃÑÿä¼ï÷*¢5¬uô¸?Æ_ãêGèö^Ì?Q”ùãŽ:´ Ó^¥²dûÚa6õµêBÞ(D–‘ÍY9XbagÁj²3DžR5Š&”»roU߬o]'Ò0£u2Oôf+ÇŽl;@Þ¢ŠîìrRSÏô´ÿË£ZÁ—èòÍÃ8*÷ã9 7ô´=yOBŸ¬£wê|Dñ<RÅéU¾@•qzíÖUEPXÀp†(µc¾)ó 6ß è>R–kÊ(ó]9,9£zÕh_YPÖº’K}«~/X€ :3¹Ç-± á€FF‡Ó²q­ÛœÆ?Εúq_ÓÝÇÒÄËšŠ“âS³ÊrÅ„÷ íF±“•E OèÅ9Žmójù‰¥ÖïÞp]�WVçÿß7Ú.N¬¾äÿ¦eÄåÜÞJÍ=RŠó•ŸÞ£ÿÒSIaõdq»µ÷²’Ÿydˆø„H»¸~, ë¸,#Cß\GU%Æ­?ÍFJëçÚ­j,½ZÅ‘:‰ƒÜ–Èš¯ha.‘>‹c¦N·ó0oÐ U¥R¬Zi8À-Bøž+ߢºBçY-D*áêsƒÊ› í7¿�òt‘¦Uš|éqÌBð¶7eæ�¨ÛQÒrq7R Ý~w‚(‹^ÜôÃôÀˆBS¿lOT¼z8´Z'§ Zt/wüxêdiØΓýZ½ŸM6„ ³ø©s ˘0®jVÐÿ¹{µ·nØ^&ßÂãd>~sêiAî{X_¬T͉¿€mc/d[6”[8BÄŽ¿+¶€ÆÁÓÑ«¥¡·ÌM ¤a¿÷5íÛøŠ`ËÞ*–™È®s•ÒGuQ®›>ÖûrÅOÉiV·½4ä·'TVUžº?‘¡ÈóÝ<°¯/,Ê3máêÅÒë%½ ¶10Öã›ÖÏŸªßž÷:*aÒæ ªÝíéYgåãJ•¦L®uâç8öúòHæ°ðœ¿05àÓüJ®R¡vRÄÒ]r€å”X‘›²w¢l4ÚÍp€R1‚±’OŽRÁì‚»ú@¢ÇÌ<¼Ü7§îþ)xD×ÎP[KðD¿´ æÛiX@‰¹Áýïzd©çùÌç1f UOA¢ ÚbRa³mÈñ1$PFÇg\C—Ÿ¸df%ã?­ž ˜«ŒõägÒ®üºjz”}ŽÿtjÇ‘c±}clÙÈ<mß3†·/7ŒàÛh'ì\ŽÀ•itr…ô­wÒðýËaa˜ÞܧsꥡY¬Õsß²r€eÿdJç2ä€î|×{ú`;º[¾öèwhî"N=å.vd€ Šµg $–ÛßF­ÙŠlÿH;ñÁ 1³EÓ œ­r~jºI¼7 ~ùEÏÛXÕC‘d¡h;!{µ‡)³x:¯s²£lÕ(„¼ªÀàÒZÎÔ5Bz£Ž4 »[ûK´VrõºÄÈdyzƒ±ˆÝ¢óck‚XG) ÆŽ‚±rék˜˜ú·o‰ýO$M¸ñvT*®M©è=@hsµÊËD÷c Lµò2⸅—݃ÕÜC¸mßbï|'`øåÖÚ¬•Ínè."ÛÃ96,¾¨¨ž/߶Ø"ÇÈJ¹ô¬ž†Ls;W½9úÿJŒ¿ôêVîÐÕqn½,{Suì âQöK«ê¡&ñêTdÜéÉvru€µåówn£QîÕìÌ6 )¤ ¬™÷^ö(„U—_÷ðþüHä£I†ÎK@Â݉‚v:Æ¢l¤dõ…Y^õy/<Eí˜= .)e'k"C>û"•¼‰ ¢L£M϶„¡�='`Ë[t§ê ³¤Ê·eR¶“œ[ 4zúf²!q¥®L¢áÉOÛ|õé¿ô\œM}˜S‰¦ßnã%úØ{zNŠJä3¼ªð‰&˽¹=“îŽ-@T£A›šª#Sm+þ¯’E –P SaK£Y®DŸþÀ^|üB±ù†vÆKŒÎ˜ä˜7ÇÉÙU˜#·lØG!õãå”,Î-‹X C2Š²­uÚ¨ƒ÷S·W»5o$õx:•ú(_Ê¢ßÚh‚1Ñþ®zþf…8ÉJ«[΄Ÿ&·±g$™Š¿ÚE÷î’'ÑùªÏæM‚ç“Kß«2\(;d�R%Öis£†y'ˆBñPô~ñ*Ä0uêÒ‚è{`}§Ñim/FòãiÚ¡‚ÑWþÈ7@;ÈÛ3c)PÅIP¾WŽF윋4˜uT„ÉYrïêV¯Ð;Æ92³ï䪽xã8A}»œö¥fªeßF=¨ýŠ“ oTßžqbo`jêL³që™Émœ®bçIÓ6X¢‰ gaÉœU¸M‹½‘Õ⫇¦íΗ¦qV{tbÚŽí¿ÆÝ¥»j†[ÅÂ(4‡m×'A<Mž/EM…¨,–3¼è3rTæS>ò¼°F§ŽºŠåw[wÒ⬇ãÄ” Žèׯד£–¢F±³={þdgÈe #ŸÛÒ¾S>°‘\½gUp­­¥ÓZñ,‚ý‘no×ø| ÷Ö‚Øöljû�ׯ>”aå{´3O*c0¤Ç=¥(ŒÅ|øª "Ô}¹ÛR†gÔdua`ÓêV¡uˆè+m|ô ¡òMgQ â“Ç]Ý*KåÚ'X0nV}=ENdNƶö•¾”ÓbR#»¦éskÜÂyˆ]ÁÜZ\Œãÿ¢©V²òœT¿_Qãɇž·øP_*Ì6ÎJã®zG¼Jýš b®Cä ß Mî ÆVtGiÑ0ˆ ­Y­ÔÎb1¥Šƒ:K¸Du\zT¢*zD;äbºËŸ²-âØ €Ä©©J¶´°Âm·ÿ`è '”t¾(–íغpöwiìÉ&K8©w@jÖv¥³ÁŸÖ9ËÓZ”3atùOÏpreÔ+j˜¤c¯(âÜô-ýYÒ·ÝË"q¼<îšìFz³nãÍ×tþnßÐÚ¨Ù*@R.äÝõG+³-f. lÈU4fdÁ!A?°6œl{LL¡éà”ñòß}` àE¦Ï~º†£As×âH …@ß@4åt¸™œØùàª0šËÆC¹=+!Å(„ý L\ùìüßêáÌÍLÑ »¨9ªwy«3™øú�"ÍÑßÑ!fÃß Åæ9 —¾J’LÒÔw貌g6þQ: Ï>ªƒ·¨0Ž$áÿèÛZ®8¯yÉYqðìãBOæòÇ\OOs_)¨h7´HÈúvšþBh­ôÒ™Œ<Ÿéïìe‘ñ¢®¹Ö§Qqð._󈊣ÔÃÒA{m¤úÓN§˜wL›}~ƒ'%ЬÀýÆÜãﱚnHrS$CSöËïV£ºŽg_\dNk·º]ßl¯>ê]EŸ½š†õ‘ºï÷§=n^íÁ©ß£!Ùz7 “ÏŽ-y}e†n鹋·ű¯£ml w7€0oº0ÖÈéùfœiê‹TÄÁúœ˜~¶žÍÜ;çéøvð™aËמB/IÔ;[ÏtÑv ÿ¤U°]È&³{´(@tQòÃŽÞú‚ÛœÇö‹mW¯ø´úÞד`Û¥ÂÞ€eMþ}Ë´ó‹dFàhìβD½ËÛÑQá”Äg=Тٜ¬ÛXdf Šå«¸MN{ÃB<Ýe{ª.1³t"—Œ‚’Þ”ò•K×¾NÓ±ýh#°‘@Ö* ¢±ñD.¡;€7tP$WÆ0Ñ qö;0LìÔQ!¦‚NÒÜ¢ù 4 †–â¸ø.ü•D¿¨j ~2Á1tli%¦ödÛ-Å5¬q1\0á‡êÀ·{H'ž÷mç]°i{ÁjÜ°A¬ÈzbT±§ SÚ¶ò¥#<Ùõ¨~“j€í5Ã’q^\C3Ó­g¿ñŒÔ¬ÀS2À×ÒNuU3ãÿø†Ý¥xœ+¢{Kßîn«À½ŠÇ‹GŠ@!æI;9a·œ+ñY$R±è ¹èöð_xþ:Fû ¡âŽ×£¤F‡*F„F‹¿«W×Åqœ}¡öGX€ì”Dÿñ¾—93/ þ²˜ñ¬‚Óôaÿ…¼éò'ÈÜø㢛0¥²r6` Ü*8P‹|„rà´+E3=¸1há.]ÒcKƒìËN¼²À90ØéçË‘:ÒF¿ÈY�x1QŽ“_¾¼BV“U®¤àiêØÿÞëô”,W, ¸>—Añ®ãÖ,•^§±&ó‘ZWŽM.FËhæRuË#õeXÅe˜ÎÏJ“7iqöëÖq¨:Ž]/ g…©ÊW&ÁzŠ[Ÿvö­È¡^ä”8Ûê: ’úúu‰p¯Ø飠´üÓ¤å!žôîÔÚ7Ç”7cç7þ½?„~æ+ZÒIh0‡,äŸÛ@(Àsï|߸[„›òLÎ?õ :Ùƒè�òïøÇSfÚUû­Ý»­Ú/%fæa¤aa;bIÈ®“߸+tè/÷’+›ÔÓÉá¤ÕIe›ëÉ25_7¨È3WËqܤ 1(æYÍ #[1ðV¢ý ÙŠaìò~ùO;ÊʃIgŸžmO;*=ÿ1ߎÏß³8xd¬¤é´¨ÚqhFÌ™#æ‡B§žÈ&jH=pþìÜöªQ$ž ‹¨ê0Ñc­ ïr¥ú`¡^ñ€“(€qö©¦ m‰Í²0™þ–¦÷ä�^·1ÉüÙ*ýÍ@î¸Ó5ÒÐvîªiÙ¡÷˜!D»KƒGg§G@úÔ:ð]å\eÜ]1ÂY™¿Ì=)>¸ï‡¾ÄŸi#úÑmƒô÷Îi Óÿ¦ó PËÛ$†÷¹óÞ–êqÜBZ³úêÑ9*/(NFÐc<rl¥âî�ãc¤‚“jë‰éˆÍûEq=G6JI]uò,�CµéX8èÃ&ŸøŠ`e-’л¿4¤§«¢K$½…ïG†Þpl‡5ÒÑùÔ›‡tféÒëŸMO*‹Âq„ÆñÚacÛ–¬o~°sÃÀ±¬*Ã,dÀßdYIèHEœN¬çÜS°ÏdÂüæg,ÜÒ2ùˆM¡Á|±(ôx®yv_ »*¸CåP]�„×`˜›ñ‘1Z4ÜÁ )l*¨iïA¨Á' Ô)¸]J…‚i )¿s'”™æõ;ž”¸…‡Á FdÖÁRDíáØþ@¿1_9pNrÇC¤±�Ë̉îÇäàr/0e¸=æ¡´´hóÝäÅI*I+AåâäQ/ªë×ÛwNÜv@‘ £é ꬼÚj\kݺ”¿y4d·r \brBZÓÆáÜE*Åfô±ðN¾ÉʲRÔèGÊ¥,·´ZªWZ žéÃùF:*0+³[º­aûå©ýΞRßXC÷#t[È kg_Á.Øy×k8Ò™:¶¬6Úï'>1A …"t}ùnضÁ/Ã+HçåT&©I&íQ+É ®‚ÚÂZüpÏ¿0NJ¿Þ§U¿«èyL“›Òã¨y {©Ùž©ÓWãIq{R§ 5Øð±`üVТ|Ö_Å÷Iì‘œDüOÎ…"]x¿"±£359ýÜR*£[É ÚÆzO³‹´Ìê ƒÔ]]©‰%¬˜8PXž.†ú–°“nÕóÆ ÑùÃAÆë Ýx8Âh— ò œ#¿¦É:v­é3õ:gfÊun:Z±³á•öJ7ýj•bÑ?ã1¢é:áÃò‡‰µac&ÀKŒªÀNßÏñ—0ÕÈÝ ÌêÒÔ€Àè½O}ðT„!O®Ë«`]ÃoðõØ£[¸Å¯¬'ÝS•‘{¦Â± XV)¨ó$ˆ¬Çhiô¶zxçpU Ú¦ßvÎroÒÒ·DâoGÿÈŽŠ¸ÐÝÁt/é-p“½D·ü º9W—wDV.Àîa°g£Îª7ãV°�pëÇéí¸oÙ(œJÿÉŽ»<}ô±è_\åô1JçÖÃ:Z´êâ ¶>�8éíµÊ3ñQn¯IRwU}¹3òÏ<E›GXöïfËRDØžÛ†2Þ¾ý¶§Ž’u4ÿP…C¹ãnŸÆX¤¾7ÅÈò§¸Ö–\y],m…ø<\¼¸½ä1ß ¶¥b4·žÜ/-õŽ9Ç“C·Uè*E£$s !»ïÒ™B÷üÔÙÅ®‘›‰ëºk¿á E+_¦8Zßµã׶][ ÅËR¸ÿ©Þ³MITu>§ÁjÖÕçEÇÓ~²�Uéãñ.2ýO#ís{qsl•�c%¢æi´½ýc”PÝgÜux—™Ñ¥Jµã–Ýì.Um>ˆ)%9 ¾j%îÔÀ`탉àÕ+raX,зâì‘Ù¼“î2¦ÒÒj-éÜÊ“™©é_i«GYáQséOoO˜ÅïNžÊñšýÖ8)sÒ¯ÌJ4Їûfna—ij’^h<QµE·,lóÞ몪qË€%Í-¼BkÈvœ…FÜ76ÆsS›‘õÏÏÈž¹e æqŸÞ9)K#’ª¹C˜¥ÅŠ2¯ÙlQ "GvïÊΓ’kú ¿’³ÂG�†ß‰ñƒjžt3W¹ Hßý@wî¨boÇýšl˜þЗ٠XËW >Ée¦C«Ÿ ×­M«\Ѩ{ZQ£n„”Ûº“Jj ˆ÷§PGÝ s¯ØB,¶\­²NFãÃ4&@ÙaÉçöPü#MR€»ìÌùqT+§ª–­7 y5E5máÒ¥¨ÃÐç.O­‡7¡Àß*Œ)ç¡86|p~™FÅ‘q$ILÊʦŸÉx¶ð[I£„:kRË¿±ûôeè¸e1ÍtŒ4÷w(çcò7Fݲ°~𣟠FüÍò ‹©Ò›+×Úͳkëà¦ÞÂýpfu¥‡—Á‰hcÅAÔ=*Ëzà¬Õ¬FÉp<*¢Ó…98mô¾/ƒ´¯Ê‹¯Íº‰6û¾åöµ(’k¹võã¬íX¤¦›¸§…ζ#¶ÊÞ~½%«Â÷áö‚‚繤µwdêW> IõÈÓñÒ[CÆ!­ß.oÍe³Á¨vÜ]è²¥ü7jäIæ›Ss„Ü¶ë ½pCl±–;óý§£þ4½¦APT¦·o7ž¡·èijmƒ5¸£}1î×ÕåV^'Ôº(Ô#i½K舲àUÔçýïÕÚ)\¡ôí*t!îšÄ„¨)¢À´v:GCã<�IXšÁRëUä–sü‹ â}Ü•”ƒlœ%„ê$VJ¡¾ŒöÄ]À†~9ÝŒ3ãpOV^Ö™’ è=jº3Î>€MΗ?­ï,ÿC kÆ´ƒ^dÅjoSÎü†¦Ä™Â†q˜äUúS·<ãfc%W–uÒ™Ðòšñ®QÆ¢§kQÒV¸÷“"3ÎZ§b©'€mDP¼¨õZ¦ea¶L‚}0…¯¤µþ0ýƒ¸ÕŽoÝÖïGIJtS¸‚ý³kÚûŸÓÒlö¸Ÿ'–õd‘¨î"gðwî_Q¼ºÒƒ™ú .6FÙ•Á¯ÇmrWþaW+_"gÓ©YpcN>/ðÒ²H)†HÉÊ·öX!´rúð²ÂššgD+¬?ðHûœ=@ >¥ih [¶ên·û)¨Ð®¸²m ÕÚ+7˜æ©dJ¤Öwhƒ9¿ö×Xqy¶ò¦´n§9 «‚±Üì¢è(Ú°|Ø;U‚{W¿ØÞþWw9´7L Ÿi*â\ëCdÓ—U2dÇËžÒôѵ´à E±n˜ °¬ób?È«ÕÂ&!ÃÔaª6‚v;zBØ,S ?I­¹ïØ Í¼<F$ñÂÝ ÌݹñæÚLX²¢¨?Ý­¼Ì—Õné™Ïžž5e£S þa#*õÕ-X¬XΨÑrï8;[……ƒlJ¸ù1˜3[ù€Èwtq¶~á »#‰½ÆñuO!+\ Š#IÐ~Á©óâì6Εh7HH\žîû#ZiëÈt-‡ŽÞk>™naü\À8ð¼b=n‡y¹û1cOŠë\†°§%ÎÒ edSf'¦¼IŠ% ê9²=ŒË…nt=ŒÖžþŠ ¹Ë‡t ¾¼J¼‰`Ùe=@€7QwOw˜ÞšûIJ™èñ÷:cl%‘¤C–Št}1Ü,“”²3 5DÕä/ŽSßËyÃE?‹«ü<CœÄ¶.f™½s®ØÛpÇx8ZÑc)“ªùÿ~‡·ôªø«Œ;xwš-v{ŒWÞ67ãdxû^v³f ¦èKO¶ßÕá ËÐù¼aåó5|×å4}\º½:‚SUn”šé¡qö øƒo§aæq­Ø\ ƒ~¾³�`¨Õµ•×ʤo!ÉËòÒ§‡ùdýP²àžzn[š�Ì—ÖT[J‡'y §Æ˜ºÒI»õ¹PN÷)6¹äÔF¢ ï¦#€ÄSĪԨn9è}p–’Yb»3ad˜ô½·w122�Š#yoÏÓRðqÈýÂ}þ$(m»£æØF{oǶªáÎÞ"8´/;¥KOð„¯qS{pPF¿˜|Š ¨~C«xÖÝXß. –;iÍ=׌­ôbQæôC@Ÿö<ýºüZmsµV¢Ð0çBÎ0Ñž8Q.¿Ù(Š÷ u#º)@ýÿd0èœ)ÓO¡�D…b…@ Ø ¬N_÷ÕiÞöD§ï!OÃX@4òOÍGÂÒ`ƼvïY»‹¶ðá€å©ê†‰Ô©çÀÊÝhFJÖb…nE_–ãÝÞå.,Jrͨï;H»Ha†Vfbüu­Ë?É6, ÂÛRÌï 29Yùµ²ãì_«1ƒ®AuÂÒªÁú“Ü[ò×GT™Àc†{QíD§ß— mÁ•˜[Õ(ýœš)eF&Íh$Fñâ ¢·Oo]L“/Óq®z—”£ô p©ê»ˆR?ÐÂH·'¥oá¬û':²bºú"w+Ì®äEP\fn�󛣖æ¤ËÖ÷{³ßµi Oè/á¹=¥§@5;! ™€‚ â|:*)„ÞC oòôЛ#\ùº£¨ê!Ü]X3hq­c1‡v2ý7¨'ÐÎÚ>“îHSZNµßRîØ[ù}ÌÕÇjR,¢qò;·mÃC›{6§ºyB“4Mßn4?-×M…ñŒ£ÅÆu×Âèó†O– ꃿÁTåÀá̉@ ²z ™à qï|Ǜܩ¶Û¿ 7R†eÃeÓ²½¹Š@ˆÆ…⡃˜ŒÕ® l>›·ñÌH°Û‹»ë)/2± 3»Bp¯I­¦—`íö³&ÉVäõ=mÀ¬¸ò#z{õÀþ1G{ˆ¤»OúV93›[ÔþÞÿ¡òF_?0žè’̪ŸÇŠ­ÝÉË6ÕEUœí,K¥.Tî˜} ]®RŸ ç «Ö>#<¹š-3؈@>ƒ,œÏ(B1íáœnE¥è8ÀV«ïLé¨Ñ°üÞ¬RµÊ!ÁšнÞ'g¨ã7Ow0Xą̈%qRÝ]&‰§&žíëîq{²Ü¦Ó¥¢› y`6˜€tŸ‡u’•¯üö æ+;`‡[mm¡2 åÖuÞèæ5_Z_ï›QA]ѱò´ªŽmg¥�î‹®>Á€„QîßR@Øviè“™"¡ Ý¥ÿëyœù<QÙK‚Ü2}°‰Œ1¶k)…™Ã-*´ëz-òñf,ÄÍÓá¬×Z–Εի–càëip”G˜rŸ@d«+zœãXŽÃôAšÙ™Ql…<í¸u ›Pîiaæe–º¦ 8êúþ ÎÓ㙘&€ÑRàÿ6cå7äQš@;' ¯“ Éã6ôÄs,*J™ò\¨…–�šóLWCä³úÌ’TKãC¾·²¥wÆ’‡½§Žò½$fáù‹ÍÄo¶‹´Bÿ«X]7Œ2²±r~ÍÓ9Œè¤[L'ùô!w¢52öÆ%‘˜o`~µb¯À‚/­Í´iÅÒ“ÝrUR…ÐøP bðõÝ¿÷{#-º‚¦Uº®v¡GHf÷­EE訪d4Oð’ЇƒzçVžå&{¦wnÀÞ”áÙOzUš9Õ!†ËoïõÎã~k&GkØTûΠļSàY·-J—tAÑ"³’?mz>ì–iü£/Ýäîa—¢È[sÆÂ< òZ¤6¾îß·ÔŒ#éëXÊkVØÊn`¡àçc›°p¤fѪ]Ÿ)§°Æ?)›;rõòÑÊù>WãQÞú/ý·“Ü·cÿ‹M^•F}æ3Òâb𠥚Ñ[tRþeM¡A_¨"¥téV[Ed„|ò~03Ϥùtð6paü¾MùÄ&pSFeutwæ/ØÐ# ­EB~7;gøeê«™áPdWÕùâĦ� ‘Æ|ÓÐ�Äó›žØ²XRFhåìv£H Jj¤Œº}?Y”Å|þDQ`Á#AàÞ—.¿UT™™$˜±'žQ‚² âNX€³¨G@Z58#é5ÐÑ=Û8)#OÞ~à‡ãÅ’Ýà‡³¯–ß*·ù3–Kü”¹á¼€C¯ŒT³¾+DIÛéîM"µ¸Ã69mOxíä˜/Hxµs¸üéa?ÑÒ¯2sGÛ¾ Â]íy…A³«óêfÓ~«êšÙÆþO÷íê¢0õ=ö�Õÿ¢x² †ªÝäë'vdeaÉO¢ò¾=ÑSË«?ê*Z²×^7cQJ‚ Êý‘aHú*b'ö\ÀŠÓeN;é’égçfË€^´¬Õ/S#ü¹v¬rÜM»Qeèèr0ïì]š~¥J%³u©”J¶êw›¼ý*¦“ûséç8Æc ç‰"Nø©�’FîØ5úíêÕT17yrèµYmw ó 8Ý^ Ð§$'™!ý@…¡}â4µZ žñ¬Å­uåæGAç^ê 9„×|õÖ×p©«%(±”â]U{M7É‹Í6AoÁxÝ__辈ÃÌïX?&AÙ¶š…„²Ìøç§n´®´ØÒrAÃÌ:‰xtrÆÙÄba‚líÀžÑ HIëÓŸ?ÕOùŽ‹~†èS(í×¢pÀ¾Ž74vA¼¬f“‡¹$NÖâÖµ³J0¦ ĸ ÈntNÂæžd‰aJV¾$¸[:æ³­&‡q!`½7gÙ±£%Ú#ßñq÷3 ÅëN\Tj'ne¢·'úátôð‡ç–ÜŒ7ÉóºR¯oÉÉTüÌÖ•ÅÊ÷Nf“zfc)´rÙÉÁšÓ>òtsð*-’:HÆ®+œ.îகÉ:ÄBübj/73Û"½ò¤/E=9)6J9-n3îy9÷¥“8Yφ,rwŽÊÒ´]u°Žd[áý½¨lÛå×t΃¸VÙí(}ûõåj) «ãKc`õ2MÜêݳÊmU*óâ h¬œÖŠ¥¡¹64]°}ÿѵ¦ÖýIçˆðía¿Ñ6mhÀÀšï57®¤ð%×0u†2Wò¨îJO`˜~¡g er«8l"½8siôæþÅ5ÐâNÇ®‚§½eó'YÅ^LíÂŒÉPÿ–/M."Ñ´ ôœnI9wžéÕùÒ9uk8`²ÞðÏ eì+H°Ã;$»­ª 2Efp˜ý˱zhûþ‰É»_,‚ZRò\Qe¹@h µÕÛo«Jol–8‡6ø¸á(W?VM+ TÚ=‚!­:l1u¶Í¾D} Úž‚>›Ç,Sg!ÀÒwìÚyº7­}\À*D¾QùÆóÝ Bé¯tŸ,ÈRFâEp ¿×¬/!å4ˆVE/°d™j¢sÆàÓ‹ŠašIe:©¾¡ÏFwpåÓšXR6‹¢‡¸¦¤S=³^Ñ¡Åq¥RºÞ䑇àµ]úË3SÆI¯»Sï]½ ˜¶5©Xp8…¯N§™ôš¢>ýÏ�Ùofì§jc´yåK¡iù²¹NX¤Þ$D/‰âÚ»íÉá[!_ñM4ž?i$±ùöŒÇ‹^)ÜqÆÛߔ^¨ Û±â'è]ˆÒ&Ê,Øs_M’“Ť‹¾7þœäXˆô ’ÓnPãÁ ‡‚MÞR£ÊºF=ëÐ.Ÿu; ;“–¦ÙJKSQr£Í^Q„«:ó6+6¢yäÑ£ü¦ï“}6ú÷,n+ÊÿïåÑãiK¡]þyݽހ`3PÙ ©ÙÑ÷‚˜b=ôž‡3?Â:‡<ȧ/G_‡>úèYÃ2•·Ä(.¦êÛG ¡Ë§?ø¹ž5 ñí ˜›V'ʆ‹€l6‚yÒ{žv-& ×R¡*h"S 3NÈÎZ×tæßé.;hßËŽ*,Ɔ²ÃÝÍb>:ågAÈç5ŒXaú"ÐwÁíÍœQÒØ¿9SñMB[XDo<ï×®GËÝ8l9µ£Íè<¿ÿ‹Ð;(¹2¼Ï‚¼WíÔ4“F;•É¨ômhékžjÈÝz¢Šbª5¾W“u#¾ÙO;Š¯JƒFþ 4§8ÑX2¥:é {_´R2¬Îÿ÷­,”ÆF‘©BsɸvýUëÔ#b²<e<_¼ÖiÅù„#O‡ NQÝ^&¨Ü”›Échl0wö±Ýå`Ö­»z@ObWî$Ll®¡43ª^⸱åk†;ÈöÚÞ€ ìåBÕõ\d÷Åð½ÉƒlWÙ�Ž …Å“˜j/Å^]IÛ•ÞæøÿúG*V2`°RÚe¾ôñ}e¶xJè̤ڒ ?*Š# ØÚËØŒûù wƒ#ŸÖÒ)°Ó~2­‚#Tïxy/´xÌ4ƒ*QJ½Çͽ–±ë›ô1-R¿YÍ@¸­˜ñˆk:éìit½¹iÎY‰wip0Ž*O±ëªH';¯‹Lnó?}köólßSj;…Ïßh"¢6ÊÖÆɉ)«ûúÎT8 Ì…ºâÓ+¥±oÈI—ÇÉ|± ;#ñ.Ò!òü£ôdl_ñcÒwò¬šÑÛDJ¢m($1;-žw ¦ºùqo±5ç*§%JvÔ}FÅÒÑQ­L”´aÃT?³¤å4œî©”™¯çg½ŠŽÓÖ"·Á¸h»ö¸£sIN½Å,è»±PV:Ñ‘'kéoä¿]·«õš“§?RÃp„ Ûbð[¸9ÐÕEn`Ò¯DÏ„Õ¢(Ó@+N1f‰,RÏ„Àý(‰"Ž<£Cý}C;ÏÝÞKÎn”Ÿ'µŒ²„¢õ¼3Ö6ªñ·ß¹º£ ¿rØÊ(…ÈG„›­ N͈2YéGÕ×áÔó„Ö® àAV…{¤° šŽê»Ý»G¦O37B”ç‚Z M˜-jÛ‰MÊo~¥¤_*iAÝ)ñÿ¬U Æ™Âl«ˆ<žoWçjøbÓmŠKË7_’ûïƒÃ´H} Et]*Þ&ˬ6ÐÏðÛ½µMÏ€;Tcëõžß”þmÛ4öU^%Ofg†»'ã—FÑA¸ü´gS–×”š#èHϤhk'ð$&6Þ{ÞÚ åÕ¸q¼áQ‰ n·óÚ:SÛfn«ùWQHn¢›L»¦Ü±Øm=¾ÎÌÉaÄwÕ4Q:¹‹‡P­$óT— Ï>•ègðôÂLYÀ º;W>€© ¡á¼$½öêY½¬zí˜Î Ý‚õÇ ¾Dy郣¡·…Ðy6“®¥¯:ÒØMܵG·ï˜A©ÍEÐð:a!].Èé½»S'v%òÞ·ì%å0Å¥¯…‘>çûäPìkØ°{ˆÿ‰é†œLy—צȡ*=ƒÚhP-OïÞiA“7d6ªD!œ# s½ºÃ®‹Â%TŒEª»"ˆ«Êô^P@`Ò)b (/ß…]+i/FÔàN´Ï=«ŒBÜŒ ‘¤àc<V_ÏËlÛ(Í~dª@Y)~ {}ê·do€d·M6ö¹´ÉwÄ›01È1bñqúìï긘² ”vý¬|óúÔ/ïòUŸ%sI–v7Ûž0&—ªôè¼)Žn-·ýë¿Ò?W`¿mŽNÛ\ÝÊËBÄBÝ¿ zŠŽC‹ÑÞÕœ/rÃB‰®›<ˆú³õ‘âŸË;@ÐBæqEE«…]. ‘hæ´¥2íûj§y fÛ·=ÇÕÛ)7½Yå‹Â†1•7Ê@H]r2ÆcI)&œÿ¤§­<9!¦•DQPÔš²î©æYŒÝ5¹"¥„«‡É>÷3µtå´¡s¤Šó†¢Ò¶ñô#YâÔ)�Ïhs<ãA†eâ`^%Þuܢŕv¨ÇL5Nb $ÂOW¢G©ý Iû›"bN°ì̉óÝ0±§BÃYiPT¶Ü¯²­´=.ÿsn›Óˆ<�*³{קŽNgÀWÏ›t¨ Ôøan8œÊdè½>1â5ËgaÓGAZÛ˜J¹©]ƒØì R‹¼Â^² ‹ý6DÂâ.q9oß.^pI1Š|wTÊÔ‡×èD¤XèaP|iÁ2äƒdjšT™õm^nT:RJ3ħM䟻3òÎIAÒ“D‡”uõî4”äç¾½`.n}Nß Ö&ûÑÎÕªõ¸ïû–ãö%™9l–|½J£—èR'À­g6=üu’DfçF¬¼ýw½(¦‹ó Ií;U«ô.ùn,ÝãÄ(ÁV «ÿX7Rê¸Ï/o}GðZ&7öÚtº×5åêïg¥ Ø„õÒú©rå*¶ˆL1ì¥â/ Ò~«·$1-ëz3;ÿRrì›20 í—áQ±&ÆoÐHB-EÚ=¢ovJg©§;Åf””öM¾ãyÍþ¸å{Û]øI¾ÈŽ7õŠ‘µRré¹Ì†à`ŒTt/BŠL˜çÆn–"çrËW®íß/V>VŠöÅÄÙíN) ʵc|Ûhg4[¤xÀ ¥±`½îÊÛ‰O[¡ÇÔ·q¬vÚSÏy¥‰Í‡Q|FKVÝPìå“,}ajÉV"u÷ËßèÔpê77íªûVYìëwG}•ŒÎ�ë—RGB ŸŠÚ ¶”¯ÓÃRèCn؉ñ2øBôÖQê±V1z«Ùû—a,ço¿Þ€ìN5ë½Ø4|Åq`σ3„µbTà.·ÐÚSWá‡â•‘m9rF@»ÍÁbS{ýÊ«¬Ã;ƒÅ²ÎYp æ ŽW†æã˜D½±WdǼ†TŽŒ£†VG»U¬ ;O±ÅË‚¿WÉŠ(õ\EÊ †k8qjIc Eû§Ä¬(O}yR^=ÅOÜÅ%KŠu Ò¶æ</Ÿ"ý²EÓ`w¢o½«Ê•ç·~OkÖâkÛͱG:æ]þù“§¿ñc™€²›'×'d ëýïg&ÝW=žû¿…Uí•­ÈTÁÊ*&°‘W3+äú”Š» 6IñŸ¨Õòg$ …›q§¸¡ëŠ¹ÓÅ +~dè?¨)„ÁQC;{Ñæ²Iâ(P1ÛƒàÖ$¶ –ƒŸŽÀ,ê’N?ž¶lØóÄ{:Í ×;7ˆ‹½m§R ›Ó„sñï[âÃRƒ«àdNkoC)¿~½Ò‹ý¯Büêx»/¯ª/úÓÎFÄäÓ‡ÑN´n$‰‚¾Éµî¿U|F–"45}LÏ´ž=¼ÂÚÆ\Ýà*›ÿ÷òù™‡û(ñ°§ Ð|_ß±•1y¡»V5ÛKßUû‰ÙÿØ5Çá|™Ì?=ë›03¨S‘b½XJÚU]³@¡¾‘c-S¿íKw¸Åh¾ïüχ$£/×@$¡ ˜)ìíH®ôµ#P¨ŒèY|í¬‰$}Ìž|Cï‚OI8§GúzÏ/ pr#8dW°‘_±uaAT1¥Âbc!&rõÑ* ñº¨ÓS.§ÿEšh´ú{ae­vZ�›ZúÂ�tòЊƒ­C cÌ!mÌõï"{µ–]Gœåäã™ÏJɾ[ð¯ñ1Qœ.äsÀ5Ê(—9kO#«ƒŸaPð9.à±ß�ece‡If[¼3EËYŘÊÝÕR²Ïv7¢]…³"I„ŒXÒæ¶]oˆ"ðÇý妠pÕùU¹³Þðt1W�.á7p¯ýÆ•(tíLLÓdyOÝãÐÚ•—F:y‹ íÞÕª+TìÎŒ1Ž¾ö ´0c èúóÄúD·àMÇPËÁiˆAYµ(¦ÐôBYÕµ,:ßÂàá‹ÞîØåA´ÝxBÓq¤CϾûíˆE3€Ç¿@TøœÅ€Nô�ÓÏÞº– œâï8:l(3lç»ð&ÛN2*~%Ÿ9-më `ç÷x©ö‹ƒ¼Ãíõp(m“ÂÝ´]v³;Øy€I_’î,\‘}ô”ÃPÆn •¢d õlìí,§0Zú•B€^kØEX˜6ý±-è}b•;ôÂ.§Rum4¸ZNE™Äd¿¾µ—É2ÿk¬Ê ýŠ‘“TÞ͇�¹)™MµHyiÓšYõhºy¦+‘‡é²bx`>›}·§C\ë '˜À¤Xˆæ²ø" Á¶€KPYíµñzâQÿ™HxÅm9�éMZúÄìÌ:Ž—E«ëPíòì½+5»*ÓkR™Éd5© Ù‡‰y¦NpµÙÏÀFêÅ §Ñ–±ÑÊÐeIäã»é[BMªßsÎ÷s!e–Ú�ÿd0d˟̘>3a¦¨¬j †+´ª±RM”f’<õP© ä@ö)ïüq™AEÌèÞÊýY%P£ ‰(pïw7Õžµ/Ö”þp¹íL·ðƒGÏP‹´–Ùª’ÈÑŠ}{DæÀ”¿¬ýx/ȸ¦Ylâêm"«ïÁ¶PZ°`¹W³WäY›¨¤ÆUæ2„àšvæt‚s$0C†\êP‹~m«Ö×)Z¢–!Ù!ŸÙ”å”5ë¢îf0ó ƒéÓ½¤È)oˆÿ$Ýß&£¢bë·1–=Ç›A±$ð® X$ÿ–I-$1ñ ÙAÔD&á>T÷ ŸáëÃU©i=³È åi°²?¦óØ–æoÐ)V÷èip9}þ䘻W¿ÅÚwõ"‡ºa¥ðº¦“¼U¿…œ–óŽ=.%†®;.´ÿJÌêA‡à‚oáYå¾g=÷Ñ¡F£^0oS[ó…ªBåÖ…ã_Ó¾uûÊ!L"¿5aŒ¥¨ZÇ­’.Ž0›ƒ|ûKµˆÕv;&<;ŒûGP³>#ŒßAÜ4ª=1_Ô€]}X/E1tI¾«¡:p°ëöÒ¹¬x)áúL["Œ3?;Á\ûìäÙ³ª4˜ê‰ù‘^–›Ëƒº GâT ísk±ý«˜^µ¼é•æ"Ïw*d ²-êµB·(HUÌCúÝNoïÁMG— É]Ýì__ž'õo°€:ƒ>‹Î2ØùÑîŠ]À�3¸¶;’žÖß‹úª7²d #;±¤C+Š£þµDJœ5Œö»†¨] çS‘Á0^fÜŒ'JÞ¨>(f#-™Wp‹©: ‹½ó!uÚ鉣¦ú°£¤(m_³×Íz¬Îaq¶ËÆmREôÈ¢¡5¾k(•Mu™ÁlNçý*9r‚(µQ­o´öÞÔ.5†¶ ßTPë©í´86@Ú ½Á¬…U?­‡CÝú—±ýÖŒ+NTÌ)fʺÁ[³Ü^½�à™Us¡C½·Þ4¾n/J4õû#ep‘µ_žþ1ÝÍ+]t×gºÙÜxas×þÕ¨z·J¾+3Ϫ`ž[gžTõ ”Ö*»ú¾ÑAÈÉZ`lGçþ˜Å ßGFw¨?Ó“­*‰šaT¨Xíù2½6‹ÝôCzu]ùîäš´ ï1§.å¨@.iພ½Ïš%ð‹ÒëE2ûa}  ¥›;ÑéVc‰sزtʃŽÿïÿÀzi0+æÞïD/b‡n¢Ré1ïÙ褫ИœtŠqùØŸ¸ÊÉâ O]P8Üjßó*!ʽ^sÊoÚÓ›†Î¡‰ÅE!Tí¨Ð�“ý ]bùB…©{ÓßÝþ`Å<,¥G€ŽÌ·ªŽÔÿÁD:4>n},¢ÒE§ˆý‘¶6èÈòǤêqVΓĨY×bW61ÂÒ"æ¿wòñ ïÓ4ˆ›ÆÒ2Š@0:Ü–lŽšpX^UœSÍgb’Û’Ö«¾ ¡ýa0]¨„x÷ǽL˜†q¢š7OÁ±½Uãazˆ®v ¡MÄ´¼)š¿_<¬©ôjÞÌ@€ÂGË-=|‹Ã¾74ž+uŸrnOx*ø¤m鬲l³¾þf:äÑV2<€™i?5‚%ˆíúb °uzˆª¢ ¬ù‘_iå‹ØHAëD9p>êl8b Fjp:,ž½XÏÆ`÷Cß•¢1>u×%”r{K` ùLÛÙM¸ë®¢¬åô¶Ù´ø¼ûa{ïW‡v?îÚ¶ tuh™ô…i\ï·Yu;O•ž6íï}ÿƒËØó×æû4–Aºí=Ã;ƒT HÛqM†Î$=Çœ‡7óbè¬T½Û¦ŽÛ¢DE'DMéSýÇKk$Äò>S ×ýYÂÜuÙò�{ú©òÔYйö€º?`²Åèˆ7g|SÎ'Oâ´k%Wçæ6}´C JÆ_"¶¥"®ÍžeS ~851ÈJ¿ÏT…-Ú83Hú3Pé•…)±n›TÏ¢a6íÚߊ-Øo+ýçýÄGb°‹5ÝÖØkhÄœú_ð<y6vwk›ÉEñ[a–G-årt3†.eµsIƒ:U˜]8Qd:øVÃg¬EEY KOÌ2[ZÃç¬Ã9sP §ù491iÔÍ×í«'bÌiá²–äi({ˬ9F–îÞù‰¯)¤pÙöÚ/býÛp ýÕTQOïž«>2Ô8M´Ùñí…âÝ”$¹Rå·á ¸ž¶v›™ ›FUÕiy…ž¾ÔÕ”5õ’@?ôÛ�«°še·§x©ç"7“ŸK±‡IzåU}ìB0žô ìN_@†µn©¸ß¡Ù<}´,tg.“¤>:Â�fãLȤ%h“ywØà;Ûñס²c`»�¯~ôuùKP©Ò_P̵C¼ŸúýÑr?š íü_ûþ;LÓßÔ¬|âÿÆ%™I±p¶Ã®Nƒt7º˜1�,jbj_ïtåhãúˆ§à·w‹Ÿ] 8P«8ƒz’\û¾­ÕtVeä©Ë‚¤U§Šjü EÃ…BwJÉÚEÊ*Û×”J—•ŒP MTÒuî»_³ºýj©1q€ÿªÿò²q t–FÇQgƒ S¸'#ëŸÈîV0 ƒÊSÏšs(¶’µpܹ{iÞUóŒ@AK‰BÏûÎ<†X€#À£«fë@i8e¦¾b—(¿ÒŠBêÎ.N몢O/ûZ*ÀL!‘abăz4óIhÚCÔÀ_‹‘[Rý éï>•ü÷~ÍX@u_­yoÙxÜR]JŸú*K/R² ¿õŠ:tŸ*ú:\Ð{Ùo·L­E³ç^·º0!+î)¬�É©dÒª?d=$ú´OZ‹QE™ýò“9û9F3ã!£ÚHœ[#ÑÐv0TÌ ùäÙæ8¤ˆ­Š.¨| tý;ŒðŸ¨ŒRgÚŽ/ð !ãVMȽY ƒÿу–Î4‡aQº¼—Zӄ´Ÿº.̓hÔ7FÎËóS:Rk€z‚l‡Q_n釡òP"iG—ô1ø4®¶\af¶Å¬¾ŽqĘ6»½ÅÒ§-ÅBÒoJþŠ <ï̧æçyÚ¿fZD-wƘÞÎÍP¿§æÞP˜w_j“säéO8óW2mQC†¦¢2·SXFŽ ‹§¹÷ºf¾|¹-…üþ�Þ!/‘Lzhc¼Zujóð“Œ;]îHlxØÌ{@7!NíÎÕÞî"±=Äý4<A»í‘ùIîpϣ𢋢ÛѬFLr ÔwzcÔú™âøæß·Ðp©¬8xÚ‚Ëyo3ún·uW¸Z@œèOæ8\gÏYsá´†L̴оs9ËÔwwƒNÆ™þ@a•ðAJàå"ýêN²àÀ#SÑ̘‚®ÏôÑ9V†&±ÜUZ!P´Kâ!,mlÖšxnb›2Qă^ö¤ VŸ:üÏ„Ir€/s¦ vÓüÎÎ_6tè™&¦wy…Mg åe Ç˜jÛ§$@nO=ÎèƒIHsY$l†õ ©âÁþØ›ÛÎ-B‹¦¥ýÏ:»JåNpFnœå}GÀ(SdGb›‰”mÆ­ê2„< ë ÉZ�õpFb÷ªÖHwž~z—»Œv!°‹»,òÑ‹FTòx= ¡ÔmmKGv¾k,S&VJÜ’ e’VÈóP<EúÄh¡>lþ†Éî_®­|ÅeÚTÃÐ_n¬z(`jUsÑv#nbU›�n/^ÀÆéB·d¡¬Ÿ<8|´$;µ½:“<áóÞ¼cw2D–¿UVˆ j AïÚú|•ˆþ³aª=þ˜uó²7n^‘ƒ Eñ»ŠÞ­»‚U)·ÒbòUPB–\YåswÏð(æÁéþ…9ˆÙM!F>kH,�:3Ò‰”‰ºêî„ÿˆ·Ò'f-÷gJ@jñ3ˆ9aÜîÑm°O÷Ú»æ`¹ e'•–VTbûYifŒ<±‰ðú´Ùà¨8¬øFgÇ·ºšó¼b4»ˆÄíÙIŸ1/½_· ¨þÏö!–¶)*Fa(ô°k<˜’xS{ЯVbŸ Rgž×|*욨d2’Š�Á²>7Õ÷Nºæ÷~z8¿M=Â^&Ù"}‰òxÒä^›hjIÉ&¾l߸³Ù·0½Mî“gµz䦙šÌÃêcO+Ì€¬�ª¹î˜ßû݃.ºˆ¢¸a=ýåá‹þðÔ˜ÌzG»ò2�½ñšÝÒ ã1Jˆ¯‹*¼Ñ¥_RrÑݨC¯M¼2Á¹ë@™nFWHÎgàõ°|‡-àêíˆEpíêNÏ’“ z„µ½Þ²(cîƒÞ¼fÕ0*£Ê]=VÕVÍÓÓ^A*‘òiË­9ý=TŠÔ£”“ó„yWajªñ Š‹–$‡Áq,lq>Eq/ n#x "Û]µ¶ä[ž±^w‹“ó\Wœ[,Î#—7ç:h¯ýn¡hf®¼Æýe¦ß=æÁÖ #K1Œà~y;´g§¬½n¬ >ÝŠ¾,¹iköØ@ùîÓzE °eÉsAá¼ ð{ô—F+)å;c$Âw Ëe“n'Qõ A ÚöZbCâ·‹O¶¯ÉjÎÜ’Zý; Eè2$à’иZèµÐúZ·£5Sh›ÞC½¦àŸj 4„®…ØmóåÉê* ^tƬuW1ûÊ”ÕÉïpµðò¢|‰Ü¨ˆ¨7Âä«RàΠUE+Àìè&o6¦T/p„¬!žbÎ-äo=:B][…À·‰vðC„ÿRoZH/©mtŘ貖§„’Î_WÏÙ/aù6ZÌšK¨öU0mY˜a¥LjDvO·Ö‡(/ô²Â¿ûWÖ KИnQM“ûþU “ÎfäÌHsF¢üÁ¨Ë—åOå©#˜Ó½™?iµFõÉ£eó >gþ;` -˜Ûý¶¯—8ñÂÓåd¨kž�™4>ògMÁÐ_¾\Jô­ï}œ/Â�t°o³V‰  uhl$|®¶é(=Èyÿ¥=÷ÿYû³åV•em>f]…Ͼ“5ß oA ÆF ²fü÷>™•U…,ÉòX;bÇö\[– *+›§ÁÜ4ÐyDkè•ÿ j2=‘,sÁ¹6XjTÁ)à0z'e€C÷®,˜ˆ÷´æ2I[Ò ø·÷ÔqhïšÎ6…wVçV„¿ °€)íÿAG%‹ÔÓV-Â}QõÕ«vn™®)T™¸%F³†p*¡¨RUáɳà¯^¶LLœà…˜k¶]J·o牠»âk7TaóàË}Ø74ìæ[kÙÂá¹Ý}A”_…Š Ê¿`ü¾ŒFýoÕ+¸i8ǤجãÍ*B;}°¸ÅBðÔ:Dzg?—„Q¶V°*ÀÒ ©Ž¶ªo™`[N#EÚi¶ŽÄ¼£Vþ+hsÌŠ–™¢EZw®ùÀÞ‡rµ! <>TZïýÚÿ±)"ü³H$Qè9N;º×­f‰U¥ÂlZ'”&èÓš™Þ½ÿÿ‡ ¹7gSJže¾o_=ñ—°2°ˆ¥N‚bnÜÔ“W©›LÂ瑱£_ê3ãÌ«ÑÚñMÃÐWæÇç3i{Z°Çù}¶¢q)Ÿ–D(éLˆR¤¤¨øe ‚Èx²”@ì¨Aaa.;Ö³$Ñ Œ¿Hí6 ïíºDþxbWþ’öR–2‰âÊã›Ï€€Í+{(_©G³’¥³&2 Ü€‘‹d3̘–U¹t’€Ø÷ÊÂpEó á2�1U)cwo¤¸¯ÿí;a`,s¹ U_¿; ¤¹ÇÏ`µL‘‚T e\[ÑG�¡ÎÎùëGÓw'Ž®¾0,7‡Ž+UlÝie^’›‹œqf°T`‰•©Ð³­¯3“bìIÿ–±'©BXá"V󄺩R¾užjñ€µ§)® |íe‹§æ–öô2EBC‘ïɾÖ×-ÿ£&›döÖµr€ŠPÖ•r¤Î¸(´WPayNGæà+S#-Œ,˜ˆ6ÿé\ß‚[gÔ‡)÷EJo/¿;§P®ÚÊáã½ í–€–@hr^ tè5ÁˆÄ5RÏbìÅûàñ²}åÿE†ÝçÝ ï£„¶YäMo}•!€aZô<ÛTÆÝãÉnèqKV?ðãD¯}§LŠÌßd¬˜ÛØFù˜Û¶Y;Õà ¨¦šf6ÜEù¶Oîéä$¹ÑÁí¯ K*H,èKÊEz*IxùHÓˆþWçi¼‹GÉÓìÆ·Vâq£äÚ ZËq÷ó,£b¬„™jN(Wfܢˑâ­>8ÿïÝ¢³Ì7é k)ƒ¢U®7zut¹àîfôm{îOû¿U#MòÐkÀÐc;2·¾8üÜkzîp:Ó!Äo’á걄E°‡Týå±Güƒñ…©ØÿÖ5Õw8à¯F‘ÝvÞ©OU¯ˆ 27 øÎËüÝ[Ôã1EÑJ�”6cO§bèF°³é ØK¯¬Û‚ å­·©ž;¼{d¦bèEgí|Š`ê_–Ì)¦£ÒÄhRžp¹‚pNn{ØÐmr—†‹áü¡~p¡˜8+N ôä+î©ÕG¤SðúàÛ¼=÷wp&cõd©KHÀÐǶ¢•Tm·×a€…>¾ý§ÅÛR÷R÷¢Mþü7&¯wmˆ”ÖlTKUd³ó¥süã¿1pp¾™Á½²XY£‰E”γÇôÛæÆØ`áñÏæ7¯J—•‰4qíÖôiPÚ„C36qÑhžLÄÖSré~bšgÇ [vJmCc«°IÏ0 ¢ª›"þÏ°£ýéرAÑL;h"Ö¾"ÍÇ�Ú°ÓCü•ˆfZ¬ÈKðöHá»r5êêôC°{“ϘËy:ÊWq÷e™ é·;É|š‡’$Ȩîía²‚:‹8úâ™"F2Y²{—Ñ*âK-0~Q¾’_þu(·ölú•†Ÿ£-F½x�*ͽÄ45Ï€nL{ö¸ ;:VwúÆíšd÷¾ÈÑŸê·m·0c#•³ûˆ¦cüªjï ˜ÕA슋噎„ĵâ}eóeâ™UˆÄYÞXҮnj¯´ã£0q° Ž’é§ :%Ø3�â:}ßÇž’~„T{3Ð2'g¢š1´¹Ñ(ºÓ·Ÿûºí~+ù–†™§ò'"L‘Öƒ÷ä㵃`…)+Täžy'» ÏUÔËÖ›ªØfÙoDÁ�Daœ¾º! ŠV€ý•ó4curwöXï†ne~˜­h_¿îJ_aƒ Ê [{× QdgFé¼õç²}&à?â#%h‹Õ6è´€+«A÷tÇ1è¼Ô7zPOt¼ª;bîwÏ9¹¯ìÒ­éÛ‘tTR5>·#­V½Ô]dµÂ¾ uÊWúŒŒîµýôü+n|¿ÑÑJÕBçªã?í&E'ÏÑ[±sh+Úúì§[9?eåËê×–4ˆÛÞ±×ñ¿5°Ÿ'N-Qá™QÆ,iÕ ÷víò(¼¿y›K ¬¹ ±ÿµSºG ž×¯N³o2T¼¥®ŸÝjëÌTJŧ'M¶‚× ^J »ÌQúøxˆRT” ï<‰= Âêö.Äã•Økì•C%6zmÑçÎ4€ˆøC¥Ü¹¯=Üóƒî'ÜV¤™™c·D'u›ìëóä\çé›n(f…L§²€Fm'põyß° TÉ&ûƸ çZÉ$©ô×ÁLŸ»#«Z w2 dP_WHóÊ.¤4èbZ0EÚ˜š8ø¡–>¬D¼(ošæ¾"ó”è.A¢*¶Ý2˜²ûÖÇ»½€ú?�¹ÆYßç eåæÜ\uS³£¨³+¤¿ÁuºÔ¹@×Í\I¹+6ì|¥ë¹Ãà~>CÊ ìô„MY”¿i¬Ìåìwt,)þµô„¾Ì ëT„N‡¥ÈºMD»®Ñê,ª4÷hÆ ëð{OùGÁ(u¶3»Lô–ÚAhD�J¾Áùd‡šh3Oƒ7çú‰B®œ'bHA1hŠÆoÿ¼¥¨ÍÏS/MÛŽœ uÇႪX%¶È”}žT|ªdgPèö®£Z ÕùåÏ^K,€ªŒÐŠ½0 7ütöîÖhyº«ï¨â|-ŸH îéðéaÏ6/ê3€&åÌ^á÷ì0NÖÊ+Te|, pvÚì£|Ùº*¥è5“/ÝÕ:îêŽešóãÐU—Ù²Øb@\v³— ü0&†Ú©•½`ÌÚöJÙ±E/B•ÛAÓoŠ¢Ó)Æ1Ýu¾÷«Ëuº3pòýbùVèà{ W^ðpáÞ³¯ÅSâžÛÍ`9T7mTÖá&‹TŸûHqRyW­þlãaGuƒÑ¢á‘Æû¢3úÖé¥r䆮§”b^ Q?iXm7£¬P—¶* ¡8¹Ý5µ@i}ãø¢r:Ë1¨4Ì]ç#BçclC^kåˆÞó©$ )#«¹7¼ŠXv£;æÍx: ù…·¦Ðw§V*"”„"×½ìÓæo…‘÷5³¿ï Ü·LΟÌT@òÌsD“JÈVì À,49&ÍAƒ_hPYýðsŠãÜ·¨bÊÅÔÔ"̈É43¾—8žÑß B*¹ãˆ.Dw}BK¬/7wlùWe7¹œ—‹ï˜ð±t‹ðP¡·t\rÖ"v­Úׂ=+ÛO>Xr‚” ¤w'yâ³åhu‰.µ ì67¶»Ïô¡­yžJL‰š'Úó§Ã'�ä?½ÁÃì–éjãgNf7'·ÉŠðKØñTAùi-qÙå’Åh\ŸúÞå  ".2?6S @g.ž´Tj0Úê;*ˆ>rý_óNûãd 9 !_–зÚöšdK0Äú,š¼ü•ÒI–úmHhÁW‘½+E0K:yûC·8փϤ¸G¨°L‰ÓL‚¢ôè`ÂZ6j¤¢Å?Ïãɾò¬úÔÕëb'SØ‘ñî„Ë9xÎïJüæG¢ˆš ?ãÜŸO‡¯O‹p»ss÷Z¨ÉVQ\þÓ»Ñò¦Bðß·tå÷ÌyýLB·XŸaƲfÑ©ññ]qúCׇ<À�:ÿ’¶Y§7ûzî‘Ò{6Ûú`ðÆœ â7f¢ÿµè* ò +Àï0‡»QýTšòPéÖ6ÌRáaþÊ>dåÄ‘ãíù¤íÔÓÞx¸˜ípS÷Y…xÂë •{ßÂ60S£?‚ž1T #dq³(µ¶S¤•ªÂ\A£ówóòÉ›4óæbáßb÷`TÑáY=âÇ?|{èIzõV õ*alZ8ÑQcÉ•À‡2JéΕ ŒÚzºt~‹æCœù|ë r A¶m}ø tÁG»SÉ»ÔCãù¯ôQip‡÷4Hú�à^b8zÓÔ{XàET¥D¾1|àJÞiy°–µËdYO‰Öôâ9÷Üãv:öô9?µ ÂX]¼×ìiUCŠŽqÿ?k.ÆåJr ƒ¨0}üO«¾ö&m fêÖ§ÓŒBð\V8Ý´ˆy‚3ç›ûO§¶@‘º†oó3õ;íè¾Ï(YZ&#�{áRÑÒ8г7EK­†ÓÈ™ŽøÃl·s¨¿ý³©›J C°ø<˜�’³uÉ$-fc-%V^FâÚûשŽ†+[ä0è†8(O:‰Hqj6×Í™>´º1ýØ ¯boºtu¤-õ{3D‹çk‰õ—Q¦Þ‚xâKý§Œn¬œG€9?ÿuÁ_z:o· ¾{æ­•¹¾¬ ï*OG6•ˆÈ“Ê0t”©šÜö‹RO½‚‡§‰Î,kÅ—€-lÍÁå&lážJêi£.¼a+C–!©èA]ð@–sÖØú4ZKÜü8`Ýê|¥Þ„Zܨbš®.Ì›Ò];iÓEGÉÝA~åÁ’Yã»Éi›XÂ|”c@²©Ï3ëBJsKޘ†‡Ò¶áyä7"eZù–>1ò¨Š{ôÖÓXEŒééìÆÖ[M¿Ñ(Wô'ZXæSãZæ+WÒz:´›óI_òý«5üÚp9Ë©+ú<2nÁŽYþ‹¢Å4éiBz.ÚϾEá~wG‘Ùúíû'Á'Ôu€@² j®v–ùöõÖF|©§^a‚7 d*?M•¤È®T¿O€<¹[i–BÓ=»NN@[IÖ‹3:g/ˆ»G>ÚçœWX¥Æí§“ªâšiZàã§ßãu!ïȺ­‡f5iTõ‡LíãÐs–bžÈk‡´'i‚ž³«G9´n+°º¢êµ=öó(½ýÊòàtxâ&k›#†-g7‚5X3œ ÞE9—N?Û.¹ÁfhºAà÷fÝdÖ ôvU ­ª!Îpü«ÉOVúÏ”öYÛCRèÜ;˜Wjïc3çÆèÑPd¸¾™Ê}ý,'âLÉc�U3ÅhjÌaáFíÆy+ºï(PÚi4G§»òè»Þ½:«qžèTB)ü̪ôÂnnS7]¬Ôð†›rJèZÿô0šR"™jÑ‹!J>Ê †‹}2ÿï­>´ïX+Ô‚]lD™…DAßÆÌ;_úrÇ·x>ÐTÓÏÁkÕ¡,ZÍËœ–Ý=²f’º¡ã–™Y¾¬’K¿ˆ÷JZffþ¤&m+9;€ôø*¹/%`e0ËDSf°}{Zû’ »+¾ï~*r£tàÍ„;tP¹ì<’#ïv#›í°û>æûùWŠ“µi)ZtÃûÆ,-–·VîߕÂ(óòFUW´¤-„³DÓŽòßéÏx0“ 5®¬Óý"À:*\7„‹ÉéÂBÓ:„åEF3γ=Q0¿«§®< UÌ=¹l=ئ‡8ÆA˜–ךþ_šÀÄÚ|JÍô¦û¢œOµ{(¢î9ª*F‘õßCè•8Ùµ76µÖ�@v9œD·š \<u»šv§aq¿âR›®TnC:kÊñ_³§1V0ðÕ+èÛTú†‚ eU›q:¿Í’Ì %kä,«º]Ò©É-t;Ð_`~¸¾ÞðÄ3‡¾çñÕi¢CÎÂÓ¹P¡h îŠÎȧ¥¾®²“ÊŽZ9é –KL'ÛŦºš¾¡WtLDeûD9¡Zv1ýª›ïé|gnç²MÌî ¿x+¶ŽÑt}ái˜êÿï°[îúžÁÃõ7[ZÞi¿xŸ}`þ~6ä<F§Yx³Œ8qhÁÐîݾaȽ믲ðÕccîöSLïv~ç‘ä†~Õº¤\ܯrNÊsk¹ˆ!Ã|ËßÀ ˆ öû9zQy~”ÏNGZ0_ïF‡ŽÎãÉVm`å*}`èÅ)ô„2+›'H¯ñ •x§¶Î‰ðÔþàæ"P] Y}ùá„Šâ¤2xI¼{‚I?”“ÔÑ&"lÿ )ÓoM¯Ü]<™õ—ΟM.ìüö>¬4 «EŠÛÈô¡¾êºÖ˜ïšÖ™Cs = tnËóÖ©~¶¶õ†”îéØ ÅìÚý“‰c‘癇`¢…³Ç¼QGúÀëu_¶Ðú½ãöö%ù …¿|&œ{¸{Â.ÊY]vŒ$³Ë8Á6ü`7¹á7±º/Ú@eã ê7ÛSj)S …kLƒLêL†q{ÈT+ãúªAÒ¨§ N÷%`§nã�Û·j˜ßt1Ý�\@bÑ¢ZfÆgRÓœªÏxjL9k©þ5VU¾á3‹%An•‘ScL‡¹'|òs§,ò˜E¢dqêAå·Ñb"’¦SðîŠpø+wÀTÕç£Ô°Š)a )“˜ÝXÿT·­§¨.ª ½Q]TŠÜ“|u¥ˆH)äaWåéËd+Œhÿˆ­‘‰ KUt{eýc'ú6FÑÁÂ(ÓПšÒñ6ï¨p^T„^üh}e®~.µÚ£â? öÕXÁ?5œH½†¦TÕǺ‹2Î ¥ôÚŽ_ZݱÜ="5OpÖ$†‡8Iêñt˜À8R•5GÑÆcqâ2íؼì….{¢ŽØi†ŽŽ€°ol»ý™à8ô”•iº÷ÓÚB­ÍÞO(•(i K»M+BǦ‡~‹¦>•8HJ1NøžWÿOÃϾ9G)EÎH&\&r»‡X619Q…w˜Ð­ G;<}ó¢Ì<È` Ô}Þ­i\¨ÍDn7 +rJØÖ†Óo/îp­‡¤¤B›-ú‡ý—çÜÝtg×i’Vyù‰�u(WGŸWÇï8AµÊú<( ÈœÝW¿«<ò  Ø„½¥d#VÌËy²°Á–F8­5 Z÷ÁË^~ÜÙ~"×^šzápŠ™ÝzĤiüðcªÿAù™ºÿ?5˜zì5«®Ì$BÊ%ÐÕÈ>•‘H¥ï®†æD;T’:û)¶S-f¾m[µ.¾k¯g+ùêˆÒ:¥ë‹Õ+Žãb’–±·xŽ»—6þ©OXó“aÊ‚°^¼[&`D3¼7ŠÖcå6‘fŽÐ!¬À ðQ'åð%ÚÛQ8·„áacøý¢Ìv¸¼ÂBÝOðo=¾1³�©öTM‡#°€ôÂæn‚†¾ÍeÎp·.†©9v$6chê:•\n=§i%¡g˜c-Ÿ) Ê Ž¢0÷¦b%Y>mÍlõÇ„Ëj'ÆBwa  Ø·‘"â°-²þ‡.˪EO™õ“Z ÌQªàâ÷ss°è€ï‚ú¿—Ø÷&a2_Ü´n{/Õ gàÕŸÆÎXX”ûº¢Zád‰¨6 ŸQcQwÁ³—;r¥×„̽}ΡñÄ›þ@teR'IÊ9Œm–DÁ¬RO.•!„›=¥IcIÿYnÐ "mO~!°»¸§þZänìZˆ&c¤g-ÇØ;¾£Rbšÿ±ÏX”zXÆÕ]}ëxÆk%z*âi3D'•Ó‹Ù>˜í¢TÂŒq¢{'‘ú¥ª¾(\‹¾}úÔétö€öýªeNz»Ð7œiScXòOsý‡BŠ 7»ÐZ%i×éþ/ý)Yné‰$Aü®z±@t(zÔ¤x'Ê»z®_/@]Àq*vo §Òy¬±¬Ü‹ãA&+Ýnô"úŠì,ŠÍAÃÆ öŸ»‘ÍŸðò®l:D>? « GÐl¨”²eY½Ù(½tZÆ׬±Ô™³ÁÖm/=`±%U@˜oÞZ;Í4¸^ÿåеç($U,¥ËƒÖ…Ý$ü¨(n·ì¶ÿ¾EzºÑ‰Š#¾›6‡º¿¥ªÿÀk)Vªã £§lKC`½)2JÔæô¬jnxôŠ«GÐ1‹;eaÚyýL‹)ì'' ûÔ·qÁ¢YÆÜíó|ç)D&‰nÿb›­Bz×Í^ãé‚ÿÿñd_Åò°¯/÷,¦µàˆŒ/}Ïéô¥6G(›$M ³|ZT­òï3”cš»·f5]6€m:eFÇû&¡¿ôŠókXøűí€FH=y"t” ïf7Ž@czÓ»Õ§|ôû{X=6ŽÎöº] ¥jʘ]ͺ*†ËÏÍIú;aJçý§ÖÖŠÒÉ 50‹™8>{—ßkt ™P¨æ½9"¬ü†ul¯˜)Gä º¹ãÓJ“§?çtä¨È{\äF±Qw+óºàÁ¨XOi±ËXý�{’9'ÌÁ‹Ûz•–ˆäŠ=h^!ŠE™³ÎŒÈ®§]•m·Né´nšîª#›`é.Òð/ïØÌF•×WûoŒàØ|2§; 9à>2X/ÞÝ83¨óöu¥w …Š)ƒòarú42@YàÚä!ÏTï (ÊÄ7k¥‚÷‚¼¨Z·þëþ ýŠè‘3Qæ¥KrJ‹'ø®Ý¢4ùc `¶‚‘¡´.‘þYÇR]E.° ƒ–‡õFÇÄ°å,ãk­Hײ µ¼„ÿ)K`F¹Ò1¡@µk=Þc}Æ'Û×ቩýåJXgò‹®q^ÇœåñOcÄ–íŸãQìjì'g-�iþx‰À SÙrÅu8tbhek&ÏÜžÂä%ÜÃm&<nN3—¥ KMï}è\åTñY^yØEpÊžå je6o¾Uû³1-¡7ZŒ%&’zÚ‹;¤‘ ™­IÑXu`‹C‡Ô‹K–ž7Hßö7ùH×soÃ]Y–­úÊZ1Ð;³·ujUZ3QxøƒkU`EWbîÏ£¢«×M¥/k¬t8ÊŸY´W²W§xXÓMS¡kÛt›Coˆ´[¶^BˆT…Õî"2BÞ•´]­°>¤òê®LØá’P’eŵJAT° ×/Tø­ŠŒpUŒg¦sÖãHÌ“<ÓŸ¡ä-ß^kžMÀ*Ûe&ÖH„sË`Ú%;lÿ nƒÏã|¬2¹B°2�\HbkƒŒt×åL/ê‰J‘œÒ–‹á+xvš,jC¹V‹X˜AìxÓísPOçá†ÿSxŠµ|YI½ü´¢§!ÿÚ©³†‹VMý¬z”T7¶áMÃ{ŧ†)þT /f`öãÜ,óÌ$¸!2_i©–û]‹ö›VÐŽ>\£NŒ3n�žöb%¥G¥á…¼+‚Ü"ä#d»hd‰ü°ñü:ì8‹¶÷DZVÈQe,v.ý“î,e^gú®ö¤ëŒúûåJu 7doÏOæËÌÔ©îé=Ï­'+Ãô!…P¸«oÞÙ…Ãh -Oñ®¥ÓÅQ+ÄŸ#˜ýˆüßÚëe?mp;5¨ÒS?Šz­g¦c`ðƒó"ü 9(óëçB/ “ªpÓ8ÚzC—ѵ÷ ­Ziª,<Åáýµ.¦5 Ïͦ§ô.H¯V*!Q%-ãZFÛ‹^BÇÈÆó=Š¤Š¿½Ù®aïdó<ñéÊM [KR’#R«Ë"õúÒ3öhÞß=ó ”Qñôµ–‚0%Ù?¶Ñ+S+‡+|Ñ^ ÕÔ¨œÉ`Êø Õ·E­+§§˜×(˜öp‰µUÌDŽÿô¸Ñ%sßUÀ’öÂ;Ö‘YÓ泇á_ µËfâ~Ì´Âßm:í¦ÍH)öbe ¦òKF²Sœ%ìÕý<.J­ÃAÈ*› …ÀO&Ìã꽎3 ^—îV¦ò«sº>ÉûÕó¼–‚žz P$­ûvq:ç?õ€œP¨ü9§Añõ¯›ùíXÂßa;´b¤o¯,ÉjMñÇ…ñCðDkñ=ÞnpxS”Ëݬµpm|‰õÕa…2Â#éÁà=§’ç_o a(— í^™õuƒN¥)&}-䮇#•ow’ótÅ'©ÀžH>mÍÃ6½I·ØMRñ'lÃ@àË”¸œz†¤+e,/¿ù!Ѧ3*ªœVšBy§Ó¼öwB'œ“Ì‹Aôñ{æ‹iòé À°Ç¨Ü¿ÃôˆŠ•u¯Bå„…ú¯·¥ÌXšº­§?T¿Z'Æßò±¢ÿ$Þí× Ö£F¨+ÿ}ƒ ëÑr+_å"Ä8O'áÞlÙjÛ8G¥ˆó’U`[ñBö¶;T!Ï‚aŠE”3),®êÕ4+*VïœÐٹ˂üsïÍ·M[Ã|^ªµÆWý·#màGJ|šGŒ¥ßíÑœñHò¨ö•[úðGöà–ÏlRŒG×7´”·ïš·Jš¤á7¸ î/OûØ�e¥_‡ž¶K…ç7×{èí` Û¥Lß•îvÝî®C_D|‹â4^®³ù—AOnBË„€Í± ¢¥q½%*â]¿$T¤òÒ ÝŠGêâIåÚê1Óº‚J‚¯ê}�cèÃI›J€  =6Œ¿ûþ¼iäâ „V0è©<(èx@÷ŽwºŠDR¦-2áqÐ_™íoí{/Û*ÈúÞ¹½RRm\¤ üq+NÊÄ–nKÑ�ݶN‡î·n¬¹ïΉé͈âÁ&NðÀ¶Þâ²FkÀÐÊA’ȃ±1û<c«x­¼ 5”ì©Ò=ü_ŒBΞ®ÜZ¥'Hq$Ñß°Âî©™ä†a|ŠóÃþXÊü¹Q‰¹&TS *Ø¢âÁ§q„~,KKñß;ôüÌËc=š8ö |›ØË7žtÄ=ª1ä.?ãLѲ¾Î¿bß9ZbÅ 6p›§ÄWj¯ƒŸ=Vk‹¬M¬léš‚Ç @¨#rN:–)˜ÒÒþï[ål ;ÑÓVé­ÿÙ¢/‰ý†WŒ9\g3ÇÀÀá:ìTŠ‚/Œ2¬Aqao»Ï‚ÊJK%,Y†òV–T&.l¤ÂUÕkcpÀ°žç3eÀòÖwwŽ0;:Rªºîx–>o`‹ìðDâÛCëpÜz+íá`}óÌÛ©ÐÐî 6Ž­ŽÖ©£õÄZ³¦×vzmçänÊÊEžvƒätÌ°'«× â'7õ)ý_z1X;OÃÊ‚Í6‡�ÙÖǺwÓÁûQdw'Œ(›UWÕ]_ÇiW~Kw²¿eâšg“ š0yJ/¸æY]e QS˜0H­A0Xrzo,T;áÿk+ ó›‚˨:÷®(¯3ß:‡ÖwGA¨®o .Q€$àŽù]%¯Èi^¨ÏwßS Í=%c‘Óœ¡šnå³¥øÜ·öW¤×0V¤cçrm}ß™>Ž³ç&šaÄSZ4L>*?éÞÐù ìáÈN³²%Ú‘‰yAFêex²]„ý»‡¹†kw«üê%ÍRY*`¨}í`—Æ=ç‰1g2›GPÇ.ÌäœýP{+ÏÀ®€óLA]EM¨ýß,Q‹Ô6 ÷fw¶ÞŸýa-K“EŽÆ_سYǙз0Èsñx³cýáÁÄ×à1V< W˜B@©rv\u…+»,¢,p{œ‘ôݨðöçØ*ßÀIÚÑ›-%Æåö]D¥Q/hXC:Ò4`a†úüµêwŸRt¯Ð§É>[/MõELåu7±øÍ?Dd+ÛÞ2äiP^§žµA3ÃH®Rj°ÙŸË/%Èm³@8g@R°÷V¨ä^)]ö%'Øè?Y™y°@ØN(è÷ŒYqß}!`‰âêÚõèE ¤8ZIÚÓ]?QÅ„È蔵Y•ÉXCZÏ2Y6ªCA‡3­yA­ y¸’d.y»÷<l<m£¿VwyfŒXf“^¹Ž \ wìj2Æ&õ5qc§Î”ˆ$¬,²w}Ø\ÕdÍJRÍq’â\q?–¾æq‘Ç>.œ Æa ÙÌ#>³eŸ K×ħ‹7ö3Ý¢é¦Ä+¼YyÆÊ” ÅŽ?É묦Ro?JnD¾È4ÏÒöS{uÍfy&N¦èߺQ#}÷+W·ìØ—k÷C8JµáX´}ÎÂF‰í)R9Aé—däT•M+±Z'‘ky²W;„½YœØgw"¨¦˜,`Ôèü$\/áòvèyÒq"‹±ŸèŽ÷[£ßô]G Êpv¿#_Â>ûÚ¥%›Í@n/ŠX¬T§…DE½Í¿"&¦ÉJ´ F ­ƒÆŽ¢Òç«ÇͯÀQìѪØqeü¢¢ú_Í.õ‡kÐÕ©5ƒeß 7¶†½µªˆü"²Œý𬟃ι™ÌñìäR‰™\]hz†ïV #°‚6 ­Òn*Ne¡lô/qƒSgL™cqoþP´ÌûÏÚS"üa»ÜÃyà¡ß÷ 2 ­@£J´2Ù-]3CŠ4úCàôIbp¿gQO'IôŠae’ùˆÝýåéSwÞ¤¢ëªƒð¢Wre~‚ÎË‘OOÿm9S«E—^7/w˜z«+c8퀄ûÒ^ûþéØûÄépß»+ü~û…/ ÇÎî´#ÛR¿³JbÀÂwWn},Co¼wõ]-:öaz•ðmÈ&¥zÓ}fÁÎ�™øáŽ¢à‹¾ ‰ï Á"  pkÖµ3¶¬*¾ÛݸÔf¹MÝ€Yƒõ E›ç!û„Ž¢i,˜Uz@?b9�Ó‚ Ðt°Y_åúºF9”¡Ï! KQêI,a rþ”„ñWÉâ¿BRFš®•F°¯íŠ,(¶«øÿ«S¦ý¾cMUóÂ.Ûš?­Îé"Ë|wö*NŒ´ÝË"£"ûneo_ïد]0o ­OKÄL¿yoÁâ ýOßý#Oy¾óÆõ,ª°âTž‡#¯Ën(‚Ü…–P  `Ä+_f+a#ÌÆÏÜ®VÑ'*H“Î|O׉S@d Õ—f¾¸•™:˜Œ(B´¢˜k«vÃD§Ùç”VôñPáÓ¿ÒPKÚ–?½/fñ‰GI^ø^¼í@„Yiü¡üÝuãä¬C‘0H÷}^]ÿ}\z¢hÇ›mžñ ¬¯Í¸«‡õ7–_,í”U úËÀ�åßõšŠÔG"@ùsÆ|º8éuÃÕâ<šœ@Ç Âáþo‘ŽyñípÄŸ ßOÖƒ‚O7ù_9— ÛÌY,}£ö4ÊÅ+Î+•Z›#eé×ìGEåÚŠ:ßÃ~GÆÕªÄÂ@p¦#;:iÿ ç7òÈÞ)³_¦ú«îÀõOT­,Î| œ}EPM‹7ä¼Þªiè¨êûÐ* S3ãÂÄvxŸ/‹'/£>ünÿÎç…çrÉ5 ìxwW3(ãÓäXOJáôd=”Зº žÍé¯ý5­Ú5+õÐÔã°š¬k7j»&=k:4Æ€UÝ"æ!�~ûÍæŒþ ÛPäQæ×кÚõY$§Ö³ž÷˜†ï;ñâ•ÃϹïÀ¬ÆÛ�pŸ(µÇ‘Zq‰rô Ä[§s¾¥çÆy€õJ¶2\f‘Pó\©Î¢R3'ßaFPö +ÈB“mõŒŠ3Ÿe—Uˆö®§ó¼?ªâŠíÕT6GGPÃ왲ŠôÝŽ< +Ïhí¤ÍÍä¹ã\é�&ï­£2[¥^![RÄóÙ²p¾LÆÐÞ•—<(Ü{ǦJ?Pîýš¼Ä=U†æ‡ÅàLOúýþ“ñ#Ûèdøý;—µFþ½›>:6ó³ÌL©V­¯+ëÚ_Éì…+£™4X>‹ ²¸g|3 ’ï#¾Òlò¯ï x«bU§g”(Ác©UøݾÀï |¡¹€aíõ×¹†-¤>š'©“Ƕ(€nFdµžŒ8Öì©¡oöS£ÛSNæâq™˜ºqu¨üe9ƒ¢@+CàMyÇẠo(Õ¬/uÖÎ.Yóé°Ôý[ãM¯.%)Ï둵 ÏCñÁÈÕŽÕMžõ·â†¹ï­ W·-½ÿ¬ù*·KêIpåä!c\C>×¹ñnäe#³Ð«° ”¬ \MÜ^!öº:Jð¯)zyT=í?][§t÷y¶*SÝšŽ7ž»,{­=„:ùÏ÷ð6–_e—™Žì¸õéj· ›¶<Ïe¢(_i… Gu¯kÌqŠŠm¤seº:‘ûÝ×E¹­2+QNŒ­-DT8kÓ1h|g¾gbT•s®aÍi¶‹œÀpˆqe(ÙÝôï5_1ë"“­Rd3Y­ÐƒÜ(ôvL-¿tÖˆõ¯s™"rÙq‚j§™éøÊ–‹WÂÍSV+èý]bœ k2±©b…¦>‡ïæΓگOËÁM”š±íZ8‚Ñ–¹2]üñrgÏ’šAž–Ó—æH"ƒŒ‚6G-¥(úò“øPœ{Ž9öøi¤…UnOfa¥N¯³Í ÿ"ðú‚›Jæù×0ürÎó ùW]i¼w_\sÚÆÔ0H$BÛ¼ŸíÕ÷OšfžÂ!P;Š„ ú&ÎM ´eïìµ;øýBvöhTÊ¿-ê$ý*0ŒQRWAhu³—éÀ ç¯KñŽ"6e”ýJ³é±ýLqkx±0±­Í¢lÐbŸB¥ÛúzƒtÉÌÍn~¤Ìµe(Š-Š’•[%Mû+Æ*{ èKc¤¡áa3'Ãô‚«Fám~V„èà{ " <Ûélyèë”éòx”Å«‰Õ\ øgV“vv׶3¨8þ°œ¾×â éñàÇt’Õ &É”p”ŸÚóÎB±�Ⱥ: úŸ÷‘J¹cûF.÷Ï”NE„þy;¼°³jƒœîM0Ó'‹ò}íüyohq>ÙÉ âDÓÂïÝ*† - Í�éŠ ˜ögç´¼t™]ÁB°{®žt^Ý7V‹Äœ·¯;œž‚[—žFŠØ_–zfFOš¥8<Æ%i?ŽÌ¼'ýGùª&/)j¤Y]¾÷ÿ²ï:æo‹­óžá 9>!A`ÕëÂÆÔéQe€Æl|smLP«Øj弜µÿeäÒ~e}Så+ag8ÖuôLѹv˜:}{V Yûîr˜ïNM­B”™Õ ݘE1Y€µ­tàÔgKÖ˜ÆùªBuLj²ýô\’áÞ'O²¿¶¬‘çrÔC“d†%ÕgéŒå#Dv§hÎ"ñÿ¥¥¤¡¶—Aú`ZôE ˆî¥×â†ÙÖÕïÅŽG”¯¸t°¥ÞQ)Úv,:]*­Í3h[0÷r:ažbØwíˆÜrÓÅésó0)îwDF †Îo „šHŸwÍuõïÍ ,ó›ÈLT:MtÕ‹ b ÇòQÕžXqDÌ;7ï°CBsÝyð"€`K8½Lî>›W€µ…«íŸu!èYæ{;“‰y FÙòôÏöÐý›nkæž%2ÃŽ¾wµm¬Ï¼ÛJSy‘Ïh.ž+–$y¸"Зù¨œ{Ÿ¼>èTÃÇV»êm=Wî4˜×;4˜Ê2£DDï„<?±ÇJËqSŽvÝIZ{o%*c_Ïx*< ×ÃȽìïVæ•o+¦$”ºÖ*£qúÂ�Þ°&°Üb@‹ ¤iºÂ3o(€ìôH…öçÚªoTemßšó !Qbáðœ{DÝÈUZ1§«t±>r¹ØÛTƒt xï$_ÃDªo'­Ö„¥úìÑ´·úe‰¡?óV:W–Ir´·»f‚Á2ÊLߘ‰o;50qi6­ç[Gu£ 4/Pá"Ç6m}ÅŠh'§²I¥‹zeý…î™kØ Î?³4·Ë¸p…¢¹ ÿGŠú¹7èÈ„.‚°Ôh_ÿ‹^§2–ü|ˆX×�ü\ê–÷Á¢_‘#ÿMíð½”=,núÍcÕH…»F£9ƒÀÕ“Æ“ThσiùMãÕ∠”®’•¸ôû´g8êÐ*˼‘·³Èƒ×ŽÏ¸òò!‘üC×£ÜÍŽªré ¸m”'@jÝðtTó5ë\!4‘ ý,ŸÀãjî eKÀØpMeE!õ'`ãéfcƒ~1‘éFM0Ï"Ïšò´KY> ²êÍûîÈÀyc|Ϊë¸Y–úO,P†,fí dO¥¿ÈÊ]¤â¨×LCq>u½Ý­3v>) iPõ³ä8°0Q½OÀE |°t" ‰!ÆqM¹LCÈgZ_—Aõ®I²i~à-Œ:¤,¼¿"<ß|€z¨­“¾þY87{±V­¡1| –ªÿwM6ë‰>eàLý/‘̖§­µ!ÒSÁ (Žß9Jk…^Û¦TÔž¼Fɱ¾ÊŽÁT„3q}]ï¯O9Ø%h²ê&)»À�O'"—¿«qêˆÿî³ä>²9mbzzËL÷Þ6¢ˆÙ pYÄ!¹cÜç¼``(Æ-êo _Ï~ò4ùãÈL­gè7L>ËC$Ül¶ÕCÓú%‰g[߀JìÏÝuçS�½bαw‹ž®ü£Ñx-`ðÓÂÎÍ|*ÿ§0(…¢©x±æÿ¾å!å7ÈhíÚ“¢KC)¨ vhæÕ·‘+¼ë8¨Þ}-‚Õ?Ú´ÇÖŸ$3øÃËŸ„Š™«Lص*Á\FÌ{µ }úÓ­…Ké7ªP6-K¥EN¸z-ž/ƒº9qCýW?"÷+œ; oB*»éÕ ÂèóZh<uœ ±69ˤ X~_fc=(ÅsÏzƒ…•6MNõ¬6c&æÒÿا߈è&'T]o¸S7Ĺï<º|­2‘Q°¤?4w¸ô6´vßà°ŠFï‘Ûûƒˆg< “~ך@›& ’½B:дf¼,Þϳ)?áéÕÍ6µZˆað±À­ÑªLb¾tGdÍB¯?QRæÿË5WÇ f7ëÈœŸØ*§”²åó§Ù$‰ônè®°¤8ê…íDéŶ¦ü”>bÍ ¿Ûºs¯ âd®=Y`Ù6ñþ]gA•Tm¢<™*ÀûŸ­n‰;óÝ €F稥Ú*ȯµ‡ÝÖýùƒ¶Åi}q’Ò¥kÏ°KÑ]d ÈO´¡(¶ùPI“[yÄCïò³ÝÃJ¨)yöÿzT>Ÿ%;ÕfÍËÊI\ݺ¼ UX¹Ã‚“GzÝXNœ1y/¡0£²\YEóù\ÙVÙ[ºòWÐþS¢åØ!Ñwöľœ¥°eF¬è2Ð:<]TÞ·îwÝ4Œž·šPÆJþ½ï¶¯b�-ø [z o2 gwvˆ 8€ðáO½,V¬óoVO8R ìÐAP¸_T;؉zš³•…nXmäÏ,r¹%Sßv=•!Õ¬PDH†`ÉÒgà³ßÐ~EßÚÇǸË;h²R2™ÕlúcÑ^“Ø<T ‹)Û­¡eýèåe‘ùf¦#vEä¡kjL ôzÅ…éÙzqg¨T„>: Œó½å×Ö%bØm‹ô–ÿ Æñ*C¦9Q­àú=dj»™4T˜^_9òyâ¤v’0utyƒ+„ѲAGHøÚÝ¢¨OÊekáíq½Ù\@ôZó¯Šw² •;›iGŒ»mºŠ¶P{Cµ�R kƒ<ï"@K'Ï0"é‡$ùÔ Ž<« f˜@ #oµ™¼ ²�wP=ÚQRCIÝmu1ž d¬ôBØ¢½V)|††ëk ¹3jGçÉäÐbŸ¥bþ.šxç$wRûšÞ6«Ïž¨8=>”eîZ£ù(‰Ö¸(ÐÛ5ªyŸc8’uG& Ý6Qº­ã3ÇN )eÊPB7ä]µõÀd4ŸlfîMÙÄtêäûªžO}’Ðï‰!Ú4hy¶“J@·®»:W=,ÓÂy]u®]^R¬ÿf Ó„í§“¦l(Ýè”:9ÕíuzëˆÂ•êK)YxÇp@¨t¢rgæi—|ÂótäöåË÷À©L„ªùVÐÓü2q±‚BÎÜqŽR³X“³ec)$àª6Ì9YÍ— R†‘/‰6œðÐÑÒ¢ñ¦wéîÝp\(®zm‡nãÕz �ŒzÀ'µ"韛Ú:òÞOÞ,<.îñƒÊ–b²´fˆHvå'€Яq³îocï;4Òxõ%(è ›æÎuÆ ,΀è9¤‚;B–ÙÀ{Ÿ±P¢C‹l£´ªû*‚ÊRÚ®ò€ãõÓeZA‚ƒ…ru‡vA˜ûclîÆõ½ï¤ð¬S7pKÓÖ¬¶½®›Êâ,Ên:Ø Ë…eé€ö`[E†1âü–šŽøJhù¡:¤•´=ÅN(j쨯�®ú<tP™­|áSíMïç8L|£a*Eç™rènï‹ ÛüHa8ÿª±úã`7´~f-¢›t”¢igK#Þ°2 ±:ÏhM¥•I"ؘÌX;¨ºj5T®Q†­quxæîPÆ–ß)ô he$“;€:1ÙWµ2JÏž‹Ñ¹£U”/ÿºã°=|wåv²Ê)0q‹Øä:*Ì œ K ÿUªç·ŽÈ}ä{¥²�í+1…~ô“²ÿé¡|òý7Ïå®­&ºúÚàÜɇwSE� ÝdÍK~}èøÌ kçÁ”7Zê•_ÄÙôã~�-UÑŠn”—?i^¼K½AxI̘Ž¿ïœÅVÀ@0ࡈ�Wÿºøkáð]²ÀÚGò¿™'mƖĬ‹>íôLDĥîy§ŠþDÝóà>77~®+Åê_õ“båݘˆ×`yÒZª­Ûw?úpåY¸Òãoöà/uê“Fëàê€s)ö•2(P¼ê€é‚Û€%ááÇ|ɘ+™jËöVé×õbÙ4¿U1Ì=§éôgzoZŸéë²-ìçæÕÕ7DœSGÕà¢Øèl£›æÖîú?ð~’È3Ñdm¡ÍD‹ôdEy+#ÊëOé¡*ÛÏí3¾°}ÛÐPVú™Öb\kUòV}’S\sçÇ…îû2˜‘×Dµ“ã§N;تT$û"fO=ŸbÛâ 9FÆ”¤AaæχpÍ2Ù5‹„¼­-·Ü¸k⚤yš™ûÀš©ACÙ@:èIWåfÒoÊ;úÎåÌ~=þFm ôüÃKQN¤Gh] Qñ’ZMò0è_gÐYÝk9¢ Ñ>¬Õ|¬FüÛP§þŽjoA&Mák„–Bò‡¾p­#Håþ8\gѳ· úê9«B¨ æÜöOÙ¯s/eð¿ ËVŠT̨Dn”"‘�¼£CS¾IÜúþ¯U)’TŽWøe.‚tÖÕÂ^õe˜ý͈2Õ0íU0¶ÎßÔ\ýÊw� ØB[Aʸ̋¯Öf¤À5Ïb›ðÔ 1NM‡ÝJ–mdý⃉Õ0]¥°í+ÕF{=ýç)™ƒ>–gÚ½©š`ó#x%`¡Øá@òéßA[#‡UdáðŽŽâ¢nŒxñöfÒçá�I`îšÌð¯iÓ\ôÌPJ¶Q}7/3ŸiU –¬NÃ,Â8øåÆA`kLEŒF-·V$Îto¡·iËä»GÑí‘”WEæ‘÷!žL;œFy q‚–±•òÜÔF¥Ù»’èø]5™R˜ÜîÓ·©©´LS7í»VÕܶÓá_ÓYò.7ã鶇eguÆ/–.Dô¹Wý©2ó- 3I�ÔÃNDäÙl`÷ ÓŸ"kñÕÉÔ�Ø w̱s÷ô©L>h5Ž´oŠî_U 7x¶v,#bz€kOd»!×nwìÜô(áÈŠ‚­«¶öÖÞB´ÀǹñêÝm7Èݽ)zÊ($A“gAx²Dô0ðf4 5Åçj¼7V?<”LŠ“Üý k’¢Èõ“Bv†ÕUr]×=TÏ<eÝRø;ˆsÚ!¯OÝ-%:¡£Dï1«Œ?£‰n_á²Dð´òy¯ á 3V¶Ì]¥œO�áJ½ šQ'h€+5Ê„=ëKJ“šsÍ¡…o?·”¹Lçã÷‰„òBEobœO‹ÓtjkÐä¼5IàëCô0\%r%Ô UïƒãùXõ³öÚ¸ðýÙ¨8 ='fd1Õ¸ýÒÑXè™õ;žqZ8µoÓ± ²ÏɪÿœÇÍýع„'¿†XŽ-C—»8“,mµÆž‹‹ù+ڳŠaÁ]Š­äÄû«`·B7û‡•i®›nªÿ—| 3-“ì )=Îhk±…):´Àxéä3˜®•évXÝÍO>¿2™J?P´ZÞ=¼¿èÐ*šð‡clm郦SW±Ûf,/ÁhfQ¿û­Ó¤íüNÕÊû,HÓáá;àL˜½^¬Èzw¡e°5Ÿ Û(]~Oï…m¾ò‘KƒÞØ:ð@MŒ;nŠ íåx”¤AƒBÔÄbߺ|ÏcÆû…’XêéÝI÷{™0ˆÔÞ@´7€Z¥`°<—]ËtžÆà^Îø&À�QN’Q&¯ÙÍȵšm!˜Ÿ9†£-ÆU…ÃHÕ/ýW"?ü…7Ò³Æ}GgFÑ~ùý~<·�ž kf§©ë_æËF• ŒÅ'ŠajOþND�t,ƈHzà Â;åõ9yV잃äS72j z¦sÖAááj_¹.¼GöI|Íܨ�<ÏŸT‡‚ë‘êf èóÆ –x—’!Þá¹t¨í@$£çˆx†(õ:i”¶©ó¢ÀÖmžÇ`‚úíÔÍ{ò™qOhEméˆM;€bêÄI¯¯»?>¨Î_0ðë&^È×—NÁ.aLSÒÃ~FâÄ»ÉÆhc7WobÂ? †ã°[Kr7ûf#ü5ÒÌV…Õºyñ§Ã\o!~f$JÙUöи‘Gt8;+-¿þ™)™Mx¸>¸Ž)çfgm Ô[&0±GÞÛ¥3ꥬIû7Âå iµVFt´é àð£ʳP¿úGš÷ïcSÀÌ YÜi†vc²Sëݺ=(£§ðÀU+¹æü;)Ǹt½räDIpÁ4ªÚvš3‚#/RçQÐÃ5DÐÃôÁ½ßËZJZì”%E¾O)cTïÚâE+e³€@ÿWÜf°�$K©”ŸÒúòõX<7ª _Y†F=X†ÚÀFíHô\æšÙ)Ƙ‹-¸Ö/w DU‘yvA-¢/ Ã4R͘K Tb@7šC«ØRÖ½ó«9ÂüAæ†ë»0ª“™aK9Q¢SÔ{§Šå=ÕGcîC©ZÈÂzæ|k•ñ)ÙìÁ²0#Œ­Î¦+sæi…#Ýv/�Ó©þá¿xý•,º\˜&ª‚U¯CÄ~ŽÔ´dM•û}ßDvò/Ø_8äÁL¤Óya!° ú~`ð‹Ò4í�*àÿJY›z1RÄÕ™ßë"€j®î¤“±;YVy<ÞíxdGIø¹D‰·;';þhªuyS¡°©<_÷œ­5nÅý=ÀýéC~¶>Í™ÞÊ¥†¿›Õ$nòÁ>Qp'B?Á”÷©X~ñ»››ÿ+¢$öíKiÍô]ðæÕi€ÒQ~¬Í&FBÈ«d3Ö½´ÁŠ*"n LཎUðmè¡íd@w÷¥¯ï‰a+E-6A¤³#sfð  uR'§×ÏŽ"=óm>)'UD§cî6@ói¥øM¡½È]½ÉN¢…wi=yÓ§ý•^TzS1GÌ=(Î˧ '–ìù^w­- »­êÊFrãgîèC%½6$XÖ¥6«mÕäàÐÈÍä;®¾)=‘#NôI¬4c  á'[àf.ýØ,½A°dPí …»XtÛºjùTù2‰“Ðæܧ¬œêœ"d&jÅ3`©yûÊkòXSÝ7°̃_û({–ˆð÷hP5ìâµÁ*ªjîEšuõâ«vŠØ[*JðŸZ¯G¹´¼¿ù€¾¨_+©ˆˆñÑå^!ñyµù>‚íúùü«cØ4ÍnDr6 ýÝ–™QUªÐ´<’º?rÚ_÷k*ô­Ÿ`Bz~5{æ^cýÁ%ªî>KÅg9h^$êÇÞ2ø“{OÜדv3Ëòîž,5?‰ ’¤†jÙëùopíŒï­ôEu¿`²òf¾mfñjJŒxy–5Æà eŠvbŒʃ‚1ËüØÆ0§L‚¬ý×3¢¨i�>°£L#á I»äÂÎN•îü4 ÌAG]ÇÞ©§•þó_yM©(73…&),j†JzXT6¡°*ÏžÄ<ö&¯}ëoNÅ8dZ}üÙB€ø4‚MŽnm'•qïj5g°­’(4â¿RžO–^ÜõhÚôHKS˜WŒ’AÕT4ѧ_ZÏþÅ# £ö‘vã,„óºX‰½•Âçà%ÚEcÑ ¹G¯‰ñÞó¾^I”½.½hÏ‚hg‚4 |vžãC?6]¯(—æÀ¬ÕÑ`Mß­\úP—(˜9+/›Î±x¾Ï6$)jÚ»|²ˆÂÊù/–Àc6”^ÇçÅQ@ŸuX[ûh¶žñuÿ=ÌÖŒoñDÎ$VB‡Õªš(ïLË_@õ‹‰™ë/å3²PåLß÷¥²ÂtÒ9 #yëÖ\¡?ÔüÍ—žÄ®hÿÍô|«Ýà™3ð6ª ɬ ô8k:˜ç¥ˆCŽŽÂ¡ñK+“dÖè½SâÙyáP0¹aWäúø•ÀƒÀ¯Dèô$<ØÈyzÞжÌ6 fõÆÝÙó¾V.ª&ç ö?0z#Š ©£ÅŠ‰LŽâΊüD¥ È{Ýj>*”¹[OÌqjæÌ{<P »úY™æ—ñ7IéO()Ì!u¶_<RæÛ¬«õÏؾâÊ$ë)s ;ZMùYáÐ%ËÁšC›7WÍG f£šèV›BrKù­¤ž¢£çk”ï‡ÄtŸ¬˜úpY$?oõtÔ)ô#;9Ô~y©Ë fÂGdÜ·“p(KtRÆ´Ðê·ðg,8/öMÉbÇEŠ�LcãVýtÌåýiÙC»ØÈ2C÷ºrüZöÇßzïû˜á7u.•)02b¦ß‹Ã2öqç z׳ÌZ‚î!(w§t}ž &VÖÆ¡ÌÇõÜ¢|òUŒ@º¶¦Åº pHîÇ ë5ñ=A±¹¾èyÎûÛØÜùÝ·C?,Ë×<B9¼³¾dØS]}îÝÙ7>ü•«5?Ë Ëé4VAZ«>ijs8…qíK« ·~ñ ß|+B9<×E­–q´æèfÃGb)Y—JvpJ’Õ SÞxý WI ¾È˜¢e‚›¹Þ|œO2¡‚”'ÒçŠQê5ªÙYc€•”îÜB¼Ã˜Q»®ÂZåÅIêN¢‚8ÐÚéµ�¿@Ï…ÏrÎηŒZxeñ£L#m g;õ9ØLþèæÉ®;S.méR"§¢Ët?D ËoS½ óKâØ‚EÀ´øÓt‹AÁ%¹«j&²XÏ,U¼mŠ§fÎÖ=—9Êkë šÍ8\´%…‘Õíìë­Ð\‘ÜØÞ)cÊkk’çL®tXŒøë¬t"ÎÒñבñk—‚{Þ<íø_8ÇŠšOŒ+„0§•DMë˜|¶Ô«Ì©¤t”‘B/”øêbR”{ ŒQçñÖŠ,´åNW+S³ðÌà:6û……Ò $³Æ†±WfQ¢š÷7ÍýÈ+°+ÿ§]ɸfE’¨‘6°Oõ°3œj›8ã}!so†ÈëÝ0$fõ¨|�8>y–¦] Åq¤ºÂÝ©}iPVj1ÔRñÈ‹ÏÎjkQ—QáêꡦL0äçttNÁKYp>º5Ó½¢0Uðl ½ýxb×1+þ`¾îÔ”JcL¹Ó »(8e7åeÔpŸ(q3QyªqˆÌ”£ÈÚ_lo‹[-åÑøØÐ3¡7RnKiþ8³;úÕ]¬³µÄ›}°#˜AU}2°IäýÚü%52æ{™™„Ò†Í拳%ä>ZÍçx÷° »îšAÓWA8©ÌC^Z</—º>é;�6ÛIÐÑqBzVžT�Ž±úæî²@·!¥œ-ÒÚè6{î×ýÿþ?Zš×a0K[¦Y7¨é"wÏ”y¹í†Arú×ü9Q0deWHdƒ-1ÊzŽ{ÍbC‡£–æ¯vjŠÐG!ÓN„òF³Pftã&gØö/#§™eH!ÄC7µí(zqHC«BŠnp„%>»q2`™ØÎï<â[¼$Ìr¡ Yz`œŠÉ2‘É=YeÒ›ã+ñ®Ÿ8ߪ‡ú‰µ½çé-7¤Z'íä�âî&€/&[NÌC¤`3xñnR¢¨ã5c =ÙѽK·Ü A¬/9Ð=¬ÿ:N+»y^ñ°ø¦#¼j•jZðIVÿëA}9§¯{4uïJ繯î ?kØàF—­áCÚŽÃ|cßf¢ø½.ÈÈçâÅ°±m×›…ƒ2¬¦EÆ÷^ÍhíiKîoð*YfÑÆ<Ä¡ØBA¯¬/ž(2âÄJ¼§EXxõr <,3X ÊAºýTÿØ)øKaÔqùߣD:ôæ¸Ee¸‘Tqì{A¦DÀ]Ç'ëG“‰P�=Ú™~ z]&™g`ݻϘË.³o©ž£;‡ŒQÖÑ2N”C\ýוˆc¯:Ÿ,Š¼¿9Sbû„Ó÷;ø_Rš‡˜š þøEça¼í¼á.â…&Zb/0~á£b ‘´Êó‘éѳ‹q²Ÿ½"zÝwÀsâÑ®ïd<_�ºÜ3UžŒ8—»ž^uš½ú�Ë­@Œ ú`dŒ<µ¸·þÌù*Zû“@`ô 8ÖâÁ¤.dö¾(ñÒÒ»†{?u—Y/ï‹&áÍìb|ùÐ8·Ô}=xf-?© DJµŒD& HŠ—MëùÇJrgûo¸±ØS§=NÁBŽ¤öî/é9g^læRc³ÐÎ?ýëÈ¢=v>Èb„ KOúûíìûx—¦…gïŽêR•QA´×Ìe¬?òþ‚‚h؈\ ²ï&nWy�˜Âó±dCQ˜Ó*ÝO'ú˜XˆÆ‚G6ݒߊU¥ã>n×iEFÄýHŸ´ø’Ñj ä‡OÃ)×x'qEs¹åá©çQU®ô<`£^§¶‹0OÛôÈí”îTvœ܆–¬´˜¹8òÒÖ ¼•µ9÷YŽ˜Ãëë§^R9 Ë‚-¢{ú´‰ý¤÷'ªêT||t5«¦šG[Þ½µš’<·†¦Ñ‚FœUo‹ÿÓ{nøš ŸzugiY]ia8Ã×FIÚá« ¦%Zè9º;ÆÓ­”!Ÿ‰Jû½‘ÑlãfwÚYvRÂR[:Â|—y‚ ¾×;ÝIé¼]™z²Ô9ý¥ßÅâ쪹"ÞF|t½Ë»=h_Kƒ Ÿ/(ÏvŸ¦¦ÜŒTšÑ"í,w5ÄøÒµïW ã•­Ðü¾gJ·½Pö\}Ÿ=�:kgp9ü;[ÕÈ Øó·µF8�©ýð *fl˳vRI½Ž§xŸ¡‡8iGþ³©j|áy»UfßË-Eß˽P%ºýå®Ñb&Ç e¼‡«nÊÕ§Á$N ßË‹ÖdÝ‹—…ó§¼p!æTª¼[ýÊ]WÝlá¡Q0wU×öc3Õ½¥&¯“¬'€ª¼¼Ñ^>œh‰c€Û{sétÒlÖ Ž‡ö~ÑÒWÅÿ�f]äÝÕQ5)ô×ì¯d ÷Ý"¬rwò6}í£ØWŠË¶KNG#Æà?]<Ñ(Þèæl—3ƒ=óÃ?ÍõŸe߉€šYõy¥Ç_{•Ôñá0¨¹¿¼±æŽžŽÿ<©ØŽãòZG>NyŽ¡ã‡­ë aVñ7¹e«ßa­W™áǶ³ |·Ùm2‚uß['žj=o(Å*vo„Ç àdzêÁë¬6ÓU¼´WþÒ´&Ëâ„ß‚6míf”§ µ•Ûø±©«®|iF«M2rÌ>lS«¡<Â’ž7Ž¡‰>žÄt÷ÕJ5‡óŠ°Ùžã‘™Žö‚¶p·RìV$û4õ)åp%ÅYïkËt0Ú«<¶EÏA’ßåmè(Éæ! „ÀÍ{ po…úh·4;ëB=M‡F›´2Ø者#É=Ç­ÇS!;"N Þs¢êµj­g À™^ípÇ$ì»°Ê‹/Ìa?MU:(Iu;‰~U*)×M‘œ*z å ¡+–ö ¥ö”RÌ2+‰u8-ì.ækx—ßË ÌSsF,˜v´äO'@¿ã»d¾À#g&àÓ+Åêd¢±W;#>ÎóØYÈ8úvÇ@Xnß5ÒÜ#8>¡kš7;Oo TÖq¨{úÏÓleGr:mÊÆv2iG7F“ÝÄð͇Ž~ç’X’uh¾Ä¦á©÷Ôù?ý€¦½6Ï�¨•³È])�ÂAVÑHŒ‚y¦´mÑc2‡‹ð—ãƳa2üÛ Û¯ç¼ÁÜHŽTo7ª–•ÛÖZF]E~†~U¥Oí¡›ÛCÞo²˜QÑcéGíÃ-±m> -žLp†¼o7Î(b%ò öd¹:%‰ÝHïjæ-Lqatãï!ƒYé4‡Å¦ja-å$Á©^°½¬lûÀn‘fþQ¾úB!sc‰@˜åxL'm¦pF¸—›ü 7_d^ï ÚÖ¡é4k«ÀYö oþçÐÿ�BKÖ"IpÞèX"íêô¶é[ÃgÔñâl»HŸÁ¼†k[!†–vqP8%rÀÀu¼˜÷}}A¥ –ïÝ:C$“/O{ÛÃÍä½q³>Ƀ˜Í(ÉÛÑù¸ÎÐ…¼rÁ´yíúÖžE:wõh©SŒ‹p;FÃYó®ó¶ì2Ç LËØR¾‰Ö冃572¾‘á*á$É×–Mú-¦“U“Ô½÷p †þ5(£í•«€F  2b}yÒççì,Ì×Ó¢¨ö½Çn5j</'Pj„h'— ýƒÚXä9 VcïJxèX¨çäÊè‰b$dîWÁ~GÝÎêAêcÀn±�¤•Àz>,Ÿ÷ `qAw ¦ŽpktŸ§Ó²®£#ŒÌ3ïDAÞšË'\¹:åà2Jê,ŸÞˆÇ й«—Ê‚¬•Å``4€Å³&rקNs1¾©ouÛšóÑ!ô±�â«l8�[3çÆ�˜ êÊi°�›µ$‹|—­éâ$󽂄sKÛHñØô.„*�…ªÏäÅaÞÖN öî�îÎïn§pQꙜA—™†Ö Êr&SPÁ­i9pëßâ9Ê/D›Gæ,#ºi€ÿÒùP\§óäökXó ãÈ÷Ã�ÓBgrÃ4ÙüAT²DvÈ7îÎýlë¯ {ÃÂj@æâó“&^f”¢_y„žU:+z"æ<]\pøD´“¦³ÌÉŽã $›'ST„I”åº ’úÓsõƒV<;>Ñ ÙÃ>m^_êÕ: Kûö¬;˺b¯D­ Ý}Û'ö'tÿë´®,’;e1–ž¥±‰Eæz±ÚèèyórŸ„¦fØ‘Ñ!¹Ô”=„»³Ç3 S^¦uB¨aéæã…û–zF8L‚šÀï ÷ï…ŽÒx¼›•x¢ŸwðFäVª4~ø(ºqLYƒ-è†ÐJ*_‚ ÜŽƒæi÷½PŸðòjEW‡¹I¤ïv<ʞݚ(S1~0Zù¯ù›D‘óGŽ «Ÿöv´\§ùšl½*·ÓdaG?¶Àku2ãW@¿Õ¬Ø5NgªäëÎKv×Ôt_¶–œR²(ìá‡Ý­ÇjV þáX*ñNF½ôžþG¿?Ïe#}ɶ÷] <hBœ'U\Áo)d8™å4¹y‰Ùè꺒leVü¥ä¾‰±e¸Œo´5fËU¢Žž„Ü5û#|à+Õž3fyêG<ðoÐ.Ij•úJyzxEÄ›"n¾Kîþíâf_øc}`P.%­šv7‡ET} ™šÛuðy¸ï"ξ÷À^sž›êNO[Û:AÐx°ü… =TzË–kŸ &¤ä‘VG’eî¬R¬ò¡— >sÊQ(1ËOˆ€rL©¬>N£ŸŒH@|}WÏÇœ©hIC»½ÆAùe[åt,¼Ÿ‡Íâ1lÚ3‚Ö/ß ²V…>Š>µf©}p‚É2´©‰/×æbÍj1FŽwôÄ}ã:*W/Cäç/—inìøGaâ£KuvU×Í\56]n&Þi°´ vÛAÜ뙲1·ì'¢˜Lÿà³þ³\º®½å+|£/$±§‹Ã0p ³÷ÎÃú²µl›í¹ì€E`:îÔR™ïK-åz²y†³eWÿ{<tÿËUáö@ˆç#••{‘ò‘­/¤ª9˜zò~ͳ§5Òæ9š´ ;–•<vª „Ù%¾=HôJëo¿ðE•dP™›#e¹µžã'*  z½3ëâl:ÚÿTÅšê±gè{†SзßÜšùNì¤×´y™é¢`•÷õâ\ô¾ë«>ZÕM‰cc‘±2H®6‰@!⭚𲎓Ug÷'ë) Ê[ÇÕÍ6Mƒü´uÈ pàè#Ÿö³…4n.ÇšB+7µh<N{zÊн ´š{¿BÔÌ ›fÂu-ØàUž­@ä¤J`O'F=©—„ÉDcýÓ=¢J\úð8Vëσ°9«rqÀj:hñ)ªe/·Í ÈO"µke¦²î¾*]OÕ-›zøp‡|CI§<s½X0vð‹à$s{›;Eü$¨êÁ©â žP}zE¥/'ëLµ>îÝÇ¿³THå13¢Jd¼Ë÷ÖÒº·¤²C¿Œf·wyO¾;rxÌL‹(Y§¿l-BwÒz×Gg©«ŽëÎËl<‹îÛv»Xf˜ègAjý2ñù•¿i–Ͼ†AÊ]=0«r¨xª  èö�QyÊ¥=«ŸhXÜj·y ÛúºÎâ$r®Ï\ª ]é§zÛ˜øZƒ²iòêéÊŠã\–ƒÚV¾š4üƒà‘ö¶�´Ô„‰߈Ÿl$¢4±0V©ömE›wqØ&:uµ0¦B̪/0-€çeÿDx+s19Î lÖÉîy>)¼]}™õ-ýø¶kD¼ÐjS>ÀGžš[Ê2 ,»ò©mÇ̺½œh?-ÆróU¸€Ïå¯Ø8§Ï­cKŒ.u¯´ˆ ê{çq§0_K´ïÃqŸÚÁÒ†§‘ÎýäáÎY†Ïª\ü¨V(-K4/b=Š¶ÖÈ“±¯g:^®û_è>Ä>¢LŽ|ø…{{p1ÿ‚ÌJ®ßÊ¿ê<Þ’µšŠîÍû§Wÿ¾SŒ§Pi‡ñFM⡬„¥;‡Fbz졳1{yÊ$Xó‘Û®?í1¦Ã4/w χE�aCG7Ü7žf‰<| "e‹“꽟‚î-!\:d±?ýëQ®8 ˜ùÉßâeð“§OsGgx{±5µð«'×y'EEì¨ì”!ÛÛ>lfš�tÀ¡‘03¯å­çôÀ1ȞŴ#£,< «¶1å¶ûêÞÇ~Œï·Ï52ä̦Éé3«W^ÄðÔ郫xLs´Ù&×Êl:4TÄ©4Öx{ë;CGm>ÁM§Wœh rc…cŒªͲ€“îéÏ‹EëCÿÃ>VUĶ©ÄŒóýÑb¯>_$îØSÌûst@œu* ÞÑýø‡UÇ!wg˜Œí© ÌÆu´h8 óí| ŠYT¡$âD î7}ŒTæìÚfzfqŸø"wì|ÐÔ´Œl¯pèà¢÷&¶'ªi6ì~´©ŽÀb®näÐN>4²(üÅŠŠbÊé±·~±DGóQø(§“Ù´îꡬu–>P™6ñud^œuüŠ0 ‡âcN’ïË$Twì ùŽ"Ý­r·wƒp³X6L´»¤â'ôâ¬X+,¡ÿ�Cç‚�Ó,aÖµØrOx˜60¶BtÝ-?.¼®!Ó‹¨hb)º õù몬ù­9z´Â1¸acCÆ ¡¦›âÀÒ?{|æ:2Ž bm8ÑÙœ :Å,#Ññ‘±Dîx<¢’…#^0~‡y“OQ¥6£+~Ýý¬¿»zó¬ =ä—ÎE\Þ=H ¢6•PqéÃòoÎÿþ[[qð¦k]æ½úÁ›Í͸˜Ó«ììÙk“PîËqðÅÌjXnÚÑÒÏúw§Îxìú±UJÍEö÷wÁ >LÁJr_š6ˆÛÅðîõÜÌÂäÞŒW[ÃöÞ6Ñê ÇfJªË ЪÎ"ejA s€x¬~V…«@Ì]5'B¼íØåh­ó×ÖY¾ðhfš›a4Öé2ðѼA}œ³þ2@VoL—è)ŸÕnÆk‘[ï’?4i䟳7å¬K'GfÇ”jN+Á±G†QZ$»Í\é uD\TËŸ|‰¾ýè‰9ê õuœ2ö¥Ux¢G_"ëtØ Ãy©'O$Šª6³òÝÕßÌò¢TETÜ~s,˜:íH[mìßæ`]­8Ì™Q¹UÝaªO/-–­W¯å܎Nç_ÿ´ìÙ•{¸ðÄ—de*g0“Ï-ºP9 ˜L½ë›ëßëiçUæ‰o¢MÚÑŸtû°J”­Wú‹=Ô¬}'»1zœãßÙ.‰Ó¥ Ñ©Kh­ÕÚùVoÓO1 )ñÀ˜3Ÿ^ý2×:¶Ã¿Øpì62úz{kåžòL' Èa÷óнòlk3q“¥[õŸž0PPóµÿST|@_½k»ë4<³’Ír*àlg3Ä”ãÝ¿†S‚3oFS½—:\Ím÷çð/úwâˆj‡Ä=ƒ)0¹5ñ¥ ? ˜a­h.IÔŸ¥¯ø!ÆÐ=mî }èwí¦Euãiguu—/ † ••`eÁå›ë¾öʘ¾¯UÖtJl‡ … ád>žä;^I@å-…‡kß5ãpwÙ¿¦1XV¾&„°&$«Ýàû%m'å¬Õ]ÝÖ½¡¤¢ÃÈ’Ê–ö•gBÉÇОžgÔôÖ|¥Y“l̬¹óù…fsçNW·ó~؉½:(\:mÿg_Ï3@îâ!’ KáëH_ZÈüîþõ4ia6jùuYöo¯ßdJ³Õ‰\û]ÄËÉÌáåÇ3EKn<j{o:œÆÁüû |F ¸9‘¹9Ìí@ŸÕö®bÑZjõÕ©t¾ä¯fœ-¬m€ùªý¦Þ #¤' h£­M,²wÐ`E†$DÎœõþ$9Є9Qí> rµgyéœ.tþ¬‰ù1õk»/ZÅn§S\n±)'k”XG£ÂÇnåÀ»nÁg•KØMk³eÈßÕÓ´}§=9ëM§÷¹ž(._½«—§:±3_E»ŸrÝ¡ ²«rsV„ÖêæbY+„§?ÞC륅í@Im|(Ëë{Eå|J4«Ã¥¸ÿÓü½PZ¹úWÁ|$XA‰ÑNâ&ý¿!a|zUåÅ�·[…òÕÚ¶–f/.iæÿ†�¢MPqOÇûï² ´, 4ˆ"tªïkôèëXR§IëÖ%'u*`?¬–‹dqb€µ¼È€r\uvòŒqNåÌ­rÂ¥ŽdaF+z}Ö)Óòßðç›#ðpµÒ»QÞàQšrFàÄ3~ÑÁ²'t(ìñ¦Ï×}QÞ7k_çˆâð…ò_'ÜÕ}u<Z—Ù¤¾à”lš†ž“ èÐ'¢]ÈL:óºîè\;WâŒe–‹Kk"ye´¤.Âö‚ƲÓnfsH_®£$mÿ¯Õ%G’V+w?ŽQ3‘óŠXÁ:OÇ2ˆÎÚ;jæÜéÑP¼‹N:§&=ÑI»i(4ÏïÎ *1C±7• 3½så„Å=[ž)N æb?y¦½’U‹ ¾äKÌ”lUžî D6Š´¨b­$@ t;ÍÄà$°2”{Ÿy•5[œÒX­û÷óp€ò€œ'”Á˜ÝX$¹tKA&{ c¢k2´ÝÊþ0)‰WÞ½ô¡Ay.ßJ6ÇY‘]Ç øÉ9Ñ»šz}³Mès¶;·JŽ5‚×é­;Lýu– ½ÚgT–{¬ ;ôÛ«G¹›÷]w2´ .~+Zœø>ˆLV—ÚËø†3}k+Ó´§Ÿ–Ól†c!~J*ËÒjaG"aÉøÔ¨õc¬Y‘1™åOgçi‰qhx–’³rP[ƦC²ßjzãôÈStºÁñ\¬?IÛv³ã_Fnï6‡M=ZgÌ(®š'_æ­–äÛóË4ò0DŸÌUÇUs”{Â>ÞíBp€ 4*q;êei®Ã¤²O¼‹ÜA‰¨p¦(ZÛ ­Nâ •d})¤qzÆãýždiv£åÁ®˜ûÙ“lÞ†™+Òêg3L8KÛíÄõß¼ÃåÝ65#μäë3r"¿¶ztߺ7Eá¯HzˆÌĨ¬䶣<€GÐÍ1¼<0Ä1^ed„™ïÃÔ—vS5Y¸?ܙχ~À¯L©ñ4 ÔàÕŠ‘ yx"jºõ ’Á‘^–A‘íe©¨æõ¡’½µÛãN¤Kj:Kæ­ÊÂvˆQ÷À`{v¦»’I¬DŽ8ŽÙ,¶s‚íø% Ûñ`\®0X•W¦±ÿót¤Hí&+ññÅ ðµ9}Á£?›3 È~! >9­K®©ð=wLL<@³–Àÿ0f·.ãJ@ÄÜSX~ï É8‰Ò–MZ´‘ð¿8Eÿ)£ð†ëͪ«'Û°Ï £R1ã/I­¦ÌÛ2`Q¿ó–蟴sèÐiÖß)Åñ*åe¾˜J˜)!t%aöP»,WçU!4¥bSž¶¯±€„ÆKEõ ½Þa™ù®€hLÐoêµÃÅB«Û…Î¥Ôy†Cë6f¹87ünLCðØõb 1HÓÙä„ßERy6E±;»¬[o颬` U·ò…Ü»9ì÷ßx—ßäC²Êôg"�Aú¹§ ‰9Ñ‘áMîEHJ‰ò?ú.=´crþp¹A¶? z¼×ÍÉÌ-ÀCL ._ð˜+÷ög?¡e­×Bàeƒlú× ç(z ofv4è䜳ÇWË8wÇwŽð²…÷ŒÊ ˜'7ª?—ú£3Ù…»ZÃà¢ÿ$Eæ›mAµäåE³÷LÖ°ÃEÆW+̾«Y0Ÿjm7}k;UÞ8©Â®Ðç p©…¢*v­2E¤µåÒ0ŸeœywJ^ö;ºÖ4s²þ 8ÌRNã(¨yžm;<k@ĉQ5‘<LÅô3ä“JM?çó—–¹¯¸~ê]—6eb€Ðaß{2“P§¢ÞH\(öù× èXq¥‘p  Ê›áf`oÖ¿³Ó¿¥Æ¥ý/º±=}å?ƒp³ÞâqìÍxQI-Ôó:uíËÅ7 # n2± :"ræx—f5p)k^@Ìs!v½?MY~j‹Åh]ö&i?N¤ŸÀåAKë4‰p·œ·‡ºém„^œbþ_; )k¶Å;››û†<FÒÂÃqnL³÷MUÍoU¾ÿù„ŽNÛvO, ‚’™+Upæ/¦ F±;3ÑŒâšú7ÓK ˉ˜ÑEqߨ…a¾WdµC=¹|l Uì®N{ƒ4¦ä°ü Ãå)ò€¤óõƢůU«yâkÄ}ü'A)©hé$ÑÓ½ý¯=áƒWY¬ ‰l›dÐLšÅ:ŽÝò<”ÝQOg×r²˜csµu~ÜBEjÍšD€ñ:R¹°ì”ØÌ Œ»ç®çÄ#ž`æѲü{§—ZxÔ#NßOÐaÎ?¯mË[n36)‹êE¢fÈ‘E•õâ•{3 ÉVfôàŵÒ!ä1pG&=Xåáyž‹"ƒ ‘´ŠªHÅÕ{œiåO ñÐKu¸ï°;#¨u>üñ…έVÞ7kUÌûqáêL3¶Ýk¿"Æ›ñP…>'3Ä"XØ×—‹Üµ}ÙúÛ�%²ê졆ÏDÉQyR°.äÜë»Þ™3ì¹$q‚âß3¼(Í|NEþ&OØ{[º-Cº>:–ßÑS±ïfÖŸ@Ás)« _èƒRÎV͵ßP¤GÛ Kd³…Ÿ ­iæ[Dc~´/‚ü|öt‰(f[7âãu¸¶-ÜÐ!ËÓÒ΃+5¯CïRéFrV°ÜcÛøÙj»©Bƒf·_jé:~abûv>IZ:ÞrˆÐ½Ô€µ‹IÒXffL¨?£³KïrÄDÂáÓl8µ‘#ÿ°µ#ÒL*l\<sQá2:¹ˆ+¼Aª¡ðf/<KF^¸´.Ê&ó«g0æ´±sLJbvø$PÕšËÔѺÖÓsB+tc)Õ.‚r¯Yp™CU$u“¸*>¸±N±Ûç= ŠŒT7TA´l-ÞXÏñ<´&Àʹ ,éÕO÷G/^sÏ2à¥g­•g/tUõŠ‡`µ5Hí¶ÿU€!Ž±û2)!&ÿ®Ý‚Äp5ËØ #H¹ ¡ÓÈ èå¾�hM 5C½ Üs'–½>ZÚʦq²ykä‰V0@¹~߉Žk>IìÝxЦ?—„áÍÔ ´ß'_0Ð4É<¾ È¿h$íxùº@­:rë aÀÓ¼[–Ù úžñ©¢l%ÖÃh�:L¿Z66¾Fýbt5Ý•ìõ—ôbTtɨ.DЭ¥?Ï 3FK_ϲ Cº¥<k?ß[7H³¹Çqc˜À±–©W@ða€}qí'<ôaÚQT -Ì^žºÝa¦Ò—7ÓGŸ–Õ§ŸW+ îŒ"j$SíÓéШ«°9J¬úŒ»ú‡]jþé¯ÇïA™Ž@çLÄî#ý9¶d ~L|¬zõþÌêýßþõ vù¡£·¸—é…c^‰# O¾õ#O‡¡PàNºA%¬[ðE€ã¶>"¦AhÄ‹Xu _ »EžW¨<b¬âtrÅʺ+Âänd·–æúÞÞÊ ¡×`&þGE{¼vRžÛ3ds/ö†Qipœûñòƒµûô™±ípâX/Ç‚K—]7B8e­ÜüÈñ ZIXŸ’íü]±;\ Ò²Å ¼RJO™‡²øq¸jåAO9^¾?;Ñ­=Ä9,ªö7vj¡ë§†l6 Ó³p¼Jˆni‹‚ƒÃò ^g÷¢PYúªE Œ› Xd5f…ÖøÊWZÜçù0@«†1gçá@eQ«ÿUš`ûñÊ5ÄÏZ½T°ÌH¦ÿÐ`¿¨ëHè0ù|Êx€(–M`HÔ )u<²•èÆ"…©k« \žøbóñ�ëgG­%Ň'«Ðž±8îÈv´æ ~uÔí~ý£vgZ�‰5zCw:ݬòpÛnœ²â!Řï=ëÚaý90‚óW: ô„óìf:¹?Ñ~)m¤Ø̶–3CEçHµý{’0ÚÖ›q:¿õ7ÊP˜eâaE7ž=6Së …%ŽZ>]?;å.%á©am5ŸùkZæ¿(×`ŒH«2yß{2ÍÒgš* X f²Ý,µ›º ºL±u}¡ÐQ,Yéªí2H>h£&·j™ÌÕiºþoyÁ fR¾ßê}]·†ç;<™ÄD~Q/Õô&Ñu½€—š¶Ìsat—·Î_m�CÒ±¥ð ‚ëÎäKÝ7ã¢*¨ã°\ÙÉöex`t«Ã}¯´,%úŒã0À”¨`Ù;+ô{¥_ñ?ÏÕ¤ÜD71±d¤jçÏNVúᧃSX_S’~„Û•©#O'Ö'¶<)#‰£Òæc´°Œ¿·‰M½Ž‹°\Gºpþ05æª=Œñ“o‹À¤÷?ç-箧Ütб÷qyÛ^·[äHãø13:™˜•ü_¨ljõ廌sœ®˜êaB) ò³mƒ•¤ž6;ƒwzŽ«Î"?½§Ähèr4Œ¯ýKÒà'z›ýxR&¤}¡\h‡ïB=æ\°‚WˆPúõé)õõ‡¬ Ú!ÇJZúßœ§ñ¾s‹ ¤bOI Ö§Áç@:d;^(b@£ĹkÇlgÿZñh}¸ó Òžš|„00+íh g%ˆ¾~åÒYqV$™Ãb„,¥Ý“çc-Åû+·MÌ˽Q‘ÞØ[Ð3D÷çKÍ”°qÆ£+’‚€<5wõøùÅ™óC“êëʪ³²\ÀîBvþÐ{BKÏKËÄÃÕ1è»´ïº#tgvÐÇM—í5!ƒ,5ß�A[BÃqëµé©˜b‰.U˜Ú‘·ø³ÑYæ©s²¡ê<S@ -·>É7àK¾#ÇËRœ£QYG[¨ûþ‹{ý¬Øjy$Vn”¾E¯å} ÙCèSRE)NMÊÚø=E.*òø âñ)ÅHURÁPYÌÁgLëg `þ0þøD?>²&Œ[;é%†»/§v²á¥7Ôg¶‘ï?^õ §|¾C°ìôm÷`1Ü=oÁQQ€g¬¯�œi‚¢Ÿ“3Ïaµj hOšr•(veíX A{Ñt_ýýNpá‡4V:º¯VXÛÚˆ£éC”‚ðïÅj./ÁͲ}${€®2×Ö Žëj_6 +ŸKL÷i„&w<ý«bÙ¡ 8ÛúˉÖóŒòûÅ}M(kÓêPØû$(:õ-‡“ N*�ÙP“i´ŽŒ�e]G"ý®ƒe›¸¶öµF5G‘£èâ<ý‹â2RßNyî˜w¬¨m +ñoÏñà·}zA­«œ/Åìñ‹9‚…öÃ=è1\Ã4µnL–`/~ÆkÄ>o›9›#œ¶‹™ ±\ãðað å€O Î@‹Îk‚ÔI®=m¨b†­~`Tt<Å0›bê,Êíò*¡ù²'$c¦às½têÜØ©ëÿÖ�r)ª êÑ·¯&Ô}ë¿%ë¡`N«“©€ Ìż=Åq:Ôîóo»7€;gŽ,xe†f7`�«TT˜¸Ï‚h™•Ìbœ<\‚˜z‹ÍÊÍ7ª°Øîñ‘ÚJ;©È3 xôê=]·ÇÃTS¹ÈX±${CMC¥™òî…õ¸Æ ¥L‚ä|åÙM­4œÊ :}ê(>\—x¨·vã!`SìG&‘ŸÆËu6ÿúä¥È�ø(# ƒl²^'•Ä~A'²4&ݵ‰C§ø‰ü˜ Âúdž¹ŒÑ¿ €d³Uº¡ÔM:swJп¶Ô'¬”q¡hôež ×RëR•Œ&å#]ªÈ d«sê<‡Aå|Ù8ÐùYáŠ9ªZöíü'©.xô³ù8‡Y¶“2k¼”p%Ïí:Û ŒSŒÑ1߯î蔄D"<¤-Õña§E=¬¨ª'ðÐD”!ý–ýu¢c²Ýú~/Ci®[¹ãžîÞ°˜]‚â~>gŒ!P©ÿãOF5qXfž€Œñ‹ȼõÚ¥ïõflf+“± ̵“—ç"”–‹«(ÚsCOûsöÂ鱞þ C¥Œõµ›õßgec^®dtCöUXÉÑ„aÍŒtÁ6¹Ä ±í5"ÙÓÊy÷ÞÎðè#î.h›Õô‡Ï˜1‘˜1«•£_BÚInjHq¢ôQÛ„‚ÏÛÃúà°0µ0²Ri=kÜ×Jå‚t!º©·¸3°£}*tÆ”CÀL±¥ÑRxÄ ûj¯U@Á •«•žï¤ü«0¬vFÒ»n_¥êvW˜9ó©G‘´¿87[úÿÖ‡¹³^Ú´ŒÅQðLŽÇ>÷,Vó2óU#ú–”ãœÎžŽïkhj,FÌæÎH*]ë?+È<È,[.)ÕÛwbIˆ ]¯×„¬¬— †(:R÷ÊMË9;Ð2Tê74½p´=xõÛs©™ÅBA^‹|¶ç'ÂMÚ‡T±½®o§¢Ì->³JD¢Ú˜ÅJÅù"‰ÞþyKŒé­:« Íãºû2ѯiGWIæ6)멹ïu2¸±¶íO‡Át9=P:Ã/WúÆqôb/v÷¯D¡ÈØÍ¿ÖÒ¦[ù þ­üu^„¾bAt*¥÷©¾zZZ´ïÙ ê6ü¡gV½ýøÚ‰FÈÒ†Šj-ˆP©Op³Vå´\…Ué‹ä>ñ8³ùŽ¸ÛÀLÝßVϾˆ»>Üu°)î¾²=ðñŒLÃ]ŠÝŸSöTcÁÒÆq°oé–Ûm›d‚™o~}n[;_y‚¶µÈÈ‘^X½ì¤Xˆí¸s’¾ô#¼Rx|¥óÂiëÞ»ú†UJBO ’Û´ ’“U¸ˆêµE òÖa¦ÜöôÛ,!V7i¦ã0 —Mwßß=t—ñ{•ï‚q<‚½C£<ç2JÄý»/Š(V¼x7Ö `neN…û‹“àUay÷Üüâ ÑŠ¥…à ïzQ9Õ0]¹8êÛw¯˜§ä¹3ÌŒØVº£$'¾ØFR…Dd§!¡_pø]}×ÉŸ (#U÷¬Tø@ß"mwš¤¡%ÜZ—–ïE¡§³¡>ô³$â÷è‰^÷ÏÊdaòãìØŒÉóÜå‰åîeß¹´W H Vé¦D_ *CñÈæý÷Ú]úͪ¼îþn3dâHË÷\lçðJ–7±Þi÷/±§+ºÌkŽ˜í?¥ A£( ¾jªñ^Lô ¬@?Ýù æÚóËDÊ„øf¥Ú¡Èù-›f¾ý;†™ÌVlmkXä#jx+þâµËí%Óÿ¥Yþ­éV@|дÎÅ£ £@ày¥à³žö<å»3ËeÛõ5匞D”Eæò£!By#n¹¡Œ?þRË:(±njž_ZdòSöþm–7Р¼¦÷«J¿ó×Y³«®xÌ·ÃYÄâ´?zEž0‘,Õò“!ÕuöøIÕÝÕZ¡ÿÃ9/T¼'Hf«ù•"¬3ŽÉø!›Œrâ䣣é[ö;"‘öVKµÄ¤if¾$>ÿ¥Ni(Á�ìé`¤å!¹}1b¦ ‰Èù¥ Y™”|CÇ°þJGaÀ!“×gM¹`u…ð"Ý0îŸÿ0*=›&îÞ¶]–I­$ e òF+ðDº; ªûíÔ™':³öízð®ýN‘ĆÂ×…Öaüù¥+&7²/ŸÙàÅ›}=u=ÛOu>ˆLMÊsÆ4?íÎZøç1`¼¯•¬ÐXƒÌøÞ<€ WüÇÈÈï¿<¥g´†œOGsh[ÃóîŒõÄúÕƲ¼,2‡,Á¤ æ¼’íŽö%¿(ƒT=:7`ûŸ}”ŠÔS!an$Ëeón±.‰”)´n•PöÊ\yݯ¤äôH/lÿ5 ê8Pj’6ëû©¯ÁP?È~«Ì·’‡òü® Š¯³Y±¹ÈåXÿ$*W¯³›Ÿ>çÊ[…±œ­‚¾§¸¬í|‚´ÂMñÝŸ¡ |Bu¶0ŠèbÔÛß~áCkE”=9 ¥ó—Ž ±Û³§›>ð  hò¸‹oN¿•G¬â.úfŸÂ;C©¶’µâjTéÓ„“F^VÉ›ÍL¤¨Ägí:¸¾!†´Wȸ#ó¤Ç™„En—^‰¯„+¹m}Á¢yö< üµá]>(ŽBŸOÙ¦°˜çÞThë?‡qqüñ‡ìek¾—oÕe ÍV³3´ÿ¸¼Ývûþ°èFê+ŸCÒy\a%óÄ…üD™åªíàY$™,Àqû+¶¼ûWÑNßgöž†³ šú3U æè6]ÇÚ¾Fˆá¬Tjm¢¬"×Ý_âðpw§ÂÁ÷±¤´Š­2€wÓÆ™ Z˜ &o~|Ѳ ýGkˆm•ÑWSLкÉfË?óÓ“¤XIfÆ}J/¿<À3¦Ž$z¤[ÍrÈ�M ý}óªüMµÕ|¢—5i@ÕÓµ禩µë÷ ['¤´ÍQÊŠÍ—)¥tõäÉ5¢¡å§«zwŸ_ÝÓïÀ=ÃaM™@ki˜ùwƒ´]Ü9¨à;GuäY5òÛ óÒzÐG¬×, ×U8?p/óÂ7 ië�½\ë8#‰knm­Á«¦®¯¢ЇbÎæh½ôé0 p"Ö�j (/BRl $æä‚nð± Òw-Ĩšÿ¤ý?™ Z篆Àè?™Ó¹ÇîÏ‚K›²�”¹C€¡W Šç¼íØ@±ä)“6Vàa:ÏT‰µ½ªëÇÎ$ž.¤¼ H9rœÒ@§!ûÒ·F‘7§ý¡~›?Ï †¿¬õëh[Ö“ Š´?{Ò†¢Älži(þR4ß*º1QŸ¹T}”óÎó$åûÁS¼pþRì#Ì3/Zƒ†>S+Ê¢1c÷a pp ˆßœY¶’.OEžzÖXˆZU—œã÷„©ïˆÊe+5øâqPöGaÀ‚± žrΩŸ¥(¦3ð"ýÉG]ÅÈë*V¼¥ªàò‡y`{7ßÇa·ÃÛëm +÷ù짛ä¥H,ÇÉyDQ34ž!ð4²ÿé¦Û<6ëk‚©Çãb5;äFÑôîUÐGòDèñ„5xF•QÍl*p¢åÓmáºï¾À…¯ß˜-üL;î7€x%ä€:ëOX²W¨Ž9rÍlœ+W† C¡ã÷8Nнÿ[ ˆ Or7† Ý·rÚºœ%|ëêŽÍþàäî]ÞÐáŠqŒB÷Œ2î>Íé°­/g2Läûï[T¦õê×w‹ÑÁ”ëw—EhDÆyƒžì¬Sð;VÞ4Ùêã¹ëßðEGÆÿ0ãqm²Ä�5çR6Ú°ߦŽnèü6>T”ï�ÄXÃjRÎ)âY/²ÍzÚBî–ÖFÉ2ÖÙL}#Kµ Ÿš«ù÷ÚÊ×BE%« À£·o¹ H^$²ÒÈ›Î=Ñ/ zég­HbÀ`̆”3Ô½§>öL«ÂAƒvŠ“É`àoìÀ’,\+X/TGVû“/o­†æêR6Še-àøFÛhõU‡t|ˆ@pE\PÜý%§KV]Z×4ƒÛÁ'Öq¾D_Ù±¾~ƒ˜‹}6"û±žº¸²Nµq÷jL.hù ÇIëS90˜ \fþ¹E^¬å*)IÛÄ/½;¦p'èÍÎý±ûÝûæÉ  UóÕh’ ‡"×RY·ž´p·Ñ»º'¹¯¬!¨ÁjüÚšT憾Ði‰•õ$aèÄÀSD„Ánl[pÖLÌýyv‡I{Þ4 ø¹”#o홢®<€z ZSœ¿ò8[Žêš{SÝ6J¡"š%¿5SÿþÁ¦r5yt™ÏÊŸá *¥2ôÿ­ÖàÎ)òÞÕí�Àir$fîr8¡¶×Ã\P�¦¬‹oŠÌÊ7ãæCîºÛþ?;·mj¶5ö¶UšÑNS/[zÈG*Â;ûM|ÔIT‡¹®7RôÿbÕf‘—Æ•ÈJF—ɱ8NðHÒÔEÏlKŠÜé8%?õ°`™kuêÄÚOÝJÞ‚žÅð3ð$MLO›'P߇ –¾¥ãÒ 9Óa©¹¸ÑJbµæ¿q,‘ï#‘µWÚ=e[Ѳ‘ùš¬E®ÏÐTQä2„œiAíYÊÕ ;ä¬Üß' ¢Ouß@T?39ÞXîº^¡Ž¶CgäÍË_ØØè%°¬s”$¨Þ7E¨±-‰;p-¬¯OÐÂ{A"íÏUX™I 8µu¬¸ƒÞ±ÖÍOÿ Z&Eæ÷7Ùî)òΚ£â©Õ,#ª´ùë²~íebƒâÁγg,h7²ÒM¥iíú,£7W$úIH®·08qé!¥Ÿ"Ö±‘ Ã_Œ eŒý=®XâiÁðÂ?õZ¾¥¢žÇò«&ÿeZf+/„å:˜QªVf8Ã;kuú²]¥¯ÎP±äÕ$òÖ²óâ@¦x SÌñró¢qÆ›‰ ‹¥Z.9©¸<EmXŽ¯¤J\{‡÷_�ÀRL¦ÀåÁOHÅ+Œ•8?gü™êÿw&hÑ/1O1{ÙºÁ›P!Ay_§~ô5Á†§%WÃì‡9F9õ¯”R=`“ŠV-3¼ôšÆAŬU-Ù©šã}1×ý8Ê?Íõʺ%ü«TÓŽXy|K_¶Ýß“†ÀÃô{Dª!ÀLË"2¥›Ã´9[Ázà†Ðî]ÞÙHÖJ:7H¥ ¼hOÞ€æÿ¿M4ŸTñ€PD‘Õ*áÐrä:ý;ŽÓ"­OÁöšé{ï!ŒÁ•|rn­‚"·£ØËuºUô«\½-v`§‰Né~ïY*5ÖÞÖÔ³¯«÷‹£2I2“Z8yè—ô1k¯1ÕÖ%™‘‹ÊUéxŽûÓ/<·¯Â€Ù6 eøÃÞÖìÊ•}æ÷WÙ7iühÐê>‡ÜŠ‰yë©ÊÓóoœ”É ½xÝ}qlælË@i]Ñ(3š­löÝ3N:ŽO}G'ƒ³hÕÑJ@(×Þ¹µÚÓæ^jœç$(-§{cõDÎYôœgnK½˜±§q‘y}Ê›ôrrÓþúãó÷}¹ãîr˜ï7¶“¤Êœ"&Þ‡d~¯­Gl=²c‘–Ø‹%ƒ»h¦NÈ+¾€o²öR¯{:ȬS%ôç(¸„\îáÿSúÇ^ôÙº^§ªÞë¹Õ+ÇñõÎÏ„58r}Åy½,|åFŠ”›|&ƒ ±¡#…"uî&sâzטðMLsÒâÖz¬R±Ó†¾;"0nõÈS„Ù›ÔPv<×lÒÍúk?È�W(•‚²]<_mºåsmËaŠKæäšW׿ïžÑRƧv ;Éz$2/‰ƒ7€Ÿj¹Ð‹ïøÓ$¬*Í"1Ì‚jRä4”tjºÇ]zv^ûïý5—ç(19Y?Ö˜© Á…rÚ¶6{Zðÿ}‹Ð5¦pptaâ7vnIä~VĦD4Ìm}&]«3º0`G)%]I‰a`™Á]‰"|¹`ón]s f*R…h­DÏö vé&ÞùÍaRe+#éT¸ecÛfoqú¾ª1Éü,4!Ù·Çù/e+`1{1¼ü¿amØŸV tÓ·½ªüÏØXiZÖü©à26t8©¹Uî¼ kJ ØAsÄè?©âÐø<ÁQªÜ[G©ª¦%�½>³�~c!ûÈ0„õz\éY‡,ô�%ƒ0æ=(Û3Õ ?;Š"ÿÐM‘K“¡4Ûk_ïZ‚N#²,¹3´ò”V¯.¹Œï¿}{íéoܦ.뙥”.]B»þsòp¶ò¼$3ŸºEqþ¿6à,’pMŽÚ�bwΨ ¬œŸ­œpêÃ4¯®×Zq‘ø¼"DPìŒ&›€ÒÛ³b;,죯ÇÑ9Ö»zìùqm(FÔƒáL uß,’_·œrlF ÏÝv²Ä÷¤{ xȳ¥·§A šÎüñ Ríêl¾¼?Ñæ g͗糧-ÒØ4s׎¢Dpè°`ÓÁ.ùËUÄÑ¿ËŤiè{áЇ½LUZQ€¦¡*Â?IÐ7çe@9* ¶v¢[Ä(ý‘½(eÝ"" ¯zÏÂm$Î: Ì=g–é|-ï1Î$*s¿ƒ‰¶Q¸ÝyÞ¿T/À á—1Î9?UÂ-K×ldÜâmâê³µ¾²üH;3½=C2Î4NW?<t6ŠØÅÝÚCb<¼�ç v2œ,½;$ù °‹”z£f¾F&Z“VÍü†Ëe|C§Ý�Ñ_k ø†³hË×}´wíäk>ȇú¨-³C«óÓ7‹=äK³ðaõ9XÝ5}Ì ‚9 Hàñðo5©N|�•Ë¥ÒéÝRˆQ”ô¦x¢L ÝÕÑ«~ïÑy}-ÖOUPœk§5‰´õŽ 0ód5(!]€†rhp{'48Ϋ}%¶Ôµ¸:Ò¡’‹Sffµ”JÔFe÷Œþð¾¾ømìççYVd+{Ç„8ˆßÿ5Xj;¼ÖR£¼Í5e¸î—Neñ< Ù»j²áŠ©EöÜ$AÚX÷E8ß'ɉDÿõ% ® Ëàm_ÓÖ2½D÷ÊóP-γh ‡¶Þwxá‹LAèèm·³“#¨ü°Ú°‡;Phùý·Œ£ÜçD·1¦Yî•dË:'´GNçÉ6ù©¸>šŠ@5hí%?]±,£‡Y[]POàghØ¿c�ú‚h‘yHi$†V’/•àJ¡ûL§Ôi<Ò³§§~GYÝuõ#ã²%êpvú2§z¦wíy—¢]uÑŒû—ÚóŒ­ð5G9Š2¢«j&§Ql‡qw.‡Ü[y¢ ›q¶Èð>ÚJvÊL»qÀÈ¿>+Wj0;ývIVøvÏ8vbÎœv‰1DÛk¢¼†0ßC2Çyœynºç ¦›ñÐwõù^uG þži Ï ±qæÕ­´Jš& 2ÆK3 ÍŸË‚°ƒ.ÿÔÁº—QÐÔ›’¬ö×¹|·½9OÇšײX°f;á$ö "YÁuÄõíßî°˜•õ³Îvz4n€‰g ¬K¤„RÍÅŽrNºŽ2 ù÷{g+çÞJ4äã^Óˆ˜=UA°ê”VÈÏ òH‚RàÆøfãI·Þ“ÞŽ :–¼ðÔ i}’¹å±£È°`ô qšˆÌz<õŒ ¾¾ííÄã8Ú<öµÞœ“€ecŒ(ƒž‹uÖÍfDp›åe;¡à²•ý©VS“ûÚ¦Qäø°a$~0îÝ{-ç¦as;Âý“žÄIÌÈé×Ìô é[C13á…Ãç èf)2¹M· úû¿5Sj—±·+ß­™*3w; ôøu߸v=ꬌu˜7¬}MçM[)uß©~8=³ùÜòñÂÉ5—ñ—›—;Hd㊖†±·ÄMòP+œéà½jyúk…·Ä› I§0”p«©Ib4aºÁ9òb)yÏ}¥¥Ø—%e¸ÎÜÑ]_¤Û%Ï›v0=5Ý}/£xc%)‹tx ÏGJ&ê­-RuŠfuMp–<…�ʲÎ=;žn Ð|/«ò9 ;²,8ä,î2椊Ö*™®Õ<~tî|{þ£¦ÏrƒpLãýëJ±§ršß^ô•ø åIÀš˜¬ÚêÅÁ-ߎ}eä´UwÒw¯ôVãNÊH¿ Læ.Vž]¿ŽÃ$ÛžûÝgæ#"UTÜRhü¬=-Q ]Ê gJ¤ØaP‡®À¶6n©KÜj¥>Až·5à¨8hÑ&Eúo* ½øžg¸°ÎˆWï;{{xŸê‡¾ë9î‹|\Ü_Bq[q`Û8ОٰÖÖÆ‚ù XmT î¨ÖF™Cs±G۾΂´ÓI6>m‹ÕÎLÆÜMúò0È„.Zr³ªÝçAò~q*„ ¬¥Ü¸ìÞàù¢Ò±zõf¥òÇA…/p½øT[ž4ÇÀGû¨)iD`œWþ½¯›dAb:‘›K„Ÿ[ol³ç9“&£Ì=–z:é°óo¦ß�«*Ý#€mî«P‚/˜ûýël¥ŸœÏ‰Ž•ýÞ›97ÝòÞèÚ­@ø«‚áQX™„>4p¥ž‘ÛRžËÆI¦qE€Ö ÓkH*ã×»jîÉT Å²•9½\”žƒ¿¨›js¦‡%…:Ok}Û´r n741„-à gBBïÆ&¿×[K<à'÷å.Û2ˆ–ÆáÆ¥)Ï ¤º;¸6.þåCïI&ÍgkÎL¿ªÖr&–Ð×°‰×…=µïýä‰ IªKï¼½Ò[¶“œƒ” ¯#|'j6W¸w…9Bé¶èå¦ðd¢Lž‰â÷yþQOêúnœØî¿(ÐôWO«œË!Jø½)Ë´Klô#q$6×7+O�Š7OF¿QBâH¡]‚Njŵlè<Á÷‹6¥D.im^¶ðQÙ«0ˆØœ¡ju2Ï>ãøa¼•E+è/üt´«º»°"îhÁÇvî™ñ8þn6Ÿ'N Nj¢)a%5èaOROƒ>mðÜàÒ‹ÁZT!ÎóÌ{°˜rc{æŽÐ±wz**`&"ï{¦rbÔ†˜å8¹ 3žüÏQq¶*z75&õàÍW wž|nïCî8¹•ÒbÂ_Ñt6“¿°]$0ÿûçÐÒŠ•m‘­¦u¿ã&¡sË`,Ôÿ�>T”3úÁ耉vùÌê=¢&Á¼Qüó´¬Ø<áRI­í�x30 J$¢oä´»º¿ ÈÌJPFŸïÒFePÌÿz·»;û\þ‹,ïo¯ßÀ+Ýò.ß)ßw×R›ø=7†‡Vw½wNûçõJGðê *6ß­hX ]¨Wè&= `ð·®ËÖÉ0ãv~\¨<‹—ÁkQu:ö(ÿŽ¿°¯·'QµêygACk-šO¶+.ËG˜,ËÙùëîÊü‡£ÍÌ'Eì—Ð ;»ƒh:ïè¬ñÿ}¯ c~ÐÌßúõ̽›ó°«q—A¢©ŠÜCCDØu˜ AíŸcm'¶§só£Ï ©Tí¸Ý´VNF¹Åcžò¾¾Š?Ë­<p¹ L 'Ð^…ÿ`¯É�RÔ¦ïܳ?€ègbÀÐ]ØÜ•‚i'E²Í[ýNLl…©ÁsŸ›Š·¾™•Ö˵è‰ÕÒètà`ÊäMž¡EÛs‚ 0Èž–OÆkª3 dªnÂ¥ ¥!fï¼·›f\îK‡¡Mó±çR­*FŽX&:ü^4õŽ@Ç$ ¹wÔΞ¹? „’—Ôz^Å €ÔG¬…¯eÃð}a«ö…¡|5 G?ä,£„EŒÇ­Ò÷+ë·*3ŒýÜØ_Ï µªE’Ÿu"Ÿ!•Ê¯š ßz UúP#nKA´òTÒ»À#œ_Y…$ëw΂á”Ym%Balj›†¿ñiîüùx[°Í gš Uôu7ØW,Õj…(/ƒe@š<mM—DQí™Í+!ÐsšW4å ªÒmêÜL­¹7Qž´®BM"#H>imâÇv„ã?±+å?ÓŽ6Y¹è§x¶Ù3�˜­$d™ï7Lx†Žl2q3ÜòZi’š´Ð9(¾téW…NŒ%R¥¾65Å´¥§Gô½™zcw±ÌGyYp_Éc*‹3«·‚g÷%Õ2g,Ç+XÛKIq¹7Ø)0Î@þèÁ² ’‰°寮S#–l;t*õ`DWqêÚñÜè>¢ÅLyÓá5Éž—9>Ú6m(ù®³¾~›©`jFÀбީÈ,X6û[s…5£‹OM³BmIÏÇ"ˆ[5´E_l ó¾7.Ù%4¶‰ö⹩b+V é”JÎ)mÎá¢ø õ²²ñª;&˜Ph¨fwE¼2ãFÜvŽt[¶™j ´A ³ÙŸ©²¥*x©ÛÓáDÛð³ÖOŒfÖ~l†Ït8Í Õ¹}õ4K#¯Ç´‘¹§€g¥#ˆþ@5Ž"ÑÖŠͽŒgV/è0ÙFGG«ÂCGQ#´jQ(5ÕÓ×uUƒ§Ä´ˆ³•€nËÞŽW‹/ ŒqSRWZB÷¡ÿ¾ÚÝ6Rå1hØ›¾½Ò½þuHPZ¥‹#ipFƒ~9Z§Ýä5÷îšcGQèkD�zõ‡ÉrÑà eïžEôíTŠæoÅâ(Zië¥Aß'ü–Vƒ ü£þàc׬ÚnW0Ãoÿþ“D¥óYdJÐfKçb´h ƒxZuóÛR>}�9‹¶>w’¥Gë‰fm6R¶;+º™r‚WÏ’ÃÑ R/Ïqå*\±mWC-íûàŽl•W¨ñû]zÀRd?l••‹à[zLô–ÛÙlvi×·S½sÓyJEqtµ–5×aËá‹Sªâž**’% Ò‹W1•“ŒÐäò©�ì_Àÿ@•«¾i{'a²"(‡A3$ArÒò>U:Ü5ùÙcòõä=3J_!¡d:7”këéÂh|Í\, ºî¹„¿[{L'Î='8&@©*{?yMÊ'‡ÐáÝÄuô±ªr…YåZ²_{OLZú0µZ^Ÿw` Ù×ìQÂ<ôÝqÃÔ(…+Y0&úÉJU;¡ðÇìRÝTJzè(˶½êVVÚA0+å4éLéì+n.w¿;ÖU¡Ú⢖¶Õû§Ù ÓªÞÃt°ædÄÆž)¿ÇÎìq;ŽÛœÌßD¥'µ«žà¿Ð'M|Í).¢úŽ*‘F'&(ÒÄðÌõ…”¯v÷ŠÁ¬¾ Qû4H¦O3Þ‰X`®î5{YÜ>ò:N,\·ÿH'Æ}ß7î·Òªh<µ^ýô¸A =äÊ€”Bï«Z[œEf+ÕW+@©y×¾HðcÈ‘#m¢>BK½½¸±c·œSê+#~´d/¾¦/¨\ýTæO&VˆTìëö*Û•nÕ‘=µ9ü¨ÁËS߈7…±¢Ù){)5à�‚…ä_´,µéˆçPŒx kmG!³§›dÙ¤ŒqùêRy†¼ˆº/úÉI‡Ñu¬­P:oÿ¾»TM¯²õ ÊaYÃðó©¯Æ ÔiHè)߸«;¨Ÿ0q-9&Š_´“÷Éuüy ¿,&ÞPÀd°»úÁ Fý椋‚µ¸£<'^ö—Á)›EÓhAyßÆÏÙù9‹|[HÏ°Z2Akoî3O[cúê?¶4 ý\�úÒ3@Û³ ‚”DÀÝÚx6ìÎÿ}³‡8ôW‡Ní?Ä«µÂ¯O:Š‰—2Ç8¥¿XäU,”ƒáL¤¶ÿS_>²-¬\­ÍŽY|êä>‰B®8Ýò_™[Wf‡Ÿ 6e]bMÖhÓ↢HÞÙúžWüÄ Ä§­ ÒS?ãYÞf g¹åâI[ž(ƒ§ûui•™‰ºŽww=ÅåÄj»gÑÊßÞØ…¿Êâv·>5Œ+˜&”‹â´JÏ/§»Ý—2ìžÙ%xæA2ãîi×ïît6‰øð/,î«Ò!<àtó noN,”çq¶cºûž_ÀVò–´î–JíÈŒ#å#Êw „¦dó®äöbm“`é[¥)xëæ×­'€øA “1FÛÝùò6M Ÿ(NAòÔQ)X6ºK©läI£Ej Pãß¿ã‰E©çÌ©±8{Û{®­¿Ö‚ÆþBŸþý gï$QroaäM9¨–6âDƦ¥:-zn? ­Ü"r páîðå"±ZI?ûöõ–äõ¶X NuÕéÝÓ0®[Ê¢L ¥Fu?:Ö%aêPr¬ÃʤoguË%læU­Eø~ûíD¢Eí«6² ߟö †Éµ Ä?˜ÐFÿIÔ²ÈfÄ—^Cí¥”ôØøo`Ò? I“Ò—sAÂMkl›UÀ]†‘[]Ë%KªÔ·m…%ÈLÅd{ò ¹VêÓ•;ßf˜f™qìQT2öþ¢ ½_,0¶Ð_YsGJNmïéÇ`WÒÀȃ¦¥¥×ks<½žîæÁMn¾ÑÃóÄKϺ@‡å:RôÞO–©+Š=ê;t°½qcŽšSœ_ƒßK§ˆÌ$=º…›‰k¦óÐÝÎyµàOdO,`'»qçIž¦Ãh]R~Þ†¹‡ˆåñ¡�çk%65°WªRòkTcì©#Æé°kÒÞuÇù@ª© p‡ÞïììV7݇ÌxýYÕ⨤¿rÀnÛC—3$goõË2D?Äe=(r)¨ 'yÊέóüa÷dûú¬´ÅÎ[a0´cÓéË7Wgpã`Ÿ¯K’fq¸2fKiÀìGåéâͲc®˜GE´étFºÖ]í¶T‹ÿÉÊ"Ê"|Þ–*¾âóÝ“éw°’K¿`ÓŠ°I™ ÍÆ­?ß·qµâš% 8Ó+ê“ö›J&×6½¥íb¤ÇõÀ/¨fYº’˜­Dæ(oì³ÃJmtøLu7~šû¹Z"Ω ”÷­ªoj–Ý„X~¥åòœNîT‹KS73·ØrƒÑ2 ‡ö>î• ø讧–½ð?,WÃ1Å eÔy³ÎBÃ*ãYoç)¿”ãÃÂæ £;BÔÿä‰L=mE ^×íy8Ž—{–׉³I‘²ðRAÞþ«3XzÒ[Ȩð³æ|áx¦º‰i®t>@î00µ¡yA=å¼YÅe¸dAäÌKXÀ¾À¿oaç£;Á3ó, LŠ‘‰Åí—‡ïð„Ĩým6–ÄñÍ梜7a'qÙ\¬&§‡¬2G:?@MŒÂê°ÜùÍnœ¹Õè§ÂYºš´¢’Ó2Rö&ö!F“ìWze¶å*ÒÍÑè礶]ÄX<A µHw„³Â+wÙèÜUZÒ>º)¸lÈ3¾k±P!zØc0_?º™•%/‡~ßO¼ˆè?q‘û°‹¿RÖM6–}YXC‘lè‹  -²/R+¥yFÞô8ú³V®€ÇôÝx‚‚ îú­×—û°UzšT”]Š¸ ©bj4íý$šE¥¥êÿÉvmçÞÑþ ¥§ÏÞAêðíÍK‚6-/�QÍËßépz÷šæSì1ÝPm`ÊD§1z´žH–wåS·rÏX8CAÔ å¥_ºž¢$´ ]m,|#féKý­F¼åsȆ¤“£KƒÂ MÌ7Nã³&žÿ”ú%êçE&vU})ýã¡÷û _¾b7lŸtVãGŒS—¤”ËiO¢DöxêŒÐ7@/æ‹0æ«Cóo{ž’Àf@ãaºÉcÍúuöø‚ Á#AâXW!£¿š=í¹mQãXQÙs#ÿt<†”%lTQ­8jì »˜(ÝÏÛZ ‰ý¹¥¦O'~@*N#_é3‚ å¥E¶Š[aÏßxãX¥¦^¡½N}ÕéÛPêûÍ8ÀجÑ;Dú¨JœÀ76šøÒE›‚Å€:XæB6C)¨hˆ‚ÃC}3_%“‹î˖ζȎπ‚9v‹WÚÈ°Æt!’XrF©¥UÛ´EËýä<#˜ö¬ø”ßÕgIúª¿ðóI‚d¶ÕY¨ÐlN@Ò„ òƒ­a¤L;EìiKó]GKh§.”«ã %6 ˆ˜ê0áÇ»Ó1ÅHŽ rthßNÿz"›È×Þœl%£jy?\F”ÿ0|ôŸŽy a÷Ä|ãÈ æ¥¨i»" òA;ÐàcŸ ¯*ÑK$" R)M„Ülˈ[äÞ1̺×Q¸…¸å»±E¤›N¨¯þ%èòþ—nú´§›”|éýIrÖ1±‚C×vóãC¬v™\š†ÑŽOƒx?¸B”WM*î›vÁß0–ÊܨXSˆöi¢¸»ô$,ßì÷îÊ)œÓ¡$e­ØÌd t¨Rè„΂кšËHvVKŠ˜þª †€˜1ñvþ/òAûÎ,†³Ø£³óPÊ!› ø�G È×æ”g}Ø…+TÈ_Þ¾ž‰±Y‚LD´ëœ¦»3äÈû~ak¤¢r´â ݲñ‹C´è  †V2UÄŠ/:±•\@ÏœÅ~Ïʼnž£j{v¤à†ñ«ƒÈ[ÖH`Ü´ç·ÃÌ›î þ,ýÿðèÁ¼¤ŽŠ¶a: `9¥çÝ»­mÆ/æ"�Yú‡>â›ÌãU¥)µþàÿ,j—ÞCœ"'jò[ÌÿÐ =»bž’i(~ð…¡È{W®..3m¯úÝk&r±ÛŽY?³[Š5? òg0ؘ´|îŽÓ8×”ôˆíMÇHçN"=èNºßeb­L(õVBû“>u00‹ÿ˜¢¥õµòñ]äÔZE' H‘2ÈÎjÖ¢Òû¹9PZ"2= WÑ7½.™¡¿ uèÛê$ý~„ºØ›l6³æ9EµN ~=ú;í2rC ε…ﶛ­ÿìb0ü'Ôvp12Ç/-_X³OÝr>ê ö7œ7Zª+ÈÝÊëHÛ­Úë—­XÔ¸í¾³>-S•¸«¿+˜Ò̦À‡ŒV_§iFYh¶Œÿçõ¸³/i±æ¥k•RtPa;MV„AK§ÂкßjËáè"J=•!îB ; Õ[muFe(›Ç Qm&Aç¼5‡™båoE<§å~Fºjè7â6§9Cµzš¥g>ˆ†ñ˜»sF7§QƒÅ‡UϦvQš B¥ç< Ê~qÂc÷eºæHàÃUPIm‡¬Ñƒå ‹œYuó»3•ïÍ�þfNCV[v¡P\*EÇbA—Ïi:)è†þßt7£ÊÜFèñƽ’ËĈ…BðÆöW2ÅQž9N»î´WA!%¶Äcöžpdè µCâ_?ÀŒçÉ2e3�2Þµª–Õ(eö‘‘”Ö¿ì»Kw :ˆ×}C´èÎd¶ÜÉrî®M†Øì¼;2t—»]«ùfd‰¡¡ˆN¼¯õ�ŽŒÐ·´o´ˆ® ﬗ4ÃGÉÂZÌŸ ¯±€¾$†Y1%.ÎÁåwX¾¸ô¾G&JBÀ'Ïï^†¿Ðñ4+~[Íüʘ±²›ÀÚr%0Hö1á2ª31ý-ÜZ@ù•)¬óþˆûÉ\ïÒ`öÈ·É¿þÊÜ8)¼;'V$ üpg_zþt𴀞bÑ]fô·Xö,²�„Í3ÞƉ5Îf#uö£àYåuè¹æokÄh Há5Lïa+•¦ëÿtH¦VW_ý3é7‹¤¼ÔePtƒƒ: Ú=í�9|y¹O$ÚdŒBcÍ}¶;u/ÍŽâ^“H£ÐÍ`æ±Ac–¸¥ÁBu‡Skà­ÁÂ4Â)UF£F¦šÇ êµe­¶ÌÛG÷¦Ö z Ë'X‹‡g‡®§ªtª £Ö^,ã¥1óâ{ {=q™h;yP¸zãׯêÊd¶DbyVa§Î5)….hÛw¯5óâfÒ¼9VAÖ*wúžz˜ÿA¼šk»õ‹u s_9 $¶œáfçIyÒê¼rícZl´Ý¸ÏñÐÖ’¹"µeŸåiÒù-K×ìø’óƒÑ z 8ºÞ2Ï‚¢¹xƒ| Ø4¯MÑ+ÑÏ€9)%ëfvã)ÕúGÉ„çµRØÉr‚.ô S‰£Z†e23¼É_ŒùòÔKBvÂÀp»êU41ƒ Ë8}_Lµ oª]°ÙÞŽr€bÐ Ó‹¼ÿQ!é›í&Èoññl.乂þÖqV°ž%(¯P\ ž‚öFtÚ{²ìÜ¡=üª‚IE¶¶ï¬;äúgã°àc‚– ¡ë³3'5ôqûƼocý1ƒ46]}¡÷£|àÃ7©³šýFÄ·ã¹ Âåêž>í¥ºL‚L Š#àÁ<?dÄ[º³¢òÀáJ{}[—Ø0rKÐzLÔJ]ì6ni°ÒpBæ¢BÌ°ƒ )Ωû[®Ù‹Ûô°Œ\a˜"ôqŠ’ÖïŽõq¬¯ŽÖôj‡V£­4ÊxKÙÞ*'à�c¾YEÕ¿œÑ³å‘ê ~û@x*G¦=„»z L§VßÉÆàÝ09ã Õµ|ü<gùVñ :x(ƒpP tiÚ ÆÊ×=ðñwïÓ؇6€l¾$”HÖ8®ÒÕí<Òé1C8½0 §IÆÀnÜ“e e™6¥ó§âÏÚœÊïõflæ7|÷ÿB]ÇS€J4ÇXˆ)hí)Uè?yr„%wÿ·YîT÷§IÇ4"–ÜùìÓ—gsd Ž‚ã}‡úË“A€_cñxžþ]3Þq�¼PZôì'*ñ #R¬Î:õ6€‹Æ-3\5glý'sðCiÒ6-•‘û­—,²ï ¢Ž!½Ž›LòrÕ/�‡>ùÒúBÁT:89ÿU}ŠüÀ24 –½Ms¦dGž:Ä*7‡º·{¸ƒ~í¸ƒu(T3Ýö×ém¹¶ÛCû#ð×áJ…§‚UE™ˆÞþ-Õå2"tB­DÇßL[]R)#x—KZEËÐœsG¡¯»Úê |änRù؟žÒ8ôýãÃMÊöš½—í¡Êñ”»?tm’l­Í!wÚšé» Ö€>$¼gèWoë«Zn@¸©ï&̳ûÄÓF*êþCcÑÂ’q€_zB—^†å?"—8’‰­ã@!Ü€4‰÷*Á�ÆŠÇå¿‘Æ¢èlêÓïGbf3±(ÁXôdN³·Üg Õ!顱Ü7ά;ÄKS t´AßuR4; š;”/Öü=7>v+ˆëÈ‚&×wË=w;çRYÑÝ9-‚jÒFž‡ù Ø$.¢¹á!S5äN:×ýö Ÿ»/òÏŒf¤¼¯»zѦ¹N£ñ#£ù˜_ç÷ø¬6±Ù°A{^1uÇ­i³RÒ6éQÏú‡ó`J¨Û 9…;ãRq#zei˜â>C·©pÞ·æñ�çk¨‘&D¸3mý_m¹õSŠd-PpF‚™ˆ%E7-4–…°ä<ª•_èËã¸û (ÜC`¨hÞ:h#“tç¹²06î?‰CÙÖ“1)- }ñiãMeZ:eŒF†íÖPÍÓò—d0þ"utÖWMBŸ}ºv¼ ¬hÀÏ'}œ;1v1Ä8R\ÎæO#Q"*³G™c›Ôd¶ÄOÆã ~á�GåÉfA-Þ{C}/I£«¡cerwõ½Ãd%½cv–‡S¥¡éVÛ›¨Ñ¶³Ê èýÑÛ¸ó2øY÷™@®ï«U‰ÚœÜ¬2:s”´¨.þ¯)+vßY*e΂¬Ö&A‚$ >Ù€ÒžÓŽsW’,®Z}7}¿ÈêðåfH~„ÝE<ôvN_s~dÚH‡E<cɘ¨äcñ‚·f·¦—éêž"è¾´2µ–Ï4l}NüþV…™n íèIÍ¡íŒÖÌtCT,RKÄŒLÅø¤£"x.°¡¦J µê¥ïw`LgÜ}PG:«å¾¬~@9ì0äûuëÓ;dr9oh)à%ó‚4oÒó-‚fàÊâ ãº/0Õ¶‹ÙyP+›|â‚ÌœK¼l¶¢m…ߊÁ÷×w_fKÀ`Óד ‹t@þë&{¹Ù"›Ìvy,žjX½‹×Ç¡ççe^ž$ÚÏ4òbTnP~Ö“©gY1³¼tÿò>n#J\íÇ’ôÐü-[-¾$nº~Nõ:·x¨÷[©( Õæª [4ì‹Ü„DÞ9@;‹Ûš¾ Ð[ägÊC1i;zpRÿÏ'¬Ìl¢Ryýé ûl“ò=ëIåñŠM@[óc3ÉŽ5L«g‡˜2�_Äï­­i…ì Õˆc±sXçK5ã5B–ð€.ƒôó_O—ÎæªYÕ_M'üø¢°Ÿâ ³àdé ³9›‰JóiÛ’‰øT²k¶pœ5¿Zÿ`öÂ=Ü^æŸÁÖpÏθ•ôã4Ôjžû;]È hû‘*}Ì]öÈÙïÉù ‡—ä#ÏúµåªoO'í ùHµWR"†mG> `©ÆÕï(.F«—[�sžúå-“^ Œ«bDBãÑz®Êe·îÞLÞF¦³?SbRÔ+]¹q¼‰ õÀÀÎ)ÿ6‘FžŽ?Þb[+q8ÎcîS´-ϳë¿vƒ‰n ᧩¤›©Ìιë9CX1E]¦Ûr¿Å§ŠF.mÈŒ†Ø|¦ö»_c_¤)j©ƒ®s& •‘溎H·ZzsE¸t'4oUƒnèQ ó®ïPGU2ZÌÝiC HI¯š–�W¹=l›WýµQbå>*”žƒžlðKxìGOQµˆ~zrˆU™ßcð»'‡z‚š‘¡¹I ý·j¼/•æi„4À»ÎV¸^¶ˆÔ ^ ñ²SôK¨‚3¬‡y7ëŸÖX8É!(M‹ƒÒ61:H…‰u£¢dtË<ÉuZbèª|C pÚWA9(á‰)x 5'Ù&w´wÙ=VH$ê`.Og‡/§ÐµGòÍ"k\(¼ßÇéöÇß ÞUÙJå? æ,È«•%±=­ý×5¡â4ó54#9i.ªmž±ýžÍâþê´Ñ>ˆÀ_èy49ý‰åêŠÈ?‡ e؇Úãäv°$¼«ð—8Yáò£œ­fò¡õÀĈýá@6MVEèˉbRw¦ÿKú8íÇn8|™®C–+èŸüÑ"÷¬¸¨Ÿþ“QñziEp„l{¯*e^£#¥?NµïboØëIiäè¤{‘»ž¾¡;©KA[,´²PòƉŠmÝ¿´½|ÏP‡-—‰žCnOðŽ «QË.úˆõ† f(wq&ð>r 7Ös¶|¹9Ø+¢œ­°B6]äþÜçù` VþÂ2"² i†¨Æ»¢J8””-IX;"h˜‚Ræ|ÜÝ?N©àFò*Kc6ˆ™%ˆ±ý“·ý8³8W7�Ê<Õ‰ò—Š…ÈçFΟ™=ƒ³ÂBŠ_9Ö;^NâÞ©_æ«æ,m”ŒW5. ÐZø‰2šÏ˜¨–œµ[f¼^»øH2môžR:ïO…ÿŸ¼™6’B¾sͧGm¨ˆÞ?[Óš† °!¢Á­~jD.<—|´»–9£·í=AÀ-@ÿ}}µF ÌžšÉNžý%h_N‹Nãa—P˜°»—©®à’ØvèØ­¥®r¿ ûýnØ%µWظ/_^:ÜL´íeÝ|Чì&…í®‚½6®¿³¿ªÄ>IÌT™åç³7LĆ橫º›ÁåXáJžÄ²‡îôºëˆÖaœX3Ẅl‘Ò×8.6Î×çx½„J OæìwÐö8Å œ¥ÿ…óê»=þ…Ä„/Lk:>÷³ÖÙÓ^s™öaRÇ;äÈ@ECó¤¶P¿ w¾?Z¦¶løÿzïb,˜ z| &‹lU6ïNÊ6/C÷Š.v{&<(dŠ¤;9óÄ-ÓÚ6’+ŠWm)\#/1ø‚fHiá´Ç ‡9$ŠƒÞ ÖqAÆk“ nÏ·€¹(ŽW-4˜˜Aj(äyq”™ˆõLy¹¹'‰/uB‹ùÔ%°Lôî³ù ~á“m p‹–þŠkå‡ÂÐø-”ù‡Æöoè^‡çñ09å~d'¤Þ|>e(öÞR­‡§¥\PÂ&Ó¸×# ?+7¤sÄ*Þü:(2‹Óá¬à¼¥½læõ mÅž·„Û++‡5A¤Ëì™ÉaÂP{²¯ ûøqÿêѵP<:ñ1ðõÅ2¿åDx7ÐÃí÷ž÷ ËáhOªn0dŽ›×ïHlä°ÐACgàéj&ÿH§ äĉÊ@ìZŽÊÔF†aµ·t¼(M\;…Í$‡ªÜOŽ9s‰NïûMcòù÷”I¸ò2EŸÈÆýœO~Õ Ë*Ùx=¸“°§%ñ::¾¾UMrE ]D =+ÖœéÈ…6ŽÞ±[®Ït]<k-Ê#OTÂôZ#oÓ‘ò‹(!âÇvnT¤ þ5f„9GhÓ¡çóî&Éy@Î3'O*µJÝÓ;žÕšíó‰î2}«ì ·›oíò‚\’Þ8ÞN¹W¨T¥˜C#7¥}Ci« @›^ÍE´ù,Ñÿk¼q g² ûÁ1]¶ãמŽºY À´ôß„YlROø-iìî= ©µ~•àžô^ØGjÒYShºY¢³è]ÝAÞ–«æL à;U¿—ÐXM ›,¦01¯&æx »ÒS1b}ålî;eç<Ùa-n‘'9zß»²‹`R6heUáfÁ^e&$²ýGµº447YÊ ã¾­vî–î¨?©¥(¥4ìec™žqÇâ¬/ÒêóUÔ¤8À­È¼›ºôD«ÿÔm/ÐŒü©1™ùr@œîóœÏ¿žðÊU ÷ÿ­"™adð}ô©fÜyxeþœãÉD£--ÙEþ•÷ð.9tz3f§Îôà‹A·”wð,Ð<'£+0±8"þÓÍfÎ|¦:ýžÎWtƒv1dC>]‡•L˜Íï¼wÍ’:–ÿ[½ðMÂaÎsƒ;<¾ÄsÆ‹ùýFÍ~ï•0›3Ì‚õÏ4 Åæ>£ÅÆÐ&=ccFCÇø>¦(ŠÌ[²•àŸŸZ0–Å4¦T3¹šÕÁgTy žvWj•’ú<”¸ÂÑ$h±XÐÀ÷_ÇA&;ºóª±ÕÊb§Fz[d±­tO±Ö.ÐÏÂØm¡]ö·émÉÁ;6„9+_ð·‰=øOlL?è­¬-ûÛÐBù€æ„» íeÎz劉F Yû¶+´bàpŸ.vƒUÜØÙ9ùƒŸ í«•»:t/á2‘ žÝ¼¸ižP õõax& �•ªpuð&Áñƒâ@iMz‘ü9Ð.ªw6µ¿ŒLÿž¹/ûP®ýkÆc)¡ýMçVlÏy”1F™ð(ì<€²JËß÷´ÓÔ˜áõ!kmR²âÆÈ×Á‚hœ–:Å"ãÀ쮾oþXAË‘ ¥*Àaÿz5‡šÍžñö;«–VßRk`D?ÖpÅ7@Â¥Õ} cLÂu»¸ ú3¦è;VA�ô†ª‘Êи?òM;'1\ÿðHž¹ÙéêYM²•Ö*JïG–\Â4êePn^­˜´N÷' ‘Õç§Qo™ë‘Ómâ›Ð/íJ‚‚¢],Kæö¸ý¨õ¸È#[DVXàêTÊþ§¶ wO)I‘Æ*Zåã{×Ä/ŒÀÛ¢~š6D žØÞšLÄ9¶#´W{ì™E®ŒÞ@Ÿ­ÝPç|ThCeYÁ Ï)ºEe¼ÊéÃàEäF3)Z±ß•G©:0gãmKšÓòãÁ0¶çþ.¢:ÎÃ5L«§ó¦ª‹u⺪±bÔ¿Ð|Ï«Ê1–DK`ír·óDS¬ ³Þ¥§ûÐA‘ø Ù©±kMµ\yfDºí¨è“=õgÌ2_Ðà2$EPÌ–Mg%îäuvž/oz&ctžÞñøRë?Å©5-ý“¿·zƒôèl‡u‰ˆ½ä%þõÇa¢}×ÝC±iBÕ˜55Iƒý¾hƒYŒQZZnbÿ‡aYôŸ´pÐ öÆEéŸkÏöœY¨©Àh £Óà»îiWÈ.Vœ‹+TB Ú¤‹•€á©ïia,þLe!#ÊŽ’äM”ý]]ë “«ÜϹ€šø((Ǿx ƒ(ÊÞ#h_ÿÛõª±ûêt7wªþh, ÝÓ³W¼éä¿jOþè/(`¶’fRdÐ?a£•.Î!QµœŒçaÞs¯å)üǪà‹ 2¨…›‰âJxúõÏ[§ðÄ4iûŽòÇ´Ýz ’zÞŒÖÖp3Ö¦]$Yo…›4ý{Öžd¾Ø<Õ¢c¹oœ…BÌ£þß,Ýõ"`Z ôÑ“èU DÆ7Ü=gØäó¸gõ"F¤ÒcXIÃíÖ•T¼K9 PTEWS ;^¨PgD 1äç_àï:õJVôÛ4´†“n癲ëÃAÜÈœAí\ëܹr¢«d—¢z—yã9ŽàèÜ áw|iêuo¹CÓ×´?òébî݆’hk˜t¡Æ4£€ $eüm–$«–ø„î–dÙ8Î÷-Œ¢Ôò pøð¯ƒX " !‰é2Sº½¼ucÉÕO\ß!·¶“a÷2A§dœÎgÑ-ú¹‚³>ˆ¡ ©í@7$|×ñq|c.7°ÔÎ<ÿª/æ¼Ui1ò}pD-™Ãíñï2‡;ˆ"ŽÉ—O#º–CŸx‰ ‹ÖÍÇ8ȬšþTw\þø«dŒÄHF°šV<ZDq¶22àÌÅ(ÁG\ÏIØ.T¢B§“/ˆyÚŠ%5.gó ׬ªÓ{Te&¦DäÐz2Äý¹Ý±7„×é³bnçtn}Å[kd*ö”qÌ”zÕ_î :c Y1žFøͯp”øðŸBð‡UP÷æV¥V{ªAóKpÑëTõ!/2ÍŠ¸ø˜lShsvnÉbæl�(¹­'ïâU_š(MVúYIpiáÄ~ò¥@ð‡0¼WgYPƒ˜ ¾ãZhý㲧­óÆíŸ{}uÏ#æçeí[ÏVsÏKNø/øˆîÜJíN€ ‹'ë°Æc÷RQRúðV WGJR:.´ âJFè“QR>u¿Qùm¨Êh× {uí=Q'ʃëHž|tË".„îê.êÞÉ£ Ê’!•ø>ÜiËŠ}ý£˜Öw2Y1Wë†y¾g•pII‚lVHSbÄrÖ›ä!'ÖaÉ1œ,[NfÄm•f4ViÆÃÍ(nP¾Zìºù^hÄr6P·)Þuäz¢‡Úƒô§Cgý ÙVzÀMáAÛ˜î›×ËÑ<íŠ lç–·ÁåcöB ½ÕÎ Ž@‰f«liiç›H{ó#¹¡ŸÂ =Al‡*–£ÿZ0ÇÚsVý• Yæ∠˜›}IÕôÞVðñw7–==kz8,µeÔܬÏÊK×^]œâ;mjú¹ï½M=Öž3Ä]ýÂþ.V\Øw¡[ךJ‰p¨<¨õ¤w’êm9Òíú—¬Ëá ‡ø(sŽÄ×± òNg¼/êC©=|ƒI?Ú³–‘]ß\Í¿ß':¹£E¬i¿¹Ð{7_^§Í¾3ÂÂ>Ó%ÎƘrê.ü+†oöþ§påˆu¼†.…ßÝÅ僼>÷Ý !:!¾X„ö¡mo9gBf©'P½÷ªÀƒL‡~ Xc™aαÍ)p^Ý©*ÞU¢”+°ú@GÉéŸðJy¨¹�7Ö©XG’¶õ0MƒÛËûÎ8¯ñ¤Ñ#OÜáåša— »ËEÅ'¼ž”³ ž>\êeñþÕú.K‡Uá™z?StΚÇuŽÝøl뉔ӹ»ë£”/Š ʹM.œ`éXœ}"·d 8¼5R4ú´J¶<F–q®y½›Ž%•×HfPåîL‡<Ʊò†îßóñð_îyŽÓþŽú[=g!xï+cІÞ>§®Oø3Ue7Ùÿ×n¤Â]_žˆ¾©JBÄ¢oLЀ{ÆÞò/ÁIàr×Ó3xe䤋ÁG÷‡óÕóä=ü¹®Þ@ÓÜSå Ùw¹ôSek8û¨1wßqÆmºI–Ë|‡*è£v9Ý#Ô$LÊVîëT>J#íG°X€n”Küîü±&"­O2:,·>W¦¾ä°±Ó­ï î¯õ÷Öµ?˜í•þ@£‰0<()ç†da¢K¿›ëPá#< %DeâJ8öü˜/0ÊYEEq«6õ×Íq± ¦­6GÊX>mC¤HUKÈKÞ¸7|f.9÷TêGVf)JÕH—Y±RëßÃq?Ct§‰å&~ b3½obEí"#Õlló-ͼ n–f÷jóm$®€Ä(hÙ JŸ¬T à¿o%÷PÄâoè‘£lG’ŽümAŸ œŠaç¹Jʨ‡–(˜.æ ¹_F™ï€BËóòU´KìÄ8Ñ9+§”9öb”™èú§[öLšd7ð’?Iï¬ó6ÓÑmͤ$§øù“g'lïÀdÆÒ©§Ã "NEF~5TåS êÕžÊ걩™—£å¹Ÿä‚NTA6X“d 4®b�e*ó©kÛÃm·oßé‰çD–A§pîõj#ÖëÂIk¼¼ÇeÏÚ÷ÏÛ.¾Ùó=fL׊w7ö;±à5±Û8Î|@7<G·ðn]ÃKTš<uºíMBõ8µŠt`a®ˆ_EÊåy`·Ýúðz$œ„U’¸F�ÕÏt?"–Î5ñ1.µsÃçƜ葕\ôŸj-æ’¡¹yæo)F+}Í((£GYÔG÷Ö\ß©ÜÕ%ÿÅ–A*~Øó.ª³ª¿#?\ºá­Æ&òµs™Q³Ö³^}ópK=f#®{žõš2ç<Ä«­ÿ‘¬KÚ\LÄ<áoË£v€[8¢Q€\*âZ!¶BÌ©’AÁ2§1ø¾/##›š!Ð<Aa7h¸Â^³²-Ëæáɹ+%@rsó þÈÝ7ß÷Èñ8R¤Ê°$Ê÷ªE  X´Bóš‘m ÅšßDIž¯ö„9ôw¯·RVÖq¼ŠáJ–! ª^'ÜóñyU·Æ,zÂ,Z)ý:™Ôˆ ÚrVD„XÁ ·vº ²;§2SÝFœ#@W(£›ÂWa\æê°ê¯”¿û:©iµ¡`Ì[Ÿ[ÓòIýÛ^¡¢Â"?QžÜØ‚†:iúÁÿs/·fÒÞ»ç±úж(N|Š?”ÒkPµcºitS«ûq¢ÛÚá´~3–ÿ»¡jšÆ>hGÁŽŠéÝ^ Yœ2úróã«©"ooëðp,Šü‘"õ<ÒÝ w¾é ëtPî=·ºa ¦rzr+ 9;WILS|îø\o¿ÃéÝ›’¥ ;ÓÇ#cy,®;. +\€ØNØk‘4ÀFO™ïœ$e&¥ù¸vÓ”A5omG*öÎC{�2Ýü{¯qQz6|Àn¶”¯Âõʾ<Úýìkx9N×_Ò½£2và.iM^¢%HšO»}]^†hÒâ×烇_xjDžÕ<ÃãDJ†4ª… ¿ëIÑ=™9}Eდ8´E+/7.tF÷÷ì·|qkæHCä–†‡¡~ÓÕg;Ôõšã¯\;_ïlôËÁ£ò³ö»m,b/is.1@x'ùÑÀ_ü…S)KnG½0ö9½{;ïc/V¨äçi]VZedQ¦ÅÔQD×™O¡Å­x0†×k#ÆÜ]27¡‡5äõÝÒH!(†¹:OñÝqg(î]ùÓôØȸ².aÙZÆU¤ýRÕc±œ:iHQˆï¾’‚ö¶Ž€ÝýÑ[³¦]3\e©H§cÛ] nQÚÙBhšeÓyÜ× s^Û¤?ôsïäÌ_¦£FYégÕÆg[ ­C¾z.J壞¿0‰®þX¿e±âƒ€4=®´uoØ6-íµÄ¨JBOÆ J_ì1R·n@ÉaÉmð£³HèêqQh�÷ý’±j%«¸Fs�—˜5ø½Ëo¥lTúÚÜtn\ÇVm=²Y×Rî¾cöf{Œó)WÞ?¬ãdTø$Úü¶ÙNyS8£7{¨MJ†öµ—lؤ7¯I]&žVKŽ‡Å¦My¯,W¤›&×ã¿òåׯó7‰áTU«ÞeT`…Ÿgˆ¤ìL™{·Ÿö äÝÁ)eej-Ó·¢*Láýli²Q”³çÛýþWJ™å)@T:H0–s”†·Ô#úäÜe6.ôádçPÐ/H¸âhTä¸:°Ì³ >dî‘fxBn&jbžp¥ŠÏüégy,UeÅ¡IÓ_¹¨Æ¤mÒ‹Ûßb Û.ÈÁ×®)UìTËáo$ë ïÄá2¶û¢”4úÜTí¿oè>™ößSÚûíÁL¨ä}ä›ÐZf«^\"6"EÛyª S¯×îÍ7ë‡Øò$ZaËÁö¶<iµ &Áyw>L“¾'4*erûêEiœ“)†_ì’luìˆó@úÂÞ„ó"¾ç‰8˳Ÿjlò¡½!®)47q¶‘¯;HzºPlUB©52 eßy\‹O Ȉƒa÷˜#ƒ“É¿‹ªú`PÔG[-Ú/žp! ^t3íË‘Ò‹0ÏìG¢¨0ÍF=°7[ÒîÄ—2T‡¾D]kýyÉZ;páD•ÜîÚ+C]Q"½×°{Ôóâým¨Š¦vº@3ôªxÜc-ÝP<ºù@ñ¿oUªfbû½Þ}Ü £xiªB#k'V™–kÓŽso Ôe'€Fn¾ʇÌ|˜1­˜Ë„¹üNû™8@k*o¦Nuõ»?_õM[Ñàù–~”¾æ‰ýyïfˆÑn¼£1÷ƒPwd½f*Óö©{ºIÓÎ$$cyÆ‹d`£_®*ö†Kµ¯Y¬·5y™:¹EÖ´nÁ†Ÿ4+«?ËÅ”X™‹pßkHÇ•*3¼O]NÙê§õ,4É™˜Ö@¼CJÚ0`=AËRQŸÀ¸ÙShÆ7 –NÚZgàô— Õåÿ,M»ÄAs3j§@¡(®ån|"(r“÷G!§„áËuG´†ºãIŒ>Úz3Nçãw \VùÞÛ€Bõ´Z[UŠKÜ?[ñŒ^nÓ½ÏeJìØÐ Q¨ßzÃ=ŒÎÕìåø]Äžÿ#0ö5Œ>¬‡S%öËþR£>µ~´8ë`;ú˜=X®ì‘Ž´æßUø²dô!ZžÜô`¬àò+ ïöOõÊëLrƒª™#½4ˆÍJûþôn³§ù{ZBúH`ô0ɯ–ÁãNwýìË8ýf¦Ìº«[§î D  àR^õz–±()„Wš«iÚþ‚¶•±•SÌ+xé|1Ñ4ÎLžÜÊÉT_ Êþ[Sª zhÞk:–A<}91Èa¤­¢m#ë/ûŠé¬ç'mxˆÒÁ³ÅÉ‹¥l9w<mìûW–-Q¬_q1|(ñ´R©‚ÙÕ^Wƒ³ÇêÏÒ²4=LTz02êOW(Sˆ4-ç¦vãôÆJ Ô-uûŠGWØw9¤Ä—Ù+ç½¢‘)Å'žÏp£é:ÝŠ +_ÀÚXg=†fµJNŽÓ±ÏCðuÖ[í¹0§.Wó¯Ÿø>[Œ×‹E¿t;ž›ÞHØKšg–ãKK–›c¯èïú@Y©ŸºdPLà <[¥Ùàe‰ÆɸȹôB{¸*nñØM”C­I^ŠÝ¼í©Ä7ÎgôïD(÷Ni6>&hrØA˜µÑ÷÷QäÝf•j/X?ÅY$~LbìuÛS*`µ“˜1¦-I Ù;;’.Ï™¯@½Ø¹°§Ú}ãÊgkihð$ïïÞ^šéÊ~ü_Ux¬p}exÖ›}šÅÜyx*fr›âîr˜¦º×—[gæ¥e1ÜHƒÔ sAêÀ¤(úüó,ñ$sØÈXû4(mÌÚ{Îe¼éÎAf­,åÏH3ñE¨}ê)Ä6b¤znR—–ŠùÙj6¡Îô½Õ×¾{i9)|íI EÚ-D0˜amGÊzýÍ­ Hi|K®#%{ÝÅ›–ñÿijT&”¾õü¡/°ð`Ò=$P–­f`tØ£±m{¸h•ïÇüdØÎEL¸Žìmå_Z(wQùSèb�NPžÎ¥¡GÃÅ�à�@¤ùç]¾µˆÒÒOô0¦š)Üt)ä6ë‡ØäªæǤ´MP$ݾmpßÿm$i“#‰`;\ò ±Ó…ˆ;'C××ÎýãÖ¢î5NvµšÎD°–Aë¤](oÖ³sÛãz;—ºå ¹è·xØøŽÒ›65û°•_d“ Nj Ã­›ôÄ^è®cû+;!XºË‡ØÞX­6žsÀ j ŒšB¡J0ýf ?Ô¾rÇ÷Oƒf�ĵקÏ«¶› M25Ú}xéîÃ8óü?¢,è¾à[­‡>ûȉÅëL·õ¥? §d^ïÚe¡Ïí§¤{Úež*8t¢.‡þh�$ª ÎÊ°Žá0~hJo¯€ºÎ|9ú¸«g§i&'¬!×Öfð Gêí ôµDòF[¡×Í^0½ìéš«½ÊsÏ•ÌkL²Á´ƒßîÕ ÖQÒÓ«„¦/ÌÍaˆ}+Q_~Ÿ—¿?\ +•nJÆAoTh"ò¯|,Ñ]ÐĶ3,Ãm[xé/Ú)VªIO¹1º©éŸ¬ÿ×ã}Ì]ÍÈ!… @½ÐcŸO*®o©¬qárÔ”y›”wåÍÞiœZµÓ®¢Íáºd¢{ѱØùg >¦ Ú¡ ’AK8Füâl õÔ íþ§H ~©_“Ø"!4y˜½¦_½W<Nçøù½îöêƺ•‘ÿßl³ i~Ü8ÙaIÂјÛÖ¬¸òcWTÙ82ÉÌ<ÐóŽ>•ŸˆP!·¾U¨â"bC·¯¾~Mh”Œ7Û< ’iï©ò\ê3–ä�’ʉ:Ö^ù”"×ò16 Ÿa D£µïÈ9ûÒN¿ØïcZ­I0Ï{Œ{~y”;õßâÌ€ééûrÀ|ýúÀ(ÊÝOa³/‚üSIÎ pîðÍÞdâ÷­û"ÎüR晾ӗµ¬@{—½{©”%K5ÝÌ&ó·¯7 6‰ ßaÎøœ§Ö©4sÐ9•?r¸=p;/•ZD™ÐôŽ¶šSyAÈ›œÍ°k“Ý�-óîÊVÁ7“B¾û¬ ÷½¯¿åÓ“¨ì/zû2¶=wgð÷X9-ªÂ5¾Y’¬öΉɲÙDÂó7d£Ø Û‹³_ÓWA8Ífä”Y˜ÆŠ‹oÔ–ôŸ»%nš{ÔØPÄ›)¨%'k_ØΤ?²¦ÓG‡¶½RŒÂœ0”BPÛG´§\bÉ^‘ˆ¡P^f7P¢ÞÍxh8g¼ ††ûi4 6ï,×0ã:bfâÖ5ÌNç‰=“ pii`$RêCˆðÕ1çîë Á«f€i‹äE€³‘vºÕ$úI‹Õ€’w|´½j[Mì¯Ù‡R½mj!ÅþȆJªl¥2è1ò¢‹'Òvýioè°†Þy]ìq:ÎP ’gçõ¶Vm.ëÓ–¥µ[ñ®™;½Ñ§â9Ó Õßšñ0݉ò¢£*[&nv!Ïbü‚j š¾²(­%JëIWŸÙ®’½­_\ß(ó9oˆÂSÉŸÞe£Ûz:j"v>ÍõõVqÅ-gÔW³§¥Y/ªLØ–Úþµ8n³£Be®x¶ï9<Œèñ»!ÎÿæibÅ>Ä7¡Z†VhùÞxŒ7ÔÞùD¡¥í‚{Ì´\円¾_¼Ã–§Zh‹0Þ fZC‡>Ãn¥�Å><Á|\{]€Xå õyH8œE "àá8[ž/W*«±Ù£ß£y»“=õ. ÚrÖ‚Oƒo;-jbò§GS>®¥·B™ó»Ò®”ãájJûß·*Þë&×\f’‘¹[ÿø ¤p#‹Š£=@½j®Þ¥Ç3lÝ‘øãd¤4r@fþÈžAlPcžÖ¡_`×îsŽ^z[p»²š”²As ·ÑI C$xÔ¯Œ³[mQ>zžÍÙ3[9uG>”]Mg:\Éßü¸ÞQºQIé&;XCM>[u×y’ùtŒŒ+5KýÏw. קA0* õá ŽA<yï¶Û‰n‚ Õ)ÑPÑ=^BV¸OË©äÜÑVŸí Ï°–0oº–ë>Ö“T,Š#ÇààÐ9Pí/Ýg@¶/™Üt2€ñîH3_@ Üü =çPsÐCàgÕÚ.·ù©Q3¥ {ûJ«JªÞoZT‘Ç ¹ƒ¹¹tPd´‚1 á3E,ºË£ùÆÁª%±¹ÿkŽë ;hõeU=çæ‰ë^ýïÆVi¡¡Èhu›øÊj@òÐa¶ ¨‘ÁÀK…Õ` u gw£¢›§_D&BdFaœ…(â“ÂSë£$GÃ…w›;ë~‘?çžD:óe¥¼ÓYE’àx>LJ­›ŽâþûÖ/¶xæ3« „6%A¾WÍã j:žDoÐXÿê l‘ˆ½¸cmçsY€·eƒ‰/Žÿá ÷ÚO*YèƒðÑÒIá¨u~òÇx®qÔ«V]ä,É<Þ-äÍ%²ÇÒOò±íÍØ׳ªë¿¢¢á5•ÙéÜì92ì‘›úæeÙÁáÀOÇ‘Ø\W­ñߦžÈ¯ð½§]¬³QÖ,â·ÞŠ„£Š*JÝ.v9S.'vXO¥i�sM ðTðI)òŸ Þ6Êç¢o6¡í.1žÖ²±£|Q‹ÍÓè2òtÕã;#nyy“® Ý nWþü,kv/ŒÂêÆýTXÑhW¦ (oÚéâ½ Å/›Þ¤¡?G “p˜(‘Z¦6}7ì»ÃQ¥ü0Å']ÑLÕûgè¾–è?pûæÑø<q�\Qx—ïÕiûŸ›Zà ßpr´ñ …ß~WKbÕW¨§d«œwžú÷ŽIA2†`D.ÓÃWÿï­>³JÀñh:v7Ï-uÏMbYg1[„€»ÙvTÓíϪÇ<×”aŒ `CFqóãrëq`g+_ô“œ9ßVôý<NÖnÂ8ó»ßÔ—þ®QKZe™g_¥õ‘RËH&ˈ`Šßd¥¢¹Þ"2ßE'>ë,…ƒ$0+²6§#ðÍâÈGôDg xÜÕ#—é8ÊãÌÏWg ý\Ìäì¢?ã•\çÞþM3þF<8\A¼ã`þ "ó4ûârÝàæÝûz[hž@ÍÐìÒ ,¬€õOx nÀxÒ-Ì<Èã|el„šýàôÝ„åo‰”îóÝ~/U2|QÓ­•¾´Ò¹§4Ü1ƒ>ü…·µFMÔSvD¾gÇNÚëãĤ«:WŒâÈÍK‡ãm}”þ~c9*ĶVm3v:un>eyù|/«4•›ö:m4`BÏÞ0té°±4ëp¯ÍE%±isµ/ %æn˜+ IÝ{ W=æµE¥ºÿ”#rÇþ‘§ƒzçFi¦¨b°jxªÍŽ,PqÐŒµºùé~ßÉÚóÆ_‹âEÆ⯑ö4Ú¼”64çyNþ$>$IèÃ(Ðj݉h½uS+¦ÊhFmZ6;†ö½»ÒOþí‘IõD‚Ï»³Oå‡ÂâªEfjìLî_®¬òØTã%Go‡òÕõŠßX:HŽ9šµ$ZìôŽ8ÜÕ¥\”à8såNH± ʶöº§®ó¼2ëyÿƒ×}d-S¬ºéqRædhÑŒ H,ê|÷ OìúÅÙjRÅ?NÝ‹wdÑn9âàƒßfV:÷~äöæ#l«E‹À°‹qŽÀØNWƒÞÐ*VÖyd‘:UvéÉÓ­ˆ¿4uÛ ?;QÜ—bâ`Ix¯q=âj­ Aë8¦-5›Œ¸êÝÈÓÌ�F(öÉÙ®d÷ÚXÆš#ÿ¥Sï &"zí¨¹ ý­:òN;ëõç0.Îœo!\h™‰aÎí5ԋܧÁ0d”ÏV+üR6 äœÜ¡=Žý±FÍŠðfó±`2 óA<çq<6pqï7œ^ëBQ:nW¯´–ç]d_­“ŠVÓ%‰E8®³‹ÊÏ»‰™§¦•ð(7u§]£\ç©¡¬J!<Ü ¦{V¹— å©“,Æ“¡0¸dítò`åøMw¾©y i§Ô+ïŒa´ñu¤8}W1$œ[—=E¡ ' +&·ÀŽ§ B£ºÿŠñ™­Ú�éðèÞ‚)YÁûrÀmp½Ëàµi)Ç?¤ÁG UÃÕÃìÆ# EÛVgÝ÷–Qo/ÑÓ=¤2>qÉjdéT;¾±­ìÕýõwRdQºž±„´)KíUO0ŽÂƒ‹¼¿s4R¹Ì(7bjMN¼ö äûÃÉ ƒ?ûÜW+õ »kZ×½CYíÎÝ4ÌÚë¸@¦fÖ—½T‚æŹ™(šÁä- ªýìT8U°£‡#9›’óÇdñš›còûA*êáÙc4Ùy¾öl¶‡Éîú­ï|äåº,À0Âb°Ÿt¨¾ýóØðÑZ¨Óñ€sfýrßn·X¹HE˜±´ê·­ç©@»*ÄÓ!œb| ,hÜgÄÆIåè[Ì ›Á·5}Ę¥µp†íë«9¿DÀ¶ºÌ‚Ëc÷LzK›FaÌ©ùÁΙ[¤åÙ-(+¡%wù×Yô­™™¬ÞªP ãZº‘^çŽséùÖ˜»pœÕ‘åÝuí`ÐŒõY¡`á¹5¤éÄcÅ]i—»ôºŽlõ=~ÅAyšt*®„S#>ŠÌí¹g£Þ¬rÒЛ§„ŒŽ¡sçÐ--^ƒá7f¬ÃùÆ�YezÈÚMóM·X „–Öe¨p\\…y#†èˆ±ºÃMןè®CÎ~ú~Û…¡æ ,Z>öðõ¬Íþ@"6²³sšaeóÂæ06•ŠÕ§w>ì¨Ê¬u… N™x2ŽjužÄšNf¡sùŽ1t'ª³¶q  >µdˆìUQ(ô•O®op­{b1¡`öw{«“ŸÕ+&ÓÂé¥ð§>›‘þ‹hS /�¢kàOöúÍl(9C+ˆÿþ(w-I@çš*F[¡ýÖË`»æ3T¨¯Ï¼ä£Ð×î¢}ËÆaíIÃnŒ¢|¡œÄ½ÂU ¸Ÿk÷[tzîª$ŒƒÓ$(jUÐ>>0Jbâ tÿ7:½¿­§Ü9¦æõKT/Q@®Ãcz ø{…{)µãf¬¦N8Ðz{{s]ÐÒ|‰n((¡µô3æs²›ŽËdùh…ƒ‹v|ŒY¥’K›S§ÖÅv0÷yP½O! ÁªG‰¶KoP$E+›sú´£hþük˜¹e>@Êf#­ê|ÙY©UC[4Y(rß z›|†n¥Hö茅Ôv¡"ä,»Zεu~0ªq8Cö8œ|íU_†•Û ÷“øÜcàJG°¢{xVò¾¨è™öZ­FAíÍX•WþÆ›z¤œÇÌWÚ™ÝÙp½€›éõç=En#‰a/ù!™ò}tK=ѯŠY¿ßJ'ÙŸào¨žü¼<Ä|I'/-BúüÕévgÎßPY­^4­ÅÇKîÓ4: ª,Êô”Â𥵮¬ÉÉ`¾[÷Æ4Å$:ï„6/§ºµúsQàªéÔIzM”Åš8!C<“)C(œâ‹0£‰jzyëŸüÁ3‹á\w¡lðü¯5ÒsŸ=ŽÆaч½¸/ÙX¬ºœ´3‡e„É»oéÍ:«ªÙ-j ,¥½@‘ž&šÝPŸßv\Œ®¢`ã¹u±øÊ ý¥â4» ÂAËè,§¶bo»zãÔª_ÚðÎD-'zœŸ©Õ‘I¥ÜR"®¸áqš·ÆUù‰âšÕ‚(Œ;Êí¿ž³àŸ‹Ó›Ùgê÷(5óÓÚ9ŠBO{)¯.Nƒ¨óœ©XÚZ$ÌdÅÞ𺠹ÛrÞÔèZxZ³Õ@©Cw¡?Ô,äü´~I×r݃ÔËW¹É¤…[ïªh*)iT&.Ì<þ‡ÆE®6D%j'…ŽTƒÌ³ýºD€_¤¦cÙ´�ó 'gTÅýUë"‚9 Òââ‡l/¾‹÷)¡8â0NËhw=ïÕœŠBç¸ÔçIÀ¾AQBê ð…»W Ò…çds˜—˜5"ä^qßœƒDóÐ¥´óé×õ"mŒRyOL_¯¬`Ý÷x=*æõ<5iø˜‹×ÚŠnåÅfåµ5Ýñ`q„ 3E)û®—!)?Vh/Ö£18% íà›þˆv›ì½Æ°{ìëÃçí‚ReHv˜§VŸW5-ÈŒ±R·xÐÝåÔ,ç´4 zµÇïŸ>a ‘õ=ìèÃ"G!7;Uºé¼k®·*ty¶Np#ãTpê<‹Ó-bi}cLñФ )ܘŽ9܈²¶ýAf·aêäT^O«Ú°ìÕ­š¿3m’y)«Ï²#° !e=R~»ä Ÿ—T #…"ÂIñ ¦ÅÃ�Zsâ»v’x/¼™ý'Òrâù¶ó_&%jE�W¥t=LìÙS1'fa 2Úï¤à£7*_¿Þu„.ÿÎBhÁšo~=±ºôƒ“Ý&#0Æâîì Ájo“Çü•0î0јºÝa^ÿPOçáÖcÄgÓp“…Õ¤"ë~x:`Ô:k"‘²>4ž!þä¤ÊÔW £¤)*RT̲D/•³Ÿ7'­Kéu™ç:·*6M­š/×ÄfŒk.ÅîõJ­<JêmÆ<ˆ!þñ3J’ªÖ7î€;T•eÿ7I³gŠa“Æ"ÔŸu*ͱ è8AãU•~‡1²ðp ÃT�ÏZMEQ,ú³Ü‹R n-P¤?„bAôK}]a, ØVmïAD¸kÄ#NŠà›!ÝX­ õÊÔºr¶èd9Mü;Ã¦Ç ñnmŸžf#CºƒùT³6¥Ù]Ø‚Ø\·ZëAÄr6nÚlÒÊãvÕ§ˆ üxdúúEè±À‚œOÝôϱ¶;ƒ¼ù7«ô[¥àÀ©è°0G†ÿ©‡µD ¥<–ÿŸÁ¥3>óÎýÝÀaëQ&÷T`{YQBêÊ¢(Z¨`¨qØÖ_¨óZoöÝÝõy]v:ßN�ÚÛY¹OÛó±¶R(�ZcÑÉÇ¡V_Wbè–™óÐÇ¡õœåÈÄÇý‹JøIq Hi»‚Ò8ëIÙ1ƒ$t@dÎ*Äͦ8œ¼ÿÓ'¡çuʡçܹaŒá‚ëî2¤çàúÖ�•¹?¸¡½¼ æq拹¡FMf¹ïoãpåÎœµ@¦;¿;l—`ÇRî7íô0…ø ÒöÉl·ék "Ì Bç°:†õף¨ Ê’¯HºâÓªþûæÿŽ¢AÿÊÿƒ¸ÔÄ…¬À‚Íjš¡UrCùÃ8Hq#EÕk³|ð&ÁœÕ ¢È‰8eP¥ï„ð+õ[y±6Ãѳ;Ç´§Þñ‡&̶­‚9øê«X>pz[‹TÑŠÙléÙ孒߀N¡ûèk<¢¬{ÔõÈ‹4,Í¢¬¶µ2Þ¶î¨&‡Økí!çf[mÊŒB˜6=ðù¦º·àÚ¹>Ôj5rg+méüäãÂ3EPuK>ßí°%‹‡aã”%íý'-3_J—–ͱË8y±AH,CùQ¢ç„÷ùY€zâdÄ)ߥeb—:2›MĢ䎯ÁÁâøïxnÆÌb'�‡FAa‘óœêŸÞœi<Â?qAì2ƒ³Uœ¯œ:þ/§GCË<ï5$VXø¬H#œ*Þ§î3 s¿;ÞYC‚Ä[/µ¬=€¢PÓ!!Bš™n0ür` …êÕýÀú¹ß<KC‘‰C£¼ iPmß½öVKÁñú_Š9 ævÆ÷D ·ö3·?›gf ˜ýÒ) ¢Åî7Q%ÝX’WßXÚÊv|•°F¶Ãm0¹Ë_Dpû?ÅŽË•!…¥¾ƒ“Ä»–…Dn[ÌŒ18†HÊ30^5Š´ãA1±*®2;OEÙAˆ|Ž4"7Fm‚ÎËõÛÏ?2OCYæ\B:¶}É3\r9]þ×HÇ©ÇsÍM7€BäN—Ü~äžÿ±»Ì¾A7fòs眦óŽ²M= ˜¨ÓÝ›ï™ý©Ç`id¦˜6¾Ûé,Á çsPiâ«?LYAÀ ²dÃME9ìb*º›Þ“ÚÛLõv™=T2›ÆÑ{#‰Ã‚Ó¯†;4L¿&.ð­¶W*%·;e} ƒ› æä×Nã™ nûîŸí•räoJ“Ѳܷ׆peŸs5æ¨ÈZÐkÌ<Q®ÄX3üÇ¿€Œ@žy<pLèbh!œ<Ó¾Í4^­ƒ0¯!þ>/›"Ú1qèéÕQÀañü󢱜P:yŒÒR¢òhVrú‚ƒ“IÀª˜€/Ö26 ÉÑB°)e>äð½?oŒsO»•Û¬5ÀR_j_¶Ë•?…PA Š‡8ýcZŽ¹úÆÎ.üõ ކγAÓ8^d‚eò–"±yè8þÛaÞkzvÖ…Õócò‰N`ü–žWj”#´$Q°léK ÿ*),W'Ó7†éÕS›*WÖ¹LE%}ñDS³O%GÛ—ðZ›õ7& hŸwúàâ‘7'£ÜæŽW$ï2q0QÉæ%r1å²g©”²NãbK‰Î À{®6-¤ÔÀ=–»¿¤T,ö´jK4æzCg[ÖeÃë ,_Ó‡<Ó*Ÿ¤½cþÃ#lªí”ˆ.(MYPÚdÉ;˜ +ýç— iäY¶³_Ç|IƒâsPæoÚ׺ÈÌD0M)cZj Ó¿XÓ½NR™ûš»”@Ó"ñXÞLÿGŠq¼r½)¦oÔ™&ÁËk®ÿ(‚™¤IÈÆ‚GçN—½ºSr=ÈrÓ‚ QåІ`²÷#ï>TDÙ‹!¿õ!ZÑHX¯?§žžutÃ2ƒ’&‰÷¯ï¿#,bÜ$A1ïµ­šŠ7ô¢¬/.¯Ö/ßîJ ôœæÙþÓ“‘ØÖßxƒŸÚ-~=_ŸŸÝ¥Ws j8Ña”ZKnôà?„iaTȯñ¾LA×4¼:wàïÂX75FŒó—ƒÚŠ˜™èÓ³³¬]Gß½¿{³jeÝu³*È÷½Gëÿí§š=TnÄ|_FÉÅåŠË ë 9ãê\¾Ìph>(jÛAœg5… dn>&¬,9nöˆ›,ŒHw>%ô¼'%x©‘ÄUÒ–¢ º|0Ø{åߨ*ó=§o—¡óFû!ú,f¤n z…ÜŸß8Á&:^ÐÆ"U÷n[ÛVK’ËÑ•x¶^I²~G[Û3âbÕ®¹tùÕzâÿÖþd»q&ÙDÇȧÐèÞÉÉZè›!H€% �0(ƺïÿ׶™›»ƒDEVý«‚¾< ¸›[³› }rÈ– VTî¸C¬Tqd�'Ì(ßwnœf]ILwh©O}ËOíEÁŒØ“ÖÌ9%g{AÙYT«¢©3Z§mÝ›tòû;‹}]îšQXÜéL"w =ãV¨(ß°3í|N„`hÛÃ&ËŠ7£cD…›¬ä8Œ²ê= 89ó#fNREéÂÊcĵÙÊO^Ý€ñÿÞbÐ3T‹‰o?ËOŠç(t÷M´Z©Š¥x±ñªÿÆ]j¡¥o7[]¼˜¡PT±º3lIö^ÆÈ-{à9“#—¤JnéhKJጊ\±:¨—W½Ø_U²YQØ#™ÙØÛ š Ä't‘;o·À‡Ž2×%'rÏÛŒóH}Õ]½1sØ@‡Ê¨ŸN3ü¤|tÔ£IEå«… 0×ô¾Qã¹/ÅjŠdn´Bá erG»»4ÉêÍÏfpn»{ ‰¶UZcØüˆ C½|5J«n÷”¥îÍQ…ô; QIªMa>^ ëž e(XXY®ÇÛÛƒã-ËW´oÈ<\JÊ„NÃYaÀT³È «òÿ˃ ù7¸õ`KNø뜴ŠÄŽ¢ÌžKUŠWrÚ‰¬;ˆÒÒæìáO÷KKn[\DÇœû-#kî.î�r ¥~CoGɤ!‹€4É3Séß©¾AT­°=(ÅLû/à„2Ê{m±Çëô×ú\ŽgtEæoÐì©žˆ+ûP 5œèíòZïÊݧZø¥‘pÁ›z™†ÒV>±sÖq8lÈ'_ÿ„Ú>wE“ò¥a`ç¢Ô˜®k·åÇvAæ<äÄéeÓ ?yRžYʘ~’ŽýåúѾrÇíàÄ>ÍŽ²°Õ[žæµ€šš^ÇããáþªSù UtëRíL 6š˜Í8†¼mãÐÙ°˜8½ I¼ìœ"&#/ΠWà`í?D: c®*íbW•mRHì9~”A´QåŠhÛÍÙM¢xl,“ÌßUBÜh(­› Z›ÙQ œ«žQ=™!5e7¥Mˆƒ2Å^<ÀE¡Ôq#j"Ñ»…¾U´êØASÆd{þFQ$Šµ\»+åôLŸ2ƒZQa*וæ#ÚD,ù÷è*rw¨4“yIƒÜúس#Uþ¡vVp§"ÃSñïôÎÈȈ@B·jm&‚š‚úÖ”ßHáZ°šqíg0ŠöU³ÜÂrä6´_-›pÈ‹í/‡«AY"’UõFÏ¡þ²˜ð[Â[Uý E8y¹¤AÆw 2ùÍn’Óñãy`Á–û‹k#5Ù“°„hõ5”ˆ„/õÜ×W¯â°C·ûbˆ”sób[á{>o†>Ö–„í‘â_8Ù†¨Ly68.§Ãø´Û#,Ëo 9‡’Í2u ýÁ„Œà›Yz‡þß‹Þ†²5d jªÈêÀG™z’³ß½Yp;Úz[(Ï8œ|Y F’» ¡UÚ›¿¶ ª½ bØDtgýqóO.˜‚Z»Nð{”qZCCåúƒJØe<›ñ—!øýÌó‹ŠÌo@Ѳ¸°#ñÕ‘ï)µ¶³5s/Ì$觉*Œ›,§¢‡ qáFÍUÙÚ"ŒÎå Òñþ¿7wæ ÌXµ¸éi çó_³]h}ïiB”Œ¦‘µ¢hâ»ÎüèèT&>ÐÂ\#-|ƒyZË´"¢üxY%BX±øä&’Ͻ#&øœ&´·Œl•Òžå½Ã–õÍ+ˆÚ‰J„øªÕMÆ ©B¹g=ðZ@îâ[]“¸pÊiÂqARMŸ^€ñ ˆrtlA6“8£WjƒÂ“P÷Ö‚6W¯Â²Æ:ººTÓüðÒÑ%©pµ zÎWm2÷S-*Æ‘R¶#ë+ÜŠçÞ- ©EAÓ ‹åAÒ-·Fr˜¾uõßVØK݉²¹7köQXU7ïò±À[™›üÓ~è!c+{Ž ‚˜FÛ+†‹©Š¾ˆ/{:Žs«!‰²ŸDeS _c\T½ËŸÅŽhE™¥§Ü§aPœ¯Æ 6fžqR2>ý´ÑðyQëÜú0KÉBäPÃœl'’Ùô×Fõqší¸èËO¶2Iâ@ Ü' ^£“m=f©Ù«Ú»G»™tâõ®Ù ¼†Aªc †ˆÂÇ“'¼?¾0‰ŒS×PFn“{PTë‹ÉÔ÷‡=�é8þ?•_!)u,Al™ÆsóKeÕ8É|°YLGËð¾Ã þlM-bu6É7OÙ°¹:³'Kö“@µ.$Ó>÷ÔWbè(£$³Èõ\zöê£Àx¥Æ%lÉ« ìO&šÎ§‰É é]+Ðrß3Œ·¥#ã]Ý·q}ÃéNàˆÎÛwËì±ñ’–v«ß{~ÒN’0‹u�É„P¡ó¹öÁÖ<ضÿšZÈI�¡›5AUsÑJ.€<Æo>䜢áAúÖªãYoÞ•ÊÒ8Ñø‡´Sc·6f-ºÁæ‹�Ë5Ù•B/Óå5La«ÀQéÝO�R?ÓM·Õ¼ˆ$ˆS‹Òý¢>hEÑçœ=òï“g‘Qœö¢#hüJª Ý×ôÇ'ô¡ç±¹™Ès"9ŒÓÁ)B"æÊr†ž±:˜ue}¥3dÜf“ÊýZ,‹ãl%m~V:«– ò#ä_,Ñ"ò¿Cº¦Q¤V‚ó€òwØ\üžvO÷ÀKþ´ ¾“ú3Hgû¤&ôåysugï<‰ù+SÔg±rd>´Zvº§ Çu¶&`bwi| iØØ‹g]–(óÒE (PR6}:;Ç´-{Ç•Cö~paš-± «G©‘¡fããl¾8y¤™>1öžë<‘j—]j,#É@+aµi†œõõ 3tO¡æõ Vât3dŠ œ ÔÝiK183h(Y[fÃøõz¢ªò¦ �Õ”+Å'ë®Å¹ìk©ðyå¿a™[)£05Ù&sz’^a—ÃàÁÔ)ŒêÇz¢{äNÂu—û;¾OT8S ù“K¨¿Ùù~¢ô'3�k`þ}nN—+κMiX2x‹ôãJsæû6“»òÔ2C‹Ú< ª÷Þ•C;8OéJDŠ'±êt{‡ÁµYU,Ú ‘ðçÊ}ç¦1;„q(Ôt³õ0ÚÁhý·*¹d=ÅÀ¸g¨‚¬¾ºlY à=nfçŸh3ÐÉ`^hO\ {H¡Ìy¬JPOôÙyÐ[utøÛš¶ì®Ã*’’ô¿ªÉ—Æ+ÇçXÂbѵ‘B› Î#h7‡o¤KÈ؇ÔìÊÒùä™=Úì®TEñ? :g¨©vò,ô-](s9`äoT$ïh€4­jm¿«¯ìÒq˜y¡ÐŽ®‡µÍ äXc4 ÒNû‰Q‰ÀN%ërXÎlæÂÍþfc·¦c±öv“…7uD­µéÁýx©¹ÍT&£ô矒­£ÂSbuØ·yîÎŽbtºo½§0½ŸÆÍÕ$Ó¦b¬—ƒ›ÑÄ—»Y–Ud'zÊ->Ňә$Rw¾ŒÄJ+[#È" ïk°¥!ê¯ys«\Å`0^<?a³ Šy;…Az¾ØùuÌ×ზ‡„GÊÞ½>Ÿ)Ʊ‘ èÎi/ú\+L†V¬R„ÿË(>Ê2ç ÊV›‚ŽßåË „xC¼ŠÊò†Ügyßÿ@¸õ•Z˜7<€^rÚy§AǤ{7àþ…¿cl%άÏ}³dãùÍõíÜT „·I½ÿ ϹíIêËˉïWÌ¢&f–ã˜9µƒÝ-B#»ÿ³þ4º5G:½,51c`½‡É‚~š©•aìyx@†£‰Ê Þ5&ÿQ#vIIW@�ï?0v#OSÆ…ÈÇTÝâÍJDåÙÔ½¢s£S…¾ðgwƒry�¬¤g·Çi¦ÃàÔZ¿óõБ"/Ò"³R%tê¶_IÉ’ƒ:8æøƒ©ÁXt³gzx{éã“t¥àJy¹@8¸V|eªr°o6ÇÍ“S6n:a–me¹CXŠtÖD©Ègí)ÓÒw¿ZACýݾÞ÷Žl".š½ÀƒÂØËæé6ÿT¢]ÍTïQÈ5/Ï0¡nÈ.ßv„]`ó×ã)§Ø㸵ôdò §3#¸ÆaO[o7{à ¬Y'èß¼K Žßÿ ¨o^ϾŠÇ¶°Jö‚õòÙ@ˆ ÀââÑ]!xÕõ‹±²r”`wMEÑw¯uŨÕ[äaÓ¾µÈì»NV´0{H ÜåLU¸ÂâÆìó~n”’[òzÂÊQ†Õêûòû.W¹Dì î–[kÊ]Èvß׳»ïøH�µ¸µ°KÕ- :ˆ?ÖôÐëÉs²Æ ¼=¨nùål”ä•:౯`°ÝPÛütJæ pWŸu™˜ð‹1¶§´þw¾¶I;¢£rß:ãñˆ«EË]00°ãv´L~ï]ú­,Ñ ÌEM¢¼ÛAŸãÊ»AâŸf:X¯¾œ„w¹¶çµ² Ç h°“J,ÓzžƒVTT~>ŠŠ¤4µÚf—ý]{ˆé¾+’½ƒŒT êG‘„4vç%W?UÚF±XrR`Ÿ¯�`O;ì˜N:fªù§<¨èv ^íúV]=¯ö™•¡¸Jð.×S“è?Iæî sïç+”+σùÌlÏ®ìN1 ´š‚þ¥¹Os£,µºoáÙÐÖÉç/Ø¢f©÷£Ëºþçˆ`]iÃÔàrº¯”Endkõã…n2sVŒª�³žµ®úY/"¯< fCn1(-δÌ#ÐUØE§Oy3ñltô¯ìúòГ²QüÓÛÇuçÍý©†õ˜ˆ\šè+} ö8¿�¯|ó‹>g†]–˜ú5ž*ZQÝï^u¯I×”;Lú€”ÛìL¯-oWîZr– Œôx²î [¶Þ1 Z¼Ñ¹ç »9OrT&É*C)-ãø¼wV<tªµ\]9Ûì$‡ýþ)”+hwlÿĜΚLÉêÐj»ë~ÖîˆÒÊ÷óAú£ Ò¶vz«=ÜhIú¾æfü¨o¬C}A!nv{Àsþ:%Ê¿´_Î3î:çß\è‘B5õt8I³å©(~zÛìéÞ¦FtF†aû©¾:Æ1† úòpîœ;ުݛ!M‚ܾÔ×ô¤-y‘ÒS Áþ»¹rš†ÿvÓÜŠÓ*ószÞtŠI» 1Ôêÿ0sØh¹°´,°RÚþ‹¢ˆcH 4*åþHÒ[ùÌDTã:)w¾o‹¨/¸‘^-Á "ë )Ndí<ÝG …( ¼ÚÓîêvÄ勉›ƒ~%¥~€Â'œÚÞ«îÀG¿»ŸÆW«Vxel˜&í/ë,”eÍo”ËSøýÆ‹KýhÈF> :†wEÛ¸Uÿ8Ýð†Ÿ@k´‹ñ 8ô Êñº©baÝ?<®àÙ27»Ž ­GB‰ªárå{Þ®LJÚÕ±tç­ÐEf:bcëuѲaàé™1¦¯x©%ÑŠç1§®ì¯^Í·=[j†¡ÿÀ©‹Š›.CÓÓ™ö³çS,î‚}[ÛC»;‹¢Ä–9ÙX Vb^u¦Ÿ„ÝÓk‹ýÚÞ¿Å÷”±«ûÀ1dCçÆ Bôu­Å<74( UmÝ[ãsÿ Uê=ÓíìÌ·­±yåy Èûûký3cä´©S.í"›ŒšÚŸÛ„¦!‰-‡ÑŒ9Ö?Þ#þÔKC‚5}…~.è¤W×ù ”¡ao&ôÂ8¾Xù\bì±ORN‹ý†À¼ çÅR}蜶7Ú·²µŸ=ÊijEÅ’Q ¤fÖ%Îôùðõ†¡¿kØþmYsÞÛñ™‚Ge'œòž-;XêFKÛÞ2FÖÒ›‰ w•¸ïÂpJït\³—äv9¬EŒß~ìÎ&:7YH‚9ÝæîÝdè @eœ.yˆìÑidÏ9ÆOVÆ»×Z@Ú¶T²Îxšã$iˆ¼® )òÐN¢7;ÒR wV­ Ïv’…&ï7 { UëqØcÀã”Îs3vÃY9]ÿ¡Ýâ¾Flôßà|‘/j˜± â—„&k ‡†ý‚ùERÞÒ§·,ºëU›Þ€™ËKnÑa�ÿQƒQ‘ç¬,êí “º„~BTÚI_aÔP¯#müèÚ8ýbÃtãL¢;ï9÷ûg=f« …¿ †6kÆ\q3_¿0v¨é|PöyÄÝûN¶ÔõÕÔ³©+æ [uë–vÜèà´ã_ÞõbÂÄ`+…ÿìs6ë6cXáHïÊ”Dç^èãÿÐÙ+}¯î0‘¹qÙ¶^øçTH@Knl쮞«D9àШOœFʼ,_–j´<Ù5YFQ 7;xñlâ¹Ç4-³_r”q?[ÜbX‰Þ.´)– ÄÊ“³‹§,À$*éµÔ¦û¾_ç'¿E9¿²^eSsòxhu¿L�ü)@îwµS\xø©”{Æ;V´pJ'‚ßjçþSJ{‹c þhÏuÊžÆÀöžŒQû]û< ãÌsÔÁA\Q’æ4?èæ+­ìE4gæuÉh·ýè§&~³ý6L<–•sÕCœOõíFHúVPÚŤÄ8/] xPušÀåvf“>úëñˆwœì^°—ñ9¥RÎ{‚eWÅûä€ }Ýp[28LNÆõ ¦'õð#"ëÆÌÒ¡öF† 0UT1sJýÌ ­7«µ eoÒ 0Ù5å8€,Ô×~œ<=Zut4l8k?7м“Gø¼ït¤ÓŸç×këµhÏ' ;Ã¥ßؾ®)%&;äi³8K.öÜF„¡ò½Å)‡>¨œ`”¶êÈ姟Q@d• Hœ{°íÞ=&7 6ª=–€õœ…%ž¨D)á…‚æ{c;nl„ ª¢Í”i[ªÿ²^KÞHqÌ<Ÿë­Md%”Ð8tÂf¯ §,6¬0ÀF6qÞëÃ.À¿šå¿êÞœ”ž—RÌñk(èŽëLS/ ‡·‰•ù 0¶ðÿ]›\¤™×ªâqñ Š¼ÿë“éfÊ8GgÉT‹î7ÕpäÁš¸[~šhM$g…­E w¨@ŒdH£Ù¶ÂÃÐ×çîkEèHV].‚ÒFsnÌNN“ns šMÇôElj87í–ÅX´s£ÁÝ€ÎcÈÓx‘»¿7H,Lˆ+�ú",R5ŸNræÔâ?éú›ßCJól-òÚ eY')lÛñÌŒ'ß*ƒr±q0–»z€~ o-R¸+™%Ç2¬av‘ÑÓ>±U|kk¹0²6éˆÞÌ°œ~\ÿðtTaasXüçû;zAR8¤ŠQݹb~÷'Õ×iÑ´ÏÏ ØŸ_zÛ,ÊVZd”wéý'Ý#¦'HlvlÄbÔ (uØCßÃ3¡x¢ÅÙ– ÷ŸbedÞ´Û …Åÿ½eÝò�Ó׶ÿ•ŸOVyu{‰­Í¶ÈáIÉgxædzgKgZ(´Èø¸_?æ[Å•{–B›°‘y4§> ò“n«Ú3íêj¹�ªgø+éÃ,±ù�öbI!&ïN`iñ‘ò[–GÆÜmQÅëÅ aŠÃ·°ÿù0^èðÓÎi îòráiÒóai^Ø#Ù›!ɨâo-‘¿`ÞXþj Ç.ÏçÕµ7º[užýžG‰¥•) YIº§ønïw…è¡^›ÊÙ欔ReÿÈËgØÐÅ/i—MûBÛ³'Ñ ‘áå¯êp 4ûö DP‡ç•÷¾4I|ª¡DÁÈÄ*‹ÞûbÈ# V>?À»‘£é}‹kÀ]wË«0‘ýGÙb«ÕýžPcøã°|¯h´Ç‘CàÆ£ÉLwÆÊaFÃÌi ó ø5õ6%­ˆðà»=¥¥ÉiöòëöH_þLáB*Žm»CÏó2!Kÿâ;}óŠ´ðYiTÒ ­÷ž½ò \g{1T‘5sRDEé². çú`t¾Y°DNÏSXY5¬¶öcÀ|F{Ç‘Î 9¥ŠW%¤eîú‰3y†g6ÌÝUka#�sžD s·#æ<`wâ«Fÿ·¤=N<'Az¿’„ò™‹÷×$X_FËí½ ½Î|¤/¯óÿœÙh¦BqɸùAK?•Cu9“¤}FÙHª¯Ÿ­¥pýì ›‡«æoÄH˜Ø0Ë@àí’pš¯vX cÞƒ|úµJTÝ*³¾(œÃ ²õNÊ“Á1Þ±oY:GïþÝ/~~\®Zƒ»™v{´Ó^e}žÆ©öP¹TÑ]¼ô­•ÈËáؾq´D2÷TJ§Ìüj9¸d‹çŽ±¥Zd­bÇoZÇ~cº‘ºƒñioÝWBˆF‹ÊÈ쎿º¡½u èJe•E:7ÔôqCÄÔ7îÿUY=)FK‡Q�Fëþ[üje!Î C Ùz½ùE*5õUo¶i˨Ôö÷¢'ÿ€£éÒ(‰VA;¤A¹œ¬wÕ�…(éóg¼¸ä†Ù錼á—ý¨•´KÄh¢ >«ÑJEõ–rFå¾#éCôP™›™Rò8Aº­îUïGÄq@bÇð©mø¾»×šÚÂp´5Ía=¡ áŽ_ve׳§mÍË‚g ÀÞµ»©Þ‚\úÑJæ R{ÕÑ›´Þ­`jÁVSO<ï@IByÀŒN>—Gí4*gÄÖ9Šm¨Yìæ°µ=æ£ PúûsK+àF&÷».‚z¬[äÑØc®Þ¸L”KµZXÏ=¾ä+n3‰:l`WãÍR=Õ…M?~ñ4Öz#?ñH.+W²¢K²¥µgwËãù0ñÌF›VáÑÕ ›¥^7í3Û/ZÕÎerut°dºYÑËÁìF{AŸ÷¿[ï&I§Ò`“–A1t^Â?WÖcƒ««Œ'tôdDwöeù2Ï®‰²ä~@Áw΋Ç=ÖP‚ç´<м»Ëë6ÿ=³M†^\zã¯79T ¿œHõ|bÿ⟴RÊÒuฎÜÌÀìXüLĪ~ÎÓɼì7•´XÍFèÓOIPX­``)ûÃßCSõìÝ}tåQßéÿ³0&z¤GŠ`fšû.N|ÝÕÅLñx2–HB_‡žâe§Îª¶Áå‘ÁdÇPGaˆÔ7îvQ¼¢B \Af¥2掔·•çúÌ8µ )'³(h#14ÒÙþÅa™y.Û`À^huœöß!ä×,hwBßØ€÷–ì÷tjyMZF«©VNíÅC| ÊŽöþÒg1ï†Ò~¯Ý€17æäÛŽ2,�Øm{o{ž(K5;ó̽‰Ëašê^_V$®ÖÝÓبSŸ´TFºÐ‹‰ïÇåÂÔigÞ»ÓÍ Cž Ú¶æ>˜ýö1Î@ 8xþÒ7¥s@šïŸ-©OQd¨å}Z«Ò‡jvxG*BÁ‚Uò¤ ½Öž‘¦]=K»BØø7}©(®üíŽî ÏÀZ#”˜ÚƒÚ æ­¾¾>«( òöËosýw¼^¬ÇfÄ"ì‘ÎEŠ¶ìy6){ÍpÁW”<Ro•¦ìÜ¡"Ô=Y€í‘ž¼(a8?‹f×j³™G7“nM©â§v‰K ˜»sÏ£‰ÅÈëVøWÏúFž‡Ø Ò{gÇA µ0X;)½ïÑH‘ç«[©úû‰Žëâº7Pá­y$Iºw;zs`+kïºñÑõõ¾uçèëÒW€7€vµµ[ÉѪ—&‹àýÛA"³ÈjëC#hDweYžæ³``ç*(›‹ùÓÜôüvéêiT!íãÓr,ûø„U…¾Ý"†T¹ÀÏ¡öü¡”oU'úî ÛðK–Hˆ©žº`‰Eéµ÷9õ@ù(³“â€É5žÃ×<ýeY™ªÿòÄ(±G…k¦®)FÒËÑÈ_¾$*“xCBágͱ‹jã'¥2Ze'{YpL%ëÄ)îr;Сj¥Ø!g‚ÎëF¡Âvxþœ°‘zˆh¢ûžîù2{-}à[,óó ÷ZmWòñ¥'˜î ™¬ôE«o°Æ±‘i«{LYÓFyôâ‘zŒ¼caX2Ç"(ê¿NÌ´9|ŒœùRÃÓãåwb¦IìµLBøùÕ¼S[O´pYÖÀ‹ëú”W`sk¡ÚŒ+šŸ =/ÉÌpêඥݤDí©fÉFË>N FQb‘äÛJ1ÿ´øm+ ƒëgA>Ø©N`Ô åûÑÊ2¢îê_δ¨tœö¦†lDP¼»ñ8ð8`¾Ìâ.›þ¤Ï* ²¶Óò™Q©¥°Š 0Dó˜­ ÆáK y]Æ ž æ6m¸ÌCÎe�i£Q¥yîp›]�Þ^fôŽÿÄܬÍͱþ˜½+Ó:ù0®tÞ|AÙO^؈^Iêܵ�j@±úé;&PœU™Óƒ£p×êdYam»›ôÅ×ú­w2®ÕJ£9‰: Ê‹Äs¢�ù^åW=|qÊxAªùxÒ¢i°i̧Tjf3Z»þ”`AœM+Ó`­‹L¼ûF³Ó!PrÆ>•tÑ€³z VËI|Š(´W½ët(‹†Dyyç.ž„>Â0Ê…U”ýU‡ô“¬)&ÝaûÁ$Ü̅犂‰Ò° ó.Äͼšg÷ÆRÍšÁ2bûø²ß‚µn’±&À€´›&H›ñ‚NŸ'²s÷˜åµZ”ÃîItŒÏy0°SiDãÏÛ 0ÉWoMmÐaêWB­¾¤Iè óv[q¿ØÎP ãFÜLÅû’ÐQ¹¡¸ÈÈ° õÅ“9*¡Yÿ¤]bÓ £UÃ¥ ÂOíã�6´´—–ŒCCYã<«û4( ×^¥-LÏ5q` yß®]H©ê×Ê!CÞk2b}¤Ìy~äo S²ÄðÛ6ÐÕ)m_.æŽQßóAL»¦Þ¶« ?BÞ8!ÑÐÌögJ 2븅®;ÜU„–RÿýÜA[’ÏQ+<§‡jûù0”ê§Ìæ",=Í@òÕ'ÄÔ§Uïá‰ÿ W¹pË™ÕÐóҵГV‚›J¤°8;(Ïí4Õõ›(nÙø‘Lƒeé¨ÌÖ´§ `Ò0Ën6“[DIH¯PÕ_4SuÝ+„pä¢|‰º nO&ï€2 Áµ©…"`9)JžU7ñ÷öÎqµ4ô˜M•ù{o¸ÄÀ[Îohï‹$$ûí€ÑÎJ»SÀo�Jw7 &¯Ô‹d$SþƒX'éi¨Í•abÅ3zEåÙ†0œõÚ¸‡¸E …/§œl4Û˜9ÿ Üéº3|>¡]õAÇÈF‡¬�ý±1Öb¯õtbVŽ¼*®3Š7Û#x°»Ú°`³"0ó".×y‚´§ëOð‹¢.íh0táoñ\$q­ “ZtëfnL-æ¾0‰zhf Y'§~¤™mÄ’Éšw° C¥ü¶9Ï€GÊøµé#<i‹œ;xe Ö.ôÿWmcDTÝÍ6”P¹_¯0’ôñ¾Çƒa‡ïÎýÙ±Ad ÂMjJ¼×'®5\r† ÈØÔ -’¦6_{ñh:z`ÿTLGÓ 7‚1k¢B;Æ ÄVŒ'n éÿä|Õsäi’â]Á|¹tFé›´>á•Wñ­M$¯¡ý}1n.©Á‡ÏW@ä'~‹»ô1ŒHq6‚°0çÅjÒg.ùAô ZþЯÊJobò× í‚/o=„«aCÅy/RoæÂ$~§ñ0¸=”•^¥^pò•‰gQ/$þ‘nÃ7FãUî¿;NÿM$ï;¯MŸDÓã|ú­-êãßús5ùÚV9Ïln pZèèVò�ȸåý(^[Ví†Ó zji}qÓ00H}C‡7­Îæ»NZîø‰8gé!t6|ZÆ´c&)‹ä•­L’ÔÌ"¢ÜÈõt'JsÂNÙpl\èóŽZ¡Ã×^@weÜïú‹ÎŠ=4ês‹ŒìÓ#²ëåÍìõ©@ Z:·YÇÜçAlmö8aÓ3AqZL0êÆþÊ'î/kÃz‰Bñ8€ÁO¿ö,Óêx„Ãë×ÆÃaôøÛžš‹qK¶¯wO·ò4yBÑfAaõö(T j¢C¨R@fN÷ú<ÏÂê"à7Én6mêÓH µ<ƒÿC …óˆ:Oô›7 ± ãQ¼×±À¹‘§È$]eÚÐM$_ÞT•ÉÆ‚^2OJ]‰\Ù^á—•OgË.Œ˜òï›…q^ù–~!³id]ï)•¨y«4ÃÏ=TQqOŒÓ0O±W®Ã«|= Î�þ(ƒªÙ›c.sˆ"N}µÂß¿UV.Jo.•°K|M)Ô2xc)ºM"‡0îv5Õ‡Å0ƒwÓH•—«©aùQ°1§E?>û/–e¯ªt—™Vt8÷^0áí¸~Æ,�8ô-ã ~¼ÄÙêT‰™"ºÉ“ =©²_WkLZõD1�ñ Ïü¿q$¸«æÜ`¹Ü)‘hf‡F­ë )Òäóâä™»ú2;Õ€y[Ojë_ßfì‘;,2曵]ÐZæÎË[¯Ô§�£ÔÃ2³'9Ðpece^bõô<¶K«£‡À¥Y扤Q<¼pÅ1)ª3¡HpÚÔ4÷*@/‡zŽ r­±! (•à»Cò§%w«‡û¤ÕãëB$‚ ϽÞ;«îƒ“y™àI*눖”½—«ÛŸ¥y°’¡¼¥¬Òlí~Ø—>rc¥SkAӣРäôºùñ»nbê" ˆ6åTÅûÉÖå,cÀK`Ãç’„i?ç—܉"»Ùó¨óf0r)ôRlÝg‘§¾ýJXd`¾0·ËÝ°+¡£ÿ `ýÖÔZ‹ó™$ç*¿ÍPàv5¥Ñ—άã"0ªM—ÖâG0zaüßsq×ïa†q]zþ¥Ô�,Pe1þ'Þí†&Óì¹B9=hñ<÷TÔ²Èõ¸iÜ·iPöwȲ5²ÑÏÐe‰ÇÚh:+w çÙÀÓ¡;)à¸HmCM„'À¶³ý§i)àÆ ¬wæüØÔ¼+Ð7þ¯Ð­Í{À[¸L¥öP‡à ÚäïÚfàbõÊ}—@Bî FÝaAOä›8»&-£ŠÍƒ¦£o0}™ï‘!q£oÁS@C/>LJ‹f"xoÓߘëD~¶æ2´5l† Ça®ëíl%ÿ>Œ}¿uÉ$.€Ù~ZÇÇœMš­7Ü\‡Ç£,µû¥›„> ¢…¸äÉ“€ôŒx¤òüÚ¯(Ñ¥ÿ²<DLå€ñ‚(‚älÍK êÖk< f’µcyÍ~ NWF˜EŒÚxÚ'‰+Çó�اñƒ\k‚´—Ãü°%¥¹/pJø¼ÁÀL™\U(*M°vFôô¼k–ÁXýЉécM“d¥–M•;È$Öä ì…}kÅcn!*®lß p˜oÆ.ŒóíHÊ Á0â.—ƒmloµŸ,Kæ5Ô T+ '—5‰€*› Óö½Ìè½DqÌ3ÿ4€… |±×X?¬ «r§þþoûuà{Q=²*O…é^¦,HæÁ7sÛŸîàþy2'lkÄ‹~-ÑZGU&Îvòò|æKÚSeÜ\iÕ¤–=Dë<a¤µ¹…Íý¤íðË•r{SÑÝC"ÓзWáž?i5\HXf¦îŽ–'PÏ¢n—\wÍ7N·íJ–?*J‡›M�H.y-šÝo9\ÒÆD~0FµNÙ%ä‘%¶>b*z/—:‰-¶ï[ ‡ÖCüø&}F||3ªÁzä|Û ¤ ÈçõPü9µ%$m9ô§…IÀ²rôŸé£ê[cø+!â 4ÇU÷¥Q c¾|i“Ù2Ô€×öGJ÷ Ô=sPw‘.èΰª´>÷Óa@¿A’ä”þŽ¹g :üDð¡.fw‡äéãM,Ð+ÚØ<‰W9ZP8µŸ>ee1r°Q½áoÈi ‘ùy¦ÿíüh-=+¸âì¶áÑÒ›YKÁB_LShl¬^½ñƒÍÜìðœwA;aÏ™<×M'0SêÁƒÚ½8ÊOe´¨úž=^5:Ç¢)NŸÊÂëéÌ¿~C%ŒlÙ*‹úVÉfï šOdB™þÿÿ_Ð:F#3ĥŚ­yÇÝ,=8/oÝíH·<<ªKÀz¼(X­œöo#cFèî}»H%")`’`»@þÓ:^¤ìŠ=éÑÓVU†nøOéJƒ‡ÞoCw#r†´ªy³GXxîËPU¾,"K¥Aõµ˜©(ʉz¢¤f2’E´]zª«duI¾ÉOÀó¸x eʼ¹–LÓ;„•ÍÙb™‚`?6GÅ‚IóãÞA!ºÅ“ÑÃNàYì-±ªQU¸5ÔŒæíØ6ÒÁÑY{µ­Ûé„œéê_Ò¶.2¨Ow¼£ÒOÕÉAœ "­¬íz£Àùü‡fÔý.×.˜—ü§ÅuR?4Šá{ ¬<X•4�ùñÐ1Ç»d¡ß=ßÈÁ/R±Ò5§Òü ‹¡ÁàXɯWÐQæW£p¼rŸß^"›Z¯•ì*ÚÅùÊhR®KE™‘8S†ÚœTÊöíø`‘Fs% ±Üj{Ç=Q;Îtô”ç½Þo(kÐhw·¿ì“ZmIÍ4N}F»Ôr\*8ÐÑAŒÂ[-èþEµ ÷›%c”ÿ0aÇÒý¸«Œ6•Y9Ãy ¢âí…dª­Áp>‹Ê‚ÖÇ‚5Úýõt?D?QM ×!ÌÔ½¶²$™Gš`&÷wúfªU†˜aS;NІâ-’Y[ð]úï‡q¨V’‚«(,A~ºhû0’ aª@qÿCßØÝ 8°Ý#/®VÇKnÊú'žp”š>Ò©aƒeÅ1ª(Öõì(£4y¹éYä¥IO2£,6·´T£OUüC±¤VÉÿ{KKu5¢mÁ˜|¨ÜðzžWžÑjô=…ÿù¯‘Ãï¶>óØGg°¯³øÊÔ•9ì0õA›9úÚY^nŒÄac,×γÊkx×ë<îiyȧ®ÙçÄœGÙœ³sÛ4_—îPkÔî¹h~3Æ¢óOÑ©\ù‚�ŠK¯îÜ` 7ßÞJó RÍèÊ–ÈtÞÁOSí‹U†•sê13í¬8<GS‡Ë¥BKĉv+ž£5Ž© ’ŠU7{¨µ¡íg»$ÿEJ±ÊÅL*K§(*¬ê“Û¾3P¦RCù‰ˆTšÇ¡Ñ~ïÓyRæ¾—NŒ=݈áS5ÚŠ$pH =[êFƉ¯pb­—¥Q³¬Ð©ƒÜ:,¦éÛßÒ\=fnðÏ7vð/ö.Ò8ò©]\0Ê y×¹Lê±=ÒÍëYgA”@„B no29Jâ±ÙÖ I^�rù­^HôŸª0‘qLÙ¤YP]z…Q!ߢTkßh´¶Í@Ñúµ<ÔÕ;¥I&DÆž�¸ló´‡ã¯E`bŸfÎQ•§Õñ{íIÙÒFëþûýD§W–ù:'ÐÉè~wêßQ®™ÕçïlÌÊdá ÍúTA¹ûr2aÈDø+ªÉºh€üÖ+"ŽVh¼0‘¾od]¸«iNT˲ìç­±}±¹^ª$/ç EéÏǯj¨LtëR†»RÉõE½“jÅÀ\$å_mæqsЕfÞô·u lÊp±1`YÞfãáHjž·,¡8¦çMϤX|9Q¸µ¼±*•È ²Ú]3ª—/+¬Ó¥öan~|°²ÂŸïQئukÕöyXÂBn6ni^¾éY•žÜÈ K*n®>öaÛSvånÓcùŸ”@AyM} ¶i£Œµ´˜àC×Õg{°§Ó¤Èi]˜FÖù±—–J ós.7=¥?›Á¹…v‰\€h¸Í*›Ï:¹C­CžŒõ×á{ᶪXMŠÃ`î)^Ì{ϨúÔÂ\[[ª?T+$dætú‘³TO+sµ¨ýŸ‚ÐCíÔÂqŒ×æ  k\[Hú³Œ'ã+HÛÕð@¬Síʳ6]k[¡Ø£µQž­" ‹õô#V0Õqs_O‡#¥êTæmð˜x„MÿœêXqS÷Y®„éËÆà†<½1†Ö”@%Ãâ3Ì"£¬m½wùäHHb÷‡JÌ|÷g  jK?LŒIËì3ƒ¯ m—eá.,3Až ýS/UOy(>FEµ“u™§revºÌôh“ <U«úµ'c‘;§@Á“ À5ìt’ïD%˜;…švÖ­ûAßK˜¬îêÁÊòÒ¨» ó¥ìä¿5Ì.Ì×*Œ˜!ÅÛKw]Zé‘ó·{›¥–>ó]4/ÏíW' +°Ÿa‚¥¹eÛG5·>ìÃÌõ üâé-@#¡ÄJÂû•ûcÚçv?úðMoŠ1Ñõ‹ž\fÓñ,YƒYsÛñtê[¤P*Øk™T©ï’„} Çg+šÀž )·›zNóx²¯›šîÒ×—kƒm°�”@I¾àZly/’ˆôÏq´þEWõ&k‚÷¨K”—ÁÉÕSøડ籞Áyë”Ê\ý�÷•’ME’1†ÄMcXƒ¹hŸ|µ.}H(v¢uDì_žÂU,Ê‘ÐÑž¬†¨R.¥· jήÿ{þ»C$™ç¿ñév+W)Ú|Úôï{;»šŽ­2aªÜðL{ia'>àPEÿ)<Fb!änÀ•ûù)œ×^{Ú¹|{åPèë:‡ üR¾T~*2ž4®{‰”Ž¶ÅƒÕ�¸Ë �ºçúse²r_<‘B„Z ŸµÝƒ–$·)ksD;åúÔ`¬Nf ì�"[j&€¬wõ…2£\ñ+û€ 2zŽ¨Bù~ž鬟8â™ÁÉ4x‚ùØòúÿ`µv–-¹+ª 3ÖY°°�÷¥ +¬)ˆ%ôlÆ7r•NÉðE_ZkëUø¾¼¨˜?±ÚJ7+²R¥îõ1nØ�jAºuýYP%ÊÊГÛC30ϪŸ#í¦íAIJ•Áï@žž]}h,,(çÎr¯‹ç¦M£2¸b|c¡îÉ®q ØôâTä¼OAà„BÞ´"¥¬„Ç—Øô‰³CÈØa¢ÂÛ‚p˜Ü)vžô@Ùyæ¹´^<õ‰N|™hô  M•7§~EW «¤„™¦Mû…% ±f%¥Õ‹Uï&Ë3'ƒÁ qëˆU*ï›Îó¿íoÚ®? ² )›9$ïã†ìwp¹ñM|Õ 9sH=™ N²°·$ÜpܹÂ1q^þŸ·¶9‚xuÿ XÚÉ¥°nÜ`Ð7ÒfU,E]³XÙÆþ*ˆr{ë¾™XùØŽ“^\r×õ@–y˜Î·»’v“U a]Ècº}Ñ=feÏæbQhÚs"_Nϸ¹Rý>µ&1�‡ŽH6¸6–4ARÅ?E™_…tÔ±‘“Ýž¡À‰‡- ocñvñØ.ÊC_µ‡Â¡I'­`œD¢ÏNmm-À~},iñ†<³‰áÓk‘) b¦SÀ_h–å±Ë—+dŽâæäÞ0Õc“8“Ü‘ãÛW>Mæ²jÙʬ :>@ÎÖ‚£Ú®3Äì³þwôaä±ú½í2†RD@€#y4̹¦DþSt`lFB†QÁuŒ¾É¾Q¯˜u¸…¬¹oÍ$‚òN©ßŠ úZÇT@tç"H¯Šâ‡<&½ãh‘™ð£X”ÿ ÆbsõqÙviL'ò—7}]ÚãI¹XO–Œt«—yP¯Ôpê/5}¹1 š8}egóþÛQ„1oøÐfåcm)™ôÁpTÓfödPößNfÄýâTªEΧ.?qæÓxÄT7£DÜ>…@$4M€‰N®NËC†íûŒ6–53G–3ž˜þÇ7õ|:!]8øS«~L#­M*óû‡zçØ¢¨‹yˆ3ª7'³$K+TVÿ=Oí‡ø·\ăãÙ«;AK/uî}ï­Èi16í ßÝÃ’Ýö$_ mž4"Û¼n—*ˆ÷ á28O.C;ÐüÒ¨ l§;&˜ß#:·Zh±G•W¢„¢8ï„ê4ÙöTL$ó­×TùA„>ÉÍàµ0ab®‚¢¶Ò HqYÕ¯ƒüuvXýô õ‘ÏkßøðÉ(5r]Ú£±µkÌQ¡×þý1øG–Ü'ïÂ5Éè <yvêtb¿-u¿½AÁ¾p¾=<ºPá<=P@—)–|Y?+L§(ZHÎïù‚nÄP˜[qéï ~Jìdžڗç¥8·ỵ́؟eò‹Øï Ñ1 õÜt¸xÁ‹B†Qs1ïΉ(‡¯WlU,FâÚÿzßEdztAÃÛõ@w`ÑcÚÜ@ ôPþˆÔ·‡*"Ÿ›ùÓ¹TOã_ëàñúˆ²Üa: x¨Â¢„Óž¯)Ï û?ß0NÀäL_÷% Ø^ÝýÂKo9Ä#Û<µp·´rÎ9£5!¥ßÃSóÜq Øb`KGUj;_ µç4«.�Þ…ë°¤¹ó{ï¹)dЀ뢩Š¾ÝOΡQ~ ŒšGX+ì5–À¿DzÛóROJÊüug¶ô°{œÎCÆÝ™Áz†%F˜µEùPsˆ$IlŒÑÅ)V²t”oðy>´ J³±K”©àÓØš¦î&—¬Á±+“ mu¦Y澿P.BQŽ; pzè—éI%²*Jâ¸Z §¦ ú óÞùâÈ5-ä±?ê|Z|6Ý?R•/[φÀ;5ÚN cæ§FŒëUj¦·.„ö)¦¦³óø›Y]n¶ìª© +×?g8ë+îyêSè©5×2HõkIÙ"N”w,tÿ<9}{ý¤`ótÖ‘®ÓCýSR±ÿåÀ0hjCF¤fèT?ôr({—Ï| ‹Èï¯R™Ù#C:ÍÞÀ±Û`Ï5·ûQW< ý^íÉóÕë؈“Êoê1(YfÚc¾âyøð¤à,¿¹f¡%%1œ¿Tíî¾N¤‘Njôë"eß‚—ê“`ääÝîËò/Æ@Ä>à‚Gk$éw^—Ÿ>•ÀœžafZ¹ÓQ(Úî~Ázì7r¶•Ó]b¥ŸMC¡*iUွ2Y®Ô8mNœD™×çþx83 ‰éLî-¨#1²RS¨â"�Äžšïÿ½ù�]n¼þ¿ñ½£ÐÔMÍÀ-û]1ìЃpöv‚2„zYyi?Ž³U]úSåTáËSgAÚmxn""| 8 µP‹yˆþB­¶‚ž° ÆvC»¯ÚMžªnÁFØ´5ÀοõHN’›’Kð\²DÆׯ¯?4h¯¯Á´fU¬bÞô¥k{&|¨Ï3æ¿ϯ|ñpÖ}zkQ¹¼îríwõ[ÓÔ»kƒ~ÃR×ýT ØšN¯yWCaq¤Óoxƒ<ç–ž“þëéŠZšéöH ħŽ6¼Áh¢“Ñ*IÍxQl\ÛgÞB/m“ß’~B3l2.>Úƒ1ß. !›¿ÿwŒ|ŠÜ¥ïÑ1b"§½ÙC@O×q¸ZуÍú¤å¾R¢.©)=™Eå7rn~~¹|×$üÒå[ýÀOžðªY™GìùÅ"—WÏÄe=Z§ÖÜ"WU|?pŠJoq.Æ<èKcsh>îp^è{ÓG¤HicÞ=w^uxŽÂà9N#´æÙÓ-:Ö× EKr84"åñsIæd¾*óöÊUµm«C“òàBþ“åU¶B³ôR¾œLô(™ú; ¶èǦxË÷ŠKÅÊð€Ç ôá{å¿ óC…+ÝwL—1³d«Úç]=›Ah²c\ZàœL‹óÒx½oã~ ®©í§øõ©ÀžËx3‡Ü£…Y7®•Ekò´:LòôÓp'©2ïHqî=ïtt“DˆNé+bI‘­´L#ÓÎæÖ >(E“æ1ˆn8mbÏëFªêÕwé:’f‚O…vÒ_<šìiDÖm†—ÂÞûYBÞñr#BØkÐq=Bë ±í¯ NÏßð\°–xÞSt¨'‹à£b‚òéA”ßÇêÛEÙ-2A}Ö2iÆ÷ü¸¸Z©âÓBºŽ ÈJã›zUxÛÝ•X6¯—>U =zæeÆAŸæ@Ç¡Ó3°:›óß¿ôÁï!»ø[¤Ð lŒï)�ÅK£²•t÷è6�9лy÷觧㶭‹á­=%ÿñÙJŸQö4S½×E:x' PÆ…iþb²bRD™¯žžÝD¨µ4.Q͘%¢ì/‡cvX;Å}ŸÑ›ŸÎÖFG5ÛDþC×ï~xù ùG®wÌ6h˜Ӳc1•ÓRKuÁûÏCn*´E(JAª‰ÚÌndì$5äA¼ùôt^.­G7”=Ïb¬«kì‰ùØ>ØYáÉf° ù‚¹zušÌâ1Wv…i‹4!MÏšÒ$€=¯:Óbˆ²£xäQ®XæØsºmÖÝ g…C1št B ×7iúZïªïl¬ªñ ,¤9rKF9M‡q-‡E‰–%…,äCaWùÈÑ㡳ÁcÓæÐO³~<»dhgäÄŒSb‚—µy—‘/÷À„ †P´õ¦!…ÄÐ/päøoßþWöÀüà7Ì2îLYm]›fqGÉLêŠ ·âQCΕBžÎFÖ¶FÜ*QÈ}?§ÎyÊ\âHÊ›Œä×òÏQìiq™9u |*âtGµ€­Èç¹é郑·½ùñ)ÿ'ñE{`s"gMu­=œ1ܵÌ*3Ýb<ùû†žj¥YÇÃD ì®Ö/¹fÁuÜ\¼ßNø¤Úòv—ö$ŠÙJ! R aÒƒ° Šðy£—ûDI̲U„ûöøŽÊ¡lèU«šVüŸZ²˜{cÈ#Y—<ˆgÓR75­Öt*î?�½Ž­€Ò‡ñ Úã‹ ÄÇ 5ùå›S…ÄzÎfGz;e‡ áf,õõ²4öô;˜A°ï‹ j¬•(ÝŸ`Ï�w±¦ê¥}>¨•ý|*›èä%Ê•ÊjȳU° ƒÔžq¡½ÀbœÐbžûGê]e˜y0t4ÁÙÕhã$B‡Èwéô-QŸÛ£f‘[ƒÜb£}JA`ïÉáÎ.NÓ~+AGËëÍ <W“œM³‹VSXÌÓv6³\›dÿÂ2»ˆÌ’ɹz+‚E|êœö¶>ž6¨Þ¬Rmù¬~àoðÄ;1KoôvØ6)þz3SÆ&„ Ï„‡Ißy%9C¦¢@Ÿù˜P-­ÖTX$@.­éSjªhȯ9ßËÊ•±m¦¢1^Ñ&«‚rª¨yåÓ„¶Ö¥bˆiYòҮ榲&Ù•g{,é îp*&ªÀ=  &/÷–ɉ'ï ïFA…¶jo‹’¾h5{ªj¼=ÍãQþ峇w>IÜkEr1u‚Üoµ?{,S  ÞÏàèàI©)iÀ3/n—_dF½»o‘çøžšºc—ƒ6ˆœÖÓ£+sÚ; €+­ ²ÓÙ#÷¬Íz~»Ò"E"‹ß%`eð‡³z¨ Sg³ª~2‡ƒ3Å=¿;Q ¹(#õ“I ÔHA5ß‹5ÿ,Ûl…p ÃyÚ 1–ÆàÚPg|<à`Wzæ­Û JMéoõ"«v:ÜÉb`ßÜr¯ìÓÈæG<€aoM–rÿ‰ý'Šr‹••éÙi„B¶mv”‰(ÕmG¨ÞouoÙ„ß;:­Q¬ß…êÄÌG ÕÀ#N1·¼Jéo'ŽÇ‘‹„ç ËØÞb0GË.¼œM,*BN ¶í¢­Ÿé¼§”Yþ½ÄUN6ÞîðXÏhÿ5ÚaCîÊø'£#j~òÝÕ½K‡(Ï|[Ê›¦=2ðkïÕ›ŒŸ€e–s3AY¯´å{÷‹pí…Á*çÐÖß[‡hÎìUõý­¢vˆÓæ…³ARD¶ôÓîTL'¹²T·™!¨VëýÅÆÒÈÔ§´8ЀÕx™ão*ÝþÔ€99%ÝË~=µþ©«é»¬%ЪU ‚Ö]_Q}jÁ Ò *¾^Äì?OD`VÆ&¦ËuV Žâó 5’Vå`ü‹Þ€¶œË‡\ó$Mëáœgðÿu±§î‹©Ç\'eP½kÎÓ÷Ð ©ûýºv¨‘Ý8<v{¤mÊ|œš†uܵþCËÂi㇪†„ Z¥<¦ >÷½/fýâ/,¬æ…Q3ƒ¢ã2Ø�‚#ëÊ`Ó±¹ÃÜ£b\û›klšqSÏ}û£ÖaŒðÞ¸)7ÿËgÕ ÈöRÒÛ~z[ "Uà ü c’¡\¯[ÉpÎa2/û…8çbÚ­©©E³ôuºDÝ}#¦]Cm†´Å^çŸ8c{ªb}b×ëP¸"6xiÜ]€sNÞ•õ†A܈<N`W_¤5ôÜYÊ0åÔÒ“£Z€âõçʲ§“¾öõf1¢7ïÿð´<O½” Ÿ>FGùÇ`§F…úµŒ²)`‰æ–½²„Ùbåç Uh,{ï­¨L;À<„¶ßäÕ[²èh89/0m‚î:4|±Â Dqg®+K÷`ÞÓÛ÷Ê­Jæ�@“F(Ik†ÂèÕ]ýâ9”ìî ¯ò¤ý‘"·L¥¡¥—ä—ŠÒë„TÂ×I(;Õ}#:"‡…׉šÈ>”xx$úP9Fap8ÁR¤õ÷" !eÓÌðöÕq[ŠÌ?mivM§;m—+ÃÊ ;C²Å¤¹8„{`ï§)Ùí—[€y­‹dÛ·G*y<°¯±Iq´Á,è禠/Oǘzxx¶”^‡õÙ•W'FphB"ú ¬ºk1‹?Ãc¿«)Úu(G‹÷FÓUöö¦ÏÂnæ(¼T&D¼0­Ó–“ɧ]=H‰Oµ™Bxlg_GØ,Éñh~s/bkÉ…©é¡6PªÊk-u`‚=šóXÙoü4$>úÉ'Ž&<!£šÔ˜Š>•£Á¬ÖMƒOͦª§2í|A: –…ïÂɵ$ˆm7™Ý G`Ê­fþæ0p›d4>Söâ ¯®1ÃE«1^”«›‰ü%ÒZ\êis˜õAoF j~hŠ+"Ópß"á¾MŠQ(©'D(±é±É“}™—”¾‘qÜìí¯+íl‡ÞJÇþï2RÞ`t°rÔ4¯§óÄtW+Ç{x°ŒiëSäÖ(W ³”.ë¤rÛ»N ßWôfh‡¦WpR8¯=qö{åÐUÊ(,/(1ôŽIéýáÏa8Ø. p\NÚ†â󤯨ŒU4[ü…`nSåÔé00g^Ù‰V™ª,ÓùxR†ÊKäíÜ!‹¹—+ý²öÝÓò–BíZs¿mdÄUé{qÐfé á™6ºÑ‘E´|`ñ”\(¯ÎíU=è_4¦Oó•©í"Ñ™Þ|Y‘ ^T$,i¢üNq:wÍÓHØ=sAO_SüØ Í~å—ŽãÎ#ÔËAü©€Åî@[ÚÕôÆ óö俵x„ ¼¢Mu™3ŒaŸW|Íö"Ž\=‚ÝMÁîâg[r§+êò¿i 9Lœ�ßcJFâ˜muMO-«ñx´žt“ô$PH6‡y~ û±z 8ÓØè¤a1ÇÏ/¯!XO;vÈy’ïþÒÑf9• 9 îH£rtÖþ1CgÙ7Où¦îV.7=Äe@¯u£ñM¾¢X2ùvûñÜÐðžêgùÏ ’£²p¨zÉoG*ƒÊAAØÄA‡VèiËÛmEh*n -GñB[X€ëúÑת¢]Ú‚9jíÓ.Ó¨¡±*á¯îB…ÔE¯©¨pYx±ŒÇGt.A>Ì®ÉBÕÅIL‹.”ç [ñ†F$®={a£çíÉ…wXVX'Ó1ó÷L§Åj$Ó¡+Š\æF³ÓC-³8Là3‡"ŠîýSÿE:îÑODfñ5uñ¢ðï ·)¶ï®í?Õ”ÿñÆßÔFfü‡=l›ÉßþG5Yýù£ ò“6+ À�e_‹ÄH¤‘ó¹?¶úÓO²ÄyîÏzÀ">&,™fµv(ÒÒ]‘¹fW/’aŸZèå÷~×âÁ„Ã`/"žq¢Ä9S¼<©ˆ£ƒÿýß[bÔ—PÔraº‚ÿé7úOšI¦;’çóRR5›ÂÄ"V¢…Ûšæc¸žÄ§,àCËùK­Ú‘o�©H2»nS:°„@Í(rBž¶ö«ÿ¶èËkÚŒGo¯Ÿ¤â¹Êðó¤ti{¡ãÑ2U™iéX»­CW-b¡1JÇ¿²êhãÚ&‘µéñhìÜ ?ì‹ Ý©L£äk¸Q[ƒ”êF:£FKþÌuÏ“©o4õÒÔäe\¸PЂGZõi¥ uG§*…ÚÖ¹3HûÇ4û…AÁ­©Á>iS‡lm=sâì|–L©Ñ&›%™§ŽB ‘êí¯ÚCèñãæ15ßÞîc¿¸‹gJ¹×Xcƒ¡žÞ´Ù¨B¯á=C¶YÎd§ø³'ÎÐV3E5K|¶_©™GbN)ð0n û¢ýjy!/"C™Ž”úS1ƒ±ÝFSÏžç@}¼x#éìhc¡E¶ÿÔRôHú³©{ÐDqF±êÜ×5ɾ'–.ÀŠ‹ÍéWTÏ:ùêU_ó<S¢ŸŸ[ܤIää ļV|i­}ÊÔwt¨-|PÏNú` ª&QžUÈà ÀáføzŽhñJ"Úî(8–Öž D/Ê8Xê¼ãx˜ž¦x»\·ýy€ÀÐ4T­_¨­PT|ô+?z–‹´/;*ÿÚOˆ9ò²ßXI•ÿD»£Úluùoa’„7Ÿ ©–Ÿ6ã-¬ú §|·ÕçKFmÌ¢ÂhXô}–é»V¬aTûѵº¯o»––:”‡`¡Â›J}Å"LV¼…<8MeN½:¢ä<v£ÔD ÑÄp Ý-"ë1öÒd¥¢‚&(¥ŒÙ®sfIlxç;­0ª¬�û03ÄåÑè8¼!aÊ͸ F°'¯ÚÑéëµúH®ÊÜ/kÑHÞHÒ9;Ña - §??KŒx[”­¶É¾ÞïÍý±" ÷¢2ˆ, ööôl×…[§ˆßœgÉ:Éål‡"ì—JÜ•‹dõTÿ5*ßûC¿i§æúÁ'ÀrønOÌjEZãõÓÿà7bŹ½ 7£?¼ì<¦ú¦UU]³ŒÆI[ÏiÖÅ´4:Cõb̆õ±kÊÝr^@ÁšE&,Måçp¿Ò}àF2&<ðPŸ݆½n×Kb~û<SPþiÂãÚÇ•ßØPèÌjäŒâr¬6kÍ0câWdV§•]šC¾Èq{öÔ"è[Jd–dÊ?X$~« SÝÔòÝ»fMËG5*ËF™­ÄHnû@ŸÉ»Zµó“<v|6ÌÑOƒä¤S¼½Æùð%Ó¾Ôi«qÆtàáYOé…Î%Q"j’ÐY£Ò9 1¯)Uu6¢ b–t_z,åJ9,ÌÅ’«j.^ fk«êÿš ·šµxeßZÚÛMïüÔ×o¸ 5 GÞ0¢ji­¸Ò�(ʲõÙFYî(.ToiÙò‚†uTÅ>þP’,¨ÞU qÏ› Yž¢ÞVõSºý¯È¬/¾ÇN—öO#(aV &wÓ!eü ”ø¨_ÓÑ¡¯±QN!/WÕ^ìÓ€sÛÍyÒÝ)3ÝS°=!/õÓ|=7–VhrÊael¤›û/bóQîd+"ö–[.Ãݹ¦7_$2˜ ÃQwõb›øˆuV»ë&Z\+Qó wßÚì×rQ®¥,f¶”µ±¤ÉMÞÕdípOS†¤»ôÆ6»“¢oŠC<µÎ ¿)²sçN0˜|Í©m÷È-3¹!qN,5¸ó 9,1m¥djAFȼ_ƺúÁÜ@8< Ò‹¯«" n­¼½C'Oï/åØœÚéë-O1Ž=MJfG°kèÔ{v�ŒÌ­å³xΡ¿6ÍÊÌk}Áu†U@£ÍŒL¶ñû YÝ`w5·½¥î¯%Kwô³›åöO”;+Øñ\}Q*ÛÐ_¼0hŒKÏÕeF*t£ÞZ•ÖƦE3ÑîZ¿Øó· WÃ舧i³Ò1Æ×ú~R{Ýy>ÑO8P¦¥×Ö[ï†T¼ðtÂ]ˆGpCsg’”û8"Ú/ý ÁßÆâ¹q¶‘öµ˜°þHÜLr_¢ŽŸÍ&fú»î—XB“DzsÀ“Wo,Giû¥}ö[àb›†”딿o,•'ºÁtŸÆ¾Up}}4p^‡«óêNOÅQ2Œ$·»”jTiù}´",”Ô@„Ⱥëô¶\›Ý¡ÿáG“™šT¢dA¢% òþêämlî`g“w=É_üÈ\[S¾f&|œ&@\<7ϱþðäöé©#X€n‰3ë`‰ËÞ9­À!r¦¯aL±�»A hèk+"ý? 9fñŠ£uKKc 1÷ĹÂb¶d/¯ÛÔ&P<ÐUˆ-(ATÊãàÔç[*�bÚŸ[Ÿbñ;/:gzÀ:ßð GQÕ^½S†E§¬‘È®ž RÆ]±„;½±@:`n┽MÌ€TüŸ<ˆûËRÍÉê‰9üK“œ¥® ÊÏÁR‹^äWƒG¹uÖçå^ð³ -­Ö^Lüh =©ö9*:”˜ºâ²ž¡ôeQp4 £¼¨2·›Q¢yÜXóyI±hL¾`„fÇ……aØÜf…VA¿‚(×ÒSì¿Lr›ÈÙŽ{ËbÁâ#òHøÅßÝÁoã•Ã)(HÚ_ª‹œ3.üIrY ˜‡—/èÙ$k§J6ÕƒSÙ»ÑnGêN7{Ï¢J§çöyyx«²ÐÑsô¶µÆ0äû¤h‘^Oѯ¯(¤Æ€VqèéµÇÍe±`Ñ‘,%í ƒQÉ£oóMÎèžBÅEÈ ô(ŠEUÅùl39MWñ+[ž­Sý”ÙâOφzãS¤p.ÕÛÎÈ6ižVa+¨8h È¸ùÉs°¹ C)ÁtÄwÙhg²?ó>;{×ÃÈ“Ióú|PY}µÄBFèaX";’£éVXMü=úåS»?Ìë�*¸#áy°¯„o‚÷¢ƒ˜2`t£gáöon¢å¬iä¤9«`„Š}§SÖ…4Ú¦§ÖŠ™ß g¦a¶–6¹ŽL4=™½—j÷rœ[Áó]ëÞåOäõ~ÚSø—XBÐþèú6NÚ&aUà¡­éßÙ`•ÙTS­Ø%á4oý”?»jU“‚y_y§É3æ±ÛŽyG€ù B'Õþá' Y;Év´¼ì þ´x=à({é?Dx>Np2æRÄfiÍÖºWÎÞÖ‡íw‹*V‰²ÄŒo7¹á{áýÏáënoŒ`ƒ¹Fl)cäîðOâa…WºðP„ajÕéâ<#&+x‹RcÃO‰5/ïð•*‹VçÕ2U«ˆÚ‹±K1Èw³ MÒC¹c¢ŽùCsH!¯sê¤IÑËèõÏýïŠâ™ç‘˜q¨Å¤³ª¥A€4jpŠAßðR¢8[[²? ¤i›Ej?†£s,6Öâtô ÍødÍ  ƒ í’ÜÒ*^MßbXcU…é¦QQðªÈ[œ¢ÆRNHÉÛqxÞëcïúŠûó¡ÉÂGWaÞãØ°p ´³eò¬×§vAL Ó½µQñß”m‡±â›UÀÅ%âep*>p½åv:{¶þhÛRU٪ݡ+ÝÒ"U¸E­NµÓBcý¶^XZ¡U× l›õ‰g`Ý’”Ò«Ïr¼h€¤û¿:é§s÷cj7³ ]ß5@\¿"6øÐR=Ÿ­„ï3.Ýõ ÿßÌ|«UC¹iJe~÷@°‚Xðzu,c+öõ¾F»zÚˆÏʵ¶#Äjè±U�(Jmr¦#‰¶©NôG_‡ÐSå~ž9B`Èž^Ø‘”@TƒºVhÿHü¡›`mçïÅï¶eäéú”2¦¢%×èö‰@�qûÔ–ón÷›Ñ”ãžXÓA®~÷V†¬%;šÿàrõÚʧñrÍ¿þ¤4eVûUÑðå°ˆ+éüöKÎSûZß9=GyâN © zœ6G€Dμ¥SOZ<æÁ®Tk3]ÒÄV¾oeÐ^»+tã6î#N‡ÍƉ֣¯ÅpœGWžZ¤"ó‘ʹMëh”!XÆž+߃Œ² àKøé¡eò×|綜TÒ})+D("gÃU×_?ºåÊ"m†% Ò¡÷TêqÈ-å  ZÊ›¾õ/·5`^üçV•—¶f—±GwJƒäÝ‚´ð˜ºéÌž–¶}Î}9ä eM½e›Ë»4Qô¢ì¢jã”PÔšW ©Îy8 ¬BÍFÇÛö \NT{€Óè?Y’yg`œr“8±°hÐÛ¶QHÇ‹˜öØS–²üH‘·lwJ„†ý¾§½•¶é0[w¦Ñ‚nèÚqµšR3Rz›OVi<nµH&(TÍ‚¹ÿeNÉ{„êûß,*`8ÿDQÓMH2ñZ¢Ø—OWOÇÑ|“Bðn[ë.^Åʼn)¬Dòƒó"£}e¿#Ý=Ú§- [ Krë ùcBíŽÅ!š•ã7FÏf¢Z»pŽÛ)t2ö!ˤ¿3©œî/§4ÑbŸVÎnãûÑþ}¶Æ»"¡¦~¡U{´B®¯©Ñ•Ž^(J7”ÝQ|ª­ToÁH–?DKÂë¥=Hë²ÄµsEqö:0;ßÆÜÁ•TwÝ�š]=¦@X±ÌØåu_9sˆ]/edyþ?Å2vã—2«9~qÝ5#8l®o– „/Çgƒª1qý}!Ó"Šg {µêá$®îÝðűR¬"„4é ¦Ì„ÅIá�Ž-Œ…Ÿ ¾ÿ@[L²Ðc¿`ߌ@5-gïë¤a¿üÚœ!3_iåÔ…ò ëI Ù*͆µY'›E»up®yÄNw{ƒ „xÑÞ³~šÎÃpÅÈÔ1ÓeƒßnÇ¿U\Žv6 >\åF9õ Û=ÖP÷Ÿ©ö?rxĽ–%Ãwec¥F_E�º/‚þû¹4ñŽ, &Ë`SAÖ{&!5átïMÚ1Q¶l»÷îh‘W÷° È�ù’¬k½Ö [eÉÙB«Nꬤz¨F¯ù9Îg–ØK»âû¬V¦¥mq`¦÷\D Ó¼ztÚˆ»ðõúƒœ%ÙßCqÓê_¶ÖÌJJòÕò~[snM\-%£³Ìˆ õ dÀìÅŸ6ˆœ¨èS¸tËÿ"1ûtF ÖTTŸë›Yq9Óqú àS]ÅÞÕúmvÛ¹žgprö_¶8 VJ™Ž;ÁvÕóÁÜBy”øš”ó\vx©‹5œaf*…áÙ’¦/rž£©=^³©oà?7³3 ¢ójrâÔTÌòá󺞃¦!$Û‰îgkW >f§é*Šu¢††¯ok6ýá)*³Ì“83Ã,Vé&0Ù¾7ÌÚ²šëÁÊJ×èj÷—R-Ã5<"_YJ&ÅAíì¤3@×yÜÐâ G�®»œ<Ô¶¢Î™dÁò½vÝ8¨õtßæÏsÍšÍ éøs°6RC‰y¦8»ì=àÜÚ&GÝøŸz|yêOèAþE*‚Û1Á‰áËSÔ¨¬VstPè1–V �;AÐÊÕ~Þ¨«÷7¢ÊiµªÊBsg5o]Yâv ­96-y­!ž¯eŒ’ ó <Ϧ„‚ñGu]ÝKÿűQ 7GT«>ä˜>覦Š¼l´VÍ…E[‚¹Æ?š¶8þ¤m„’¤¹ôîhs, …óP<ZŽšóÅZ¾XÏô=ÏÇRæ§Â `–ÔÄ›áaø¬›ë³{ð$öcœ¸žê¹ yçKÝ´ŽŠô[ći¨X3«Mƒâ«õ|$W^u§z¾s³‹éÏxRc‹1íã 8µS…b¦8¬˜!âÉ®M2š!†ƒ=Ç¨ë” üd®o ʵc‹¬—nú©&pQ[TÀ®kc[âÈ8hLGpôl…^¥VZIǶ@Eï6jââvžüÜxZÒö`ÍV^üQqЖ\…ÑÇoº‚2Û!LxéqÃÕ@^Ê.Ü‚%hΓHÑžz`bô£9R3Ẏ´V¢³|?2–o–ŸIÊ\ÌÎ÷BÂyæT•Ø‹£k’ ¹Ô^±˜ã âVò6/jÝØ·2ÒJ”óAvKŽ€Æž?ÜÖ¹¨Ë÷%Oj%е©uBÉSl<ÙP8´³›ƒ3ÑlG'™q¹le î¡FÂ4 W=-̹*¥ Œó0ÄO,¥¹ýø•ZNæù¶ç0Mc@eû×Ï—þ7@¥m'F&CöU×úpcî ú<*à9¦xÉ<e7_ •ÒRy>+¨¸®‰=¯Ô§c= z®ÇÃø®lÖK»ýÅuS­d´hóÏSÁ¥”µuŸxÒÆ­jUok–¸–—¶Ö¤ßî LU"Ø·‹.øq׫‡ª7òäÌ’ßPÏzÀ`8ªå|׺J`¾™r¶&@ýâEö¾FX85ÎBòýò¢+@új7°üC¹xôõéFÇ»‘rv8 ²·¹¥-CŠú¨ò4§ú™ƒ]¢f‚BÙ s(v”A5iÖÒ!ÑE:Ÿ·à ¿¹h�å¿t5UŸšH£l°ëÑ/2·I®PúFOóJPx&$OZ¢Üø@UÈ/Dqë]+ÆÕþg4¢Ï‚)dß¿¤¶eVŸÃÀA˜ã*]ºÊ¤:;Óúèû]©&ÙG"*Fñgí-¢šÑ¶–x*Tt+œP1�3È“§TÄÖd^+Ïu ]¹†½â¬ÓUtú_]<¦BâÃ*Æ¿‚ [cÄ"üÄýSxƒfËƳ5ÝÖ§‰N “&‰Ã-í¿íwÒCÎÝDä&ûš—õòÃ98Á¢µÄƒ—~eÏ’[m”MC·j=„'ÕçGbw":à´öÝ÷vΕµâÏN© EÉü]ãpŠó´†mš)â·�¢•ò´xuG`®ò¸Rª^wŸJ4E15ìTiº×Ÿ˜G~Î+·Fó‰åê`Ö¹ãB\¾Á,y“°òP¥üO5£Q’SŠ†²U¼äÏ‹( Ê,š½Ç& ͦÅ%§nÍáÂù›p`Öß꤬JY>‘ :ñß=‚ÐÜÕL'±Å¤´»+;¶9Þ÷©JãU '>fî÷`R«š**EæXîÀÔS/·è“Ô#õ0}~¾”A2œìɶ:î]0ÉxYžÔ‡Bg8»º© ‹yáé+ǤÙ…›_NCZŬl‚=„eç­3Ÿ²pE|Jƒ¦§`ZZ~Z¨Í¡‡‡¢ý«¨ßÑ®Cfö~¶H¡°oÛuÿÉåqè2Uóè/i×Ú4G­\4 › ^ý�WpÝgó 1g¢fC Ùz3¾‡Š3F°nªåyd©VÜ|Ê)q ²Vq¦U #@ÏÖ?-×®F¯ÿä³ÄÁ@ i¬p*íg–d1ÏüeM�•}2ghJç^TÅÍV¢†ÊÉÀwši<ˆô ìÎ%„ÝY %>̆BV3ÐCýÚ;ìR;q•ÜÔ`Wѧ1'…»ºŸRzphc{©YõùÙÔÁAþÁ$Ë•dR(ÞÉ`µAcÓð‡]"-}Ï×€’зQXìµ68vb˜Ç™Wà�CÊÚâÃd=jdåÌÈ(b[Ï´Åïb]æµäÒ½íâ ñEÐAõ°ŸŸeǾ¶¾ÌòܲÈgfq?d°»ŠÓ¢½õú¦ R±'>qÁ9íÀfkëh  Ú˜ÞR¢,õЦ•Žâ?I (M/d“!Ðôº<g(œ–7¬}j=OÑ6¨”b<‰4˜UÿG‘#’"Ñ»u©ây­µÑƒ»ådz•²rúOTLž¥á‹“µÝX‹í—ñ®¡š|?{|(/;¸Ae)uú˪¼©Û 9ÀWìܽÿõº|ܱûß|[,›ÒPòbIcw{/ñ9rÃ^e© £¸šó7àÔÒÓßåÚkÄóÅ“>æ8ƒsL£')X{ “š¥×ÀôÞ'æè‰'aaÄ Z°og+بÓ_Æ¡ôõe}þ?Ÿþ†åªÿÉÛ2ÈÞÕ4�⇔ط³Ñ±UÎ÷¦Og¹ÍOZ·-[ÈãîJ̦téd‰hSaÖvÀ@ îÆÛºN¸'×'—àgg~NDwe¹T,ìan ”+P¥_mì0p‘Ù½QVd^o½8¦­¦Ê§–þ—S¬TV¯prŸ0Dëä®l™ùþŽ!£%Ý¢Öª�D*!fÉïBÛ<Oò�¤+õììÍ*Oó›­L6ý‘l£Kž’ä¦îÅ Ëèûbzt÷|1ƒ°PŒ\”od¹01p)»–=V~¡“_†+ôoNyP¶Š]eô Û23”ÔH†+y¬m‚F• }H•Ýù5÷üÎ(B£‘–ãÆž¬ÒCKŸoõ§kÀ'•M›Ik ~d+ÂaU`žæ�b8äzoè¦Îë¦GæÏûxvI’ðS»Ò(ìlÜCL£ý†ÃèF‚hdkØ=Ø iìÛj#Icqò`{:fðN8%]ï&žø<ò´´:™‹ÓIˆBlåï ÔŽ`Ðø³þß[l4ÞÊhE|üIÅ3ñtü¸‘ úË»×ØÙ ]Öö´ìiŸm?Z·+^’m¶2Û¢°BâDu•CïUè?6×·ýˆ¯Z#Þo/>X^­±åžRœÂú&¡X1l<-ö]ß-úó,öµaòÌ?lh± (°_íÍ=>ôfM°Ÿz–E‘˜)B¨Û]ÁŸûëMuß©Ôœ=]ÁŸÐÀ…'ÀÎÔêa õŸöžMf?ÕÃ^¬ •ýÁÈÔcc´  -ò`_ñ˜Ï¼g &Q’¯¹³1CdiÄú=ëÖˆ?÷XUÊà¢H´?ƒøé›óŽõ‡™<b±í¿8Nˆ•OfÖdÞœ FÌØwoùK§‡ÃtNõôuí ¥yž)©ÇŒ~hs.ê øŽc”öSÌ•}ÙrÑ5H˜›}½6„gJ6Û¥ þ›* ÒéìA!>Ì h6ûö»8‹<½àÖ“½¸]ïyégŸpͪÐnßW¾!ÃÛ5ͼ´X<?ž¬z"ÛŒPy!pãEÅS¶r€¹ô‰àAÕšÆÏô_¤f+E#Ç“pCF¸VÿìÄZŒ6í½Jmäwž‘Ç 7-k.Ä–Žµ@uü}j•º2U'°Y(Âì<§@J:­B -O“ÆI+“»þzá‹åÆöžb­ߊΖ{³²2Ý;ªëëófC”¥7,Jxh'tºPD+Œä·Y= ¯pãÙÔ1ØèÅÀ° ä<¹øó*3 dR ?¦ÉzŠ&;2M¶»8›CŠ@ì±C¿Ù±f3?ÿû: }Í0úØ$€ªºöÈE¶ÛÍèÈ-wñ`ë´¿ú†ì]F+7Œ‚ ¤ÓÁ:{ækÏ\¹Y$Èïý¡ÙNËJÆГƒ¬ÿëY)íê¾÷-Ë)É>Ñ”µH[¯w_´tºÎµ<O×– }‹ª¨ûîþúGm™ã׫‚eHéýNZD€w€êœS¦™6‚ôL‡fÓ~!ñ×»póã4bÒ{#rWÞˆ›gÐÇ:v;¿ÅD÷è2ÐÎ4ß„GGqj~™„^¡ÁݦÎY3ë˜q½ŒÔÝûB.+’Ìã*³B (žŸÞg‡y“FFÊ»Ž¬¦&ÄÝüþ§ò\ÃJ´ ãOä-9crz8/¶ £J' ‰ÉÄ6È2¦3âG>`Ò´ÉéÀÝ"ÀÏËaÛ•ƒy¤Ü[32¼ÖÍyºÕ¨ª „š>ýFhs<‘Q:!õƹ /XOËÙýGmû}fŽÑg¢Ã¤o\äg6múKßԩүŔ”K ‡XRÌ ÈÂax.X ÚMñe—ö„#ÙÌA©Â2^böª?.Å]ã³ð„,ñ'JÊŠ“4(†É0aU.->&Â`N†ªA²ÏÛíÕ`Œ0ívºhU™Úv(C¹úsd';K EOŒå–5¹#Àšô8”.dJÝà Ì}ƒ‡¿Œ¨Lq²ÌBýØn"nDKZ¨}™ýPóC1ìJ7¤2Êúß¹À<ðƒ‰ÃÔò|I¦WS‚å�ù…•ßìr“ ;N©ËçnR(3]ŽFä]®1Ñ¿Á‰Uiã+¿õ´ÕR†ÎÿhL|Þð„þê ± í´l5[¥ª¯;¦qVp·)ñýE¥–š¾.  ~ûæ÷¬*nÐñ´ Ïï.‹MךáÓ‡`ñEmÄî‡5õíô¨ä±Îæ¶ ÎÁú” A{Ö8P!Ÿ`¢OwW7Dÿa©ƒÌd<‚åTf%åc¦ ~EÑ?¯M•±sÀÕ†þ -#t‹ƒèͲÉfí§5ælºàj@wõ î«PsZ>kT°Ås¸·dž®4WÄþäñù<z¼C›VAå0i1ûÏlÞ|g¾º_.¢zwc"û£Ç_”zžÞnÃ"…í§'½¾ïŵpjž6üw>ÓFüï±ÖØ!ˆo~¤çe¡“NÃ@®ÇQ]Ož«]VÓJFz²€ÔÌ.l|ù=3‰¼ðÁ¨è/Å“ ©ö¢Rohµ�MªÒ™gÈ2Ò°%V?ê2Å~Ã3ëš*HÞ/^ç«“Ü…Çiš»¶1 zX2¤{P\©“4høè¨@ËϽCÛíûv£ð"à¡j–?LÍ× fRdþ3 íÀê¤7¦¼§iüCÿkê˜p ¿0i R·«0wv¼Ö´ÚH¦›V`†AÞZ…jÌaø¶µP/Е,Ýÿ•†K¾îR›Ó³À§DØyùÑþÎ\™Åd¯îǽÎ8WìÆò·Ý|RPÊÀ_ä”òÏkf'Ü‚q2(Æ8h—i¶‚v•ôUçå‰ASæÉ{°üt¤U—Ÿvʵ`|¯“H’·îLu\‹Bà@ ÓÅ {§‘,tpd »>h?µƒœ¦÷žk©Š RÊ|ø¾ a)V4j4D3JüVÊt*@w¸‹`ëæ®Ý™„ìÑÕÝͼ.KÉ•âGTÃâÅç‘å~ÿ™,[e+‰Ù28!Ø*Î7¿DK0ãÍ:ißjÛ ŽO�«3¬Óã,âÞç¼vk¾¨0¬¶šâËJÏ–’*L.žpÓ¸¯+?\¯—{ûªÝ\+‡^ù¢í’ù—JlÆë{³ö0¼ãø†žy%i�„?¦i2faèÑÆޟܵJhXéí`bâr`¦%;L±ÐÉ1ì × ]ù ópJÖ<Hëëà¥DhO7\QäD?T§…7¯*˜“ËÎw‹§E;‘Qüfsÿ$EQf¾¤xêgÞYlj1eÞsè^XòmM¯Ð~õ8É]g  `CO=]z•9Ò–Õ\Ìt(ÅoÌ&»ýÅ7³Ÿ4ÉÕDÓegÇêF00­…˜!â­Cp­½¹&±ñãäq¶.wefòÜÝ8.mJŸíQ¸‚nÀ\aJƒØ i€Ø±kûÅM2AQ?SÀ·M‹P»#Ü,ŒZí—"}þ<ùa}g ™yÒ2@ùN[¦¨Ol}ë€zéÚíU9÷<ôä»xZ3 » ûz–í<°ß(º=T‘Oœq:ô&³¿tÌGqévˆløØÆܹ4Oçq}a˜ƒõŸ*wˆ<‘ëR t¢PRî5™CÙ¹»i³¤Ø<×}»¿×W¿x´5Ý`趕_ÊRIØŸ‡Vucýú`=tCéG.†Zv^ί¯0¹:uU§Rƒ°cÝà{ó4Ü® ­æ¾«ë¼ JRð:Êæ䀰­æ6ÝGÃæøU„« É.šwŽpKOëˆÏát²¬æ½u\yµôJ<yTq’¡í sI(x›K,fXi‰"V‡$ôKÃ[»üC«»~,!`F÷à¾-” Û+ÓhãnÁÊìï>ç¯Vv¸Ø¡Gô潕¸eWt#¶F÷5»TƒoÒy(mÚy(ƒô½ö\ðN(N)ëÃqâ9_¯ý÷G“æÜÄ+±fº}„'4Ç'm;1Ж.Ã@ïk{úëŸØ—û46}‰ñ¹…ÈñÙº˜3]m@Q¥…ô‡¹Üz!1„á@’yÊÒT¤lw9½í_m— €òlïmsö5²o&Nˆï0 \” ¾Óq…[©*Ó{èCMûzxò[LNÖê 0½€o-N~Çq¨ãТi!¡bDÄáD€Ïýü _Q¢2a)Ñò×0©FædÆÈí÷íJ@¯9¦Dÿ±3ÜèŒkÓ ´ç瀘s^o4¯¡ˆêÝ”ÄñÙjbáD¯@CËXNSˆ_›ñoÂéàÑêH¿vœ&ÀÎ8�n*²¨Uy‡2T4=–ØKó1{Bõx:3÷ÕQSØeè?ã:e ÷,‚í3ÿKôý¯|£Í¿O-•PÑ—†Ñ >Ø>T§ÆŒ¿aKRv”{rt‡z·âÒ\2£ÇŽ±¾ý¼týoÓþ·¯ÿûw<[Dˆ 3×lÒ;r©cOJ-šÒQš2¬"±¶8VY¹‡'.LÑ`yAAØòÑĆözC„Sï°ŒÛˤp9`3Ë¿OÞÙá£JnKQE”u'*øÅ:þoVÞ±Þ¸Â'MmFC¼Ú&F†ÆóÀjµÚdðªÈ‹ ßxê6w*SÇÖùzWt§Xì^]±ôÉR6o@En->šnÎù´Òª“Í'­ðŸI÷˜¥¾-‚ª×§ŠgsØoΊÃc?[Þºžl素˜* ghZ>ýäŠ>*”–Ö©£pº±…é]ËõT¥"/\qɱ§T¡hÓðª h”V4·:r˜Êÿݼ8Y¹ARsÎýSìýízÈv „‹³ÙQ (}ÕõìgV=xÚw(l?mùÍð ö{ʘU ÆK/?¾Øú‰Ê²È_Ãk :[X¿êko‡çëZÔë;W6«"vZf"SbÍ$u"?8¾GÓ® ÿ_íqÄ+\.ŽŸ l(‡Öj0õζËñÆiòųN W¦Èè‹ÎÍ?,Ôd$ïFäµ5+ŽÔ-7ÄçT_‡;|èKzºQ\¸&4kø^Gt¡ û†<@}~´�BãfÍ·ì¬�¾ª»6CBñno;YL±øSxÿоê"V¹š]0fÜÍš.æq0Ǻ¥5b]¡BNƽ~ÖêI»z6Òrq)(}Ñx¡qíCWÁ8ìêSÛßÆü—¨ˆIš;KäNàƒ6cgBd.£“—zŒ´)¤Áh¥¢ybCb›,R™Ëç¡ £v‘fÖé.b C¦âæöÉ¡©u¢;|j·¶-d¸/Pq³ÈÌr£sAeu™€àÂ{=íH(ø•ÂŸµhËrAaíùÓÓ‡æãXÐánlðHŒGúyRÄcn‡#W«¦Ï2Ðqžìßõ/ø®:Fˆ¢0o<�¾+úªv|‘KrØæö“7Ceß]ÝØKâ^¬$õj%=eFŽÔ¸âäË‚´U þ”UþÿŽÃFZ)ÿ¬`í÷dšÔ~ÁvzR•˜©½Ø”*<C h¯hoE\nÖB¼:H +~0Ñ~Rÿ�¦p¸áÉ.0+C˜Ø3?.xwJ‚ÒºaápÃßö­…Ët }­â»ŸŸªó&©   ónŠ®çÞ¤1³)gãÀòÌ~#îɵËn’:§‚Êç¬ ­Ûá¼(½Þ~ ,�{¥%ÝÝ/XB&s­ÌVàø+õ_ó%($ú£&+Y÷‚v]Vf¾Ðd‰J;£ûãkët­7' ®`“¼RS›Y¡•-.‚™ Þ¸þ´æ‚‚{Û~Ø”ìUãŸh=Ad*ZAï®t<žXAm_ -©ëüËÐã ”ªÓá&Ú7ïãuð0÷—¶ Å¿¬û¹~Ø«Ý7öT*¼ÇÀLM2²°Pð7ðy¦V²íñm×—æÚV2ËÎô¨¦Á{¤`lÎtìÑð÷»1°u’>ªé>Frò”ºO@P±j¾¬œÝx¢ÿËþolçEÛv`Õ’p¥Îˆ“O Wª^µ¾`Zåᮾ¸ÑÛk sqX­D$s–ÎH–ÖS츰¶mPð‹ôX'þ‹jýù“”†ã–F‡z:Y=Z®L)•‡ý—„À¢ÊWz¢xü(‚¨M3V›nãAZèrdÓ-¥°ÃHÇßYzÄΪP”g—©`p¬‘Îjy²W±á˜b„øçšÄvm‘`ê�˜¬F>¬ ¾­Röv¼@÷†÷¿¾®˜.ÃUï†íš½¾1Ã(ð–³x•IÑršÃnw÷J…dTd«é>·p¢ö¯g ‰þíÁ$q÷ý›ÿ©£ã‰ÓD¬t9Ltš'µuôÃÚÌ—5ÜÞ¡y}¤È™yxÛˆE>iM†Ã౉%mÇ£Mú€ ÛqöÅßGàÔh5,gáÓ,»ÎKôXÛþð·•ÖjËn·šx—ÝuhؽóF”¦pU_ÌÊšªAkØ3ç”a94·»ÃbdÖö«nì± ×náíuùCÅeóåf6LÙ{Þµ<ïÍO·)++kØæ댔±NêÉ*ŠC´éøÿ’xŒœ7JŽŠ#énÆ Œ?+ºŠ1ú5Ö(õeÜ¡M$ò q=»1öšá 2øžJg´ò[[Q¹Épix§˜ÄÇ'Ï0ÙƒI}¬™íÿ2OR­Æ…–‡b÷»GêZ¯‡¤ÌY}uãÃ8ö Lìl3´|óÍÕiÖ"Ë5èýôÜ>¿…³gcO'˜*µ&”Ÿ¾†]¬1ñóá1ÇI[÷™¤ô#?8ó8"?gOלÇœP4«w17äæ•©o¡Ç¥c(1´¨ÛÞcŒ±*Ž¢ÿ¢9mkMƒÔÌaÚŽF¬bð¹ìï©u¡ý/F,8àÈ<t«fårt´ü¹}wÃæ°ÍÙÒX¾\G:{*kœ›¬Öëþ>.ô£,³˜Q)X(~î•­Èc¬¶¾Hwâ ìfiüFt)¦”¹žrbeÃ:}gÊæ-0 ó¨V y¼fŒóÀM[j²ÈéY†í-ú´Z1P ÔÜt&Oï^¢Å¹B.ÑâbbNëÖxÍ#¤±‡*À›w¿ -sº3Œ=Æ„Š‘›rði¯.Iís?ŸN´æ‹êlз¯'YR8,›X鑾û„nv15P+¿˜v½}0°KVRªO¯#ԛϵǦ‰/™˜ÐS¡ÅI§iìòêt¹®@™•BeתlÛeAfY~¬°GÃUð~£ÉX_o=úÍwS=Ë,°qì®°ðÑXÁ»ã ^5ŒKÁÛ‰<dˈ˻_]®Ó­Kt±VÆ¥„¦¦�U³Ü\ò¤t¡G54RŸb8?\(»Úï䞣ÂeN¬~H8µÑH^h&a»ëC#wezM‰Úg†o:gLæˆí<í8\L›%úKH§k ¬9e°Òþˆ³ ÒõÍ¿r6—T@Ì_>RÈYôžüHIîsxßõ¬Põ: +M¬¨5«T¢YwZªzW_FG#íìßpBlVVÜßús;&hqÛÜÊè¥ÁH{‘œžo?ssÿgaö¤ÇJI_!t3¤A±û4á½àÎò²ÚV|Mt+/|5,œÃp µ‚�rãoïqŠéÏÏ©f¸ÀUg•+N\c)m¯³pð}Jç$WÅK†øb§•Ü’¹SFߎ£ôÓÊEì¼5] jÒlå km²ÊÔž)*¬–-Ñ´þkÇH¹Ûùíú¶Û]‡Þé:\ç͈óçÈ �¸1¯:Bùì"wœX¦ñË.8ÉwöX« C­þŸ·¡—ùgtAœÄîøá³bû§0`ÑÈqó©mX¾‘N…÷ãÑ_µOÙýQ¶V•AzC)µøQ5Œõ‡ÍïÒGYLŒj¹(ØÖÏJ!“—L”A{E´ÖïJóiÖ~R¸Qk:c›À¤ú£(jÓ*¬I¶»”º|Ýúv€ÅÐ�f<ɸ>{´SÍÈ_2X  †È{4ÖÚO©XyêX^b×ò•U»x5ùv\Õw‘†1/ßM­c<1 u»££%jÞ½àfÜåÓRþU³’ʯ Zq˜­ò|(½—Afm£ fci¼^cîüYO±’ƒòïý,3/ýi#ú ô•›³£çãl=z(‚Ëõ£u3°oDßÕª:ÖA{VzÚÝv¤,•¢ÄD,`X•ùmÝLknxÌ«®Wï†|YzcHI”ýÅtHÒÀ XÓ©];õšxƒ¶pûJm$=ïCsç=>ÜO$;²òãPÜÿ¢Û¼ì¼¤ÀˆÞ«fÄ ûþ5~æÏyÃåÄFµÙÛòdšJº¥ö³ þ¡†ž=~º «'ÚU¶·“›l« #Ýz6ñž’!ÜÂßÇId²ªž%AbãE„xwãOðÿ¦…m”E•øž¡ãW %¨“k4ÈÉÃ$ZOLA 9DG;qfíÒ[¦®HaÊåi¢#ÇÂ{9¡—vU0ã…š”+Û‘SíÓ$rŒ2ùÜ!ç¥áÙŸ!pr0° ´½ŒÖ 6ç¿ŠxÄíû&s;4‚g)Pzº×&µw�sµ‡N'±¿üƯ*õÞœUt/Cd'¥t¤a.@±z6®sœÂ|–Ë=’ã¨>à:SL�ö²C£n®âü)Zõúíޑ%•Fë‚á_¼›Í˜7 m¦'Ëv:ïÙ–B_·5¥NÛ:ëù‘YìëGR!Ò×JªsãÕ¶TÉ°@±¦+T©]þ{þ»Jbž_úÓ5Xß& _AO̺“Ǭœ‡öjyÌ¿§(Z„m)¬¾ÅìkÐô•g_ÆŒ~­*ùtžiÅÄ@4†}³2[s°•:D51Ö ÕZü¯Øì‹¢šÈ`g´ UÂl1œ¢ÓèI´YV�>Ñp¸³ò«N‰ ÓéÙL’¬ýš+|‡ hìT?bð;žIÉxm"Ãå³íUo>Û¢¿ (’@ÜæKƒQž«~¨Ü Oâê— 7÷Š7‰Ù0qh0ó³‘Þ5˜²ÕìæÇi×(åÎgmÞå}$÷L8Ø‚·0ߟ<å(dðÓò?ÝÁ()\ó,C8¿Ž)Xïº/!¯"#$zOž‚ÞŸSýQþãUÍ @(­‹¼÷ ¤úÃÌB) Ïuà¢8q�>«½ìÊ š•]Ȼґ¹ ÖƒÕ¥ÝMõvùnz\–&Nj¢NrÒNfü H½õ¢5M¦‡ŠÁ?ÚrV+†°– é;'ö¢’†{ˆ¿Øž­$Ê;Ö˵ •±#ÖlÚ�/Ÿz’`ªFgån“A&‰ ¨¾H™œ@Bm„b”«øØR‡1*áÁeÞ†U‡^(ÝSOP¼Z:”­±r™Ca´Q©o³Ù•xDú&O”é·<ûüò2[†§bœ… [¶k¯ãËbH"'N†Ž­²2H{í4@Çÿ·¾~Ÿð¦ÛÝ"Œ Oó*öÒâTð8�·¬×·™âÏemÊÅFÜ,~æd+æ½#ü¹‹ÓF™C©È•˜Öüy>à}ã\Jø ¿°å†bNî&ĬKËcðÆxG›0îÇy#ÝYö«â|E|ŒŒ,êx_bõL#02íÓˆ“ßÄög±Ò˜åëô:Æmn>¸ò4]Ì!ó!“õ*¤•d~óÎ{²¿P³R ÝCº(¦£À° 44]YECb<v¼ ‡•—U ”æÖ9•µ¦Í«¤BÒÐß µ‹ÜÉ&¢×_”ÖÉbA¬Ïóy$¿í•e‘yUp˜vg{̘Fâ™B(zç#QùÈ ­Ø,\™ÜŸƒVíY“<à°ƒÇz?Œý¡ÖŒËXiXè‘Aíim. 1X½~wiÅ�sßð1B«™öÜ»ZkÌíÅ FIé¡¿CR»‡ŽÆKmçl¥%HÊíD²Ž¸ÌÄå„mÿ´§y íGëiצÅtËp*\o=söÕ ƒj~wf·Ü'âÚØiªçÀ“Í…+52Ð×6nfˆf¿ó-Ê2ߌôÇþß­¦³|¥)@¸¦EaiI1§xGçaÌ÷‡ÙÅμ՟ 9ªú ˆ_Ôµ5FŽawCñÔgÌtĘ¯½Ä_€ó',1îØóLk£²6P­‘ñº[ìêh÷Ïïc˜Ï¡å9ÿöBÇßYû+ÈXY·›Û@œ8Õc¾ú#®‡WzŽžYƒë%F tž|9{ò'k.–+¹/Ü‘b�Í÷ΰžhd *óHúR…­?2H•Gp‹ô¸G|T+ =zÐìǘ}í]+Ã{ªI\'n®/ØÄ¿²d¬Üø{Šý\P±8”dÝ×óGmºr¾¼ã3ç\Q1 IWB¶¬ÐméÆèô°?Ôçïpt¾)jŠÏÙ,àm·vB{ž�á–=�ötÄýi­ï¶Ó®½Ô÷Ìs#Î<÷=Dúç3êä„Âœ™ ¦¼rì<¾|ä7ãq9 ¶ˆƒzR¯Ú´«-!å}Ÿñ8K÷ñåJn‘g¾‘T?(-çO²_º«õ-SMZß{FŽÿ�ä ]¦‹æîÅþw—H²Æ#Õu·áñåÝØT¶&²–ö#‹fHyÿ`n8ÌTM¶ƒN .›z—~ÅÖíUܶuTŸÊ=Àí|Ÿj7ÕSŒÈ£ Ûʼz¥`Ù× ÚíÆ)‡a²£¼í0]}Ù-´ýXÁZ«p%ÝÂDkŠ|;eDÓò§ÚSÒû?àO ©FÉN7Þ*œçô †iF *Å4³ªÍ—-Kß\wµ!á‚ÅÝ]':ášÝ¡ÿ݈½ž¦—ÒM£ä^”œÄ\ °¢£#×¼AÂUPÂZ#¡Ûy: Ü –TtÛ iÑ«l¨r×Âbt#ì"úΫcÕ¤h}«Ÿ¹¬œi˜{¶=ÒÚØXÓ+<ì ·ƒ#ceüKWzú!L-;&)•z‚E™”YªÎ2ÓŠAo›~^Í~¾)®|5±Er¾°¬ E[šÍÖ%“y—ÞÅZÚ6-|Æ+h›4(§‹³Çfâ Pñ&qÀO{½È?°úlë_®{þQQeNå ~ïÃõÙ+š &Ç4Ð ,‹;KÏ슼LDÒž²Îvà™ª¢m9å,(Êl¹»‹G¸ÇlŠèöm†÷ÞWlm/ýœ­—B-Lovrš¯:ÑæÜÀ‡Õ¨Yðçy]¶¦{q¿Â O÷zl˜ ÇA9œ\‡ dS ®†Ê·d©O}ë_>;<fnŽÍž$U£ªƒ9‹g]™ÝdN5q¾r´M[®zîwPÆ0uý¸Š-1©¾aˆYdÊ$âÈZ¶,ðc%~ö‹m:Wý½íÚÀy3xh°·§4†ËÛ'âgÎÄÎÔ=4ú\bèiåì1£ØÀeñŠã(Ó€ú…‰gY®º" ÷'A2iî•3ëžþ/få÷ œ‹£«×1Ûôõæú€Ým…‚Y^‘’‹ñ ‘ÒzL�å':ãrdšøðå~˜™Æߦ‚±%ŒâºdŽ‡Ÿm*âÜÁçVßüAN5_}jøÿð=tˆPa¿¨Ð¾í¦i<W;µõ‡wµ¦ÄEè£!êDcÒï`ñ.’ÅA]±Ðè~Í"ž#Ö“›,(98FEzP›|¼ÑÿéÄ‘/éLÛ Žõ©ºŽô,Íë(æ·”ÓÌÒD¼›?ZŒøE`ú9;0ƒWZ2*¥÷N&÷“ÍÍÉÔåvqK _‰âL×Ënq,ƒñÕ6¸7ÚêßɬW+±M™Jj)øŒâ­Ê@òØà‰3 ¡¼bî5Ù©,ô§<´ÝOcB‰ã&Q|°j‘8@«Ë¾*ú‚âÿæ'ÄRYÛí¦ B›x # |zmƒ0ÏXÔÃ]Ñfj›ã™ö’ˆN:DE¹VV§z©),žÞ=êŸ ?ü]ÛÐFmñ–p9+/žcÕ»¯Lê) hˆÿ·Á‹YNùy“Ó¹õéø¤n=ª Žx=>ÌÕ3jEêå¾.ЄŽ#3°ÔCˆ@“¯¿k~?Õ‹C¿Ï±©&|yd'_ ÀÜa‘å¼K¦Ø¹Œ˜é00ºÍë·çÌŠšúÏÆd'ÿhs›{,ÉȨ±‡FÇQG û¬hŸ¡B€~ÌÛøæGåºEÞþJ …:j”Cˈ?³b§)}Ù7*<{^ º‘pCý÷ì¡öè³`N ηY,ÓyVRZXè`Ô®zM±ú&ýö ÏÓ¦‡*¨¾4—9Ÿƒ°3ÔOI_{ñ&EåÛ×aâF»;À&M‡ýäÖræÆ¿|ê'ášÎ™$S²Ty§µSG»¾¶4((¡ßzäfÏ…­YñaÿÑ™=Íoö–9†+ðFñ+˜dÕ⨑n¢›Ï}Á/q ®š0Z­)'¹ôÁå+=ËÖmT:ìþÂeqœºÕŸ 7Ù`¯ZègºEj‰À®¥«¤€²ÔŸ]VŒ¾¯±Bïÿ¬ºAôy÷㌠eð†8Oòqb£ŽBÏ…¹¹2Ä3ZþAÑ-ÞÐgƒuïìmmú¥öu䤻#FDœ©RÚa»Ud˜•VŽ Ù ˆÍ+7Wç¦Ta¸jÏF\¾eíÆ+ߨRþðදL[Ø«ÁJB޺̓С¥±_ÍTÅ£¼À‹ô_}2mÛ#6&?§ƒ÷ÏÖ›M~ðÈ?ìñËÿßÿw~ë¯Ãðü3 êç­'¡EŒ‰‹EíÀá'µF`Ëvì)ó<윶ãâ.(æÅ*OeýÔ(|Ö*lè#ïv욪wì/%¢¤ò>@C¬B{ÑSnt½ù–Æùë*´‘ja;y¢rkî<ì¿êU*Î÷! è[lÿc¡åÁr¡=[¡_é>\¬*óm8ë_¾jäë³ë`˜Ùƒ{VØ2;Ó§³séÍȹÊúåqÇŠE[„ƒj`ļùÿeÐòBÊv¸<8þIðÂJX:AÓ”+* g2 ˜Ó‡*h;° çC™Þ[Ñ^Ëù”–7úýLw%ßtvU Æ—K! Ð8 oЯ\Ìàå¾=a#y´œ¹5}¤!%0°hžIÇǩηŽWÍ o~æq¤á»ë7ÉWbAQ$Ãá¸~÷zœèí"í’mðóL¸(ü½Ó{BpüÓZT+QûXEß¾Þ°ÿS7æaÒñ#-ÿ¯EÕ.‘X²A:Ø »ìŠ¥¹áï|EzôþåàÓ§‘îR• ŒÉÚé:/—+¸[JŠšÃþ€ŒÑ]`ìâAŽ#¬kö$µ3ò+E¶!OXß÷ýEø´ “ÇÝ:x€E¬'(ä§Å‡üÜ3âÛûî6ShrŽkÕ9£ÜpþàDªü_ôãTå͈„E¦mÝ*Œ‡ºß×–º­ÆÅtÚQ¡Ñl¡ñS3;÷eüuæ Ý›rj<Â%¥êÛ0ßNe _:NJ8‡£ÏÚÚr‰º¼ÊC¤Ðûv¶3P‡Ç=›Ÿžª\ÚFSTÑÔå³ BRû·ká=Š›{£ÿ4ìç•"r:×·-Vœ/Ü#J"â¿'£"[ÆtÇAM’\i“±–Ê‹´Ô,ö]˜™ÅCŸ?´²9M‡#~ o;7{ÃéÙ73¤«?'aî"š?b ¥n¦ÊŒÎö š²;“H1bhmñôÛ¨f™ªpëwßcT5{ÎR7ÊåC;Ŭ79ýv¼R gÍh§¤ƒÂãpuÏ¥‹:ƒbF‡9³þ”OÉ ß>“EGª µº’)q&(ìš{ñ?HDÿIK1®Ãsë 8;ù`acË+NJU<v.n~}ób“V£ÉõµÊ¶Á×o¼xV=ÜÇEððº5Þ>†ÌÝ °V=œÔ‡H 2I|‰.·<£2u„)VcÿX¨îú´>˜™k„ãíHÊþåúÆ>KÎ,z;1\í.EìÜ{âÀ,Âî†gàohQ¼JfuZ–‘ÊÂÑö Nɬ°³vçéo{£/M?ˆà݋ŽÒ› À–v°qqsV9ßR»9]Qz‡éåÃí³ßz(# "¢œz7xg¨ñDgE‡íxÙ–‘©Yú’KUpØ—”“jC$ÞŒÄòÍÎÕ`ÝŒŸJÉ{àš°4Œñ+©Ì4]x—G1M X°FÔ(òJ`ó§/ëILUù:0! Ò†Aú®s/Àݥƕ ÅG­{kCã¶Ý Ø['Z®·zc#"¦DÈ+eÐõ[ñÞ*òµ½é$>R(=kiwd ùÍÕ¿@|Ÿ-Eß°ý~¯âÂwiðµ'Ö°æĨT©ÖáÜn3öŒ‡ï^WÅdêÆ×ØmdçO„EcŸy:xÿ xLrGj…Ì–qµŸ\ó{n‡aT{ÜÀÖ"?z):¬P¬Ä&þ2š|¡6�àM*Gïû×/Sz˜ –¾è©º)Z+”‰CèÐ8¢³íûÑŠZ• M 5¡˜‹YâÉN#Þ×a×6f ·M{¾Ó™K€²±Â"¡A8GCï8ú¶v¤’ß¡›W&Œ"!~¢÷Ì÷ÚðÊ23›·Ç÷‡Z_ÆZÊ_™…çJÊR(Ûñ‰¥?1â»ÝYÇšþJ‘ Gl®ð§o^?€ÒÕ>ƒÌ.y¿j—€@Ä­•Í}£‘UišYÕVÖ· €Ñ)a7)½ì3Õ©›25T·ÈnÝ6—œÑ·ŽàTC-'Êom ’0¿œE^”í4ìôÔ‚ƒ.§¬î'nm½ªÎ[…«¹90"YP°[y¤nåÞ²ºHô5—®ïä„c_d¬>>€¿Ü]‰Î w\¥‚Ò["6BtB¤l†ŽdV¦'¼}¯td_gùϨ_0hiÚÞŠÔÛ¶ã"¢oé »Ñøªß†>\Gµu±4zv'âtÓS½WÍ#‹öIMÂ1 Š"ïn ¾k§A“Äi<Š¥Œy}®ê9ÖJÿ±ý*X(Ѿ¯¿Ê*nêK“Ž‡ªŽ¹'»ÇŒìÍSØêÛU\þœÚÁCMÜàþÞ7ÎV¸Þ*h†"ÈëÎ}‹íx:¶6pwÆÛïEž¾ˆ–ï1!äV“e½¦çõì­›z–Ô¢îšCpÓâŽúñ%qµ€àÄ65dZZÏVÊšÏHÜô�j›­›CŽNŠëwÂTeìC¹ØøÒÈ ÆV§F´Œ~Hí!ˆ~'Š×Î1dÄ‚¨ÓNÚËø#ÒæP©5¾“ î°ßì[ŠŒ5Úv-†WðrŸ¿lÀÂ÷‡Ñòªÿ§‚5R€Œ,!!‡öbµÐ˜½©}ð#e“¿"uf#A<ÝÄXZj&y\óT¨#ÙžöÖsxS¯l?i•ÑŽÉ‡‹Sñ ‘Åŧ…ËX¼*õåBˆ3ðŽ)µžÇ)LﶓæUÝv§ÃòËíbGê¡xþæAÝÓ× ?µ•Y!I¤•/SEi˜êηTP^®ôpí¸•e(╘lÌTO‚žïLé…L£˜HúÞýÎNsCFžÒé°¯icz™¥qŒ"CˆC:4ù­ðšSzQ«×ùðµn˜êëP[‰�Ó0ݶVµ]N؈>êmF8!N»,aiÊhP…D!âGî±ï~#I©â8Q¡–+”«oþšÛ&ìºzR†HzYY ¡tª雉Ñ‹MÈÄÓA®xî¾þºŽ*¸L™œîÃl,DjöfFXš&Õ¾qÝ%´æçÑ N@½A!ðNÕäGždœUaVÚ†0èjŸÅ`çiñ€ûiœé é_²`Ïeœ ¼i^@é6Ì¢Êôaús$Öu*«—íY=ô3O¼ýƒVá ûžÞ·ñ‘Ò›¾„õß–ßmæ†RôåAÛÔwu-°f.s„ïƒm› ‹ƒ¿((ìœÙX9þ'²üø¨Š†pôÐZ”DLë<¿Õ”ÀW€õŸi¼#GoÐÈàõxlû§Yî<"}·È"Yµ½˜¿Yä>†–ûýp£Q»žL<#1$ÞqÃØAÓ-·¼«l•ã˜Êp=:Ú>á˜Á¸rY-CŸEG%40óÏÖefçúø§žÓ”nïÐR ò ŸY:m¡Á³kè½;íµƒ>¤õÜöÎú/ã²bm†ŠâÇý»å­B jiR(Y^-Ê“Ûï ùøÏYâ­#6Q}!7´Ë¤bzòVî-#‹»ã0´’‚ã*±p¦8Qú Ocda#OÁ _u‰vè©/‚xÿ×Ë„ùr†o¶úïþB¹ÎOÁÌ”9 ’açU|Ž�¦ºc“ XèU¯´(u"·,\=ì!ÈlÞ)Œ#;Gÿ§¸3,²{Ì…œø,\Þ´r“̃oÂÕ±@eÔa ã!ð²Q…ø©ýâpóªå¥úÎU¹£[ñZÖ”…p^q%S毅nŒ>ÇýÚ&‰ƒ>r‚°Lyvƒ™Ïça¸:V+¤qëáij+ÿúãÍõd23P®²j&ßë†>ŒXÉ# ×Ö²ø\eäI!ˆÇM¶hóÎþ@†?º»!~s{lÇÞ?·?ŠÊ {ÔmW틵Pˆ:{8ÞˆûúáDø‡`–¦«–V=`Ëìg™^ö=aì¡ý0õ{š÷‹(¾'MQ—2È—yÆbˆ³‚E„ªf>Ÿ÷Ùµ=XÜ÷‡ˆ¯²‡ü¦¢ý_íŪ!Ÿ`ÛФ©D:l6®I³H¦~g›Éj W Áq tp3Ú7Q¦t?õ ÈÂÌn'4VXï¸rÄNý¢JÎ8.ÿ:í¶ôh;-›&</þÑAÅ׺šý D“†Eæä·Ð߬!iÙ¿{Þhì2v¸“íåÈ£Q¦�/u¿�‚¦É÷¿ÁÃÌ|yÊ3ögúá»5§gDò×l/h0|³N‡I�ªg…Ž<¹Ð­H®£˜8kw §ªùØ–<áòxJ]í¶ZY/eòjUi+ ‰`ù©:ã¨Ù�NùåR ¥…kK¼ž:¸Š˜â 3AÕ\ô©9Õvœ¯oï„=üË÷µÎÔNÚcÿ"–©{ªÀy+¼Òz~?yZô÷ÞÌîÙ¤®_t9šλŒTÜÆs¥AwB»PýN ­@™7<Í·¨‚ÆshÖÂÅøF8/L/¿=Kò$µ®7“[EaO-ä¾UäñåB’Èë°33d˜ Ð{òüZ¸2{ƒoàŠàï›G1J͸jÓ% @½¬`ÀÌÿ1}•ö÷Í¡#Øm Ò»€_R~iC¹Ð±CÂDéô’8ñzZ,°-qOÔ³®wr¦"¿¿Ðµ’ÆoX%e så$È$b‹‚bìyøò&š(ÿ s.#ïœ ñ˜Ù×0±VT°YBeÌp!ýI¶wß^~08L“̳ ¤g<uô´ã©µøFQº²[Vª<¥É*(‚ÕM{çPõØ©*Ép‚Øi8²‚Žç’“µÀÊ™a$N ˜…ZUæq¤ºßÿ×ÓvsP¿ aÖjðÝ€Bóç*&ð´1A֯Šۤö×i‡ñipîOƒö1]¥ÿí¼ž­~_®fY´>­>g¯ÏÔÕ—áÒ˜Œu¸ˆ–¿Å/Êé ™Ç:å(è–;N8¤P¶kO_K¼“ÅU‡vìÆ“Íeãó ßp^S@½b^ô¶73}øbRÑ|Z¿è”Ê‘rªÏ½_ä°_4>…,.Fi¯ÿÛÿ( „Ì“ã C¢. ´CŠ WãbCÙJ¸Ý9ˆ>/|<6à$)¡û0ÀŠõO÷ÊR\ó´sÂ+u#{Fó…r3_zÜ©*§m‘ whv&;yë`ïCŸß�q2åÅkóÇ�a0œù:Z6Q‰á¼AeÙ{òÃÙ4”§¶áÎÎÂ|±Á1 Pey”>ñt„¨å¬Á„;ýž,-†]Ýo]Ÿ²†ëlþ…Y(�…î"\鈋Ø"ÜNì6äKœ„aX,÷ ‡’ümû»À[IÏ´ö#ogvÕË^©D¢]jÙ€pߎ5—6»X @ žÎÓ†NYwFÖ2N‹¯¥¦Óå]©hÜRékOW‘Xfé'™-) = ÜèR¿w¦Š‰¥4½äÄp?óãf#iž”†·kc«_|`~ôBKôŸ¸Œ\®Àãª}ŸåAµùëñøÝ€tÓ‹Ñ)–:LÐ/f†t3W´;­j\f$uO-Ò‘/EAÄÌ èÓ[.‡E°Šh‡™léŸX>QêéÍ0s~ûâX Î>Òÿ-Tf€;êué䙨t Ü× „^ P%Qi‹+œôm¸];y4gòÇ7rhÚZ*Ÿã±­Ç…×]ÃZxM¼ätä4VÎ 1ë²_&7TsW²%íý8H'ÛI«*Ø ¥“f¶»þüšû§o¶Î½:`KóÏE#Ôô(Rôv¾ó^zaÍ{õé$\Ìß È€ÓŸv}i>N¥»c§[¾ð”ÀmsGñ ÜãýüTXmûå< µý3'"JÔt;3X¶Sål¹E9ýáKÇ|ÿœžé…ÑͲP( 7�ñûG‰6¿Ö?=§ûÞ…SGʈvƒÙ†–Ê%Ñ=)ƒ âûtÁ4Pœä^Á, ÙÇ—ðâIeä“ûŽÚe“¶]ûJŠ’#›~ÿ &—zT»ˆ·Ü'zwòtS ª]ËýȹÜË4wí+Åœš©´¥OÝ)ÎÇ„4 Wí¯çì‰ê½†ª Ü(UscêÖdá6‰±R¿Ð·\ýuIÓ,Î+çÞ=t}#cªs0§ Ÿºù®Óëµ|w#6j¾Û í¨zp@[AâC 3¶'Û^Z«¹ÈÙÀÍOfÞf•Â!OÔ–Aú9y6\ DÃÞgº­3Cµ]ÝCO«Ì×;OÄ×xÞ;¦ï¾¦?³~œ•]E¥{ÿÆMœ_Q½2-ï3ÅæTDÍÎwʘzU¨ßÐjOhÓönJ 5åcñº(‹Vâx¹¨úU½‚ Ɖ® »’mq#¥qþ ™?¦g.´¦ ¶Ò†¾Xue˜-™Š\ÚŸhx]µï©­‰'^Ê„ßfH² èU,:n?ŽóFQ9[˜M°žÐì'š«™Ê³ßSZ¥=/¡†Qõ±TAÔy&àð%P­žÖÖ�þõkDŠÜ c TE½[¤#ò—º_ɘ°¦ r7Ê}{ÙÕ¯ìÅ}øRd¡”;¬+MßnP�ž¼ŽÄ¼¶Uït°öLxñFr<oR-ÖÕ/xn¨+8Oœ•ÙÙj~ʬR¤ˆg\'JO‡uiÿýèŒcÓ ±%ûÆ“O]4¤ m?ž®½^u,Vý0Š+Ë ØÒΣ÷A‰¾¾±™ˆåû¿  qƒL¦ãmž‹ Ù´Ö{ÞæÚ´Bj±^1˜>ɘ-àMQ±F4#ãz4?=Ýc:Ï!™VŠæ±tJÙlZ•Bãܳ »;Ö^‡Ž±¶YŒs¾Ü©–`[Q\Ý;÷mm\ˆßæSýTÍ,uˆ–D¡í öÓ¼­ô‘ͦ´9¼¾E#Z+qæ«Fžzú99»IæuE0[êÕgº|_XÒÇQxã1A<ÿä#”ÁìüL~zšA'eæO# E Žé{ëΕ55âVû“Ï¿wÃÑ,\ s…‘qÿ±ÒÔH·˜¹è+æ? *£õÕÃí¹V°eašôçö,å/O²n®œÇðÊƆ[¶p=0Þ¦æë?&_ƶ¡Å<ŠËsA_q§SÂcˆžÖTŠØ{EʱZá“À½˜(ë­, 2lã-mÜ ‘¬ª-szÝΑÇvaiæ(„B™GäPèXsoóž´<Ùy ÆòõCSã3ÝíQb(ô2 Uz‰Ÿ³2hÄG”}v8?rW÷lÙ( ]ñZŠÆØ“Äý8à<¢jÂÚ×ÍA²9åú W*r^ ÆÒƒÛ†À•)ÜéÅSíéñ…8§^]<AQE¹ò°s¥²ïÐà9zœOÒnßÖ”»º…sFB"ö,ã¶Uô§Î×gÃH›²†_`ÍÞ«¿-L ã÷;Ò[¤»Ù3Ô¼¶îšË±.f.lânä4n;þ{QÆH%T6úu„ªäyX1ò|Ihdz9ѯÁ8oê¾áð~oRžxÀ©ˆ‘ (6ƒÓ2 à8¬–ôåVÅNÁSSði«ÓÕvMÓiÞåeª¯\#ÆG¶-.Õs3TT=ïMáÑ)+Ë_؉7ú_ê&g¥kÉ2&nCµrfaÝòÔº¹jàزÞý‡Ek’‘ wóæ0]É´²9WÕktŠM2Á§vXž[«¤'F]Î 39èaŸñI{bcýáÕÎ’v„Pÿض§C»U½sÊBq„ƒôtÝÿ _Õb¼¥ËÙÊ?´§öÖõq¼�Câ±~Ͻm65ô%—‘òPm:ÌÜåµ#)£P½~¹¿KQì2õ9BÝSÐízá@œÖRKåÿø å Ž¤!âøÜ-0󧱘1QbV8J þN{pDô_¨ñ¦¡Ï½¤BMè.ËÙ4X–èÚ<Þå/‘ûþDH°H=m²lz7Õá‘¥ h¹×ìn|T‚¶Q”÷?2þ\Ú9úOâ­ØX¤ èA/g8Þ_/ø_¨!®]ÉÐ'm©Më#ep`—ê ­ [¾†ôGT›>ÙœãÇ-XÜ|“ÃÛ‹ï3ü¨(]ÈHeOðO1C#žÍ÷æ#cÕÕ?lÙýúò úÚWÊaÉûÉBž“ ÊÙzbSKùjÀ�0Õ.cS³cŽ'ûV°±àE()¨môÿ­„ÒºGen_éC&™GÆ@û‘ΫèË …€p´ÛÅÒˆ~׳Š½¦+ýb)Æ¥ðÕˆM8¥Ë`?6 í+KVÃÚúŸ–¥ñɱ΀5pú=™3þö Œd«;íý°.ß_(Þ¤1Áù ·—ì•Vw¿ÀŽV^Ƨ@Rëø1ƒZÅ}®yŒƒ>Ãfb¬Ñ©â[Anô‡}ÄVà F#m3Ô®õúÂ?]: ¹ÔGŽÐÆbòp2©›fÌ20G÷ø`y<¬~Ñ2,‰x^]Ò¹¯  Ì rºÞÊY(.ä"k)à£_I�Ð#»õ;K7¤¥(sêcß{‰“sSSš‰¥›¹ˆFLíá¯éX*2ß#{²‹!¢ú×oâ×ó8ˆu;6lÙȽˆÓYFOð0vxÂçvŠZšq§€í¬ôqlV3l0šUƒô_ïuàŠl-ë’S%«¡YãÔˆkÄ< Sd(š_—hGÿ)ÒµÌnE'6­0h É߀’&ýAÉü-‹ãä›{mG™œA/ŒsüC³:¹©Þ½®+kýÁ þÔþdŒþ¶pXá/`˜é?‰ÿgš°D˜ÿtÆ ä`Ët8O]Ý{ä×_Áþ-öOäqHª°”‹;äü¼{L>î¿ãIJÕbŠ0†ƒÊŠ­¥ÆÎP,¯0m²ng�:-F"ñ;±¦Ò•@Ø 1ÀºTéž+RVä 7£X¢z¶—šaŸ·¯­u®%ÿ@ÙwÕ®¼ì'ÀPJìÅ:½ßÿ m³ÊxèTjUq„Ãgç¡jÌh›C¯ÔéÐs#J\hì¾â«’ž!ÅÝ”å§Ê€R"0]Y#x¶°â¾‡Á�¡íå„ù0ó¦¬@‡Ab-µ¡2 „ ÿ]ÝÔ‘bÃ*Ý´¯ÉóŠgúëW½:“vFA•1ÚÌ`{ì[U)Ž™¡¯r–`ŠáÎ,Õÿ–¤ñ (2w+”Ú#3o¡W-Ýéÿ{K”ÁòPˆåýöw€¾xy¸’+ƒyH‚tÞy*llèÄ\¥Â$†‹yMø3ÜfÕ{ïW/ÂLN*n FýHvÍçª&†S�ˆ¶üCGðÚu*qÅRÊdÔ‚VÚÜ{çê;þ¾æüôÉÛ.£_tñ,EXAå:Ò?iÿ醃f»˜ø8Еž3ƒ…ÿ'$y˜ù‚‹èVÐÿŸµÚƒk„ù¼¶Ìü-I¢¬V6¸ÐTqÜãö@‹D„íM«O®{ÁT¾€èŒCof •?ôXéŒ?ŸÜÜjÇ‚R³ŽêY¨ÅÌ8¹FÜ€ñHú"½’™¡ëKGì‹î@oâ‹«µl7ö,–M_gÆöﵶ½=×ñÙ“›¦û–IN¶½p“¶íö�ÓQ“•PZËÝ[Zý0QÅ4¿;Áí¾y™f¡ ˜v‹QÛ{Ôøü¦Ç7„ÏM¥%$,€rR¦N8ìî³»jÎ  ½]&•Wë±ùÍö >•¬Ã\m½c6ðtÞo®æß›¹“knpC JO•B›Å£FìÆóôF‡.g©yDÀÁ¤ÕòùžJ%ÙÊÕl:äú©å³Z%%uÓremzF}ïÄI lÙSÈy¦§–örDPÖt8•AbaÊì.ÖÎnÐl ŠÀò®ÏKë•©Gµñ‹ÖJtiMÎ�‡ì’ùBQÍHÒÇE"´…¸ÄSOáüEpë£�p±´WÄ.@V›ÖŸRvÜ,LÀ«j¡q蛘°¦B¤Ãިвýg;Ó‘nFW š¬'ÇËK! Ìö:ñ’1™Ü8øýQï_Šs»×­—¹äæjËÈuöUT}äûµ€\æ„á–±µ:ž·tj)%«½a+=cµ‡¡¯DVpãŠYÉ)ÔÓ†eÿÕ:…v £\.uÃ;ÁÎŒd“¬M n~„Ïw®ñ°Û?À75ڶƄÊQ) jkº£’?Yâøzèüâ Ú÷-ªÔi/ù´ŠÅ9O³™\a6g#EäË>{.ݨL/µÝFWŠˆv§MùDTÉÖœæY;vócÚ¾¦sˆã†¬ãà8ä`+o ‰‘V=:Î7¦Z@÷hÈ<ñ½¢(¬lGú´›O_(th™o~+ÐCGïªÊØë�2S‰íUós’u›Z„¦ý’í{®µ Y‘qo¡¬˜ »ËkrTo‹¶ÕtlÉáÜ·£j¥ôIÑÝ Ë¿Á£¢ä4zÎ8/J²ŽqM÷B—€:Ÿ7V®1¦ÄL½Í›sÿ¡,÷¶Ý`û¿àö®þöv¡kU'ãe ðå|o<Q\úÒGÍRÑ!¸“é<°£\'ÆBæŇ´ˆËO,;zßAž•лñ‹òEã.TˆV?—©¥/¤/‘ÉZ'ä9…ÕÆNA¥u gU"‘]xÛo˜ú2Y!-W05º]]…M‡T^έôd‚©}ê³fÁ·lNÄêPm„µ>Vàbé),(Ó>vºË#Lœ®úâuÕ„VM!òp‚jhrf[¸Ÿ©Îfß´´ÊiÏyº[ÕaÊ‚ú[:Ë®¢u­xg®òCÕÕòÍT_9Ë~H…JŽÏóbÐàz­þÐ>?‡i«7ßüJ^‡ùCÐIbCဪҾ¾<ö&+V[¢",»ÚWõdm‘ßé­¸Qä“(´lm[s¬:îß«†å ‡ß ÒZýd‘OŠQIñ·ž–nŸ˜ãÌ(f28èD%â'eU'cÀdzXTO‘%ÁB¦Ë݊ƨº™Ùç4åÐX¿Þ¯‹ªàz!gJŠwWÌ‹RM~ŒÓî?U§U¹rÚ„€¡r¯Ož]e¶#¶¹|÷ ðŽè»„”Ù••å·^Áèç¼Qî[ËÈæŸjnȨHšdgÚíñ°·¼{>ù¬À• <¬†^4þé¬Mî)©hÐ/í° -ž`Ÿ…E"!7d{óãÒ¶ÌëtN"ii8­¹ñç™ìæäTƒ‘¯0Vôÿ©läÑ÷TŒ®o¹èNž¡ç{=ý9H yØE4Lê^0«/§³¾<‡Ö¨Á tPó/ä lut¼׆íë–JôÄ}ÒÊQY‰H°/Í÷Scà4o{Xw¨¬ú¯!0–lg`Ž!FUPvjkx‡eí‘ŸÍZétûØZäJ#4L|^UŒÔ’õlÑFõ߀‡Q½·…`+öœê@ú½¤%’p&H[¤yg2Ëźa»eS€ý†4ÅÉJ5¼ æ<¡ãfc²) #Ø$×B±)Ó–dy›ñBõ?+Ó"þØ«¥¬E´gÿ6 8õ'§Åé X`rÜ~p�éÐ^„æ®Ä2?S¤®ë‰roDKï‘’!‘þ£ mèõ&6úóGf…zÆ™¥„ѽ>Þ 2ÿü*ç »sßLÊV'UÅï°_¢¿™¡ÌN”_±¼bQÂP€IúY;Z©© qsç–}âPv¶Ç.ï~;ûyü[oT²ÎÓ–)E ß‘[šô˜>ç86L…}%JÒ•*š[-y“ÖÍ,-ÏB þIn†î!ÆE&¹:¢ïw¨p5øba›(‘§4o¨¿1ÄêZºq´?Ñ# ‡ ò°~GˆÒé¿cžÛ™­T0'‹³ï‡q¯vJ ¯}šŠ2>=åVeÑxº‚zv¥xWý³(~‘¯œÊ`C»9ÓR( j š¥õøòΕ2ŸHéB©IMŠ ü켆3ªRÑäù¿7 ˆOgÖÕþ“p”Þ$`üi˜—.|0A“¨¼6æKc,O7êíú¶\¦•ÑïE‰loªÓ}$»³ù[‰¬ôa`ç(Iºæå16r-½Œq† i×y©äÌñÊAšÃÜ Ø‹í$¨V¢¶åœ:íuVšÿ¦ó¤ÃŽõUÜ‘ô=³?Jª8s'iTjÆÆÂÝ3ž.ËðÉð&îù/½2Œ+ãv†Ð’×¾yŒ¢®-äûØ’$VDðÒ0GÈ»wó,ÑëºV^÷[$™R>âC,í4iÆ&Gcú fÉšY~s˜Åv¬›­—\!â÷¿.U}?o}«ø•`B NcëX#}$Ê"Sug&øS0¥Ìd÷efªÌh]©acÓö‡m­bž@ÛFêÑ• ¬) ©úfÃ-t­RÄܾÞÓEÖˆú ×Yˆ±íðËL‰{­&ø‹ð\A4}ŒÛ½æ¼òͺAÙX:mª–V®W†½¿±=¸sA°Nb›*¨^,)9±ö\E^³B=ª9é¤ü †¢(Œ®„ŠÅ—2»½ZÔñ8Úlÿ÷–êÌ<¢Gwy33Ãâ¥Ï,'¾½¢;;ÌH ïÇæ•ë¼”XY=BpxÒù#«ã‰ñÆdP¡9C7ÊK¸3[<«êM§4õF¦Tëð5”þ±mÞÚ?5$çàz…ìW·î•42`‡'p-«ß8V�½ŸÇÙ½¶ÜQÃ×|`#ØiÙ“ð•]’Õµö¦ñr”XMØcx´·¯¹ÒyzªP:h@’¨w^xCǦ¼˜#QX‚ô›aB®á"½mûz—ꦡO#Ù^³ ¢Æ¡O+!/™Nœ¡—ŽÒŽËÌ^8`\jN×Yr#]û ºdq­+ÆCÍ2Ðf²üé8;°Â‹ä†Da\¹)YNm,²Ò‰v,x©Âp”Å~À4ì0ð q“ù£ÝsÆøÞíQxôÁ–“u”mïI!Óî„·1ƒïy²ÀsÊ#=¢Ãi%{G3ÐùÓ“úÇ¡U°gß éúîÕÓuâ½CK±i‹,(šEc0mCÿá1'é¾Ãf˼0 å^BJ¨“.ߪØg£Ìo©]ße5¤ÛîÀª‡ãîâ¡ä\âªgnãbcm"K€1ÙÄw§¼ÞWžÜ&+Ž×}ÃÅ£’nF:uæ~i{®ÑYŸðe½þ"ô†¦ŽÂ¯½ïm Õõ³?O5~-T<kJ"¯¸â4Óù—¿ëT,+<Á)»mÎÓÎÈø�%*ýËæõ¦Ü£•díÅZ�ò ²»%Ò¥´S‹‰þz‰ä¨¦d£¢™nDå ñ8«Ï�yhÜŸsû£F‡6–f¿I&Ûì½ÅAçüÁ›±ý”Ç®fÜ|h°‡ûÎa>{£FáÝt( žrp2å熇Ñ5¥ñõ‰L¨»ðÝ´=U¨b[õ6/OB߃« Û—!V!½í$&DPª`×S(IW˜2ƒ¬7ÒQúéöeæêJ1¾MØzª¬ß=©;±G†SO¬§’»A›´¶-jžýu¦ >eP5)õùI`ÄÐqãÈP°Ùö+î6ž);Ý|+©ó{·¯ÈgH¢A áÔ[®•Q(!lŽûlt—®$Æè¡v'Ú9ÕûÆÛ4'¦“˜ã÷†Ë j.•#2¬N ÅM+ôœ²n};ÕV:â5ù~{¾[œ¡-B ¯wú!6 aݘԧôШLCÇÞä&[Ã"G~©®ÎÐIæ ç&íK?O:¡®‘™•Î’�M—– Ä¡QÛ“K©\7ëùètdAš< ´¤Oò ûúò�º”׊ òöÉÇ0^•¹Ú0ho‚VN ŸÞªÕÖdÖÎÈ<’ÜOó4 oæ¼ »×j‘ fˆ!$,ƒÀ XÀ^ëó )½ä42³@ƒêö¿ð‚÷ °Ù‡4(§ÙõWµ¼5 R×9~åÚÑjBonAÇ|K©³=2â2dÜÆ]U¢Oi¨‰7ÎÆZG $úòU@>Ïm;˜'Ù/7/ß :âýC!°©Ë j;W˜ ¦YÖ̓éðÍ)”'>ã ”%Ì‹Aç-¸‡òáÃþ”‘)š#S3Ÿ’óJù e)…‚kØ?Î}¡óNH¶ëÄüÑö=Pox”ÛË8)2 +»dÚ-Ñ;V–¶‰+º¢ËÎÛhm:òhBòݬDq¡îÇ¥ŽƒâÓŽB.n®˜WÙ§§;¼žª·?¬=ldèÛc”ÖY�Rë #5zÁ÷z{= d~¥/šíeÞ€D,ŸzŠ¥¶¥”…Œ(¢ÝüÆÆ”ÆOhÕWyyÜ¿ôÈÙ"‡¸Á°¨œ¬”3®4`0 Á�¦nÎÓŠiý'ÎâÈ¥¢ÚFA±×.½çu™Ñcß@¬´=bxwdþÏ^QUâóŠ(wlê„Ò´Åm¹’WãNÄ[)Õ5½ÏÞ,aàÁІ°ý¯,Ö‚Ú+£›L[»¿º7ÆÈu±ø,A•ëÝåïn¶Õ+‰”Ì YÕ¤>™Æ%—ÒÈL]÷o‚gû•’j–û:Ö–’6½uÏB¤õg4ªñ? Ejh†â åTãp¨ñÆo±ÆÒmßð(aì[Qýý·Áx¹ªs ;Cáìsð¸8àèÈ4[ôÈPôY©§ÿ4p³&qL”§íÅ êÓ—/‚i²'ªû õÂK‰ŸÀf@©5o8èb4.ùnâ‘»jïòÒŠÔæÚN4Ëü'EÿئA>iwÏ夆–SN¥ñ#™E»Ê(ê¬Sd³-!Ðnß_Öës‹oÊ·ûb8²l©&7€DéH-^'› °"�&B<ŸÍ(.TÊ¿8p*Ë5Æ—ƒèˆš3×n¸Î3ÀÊR3<Óî/8íédvû¯Í‘˜6ǦIƒÊÎ{Ð"wŠ;ÖJ§1ÙÛ‹û 1׈=”Òzã$¯!rÐZ-•þŒ½À7ýkÚ» €½ÛReá«,2†4¢“vT°‘âªq*\D–ög}]_ §ïsO«Ùs Ú^÷¬#jÀ©"çÞë¢ü™¹Ïåá훧(g÷÷V§‚!Õ&ЄAÇnY=):Íl@½ ŸUájC†8~,e*_²¬#ÙYWðM 8‡fcÛ[ðž[ö¡ï€˜,†ozÊbQÂ5ÕâbhÝÀ6S¾€ü•õê3–GbSÓÜt]¶èцçOÏY™nMKQKgLv9×_&i8 eœ}`Üïô77“¾µÙ-•Á›žÂ¤ÁpÆìþ½tÁóP /še¶ùªD2¶Øœ=<ÓÑ@|`¹¼›ïÚR.¿T7€#%+Q­s5œ ­~7ïã¤çø&ªìóH¹_fuœ€JÀdÞúŸ{’žÏÔ=Ól%̃–-}¨ªYœùFB[¿óoP š0¦”BéÛÚ ;0‚c7Æ­Ð3¹¾Ùÿ;éS˧ILª#L ÏÞ2f2u"2#õ˜@Y”ù~9%~0¾³žzpo ü‰Ò&n¢p’!1.—f–ÿå+Ö*7d¨ÄS8à¡çŒaÕ0Øå•m tO.h¼JÊrÕËç>|Œíð\ñq榺F>÷+RÝ‘ÊCÄÊŸÁ^ÈvÊÉj>Ù'ELJ³tÑŸ1}©CºKQ1±xÙ{¨5×»’6È?ȉEUè{€Ó¹·ÀS=ì€/âõ²>ç‡þJ§•7ɪ`9•t²:ã‡T*à~tÔéÌ÷ê©fvŠ£ÔV PÃ=fAò©üJ~¾_^¼ƒ†‚áA!áèÈkl”«>-èˆÞs8�ŽÕϿЮrò~ÜË¢Ógkd¹k™eÔ?¨{K騃×î°êþ©Ï“u`”êÛÔw‘ŒùèçzO?÷‘òŠ¥> ¨Ï^o߆ñª3D‘ö£ ¢w ´9X­‹«™ l‹Ùdï^¹úáÛã¢Øëè2böp¢Ø•nìÈ©4ÄÊ)Ãâ:M_ c‚ÎsÊËqÇ,ƒ"K\ (­º 2˜á¯cdtl7gÄ“ë‰êd9ð}‚Ð7¯4öðì°=Ò§Ï'’e`ÐíX¦·íéÄô%~Qm=ä©eÉ'î&ÊxO³æ7ˆÖÃbÕúETáþâ±è‚3^ç!Ó”Ÿv….ŒáÏlluü#£&wÖZ,ËÖËÙ`£0:qX¤P;H<˜éÆlÕ^„Ï-õK$§½ZÅÑQ ÂÊè p`*—·óI@A¯ÙA¤¹Ë9ØÌöØtÀœ¬eŽÁÚY ºé¾a ±°¬PÁY¯Nƒäúe´K~Ñ©¶}}išoºèy²¶a¸ð¥Ó_oR)y.ƒËpþºÄfœÜ˜=7‹¬NVn,<ÜN]–˜T6M47b^Γ"N˜û†Üe¹bh—°~ Ò~°ö»M}û…âWyC®åUÉÞ30Nø°P®¢9ÝSª£“«e°0a~Ú…—µCÒÌw,¢s¡5XÒiÁÜû¼¦%Ó'Bë“eÞ$&Ý CºÿŽsywÒÈS³e†Ñö²:¿<Aç"­rxÒ:u«™SUz¹i VáJ‚7§“¨’óÅp“Om=9±RsþÙ_q+È\æ ÏåT:ØÞ‚ÉY°0g|ù{Èè߃ïÁO¯,7¨;3{î§áRGiæRî2Wô?O¾éÛ„•Ð×–*à}ÝÑ4ô5ïr­\ÏY–]´4BdN”ÙôúPvlåI-¾¤ºÈ]—Ì÷í+J‹Q$‡2¡¥÷×#Ÿã¿ŒŠm37©í#8å(¡NÝSØ[÷lˆ!¤ÚÃK'Räcì$ÐMÖ<{H{±9v¥×ŽÈàÓü¦£bª¾¸5º­æhäÚéÀá‚»ÇB¡Z¿` ¦3…ÈøðlÊÜèª0ãBãëÅR ¿l–¥·½Û}OG{«É,Nö-}Åaë¹rK+"ÌßU᪖™ –-6'óâQïÿI1ÓÌ×f¥ÌvŒƒ’rr3ÔÀH¢Ú,gcR·\£´#5–5þ2EÐÀ¤¸[\ÕÜ¥a¹dG³6ëùî‚ï>2[žŽ;?PÏQœÍÕú¡ ò¦ñxÀøXÃy1j<F@ÄÀ§zÖ&óSH]ì‹XS|íösåäk”‰ ðVŽ{ÕðoõÃó¦QEÿk‰{KHgk*þ˜,YÒ7" #¯Œˆ}PD‡j—©€òáR13Ë{™|ö¬þ¶Ž1=ù’¾ß% Óžêçl£6îy‰Âmd3Éö§šü‹˜A¾ ˆV+VåIzãéSC&÷‹¹ø×£yû1¿ ʯôéØc—ZÿÝÓÐ^ ‘].t_ÒV6vf µ^±ë¸Oü‘y/|´ëål¤¾5bÈR3ŠËM‹ú4å,%bÈ(Õvê%6½àhgZÍ⥯+úVå¦Êx.z¡$àýjVQ ~üc=•oàmx…ÉdNc’ñ¦3dém™¦(°ê–ž®tˆó?|ŠR(º° öú'‡¥V»' ²OÍs¢f©s÷ÁUtæM= Uðy^§ZÙQáæÄ<æ€L´“QŸOcñ‹!‡ƒÏ‚„pj„d¤,yº¬A½qrjJ"žI{XXŒïÀ’ä§öÝIw d‰Y椠[Ä<hÊ*Žvµ+ ŽŠÄ…vYØýõ ?09ÏÇ[Û Z2yÐÈs­M6’›Sµ'*9µ{TænÐ]¿ í+]H_ò›q/ ÌÊÆJ¥#îG²Xì'ZTÌ@dl AÔ‘"dาݻ5ዪÌW.ƒãGd­Õ°ŒµlÊHAzÙr…ù›V³ ³r(¤Áe—Pn´wg›5 f©ëÅÈî_êVîÛ“ñ@ZyãzVq9ìiý¤– êÊLGä2[ITxÜIÉRW]qê9€_Ögû$¡‹øL[F×ïô¢½Ù/øGô7èNÇÍ_¯ ·‡Y³v "¬Mù oÊUÅí»Û‡¸OfAßçY_;;ÇÂF¢•°ýàÛŽ˜³ÛMõ>(-ù©¡ìó ~#ÝØ_ùók|«ñPXÜýÂërKg‘îYßgT€ –ýZÀZqèá,Lev}0”˜—Þ½ÈÝÀ/%Á8¨xlŸp°êD†9•±¼3”.¬¯k¦p©Þ2<æGŽ]S~î¤È.2 7ƒ¢¦”5ÿ‹ gVøá‰<JæÅùPS½€¹«í{ý6KS?ªPŠt™² Úô7v>!=v–mS~eóûÒÉy†¬3sébí×R^"¹kÅ0O_ŸžŠÐWDļd*X¡BknœôLØv’Äs[s+Ýj:V¥‚Zÿ­$L„¦×Ïô¡£÷½üÚöç‹ïF“irãÁÚ5ÐÏܘF\Q;ˆ‹)ùþÁ¼4‰p”™z•% Q ç'ÄhwöQ0³‹o«_Ks%œ`#eŒUw1çb€,"÷Ø”»†5‹Þéyð5 ~š‰–Ù D_¢l¥”jÙx9ï®î–ô@)Ö!•ÇhHòŒn·»X‰…Ûz,2RPÍŠ^—žÛØI=‹Ÿë`íÄDaJ_,O\~}ÑßòFxmh¡Uõ>{h&£<Àwý4›n”HÜØ©¦´Î<~ 'S›™Þ$²fÝ££ÇÅ1†‹;Uùý'`”…cIîFÌv¡U¶š€ÖÃÌïhúXHÄ'ªèÙ‰§¤Xf2—e™×]ŠàÊIÉO¸kM²_AVª Æˆö¾±µu}Ú—ú¬4OTnnÂ\jŸî¶¯Åѱ8YåŸLÌÛ\=nÒ¦¯ýŸï9ϱc³åAÜ/NRnd B€ò8“Ž÷31¯Ì}ìS˜sv•÷ïN¯R@šžÿSjå/ö©·aߙΕ3@”*Y’D†!cŒ‡?W=‰í•¬,ôî-e: kž$¸žaýÝ ‡0OEÕž‡@qÒ“ŒŽ3üú­¿Ô™–D N€­Ž6+ü'¾oYø€í_SDq^…LØk2³ÒªItO/JAÎ}lÄ÷xyljӻ34‚ŽnWÜ\=’àî°ü=Ög*·[mdbÃHÁólÏÈuÓ¬# ‡ª×B9@.m&î,̲Ñ4IªZt5Z ÆJe­âWžÄe†} ˆÓ]½±ëú¬°óì/ÎËô©…,,l¯‹U¨Ò îj/"™júƒèÍó‚øi9:m§4öÅ¿cÖü?SœMæwÏӤʼnñRžÉ|wåÈx7'ŽæʇÞl¾Ò'¶L>õå¤[ŽÿCñº×}]Ïæ¹9 ›Ò?VÛË_v]Ï,(͘�]Ø™•ÏÞ§¿­u¡Çýe´âùõÖF0©<¸M,®î÷¶Dh[¨/.ãéÿÞ §?Ò½w;¬S>+¦¶¡ì «AmÏŒ×o"­NêÑ€g½¡´¶Û«8åכ͌EpQÖo—ùÜÌÑ­ŠqZÜd�¢£vþ´gD‹Yî©7ÔßBtX¾Èþ�°CsýøŸDÕÒ0Ï<kÊnE7Vb6K-Lmw¿ŠWÆl ½j²[¼Šý—A&³a2wòÁH€§fòZ×÷íƒÜÓ>jì� \67=uíÉ“Þ~¤í4I™ÈÃËð?Uî׳èŸ~@§9+D2©Ñ¬æ¼å­ГNì/V5åaKKûeM¶W!šªÊ©£·›CaÔŒRÔÁK`?ŒÓÖÍ8LÀ¸ J—4òPžiM:Ê86ÑSÚvuÛÏV`c%×r æL=¢‚ݘ6eˆ°™J˜v~Î ,/8¶òŽŒUÎÊ÷ع;ðNv_>£¦Ü÷<½ut’SU|¾‘qÉ*ÃI+ ,û°GëbŽ*ø<Qqˆ• eÁ¼m-\ëÂY÷4aAàIˆ/HÁ…©o^•Áu¤" n׳‚ ,‹}#e?ᶚEË>™ÿHâ*¡¼Áä¾|(®•At¾¸¿ÊŸ½¦ÂW²,Ž#(šþY Ò1ê“PœÒaçÒ`LjΔ®éDåGÇ„•ö6[. S|¹&ð9‹2ÎGª \_‘VÃIPr­'šÝüèiž}E&*1ˆaöÁÎóÚ4¾ƒ,Ġϧvúï°¤ûߘSY›47?ú ü|(d\**ã>Í–kºË+•Ÿª` ŸZà®7ˆ!3ÐÄçPHÄÕÕÈ— ŒaDyÝ|ñÚüôÙ=ZñxÆ31$à%QmU]™‹P–ý×ÚëæûK¯T«[€*à»™•â˸¡£GƒH ôõ‰—à Íóx%ÙÏî~Кªwž5V×n&ÃÆØb‚§nOÞõ¦¿ÒÃ6Ó„» ÞdÚ’�fŒ›"¨±[“÷òF:¿–„šÞIœð½n ¹›+ËtŸò°œÒë³G0R±b=ƒÞk:L—Á>Øzî”{vûXsßÚ• ‘–çno«C¶—¹wNÿï-öÀP´øb<ç£ U½è÷¥‘cnÆÀVC©"ÿlÝ.¬ÊL:Æ Fã¥ÿ•%Dæ‰Ä¤¬×9Qô´6àEž§í¶:™ŸÒø—wjyæÏð0i³ °þ¢Ì`µï½í½=!g¡¯C‰’îC±ŸLŒc•à4^߶�ÂX<ÏXjk è§Ð…±3¶Ʊ›«¢ÌEÌQ”èD:o:éÒÆZ=×9‘4 Z9ª¶öôít¨dU<Ìlñæâ«¡nÅþòѤC]4ŒgúHƒ“axn/g4Ÿ¨:»ÑZÉ‚ ý19É"É”OÓHÁï°5uÆæÀì-b™ÞlzF?òh¢ÌKaë‡y̱֛1}¤sø@ÎÞÔ4´È®?·ÒÐOh Š`\ÔÖqÇÛ¥£ÂÅ.¿ƒóRŦÑJD4Üæi_µgck�˜í`”¢*ôÄ´æ¹Ája‘ëÉŽEPt'¶JéßÎêSÃ=,Î_~ÓëJ*•,­tZ\Ð]o\Êú*òñUV|êb»È/7è9å—ÚI³#ÓoÇiO_A Þ{æìÈ¿ÿ$nÁÏÌE St Ë Þ þBûÛ#±Y"óoºqêr!gFHTZ!ÜÊz‚ªÿäsÆQhÀ럨R­‡ýš$ÍÖÊ´»+Úiƒ/)s“5hßù¿[Ðá)ðÌÁå:ÝšzeáÊY8 Z*>Òfòô—v®ó­Çü3•Ô¥.*%8P~WYMH½"¤jN‹>~Fó vûÖ×!Ó ;*xÞU„p¦³=ŽrÎÎ’!nRøþÆfœÙ9,î°ä¼Ï®=†r”ãÑ<òxט£Åü¦?·¨T,ó®¦ôƒ©¨¯ ·Dvt‹"0Ó20rzëÒ!2„©K´û¶ ’zçƳ†V}Ó»³¸ ýØÉOÂÊÆÁN°Ë\cErE6MP“#ÿÖc.‰‹ë· 6•°¢½N¨A‹cã@É :éý!ŠöâŽõcÁ¥Í¸Û,“%#ì;ñÍL˜x Åœ$ÌG7‡Zß!Y¬™‡b{Fȵك8õÓNÓ—®1¯Ä-zApפ"üþÈx2ʳà²:?ˆ;:mÇÛÆò }ëöõ>%ñÕ0BÁÊäA´9¹X Y Þ'6çƒ/š°ñ]åÀO~¾1) *`a†0i<ûRö�ðMã"ü3Ø3èå+Woëæ–ùÌ|^p pŸ"+•C¦1%l!åæ¤íWëp·Š »A‡¹œD5¹@á¨) Ÿ=Ÿ–õJ”¤ZOds"qdV�o‰U²?3´æâD„Œ–¶ ë}�:¯˜.~©ð´åXWqæShÕQ¤ÓÕcòö·±ÊÄØÚÙèçå•k‹dª–4(wÖ�1bF’øO©“î/ef£$ñ¹aÆ09Z4ªbƒw+û—fɉªÀÜCCþKasU\XUBòœß99¦~RϳÏžQŸŠ¦Gž ÄtŠ½·3£A¹j�íCݧrKYº"1È 1ÇŸ!X‰hòê¦í '¹/Œ QŠÝž÷Æ5ª€e½‹‡”V¸ Dš«ùW+jÆóå$¨†zÛèv½ ,°¥·?Éé«ý¦%×oÿd Õ—ÈAiSÛ£«np¸YäUÙ”ß#`‰¿±·LÔŸ•ÌÙ‡ Ÿ:0óº¡íy£&ökÚo®}PEQè©�¬_‡¢ w¯+Äê=,±b‘ ß{iGÑÊ4ª@òÞÚéñÁYEun›ý¬<[5G¨›ö€zœ°æ/“#ù¿PøaP!–6ë{w¥ãÏ»_˜ªÉÐ#IÌiÎÙ‡ŠÂÿž÷áÿ½E|ù¸I#ée¶µÉi 3úôÂåþåM×”ÙƒÌxßy Öùãpò|~Í�W²9ð{O@+¸ž®³ß&M¼_„GŸÿé·ò'ì° Õ8ïú7“J© bšàI¨q[òf5 ìèˆÀr¹Ñìñ5³…y XMþyVŽ Ø8@cÑÿmíѬÔ>ÖØÛ7t¾dßbrsÕ"èØ`ÞU[K2ž¹›ÒØβ'aD¾~÷EJ‘¤d¤×)ÛU¾M\¬Mã†[ÚccD÷¨F=ÿåÅQx5'KKlæœÖ€VBU±ExcMü NÛæÒíúìg÷xÊÏÌò…ÞphìœÒ8 �1Ìÿ¦-g+ Uúç •§/;iÛˆè¾ãa°§‰½c¿<2¥EU”ÞG Q³TAºÛxj¶5¶8'Y¼rîZó ù‘®©¯ÑZÞ/eà ‡¶IK‰˜•áZnîˆðÚ÷Çnç«”*gŽGµó¥%ºÚslÿžÕ‘UU‘YÃx¡9߯T÷øaý¤9XêIŽ+-ÐDŽÌ½çêí OˆÇ Ã…VõF] 5S©ðŒ’éOÔí¤XêQ¦$Žò–ï ºæç™Ö~ûf±{ßÊGI´²‰ŒµËîÓ<pÁ1_¡[ç–ÿÉÂ%Š p+p‚>÷šïa‡Pʪ'…~nGªã'¯‰ù$zV8“Vé™OTQž;'+y¬‚Æ`˜lš%täcoú¬·â¾EfÚ»—?tÿ[c ¹¯ûÍÁ;·°+P '¸Œ€ kçæ§[çú0ó˜ê°çº�³â”ÒKNH<a¹Ï'û=W-6ȃŽÍŒLÔ’ë8d:2²²^RÅHl¨fõsM{ëÓªÙ”,“ÞWE¸¼~'àÁySdIC›Ã¡}ç(må„� ¾'ˆBC%ýñ~¢–¯Ê˜=ÐèÖN‡mQ‘!‹CYÅ-„[ªæk“Û‹G€¿2]™“Á<¤T:LžÌ|¢…>3£És¨G6¤_.:Ð&U!Ü'EhéRY™yñ0²èGÞŽ¬HaÀaT×ÍÍ(ò%†‡0 Er•Nª<Rð ÕggĹâý9÷ZBbO•PÂبէ9•EkÙýªq@»ê‚ÁH 2‘ü½ñ¾ ¥…XìV½¨[À¾š"<úɳé6¾ue°)R:¼-Ð77Ì*–¸6)¡SFÓ˜¼þ"aYGEu.h^FÝmV‡ic†¾s†…¥A`zºP Š¥o¤•ï¨<xÿò -$VêÐv¤v£ç3ZîôÉ'ˆ›…%wÞúuùl XçÔðÛ®;·1öýu˜Åd…›?ò¯œØvÒé<ËÄ¥£qÊÊNÖÊÙSÊ„‡Ëž°Ó O¶Ó#Í*@Ú®`&ö_3:LoÅÇ-RÅq¬ÂxCë¾;"ÕTQ *·»ª­ ¼àûÊ¢š¸Ð=XºëD1‚VhÿÃÈÇK_œ bëÞ”îÕ΢H2§œKëOXœ�N9þmGAø°ù·,Diá‘ê€nwxVÊSŽ�‡6¾uœ˜Ý7¦©Þ„žýF›Žr3«”Ä2ýçÚÎØ Erƒn™B™çº¤n1°ÙP:[™n*[3htoxªßdJQ–d^ý‚x4$´¬4Eç>ž€$cU¢ŠçN´Nå <Äeœù¦¦zÚeÓc1'çCÏ,-Mƒ!^®†kß5³©åf‘_ð½ß,‚€›€/wl/3«çrG…›G�BqÝɉÛJVÄ­ÈÏÄiíîÏ€­Ú®]Ì¢®3øKüy¸Ù‹wÅ,ëq¼á*å«}Ž(ÒÓå ‘3ps,¹ø`ÎòÝ ñµ¤ùhhX@x×{DOJ*v*Ë5ok(„ˆ®!ÍÎ[•×~­‘ÜÕl*µvŸ 2ÁŒºnªly+@a9©7Ž‰šôë•Ü× ˜3ˆVV¾wIYÁ‰Ga¦wž­DÄà3'³ª{w²ÂÜ—à\Ì\¯97Û =w…@}I9èÄ;õ¢æò[ÿö¬°g£ÀØ—™*á¹õôæèÈkšÚúøH³UM¶¦¶¡Ð%f¦<öÆ7yøKOË'7v|3þÖûÕÉ"Òâ´?¤aÈì.îlˆ²Ìg=ÂÞ¯¦x[µÃIÑ9rbíuÆ耜@ð…`’TáIÙQ®4P…p_ÒáÞ{kfCE] ¬BûØñõ[ê}X®:0Pw‰2ÎÍÌÂA(ý*–ÿ‡Ã�±k¿iz3Û¾Þº<’—¥…6öVDpuj‡n¢?T_< ä' —'òÄ_žaÚ¾‚Àni1õ°Þ-'·V‰ñö¼8¯`é—2]e£ñ xˆz?·ƒÖMuž‹ «gkðÇ”C?íÝ´bܦ¥Ûi< ‹·Š\3ĨSN´á¦8MêÁ´‚¨¤¬ÍÌr!80yWqûê©'ŠÎBÓÚ{…zˇ #µHY1hPa¬×Ô÷ÌlAåW� ã™ãçìG´äéà¨UQ´UBÙ+CÇ8q‡îJ„ Bõ{vwP‡®˵zŽ§Ê2_pÁ.¥� oš2§Õ¯"_€‹Ü@G<u:9/®,…lÄøâ ÞàÌ¿0®XÜx8º,3w‡) ¤ÃÊÊ—ßOŠ*\F7]$ý»?é•UÆ Ižåüþ[DI¾¤ yh'½[-Ö¨ò„“ÔèçˆS:ÙéˆÕÀ¯Pí)ßß=] z†nO:Š#ÿÝ?C÷Æò¥y£˜êÓç>s�àNHâõÝÚ»wqô3NFb`U´'@Ì°Eé öOV¹7¡¯ÄÃ3ÿVÙA^Û_o˜HNFÂÉŠÝ{ö‘ßY™;Á=q†…KÕ>2ˆû°Î/McK S|)ÊWÅÖÉsj!—{µˆ…Ž ßW®ÎWZ9ÔZƒØ"ÀØeªéôñU„¿eâ—™/CFîŽí<xüGñQŽåìL=5ïênRžyö ìÂ*Š­ ¡Íð÷˜17%Ýn´¹¬Lþ/=éžV!Z]GúE§s1:ëþ À×ùÿÞ¢,2g³‘‹ÄØï Ò>~Pyvý`äXxà,ã%&D¶ýÌ{‚sxÛ¹xIx,‹]6ÌgÒîšÅbw/=©e\K9g´þÛ·ÿÝ]©ò¸ÿŨcaÆøqh´!éš³<ŽÌN¾4Su'9�Õ1Ï;¶EgNƆ‰»t@¿k‘I~†¬p»âª¤+–±"“K_û‘Ë<‹½¬Ôò| †¸S?ÈjUÊ¢³’Ò”ÚµºŒÊ·ÿÏ[TÖ¦† ÞÇÎñ"_ýS¥w-4nî—¤ü­`ÝVσ¢6¹zè¼`=Wñˆâ8 WŸ¼¡ã<Ÿ5±¡ì8ÑV'g~ „û*c›þ«èµ|Û»Ðv½ÄWî'àM¾ÆÉE'/bPòrŒRç³-ÒçË'ë# Î3@„“YR†O˜Ÿó¨L±ÅŠØ_.ð’,'wÇ‚?³êɽl‘¨2Udö —Ê÷¿G1ç›JD,þVÒ¤í(¦ecøH#Â}#ŒàáûýRuZù¹a¶°VH{ýKV®mTW=þôü€µe½ÊG¹r¨j:*­úX„ûtj‡ëž–Í^Ë.èçq"©<I˜…Ußs%Òz~ò´c†«íW÷¦Idã&V»{eÓ2cªÞ¯”˜ÑÓÜMæPhΔ‚XQÂÐC%LJZ^fó]=Î0Q°ƒ±sl1y~¼ £0kÜ¢FHiù§4} áªd]TŸoöƒÏ,®èQ§B³o0öƒ Pc<ÄE?¥xP®EvÀîNUY ¡6íÑŠ·PCã;»bZÿàÖYYnìχ)ôÝëùï‘Ûh7Ð8ÐŽLžÜ-ÞðžÃ=-K?=‰+¨-Áµx¿x‘ÒÓ .4R¦ž/Òýo¾3MŠ«õ‹ ;DE¯õbùsÀ÷·Ui¶Cì²F¥N…ëé<ÜR¹=å~T£VAyÞ9œÝd&dÜ>µ|,²•$1ݤɤé<i `ÿ(²®Iº–…5ËÞ œ×Cô½9ž1Þ>º< '¬Ù·¡ÇÜH-Ol®¿xôe{(åþÔ%ÈW2¼ Èp¼žæ Údm3Ô6·—ÇHÿRè¬ŸØ å¹ß‘ c#>4µžCrwnf«¤ÓËê|UuÈó±$ BÈ€ß*Üïñ43àE²c™¹Õ”J_&0eLð{¦ÐmyÑanŠ¸Ë”ùç_¯#Cï¸÷ìd”8¹p:lª|†¨5?&%©“w`žê¥¡- V2Ó†ùÛéßRñqæ?+H¢üÍë} ýÅÔŒ4p$óÙSº§(g¥/ ã“—Ï+ZMwR­Q›Åe÷êóùoZ°‘¥•‰w*¶‰ÉðWi4Ì >B˜×BsÿÁ&1-X0U¨2‹÷]û›ß†;°fúõ+ìxâæ¡Œ½6Z!>eÕ_E["bê\Mûlð9¶7BÌPç§Ê³=a–àü™SÚcÂQ(óui` ¾{ÚÔóxz¬ãyþ¨©qnƒ<wÙìÍ»fXâYÁaÓÚåtãÒöü«v>Ñ—­vxEª;ú2nEVŒõ†n:œW·Z¤—k5åo~+¤oœuá�èPÌ1e—Á¾V³6èh›dv+ +ÒY|qIÿJ'Ï÷ÍÑ2ó§jè–o² ì­“a¬mÜÐäÛ+gãkhÐÛ_š8ã!ª:t¢qB+o6`ÄŸ"M\¼ã^°…ögzÔýÅkñ ÚÏ0ÂdŒ˜pÊøÂ^9ã¿Ì^¤¼|˜ýÙëŒCMh¯Q1aSÓÿ•šäžÐ%3'qê<é}èq9ê$•ˆBµîÎP‰æ-vÙª².™7ÖÌhaâßœ½¢“³BzKó…¶lá.=+wiÆ ©Á }ßÏÐ~‰-ó9 2žú"MÞŒð5†<¡J·?bé8ñO9ÇüP={Ì­'^!Èe(¡ }/ñèË90PŽŽÉŠÞõÓã¨uã3G;y¿]KÌ'绥Z®gøÎN‡%H«­0Ÿ¦ŸlWÄÜÉGWøÔ©_P윯p쳨圪².Ó9¢ ÖÎõ¥¹—ËÚ©äÂÁÎ3vj!X7«Ö[7öGˆŽA 9 Nó„T’RY›¥é]¦*(¥â–oÕ$ÒÍ4²$Eç+íƒ?AoR…2óÐ,ÝÃ*ûêh¦Hœ€“Ržg ÂAíäõà<;ª ±ÄF Δ–1gÚ5+p>2™ÕSìØLãhÀúã¥G¦±6O-¬,v&¡‹*|6õ ~?'Žv2¨éÁ¿DSg%?g¿Ozò“²3Há6»‘)„ >ìÅfýF`.‹³µ€êá dz5gK¸!»q:2t+¤Ô{VµÄ¡/ J¹ó�ïlwöXæBy3É+ÚÍÈ$ùw½Ú J¥5éSSIK(»i€ÙLþîœä$DŸÎ6º\':)š0ˆY¸r›/Eð;i4ó«à >ÌGßž‘PŠ¹Ì¿“þŽ¢dŃÉ(TÑ_èZ�¤Îã·CÙÂæ#/±<òÊSZŠsÚš*/ ½¦œP9"ÙgÿyXÒU+*M˜1U³øôu(f΃øã/‰šáJ îàêé–õÆèpm6Lì§Îž/n•ò Õ ï[GëíÛ ?ì• � àÎiò ´- ½QVÅ9I ѧÖyR± ý:½t46ò4µJ.LJ^f¾ÅáîœSî¬À’R8r4HæÍýO”»Ì“©aÎí�ióÌñ$ZØ”w—âx5Ú¯‚#¥{«d˜pÞÖ›¾¡]òÞBô..Ó2ô#1hL­øOßÌv;ZYUÞÂ͆’rû€ñû 9¦|,Iu HGfÄÎjö± ª¸È{—ëÛûÌ¥%Ò.臵Òm¿'Ž{6^åÏ”]ô§L‹GþÀUpw¿»B…û“’Ø x{«ç±îne¥žB9¬-Xjh' ­ÿ.Šõ*¹9µx¬Œký…euÞý(˜’–™g]Êíäœ6øÉ›  nT©™þ}of£ÂzzÐMvÝŸÌè3m¸¶gG§ãÎånP]圸»Òß»CÓE>(ŸÖP3¤,Gf6nª\'“\ºÙü£«{Qœ|í  ú¸ÑÆrUjÔnO}Å ÌíŽgNÿ#rsÔܘ,ÌcšÑ—•ÀÑ á9©@R_¯‹mÚ²O4…™¥àq[i•uuÄ­N’€ºŒ½u„åÔÁSîêÛ”>É Ÿ™ è%¥rV'›e¥ÖJ€­çˆ@•h¥µV£-MÆwÙF­9÷­BÈ /þiò~nî´&žíÊex¢+¹\Pj½‡ÝB¯Ñ0W MëÌVß|¬Jtyð›SË’mƒ·Ô­úfº {h$œ-iŽqùì¾IÑX±9‡¹õõ7þr«nW„†-ý©´µDÐt"è�›À=ºq†Ø—á*�Ó€tu-�ÝOˆDÆ"žm-Òf£†ó¹´¨<±Â×­-âHËå›7WZ7“j¨c|P»=4gv3/·çHž­Ü,@xT­WÂö×5ìªÖ~¦â›&+}Ž¥òºöT6Ù¡j†ö²¡”ÅÉeÆi­§·^NžèÂ4Òz°’ë/H ¥+ßÐ>z>v؇ÁÝG‡pĽuÿü«qK꺅˜æo1ÙLÛOÅ××穵¥+2M ÷SGf t­3ùðÎ5æFì{:pšÙW0ª©Ò¥çTë\�pÃ`õ6:Û}¹ß+¶nÍ oê ø=XÈUÌ„C= ^"*u@¾¬ky]ÄÊ4O2›Ð! ƒdNÌšr‘jʉð¶¹Ú‚n÷ b‚iäyVòóyèûp@B ’MïLÿÂ*§ÅtžÕMóÇ1žƒš ÷ÊIpÂ4Uàd×sè`¥ý#­ÄÌ3`åFù<dAÞ]½ÝH_¼9‚Ú!ž'•îFÅW©…UÙñÛ»„Ê•Gvê4¢]9µ¾Û¸tWYmfƒRù$þ‰ ‹.nëáncÿðá¦Æ´Ï)àé®ÏØ«å r§€EXõ³­'Ÿ dõ2~èpÅ^³Ý²Ku‰ÒBúˬ6þâIæÌa+£ÿ´|Òî›Uêj»t|0àÖ7 øÄ“ËB»† wÝ‹Ruª+ãJÞÔer´+¹Å§ÃÉ_.D•öë¡Œf”©?»ôíR0c2Ú_¾½6†% ß4íÆÆY[lêAìV vÅŽYÓŠ3Æi¤×Å“ø¯XüÌ&¤ˆ"9Ï ¹•5ÔËMB¿ýѲnN^!Dmc"›Öð¹íÅpdˆÀj{#¬™Dž8=ënP¦h7ž"nÝÊ+~\ZèÎõE’xyÛ›9‚¯³¹»fšù™$yõÚ¢)ÐuÓá‘ò8Ì0¯«í -î'I­dºbàsZ¿Ö¶1†(~ï•ÜÛžl1Ç`‰§J*Žbç"HkÍÄÃýðÿgí϶W–vaøXó*|ô'³Þ¡¾9”@ l!°$ ScßÿuüñDdd¦èŒk®±ß]È^ka2#£yš?âQôß+y;81•%xÁt¦·[Ï&‰Ž‘õ¡?Úžp/ž£Ì"OB†}G@€é)\ÔÖ¿žÄ&‚9]ß^¢‹—ÐùtŒ1ã vÙ<{qY”å¯qBŸ›}'ð/Ï CmÛCH…û¿Ÿ,¾ÒdŽô’¯Æ¾…‘¤­­cKI÷^ªa¿Ö”î M}ñ/ýqðxXRfm‘NŒ§F`;²­§ôH÷R°;-Ý‘ 1vª‹0(>õ´AlFvøø5>ßÜ JmZð‡³Þ—?Âi¥ºMê4BŠTqºô7hSA)—“kód­M•È^ýø˜dSúúª°½½AÑŸk{Ç.Æ´ðí¿èÚì†í±¥¢%y`9¬Y°üUSi'Þ)vÌãÑî²ñÞç®m{ÀA86zPóÊæaÓM�¸úÑ—JLUDx¤4ç]d€<ÓI˜ÁA Q˜‚IgòÇ+¢˜ÌÇÉ øž¾@rž<ŸvúïËÜ"ï5ß¾ëÙèlqe0× ãZßyº1°G¦¢=ß©žñEôÇ9<?á{è+&÷Åär°6ŒâÛΔD«¢f¤mž ÖENÙ€¥–{ØdcíùÉ‘)‹]µû±y›‹»xðþŠxÜfÈ8Ýürñ&á”Y®Þšñ2à+`¯ð¿Œgx›ëþ ·¿:¨'àÇn›ç”²n|V›žÎ–¾u=ŽÇµoVWÇÓ4•A1p'€‹" †ßTfî&a|^ýtx–±M±*R ô #Æ©›¡¥rm]…éPÝõ¦²‘ÖêR÷+ö’Æí°\jý¥kXºå*Ÿ)“úT-Uqí¡�§m¤›/Óp8ŽôÜßXh¾O²ZØ£ÑAM³TºÁ^듾%8hIîíú=.q]ø}S‚A²Rf§Ök¯ŸÚU=J¥(^èæâŽÂv/<×èé¤TÉ GO—fÕ»ê Ìõp[j姌Wùcúl ¨O”Ľ_<¾5 ÝR ¢ÛÅöÚ‚®É9¥ïi¶> „dK¦ä¯£Ïý·Ë‹Ò÷Ì`XÇ‚Þ¾¤ýi�PºÛÍa׋=uA‰»+þÌþÛ.ÿ„ñ¼“JŒ-YZúŽ¡ƒžl®Zù;ƒ}ª‘ò%Ö3ýSœNž «¬`nÕðüF±Ð?'}¬×4ôÈ(Xµ'†‰:U6ñéä¨ÌÛ�¿‹ÛbñOYRúÏ2.Ä0z-6/XÁfĉŠ?õ‹¶ù¼µþ:o T3ø,椛ñºLܘ^"qEÿ”nŽ+b)Ë.ŽRãªÕâÜ©qçØcB¼ô_ƒè =IÁu0àù[Pbâœí̸cK9Ù§úæ’ÇÞ%òÇNGT½�ÑÙ…’Ôv�¾IFœù¬l¢Š ,úN“¦Å”T@GÔSÙd;sÓ‚‚­3σVˆ íÌŸÅáªØ§ÓS†Y88ƒÁ8pCT|çE¶°%‹rïûpsã8B…iötDËØh !(J2r3 Åáãÿ î]ge(@ï8íƶî0‰ØÕëbRÖ×ZÐ÷—CšÉfT¹{|À§³¬ùà韈ˆü½U”%.óŒ^5v”CôŠ(¡gy`#!–Àñ¤Î´l°p¢Q®Õ·Š3rÌŒ²pF†ìÁë$<ž=¦¸ï_q:I³/ Ú! Š³²Ëê•* ü æ¢ ã#ú/‰ºüù?ûëçæk ír “¶àoM·ª}v^sM5îŽøÌœ°è½X X¢ÔS^É+Y]ÇŠ£à|b”“MðõħÍï«ó’më Ïݯy²*Ýœ|ÌjtÜãÝSM [I¹]5q/·ÍØPËà#µV̸Öñª.ôl$^r–H˜"ë< ÚŠ”Åm.º/Œ å¼ã Êž<†…®†)W®-~l¿"42$SKµæQ -à@;Ęìu9¢È<ä5%ô=ŠtR_ÍL14m &`QèV{†'㱓Í]¯³èŸÌÇš‰»"PÆMë \R"‰c·AEC_óU©¼»’#¡ ÙÑÍ)–V˜!OÀl½M"øùj¯= M²Ï}Zï{Üšnc– •þ”í†ÉS&ëµ±>ó²ïÇ�¥"Ï|ÿ²àÅéÄDŒø:û¬‡9’Q+øõD¦>Ó ÃÕ©šjèlJ¿:C‘Aðᑹߴ‘ðÎâ­/÷5X|4qÁɬ€ ;þÌ…­ÍiD‰Ô=£áÌAëÀS=-GóHo”�½ä©âu~wª`sh{Z)Ž¶Î §u{ÞQ)JùRYJ‘½¶c»ÞmwËKOìEšÀQ̾ÙÅtò„½hb\m!geí\‹"ãŸT%:Èã¿ðë/áPËYÎIÑýÂç8+°ä~ñ賕ù6ç T쓧„ã×¹~öŠ;ûz R!½H=φ–Î×tR´"š£%ú‚ª*Îvל·zœUxEw¤eµï nðš;úì(wzoAÍÆÔ7ÛÈCqæF轡4©:m=QµÕal\SY´hžHç‰CzÍ|1™•ÙÀÕÃÅ6u:¦¯RÜ›•žÞ~ÅVƒ[¨‚lµÅ^d¾¶Ì†¶”�ɵóæp˜…Þêâñ#+t]¢¼Ú-tóîIï×°/¶fèÆa}ñÂé?t£ Òåmlͯ2SÀ ü/³Â¡6S_Ú·5 m³J!¥f×úæêÖXë®05$v¹œ¥q¹i‡ñòÆ……fuõýÐëF]--âb*éG»ä�OBªÐ $³ǧ"&¾5ÍÁ®(ŽÚ~ù¹¥÷´:†�Sbëí q»dQTž\QÈìÌ< Òqã/] 8Ó‘$‘4×GýãCžÒQ*2–!ÎÙŠÉ c3™®ì¦ÎŒÖï÷ßüV˜3‡m<Ôj“a §™c'€>έDUJ?ïŒ@/¬ëž€k™‹¼13fÒ O^âÏ»ËIãSŪ‡ò›í(^¸=RöÿUq«Ù?%º¢àä඙Chöÿ%ä1ùè ò~¬)QjH,Ìú?V=ÒªBÖ:Ö¸ç/§‰E•ùî’%ÀëiPZƒ »n˜&LI>7Ì\¶Â*Í¢Ûºéu‰óëÐ*¿ß ·¦Êm‹U]‰;^ñæÓ™5Î5܉.^ÛÈ×ê~Üê* ü†Ò(xsa÷ªÇ›A®%æt-0ðœ+g³„óGËnÞ@|üãõ£ÿætGüó<¶T(é []aLæY8.ÉlÚS_w6™ÚL„cVò=Šº¿IXu²é)9ÞöÏ•›h×þÀ²â¯d™æ×&>šÕûØ£¬Eå&°*ofü(»Ë—[dzƒ… !Böå"«šVØšÁ'° ÖJØÿ×9Ã… FSdíºµ7à ;,XIÙdoÔk_ÿ `k®þèš—Ъ¿U0®*¼„©tZ°'>=+yŠB< “ŽÖhš”úúì°©¼¥WblÚ4ô,;md¦¼ÇÔnt*tJ@"îÞÕúiotá—tÿ·ª¯+Q\D)’ÇëVë”’ËS±±¶–yá •§b ¥#a–½êÒŠÁ´:ËÆêßmßд>ƒçíƒ^_'gg À²f«w;ðê¼îwÎ¥ãç”Ù蟢̼õOGç<B³~ô ÛDÆX¡æñ4Ì¿+l;Úh^FY-¬Øz”R’¤Ûx“é ýÈ àlÇݨŸ‹ßžü³Ý›žè<8úq·ïiª”ž‡2Ê’Ò’zp¿•×]*”ÕQwýôCäé~rs:â8fOÇÍmZ¨ƒIÿð�æ”2½žÇdØ•Nû ‡s«®î¹±ùƒ¥Áú°­=¹?Û¨€µÓ>E- :éÜ÷´˜ÿDrkKü£©x¸P¢³¿;UAÜ¿{qa %ç†vÿõSx¹#— ðKÏ |f*広Ÿ'ˆìq×Õ‚=„ªFyº¨Þè$�öÇzAƒ‹‡rÓŒ‡°±5{³6½¯´ðãÌ9׊‘B·Î‚Ðy1¾’/aNw‚ª»C<ü ÃE0«‹F…¦£Ï+e­z KQs§~¾7,`™2ã®$£SC³ÓÃ&Vš‹�â.¬¹xȶŽ ßgƒh)Yo‰Œ×«M#EqìVCîœ-d§µ×ëžÙWZkºÚ1ß·"'2#"<ç! 3©†6o(|U¤yúYE_Æÿ÷þžÊ?Á¡O}^SNÚXCŠ2_ªI! Ó;˜òsùÓS6IVND‚ó4P K[†ñ‰.qʯ; Ê¢frœèWØÑØ!),w”)E,;ÆœùãbÙ”ÑAFç±;Ͻ3ÅË´–I—“|¥ bgÚµŽÝìÀý·Â|?£uV¥o}þŽÒ¬Fƒ«²2”1�k.I~ê]WšÊøŒ$?úÔ­%®ë8OšôÅhŠÛË' ¹N²ÚL;ê‘Ÿ@üùÈP]Íå�W ¥O(ﲞv=K'ØVcá;"@ƒ¶\¶µʬÂ}œw“"ñ9ƒÞ³‰ Íw/­ØC–{þ§™H¤&[ ]PM_k ÄN4Ã…e÷Ÿ«Ú{oñp¬ÂSµ«¯&âbKZRaÏó,ƒÀFSÖŒ‡_|ÛùŠ!K—ÁŒœ=kU¸}I¼äÁä3xbJ NÊJ»ßñ-S'óÃߦ©‚ü}ö€_ýéè<h6RåU3´@�R¹¾ÁÚ…)ÄUúd¢³—€¶é]òfÕŽuÒ'ÁM>òâ‡å±ðÍ0™o1Qázh)t§Ó·³@*hµÿ¾U©á-‰¼S}�L€øPZxªAÇÞ™¯Û[ÓD é}ë%INC×â›ðžtŸTÀý§?ƒŒµR—è&Q»µ$kH½øžh… wq éÍ{QªyÜ[²#6!~æ/ËXlR=}yâ³vêÁg$Ǹqª^výa¬Ùƒ:C_fÕ€…T+þ Ëšrã£QêÍf„I®¬Ú«Oèf-eŠ­](ãDh —TR)V#H3¨‚š÷—Å¿wZÁåB 6QàÞöBQo]oÕ펴)<ØýÑšÍE¯ÀÔ. ÊIŒ*îѼÍÝa_›¤kÆGv¸wùl~U ÄOô}Nó¤a KªèÝTmÒmÞaœ3cÖCù$E=&‚ŸÇ[DujÄ(Õ¹ýÅÕ˜¹”;W2 ÍõH(^0vׂE›ŒGœž ZçCî+¥á‚°a…Âì@¿Q–zö©§•b¯WåwÃ2ô{<q‚€›±ä¼ÙèÚšs&~ç º bg¡¯>Zaª,vѳW{m•É"Õ©ÑdCO†WO¦[,›u,vz† P)wyc°å¡þ÷ú�ˆFt¥1"Ý4,3ÖÃHïiÍ:¡„ RÁ ó"õŸÁàLÏ{UÁÍxQwpS…ª³q6G¨r×W”VQJŠTÌ„hïò^s%­ô°ŒŒ²æªivçåEt4•ç¼Å¾ÿÐi¥XÚ¸³ sõ'Ïl–‚§Cóš.ºÇ £˜LgíO»‡â§oô!SÀ*•c¿>gLrÝ—A~T øøÖkþôH}ý'‚ìvÙòxâ!}扠‚atùhU‹å (Ô^ <ây––ª›”­™›)©Xx Q&ìð(c/ÓkqkñÃim½~ÿ × × Z™eSEØ J;e•™Íê ¢|dc¥ö9@Ôö%3å´$êì¸>¼$@¸ûÐ’g]ô(]˜³°’@td‰ 3ƒ+TÆ|Ú£){-‘a–g{s)éÊ=±,‚ ³ÍU‡ƒnó\÷»Ã`0´†Zò2Ç$²ôÌä3줚;‡§ü—][ÎÁ ØÄtÞ}œÉ][B¿½†bÜL–ÆÂmyK˜c=8‰7óI9o²Ì€-6*Ì ø1SUÓ+çað|Ø!LÏfMvLG9q³ÃÛ¿¦É{Ö ú¦ÇŸÓƒ©ÍŸ~ip¡›@gÂŽÞ~½%”;š¹8x)üïÍÄ¡«L«”W¶ÑæÔû§ ‘ùÈ|È|¬éñ­7î'ÄHZŒF¨é‹/!·p­òæžJ¨jT\µG:$ÍÎÙ€x!¦·Až²%¢ ;ë‹ 6Ðï‹K£Æ5ô+Â"…6È”çºnd&ž%„Is ™úÑ!„9£Ž¼ÁòúD7_"ðŒçŒ“òþgÎK_4šÂû^Ûƒ„·iWÐìÆNŒ`Z¸òvb…ö’ûµcª»6+µÆ–Àô·›¶¯¯•Zïj¶FEXe±9MX¼lõ; ªËÑT/9zKjŸw½™ç¯-‹@bx¢˜Ò×NÂ#dlÔþ 8¯ž 3qྨó.5XþŒÀù‚Ëèæ 4ÙLh3–Ð)ók6ήM$ŠqE(Lƒ…Sé[néyêî¬%¿'ZÔ*UYS~éiÝ…¥o)%ìË ú<9_ds <»‰IO”þ£Èg‹œ=íôâh«‡X•ãeÏü •)Hs•>@ÂÑ朱 ¶ÿ>ÚÎ"°0 iñá׊€êW;-{ÎÝPÏËa¤Â+ž!•´¡°±‰ö"Åʼn§òî°×ijS î)¼¿ëd¶¯¾­ á9äÞãdŒÁ¼”AÔXþQd¼†½îçiTCŒû"/n[óW§oMGEÙ©|T9kdœÃ샦(ðzC¥¿;ŠÊk\¬´0Ðþ‰,¤á“oÜJ€Ÿ¼+IŠÂÙõr|b¹Ûx«³…ÂB¦´†¸LÏn+O¶1E^@é í“ÓÑY‘(ƒß¢µØ¹ÑÍÚqÛoY+ÉB¨T5äÛVm51jihÓ¨·˜5ku“õ‰²ÄYî•Õý²@¾ûKÜù8óì磠§R®²ZYi¼lêýtzä€ÂhÑçh’äA¸­=Þ>å:3ú|¦ R‚»ãɳXœÜ³¥uù©''˜_< 4P“—f’йJ žy:ÐÝ.—X¨ô.ñCXycü1`D‹öuðT oÂß®Izltè±pH<éI,‘­ž®Ç#W}FæM_—nNYx?Çâ e‹Óè•TäPÁÂ7¨iuÄÓÉ[›D…‡Ø/! 'ec ÖjäµFã³@©Äv BÈ](.`ÎÒ5îè,ëóY%ÖÛ?ªƒ�J +…áÜO�ŸÝ14—:w>ÌëòîøD§˜eð6$°”Ö]³Yún»£‡±…rñ¦n‘mR)ºêO¤¼†õº~[]àzáÞ¯¼sCÄb(æ`U&ÞjyM‚¦üéD*ÎœÆ9ëZq꘾o¼Ýt¦G¾ñD½^Ìã8w§£˜w ÜöbZ©gLðÞi4sá›ýŽŠ}¤ÏB:­ãûr¥l^Vl«ÌJ"7­ë`ÜÇ"z·˜â—žª1ËÅÔ#k µC¦m¦«¯‹µ“çîVKÑ ™›ÒÑM¡cxó¦o?æky‹7±u¯Íi7±!f?šPÏ*ðã`Ü{ÌÔé¼³ÏË»\ä±ñ $rB=½ïNÑf;2ªO'f?kÈÄ>Õ‘ñŽ <Üì©;ͼFÔ¸ìgþiÅQæÄÖ= :©FÅ%Y‡‹ ²—ž F˜/$ª»+Ê0¾¼Ñ«t0ï™î®1OZ\¿¨ƒZx]±ém&zªvõð¸}ËÖõdEÇwhîšüñ1èÔ²Y/‘œVE3¹.Ö7ëQ#mÜMÒu5°ïäÒ£´ôÏZœ %Ñ»"XßépY;ý¥Ÿ>ã<v O ²ÌS“P³)GÄáÌU‡j×—vÒwŒ‡¼+Ä’f™)¡bé<о²|' 6h(„bé/À4¬f^i*öÐ%Ÿ[…!e¢â ‘~ È{í€\ZÅôO¶öâ.Ý ¦ÝØ×".Ëàš¿ Ì–¹ëgò¹ØOp^Ýhø)$Ý™MÍ÷\± ¬ÜÀÿUH‡l}±‡&wTz¨™ò€ú" ÉÚ<£ºrm†`j/Š 7É°¡2›‚… ‡ºÂýã–˜Ç :Ô§ž{9Ò´Ó0(TF6î|R¸î™‰×?sMIÔ #¦,! :à¡äÆÀ´ûW–¡éÌF¡í¡u"·ðï”m’"[øÊ'Áö©÷¸»]}þСúëÌœæxêÀ'º55qž8\’Çý—�œ\+Nc¿ÓŽ¦™mgø|“ÔÚ ¢ç,_œyJ^^µW]Š™žâE›T ÙQÜú‰ç½IS”[ÎPüº›2¨,l ÛvâT¶½Ú»˜‰’’ÍÜàäB ¬Ø4 ™.†š#7Û­©†õ‰EÛ7ªûÖ7 R•Ë)èÓÇ«¶[…d _e¡|Lq’£Q_N•kŒÍýßzÊó‘¨-ŘFb±6^±¦ÿ®ˆ›°c("D¼0LŠ<òXä,�Zí¬¤¦¢,wM «ê _Îû!¢lžk>ZrME'ƒ:œ5(ç wËæ–V¼Ì®oïDépýˆ–)ÛyPnUÌ$åLí0¶&­gìÃOÓú$ò,…4 ·³$ñ’£y¥';Ûƒ¦š÷¯¯|Ó$ú U6QýmœÑ©{˜ŽP81þ?>få�.§ÎÐŽ…œèãf6“k·¼Ÿ±”7—ßP¬nŒùôJè(óòÙfaú ¯6ÚLð�3ùá9WaÙ aˆSRVµgC;çñu×í ©Ûu2TaÐLªÏ ZäžPVå›6÷f7ÿ«•‘Æ,ΚƱTÞBˆÀ nC£‰2£¯ ì'«×¼Xá|óEÝROçÌéªr2HÑ Šuç™d±˜î‡Îþ³ˆ±Ó†“™2Vzzñið™1‘à°ö2Lâ^óß'¸e.µ0¨WotäVÏ¢ð¹8¢ú*à“Ѩ”Ü\ðßì[®ã)醡Éú‰ûJ'¯«‰t%¬Sû½Ö[^©+A®'š¬…±Ñ)æ/dä­¦æçôÌ~9j–"HÆÙûŽ»UǪ¦N—‰ áY©p¬m€KÔM¬_DÎpŒ1¢vüã€8»X1”~,›:¤ÈµSN‘5½à> wíßlJw–“>\/ýUj­~Ø‘¦MÛÚvÌð|¾DßÂج±:±F¨ðΫÎ]\áª#5³¨ä8hWÑoºe:ÏMÊ\ÇùÄÃݤŒ„;5ëBáhê=œµùOõܪÓÌ4 ­ûÜQ"ÝÎ?áßYõ·ÍT`l;æAÑNÞãiW³À?‰¥¡®ÍÕ’ÊMšD¹d†p÷±ñ°6öã Cdî{¡7:Î+kl³@\.‚â]kõémÝS/j4IVCd9 )/ÛJûÛ:â»< Úš¢ûpa`kHËG RŠ|1z¤¸ž„|ÿÒÔ¹1ï\Ï0ÙÐoÆØhÿ¹1O–˜‡bkPVZãïa/9hÝÀ*‡ua}Pö2ÊßGo^E¡‰b 9׉9ñ Òè¦yµ˜÷Zi%Û¥M9ó50Kô% ¾ßoþZi×28Že®uú Š†¼$¿•xð6öú ¦--Øí€ëX³Žñ™ÃGW†ÏÑfȘÑ’#ï¹ät•0Ø3øÅ° ú1oÞïõf…o-Ë �+}¢s=ZÁð—š>–ë’YƤ8ÒDV0Zú¼džS¦sÜ(÷x ]þxN «úlíEóµ¨Aw¹ä7ÇQjéB1ékP7JHO%ýÇšáRíúÈ<cºº²úžè)û‘E‰£k@¥`5…äµô N¬f7bÖ/]rëæjÂÆd‘‚Â`øÕ^Ù ýÞ í´¹ÖUÐo¡Ÿ$J|ãLfá^¹ÂIñ8CÛƒLÑMí ‹9aÑȘ•ž™4#ï]Ýx;é•ÇÎ@[/kj70—dص W@M(÷¿›ÆGyœyF¾<ŽOƒª·öŠöõz>žÇó›âð(²Æe¶8b˜fb™«œÙ;«™1«ú&| ¤MÝx0µŽwif|–ÂCÛ6óe­){‘%a‰ ÆœJA¯«l…±/ÇHŸvÛgôõ­ ¨ï|{m'- Œ¯j¯Q%íþåÖ‚­©¤áYòSÍ·§Ï=Ó¦æZ»Os€2»¢Ñ «Q}*é³lÏ´sOÓŸ‹×SÖ8IüÖ>Å™ÕY&7‰37¢[Ô´VüWÄêàÓtn­‹¨Ó/òe¸ï¦Åoú.sÅÎ5ÀëaÑÖ{3(šŽµªÔ^«ÕFU⛚îGŒœªqòzts‡?–nÒ¶�´ ¸àŽøƒ€g†!ÐäE¯µ¨Sä�? aûvîøÃyWŒë"·È!æðU‰»Õß³óïw#›42âï½’<Ⱦþxí-J¬<òMwr?£X3-ìg³mkÒ’›®Ž8“Z3aƱ‹”ª'¤¬Þ¤ßÚ”²°ŽìÅÒ0B°Çîл/ã6@Èhu\ÒàŸ’â“l‘*Rñ:A±)9ÖžLG…¶pˆD~Öh[ Ä©¹W„ÕïÝŸvºGI¢<óÂ|˜¡}ŒÂsãý‰ ðÝL¼³†P]=Áégô¯䉯<²mÉD…ø±÷¸ý,«Ï}BVÅ@T \7¿øžñ¥ûMµh‰M-Jÿvc‘ •ÖiômF›—,ӞǢùB ˜Ž…ó¦ ’ºöàŒhß ¨fí<Vlh7øæg †¢Z|úœSëâøîiX}¡CcêçÛ\úqRíôs3bœÊÿËãÑùVÈfÈ—éª:&þ#ù»*Ê|ì0hŠ"ˆ¶“óÖÍnPøh½7xÛ‹kXxêßm¬S\Žƒ¼µ{¹dm¯mc î—¢râ\Eq¶‡T)dAØ»a7­JVl.ÚÙ,æv# ʲáξ*dw¾þc‹w‘ Q€7è ú;7‚ù)h/OœB]ÆÔø î#³ª¶�¼UÙ“5B<�¢îêÕHO^ßõR+ðÔ¸\1IüßØëµ½À:ÍwØ5"0d¸{Œb^öº®~ôìÈCVä sÑfl,l"„{/%Æ¢|êë0~¯Éè0¹RœéžuZØ'w`¸ø" 8+œ»eŒüiÜþóhnz°XÝKͺOãžo8¦ëqwNh-" +ª” Ÿ£açâÐljõÖÁ¼¦me+[ Ç« † ý÷Ž äæ©:`IzÛðÄþbZì¢äë7Yè 6§ ²@ÛvÝ#Í­­GÄ;µy¼  Á©I½D8N]ØÓ¨{sH¼ I3ß<ÊNs{@°†— G¹3¥‡£˜ïÞ:â>·ä®<Ð+û‹¾DÔX· ­cI„¤ºî-®Å^>ðýJS—Žñ×Xè³÷ ÔkÄé–ßÜ°æCi+¼µýîO LŽìž—=kÂЧÅ0^¡$³œtÜÃNé@‹ë]…wwƒéæýßå<¨ÚõÎWËÙoáô±#7h”7ÚG¥·æ |ÙÑ•eÜcUõÉLMÕLmIR¶Vã(è€øÓÚñ‚L8®^kô‹bOc4çRu ó4è*,Tã…ƒ¹¬OJ¸NÒ×'Ö:ñSÐPÙIQ,|d;Ö ÇKnòãê)ª\{ÜLÜ<Éß-o$eBU-c<‰èz;tÀõègïíÅ0ò ÊëÓ ›/š°ññ¶¼�÷÷X”Ô“ÖˆÍMË‚âÓWÑogl+ã¨d’| ³ð÷ï]Ý«9c/s{u€´Óå¨_«dFìÞ"l¨FYê²Q*Æ×ü溷ÊØ ¢ [Àná£Y×ý¥Ø žÿ»¯÷ÂóÆvš-…è‰ÓŠªß=Ÿ”¡>B!P‰‡?xà±öR™¯¦®tÖŸžâ±5HfªÉ_ÄÕHc_;í³óª· ¬1Ód Ë`tRMÑÿk:Ûñ×¾¶+é î.I}­´õbNgÖÓL~‚ñ›Yº¨Cy¦sœ¸3ò JÌ3—§l†}ŽÎAù¹6Á£c«gu½Æ/íÎm=£êY¦‡¯BCÏF ®3ô>=,*+çȬY¾RTarê›ñŒ§OG¦Ÿ±:À“\ÛHQí׎[î¼óð¼‰þ©<p5¿aw¤û3Ÿ½† “k0=ȩ́8H¹'-†ýGEÖŠ=fnÄ—ROü¥D;Ÿéý[ ªÇíi±Z1ž¡¨¤fç®Oa§©‡ïBÕ–ùôpXq¥Ò tÀù«æîüö~è#?þ“ÇœUÎy,;aújVß/’E ÌïÄî´ éYg Ê|#mÂÌúŸ�;¦ôŽYÿ¾eyÃTúz¦$kN_>Më^#ÑÕ†D_lVzOY'Z ÷Šõ‡VQ˜/\.Œ_ï`G>©€ëéVi¿‰—Ål¨ôXÇÞëWà]ËÐc¨B–¯¦U»®Íî6‹|^Ê\Óá¾­/¶*2Ug}¹ÝËIjá=Âm\_(ÿhµ®ŽŒ'¡ôšÑØv‹¥Ö⧼3ÇQN ub òµ°>»i_;Ò_ól¿3ÐÛ‘g¾ª©Ê䃊�7õŸ¼úDKE/êGâ I¶ð¯‚#´_ãõìuKDW“Eö¨¥©C{˜'ðÄf© ™¹VN 43zûV• ‹\tÓe }'2˜"ø; `ìMír©ÎèH‡VË×B-‡ú7*°ƒâ.U5Ø],•ƒ«xQO@WR+÷“1qÎ*çS~Ä`TN¦D;èA‰{%2»*÷5ÅÁÎ癟Ñêõk8RªfhPúî×R×רۢdñåÝÕßÌúðŒaæÂì•Û‹gº€ž)ât 4<Zû’ƒ˜ëBñSšˆ®åg˜øBWú^U@R¸H×ï^SP›jØæ¾?gÞ 6³Òa«”4ˆû‹ÕJ¬€lv½b“¬˜¦ßœx~sÒìjÝ@Ÿ0³ Ê ðt þ»21÷o¬§/EjH¹$ï_v-¥/yd ÿÝò8]˜¥EhÒÑ­­)e4íjg]‰§®¥5ÁÔ;wå{ܱëbÊÚ;ˆt¬uxµê™Öhc e2û.Íä€Ë 0ˆ$á‘Œ“7ôÕæÎ"Ÿ³Ü$¬~²më4×1PZ·Š g Ué“rOÅ; {úý/|6d®ž{Ú;¦3#³øznW EK9g1 ÛG¬-« `uTjDy+“a4ן·o—·ýe¸¬)8¬GJAÇz·µìø×|Q;4ÚÏÓ ‡Ñµ¢u0¹!Z£„×´×Øb[ìüÂÍÑw¼m³¦¥¯ê4PKÏj­½þ2•‰¦GÿÝõ2Ó´÷Aë¾ÈˆØô!« ±zÀ*âÜ›Ž!ÀƒlUTA`c1GK/ìºQOb GkU²ÚSÉÝ.TLi‡Žœ¤;ó4< ¬ðãiÄ Ö¡”ŠÜG©Pô:5´ñÊA2Réõö®Ÿ¾Ì‡µÏZNH/4ýþÕ!£:ròD€Ïx î¥ãçwËÙ¸+Xt¹™81NkÌ ‡R´_0N°Àm½…T†  ÐË/ZZ+‹ÁßÒH¢ð\TD†kS&A¹>º‚ÔˆÛévlå\Åãþô8å”oYs´HäÚàí8¶˜X­B¦Ìã>‹‚¥#MÀ#ÆPïHn+ó/f¼ ÝÎâyPÅ•=÷÷=]„˜ÒAÑ!þ7QP4¼ƒÜ~�z¹ï€ù$e«Æ\ûoiqâTÜBÐéY†* &kÊ…5±ÕIfޯʟ¨ÑEÿäéÂpÄ,ˆ,3(‡¾vL–ï‘1IìS ÷9–AÒûj]}§m/QÙˆÚá9+5úgiÔqŸ˜Þ³?jÚ^»¶¾ð7ýá2«Ø(7b{ßxÅ4¡³R{¢%»²ÑŠÛ¹ÚvO |}q©Ù«Ôq+—b}¶úž¾Gt¬-¯ _¡þòPÿç0âýÍ«UŒ±¾P¥p˜§Y$:X·ÖMnù õ,¼ÅFFÞ*-gÌn¬CÎÀô ­Èq>šßèCx‰8Ç17hLÙþ#”hÚzNŒg¼ðy7QPïìë¦ üª¤²,'+w"ªŽ›ÖQöñ,[Ïêúf#½ªïÇžxøJÌ›ÖsQ—|…4×¼H_¬]ç"4âÿ«=}ŸòS;11¿WÝBÖ¶ÓŽ—͆/¦Wöp± ð,Ê„¬qKÉ3,âF÷iٯѼêÔûèÕ+EbnÑ­ d”¶ÕøÇY!¨KšÁ¯FÆoÚ׫¤³L]¶M쎴h¶gÏ¡ í±Ç%›¥Ì…q­¶jš¦ô jLO}•¤ +Sá­áœñ¥·€Åi¹U§µ÷‰µÿO-ƒoñÐNØ9]gFØgµÏƒÈš1Ão-&Q2œP00úÕ CyЭÌ.kùš½¤lÃ6 òµ¶ƒ7>ú¶‹¼npÀ"'‡ƒÎ—ö5ì™{ÆZÚsX+šç¿B)Ré”Lìr¨M‚êdóÛL„•°¯|åê_»á×æ$µÍ+¿qu{œTÖ¢;’vt[ûY€¼¼ŠQ‡m@—·ë»Ó‚;¿»Ä¥/(ƒí8S’úÙ_ub¶àµƒs†<ê+TXA±1Á8»š†á‘œ41…ÝK=Öo,ÿaÛÉô0Û¾Þv4Ç^z¤¥ËÕÄùÍj^ÚßJ¬Ž„i¥ ”fM wukkµL2\Ð:§tTã6LwÏøÈ2Ä¿Ù)sû—v`¬¦¾¢)N·¨b|ÎÉIx9" Z# vuéâJV¹æsŠ¥*‰Àqö-B…ÄcÎ5{þÿ8Ho }Ó‡D[[gL {mV PóÛ1\$øÏŠã`2*þ ù…”rílJ»‡4k0ßsˆÄÃÚÏÜíH [TõEuø´Z,·27´&>'üCm‹¹EœZwõÚôÝévÀKñ›Ó » r&E{áYÙ'i&Ü8?\V~Yl[KÜ3¸·™z‰é(í–pÝy²”~êõcEXyb]Ȣю-?'Ó ÓRÀsp+°ÕåߧZæq¸h æò±?מqåû©‡Ó_J~¤È~L¦(>]N©â»2i³B446-û.HÈç> ¼)žYqUΓP„¾‡#ìýÚ+5‘™ ] xéÆ4O_±VDYŠ%”ÚR¼íG¯w1ïz&á*‹®؃AAzVò €áMvùô\΀%ÞM›ÚÚîV=·Ê<‹µÇ”¤!ömjÞ©¹ 4É –ÜvÄpÀ]óA 4å…d‘íÅF¥«Ë œ´KľøÀ†oJ»Þž1üÖ×Gª¨VªËÀÓQÄUAZ+;ñi:ðiÕØ\üû". ß ‘²Šº¯‚â¤R39ÊôþÔ6ždç8H²ÄïÉ*_?WÂŽœ••Â>sN3¼±Øܘ6"KÔoÐ_ö{€Bë]bŒáhõ8ös™¾d£…©ã-ÅÖéí·¾çÉËýL–ùS’$BR„cíù ¯úúˆdDÒJM”¯_]îšê™ øÚˆk¾ÎC-fc<ÚãTŠ³áÏ¡·s¶gÊ°q¸tMëéÿ§âó ˜Þ³±ñäéùƒ;Â}²o\ž ÜYw&O×æÊ(½ÊWoh_Îÿïÿ›<e†*&sVpÎplW¬h­þÏ­"hd¨…ç‡ÅìPW«Ã�ÁXFI˜˜—øºŠü‰S¹NÂSu c:z×T´4~ °‰­Õká ©¢‡®~£Å«$©ˆ\¾ËPÝU—æAÞ) 4I4‘= »yÉ?ŽíQt½V¿)gÿT¢ª³®wÝÞÒû­50ü^8ÎB_ ‘b'£öËl^ÜKèÖÃŽž#ÕGÓq‡2Q’T/Çy¢×eèMqá_ÓI›Mƒƒ¨cÒºÏN'jÛÉ´Å\È.¾cu[º mÔ“qŒçµ¹¬£pÒÇþ±eBdå»øv†ñIܨ‡!„2'ž=þûW§Àþ†yú¾=¶rP”|ÝÏ#”ì0[w—ÏÁÉÎÜ;7@Ôù3ŠIg<Ø–];ªÈüadδ÷Ú¸Ê0óŠî”¶ ™¡ˆ¿¾2E£EÈÑjW÷¾åôÑ_¹öÅ{+k}Wá¤Þbc+ô·@ð´ºzw#^Ê /­Ø?¡Ž½39$Ðz«ùBIóÔ²Û…ýwñ(Y†Vú9-Êõä"–ÕÚ;Œ[0ZÕ bQæ÷{âȪžoËþpÐþ£E*€wiVà?–àÛĪÿª4ÕcKêd¡|V'fw–ó%gnö«ÀäæBÙá2 •ã8D±¨ dA8œ´·f![NŽg‰x ÇMðP#Jß©á-~DhÓÄw‹ä�Â!RfÖB¹,=;ÕúF*Çö–¢ÍEûh~÷€`µ³_¾¹äöëVP—|ÄÊÛy—þ(T5„-=ìjl<tLéy™öWsÊU^®iyœiZË4 _úŒ³V½›ˆ) Qa\¿dþ’¦>PÊœ´õZÂg–9 ”‰¶ßiÕþ8s³€`=Åß“ w óŠéYŽx!§ ½«Gu½°`ºUÙptxg°¢ÍvEÕ6SÄ@ªOÜ»pŒtgc#ù¸–²žyб!Æ{%``: Z‚Ü4>âÒ¨±ü7÷ÈY öЪØÀÎ)—=#£x`­µÞP8¿=ôª*\&8m”íÙïÝ×Týësþõ‚(L]dVqƒé˜?nÐö5Û‡2è™ùË/ÕÞq´Ø@$‡#Õ²Y=x iÜÎôíaƒiíY.úõʤ”Tñ8OnÊò'Š�©/ €ÞÄ”Õû§ÍÕúJc9 aǬý±¾\É]˜i…7ˆˆ|=�n®$Œá‹,‡Sž¿k¯X¯…84FwãíÏ3¬c½2zZ·RïêÊ}<2tò±1JM€¨µP7xÐqm)ïjîI uN5mæÌ¥J”úAÑé¬?Në@º=œ´ØRóñ(¦ˆ}£S�è»®5^ ²“îÕ<Þ< ¡Ì Ò“kïýÈNÚÛO9 a ìwPH–[a'¬öÐÝ]º‰¥§Ó Ü-`H‘6®¥“o&À17ç ê6JSGYÎXÂ夆ƳÍXﾬf+eq­«W+Ldx¥,~P¦<÷ÊœRŠ6Jp!g`›ˆlQy²«¾'õ!ç4 †h¦M¤U¨":ï=Uù·œ"¥µ´pÛ©,`¹ŸSöÉenæ=Pùf£"•‰èï2KŽê§bgqš©³³ÄÌ® ÝàM×õ™N›îšÁúHóÂBCE0ŸªÅuTGêç¥icQñ`›ªby{q{ø—N!;âOÜŒ¹'SâƒkN Ê*L€rWÏåÜU¨G˜p”Ï“ÃÒÁ°²oÞÔܾ¦lPæœ/²¢¬ry5‹ì®`z”t[O‘ø4­N•?ëU÷ºElt©AЭzãMcšÀÇËÞr9Mßc™)yÖ©w®�TÇ”Âìt¦òºÓÎõ»oÆ6 U=Ð âÁ¬w©½¨Ô3ˆaÒà ÆÍéØÚYÜÊõ椋©"ÝÐsqBî­¬Žflü¦¦;c FáVÃÕ„Foí´;*¥›áVA2[ äÌ8áçþ• ö7ô‚>¢_C°ÍcáÀ&@¬°¦T”ßì~;ıÉ FžZ!ëávkŠdï^’º>@~b+8ÔݹÞÁ’û|‹‰º`Žö�Þü,ól—¸ãØÀÀ¼°ºÜ©1+Så!º3ÔÓ‹où^qê�!<æjr EŸµS¯…·LúÌÊ*:â>K²<ŒÃE±€Á¦b%š[cô˜Ñ£ãaÆŒ¨÷ZÑÞWÜD=­HQ#n¿Š GçÑV§EÝÕ»/™5˜ }÷PŠãØW¦¡ßLô™«ÏÞ£O¬5{TmšP5è÷¦ ¦< ÊZ·¡+‰®Q!à¶1¾¿4:]h¯®³;Oûmä\íi=‡öÐC1ö{s‹õi¤†ªÆ ^¬råz‘xˆm½ãNˈFbhÖõ0Ü°”_âpñb_ÓìªõÙÅ{ð ?è7 '?ðºñô^E˜o‡ ÕÖt¤s]ç!òÕÐø2Ëã¶,½wEC+hË ²@|F_Ÿúµuœs¹Àêcx\çZý"úÞ[È‹iÿˆ¥Gx½?¡P5d-PFè2Ò›éë+R|‰#¶Kó/Åßb½öZ1K3 ŸQ/3]ñ¥ ]+6±<yÀݺo¬W•$<Ó\Cƒb‰:‰<w°w+ƒ¨¿´®{·¿Œsïd’FVFÿK…N‘WŠ˜ÕïÄ¢3Ô²£ ½ ¬¯²ø÷ZNÅv0¤¤oA”>¶N‡ÚqT Œ³Ÿ7 ×v›&©õ“LÉédpäŠEu%št´BwJhkhÌM0±\Û¾ÞM‡ï†m=þþŠméfª‡g (LT >‰¶®÷ý.ž¹^dÞ™]@D—r5×]åv~½ë›mÀ¤¤/p©û·=PϦ‰ÑHLå·iÖ–'f¸PÐf¡/–X†wfüÔ‡1¶T>Â[€K)s¨‚¼÷Õ¦0¥¦pr¡p-RS6—BwŠ(·æ ¾ƒ÷XHäØyHU0;}ƒWuDòp1ªHÐB91³«S8â-Õ*&tÎ ;DŸÐlH„kñRr´Ä‡ñy¾n‹4ˆÇÆùŸ™·1 Ý[q—ÑŠ'¼ µãcnK®.*)ËV¹°1nrÿ£+ÊVÍJè8](²ÞiýÙSÇòç’K³Â)Ïü_ì«÷ñQÞ²îâ/¥íoœñâ‚1E¾…´$¹‹*‚oÅÞòÒ“7å^wL)UW ¦{‰½£¢7ã�’2G“u�ý´ÒÜ>f«;ŽÐΠö“â[i^º:Ô«ÎrI€¦Ù¶=˜€¸/—éÔ¿â–Z¹I¥˜`-[žVă)·ÛϨa"ëY»ùÆŸö¾ò^TDn=—ŒÙ;Ø}´€q4Èûµ4<%£”ÎãžW±eéÚ3ŠØbQµ­Ñr^¿õ@GÈà…Ý#t9©¡Ø²¸ÆýŸDÆîêI¤È|ËéƒN—£ú0E +¼yø:Æ9AÔ8ѶW÷¹”•Ú¤ñ« YEï´V Er” 0^Ä3Fÿdyæé›ÁÛà$ßøé‰@ÔT0:Ú‡;hÆ!ÖhÉô@5Ëï¹ Dý“ ôA Œ¯îÛH îIB¥yqÕÍÚž(—X+9�Jîþg;ìpBà©KïÚÖμƓ�`ÒPpýk>wêÓb£*VÒvÝL+—<º–µ¨J|!ZîQLð‹ÉjÍ«X%ƒ>øK`z&˜°^Ü«Í…âÆSO…ÉU�ÝÌÉ#MuPùò©oê½îøÃ>¹gÒ æNEpÞÐbIÖ6×LåìÜ»ŒpMa[3öâñÉl…g ; ’É >¥^w;§'‡$LŠ¯å*E¶ÐQJ©,¦?+ùëE÷©ñŒš¶–R{7|Èšã²NNR7œõÎØà¨ÝZÅ*�<Œ`Ú"¡”ßÝ;yMx¶=]ƒË^Ì ›:~NšO¡º œLïDMƒã½$JšEK}ÞTAüyñœ/0YÕ³þ°ÝRM Ò$|=²BÅ‹V§|&2ݨñ³¡ur’ ÒmãI³à¤_+ñÓhÛDƒÐa5vzúØCÆZ{¯Êé/wÒ•ãÃ÷-Ýê£mïJI©õÚ'¬bf&+WÒ‘Çkñ®þDÅöçF‹ÉD$Ê9 Zlwâɸ÷/x•ç¦Dû¯î1À;zÒÃhœÈ”�"¿ÁEz0ÃÂLí†mÆø\[’AÓ\­V<˜õw—ÎKªt)eÉcK&üÒµ†ëÔ‚á0U€©5CGŸì¶Ã#> ô{¨Ð²,Ó‰V »¤3ÆÓ^ø3ðl{¨Ž$“øS£üUþhijFªnQÙ(õŒ>º9ýK5÷ã‹p1÷M`Zdãìy»×ãçi7)Ûåñˆ0ú¢EÐ}Ñǽ ×|éèXßÔ_O½[sOdò5ê"$µ_^ãoÏ2ëßU‚ìàœÐõ²t´ ×!"ÊãEמ"ü±dñÈqÛm;¬œ6ÜÎ:`É {ãi‘:8>#Sº¯Ä#§Ö‚]gzO^º7y¸4²l’4È­"Kî\Z:6öÓÏ‹êraOÁ«ŽÖ[Õº ãÖ¹ZY6Á Ôö&ëÖÇé\  œäÜ5Õ¬d%bAgàv&Íc”ìyâÎá>7Ÿn:‡¢·&¥¯Ù-æ$ºûZÎ0Ù´²§¥W¾×ž½ïa’^×4¥‚O‘YÑ[}Z}0±œ/íƒÚ¿‡×Cu,îÌÙÆxê˜TË üÞ•¥Á:§M§a]4*Ú‰*JK °qúÇâÕÎcV1ž¢x7i—x®•“†»U»û ý;¦"ج¦ÇÚµ¡Ar“ÊÓd˜,ªÄ Ø¬Vã¬vƒPa"ëÔsЛåI™è3GÔz²c¹¥a³(¾MgôneЧ¿ÝI*ÕNŽ 7ƒ~îž3K–b€£uz£¦ã®n³¨*«´tâdpõ€ûòVmؤ~\A$IAH­Ìûºö—qºýÍö0q¸èÎZ±WQ^ÁGÇ R'Ác¢ÈµÞKíGdtGJ/óÐ'‹EËË 8é å‹)¥î(tp…Hs¨?,¼Œý>­Ì=ÈaŧjØD‰ºk ÐaÞJÔ3ª,¾õô'Íùþ�¨v�W‹ÍlÎ(íkc&©(ݾ7ú./ª¼$¹ƒ ‚Ú¬fz¬ññäìøŒëË”úì<ô…Z Þ%e G¤…J8RJ´èðÐsìÆ*(Þ* ˜\·Â ™'þ°ZÎNŠÚEŠÔ.íÝS_+„MJÊ ²l©’­8ÛõÚo¸½(žWEží#ÇV°¬Ö›+2í{`؆fLõ“™I”-,Éèœkœ·[oBf“/랟>c‡ÎuïmÕÜ¿ý¨xn~­Þs¨'W;Ó̤³å™Ô=ó¥* Ò ·îû´ ªË»'T·oíøQp-6õ[’ÈÀM‘n_¯”3RæÞB¨È¼âO2Ïä @òQíf  »=µ”D»ZÇæ¹ÞÔGÖæ8¬‚|ãqsï(é0ïÉßVé2’¾˜ž2j,à=·Ç ¡XË À{Ð¥á1ª§•|¡O‹h£¯”y_EDµ}‘R™â×¾¥¨3*CâgÑ“4»É¨Ñ<)ÜÊ(óp k�Un=¹XVáÁ™63;¾>®éË<qhXZÉTÅÕ­òûëSÿjK¸U0ïÐ;¾(ë‡(ßúÿGe0àCZàc;±N ZÅõ0rpìhºŒÌ™ÝEôïm™1< ‹Ø’ˆR±c¦ãM’ÇW¹§™7¦KÙÃw‹hn»Á¨ß„cÕ²¢<ÜÕyݽZ *ñ\¢ŽË)§'9yõça«dKÄÿãbÓ^1“¢›Û�S_OÞ®ßÍÿ¾%ÅÛ/¸„ Ã!ò],Чc­C^F6‰wýïÛªVÂŒwð°Áƒh_úïxÍŒ04VŽ› e¹ï¯“¿Ç ãemwõÜU¨—žÖ|Óaæ7¨%m€^\%D¶8Q$d xoû]ÿs?ùÁt^¡!­™Õ&PÉyÙ—ÆkË4Ä8–š_&ù'^£=âPZ2>œëqíN*”•Awhr£õ¿Ò¦°»LóHŒ’¢Von•[¢úÀµÓÅò§G¯L’R%Z^RqPO^×Ã# dýÖ¹ribª(maØ“SžR…2øNLÐVôÔ¾ýÒBÓ»|šr™˧k伫I*™WhˆBÜÚ™³°ô¨Àí1J–G�MŸ7:ºSEfU|iÝAE¹iÓÔZ$í#:¡þ}Kclø<@;ü-†ßKë£Ežó]£Òbᘖ‚£’Rb¨ghLô‡5˜®e¨Û ·]Û¿à¬D*"%Û¸n©¼k­\>˜‚±ÕIOØéÓî빇©‹£ñeºÒ,ú iÀ\`T<F†ªÕ:å½Ñ›]þù*S#.® ±¶êJ·ª¸Œ~ë±k{¸íì¬gúbt>Ó²[ß¹.¼#E‡ue±Ô”Ŧ¼UìÑÏTeíY- uzèãàj«œ¸÷r[ÿ¾EÅb²?ëƒêbœzÔ>½ò¹[Ò²`?Dà4µZ5î|é7Tˆð¤ñÀ´“é<Ñf?_ô_cvf\5BQy€õ{?8•‡zêøˆEαnéœut¸´C}zÛ2Ÿeù“©™s–} m¿¬Ýz£ $™{gA§c/ ³ÞO–í†<ô)qa‰‰¥¼ƒN¹3ób5šq·Z!BÁ+ƒ½Dg¡aáÓð©,Ó ×s‘âoOÌ6®±d¥|#ppÛ"HΗ…Q¥^õö4ÙJhœw{H÷š†±5¶ú±¯~DËÞCðj14£ÆD„þª#FRžƒCíÈx?‘Í.3ÏÆíçépþ·|ØiBCþ›Øâ³ñ”›183u0ƒc5�µçÝt÷]‹…[!Å#ÔÊÆÇbA_‡Z¹®bb¯T½ú4¬„Šê]Ê»Mǽ61³/ 69Q•R vbšì¢SÒãIÀ Ûiæ·€ Êº…éÛ—:ôfJùÑ=ö#’Ä3I‘Šøð`QÿåiïïT É»58mßZEf×.D©°Yp•»Žýa~ÃtZW)ï7±{[m‘'·9Š=×Oñ¢�[̺³¯0fZÑÿ¾Å9mIZî<à ÍÊÊ#2êõkÔNK³4—W«e×+x¬¡â•äá4H³…Eõ·7ž£±bD<úƒ+ݬò U,P‘¬ëÿ{Øþ®¾ï†xWÝ¿ð¤i˜ ;lé[%kUà®=«š:Oz,“‘‚^&K¸ý•½¸£,›9L²ø ¯çŠ¡Ó‰m ø½ø=�“˜):~äøQ‡ìw4Xjvb„©WRëš±¨Œ±ï0BТKéYzñ^|²Æ=YYæãѦlð³óFc«žŠaVÕp¾³Úw÷ l°ÊÇs(»¤o½ª˜ <ãTÏ*VòCŽI‰<+ vh ~û -[¸½÷´ê*5·¿<õ¹ÑÆ)0µÒ¹M4 >Îó”Xñ3óÀ< @¶œ½âãF©)»ló“<ZBÝ_›Ä[U Q§Ü󑵆Y…!ë}"M1‰ùŽ5¾ŠÄ‘FDç¯ÆÀŸšO«Ž*«NZ Ûá8î¨<Z#OþÔxò"ysu,«‰sNÖfF÷àKap¤ôŠïÑÅ›‘ýp\•E~ÌÉ…Eä2Úk›¨Œ%3d1Lݨ¸%wÉ!µ–&ßð–D‹PÀ¶îUÚMfÄ€e˜ùO-¾8)×Ãì^<a¯ÂÊ kðÔ-©;É™¼ã©*½2i‹òÄ7Ìk‚²Ôôs멨ÓIvpªï¯Ãò¬&ç¿T­»*(ç/u(n°Ø×C`ü>”îÃ¥°Ã+Ùé#+/R¶>S´ÊÚZgÌô87õnôTð9á¢N°£S#[™Þ°S‹ÛôÝê ¤f ³jò é¾ëÁH�ËœXRý'BÊõåç2ˆ?µÈÛ@|k}eT§tÓVýÎâ0I]öŽ?“P4f-Åæ©ár‚0T7ô](÷/IÕÂå9==„î‹ÙAYx"¼Kù¦~v.ïÏî~úÚœVW˜¡(ôý`ŸuT¼»ÔV?wPSýÕX)Våê\ýé@s·Ï¥%••Ò6ì/¹îùB¿ uaKÕ¬Þ+1›Ù`>¡¶¡€žx€~ïêÆÏR5…—ò¦›l߈J§ ¸ˆváÀ|R+}÷]ÙS&Ž{"·:²ëáqps?ŠýÛ¹Þõ\Hmèñà®_s±ç” ˜á{ŠLVØácš]O²¿˜Þ£^èsü E²*1‡ÖÒ\Ó ?•ïJËé`mV&v»n­_î®×åô8+¤Ã'ö„ÑÂ"èio¤¿®Ú¾ç<dzjz$jŽëº‚×#KÇËMBÛè-6‚ "ûņÐÙ´ìÌŠ¢/醸¸÷ð?ðP1'ïPD›èü±ªÄ`÷zhBW‘öÙOÀ¬y öP™ë"(?U7%³iµ‹þ —X­Ït\Ž­,$õÀ$r²›˜áU†4L^“›Ûª&ô=AÉ¢Uÿ{éÎw¶Õ•sƯhk OšÇÓx0ÿ(ƒúÓ¯2ÃÌgÜÑ·Gw4ª¿<ù”¾†Òi¯¾€;.x )þ꧅³Pä—”I„Ò> ªÚê]G8=ÇCk¥ î–ö/”ùŽ8È}R&Âdž$`J_ÌÈFã|gò”Ñì« 6î ‘g¬-þ›Í@÷:aQ6Õ …ÈtP¡ñ4Íf×Jé¯ñæF×ýï<]@>Á«É‚ÌÊÿK|þ½;èA¹‘ôº jtýªmö©&AÚ¨ñã>埳Á Öœžó»¯^ÂdiäÛœÕüF8®B:·=ÝC‹÷מÀíÅó.A˜Òþ±„#Ú¦«‘þ¾4?€—ž¿¤„ ±vrhTL±ª¾ÞJ`7¨G�ò,†<÷cÁžÃÒù®Oê¦ …y »mAI®–K‰qE”¸7aém™®o/ž+×7Ç“¥ÇºŽà>â!ÚÕð’¿>Ì›ø½FI’„>Ö…‚Ö™bû§:ï¤ FK¥ŠrL·¥í§¿b#;wÄØ”có' –ƒv0æJPÓceëõNÇĬ 'êõå¬M|5¶<‰£„}ùu fÇ®k# zO¥ðúsüþ}ŸÀšWQ”,õhî 9Šm‹ÔÃõˆü5Ì&¢ÄÖ£³û¶äœ¡Ó$j.¿½ù‘‡E¾’¤ièÙ¾SM±ÛJî{úÑ÷ÛªV}Oµ·ÏL”ôaxJ‚¸ï„]ðyâHj5èï âŽôÑÉz/ë:Šúèù©êÍhÓ·ý¢X$Òr}uâp°¨.ôû*–æ0'|îÍ ÝÓ¦²œQ½ºí神´)`(ì$kÅãeôÔ#ï*¼¨<T•¾/Ýy”Vn9ÂÀšÎHÏ(9á¾€¾>–Á¬|Ì PD¿£ ëtÊž'žtŽ“ØüV7+<ÐLŽ:lÚ¶ãìºõ¼U¼‚’bá¨.®I×ø3ž‡þÚ…ËRGŸ¸˜U¶<ašI/¢k ÷õ‚ïÉ—Ñb :óœPq§¬CˆW𜔲úzÇCXIûŒ©Àñpæ?ô‡MB û/b‘È çÕeÐ{ïî Dˆ7�{È *<JÉhÃÞ‚Õ>ŒUö¼¡ø¤“_4JU„‡Ý±;|2¶FVì<¶të Û“ù~º1ÅÜsIõÇ»÷Ž½g�Ì}usjèÕc,_””~ç‹õ úú§Ù‰\q£÷U%}èÃÓÖ`ôá0_V=åG¯âe|iÆ¢o{ú›Ðú1­Ã´Z‚ræöüa vï_ÞNßKOîGØõœV~éîìâñ$Ê�54~!¯´¼=£õÒª£Š^À4¶s`£ëÝfÁÛþ0Ô’>íƒ œ�ÇV}‘G϶Á¶Ï ;ÖšyªQ4e²þ1©tzùf*ÇÉÇÕµ‡yb4ËíÝÒP&`NLõY¼ïÝ ãgÔnäüXJϘr¨ 䎴^«A§ïÒNw¤É¾]ƒdt0™ˆ›&À ÊÖ;Ë&yÜý1盚ÓSÊyøBÑÙzT7Óµuªfh²|¹m+bþ‚fEú5x †qiŽÃ#-7¦ù«ú9öèu¬"µ;¢×н›?ü1 Íê�Ʊ­²dDm¿— ÅXMÏi˶¾#U~åJ“Ýe­ü:´x_±S½ú½a¦¡<㱈ño€äUµðŒeÔ]O¸Aâ°Qj8\^gGIîÌ Ä¨¨èk¨áXÌ95ë,O’’S¹+öâšW–„™¯¶ƒ¶B;oº˜`XäÜ\Ða¿0ö-—ð<< \÷Q$Yn:ˆª—ÑLˆ›wsB‚9AéHZ?5:–;éà©Ö·ÓŒ$[@Õ«`Ô§:é™ àªÝÑÑä‘´…ÅY>˜V'UH–7^òw~Jþë5vCúZEPN:v¨x¡ö-Å¿QÕôÔ­îeñ/ëw]cÔ¡¥å[ gkßÌý%Z$¾Ì0}íup†N(?¤ë–hrm g¡á‰q.Q¡ õÙeê¿8-‚>J ³°0LþÞõæI˜˜õŠÁU»¡“#¡,“Eç‰éù¡kÝÖ<4¡câÂsì{’2¹R# ÅXÕ‚26ƒK¯EI—ó›ÞVçEœ]¡÷xHyÔçÂEÓRRÊ (©0<']ïÒšˆenªD%°³­ÊN¦Y#=QIHU°óúõY'EQº‹cV¥ÉOGFI€.=ì]PQ¼î[d¾P N/áߣ|KWŸ'’w ‹*„¶·§U= @[^½}¼ë�è™s#ulé� ß•ÀÅœ©ñno€s¾õ‚Åeâ ·—âCIÏ·²ú§('—£?”€TD;XÚ}bZdÞP?Nƒ} nÚ»"¸ƒ6Í^¥CG þ\¨6ãêÑØé3…ižèÏ”Ç/Oîxƒ˜<,¥oMÇþÞ%B]²#ƒ¿!PbóhLƒÄ7Û௠-FœFSŠeEP×NÒ…£û=45adæ½ñsì1H"ä/—CdN©©Òþÿ‰Ž8¶x0Rà‘@’Qê µKÜïf@÷òØX’ ‚e}‘GªƒŒcK«³cÚ`ßÒ.ºŽ“¾tU…u2Œ M¯=1<À‡™ÐeÔðŽúv¡ÚžËÉ« <Í|U$úæó'½i£ùÉoXE2­Èj?VòK—¤~çw"ísÏ–É™Ö_½±ª‡œ\yÓa:Î\ J¯w�£¢ÂAVƒàV©Õ\¦Ï„iÕzl”óŠrœä ÕÿÍ P#��áˆÐ»è‘íCdŠÛ<Óÿ>›gû1lÜa°÷cZÄÌc Fƒ…¶dO4T _éÔëYätÏrÆëG³Ùx©çÁþƒöåúÝ3)Ñ$–þ©i°X‡Ó̳?¢Ç–…Ÿ‰€G}HiwÍC!zsšlF:ËÉî›à<†tšŠ\H …‚±¶V&Z8 1ÉÆ6 *c¯S%>øV=§ðô?ÛõÒ�wWNI]p†~¬fßl<õ lÕ PuÊÐr>xG:ò&;¢eÏÞ{½²…‹zÙŸpV.¸ (cäEt"éO±ÿò¡“ꋺúR­|ìMVÕ·õ^‘g¸¾bÛnßÀÔ<‹ïñTr®(‡¢˜AjE.ØB á~hÂÐ÷Nq ,²5 ­~À§ZÏ“¢«wýä<•÷;t*XyVd5úÜû‰q`îÐå"ŸåE"ëàŽ¾ Û¡¬^y<è+q‘¿‰³8[´ä§c$³¶÷¨dX›RhYÄôyšwuǪS³ 8… ün¥; ž¨Ç×÷ýc{�[Y)9ÕúΓ•ŸY]XŒ#›¶ÿÉ¡æPk¥yÐRÀög¨…Ù:›Q¹f>x:a/øŽl­£Zæµ¹â0R]™t§$È?OV¤@ ê»Ú#@u'º©üχŒ®IžÌï÷™D{‰Åi¡IYì6Q³àQOŸUWž9s†ýŽßÎ^Ü â…XÛðŒjfšК–»€) R""Ñ3}ÇUwZË­ùÞJÂWfƒÔ‰ ød<:óB1º•%3lz‘93&Í<vØPŠvu˜,éZ¯`Æ–[£‹è3s¤QiÊ‚š—¦¼2›'ûÜkGÒ?AÏ É¬@0 â~ç¢=Úh¦ôßö“Ì-Nñ—ãÙÜzk*>ØZ£ìi'õ΢·_oy¥Cî$PÍotÔ^Ýå™ë–£»IÇœ,­?ža3¡£ÁgêÄ_[ô«:zâwŽLg×Mͦ*¨xÕü¢ÞèúwD3Bïœ;7.•ŽG›F }ìœr ›$FþtlC=›,¢è -ªgœ~h‹T”Î%ñD¥i§]-4ç–ÆÍk51`Zº›XÝçîR“…†7=§ù“¢ŽƒÌ‡¬¬Ñ.}ÁE=ÇGi¾âl·;*Íýæ�Äøº*Û£Ëé,ÜÌ ø¡{'éÙB[ŸÙR"®MQnúëKÎ çNOиÒÎ;ÖKÖ'V½Ž=yìƒÆ™ @k¬°°q¨3™‰ƒjãQ …f4WL¡å©ÖU[=K—‡SÀ!… gE[’" 2åö ÿ%5 R8À…yH°)'¯Å³¯Wõ©¯-fFXl±É)À.çíï1Ï7Ñ1H×*©AÉ1p~ÍUÇÚÍk—EÆk°‹*ñï\˜Ó%öbé4ï <pødp5”‰7 Òr±Ÿ\ÔïÊ°Z‚” ƒf§UAµ][}Kš¶ ðT^çú÷Žujï¶"O#Ž}»#Hc§?žPÕ¬{‹DÀá.ŸøΕĹÛoyW¡…è1–±ÙM7; Ít« ÿT%^û2B¦÷î3kÙ{œ…¶<vÐc¿¥»Û"e§?cÉ"tÎ \ÜhjÇQᢣʛ†>ºÕÚ,ÄÔè<xÃ,Ö[ÀnwWogÐ)FÛG¿ÅãN}-6:AÛ4¨¾Zo³Ïô\1¢û#¼$Ê®,išZ‹µn9–•à• +?½ô Y ø<QE¯‹Z¼(|±Pµ1gX°ÿc¥“Ùlw¤ŒV`ZvjJ…Û û8ó…¨JŠy«&Vp÷îíO[ $�‡íç©vºV ëÙª)Üšg6ÉDß"®/Nru.hfIS†í;=ßgŠ©nîÓ•$WªNßR€MËâí–Ãõׯ¥X8ÜňۥoÐeapj(eì=ѸŽîm¯ÖMõx“úÙ]м/¡FNv=Òm”†ì‰X}¤zþàuçÖ*3[pø·¿T‰4)´+ÁqAw}t®h"ˆ®ý.&#|ÓåQO Ôat Ñ?ZÊCÔ2.¾L÷š[ù afË&æÏm¤µÁ€³ìa¤�„‘Þ§Wûϯô¤ójÙÔÌÀT®‚bš\SJ“;Ž<ÜÇä²ä„ÔñmG1>-°výÇsó£Øĉj2ä[ªvk&²9šËM[¯ôÌ�щ‡Óoð�ã‘ÑÏ[ VÅÈŒYBI#’µªkŽ‡=ÒXSG¤ ý†œƒ‘{)…á,-ÿÚ”L|j?ƒ‡bP´ïÿ¢*…­XXï]÷•+ 3K8{äÿ6¤¦è®Ç#ïiï MŠ¾©iO\ó­¿eiúêÃóœX-ÕÍx`“{§»NûèËp -Ìmº(¤æõÚ©Å{ä¾| ˜V7«=¸¢*Ïþ‘±—\2:1)*„Þë nðæ„}=d±‡ë,°O¶§ŒBý»ïd½ÙÍƃÖBR®ßê¡Ù±Md¦M«.GΡò;tOÛ/Ð%œ öC¼^„Y±§›ŽF&-©hüò}¤„à!ºJÌ0Ô~êšË¯uû«¯ý9œ¬mÀKn$Î &7¢ÀóÃÉLoH¿ë”ÜñŸçVŽù<ö'ÁN=²šIí<Gš2ÃP‘eõ£ HáöK%Tyÿ8>ð³ïñ¿Ê…Þ,[•ArÞxÜÂñÔfÏ;îXô!žêon[Ô!©·8Xí©Ìkz7üj›vhÿÐŠÓ Uš‚M½–æRÛï'¾?Þ¥+¨s‡ÎÇÃÎ@ÞêXJö¦ƒÿç´‡­UžP ÉÇx™[§=<ˆð m?=Gk‰Ï¼,ÿûÜN@"ƒåíЭÈ>?­|w"ų‡¸µ æ󊳅x >Á¤·Ñ´`2„„í;ŒÄñ€ÛYZfy?©—¶ }ƒ ºO‚¨UV3‹þ¿mÐea©s|ñcÇmRüožwä£Rìùî‹þ„­ëè” dfÁo}FcG”¿×ζ÷JØÇ™™„u˜Ö~ÀŒÃr.ÿ‡ÉˆåoI~@¾ ¯öÇó<œ±™Zs㶶úÛ<ÇMG¥‚bKcfÑ·e}iÜ~ZAgV´ ° !!b½hˆb¯¹ÜÙò©w#¤5vH{zòG7Ùã2¦2;7 ¤J¦ÂßêÌP.éЉË¯…+šTe¾X@UÓÄAÖ\ Š¡¬7„êú·Å¬g!dPÚS…U¬ÇU½ÞÕZk¦†œåüÌ:¸J§¾‘A°ÃÑÕsvÀ­¾FÏâ„V9TÅâ<±½½ÉT¡¿}‘ä·1,£UV)·¦ž¦z8ü@6&J–2`}çã_<6ýo¦æâ<Ý«ªï‹F±o2Ã4BZÈysö$QçKcXpp¶clÎëK|Œr3ž.´)óîÝóÉÛ×ítk:fȆQu…ܸ¥dj·Ý-/}…¬Ð°>WoÓËÜ8 tôÊ@Xœªx¦žR¼ø<¾ÿO<RXl¤`Ö3:õdC¶®Ù¿[3FÏ^H“íŠÑ°x¶ÜΞJZ‘_ÖòÐ*7im q†rÓáÈ˨ûú|g\]z’¿2k¡z¶´/˜¢C‚3KTÜe¸t2¢~M¯$ }yH¾$”Ø·k+bihSá)Ã=½ š{2Z3‚ bÂ_…¾À—Þu�”À…õ:^7T(%DEK 5œV·Eݹ¦ U0®ë|rpvZ€«z”%aNÜý%þœE‰;ƒ´i<Å0˜¹±€Ñ›BÃ¥ùû÷`a Ë¡Ú|oè T¢#wÕxÓ©|ZÜyJt€î=ôÈΖáþt†Žž¹lw³+Š,v“ÂTï>*L5Ó4E×­×df…IÿÙû�aì@An×4 Ö‹ýÂC›G°ÈÎÀÓ)ùøéñÔjø“Í»•@Šx2Ë+JÄ>\æÑ5WO&H¸†)‚Õ¹ Šnôs"8 ¤åµœÁ¼Å–ÁƒvðôM}{VDX•ìt2U¿Aúm¤ræž>rï.’'À¥4»ê[t"g;YÄÈR�8ÒN¡Ãlæ7 §HÓjIe€òišYgwx(l�{’&Q0Q¶b÷/*3±\êõi¼NZ²ÜgKSv>œË l´i-TÍ…ä §Ò$?㩼$¦íYG¸íf͵:X°_()ù þ´XPÆÐBÃZuBÎ9–Q;ô°0SR×™Ù»‚³~ý"ý‚Jô)ÇÚãènN=ê\¥ÿª[€9ÒreûYYÂÕA¸…jVÈayp+—[&uEUIgëeA 20<p6Ê@¬x궕¥oQ�¡;`hŠ¦vÒL°“f ÿ9ŠJÒ|GãÒ˜ÌóF˜åy¬ß_ŠàƒÐíÖívSÃûm¨wo&_ÜM2qeÙeh5Þü"ò*³Ä¶'tbKl/™ß¥ÄûåºåðÈ1å¶O­¨7Þ¶ ¦!£hrñ,¤ÆšŒæåruãöXTæ~…Bo:vTk gÛ@áX´Ðe~'N¸öupÁÛaªlƒ¢^“B ªõ&0.w0«îM5õ-¢.Î='?F…ô=툰×å’ó³œÞ.oÍî€Þ&?Ðñ 7ÒÃp¾˜ ÓÕ’çPj¶yAéþÚÚôÔ�2Öª7F'ž‘…«èý¸_fþS1çþÈdóó¸ vÄìã“ú5`sMßþ¬½3ÏÛš‹èõ…=ÌO^Ž}>€iNBùk»õß1—?/c«ƒÇ�J\™g–ÆpbxW­=·Ï¹ußN/†J›D|ïyù6r¢06Ba;Ž&Š?ÅóɃӋå!ï²ÙªÂ ¡ žx{¢·Ë?øV±ˆ‚Umô›Pž¦ŽmÝ,ó»àìwÅéA Ù¥Á¡È<g«]Ë팠üñîæ’ÛÓÎBtåäô&[,¢Ì£§@Õn¤¿Þz2‘�/^ —; {ŽÞ§ Úz‰Wya!CJqø¢Pm;s«K–G‚»m!ÔCò)°¢”áuéÕÙB=áÖ'9–,Ó(8k©R×õ¨Ïû—8]tÇ ‘qA1}zþH«Q”=­‰ž<cñGž 7¿yÈâ‹ôó§¬tŽÎ°çñ%©|d-bWÝׂ#=2BldmµN‚Û –+É|y8ÈÙBi%üúã&™8ÔÄßÒ´9:h=†J­—&2YøëëŽ*Äè3j©°ÑØoªê7Ð9l?׈°Jמ9¢Ð,¥ÓJšîêzøVygoŒo´ªqÒ`ÄδàÿœF !£‡;õ­wa©qQž-V'„hètÿø¢p‡a°LËåKïf–͹¹Øú¡ä΃ö‹’¸î­UkˆÓ£ö:-7säöµ¾…á°ßõª°ÏèÓZ3‡ÄÔt‡³ðµ#V×R8´|{yK-¨tõ ´³„Š14YzÜ" ¹Ä|=c_ŧ$ÈÞ2Ó–Þ6l¬RWq#ðHgüiTœw©{ȹ•q÷—ž4PTþÑ¥SÞi?%Kdä X]3´ #š‚ åÙ=¼*_\­—içéwTVã: ˜\gõ#_úpl¡¼ô9ó¯"kS(>uSóû|ߺ´©qÆt.Z­MpôÜ(оm@ƒÖ§aSŸÇ nhÍOóùY½ͷ¹8 "c�Û0·‘’jø¸è}Å9¡žþ†Ê[fËù-…É"ˆ×:½>{UŸ×iêø»ÁS-ž++C¹»Ö²§D‚ÚÓ×6KÙee•ŸY¬a$5{Lû4H§“×_†ÿ•ƒËA÷æC;©ÜSÓqm:IËN;IŠÄ·€”8IŒ' †Ærz€þ#þ[•SæHâÇEm`Íðèð¥Si²•à‹%¡ÇŽbö í¶4’ٚȡ¾}!ºi)!å¾ÅÝɵJó‹»�ÈpíûÆu^M{eóH¿£Š3O#z_˜C§vþÉ’ˆ*$ØÉD¸¿XšÌ éÈ×a»!Ñ{·"ÒØŠ¿)‹uL?yÏ\±±Èû4CîtTú,˪iÈ×Cg…{ÚßÁ×{ï›úVOwÜ|‹…iœ s MÃ:åóÈjÓ=²¿Z\û>†B.qø¤tÒ+–)g½ÙzðæÑËÓùµÕXz’]%·Ø%ö¶ UˆÔàÞ6_4Kt¦rÚ]mè^DÓ E†È“áîK·‘R­š=¬Ì+Zz ÌÞö5…‡m=<ø-gÚ™ÈÅ€”ÞÞxѸ?uò„—ñÉ—² `~êx¦‰…!‰•WŠ”ÿ|°Šø‰E‚F,¶:›�óä=ly²ñï›ñRKi»p秭*æ!Š¹:¶È²!gÝ/ÓM UR Qá4�Ê?]kŠ½æ>G +ºØePÕ“¶9ïFÛbr‘+Lü $Uß^×R¡/ÉBû{O·®þ2¨³3;ÙêtL7PÀ|°ÞŸ¨@9l¾ô„ج#¢»¼ÏšWa,V¶äTp ›¶y7*y,"¡“ôÑTžO:FÊEf­slðËP¶Þ³–CgîMö Mæ1å*hBQÖ’„¼îà£ë;V>¥£{¢ZТ…ÃÚÁ7hè&ý”F¥¶D“ìc®‚¨Óê/+¸õÚ›¾ƒ êN­æ–Ô¶GQ-Vuó82,Ó‘žÓØ{€§†äV_çÉѯò‹žÂÀ%ÃÁ%gÜ^÷õv¨±1ì&ØÔ”šŒõ¤§"� ìQs§ˆŒ…ˆx€'?6;©Áøq‡Æ9‚k@Ø‹;ól;(. ™yOÙ‘—óÉ‹ðüÇÙr¦š¬ 4ü¾‘Wì+þa›ÇYPZqiÆõ5�ëŒýyÑ%3ÊrgºX!ñêOy5[spàám`ýÖ™ù Ä*ª5¼+¹‹jèº4Š*œÊtSª€++,‹?šj06õ‡V{!;éÖDoáEÉÖl«=|>»­§Cgó䔫Ÿ¨ò•å•aEw¢ÑÏÞ¼‚nïý¨Ž ªã›;”Ð'ÿ‘'QÅ‚²\¥æp{Q¨(Ë�¯e`WßV<ƒXTÙbR…DTÆÙU×â9q›) DWH »õÃî@•-pŽipþ••ôDmZdäS¼ÆíóŸ®V©÷§0žHàatìÚ¬R@Í[åR9¶Ñë†uJ\NO˜‹õhü>Y žœ·mG)8’„<x?íÙÂYkøo=F£ÌZ¸•FNmjcœ©½7^Ÿz$HV²ý€ŽNX¤~½¯KƒÜÎÝ(w„“húž?kÖ–Uæ•;ôú ¹þdáE¹Ò~U"’íüÜè6NB¿[@÷{5!ÿÔ pUªA¯eÑœ¸]+^ö|MG*1:qSÒ9N;X …w:ÒzðÊ„z]ï§ÑK´Ù1í²^¬] *5ŸX,FEY6Ÿž²ŠÜ™{2žÐæx5,ž•t|6”*Äå…ð»¿Ð q65+Ïþèüx•ù'@Šd¡µÇT«˜5¦Í4Gœþ<âŒaQùÿ‚·º©çÓÒl“vfÀù�Ë4ÕÇn™Ø>¾«©’áƹ¦ü¹ÕT§§h“‡Ùµâ³÷/}åëÜ˜Ç ½S¾ÕÁÛ…Žw‚sz“‘#Ÿ+îµOxÎpe·�²¡€V®u“§Ñ‰»ŸhŸ1UÎטÀåhìw^Ë`Cÿ»C*TŠ9CwÙɵðLqB± Øy>ïú™ÓØ ÚÈ|®\³Â¹5²¥çt–túÞ¥Xe=•"–±ýAÖm‹ŠPè¿qÐÐÒjÿI›“ S”•NFúþž}¶}y°cuëÏ)3gäϽ·Jª.ÓBÚÞýö',,cˆ,°l~®iA°tf¤JZvØ*¡HÐS=|€Øýýr@©ÈP\& ê¼½€s Üä“_èÖqŠüÒ½Jìש;Œ/ Št³)÷Ž` 7y)Ud5@~¼Î¶ÆÒW÷ æãhÉ6* ]Dç‹•¿¢ŠŸ·²¨,^Ö×ïé/{u}°WäŒÊÐÓÕäž²œõÍÉqî¯ú—Áúišf¾äeC]Ì–w‰Ê€­é¡ÆvÇ[çêU:|õ sD'“.d…élû,Ê/eg5Ð+™»¨âlÚ!…*õÃUyÛ.§@O5˜£gnÓ45ý±V'40»c¤lZLïŠ*;�kÞ È‰þèéÕ¦Qâ‘ò­bÌÓÿÐGh‹jÉüæµÅ ƒ…Ñß›óÔŸtSpÛž(ü–<ÝÑÇ«�Í#ªVN´Â)Øß{ùêÅ>°J3ËÜð»(?£¬ìÝJÜf,cR@qŸ}–™Yþ«ÎS´¥qÔî¿QÜâóÅÀä3:Wh§óíV ÃñÀ‹îÞÕm .#§—Æm3LijitPÙ™ž<v®ᯠÆ=ÔnPnp{G>n¬äž5 ×ßJ¯¨°¤[îüf{˜hí‡ÊlFlðÊúÕøå™Nó‰C¡ÍÌ¿×|¬<›½‚-}>Ò˜áÄ©*W®ê½¤ž|¾|ð-#WÑ{¿z5™—®¡ ç´‡DçÈ3ö÷¦¤ÂfÑ—[vpì0C,á±îi…ŸÚ°ÞÕ\Z0�KLm{ p æKÒò¶Ž}QœÛí$J‡/tÑ7ã~3«ƒ´¹¥SŒF´Ø]}㎚/¼0€DBr¶¢P9wƽLžÍ=¡¯,¤ÊìÕm1î¨Ä•â©jä£vN Á© üŸ#Ç@¦m|×,¯œ7Í`ÎGç8y:Á;tM'ë{¾´L\\a’îÔB;BŠ*žcî[ ³´5À43Úmãi.ûvíÕfI’ù¾‘ÌãËÏAõ3.%'úbíq<DÏúL©çÛÌÒÙô‘3J$mG/gç½µƒ Ð'kv²ÍÅk]Ïr _FùCŸ¦ÁŸQ :úÇh%ò!&`ò+äï£)F{BgÜ ]rª‰ÔO!„ xy¬Ì|ÃðQþÊ7²Ç±OM`߸žŒÅMÄ,~úû@â¿·Ñ?íÁnº,]³Ö´^ÛK ÌÇúÔOÊ”½öjý ÷Öh!3 a‡± ²umíheœÚÏ åM'ÎÍü\Aœ#Ç íúv(ƒðËŽY)ra¡öÙX“ÑñnÓ– îêËÈtßð]|ÓÊ”§ûè“àf™X”åW3ƒoWU ár:Í´;úÖÝè³”±ú¡šóájo!ˆžèX[cášý»ö5ú ¤'M¼¡y†j~>Çð({÷пt^òѧÃí–K;ñÈB~3e+Õ˜’ŸŽ.ß�<e{nǪ³³oÑ*@ç…… ßfð-A&ÅšþV u´ F¸vGJ=N6P®ìÀçßß&8Š—éÝã! ¢¾³*P”6Oí±›¬¢´¡· ·ô¶ß«¯*¯ýÉH4NÆÓ]ÒýóÆ·Ò8íSJÞ· .T`Z8‚tP‹€¶Ñ7/§€ž±7TtHF³&7ÚÃlÆ0M}Øí`ã4¼²?ø˜c<}=ˆár�aBs”M+ͽP¡!rKîù g…Š’4í9ánX•q•ôv™q6\Úþ ôKÔ$ïýêUÛ…8-}»@Ú…kHýWGBÍ•™HÚü_Ñ0/츒ÌBðžÀ—ÄAÚMžÝ*ú/O?🊠g¨‚Д±.HÚOn;â"‡‘Ìå( â -X{ÿ‘q«Y:ÃÇzÍ2ÿf\´2éÈ7æ'jÉQûÂ-”÷3vÒIe°fý…­ýðb¬¨dbm›¯â'“ÐÃ:1bè?6 dÏÅ:pàž?ÿ%ó§8T€²vlN†‰K‰w‡ã™¥?ò aÎTùæl(˜ÝQýo¼ë¥™Ìý°¨¥ÓÎù 8žù0÷n%N²zìFäð´¡ÉÐWàÅ_ŠÜû½C?Wº×êô¥UÖŸ±Çæê�Œ²t-’3u�¾BµMœ¾t,ʪ­¬#$aÞ›&{Tu9031Á×.Ÿ0(×°œó{~hWP‚/-h•5ýîg¯‘F¦Ó=AK5NÎk‚2?ÎDþ}ËÕÖ.“°!Ž|b6ñqÉGŒ-•LŽRSO3èNŒóY ¼Ò…ø z*s2½¨¦éˬQ?G[’ñÁé­*äY9öuîÐäG=ÞF†(_j{‚#HÏÄJ‘Æ`C¯g‡Å³Fõ/zØgŽF#±mE9Wòî;ü'€+ëÁ©Žß¿4´?‹aôäôAiíg£§0£ÖN¨ÛÀðÐÚß/@y«NtïžÈ}) 6O<08ò.<IÌ5¼ôYt.ì4ƒO.ž2^ýyM¸Ì°4·=8!Š·‡©Î|Úlð`*?xÁáþåuMÏ! Лó�cJ;^*ô4NG�»ùÿÞOTòØÍu Ù÷E[ծǤ®Þ½ íù²¦5X÷çqàqÝ¶Ý »Èy¾Úµt#@x£ðÓÖ™Z³r½a1{FîÓj¬eÙ΃þðX‹#³hó€jz ÕçÚ£ZsÌhH+˜üzä..ÃQTd¾ƒRŽ™\Æ2‰°F´M"ì=Ýͧ œQºè“ÔWAiÁ¢Hî l³s²Ï´x×ÆYŽî(ŽAórߤké­Í\¬˜Až¬4U1GzŒ¶4»gPpGw¹ˆ3oJKÅÓj¦hžùoÆÚ ì .ŠEN1ÖD7ÉŒÓ!u³áݽKÓO¨G7ó[ÜizR€àŽ–AÕ):¤:à¢LŽ+)y÷ê§qæÈú˜sÑN/g+„<½UÔ.CoXT&êÐ7g˜ò|â ð <ªÔç�I ÝfpÃæ2w‡½ícÿñ¿PþHÃkBÉÔR¶:h>|…½å }?b/Ògt­{ð-‹%„:Ô¬vø‰G÷VsÊ›ŸÑòÇui}?&~wëØb²Ä+”!¿­´Ù}5— ;aš¢îc7~ôm{oD‘‡¾½&}êܬæËéfûæe’t6´¸z«µ9»b±š;cˆ,wJw<˜¢l†¾@ó~Å’QÍòÞ?ÕÆ•7ƒŽMIK1ïS‰´MÛ®:F­xG¡ì_JÎÕ>«÷Bá×ÁŠ–Õ/V»†¨!î'û §­×J܆%æ-4fIoèÆqÚì®´…˜Ä ×Ý$ `·‘¿*§/Ú–¬µùï[e¾M•¢Ù Ð Zܽ§RJÑ?YìŽ +œçAxþ㙎¡œϲ¿œEE±ð§Ç?…AÕxuè¾^­A ¶FRx®˜4¿ùÅ ¼¯LÈM³~JiÇÏ“ÇÔ†¦üõyÆyiê) ã¾ÁV>¢“ª<ÐRjû7~¬x…º‚gò\µý”«NHuA¥È‡­pÈ,{Ê«2qòüWL{ö!<,²™µ¤IVýZÅ‹1 ZíFû§÷´Î˜õÌr›£Ågƒ±ð[ἦSŽí¥q~žŽG윚aïð,…†ŒËëàxhò ÍK’3cÉ|fÁ‹Ñ/C~ਠh¾$A¶ÑŽ0ÚŸ§Ý` ò´›!†Ž‘Ø ]˜DqÑÆ꙲Q„4g‹Õœ¾l3a…MÊO/à¨*âV`{…¥U'‚·øIMlr\RzZýB3îꤺ÷ÓCV_¶h¿Ñ¶9¯³ tzâôá à¤Y–XŽZÜ4à-põãÓ:2±,ÐÄL—?fXóº|Ƕ2ÃÎãtØË¿ü-Z‘$±ÝÄ2[ؽÓ×I=A>¾qc= wI"yèç-¸í8 O%> ðîê¾ý‚¤Èh½:™ú"ñÓ^Þ3µ­Uàà"T,gÈÄVáó_Àøéq™FÀc¿a¦m^ߌ¾ÐfC–-‡iÐCØ÷u.Êa¹±›¬aí,ÈoŸ^TZ´öÝF¬±`Œ4wÒô5okÀ ÅÓÕ‡RúŒúÊ© +³åÆJgOï-,„–£ø ±-\мN +!0©ÊKZjs¯f)–@p¨;¥±óU‘Mü£ï¤î[é ˜¸„½Æûª‚ÇpÞïŠ-õt€ÃYg>¼B™Qæ})*lλÁÚõ½&UD.ÿËs1í«·ÉÉ]ÛŽ1§9XrË‹³z[ «ë=‹Ç›ÆU÷g¾¹ž¯Î•2ñÒ*viUhKQ‚5nI' Õ:C€\yTÛÒºžØºåA4OB…³^½qrú2C1e´ºö»©Þêù Ìÿa¹‘¨°wD¡* Ê^‡jü5Ò` c Í-¨;»µÔ¯îJ{\Uè)²2mÅæâ™úœEÜz5JŸî±ò]cdǦN ´‡îy¹þtR®ýe`2†“Çö‹±W¯ºË]S‹î·-ÓaãÐ@;Tº3Ó{–±›_±RÓÐ)÷ÙXêŸ2µÐ dok=ßV+…wz—}+ÖS]PÓe¼…TbÚzB£/Çs¨?8>üÏÝ7 w´Š´^û•”½F“ƒÑ²z?5;ä°fð;,Ž•/ffqxe rÞAö®Cp Ø1ªgÉ` d^™°ón7c½Â4ÿà •®’µèŸÔ’e±„‘/ݾ¡vN{ŸaÊ©%î ˆ* ”†{æ5¾É•T¨{º£&Ti!·äYÊk-Jëœm:kò¬À’LÖ'gó">Eg)Ó11¼»5]ó'xÅ™¾otq&¦kí|ÐPf¾].$2º”Ó}ÄÇw¡ÃY–Ï9'¸¿B]íÅ7@Ø<u÷ ÐT d!­ÕnÂw ª|î.`G‰˜åŽËY®~ò¥÷ò¨M±­à%Þ�ZÌîß\KG@ôƒ™‰E^NQ™Œ5ãŽßU˜ §Sü`Î^¨GóÒŽ;Ê2xÅc3¶q'4T€Õ¾ âõO†Ú¸:Þ¶IÄ*¨0ù¬](ÙB9Ö=½OgûÍ ÃDÐ)P+ú"KQœ,˜“)}Wª~G}à¥tDrkÅk¥ŽÈ‚L÷�ç-æmRepµ>¤LÛ3ë°HƒÍn4m½©]áðô�a³Ü¢ÙœVÁ R?I‘ûm/ =S `yhñ*“Ÿ”ªpÃõ«F§$÷*˜êl1éÜXÝvâàP,#Ô¶Ÿd˜cËsøp軳€Peæù¢#Ò&QzOùV׃3êùʲgY‘y-Th4žó hûŒ¤2}¹É²tâ^×=W”ÌòäЭhY*9¤s8¿c„ºæ´ßYy*‡š¹ö–G´ÑŠI‡È˧]Ãb´ê³€W³~ÞMMK1gÅÿûÿ¨b½ ƒ¹ô_¹CžM¼ ‚Õ½‡± òwõ~ÇÚ¨šÃi®¥q†·áÈÏša:ÒSÿדÀ?bt=ZVǶ¦ŒKñG¹¢Ç šTÙÖ/Åé¼2˜ÊxTÐá´*~ˆGü!e¬êNÙìÞuÞvÆÄöê'uO1=®’³A¹ÃÚ2ñ& - %ÔÚS€Ê´ËëVnYèªèa¯öôv, -‚s½ÅLàD›X‹ÂÓÛ°)êÇæ±GŠ«ùp6š~¨`OB»DŸc‘ƒÅU=üŽ€Ü÷÷…ñÈãŸ=ÖµñhÕ}½?°gçsRh±Ð ¥Ïx`¦²Õðƒ(p=ÀÚcàøЭ0I³»–ãñ1À;ª<+êBøl¨ O­×G 07è+Bã ‡-hEæ~Á¬Üwζd¶%×ÊLý ÛàÝá1 ËNa¹:qÐ'GÖàšÓŸ?5Ì4~ D–Tž|Û†Ð)†€ŠöÇ౯NM³° wÖáÓ±¾þñîñá­\ñ/{‡nÚ½2|ßö{Ψ<Z¾kjIï.n¥~pŒ(’“.=j~K;ìK3™(h÷o?ÕþzræùÖí,  y‰¶ òÉþn¨zÖ£Q‘‘7>q<Û ‘¾r໑IâĽªõœÑóÿãÁ²€’Ú^T&äó„a†k²ãLd~kIåV'CÒ0§‚¾B£w#nsDrCõØg”[MY¿"g¾L³ãx•ËÅð,üÜz~*â|ô?3P¯ü=‰/8G§ îÕ<€ ݶLì0¢<?ó3sø›˜‡ÈÓeÇ›·.#“÷ÿ3·Šc ›`@dß炽²$Vz÷íÙ¦±U.Œ µ¯`A{©0ÂB@ɤŸ£W÷TŠù �lïÊ�Æ—2ʱá3/¬PÑÙ þ!ÆP+ª¨a”³¶o˜ÙÂ8“jw¤­ëꀙòÇ_º¹FñÒ¯.7Øk‹™ÀØÔW½‚ŠüÜÿ:Š3_ܦ¤ü8N‚l°Fè¿Ñ[ú…IŽ[¦nÊ‹dÿ˜ÅÙ›#GE™f®'K”©W“5³Ìa«G¡šŽ¡ƒù;ËJþQAŸ©®2�.1ZñùP;Õ¥~émV@ôs0ÃÞê–”ãö¢ª%Bü;ëËcŸÁ±Q´Y_Ê µwd”m;Ö½é?éL_B½êïV[9\Ã̧\s¢D+²#}†ëÌç‹ ½ù¦¹hG=þÑϨ¿«º¢¢ðJ6Ýô¤ã”yç·¿édn.£žÂ-‡kº×w¯šÍU´�áB„ £÷Q‡á@ÈKîeùYk˜µ±DÌ|8‹N’‚‰ ›f³ú!‹Q!Ðsøï׶‚Ôu»5­6:åY Z°tîþx{@ú&•!‰ÐQÜNjqëG&3ð¾B&=³,S «~ Љº?.â#ýªïŒkKXöâ ÿn¨í²ú…SNjí€(^`ú0Çßé'e±¶G@¦j*êZÏ»œ >¹ñÿ¹- n „Øs]Æö-\~º“1ÒeM)Ê^ÐDi @ÚÓÃ,ìq›'ž˜= ¨^ÓürÛ1Âp1‚¬gTcíy;±GÑ�=TIMÉwD&"úáüzWÝ3vVœQddÄé3Ûþl­U„c‡(Ƶë| ^ð·w¹mbDioUAÜœ<ˆ%Ði0é½}kÞ–$ynë2ÞPÃ9òí`Jy(%58êèr’‡ Òs:R'ç©tiï¹v£…igì‰y ŦÕR úØ·Ü”QÉ+ N¼ôœíÌÎóÆÌ©eH ܱ±½Ý+¥Ìʼ®eÒ8"L¾V˜3šk®^³¿®Tˆ)3¾T,“›UUHÁ¨ŽŽ€Ùœ/ÁwIÙ¼¯‹ x×*®“Y?uËó8ÀO�°?âû ÆûO>3R,švãú<ñ…èiÍŸ!Ç?éL½ÂTøˆøâúŠ:—¿wå”âl> Ë`ÜR¬¬¾j¥˜¾ýÿÞdÀñ‹×Jsšà6™Îå=×f´‘ÍF…ñ’짜‘å¹ï:LoŒ(û÷-†ï 8Œo¶†¢¯6Tž=ˆÈ㉅†zÐ�ªüeísa„lò‚ð Ú'¥ÇF2#X`Zßµ‰R†¦µ„ÃéÑÀÕI;Åif”3KC,ï{z”@Øk4Üèñ2¼ 5Šðñ¡?_˜'L/|î-½F̠ݵ![OéúñË×~™Øbò®:ƣౠâ&xß3D+ÒF½øød¥–KíšÖ„8‹ÒƒEÓļš䦅Py`º ]µqŸɬ$b'Ú ­ó.6ª}…Àø@ã»4MÇ’ÓɈ»kÙ\;¶ †ÄЮUÛ`Ó<ûQŸÍSƒôšÀrʦµ è˜Ò 4„|  u8¸ü$QJýV¨5ØýïŸn÷CtãMäØžÕ˜Q¼b…“ŦcM¬p¼x«\"ÓêpœÚWjî»xÿÊ“õ`ÙÍfH‚¸ï°™œtŨ«8Î¥5νª'ÊS·¬N¹ÿ�üℵJ¹µqÔƒ2*„‹×ÙƒôT]åÆÂå»#:xí켂Öõ¸ºXõnI¢ÞÚõþ$ÊÙzÉų'¸œ…¾/&%}T‰I©ûîL1ð à+=ZFIêÕÜJÉÇõg5zxu´o{:#““fÍÇÃÈ’ iékXB^(ä«?Çah³G1ápºG ¬y{ž»ºYPY<[pÆ°æŠL>… yÓ¯zÞÙµª>Â>ÿš¤µÒ´ÿÛéƒ þ“¾¶Ý6—~}-¹¬à)qΤã~}Iƒâ4ú.¨äZ^Á¼“웾g¡7”ÚÄ+ª¹vX_’ éñå9í˜{Ò®·è_{/7o.\ƒ "вl¦‚¿KŒnûëä„(/3ž°SG÷!²ídÌ,(¼€c¦²ŠfÈì.Ìjs§Ù±¦ÑÄfóƒëÎ@�9‰ì¥U…ré òÃ/‘ÓU΂#î{pnÅY<<)ï_N”!Ú­º¤ahý°Ò œõC' ×Ÿ:+%ñÛÕP,«ÖmuJÇlÙJŒZG4pÆfÌ=g÷Ÿç¿{`€æWÌRXíŽi;Ê8s¾@h±…ìµpü­€¼ë°§ÆÈdšSÏ´-bϧZ\‡TÕàgJŽÊ­x6–×:é :Ú-àPRÊÊe?%7YçV@ð³…àõÑãV¶”¬;L«á½[PAu¨ù÷¿ÄÞõÔW¼"=½« çž–0NMÍný *ÀôÊ k©‡á6¹=›ˆ!�C„[ÍÿAÉ®­TUäý‚÷7ðÁ€0×Àw è$w3ßÄ^Q%¡<±Ýï‹YÍH)Ž‹o”{½ÚDYäDŒR¡e•AÖhÔÛ çvX vÓœîËNÆÖ/ÇB®ol‚ŒJ®{ÝÙÊÆ}üzì=UP*~þS]Ñ(ŽΔóٺг’á+'QÕsyÚ›tü÷„KÅÒ g­B‚¡x0FE”…#è`±ӌ¿wå«Ç³õ‚U‘åt“2óþâ²ÙÅ ûÑŒÇ! °M“`ú�h~²çû?íÂ6‰UfÚÑ߸ Ë.ãŹ—Pi†¬¥ï|ùW^Šµ¸:.~«ŽÑ—÷9«Yä²ÁM×e]Ö^z$Ýhs P˜Áùô@„7wjªîW¿‹ Xšêäc@þlahÇ:V&>Dv½§ ÖÇ6JöìVi*q3iV¸ (‡1ˆaVƒb°V-¥Éoã”PåžA?ÜàI¤ óš,f®­#IÏJxž”AÙÏžW$ÒVoºg|mÏšžÿŸÍÏÍVKfwšYqæÜ ú:’w=˜ è(Þ ÅÎ^ßvPÚ&acPé½5èG4Ç*ÎóÄ6"aN)ÎäZË I;îÚßõ©ÿ_mϚܿ¦G‚㯹÷J3ë€6PfAÚn´„Q…Që2ƒ2›…ý˜-Ñ"×Ðɹȡ详ÍÚ@_(9ßô­†ÉþÔ4ô0¤Eöm‡5Î|ô8Í8dgØ´Þ¸mÅô¯¼o‡ƒ”ÿš¥á£?l[Cƒ)fQé VæÒ´ü]Ù!åêZ^Nˆ“o榕[ØQ ÎѵM”Î7£Üd¬'ÝÖžŒÏØnwCíøþ“Žtâu5™JL[tÞ=‹öA–m‹UNôNWï ˆ/=�¬ _Ð,m3sÅßtÐ<êT¥þT’¡Nc‡IX}6¨óJðïνAt8`žï½çì5�3£ƒÇ ë£W›)ºRâ~Nfu}äBÇù]JA»Ñ³·üt<.|¥ª™=r¯Com ¼í¯“•7Ni™8Þµ3œ¥äwÕ¼X¨š-ΘDŒA5Hɬ@ë”uÄάôo:¶«¾]}tìTö„)YyJh÷ûçŒÝBm÷RËIo,¨ôÞÕ/öHøÕ_ö·ÝÆ4r‚§f:íGeúH‡ª5ñh¿Z†H,^¬X2^#í2Û"H­ZL*2ïgÞz¬U-à5Ëãf Ãi v–?¢µ»„‰áOÐmN '"&Î3±ÐÜ!}ûG¯VÜC‰QÆSStO… û‡³TKȽ÷“MÃõò–ùgEY…ŒwpÍÏØ S·ÙÔ%Ú{©ï¼êK3¾™Š0ÈNµ7õc€€TÓáúú? 8÷œ?Øè ia[ûÔ?¬m ~ý›Ÿi¤¦Y\@äªB¸=šL,2y5•u ¶¼ —ª'&îi…‘õ¬¢Ç7õôžïGµ)Œ±KóE²§^dùï½x>;¼ºã”oIYëpŽ7Ü|ôÙö= Y;gšsVR‰ìTnÏÜ [iü¤=pÛ-ˆ|bG.pä’½´VŒñ eÝèöB¸ñùãÑ;ðbÊ·ëh-  ‰§ÇÆê¿› âÝÙ*Ñ «—{©§ÇR4<)þÆ dBƨCï]¡•»Ù {¤wud“:0*‡Å‡~Ûw§Ãdlä]¤O”Ǿ1'Ý£3•!É{ã¹G6TIT\ã¼ÃðG_ºš÷‡yñ/s£6=Ñ:-ŸdØN® §?Z´‡ÍÉÝ[ô+÷È*ç€|8ÚWÆÌ=ú÷ \‘O¦¦·®{ú×íl ÔD>„gïðÆ|—×4“ ^CŽ˜Ûðð•Ð±ûi§×È‚zš’þé!Fûú":ÝÛsq{†Jdnms"´‘>94+ûófHL”MTǧò‰¥U#”ê¬Àv"r ˆáÅÍ·oÜd4]:ü¥n™ qµÐ% ©0ÜR~•¼O®1¸> MhŽ‰ÇçYìs8ù<k¿(Š—v1×NôL xZ›dgßÚR°­†`çÆä‡*Ê‚a,‘Õf)9tè†òì~ª‘rNÞMJIß¡¨OªV;ë6•Üo« È_')§¶§ÊGþ½c`æ‘¢–I 9ï:sÔtôAXÄAÂ6œu¿ò¤—þg å+`œ'ªý­T\09ƒëo£ xÕÛ{Ðãs,`±ÕÌ‚í·£N- ?p•Ð5Hš8•Eéþ¦5n}hàZzS^–4F¬„÷Ù³š_ºA4S_:ãÙûS™ª{=§A9Îæ+¬ý‘Bƒß©, úBÅ@õ&RúwXô(ôÑKÄÀfŠ#OYªÌÅjYÙž8v»­ߪw+àÑôs!Ê“Sµô¥rXl zÚMÚ»1Ü™žØ¢'iåA¤‡.ÝäãÆù7 ôÀ¢]@»äw°*¬–xÞt9‚ò2¸t<_êÐùX#Ûºëüz½ôÔ nu9äðÑ¢K>ë²;$G>¯™Ê'z#Ö¿/ž€Ã•²L{ Ñ ¢MeAÔDLŒ¡ÑÁæå£uAOÄ‚<þ>Wb=³ùº1Ø€{ûzÍ=³�rQ¡•U¦¯Î^î½+Ç'ûÇÝ ³Üwÿ'ºñ•7dré”ÓGGâo5”v»/^æø»¹°Ç­o¯£¯°=E´žëµJ Â¥î0ìÔèv3îö8dWœÃ8¹iú­ÇBî”Ø°£ä*?ê>Ñÿgžq GªÕJ_oÏõØ>ÈÝ�rŽ}{SV~¦„º÷ {>vCßê Ñ%ñðPôO©i±!äÓ¶¤"¦Ö·.SQ1îG“ãÀ3tÅ3ïòz“Rþå~褘yÕôZ‡Š·5»N˜\¤$¤h´—LQP”�7¿`¯Ó*ó"B¬6%=ѹ5ÏÁäm}¾´ã™žg;щ¾|éi½¦Æ\vª1¨Í6BÚÔ]Öo—· ´-Þª¹9»zõqñ¹¹é”…ÐÆœÏÞ˜ Yß±]}Ð:Øz–,Œ âÙìûÖèú)Xá� …ˆÒB\_<f÷¶§Ãm%í4ÝÅäæ…­D·{:¤Tá¼y²…ˆì¦`ò.ôé¨äÈ€¸ôÒ» !|ÏíbKó¯xô5Ÿ1OⶦŒd ëÐIþð ©¿5KÐóÃ?íóDÁµö„Ï•ã/vüÌ/V5 c¿†zKtÝ…< ªI%ùqJÒ–c|ž“¢jŒ>ïô:à,‚JSHï _˜µŠ$iÆËa¸Xº8×蝹¹n)ÚÚü”N©ðK/_M‚>13Ò èg3#Àá΃®7¯»ý# éH‚öYj@Xɶ©àË“çÆþ*¹Ì|bjЭ?µÓˆjÆa/iâ%oÜÐ9cëtΰ|6ÖC’Qd!§¤£µcû霾̬БŒ‚ÖÕIÝzΕûvXïŽZ!oé<šš‹}õ¼^îxÜþÞêšIÞ[1Âó§Ä¢QÀ×|Óu#Qû;z°cöá\m0éêT(=«ß÷:g‚¿Â…;| àßöõþ0Bøùþoé¼JL¤ÏTÝ€EÂÞ/ø 9ùp6ó%wekØeëêN/+s:p¢Ö@ßÊ'Å T¹v*bë‰öóeúÑ×ÃÑàùcp†ÂÖÚÑðé¡Ü C<xæîc½Ÿ‡š"ÕymßDeå옲7Ò~ 'Ÿˆ1SÝ¢ÂÀ­»çÒÃåe½¦”wx€)sRʢൢ =ÛŠÐ4«îcõðÖæ¹]'°™±=·ò¯ՃȬy6|;d|ÉüIï×ùönjï!{r>ŒlRé½6î…{‡.»Í±é‡cŒ°æøpw¥ÿ%Ìiy8v¢’òë˜'�¹B“Ï·ü ¬ð"Ë3‹‹ ¢ç¼¦³Ö&áq7|L¢6“ÛÖ‹° »v@º9â4ÏܘšDzöZʬ1¼`{Ê(OVFàÈ…¥ ¤u:2?züËsýÛÏpùÓ/ŠY±d(‚tÒ††Hdq"¬©ò“”“þàÎö…¯ýÊÅ‘")¤¿pômØL)19óïÀWRÄØs™‡qŽŒ»ÒAYoIÃÖËI„ºQ×kc¯2õyÔ´Ž}”Ó»j/e(p§Õ¼ùb-„DÏÓhç¢Õ¹:ÀvcSkv*{mU}}æ‡Aï3à$íF-ÊVÜzD d’2(Û£7aªýiä@Š–éõûÞï ¾c‡¸“Á÷°¥ó'»El“GgÕ¿ê‘£Êø½¾^ ¸ mŒÚñ¬AŽM­ JJ04Ùâò;b¾àž ”}뵧M^c‘\LÂJiÆQ¤É_eµÒbZôÿaŒ±¦ÍR¾ëh3Ãt–Ïaƒp€™Ä (öÐTÜHìÛ‚3U«³×´­ DO«±¦£þ—¤"×ÙµËVk6Ž®“Á#/Å°èCæÉÕ?ˆ?ÅV�Ñ}ѧœ·^Ñk<äiWRv;[r`¿ÛÔ_öuÅtsî¾Ü5w’ âBû13Ò@õÒTe@?OøäÚáÐ麻¢£¶¹ÒßÍ<C-–ÁZÕtZõÊÆÈÒþV¬ ᨇ�Á½ Ë«b‡ƒO8ƒ;¡`¥ G�ªñ`¶?a½FWÁØÙÐÆy·2 mF*‚Fœòà¶ði%¶3Ò‰½Þ88¸Óç¡´HaËëm’Ázñ>gôc¦D¦Ÿ]ÃdrÆSA®RÞ耒RÚÿéÎóKr/òæ`ǯöt¿K'Öt+ø7s²N(œ®r¯|á)‚m ÒtýgaU\™Ìé7h8›*Àwµ^L‘ºöN[Ê4¬apÎrü3B+ðTOš. S!œ_Ó[çúëjÐÜZ}Òñµ#KŠ&è=kf…Š¦¦¤]5pMí•ùé †î›1ív¬‘ešg|Ô)¯5¬4û̄ͤ?±žåÞ Lþ:%dMf»Ù$ÑÔ}ÀÈpm–õõ/ 3ªÐ!b#Þú”f',º4E×FÍ?ž²ÆÓØBæs6•Ê~ëa‰j4kçÝJ}ÁïÁ/ž 1\äÖiÈô'V×T`Q;U™UWÛþ éRû¶aÀ*C#mýá]-•™òÐÇ;Ó’ÝcHïìë@‹Ù·kKEð² û—÷眑" ª>7#º:+ƒ öá4ëyù6# ïó’únÊ™äÞÎàv=cÓ²¦ó¸ &ªêÆ{ HK|º.âbd»�¶gº×:­‹-¬ËÇtõÓxîŽ93op‘¢&85+;+sýE§§‹âÒµcÁ<sñˆÑíìãscÕZÚ¬—�Fà›ðš¹¥caÚ$¾í=´<ºÎª;)2ëpø’__d¼Ìt„Êö(i[åÈ„!;Ìqô­ãn?Rr(iÜ‹>‰sËj¬,Áè0Çèk¢ùëâ)ž,í9Ÿ¹t&Q¶˜²sC"b<¹Cžü>&·öA*¡bÓ÷ÃøæDâ5%DY~J2VÀ”úÿ;„éz¼�©ªbÖÆíÛÔ.9x‚ÜŠŠ8ó¦M1÷Æ©P›´kÛ XÝLܸ\°ãܵƧõýýYe‹"¨„‹7D}i¥®¡ÇÌ˾òï¥ßÆÂ`/MƉö2 ”û{¯oK¦—|¦_yP Ö8›Íï¸Í`EÖZfŽËË[WÏƈõµ†~áÎjà¥G8Cñ€Æ´ä·nàBøÌò1üb`:SÈøé·9%-š‡£ç2Ÿ¶m_Û=ù½%’7¯©D7 ¢¹Vp7»-[ã顆X.^œp°uÛbmfÚxÇ•eï½ÇÛ3Ê°¶°TÍ×ûN» ÓÝ(®ü-�v&¹µ%ñ‰{v;[åŸ}=²G�þÝ´ƒè?Üd$ª3#2a4IAéÐàÁ:#£Ég´Éy¼ý![ʱªOá> ©l»OYæɵ«Un´ 8SÝ?ñéR¤Ñš amE}«YNÎÖÛÖãæüLIØjšFfD1C¬¨èâÉÇ6[.¹%CÕ½RÒÂ(</ÉwÚ'¡±üj(àï£×9=òr ßî[¾s“„>–…C¯) ¢yö¡jjÜë!Õô…50ïm¢<órYþÜIPX¦j„N®sp.‹?ÎÓ"ó…#P#Jªcõ#5=ÿ—u`ÄÔ>Õ”m).jš‡„Cýa<9"ÈáÆ©ÓïÂ$‘`ÖlMÛ4ÆcOŽÎæ≢®á2‰¡ÏŠž/Sû©b~Îüò“ì1QI¼G‡äTU«‰0žk$b¬ó‚u5ïTGl÷÷ïÐÞ*‰~OÒ/]«U|2),)ó±lÔˆ½[vÃ�u ƒ">¶Ãúìíý0^�4Yé$I‚¼S4TIÚmEp´‚q¸n4ša·fjèøÌ(Šáb‘­©n­�Ê[‡áâôDž©\ÕÆlº) eߘ6LœsAè0µ?Q‘PâšXõÒïŽÐ?©íè«4Ö"jíf¦Úás.2€ìDµ#¦bãiqZÔÃÞñ _0 �N€LŽ¨<>U>â¼ ÉîÅÏš‡ d=ÏßYP6¼Ïº>}´?ðO–^„!˜­I~Yuè$?îq4´¤|Ãj|K&†»MÅÕ°ÖQ\Y^âo2›}ÝïV†ñ€±¼UŸÁ…|”)/.UóÖCQÒÎƖ˦o›ÂƒßüêÛ_*¤¯~©Çhfc Q‚³»hª¥]Ïz‚w¬t_Iu5y1ýUŸÊu¯QÅ¥rÉ0,\bؘ‡‚âr¨ýèʳ…¾=ÍNÈjÚzÁ®I?§`ǾV¡öþb¼¢þO Ú·¿¸£ÛQx ¡ mÒÞ!TžÒŽi8œ×!åÎÞGÜ«È¿ÑI�Ä’ã»›[ì$摾ÍußæÅõÀ0Æç¿a “ÙðŒ"‚H=ŠZG…¡¶®Ûž–„ô¹[Ö´pd£Ã‡ØöŠÖÕR‚ òÐ$ªyã¹hMtFL幧ûÃÖ—R<,Ù–qP,?ÛëáË<liµ wÉäcU ÂEòKéý…vQ.=�€UJÚ uJ©yŠ³¶ºž¯è0Eq’y:c´×4'Os³?ÑÊ3_§³M‘¿`T¡¯ŠB[jŸ8¨¬‚‹¡)˜„'Jì�Âç£"}V±‡®¡'é˜`‘…¶Ÿª’bl¬šÓ<s:6ð3§ƒÃ¹ ÜE˜Y¢/2r èqˆžT‚0M '›þw=O÷¬3'/ªl“ý,)Ö‰¶tÝU5²Òx¼”¤ô „C¬±þ5T—•fV;ÑRŠ†‹EÐÉ<í÷†-ÙÖ•üMwå=å‡rôáBaˆêƾàÑm¨btœêi:¬v´4é©î`ȉô%4„ý@Ä,Yoç=QU³Rª7 ¦*fý¸"péÈ$Ñ4‰›³G%±äQÓà‚ØŽ¼-~¨ÇÓpÕ²Ô Yy*×·Yu÷ñé0à> Ùêv@yïʧ+q CQisɩȳfÜ,EB†¦; %g·A7¿8_ÆkA)ûÁ#Ó¶ðÅ8¿ë¦+Ø2íC¡nHfg§rôÈ1BO}Â$ÛŒ霄„O6Ž“îô½ËmËÛò¥Ê’&¹N KD Èa½{½ˆ¦mßÀßÝI7‚Ûo<GkQr¬§íóHõó­�ý‘*ˆ„¦ßià[|p}½•Â…@\ŠöL”µ† ÚYkÓ'" ™.éÑ7#‰þ¡g3¿`:Ö,Õª†O¢ÉsýP<v@Ä°  (j‹pÆf…mFü7ø„µ€Ê{F·¥eú´­4¨¡6KÇ"¬$‹)ýÒÒ¡þ½Vü³¦|æ1à"$ÝÝ3ì›Np~Îò„t<RÌ}£MöúçuMêigÜè…É„Q¢=%ê©Ã¢[a=�I•? Äøæ”7,5/KZF”ZV5.aš ±Å¶Ee‹50ªÏ­ûQ=Ž–ÀÜ!áÕ¦5ˆ_¨ 3¶¨ð}‹æ*úŒí�hÞ¶F_í!:¼²¦½™á¨M82ÖZ屄*‹¬L>ã„R´ášb^ž“§ÕJ„ïÚ ¥ÔÆtî€Êeª§Br) mßÏ2*�È*c4ôžNCð/ãÛeÚzJ ‡6�’„®tn»üÇhqM^léÎTǵYý•/m­ÏQõMÄ¿ødFª­Êš·ó»²Ñó ý tL|EZ🰸Qšg>(M¬J";È1“šwŒL?;‡’W­JâÔU�ûPÊ<A²»ñàVþ”vFç)ã¸=Ó·¾éw|ÔÓÈ÷onD­Ê`GÈ àŸeI*? &¼Ë ž<ăêX¥Hù1\¡LíòªÈ—U4“DL¡?èôÇ£'H-ª?ÌЦÀÕù0ª/¬Yb7Ó÷m½,ô¡™¨*súüÝÚ³úÚ×[_èeÓ³ù3³^C´’QaŽ…óoz²UmMPRžö¬­¬ˆù@c2‹••ˆÌ *Ö£S—"dî9 Y›GwS~rœHeD¸†6O‚²oI-Í îeÕ Ù’ñÀ•ò7rZø!`0~Óilß®àè­!FâʾënY¥ i¼³WÄŸ'ƒÂ1ôÆAáûîž%LIÎ `Ì™r¼­ÕÒåð ÐœT¢Á <Z˜áËŸ0AYÈVÁj΃ÌöU£PÛµñ¢À¤õFáiwµ¢¿ÈÆŲ¼*oê†å@iP®•ï‡æÍ›`è)´œ¾¼¦ÕµM÷w?+¯'rÖmX5”§ÒJùT®]Ùö¿¤{Ò]‡'nYºÀ—Ó‚¤Ç›i‡1ãô}0ŒŽ{ÃJ¥è½ïÖ<&LdÌCèÓZml€¿¤Sdfö8síU²û^öTJ9Yë ßœ±÷Ô7šéá·“Ý4Ì|?Û3SŠ~E·à‚ŒMï{–Á÷Kš)]ý›Äb¦$ÔL­zBU+e÷¥év_š~ïëªUŸëß;î—¶v<K*ϳî†ÂR6+~ˆ /-6õRÃF:WèR8ö@(`ÊÅÖ×ö[QžøÜŠ|ÛBi¯u¤ÇŽ»AÆ™ü‘OV<¬=ž¦n8ŒWö1¥ßw�O ÈOÅ d˜õεµ÷ºÂ@>ÄB¦Å‚oQPêBïfm°€»×ùë¼æÄNÕ¬ŸŸÐƒ]5qæÁAc;•ÓJ8Éáåyœù|ÌËÂ…P-­Âö ´¤N§°«ô¶tÝГ¾PUÁ¡¨; Ì70mÉ$É¿I7†}EŠ¯Ñ{ ´è¬¦·ñùN¶ÃYÔ'Êäfd«Íû¸´:ªžØkýÈÊ'[ýÞWAs ~„ÞGkùbÔKÅ)ÝîfOí÷cÁæ,]ÇKTžÙy±l.Í—ÎÁ“åÂ"œ×Ícoè(’Ï}‹3µž=í«»tÞ±\}¥û„: Y¹ùÍm÷.)}M0˜¶EÕbày¼ªÙFÄð� vÇ è ¯~ÚE_”3P˜ÁɃª½ì¶¯×¢Ñј‘‚õ@òÏðòžô¤°–÷‰ëýÝ0k#W¥X#câømOœ.ôk ÄD§SìNVñTHZÏÿ5¦ żsî ¤} yPuÍØßöˆãÙ¨ JË p.wuÓ È:¿øžµ0)-gEb‹¢¨p҆×MéhH_ôNˆˆÂÄkÅX{¤ç<½;Êm°³”Š=*ZÊ»œyb·�Çi¹XF9|ra´US^ÙËV®•’�O­µR+I]_K_ðÐ̯ͣ—QŽ³Ø4gføÃEâý!: êÚ**to”a!yêî…À•æÙ‚.^óg¤µÆoˆÉ¨ì °Ò™ |¦$%[. F’ß l·g»ófwâq¿¢îhÃ/:«‡ X“q|ZÓ°P^©À>ȆïZAa—˜A†³ÞŒÙÙ/&®¶ ŒfÕQ=˜ŒÊ¨Çèdsò„KuóŸ AA©"<&[þ(ŒIq:ðø’yäFætP}•L/çdӬ͸«G«âÒÑ.šh•=,­C•"í‡0ïQß·©W a®õØž'ÿqÐdm�ÊhXŒ«kÌó—•—>" –ë˜Å7Vy�æ({cœeµ½É/^­Žtáƒ?@©¢ô%ŸÖžD7)Yj@> m&|{{ñ„X•:9iÁ&0e=év+¤&ôÒrQ¬»›`*böó ÒÍäáT§ãV´z§–Á¨òb6*_Ūs�”Ì_ ÿêtáv¸L&ÃÄZˆ;3Å3m09¿³žLÊÌ_C˜ÃfgÝx0ò=›É°ºã?P~BÏÞªÅWÎ:3M>¿‚]Õ Ho­öß…[ß-…÷î|åÑ™!<A"¥œFÏÔO5mv:,.(Ì¥’{ P9¡ ‰œë,¨œÆ 5ƒÊLžŠéo'3õ£p Ý¥Tq-†0¿¥²¶<éy,üõ±‡¼…ʛ۱ šU¿ÛlÚ{“#½çâJJiŸ uŤ—¸G‡‹ë²<æ(dU4Æ`¢.P[M®*Oiš+¼óE÷â%è­•B0“x:mÏl|îßxZÌ *¨lÛu‰<±½Ô¬îuõ›“klÁ$ô v=÷ CXú—7ƒZþä1\+Ó9ôðÂÙ˜5žåZ&¼¡Ø÷Ú[/ð¶ØG„”¯Šg•Ñ(–]h›{0¼Ž î0èybH` kÃ.Jì*ôÅðAÎà¿6 Þ<Æ 5L ë#l”[N„^‘o°í¯Ä0øÖ—,ˆ?×4 t ¬5£2;î ûŒs’ÅOÚ¥¶š3¶o)i|y,€!,pèûauUù‚CÜ`dl˜ÎH3',hßñYg1Ñ%”ºé-Õd åW43:**®”L:ž§]îQÆjÅ&:C3˜­ãè¥K‹ã6QË(ëlvóD(Ê.¨¨a(óJ©¹¤V–åè¼î¥Cë¹¢¬R«°*—ºÌ‹y‹"Š7Œð6ƒ;É­>s4SÁÇÐ&[c)ûuÖ¶Ü%f~Þ·j•îHd×V`µÖ™´N–ͬè ÀjJ‡¸ÁÁÖ~yÎ3�·“Û½„æÈ\;12*¤U5Ÿf RéâóȺkûV„SÍÕ¢Ù bhV/ h…Ø6G ¯Ñg›Ù?µ�4_tëÔÊq8zÜ‘µWœË÷~Žiºr Sæ½V“Õ-„qæ–‰!½ ¬à% lgá’“AË$Úh£Ÿ×�%Þl…F9EÄECl¢4õ´› LÒ¾Ò×Ö¯ÅüQ¦®)_·# ´h×-{§·zóß$]!­¸]»ïläÓ™öE=ëe=ž8,}…ÚƇ¯-&Ý(þˆ¶ÚÙy7,«//øì{{Qâ <üt(ZÆô?”L~š ­eKˆOëÖ){!—œ€iô®®G͉çFÌÌTç`+5^c•+`ÉsîÌzœ²w ñðª©tñÝJGG5Hå--W”–’AÝeÚ §ÜâI ›Ö´š“¿Óñ艾ުwÞ(ÆÞìHÔ j‹SÎWVÍX;’Âú~cu¿U°Ëâ ¨pl¡RÜõNXR½%ä‘ÊÚ¤8‹Ì°ýÿßôÖ_†åæK^r…zʹs6•ëém•ÁaÒo&‚Ër<ÜÍz%e1¿F/<—Ý—lFE¯sÌs÷“NÉÚ@….v®:3u¾öÍöÐÄ9~÷yŽ½'3@«iêø€À[Ÿkedù—¦…q;¯r߆‰ÖÕ ‡š³aBÀ…ñÔ9èÓ—)ÑìųpëÖ™ 蜨éÞ4Ϲ|Ó2‚ù õt¬g¨mœwüñx‘§ád8l  zPCNŸüÝ PÀך‰Bõ‘œU3d^-//9^äÉqR¸¢“aW+˜]Z&t\²zÏjn¿‡ÀÏùÆû7Ûw%É‘Mà)ÇÞ3‚Ù†-–ÉqׂYÔí)Ô\7}ÑYg%0NÛ“®Â‹Bªý z°ù´%ÄÛ¯7?há¡×]¿Ÿ�^z>Õ.ÝF�"Ç„’îµ&Ý¿÷E#'ëÏBÇÆ^AîŠ;OŽœ¸•.ݹMIÉÊV»ñ•”ù]{ê[Ëo‡ ~Kа=´ë‡¢ié'ŸÒ¿’O_êoÜ5“§|ôÔ«Äù(y8¬‚=Ü[ΣçØN§RÍýA%¼H‚‹ðÆ@ AG£Ã|´ú¤‰P‚$˜ 홥Õô•ýVÇ}» £¥ùÒ“°¢U\ÚCöã²pð SºªÝL¹1ºmXå®6¸'^e ‡§ÿ!8ú¸ X6Ê+*ª:ó‘xéŒèX¼ àÈâÊ+‰è‰t'úùÚÊ"ä¬MG·fW»Ì¥¹ˆ¿“ˆîP Ûuoþð?ðˆ+™‘a™ÝØÂiñWa,^[TÜßËì¦Ù• ,ˆÊIÕì2–«Ô3•DêQüÀ(Müé2¬ÓY¶¶väa Ž`Æ»gàQã÷va‰BŒ¥ÜEwú‘›OáE'6[>õÌL’Váa¦"j·UªÝpUiG¾Æxwö±—AoFÕ79ò–/·éZjõ,qr1ê>Mo.ÉJÀ¼ÝþÖ«ÛU§2A*õøn› ža†ÕÞ«¾?ÏÔ‰F‹84’¢u_Eg)Ð`0¶„†µa T?Ê»ïE Ê(ó$ƒ™ý—ÅûÖ{¨¬¬5K0 Û›¸ˆÌ”bï§yŸ_ƒ›SßãFK×Lú ['Žª#Sé;Þè4%™s{‹Œð &úïŠoZ®‚žƒäèžÐy)¶Â}m“ÈÒ¿ôÏ«Bx#hö4l[«K’•À° _¨QܼAå\Á\‰êιaÕ§ØÏ-Ò…Ÿ“TØ>þ -0 Iv¾Iš€rnfäÇå1>z5¨Çä„óaÄï7(‡¬˜o)Ã&8¶2Bó: ôßù‚Óß=ÁkC_6㎬ŒEÊ5Ï•â{ Ú²rânL dæìçà…s|óq×.{FœÍjÛÐá8øîÑi„¤gDǨH7yûcùµÊf2oÿc.ù.»&1J˜ÁJ— çt #ÞíÎ%º‹îÅYŠ �P• ÄÿÌ‘ÙÉ^UÆ7ê<$žœljÒ[4‰;ÿ{ßëUÓ²X&—ep9€7\xÕ_ÖTÐú²EšÆ2Ëv¢å]ß±ƒ±›QŒv"x¶[ ÔŒzç6 …Î7¡@›×oêl—ET†hÛlè|*H×™VÌ8Ôæ[ÌF’M_ÏcKÕ±¾ø2Wªe>PòÐXôò”úD«ãlÕ;Ú5ܨ\Ïã¡—K-,*„å‘06ÐÜv(l ·dE-c«ˆO¹ ˜ì2¹÷þŠ'HɵðàÆä¨Uöf‡æódRFžªq¿Â€Ö�9¶ÑQÔ‘ñ1&Ø×î{…º %ç�Õzôܧ Eåð¾éN’ÌÊï•BZÂú|÷äØ»ÌA‹þh`v/b"Õ¼ŸJÈÚ4¤¬NËb(jÉX×z”4‚ñª}G‘A+y¼,O«ë3*. X-¶ ÚäÒö— }R3±NŒ3 ¬�ø>›àôZ¦-õHáHB_,éÕc3·Cý±°|3‘ÁøÏ>üa¡sj[¢ÞÄÐÊ‹û­…l«øš@µkEë>ù¶þ7) ܉èpYwV}9mÐsÛ!×´‰¼ûÙ7&êj¾ç¡ozJOƒú”ÎsMÑ,¢ðß·”ùEýN“Kð†×ø»Ñ?iìûŠã_«¹I†éçá7-!L@ZŠ&”ÆÕï©ü%KÜ98°Æq[k`˜¥ÏMëì•XO�ü»»W‹öN™^ù• @æVy™•aÕowh&Qa0‘¸.\F`ž1#ÀŽ±b¢ÊHˆ ©’ מÏ-TÚˆ¤â­Œ˜ÔCU©ÈêÄJ·ž(ç"Hê­C` ©  ¨Рb –mìW­";S*”;Íè<Ò¯¨<›GÿúñP©JYM C¾<(Û?® „Q)GG7úNódĶY=ËíoËì3%Ú›ŠVëÉ“&ó¬OGQ%€ËªWhV}´FnôÎp×#£Ýô ,„?f¹Ë DrMBçÚ`GíÅ¡‰°„Ž ?Í6B[ìr­EÏ븛uD’ðò21Ïã[ªÓépE•O7¾5ƒB:½ˆo”#"ÏÖR y½ö|ù|ðØV—ÜÀ]Ý«¬‹øÊ Óèò4†0Ånšå)ôü²Pä!å…ïµúÜRûq„SqñÑR­^?‘í)=à wý (–¿w^Ç8Uý¥XîK@s5Œq¬?½ ÔçD ·ŒA,ŸÜ{U&y&yå 61„X!ÙÓªdê‘…H‘Ép±gr±Êx&Ìý“§¾z7t‘ØTjÝzbÁ€ãv �8rê§sæŸØKQyæþPªæa…µü`·W¯S¢naúúÈE=ó°Ÿ¢8¬N)�—㩹ƒ \½.„Áª;bLP4Íf‰GB¡šc¬•dò-(—=aÔÏelGó�×ð]`‘^§íw úo\kAöm=$Vï^R’Õ†*ßO…"Dy° ‘;Ÿ€ªÒ—e©Æ$¨N_ÖBBô·hùôr8üxƒÄÊñoÌé º#_k‡FWÝÖ‚tŸÂî÷=«\BÃky}IƒâËB<dð&–9<gi?™—‡UqZ8 Ð&¤¤Øöp+T¢®‚¾sÑÆ–ý°¾±xŠ ovÇ…ÕX°m×ÿ¡ÄBêŽ3nòn« <ªélW7;ÊU¯mr¤bØPYCoûj–éêùèî TÝZµ„*[&-Äa³ÒrŠˆ¢âäÍöo ~‘Ë&-09|¦NZ³4I4-µ³–Ì´3(;ƒY£6´ïð436¬Å[#Šõ!�š›ÉHXçÉ?áTÊÈ&¸>É&¡¿¦#Êp¡ש˜~ÂŒHé½þV=L]ÍÇin3Ð7 »Ö«À;|0$ž<<S†g—nÑ¡³t ÷9Ì_fof‚iƒ ›æЫ®æíhŽ1ëÒÔª¸ÒíY`ÛС1î·)sº-è)\ÓBmŽŸ6nœŠ]š}KyÖl„¦v¶V`aiéÓJ™(ß)¡F¾¦¨mÉ�±‘g]qÌ׃§·¾ª=vVH¹sëüÞ•KËÙâÀöúÃœÖe i£  ˆêŒȉ,Ø2í"ïßa9#’H’’좥iÌ:žoõz¿ÃIi«»e"r_)>.òEZ^Ñ‹ƒb£ªKð3àñXæï¡·TwÙšg!ŠÄœóTeýiÎßÌHy5L¥ Á/|§Û,”jàÎ\Ó¯ÈØÌŒ,ÂCkx‚Ý'ùqÿò¡0ˆµFM }}‰�xÚº^€" ´Á4íY ¼ nF*æ¦ùf¡/ængTÌÓ]1é°¤—,?åu-ù^¿=¶NT•Ñ¶j)-ËÞ'kíÃoÓ^ÄhA³»GIžScÍŒãôöZôôéìj½Ë–„³íæsÍù˜»¼ïlkm­¤ÕB)ZœÅÆÜ„„ÎsmhaÚÐƽ?†Œ¾æC)¤ïƒx>eA¹Ñ–B’UM3íZÜ 8ÒD“¼mÛøm�ܵV2™„í? ø5xÝ…N arŽ\‘.¥EÿÌW'Iú’�$žÚc©’#RõpÏ…ÿÑÏú!€›AÚ>ßýG§dÄÈzÑ–F>nü9ÒyO«ª?kħ۱ªÑaâZúaµænE°@?•ÓYPt>&{©ýöj!]*¦0Iw¢UPm{68гuÄmZcYg/þA‘—‹!óB¦X"à_ír¦ÓŽFæ0_¢Ò¥ ›œC¡6™UÛ‘Q[{ù_ ûuZQÎȆþ¥,¨;2BWU™¯n•±ºàH·É¢Ä€€f iUGnêë’™‘„ÖTÜÂcäZcÚˆ!áöЯÑƘõˆ”I:ômek !÷šý‘ù ú«æ뽪qU¡”cÑðW}½#>~Õ$þÆз-‰Àó0Ò?ù§Å-±eØ09-†IÄs¢—ôûky¹¥U*¿! ÊF…ˆ¸ÓÀ¼ƒ“+¨ L]”Ö4Ä–u”'Õ äŒ7NoN3sÁ@?ÇýˆÍ ðÀZA‹xe|CÄ­ÖÖÓi؈ª¬‡¹JEŸýmÚMÎÆà[.ˆY9Ö"5†d„§…?áá‹vÊNµ ]Þ O,QÓ^^IA&±?ÍGúW§tëgóÞ€v|�­Ïî¢S Ä5—§>j–Ä*8J@nµ?\[u—ßíèQX^ºÅÚdS_¼ñ°8Ñ"Œélhu(hŠ<Ç[€Æk²•K6‘ÂB¿%cgY–€ôC¦Fþ”Ž¾<A~w+ç…‹Gþ¾(§¶Á>–á—UŠYíÆÕ©¯ÇŸÂ ¡ë* ICúó^¥êsÈRSÉàL~é<8#« ˆÎMs±ÚÁ*d㌆*Ý<“¼1I´l^&¾Ãl¥>uñÇܨfjUË_Ü®òðwþ1âkƒg|?z¨Qšu‰€¢)Öö.e¢#”íÅ£{½ÚÏ‚îEÜ[%30hn4ÕK©Y¨¸b"uáˆUxŽÅ?"¹F‚�+¡v„ÿi@Ï÷Bînglàq#̼>²†íB1 1M‚ݧªI@¾Åóû–ÓŽŠ’¼Þ»ºE¥Y‘9 4Ýèc íìnð]æúÆ›0˜>Ú­Hðé…J®3¯"@¢¨¾84Ãb6;kBßÐú˜võÎìHvM½*ªî[íà ÒÀIŒÿÅ•^Õ­nUl' ¥)©Ö#9ºnÞÀb¥³#öáÕÆgܺ³Þq3Ö^¤Ì1 Ÿé~om%„ †åj{bØyª»úuÐôWÙ·7mÔØ{÷l˜¿U_ï^†äR[fvÃb맧¥½›I ùLÚçíàá2ð•ëß;z|€:|y"$¥Ûé,Š+«ü¢Sf4¿AQ@"ê¢ö +;‰‹…²dL“v“Xþ´î)•ò$[J8xL®f}< þ×nA$cÍÄYÃÖƒ€9`|}bµlU³mÐû P7­Ë|~íýmŸÒÖ¿xØöéãÒCJŒ©2�¦K<u¸»—·申JÞ‹“*õ¶6êS<ØïÖ<´60¹ûîV>Õ„oÊ@[ÑãtŠŒ—Hϸ|ãP0Ðñx¾ —µüpa}(ÊX65Ø·æÕÏËeò—ãdÿî[™äÄqøÕ�þ5WxK¼2“Þ~Sº¢ÀL[¹ƒQeôpÊ„¾YiÀP0ÕÿŽŽÚ–p­‰±¹ö»a‘r¸^h.¬º1…L(PÔÚæßÃK˜]ÙƒÓ‘§Šð€Q¹¤(ryl:~ JÙŠ‚BŠ°ö’K:´ý ,¾úP¢{ÿMEªÞÍŽ­17‚x8ú(ìñ¦ï'VP-8¡µ?`·GIiŒL+£h¾ÿ wÊ×µ"Ô+51‚^_Ðéy K¥ð&ßš’rúÙô¿b†¾°…9ÌÛ ãôõõyv“z0Ü÷H$ãùËãÙ¨~šŠ#¾âé—Ì¡B¤ó ´D5ö.¶0n!GÑ_:€Úеø<4¹©£ CTkÆ$Hë?AÿUÎt\X]}˜]è®ê.Â×RȳÇOOf›R„ͦ5‹-6ù Ô1}E±Jä4l—ê§éßîHï]Õk;6½{#n‘0ê¦ÀÊÝÒk¯FZ~oš4¸ä¡ˆ3ŸØ X7F1'=tèP„‘îÛ#SÊÎH5'�XŠÊŒ‘¼°úú|çxóqrXEq0ƒìºö±Í›k›Ut%dðXÐ J‹üîÑŒN‚åðƒÐ¹¢Þ,¦ùŽ¢Î ÿ¯B2ó%?ƒþ溦¿¹þcnܺ>óTf‘j}ÁD(Ó²]z·yãÕÖ8ÿ¦\¨'˜‰8¥�º*=åéO7(u†Üãj¿¢œ¥N“µ¯ÿpƒÎ�œvR´óBZʽY|—H÷†FÑr=šè“°¾°iÃþ¥–e”¦î¾0*õ‚rÓ9f^ãhœé½ûÇŸ}s[pœ.JY³ÑàOrAaák4;² –ÿ¯õ¸‘¸"Vá”ñŒZ#Teàጴ‹~‹®úgUT¥ç#ÆòQp'm9#|uhÜ›öØ7êP*'•ÆÁd  §,ÌíùÃ(LÛÙηXqÛË“%@yǶ ólò™b&n¬£@[[}¼d›UÑ¢†±)[ÌéM¨ Ö]á„ “¦î0{WwÅcãÐÍ(XÇ©ûÂ.pÖÈ!ë¶í6õ—imó1—}¾ÆÒŤ‰Ñ[8aV]i[7}”ÝàÛ¾–pÈí?÷FéÁŽù£¯ÆUuMw§4o±B_vȨ́åëmß1}4ÌÜ'äÙǵ§¢ÀÁ„Jù¶·ÐþÖè!ŸèŒø€ƒ¶}4N_ýˆÁÐÔ-´9;©`°qðà4ÄÄ^`úØêLœ§*ÀU”"Žz[¯±Àèê‡&oV„•Mh¨H]%Sm­|Ý $œf‰O<<1/ïwæÁUo64­œ MYï€Z–Gy-¡#ûê:·ºÿ[ÄÑÊÝ¡©hU•Ã§Gs1Vfœ{v‚„¾$½ o#,ÿ—µ¢l’™F\ÊLO®>aÔª-O¤*É¢kã_Hëô•kÏÞBþ4…ŒÕ†Â]ø®6¨}½¾¼±È§4séƳŒ¦ù /ÛÄ fÄ65¦‡uøJƒxóiœ¨¢¬4¡ßÁQTFÏÒE]¾(ß„8‘¡dµoó"¨NG/[eÍÆ¥CWû zE…»xw3öë`Z¬7tÞ¸*}ÿiº-Çž²¿pT €Jvƒç ^ӆцúAzG»ß—Çb¢N¼QËkñ•ˆa¥íÙ(ÀL0îW O ˆ(wSf1½>Óý·ÖyÀR©>(ÚêJVþpbýîSdµ¨a$u €²Ý˜¦c©¡ûê½WÊ$ô$.áŒ;€t¦Ã5öGOJQqc-MÞ×Ä­"‹†+ \u:Г(¹üÁÿ£R(Óˆ3dãG(ü±„­JÄܵ]äÀîyÊdxìë.÷uÑ ~žvn À3m)–ï¨ò]kô%Iy¿Æ|±ËÆ!pÏõV£°Ä©í¸3 H©‚¸-vÕ+ÌÓ…9Ý)HüXv äÞé,:<g²¹^X…÷^<ÞN:á ÔöwíÞÏ&‰©;ÔÏ[_×ü;öiµ¨É3Q^-lb˜±b£±Œ* ‰/È®ú0V$€ÁJùn{IèÛpaÁà‹æ*‰ÌŠ2'²¡¢û4ÕûÔ ÙÑ ùPæ£à¹ÛÖpn;hs¨®ànpT¾#ÒÔ‹Åš¨*7¼Ï0„šf(Zç:`¼f·Íñ‡Öþ+îÛŽw. ä]>6bÑçaÚ}ÿ͹ˆŠRó3c2³ÐMÑ'‡Ö4[äMëéü°×l âÌJ9 /€Q‰M£%¸Îzç£_„$–²^˜€€p £†Òó> µ÷í©þÓ>á¬ÎwD`ƒH‘sçƒÃÐÚx þ}5EöýYJ¶€ú()C>»•Æ´lÚ¿óeœÿojÔÎ no<«F¤™îɘ½Êÿ²ß#6­±í‰žc4«ýw®¨¢a=$£áÔ‹r“õ†p¡1¿«Ì¢3zÞ³õá¥ïËvíOgæqè& b*¼Ú—AlÛH à ˣ…håféà™_;lKš-`J¹¸ÂÕŠ)€ÈèqGé+|¦ô½ \’:%'ô×Ì­ÊhdàŸÆTw’ãO¢Äc‘M÷17O +Uf¨x!ó¢?å 󬄟o‡ÍV­R\*) A¤«¥2°‰JÏ®2&“²Î÷®Ê•V¯ßjz}Ìt©sµS‡mq1¬Òs«y¥»º/Þ탘©T@øL:Úƒ{9M>T£`M6º[†û£˜¨Åþ1ÆñãI¹&æ- pm1ýÉgSEËWrT3…ÿ/LŸ0„^ Û’ȇ›%¼ à°Ì&¥óŸo¢~ÆÊ2:vÐÞx²!­m˜¶@¾çœÉFgZóHòJ™ FD™%±JÕX–IœeÐÑ?I”ú­WL3SK¡Db»¯\c˜–ÐÓ¦“Æ®*PnT <]#ªYê þN Š^»Cû²mÐY~µ‡7òQQK šNt»àS'„öíož¡¸+û¶W)` ½ÝWç1>Ñ+’ò¬àœšž`o|<Bw5™ÏO«Š•k/Ð*…° ¯|Ê;Á¢LËȱ̱©®-ûÞ#-¥e]‚ÛÚ+|~DWyvh9y /’ΠÉB4šY,ïNIÎ#i’ž_2uË�MÚò݈•Žtbi6ìà`ÝG_d[ÑÇX-V¿3:yuŠ‰¾8Â7…"ö4xÉÚ®(>ºä!ЇP…@ 66Âå1{üþ½5Ñr�¦R)Ëè7×T«,ô;¥Ìý«‚t²Úë‚ùÒÑ̽܇HŒ0¹3k¾Äœÿ¼QT25t7¥Õž&ˆ3nˆñ7]d ™ñF0gy!bÃU÷îµÛM»^›@Á&o˜Ç™ØjN14œ’ɺσêS‹^Íg{Ü@$kùòD2«ò?�OQöWù +ÈæËhQSÚÞ¯÷ü-F(3ÓáéA©wýbXu\ìa¼êà /M4Ë“<ë£{G™°Ëà8±‡ºœ:´{ÓÚ³3FÉ?9Üæ¦íw_«8y—-è­úflÐŽ«.Mƒt][‡xH;‰¸Šyc?´ïb7Žõu~yà†(ac›ogÇÚæÚbzÖtÂ)äœÈ^>š<…^ XwT¯6zò ŠwíÚAå°²>.–NàÞïÓ†F$–:ðc$åúÓ—[ª{X‹¶¦1àÁ½Ë0^\úE|‚þ^‚r¸õ¼ÉX ‡ý4yx{XS]©/ÒW²�\‰ë&Ìzƒ‘ vm¸±Z¿€àµ›áí0 o"E±|7ýfg‡{6)b7“d…ÁÕLa2mDÔCys}˜˜¾Œ¹:±\("_»Ý8¼k~Ñ¢`9§lÔÕ†PèÃ/‹8žŸ ƒPVMdVË6‘›±>Ì`h² 5<¦¶¿¼6î´ ¾‰zM‹¥Le¦Ê k 5-söýí¥'—nLq&Q?{ ;|Læ{䊘_<t°ck€åe>ÎDÕav.]Gö9k–¹טý‰¼Õw„åžöÒ«ãHðÑÂ=ùéO8cSKD±öjRú ›^ ÒbõŽ8;œ¬_ò‹BÎœ<1*†S›ñÑN8CÆß­êWUéØÕ“0Ág>Gç ´ZûyÍUWÓîôîü¬Â`¾™ùóÂQ9KŒÇ†ÿbÜ=`µ©j¿Ä¥æ¹ pzQ@´”y¸Rëp…ÅEXÕSWµ$x¼ý­I,’£‚')NŸ)c×â3¢¬Ç…“‰ Nëe^álÙÔ%±õø$}gÆÚ°4“±­Ð—ëÆzTydµ’ãHüt@ÏŠs;ZÈ™l4œS}|gžã@‘3HÒÊŽ�Oà’Ï> X ÓÄÍÐçÕéO{cŒçÞ5eûv žp1õÕb‚È(4-zð‚G(e7FJ`ÞéÈ»wϪ(½–Ž…smŒºÚÙ˜!ÜRÒ­2–kÍŒ]„k‹,ÜÁ@ÎP?|Í™~GùŽìåà÷Ì­ŽP(b•ØþµU¥J­×¯vSYÿ–îh®níòIÏ/n§QDe4+:ûÖ]>˜ÿÚD'öiØÔ\ü Sãs¡ yØ0Nšƒó¸ÛBð èÕŠÈ¢.¡áîï¶eP¶*µZ(4CҜۑZŠ14–ö„FŸg¾w�<º»4 ªwuÓ>¬Úz`hù¿o‘óÕ®Í` ܧb\d¾DË2Щ]αˆNSÏMˆ9µ<{AMGeï‚zz÷—è7[É™ˆ•WæMÌã7?Ž»ý^uÙéë›ÀóPàÑsD*LÔ­ií× W* .Gñ¤¾,\&ýß¼Úó"ó8,8Ž.‘p³_«ýmËæZ\èà2ÒSVx—ʳêœÅŲ­ q K¤âÊÌȪ†ýw:M ¨ Õ/%yéöâÊ&Nøå°c`¹//Ž®2ÍËróˆwGŠôÉÔxª¯=a4¼NB>{™dÙ"ÑJ=¤˜ËëC� ýc0Å™¡Ð쬃ûŠ^öfQ¡1Dü¥Ÿxè×ñè›Î”Ç7t†[ÇäšÑî2¢ùÜrXL´næ[~Pe­‚c›ÐNPÒH‰’éÂÖXB>Ÿ/szžEúÒ ²Ã†ÊdT‹;ˆï™ÿ×óSÍã(õü^#±ùË‚ÂBp‘ë3yÖÌÓØ Ý_¹ÛvÝ -û [xü+‘}j¸j¬EGÌBýNÝE¾Á g:â¡m™UŽ€ëÊ£…\n½êžð\âØk²qê¾í)‹lŽ@aü">Í‹ƒÆ Ð `x0Fɬ- ã� `„7pŽ²Ê¼y }‹se¬*g‡€Ó¥§BÒ)*íÂR¯{ô°Ùªƒb³ïûí•hQú€¼ÙSºúÕ[¬"ß*¡R¼Â“â(ƒ¿E…bßátï;DE'ÊǪ¤òL!¡öÇÈz!ðÍPÉ=˜„â\›Š£™Ì&yæJ7ðÍ/Ć:ÎüžþþûxT D&¯Ô0W´ú¹8â¦7è^ü¨¼Š=#b‘>س}äiíµóaIwÌ2ûvƳôÞ•’2Kè ß ¼Sf7ú®«ÎåÛ ¡uñ ¥6Æyª_ Õš6?bFad¬×Æ…Ó[(ÏäFÒĥϬ¸·è8ËÇÞ÷‡9“ð7ŒÍÑ©_µÍåe!‚$6€¨2˜†ݪ¶º×¹M^P¦¡ÍúöÎTÍŸ´Zf¯'º§´›AVy¾Þm{ Jã¢/\o;uˆÑtð&µ³uTöx,Ž]ü"j/Í“*¸«Ã[µ8|KÁz½õò¢Bkai‰©NÄUµ9{<ÊqSyä«bYÏD³\æQšq÷îH7´ÕôÅj<ØÄï ›³H®Hc‹Ì¦Ö3á6)‹›½$º•øý0¦©yª=Þ"O é¤gzÓgy]þ¸TËvV9оz ”«ÚÕƒYÍ»~JƾýÒÓþYr–DÞœ…'©pà ßuÓ UßÚ‡5RŠN¦lS:L&ãßõÍp,À'¬Lk§è9õÙ›§Aø÷I–Ä+ªfQª�Îéîðg±frH³ë'ºYvò‡ Œ<ë'Òiî¨ Lµ8Ž ˳٩Œ ²¥¤°,[Û£I¬¢%‚º+±rïz‹nloe-Щ¶KÒ¨[x¶p Ýl¡ÿç;z³*ýFÆwJÛk´ñ¹Þ7Gíí$,Ï|U%vàJã½uòPÒÇ´ƒh*†­ Í éa; Ç‚éˆ-ºq†×AE2Ðëó¥¬rs6ØXcž–îFCÙ hÓLº?ˆáÚ}½ë™ H1 K_“g EÐŒ§´ù¢¨g‘ú8SÚ ¬ ÷ ^RDƒ*çÝ@wÙž²Ç+O8ful4ã¹5½Sn 1_Ú9÷tžÙUfþ€”™s$H&ƒ¾JìQOGwÆÛ%:}°{èåÜþYñ®õ8i¼L'-ïþžI–YZ_i˜ß‡/ú+ý`ïBq¾€µ¹j-ý´VÞg½[Óš³Ö¼ô�è{Ù±ž0íUKF+»ù7 =M¸êòVÐhQfÈcwúž )qSL[9ÂÑ5Ö ‚ò¢!# ü“[z¤C‚Qž‘éQ«Fʺ¦O<„½»Øqqi¾�€ü÷{‘CÃð˜¿û¢£e\.wôä´{å52Gʾ>cCÙF?›s…løQÕ—¢T!1 19ûÇŠTð18†ý+Ìo‰Îb&ï˜ÛJ¬Œ®0HBAX×{Žnň2—£­4`”ÌÈzÇ¥ƒ+Íaz[ ) C–  ³¡õÙ 4sÊO<Ø\–ì3#›Ü¬È Ê]¬°'÷6º÷WΕóCc�JÓÍð©¢ÞHù…x+Ö¸yù«ˆ­×�‹ζwpˆTN¤³ÂdüqËd8þ´€'ÌÊåG£òø&DÑB†‰N©ó†bdÕYÄqÁTØ֧ݯ۳$pöâI»3¬|ð Ð,¨3Ö_n£Ò lMnˆ%0M‡£ Žmý±œF¡·k¸êü˜q]<ÉLÓä5Ý™Q´ìHK ñú÷0>ò+a#åÑåäU/Çv\]„.}ŽN…Ö4UgsËH;!üÖKaÕ× ™¿õ-‹ÎNA½bV ¹°²Ì•ž•}XÔp¤;ž­/®ßQ:q¹ã´ÿŽVÑæêPÞlù“…%ÙýR±kFúµÖÅ !‹WüûÑQ6ÈžSEvvû‚§³Òóˆ}¹¦>¡²^òþ*+¿ÙÃ[Ñ×ÆCU¬ÇK¡`shw<®-"ŽÏ#ÇÄ÷ZìGÍüÒÒxŠá�1Ç3Ö·æ½ey¿aÍ93dH}·}MÿØwÝÿ-N”ÒJF¼™wGh$Lµ•À3b¿Žß²²^Îñf 0D„Aºè¶‰nŽ�•Wu’HÙ‚Ä»mD–ç ݺÙÚ#Nñ$À ¯¤£þlhårÛÈ(vv�PE“ž-øK™ùï[R/Á&/ÚRd‰ÛžL‰qð©vuFg¤†þë,XòP NØÛÜ™þ‚ï+8Eû‘aî ¹1\ŸÝkŸ\«]¢ïÓ¼pÃÜÍXY³1û½9| ,ÆpÚ"£s£v¤ÜßR71°?%Ñð¯nÒ¼ZC À Ê ´´&gòî1óh8¶"zÊ)ò!=óáÏâ8qp@î%ÌoŒ“kÁñvGõªÝ/Ï%,HZÄaºÀBé³µ•×©5ß·oL­P¼++‘{JŸYæ'ÙtDM•Qµ9d"žê1ûš¬q¦â( Â;B–çÝ" Á¨oÙN­D»QS‚»—¼Ijqú^L1ãT§¢‰A’6…â¢?Ú”[í Ï5Ž>’äXŸDºZ)Ûÿ¡¥d5éÄ·ÀÐŽÒæwn2@¦¦?ÄÓ}µA¼å =!£EÆ—‹GQÅI5ÛáÁÖ#žëXøÏQ&©ª¸¨-‚óqzÚñ(è¾Æâ7þÑ?�Å8£ˆBAFåÈ—áÊÑ÷þÛÌ®ágçùC¤TYúŽDŒ1Ë F9½>Ä2À|tÊnð¾xÚ¢ËûT ¸Èý°E»ë<D¬_jòYÖß@ÇÞÒnÝybiÏ:éweô¬(s›Tú uÈ™;ŸfŽè¬žï]A·;ó(.¬ëC,îè™_!|Fym[Zµoc»ÝMËêñ4\5V¿u”†>m±õ3ªLÁšcÅ'ÆñÈŠÁOÜœ½ï4lem s&syœº’YsŸ�ÚçO;èoLìAûïÛÊ8R ~¬ÅÈh=åÜ’0µœ[6y°«Í¸ûc’¿;Û%Ê<°7/¼}Ká¥ÖvA¾€_žŽRÔ?•ËŽ5×VÉw „òõÑÉ¢óT–Î æJ~²PâW%ÿ|”:S¡V5X]õ—'¿>îÏ`u�¬Î$ Þ5šÒ*ðîŠáE†ÖϼõâÝ3>l™0ªví8êa´k Ò <}ºYçšNÌá2&ÆÏ>‹…ÿ ­ÁSnã>8Ô9OÐw—jÞ ¬ÍUËšš÷*6Ï ƒu‡ ™R ©2z¸'éæÖC}î1óÓïÀ¥§{Úf‘ÒE’’dzuï©ÒoÇúù§LÎÈŠRÆÆ»vO";ÝÊßÒ3À:U 5=NV ráoªûg“þÊÁî¢̬Ïô2VišÕÃáɆ¥|Czm vf=Žpà]›/_¡Í|èZ<«JÉ[p^ºçî”ð.#w0‹Ë9‹³ñûã)Ë5°õä\NWúrídÔhí¬á¾í§®”ÀCoÑû¡öÆeü“ù&bÃ2›Ê/¹ßIU –­ÑÇ;ºGƒNKXÊU-ÉÌÚý¾@Ʊ×æËÁÀî 8-Ä7˺‚»ÝeÝùþw=pÊrÿA8̓ Ά"GÒí’íG‰ »¢He™ë°Å'¶{VM,7oÛLTŒÇ›O§jÑœÖÚ@ê]oÊqÎ+¿SZŠJ-$#Ó«¨{ÚÇï dBK‘vÎAc)×Óˆ—b6ÿßf'hò˜«‘.K¥.Œ2>¨gñ°öZ­è|R˜ys¾p/sÏÒÊiF°Úš#ÉWíÔ.¼Ï?Í _YvE¾­³¯h%¼›5ZkãÑÛmªiˆc—Öéh<Ôˆ„ê7t§‰¢Ð§R­Š”“2c``²þ…u[CÀ låÑÏgHºÒIÐ~Qíön¥äc´w[i™ni}îwSg_ù?7ýUñIb%å(²aµOXØÜ$ƒ¥ª[ˆ¸ðæ(ü†¿±/^rKÀTþF„0л«é4û3™|ªÜ¡ß»¦ %ùH¶5bÿc‘ælÑu� £°“XuF^iŒÑ<K˜ÁU€Ži¼ГQbÒ+ÂLéiF¸Õ£6—­îHÇšwÈ0/ ÷ãWßþBød(<ܾBáðw" þÖû§Ñ·ß­ËÀŸÚÍ,®Õ]™7gÞ<(>ùREËÌ2W »8<~‹µÇ¥î}¯¯8_L£ ƒÁIý·Ìö|á~·w+è æè$ÁØÔ¨ß'lÅR%- _Hì-í>JÔôA1Aªá.´1Éåë“®É"Iæ÷ðÑYêîlÕ:³î©f¸¨ó¹DÁ;;¢ý¹R™m곶%E·Í…R»yS&0¾ÑFÚ994;ïy~e¹°sfÆY«;¦Fµë- (Fm¸Z:‰ÛWL­…4óHcŒÁ ËÙ*ÚŽÁÐŇsW›ÀúK½%™ûÏÌ:x4 Š<@q¬=þ-}ëÉc͘ó¡×?îv×|üŸÈN 0uN¢3ù§hb(tQìz{¤×ÿ—û ­x±k®RÄ¡çIÈ͔ÞÑžòM?OõÀê„6æµØÄ`‡K–õ3Zœol̈¡é…ld]:„4blöø׎╧ÎÂ’;çß0Î>º™È´êÅPÏ~GèÚË x•€=dx ϘíOUÕ³'Ù:çp§Úð_=À"h-8ŒË$a;ÏuÌL¾(D…S›Âp&ûZåòR¶°ƒ~ˆIÒ^�°[®Ì< Öò,?m+'‘·øÕ+VéFÈóÎo0Œgɲ –DÁOÿxñ$ñëäÉòÌõhó›ŸOÍaͼN¯±ÒæäŸäY3º9h˜vy´½ØM/‡…ìßlºkm[Ï—UÇßâÖ­°È¾ XÔIPÕGoÃRJ²·39JœúNƒÁ]êtš™¾ulÌØÆ}AÏʈf‹é­µ 5¯è¹Žw»Ö-=ŽL ´ê2ŠÂG7#@¥7à®nzc·¥u+3JÁÉ÷.™pg ¢`ÿ/‘uô„4Њ»Z;p ŠÁìûÓÃñ²Ä.–yPöÊZH ÄCJr4uë‹È@±~)ˆ§z3/€L’îÀð呯ءÌhHf·yN‚ˆ¢È`yRÞì%ô8aj°1è&ÀÞÏ—ß;íP %Ü\~­Û_}ýëÏá$E5Rè/‹ï›Z<+ð#ø­¶¼UÓZtÏE&¤=#$ov[ahÛ±ìí…í0j2 @ämüpг…ùçÛo`hXŒeÚƒ+ˆró™ @áÚÎR±Îu â¤â‰9Ý2Ç1zÑ¿wtœ×JP£kð{Z7ŒÓ‚UnÎU~÷KÙ8¼¢”÷5lœæÑ5Ø>O¬U$iç §É$è{½’Þ]Ou˵ê¾mðfÆê`þD{ítö&®ˆ\*ðáUwë§2÷{±¡x ¦“ÕA‹àÇ&¦ÄÄr쯦÷3ÇÖ„èž*â´µ:›™ÞOÃÊ™[?–‹ˆœwSTi¿õ#fI;ón`FOÿ8Qä0$¶Ã¯‹›,Ù7t‡Û˜VÊ_€—ôÛ—idÜwëûZ]ß40“HQ>‡ªÄ*Z¥Gu¾¯°|›x¡¹úüöâVÜÇ£+°­û%kÿ\êë•ÂÓ¿@SÇÓþÈ&½Zv¾èä°booXhqÈâ>V¶^Š×¯·P†$qìXî†7}…°ÝzTM|#¶="Þ¶ìÐawoÀS¹S'u"„Þ°ÿ£V=PÔ“`Ì[45qFËÁgTÞÈêJs$wë*HN_Vâ1ò<°`8VÌÝŽL€à7;V@} ³Ýë¹1å»ÉãEbÔBOÎ ˜(ÉYFCŤÐ^d’²D¢µl¡§¹†½nzbeeÌÙg €ÏõšÖóÕ5¿·×q]âÒÒ¤°Mä1ØEÿø]aÆ¢. é4SÍVH´OgU÷si÷Ȫôêà`8R¶“µÖÜ3gXºÿãÛep,8®_­·œ´.JŽO”8EuçúÍÅCA£]š—#e°Y£¿t½ã$Š3G¯¦¥?B|èƒtqQúÎçíó7 ×me³n@² j­¤Oná òh™/Ì“¿uϪÌg“Bœd[цë½OMà—¤�ÇZòoœ*HcôUþ”%ÅŠã-\Ø(¦ëÚŠ€‰ª·µŠudk9vvÿV.²tž ¢ö°žá{ø®@™ÇvE_Ç+÷Q\ÀÞÓ”¾ º@ˆ–”ÿ0žöc®¤5£$Î|ÝÈ´RËFè"q\ovy�íÅå6%×ÎihÁ°{0¹FoiÕMs˜'Îh½÷Ç}ÍýçRÐ^ÓÊ ¬ ÚÖü& \ò¥SpÈJýˆzibq@½¸®ª2·¡1Ê#ÝÑö®ºÃ9•ÙƒÇ©"_Š‘ëï­ùr!ýSJ[,çñ[ý½Ì“ªa\Ó¸…¸Žê‘(&4rǯ–BT¸y¥M?;¯‰`&šE³V/Qh1÷ßfJzüÒòʼn`^îtÒÌî�Fä±x6ØqM¨º´kÂÅt=ïh9¾J”šO3¯ûž©±—þ!()λߔûü_äþ¦x9@J¢ šÂ¡ñFn§#Ý¡z §îÚk]Ë^Š‰§.+Vá> ²Þ7È©é,£š×®ªo ¨/6pR,•†©¦þ�qõiéÕ%1ù涷?Ö.¡iô‹Û îwú›s ƒ¢§Þ%eÛ‡¡rKÞgÄ<—H1=Q¸<ë÷ Ûÿ*­¼”5 Ow—HNi¢_bŸWqT}gàTK8Âwp5:½©,�á^áÌÄÄ4a8=œ­¦j’v³aµb™èÏõQA—VHì–%%•6GF ]$tb×þ =Ù¼Šù¬¥Ã6­: p<Û¹EÁf,1ÜÉÐ(¥(±ŠDÉë¨XQR8CÄîém¤ïµ7T¼B\{ŠòÜxqìîï®eyå2J–Cžk˜}Y.½ I_˜°Û-FªÞå±)ê\BWfµ#ÍsPHÞß Ð`ßöƬ]±}P€TçœñwA~V¯Pê4 _´u«ædõ(WBÒ_LÖ@N¡àa9¨»~C¯ §ö.ÍÑ¿0-³¹>çßP1ì¨fN[Ò ^0Ät É ‘ñÃòéM²|Yä3~g4eç Ë",°ã¦Ýøf@¼æĨ/ýdtØâj+w®‰pRÓQêW¦;…®÷šS$‘âúŽÙ¯3ªbø&”G§Š²ö­L¹­í÷‹:ª6Nšq‰“+š" k)®ñÿ<«ã–í]W« æ¦KG%x$¦@S'êËÊ¢”8ÂÑ*d<—ÅÈ´c{®1_ ÿ¹]•›7/ƒl¼XNS‹䣻ÚYÎÿÌÕÚ» ÓE˜7T1;uëœ H¿Ä©rQd£’ìhM)|5ÄÞ-¹';ò’�IæÁ!Å«Ø‹öÓ ÿ@O¦ï4ªÁR¥˜Y À`~+’˜‹Ê†ŽÆ@t ·Ùõ˜Œqˆ¶©Iäâ°0ÌÜG[x­aY, È1Ï<û(*94n sÏ–ÌɺËÛÁBì)ˆ3–×E«9)Žª™ƒ¾Vüö‹þM•¼üÀÇÃé;V^ê³òJû-(O³×ÕpöŒôîzÁ±¸+o«•1âÚ*bE$lµíÙ;‰;‡‚w-»W·[Å‹¸œ³ûLÕ½”tº¬jf%iõ|ÅíµÖ‹Š,FsòÛ€uãì*)[\á3`z}¢M%;÷ÙFp²°Ï‚}”ŸÚK Ïj\’úRiƒà 7A—R(žñ)®ÑrÄk™VûºÏ‚ôËz²CW¾?Ðé=-T‰y|{1R7×?ó±o„OU›ØÉXdÆ!„]ªùây’Snn´ÿXFGƒT^ÏíÁâÌ7o mxô>û‚Bp©¤¬ì(•åøOD ë³U:hfVÑ0ä¡c§¬o»­µ3ŠW ª@8 ܧ¼+Æ^† [{Š}Ù¶ø¤Š¦È$ø~ÿ‹¼Â#ò"øØA±ïˆ%nY“ˆ×{ü¥;þÞ¤’ó³Ý¶±þ¤·Ý Sþe–[ä èBÓe•WÇ:; ¬f I‘Ú'¬Þ,órÔ \«j¯¼§zE�­’ç½"’X:V–ìÖz.Öµ‹¦Gè°c¸ðï[^iòÈ{à<üP:òÀ(li"že{ôD�7‡F¨½Kµÿ“i£vèå Òp®‚rT€ <­™q§tå½È¨KæË ¤·ÜtÍJE=üO¼Ár™q Ty}®='Z@Ò©§Ïi„w¶Ÿ[¦~n ,y_‘5Æ)bVÇ<Øcõg<C;‡A*ㇶé8`¶2:#xäy˜_½V=ŠoÍŸr_ž*ž7:Ûƒ_ 9g(á°C6‹ÿžÆmgJs½–Jñ›¾t”ú¾è�£vÆíXÛmâåeÁÅa™-ú¬Q°§(ï…˜çú2·²I-sr®�øÏ­ã=3k<ªÛוšµc}s¨UŸ·±]‰§ ^Ž‡óe2ÿ»zG}Ò5Á^€%ÛÉ°J•¾›´›å_]0÷~ò5uÕë<eARë)—q‰Æ†/Ö—`Âüæõ-^ø¢[èe_"‘Rrµ__ÿÖþl;ufÙ…¯5ŸÂwçfÎÓP-]J [,ÁÀŒö¿ÿsüÑ#22C6ëìÖö@ö·&)32Š^¬%×èEÅçŒÈ’‚ g–QÒ¬û>•d£Mòa�?žc<N¦Oo#4'ùÿáI'ÉÚu<ÑÎŽ=üf+G&D\ƒùêXUßw¯gœ$#'é¸ æ ÍÂÏe2‡‘›Ö±sß®ãÝühÀõ,)ç Ž°÷ßÌ š°fëG×Ã&Ì«Â7c>°¹ raÕŸ�i=B¹§QBòëO»¥»¯’ª“ Kšóêé¨+þOZ «:n›**?µ×U'VÆ›ž?•xHŠÜH}Ãw çÖ|7îûP¾êí?ü£ ¼7±yø00}”8µ¶¦·R<gÍìî‹Ê•ü<X/:SöÂ]©Ò'¹(Âxß8%æg¯íbÚŸºº¥Ì¨‰]u±=Uщ>Ë„ÓâÿA¸Ì˜[”H:¯ÀJÇ[/ «¦ocU/É{ûz¯:ÀTÖ•Ú»P#ÚvC¯êoµ´¾‘Õª}½-þG Ê#)‚Äí_#xº.¥gëü!z$uGÈ\h¨ ЬÂ!Èœ–FÛ¯4*Ngë²ÞR¾´5ÉØÏJB±ˆ%Óº*Z_ÎÚ!!:Ç›‰¡fÒŠaö²§ HAjzô«{Ý:oì*%Uh‰ä©"ôñ½?ïu4l®ö’¢Éƒ¡Î“Pæ?›TÏ›E Èe‹MtdŽýyÏ(ïÅÕ8¬×ÔåÒ$(1:œ; }Õg”JwbËq±\º$y~Ó—f˜ýû\r •=[e÷îÏ´È#: 0Ò�šZ#â€b¾Ü+k;u¶›¹Œ(Žµ3äy–±Uo·¥ç-1sÔ™Íë7˜Ì¹a¶åO=˜i­kÁB@×E±ŒrÓù]ãb¯c@ÿ”²0ooÞv9Ó8èÍ8uË:ò­ŸFàµ^ã¡i3,ŽÃ฼à'üo7üOÌÝêv•Z+%ѼhyÔ[/ Å¬Ý ¹OÛ^7f•µê†Ý(�Zv_¶; 8Pi³)r4í4-w˜Az›AG9öú¹žt1s€E“ÿOJKåóêž@š©2à’Ò°Ž=‚uß5{íbÑg¼ùñÉý‹Ó@<pÄi x—†Þüà-¬»pÀGW~úe¤°˜B%Ê߯AS G}î/(Ê=œÏ ºh©^F]}ÿ „_ q«ñ°;qm®žc©g‚â 6Ó¸½·‰P£ÛæZ¯œ«2lœ>Ó(iääteU&Cßâxà ‹t­¾Q:¶Sv0ܳ(}×S¦bZàxn…Ò¤ý4 ra;²j–Œ@¹ƒÒ,Œ_sÌhÓ¦ˆŠë:@Y·Ífq:uy`g…õá,/Å©4ñFì1—ÑnÀä¢ ¦J³Àƒ‘£…pÅZûšIÚ¢°¡ý¨þ¡‘O_Í 3C ï.ƒ‰õù­8°® ¦T:aLJEÄ#Å£ŠçȺý¸ûËÌÖçþáŒ!‰7q/u-¶!Iåô§à¾/ò«^T˜ûÌü(%FÔÜ0‡K âÁrl.ڢоñ¬O Í‘1ÀÛ#È=§£C.EŸ0Ü¢óJ–Í‹TI>‹>´þWMMCåÕRÑÙÓîoè[¸õÏÊvc6s¹jœN·[Yå {E7žMëáÝ€ŠÆWps~ë7X×a¤œãÖoh^_ý�+bu iÈ" ôàŠ…ÍÜŸª²ì: ö}|å1,Ýî ¤õÆέë6µ£“Ôñ +8Ÿ±¦‰¿|U¯“P8×@5B+ßAOjµŠrŒýÃ$atþr¾°²,Es<rqH ø"-‚o ^†®EnÅuÑÑÜ'Qýù¥sœ4,ó¾ÒRæqáQG!ö&¨ñr'0ú©0ÞV¸²•>(ÄU3וðW~ÖMŒò€téV(ê|g¡b}dáÒ ˜>vBjs¯";÷�ÕT-,«.0¥-]oØm®§-òÌc3M|Ì ìL)ú \Ö¶•MëGTá7gÛiÎ"XØÿŸèÁçFx …TRmf0é¾¥,`ÏxòyÙF!6"—|ž&:[‚´Sr?¿—]ǺÚÒ+›Z§?ß­(ØI“œËElʇ¿¤ä3´Îr.{ó£¯ø3(ëý o4¾¤ž›Û$Ø `8ªzçuf^7G)=›ùÇ ü. \ OúÆ8A[k3Ô�|CÇfc¨l)í^¨k“jaMZQ@ÔT´iUsûC-\x¾£Í L½Q`=Ýü$F(þ+,aÈJÝÃ18Wm!Xß^u:2ŠµŸ¨'ñÃ~f¸ò?A>¡sCû¤Üêü¼–FÞûÈî(ÂÕxíøiÞoô2ÍêØÏ¡.·¢íÍø†XòVðwá<³ôéŠð凯Á~”¡�½�n#ðèâ²Â74¬$€™Pv<bQzmp/Þ½Þe³imíÏhÙôSLõÃû9úè¤ËýŠ³cøÁê[¡=’šáÉhÕ¬Ôê»q3Ädô¼Ô²ùÓ §ðbt ãËs§¯Ù,Œ‘·}³£Âµ¬ßôËÉ H#H&´ªš²1ºÍG•>ÄTv}Æ>Í�í„°Wr]nŽzd¨n;#Z³�ŠÛ³ç#SÑ/»©í–[V#…]t"¤ÿÁ½œUš%AoŠ—;RAëÍ Ø‘RîÄøk^Êó?'Û®ž)kZ±#DKh TF QzÍÖ+–ÐaÍF <·9éNü:6)x¡y่ʵ9£MØàì†îm¿lÎ4ñç‹— [=Beú@ynÞza»ïTOËŽE[ÛVø®bžÞ3ïÄØ‘³~Ü¥¡Ê±—d'Q  Î…i™õbÍáA:O.9^ä7Æ›PV†|Væ•ÈdzXü¸ŽØo6G^,fìjçv£4𠺃6;dÁïÄmãÿ¤Æ‡E�'€//Çq�=]äX7½ ÔÝS^Ó2€!„d=]à>õðÍ-à †t~Ù!×|-R¦u–{ú<Å¥‰îráìŠ"N! {¨•újªçŒŠÖ E剢éçVÙÌÈ+!¦>A§Ç÷2 6¾ÒŠÄ¤ÉÕpµ¹Ã,Ä°ÜÒ™âé' Úq‡=|rÇ ÅyåÈôŒ€/fBƒ1èT´’V-ø@0@H¤}µ v ¹Ð5ùìgz3& ŒÞ1­­[Ób=Œ@æ­<|ý~XûÜEnòD0`ÇXyF3rºåyì;å¨þÎŒ1®ËP¡²v ËÈU^³˜ÍÊ2^‘V÷.œ°NQèØ¿š$DŠX' /²O½s¹‡ž_”Iâ�2V�üÌ–}¢¸mçâZî·Íäè—ÝŸ²ö¤{A#w_8¢ßMÃöDß2À;wçåEñluš[ °”3‹ø¨ HÚ;â¦ÙTI7ï¿ðuñÙ\F‹ ¶ç;”£ÿ”iØfGÉF&ÇŒrȳ?åÀU¡ºjzïã0œÆíuuÅ0dyÙSâÈÝÏuÓ…WÈmyà˜‡»v+ZŒBq½Õ,¥õ$máLþ¬íP†©C¢Àã¶òõzR–`Ÿ³ûøE <e)Ÿç¼úE‡Û¬6¢1üUÐÈzïK½Þa¨¹îao‚åEÁð’…œ>óîânÒ øþ`3ÍÌçÚidüx5¨Ê„åÜÔ@²üPó|öø…•rçtÐ3*++‹Íy…+7ÿ/yM¶ÈoÄ)WeŸUáæ‹áU„b]ai°B÷´ö6hV_Y1Cê°Ð˜à§:Í;©¶ø‘èTlý§ŽÒélÆÈ£"O¹+àÎB(zQ¿(-èŸYˆE”¶^x3å6‘·É{‰…¨ ®úÊ!ñ%§“±ô’ÂjÿáøJÔdC°ò1$y´Xojzm–ÚÎ냆î¹8x^Ï|;Ñ0äQÞi£,Å”/¿™8f&Túméç6Pntžkþ÷r_6Hz†dˆE0î|6?Í–þS o‡‰ÙÏ,>Ÿ]–³3åÈù{°1yxÁä¹P¥p/¼‡@<j©‹d_ñ͵¬µ›¿Ù*9röÃ7\7ÙH £ìbwL¡é¨p7æ‰5ãAUwï~9DVß·à‹ kŠ¦¤áPZÈЛ?Уd!*DáPÿZXO<Ž >#íÐblL ”,ùå¡ç„~Ï ‰á[™kz.^äPˆi ÁÌ7ñÕãG·ÏÚ³ú?EUdÆ_Ë8C¿äQµÖ£0ËU_ü{ÔÈ/c'âC3œæX߇í²x¡uLé Š_Àô6:²8ŒtÇg",‚}ͦFþ a8w·:ŠTuÕÆÄ<glÿ–2¶÷“?ÐAªùøíÎ1éÞ¸^yÕ%6ö»»piÛô‘GÅ©7 gßPÆ b§¿P¨©ŒÀü%%”ÓÕSŽh™F{{êŠÊÐC´ïἩG-*³ÚÑ”4 xùqNk»içá! |Ó&vÈ"®Ôh5¬Y˜wôn›“Ǥ Nœ§�wðZnÚý§­Œ¶~)<8ˆ};ãƉm·?JPcûrWGtLÙå…ÏÞÉõ¼Ë;ä¸É£tµ ÎJl´ €™sB·XùùOîK’9õ5 ±«Ž¾Bú·qÝVØôŠ³0gÉŒ�d(+À[¯!‰};FÚX´/1-ûv«æÓ³¤?Ž]3>x /¥üE±˜ÃZW×"*! K9lH™ÍçÿÀ‡Ÿ÷b}—¬dun—”E0ʽXéžp>ì(³´êÝbqÃo'û"Öݦ)KFETy¾²BºÌähÙ(‹êGcŒÄ÷k¤¹žÐ—H£lÐæ:eN§fvK/èJU›ð| œq½qN°žÏSÅ�K®G»4ŠÜ Ô7ª®6]tvä¯ha-·Ajâ‚Ê™¢ë®éßèã£Ëò#Ô.6S¯qÓ;Ýd©C­±8öÿ7c»Ì   2ÂK°:Ù©z CE XÎã‚•"RgxŠiàjN A¢§´n-ןRä¶óâYOÍåÃ9e�&-ñÞVxBC¢—ËãÈÝÜ¿OF¾1±ˆÅ ĉW(A·fÓ\ÍYù„{Ø\íÆÙSO»¢óE°eÂÿÆ—@=“¹½(hÈ4“Räé€!Îj meQZÊžŽ¾0©™ÙÏ�|×iûî´ÜþVŒ6$7 ÕAÇÓh´…•ãœ×]$éé4BãÄt5_˜iÇ™a°5gÛ e)`Ñ ¢†W}s,ûƒø5ÉËèâ-,ÎBájÙVÑb5šžøRb:W¡l0Ζ2áê‰k]f-/Yä N0§ÆC"Z@´@ üU–‘gÁ–ã«« ;%ˆ°·À(NmrýPÆÞ5B·4jÛ,ªúOW ¡ÓÀ¸j¿ À˜ì¸ûd/ç’†Yn-ógWp¢ódQ@ r¾®!$åáªÑ˜ýä’«ðÜ:¿Bþ͇^;í9�ÃÊ­AÃý}™l1 9ÊðˆØ;ÇI‹¡Ëüñrƒz~Ž~NF·‚Q´Ëºq^ˆa]Î|­úå‡w»N¼mÔá 3^;Y•{Š_§!­£Ì›3¢À‰•ŽZö{0¶ÝBº <óú† +ËÅ×pÍH¡ â*—ÝÉë3C÷f}2W<óΗ¹â:$º³‚^F¥Ù%À'Q÷ðCQ±>Jâ–Ùˆ3âöçWÚé*Ì/ù ÛÆUo=¬gþ2Ιåj1YÐfŠãâj›³_;À„v£ô‰Ùtü0I)sójû•ñ‘YˆÄìz'ù#YûxÀIO‰áéo7rkòxnûÅ`PÚÃük=©bGÜSO.JÂv¬×¯wG¹ÁÌéÂv/ßR˜DóÊg䊾øð°‘ï;(‚0a}LÈŠè´’žìf׫.,dQÁøŠ¡SJ§úI-s&øÉ”°-Z´ÝQ5x’Àä=-å[¤fNÛµ^P¾ÌPM-¶ùËýŸ ò"’Y¼Êhãx¹@în.·œ³ ‡ê­7ýöu¶ÊŒ|ͤÌ0‹F•¸Jßl€ù2‰_w930’ƒHrÍòƒ‹wß±@aœDkìý¨9×iЄ`öð½”z½ñ³*gG.9eÒͤ»ô+@: Òþb¼p<ñdð=ó𞂘ZÁGéQüiX“›3÷ Gî €ô½éQmðÅ Úû"\Ò9ÄR¶óÁ¬;î>Ÿ:‰\JèQ>òT1Ns#ˆ…68-íôSµf'™ÎLù£ªÉkY2å’=y/½`(vìИ ó˜^[Ö¡™è8æƪ80eë võM�&HY;ÍÃÌöÁ­ìÈ>' )ƒÄþ‰m¸maAe¼°ÆF%¸”}÷_†î (*ÃUƒ.-mz×F ^‚†ðÞ”nÞiÐzO’E™'®Œ‘d¼£Õøþ×»fØñß·Ü3e€Ñî|(ÇÌ€{=ž|ÂãÖ-gÙçÕÙÒMN’ÛÀ™ ïÕä¾àwÓ•SÏ@7%O-Êqk —0j6çÎ4ê3¸0N:¢ðŠ‰å๩¹èÞX>¿�ÐËç-¶œJ뜰>èTR²EaG‚²¦4á7 ð¹‡áœ³ ñ}m-TÉA2ß;)ºýAŽeùüCœ¨qµkš”ïåQµýkÎ/ºÉ>þÁ-¦—Y¯mú «ºø �) ë…ä|~®¼‘˜9£NœÒ’âÅÉ8Ç¡A'’ç[º‹'ÿW  C+dì’EÉx ÙªŒÿä ìŽß…ÛWcFš-l¹ÄEDÒ£v3±¥—@Â@›_ ¹‘RÿȱtÆË‚ÊX@§ Œí§+&ÓÒÕŽ~¾¸Ý­Ð2žø¸Ä,�üTªhšò¨X F¸fÍ|Q¾-˜“¸Pà”ÚXAdYós† Ùrðcð‚‰OBuò„ÿŸ¸±Á«§¢LEäùÓTþë¦_ŠÛóY;ÖXxM•*Í6+C–¾IR=`ØT RbÁúÀUû­”áê%[£Ô €‚§EIõ‹Ç{KÝÄG0 ¼'Ö]šž»e¿qµ( Vì¥×-|/E‡™Dú_\<èÅjÃÍÏ-G2vîÚôýB¿÷ñoÛ¼€UsŠJÃÕ´ûó¤¼ÿ¾!­cC]éJâc»�75_hò³zÊ0*‹™âf]&*:u¯C)�«Fd®²¡¬ôÄ/\ùNðgîØ掋"Z^èþ¥£® hS£“å'›�ˆÑðƒ«àÜ+5a‘;‘»c às0MVZ¾šÁÛGÐøÀò ðóàa…q©3¹¾:º :pÇÉpU·Í% n€ôýèç8ù ¤¢yR÷•±í’l¾5ò*ª ¯3³¹Òü^Qà[±ç F˜êùÝ‘Rõl8º÷GZ ÎöêK—ÕnšäŸgVÀUî eLÁL` WEñu¥pKÀ1®£|tgø߶ûz“ŽË*—´Ma7ûPþüP#M1æÌCć<iæW­Ú:ÍcÞ´l\žm¢MvÂN uÆÆ¥åo´8úm’“²,üš‡ö›3þÂFÃi¾ÜÄìjƒ äÇdTZé˜ÈܧY1çFò›8@kù CÜLܨµ"üß,HÍà£b²×Ñ;ô�Çô¿-¨^FÎyâž۬ηl;KêÈ£ f9flõ&*ë®?…T‰ølãò¸ÈÊí‰$ÅCŒ™ÚŨ¶YEv÷ —}³tí0tòn~<u°Þ¥ìòžhW¸4{…FçI÷z‚ü*š“ uä–Z¤ÖÓfn_±iäÅŽ¾4AyY‰R¯¦bß{¬]¾é!ðïᵕzÇ:­‹Î‹ºË‡ƒ™ËûÔ.[d¥1|HØn”Ĩ<V§£µê† Àëú¾[vÓé6›nådÇqøD¢·ršír¯è±.·tœÖÞ à ¶ì®®Œr~îÄÓ ÔÒ7”x2w’ÿbˆ:p(Ñe)¢®ˆŠw¯N:‚Útò4%dÓ›cÃéϚ݊ºËã–]‘»T/——"ZŒk#ªFŠp(€üyÃ*!ÀX#DުؕÝb º1½ê›P=}¡jÉI3mºz?§ð‰‘àaÖ‘vk1ªúH A·¤sTž�}´N …jçô÷7ÔÌè’Òvª¢$` êÈ0‹… K{Á‘#_Íæ‹~K2¤MSïï;÷<߶Â*_Õf¸Á÷"³ÝÓ{u [p8 *8>¹@ÄsƒtÊ¿†2Jû£r_@£õ-]áÎ|ƒðrÆÌFeÆ!O£¼±„Ô …-/H‚w§ì<*oŸ"æ YVl..s‹tû_¤•9Aº~÷·aØ’KX:éE¹—ï#]m‡r´2/CU_J¡BÔwLj㻋ón ûð¡¤áa^¡WGhY¡÷˜|¾‡J–MNú(ßÓúä•Ö£ß¾’Ò]™ ùìƒ'ˆ‚€›Ó žê6ZP,Oð¸Ê>ßM÷U{w¢7Ø\>dèµ›ÁžCÁ • Ï’$!Š± Ñj {½è'+Ãà ¦’ê9Ϩhìäl:SO}sy¤Ö„šÛêûM`oœ:-2èD·Pv»ç—¼ 2u%¸ÀH Ì“E™WZ˘B6ÐyrFÅí¾Éô™ó_Ï(ÿÐê(ÀÔ[]Ÿ�Ъ¥W„<ô+æ a {¤›Ÿî ²V4£nS²¡â�óÛä]p€ÁÉÀt6ËjGÇQº÷Ô&&§‚Kc¹ ß/ÂÛqƒ¹¹ðô{â1 UÌ?!ÓæCèQ€ìz—ÓÆvN¡ÿÄì½M¿•yK ØΙõBߤ\ BéçŽÜÇgŒâv)±Ä¥ ™ÉG…»ßnÙ)J5‰‹¼MÎà+ªï4Ìm]OÅ‘Vh9xk‹8âÝÑ«¡zaØû /@]Ï‹ëŠÊï"Ê¿’ºŠo‡pyèOªB´01þÕxÒµw—5tì!Gô®Ä]¶êrúæè#ˆü€üá7ÊëþÒÁKëà!A1ph3 “SŸZ8›lJbÅù #ü3÷ñy(dþ KӮ砒òÇÿIÒÚ¶Ö(°]Ag-‡•~'œW!GÐÕy£bè¤ ƒ®L/«2ª¼ªUÆæ&øWŽ 4KOþ-NdïZ\٢έÀ=ÛU—Ei«ÄÒ}sb´®ôѧŽ¶è´+þkÑü?û¿å§ÄB 2´¥>N™‘ÙÇ ‡±‘l¬3[Ï”üêY¦ã“Î8q²Œíº·öµÒ$’Dx8ŸÂ{cÓ£úü–xí‘ÔlÔäÄ(<NšÐækÑ^W·“Q%øáÉäënpÙÉÍ &–GË}šÊ(?{5ÿ´ÐxâÑ$úǪqv7ÇÃn8ùõ—ûžºbî𬊗^ÅöF¨¡Ã¥0¥°Ù Ëcá£[¬º½‚`nr“ÐΣôÝ+…¸ÀÔ‰R̸;2½Ä4·Ìh•¶2о?çôí}�dšâ¬_±ÁÕímì6» ¾°´"ÛÞßr+ez£kÐ…r– âO¢|mæÁû]¿£²I*3Ö£”ø¾m¤Ss_ß«.–Wo:%ª£"Ç°E{ÆfxÁ6¦Æ¹½¯ŒÿÒX2³ÜŠŒ—?8bÇ1¸U»ód»|)Û úYñÜ>þÛŸnüufw�EÜÏÐùd™²¨kɹ©Þ}G㶵ᵥ…>¹@KšvkqÚÃx1\ðÊbB¯ñì×-’¦³™ÿä ;°ìùóUm, HÚPá9y·WHâªø.<5úx«Míw£Ø °¼fP3ˆ¾„A) [!·u9©Uæ™i“™sîêeETl–Ôv®|¦¢uø̆ Š¡nªÿâ½céànþ@åºS»êÑÔ@+â›*cª£´9+zž³ê6 ô^¼}u™&¹Ë¥ù€ì¹ÌØxÏ8FdSL>ô{r>@§<Á©$¶öbÙ,iÜŸTc%eYø~ßèCÝú Cž[‹W”­Ã@Þ[­¸as3ö-d+ÿ÷Öç%±ó[dò@ù¹vØ‘˜ #¼†T’î3œ|¶N†ë%ò�¥ÕÛ„ùeAï¿ýt€êžÚþh÷Ý\./¬5¸LEUƒ&±û”\›žM¶$Q9°†ŸDñÙ�–Š Ë9´›.ç)èG¥}`”+Óg Ã-LG‚Ä:’¢Ÿ˜MIFÎ­Í 5𸯺÷it¡B üÖ;hòï÷&ŒÉ”Ôsë¨lÖ®œ�¾b¤[ä+˜é¿oYî(ü颶5Ø¥ÃHèú¬‹3mÆ®ûЃP­¯AÑc gÝ ââ$D¶áÜÿÆ\Þãåüì)WüäQøHê.r$¯„¡TÈþû€.÷Ú²€ýí¤‹L¥…S¸W,F øO1×Ìμ¼7bÒ¡ãí ÖS¢{#Ùãë¿"YtCze¢¿¶h.AâÐï`}ìæ#»^‘FOÕ¥’Ü�“cÞõP;~7|ÛæCî¾ã>"»ZÚë‡Ð•Ä˜{ˆ¸ÂÇ©¢O«œ-0ÊÜâtïðP×{ð·±ÊJcˆÀáö\Rð᧎ ÁÿHïq;î ¤¦ÿ½3VQ{Ô, ÇÌËøØ{5 Ö³Z!oúfi&ùRîAô¶É£xÐ6wV8<š›¸šìpáçø½|lâ.Žg:@•ëÓ™ß7Ýt…çÀÐòíuX(„Ûêu:]®Ñ¡òlµÛ ª2—f�³&�áC%@•j'¥k\ò·5U7 b|«•X Κ»Üçö3K·Ý Šö®È9}Xƒž«¡ 2™³”Ѹ¯ ")M•#ìHtöåp˯™ë2›£bZZôñ§�;l»�€8ðo›@qe&1Æ$ÇÓéØzÔîcB\8&²�Ñ } ¤ Â9ˆÑJYҽɎÍíÖ�ÌeXuŒŽ6­Œ[1ÅôìX,Á`Ë¿Æä �M⣛ eò“òž”ª‹[ rXÇ”Ÿg¿6Ø‚»FÛ€RßÊ7ž…h1NÅé 1&ºÉ}·â@ UfNÇ»åvñØy©c»Î±ˆ8¢9™ŒÇncþ®ÇLKƒ–4ƒS:EæwäQÆšR½iœ³Hª¢úPøÊB†2ñ~¡ÕR|̈9¸®Ĥ‹‹¾xXV™Ûc”NîË*K×ß Yçð¡…ñ“æ`²° FÌ"Žô–çs  C{{Ðmê å«ß\9Á¾—¼‰­0rX:¡�ÙÎWðiç-áiñÁÚÞ; óÏÒ‰Þmæ.ľü)sã Nuèéð¼(Q[¯®"`Ä«{Ž\¹Ñò]þÀ4œv^1j5˜ðli‚ˆØLk…^ŸÇZ0þ¤E”m¶ËC¹ ·ë]åJßí8)d�:X?{_§^µp=ËËTDåÖ“õD> 5n=—$cÿž³Sä.­â‚èþ¢ˆÒ¿“;îkuÔ‘Ôðs)¸^«*Ȫ¹žƒÎàd˜µÚ² âìæÄ¡èxƨ´ Íû™«!ã¹<jN Ì‚œPè ŠeùCïö¦@}Ö¶µ™B­“Í æM“9Í©šwšÈ\èÑ[«%š•žý0g]&•åxA3çBñçSgÉ&>P" r@ì}-Çîb<®ÿÇzÃÿë¯ûô+_)‰çlMù EϪU”ôòp±­Õg GòyFxÀSø°®ÛRùÑÝÐ]+Û‹1Û‘¤ ùáÒÿhA”h“Q¾�ëiÑ#ýò¨ÐS]×VÞxþ¿A(‹½Ì ¦=äMÛ€Puêã>ŸÕ:â¥y{\¥ù¼Únë,Êý#^ *k#b¹®©‡9·D/: $…ö–ODjÂMtHâÚNø)­âÜ aÒÆ †HkZ­ÁCõ§ä-ζY9'•aˆ¥ÌJõœç6£WœÐ#Q&'/·5+5á8 ¥‹[ªŒßíf^7;—ÎÉ#Q,ÿ·˜þ™¶i†<±§ ž´¿¡•ë‡Š^)sJÇpEw–jz¨@@�‹±'8Of(Oc§\ø;SÜDEðñ´O ·1#h¯/ÆÌDÕ°.ãá H» ò­Ú«Ý46T]9<¼>ºÄwEÖw„Ñn=çhCë—½g}|ÿ¦öí½ª[©Ö´Ÿ’So‰)¿F‡Ý¿ûªëŽt—_Ã' StÚµ¦o‘·AW~ÆÀ|æ¶\W«Ø"°!‚ \ÈàeK—¬œ¶éœD¡ü·`‡'à‡$6¹Æ=¦¼W¥]âÝir‰CvÜE0ðbC·Y¶×}J2oÃðc°Ñèí¯`¤çuõ¼œÓ·*OÀ»–/š ñr©iz?i8Ð=Bcg.­þ’ÚmL&Õ=ˆ^‹ãÅ&:­8zº›â8¢î…ƒMÚâsjZÏdÚ¨œ>RÉ6Gc÷Žnù¹·ŽèÏLÍàŠÛ‘h²¥ …•QÑ¿•h²PñÙm¹×èBì;×Ãá2±HĬ…íÉ­’¨âI¢r£ç·cø«UO]Üíw@hOþGÁº\ÈîÚE…÷öLÓe´-€A¥a;ûáA­+ÕWДX–ô-¶ÞŽ/öüwÏßÏû#[5òñè Uð¶-¿ŽÞ>¾Ìe•MÜ6·š¡ß¤5©‘j-؇—Y’Ÿ:åDþš‰£Ô¯I’éºÊBu=©³Ö èÔñÿž%•" %{ˆ¾mûÉGâöJÕë@ÿT§6HÉÏ-¯DŸìÐ|D|Ø;(ÛÃJY<xèÃIÒ«N+ÕW¢œø›Ø†u\Ú¥HËöürï}³\öÝ’äoäײ K$‚8§â³ñýï)Ri4´ ÿãå“Ëdá´ýú>ûF—_Fº }Óy5°Œ¤;½ô2xªüß(M¸\Ý¿Γº¼Bãé»âРÎÁRrç¶a‘ÌWÔÆK³Q3F �Y’yß@ÖåpÆs.ßÞûáø·éqi¢²íˆþß_Ót]5xãÑ}®põ@QÏå>`Cw5ûÔ,Íca+N&¬òy ¯Ï»ê 3eap–œ Àî(Åíw^êÿ÷ÀˆïÌO‹6+¢¢õŠµ ­(çè¥2QB[¯×—YŒ/cÓH¸})Ö.mÒ %‹Ä‰ù4ÃÏ]®Ä«Ÿ¤N2o‚x1|™””¢@˜¦ÓWÜ�]‚VãôM‰œÏU–Š¨?SŽÔµFÕA¿¿Û'gÞæ_ßQ•EÌU; ‹ÜÏ«Šk•F%jç•Ý3ßÂ$žcªCóK°`@žÓv þ<°6ÃÿÚ+Ó6n~@@‘§ÿî5ãÒ­fp¬ház¦îÙ?…;8ZzÁ- {…7õIÄpXqeR½ìÔ¬™óŠÙŠ‚\î]äY… „t7¶WfrxQyàèQý°çòÜ–Ñ´¾†® 3çz1ú•Ó©~�¿ù±sã¡=$1øô’þÈ%!WÄÎ(I«…ñf?óœÊ‰Í&ìNÿaÄ´íú#ÚîO!Gq’äV-?c¨dÝm<™(eùøg`I½íÏaXKb÷B m»…ñÙØ„Þë¦'ƒn1€tYþó‚y^lž6÷4'@ÓŠqkˆß˜paœàÆûó-Õw—Ýô˜z/n&îG*@ó/¯C™¹ÃtböÛa|ÊÎaÛªx¡½5?þB<Akž¨Ú¾ŽrvR<XK¥=•ë]cÑ@òÏÙ~VÝ`ÆJ‡d» çæµ;°¨‚È‹hsäÇ6‰–è¢.HQæòR§/ãÀ-¡­Í€~»Êls2•ðëÝqÆ�ŸN»?Mo´n¨ú&ämJ öSô™®Rnéßw+¾Œî¥êE3çÄOPùCªºÃšèÍÎ-x߃=(‘»“Â>ôP•ê–³E¨ËEÊfÜWw}¤dÁ‡%tú»P)ÿr’DÙÕ>82ëNï/†7]¿ç¼)X~ ›ÃÉ=ÌÓ;¨ó01 ½Mx¥/´PW«Wo˜ „9XÑáê îôÕ˜­õø·ÁÌm­ ͬž6@ù¾2)Ái7\Y¡Òu<§s¨—Ž#çàlf`Å|Ø×é$Êú•‘´øºãÑïÛß9 æ•UþŠ©Ð]Q|™‚wóÑ™=}Ô=AæêBÿ'ZúÜjn-󦌾Ô(aÒ!¯0¶QyÐ+Jã‹‹™ÃÕPT¶—Wí>@wçR ””î ZRÌpqç‘Rd¶ Wz….N]PJ^n›“ÐŒBûíäú®/÷šm¨…”¥Ìó¥?•8æÐák¿ ·KN_K¶#òÆ~TS —•ÐÈe–ÊX.«½o|Ó;ˆó$¨YñLmy�»ÿæØÍ´…Ǭ°4©Úô,Êp©™±éJÊä;Íj¥…Ysæ]ËñŽ"…BÒš^•Vé kfN÷�£õÊÂ$ÇÃjð®že þàV¼J7*CEÐ1»MÕ~f]‹„Z�Ôí¤Íæ^h-:ÔЃ1Hl#* ½Ú«­WrÁ�Ÿé?¿|ã´º= —{ø‰v'U  ¬pd°³][JoGi½¸ƒðQ²$YøÙÚK%ÀZ1ûÕøNêr„ûêòÃû@.ˆù‡¾n`e#ò ^˹´J�K® =uì ÃÖ>Œ?é‘u¢EAñûÄ|fEÌÍ¥ÃZWÝÅ,ü¯dŽÂÚøÍÀ¯úª¢!—-|w·È4oQUqzzœöL `Yïeª26É’ÉïûG´Ï'­ˆ|îEWD*ÄEÛ…´_™‚ŽbÊnŒʬ—npöB˜Æ·FDDZŒ’éSͺÅøM}–[åRËëÌ?¯ª +‚ÉiË=XEŸÞ? G‡0ÂÑ‚pŒç‘v¬¨%u*yâ¯<$ÄÌTãÓQ‚¹2* ô)äa^Yzdv„¾ zøiz$¦¹°éÕ"Þ$§CãËu²¾¨íXý 9ñ-ˆÂé@,ÿ@*°UtÜ‘ÕÉù :(³¿Î}X—�øßÞÌ>Cë‡qB�¨7Å»Îu}ë[¿ÜßÒbçÊÿæÕÞïÊÁÖZH0—ï›P³…ß½l9pë…¬;ߧ½ùF¹®„ÆXÇ@¡­11]B%eÿ8ÔN«9l˜X ÉŠˆééÇîtÚ!ýÑ‚œ>ÚŽG5>}ýéÃg…ÁIJÓ媡àr NˆÚtþŽõ‘æÖºŒº®x'o ”܉v+ŸÒ©@Ì~[Ú5ÆîÖc¾€hæÑ-ÿ”Q9vÜR9L·ƒ jjÔ |ÆIùÕ«§ƒ”Â8dè+´�Qž®Þà¬ß;C¬ ÿ¾Å …wGJ‡U$ÀjÓ6œn¿–0éYsvIµË¸¡Õß]@«óèÆžDɶ·¯ËR«¶ÃÄ‚žDºnÕ!ÉP©]Ï¢¹:+ ¦NašýÔ/87ÐPF°¨BuÔÎZ©m8ì'GôÑüššB`ùç®›=n(ª›µ{9Z‚ö•gÐòdLòGg¯¥|ì\G=œTy‘¹¡ñ4-(CóFÓ ÚùQ)n:±? êÅðmê†Õ³ŸÁ�²d/é”®'{ÅÉBýgüðrz[7ãþ%ía¤™•µûE £žOýÉéá”]_Ö{¬M⎮ íðÂçØP5[SÉt•ñÆe݆Ùߊ€$¶ÛYáä=·/2�0/…”<Ä+Ëð¿;N "Ĺcý{E­=Õ']Ehϯça5^ÿûFÚÏn .ñÞ•lÚRæò‰„„Ù#`rFËu +¾9Cׇ/2¢dÓÆÍæ†Õƒ ÀTs«l‡õ4ÒÛ­U³ OûNx¼RþŒr3nΚË[=¬ö‚^µ 2:ŠHè d:8C•n¥Ízž<J}ôÓSí‚Ì&»™ðrë(íuòsw‡Qeq×Ñw’!]gt*ªq÷¡8x²/–C wÀíN‰»à;qwº?`Q˜TŠN8ŸK§˜1ѼÖU¾8þO ÊwÿÐ[Ǿe¥è¦—jÞ iö]/æzŒ×Ç?> ïøBôíÅîlt§æèÛ]Ú1`#^'df1‹úÓªŒÒãhræºýª½ÌÓ*s=­‚¥26èiõÊÉþ ’úm:K§�o¡ê˜ËáFãY3èÊ"Á"‡‹”à\ô·Ò­:CM®™ñß÷~ ‡Æp5ö"Èšºë0ñ‡tCáîtr"–¯ŒWS«²¨èKÒ–k´·ÛD•(ò®ÿWÓî¸T&éž&´€&ëàF©ˆ4L­c—½üeU3ó#Z›ÓPDå ­„T4yñ§˜!Nõ¤³Â@Žsýù«auˆ´Ç"f´W½Uû‰¼e+éÖ3î˜{‡jv?½ ú* û‰îª1ÖŠòE}“lï KöÔyâ¬[RMÍMã²¢‚GQX´’/#ɉ„´Å*kS´nþ2ªØû&=WØŒc!7[å?9B÷½\7Št*¥•Ó^ƒb=;­ Ýw¥b(w¿P7u7cw®{ô—û÷ñi]—ÅÙ\5úAipÀa?båÙbæG3O¦zß¾6O:` Y5š½°Ðrn°*,|*™W~z¨ÚKo8r·Œ~Ï ?P¾ÿ–÷’Ô¦çÇ÷zè¨P9­Ìb‚ÊŸŸ˜pÙŸ8$þîNùg‘ÛÑ!Ïjʨî7FkÜç®|иOéß&PYa¡t€-OTŠæSk€TÀëuÆø=æNÌuÌ%å™Gìo?D7K…G—)¥Šçjä)Í8¢Z"§Ê-/â®í¬½¹X}Ö¶cÅÍŽG»o¦îÆS ˾‡OÆi˜#`–˜/¢¼iͳ]ƵbNŠ^œ“Äñ<¶DVtø›z\@¿ÓÒ€'½¹…«>DÍÆé‚ÞZ"½æ�M\±áA^’¨Úz¼Zñ­t,”…!L1wÿ1Å[N®CR« W@xÜu_Ƙ€KXg¹¦*^/[Ýy†–ÓÝÍ(’ Yk±™!$óüK¾„Ÿº´pùßnøßúÌzØ~c¬‚rCÖáYÀtÀ°yø{öýï›#wS‘¼®7‚¨.“zåR¦u€‰hQ6®}ÚHDòH¼øãiÀ4Œø.”%W/$§’¬ùupxb�‹ À…ËGâ™u,¡`7­YðÊmÚ—¼>Š:Üä@ÑöH‘¬U ³"RûKW xí‹ŸE0`tmhÏž¦Œ[»f6ÌÄ�ž<ªúìëùM\F;wÓP[øT¿L8êó$^„¶gÖ˜pí®ï›-~uTµµ\tKÞ&¨y}ð@¸Ç«û÷wòâUž[} ”Òò*Ê·V?¡iå¼ðRÅ&לóû_9)xߥ]$CåE¶ÐARü‘ûN¯C¨Ê"7"vôVÛ¯‚ÊÊ/S÷£ƒ:î›b¥ó™;7wšÐhÕàêöÇïD*Ë,@`rÑ¥öÙ)>UvõœríŸ<\ØH±|ÏSÊsÃW…~ª˜ªäS>ûݷߤ#IKkæ£Âû®Ô{ü[Þ¹Oƒ,¾ ¯ó9ÝPÕ“Õ.Eã/=éS;ö̓Ynll•¾Á¥`±ö®x2ÌÅjõõÏïªÀ…(Ša"s ²pC˜Íˆ>s‘8ŽÝ~7u“Õ!{i—»º0VÝ#¾ÐÆ7ô KBb-º2ƒ®IüD#1©½‹ÕL0ÅÊ:={â²n¡}ÎƸճ Ãóa½˜éC—Ñt¤µÒëtërmN§77”C£w#Õúð§ÆŸ×ôx¤î?X¼7\†”±µ¢Q“¢€åN†N ~T`UE(Rl7 *»c`æ ¦^¥·~_h'‹Ê/?™¢O—øO”´*Ó^§Þ"¼ë7cóç¡;åK ™* €Â…¸)¤Qäkk’Æp£î2Þ'™oÏ‹WøÈB”^ì„Õ>`ÙÙx³>L†Ùà̽γe#9÷ÒÐ8«4Až<,‚ÙÎcÅŸ‘ðIn|ì !5Q:zYû2øØ-©èUC¦ uÎYTçø›;OoHl],û‹±ZŽÍn³§-ú…äbZ/ ž�] Î[jŸÀ=žXå¶\~Q"Á žJKkœyÐ.¥¿>˜.Êò0‰´‘ïA`æóî –LåÞeò±+Î7ĆX¿Ø«ëÔÛ9;\´E©ìóÌà˜íÉ)¼q³_vÙƒd´í«Eš}µÕh£Ÿ€‹ü܉@:ö¹\už8ôÇ |é^ÑñŸîÙei(öC,¢¸¿¨`¢"Ó¦ºYñRèìœà9Â569ªèÜ ]GÕûæ&g€Ô´†`¼}¡rŠ=z?ßõ×ÅyÔŽauÑúiþ#Uú,ía¹½îyêDïº<3½ó0 ÎaúV7ƒõ æŽòÅ+3ƒ)‡ŸdÐÔžŽš“0‘Êu¢ÛÙaò1¬¬¯H6C¨• ¦SQ´^©|Ñ‚ãÿI„Ûœ8ÌjåP£ßÓÓë4�ƒ˜a¹üCÛŠ±?÷¢ñï°Y]ã»çÇæöG‡j¸E7žÊÉí0(S°?wïH‹lÇHLf:…ŒÎ„JëC?™û54HZÛñ5×}Xýï–ä@Å×éÂáÅÐé^ôÔ¬ÃÀ_�mhƒ'ïÚC€çT3-®ãôK‚QnZYXEºôï+K >öh»|¶í!¾dþUªÀ!«ñÿ¬u’˜eqš× ¨Ã 0c¦ðibdžÍ›H”Nþ×Ñi'©:[¼‹:‰j”äµk¶ŠB.œàiðåžù…òÓF“ÇnŒ#:^`›…9ªSÇf3ÚQžµ€+q,/;¢¹T®³CÅ“Z@E‘œJ|ÛØîD‹¾U³FŽØ]1þÆsâþ¿ ˆS¥çÒYдeIáVa+`}t\GxÆÿtrÚ‡®qí/îúÖÙbFÆ+YY6kÎg÷þ÷ .ÁAKö7ª²qe ÕŒià÷wíŽ3¼jFg¶ÿY¸N¬Å9eûÀ=Ž—Í€]»½÷¸áïÉoŒ<&9QÈ0+˜Å+mÉ@mCUêj÷6n»Ý J@c·îXè ³2±‘2É£¾‡IïY™Å”ñÒ¹BŽx·áf¥—¨h/ýr»¹\)ñ»/Î/o^™È�±ð é“ŸþjG/bIŠ7x[ɛ޿¡8ù†måÂ!2ØÒ#B³ï.“þçò›RÚYvë]î“ØK_“ë*H^°–Û¡é5»y¦…糩LÌ!X×D Øüpxq[Ž§¼Ó¹Bf¶½{Õ^|ž[¸Æ6xÌIóÐs/räµB(gpV÷·S%m9YëüKª¿´-‚½Ì¹ú˜Êquë‡ÌÚj1. HÑÚ¤Ü&tªþì(ÜjÎtíð)p/© à8ƒ’ Ótñ¼KÑ®£ÅVãó84xáLk=eüÇ^o\ªqcáÞ{ÅèØM¯‰ ÖÆvwÂFb+åWP÷@\{"K[ ¯ fQÌÀ»àÇoj‚_¾b»Ø¹ÝÕ”d&Ç1hžÑkú·ö<lƺœÆóä g{jwýüC\$ùÜ?âØÓó^\Zoà6Übq‹÷çêk¸rÜþf?£„$õ(W»{Ê«£:]ŠÑ %,x9·á×òŒ+"iV>í›õ76è™isp=ÄÌ¥üÝÊ+€Ê ,5GW ü#m©¬Â@ž‹Ó¹[Bãئ“Ι(Hprælp&HÞ=�[å3êX)È¡b5ÿ‰2ÛDrô]èý^(Ég¸oŒW €£6!Y¨˜ð«Ç–ÿÊðØHⱫ=‹ÜÐJK`â×öÒ"R‰{ì'QÚ˜¥ÌûàÑ߀vÄ @óF¡¬ŒÀu‹¢ËÊËY’çŸÏ¼Em»)‹JÐÁÓmŒõ†Zƒk6îDE×Y¦'ݳ£¢¾ÍÉŽ‡´ˆ½šjLƒ�ƒd©9N.é!Â\cî‘¡�¹ù 8W®:e`.â*ʃ8e¢,‡¿?Œ““vzÞŠÿ“§;œÊ¤·Š‹w§Œ76g`ÍM—fÅ¡çtsÍKÓðg”dÛIy6 ­ábðüu�RPNò¶¥4ƒ ê‡ËÌ·xD÷ùªG&R`>Þ…ØÈ|{-±n_ï«EÅÞÇ¥cPv§<«¢usì\@UŸñÇÔ$iãSS2ùa&áG§°gHS/�¼aTáúxßyWõ™ý£?Ä¥›FòFÊ›s0ª‡û#W[B›^žèàx /l&…9X¥=S/¡Æe#U¶Cwe(8-|½2`çÐQ7ð[)Oèú�ñÛ8¾q²p`BšUИ†`'¼úœ–4Ç°`»Æ .êÿÉí¡¡RdÄ8Ûã¡ŠªñÄÈúæ2ˆ`žöžéÏô‡ƒ¸!ÏÚ6<°mô¼°FTñÂ…†wÅ®ÏËíD©˜«J³“«L.‚¯T' …'Qý5®2sTx$Ž§ÀæztçŒ0´svgÿ"Ÿþá˜éº£7+•ø>(Z¾ˆRJ†öÀ61geé0YQ2ä¹kÅ6}üüÏÎ!Kr*ât¼O¦ù--~÷é¼íE†Ä\΃øûÝ#öQAÉlí ­ôÈ˨”6™ ´syo0Ñ PÓþáÑVÉlœ‘#žÒIpÖ"Z:Y##,çü{ºãYÒÇÇÃÔ{ gd×Öô†ž0¿—³@hÜɘþ—ÂAýI‡+«g‚â }è"ÊåC=¨¥cG®ˆ^šcëÉÇM”H+þ³ 3Ûá\äÑj²é©Jî;•ny]'?p°„¢ŸFÛUå[Ý·…ÐƺGÏòBÿ`»¢3Íè¡ŒFßáÑ÷*µëíM%O×DT pP›¦·½¶œÙ•[ÄÁíá߇Ôì(–‡¦ÍH·ü †“h6Š¹ÎýJ$}ª~P$¨ÈfóqáéN^ D½‘÷´VŠíà= 1¹è÷°ËùœÇ½D…—‹Êp!bÓ6”ÿľ—Ž&è¡ù0„ª,͞ކߖöD›·Kjo¶Oƒ) ã¡“(ïµÖG¡)@}ð¾ãä²9P„æÆþ/Ûm32éÛÜ6 §êó32Òk{ž´rÙ9þ·;›ƒ°òc:¨ÿlçC•GGçôZujU6B‘*ü[qh X¯”+ª‡É`Ëuجfêà&nè�0\tE„ÖÌu@UC÷{sèð8ºñˆ}sµ—lp<«crvÿD·Ûᗈ̔-œ^5ÿL²4ôCÄ> ÍñÊs)ž{3ð£7bþÞ‘¹ˆË,V¨xPd;~º;ü~vGLcUlmV–Û†MaÜùN)éO<q?”¹{G©Ó|9ú‰˜“vyã©ÜV“Š–ó"½oÖÇö)˜x/dÀw»¥/Qt]\ë‘KªÃõ벶’µÁA–¿÷Ö"©N°æxèÙñ$\<‘Ëi–;ÎzÕõ ¥Ì‰âºbÍ v|9¿ã߇”Ç%IÔ}ÁÞç&Uƒ6㙵ÞÜÇzíÅbÆDDQD§Uæ•{vàÆG ½p"Öih^$Ò’¦Ì cÑØIà:Ý5Γ§hÜ&Í–—‡ž"æ[Û\o¥ÿü­õªkCï£RLc6Fh蘂*E@;Ó*`„¸ØÛž<Ká;þºjWx­Õ¶Žªîf2Ë’�`p¼nÝë ÝááÄÕª¸ªqk¤°’@˜:�„˜¬Ï®ÌÅ´äÜîè®ú4rÚ1AQˆôn}K¸œ9‡-èF•Q½õZqš«ƒö˜/ôÝ2I:­%øâUT{}ØÌ‚Iäþ¢È©q{—�m\ßÜ÷žÿdòjÉî�s)s?n ª¢`,S`jd¡ÿý³ZóÞì ²ï YKÑŽ >4íYÞÉᦿ•ÊLgh™ }VoLœ[ô zöœŽ=¥Á'‹ÌÚíÆìÀAõ±—.ã|å0¨‘&|~iÌ8Á9q;‚ä­½†Dí»{“z¸HI1šñåÁsl?Dþ«§À2–ظÌCp¦àÄùyé}4IMê"„'€¢ töàäºåÐ*£%8í £tKýF;ᩆ‚B:‚µÄ æ{ƒ6YSMKèXê„;¦+ÒÙÜK©M  T…¡{à6h¾WfÚ°"õvã²Q”t¯¥ ñ&zÃOØ«?Y½b‹lZ&UÄìu#·iÃÇ�Ÿâ ´^&›¾*Jí‹bý•¼ög Õx`ôU–Qs‡ç Úù¢ªŠùTºÁÔrݸèšc"´­onÓ›vw½±õ/A)l”ê[?Êe@Å–ûz^T¬—”Ÿ_ÆkDZ9^U™ÕCE4lCŠ‹ë{W?i¬áNó 0ÈWXi9¸Ñ=öµ¬çVó•´ßÒO%Z¦N™ýŸGÀÆga1¸«ÆòÃßåd̹èMyi Aßý„5ÇVŠ ÷ž¬lšF qA*ñ*¹jÙ¨BL3×`®4ÍÃŽç›s•[ö0.°mNôÁì¼'w¶ç˜KbIò(»ùcsÊ™¾Qæʆí1±ÎXYh´8RKŽpÝέTÅÐü\?–)ê"wæÀïÆT@$ÖqÇO¬¹ðš1°ŸY $|uôš·Ÿ†!ÄóH§™íÞðǺ$/„€©{û~ª–Ws˜Ðõ¯NÂç×}·bãyÁÆ rB€@3A[©•ÛÛ®¿µS[5N äÁ(/gçZÁX¿¤Õç‡sÓéªüÔ/5Úl¼D»†Þø¢ŠÊ3o•À4… Ö².£×qË +›ËÀùŠ>«U¯ÖT{}!bütyçxèLì’[‡|ôYíÚ“x Šƒm\„ä7d˘08;Ñg¹ó“2ßXG°»À±OʨX5îD•žë|ëú9`r^šUçªMsù\ 1^d¹G÷s¼oå‘V1,^9þ@!@ÖD‘ÿ_à½ÚðI[6 „åç§WTIÐöÝ�ŸâÖ]°hytõ`a§é¤Ÿ±øO±nTyí³DÇ=®gê?qàƒ8¢4êÏ0xó™6|<Ï'ñbñF$wzÒª*mç 1÷Ü›¦ØŸÊ|(Àþ!Èuõ–NU¸ Žò.ü‡[M¸…/8Úœá!>]Œß Á19Cµi+ј?Óöpz<3È|ý(‚ËDÓçÖ¤ÛûˆÎÍê(¯vºaþê"w–XÊ,+ûÔ´Û·f¾¾j6ðE–„¡íTñÓïpˆ,±6äŽL:;�@ƒ8dtW<××wê|žº½?-®{U˜àαÂíˆ(«ìŽ¢$DjÔ­vÈ¡²6‹­ß•¨Ù¢]ˆÞÑbÝk/¤Öé£m™Ò½™ùØÑùÈ„(*;LŽO‡~-o™û—†þÒi#Í@¬œÍ®÷yjÿWÙ~Ü! Bµï4ø±¸ñu}À­¯l\óší,z€U㌠Ÿ4GÉÍæùá߬j5ß¡×ÿo@DÍ-e—m2c°¼£Èðo i„}«¤ç[É#¡ú0R˜É›Ñ(»/FE°æ±› ÄOFðß «;‹ñÞ#xÁ5æ©A<] &m‚P»‰Ë_7Ýf&‹[¯÷}J™Î¸2“ÜÓvlØ=ÐëMž±‘¶Íe6%À¸ Eêc‡ë|F¡€ÀÝH'Eûæ5´ó6=þ; vb%Ÿ0 :C õke´N–�Tø`Õ@ãÒ`Á½Çô>¬Méóô?àV\B¹ížBDÜœ/OKÜ9o8îd’[»’"¡òs£®{ÿRêÆSÈŠõ0è`«ÍƸ–¶]òòŒpqrp?òã¹³pV`û,‰êëÉ€Ãø‹ù—g4ö­¬ýX·ªŽ.«4Š× 3GÈÍoèom©¢e‘.×­D b逽ü˜ù°ÓÍ åifæï”æÑ¢™B«TZÀ®¢9�¨Ù¿¨/æjoa?mvKuØk†ÍüñGññô뿼[ìY63AMØhUkmÒhÇtÛqŒrÝõ‚3f‹­öïµø+ƒI„ÎXq'ÁË»TÕÃ#0^s15|ôÿTÍÕ™á±eÏRÓr Ÿ;pþ™×Å!¦SC “Çø§ÌàÎ8}e ªºóÜ@&p³$ÎÿÊ€*@}ÇêZr:ÉÖ†zÌÏÛˆÊÈh}œæ‡žtfÌœ8©ê ü|2²Þ[éÅϦ†Oe‹ùgÍ°Ñ㨕à–ÇÍúÜw[½ž Ó‰¹mª¨žþšÔ�0œ°j¢ÝÁøÑÖ½>³]™ 9Nh±ˆÒóÊÐ ú=“L9,y}[[V ÒfÙ‘*ÊZþ– ö$xì”×l˜)¬QÀå¢UÉRKc• ½$@–®UhÿXáÑÕƒ„XU’ãÒMüO ½ó°2§L(ØyBÖ‡ãÀ{.¼Ü .7†bŠ dÝh¡—ŠDgx?å@>éˆK£%Æœ³íX3·Í´±Ž š.PÀIh€~´_®ÝOM[ÊŠ¢ýé³ÙÏЄ¢dkÜnƒ[q eäØy °_¤@!>×À‘w½ñ½a$OÅ`n ¯õDŠ ¿9]|6tv4r3=Žê§qk,o¨68œ‚³Ò  ?’OKƒ½gB›Gåéìðyí19ÿh`•cZB uTÄÛÒMÝ‹‚JÊ›Fn'³ÿ#ß*·³ï˜è¼è¾ÂªéiVB—¨öY°žå$žX¶§–3HÉÈdâkHV)? ÍÉŠÛaPÄ3GW÷ÍtëfÀ‰wßCh8+G¥¡±`úBR &¥F]#fõÆv 0ž\5¾ä©Ì®^\�›Ä^À¿mýý…Ž[@rÞ5ɪ³(°Ì´ˆâ ¥‰Ãýìgä†NÚ=ÅÛ:©—¢S»p6h˜µQ%îóŽ“2ï ~MýÀœ×ºåû2ö¸)¢äô()Bœ½�.±ˆnÊÃû¢/ä¬*k–ÁØeʧ“Ïc�kl¹í뱬£Bõ#hWAh¦üÃ!™ô³g\Œ%¼ãÇ UUzÅ'´á¦O“*]šijv.Ò9é§õîô]ƒnøù©ÿ6k÷Ó€‚Ê÷t‚6L”>ºšMM½€á"sЖ)sÜ¿‡<Oy‘hoåþâ‡n‹‡ó%ŠímºSű�PFy4Gœ.»ÂÚÜBúÖ™˜˜‚ÏȬÍœqdñ3?dça[USÊPW•¿éÕ,)ܧõSð®D6ŠG²7øÇŸ¨¶7Ÿ™Ê€û¿7AÉ9Ö´t·lÜð€f–ÍðIy4)½ßÆ8˜ ÝWýb{_KÑZC+._gðªÛÔµ[YLxaR¨Â…O ?G’ŸžK—°`Ñ šÀÿ¯\ÐÇà¸ìä¨(ÄßÆË8.rˬ£=;ÕjŸè´c³:ª Æõß(i6ªRP¡8ŒÖäßšY¨ ‘Áät/é#|ú›X=´»Íf7¼,*ù’Ф5 GÌ•I»¯HÓ)®Ur}ž;|ËþÜ°Í/… ÕHV Ytyéôˆûƈ®ð¼vf½Ͼ·Æ﮼ÄAÆ<–¿4Ý 'KÉU"~=™ŽòŠIªê 4þ_X•âËŠi)wÊçÈ“4ð¶<á^§QÒëd î+ý:C99¯ÂAÃÚ]Þë™ÎllˆZ¥ðJŠ¨Üúz9O-÷öØ„(·ô•¥o49’ò"y=P¡•®=b¦؉¶2øDt>,—Î%E,žõûþ`üŸ4ÜA¡®Nìå]2èKz¶H–<o7S 0Ãqæ‹-¾W†ôÏY­fnAœ4T#CºƒÓGâ©ï C8MGÒÑ^…«{3ö„ § X€øîÍÊPº=lžgÞ® –…‡€ZGË5&šhCFŸj²·ëÛ±S¥JÀÃW»õúîÕ”І¬-ùܺ#’‘M76 ÿï[òö?Õ0)A0èߟ²¹ß6hË}”Q¼ZÛY"8Ü:ú55 ) ;[\ð"‹²Ê$€ÂÛÍ"H @Ž¢4Í$øü¯PÁæ¶à¦úétš)£Ð4¼xRóñ?]ô¤8xT. ¥Ü•TmKÝâ¤È¾ŒêþeWÝÞ˜/rÇææuýÒØ:ûR¬Ý~ÑBtic"·#Õ´kEÏa·n¾¾C S›Ìµª{Jw+V‰]Ì@‡ Š­Âw—Ù. Rÿ±‹"Ë—yÅ¢yCwýtvïIX±l“`äðÆ|â]_”*,܆"5˜ÍùÃ×R.x8ÒÿLzU¯° ²,T)Ñ=2ºIë—ºdzîYž~8<…ûÌÃfZªW¸ûX÷jß™Çü¶;ý¦÷˜–e>“ÿX ´¸oÉUÖµ–D»½v/•éÏ>î³ßÛê.vÕ©8`wúwórFìV[Üm°S;G/eŽ¹ ïÆ*ÀzK.îb zÏÙNí(QÍdŒ†C�Æéã¶Ìoƒ[cD&Ų‰›þbŽòô¢Nº|î´ŽÒAÀ§3W3ÞOç\ïÐ+ w_ø*êJ#¹û-· MfQ²ŽZZ?±·sª�æëÇChÿÞƒ=ÅJÚ÷´c«ÎÎ×0\;°£rÔ-—]2Áœ6Øsú”—¿Ò6Ði]Ee¯*ŽJ*¼D¸¹PL(� ÖEï´U%§:¹®Êeì>vƒ¾ Ö„œªBF°ê)?[²8æyj%?„«B3o~ž:J’œÁ¯Ø-e"“` ©ªí)ôeš¶åq¿L¤šé£Ù[%ë»_|'v ?Â[ M:}3º„K "ÇXÄ°Î,d YïË]:â,· ¯Ï úë£sPö¾âÒAdRÆíD Y°^а9ÍymP6ÈþÔ kTvüÎÍja$µb¤µp‹Võ0€·3æIrŒ/˜aØYt'žÒ}­»}͸X|¯üÂAg{.U³fµh?£xµF n'©«SÝø¾1N ÞýKÿ—‘}’;=SGOEOA*[oÜù ™ÐzׇyÂQ ¤(‚W›Ïå M1&ÑâÐ'Q9]-ÆRÔýn ÄhR„Öé^ž¨®äÖ3 Šøw›’êÏN•fÓÐÙs_zßV‘»_EÛ ´=Þð\‚³4Ç(PÂ{ý´}±Í]¥¼†²1sc—ÁÛkÐÝß*,Ñèx>Á\Ö¶_™Ã$Æ5^Ä’§.±RIfŒšÝQ04|cuTÝjŸ Ù­Í» :”ö×îÔlý7nIRÌßڱ¶c]Í% J'uò -,áTDŒnF­À«ƒâ¸TÈ‘>Š¢O¥¹„’ÚËí{µà§<Î<¿Q¡™>�’ë=p‹[•ƒNq NWœænnºoøÌ +õ9ñÈ;Ó)vxÕ *êû°¦(éÕ)Õé0Ff˜ØWÙÙÝjy>"Åxˆ'ÊÂȃ™öET¿o=™2ž§î úz|¾¸¯òLù<®”©W:Ó. Oëæh8^Œè´ç9èÔó�¸­º5=ºÌ—HÁYXÒ+p1š2t>ÃÕ}볌ÙâlÔª(>]-•.„á‹æˆ/§B$|“Ĥø캹Ü×´9•˜ÇN_'§ C`-A$AÜAÈ)6¶œ9i,N=ît½2gÆrËø íwýÙýí&ÿú@×ÄK¨9ø¡0œëw¯\ã,Ž(½):³óO$瘒ì4·ŠëÌÙªé¼i LZÂEp0ý‰©•mtNò¨¥ó8k}T±SqW©5‚£â‹©oj� 1b÷õ�FðqíþJÉXò)X\ܨÍ;+²4!ÇM)Ç)“PyôeÌBd'WŸ×bpâ’Úi;ŽwÞÓv R껄IŸ©orh_ù:—G=ÇfüÓü\L‹£wŒq|QšÕ+Ä»Z€¢Nµî5zQȘ+ßZŠ’ñ5ÝrÂm]­·fCoú¿ëÿ˜±"ãü½Ùbœ¤áMyÖu)^±ÇÊp¡ð8 ÞZ_ç­å,³<à„ƒ_󥽄S·?ö²w>æ:Š‘Ü¡ãH—¯Š<Y<C’d2UözÜ—À¸í ¸ÍcÝgRAp£tÂÏp¹È½% 'µ8'¦× -¨$stL*(ÌóÝŽÝî`^PÁs©½¾ö}¼Ûj!36q ɘúE´8ú9(°XËt‡¸•!ÆÝ‘®îIX^§C(<˜=ý)¢bý×ÓsÜÔr ‡è æÃþâ6BThKxü„2¨)…`À^çDEß`¤ þ¡�Ofúmθ·ð " ðÑ›ð€·Ç–½ßº÷Ú¡yî&sTîü]JóØ-ñüwž|,Ò¶¿ŸËY@ê 3¢¤ÕŒx{hÛÉ'fN•þ¡5ò×2żÀ÷ê‘yVðD­x©ƒA³† ºáv3Ñߎ‡Ý€[;ò=A[¦¼®mVƹÕ>_@,J?7††"—ÖíÜƼºâsÖtáæ0æQåGAاëq×ápãGþó[V cs‡• ÕÔ7µÆÖï[*uø–Dð>[÷¸ßð>AÒô±ˆ( Á}¥««;tä\á$P=FØ0/î9Ù®JrƒK¥ð·9³Å$(è¶o@YV~÷(m'¬íç4OmËÕαks†{åÎ ?“gb¨C…÷‘‡wìørO"Šÿ“,‚ì’»ŒUç‹OýUð Wðé\§õéìÎ?²$V"_ŸFå¨3Ġd~oŸ˜–3‰"Ô䥜yb f÷Gý{¥ ÷þ‚GZ@¤1¥|ÑS;¬)£Cªßû|ÒÇrýöC“C`Fžº§RIX¤º¨\\Mf<Ê'(O;Å—ïUIj3/c�ôÔCwó3PShËÚ ’ÒpøPp’\ÆD%ÈNýôë8¨pJ#€âå’Ù¤A¼Ê]Ëb8«f¬¸ @5@þwõKj<Í8°î»<Zx#"N!wl\MÕÍýàŸ…+úbZ³?ãñ]¨…KL–˜´§O6uØ´åÃaËÚK“hº™Yš[¡Ihi\ ö´U¯õ”ªÚÑÉØOÝòà-Ÿ¸aÛ£î-è#ÿ›ÕbX •SÓ>·°�h]l€PåxÐakÏÓYñ[<;.°—‡ Ž_Ó^<¹Sñ¹WgüŸ,ÎoÄUŽÀ·V¹ÌŠUŒ„‘æ’ø‚5¬,xXâ ¤ÿÒNât çÉÁ›©Í‹¡ÑòXîcÐeßáñšžååˆw\‡UG§«—™0^î‹Q£«…£ú~1$*¤4ÐÄ»“GÝ=á©ÒÓ QqØ„\ünÍ^G°Õ´Áý ›·¸šÙ6Çl}RDÕ{c;§·wú„Çíä/G—œ™Ëgãt1cûs;·Ž’`‹óPÆÔº;liÖ€ù—~nµ˜ª2ˆªFÉ S:uØ æMe’B±sƒ‚M9w¯(«ùËÜMmÛ´;íT•ëÖ9!{n ½ ¿˜Î\ΊÈÄ|ðÚ—‹´Xá˜Ý1n¢,o­ÈÏû6VfŽOöÔÜ©.[4ŠÚä¡#¯•¿'´W‚Ä[žW+—±±‡Ÿ àê•;åzIÊ¡Yº 2\ðeüAP¸\Wz¤–])UÍÿ¥~§(u†VLÊG×hKi“Þ×Û}—[H%ÆÂÙÞMÿM¬’x`®i/nCwŒž¨zþ¾úð¾KÞC.¨혮çv/ýï®pnÙ4¡å{Óþ-rkj xÁ9òÆÊÓ¬(3ê›)̉·:¶FSp#áA#tð­ÉÃ_²ÙNe‡°¡½P0Ÿ¼!ԧѲ³THWÞ,9Óbå·G]”ç.EiaôÝÆ-šk3Á㥰¸ÐbÝ5Å㈲¹‰Ð¬n„IŽ«Éo`­q¨Ldp‚‡e¼ú4Y–JÈé+¦fµ”\¦²B’[©íQŽ5=¼RS÷Ü~C ('èü7­æU|†˜,#ÂW‚Ûd'ÁÛOª™dúB¤~Ëó§9$þÁ»õ™º¯Qù­7wô=ʨh¼¿HÞ8·eoÃK ä_:é˜È?}›,Ë-*¨s-ì#s@Ð$³@æìJqnϯPª¼±dì \s ºÔò£rÍ:T¬·.“B5$Û÷"¼ôl(6@éÔÄög«vÕi9ûO°0Q ¯Ÿüh×¹íR‚ÌŸ¼ßÅó¾¹`r)ºHSIè`§´Êoœ·GzÃV« .p¦ïùÀÜÒƒßgââÀºã‘ú¶ÛwPâÜe®š%à új"ËUn÷MŽNWòIç ‡Ì@°œÊb*$PǵY• 3<_7¤zÉÌ·¾Ù;Ë¥GN©OÜSÓ|VDÆÑA{t%ÜD«§Å2,U>r9!ö__>òüf܉»y°_ÌÅæ3ôó»z‘WÜX<¼^2Ô—½g²Ü xSÊ·éá ¯¼ôkyˆŒB˜»–C³ë'µÐ¢¢u¥/:sõlൈ¦}Lu£žÌE€pfl¼dIã?´o={Oô3áGLa.îT„ʳ²@LTH+ó{¨+½j+­rE­º÷ ~w2\a:Á*¶ï¨ükˆ/M݉ŽPÔôYT­þ×Ɇɲ /Üjtû/Þôm#xqwu»àÊ$·qÚù ú.¾3„PØöçÎûù¶25•÷ä‹"9²%¡mÎÒ¶§ìy{Ôn\9”t /3AD_ž@SêÜÊ¢CBßà݇DpÏGIç7(i˜WÅ<Û±eÌÓƒ¼¹ª­­Zé[˜êx%› ,XðÞUWKÜ¿çã–�ÏŒëŒx¶¬®hUx™û˜Òi h»|ÀrT+àËuì´¼ ÝzCwJç†a8-Ë(Ymì‹bɯ!ù3ÓUFL]0 {nÜ虵 M¤¬ŸªàË5(gí•Ø˜æðÔgˆÖÈ—¯S¿#ûų.#?G«>ø 4½$ñËèÔ âîÕ܇¬è ɢܧ)«éتëª;ˆŒ¼Ñ¨&e¶Ä¾9õh4°Îj—iŽÞ)ªÀ4q°‚”J-Mõ –oÙ:ùs\A‘Y_ á'båÛ‹—®>ùT(FÊÒÍiÌÄÙeRå迦kÃåd#´=%„U£Ò)ëë÷ËCë‘4 ‚Ý(Ó‹¬¬ª½âiZDåð([,ô“÷–FžÏ(G…œÞý‚7p7¬žýl(È=rvOý*¢rÔ]ç”åÔã’ö+ÕØÕE­Øá¨5ÍÜô~_ùÌ£z/ÓÀíÇæ¼>C–•y=}ôˆ”A»’§ 3îõ§137B‡ªˆl®ÙÑqr&²\fkCéñÏ¿°¥”Tit‰OQÖªZz\ÓÙž¤Þ¹ üñài7NæÍyâäòfä å¡"xÕÔlkØS”¦'éj/hÅwZÅÀÄk?0ÌÔƒó—b~¦çŽ³éÓ(Ùnƒ'·¥š½ªG“’Ãw8çi ]>\ÓæAÃaDÄ?cs¦ðY¯Ö––Ô|ˆÒŠlF¢±KÔ»”ÓëfÌlu¹¥ SXªÉµ|Œë‚¢nX¯M­ïi3Ÿ‰BÄhRè°©˜�&ŒÂ9‹ÃŸ+Ò$O‚V>)¥–iTŸ/OÀ#‰ž¶vP9¦<hÿS^éý*„s¶(£ë¡€¥÷É8š¹ðï�Öö4z¾ÝØ z]ö™ Q’[RÌ‚èŸôÝHf()óMÖDêã4 ZŒu9RFX~ê$•S·ß)=ú?¸:rÚ,>ý8@¦*`’ì1m“'<×¼0%•–šdTP*åУ]f†ƒákoÿ#×ƃVÊõ@k§½Šd ^Ðß®ÇðɺîaLÉŒ�ÕöPd K÷` â»;ó¸±ðàOäg<Ì[ yTzª84泤òÇñpr Zh‡«ðÜêÀ}L³¨ö|é$vÞ2=Ý-@ª…¸€±ñÀScÕkÍ3KlaRŸGéêb´|�×ßqzÿе>ŠY‰ Énº½õû»q;Ò‡ãNšxé9&×+Œ®* D7& {èÏÍ+ÄQ2`Ägÿí‹x"VºÃúqª¢ä¤ ÜU& #ïêÃ#Jã…C`~  ]¡%:ÄãÚ'ò_—8ª®uEk{ж½¶YÕc„r UÈøÀn®õ`bèöߊ%^(^9>yUíÖHP­_<ñ—ºò²O^y€†¾ÓeM»ìÔn©¹¨�á[Q„ç£Í_<÷ròîµN/1Ýø¨¢ñ@Å�U±+5O÷8˜–¾/`­oQÑÓ^VIî&LiÁÑWZDùÕSý‘š7×þ0z^+ø}ô©Léû/“%!H³ºÇiÄã÷Éoëæò±sªe`UrÕõˆÿUf3ëÝ4Ú©Jñ6Gé¢ðÊÔü!wljÁ·¯!Xx¥h§½Ç¢j d¾ë¡Ê¾Ìp÷ ¿ÒU‹Ít1—jÊX>u#Ã1‹õÏ‘›¿½(ÍÍ_Âô¥ÌçòSãàqp÷”´hg¹·]QúγA!½HŠé/dqÈb¸ºjh¥ÇŸÚAEÜìö€ZˆqzÀþo0Ř€ò¼½ÂŸr;©ð^­|ÐÂ>Q²~îäÜÊ‘ÓUæèí8s¢ÿÍÄ'¹C+¶ „—­î-4é´À !ë2Ê—EÂŒŒ·i ƒÓÐyÝ•6±NŠ)'ö5-Þ­~h‰¯Ú{Õ ´¼ÿòÝðƧ•Ѫ[xpî’ê&ÐvÖY¡ b«¤¯ªsm8ü¥’²Qÿ+5Áu2·7?~cŠ4ѧNkc šqÒlÙ¿Ãrzó�c& êhÑÄ­Úd!U=|]iAÿ ^Ç#«¼E"Âã=Jð™Ô ow»°˜CH>£ðµrÜ+ôѧÍäÙ¸i|uoei÷î EšÏ²©:Zþ©©6ý ûÈ(õc³Z!—ô¿<âÌ8¹(×Ø$ûøoÖBë>öYÝw´ú3ÿ'×»}†ïA²Òë ~tòGÕ6Iª0 Q B¿É—B‹Šå€ W‘ÔŸ…~ų›ö豃oîÚ$@ç~¥øûÍÙµÖþÝb=S&\+½£¤®ZÍ_©ƒv¬dàÕý@óGY¸êº#'sˆ«ÿ¿ÿgzë¯Ã0ûÁqL¦Ó %¶Êv’ƒõ f~“’ìÙuÅ"°Ê ¾ãœÞÿFÒl„-™¡y—0x¡»"j‹E”~~‹i|Ù5à£î†|¨q,Z S€È»Ë»vk•Y«Z:Sw›œ¾É¤Çü~0~Ö¯ät½~–÷Š‹xa$k UÓç?*y½,E¨¯;M2øp¸ W]FcëFÅ¥öe]Óûoƒ=Š@OµÙÇ÷9]{eÕÄnMeìéÛÌH2LÙpm™ºó yÚ¤RñÈfqÔ:k锺} i:Ûàt{™pŸS¹ºp1…‡ˆtS6—bßt\C] Aù2`@ðÝw4ü8ð qhóÉÎÆbšŒpp~´`®ž€,çYenÈ=w-ñÙ6©c /Y°Tb”z–9]gr¬X#×Ià·qû˜£á¦ó¶ÜÎÜFPí©ó ÎUé6:«êÌ÷ø¦¬¸åk‰ýªRH!WF;æ{ú*¾eü¡DpÑjãªJÌrËp8ò¢G—Ç›7çFœUA¼–AÃG8ÞÀ«b° L¨]BëD9xÓ e`µÞ*i$zP£Aqìá=ª‚2­U͇¹½ŽÅ êO3>V‡Hƒ:ŒØ ŽÛ"Æ^a“¶­äЄŠsçq€¨4 íOQ5Eu«Œvú¬£¼U¤÷ÚI!NÁÐI×NC§qÓ´Ð.÷.] Ö¥>Bÿ,ÿÔvyÉúÕ‡/œ7ú0D5ˆKì:y‡ûG`¨fØMÕÂ朕lâà'k´š†C¿Ru-í,œÐ¢…O8½Û#íÆbŽ±Š¦3 ‡ÕàFû‚§Š%ð3ù[iK~+üS,,ëf[`×½ÜbM7ºQ sG3a㉃€^ôõ¦:«ªà¼Ã†"¨ÎÊ­ÞòŒ48,ÜÞ(Âð»ú¬ŒCÇ£ÿ“:ªW+«D æ©Ä숣B<§DäÅÂŽ¨…%SDéøø´ËÃ×Oá|ôG.´Å» ÞÒ­ÌbT¸bÛÎ}#ËhëÅzßX³Bn(àèÊ9ž{MªßôØ*³±,×rMÛ~ñnGËÃÞŒ¾ŸihÅÆ"ˆ um°Að3}’ª¥päp°f Û¬ùu‚àr :@¦Í,‹UÙ–-\1¶ŠiËZ†I­ü|`:à›w½Ó|ø‰d•Ã_ÙJQ˜¥ÐÅÒbâ”±ñLØÄÏ•"ãwè¨,]X ëª7¼Jº9S¿;ºÑ0U¦õÆ3/é¤ý¤Ÿh³jQ¹˜ÛwU´èW!¸ÐíÿpÀì]{£EjÔƒ™zà?rŽ0Í¥ Û¾)¹à­n‰f¯ò’r&ø¼È#zÿºm¬@ÜI*…éÿÂW(L‹•pNV¢—i  Ê3aþqzô§¾%æÎ $€ íöjVFï)έ¤í›nhÎoë5ÝïÝ°;lýjs�yå_ç´’˜Ñ‰MÁ÷ôÂ0kþ¹©ëŸ«KàÃÕƒ“/7–$ÜHŸNUT~væ!P†*”L­;vƒF…Ú…â$P“¾ÿ;£ SJš@YßQµ賆‰÷q÷%¾ìò‡WîšùW4¾ßÄGØde8*€rä–e7˜ð¶–øãçü}™Ä(À:âËHØGã4 8®�’$TÈÌ3gÖjDûÙ\z7âà§-à2nu£Oºãc8éì]sêF³rÁ²:_¿eûþ*}l Û¯:ävFL»àðE‰YAÑ"s>zŒùÐ1ƒ‚¹SUÏt›ã²ƒ¤‹ÁÙõ<þy­€Üaá:¶ŠüÔ0›ÅQ  R…¾[IËÜ_œ mbaUú[¬osšRö¶HçFÅ<ðêÃËŠÇ“µ½þ“!>$lˆ…}7�~2þ¥¢†õ°|.w|“¢Q@ëW_ðv( ò7ÝDeæH;®¹6«Î\—ëäþ¥*õØó²=„Ü,“„c‚ŸD#üŸÔõÔ[<BH|F[5HÖBòbJÓÖ:Ÿ‡˜ +{Û§YY™c=Ì.Q;UÜMÑ&9»À€#:;ž¢”ãpšÞJ£­b'ѬÓà›±}Ì á “´bõ× ŸP³½[µ†IØ™/¸¥%u¨Fµ[:Eâ¾­Žñ‚1˜UÀ²é0§n”0lJfÅ›’õá+ÌþššZ¼·LW ·e«„Çc7,ûæM9œÞV‡~Ó¬Ö ßÙë°ov·kÑØî8u®ð'7xӞŒ†;›ç~E~‚\9Ô"îâäÚ)vЭ îá¯è—¦¦æÓå$S/¸ƒÖLs9ÍhóŠo|ÚÝ)K>•¼-æÆ1Y<܉²&X³%AAÝ{Ñè~||9[>,Ý ‘Î?lýæeéRN5ƒƒ†ëd<{õï[†f–°!1¾XtzžrúÞ6GÌ·aþ‡M:d`ÒÁ«4ó‰ï!³±wGÉà>  ‰×Êàaàu‚çÕ¯ùIZçFržýp=™¦9•Cs Î’ößo‘Ø€`X|¹-oôÇíuõv˜Zö~êVoô'€{<ÐYÓqzEæÒY5böDÂóKÛJ,ÕÃ=\31§ ЛH‹‡Øy€Ô3ÂB¨6…¯¼E‰Ñ‚e/N„ŽWöá2¢að HC½‹RÇšN9­ø)àpW+íƒ|¸úZ}ãÿèù="ÏG*ÖD[Ž¡[û¨S5¡ëépu‡s?q­ï/ž¥`Á¦6s2›ÓGF+QA2I¥d„ߊnË×ý$JVûôy@&£5Œ:O¸ßæ«*œ%PŒ¥)Ø>u¹ÎŠ¨xoU:že™=­Áéb‘]?¡/6vrì>5.òÀ©2]Ð=ON_®þ.Ê©Oÿ(%ºsÃl}½\—[™ÄÞÏMãFÀd¬†xÔ}Tä©ðø¥ÄÓþïkšˆé “sLµ/MUõE‚–3¥ç»Æ}tgnÓ ,uÿcBPç3'Ø$h½¼Ÿ=íÎå»A|Õ»ÿG‰æYÏ6f_!Ðï~99v íöï©Dj¯o0úhèGV­2Ç+„ê›ã©X”*÷%)2–kû«míüؤdö v“jæ=Ë3]ŠX² ”åi Ö!È-Öë´ä§-¿Ìs85tw±‚¼¦Q݇p›EÞ*L·ævTPQ¸än€úÌ·úcլ鎥 ïE§ §èªTZ3«Ûhl›d%¯¶¦Ñô5Ïîm=ŠPàÖ)n¿<>«ú\ßœ<ïü'FC…N{%ÝÂ*’/e%¬ò7žwÁèñ&Ÿ•-3˜uΚ‰ ‹¥u-^ÌA˜÷áÄ´ Ü(ž L TðG#ýÉ3”ä2ŽÁ1p¤c˜þÍ+Ê¡€äàh}naKrÖy«vA(¤ózÔr”õ§pÑ5Ìhx€ ×ÏÌ€Iø¢¡0ØÄ û×zå®8›9fÛTÈULòñ튲ï ׬­påa¡ÜCOUE´=ƒÖãxðÏ¡rÞBL¨ãtc–-Ô8¾Œãë'ßx[ÖñÙéÈW`–ÙÉ/wo&(|¤[Ý8ÅÿåE±QßïfZ¢ó0fQém‘²¹œ ÌD–#STYYPkªtz#`ÇjT+;²ˆú2ŠwtÕð[Ç×Øø,¨Ô-Û™ßV'GÉèïleÔ”]ã„þOÎãáñhΪ¹!/ˆ®ªû«!h_Pþ^4¨u=E$ù÷M^j-é°± YÒ‰¸XÛZqu.™Ñå°ì¾E±xâLU5×)í±ÕÕXR™ÞŽ¢iþ¼¡Õ9\<G†v¢T¨¢ÔV ô¸Ïù‚zúHu±Ù­ÔÇ¿ð&c5Øôæ€îpê+NW0ÇÒÓJóÆÊy÷@}9ëzÕÝÙ2ª%X64èü Ó‹åØÉï^cŽÿ“”ÆD F1;n ÖUt-š ƒ4 6¡)3v;îòP»qê\X&ô±õŘö^x*û²#é¹›6U[•›¿74U=K±(wÛ@˽þÃP›îxXœðÑÙ(§Ë´dúÄUÏÀêþ.që¿Ä¸¨]UÑb¥ÊQ,P‹¹íΛó½$'^‚¯d÷« …¾âØyíkQrAÆkýÒî•ò—îÕ®GË:¸ ÓbgËDï—(3 Ï]%pƒöíÌö; Ðnñ>„sñ"àý¥Qu ;؈–óîˆHøƒeqR7q.ÀVTø.Æ/£Æ@·ò4Ã>ÔA“™»Ô&žÅ$ºL´ß? \¨^ÏÔô"ª}ˆ[29‹èãÄØàŸñ®;Ð?õß{ì¾Õöd0:Þ¬ŠŠn« 4�*ph±‡": ,rœûÇ£‘À£Ýó4:|Q±Õqm¿ûËdj¹¡5-]ÿÁÁ­âoqÑIPʼnYxœêôst]cUÖÝÒ)wæþŽT'F7O˜)½™S/”nÈòD¾wéSž]ßEhÇ3‚8¸ +#ãì´å¸ ñÃÂMëzætšD§ 퇓ƟŒî;õªÉ@Ërb™0½x ÎTñåôÜUcÍ8ò@ü¿$Î,1ná˜ÞÙieT§ÝDù&o×9Ãû|ï8É<EFÓË-´n/O³m.BÁsÁly8¡gÃIÐÓÞUnSà' ’Û/3kÄÕ+†}sCâ08‰y`ø*£«pÌZÈʨÀÏ¡¼6ÚŒï<}¦\¯'a,ÕŒƒ±(:6» –ý%wëw/C¼HG}¥š©ÿ j‚< ÷0œSÓÓ“çÿŒíõ¿¾ûßúJY?·ÈŸºo:žH.¾sÕùˈJ`4ŠôÈA wûc£É׬æãì°àå0e”º¬ÂÀH­$/,›µd5Çyß…ÅtøÃÄ8Ó€Q’ ¶#Zzúé0¹®|T»ã¶Ôªû§ü;Q}áE�!¾.#U üºpÛž-9$%SWÞˆìè~XSB/¤M3<ù­‘+v†¸çQñþ¥1¹¡ÂoTÉô@ˆ¨yà‹aâÆÓ¦èž5KÇšFéz‡|O¦WÂŶ)Xjf9;öê ‚ÄÜ|ק·Û­”KçÆ°3Nœùi£Á3‹S2ˆ~?ô@}Ñ5±“¾Z:ø´¹ŠA«Ãýá9Ó PÇÞ>c#–•Í™Vlà€÷ݬF²pH_ }OÚcå¦qÉuÂÝûÝ„[ãU-±w)8æBÀ62¦XzF—‰ý6èö·ÊyJ«RäŠÇaÞûN¿ÙªËr_©§ê».FEþ, ôb šª®pîP-¸ À±¨|8ÙÆ„ýö¯\ÓÞCJ"–õ»Mv ¡WkÓí—?cÔ“Ž` 36 d ‰8LÀENˆÆ¦ƒ‹2Þ»Ýi·%ŽχïIUXr ·¸ACohÛ°›–;¾ï-+t$‘ünK7\㑨²‘§Iÿ}'rG¼ÄxýÿÆ ÕB ]‹x»rµ”'à”z ÛµÛã*³-tÚv—?Y”m¯ÆPh#ü<žB£õЋp³ì‡ùO7 X3pσ\÷Eo{é\¶ �Ü:Þkú”.}/Á•–sM•"‰t˜5FO—k¿nÞvS³v�-·5è#­›Ý¸î¨Bnôãx6E¤2mù'¥xݘâï£výÅYi3„æçû›,꽎vʪ(ñ0wä`yê4 cQ ¼àw›¨/ú#5åèïê7p¬¸¯9}%yßWyv í_ܸá�gà÷3mAÊ?·pjQ†ì’d‰1VrRø{¤ÁZ±¡!œžw¨¤Sœ½g"ôéÌì-ªáÎë¹Èlx¨ÍÀˆ_ÆIl³µx!>ÓPVô 9´8Ø÷s±‡M¤S’Û†tOÊTÈŒÌIŒÍùÄæEö¸póÄRžâXèÙödzŒ[Ǽ~£çÛ>ÄÖ =ȼæõb®ä½JJùÄ NÅx€ÝÛa’Á¦{µðƒ:˜ÂÄ2ã$C|‘3'¨G•‹<ü-¬߸±oœŽG¿ˆç3EÍ'Nœ¥]åQõÞ…1?ÛQ¹%pW<¯ò…]°÷î)•Ì{%¿o.Ý@ïNA‚%†¸^Iz¸›$ad=iô¡î~ÁÏ17‰50èíƒ~rÉ®Ãpü8ù…h”Äeª"6­¢âªS‰‚‘ùKÄ"ç)°íNÒÈýÙq¶Jn«¡±³Øú±D…ƒùÀ+˜›üîS¿"³cn¶ðÉO#Uß_ŸÆ±o.&â¼päµÄä•b’ɽ½!·B)ª;4 ¤ã¥·ÉTæTÈç?ÜCdzÀNe[@WÏ©Us ªÔG_ÐO§oQÏ„vr°íQê)¢n̾é`áHÖ±bˆÐ‹¶;mw<àÚ»{/L†QŠFºåïGãq-ÂæWíÓô]³wùãtlža„âÂÀÿ™º¼Ôž%j}ê™í€·Ú£ïøðüæÈA\›ÞûÄqÖQ̲qèåÒòþÒ æý°¥³ªhÇZcfÌýý†Ðâ}ùô°¥M åG/|åÜOG±…©äozZÅÊMÙX,éÊÖZˆ¡“<á™ñê “Ö*Ë-m ,º)õØ™¡ûnÚŽS°ÒåY«ŒûÞéç¡~™. O%.¾Hm% {Ó–aÐé„Ýè�=*Cú½UÆÂ%ÄAŠ¾œì’ÍÅÚ›qÍQQæ\— þØЉþ’«]W¹UÐ,E‘*õ0ÔÞ#å.�ÎÙ¯yˆUÇ-o=Zn~äÙ™›DÖΑ¯ÏQÙl [~}èû+7ŒÌáìC‘ˆJâ Ã^yc“ÍÌ›Ì×à±{Z»“ŒøH§}7ÜòÃ;×±(V¿Ÿ\xn[½°¤eÐ4 ·ÕhÅ«ÝÉQþ'ÄçÅŒYXŽó‹)ò6àƒpü@mÃo—-}lòà^A¦ŒÆÃ4Ø�”E}eâ„3 üIµ¬ýy0\ÿÕDV¸&›ÎØŸ¿Ÿ;lÖßi {i‡D 'ŠB+†òËaÛíËÊ‘%ðp_v0&Ü] t(×ïÚ~–á–„‚h=&ì68A=3§¥x [Ü –-Ä{½x %¥2Ÿ®W¡y<3–¤¸=ÍÅx‹… ø‡E?~ ÷¦íwîí‰U /xLŠ–àж#Ñ=$E=ƒïeAÅÏM:vžLù4»ã8S’o¹ ÊŒzä Ö‘æpHÙêhÏNXJ((¥ °;¨sžþàÿ R„þønà‘¡ÞŸlQ{,r!x:ѪãÑ÷’"uq…þ±ôü±ÕÏÇnüß¾q¡óæ7‡ÃJ²·¨qŒàLIêLŒÙs,(™ñhóÜ›.>p,´Ô¾ ;ô@­>S²û¡Žòél¦ž˜ÌÊ&qih?ÛúÝÌ:ñ¦±ã-´[úN‰×pŒ _¿ ëd „‡ÓüßؽâvêJ½e›ˆ¶`âç¨cmÅJaïÍeú?¼ÐÈ%¾ÝÒª†ÆhQÊ@°¹B_G*siÕ•À§žëœqSyÝžŒ}œ˜EêÌŽßù»LÛÓÉ™ÞZÂ>.½+Ï¢E¯Ýº§« Ç XUš$ÊЛ]Öô¼zo‘ÂÁ®Ý‘nd/]Ýᨠ KöÓ§uª§RÁzV“»EçS…×rJ°l’M7xØ ·ÞýÙÂ*EÝ­ÑùóûÅ)Xw=ó¶O¼ë({ÛÃ*ì@w«ò©(`h+:¥6¨:Ú{o‡æÃ4·<"T…ÏR m¨®E_U“úˆ. xÑ3Wv,=¦åœ.ô®ÇÖ€ø<c'b€ÚHÃ^“ß‹u&ÍbG,†º/£ÅÕ~¨{Ó·X¤¤"@Ù¸L”ŠmùF/i–“ÓÜŃ푞I>ksüý£n¬Üu¿\…O0ûA_ïÉ·£ *:|•QÖÒ¶ìi½xBP7ÈÖ÷6!¸¯Ú‡~N1¬ò ÕÃrÇ«+½ûùj " pÛ5ç/U{;3cþr×`©ò9ôqK¾ì€+ÍÆÈñªlSÇÈ¢Ÿ°VåÂRØ@%†_Ÿw¯j`ß Šý\ï�9cšäË…lº¨¬07öÞ†Nb¯Â‰Ëµ8»Ø°”í`œÿáêÎx¢RÉ‚Içª-¾º2‚Çi‹!Xr‹R;sóŽõ/m²ÒNc¹P±h«³PÎêÈ Ÿ>Èß¼Zù§F? &f*mÁwreA%²¶ hÇ¥æÊ}rt©([êÄJÁ]ÍK„En0ð¯Ì¢dXi¿D¯ô<®ß¨Jêln_ù‹¥µdu×U™—³àY;_ܶpõ%—ýo í`æÊÝþŒòXJ›UŶ§Éí¶˜E­ƒ}Ê–¹>]ÿgá±rQzÃk ]+Ú‹k.˜àŬµJù°6HZ¸ ë¸w ðØ„JËäYçó�ø¾.i"ûe‘ïSLÜ=Q<–SLQ¯3UŒS‚t7æWìü;²~QXÖgX6ôG¼–J*÷Óf{õÓS#Ü ñ¼Ûxéàq{È%íÏØE/„Òñfx»6Ë-²sû&LãÉÙìB3«ÃÆAß ìfÙ¬:1rºkÁc)þOAÌ—…ª{˜æ%›/ÕVEãåà[({o9*Q’!õ½»0{˜n4BÔ2È ˜hÐ{¦Qé»üûŽ“Å΀Ø”‚ ¢¸ÒÀÈ%÷ûï݆@Á³¼¨Ÿ`‰àåòb©À9÷Óù½`t¿Å‡åÙ\%+£ô¦ŠÊÓðÊ}'Ý›7uÜ+ý…Ú®8]ul¸œXœ•¨S Hœ“vÕãFk¹’Ç㎌ mìà®Ynï¦g3CË…´’WcÐG ¼mU¿ú©‡\-,‘˜¢Çé‚‚d³.GA÷Ñœ%–ÜÜH¯¾Áÿ•å ·ù^hžY tG{æ…ã6½j“"/uÒï÷DÃ4®Ê †œŠÌ¨d Sj›S°•¾¡Ž$F¤‰ìG€.½Ú8òÚ{\”ÝAÏ`rêÚ?]ò>è`ñOQMÅ#´tg“<Ï%mh%·7¦=CÔeÕW/ñù˜äsÞ…ʹ¬è™@ŸÝesÜÝ ×ÒA.rëýë½×Ì>™Î9Æ7.“2Ká$Ójù”-lÅv' \ qj ÿb• ®§žª…³v@ê=LQorEý#Gm÷ÂlÃ$×Ò€…P‡T]ïÅž3N¦I÷ße�XX î =&Q•.Æ‹…<uáM½¯^žF¬Q {Žš MÔ?á;ë„2™Q¨œYQÀð3à™ÕWÍé ÷ûõgÅ7ªÊÌØùbàÿÒ˜©¶³úV“ ÓÛ•–ãÚr«ÆqÍ‚üP q·Þ9Ùú$ô=.`.ãnÃGœ<Åc …@þ^´ÏñBÛž¶seôÜy;›¡,·8cˆ¨i¬àa˜c§à<’EèÓ°ºhÓù0…à›ã~A›¼‘=MôOîÕ1ÐB m}€Fôwè¼4€Òdá¦ô§OØÿU;²L'º¬R…ãç9à= 8Éôy²Î-H–œÎ^ߎ…œ™’hÐ=À”¤y`þJã¡-1ñÐçuì6ÍtžT‚3Ͻ)�çÁîèwM³›Éô+'tû‹o: qbl}÷DŸ+ó„?CÎä¶n»°1F}8±šÞ¡ ~<ÌJdŸC’¤¡(£x» bçÐÓY{ ¤l«0‚4*%¬Ózæn×<¼K -[^ð+z8™÷S®#?ä –ÿx…+”§npαHéü+£|Ó)ëÐÛx™=údýá ß‚"i3Ì6.™¹y{΢â¨ó‘¢Œd4ë×?„{ù-¬ØcÏÍŸþÔë0áðÖW¹ƒ© ¨×ñ¸Ò9d¿*±¬S$VŒ†sN7Ãä…]@^ø˜GLb¦îÔ7—GÜ©8ŸØÂ:úJ·ˆ–œcG(eÈC±Ó§ò…U6м¡5ù®4ÊX×ËÓøN˜zÑ:¹ÐÛˆÙ61f¦yé*X׳u'BDÙÙ*R0nDhƒSP±²ý·®ÍÖ´ä‘×,%ø -ü<Ç)¦{Œ›«¯Üà;vÍÇÄs'è].#ÝÔmïºUÓyÜaO9±WÏ% bIc²²X½¶SÀ4”Aðç[‹×›$Fâ‰Õ}…Óh¦`õG¬àK›»Â›!R] ïiÙ¬D'ד³^ÀGÁ,@„.ÄûÞ{Se¡·øô7�Þ¸ªl$gÝhtß=Õ:C7"Âoà Ç¬²¥’è;?ròX„e'ÇÞ´Ï£tƒxój"ÿÀ¼á—öò)ªîÙa7ôK6â’5X ™Nuኪܿº÷w/h½k'K JÚ”s±ZXìN7)/AâàŠKlÌÏ30Œü ƒQÛÃ˹ŸþùT€–cqº—9ÇeP¦«sÜÞ7‚ B†åwå!ß!gÊ…å€&“•Q½š\;$/ú¿Ÿ®”"«ô иÛëHÅ%ýï~taÂËAHdyÇÍ—éûÇžj —ÍŠ,<;xLÛ[flôàwÆŸÞN¶!K;|1¶&÷÷š#énp÷;¼,së¨W"ãL¢¼Óˆ/ “·N#ŒGJþòïÄ8ÓßQÉa–=+p‡¬Ã$6=iéö[—¸9².°ê³Ó{ ªy·@Y@ÖðXË®ï§&Ï~¶k“Š­.>½u<ÿéÔ ^ï©ÕEa´Ùª{€³Z¯ EhPO(¢ƒ‚ûë8¼ü6§:"ŠOº;€F=u Ñ5À£z{iÓݾޣ°ÂÌvÁîgåû`ê• K’˜åó´R-ºkHV×<Êξ?# ys×€ÃDô÷ø{6÷ªs«¤£ãW9áTZç Ê9G/ÃÿCÜŽÿ“»’gñiŠ«(kµ~+p?ÆÎvÅk@úÈ‘4™¹¤ÀâgO_¨‚LÀg[·wK4›Íå-(öuž¸VÑi ¤hñ©ô¢Ø i•²ºî>ƒ2€¡»:…¦×@Q³dnWeÛ•ÚîZñ9S*Ïíª¼t9§ˆä¤à(§QÂÉqÖPÆþÏ.“y:“¬hñ¦ŒüuˆÀ:g¶ —3ùjöæådÔ UÒ>„ß²ʸÇöÀ…Ž×ôÍd™Ž°Ä]ô;ƒ¥Ø\ƒk×ÔiF¿¥ º ôúãÓÔ362G­¹@$­Qö~•ÂÜ>×eÏœ×5LºW“\3rÙÙ ÝSc`øîgˆ Ò‘xcʳ p ´ÐÅáp{j; ôÖ噓vh ª£Î>vÅâiq­Ó;¦>–ÌÕ“SVí�Rêè9?{L·ê½M]3Â}Á&î??È ÒE™ä±Gh±Ï8ä·ü›C=¦§ºm6“üî.lðÕ©×å ÊqÄÚ$rr|~º¦YÃÐ`éëtƒ4ou“}W³r°–Óg%^H”b>Ý¥âCzÎKŸëˆÇe1S'¼0íPµ/XR‰×�út´¨û~ŠšãÖÐpMÂsÜK¦ÉPLSÐ&Y=+- S‡LLßZ±¹€ á(;h#ùé0ÌîÝ£U¿`éã<Ãe¨îÜݯ{Ÿ‡Ä·ÞÁ¿ÐÖXµhT¬lO•ÓÎã—– ®Ô#Ùø$+sãÜ–À‚ˆVk6ü5§x G§®>ºô©™&ñ¨ôí^iÄÂG+²õBG@C ç¶óÂQ¯ùÅñ!-`¦’A¼G š W¥ÌkEÔ=ŽgúàÅ ç{?$/g>8¾›Šîö%ð¯°6$ÛpÓgûå±”¨”P§Xvz¼HàµPk¼Ü‹ñ² ÖncSl“Æþ\òf‚¼\wGJB†£ÅÁ‡UD×sƒÌÒˆS0;Z|AG•ûÃ=_ŸEÍ> —_²UKai�SŠ×ÂwdhÃMwêÇ®öxgû®¯{ç(¼=ÂsúÄkVheßöP~ú§à¹1@‰Ãi}­¢Ø¹ÿ°t¸×ÂÔ0 F³cŽ×�Ž—(a<Ë©‘D–˜·ÕQâ›.›çLKV÷ö¬™|�Y(Ð\þË´-¶ ªœM‡!}¢T¥®#ä lâà <ï@&8t‡ÓDŸy8 (õÉ<SmP¡¼rÜPκY‡<;U\Õ³m¸!¡<$ÄI™‰JTcÉc2:‚¦Áe·iÜrêÎ_r<}Wã¤3…Ç6££Vׄyp0Ù°ð-hÿ€‘öVËDù´Óí0ˆ×Vâú=®!ÿ3ƒRœ»tÚ��ð–V×äþŠ ‘[ý[Æ"{e!óª%Ya%`él8|QIÏVùf{h[?ãlZ‡NVÝ~®o[6º9†Q³ô®ßãAa®)KÁ…7:LøÂ"zªò¦3¥ÓÔ§aL¤­¿9Ó‘ý>ŽšizT»éUhxÁÖ…°Û<x&%Ã#Ùë¢äëo §î¹²R_nPt\BēĆûðP;uï.FÔYûN4ÏMúï[–P:Ny2Àãn?ú,MY$ÎüýÔHû·E+‘ÁˆÇÛ¯0G20ÎWU‹k„aã©¡¯qÔ`Öðñ %XÖ<ã§*©žÕ»êdØPh®/ÊÞ:‚üÅÙ«Yñd»;n;åt"O)2hœòÂ,TÒÄßà¾Q—,¬‡óMïâ»ô]þÐßÀô‡ð¹'su¯6PÌdsÊ9‹¨þͼ@Þ}hÂ;ƒëG÷z²é_„}C ˜«µê·È)2ûÀBÍ7tªêê®ë~/ÿ<5“Hæ&Ø”MUTù¶¼h;íA8ô—á=§ÝäÌ­¸Vøç(©GÌ›º8Ê•ÁHËL°ËQ£¿.fã-‚R׆ï±×ÒÉkrÕ¬áT˜éd™DqG^éw­ öô7÷ÓYcÏÌ“:í)9¼*‘Éw‡;oÁ—Æÿ"\þK4ÉŠÒÀþ)טFú‚Þ9G="º;®ƒÉ°Õ¾ãwu6HfùvÈr[�–» ¨=�0$ýÿO÷¬J€Žà[æþ‹%IWu™;€ 4Y)Ö$ƒÏ¾9ócT8}èñŒÔS÷8íKý³àöÙ*<ª-vDwíá¾ Q£ú¨ iQÐéa—ù®ømÌ&ÇÃ&¨˜MMjÐ!s¯  µ Ú•iã–A«„®VPBýÆ󰪶ÿ ®-ÝÚa2ò¶-1˜iá:†çµ`Ôþ?T Rçe§ŸEÛÕ×Ù�0þì˜ùÁ3i+ùW•C÷’-Ý,ˆV K�îeHÀñZD FŸÁU0’Áɨ¯®ki œ1÷ìÀŠ,ûÁ8Ø€ ÍŒMSþ):KÙ|xì`¹º„ô»d|ÞCóáþ…+~³Ó¯p"yÌØ ÕoüÙêˆeÇ£ç{ÞÔ¾/•ÂEn I:zúCµ8˜ ¢œíFŽ²9ö͆¡¡¡7uk„†J²°yZUig­ŠúL®ôaZ.-ý¹M•gFL“õøGJ¢ÛµAŸnã“á(1?Pc2úEòsꬽ>Ôžþ‡ ÅfØìwøã”Ú[3;ÑË<j§<ª|AÞã¶ãIW ÙþZb)©ÂÑËÝ©…ã¤ñ=tt¨®§™Íœä´Ä„v²¾X’zêÈ"ª€êÁ‡vvƒãþú¿hzéÕÑEjÌéè~x\Sº`$Öv€\w«ïÂÓÜŠ!Á£á„åvrC5× síug9ºì›«ÿ#¼`^s…aè]ü0Á‚1Z«sͪ`Qéýq¢%ˆ!ëcŽ¬ËûÆ#ö•Wž+Ù!Œ#ö¯Ÿx²ÆyGÇZ³íƒ¯2�ñüý¤W|u>Ž·?1{_[Wº2Ê%tA„lÕ -:5:¹ýÛõ®†}oé 9ݬ DM9o§#’þzÜÑÆV³Àv;3¶Nh9^âªÊÂ;”±´mÅN/áêfšc¨gW͈‘BÛ7Ë– E7çíÛß" žÒ2d0`ñé×@‘Û|žgXç ý7ù÷jŸd³ab =®Œn‰öœ·ÍÅOtGêŠÊËt¡Yv­»q%Øå)ÉÉ^ƒ×ɇƒ#ø S4ª¨þ65»F‡tÔÕ:®Lï\²`xcŸ—î¡ì¸‘}çÙà>£ÐrT·) 3D}­|ü3äVpÒ¼ê'˜V¦É¯,>”zÇ&z`El–ô?×Âv.Aô¢"‘Ây¹z> ô´?½­UÌ“V’¿#„z-Ÿ¼m¶@ø)m:FŠ£ àÜ£» 9â¯Ï@e[4”Ú-¯òe·ºa—ݾE(\.îFê7󒶥“™¢•eÍè:%,Ã:Ø�3‘Mv7k™›þO¸rçwüŸê–ú ÊPì)3è?h‘àGc<+|‘•]ü$—SŒŸìµ wK©uówZí¾ü\Äo&¯Ââ<Û†Þîì'‡øÐÝ—È ¹læ¼cƒèï„Ê$œ†¬¥6Â4 ½¡9Ô‚NêŒc¶Î”È_Ð*å4ÞêY6 {ý]F$À£º%çiÃÚŠ0ÒT,½ˆÜÌ&Ó7œ‚ô¤x§_ZÇñFh Ë,ÐgE)ÄC5 áõ'îk’¥3QÃ<êh_&ÞÀ‰m·1ÌÄgí\gûöõ±}ôŒƒj¸Q½Þ±Ã$\»Z3ówSüå1øýŽn­E±Ú#ï³4*Ú­6ÒŸ1I’¾×~b™K+!€[ò VÆÆ qf(—?˜Ô¶ƒÔ2D3Š\jGw$K®Ó¸¶yÚø³*`‡Ødb»¯ÂdFä|s.ÍÕk˜¼`Hb¨±Ú´³}Eîð"‡>KÀ¡["9×÷E‘ϼ¨Zsxþj· F)±›½'ºÒ <‰ ‚¹¼OÞªÌâ’:jéäÇwÏu«¼ƒ7:~=jK £ ÏGÓ¾A¶ŒkÙ]Xû¶¥€8þÿþŸéÍ»·9¡c¼»ã3?QÂ6塯¢Ôy&Әǡ GàFyV1Fk\¡·³ey—Pm«Qv™ºKh°"µŒäã(¬2ûÐP{9ÄŸŒvq”l{£ iu¦i ¯¿±ÀÎSÃ{w»*¢t{ºË®—ªÖì Éç`¸ú–—ÖÁ5YDñZØÛäã»±yùÆ·?¦bÁܘ‹YÕZT3Eª¡¶”Ÿ%XZŸ¸3Ëî  É0i¦%ùáfÞæò²£ïv«%~ÓZ°ÚEÑjBC%Bc‘“ç +é5Ñ‹: ­ˆŒÇå+Š Ù¹5:û]?tú·ZJ‡Y—_0àfè=3V–’»O%# «>»k!âI«¦ŸyÔ–lþÓsovïØV:»Ô–¢O<M¦—òÑœ¶}§ýÿ#÷êG+`‘öÓш˜ËAÿËÝ4×{ ,Rä™%Ä&QÓ†þÔZæ؈#wÈ�kÑlbƒ*?#8¹l`ßw§º62s_šj¤Mƪ}¾Q÷Aw€µ(v†JF`SÆÝQ”Òžž5Y<£Æè6–Qæ;ê±2UÝeS)éþ¾å軤¢ ‰Üð˜”܆‘o²Þ­)}vÌ­¦£¹W§¶©9«Ò©lÑ RÍ¿‘Ï13EçβN+Š‡3¥\جõð%¦+1é>QüFõä ¦‡át¥¿ºZÑn¦g²jÞ–×€6*Ôý ,Ž*hÛ&ìqÕQ­T¼+5‰Ö™ì{®dywc­Õ‘ÿ/Pœèá-;G=RÞ»)‹zÒwʹ a™fC¹»–Ó©Svj­kýßZ¨>SÕËëYÌIœŠ¸³€Z_ì°Ñ–õ’ˆx‘Zˆ�bzë²×̳m´0p ×îºÑ}˜ÎÒª×׶¡Û´±0#d–’-fG?ä¡¿$¾…6í¸Î—ƒ•Ü�³/·DÅlìt<Y]õ%GWî½NÇ!‹§²!wG4o›“!oÀ»:¦ÿ¾Åyá d ¨ÛM>e¸÷¡œ9&&(Žyèo÷gøóƒPÞÐ`͘›½=S@L?Šñ¬J¦´°¨©ªP®¼J¥¹Ê]UŽ@.%“–9·Ìï²Á,­ªÊ-ü˜Qo¬–¬ÒµkåÜ÷Íð"\1dß?Õ2Žm·­aˆáIéÓ¿ÍHë}G™sh%\`Šp:Œë¦ü+>³8’ƒÇâ·ãòšVäRÇAd蔆³Îµl;Æ¥>£Œç›Ò-éRíÐXO&ˆ=O,ÁååÈ7ÿjŸQUzÍ›:*¿ËõÆÝç¶ù<·Í[‹þb˜ô r4 ƒ5Mñw¾»ì¦‡šji Ya©dl†Wyn.Wµ‡=%.Ë]ÓõNþŸ»)ñü…R¥xæ£UpÝx·Â[n·Ÿøô…7ì•_Z©ÇÿIÔ_-‰ÕWç;iÔ\�–£0z4‰³Æ à㦷¬#jùdóŸ‚V•Xƒ;ðOñÁŒm§Ónd ¸¦™?scâ Œoc �E…úܸ€ÏnªÞ£cæËn¸ig~/§AÈìEYæèéa€£+-2aÈÌV»û§É‹dgÏeíê$P“JF“õ,Òš©/„D´RvLX RñAúÓqÆ{c&¶Hó¹|í‡9»M˜Šˆ=[iÅ*Ôæ"P¡®¢ø´5æÈ°hilÁØLœ¤W}+)[Î[^• ªÊÏ­Y•ÀS3ùw&¶ÕÌ™6×>¥ÐðÕ:ªS½0HiªÀMü®Á}”[Œšn …¬Å§÷‰Î‡ uky/IJÀX˜6§«’á?éä™gñM²ÑÂd°^iÂÔvÄ&ÏÃL ¿²¿wŠo¿oE׋›ô£Åi›mGŠˆ—l1£$YW3íÂ%îhÖA;9øG㤓’ PÂpx¥?W˜æ3izF4'3ÒdÖ¤KÂUz‹îÏt�éaö_Q]Qº \Û½OF2wTÀ¨ó’FEwµÝÌf쯽ÇòÏ¥ _eûÔùŒÊNÏtUDq6r{rì*ó~×Baø JâÜz„W8&KÓö¥œ‰-¶h>!eËfú0=V0 =¥ðcùbÞk¯ÑkvXÑ·¬~ÀÙšÓ vtèÃeÅ’ 'ÔRÜ'ÿ~O–E&=%O0€Ùðq4­^1Ñ{/†·º°Øy“£ÇðÕìl÷§SFµêÄÝÛ–d Û§Ïwiê(ïÿꤷ=èJÿÒlo¼–ÓË£Eã§áæÏ*Ã|eäøE³ˆnã¦Oÿ§7˜ßr&æë‘íy¹ì;ÆÞ ñ©»|tLxD#®RŸš�™‹j<(²«H¢�ÞåîÇo P‹$7дè[<ÄIEDBJW…Æ1š²ŽÕ€K”n_ï×|6c4R=Â+~ðèpºc«3Òa#µÌŽój}ÝÄûß –ç‹”î™LMFã¨{s¹ëÒ]£Óý-:r8aÓW€¥ÇÇÎr3­Yn:P¬ÐR@7®C÷j•žTÁú†Õ[ú¾È£8€ Ñ¿¾¶;ÔSuwåvæKL)ÚEžh»v×U™™+äÇ>å2Õ:ýÒˆ±=¶çü‡˜2By"ºT”h r;XW"mªöê5µ)§Wõ°7Õ‹¿mOÝÿÞ“©¼ÏTAé4å4ßZÅ–d™h’¯ÏÃeDüëÜ{ë!¢p­°„ãuyÔŽDˆ¨–œ<ö䂾VW“NR°®³çQV®a¾:Ñfð¶ M¬ÎKoš»“Йˆ‡Kþ ·cîÒø¹0Šì8R9Ü\ƒ ªI’yGMHÀwm{›;×Un<Ñ´ÁA:ŸM±´§ó TLµ"¢CÐþN2ÛÎéêLk!¿-×€:}t¬ÐÚAæô ·¬¬ãò|úÑæÍk}»¶~)‚ä]oBÉ›_’<¸±™ÜÝPƒúFë"Z_¡Qñ78æaŸ4{M3Qþp?áû+™´[6ÊÔd{28B~&,4å Íî‡&§'ñ"µ‹Ó‹®¢Jêݼù\W·ÄÖtJ} 1FCØÒ|ð. ¬o]Ÿ/ ‰.Ø^ùS™:¯¨€nsfÏ"�1=øͳ½ p=Ô`Nƒ²çñm夘0ùÖ=Ø#à EÕÙâ�4’ ï"¨0NŽ±ø+§e”v¾½¯ŸñÀé¾ Œ×á:]ÛKÿ/}gú{jŽrXò£â_ÁEìV]ÿÇÏo^”‹sÃLŽñ|vGJrK/Dkî, e[à‰"=c‚"Ò¬nµ?£w'™„ßd¾YØ4 ¨Ã+ Õ,Î nýñ§íK½å´*s ÿ©£ÒέÊm±™4¥7‚½w'ð(ÊîØ8LAª°ÉQÕ+M)gƒïÓàL/4I·ªžƒ½ÄÀaÒƬn²ja%pè’¨öÒœiwýflÌmÀHUä°n.¸ÚºZõæ7¬9N:änÑnƒ´pJÖç¹ó¬%©è¸›,ç¹K }s¡´Êfl/ :K3袷ÔPºú¶»cok¬»Ã2+òÒôcé$.uT­›ÑÚ_Ý¥äY±äð7EàÂÕL ;ågí8©›±£Úï£=NûÅ™AM"qíf_/rŸr˜)}ú„~£`{úøË8êÀƒ˜º º^~¬ jáÞB.Ng‹&®E5`¥<Á,›wL,¿öúâG‹< AÙe¬Qº=IO¹ÿA†ãeÈQœTA7žk«‰²‹ÒW& +(‰¡Ž¶è‚ÉΓË[ o½`Ô'ø7YTo­gø–BQ ŽÀÇ0æ1ü \geçè6)e^ ú\v€Ñ¢ñ!ìè¾a–YhÇlj€†hõùWÓOŒàêÒ`TâT¬~Õ ƒU¼/CI9¼1ìe §î([JÖžüËìæ'ò²U9£Ðq·M£¼Õ` ²µ“Z5Íú~ãYV¼—†ºgß°„­{¨ˆÏ¬Ớ“Žñ]3L¿l] ¡_«Ë0Ÿ‰Õ³þÙ5 î~ ÿñf5çàæ`7Í«4x4;IÒ<é è<¥ÏÅ_WE$ÈS¦JÂý¥•³(~p¡ÝXߧæ.ÕÆ°œÛv¦4îwËíLaþehÿèÈ—ÄŠ+ž3L#ÝéIg´P”oV;Œ•´UñzQ_1±W9ÕÑb{1 rÍ„¨^Têç¿Šú%¦…ZrVŸÒ£öÖ‡sàfÿ| §–•u(ñø61êz °•Òvð„‘çog‰üˆB2í¶q­>‘%yJ,ˆ!¼Õñvã#†ÿ›š|| Ö‰Íñ’»ã¥¥Z¬>~Q½°}¶èVˆP/Ý°ðMdm•Ü_,×궒°Ý82jÆej¯Ü#˜b½îš“‡’õê5bÂŽ½·iÇåÈ#«ÁïÒÁZ­C¤–È¢qŸD¹ïÀ¢ß_-uëg‘w¯/š¹!Í0ÒÛïȘ™OgÞdaù8&^ÓólõÑOZ*›’¹0³Cv„[2X¹é ‚Õ_üöÍß²‡c7Œ;hÆÎ%Œœ£WŽÊDµäkåž%$ê<]㥪–<-ñvx"uçâ QŽ“«‘û‡KÿÉ ÂŸa¥›w›ÎE_–®ÛýiTï36ÕM&'²ùŸ¿(ìÜ>LX?µMD\Ì-Ûæ8ïœUëlΪɀmŒÊOU‚ft)æJb¦íÎÃÎÙ¤ˆC‚–±§äòsÀžÆàQ"?s·ìñµØ«u"fg(:Š©‘¡3%@Ñ>|¹i iqÛ(Wè†aGOât’ÚÖxÕ×ø?IRZ IV¯)Jz@,z®‹+‘ëÀ!ˆa7ÿ¿ÿÍ7‚§•AxpQEEP†5‰gÕ"”q`~ãyYt¹~¼¤†î¤¼'q[bÆ48Í+è0»SãùK§Ëá­š”—Eê/îY¹Í}œ{Úm¬è¶Ù©xÂKNìjƹÐÉÃòp:%YN…Õ³ƒ¯àJ•z¿^vsvÉÿýÓ#ÞCË}R†¹PÂã—›+wNxpÛÂõMº/´Ïæ©í›Ípè!ï+Ê\'äI vØ­n4³½¤ÁàZt¦50iz™u ðážSi2+ÅÎ Êi`„ÁÆ {Áv®wPúß¹‡â¯œj—ä½.S,ê@"LLEÙÖ—q;ÒÙÄš‡ŽðøëÔdqãúÇ4ì•ÝZà™P5°¿w„~Ƚö ÇÔÙ°_ôåso]š³‘NwÔºácðQ×÷P»* éæ)àS¾Ötº‰ßH+‰’ƒ \øæª-/ûD…hâÚu§û†ê•ÍÉY‚9ùfÚ9‚EjÏ*iµ Éã<ìÀéÓ4 ßðæÀ¬„µìl~}óщ®‰·%snZÞÁ©±¦í_£‡úg·ZgòòƒZ“7€® Å»cO·ÍÏã@n)(Œ»¥?v>º+’’cZ®w¬{ú ` çê\ï^å5hS!�è§å·É€ÝqWø«Z,-j«â'ôŽ\ñùîç<@;¨š(BÌrÂç(¶$Žs£`…¼¼¥C&;i~M{ñ¢]óŠw°0ïðq —jüÖÿaš9¯g6¹åršê(9*T&e›!Iýhz³U…Ù/xÇ祌aºP/hñ¨“'û&ŠÐRP´ÓN¦*î·á⮋’ÂŒŸ&J´Êíd–& âKhŒý“–ñìž±­ÃòPDÙQ{žÜúk>")*õ®aAI»ÚE÷ðâ¬\ÌŽ;´*é9m Ÿ•Í'¶'ñdÊÙÂzÒ¶ 8ÌÚÉöõ7à¯FÞˆAºîöÏbýXpØs 6Cº=­Ñ± J:ØM’¥° Î$=Ä®ÑÐ;7¼+3-{#(‚NØAÏ^ ¦ñú½ž‹ô ò àC«¸Üë³hÚ€«¨ïCÉmy8´¸DÃ’*]5#¾Üib•¹m³IG¥ýßàØÒv›ÃàÅþ›tÜB%²*·´� :*ˆ¶Ê·U|€%Œ”u,£ íu n “¦_÷¨·b¶-»–ôG«íg¨ð\�rî3 ¦ãîØi‚.G° `+¬Œîü×%È?»Þ;ºÐ!‰øÏÂtN _ÝË ¼ ³þLV5`ÌAÿã&@Å^êÆMJò”°uITWÆIi9ûô¹] æç?™p¶}Ó^"¾ï% :¼h9y[pœ]ûÃp¢Ûµ3TwiRÎ_î‰ÑynU SÆÝ¡"¿”X±ËèKÀÜj8q-ÖVTŠó€§à¾y´5sÁêŸm“$ôÎÙ-ly¢xyTGs6ž8Pœ±`xQ©„Iز`‰ÃRµ“æywMcÕž½Æ=Êëļ=Jð´ VêD`c%Ͷñ8 Ð5>¸¿®¤)h0å+³Cýª£ÈVýž–³@°wÃÐ,S bGfáCý¿ìÔñ[ÛòçA»ž™cOÞPü_狱v,N²¾Âz­Oƒ× Z°+Nlõ4Ÿ|6ï—y”‰lë(”EÆÂê»jßx¬(öôÚÈ<ÖŽ¯ kæ|sqéúŸfÄ•àV$!m^7ã^OàójŽÎhúá‹hà‚*Bl+üG©Ïn2èñ<H!²ò™=e*&§&ÆÈ ð/òèQæR?ó÷¿¢Xä³ÿ> ÐÕèz0Gqræà¤Òí? µò¨ü›™i8½;z³´×ò§½S f¢m¬§kíaE'ãká2Ì5¡Û{a*´¾Ô„Êmå=_æ¾û ºÓ̘ç^–þòÓl„1zÿ·ñ=¸\íA±Uw_½˜Ñš¹|£0Šc0)7ÏÎ+So3 'ïjbúzvî¥â® Øôy”}?oM›ÇÎÄŠìFLj4ü6EÃù‰i§Vþ± nAåÉyü=ÚÉ#ß…Qfÿ›Î”åýo³þþ7’íy…¸›•Iíð“h²¨þT[fè(¢3Á½$þ£/Øâ<´'µCó]ž0¯ì'3kî$5tÑÑþgÿº³ÎôQÐB@cÛûd²ÅxhFbp®ô¢Øvf8ó”pWh)û<›Ä¨cÜ1žO9Âÿ{nBñø2fÊãÌÔºú4P%›¬ü[³_"Ó<r àýÅ]S7æÒaÌ( › ÙhjúÝäKÂx¨6ûLƒ6Hü‹¨b ¾QήÁ ‰6ÿOœk©”üª[¥¬£Çû¼ònZŒ(‹Ú6Û{sAw±ˆ‡?7Ë¥~<s¹½ W7X©ºýAìf©tçÛ³›\f‹õ«¼Æð-C§æÁú¡Œزá2ÕQÕvêØ‹Ý¿‹hNRÈ’v¦Ï'ïíQ»ÉÂÍBOë2Ê>«©…«6øT%PÓGéZƉ`ëϳÞßÂ)¤(´üeÈa¦€WçB@ѱ/Ùh#(‹Næ(|Á%ݽ|cï„D|`RZhcØ^éVNŠƒo¯=éüOh Ì“à) HÅÍb`p”_S ã G±èéóöqå;QÜ FÃý·Õpr˜©£ÞnÓoëþpehÍÉ¡¶7èhuüpu?ÿõ}¥˜×&‡¯ÌŒ…‹ïûàL$h™ù‹©¦3·ôO)è&ïÚqË+1ñßã(vëúúH7$¶Rïl+Ðw´)‚tõ‚Çl‡•QËý™]â‘Išï{Zgµ—âJd ­WIw®n~®Yàe¦ç1û \Æ4ª_t2Ûhs`Óö]Àõ¼Ö%I ¥)Èu_´ž è\ŽëÁý’‹ØSs”u­—rØÏG3ei*}ÆOZË‹•².¨ÿÛ€îõíK׉¦#Þ[†Ö«ì³xajGy#¢Ù ²NðJp¢6^´ï*ª#îõ9 Þc¿c!ŠÒjcÌ<k\q¢LýÉ殾ˆs’¥0Ö«þä‹­XB«ÁÉ «W‹;æú¯AËÙÀ¢C?ñ­ñ*YBFÚí5zâSï¼~S«&štÄ,ýM.;¥­Ö®òÞRÆȥLJ®šÕðôŽBxþÙ2-þOqKc™ ª>uf)C¬±¡t%„P°  ¥y€é 'Oþê]ØH¸Iaèè‘-ÚNOp´ûz¤‘Æ.F© Å{ìâÅ»—¬î ¼R¹K¿\c·zjOÅJ 3Æ´/¯{´Ê8¼ «ôÜCˆ~{R¸¥ëñò�ñ -;p,bDß_‡áùî£ÃGæ '3ðeF…^Ÿže´P¤€ÁJ_N†÷×H›Fø.å¡n“Pî½ká.µ=ðœƒó� fR矚3Ÿ!îÕá'L9“x<­Èý—tÇ‹(;©ÁáʨÎÏ3%W‚]ÌyÓH' Tb%ðN’^ÈãË€tðrZ×C’™®fŒªóF¢EÚ¿áÖ¾Ö gtõuTwž¯P¸X¯­î0>+>-ÅLè ùX+íB1ÚB¤Ðp‹e“³ënø…r# é~¶–‰ãÚX`«´¸˜�Gˆ“GSeþG’€ßŠÆ3]hpÈÃlþÚxŒiç0ÍÁ>/£1½N{éDr/€ñg­öiÝ ž«²)FGÛnØu’²ßúg>õÑL‚"·`…/«4J}wëaú`^¸…Â<vÔó˜#0€q;PË•®Têw©¨SvЮŽYÆ#?`¢ÂûŒÙ¹R—0hlxÌuÙC_ä”K\@9šŽ=4Å<¢ŸNð?,¤8DŒxƒè ÛÚ³¿È†*µö%”™0;ý¤ 3D TýUdCUôgÐÐ"˜f`a¢‹¥£QQïXßâŸЂq„>É奈§!È“Q*ï9Ü Ýg†åJrIê4ÃÜÿæß”¹žÔ|›ŽP¨»~q™`p <–g°«‘ŒÉRõuÞX^da¤µî>½ëQÅÒ“?7U¡^ó…¾¾‚‹J—rn7ô9Û­9VxQ»Â×ù€þ.,äqbñ •ÝÝš9ÐïUw+Ó1æqÜÊuµñZÝH ¬×­¨‹•Õ·Ýe¬´Ìc¯½|Ž5–Ã1»`@M!ïUû¸C–¶VóhhLû‰ñ¤Žžô`$š„C²‚îñDÿ?{ï<¾6u!”v©K—¹êf°¹‡=±ÉòfæSaÊ®¬¹ ªŸù»F9V¿Úõá||—˜š_|±—¨bêÍ98oÖíY9‰ÙwñûÁnèöf®Ê]m+î2†”XÏOâoî e!ô†�5^ßœÓü'|ö ”$bÃ�tŒ—´ƒž»îžØÖª¦nóþêãß]ˆØÝØ`)ûÔ¹nž )çŸÝ•b‘ÐÖ…«+¶Ýà�ŽqÜÐ=Z~€Üî•X¢ÓNžéSi³d&âÅ„.z¼Åç—+GœÍàÉ—s\‰œôÑÙ2öÀmw×y'þOçvv¶Á·üèù?—énTîØœ·o¥Þò|–´çt€aÝ­á1×çÁïÇÃË&™¬Ü¹ÜƒÔ2Zb; @I œ€Ö®gþÿ‹  †QyáÊU’¹½p$›‡Öè+͸èÀGt0Œä&RC©¤¿…“ä »ŽFæ:çY”têE õà #ÿ ¼0µÆ7ì=€AFñ®44ì*†ñH’vàºü7ŒÔB0Yÿq:P‚_¶+1“u:SYvÆÆ­'‚Lyº˜Ï¶+úäýÑ‹·ÔÜhE•£³$#=Î8Èà®{á™VíÍ#$Œ¤á¬¦²,ÇãgÝSŽ[¬‰ñšlÏØ+ÈHÐg[øîÝ8é|(þ¾¹f`.,Ê¿‡4ħï³Â9‹KLhÀx®—G…qblŸrÖ’(i<˺âiW$†Øªãü}ÇüóÒ}™üNˆ´‰wÖ,ùDÝ ÝÉ5o^>šî«‘|aMâ¨O³(ÿl £ƒ"Žypv.äcv£„Î0Àèã„1ã¶U`ËS"am"ŽvÔ4 7`Ø;™ŠeÕ÷j–T³¦æêʦ/ TB@¡O{‚ÌmÉì£ô£UçüàQe îÿå{õ/Åm?ºç–nÊv -Þ¦mi³O³ü‚Îœ®éf^ê’&šù *ËJ想@Ì# é€L'Ú»iûó*Iâ<7ÍWŠIûŽÂFñ~ñ€v^Ü^ä¡÷vsÍU1†ß"ÛÓ8äÚr÷€ü>ât»bgÉÜ ÁGÚï¡"·"|T zÆF8|Û èª¹>¡Œ gJšÝLe%0þ sÂIë°™=ØY_“Sdõ^O©º OóÛ,B-~˜Ü)ðn7Øòm ¼í×›‹@¿6èˆJé]|’¤ñÀBA…í»þã'£: ÍñœÃN—nëú5m×ÿ÷-¦DÎh§-ÀíÍöÇö½Êñó›À˜¦<–à)SɱÕÛ•c:¼mÖ§nf¹Í}‚þp`DïÍOTßP";ç7¥ÆŠ9_Ý­Ì•¾›uÓoš˜‚>‹åïŸ`BCίŽ)1ò¢çG‘ûˆ ^M綌êàš†¦Ü” �埑ÝÃæ?|[†Ù€¸lz¨)ÁøÈm ä}�)¤q4»|"g—¦Ï…P”lFS@µÍÉß›Wê§y-Uæƒ(5nÝßÐꛋeZbdz(ŒSÄGÓß_ »›¹z€¥`‡ã»ð.1:š¬ô@Aþ ²#ÊzLxÝK€PϤ‚SÖƃ4‚*—SuÝ°9úи"ùÉ}§ ¥OËÆi=@ÅÖM•Þ|jè¦~é­M¡¬µ³nåÑ(KÔ2Tâ=0¨ë@ŸL904ð¹X­‚QsAtÂ…à@+,\PÍ ³!˜%;g÷ùÏ Cc”Æœ"Û»�né¸ßR¨Ôœ  ¢·¾åÌñ$5ºÕjåb¸È ð}°û2ã„W¶c9.‡0:¡G<4;XK­¸Ç¡6OBG:vø¤‹½&ÒͲYí@KÆ=eº€DP*ºPz!ýÐáPCn$dŠ@ g!(69ƒ�´O è^‚Zä4t8õ\ˆ¾èsæLâÒ©—]hÅž\mŠŠÌ€™gŠ“ŽØËÒ ”œ>òr[ÉmœT¦Ï‰€`Ô™E#ÿÊ3—"f$+!†ÀJÛ×wWq¡ÎmXÅ›Ëf¼ç$ÈQO^Íœ5Ñp!L´ÁZYñïT4q, :Ú¦¾ˆâ³zô—"¶»\ïP^R¯7'i{t)ÒO¿°!±}ÀÇ(K·ƒyMO±@œÓÿû¶ûÓMáb{FB‹sB·í^Ò´¦˜ì6†r¬8mþ‡9–€ ÈŸ¸\÷Èýêe!Ù,3œPž~.O´›p•»×ö ÑB¼úïP£LÃDE‚ý+>gtøv”aaþ�vçiP‰ò‰=Ì8#$ƒÃ¾™ÂŸnÏ AôÎnÉÎO½¤zÚ¸[Çxg¥·‡^Fv?¶’⺠¶ œ^nK¬úöÿFZ¦¥éš³pJæ‡M骡s㼿­¤!™a—¡KA÷®lÕ£ê�ÞŒZ­¾3ôÈÕ¾Oˉ'®h>6n0û”DÊô¶~·ÍÓËáCg®¬eæpÄ\¥ÆžçQ*Þ3øÛûó^Üw~®U?[ÜT¢˜öê“ =Wº“ëNÈ6ŽòŒŸ)%ƒÓŽƒµ=¨(8Èĵ?Ü ôBÁ•y7m3S±%Ú ‹n4”‹åyìéÓÉAÁhõarÿ›ç6¥tjÒÏHL´w°”-â‡3¦§Pdë˜J½ê�QdB:5#ñÝø¡SQp¡Aüµ:NƒŸ–´ðY2½¸ö!¡á‚¾Ùõoœâ>L¿“N÷YzéG§Ï’²¤³‘øøÀ2;©ªs2\×È^?ê ås�{‡ÀÔãêUh€aG:ÿgIdÖ2\:j#-zÚMoTâ2<Þ§ „ªZµßh"Ù¯4‰òý(æ\Z@¡eåž‹¹¤ôpK ÄÊaP¶ðø{dG“›½� Ç.wÔxÕqµ¶)u× ð!¸åÁïî8?‹Å \FÛUe­"ÐѸêúãvçFw¶;ùb«2À¬JçšÙNU”´J Œa‚ëº7ÌÛõóß—Ý´ ¶^hî—uÅï:Õ)ª(Üyñ¦å“ˆnM PèÎÀ†fŸ_  ߀LáÝÑÑk]�a}ƒÙ*•ÅZR —1ÿ¾1…–[{8=ø Î4cI’‰n »ç«AûºfíÛqÇEVKßàF¸ÒžÚÝ/Ì!/zÂŽÍ£º;kŸÕ—¬([ëãx>j3;.eÁŸÞB[Ì7¿j¤X=”ùtÅ>þ?<Gpƒ€TóˆÖÔ×ÜF£Ï…øÒÜ:UÃøm–yeLýp øë¾AœÜ<„oÅeð æ7Œ.$°ƒ“e/UÁu7àî' ï4OsCe¥;¸ÿ ÈYlCZ¾èÑwšE!5mqŒÀo"Wøèr¸Ày7éxÄÝÈjoSì åÒ _*=FÞ¦£·vI†®Oóiñw°½€ (Ý©<naötÑî׺ïÎãÛª{ëwÓß4”Ò :ôôyýX¤¹ ²HhÐ%qUáÍœÎØvðB $xõíÀÿ9r 9ÖÈô6\Måmèƒw•EÙÆÿ©Ò™½™ôaë ÙÉ"í¾ °¦³sòJš—+ûÞ¦ž˜9ŠÖÓV3Ï ÔÑófÄ x½ÁcDë¦CNSúØÆ n2]S:Ê 1Áõe}óñvw‡ñÊÊLò[˜Âv‘Þ—|~8ëá™k¬jT‹ˆò‚ET¬Fý™ž!X² Êþ}KË:°µ�=à2ªýùŸÌ|”-øÒ£‡¯¯tF3ôh½r$¶ ½Ô’[*Ÿ8uÒXü¥‡xs©-û,v-³ÒÉ—È$âÓÉ !bH¿§ðLY°”)Qô´Íx†xEÀ”R…Š-·\ÇU½¿ ë>¥u½3®z®ºŸ&Æ„/czÇR’¬×fð×*o¦Óï†îí([Œ{n:.mß8KÈ 'ŒÚ(6ô¾E²Àù3y‚sϨ¼®.Ãí‘ÒÄ¢QûåÞVû—ûÏJB™ý𜙢’ÑøÈÌb] )ÄŒ/žÈ•p/ª P×í/ÊYR¬¢dT[ Q…™ÈáÍa#eù+A…<Éž¿ë+ (Zãg7±‘š^¾,àžgža‡·Ž9-º&$šb"¶ß3Ë÷Ê3OÖ©ý]òÆØ ÅBû&ŸÔÒ-f1â•hjñšUƒç.Çz(´Ñr|w4AmÍþ¬²¨•¯¨,҃ݜ3Ph» W²vÜe‡Ë»Ò;ˆµóTžzçºp“Em›±ãX<÷aÖÃil."PþôÖ ì™+X@¬¨�Ü€AøçÉ3í�ùXþåi†–Øi —!í@[vã­»†’ÙÙ“žp² ¼~BêHªÃ…ªÒ^‰Ê¶÷ÝÃÄòç<-Ò"OܽŠŽ#ÝŽ÷I3†Ú^ᇔ›¡^É›Ô:§ÉCaQ¿GñÚ¸±’ÄljþŒâp¨AØ`ÐDF‚y{“®ßûªW}JÓJwhzÊØ7km6ð°ZHՌտ>Žå©¡¡rkºÝRyó¬“Q•‡}çF§®zNc7ŒŽçQ4íd êzuÏð½£x‘; }í8ܬ‚½iÝwÉá==�@uÛògdkgV„âÈ°¾ní»I•Ã¼ßyu­L£šù€ <w9«¢ fpýÚŒ°×ôƒXTÏäÆË;Ï~˜!4©îqÙ‡ÐÜÈ6W‡ÍªÐ¯¢XãJ ±ÒŸ]y‹ÜºòÒzdàgÒW$A!8–YîÍJáÆ2N¿ƒƒÖ3LO*ÖE£ÌZ„sôçusÙRèænÔÊ5.äÛ_=t¹†Æ?\ˆŸÝ¶óÚS¿àg$ƽRJŸaL•R ° ¢,•= kvpV¸Ê@Œ*Í%[Á�± õÀ‰Žw•ˆskyô5´wŽ*[†»I¸<†"q;¢‘ \ªšÇŽ’·Q@Ø—Gý¨LU]H' ìßde‘k|IWRLÙ;ÇQ{MT1CpfïØ¡£o¯4Æ¥ââf«Û®eŽ·¾þÐpϪ0Ÿ©±dÛrØÚŸ±1Ú*TE­À½,BgŒüüÒŒ&m—ˆ×ýü먼•$ÍçþðŠÍuyßú«’Êsë.¢ýG–«Q nVNî›MXtÉTç¯Á¹p1C¼.(TæQšéhÙ¹ªÂE8„b4?)œ&Y”(w;*6Ý;åû´Á:^©€âjˆ}üál„¦é_�¤,¯E)ÖîIÙJ‘ )—¦}Ï„h&Åÿò4<ÂÙ£..”žŽ^LþŽüílðæ¹èk hú·Üȶˆú {Ph;^‡· îpXíYMõŠ<÷:D¬ñ×Aó0\®îß8$c¢¾Ao×N)Å÷íÊX~ Íñè:Ý`=ˆ)¹ëÈþŽ³u¨Ûœú«À*‚T4¸v”ƒ!=ãîø¢Ñ#rLSD±:b {½z£]âS󿎯Ø78xìŠ ƒ(\0iºm±7ŽG+µaI¯ÁoÜhñnø©¸_,7˜" 7^ÍèZøpøÔ/4Ô¹3Åø÷ÖRÒ'l;Å;3� LLÉý¸ÝÄXë+Ýx?»Ånj˨i5Pòt<ußÕ™¶øÞ°i?tP¯É…EOQ~v¡¿P‡Ã»ÊÐs^9ï³úSô鸦™ý ƒ²PåÌ•ÙuÚ$Û ~éc-Ž:ËX­‡ç5ð9x~Ê·èÆÄ-YÌô³qSz`gÕBDDe:©r»†ž® ÿ è°’F­"_ò tFi¯\ÖÚ\5­w2˜àãÓ=ÊU¿ÏZ3#¤KòO”®®j:ÕÐ<ÏwR¯Å³4›¹.׬«{1,drO~%ª–¤¡*©ù¸9äPûk=°…ÖÊ@±p·l‚éaä7œ;ïR®f=¬Ì: â/Ðb\õ.b2»š >Ä~+<Ps•C$Œª`/ƒ™Û¬¯7'¼Ñ=ì~Ä™îõJ<ðîñq˜¡Ål°Ñà8ªS£ÞÉí íU›ï"7Ú<šúšÝÕÜu»CUÓD÷|zã²G¾ÉøJôþå{Üü(o2=èÓ)“Õõ骨£ßŸ¼Tk$:<zbÑ+4»8dG®#Mž"*¼Ä,­§è0µ2(y&É£#$½ éaÍŒxónÌ›8ŽÈ¢Q»¢We3fzM9°”õ”Q}ôÂ<‹‚)ŸÁ æ0ÿ) MÌœ;¯Ã€ÎkðÑKüüŽR¥kyB4:_šY%Æ¿›m;¯ôC?ýcuS¤XÿššÖý¯ æ¥ÓÛ®ê(y÷Ž›V ú…,ã`Œýž²»ÓÖ\½0EI8…C _}À¼¨ÐœbŒ»½#û2Zu½4ÀÅŽÕx•$s<í:Xõ¤^6Š½>¼¾Wà€ÀÇ¢—¶—»ðY{œ&UZ"Œr£=¼Yi!ȼvnýû^ˆŒ—öH¤š«ûñ¶Gô)¬½'x™Œ–´¸æÔð‚vùY‡JÌ„Xt¨2ó½ç8NÜ©8^¿Ò¿«Íü‚§<luíµ52%A»EòÐåúá¥?]ÊÜx‰/`XŸ1kÕ+=µMËŽ`Wo:ðƒ‚’WÓÝI¶¯ Ð8¯49RC3£Ü¡é‡ê.ÏBZ›žJúŠ-€cwÜ®i£?áÞ›35 –Þíû{ãïla%�‚=—QÖj‚ŽŠaÛˆ"<–b{þû‘9çØôo³º÷á/mÄI\ɨŒÅùd”MXÈ÷` · Œ—à³ç"l3ä*E«qÎ9'kìñrrlö ù)K‰‹Â**Sz!deS®ìÄÑö"¯*wغ�¿8‡¾Øú °@õÚEÙ»*å9‹(^ØFiB¢N£&ì m! œ<ı—¼ƒjìk¤(Œã)ýO‚#tL°gÅ!Þôq…èU2G�>èÃÇ^‡ ÓP‚Èv€Å¶S¤?M‡£Ì#]óqþÏ*K¡�㬶—kƒ#³À{XIÈBÙ6b¤$‰Ÿæ `À[!(”g:›±Ös\!F¾›ŽÖŒãëpOlÖ~¹õâIËÅLŽª”yyÜóìÅØÀ¥ƒan’ƒœF�G+=æãë‡yB´¢j±¡hÑhs.ab~<x§¤ó�:‰u¦ÂצŸ9HÅ&ãIY”û ­‚O—ÝôÖŒ l;­ø#hS‡ kF&š:»œ1Ó|æ )%¸5Ö`·Že»›à�aîþSœË… ›§%–ÒÿA/‚:÷ñª¦ø?] åAì¤8|˜BÓËN6)}‰aêõˆëÌdÄ\.TõʸañðÃ4O5�$§ï›ß´mŠh8U²RÚ�ÇC”ð”WK§Ž‡„˜x]ƒ“$¹±óŸ,¡„gèržê(펦1xìÏœ¡úÏí€ÙÒ aPýý.Š3 »IØt)’cïŽ@zþæ.À­Ñ¦i{7@mS¬múþ 9ǦržÒ�.Mw»mÜM©¥ï$âòpì)âÈ¿÷Á»Ì- nî¡Gé×(K=á.VL™›åùèþ}6*Nâ2ó'M%V8Pn·aàÿ׊n §­Ù­joY-æ'y¶xQÍ|FagÝa¿–ð1Ù\Ü9ó¨ÎmÍJ¿g,¹«Ñþnݧå§ßs.ÿ>W¨ D.±F”|Œœ®­A/5\ýñþ쉶OOË´œy@ÓMù8áOtEŽ;àÓ©‚PD[…Žþ—ï¯LaéÛxU饊r/òÉ;²Õ$sM~ê*r ¬§ã Ÿ(ÚUãÙTŽ­^ ÃøÍu–L=ìÀÊ,ª:ûˆva*Ëäf:I^÷pÍA¦ê-›$Ê>}Ó 9‚=-ŠFŠ@ûëSÍE¨Û¼ö– çS`òiNÚ ßtÃ7£_]vn‰¨¡1Š#·ðïè\°1]LÊ+ö]k *ÕÉYmd'¡nî¼ù{Ið²È­è+Î[œñkWZŽÍ0‰´2p·”Sˆˆwµý¡Ûc(Ýíî j€õM{ð°J×çþ±¬§v†GÑKxªÓ`À|,Õ‚À3ŽªÏ:±˜ÌŒò?=kB›æ€­—𥻠Î|ìnÃæ¥ê¿\Ì"xI‡•çïMódÖ]h¤Þy÷#«‰UIî'’pT„©U7yØú‚ïífïa¶¿Í ƒ‰G˶Ž*QܸͭsdI,tÞºÕþLo%°.?ÑN½‚$—ÒHkט5¾S[ðX¦[½ñy ÝFú¶WƆ<Õc06¼ œöòLëÖ·•齸1• ½h&ú? o*M3ƒß:$(5«Ólp7ÊyEm¸¢ôfçਾ½Î=NI _k¾'–Í%úE¨yÛÐ/7-A9vfzàmnÁ¨{Úf`�-xÏÑ­Ù¾Ez:}é¬wh<¾Ö—gJ ¾á^¹ñÏrOÉëY%N9*¶ÍéÔÍ8ÇôœfÿÉé64»}¼]ùžÃÂj¤ÓChÙªÏ#óغf`1ÝN­`¼ÝËÙa½°ò‚°L/ÀZL Ò5º¡k»ì»/-BÌåw”²rF3Œ•fHõNv[ŠPýì/Ò Óü¦ÔÚS%×jsÏxån„~,›?~ê­”mÑæjh¯»vd¹m?ÂÓú E£’g)DE„oÇ£æ)É™¥£a1²óñBÜõø¼œFx€MæñXmE ¶Ï3_sD*î°ó\ƒ5 fƒ¨1fs=8áÕú¾šÌ$ç B“EÉûÅ¥i™àEØ[ˆl´ÔþtR’ü£\n—¹¡]ÑÎî“"Zxyx‚vå#0Ó…¡8,XY;0ùÜo5tL® Wudïûð½DÎdD‘ûa0Ó¹qkzScÃ]#V´— Ç ‚vp¸øNÔÃ)”Èe9„ºå¤i ËÿTE;!ktˆÀ é†]:çÚ©¼\€Ü䉩џ¨Y/ŽrÃøèõiê‚9-ü,ÝWiYZYÿá76pÿd¿ýÀË™áÛš¹sèLØ=ø< ;™~SñÁ&HÈ‚ì®Ì$ú»QÎncMCAK`åêŒ98À‘ôÙ½$}$ÿ7¯è°V31”X¹Üàss·çÎ…3¥]W}B¤ WÍ 8K{ÜŒêªgsé$˜‘ˆcqóÀþõýG9ù`luð4Û›¤wayŽ)]¡&ßW�TÍ(ØSÆc÷2—2™Ù-Ü�óÆFGY6Ó[•Y?KÝ8,¯ñëf`¯*Ÿé]בpÇÿšž-—/zœãCYÒ±SZíl·¦t5/È$šŽ{Šuk˜mÛ«óysänúC,Lp pÌØ牕æ‰,ªQsÛè\ZÓîéiÙ¥(èW3Ü›Ï\bn²¹g¨’ð9Å<Tåoó»<=ÎÓPG|ƒÐñ¯'ÕhÙsŸ¤ï-‹§Hmí¾àíÿE²XÌpÒ'ÌËþ0Š-O§ÎË­66gÊâÕÁ§[A6VFBn8ôø—è¬üô‚cĉžÐ§>!Ø£#¦2ýU§…¿Âõa[¿?d}U8“S™˜Û³Ö“ÆØñ°ŸäXz|yd sÔÊA¼† ÈØGãWGa £-|ß;ÊÅÖ•• }-†¿&NÝÞO—~—á�’“®ŸÉñª8|QÅ9ÿ¾e�ô¦n7{?åoˆóQâbVÕà®RªáEY6f‡"ʺ ñ“?6Íù«óŸ@¼1ÙdÌR¦J“<Ïí½[¯éËëÐà¿o%çô}ä�e”ý¯Þ&I6ÇÝP\ߤQîýNŒ¡ÿ òéÏ£?ÀtVU©ÂÚqDÚWkY1 7‰†AÕ2å.»9jKŸãÜs§û´AZ�ïƒËurÿZÓÜœ§ø‰ÃB{`�ˆk4Vahô�:],l—‚)—,JO:"SnÔ; ÇöÐO‰6 ;½#F/Y ãË~‹xó·ýŽÛ¸°ÃVø4tdÿµR<ñ†Ù¶¦³Øo‡ó÷ÂÐ5¯F#÷uÜÒ§,½û(‚+qÝé¤�¨µÀ !vaáx÷úDH1±ò"º¬!ãµõcʸEQ¸üLÚDãé„w‘vKE‰ÝR¤óÂ!ìhÙrjtásàô …3©\\Ç>™Ð&7=¤µ2¾‹ŒK2áÍ8©”ÍabþÓíëìøªfØCŠîו ugŒ½ÕKCg57*1N*¦,£ Â0Π#鬄Ê27~NŠ¨XíVÐ]•šÛdÌÍ2²â.§Ã/mÖî½3×ëliöâ¼óû ]0ƒ(*߃ÆÔ¡ªØĉ ¸°Ã }^‰‡d"*Ç-½ùà'Ë0E›ëÌÊq¤dìæ•#+ü0Ye(L²Ü&"€¦AÑT¿÷ÄIS;Ý‹‚þ†˜_ãÝži/¯õ¾,oÛ£5«Æ‘ÜÙäôLfh¬oEüôŸ,‰+wy(eTuTu¾}V¸ë]¤eÆÍi`ÇRc?ý"¶Š”bã4n À4œ½o˜è@wü_A‡4“|î§×âðÊíƒ9V¤¼ñªÜ§Ï·ÏÉlàx±ï k‚É×ôø¯œŽü JÊ…§ûlÞ;"æΗ;l(HªÁã?z#€$¹!dA\eŸòLÝcž.‚;w­ÅŒ%¢ÜPFÔÏ ¬†.æÜ‚ªç1fC ­…Úñ9ò{nφQA �ÆQ}²wO½fÆ®ïD+V±¿·¯ØŠIÏTè'(:Ç›“K¢1-Ù JBâÙ¥Û²0udûÇP’#ÏÚs ÅzpÉ'‚ dt e³25Ÿ”ÌìòWo¢ÕŒ—îÙo)ú湑Ïd£™:ÊW>·)y.qâÿ¥ãÛ¼"ÕƒBä»ä(7ÿÐfȘòÈ%šÏ¶\h i …g%™º¿Å?{½C€ˆìù[@VŽŸ>ƒ¿ 5TØ}qêh–õ,‹ÇºÃ|'\<#ù%‰YÅ1¦ °%ɼ f.¾/ÿ;_’4έ &EçSå'm¥r'µ›,êdpVÖÃ_ÞýµbqÃÀBÍo¼÷‚ùä€Ò®§ìŠ¶¸œ. -Iw«Q‘à”q߆ݒŽÆ㥣/·’ûÙl”AåF÷µ"jˆ™µû…Í¢üÍ]+î ?2†Ì‚l²RLÊ.=#F“\Ô_Œxíá(ýÈ¿NêÜò+è~³üe>6Á²ÂÕN¯n{p!q.ƒù½…r2›Ë²‘mUýÚ›.#NÎqâi¾ÎìY¯ªL—VF³*a %e{ú>�·8£œçQ:ñÓgÕ6>ê(é´¯Ïæ&à ßQ—ƒ—Ò¾WÔŽO“®è²¥¯yƒâ; ÷]šÍNžšïpI¾zÓçºk{•3¶g1e®é§Ò¬qØC*: ¦n# ½øø’/lÕI·¥ojŠfk³¨§6ê°ÐÀÈ"÷ úæ£sÀ(]¦±±Ûaàu ׸?Ô)à{]¿kŒÆµèIbÁ]üÿ¾Ù…ízú¯þßØÒO…ÏÛ¾ˆòÍ_'¢*ZKK¾ã�ÿæz³[¥Šý<‡LÍ RŽ5È*'€ƒ3ÚùüJw#.>fa™MO?§~DX®¼Tήn‡éžŠáò gVÈš6ÓjÈ£zë9†,|Ì2él´cêÏk*œu~Ó ÈVÃt7 ½á-à7†£H׿¸”FÂ"eŸÑ ´ì¶Ú‹c2¤WØÇ’Wª±C‘ËñTíqòàw!É68k î?²<Êû­>MG&x^ƒõ<ÇMÏÜÆìcX¿¥rç¦"-yD ÞFÞ«&NuåZãßMôûGç<\¶¦‡°›¤œC)3™µ”ÍÊȯŠ?¤×t¾­˜Ë{µ†<µe)R;4¯k?SKk· ` &Åã#¿®$Yæ3•eŠR°OKê•[;AÁHjáÁ¬€ ÃÐbº9UÀµp–=n©ê ²ŽÐô¤C}ÿZŸ&¸^·´ž*ÞÑFr¸.È`{u>ªâ‘ÓVB-JШdxvü„ÝÓVYMd–rîWžG*¿Üö5rsÞÂ|QR+.²,7gP`8Õ7çƒ6Ò]¸'ƒ/ò¸·“£[ž1÷.Ù|3JSn¦~<ô›Ã£ÉÓÿûÖœé½!…„-6RÀ˜Y ¨{Œäãò-•«ÓÙ%5t™F7vE ÷q�¸yA]©¬cË}¥?pøw·÷”œœÑÝÝ1@XÎc(Xžµ¤âÿUNjjxd¯ØlpeŽ;wW­é÷j¥õK³Üê—ÒÊ8|Qj•¯ß ìÀÐÎÜR§"nЮçóÖšwNÎœØÁÔ”°’ïMº·h¸_I÷º“0ƒ™WƨãÑC $âðáòŸùO†’;I®õ'€2NÀ0–”+`— WXé³_S$‘Ôpõ€™ì­-”™‹~CÙk' à±=+×7DÙÇ’ ÖhGGϧϘeb=ÁZ*ÆœV7Û$›×6¼¥ø8`FЗQÕh¶ä umi;†ÀøTæW%{œºØÈÛ•©k4šzƒ„tFRXŸýî˜ÂJúäϸµNTBÍ i¹Ÿ&“÷“Éî—\£«s¡Ì11㌡Ý,™8&\VE”µ:øBóoù~ˆ t¾#BºæòóÓ¾{à°'Âeb?jó£âmÒrÑX~áô²èš×‰æi w_´:±©Yœ²Y^Bç'ÁÈipßõÕaŒË<(ò—NLJÞj5:M±TDó§ä|nñ<Âü¿Ê�ˆKŒ¤³´‹w…¡Š¦`£jcL¿9ºóO ZŸt‹•C—I÷är¨!‚�<A¸ÂÌ ]ù<À˜¦:ÁM>/)®Œê€Aù¶U‰ÛÀ°€áÖ>³ü¶R–Ò{K`2�£ù•Sè:wp9»EKå( ûŸLâ´ LO¾ÿ«k%ïÇ0 ¤B–ÞЉJ5Ýê¼Âöu/·#ˆ,è ¢4gð áýÊèž Oï¿t„Ü)? { í.§²ä}ZmØeAˆVjñæSÑw•3|dˆ¸´É7»µkþ“ÊM6› ?PpÏ?µšGÁÿ#Ôªô«nc4ù¯ÿ„ñHŠ…µœ„äìq6ïáB¦k\,Å踟XƒÃ‡¹lF꧳üaˆ²[¼ßÐ]Œ ,Õ´r»ÃÕ-pçRbQaEy·5Á™·.r%H(J¥èŽ šL¼l™¥ªbj;¢øj{ÀmCˆ¾~íÈc;À‡ÅÚÿMO?‹C›ÃÙ/_ª(it°¸›IÔg‰R§]pôÑEÙ#Üh–RQ?!ñR• rÇnõÖ1@­· S)$ô'0ÖD?ÕéÎhµró£'³Éã+…ò.*¼ÖW—ùB‘²Ò@¥Í‡xºiP¾?uÓJõ)™Rjßx3jωó]–‡°´Á5e�Ü0×ú÷WLîjÖ;�¤ûƒ‡»#ß‚;Ióg§våhs4«¾“™œL§5i*––RžÕ@§¦ŠÒvN©ÛîпqfºÄ‰sBþ£÷ãµôº¶z_�<G˽š¤3´¸sþÀÑŽé)¶FÇf/^“^»?.}¼¨YµRlµhfê»ó”Vbl<Y{¯oÀë|E³­ “{„¯ Ía¯/ËÃñ¶ñ—ä`{²é¢#­ŽªMƒs4eß ïå¹=ôÞðögÝI欣` \½ë´•î£ç/9œQJŸ‡|„ü‹˜›÷~SHxK GºÚ†‚nCã8®~?¼nl™” ë1 zµ¹·Øò¸Ãsp³Opªw0c¡U$j¿UÌÊópÛd9µ[ti>'Å+UÂ/ÖÍõÈÂëõ9E‚ŽCo¯žÛÞ¸‚Bi¶òxú×%.·??3y*ã,Mƒ4¦TGɪQgNL6»Nae9&ŠÕáèÔ} [ûҖ׶³'»#ÛÅ^r\Âòe¬¶ä{úØ*¢‡n8…Ój¥uÌÒøk…9»·¥sùØkÐÚZ£2µnê N.ÉûF¯ïV¾Ð7̳2$–-TjƒÈ]NéNœMh9åˆóØzhÇû”¢]ÓþmÏf· Ê£:L.Þ…+)LYO&YœùzÅ£ÈyËš:î†õÁK[Ö¨™W ¡Ú²YÍçK? ›¦F' fžõ˜RÌ8; ~†à— ŽÚkÔ™WÅË'&ydY«c+7!'Ûè“9ÖW‘K‡Úþ‡j¾°žWÉ‚-™«ÎãÚNË)N©pÚ7ˆûÑ–¹®¼Æ–°ƒŽ=…T-�¤“#õDs áÁ$OaXe¼%¬]úøíW H· m‹Qžªxñ ËÓõ) ÎxVžæŒ»hoKè¾²‚ò™¥ùKé·ÇÁ,*§íÚôI”v­¬ÄuÅjKIÂÝÑ@®ù¥^ÝÆÕ$1jr"4s¤C ¯®—Yâ€Å§…Ã¥Y­:®E¼q³±p†þÆ£žqZÜxèÀE¾>C|@âýĉ¨^ zNK˜dºE‹&µêÍZ€ÂiØaÂÝ ŽÞ?Ò´ª…¥^°ák%@&¦)9¦VwAÇü{SþÔu– I{8‹’¿:ëÁàJ6Ï4K^ .º¤Ós€Ï<{Ù²JÑõ ^‘äAí}Q ÒÊ؆ÛAÒŠ ‹dMŒ}çÑOÏéŒq>3õ]Т*£º‚¤š’\õ7¸Á<|Ó ÁbVþ`—œ¡6kaÁ÷Òékå¬0Ô½u^ûð{¬"˜ŠƒÏóàIO´’¹Åý¼þ«xãé•r±³3êL]5,S°@g2ß+ Õ<­¥UËÒõŒüÓ_>‡]DZ3Q§AÉØ)K¸4†ùðŠšSn¥´ ˆt,¢¸S ž�ˆ¼t<püN¶œ×”RÎ_;l§ßñæ'ˆM90ÒÕ¸¨ªÒ¥õÌcül§F?er‹Ÿ‡ä_àg+ã—S¢¬í§:*¼‰ J4Ôà€›BÕÿˆE\ •óÐÚÐç$(2;M0?¤À1ôÇ꾞 ÷Ð&>ÒŒåñœàD3rXÖ$ÌÁ¡)t+Äâ@\Ú`â~óíŠgÐ>ÜíÚ!#JQ„U^ëج8¯¾ø Ñ“KeÛ©Ë$lìZŠzã%@cZ*þØKàFT²]•Û÷CšX#"ϲ4šÐb©&…û`òÁÈ^!„»Í†Nª �¿éFÚ¿N´yè‘6 QYo JÃîE.m­XèŒ (øNUQ¶ýò-0Xbˆ´•{5,£+y-g…¯1ムdî·ãÚw«±QG$ n®ú(]ÎJw„ðñG«§×‹þËt.;ø;@ʯÂÜúµv¾°š8¬ÖZFÙûWèqÐñÑMGÆÔñ\jÜ1{6c ôz+N ù±›ÂX^–žÊalœsw­!Åô­ôh=«ˆ ÷ˆ{’4zÁ$ŠUHˆN¬‚§ÿÛ ÿ[ŸEüåþ7Ú@‰ÿ“%æ(euІòâ¬éBºzÕ)wäo3@ƒð¼'ª j¥‹is]wdí·P^BAçGŠ¹F´\gôWib€Ö.3 ÍŠ+£5R¢¶Z5oËë€.eÅ~\ÔŒô Ä\ž/�çøüÎŽ?þç.¿<bc‘�5;í}¨X&ã§éça†Ýv¡úý¿IYÖÆ ƒO§Ý‘Â’(í{¢)Ó•'Ö‚â3ÏÝɶ<á[WÎp†¹TÜD'öÉ%ëÇWÓǽàìòlWÖqL„Jݪi{ÓîÑ-¢²zÃ^¼Ýf7E źÛ<ÄÀ‰b¦«í?`Ù¤Æ#–І ½CìsSŒ%ÆÓèAh3‚N%.eÆïŠA%$£q&êÈéJåƒ Æ~ªo“:À"ÖæZn3 õZ¤blrp‚~>=¸ìFZú2§Ž66@¼e îíRE×Ã0ˆHº”Îô»+% «Ùå«{Σý8`·¡ÄpÔ-×vÝ–noÅéø2|^ݦãï!po™é…)½ØÊsy€wð¶zνáý°ÕNï²ÁQĉÕãKWÄ;öÒuš&¨Åï[£«ÃU?J¤`qýÝ8£0؉LÌ|i_L¨QË–sS¾En1äÀ Ì|hòîQ—4*¦¯íœO ÖN{QMÿ„.‡j‹Øú>§ÂÚ(áY‚w¤·¤„—nÀ8^úž>ç.Ú\hoÑÒÒWÇYó�\Œ’ óàa¬*ï�q¥U¾ÿ}Kªî¡ÿMµ™(Üü$vS.¬¿pKØ4JZíÛSjˆ?}¥U[9³îÝ{ÿØûîó’8®,¸2Á6O£|e9ËniHÎA(ЙŠpøsDçþ‹56)œ49ܨÜv† Bÿ§Ý¸–>¨ôIÿ“ŽÊ¼¹’.¬$WâäÉ“þb|®QÀ6KX_<;†%Žgўͩ|÷"g»½ð ¬EÛËJFóO ªG¿!?¼‚¡’îdãÆÕ/à»ó$ÔÄ8—éOÀ!]æ¨VÍnr”Kç°ÅŽ;þŸÇe€z§åÎý`¢ô<ýZ›îêzì–è§ö½‘³hØJãeŸ¹En9©ðîéÔÿzÍ L®à"§màÆÛW^ƒBŠfÕ™'¿æþåÂ0Œ)pCÆgqV#•Ln©Î¹$·Bïä{~ÒñIÓܬÑ7[n«¨<n 4­ÇhúЭؖýÊÙÒšŸ«=Ì¥=âx¦È,‹‘bcŠQŒtEöe7µô|¢5%<½-UÓE’ƒ ªŸ–”gׄî¹åç¡–w–ƒÌ­-d’Û@ű´QÙˆíÊ¢i¤Á~‘Ý0Û’’ÛÏ1ÛD ï*bƹ"Õ’ýämà“@œðôBÿÙà ¯ë w6“*a¶ËŸ¸vðµÔ×–Ô.­m×Öq’ûô9)ä}ó 9›ˆ1R7â|ù­Ó¢Ì  ÷F'G°k<Oì è6¨*o­ .ÀVv«Ð%Y²ôþ/;€r'ƒÁ*‰e»›«ÛÞ›7{g=ÊÌ— îÓ{ç>�‡Ôr“Ì3  h6Ü^]¼[Iñ†—éMç𲢂‰N Z «ÃÅîÜãîõv½Ä©áÖJ*¸¦Û½�àY‚þÙw—IdzÈÝ®O.®¬H,kδÁÓ•Ú3ÊWžaˆ]ÓEÕŠœyoN¦÷;5M­¿K†÷.È Z’C‡%ª|f#4{ ¦ž›É9…XÊYá;ÿ¹ ) %xœèýÚÀ(VÙõ• ADùÔÇþ0Ž»ÉŒjÞ†óIÞ2yiÇÜG-¯; Ëšr@Ôrμ(c¡F4¼`Û0aã¹8Fîþ©'ÒÇ-¢l}vq 7˜ª’åÖ©lo›ë…‰äI=gldqnŽ/¶ó΢zåe -}jzÖ7ýW \bY`)Ÿéç1ÈÆ ¯`ˆƒ¿6ÝUú~\;(ëi¢ #=7&óâ/Ž©ÉÿŸµ?[o”[¶†ÁcöUø¬NÖª‡¾9! (eåS÷#b6,Ér®ïoRØï^²sÆŒf4ÜüúÙcÝ©*)Ú70Éñ%hE8înîÖÐ]ܵµODÉ'œË&ßý2,?fÃ*çú*øhn~ø‹Ÿq()ûlè· ž°oÆù¦mä,HáFþã÷)lš•zúŠiAY¬R´aaˆgµ¹CB¬xƒv=HMoœÆÞp.è3{—ªR” Ñ í\‰™•È"éûÇæ¬÷Ë, ®(…il³ÚŒ,=Ít¼é’üâEî`‘®`]ôǺM4姭kÿÒxž0ñ9S¡Aâ?oyøöß·ÜȶDÿ_Œ¡¶ÛÉv‡ŠªÞN3·¿ŽîbQŸ•‰àØׇaVåÉ¡•3Ø_}8UgCÒ‰Î�ÆÞ¥¡(B Ä»Ép—_„0z£ÔØèÓ,è³{FÒpâ$ ^জšÃoÜÊõùƒ*Nµ¿@ƒgÙÕz”Æ,;×÷Œ=w*¡ò¡OAe¥M>îá}³¸Ð*·”‚tz²Ï‹r½?Íò‘o,2ŸkD©/3„$KÐ',nõrWÕß®üUÃÒÑÂÀx÷x*È„^»yƒ‘”·¬'XË ×d0ÿõaz;Õ?cËcu"2½cî¨D(?ÿªBõrbŽÕ©3Ê^t¢ÆŒŽ…«Ï¿JÀo+öš ²Ö´!òÁîuBtÏ4qddz×MÀö©¯¼=ÌûGøSa†¬Zùd„˜eB段ûopftÔ®†Ä§ƒŸÂÁX:lþêX³µ·/°í\0Í8Æ}j´�HªÐ¦Ÿ™?ȃünν‘ÝRÒÎS©×,ÊË£½Ò8Ö³¸,c·Wg™ÊX4éöKçA–K'°ñ7~¤È.F[¼+’ ÿtn˜cõuË5åMòxYëRœ_qwK•@£�h*ж¶wÂ_ž½Nßœ&Ë”CEÌX£nçãÛüyf›ÕŸ5¸¼×·5Am1=›¾¬^(Ä´kxýhÞºòq Õ¹Éñ¥Šn­ƒØ•×ÇÆ¥oô-ƒ1‹i$Œ ù“Ÿ�ÍŽü’á¾Vâü‹&<wœ*kÅeH×óLÉ ¸)ýuXÿ`fvP?ù¶ðÊðÆo.beg‡óÀö~¼×‡ÐþöVîƒßÌ,»Ïhqœ- m7º¹¶!�Ù„_q_Ùâ±ë2WŠ‘±øµ °bÛi·¬H  TøÂ…�ÐNöif+¨ŸÄx]î.Û2 .`ðL6ugN+•IÜGâ¶Xx„ç=ôev‚e\åâL»ü¡·í\íÁNµ5k.R6ÞØ<ûéVI®H]ÁG[ôH ïió峉Ó<NÎ\í)…îÞwQì?~C”“íQ§ìêxšé¶Ÿ¦õÉÿéeJœ§Ë „Âá]!`áß.Ý£±súm÷n'Þ‡6í_:T«Ã΋(¾hº\f¶†²Î9º²!‚™>àtÞIG¶HQÒãïèáÆ‘¿!ÜTvI$óèm¡äÚÒ:´ãÜò|ŒùÙHÖÑçötÎV¥õ$_"v¾Üæõ¡=ú¿è#áMÓt³OSZEýŠŒÜ÷¢Ç Ïà’š)b÷æ›^Ï@¤hæ© ||ðhÊå»þd5Ué1òm‘—®žmĶtB'uÌ8PE ”NZ>{Øm¾ñ!à¿ËcªÙ´WÂD³§õ>ØƦ3ü4}E¡„l^cÖ‘höFÄQªUœ ;–?ÀëófÅañ0™Çþ"´¹.òÝò¯ÉKSeÂÍ·}@V–χoR1ròn`tôµ­õ0#C‘WÆsuz ŽäÔþ·I.Ÿfb±‰a„¿Ñ<U≢~‚ή>£ÌlVŠCp�ºÏlÞz†l¨üûÛI‡ë®f¨=/e/bðÒVfŠ¸¾ o½é¥¬÷• oHO$Lãf®äK©šl;;§Sd”h;ï©û˜Ègò¢ŽM˜ò  à“J§51pϘqí2¶Sí@KT]ÿô¾š«ö4¦–"n2Ú]�€ÍÞZ[ªÿ¦´¿ðS7Nq÷9UN­Í=Ì»2ÇÑùÕ6ÏLGôÙÙƒŽòë¼ø/ó,Ñc ¬{+ÔçNõ8âi6võý€TN´¸ Ñ]„÷Ü;QQç'è2RµoðŽk…yÝt—ún™ïÉ „Ú†20pX*Ü¢ËÁn2Á·çOœ!WÊì[F T]\læoaÃ5Ü—èà´:P§³³zx£}w¦líP÷oÐ Yºß˜œåÖä#²ÈP«¯ÑçR3´i{hø8¬àÁ°K¹•nTÄŽß°ã8^ã´ŽaP´Ÿê ¶ÌMƒ3À*³ïw¬×ÞÞ®¸åT këí§-*¢Wƒ"í™be-ýÅ7ÿÓ´è©òÁâ5•ŒÈ¾«®|RÚÌ»gUuºuâ´é—ÈÑ]!aÖ^SË'ÚéËv…�03™\¸)=;ìÄT.MÓÆùl†™ÖgI„« *72I¿ùˆ‹´kåfP0›Bj>ö*û"H?ïò­Ò¶_ò“"%æ+„Y¸úf½²‡‚÷ìøÓɤݿ2÷MKŸÆ®Æ4°kÌ ¦tu¹]¼Ä×mÇ?hr©B!‹^]Ú„–ëâte÷”p™=–'µõK4št\|±£+Ó\Â2Hò1€þ(o…«Â÷¹òJ„ŒG7Ò”Ã�$àóŸúuSÐ;g%fÙ×Cæåb³½™Mß–”ó‘DÄDd€aIZÛ^øZw¨P£ˆŠuy鳿[™ÑYFl;ßi`Ø$Võç·G–kB˜¬-{MœmèkJÙ—«S‰kè`‘–Ö3…ɼZy•À�Æ~ß{ Ò}m‰¨œj®«ofÍYâ}Z½×ÃÇRÔ’gÂáå°› %‘_éÃSMÈi©ùÍ7I»Ô«{Š#§°Ø«Ü&ËÈ�Ý�"3m•ýÊkUK È@m ú§l£�– ®Ò¨ie|`™¢LÅd ŠoæÄI–i5Æêb¦ çÿ·Šx.¿óR»5!bí¡TÒŸ)9tL¬ÂÐù0ãwZ—g¾¹ßþÕ¾±)gš=Æmíˆäèœú훢¤£öÆûû ^vfðéçŸY¢óXk›\íkÃàæá�­ñ°X-öŸ}“£Lkí!ûnèc§ï;@‹À †Ø]H÷Án^¿ïwOH+ƒý¥`ƒc=¥Að§Ûчõ�ê}ݶõ—Á‡ˆ[Øíˆ<)¼°œTÒu­E g4PݳÙ3¬œùB¬£Ž˜zn–þé¹*›§ŽYÝÏ£àpkSh ðò0ª=ç+FÈØWB/œcÊ÷«‚éx„ï³7€þ�ñ§Vû=àæë%%rÆô×­Ç®ë‰ýFÍ©uë@«_œjËK†Ãì¡ SÊ&úT�&z®£Cjyví-òöçH•i n”O{û±1Û²ž „ûƒAlÜi$º¼,¥ú£•8ÙY`æül„K[›Ì]ÜCøÈÏ 5°0…Ùž�âNœŒ®8æ¡;¡ýv…¿áLÜUû£$zfYÏ‹ÙàÀÖý9l–Õš+8×ÃGw}…Ö$+k¡„û- Oîå£×WQ~5Ãï‹GŠ³¦82¯or¤J®Uo3'i·Vü.‹›°¦B@ŒŸÿ'i«T!Å…—;íbXKï<O”· î2˜Ñd~ãFᄬÐÛüA÷©³õ`ý ²j¡‚çc˜wÿ0øV•µÑÙþCµïh󡆛ø6!JNÃŽ°ã2*Z?BúQѦ}]Å2«ÈÅŠO´ðy¬~é0Û¹º×†#×ɘR§Tt9Žh០òÏõñlÕ ¶SÍ!ñ„vª8s£Ë&0ø—A¡íÇîA%[z…`‰ï!ýxÎœUŒÛõ 2›ìÈÄ°k'Ô6ë_„l3<ó°f4”hœÎííií$s-Æ }ºV#Ó"–ÉUœëŽÆ#œM¦lƒŒÚ`¤ÃƒA€øÔHåŠä'^ïùbx¦¸Ç´M‡•A‡§ÁL{­MÁ#ñŽrÕÖã`¾VAæÚÚ Ë¿LôŒëE§‡y)Ù7 'ë-?ÿ¾¹G¬à"¢µ»ù“Pyü>ùtmÏ Î,ùá'ç‹ØÁ"¤8 ؘ;5ºÏ†z²N;¨×¬ßC$NRxf6wiIÓý>_ÕÇ=»ÚixܶÒûá{ýhQ—+ñzjË'…ˆÁ:u,´‡ëá ‘žzw½s¸ëÃNd"n„XýqÉù åþÓ.¥;üyñÞ$šúMÕíE°Íú²™XÅÒ0ƒwùö Úó•‡MKi°]ûÝ~kLX’ ˜øßX_‘õË÷[¢¸­¼äg4d+g‘01L8îÔP)Ù-Wt«Ž&ky�¥I¢V' ÎMÁv“©£%Sð£$_'lüéÛ‰"×?<5šJ½tSÄ«~ ƒì}Pý&ÐÆ$QeÕ©~,¸XªM•Øþxî¦ã¸ACÍrͪ­÷s'< Cí4ŽÖÅÄÒIÇÅ™€ôíEU¨µ‰=Rh*5MšŽë#"œÆ£kÊÓ­×ÀÃ)’*?<L"ŒòíÒT™®uÄ1 µÄøÍS^M¹_mº¿ Yù±4\Ö!\EïíÂxm]ƒ!+ãȶ¡;ll·}¡ÅÖß;Ÿ<î¢â[–óLçÓ—Ö¨X›bð|6úþÔañ‹ßƯ§Q ä‚#:ÒÙ4ô¸C—ff…ÑÛ¬iWs"xžxŒç¶^NH¢"ͽ+¨®e;Íe;XüwÄrÖOdæà„L7ÇטÔåâ4^ñqiAÔ8Â=ò@övJ-P‚Ý€2Á vë{u_ÎÖÁ®2ƒh‡8È:+DmÿvL2ê;˜ÓgèÓÈ%æìcÊîÂyPtE÷æ;£û¿—竉N †wÊf™æY—=ºäKÆ™O·ÛWOë® %ê£q·9åAÚ[8Ìð:LfÆ ~×æ�¨ÚdÞ’Ÿ<5¬a®ß>Î}ýVbÕŒ,£p~7[{ғΩ‹ íw%?®¹Þ?¿‹*S¬ ºãËÉÙɇL™Ý¼AÈŽ¶î¯�ÒZ•ˆòq—…%/+é·Ûн;P×vÊÒÎ(šzm-³íËšŠåeûc#¥XŽ>>•!£šÉ<j£¦Ø2ì(§j5=? QP"mêr×µÌéý.6-ÂßrW¹m� ­Æ«Ñ#<ÐçkñUDEN+öPÝ‘ ðâÑ£0<?7”‘YçlÉy!hém‹¸Ú÷þâO¹ ¨dÏŽ]ã§ÒfÙœÆÑp"éˆG/‹íö¼¨Xn\§æk$ïʺæT@ƒ>ÐÍm|ÔýÔ]$ûy˜Š'+.;T1Þ¶\Ñœzª²-ÈòîTø΀X+/0³yUH64CVZ°à¤HÁÖKÝ>¡ 4ó”ÓªèÿOïŠX{°iÓ zŸÔµ9/ÐÛ³�Ælɶ·ö}O|ü´^¿øø5°[¨-s4³D¬Áº Ñ—™ÿÅPËqL„˜Ia¸í²<ˆú¿þI{mthÑB2N<H»&ÙJ£Œ{­×·›-’²ÖÇúàr>°å®kµ™çÊ3‰Í²rƒµšÓ”…˼Årmocù-XÞPÚåþï¾G®¸ÂÜšbý Äµ¢3Ö¼*ÙA#ô³AKn– ~AdM)o»ÆN–:Óî{„–Œ¨Za‹ÁRÿ¨¸âO\=»«F0£29Îöî0Þ†»ŽëŸ@FqBå<Ç>:Hwý­ ”¨?À¶Ñý}Þ½£ˆ�ïõÉ+/ÇÏ Ì|J)íj¬î|d.WÒfœ €gÉ×£éQ>QS{û(ú9†…äå™öÍþ­|ftÁåy]ð$(Ú«m•¬‰Ø!CÝ®6iýYEð›W ),ŠD 1U¤óÕ÷)ÛîÏÖùGÿC÷vüu·QÇNBÈË@§`1*¬«²Y80úçŠ1;0ô7Œ¯á_$À%Úyï-&L•·ìŽõ`Áë7Wp$®Yìf‡‘Ž¶²µ2(¶¥5 /\ª?`<Œ¨ù)è®ÝQ (ÌÒl5Óêa¶1å A…žn-«9üoÌÒñÚxòâõ0$–åád{F1SëUxœGzÎ>S¾ÿ|ùßåBo/Q̉šÜþ¨œ‘#®ÞPNmsÈ9ÐT±vÜ‚üT-ØfI0ån××´±¡krÿ·JöO6Ý8Š´Í¾,9æ} }IŽ ¥uƚ’0˜}.­ÖCè;6kÙ%ü0Q çJ¬„ÞúΞìOGÄEy3qž?èXyo”HPü´+tÑóbë^Y‰ó½Ÿ©6é,^1ÀÏq=û÷éjŠ•?>o&z‹UgÏnL©è™r+É$#ög§»ø‚Ãv¤ž/ظ𪋗O¥dV"oô›:§\‘¹‹“/ëÍ‚ô•‰eÆ2ÏÍ@Ÿ\ܺ: m„®¦…SÙø×Mܜ՟›Tí£ 2%geª»ë12Í2ˆÛÖtðØÞ¯^LçÈ Î_&){Ö¯‹Ò•÷0=Î~¦l¾rLe–p©¥QêàR·¶Žïz·‡ôÎC]|„qÐ}Au¨Õþ:ÖµÔž(°¾ê è`løîYöFQrÃŒ;}Q<sÞL©8K©ÒïãÐZþº¤}"œVo”„  –Šbþ`EÉ"h|ylw V¾ä¾?„qèåO‰Ã Aƒ7î¯Þé™sCi°8³%°ÇÇ"Uùä1aÀ Ðxí ¶¥4–”2âÞ‹x¼¤XióQ$Ü!^}_›¦ôÛ†þêyþ7é¸Ðâ”tØ·û*(ÏjxÚד·ú:‘°3±yX¸êX ©š.aÅ(ùiÙ×W|àöj)zÖã¸ïjÞ¨²<ÑAÜY˜p>Ÿñ§¯[µåF€Lx õ`x„hSšÏn´æc¯Rd(1áŠJÉNŠq6OÁ¥™7ÈÂà´Êîü$ú¿\í0Æ*FVÙtQ!Eø@ïк©\Œ— º¼ŸóäQ¦XðÏÛƒ“<8‹²’cÔ <¼ÂÏXs54¢âŒç3ʱWð_G 5ÁçGÛ¿HÍ|¹‰À&íÍ;ß±Þ-­ˆkÉB �(÷ìTñ?·' ÿ…öH.îÙŸƒw)!¯[ëìoÚq•i!zLSNt›.ö$§Ý%ßj‡"ë5È|ê<“±tŠ i² 4 ‡èí:ÊáNòyÿv¹8öÔ›€ì¯C ¸Ö {¹ÔAŽ–Í¥¦Ïi p1;:t»N‡þ‘&+ÐIVø„‰GZÐñsG:OŒÇ­4ã¬^äÔ‰r¥53Zà—{nÆYyãnÇj¦õ»¶Ø«�ÞáÀ0hû?*š¦Q¸VSa¬–²�‘ÓRvs“¹âÏn*Y®! Öú“PÎZ+5I¶­|J`jõð I˜d…öIl(A‹F§“ 8¥ª\Š*01‡biµ¼ÖŠXw¤RÙbÏ°=LoZdÉsvgSù;#Â2CkR:üàûý©?ºÝ(t¢¾DB¯¥(O%åÞŸ~yöõxÁÀÛi<i–Àê'« b>ú Q´rj£m†ƒ+<Oá‡ÿi×xx$ò5/X•b½#Dû3{R:³v<ݦÃ[žsËM§ 3ÛlÌN(SðéæÃÿ ‰0±i˜lþdA¹ûrú{93 d²ëÑQ?/Óª(2Eƒq’Y½± <¾Ü<ŒZež§IDåuGµP ¡èQZØêêÝzVGNŸóƒêª«+Û—é<Ì¿w&09Âý:ª˜÷-­Ç½÷J»¹ƒ€±PJ·?·”DÍpôH*ÿ&¨˜Ó±ÞZQWȪKsľ;zøÒ—NOÜÕ ak$fÆG@dÂì؉CÓ¸IÍÏ؈ »¦]‘cC‰Ì­m OtŸ•#a }Þ¶vlÕçB·´¸¼d ×ö=ŒÍÐXH=t{ECùÂÞãtoürâ-ï¯V4]·¬í NTº Ü}óó|ä ŠÚ 1P^Èsó_r®Q¦«hSRid£…Ë´H¶‚·ØžFpÀ\p1¿?1×òö7À.)ÿ³\)éHwöùQœ†Ãñx²„M(úYq7ùá‰pl%bÁ¥P¡8YL*%r’b o=&ÝÂì·†VzgXßz5+ (æw ˜ójïR‰þÇØyCÆþºÙ‡å—ˆNŸlÆÆí®í ~svè·”»­ôuÿçu]Ø™fæ˜ê¾hùÌ¢_q켨DÿQk3¼Ðµx–h5@OÒ*Èk &¹(÷!M'Û]¸!'¦ô2h¸¼¥Þ%2Þ°´NªúÝ«µÓtšÜ‘7ÍèþkbǶ–‡ººÇ…o‹ 4zè’*ˆšÖ¦˜5k aÇ 4ïŸÐ«“¨Ò 0âÉ1¢ËÞh“°fUeòfJ·§=GºÕæåŒZ-9¥…ÖU¡ú~<ÁçÄMp°C¥•YE׳ œ÷šyh;ÇU¦X¨¦¨Ž“Ïö —ˉ¡¬3GŽSRFãŠ!­´M <uFèØo›,5¾ŸžÞÇB¥AÚüµÃú ¡î ðuƒïÆùtÔÿò]汆B©‡ŒäL©ƒ#›ã²#¹¥o=ŽHá”Äk¨ª(Öµí¸ãGNå–md#qh»/ï¦Ô ’ZÔ"~åu˜gÚ "Š°æ])tmO_&?Fþ½2„aŽ&ÿ„K/³påAQ—¨a{ùven'`Vø÷_\; eÉ*ši¬À;À«„Qh2=^—,òLƒßCkí$–Å'“½“4?Agd¯ñ 2Ö±¦ ÿÆ%vg / S¦jŠ"¾Ì—,Hf7v¢\VªoÅg–?ƒÃï'Ý÷¤ðæÌü`–½—‹L–€A/8°P¸H í‹Ô´´–JŠ‘ ÷4Q»71ˆ¥IPr ä|ÖŽþ¯(Wø1dÄŠ ÙÚâ •þR[ñÜ|ú 3¥’Ã"­èGЀ4Ó"3PÂ(gÊ jî Ÿœ>EÍåþÜÕLR¡¿Ð­Å]öWwê^'$4ƒªô’¬›l/AÜ‚­™ˆ Sæûñ²ZDR™ê¯�ÑÖV/vÍ d㦋 ÷É5¯O} —+ÓÐd:©“AãÅf9ÆM͉šúÒvF‰Ä%;ߣv–Ù Ž\ó12ïVkºÕH£¤+)óò}Ç+±GZ.ôh“ ßYá.LÆiçž,GPØ^¾êÛS¼óX‹`c¦kÕÀ$ ’þSÉÒb\ö§c=϶ç.û|çb={ŽŠâƸb×ÓiŸ~Úrq¢´FþÈ\¡Èÿä:hT8/¢>§.¿‡è$T ˆ\6{Šu•“ˆ‚2JÇ©0RþµYš­n•íäAÖ\}7Uç±g ˜7îîÀ4c:çæú”¹Vw¥·ÀÑ 5<g×â†5Û`'·;œ–£¾žº–þ»82ôæÎÞÿ% iEä–BZTx;•:v=4Ã̳ùÞ;ª¼QV­ZÅ)¤ì+–²÷#@&Ñû™+<CwZ^‘I¹â«Â¶eû¹¬l]Ïj:ñZ~e_î;i„ ‚[2ö‡=Ÿe’Åh›Ï”ózé¤ç Q›t87oxý°GdK§‰iÞ‘òmÜ̾û¯hRÏw~#½'TW«´À*[ ÓÎ`yÖÅ<`bñ²(?ØÊì4Ò}NŠXûsÁÀP“½$ Tûbp6OüøŸu;ßü ó®Y©Ž.˜_Z™Ý´¨EPärusƒŸäÉíÀÆi>4{|ûÚÛõð#ÕyÎ @«ؽ'"M=b'Ž.ònq§™a2+Ößèàäš‘`Ú¿;gôæËägÃéËõ“y˜µA²Å¼íñ8Ñ(½©¢ËLͶ)Cƒcs¶¯*{<Qj;ýã„2 µo<µ)I‚j°nÆ.¯D¶ÙF”hø°kƒ›v¿p[‡c½Þpo&y"á‡%Gí)ÌòùíBÜN¦¿ö ÉB%Ÿ$œQeÐp\w¶ cY.{jAÄêŽØ«ïS_­‹¹bÕÞ2(÷¾!3ÿgû¾¼DÄY`¥G¾!ûŽÁAV-Ó¤¢F %OͽÁ™UóÙ;x=l¶º-E×E_>qkH’8Ó€Æ$8}¥Aa ‡"ÿÈÿStÖRá«Od W^Õ _’ ®-NnøÖó¾¾XtpkÄiϧQZTcW¬ÁŒÉšUb¿�~m‹‘@¥5ÿô½¦ãu~ã´¬tÉëý•+ªu“Ž[ô›=è¾ÚœÖ惇,Åÿ`©äRCñYö˜J—õǬÎØ;9Ìg%±ÃógÂB4`›wK#æ{”`Îû7* $3 ääE}ê4ô(Øì監RÃD£È¤áÇúËÃ=oVóòö“„ÙŠeO¹Ùª0‹‰BæÃ…ÀY@Mw¼+ÝlƒOý¦ZžéQ°0ÉÅûèÙž‘z{·9ÅçH!$–˜»yÅ3Ì3e¹Á:JtÒÏO|ÝÓF¿ÎðÂòåÝèIÈ1JÅê‘ ›×xx!J* [ÛÎBh w_o|Üü‡Š~ÓÃÔýõ¦…ñ¤Â² ·(2Ôñ¹d²û«Êˆ]¥$·kp›˜ª-L_`,´ï\·þYÉÛ-6Åh›]ÕœðDU›D\zÓY|èzh£öÆIÒR÷½á4Ž®t<yuª”(lû3mM™ô¢ɪ �C1Fï[PÏ¢Øßñ`i;íéè¨m÷I#M�Qü×$]Mctt² ì²b&£Ëk8O”ÏÒ�YýðØXD…LŒN+´¤ƒe."f @ʤ¢ Xá?áYŠ5Ÿ> .h‹ƒÅæebi>»»ÿï¢Áÿ?‰ÓõKBá=UïW#lymúßœf¶"µêoœ§È‹3:>Ö´Kés7ƒÆ8ÝR£uähÑ/1¦KK˜`¤6ù{|T—“X‡ýloËïWM”†Z#�p–Þ5vn1PV¾poqJ‡KZEÄYØô¦G@?!9· çy uÝ2*~vþpàîñ 5éõòÎÈaXÊ_ˆ?Œb‡Aí7Ø‚×~®qûºÖ�ôÌ~SßCi>kjEoÛÖ=w¯¬“çïdæýX_t)eBô"G\­|­Ä|cbí!ÚgƒÌOÀ1Óbå_ YŽÏ&Ù‰[+#jî;e txÿHŠ Ì€ ã) ê‚*}t͆;Þ„ôÕŠÒ�Î*[Ý_•%ô'äTkÄÜËÈ‘�õmòìßDë¸XuÇ%Oè¶3¤ËøNÃ5â‘[†’8’r¤Ý#úë$ÂPŽX—@S(Xz4ˆæqÚæCËj×ï5¨„ݧŒÒ(k.Æ*¾ýJÇ\G?MïÖ׊]µê==ú½:âSÓÿ¥ü­ ?<) Œp‘œËW;°Æ3x¼ˆâæò*ån6MN«Òfo×Ö#„sV6^\Ó6Ø)Sõ“‚¨»FƒmÇü@Ýì-ÎRIë0ÕnP¡í‹Cj†Ý�T¾wR—©ÅÀÏ¿RSH´«<Ö!©”ˆ;ò²‹}vð¼¦ûÂz·œÿ»´"§k1d”2>Q÷vrxóÞÌÁførF9ëžwļ¢Ì0îŒäL t>Å­j‰ÚoüëøBI+݆{ÂÊ©–}m¼yÞîL�%<m¶6ç½sú¹yÝ ÁšÒòk¡·êÎnp/«VíN=å·¯¢„‡&þÒ€a. {ð1œ.½h©°,žSAxuÏͶûÝF'„•jÊ2Ð)övÏ\Ô(ÄùÃè_ÚäôÁ7vT `èbVãÝ…“W.~áorBDïv.سµú½Árb úpê¿ÿkê¼F1VF±µ(^@h)±2½Åí<•CŒ×_–|¡+‚Ê+í&œ`r1q_ó”óRnR†Á<æAä¸ lS×WrxtßM!þ€jé\$Ks€óQ—íl£=I±Çºë›18´!áö¼»9÷¼‚.‹!%ÀêRÒ½,ÊŠvË>HÎÊéžÂf¥8òRcwô‘¶–€o5X²D;f…c¨¿vÚõgœþOœú2# ¾„áNlË ÁŒú`d›=¶ñ·B|e˜)Y_0±º4Èß-g%)¹Ãya5zÚïî9BÙÎmœîò¿TÜ¡ÊÊm˽(Çú^虯fŽjûo‹"Óï4� Ëy¹ã Ó:wzg/8Òñô•ÌŸ'ŽvÅTŠ”Ê f1ð³6H¶*«U˜«0øüU·e¢Õ�¢òÊ>«®Ð½Oöëó–‡-Óæ½µi_zÀÈí«Oyß:çÛ¸ •0”ÑvTÍ~‚ Ì…½—ñ lîÒóòwjýæp„ÉÅü¥pÌv"c]d^åM¼F¦ˆ¬ñžâ連#´ ÂþÝ5gCѧå¶S˜Í‰ËŸ“ã®Í$©üÀŸÛ˜pÿŠÆ‚ü7uïÚmË y' Lµñ¢ýÙ‘WuÙy2ßQŠUî¸>:ýÕVë´â'g?Çq­ Õpƒæi26*øÕMã;±T³X^Š,£²í…üÔ£f”}Cù}>¾;×lDÏkþV7Ûã8"Ó:Á‚¾î­}%N¿Ì¸¸ã¥†«Ýà(n#ÇBÁ®»Ÿ[”Þ7ÅÊùR=»š™sc5óW6—ãv;]ZÕÿ{¡5X¬„ƒ1Qª‚rp³ã,ð¥li˵p¤òø¡…Sé±”‚v¦dEn–}¬>÷V@í‰ØZp˜Ö:maÜÛOKqöö]c>#nx§^ïºâ9‰kC+L)ôƒ3Ùo_¬0Ž` qÃÂŒpWc fÞ3÷ ”…›gH%U1}*áò÷ó°ñ‚ÈHŒœæKÁªÊÔ Ša»´] CbàŸY ]ç?Þ[øVù™£x%O9õœäAyµ'æxBK>õÆÅq”£î›È—=}ÙrÝ}Ã'þqëtsïø‘Ælöc8"qmä÷˜mb²Ûû·ZQ櫶ڿˆîß\+<ãÍΊ°}WQŽ·y¬o| ¥é)æ–ÑwæÎeîvfªa„Up†¨‘JØ)þξÞ9䕇חE�jc0JðØ-üL[hk-›pOÓõ·²ižiºKLGÊØrÇ0fntÍÌšÙÓ³d9½í)N«=_gú´-‘A¸ H)å~ƒò þ@™|õéÈíU`:«2ŸîŽæ4îœtÚý&zû#M`Þ”ŸåÎMSG ‘ô¹ë¶u˜¼;@ƒ‡6Ða~#Äðé²µðÞ–úQƒSAñÅÕм/ )|XåÖ)‹ðž¤bÝY. AL¡‹+ÆÐ ÍÛ¡ž×»…’£¨ÄŸˆûºŒFŸ 6¸Šÿy³ HÐZ}àW@ -|ÌË'àÉÕîz ¹1Š§gü‡»Yüø;£à*³â7ÊNË]Kí¼‘30ð‡jöM9dû†jiUÑ8<þ½«ohQvÓÕlæ´b‹8Ç*g5Qrb�ŸCYËéã¦o7?*Ϩ¨4JÆÒçýVu_/¢üç)ª ˜|Š¡w]Ýûs”1oš*(ÜÛ²ZE½õ« ²Ì I[·?c/o”.`8$ƒ /ES$+¬vN뺯ð±t ^­¦æ: ìdK{ÒŒÆÕ¥P­*iÖ+ª¶[‹ù Œc‡À=¨´ç‘Àƒs÷¡ÐH gAÚ´ª6læ‡SË»¸ëèÿòÒßUFbÍ¢Âb÷P‰ÙfmœÖîÅ›‡æg^ ?5>¸C—¤Añþ©´93ñJ«(-’yòÓC£C%ãy`›€LL[ÕûÀ“R'üFêU©ù›æ1™ŸG±Ÿôå¨P”“5{0Ž?<GÅ4ñ17 ›#E~týªnÎÃŽÕÔhSîƃ‰2–·Èœ<wý•Íú*5NË?ëíèg¬ÈlZò§i4匿zø˜óJ‹ÂÁ`ëRùüiz<=‹±9· ›D�ñѲW)ß/HŸ ¼Â_=ñvsðRûôäktP«OË´LEI“]?g&÷µñžp—®Ôÿ‡›B3-ìâ:ªPQk—#Q vèxÊ9oÔä[‚ovÿåyYîpŒ‚5È0ü¤µÐî\£¦‚+ E[ÁTó¡¹;Í¢d^×¾ì l™ ´B~:[}_”)5ûXó0t£Lû G:N+ Ϧ'°éó}íLF'¥TÏÎmEÓ»þmÏ›£“ìhõs[oNÓùøí)hÅ3(}@1ÇûO‹¡e¹ŒëÓ(ÒL'S�ú«Ô“Háó&ðîhqE{ 6blìˆð×:¶èI\%K+]*ž´0…-FWä24àbSHvÍÆæŠ>@Ëjé~#Ý•™R_€²í µ0+*€aÅxõ°~åîÆÊø$ųòrD* 3t?f¡‹ý£©O™e¶LöÙåÒzà~M mÒ+Ú±Ãr¥Ô ‡ö@ðí+K€®R€Rì—aJíq…\))Ò/÷´µME¼úˆ”ÿ´n)L¦¦„2-[cÅ%ú®øzŠžÒÙ¡®ZŒÆê,ñ‰»¡ ŠÎÑû#c¹¬NAÛ�KêõOô‡¾d¼òmfj’/ø’Õdé€`äŽè¨¡Èq°u²À.&Ëþ‰´‹ ô(≰·¨¶¤²j23äË'<þý_éuqdX5N¨ÙÓ#32!ã}°=÷|œòwCWß¼®fF¹ÆoŠÍ nª•†…Ë‘mÓ´ƒWXz]®=MW @zd§¼¢„ai:¶O¼‘[C5¬NÈ ØÛ‘›Ð&QõWiA¤|ê¥Üœ»*È]žÊæjP\9]8¹[¯“'ÀĤ46æ¸Ó¬PÓ :ë‹ömXTÀ¹šàAO0Rc¤ÊpÍyPJ�îóLÈûl«_¢ïz›|K rÍ2¥Ódìâ –?k¹X6šH¶©ºcSŽž%eåŸ+7). ì´½Â:¸ÉTþ’—Gº" £H½ÿµ{h­­|kT5ÕG$Ùö)ÒQ‘+£#âê<YéŽÊÈÕ­´Ä®Á«Ä®#\_651´VÚ1’¸«V!ÅÉ$Ë”i‚u=Eð‘·‰=†²b2nàÑF/hºxOޣعM׎{ ßE­àƒ(ø:Ðm¹¶¾0¡DQŒSxÁ½ø.£0\ :BàŸ|Ü1³<€Y~+3‘SúÁÑ'ª™Å}p™Ê jlÝMö‡ž¾Õ´"­°hP:x÷C½fª•ÂþTÌ‹(©gÕº3ì~áÊ;–Ôk+) 5© ²n@÷Ÿ‹'ÂÔý–Û(ƒ-{Ñ÷·7:Z9?fŒ=ÕÃä#4¯{æˆ7 °üÁiñ@­ï ¦¡Ñhp °ÝÍ»w­[ÚCÿy‹(¼ºQÝ[Éé ¤²Žâ… UCý÷Ø·“’ª­ý{¬dZï�4Åf¨@ˆ¯Õ¯’êÂ%…oBwkQ(´®‡1 ŸŒ¶OdóDé+‰Œñr˜™“}ÚSOœàûÊ%<Ñj<,õ‹õËÐç!:;ªô“¦Í”j·3}"¬Îú/…Úç^£i$©2Eüw_TÐŽÖùöýÜúηyAG€è”±óþh±¿RÜ ‘“rKCË; T’ŽŽCwÞ¼ôõ^2˜­tl 2\‡sªÄ[Ó7¥ÂzfàBË°ªVäNP>hÝg½]‡h¶lëÃDKŽún¡ÈëóŽ=¹’S²éÔ5$G@“‰ÕIÀ2sMygÑ(]q–ƒ> ÅLðX‡ÿ}Ã"|[,w~ci–.G»õÔS™ÏÎG ´uœ vUº®ú÷‹,V%3‚$‰UÓÏ‹9~3ÔvgN:]¯…žI?¿(:§•w‹™m‚y~¼³^ÇóH;v:µË G×E›—¾€²�9NþÑ]¹PþŸí[UvïÝ's,îlù~劣ʫë "Q_nòI”&nZzÿKÄÄ ¤pCù‡Ú€rbqb Α²èî¼öÉä6Ñ^â¿M]Ú4þ;ýYŒ9”Ýž>|ëDËÂÊ×;¤CíÖ:@A]o˜ªÇÑß4å¤JzCŽûcŸ..}ôäAÐfK%WÚïëM€ýu;][ùØ3"h×^§ýáÐѲ¿No˵Ýú~4 ,®· ñõî;®©ÊÜQ´÷‹O|“íɼþ­>›1ÇsÑÀ(JŠÔ‹£ K¼…VïΊ*1êBqáú¶íÚK7PœÂêܹWYCë/ôD%7�ÝÃúÒ™¢[€µá9röÙŸ·[ w§š‘¿Óy óŠIcäK¿\¤Qà\Þöª1¬1$;Á³Œ:mT «O&½Ì‰â[%œöJK,úT<>áÊÊñÔ>¨l—à O0òh Èè$_O´¼Šúªà( „€ísƦºý‡m+³µµi ZüH¤kà¾ô3®¬î2vBmänÚé*]3ùÄBC¡bõ»~†gITý¨’ õvÆ÷K »à’Ûš¯Xå$©É‰dùSRþEÕaæà§Î÷*X°_ø+¾áiXh‡=Ó\تŢ»R3Fh!Χ›a×¥vCwf¹¶0 ]{n*Žsi¹Ô’¤·²Þš¼ÄN þæo®ØÆ͇­O´©,ŽöBàs89Ãà‚jÙ\²”o£©É]£1®D ù<›/”ðnÏæÜÜõ”È¡ƒ¾eV6³ŠÕ-Zߺ‡ºØ‚E¢Ð@îvçŒÂ÷ ì\é4ØÅøH½&S`ÍDT†N…O¸®Uü,ÓÝÞòuXÍ‹g¦c#Ùÿ6×ÿÒFzÃ/Rb‘ï³ ß˜õ@C½(‰„q:œ\Â×£ÈuýØUrwð»À@¢` ò¾sC'ħnˆ#Ù”Q‚Q]¡%ÿ>±-ˆW¿2×#Ö;kUEûìdµ¸é+ˆ£m$ÊìgïL¨,O]>ÀZ¬i0jéò"¨Î{•j®ÓFÍqý¢(CiÎý 6O¾ß+QÞÜ4•î¬ÌSµ-Ò¥CŸ“ª€•Iò˜Cx f æÛÖlÉzÚ]ù\AYA½­{Ê>Ì÷¸ çŸà[د.1 M•S¡‚ÔB]æ(3 {yL5 &†8ó ™x?E·ÅÖÇ›ýF¹qQ¥31¡â:`·ë¡û_u)>° m»Êl; ³£^  gk†—ÏLG ïDµ×-ƒ"÷»Š§ %äÓd‹Ù’uÔÏÇæ<kí5<<¾Tt¥rÕp‡¶Dýç –³;6?/¥jüJ¹\…ÔTN*â¼P>Þ¶údøŠÑÀ°¨4îËÐœè¹!t:ôrh¤ÍŸDüø  ÝuJíᇚ£(ˆ\jjðÛ^m~”@m•Ö§U¾Ê®tSßÊXxpÿ½udÚÒ€‡ìxæ‡þ»6bÖRÑí*‚ìÝŽ°ŠD´*Àß*Z2‹¥7Ö?sF¡oùÍí¯p—Õ>…¡¸íMðŒ1ŸÆŒ'(>¢*Æ¥OB84ˆ)sä"t ¶°7Çû«F±º±ŸÀfŸçA4}©‰•ëY˜ÔCj¾›:î<ÿ‘Ÿö -«OÂÔÐL¹_P°ì¾ ÉéäURe‰c$õ&tìÐ6R—÷¼kâÄÒ3+YÊ ?T¤H4Î’.ÚAwñy϶®SC-m«+%"ÅhXÎK´”„Ðÿ4HF^AÉÈÙ¦"‘ßÛlv<OB¾¶c½gšówóY ËðJž”] æ9v¶=ZG7Ø¢à¢çÁMÆ;ÑþqþfÕÉÇkFÊKÛ½Ÿ•ÿ¡Sý.ZFÛ…÷,z’7–¿o¬^T÷»Zª ë½mŽqPL–°¿@ßl<|pË®‚5"P-ÓÛ}×­®.íî“Ohèƒg kŸ°‹ÃA&ÃV›œžÇÖ$OËy®ˆ¿YÐÖ¼l”üŸi¿ÉÀRmIfùÍ(¨ÛÚ�ï‡.¾U‚š#¨omÕ֥ςª¢³övÅú®¹¾5&Ìÿ›üž„h‡É¢¿üYñlÿ0tèË� ŠR¸œ…ApÕ¿ªvp�øö¯í:Š{)ÈÍCD•Î¥û>tV5>f ?ñ<q\çßɦûª´“ ï3ʳ{&CYŸòZ똦õÁú1M†³¸ÆmÅÐñÛ/‚"²úÚ§¯Šªk@(v'§ó�Yl¿¯:üŒä2·éñ¡Sz!=ÓÞŸrãZi½BQ¬ÉHPØ¿·'zŒ)„MÔP™ùbÙO§kû†ÌuÆÕ¼1³Mð„?û(:|Tl»§ †Õ ú</àWçý©ûÁ0G9щýZ“¦ÌäòÒf¯Åü™—ÈoR‰:O: 6þàœZQºØÖ’¨:Ú{þ[oßR5�X"•OìÔio•1W³À=æÄ6XN£û/v”Å™¶¸¤êŒBXc…vÏŒƒo uFß ºP~ªAÅÿ|ä ·•‡úI2‹=Œ†›Ý,Q´„‚´óé=Pý€¾àâ?˜,† ÁÀ'ÊRÓMlÏ*v6]çjM~|Òê˹£ç‚u®Õ¢,Ž¹xÈ?Ú¡ ²ñÝIZb²Vÿ98§9°¹3f&êê{= •sŒ`/ôOTÛàˆ–Áb±= ’Êt¸'t=H »;Sg=-'[jÜÓ`¦÷ïZ  fJ22AØR›žpœb7(L³Œ"/U*g;°îÀÒ¶ huÕ°:ï¦g/ek—ëе­{¥Œ*ËWóHXrÒ&ÏÒ3›†º­ýª™ê ç6OWLló¡ãÅÁ©Ï‚j+hTÁmÃh¯ ç4ó·þ-²PŽ¸¬i-º$µCÜ!šü¿tðqaWü”Ù˜˜þÌ~Pº]ãtâ™9É¿1>td,rÝ«×ò<ÕÒ)Þ€0±6.SÝåí–«›¿^95b9+ö…>AØž»H2]È5 ·K‡bg¹T˜âÈüæ f³pË«‹”!!6(T?!®Þú&æRŸG뿲?o>˜)ÉSH%<ÿ,V`¢ƒë”ÞÖ,áwÈ D¹—÷æÔ÷®´ddTá#ðµïƒ¯ÈP ÊÓ®m×¾ Þ¶º|’Æ羉`œPË ™.ªÖiº‰§®6û…û²!¶…Á²EC¥U€Åz ÍþEXñ0ÿ‘¬•é„!¤u“åÎìÉ÷Ú÷’.ÜÒŸÓC%jÉÅØò™Pa ßXFW‘,¡¥I áv¹‹[ãD‡„äú‚5¤èûo;ƒ^‡½ñyÇ>§–¸ê#�ÈÐ9O³¾ë›UÚSŠ“;h¯XJ_)Ð`vȶ—Κ߯¾aW§ 惴]©|‰­ÕO`z¨iŒÿhÙT¤>Bãû‘½bk3mÀëÿ½gy ß<&jݹŠÝ÷ŒkÌŠ[˜‹íóheTƉ=3ÏEfžŸþ°ˆ£•ËU<=”ü¬.x^³—9iž L¬WÃÃpórwá1~Àt¤•<'AùåF ”BBÿƒcpœ)·ÆMÀõGÜðwqVù鯑¤áDÅ9ØR|°^¹þáíŠX{+©ð89É¥‘‹Åq¢åÿÙ©áN{=‚ $=ò˜õ]¸uWZË’>÷¾¥´d±ÞsUQéá†=ƒ_´q+2mk\Š…I=*œ`C‰òÇ[sº®ÛH«âЦ¥‘×»œëïW¶�e Û®ãž&}8ö ]£å¨{d»eYœy«¤Œ¢74Œ ì§úáØœ–ÙÑ{ÛÓ…UÃŒÔçÍØaРi0$<Òâ³ÃÓ4ó\'Œ\ªÓ9•9ú¬ ¼2gÍt¥‚øþŧÞÍkdgü²7¸sÜfé¦hYlj´PŒèmêðAøŒ* ûÑ7“}±‚ !æ*þ5§áJÕEs¯=%0¦XÜÖ½T9BíD˜­•‘¨>ßÄC８EÐÁûiOw¼ý^¼$¿˜¬, ¤ð—ˆª(Z4¡µ²\ÉÚý†M‘W±ÆâÓ6üÀd-ÿzxª•}63A^6ÍUšg’á(>Bæ`5tìÓÛ…|ž1 ¬>Ðv&ÃQN•{†ÁÜY¦ÎV‹ê¥%ÞxÊc^À"äé]d¹>œùZõWCÔE3tsBé¶ Ï�µDäà‘ZîâRŠéÈX·/L÷\Š¬,+ç±³†ÄõË]c>c‰´Ýâ<c6õ$@¼S/çgjûßi[ N³æ¯ƒc1sÝdïzYªæ X]Çg9ÇŽé¨5—±¦LfÒy¼f«“Õ"à yŸ´žÂáèl¤æ'Ýf&x3†I5(+.Œ ùÐ*òÖåJwE V O=3 Ñšzy4vÆ˺ °CÀ!0Ï)Êe¸™\&¶ÝïQXê,L<að %“jþ±{c|”.Cº©ƒHß71+x*Ùõ‚Ý’qó!ñ ä+Åßýa±HëoîYjçAŒãÿ$”~v®©Ø‹sÓ ¢&öÉô”•½!h¯bpø³åaœiZ"àdô=Üt¥S½«9Söv³ß®üí‘$Ëîø±‹!x5oìoÉ{Xo¬îm`ùe¥ÌV¾ä ¯]HV÷ )$�ݶ¥n/,Õ¸(7Q¹‹—Ñú¡3€ïÓŒÎÛ—äµ])L zìµÖ© hadP& µŸ“wUñ6§æpKjû–[œ(+S^È´Kò Þ½+jšNðJÞúE¾˜Ú# 3rÍ{§Q*…͈sàÉ×Ó†Þum=Ó÷UtŽ‡%VÆð‘íE»QÙdñ“¦lO©ôK6§f�ÏŒG£r­~1‹#qφé È&µ¤K*ðæùdÉlÿ 7¦ä6™EsìJ6Np-Žý‰ÛÌm^ÄàKn.о½Ú—›û•"‘èûŒ*¶Ï«bôu ž.µto�v¥7„ ÷·>ch„-”2æe¢³`oK@43Ž8D±N殪«Çd¢4ÿN&BÜÂüª˜óÜËò›ø\}nõXʼÔ0d¶ÇC, £åH\ê³´Ö¯ÆTW5¾45鶇öY¿7Hl<†Aaï ?|ä­2Gå\ZDTÐY7{SN³בó÷hÿ¥›/Wpqdp®r‘åÑßabQéË{™oöt$W{NŠbl¦óæиœÐîe–3²å’ùí£**ÎJcµ‘pMNÛöŠU“¢‹ Ãã³!HºŽïrš>ϾäÚA¤À–Ø!"ÝùtœT–²ÁÝ·+ÇL‡&;`à<,ÞüчOJ5Õ® ±÷Näò–ˆ3Q8({¦Û«î;y¥á]°±ž ¶`HܱCAì<y7+Nâ®QæÑjI]K ¾�¬<ˆÎJ@šñÔ÷ÎBEôÒ£•Ü¦E.—&Um·©ñº3nahú+728ÞìYGá05VJíBÕÊ\›½†MŒaóÚ‘¶Å$c,úñÆkO¼sÍ {¿¬Àî)­û2Hæκ­§Þ„÷ ŠÐ–•i°{¥’›ê¹žêÝÄJYGè8Ó>ÄĩϹA½±D\Ôíë ›ñÆ‚$ vgZ‡Ùר6XƒOÖ}2ú#f˜ÇYI¼`¢‡ç›˜´õ~Ríì%Á÷“y©oe¡g|#vevuâ¤|à™¡P-í'l@®DÝéîöÞZ–¼’¬]ÑÎ\L¼{…™êª±«¦ì3z·›(·Ä¥gïg(îÔÐsÓµòY i ªhÛO a`p:« ÍÝwí`$()µ  g^ßè¯Íwtêºí•vY¶ADRRÀgúÃnžƒ4ôÍ ÅÓ‚ù~¶–ËÉ"(Ðú… ÷ðî7o½D$%ÜmŒ—¹“¤Ðy?�  /\ó9“ ¯‡‘|ñšxPN#Zé=EÞÄÙŸSŽÛÖ „¹ÒÝß8¶ ýbÚ_‘Y@wn‡—«ùW9…ŠP•z»3ȼý4ùÌïIn>ë|2¸+ß5Ë–ûðLµO¥zϯaHèýk5XI‘Ê^æ€ý‚Ÿî…XSû»lS¦uhZ&˜½í냼 ÙUfxmñbÕA'ŠÍH2õ±cíî6ÕŽ-Þì/}ø}8RÓ¿Š=Ÿ@Xø0çKœ—^UʆЯù“÷¼ùn±°‘zW±C¨ôB£,âôÇi8‡¯_X}Eq™)ƒ(Œc:Ö´²S5#QÂ5 Þÿ”jG1ö*ÝìÓŒò[ %Í|„×ä5Ú±õÌ*ðöâŽÝº G²°WY5Z@ݼÁ¾Ô�ꂱ?ËZÅÆ; xCÈëAG¹B*$ÜVÙF�k» æ×·c}™üMoaNÄ«ÿ‰~‘·¾±É%·ÊwVr©¹Em:y¦îLè@¤MŒúŒ÷k=Tçk )?êÜwfk­#øô‹ÈÜŸÚ¶›¹⮞(Ū,hÃÚ“¯­ @=tD‹Ö M¤A dÕï  i–ÝŒ-æ íó°>ë™ÏaúP?#nõ¦k…Ö)ßi!LÊ9ê?†nÌ••þÍX&‡g0ˆ¥¹AN³Ÿ[[ŒáÐj˜{÷køFßÈ?55å„Ÿ6u£»@w…âà2<@�?°ä1î›å}þoF~.bOw¦ÀF‹ßóWlóCÍgGÀ‡¾€¸Ž7B± PÑYÓ2WªH÷D¯ öÙs@),ʳü¹QIVÎÔ‡ËoƒÿÐ"wϸ2оv¡Ý¼¸²%—6¢X3*ïJ…Çj•×T-‘+Ý°‡æ~DŽ¿·í£80žè‘¸ßEòrå¤qýƒ}½3ˆ/C½@Ù¯ó é[Ï@í;–HvÎ3؇÷wýÚv6€ZwTpŠÒX[¤Æ«í€drtcÙg­’· €¯.,¤ŠdÄ¥h“S*÷ù®NzJv˜· ‚Öþ $lJ´Ø†ô¶ƒ–¯D~c–x¤BtgY›LA­ÑP×FæÅYÜ=0u¶†âÑKŽ›ìÕHnÛMvdÉ¡�~ö7É­ôoêO‡m +§p“R´Ù¹ˆÞŒèÓ]ä÷ëÁªXEÝœ!{á¼x·uzú¬Úë’ÙEí9_f4s $q‡1I‚äo­�TÝ É'Z^'ø‰dp¦v‘ȃ¼-{w œqª°U±Ø&à|vó‹u¶W‰—êgbû¹)‚bk%V(Nãă¼HAðº@´œ?ºL¯:ÉÝlé¿Jºù¸mE«D7§è;*Qƒºmî4¡Tªã¿°¡È6,“ºø†Á®ü Ÿ= 7GzÔõ_‚l«n»ú`y˜§aWOæßNè]¦Úr¼ÎJa ˜Ç5/ ÎLŸ^¿`dî¦=±=ëòö ¹_&‘|Nª›ã÷ÙG¬m7³+7ع–i~q.ËŒp,??:üi¤»w{0k¦Ž*ÌndX*·Ø›¨µúT ó•@e}¸}mÜÏbn>×ËŠàmAîõ;×É—©YsÃPqgûzX:Ëi´˜ zVýJ€¹ã¦k5é%ül¶†»•xߘ‚¡¡ÂÃù]U‡ªø Õ|Îç<ÉCí½™NV9Ú¬åc@ƒi÷å`>x$#Îk¥ÝF¶•ÚØJb%Ì}‹eK·¯Üµ&æA\ݼI!jF£ûÃv��s?LøV—+ ±1ëXpBwVå8bïÉÞšxDæ‡üóªŒjåµõÆ�Z!!:x€fú˜kã’Ê–’³YÌ >d@)‡‰`-þ‚Ãè„ù´3‘0¡f¬´™Ri)áƒGÞØÑ*§aoltσS[?¨C¼5X¶zë‰pÐê‹€íMG_Eµ¥S¼¨¬Å´÷—ÞsºÒwôo‚»÷bHLbº¹”A2¸A‰mDÉ}èj‘_”#ð“r™2[ˆƦö˜Úmf…Øvf`ÒUžQÞä«—¼68V^¨1dC:ªyÂn«F@ãzÀtþžØàÇr§WÆ|)[tÆã»"…ÜJ>wéÌU;š›}ù8z“Ç?0ÿµ6<A!Hºc’Óm»� t‹Gg?ÇA1XlÆŽîžÿç--œRÚuR ÏyXixÚ{ÚUÃ4QU{ê LT€L0Hj%9ô=dZìÜ™p, ¨O{´$ÅMŽ‡ƒæûL—nCg øÉ–p”pm%´‚ÿ-fB®üÚIúiAŸÓ¡i¼KÒêÙe¡vüA; ÊgÕø¥  |¼2~Â$�/éEÿ§ÌÙää ôS}Þ�ÈŒÈeÞ›YB"·gœ!¢(.E2ÊçÚûÔShJ}N"ªåFCj$'ÂÕóÜVÏ[ f먖L‰³Ü劭m Çz³[w@W?(x[Z­$@艶=D¶¾œ’Ñ5LŠ£F@Ï‘aÃ}»+¹+¯µMñªª µ* •K¸¤ŽªßI§³èì_¡£‰“²a|Ù`ÆÆ´zz™Y¥E–­§5iÓ÷…¾ék„O£Îcµ†hÛž{&ûZ‘î–cáì™—ï 2+µ)äRª wg–ùôö;J²¤¬Ý¼?-†]Qb;‡±¹'Ç$(.½àG×ä‡L»‡Nkl# ýÁ–ìOˆZß!ÚVKÄ;ûgJ„Ŷwy5–ÈlÙ’êúe#ÂLÕPÈsN „­ÊŽ*Ì�¥ý’8ÒPRQeJ’, f:9ŠÙ¦R”/wt,­…mèªyÎ./]m¿–< Úâ’) /3flŸWŸ8çÞKÿ™û»[ŒÇŽ˜Pˆ%N½iŠ¢ß¡Æ5b>§M•V?ÜóÚÉ4%:býhÚŸ6*J ×ÎÆdš ž¶<§pÅÿØÄc=¹ yN±r[äp”YŠóŒ3 ú…DL\®dD¡¼9FjbLŸê®[Q÷©ðH©ÙªµÁ „¶Ãô¥Zq6]1Ø®mͲQ—¯u‚”ÈæҢŽÛåË”Ìêæ<»“švëÓ1Ð’F÷{×Ãft™8OUYÙ9wv°ÆÏ­}ù®1çn²T>° Gç<yßj‡Öôy@c$ßþž–·þI™'…™QnbÙïÑ µ ›=RšJGä°¡€ŠëÞ"3Öˆ3¦Ä!LÛæÜï­¾”€TP C7[™ž¶]eþo0Œœ*Ÿ`‘†Xòÿ{âz¼æë‡[ý&[œ-OÈÉÀ¦–ßÈÛyxOXB+ ²Ú –‡o‡–Ÿ³t}FÏ×SÖæî™ìºUulšÁÚ}ÇT<BWD·îmÃ. òæ]I¯áH7s«BéÐêr×±'Þ©E¯tXž–ýR+Õ23 ‘ÃlþèvB©²üø@e¼vQhä!›!ÑÒuy­¥ ˆýÒÅ=í‹Üå¹¹>w_yPœ/f pe&œ€ÀnVºùžþN™$ôû|ŠB-Š€Ág+go¦:qÆæ®ÊÑûÖºÜ÷ Já7/c:wÈÐ /í:Ó€.<‘7 ÝŽE­¿ýæqÊuÂ9Vz q=;Ç^¦m’Òúö•ØÆTç5r¿Õø•q�ƒ’!T5;æw‚P×4h!¡Ê³½�¿P-­æù¯ø÷œoÎ-X<œl_ˆ¨ƒNJ ü5apßÏLÞÕÏEÎ^VN�¬akNƒ§e©“¦$\3–ñw¼~ŠPbÕùzag.hïÅ£Ÿm<²2é×ü� èýì ï<p£·•$÷Ú3åDRÒ<Ÿ”©v2«`ù¤¯á÷cÑš1áŽ>Ø— Íåõìéc\f ÞþÐÇí·Šý¸9OO^/íç^ºöV<Å2AÐБìÐ-żo9x‚ëX¸‹8ÕsÔWÕ¦QÓÐQ†Ó¹VBØ Âáð4̯‰7y¡ÁبÅ;è\<‘n__V£u”çF–ò)^†Z ‘öÅ~ʃÒ}sÚºÌ6óvÝ2xê\ß,™M]Ò²ìV.Ýj$§+õEŠ˜{Ú}Qý¥$jT–j­�ýŤXT(J(+¡i9TýlŒ»Åy±[ËzßWìüQ¼Ó! S£ã±½Šø—“=ðn¿v!rGXSéܾ—UZ„daÎðý˜Qö×ú•>ÿRáö˜Z{î•bR‡ÓåûôX‹S Ÿ M®™Xf¨CÚ“Uê¼[p¾þËïÉ” iQdìXç]•ÎŠL&¸oo¬eM»Í®^:jÁ,¾w‚•»…foº·\ò0â¹gwu´“×ÉÖƒ/òÃhiæq»ú@§Yê%§-)MÌ{Ч\ÁÁÄ¡?ŽÇk SP™i™ÈžÑ5`Q`ø`XÕÚÿ‰òGÀíˆØK"«'¯a êµA}”]&ª¯?™H8D£@càY0d#ímNðÙÏ#%Âl&fÈ0<MéL‡ûiŸ;ÎÖ-XøBFÞGhØ?õ4ã�“Å©¬ Õåã9+ýâç'å4`ÁÕ°úvssuD¸ép¤Ý«ò<\å­~ÏG‹Ÿ0átþ ˜4¹t™‹f;‚¯¦ú7b–?ÈZ&vžbãy»“‚ÑQÄ—,·µY.“õÚöN=‡[;•4ÒÞ”P™üÈù„ŒÒà3ù?²©ÐëŸ?W`h&UÏuT—­ Ý å^/oMj¯ã÷f.3Å>”·›W&œgŠ‘ËUR¹_« s×ÖQ}ï×B¯¦˜qµ’ãˆÙÚ4 ÊÞ&lEX'£ûËó8÷úx馪Íí£¹§'êLSebhÕ©o,ï£æ^Tî½ =é´,¥Ïšÿim ´†¡þÑ_½´!žWUÿo4—Ž£T&•£-»` Æžpo]KU ½RÜÓ«ïŠUìGCËŸ-CJ7xÅ€—Ò>NZmCfeòšHÎC ð +þÖj«õôÁÔœäßç íÓ&ØÖPot Ó|q+O]°œa¹ÐÔñ4.+@x 1ûW„ÃÿóÒ,÷‚²Âÿ U@éõtö.nÝ�é]èÇ°¦äõM$"M£ºÞn1Ö»üŒ¨u“+X·ôkÆíÂh±âä”:ôN¿G@÷yà$ì­•ªÁ„ݾ®fñ«æeM5yYwﳶ°ÛÒø[kŽ-ÕÍ—Žkwõ˜/R$ž:,ç|ÂÆŽÌsP9ÎVaPP„êòVRUOnR¶«ìË ^,ü¬âŒyéQha±<-cCŠÐÜK÷”é¬x§4ƒYUÆBHù¦\V„ö_ÜÓX+zQœó<ˆ¿:¥Cˆ%I§;­ž6òc«ÚŒì¼â®î¸ù”ºÙÇ"26.y�0}‚ÎÉjþFf W¦(=´<H„sdS6ëüpßþ눵È o»í¹¿¯Sï8A¡™×},´p‹Ù†É< [¤8FÍHKQþåwïx0è'iÎPR¤¢‹€¾@¸waŠîí‚©~‚¿úÙS¥±T0Q�î)€GWOüܲP´’—¹ÛòlV'䎶^™w„˜˜©K<�t`¾€ü ôPP-®2-€æT–l/ 1¥7D1mhk»õGÛ™þÏûvUFTÛF™Ry¤Âa„Þ­7jŒNc}Ó3:ñ ŽöT2ÏÏq¾£×ZÞ”°ì­ýEÌoo=öPû—6\\èî+“uQû7®Ý¡ãÚ{9—ßAêWÊp´A›}$,Qct"l±ìŒMôÎþ{f YH2E#¬0/Z¦X Ï¢+tìz*Äå†ŒÓ £e:O§»*EQkY÷; ñ'_܃ù²sM6Öšc)Ž{WßGüQ¥LÉF�[;ë)–^ÀNb;ãœÎQÖ?\až«Xf±òwãVÓ2PJûe'—@>óFâø”®™µ[,mûlÔ°uæo?[ïLÉ*¥ì¸�;”¬¶ _®®ÄÅ¢Hjp¿.ÑDhæ`ñ’gTÙ¬þÏ Ôx<ƒ3Ì:·.÷ÉK—ØËæ{ö-*EÅ(ÃãNV³­ÏÒ´AçÆÀ"`ñ›Ÿn݃[©ý„Y:¶î{OË\ øÉ ;QÚ¢4¯1 ¶ÅCí6¿NËõü.DCm¾ø !ê`2¹ª¹¢Dåp@T›GÔ9Ü)uë+‡¸³ÏihA]S*ll· fîÕ>šG#<øz~eˆTn€Áå0ÆHNËãt~ÛR*@á°Åç·a`C¯Ôýsýû˜1t(ï­MÆî~Ð鮿0î(•ƒœÀ^…`ãÄ*²LŒ»~¨ÏÿD¯)BïÁ”§úPí@%NÆ|ì}wåhk_r¶ÔÆí,•G_’Iùš*^¯“÷J®\+gæÎìþúƒ×eò¢ˆ¹å›r=E>UgÉL%kú­3÷þ)R´ÛœGûÒt_÷ÝÚ‹Ø·¢™‰Áç\º¸æÆÊ7cËH²á·Ö1™Fi|„ëÖ’Œ‘lë~£¦!†;vì÷´‡sx†Ü ì7š–2éÞI²ÈØ0më/g@ð£Å]äJYñ0ʃØÙtYÛ¶at2³k´K IIó+¶¶%Ö§a6Ì6``W²Ö2EL#‡Ê­“Yð\|š¿g—ooJ¯¿‰.o¸W%šÇnF°›Ë_ÇPû¥èq¢Æ~)[TwI®¬bæ¹6aêž\ÂæúÏ[D~´PrŠ>QnP[-圻<ob=ÌÚyö‰_ë÷V¯ÀKŽ½±ð†SÄà¯J1Ù÷¼FŽ£|E Êé@¸ë@×…þGLôic.¬ H÷@IÊYèAa´{±Ì‹mÎNùÅÔóšt“Eƒ®÷FÀÏ}G½3Fh,ß:(±äƒí¢ò(°¾ аbaiyk �?¸„9´·�˜jå\È}XÆl¼s°˜±³ðï_Mß«‰#öuÌ{»\(q`+0+í t–·Îöþ)Í4�Îèñ©ÿž:~ìÎ%¥_'ÍÓsÎ.8ƒ^»‘¨ØèD:rŸ Ð~ÖÞ—#ò˜tIZpåƒ|š-SJëÑøó|˜dü¹$ˆÏX “fM{xt6úî0'Ö¦œ•‹cåÿÀqä±ÂL37Èå G¿™,i¢ãì k:/FºO-Ïm¿ÞÊe/OÕø˜{Š;x¤½¥yí0NÚ|XZ’ùq~c€~-p~8½HkÖÞý=0IT™œC†^�‹¢‰Y6Náß0nY›~F†ÓÝ#ûoåߕȇ§œ8̈õî™D7Ù ªÅ³¾®›�0üùt|“øÆz÷€Â¸ÚÛm…±Ô­SwCG7ÖâÍ«Pzh¯ w[«åT² Ç.c±M$jè³ñT¿?!éÉ9 Ôá´:IžÀ·¼x<OñÐÈbÏöáÓO`ñ(ü—1-ßÑ×°xxouÆ»9r…>›pQñi=¸Bàý)b»pú«^P9íCî{Úy}Q´ß±Fl0U\{9½Ä®9#‰îï–髇 ¤U´±?í”:ã¾(Å;8BUc8\ú±7莿ÈÚ°0 æ–íSXcÙÆT„>dØ”¿»æûݽط£Ä˜Äy±š¿ÜB¤£×TŽžòD›JadļÝøYv£ÎÓ€pY4Úrý¥;Ìóš¿�(u_¼Š`‡Ê\€¶Èê«j~-µe½ÜY¼„¼pDoaÀP 0crô[sçêöx õ:¿± ]œ¾q¾ŠÒ\E+;8mÐ3•{÷ŽÞ)rHMM…"Aì1}%dê;®° ¦k¹Ñá_Ÿ)š¦©G0Ëœ-¦Â¡WN6åÃÛdÁCT…_ýîyî„8p-šm­å�ð^3F6°ÊD <(í4†Iј΢¾‚óEï@Aä[ñ~¨pLQDËNu ajP;GiÏØ×{|“ I Ÿ¥W‡K$ŸRöñm@jØ~ížák¼R‹ÞcSÇ:ŒÑ–bßä+ÿ6Šó©ϳYße ÔÌhç4Xÿ ô󹔬™Ì[s꟨ëñö}€4tŽ‰oâü¬²ßÖ½…½¬EÆß'd)ÝœT Yqx±Þx²Ã±4³ðŒðî‡còAdhŸžžéO"³ÁÖ²yŒ$eäÚ¦¡órv~µ%'Xƒ,eç´ûÖ kê×.d™Æ=Ó¶¹ž(%NÜÈðò5£ hL*ÃÌ »v¬û½¤tD¶ˆ‘P t tV§°ðSýÁ†söÎŒ ‹ŸamÈB?ìiöMò'adˆéT‰áæU=›¾#Ì؉$(föyî¹ßðÔ0ÂÛÄ-˜ŽÝiXyvú>‘-7.-ì"n ÓÁkvæ³R)RÁ˜™}·Zô©rÊsB› Àpºšò.Röš©iE´uAêÅ© Q¶bª‘àR¹Ñ#ô±ï×wV¹îÿ°ÂU\¥c‡`y<›ÏD1ßÉY]nN£˜«{Á«xagˆ©ÂîJpÞŸ›‹Ê;=_fdß¼‚énÞëXÑ°S²¦Û䊮À2?ˆiG+ E(¦öôìfëÓƒ[�U–ÎMÝQÝÊ?ÆyŠÖÊ|Ç¥…×*D :Êåêý†4@÷UuxâÛ}Y¨Šó/ôùMÝÕÑ™®£y+’šW›Ñ0úÌ)™BCÿ¬«éd ¥œÎ‚Ìz�}0…hl`½è—Œœ÷¢Ƥ—ö`miHÛÕ)ª±¯}ô¼sLØ‚¶ü¸LV_¹ ‹wá¾×K·‡fx;µ�#¯ØOæVÆ%Ö®`Ü�Ã� h½5‚´þê[f—–™jìâä©cJáÝÁƒV/¶3,³¢sÔÖ£êÂí^Ñæœç¦è8•A2^ ”¬Œ ƒ[vò±¥vgBœå¡Bä2ÞëC¯ ç—Ã0¯jÀ×<ד›c·?§AåTü"æá4§ü’Õ¨ú3âoÿjùìÔÐP> nQ6[³¼úTX³ìHùŸ·¬xûï¯hîRî[L—îj%‹zwBÚEìì±J¦¼QP°7:õq˜pèb}O7„çð,P™ÅÝû•„é;°Ê[1Ý<^=ߌ+ˬ± €©è@ 5€©|T„±òŸ®½å~½Š<È”!|Ê$ç: ŠÞ3Ø mºí@Û~Ø\gºo ï<†)Zq'ÓЂ*¶øJ‡(ã’̤*‰f©î/ðâÐöªÖ|âW‰4È›–‚P6zü~ í¹09Ø´”èÖQxûÁÖ#R&ð \gMG‹ŽºÃSg{J RôHÖ1‹TéRXŒnMún™#bý&^á›Ú##Â(Tí®7ó¤ß&{¾K’ǪùBiwØX<Kݳ÷üÞœü¥ä¹È’ëåFçÙŒ+ÍB 8Û•,lœcºá ä›p2cÊé`Bû t}‹¬y€çÎA‡5é3Ÿ¡ó‰rØìÝOy(ƒ;/M×=[˜Ûëw¯Vȸ‚¢Qä’7Zûm‘ϽEä³Ë°£^«âE„ƒ—vŽLÓ§?'A2ÛÔ Ä4°| Xâ–ï½€…ÊZ¨bñòœ¢º¨ÌÄ€Žët;¦XŒðb ݇îEäX”ø¹…Ñ]�誅£Ûzo[Iý¹ؼ4àA£Ìˆ$ EÖ‘¾G5Y¨£hÍò ÊÞŠ¹6L6Y„÷…Àⵃ;NýqÞ¡Nqħ»"yÞ„§v’rÞÚ_ °iÆ·>^)Ø.ç ìȶ.&…|d® æfN‚n¾ùñ‘vDT…š@²„XƈpßQÿs ”¢Þu¦mÏÆN) ƒ—§†¨YžiÈ”“Þj²táŠø´k~›ñ&…Ѓí†2—Þ%¨X0™U»¡¸gLð¬òËn?ˆõŠOb“#¤?Ä‚òSíG®B¥í(ÔÕÃ<ÕY¢¦}ÓÌôGR'«oÃ[:D=š¶€#6ʸmØßÿ­òõ‰"£|™éÀ(†Éå™gõ¦BwI½õTxì®(Ì™¨Š Í©íX»4¾ÚZ,s v—œ6Ie•NzŠÉùø©|­Î´§§Ìä‡1þòûÍÈSí§ŽxÄΘNž=æú÷ÿê‰é„™%ÆVÁ y©¿fÑNõpî·6³ÉCË[¨›¦»:cí7~ÛàÅz¢È3åG̬„ÊÙIÑõ¹wîlŽ` PP_®#ÅEªi÷ô�à•}€¢¡‡}ïWJ:+2OçH¡¤ÜÖ„6FÝ v7FGbl\{ï1ŒÚ¤#–µŽËà°K)Ù¶{ NnÂóä8ü‚d®|L¸!ñé@ßÈdûSg=ú6”ÏÁ<Ôï}àl%bìò�?ûOs+’ØÌâT¹ŒüÒÖ?茆¡†ÙÃ@¬§åZÛ¾[šsor8Ììˆez-ÊB£.óÓ%£R3f™döýüò€°ÏUdý_ÌD³ÄóÄH茦ˆ1/J¬ŽN´Ñû/ bӾܙ&)°§rç&cGX“¬ÎÈÝÍ¡°·©nl™F"'YP¬u]Ýß[U…3íÅæÊ‚KK¹—ïÊ_cdç¹*¡ãÝ1ÃÝ@“E™dËžJ8ûæoÇP•…k°ó¼äì¤kèØôÈ›+Ó³ãË}t¬è3a£ýêGðÓ}eǪ$mWÄìû»N£TfØ0ÕWTá¿èœÖI$"…Àà’©u�0àÖ í°ÜÎ^áÒF><8s<õtœÄg%r¿VçãÕ§œ{Á‚/[Èy)'“V—ñÌØ…Ý7iþ_h÷kyßÏ2(GK ”XlïL(ÍVÚî”2×½¡´ðC~äúvq’û>w,l? ².{M€¬‡ô}”‰Írþž,̓mÚÑ“,wŸJ±hÛwì aÖ=U(Á8yùveSïo¿0p[ß‚bjõÉÔpãí#OâÚþzûò˜Fä\3ëæÌ\Ë ›ËD Áñ˜½é/ø¹¬·ì·<Òuhˆ^‚Rqu黨 KY[òšLø ja\¨g‹¤+{'V#¡AæT‹^×Ô1žö)Ð"è69œoÅgå¹e¡Å®ó»Ãlšïgq¥Œ±…vÑÁ$æ݉ÑXGïêešñ} õahPíFÝ<3R?gézZ5J#v™˜·õç²IãÔìO—Ù¡¡‘þª€yål|¾þs¢%™QD¥åUñÙÁëCisoEr–/®æߟŠ«˜ž¦CÂ=tÖØ/[‡óEùXT·Tõ˜Óï_4÷=9FqJAZ[fçãH§ÙueW“«_›bÌ sx9[`›í‘"TŠ§t掄¾¾¶›¦ÄŠ›è5'Ý«ƒ*‰K:’õMO"3FŒŸõÕÞÒÔ‰ )4ÍÇ*™Øªó†É*`B*úeü7Ö¶|¿6cyç¦[\…/†Õ½ÏÌÍURS¤Ýà“ÿ™]\»›Ó¶¾ëüÅYÂ(IÖÓ<ˆNR~8Úá 4®ûJwú/‡¾õ…ô‘iù«[Œ"Ø…‰–… ”¹Ó^-s[i7½ÿE‰#Ž3gÝ+-ºèÂÒ—Ü:š¥Ud†ð•Þc ´Cí”R¢>hÇ— ÛŠB™-pJ¡ªxB¼r¢¸;b$S:”I™2šýêßȺ¥‰G· ± JÕÞi'ÕZ–wìkt.öÍYúþ*LLŒÊÀóÉ8SŽfVW3ÅÆ·å^ÀÏÇÎÜ!1ÊqË”¹óÎ�árÞ©Þ˜}æ+ªžù<ᥕY ¹!™B‹¶åìêó×­‡ù­Á§w¥ð¾ýýgéþÅ¿ºíúú1¨¬5¢pú¢ƒ#l°© èל‚ÿyËÙÝ€¡Ä¦àžŸàn€‰¨ùÏâ§vÚ¾qùý¨í7»À²ôÇpˆÆû¥N‚´¹ÚA5Ž¬Ëaž6'×Å›3 Qð…ùY’%C}ÎSïª [¬=ɾ^6{w_Íí¬ +(ÿv`õ ¡_)yh&Þ@+Ù]]5T•þ'Lórb…?MÄZñ?Œ0óƒ‰ÅÅú.0ƒù$ÎËnÞœ;ö—/OøJ¯ ï ŒYî.>6}à(ë¦Wc“Ct¦ÆÊŒµkÆ‹RÎcG“ ÞèÖpºÛcMß0ÂpͶlkÈYî|Û�Øê¥Yîý- ßÌØe ™ŠíñÅþdUƬUv©uý“_•¸^:P2a0Å\ÛS^ÁÈ)Vü­ÿckoÛèÿó^›î‡*ʲŸúæD¼j;?ôDÑ�0õã|n-ëk*šO’¬ü )‘Ýã¾Y^.¦Ð¬%2K~²nŸ<좬ù%_…êì!à¨Ò7Ý"¥Ö'×Jþþ3-4Ò’ùŒgo„,¿ù¦E›ì ê…RØ)Ëkã_‡AqíÍLÿíY}¬Ýµ±JÀÎúï|»é¿G7ß#{ØU˜7?*›l)Ä «¥úlëtñ¼œÊ¯¥ÙýZ‘:‹oúð}’y;iÚÔÔ:ëý½ðûNâï³ÚåŽÐņ˜|É‚¬Ù¹ ÐÊ™CÙÇb0m°~ØI‹=ÀUîÉ� ²ÁÊõrb…>Jb\[Ñ€¶$§†°¿dý»–˜rù*(>¿”þóàýkÖÇócNjj 9qM)x¢•¸‚ŽUŸí“{ˆÿn”’¸´ZäŸÛ²ÞO»áX†¿œíêÞ‹?ƒ{­WÛÊb: ¥Aɹh:ñ1Û/m`F›W¯aýB ‹þ¯ÌWv¯°ÊÞºÕ†;Cç`c¾hšNÇ;ˆò½Ê¯;ñhã§Í—Y$pb¦„oR¾·{§è¯´Ö½á‰TÎ rk.û§ì÷²…”¬£èA�hƈ‡ æ�£èÏ�‘ÚéßKµ®P**«qÖŽ‚Á¡Vˆ‰tUÀÒÿ°ÊÚÀq”²š )Oÿ£Vl–Dî¨Y8÷çT¤HXáú5óçrÕ¢-0á¢8x”Zbt¾Ucñ·”bOaÍGå—çÇ¢…@Uò›iG»¶~Ö[|‚ùÉ»+Ímˆ hjìØ6Á–°à¬"ÑGɃ°cTé0`e$�CwZf¶éÌúv&½] =6¦¿tq`k;ª|1uóÇŒRŒ›ŠëÅQ ƒ;ÝX ²Ð4Ý­öJã¼Sƒ3zvšµl øÀGЫ£Ç<Ë NE?׺Īç½/:ÖjT?‹Se¹VÞA:ÔäAäš9±o½º"ŠykŒMìz£|þ#zÉâB" D,VD'Á0X¿‰»¹á+‹Á:%glwÙ›îwêêûÈB­DKÇVO™X|®MåͺýýÑm·Ú†ìÛ+Û”ÊâCÇåBÃÞq1òƒ =ø$6ôÝWƒ|Ñ@#Í�L@¨ BgÝ ËÌ•`Xa•À¥ú°:ã/JG©§©#JfAÃA7åµµ@ÙñÜO'KsÅn/ZvÏr¾2ÔÆ´ š†²¯|°’IèGÐÍ:ôõº“­Fˆ…â?1R}×ß2¦bå¤ÊÑa¤7»aRÃ&ΛÙô¢nR¬ Ý…—õí«FkȤ(g…Å2qdZ%"Ë>Ž ß#çÑz³=·[ðS´ÔˆlUÍýã0E—#Õ„ÓØ£Ïkø*²¶®ò¾ýî¶ Oŭ߬¶È¦jÉùSÙh E8(éŸ ÕœšØЦuøÉc™Õi§º³…tD$~!ïÕ`NØü¡¯9Ýð¤ NÙ•W‹®Ö\o¬o4rn·²ne¦˜P Õt÷FÍGˆbËkÆÛ@Ež”OO)øß;~Æq¶büQ=4å”ÚN¾€§óÒ"f£Ÿ¦ÑIßMÛ”RIl†Q׬٪ƾ mžðǃ(Þ)zÐsªwÎSÉnhcx—çsÃ8/fI7éãm;]…Çð¹ë íª uÌ­Ð(݉Pþ§\ ­ÑŽ–ç¨Åñï3¶ãP`:ÔxèÁ1ÛÌÑÑæ€hN6WóïzqáGÔ"#Ù´ôŽIóéå·…(Ç´±œ´¯Oz¬™8<"¢»¯lÐD9<ÓËmîÊv�C·¥;`šk1Ý¥u‹jåx‘ŠTÑt±æ@wT$‘÷s}£Ô¯¯ç_9`dñŠÿOIÇîœQÚdožqÀÁ¤¢t¯ï`mÜ;Y4Ñ,+7ë¸7ÒÈãL©rS„{ª¼[ÅîÔNÝZ@èmý¡ƒ»¦Vžý‰£ž;Î ö>Ò©u!‰žÉ¸äN,Ò›“èxÉË]ÀQ±æ†¡U˜áøyO>4浄bTqé6S®ó³ÜuºN™…O[ki”&Þ»AÏÇE…ZwqxŸdÚŸ5¦’šžmûé5À¤³qr>†ò*[Ë;q;`¸$A|µí$ª¥ ¹Q)OEZ|§ò‰2-±X.Bæè”]Xmˆ¾¤¹3hbü¶Èjã±æ-)M`'€ßBî#ª3›¨n±ª¹Šž/P¼â†md¼ÏAÁ#)J©hŸÎ=äÓ¹\²RgìYpô±cÆ+·Ï8ØïèîÎï{Óôç¤ (_ÔÔ†œ]¶iŒ®9–rÿ»w']{ž>([q’úêóCcb8·5?¿O5ò§o<ì»ÃÑêÍu§QÆgt‹g:˜Í~gÚâIe-æ ³Ò.P_,6"ª‡J¸A…¿¦S”—çD9v3SÅX\m€²É«©ˆF0/d{ñSç3ñHÛA0}äË—æu^/püÅú"›Ø?ˆ– ò0vU•Õ¥<ô,`ÿƃ&Ö<guåÿúYæâåHŧõµHLóäà•a׆°÷q*¶ %Ó—9ªÅÞk(wHë"ÔŒ`ÿíõ¶¡í|sãÁ¶ )ýܺdET”£©ÈyM÷…ød1­Bßø&ñWxC1îÌ/SDn/f9Þç/l*d¾ŠìŸ•!îZ•aÎÅ|ær¥D›.r:2Ð??^‡kÛÒAÑ™ ½)ý2Ø\¨È¯a±6mé¿»×Èë0 äËœP9áe‚J†“Nµ6Dîoä´_ÃTGº-Ó*³óä}ˆ”˜pgdÛÓ²y‘!“V«æNÃýŠÅ¯èÙ N/§¿´À¬¯M–o~¼w<Æ+ŸÈª{wèg¦•÷k€tÒ싧ôº‰Qj[vGÈyµÖ$G"ûåì6{i¿íϘ¥qÌcq’ï|Y¾:‹ ûJTÊœHä¨Õă 0-äfóâð‘ÊþUtÑY¼3Ý[u“?Üøv6Χ5\cNŒš§P7MCåž²g®�°¼„@À~vÂõpßœÖ +÷û#€,6¶ >ÇJË÷ØÁßѱJaGô¨ûžvl:Z9ð"}Öð¶ëotoö*kÞ¶- zÏC°»PÚ@Ͼ"HµTtPZáìøºx*§K?Ãf[¾‚ý‰nì¶òôÓCÎRÒ_êXÙ«O.ˆ¡‚¿™Ú¹éXÇ»³(2.\$™QÕHÏ `/ñÁ"”(N)#Zö+s²Â!^uβÚ÷STŸ³"“ÐÆeYÅÓ‡{¬Geõƒ[TºÞ»Ìˆài˜MŽ“aRÁY›5ó™ÕKzXîÀC/Žá:›-pP%™â@E`0ìu{žèžäYšùD&WìÝ]¦}>�$~{Z·Ï òPK3p0V.1ævñÁEªýi8,§á®Cf¤Þ˾a¢Ú©:ת6@wß¡*PÛ°ˆœ ®õ$°¬›-» #+«Š+X‘­   ­ökÆx¡Ì}~;Bñ%äÌxÅçËLwi±§wûê•î;ŽÇM7vËÞL÷¤En5­¡1Ù+ƒ=´Nßg5¡ÕuÞP\Äm^f)©¹Eî¯6èøO¬Š{G÷4Ôs<ú #옋ºV£Á÷ó—7ˆ¤XäÍ4ÜåIæ1KRÍ @¡ÛÏGtòf/& *’)gæq‡£ç ¤ *úsAÅ^OÒáVa?//@:ÿý /+춂ïÞý¥ue’±;‚»žÏŽ™—ˆ÷É{"³x˜£ªÍ°Ê•Ë÷ŽYx7é'¥•4š)Ù~rËo•wr›£³´ùèÄL$CB“ÁNÑ°.þ &­Á‡<¨ö³ÏÁD@ñ0²u¢ Uô´id+s‹08ŒIPvWů{Ëøp:¼7z¼zŽ  „ä$Èw‹…5€ µ 7YºŠ²÷8¤‚ŽáΨf%2Fßû²-‚»¯…‚ˆ7ÊW›ùâHœ»--–åYá—EgfìÃzæì†Ü}:*¹Ú/è½ ?xÑö8*lÃß*ÎÏTȆµ/ÙžñC2f8¸´F¬^]~Ãò+é1©¹!—–¸ëëãaÖcöm®›þEF.ËôƒÔ“¾FÑ[¶c‘çªx5r› Ä)UÛ‹J8Qk½k`æ©¢â³×sh'?µ§@Oí÷‡aJ¸»Ï~2ßoòÇUjAU ™—èÖ’ÍHSÐþ€U¤{fôÈèBÑŽ/Vˆëoeey*ߧʳ‡q›mRñÞ‘<M¾ ¬ñvÞº]¡’�yïr9°ßU ÿÂOòJ«ÓÒ»„¶Îl•}ãfŠúß=ÒÎËRÝq Eü$wí#vî@¨ô56mŠÖcå“<W§zÁãƒ*ìý_xÐ~#�³¹í˦r 4N)&âF7½í—SéçæÀòBTFØãlÛóT¬žÖî¢Â°Å Ø %Ÿ£R‹ßâ¶ubÞ( a8jpëæÅJ8W=‡‚;¨A:y¨¦"£ËlÜ#k×t?ÞâÇ&t™í_çÊóg•˜³ª›6'úì7z|•%>‘âqØQ"uvÆæ°ö¬q´Ém6LåŸ Ë^N¼0Ž=è¡«…¤bG~ )úo Ó&æ0 æ‚õ»pLlF<˼ŽGâ<*uwbVèÝB)ÍfOß>œ]ÍãV\•ÒäˆFœHíñë=ýó´P½.yÛ†ÞÕéW¦¥(3HŒçšyw˜þEêÐk¬”FLL8\.t$™@ϘÃå ØLáúMêçnTÌ5:-îî‹ÖM~¶41´ ºÆŠÔ^ºîÃÉ¡Q‚%þ~¿-Š’• „,JjË däñ‰g9²þ±gè'À[·‹º2£xæ„+”m)ƃEuÅÉY”q'†—ÿ,IýùÄxæ{{ÈB Îئ)76zÀœ£¾@CˆÒd¥þDÑ}zSEÑZ¬²þB§4Ž"o2±s§Û\:sn“¥î»£AgH%¹; ̤ÞQ·øÀøˆ?ï2ÃcÜõTŸ –ZŠNÆûi“ðhÚPÅo{ñD¯<v“"IcCÖÌ-›³ŸÂHóEœµê~20¯gr¹±­cAV𦠒ÖÆâ=;€3�ë?�WG5Æ–rGjîW®Ñó‹Wæ³¥H¥µvÒ>6†*ýÃxê»ÿÉW®(µñ0mgŠ{6F'£`"”¬,žø7×WÌ’¥‡ÇÃô~¾üǘ÷E[s/Y6 a«op"¬ð¹—z¡ %Z¸€ÿdõ¢ºbÎxÐôÚ^þ¼*b]yEìڔˠØäûú ~ýìœV~…5‹Ãre«E§çR [„NÉŸúüÅ;žñâÿÑôÝïby¬¬Í8—ÛlsŒëÞ}þNoË¢V´á­¦ÝδQŠç –ª…êå4ax~ÿ·ŠËÌm&­EAÑÔ¶rK ¼¼õiŸ“þ&5Sm§Áòhè—6¶Â*-O•]J¡0ìÛ/ð"ú ©ö4Š©âéc4ä]m›ò€s:8»fJôç7D‘æ¾\*Õpþ û¯åÀÊ’âFoщ´\lGŽ€u 7¼²G„Æ\5òñ9+£,96ŠÊOûJEªç"’®9ÙË. B´oœåbcT‚_hGÿeºé€¡¦AÜ9Õ-âWéE)§Ó忇á¿[„LÈb½ð¯NXÄ7ê—™îs8üUêL ÒC2ŒM= ˜îܼ¾Qõ1wßu¥”Y³i/’ š­‘___n@¢)ÄtÕ“Þvìú7H“Ð9÷‡K^z7?Ý‚ s•ÜðH•µ‘»EQåv=})'@ð‚²ÇH¢®Ý­Ì™îeÉZtâfcÒÂz ž»³è­ÄÁp¡ç>þµ"D©a©0`j×1kàGhJ’¯|·¦TfýEõ&[ˆ¡LÞèG>egZD•ŽÉ¶ÇÔpqST槯7¼jܱƒ-#‘Ô%à™†Ïo[ÙEå¬9ô)]6 Ä‹o)yüÏ·’æYm)ñUœY( À k4h‚Bš#&Ô¶µùƒdH”iIñ0Ôz9Ú&R^oÒDÄE®GŠD˜›ä¢©Š s$BŒL2·¸Ö<•©íŠïßà%nà&JdT[ÖiO[¹©YÝW ÆïÀM> §gj±Ð+òÌ5þágœoE©f¨p¾ÿ=¥-Vb<M,"uaN´y¾xøD§²kªËˆòÇD9 &ì€ ícØbÉc±$»ö°¡Ä`DÛõ€s::NÁÿ_Úß»W«r²¸yš™KæÊFu‚€Íáô–d5Zft°gA2Ì6w(*•E˜sÇpY ôx˜„Êì¼d‰8Ú“Qÿ®pÞÀTp*í¿ñ„p7«0(r>R'„ñ1ŠYݾk[¤¼püD®á+² ೸IÊŒÔ3Ø€LÛžZ ׯÄ|…E£°ùƒìœS™øô‡ÙÞÊ5ÍipäçN¯ýí 0ýŸÒ‡æq¡Ør%‹$‡’ÓójÊ<RÖ§3œZ9Êž{sE©" ó)9×9½õÞ¼QKSÒð÷*‹•‹~Ü_¼ÍÍOcG9\ùó¯ZAXÙQ²4[t0T­øеŠÇܹ5/ÏÆ’±~©Ìà{d ú¸Øž~ac´;ÍÒj5¯«æ¨½¢ÕÁ©¼Šw·Kj¨ï­+°qä1w{ƒ¥t7–{}’šw…QçòQpëys¨9AßbyKPz~äd mɤÍÍŸ,ÈǽˆÒ ù›WÕ 5~dÑ®¾KƒêâT…“ç¨ç™­&!¦Ù­äoج³]¹(Nëµg¬ ¿Ò*¦ª®¿K{ÏÔ fñ –Kœ—DXÚ‰S‚ùQc,qÅÜȤmöôQÏ΀87ýB£¥á¦Ýß_¿± „FGïZµlÖºcÝí_ës(hTĶBÌðX©Hª¬ X¨ÓÜÕÇ;!ÉÏì΃¥¦,¦ÚjÌãyN ¶é_;@z|K³b¥F‹u?f”ÝmoЪ2?ÑJ Ûøb¬sÓ±¿ÓÁ/•<rÅUÔLŸ¿œö½3 ãn³9UžÂ7œïeXT:£îÒAK^rt†Z¿kàÝ-þ.Ê-65æóÕ»´Lõñü×™xÏL´¸Ïo¿øYÑ6ÎWý"1—È2ò¤6ÞõðáD¹¼¿ÄS§ ¯¾œë׆ŠëÊ l¬aˆŽ—âdL禃N†’€˜NÇYÎÎïmQ¨›×˜y,Tßg…JÖì0t±¸’¼Uqí-Ãë¯ÇïUl¬]rdÙÝí¯¤Mÿ uÙ\{ð \aÁä.¾[™G¦Œx½ÀEuçÇ=ÝÒúþÜöåvf•Ýp4Ž”@8â‚”÷Õ²ÏlÙC_>ö/˜ áÊÞŒ–}LaÇÁ®s£p—{7¦ìà}±X¯Ç ó²jb%žÇvUEû<ÒFrGÛtÞ5Wóï-/_ùè‘æzζ¶Æh=u]w¥îæòݾò©Ì~œ ˜ºÝ‹‚Æ0‘K‚rq‰fÑ c*U�æsa,¨ÉiëÆ|í;†uœR ÑûÞýØíz§Tt¥F†ýrLV©éuÅçñLw¸±wøp?3"Š+ég?YºŠMü(Ò,Pk,ÝûGFfZœù0}Bẋ;wÈM£ÖÜC€=¯­´n|‚kx¨-“§±]@"Èèÿ° ʺuÛ„âa‹ÒÓX°õèWùÜfïéŽß@Î 03B)û¶ ªíÎZ|¦npì.s0tý±¶‚Sû3DDM à±j…÷`dñÐ@:LÊ÷F‰# í½÷ZGUƒøsõ½á7yPwÝAP ZíR5¸1qãXD¯¿"ðùÏ›ª/›ëAcÎ'úú<Ñ4Ó/ï¡÷ØN/]yÆl¸Va»õ≛ÓQríÞíELY®Œóx³Ô¤=Ú ­•ð}oÓÅ9HilÏRêÑ:¬ÿ`@Dÿu:ÞM…µ¤0¨¾Åžã1X{d À9ïz7Ô²¼[¦–½ÐHl9"êéø¥H;õ`ÅzŒ*�Õ\<~£GfJq±œôÍ»CfˆOÄf¯5çèHèN¼èõ£1ä\/ Õ‹Ó§/á/'³˜z½x‹ýà‡z¯Ñ~\€â¼K‘áÆÆã\O÷EÛƒ|O`O�I ‹ÙIqg(¾õ¬¿rðú•5—ûŠŒ5’Ç°k<¶ZÈÕþ¦Q¸Î±gsy¬}µeUÁÍ9ÿšG”Æúë ÿ(QçÜ)¢ýæQhz<Ëž¶C΀SFg Š„EÆ<3Ç+ç xGïïûïµDŸp¯#ÊXŠ Ø)Õžæ*ÑÁ´l„ö† „|ÑVäó©?€µü]È0õÔØJ(hô¶µí$@e¯î»/èÜÕ¿£¡åáÊ$œ¹&IPìm/™Íën®©è g7Ÿh{—¾D5 ‹;7£Ú ¼‚¾ŒŒ7yt<Âõ·á…VÅü*ÔÅ?<|¡®×_Þ}ÌŠÏ•”èÕHð—ÃÉ{6I³ó5™•—¹MÜSÜìSÊrǽ²PEÆdÒ=ÁgÓ© æhÝêË»ø¨Rƒè–Ãç´¼X[“‚mMfƒ–yÉã´(½ê/KYÓ‰˜ÐŠ±›Š;¨ÍÁAçÔt9¡ qùfzŠ±¿=·üÙ¨•;O4_¨¨If+;P䵨ñš–´›g¯¶ñQpìߥnËð6‘¤²>émðnÅĬí®—ë$‘ÅD Äu�-ÿ¿oásA‰<vj¥ÀÁèéM²â¼Tl¹x:úaÀý왊Mª‡Ú´D§}…Ö…7ñ¡l9Z[Æ?@Ù]ÍÇîsq,Ï?dë�ºÿ}›«ÊÆô<€Ý•Rä)O�ìÊ¿z¸'î*)””¯Ö?(¹-³:(ãͽÐüÈ8JÖìnžåã|ütUo*¤R±Ü®{ Dm`æÛ~“ƒKÉ£rÅùBÿ„`grr¡ ¾ñwbHùr9ýç­2Î/)¯àRêÒùʤ/§òÉ ôãàØvyaádµY'šïðµËÿ“P/à–¯ EÁΦHŒ8E¹¥ÂÍA¬¯eÆéZ«öxá»F\AoöEΓ‚ùë/¾5¶-ÜÍ Ž€¨ÝŸÏ™…à ˆÉpv£‘€*ÀA!ï§~wPMKU¾ˆ/-ÒôÝùÊ¥Eme/¥æ‘t÷©çÐ|dÓmÎiçTAüù×s‹( o|G!kB©ÿ°øßgͲUŸµ”1^ì›w›F‹”¿V¥Û;f5sH§Uà³æ˜$µL é,X¥Cdé‚&îܾ¢º·Úuã2è'Qõýþî̱„*lظ•y(­.‹yEEieéÇ5#ê­ù2›=øo-Å¥`[¤°9tô½è$£´3±ôë &YW¬•;Û¸P(†€íGz$…ÑѶh¶¿}£r†fù_…™ç…FáÐSî,«7cÏ ¶¹]oËõ¹a¥Õ Oñ\&²ûÎýäk^%›5[Qãä�ˆÍÂ!á¦ýV‘:eA1›Ó!… ´†}�—JÀ™ÃÜ36=ÐÞ *V6kG‡Ô÷%Ë/ŽqL§Ùâ¿“U¶yÄ´¿Ñ’¡Ñv»×nâ'~Õ—(ÎT¦[™&ABy¡òJªW&Ó—S?»ãýuxX ûö7Ž›=·¿åêBáj¡ÌÎþ€âëîü«Y¾©kC—A´X:ˆ•MW8ÞÊÀ¹ûím¹‚×Aœ±½=àÓ¬Œ»ñ¿ù »”œó”)Õ‡õ§r ey¯§ø¢ß«vÉIØg¸-è…Ú� éAß< ž¸ÿf™‹Ð¶Ü,•²f+ªÓt¤xp ïXOŒÜµ¯ÀƒÒ¢±\Î,ö&BŒÁ|dK¹© .yÑN‘&Þ©N;M«cßR®ÿ{¡ê±àÜ<QÖß9;¡0dDaœI᫼=##6 Ü,¬×B’²ÿe7Ô=×SVæzÓw®|³úä1[ú"eúT£>d¦-t¿Û¾›þÿŸùÍY;=sö²ÒZ ˆ¿£cäÆ÷Ô‰òÜ ½.ßØp€jÒÑçüüt‡oÿ}KJë­Üv›Ã±¾õ–}¦ŠXÅåKU½÷Šá£´íÍífŽú�¤­Ü­çebž*«·”Y¯SÄí¢<µu"'ì öþ£‚-νB¤xK^úÐWË?kx}ØiË<rÃã'Õ1_Ħ¡ÓÌIÁsØÈAcx²( tS¥\±5ÿm•kù¸-°þyß*­~k¨gJçŽn ÔXñ �H«îy;nŒoIY¬<¬k'%ÀƒUû‚R¹×¹°Ïìhoû$§ IA+ÐDÄçÿ¼Å‘ëƒBŒƒk1*÷ÿ¡ÌwÙ”j,}ÂØ+ÿ7 S® ™Hf(-.¦N­uÎfœ 7ß’´ÁŠ›)ߢVši[Éó�`€-#n–Ž'ÂqД‘2¢õ?Û°¤E¦í™¹ ’SôrVW±I=ãß&»q\eÊ^’–àòIìn1_MÍë"†Ãò}–ÓÄÊNêµñ/ ß,¢q©pH&ÛÀ9ÇnÂØd<�z 5‰'÷š-úöõî®Ô%æžÔÆŽZ(bOÆöÈDùåÀG yÁògUobZ¥÷9m±Ó½kÑïíûRòÉ#|Åd' µ ½ûxJ(û=[a†-Ï?'c²#Kµ=ìvŒfñ,Ó•(êUþsŽÝü„C¶ôÃîç4}ÙbI/æØÏ6jžPNÌÑ”>w碂ýé¿ÍUšù7?×”ªÞ ³UnH«�ö¢s’‰§rmqñfUbÑm4€¾§o•„æ~ŸåYüºb†Ð˜ À•TðØÏÁ¥„БìßgiTæ‘I J#^Këx»˜‘ÈÇ�‘¾ãÁÊD)„ ¤‹‹ðóíùÌrþŸˆjSPÇFª¬Ÿ) ÿ|÷ |$?íþtycQ…ù§ás®ÚmCÞ2»ïb¨Qz°ÕÿGTHVfk`ÅêÍå`eú¥æñ´˜ö5PÚ,˜ÝD±U]™4×ðÄI7……›Ý¸ðŠSýa†P²ýèÕËÉF±ÁZ±<0ÚsÞä^Xž—=Žõ×óÛì,PdC¡N¾A\ï}BÂ}{Hr:Í—FLI‘©Î[˜ðœ£Ü½ûZU¤û<éM:º~Îa4mT·ã¦õ¡U¹ö£s‘ âÆoKèg8µø„»Å( sÓݯøblÎÅã%ð•3ŽŽX½†NXP9¬ªRgŠ©û¯>^&7# d®•ÃˆS5Á—˜ÏýÒ\Ck<F¢dy»÷âÉÐät(S}¡úlÞ¿8"Ï`ù+Á|°™zf¶b ×ů“Ÿ¢`Z„:ÁÝ“‚*Í‹_ŠM7ÐZƒRÓ©G%ì”5~hé<2T¹Ie2èˉs:ÛÀ"è0ÚúIÉT?«ŽÒ*O3sGx&pØ•Œw÷Ä}ù¾oõ8N°ïãí¤,„o~|¢–P9טÄM6sDÓV¹õðY7ÐV¿!RØaãŸÑú/CE(†Ž,XÑ`Ç×pc4Â.0¿b`¢¡d,ÑiÇÊgµRQÇA6�ÏmVÒ<âÞPˆ`“±±z·?²%š·ýælg¾p©p¶g‡¨=h’uL{f/…ÕÓÇ|¢5̓’–ÇPödß»=4 çŒç©?tçU'QÏlˆ5æÞÒÔ+קX–4{ºXoH.3•\n»ÜÞ;²ì€0µ2Z ×iöV+€í°0€äƒë¨]’ŽVœñ§#o">ׇÞÁð/Äã½{Ývƒ¡;Ü¡¤^THº› …ÛÞlè‚­C$œÌ¬º³¡»Häå±è©"3&¢BŸóËa€™:Ö1º:VÂϼ顩Ä÷Vâ$bß³¯j¶A¿vó«+ µ=3RÔ! ÊŶ/ãÚe‘^ÀÛÞë—Çh‘кšôç4¨v½¸¯3}OøÛv79ðûWµàØ Ò:gD³œBõ áöþŠØ]¬„0¡²QÒÂ^ÌÂF½Eë𦗢—}%rû‚€{ƒ»91ÀùsQ›%ð|šœÑ9DÝP2• ®^ïOº2-–¿mPªÍwJ-ý½¦Dv°M>ÉñK¿‰÷[s‹Tø¤Ê?+Uþ�Jdƒòù¯¹ÁÍXט;ÄÆ�ïäôr¬oVM+-­Å^©¨äj€W!BŽ]”ŸµÇ0B ”£Øœm×Á{ãͪ9ËèÕYf<W )o¸È*Áñ�ñÑygOvøžÛÙ9ZSXd0·Ët¢…sG*¤ Ýèè2ÐA•7–Ä*öăaÁˆ ¨Qé{ ^æ  6ÑÉÂ'…[]™ !v"•ðù'¡¿òÕ*ÉÊïfÁ.ɃƒÃæ´t·#Áûðn«’|Ⱦ—Ým@ð‘‰f–¸yW÷7Í”¥ œ’:ºßió®$¬ø(†]†áSòùðãM“ÈEQ¸ûJ*ªNÄü'v1й†n.Pö Âr´S§Nl²k ¶”%½[v½iÝ%5"Ö €Á?ƒ3¬æŽªiÑ^ê;geU8ýZ¦ŒAí\þÇþµ«÷Oÿ aNé~Œó¦hNÎj ®ç=ã^ Ž-2&Þ~*ª|¡ÏÃ@0p²÷ü·ª|Qêz|fÿá ;Äë¶å±“)X0¬wÖ‹­ÍÍ;;Ö‘ú±qñ´¢]fYÁNÌô¹FªIR¥è‹fAê|ôRåýà?±R1°Oíù¯Psk±Â­Zƒjéy˜>·×Úý7¹¼¢'W(0Y]8qÅ7ûEK_{†¡pÈ(&cm>ÑÖ*Ü}Ûõè\½ÛÄZ‚äì¯fÀ�]žE Ûî_ÞÑh µÛ+V Ð{ûÙ¡H0ØѪ–þ"C¨nÑõû3…ÃÏÑ³àŽ¢Õdý³þçÍZùjG(Û+­)7êNYG^Œ¢œÝáÏþ—Í(hÌ÷~u¹NݭÈRά”c4Ù‡séØóÄW0ÇâÛÁ}o¨Ñ�¿†Ÿ&N  xëçдvæ#î Yz±éöRœ…ÇC cáýUÅ—bw¦“ î˜r¬`¿|îÒzq˜F$Õü"¾þXO¹´ÒÕ±™¹m¯%íëƤ…hä4†²¦Ú„3-vŽ.:yˆˆüp{íÛ›{^„>ì&Q<ŤobÊî#¿4ñ¥=ì%?X[zíú2)â %fìàgÚOôt¸o#/´M—Ë/”Ô«LìÚNÙ|nƒ £iÞ-”éq{îÙá=ƒ¿öÙº´�˜m;‡¢À mÝzý­o¯ß$Dœ“PeÆ0óŽ–‡S£gJ–$?nò‡\«f§;{uû®I®B>Ÿ#ó‰¢eôiç±Ü†£G/320º\å“ÜìF]®*í<ÓûŸ¹ƒÄÆdEÚ(žZ©)ŠºTEPf¸ôUÂ÷µ›*,fNO? óùîÑ:4ŽµW¸•Çôèõ›Gœá"C; )ƒ¤?Â4÷%;ïhÒJŸ‰R³åžì±>˜ lþÏØz‚¾ÙÓ±N¤–̨˳œi~î”4Ñþð2:±P²WeL“Xã flm·hRÁY:[·<’Œ•ì‰—¹PY.[z²ûEiP¹^›!cÚŠøðk¶KQ‘yq?n+öC¢&ëHonŒ€Œe„â<Ú,À_”©`æÝTOÖ»& ½¡e°z?{Ïd ,÷«±=Ãî´lì?¢´R�"”dÀíhz÷pÑé4÷r2šN Kbzè€óVmoM‘8¹qF¸ü¡£ªw“XTxjcž;”˜~¥«µB°À50ÀIýWéÒ›rSJP–@£§ñüë” åD„%õeëì« ƒÉ2 ;~à‘Ò‚Ž•`Z•-÷yxÆdú#b…Åü²B×y9æŽO‘S,ˆ¬åU­t:9È)`ÕË¡m zÕFd£¶(3õ6Ÿ¶¿³¿¹ñDî^DâY9P‚;Iœh°u#ù¯[Ï®öåšÃåùªQT#ºP¹Ë`$Ü�ìËám®ûbköuSO5W‰Ú¹peJCo¹ ´žsçf¨ÓW7øÞÛGwœYôàqw€R¿²X7iž).Fï¶Æ¤¸oXŽ”ÇS’5äh ý½ çÌ…ƒÞ;m¬Â˜b@ý'rÉVf~,¿í{„¯«ˆ…h¾›lŽ…ÆŠS;#Ñí`Õíþó–…oÿ}Ë ±€Ž_ˆPÔ­|á·Ç÷áÇ* u‰oãeo™vD,EÊÙÕ±„ô7ÍSn¦ëp¬)“êšæ”AÓ×”!œßvÜZÿäˆÐ–_FKåRGêÙY]·Œ£ÓÀ‰Ó ¾E=™ ¹œ«'ƒ?º‹ý(ÕL¡Â©;_ñœÏ¶óW°#Y·ñ4e4áì°Iˆ÷ÓÉOêRE§XéÄÂrº*`_÷ÅÈi•zÙ‹<³L»nÙŸÝqg{®À%ž>ÌNú 2^IfPü±€Pð®z•Xªâm ·wÔ¦½úz]›=b±EIQÅ^å˜Oïΰ·Ë ‹}}1mïàì�ÅÎYÖå¬ý1S²@yAhúÒ~ã,»Ö6^-ú#ëxlil¦^ådk(ŒàÔË^Pg÷_O'_®áecDz­(Y¶ Q4.Ž5þâÖ4}t زúíÏ×lQ®Fl¥¨”'ý—¢¿ë±·0Æ]}DÚC«W¤Ê_SyÈ4Å’Ö]$˜ä¼Évüò6€ÿ¤ì("uÓ ­±³íœÍN@k3K`<[£:}ù@±LI~¤g£© Bß!¸“ìÙ#÷ë(gw‰©d5kkÈ™Pk¬8/¨à¸›T!wé-»z°(<˜¾·ýúœŠ2â{¯1ª< £DB~L‘È~Ù˜4%Ój;0QAø ¸ÖIݘC-ÆØ„VÈ®UøËÑe(;…Þ‡_˜—xè¸t¡zC‹>ë­JUŠ“‘ .k¨‡gIeìWX×·pä¹a 4RGã‰Yjž™‚�•¡ã1ÃRå ÝÅm¢]ª¦;“wšžV`ï¼KCøMì&uì,í~mÙü̹™’ÀØy ÎK<ýšü¼e a‘³« €ª\¿?ËÛòØY[HoHM°àý1<k9Ëfìðxþ;j}dr¶–Ž­´ßê±Q'^h¹\‡ÅœSð¥}Þâ·Ò?Iîq¢p9íŠ û´x$—¼Õ(E³,²±6·cÊþŸHâ*õMp÷¼Iÿ-ë‘Fn›.ÎеHkW—˜<Î=e›ËÕ6Çží']ˆºO+¨B­½ÊÄHˆÜìíV4mmçÏ%>,G_tb4Wˆ>ó\G æA‡î¤gHƺ)0LF“0Šâ &[š¾DuŽ#E;/dæBc½D!Ÿk×þ8LÍõíxþêOZOòÓæú=æYZU¦˜g©©cBiÆÎÊš+oBKNV(3“™!:>OUã"ÔCEôÌz ]c2â–'ã_ )¢ž Oø¸3ãFvfˆ²I²ŒÎPÔš°²æu³Ñ~<)g#º4m Pºvz8\ÿ­Ü5•ï2aôÄšŸüéÌ>qW7‚Æì.ÓöIP¹cŒ»'LT¼y Õi“ÅÞ¿ÔΪ¹±M©é}‹ÆIfaÀ¢%Ü�C.ÇL—æ^êê¶Ûé‚GlT­Ú!)9MˆÜ“s.né–_´ _®Kù·ÙÒg.‹¡ÅâèN=…èay»¾mºþ:<4Ýôæ›Uᑇ"ºÄägí¼ aM­Æt:rzózR—Y•P–«Ÿ?"È)@í®ÇÜÄ&û [©ï$w`4+à¢~Ðâ–ÑJb?Êå†ÄïW'+Èlù¾sàeìGÚ€‚yrO¢T¹xÐÝ.TÊ»w.Ä‹Ž™ƒ‡AbÆ1Ï]\º«¨Ü ÝÄüÖ8Q¬€hÂCßÆXéƒÎ½df8'Ûî:=~¬‘›œ3‘‡Y£¬Ü:OX‘ ¤€“—†£/Òw<Ó»©¼Ì,˜Êô0H¾ÄŽ/f{)âáÌK_îg!¬!Eq¨õ¦BÐû3MŠ-¾›ã]¬ÛNø6Z|,£ê 2"GßÛ¹ü9R8NfLü¤O±yÕ¦»Ø@€õ\NS®L½)š^¶ô9ó÷«ÅX^ÕÅtxiëðËc5µ()V´äDÍ°½7æ‘#¿9~~P'ÁsaÃ$N*lÀ»×tS2“\>€F `Ĥ¦k°…³<=³¡=Œéäìãáʉû سcRÄ8Íͪÿ×ò.N 8¥ƒu¿£»Ò¾«~ýtjh:Ãpˆ7œ˜{ïJBëêÖ—U‘fftÍОyZŸÊ˘aA(`1xKiß_?:=ß>ÂS%¹ÞB”¼î¿@bµ f–»V¶‡@ìëþ°­¿žjRWe¶šò¦ÆjdoyÚP ”š,JÇÏž[Ž8™I¶ŒŠRV.g­Åh\lžÙ4 ˜!ñ²±Viʼnscé°ëiGeí^‰ª‚áر唕Àî.tƒý§.¿OA2ûáÅ&‘Â�çRÍÎCÞG¾ !óS2kjN2!S=9/ Sï’9~é;¸Zd)�MZ°Ä¤|àÃðÁ]þ2#KDerw†WÔkZ÷3ö¾Uâ6VÌ<Î.ÕV³ê^SÊrfž€¬¿[W÷w½Ù"­S K¼ £º÷0%9Iigu‹9Ki÷p…o_‘–Ê�ã›.ož¬ú3)ë;ÇëA>àïk°ÊV×yCå½Ípç!WI‘yŸ@=Š:Yï2f´|N3­‘“§ŽÝða6ãŠ&õóZëàƺ«y4½(ö€LP\· Êêäÿ¾Àó6¶˜PP+Ó žç8ÈçÉ|—?‡™‡ÍV0¥² 5dú.Ô¯¥#Ö™Î,¬€ÃÒ0P(MëwSëìkÜ4ð•ñ›ðZH›´²4].ÖÄŽ[‹A¬B­GgÃõÇP³Ç#MìDç" êb,XmíL&Ó:vTÈɦÛã a¶V§Îa{ÙtV±¶[zoò©m_q@LzsÉ*­XàÒÁ!àC!_ÛÅÝW ±¢íqçoÓ€=9jeb[ÍTHô–ñÏÌSŸZì„:"TlmÓ˜ªÇ^ä\;s xÈìf¶]øšÁÔ—›ƒeî{)‹¾ìèàßY¨c•3h­›þÔÞ:²gð?@ã\!8î'ú~Óäñ�ÞžÈ2¦ÎBvÖΙ¡[±ßT{9æ‚h¡[X “‚ú68ôjK±˜(îqZä.Öb" ·)êlbÐ[ëÚzâwž`Qœç;ˆîJ‡HÑØæÂ1Ÿ7°º–o°9}†Úc®¨Ã{1 ‡îË8A¶ØeLYù¼¬-X¢�vâÆ-¯“0(Íë ª&5—”Ð1ˆM ‹ ›” ·î»õÈþ×b~y¨©Ñn’ ê'¥—{"÷è!_è+4Пb¾²û·§¿…äRêM<™Åp=áôs6¡êXì$ªEÜ¡Ú2îŠÒFfñ¬ËŸ2ˆ;Û‡}»tT÷ E™ßŒ"r+r¡+`È+Çi¾–l,‚žÇ±Ó;D­@'5}׫X†ÎˆðÿÏ„ÏéØ­¦5e‘–öŽgl´MƒlÛhÙ:ºe1K‡Ö†°è~F"Ñùè¢ØADëaŸ±5ñÎHÄq¸›M[±¸i"¥d«æjº|¯ÙÌwò›"ÎVuÊ7” õ`qlŽ{«à{5*C|û·2.õŽhRñÝT”Üö¾G Ÿ›ÍÁqr%bpк~+—G?7¤ÜD ´1°¦›oí IkîX†Ð¤jjöJgÏ# ‹’Iò š{Ÿ`€¾¿r;Õù¡´®ÏŽ­V#û–w­ï] ½iù#ûríT‘ÙöÇ–‚Qí0Þt΀W͵$•P¢šq™:Z&öÅ ‡µmûHñ´Û[ €2ž€î2­tð†$ÿdI¦¼ "ˆ^Aù~Òýݽ*cø¶áh²©åú„ª2¥#„ÿ/Øï´²€ ™áEÀQr”r˜ÒBú°nü¤G !H@!ÑÙªSÿçÎmöt¼Ö?×E˜¹Ö|,@ÇH“=ÂÆIŸ:ŠýO¤4CÊo§AT£»˜ç‘;Œ´éèã•TUær;«šéŸòÓ ¾�Z,Ž5Úíî:3Fü<F¨JÜÇÂÑ/‚ÄÙŽ¢CI¼qTúÛ³÷îìºRNÔbì ¯êÔ�DîcµÇN<@€àǹ5×7Îæp?ÿZ™ȩ̈ܙPg•±ym1!Jˆ¾½»\X]iÕ}‰:ñošHù¤¤:ûÛ×W?¾Ä«÷z5‘jëŠ ìÏ UOÄ1d~böÄ™¨©)Z>MZ]ÃÎtNO.K7:ŒNz¡žFÿ‚@MÊLé*Rž²|AôÙY86¢ÅÒ×LU¦;ÄX%S•èk9îpH*Bî”)_‘7Ò3L‚‰óñ8±Y„•¹dñc.ZË!âÀ†©çI ‚ø/a³²ª¹Ôm§M—q¢àS#k4¢Pç–Ó‹bè8ç=Ê!O§SiN’f¦?Rlmq©g£è`#‰™ÁÙÈ)îç3…Åÿk7r=ß›yH—é“«7çI®g+¹TÅ*ÏæÓË+`Õ\K­¼%vl¬ëš=¥^ùΚ—€åÐ:¨w¢ó%9ÊŸŽ§¢îõn¼ðÐTip ]�å¬P\FåÇÞ$“vîEX÷ÞOå¿, Pj'HGÖtcz[Ôd¹ [W°°ýGxô^¸ÔÝý§ÿQ¹²eF‚`óÖ£_΀E>Ÿ ð³9_Vyü ;:zˆÑ[KòI9¯¶Æ7{˜ŸZ÷Š†“û#ïjÅòa¼p‰»M‘Q“Ešqºp¦¶ˆkò H¾»0«¼Ò>zH &v²Dk Ò@ÜM°ÂѲ³ìë±Fí1pA2?s«Œe_§A:Úœ]M;�±&¥”ñaiN-ö)\QÌr…æx¿ÙÒé;\T3œ2྿šåòód7/ ´01¬/f'±ø¸ÕgßM5Sâè ‚*‚»@B˜èU–ÂOá&v5º=M‘n?èïyŠÉŠ\Mì0ÆpÕYT¾uäÆ¥M¸j>Lò) “ÂöY33ãžöåÄÖfß Û«Ô›P^¹_ñ’¦Ã¯=pfH±„;‡Çg#ÍáOì*\ÉØACéwñn‘ÆyÆŽ¸ýõÍs©ägFU½tQ\`UÇŽÎ¥÷ÆŸK¬š,Q VòÖ¸µi¬[-­HKÓS ïg`s|.ZÞŽùÆ7þ©ÄXôE’):íz€TŠ98óáÆÑæ´ÃåÀt í—Ki7Ï1µ¶VÖÝ}œh%›)"G§>x˜ÕrºÇ0Œ<â‹g ó霺ªæt²VÓ³T´n`ǵ(÷£L<RBW¥9ö_tH~ZóIGa·ÚÁ3`ª”÷º¬dõã³`éµ¢¹Ž¡þÙ0NúmNÀàÉ°ùˆ cßm%Ëx¦RåFvaj˜“­³nTh¢Êʆ®Û|þ:÷×z°!ûn³%ÒÚ¢:ó‡AÝé5hþÏ_ö•-tÕ™»_O¸1µ“%®à!aKËÜÝ4³LGË!NXÀ†ýO Dè Δ#4k”÷üîY7”‰ÏÌséãçT¶öÞ²} JŒìÍý©‡ï˜yâú#nC·ì¯“T2*Áóµåpü†¿PÏÿ»³µëU*¾,¹sNáe%VÚЃŽQ83gòËàyo_(:¢ìQ”RæÉèÔÑò÷>ڬ⪿úVf”‰FŽQ:1öi®�>€·QK´ý×±¿‰-þ"RiPÄ:ŸtVïèŸBkA#J†rƒ(Ðõ2öTä[-| 8¯$’ùªT®š¼„dËÿxñ\J !kV? Ý¢µ²¾xÎŒð¹£ë˜õT¶v2—ÖBUAVyZº—éMQ¡Ïjÿ™>í²Õãî©î¨rɱˆß±2]äLœ·s 0…Cï…œ”2¢Gžïˆ:XN0~½gßT…+tL´W@ógåïlØ!vYrÙ{9 |ȶgTúßG ™Y Ø‹â× ò[Ö¬e39UÕW6÷UÝèN�è°¨[o9‘§ïNHÂåÛß» ¾¥Áé+å|ß‚�";/Ô§ùætÁ—7Z¼«¯YV®�Ëy0Ltè¡n—§V&Î�Ðv+¯�ùãÓf/>‹)‹ž?B/ âý¤ ½\²f‡EŽ{¬.™Hh›&È@¾ý‚qe^ÙsaGá0™¶Þãîý´|Êr³;C:V‡—®8¡—ÿôÍI/oð=h|å´¨òET†ü| œ=”†F²Óù ¡v¹ãtžó ø´£«ÐÛ]æÿ¼%ÖKÉþÚ :¯¢Ëï/ ÀA¿y¦´–ÙeüüÁÒ±&´¼È/¨øª‰l%^Ú}T.Ëf`æiì¦zQ†"mÔj žl‚&f‡¼þ½!Z®”{"a ”AÔZ®4:¿à<R 3?àž|;•zÈfïóe­ä•×w%úg?FFÐVÎ&žY4 XVk1€€ì×Ïá'¾·¯ë’Z9¾²H dO+º#Î/´¥ÒÜ‚9ÐSÙMÌdŒÚ§i¦¡Ó¡�(¶˜þª¼ƒ2üÓd%{.LÕ¿Œ ~[(ñ9-w~ÃÖ™âSÇ´ôsª!þ^½›ÇÄqŒTlHT|MuV»b®Q€4FKþ2è^|ωlZÊ\MÑmjD£Êþæ;m,IüšŒOlj2šé¬œ#-:[îέüî}{ÁÄ·2œÛ§/Z*¡Ó»GS/l.e5öîV(í_\wá9¶‡¤±h¼B€@rÎxÌô‹n_õÊpEö,°n"6ió¥[+Á¤ß¯Ô! ʹTÍè“JŒÿ¯”½.RZ“&Q\z9çÏÒp%92?&¥ŸûqÀ=YœÂÏtO¨*Þ´ƒâÝQê*Eöû$8³È««k³‹}›Æv˜%NÒÂÜ)Ø8eë„à\™+,߀£‘ãõ—öðHÔˆu§—9 2g]E|¦À÷¶³®;¯ºšó8WëGd¼6t_’­Ã¡V<@™\L€Ù…«=Õ«C"–z*Ëb(œvj,Dÿçj`“»²Má¨EgÚÈ‹¡€5O§8!Ѹ2ëÀ@¬þŇÈ8¶Y!í�Á2Èš½ÃB ÅÜöú¸8{ÏŠãÁØHœ(?9r]õÍ…:ÎVÅܬ&œVn[!Q8 õäÆþFÝ»únÉ8¨:Ñ9š[YöLXaß]®üÙ¬Çîk¨S¥©ÂáéùµWŽÇó0TžÃ†>?ÄæH’@ÅÏd]Ï$HÎÞh>_ÐTµ=œ' izé) ƒì}ïµàî:¯?ÊüèçiXVøyƶ’´ýC§åÆÆ«âF¾rœx¾ÿ£È†#ó®]äÛÆ´Ú/<èCý欩&oÿ}£"Pè(©ãÑ3ŒøŸ¬ÉªRË·PA?C4·3¸ÌYÖq0tݸ—û*®dlM ~åô³µ6)€™®P¯føØT·×éÉ<¢ÈoÍéj*V]ŒÄ€^òkÆ<™–k_c¿¿þNK‰âTÛí�ÍÙÁ.°ÞûÌ�›q§ÓSEӹݟº…Tð#Rhî÷”)½{pwO¾´œ\›IŸüît•ŸÉ3]A¡3ÀE:Ú&¸¯0ü­níLþœÇ‘XG8‘ôDw˜g²«-MZøÔn•ˆr­]%¢Aïï+ká»X$ÏËåÓ×—¢qÎ R´Ò¹¾þÁT)ªr}”Ðz<ŒT©¥õÙi°öˆ`9MÜ\‰ ŒÛúë0˜7¦»û½JwMC~©¨pFÃl°º™OÌNïÓ6Îýl’J:qŸó‚\Ø%ÐetdUT:Û8‡Î\CÕÏmJ ù{z, b¡¢t‰ªäwW_†“n²Nä'côü8_Š${ä)e]m³ÁQ,¢aHÑŒø=)é–mm#%MÇÀõv�þÍJ‘ dô`øãÒÿÊLNï]}¯n e“'ðõªÊUíñ¹ï)ŽÕÞ‹‰Ud€¹qh‡2HçÞò÷qòSQ¾˜¤^ø±Ã*yí3;¹¾(7 Ä´¾ƒðóêZo•×ɱÙÅaœysÚW5ùÔ·Xèsm„£ÞÍ5 „©€o¡çÝ:oæÇ ³¸ðË”eJÁî Q%5ç/·Ô3zÒ{ÃUã b¸Y$û=+wE �Ùäð·ÀMã(½‚q®Š(Š$:Š„ýÅAìõˆKǼ5Á\à|^0ö+É3¹R™G„ý`>9ËBѧ”ô‚ €‚F‘o†‹‘$VôŽ¢_Ðô¹ÏTr B[ÂÑ=±ÎDz¾¶HÌYÑîé~ìj‹¾1M$™†Këéî‹"ø†Ò3 )®EL¢v2„=çÈ6b8åuå£[¯ßQp‰¨`nlÞÈHùpøúÏ›™j%9Fí­õåkþðÖÌØn'´7àÉóéÀl{4BäN׋G0Ö—!=_Lé/ùÅñð?¬Q%†:Ú²úÓ‘ RfY ´ê‡³•=D/ “=Öª|Þã45\¬ù#¥ªè¯Ç3jÀ·ï6"5ä®îd.PU©EÏ|ìÊ ÿZ¼+[¢zrS°ó ìoØå8]²`˜�h. »£eáMAEÔ|CàRÃsTŽÚïÇyš…ZV[J±Òqöª®ô‘ÄpÔ|R#ß�9Ì`†~Ÿ<¶Ã"ÖoýŤd{õš 3ß ‹Cû~–NAø¥c!+W2JjAeØïT/2^Î.U7 ¦®Ý`’¾+9ÓÞý%úÈ…?‚"¡³�6dùàÕv’ûÄ‘«†‡5 |qXXù"=ã­<$A¾·ÒÝ´m`T†™Of XTF­O¥ªh…ŒƒþœÑ׻ꞮޗüØO%”5K$ÂHqÃÙžùBÂÅÅÁ/à±ÃŸëXi¤úKàL”¤µv ›CL«¯…¿dÊ£Y+þê¡ìF¡üA˜E7v)-ÛþÈc£ÕU#§çâøØ+HóôüÝ1¹Ò0ˆnY´J²Q±9؇RÆÔ¶WÊd=¡Vÿ„/­ÒPùƒ Hw?é>Í!TkÕÉÁLF ÆÚ:8úuñÔ4rZ½rµ¤½ÎNWQòqM#6㟕g@ÄÌ·0¢Hü ’2¨ºiåðM•ÛÊÒý5RU•½53Û­ÑGÝIP9Õ]Pü¥e„ ):Ž’ÓßþÜÒÞÎÇïY@¶â;Pf~rªG賫ìAƒb~ý0ïÞE®”ô:9iD;§¶ÀM…ƒ%B:ͪ—˜°Y¶rù¡t—ÁèNÜÞ»Ûô”&w¯¡Û£ÜHCÈ€ˆ�件6ÝÒ-Ú7þ†8-¬V¾±ÏjÝ�._Wh|¿]³ (Åu kõÈîÂåUÁ çW8í§"ˆ÷öÔHX¼Vô†öÍa~Õ}ÒÌG‚£N@ ɃrøëRþ`œœÎÆgä‰S¦£þFƯ©)ÐfõE¥µtÖ/ÎwåÚþzûbºž6~è¦PRhsY°&Ó"Ȧ޷T­¼7ò¨ý©ïµü¢h‚G­efôy_ìŽX"cî¦?§Ãäåâ_·ÝÊ#ïNb·,t3ŠÙJ󄱦*­¾8\_Ðt@TÓµÃ%•¼ï{Å8ž†£¢ÿ™®>Å>JÉE–ü IU¡j˜3´ë¡asQ2Xl¼f73&8,»‘ÒsU2Ôgmæ1´|䩯¿ÿ›9ôÍHS2%ûJUnC_ ùš|kkÃ&ú5¥7Ž]laÖ+ÿk[ÄX˜¨]?¿·Sò-&6/…òGIõîbây† FÜŒbØÓÊ̈_ŸÖô\2í›{8¨ê;ex„Èéœx ›î•Ó¢Ì<ŸŽùÝàE•‰QH÷‡¿5š5«|äô›þÈeÀ±Ü¨O-ó–û¿¶œœRç“¢…»ßh·V”¼wö{á‡Ø¨ç syhT]×"ù\ÌJ™–'v¢S2ØžñÞ*±jÅpÓúÚ1ëþI·$ú¿<Ñ&tØ…psê{®õ©Ekg˜>`]mJ•�¨X÷Þºøj,p*ªú°Ûqwž¸º[·Õ4†ŒÓ5ñ0 –žÆƒÅï"\c‰Ž`u Dñ¼ù ç.îWØ«¾]ÊÎa3ìNÜ´Šý›¦ÓE–pbçƒó0Š¼søM¶}ÚÉ ,R¯Å,/ÐÛl®ÜÞݽ,(è #ÆP-pV=@é,È‚¤Ûz8ÎN¶ÐJsßþ©ï¿D´rá”IjÃÂ:®úºVÑršN†ŒJGƒã/Võ¸AËB]·R‘,ƒ½/߯™Y’oòøùLω •¦?½ÌX/{§‰#ü(ßaó’jÕï)¨Ê©‚òb!¨ [jvrX, /Ü5O"g^„PRU›i†R‚†£Tc¦¹~¶-e„žìTçllÂh¡Òþtªî�ýšU`oúÕ›­-W?<³S©’•òÜT’4È:ç6±«IëìnGhcÿ«‰J¥ýåY½˜NL‡hamFnó~î¾Xì^¿;¼9;ø(3Å ô_¢ÞÉôÂEv‹Ô„ˆWE_R×P@©VÑŒ¡#ñ®pX{ª¿Ç%ˆù×æ÷~B†’iUtäJ ¯§,ÔéÎFg.í†{]ŠØ•âX ÝŠùêðœ°÷¡’lÚþç J­vhþ–¥‘È€Oì<_^J¶¬U™t£)‘ërÕ9Os+æq;ÀzTæ…OÍ9¥êk*…*†Dò((4Ξ¹ÿUœÌ(wÙ¨tö((Ç7ÔÃ|Q¦ªyšEí[¿Üú%¤™®Xèlmá½Z-î¥TÓÿ­ŒÉç¡>`Æ�¢ij—N77„TæãäµT·‡‰3èWÅÖÃÿój™¹àÌ,aSgÄ·‘J6*£(Ñ|›á¼ç)oz7ßI«Ö˜Î’V1=ƒí‰1´ Dj'+o“v²/{‰þí]'¾PHÐIrØEMäã,§±pÕcn‚Á!=1­wM}#R›tRê«K�'»m·Ä¢ÑRZê?q¡ñ|óßq¸Júc°*é”»½§"bxuø3æÞ¾®á´…šø;•­¶ßq(£èx™ø©Ò·cA/Ä ô+™Uî/ Œ(±€ÎX¸q)e}Ti1€"ŽDj ¼txdyÖ´×b’B…âñØ8}å´îþtóXχZq´6 äúR_sc2)ÝÚÜ.ŒV’3yÐTTôÙ­_°“orPœ ¼2ï©Èž 1E¿÷w §®w#9ØöqØg©VÿÖ&5ŠâÖĽ+k(¢4Ëû™U˜-j-DtÅøzÞònã¡1‹ÙL!û”šqGüÍ&¹õ•—®yý¾³ oøñX£ê¶è·ê»¿ŸY¥ÙÆlXB|ˆ;7‚í®û/¤sþ;ó‘ò˜®P¬,—áŒVó-Ù©QeS/´Êæÿ¼Ž¯@‹ùè¿Qsºàƒ¿ìsä¶cŠÓJ™K0’@ú[Íy6ÏvŒ`8MÚRý‘,CâmÉ$j‡‚*ü½ïùˆî¤¡¼#”¾È/Ц¨D’Gÿ't„Š …³Æqm)ÇÚŠÍò›¨(׶fÖ{ªXåèÔc ±ºUêi«ÆÑ«™LZ­j(ÚPÓ>aÙ_æãq£)е&"0ŸgÛÝ>]f5rÄÍ…v@‹ì"¼Ú}M(Xtƒakw%cÍ»Úï„oO"/MgxÓAvþÒŸšê\/ƒÁr¬¯ÉŽFª+*CŠRÝ4(¦Ë&ÓÒõݸǠ«û¢>ðd…·ÆE/æ¿©ò)K0Øe¥ª»*0}oëîæÀGFÿ“ŒRäÆ®€dKDÝת÷DE” @M}Ç*U}†©&£• [dBŠ5moAt±w~«¶zû3$‰týGùѾ®T#å *-ÍfºtÇFNeym¸ z‡‘éÆÆCÄu¼Õÿ¶²íõCöª¢PŠsà·‹7‘öüÓÝùÇ^†™(¸À«/_, ´¦¬ƒ9³èÚŸû`^âøf*—b„z—˜£XgCµ*ÏðQU®ãÃÂþR´Gún¹c~–+[æ50V©FW¼†9_\±`2ú;0×4 •m�-ɦO‚¸|”çÕ åžU£û٨ʜ_ƒHnÌe‹åØÑ ü¾l:YNe ÐëÐÝBl»ëÆH›ɾf¢ì¦é5óö4 †ÒÄæØoñáN—†étj¦÷`JêŒÑL8Ì€Lu/Úëþ⎳Ž#wwgú§8[.)mëæ:;Î|Mû_%íä…cEÄÁŽ¡škŸeså’K|o° —ZŠ. Nd ¶ãæÿ³™°mS9ËÍÓkÿR×Ý?R1xu#"6Â8·ÃI]mNÃåjþUdÂXøÑEpÂæÁ[]m� 3ÖÃ@+êÃŽ9ìíGLÏsga‚I0D+l*-vÖ Ÿ½óâ•}û¶§ÛAYîÅÏm“1eÊÅjöÅLia1HÜr›ë¾`—å„p2#mÂ-¯tkoJ!âG>31ü(MckÕòz¹U›„1C%Á¹¡cµì/ªo£Kç/S9º‹gj”Zöknˆ3cWAôeƒT !·‘;Tk|¼Y²ŽÑgöÙâ\É]>%ÕwTĆc.„¡€®Þyg@Äú›^ðD‰ì†UwºÁU&±ÃÙ„ÐvŽiqÍÊž„=ÒðÉ*²f>¬èŽ¾ø§¼”p¬#úÎÀd|º…\l…¥GSZŠºðÕCž­ê ½”ÂTgt³- #·ÍôƒNòǽ§p—D›*³jÀ´ƒTÃçlð5¢lË"EàTLgÓä±®Od&’p­—ZDeV³|sœjl¯VÄ…Zï]ùäÅáDÄâ2EPyì 6R€ùSSÄ]Óz¼`Ù>ñ(C ¿¦ pìè@œ2öð”®çŒÚòø¸?ò†¹ R±}×:ûGsXåÚÖ™Jw}„[+îñt¢f"¯Ëä÷ÇDËætníËm³:ú¿4‹½ u †½ø¹pèºÉöZÓ4r®bèUÑLÿ>S…hĺbÂý:m/ }?bvôUj«¡™¤Üjnö¶?h©¼Ò^ÉË8Ïc/ìL_ªÊq2èìf«7ÎC?²¢•š¯Ðû7Ûœng X`5DÅÎ#£Þ4ÿ"õ·Ôä]_OÎÍû¿¥’'¿uš.eÖV"±,ìÓœüÝ’5q2’%wÚÙ #L{•ìü ƲêT‚ù5ÃÝÖ&(|<p%ÉRl´_ ®üdÔ “·|mäÀcØ,(>óp?ãXA!®|²QŽS$Ôy8kƒ)1r0Èÿê¹äY\V™Ë˜˜¯ÐÈu/S– :ãìZÊÆø+þìþéQô¬SYVi·õ…#n¶ü§5•z¬ ÙS6VåìÈ8`˜Îfî½z±à±¯÷°l¥wA Þ@EU<Yÿj¨žÛ“ÌÙ_ɸRoP‚cTñîâAéöŽ™Xrž˜ ¡NIuùð‚As*]OŒ/ ð²g?; ûÖëçQë3Q€z¶]ï¾P‡MÚÿ}`MÆQ—žË—mÒß™;©fû'’gAâùˆ%‚úþ䊘¥#l[]>(Œæ>¡ÙqýTHæ^1€N;¡uw.îh,Ýa74k“W7rÇ^˜`v`ø½[ÕŽŠP»ÞV·?–œŽ4hNõ"˜¹G½µU>++˜«aÝ|èi.,* «Ì@‹]œ@D¼tJñx-ÓÿKyˆXƒ Ú3\ìóaˆø^¥õÚ´Ñž­J–ûýËG«ñ‘Õ ¯RµÎ¿™Zn«ü&{(ºh‹t„èíÌ èS‹;6¶Oƒ”Ž·¯OD§s3…Á€¤¬;¿Á–M¹_˜$Šð#ut$µµðd eN´í{‚gjK?œ€™RÿbšL_Gš×’–«âP~72±÷®œŽ¼î¡W¼/('þô67áŽÂ$ë5˜¶‡‘}»û“]VÆ$§ç1÷U)W;sÆ]óç›R*t|ȹöG³”iìØ>–Zk]{ºŽÝÞúÕ ’á7Û 5d…BQAQ,êfú8ݯòá<¼Qjq72Gßð«é rŒ…ÍÂ[ü­>]S €XÍÓÝêXaúDÈðc¡$¬±yªbzXHbæcx[ç©9ˆ()çÀƒ9%éí»ùÅMÍæKtr©§Âa·3æèT½!zÛ”œi=„Æܡ׊äÈ›KË™œí•žµ3ƒ‰éÞ÷0¿6x$–¦[¿|+Oâ<ÎVKhó‡ò¬hw¶e,œ:ѪèœýµŒ‹D=«ms©kH¹}|qš'2µ_œóz•ŠAŸü©ÍÔþçá½—9Ï Ä‘ÿÛFÙŠÜp ŽÐ̽͘~e¡fçÓÝèåg?SÛ׬*Œ ûæ¼ÝâF°]¤‚Ž2Iºé= söt¯xß’EâJÉm£"öýÙ—Š÷ärmÞìe„4×Ú`bW²ÅºP–0¢Y¯ÿOóIçúš C7€ êœì#–L¡Ý>™ÛHѺ#±‰t§/¿ÝÀô–s©³ :[tvÂ0+8¬3ÂÍkDf®‡V€ùÑp³Bjål°P…±Þñ`iU@,mé+3‘JZ»¿R<FsÔj~eÆ k>aÒ±³`´´`!¤ãìzWjtûÊ5ºm¥ov°«NÅßâ®Ì‘ñ]ûVd˜úøãÑYPA ?,‚´•Nšü¯&´ž®¬›úoÀÃ4öõ^Å,:PÕèo£Àj2‚÷¾a/°û“cíѱ):Žß”ÙŠbm±‰B/|'•ñ•Ä5㲎b™óXÛÉù#õ3å7éxVÃ-—‹v8úZ[NžÖBNRVøK!CÇ(ãØ[ÊwV5ó–»óº¼M^ùuÄåéØÑÑqöêßM°n ›'6¸ÑÉm7䛥a臰\º¤9<Lºív€ö£æk®èB£SRP `OL¼¶2Æ¿G¡›Lá5ÅÊ$Î=¿™Ur»/:µÇ³êZnAŸ¢ÚX¦uÝWÇu¨¼8Ök™û'){–Á’c§Íl>Gç\N�áÅdu ¤„¨ +°d¡ñô(·”\Tï²ýwî{ØQôSX“8yÑ‘¡ƒÙ eÕh‘�BµVäP:Pà¼û&B£—Ã2ØÜEƒjndmÝ_˜Ì’uZÓÞŽ 1~©-pçwÚ¬e¦gšTˆ 8¾¼â½-ÒQ$á%Ó;[DÎîÐ8t û;MÝ·{­Ý,Özà𾩲mQT!4®jÉ-š2ÂÓ´҅±Pß}j¼¦hÈÈlÕ dâְס;9ç …¡=¬^ôå«Ã¸Ìä#Ó_ÚP&ù²¬¼M/ŽÛÖ*îH;+î¶õ™~ì7í ŽÄ6(Ì0“+ƒlY|ñÕvF}Ïœ§õBø¿™Çe¹ójY·{5øCÑz‡uú¤C½¶AP’ÓÃ;£¸Ð‹­0Dj® Šû¿jóE[ÏÛë®2Ó’Tú œ_ÔÅ>ÌG_ÿ¤È‰I£ Ð_Ö¢¨ÊÛ××÷»þ¨Í¯%R3Cía 0¢,“é4PúdgZOÉa•Â„‚âˆØGÁi·5]ÿ.GÝÛ›s™_Ogiæµ!#ÔYIøŽNJÏÈ‚¯×YeºBЭÝü¡Ì$ij¥^Þõsç\åÎ;ÚòïMQåÚ¶×4”0äÝ_ÅiEŠÉ@-Ë¢d†%öáWµúáž+dì4 ¤¸J‚á’ÓÑþeÝ\ ë Œ¯JïaH? IÒ<ÔÊãXÿ4Î¥S‘… ƒô´à|nѶŒ±E¤ÈM¥ô|Ê 1“Λ3·ª{W“ª6v:…%>é‡~1cYw…qo¥I”qéùÅ×ÖÞŒÊêÙš·›Àu¹|y©'’䕳beû> âÙ*Ä­¿ûSt¤û»eŠKW²}b3|ÌE)Û%M—C;ÐßËÍ5/Ñÿ%e¬ cà4xšg¶³èÔvl8#ÌIלvÐ1›ºÝa^ÿÀó5fÝ xjÆBXôÒ¾¶­Hà2ºÚDg€SÜôå�ÿA]­”¢0^åÕ´ ² jíSfLÔ^๩ÜÓ½‹ºúÞ»X¥ð )úL»Ü¨>[‹µ]M§miËèâFáMãŒçÄéÃ. wµ‚»‰iô|„ê°íß—qÙØæúVO‰›+r%Ï·‡]¡„⌰#/÷b˜ð&Ý‘Ë$EtŒ6KEÉŠóé‹ó"P‚�NwøÇÞrœ;¡„ý™9Ûú¨¬¹Øhç£*Œÿ'h™+Ž Ë´Ì'úá‹Ul«&¼ÀÛ®>K©T÷´ íqpgËŠ<z#¦R,2ðøþ{c…67§a¨÷ó-#pÎDÖqK Pê’Íc´à­Š¯t{6ˆ1 ž _õ0ƒíDé4/w"˜ Âã(¹›7Àe‚y¤-ÎÀ}F‡So¿ð—°¯÷}Œ Oû6âÞ(®‹Þ¹V´ú)<ô"asw`ó¨ÚέS*÷–±õ§–$øêf§ýV³ÑÇûî¿0ÿþ‹{ƒ[çÇ.èpúô›·w‹œ«E—qì¤æså½+ ÒE+8[xtÌJ³Av¨}4céC½à¨Mq'×M ózº7ï­¯�2_Ü SŠÔrhÆñwûß8JýL’;€”#‡LpT‘ F‡Îؼ{¹†Ý›4ÎT¨é Daeó#¥=Ï4±iGÉKù>º9Q¶Z;ÿ#&Õ®)ËBÌè5Í6B +¤uQ_­üÿæCÆ-·SQ/a›35ª‰è:.9Ú]K鱌¼ZU«™ º@50_ƒ›`‡y`{Æ9GÉà?É¿'›Ç­Ë¸$¨{ºIçts<xôÞ¬¥‘»Œú_]:„fÍSùF?»Òf^}羫ý$”ëÝíòœÉéæÐÎ(ib¼w@;{í~–ŒœÚß.V9M|ƒý ‘€ÂÐXÉ(èÙ×ÌÉN†jËý,ÔÁq c3BòÏZæva<?ëà ïÞÕNƒ­’¿ÐŸé­k‹ <Š‘Õ KÜ/Xû讜cGB<SÚÑNæ #ªüÁ›¤)aÎí{Ø“\Ìñq£ÄX‹Ïudc«¶ [Ÿ0pωoÃâùÜ¿y5ÆÑ ÞSqDY×4Z¹göÞéfÆ=Xu_3eȘ7¬¿wÏ ½ÒS}Jx—Ï4(\#Üøÿ ÉìÆú°#+{A§&¤žÍ îAê[±ÌJlQ¹í|tUYº¼k} bû‚¹/úAOƒ·=鱜@7(Š¾lÁ™IîÓº³ñ10Vx€¸m4k[ÉÞV´Â‡nçŒ-Ë »•-VÝ2 ÖlF;|/4u$Õj*DUE³áµè(wÜÖ¬ý¤ƒ²m÷&ã,|ÆŽåÍÏxíÖ9R Üh¤µ=Ýâɹ ”‚OÆ—ÆÐWU­ êøcß½ÔÛ\DÓ`]™ÝzÌûhZ˜,+ôèÕÀ«v@#ä<Å~¯t­é %å³÷—õ‘!‰ò³ÇeŽÂ›J#6àÈq�“vVH&6F~eg÷P8-\©W1©OT˜"'ÎhÅ23{/ÿ6Ý×]ÁGorTñ´® ²Æ¢l@+ª- Üô<JV.ø]Ù††‘jLˆø50õéN«1Ñ9 Õ"3iÿ‡ , µ`[lOûÖ²t!Í<Ÿ’ȵå“÷·¼ƒ®És ;  »³§PÑÁ9-÷@;‘¼p퇡•-�¨ñÄNB×¼ÕÂ…À;o\ûº*Z‘(41¡]è}Fç]Á“âN1Ï[�hŒZLwÇÝCs™…ªu-A¾_ÈRÜdl(¸C`¸ÃdÈ—ÿàG@=ÑÛ:¡(è8é>�(2t\ŸŽ“Äç™@†ËÉ¥¯EÉë‘NçO='¥òõCeÊ·î”èÁ#ˆ³nbíA>’‘™"èÎêêþ®@e”+û*N­D–r²ý" ,ܳ}C K˜°œ.F#ïÀúD±¬XTzÈé ±áaÃ}9Ìû¥ŽöV$ö÷¤_eC+¸‰€W ¯£ÖVyeêGªÂp¨':¬¸øãå 02ÇŽ‚xnåtƒÓüFæWÒ¹YysÿÀkÍ'‹]€/£s öÒ¿c²ÒÉ‘J·41ÍÝäÙáÝtca­):4³´Oþ1øˆ| 7}¥{8öUP¸{ŠZU­9ÎŽöû…Çæ*{wÎuï,›©±R§,_±]<Y½V7leø|†ãú?…9bº/º-g'pϤ=Z™Y»7ßL-êW(w‚]8;`B.0xÇn¸È}tæF²ÍÄüèf†k=lØéÃEƒu'˜Îl¦,ÚÐæ»ä§=^@¯¢ô¬®>Ä1Ê4¨ ȶ‰–Í»Í@r‰n”1* #Wýü\CKÂÆB.£·,§`é pa6˜…ÛÁÆjÔôdb¦í˜S9÷¨6Ú©e•jÍYa-‘0 …FŠ"»4{ŸMDs¬v~ /Ewv‡þ‡gQB…Ÿ~»y½âŽ@šã`?Aú¹õ s0iöOd錷ý5Gàí~õŠÔòbŽäà”î¢:ÞTc‡ O”õWZ=9ë%±ºFÝ+¶4$³s‰à £¯Q®äù·×,HÞ/¦TNeMŒl®Ã‹ ©·èÏÃàæ>#Î2ÍqF§*¥;±ØFü6ðÈlµf5Lh0?dö,®ÌÌö7§Œ§mÙd…ó4·|ØŽ[žOÝÝäF˜™^¹Iƒ²ü(;vl\i–ʵÿ>áîV‘C—‹ ð˂ìÜ*2 +ív}ºØްʺÿeP¢…•ÙOawF;çÚª“à4K‹Ìx1Ñãañ§š]µœÜ ÈX >¹ì+ ½8OogÚá©sÚJMÜk%`ò+ã¥n^‘—7úT ‹ÒZш¹þ²Ý ¸³b›¸c£–{î…73bv?´é¬I½ ¬¨;\½JÄ?íËÜmiøûùg‘­�ýÇþ¤é *;‰ãÇìATÜxÌ‹g@¤ÔE™ç@jN² ºØéøÔíºasµw&‹”þ^Â’H­¢ÆuʽçÅéc®X'‘$i³˜¥C߬ž †x˜÷»sí$ž~“GÄñš"’€\@GOã<Ì+g窚¤‚[r=ت ¬™±£~×›îZÂœ™q9{ÄùÚOÁ짟‰¯Qj%\´Oev³×/wfPFÒiøhcä=+| 7¨²§‚¾Äò®Äªz,zi!`"7°4#Oôf95L¾øÓ¥Ò•#-¾°ý2òÇÓÞÖ‡Þ 7U†qê[ÍòZ‹`å¥ç+3Í`ù„©=7ÔMÒª¿¸á‚Ø`)èHåáÞmÒé®M²<˜1ê> H›%<èüÙø†û«û!IVt¯,ØË Úuf?¢¥z`Ììæ{,"‰[@cíü0Æi"åN)¥,}T›]½8¹tD4ï¥A›2ý‘óæ6Óðeñ„DZïßkÚN*~äA{¨{ÛøµåkîT$ƒÚÉ‘ÛÑ°¤ä³.ù2/ j=¦›Áu¥ç+ÝpGš(í„ k~Ö6eñ¬8ýux£JœŽçy°7ß6º<™¥.U$g¦ ÂTòUï÷Zr¿\©¾ý[¿ÒkƬpÿ•E󩦫ûd<]&n0õ‡mýEç2Æ ÜNÿî÷f1D,ÀDKôÔ§AâüÙÙ1™Só`Í]¿Üß±Y¦å€àH0Ó*‰ A5æã“>Ív¢ÿÕÁΠx8i¨ÿ´W°^Pš,H+ÈwS7ÑãS¿<ìï8›)£ÉIe!åªé»kЩ½PA‘¦–ëä0b÷ È?q‘×!O­§ |îÓºó~<cݶè÷:ϵÅý«Ž÷yj=`@³à‰i± ó…†gê²:Ä¿¸äéj…TèSêÜ|y¸É|>÷çA; IsͬŠ³ˆÅ3GªÑùE,µ§A7Ž¬áÆ/¶îq)}î(óÒc: ëö6²iö zvÎÃ]ôLö,…y÷§‡Æ§îÓ»fêÇ’h7:@?pðÀ‡Ç@ 8½úG’(±évdÚÔ›?�PwªI+ð_�ÀìoN`@/Ò^Ü‹ìÆûèòC{5§ZØNˆ½×è™ë —䆹Ät8’ÕyPîÏZ9þtqIðë¦ÁIâ,‰Y;E`YïÖCnJ?œâÿŒÊRóS:Ùü)ƒ¸ü,’SŒ~”Ã{è˳ÈØyž†öÕ©wWÔÅÛ¾5Ý(sá¡r«ëá89 WjATÚJA·³â÷´´6'ª ¸½Ò3Mæm/Î?¯ª•™ÿ¥øÕäIVUEûkÛß6[Ý|‚ïô#rh¥d™Äj ¬ÿê½ö€ &FsB¨º¯Üs-™A·ºûʃüýâÇ;7fÐV=÷M¨À6@!Ú®5|»&2jAÓŽ’çÝŸçÍa8¹8º3C=Ü)eÑ™·¯êYŠ¯J¯Ž© Žôg úÔ=Ú}kݘ'ÐJh#Óf}ÓûdêÕ¶<Ú$Ø_iW0q ·Åt<ÍSሱÙÒÿ2ùtÀp ^àÉyŒ‰”ùÕ, ò+µ÷·Œ¡bLGàèlòWÂÙaÞibEçì¡õ˜K'Œz�¥©ŸX¿‚ðÄÆ«¹µêôB£!Ê"S€'zøûj—ï¶è‹…h3w¢zR[¹%i±€ûv‚OÓ¤LÏà ÿ#ó_(ï’4¼9c÷#ú˶ò(k1}ðhÉ%{§…Kà}Œ;L˜,õ= ¶½›Áaʶ½É@_ä»)ìð›Ó±žéfÔËbmþþv³{¥u‡9½F)å*',YüÛÞ¶ÿªDZifæW_xUPýâìF÷•‹±L¿g,—"Ƚ¹†¶h¯0æÄÊ¿Ï}'þ±û¨6t¥ZsEU^«ÌR…óÇý*ëjðLÃÈX»ÙCµåwÙùÝ«>îO”ä-TÂi1�õù¹V=ÒG|.=P­Q4À±öN(Ž¸¿R+Sï*Ò1cÇæ‚£å+ÆKKFîb1ЃĦØužX3xh–™É‰˜ÁLï¾ÓË4Yè/Ý`Ò4μB5íœÃ˜©›Øa•ì:¹H ܘ~7ÿö`eT6{›E2bôšSeÿÕ[‘ûŽ|ÁSÀˆ<µ"KK©ÑÌ=ù>Yt}¯‡¿€v^¥X"¸C!úý˯ÊNô­MߟV÷Ÿîôi²ÿå™æ_û'›±Ÿ!ÃêÙûlN_îðòð„‡ ð‰SwH9Èæ'g Ýâ63€bÝ,m\³?éB0ýnõdSï…̓ Ñ6jÓŒ:Ö lÝÞò¢öÃFË þÌ"‹ÓÊóø+ÖObˆ÷¸:6d=¾ ¸!‡N°ý¨!MEþøÒ—’® ”}�`¸è>•"È2šóâF´›ËqSOƒÃ†mênqÛ®úÓ3…øã.àþŒð2îTŒ²‚/ðõk›IPF,c‰±9ñ£ÁÒÔà°Žß?•øßЉ[‹œ}‡ÝzÄxK9:œ\±‚x÷^šþƒÕ®åiX®÷®ÞÐ*|kkp,üV=ô¨2m=ªcò’ ²¯ø›F:NßþûFYZ$œìiXþö°ùÒ7œxxÛ©ê2Ê?'ó'r#Úà~‰O‹S?ˆ:EDgÛÈžZ¬Ëkuÿçâ¹e:7<}¯E•ñúnü³ŠŽQB‹¼¹@¨W›%‚y´%ÑüÄ&¶Û}×I~ò¼f{èØÕðBëyš)Hú‡t¶ýÅަݭ¸Y{˜gùÇ¡’n¼×}i<R7”kW‹š|Öl«(n]¶™}ïÊ®¢"&vðiì ðç …‚-\†«}Wg­a>ã#½^M ý¨]Ò ø´4-ÿÍpÌŠÙþ¹}À—Î_ß.øv¬Dg†âeÊBSXú DßòÑ.ß1ÖÏx«'ú­«Í·^L¼íI `Å´g»x1�”W´½C+ã?BáA KߺøÜwóq°ëȬZ4¬T¨,ÒFáLpB¿xËr•í‰MÎ5AkÍ}Ë20]çÈQ$oÿèšÞ9^sNX ?Ò¥wNd‘‚g±){smÝ™îœuZÊPëà‘Ì,fë�ô×!æ‰ÐGR˜mÒùD”÷Ʊr¿²] ™‚/K*à¿ôÖ‰~Áb@[ñö¿RMåÖmâ«ëBV¹œ®2-Œ¦žŠïCp'}¯àVô_Qaxc±Åsrþ«p~žbÖÏöÎa™jׂ$h¯iPîZ¥òí¶÷ݘï ÒBô½X–ò[)¡Ñ¥LžÜœRú¼v›0¦¢v,ú§àÈgÆ ¥4b[1EÛw0€@¸â’º¯Ûî·á;±Ê§âuöMŸ·¹*™¢åÐ-ÏC-€ŒM•¿h¹3ZHrmêŒÓ§iÐoŠÝã¥[úŽ¢S§®EgnV`º2ÑêœL÷F&88}ƒíy SºWoû®GÇÎ_­E‡£[5D"ÃÞ‚µÐÛmO}ÓPØK ‘éÚþ«Œ*c§rÇTáI#&ñÒãú:e³™nÐÂ:Rí”­• ]?»¥ÛN§k?sGßïáçû;Êc×âsž–E¾Ø@ Ðñ|ø‹"Ã,gÀ§óHsRÓ–0¶ƒí$”Cg_iSÅÅb€Nv€(8ü³^tžT1)ÅmYà2nµY/LóºismÍýˆ8ŠóâïxJŠªAÕÉúÃ+J¡”’žo {™AD}ŽŠv3Æ(‡é5DTd,>m©Ad€Þ9…LÞBvr #Ú/tôIÿ|qÄexcà`C2NÊžRçã8É¥sh;¯~ ã 9œ%âÆÇSç- 71£Ôܱf_WÏR6’Æ+eKg[GBÕN?“é÷\=ºÞ;<mÚ"­ö°¯û- s~¤XÄÞxNT|à†¶[ç4~°øb•å̳f·®_óÂ2d y– Ö —"I³÷æ$K=M3K‰HhgÚÐ?W!ί˜ûü4€§ƒ{¶·À®áòТ‘Zò:’®ÔªÚ”Æ_¶úïªó‹Ý@­Å_¸‹'Ú„+´sÐA™ò Ø·~HŽóÎÜñ_1RE{`?ÍBXõ~VKÏ5Zgž‡» :&f½ò™[…Ú:dóøªu¾» F×yÕØ}Ñ7>_5#:ÍéV„Ÿ,š±^£q´/v_ +*"éx$säZmòþ*ö}Ö ôçr奩À9 †]Wˆ^Lù#ú 9~T–Nýƒ>ªg‚Ù,o˜€ÝÔž‰ O kµRBŒäp y&`uFÔ×W½\Kzùkî*¦l¨åö#[Z\è þÀÏQN= -$·‡,Ù¶5'2 ëÚã˜{Ñm`þ�ß&Y-rþb,ü-ãܶb#M̼ßá¯òfõ¶²c‚ÿÏÄߨŒ=”2c!‘mIÁ»¶ñ*aª�e›þ`Þ×÷KÍéò©k6£,ŠÕ(Š6ä´‹Ï‹¨³tÁ/¯Y“g§–zgŒcÌÀœLk$fˆ;•Â Êå7cwjÑu”gÖÌé¢Ã—bÒ«C+Ð, ˜´4Eì­Ï@ó“mEб…ÏÀ”]Nhí´ýöõAŠ˜ø|.å°€ñFÞÖŽXA™[Ç3.Ùÿ;Ÿ)=øï±v’y-|ä4t#¦*èÏÀ…8™õÔ yíôù^‡4‚ ™«HbÃ6˜&Uöó«Ý\ÿÕàί.×é†éã¿"ë÷Å­€b´f®ûs‹äüZ{«åÈ©‹†nW[œŸëýRóÛ ßû± âÆS)„‚L‚paì,iQ óyýÓYª·YŽÌð²¤Uk{°‡˪§âjÆ ņ¦3£³Wü´Ë8ËL+žù¼ã© »¬è<°ýŸ7!H–%Œšà!ÅÏ„,ï¹›ñéSÊ(º¾ßØ»óòçÁsÎàAå(§b¯iÕÂw¼¨¼Ì'þIl¸´˜ïÈ:Ë/CĪ!pÓt羶[d9›TÕgæo?›”bEßf ¨‡©cãB[¦n)]Vú8¯qóRÓþ£‚Ž:ì.£O®Øô]ö$âÙ3÷/]±YØ0ȳÆô*¨¶;s°ñ€îƒ5Ã4© à^/õ]^‰;œ6¨-ÿP¼Û‚*¤s‚™ƒ«iOþ èž(‹]a9ÐùYoóMhÚÒa6(Y•PdÄÃi;¶fà÷p¾Xú“¾½ Z&Ug¥ˆ†° š³œãžàs«‡ïü¶º<èle‘ÈŠê¸T¨^Þ^ü$¿¾ñLU¢ÙÉ’TоôáÑ£’YÉÿDT*<rY@Ë\Ò7ºšS›ù\Vß1Š왆§jÌ¢caßY@O²6ÄR]pèîgØö9l¯ÇMÙ"ÝvÓÇfÉ&Ÿ¥±–i²¦†ñ¼kÅÐç¸ô@JÒ1áV6º×g ²²(”® ¬x²^M¼žd9iQéPýÞ‹]ývz–*]Ê4~ŠJIoE1Øf¹žvwv‡šé%“Ž–ê+}©•ØXËj¨ã¥ymq%ó5i‰žœ¡Œ÷ÜJctÓ‘D|t€åþ‚v_~5äâ¯Mh?y•ƒØ³Ógjw,4+n ¸?–4(‡YQÎã3¹¾·ha>ÿÍt“"ÓmžƒV°U®éNüÅ EÊMâF�ÊPJ†áQEÇ[MAuiçyU¨Æ|ä]¢}9&l›\%•ƒ–‹äd0ëÝùV@ý¥Å—>ÊK÷NùÂWVÜ—Õ’ìŸø�dT êÖÛbêýš„êÌ‚æ-5ØD5Îô9–„§A=ãôˆ-&ˆ ›n6b?Ú îÖ..Ž-=º°ìýß³Ö"¢uºÔP…6mšûË;$Ö(¾ØÈßrò~̃ҙBëU¸2L4‚Ô¿¨Bíõ+½‡! òΦy(yÄ…)êèë¶Æè¦ûM¶§+¿Ì8³ëÜÕæ¹(Baey#^0¸u‹žüp¡·¬íbŽ@²‡Dx7l:® \‘ò᳸M¼.066 çØùŵLYºœ�^²·æéO7­˜ÌiŠðW]Kʆ÷VH#:Gë¹Æ×ú¥ƒé-JúΚ{‡‘>¿{ Ð ŸNë<A½%Š ÅÍ Ú#P„ÿêU%0uü-Ë Œ­@º°¡ä_ÙVwŒâãÕ¡—O ƒamA2]Û^…ó/4§Ü0» ÖìvûíU±hAP’‰ÃýðÀƒÂ€£9´Ý­íïc 2^Ílò`ž©¼|·§<“ôoÍÿ*»!ò’¡AÐY¶W·òq–Oý,wDkf=4Vµ6a–Ÿ …¢=­µx²I):–¢ídØb‹#gÚME¶þ‘ ¯AJK[‘qœê^HˆFw ȽE²~ v búðè™onñÚç,døÞƃ8lƒíaÇM™ù±BÚHñ<Ït·?§Ý€ÁéÞÍ…Rì ;£Åؾ0iéìž¡•Y+ ñ…ÞøJŽÅËLoœ6Vh’kï§=£v䩇â±7¯TÕÖó÷C*Ï<›°’�IôÓÎÖóȺ–`àãþÆMp|hc›Üè, —„ý.M»†v>Ùp†S- ¬>Â/þšó°Ï ¬aØßÙÛü¡2…—×¼ðJunV⧮žÙŒ[VïæOd»A}tßëÞA~j¯ûÉ”À\ÐàIzÎÏhîª ŽahkòÓCÚZ”UŽÌ IøWî5ÕŒ$T¬H�Ÿ¦z[÷t&Ú|ë·šš^ÏfþÁi7ß+f3ÆÍX´v¥ƒ‰“…3OcM7_ÿèî˜íêÓ›NeL?'-FKÅ<Z¡Êo„¶¬e4Ta~ÿÞêö¯9–Qž)$Xa3pH1™ÞŠÕ.ÕÞ§*¡©b(üÿ³ö&Û+I¶èõšÝIžZè›!@€‚�ųÞÿdzmææî`¯ÈºëVRfR$ànnÍnpÀö´NmDKYÉtäåoŒ^Ž]Kð ¿è„>å n8­æzõI3(ÀøäŒûr˜"7lu“€¡ÂãYwðA�N ‡£³”¯íiÔaÐrÿ>9^R'£‹]UQéÕ  X®ßìnmôàð©÷;ƒO[Ÿú»é`YfÞˆ)äâB÷ö� ôíirR½›¦¥É‚€ ³•sÁÚÅæ®´5=ö€ìȨfy·¾è‘˜¢Î´&{ï·™nQø:y0Þ¤tˬûÊ':RZkŒÇÖðCÇæÞ7W:³¼ù¢zæ» ‡Î,‚ÔòŠPy¨U¨nhÌ”>Õ}ñLJW<d*‹ãQPÒÑ<y.ŒÜšcç»JíOhq±ï±í0œQçKû"¡Û ÖÒóŒ(v8ÚWŠS7÷õùÞyÄf"¥šHG ´-É�jœÒ¾°%ÌVMׯËNz”øÁsò¼ðò|ln^YÍ D' •ÌJ}ˆ«K<h&ôMýí¹';ÁIÓÉz£3,n‰ ìo[L\•#˜ F”7·§¶µV‹ž RÏöZP­åGñd; £¤5²ò¨+FÚÉæw O‘åóÇFcy„ Hóc‡B# &›ª­7B½²Ê1ôÙwýåä¥ôaŸ¨”¾¨{û¨KV.,Ñ9L°?þx÷±fmÚ—f&Î$=c©<¢ZáN ¹Åòe‡£íE™yû3E‡è\ä{ØFá*` ?µ®f4Anœc*Ï"1bÈU†AuQÑáUßµý…ÊQphCœÇÙÒb{i.XMÁŠ*v·Ù!ƒt—lsá>p…’`¼k{2üXXÚ°ë³Yþ2£'Ý“Ô©Ã ¶ïhÕ¯UÙ¹d˜Ø Á,îvsq‘ò³$p»¨Î_ÛGFErÅ…g4¨B/’«¹;‰¼ ǧ£Y™¯> c¤¹¢Ò[—+JôÒ�ìOkHÎÑF6uóêk/6×V[”'¬y-Ñê¦ö¯P%)­¤JîçlÚStvÒš°ÎLc½×ÌãenY)J³4®*Œ›;ï0å‘Ó•zfÙ\¡õhwEßjdœFNëF²¿}gô¿Ït_Ìw–B\ú€÷-•$CãTMvÆê0®¯ð  ÉwüêL[µiê™’°U}Cq»œÁۛȥԗÀb£†äü¨Œk•´ÿÏlJm'd=\AµoßÝ‘–ˆJO~ à4~ƒ4þìX‹þµÃ(кœ‘.QWÛÝ b$àÚúdwé¹DFyð”|kóØ$!qKV÷2›1ƒ¯ÛTƦ•¥1°ŸH)h*“1H´;n;Ú½J?RÇK«'ü¡ö9Â0ÙœvŒ¡¡Œx«ú-È»¾{öí¥]š�„Uää—¡•ÓVu®caÑœx Š¾ç%:ïv/ !�º™lwî\ÈC×èê'ÏûJÔÁ à<²Ð¬â »ŸÎgÖ÷ÁÉy1›¸† ‡–š‹îÁÕ'¼kt‰Gú±_¢7x¦Oý!øK­±62,3ñMZ±h`nºœvvÝÓiñsöøê,æk`Êð`þ_3 ^^êÕõt9‹}EX6´v¶JÿvÚÚlùAe ÌWhíEIQäxkßrÎÊÌѩ׌Eª1ØLe*à7”›r9ú6/1ž”c$Aµ9{®˜ô1wƒUz·ûá3k1¦¯rQc˜[IØõ9wpÏÀ4ËÚŠ/!£ºº…mQ˜È‚¬Ÿ=qWZMççö·NëÎ$1ÕëžÒ¢^•º ]†Â™„¾œV ;ç ÜêZeå«>PäÇÁ[ÿõ€Íìb)S0¿}ô&ž—N&Œ€2g퓤¬¸¼Ú­w+…¯ TŒH7á÷LÑ㤠SÏ—2‡&£4ëñX|³'N¼cL?=wJzG½QäžaFa–y¼v @Ù µµÂ!C= ³³AÕ‹¯²OãÂ4-Y€e0/_Ó¶Z[î#x\ÛC»†;=… {tl)<ª\»Gq5;ž<n.Õ¯hÐJÄq%ìëb6Š«Ìs‚„ =„dÔ´!|¤´{ôüž±%Ì…™‘›<�;ìtêQ¿äÓ_{GÜ󰸑¹g˜0ýl9t”vìÄÝ¢$S‚œÖâd<tÒ¸¦g|8µ÷àÂÖ–¹0çl;çAòYÛ„ úRÂüM‚Ç4öâ.¡"q=XÄMv’¢x4Y<øª1]uïÌ“t:iÑÓÒ{ÓP*ÏžU1ÐÇAe»½˜äN€Ãþ©=ñô±ž)s²†,(…#Y×»q]ÿ8N ƒƒ½zH!ßlnM{)ƒä[ø ô|yÇÊØcWΔr+ë㾨–庇Æt£?Aº>šO ·}GW“RžE¯Nÿþ[[ ö"{½JeÓ(ô=±¨Æºrʧz]>í‰á2«e˜×áhÛ4pÜIÆ¡Œqˆºõ…J|´[„ÝÛQíbyCbò†RYZ-² ÞK—ӥǒEË; ïöpøB¦19屇s¾,ö¶"ãÓG)Gg›N© Õu*óÄ«/ί ¦Cø䟛SÀšàA‚õ`Hœ gû™®‡¾Ø@ijÒ[³¦¸z"`ôÞ£ÊãüÞƒÝjÛˆæ%Å--ÄVYkq1]©¤©t,VçöâVï´\ØâPÕTô­˜PŽ˜¦PbBkƒò{#O·´ßmO}ï.nNb1¥¢ôw˜9ý׊Má0½Ð9Z—„Çjç:%7òȜ ܞ=hÃÈêK‰v÷Û }y‘y¢3!ui5¹è&e–Gœþnó›ÆÒ½«èªÈŸV„𞧳¢üÖ6R/úÌHO½„uCÛžÎJ.Â?Ö‡ÃÌ]ÊY¢Ïø>ITfž}7¨ã–¾Â`õ­Ø¡#r tè VÚ×ýÁ‘˜š8ô1ndkÃn´†‘FˆÀS=ûµ»¡%ñ2¦çö±KÊ U6=gÁ BäpfE*pNø]üˆôÿý?ª/Ã`²pZ¡·…[”\cŒ ÉÅ÷Ñ•†xP2ëô~ÛåI†V¯ÇbA4§ÌI(6'Só—þ„8¡ØG¥Ää0‡6,ƒH{{ÚF‚µª›hçÎôX¬›JŠø¹”5¹éþâG_†Sl$2ZhyPZO€$t涢8oíÇÖTPhK]ÐàC‹¹†a­<Pâ(Q´öƒ÷}’a¤ŽG†o™±Ûuv´ì·0P­%³ón9òÉò.D— Âxî|Ùh­Â>P—xÇ‚(d £œ0ÿz0O° ‚(ýPòÄS¤Ôà›ÃÉL‘}@é¿ÇßѹcƒÅ‘Y’»#ݪï<l(ïjH197“¬õû> áNGü°ñ€6EšUV:G�†èÛÞ¶ý¤Je­úø†H7êMÑÊòä<ß®œú£“,€˜ =;³yéÛ˜Æ| §Ùbvÿ¢a_Åέg\Ð ÐUë<–Åþ0°ºÀÅ)SÖúõë-Ò'SmKp6)d°²í“SKï{žÅdÑ‚Èš@>éœ ,Ç鲪¹C¥ê¼¿ã äbÃé[Qi5;ªthëôÔÑW # éàªfés&;+±gaŽC»?6ÒCodk,=ÿÖ\·(Ë>3•–˜“·°�NÍeð=^ÉÀ%Qè!¨hƒ±Ò\Þ*^ëLßÑ›ØýçƒþªÑ%¢º}V…È_ŠÏ9©°Ä$ç1æQ±a2 šÒC$ÜMO“tlœ³VsœÆ߉qåÇ?¨QBL´úþW[ò•ðÑît×Ì‹>(¡?{óãŸzXª‡DI‘y|nÚgÚdÙVs,ZêìÄoŽè²ýNXMÃ-„ÿ}€É®ÆÍh'æ”ömM÷/ËÛÕPÂŽß{WÏÈ'…§ÖÇÚ¦ Ú]R ‹\"}ïãsä½G4öžTÑšFÏRØ;‡Ïk©_ú^TÍ S—)q.©ú8yP]ÕQ‡åK[£9þPg[¡³§C¶˜Ç{ꈥ¨<w1“^¿ŒÔ«I èfÌô³í·Cùõ]wvØ^l ã_Nho£¢ò§\U™-UÞ{øKNͱ:Ž8Šaœ`þÀôÕñr0EŸ62ž'ï˜k{Б0æ5š1V¤·Ý0±Ä€Yé�¥s²¼R؜ǎÎl}ññ‰…!¤Í?‰ÇÆkþRU$1g6i)–._äÜc1¶éÝ_‚Þ[ø ô^€˜æÞC‚µ'ö÷Ö žÖÊ¿§\$™'Þ…„‘B9ùÒ>|tßtFq­Ûì&F1[nÝxlS,д´OMD}k‹as%ï}ú1ÁåÙ®K¯ Qˆ74Ö¾ÞÐ &OO„}´&{Æ$ß]DN Ž[$±˜ZEgõ¢[ÉH=íJ3ˆšoU2ã;‹rgÛ=) ƒB7Þßs/[6cšÏèôÔ:Ù3HÓr¡r¯ßHÏÈËxðž0 K×3Óž@XÊgK`Û1PÀÙþ^Ãó1)&*}ð”Œ*$SÛÏ朶”nE '+_šzfºtÀa;&lœ-e¢€m(ƒüäY2‚ýbÆ£ľWÓ€~0óøcò:´ÍtHzvˆs*¢ÄÀí)BgAÕ®]»_+l=UF¬ZWKë¦k{I³®1}Nx72½[à¶G!‹#´zçénÿZ‚ÛiÆFëœÛè¹õÙKX?üR«ÔÓ¯SFÛÜ©Lj×÷”òWEWFìV=Q¾Ñ^ Þûþ J)Äj€œ‘­ßüBle«¬�OÚ ´¶:®`k‡ú<PµX€Q‚Ü | <²ŒÈ³léwná¤Óèö‹KNvêþK gC »~½L'‹Á40¬³ÖäftFBï]ì~‘Z_g‘¥Øœè0<® °žüj·)mÊÅÖx0GËà éõݹrfŒ±Q%”7ÕXs”ßVcžGê¾úo³Û0¡ÑLŠü¶ˆ�ÿs‚ðÌ?ýeË IJ§u1h¶‡kGòyô†jühë‡æ§Ò§3SIï8î³ ™øQ˜6„×ÂUχw¼’JM„’ §†M¶ñ,ÒÔDi@t †©ç/Î"ÕZ7²ƒëÄßžìoo|ë-e:sCº=ö´Ê­}…gŠ§8uè4`µ1•üwúíQìÁÄE—™J”ôÔX&,#Ôovëv7`ƒšNÇë%\ cŒ¾A¦5šÔÆVôTçŽô‹d¡à™R[E¯hè `YŠþ‘ê•#ð‹ÎÞþ$Úÿ<ݼû]²j3‰)}£/ñsòzÉL‡6Û˜ÉnÒÈ÷•Rn·U45>¥4‚B눉|Ë«åí]È]íkÏòÓ£Í%ªR) íéÆ0OÏ o6Ú®XßœIK&M « BªxÉû—<9-—bµF„ØþØÉ]bDÚƒóÆ~ ½z‘ëqè#ÛŽ Ú'ìŸëݘñо”lȼ§Œ«:c¶ñºIë|ÑXz¢§'yzõÕOW E¶ ­d,å’X#ê,æQ URÇ®Ö[ð—Nò¢þª(%fTAuÑ¿U±z#= :h´�8òÌ{ÜR€lëÕe@BqþÞ¯|ºVd:b}MwgÖQ8ªi†Ã¨Oŵ&齫…Q»‰=ëZ°•ÛR=•Ñ `}K-FMOcÓQqᔋ,\jpœ[ öédA–tŽïþ ¥;tJé§ìï¢/H ˜~z“ eækY—¢ù35žàa®m¥ú“*†!• 7Ò‹>Õ:Xs@ÂU˜NŽÑh1³íK\ŸÃäfô;QÈ´…™*%áŽ%§Ý5—ê±_½oÒ)oŠ)ñ`]Á >,~cr|X¸<gùW/c¶0ÌÓ¾§*l±ÃÄÀñãòÁÂ"—óEÿÝÐ?TQÙ×+q ž@[è ÿ뽕Buí?T’™ïNcߟ;õ«½ÐbcË楊¬Mgû¸´[ù!|8'܉¥¶ÆâñpBu<$°¯Í=dgÍnÒš2õi}åüfšNåHÜÕ :Nº˜.%T’Ü*a5-dB/©+‘P¢Á“}},ý+wÕT�€1!S=~›¯Åè6xÍz,ÁÜýV%PÛf)š¼Ëk<SäD 6ŸvþGÄÙ#Æñ=jR˜™Iš¾£î£c"Zäa17B°ùO¶µÀ«Rêb±±YÑú,; =^×”ëKäãÆs†ˆví×ô9gnÚÞI"B¬ÑÈÁ¨ã›$¨zí7U7Î}nêz6…‡cœÕþ‹ýZ¶–-·×A–Ø¿dâZh©Ñóì'ŸZŸëÙÙükmQas¯ÐÒæ~gÔéșџzªõze·±1æ/’› +˜+0˜é‚š ²òï;IÃïµúS4I‚rÖfZ­ºËtOî5nž°­â…ôébvl©¾•PJÉÉÑ¡¤e ¾yl‹ð¾*m™ûf¼ôºUú'HìnÕA0ÄØtá i­Í;0ii�=²%°7­42J‡¢ƒC‡Bõ’žÊ—Hz˜ºpµeHÙíÅíeÖg( Zˆ @„XòðoŸÍ#¯aÛR“v2ÎFª ÃõZ±x(IÆZ±8ÇÃ0wÖ­ú•qu–Û‡°I ÓV¬{ùXwÃxÀXŽKðÿR¤-s‹—5:²~ëqv{KÛ<ô=[Y/°%˜ìJà½Uí‚—ƒtMÞw®©ºÚú;1ÉÕWՙ䮿ÙJMRJÜ ÏÀvc’˜Ãc;¹ 0köØasíöªÜÍ=!vã>v´-££iÎæ\€Â˜ÇƒÏ4âï^fÑu\®|ÿr9Â1YŽÛ­Š*“@ðÀæ6yÚ°ÌT¿c)Qº¬T¸nÓW$Ÿ£ó’0ëx§€iáÕÏ/*iëÖ $NÈ[ŒÎÞt ÚCg} $ÎL‹¯áIšûL0º7´K>U:•?íç}Ì¢rî›Xz—|Åe)p]¸Ž°¸Ø–"F}ª@@ô§€„•¢y&IãJ.ÅgsÃdš=Ó ÃO"JÛÙYBFa²¨!é¶íéoŒ[OãÏ b £èX<’³°C)£T»Muía1Yur¬RþÉ´”–?Ž]kr“Û?y0¦è·® ÒmcõdÄÁ“’)ùË즩¾/‹øÐÀ,wBAHƒJ�’£Æ‡pvýîßš÷õ›÷¹òôÓ…®QÊôóbZ2wÅV_Ìn`_8Æ2­(ÂîºñâgÐúÑfŒÊ…:Ì/7øa°\„Aùýé™Ú8¿^>¬¥¤¼Ï¬ˆç5-å[}k)Ù‘õûàÞÒ›±p³pu¦é8»3Ê~OÆðôÜ¿"U3 ¯VžÅË#Šø{rûjêA;3o=ÆãaG1Ñ^¬�;Aîâ±}'kÖì?è7ÖA.ǧ†Ll;2ˆ'ì-¦÷l{Cg �¨Jã… þw£­»0p [c»ÊÆ»ºµ]ð´öÝÑpÇkŽ ±Q=Ų¦ï .€cV¿cÿ¬k4€ål‰zÅ`€°SK<æõ`AóØWçé_Âg$ÉCD€…íHZ•›IïÜ88ÊȺ½z¶þÅœ7«üt7ƒ–Âo4©²4Ú=t Pº°Ã7—•Ø,X´8L§Ë]ݬ³Ü[3™(íAÔ6ÎçÍz9jÁÏG”Ixþ"‹KS7䊹¹$A1ûíNè/P¬¬qx/’ÐÛKÞcõ̬´Ej©_”à@pš0\h´â €l _Ǥ\pÐãÁ Ý•¾¼Ä<léfê[H‰½Øö£Zœ=Ñ]ÚýCgÄìêKoRl{%0òÛàÛppò¾ú§bßaK¯ÿ�9SÏô@¨ê)M•X!4Ðö­ÙÓÕr‰_L #OØ%V]J(ÙgŸÁHD8_¦– €YŒf»Ã°¿KÝœXÛ7$N_1?·Ê*­Q2Ó þÇgŒ¢ƒ1ÜÏV’,±U;ºmpª ;«þ7VÖx€ÆJsñÈôÿëÂþ÷¥YXæëRÇ)RjJ#šÚ)ö¥3Óh“¸èú/7ö"ábnÙÖ;ê·24¦nL~!ã—>ŸV{CõJÙ(¿Ê™Œ²Ü›fþ’o¼ÀU-ø�Àòµ¥§À·spÁ-­qŒ~ýБµrvå •Ó£Á­©½Éòþ„yµe?ÿ‚ýOºÐ„aB%ÿÙ8{þ+j­w3îö´†üØp‡Štû{Ü­Ìç™B5 þeÝ:‰ãsÏÏCT¤ïØgüÞP£ˆ}ª%©S“©õ—Ï0\½´ÞX’ßáÐÏîâQ‹!öø2H•ª £s*¿½ÉØÔµ«ƒªý¾ Þ.½¤šwz0Ú*+=Ä[ú4L\ƒ²×Sþ´t­TMi͆íQßNVˆÑ’u_ïl=ïÄYïeYûóHܤÒ`Ê3îÙjç‘ž/g€f‰TÃîêöØNÊ$)2KõÃ7˜0a²…MÁ0ëþƲ%rƔŞË~ö‘ŽP…št[}5Ïã9øú×¼yK¶ºÄ¡Ñšeì³õŸôkXGŽ—‹¦t’ÚLÊ›×T´:BF³Á+·|E·Êfy³½…õ)ömƒêZLûGç˜-‡U½Z©šãö2´ìµíµÉ£ÿQ¡]éž…TwÕi?ŠK(XfeŸé€ïw“$‹s}¨¼²!S·–)ßÀ0D¶¢%òíê—¥¶\fQu'|¢[y‹(»^tåV'ce\;lž¨rÎt‡GØÊ¢PàœE€¼ü¥܈ÅBö̪ÍýOŠkpé¹SSۮׂsJŒ=@†²<sÕy·þLÌá$ãJoÆγÂÕÚ(Ùv W´Üw6YÊû éávõ^…ñõõ¦»¨¯.á,®fŠ[xH¦ýÉóhé~p-’ÕKÊÝåßXØGEæS1"ÑÆ)úÆvËhe‰ä> zôW=1ìSq$®~\#Ë¿†æ¦�f™wúKÓX…í>ÅO[WK#±6_ﺑe×S4t*³V§œ [¹ÍÛ“¶ñ_ÛÉG¥ iü¢âSñ‹™Áü ŽŽˆ°‹^Œâ4rn¬Ì Üœ@¥éÿõd÷Ö»‘µÉ­DËé§æÅÎŒ£"v9}ÉäŒ ¼‚Ô§ú‹Ù3`!È|&Ok5}YOÆ–3=ðÞÕ-q>­”x%\oº1ø£Öu™ßÀ¡–Û.~4±W׭Τåm ~¤ÿéˆ@”Æcc†êÿK¦×e¥<x½›ÿÀwG»û/¥ƒ“ÂQÖR™*ClIkKHvî)î�W¤ßmµãÆ¥°áüëÃ<¡æu+aõ'…ö%”œv¾ &·Îd6ÎiO)oÑ(|rø:hBimÀ¦ ?H… *lŸ»Æ››½íLn±ƒ’¿QMÊŠiŽ€ T ûÎ{]„ÒÊ¥%l©€VÚ¿´+Š ©5üÕòÐïi1Ñ­uhÇm=õ€jìÕ­ãS’-¹ hSëa ÑÎ í'ú •±æŽ•Äÿº¨2ÇÑ'jé˜lé·ieã#6XœÿP…7XR‡ØLÿ±` ¿× ¶�ã¸c?òüB0Dì/ƒ-Ôç÷_ûeåÏûé®ÚUûé!÷õ¿´EÁ¿Ófi%oñK¬_cahkgÊÁ¢ÎêS#ϥݹu±¢G·ÉÀ¸­\÷ýK“+ B(¡0¸ov´Ú– ù¬²ïA4_}ËØ<{þÜ´S‡FRßJ©¢ôERÎΪ™É!F¨’<®°ËƇœžd1o¥(wø&ì¢Ú„èKüK««Ÿ¿¦féFûº‚÷òÉ«S=t±“£Ž(Õ­$æAØF×Ài7…%OÊ_x)V—¥o-xú¿d£;/áî/ßo3²¯[ñÛòµ.ø«Ü*/ŽÌ3˜&ú&ᨧk 6Yy0ØKgÏ šzC1@zŒ‹úîŸíáØÝa-¡üH=Ý&É‹ üv­+™MMµýÑ= zlTb,>ßו§Š5r#ý_jw„«ã·¦3ÐRe'«p6ZÞ%E{Lv¿×ňMQ‘s/A8ì~f6u¼ˆ#£[çz/I²Xñuz\8²[Æ)_E·Š¬Á$<ò±#×%Èq&ajü%§¡O¨¦³¨ª šÎnoS‚c,㺣||׌WÃÆņrø¡gMš e –‘ñôžCf.Ï÷q–]* Á^7Ýj¿—ÖèàÁfV˜\k^E­•¿5Òò¨jñqÅ]ÇÞÐi11:ƒKPóïcßB„š¥9HÊå£.Ké„Ï32Fêʇd>2X† ¼Â©jû 3ôËÃ×<AVdÞШ=y>wüWeN,UOòß~õ]±¥IÏ°Å4b5qÚ zAv\Î%}¹¯Yèă°**¡D!K±µ/]ÏàJÚ­àÝp,õ.oú÷Õu%µ9Á±`k`¡=y°.E©”²Rnl3Såyk/ªžÜkÍ…8sZ ASÛ ÙöÄæd–»…n›H®pCT÷ÀZl—Fö»Ó»mQC¢å„ÄÌs'C mˆ½j®F¾40«øöôqê_bjÛ¬´bmïÓ{,>)5d¬ÒÖJg¡€Õ³u:ÿÚµìô7«,µþ"rzú2Hzzæ,zþòU¹Ú‰}å˵yúm\`q«r«DIx’méó‘ÆÇÁ±¨N75f™)ò.çâ 3øºT´†Ì `ꚇ:x.ä™<ËH…>pÝçA56.àÓ­gÇ#›lÁçtùòØõÔ# ¬’ ˜t~•œï.L]¶LƒÂ?´TE@{ôÁoЭÈÈ-C"Ïtêü¢YÆ ¾»õL%Qg¥üÅÆaK«eìÚ‡ôj#)WŒ’2 òúlv‚D]Î÷M¯!3@ò4‚W:O 4úí2s!#ÉÝÙºOh©jRÁæv Ýl:g“¿S vÞ8Ü«¦EÔB×=¹tžŸxs86 ŒC¦Ðwßst(ß}‡þB÷ƒÜk« 2\àZ`÷°³E~ÛÁžZþUoÕÕÒôžb¨öwGë +'ãW›½e‹^WJ;–‹Yý€TÆ�¼l.^.ã€H„J�²4ð<‚�¡b —?óà43±A÷ £ Ñw›Xê®N}ºÕ»DþyuKâ4ñ�¶P›Ïƒbh ¶âûIᎨ* ±êÙ™ìa¬)× EÝތݶ«w³: è²›êþ¥Þ+Õ^%FZÃA£Û%ëDŽˆÿŒî¶maÜÐ ˜áQtn¸G!#1Aܘ!Þ¨ÊïMŠm3(Ž,1žâOøiU@²Ð3ÌÓY[=Báë=ï3—‘g*ar¦ªM¯ágîºc¿´„ŠÑE®GJUˆ?>Ô‹mçšC¹GÏΑ¦µÛ4HO[^@&âµÆXÓ-j,.Á(âðÍ»÷«' VæÙìr:CEy¬]¡LÿsÁÜSé…ìiXÜŸúAŸyîÜ,ÐEgÐ…i'3ø“¹ä“%au»¥~Ïग़*½£uyL"xE¡�ó ±ëFÇ_ëØ9Fþ½oÏÄt|ÿ/!*ÍPQ/A‚³Éjc¤éÍiØÔô­¼ÿL+åÿBÎ/JSƒûL[xõ' bÛ®Y6R¾T·\>½fñ'~¦Ä˜©¶Nxê¦b`Ðo9 hò°U)ä7¨"3åˆe¥Þ"¬¤6ƒ3! ÝQÌ*m…Àó´IÍ‘Â)•S‡  Ýaž^!Ä#—Ùv–A¡·Qq˜²’?^„æW"Èç®n;µ–¯dìb"É~ôMgÖç…}#ûQ~˜îÿtW­÷±:Ižd¾ˆ TãäÓÙÍ£p0 „—m µ~Gofâ¢Y/î€ñ|•Vmœ�íµÆɉÚk\-ë姶 zƦ!lÁP!®}I¤­'º%ú®¿ÎòÂÑGy,Ü´`�4ß.ˆÔÿ³-C{{¢Ï±*<×µgìð£éVª§’mýžÇ¯š]HŠÍÝ´¡ ì:«^Hbš+›ûˆ¶æGÝ4tÞLLû5S•§ˆ|çEWí¸#Níès0-»3ëùÔMm}ùX ú’«oê¯Fô ÒÌS`‚~Âog:±(F?uÖ˜N¹MÇ1è©k‘;± q4bѱzr<Œ=íËÚ‚÷Žë§¦¥‰7 ¬ø¬»¤ž{ žµtz¢O¢Ÿl°68ô0á-YKáÿø‡`?AOt|´¨Æ°f16F’lâ{…ùÔ­9Çôëó8¯¬u„àÜýkkŸ#HS÷Dq¦PMJE}FÌ•§ìCÒs’ù¥åá2„\;Ƈ*à Ã{SGG~̳ßjM·*eµåÈ ´§3CÓéÀ¹Œ݆êÚÉIÿ?¹p† lëè»c埣54)­PàV,º~áŽ' G”®R>Ø)©~t0J»Ç |h;ä½ÆH¬m'ý°·ÿÛüì 5§ùT[9\@ÕWÀQÿ’„‡¾o³�„Ý�«Ã!ÿ|öç™/P‹)Å^VÌUë©w“‰öd‡Öæ óÙ4Ûí–|z"¥° ‡³t}²ðú ÔÉQÞ›®/'DPU¯if«ˆÁ&FWnh|¡"{×ëËã6²ÍàµØŸè.|+_1‚=-·³•1;òÄ3¹›YöÒÍ>PÎÜ\TÛnTÁhixý‘óåë _²Rßí=vúÂF:äœj«SÞÄl:KÍGݯΧøGÙ"ﺿÅéè-,,ªf¼ P9h!wÑõÓ–ƒŸ»:°ïå_ÀuÜcËÅð/¥Ï8[¹K¬Œæ­ Ú‹bO¯¯ç#WÏD' qh°« e³¶®«®¥*‘7ƒÞ†·ÀlŽÏš~Þt S|ní½e1ÍÞl1„Ó:#øø—¼Ô]ù]ì´}kx +ú<7µ¾@°y…Ó<ë 4e«GÔ#ûš¾òÀ½gc€q‚Ý-1ÀêðE œö }v3Ê ‡Š†×ÎfŠT‰{uc^˜/…Pèæîi=»ÆQ*R_U°»a`ÐÒÈ•ÔâEo±ÅwJ€€tx„ÃÑœº±AÖ äí/ÄÃ#ÎÈãaÀ]hNÞT3/¡n‚ïÒïâ=^b¶xšôG¶Ç,Hº£åOð“žR¹4~ñbà´Ñ½‚éÆ\¨§?Ücz,\##tG² h?=è‰p¤*âп)X¤¾Q6²*ˆúI‹/ºEŒý·¿™HH¦�Ò)­Ã|áë\Ÿ6'ZdF3 å“©Jßë%¡óúb[Ø`·¡Ò×ÚÁÁ΋=É]ìÂû„«™g %š$˜rˆSœ<PùæÀV଱ϟ}C·ÛÎ2ûY1-<±ô·”èDÎ{$³š« àÑÚÀ°Éèt<þÁÊ eî”Hξó¹ÐÙÐ°à†ƒN^î\I‹hßµH­Õc1ò¨,{�¿³ÒJ™î¡èÈ5hw<ãxÓð, =0æ+·e"Q?x@€ë¡g°Ûï2´¿¢^ıO‡b& ҭ΄€Ø;œ”`ô¿†š¥hIÝr‘ÝíBéA-:6ôþÛ¶ ªÉfkÿ|pýÎo0JWB–lÇÆoZKÇÑb¾–²®R{h1gÈn¯Mì_®,{ç†G*Çb­]T:ˆ+ÑÿËìù¨.což–yîKÙуGÊ^n½6'ì ˜ë/vËäeÄ(Å¿öÕ¼¶ŒÃˆ³¾Ö–ÅC‡ .Àap{ j—ØX�ÅÌ×QuoëÖùÄž4”† (aUÓCÇ[õõ…q³`Ç·õepErR"‚Ë@ïaîØÒÊÜàM½ê^*€å@@læЄS©Îúᮣã§Ä_@è--¡H‘‰•Î‰öaO´1ÈdF¹S°~NäÏòJQŸ"ý6  à½çÂE[óž˳ÏÿûÑwÌ]&ë~çw[Z; ÐZ2 3Ÿ²^™R>cO§ÿó}ê`cË'„0¿céV„ bjÁ[H½ôžJTnL_0ðD»o]Ó^­1–¦ ú â; ¸Ö*ÓX1<Í>5­ÈØì›þšö¿×÷K“…œ ´N£­¦`ùÉÕéck{ìgU½í'Çeæß/ص•§±ìZèBÐÀxÚ>U“ºÕ/‰|:H‰'2ƒ˜´ŠßX±…ÂÃðãýÚmërz°®¢,ñíÈhÕÂa;<®½ÂÖ,+fÿ±Ëͱ¯B9¿4_ö•Òh¼åsc÷Hå+™©TºíÿÜ¿ôŽOçG’#iZm)×ëÖS :>òeµ…hó¹êš¢•ix—jpË9¼<ß©¦3'šmŠ‡ç[óv°�tÌ£PÖ{Z+ÿË+h`[‰Ìúß,{¦µ\ˆ¿³›Ú6ô—þ5Þ ãN(äÍ—áŸË?›m°·¶ŸuÕ)~JÓPÒÑÖ€ùk8œ{ G+_sê ‚!Ô»ÁˆGÙË¥reâ­]ÎÁ©` ª­•k¥tàó4ìÀÇQ·yZ{kØ£—Z±©}›³›áöS…¼dHg­O~;$³V·ÊÊ\.ÚΟ>Y^w¨ AÌReä––?ϼûË;"XÙB—î$eu[+b /àgN`X˜¹ú|-ž8+Øöšˆ§D(Ó ¶5'ô'T‘‹Ã bŒþuK¥ÑxÚßV’ŸîÖîˆùÜÐzÎ ²X–Ø[ÁSÈíÌ!dä‹| n’úc_qꉬã°ØL€—ÍäT‘=ý¥{Nâ³?Ê=êìX{MýM_·œÝÑ¢~Kž:©²…Àc&r˜6û<Œt‰vÈ/Ô0•v†:'⶞%Bk‘òåÕX|ÑÆ‹,¬E4ä2ä]´›.Ÿž&l»£CÖ1¿M¹*O¦_¤~7±²VE°\>è,ÑAîxš¾´ÍÛ ¨çÎ*y¶€fB¨?+‚dP �#3En¬uJy' vô­¨½#Žê‘Œ‘feAßÁUåSµLaý% ]»h‡6Ì £OÆ]½¼ƒYî7¦ Qää²EôðC¡2¹ ž¼-§Ãivö6ÿ €wí¬w ¼eé²vê¯Ö°œ«gÏ(fÛú¶ÛœµŽ…ˆãžNN  0:M«± â­ö¡Ö‡Öj¸ôh$e‚þñÄ}á‡Ó¤¸Šý”c‚MÌU˜™=£eÂâ¢6x‹³g1ì‘Ú¯ê‚Ní…`6ˆucÈöâæÁ —ç/Qð#8á©['Qa†¹’ëgz¨á·W¾–µpÚý0vÁ8˜ß\Ø®YâB@ÈÆ3[(YA\:(IÓ/ 6€lêÁ¦‚†\qdá»å†Ä¸£»íA=Ã*c´ÎSýxÝÙr ÷™ABNôÙ+\±ïc½wÓžÝðEÛKæMËñ4ϯƒ¨6 ƒêÓ¢k‹MÀÞFL¥¹)¾èÓï56€=*±[ØBêq¾ºÞ µÏÚbý’Ï+o&Œï¢[JÄD ñäØøÓ[¿ªwc,öþtV @ô³#š Ò>tîØ÷Çz˜/c kzïòÉÆÜÀQ¦ã Ýcã/¦‹ž0|ÆŠØ«»•4%Eñμ:‹]ÎsÁÕŸ(acçr+]fÏêômPî2Ÿ†½mÕ«y%Ýy:QÖ}0‚øÅ¥îÍMõ"Ì{ Í<M5Ü#ð'3µžQ¬ —V<ZÖÃà˜œÍ¡Ýï}qq™ÅÕ<•5µ«áN:ZX™…ëW¬¬éóÁâÇü¥—NìÚÑ3ºmT%ÐÑ]|®=«Ç‰2bþÚÏßTçIÒ”ÞË“Ž´è“iPÑ|̪ñÍgóÎë¾;Ñ©Ñ}ô»I$-„¦Sw#ÐŒᵗ‘×*/œ48WAÜnÙJ´�n‘~ˆb‡ÃõT1Ñø&ô­¤½i-”MÙÕm·qö”î°n!àòŸŠ®\°WHüd­ªTèÛb€Yé«5£™ßÐIc¦3Â)óý]ñx;óﱃIÉ•@v:n<]«3ä"•z­ôtY@™ÑHD>Lì}IÁßù­ºÃG­E1â‹Oªy|y*Lúw"‚cû2Þå}ù©0ô%´qÇj*}çÚ¹ ÒGs½ ªgTXÓ¶ÃðÝo€$º¥€‡žrv(..pš»¨ö | /“…‰ˆ˜²Ÿÿx×ÒÔ |pd§ ŒÒÞNûs}1Ú fâé.’ÒþýÃ/‹SH Fÿ} `uïÕd¹eyÆæhÝœ(o/;éó‰¿rCé¤{¨C!llŸ3ÿíiÅb*ÈmÚ.Ë‚¼S?O¡Í(B¤Ì0v³¤cki5¿!—d™OùD#û�ä•Ò|’ÄXÂbP¸£Çò´Ø<v1»ËÎ&P‰/ȱÑ^Tƒ®‚Ês4´Éo„÷ ]•s><PŒÉ:-,!ã"Âi&i¥ru_Oç lS%¦µÝª!¦è™$ôˆi#XÏy÷­×à§léâ÷½–³¨=6b‡¯Oý}Øjz ÐlEPNßv‚šÃTRä vD›Mï@Óô×?Ýq—-"7…‡2^°ÿ¢ì¡²•~’A`2'æg,ê®_ÝXÈ;Y¸¹|< WëìµX}¿Ã†–£±¬¬ÇÓpÅl¶c ÐèaozŠ{ÅÔéYXŠXéÞfñgÖÐøP±Ÿ¹;™õã]ÞöJ«È‚LCÇ!ªI‰&1Û¸íOýiâ€~¥ßYôQ^.”ªK`>¢ Øtž¡,…ƒ˜ Ëia/ž1UÚîº[ŠrÕyí[WÔ—ùp,MòÐßû×€Êe*À(¿`ž0ßð3½€Óv{‹Ç“b¥ŸýDÛÆBü"¹°e-ž93 6ó9M')¾õ/� Eìz¢â2æAñ½Ñ¿:ãlõôêë‹az0›dféë2ÈJ_‰…ÈìædrJ W߇/æBJ¦fŒ¥¯_M§>´§dõÞš-ótâ$ ͉Ï-G{ ­YbuMµ|÷зƒc®®BÈcÒŸ)ìȲâ€f—üpxñ{ÿêÙ ¶˜ÙnRQwvG„lÑ=o=–êgB‘UZIÖýWgËÌ—}qÚôwðϬ°ºšÈr2¶V(û­§×ÈSê ÍušSÏ ·_¯H$<fh¶ÃÑzcRÒm7Œ:ÿ¢OsÎ;“¾t†8½6'EÈk{„ù¸®nô&ÅØÍ3²ßwýý+0ªÇýqºI.¶ÂIà Fá ·ÊÛŽ'_bR´a¦xMãäüùsÿ³þAåFÑöÎo´íyXu¡ &P¸ï­+–në5UNã }¡ÇÔ€$bò$ï:72·} b„¯­"µ¦šÁcÓr ÁgpNæw/"[,tÉQbö´\Í6‰ ”˜2X'AKüm÷Ñ(¤èËýd_Utbî•aíQYY5p+á NoYC™‚U¶Â¾ÎÃîHb«þSiæ!°HͳmSÉpÈ(4O¢•þŠhåLás:‚Iìr%¨&rF¯ÞXþÊëÒÓȈxhti—ýX6z­'z£Ø­Ñ¦:³[’5n\_úöº¦L‡à fhËfV �Ø÷ž¾$¨h#qaµÌ[0­öèæh—®+WanúŒ’²”¾=ý(M£ÙMtœ`VØuŒD²îYO3¨<Y´ë© n“ 9Y3q¡°ºß—î·1jØ­¾ÐS–fÔ¼¥_~0­çu)Ì}!wtÕZÀÅOëù­£ðÒ¯¥VetˆÃj_â n`Iâ±øXï"Z©ås&èã¡”òô˜ÿV<+¢'¥AWHñiÐÁüqš¼FÕ¾^wlü;U^Ú% ÷ŠÅ©OŸ¦NwŒBÔ*fÒ SÙï\û¾Œ°ÊDO�ú\²Ú®îÕ’.SŽ_€Pª×~ÍìKâ•(öUY{´¤V^à‚QKq´æ Ô6ÓþúÇL®qØ ‡!þׂ¨Ìc³Í G Xáéâ*:�ës*¤ZG³Ü¡9ç™ Î8Øã Ÿ j;–<dëL^Æ Èà…K²íµ ¼½Vû$ÈÖ?^Žo.?X™ÈìüV´£ï‡½ø‰°„íÑy2QBR´ë]ñs¥÷o[ø3'»t~B×w&[¬œJ§ëæT¡•Ÿ* Å÷žrmUúzG.0÷eñ8,Ø54² Rz#V„jß_JM%q¸¨…cÈ%A¾®š¯/˜&kÔÜôºŸ d–›†<Ä»RJ³æ¬yÛâ:ØèÇ\°ã8Ð)PºxV PZþƒªñðe¢Þò'z¦ž4KŽÖã©)ƒ¸Wÿ¶œ«L˜QüNÉÏP™GÊ>NÓPQ–©Žà9×…õ '*}¶3P:ôHõž]VùØêˆ ­2Z'ªô"~ÊL¤f =\múÐBë=žõ-ã:ª²%½úRI{Ôî�î@¡-m¶È\£ Î%üïT¥ò…Ö<­õ=Ðù“ï}ÂÜÉN½;¥Sm"Ú{༴ô@1ßô=D5ôL3KîK óžÎ*_ÑÃ<×êîðØÀI-ÒŒ920mÕ¬ßß¼fÍã‹É³/îQQ.\;ÓcªÎí±¾†Nöä…GvAAžj€H Ä2ÛK+ o0WiQd–D“�®JA2ý®í¸û"ÊžTÌ[}yù•ÁêcVð\÷+G—QéY ©cÛžèÓ¨¶I¶ƒñžÛTÄÃ7ÎXï Í#ðT„¨u$ZÔ¬_ÙsK …módƒí{H¼Ä3¿æ^Îq¤óã¤é|d6•‚ô¼LèÑøúõÊ4ó%óèæì“$ˆ[í Tj$Öú¹ðÄ3Süó¼Ë‘äËD\`v (½kZÕFšYŠtO¯ÿñx£ÌÄ‚qOáeò¬±¦£ÚÆŒ‡½0+㮋"[ª§­¶tJ4*ØÉÄIÃø@.¥#\^NŽžÍ”²ÂR Q{$<¡†æŸârMÎæ7OÞͨŸN«“ÊêŠáÁøÔØxFÖÓ=Ñ_Ê:kÅõµ=¥tœëã@qyŸoO½óOX‚_ýGH¤sgïÑ=íé¬6³¬í¬é­ÑÉ¢@Ò×'Ö¥³`“ßÌåªÐŸç‘’·úè1æ|ÞЊò^:F4ã$={I~\¢©<yžRèÉ eMäÐ## xòð‚>¯²+¢)�á}cå¾RKú€â·hðr)lTZäÃÅáNêýĹÜÝUÕ‡ïÆÅAP)j=vƒ‡(*7êc=ËóšRÚáÇë‘KÇͼc£–¸¸‡W)­àZå†)µ>ºõxØ[½njÊd7œ<·—éDëµ»v·Ù!"¸K?¤æÆïìx�j«“~ŠùgÈ\Í�£š¥šhcHY¾9LâÃyõº˜M†Þ¸jc¾Þ(†‰N|ú¨—aØ ÚõõzĘËLwú^p² âZˆŽ5Öó7nÌ8½d÷®¯Õ½ß] 8E‰ à§& ˜&/k“€aŒ¤Vü?YÎ B­áG?n´4¡Ì}ž�¡¬{'J3Á{y¶G? Yôù/Íf‹Tæî/å Ù Z ÂáŠÊ?¶ƒ‘²´®“î…bÐQœ;fV‰Zí©ŒJ‡Úƒ!³H“‘L|F6v^T"hOui³Qlµ ›®>íêiÀcàö½ ›ÆIž/ªõÕ6§Üö¨¦#'ZÙ¬Qyðô,È—1HÌsºóWg*D“ÜÝ.ùÑ¢æ«>5R/$oqo¹ ”ø]@ëf†Ü”q>Š)òòvùr3kW_:o¦ÕŸ((˜f3ëõ40EK’×ÍÂ;ÝÃÈKZeµÚÃÏ÷¤JÉQ½ö6jõ®?;iÇÇžÆ"ŠCÃì³ç[;‡´BÍѳ:ì/Wàí§¬-2Á”66¾ùv£W�ñëóäf€ÿ7"øQ±�XA*Ó?§µ=œõ àGÐIÉhLìŠ=Û6æßîÓ mÎZ‡{±0¥•×ŸZ‰“,Èò‹tÃoy²"Z ÿÈ4Ôã ‹™iÑÈöM}i‰Â *Îí§E/ñ΀þØtC¼ÛòªÜ¬<U&vÓôÇ“Õb–a'pË~yÏf:¯Yçã6Êh;O¾Ã)mgTþ"ä}7`? ÉÿA´ÕùQ.ñ­EæSiéÄ£z5ëd¸¨Z^¹5úDËdÛ«aÔé¡Ç³ôÆÊ#W»sۉ纾>÷¼Ï2¿ TxSÅÚdl€f5»Ák>ñmpWtº�+cj!U‹rÁâÏ�ü–³œÏÙÝ Çk31úÑ%ŽR·EYõ¶‡efÑm<Ðÿp†NgjìåeˆÏ’EÂÊèçÍ-—ªVH SF/­·*ߥºFž+ß`bÒ£6‰ ÷qÀ<߆Î7à¥äå^¡å‘(éÝ.h…]¼Z=î'­è§®o.‹o½„âÒKåx~jh»ŸJ!Ïy}*楛žö “pÁ+e‹;–”·¾ï‘ÏDs„L´ƒõQù×wÍ£Ìøƒ¡ûÎí¥íL(j×"ž $Ú’gœ²Z›@óŒ÷Ï­ˆOæ[QŒ^iUwhuh®e‡œñÝýû8ç>¢-e�?Zy•Ž”¢H³öšcgºñíXëw@ß_¢ìM»Ãɳ&&Y5øFõ|¥S¬žë-wØ,6è·ØÆ̉(Cr¦€ÿ@PÔŸž( þç¬Â®÷ᥛ^å½)ZUÝ%AR¾ô‘X5b°>滩otMߧöKÑ_®Æ!M°-ƒÂ²ñ3C\SéÕžîËPðƒ^éÓ½³åO¡(¬›5¤°Ë³!­”s&,.~[t­t9?º¾³;“ÂƤ’#ÒiëÆ*uÅÑúª`WKĦ%ÁHR™:“íËŠËîxØ¿ŠÕÎÄ�¾Yeï÷Û¸+?m{׉ñ½«1enY!‰Ø©š/mK<Öæ zfÞ¦¾Q]÷¢É§A¼ý×ëïoeŽ´žw§€é8h»ƒøù!í,"ÃÝj·ˆ`ÿ:·ØÉt®)2…™›¢›qg]^¯Ò(õ˜(¬ÏÑŸ¨™”…ºÍ™\½CЪò4¯|Ãæôï¿pyyÓ’*Ë"—†ÁàœYýmÊÝ‘'Ö†’6i:I_‘ŽÀ?‡ñžHã»PÜ8[h?€=ròeRA+EY7^Ti—jœ‹rÀñ^EÁ|¤ìl¶Ì}~ˆ·À%Âñ¨KÓ,¿ÿÎ("÷ØcÁjŽ`·°±ö¿©ÌA¾ dò+ãë\¬Š}gQI#ÀÎ~+”oæ7š"nì6<På yç¹@Ÿ©»cfIî™ñ^QY¯mùCoeÞq_·"‘J‰ÿ›‚3Qõ'Ó•áQä× )ÖÖ6Y!4¹„mm¼çk¹2†À»¼#B^¤™¯¨„RJÇÛÆAcøÞ$–3²‚幊›ÿ\)µ.i•?Sª”‘£rÃöu…>“<…³2§˜+ÀIÜèÔ 3Ü¡fK_(m½ç°uµÖïá#E¸`qgÁyf© !Ó®âäG¥VedK0Ei᛺%"½}ú&VÓj{péèÖ�Aœô–ÑÚ2/^µe ” �éRµ['ç F2ƒ;æί•µÇÂ;V²ûÅz¼YayE'd?dÛ{Yݼë9ŒJX¸ç&ð¦·@»„Gqç5E<«ó°$ÝeÖ vÝHq×KÌÕ“vwQdžÉÀhtp$ýÉkG\©‘p£SnÏ“3{uÓ±o¤b>C³P‹Õݾ¶ÄÜyÍÑÑ6õ÷0°I¸È �çM=ÍXÎÅÓÈ”Þ{­˜üDæÏØ…Zld쎴U£®qô¡Ökwû6Y�Ìñ»QlmwÓôÈ¾Í ¨*its¢ä&þô’#Æ·?œÍâÿê£`™¹Ój!¦–+(‚L7p±>¿ÆIx@‹Œ=ï^ê‘’9Ó0©ð&*7ÖÛ1“áµÝKï KÅÕ‰”Hed¶ÇÞ#aðy´È!Uhû=Áí< ¯X•í–nÉédzš¡ÈE÷ýFƒ¼•k%V$<6�(:e£QOˆ¶0qºR—tŽ>µ.9:û›:cú§C‚(õ¥ 2´©'óïj_ú£ChÛUTYeFº³ëþÂð[­ßÑÍ<V])„uÀb¿­EŠ6'jóÊ *JòŠ>žç›ÐöèŸo.†n `Ê€”M¨8¤*ùx�üÛ…·Ä³§ùçê·"79Ußoª¾nÇí^å�ˆLÇ»ÐZmËžc›½â鋯öŠ&kÌ/¾düöpÈÅ<À…¶Ü=‰¹8òZËì‰Ó÷q”—Ö38v'h†KQ‚ꄲLñäå£aZÔpÖU$Ðê,'�7gA6©ø8Â?°­Èz¤4UK_^¢†-Sß%!‚ÎräV®“…F}jgs˜¬O;‡êæò0麅z¡t‚›“~b(uìúB38w⢼éú#e ü u _0,µÅdðÚ ýVp?Ζ=í¸¥6f.·tg{f hÉ鵦{.픣Náz–vŸ–áW½”Ç=•¢ô½“Xà¡ ZÈÊ°†‰VãÖôîìâß«^¦ ”†™1põ}t§Si«ã6oeþzù믓fÈ5Ât�å©Ö³4æï,ym`™õ(ªêf*î»=­ë±cÙߧۋ,˜5ÁD;žFó°:ÛUCm€aVo¯,£PDKAŸ‚˜G<ª¦LÅšq¼ôÌf½*°8é¼C9Í<(&(§=¨f§­—a6”Xbr`&Åtæ|ulZµ°5ì´2ɯŒ›& òÑoR7"z׫•JØo/bƒ|Í•¸¾§Í@åÆQÏ-h"7u?aÍÚ$OZ ïíùÒ Èùè©¡eÿ­É˜ðÍDöø©¯·Þ’ëöýexˆÆpž°"P™ i!o‡ßvÅf²Ø³ºR!‰_Ób+8¬¶kxtLÚƒh 4º³è‘Cÿ…÷½(7AI‚cíó+-ÚÔe 63-÷ÊboE« ¼ŸÎÙÚ±¾`~+?ç%VèÎ ÕçFìgñÝÔYØ´ëÁÑà¿@Kƒ¬¦¯¨—‘*pÇJ&_ý¡/Íz¸1Óèþ¸å‰ÍÅü{íoìùZcR€­�éçÙ³Âä“*k f´4>pbH²í:!¶Aý£ÓŒ9K=¯ %D7d\¦¸jþ«"1™áòåŽ6¥—Ø1%¸“ ëNÓCÛý0ˆz˜c';ӃРÞbˆaÜN·ŠÅ‘2+¬sâT§eP~_¬HåœëzÐëï)PrnÇ£ö‡›,E*WHm”r°1rÒOꀚK¢/IøÃkD…4ÎÜL•žÚ´^ýñÓ3Íå. ŸüÊU2ýñ-û¡,v³–ˆ{ò ä¥õÖby�Çr[p_æĈ(ôäf„ “j,Ž"+» Ôö”jãH¬U=1VîH³™i­;a°<®K´ÁâŒ%™U‘es³­QåÖçy'® W¯Þ¤&6'Úþ+ƒrðç®]È[™£ús1‚¢ðd™õ;PøÚÑÕý- §Á×®7Îë<Î7ñö¼³i•wy_–ƒgzt+»"([EÇDXp[~(÷zta¯:Æ=2=ªÜKŒÞÛ¢y~šÝ¸:Ôó/[=VðÑ€ŠŠ`µÎÓ £lB¸¸tŸ÷ÝüÑœv,ÁJ&àÛ 2«÷~.B-ܽŽ[ùèHnhË('ü6úŸH5pC5Þ61Э'w.âO)(4ýãAtÄ¡ 'á#Äd™“3º‘cH¼»ï8—aÐÂCƒsðZh(½|Á.Ϊ\ …qën„Y›"è¹L¦¯ûêòÊÈ6c¡ŒÂÙI;\�&nðú —V–S»yQ½ÖYW˸²‡)ÏŒ‚iʃržUŠÉÌæ 'jÄÐÓ?wqXmT°ØžK¥RR¾«ÙP¸œeË»NõyåÆߥ9èÊå+()Ý–­kÝcdÜÑ1bĦêæ=ѳÞ]"G•Î¸gŸäµ¯`ÖPl°Ô?‰¿Õ,L]¸ Ûɵ™¦Ž(çjEV8¯Y#¤E{î°§ªÓ@N¡´X?âwÇÙ„?îöDϲޘ}ôÈXñëö_¡â#ˆ½°‡èâ bå>êÄ1b«6ž³‹eý¾óö¥=˜U¡³°Çv ¥9N>äƒv–LÇ$ᲈVJ6pㆸ«Ûî “C\öZ²×@ùóíú 7hŒ ŠËu–N ’ÔsBbO°µ`Ѯͭቆùøºm1{€uönV1”pÈÿ3I&üˆÅ”å~s‚}Tf”ÇÁk¸(jï]9ºgÊtyäèÉ,’ÃöŽéÖ¶DBp–¢¹Á-»ôýüÄÛ±\( ÒvZágG†9Ò)õ#Ρf)ñ9bÐË97g>¿YæÚÁ¹03*IݨOÔéy'ÌCiÑѲ_ÏÞÕ­Dsâ Øoxµ‡æVçLI¤ñÉójl#æ ÁsWMÓj1'(‚óJ ó£v°qëµkcN˜3i£v)žþtý m>7™ÓjM…pt²>ü†D`7¶íNOÒl:f)\(¶¿lhÛúcu<*¸{¿â®X`DË€ª˜h¶Ž¹‚sF*p“.í&ňÞ!Wå~šŠÂôXY¯âlØX½OéÃ=É,z§ñã8þèÄÚ8ÉSÀ¸:&tºÓòÈ›©ÂqòRá™VžÜ£÷@ï®dÄkzãýßÞˆ«;òdÐgï©°ûž”Ò ò¬¥ù•‘aV¹Ûê´¶-e³ÿnÜV5ñ˜Q³ &¾éŠSd \Eôy[Å)Iœ2V}“·=®bÏ…[àÆL6š”¨Spû³îñ?ÒéÔ¯èFI´š(ÚÒ&m“?¶õ±>‹»©5£™i“2™/Smñ“Tô$1û¾‹|C÷@òU½¸qùf fÏ0®4PûùÖ¼›';aéÀü…cã8|-cWXû‘q¶á­9[c\cPj¸Éº•¹\¦Ÿ‘ŸÐmrëæá`Բ̠³Â‚jò’ê\O(ÀˆÃIbvè[ASÔcšËuÌ wû™Õ4l ®¤_”éüQ¹Øwê±} Tu÷r)!¤.·1+Lä¤ÎÞidþ¦[ßÍcåD^B$Zô·®…$ªðJ%àkN˜gÁåH[%ÅxË�Öá]“†Ði:ò¬.˜hw•ëÖÅ –±ê‹àV'q¢Ë^ÛYÈ´ ÄhèXúIf±3T­IÇ^f^·ªÒ÷å¥óÜkòpµ(Æ­6 Àv˜ºÚãï1"4¶rþõÓçyjq)ëF‚\Z¬ú£”¯¶Ìß0Áâ~ûáQ'" }ÓØ°ZLÆEòå[geú”2çfV¯×öBÏ$;ª0És½FpDÖg‚F:xB(½å¦óGžX—±3I‚tÖY$ìQÐý:ÀdÇ#ÿÆÓäÆâÄU«ÒƒÊð¥Ò úT ©IqTí~Ï W_ëEK9ŽrßQܾyòîT‹ŒžÍ R‹¦Œ¼Þ¨E{Æ»k üк²^õ~§š°öR9ýn]ÿØ×gÀõ(ò,„–¹)ƒtm•&™Œ^€ÛÿdŸ'$ƒÂ€ñN9ºA)è¢4 3x4¯{?=lƒ™ïyB"+õtÕcÞ(λx_ãp|Ûˆ)â×Ä8eAx:Úµ%ç’Y\Ó™6¿X6ˆÃ×V”¬ !}8iDÝà ÒÔ rs£NËjt£ØÎü²BãÍ ‰>â¸ü'¦ÊÁä*,™qy"IÇÊ!Ž¸JÙtAϾ¶åeµ°ÂºàŸDz—´iøZm)´ÀAÞâsXÒfß-|jæB¸I…¦®¢Dd²µp&ÑP,$…C$]osº‰Àäwng¥‘ƒTq¿i5Ó‰ÝXé)º 5eEy#:ÀIÜ€ž2¯‚`ÔüôE{xÖn/ÊvKÊVk†·Il¹7&K¹–ûC!5ÿl-› “ØÉ-nŒuw˜UÄ õµ„ò¬Ä¨áps:gÝ‹i¥ì@“¼«Ý’¸*œÀ2._3Ô·k7vb%ByçÃϴűǰ… ÚŽŸâ1cU,´EH1Q‰±_%Rq\^k/ÅIz¾m`[NqEÕ‹žµ9<·:£aj(:Û¹¿¹ëÀðXº> ½³œF]À´SH8»ÏŒ®)ò5ÔôGœ;#9îšIj|ƒwaÄ ªnY!ÎU+p[8ýÑ:gEaÖ¨1–%&?Øϲ~/'µ2ó‚ƒïƹ`aY Y ‡ñ­§,e@VìoÄôËÔÕ?¥áÄW”ŒYM·È :qúüÎ;ν_È8¥Yæ{Å�£A§}xôþµ’iÛ À^’F‹0㽑ٺú|0¨_©QPr�D!©ÕšúK¼Õ]OûgýtÝä6·†ísx(K!^ [JZlë gÃÁ{|áÐ6xÚe0×P›²â“ ?Ïö£u2Õ¼}ù�ô/'¨‘2Yχ&‹î 3àí’V‰ i&TQÆÐÈ»ÿlû6âŒ9áT7·²‰¥±v`ˆ®™sþ"Õu:û™™ÝO_e}~+* ‚ìø8øê5+!×½ ûv+Ç‘Ñ9v€ ý(.�‡�X0í±§yŒÐpÀš¿ösVÀ2 Çûr®lmÓ±|«iDIWÖØX-zhnù㣔¥äGP¥&ÒêOCÇ®9f.¼co¾§z«eì;/¢WWA^ÄSh÷BM¿§C¿ã‡½XX0ú)‹²p6Yp¢ÍiM¸bî6Î>%Ñ‘u,X¢þú5’ôÂA#�Ìù“ž©”9À—Úuç@È––¿ÌúMÜfÓ,Óÿû…ü?W¿Óß\ðŽõ)!§ÀùâųE#‚Ï–%„4ñ ÓtĬ;®$F^ç.Ä2Â+™„q[RÉ¥(_›­zŒXªo0ÁS°ó]g¨[z1®/ó¯SCßà¨*УíwL—£ó‡u¨³ºº¿/וyÌ:I±“ Z«ë,Ƽõ©×¦´& §¤¿7¶ŒoN\Ò|é”XÑzM‚ÊŠ¢¥…1x[£ì”]�oÒîåÂ5g”oá}žŠ =5šÅeB÷d抧= ¿MžLô”¼ý50kñÎtç§ ­—d«Q Œ¹M7^]�· 0”jÕ ývšÏPšÁ芅O5}Ì3¼N[Ͼ˜¥XÑ—\â=R[–Ç¡Éæ9™+­Ù¸”.x¯²¸Hh4*Ç&QÇ%÷©¥`½Ìzn´^ºg@âå/™a¯LïM£¤ô…í(ùˆöâù«5‘‰ó¢ñXE‚<Ö=‡"ÚŠáè{4;§ T_Rßð}h²åRr"NôØhëÜ”Å<R0 ÐöÕËׂb'Ö/AÖÎ^ŸPõõŽä`I ² …Ϊ¡-Òi|rB‹�µÔ rä"ÿ‡”øÕh²Ê|ฦ„ZOÍîPq­&ª¿¾èï#éß,·‡‚a‰”$(l±¡Ü׫,U]¦qF±fu Fìê/ïj™:–NÖ¸´;£Ié€Þ‡éØ#ÊÍ<p$®ŸA‘±UBŽÚq΃øÒ™€ ã?i•É=NùzZÈœ’-ÀÛŒßt!/*x4Z¥Û½97*0ÎŽÁÐx%W&åÃHÿ¤µRÈ,âÓrÿùÀæ:ˆ´ƒ’7q1U¨döÖãPš‹ûÑÕ¨YµÀ�”ƒb0ºRÎ)½ WÓóâynÌÃ{ß!a²š‡T(\<FM´B Ù (µz‡Iúâ\®ÓÝwWwj‡¸²7B½žz:™;A;´­¿l§^äî½øÞÏL¦¢£y¬OÞ´¥9Q Ëk÷UþyG+«Ê”ëíMcÌV*²Vf`,»eAìŸÙƒš>MÜ2â5uÿò†È`å±Ñ·j'J2(Aº07]¼ó®ÐðoÂâ‹ÊÇçÑ–¦˜]Ù·%cEµp®M«uþßݟλpî…Ïiˆ@VNsú*?~?ÅLRm2r¡m‹X_oPmi¼�µ•Á°¡C¸œf7²žF²þb|[ü"“ ñÔÏ´ˆ²z´Ä 6žþ£1êô™ŒY;Õ[á"YßzžÜxÈCa•#M0ªT"G­1n%ÄGéÊ™§ò$a÷ÑnÓ ˜¿ÄU:x·AZmUIç5'I÷~õd[ƒ£C¶†ðò§~=>nºsÇŠìTƒåIêI|‡sèŽÛŽ²<–`ö ‡ ÖGÐWÜlŠƒŒEØ#©ø(BÁâc³);!ƒ.Œ‘ÙeÛQâêmù“gôÌhhVüƒy…2 ªÊ€Ä•ýÐìX.Ç8M©¹ÉÝ~kœ„>.’Û4¤\ݲmi£rÒËHVÖÁó'cÅs¯»±$† ¥ÐLlß·–ñ/¼fþÚø=É|í\OSBKy:9Ú0Ï£TÍ÷U¯è(AÍÀŠgŸ`BOÿCîÙú­2“žóš=? .’"S>¼|ª“ úÍØå¹ ÷ʯÛéûmO1Û,GVù¼a^¦*^ý7JÄùŸªc„Ó§m<Ðfåpnû;Ï ÍÒÄç{PÝp9Ð?©µ2â_ÿ¨ŸTÔ0�2)ÖpTµ˜¨íÉÏÑœ…ñ-Ñß”'¿tÖK+7¸—:ˆ¸jkiípãf1M‘·à^ëßcâ¬j>ßkär Z'ka‡é­3^Þf‰ø;«Ÿº|qisµ�+åà݉Ơ º°x£¢¾Gwöõõ =q‘Q·—-ãåºçjDóÉ£X éîFÓóžx’שãS MùðãAŒH¨|Ýeö>¾4ÒÛÃlG³È¿ÒL ß4ê\λ‰´=ùË<N¼ÿÀêÚš�¢›êÑϾ¿@l$¾æoÚZ£Î*f~Ñj(@0š™]V» Å'àÖtPiU[ØUé œ¢l ¹E°g4k¶:i“_åä‰ãB°š`mV'BÙò‹S#« *w+1íþ·Ìœ‹cÁNì”ó'÷WX o{Ï{#Sä]Þ"#<ï(žýNyf»Ò‹¢óø«›B[èÊ{5DZ„KÉ@f¡ÇõàÅ i´p+Ù¤5¿"¢;eÞÈ€0ö]ÄàU#„$wÜ£˜Ð†Š>õ x(2S ª˜Ö¢(m¸‹ï+àÛ þ ã÷‰þ§ôÚ¸Œ‘¹]Hk³³Å,Ö,q)¢Í¢OñßAj25]ä¨9÷DýòȈYÌÁ‰à ½ȶ&#e`?½Û´<Ûã¼YbYÒ*‘zë$H~>M—´à-E©öÄj<²Í¡oL³òyÏxyæÑJ8þ¥¿½âÏšùÕé膽M¿›&…O–þ§‚L*yÏ5r ±–gÏÒ¸óûKf P!5lxù•oi¤ÏÞrGû¡nôTyÏXf ôª;'ª×_ÚFÓÙ{W¯4)}JˆÌ¶èal=½Ú ,=fÞxKO…fÞ›q9ÄNi’+*©Úloˆ Ö fg[‹MO‰'‹¢ºº‘Éj¼´pƒ¹ƒ~[KFùµ)ãTÓKœ!,ú¶íÎ;9x@œ` „ñÑ´£Î¿Ôz{ù³¶è%ßO¸W—åÆÉ2Ø~h(d`H¿sæ°£)[@9Ñw¬Ân¡‚ì~ZŸ85¸ù—Qö¾[‰„ñ<¨¾Ï^‡@éëú̧&R9ÌâG 5¯((,á9Îjv_²F,ô¿F‚[s®[£òenÄ#gõ,up=Öý˜º„ÕÍ\…€‚ÖÙÄ/ûÏ0Iž»::°ÁžŠÐò¤]{æOšÚóú‰²á@L„Ê-dËV§#ñBØ]Çqˆ+ÏmÕ¼yš‘]´aZØú‡?‘ÂÎë¬ô�²R|ª’HT±µ¬ R­¤æíÅÝ{R–®^âî[ÛQ™“ôg7s Ý0ØÞÒ’× ËÁ&÷~ò¸‘êÂãyu[FäCíÐL?sÐÚùCµñ, }?rˆ ͬ®ÛcÅŽÛØøÈ ™'Î'Å6|PPã#çŠíaç�€pÖ–JRØ ‰™"Ëi¦rf”°�Z3HÌ|¿ÄEˆ±F ©™ 7 …¯Ñ3¯¦»rT„À¯oU|59Ùœèý“V“&L÷"dqƒ·}¢w§•kƒ™*OI¡æÇˤ¿xà8¹†‘ÕEõ/_Š§f™¯GEë¦ï`ÖQ7ž¯Öa€W—HA­QER¦¯ýŸ]Û3óIÏoæº âãÅ3Ÿ7Nr =±%£Š›_ýxݧ¥OìÅ9ÕSÑmîS™Rî÷œ|=oþGô …ø'TL†íe¹I?ÞàÃi6p[Z~_kŒ¥Y»¶GŠçQ’/¼|([ÎÝO ¿»ýQí5)p·øУ6¦ÐòŸúIË2ö¯ê=z›7?õf†%{²z¤°\Ü$úü,žý+…¸ðPl)Vl¯µÅ¹r[pë•«f ¤¨¾LÒÚBb!‡¢Œ’Ò=ƒ ˆºìÁ^šüÚ©‚.Ooä˜þ†Vy2ìûQCò 9þØy( ;ó¼¦TÖ@_oE ô8ÓŸY7ó´'¤j£xÑ8“ûP#8€Jáÿq˜i%ì6Æ“Öv2Ï%Nã#˜¥Õî…º?î¨xáe° žÔÒ eׇAЭèÂÄŽÛð'JŠ¦ôÞÛ“/µ½»óÔúë ª6Z’ÉÑíßœ@é{;OªÐÜG+ÄTãÌL@KÍ»º«Üï\ëYÚ‹Þvš(}-x8•~km!›nA{a]ÇÃnpÎ+iêÙ£%F<¡­óü­êáãEåX›ù·õê0žö7J/q^ú;‹V#PS‹NgqÞ³ØKÊÖ¢ª•aÉïP#Q¼´œ8ØmÊ OÌk[Ÿ¹k? í•gkÆŠ»kÍ껣 äF²2?(ÍÆÆDЂ¡³ãϲÌtã]¡¶· º ¯³ßˆÖK¼ÑúÊg‹Õ‘õƒaP0LãÔè™wT-äáh "%kˆZû±|9Äݵ¬8žü=)ûÂÓaÍYbƒ fúÈcWM¶¿uñšºÏ¥ƒ`/2ªSGg»íîYÖÒ’î8;<ÌòkpHc}•Û%û.ÐCªÁµç ÆÎ,)ÏRî"Qßïî\´—uת`ÜB«ls*ƒtÒFˆÁ³O:)Í‚’Ê ÇŽæ×lûD)8M}‰·ÈŒRöÌÔ„z 'uâxköc9N–5{‚xÝk§(àµÌ:Û˜¹þ_î «•s%yÛ$H?gÏpw>ÈavÃ'{À+³ÖG‚]ã�ªº¢Ô¿J¤ãRýÙï±ÄÖF_ùöTh wñ6 ¥’KWJ3ÂãYÛ¿P¸…bÅn¡Ý.¤vW‘=w€Í"_ñžžù¶Í)]=;©n /¸ èÃ2RADpòñŒ gu1+ƒ†7 ,ý4jPù´«ÍÍ*es1°RI˜B¿~5öxæS'ˆ¶`÷eÜ—/A¬VFõÔ>OpÙàó×PLÓ#“MwÍ'OؽÏöÌ‚5†ž=f}ñŒ_ºÒ*+‚|¬=;z0³SÜŸÆ–RÇú N9¦V0âôÊ&îñ‰dÇ& ŠZ!šYÞPX> <è] Šõð®wêÅžL´îèsþhJ" på—&†7q¾ºÎ¼KaÚ^•ÆYVy :€nGx"MŽûý˜¢2½œbáÓ+ûMªÅù“Rä¶6PÌÖ?WÐqWRÿ[ž¥qZfž“5�ê3¤”- •ðn(]œ¬8±X˜H$Nä€ES‚aò§÷:bH#ÆÓzmA:Â̺óª2,ªgÌ‚ŒŒÚÆ <¨x#€w´žPö"u¾ÛKãž+÷ë'W‘ˆGó A™²¡UXM?N] Û_»óÇÁ¸¨PÙ{-à"÷$q¸k:lènÆ {ž™˜þŒ!&‹äŽùÏüEO_ð]Ë{íæ"\(äÑ®êbÑ7}ú•I<¯ Œ´Ø«HÃ+é¦"ó½èœè?ëì–ínñ!‚èü‡~~Œ¿îPÎ¥¾§­´Òà1 à˜üH}È©E‘³C›!cƒ¢þ1IΩ“²é=hnJûÜšùtf0¿ëŒ>ô§qãI!ph2Ý“„:ððÕ]“¤»—ÈZK× cÇŸfK;²<ZÑg�ãëV»I·ô^%ùRé9§fú¨Í”‘¥BÃÙ‡¿é\»¾šBs®^k)]Ï20:ó“•wLoDa‚*@!“©BôýÃûƼ³‘­Sõú°KâtZJ¦•Äë†UÊV•í}÷„ÚŒã! ¦! ŠÆôäáRgœ>#ŸnTŲå—â™%•§¯6ËÊpWè¶Dyä(è8ªA<¬=¡õnþwÓµ¢L^ÂÔS1Gteè­·ÓÖ³oz¦@{ý`°�´¿³º+½G7¿0ÛÏ ÷Ì’UXÅs7O âÓ×o›î‘š!Îø]Ø*–Eúc1Ñé€?dFÐü¿7ÆŠ÷~÷Àl±(}á-Äý^ËÍ’}&@úòl²Žõ™–‡|wÞ%\C*ËQMä3T?6¾îwÑs2m†ãÚ[Œø¢f+jö8eÑsÙ¨+šslÝ"IÎ`Yoè Ø–p½p^ï¸5ÙÕ„S,¡?5öNÔsk™{ô©'Ê-þ«9©”½òH×3‹ü"”EsÀ°ÝêºNÙH­ws4ëùˆm͆b­ø¿ð‰¥“åØ+{D”}“ïÚˆ´&0O·³øX_-¢w³ŽZ¾¿-a)™~¤»§gõË,c*èáÈ£î>å|ÄEç™ð&À-€zD™µ¼X/ÓZàCÑSDBê_>/±òxÑ%ËÄœ³Ø¨0}sZÑ"똷ŽL:e÷¿±3ø÷×Æœqœ:\ ­Žû8Èz]Å)8­ó‰r6Ň½<ä‡MÏ8.n³@¯QÂüyñÄ[×T¼R¯–¿ŒƒYŸc¾#”%™Ím#Ö”de9cO˜avÃÍHŸt'æú ÷ߤÌ%Æv:d eùûˆí…‰51¡è@Ùèÿ÷ÿ¦«F-¢d£³0ôG±‚˦Äügk€²âDÄv) ¢T$øÙ±¶�­®#ÌÇÿÙ ÿˆÊ†$… xvô?¨˜¹aeÆúî<$A¾ùäðs;q½ØL”¢ú—õèD›ý ª¦Äì á¸Y.á¡9:J‡ñ¡ >òÖÐ ã?ÞÜù•çÔY(U~®‚°ÕQ~Óõðáú¥Ü\›±ý¥æ½…à 5D'Ëu¶:ˆ�r§Œó$þ3ƒÄ(ÉPΠv)õ0¯·ÃØ>cD »:ZPá<8$Õ¶¾Ìn—íþ\œ Øcd rC*˜×T8µGÇCZ#ÿ�~Æ@ïçAO; ÆÍëo75LngE°ÄËÂèllFkÖû{�yâé©ÉävµrÔsà xQÒ±mfHÜu{íÀ“x4¶œt«*;k+ VPW2zº½;^̈íÑud9<±ìª‡[z¤Y÷¯f— š4½øBlx®Qâðv¶âèéiš:•¢œ<FšX`4L?„ÆÙûŠK÷ÒÄÛ3Dd(Ç“¢)ãªPÍ·zÀpZ!ÿ€qšúœeVέ‚⨧�¤Óè3bi°{ƒý}oêeYÆæœq:•õgµËËÀhŽÊ æw´ÑÒ+¤'p÷ âr9ZÂtùŠ‰<þžón¹ÌF j­‚ôSó25L]5BÝ^ {ã H÷Ú `±±ô·jøæ9 ‰¸ lgÂcëZb wå}‘k£M(ƒæš‚—à6;Q‚œC­o!&˜âŽJŒØ$•+«/ú¯¥š,ÎÝt·MFv¤&D¥ÌÁr°ë’9j'ä3ÖXâ¯PPVmÍ ¡ˆOw>´"Â%Ï‹EkMB¦a „8²ÔoîêmÍé¶îL§{mx¨ó»a8ü8y_ãíýâ’ð¿hÖÆ^Q²/ɬËñèÏ DÉõ”²öŒž\cíLHë{4ñ¾㣜֮ûì­~–¹ÃÜ¿ŒOóuÝ2¥ÿç”J–‹­x¢áØYÐÒ+•¡gúC•ŽÙ>_£`úʃ̲„`’=oûÚ ÑI}d¢èûª_‹ôµº›~3ÓµDmcôp”� ø½ÿ€f>á9ê†þ´=q vuÙM{çžI ʼÚîÞ›x¦™ï/r·EÈT‚ -4owô¼cžú Ü;δ3z«`‰ñÛÈîÖF â¹µVœ-xo1LÝË ÚŒžùݽó®§JÃîiØHóIÎp£û £èJO,³âÅD t|<Z§D¦œ 2Þ7:‰/•²ÊêÊçÝô°³šq¨/øù[¡éNºÑ‹KªÚ;[ÍÎÁåx¡ŠQÒ¦Öô’æW=ÔÓö?˜öl4Õ.Šœ¶ê†µÝ¹í¶[Ì]lû¦òào,\iê`Ý×Yâã`M,úEÅ/5T¦/:mÛ›AEÑx8;•¢÷·°qµP¬pËbúìÙZ= V©Ÿ§õá ¬Õs§…•Äw¥Gn^1‘š1¡{bG.˜àÃL[ÚP&oÓŸ™ÈÓßË⸰F¥8VÀò©êÚ S¹ÙBÕ Êȳ|îâR- xŠ#J­Ùôç§#"­¨!ùxÒwvØ›a<ìfnÄQݳÉ£›ÉYä¼bðÀ - ª®ö¤ÄhžÕßà=­ðe•Ha˜ªj»uG9rcn‰þF5ŽBß>' ö”¤>ªÄ{ò=¹ú~‰ÿ¶"÷Òo«à£R§ct2Vˆ†˜ãÊ7Ùµ\R¿°ÏñZ…•B»4È™á[•¯®;REe´ž Fò˜†¡)‡dNÌø[m!YSô—¿ô;*…!@¯Ö¨«{›É(ìŒRÕSÛz(âåQ‡¢ÒT›•,•I54þAû¼En9ùUSñ,æ­‘EWoªN„º—íêx!y�婺HصΓÌðG”ûs½ß‰¤:e¸‘´Œ)Ÿ“g´ü ~ö¾.}ˆž8r «¹‡£ÆxEœ¾îŠö±Ž ØÒSk_s…K?í¥dnÃJ‘Èà?<À«^ t#(o8×…mLã�ð®ãnž½¤—‘owµ¨ÜólqÇ3ˆSlžÛد)-¨aÝ íBM 'Zµ ;Àši£Ou3ýÉpȆ‡kúKawò˜Œ v–50NüYjõñ<ßòŽL[ƒ’µÉ×K°ö§Ér›;dÑbEˆM»ÞNV^üŒÓ'N mMcÆ DzÏk³ß9Gá`N["ôºÔÈĺ³ Š<ýùúÍBƒWì~â ;—×/L:6¨Ôía%Qáë±ÂtQvPN‡®·C­m§ý0ˆé}Q<i¦óÄ(WÍÀ? ìVâClè<¡Z—q¨jB\¿Úvmìò+Q’,‚x°ãß T¥P½ýU9q43 $hšÂâ, ’λü¨—6FÁx¡5´›0}†ÁÕO •vsCÆ8Áë;FOLyC7…‚£¿/ºð-¿]$É<fiPZ0øD»žUkeªâԵݕZ*.·p0D;ÂÿhÓ8Ù±×G£õj]ñÝ…kÎêâ_zFHâ€]Tß½‡×í�Â+Åðæ\}rÀÆ ƒš(hŠ"HëÚ»£#²@¥ŒÏõ^4iìÅM?Úöê3ç[­Y¸Ç—Üv‡þc®§/ZJC×C9}†’€ýnHD+Ιa2ÖCU¶Ú‘K˜_²¾¨|õUœ–Š½¸q䪲EÍTgºÙål÷ îǦ³Î•Ò×¢ÿ5‡ÑåOÞö8+M.‰i~4i'«ØîUü<ß: ã01“’Üd`梒ìì<ëÓ|Ú¼›N!ÞÅqv½O&óÁ¤Ìäw(6$P^Õ¼ÏÂa¸(Ò« §³¶^› R”‰úN§:ÈÏ}"çÊŒ;ÊdXA!>Næèc-Z¢ofØö?0iÃoTb¯‘!ÆT«}Ä=¯úݾ&0à á¦Þ?ÎÛ¼žëy7Ë“ �ÿg–˜{n}lY4´ÿד©p@L2fÐX’Zw@®ƒþ«§ñÜSýˆ”l… iѧ1 f¡>·³[ÃÌžz˾r¦K¨V)Œo�ú´¸ nˆ#£‰tŽéë;=ŸˆÙV–V´ìé¨ø×<Š’46C7[Õ×ÑÀ-RÆ Rµ9ÑaìüÔÁñ“€comm›@Šðü"CZŽ cìˆ&œÃª çoQ \¾éÝ:V¦7·û¿YÅP]²ºò¥„7û¬µA„„×ä÷¦?§Êº×—‡fƒ*\cfJxc´'¬íi$,|›w-qü挱ðú$nÖ·¿ñ今ÅÃA]6Tùz‰;[oµÝˆ"ÏXi¯›¢]ÔkHr‰7‰WÁFIéÍCymŒ@ß:/bsÞ'Æ%:x8`<(­n*Œ¼Ûù¼Ã0>¨W+o/CËØ¥BS\¸!•aÇAÕ)L?±Ç2¨òâÍ+/‘¦DÌ"Ü{²€¦y|n¼Ìƒîð`e ¡£SxG8¯†6VÑ9ilÃÓj÷€'¿çè–¡§V ᵆvïië¡Î({±î¿´zË2OFZð¦5p¿6±6´v| vE”WÙT!Àâøz¸|j=c1GMú£÷)ú¬è<¥ Òî¡×3Ô$THkfÊÒUM«ý8º§c£k®­(6#5¿wá¶c¹™oaœãÊ °“)t›a#êîH±Hþå(.vùYñ(/Fr* Z+ã…å$õ`a\u+÷·»´–2& +)œܵºoÒhCåÖÉ«¥]ªÉîMÖ›”×fQ_ð•L’Vsy2õÚðÐNc³ã£ãÖ©$ ½B r®É[yeV®È¨rü­gráÆì(M²¢Ý98[ÚyÉwd¹ðm¡P„žrômÐ 6±“½ la×R~£¹¬œùHö9å n;ïY´¨7‡ÙŸÈ-ðm¨ÅqÅé”<ÕŠ*…­Ãîþ¹ß® ²е4)DßyÑ1¸jD‘›B‹‚­ˆDtjc±˜vá$Ñ|ð™Jgz¼FNUøøÏUE¢ÜƒL0§v‚í"h™‘EO—v°RKô?´ÇØ ôˆÏÑf,X‚Ž;½çxq<î) v³ê ;–vpñlÝYÍ# á®A÷¦õ$Žãî0ZÂÑs§å¨Zfê<Y¢½ÓzÄ#‹þ0"‡IºæuAMW‰Xhƒäv¤hö'~u#r|®Û¶ƒù…Ófx­Òø*¨,­¶és:Ú.{ÞîhÿRí ýŸ±VÞ¸j ÈÜnyt2w{8~«B© &ëmõKAH‡£]û1ŸÚÓˆ1jaå?mÝpí‹åÍ/ ñ©ˆ>-—Ú.é*gȺNÓJL„€62ýõVBüÅ(Fƒ�h²#|‹îÍj¦Eô}rÖm]Oë’d:ð&“âz\÷/í¨Ì×Mä0yàQhM”›r¯æå(½yž¡/a6oD’‹y|ŠqL­ Dæ펊Æ~¶ˆáíjzœUÜ£¯G•(Ž˜_ÉttzþtÂï¹­ñkAÛ 3Ó\êÙf¦ÿלÐÿä0*óâ´ÙêàeñTx±–¸ñ ÌjÛAjýÖh÷ØòxKŸk½ŒÕŠñ+°¯w¾J䋽ˆR0ˆ/p 6OZž3ÞäÏáòë\ØŽƒâÈh–1$µô$ˆ%ŠÖ=rtÝ;”ÇÐ÷ú65ò2”԰Ȧ žÊà!šntš ¬ë Áêî%ùõÌÙýöàjÜ°rg&33§ ‘ÍI£*#_ÊG3 äñƒ¢ªÇ{y¿¿Ãr•:‘›!Q÷Sé÷·ƒ’²¥v?{7T‘YÏe×ÔjZÌ…ªò§uiç¾ëù›³Z»ñ‡Û³Ýû¶;⋘‘VVŸ[?q”³¦—�Œ@“'kZ䨸Ž^Àчª+‡Ü=GÓ—;CªTÿT¾YâÖt» ¦G×¼ œÔÅ»óÔã’³j#t{£iíÁá÷ô¨ô›¼-×ë&ȱönÆ”ÝË z.BG´¡s ™Œªw²Þì«t¢n Òl?W=P† ÄVêé aÂ=Mg² VéfxÐ6!Ðÿšß8ÁœB·­Ó<YZõ"ÿÛ ÝBÓ…üê<žw”ß=@‚œ=}A´w­!ɳ—Áˆ–þÛ œÞ††¿¦‹Þ†p™ºWœ0–ôx/ZuYƒ�QŸ€t’†�_Óá©­¯Ïwî†Uø6Õxœ+¶ŽÑ‘·1šW–‘òó"F©Ô’]ɽ%éãÅ;뻌ýå_§a#“cKp²Ýáν˪{´h½©›é¤cu«`bÝÊšs&ÅŸ¸i®¯€§Iaâ«‘§§œ1±� ÌYSŽ ³¶_Üœ`Ìñ±v{aw_êüt%¿¤-BIÀV'˜0ms²)FóóGú Q…™ßs°]Ø­ÃØå@~’>§ÜùHÓ{!êB=™?õíÅuÏŠe·3†í?³¯°^÷{+šf¡okÓ\ÿ,§Î€ÅÔdÆÈcsJ‹ G'à “Jå²jyßm:àâáˆBÉ;´É(Î|é!ìG–"‰Omç0'D&ÙEìõeßNê°3K9ñ(Nå}ïÕ®)‚•oùKá >Ô_“weŸJäFXcŽÒÊáÓ󂱩â^í+ó’Ò³ïRX€´JK´®M<oGKG¾ñ}Ú@]32à¹ÕÁÂôÀjJ('r}Ƀ‰áŠçÈ0ù’lGéýÓwÿˆ¿àÍ/îØXœtZèxj{úß[ïHu²Üw¿âY?Yè›kŠ·†AÎÉIPŠØ¢¾t˜ðß¹(ØnAFEdŸß~Ê?Ž´ŽÎ¼… Oôu=ϬÑiˆ÷=v œ5kÇRÁQ>Íõ¼ƒš‘Q$ØÖ('wS°tÐm³«È;XÎÂåàá•ãÚ—«�rrpæ ´b­‡§wÙ P÷ÛÆØÂ@È÷ô ?Û;‰ôT`v>’ŽU¾^-ò¤LAºé£ñg2t% …2{6ò‚éf-89Õ¶õ¿}iÿ% ìºq‡ ¹¾^Žˆ»§Ô-é=26ÿ ¼°}ðW¡ˆ( ÊSk%áÂU ÎÌf-Ÿ~L¿Ó^lNîŽnDæk‘éO$Û‹³€𬭽è¹H!ùAÙûül6_%‹ÆŒ†À6lõp…&™”À¦2yAžŽœE²*/RŽI· „¢if G!ËÇÛÍÙ>k•þ,ô5xØLI;£&½œ\ë©È4›zÀɬéZš[­Æî÷f2¶³güœ Z Õº¶)�ÈIͬN… ñ¤ð|õrK+÷â]Âñ®¯‚j;[t#r.Ôx'ƒ2Öýó@ÜØÛQŒ@ò kkûaᲉ3{[+côM l u/ ›üLwÁöÄ“(S†®aC¾^y•PÂÔaæì°² ›u1ug8Ç1QWi`«8îVÀ‡ÔÓnI‹m~PeêfK÷7ô8,Äkt˜-ëaµEwÃKÿ`Ó*gõ”#ëÕ :tmñò²›l…àQfÔSTâ‰ær°Gˤ„ ˜4ÛÄ“ê 1WRª 0tþ_wŠäGÛ3öiI Ä<ôIPô2ËJ¶«8‹ï ûV©¦Kg”5Þè¬y¶bâ7³ª! ªzCâA88M´·x‘rô%µ¢}¸‡r~<j¨švûÚîŸþpúÏG±LLóxèÆ®FøÙXÒÒïdbA¶åä±ãæFÆ­ ²£vÒ¨è x¢ì%;oTÃ~m)e~3Ñc>©ò>)œ/&ûpWVŒè¾NÍ;]»ÜéŒË›á˜Pl•½•:û˜aJ¬BWÈ@XKÊ^|ûÍ­‹ÎqI‰lö�vG3PH=ÌÛÇ‘úÅ©šy>¶ƒ—{lå\„Û®^AÏ‚'|ïähŽ$‘pÔ)À4M6³ú³æÊË"˜Ç�Ñ)W“ó’yÊ2ðv¼ Q€¾}l gF“Çe£ñÕ©­3: Iq\ø¬Vz ý‰vìöÓ6Fñæ<Ÿð\rî:Ø~1 Ù]ª‘²×JÆKCRU¡.ᶚêù7’`e²@Ñe‘³•–ôïQ ¢¿¸ânºE¼!•¤ázË{äß“Þ p^^¢C»:é0üéï?¸ìÊ€¨ŸÀ¢è<ù~΀­€? Ðrù÷LÌ$ ý&(mì¶Æ�CëK¨¥ï»‹¾'=94}ù߇Ÿ4)ŠÌó÷ˆ ¦LggµÉbp¦iË©~Œ•¯´oŠ[ZS¦Ê»lOePY™CEèü_¸Â¥‰-s³A›‘þJ;z:RÌbµ IÞ£pajG9Á0€¯gµ„*Gù ‡úK ¸lnÀÿÞ³£IR3*,–SO ;;«·oÆô¹8ÒŠ'·ª›+]+^G$º4¨‹I EMQî]ß“+S¿«í$(gë¨+º–ãx<(oz•Ý~C~Û2I”0=¥išó«^óÂqÆè'¡¤7_Ûs¶ršÁ ^¥é²ÈÀ 5üº‡§$B9n4÷‚Lç_ÌV~s˜æžŠX (ŸUþõ­–µ)ùr@¯¥|ÿMÌ9ƒé’á÷¿Þèßc‰‘Çþ͸+qè*…ààdt~hÇ%+õȺ«zx�ÌÌ^Véá|ã’Ü㔂I§L¶èß]˜•Ëö|.ÆÏF–X^o�³Qè‹N@÷ƒ‚|ÔX=ƒû]oÒß mŽoyi± <¯îiÕœOŠ¦9\ºéš¶·9ž£é´Ó»ºùYáÛ<B“~ù秉2pGOÙ6öÍ@¾Â»WXu àÿ² ß¹ö¤ÂÒ˜ïqœuÖ¯'dÙªQÇaçËô^‚ŽË"²C#Wˆ×Ðwï5t'¬>.<€¿q²’o ³ú“åpTQËBÀ0íÁò–ÞáN¤^ÎÇËלùøé5ìp:é{¢S±¦¢w¹<ºu»é^>gžý<FÖ”6½G“NÿkoÆ2ŒuüX=Ⱦ­Q$¢‚?ß]×Tn­fóôý[�x$þ,»–?Qx`ë[4 ïþ’E¾ K!Ñc¯†ZÍÞ8BY£7!K ~m·¦‚Iœ…³K–ç„ÆF€aÐ>éU—è‚ùL·çâó'…nØÑóZB1žN<«k¯à&¦ä¼¶:ö8=,ŒñʲuÝ›Á%YÚ‚dWPvÝ*‚¡AÇK‰E¼};xuƒžÓºi°`Èn'IáZ(,é2] ¯}ö¨gJ?ƨžÇÇ|ÖþîЈ*“èH¶‰ScÈ‚‚ycŠ/²‹1ÝÓÔ¤‘–f÷ZñÌjù†¡!§mk:?Æ£w�R52øͼñD9Ûîø´q+Ì?LRn¦nãI¾†dÆöý“)‰2?ÙIšÈƒøç_'¹g%Ìwk>>GKÄW» VûÆvšÒø'‚§æ]]±^øFѱ Nh¦N‹Qjbe™üNì6c=pÀ¶1D!ÅOÅQ–^™–  麳-È‚àO,Í$B-ÛÑh'xxJ†ÎhctfmÆŒú¢£Î¢2Y‰˜²ܲW˜=(Ï|í©’Û=³@Ü[îÑüpÉß* -Í-(‹™è~×ßžòöeö˜i¿6*Œ„Ã@y°•þ¡€^«/™á(ï—ϼSú$^ Q4Î? ĵlɪ ¼ n2 쌅þØõ%¶¼b•e?CÅ ¬Õ”+“óXŸzuÙïLÅð$7õAœ›®Fº5£.ʳP]€¯©Î¼´NÕü¤¯wŒEœƒ«$׬w2©š3tÑÍÖéß{Bœ®,LúÚ±+(RTjƸ ´g{$?1¤üµ°D—ÖÀÚ8èÈIÛÖŹv¬7‡aMY¸�í­6§»òK"ö}Úi¿ ›$HkOM»vè`VŸ¢ïéÅý¨ÏÅ­zV)ÂUP´ÖR�”{±&Ý$*}Ѭ—Ê—ŽÄ3­á cQ§3j¾’¬P캙QNßPNÔX$×ì[V(ýž�;V_L‘ºsõÁ h/v~KO&w¦h|Á ±:~;¡ýn`súÃYäÙ'. T)`â¯rKáp‰·õaÁ`!tR·»ãqúXxq¿Â¹EYä,fx¬ÖYug¯ íæ0+×é¾8‰)©-uªÖ }sëéÿ«©™\ ºö±¬(ZÜüBPKâZåç²ASЩósò­ )“a …qÙ †qþƒò"ô[²q,Yp±ý.À‰ö”tŽéÔïDzã-r‡W€/ô–¬F$› þú®ßËöRè©ú²ýÚí¥mç‹n]MM_ K×RÂó-éh«‚¬·œG|æåi%y½:þÌ¿=Ø¢Äq& ˲†ƒëüé84�â}Ì—óîãDw{M4“ä^;»!¢ Äâ-™låœ,ùQ/¬Ýâ²È|Ñ'*1éEÇõÌIYì7Û�½¢â™®eé¹2²@í±£T1ë.ž¬Ò,xXÙÿÆÚ1Aû?hLîb{fIÑð¹r,šð¼Ê´ùè‹ÌqóHnË-Z+4#PuèÍ° 9^|¯ø5ì&rÝغDô&zc+Ó:H O*´åª¤GOwâ aç(­þ¿ \³ãÖAÀ ·É 92ì8Ž§Æ>¿ RYúÊ!¤,0F>U® /ë@] _È?EÎF·Â`®iõ¯oh!R:{ɰϼȦ݇>‚p¤?&¯´^󦩂ª(ض60…­ ªB\©9,ÒQJAˆó¸+'v'ã5tíP–Xƒ•ÒðFYq®]þ›n´Uü¯¸ÆD=Kè`Ü¥T4K²$õ°ÌÃ¥ñ©|ü§®€iâ{”…í¤'oO� SpÈ‘x¦é;äØbØäf½«e;>ñd·snFТÉNZ»Ž] ›[Xƪ�2Àð4äáÑop)GË7,ç˜ÒáºóV’X–™Å©bæÊ<þU¦e"+ãz†rnôýã̤©fôU)›üšÐŒÆÓ¶;A¿[™šö†‹›»¡Œð³;zSÛ‚Có†ÊkÐð6º;N5€…&€ çŠâ©>ðà¨Ó´o°k!ÐGÈ®bmPâ”AÜêCFSi¦¢7ž˜sª#¹xÜa 3Àìe;ùð(FPÒè¬xž(¸@TŠÍîð€kÿ®tP|yb[ŒÅiðZ¿ žáù¯Ò+×ÁªL©Ô$›%˜d‚Ó3ܵº>¾‹FË^Õ˜…̨˜ŽVÊÏ‹M¨úÝdMè–ÐÉrÖ™Ü5u³ä¡€�?öE9O¾Q#ÒDØñtrÿ×f{úaõ‡û"m“]´‚b³¡@{úÄ=ÄÙè Xo |ÎG”„½ºÃrŒ2ßz3†¿Q”ÿnLu —m,†î_«ÅJóž1âÞ%“W²¥¤P»¥7Ûj¯Ã>qjýeø+(­\>îþ„Ýn!ÜB¦(vÐcòÒáFÅtøŒŽšáQk¡{ï'_²4/Ey: ‡Ö“løÔ–6$ý.ú"ÄÇ*Ök€cYpø¡œp=+WN:žÃâ e"@8¡Ã+Ûß,wÏQP ØòMŸöœeLÊHIG-Y#§aÓÆ Ç^BºŒa“ÄXºãPŠt< D±·­‡?–—‚†!·ñ¶Ý?Ó¡giä;4kk_Šz9bßAôY{„d(=àYÒ¶ô«¥V`š¼xБêœë$ˆÔŸ˜ý]"Û³¬¼à㘾FÊ<IB#Y%éÌ+©-I–Š=1òÖSþå‚–miíÅ"Â:þºhSBß…*ÖˆaÐçÝÜh£Ã¾ß¹»Ìݔ͸3Ê.•/Ó0ñ7•mÍi½¥š 'µê¶0|¢Ib…§f8Á! ¶)‹â[éU±ÝUßîa30*½ã†c’8´?«dE§Ê +7c†ç9lsÞµ;±ka&«úeëɳô`õu¶âBk·±.oÊûEQá;ÈèÞ—[–s<QÂ6øÔÊ K•gÈ!–½y0'œeY„ûaÅwÁøý˜ey¤ï#…ÇaÄù`^|ÁÑØh=† mg<3êÜÝl¡º;0 þGõÁ™Q@æõJ‡5É|1EÊÙQxǃÖñ dåE{Õo–Þ¾b› Ïç ]É÷C¶Ë|êèЯ¦º[Öíq•¯¸eiæ+¡+J™xvi®¼dÈŒŸ:>)B'C{ Þ›,@ ±# …hSžÊ«h‰[Øñ˜Àbû† ÕÒ­§3¹bÆN„s3‡zÊì‡ 6ÙRÏ9ÓG}$K°?€Š1^{´lÜné¤NÁï‰!Þ¬­é“ ™.jóSUI|ÚâRé™F’çQ'Xèm›RB5yȼ¾>{®{ÛSK_Ü@8?<žDÉRº ™´ä§v 1S›Êb¡lh î/tÒRÜW°ý;üx«Ï“Ç®æN‚ %MUw3‡|<™Lã$óèQ:#Ö§ÖÖ:ï_–,Ú©ŠóŠh--ÂSCï4=d!ëàMÝq«˜õ(q¹ßôŒÜLè›´7wÇ )XQDb©Ð+mì$z[z³QT팽ŒçÞ˜g~ G+òr€ÏªZ¤ÀN«z\ôSGÉXfÑf2Ã¥ã†Ìu|ñkJÓf…–¨>»@N¥ÎÇåc¯¢¿“hñHÌÑfÞòÖ/þYæ|¼¸­á+?ÏÎM[A&©l 5œS¶|‘Uص»Á' a”ä 1‰`k½_ߣaXÑ#9ž ]W$A>X8&Ë59jÿÍ$á7£…X  ‰“ðs­Õ· á=ØÖH)¯ü•öhàíw†R¹>õwqÂŽÊ)®09L”œ}¯íLöWs—ªòص(²W$´qk:X’OŸ÷{®OÇÑO÷zî÷/uæ}uP’h×¥AÚ[˽ÈÊ¥€ãÄ<ºë×‰Ò # ïµÄDEwþ† ÓöÇ;iEqKÞR`eÉgTB¨isÀ¿5Ùƒª€‘'îÃYó«O;Ù®’ZÓÍs@™÷X‡‰gÎÀÁ¿­‹ Ÿ;«"þ˜ThIÒmÁÝ^߉¢eæ{Ê—h4ÓêÿÖ²zv‚ì@n„A=:k|Hi/pÈÛ~³×x.³…E;­ýMæÝ �/5—©æ.‰Ïoì|’Òa<¤]~þC r:i®¹Åà_@/ÌO1)\=P‚˜¦ÆÀl+%÷0§¢‹i`¿¸/ŸZ×̢̄ž] KzûóÙèça¼þ(„ÙM_STFåxÿ·ÛÐ*J]Øÿ¦ÖùpÙ3Þg²#÷¡pÔ=:4"çBPU/À2“V#o)Tv5)þo0™–Í®Ny›SÉäo“i(ÕU²c+A…?}ð=×¼�À3¹Hæ¢Òn™Œ´ÍûŽ"‡EÄhµRlæ"̪„Š!–ëØ>ë,fÚu•Vn49}ÖñÇõ·XàwVË'FLry—·®1™ïïB)Ѹ/ƒÄª×£WÏð]Ó±ü%{ÄéBÇfÜÕÎUZ‚ê—ëG¡é? ßìn§²RúXÏÊ]’þìyl¬)ÇbúÂô×pª$q…ý› B'µf/µÃxT½áéÐr{q} g±GÕÅ�ÒlJëü”ç4fú2¸Ðmm¥ñrWÂ# <³ÙÒ†œ• D‘­[jÇ8'š‘N, M=É·¿@™Ó_¦Jƃé¯æŒŽh%/ð<€7>½>°•…îaŠIŠ´bÅ{¯¹ƾU*"k±¢‰tɲWe&d'œ ¼Þ ’NKøû«sL'Å8¬“h`‰ÔŠÎÿ¯ˆMpP]m­wg”eæÍ<éèá†o~¶'4k­ë™R`Ænx«å›„™ïÅCë…¶YQ¯³E}ì~ÔhqÜñ ów?Œ).ØÆ´¤tÃZÖDYm)!-ÀÏ�/œ“Ð3sX _È€!e‰)S#7ì@&Tµ²·=R2S škJ¢ëÙ„Æ„Å$&i™^©œ>+úª—×CëÒ3Žb³Ãá‡t{7®eÌ0OûÎ3}~m§]¿æØ4AÀo]šY38#ûv:¨Ã8#¢TZÅ»Â|Ú¤~§Äõ¼2£˜­MÖŽËN¡ þ:)òößÓ­X&™ŸtPøÅ1Ôh]Wf\°˜#Î ÕÞ»ºÃÌ-]ÂtÔy±ãµ„b6k…°ëv_3$â!KÂÖW¥kYÚ±Ùú~CÐôž;Ž”N غ 1…>ðj¿q5Š½&# U³ñqáD/•¥ì1<~ÝuýW±;E·‘êÜä[!ø ®B+S(v,ï‡sURG ªq‹ôU‰îi‘9ä"&rP¹èâ… ?œ ¨Ê&¼EÔÏ2ŸÏÆûî©~»…ý";?®6âã …ž…8«0t´Ö1ÒÒ_lñŸÀ÷wHÿÒ÷i{$:•÷EP6ÖæÀ´8UžN4Ežq!–%"7 iOô•Óvcɉ&ͤRQ8k~RO‘êΊ<6ó·"ÒQ£¤ŒšðX¦²ßxË4qÐFáMgtÞ,”"O3Vg úFOuJÈS½éL·b® ‡¶n0Áÿ•Æc¦Â�†#Q¾Cw¡W¤ûK­Â7Ó˜¼ôÇNº?k×6SEM2<³†ÇÆ •‡Ðã¤uwL‚²s"ˆya¿ûPªÛwŠba15>iJ `Z@¢$+šXÿ¢WäÙ LÔø´]¼.þ´Û§ƒB¥}›¶7-Ûâ0÷o6U|Û#{:õJ sjßQ£~­K%™ q¬ˆ>cy—ÝÆŠúÕcÇÐ Zè=½‰C•l»ãÑt¼Ëcgà-`:KÀ¶ Oz*ZÁ'åt”ÜiÓ˜ Í/J8®óUÁSx˜911ÿ¢ã¼êŸ;bÔú,†Çêó¿Wǹó³å&öÐADÉÎlR>x íE•·¥\äíß]ëҴʼzˆÎµqC)ÏrU¥Ì]éþKÕ/ºì¸nÂõ£§›“eŠÂ1cÒìícLšø—JÎõc(*bß›Mù’<H?g«º=œ¹ã£bò|$í½Ê]IúV*㜦 èàÔ¬—ƒ.ÁÿA;Ø2S£ÌBÚŠ =ÕžÛÑtBç×›Lqþ5K‹â!ž-Ë$î:• ±v&¸ãªÀ¸™kfã«Ÿµ*Lð lÚEõ‰pñ-Ù†u.ë‘b”f÷T†ªgÙ¯øùÅ‚ÞN‹hÛfAùÝzþgl«þp¹Yýéí9[úb¹d}©<ÿÕØVò!oò3Æ‘‘ML¼yb™œ¥ÞÕ±¨îHÙçNV,Ê/ÑÛ äH|Û}UbÜÎfm?PM¢öTÑäç…½‰Ü«y2Äê±j-÷DßL][œD~“‘Õ¼)7|ñõã¸Ú¢ßIT}å%’¸5+Lóa@݉$…‚°ã Hêh,”èúÊç†Op‡`f™Gs…ÏHKÛ<Í€Fï‘ IÃä}hwqÓ‹¢=…Msé#秣#ã­êŽ–Ï9p½ïýû{ö1×=¦ ·¿ñµ¼%û4RƒÑR³±Å|ÑóN¤þº·§®ÇÍÕ† ŒZ>43P#¡`˜çFÏÖ<~¦®¾‚Kwø³ëŸ ¢\¡¹Ê ym7nÖ=Qr¡¹kEEÖ»¸–ÙBdk+ *«Ü)@e|:‹£÷Í£k•GBÎ0Ô7 =øº±F>¿ßJUóŽ2–öÕ–âõ+˘^¹ÔÑr ŠuoúŸCw¤ LǸ:ÛN貕NEÕ‘.AÌld9P�; ·võJhî“LèÔŽôçÊúÇÄŽ\È6˜ÛÂãQoÅõX¬y€4ÃÊxÉŠÕN‹`ýw†²V J uÙD Û!$¦çÙñœçzHO™ÝoäÙ£ÔÓûâ‡Ñ´ôOþ¹õ<8“D« Õ«/´ò8û{tÖX˜ee@ÜT¨«öì #»+É ïK;Ü2½ÃÿC™vÓ-/<Iª‰§'-Ú¡¹0Qº~°mæ·àk×à2´úŸìÁƒ&edkUWAo§ÝŸw˹™"Ò?9Ãd óŠ�gz·,×.[ËÙðŸ wóÜ%œ¾JZqƒž¬…×÷ˆ¼Û ÷Ò¹¸ˆ-IPPy{Eô‚a%"FV‰;p|ØÊaæ¹Õ{BÏ>Rì[ZÙxaµ OÐ?FöM_ï–1.ˆG,7íiGÖvBÁ’çÓM~•ÏÁ€­õŸ½xn X–‹Ê©¶?€oŸ  4;HÄÔ–Z¡²Gð‰¥Œû«W['úŸ8òD’cŽ-0´È[Â;­ç‘¸Ã]½ß+±S†XǾ¢ï£;.d´j$½ö[úöÃ_ °—vÊñ¶ÿJ‚òhñ•)·ôÛE§òN<|µ`mšPôy¤”$í;O%kéGÊž»k‡…+‹2ôW)ѧy™|kiú�6ÍùéMÛƒu7§_ÐmÁ@Ê Iy•mnúS·:ÔóôÁdgå^_Zb”Ezlµ‡ùw´ŽEýÀnÐøÖµ &F˜‘õ|^ï ·p:Ö"`dµ€+ÆÂ�›ÞB®ñÎ}}a^“Ѳa�^þÿ…4@”ª§zdôÞ -• ª>lãL¹Çx˜¦_(4EáNOK‡J•2HÚ‹›<¶'@¥ù^okF¾v?8T_U-QV,æ$U°AdRvÔîÏå5Q༗¥¼èZ.TôuK'ÇÒ-Ͻr¡—í¥ ¢ŸÁƒ¶¬X–}“ÎxüëG†q±3[”Ñh“BÈ÷Û“<ëÎ=ú|£º'éñÛË¢¥ý’Ýôí5èê¶ë™6ð¥n˜L ô…¶OU‰Í‘ÉÈ�ŠF‰A#Œr¤waö°éÅ=CD¥kfñG¦RŽŽK‹S^‰3½å_l#*èëÛ«{ qßË‹Ýfˆ„æÇÖÃ4P4ÁeBÛV´v“m0üBr+®Rß!ÚßEßzéŸ`ÝÖ‰‘)Š“{H7¹}ÝŽÞ>òŸbbêØ(¾v×\¾ÇŒVë&\™„o>³R˜Î9)Wy]!Ï+@5®<g LxÞ» =E2vÙm05ÔÄ>õR¢[:¢Aô˜—'tÄ8^Ê> ¼Š8«3¸õÝà`¦j*W[¥axÅa¡{TÛgÛEóË#ݼ~Žò �€"hѽȜÊ\¼h¤O¼^P Òg–HxNhpÛ#½cú=xøKÃHÚcD:¢cJo1RÈÿ…¤7„ca„Õ,cíR$˜GЩ)å@/5y²Òu€+<Œ”}¦v´ß ]âæŒ7:ñ%ozþ£¬Î•Ú'6jGž[ƒ0·âQòafŽ¦­/î]^Q < cdE6¡¹Û û ÒZéµ]é˜=Ô3K]C˜;-p(Œ7"¶ Sæ´±ðšw ‘`-`ýôQ·›8(­‘£P3Á…‹käß»º‡5wÄ$›Ýõ<ˆ;‹GmSkRu�üh,ìh¥,˜‹Ú¶+y«PS±r/A <c"ŸÏtåž‘,Z…såîÇ”çlÍ)Шñ²Ö‹a˜žùDd]ó÷±mZ+Ñçð¼œ= c>©vkk>_„:Pâ(úÀÖϪŽ”F wÛÆA<úôÌ€"äá»p û ^ÀزӷçˆNqÌŽV¶,ÙÎi ‡™¸¯=åéÉ„L1Ûmp,}¶žæ«ˆ?ÛŒÕ�ß•ËVMh–%स©‚ª×j2¸´jö”(} ‚«+×·‰F‡(Ù:»UQòA%QÜÔ®uCç­½£½í,ÌÈ ØýK?ÑÓw.iu£ ½«m}ìl©|îöW’ŠL^ªzz9Ž)í–6§íÜ®©x'mKoë‰×Û{ljQ–—a÷†çŠkÖ  œ)Œm§ñ ñï‰XlK* èhפönBÐE÷;‘$ßñJ˜lÇCI!Ñ÷ŒÞ™ö€6SÏ”CØdZ–"¤K‹•óBC:õpÈÈéŒqEk©�ôt½2{´n}£/á lÅ/¤²Ì^pCױśÎ_„R`2™¾:1K½P) Û:2LÇ2HקwF,,Ú-…ú¾ž»Š#F¸¸wrTI—{Sd¿ªâÍér¡\¦Õ9W¦‰ÎY%X3r~]ÍÌsô®SåbÝÉÍ)Êï£×HÐ{ ˜„#Fëbœ'<0Ä8wuž.1ÃF XG1«Éùhìë¹?X¸Ìc§¨Ä;Kîã©'´ƒ³‘ÅkmEKAÌÝ÷/¯‘Ç#ÎÌ4�}b‰µk¹·Nd˜ûQ‚iíMî[œÉÕóñ5ÿþ±£JÌ*wc[÷j)Š™Ð²½[îä¾Nk[T”†hÈaÀÔ¡yôŸK+‡³HsÑÁ¤—íÍfô7VA‰ZþYÏŽóTá¨&ëÆv)I¥Õýƒ*ßêĘŽp|µ~ö4šêp߇wèÎ÷qÿIèK–°î8Üa~.^œ[A¨u7hN9œ\Ü\H‡·k%8]wÀ´·lEsÛ>sÄ~r‘¡KsìdX»Ïwûý"€ˆ–ô­3õíï ÈÁ•Î´vŠâßÆ'<,óx±qYbØÐd—?>)Cµm(Ì‘‡|©µPFÍÍ"ÍáÞ˜ññb#Á©¡¤sÖ4¨Ê{’Y9Ñ dÜäß'”±,qzF<‹>);š-&›~g=Âë Š=”‚îë/µñ ºñÛ®G]p¥ï¶4ƒL‚Üò ²Xfb±ŠéW?#—‡RÀ¡/_ á¸3-ÚZµÿRŽ”®ÞŸøÊÎÌûh AÛU7)4õǯMMªeãu–é~žÕV€éKhIá½™ÄæÃl37‹¤Â…5Oüx[Å…©·éi_}_<Í0)O®¾é'Ckº{y•±(¹œŠæ¦ŠƒªöÐBŒúQãK~¯ð‚<¥EôcíAC)圹Â#”'²èwsÚ+ _Z|ÈËíd5C ±UÑ{ñòUzXyPYæ[ø©UvÏ¥;°Fí±kQœ¼öûÞtm/ÍËë^Nœd>ušUË)Øgt™.”%èÓšÁô‹z0ί(œÈ0âúìØ{uÓ€áÂëñNzq•fDѢ̼t­®¶ÓòN¼Ieß LbÏ–ÁV_3eÙÔx‡ž)y :Ý>öâùð1+Ã¥e®(Jè¼3ªj!4ŠF¯–š¿ñF‹]ÓÉʧ&¥:ÖZƒq_pù¼¼‹ÂŸ5C$Š¨³:Šì#É=E¾c‹›Çfdšo‡fHiSÖƒÒÿ¯‘ôÃ×øŸÔêîðÛ9Óž@•ßþi.ÿ�CrGèÍíÐؘS°ðŽa 2‘ö_ýÓìà=*Úšq*QT…ž™!=ϺOM§\SŒŽÜnÜuVZ Õ™¬ è ¿2‹±ž¹i5-Åo-Wñ=€ƒÂz“wh%ðn/–Z-©‡“9f¦Ý¿Ž¸ÂöæNOî—v™š@fÙ«?I„íäÐT6+ºý¶©.ê =Ç´±¥c ЉXâ-Ó¿8õL™*¶÷B@.$•ÒÒöÇÄY´:ÛuØî•[ĺaæ¬Ãö¬,ld¨Ž{ ·gãBŸ œd™zj„#‡¥3Þ³HŽ_Ч@G/Üj+™nœ5\ÕÆ ‚ÑÄ÷®nª¬2Ê–mV´¶j q*­™‹§ïýߎo2–MŸå´Ô,mu¨W[>Ø õ­²æƒ¢ÌDûð•Ýð~JQn~Aát›æ6Ï0ŽßÒ)˜å¼OR ”èmy}5P¶¯WQ¦(}+_Èí‚4X"Yü>uÖ¼i:µ¦™'¯ ôb7 ¹ˆ,2½Ci—CYùVåõ°#i‘žÆΠP75hätÔ«<ð-¦Ç‘Z8_aÙK€6žpo²-n¨Uþ~[f´(⥿վ˂ò§vÐS�”!DÏ ¥¸ÎÜÏ3¯7k/aðbTçVA2{Phµ7'E >àcî•/³.0à jOþvŒV¸M'¬o�×ÖE“¢-Û¤ºâúq°åͶòýõoLÐðùy÷Qú^ñtÔ´´ý‚ÚØ1==vG’Ù´Xkúʃ¸ï½ó»væ•Íh@ ï£ΦX)Қςä{ö¼t8òy¬UÏvЈß8L¯~¼õôösôA—ŠÙÓÓe‹.ËJ@E¦sݧ²«ÜîÊR§±,Vr-ÆöCí}ö}}1ÚµìŒ<ØÚh.ëÅ-¬2Îü:) zªÓ“©óæ´-­”/3P€›.êÜ´ZÐéÓv?1eÁÝÚm»“ÿÓhCz<¡3|è¥ËRxKÅÓ,ñDX7§*(O[3sÂaÙ`„‹ÃÑ0Æ)³Ã&Õ×ÛcRúbPÅÿÄAüÙ¹éÁz4˜#‘J} ŠSOd„CጦNܵ¾z¢A~»ayÓý ½ÕÅu׮ê¦%&57Z}cHòŒìxX‹áG¿RXˆ Äž ž@² eŠ·[’÷ Âÿ÷&©Ã7ƒ\}Ÿ”A|úö\–¶ëAÁšEdÙ›3¨ã­}¥Uë‰IÖIIgØ«Ùu™4c\ÉDÃ~K¾öÝ&7š‰]Zö9¹Xòoçû*­(çêò^6ö8™±8 .a¬y¯2KÆW„¥´¬óÄû¾ŸÖZ>RÙ”·iÝy2’«°¤¯ûç¥Ù~¹‘ÀïñI£éÇÓ&æ\tÒÑVœŸÓÑr/*‹Sì¦ãïÆÍ·§#¦&ӯͦM[[»)ôqÚÎmã™%Ú2ˆ§÷´­‹ÌïÄ sSœK‡O£¡«3Aa¨3áhñº�vFÉÕHåØÁ{o¶2Â&ÝÓ…·@6þ= 2òæí9àæ�âØ$3áU7˜éž˜ ÙŸßê—*,Z×9{N Ý¿¦Ý”ÖÅbRSÐíŒ<™®Ž®kyëë\ùþoÉhq¦X¹´º*(.‡:ÒÉìVŽcÔ™ÌG>Ç;u‰/‰—²4i qB-|RÌ—XÿK3IÊ5”€“N lVËp_Ûãæ¥!ƒ€»U'ü|{jü€"¡æ ô^,2¿ØChÞÞ¢K³ÄÃ00#x{¤ Þ)G;æg´ëYòË×V`¹j©OaÙ½:Œ§ý-VG}ÆBF1À.Jöɦ×všÉûÃTëÛš¤÷cN46¶]' œhñuNÞãêæ÷<ø¶NV± i°Ûµ‰ÌFó²|ýë­•¼³ÊË+­öf ôAÙ|ì†^3ÌtR ƒÌ]Üç‰Ï¬Cò …ÏÂv!é>q­Zíà¥Àçõg®ãaãÉ5 M]´“ƹ|yéE®ŽÜ7˜ÑDµj™vK¨:f8:ýç§ñp4Yäš× È[Û¥à>/mW¬bÁ‰P }\°Q^ ï$ ,Zœ0 (­¬Ÿ¸¬¼PËÌ4m“g{`pòħÁž%{?¾:Ø°XvÆÂÈäî/#À@}˜oã†ûÅz‡ã±7º`\¢œMž¯ô¯Õ”eî]i¯þæáÿT•o‡FÁ¶-ƒÐ‹¬Èoq,¾cpÒ›P¨*]L•‘Æò³Ó �h,iËÑ–¹W½…Ÿƒö!b’À†Aªý¬=8Ù7GÏ™J§¹ýZ¥Å2~ #‹CÁ„jŒZÁ?qa&^&”ì;~øûÙnôåþw,Íü@ I%hÂC ÁZàpE+‘·SHص«Óñ¡"eìC2&ÿIPxm=³m)/`ÁÖx¼áÓr3Ο ~÷MäH@ø§÷Âzw�˜«_Ú3Bbãs­Êȯ++Fq 1;[8Çþ¥µS;X̵m†¾Ò*õ¸}7NZ!ý\wLú53¸­¦—ÕeægUôi=½ú©C1(Ô˜F›±£/}a>ÚóA7Á¿,©è9O[µËÀÀ¡>³F{DÒÒ2ór2“eÄŽ~Ê=g² ·Ì*²Ic*cÏ íµWš517yy‚‚$ Kž€¢©?¾jL&ö”©¥ž+DÂ=á!¡äëÓ¡›8zÐ ³0à®»=¯|!‹e|¹n=×r*�ŠÕ¥(FëVx›¥q¼øtlþ½ˆ7Â*ûUÆœ³£'0¨‰Ýôua� •,ÿÖÍiÇ‚_ÿù(ýʦd?¾n\íCø¦ik%Nü5°Ú®È(Œ(”)OkŠÐÛÒý…W.ëó£ƒå8Þ / 3Œ7Ðïï,¬:ºif ‘’Ù»®ØÚ‰é×~éÌî|®s1\n.Þj–3Nq"‚1aÓ«gEëQ¡òÛœ2T—ª¶TÅ‚)Ÿ¹í⃈&ì²ÜóµÜöäß–ˆd¿ÜSâõëBÌ×Í_ãå,â3p=[(Q@ƒõ0Žô€ß5ÊÃp-ÚRVª©ÀbNž½Y-M”-iH µ%4ÝG3v‡ÉÃ.( ÎÇ^£lé|™Ì¿>¦"7…Ó©Uîl%”L+ ùÿ|Jtpÿ‰|ø·4§m Xr:•iU~ξÀ®§,шOI4 ÊÚœ÷~zâë§!Oàm–­UKŒ¹p˜g«Þîà¬hûÝŠ)Eaä<ˆþT‡Ö�]ØN ¤GΧ�7Eûy† ÚäFü„É7J‹=Úö3÷ÿ¿ÿGßû2 æ{ˆì‡p?”{£×Êx,§¬ê–XÓ†¼F“NŒ§éK v0‘v¦‚`»K÷a:õwǘŠéç dÎÄÙYý<‘J÷½ZP�qõ“|*^"åPS€¨,©LT³Cû‚9yh.Î ‡ót‹�.M#–2sZîµôªÛþ :w7õx®æ~¥çöœ0b©‡Û`´%P"ŸÐ½¡8˜5ó¾£GT¨ö”ù¢ý“¬Gõù8©ŸÜ=¥ÿ%§ÿFšö¿“ry«©8¬éqyFÀ&ŸÒp‰õ÷©¾¸‹EŠv·Ùa¶æ.ÙeÀbI±¥è¸àßný»˜_Ú™MÌ„Z¾ÜNçœ6¢<<26 72¯<~6=\ÁÌbSùü‹Á0qWHJ.çøyìrF‰÷'ŠºŸgŸ+Þ/0 šÐä@ró/“…Kûäè›GÛÖ­_ªc÷ÜÎâ{cÛ$æ$z¾éT-MØŽt{÷ð0ÙŒžƒ3ÝÝ©mµ²º‹*z0²Z“‘¤ùONë{¡ y8|1¨ðônµ@:ŸqQÛ—”¼x4?”çŠ]¤“©ëváCsùD¹ô¦ÙB!uR.HÃ@BŽ¼”÷펶ÎwË@PWÀ6 úŸæÇÛ¿æ»]¨¬O$æ>xfÕ‰N÷äÔ0²CߌŠ´·q37¬£o—tÿÚn6ósº?»ƒm̽çheìÍOGm‚œzãÉ^¦½qTëmG÷ôï¿èA½ß¤‡$ñeg S>tˬ­öÿç4›“µÊ\m¡0+¸æ‡°Ø$·¢p8”²`‚)ÂϤ­qh~ÀÖU8¬ÝN%GO™ó›Í÷4õ•GÁ°anšÍèÙ=缃î„ïý†'*ÈË°r0ôp«ÏµÇ…Yz›S n‰¢w/ir•-ÜB09 ø–mU†Ë|”-YÏ«­,ßß "Á­;7ž cªMÐf®òØ.¤&žµ3ëÓ1èú½6²,®2ô¡È`dN-¡O=m¨;½?¸Í§xÚW$8iTS‹²]æØ£âzòHôì&ñ·6Õ>ȧW˜â·!õ¨FO¯ö»"tN³¢FxìcÐÕqzø‚"p5$-ôvŠ u½Ÿ0`é1 4¡ k2›”=Ô_š„¾°æÅõÏ÷ÛŒeîžClhySVºýô©@Hx]nEÝÝ$·÷Á²ËXá¥wÁ½‰æÉÛ3¦³¬Óí¹Ï±¡ƒÏ Ø£,¹ÿ‚hèz2MnÊY\¢ö±{Cª_6±Ÿý„Ê FKݧ¿Ò`°ÜY†¸CR§pÍ x¢À¹Q&²®toªŸO¥qkñ8!ÞÚâf»›ÙÉÞ³Ò)¢ÏžÊm7’W ÆÌ 0Ú9ãî‡õ;‹»äª0«ÿÑkµg‹Y·XíqŸywòj´sMë˜áÌ#V…n}}Ó­$[ŠçÃÝ:ao4ÃüDQcç|¿âC…å¥ZQT)‚Êâî±H1h<ì;«>Ìo#4Âæ™c Ë”ÝD—*ôMWéöXÔé&D’š;³6¦¨ïLcc¯ÓÄ3Ž`ŸFAù=šbUäEäeØs÷ÓΕ¶Éú Ð5\ªÇÁt¤Xûù㉸ÒY´ãcEÖO¹ÀÅ #6K±¿O¶¯r;ÄJP—Õ¼q½MÜ—ƒPyp븲b¦äªƒ2I㉖¶Âª°–²/ –Yép.â&9 a¦RÖ z¢ŒÿùˆÍÈÎ›Õ ê~#é5‚'._7ƒ§MT² ¸ Bß–ZTárÍnŸ¾³@ëÝ5\}ùàUr¸p•b”Qý¯wF6€3©Së; 2Û݉¸¹–[°U¿{'°` ZŒo?c;ÞéQþLÞÉ‹2f÷U]>=ÏŠóØ™µjãÎ/=”ÔÚZ?àmfÀû}¢O4±ì_°9 bOô÷‹—Ï%§:H_SE×zúÖi~[I\Z¥Ý‘U¹”ôà ¨î@ªë,Î3Ž£…þS ä$Èœ2jˆj‡dœ µ>ö7]‘#µ‘ª G+ý‰°U]4éQãdÃ>É(Æ^ù ¿`J3ótㆶZ' ˜[œ›jeÆöËÁñ0Ì*[:¢¶ô Ûúcu�/¡pyïWXl‰•e•ÖîÐ%@(Ÿ<Žô Ìò“ WM¶÷°šy”nfÌõxòGµ¡d™¯Ód¯xŸ¼!‘žE®S‘Š^vd­&ê»Æ^,qêkpÛéŸîmÁì¨HíýÝ#ö”Vñ•GÑ/<íˆMXÑ;š†¾Eõ©CÃBgš‡4äZ‰ÿq2âõHå_…Ë#Oî½àÁÊ@çÃÖ ß3•Êf{ 8™@]}«Se±Ëbsáá–Œ�1@_T×bKcjûé«cN§{é}Þ%¥ Y°Ÿ£T›Ü  #aìCÁãø¿éoÉbW&JzJk¬1ÖŽs |!ʼn;îØVãr SÈ¥Œ;ßS³à'a,ÛÂ*,ÎçbE*å*üŠª}O»+²X'w¶C7isï v,w8‡”OBøô/Î\[‹J-­vì~]©Î[ú3w¾I,­¨­ä¬tºm1EèN‰t©$­ÚŒGV)ÿ>®¥…ÇÎåœhƒnëP;q¾ f°\Wy³|ûKïʹo”ˆ"G�;ü$A1¯fp £(1ÛÜØ %"°X—/S”9jˆjOç.¼»mGw®Çz°ÇŸI%(¥Â`Ý’[ºöÌ~‰\bE¥Â8èé>À Áre¿ê±V‡a<! Da’-A§ ºÆc¤;&gr©kAHʯ…2£ÊA–KA³£(²ï/X˜¾_1(êÜi“Á]ÝéãÅ‚iOGýjL8ÁP,&ùªhŒ!7ü.s¯%ábÆ*¿j¥E¶TÄn£5èÈaqÙû\ü3)xƒÜW‘ÓÿƤÒ�—kß‘þÈ\M¦ ›ûj9/c‡:Ê¥¢d¾µ¨£ˆõ[kQó]áÌ­XEwÜæA9m½O»áMîÅÏ/óòœêœøÒ@,ª2uT'DŸG_ò ÿm›º¿Ö4´Žb׎Øk²O¿e€¯ŒŽ3g;Ë—Û¡ŸˆgûÐmV ©oÃ2/Êÿ®®LÔ84,ø©kídÅù`OJ;yZõå}yÇ%r»3Õj §ì(0Ñ/Â+|¯£í†Ð¢¨¼†»‚œÂÕÚwªÃÆ­´ëÝÈd mDM£ ¦=¤XU·„>PÓw­ÊT á¯õ*Ly¸I¯l Œt-×Æ^ õ±"¦1ƒ4º…‘gÅ „"áj‹õ¹¯gŒ|F ¨ ÀºmºÕ—‡”̼™ 3I§~iv“²þE ,!ÑÌ·jø·N?!”\6*•ƒ³¡l­Y›ÁEÄp®Ù–q2²ú·§ù …Üó_±oŽÉ ™zHΞþZl¹øIâs:ø&1»ÖUø7D”0_pC “fõ>Kk×ƇýEC-]èüì} í•Z=íÑwPš�}…+g-†0ø»Ë»˜Â,)ÞÜK<¼�¹eU³çhO#íy#g–ˆœ9_ÌÀ²o+°¾Æ �VŸ¶|Y7ûzkÇ׫ßýWÊà[§µ¦unk÷õiü÷·Ýë¤Zt¸’0è &’üüëšj«S¿×ªKö´^ãWpŠìûƒ<´†–VX6rˆ¤¦ý—*kå7�Ž|¤ê•³q ôsæ«f?³½Žsψ™Ïïá Ôª5†£ƒB=’}ÀºS>¾ÿ‰ \bÝj—gtš$Ü£‹J7=ë–‘öî¢õ 9ý)‹¬~úzÓu™€Ò3é*bŽ–\aŒ(Xél»üÛ˧#ïÕ–U²¡f"~Q¬úÞ²±Bœ†ÝüÑbPéP“ªÃ$–[YÆ�ÃkàË\ýyÂ<×Çz¢|®ÚÚ-“É<êÆÜ)‚4ÀKüa”¥ —FdvbŒ'Å-"‡Øð>ï;ÆI‘]iù4-…‘|RÂ1Æöho(J¨Þõ ¬ÞîŽ*ð�$WÔÊÃDLÇט¥G*“ùèí®¥j\_$ ð«+uWÛý‹Mß´£ì¥QP´¨ñPÛ´®—1û,ÖÊTf&O 4C ¹l5)æ½ã€[iÏg¢QfÄz)äÑ£<Nc©(Q ŽŠ…$jX¤˜žô¯P Qé%PÒ”‡ÝEUÿø"üÂ’0ëûÕì±ÛÞFU¸ÆS$ÊyÓûäክ ÔråGc)ó²%žX?ÉÐLŽ7=NäY„a"-r œCýµ=Qé<,HjDÛñpº'¸‘d¾<º‚’k«sžàq·Ù¸ö­*#ÿ†äkÄßÁPüïþ™Ï´‘ïÔ§±Ó·Íd‡vC²n½  +®ýÎâ¹r)ŸH—¬/ð¯<Ãá/|lë@‚|G8w`pXŠáŽ×D‹þg© ÒÇ)­Uä¸ÊØîqÇ+ÔÔ¾5Ÿ¿´ñ¸E§’òÑÇ]Ó\·Ëtá®Uç± Êñè J{–BÓðÜŽ‡(×¹«'äà4óôÀCmè¹nO &‰ÙéQиF7‰F|ª¹e¶½ -_,û‹å‚ÏM©û€‰pÚøöšõø‹Û¸ƒ5à\/Xwƒta®¹0ÔJKә欅›—Õ°1Q¢k§ŽîŒÜù«.åß6-gÇmñ ¡»¤ÈJø‚1 ùñAðÖ¢Ì|×èN¯iåW³Jsì9M²-¨¬êáÐ×tÐ\h¹3)7jhï\�ú¤Ã4FÓ†qP÷ô¼?7Úm/CU5¥JÅÓÿX(_½!‚%©¯Rrª<¹ZµRm<i"Öä´èY*)¼ú<CT+ÜÔ´±Ë­Â%ŒŒ¼2ÐyÒÐ6ï¦Niÿ ÏÚüº+?›>ðDý5­ëâóÓåí¡Ï|òà›\d3vÕ¿|<‰KgÀʆ´( v*—:öÜÙ¿ñäÉ{K *R§>ËjÇ‘Þ$—ù±ÙÄê‹Õ3ëõn%æñWúºŒ†aæ;êRN0¢d?/>ž\ íB Fuj[_ÄiW4QN´ö•yBú"……IÇγ¦e N ò�MÑ£ë_ÛFfad•ü±xÊ`u¦\r¼è°Å=ÛB<´_(†þÎ}.O®l Ž=©–eD·îkè:À8M;Åš‚ýÎ?,Wm{ö eÕ@õöÛÑÎeðå†.&Dº+©·UnÓƒÿ{Ér…Fõá§ÕLI˜‰G ê¾ÎrüÞÓÛZO˜ÕpAÓ#²£fŒ8•Á]<›^ºˆx±ÚDÍD£˜•Pé>v¾ZÅx˜Aœ4‡ê¼ë'ö÷nOâÝð8gò• °�È“ÚšÁ¶2=ñÿ|ät|Ð:ã&n¥,Sô®Ðh®ÃCJ¤dú~t|C«BôÛÍÍþEÛ'±Y(aÐ$EPl,ð”Pn³}˜$üÁ!÷PçÕ­&î°íR„OU†e;­Š \¡üç&Ã/ú§~™,¨Þ¶@±)N½o­…X¸×~wSÒ߈>'¡Æö\¨LÑ~nó µ8lÕVèÂSŽâ/ØÇð°$sÄ ~Îý) ª%8¤¬TÝv²!ï2â'²XRÞ¹åxÒšBiŒ!Ïözƒ‰å ÿÏt:v#ôù,MK£æÕüH3¯us‚qãz'HÐ5ºh–á.Î]¾Ð‰nÿƒë̪xf€ÞŸè{X =*µ3Ý nò˜ïa¹ ~¥€Í!$<g.à×Äu‰Ï\:¾§»z Ex¥ Å㪲ñÜç x…½Òöš‘r§Ía¼V=hi:‡èØ(JnOt¼f_¨ƒDÂÂxµ’=…htœŒ?8.óxøÛ" 6<[_QtO?¼¥š0™`QS€þ"÷ÅÜB­”Afõo­±zÒD ¸¥’g}¡8Ó(,²¨Üà§çºþVªQ"ý¦ãîh „7ZüÖÄ<¶¨uäθ…îA{Y¯)—{°AͺžêÒ–ñ’⦠qÖûË´÷¨²y .–Ä,>£"qÏôââby.çè5a ®C­óꎊ\Ýøucˆ<“‚è"ÜÞ?¸¿VNçrÂ9'} ÿ4µ“ŸuS"@ c€„ COÓl}ÊÐÿþ^W®{ÆÊÉœéÒñây2B»¨O.WûͤճcãÑó<älГØD–·JÓu8Ì^Cé ˜<ïú܉0ÜRÂÎÕb<EÀ¤–oi×ØFšÄ1¨RTX_ÿ1w hé»É<¹E…éÂp:¡•œU«udÄÉÑÑu œ@’»ú‡ý=þ¡Ô±»ãí%)6ÂÐåqõ¯/ …¢#(r‚0ÜÑ|vÿçs7m¡DsÕH­ÑE†áû¨#µÐy_Yðß+1” 5x(bŽ”³¾]M æ™öA/ ë×EᲯEP µ\Ô±Þ´.EHS4×~7¾Ðå –;! c}®Õ©!QÆJ9ó°»ÓyÜa××Eû& FT¬Ñ£L9ú©õ΋þö–Žå¦úÍ­/sî»ÒÖ ­ŠIÌEʱã'%kÿ YèÐ-¶ò¨ÌL¶Ã°Ÿ вd»6iø×®—Cra®ðy¢˜d[Ë r£¯3î½ÑrðÏek‘œv�#kj<©H5xíZ³û©¹Ø×ß›—DIì2—ÙÆñPq¯#h!¯EÐÒâìUkƒ kÆxêÆʘñY«È*L”Ám·B—.em)p €÷¹E’'pˆ¹ .ÌóOš€–hQÏ牅Ò{²pzý_å.B¢å<á'߃£Ò‹}æ,{ϦÞ¤ùѵ¥ ¨ J:J ªo Ñ®AŠ/bsÇ€ûǧB ‘=é¿WBјÞq«Ÿo˹.$pö{Ë wÄH†>¾ôÔ°sÔÅcw¤âM«ÔKJaÎëgdD¬ÈOBHñ[ksÞ×P±ZìÊìJn@ü„.‡ÆÛòtËÑ¿ç"¤rÞ6ÑijÊn>·žv#ÕŸÓ 3M«QÔMÿÍÈÖÎ _zVG1¨ŸH™êšnÒ\î6ðnëJY²; €ÒÝ2IŽH@X¢RøõiÃéSgMVh}"½|d‹çWŠ+xgÄvBÕ×hé£ù`p=qüñÏGì<LLÓª±â9w¢ŽÒ£iÃÇK«Âªå"e—Ñý±4¡:°èÛ vUîZŽ)šLp_=¬†ó£Y’´¾3¿›²¥¦ÐÜœbô‰”<YÞä&8h=}q×ÈÓ#cqŒÍ F¤óÖÓ$ñ•l•d#¥ó]älê5Q¸ézžh]L«± òÂnµ•wULò+C±(_‚$ FA^«Rà+WõZÄÄ GÔ/.lëÍÂåuÌzì)Þ¸Ó¾bä % kø»gæ)H¦8ú©ª¬xöj;\Dq‡ø‚º~xQLÆÅb%Á¸G…Ó;€$7ê<B‹:º#° ö2k¾¼%OÐgk~<„¡Ã˜ˆ3ñ‹ß¬W­ûBhYæ+»gtÄ–A2´^ûg1~èz(¼ï€ÝSO߉é*SIwÑZ;aj:YZz¬±CÛáøÔ:K<ù+àmúœ’ EŸÎ´J)VÖ¾G`søÑÆëÃþ볎âŽêþ^ëBhRßý¦–D¹[¶¬¢ñ5—AÕ뜡÷(qœìNsÌÈ’àc•zšw°ÔN "1^{gì·¸žM_ц ª#yØtâ—8 0}¤‚zº­ÓíJ8«ªC¬½Ü0—”üWêQ\X›;Á™OCÄFÄK¨|ÓUkÂòôl îÕ³±ïéÆîeMd¹Ålu×bò¶ÆµVš=³Ï”®ðt]3øå°:ô(Yí½¡\'ì+ƒJ‹l8Íz&t`Š<V,ºÆFS 5‘è{£ —…ßT¢øÒý`Ø÷3¹¿Ð’ÔûíƒÄb—-›æª¯†®¿�á%ùÂvžô½†£§©NéYo­£Çzfc=å«Ryº#e¤]Ó/¹@‹B刧960ݹaëœñ<ÛtYªW˜ GÌq‡cŠLn½Ûøv83xl‘œ;1å1/O<‹ôÚHtÙQë1Å],ž©ÆŒzÇ÷‡¶‰ð¬ßòjKÂÌËÞc1Ñømy"|[há}ÛÝ´5X,I*äH{çÚÙ4 …1‚ôÐÒš°í¬Ü4J!9­TZV–/ñæÍéžqÖÅ«õFj¶ô´+b‘&Ÿä¨*Œ+^=wËð Ì´ÔÞ<*•²qçþÅ‹‘rH…Û'mùóH™vô¦SÜξf¢´œrÏp‰øy‘9Š,†ŠRV›6eaÆz…ÜÆ8fu Û~ƒ¹ìËøEh |ú¾GOàÓHqKÅ+’´"vÀ–}uÀŠc]¹«{ÒBŠt6HmÀv–"ÊBÊ7ùMŸ5ÊŒ`¼™fæL[Î,¡;e2¤‘ÙЈþ×ÖBãïiËKÚO×(cN­wfqß~½´€·7OÐN«/"Ým¹F±ïT }¯./‚ØZïÆL¨ìŸ³¾ôàlÕ‹Í/tKc¡Ãm è�ÔkU<÷‡“ǽ¿+Uïw7àÊô“åYÁ‚ºÏRžL°“G¦Ôˆ Õéˆ0ŵÉve»~û3.͇C5š¿©‰XYÓ(4Õ}³Sq•pƒãò‡™r¡¹2·±Ü Ñ!p¤ß ÔC¼ç nj=˘7…¢ÿ)cËô–¶Ùj]ÄAµù4ˆa8š Bµ0­½l€›¦ýŒNçEøÞ«žvÉ»togÕ©^N"òꜘÕú´ÚNTCI¾ÿžÈ’{³¸„…æ,H>í07Wtʇð 9E1c»›)_�Ì2ÇYìØõm“«0r“ Éà ùn½·]¤§+~{Qž•á³×†Ü·¦$¬éˆ/°;R1‘Yn_ÊR9U;6pßîpú£ G°ÐµUTeþ¼’Š4ÆPÁ$ÈUe¼²«êV¿@OUNÇGR‚î(qZ§@KÜMµ¸ÙÆÚÞŒ½uXpÀo ¸lù# ª6i%ÜóšÊ8{(AÈZ!€ô?Qt#NáÂ/­ÕnM_ íñ¯N£âui›zgÏÑÆ 8ÇÆsø!–2kh7Y3Ì{]^¿ßkgh~Œ8`ÐÂd¡ÜP†àiwŒ”™qgJïd­RƒöFÊÖÒzt}Ã^fÍÚ^GÇa€¬˜ÑŒï•X¶ò¨äè„¿-‘h½ÖH–ñy@cmŲ»†Á®/_[‡ºó@7³Üê‘ieýeœqž¥mNÐHì€Á×è8ŸÌÕ[)Û¶Zℱ™€;Õ”ôÕþÐú„nÁ<vÇC7[…ã‘Ãá³™tì$£&ajÚ?ëÖ³R² æ°”òvVdeiìï�–ñ±ÁãI†‹>écê€)|¯ŸÀÔ°*Ì^†ÄdU)ŸQKòriÿÉŒ¹¨5y_ÕÇÝŒØ)Ž{ƒ¼&Jþú§'¡ñgøìZ•Qfh¶9Õ\¶Y•ïÕiåœî=@ (µ^¥a6´ç›†…Uì÷¾ãK=’®57ŠI=òFɃi!‡¢Ã ™ïn³Ù™táÌ…lÙG²h™§aùt?%% ÚnÏsE1{ò ¦ó#7CÜg–„µ<õiÈ öÅö³*bÀÐQˆ-#¥¬&ùäz¦¡û…œ[­‡)P[–=œ7V‹5ä·?öoMÉyË/l΢Ò} †Šm MPZnûœ`ê¢�O®Ò1>wç/#Äå]Þ£…, ÅB*5¡­¸ö`žMWŸ(ˆ9³Žsg´zÁÁ&ÇdWYæáæY ¥¯X«#ÍŽÊäÍÁw£É‚žv¢?åöwf5ÕÝý=m¢Õ-³éö¸?µ¾ëå¦Üéçæ‰Ïö†ã ~”ß­7¿žXOÃV{Ú@#T.86 }†óã>óÖOórièÒÎJÞm/¦j»Dø¿”F>‹û…pÉ‹.£ ¢�ž³Úà+—¼j!V@‘U\y<ªvøñÏGeÔÍ(¬ ëHÈÔí¡-ÓùïÆ‚j¤»Ùkñ}ôÂ>Ý';¨ÒÁë{Øl1¶ÉƒãðÙNà@Ý7U¢áJÀøJÓá·hŽa­ò�ÀäWçÁsC£Ï#®O=W¼O�ùÎæÚHuâ Çð¨d¤7_b:.~lfêퟆBÏÿZ-<¸:7¬æP€!Ža˜œô~–—+$C/* ‹}ÄóÑä0Œ*d#¦Â¶ËöŸ»û¦Ì}PLXýAßÛºÄFÈ/ ¬C!¢0^8cT¼Ç>´/îÁkaÛfAeTTbþò†g,ðdÊÔÊó¦V^UÙ‚OÖwtšYY‚”-AY#_ ‹Þux®<P–чaÔ­-QUõìÚ^½ŸåI™ŽyÅy§ú„{fèH hæV§WÅGšdX¤þi'k,Í+Æ7Щry¶ýhâíÝ[á£õë­iY/Ô–ÔCûŽN†»ZHeTÅbbš”qïï6$³u÷ßÀÒx¡û†6=Ö­f,IUÙ¤—o™×wý Ý ›è%ÆwOµX1ŒZnÚ0?ÍnÍJ|9Õýc)ÑÌ3/*2è{ ‚Êvô ƪFl,ÚktqA­7P&¹U%8ï«Ô0~øK;mýAñ£¬.Øjׯ/Ã¥mÿJåÏÂä‡Òl_´Ÿ¶„7VÉ—#z(ÜÅæò°8‰S'#È8\[ožf%eÏ,ËÃï ÞŽxUKL°Ýi,;3hz+F©´íÚ4bî]ÝJÔ¡¯ìvÓwlBÞ5Ó±C‰à#æNe½—-@}£Ú•Ä ¬þêp �œyˆþˆTFÁÌÉó0Ü·í“ O�Š¾Y#ò-}*…ྺô  ÂIô¬Àhlöì¾ê‹.€íAz-<×ã’B/nïi–{tQ†:Œ[ÜÓ­öEŒ¸»P¡E¢X>œÖüJ z<õÎæhg‘KÏ”"\è¾A:B‹‰‰kn!P{Â÷¨˜S$£qï€fp1´3Íb®<WZi:È\9ƒÒG×w v P$XP^ºVY!Ð[9×jêÉG‡&x¬«‹Õ­í-©Ï]:YTpŸ3ü´ÏƒlÛx"ŸõÔgZ¯çIº@ÝÀ“E˜òM1}ýk§Ïiº¶ ­Ùþ_ºÕ°éq·íÕÇy‡áq=Âküþo=y†84–ŠLðL¦Æù~l¤µoR:#*JÏþ¤Š/8dÚÙ%Ï-¸I+ÁŒ2¬Öö%ÞŸõ…E–zŠ*Ë ÜŽ×³XáÕÒ©§%å²YÕ{ôæî ©K_Øa뼦Ï_«ÆW"YülÏb¯/{ïê&æJ奘Ӓ8)ç:ðsÍir ”¯™-åR 01“±ŸÖ 0vi1«”ÑÑöĪÐlä÷W£±(K3ûÐY€¦ª 9¶>²ˆÖ“yyô^ŸÄt…î¶p½«Ûؘ /Ùæ AÜZ²(» ðQ÷ð¿›å¥¯Æ”åLÔˇY3(_ðÿ] %e.'¿ÒÏ÷°¡øV`;ÀæPƒ¼:ýç#½ŽdX}.Ùç)äK¥°R'KuÄ[‹2+‚¯Å_juØ­dÄ:A½nŽ—ɵuëˆ×$Ï<)P€´7 ~[ÝV.Yl/›ªflaŸIúæronÚ‚Eþœ ßq‡E¬ÿðOµ.Ô0zfe­4«*¯oڇ8ôõظBÖ8ºYÙº?ÐŽY9íÑuÝ˽µwüÛ,$[ÒŸ0 fŠŠ¥åø!kà€'s3‚ÊÜI©p»¯Ý /HY=ÆPryZåvvÏöÐ\>Ö­,(ë‰>Umˆ'——>Î,6ûÃOœ1‚\’œ­ôÍh’ƒCjøy¶§28ç Ñ:@†i]qæªÔ cÂ7Ñ"/¦Áy2XÛ×T ¯wu÷‹¼¦›¨ÂѪjŽÞì�kÐÙÔгšdà/¯&†ß•¾ˆ4܉¨¥ìL£È¦ÚÃ�Dð§[ ¼É£p–͉íkëĘô\M sË©ñ®Z%!é€,MlÒ*¬l±øÚü˜söi®·ª‰ôÎ^‘ÇkaÍ– ¦Û‹GÊ`Œ}˜%†•zvè¨xd¸×vž7%Õ”Ñ {k¨—%K•ð½Ø@núS[ ×jvsœXÀ;ã«ÝT˜9Ù±ƒPÀÑ¢º¥,;Ÿ¹úb$Ãz͈H½¸7›íø^hUª¼ö­MQ,5ÆÄ@úK]ßU_ËÂ+Ÿ¹á˜RTjY% öíÇù£¦YX ½ŠDŽÝ*Íwƒé  ÊMÍÃZy<9ÖؤÿmMAºþqáIT ,¯» bd×ï;CýeG½EvÕ&e3Ðð»öw¾j#=m[©!¨¬ì‡Šó>`%3Š2ËûËo?Løtv¢¡«ƒu7¤«ñæÚáÅcïTstjmû¡À©FquåLÌWušžÿ}¬RoÞÆ3æêO-ê$*‡I0áÝØj@ÑYõ°èÆÎH•º6â]¯â?Ö²¹Ë‰”M˜¬ÑÍ—}ôM÷àÔî@�öUƃ¯Í%Hœ ³ÆÓ¯ç?FaœZ¸##l#E¯P¥Gø=rF–ê-H„} Ó,™ÝN·@Ÿ$õÒEö›ÏUMç™DjÝîTÚšDÚ zÛbVvoœ»%›X*SÒX}ÚÈŒƒ®(XÛß)úË'ô¥j០PŒ×5DÔqé½ÁéaT³û…í¯ÓÞ C¹ž\<Ý�ÀeºÜ䪛‹0¥ ×'ŒñÂë_x<°Â€GWPB{;ÀdY‡ùOhs²Vä2!ñÿÕ·(LgRtŒ¸IƒÈÎau˜ß2Ntãz!Ž¾+þä,óX&žò<Äâˆl=½kÅådF>+æ8¦ UO[‚úª¸·²ò·4¥MgÈ#hKèû´ÏW¾ß1ȃǻsÊå€ý=Ír+†Î FDÖSŽèÖïrYÚ‚EÕzLÏæ“qåRÖˆ±ÓD~Þ*ê3f;>ÃÞ2»cb-ã­v}át’|5z9IÕvk”ó‘CGºäÀ\¥/œ}Þ´ùqªŸ g:}…<(F­ŠÊQŽõE˜Ì·ŸÛ:ÉG*&9aÚ¥@ 5–Ý €Úg,¡'ÇÔ 'P¦Ï•ŠUîÙ®9Õ-¥ÀÉ“É�cÿEåC»¶D`&‡í¹&0îpfb€áo”›m2nä`RcsÔ‰ö%ú˜å ‹ŒóÜi5ŽïšèDåRË4a{uvM1N\0N†d.Öê/,ÖÅyA1ŽtÒõ`*ý·§°á»mN´º^ê[Ž¥Qý¦³àLAzX[8#z‰—v°þP¦Ï݋Ρe[”ÇæD ÊFƆ§~o7^l/moËÜdÍ,®1>FÍ=DcòˆÆú4˜þm™»©—ôOµœP“¾hnzºÃI«šÞ»?÷q j üY-äG•ÞØosÛ0Pš„K‚Ëîã’£‚U¹"¬‡ƒm¦ÒJTÛsq™Y&nX°ÖQM§J¿Qñð‚.Ë” îÏÑÑueõ‡ÈV{4hGX‘ w·_bÇ៑'÷=F#±±rRlïîUÔÒr§1œ ­ßà 'ù,Vkœ£_¦,=Eð¼aW«R]w¹(©øv½Ä$¦uÓpÖô|G¦þŽälùðÈátt&T¨¼[,šñ䥟I\+½Bv;Ì6`öää ¶ì�iN X‹Û—²ö´0±óõGQ0¶zÜÝGg…Q<þë!¥!úc Q‘T^~ÇÌUËœ%u(17yÏ«ý,ï†Ècä6½bå,ºy�™Y­?½M7ˆ%æÞ¿É:Š-ÛDúzyð…¡­¢» Væéº+n0żf‡õ·Ôo}˜ÛǹßÏBAÔ�wÔ³C*Ê}¯ÌGRQ뱋éõŸ{¸£¬˜›g‘h!–Ö§+Ëà¦Ö»ikõ¢›C?q&¼XZö·‹Õ”&z÷8O�å3 â¿ÍÖ˜š,6˜Ù$Lx ,s“JírºHíÂ=;î5æ³Ke\7ž-ZëFc&îÌb<Q³¥l¶mmÊ ÆŒ0=A—µ² $Ózû-вS•-n¶Ž½ög _àƒ™äð…}PQd Âm`WdVû"‚³Ìj¬Ç;y©Ó‘FÙR0ìHñT?Û?§Ò˜çø&ùmèÔÚBãàoirΆ-4 ©£o~Ÿ­õ&û²bå+Þù¦§ÐtÊ&L�cjœ´¾üæEä+kV*‘ôxéºÏT9ørô4Ømè¬u³[1]×RùY¥áöšPûšè[æΉ„¹±}Eku\x+ïF¥Öõ¿õ—äh/@_‘ç6ò) Ë[ºwá§Ö»3fŒ\£OÜíâj²¾zŒ “Ç°UÆÓ†n¨ü{-ncmÔaÓS I§Ù#ÔPñRC<]lt}ZŸ»¼CìKÝØM »íT£þ«A­Ü ´Qm6Û߃×\9/ÕrpdŽ½&m:ºï~6Öð®–sc:Ô”+aG8øJ=ŒŒ½9W¥OˆØ¸‘þΨ�€£–K«0€ã¹ïéníl¡°[­vLQ¿ñqŒ’Êòp„¶9цÌGnß×ÛŒÉkF”{š¼T›·𸭠2ŸÇ¦)~£‡BÍÚVQà ^¨÷®ŒñˆŽÄÓBÔX-,æ½÷kvø|Å’ sŸ} JŠñ_+¸~(jLNEh‘Ezžgp‹tð ˜e'öl;ªé€u3xb_VïÌž®æPyåË'Ò-ÚwôOþíÑ$ÅPkV8EOBúø–¹eÐ:b×®­|O(6ÆÀdÜÒ²O¿Ui“ªãL�ñxšŽ¨mÌ”N_¯e1K_N(tkØï62°ºû«–¢Äå¦ø¨—±[×»žçåÛ_x§¡7 ¢e3îvg6«²¢›SÓ�IÃçí̓™ R‰Z ={ÙßœH%ŠKð2Ü'–¯­–Kʨx׫yWIÜþÈ]bë ;•)Ë)Ïu囎;q”ú&žœá¹öÚ}€]/k9¡ý ÛÕÇ×[”ýUÓ<£C#µÏÆ$ˆÈyÎøÓ"bh³kª+¸¦³¶üp¿Óß\+KšfÈ ¡u 2`ùí¡÷U‰¬)²¾.]‘«la¯Ç=`ª•¬2¶ÏzÜYžtŽWÊÇýß {7|¨‚Ð*�¤Z%º/ì‹AL¹ìEß1n[ÊÞ¥•ï"¢*ìtŠÓìp¥ßPá‡wßÕkäYwY~ùž¥ÍÅCæ¶'§ᬬècØ-›~Èßñ'^Jaßh„[³tnåÓŸžx¢ÌŠ]È™š< €+`ŒÖa@Û+ÝL8ì²Þòþ”¡OG¦Ûs#Ï w§jgxŽvôüÊ ¿Þ‚[ßWN¹çÚ2çH:òˆ¼ßø‡Õå}ݸ…áiÄÞƒHÖªXSõ¡µ•Éþ7Ì‚MÇÈm:ÏíñýrŽ_V¶®gð¹Ìs*k2‹po ÊjÿùßLt,%-R'×)¤Óñèé'¸ÇeuAYEÂÍ/�>´~ö(™ÂÑAD7´Õ¬â{¸Cĺ\óÑÿ-=å ,ÿKªÃð§>œH·—Œ§¡†ÙT¬c8,§Þï„ àÃ}÷v_ç5…¦¨QõHµâDñ…'{¦‡û¦™(Ÿ)bå\HU¡³·ëZ\ƒ‘6´»££±ìDSHyœ¯dö“4vÜäœ-9!·³sm4Ê2&šxv˧’Q®‡žºFè¼*â…!†WïÆßèÊ$Ñ=H8–õ„¬%’aíæë4íµ\é€B™¤O®« ù©–øBAÎhîÔ„ÖG'~Fæj‘qºÞ_aÆä”ÞÃòüÛ#8ó2¼µ5|¤™Ä6ÿÃÛTW—AjÐk1·-7ÐVu6Ü,Ø_½¼0kÕÎUSÑ­Õ²f„V-"Û;¢…û'È'#SöP¯,ÉâÌ ܾσòÛ¶äêa}ЦݦU_›/cÏ×Ö¿…R™ü{ÜГ,¶ v<ï¬Y‡1Ñ“f£;¢ÇK­ çLÍÄ ma§óS‘Q™X쇂™GélŠÊRÊ7 3W¯LF@¤»å¬ÖMSÝs‡wøÂdÛ£sŒ§ÏNùF×ØÍçN0…§K"…©ƒžÊôéQÛa«³x——'—Sµ Yz{az®©™9)Ó_OpÄwß^AuïÞè×ÎMbö áiA9K½ñlðÌTG÷ìe–„±eY¦bâ�óQ`ôR<î­$ÇÀ°ï_&®SÔ‹¤ÑõoØ<'sº*˜™ž*ï/@I�ñ’‘4Ëýù¯ вlAÏGg µUOž¾UDº-iiñpŸÍÖ¨m‹$j×­Hù\ÿÆ×3¨Œô.ø¹2æ,yÝcQý±µø{T‡2ñ…ùèÄäöõf ¥ºI¿TpÂL%o{@¼¡@Û&ÈYU“$ºIþ!ÔqN ŠêzEÇ(7»qèŠ_½~Rp²v‡Ù‡¯Ð@«ÿ•¸ŒLð Ù:f.‹«2V][«ú¨z¢^¿"J-h]ÏÇ“ŽÞ ƒ‘ªÙ I”=]Væªkx=õ³ƒsngGBgÐ-ÍQD‡(4Ì•ûÇ^ꉵTl˘ӷ˜ ž)6ý÷æ~ÔOܪ–§]ô?¶$ÓªJúÑ:2ÂñåØ-2Î×ú·‘íH›S:üÑnãih [,÷b:ïì™ù¼W.àëqÐt¼ôÕʬ®6ø¶‹÷ø4Ϙ5–ùm|€² O² 4½Ìü¦ÿå‘ÊN›¡ƒÂ» ÜF¹ŸdenÏ ê ­à|:{8AÄäÞµNÞï<Ü•°2zDéG|î ß_P›f¨€²d]Éá)«Øé$†g´‡Â_9µNaµkw*½d‘iÞÕBØ-Ë®Ü^;´¦À蔛˾E”Áœ(bŸÔ2ø€9-�ˆÿ âÚåæç{Z7™W”rßvw¤°Ýôjª˜¨<Ú‘ílð»ãÄRׯNzÍ– ŒX ¶ÝÒ éGÏL}èÌí{cko&6 adÈuLÃ…ý‰\*¢ÁólÁþ9e÷æÝÝEÇþ3šPÙ4­ }" L¼¦*H‡ÚÓÒlOMïgοé± ØH æ[p¨ªÙJ<E-í­q9£Ä mÆiú¹nyœ2w/ð[η+4–™˜ëTj™asÛ)–ô?‰Å‡³Ç®z)ò€°“Ú4PDœÄnP7Ž;_7ýi˜x(yÝøëWÈ8³OFž5›¯»³,$àý§«ªóe šæ™/4é±à.|ds%øT^e˯2ñ¤ }ì’"ð¬&"û£‡<ÇY7À±uWí©ݲøRŽY”¡ev.kíÆ¥le8î^¾éën ýü\Ù°REÊ<¿# ˆÊr–sÐã(N²;êÓ‘aŒT<4mÿ·ñÍ‘7,c¨Ô¹’Ïvj6nþ Ãó°Úѽm™„|ÿ—Ç\²jºº¿;L°Ô"чž~j‡ã~Nä줪6m?v]þ’*Æ:·ü¢né^™Ñv‡IEÞZ¹²Œ§¨hPÙï"2Éo�ÏŠÊJ0#˜ ß‚œÕ‰j^h£¥7íú/ÑM“}^k X–>šä{uºa²®Ç);nqª1ýW¢ÕÖ ÍÐ`®K:ù´·63Ý|VE`<Jl[®ÊûÃaô}}­ÏZ$BT˜“ÑVû¦’']+Äv±ßé}槺PÒ&£B4rÛ;·Çþ´Ú&_fíc+�.Ëÿß>bãÄ:aÃM¯ÄæÜ/¿!Î)pÇYep‰:ÿ-¸$J*gı¬/YX!"֗ŃðÍ’¸mȪï€<f Œ›_ÝJgIèS¦"¦·–AÜž|™ LÏG‹Ýý…Ÿ/ŽÎ¶« “=oS˜O}-ì™hŸñ]™PEÖí4×»ߨ†(”²ÅAB‡ˆÐ‹ÄrÓv¡Œ²’ÃRdc7ϬÕ WãŒ9À3X�@­ýÙ\b¼]†c ö¢2¸žßí]/³kš³éµ ìק͙s”ÅOÐ\ˆCLò춨­õf©(*Äùzd›‡ñB >[t<EÆi2ØòŒ0g• "jHaÐ>�¤ôtÃWg»†ß¢Ù›¥.[K…GK9G¯Æ¾%pz·;¸¹6½1E÷Ûv‹t ýn- EÚ Ö¥‘ûz#€ DÅ{¹'Yg"Re¨˜ä&Ólv5{{bÝgãl»‹›?3!NSO=1ÇBÇȼ:w^¿»nUµÌ†”öøöè¼ô°#1+Ê À“jNLÚ½¡ÓtÓA¨cš; 8vl3‡ãûkz"Ä{ïϤsMÑ8í°Ü™í<ì.=¤°S>¾é}vÃD/E ¯4áËù!#¾éžžwýŸ߲׈YbzÿÎÇd‰NE!ˆIÚl™¬cäû/žÖÞé{@@d  ä‰'$†ï² p¾[Òå>ØzæUü>j3·“‹*”…+·…]? æf˜c?Yv˜RÃ…OdÖ ¿|в¶¹ÿ@IVÚI më±ñ4ÿ»ŸU×O»ƒí×ýéäEϲ{?X؆û8=äê&T(B58"Y`ç7ÒoQx=IÜs7ñìI×ñyɳƒ#«Ëð²ôvï‹W¶< (”î1Ö=;åŠ ?P¯SÝR/9¢Et¢¾ÖÂŽ+ó<$cÉK³ ·]꘻fÏPð„ÔUæ<»ÿÈ4(ìü3Ž…èvP‚·g5q^øš1Àà_â˜éU†×2Áyi=žÝò˜‡3åò¯2ÊTPŽ‰9ž¡ö]+eÚÌâëÓÀZËW¦Ãt~ši{¾F)ΚžÐeð¬ÄD2F•¥¬Þs×f^òÈÍç5¡V‚a�6WÛIâ1*“¹a…ñ…fÁod ò0ˬz+äF¾`Ù©ú@‰)6ä[vŒ¶4­ÄÝ´aÜ•gZÈèsW•Þ~Ûæž KVQÙ²[×?NÙv#Ôòc¨ø¼m€&‰ËÊÙ#}µM« <ýëÑMê^„Tcßnë^_;;wå‘ø$nó<H¿;O5¦ïZ2škf´‰†åDoØñ|èêGñ“ÝVï椩ÇÁçVù× k-‘Áè¤ÈjEÅÏÝÅ@Ÿï8‹U óo㧑}«T v r˜¶cð‹NVå ×梙•èz€ÍXƒ^…çjµ-÷Ãß³¡¶*÷Xí`uÒQ§ÁÅÚTGFC)›R¿Êk• ›ß•†=u´¼/'s2°ó¹ˆÓXàêôŸS3tü5Ð;ÍÀ]yG¾V©÷g™r¼;Ò.Ž.­Õ¡ûøD7ÁAžXýÙ 24›Xþ–{¼]»1ûöôæ’ƒ‹gaë!ñÁ¾b¨Ç³ „,$…†x‡wî¿TÆO­Wß2dÃÌ·¶g”UF¥¼¢¬ÆÓôµ´å¢æ¢1#ŽÖ@æmÖŽ™ µ}¾ÚÂàèäíÛú2ÃÍA²;|‡ãcï¡ÖÀ ÍHHx—~ÿˆ#p˜M‘ŬF€ªBÉ©(Kø€†‚á=•H#S°Ù(†*eQ>&‹0ñé@ÇÍ�MCñ ÔôBN…Ndˆ¶‡µT’\›Èhr)ZCuÛo,À’ìŠ3ÏáÅY;BIeЮZiܳíî´9Ckœ¾@°Øž /…%ÖEM >†é·­tÔv<N`¨©Ñ]ýå]-‰Îat¥£ØA’îÿgíOÖ[U’¶axL…gߤö{Ñ7C¨±’-YûúÏÿ8þ¸#22õ^õ ÊÂ^µe2#£¹›zòÄܶ‡AIÔ¶\7 <ïÏ–¢™l\XÙä~Z7R=ºaªnˆ‰ÁkN—<7¤ù}Wé¤á(TÑ‹36I0¢É%r,t—{Hd]ôÅ# §VèéV®õÎ}æÓZ€v=«&™—Dz;ÅR+ Ò)Tõ´s76=-pªDzÛŒhý–™È B “ù9KZÑÑÇ º)óÙÑ°T Þžu”%ÏByÈv³âk–Àf.¹ÅÀқĴÍìšáò;¿ôq‰ubf²ûLŽüòxòÈ\ü‡‘¼x–ËOþ¬Œ}œ�œk7°R³¢ÇQš¯„ÖõÕ¡«Â¤IQª'˜Pé]s´—Ü×ïÃ$¾·EÊ ›”Þ¾S¢)[%s,¥Ûsó ßF(qÄ:‰»ó: b‹›Ba(ûƒµ¢÷ûH?.c_o(x­&ßß6'ºö6ÞÖƒàI$ñ‘xsÍ ºÿSŒC3Ïk›~ÝñPÕ¨XUzÔ­ ŽîZQÖÜÖêa tÌýEÉ|¦ã˜éFo9àP¨F™¡¡‰(ý CnáÓ�ùàâzmŒZøÖ·ôK˜ß×­g¨‹!Ùd7ÔS^¬ £if´A“ ­ì{ ,ƒìSŸê$^D”2h‡œÝœ5³3È[bGÊý&Þ¡\²E+VÜÌ.gÓ“‚ÂÁ…‚·qí»ßèi:é�žrÂÂ|!µØxÍöËø¼5j5Z<Í[QØÝçæܧë$YdƒA„fòž²è|Ìß‘3Ž¿6òÍÚP~rFXº8‡PÍ.©ˆ;zؽ]K5¡åß#{¬{R1ˆ÷Žå´"s³¶mÂt/©AƒgÉ)óÞ ï-¤™oNB˦£r7©?åî†Öða1æ§}©¼u¿;ñ´¸ÇÞjõÙ§¦ìµsHDÛSšþšâcl çÏTu¼*ùå©?d††õHeÕRŸ¹ñê4n"ç(‚¶üF—•Wû ³Aô;}½c¡z.ã€ZÕ0“Våí9GùŒqïm{Çõyˆ¶…åBõ/b8ZÕJ¼ÉjÖ Ep°âß¡Ñœb¶Œ ô[ZŸˆ]’ÒkîÔüq˜.x·@ßÔ÷‹a÷.øåíìfbBu°b.Ëòæm¥!‡0EÔÈ(Ÿ§7?)$}{Øw ‘ö¼’b£ÉÄ]wùõ”Ñk0ò.ïÛþæ I(z hifjD!„’¬Ó£J®õh<@@b|Ë ; ¯4F»º‰@ܹ”YvþǾûwÇ{3œœï¬ñÑ©!-ý|ä((ÝŽJƸè|uvÄbÑ×/ø®°Ü»%£Tžp=‹= /L?{OYa=£aÚ~¦oz{ñX\TJ.²�ÊH,e9¶e[.hÕnTãÉ7Õ!RÏù\ðïLW)»“¶ ѹu&S¿æ«DŠù°ÅeÐTqP}ZË°œË‰Ëäz‰·<„‡K&ó.X³²W¯½wìRgEóžÐ£ñž–(ËÆgªÉmÐxÕ„YzÞü0rÿßî¡ùßÝãËí†H ë©íÉK ÄÜYáÞÿÓžu¢Â·9¤šl}I¸äÚÖt@¯,sÏ@à)ǼXh×´h°‰›aƒ‰<ÍLÞˆé5wÅ«óúuQj¤±ïÒG¥Æ9‚KU{d‚åÀ÷å¼Qr6BçÛ.D±;P!»éÄ+)ÇPŸ>ô·b~eÂÙ¡þ‚èÏ©ßÔh0P•Î†«~‘%Ô—2^xƶy™D™ÇZ�H" ¡>…ý ‹4󨦠Þ2[¹‘P 9®^®]Kú_û¶hBd{…¢!„Žzƒ²mÎß7—?D@uÁTÛªT²‹eçN»' =GÚ¸ ‚¾ÀÚoOÈݪ*ök,jês‰8í­û"HGTi-X(®¨ûóE14HôGÛÚ˜(_Soc¿Ë“²ªX“ÉÏhýÆ�^™'šÃ’X~]o�º¯îLQ¹J'fçµCäÖ·‚é„i«ë‚-kÈ—eâdãðW@†± R¯qMad<v ˆ¦Ö=òˆ!Ƥð˜ñœ0ÆZ'ƒŒRblméDÿ%>™¼ü}á‚»˜ã(`w„Nµ ý>jTÁjŽîÁet}ÔßÔme¶�–Ç´øª ´‡ÀäÕߥ¹gl“Ä(T×iS7ݸñ×k”'¾wK"—T:|[VÓç˜O€vӯؘŠÍBtY;Ÿ;&v$’—96BøÖ)*ö`ÞˆŽ}Ü÷ü,ùÝh¤•0¬¨"T?¢‚•vè^zwü©?s^Yžô'ŠpÝèE83åV¿G6WIâUñ™È%åìY¯*–©j‡Q¡w8w%ò o8Ç…cý¤hâM5-‚xž\ìR4’¬� oŽC™ÎÚñÐ-áÛ¹üÎ?§efÓâÍ8Ƥ.÷®¥ÚÖ͉·U\=*Uïåî’¶8ÕÈP—´ôË㿾Ræ ³£¦j²g˜KòÝCæÒBÐ]øVcDÍÆo+w‡£}¢{ñõv¯à˜9Ë+TœV }t*J7G£ØÆsÚúÈ#B3"€2§™jù×MOeÞ‡˜æÉŸs¶¬ÀÛuõà`“þÓÁ>›ÃÄ»Þ0Þ~Q˜FÚÕpt(ÞºU~k_BÒŽ¾n!È=°KN.îoÂ9tŠ·Ôó'ÊÒîAbeq´ìËydAS;.Ä·ÿÇÿÕQ0 }§�QA–·•2×ü_&@y«wLç"îP‰@$sñ18†hþ£B{À¢Lu à5SüÕúsÆ 4K`AìË®MÆáz™}+¼1á\yƒõ=~îzéç'¥ š3šÑUÓè=‹¥²p©ÇýR‘GLŸ£ ïþ9Ù µ ¹SB(}8ô3ôµnO×NpY¢º›ÂüÌA?L8SpšÓÍ 0WöëÒ&�ŒæzU\Ã?ü>f©¬ÝÄ(ÆÿÐèî'Š€šë–Í ÌmמŸ¼žPª·ˆÒÞÊׇ=9Ôì# åœÝ×x¼óß,Ö㢭wÓÅ+ŽþÎUÉj戋ýêãHéÝçäF×0“¡êÞŒÿ;ñÈy*\¦nðà@Úœ¨F ­Ÿ ×Jp¨±:¼ÆV[(nåûY¢P™¤yâû¨‚Ìp˜M?I(UÁ¡oDàx@Ôâ#ÿÝÀÓ—älw{¢šþtô”á ±zÜí€ù£NGÚPãž&ÃC¡8ü­uX—na Ê0³ 1D`i4¬È|>3sOh‹$Ö‰–ê3£å—P~ûúÑ$u)7 Ó/‚lÔìÕ!°‹±èÙ�€-An<V®ORGÝÔÜj¦;SÿxŽéô—ïŒ5��3Ó IlÿrE‰6Ohÿê̳H|«q˜)×IPŽ6WO`h‡ÿ³½Á/t=SçÒ1E¥ÙRÕÙìàHº·6=â‡XÁ­IÔ­ÿÄ°ábøÂHl­ërÓGº MV[z'|ìS|†‚öTŸ/ 9¡ïOãÁµ½~bœÅ ¦ZŸp¶ðjvi¦`M´¿V0¶tâ==+Õj:ű8pÙ¤`ó r>œâ¼çÀ•D¡?‡ÜÄ}É£7{4Z‡Áþ‚ó•ÎiØ* i;ÌÝô.Y·Üwµ¥èt„hÔn-I SLøeþZ²JU…‘• 5“È>]½.¡å¥ßS5övü“²ËMc–ÄXÏìÅ«šÜÛÝÀ6Q‚}:0ÛMïĶLÍQÈd¯>ݤÄØ…Ž'Ð×;ªIt¶wýÊ* ¾Ý= Ó{æ“ígˆÐ8?Kä4‡ú‹5cäe<ÍœÈêëbÓ¤{�\7³À©ÞYÏÝ‚G×Ø—Ÿ‡Ëªó¿M×ö"}ãõ:Ÿîí‹u|øéõôÅiúÔ6>r‚VÅoO{%kµo + »^DŠ ÓÇç@kçÝZ©„FL)“•òäÉE kE’÷º­ËÝ<½2(¬‚+;„Ž†Ä%ñ t«3™ÁSÓÇAÚép†zôÁÛ „=•°²( ŸÕ†™’VDÀß×L;´h%—Žx®ÎäPÓ /kE”Ñí€ãƒtVél”¯¼:qÃPÐJZ.}› d-ôñ·š igN5ÄzJÙÍhŸïvLj©ÙNp‡ìlÅ É+t+(ŒëiÑô˜0÷Ðyß7ʾ[®z¹ã½*Ä¡ðåúé¿'Z@ѧÂ=â"õÈÝÚ) ð#½‰ô×ï‹ÒÊÙY´æÓ|ÜÏå¹]çç'aùkí:„…Be(ÅÛvÚl?þùˆø ^ÀÁBLÞšýra£¦[+þ ñ§†ÇUsefüŠ’‰T¶CÊA 2ß*¸AÄã\ TñçŒRªïþQý§ÛŸ<²ˆ¢"ó¼å’“Ùˆ§¤rÓŽ”*1êUd¸p–Yö‰?˜åî$—@ÈBNûf‰”ÕWg:e×VFyì»xÛM_˜^<*Z~#€:W7\y‰”vÊÀŒ:“ã °Æ @y¦»)~)÷ýW¹²FQî+%ņ’1úP€*Çô]:Fåf8‚Þ§yPY·¼¦*œ!‰Ó‹È ºbå<©Üã%%‡j”aC*éœvŽˆÎp¡ƒS¹rCKo|lÄ Ë1`Þá¬:eIg­¸Õ鸜rq‡ˆCÒljt9&¨Np~ÌQH¼OÜBSò»]–‡ýcDîÑ:B#”7*0e€N?Ïü8U†ÎGÑo÷•óâÒ-–R”8ôë³A1'%ˆõ¥wèŠ{ÂJoÊ,yò‚Ý]QI^n5cï¢0Ó%¤„gãdvõíCHMTä6¸Çœøö[üxº¶.þ_d˜¬5tÄ"°Ö£Ès/D1Gi6ʦféÝ ò.ò„â… =úfK§^¯vN‹„pÓÕ´:¥{úÿ°Úroè0™Óè-{qI•‡”¢8m sušÞð⬹ý½«…áýýŸúˆ½\]I(f…kÅ’”‰H Y¦úŠ{½ºT’ÎÈ÷AN¨±Õ¹ðñ¦j‹rìAñ?4>èÉÅB™0¦Ä® âÁê?çlþL¿ˆ7‰®‡¾›¬:‰ùæ�Ù5 ³*æ6lø£ D*¼HdÚµ«ÁŸÒi] [ÒQhøQÛ#UÓ9½f̈M áHö+MBí=É`˜}Xsí¸–&u jr+âm¥¼už-ˆt4ô&{í+ñ3ßq/s‹—Z¼PdWÜ8{õÇt‘õ[ËÀÂDb©&zw@ûýO6ê<ŽUP±’?né´¿ð˜td MÊ’yvYR( Ìîª[Ï"¥áÒ$«‡ÇñÕ:)‚ÈÉŽ§âkÅh}c·K¿¦õ/ß…¾¦ Ó©dýx Ê6ˆgô�Nø:uq•¢´+brD|þ; AȈ9tÎÛVRDXå£*˜×Q;!å'ÀY>|ßômÝ>ŽÛQCdÖÊ©)ƒh£T·¾>a6©8ÀÖÓQвW¸÷Ÿ~Ì&f³–&¾´ÈFÌßnm„¬Õcâ`»{o’Å#IS¨Ì)GÚXÙ¬£�Ôç<"ÓÌÈi¢dQøÙÄ9+|•ÂP¤ycS»!CÊ ˆ'|ü¹¡Í›¦QRÚÆ!Æ1}T당ÿ2p²^V¥ó![¡+Lj´'µ§Tmž©”æ°Æ_îüZÌ#¿Ð KÔTÂW¶m‚ÀžVÉdCŽòûÞ!úá‰ý˜‰’Xµpúñ¤ººgŒÀ3úQº’ÞZRt”$ž %Eýã˜ù¿ž´‚òŠý &(×WæÍß ;¤ôº ÁniçÆ<}<|z—ý®ïFž÷•òla˜eŽ<(gE‚Ÿ1uVý×ÀµE^G¶GßLÏ饿EVå‘ë´±ºv„XÞ›‘bZQÙže~”óeH_ø£D¥-pN ¨«?t'uë{ŠaJmÖªçjt×Û(|–5ëÑyVHÛu#3åtJ¹™áV¶.zQRÅѵ8MŽa³ýÐàX1Û·¶ÉnXå®n랢\ j(îwT• Vv3ƒöòní )¼‡ÎÓÊw—¢Ülá¯C§ZdêëÙl\M ¸3 :7¥–ˆ€’J<g¤â€Ç0MKçð·µTŽÌ]˜êËÇ †ëJ&FIö!×ÏÀ(%3g[íH{è¨vëz7M$¡¡e¾º¼+DSU±'DB'@OÕqiåSpÇ¿OØ;Î4Š»Œ¿ìáGô‹ÌH"5˜žsÉÏZïÀ#JÔâêÕdX‰ ãyÜI°Ú!3ÄØ‘†\ÔŽvf'Žt´ýaþôŒv3Ìèôå¹[fœ©åZi¤ æ1†àáÖq^0ºª‡öpÙ{ƒ»;ƒ*§Ï®ÖÐgðdzÓÚ‹ö†¤£ºÏÈÅÅãìù>‹¯´Cé°‚ŸÚÆM „„c—zãÙnO¬7Ç3QûP±S$£…šBgÜ^Îß tü¹ünº Y«UŠ5j:±·~ˆO¥EÐõËû{Ç/Å·æ–1B VwÖõRa|uȹÓ¿Ë·ã4U)£Z›ú²¼ÎúÕ$rŽM÷¨,¡ï<á4#²mŽ)*⧾“žãCùí¢LœÎ“<ˆMþë ¦”Ãõ_òž(Ÿ×‡I´ØDSë±øQx%8p@æ™ÎªÑsÀeÇÇñÀÖÆë�)š,’½ÙØo¤¶žknŽSÚ°p‡®¬{9’Ñ^˜�f`q¤rR‰F È|çYD»+Êë{†…X«l£»uwìk8ô=(ØU ak³òŸ¬Ù,w«œKŸGômìûšÀ�8µiû•±OšUÚ¢622)¥jV‰Íé齩ªÜ7;‹)[8¨>þf)së |VøU 7†ßÖ˃LJù}úÛSvc;ð F 4eÛ* 0AóO¬s NTò–îHÈ0…àüJ‡ðˆÃp@ÛØàë±ÙM¼7!îA?šî9ãÞä19£,¢Ÿ^ßÓ?L6'x>igo_ï0"`ûA3|ǺW?¾R¡gäÚæ¼eóé=݆÷›„üתݕéb8„’Ÿ^IY-½¢ÓÐIIä]ŒTHj�Eñq¨¿Ta[¾ó”ùïiôûú …ñXc ýê¸ñ´é:ƒky¤¡mãl'f±é£´€µ|j±MÂúÒÉq‡”ŒÊCcÙWi­#¥¿Â hŒÉ ’«¡£Ê‘ + ŽûƒU5ø½$µÊÜ–J%õÓN½ÙG[ÿfÁÿÅ.ÍŠ<ÊìT#Œa½^ÐÆÓ½;×?Î/¢nLAÈN‘ô‘9Cÿà•|“à„~UB¿g[—AfÝDÑÇdßUnéjC£k7gˆ(é+ze÷4ãz4˜9 »ˆ�Ñíhæ­0úã}ë®naPQ¸DüBƒ¢ËÔy›H·Eزý¢û—΋ʃéèÑD ÉØx>–lJËŸÉôyyð¼Ü,åÂ8,a6Œ¿–Xa˜´ÑJå•j êÛÔÀÁ“c£Ü%6'ˆYã °lù†pÕ5ò†cÂægÒŽz€}•qÚk$yƒŒ{h𜭩òË·ƒ§¶§¡Æ^ýqïÊŸG¶m)MöãÃ$nûIRÚ°†ì»Ô÷8,ü­ŽC Á¶±ðµŽR “¬@‘ ©ÉÖ~2øx0Š¢+\k‹Si ©P*¬Æîìø‹�‘øâ }40qÌlZ”ávÍ#=ÕAÇ tNR e¹“€§y·âmxÄß2ˆÝ©½B¹¶úZ€ò|/N†-É8ÿd¹âÀTî˜{3´¿þÞ@ô®FùI.ãûj»dõx³À�”d}UôŒž@Åâ,uj%7‘Ù²m=jçti1¦2Ñö}SHë6É8SÑd£¥T¶mK.ž³Gé}_Ç«\uhÑ°¶v¯taØ'µ˜¹šrûo´µól–ÂL�uæà9¶7†a‹ú×ÀÂ(v“v_ë':‚¶*1 F”VõÅÈA?MÍ- +4r—ãTWË@xì Ssñ 0¨ï{w¥=Ÿ›øziÜw :r^'AfU{ÓLûVñ8*¨úzŒ g™øUGÝÖÕî´¤®F^q‰ãÄó¯f1&A2Û)‹™!®<Aчà,ªÐ‰zÂ-x(¬OFyK¶¨PÁ’w TNˆÉtØ -Ðü¨>dÞk¦ê)ÑF>HBîÍ¥1zÝ -’…«_”&í±õÆÉZâ°ù´9`à)˜à_³r,4Î�‘¡ªSYÝ9¯&#³h´1jÎÎY%îIØbäD92ÒTe'ÅÈÁwãƒ#mÑ<¡EÂu´WvÜʧR©c.⹃ÒÜpmì[¹æ…€¦3ñl:)Ó·Ñ’ãT‡\¯Ä­Þ¯ˆPq¸j¨ØüÔ34+¥-hÌ„(tÃC‚"½l=}è–ôiýãsÃÈÜéM¶ºÄ¡ŽÐ0‘Ód€¯iÏåÂWþÐy¢j¹¼Ü Çúí¬Ò­è“qi¥S¡L'‰È°v?£†ïý0Zà!dÆ=Ñû'[ÎËãSàÚD ?”ªç=h‘™£Ë-âÆι¥(Ð[ EÌéa{¶nã«ñðƒ_h Ôi7Ax^–y‹Å…=>N7tîÈ•¢,×5œ)£ OÎo¬‰LöÔaHGU)|×àØš÷ÞÕ‚(bzG lõ0† Á¾B.jœoÑso5”Æ5çɹÅʤIÂ<U@ ¸ž½"g©!¸ï3å•oO³STŸª�*ß±kÛz4Ï"–&içòÁ±9ýû/ðµ²�¥õUm»bHB÷¬™h)·n´a ÄÊîͯäQ";1–Ø0³ª/ÃqòHPó…ñ¨>¡ÐwšMeÒí}'(ƒCS¼¢O ‹+ ÿ)σÊúäE¬ÖaêÒ·“š‘žFf¼9¯²@@9Rqî³ýܧöïÑõ“sê]€rôŸXÙì•"F €®:«ÂAxìñ§Z鮕,lå®(�ýHŠp»1£Âƒ\ˆbùšmR+Y25ʵG�Ї—¬þnŠý'óân¦6cÁ¸»ÄŽ‘–zÂlºµyI¼K’4ô´Ö ½§ZÖR„ãf×rûÞòË@ºlÿ¤ßOÂt—VSÔ;= FzKYÛqö8ÔV¬Llk'àv¦I3‹WÛ™YHrÓ9¹9¥-o§ÛŽ»K<]ú ×!¶Gñ^æ©<ð(2Œf¢?¤ÜZ2H̦è‡óþÅF­B߯LgÐ^1uŽãáØ«?¦!³P€ØÁ X=18qWwÄ™RÅèd†ן(ô\4‡AvÜ–p`+DYâ«Qbⵦã3{oâEùÕz<›£šªÚÕ¡kŸûy©Q÷®q^‚Κž¬ŸÆÿ`Ã5bøkù —–+“ÿðC‰b4k­S†‚ÜvàXl¼YÖ¯f•Eè‹é‡JÜ>y®+ß'äÇ;dož”ûs·åbêÝa‘IUY2h ¾ ­¡§Õ@wû©¹ø‡à¢˜|ôóÐ;Ýe|FËœöTf§+1ƒ¸÷ºÆ!½,6/>[b<ì'IéoÆ+‘Õä¬(„äD‘Ñ ÷‰ÍlmM‘œr©�Šá…òD¹˜QâÐÖXJµ®OHlÒ)ÄŠÆ` °t}iºŸû¼jV*TdZüÉÆ*åÓŒ¾«ŠXà¯LxéÞ—•Oƒ•#Žk‹Qᆲ ÈÁz'´ÇwNê$]8–Òç¿AiG£<o™Ž»¹6@±Ub¥ SÕãÞÑï³!Ÿž¡üß‚ñ=xN\cË£!jº Žì#ªl²6 —óßÙÏbéL<«{ÐßL-Òb#¥ÒqŽƒÒ·ñ©õ©Ÿ¸‡Ë§]L¯¥¯UQŠ€ëçÑ‘-¬ý›™°¿©±§î"ÑMå{?ÐÛ G'GçºÌ=Lí>Õ?;p9Þ’¤.œ$QÄ-¡¡£{o×–†€3®.ª´ƒ‡øÌîÇ÷®DHn4IbßüͧŽ N£SÍäÁXsy›+⨅9?š-ÝšÒ¬&<Ç^Y±º3Óæ�ùÏóèæÈGTÌÔÎ3ÞšŠýÅ»Î:"g3RTTÝf7q¦!Γ7^z(Zkó@›q\»:¦({ †Lµ)¯çæ…⸥Šrjé¡àCœ´YÙωÈI¼q¦í‚Mþ©ŠèÀQÁ²Úr›Ã¿¯QàqdÚ™K1uìã É„æ=($ë¼õ¤ÜŸÙõC…£ ödÒÛû—>÷!5Èd±ï>=Ðóf·v\ž7禶z(UY…!E†»ŠÝ¹à™§§¥)ò.E§ÈšMªÏç~ÓÆAÒ.¡˜v‚ž0àÑ„Ûc¨[Vz¹sÊæÛ’AøÉŽ6É\̶>ßb¸ÄÖó56ÝPÒApòz9¢ÐhEgŒ3$ýO ª¤Ì¼v5íþªÄ«)¨ò“l?êá|éé÷léësCìÒ‡~Ój�¡ôï3¢´w£ï&Åeá˵²‘9ln»£s¦ »³”MÑþ>U‹S)ä߇çös©¡viŽ¸?€œ>9Ûð_0Kòrán—Ió¹×–ãx¸'žo¿iAûTDîYóêØ�<ØE"@iöCyæ÷L.[B:˜¨Þü<{`KKt³MóGÝÃ@λº‘MŒ3_Êç#};7NÒÌ𘗄ßWÕeè#Z)1Ý#üÖÉTÜÁnðçéo=²<[Tô &ÓÃ+ë=Åð¾k:79Eîbâ&ÝQ‘ûÌ«ê?‹ŸéO®{þ¾·<»„ï6%ÿ‰oqÞòQHûÉôþq˜]};v­i´Ý™Ïz¢uFɃvi{±Râ bR ïv•·Î”ï{¤žÈ0ç@«s$ýÙÙ®zöuT乫#*;–smVˆzµÎ]´1nÿHN­<âéÛô~;]¥ñ¢–JÓ‘‰ÕQ1ÕÅÓܱ̮XùÍÒZh7QGÕ“eA±v›Jn9í-|è-óo~¾uNN—•9›¢`¿ŠÄ:HtHñßáp¯÷fáÍõÞ4¼õâÆß´ˆýQºš4g[…5¼›?ÛaÒnàýzï£[±ø°6Vpun40å ’š•vTüÂ]¬|@Ô ê–ÎÄO8ówd­b_¹¿ËjÕ¢]—HC°¯w‚æÃ<töÅØQ€¶j9eApÍ‚‚Ë`s‚¨w×›ã‹̆þ«q'’qg¶tCË^GÐ÷„«Õ–iL¾t\fžj>|º¿ÐÑ'Â%ŸÇAgöy¿ñºxV…ÙKXîçTA%8)#ài¾@›¹sä=² ÄVÑuŸ;×K/ƒ§]þ+CŠ˜q‹ëÃÏ\ïúAgsw¿ÝMÛ× xq‘û#”ªŽ›ˆBë0xæŸÛ^£ô,جÞsNãýÃKÿÈ*õ©’D(u?yÓn^êùBÿ[¨þð÷ÂßmD’æRçþ”*̘K ÓÄ>äŽÕàEä¹öé³õs.m’” ¸z ò{”V?f‹l® é? }@ŸÊ?§¡5Õâ5Ç=Ž<ƒ—]ÌÃDÆë7ʼÚþ@ƃY²O:yaêdûX,‹ÎMºëǯ[ÍyªµCè4z}LÇúúÛóq‡dˆ g`õ¾Úc±wƒV«o:é–ΣO:TxÞšH@Pg 4T-(ý4}£y<œZ}¹ÃðÄj4;ªàú·å³UÕG éó¸®?ßÓ‚@¥ó×ÁGΖ@ ¬Âë0ö†`Žó¬fHüÄd*3>—²›%ÇvŽ^˜õ|¦#Â)ç𧮕DfÁ`·7w¸2p Q¤€£+ŒÙÓ^u:йÀèÔƒÎ]äéðÕ±Ò%Ã5‡8¥£Üëî0¿NzÖôë€O‰[ X®!¨?p;ím|JR,wP¬æ4Èt,ˆQw‹ ã{)3”�6nm7ѳ†ÝäãB!ÑŽ“EéBSƒ­Áò µŸ9~Ž".…WåðƆۘKºÿ#ÍÀ䊴‚¸’™ÞGî<2ï° °¡;í2y÷ 8w~¶ 8tæˆ:4”ÊlU¶ ó½ˆf Ÿ`”ô÷ NóÊDÎqß-9I‘§ P Aˆ7Ž{ÿ¡¨ª@©§ï%gµ¼•‘ãH™ŽhD ”(gAoœýñyjÎÿ• ‡:¿…,¯Ïªh€½þxY¾ÔÜZ_Îôl)Q¥lƒ•Q$ƒËÆÛÖcuÕAnÊ0(,3%fzú„Åé¹áNó©_}}Q§DE™CŠŠ³SŽ9ÐI)ì09Éb™eÑ«ÿI'¥T/s2haNgüæY=¬ w´°»¡MªAªáþŒÐ Éðí/È]n™c¨Õ#´/ž%†DA S÷D¡ík8œ9)\*Cyòœ›mNô%59c¤U¿C#Á8–ùb8ך89ü‚­ê%ÕVpTËX;&2vÛˆ ‡so>ñ±»òT{Ô2+=�i‚õ½�§AÄ®&ÄHŸö-&w™ež€,z;5fbµ×A]Ùö¶¬<D’Õq{}çw #Ø ÒLAÑZù'@Ôíg7uÿ£Šu”x%I%üÍÖ ÿzŽ!”ðþÙ楖óê$ú„ôˆ‰þo;tç±Ï™F¼º7lTžã3kbh"ïã{}ƒn6R¸Ø"qcPPgÈÑoYƒO\¯Åú„V[Ý\x­ãß›9@R(õÅX =§† Ò ²ŒŽêQ¦ßÜa·/„Ð #_ÝŸ² ÏÞIa,yìÜQ§fÑR>#º¶¯JYbb–ø§0t“þ [ø•HžúýäL³pOD€Ö-24qA¿'¬Ç !]øKR “Ïp3J5øVV íN<úwÚ^•›/s+­ÉK*fÕ;/ÐÎ….±© }ËËX_Îj’0¼’˜‘±³b4Š|¹S¸Då&¨åFÝ°¤’Ü„ÉHöý ’FOnøË2»ß;#ÒØ`|0¿¾F€êvÇÇWõ…ÛZîÙ¿$¨¡h+ KÖÕöW*T¿Ú'©“[g/Þ=%iÉé_c€ŒÑE§5´)¤ÈéãÊl ðµ)lÎÐXr4(/®=Ì™Òmdbþ¦ufXùnì~ ;^nE “ÅTîË))ÛuÖbû‚(v(¦ãJ¸ƒÒÉÌöǨ@·qPmgçKËÑ#Ó¸„Ö.†jW¯Ò90ÆÎSžËC_É*̃©÷‰keeC>¶eÃW×°'ƒ«×·I–Qûª¹§ƒems+®ù½¯¦úé#ÕpÜÈÝ—´UØ÷ÍãÙnÈîÆ#ÇöIâñ>Á]jçî‚fÕ²À÷BGu 2¦ûk5QãCöK „¹é“ ݶ*s‹z¨UHÕ*~[ä6J3ß³ä ¡6ù(“ÁýŽ§´t}6ñ}–Oé†Ç¨£#ãó³u.É,{fÜ(ž %ÜÂk�QŒ;*"碭ë“»kü‘›»X1‡QÈÇ×t "'v†Èi`¶‚2Aóµ,̃Qå¡Û¸kÕ P¶ó}*eÌî…ä¬äZY~®ÎeTBåÓõÎûŽBÅU¬Œ­Ü»'A¤Ïáó¨åÔz a°–ê=>è¶m½®-‘ ø…7ZΈûõ°‘†ÜͲÐÓ‡¬?D 쟆¦ü´7*B÷&ÆÀêt™XÃúV1{}INOñºëw?ÿýˆ!‘?°*”ndó‹U¨‹Æ“(¶µ‘Š4í›è8yCV.•P¹†¼ú¶¾ü¥ÿu‘.#búüP·¼8ݾ«¿Ü0׶î]ýý̨‚înÚ;TiÚ“RdéÛ-ÅÈõ§ÖBòÐÑŸ7;ìžÀØò;Œ)=RW‚P¹! öé�BHT|uŸã‰{°Ói¾&o¢š ¥ àÔz¸@k!‡É„´…ßSìxÁÓ…+(¦]V‘ƒ#';–qñg!Oó¤Mo¹]¹Qã©jcQÇ ¡&Oný—JÀÖ¬^@9p†´‹>[*ú½5àˆ“` FÌ8a9m¯þ§ŸÅ\á)Ç:÷dÝX^sÜCí»q98þJðè´ ÒÖç³TE1U©þðŽÈnè{î„ð§LéWYŠqs¡ŒT”ÝAM(¢dáNyçÄ}Û¼2 ýâ†V4¢Y ”q&PÒùǹ––:d¯¹ß£]Åo§Ýw÷·eÅÕtoú¢>?Yr/Ötž})Κ]%Ì g÷GÚùW¹ƒUDzΨš±œ­Â€ #”÷ËUæ輕ñM¡ºíÙkñìw“!)Êv~Oó0*´Î“ÖÑpÖ¢Õ03Ô*<Ø>*Òåë/*2‰B{‰@³(š A³{†sqïåkö·Ö(Ëïΰ84gó-†8q•˜ˆ5²Üiiñp”@ôY¿Ò:u‚ ±Q˜Dì§ó¿£ÃV[°·pØGèk`lÛÔÓ͘gmtнv+ õä ¸©I¸Å ãÊÜ Ð_‹YFÔªÌé(å¬nc7XD×_W_Ž7"·–µrÃÉ‘¶ªš�ä ã2éV)Ëœµ¢-W\}5[øhdÍÖ÷ˆï%‹üÞJE¨zJ? tÙw¨$šºj±=Oa×_Tý¯-l#]/hqí˜ ƒ§þÜe/|Óôë¿È¸Ì|ã,è'**Ëó&‹‚ ä¶ï Ýæ©Wæúq‚�j(6•ÇÙ{@«Ê×­ý½qrì8¹b¶„¹I:kÑŸ—Œ[…õEç\Þš™¼ž£x³ÉÜE4T²'³w¢qoÌ Â,'îb™@çyèqÅê`°;E‹º÷`Þ’(KÐr¼ëîˆ'²í=œ«Èmïn”‡gi„Cúˆ¶æ ÷þ‰¶ˆ²pÑ.lõäÃdiÚ'‘‘Ë÷QpQ¢òy•ñFþÑi…“šº½LKYd$oLIê½?à˜Á4¥Aòù¯ÇY¢úk`ÖŸF9ñãZ÷ÝÞ(Ë»,æ)£ðÞº.>÷oÜÙ¿d¿ÿï¿[UçéN‹T’s )ÖnØñ,æ4¬ëóÈ*`—i>_0þ¡ ·ÝmðïÞ%ªs½E<aÁ©2ȵ%¨Ç¾kåè™ÂWâAú Ærwt\mì¹ÂÚv5ún¦Ôý`‡Ân©=jg{/‰¯¢DT¤RÉ[N½Á‹’q›'A¤¢]ÛÕ':÷wÓ[j‘„¾&¼hÎÀ%+µN4â®äù9c . œwsjiGR &Á9ªV·=0X?.3Ül‘Âú‘÷ï]«æÊÞqÄ?kOIŠj€a`å=$Šÿ—Ñ×)+† ö5CûÌ ¶Î] sЋf<˜Qlº[Ü“Eaœ¹ØÉ™ž~j6cs¬ÞÊ3C—|Ùn0‡¸®´{ßùE‰Æ€38\Y¯æPi¬„Tè,}•[÷óV;=‡ç"Çiî&ét”I&½.Œm½Ùt£j¸•¥M®˜æUÛ)‚Á¯ÓÂ<»¡­@ÚM{[‰8Q¬÷Îg€î$o©ãш’ ûh<ìMÈ”W¶cF‰}‹‘ˆ])ŒÒ uu§:ZPÒA"'bžr¾lK¹FœÐÝ}KÂÌ57…¨yK$GÇÁ•†9n¢¡ÝXràýËÛt¿L2ÏÍQ˜·Aþy¶B{€^l@ âcU#¤»ú÷TÜDswq­†LЙN…|¬Í¯[÷`‰}WMT¢›Ó4Ÿ¦÷çöq”ú„ÚKEºp«,M7Q"æ÷+°,†¶ï6¸Wõ{ëV^ÔyVÊ:8ô@kô“ ÄBDŸqÄI7þ›B¢Q^d^ÕG1eÿEÅôVÙK¢”u8›sÄ”}­'A™vôWͧß•–‰½µMáÌ5ä�D÷ÊÞàŒ0›9˜ø mèaGã ,$L"I:Ã8²2”˜^~eyôHÙ¶d‰XÌJPQuaÖ dÜ…U3sNn›F¢_2ÿ²ü¶0»M7 µÕ3xŸ|©96Ï’ö½[ei7‘•zYÐäG½¶Z£ÓëÉ|ä¬ð[pµ©Å­«§(Ÿúà(mð+mØÕTœz:É¢ÆÕA´ñ¨7 §8¬óÇüï‡ûø½uåjxõâ}FVe¾½ƒ¡ÍS¿ñ8›ö˜y¡zS›*…ˆI³’Ñ&BgüÓÕw–À&²äÙ¯(ã¢{Ÿ8g°óŽ'_Ò7¶&†zs{q›ñÒJî04-ô€•Üˆ:„Àêb ‘wfv±›±F ǘŠÍãÑrl ÿ7x\ø@bôTà]Ìe†¼Ýò;n;‘Þ§öåÀ¨*õ¥Ø£!ΈzkH1!;¶?çöáp}§þÏÕ3JT%±’ð‹-=>JÙ*±žwÎüÌwˆž šá°ÁL;œm­x|Å0™Ç8’µÑÈÂwTôBCwgaÍ5r Ç®˜¤yÁéòºê¾œ„ ‚Ï¢X´£»^%¹SÀJ̾@¹Uñ�ù}+† Zh;ÃÁÖƒUâ–v.~ßiävŒÇ¬9 WÀ²˜âB¡ O_o¤?Ój_É@‹K˜ýoª¤šõHŒ ? ùÚÖ+=¼f~e‰'@ÃÖj»M$G«gÖQÃ)¡±¿Pé‚îxDÞ$‚¶ÊMBß».σhÛz†áuël¦¦}Ç´¢/ÿê!±8öä\Äd©O)©´ÜÀf¼ (aAŠ.ø6X¯;À9v‡ :ÝõïG›3Ämk_‘˜-TKhŠjI=ÛÈÞ@ñß’*‰ Jfæ¹1 ïÔ—/."ÉŠ0‡¼ÎßÙÇ®…Ü`J oͧ£ŽÓ¹Æ¬S™yt«7®]¶\ùe(¡«-Ö»Eˆ1£C4ñä©ŸwÈÌ®^®Ü;=, QS]9j 3h‹:U©¸ @'´¢_úÒ¦ÿÿßô!½˜WbÔV7Rþ–ÒNÙ÷Ô2×¥a`$3“ú쉰vš/ž<ˆ´ôÆùið”F4ÿ”°áf¾|ý=jÏ󲈴1¹OƒÔZx·õÔ}$@D·¦^­”ä°†%O³å~ÒŠ©}7ý0MTV™G¢°j(b?³×I«§-xJÖ7kd—+çeffÙö{“Š.¿µ½5ŠæbxYPfd“ ֓쎠2ŽjY±9P °ç:Ó^‘ÐÉÈØÒ}Ô¢\ï#¤…ËÏ£*£uC%šV‚Ú‘¡îï}ÊÕ µÑ}Xý)):(1Šëè]>šÓ°©Ñ2•«1ø¹ €‘{VP3Þ»~?W*( ‘©Æ]ï‰'LiCïƒ;ÓÔÓ®)½ë =, ˆmx ò<Ò¡wLq†ÞuÓÕ¿”\­žPׯKtY~M8Ü3º=úY9IéèùÑim{¿ÌÉ—7óJX«É[åÊ“6áB£™R0mrÇÒô ˜´ãè+`d ÷\Knɲ¬JÍÕ·L%õ=àðÇüÄA±ÝxT\Ü™RšêŒòݺþᄲiðr˜ãù/°÷ëôUY¯}…UGµ6ågc†ä² þЛ¦` ;Ê}§ß‰A¶ÈfÜm4Y¶Gfºñ¬ºMñR€"YQÍ™ï]÷¡Iv¹WŦق0ÜŸ(þwg@udþ³¼éC]¯¸¼–tÞ¦Ú‹—àÕý—ó{}8åáÂd2„. ªÙ:‹'*ak€ÿËžçUJ6GúRØE[Ÿ{0>f·àôÎü½¢­_fžJ=¥ëçlXÀçjêqimnô4˜c‰|u·}—i¿:ÊÌ'oêˆóbé~fÂi„š)˜[P›´'awÒÓô­–ÕHp[SÌøѬÅ|Ãh}yÔ:p³pq—HƒÕžnX5ZØ&|­'1œ‘9»-Å7&Áï¥7œÎR14†ZÓ™–lÚ«iy$Ï‘ôž\Uºå"ˆkJg¿Õ@ˆ,¸Jœµ:¹+Ôè4Íï¼EA‚RVž£›œ4rÔØÉÉßÕ¦qåÉpfì+<¡>ë7 (•±öñr‰ß4G+/×d`\3UAÔ½D…¶Iqέ¿xsß@œ‘F åtöð(È»+Oº'Âì•KS–Õ@KnÒy=ë)Sd牙?ý‹Ü>Ó¦„üª„8Åï= †t×£xrø•§Ð wŸ6ˆ£º9EM|VHj¶´’ÛîfUÛW#»¶¨p¯ëÝ|a¼JÏuѨÍÑ“…Ÿ¨ ô†E¿HxÓÌ›ò1ûˆ“Ðíì=àuy¡cÑ'™g^yNBìŒs.‚äÓ2ˆ1ƒ¸@øõ†-ñ(þFEäLf¶lH¶&“Åú4î6ÊS’±Õ;ƒ­8)¯ŒI ^ AÓHÔ&èHo·]«Ó‘_Yd•'VÃCÛ3z¶?gO2„'¯_óâ®ä‘Â¥š‰Aù`4cnYÜÕnø¹ÒsoýÄDK!æ,ÊüÎ8%ðT8t½éæ50Û/üÖÿ…¥ ³™EO»³ŽusGœû‰LwUYv¯x>N0q)[UÔ-à–q´5¼ïú¯Ifóæ‚óÊ3åÊFÃÁ^ñŒÔÃw„F=iTES©È@:Äùžx’¯�]atG‚ôhQZUÍÒcõ¹aˆ(…„ÅŠƒFf|Þå{=+»’«Ïá:¡?âÓÏ3·õ¿tím0e%ݾ~®üš¤þ3€<ð! ²Vsànk:¬j›!z«¤s÷Ò6V£Ð‰€®Ï.:sï ;ÛÉC¡·4eì)³Ú‘zè”zh‡eãè=ûÝ©wj‘@ÇT›vW“ÔÜõ#ÑkâDiþ׫¸{‘^#Ù[ÉR$j(ª%Gi·¼7—ýâÒq‹Ai‚¡ë“ÜÇ40·% ÊZóÔ$ºÖ£^×ã`¤o°[ôí£ÌÈí»"ˆÖêÿžLs@/ç)N”øxé3 MꉞpI¹ú“ñƪ9 ܧk Ø‹›~«J"‹¬-Õ’ãÒ°míU:úè,Tº|÷œÿ^dµƒÄbü‚Ž?>®Ö³?ŒGwW¬*/åg1½© ÷œµM�K–³æ¥Ã$½ë‹{¢í¥ã4c4†!½ñ·mOÅùÒzF‡—O £ýwõÝbne¾›EÌudµsUÆy MQ8ä°Ú’S^õõq«2÷z¢Ö0›C¿âf¶±PT@{SO¼ir–êÔ<6"+îmo} .ȸöì{Õ¥î]95¥H'ŸÆ+zh¾¹½‘÷“;ó)íYV•�¦ŽMXe|å‘G·r”òÏd<9œôÊ`Rl;I ÿðßtÌ®¾C®œÔ”x¯¶‹Ï'V�ñ®ýèxþ%ìáÈcaJ�è`_ƒ/oç]z9Ñ; ÕÀ²›<K)Ê&Vp^I¡ž•ÏÌ+Ýì#5öƒÝbÿÆÒ+…“ã×ÁiƒúGîÆ™êªä‡:]TϜՖJðþgA;‚‘0(­šyš‰'ìm'ÄGw"ñ,rpPÐÛb¢¢3ñ$)™OvèÕ‚;ê¯ëžiÙ¾2*`*Éi¹Lj±ad~EN‰gËïÈ0–á•pÊj¤’ºý±îÈM4ÛÒ&}„äÊØÚ ¥tÍ_ 4ZiëH€å€ÃS­ÓQWZ#G1 [e0çmb¼AýÒg¢_÷ 8+Š…¬8ª!:C{â‹’«jÔìŒ�ÃS÷ݨÈ]âÃÞ&ykÙOâ¿{ÆÌ‚óC›‚.»Ž}wÞMðŒ ±þX'ÀúF"^üÅoO±lrb¿ ¨Šp9°€qQñ9900mËà #w <é~˜zöÒÇ(Î|)¥žè”GíƈZ5‡™-¯Œ.Ÿ4Í:òy£<úWSš};d”ѵžVƳJ3æMý)a=I| å²0-|kÙ–½4aè­u[º�K]… Ä_hŸõOt@ ÑvnÍ?—~YȾ²îð<Ñm ¿UP·„!J+qä v8åhØŠŒ·Ùé~±”VÇQúÕ|ð›iÒÚŸ×t~MʒƱ8͇¶Îü¡c\±pÐDÒÙÓVÖA†Oânî8À“2¢¡2R¦5÷,ê³lÉc ÅWA¾\u¦âTµøóµ‡Qç~¯à=™ÇeNÏt¡G[CKøùÊ ¿ÊÕ#ûqrßHÄÑe8ó€ödï²´z¡¹8ÂómR&!‚øÌ6ñxZá1x%!ÿÇÝa¤ l‘/ÅœâÒ“Ð(ÙéóïäXûÔTúÚ^~8ë~TéUž�PÉUä¦ ªVmZÁ.lø2Íýæ4̪6è_sôxÞvËž½´åZ¬­r¨=Œ`Óu«-;óY!Äš¯˜{X^”²íÄ—êTCq:Ÿ{¯i‹CXhNUëïºÐQæ«?ÄiÐOµD&x ±0~’0Ä›®_å]ùzkUr#À9Ó4È{L´bˆÉ’æËǪÐv>ï!ü̇q]wòÔ)AðDºtw>{ßúD¥„ÝiùWâþL³@{±Á40ùTÜ9Ðí˜ï LŠ“£a<±Ø ‡4k¢O†äXBŸæJëˆeù±tÒ)RL\ ™Êî©h /˜{6óªÆmM[ ù´Áy*}d;Ç|/ÍÏâÉD0î©À?j¨éORçKð Ò–% 8¯æÜWqðÿÔóÜýÃîo`ä³"µi$ƒ~æoLdõ4õW'.‹ÐBø@È‚Ý4½JÃÕ@øPw”y“(\x8›‹ úùqÖá°f¶Tœ<>–!3@h¡‘hk>çÂcgrpíkýNUÓØÃñ„ÏÒScªdnùôp=°� ^ÈDè1è©ŠÎ9R—2‘Ëö¤\@°ü^›Žjã]Ð kq~²Ù‰@,¯ D– ¦†™Ýlaæþ£ÅóAëžR#í,>æ [¡âH”? 1 O:p\ƒÒ˜ ñ4Íê3•ÑIŠCcƒÒiPãF©MÏ»A¨t‘¼“FðIˆ­þ1s¿fz»ìh}ëÑþgótn¿˜7ŸëVbð m¡Ô±õÚ„ñH§Â¨œi^+"BÕv´â§(Ù.xß[ÙóèÝE%E3‹6‰7Àú4‚¯å'i¹Ú„üµÓAáy;…ìzŽéàí¼ž wŠü‡Ø€»üÕwÐ$ô{õ´lZØN'SëéÞœýºÖ òþ,)Ë2°!štö}×~|éŽptttä møêpU¶>föMœ9Ò#ÿé(Oø™Ù‡û/hîÌÿÚºûCp&"±'Â8µû± ?ðWñýo3°[â÷g²‡ÙGÆ{=‚£ØáëÄ› ;7™kËò |hIL¼ù…¦TZùÂé°•¤t»´òyÈ#š®gÍåû‘hE\�™àº(q0@ÎØBÙÇåÕe%?YX¾â Å™SgDó3 6}ÁTUs~ÀÁ@»7@œîÞj¡¿À:½¿'m=ìÄÜzsSEéÚÚ”Бþ—‚ñù>„ä¼äìÒj¤ïy'ûL}¤Ç(µJêM[8+<I³ÛF:DzZ'?µæèq_S¦X‘Ò³<üTAÜYß’œ5™úÐåT1P{­;î[ND‚­H)¯ê¬_pà=¿¤µEÿ©Ö-âVÿê\0ÏÆ¢PØÊO!!ð$V7Ï¿mû¹B0†zMTµNCÒ§¸i…òßòÁ·˜á$Ÿdm& o¢;”Ú†õÅÍσCýeïýŽSäתŽQn\ú*$>{¯ÇášûÞýtÜÕÉ÷¢ÿäþä bšé ª>O–v4«Š ó¤ï»CR½¹¸±ža™H|Ðq‹lÕ¶"š&£#n˜Ì¼Ý+Ü ®úi£øV#t€Ô=ZÂêÁÙh¨ôa¡™ÁǺmÎþ¿7ìr¬¶™š0 ›½Ipf:ƒ.T‡³4ÌW7›É#âÖhÚÈ ¯1X\55å)t&$XÚ"˜R*»ÙãSˆÑ.ËBNÁq×Of‹eø¾m´ä 6SÝc/MVåµÀPù‚|®]¾hì;S´­gó„®ûÛ©RK u¶=™†çš¶(šå“I¯ {}Á—Ýáƒ\ºR˜­¾w'ôÒu¨² h/~ûp§suc ‚¡¶$áëW8¹ºÇÎÛOyrgS©JlVm>ð6r(Â@ØìþÜ EØ- ²U43˜bWï­.”š¸+@ˆFY÷ùÂXaøÞäAd3)ÌX<[zª)¿ ÚõÆã5ð¾ð9‰(›1´˜'çy4 ‰\´(:)`Í…íu ¹ÐⲨËỹ¼V­:(ÈÉcqFÚC•­T˜ä¥lk˜fÒo8/œî°°Cý•°#¥üñ8›Â¬Ú³U§BDÕÇ?¢È†nõ{Þþ½ED/ñƳ ÷èOGžá6Üö`yèþ5p—K¡¦Èãµ²¯‚ÂÅÄ )¶Ñö´²4RWè—û¨«,ºp´§ àT=kŒžEðôû훞¥Eê°ØgëTKÑžÝ<vfªñE¾¸õÿ&tmZ�N² ª.ššÜ¨ä È„ÎÿA($a£}Jwe™ÿWÇk¿ï÷GˆíÜ™ïéØ»«Å�­J‹=õ J ÃFÓs·ÚJc¯¡I%:wǾ[ÊïÃãè�2e†ØÝÐSžÙ!|ÐÎ0 ðéì÷ ˆ”Ô)*\gª[$›ê©cÒ÷ÝF^Â(Ô~JAÂè4É*æ®T/€V²Ùê¯{êQì#›Øb ¢>7‘Òñó@u­âôšž£+¯;ÍGŒ¿+êÚK{ÍìN¦~À‹ÂlѳÎuŒGâ8«]ozÄCêõ^™ž’¾jGɲ8X7`]ä­z~²Ü¥°.¬Xåós©˜¹ˆl-¾t2MªLUãnmáìãa³ƒÿ{„én»ì­Æ¼V�“¾†ž}}hgOêiGHÍßjK7õ8º7kØ O™«u?.ÑúËš"® _*BŠþÛpqÝlüm}±(AŠ�Bàñð8/ι*öYδú`]ZVAe澧Ö-ûÝû¦iìùÐsó:Cñ²WócŠ @ ½@ç¨ G¥Ø$cçÃ×>ƒ¹XwÒÇZ™°Ýú\¬ÀBŒŽÊ<üqò*ôœ/J,ô®Ÿ+]ÇQå¶Ú]@ÁQ ª}Ø8ý!;ÐB•@Ñcù*àí•!¸šy挅ö_¡Ôÿ¾ÛÔ+°þvì7m‡^—qðgW·§Õ|F IœÖ†Z!#3mâÁ.¨˜j)5J4á{Y~÷°Í’2O g1á£Õ)_ 'ˆ.'MŸ—=©÷ ¼ŽÎyO(=ü¸±x® ñ�x/Þ.¦Ì×ãyé3‚kÛAÕ9ªE¨Æ)±³ ê}ÖD¸weá«ŠDˆBcù6]"Hù6.5 ÿ¨‡ –µ{b›Cð:Êtf…·%ŽíŒ„Ó¯Y‡ÖN‚†¥Œv«úrËå´ù‹ôXD§( ŠOm²”¥Ä€ó[]¢4qí9ž>ÌßTt­0ZÞÈ9© P¤ýe×ú×wæTÎ^D¬›: ’ÏÑ“Öá¹ üCÌñS· ³pÿ÷LÓðØôí¶-Åóï£9ûª\�PƒGó÷BÖò›¯ÝøÕ3ná†ðf¾^HuSáe¬¹ß™)þö`Zï?# qæ\OKý† ô¬hütc #ì¤Ã9#jšÃ¼üf¦ÿ›Qû±*³A«‡t)\[’5{kŒ›:þžCÈé ‚pB·ó2× =§ˆÂ%ͳŠyÁÎtü0ȱ6HA4ò°LGÕ)m¼Ä¯%x|È [{OMhm›@p«1žm® ÑÙÔ®½XTŽÅ@™rB‚ª;ï¹Ùy—šô…YèswñyϘ@ Ö2ÆÇ›:G´XFågg‹³V€[;Лà 2´þô<¨ã€k€›Ø–yË®S¦iuÇ6|ñ£®#™'%Më³™(.Öov»Ãd=_`ØÒ?ÓéØÿÐCî^³¶C¹0‘j…ÛŒ3â6-&•ÉEtAÞŵZŸ·xø×#©hq0Óº‚»ÖA$r ±Öõ¨¸iêÚ3*âs®ÉÖ¹"4æý�ÖÚQHÐùêF'»©ŸóúÕÖï kŒOG¸K[ó žÛQMfÛÜ ¡5à.趘ÒÂ}¢0·0 içð[+nf2)5’‚ÆüÀ³Eþz‡×è<Ïc1u”³æŸ'g½pD°ž×ÈÑ|)w„>Øu:D©*žò}šjS¤¾´¶ä/nátW§ÈB³ÃØp÷†#ïÖYÛÚÒ #ÔÀÙH |ÌùNÒ…O1¥eð”O?/^I¼$)ý¶[î{AÔb–AÔ©6{ÀUâõlÓWL!·—ñc¾PeпøÖ‡ËÆ"vb'Æ#Íh†Då˦È4Ë_?p;>¨"ãêú'fn­ìÑhh Ž[•¤ÓËØCÚåÂл'>QXúˆ¨n­sº÷ÝÖÃðC£÷²:ïÙ£)„ãA«Šå†ª$´Ù†?ÅÁù¾± !W°µ¼ ÄyÚ"˜s™zÏyà•îg^º†ò´$â k=»�Ô§ZèŸV_’†Ø‹sQ‹kl+!fÏîqÃðËž†žÔ8skç|ôIç•m¢<s¢öLø±{Æž-â°ä�frŽUqªùþÐÝG½ê¬@rðJ«šÖà¸ö¨XDhуÚå’ÿ]ï É|Iã0Ö:uj†è`0<{gÌtê=+{×d)×zKí•äªºO�¡'0ÙîoÌ$ÏÕöº„.†”' ŽcÅSEgH4±î˜Œƒâ4pŠ+’ïs »G쉴g)èªYÀψ¹„J˜ÛÓ‰<ý>¦©˜ñ¡“®Î>m<}X®wðfHètèÿÔ2�Æ[a)Ò±GçõáËLS–ßqW ó">|PΕ?”›‰ëÀôRÊþ¡�£GÕl”— ÝŠ*ØnèÝêOçrË`lëLk¡(Œ#gjîê¨àEÊ0wŸ”A5ê¬y¼Ø8»6ªB[–ÈxÛ!Ï×tä#v* yôÔöÇÝfc«”¯õ±Ï‡* ¹+©>ɨ*Yîæl‚ŸN ¼ª…îeæMŸ~ì ô)\\(=Þ&¥]¹uSVœS§qŠó_:"XN33®„Ž@[ô[§ê×9ÌéžL ¯ÿi.ÿо`Ä{?{¿o)ŸÞlžI}6-ÞÌàjŒÿ…(¹Àª }z¯öØ ¬Žª¯¿;÷Jg"§jww3Œ°û‘à's0+ëþ;÷´òM è…˜“ód*ma_ÅÌÔÈ9½#ëTfW Œ¡£Tª2SBi–A¯¿€íQå¢4ñˆÊ]]ã_ã*ufÛÓk£%, ¥:*Ø,pݙޥ_½Úh“Àm›ÙظŠ`÷Ç6Ñbf«a&°¾Ûý(²…vKœÿ$AÙ: ¸ðÛ $Á„s> S®(ó«ï®vR‘™>³ÂþÛ® ;Ñ_LNØèÀ%ÇÍPp4ÐÌH¥“ûΆ€0ôiúsAl•ƒP&HP¡%³Gý-¨Û»Ó*|éÎ¥Vv©¦{’‘ÐËüc𷹌s¤K¢å¥L·œòÈH])~ŽÖÝ¡§´®Ùèü&I¬#VrçÉ;Ú/¹‡"g¸‰è.4+ÙG9D™pˆ¢-2¼'º`Ç¢éÌ“Ž,ˆ,YÇC=M,º3ÄäOÖ†ñ€œlù/·9oî›lFL×r;ˆ®îäø‡Äªîz˜/<ɽåjÄ^Mž«†ÖÃÏÑi¹ŒNƒ¬RâÓ+'§TY×N7¿„ÁÎØc¡ã‡"µJxæ™`Ã,3¼ Ft¦Dî¤À˜¥Ñnô¬ƒ–•]ÜÓªÉÜ!Æžf}WÅFáѹ7tÄ,ZqË¡$t¡ÆUݪ[ûþl,tFûcl}—0ªÄg+T³XU†…×_Ûô-%!7fxînÜt…ßIÚ8ü,¿hKJöLÇWÇL¿q¡÷Ìt1Š"çÊÂÞP•Èz_ƆnÈi¥7ì©'‹êøKwˆ–Ȧ§u“Ú¢b‹t¼ˆ02åuÛ‰[·Èù—·ÀÙ¸ŒíXXl6Î5=¸8©¤¥V�=è£`{Þ6Á¨b_&:¾ÛU­ç¬‹jš‚ÊÇô}BûÏBÆßÅŽ{L`wrˆ2Ó÷í V\Óáf,Ê‚ö_Á÷#WŸÆ†#p<dAÒXGñÄŒ0¬LÇ‘¾éÅC—ÇZ|ÎÍÚ)9§ˆŽ€¼js˜Ðžšpôó—Ï4éáïçà„,~yþ$‰SžEù{¶4¶Z·¡é„ÖÓnê^{‰•‰Oôgaé0H¦F[09»ãíÖæD«9Q‘@ÿ®'XUìLˆ+8¤Ö[‡'fúš™&Sñ]÷œýlw³ñ¡¿í³Ç–Y$pTpV¨*jµÑ*ôQ®qÊV¯”¸j}Žœ ü�!/¾yoFš…dš3ºÌƒ0Ð×æ—2¦î¥Ng¦þðn_YP6½ÑÄT-« å¤E_ˆŒÆ^ò+þwìHš~Ú`ÄRþæ^Ù÷bDZ˜S0æ\—ÿ�1õlò‚3±>Ø ðãútMs6ûÔȈoÎŒ@[|‡ôËUŒº”j=yôxKLD²×|}œGeé õÒ_¿)›k¿Îò 6¬ý‡ðž<ÝѺmMOý¥ Dšø‚JÀ^%–{îMзâõ*Ùpêäž¼U™j©$ô4…AqT§æ,^ùÿs¦1à(´ažè£ï¯ UD s§jT:Þ“C®GçÉUÅT*0OáL}‡{ÝbŠqø¡ªv<ˆcËå„ ±|±µQ.iN³äW3ÖÓÑÎèé±bH@™)Çc K6¬â»8±ØsÉ¿„f¤8ZorV36OPY¥'sŽ0ÏüÜ}P¦R›»—LH©-WDlxm<&I¥n´&M‹© ŠÓɃWÞ{ù`¬|ýV/ÊÓ‰) H7 ƒ³;`w*:ðîk£x¸Ó…U8Ýê~�ôDÕâÀzk™¾ÑpX çYFiò%±¯rÃÝ”a¤ßZïî\„Îdo‡(ç —Ç\;GtCÃ5ÐÃkÊR·O¤ŽÓT¨¦‹LÏä|˜y¸!¯Þt-V'”5ç�nqóÐgÜGh½LžpØŒ#¥ƒÈ¡É°çZº×-•h¾Û £q¦]ñ—(r;9XÖ^ž·¼ÅÕLþmqI7nÈŒÖCß#u©UÙgµë‘#;E–øŸ„ñâƒí§cðvà’Þ¦ô[”ná}ã¡3Feb~ò­MjÖ§Ø[ynëÞ§?–õù7<ýjä†Éªißz‡M¡]cæ )ðÕi0Óë÷Fó¾_Ni"Åå@‡ubé+Ü? `T8Z¸Å¹3ˆ[öbþ<wâ÷xÒŸè×~ö–aˆ1{4lXè ñ³\ä{G¹òÉζ°ùÆv“Ù{aãq(ÍT¦SçOÛBAs1^³t::ÏŒ 9ôû5 îžôÄ«˜š)ZÐ]ß~úÔb–o1·œ3‡ ÈÖËÇžƒ×žöIìøb:J[Œâ¶j´›dFÉQÍžòúõz˜bûŽ‘>5eœ”ʼ{™šKà´&ào¹GQì¨5\çìÁé>úö”D0w/šyº«›ò¸ô˜âˆœ…¶'/!݈œÃïc ɱÙ3ó7=½pݘ„ºdKË3ý•(„!ÙoÆ[™:¿\E…/׋֔ ÊèInÐÙ¿×´y¤¥›D•ÏýG10Pµ¹8#ÝéÇóá4—y€v¼N%HÖÇÁ=®ë^$¨å]½ñäÒeu•º=V19Qj‡ 3 ­±¹õ=RË3z‹®†y#Š Ð,§É'ãÏõ`Ðæ¿×»R'TžGSºŸ’þ”ÑÜÿ*ê²ÓîGšöõV»5mâQ±ðMYgºpÃDy_zýÏsì$. [)d¬ÜÑA\Øñp””Êz^2ÁÊ‚.Æ{ÌÉ8ö@ülgohK^¿ã´›Uˆ66ÈÀÔvàyð‰Â?ê÷µãÈ?màèq¢GZu^QÙ ÙÄ7¿j‘g·ú+‡ŸÂ÷=§ÓmO8´ägn0ÔA®À¿’ŠÎÞÀõ¼òúY“~ÑLg-Š .©” TcjQÐÑöòääÌíçAð¹}7ß3ª*C_ù(¬Xû°ê>½®´E>/¯Zʾ©x˜¥Vå…ñÌÁî˜Óï±jØAtNÓåÛ̓tvÇI`î%lJÐÃþ2Ò˜T‹²ŠxIãtVߘiDqì" k] :x?-;?6H}fJ«k»h²½§F˜.3% ¯[èíÅ“jú4§n¨?þìèOF‰Ôg`Ï6¤ŠçËê°o(r›×[)’¤,pwž{eAÙÏnð‰e­á¶ê¤Ä#îã»+Ûm´rDšÍÂ"k[õÁ®®­!żU2Æiîç'4J¼ ÿ•Ñ´åÕòŽÑ|ìÅ£ùÔñ"¯'Ï{ "–E5=Mx@c,º…ÀÉ­>fž-T%ÑVÿ{p-ïñ4m¹„Ö´añøÞ|–±Ò~MU­÷¬ÕŸ»ß±½!¯ó88îìÜá¥ÎWù£ð8Æ‚uy%î@kQ«_A…µûº¶“¼ïåkúʦRã¾[„í¼XÊT�Û&ž«jŽdIlj(—?!³‡w›ßÕÀ‹b´—!6”ÅœT†™!aŒ¸µð›÷T†ólE‚³”U«±dI —žÓ,ÙfÞ®è²Òy#3[¹(Y}ºåšÎÅ žìöSs±¯ÞiçwÝþܲ(ÑFKíÚl:¹üB‚\aª)&<b.Ý_’^i }Ÿ+º1 ö±¯'zš¨èkƇÅRÔ·m=P” _©ûá=dˆÏšNÀÚÓÿªãÚaŠØì g‹³3º!ö_ÞSq)<ÓÞýG˜b ¤WˬƒÛÆÇu^I8`ÄSÿ0ÌóÕ<}}S1á>A=€Bç,[\ IïÕœ’~ó- (K*ƒÈªÇè߈v¬€Øé]ÑÚÕ׿ʔÂ4 ß®)2Ú{[QäF_DLÄ-ù4µ¡Ö ×?x†Àª<°v,±òKÁªðWBLÎ3±¸'||'Ä[0oÌlö#„µÇzöƼ=ìi ¯w£N¿OДcóV+Hðx:žx]6é“~Í©T›:B¤@tŒ&9³Ü§;•xâ¹â–ÈbÚKB…~ç>VTúÝÊ<‚®ÝxˆøÀøØr2¤Ë“Íšp¶³èÏ<Š´6íÑáî<U¤?EóJeiÓQfn‡-“LŒ·Yp¯ŠŸIç°e#ˆº¥ÔÝÓÚ˲ÌtPÒá¢æGSv´£vß'E¢¼,iìAøÏ%:‘«O£ï댩€§cÐgQu„¹> ¬ÎÜYcpµ%ôê½9,Û=}Öžu£SÛ†Ù;`ŸÈ3„Lñ®ÃH¥ŠcÍD?_®Û›øq¿wNæ𩹥“"¸!ÛI Ïó^kîIµèu.¨¹ú@û¨iA•E[t¡‡Í»>›6I#cŽ0Mð^ë“‚tíB§<±×tÆÔ ‡ 4%z›“ym²Ò³Ê2ùçˆÔÝ»ºM.Š<ó›/a…‰ê¨ôý‚-Lò|ïþ>êžE(+ÞŒ ©FëOí q_¡:Ë·Ç`›ýˇŠZ~'Dó­((;ÞÐ’hêkëâ·$ö· µUÐÛº-mäóe|O¾§îbu8 fÖ O¢<É“Ì |Bhƒ&šct  ¼åIKÒ—7•±ûÁ{d”†¦GšªŒÚš²¢¤Ó™i ÝóÕÁ?W WJ‘Y=÷ÜíFËN~-Z©ÝºÌDØ= âZŸ ðÏÆÃQs7Z÷Þ%…ÿ-¼½<ñ$¬XõlÜ',}ë$¡¿ºÁ8 ø Ì’ºUé‹”AcŠ1Íú×IC`w¡é@‡SúÌË0Kæ´‘E£S@w¡jÕtªà“`èØÖ<U<ÑA o¯Us•8Ã" ú4Z95»ü^ã›M™»TN%£þ·À>ï6m|õ ƱN²à¤~·ïXU¥Â+6ÉáߟîpÁ‚î‡Ù—­“êìëˆo›UZ,Èã@ìXm e£ÓP¥q8¯ö�"½Õt™·;{ôñûнg>Á¹þêÔ÷ùî3Ï/‰fŒù\P¹o#^ ž¶HºÛ .* iÙQj:Lý]/Rÿy$z^Óéj% 0â0€bƒÓL—÷‘o>lzÕœ(×JÚ3pv!Z‚–‡³è?Ɔ¹VVb´‹§/Ȉv:yH²åðQŽ­ �Óáh_ùÿpìê¯%²:ŽuØ“˜@Ö÷ôÑÓ¶3‰>„æt–6¨|¶‡ žÙ¨.(´c”ÛÔ Žgýj,Û8¤ÐBYw”£~îãicª-±M® ¡0ÖüìjWÒ0Îÿunöüxš…Va^½ÞhjŒ+<$¦ä²»éÁüÒN”R­ØÓ­”¡w-£†¼F.ºsbš [ö6˜qåðO2|(ßžŸÞ°ËžRK|øKsÒØ÷œÊØ�¿ë»¶`€ÔiéÉÌÂ>M/¿7€±´ðÅ‘¿ÍYP¶ÚگĎdÓFª/L|цîÞÃñf¹c&s×”ÜÑ›6£bßKÒumriZ¦·ïòú/�e-Ù®]Ý­ÃXû<l…>òÒš5‡SÜ(vϱø ôc1ñwm¨G¡·ç4Z8V´À‹ iþõf¹T»qÊËb½|4§ÿ¥zû‰‹…$¿gñÍ•!'c+0‹cf FrãfÝH:v솮ZȬ^N—ÁKÏR1qmÁ>øn[`M)çåh¿›Ÿç™_œº;n#*xÄþçNç&yŽX ?âê'H›‹g²JAk{m'˜ÅW°±í© b‹v`z]…3Ñ÷õÈpL%IŽ§Ç)«Š`Àº¨“rð)è7}jqHQÐtŽ—1Ý ªq±ˆð¯¾½w¬i±‰æ<*²¡ñÔ&P'Ø’][“+Ÿâžã°Ê¼?‚'ºô(:U¦Âü|ÃÐí•oEqv)è»Ðõõ} Su_îJÏñÓ*ÐKeÔ#Íï·M´R¯øJXÔrMïØ6Öt&±Ýyr0-/¹wu·ô•Mbb˜o/Æ „-°·]?9¯å7G„Qž-jõDÆxé÷ä“@Ü •³2ÁË*'µÂ´[ P¢“ê1£­bL‹Þ”"]˜€ÇÁÙ¤‡:åþFœ—->¬îŒ%R$dßKlcV…î:óúEíÂÜ£vµ?‹¡{¤ÖdÄcž¹›ç æe›`oúûRSµ@nðhNö©#Ÿ{/ž[Tn¬xØ–™?O�bí´3lï(†5?¶EI±¯TîÓKÍ0o¡ÑYÛþN. }ö@È=¾ ÿ´c£¿âèi¹šÞÞõë^Ÿn!£ì³´Yü­‘ã‚}Ý_œIÇ35³ØM·XAr·¡׈ÚOP\§üx¥B¤q ù?h>£ÚY÷ |®újvªß²8妻t+Lêc±9Óü‚0yÖÿk½ÅCá>uw¤?^¾rUÙ±Z{šVæOb)HI´=‡­£ØΧ~wTq ·üõ蘫…Aâu±O©”jR–ŸŠDqà´Là~Ìç$»ÓQ6ð•X+ÎåÎö�ÀÕd—ŸÐ±¬)EîÛN‹ªib°õGE9³½Ã¡³õ³z)Ì«¨–ýöʾ(® kª”?ÿõ,«X7ñÌ ~(vŠ âíõžƒ— 3JjQÞè[s&Äã?õéGŒ™èî  0Jêáž®ëma´"rÊ6þõ’&ÊS  ªyÆ’æ÷«o•h"9G&O?Âfë©wQaFñÌÙÈûý@MžÿE5†&‰ñÔ÷ô·´gV½­W;èP0“ßéRFÈr·»YŠm¿ž¿_N¾ª,-÷" â1Ö_T'[ïEi#­8H¡Ê©p Šqr&x­ÛÓx½Ü<ª¦ Nوĩą•©Ç~WógºöG1záC’]!© ,}¢Q)U)ÚCýo‡>‚%c¨Þjwäþ‚Ñß±è—Ìkø%øèt®AûÌ*Ç3¥0 ‚0*w½9š<Ê~ä1\ckàî¹Þ˜!2è¼Æ¯×d>¦ƒío§¡öî2�Wq?b_òœ‹Å ç(=i™t–PŒ¬Àó O×MÚ=ÿê.Ëï<ˆŸ5žŠŒ*ŒÖÓ»Ç>£ yÛÊ >FD²!¼ÔVÁT40÷6Ù|‡ñbaÚâùÁC¡,H§£L;¨°#œA =r±¯H—•HÇ™ç·BoÊ Õ‰`¿ X¦ý7@¨¤ÊüÆvþ”²ÝfdiÞgÆèÙ,vépóþw¦ýè{c¡v‘tßÖÇeœÝ .˜Ž5Kãªè×㚬 }‰x Ú;ËT4Ú¹ ×Iäß´¦ª4óþ‚0…ªäÃ쨤m?ZèLÍ+ñ ‰ÿlÙGÄq6Û´ª˜™Cš‚Ÿöýÿ‰ßlV8[a@ €4 ûµkÚz\]¬8¾²>ÐO(3ßðš–étaeùÚ‰)ât9Œ@*´l§ÒëéFq››¤•‹ƒÌ\ìi”“½Ý¬pMS7 ÆC‘h/ö£RDªðÙo®(Í/¬XG EaúÿÓÌ.: C–¥K°aÈ¿¶Ô9‘L· æ:׳þYh–²L½E/Œ5@Ò<?ôEŸfÇVÊc-4+£ ²ýÑÈÖ+D7}m¤A¸ ø–<3\ œâÞ·ü>zjŠ ñ&y–⇵BžP$ mïæ&lÚÂÊ C!ª–VvÙÄØ›‹Ûœ«ä¬ð ©ÈD7ôdÊ*ºî/ãÜ/ËïFÓ¼ðÛ\sMoYÿ¨”7†©ÒjϪ:ŸÂ§%[ä±·K3›&ö"Öî³n½ÜÛÌʦ¥/wåP”žð[zôYëÚÊ ÔÜâÜ. ðz—)‚©NÙ<â"­ ÊO+ÐSJ>ñV‰Vx0ñ”ÛJh¢:íöµÚÖë¹[t–Þk¤¦hˆ™~ ÷ŠnI?¹hDAÂô­ÂªUÀ}Sš+ }7˜ç°È­ßéGuéœÀëWm'œn÷®î?E⤧ÙÍ»¨2fªa6ãe²¥=—»7ÝÙ³Ô×Õ )]îª ›=6q]û; K¬}I‘Q¶> Ö [½(ÿþûA‰±ÜæûÌTqÍœ9k¬õ£k/}6|O*Ùöi:SCL+ú‹ØN8g§þ®‡F‰¶h,’`„?XV7îìGãjë„ö–½å ïÑ5ß" ¾Â#õLžÁ0¥~¢/áñÓáO,ñxÁ\âõ\qÃb0tƒ(X>æµ¢XL’Î=¸è ­ÙñîÏøùˆÃ%Ÿ®7ã}Éóºb’ódi‹¨ "ÌlmKp~Euvö]Ò’¦£¼4ÂBeÚt´owªú¾O”å•gDB§jUBŸßÿ1ÆÕÅI&ž˜tפŠ4Éü{!ÄŸ&ö}JÕª­E暞Ǻ?ËþÒ�dd/6gºémk_‘2ßÉí)XêF– Œ¶EË^|Ëq7;‘ö.i+ÁU[<M ?õåcI·õ¦”£ìY°ÄT!_݆VÆôT;],÷|b:`ãgbpõÖ»µ·[oñßqæŸ"¤o¨ýQ’DNËú“Î÷ÕÉ€ßV^‹óÌ×|Rª"J]Gñ«/Óê¤õÜ[ôÄÄv&ÊFXÎÐuí¥ÀÞ2Sä­ƒ´ºæž¬þ€‹8XD&�‰õàj¹`8 ‚žÑ 1QòµÕRú2Ðc>�ðèøBÖíÝžF:cê©G×¾…BY?Ó ^E‰ÒÌÙw}kWQa1p¼. ÀcþÖ‚ ‰±8Ùñ‘,%«h—^ƒ8ªŽ;µÜ¤ß=}âh=Þíö0͵Y÷"Ï×p8sŸb‚bÛÌaÑŠbòZGà"÷j¾QÎ(­*€:ÌÄ<ã¾å•-mCîg7he•Ÿ³MÂj€êZ8Š|Ùmxì¨."eO«qº^ãa±P/Ë©Ü S«Ú«ktô$åFŸ¥DÝP58ŸØ—pì•ò.ìä½L}ÃxpÚ;sçµßÙ+Fºïçéמ>P¨³í^Ч¤™r¬ôôé±ò(zQå«{Ý�°u•\}{g¹XG ¼?£›‡3Ä ,î\ã e÷¼WŒ×]¤óÃÎ$W¸2c›Í 4ÒFaù}^Èi8™DóHéƒsu//B²™‰Ÿ£¤•S,ì¯ÓogÚÎøï¾[CÝ)÷¾À’&ÙP‡­§GÀ­.N´|cºÇìŠÜ“Œå&WW2êÍŽÓJGŠÔ»[ =PÊJ3_|&FRžE£·¡ Ôß!`;€·rqÛ)cì“Ê« ˜>ý‚'ôEÆ/÷ð‰ÁHܪ¸NÉòÄ÷.„FÑ„ÎíÚÜãÃçÍ})×=€ÁÉÉÇÓ}¢ÙôZÓÉ*åý¯"8³æËÉWëêö©Ñæµ<cœf¾2‰‡õèOj`ðæÝJ§rob o~ÍÏyØ”AÞÛîÏ Lhð.3¡É=}4]bŠÇú”Ìô"À¶0õßêÏ%Ñ£ÛåpÓÚiŽé°Ðjdxó?`v|uašâí '´îè¹"@`g¡õÖ`õr§/«®¿—ÊÃðy,­'.X¾´=V#Äòmk"²OÜ”ⲿòCüH™;÷ÕLÊ?ZYÙùÛkkŽ ü:u,˜wêcô¶e\êŠ%!f4SZÉ0{`÷ÖJµ5 Õ§;¬¶N¯œnªÈBœ:¨Ôˆ‰¶˜½vfk4t©?Ænílÿ›{ôÞÊobAú'"ëð‰˜0q½9yÐ탿ÚYøã^dœYPhÄóÊvÀ¿V`“ˆCc„Vàädi¦YOÖ€æ­øK¥ßÂç˜ô$’æÛ¨-ó$ÈÒ&R3±q•÷·á]÷‡ÞÎèôRQeb~GÌú$5›Ž�KÉÿWÜs¡ûŽA3›ñÁøi3 Xcá¼üÞk¸Ä‘ÁQlzºa™Õ^ƒNÜ´=ÍL(Õàp‡™—Í”À´wæáJøsõI\ l,×®VÒÆk¾2íI½{J5-š×¶É+Äßê¹ÿ¢#œd©¯¾Œ¾í@Éy8ka >þ–Ö–i8×€ê‹h¿\åµ—Ú+£Ce }µNIâ#k#Òo;ÀØ]°óÂüQúcDZïŒ[©ŒŽ�›{Žn�™… ‹Yù/à+yå©À¹©¢=¶ÞafÓqK[{L¶ðùænÆå�'Oåb³`zN ¾¹ ôðçã’~¼t n )¬J©¶=˜Y6Ö×6[H“ªÉ%Í–ܼÞôr³…„4ô¿©,»Öú‚‚|HmmõîÚ09;¦8õ´ŸØߢ™’"È~>sFb}WÿK<à{Ð%ˆ\oÂû?õZ¸™Q_?vè(lm7,ZÔíYÞZ‡ÊrZ8CG©^�›XQßzäDZªè‹¼R÷CG+ìL‰!V ìÃ÷ß2åaÄøè2bVÇÑb¦dë&hÜ%òÄÙµ(û\¶iöähÁ¹£me%0X±Ót7\buW¼¿rù¶ˆ8§$Hæ皘/îGmüµß^N¡[¬Ø )@”ÇõŽqjm$øq|u{<�1ðú¸N 7—ú m\õ¸ox"`aÑbBxóA<Õ‚ Œ >7-3>dúY9ù­eЖŘ3cØ­¶(.˜èn €“(›×EÓÛŸ³°ß¸¥u»¼™ÒÂ’¢Â d»ÐË«4®êA€;ÞpÉ3ƒbŒ¶£‡ÕŠ ÈÙéµ÷ºÝ7€Â q| ç-™%A©Z`‹ia¶[X³þëÔ #Ùg¡ÿzàÙF§®xt` ”DßýŽ•úò"óe›Ø8h3(f'B׉â[ÆA‘;zC“#Aö«À\° ,…QÐ_p[º? Wˆ±Ÿm‹™ÄÿõUgDŽ†zÍ#+Ô ‹sž™˜Qc…l{®Å€ùƦ¸3ûÎCßÊ7¬è^S=ÓÛZ9¬™1ʲ9ŒGQÛ«Çtqëå››CøØS‰úÝ:ýW´Q€òôýE™½ àµ>CÁa£Ô§]•—N5£ð<ÌT©FU˜¿\ÿxgçÌ"óBû鼊› µC8ÓÉþ_D7º¶ùÖUËÉüxN{á¶ß»siêµç@4„Èžÿ´é°±¢Ô ó%®¿ÍËOå´ˆ-yŠq7 ­Õ|ü±Œ°ôD ð0M•Ü1®<Ô_o6‹“¼Ê='ÈòWT7n½µIå! —½­Œë?õ0ß¼xF¯j‰™~A¾þöÞ“Ï8ç éGƒy×<+É=ጛò}¤ŸvÚÉSÓÑ· ú“£¾ò"wL7ðÂyðcÜGÆLkC¿+¼XMEôÓ‘u9õßÓzÍ{Ë™Úß½´Å@áFÜÒõ‰Þ3Ü~zd°é¸›)-U+ü×’E>þf®S¿]ϨöE �#œ,ú)“júI¤sôâQ“ =˜„á'g ËÙ±ó¦Üëú+¶ioL²h‹Z¹3fý…-oYZ¯\,]HâÒßaÅéу„IHÿÑé`nåôã…Oúš3çùI&½µfZt%k¦ÝëzþKï ¥¿€–r†ÎØš´Š?ÁXï' y›’ʱ}Å÷i[¥esA˜mìÌ€Ãàš¤'ÈX³”ä<^¾x9€¡šÇUÌ-o§«7HQÄpàüïG–›ŸÑƒ§¤u¼m_°õóÒè1úEYP5½‡;¡ÅÖxDÆä2þ^áavÕ“?bÌV™R(ÔŠG¢”Ðqz‘»‰ŒWïHl–žÀ•ÌˆFú¶m<ü!žª*^O²·ìÂ$óõpé™|Íà8ÍÊwßR½Õ3-‚¥íè¨0IÂÈA3„·YøÁ¯ë•±áqKbW×±+ÕÐeA¶=O™âš+•&™Ï @û;pÐ# |D$"B÷5xuÀ\N¾î;ÚôµU4;ƒ7ˆh.©1¿<vyŽ½çwÃA� *ºü}˜F<‡oÛÔ4{TÓª>"·Õ �tä‹,ìE»ö¯g‘3×Ë |€úeá&šIÀ†ÖUz.SÛžlᾪ;‘˜ºø—ž4•àbÔZEPýHEóû¢ë(þ.RSt5Ò4/wÏó<Z–Ø0£„PQÒ‘M’ÿ7Ý2_¸eÀ2鬪I$âÚ!ýØgþzOÝö¢<Ë|)CÄ(J„Ê‹ ¶z<ajjåS%ðü]$Ž=ók®“š" ’£UVàâa¢Ýq°:دuáø±](X4^õ}rÀ9Ú|Ø4‚ ¢wÜ–8ñüÝY-·BˆÁ'Aòs´À�*¿GH-ô[Ñͼñ»óKæÁ˜Éq›Õgãe­´Â¬]("L[x^‰ë€À(~GŒ�¬†kšŒÀáD‰‘aqGî_¨pSê×@À%(Ðh YƒF çœÛÌü \a.ÔO»»ßLÚ«t²Mƒ3Ä*Ž³iÓq#ÈBýèõÄZ´Ú÷8öÍêz5Ù´&¼‘Qƒ™¾rö؉µ9SóKöõxì»÷͘2Ï@µY!cšX@Î¥5åû›VË Ø [zŽ`‹!-ê<E4ƒ(ñµ5r.®BâKCžZ”]eå„-) ÌØæØæîãØ5 óÜåȇºü¦¾a£ÎµAA=[בaÐhV "T ‹›Y•Še³tµ­¾èMéófŹ?DMSþcõŸÚ®§Óia)Â<q¼wƒÞåhkŠq‚füÞ‹ùìKúѽñ=èöÌ @Ÿº¹¯ÏwH¦Iž]m¾¡¤ßwVØwNPí9¦æ5Ä&­ ïìîè=ƒÒêAl4úÚpÎ4Cû‹ŽGæEæf«‘V.Ÿ I¢´J‘Cûî<ý¢n)®…ÊVç(H.ÊÏ…c8¿­=?W#­7ÿ«HòSÆÞ#ØDªølÈj!¥¾”µ¦ë³—¶'¦oX×'S»7γcu–+š‡u72œ5XaÑÇîí@8Ô©˜LjëW¿�) VdžèDú¶Ü᧬4´Å»…KÚoŒ®m * ¢Ÿî9}ú¹1‘$Øš®ìÐdóRh²4µw›Y$êê»è?Ex5è‡vt<šcƒ¢ËZš NžtSx+¿¥~m¦0I‚¶Î‚¤l¥¢X¢ðªøC¬~įv½ôRñ¿}Bªùׯ§\ Ȇ>M8 ¨€êÝ…L÷î–…¥Q²¸&t ’ñ_7B\u3Aúc=?W1ðáT|4´óvp—¦«W#˜©‚jjãr{ñÜê%÷>8;8¬ÖeT­:uYuk u” ÅM~‡SnsèÚ‡…‡#Êð-ÅŠÅæŒuÃiõ… ¦½¥  >ëÕ×$*7_bEúi×õe £Ì¹Ä €fªáaÕX 6ÌœK8l{ð,ÁÑbE}%AÞhš¢¨’?d;{T§Z¬ÕžKü#ö°; c 4’A!m§ÑÙ:Éó½Ïƶe>í¹×v¤7²Rm܆3˜úQ<씋´¼°"òÝBë©Ã*KÛ<XÍU׃'[P#[ˆªpÛȳ/:÷€ñb|~’C;sÐÚË ™ô*bf£{·Tí/ôµ©›nÜl=õM ù–d ­÷(½£òÞêݬú~\R½Ñ7}Fk&¡^Cœ~4k©bÏ|Iì¸)v©êäcKE�ÛÆý&#ë& Îu.Æ+íQnhXø€î6º€•ƒ>2ŒoNæîaŒGûƒN¢AüqïvÿÒÔÍ™! ˜˜Ú*O°KÌðÅ óSž§N«;fÒ;z=e;yHFªp†¶VF\ÃÈö ]ßq�FþM ·¯2ælÊo=ø3 -{`HµÈ{¡1@9^áÒ ãÇ.¡-ý©ˆ�ÜVèŸNjúÈo|¤Å‹~zãð_è/ðøÆ4-¦ùý§\¶®( ·äÇèÜt5Þ'^E®»^Ò%ÆlÆIìgxM,}L‘6AÌlh%Éãu~Iínë®ß]¡0ªÌ{ëvZ¸§œ Œá??”ñqâ6¦5½¹ÕŒøÄà‘R¦¯VŽç5mVãUq_‚¹äáOã0èÿlܯø3ÿŸÐÉã¨È|2& ùEg¦HõÏ&u‰²¼ˆmŸÑ9ÿ}S±ðš>Ì:_m!„ØkìËLÓâCssODZî¯^–$°0v)àaþ΂Ê 2F;ð‡™ŒN*…¤ö1§½Mɼ H(¢0*©«­¤!&À'Š¥Î±À÷œjú39AºbÉËÆàôõå¿ÐIÜš8>T¯Y§ùCñhp˜,ãýºHéW4ªÞ®hOW\âà¹-‚bó¯§*ƒ°Á`ƒ,¢ñW!å^=tlõ„^žŠÝP{­ƒ´‘II‚óâ¬K|…ÂWM‰â²¢Ÿ;o=NÑÀô•Ÿãtk$nmð„õŒÆ5ý/ÏΆ­íº£%¡G¶Æ¡ô¦m’:£òTŽ°«¼ž ´æààà/µ,¬Ya2¥3“žµËWV@ÆÔÃpP‘}6nælû7ý_W*––u¶«u£¬ü@ÜjÐÓ1d¦à…Òv•alMÒ`ø;ÒI“nZó–,YqFÞkJm¼>¸»:#ûÎÕ ç¥ëKUŒð?²•Ÿ†®’ -,Ähäµ^ÿªÂ%ìÌ^­³ ·ô'v ‰ï2P* CìÿMý‚•†©ÃÒ"YÕHÎÞÁÍMëÃa¶¸Þ"Õ-£*ó4$*ž¼Bµ°R²Qd\°=ÞÀz\üõóÇL™ßa¾óQ ’Ý›Ñ.#±ÂacZÕ€ ÿ²æ†j§°Ô›aiì¿÷ÝÕ–O¼-EŸtøtw{ËJ±F wsèé6ÛC¹õýjû,PÔÔ%ÔÉ÷ìì±ÏÝ¥F~ˆ•…ÞZ—f«ZÓL”ZÛ@ ¥¤w¸çå\äÁ­%’ T¥KL‰‹–¢¬[j ž´ tÍ»¥‹EË ô ˆ‡9 ÒîìY“Á3¼=¸.ÏïôЪĉê³Oèn“á©×åÎlŽñ ;ZБÁWZƒ~ŸD:kEÐöe}~{Žº{ÀðTVŠ~‰É»V[œ}‘—E$W¯³H µš˜¹÷:ÜXa‹ê–âì$ïÊN¨—¼ÃLlAûÎAÇ`²ËŽo›ƒF¹/<ŒbtÒ.m… í4*”‹-¤¾ÇíFZ«Ë€zM‘êÎXBÖ´PQë &ò½í7æ%9Œ)‘ð2MöÞ€‰£RWÈkæ¡âö²›0Š"“@G)¢˜%a¯ Ö‰ËÊwOü&]n¤(Cú´'&8–ÉÀ‘úúÂ…9xã=Ì€%š®hôÐ:©¿=âêŠå„|lÿþ01i›Ì—±¿€¾›¦"ˆF'u›€JÒ*³8¬{Ž/zafÇÇÃnðÚ Ö 56’Å}Â]Ìñµ2ºMtRtÆ ¡úÆgÎ’2I-Ôj}t_ªõɼ½�hLüF&tÆVf1¦Æ¿Ð¬‰<ñëÐè^GÚ’l¬*À" á™V÷ Ô÷úla´+3èÔ×EÁéðÄnR–È/çÁ+ØW#A/žüŸ¥i‘»LÕîÿÔSŒuyB‚49ê\ŠÒ’Wø;ò£q\d>?°„¨1=˜OçD˜N–þDgvÇ‘çbPô#Ü• î/‰¸U°Ç3ßl=eÝÚYêÒ§÷:¾ˆÍȱjîO2=Œ ¯£P¥°ÕÅŸ¤NfTíÒ9Èú´büL€‘Vֶѓ¤qæ T3ó'§­å¤ róH¹;u®/î;ïê™·9ó*œ¨d˜rTOí™]p¾\·vtù4šg {ô.sÊoUlÈÄúkðë.½-Ý»å[ïPã#¯6¹˜ðAw¼óå7¶ì¥¶ñ˜\¿Ó²´"cPÚ_©%µƒÝ2Ó¥{É*;ìnðÒl¬ âQŽÁÝ9(­d:•FªLÍ`¼©?ÔŽW´¬=qSy÷˜XßBóÌ“g¡c°ÝRâqògc\à)mžv=ja}mÙªræ5ìšËÎzˆ¢ˆnÌh¥cÃüjÐa`ïG6‘ÖU´ì§oMUSf žˆÖÝ’÷™eœy–otšP9*ŽÎaÄs[9£²¸%â_>�éä×£Èy]YÝ{“ ô>lHÛc¦N7à>qü¹*[¨´¯æ,ˆ¬l&LûÝÚ}ÚínÛQÿ’Škô°°¿Ta'ñ@*¬$²jèV¤£m¡B^Œ¶à<kºHi‡1¹zmjW¥?㧄ú ÎåÖW+» ïCíf®¸ Œìö]ëà ËÄ´-Jcе/™ËÁZñø‚åt=ÿ¥R°×0e¤³x-Y³2PZ™Ãf©*®èY œÞÊöÇôt�>¥õu8xz­ÇC»còæ¥;Pn clåY{„ëÒsàÑÎå@7;t¡„"¶ÅN†V}ת¥ãßø¢fÉÂ&ÒBUk2àÛ÷8Ü”îôF­š„ÕB$Ãü2HºÞ#Õ/Ý60c“0ÛÓj7alÕ[Ç®ŸM~c¯`¦ûŠX» Ô¶ÏõŠBØ<_Œ…µÔzYìe™ÏTº‡ØÉàtx&®<b“/ÀšÏ0›Wøèó~ÑsÎ>­ øý…†œÙ퉉ÄÂçùLä çIH8µúÉXàÎïŒf‘kYÞ»r÷ØÞbéb¶t#Â~ö”Á(|t“­Ø[4‹ }þî%Šƒ$ó{/ ü ·j“Pí?^æÙ~EàóêECTež¦›t÷’ ¨uŸ‰æûf‚äLÚžœ`EœùÝÊ–×9ÀÆbH(]në ¯ók$>Øj›¾¦½ ÞýŸ‚ôãÊÆXÔˆi×}Zט”5ÜšÃü?õoã°ô»ßp§epõ© »¼óí¤ö°öX>ÒÿÚ·Mƒó¥´l ɯ<¨Îgj¸:œ¹ñMͯDÍd"™EÁæ'¥ˆÅŒr¾|Uryo:W+ZšHx0_:ûX±@$íüBl(¤o½¹šµÑã1\ÒÈ=çv›i¯óØu´ WLî±åÝÖ` >  q”3ú±2O¼Ôý)ƒCGÝÚ/¸à`严5``¥Ö‚ €ï§q¥H¢0v z,v¤rÿEs͘SªèÏ€–ÔJË8³î!«K¥¬Òý³›kÚ`§–'°L6¤çƒ{í)—ÿ¢=B?Ì<ù—7ô˜âãÆc§M—þOíÄA°­n|¿Ÿ´Ü”o##[HÕN<"°„¾ŠÑÐõªCQ9{àz«v0ÕÔ£4Õ·B+´mMïú£,"76E˜QÓ÷‹ñÙ+}³8O|=Nz—=DòºóüUFîEÊr¦¡1ùÄ曧Í3kÛ%f<A—¶*`ÔŽµsžýïGVyý#´ÅN8^¼=úP²L-“½IRô£G|XÉ XÄsNã´âèw÷ÿò×yME'}D`ÈQªpgËS 3íS²[O ‚BLv{¥hÖoæK»Þõ/¾]ꨳ›ÉÔQÅo-òÛb¸¸0lൠŠÆ‚¼¦}¯ÐÁª>õ-J&pGºéèÝH-E¹3851=bõF)²+Z!¾$-ýGø-;…â 5@£<\šÎ×€}g}YþÕO€QeË%Ï°æÊ©UgÆl“¥6mðFóÜ"^Þ�9ç7Jú«™Vr¶­­$†´Édà“LÅîÛ eׂ«¹çÌ“ð7Š­RtJPÛ; \ éÛÐßJEè­ÁàöN¾ùvîÇ€œè¸°‚Ƙè>¬Èö®BÕ,k¶`ÜÙ‰ ˆÚÇŽ±TØ1Ú/¬ ê­ie]-7kÚ(Š©˜$wE÷½‡²â¶ðÐœ˜Hà›gÉNTº.cÐ暪µnm•1@öjAŽ€ÜŒö/'HA3BÊWßÊ]‘À¶lAÙÄ„ „'ÆuýÔ{ŽÎº2ó/ô§O}d¦#E(ÀÚÍ–4óÜK-‰ŠÅê5æíñvÔ¿¾ÒÞæÍ|â=ïv'›`iCK.µŸäq4Fdhßì¤c)/úïëÞ<?ÊÏEëcBþ§k™Ú\Qn÷À@v 2îàp1È^Ø«÷]·Á£zÜóQ3 Ó'Là‰€|ö÷§i3Ò Û^_ˆûضð,É¶Ý YÕÓ8…¢®Q$vªT±ó˜éÞÕí4²Ðþ ×#1;r$A:¨ùÒJ¬WäðzÜ¢Me¨wiåœgɾ$Ó¦˜Âcæ²âb:;[½´€Q4iµ0ÿ?ʼ@TRõ¸®T·ŒÎ®Åá…A7À°ýdzãl¨Þ™Î|µÄ&e­t£2ò|$,8y.­y$üùÞ 8'åÝäƘü•˜$[(àGtŒ¥Aµ¶}7O¨ÿìÄظ(žS “b±]îÒº<$ZGZÎ×t+Ö[38ûê.TÊsëÝ&´í?`6éáŸ!3Ë+Þ^˜ó§Ì|¿O°Â(ÞGuãıy¾¬èïî÷îÔ|7{ËÞÎ/ÌC¢0ª´–eÆ´«?˜*ïÅw[ñʬ“<5† TdÍ¿õdpՙŋnz#þ«(]šDäNB_îäbTz“صZÒ=Õ$ë²ä)=“†Þ:é7šôžÊfáN[Ðý"6 yiP$nòÂ4L$6ôErÜP\Þ¢/êõ÷lËãÌwg 5¹=AØ(�»(E°‡ ×eŸÕ8B™OHY\àî  oÒ…çM‘Sñg‡C�Ï]V5>=×$ßgê0±/í•ÂÞ]0$.F>éýbêY™ ¤­£ì·4ƲéÏg0£W’kD¿¬{ß=tf°ªÈ¹9%Õ|¼ø¨æ˜…ƒSTóf]hB…¦³ ¼¯=mT+o-Ò*>W1„ -Ö(ü›äÉ\½Ü1$Ž]=“ ¤¬HX”5²`•¯]ÏžÚŸB èßG•EªÅ\îh@=t®Ç‹·÷vXp<†/úʧÂMïæß÷-aÛ¿†žB«2ðx<e„ÿ~ä…W7§I°áfc{·ïìïÈs(tî´.( ™zOÝöD‰¸¤fûÝ„”ˆÂö|Yõ§ámøOY¸<c`J§ÇÙ[q=”UÙêý‚Lu­R¦®3Êʪý‰ná©õE!@3væ×Ü S> žñ?H©5YMÅÇ×Øé›{®"b;Áäýþ1'jŠ)'—0Œ³ýµ‚욌´}ŒÛNàI`É(ÄòG)­îêÀ*$êxs¢ zè<Í$ÆÊÁuGýž.{b§¨"¯6 ô%ìÖ® b9i'ebŽó*îþ$) Çpá)ÂåÕ÷§É‹öõš/¦§tÜ­VuËT»;î"‰Î7 ÿßSe_Lª¬™ÇÆ'qt ü¿q¦™ë`ñ¢;2Õ»µóBú=lƒj}§·5FùWënàîò ¶Ç—ßcÔÐáÁ19¿yø­ù+ŽN&êŒ$èÙ%k,¸É +kQ¬D“¼õ´|¶Lø0€¹y;ÖG£ì§ÆWïÇË(v…=ÌᇕډNÅ©ÛYkdaþÊ+Ž¢…½+œ‘㜱 ;¶»# mšŒrõ¼ÃèŒímð·LœûìDh…P„O»N“ˆJpk ßô4…xj?ÛËÐòÅ’ìãë£æ¬óˆùã8;ª"kËëXÕ#’Zz×g¶‚Q˜ÛQÑñÍ­YõV2Q´ÙÉm¿ÄjFy’ù¬§ýgÊÓzg8"&¬Â Õ잎 åÌ Ìĵãá¥û™ÒóU‰­l(ßQB-éÒHË0ü}(;q†÷.ïcúÄå6„Ü)\ˬkÉÔ–‹ò[œ¨4ªO‚Ìò.ùø Üòî¾³ ƒ0“<õôPöL®{±n²mB¥E±¥etOÇ£F!6(}O«€=ÊZTVžCgßÁùpL»�«´ézt‰ž©èdÑb¨{žËkdæ~ú²ÉvÛs«ŠÅÔ}'ªN?¾äß<z~ãa/Ã~ó è– {©Õ!šÞÖyz¤\'ÇÁy ´´™ û€]Ï.X ò ÜtVeú—ú,±% «Î¬t>»É‰ÀBÇFDÒd˜ùnß3Ž–yaAk€ _ëÎß–Âÿ±ëF¨q¨ûõؙڃýè¯pùÂnœŽA–'ÎÛF{CŒð¡¶çÝU]O5{ˆCãÍC¥Lu?ž®=m¸®éÆö/{V“RˆÀïÍ”òÁÀÖ®~ ëÎ3ÄÜ 9)§#æbá&ì¼s0ñ¦"5þ¹h_Óòµs‹æ¤ß Þ¦yæ½9¨¤´ £ñ[«õ˜Û¶ôþ€»w†®øÝÄ«Å»ôø5̃eØSéY|GèOª‹ú¦ÞõF*øw÷(ûY¬äÇ Ä_[Ïi=¸X9¾´yz…_ùr VW¥þב]RS÷èóÉm{'_Ž‹t!Ú˜á,AK©iVÕU$æ5Ý]tó Î9I=*“©†¡+:½:@õáƒÉÉ Coꋇ˜;µ¯{(´ú ‹`}%ËIT Î]Dý·÷H ɹ錔—ã†ÌÒzÚ²NËl ¥¬ˆÎ‡nc‰bñUgK«v{q?=Š|D;óåzÚyÅ÷èJm-ú+w8À¤aêÖ ÷eâë‡Dª1ª?yµs½™é#ù½l‰¹;™Q½wy«ÂV„þÂG~ãÚ¼·BI š((L)dÖbÐKÿùQ&ô]+ªrÑÌ*3H¨P<ªQ Tã!sÒ}¬×oÛÅ ïê:¼E‘²LEǘDZÇËÈ´uûúx¶ÝÛuWLŒlM¤²"LP² 8Yí…ÔpžeQZ­Ìï^OQÄ|&ü‡ÕíéAœ”œqó¬ÆØÊûËpiÛÝTC¦¦¥B7SÞλôOõ}¦2ˆ›“7s\$–ÙðtX‡ô½!üªIl%E+Óm†.³:„;Ô_F=ÐõÏŠ`#ù²¢êå»æÂjiû»a/¾=–F± ½åãå bœt÷wÀëè¿…ÏóÁaCÿs½yO¶ÖÍBJc¾;‚dÒÌ™;ö"Ä]ˆ+#„>Ùçxc¯ÌÜ*à’áÓ:w°<Óü+ Éʃ±°á—´be¢Ü²–"„I­ù­­ÎUxÕ‰]í“ i..u&ÿØÕ£æ0vÒæ\š{\>.VMØɱ3%�+5ó5z<*r‡q0”WTÛCÌ£°jÖÒ…þ²ã~`ÔøÝôU¡BEì œQDšÏª^ADŸi8Í2y·HÆ£¨ªú—”›"߶™üÜ\ìôØ_¶˜g_ÖN�ûËáž©‡z¯Ú[Dヂ;xcæ ¨ø A$¯MôH Û Ë ­©ô̹ôŒÔ*Îúoí‡~>)ŒòØGë ¶LIZWÁ„Ý¿Œ+¶í¿Í5ŽýÑííu‰Ñ–Aƒ½ ØhŸ£BÀ½8ôº5)Ò#o¤ÈŠnV¦ÏÙliÁߎ£Ê¢ûâI° ®Ñè_¯:‡‚sdqÀç÷Àþ°beõ·ÐĤòŠÑ“ƒK…%×Ça~»ÉßPœ·‰¦`J{Sè/ÖWÞ¶ë7;·°µh~ Óˆ)-Nn˜ãÃhdú×C†Ç&Šú®b7ò9‘jž-Â!z>YPnÏ>'M2¸—‰ðvÓðñµ$*Ôz0ꉾ+!€ÖDK‘ÞÂWþ<©•ïo&ÈNÑÓ ëá…â€ß£Xb‹E#òG¹‘î.ïÒ¯ó²Â:„‰ êá' ŠMc6h¬1mÂÒ¼û²„aK^À"éìjgÇÌìê™è­-¾w¼@#ÏqPs²y¾{{ñ¨êmÝïO»ÑB1ÿ6Ö5¥.®e ñ8À¶¼¾pócܦáð>¦ÍJ?GªþÆ91Z#ñÒ4X=4Q~UwsÿÒ³¿­XûýœQ£rÂÌölµ§¨¿ƒ©‡ºÂýÃ/4†£4Îü´v5è7= £k‹ÜCFQìDÁacýÏLTyI¿‰Ì”GÇ€8! H5Z ”Rˆôgî5§íÕ¬\>Ú,Å?\&5*ÜÊ« éN(S8¹¬vtÎ@#âHçn£ܦÑèÀ®Ñ`J]b!X®…»8H;­Å±ÁÙ¡é꽱êÛæâ!ù{Ù5»ÍMèê„Ê®‚îÙs¦í?ör¤À´úÒÛö<u‹òÂÑ•˜†½miclþuÆåîC3y¡cò¦¨I²ô(dÓ©d¥æÁ‹<̼Y#ù»è–gät‹>´=ÑCmy\Tפ1£Z³²&¯Ó¿©3™Ánsµ’KePv½_\Pày=¿1»M–…�÷‚lýé¬S©>9Öªò¼e·®}Ûù&Ž¡›4?(¢@\5­OúÄ¿T›xy Ö4þˆ.êa~à"%QæÛXÅ"Ž–Nÿ:`kõ¬hƒu¹Pit‘â¡8š#d‡Fò`{ļÙéEÓGþ<5t|šx‡CŸÐÎY¾Þõø¦ô<íÞ^Hó°@'Fõ˜'i·í½+ä®É$~¬¬X¬U;¢5 \wžä™¸‰‹m_2ŽŠÿÕïø®k)ʈèpÁYEgb†»sLa8‹ š=»=jð–p™-pÐ%òtÛËO­±¨<$ŠJôâAqê+†ÒŠïÚО MÝiwÂ[’/u ä—ß'ßQF‘ò(!;kÏÊ‹¸ó½ƒÊ§äÓèN%Ƭ•…?Ö£I6¸ºÌ¿’ýð-±ã£AïlUÛrúâ]²«mYõgÝ¢˜ELJ�79çHîfü¸MïÜ^IØ ˆéÃ8·\+3Ÿ6Um•)‘æ%ÜY/†NÔ¶=‘Š?hÝyqênQ3ŸfVÕM­#†N¦Ÿ’ÏÄ uoûA‹âðÓYÌʲ×yÓùŒ=wmöÚ›ö¹g_%âUÜÍ:¡«•<é_>B£Y·@ÑÚ€< äûê“Óƒbµph?RJï $Ç„ºØѵù…¬*“5:ÕÁ0í ÏS„méèuº÷™¤V>ÊÌD nÍÚsg®YmÙl¿·Ùüˆce{” І”[ÁS5öWUû-kÙòŒé¯ºÍq¹0҉Ħ§·„ï[€€`³;×yµêd¸ø;äoË}–_ðŒ†ÖÊYŠÕEeS7:A¾»ê~žÊŸjMš^fjî×æSoaƒå)‹KþïWæN–HBçûÒó�9Ö? ãº{u§·|¿É\ö rª£2HFWeꜹ? 0mOwYÚ…öêµ¾8N4%)¦u? ýŽ©óDˆÅN$06J*þ8÷;~íáŠÂOF€žš*:t[o€¦¯Oxé/ÀÛ˜5ÏyýœÍÀ¨þ:̵΂£w#¥—V>ÜNx pd¸(å: ŒÕD“Cs@¥v˜ð±éQÙ‹룈®r4XÐMgÞ4T³VâÒoÈkrî$øsë„èAç4Xù«Oûˆ¥’†N1d>KÄG“šI$€Á–fäÖTþ…L|Rb˜N67'Ú?Û“Ù®¨¥ê/î<0ˆvÚªéËSˆdé>,ÃÂaŽ—[m¢ÃŸº7YR"ßüÎ#ÏÊÑYÂÞôþpÞxw‚ÿØsâ¢9î½\×AfUf§Ë °Ò["±v®}Z)÷Ñÿ¦{3Ù×'>²aÃö§òíÙƒk´âäo׊«»Ò v–ß=#öWJ Ml:¯éKf]SAî¨2­ôz¥Ïi…'n'’êùnøya0nh?ÛhÁ-sU/Åèé 2?|EŽáØ>¢ÞÓô´´6ŠjE~f}L&Û¡yƒ~ûÈl–-­ƒh¨W&Ù\3[°K†?›dljù9èôßoè Xã»ñk.)\×6cfÌ°»oIÎ3H«õæÑYïÚPÚÞ2­Á1ÿ1±òBw>1@z¡ïðñ1±&Ϫh²é3z`ÕÔûøç#½n†`Þ©Ùüù –¶ý,è6ªz'þÙm!«ÛèúÏh]?(($ƹi¼ yUøòᾌ8|c/‡6]Rz†:]´JN…[lsš¾¥ßƒ)0¢(…` z\Å> ÌQ;ºPÙ“ ú9t|¢›0쎪}á[¼´'0ÀS $ÊĪV^ E:Ê\(:¯{ Øʳ)øT¶ ®1—cŸRÞÞ¹c”¥Ðmša¬0B…—þ(*k’µ{ ?Þò‹¼š-1ÂœûŽvDaW·IK‹îÖC©š õã¯'aDÉ`­²3 ô-ê©·Òéw§jièÓ(׿(‹ÛÆ—’fÂ>§ÞŠóø¡Zõfîjý¤—Ñ¿c ‚^ëšØ㌊0ˆ ¸æœ™ÁOa‡Æ˜Î5e1,¿€Í k*ÃK>轇µ7DÃh¥Þœ:ûgßÃö.`¾qéá*`¤ÌßT³9yz*lþÙLùøŽžw¥¦>Ö» ë_^› DE˜y]íˆûÒ 8)É ݱ[„MJO¬–ÄB/žOŸ=*¯œ^èüØ­BÿÁnÕ™ÑcQ-_ïO]ÿqØàìÕÅö þC§Vƒ3ÊQ¿bJˆ/¡‹…­ýÜ=‹Ãf‡q\9±ªyJ;$ŒW4h¡´F3÷hºgÒo¢Ðÿ&m MB!à¿ Ús… ¤ [wÆ“©¹5RDø2ãµÛþI”ûÏ=̃C'½µ§Ä¸®ûÅŸnÞvùrÿöG šíÜé«’ãÑ¥BÒ˜“NÎý=7±Þ¾÷y”y®³”Èõ}Fù@3¹¾ý?­FÄ"vS=žëÓÀÛzÀçæ|º¶µ¯X±™—Õ£qN›ÔG xdå(í÷{Ù­"ZôûÐ…N~|Ô}­”Iý êé ÷›þq‘VtMœê¾eÞ‰Ü. ˜#š3ÅG=»Š;Æf†iž-\–#ðÂi+d_ffH<Ì“¸Æâ B˜+|r‹Òñ†*œsaŽ• ’Áà2{r4¯ñ™?ÿ£#¡bøj韾¢º¾Ö^ª4p‘Lâ¦ýMhjÈ°óÉ¥‡2-²£@jNkeT™%hâYvX€gM=IÑUeíµð :Ét¼ÉTEÙBgíðÇ ™Fs×Tú—ƒÍ(1Òaœ\Šú¬-§¸f mvO“õ]—<]¸r øßõ¾Ô‘�˜y/ÅË¥“ÿ˜ ²ü¼¹*3eÆ´bܲ¹„bê!ÝÀ¸KՅωŠ~DÓ”Ñ%úºì,%©;©¸pFü³u£-LƧlñÔÃga‹�ÌDéÏöÇUArÏL óâÔ\þ£I[êÆ‘1r>ÿAý½Õ]Jùºú29E‹ßدÄqæTaj²¡•RZ `Ähz–pW6Æôû€š¶*pa§;?³½•,VM?Áù°çT>è´+‚; >!×Ô5TMwñ¯°$YæûC„ËRm²î]Ë1둦Ò?ïNe£*^¨eFÁžRÐè8: `=CÖ”Ú¿ÉurG.“\gU'AÕ >Ž]éè;”ß“õëìR£1Áô>o×ÄZ- D<ØÐM>Lœ¡eÃ4¡7]áö {ÇÍSm€'ÆUÒa¡ä)Ÿ¾-‚j‰«*’ÓŸâ ˜*!*5;s$Ü2º•×mM£B•jÝmÊ < n Ë>Dñp"¹U×ß¾²Ã µtS2! WMgº»9wfÔ"Õ0~±€|EÊœ™1_eŽ:Q)!áµClpx£ -Vžd¢äèž'k‘‡UoûÎÃÖ²þ�,ÒžÄ@d£GïRÝR >’IK÷š$¡¯_N;ùk¦s\»ñÙÔ](±Ý©ÿÁ³ô-¿¹c»;  3Íy´]; ôêð#Õ¼ûFðÄo´ÎªÐŸ*ÂH«Í‚°ëý£=“3×Ms˜¹C­³«oç-œa’1ÝžE.+¬"=¤¹³·Ús<äöíž{ï¯Uö=-–3Ä{ŒÁjù׊ Ÿ”˜p�¢ù ØÌõ?øèäòšjq•džo}Ì=ºóEµtŸô¯wV˜šIŒ,§¶bêG®Ùªišyb»’EÆ”ÌÙá9ÆjŽŽç•5f©?5—€‚–§ªs¬ÿÂ1ìײ éƒJÉÕ‘)ß¾î+EÃe²Éõ JǬpÎÍ(Ø¢\}ÇF¾¦˜fÞ( &[8nY=ÙLìªIÔfà†= &ñì@�@Þ…Á­®X™û°}íj&ÇÖkÂN û0CRõQøúÎxd¿ÑÑŒS7 $Äq,ƒl»54oࢺ³¥ÚƒxFþ3P s{ªï%Õ§.b3¨dÔNõYHÎëÎE2à‹MO±ŽçñÒªL}Žfd¤¡GçþñPzá{ü—…ªk:+4|ØÄ,FÛÉΟ…ÌÙ“aä¸iúCïõ#¬õRaƆ.)YNÜqàFÊî ²òG‘ÓÖÂ)Ê!G>ì5a—Ú>ƒìÆ¿V EM¸´žQ]QîòΚ C_:�öâ€>Ö¶E†’½pcÛcX¼BäGV×)´uÅÕu{ã&2îš+3Ò_¼Fÿ‰³¬(Ç“j*øôȽaâÖŸƒç.ZËÁª¿P|2TÖ7ÉZQœ/$ Ƶäí¿Ž_ÝÖãÊ €û(”'À–4É<Ïd8Ól’ Þ¨Ù"ê”I ù¥êa’ù�Z>ÆX\Fƒ_¿Ctû˜€8© 0@Ï/@M+‚$·zeúÞј–ÒbGíECž¥YXfRVÊL°?p9>Œ/"vûD0Jxh°µRS…1G3SÞºÝÉþÞ¨�Å`äãȱ8©äˆk•ü‚EâáØY"Õ‘¬_ʺ'cÝrÊHÿÝm†á;áC«túôñGê 31®{Û#h ÍÅÒÜÖÿöw8ÔÚoßEŽ–©L…2H‹ºm>;¸‘T볚„Rö¼ãXúð¼s–ʱÑLg O^÷Nt•÷YjÄ²Ô ã%ÚÇisã~³úéòqr¦ƒ‘¢9Þ°¬˜tÐ1ºWK¥c­Ð÷k|”yò0<!â8šlÿuEÏg=íôäéø±å³Î” oÔ<÷ì‡ nw@t-É'2lÃöÔƒ¸a -Ë4‰Ïê3"Ç™d½¬¿røÜŸ£»EJ7êœÏè÷êj*q–¥ rì« :Y%±ÎcL¼<Šc1ý°Õ`„†µ™Ê8KȾÍF•k/36‚ï…½¨ð9é!ŒòÊ ïZOF°e(…(í K¯,kó² vˆó±¤™ÕæâÐ,{€ì¹{@„\Y/®Qeº8E2´�zÇ“íLTÌ%ù¢D‘M°…å) ‚éUFõK_—}@w ‹·\&J&á÷àÁzjsÓÔ}¬_’ºÈøêmK*YjOÿf_Ó§¼|@®ö£@ mø£õ÷èäYd2r1‚&¯‚ø[2EjÐ6ô½A91Íõ;ÿŽ›N_g{'¬(Û¢­^®7ž9昢s¬gÈËiœB6æ§ô+–4ǾÓvÀ–‹¹ÞZRú]ýV«hº7Æœão‰U¶Ü,Ì¡ÓÊɶ§"%»Äú˜½xL‰çÈ.BMÕ·ö7„(B… H\ ×€±v$¿óžR†ÝÑ—øN’…Æ7>37F‡!i(°}MGÊpµ+ÿ«@™ùD@`¬ Nsúô¨Ìt'¸¿úš»ÃÚ%&›lZôßV.æ¾w¿t®‹1WýínVè1ÏYKùx §•8›ÓxaóÊ;ò´ÌÁ©äè̓՞—Oß @4bAÁyŸˆà¹æÌCBŸô{ð$ëÐE¡ÿ–ª¥™ÍbŒ:õ#™j£0¾œIÐ^�3ßxÝߧÎ3ž/a>µvÊá? Ô•sllƒZZ#¨y¦°8r{W+÷¶-ºíÐá´2ê>ggVëz?‚§š®�Áž/ƒyA&a(i×+9Åîóo?iê±òÁoXm‡^vÞ4³ç%§h†"+³w?H-Vâ¦Ù²½§$ ÒµþL,á×-LN,MKü-ÇÂ4.bGdÀ¯½Û‹uj¤–×Qü²|B�*¥÷ág¬ªœ×ˆHZQÒëT ‡'­hUs¿Â&lÙ ÿà©[$À3b„x/ þ…±h\ÑÖY×Bv’‹Ú°÷³ùŽm*¢NFÝ,¿CÿÆo¾RÈ꧜¸MÜ¢…'„új¾F&=Íøà¸äð]®[³2&«À&Ç>w\ì~Çcå.F‘Ë~àÓ<YI=À½!6ÿÑÔ§þËL�™D´eã1*å¸~_´IuÓĦÓ³!©‚ä´u…6Ýp6J2Òî³{ÝÁWßÞĦյGÉ™²¼éì9\0íƤu&û~äÖ§žy"íÝÊ0jL–hê2ÃœWÓ®Çæ]‰'ç&˶¦ÛÚ$£„O›é1 ï)j¡Ê¾¥´“&` ´ðÉônw>1uŸòC£÷³ñò—ß[þ®U¥‹Ñ* e9X6HGN\ãZq†KÛ½hÄyµ˜üC nR¼m½°³‰ÁÔ hñžzOî:õœëS<ÑéHiPò­LÌQæÔ46ÞëÄpÆþ4ª,ÜÖ:±PõI7ÁÂøKÐc¶”6úXè· Ï2„i¼dë'D9ÆFêK˜Öо.K³¨óŒ±_¦ÖQ’.H~9eGÕ¶½ ·¦P‚ý9,Ìgi¤vý$ß4ɵ‹øBLû,ˆŽÚrætz¬áçåéFÂóËÔiÞå#VZµd˜”ÐXf›7¹=ôàþÔ;×(LY жÓø¶ë›5®zÀ’Σ>ƒCÓб¤¿„—d*¡ýWë½0\šZ¿¼Ê€áš& 2{n±8׶£d‹2éU/"{Ðd`ÑÍzµRéâûªºQ;lè»Uª™‹X#ð»«sÙ9ô;&aÝ^Üx $ÞA/†Ã9 Òcí {Š­ÂX_n¬ÐÊE¨Õ½•¬gŸ¤Ï££Íì>õIEîFñ¬˜¬qÕüxÚêSÇ=ò{c°¡;ßg³8óx§0PÝÐRûq%mÆ“£S1#“*P€Åk:‹¥ˆ7ä°{?ôÐÉF+. z8Äçö¦ï}!§àó°µ»z<ÕÍum~øðºz·¨ðÁ6 Ê¥ªçÓÆÎÐŒd)ÈL:ݱsïRÃòóyZ½ÂÜŒƒ©ä™¤éGš6Ióôw¶ÜŽ¡æéè¡CíQ2†º_ÕÿÖ£îmOÓI…3%ƾ3c‹ÌC%¡˜RFç­gÿ .ŽG÷•òtÑkIñœË ¯5ý§#Ý%Š¬úYÛË„–N0n/ P´Ò¶jèã}lzn•n8ŽNQiu—c±q_}l å ¸ªy}Ù'²Ü{{f]¤ß 4Ø(¬Ëc„¯§ûžJWªÁ^DóÉûÄx&¼÷ß\"±Ï€Ï‘±­Uµšd†¦§…X ܳ"ýÉÈL¬¼\b’(–Î[JùA}tí™ö)õ|7~ÛïòžTEœ{½+ÖyZt89Hcf ¸±šˆ¨Æ;Çjä”ÃŒ8Bl[º‘GxBM†¡Th#Ÿå míÑŒ´ª8Þ<#ªE‘§ Ã|Èî�Ù<›®1bï‰ )ùÏ·»#ï铽±@¤Ü§TŒÃ¬ÍF›[ô }’ÄÌ=â�ž þ_ö‚ˆ™Vcžå–WëŒ1F¾YÇeòÃǤé2w†�¥èŒ%Añ­`@H1̈;n4#cí'óqi눰l$ ÖÇ~+&Z.[$Äó Á4.�³&­¤gã¥ã§rÛ°Ï"Gß‘8ÕÎy6³§¬~S\ø\1ñ1²wè†ÏÄ2¼"=mJGNщ¼? RÛ_D‘… Å¡™êM‡ÈC½ùs=lœ;ÐÆŒ<k‡+ø’˜” Ã�ëüb¢ð%‚%ÝÒŒJέ…ߟ‡IàÇÃe`6šPjÌw²ÙøÑ°Š(‡ž+LqìA' žx4›u£†ÉZ»ÃË“Ñ2"”ÒqÁÛ.rŽ«¤Ì|‘-ËÀY&²¯1ͧ烑.„(ÅÅ|½'ûö¦1äÀ°ƒÖfÇFŠ:€ÿ–E®­^Ÿ9‰Íƒ™ÜÌL¦x½ŠÓ–>X%ϸ²êÒC“%³†¹Ñ'½bp/ò7_F¢ZÌ• s+(©ùÀ»` èðÊYµÞn±Êù‹¬ë~tG/·ìú½/Íÿ+á¨PŽ«:dÐþ‚äǃnkJ[k™=у\Sr‚ VPZÒTèFú?ñØo¬:õ5§”¯möÕÔÃ…•R¨x£üO’/!×™Õãè#Éx$_’e~Çò�_”Å•f¯âµÇ.ŽÙÅvì’(c”þWßy:º±Õ1söçè‘û~÷oMõàÖ: ]KËõÛïGìHC{?uŸÕ·ÚÌÃÿ`ë›V(¸£“wuÓ·Î];C‚ø¥87jH-àÔjMmìZ&ÁŽÝŽ»w8nñÞ³ˆ3šÎWš¹Â„w–Qdë­9jØn—¦[}Š-Ý#s†­¶N0\äÅ7î0°c™Âhï šRŸEEÀ0ƒ'-ý%F?¹{ß=v—SS’Xœ%*ü5¨J«/òš¹|\“³Wž\£‰B±ñ_Ô±>ŽGAn&ÊõÚiäÊéÌùòö$¹ÐÑ·ˆ÷”óTAaOüˆñ†p‹á ¥J£ò#s[0Æ&ÇôŠ G}cpO³ÀŠÕá/ÔðºÕ®×ãêšX«ôÚ$^L-Ñtí)jG5ݦ¦¿Çv ¾OÆßõ}Þƒ…¤„…‘ɘÎY6 k¶¨ZªÇÚíálײà×…3©¥_ÌŠàtOú£Á6¶ßê^CÑâgb•)SEÞèG¡Óù�PßÍlºv %ˆ%¢Í¿”þIÔ!Êèôgtç‹ 9Õ®c8¡ïg†íòò¡Ñ*=±¶§™T{°²6WÆ]¶Ä Õ4‰îÕ²ýè‚Ž§îéC'½eäÚü›”¦®…Ï@H Ìtã­Òd%%wËE²Üû¶6Û‹{sÊk!0@¾™â š{¯K'Êj.£}S!F,Ư@‰O±xpJ¾øšyÆ—aî6Oš8‰Š0VJÅ•Y©Õ}}‚u Eð/Jõ;´g¹{X}u£äLè‚KçqË”e®f#M[ùq^4{wµÇÖ°²··Bevep<�µ¢Îë‚ÞPH¢…fýOUpI<›¶õú竱»†X‘Žà<GôÑ9€Íõ^,&)hO¦SÐtý¶‚€îë\À3Šþ§ ì0- Þó!ƒpÕåÂÁ LÍ?;Þ¤†·ädzªé4¯aää¯r-ÿÅ)4NÁd¡DªW²é Æ]V±J–<* `ªg+ÏuÇ„Z­§aêo•É#ï)ˆa½ñ¹¤jQ¡Iæ,é0§Ó€Ad ½/WåF44ÚíÇ‘¶jòÓ»] çk~¢æñ®kmoÓíâÃHÎ&Á/[ÝðTñÃ&eëwË¢l1¡µ A*%(/º¡nº¶ƒÚz憛ØTÔU(áØžœ.ÉêÆWÞWWyGhÅù˜Ê5)Œrغߢ•ŠÎÜIa$ [ :ÿz TùYy%tŽíöæÔ‘–ŠÀxÜX §d„‘O±ùÝ­KMôŸ$÷ʼnc†ÏW”ôž>(íN¶…x’Ar6¹øîqG'UåÚP {Æ-íµdP'>j>¤åGëû èÅŽ¬½ãñdÅ£äM•Ð1³í‘–æ÷ÙE )Kè0QÿnOÔHå¢ó €Þi“sÛ¡°‘…ÀÀPqoRù㸃½µ*4V_‡ƒd}îîß»ZªÙfœ@~O´ô[­µlVoø艩¶J–*Qý31¯¸*’ª0'!‹œÿÐÁòi}(¸Ä:ðéiðãϘ¾Ïy¿–‡  Ž8˜.ô»Öž·*§9#ÿ¿¡Ñ£C3ï/‚Ô°­Uš¡€Gg_÷SƒÓatüp.*ÙôM0Zæ`RŠ¶]ž1µ4±HÆÓ\+ir+u‚Ì°%ÈyÍÂð.¯¤ÕTÔdc'ZhÙJÏ fJà.ï*ÉÑ¥ÎG, Ca£ýTm@gÏ5øqžo;±âNúÖDÉ~þyò¸¼˜&aqþâf«^?pŵ\}ëYÝ©þ÷jS^ܨ­�p?MWŸà Æ5ù¸=°Öl=BË̆'Pj±?Œ°G¼ÿS’d럊ÒÀ£"“S–£è:›þbš‡®Ëɧût¦[Ÿnµ®ó>‹ÎoØ)ÊNqç-¢^äáèa;Õô'¬óköõÏnßùÞL Åqâ,\€.¬{Ç}·«W AEâZ�Lt^­1’· Œ}¶Ý¡§Ô‡ùÓ^xu-Æw¤âpy×o9²¸»hNý¿ž§…ͼYTŸõâ’FAŽXûgaBh“­jZR¯u㤟l5™˜jC«1|ß%ÆM²"©)¶ î6»‰ÇW'Tdýþ SÙoNföµ—ƒË‚üì¨iò×P¹}#¶„úb£º5Û *…@4„â­n"ZwüµNåO»Aït…â¢Ê<\;" :2+Þet]»…€”-¢$^ø÷JIã{hJµ‰¢c¼ñŠðOí×3|Π܌󨛡k&¤*‘»ÇÓ´W)ËÅP媒t“À}Dºüÿ÷ÿ!ñ<HNpϖʧŽsy¼š¡Éó½µÙýµGu=©jð•Öënœ×” Ä0p²åªŒ©b¡ô²Ý*5€‡ hÞ'v(ÑW¿èv¡•B‰cˆï÷º;IAŽ±©Õè]ÛnC Ýs¬e–zi+[pÓtTyu°a’ToŒ’6‰)˜²´#e9;km³Ø<iœW:¨ö×LŸ¹XŸÌœ¡ÛS2‡ê’+¨ÿ~ÐSvjÞ΢Ph´B[;8n£�*óÄÚÇ®ö”35¶ý†iÃöÐ »»ÔuŽ|;QvD›ÌàÙVMdõÚaaDòwÒ.!–]×ÆÂU'æ¦1)¡Î8ˆæbÍ  »gg‹IÖ²²DcwzíÍ›ú¤0 ÐiSGá˜ãÊíÑ)‚;ÕK‹öè?ÖXRâ ¡gšZÛlÌå¯üØ ƒ7»N#­·hað³…¹[oš‰ XÂ? ÉÿtíÈR¸ÝÊf6+ú»²^k¦q¤à£ôŽâÉ­ô 垎QqP§Aú­Ìœœ;Q§äwÕ…O5Ë ˜‚˜Uªîz«Ç‘)%Ýœ=‰:v(¾´&sùE>š¨¨4kÆ¢þ”ÁÉóD<jl§úâ„Aëþ¢ Þõs •$ÎãlAv™øUŸÖM#R$‚ëx¼ËÂ,ô@a�Wà­˜ »�K«›ŽtoØ‚Œ\í�³«¾^]|;ƒ‹‹CÖ:–¾'3ÐèEóäÑ^66mתÀcŠ¾k8y°ŽœM옛Úëä7Áèhuu¶ý%/Õz¿†²OJ–³“Bl?Sº2A™^Á¼Gñ-¼ÍÅÖZ͘Ù±ö|© µ¬Elê«cìmî “9Ý•üîHÍ-:È3*Ð «ñËâî*ÝdPoÝ™1 ^äCÒ z{8êTûˆþ4)îÌ_ Úöõ8ì&+Þö¦!iZ^iøÏgü GOü]pñ>³Ò“5Oéq±‰òžù¤…s9ˆcsß®­’Xk¼nVøŠ:☹©‡4 ªoÕNmo¼|wÈ°kí¦¯¡z(s¯çÈò´ˆ}î{Ö¡6î´O¬HO #\ÅœôsÎ`™úpÑ°|2ëg†E³“¤WU“k»wàð 4"Mõ) Âcã±·h3M–ÐIÞú _Ëh!f‹¥Ä³zdQªìÄó@oÊ»&‘ï¸Û;oŽÔ <{NÿGm\CrÀˆ Õ¥Ú‹OÕ³3ߨe,/¤V1^[l–V·– è@Èh<™ÈŠ·æëóàÁ¸ÖÚÙh{€C>Y’Ë…5)ÆzõKHÆspú̹÷±é'&‘N½Q({ûPšU­¤¸<zÅá€ç2òü_NTÒªòc5m…m-½|s—¸/ëÐ…÷Uul7g(mè+äçº;JaÅ¢ßY† åQ«Hs<ä ÝVöŽ1�ÜÅþg:Q üg7¿ýÉ«öj·ˆÒ…Ø#0‘£&ƒÜtþ`P$Xûz²fCTV_2öR©âõ¥o¯ù >“ª¡AGz‚ÆikÛõ<oåûWV<ìáa”för¿ݶ4ugsVûŽ¢Êw{ňL‚õa2.¼R_h“.TJóÂœÑÞ›×t Z-k<Y‡†þ–ƒ¹=ÈuF´ä9¢&Ù"¨$ãF;I‰QÃ|øòhqïÆÅ8‰B$€%•A9Ûæad†kzÜ\ÀKü»®AæL¡…'q<Ðz‰ÖÊÁ©pjz°;s*o“¨Î]½úñ¢L\eÅ™F»U3ùD€"yo[ìâ/úýQêù›ñ-ê)]BªäžìöÔZÍ­}½áæã³$afò¶£/Ŧó&€rÎI½y”Åü7+Ï|%DT7¶ãº¶]NƱM::øÒöúÓ+8À«†Ze¢(„£íäK‰Ÿ…+"ñA�TŠûmM‹ö² ùp=fù'Á0¹zþUlŽ¬¥·èg´µâ ý¬=Hßq7ïëÉ¥üʽ²H;™uOÏjê§)tY1ïW;pª-xìÿ½Æ‘åKJ´ ¤­l`°±‚ yüÌ"PóXÂsgǶ©Øá;ùÔ=“#‹åXj‹x³ßßO‡r¯@â÷û2žjÏi<µ l^2Z†BÜ^<!/˜å4·%[Ò8SIªz{Mp?°Ùœar»}´•»ÜbðšG0}NG‡š‘¹q=’àM»ÓÌN¤k§^N9ôÀõØÇsÅtzµtr‡Ö¥&cSæaúRQÒ³´En^oeM%6£`T ºo2ën‚"š–ü^õ®…u%§¶tàgus±”Ëå#sÑØZtÈÂT©v«Gœ˜úzG+ó–lJƒDÉ94�v_ÿˆÊ Ö šÝ·xþ“–Ö^USÌä(¾½éÅpšå~·W îRŽùÙw”E>ц–GC+¸°ª©pü¨ª£Xò;E4õAä´4Îð~ë‹g+±¦Å[ïz‹pØõëÇj[O·œý*rú<,¾8@Ä<9ϦƒŒîà^:¼fe‚ òs6ä®5lOønÃO‚KV]**ô8ã aM«k´òŽ ø±€–^ô´—T¯*3‡.¤ÜCá5êuÖŽ. ÈYTP÷;¾…]¼'óç¹öbèHÇñ…îÚQÝà0tDá´|Sƒ7XáHLÅDó G-HaÐ;€[I’c@wp¬d)M.Ñ,`Ê]\?[çèÂo ö5´û×jª† [ïwÝd"ÿ<ºëÄáÂô¨…2H-‚…c†ag+;z;t/½¯wĦ¬E¬º¬ MŸ^ýmô�ÛÅí<çÞÏx±,ãâ &$sØ4)š(JRaÞx€Qn×ÛÊliƒU7sÒ;}§Ìéɳë æÔš¦{©³<ú¬§Á¨ˆ„9Š/‘v§d08_nF ¯ì´„fæ”jSˆß‚Pì ˆÐçžïSi_©O'h½˜ÎHeêí*ˆ­å"“£2?öô©5‹¡\ŒÅwôµáBoYtÇ‘Tg¬n÷Cw¦ÑºKä:åà:&ÍI+écg<[åE ã(ó‘õ sOIν2¹ù¢fŠ`:õ,Ã.Ð#r¢¿«`âØ«T™Ö|ø2¾µåë‚£æåXm\�8>¼)F“f© EÜHšÀÞËmEM¤Íi  ÙwWúOdñ_qjTJ~à>úcåUB47žáWÐîZ@Y^}b‡XÏVVqª‚dP¦z—›]!8ïœؽË+žU˜øœ1)ÒÙÚ¸Ò¶nÐ1Ê %Nc³c‰N.>´¯ª©UÛWAj-*²ÔuhÅ‚‚Xô㳉éö7?z©÷ká}•iÙîŽtJG½åÆæž²3÷«ç­zZßÙyUx5~Þœ`Qgݲ¥ñwÀdRŠ®ó}K4_™C‡ ‹­Y;|ïæA ça%~‡üCyœP\.ü–s ·Ò N 5´Ö7ƒØ¢µÁ_žO³bÏ]õ~(iež½®ºÓVÇŸî<£Ž‚:T)­2°A`÷Ê+q³cvì;úøT¾ša)‹|*0Ê€1ŠUáòg¥àMÍB'^öôótq‡*£ç>_ŒE@Âs‡z¦˜Ñ×½Có~ŒþŒ¢2óIÃh ãw:rŠ˜ËÈü0óiwý2 óò¤/B¿ÿº6TÞJKùé v<²&æwœ™«ö†CýowïG7s@wD°*E»®FÅøið£À4ßÎ<¥»¨è XÉɶªo :TÐ……ÏS�x‚ÊgŸ‹ØôfƒýÆîcIƒ ·î~ò œšœç‰Nèݺ šSrîv›Áü5zbæ…8cÔ4Sñr²"U9ûN;kûÿÍ?¸ôVR*6y”PÌžï‘ò[õ~4d‚å‹G-ðŠsTNÌ;é&0-ã˜nÜW¡9xÞõF*Á]ùr:¹QªÆ8ô¨ÔPW_×2ÎÔ9'sbŸ¦;VÏ/R9•Ÿ4ýþ× #ôR̼„~†M` «Âê oìÄÒ *“¬àÁ[mTÇL<[àâÄÒ\–h%óa3:9B¯2§·IÒF0µšrŒñßNjô— ×$Ú‰¨wÊš^cÇaš¹UVáH÷>³îLÇØœä C>õh„H%úo!ÿ âðê[÷p¬ÔMh0Ûý ÔÞÄyè°ÞJ/ŽI”¿~u:l•:‰$äžþœÊøÚHgŠWœQé ‡y°oé£0Z”¡pþ»³5ßõ¾fHË&‚zjýõåýßÐü÷zuëttìà•N x§É¿ò‰~q*“î‡RšÖ¶5¨D:0‡àèÍ-¤ü‰g*Øcë ‹ôfµ:YF#9á³€Ï-L$ õF?FýØ_†añ9…0¼èßA7ÌOn!ßXçAÖ×^‡iÕïØ S‚'Ç^¤{—˜•œYyƒµ(‰2ÏG•v3ø4Éèëü6§g ½÷È4•+$ÅE‚*ß‚J»µc’öhº@<ßÜJçË‘>vë_Ž[J^ÛúcupìÖTßù‘&~P\ î€<6²³Ž[¡—³{ëcÑ Çuæþ=ó^hT?Ò”;ßk!ã3Ëy}wŽ÷·ä¡ëoÕø^5ƒô¶m¤u‘`Åb•'CÎ;Ô�ÉåͶCã`GÑA}Å=õ–'Ò‰¯š*}òÚQÿmŋ鼧Sq°VºïåÔeáCöiÿNudÀÀoÁìcce¿‚=w¼öÂè±N�ѪÛÉ¥"îqz‹ŸãÓt›7xݬ+Ð|«:Zd¾™­-H­áùÛœ{0°bOpz楚æ‚ö-H*öŠùwÀVqè©xV t˜h‘:¯NwfÓFØÓ,\ÖpÏx*õ¾æ£e)I9ËzqIPZá_ôJ§¾¶† Ý-î22Ìá5Ë!.@år##€ JJoŽ&÷ŘÕPüØk…™ÇK¦ñ›â ¨ÎF\DÐÿÀ±q£*èÈIÐþ0%¸ÖÍÃià„óöBðíTøpËóZf © Àjè¬h£–µ±? ÄQ§fîV³ºˆ©"?ºvör‡ž/Pcˆ™@yÿÛ›.Ñ2š/£mÂ̇ñûä„K¬~I^Yö±ôÄÔrhÄÃõ0üÚÓ2JbÛÓa")JaÀ¬Ù<«éëÂpëc_ÿ[ÿÖ¥ÔÈI«¦ HÎ }âÏÞ•æØžR’BŸŸ_Ù0Uù-Â( ö19T̈€ñOg¡2íx¸ôJE/SzÖˆŒ4µ­ÏchpÑ[Oƒþ’¬dµ±Ýºþù8X ?›[¾Ç­&¯l¹„þ»œMãu‚0-¸å¶&ïZ™.›S¯þÉó 7ªe0Ðruè@n;L›v­³J¿%ü'céQêÑ´mKö`sNPtã;KRêé6 æÝÛ”ÇÙÂìœXKß°œ>òêKq§JÃÐänɺ/»¦`<…û!ó™Á–UžG’ª�Îtî.j“#MBrß×# p/ie’ùBÒè‚Áóé¬E ÕkÙÏ-Ðç2j|yI9xép›J7§¸’Z YBŒŠ¦én»– 9¿¡Ín`Æ·‚ɱЅF6fê« ´. t™a±iÑ¢0€�øà£òÌq„¼ÉV@¯w˜#ߢ£ó̇ØÓѲ2ÂV¡ð1¦H¬À%¿lg’õØB=´–3_s(΂þ«9Œ¸¯!ÐzÚÛúõ-KÜ¡‚ó¸¤d½ ¢oÏ®’CÐqX®>æªòðÿr¶äzÑú(ýrâË÷úZœm¶ÕµÒÿz¿&TrZ”™ˆ<ŒÐë..«Ç¾3qPóDÑœëwÇ4¶oQ™›åO.*è- ôŒ'V)”¶Óû¾—Q˜º÷Gì)}+Öß^mIïûÅy¼‘¨üE¿¬Ì^[E0Sª¡:kŃ€(7Ãä;õ—îé0ªYol]wîÙÓ+gAÓÄAº® p÷qê­›™ób»sõ–¥s_RUؾ†E¥#uŠð•:CgÉg>øÜÕCa¡8wEI W =lÇ–®”xo$§m¬ågOpyû×|§…mzUç,È-w'6–ò<­1éÓ@‡ o¦çaV‚BC{‡9Vti<Š L2$¢ðÌ9ßÿ%ëïEQmѪrš`™a Ÿhdߟ©˜ƒ©@Ã䨶™ÎèG*ø°¤¹1ƒjª èíREøZ‡3ÕÕV}oþø<Ñ~ì†iÙwPã!kRÃý4ª%€7gA8lͧÇÝ€”¢æÆà„ÔbäÅ‚÷ë7td)hPÜYÛYÌák€]ä$¥ÑN‹v·)h§|«» &K¼³Íž™÷CkxA§É†±j˜óÈJ»E?‡Ž �4­©(H& ÁÉ%è�ˆ«‘–˜ÿUüæ®W«_\™OL›ˆVìéGÛž¥™ ­ua}}¥æ…q•ë/(¬fqÊÜ'Vm‹eü3ù5ËKIõ8Nü‰ˆÁÑ­ÿY{ý)fêQÎg¹#´<âs_1-ñ+nz‹íHÅÄÑL`ùsÛ@å9D&ß^X$F·TÄK“§œ-eey?{VŽHw/0[™‚K7ëhÀ#Q?¼/^yþÓÌ}æÆUL£;q½€$¥%èç«o&¯…veÌG¹kÇ4&·Ê@ó{P‰² îÛP; –TqÉÛ.¿Ãuzø[¸ ¦÷¶©§¨‰(IgÔÿ®ˆŽ| µ’ãЄ8dIùX3Íea*§´,nßtÒÌyñˆµ…¡ (‚iÊ™?"Ü ~qךT4!z6;JXÜÅaµ]:2YkÊož£5Hÿ|ñ(µÆ]…S–¦¿Ð½ð¾*¥ø¦˜T®*QvŽÙ=;ÖãÎAv ã¤KµEÊ1\¯ÕÒË,xÑöTtŸI´©{xinE®Gíž\©€»ËýRkäüU ãæ'¼GׄDÖ• ÂßðÓÄ©E`é(÷Jýjg–ŽE‘bUŽÍE¼ñÐ KðݘáSCR�fQPZlIœ”Mà!ú¬‚ÞS§þ ‘?,yœÓA0Ø7×6ãyûÔgy×û3{3¹ÔL¿¤OÞZJÕ&çÇ;Y–gD›Ã}Z-}}¾ÓÔw£íʨìò 7ŸPxÜ â0݇ýÎD‹÷îHd` 2¯ãùVÓý­G mÊ¥EA„ñÎx ™Ÿ&V W»ç?eMúæ9§q=\å‰Ú©fq _Íè×* ï÷´jú[µ6a/I3C+³jõ¨4¸ãûðcßê°2J/gÚpïYòsb =0øQþ;Ô›° k:p¾hE¶ŠâÉ &UÐÍæá:¦Å ÎE’ži6F¢´Þs«öÜ­#Ñ,(ëú!¾Á”Tžè=×g D³ÅxZ>ï|h[m†œ(‚Öœ“§ú,›*<}©BL›¡‘ØzÖyíkl=Ö ×GÖ¿:ôî&¤ûn‘J»$=6úäóÞ³y¢åŠý¼¨D¢H¦g¼‘㻽¸]0Iâ„ÿ˜zÑÂ'#™­54Ì7éŒ3vX’ l‘ƒIKùg€$‡¼d": Æ}±ããvòGÓÐÀ•€üX6’·™9ÏYÆtÜCœyôdi§t¾gAK›‰ã‹½ Lô‹Y°h8ëo“ýÜßXP!( Ù{ô>(`·xë“I£)IÙîĨ$½¸›ÉâЇ©�RÉqöü[ºÑÖ°pËZ†—眔ò‘Ÿa…3&Ó‹~úØø»X$<þîÏ’|,ÁèKÂpe Óžjýc¢,¦�†‡S(šhÓj¬ gsûtëDÐo|{r_…¥ÛV3T�çÞ³þ˜Ñd¬Q”oýáv‰¿Ü¸L¼Ð¨@€Ì; ‘ï¤,ðxZŒîáÉ9iBÎW ²8TG„ø¯'5iá³ ˜š"lìL'¬(ÎO`o¨äAŒ ÍƒZ(Ê=í3!½)®ê~E]x•X-›í=DCî©„Y‰i»U #K·[3•�iÛQ©l7èo@d¾}K…ísä®:Oå¤þ׺î¬w¼Gžªã»þThlÍú¼¢¹cp1ÖÅÓ;ji[Ö½' ‘d.ÉHÅÀ&‡éÛÉÛ*Ûúb+ Öô®0›†þÄm&oí\¤ 4SdÍÅ“Cœø÷B ¢Hý@Nñh^ÇŒþ1˜äúZßMÒ}#_W‹ewŽ¦pÛ:©ò¼‡þÚ” c“$Qû°cBÍòT(#§˜$(ãf ø¯7ªÅb5À<lŠã ÖCò¦ úŒÍ02#œð ý Bo Óé�ïÆÁÇ*ÅœV]P,àð‘%ønú’úÜž–ttþô‹ T{)ºû—£e«¼ùp«Ü€ ¦ 9ä:ÇNzÚC0¶í`ÑHÛǼˆˆ9“<°ïþÐßQLcJÂ)ÁîO»®§½„D@gÃ3ðä﫳{Ît\=kúcÂm­Aä[óP¢œµ’„Múo¼ä:øN¢\{ßÑÁ;¶ %‘jž1 âÚê'úZ†lêÖà¶hß½¼A+ç¹O/… Å!K‚tÒ°€¦ˆnªâ¶ÐaèË’‡¤¹à®üПUŽâ“‰kXÉVP¢á¬ø·;ZX:kr:Bƒ{Õ̬*¯ÔѨzKƒxÔ¼ÁøH¯O¨8&ÞÙÜYÀd~w@ǧe ÖUJéZäÖf. ï0‰¸ @¦܉¦‡ï¥o±çVÄÙb°=ÙöíÑÈ(q¥ç3ª¿…n#ÜLñk~_÷‘ÔoœDr#Åj“ÎevÏîµGC¡½6ýnÚ:?Äwü³-lQ (ŽÍuÄÍÖ£:`$ZŸzËó<±I­üÜEúùVAh0«u{²&ì=Ÿ ð£’)c‡^ÒÅ]¼ Ã+2 dÙÀþTé|ÔþU*~…“¥<ðâÇ2kNÿþ øÔÍ^×dBÖÕ&´¥`üíkÆÑSÜïP_ÿ÷#3 ˆ,°?|©t]·7'úR´ÿ:Y,#ÈË|;Ú˜ÜÕWa Ú¾hyç¡ÿÖLìŠüç~¨¿\GË“ hL'¢ñõ•ŸP] ÐÈêjó%”Õ:@¸eåk®\‚O&'p9f¢‰mpÍçËಮS‰ÜÙæ¤x}¡l­¶ÊÈ7lkú´éÀ£I–¬¸wȳ'[Ïõ}3RBÑ7.«D!Ã-WÓ@9ŒG“¥=Ô³–õ‘´ï3q`LG €ØrMuÛµ—–vÜKÇÅÈ›ub”Á°‰èÍÖE à-wvÖ¹?MW°Ú}×/ÌNoÒàˆûÎ1¸Z°üvZRA°Ô>úêú íÚ©þ䌥O:$Þ!äê[y8b>ˆÕßÄæP<ËyïL°rß"\‡aÿ%ep˜° „;ææ‰]¿Þ<AK€âÉ•»í¶ KìOÙ”å`A“ â,™}××~ù]ôŸ"[ ’Äû6é•Ûž¨8t¼X|üÍVÕ¡Zw\WÞKï¹â–^•±»:˜C¹}¼e¶\9T†�-„lUÛ‘ö½øï椢A8ŽJ‘Î2 ³8ý4Äþ¥g¶Ð7¡pr΂ªýöÈ»hu‡¡;zþªe-ÆE°uƒ{ìÏ·kC®Æz�=�že'ªG>ŒïoÄ£EÁ×PÖƒ¦pÕGNS›ƒERñ@IG¦——¾ÌBjºÙà)#Ù4–Vͪū¯½%‚×¸í¸ ,gðÂü n|ZÙ™¬p“+;Gf9jJo�¤ag˜c'2„§‘ü¤ke• $²AíuBe?n­ò$7á橇~f¿[*û½«¨uåµ,e¶‚@zô9;Yz+Ðd8í@ó7õKØFžXo=a:pÇvl½”܆ÃfSëÐÑkÕ¾ìÚ¦ÙÂx=6Ikcc¸CU.·›QK½CŽ Kürü˜œ-¢”ˆƒÄUô{¹”bV‚óø�¦Wò½+Ó(3ÆR­1ÿàkþr­R†³Ú<C}8Ÿ82ZÀËoz‹×±ø?߉6aüß1 ²ï-OÞŸ"_“C¸Ü7ôL¥æ4½Mwô¨ü÷]<vŽîå-¿{,U†¾s8ÖÉJ­|C ~ÄÞ³…¢DÏÃw”²ÌJ‰Ò(ñÖUH Õg,^(¡jøsè¬0Ä/½ ÊÔµåX#xŸ2�báÀ™—ÌkÏ>ñÍÆ_ôËaÏŒšp‡éümÍ_þÙ /z; ˜Àl¢0Á2H:5Ž&+)j–LJ÷òåî_õái]nbŠg?ª»rô=‹¤ÁUoî_]׊ö¦DÆßm®)nÆÇ71Ž¸%R<,ŒO?„N"_Ÿï‘ícVf®ßýÐH“—rI¯ ÕÛøQ2]Œx)OèZŸ­e+òA¿Ù¦Ù”ZîúÆΞ‡Ód”álHà�7kÇ©í ÀŒîl¥‚ù=âO\5Ã5\‰õ8åY>‡Âouò</ëÓ|ÚÛö–£óš­Syp~a=t”nZXw¨”¨Ï|¨Â"1æ:fºŽÀ{Ý@!8Ø:%ÉPyKj;)‘©û‰1½RO½å-üNè,Ÿ¿#hÔ­Í g Ànåó‘Y¢`ø`+©å7÷èßeájN‘xÙdTrž=)k6f)9¼ëÚ•VnÃ}Lö+:n=Ößÿ‘]‘Å*sùtÔšÖnøy´pÈÍå2”Çæ'i¹˜íлÍYÊí„:`C§Uh2’BÚgfÔÞ%• Nañš“<õN-á¾nzZ‰E­;x+p)‚€•³¹#5wç/³ Î 8,‰ °)šÖZMJó¸ñ¸ü= ßÇ㎣à5|°sÝ</dÉèü$ÙºùEÆYE¢&£U§MäƒòLàk…lYbo!}•ñÑse¦Èš T†Z»jbx‡®½Qc WsföËç¤ÛÉ‚C$¿gÀfqæ”TÑ š :®ñ¨mþˆ"¥G‡_gŽKuµsÿçw®í£Ë T…¬Ÿ™ôgÏ-|å`•2ü?¬7u4³ÌGÈRÜnË ßZ]Ç 䎒Ró‡ôô®LsYѧÄÚ�x––0g—]fý%"ã/1 ­„QõMàæub4¥´´ïè�ô ©Vl´«AµMº¥ÇÆ>ëWgH”úb,ŠšîTtšœÓÝØÑ_ð}Ú°×ÔÓú‹ùZPàcTå0îæmÀš"ž÷Câ¼u…FÎÞ©ö‡Ö–l4ýÝ-¿0É„›Òv¹¨ààˆ ­—·2àè?U2îŽtXó¢‰ ”ã«ëÙÇK%±¡áÓè?™ÜõÚZæNß©Hí¯A}–ÑJ̹ª4ÏÐ~·?úØd’ʸ£«™DqìÊJ‰V ä½m½”ÍÅiOj‚jC+á <|Ò(®uK) Tf×z0Æ[7½9­H¢ÌØÿíŽôk‹­ê%ä�ÔÛõŒ/€Ø'Te»„pë! \DÌYâZŠ±U“åfK=0Ҭʅˆâ›ZŠIé»…ep^G€3ÛJ íÐÅkÖÝ6rlÆÏ^<†1;9 Ƭ¥@u¦23ÿø\{³M`'{ˆ"ÒÛÒ –C+†÷(›¿¨\ kÿ°:²HÖÖÓÞC¤…Ý »%è”á%À>ŽÜÐÅapjò TߌYÏæé˜>$ÇVUß0WÉa–AdÎÜ5JøÆ=dÙFÍ;S` °ܸ‘{+Ûö ÓÙ.OìEò[/ünµjüî;¸‰ÔV#RÉúYñVGÁrE#U`KÏ´WnWÎ …‚0' hÍoÜ<£,wÏX¤©(¹Œ6'O¹ì¼;ÉB8¼”Ò»ÔÚüù<§qˆãœÄ°uÕÜ(ˆã=÷rÖòNëŽGºáÅúXÙ›¸([ÝR˜=—AÚm9z³œ#@X 9Ÿ Gû;ßòè?¥W<³hB;ÐûûPÚ eƒj}ìþsã6ä®n»‚‹þO-û./‚Ò±‚éïñÞßTv‡Q\©ë^¨¯’ºI¹ °7ñ6Éæ+1û퀿m™L­÷àc]{ác½í“ù™`œÙÑÎBlžŸVü+èU˜-üh,ÒÑômÁÞg·�üIf :}ãî¼›îνEÈO+¡H¤à²ñl1”ãM;T8ïÈ‹Ò5dÙ ó<Ñ*í´BA`ØvJÊnúô×ê^àÒúzcšûZÌò/ŒR=*ãLdzÍáÀM´ZÜȶ;i¶Ž•¹ÝV«:SÖ>Q´=Œtyv÷z€g =î”QiÖâ …ƒš«CGR3ºd˜„S‘¬ò)0<*—ŽÑ,·šfy¨  xp1 ùÇúƒI-¼3"Ê{éͧ£7ûÿËEL Zhs6ü¾3l;Å*2ÐÚwƒmE /[; ydMÊ5äKxÝ-7Êcxž‡­Œ8an`–Ö+Œ£Bú)éA'¢P\A홞D«xhwÇE›¬,ªl!µ~^—A|ù4c�TÜT‹|Ÿºñ0¿QHú¬)àWgt%o“Mý Nc·èÎæ +X¶ïFZV®=®®@m•´Dܦž[L‰ml«}[:8œû]š‰JèüáÏò¬•ì;þ±Eäz‰ þ–qC¿dV”­ÛºeÅb&xðˆ…ª¢š“æëWÜœÈñC#ôå& ±u›ÇC¾Aô8{á~ó›=ÃÎgÖñ’óüß% Êéä `àãâyƽ¶‘Ε©)3ÿÜRŽjéFP]ÇIib�DWaßiøþ[ü92-¹…™¿/#£ ’º3³|\Ü-Öñí½úE§nÒ¾¥ÿ¾k¹u ´Ç·'ëQ/‡3&½¦G O»w½P™{ŸõZ8[A!zô´ŽŸÖ§q[úÕi° ´{…¡¼F¢"8fIs rÓgtÈ £¹ßE*ËŠÙVÃñ]æV;N@è΂–pñ@ ">Ï!…ŽZÃûÔ *¼ÏtÈô®;Ueµ°'Kxv–¶úŒ¥3ð ÿ~°Óc7{#Ñ.7c^;UsW¾<e-0› (9ÉzêÁw4pó•ÇC–È¢³5L(Öžn5OŒÍù0wûcßIfæ_?™€ØW¦zo'Îþ­Åyö�LQ@?kÁÆû—^£63ÎghÞôJ³*ÙÄàâ·&ì’Üã¢ÃÀ›`}êïæm8?dl_aï~¢pSm¬‘KàŒÅ& É?ždÂrß@­Tm¬Ì üÏë4È]»@àçP»Q"‘´”¼sîñ‰Ça ¡våfR\Ã#2Ôa‹‚üÌÇ¥*ˆE÷´¤¾~¼â*3~ ü¦EÛ8ø"t%9OéÛGïwO†÷~`ÇIï,Fÿ,Í¥ª÷™¾†Ã™O£…‰’eȉ´ˆ(Sál[LL8£÷„΃ ¾ ÞÀ{QIÂj®çÝ)>&Ð’]ÃÒL&·˜›tÊ„.L=Q1ùq ´þßTQjµ¼üŽïwZoy‰UŸ+ ñ´ƒxƒµ¦ÓüÍpËW}í)n™¯¾†»ôŠ*KhÉâ¾÷ê}Û^<Qs®ÛAºëÌñk¹MücS‚÷€ÇÇ[; ” ªÔó|ä6Xæ>µ4Øm„bxpŠÔ�o°Rðc™Â<.òÌ’oiÁõ(oXY32’âõȘ%7òB¥ƒ‘£¼Üsí²]^nñâÀ<(ŒÚÛ sÂÏÓ°;êÉCëþpÒzùÝ8j”«­ˆ}m`•s¢�Zmôn$fsÏÖ·…v‘|â÷ÙÃÝw“þ,þO4¥7Oƒê[ yĪ†‚ugòY#*<[ͼÀ¥oâÎ3›2sÒ!ÿ⧙ÉríŸáa˜±ÚR¤Öøª ÃËÀ½áÆéѼ£>`ÃNid÷=¥ëͧk}4¿tÝS$Ã[/_×>`Á÷#›·Mš—‚Ä9íÆÝT׫3ŸÕ?¦Qå¤É{¹ÖÖ½áÌÀ¯¦TÏh¸î/k9©ÞûIÅØüÛ{î=q諸P2°ú“Ùö[ Å$èØiØYèžÍŒ÷3×c Çm sÁ~¶ÉQ¦‰´Ñì m[Û:4ºœ®öðñ<j9Yù¾Þ ‡~'õq×oÆÝ~BnÇÞ øÓyWÚLŠ"óRm$yЦ‹ìy ½µ½Ë{¤D—§¡ßjB]„æ§ÂWSc]‘Òî[æ+k8ú]1ôt+C¾Yý¡j©ÑÙøª¦c .I¦3U~Ý fã®m;¯?þò1£ú1©wd¦uÐö*ôy°´W»ñÞó>–é%Ÿ1M&YE°¦ê"ðªoE)²f«=G³û¸öÌyÎ çuÜœ{œœC¨òÉëÀ6Â4Ä+ ãS-H,·ƒºÓ`n†àâÚß&§i¸@QnVéàt¯`Ôƒ»Übœbjl£.þTe<ñßCéàGy[;Àˆ픺;ÂÖ׎I–,žbc ¤ iî‰Vx¶ˆÛ>Cä– TÜßâÆÊ’tê²ÆÉâiJ»ÞÌ¢MSxú†"WÆX1µžoNÝ4V±‚v½ê[E‘ò¿2á¥3ÔÔ­™“e\ÑÔ­Q_¤ûIëC_Øƾösœí¼Ã'QÏja«.ÓY‘ ‡Töj„RDŒµŒéÂô(þ8=ƒT5x(ç ×gƒ.ªR«kež->ã¼Sø¨Å${W·ãŒî¥+Ç.g#ÂÄFÎúû´ë%(ÓíÚ0%}¡9üœ¼škÚ ›ª’~uv¶éaÊCpyåñ^u«MË:ÊR㇧gFò–ëV=hÙì‘IáCOæk6¸‡jùP÷Yþ(€%¿æënùm¥v2W¡aé¢ù ½±òÚÚ•ZˆÞUÖ}D&Ø«ñpiïʤƑÏJCïŠ%'•3àŽv³ߘÇ$¨5ÜRÔ¥CZ«fÏ ™ùá}%¤Dá?¦œ€QY­®B1|¼&ž+ø#TiÈÿ2î?ÆÑ ¢hÓAh¶"¢ÌMé?†²¿;™3@ÒÛnl¯mV^ß­æÃha,ï ãbÅ›ŠB'˜pTɤ’n­õO=n.½£&7xVø"™³ôG8$i—åé?Z쌚 Ó^?×% Hºv鉋GìîD}Ôx»và»Ç/[v×ÑÞ0®ùÍ ­fKÄQ!Ä…>DÈ+èJù„†Éœtéà<ºf­­Ìª§‚}êK>zå´œŽuÛ} ‹øßÒôX~ óË `1 5 Sx{n,y—O§Œ•mŽ—¢ƒSr•/ýŽˆNqÕîáºï¤Ö~GO#²´xIƒ)µ8OeP´?Å{É£½|Ѓ›^ñòÔr*p\djÕÒ{®ŠF·™nõŽIKâuy€Éxû¸ùñ…0B`ÇQ´KÀ½÷ÕÖ–ù‚±B•@J‡çF“+›‰/€wô²û±í4î¹Lò5¿G™æ=2öúûk'å!šÈd†Ì¶>ÿ÷ƒNC—ç<NàÒ%·³gSÈŠ*%Æì·™¨jOža }@iTÊZ¤åbùÏFµ^é¿ð^¶aÝHCwb––ùÎnHwk=íz7¶.òŠ.Äiz~p’Ð;ɉR…¢ VhQYùëëäóišº$Ô`”‡<;ËçDh^ß›Š¥~ òwiК “% 3òÔ¹¶¦¸Oµ%®dÜòº÷_ûšr!Ù\ž‚ë+wçCŽhg*ÛÊú÷ ‚Tÿý ÜÃœ_;Õ<—ú zÁQ]–C°ghš,–9å»ó7}©ì€–wkÿ Šzc<ŠTn™ ™åQÑ+ÎÚt:3ÒÄ›È Çë±nè†×Nýÿ>ÔÚA®yVãLi(Þ›F{§§c¸è´›æÖóF»#ÍV„4ѬÕEž$ò7²á–MžéWPe Ó4zG3û]:z¸˜ÃÌÙF!)ÃQ/€ÊO `OŸîε»Åº2Nè\;×àñY¦@(Ör:É:ÐWÌ/’…ÿr ­Mk‹ßL˜xØ·õØÝk_ÂæÛаˆ–?®âûâõq: ÷”aêêÊnØÁˆãòê¹UáÂÉ5¢2(«HÍÆt ”zfV8-9Žx¥' ¯ìÂr¯øŒB¸3ø~±Ã&I©¬:ºvµJ™{ÓÕ“váe)¿m|RžD´YŽÅT¯tgÏ–aútŸú^þåíqœyÌŠ !•+AT¯}»„íÙ¯”™ŽÊ÷VS-ñ:uN‹¡Ë!:{ãÓíá 6E„îÑg¤ð¤¯˜lI›+€¦¡›>~r -rek£Ú¦Z<æ0²èךéË’?«ÜT™Yþ_s$[LOk¨¡Ò K|í…¸ô¦%l;Þ'0Å°›¡ðº=9ªTS(ÁÊøøUƒ¸¯Å÷•Ë¢¢òËfCÆ/š^÷=.ÝÄÙ‘Ù]üƒ×À«`ÎF l2Dï0kR�DD¶n™¬oÙ»˜„"ômg`Ê5@ºÌ6Œ2¶¨ä�®2UcÍÓo68uÁ7-†èŒË=q[îË€‚•Í§§Hw¨×&©ä r|ºßw»ó³kò¯m:[»¦©.‚ʪS”ÜÐc)B=蟘Köd>eõ c3àY_"žË99˜¾;ÏõäÊÃML{Š1•Ò» 8ÐÛ¿FÆ Þ9,Šú\¿¾ø‰ÒØ—?¹å·UÈ2pëvç¬þçõÿŸµ7ÙnY¶ÇȯЬ&·Ð7C€� )� Š±êÿ¿£l›¹¹;؉Š<k½„”çR$ànnÍnN p3¯ÆohA£Ì29‘YZëÖ‹*ΚU–¹ ûO‹+ܧ°¢t~­¢%Ûû(,*“f.ÏÎNÐ÷D”&èÍ-I:•[}"™€ÆGƒ\pÜ»a³—/"s6Mêñ4\µ›­º-kc õÙ)©Ê'¥ìŸÑ¢OÅá^\ÇÖÒ¡÷‡ïÕ=·“vã¡‚¿2å�'ën„xàF¦3Ä�K‡ŠÌÕÖ]\qÌà毱Øù¾£ri´bKE [­ó�?M¯†C+š`Ãs4Îûµ3§°)t-*öè»OË<á$5å~©J‰<gminNTL•ŸÚF¯œª!I× Üe·hL6#Ïéû^Ñç7¿0à?Ïó32P©F‹7ä²GZbÀÚ×çá¯ä®KïÔgIáYÍš°œÅ ¢vªG`Ìðüˆ]U™¿—Ê`8ÒJz+:É<Ð3eTÐLÝFøô¶;˜Ì«X›|¾åOž×ªÌ§éƒ6ED›Ao;8ËÝ\[Ã+(k³žÃ þ?<ÏR¸ã#x=ÕØi¶{=Ô­ ./<Ô^ñS‹\:³ÕÐ |¸ec­G YÑÈÿâÄìˆä¤é”A‚”~j‚”f,ÌC;÷¯3¤0vˈ§.�¨§ÛO%/ÖoGà×M­GÍ­HK¯Ä ²>æ8ÈÖ55©×uO‡Ø[sÚ1]ì_¤¿RR‡Á–Ö腾˪>õµ‡m¹÷­^ûªYèõ Àऽ_å`YùÀ1õkùfRZË{O_o-¹¬J«Œ(üÍ\rt¿ä™izàýLFóº¤ÎµÀŽûk©€}¤A|¼x”M½ë]w+Åù ÿÔéN§Ozì©Ðšß=Ä:[ ëM£C»X<ëñjn)gJ› Ò–ždO…ŽYjFâoùrÄ(þQYšŠ2üÎÀD˜d2âKZöo×OœNò †8×ÍÅb�œ€‰–ÙÖòV2vS4âÒ¡ŸÝÅcZ”]‰Ù·9B<ù8Ì7Lã$µÆ†¦Í7î6Òf]± «.êòØ©7FBÂÝB•wPIåŒáô£?ï¨0ìõe‰™ ½3“Óε£jo =–C¢u¿÷$JüK­&•Iï¨Ü§zA ]p$w R~•KôŒ)Ô̶¦•`}ëdÏ¢l"Y·odEÉ뾆õ?Ñ:ª*ƒ‹^± �¯¢¯õ ‡ýðYúîòzñfžô5‘x*š^:'`Cõâš[ÏÇ¢ %%©Ô)OÖ?$„©o'U½ã€õåHõ×7œòæ�‹‘€-U"Sªô´’‹Y H6[¢SS±f·xPwµXk‰¶a„ÖD)$O³cïà«”—™Sü‡’¦¦Åã…Ÿ}‡ÚäÓj*ÆÎëvëÁ³;pZ»ö)Q3.]†Ø‰v`ÁêL渧ò½5T°°C½ÞvÃpø-f¬›‘]»®þí‰"×®îß *4w†«¿üŸý µ“á5=™g%*&b”¶h¥À‘»œG/YReWvöq…Ç…(ÎüE§ò$È›Úï†Òâ3KïxéÏ:ùn.˜éïòoÔ=}¶­úŒ²IªF(ûzz,Cý/(·Þ�™%¨÷”PïŠ-5ºëÅ$Èšê¤$ûÄ;:÷©D²V‚Baé1úü½í~p,÷!C 6?XìÀn:1õîí’soÌŒmɃrTñiôá[„wÆrJõµ0æ¢Ù’¤ í[hx]è_zšäÜ€¥Ð‡ê‘'•"Ýgˆì0çR{¥ÇÂ(I¹èJÑ¡²¢S·|W}?´Žk>]{¨yÉcO'§öšcq’T6ƒgÈùúRpΦµ0+hžK\÷ô/OHÝÕùr^Šmä§{äÑ1‘¶ÚPaÀäl†ö²q^ƒZÒ]KÀ( }C;Šè4¤s‹^—i‡h<Ñšš)Xk>ÒŽÆÇGì³ÞEue©uÅ©éo0÷›žé±Aן?OÇ®iq¾ùQÂg¹UFs,ƒ%.EƒÓÉÁ ÍøY)ÜÃ2/.ÓN3ß’r=¨žY£s²4 Ì¢3û>£;ÀœµîxijŸè8ŽœýM%ÖL´¥ÞgëOk|?`ȇgÉÈhí;ÌqíËmÁž$I^9MzÚž #‚mOÝâºm¡À"7ƒËz-ˆâbÑ6‰ƒ= xÓÔC½ˆÌõàH|cÝš±Ë Á £d÷D¶}5RºòyòAÁ‡¾¿t£Ã ðÒtšïÜ2‡ó–F÷�·£•@-*@£! ¯©Â1Aï£=C{ǹÏïÇdŒ¸Â¿j´­5§V—ë×eúšÇPWšó µ"ümÐy¡uHÁGIS?m�$^êÍâ1%ÌÉØyø¢Síî÷߶ÉËÊú"¥+(á£?ÕêmŠÅ]ŽÎ¶£=îŽØo5§6fúꥉ‘gY«ìÇù\ÑåÝgz.c7ðY6´yÀò²zöoõÌ ®×ÝjK»îÎÅóÚ?¯|€0ÕÇ® â¹wahÓwCWÓ¿:NA›IÒËçÀÆ4¶3,cçÜaÀÚ͆©ÂU9…1ZæáÙ [m<>¿nI¸(m‘A´Þ¨æ*€]}ZqƒJI2xC4~ò«ÇTÉ<q4@r0€¨˜?Ôźî!8‰A©¤¦£ÜèW4;mmjô?P¦Ñ·±úØ< ¢ó†³9-§–6nÜÜ膙 gf”B ÃSlÿ˜–ëÌä –—X"F8>‚§Ýž…5í€E£^a'%|=w› à–LUü#ĨS`Ì£hÍÑ{ï3®:K¼¦5_Ñ›•:.rØ�@ qP6ŠHŽKÓS°éγZ‹%dd{« ”ãT“Z""w‚Õú¸Ö/F+Y d¶ñÈUé)“Ûhª–€i‡žP]RÆ^ßÏ”®k°œ¶'ökþ9_*J—àQ°‹0ºý2}OtºÐê†LÈ9à^!Å©ßA§ï"n—v\¼Ÿ‹ƒ€ÿU÷?10hÖæ¢ûÕC¥º9æ˜%¦D•S7=¾ãcZ-KxA?º¡*öÚf£…Òš®í¸�Ÿøt]yMïp‡YÄÐÄ$V“­6hPF¬»qsšl ô]+tWϯp{‚â²-;Ñ §Š¡•J“n, KËÞñwÿÉKn štGÊnn†QÆŒ5§Z·õ çÚ/oóåoéÛ±¤FDÚ¤A5_<I÷6Ü&˜Ÿ'Ï:8«ínxMÓ1Ê|åK:Ÿ‡® үΪpA ?ó>^[|Oï‰p?‘ã¶Àx5ëF€mfËÇïZÊhŒÙ›a70­}ª¿ …ðm`;?åä>µó³ÝÁ±8^䣧ûö~Væo”ƒ5s]üôŒïbweXµ0 L¦‹§åßÎ>ó_˜…6Á\_úön+Z{št \Ûn ²áª‡ñJ�y™™$Ä––bÄ[íM�zcžÂ†j4ñYà :¾läæêƒÈ¢a,ZQ*H¡¥S½"VŸ¦²Õ`¾êŽb”éi=ô7HÃ"Štn0»#H…)´Ò2LSn×oO“TË 6ÿº¼¬!|#ìýD_Û7 ÐÕË­nAÌø¤–¡UwZÕ@•`©šÙðíŠ),½€ó`ÇÒPÎý©¢7P‡bsI$tÚcݾ êÕJ»êÛËÐÞB«(µ.mÿ€‘«uAyܧ"Á×bjE8þ Î<Ó8ù™2º¡&õšawš¸Ð€Çäa†Ÿå]&ãêxß÷]øÙoNô,+Î m@]ÌgŸ¾Y)HÎå˜ÝšÚL‘Û‹SG™hÖv¶ÛtdåY¶%Oœ.–¨À%ÔÞUQy ¢báç2ä¦8ž5@¤,Ü}'×¹BÜ<FÞ$±ƒÁVî@˾´þ¬îéÕ½ml·jIî]>†Z¬(7–‰Ã†tÕL–ðƒ8AÈ�'Àò˜Ðþ~9ùDÖüd£íÚfa{ôÔõ°:d.fÙþ”kï Nÿ5ké!<=ÌĦå¼"Ni:ÖvÇ„ëùÓS©Wä¥u[@�Ý¥˜ 0vuÖRŒÞ”Î5$$ã Ù¾kÝ£‘&óÚõÏœ]“ʨçÒ¹‡öh’3”•õªÓõššå Œ §³xkæ?ÙoönagÚ)Ü5tDÈŽeíÕZç,GH‹Oö*Uå¤ØÑL®‚¶²Ü¬2Z¡¡]Œ<Uk¨ñ–<&:=S¾.¯·üjÃzt #§k@T=Û“~ãR•nÂ#’à«m”–\^dõRx®¡ëwã!(ÂŒ†þÍQwU«pǦ:IØ™fÌlf@uO;…Ê-¤±ËΙ%ÒŸ(¯}WžšY&uáÆ{ÎÐzz×A! zÿz®%Ò™ã”ñZýtJ¶‰§ƒÝô—·‡™Mfü¸ÄR9žÈh)^´ÈããÉñ>ð,ýëH_SJÿ¦VLãl<ò ­)uy·Cˆ‘ ÇÜ vUË­¦û¢uk¸|}¢ìô¹ÉÓlé ˆ¬ÀÀ‚L 3Š<ëé€K<…¸o\¹æ§pÎD‡Þµ›h8ýÏÛNFªÜ7Íÿ£›Îk*—xÎØ*èòv¢²ðŽ1ü+ÄJ×iÔl@ëÑ&�¶lË‗U^öFLÒ‰ŽoD§ZdõÚÄ<ª!ªÇf4z4¼…ÙzGÛP]e‚f%‡^Ûm¢§0jÏë{;àÜÓ5+ØpIFØi“!™ß×jwsb±lZõ=”xÔˆOÄZùEz¬wNf—Dó–Bÿ…vJ;¸þ¦=NVç(Æ¿Äж»Lw†ZÅÒ.†’5TiÎ/žn Ù¸E_óæ™~uìÑb§³˜>c¯ª•î…WÿVûÉÙ7š ùa¸˜*„"¨µ¾7ï’ cDAî‹¢åQé–?c!VŸ€‘‹Q]ÓäôÐÛØï.•®gǺ:X8Ò)_v';Ÿ¤‡Ù]A´ ž«üuk!)¼3†í݇sTõÑâZÕ]¸—ìš7ÅSÖïm÷½pÊÞ ˆ3oTˉýK°m‘YýJ¦ Yv ŸÌ\xPv]÷¾ Q•…þPŠÀÇL¹ifq%(NGÚéœM¬Üü&@d[”qmLå]ËWItfìçß µ“'Œ�5ÃQ8*Ê»?ÄL[z$T3Z:ãæL±ûí›;YìÌ÷jHî´cE¨Á÷E×ÊXd¼‚±^ZZê°·¶§m€¹-Ïÿ4âucûÊ0œØ©³œN?³7òb3”éð§ì¯LQ]ŒzÄùØбõÙ›º¦/‹BY×Ü«›ÙÒî\½`¼&&-~ë“1"sæÃî1Üj­&î)›-Óïì‹Gø¿ÌË%¤Á/mÉ%§˜CX„ÿKDÁ2F$. FfùdaÉ|“ÄTT8»¾H»ªÌ 7¯Ó0}õ#í²ÂÇ-B‡î�gÁNuH0ðä¶ã$ !gÓí—mLO…NI8L€Ü¡Ô_}ƒÛ€ý)’ãì•“+fv÷:wõ½±q’,óR:‡²ë¾œ6äRÊA:¥ôO™ät÷§‡C;˶Ž NW{¨b ‹lñ"Kœv/-¼tÖˆk““``bºýãõÔ{£<ÏcÝ2£ŸSAK¬æ“R,Ъ¬ìIeC†ˆÍ7-<ùêÙë-ëG8‰h´ H² ‚›s=ç6Àš”Wš¬ŽŽÍÉùüýU5 ­ <ÉMŸyóî­îÜl»A•›ÝðäÛKG]`o<âŠ÷I62f¬É½¸Ép˜ÍíÙ ¼ÜÝ•}ªQì7 O5|Wƒí¢ôÓß¹ zþú¢ ªEÃæF3º§÷£§1€�¢n÷°™w%ÃÌŸ¹ÐJü�òá¨=Ñ3«AØƈd�©P]d¤iq¼6\ã½HQHÂ++ú¾§¤*žt¬‹üYr§³ÁæL»²míkhe<0µá©öj›æìš9(Œ—¾ÖÑêcHtä‘oS‚*nDñ¾ñp»XÍcäÛ¡EÉÍï}ùÒJ¦I’ Æ 3é}7Ðß8Ôw’{çXfŽ(¡¤¶‡ä¶Èóí&¡s{l<:•^5-±—@HqúTjèðmò nfsR v:²š×Ï«­,©ðà×/M±2¯ÍÎ<j¬N'á(Ó³P3düfØ{¥ººÓ†žEQ[ bˆŽï»M Ž˜c1.Ò(…>ýÈþ›‹hütH˵“zÊxŽ§ )ÑöU õ�’…wÿ¯$¨}Òœ°L,wpbþ\Ï“ºƒÃhtS®DÖ’ìZ\¤­)/'Kž˜ÒªÁþ Ðÿr}…ÕdŽ(»8%zeÁ”ÇAæÔ'QÐR”‚U£1ͪÏlàøªÐKZ¹ž‹öGŠ)cm?¶Dx††™aÔjË6µöuY*/üC‘ÙôHøf¤Iù-ž0‡¦­)Gg»t|›µ0»Çã´¹6«#Œ›4 òÓè!ØûáÿÉz\ç/.[É;×^y,i O¤÷¶ïÓXèÐ’ v¿ëa{0rX…eÆ5Ó½wuW‘K|cbþ³‘Ñá«@v'½á÷D¦#LÕù‹¸2Mmy­Úê±+äâÉ× êfÆ'°–ññßOå}€V!÷ŒŽÂí—çóJÛHJQÎcv Äo`Ì ©÷ÝRd™gú FÇL)ýQo <‡r¸B së•I%B¸´•c’Ô*Žü€fÛš’ü5Ð]Q&ŽÚÌ´ã <±¦©ÉÖöõõp ~Å_# =_2v@£ÓœrM‹C…nÂN&±ïØF7λ¼ÇvÊÒCX­êÉ:ÂSZfAð#[€84ík£îš9ʵŠôré÷§ë9±4;ÀˆQþ¼kQÁ–x䊠‡ª “%ÆqÌI‚²ÂÓÉìÅ}ŒSRšï‘ê´f´kÓ#„“¬p»_¡,ÒÌÉè n¤å�ôh¯;Y gÒ.¢,cךÂçfÉT©£²”ÿ±K ì¥[ïÄÏñß7n°Q ›,@kËŦXû¸Ë—]ôÂÜ¥ýŒOø€¦”µàÑt¶8Žši–)®~”6þXÇ Š …gãÆIW3PÚSô^Fº9Ñ;õV2 kÇ "_º“>Ï3OÚ„Åk„³OÜ0±‹<wÊU„±ù5yæ¹ El¡<uyÍkO¸ÛÌ•eW챑We‘™pÂîöUÉÅVd=sºvÃQLª[½ƒGÂ'È<\HÈZµEOŠÇ¢;1³ «Á™¦U°9´µ¯½®IÛ· Q»;ÏÚÉÓ%JX =±ó•ñ°7¬¸3ý�™ò/µ‡q¿-{b3Âßê'�Qþ8ÚݨÆ%,]�žø[h†%+’b:]i³õÌ™é0gS>±±·®Wz^Yâål9Ba=êµÁŸr|ƒÌ©#eR‚,qù›f—+9+#W0lèŸd´~HÁ8Á¿Ö¾;}´Í›Øz½M:„Δ$.‡àQ^¸¦mÌï?R~Ut*“¥ÏÕXc·óÖ<>(šþ�'3ÍÍÎ;’([´�QtÑíH¬‡NÅÂ×*ÂÅ ž2-¬î÷0¸zä•Z%Ê"Wþæâ@JùV}Q=®ŒC=½©QÏÿ(ã*¼N¢iÐnú’[¯ÿCò¦vEã¤ø7×Þ{ø›_}÷Ëüƺ'[UŒHIA梽qô,#°X=ô™’mDç×´µÓ´Ê|Îk ¬¬Ž^öʧïnF Rþñ[þÀëæÕŷʘK Ѻ֞Õ®+ÚÕªõÓœ†M}ÑCàz¾–‡áÂS-B V‘#ÓªeÓô6±[ò‚yéˆÛ¢“Ü º²µ´ˆÓq´…TN« „¨¬£G[^�ŒýÞÛæz±¯Zri­| ’öæ2šôc½ÝTÍêÌ9¤pRÕkp›ÐÛü *òGÛKcëi3Ê…åTá««HC7Ê~òhHÄ.…±YÛZìK}]¿¸bËÊ#Ç/-ÂÒ”5˜*ñP„G´R5|ë µ°‰Š²ÊáÏyøÉ€TgÔU 5Ýõ5k˜ìò5ü©“…‚Û¦Ðu€áë(Ôc7oOS­;@0g0EC¢£ò½Uù-Š rs8WAöGÅMÖ]¿û²ÈAã�T¡ëX«ÃüÚh/N xɶ<G VO}ì´ÅýT°,À‰òy„cq=°ªÐ-2o>ð#k–ÍÑBP,£õ ¨Ÿh” ÈÉœƒ}öZd£ne&°€z°;*Wõ0ì&CbŸÎuË{tþ‘m£jcIqª§¿¶Qü »4ÍÁô³Dô.rZñ@g áÝKÄ$émãý†_¶ÝË"ü=­ÊfT÷O:KêùÇ,TñŽ±_§bjaÑzNŒën³yc%AûçþƒÌÅ …©Q½ÎxhïÖK¶†”ú€4çéÅ#íŒÔ£òtxÜPÅß=ÿTJtvk/ûÀÓsÃL=4ŽÄ°šÈ¦,xâÁ£¹§n#,z½Ð#ážp”z2 —ú'œu�-@M¿k-)UcÐKÖ=±ÒScõ.駒½I8äþ4´P÷¬ežZqY1ÙÌ”è{z›|ürCfØÁ ‘a¼ÈÿÊÓ%7ìqs¸UAà¢ý#ŸÄaô±k$üŒ§Úä·z½¸„à 1®ÐÊÖijEC“fAuî=k£r¯–ŒHUÛ@)Æ‹Ã +ÉŠ4”{GºývX 't’<ÛSœU"¦tg:f÷.7yè턧Þiá�bÖ°[mÐÂ`ó¿g«»6XlæçT…BÛ_%žA×b¶ÐⶽÀªá÷.Ugé*h˜DN.‚èxô9@u,Eéºßè&_i(W Ê„MÊîÝ“ g?}£ éú±2CÉ‚íH±ÕÇSOϨ~jýÓñÐ [útK‚fá’u>>÷Ø'ôÝžÚé`½›³Ô7hŠ"9—,ô‚\!\çÍcd%eBSiýéõ0踆Øþ%£é‰léb˜Z°á ϦõZ-"´åˆºo´ú³ðZRfßeìîé<'OkE(;«ôk&h’:˜X‰¡ÝjTAØ5^(DKT ·#]ù÷U©Ó9är¨3\'[Ñ;Š¶±?¼A6+¾9Êã+"æ> i¿ËØmØMZÛ¬?‰°Q¸ •2ƌֳ‡ëÑj„ _šd:K�¥¿A3Õh„Ç€À» .F:@fVÐB¢-i9k· ÑÔÓê@舔³[Ë Dçd¾ì=7åo1nIæ[KÂ"¯³BjÐJjOR¦™Ìú;¡©Øïð$÷‹ ÿl.ºÛã;ŠFm'$“§ÀAÎé#‚šŠ2pd¾Å>œšúž(c7 wùÜ>öí%&0Û-[׆ú›/.Æ:jþ;ª›ÍqÖ‹^6ªñ3S˳9ŒkMÞoˆi5½í•„^}¡ÎkÙÎÊij°h#Ueƒ®D¹WéÀ¼B-+š-ú'‰šžNs‰,+šÓ‘ÎùÆx9‹Ac¥¶'Ö…Ÿ<˜ÄÄ•$jt€Ë/EN·ë]ÍÚ]uïw°µ©Ìf'‹½w›©œîô@®xWq완’œS‰]ŸìY6LG—ì-KTÓŒ¦è"‚à ùÔ%ÕKG‡e§Ê©`бí}†Dd•VŒ$BΰüÂ2�'yÇ–yEG—$£¼Ym¢ó+ï$,Åðž"êpöäëéó´³Ò{¯8ÞÇV,02vHû*(6£‡:ßv{¶Œæ4à§AQ…^YH‹¢Kƒ|°ší¥èØL<$ñ›Ò? ¤VQæɆEÐ$ôÎÎM½´7¼Pû¢2Qî«°"%ßíKï—9TQÞ¬øpž^ºÝié}0˜ÂM©>µ—ÛÃë®ð÷·üÜ0ó5ømî(&¾+$§’*€ÇÆæäö{Z¦šÔ‰þIŸdAò5˜u—ˆçÜÀc`ÏòÚJAmù¾|CZ™ *¸z³Šïô ¡˜a‹§ÝÄ<觥dž/àÝhNù¹Õ>N†Ë¼WÚZ¼‘]Ù’²ù–ÎÉOíñ¥lËÍj!¦¸~ÁˆliJ'>ž‰”)%}ãb %˜$ÙÍâ~÷2›1/¢2sƒ³ Š ž5„š6’ZE%™Rˆ™uÓjQÉè+ióz—¯¡,lc?TCfAQ«½AÌz:˜é�|ùwjÛ—µ¡tÁšÝ`]±#+B˜¤ãÕÀPøQâö¬ß�AÛ´wÂS÷„8o%9‹ÌK/`HÓ80K‹vb==´Eȸ9kéó¢uŒOqtº¢ñçÑ3"Dh×ÖZP<ûà´?\Û·`*ýûe´VÆè0ºÆ,(¥r˜[´¡?3Žö•™©Ç®þX®ß¬ð¼1%Ì“wopT ssŒé€´4¿Áç…7¢å6T7 :[òL·ž@6G¦e‚÷(ÏKõÙf¦€Û#84Z)l|ìÉ1Ê`C¼K3ÏÂ$ ôMo¾å”ˤF„qTJÁyÐm…'æÔZ!^ö¦]ì®À1í©"Q:äI\¤öXîè¦ö]äL“èRá®~T¬IôOzÍZÙ~AKo­úJ«NxªòÑáÿE9½yy&+¥QeQ4ŒÐÄ¿x×ã¶b³ ˆ¦âAú§ž¢®Ì+ÏE·Úh¢,íÑ3¶úFÏëÈbÁ½A¤ìé°‰Žj™�†s7ÐGŸ¡sÔƒ´JÙð-š<I=É;4 ʶ÷üuÈl:¬+ŠøvLõèÕfµÒÅþ$É”ɳzóÆá¡¡L«À¡â©˜u´„öÇ«|ù= ç™ðìÝjÓ²xú®]¾×t E<™è^ @«{*šš­§ñÆRï–;¾vW<K E…Úãvs­š®sTø}Goù»»#wõ  °ìahÍžÒþ|Ðï_²8ä¹»²wQ,¯—ž?u©*ÛØ[W¾Í…õÚáÞý·ØI«Jó7Vû$ˆ§ûtè\(�‰Ç/otÕü£s�ØH&QöûÉØÆ\³U\ˆÇ,Q@0èöÚN`íB¹ŠëãœMÐr¶(/9¦Diâ…Làì‡<¨þt¦‡Ô¹^íæ“4c àòÔ”žÆßÒQæwè)O°ò ku fF•8pz­º~oèðϦï˜>ÚÚ†UQ›ï½V1™ù0Šo¡aÄ”B;÷2 “×ÜpÒË<óˆH@Yì)®ï!oN .Òÿ»C?ºóhËÌ2Äý¦÷š4 föÛw º6'þ  ¦™‡³½ÝÏL4£¨Zà"ð´h$Ö'e7Ð ¬Çúòï[.é)} /jàÅ¡òõ¹4ó„ü]‰ËRàìª3¿”Rô;ýÏÛ³½_E¡ÏÓ¦M½/ƒhk›ÈaÆ ¨uš…Üõ6/·%V¿ƒ³ âÓþè]§ý’Âõlµ?ñ²4{“�òtxXªn´Ådá^{wLª†$è)wEÚÀ‡"´Ði¦°6œšˆwyíE˜/õJ(ÿ¨)瞬«}€ %š1#Õ ýÙ)¿ã}Õ$…Xœº’¶gOÂâ4øø«ŸÈ‘Z “ zQ+žÑàk- >R›×5“4—Eî3˜zîŸ.,8¡´)fk$‚Ñî4$é˜ÿKÎ0;¾ÇtüqžVJQóÞØñMÂ’ ôˆ:›Ù:æÅ‚&ŽÃÌ-ÒE…Bk=*ÝÌðÇCc7ÄbX3 ÐÇzšx´öŸ­Ð-èH¼<è`þ()ÁTž³0Ô©jáµß¡Í3m6B­ÊbP‚QkÙ…6m‡¯6®Ð»ë'‘I»UlÏ“ÐA¿~jh½nѱÛ8ÑDnx1\ç ¢SzÞŒœ]ýNYŠÇy”5ÎîÁÒ“곩º¹¸ŽYiîd¹YAK=òV ¨eahU“+$_Yè>ç©YðyHµ¶bÄ*Klu3µ—@çö¤å„2v$}ƒ-!¶5Rˆ7³ÿí¥—(!i(`ªw‰÷«2ßì5Ä …nDc¡³p¶ <™^¼Q¬¡ìš)k—éþ(% ¯`0cÉ&ESO;ŒJ8¤û;–ÕÚp“”r0TdÑtj=ë�]ȳK.¢ôf‹’ðm yù 2´¹J\¿!{Ī¹¤€Û  úúâ9…nÇγ9¸/y{qÏl}án*›­×&Îd(¨ÆÝqõ¡°Ô×]ÔÓÒ÷Ó ™qFi÷ÖÂ#8¯„ϱår¯;îÛ×Çøó¸ôÎ ¶>¼hÏ—ÛÞs$XCpºFÿWwÓ•sOä Mdæ$¦T)¥BWA M}áÞHÑ×›|}lüÀÂNDÞ)”‘}¸çHPø,w¤­9}ôíÓ,½+'—~KOËÚ±—~©§ÇöLš-ÒR(R…nx˜e½¶µÊjÇ”ò*>lÒ„ »æñ`L…¶¢•DÛòØõ?q8ó�ŠÜ"Ÿôs¶Y›ö{ A—‘ÕªÎþÜ#{÷Êoë” '÷$ 扣Շ{‰×šmbþ½\œ»Ö&§žSO[qøô`Ë›nü]ï&«F‹ÿÇË5¹Yà‘ûÓö‡yƒcYéë.‰£¬µ3^Ód98acý|"œx8Dœ#%ßUY8zn§½í+ašMe±y‘?�þ¾ô±¬­e.™Õ‰ч”E—óy*l[íGü˜ì˜,hƒ¨©j�¿fm—ÒÆžå u¦À,eÿk7üZŸÄäçö7žCg/Zªthk¦ylÌ<†¡‚&32h‡Ã¼åî-çÜõ ôu?BßuòƒXÖW?Eÿ•C ñÉ~ìÙ3K½ß0%õhèðæä ÍÑ„N*ÃêÖO™|ã%Õ¦6eu*y‡À<xžgÈ’'WÌ<'§$a¸”`Ÿ(y·k3õÎkÑù�,å@SjF+²÷x¶T,õÆ«j6—a²ÄnÖ‘º8œ2@jÍåŽrXäÍ>R¬Ìí&õ°ŸeeìfêJ]ëI†BGV¡E¢Ú×WÇjæàÃ!RL°þ¿<_(È$29 Ÿ™Ë0­GexvjÇ¡ˆN€^«µã|¦’úx ój£¨S}�Z†ïÕ ÝÜ×ç{@ý‚n·¹ÙL¦r”z·“$RË=ëþw=Í/|V»Ã«QO–Ÿ­Y}¼…¤{ÐU ©œIq¢`T _)×ìq—iÇ™êaÜ*7›¯)mYBǛŋ ¶wëJ×Ù³Éâ|¡ÙÒMÙjª ÛiÞí�"ï”)Kõæ²Ú¿4FMݺ0ëöD7¢ÚØÑbŠªÝÛ±VÓÓ {ñWð—²L¬‘#ºÿAµç÷/†0œh «0 6óxU¡Ä¯¯b—PWê5VÃçX:¥ªÓÐ ¬ø£Ò2.ÒÌݽ¸ VgÊ gª„p´ ¤§ÉùW–cwîä_)©´æ.¾7ˆ"¿iÁ{|ÜRùvüãá÷˜¿…Ô5`ô/Åù6’¹Ý;Zo}§²’žì]âp‡¬ÕSõt¼8õ”ãe¿×~õ‹nêEáP—%¿éš›v÷uÿçb]Ý HÔäúÆçıdSS~Ó)Oq£WÇÀ8d×ÖvMY®?ÈöS'¡ÂæH …¼ª·m4û8@°Öƒ{ÁÒüGö]NŠ13…ã¹¢÷wE† ƒÀ‹‘®û^ö|gSçi‹m•³öx9+]ÍÇVõjWÛn>:4<2yM{Üå¾p÷®iÃÚ)r¢u¨ãH?”Éäß;ïÂ7Š·`›fAf%=À™N¹0ï944£ÝŽÉT”ù'WÎué¹1æ¥NVªÅ~6³)óâÙêp¦ ?Ž9 r«1 c.ÌVÄ&å¿‘sbïç�|ò¶_ŽÙßtÝÊz2ÿì4Ôm‰5F Ý9 åF·§n­XÖè4PÿúÒËüÂ߈÷­7 ÇebZò°I‚¸þr£ÇÐqŒô¤¦F–6ûÝ¥§*îƒ`h«³{ѽ{tÔÙ•vyò+½þ31öXõ ž"Â@ `«�ô˜$qÀ¤Hø vÞJ‘lÄø¿ÉÝO<AðhÑþª[ÏÿíLs03w¶b˦¯™¥Çeà¼ö¼®è„òÕôplpûA úm·7M@(7wë±^ÍÏD�ìüJE…Î-ýL>cvÖ§ÞhxpËÀ KôuÞ⯋ÉçM®ïÕÜÒ¤x?y©.åSÜTÙÏ$>—$Oü¯ŒmÅéñ]Ê€ÜñoO,Å-Nè û;ÒZ1 D CJ…‚ÎÁ¾éçFÿĺ>bMÐúÉé˾);“YƪËaÌ>ÞèÖì&ÆÄu¿„‚Ýý%äƒ"õÃÅóû@ü{Ào ÝÆ¡üg& oÁ£žïÒYîÀþ<Ûæ™gÕè`[œ¹(K¨OólØéAAáÞ±9CdGü†è«}ù­ku¿xnçžÇ/«Ë õåO–Fq—M*ºûz7þ'eÇxiªšÍDÙYçŒré›È²¼ž{&þ”ÜëýÔ¨¸¶®_PX^<TåûiØôÂ(ÖúòÞu™,ÆžØѧ´! ± ÄBÜ÷¥=¬pfN¡”°ïò ü²0ÐؘH Tuäf¿TU<ñõrTÅTSTAþÞ9¾(Ü”ŒŽ-eP“8È\Õ ÖÂj©ßpGСX0Ä9Ý·4HšÉód¦h {�Ö¦þæVYƒ]qȤÏeê´Ñ²0ŒM[67mÙ"gE¦J™°ïHíaµÐ+éС‚¨SJSÁxbÌŠ< ÿn`wÐ<"¾†©C’L˜›â 릦®þ}c§ ÍÏ“OjÎO¢8ò0n}󳯃Ȋ1Ðv)^·jkD%‡c½í ·iß»rã*0m­ ?»ÜQÂQ´*ݱ7PØ5û4ãyÿ—<I}Z†ÎVA¹ÖäVôÚ¡ l'Ì3„vÌhùÍg«;Õ6¥Äp°ç+ ¯>830]À#2b‡Šº…C9pX Ç3ÓOO}¸?µ˜ßÀ&…¿ËÈVä«óž1¦q]wî•Þ5º>‹š© âÏ­[¬-ËÝ4}ùA<­œo€è%t0%c!ð·:L†³*wà»ÛšcX!Ľ´atf+Líëw2λ‡Û3¬v⬚q;LËÁ=�¥…(C³þP&Ô-.�Yt„ÓÐ7° l¨ïp\$Kk{ Ï”Î2DTXö`æ•Ó»ò¯_›^ØÁ ź3†HoÇzÃ8¶ç½žØ'(&H�š„Nšvë©HûÍ¡ý=úxîÒÓ$x§ ŠŸÒ/ Ã(¨‘3ÏtOyhò9o¤æ-:ûEk#|d§(R‡oµ™“ hE™¤åO>˜)5ú(‰Î·'3[ÌR%%ªÂ¸…þ©:´öª"åz ðÆö<ÁØ’.£.Ìw‡a#/E_Û/6•@´|·>½p(¨s« ô™¼DgW¦!fR‰å‘SÊM[ˆSe/K¥Ø55Õók¤Ô†à¯ Ï[Ϊ{ˆ}µfžœ4<m•J›”Yy÷&P‰ö„Í�*â™}~Ô<\H&9ºÀ"bZ;Jqs¥T�¸ébMá[§(rò%iÉ(Nò"ì´ž½Ób:<§Á…€f� á…¾ 0Xú“&ô€VÒíZïmdú^Fƒ_= ~NúM Õ͘OY]ÉÒ]•8ŠæLo9½MŸ'èN»Ò˜Û;ÜÊ$‹3××Ä1|@Ovkž¦Á/z™˜¢²j¼ŸÛßIó“£Åª°´ì>]~¼…‰¢%Y’÷í:«xÁ,Dºœ2™¨v<ª]*“¦®oV\_ßÊ ÜÕzvîž6A:õ®×‰†KëT§®bMÇB¶S€ Ð!ƒ¸v@Š†õŒy(Zûn ÏFŸ§p…Ô)q¿üc¦øŸ¾;®´úÛ  OåB•�}/+vSƒ…G1C+ ý”mÏV=t¤ú+ÆÆåÖ8ötŠEb†[ÅQ“ú¦«W�Œ ¢›³pZmahìž/Pð¢ðpDfl0vKQ®5q´½kª®”²’z­ÆÑÏ9_^QR:˜>›òðsë  Ûúü!{“{|?,Â%*nè"ÐÃß] „¼>b™¼åÏì™c;ïNͬ Ÿ %»]3UúùBÕÕÎ27wñ J«â+éÀ‰*׬i<5:äZ¾Ý"‚Ûí_!Ek5nVzqë5;(¾Î7îyâ6x’N}hK±±š¼f ¢«Ì«oòÈZb,åý{O¯7_ ¢L,iâ©ö ”¶Äú–4YúìM€®f¸çê´b£ ZfS™cŠ`™ÖÜ»ú… ùø«¿ìoA<± %“£hk!³iµ=eênX¬Õ È‹àÐ[Ï«­Q.¥Åu2Ïâ-GçèØCd@; "¬û÷‚v@†&»Ÿªõ³’Ô­yÔu2¯üÁYÄøð"țƾ¬3{è鞟¾ÔÐâŠeþ8=sö˜™‘®Û¤Øj“§b»•jÃhüuûãd,{…¹sõê@øFÖ¡d�HéÏ‹öõaÜÙžø¡·YvÛáf¿IrW OèÔu­'»çÌèý†Ž­ ÝÕª†J2ïiË} ó<7È  wûØAÒŠ%9#« w{i_NGJFø’'wã•ÒE¢Jô 'àp¦2jrHÝwÃpñϯ?Å2ôÉ”sãÓž|¹â äÞ¡i¼Î܈—þRTŽÐj¬g—F5‡3»Ásè[ \R9/&�w_tsÆ-ò ¯e¤™~2®5Þå|åðÖ=%•/@G'ÈqâÎzË€òu§\…ž€ô8­²<Ñq×47ÃAX;ýMÊ&§sBUŸ¯|Öm„bå‰æÉ£µ¦Zã¶Û£‰wÇ!çZ~uƒübq€‹—Gá’÷ÉpîIQªÛñpûÇ$ŒÍ´7Aá dzµQÖºñÊU}±0 ;éòÆ{"Sϵ»¢Ä+Ô ±ø̃èl×SÆùe¿"å̇Í^ðÝÕ“ ÿ3 ‘½mOYY 6êÏîKÜÔõÓs'„ÿÑì{Ù øî?¡ŸùÍ zróË|4}±µ ‡„Ô¡6ÕýŒ!ܯæò‹þ'ÜÛ¥ÔtU²RØ*ñåî/#ø°fvÊÇœÉ ÉYI†÷Çèt1SèﳚèŸ8ÌN¦I°ÛP·NõmG矦š”ºOÔ 2ªÁ"ì¤'a^ž¥ÛÉÂЈà•ò¦÷Ú"¢d¨ ”þâøœ ÿÀsÚ läÇ6G‘ŠL=ÕÌŸk+§FG/-U£?‹n¢vP>È}ÿþ×LD´ø;þ>Âs¦3€Õ ¨ØH¢3E;Î _OTÎ W„ÚvŒ+¢A¬¨Gã; ¢Bº: Fõö5½&&c¸¼<³¬Êt{rµçïÝŠ¢ñ®ö„Íï)Ÿó*mð.,m-Ψĭ-þ‰ô4sZöÒùã(ñudàd>вÊ{ëÊ^z'°¼§±¯*ì‘ÖÙΨñbRµ12I¼†YnþŽ2¦ÿZŽGVœPFíë„:y4h6P*bG<žJèS½PwÆDƧxõ;FÕÜ[¸+ÄZÇÁ›N§ ->ù×ÊY¹ψ ýÈô ;•‡þƒ<íð÷3b?ÊòKó\wþ‚§wGÇ·S3×Ë0É\Èô\þ ?° }è4­§s IšÉ2Ã2¡…šsËÉtìåºq£²ìÝ¥w Ju Ëß9·]ÌŽÆXf‹o Î/‚5<ê‹ÙB¸oK2Ü*” : àã©Œ-úqƒn ÷6?ˆë5÷Ö–º­™ïIU!Hô Äh,‹˜2o’›¨‹Pàå‚û¹Ìˆª,,>—„ÕH9Jûevà–Ž ŽßV5^¦Ç>ôêä³h#ñ É]ÞQ�N<)Z†Z­Ö)åauÆ,²nû‹sì©h˜ÐJµ¢�j®¸{›¾¦Äž4F¤0~RHWË÷‹§5"Ó¡ÑU_—:>3Œ¿SµÎc϶—eð|$Ï=A+&,¾hí¤Ÿ“'À$ž39lú×”oOu@}‘›Ô/¤AvR¼ø) ÆÅçT|þÞo!µ/Ôÿ9rw°°ñì ÎÄ×ÔWá1Iä“—iý{øwi 81rX}š²Ò ý‘óu»‰?·iYR|èk¯ù}è)u^f~Dtè^ÖªýÞMÁKó@ ¨ê4Ã�UÙ,$?lJ÷æpì+kÁ è«Ÿ0á‹|$à÷�Ÿ÷Ç•“ãa˜˜€)7Ëހݫ,óMP´ö´/Š©× 9K¨Š<Š…ö즳ƒ´‚ΗA‡á¬ÿ"ò h HÚB*©ò‹<€yaz! çËê€æª¾‚úu…&MctÄÐ U˜UIN=’=›Í0 DØo„Ùsàš­ çîyæô¶2öéÏ;T!¢¿y’iìë!Ó…ÉgÜÛ'É]FðÐøpþ×ýœÅ>M€vÀ¶-‚lrN×…¬MæEÓÿ-¢Ûnî ’M‰…Ñ<úØt»¦{R¥_Å!Ç ê o”~ÂZêÜ+Ñ/U,ðç³uÚúnäÒéׇ¬¤»=ÒAõii&ð`ªlFnc™ô‹ vå͉E Tć;ëÈùHóÌ+¤¿°Éh)bŽaÛrŒÕ5¼Æ,Û±\þôŒøem"± ΂¾¥ƒg«j1"¡x´ ÿ;öÌgáç‹þ èËÂkâm_1çëš­°[5¢4’»ÚÔ7ÝWÇc¿Å‹ö…âÔ3Öf¥pföôž¨šáõšü秕$3rÜ1+¦ƒz¤j%ÿ£ºYÐÇx‡j‘è划àÕÏx#“øc²…*K‰©œY¹bQ¼âEràcö~ç'’]Þb]=¹6n0 £5*fìñÉä_ž©Jž¡Q.dËWw=ðဦpf£öEãRµOjXE·m=|зrσS’8@ÈyÆœå§íÖ!Ï@Ž¾ ‡˜Ããæ‚¿�""7]lc´ZªŽÓq|†V«~•s-Ö‡’ÁQ|ÜÖ-+·ê¡¹³ÒR º•8И>ádÈõþ r¿Ì×ß«LûÚú»lâ…Ú’Øö lF2Xùo<µ2hzNVÆ*cñ¦ô€C™˜õyÚ ¯ÓãJÏ P¬Cóñ™ð-³Usy âM[?vprš®>±=°¥}B¨°þ•™±°0…õ€DžsÜ@ ÷þÿHáË°°v#Åm¥p¯ƒlC;^¨rñ±Ót¯Ù/•Žõý œÊŒ™ågl8[¢E"ÅØ´kÓPyæ8ú‚©ŒÙ`¨Ùž[@›‰èµÙ®§VZŒæµá kë 2GÞÑtb¢@ßJþD, sF/›Ó@Q?y¬âLz*£D9ÒŒÕãLç CÇYœ&Ì*¥{ ó{KóȆeE7Û8áöƒ‰\)[/Cu•BÞyÛu½gèÊ÷'?¸‘‹_}q¼¨(­ÔWÎÚÛô%`1Íå¹…h>„j:éÁÐä˜Í@+,ÜN» <ëÆ!4]jkÚvý=£PÛ“±�ýÍ©¢±÷Är&@رÛp[”Ûï™2h¯à.9. ¡V²Y —.dµ£L;Ê-uJ„ÕÂÒg|.­žÿÊwè‰L§éx¨ØÎàckGÀàJ>Ö·õïz˜Ý‹[9YúF™Èº¨ ’íÆ“´1uý‹½Í$·X’ˆ"í‰qdFãÖôæ{ÚãÂ,ÿΞy뎅bW3ø×ï­ë^C¢ óQ%™‘M»”ÛöÓÅ¡Œêw©(`ݯ "O<8dÛ0¸àFõÉëJ°Ëd¦µ«7Ñùß;”4RãìÕOqP4Ö\§6À[ÃB`RÌ·êž>¼Í¾¼ ìÁ-ìø0T5úsô;ˆ«@‘ëÐu?c.K1To…±tÑ☠î=úmìN�Ìq ³b¬k¤M6.µ?ïaÞ“ØášM£~³-ŠÓ¡¤[*wéÃA¨<¹’NPµÕG¢«Qä3ö•F›Õ€ubVˆ¥‡2˜1ÓÏ!åqî?rJ–Ä»OËVøoµ¬ˆÒ¨ùç·†} ï>únZÀ»s{qR°ì«SÓ«ÚúÒÉÏ;WâWq§Ð«ªðJ‘g g`YŨ½çP±˜\n!¼Ï ? ®î¼²îpŒì:²§hžlgÏ‹Nøþ`=G,N\½|籫I”&Wt¥–«¹å7&R[£Ò´¥o}wÀÀ{RÚË–òu„Ž+Ѷ(U´jbì§t¸OÅpD¨t¾×}iVèBî`xS$×.Á¯(ŽäA2è)¼:àˆÇþÄBy{1A¨?C§FUätÎr†Ô±ñèEÕã=…=9…á½GÓІ%¥@a 2yolʃڶ›ÄUñðetñ®©…?âfËîq‹”­ýc>qn<» HT=ÊÛ Ð“Ù>œ$ÄWZCp&dÚ‘Æîñ³ß»û\Hño,¾óYN£Ì+ѳºäA9lT­œ=A6rñEÅå-~Dzû:^±”à…A2Ÿ<™S¾ òäàDyf'ózg´b9Fth°Ý^Úè¡¡Vl>\º@Ž,ž*(ðñ^¦Š{,P�=Ò þNcíÍß?è#÷�A­»qÜ-AÁ¸4õ´ë6g.¼5îz½ ÷)áÖÕ¦N_>ìiÜOWzÏá$yêô¹iÄ åäøéI·  »ê;ƒPz\~Ô“qº¹ÉÛmäÅ3æ–þ¹·†ÊÌDåçú”´"Z.7¤òpÜPªYk>ß|j¹OžZœ$&ð$¶¬Ãê BW1Æ[ÞÐåʈ-ö°zLíkÆ$H‡”jð§\54:„@jïŽg’6Côü€AÂ&ækGŒ¬Ðá·|9åsñÛÁl‹îͬÃ÷¸ÄÝéö+ìþ-"ñ¨_²à7§8¨†Écé¢ i9c‡p¢¥-«Ð^9zúø…Mv€>NƒÇË ãKrÒc-)ÊaÃêḦ¿S[¥‰Ã‹3€ðx€ãÄ©ö`(ÍwÝõÃ$*„W¯þBN<¾ ûw^ðAã,úÍÎåœ8‚(wžV®“rÛvÞvŒß¦ý1”>l™œŸ’pJh©:2šëÝÀöàQ–D§°^˜œä:Ý€Ž`$4®È'OùþKŒz2Þ0÷Kèc6­kŽXŠ±Ú\@—[@ãƒ1u¸ÀÖ†Tž€¬ø©Ó¡ˆËŠAK¹3øÇ2v´MQ4iÚ$(·žq ÷ßd¾è²Šp<VãPKqa`ã©mX[•B cmm〕+z¬[¤|P!y@SJ‘ïºÀÊÒC ™ ò…”:LÜA’±BÚ>nqÜ:ñ‡Ï££Ì‰‡ lw÷g÷ÇŸ•6T¹† øÊKõèñB§®ÝpÒ¡ìÄv¦HŠóâØ/VÓçM!ðt®ÄV·7M™Ãom~lK•Wîà?Ïí‘’ÌQ»ÃÓj4®A»k V#Í$:#{–­Ò¡ãÓ¡S”‡Ëáå¡ÙÌP/¡©;°A#oë3:»ƒæå>#)\¨GSM`ÉZ%¹ñ$P¿t#Û˜°ʶŸ@<mÐFiê‚wÆŠ1kÊ9él5ÈŒ-Zfi23yÏú’4iìFPûI ]¯íD‡"�Ö†u�— €a>v=ò-‰™ZJß^<—õ±ª«ž‚þå¥ ¢¯?(¶­·–ç,Äõ‡¼—(,ø‘8£L(qך¨£!lPþâ§\ºZNågÃê¤\ÀÚQšÓ{m=„—')¸=5r¹5¯„‘̵ˆEenš*;¥…šÔ¸ çž{'¾®Ê@µÿ¢¡”ÃPÉÚjÉ îRWéX§\O×ç?Þéa¹S§26Û/º_½n¹‘.‰×Åj¸AWl·®¿žº/-$&¸ÝCéBäÖ÷>Ææ0ÍÏâ¯E§‘¦›ÄCTsTÿ´—-±)BŠ´ðà³¥þíŲøÓES0!Œ¨­=Ñíó¥oµ%ø»ôÖrÆc`âaõñžtt|ÈJY×`]Êþ†ßä W-.@îÅ®÷FÀ’îT÷úºÔcVpÏœ’Ñ<k®\‰Q¯8ÿ<ÂHš×Ú‘Š+ÄŪ¦”¦ï\q0#:®R…ŠaÅÙ¦Pøïì[æ $g ×\(¢î)¥9ZJk´.Vä(°Ï›‡¹IÄÜf¥Ô¾ƒxv=â<—*yå4–EÃÚ2ˇØþ­ž1–¯mç€nÄ í ·v·=ÏkÛžwÀüÉ¿÷g„!%ä¦vbÍn€jüÉS&Ñ­aó»ëqÏã±.6+ß:¡6ifçŽ /•Ñºìv|¾ó]¶w‘ãù,­Bgq \È-¥©i{r&:öGÈ’ó">Dz"é §AÍ•Ñé´æ<!mί)´.Ûå´wÌÑßµí\& ‚IÈ(×bÁ»«×:3I€º“ªîïΕÅñç(Êçc&¡ó_øÎR&wFŽ[?Ÿ)«ˆÞ•±A‡¥ bÔ*èÄAÌ¡"ùŸÎB_"¿²WE†Eñ”–ÇÚ° "1X™bÄE8L¬Ò†pú¹gw­%Aåö’Ó07åë%%yèCþLƒDœ[Ï×ó74K†Zfvgž¹ýšN´oík‹<³¨ï«qÖÄ®_Ã-á¾£íYúE¬õ³Iö'AûÙâáÅüx‹EÈÕiNRÄ<hŠ‚*R•¿3Ö=Þ{áÊ^Z!b… ÿÅ]\ƒç­¤jÍŸ±ç‚°¢ˆ-ztF·ô~%HF*Ù¨Êfê]ã^°qrwB°ì ºjùiuÈ„qÎ5ª`_¶"¥‰0öòM\è$xœå8\4)›:—AÑ~ÙñÜ€=âëf§¼¶Õès%v%õÒ-KýY&=j¸Á$V†7‘%EéS-8ö{ìÇ<H'á“몉«ô¨DýÔB¡ÚîÈxÚEôè…eù]“+ËýÊ’â ‹íT§Î‰í€Fæ‹_X¥kåÆÚ™¶¨ë]ÅÇ»Dq:ªÀoŒ\z7]ÞX™Å\¯ÅÌ‘Þ¦Ñ�@àÓ÷ ¶ÀhkùÜ ønO;Ê4î)~£�iSȨ4\›Ë!ÂBS²MÄ4@°Dª¸ �=6Áxé8y¾ŽL=ÝŒ½±;ZÁ••/„6¯TRaN§Cý!B9ÓWå x‚›$/º­#ÃWµ£`£ZŒTËð‘}z°óÝfœú¬cBInÑ÷–&Ç™že•ëSoêÏÿL­É-QEû§0s ßÿx-Ã}aåò—ÈúyµpäŽèùa²?Øj)fÚH‘9kìÕÂs1Î|Ö{‘)÷ pç7¸©t‹é|5Y&šë5U ãôæÔ‰$uÅq×ñ ë_<C›Æá•Í)<8³ܤFoÒ€rÄÌDªoÏÓŒ,=NïRç6UênKií6–ô2Fî7vÚyæžÀÿ8}èx+Šª»3Ìb›Ðá›Ô©¼><ìÿwÚ7 h£n…FÐ[íÀ'Òç<WUjµ1BéÎÆrŒõx„�Ë<´uû½?e®�ÅãüÞÉÆ}©Ú¶ ¬2¤þ ÓϪSývŦT©x›”¯L'ãŒh®y@ù«ï~1;àTΪÇFª0ÑI„km ¢íÈ:"Ækù¦ŽNÚwÉGiÖÓ¹¦üwœ]ó§´äÕæál¢™´`Í=® ,]¦Dt,óܵz·fé-[×uÖnÃrgß a½Ù†ˆÇätu¾ÃätYÕ¬€ð3|AáÚ]F;t¦›“\:¯sc¨ðºkÒº'·7=6ôŒydw‚£í}£­05.±”ŽÝïݼ¥Óͺ$ïå9ÜóŒc³øãÀ㤓#óì3w¿ Vÿ¡ß]3¾Èw9ƒ¦Âû»¹Ô¨ö]­wHu o/n*¾h±,ñéÁ¹)úNuVBu=\Ž^å½g»B5ÒPžï5¹ùþo=ìЀüSgÆya0 *V3ÒàÅ ¹ð%R˜ÛcJ «6i9Í»½M€ ï3µ—ë¶="õ Ïº¼nkzð§ý-½>}V*]vÇ<¨¶£¯æÿbþN™å¼›¡²|o©z¯¡ý枢ý\yŠô×ô—D§²"ô!¦3èCÛî&âÃ… ÖM Á{âð›Ä¼cùº Qb<¦Å}áœÖ/¤ÒÍêb€ÓzÄT|²ƒ‘;Ú‚OTc‹{b^<íýØ6Š! *_$-Hÿ›ÊE«7—d´b 1.å_Æ¥öûÌ!Êj1I*‚ãH{#ž­; c-ôò"¤óúXÂ%-|æ ŸyôºÚ³hÐ…±hHLò¸â±!üY0w´I–µ ¡/ xÛÆ*&ƒu™Þ.˜ˆì6Ì‹zCq%ì×à«ÉÛy— PAÍ]l¢ p‰‡Ñ'â®.r£w 9íR2 ¼úÑf”™¯YKOäe•Õ’Ðì†0ŸÓ~¤u••¥UéıS!§$%•qš•­¨v²¡h¬›f7›&=€èHXeÀÏÃ]Týe̦ÍskþášbzÓžÒ™ÏÁ¦dCÿû«Ërð×ͯáS³¢ð %©P9¡î 7>p¯íšÞ5N_ÝòÜu:v*fœ €FõByuŠs5ðivîüwÜظð É Î ÐÌîþ¨íO± @*ÔîŠêíÁÌw„¹wý³ʸ֤?ÃÛ%ºœ¼:Ú WÞßrœ/«-n†1ª[mt(w©©ÎͬÏ1ò$¿ÏCÅÖê²îÀ£ûµ]¶ó/ÍÄÕÏÔV Ÿ$hµn7–2lDOyˆâµÝô�©ê½ñU.‹Jc£}øK¥"3PBKóÀ¦ÒÜâiw-P»s›Š± 8k®!]ešÙž$& …—AÚ«4"ÍêеÎ#"¨læy¤ÿv·»3úSóö2¾Í*Eûo~p03û»2S=ØvW|€FRF0Qü4¢É‹p<1Cü?{u;O¥Ì4¼·§"H:‹mOÿ²#,Á©Nzÿñø«\›½dÉpZya7ÙéçSƒ‚~»,¢Øñ™E½ ¹M4)¾³�Mq:Ž ,[O`sE™y˜!ÐgJþ7V²Æ¿�BÚ嘙ȪóÌ®o}…Ó@'GGUdÛyB2Ò¶ñÈÌê³Fÿ[îdš?‘LŒZ Ã$¶Öº^HŸâѨ÷ß‚"Š8ô £t:3O¡/Žåïµf·Ýuž{à}–äfWˆ3/&>­Mch}‰Œ9#9¤†§2ƒ  :‘åßü‡ŠîWœ£ XÛ>`®wK´ ÿ†B’;(—0›‡ t ÖŽeduWôáþÛªÒ¹aÌѸ֫ոA;óí÷‰3eFNhŽÀÛ¢«~óõê=À±·`Ò«åY%ðc.ƒhl|ÖE,‡¢“¢ñ@)œ-ú}s¥ãš¼…gnèMâÙÇ’¨ïè/¯²T<—´H¬²³ ljÏ J}’¬JÓáÌ|iF”>!È<Ækvʃ­`5ÃEêö"º'*Yýw¨#ÅÛt@8£Õúcü@ oÎ éEŠƒÍ5Œè ¥zºM¥å²£1C‹‡R¥“mdw¶iä]ú]>jD¬À ï;Ê2˃ÉyŒ}±n}fbõZà`Œ±‡Ûm(j†Mï1½-é#Ž¬|}õÊ÷º¥}¸/Ÿk¦Zšã™1 ­µD€Kb7\ìÒü¨°p²ECN@kÝÇ­‹ßFéò|¡m°šs?ñ/=é3¦€ Ç8gX¼”Å6U} ÐØ‘*Ù‹ýaà\Wnüò'£§îà7à3ÿ†Q³õÔÆnÉ”}FöìÑ«ÍÅ<ÿ<>SxQG=U˜ëÉ0?G0y3¢¦ß/Î$õÔÙÓm@}œ[Rîý³µÚÉIöˆ‘âÇĈ5 m™–°•áÓc=®=8Î牎³è÷9=ÅòIæ ²b{¢›]Z0'ípR…Ú«ÆõKì(½ö7œ“†y»B[AÙL°¸\õ.Eg¾ÓÏõ£¯ïÉ°`Š 3í¥©ayÏx ñØ8Õ-fä¾ËÈ+Ö#Ñ?Y^(ŠNäi¦8Yÿnú¡€MÕ_³Sîó‰í¯\‡N9@Єи>$AnÀ‘ÜÑ©;óGÓ³LƒÉ”¢w/ým—™½±;&0â:úðøÕx™Ž:@“ÿ{ëÚ=læoAÏÉ\ÁÛ8¬2Ñ”í„ç×æt &)VV—5*1 c¿µ'‹;)¨�zPȬ)QYú‚¸fÓX<黾Þ3ëó(\ˆD"½PŒ?}`5 ÿê;3Ì{,½Px[Î�Žèâeãèá‘°jÛ–¨ ¿y„Ì`úè6,+úÌt¦ˆ—&uɳaþ@^&rjÓ[ÍݼüÐïœn´âJDÄ$çc®X–ÄSÐë=3/< UÝõ¯_4ý)ŒÏ[5ÑcGѬëL©ËÂ9'ÊÒå²DTÕ#Ë'±¥ Î…lWæÛ_.cOÄr„mMYëgíægT{)fÇ>:M÷Õßs`‰Ê0ô˜E”¡vèEDïGóüÅÛ×`Å ÆÞkÞw:æ=`4"»2%ÆÒ€…—¬,w.\•)PB®6ÿ¸†.[ž-^ªÅãQEcí¥œ]n¿˜Ì«µ›aQ�”Eµ³,#g› ËÑÖNjÝJÄ<¿bù†…”Àª}Eeî£ìl¹ ¦3ÍÌÅ/t ~¸@ ŒL‰;€‡ì z\E\T¹sú*iG¤`WzÀHx¶Á²Ø)EEïCÛŽÝ—½‡§}#® ×?B4&v]•”ìz¡ÃÙ©ý/ÓºôñãdæáœKQAŠ¾­½<ß¿^muòà ašà\fÊ`´dªæhŠG4cúݪöÏdúcgµ—¿oÒ8áYäš g1ªžE.`å#|K\² àFwu=7Ë2_˜ªÔPðOë?Ž„6_9I§C &à7ÆÝÞí~³ØƒÛÇ'N6OÁ,¨ê£ç¡7€¶ô·E zIX´—,Hæ/wÙ MàS Ä(UEevñÓbu^ú¾ÔìÖŒÿÚC)Рνä¿HÀ¥oy@iü΃¼©]VÉ›]|&ÐyîÆfâ³9Áyìhë Ú5Kæ ªnJ­â㻧”×}yt‚oYÛq¨ ©Ð„¥aȃ‚¡@‘EÓwb`‚RM»Ù+jÑÜkk#!|¯ËWi1–,qÔ>Þãí@"³Ðµ“¬*Œ¡HG›êd Ü¡ äœ»£iåîQVbÀ!núãUXóX,F ´¤½žÕ¤3¡„%Ó{ ]ßg<ADïødbý“žýkº45„´ß ? ˜“¾n=%½ÿÞù.B§üÃ}ÝqK÷?í´ªB2âiŠ´B†ÅÏO½u¼?²Î= … “5¸IØT–Þ* 'Ñ£1Çi.3ÿ<  w®éD½g3^ZWVPØCŠOê]>( _€åþË ; 3wÚ»'Ú”!gË[7´þåcâf”8~&E„ñã þüã X̬踛gWu«ëUaüÈ­yPËó¯¤ ¢Ù'–óÏù“Ýã sÛ å(¹7~)qìéÒ‰ã¿yW–(Š¾?éÁÌëqìŽÇ ÐpZú ¾Õ¤‚'Á}ã?fYB¡âšéÉ]ÛoüK—rõÅŸå–éÇ %ˆÙióÊBÔ/ÄðxƒùªheÕ[¤7N†nÛp1I™Ñ|®ñ\¶ ΓÔyì[ì_ÓEÚœf¡¬ ¦þL!+Û žÑÑ$oÄ­ùBõñÈAøÒüBtÞIt mu“öìõ‘´-ï]ÏF¯ÔtÜÜLûÌa×Ö~Æ£nÊ[ûÖãÐQ¡²ÚrÌìøk $Q6hÌ{t/{„!ÈD;¼³ä´\9zxÐNì‚}ýz K½ÑÒ¡‰’tko}¤¼nvDÝ4*aUc<AMú¢&­~:vœyÀUÔ•ˆ‘%åÜj^ 0¥öÝØZU­4”ØRºZÌ&žÿ÷ªd’5š–¤–ØæD¨<nT ½xêÇ‹i“‰ãµcä±€ß&”/X«H*L÷5žƒ;ŒjC;Ö!<`g©ëð³C<¯!C"¤ò‚aµâÓÐ¥;P°5{nÚ‹èŸT¥ó žY¦Áþ£¢…okEn¨Ÿàa¶‚gnÌÏš£¤X8d¬³ÏÙd ¸7ÛÓ—UºýÙˆ3Û4Ô«©¤XkGÒè‚Œlm/Åu=ü¦?D¹ ;*_ýÄyÔñ°hÛηÄežöÀjM·Üþñ ˆz\ÞÖ#3-†ËØ­kz›^^ÈÊ…:%£Ÿá>jÇÌ'Á½ÞÖ=»Ëû±úPî•íÜæ긔�Ÿ;J)¸ÙhNÏ;‘2vÔÂ!‚ÐÖÎI–Y¢‚dñ¼ç>º‰Gß ºŠƒ$2£uã ³ì ŒïT^ÂFв8D”I0A›F2rÒ3…·7,y¹ Ÿ`ï?Ó‹Ë ß²]‘3T-ßß=3‚V'º·®÷BúºƒˆHü§GÂ"µÌhú{\²oœ]“þô*D¶*Ä—>øE#î|hêÍÁŒÏ3ù¿§j¯†PZÓ}!Üjl׫ÈZ„‹$7bÛáx­¦ ¹,8Ú›³V˜(Óß”ª®E¬ÀF*-CJÚuÈŠLÎôeõ”=võªÛâÿ’Õv¯¾Œ­Î"£¾´Ú¦Tã8¦6Š?pÜóhèÎ?,ïòžœdTz&Ó¬ls9$ôîMo²(±RŸ&¯³…x<ð™}£1PFW"]«Ó‘aãð9Š ±6fë#síL7kiÛYÉ8ð—Ø΂r¬_O-ºîC™ú#k"â_ŠS&´à€^ç¾[! À/¥£Ö¼ÐŒÁ gö@9ìsþ‚ia0ˆˆ4y”5C£0)ÂèTw';H¿3ܨGÞY¸·&Û³ú¦e äßn¨ÿꤓŒÛJWe¢y{ªMJ\ª†7Ѷlvl=´ß+Þ `Ôú‘C¶þÊñ™‘WÖ(ÁfßäÖ‹4;ñ CÀ¿º4¨,“ 2)Ó½6§þî^EaÅ:–ºR6Ý2yoÈð¢Áé´?™fó¹nv‘ýYcݺ2‡†¸~<@u©³6H =¶õà@Ó»™3ßu=2›[_ÅbB°cM;ê]=°hÿh³ÂævùäO”vìÈ/±J;9å*: ¦{²²b¾†¢‡&w=ÃqˆÊ'ºS+é¹ mž #ì.ÊV&‰P³‡&mQ±5¬8 |Á¤ô¿³œŒTëÛM¸Éàwv/—Çïoúšý±u°qõ³%¢§6óMé¼uvt\ŒVðy‚ ™lëâþ¥ã¹» C†Ó}†nP9ž¼f‹ÌË¥Æ|w Wx}E¿PÝ«x\©Ÿ†‚Üážô#\_æh‘¸«œ¨Ì±þKЈ JЋÿò€#ZW¹]ÍÜXÕ ~!8Og¯NhåöÂJ¯Dž¦(‚íS(©}™r$ÎÜ5·yC[0Ö 2¿e¸ ëÀ7Œ6xfÓ¨dV{ƒ©P¬‚LÓÿ±tel»a¡YœMAøS{èYî£ëhþ×ص…‡Æ—¹sFÙªò °£páF­gög|,¥b㥠éàÚ_m»eš¯¶jÐæ[ëiöHŒõí·¶Ä_ˆp|Ñí΃üköÜ9(çÚPúÐÖãFc€^<0k[ÂPîd :OˆÛšYÝ’—墼ô[,t ·C’i»qê°"ƒõQ•üB_ß°[þÖCÊ5+*#øÆŽ)§ÆŠ¥8�žé¸ÐA'™cåR9™ìžíì\2ó’]f± 7¼¢Ô˺/¤ÊGwý™˜àvÑÛ¶h•¹‹’D”æWØ&§ˆg“œªLg á µÐH.zœçy^­†#Áªï¾}¨ á¶Õú?s²r:ÒkŠÙw hµÚkÍÑSªÇÍÉ‘¹$¡ú/«&  UˆkŸn6În>ÑÝí¡™Ú¹oå!’pa A÷p™·[Ÿ‘†u�Ò’“ÿ~¨þeq ¢ž‡†G„Uq®Þ~½ɇz™ÒŒûv£Z Õù˜æ$È­ühÂêÙs¯¸™RÿàG–sÓ¯¢“Ùº6}¦èI=({Si\©u*7Ý‘A“Ñ‘2;VÜš¹Õ¡7-«®dïç -ÆÁ"MS¦4Ri,·ë/r‘gèý(1UÇ„gØgÎv(›w«ÃbH„£á‡¶^6ò¬<˨Ÿk*klC…êm «›­æz¥®±Á›ëlÂþ1#+¶ Uoc½ë§gÖB´ Um€6³ÅF #�}ºO|€ ¯±à |“'kV ° ûzRíÈÓ ‡Ê ´áX ,müÙœRŠ?í¹vý~ 7ÉÓY;÷6Xé±QmÑ9Š¦Ü»ù…A‹8ÅʘX°»ñɪ?4eÆ“RVfe£2‰ÇŠÝµNÖJ|UúžeuÑÔJÂÆÛåí šm` 3¯ü1“È@$ô3•¢éûä'#õî¾YÏ o/îà!“0ÏK…ƒonýY±PlP3Ò 2+Uõ„¯YŸßØ°~  —õÕ# Gÿ”±?‰X£„îÀ§–"†åô´3çÎ IpBòÆf-õnpìXŒ Fì=¶Xªû—†~QPƪÆ05òvæ3ðy\ºHÍņ*¬²Q¿Š*…FáBEž.E0ì5VJZ:gN›>£¼¸Õ}™][ªÿ…|æA} ælGôL4OBÇÑêÒi1Ý2ç¾¹7]þä‹àWfØpÄP¦ê¬3vÂ4ÜG0�³8Ñ5ì¸yºLâ*\4~â`–Ù•~ t éˆ:·\œ0/S-‹(©nN°P¹ VÅ ÛÀý Vš41€·þXRÅ©{ÀËD•Ì¯Ó©Ð†$ÈjOËqOë c……þˆ8˜8/yÄ«šbNn ¬bóv“Q#oãwsùµ~qš.· ÃäÞÕ¸‰VE‘Èé%âÕ–µ'ë#‚q±zˆ‰ê!êíÁ¶»õº{ɳÍ*„F Õ^—Pœ²•/ˆúÝâ¦.Û 3¥$—¡¦wÚvÃæСYLYrÉ‹©“b>|È‚hÛz=ÛSkw?U+RŒ‹GÀ|+€Íxpz}—™ýÜEx„çŸãg‹kolj÷Z?{š;=¨•D{W¯Ïþoîqç³Ô“‹“¾Rl4i„ ë\£שÀa.öÀ�)>ÿU~Ò5[É×L°Ú(ŽA¹i͘æv»ž"ãùð‘ÅQ :É îÔCµÏ¯«ßÝ=¸£e"É^kCGuC8ÏÊÁª�ÃN@9·‡þ"•›_Øæú94سÌ™êKYùÇŒ¢¹_{@$–ʶÚ ¢ûÆd–;è ›˜÷' ñ”0™ó2Ö2¿ûΛ2+<Ë Q>¤!IgO’Ý©á4« Édf›ß›>:è/Ó¨ADƒ2ïI‡ßUbze§h?õóO•Eä'Ñôîó'Óÿx¿ÿ¦ã‰êNàákkW³üi¦M¥ãð÷¶7‚ùpÆœB©É¯Cf`Ö'°^Œ„åKòzQ™8Õv:0v¬>í\ FjN×K–RSÄj®°onɽ{”U•·³¹«QPÙm­Gá²aX€ {ûŽýt?ü«GÍŒ4Ì<T1­á¾£ S5àÝšç*£jÛÑòèÐðè¹27À1ã!ôMG=.P"Ú¢uO÷þ8{¢ö¨z"p:òú¦&ïê;©E gÛ¼ú7xºÚBÈÖnûÝ1Sšùý‘.'ìò-oÀ¹±Ë(Y†‰ì©_bc5œ€žÀ§c²ÿÔž™Ii9]ͪ¹³vH´’X=˜Qñ†áˆ!A‚3ó¸30^_´@’=¬½Üæáð$0�AB‰UFµÅ§R|˜-ÖôN}e:Ž‡¹¹z{–Xqâi$à—^c˜Ü=¦åþ‚ĪæÏy'ÊÛß4ìWèÿÆÓZ_ Ã“”Ñ¢ûtÊxçî2xf&b9ðŒ4ª‡ž¼-6W[Zmå`†Scî-¥Ì´ ‘Ö~ï1G†M`PÕpP g‘ÛÌ™6ŒìE4ѤbvãKų®�¬”ñ_gOƒŸŽÜ•¿´u*>CÅäg<�·ÃÉ `û•)»Efš3í(ag¦3,éÛœÙÓVÐåÏ´$ãÈëÏp_e²">jd(UÍœ¥a§s= ~]œ‰8ÈVU’k`ý>i oÕä‚]¦tŠŠ².ÖãŽ)I×bÒIäÓÅàó³…À{«û£ª˜Óß+Ï�Ó ŽìÅ=ÓÒÊ#­s~»…,ÓJÍq{è†Ý×…‘/í;ù@z GÒwy…hî$År%4ô¿ag&ß3?=àQ>l2ƲQæŽ^µêLùÖ &5+í×m/ïÃ¥ še{•¦[°m±B¬à/«ÃY* eú"Î* =± îÕp3¥”M@?¨^gÄ@Ïò©ñ@] Ë:v¢–w8 0!mQòqÔj2 ×NÝ€üúºz'TË‚}Lµú¥ˆTèòö Ö„zQì=Ü tªû'n…¡o¾rBI‹ú8yMÑyR84ÝhÃq_y²� D_Ÿo1`k–:”˜…â6”ÒTŸ“©Câ¥JVמ1墠âëltè"s¿”INinÿ”ƒGKû7Ë•æË…èµ0D.uÿÛ‹«7^Ù%KÅÆ_J³Esƒ÷Ê^fnçë&õc트ZæJ”ìÕðÕq£éò«-Ü*�ãF„0zÖì:lÄ,d¿b!ø.7^·\8–ŒRJa2<âιµ "n±ç¥yŽ�ÙìLõÎШÈüá"ÎG„-¥\¦’%=F.÷¬f˜°vø »úcéÛaçy‘QNޞʠª'ãcg.ÿÔJœV.Äóc ã=r+zk"<ÚW'ŠÆ´>ÍbqW¯ŸòE¹pINÙÕ8ÜŽÞˆmîÎÆkYê߇¥.²Íýä+Æ�|À14Ïe3<M-áz7SÊHz‡ZfÏ5¦ü KÓ1Ø™‡Â;üêÝÂœŽœGªÖØâ;N+‡‰ä 9MIP™· ª›è\uÙ~Â}äõ;+­{ÖZ.=çÜùÐWAa‹e°¼¹ìÕ…¿4˜{æ3çääØã¸Ú¹éÑ 1ss¢í³Û åÏÌ墪<óÀ6t¢~ÌtfVò"ŽÄŸ÷Ø+Cu·ú6¢0·X]÷¤*=Ée©øÎyõ~`¸÷´9~È£²{¦4xqáœYÐÜÙnÊæ¦l‹ôñ ßìJ’h |Ùxþfú½tA팧¶¹Ð,ŧŠé=§…,Z¨À@ƒ8®‚ÔatC~sg£nà º,?I²t¾`øi}òøë=Äâ»Ýô|Ë—‘_cCh¦³ÔfI<(`ñ…@:Ò)GýKl¶¨�[ÕrÝ”ú74º¿Þ=fjûÉ’!ÇÓ¦¹,þ½J’lf‹qhœ×UÕ*2 þ) ΢% Xïæ?Óïhá½fž˜ž¹$cÄÏ´mÞUçn3&º!êŽÝ7íâȉº£k7ôá»{€ã—4ðÊÂÉi'Lê¨xõ¼­ !@iìÀ—œÇÝÁ²&Uíð¡êaºT€d-*Š¥µ¶õ19F™`“ãIMÑNMcRŸ¾«÷ðKqüш0‹Â+9í™›mèÄ:jÄÖ±£ô‡-$ŠTæÏ=4‚öZ¦Àoä!©Îýš=Ù'N  ªÓ|NXPˆ­U;™{zŸEî,‡‰‘yªOΆ®9õG•þ;§8\z×fœ|¦ƒFÀ !ºܚթ§`O•Å ˜ kŠL+=é3ì±ÕX±œJg-˜ÌD ôzÖËZ¬Â4u{R‘ÕúÜ­•Ãh÷;(š¹WR¾ýzK!l‹¹ÁÙ‘º­kîõ+Ú™‰[@LgÛèŸnf­êr>*;m¯ Ôìð%]Í'ø¥<sz k÷(_NúŒÁ <g;ÓÜý¾Ø C*öà©Bß‘ÂÇj XÜÉï`2*̆¿é„y•ë̼PùÝM‡T*é¯?‡"`A ÁO¼UØyT@¡…‹äIJêÜÏ­’Ü¥¬�þÒÄžŠ3ÑW![¨ Õ2¦b¢ÀØœþüA[¬¾ô&±å&ÏûaKÏŒ¡èìY{`4ñ¶Ý¡›vãöp¾/KìÅéb+å‚È·k[V°üF붅ñ2B ÷@[¢Ã»"MÁ*ðm 55Z‹ûZ ›®å6ç­´dv{…Ç[Õ[&"-™÷•Í]Âú}Å* c2ß) G1†1ÉE�±ßÀvÍÙ”PèÝ-Q™ fÅTQl$ò±Å¹K$XHuÜãíÅ“@¨FŒ€d4+Çb2³lÿ’‡–÷0ðQÛþ,úFm5úèë?Þ˜›÷½ÖŸ¯èþZÂHÍb`?kÕ Z9ÃqyÍÿû†dŸˆÍõO:ÅÃ�땆¡x›ÉK+\i$ö1y›KÊeÃ¥š‡º®žÉ„ÏfïIÿ7ӇܫÎ"¾«5í’yãL¢ÍXÔt¶jéEÞ¹ÐÄÏ¢ÙK3úëOyµƒWûâ�ñ*†Áqé®$Ú=ƒ1ÙêÉèÉÁÇ.’îݤÔí¡_ßë?¶°+Ãø*µS°‰SfRJ3(7Â0Gè÷á”Y<ÿ—A™¯†-„˜âºqÉìidÿ.@ë‘ý&Ë‘þÓiT¤8ý5WœPˆÃ†T ÅQ´æƒŸÔŸsD­;ŠXAµ­ùœhfþ)Ä~ÉTydûZ†™çáEÕ>ÖSfµ¹‘æÕ�×ëÛ>YH¹sy50ïâZ[¢‘ø^¡%JqE‡H¼ÔØd5§ïXxYšù$VHÁÁ´´´lx;Ç Ã5}ÐbÙnå¸SgŠ#5PSúíä1ü‹‘:ª~›÷+í ŽÀŒ÷ƒ"ƒT®îŽ‹d5q²@ÂÉïkàðü‰.9¿@(ç¹Àãžb©Ç]f\W`‚”¼kã²�þz×brì¹£ÿÄ©Èæify!—ˆVÖøá(*)è1°Ädz!^Z9$(ÃßšID̈Þn¢¦NC¦já&«B–”™§¤‡ÜH†ûÚ5¥'!E²ÁœYö»ýÞ¦?å¤Qa}ÔÐ*IaÍB_°ÓB¸¥u ¨¨jþòrš©.~£„éc¢HºZ¡?`šWCÖ4ñõ˜âRbÐåÚOÏøOÓàÛ­¿Ã\ÿÞñ ö®ø©_©3Zö i¹›ÕºqܽkÏ‘g%5pWw:¯Ù²SMoÝÑ­)¶£ym íc Øúåm…õÌ»`<öoí1Œc7w4ØÁDnèlT:ÐNÄ¢[â´#GØ`U1ïâ­F”„dN@ 3GÓxÐÞ»º-Ù½ýÍyV÷U•MmY"Ü›³ÐW=÷tÄÝè(‚CªB@P F`ù±´:³vÌ#8Œû s7y¦ÞPoe®V¡ðS :¤ìGéÆ3èëê½à#\zÍ{n”6hÞ§N”‡5û,š^÷æ€åñÖ\Øbñ;E;'¬J)sQ­ÁZÖý}ÔNäb5)KPÃfªˆ³œ3Ÿ)„‰9Ýüâ@­,RËÓŠÙ–÷Háö¬®p`çI€*ª]ÃXÒ§ý¨o˜&ÕÅ4Ñ· ?5á8cÚäÊ»xÖWÒÌЋÝ“¨*\³„.X•œ‘³:1=5Íó‘€7¨ÀG; †ž™'t³YÅøÚŒ¨S@èË È2wGimiåò¨Å{]̧­øYŽÉåÀâž½‡g§ª´Ó"«à½He>¶åUÉ7ÊŒLØô˜®Ø7Å8ìÆšž›%J.€æˆwuŽ`¡ë’±VƪÓÁHQ™,ÆóÒ²æP¯¹Dùe ÊStÂè­#5€˜ôxzÑH´@”{WOÐ*•bp £?ÖÃ÷Úém¢±ã=íÛ^z¶Ì£`%÷zñƒ?e Í›N”’:vHšß È MáyÐÕ«rÉÕô>Áá˜Åtq€óÇ®«§¬;Í¢Ô“«Ž8~† O¸ÙzÒØõYÀÉöÊú¡ëzW7<Ý4[l„šQuéy˜Øió¯¨Ñ?q¸°®*0_‰ƒ¤Öu‘fWY‡¯qD©à_Í…‚b'º6]K'2ïu ¼ÿË蟤òmCŠ_ë"Ȭº¸ÄpHQDÛºã§,Ϳצ�Î(IDHcél:Ç'ÜÀ#­ûÉÍÿõ0]/³\@R$èû ª²‹ŒíZwoûÓÈPü¡¦Älð/7gŠ‰mk_}[’ÐÐ�æOžo_Üœµéêak™viÚ,Ý-¹ûÉB\ø˜5º é<“[³n Ÿ®NôW 0Þm)˜¹¦{Ñ«ámÆæZ‡Ãحؓ>¾u´ÙP§ã]ÆNÞ´Ÿ<m~Ç&ˆ ŒÝ3‹ƒ=ÐÑiË0v@8ÈíÔaVÝÇKÓüÄ•ˆ]™¶ªHñ?»yºee›JïG ¹Bß™ëÓ€qónÁÞ ¯gÍT3„Afu÷À`ÛQá··ª;n0ŸêW]ÓØgí¹>&A2Ûb(,囬®K:2êáΫb> ߉Xì V¬veP9ĘIéÿ gKë Úä3ÝüøýSÙZÚjŽŒå 7¹Kñ ‚z¶íaD¹Ë%ü êr¶€ˆúúb(”ßJË9”FnôÛž>¢å¨üµ‡¿ê¾…‡ ƒî_&ÎÂ}hÜ"ŠŸfÃoLÑJ£Kekq‹Mñ'âçž´EåX¬æu« øl¬”äˆZ«ï´ãa'P˜g˜-m2CËâü; ²yín†/©`¹Œ‡ž6ª›.ºö¬Š=®|Ê÷e“ÒzèuÓÄ•rˆ\buÞ ˜¸lZ%ß;W`5.Þq8iÏ£rhXè(!ÏNâgÂ"ùBõ£D1ˆ{+«ž®„l›ö0Z3 ®Ü¯ZŠYåH3º~»–j.´I�"D¼rz²ª“Ð1Ø ò:†žµ•†þÒÿvrO/8FYæ±ÖÐ[âùÛ¨ß=fÉÄ‘RÕÁ›¾¢Ut;„»ÿ[úìlÈþ`1ÖÊnv¤çà ;aÀÏVd_çÓGäî+j ¯ûýÔÎîb_sçGVŽ7É=·y<©>£©ö´±˜`.©¦4ÒÞ¹Wlúegîë!Œ¬¤5Þ/L Æzàƒý® ó~…‡óÝ ZàM‹üÿûÚ™À#¨ðÞQ³ÃW$ÿ]ßY|M‘:@ÏY»’q^ÔÈi†þ›Ï¬©‚)eDËëÕ+hdæWVà”´Ñ_±pyªEÁôBSCE‹V[|l¯¾ÍÛrO©Ÿ>ÍÀ²ênÔDÿwVoƈZÐ_¥rg°GôK–¹Ç·d:bÛÑ_‹êwg ©gº;G_Ò¹†‹~B> *6¢ŽÌÞžÄ2º~b¦ýNC™wyÕû s'2 P‚Ãí¬ÈßHÁâæ6Y¾êóÞ¶á O .AE4tT9AÜ,©ªFG‡QÙö m×KðY‘¾Kk7@¥8J.æ¹èÓ5—…x:õd*E{qg4•¥>ÂoÓB•aR¹Ù©æãN¸PòCpøêØЊ2Z›,§0Š÷Æ–H±<ø@â¡õñÞyjlÇšóXéçÁgJœ”Œj”iÎâ¹.üö¿xI$70b¨t¦´¬F_÷«ÿÿþŸãm_§/÷¸^È°TåÐnw€oEì\I¸Ý€öTt¶Ú¢Œ§œµ.ÒÏúQ¶ZTeÚsM»M»‹eV;“äh;ù4`Th_·Òœ2/¶P5ê¸äÌ#ÝÚZÀ?­ã&õ¸ùÅ“N„MJ#жúM§W5¬=ÇRþS·K_†ßõ Ìzt6—™‘ßcÙÖ½£:YÛ¯7Ýи 7^fCZ^”mÞå}ˆú^"ÜZ­èÄ8y�ˆÊmK¯ÀQ„ñâ‡àÈIšyc�DõØÞOçG‹±Žƒ$2|‰ž‘ÈAS‚CÈr%Å¢°€ÞîœS¶äé°`îX»4ÚwkïlÌcSðnõ›NÐ÷Áóx˜Ohδžûê`(ËöâúdN|5L‚.òN³ #§Ôtî^oÜä àœŒè¼±¿À­bQé|cñÐÌèc£Õ’y¤è=Mœ>Òÿ¿ÿgzÝˉvW>…­ò8Å/–�̓ò«ó†®ïÛúìݪX¥‰SÑ éQØí—–jÀ=ŸÖžAÁ_@Tݬµ4Б¾Fòrê,­Ðý±¶O·|ÑW~ã³\r¿ä£G´ÝÐr¬ì|åíððìšìÏ\žQ]rLÆÌt!AŸdµ‡šóhÓ˜HõßV°9=šjiÊÌ–/¶fOb_Šö+í†ÚÓ+ßÖ3†;ú0tp÷l€—&Q!{¬P 8äE÷Gá–Ó%3<¹ Òã7=¹{RxÏg/•§¢P`¹9Ñ,¼#â ò÷ à!Ûws¢ªOjöÊÑ âÅt!UH€É£ŸHþËMu‹0¼wõu˜„ /,ch—µ ¦£ºú;'iO¯¹Øùe£ q=eA>¿{aõÑÒHТJ³¥Ÿe1“Š’k}Y®ÀÝß»Õ| íâÙþèæ¦R¿»‡S‰ ˆîL&VÝ—Tüit~zÛz¬2·,-J¹„Úq^DߣôΕöqf!$Ò¹|º=z•á×gw²ÐöáyÄ«†åeY:ð!³¶³ z›J–<˱À‹ä‚îÒ¶mn¡(áí‰ö\Þ)ü˜) pgÛ3+ÒÊ% £_þœç\ d|û”þØx4‘BM¥è­<SãŸ$/eµp2§BŒä-ÊŠY}ÖÞnÜsfî]=›Ÿ„áíˆÖ-¨Êk­@é7vëµ™jgÆІkö¿„ãDêU-sntê?è¦%³'|Áù¼Ás˜¿ó€û{…9ÌËÌgMPšôGÞví†+*‚<Ü 49M£x8Áíy¸öX›ƒ•Ü(xøì0®{yL”^Ö†W ß_—_íyüu G‰‰F˺Øl¸òpV9RT”„£ s·:ÌØšn.Ü– ~8Äõf¢‚ÕwÐNÙž½òÎE)Õo¹ßûAw¯îÙµLFŒ4YÞ™[©'$ýÃs]imE!¡ÿŠ=àÒ º…akŒîØÒ]Åsu%†žÒ:ðV¨ = Ú<˜g°ï×}5Š+õû©§¬£µvb1«5=ƒAøî­Ñ8ÓžéΠ@ Â{‡¡ïR“¹xV×Þ(ýx5Þÿ÷`–ç¾Ê š]5üŸg5´Íàöç›·SÐïÄÅ£óí=[%ˆª¡1Š^Y°G*cÝjvµ„Å€8J‹›°¥½@2ŠK¯MÊ9ÄjA½Ãº³)2NNÖô §%/LdÁj¬e´V¿µŒÁ@²íç2Fièù¡]Û)k„ –õ¶Í‡ÁÍÿňüÛ–±«èÓ^œ?é^T…xw{t¦hu€¯¡#"©•éáõåuS!ÅR›¦”B˜ÅZÖFÌ_@m‡©§ÓÐ{SÅÅÍéÜp-"®¬ªkK§©´%dÍÛïº>I$zv¨>,„Xb#1ÂoбñE`Ô°ø÷B,yš-Íy8GN=}e ¸Œ£TÓ(x‘²ÄÌ_Eá(Z8£S&±‹ ŸzÏ<“³úÝZ S¯‰X¤Ö»¸0J„ç¶ðý€Å`XÀÎB §-;A¬1÷‘‡’V±Õ† I¦û¢÷ÚÄq¢èÀ×öÇ­c@Ÿ‡åî9‘k>*ÌÀìØqWêÝÜt>e™X"™ãÈHZÔÜ4/W(à¤,`)(7Sž –ÿU+•ÏW~” ùæwá^,#j’B†šîŽÐt×´-—³U¹Ù»ãÄ3ÛëWGc.2:M¨ ›O Zp~k²áo’7yçd7vç%²/)áœssGVMÁö•NSÂH+ɨv:ˆX qL¼²KºqOŠªÄáùY–¯)Hw'ã0ŠÄÃ,WèA¢¯I'Yáó&"–ËbÝÈe¯÷¾ºýÄD\zêÛh„i–*-æ_è´àD´yéóÊ!�¡#qÑ9žFÆl¹)pèÛµD.@çgã<î¦wú–ñT£³s v­û¢-^4ºZv¿/t‚‰ÈØ™GÖ_Ú°º³”ÄfNsNwyö2S:ëê‘‹R3|àØî„„A7bÇ;ý¿Qæu)Üñi^ZU¼Ðú¤kwDÁk‰žü©~¶[ßÙÂPªWÐ0¯FëÝ—q9R÷L°U^8ã”{Ž/—-+ûEbc,D…G¤[e~T‘àÓ6”æãvwÆkÉ ñ.2-ó³gJÏÇ=ÀÛ¶i…¹Ž¨lÖôSv CP–Fx5Ó)7_ìþÁÍge±ú<Ÿà$¹ékFǼZ£Æ›¼Ë¡þ0í()\Ñ“ ã�Ó½¨¨¬ Z$ùñèQÔÙp­ïvAž4D¬´A”IÒ /^Œºóš‰!¶'²ˆ#h!Ö#AV8:¾¬Ba•¾qÄ÷#O÷)ŠXÕ6ãÈÀ¤Ø|ÁöHãRæÈUÌDó%—…ÊùŠG±Ñ M) ÒAfb¹rKlvü’³(ªÚæ3ºIf6G¨Fuí™%}žÐmàžöjù«H_Nb¬Rï½8‡Uy$•ê 8Ekï0[œø7õk> -dÅ÷ oµ (¹ ·šC«šïoü _ÊØ( g¡‰‚žÍš¹wHµ÷eÜi[ŒÞ€¡‘:ÓºùÅ C°Ê³gôÕ:† •?{€„ª—E‰Ã0Ó½†úôlŸ†‘Sìbžw?dA5Lƒumõ5ª§ÉlF“¢™´ù‘H{J PVZ?úà«& Êvëä_›ñ4ð¸ÎhÚ\äÞ•W‘e,'P—R~õ©¢Ä›¾ÇgŽjÛWçÆ·â‚ñ²ô¥¸q£È-ÊÛœ™FSDÀéY\t;Ó›†ØeV»ºW¦ÎHëm‚ôÎõ•ìDÞÆqú sÈfrzïï�‡¬í጖šö3JIT¡ha}âÌóÅbZùÅÜóä4‡M7œbÈ3"ñ}í fÞÝ“¯-Â…æ²94ØZe~r’ɽm½ñðe:hÌC}oÃ1£-uè 0ÛÈö3Ê`Ü 5¼é|HZ í7°ç€Ä"rWóUöEM¬ fJ´Oöô-ÝI]A+éÚ5õTã¹ìÙw´<z=)@‘þ’Ps^á¿Ež®#+§Ž[ÎŽ_:©Œo™9”‘‹ŸÙrü^RsßÄ=V±þ£rʲPG* q9lå?…õ‚:e Ý›,ÎT™ ª±êcv¨}Jß`۴ئöLO*;ú#µç[Kψah¨Õ8 Áo™JEáòXæýWê¨ þnBÇ—GqÇb®éKà:¿Dä ïŒò¨‚î Wõ<§W ZÁ†ë©IÊÝä$ó`¹]~΃ÐÒE|l6`,úìU¤aæèJ¼¡({K7ŸNàó´Z܉kLR’;!·À$&OÓ•Ôg@ˆMå�k.K¹OlEú†©*"^ß_‰e„ýáù­GÁ„“‡òÔÉ»Òxš-˜ÐJ¨³ ·à~'ô²¢2)>-Ô?”«0Hm`*¶½@££pL<‰[QÞY]c6¸ßŽC¬ÕALåXŸê¾/w®ÓãOžÒg£RÄúOÑM2ªÀL¶7-ÆÕf#Rc=J¦—Eæ743†ñDãÚjaD £1{~pÿ ÅG®@¯DÜ æɨ‹ `bªbêfl§mq/àêýaðªçÖów¦¸‚:‹…LºË®Ù-˽°4éÑþ¸ý×Ó—ç,NË‚ o™põãæSùz1¨ÛcÛü¦f‰A]>Ø÷Êbð¯›þ(%\îLê}eü }ÄÕžþPÒë0}71lÄ’ŽL”ÐÉ=o�ü¡ÇÈVpáþ¬}’:`×9ÆR§ò¬šÐq䤎H9 ØŸ{ÿDyåÎfø¿[01r ®ŒTÓF]âÑú¤Ò;ÿ¦„ÕŽÔJxí÷äZæYPæÈê üº–W>ðhÅþ3#²6íaÆ®mçaÛíæf—fÝä4œ¤ /·Í÷xéÞ˜ÓçMhgh? O h–ØA!>&R3³r½EšºKÛ5I¬Æ~ÄZB#dcÊó—3/òôÃt Å|= ¥õ£ó¯ù„—"+=·�>@#škŸ!»â  ‰#¸)[Utéãâ3õ$!…~{Ê‚lš<Ù‡þÇŠÔÀ_áMßmvÓ´{ÒÄÉtÄlhܦAñ9+ã kÚê†é«ÜT_ÿûE1ðÈÇÜ!a ’O‹Æ¾&/ž!Åaä¡ x”'¾%pŒHKû-A ܾŒœí6ÞBaUFýèz)ùm�öÔÜž"Á²²¾UPZS>®ê1ë°ÞUóRìþv`›f>¿‚’y¢/šþ‰¾ß±Šâû(÷ù å&”^ —Ý=iÿóåMl ¯~òrÂÙ!±Ô`À¨œ¡\„á¶ÑX0Ž ÊÃ0 ¸Í€/Òi„‰KÍôáÇ#kM:?=¾À®7”6ÌÛ†+ÖC–øXyˆîL-Á±²´ÛÝð»c$£¼õ° |<i‰Ye"GŠBïscx”!œp, JÒx<pRYšÀRÖ]sJMóÛ°C³®ž,±“ö¿¾6c·ú¸*D­0€A©äÁiŽ‚m)uP7Râ]k]¶ïú¹¥w)C™O1ö–ÒAÛUªí`5WéO,õ;ð{\£§ÑRGOnµO9Ú[ÂèüiŽÈ€þ º"ŒèZà~’Óß!Þ®›¼æ`³%vJ¹¯/ÓÞŠÓ¢/ñÅ€˜¤Ä±(‡«Yw8óœ¤û‰üÝF» îH¯8ŒFQh `¹Á„4F•Í—–9`M÷§ÎsÂ@‡Šµ`Îc‡Ê@ yM§c7þÚ×VÆèñ—)s·Ðµ¬/ƒª‘Öù2°a€øD‡¯¹Óyh¯'0iQý(ý Ö€]ý¦@\{eC°º~BŒÛ¢^@‘_0>ËM¨´œáv¬Åñûi8,„TÎçدð þŽéÁ¤’š?Ó {×®uTåÜ4ÀI%õnÃH<{qío’ÚÄSŒê )£.ZÀRñVñ¾´9üQŸ³ö¬pJò<sÚ¡P £-Y\Þ=]v¸ÞñbD7óµIFbã€ò²§3å$åQyBrŽ—i9Õ~TKr<2˃9¡ý”‘20 yÚzžg!:rˆß82&Â=ð/ÆŒ˜\€,FJÒûµ»cÍ®?†ÃYL<üÃʳM¨Ùt¡“7ÙêÁöÚ#˜ánëu7… HEÿñp¾Læß+}ùôåq":«?!­Y¥ip:ÒŽ}k<sS S|¯XE®åÇ2J«1 ’fmé 쉷wSiÓóÔO H°ŠÄ"õ¬é+M�¡ç­¦ŽHJºö4ÕF» $Ÿ€%¾ê~™“Þý¥O…U_ÅmMï}T14i»ž Þ\µÝ® 2”`ùrÇ8²—$Ö˜L¿Z/·:vÊ·ãGò’eäucDMêLO¹üìüvŒ8}_‘ª­É­D¯êVçq!ÂiÃ!Šè˜Sni=žÐ».¢é0EwJ;©·Ê\÷%ºÒ¤0ƒÌ{B#Ñ5*ž ½_é¹YÉêo·¢4uUˆÐ¶|£¿<±Êñ4}(,ç¿ç~þ^:ö¹¸iìA*m?u‘æ"Ë ëÿ>\›çú1*ʼQúm{xº*Q?Õç‹ ³›²˜ùìV¥<pˆŒz“^iVSÙµZ<´Ã_ÍÚ˜®ìäºk^(�ZâˆþöšÅ§αfëÛRUK1ßHZ¡³æ“ÿÉ& K§-'”–žžO±UàסþxÃt ÑcÝ#f¿áž¢ ÞöÂPÀ™Á W iÛ¹ ªî:ú‹é§FD…8Ñ2‚s±sUünÈ÷ÅŸ#Ï,L’º2h/”Ó Œ�yºûêfÛ2ûý{›ÞÆ‘êw´MÂÁ“÷£DB—Æ­]Ï`ô]è„Á¼€þ”iÍ-Ð[Q¸¤·îRÊÚYFI~RË´CÛv|`P®þehé7~i±ÃV™<b‚¹º¾/ÛJl0!èMóG4nÐoe0À_8ÇÄiIµ–œ$\bLG ó?O–¯VHW®ýÐF‹.@¡÷É-镤 ­‡¯HíN+¬?@'ËnEJŒ°›jW(3Œ2ú¿_Ü­¤\x”‡h=”Adëð¬°F,ÆYý]|ãŸ7<ý0±P‰è¡AÖ¨‡1Ô´ð(~»™#£©øå03’ÒP­ÚÚ\¶ú œÇëÚC4šØ*Œf þ'ÆyTyV6”Qž2néþ½š/wv\!ÐI?Ž2ÉiNÓŽ[RêŒ]Ë3$¨4Ô³Tk€¯²? 9È¢ŠÜ1‚3±‚ÚÅRÛ©Ô@Ó¼?´,b^:wD­0Ðï?´kÃõîžB•7èÎ<Wë=¢­¯vºë×—áÒªPÊ‹[ª2¶§ÚúmukÐywïW9ûˆa÷Û4ã.žƒÙ¬ãþ€N¹yz¯¹4ƪm&âOa‰ðLÓ§òõeVÒ3FƒþÍãï£|¤Æo± ˜Ã Ù¢>x·²¢”#í­ô†Í‘ð¦›�Ùûu`,06c*ÿ}ó‡Í¼(^ÿßàø‰<s2Z vGí÷Ñ GFU„l Ýø«Mô™ý”z±(̒η¦¢9))/­p†®>DÑL"­ô³@wq#ød'¼"q‡&±: Ú¡ñìŽ_”0¬ÜØO ,Í”P½Ý÷®D9“ÅôAÖEm¡í5æX.€û¿õ{q"[SçßIPn/pã¼ÚýB áG"Ayì 1îy7証7ºYÂ`½@oÝC)ˆ³zÂÜ?snÊn)½tm)’ªaÇó»$H-ª ¼;ñÈT.á=úñ‹¿»í]-GUÐIdŸfi+öíu(XKxÞb;7ñdi œnI‹Àq5hËCÏN“ÑgSG'WZ[^+7Æà«mŸ$VUo±*+ƒ}‚î›-�“={Î`…Æ N9_¬TÚ£”fêÂÊ>¥œÙ 7}ü‘[ôO–;$®ð ;ú*q§ÃÕn¼ÜÅ/KRNÁ\Mb+ÑNó²[­_1UÚã!›-e9„,ß8Ï~0/·Ý9ö–TÕÀª³V@Y*+–ð²2ÉÒÏT"ˆ¬SüOtôyCZóˆ,¬L!`D_f«ð0Â岌ŽïµwkŽˆ$B9_h1s‡òÖÌÔ§*Ç`œ`v4éþsT³£/ R ä#&Кñ¾f‚žÿ5ýÄ×9ϹSuH)]ÿTb øLTs Œ}+úË^áö Ã]d¹iæP0{bç„Úº"Û&D  ‡™Íž¬æ#Ò ô‡®YÉgæ>®Œ×eÍìVvB\® : °DS¾Þjd.šU¡¯–@iËå�e»ÁS!¥bn᯷9Ôó–ï7Rt DÓŠ ñ€|…œN*+aÆÁi¼9“é¾>ž9´KV$ÈJ¯/}{¥ß—‘uJe÷EK&Ú|ê Uù²Üe[Q-}ÈΡ+ÖEá-¶loÚªÚwMSó¹ÏjëFÕ‘zAPÊʇ‰À‡#ËsL%‰Ó~‹õ3znl[%p 2±àÝËϵçÌƾæâºhOmV3×ÒÆ´¬ ö”ÆnÖFã5’è˘s_ÂSiqOéqQ섧„´5Ñ#;¶fúñ½ÏBŽ­½ëNóÞ¤dL?¢î¸ø—Æ1Ò©ÑCljèÉé®\×è8˜a4shD{„O+XOHmÅôËZ8¦÷$mA¨x)»ú"úwržV¶õï]k %ªG7lí8ÎT2ôÄC«iûöü7ÖU^Í~èŒZß‘Å<ˆµ‰eK"áDs6oq²ú Ãî¥âOi ¾Bžæ"ˆ[Í,“òV {6ùYhûØB“!ËŸX³>³xî(0h~·:1 ?twiÐ •öh÷k¢ŸþÄæ0q¡·�"ØFudEýs/©ƒ¼w½S7“ÿë.õ$;Y•`hùv£CÅo)v6BLH“1¼{ðÊF#I¶PCm¡9ɬ¤´‚{‘¶AÃÄMjÜÕ¢t̯̓rJa3FttZÂaòTÆÈ×ãŒD¬&§Ðc\e"3vb Åu)Þ|«¶ð�úªèöÍš¸,]üÊ”¨ŸŠÆ-km«›Õ)5äí¿¾nAi>ñ Ù¼ÖaS’+<›[]:Js¼+ôt¤Qõˆ™{™SÄu*]7 5+c•Ò¾k {-r&îøȱL •ÂÑòRñÑ·2Ua#)ÿyêælì=Cû›‘Œ Yý.dM«õ¼aîa ÛêÓp4îL}ì–ÏÍÜ|µNKÚš+[Ý@OZ÷Ë‘}nø¸Ãˆt{¡rùB rÿÍØG…å®Y±) ªA ÐîãÅœ„š{üh>Êb•Ö<Ý¡†–U9)L,.s3‰s’·Œ>½ÆצÌ)x�–.¹šâ¿¥´á|«OcPDÁe¸PqÌB༺.€ ´› ÝäÝdŸÌr[¹y®¨y€2[i%ôÇxøV¢¸åkÖðC9Š<ôõ£BØgÉçÙô®"îä €Œëøù[Z¥ÙÒ¸Yä[6VN%冫Iþ›x‹O:‘¶ÁöHßÁ2è6}Ýú¬ØJóQDNB6î¤ ¢ÃœáF×!RÃHÛ°SžPÔv?@·ü`–,Àè32>©Ú<Œ`<À:È]É=\Jœ”üÃ*Ê«-EíüÓÊ(§F|¨ï|éô�gå.-ŸÁËù”$c÷òÓ*u“ –¡ ªZfZY3” çÉξ3ï³rM‘ÎÂznleY™®ãtí»¶soJ§²V(O@"yâÔˆStï¶'ˆÖšžÆ¥úöbÉVÝof”üÜL/4í HÕeAø¹v¨¿€s¬:4w§ ŽÛæ@KXflh‡¥‘f:”·¾3P»ÛOœNp,ŽÍ~Ü•m¦îoÑ‘Ç©Ä-§ú4 ªîbx@ púžIW÷w9ÒŽ{S˜ÉÑyH‚´ŸQÄ.Aõl2–õ–ÈŽA];ˆœË¿÷ÐРW½(P¿_<ô3}.抙C“@!§®G©ËÿÞ‘dŒ|‡fÚC»c\Õû»"KÐ$éjŠ[�0Žúlj|wsX3['G‘¼[e0 ç5¥*“*("›àô_�ÛvøÅØ¥ìÙ34wêì)x’Õç§JGÕ"{ëx<ˆ«†¿ßý*©ˆ\3œ—wC‘&<*¦=vá»{ Á($Il£øEoãöH\xµƒ4Q°>’(#k˜ó]<¡¦¶…ü¢g?©<˜•uˆ%³…Ó´Už¢|„¯.^*6«­û›[]ì,óù/ˆe:Ø(C|ðþÙ=~'Úý“¦n‰0È¢Ÿè~À Qn3î2v®l9¡§^(GÏyî$dËs]Ѩb9@=îúÖb)N¬ð¥™ÑÕw½ë­Pa´J&ºËÑ8«Kš`ò0äw&„·gÜÓÓ.Lí¾”'yø¢#/ã8…¯0 õà®01™ëaØÕJ£©Ñ`� +q9Š¶z¿¢Æ”™R&òeÓΰô¥ô{lÁÏÝiwyC'µÓ¤ˆ9ëj'ýÆõæ˜äÍn:±L—TÈ”µµ7|®2mž’;r†,•p÷bEw³8Ùt¤ •Kr0þâ¦"uØÚ�$HŠÏw§}hÁ3ªAjgæÏ ‘sàás¯o£ · ’Že3>íÚumý‰x,Ï€ã€{È# sÔû0¹Â*¦¡¯­C‹e0+·ä/œ!ç‹x*9罿‘òôì~¤OÖvYF7i2ÓÄ šúÂc+ÓNQg=rƒð‚ ƒÄñ*ñæÐY€ºB²:€,'0 ºÉÈ-‰Ú´Åߦc}ý£ÁIÝà¥2ïTOÅ­ÊÏ£ÍB¤ï]x_ó`j7x†j?‰àÖ87ÆÛ‡>Êùl|k`¨Çž/^W ¢ô?™J_îOŽS›`IÒ¶m1º<™Õ;­v€ÅlgËV kÍiÓF†bæòC ‚žj<3´'ˆa†õàÙVyÞ ý!q.ë^áûÅ^G‹Âû”ª“¡àiµ³ E.ll'á×°òjèÙä3²@ìÓ½l‹ŠŠyËëÈ»z”äIèÃT1¨ZÅ[:þ„*'Ž9ÎJF�×OÊôÀ›¹x:q¢¶d¹–_f"·ÎÚ¶ôäÄåœ{ ÕPD ÉÌnaaåŠïÀ˜Í‰bbÞi8%w¡Ââ'Ï@lÜ�Çú÷4«­®QdE°`Ù¶ùTû& ¶ï€I¼ UH$tN¬™z°íÖÆ)Á]ݱeu{›ÁZz_yþÊyDõš]2%"¹‘RÄÚÓèìg¸±ÓQMßý¨Ÿ–‡¾C˜²ÞLÜ|zœ;6¢6$®4úÞ¸îtfî[<”áÂó'§øP1 Øb „à*™4üë×;‚iêkÆÑ8ô$8é­2Ð<q¾µ‚]…Z«(à ë¾\vSÊ—�) —Ê÷µ“ŽÕ†€Ê¹¾\Šb¯wË>Ë—CJµ¡}çúH ؘ½;7ÛÇ]}(Í‘;þŠ ˜ú^ôÝØÑ"Y*:H­j¢¹u÷m½OØXŠ>&‹-Œ‘|³³óžÜ ÃáKÚAë‘`óïkž4ó%?B!ïT&óãi:ÚtUâZTàhÕY–…öC(G^eþ߉¡ùH+é½óĵã°Ðy¼/÷{ ;TóÃŒZå/ÁÂoW+sHξÒw뙊ïAà}Ê=oÔ¦§¨i]ºØïöŽõ~j”ïåHz|.YüWnÄئ}ÊnÝf’ƒ•çÅù¡.I*ïpLèËOt¥T}’Å¥v"õðgw°&¹Ïé6‰oË‹éƒÖWÑ}º¯¤?âbw_ ÷þP.ñðjˆ¯´vP0js@jíw'tmdºŸýò(º¤¡ïŒ…ÔåLEä¬=�ÎZ,KRtlN³v—uðÃû¦VXô.˜ávÞJÁt‹ÿ¤ˆo¨èŽmBø—~W­¸¼nbA$9÷îïCºÅøÙ¼f  ’PLUÁȧõ’¾+L+Fóe‰VŸÙŠƒÞÌ^ð»RƯ¦µËñ”#«é G¨ÀçA›ð¬{Ëx;n cï?aãl©ÞÛMæé·ÐÓ˜;”Å ¶H®¡ÈÍ´jŸ™ ÄUès¹è®Q°ñmÅ]ÙT'"úsºøÞ¹Ë×ÈDVÁtCRaú…ƒ‹X>'Óú_ÆâGñÂbº ;ç[ž•G³vûò#m¿~—Rg†‚©-Ü’¶ÄÖEXú÷èÇbŽ‘ #Šò °3l·ù®²Fªšñ´7ïÛ&üpyå±E"ŠºÁ±Ç\É2P!IgÂYÕ¶YWùDoáKùÚ@qå`/ì²·ú iÔ^‘uyR#n{zÖ,á%Ò~`cÓÍž ¬@ZÛ㥳/mÙïýí¥ý3™;×cDLûÎJ|€D»¡g'RÝwÿíaT™Ÿ@²%퇵]¿!·ÖÝ4µïi½°Óbªú¸§Üë·É9ù¯'›ým½‘mÝP˜GBÈ%úË[<¥s·Ä2JàTù§*©¦ÆÕºÙ)!I6O<¯^—§ž'NÍ4õŽþú®5Q,ð ÷ÃVõŒ Kr J1¥ã¶Ç®c”v[ã¼³&k¡th©|´÷Æè�Ù •“]LÚ¾}s`§˜#ïÏZ’~"Qkô‹ó“»ºrš¦c¢='VêyŸ½Ñ M™‰;¿É¿ë‰|}ƒÃ­»ÒZ3ãѹ£úÂWÇ…•µ™þuJ¹-¤ñ§J3òŸ1Ζ¿§Q¢ šºþY¤;ž¿2öOØãPΆXˆgvOÈŠ*>ÒÈ.’,K->–ˆ¡Ðø9x ‰Mw7¶ýCŸõrd¾²»z•!…Þs‘í{?’®b†”LBnÔpá¦f©G#‡§ Ý0Ä­½'LÞÍUõŒ³^“è±¢C…Án²yb§ªŽô^ÌðšL”d&ȼ Ò<‹ÿ$Èæ‹ „B6¶Šv°:ÍÍi2¼µÓ øŽšRˆ9ÆGLFÇ/ßõ’¨t;»=:Ù¦Xþ´­×ä绡ۋPBóé¹Ì‹Á›¬¸éšôýP3!.C ¾ýTáæËA19í°#Æ~´ïEBíæ'F�;ìEõdzÌy\• òø÷<Á“EOUʳñ¤; ®”?‹ü‘÷UæÌc(27-¸ ÇÖAy¹BŒÀu²¥1¨¯OPÉþ?Gû‘5r#+Rœ²Áûnc3…—Ôp³2[@ñ´)Êǵî·Ã}ê7îõÆô˒Grª[A¾Ò‡¯Ó;ÌèpFÓÖƒO2,Näò 'å1ÈŠ ]ÒAdÅê"(¬äoÌì‚ÝdD¬l Ê nùFÊETä‡5z<Û#ÐùkåI ¡ô=„„ìÎì =÷ƃ‘"‡xârÆwa¸Ì-{¸É"†a5æ®õ"vß”²S 9‡ÍôøåúX7xÕ_¦Ù§ÿ((f¥Ž¦›3´fc;ÏR¢´µüBÓ}¡D³ãêå2S¾ÒÑ2 —b§Á�RFÖZ‰³ËÑšT,Ë?–,¸SýE™/ý…¦Y&}­Î]5h“±ëAžëÖðú™3ö˜Í¥ðã6S?f íS ŒN‘¯d¹úsëÒ/Ãâú؃•ó0Câƒ|Pð(ÄÀà˜}Yu½¢M¤íCiç™'€þß�f†_#ñï[òöë ù–U ñ›*™6è[4 oƒ?gÖ,`B1{@ï)|UÛÎù†S{3q¯Ï‚ÿ•�uõã+¸ØËŽÅÞ} Ô¥Ó-ž¤Ê@£fï}|‡{ß*Í«Ì•#Kî!ÇüÇ´è€_wãæ4YqÃ�¦ì&ÔúÓ–¡.ö÷˦Œ',ÃÑfKg}þõî1ÿÏ;,™]mîào££¯bŠ")ªÍT)e¯2‡#¥Xò1Ó{EÛÞKU¹“Ϙ6ÛOZñϹ•VÉÇ!2Ùh\…=YéIÎ=t£'÷~Ç“°-李ié(a9‹æïsv´2ku7ÿAUg}[D(4»Q<iOÞ Aór‚“ïR­T¸÷:Ѭ�ˆ3«GóD‹0ý/e¾¥Ì>…p¾†èLÑÈ0ÙbÂ¬Æ à£³ç<0§Žbƒ½kbíí 6ûï@Ð@!7”…iFŸÍbÆYxùŽÕÍpà"QK¤Û‹ádW�v£‹‹ œ-.24#tIðÅp¥¿0 ŽC3[1ç^¤öž×µñG¨ã™/åÙ‘9ƒ+é>9nH+*ÝV!EOž‡^NEéw£ –ƒ©êeöø— úÖãÒžî÷®tYféÂ#Y˜8Im¿wÄ4ºE¨ÁÇüùÕªw¥Æžª’8(Û‹' UrY¤Ljy Ê§v#­G¿Ž&vË”qÿÑUõÙzG*ÔÏf8Ó®vãJµ¼Ï½zÙ>c›ÐcÙªÓmˆÄ§ b˜õ"6ÿE]¨Ì`Çí)ÓZÊ[w–ts‘äGž”þh&A9°G£$«}ŠÎ‹ËØ×;AÔß½R-úl¡Bñ»µƒvÖeY×�Èo0g¿0€Ä^¬¡÷'ÏÓ»ôäR±2QA×–ã.´í¹©ç¹Ó4�]@Qxy 5yfPèßÑ_¡˜X (—Ã:%´¢ïÜŽ˜ÆP0塽¸É(œ9 »^®ÖÈS×êAÓaÛ0Qª ã‰×Lz“Vf0£*O*3F˜ vf4» ­˜ éédí<‹u† ƒÑ,ð9ê¶1=»¶68ŒÛ‹;0Ë”" QÒ–²ZÁzœ·‡½…9üP÷:ñ¼œBUWT¾+– ªD˜&3H›ÉfHma÷!ž©«`q1FMmᆞF(45@Ñ礄¸È½.D™“'äܯ××NÂM&ŸxgEõ£Ç;“ÐÌY·Y‚Cýµ£²v2*ßöâÞ™úÜèDÊ“òSåÍ°DÎ^>ø_Ô&Ù•këöÇÁlê„yÝï4íÙžOe¬Û+ÕþoN~k7Ë4«Îà4ŠF ÔÎÜ‹’%Ì…ºÿ¯‰mQ¼°ç‘è”é8ûjv´ôvÎ÷ç Z.r¡GP¹(´%«Á¤i}#z6Ëîó| @E\Ãóü‹Je*v9½ùçÅ Ùm„â•kˆ½È|O!ìc mETCo$N+zÏýÛåMpE�õb@zM§U^nX'ˆ4Cí!‚WY/FÈ};î—=ºXwlë$nã]Þ±T®œ¤:*xÓSo½v!¢¸ÉJ'3„u!(wê‡*r€%ý^ìÊšžþ( !ej¼xü½èÆZ.{û”¥nÊ ëTFeÁÄÎÀ¦¿@oÄ{X_eg=/•­ùqlà˜Bßµ‚žÈð¶õ…aÄjͺ›¹Ÿ[qßûuožúø ô®6°Ÿ·©lfhÙÜäíáyÍ•êþ4Î|ùS:`»”½ÛÙK(bhMëNäÖž7“Ô]Ÿ«•@öWT<m-Ü6Bé1ºyé_ô>##»oq±DCÒ j?ÝQ:w2ð¥’k÷-cÁ'Ú"ÌŒÌ0г¤8žØª^N@þU}ép È&2éœ'VÙ bùôºõ…F_í›{Ôwñ,ozôlj{Ò§¬^`›š>ø E•ž6LVX•[!dNþ»™ÅÞ ?í®ÙÇßØgq›œ‰åIïsfÕ¯ÿ¼ÆÂ÷JÙð~[Ñ°u––ûÓäÓ$~®äGËx¢ %ÿ­æd{è Íí¡ÍVy‚Ìúu3ꟺ8²ˆNÞÄSÛ€âû©ÙáñZ0¬Lª¯_o2ÙÂE&¥|5£©t ØQWÝ/ÁÅ˽ô,óÍ Z*zO=l±ß)¡‘®Ž³«~•äë?£B¡S‚ÊétVóÏNU^Vi XxNbùD¼¼ ,Q´GŽÝ-!…ÿÇÓ•¬„ƒÚ‰GÍTÓí¯/J¨~…KQ:övª¡Å…¿>v´™¾‘$(#÷ö,ÀÅzë^=¼IŽT#ÕücË�ëCGÆm²h­Ì& °ñ»ÑˆòšcZ­?ÿ"F‘yÆQƆ頼ͤ k"®¶žÄØ­Šá9ÃjÁ‡N0š ô ³Ö€ºb ÓݘѲ¼¿(\™*ÉW¶ŠCߊ*ªÃ‚jýn½ûn”ÿxÚ¿¦MfCk¶Iî[¯H<ñ{é¦làÖ¢à¡é4 ²åR8,Ý3T­ŠâØöežµ#‡v†¯¾.‹è'Cßüʧƒ³Ì’«yf*QÅ̶ö`©eüq™×rMð˜·G Qk±°p=K¯i]I³Ôä¼w&ßÏËÜO"˜ÚLù{«.¨–é‘´ìß!î÷ØÌOxÍñB}œ¬vÀVoô/$0@¢µÄ‘ ‹µªW ÀŽîòù^Ášda^š‘c OªóÚÖ‚L»™g5zžž è×+²Î¹ z†ƒüÆUæÍO€ÔméÉ[ÿm8ÕÐÊR…› Ü^ÜÈä¡5æÏL÷8³\ˆ9K§Šíi]ïÖš@‘4¯K6d¬¬c[#§HÙ¢ÎÜÞÇJã®ßæfëgpoæ?üUz‘Uþ(ˆ‡EÏ­”ö w{‘õÝM5ÿòa×/M`&÷Ÿ¤Í^ž¾<$o~\PŸîør¦¾Î)ðDZ òI­—ò&LÚjb–‡¨»«ŽÉüKMà<ö}Î)—Ø~ÑÚ>Nææ›~kŒ±u,?˜¼‡5hvkŠ„ú QȺãÙXÄWš“›>£¤ô]§k`ÿ±{„?œÇzÃsv6$:¿1¬šþá#ô³€1)m˜øw·ˆÒtÑ L vD[7ì·^/Ÿ6½#òÍ'¦e«ųÍk ô…uvG§‚¥ 0\y·¬è†­Ð S¸¥ÚôµoBãÂÎÅ+2-EBçàê‰Â÷œ£æ}!…ز‚b£ò7)}·âOe%Lùn0U¢wú˜ w=PÍ´Il4P±‹’ ¨GÏ ßOtšøàß Ž—ª5!cÀ5ÐNìZObª?¹;Ib´9œÚíiwe¬NÊèa«C­Ð´Åêç\‘€€}^÷^‚}¾t+:Ùy©ÇýkpŸ4[¸3¦„ú²áNÔ,6ŽAñ_Š¨È³„ËÄŬ€©¶Ì̳N}ÏÇŒš³~&K[ÂÁ VQY|ìheû×çgÞ§6mýeÿ`º ph»±=Ž’Ô!ðÿhÃÓw˜;®âÆúWçÓzÍÏ‹°wK’ŠÈ–ÉÌ5ZÏ 6ýNLwÄ8¡5Pñ‡Ã×4^9é ØÀä0]¯-ž!€8#KE¶Cé´=Ì`ëmyŠ¼ÐuyLgà] ´À©….qt“X[nkšC§é)FœN¦;¦ ÈîB5ýBƒ"N\a,ZNâ%³žÃáwí ¶T¼ŒdËâS´ÐéîPl¹Cº‚,óDS)îõð9zCV o¢Á2ÑM2ÿr—âço~±Ô9G» ZIGì5%›;¥¬ Ý+Å­/{¹@p")â¶m§™,¬0(ç?Z´•&Œfwÿ…”Q84cÁÀê¸qü( -kOëÁJ2ÑY4R_LÒpa)‰º"dqOÙ'ôê¶�¥„†žQ}ìÀ�££Sþ=vPbþ0 ØåOÖ Ósîšz7˜î˜ÅÀþû&aü{ðkuºÍ>›ÒÆù•hÔv¤,Ëò§0—ªwØ^·`Û‚Ê»¹°àn�+½ÐUñTf*‚j{òMS×[I?~lâ}ÔïLiµØà©ûmxêÌyœtÖó{7xnA°Õ£í9AŽj×rÒÉ7ô…•,Tå)’ƒX‘ô«††²¿ær=b|Îe)_í:„ýMÊ9™åÌóç±·+ÊaϬ¿~X uØ^hÏ3÷F~lÙÜnã ÚZ›"`³P˜Žì,hýFz;Ð1¿ùÕw¿ÔtT aËÐÿtŽqþ~²5\^LÞmMvz[ÈT˜ÌpLƒâ4ºMÌ)qHíèŠy Å3Áu7ØW¡Øyj:¢wE{ˆKrIÈq(ž|þ¿·º‡©ËòR¯n5EÂ'¥Ç™³«ˆÈèO[ë#³îñ¥á†z²›i™—ÒJøjŠ©†jÔY£\eûröc+$x%"Ç3©!¦Åê.ת+=kQé´` å`†Í?S–T?tQ·ÅĘ²ð¬÷ý…ÅUÛïÝ €šø鶟v/Ø‘R"Hò 3Ö9Iß`Bn��äÒ>•‘åË^œù†ß¼¥Ü«ê}eg:f~[ìêþp=¿ÿ®#f»†!@ØÐF8*‚"¥´i!š³X }Óáõ+f¡k³e�UŒ[zãÔµúk¤Âô€wêQË›m3„ä <|ih$�TSmæ$òh@MÈhÂ?9^5M2dKo>©'ø¶?Àÿæôe›Ã€äÞ²jA×ÅÔw?›bËâq3cnÁ͵pn<p?:Ϧ6š9ÝKݵ¸Jü÷¦Óý7U>½v×@…¦`&ƒáóaoTÁ~Î,ÃÐg_£ ¡âS -#LN3u§Iš ‰B÷ÔKÇä¦]'§:‰·³Z•¦S´Ó±O(¬]¼­?t¿ëVUXýE¦_öBÿÌã_G"`bQ�ÏÞu— (¬ÌÛÉ®^ñ˜ã ðbQ¤Òg>ª ³¨l8S5æãè¬(æ0pgÁRÅncY¹\ƒ•©à¶J!J²:`!M>Dþ ªRz)BÊ<Ñâ ã‡TÙ`¢´…bÃ¥—è€iè È]üÀ½Ic,ŒÂ8ë &Ÿzô¥E`Éršæ…Áo”é=ݧÍy¢$BKG‰Eß‹²‰É³»ÿ±ÚR¹åi0Œ •ŒU™§uð9­ðµ¢€¾ö¯ R'eãÞ8æ“·$ˆFîE;¾î÷µýÅÔ-K|�VQd¤¨½¯àð;¥ûcwZÖie�ö‚ñµÝpEý‰}A>@ð‚,”Ž››ñòGãCÀ7˜ Ú-@MrÀú¿QÕ3…¾ïßT) ¥0n¦”òDÇÎT;í町£Ínp/4©«¢ ƒ´ªlp“ùþ°èž&Úçú4Ô#mûd¨êF-jT?né“6:°bg+*+רiõÀKYšæqS•Á:ftFÙQ±ckä‘c¨3÷꼆_í»f)Zâ/˜7W†z·ú€´Çy÷Ñ-xÌõµ=ƒ¼KÙ:ì$pÊ6ÞcºÓ|Ñò¬‚y„•ê8y#z:b¾ >©±¬}�Æ®Ç?0.al‡¬¨˜FŠG¨‚Á÷BI{aU¹)çríao’‚‰V¢¹¾®jvtàª.¥XÖOÔ±ºó,w9RüœßôSsÿ˜S…&8æF)D,pþ¼{@â}=u®…JÛfguC¾±Â‰”} ‹"=@ž¥Å3,i³söáMM™ö†*뎖·¾.ÏLž€¦`QZjŒ½DÑöÛ+’î'³ßåµYÛ »h/CqøRÁqpHßÄqWç‰/(#FqêZ�<ÿ<À¤±02Â!¨YØahµÝ¹zÂ^.“[+›Jr—ñ¶srÃtsÀ]Ê÷Ýy¿¹,ŽÁåS}÷îa“&  ÐL'6osA§§aŒ%/—зÃú,)}Š3É}Ä_½¡¾¡ë†ù‚çô¸}¦ç˜ñkThÑ1ÂåøðØ0ïùÔtºíÇáÙPOC¿+Àž=Y5³©ˆË&i=×K„ ü!¦óyhÊÄ]ð„œXoˆcÚÅyA}1òôm33ßã\Ýú€ï†–Núþû›ÕrÑŽçj¦ÅƒeŽå2ˆç^½Ù¶؉c–#“K©ÀU•I†…qGZ’v*?K Ûè ¸«Û³8V'†(1ªP¤ONZAyv“âßÛËG§.w�Ÿ«Ò¥‡1å­:£#wÁ ²ƒÎö=½+ ¶ˆ*_ûŸ ‘öG¥M™™ë«WÁAÉnö%d¶ØbLÁq×3•Å¬í2[ò•Ws,ˤZ ¹`ðG­TçW }ÞêS³sÂ’/Êb,æòæ8¶VŸWÀo5Ù³¶Ï<#ðfϼ‰-èÓö¶Ú ÝŸí»¿Bv2¡:1ê%ÿóȇws3u{¬‚xÝ›¼@V’S£¸9åÅ×´”M£ñƒ¬`ìŸéšÇ±„Øöò{L°¬{g8zêûIt^“ô£YÚ3ꩥφ*™Vo—7h¸P R#(ðv¨?°~!"M·Î»T°÷ògˆÉeW‚Û«ß”;TëÑQ¤©,0’¬%HU­tŸY ö¾lá ™P„Ó1œRaVøí´[šJ\Åç1œæ2Þ^ð†Äî5óê'¿IV(w%¢ÃT¥ÞP_– 8€º†qâ25=Ì»h„(+ícô²i3X p.²Îùþ´{‹RËK*ž#¨œÛ8 ŠAísa ½:±XZ˜ìfÆ–ì-K%HßiÞ#’¯7}kß«(ô´iéhÔ$–Öí÷T‰ Ûlk¡N½â{ó†`a·;D¢ËIãéãó/7úƒýçA˜Gc¼0­‰LÄ-‡¶õUþž'et@•Ÿa`Ðó•Ðmn”’•a²±ûÚu*w9GSƒ6Y¸kº9kb@·}D™Jm§2u@Æâ™1Þ3·»¯êDsSC–j  Ñì‚Œ®nìUÅ‚] ˜\L÷ iV¾„ûÚNœ\¨Ø8š3,üË»·È&¹bS¾[t$ë[Ñã‚šª@�A}@ô{°<’$4­„Ü$2è3¦ŸÖr3bÆT;77?ù»fcùf_”ÊÓq\Ðq6Ù¿ýzcÌÄqÜ,4öµ¹ Ó²°*\œ4Ò:? Z=²˜v¡CAc4ýßîŒÑÉsÁÈZ‘¤Fö£Ù"Ûkz74~ b°þÐc0Wîmi6N‡È/åAµ0>ú÷ “Û™ ÐÂrñ¯t‡âØC6‡&R…AÖ+X1)“r Šg”å¯*;< Lkµ§ü¼Ñ>ÛëÊüÈð7D`ÎéXø—ÝR?G’Vܘה˜´þÀ©âµK÷…ªQŽà€SjÒ+4% “Dh^P´±%oÆtN´Zdz‚Å8Ìo“XóšPk¸”v§#¨¦­´=:[ 6“Æ&á¨8¢:šCöþ¥=<¨h c”|ÚxýÝ}Ýî&©ÏÌz~©ÜH¤RŒ†ŽbJuY»Úª–onR~ôXßË^|'|¡ùš57\¢²Å0FfÙ0ö_‡A÷¯%¢°tJ #¤T÷êc…ƒ„5ݧ˜Þ±ëöc·m)2³pè((­Æ¬ˆØ|˜‚cǹO~BXM²Ì3:‡‘ Ä}¬šPÌq€ŽÓ^Á^ãÞô‰_,#Ó8óòK�—©LI{=\阂@!·7ÔÀ»žMµõJb…µE‰N×™"B2¨œ@œ¨BÑxi=ÿ@L%Ä—U•ïÉðùB<6g©Ôê½óèVûú2ÔV<v±U¿I 3¿»„Ž÷@'î'ð°í@gµµöØ«7sz¤2@pE�Ͷž}ÅXS¿µ–j åÒ³óÑÏÞ}±¾Ìóg³/ÙõÁpÓÉ)èñyª!Î96îÍŒÂUg±ð¦ó4ˆgŸ'¶ûíôh¨ àV²&îrÒ‡ÛP¡vÑ–¾ÿ[oLƒÍÑáͧ£'Þ#’L®ŠZ<Í'JEêã¶i‘ŒÛN)–ΑŠ‹Kñ´^Ã8–ôõªzˆnôoë4¨Ž6Å­Œ* à’§Œ'*¹vG6öðC"/œt‰{0B5~×(ÅT< ½2ñPÝu庉/ÇSoIãw¿EšqEÌF1xs*÷7žŸ'à1 è‘@¦„o¾ k-À1ï ä£ÜAÙÅ7ù�ËMå‹bG5B$ÆYë8·š—¾l«Ê;´‹vcv'•~gΑDZ•þ²HfÙ¹»<—ÆŽßÇIâ5M9§™:¨§Z'õŒEÝ3s›[#Ò ƒ|~ÇûêÆGT¦®NÍð@ör4Œ…%NSÎÿ¨C$çf씨ÛØxÉ´ñÓ0q¯Âá<,sf±w"¥ Š£bIçRÊÚ²&N¸ÝeÎ!…ñŒˆówõ@ÚE†ÊMˆ^û`Mì6{8ßì ½…Æ%k—|+äU>•Ž«}Ç¿OëLšÖ¸ã¼ƒMj<~Û]ÐÖ3 $ælµ9¢2\êPä¥LÒ:0.ŸAR÷IŸØð"ó#£ªðïŠåšÂf:hUåB[ë¡?d‰ èŠg(®¬„™¦;¿YpüÖ y‘Ô˜'l[úà“\¦˜Ò*ó5äÜ«K$ÝÎt*:ta¢ûW¤~§+¥×G6\Y²p¨¦çB7Üb€'œOíÁ¢|Çî,Ü—»—üLuÆ¢nȲÆ8 V3÷ÞmùZ¨/Õ•»¹-_“™NÔ©¼K:š8‰ÌÂ)¼¼±ƒŒ52"«µ+¹Úò¬¼¸Êà×#Íl ¤ûc­*"ÖFh‹Q¨ï0ÓJÿ¨ô²Ä’é*G:C;«OóÌwlj#¨¾:¤HæµØxºdAØn<&žϲúMÂ%Ú ?yâQ‘ÙæˆÌŒwGÊ«u­Ý†D ÕÃp°p6Ô¶<t5¦žo”ôÐoD |÷…l_D(‰É”íɛIJ¯‰«]kàl?”ŽQÁ]é—Mz`¿:=N»ýq7vV¨<Ž(æ'ƒÔ­ë‘yÚ|½úqîØ&s㺠‹&J8Ε}®7–VÛ[óœ%*׆aâ)¢^¿꽦þâ3’žô« ˜è —ßYaìð0Íñ4þî~"çDZKÿ*ÔÙ6k›UŽ<b‘NÀ´äÀR6è£ëfÉ@¶ãBég¶(¡gäpÛS\?ëá÷Nî¨&ÀIpEGé-wš7wú8Iì5œs£¥ ¼¯Nì‘‚tÚÚІÙ0‹‹çCAÍgUt´˜G¸©æO×»ícáß}·Úö¬?÷˜dšEθÛ?hûŠjs«‘:˱Âñ œ£Ÿ7 ÆàëæWê'äKH.¥ÿ°CÓ Ó²îr¼Ï"*%O çn%‘îæÇ;.r¡s `£WXúåA8·^Q@[y-hã!~÷ŒüÒ*[ëMCy«È½âÚ%"¨W+ílm/C‹ÇU>…þ'd¡`ʳ^Eb2Æ1×̓X½™~..MÉ¿ÀŒÆ.1Ó¶(-ü÷“EŸyh#6&­GçÒ¼Ý37ŸQz šÒ_¼+û ]™GÂú5³ÚÐÒK° Pó©™Ó‹i”«Lù�¤¿#eQó©”É0XÌFzãûÈÈ6éûJ ¦•—®¿œÍ˖׳ŒZ¶™b^²kU^»I;🠯Rj_°¤Š9uÚöâ¯æÔûÑW¡jC÷Rú8Š$/a¥Ï3 n61MoË e)üoña÷íï½&3Ùþ#¥=ôîŽP�ACÁê"=¢ŠjÙ‡ÁOæ‰åÜ&4®a�WŒ+ ©vø¤Í‡¯À¹þÊ‹ Z8ˆÑ¡Ólas^ku#6tÛ©6½XxªJÿ¾ ÍÛÔ]H™^ÿ߀ÂUx }0zý¬¡*†›ÒZpfcVþò±Q£;ÒÄÞ£æ5Ý×úËkÍ. U{ZLÈ Š»A_i+ŠMn JUÞ=ƒ¬s½Ö]ïÜNžrª,P’&¶ö:ùµ FѬ™ _ÔÖýžukjCwíPýtP–ánîjNƒbþã!iÅP3z7à™íчdbæaŒu÷/•¾.Á ³ô©qÿÇNø¶îy€¤ªžsÝ_Ì>ÑÐÅép×R,ìuAלè¡1Q02_M)Ú­%¢Ul@œRHÓ ëž§¨zqל¥ðYÿÌü®©Ö)G]xjó˜ÏæD_cŠ+´�–âa>£´=&·-Tb:ÓMà^)ÉÂŒÛþß¿¢ ˜yyŽxŠLgˆ lµ[& ôV»î®yn«gÁ1±¿OkMY™ðßžŒÀÍ}¢¸ }¶)<Uµå Ö­¾+ã÷`‘m>†¹:|L�µØävW7}p{SÅ7§uGô¯Ç®]Õ£HRX[ù»¿ôÇ‚r¡CxL‚øó¢y<…³s×ÑAfŽ5FÏ`WGÍwMã ìW–h.á™$ÁÚj4£*y×D34ú?wÕAÏèÏw¡ÕcOŒH^ àEÕ¾{¢ÛúO§|F:ýM¢¢g!»ÿp­b©Z<¥i¶±w4šÝÎéÎò]Ôéîëè|š¢™ ™<È'Õ¤š¨ „ÈŒï„L˸ßÛ”¨“§±xÑ¤Ñ Ög^P¡Ö °ÿ«=» ¨e¶`(ä7«æm­Ð©”ÏfŸ_· ô?%Çö¸æef<˜,šui'` ‰ :YBʬť§4´Zî>+ÝîE¥äÈù)•&˜6´jŠzãÕD }fª5,Ãè§Pš*ôñ�¡B¦Ÿ›­Énst†½Íú÷®ÓdTti‘9JòNßðpº­í"×B*ŒÖ±ƒö×Qwïx`DèÀÜcã¯Ë­½xåÿ½î¬ÑµZ�Üc¤UžgN ”ž‚ù"8å`&}6ú—R¶Âìe…ý‘"Ö‚øá^æIS^ï3kÏ„ÊãÆSé¡ç¸9Œ†�| œˆß½+Û¨-]ÊΘ ¦ƒØa¬Â£Ú¯‹˜FÿTPò­ä·_iP½k&Äuú¿ÃŠÁ \ø›þgèÚÌcÄe£Ð­¨) ²Æ<°ÑWÉ#UyFˆÂ`ŒP™_´#‹ø{–ÞW<‰Xmíë-}Ä%?¢LA±¦ÅÏ_Žµ/ꙎgÕì6ˆgA·ï¯«ÃQN"×´“¥b0¦« ühr€Äƒˆ,æç{Ól?fí Ø=`Ž¼ÐàÚHiØÕw†JO·‘ç ‹¦ ]ëõ>)Ãó8‹Ë>ÛCÞH´(;)ë^­‘ÔVϲB—·³‡B}ârà”Å&‡¹( Ýe'b´Eå^t~þÖ¨$±Ò[oj*gÇœÿV«{l5õ©DåÝ›H:ƒ"æÃ'¢ÊÈ4•´2¡raw˜E­ÐŸ2úüwÐN‚Qªžá «´QíØ(S/«ÿwbAâãuͦ²2 „9œÁ7FÞÓRrÆ<1¯ö*0á¡BàëjÏð讆«„èÿ]EžbªèÊÑWüœ,ui‚ Hëk~t=Ôîu€w“ŠÞ1£wV:QÛcTãÑæñA°¦Ì}ô]g”'·Å'ª´i)GOû›œ«ð¨÷âæÏbLŽ9˜-Ê­£ü~ÇÇò3Ób_$.wRù»*³f(>üP8méÄ¡{à.¾Á{Œwö`j·ô‰ÛÑ‘sš¾¦ò”HÌ5ÄÓe6ëĸ®› æ"•P-Ygùª[,ql'.moq§zM{~&.Z¦~}&‚t¾´çÕÒ)C7ß°ñ÷áðß�^—à×$qF  îbJ™ÀŸµ'Ì£GUū鯇 ŽD™¥KGŠÖ€ Ë:ñ\lü{;ã1£#ή¬_¨Hº­k¸Ñ†fËbÝW¿K3Ç»–Ðà³ä¯ó¹×9â–Ô¶N‚¬þcBN” ßôàAÖXõ÷¬/· ‰$‰#kd„È=WA<i)Z°U®±™´¼Ð‘U„õ•žéÀš‚%°*Ûrì”ØÌôóQõ®1rf’¦/Èó|GÞù`æ1ïÚÕÙȾ-gŒ|•Êàûù²¥:²e÷n3HÖéuòüñwê ÕÒ4*ÃRA[íÓ*¬Q�W¾Koâ<cÅdÜŒÈïÌÌ“Ø £/X�¨dïŸ&ªÂ4 šž”6ÝGA—ßa*,«Ùj¡ØÆÁÀë “æ)[µï'gÖþLPk^Ë•©OƒÄj|d‰ÕøÏBæ0^¿¬ËªˆûŸ]ÿZþžªˆÕçZ¹¹ÕÍCý ˜SFÀP^À ÒP~{ãŽJu–á1¹Â¡çd÷ª´Š²ØϘ1Þi:jp¢æCrÌÍ’¢Â_Éâ蟕n‘¯)bóú'·}óø xn—¦Ó&Õ"`[™©æ5»öZ9ñÌ bæùÌTª†ð†Êp7xî ’âæÂ4ÙEðÛI±U&=EX�‹»‚‚Û×Qƒ[¨ÊÔÙs‡nËÌ”“±¹XǽŸüÁHn¨Pˆ;‡–8jÄ‹Ì 9 °£Ú-ÐI4¶évOÓ¥Û¥©æV¿ó wf}Ç ¯–ÑŸ¨22&_öâV�3wÛeêæO ›¬´'óuÓԞŽ ¡u…ѸÀ4þÒØ O/àXè´èÛ1hù£>N\íi©4½Y/¨²’Ôbh„ä‡1Fwô‚š&N‰ØÌ>9ÙÅš°‚ l²AÑÈ&<t?ñÇI‹Åai UW¿{^§[FÏnT6©Lß~½•™¤C¥!>`NÿS£^Û¨²ÞL€YTVa r¼lÓÏz° Àè §ÍCó¿EnMK¾‡Ná€qâÿkø™]-.› Õ<м°-}cPP®Y™¥°2Õ}¬eÆæ$˜Œã‡è^<rÿ`έíˆÐŠ<)õ³s°…`¬ 2u?…ƒïï]~c^3c[Ê;£¯‹‡ÜÑÁÐzÓÿç|E+_&JÊ`õB¦9µÐBRå’Ǻ8×Ó®—bÕ\t>ŠÛ§þ P}ìxÄd:|Eд,}ˆ ~ V”~=R%Û­ùÚµŠ’È7É9E›i­Ï.f^‚äóàbÂ]=k–åUzÎUp9$ ÕÞçÇ›ô˜[¦Ü™S¢« æ”yÿé 5†¼šíRçWœ)-tÖ˜PÝôA™i=˜µ=œ1½´xoÚ‹- Êt¿{Õ1V¾á®TÙU«yú mq´CÎA&Ó…´â|ýÝc_@,a²_ ºÃQyr†äètVWÜØè¡pþ‚ÞįIÔ‚ù^AÏìªë糞¤ðÛƒ™n1-˜°88Œ]ã¡E‡•o2Iuó¦«pý©±ŠÂ…p˹;€ˆwyiåµn±ÿ€Ðš…Y´]wfÕáZ5ýáhÌ 7üÞV$ŠHsŒ¤ÖiDµ+¥‡¾º¬±ÎÖµ”ÿ0CÝ�±¶aîßö2¾Í—v½ë¿ùO'ö]’Ðëe7M ·H\þ˜{ B æ‰Âþ¹û«¢ �ñ† ¤ÈóV[µu¿[uoH þ}ËtÛ kb%?ˆ<9aò dº¥ˆv~螟GÆ Õ‰öJ§`K`Ò:v.åyÞz< Ø¡^³.¢T˜õ,ëÊt‰gGc.XwaFù{ăÒq´ „¤LTé½ûÝÄ9›ÅÑkDuf×ÿE¬à$Y–²=Åú£=Ô)ææßÌéqb”¾ŒðÄÙÛGÖãÓŸ VÅÄt–tÜ~Ñ-´I-Îz—Ù`ó1àÜ{w6ï)ñÎzl–èfPžÝáÎÚ[fLÈ(eo”( ²¨L³EäN‚xüòZ‰H?™)(‚ôŠ}ø-ã#-}Æ<b#;Îi³±ô½g¥ò] ä¾-xNGœÈ5­,½Ù—;6/þ>A×4g1úºêÓÛæŒ<kùLÄ ‘(+U6»ËÑèÅÅÒùÝZ æG”²IBøC­šÂóßað ;•]ïL›zöt^ Öñ/d²Ñ9gEyÍŸ *î}'M¥«î *–{Ùfî¹Ú‡¸5çžÙ H2¬?¶×Ó7d9g1Ü»ŸZ¦ÎŽVºñàƒGVø<3Ð'ñ"<Ë­EØ6¬Ö0¨üœ=ªEÓó‡±Yë“ÙP桪Œ@iDÁç¼É¦pCQ¡©ð d+úÂ=ócW\­=;âÈÐZ(wTãÚZ€&\Ä÷»Éå>töéPƒè"TùDâ6ú'^ àÐw(r”ÇÞ<:ÐV—�ÞðVLœמ&Ó¢•òè÷fÒ¬Ðmž`O{ð¾¶Në^••ÎWs‡°´óî XœØŸa\h vÞ,y}¸Ëø}ï­Ô³AãÄáü›…gÏ~œ¾ É((KC»áïÿàrùGª[;à$â¦sAàP‹©Êþ‘KYõâS!¶u¼•±É}F�jXVÙ{딘.µ#¾M˜D;y/Žal¡tsË‹<MÕz™wk÷EEv²î U¥1” Ü0´Ó™¾¹= mbQàÐf˜v4˜$nÍÁêÔAeÇB)UëYÆÆ—Àlÿg<\gØ£X„ÃW”“e­³\î¨s%ÏEï-³„å‹}Š¥Ò†˜>^‚±ùçÙ ßš&¼E·YH3¯u>c…&ã*”Žt‹?^*±†Ì89á½ÝôÌCÊŽáÕ1uêò ª5}ÌsSMè™Ø€s5Ù¡„|ºïû/1ÈY°;Ò’ˆ/>vèý4ìŽ]}«rà”L|(÷ƒIS&jé!ÆyåÄãÚ/|0"›W–Ãð’?ŽÍÒ …–ý¦š ´¢Õ (~;Ö§ÞÜÛá4Зáú‚Ά*aÞé×Ê_ébØÅÏ¥ƒZƒÃ€xÏjÃ÷îô#.dT¥Î‡ç3E©ÓÚúgÒRé†;¤2Fê46;‰¥æ‚'%øô‚Qm†Ûî’çÏÈg(|i£ô˜„1}¯`³›þ»Xj)[öôˆ œí§Û8îö´J†N7`Žwü­Ë½µa‹ŠÙMšù°1ó´ª ,$X>¸XA-ë£Ö¾.¶QlO%•'OHq¡ ©¤[$ÿh}y÷¿ûOÆÆÔ‰*Asž½ÞþuÚíw—ƒ³Ó&™(*|æë yäí­×è{õÎÁ’? ׎ÏÕ½$ªÕAT‰IlÅÇfdtÛCÝ5ž‡ÕÇY<4:(³½à{…¹�Î|þãÖd¦OÏÑHÙAÓŒ ıi:5¿èѶÎàŽLW‹;ƒÙeHV…™cßY ú¯V›¿cy±ßþ\i‹œåü—î'¸J§Æƒžò2ÔŽ˜uÿûõ!Nꋈ³d3RÅ4ÚÖ3¦ŽofÉ?Ý›ý«ñ°¿ßNœ'OÛ¼ Ê~ãX9´&*wuð-]ÉÁí®¸*ý*‰žônƒ&Çà?h©ºm¯ÜxÞ}o}—†©0ìqE¹htÄ‹T"âW=šóNGgC=ÌÌUæ† o(÷+Ï~%]‚J8}ÑÛ[…•y\Mm}<ð2Z “Ü|£S›Q —jÛeûô?¢G^Ú¾”nP¾ˆú³©Íÿ¾¦One”8®<ò¶”NÚ‘ÅçìHݯG©\ŒO:>œØ5ß\,4MÊÌÐÌ/ÏILª/™†L¡ÎÎùîã€Ùù‹;žéɢхmA˶V뤺‚9±Ð=÷³;¬åúÚ ¤6âÖž‰Ý“ú÷äUàiIè`''ïJß/Éý…ƒÔ¹µöz·' ‚\?™U(ŸëØŠñÂBC·9ô“H/ Ï,óµ…0åBŒ«íL' ,‹USµïôJ·oQ<åtª#©ºx3ƒxƒ–òm=š]uîÚÁÒ ïóÀÓd±£`¸àTÿô¤ã´nâT¸ûn¬•,B²¿c´;õL_ yg24_æõ¾Øk.TÒ×»§ðÙÙ„ÏÌõÌ ð“ü-4([˜­•A»¥sÿ8ÛÊ™v-“¾¼±!ð_Ý ø0¥—7ãT¶ü 3w ÞaÇžY1X~0’uz×úã­~û 2¡=Ñ¡©ËF`F†å.¸ºZx€Qž´ª J~7ž3 Óß,˜ž37Œ°(À>¨€N!ì'�èHZ·y9W¥‚>õŽç†F•Ô1^Ó'ý¥‹›ÑÏe1 •D€‰{’‹Sü¯ÿHE¢¤õ‹Núìñ<xòtê²sŽÊ’q'„ö~ßš½ýÄ!*òv#sQ=&ëw«@ÿõLØÙò+Daœ%vl-y¯ªô؃†“±Wön½%cVú£ÿ €¯_6är¼çÜèÚ7iÁˆnÁòÐuæH¹Ì öñ™' Ñ¨=ÛíáÊ9<Eg$ ²ñ¤WlúBC»º÷ľ­}—ÿ(‡l(òÙOl-ȨÖÏÜÔŒ˜ÂËHóÆ~:M‹c‡ŒWBIÒ¦ó¸›+º g`N ^ÊZÌh1ÈÎAN³’|‹äÍÛ¾v糆"Fßèƒyû¨†p+V¢Âeâ²A¡rÿAË>ªµÅ‘ó*Þ–õXÓ½“‘ !^CpÅ\Ë;/~ÿ)é§ÐN€ w|Ñ„Z›Ã…b©ùšeÊÞæš*X¹ ½zþ›¥F…Qìèì~Wæ.ÝB×.®~à^è½Us_”]@ýHšÖ¶ƒÑ4 žÉÚ6ŽÂn•”ò;lnZ,‹,äEyP}ZŸnW|Ié¦[ã0Mñö°JpÞI¡1®šæ*¨ÚÚCÃ1 ÑÉur?þÎg7_òäèÜÜs:7uw�7Èg6µžtû°õTŽè¾’ORfWBŠ¡ßa [”–½Eôx0wEúpÔ:±ë ø’êêÇè«DŸq6àJσ)§±^OéÍ65{bºeÍ3£ÐL_Ð]ûT9Lç£bMåã§7nu¦^o4ç{àSg‹ì=dÏ ºE'$‘snˆÂ‘ûšò*>8‹}µvXÉRïµËÝõ»?5VºÉDY û¤áp~eœ]5� a¶'V ³ ‡¶ë_Ùw»bh¦̨Ùp«Ù½®{Ö ‰S®iå¼sŸîµþqbqå©q‡˜pbñKžL®`QŒ[w¶ø/Wà£Ù`Dù9¦K ûõ”"ø¹ö€ºÔÌv8ûkÐoòõ,tù$"`e¤E·qžF+NÙgÛÌx‰–&q¶p®>vh_Õ¾ô/c÷ÇN?½!…._®¡Å^öÎntÁú’iß›>df†õX;¶{ …aÎ2ï]b¡•ŸÖä7+XF”fGšßBeãBQ%¹}:¹¢ÁBJ¦çÕ'äRê S�4¶‰f(¡§JËý\_LcÐüô—†ç>€EVH;Ó §£g¨ƒü­¡Oc?Œt'3F’Rca‘M_3ûÊ´<¯œ°aˆò6Æ Õ#é秣º®P¹¹m=ÉßøèükqÒðôñÑq¨9žjlí1Äs ô!Á[†6º~ÜYЮx,và” ýËé ä$¸eîíáÂaå%P_ádçk2É|fOÓUÐ̶ò^qÂöüa~ŸåFH8t×|WNZ!0ݱö¬¼°ué0_wƒÀê®aÌVIßj·t_%%VjÎR¢`ï÷f kËìîKŠGãN´h‡§ }VºÓ3Õ¨'Å£kå2Õú]':Ï~¸!ôc;­qQÞ*¿@æ‚,F°z¦$þ^PXËa£¹MUÅVK™’?fS´Xgô·dwm‹ÿì.nÊ0k±ª†í<PÍRvješrƒoD™.d¶ùÿÞÐtG“Ë:ÄÜùV‡W§RMYKƒÜ_mie®·Ó#í^Qf6bꛪgÐ#Äx”‰÷˜½ Ù2ÓûN“#{¯DUË)ëÿô‰§¥§†Áõö”IóAVzÜh³Hµ9ˆ]ÀÇ8+²Ï¨ösm¦•c·XPÊ4Àðà€VÇ°4Ô›óTPu¦%>¸sãiÓÙÊLd2,mó4l©çtnõ,É|Åáp)׸‚ãóD9'"õà7´Dà|s¹ $ÂíèÙlO"†e›ÓGi}-XùÐ7½ž’ øRc-´':c¹Áz”wå(Ÿ¹³FáÒ,`}zçd`: ¤ÄMT£ÑúmʸøfXòÌhÇ+y‹ãždÂ}7ÖG­¸¢²< Phƒÿw³¹Xä«Î‰å(ªqÆ\ÛËOGÐqµháúçAb7@ š]ßé¾=rÇÖø…Îb/ñýiyêÔ€V†24n¬ärÌk{˜ÿpdÇ©/a†’¨«‚¼µ>ó‘hÕ¯-³pY=S·Fó¹Ñ¢ÞÖeöV� 9I£ØƇ@×nÎ�ýèë#¶kœ¤~·¥§”»ß¸Öˆ'_ä±Lˆ FYݽÐ(![Ô4v¨É§Möôñcõ g»Á1”Ž¨1Ôê¹¥ÔvJ`óaÊx<^ë°àGH9Sdq[À+0˜×ÿÈ•Ù*(ÊyˆáÉ:¥å÷î™mÁs›M0¸ÿ"3ŸÃh†&–¦þ˜°nOõÜHøOuNõ¸ö&UG(øwTê@g‹†-bÞŠB(í||9~»åO¾ZSbd(¶uÌ25‘bRœÃ± c.˜Ö–`áÀ÷æ‡c,V§Æ—ÉÓ¦Œr)¬Hr¦ò)—?gmK‰çË& ²Iíä`J+¶]ú;úŽ ›®íÅEýš=”” ¥´¼x:ºî¼”ÃÈÛƒ ˜Nßï>†+Qð`d¶ÍjÓÝ}÷” úÝo-eLêô†Š˜e>@Óø™Ÿ‡5ôIJëîáÍÙ‚àO <ÅÂW‘Ê+þ tF[·îGÑn«¡!èõ§,V4!’È°&ÏSÉ©Ê®ú–Êà%þé³Îk[Eû`§mr¼*¿E¥B‹ÙñP±†™EæÆÐLm¬¡cUónÅó §�ò$]θ‹êؤ,H96%c±s/nyè#ç<bè X1ÆñôŽá› †^—º¡¯b~¤Úè’?¾ôq^&bææìž>h#”ódþ,ÈxæälŠ÷õjEËGùy~ð±™kÈFÜÀàQfyQ˜àˆ‚ŸY¨À£Ó_g»;àì7—o½$ìŒB<ÖÙ‹N¶v«ÓŒ`5ñ=õ˜sa7»«‡Ü.Ê â4³®öQ%PÄâ¨AcØ?÷‚"f^ºV!Öa|ןžJŸÎÕ-®ï^š£g©ïi€D°† Ç©v8ûÜQAJß~Ãl:{ñ‡eeHbž„}%*Ì/ãì‹È#á–‚¹ŒàFž8ÍÒ”ep9 Qcá(ÖKN˜@èX9±ý[5h7­,ÕÎn ’%:锕‘Œ†(ÑÖ§ U™* ß~‚̹SáZ·ï¾ÌG2[æ…Üʼn½¦f®Ú^ 2b­¦ 6¥éÛ³¨$€Rµ<Ÿ/T›RëVK.-œ@'×MçˆîÀ»‡i_¢¬—Ùík¥€Cç'¦ùyžª ü£úQQ˜ 8\±ñRëÛ%jô¾$º²~ Ÿbº…CJqKÙÑ¿oHÖ§ÕX;Ës`x¹—½ &W©Cµ3øw^Ó¹6(zƒ2ïÞÀŒ{‰É`PõS®ÿH¿ØÄù°”«‰ìSËÄ Ýúnm/›º|_MX•.sW“nCvz÷9ëi¶õF²{AIÓ.ø$Ò_>—n+C‹Iȧ¦9DÙéSOÇ“âŽõ¬†[–ggt,ozÄø›”»¸Eÿð?`%• žÀûEM[æÿs!! ¯¡wäxØ)ð%(d 2Tò½kÙCÆð˜Œçózd··¨þ¡w^cÑñBs¥ÕßÀ*:Oôe tƒîÚA¥ä¾ÁÝE¶/šc䔬ÓfhUec§Šý %N w/ åÑm-È*Ã<¨äÍM¾Bÿb;E¹ÛÅ%OÉ7ô™:MWC‘õ$GvÜéŽoÁ⃠ÇhÌø‘ §uí#ü¯€ËruÚŸ¼ùÅ÷¶××ܳ‚ò›,H­¸8 Z3“Âðgõð¤{GéñÏL|Bçl…^ÀÏtÿ¬‰Ò‘#OKŽª¼«áÞŸé°@\òz.–{JH¡ˆÌAÐ Ë´]¿ï|U៙ Édƒˆ@ëÍë"å-»/Œ)¯ ¸éêÇÒ]f‹–øè†]¯úWöÒäQ×ùTå9E%X§†Ŷ±*!˜ÄõTb4K‹cY\4ÞqªÌ}­ÊQÚ! ŠwíA¡maགྷ†¥­hC2 ü³ÐÈJRmîÛ¥ž2ú.vÚáô}Q³õÚ¢1ƒ4w¯Q=úll�T¡cº‘A“ÀmæÓÀïø#帤pjÜ�C—ÒyºµnC “Ãb<µÐ³ÑWиyã,c;b‰´‚B^µõ†”Tn*úåêß`˜­Ïø­¾É‚p·ÓwE›1¹Ud Ü…ÑZ`Ì1Ð&“>ÏŸ@–-ôð©î:¤¡ç´‡d tÚ ÇŽöŽRlLôDô×ã|aòF›ër G'ÏÚ×q"ïí,tf–ù›s;«ï‰i‚ë ½æñ€‹1U½Þç¿0€aªê‚›_¬/}Û-9ë•k¦Šjô<Ò™š ZîEo¿ÞàØ ‰^™Yî/=H'²"ÖuoB+ä$)jø¥dû¶„t×@ŸŽNÉÚò*6”i³-˜=ý-‡:MÝÈ€ûðH‹­o1Üô¤1$¶²+C¥2MrÕI“Øò(l;McÔ±–+*Ml䈅Ve Ä<Ev ¶ék*¨î8–¥nX!\4Tø¾+OÂ*¬²¬œ"|½‰"„Mý5·Ð~(Eù°ò‚•©‚ƒü»sš°¦Ü,3õÝ{(Ö¬T¶…õ°®=ù}ÞpÚe²×å)À†€;‚ªßÞÔ”¢Í}}¾çÎêÉB#¨g0/ü&ÚôÜ1Yô%ΨîW§ÁÚÀò_½et_¯‚8]p3 D”­w:†¬Â¥mçTS’Ì=•­ÅŒÙ×…ÆŸgÅæ½}ÓšáÊè­¬¶ dxÞÒß«zÌkA)À‚©;‡Ø@›Ë.ÒêtBSZt_” •Ì>ă˜NãZZ¾ …Hc e{ßù(Ò çpŸEæY'ΧPÌÜPË+ÀXeàÙ# 5êÇ µ³þh}"‡]@:¶WnâAwœ{ù— ¿Ž‡`®›¾]*m²Žb¼ÕMW¦š;Ò¤C4©—/wzqæMz))h(|„ŸºB•ÙA¬Ä¦GóÂãR̫߀i~{ú[®‘|m,$ u$ïµKV‡Ã¦³y¥Ì ©¾øè6Z÷/ýâ81¯žòÀp¶ø ž2+ñiÀ_i.¯FñH‘:¡qámZ ¡çZçL¾:n¶+qx1iR9Ø'º°™—óˆtØ6Xífg"Wå„:i/X3Öý²þºûK©º:Œ3 ÜÉÊÌ0»i,Ï”7ˆ¶ù_L7 zMKIæn'AÖª¾sbUñOB\÷ÀAßà@}æ\¨:’Ù×èð"h]ÞL«»g©è^c®8½ )YÆn¸ŠZÂðÛKm 1ã  ÓÕŸñÚóÄõ|+´)l�Ù×xY³oYÓÐì<ô-`5S‚M¡!½ïÚ΃„Wèm#?´¦·ÝEÝ™—­­ÇºÓyæÓÓ²Üm §°ö(ÿæ#ëby™YZD¡gøB÷wÕäToZZ§ã¶ƒ\žLà Œ¦ÓûGÁyÄâýÝÓe>Š½îú–ý¿ !¦n1 <_¨lø-ØŽeæÄ<µ*gèÿh½5²@Q|ªúîߥŒb2HK —2‚|˜¸±·ú¸W >Ö"Š5òÇ‘yžMK­sqCï}Õ[Ä¡h‡Ðàƒú¡ÁcUYz¤ƒ I”þ«m2f†´4à?ðï[RZ]w° j â{ÖÙ’g ²KbÒýŒ´ ÛAQÔ?Š²›Ö¨›2øôÛ…ük¤#Ñ¡-ÔÎT)MïÜÄô‡Ò€¯mõ³¾ÊÚµrª¨BKÝôŠïÆSÛ1„e7¦õèL÷/ï0›¬êIbRÁ=a}c†>qžùÂØoV‰U¾Î¢7†«þû•“‡¹OÓƒ+ëƒéä;‹¼>üžœ‚|ˆ[<‘èJ'A²©=;ÞömCUñeÏrÒMÝ€y ¹²ºéÆË4ƒÞFg žÝf‡…ë.= U#E™È:§˜¦ùl|ÅoÁz§; ÇCœH¢­³84yÈ~”õäI{÷'œÞ}¯=Ô©îgÌ®á»hR`Ûm0É8[‚ ®žT8mE!«ï«ï{|E6|ÊüÔdª‘ߟ‰ÚéÛÍ�¿ÅEæ(XÌŸ¥æJ¡Õ)8Úò hï²>ÅHL¨t/33mgC·hâ\ K¤àŠ‚ã¡ÊÞÓFz§ï¹[ÕJˆü©sŸÃVPAî „|0nàæBáMþ†TsY1èË1sÊ]Ý–eè[º‡)Os‹ùÝ;`¬(‚꺙—'<Ììè–X-Q“¥nŸå®ÿK¾êˆÓvI‡w¶¸ªÌ‡¥úT&‘ôäþ}cˆ”µ>Bìy±L©<Ž‡šóMýG³nø#Êî¥ö[¦ÅKnÌæóúúÆãÈ<­uˆ"#l4î)ÖGGå:bÒí9ÌIr©Ùòu·9]^ÓÚPB³ZOF:@Ä@’«}£=j+¬Þ°g’¿0êýÅ29w̾=9°”Ó×uRa§ß"‡~ÙÀOÏZÙ2žyKŸ¶¥p0G¦{sïWt˜%®eV™ DI_ùimýû²ð¤Óm-rè¤åºör9HK#·Ú3Ö êi¯š8¦¸–°ÚÁ’ß_M– %nVµÏ‚j£*túŽÌöäbbÇàxÃNèZXûüFÙÞ‰ÐKÞSQ±CwĹ£ŽnÏdöGc¹8+=ö8ض2ÜA7GŠÜBÛ†1¶AĽj˜í: Ìó¥ÿ;Tµ“g&@ѽï~Cìþ¿+2ű“âœÆjÕZÁÏà_ãÆ¿í©À½Ø8Ü_¬ÿŽn–fW°Øfª‚dðÝþDªÿ·ƒ½(YJ?ñ£Ÿ=Y•Ò˜Ë6M”íÚµ q“„(çÒÚÀøåØ mÕ5O£+ÙíXÑvôÀE§£›k*:³ûN´€ö5€RÒOŸnk“Òy›ˆZüá‹ò‚èkòT‚™DO°ÓcPí_ôõW5‹2Ï (,¢Vl´ÿ iJ+0-}»Ÿ#ÔÒØWéM¸§àòä»h!ðÊëàÇ#b.“—"?²º¤/á­L+í¾¨hi?ýôæ00+A£M÷ƒ¾h®‘¨ƒ·'–žñðg!û.ºx*Úá9B¿î]x3BÁ¬oPÎZ1/äc`ð:4ôq<l̽¹¹úÿYû·íV•e[}f|…ßöK靖;<‚@B6B2 &«•óÿßq¢Fdd&ºYvŸ»¬Ý„Ýç%ÈŒŒK½Ür>Tæ"ë‘r>«ÄEWüª Ä K¦çw˜gyês3VÆ­×PóÔÞâÝf4/ú¤%Yºl …P×o<µY0̸ZÍOØsayíqØŸ@@¶¦e§ömä7¬¡"nrŸTþ‹å9Ÿ˜ïêýëñèŒ<3ä&g‚3)Çñ¾vZÃÖúÏoµ­øQs¢ï¿+)cs˜:_Tsç§3¢<Zn£ Ÿè@GEÏ"]P‡0k°õÿìÁ36¯{„ËËôÑTvÝ¥A|ÔAjj§O#­ÕKþÌ0óy{="¥•:¶{)R¶—Sc4 ’K¹Ç»^ĘˆÆ:Ò¸i… á—# )Nž¶óH9&ÃM¾w”²y} $ #7 ”<œM‡Ê/ÌD(“Ê 5ßÂdè{áܓÉD>¡üÝäàlâš½æ¦ðáýDà“lQSQvЮ)óŽÛ³å‰‰€�­%fŒøuïký1Üm«­®•¶ê,È ÑCÙOÑ÷—«ÝUµƒ SÚN9%߽뾶Tå™Ns4Ç¡}u jÕ±ôÔ´ÞÃwÍ`× gÁIõÏ[d@ahí&åšî6›ßöØÜlN¨$T¯OÜ?}m®u…dÉÕFÌf`*ÝýKO41z…çMIqO‹ ZBÜg7SQ;¼žŸÛ6Œ5°ãŠú5Ê(SOÔÒ®y€€d×{ôɪ¯Û=ŒŠ’a;é>¡ŽÓO}5TñÈ;阻²Þ$pÂ](7ÝCżƒ›D–RÁ†R9nº½ZŽ…±át‡ 'fO+£:ÓüÒ»Ù}>¨!eÆF@*©ÌøåÁ3Ë~ŠL›csÁÐîhˆl@ÌöÕÉ8/ØãôËþ]c OßpzIJ´‘ȘPý”½«<|Q²€Š¯s(ºõ“0K’dö¡¦V81h%tgwĶobÞñäXâAÔ§µÔHŠÈfÕ,Ÿ~Ñòðx ë…ƒ?Íê,~'œ'KÙ¸„,ˆ§ÆsßÁŠvéÑ/ VM83¶Ó²½tÛz“zKNþ‡vf]*”²‹É}Ëôo4Óý##Qȹ¡–$´€CÔcÖaTøv[QÝ/I$''ÛqgÈÔ"!Äw|ÙˆW‹X¹sB Fqª( ggM E¨Ç„ò/U/°\ù¶ÒPO褈ó´ö•çùðZØ^hñ¢;|Qê{úëÀñǶW,³ùIk½òç„Û†?fª4û{õÞÊÍl§oémÔY¼! Y‚•r ‰oô)EVI©ðJ£¿r"ó!·«Fø,G÷•ÿÚš_¥W¢Ùó™*¾r´½ŽÄé`ŠÔßrù÷Î<ÔœÇV&í9í÷Ϊ}ó)IïÅìÃ81Rê·Ñ%/ü))&vI[4H¼ZSn7V×xÙ;¢ÔÉmÒ1Ùh'5½}¦IÅž$ d¿Õnû¿wj’ÒŠ,³.%ïTŽgÇgÀÙ/ñ|…ºÔ:FPøDerËÈxCÓ‰Pä ý…!ÒlOÏÁv7­“µ‹³¬QÀ™‘˜,"Xéé)fÜêÄÑš ê`̹–Z²9ԀѷßMmÅv›·°¤l•.«�hœÄÖw0ÄúÊ3âù©âE¸ WZ‹žây_y²} z:ÕöCü[\á<æïÐWÉâ ¯¬°T&°™¤9Q’ò2kZôü_œpYo!Ì!©¨°²ÆøKª“lxætx‚ìÂí…bX¨•¡¤‡¾ai"ÀÙÀá:ÍÌ´þw7ü»9ñ^»ó÷ö¾Š+††#T·ªÊë.‰ðºhtÐ Çd„É}몙-pñ/ýL<1eoRÐ ,g2Ü~îÁÄtAzQBZ µå×ëº òqëÌO(€¸¹–0(wQ«º+67ÜSži4P-[9²ºª<aY±êSP*¦W·ó¼c»-Úê円°ŒM¯B�ç©äéù ¶vî Ùd‘§¡.‚“ÆŠû4¦SËÁÒB…Ñ(ãüt€Öcœª—†¾útëTýáÚjÑYÜ,„Ñ›7=›à÷|ðº¨,<€ÞÏja±;Òø§åäþ_@B¯*a6qݤ´Ì5êR…4c%š=n­¿0ª·5ih¦* R’¶òÍU¿7ô,Š”ëÓQ_³†ÑRÞ7 ÕÔ‰ÊÁ$•â´y€5]ª^fµr:ð§½Zâ7ê<õ@hMV}ÁL3)Ÿ)Y’3Í—h½œ/ÛêGÓúäW]5i×kfWbð„¢*A·Š2dOf¤ä¸×æ˜m&#)èØ6¼ç¾Q#Jóë¦L&–îWÅ( s|’Ëypi1öÖ—ÇDã,sf݆tÛ–Ahmf˜SÀÝ€©;YÝ^Éo×”Ê]¾G¹Ç™gòÌàùa„£•oJ"©ÚæY—Ùq÷%Ø;Z\Áqßkáãùÿ–FÛ–•º¾,°!ByÒð=1âĹ(D¤· J'0ìj7žáoä£QÊ™g×õ‚sWXø zû¦MS A (m aãO5ð�c|DãçV—«Q~¸Ãm¬§0qT‰¦¹ÛAþÏSÓ^o�•ÝMŠY?1?{ÇrʼnN8,MëQˆj¹™r÷×ÊâVWtïÇ"Hû£Ç/ôþ4‡³EÊáPA*¡ËŠµgÑ‚¤PA­…]u±ž§·Þ5Ñø‘ [˜AÒ ]žZ/ež´õóÎ$± ˜Ó»œºöÈ¢c¦¡¤Z†â HQS2ß!^+4zk÷üBÜö%VX3‡ýS„ÆÊ:^Ïú>Óç°Ã‘lzͲq/ø¤˜ÇRj›*õ½yN®L2~AíõKõÊ—)`È@DïVû V€º^´z3à‰Ó K˜Í–FKTŒž8ìý½½’/b› ÀmèsfÇw*�ÙÁÛl<Žâw—ÙíIeEA7FA1(—E\hÒitkEÎc'¼c±˜Ó ¹·ËŸ°‹«€_õyÏšò§©ÌñÄõÛÿÍi™+[AS˜#}µ²¯M2ÖÖ<¹7'–ÃfûVÜ}] ÞmcF`91,)ƒËmg& ¬°J/ì¦Iþá^•+ý²±X Ú‡nM^ ƒV♲A[ËQq¸ íÝß-¨B—:²x"¤ìÁÅ?ž=\X_Ïhý–‰_¤þ·Y¥è/§ÁêK³éœð eD ¦†‹y}ÓVöa»1âÃÐÒ¡UVµäâQ[×Á»ˆ\IÀàÞÍ-)}Ž.}ÞõŸŒrªÊõ, ^c0ôê˜ù­Ðo©eQdfîâ×Óõ†˜apWŸú¥ÞÕËž=aZ,Æ¢ oŠ jlÍ’³ŠQcA겤y ÿ|™Ì¿Åf•™E1UyPž¶V a…MOÛó¬Îyô-'á}²S˜ôW¯K ~×~¢Ó-ëOžŸÊºª¦2Km¬ÎbûðÌÃ:^¬.údmd6YJ…5Ê)«ÖΉÐÌL$!«Þ3ß³PôÒœÐT)}ÔHWMF²ôŠñˆakNpˆtZÂ3·îèÚ((B;p¯ùa¦¹C±"Öú^[K£Ìx¾LKÖ=þšT_X¸±×cy¬þD×Q"™r2æÒ›|¢`y’¦LáþAhÒïϽ› íM‡ý‹ ©ª/>~æUQâ©G•í=ÈÔB—Ô‡0ÀÃì1œ{{? ëøx§]® S= …Ò�$A Ê&5bÎWÎR áoICyéÛéÂ]»gÈÊL€Q…£dÜm·Ð¼š)¾"ÛuW׃Eé÷¡ ôAߺµäwkû÷›”@Þ¯°øÞ8N¢5ˆ9KMÜ^=0wòFä¼y&ˆRΈ}e µˆ»KÓ°$›{¼húá`/"¬‰×nÔ©,dÓ©–Ù¯çVÕâ÷ ©úgèØòHéæ’««m@sõ×Hoîñ¤A1lû¾28údÿ,$n …Çãá„,òß¾ýWxñ@j\ñÊâÐ3£CuÝËíYµgðŠón[í;l^ü } ÔOíå©p~†]Ó÷(Ç@`‘oú6§‘/Æ¡¢Š˜2à3dûjÎlÿŸ]¢aT¤ ;Ìv <q_M�í?a\¸‰ff´æf!¹%Gd˜#SøesuÓë’Ū–Ý€¯~ÿ @ƒ¬XʦÆð4ÙÎ^‰ Ä*O1l÷‚ßÔv½«ñ4\ÖyRzø Ê<÷ Š'= 3Íâ¹Íaån¥&3Î;W¯·b¦R4­‚¹Á–˜uó±œø!™ïaó†B›ó7Of39³Ÿï`ã7(rËŽûØoA#¬­‰ ªîaÜ)Üþe®Ÿ¯†"Zî}–2Lב²›CÿÖî(ñ ݶ»~wØbÂuáh©?6@Á.¸ùEø¿8Oýf3TÒx3èô¦Ô`Bo=($§n¿p¬¨€ÐÕ2ž¸RK®,ÚQFÐZS2]$‚—™ž  QÐ9ßfà£iÖ™ÿî:wVŠ'7F‘3 Ï-u,a#ë‘Ygí âÖ<Í»¦SNÉ×ýƉ{#ùßI p´ž7À›Aî¼Ô ÉrsY)Øš{/ýfZøvDïyíÞ¿¼>m1X˜‹ƒi2¨œ ÅQ ÜÌTn•qݱ¼“FÏE\}5¦~C’±Plc{ÈêîŽ~—vMÛ¨=‹í 1øfwéÉ#š®%…›œí_ò¤d¨`^É9|ǵÀ?]Ö=­W1D‘nIVÚCf JP5¸dyØmÛ»‚CT¤Þ·t ®€"…Èn³eÌNi)nF:#wV KÙìöâ;I±°X-¼YÙ˜Önç °;–fùÛ©ç7&À¾nu(Ì^ÚUåÄ°ÅÚ °ª·MéjŽ*úžÒ;6Ý&Ãó}Ì÷õ)ÌaÝSu55…áaÞ™·—±Ý¿¼›ÚÙVº¨±ËÄw-Ú=cÞX+€ÁEjõøƒg©ëxó'ÇVŒ*ç,d*ì#X¬ vvÏcç™þ¶A�÷Ó¾/xòC»SÞð«já…ÇÖaÃmh‚$o‘|¡ÕØ&ܺ:3˜­}ÍÐÅãe…}åéèI4•0<Éå5fTy•AMT®ÀÕŒ±*œ:ô²XZºæ¿z“ìï¿ŠÊ.™í•öÒºò¤Õ×—q×ßøÖ½ôüWu‘ƒFr«Îв9™C¨`:ÅIë幧‚‘3›‡}V¹Qº&kÏÁzùô ÐÕà 'ïÄùG6¡iæfªlª»ÞC†sþr³òºí·`Ë[À¼ vëJ„§‚§¹'å$tÿ‘¢fÑô†¼öÂz¬j“StV-Ù奩{õ£›v¥±ó•cQïáHYJÚ\<tLG§ <'t°B‹Û³»x.  N5­ün± ÑiQ{þËF¸]}h^$§X:\lL£û<ˆŽšç€pœ£\Ð3lê®x‚ÉrE oóIHà¿xHEˆTÚˆ)““Üáû—í,W~¿:£"!,‚È é$CAi°œE_]8ÞZæT�©ÆR°Ê¼÷_®l˜äáæ8mÇ|/@@F}¦…b{#%öuè[ Úü3ö'‚¹@6(‹Ž]ä-( ‹Úœ³ÅÊÈÀ[éÔ[¤†ÙH£•oûDgÈîH+mfWõô=EA¬˜%=Hþò[ºGÛî‰\~‘.&ÉlµsůÙÜ(¶åÂi{mKøLö7YHO‚r»Ïƒò8ù†¯†lì -ëш+yW­çõ-ÙV¯h#?-D,RFЄîIDVɈëc¾�VõFQãWœ/;ªøŽ™yû¸ÂÏ΄±Ü·Žó¶ãÔnXÂß•¢mæpçIPÓ‡,Ž¶ÌNÄ|áÿ(·Ì}Ò%îo‡fÌ`ûíùáÿ‘­ vbä.ĽìJëù¹‰\ºïqv£güäÍÈõÜÜW—ªŸž´ßí"3D-¬ð®ß{çåÇ<–¦š¸sÑ´ýâõzîP¦>§„Ý 0ؘZ_€Ð²¦/6òȇׄ`©�qÿ>8uóþp~ãEJÏé£eáûzßÇ<õ›;ˆv[ìb[°Ð9ˆ®…húž/¦)ñ6æõ%ÂP Î1¿¾‹AZ+V ú;@sèÁ£d@—-î.»‡Lü1eWS¥>%b è½‡™ÒqyåQø\oŠC½¯!¼É4×ÀÖì.ãÛ|¡l§ÿÙ>y@(4lZR6PB/MÀ΃m_5‹±Ûw†-‰•³ u®jýÊ¢ ‚ÔN •_Ë[õ³S"‹¿*™ˆÞÅAÉ”nÅäݸs>g3¬è†QFöTæ…oâßü¯­Ì~ÞÀèz[Þ”2Y5~»v]ÆÖpv<\bœùúûÐÂØ¿Ÿ½~„²°œ2‚0§úzÌ=51¹ýÇ–Þ÷491=Êp×î\ R /‡ËV*ûÛ_Ò".¬Ù ô»Ö30ק­9–X 6K;h3¾i錗¸¬W>‡ŽBŽl”ð6˜WÍ_GeS•áÁìNЃunùÌíwËq)­F)…·°9yö·Í®bƒµZCs_¼^UžFuàVKŒÕ2A÷;¡½-öÙð™=TN“îÅÍP°V® „„Ð1²ú“ßèÇ5Í…«Ž·ÝÐ@»hWõŽkßóG}¿kh/¹$ #Z18០N–ßU©ÁäaÞ¡`'^òÁCê3sáÞÆÇf6©4c¥¨HŽS“¸f*Ô·Œ$¯²?"ßÀ>f­Ñnàà™?|8ðÑc4°’˜ÔŒÑŽTátªŒ„š{SíÆ…SšZ–˜èÿp/\d±“ÛKvŠÞ~U{óæN[øDú³åaîw'i\Ä©ó½‹ã Ù^åCÇžµ?}Ñ<råëfcþ|H ›Øz­ðšÊ÷é ’ãj“v¡ÀùŠ,w¹ZHÞ' |¯8Z˜<…«ùa¶;ìŠéýì§k’°ádE J‰ Uödä‹È£p$XYêDžÙÞK‰Â•C½@+‘õ´òϽçwŒ4eÇ©5 H°ðlÅwä'æÊa˜§¾dFÌpGOš£V9ž(ê]_ˆn„Š[è•~òÔZ£v™§Þ؉Þh}(ƒÐŠ ¡]üAEêîo«ªºT 7¯¥«ó ê}[\å,±”ÚŠ2Òþè:Æõ1Û“ˆù‰,[¹òé~ Þ´t”ÃÝ´…²•1f}s®~žMãÝgÆXÊON‘ªä‰V,FtGJf¶£'>ÖìÐ*@ú¢­LJ¬¹#eöãj9*rwú3éo /®:E)Üžq™Z<Œl…×'–üT¸6þºÇ©²[X°¯?ZÓ˺[ XS÷Òt>8ó™FOíjËÍ<—M¿˜üXÛ'á¦SYß~Al®ÔzaýÊn.–ÈÇf½ùùŽÛu–ÆE”ZBr(–1I5x$t'£°¦G# wçój2 £Ô³u‡šeKñ7ë47Ä †iÄjCÜ4 4zi<â-#!ÝTßXµÙŒ•ÆÛg]¨×…/ôÜ4öb c£h7ÑYÒv^‚EuÅàîÄ‚—>c_QL`È#ûN ë mrÝ ½—Aè=!˜8i½zdŽ¢JÖ­ú¡2(?—έ#îÞí/3vKá+  ð “}uÈw ¢xì©ô<võ É<¨´™ÅÉ©oé€Y vC§CÙ ³uãÏmí‘Ç›CkŽ†Wâ`1ŽGg¤³lKŒœâü «2Ë°d"Z:ŒÍš:I’ø&^|òøÕÀÝnL|` óD×TÎõ§®U¾œ ó艢Ùm67¯áÂR‘»‡¯$ˆ,kŸ ¢é€Ù+ªèfï ºùÃŽ‘$Ê øüë…:Nâ†v#xsŠŠ’9ß�Ô¬wŸE M¤qÆ/ë–‹¨0joÎŽn/œ¦mîºG9òƒ:/ƒÜŽË›jÏ5eTßt1ݺ¹ÚËäöâFKÑ÷ÍY‹ÔÙ°>š2Ó멃4º5ž¥5Á­�gà(ߎ›í’dn¶ÃJ$`®ªÖF¦Œ ßY™-MW½¢YŸ:ÕÄ’k°¼Ø¥ ¶“1_š´ƒð†M›ãx <ÃÝq¯²2H˜Æó¨£c7½>P»ýÄ7Ðù’*‹øÈZƒϲoT¨±Ý>Lú»z]¸Ó”+ÉQ:T³ãì0ñ<Y©ÎÀê½ -Ïxû»-Qä MK”…‰²qv~uYUš¤NgqY.xë •ͨ> "54°FkØ"…G„Ki±EEî£EJiÇ1ï{C—óï]¿¹T»Â‘SQy¬Éƒ)P0P–«™ü¾Æ°0@ÐÊÛ·EP6_že%38(YÎßvǹ8:Üå¾eùsó²½+ž©¡jÐá*¨¿Õ°«ü±TÝd_w»ûÖUÏ ›aâÀ°lÀIç%Ò½g@€ë„#G|`üóåûÃ&òäÐÁ jª, ‹˜OòÂ(ÆÙ?°>lÄK‘ÒÓyi3ö“´Woöl©ç܈Îõž>{ìœÏB°:¥ŒôW«ËÄŒø1¸ '¾(6”;7š½6­Ë1‚,— é7zâüîñ1®ÙIáÂ,û pk+ªU« vª‚±Ú±¼Á°›jÙ£¯µ´¢ìj3´´MËöâô‘,ò”ÄÀƒ„…jÊ£{?=(–0«w5_Ħ•ú[m¶ÆÒò°xb~;AöÞïÆq&;:ZcÁ2+ÕlBÝþÝÔ« æžê°êèy[1 ánuXô’~NÞuêzlÇõ•­Œÿ6f⯓Ã#ïô‹ñçz~Ô–Ä‹ýõ±;öŽG„ºo'Áf_Õ}kt‡8þ?@&;«i‘g…3 WGÏ@ ÷]ßNŽ’a|Y®^-ÊÐSÆ-¸1¡ëñ>[>>œ*ë"ø‚ Y†~Ñ@sìÌ™ñè§1:¯ÊêAù#îê,aU¾©â ïí5Ä€ÅpÍýì¾ÙW £Òß•€·´uâcãyep#u8;ÏàÙ ÇÔ])ËÔš'ÆɯêéƒnE‚ÆÓÌ>¾ ð(žVÙÂ~b“)¹º)B“ì,ä,9 òj³<þ4a똒ÂÚî;ÃÀpY;ûÐ?p‡ £˜•UºŽ8Åš }l;„šiRÕÛ ¥#ׄâùâñ@9îíp¸4 ¾¾µâ¤õÚ‡oc»ÝMËîL]£ØKYµ;RrV”=0—Qâ^ÉÑ•¢[ȸYç Ãô}½Å…8Jrl”´)óÊ©`óí„JeÆæâlL†ð�Ê7ò8¡¿¡¹#»ž)ëÚÍp“þ’ÅËþH¹�—˜¨Òèn׬År-ÀGÃR5–>`gkàÔÊ€sÇÆŒ ³Ø2øDç·ž(:Dý§§š‚Jõ׌'ñgŒ›~EIö”¤Í^WINŸî|“[€µ ß 0¿™Òƒƒ{¾þ‘J²fw\¸¼[”maðVCK«~UŸÍ®å Ç¹ãÉ Ò»¸¾»O;}Öu\ýO5®ŒJlVã,H.Ö^µø…ç¹Q&< Vx·‡îƒ'H{r}û{_"1–Û}ç|«ðHB'G¦7pEéÀ8v ¢>¡ë:kIU¦TÖF\˜ñT@+©Þ @ïËi.lo›ÝüÞcpæêÄÎ æÕ4Í}ÝØ‹€%CY¦(f ù+ Ù Ï<Uf•ÒãO5œLqÀ€¿§þÿî+{«ìŸ¹ú_ â¶åJïYS’˜}ö^ 'J[žŽæϵA“ÈÕ1¢Ì¸1Eܨ¸³(dšhF ÒS#•$÷qª[W,ç3 5•F†~ÄÛž6®Oº±?¿â‡ž-CPèõÂ׳ ²O‹†Çù¦èmvp@þÖ9Ñ£9Ï¥Ó¤¥PÙ%dºËø�ý_Ÿ¦‹VÝîùœÓªï ð�e(G«U‚Œôj(k¦ž6ÇŠ«×BYü‹ÞÔºBœ„ª&’5~0ÕÔ<éÏßð|3¯s(-€õ#Ç¿^cµŽ7¸RÌDU%zÿ‡ÞÂ*Ü¥í¶Ä©ï�…¹QGícÂÍB– þÐ$òÀy,Ø„pÓ;v@»©òâ¤ë7ZY쟅´DzL’i²VLþ8 ʶ}AyÏQ‰Rn’$@œÀ SÙ|qè`&V©£Ú3ìI”ªÜVaÖ÷<ÐÛ&Ÿïú¶Ð–:‰óŠ°'ÅBž¹u÷5t3§É$éb Ñð|TÚÅþp¦rÿòÏ›õôP(Ì¢áÉŽ^|&£lIv‹™Ù]+OÚxo[Í/’º£,\ÐðéK”ôfG ø˜Èº®µ-üoˆßïX‚Ñ^Üкݙ…%h°^EwòH@bìc_í&;þûoˆ¯Ú¢–>h¬ Ä,f€¾µä@úî°2žð3¢¥”ÏE}jSÚ¾†4bN> ~®<Óü%$+ZÚôÀ™ÔËwÕª"ÒznôÒý¯Ž§â¯K“%ûì,¾ç7^ÝaûÊ“[€Öa½õ"—ö­>Mê] lN ©>ù«>²é‹}‹Ôyûá‹b}QiZ²† å"VöCïûón†¬:ß½'fÁqtÕüÞ\è“[öhlÔ…–Uï=qh_&ZD—Uj•Qe] ›yfZÜvœ‡Óö’A¥X”‡6wuíPîW•záFbQ-•Í—öá‡QÅ‹ýTJ%Ž£¥‚Æ°“ ?iö2Lÿæt`WRŸêÅswZ~J Ôv{ð ÕC6¯™:¡ €'6LWúhóƒU2Ç ?>ÛÂ?ÿ¥»ÚêX¸1«¡·`lb‰ˆñ4 n6»ÒR ½ Þ¬o7µASKhe«–d« ?Ñó¿FúSž´›î“Kïœ`IîqËâµµÇèl7쬓Î]dÍ+(›8µàTÄÁ Á¶¬;íÇ<¬ÜJ?ݱ ^ ²NA;W Ú! ò÷‹×ðüä"Uœq‘¡ucÆ}Ñk©g…ÊøÍzÈ)„ž<7#¨Í0ïÞÈ•É�ûvŒía¾Dk %tWÅXÛ)ŒŒÕ+÷·Þaê›RGŒâ¤›=^¼x‹5ÇšuNr‡ƒ*®¼nƒ‘RŽ¦Kõd ¨DUˆZœ×ìØÄgà|’ÊÂöl¤U»ñ`ŒwipÓN‰. öÐä<içY{úBõEÿï褥7üæIìqL‚”ê>¥˜—d¨§aW;Ëøpî£Æ¤‚¯­Uê’5+ñÚÔ¡+}Œ¾+³¯“ hµ“cå:ÑÓg:×ÊÙžvNVûþ ;;ϲ¥�=$¾¢Q…«�໘õeÁ¿øÂ~ ]Èa¿ô5zéBNR<gѸ³Ks:°,ú«ÉÖÚŒ}€œ¶(&o–÷8Áî[Íøß~§8_ƒôŽð¸ÖÂÊÛµq¾D})çŒÇ’ʱóúâÞû‡Åºõ;Тâ3ð€hš¸š„Yè»ç% Ǩñ{óMÓþÒ·¾õˆô¼åY¹b¸â5n ÔUhûMôÿÐF‹ ´Niü¾¥esñzÜü…ì;_N}#òÜz8½åÄ„ð5òèxþëšT¾IÈ>c: Œˆ æn7–YäµS3¾A¬4üyò&ÃA§Ë¯I GY–úâШ¤ÏZ)‡8½¶:{Ý10ŒWQ in¾ÓF'B*¹{ƒðâY/"¢ñgˆ‚¥…šÊüÀ@ƒ=™¹ûF¿%ü_¸ò4Řî;néÏ'Íä=£èq¦ÀzÓVâãf/„×jêpõ#óÝü¤ŽîÝt²¡WW¢cõâ-0Çø€%`…õx³R¸â±i÷Ê`l÷Ø–…¥9IçKÐQ³íH¯Î#_ÀG%«Ì,Ü(ÎYnT‡ª·K«/V¦ìK(*ö{s@4'—€½póéK7”³«ö»ìÉPB,¡´fg«ÉïÔ²Cg eéå½4@³èÀ*I¶ÿ;µÿE…ÌÞ"Œ*qº'ª©^™¥Ñö ¤ÌSOþ”Ÿ?tK¬#qƽ;‘ò.xE°1]¤êI°Ï‚⨵bÁSRZTo¬¿n)¶®^èÂ&«¥ÉÓt.ƒ•UÉÏ’:` 2Oâó;¹»°\ÚΔ֤AÞÙšVÚoŠ´)]<ûÉߦ+FPÆBO/afLÈŸX;iTóíÅ'bOæzøFÜ9¦4…¢@ÊQÀLâsLï&pJ–ïúl«g¥á‚©ãÔö£qôš ”œU`¼TÂU=‚õÛr­á_ª¶‚®è,§ô­i=Ê‘~¨xcgº"¼ó�µã£ò ê¶:±üó!Ua2Òsr˜2ô-`Õz–D˜ô8ì*¾w7Rêeú<h!–“/Óµ/Àrb¯-¿Éƒå[B"«GŸ8†*§*ü£.ƒÅü3Ÿ @�cûpû‹‡–a¨Ñ\æË-‚øÝ6u"VO 9£î©'>ÑQô"ã/†!*)+|÷ð¹"…lÞ~7ºü’C–“ÐZüx'<:¦[høêÝ$¢¡ó´ÛìsÏS,‰õÁ�¨¨Ü–s} ¥=}ŽáÎ`?öñµì[2Ÿé _ž_hµ¯ÖJe;\FÿŒ”>3QòsÞ÷´N=5"ö;ôûz<Iëï$æ]H Ÿîæâ~- Z6…0£[E8QŨ}sè;ù$S†·­ë¼ÄŽ¾Õ -·Ør°¬§êÈ6 œx©Ý+zêQ¬WV%Þò#¡÷;èC¡CD1pÃè�Þ\%«…4Iôb•;‚@:ڇʦ ÏÆ@…éá Ö‹’s¦ÑeÖ´™âÿnXHzЃ? ¹ÍwåeFKBSºN-4ŽxPµGÕYf"ò|Gdê4UY³¶†Öç½è“í†Ã9 € TQG[êßÇ)—?aíç‹æ{Ôe”–yã–ŸwÍ ü¥é¾o»•ö‰*ç§=²´hÖÂÀœRËä8'9¨¥ “e£F `F¦ î§ÊˆŸ ¤Ÿè/ é"<牤¬b̪ixîIU)Á{Ýa-Í:Ê©ÈøCYQ•hWh˜ŸwãX]ið8¨\l<«zÊc#[H˜…)Óß ´ÔÿTôw@B]!.b' |&›ùÕ%c™úŠ–h{öll¦“㥹1Ëõ•õM,ÃÌ2Â4çN%.âårvÊÕt¡›ŸÇ>Þ7Ê‘ƒ¤«—óíeþ4ŽûIRº›—»±xiÎMïDdž‰*` ¼›Ü˾‚Ó:'ÌêDßëG/ E0 +‹ãN=ð¢2xeÜê| ĵ2sD±”§+ …j …*„À«Uá‡B……Þ7†L~ Xzü®1¨ã³™·Ø‰¥8í†þ*ôzà"À®¨æê5ey àaõ¨mà£l^Œ™ŒyñnÚeš¨ÎUŸ I©Á®hïT´ôñuö;c(¾9õwá8J=v9dû *tÈ“'~áaŽ~:$ŽUÿS° Ø]ïé·fÅ–«ƒKö`ì¯ÉZw¾ˆ¡*‘Øq/q¨ã¶<?N$òÿPR‚MÈ!¹=v 4©¼É‹ðëla †BÞÎc¥†38sƒ#¤Ÿ•¬€`n× òºüsv58|F/²?s´~ŸqiÄXúœ¾ÊnKKÀõ¬Cv uÚH¸RæÿúÇ'Z‰ªcˆå¹ ±Ú<éÒæ4Ö•‘DÇÁÉ¡L’8ózc4²(Vˆ´`VØVÄ™�!­I[èÛà€f¹Ú{„ŽÛßÀUœÃÈÝì4ÄÎáNab¥¶!=Œ5.¨«!Øó„ÿËA¶‰w\2Ö=, ÿêA‚|PTÛÁü N9ê²$uÆY wGmmÂ/Æ »¼m)¾4¯ÿ\'þ®rüÊ›‹ Э±òôé,LYGÿƒù€Þõ…Kú*ëvùìoVBîBAÊн/ª²jë_«€ŽÒ¢éH'‚:Ò~µŒL[¼h0/öð¥ 4v°Æ»ƒb>o!Ÿ¿�†™[Ï"„s¡¿Ù:‹gvÇDV¡Õ ì^®^®ÓØ"ϼ]Îx ŒáFꬸØÝW—+FCªÏ|' æ"Ù¹›ê–’5œ‡ÿ¿ÿ"ÛeÌñJèÖ|±Lý .cG1ß:™‰T†V9Vg€˜×‡ŽÒéÊW9¤8Òc¶Vz.ff�Ìpª¡ù¥¨Sõ‹•, áŒüSÍiØž‰ÞüTד°¾“åï8úƒ‡ñ%lÿò–t.´³VÐT¤¾±°Y‰ÃR ”¨…¸‡p¢¶r¬Gêç’›î¦\ïU Î/Kæ™T’þBÏG5Qï Mdºg«ÁÖ0V�шùDÑÛ¿òñ̲k_Œ ]¯)MõgÛOz½áÿJ¦¯š#3dé%àÑڳ霂jÜZÍÝte¿ºël¾ÚÖ_´,èO„IÎÞ¬w¼xö2’ÑÐ.áw?k–¬È� ¡O¯óÙUÎ_’›Œ"Ó‹{0 ·Ò ãc é¼|z7À&VÖV’‰€# ×Ìž‚ÞeM‡é­WRzYéÖc šõ&.,²ùí–±È@áp'‡¹Â†Ó¸|ñ:¡¤ª‘Ôsç!œjà'ñ€þƒ;¥—¯B3<Þžb¸¤v^y¹>ìÁ°›ØåÀìiÉÛŸ‘ÒÈ7`æ6J7‹2M‘ ƒE0ÿj(í!ïÙ¡«CíaçãfÒ‰Ï?I„¢‡pÆÙ„\²½ó¾yèq·8Ç:Ã6záx€Êrç<vfÊSÂJíÖ?BéG%ÿ‡¥˜Qq:�—æIQ…ÌEÁ­ŸAîËñ³üÇ õd;N]1}hÒ6ûö­ÙÍâã9Ö;~ˆ½]xîô«Â‡IR5ÆJDê'â6€�¸7‚5N9öG‚DB:VÜaÈr\‘G麉>Ð@U…7íÅÑÆ =‹$ÈÚ¦µÉyä5Ó3Ša`Üz¦”¹«<ŽÃAÞjLÔh³›q’M« ÆZ_ Ú.¤ò l #$v—†9‰jýÊÖM“`ï¿*ó,áØO�ÂNƒ°¤å»ÝµŠ ÍÜíÆãÈM3Yï»þCÄýûmÆ©ÏÔ‚´ êýÅÓD`¨anÐZ•è²ÏãáÔ<#îJ‚ ß©"cÖoèÝœÏ=-+Er­ŸV.¬Ýõr qgÂá›åÓ!·áº"…P îئH‚Õ€ êaÏsÛ<ÏV¾ç ±Ý‘N¢Èò”ÀýC3Eª“ÉŒéûSám2žYóòÏÛÖÕˆ®ÙÑÁÜ-Ä×Ö}šHrĹA$ ÊêÓb’SŽ ¸n«T©ÚÉ.ôÎÜ„å³ ÙhDÆ푪gýZo%sŠKxÆ” ƒ¨6~zc¤ö¼:ÚÑê®>UrŽ³kYà+’A7Z¤"Œ‹êç»–h”.F#‘x'Í @oCªuêwJƒzEÔ*NÒEÇ â5iÖÖ”ñ,V#p„ñÐèÄœñ=¢¦ìØÇWá 2c <cÜÇ,ö/Ie:îí/Ñ£ö¸³³[Ÿ”{s#ƒ~1Þ=!Ã?ã¯T°ïìê½ñ,æ¸rö’/Pj£2^ôÌáhñ/å¶'¬˜Ü#›9É4URÇ"ìDÝ"}ŽŠg1c8».#îwÓG‹1†½�@€×áGa¼ZÊ}LUNâI1·¡!u9½Íw*'H Ã¢·ÔÄ烤0*|�=2´ó“Så‰Óí×ô çî‰ÃB:ÿ[Ñü(Yù #Z§CHY·®¡ÔÂÜÏíÐ[öÕ2He¸‹*JãÅô.¡Z•ª Qs(êÔôt'™^›DoùrGŸÕcž¤¨p¶§H¦zಽ¸tm½B2¡ÀLáØ>@¡ÍmÐç–µ´·á.%ô±ÕvÄŠ¿àOåÌ.ϘÙÈš~b8¥…“ZAg°.ƒU6mmtÍŽ°î›œ�%äyv¬8ðàdÊÊÔs[‡4߇ǻÏC eØMðM3&Ž:|d“Aï]*yÂaÀîDËQ¹QQqï_Uœ°Î´‘ñ±˜˜å_¹ãs:Ðý§gs‹ vW¶º¿V†Qîw¨ ß´/<e&šì†\cc¼›E5|Ék‰Ï¨ð|°Å‚þñq°úþéRr‚ž2è*N÷Ö»|€šýAnÊØJt³ÆþiZ™?rwç!TßÛzñªL<c(Ñ7ŸjÎ:cßôýÑú½Ÿè<¿phÂê¾iEÖÆ'2†¬h½kK~j«7Êh™RI¹Ö•µÆwrùRɇ*Ác”}ï©3QZïõ™ºà*ú×DºëŸ›ŠÂõió=â$²;†Û\…%­%ÑôÝH2OµG³ ­ÈdGÙÑS(L.tï@¦ÈæÚ­éJ¦FŠgÉ­~À¤0º.ž«G÷ç!r<eÔGGʼnV~m�¶SœE=j†6÷ÅúlÞ³Èùg.@¹\¡ â%bÀœ¥ƒmˆ¡+ƒV ˜5ؼª–r¥™ü,ûà¼È<tkÒÔ5ƇÖ|ú´Sky,t<He Þ ûôÞ7ìÍV>0ä A)Àç»gB¹ÙyÊ¥?ÓwIÂ2J=K+nøÐþl ðûüåmBÂÛéã­Ÿ›@¡?ê1ä„w€`1Q.äÕ¡Ž@;kT§«Ô�Ò½7 y]Û3SÄ¿Ô«eî]é¬7ê'Û–,`'¾E›§Àºúæ_a|ÜR†½í«ýaÜVÃßú»Ðˆ¡ Áæôk@HzÊ"X*g׎Gé?�"¾6 …gºg¨ÆMvÊ’­ÿmtZmûÇË0þª<|"[6­Œ -’ÃDÑ'W`w¶µÑa5÷±i-¹¹®D‹†þÀÈã“+Æm–Ù&ù3h©¿8ÙF‘œ¦ ¼ó¤ÚP” ^-ežãfŽÃÎIY¯ ¼{1i/×øÞçF^Õ©²?q³µS îÝMvýCÙŸHi5œFàºP 1&XÁG úÐëÑ’¨œ)ÜÖDžïáÖãÒ‹°l2R²9WNÖ ó®Ð3Ë6Ñn ôhmzÊV©s>g‚ÔDghZ‘›Ø ˆ+{ï`Yl¯š ^ÃÁ?fª¶•#°Qn5s5© íÝãòµ34 —b¨¥lYÏV´Œ%P¨Ns)äa<êÊd<™®®wgNÀ¾.žªÈf7NàU0ðU‰¿¢ˆ <4p½«›I=ÊQemó ßœíM óËøÕÙvò/¬]ɼͅ¢ß§%þ§âq`d;MUÊ2´ÜïtW·ä‘ï,‹ngd­¯ò‡~†o,Á¼ZgÇŠ"ú=õå�+ËJÛ…g³ðšÖiô©Ây­¯…ÇHZð’[—-FE혢ˆ?¹yo¡«¡j*Ûv|ÙíÞÊó¤fiÂú¯¬|ßø]là[ï¿…Ndæ ÉÆÎ…ºl‘àl¨´Î/l¨Cíjˆ$î˜lÙ¤ˆjœÓûvø»súŠ/)G;`3Š)î‘gtƒ¬ +¢ž‘K8W0èü±çìå9³Àøm€Gð§i¨Ö«#4Œ¸Ê”¢u¿Û_2iw²ÃÚc› =ÔnëAÿ§ ÏÚL*Õ—½*Š<ð )}3èYŠYŸL/ €¶ñš / 0ìЌT|ãÎP3œ{+a”U™].ؽÐï ÞcŸBïv쩺++;–É«e Éü,l{!hÛ<ó»h‰šgE¦ `û‰Ï­G0l�-P$ÙÌ?1žÈÂôÊ¥øcN‚üSoEʳÞqÞA©ÝÅìÈXº²íq:ì9)k9ar]¢•Ã@?G†yïV(ƒBÎN÷êHOTE¸)ÄšÛ\è kOb¾¯ÎËqº€Â£¶ûößÍ¥oîüâN0SÅE;rÛCœW=sËR°õœc‹�(å,”4ЧåÃÔ¶¤ï_zJ.‘5Àf±çsâX£¨,vž¶[ˆ÷sp¦ŽŒûMæF4·^·`Þ«ïèð±ó*óúPÚF†"ÌÙgÿAÙ^¥ªó!#ëÙuÙh<ŠÛ ½¬ õÑíûô'�54Ñ c0úôíè¡Ï¦#­‰-F=ê>ÌIÏí»ê£õQ±L} ³ãË ªÏ‹Âñ@—ŽÔj˜Ý‹÷Œ@$ƒý(z§AXÛÖZ$À&# a>+ea¦ä}¿ _xmô'P *Oc–p®îìOxz·ÿ!;‰ï´;Rj—åàǶwÀÇT£ãü_v”\ë13sÙ :cá»"b"=öýEÎ C¾( *δP|°Åý±²ˆ:ž’•Þœ¼•>šÕhÓ–oWøjµœÎqo0ê¬ÒÅkçî»Î`Q¦ª†ÁMKO³'ùEMÌDïHÓ7ÃhAvFè‘®uõQ]õÈ+up€ZOó…;0DéÞEvêœe;Èõ{è*;öÍ7ç‰ò<˜Ï!Lk}ÃÚZ#V;|TûJkÑXÄÛ³`¡Èó™®Âñk]^`ÑéSƒ b^nÑ8yê“)¹Ûö©}eÈ`.ø¶oÏ“70´¿7f,÷@éÏñ骇, ?nìCÈð|z y:ôìkˆœtfVü%°¯w4=zs¦®!¥JGÏxŒ.Œ2‡øØÔ‰”ç“ngº²&òØ« §‚0¬*'ï 9ìÃLJö­)xÂL99ËÅ·ð#¦omeGyUŒÕºâDO×ÅmÙñM’æ¾Z³œAß·j’Eljoçœðä>ئÒ2‘dŸàºñ¤î÷ú£Äºšpb<5ΪbèÁ6ô¦¥3Æ 4«Æ 7PÆG©¥ß>fÉjiît®R6Ù0C5ÌïmïNM*Øàž>÷Ÿ£ßJ»F«dåiõ@ ¢¢¯!5ŠŒžE–7œa´ó|yæÃœ9²|f±uß´&óB‰>Ÿ`~¢ ä Fó ÝÑ>öø½¬H‰ ãØ:‚¯ÜN¹)18Ç5’´ÚYì0N¯ú…–?™Aìå�%åJÍr&‚|87N<¶ë_DnD¡ ëó¸>;ãy >ñô|ôËïùí/]¹®3¿ñ0RžUXÄBºl7Ò1glèüK¹E·PòÌGa¿qcyßz¼EÎø¥=*Õá¹Åád²¶ŸØ=úÚ·œì© Ë:½Õ1s©{ž˜˜ÝE1Fžþ…¨aCÊ[ Ãí ­ÕÀ5Ÿì#¼óø2°^¥Æ¬})>Vù‰ßEHêtž¬t·ùh6¯´@ã.TþtIˆ<4É&Á[ÝsŠÓj_¦êfçï· ½Øš0øÚ‡O’W0iN0´TÚOJ«ÑÃÖÖô?áRJ ñ‡ñóD‹^k÷r"|ö<å†ã¬ñ$;¯i‡ká”×átaú zJ<DÆJªò6¤Ì|fv·È½¤kúŸ¬ñÔ}eAdÅçsçfʇð3³_Qsv¶R>Ÿ«<H:=aJe¶ÚAH+Æ!‹Î,—›,Ï•©aºð<¾{Z}{8”4H7” w^-iA[@œAKö: õàu÷x·ÒFKZùhòq±ð&mOifU{uXA?TÜ‚õÕ+¹Ú6VöŸ`=fàðg÷§ú ÑƒE�råÎÊ:C»Û}Ò$µYÂícŸeÚcíÛ,Ó‡±|û"%!v:öMРËax ã5_ôÀ!µb4¹‰œ)=wõDçâØÂùsÂ^=&`Ïf l@|؃Ä=ã˜þB«-]‰}/è¹çAÑŽÞd€^ú]5Ì1vM:I¹dåþƒ€ù¤™ñ/†ÿ^ýNs½ ,~*6^‰Çž¶vqüëÒ}u* ¬G^e”ʼnI`_Ñ&i=žÚ½\²Z-6L Å™ t®=E ôbª¨2ÂdæpОÕ|R 7¤¨ï¹L¸n+ç:@c¢ý‘5MÚ/£ÇÌx„sÐü×»q-¨Îw½¢{èIn2ç|ÛçAzúòd-Øm³XGM[Ûh5ú3í°V5ø‡¾š¡µÇˆ8‰ˆ@£CòØØõˬþáÂí8M¥.güECM¹úñ!ƒ,Êr_– Ü®ðÌÌj'd#·›‰Œ‚ÜYÖÒߘDqîw-i1µ(ì�9f9¤£ªY†óc¦³orWb‰6CAohõŒîùÔ¹½ÁäpÄ›× œ©*8qWŠ¿I„ÝÙ5+ºŠn{eýa};  Ð:Ù‹ýu½Ùâ2õ,<è›LtZDÛVá´»¡¢üÓfÑ �«q¯=ïÒŸü°ðè²J·†V™cq%Aùyq,}rh(ܽ( ÅÉåOHÑmLwk ܳÔT%fSëC¤—w-5@ ¯¾ph¨£ás—„Uä«ÜAy¤AKÍ"]Õè„^4Š[ù,½k×ÐC>µÝ›bíÞ‘&ÁQá'ñ,É#ßâ‚w/ˆwá—f¸hq³¥Q'á#ìÅs­Ð÷ÃH¸|YPgí ÂeË9á¼0Ž-Ÿ$3Ý´ùLÏ©žlÇ ’Ö¡Å’xÂL?ÖhJ£táT¶¢½1‰J ýUú½g»Û¿Òa ÿ‡K&ëJQµ?X¹!ôQN“Bßms»å:"–îÛÆk‚å×’Xl?Ž®ŽC‚˪¬¦…r”Oóšÿt™z-hAÕÐâ;ê&,W2‘ ¬ šoÀ4šÁáz¿òäp!úµ)×xý)…uñúnþ(Õ"iWFµNƒ|:™ ÕµûÝ+(@æÒE~˜óYXN}û ö3BG;ŒMet<01îÝó¼Â™O7c+Dc¬k -ñš×…?l´ò ð&Fã š:÷<»CO –Ï Ì–fdj¤–AÁFY¼{¨3Euµ©'ÊdM‡¦ez¬€cæMy¬„¤¦šº2Ú$žø­eÂ?ý><Bt’àc†ûÃð×4ŠÞ«i•¡¥ëâÁêR(fÍEFøÜÙ ¶ÏÇI/¤?gzݧ6»PÞìöz$5«Cç]ŠÔó•¿n˜&>ÉÖÕyH)›UW?–6š÷D‚óx;ù÷>[–ú"Á¬²SîÔYîL¹ÖkÍ‹6óiBcÆ}ù·¾üK+W@ ?׶ 0AÛc†é槖Å(ÛX9̢͎ýE!ÿÂ',䃾U ¥M; WÆêÐ2 Û†£ÄëÊ¿…GV? æÏè«lÍÉÅidžù†‹Î2ýO#ÒCzüiÙ_ñöwO}¡£dá4†Dtþ¡7Uöu5 ¸6µgx‹9%-„¡¯‡ÿ(ÿ·÷C7\»#<T =Ð}l$¯Fè¾ g¢½áQšÓyA'Ų4¿sÒ²~+) �/(Ÿ¯y¹n'èzü©*a‘¸Š*Cü9o@£x¯¬ŒéJPL(öºÀGì»Q‹Â5Ú Hô˜L…Œ@íŸÞuBÔr™nç&a¸ ×ßßRZÛ¼¿QSxÔÛÐRåô=Ë)Ž.·ÿ£Ç«µ*¬ öN/¶r4ê½�/Þg•Ô‹VIwʃä¼ñ2Œ â�óÆZä,À£ê[¿ûOp1ø…ÌðvÝÍ/…šLÛ�áå‡pÑY²òÌhv'Z퟽78¦;ù5[™#þDÿéËø¨9C ŸWºÃbîÚïP×o·í+ja^©ÍŸ‡©ý!„ÚmÊJ‡®‘.»nžú.¯ÒlpÙ ÓŸV!4Ó€|±”,PÌ[Cs k}ÑEç{¸Ûýáë°ŸÍù4ÈaL‰†iÔ}Å�ÆÝ2f–žG$<¸¡(t1§%ùŽ$\·„n ]�µüŽk¦ •Dö~Oƒ´Q’6z çõí£¶œ¥ø— ‡P}8QljŠ,›3›¨cv¶aˆœHíÜ#záûAG2ÿáÑéÅrögÖÂP¿†mmå‘$è³ÕpƬ">ðuÛ²ÖE…0ó²–\ztxó¿V{ƒ Òâ>«Ýþâ ðÈŸ¿s¤©´®>U¿‰Õ(½²¡ú^íµðڢ̨+ªi†³s3^ªþ¸›U€ž’ j?êJS]ÓOBÀq,‚¨:9¯Mƒå1ì¥V7ZÞc2¡vWwÈÛÑ*÷ €G aÈó%ÓUìrØ«Ò'öÖ"âRírmŃ¯GPVjÏ ¦©þìË]§,óÂ4Þ«×'êÕ*Ã=n)X$‹º¨ØÅòCó®o¥ £iÈõ+ߟ Õ‘ŽŽyëðëÖÈ@£ô®_o{áµP=K¬Øµ”cäÔVªü§Â*ß ¬$y‘¬<4v `ÏWPZ¿Y@ìÓ Ç<Îßþ}£@düìúÙ¾Ì5ÖËd«v±2¾M,ŸV*9‚ˆÊ,SÃõ}]~éRž‚×Y‘•dÃôýc79—èí¡ñ2¼Ñ;W‰ÈʈI7­øz qÚª«Xª,¡˜"íÔ–†nüIÉà¦7²ÉŽ#lb}ÚvÜý5¨b¦‹A¶¬'éëâ*“ÕµVäÍ*?24”Cç¹µø‰…³-¥¾ý¥?œ`ô •Óç¡òN)p¦¦� Í‹b8M‡éº§,×ë¾Åÿšxø×Ô¬°((ºw>*8ÉåcÛ "_Zb¹— ²tMIV~ª^ÞˆRÁ8 Ÿ<©AËëÜjáÊ Îö-3Â×óin›@rÞM5IlÜ•’µWé‚õ ½ûsdöI‡fÉâ¬þ8³XÐ=Xß#Åk‡àDöDhd12Ø`È4uÕÙ¥3¯Þ­5$'XîGO5­öv`„«=¬ÑnîÎôîÁÄYÌ¥©ì¤÷ ±F’0&Ⱦ ÓÙq\Ž~[ÏLÏÕ�Ìé  š0ŠSOÙ›Âé†ëˆ ¨;VVŒÎdd(…ça®é\…e”«Ü ºÖeÐâþëY¯¯}\�þhºDŸÝÏõÐ+ìË <騌2L^8”•æøæc¾Ô|±ž~¡°Š`ÜS ëm|*Ñ*`ƒ ÍÉßyAç$)|¬ Ä~zú§ìÉ™Fòq=ÚÀL‰CôLwIxJÅKÑ`vÔö•ˆç•íDA æ:±úÆ2Éó|Éž:S´l4š©b•(†wû4Ž×I “„8XïiGlk§ÎCMÓìø#˜I½Ù~kî»—VŠ!Ïý~�‰´¸ÂáË)‹¼F‹—ZÛEè °Œ 8ö榿ž^çšv}’aWYV¡]†?\±Iê8y€1ì×à¥* d¬ûcgX[g¥Fk¥Ÿ€Âv®™t˜m9Ó3MŠçE}{xi¶C­FóJ‘\T€eò¡ˆzÌÁy,E‡ØŸ*˜aòàÁ)u¢qÞõ³™ÀÚ+Ì_‹ 0†°ú•WT?qb¦Qé´bÌ ¬ú’ÐÃ@ŽlHå¬dû‚f¡ŠŒM³(h‡8HOG·g Ø"—–ÌJV$½½¶?ºg±WSÎ.‚ïz¯ŠÏ`÷»þðS"õŠ™R±NßÀ… ‘s€¼µKðZµž¬^CBı͂•õŽgíÙÖjLjX.þ§:j‘ŠR¯TBd=&”Ök3 sŸ™þo'Ó“ßïÄξ> ÀE«eKª†#}öÔÒË #øÏ®…}´íeØ5£²0«x0A[×gÕí«v¨NoÛ3CY?áøñfH,µØô¹W(G8ÿy²k¶±¬vä+…Û›dþ*íÏ$eKOtƒFí!e%S^‡–¸¶5“±×ëÕbìŽiR©˜QƒD3ȶßîï ýá©;Õ4±¨è„¢�Î t1&!R…7ü7(¸œ _骳ç$^EC¬ £ |kf…œ ÃU ö´ÅØd‹Nž©;¡JMwEö¹Ñàxª¾ð* Ñ_ ƒrÔ, ]¹®úÛzZISu–Ã@¾A{Ì@wùž‘¡’Ä€CÓó¬²Cj¥#O­œ^‚Ep¨k=E‡VŽ*7zÑç)VÖ)ŠÙ4¯š¹h”ôŒvóÚ(§ÞH;¥ovƒuÛ% ã–èjõR0Y&s ÕÓâçŽÎqá ‚£9³øDzVx¤¯:OæqºTÀnzj]kœ.7÷ë[=ʵª°˜[8- Ä`jª.nòú’»EV¸þ ³Cú‰Þ?·f‘ðÓ6ÍF¹÷ÇÛ嘗GžRžü+«éLØ,š‹×¼ ãfreÏòã>±\ÏB^,T©ùÙJ€CýÕ´:ËØdƹåè­‡—¥+^Ó³HüO‰|” -Ûh‹â”¦ª rQ½†+€Å] …î³™ ùð³ñ¼ö—qVªÝ‚ì·;÷u3Z.Ó>eÊ‘ÜTÐÞÄã!¸¿Í˜èB§yÁC5�nÉïü1èE© %nè®݉›Ý蘕ôWLA[»ˆº í#<í¥†ÕêPDz¿õ»Q]Bø=úêÛÖoH 0w¾K,±;M ã¾Û>Ꟗ±{V­3L“·ñRX“Ûƒ3£•æøë‚í±áaɳREa¯ÌXᡲÉüÎ{½œ6YyEÎŽ”G§¾ÂØ6\}›–ö©?£ÃEú‘¶È9 D†ã­,ÙåO: t”^<øŽ‚fRi×\}ßaªLwJþAÍ:ê“À¼éðó@ˆÁ,d<Hï0›†~³Î¦g:ÅKQ<6 qá ë7`Û b{Ž-ºI�ùrWã™ñbžû&Ÿƒ¡48ž&פC’[[ŠÿÖ$]0+Ôž(¢N½G Á@ÀÎŪ~áæõZI%O¯4Cû>éu9ç?ùø ñÁh«åÿIpÛ/®Ð¼Ru›­–\¶ºÆ¨rÔñjˆ–ý¾õíîÞçæuÑø-ŸJBudŸJ„\”еÕ>¬bÀ º™x¶´·b/ïæÑʳôB©ÙAZ«ZËn8·ÃÒâ"C[~_Ç;»ïÉѦ–?Fƒ,¡r¢ |b£žÓâßþ00b›Ja<£ý窥LŠ:œiÑ+j•ño.:ˆöInœÅ‹Jíü$uÙeëØõH;±k½d›ºÔ[çîÄaµ;ìÞRÖøŒ)",h“з&ÆZ‘+ç¹õ xÛV„FmñÐGÌÍ0¥GÂÐgK¦F3û —$Iý³Ž–„E²úÓ<ÒHçEl¢ù;=J¥¶9J6*,‚ä8{Ì C÷�¦–‡Ò0Ýnºtس‡ê••£rºLk9ÜkÄBõ“Àõ|ÌüøCJ ¼÷_¡qéC˜ë?iÙdVÉŽaÒ´' ‹«·ã®]·üÞ¡Zûˆ”{ö5¬ןò šÍ(CM÷Ëóãƒ߯>ýýËšÒ׿–Æ°õʽ5ö¬—RævSöš Ú׃vRµž=UO(Â;£Ïýˆ&²7 ™iúA_,í•W…6Êš2Õr¢ÛÈ÷YTòèÅ.¾ÇÝ_*®Eé#�9â(Iš£÷íü¶4å o=m$)®ß*IñhÔGfIiéß9xRŽ´OÊ<+!]„‚Ž‰RÂ9­’3Ë [¬·‹Ò4,}ÞB”-ð­Ö9¼Ú/ž·Ä‹£”"ôÑ!È?ò nuÒÃƪ–ѳ–êÕ¥áëšnvðÙ0ÒV)·RCr¤Çù4´%(V/]ªQŠå«]? ¶¢k\zÁ–°£ î·NŸ`9†CÊßpJÚÇ“šÈ?඄šI­ÄÏ'÷INy­cg8lÙÞ2<¶«vý$u’¹x@Ys¬/žwà ´`Ô»…>ü9ŒTÆÆ 6ŸöbÀ«CZà.¾q�V Y}ºEôhél7Nâzhx/þ ¬”FÏvCyÎÙvá…¾ò°õ,+4mѶŸZ;’vØÕêtP¬¤¯ý2“j_i\Y9€Ð¸¤Ó_.¸÷ãƺÐÎP%:K¨â8WM»¸;îi8 ŠõôwÚ/ é¤Ã Äz4˜ò¶çý °ìK'ÖrZç·_ÙbŸÉÑOÒ†ÿñŽ2ØÖ& ÷Å=3‡Ö—ø³=ÑN.û/Grfò‘ÙÍÜg¡J-N©‘˜a„ò”²/Ee g†õ†nš‚zƒÊ ”$Ï0O±)…г‘ßÖÕñ“vAêà_bs[Ãd††KŽR±jX™O•[Xá}|aZÚÂÿO”5·ÚPK€ÃT¹l÷?ªkZXRdbÆl¹1Bkô•.füÔš6IW¾»DX‡/ÚÊÙ—Æÿ2z;¾P/1¡Vtê#m_ßJ:ááÈž–âx´ð;fó·Ýîúo=ÉÑÊSQÇeJ§éhm¾mãÖUf?7Ÿôñ‚8žT¹3býÝ3°Þˆ·IÌgN¡jÕí¸]8f7UÆ9¬ƒðSËtaÑ¢2¥Ø˜6ÑšÅÊ,#œÿ/Â0ƒSÂÀ<æÒPQ¼¥-?ÌÊ‘‰êšâ„Y,׿xÆÝ*ŒÎLĹ@—#ƒW'ûÔY­uý‚iǪól€9^<³-^z‹‚­¢¨²MkVÀœš%¸�ttñƒwW7Ç ¯´‰ù Ž2-Ý^‡,*çGÿÛ‹ù÷»##*=jCʬç/(fö˾ŒŸ\ýÀ}5KRÿ€^F“=úkÔ·›†p¡ÿ¥€§Ï–ú}ÿJóãítË¢ðùÑ·‚µ›Z†Ïë…¿Îß¿E¬‡qšzÍÊohÛ¿†–Ÿ(‚"†ÉΦõiÀùr\\Ê–]ÌcïüŠvrrí'�/¶lT@7‹Q×K#ZZG´¯¥š2ˆäü-olk͆…O{\™ÝËÑ�|çæÂóÝJU›.+=€Ã°tÉ{qä«™p¨€a¤ìeŸjÆ6+Rb«÷Ît‘ÑB昵© ÷ш͞ adŒ2× ¨÷`_ÖÐBe"z “º§m}¹åÀg¦ËS˜SâÀ¹ÕðiJ‚Â#3ÛŒ©ªXíZ¼�q³è-C:.õ óâé¬Qx°¤÷�zZÖrWw0Eîû1Àmó”/-÷þ@ðZ­=þySÜ-­Ax.Q ™ïΕ¾Ã¼)qÒÄ-zÐmÍJÛ@ì`|`Êd¦K3àaPlØ8 ÿBóg' Ì3ðÔcÐz�ŽXNul$ÎUÕ‡°­g餘Wi"MŽŒQQ©¥jñ}g7‡»EDÙ š‘7Á= šŽ²…÷‹'3†j…ΉNµõ t}â籨q¼ KkNdzúŸóÀt ‚÷ÃÅ`áÑÿ’ ôwšÍ)d©,pEyžɤo_ÆR©±úÊ´ë?V x=; Ø‹Û„¯ô¬D„}FZo b`¨ƒ.œoSö²†fœxµl°E“úäîh…[Vm hûÔ:ÒŽ0E5‹RÈ6 Ê£ó.¢‡zêÝBùÖ0Ì’Í-ÎïØÓÇÍëÚî&JF@%ÛötÉ6ÀXQñà¦Uý©;)ŒÕ¯`ÈÈè –óÆ—@¡ÿû’³ë‰Þ‡”½íR”i‡°…>*•Õ <Á²QèÓ}¦ØfÕÓ™Öò6íø¶ŠKý«îõq$ “å@Gú6ñÐ;y.:÷é�=íÍý?!Y‚^ÆÏGo‘uF(ó˜βÚîì$„> XLÁ–’ëo¥þC_@;bQø&££Fϱ-x›óeÚP%ÔçžRËÛD[¨:´á/ô˜G lôaþåà€#áö–´zŽ&ŸAÓlf¡Üe7þYSÞ.ÌPLá"‘Ê+ê',¶ÝõÓFÒÖúëv¬«Æ:y,–aÌn4~5óå^­÷:§USY‡B1y|’ÞŒ‡=+•-BBÌåßÍЮ\Ìëa×Sð¢"j¥«eM¡ng‘'*ûT]Ì~{|CKd\f‡À‚Å eÀäf'\ÄÑQ&F?cÞ§þ¼–òŸcK"ìFXˆÔ©Þ­ƒeÄ„B_®òÒÄÅ1ÑŸ§<(¦O‡"£ÿëÓ¾ÞÙN(¶ñõØ‚î6´jiY>ûÉœ²“™Mñ˜UmÁ«ÌÐ?‰¢ÂõàRä�÷×Ê�p“>ÅxQ°Kbœæq$HÍþ?J€ÒÒÑ´crþC_¤³¹ÜŠ§©t¤[›×Ÿ_†^Å€½gXsÖ“ߨíM¹ ß…»j7¾A¬izC®èt( >n›†—Ruf‹(”“ª‘jز=£Sáy¹T)e\´­¡™UÑ6ª†fuSm!o.n/,kga[I:¸I÷î6 nËZHönðK_@¼^^PÁEëËoË©²à©czV×ôº,Ô“¤O“j|¹ù§¦m¡HØn¦Í”Y¼V*tÂX¶X{¡ ª8ƒ‡I  B?G»+/€4ƒ2P©57‰*Ÿ{­¥’/ðq´pèi¬Ž•GÙW狀Òúì‡"¡í½%f"X—y|ÖžàªÆKe½Àl¦óÁ^Üh~d™/#ÊI"}Ò¸¼á-Å: v¢üü”À}Pæ[*0,x͘ºmé¸7)Ò¨†ò¼„2Ä®@³ôÈG$a½—„m 8;ˆj©A²_áPbËt¦Û"y´*æhcŸ/í›0ÇdJJo"Y?e¦|îÌjØåÁ –²p±w8ÄìeÚ%)= Û¤m)}žÞŠTSa„Û4¸ï+À-…³dcùBe%¢}Ÿ+б3V¦oõCÉ>ŸÚ©(‹JBÅÅ:F¤|¢Òݘ<ÕDÖËèÛ‹5*z­£¿ÁµóÕ|.Ë¥ïoí]öDbiÌÐL,Þù;k£v·_ŠòÞéYÝþCºÂ ½ ØéÏ‹uÞãNÔh‹ÎaBÊë¶Yq’< ~˜~€©ŽWKèõðzjÏW�ƾ…¦‹N¤¾6(5ë4‘pe�=míؘ¬áÏ€<i˜f™IªØS²;QÉ?ÌzÍîÏnÚÙ#ô¿éš”©?²¥G´§=“÷'Ç.9Tž`#7¨nLV# ¬©ÊJ³DJ<)yŸ|AXmð™{%¹¦|}KGúó44ôÛ�\›ÎUt£†®·©k÷Ì–Ì9 GS;{tÐf,©Ú»~0䎔îUÔ]D³"Õ`ÅV¨¿…Їh$ˆ £á,´¢˜ Ÿq«§=VØ+ f¿ËÇ £îB‹_ßÒ°zõþÔÕÚˆ^×@é2¹—W ß :Ù±kiM¹ðõð?ÀÍÁµÚb´‘Œ¸“nrª~ïí0\ÞjÃPRwZG“]iæêöäÊÓV"§*„bLÑÌü8 }#;QFƒ·ë\†ÿKb/+äÖϨú¤z÷€$ }FU² ƒŠÑ.f0q×b‚>M_½ãˆû›-ç9ô ;¶7ï{A'4^ûèœØ­áÃy¤åÖBÒëèÞÑ_<¢é¢2«•ÿ—B~më™·"Œ 3z›ñÐ0¶Ã^;› „ØКò”¾w\µ>Ê2eí%ì>6ÐΑæ¹íLZ´ÝOm óÕðôðEq*µÌ÷0MåìU+N3ø°ÍõtÙËÈWáH·Í`«`mìŽqÊ5ã!:óg×ÛóH–££ÛIR¸ o iÍNŒ»#­Y¢éçó«%¹Õ")r:íi3ÄuãõH(ô T™Ý±wû©¾ØןŸùqš…–Ë$€Ê0bÛÿÊE÷„W×nj_ÆŽ %\˜'x´àú¿.�S9N>v~7b4ÔJÉ —÷Ò»0Ì]\™ÙÜ¢²µLKÌ}ͬR±ß»‰bVg_ÒŒC5 sS|tML¥±RÞ˜7Œ‡éØ®,„ ð»SÓX;êÇ:wt×3ÛR`b6Û'–¨&-ܤL_úxAËK¨ç ­ñÊõô¤¤ (g“ çíÈÊV˜ˆMG!_Ýñíóh‚bÆÌ‘¸öÚH•Gíz¢”*Ø:5Â$ë:Bdºxã�* w}k“DvØrLõΗð–8î)\ñØì8–ÁêÓ÷Ò[¸Æ?Uz ÿ¥™Õ_EÑ9R‰Ú‰‚UË5¨¥\™ékÊúO»µ$ø¶ocÅ|d\UJRV´ƒïß �ʵJEÅúCº$Ó µe$È¢EW ÄÉ4XÕ•ë`ìÞTæY\{IX/ëľ, #ËÛP*C©ýçÑ„Mt9¦#«­ù´ôIÐrÆ*ì×ÉLì˼ÄìëS#ëœ*Yþ°M¦Tµr]9} Dìë+»•3_„`þMÑñ­÷ `×ýFÅÑe¬hÞ¥¬Ô¡¹sá‹ŒZÚp>Ù~*§?ä–Å~7פbÍ`òï]Èp.XyTzÛÄó›ÃrÒöŸ«ùyƒHÓ2&ý5!ÒÔËcSf& Ï_ÝQSµ?L÷ Yû˜>¶4Æm¤§wFÙöœ¦ó©« LkþE@ÒäÜg¾ aTøÂÙTˆRŠûV;¹@¾z8µò— *wù·iÿí«ÿN´1nóƒœ#ñלÙÎCœÓÊ:zu±Èá0…RG?è1dª^¬Å Þ+žoj¶–ùR#e*#Þá40–äã´ÈŠÈ,*‚áLu³5H±mge7¦‹¶¯.~Ïçá¥H=‡••/0wé˃­Ðä9,ÈIe› ¯—ø10MR«˜ÊGá4å ¢líFË<”šžRÏðþ{.éÊw@ÿÎtœév¬UŸ&8(NÂT¡Ój~kB†L4 €îL«ÿ÷öÒKÿîwãBÏŒ*3"ëÏk¨<ˆ&ÆJ€úçÖ^Ì™U›çó¸ÊI ¯ãǽ…!„AöÅü :1M+îŸ7%(ÓB9îªá`jÌïfë^)ŽÐP åD)~tª^tvÒ]×f…œ\._–¶¥7±™ðßPÍ:Øwe+;(ªÊ§äB ×la;w`í⤧<yéi{âÎ3¿*«jƒúŒQºÊÌÖ<Ý€ø/Q¬¬W'ß(i8'¶çäX}Ù¾ÇrÅ?.D±«Rĵl̃UÛy]Oá­L2…[÷©¼ô»òÐŽ„¼èfO÷³H*/Íwèñ¤,|&ŒU:hNG‡ÙÛm;è„öÚÝ统u1g~1¸âÞ�¡G ƒ`4ÏÜ´´¬äÅVp韭|<˜¹-­ÛlÒ]³†ÄnÛQX<, _¼§ à™Òsy×Ì1ûúXÚÇ®¬JܺUl”ÙºFß•Ò·F±L_íÕgí:‘õ ³ØÊ£h:j/è`Þ-¬bT^²™ðø¤¥PëÓËÑKk™J.° î1LÂL0ü‰ï+0ÅÜTXãVVJðc7Ï;øNkÕAUs¬‡yPwJweIRªrM7dw̃ô]ug€ß¦÷;ú4šöŸYR§÷[ w’”‰.3¶I¶t¤¥Ý—ÝnHŸ)ÉÓ†™@§ÿÝ ÿRâᣩ¿²wFK¡Ã(‹¾&°~«Îv!BOù‚UêƒÝÁ ÿG˜Ÿös¼Ñà8íÅ›ú³ÙN œ*ôú%”DKú˜ï¬7iÒ᯲O–²Ü_ÐsgPsX&’¼o) ¿]»k= :4têݼúŽ‚!Þ žô᧭§¹F_[(žäæÇ« öÌ»ÀòƒÂÜŒ©×èFå³nlœïO½(Ÿ˜ñ(ƒaïCb“ÐLB£h3ÑÿŸ}ö\£EüÌ)u蜄ÍùWˆôKl¨X¢“™ÆÔ­s 0V¢b¡-Äg¬é¶__º 6öµ„¸r]XˆIfCP M-a»êÌá‡L´¶ØOunA¬yȼoi†oì7ÉmýžRƒèKä:ãž6žíàóûÒ²rDzöªf 3WV|Ç14H¶V3· xÅmJO†Ú·ÎüæÉpèç”KPõÐùVkÐl£3C éÎâ Á)æ~Ç×-X}OÒBO9L%¤ é¨|î*³÷zMì{Uîá ;lM3fúHƒüÓ’‡ƒ ˜l_äÇÞÓåBî€ÍŒAûûÔ}*ý9ZˆbSÂOûÉm WN­^t±¦ºƒ“µh5å^Wõn¾ð‹¯ãb”à˨ª ƒt39 SOI!¥ø7P±¢™ß¹lDižzCö,ÌŠÉ! §Ü¸6 ›·‹v1_ÃWXg>Áÿ ?“_^[s4ó !ÅžéžµÖµ•ç3Ƕúð®Íë,_ ðçBh´WùxôÖ´ bmÕÇV“gùßï)¿Â¥Rù…•(çmiϳÊ…çùpøÒ‘xÏ,y­ùobšÅñK.ƒã¡ ²îÓ ÍizÔ(BàM¶áßmÖN/š‘>¯ŸE×5Ä­ÏHlj"ÕÛ/&ÙÓ¦§|ÿÃR>�§¤—…WN”Ñ–¯´ÙôõáííplÇjÝOUNNT9V̵0›'ÉP˜g¾š#Õøý@‹«:{‡ÖæÔï]•oºª×¯ÎÌ!]yÚà5\ÁN''&Ô ‘o-®_´´-üuB)Ç~?ù°õŒ°ù‡“ò?”°ÏN’BÊ‘[Í9Ì®n6]]Õª¬ˆ³=G³ã®×j×Ý™ní͇'/¹AK…DM¥§¬˜l7‡Ã¼œQ¼Â0ÍÒ…yaÌø1tÊ:§Ì3Z³'Q¬PN·ÛÐ2ñ­D®"®­,ÅuJñ§ÂÞBSÓà†,Ûæ¶öõ›àìü åXPmI™Ç¤¥EÎjùÅ”)Š˜ÝS4i1&ápê.u¦;Kj0àVgAxiTb¨Ôq ï†Üº6Š±ˆ ûÃ9`Y£+ñâbá©® ݉ëA†¥Cüw7´NËa™´í©zàrø%úS’øZ˜ pO”JfÇÆ#6Ð<ÁGc4©êö´ÓQóâúGFk™§"Æ�” &-”9áEÙE‡Mh7Lñ{5#,ÂÌõ(}ÐMü2÷òÙÝôm v¦ÓPÅ~¦7º:ÁBß|©Dž0„Ä*pÁ#ͼºÃ…¿ì+T=à ‹‡t¾+“ômP¥³ø–ó�Ï«¦h÷/™"ë'sT ¾â2HF…8ñœËAŽ}«Ø‹O¨{vj_w;:ÊÆo‡y XÕ8‚©Q9re¶DsßVðŽ7t?Ey¹Ÿc¥ÉÓ†áGÄVÓ†ý»Ú^1T‹îö“–Nl±¥eŽ´ƒ³¾ò%$Ûõ®¿Ò‚§§ÉŒnÓ­îjmYÐäÊH²Ìm©¨:{y•—±øÀd/<4¸£4„úE›ô]¡p Åâ¶UÚy¬.ÒW˜æ ­o±7À(ªLÙ©°w°P»¿¦¿Ÿ>q‰‘Ýм8yrP ¼C»“ë,|§ꌟJõm†iØk&M_gÏ{Ôwä¿{2#vµ ~¥Î]¹šë‰rö¥³j6foÿ‚äL”rìz/]’‘`”^Ù ž+h’Ÿ<(±ùŸ¸†X?=ÆÐ_ÁéG0,$;:ããm`ñî‚É®½é((Zd÷ÏÛº±À̶Y—àåÿß ®äÙS •÷$È[DA:U¢0nž{3€†R;<è,úVœR‚ƒÂì¨H têX e¦#ÏÒÛ™9{Ò¦zŽ˜Î’æ; €w)­å"0)g- eYpÐqt_^Ïó-Dÿ88H»ÊQk}Óµ?;h™ZH+Èa_mêŸdžÚ †&C_Vf=‡Ä¨gµjP˜;Üñ}k¿ê�.‰qtì[vBQðJszºl s¶žw’|0ŒÊCz,p¡¤ÀâJ;:ü„0{«”¦¾s ¬ð,·ŠÊðèP}øh†zdõ0ÞÝÎ,Ò»Ù°Çîeá…õ†ÎŸ¬í-eŠÍÁÎVÚ~{ RÚuS0vôXÒ¸àd‡fô½_QœW‰æ’çe0¢¯¼úì¼-ÑU½Ñ¸0µ EÆ-=ëôöDŒ@Ö”UR,1ˆËƒ¨iÝfñ~ŸŒßÂÌóÿÉØõaÈ‚Â `!„P˜uã&Èç_>T«AO~‹t \Ôëª,ÎíÔA\twG$¯ïv*€2{ª¾ö§Áâ�6†tç]™ À-j|1+ÏØó9âÑyó¹È¢Ñ t¥UýÈí&‰|búäôñ)ÆÚT“Ó“RìX["™9`ä3êkH«Ð•×rÃÙܼx½l-ÄF»<Z›‡¾šCÆ™P± +M;ý|B¬@ïVê³3RÏÃéÖÄóe\\-&þ!Ô¾µ)! á‰Ø2É‹(Ïl—ºTù¯7”"�üZkeÐ;Úa0'ÚÝ—±ÝT»žõsº—7£Óš|e´>¢jãÓ7ì)°cÎÏ_#REÞá™ø<•A6L.¼3”\Ç"sWñ˜yIè|.ž0*¤%³ža¤Ò; <•>Õr¿J½-XcOS+c|jœ«J«á–ÇXY—1ùáÅEE¡Áxw'x™=®Óv¬6žôäcpØÎ+Vìm?ÅyP̳ÍßáªÝW» »û6µ²*åã_7fîÿ–Je ñ™:l`3©µ š}tL‰Ú‚ɽž@Ñ<LZœZ¯'Y®SFûáÓ7É£õiÎ[@ZÂááÎÕiQì™=Ê ­B¯iÐ-ßp¢CBÇ[ûöp”ô†¾ KÊ~§Kɳ%!ov‚µ½zK|3œgÔvWä¸lKÜéSdiêèÜŽóHc7“ÝÅL›ûŠž÷C×Î$õAÏP3ê voí_øéÑóÖ3„B›ß <Ö©²¦¹a©8š?ЖµÇwb|åÁósNEf.ÄrÚ舆×3Ç4u2<la7µèYÎ:3*3µ¸Çö>ô‹­ßV²P%î,пÎç‹õ®‡ƒÃ\mѯ™l­ü½ðuºò‘q.Œ0¦wÏŠn¹±ùУ‘–T?=µcUĹXÂÓ‚ïÛ$È6GÏJöVXí«çW~X]ϧlÄç§ Z3©Oå‹»TUnf$õdpÉ:®x[èÞêâý\)ψ›È‘™Â˜ñ»5ªÁâ¤*e>Œ»êg.H™7əѦàùŸ=»]6c5¶Ü(õ…ÇÖAmL×r•Á¶…l„­„nHˆõÉÜ{ÍG¬E°ék°7¢íé¦<œ]*ÎÜÁ|x fÜÄ…G`†÷À¹˜JË]Ýp¢ë3kÝEA\Ï^)M…vt½Äƒô»V‡IâÎn ×…™²³Æ·iàa5ú/ýkä†Ü¥TùZë'‘w¯Y©j}(ƒ¸=YÁ>‘™NZÍz_dÌܵɤ¨þaµzöÎ$`aJ~À)œ)©*ÛÅ-Ï-Õðwßqà‰P§ž–¦éÛ8 VtzŽ$f!ZnÛ `®q*ñ(О<¡o9ÁÝæ®I¨h¶N©´ùl+aÁjy•âbg ‘¹Iݖֽ͠±îë sÞÃ豜ˆÌ39™8É}N À'”lÃÙKÏQÛôü„ñnàf7¸³ÔÊÑÐ.‚c‹¹ÜðîÕ˜C{^$KÈï0í/Ãðøs®Ò½¹%G^ï"ãùÔgµB’o£Rnaf‡Ë˜,XAnP°««‹¾<†gš£Û äýìÁÖ%¯çƒZã¾!=¿lcÙîž j3Zàžl‡Ã$òݲào/ -õ…“€B›â,;-A‹D è}ËûÒ;ý]ÎìöEhšëÓeÌ`³PÍ°š¾ÊÎô§ï\-D³bå¡ç†Y_7¡¬Z¯BWË«7Q€4¤HõÁÂw•>¾^Ü£”9|5ƒÂ&Ê“ÏÑŠ[DL ”G.1þåí’Ãw¿Èc© ñ+a{-í±¼ÝxêÉçñð…BÌLQÁ!™]êð8¹Á2:…(µ!±Q/84 +�ÙÜ´á1ü.Uø"7‹XOôåS¥Ü=z„T\ VCbÇE•BM-&yú›ÛÎ_¡‘£&mȉ2ŒYÙÌ�ÅŒÊ`Ö°-q{p—7¢°åÊW•¢OÜÌônG =Œ<\èãMjÙ ®6ŒÒ{HÝÜ[Ñ¢r¤•Q¸-Z/S4Š-<š~ôjË-FĽ m͸ÑЛ¤&[¬!Xn‡¬«sï]¶ç‘Em·}µ§oT9GèEë}Iú´Åò¥f<Ý6£é9�Я*Iì×¹èþ[ $Ñ’åWP~°©Âöäú’’:¾Šv ÿåžðn‚Åz_iµõ„w?Ox4F£ƒÒ·†ÝÉ'?÷dU«z ŒbTxŠ1LKOØ>%x• î‚ÿãÕÈ()ÓÕÒ&|(‚•µäJÙTŒþ¬åû†Ó‚ˆ2Ú_$é,‡ýŽ—X9ÿzÁŽ®a<7)ÅKD·wÌ…0¥õ«½ŸP ‘V© G$ÎVå&LJ„Íö Í}“ê/¬T?X•µo‰Œ7J}ê&ðÌxþkUÆÚžiËœŸ¨& ·—ñ×€Mål„ ×çÎJSy³¸#³su÷¿V¨yy† ˜fhqÕ:ƒËÐ :ñ8WP ôßO¬oh^Í>òŠ0+Ðk 0IåµÍ³q -kd/–±®…ŠZúÈÙÑ¢v¸€1õµ&ÀÍîËê‰sº¸Ã=¹´æ¾\mŒ¼´]E¥Öy$VM6elïi|;T0‘Øï5:þ'©ò¬H=í^ôÍÎQ¼ÚsÎ4Ïפª+§,”š÷4PíNŒ¿A3Г˜^’±¦#YÒJ©Ç¬ã‚õ%É£05bÚáÊ ‡Ú/:�;U. µcsl‡aºô*˜Š3˜øÒxû²÷Šk*ÙbëÖ ¼?Â[D¢<�¼ãj_l[_nø³Ý‰ua­EÌZ\X}KEG((÷í/Ç¡³·ۄÆexñë’Ëp±T_ïô¹ê=}T* ›&óqV£ guBA„¤Txöi'‚KÃlófÇѯ+dá½Uóî)ƒ)x[K¼€Hò•¯­K‡Þ¹‰€ãür“€°`×b•¹’ýš×gáUì�+¯ ´NŸ®$Qåp9ÆÓÔ±ëyå‡ûJ×Î<D[nJûUéçìMžÕKÉÎȾ„TuÇ“ÅQªÔænæþtcWêŠÅö„׻ʌ;ŽUÓ`sðó´m¢G¬µ¨ÈýÎЖ`Vî~ÓÖ¥»0ì´'ú:¦¼X€òdæ¶Öþ$æþ6Ôʤ@Ðúóµ_Vlq™zJI@õ´Õ‰_ƒK褞jMc ·ªX"éú•Ÿñ }<Eý…é•ÁpßÃhèÔyÒN‘&—†û‚Ñ£¤^ƒ~HùŠºQŇ` !0ôÆX¼ G"eд•$âÑþwh¿fë#÷He-KüéA˜û2ˆ+u,ÏVåð¡žµ·¨R¤½û¶× ×|;HŸÙmÀ/ö0‹X#?ºŸðÎeógwùjK%Ïð@Lt¡ouCBÓQÍ_·ÿ…M±ëÝ?ØJÁç]©W¬M…Ó&ݬÜí¬yEUá_”×ÿN|BÝþFVz_}\;Òƒd‡)²ÃcO_0êÿ:HgEAÞ1ÊêCCçâ]‰ð¼Ììt=¯àE¥©ØÁè `ƒÞËAa¬sˆhqÑÑ·þC »l¾¬àÆn@+úF¹Œ¹_JÌzÆUKÓE—c\`)½ê¿,öo;²é]´=é6;F³®+›éßi,ª�,k ±E÷PŠƒåõR >Æñ’2×=3¥ížZ¯¶êH ‰)}Ê ¬ÄtÏMÏ•KÛšê°½$¶Œ¯F#ŸhÔªžš¢Eé‚^O›m:D>x÷�hpìЪ;§w6ˆ{—®fÁm¥ÿϪ™‚`„Eóe5"rÁƒàeBLü¦³´]¯_r÷"6úèýàiû¡ûaÒ¾S3Lsïê'_´ýÌyãêNhÑÌþZ¨&Ø8j$æÿÛT¿ðtä9Ëœ+:'jEæ‚Aëk¦  5–%ÓrDCh»þ/HÝ`G}²DY½uĨ+•lž=«œ8‘0ù]£eÃ(TÖ„„P¦¶gþΞÝ× ÞI°o$eA0õT€"Ñ_B_ÕÂÀû<,ð?žÓ5&K·yXa|“[Epép¬p×_³NN<v-ÓUƒqŸ…“|ú]–kq½Ó¥²~Ng-zøèšOÈËR>‹žHÕút|8†Žb¯¿Ïó³qO_y{´£Nþ”—¦u³ûJe_øÜa¹œ”»‡€ßD­ÏxòÇê|þhñp^„ßä‰Y¹ÒÛ—”0°Ìð(ÿ£e¥¾×hGxçXaBŒÁû¹X†ãM™x¾ˆ9úµÍù­í9U“«åHœ2z¾¶µ@€ÏõÞXñbû®\p�þÝ,ÉjHJ)ˆRîƒPïuSZhꉟ©î;®ŠGr: OþYX1üGdµ0 dª›†$(ßUL ò~çyÅ%I\Y¾Ü&ÅÊÏýV‚ó.f«9¸Å>íb°�u?ÑŒp‚¨òqYh0þT3•œÞ—ÂleµÑ^LT?.µï ضÓ3lý! ~¶?¤È½Ùð½[ãì=~1MæeÍŪ!Še–5ŸœöU°$¢Ç�†¨Hâ<³|^`i@î*çw˜HÑKfÒ:¤¡ãëˆcš#^«æ4^­°¢LV©²B¸7á°É¹GztK7aç‰%j'Ïý†^æ h‹Ë}Á)È×$c¢ú¤á¨50®aÕÛY£úî0°�ª¾Þ5TM¬Q°(XÒ& ø ÚîØâ~8ìS{ÁRZ"*Ò'ãCr‡Šê˲ƒŠQ\QýQ(ŒŒÐ'Kd|Aq%R}äH:¹@n¦Axì*n÷Çäë6(â=ïë¦=”¤r_!’Ë0ÂøAU?¡HÀ¤S,ó†¥Â,öƒ£’à’f둨ƺ9Ü{לö{ip«¬¦z[3ˆ;ŧfãlº(,ÛdŽ¿53`û i+)„æžµ5<ûAGUó�Õ^ƒvQL<þÁGÖD+ÄDâ�0{øyÖðªæfRÀ§é㛤ØXæMz®�NkúA±¯N- ¤š]¼Ðÿ ÃÕÂk3浶*:2éq'HŸo׊“á^Uæ[¨f'íèNfúßÔèÓhŽ5NÝAlóçÏ #;’¡ŽŽ@ÊP&µCƒn~“ï#Š( ]¸ŽðÍ?æ,È,ô«Ù…éQf™û™CüR9Ì®í»J£woؾßù¼¾ÇE\²O³õogéª ëfº}ž ÉGMÏ<y‰\ç÷Ú OðI-†ƒ=ííRÕHOlŸPXí[©}p|C)]±‘#Õès,¸6M¡`͸Vá‡RsiDj«•ò“’Ïç½½\Ì >L=½oHˆ…›’ŠßhÓÑ·o7Î"ÍdƦ-dt@ï¾ø�õØ’íaQ;j›g¦T¡{(1Ðë{—ßt‹ãh‘Yælœ~~Ú»Lå,ê¯*%üŸ*t:žSÏmšþ¶§ußèPqjsˉö´J.ºñt<Ê÷”ku |hh­*¹¥ÂnÛ32íd»% *ØUb»Ç^™úò­CäH´À¬‚õ~äýÅ4Äf�YXwèwMu‘Õyìó[DqËÉDB|´‚<åÚôÖUƒdK>ÑP€Þ€š›/ÍTSÉû?Þˆæ䘛DßÖ*%0/¾ý<哼sMØÏê¶ÐçµZ0Ù .ŠºÏ®ƒu–»‚Õ¡æ3Š×¼BéÍø‘vÖnð¦)…'2ˆqìŽn’t_´j›Î õ0³p»é‰’l´K%!í* Õ{Š¢ÿ-”+_P0]ï©RmFˉ¹¡¤¯f Ôçë×—Òî4Ny�E‘²‡ØJ€FI`ÚÕ’lsT¹z?)ü¬ëjf`èÃ@Ãr¥“¬Æq¼¯œ‰½¹½r½tu´Z ìÌ>•m`òï> @Zß+Naê8QÖWÕ{\ùd~zÞMëƒÎ#`ë¦}kæY¸÷ÕŒÁµWL±gÒtU]E¹ãß²Ç%[úΣm圆¶÷ùã]ÝßÀû©oéúP ’™ ºOž=À—ðª´BÂLŠ½zYŠ_J§y¢#ßR˜XýA4vˆÐZîåí…TgN׃M-Çïب La¦xŒQR:ºlÖæÀ”µRJkÊW'Wï ãD*–¼k› ø3³2Ф®bkI£8¤2JäLŸàNFå™B²ziÝDŒ(3µ1Äçs5Xœê+XÎ$IÝœ(èO¹‡éŠq®.ý¦8èv¬$É꧿±2¾U¿4¿ûKÀ0¬]‰zK–žZ˜•šÿroZ«ÃP¦ îÖ*(kh9GKI@+ÓC?ð E'ÿ!V¹ìLùáIHEñ»–XP$bUx)þóæVfzMy¡i¯m|Ÿd 4ÂœyÌ#eJùiöš£sÕcP»hÌÕé[Ðëß §î pÿô†r‘ ‚|j QQtŠ~|G³æÏ,^Z’mÞ5[¦>üFߥz‘¤[´¥»Þl»ˆ]-Åš*ÖÂ]ˆôׂq Ȉ½¦œ,h¬a™H06‚]»G¬k)gêESÑí9íoß5Lýþ÷Šª :¼«5ÏúP³cO{%}“*¤x,jÓŒ‡Ý,æ²ÚõØ¥óÚ‘Å“™ç$µn(Åï–n‡V‘�0, ¡™Cy}¼X <o¬â ¬k'F¹ƒ|v?q_T{MptÌ“Z±Y¦Î\ €]iñ̆®ä´‡$µ8Y¥ž2`@Mˆ¹ÆSˆÅÓºže2$ùUÕtð�'47n;(áùO„Öq§É„"eÓÉÍ<š…§êd˜q>àšTÀÃi;Ø¢°ÓUôw¿½ÆðxÓÖT¶åùòH>[-$–h}Ôè7œ=ÒžIzÝà‰›ºð!°Wo”@öíÁoÙØÀz„\†¥wQO^ŒÞ3:ŒH¹·#¿°vÞ3V 9!%oš[.K°ákd½#=¼ýû¦3´y§˜;ßÄ»ZN«R7­’uló x¿xªBì5ÞØäIe‘àõ{oªÔÓ¹JƒÝ6 V_VÈ�MÓ E~>óu—íúoýÈÓvâãY$e,ö+cÁ=Ú]¶*zmÖfŽ>Ìðã ?þu퉘M‰Î<W—oÇø ñGœWì"ƒÆàÑŽs ž V”CTÃG0}´[qEÓ‹gþ1žr·°«÷´¡Vã_±í>˜YB­ÉƒÌ«ô)¹ÉU¢–‰CH3A�­È´í¼ã¤958…@c¤:ŽG.x¡'Y.… ²` âÔÊÕ‹7øØ’A¥xù(ñ.×@Þñž^sÖSCtLפAñéÓ€Ö€ª˜!Á«L»´°äaá:7CL÷“‡QõUs™ö;m´ýwï°ÐW< Ei?ãN‘A³­æç·÷C§JB/˜7ÆQ™z<E:pæOJƒ%PZ}½WEkôÆ„‚7ÉÂ+ µžC].‹^ÚÝ=ˆ¯ÞáŦêÄ29¬z4ÅïªøÐiÙ í‹>}7Fì•`’ˆ,**8(5ßq1j@£öÂfVíb/D:= z¶µ'ŸlV*ø±ª©™'T6(þ+ ¸·ƒítµ˜šQ‘:Aî Z1aTéx¢Gi†#ËŸ(Iù2èëtÀr ¼ )�ÍñÞ¹ê’6–I꤉ß!›‡ùèÏ4«KîŒE÷ŠÞÝ©®,E}4!͹tÓ|ÅmŽ|î%k¡ cTIÔãΘ?sÞ+ÆÖìEh¯P]/ á«=§«¤ƒ<µ:Êjk;5© Jìx‘Aà˜Þ¥ÓBü?Uz´™KÚM•’²Uòÿ?éþGQlÄÖc£¯}è¡ëÙ :ÜŒ}u)æC³?`;zWÏšjŽh§³æõ˜y=Z1eÚ/-OÕ|í¡c°„÷dÇØî^(QjtWNµgh°0êOèßï®°ƒ¶W˜P6£ Lª—4vî+Ñc‡Î)8*üIR”ÙßzWK©�‹lŠÙU=Z¿j <9˯o‡Ziæ%àñ„e‰bd5í)C„·§µ¾ë/X:øW3Óv”¹âËøquòìÕ|märæ8Ÿ[IåÎcKñL_<z1«j3L˜2‡Ô®ó÷Ó°‘>åÁ? W«VGr<ô;ž1œê ^uåÚ{H»â`ÝÉ®õÀiC‹ƒ“M¾7Oñ.ïT¬r§5Wjé,½¨ (2ï+õd`ÜÕ3¢ª:‹c;ÏÌéÓ¯Ž¶áÉ>{D1hÝ *J¾:ø{ü;ÕÕ•©Š3_‰1Ê ¸– ƒÞ¦˜5¬+Y»Á‰ßÿ?Ú—=;Öú—zµ� Æyâ¥_`jÎp¶¯­„f¨³2Kˆ§)~txsd@ÙÊ¿Ù+àÖðF­ªËà6‡sß:aƒ{7û‰ƒs•Æ·÷ÜdAB™ÂJas×êʳµ¥\ ¢wbCú ÞÿWz¯¼ô)ÔÒ³›ÖË€"T{®õhØ]sqßtjµZ¢ïÙ­S¹úŒ%ÞÚCt–hp<ìèöjO8t$=Ñdڧܧv§b¶ÔÙMëÈ´:Ѹ÷ÓC|`F¹#&ب}Ežb2è+ív{1Y:üFîê1t¿Xê:fÖKlE{C”^{!1ß;°5{2~0·Ì¿"ñá”4mOIN÷ªrúkœ¿Ê–¤'Ò]Õ#{ªo"ãæeÎ[OòŽ#ìr;?@ÿ~’îç?¨þÌí<IŠ•gBHEæéQO¥”%<¥—óË) í 3xj%íôrêÍ’AÇÃxšÞŽ»vý_»éV;PøÐJ�memÐy;�¶ÞXožrÏBß®5áaÊ”6µ±QG’ USì¹Ä7âÁý¹wÇ¢¢4ÅÜ�饞Ÿ ”²@„ã­ÇÃ@ÎC¯«z}ea›<IÝüiô +æ­¦H%‹þ@Èín‡µ|l[è³ò¿·-ÿÌ«L„F·7úª¬CÒñ‚ØCT…ç#)xÊ3Õniûå#Öññ(“3ÕúOí¾ývÌÀ»ºÊwE‰¢sv¾¾†âÙd¼h‚y&“¬îÍöZP¹±ê ÇÃñx1n¢ÀÍάAÂ÷î5£­°pŽ¢+4üÙ›µÑ3 24ç‚Åå´U½³קS…(ŒÜ)ÃWÐÌ**‘CŽ„ëIAW·# ±Luù0z¢¸]qÐmã jmW%oy¿e9aX´[ˆ=“1²éL=¦ú2Xõmh”åæY˜éÿθóÝki(. }¶Ãçeaû49=]>ßµÿ³påqkh—íi3gÖŸ> ÄæÀ«8ü+^Ñæ ü îç¾ê*Ë i6_Q–ǵéñ$A3 xž.Ë=MßÍäÿwpy”: &è]9bµ>Nk´nDÁd«½bŠ¾%†ëSèP¦,k* ëШqÏOFÛ¤L(Òiß’nP¿Þm}]B<—-¾ŒX[ø¨ð½™ ºi³çM¡ê®(l÷|.ðmk+Å]ÓŒœè­´º³ (NX'Àg!äi`fÝyù”„ŸÏO%¾ÕÔ~çp¾ £Â¦;CyÚyΆtfÊc;T£Œoù -2Ü!§\sÿ·h1Ež°4uÍœðN4TÅhUžé¦Ö¯ÖyóêÂÈÚ ¿ÔIü$…çmÈ‹zDÕ^_™ó9Ó>±ÑðtÔÇó˜”$Î’5^€ ¢ó¿Ñb'IwÖ¸5=£O e¸½|MX,ñøÑh–Á©NëdБk´ÍÆ:Њ¼OL ±ñmŽúúôŽÛÞ„–ÔsY‘jñ°½Xc6(M,û+×õ+gb÷÷'*V,«€[rW]¿þÄ2S7ÿªJ‘t€ w9Ð;FG‰â)ny=¢ ­`îxQ´­¿#¸´ËdN±K\A¾ ‹Å¢£ —}ÙTªÝôDjË™;„Fka}�‹xòr$ xä®\¯¦¶zÛ9u— ”,åW”ƒÐ9P[ŠFÌJ&Z+ÝJ±G„ ¼+˸¼EÄ+¿1Ï©Ú` F9°5 ó¹ñ¿FÙÒö‰1ßúÆûl\6D¢\‹ê°ÍÙî}Oð]Òº®jQB)Ñ*W~³Â-}“¨>{ l|n¬T¡iþ À‘È-r–j×Ë•ß”7—ÃÉa@·Ìϱà¼Ðàõ’]³4U„6ñ ÷)¼=Ÿ(¡5Ø~õ÷œ¾ì”ò(9;‡› ¬Uø„];Э“ü9v¿¸‚U¿äÃç0Û¥!ÉœªÏAdÑ7šèpfÏ`\ÌóôCænp;f½‡C§¤µ2­Å7ÄHÓPBBy y±­ ZW!•)§efݾY§‚4·.°öŠª})³‰Ó…‹ Û-Âa`²K Fxk*vkõt<\„Ãlaà+¹ùõÂgº|œãvaŒ—'ŽhÊãÇ|ýºò$ÉdŠ©aÌÚ‘± è|Œ2â2=.µè:V»­ˆ_]ij‡Ùp9*ÍîHji…©æóáÍäA“ÎŽX(¸o1‘6ž�ìY²GÌRïànëÁÁá·ßxshŠ|–ڬ辇Ð];!KŸˆŒ¡Xáqt ¶´1@èÍ N°óAÑ„§KvzÜšö-ÐLÛ´8)ªó9é@™LP­×:…ï.Cs‹" £Òï\†+Ù*¥µ2`whc%*ÏTÍô6[½ÜÛ<¥ÃžÊôœJÉ >V(Ì?¿Íøé^ZûZ+³ölPV_^ò&êÊ26ªÇvæuúkPL–z&µÁ]üÔ²jph69Õ’{ˆ¬_“ÔÎ0È 1# ¢y²³O³÷v 6¬ŠbÇ™^gŸ«nvÆ øS¥s¼N‡3ç�z,H{ËþË”~eUÁZ*4ãÚú«‘kÈ»ÉÓËø†„œ–*“Ì~b"¨ß8âƒï¯ñYô\Ú\qéòK^üý)fÓ…P[7Q-üåç—6¿R›·º‰�Ö™}BùèµÜì¶êv¯`pãx1ÊÁ$Šž[ZÌ ¾4„i¶>ì~ÿúLé[ÝÞÓf*Kƒ”ƒ…,à`Ec«Å÷¼Œ5ä¡®Q¥Ýi>„ßÆq’—è_îõ¼ì”­|Öuä—ÖS‰ÿÓÎw¸3Ê•ßEwE·¬mà&d„­ŠK´JÝ׉ÙsHeñðîM–FDeù ‘ÎG²öq”.H´Y°§”:ìtš!+»«ÔôõÑc/Žà|Ò Ÿ&Ï‘P´™…nœ«Ld¼wõ/!ÿí/û[g²ZXWÓ—©;Œi>­÷jøEÉðè½i¡n_I䆱7=á^÷4S�3ÅÜ ÒôÈ€‹sö í‡ü³øˆ|šIœ¹µ¶\$™?æÀm 8*:Ê+…J}ì(×wWOز鮋›Ÿ2š¥‰Ó ¡›êjúð|2jŽzWøÉü×H)zÂ0S7]MPØö2Bà–µX«LЕI¿urbff_ï1Ý-®I¹ÙÍ…‚³=æs†‚´¸Ïj‡ ¼HÐÔ!GÞf¢’­–³“Ý1 Š÷¿v‹¡M`¶�»ãÄÿõ«·sùöØ]�fíÎÕh«x¢¢¸Ê`.ë†Â…b8¢x¨P JyBw�ïlÙÊÜËä ×@ãÃdµ 4ÌÂ(K½ym,I¸Ü˜»LµP–iÁU†u•h%‰{»§Îqô�¨ìÔÕÓ›X}zv¼õõ±yn¯|STJ™Zª¡ú“+Qqî´u¾qD”ÛìX*@²œÁNUšeÌOrÚýõÚ]¶ž¬ö¨àoP¿©LrGtÔ–CÈRÆ”²˜%½†[D7½}ž*¨qÈ„‚ÅÅå;{—‚ýH]'€âÊŽ*¨‚RÓPíLê`ˆ(çϽKÞúFW{a~¦ÉXkwvbd¹I�‰Õ~õû {':å¥ôóÏÎAª«þÏnz38„™ógsóIJ1Ž£Ôaçéw_ mx‹z‚ůÛ¶Òe}…®™y SÆ›KÂë¡Œ-–s¢yÇÛÙ¼ “»ë(•»qëÅõsP­ÜÈ”ú}«‚š­èíËÞà›2ŠJømвÕîØÓÔù†Ck:Ýþ¸n±9Ù [`<ü…†ê”‚lTV®Œ-=51EÿG‹µÌñ<85¬¡@2Ξ ıÝÓµ RgÉjåõ6«!—áI#ä]ÊKí YnÆ×´ó8Õ°�Š{WÏP¡¥!®÷´±j-¥YÉdß*µß‹#ûýË%ÏR>¬T1†/—÷”¬yc«ôÜk<ŒŠ…EgÉGQ÷îA×,º»sPZÏßh9œ‹¾\¡²ÍÖY°j4 ÷§ÉÖF•J¸‹$ÿJaà`§OÔQî,#ØX·;¡7\<ÀMÏ=3Œq­Zô¯HwN586ÞéuE5Cg…þƒùp4ŠüV%Ãœ*ÞióŸ!·I´Àò$Á”Ð7§>ŒWÐg§8sÿ‡ÅÂX”Œl =¿m=ˆúš–Á½5ƒ5k*Óœ¶Š^MS,ä8±/©cä`]ð›ÂÈ5 WÆ¡èð—+¹\²UVq×6îăK�·ß̇©—ÐFÒáh»Qt³kžr‡ÇXØyËçæ)šù¬Ô|„Ú—&þ!s8yVäVÏY¤³lËss¡³m™Q¥¥ÓváØub’K¯®芵‚5éì¡'“§‹–}Híãè)c h8MOG¡é(‚h¦gì (,}£Za½ª,ýwꜟR ZýMGAÃq~Ãÿ×ß—\ö¯1Èßçú_}òÎ[ðþ¾wdtϼYÒ› Ýò÷Æ| ;D•æI‚ïe,­Íywçî]­þW®–Ê´_ôxãcãMߘ€¡§ô»}L³Õù©¸ÌK”Ÿ®–}j›l™Ñ‚U¢4¢Gßä„3¹å/Ø$êNŠìåú\Ð[ …4'mÍád¥©xš¨$Aœtþ‘<ïRõ ÞFºðÌÂ9pŒƒr´Æ‚>mëº-ƒéUºr^.ÜîBfÇÆsL=L’/‹•ð’rðÁ›Ó„ª>Ù~¥A¾©´ ÎLnµ©„µg¸•¶‹=¥´’!9Û"HŽ>a¿;}1šÈp[A»ï.‘¤wsc¡žLV°¸º˜‘o¹“ñ‹%¶ˆàâ* Ž”�ƒ‚s@p>#|ÏhmŶ “É|Ý%ða‹þ4NrZÒÑɆÞDwiõšèûƒ>µÅC n•þ{]Ö¶�çÙľ]Ú†ësi8eþͺkÓ%åW쬩jD»øtªÆ±ÝvZI=}¶Ëþ2@ßòx8_&ó¯YBC�i©ýd‚Ê<K&åZš#ÔÙÝ·¶ò¹c˜¬õJÉå¬ôsmÛ'(0m0 ?„ Gq±@–Agìb!U±ù¹ 8ÝG ¹zœQáÆ´È ê–Q«Ï’µBÎ8|ú*­gj2p‰y:ú{ÊS¡oÅ´âÊ¡£3|úr$½-DÝ“^NÝrV3]ø/}žèN,ýmÓ!¾VPœ@.ë­WAYRËžKX; 縋5„SG`ÙG±üËB‡Vü\ÑèUÖ–q–¦3ïfcƒ/Õܦ|û[C£4\ùVYôá!È—4*ûf„Bjöõ¤?±;ZƒŒ*ðÅiêQ ¦ÚQÖ?Í×.@¨ñjGC“lPbÏ+×PI=!N }!q'8泓<ÙVT.9BîãÆ`T–Nλ@Òù1£ú´¼z~oPúåÓoZ‰H½X¯0çå®`O˜«Ç^i§GìÒ½Q=äöüax«¾²ÖÝ ì7_Û ^O®�ŠNÇu¹(m ”6úJŸùO²ÿÈâçb“ö6CDÕ¨É.®.–Ïåû®êTž“|;Ìì«Gc8…ÁÙôÕYc½¾¯{ ­a¶àx’Çý`& £FÊ™ÚñŸÎJ H@Ê&&õ~Q,‰j %…zäóäaWÝÄÌ.™ ³wáè6qî/}zÃÍE0èV׆=ºÝÈï§ëïƒ|§ ÊVÖ®\hÉpΉÇÖ¼e"³¤W:b¹ãó‹N©ŒwnûAsfÌ‚¢V4BÊ]¦02´ÏQ§¥îêa#+ôÛ‰$B `ØŠ¼ÈP„]ööKÜPxÈK8î0Ÿ>‹n(:j[¸d1WŠü,X×VëN0Y¦…`P…·v“±'çFâÅV÷OÎÑpJíïÿ g-Xt_(£0� é¤Zöq·‡IžãÕ«SJÏŽ&…Æ϶O“ ´(=Í)w‰ MîžË®‰ *tðæ–?ÏÎý$_À³hÓS5WåñäZçTñƒdB=\¢E¨x7šw> a¹««Å/¨ŽxðTb…s¾S–/½T|zXꪷCô Ên0vL¢4§ë÷o¬Ë![•Ð‡¬û8HºÚ-GbNÉmîv¿¼ÜÝ—ù�æR›Q ×[5%–W&ŠâV-ÔäæTÆÁEb¶œ­Ë)ÅÍÐ" Ã(u¼&hæÄ kш]áê�Òˆ¡éSõG®"TýÑ^¦ßy d+'ËCt8R:Ld–Õ•Oøw­ ŠzÊvX¯X¬TPVï° ßM¤?ñÈ_Z£iîRF@q¡ÇvzwÙÎþ0zvÑ/ñp³Ô#¤pÃá¶,:²µŒ‚fuiQÖÌ™Ãj/(®UÜÑp*o¡V¯}¶R΂ÕðîÉCPõ°A˜µ¢×¶zÖøõüWŽÎsbOAÝ¢S1ÏBÒÌÊ®“dNøR†™•+oСnGØ+ÆÙŒ*0w¨w~à­œ¨üSi³+l6~õ£¿R!¶®”BT‹û »Dšáæ\íÕX|ï¥iÚ¨*3¿ÊL8Ž” fv�àû©ÞQf¤¤=¿Ñ9Ð�‡OO¹QôÿÒ0glêû”™ÛÕ±õei­oN#ü¯‚K5>¢Ž‡þè±×öÅÁ’;*µ]û>ÝàHÛÿØ®Už�g}â,~õã3±«•g”‰Î Âec)=�Zxô¤íæú´ŒO³ ÉÛRËþÅ­_ Ã+=iq–±ÑY¥<" Â÷Úc,ªaÿ¥’‘>q#†tæòì?_œ?ø2Û2ÈlÐs²A;æÕ„qÐw½Ó$³'œr²¥ã»žl\n3II÷²¨=;Û¢(³‡›|hh DïJëxH½ÜÍryIk�÷Ü+¯F<h±„“ö™Ñ#O“ǧ<4};â|²¦c{W‹¼34p#. û³¨HD˜wôÉÅÂBZæaÐbžöÇóÂ1Àáà¾0[”zŽ1cÊ'ºåi{t2…cw¨1Êeu®¨jME„ó~Ä=ú3T¼¾ÿ…§ j\j)~Dƒ •€ntõãèí߷̈gçÉ"[¥c™úýÂÇ3öÐø~FTéØ $ tNßúÿH(\ûb4FV¾!$EÊЬÂúðÇI¸qmr íKÊ…à ½éú@çwäZâQ ãK;½”ÅL|¦œÙÎ5%Œ}ŠeMŸÉ£‚ÈÊô†íi\¾Ù×G —¸ˆæí9ý T‚³9Ûm;¬?¼‘ŒÓf7X몢EÓ®nçÉêP|CÃq$¤ÂäÛçu4é0;…e£Ê&P”û,ü—H8t¦¥ž3Êϡ 9 N]äØö,2f ^“F<‡‚ÈÙé…Ði¯íuЈÌl–²—^kH°œA#÷lE({]¯7hÐàÞÏÂ&ÒÉÚ“åEn¿6ûV©I÷=ý“œôx€2빚?œrέ¤Ësm'o¥¤¼õ Wký209DóV›duÛ˜¾Ü ÞÕ¦Ån{¥“”y£+¶M8@�ªUM,3y²ÚµA€Ö/´ñ¯~£-|ÏTŠØuœygé™`ãp•î°—G 1敾~¤­V&ÀÎ÷ p_íÆÎ&NÉ^XáË7¶½ÿ9è阣' zJ¬ãz¶:‹h¹±uU é¯N2ØÐ&×aÜOдÌ$mn-Y6Eáš|,™ÚŸè>õŠtÊ!Ns¿³Ÿþ¿ H}Ùu*ÆvÇ”6ÔÑŠjÚÚ6aÙàà”æøu¤M§EÕ{pÁ,öµ«c‘]ÇÉ÷h<aΠC”Ýd:ð½�{´Ê#²4˜>(PZÜZžzÖØ:¦A Ù·ßµø /å\×ÐãlÃ+|#€úGè§çÕút`à?nvØBAOƸ¢ØZQå–ÝŸ]}@GÕüŸ5“…%<ƒN¡])ŸÞzÞ Ëð¸§ÚTCPÑYx™æ3 àkJ›Ýv‡•ï.QnŽ•‘˜<(Ε!çpã41YÎTQ$ÎœÖÆKÊ1‘7¿eOÕªLÉÙMâ3kBå¨ø$–éÓ ¿øá 5 }0'mÎ)K‚ÒJ‰@zZ|sŠÜ·_ú¾Þ%`¯‚f¸ei†+Õ¶PHçT2Ei7ÌqWc<ªzkÔùIJÓù»eÐÙt ÛJY4dúJÓ)­´¯_8Ê›04ÎT„Þ Š@p âô{%z'*À"Y`}CÈ ´)|†/S†dxhn]y4ÿûÔU[ä³ .%<`f…ï|ž8GƒohÿÌÅêÆpC<Ð×OÖƒgÊyè)³í_°Ò•¯.@çɹ’÷­M£x7±k凔I‹ ›'­Ã¥[×ö€JÜ7¾ÕI: º¬ás6^<³îñp^ª¡P…Ú—Ÿ cU.7>ƒ>€™ÕyBZç Vkµ'§nf>¼Ù_Š‘ø+‘'>éÌ‚/ʦŽj‘@Ç tšFÃ539³ÓÈ‹iÒÐÇq©Žƒ¨›|:#÷<¥,5ÉŽÚ•OâÊÆG×~´Ã–ÉûZTU®µÙXZ滋oúf×6%ç îxªÚó̇õY4 9ï`[è 3}å…ªÎÌq£Œ¢z•‘ᯧ0L[œij­µ0~­Oæ±c¥fbNel2é›g�>×Ãßö!<-Œ‡ [Ò:YUE  uÉÄ—GV†áÿ¬,CÀ¡vݘã§f­i n“‹®êkb1V9NÒxJ?@}fí–lq„žä8E÷†ù¯fNooû3,=̲XTݬQ¨±Ù䌣̨®¹°Ê‚j¥ãÉ÷EñZçQ¸ ]9•€â^èЮ˜g{m~ŽÖh’ÛW*ÐZxÜš7'‘ƒfGçÕNC)¶Vf5Ÿ½Tkj3:ž¶õ庴qfÝrBä [‚ì»sfî«fGËz¿ëÛßIÚ•Ðn!ZÑ[O½^ªáÃùS}+†¿ÐÅ}LX`ÚŽ3Öè!î+ |!´l Ì›&Ìþm·)ròdÖ’òÇêXaX”EjžlŠ'°íf_IJ ~ˆÜ]œ^«³~{iŸsV,x@ip¢WŸÞŒpšw#ã» eý±ÿ(Ë]`g¤e,÷l€¬ÃÍk»‚P4è R=‹ŠïœŽ¾ð’lÑ^F“¿Êè8m¬;å/‡‹EO[*õJ±F2‰¶øƒîêÙ·rDj… C'K•OÙ@©¿8Ë‹5ü=ƒP¶ƒ§5л×ÖxÊf™ס ’¾é«»¯ÌЋöYJåIã”–Ï-vô)考ìBÏ<šiÎ}GLçï,ØF&J}:7°RN—„òÿD“ÊKdN÷§§z!›,+œû­ üÞózÊw —“…Ý-ÚÊ£8Êì´Z½hqa]‚¤ùG’Îל ò“ÑÉaÁ’KÕkó¯ðV˦{Žé‰„ɘΌ<xèul AÜþ¡ Ów®¥“Ô�&!E¶ìå<3 £ÕÕ(aêcFk„Jƒ¢ÞؾCW)¼¨ÃÿÔÓÑiÞg&ןÀuî.žw=Ñb"£ÇûTÑ‘ÿdâé"V '¦*¥ÑÔ[ûé^òMkÉ-v›%KÂrsF¦ Rýh˜mè/TÃ>Á`y3î*q8Ð¥âO»«5ζV­¸¯VR\x˜j´÷,莳í â8žw{냸=í¦¶·À¸‡J´¥2Æ‚††pƒõØV#²mÖä¥ÝÜWœ?˜Y€Ã^.~¼ÛòÜE†UQºœM“kÆ2‡ƒMAºz>Y:vñæ/™ëaÊùÞ÷ 8v ´MYAò2ðwÞ <èÞžGðaÇö‹µ …-.9Z±Öu—ÐñkýL‘rŒrm$|¦¯çÝ8V •™ðQaJn³�WÁˆbae¥º¹X °A¼d´Îx„úº„ 9¹c±ÂK‚ *ï¼êÌœ( ¬¾",ÛÈÒS—–ûæ·4[7Ô’ÑjóUŸÎõc>ŒXGù¢2b*YþzµX0ªBäò =2;1‹Ð3ß·¶#ÿ\ºÆú¬2ã±Þôõ«Îá,º–²ß ºø …ÞÀ‡"Ê}ÙMÃeŠ?k *Rž­ØCê’ObŠÓ%IrÆPáïHSždÁF8™¯é‹‹ÐÙ¹j¸žuÊâq½Ëð±n7VvÀé3Ÿ)L¤•õÎl’*Ý`n¶4‡¦Ux¢+xð;¿9ÂmøÀT?EA«„N(¨ä‚DB¦«=æ±.T¥ï¶jSr.GZÌ¡z<oëË�4%÷~¥*@Ve’Ë’œbˆ :¥ôA —Å$\ËŸªñ4\o)m¯ hK_1Ý­M­ÎÑ({ÜðÁi "š•¢cß³®N‡låçÙ,$Ayö¤‘*[I7Õ6ÜÃVfiJx Ÿ/½êoÇF,jù'²wÛªåväaò˜B¶ú³7zSÅÊk¢Wu¦Sx°þwÐßw9Š¨rþŽî€—ÐýN}tå7ãéŽôŒÅ¬‡0„Gçqh~gÐßti}ê-°ÁáKLŠ­ûàÔµàòphž¾|‡/S_gÖì'0I¾«–ªÖºXÐrôhô¯!¢Q˜EW¦Hœ‰kˆ1�7{×ca*4^Ó·¦çûôÖöפÓB4ãQ‡Ò´ñ¦76½À)G{vì.v$Åÿ:Ê‘énŸ/ƒ4;ÃYÿ•æ•Õö¥|†wÑq«> ÉÒü†"Âñˆ-Ž4Ï«úÐÃáj ­§ˆ²‡iãæ÷S»>XÎ0ãÝ-@`Ý·ÚÆê¶?Añå ºpG* C+¡Gñg·=×>c[ù}e¼Zè÷¥°ûŽ=‰ C ÇvBWòk›ï+»ïr|e7ºÓI5Ù[ßDY·—¹»V*»µ3 µËTšÉb=R¦Ñ©–(ñœ÷™ûYwÌœŠìjí m²â¸á \Dx®</S'Cƒ¤œÛi :±Q¬sE„qVJ;ðí<RžÛ>*#’Uæ„ØÜ ¤Sl-TK¡`!ª‡Õ^¸Ó¯2)œÈofê»#<ÅâV=‚ûÓ—�¤ Å™¶Í–ÁE¦’ÛM̻ۈÌÕÜQN¨\?é]þr O²~§ ÎfW³,±7ŒˆÔ,XNho^»mƽdgâ!elËÊø–¾`_º[Ðû [Z>a¯‰^±º-ž¥íµ ÂüßÝðo¥¬ {q W,’Ô#V­"~¨[/5=Ž»ƒ×q{,üÇÞä.CÏeFžû^yP¨i;`§àÌ'c6õ†rjºùYwQìq³Yœ² Xt¢˜ÙÕ¤PÚÂ}6Bêehmý[lÏ&v3ûíDa‡YJBÚHïûþë…m]³>JD™[ïÝÝ%?àÆSò;sIuΕ^8lí§4(§­—m{èÉ;g¯Ó²³Â¢–ôsèË œ­ÛmŒù\s‰D6²tãl6/÷#@æy¢qø˜¡–fíŠ�Æe@BÛ´÷雯ÿòlzþ¢g¯½¤¾8{Ôy7uhù÷Ó?o´åÀñPȶ"¼`º·L̸!KQ.ìtü Tó¾R´ÎÄ@,–á39�ÎS‘µòøs«ÒO'i;ôT§®.­7¾=,÷h¾Ó†ÅARZg¡ØîÛ8(6ƒvð�3îwû½©…Ï £‚ÙûD(È2sŽ2¬žMËt½GLa˜þtໞínߤ+®ÞÜ¥vWV(I“ÒP%¯ë’>l­”*v­zúx'ÖFÅë”ØC¸˜+\c«¹~i¼„…QóŒÏ·$¥þ $þ¨‰+Ê„GMA·¥Ð/”„û‘*Žê÷|jž9Ö„‰†ËÌüJB}T-±9qYÑÏSêpå÷e¡OÜRjPnß½aM5l´6'“1wNžÇ»¼Åâ¤ÜÂ?СY‰Ã{²ž­cõ®i̽ln•-œ£ÁS<�ÈòÞ9’vµ:fõm+]€ö_Z)8ŒnsR'ÉB'/ÚˆÎB•¸Á|Ama‰Œ$UŽ°Sj£òRÑŠš§;£Ü0õüh ƒúWX¦ [V»)  ßëÃöÜd5WÞ¥+ß߯ (­,·Zôaú€i¨|d“ kÚ•8ü ŸåëCD×/†tRu(Jîúé Unë›PP¦¹õ­± wæ}’ëÕ ¥c>W4£ÅXÛlÕ[xácœ¡s¸ž–ÌŽ¿4Р@¥À1AS®Õ ~«™}[¬Š•ç"bTNÑ°•î"ÆØhò/p1´)¶2¹ì¨,Tæ¡Ï4‹ÀQ€Üó`¶kG‘L °Ø•’¤`OÃÃðš"gXÒž5Æé šÓU粈Ñ!ã¥y»Ðö‚\(x%HÉ QÓ7Ñ®ž÷èîæ³ÎÇŒ”.bYéÌè༄Eæ#îò¡c˜¦~™ƒCU¹¥×� {®&¯÷#>=úòÐUÒ6—£ÐØ ­ÿÄP,R8 wáŠc¦QŘ)‹ìOÏMŒãšŽÕCÛÜä0œ'N½?3o™¿‚`[^˜¤&*1ÆаU&áñ¯ƒ•\úŽ5$¢4 ¿Üv‚*)4]†ôÇw¤ÆêK¹ôx)†ª²§ Ô(ºžª pÂÍšÎdöxëõî²]ø•q`r ¼I ø{ÛGäý‘ÏbWXú'ÝZo7nO¢Ï'åŠÒ± õG_¯=aC§J(C1Úž!:”–l"m2ä ËKIž„?t‰Nýýz–¹,Œ§X¥=ª7€½ÄÜmh_T1Ë"§•1¸$Áçcãy†¼Óún§§Þ4v<eÐûØŸ˜|õ_^€·$5‹B9¡ÞœÜLíÎÍ#_fŸEôháÅsï°²]{†CŒ>¨u·“öÝó£3^Š ¯J“ÂLÓȆçÅ®âLZŒä¿Í`›¦�™"Y¥µw…ªËºo·Û—²|qBöh x^l-VbÅÃfYÅÛè÷£ ã{K=† kvžÔ6`Ú±H„Ì­ýOª¡Z¬­b“¬ U¿ž«ƒ<0ýy˪¼ÖAÛáÈ^YU¾˜¹ìË`çe;.‡¿'L¤‹t Øb*¾„þºJu-Î)÷ðôÞÕ ÏÓï—f& ¦AjÑgÐù„È áÏÈš9;uó,³Twugì]†î;äè[]EPvgZƒÈ+øó àÂû³ía‹ÆÿÞ©hVåBS0D¢é×l³Æ©GcÅ€*`2üÌèÅ4©Ì}xÞ –nTšÇÂ3ê€á6fÅšªæl¬ˆ%\ýfñZñb™A§èCQû9:žƒ›m›­}Ýyºa [‘e°fš[Ÿ½ƒA­ÇÝfÓ>ì†*{ºÿô¥.¼îõ"+0$s}ãM—U6•ìÓŒeQõ:xèOZÆÃ~W‰°kQº¥ïdÓЮÚõ“(¡½1\y&Eåê àøiì ‘JWìHVü�{G¡±Ót U™Ž/K”aŠ�¾ƒ#[NwdÌZç‰Êg噶ɸYc/e¬ ˜ú†sòòO8@ R,ÁÜ­‹ ¯NÁI ë“ào™Q*/˜õ]Ëù{Hy£ÅÓÓ©þzŸÎƒªiu üH‘<)=$+.[øxͪÊPré‰ïhÜ%;¤ÊÈ]—Äs+¡Ìʘ´Pˆ‚ÇÖtÜBVO‚¾@Õ¸ [PŠ|Ê?Æ–ë;å¾F§" iLñΦ¶B©Á¦*óùðx…>Оò€ß«&Tá—d¹JOm‘³þþD_ìØùB-€ÙòÀùÀ}B W˜Ë]oÒ ©;ïøT ›´ÓíjÏ}2óÎήöôËAëNZòîn�rt`+ß7£wÊl@ßÚ†òÇàL*\]§:Â8ãØgAa #û™yÆÍßi凑S@–’ˆnЬ©XLßþ˜ñÅ49T*£­r'Vèíƒ\±Øÿn3›ñý’ëÃõŒïoá§a[²‰cTE.ïüFœÞ–™R#Pøÿ˜ã ûÜØâ¦}<ôvf„Ú^BµwùPïÛýDFí xâzëYWà(äCÜåúËûñXÚ8¢½‚+9è[VÈŽmx m©ÙÛ= ¢'jDEzUOLŒB²gŸgõî€išWµwúY†æÐe´,ã®ÃICL—d¤… <WÉ|z?ýQP*‚´ñõ•C,Ä·©ØHø¯ȆôìÜÖ8]Ûô,·†À9.Wx¦×•¦.-dÚƒS&¥_sßûòÁî7ö™.!*‹—[ñúBï*Š›Ögï‹ò¨v¢ŸûÚjõ.îæ �ÊÇÉD,Á6ˆÖ`uü�Vù¾ &èdPî!/Ûé1…LŸ˜òé4x&´ßÏÕBw.¤Æ0±ž¨2IúOs¿YÔŸŽKi®\*ñeâ‘Ÿ”Ê×Mÿû¿uV‚G”<€ |¶5U=k¸ çÅI}8ƒ^Öò¢ÝzhïÉo9€—X×3EÇw¯ûDÜ�Eø§ä·f©É% 1ü_²Äwb”Ó¡Âí<‘U£€eÌ«a¢”¼$ÜÙcp�Î8 6\üé8W+1ã†{js¹¯øp“˜»øÁ[až¸®ïF´q¬¤BäÙÙÍTd&W(¦~£fS®|$:ÒÀyŃJ<0Ò…)MxRFÉ™={y¨ÿÙÔpP)ÞÕ¿+çóÈA†VlçÒÑÂ*g}jqÊùÈ€ò«ºè ÈMq3ØÐ×kÌ£§T£ÜUφ.³ës3ºÇ64ƒHõÝX÷YÇaZ¤iá(­Îœ5' �%gÁ»”BZs©æ`EaúKçÝãéoäLLršžÐPy>«nÀ¦”ìÓ@A‚žÇfÇh¥§&äIìRP æséi~Eè—Ò}?tJ&Sσۋçcx•:_©ÐäžÂvvV^gTôýÙÙ!&z95L²… :mɱ£S¢õqó˜ ÖHJŸ‘Ê5„Eó*Â(Õ 25\.µz² O™³jøüÜÝœö;o<ö­=k´òÄ1\=(Ôiy¾àJŸë]W¹Ílpä]úh«Xj]$Cµ zCUþGÌÝ8-]Å0"Ì‚£Ï£92Ñ?šOM«¼4#�Ó¡dP‘È~îeµFMÅÊÇŒ€0 Pth¹ ¸íCµ˜÷Ñá‚¥÷ï]Ɔ—blÌCÆI—óóÒH˜ý�`Yi ïú~o"´4,1Á¼ààjŽ5L .£muüœr²ÊRolDÄDÉç âûqQ�„¹ Çì¬Õ¯Usé(k ›E7¼o+zR@YÄ°ù¯GÄÝÎ]<:T­�»:ôRð²FõWÊì&ô´ ÃqÜë³]›&¾'-D:WK:³g¯TÜÓ݆�¿J³ýø0½wº+¯!U:y²JQ S€óƒ¿u(R_!( Ù$mOÞ¸Äùš¹É/DL#[GF¢e _`‰äÌ:î/M£4PÁÇ1J)W›$· ¡‘ƒú˜¡1÷®Ytï­mà¼î˜ Ò^}.')ÏÎy‘Í•‘³z¾(œZNh2ŽéùÀÚÞ4¨Ç"‘X-‡’ºKÂË-ç¼;"<]¼2gy Ìã@!èšCai7›¶ß}M¬0iô5´ÖC‚÷€Ì$|çW§Úú“1Ä„G½Æ]ã»ùäºÝ�Œ[¾y³:æÏPnt4(K¤VÕÉ7eví~FI¬hpëB&ÉÕ º¡¤(ûT‡xeA³oéý‚r^hyL¥9.‡„j梣’¹å) u5îë [ÿ¾}ï{¨adA]®‚¤ž=Á(î÷xšþô?å,ì[,Zõ–­ ÒåØF”UŽg×ÆTÏVãO4QãÄS&HM¶½ r+\²*Õ\`ƒµ0éÚ^’–c$4Hzë4(Þã³ „ˆ½[Ü "ÆÙ–bæí®Ê“ÜÁôÅÏhÅY÷Á^¤|RMakéI·†Y>ÜÓäÊü6?Í׌ò6ÑÒoĵˆ wö\}‘2‡~‘ƒÖ1-ÑâxñNõÎcwßo ?éÛy±Øñ@pŠnÑêKû�¡ÐQ:µÇnýßï»hq-`»å|”ÅŒ*PÔö§¡rÞˆÓ?T%ºFI á ö7f‹#î)Ú ˆ×Hâ=Þ1ûFȳèÀD™yÖsFr +è�BÏùâÕWQœ¶[äYS€­(­Omû‰òÁ Z;–1&y€"bãåvë»fó³¹ÐñZç¶å¥ûÒ8˜P£êm.:_¨Ô4ÙÓ æØþ-Ñ‹�Ç¢lÿò×SUíû ˜²ôH.o붿ÈÁFšÆQXOÑYQáIÌÉàòŒ!W«¨ŽˆZcyžl<u| óÕJìhc¦®{¼”ç6ÚY†úc¦z¾Šm¶Wpl)œŽïžuè~‡‰½mùþLeoå`È’MY£ÎZp—ìE5µNôn{˜jÃõ>V¬\`úk0g;í%µ/÷¡?lvý1ƒ�1¨Ê?òœ#ÀÇpîB¹Çw[,kìÏTøÔØÍmouK%÷ ÿ—%þ¤8ʸ«Oï^7A‡Ë2|·©ÿê>KW¾t»jk.@x7U|ÜH¹ï€LHXï)Ô¬Ò¼,M’S·Ó“úS‘&I.çÑêóZ�Ò(*—VäIQ`žÌcÕ´\úÈ'MIª@2ï°Ú í›Â“»¡å6üm­²Å?€cŠftÊ£éÎÊŒ¼¢ga]�ÔyÚ‡lj¦CVn¥ðef{—…Mtõòd¢²Òr|„OHåU6‡íÛn<XŒ2Œ cewer«~Âê”×õ½™^ÃŽ—22ˆ ¡6™8úE=f)Z<ÎïU×Óпm”¼-•Ó“åmp¢ý q…®Ýõ·zñw·Ò Ô –Ä㿵7Üàv¯Ì#\[ú’(' NÒª#Ðv¾öäžñMÎq±.ƒ¢þ´Í«0P°C£b“Þâ Rå~AÁÆî”Fünf ¾c2)Ùè?«Sƒ´štŽ…ï!2Fhùª/FWKë}žùü×kaµ ½¼yèsԫ⮨ñ[ü¸ð ͽޣ‹U´Š•‰Ù`úÀ&f!˜»2Û;¹KÕC+�EvCë™e"9P@O'‚ýÿÖÖĪ¨fºÎxãÜÔÜ¡Ÿ~¶ÛÉD£jLô-´u­¢ƒ÷®^“'´²Õ 1ØÓþ+]BžÝq‡÷¶ÑsI%7ùfk� L[ʳzºÒø1(Ý(Õ©ƒ LpâJáJ±ü‘«±Á²8;&böKu*H¦™ªþk�–ñhUú¶Ñzh¢¯<P»ÛOSDÖz/ñ设dÑ›° Ö4VË~µt$§n‚ý¹‚®ŠˆÅiIWžeÒ˽=+˜±ç<ï+ª0g«x¡c^¡Ê»Y8N×»(KSÏ«[è5TÑwGÏn•]â˜èâð¾Ïì¹bËn yÑÙ•¡“˜Í4Jü³m{ñM'PA£2À†êpxÍ {AË�at”ü@ÁL‡C¿pàùçÍ]ÇWÿo´£­Óq4HÛŒ=Eo¿õgl ® ã÷¡ãÆ¢Ö×G²UZ{ÎÛŽ»Êâpé‡ÁdNÌø™¬qš-„¾iuf0•ýòì(èÐÖà ´³œ&”¿pB¤¯¹iêW°ìY_+´’²öÿ°ë=£stuè=‘y°P+­öm_í#Ô+ïÿÖ{…ŠµTúeí@ti)¬lf«ZòèÄÚVKáGáx Óu5½{)r– Èì|¦Û¦¹ù¾CRá<WÓ¢ÒW˜ÆÃf‘þqð�(àµÂ:£²]æ®ëÈ ŸûþÀÍ¥HÝ!Ä‚ÁRp³žk0™p¬Îx†9Ô—{wíIß%ŠJgèÈÊ ë Ÿ=ª ¬iÏš—7VÕ?�ÙЋž�ÓRo„Ä-TÖ|JÞ5â¡AÎy+§'÷Ÿ^ÕZyäßÐ*§ó»·ªœ¥®Ù?ÒOÉ#þ"!ˆÊ“ýÈ,ª³ÓC¥}{8Ú׺¢à=÷Õù´Qu³ Ï“}Ó l· Ó„3£ÇýÑnyx-kà¾7m¬ñ(3êúóÎÅ`ËMU-MyœFu–åãU}ö£e¯j8’èÝŽôn÷-å‡ï[‡>·\SÝ^ôéEÄÇþ—g*ñ…_²bÀ¹¤›mq¯¼â-RoiñŠƒŠ5z sãGvè$hÞ¹ƒ :ŒŠ(¾l‰8öÔ9¦¢K‡ó§Áªt~Äô–á§IKddrÄKªó©'Äm–>†ÛŽvA Ž·ÍOîM©|;³î×b$F…v OÝtyPØ�qѺâüUzŠ´‘¾¾>¬§ÁÝŸäN€T@4?µúÿy`¥4^Ud*=]òTXÒ´yFÛcX?O›ÃÁö&÷»~¹ï]ypºÒLë|vö´##ƒ”I‹»ÑÖúV,ÍL„/LºÉâ#i]›Àĺ¯ßzGvägJ$±us—ų2iØdÍ0â ðɨ’8ùÿú⦩Á¢Õu”VȾÊûgÁÙÉhŠ6+R›CûLs,ñ&ªÒ‚·YžÔJ:u[Q¡-M©Æ+>ºi7¢@ò¡]&{eXö€ 7îNq7½§H ck3%¢ÿ¬,›z ¡„¥Ü§$ˆ¬ƒ Ž?H‡TµÔ Ñ×ÊȽ¥ q3Ž»èlo©>À†Nèõ΢K^öåH01´Ùe¸$XÚZÖ3hí wÿº K³Æ¥AÃÊ‘j•æ¬ÀÅÄ#;š¬ûÇî£E $ ]lï 0còúË€4ã¢áþ$I‰sO„»^”:ÐÞ³ä¶pgUŒÑߦO$s–ÿ˜ºÃ uÔ^(„Þ¸Û+)KãéHk`œ½aD}Ók}:ʬ´i'g¥õlå:ReÀŠçíàttÇ‹ô ¬ùÀ÷:ç–Ûk0—žÒ Ÿ¾œf}¨æ ò$*¢qZ 8Ì<ð“€ä„b#–Ç/š§ŠÛ.:TÜ옩¢Ôýá|õb!Ź“ŠbóÃuGË×zÉ"‰ý³£Ç>3`~Gÿ7Å+{¯÷ì9õv~Þ¸i „vGÏà×Üì–îú-ÊÕçÖC7X§+ÇJN4‘Ý¿+¾otìqS »wuút],j™ã:Rï ôÞ$6-ÔÐèÙ GÚé¹uJ¤ câ7EÌóyºq8wNça–Ú¹ eÂgf!wU-*b-L]œ-ŽÁ¾ý Pð‹Ø§G͵PÞ±Bë!gñ�u�yÖZªE×î”ÍxØ·ô.C³;ú*Á¡¯ýã­¦N½IòRAdŸiŸþ=­./Ù”RN¬é穬™­ÝÀÌÔÝ‘ò˜òó¯¯;t ósë‘3Hõ?1œµ•‡N¢Æ€o½àä9ûhQ è{=9×›=ÞEܛϔ_¼k 9w¤vRs$ÀõªÏkpÖ"¼†'Ž�DUƒ·æ�æqˆþ-JüÉŽ!Þl­õ£›ˆXÁ Ár²ülœåÑ YÃÜkÚ6dñl·Lþ�ÖÑ d_¶ÌÆ&A(H»«ó¸âiIûæ ø~lIå{µq‘:“ í4»Ÿ…‰ºº· ¦R^ÆÂí,~á a¦[Pµƒ}õ„xsU±ÃJ©íÝ^­cÍüºöKÜÂz^¨ý°ÈíÕõgÝ€7’TÁâ2ÑÐxÞ h5O Š7…ð º2!³m |%áûþA§X£kœSJ §{_ êu¦z–ú-Py.´k¢/õ$ŒK�¸á¤Ì½ó_# bµù Èë¶TSŽ£Y‰üé™+… JõEñŸNâѥϴ¬"Ÿ®ÅYZ=±MÍh•àÅ}Dš‡Êê_&©?c´8q+öé„kÞí‰Fû¥yª£0ùsZ°tçç¾}ÑÝ‹2ÚE;DLÓãÑSf‚›`_ô†%%ËVj~Z-z¯r}Yö'Zê–â_³X�®¢õBÚåógnrò¨ðÔ’™*Ϭ—âh“Ç<ªœk¯Œ=¢¼<ä¿Xrxbr›б¸UôR‘«s­ÉÈŸV‡¥k 1¿•²iºç“Ò :F¯)J=+tÎdsg+:ºífašv¶¶jf½¼‹À͈A?{ 9±Ë‘Ñôt­w¢¢'NB�™=¥vŧÊpñpèL*ŽÏÛ¡ÇïÓµ ¦ì4ëÌ·Yà¤oÐP³_øÊB˜øÅ$ÆäPg­ˆ£h¯)dï*ï°™œYjí²¸®{ŠêÕém{f›¹ÅOáiym)5JÈšÎÌù9’ñ}sÑ@Ò`wÍ©±XE_*,Öa*LJIËBv˜j«7pPY;ö‘m ßûéaƒØy]äF‚tý‡’¨²ÒÖGÄ…(tË­öƒq ÿ™È¿\…»ßéo®Òl˨* ®J|,Ê'I¨Hâg½î<[Ðlb8ÙQRrš=+ùîT×èJ©KäZU.§Þ«Ê_ydgWzJoh1&íÐ䙨jRœÿK@†Û=¡IÆm$Æšv°K™ý`(ÚÌêåÞËGë_ó[6-Ò„…DY®|Ôa ™¹4(ªÞ“ñ;óNV4¨I~…Žïäåèn]1›sM°œÂÜÌh§œÞÜDzBèÕ¶Ê`¡ÿ^ÿ±|ÝEÖé—CùgzÚMFv ÿ¹]Vêþ¥Â(+^Z4܆,†É5Ãë¶ßØÁ%€¶õåÌ;¥ý³r?OÌ®_)Xrb›!€l(„‚êâbí£&š½–`'4èÏÆVü ªJø¿·Ãúi}LV*ë±ìïüÊD߬rBÆ.㱞„}”¯p‘“¤tpíãö3ݘJÉz,†KQ}¬x¥Ýj>f¾5Eí°©u@U4Ûn¸ªÑx ø²îG nFúÉ] ¹-ĺ¤ÝW䆊¾§Ø6[QkJÛw›êËèå2Õò6YO ŸŽ¬p¤¥8) ' ìäÛZ4qP0â²2“{GƒˆÊE³N\' îçŽwd¦‚ÊH}¼)­ßßð²Â[½îÑh±ˆ¶˜•í…Üb)‹5Í»5Ã+®u ÂÔó륣ŠK£¶óÈÏ€µ¬[O¾/ŒÒØK{^]ÔZ*bÆÃ…ù-» v˜õÔ8çEñwä¬tåɇ±„hdÇZrð_í‡ö†*µ¤îû<qH‹j¨Úgˆ'Í–d$‹L×Yp@Gå+Ü‹1qÑ>Fq@Ê€ÂÑâ‹RªHÙœ™È8/<Tç ^(NL2âÅç‘ö‘5‡î5÷³@÷3lE- ï]yR¶s ©`ŸÐ÷o4f•¢Ð:ÓÔÝØÃù÷E¢oZ¦žå–ˆæSŽ¿íÍÜŠ¾æšŠÂ#Õµ7ò y!«‚ëH.Gñgm‰¢W·‡Gé|ܹ[´CÄÕÑë˜5Ú¹SÕ£|«êèâ§Vh¦Ö¶ð/«ßñŽÈƒö+¡jËšÍF|ÛÐ!çoõÔãØi2Î%ÄÃ-ƒÜJ2¢±´².Àf<ìäœpWç˺“óú —©ëv3jÆX!¯\ „Ú¨LÙ èc80¦y~¦—kPp7šò/ µlþh[Zôp,ßþ}~õxa<0§ü@LKöÓÌÌ—»fÀB]£ï{|7ÕŒ]/ ÕùÖHQØì r3Z±õPµÏ²œN�m¥ôÕÈDÒdýûvî$À=²-<á˜P xÐi\í©ô<ßKU"¿•‹Ì×*Œ±Ï@aí'7ãR”—ª}Ð¥×æÇÓŸ®¿Ë*qµ˜¤ª€QVÖÃPòõ¥¸ù%G:‹©ü\™z`]6–ÛSÉ«³k4˜�3=ab~lÍs¿© ?Œ¸ µZ9ŸøšÝ@#­ëÞúö0�©Î¸}d¬Ïk.¹¯X,¨Ÿ‰Î,B&ee_swúJú߇¬ô¤2à‹½o}ÔýÞž!ßûá.TÉy%¶q¾«Pí¹5}ªqR`ob2Ëtaôºº][¼í§M —Ï*©pÇ£ÞoF)@`¼1SgLÍŒCƒr¤ä)Âw¿¯Ïï‚Δ˜xæa`0þ~Fö'¦zvÓxZýšNJUIáã8™Ô…^Oã÷•¿còùÁ,@ Ê€£‡–»æøHgú=RÞcl£e g†®=¡ÄäjHÕLXüül¥0UtkºÒëV™nMåݱ¸}…ýø‡èV¸Ô;ò'¦ì—©³îA ŒbÏ—\zÁ?®ôú"‰Ñ~/+í}”ÉRĬ,œû"!zý#þ>líûË0˜Ä4ßaÆäªYÊø—ʵ˜’V¥Þ¤ žo±h*5‰…:‡,Y‰îŒ «@F²ƒ'HŠXÈL=r¢ÌJ?@¾…ž0ÏÍÂ’ Àã©ò¬¦,Z]¦àeÇogL$üãR9+ª“¿”%ìYH>(¿3!ÿ¦=›„ éR`ézJ’ÛìÊ9žÓíâx®GL‚—/V†Ù6çÊ༡¯ý©Ú,1ôÑ=¸E`àyögßK÷‰«nêUlâ·®aîf½"³ šäÏæ®f�©ƒaС7r‡‹)' É–îAr  uÊ:º¦3ÁtÂSeÕT sošÅöŒó”é`Å‹.TV»ïôîüL(ÕKé9eA¹Ùz«ð¸[¯«†½S£˜aûúFâ0”Fßj¶^Y,ÄS陋 Eà³Ü8\*‚§˜yêÎZU£Ó¶§ “*|Xº«Ûœï+�àžNñxÖ5Ê‹v­œMfur’uñuA²«)Rèyœ%†¶¹§7Ì]|Ï@ÑV×OkSà¡/փΠžÕ!öÕÃïÅÖ:€P!Qõcý£-ªê=rˆF†ç n쌌:l c,ïȽ/±| ”G8XÔk{J ˜®mÔ$TÛq)ž¸:;œû‰A®¨ Ä}Ó)»˜:òætpd.ßc—‚¦£ËpFEÖomî äÆu˜ç¤àþx•‹·ðZoË$”š¢{Y«£:[¸ Ót»`ÃÍ}•ïyša\æžAÜJ’â]‘ŸŠ„5.‚À ÊävÇv 6yÆqI’¼ô� ðÂzOjÕ& ÌiNãŸö*kå¤ïͽð"ÍGp®F‹pá€vlXxÎtDª•ˆb/êŠ]¤pÕ_ÞÊ5¬Â…=NL)%êíÑ~pw<BÕ¶(r¨=Nq{Áƒúó=‰Y#.mö‘QŽ™·ÞܨuYMR’\‹Å¼$“.^`z61ðÏN/bãüë7¼ºÊ@ªŸÇ |JŒ@‡Ð[„§kAªs¤ÿ¿yÉš{g<xlÑò kK¥”‰î¦úÒ±�}n>4Àá'{‹ãŒ£Ô·WƒêqÌšR‘Ш³,’÷VöØ^h‡ÈŠ‡ª<V݃ž¡ r–ñ½ð8J¸¾½·QŸî×°peŒ^b%õ¢©Mø)l“ ûëÑI1TÏÒ™÷­®zžY#ˆ»¬ç! ’ÏF¼;k•Ù`Ó±æÆÅLÒ ‘‚ÿ½¯'˜ú&[)dôñm%ÐvÏÕª ƒ÷à²O³Žv›X8[s—îè¢gp9Ž'G£ô,¹¿qçvqu]{J rs¬GˆõnæƱdÍx¸ôë6{Ä^ÀßPYÝwvô†¥½Üž"˜vŽ®UD÷f¨Ð&3€x}±‹;ó´À®°®èI²ŒY(œ Γ&lj¤ýÓƒwïÂÉgž7'Ë΋­—Mâ8ÝaÜgÞ¸óF­ç,¥4°˜£þår²ŠRN›Q…‚¦¾:1‹T¤‡–?Šhý%Z,B“xÉC¤()}L«Œ‹sò=z±T ¨„´×;ì{óÚ⹺›ç>^ÍSŸÍÞcÁ ÐI`g:/8IYÎç¬.—ÁêX{šÀP¼§z2D>FÉ¿cGÇMSñ}X°6=‘žW¸-Óßž™Öøê/£žbï9³Fùžþny¶²¼…1C§`¥Ø'»3î_>JkœÁ%C–æ VRÖ3ÒÂí<ŽÛ  -Çh;Y% öñÁ¶p•Áq‰át„öóã ÏíþèÏ?N‡QìÆi,áx’ °ÌÁTí€ßêèƒReSù‰˜¼èF|(ùÛpŹ=Mx o‹U½5©%†ËL@õ ⬧à‹$w!^\K)òàX -+¤v$“µõRä±{ue ìÐΣ–ªüI-ÿó€4õY o MˆF©`©Ø S_ÛÞÍa«¹çšq_—6:𒄉ÓÅ3ÖçøL>¤täA kPÓ’É:ÛL*3Ûø˜÷[Ôªˆ\îêÚ >ñT xŠ ¤wX[ôÈJ”Ã]sìÇPoˬÏjÈ)£áݳdû «#ú�˜î�깺XäÆ̳éèZ$ ò9´HgÁ²¹Ò@Rä»/¾›xix8ýD‹¯<N*Ó…-òGmÐ)ÍœZ)áæÌ¡kˆ.�U0[½Š\ãØáƒ%Ö¬´€©Dï]=-W½¶L„=¾ÞÇ” ( xÝÁ£ª‚ „A-Û€J¾sµ�âÀ¬é¥­>:·O:¬ègW>Š S`².ù7ƒ›{¿{0̉¬2óÊÔ–kˆ¬$ÇjŠ`]»Ûk —‚ MbºÉÆŒßv)ÿð@„NÖ,/…í‰jÁúèC¨6Ä^ƒç¦Û…£=·‹íÕ¹2NmŽO–…©§Áu˜ÂÐé¯×ÔšwÍÄãuY Ÿ'¨°¨Ú‹Í\gQÈ“XÚ ›KÁ:›2ßO¢Q&·(¶?KCðƒv<—j@þvó‹Í¥o®"Súm ZãMK+c«-ÓrÅÊhóÎ÷±K°þhßíúau´c{¦w\Riœ§ad’ÐÍ% rëÌ3ý‹”ÌzÅzýù¬@æ_…R­~ìTy‚’Q^©!KφÙ_ÎIFѹ¥° ¹LËnþ¶+kõrÃxlzîi[{RnÒ‘1r!‹SÎ [?Ö p…yhÜ`È‘6V3{U`›åÕƒµ2p·çýìxnÙ·â gëßQÚÔÓÆ] Š¡vÇêóþ‹u%_y áƒÃ0V­ŽRcµ5E%Ñ_ŒrËÀ"e*K"–TŒø½2<ñ™Em¹ï3ôÖâ5Ã/]4¦‡BÙÊ…óBU a‚<îøÍ/0y‹|[4»Zé&{L?éœ; ÌÿSí³(º²‰ž†Hïw3±,Yç°¯vj úýÉYÕ05€:­ k̓Y‚úx%¬G÷Ǭ¨[ªW¼Z ÕèG…V+ b®úú0ÿB–).T/Tõç>fÚÁÎä! <t†‚ïH0¾þË;ƒ¯åÆÆìž’¾[yï«a’4㕶ðOYüÐL-’å…ÈÕöV`0]žZ¬*tÞxðÏÚ_®'«Rz}ìsqbIþ¿Õ«`´ô}_¡*Õ†EVê«Íõ³Æåbx&¼òÜÎ8ßÜö)­ÏAÛ …Q×Ø_ÓOGú"œ/iÊ, ¨wyïôh˜<+­ã$ÈÇFxö%²@ÉÖ³œ‹˜K°Ô‘zQ ÓutÄA´ vGع}ÚöÆ FÃNu¢Y^€8S½rÜÍ›f°ý o-­¥Ê¹‡·0$€F@Wõ«õÄþÀU1ôwŽà ¤GHJ^_£©5Rð× d«?ÁIQ\S”•µNŒ[Ñ™ârî URþ#\Sú÷‘‚ëüIûÈ:«�Íw¤[·6“9«Àxü<aÈvk÷âk1-H  Óo´™Ê\ÙZôЊÆ"UªÞF†åqßJÛÍ+Y‡’BÀŸ¡ÕËCÑÚ×6¢ñ4¯^9™œnƒ‘EœGævÔpxÏ7ªò”#úK¥«È\ZØö/ «<Q 9W€ ª% ®•Ê0)�jÊfCŽ·}—ÁíiÀ¯XÌ›¾Eë8(Ž£gºÀáÃJ<ÃLŒµxÝÕ>/—\§è8SñWkiI,&s¦£ê¨È»f¬.؋ƬùAšù¨gŠƒã…w£g Ô‘›‰Œxw}+SFU5¹~ŨÌ+Ö2¼éöD;(Ú¼«/)Úö-)â.¦~±­üSQá¡ ó„&;×æM1c:|ÑÿãmQ‘¡j«v9¥yêè™9«h™ñ—V•jþ†µÑ±U®rÛÀ4¹¹Ð_ymÔ%.« øqŒü[Z«Ü"Z0%Õ#¨e­ óÖ"Vs) d2LMÛê8æAÞiî%ø1€Àh…]Nˆ‚ÕY�ÛV;öuñþYjBòÊ$$-úÛ­Ž@=_<:x ,HÖüÛñ0Ü òÙù·GtèŒ+YSºÝ‰¥²ò’Ç=×%ô‚V·¥­æ-Õ’ ë*ßá~¬Î²2LOòÿHlÇÓôJƒá µÎ~“šÇ–›(°+Ñ°jÖÖ­¢ó*õE´) KµW?xâ3†8 +ÓyâÍîåÉb9 ¯~ôgyº�¿çšž{¼Uvœ?paçÁUæ ™å+h<ÚëÒ}âÆŒ¢L$2›e¨yg›RÖ@ÇGÍ:+å[Xd¿DǶÔÂ`Dh»S[yFs ÷­HÍBå×r*VsXÜšè2]2ßj+}ø÷Ó°ÃT Ÿ¯Q$³ÚZ -ø±cå„’HoALJ]ûÅc'yAAÆL(þS'9Y-"ôÅ,¹Á0Œð?~ßxÀ7z œ}oqZó‡omh’y¶–5{Gî;5ª-F>\pÞÖNæXÂ’%—£²… íßH2;ôÛʼéúÝ`!§ªS%-ØñPŸ&›dH“mz£Ì¯Wbz{“>S¬×Dò:¡Ìbw„Dh+LCdï«ÒkÑ6 W6¥QÅç6nE¼hk8oì¢RœóšóŠuõˤN�2‘»€»<ܸgš]†.ÈóටÏ^n¬l&`sšÏ~®šÆÄ]ÕÁ{¾<ÃÂÙ` Q‚(Ýü¬ë¼%÷ú±Û&x'¬+«Á³®ÚñØ1øλÔF¶5!þ†V|eõš¼ªL_)èÀÂõ— bÿío®dÙ†G tg†w¬fµjk ïÍiükš©ü&ÞûÞ_KroÙFÈü>æ$(º‹‘J è,�’\õ×D,³žîêö‡ðíËSõ, ñÎû$ âÍI4eT”¸×¨À­N¬AyЊ>Oܬo¢ŸÁülbû½_zN„Æ‚ŸÒ 8ii7VTÖQéms}:Ðk®Óp²mÁ±Ê¬yíÿÆö§¾‹*ñLº+k_ÏC ÅÌÛßðíL¹mç<1äòVA1jÄU=ŠÃ€z0ÄØ•"3nycHó_²Oÿ#0…KY`ÛÓc‹‡Ö SRAí¿ÜEÈr{ÐJÁBçO}zä¯ÞcøÚ5/½~(/àsiÕy¥5'²?LÚil×À˜KÉ>w�=ŠhþÍTÃOã(M %Ñ»=£;Ý$t 7íä ?¯u@²Ì³Çqb¯÷P¥ê&g3^¨ÖE³˜‡P–àf²*Ìùlº%„Dy¹ò$wéqŸjXŠÚ¡%¥[ÛÝx¥Ð�âÜ#Hî‰Ý'¬h1Âïöóä¦t�ØžÜ{NÇÝ—Üs5æ`4ƒûZ ª<‘Ì°4Â=êöÄf†˜‘ã»1ÙLÒBA[‹Æóèxa´djå dÆ ,h}²X”,{Ÿ¸¶à°ÅÉŠ< úhe…^Åÿw17ªðЗ©ëY¿ô/²(]NšèΪÆÛ¢,D¢ 7khø×m¡þ/ôEd �¦¶ âYZ²‚0}¢i=V?ÕÕNC‹¾O0 Úl̓ÈYu€þ“LP\úØDpIPAèµ¹�òãáx4æ•t}™ºIêÉÅ¡T깃d—âØÊí/£8rè¡ÓÚ½ ÊÎ#™�J1½iúi ÔÒBë\JÕ×n¸|Ïf‘›¢³û1ëÛ‡MeÖ#ÚœpJù½°}¶ò±,Ü뎀¶Ôi°×2’ÍñmÓc†Î_ªš)%ö\—_ê±%V/:)ç1Ë«ã@y%uCÄû3/Z¨…�4Q’Ô÷žQNݶkkŒè…žkCýFH!\e+Ïz¾FŸ§£×Ä]Wô4vèˆKlº´‡?;íWÞCfE¡G1d uM¹p9Yc’œ(©3‡‹õmõnÎCÉ0K|áCZÉ8YÒ^yPðÑØMnÂÔ·g‹ð+œùYÄœ":Ô'-ùƒŽºŠ?ïlÑð=¡(ÌÕËN¸®+Ö;(:M!0«i˜Kë5¾§ì +Á}¤)«>m½xKÿÓ]¥uÚ†øúÊ+ä½{Η~O#J¥:Tc±(UÈlêªÍl´1­EóOÊ“(,*Ø”«–¥ªx‡ 1dÖ;Í“áß Æ*·á‚Ý]Ü: &±ÓÀ£Þð¸µÝ4ôä�¢2Á ‰ƒI|¼KÀèÑ Ð\»ÊŸ+c4œ<=…+$þ‹¾?Q¡þÛjaRk_¤`–³¤Ìßµ-ùû£~wbSì? ÐÜù<×Âg2â‚…q©LÌôéO,o¶@ª’Ç0')ë£Ué„óÕž?;Gƒúí�~Q¢ñæ¨' ûfÍ©Ù÷ŽâÏaîPðJ~GÑš³=ÓoøÝ„&WWŠžlÏ[#f¸N8:‰2ç!ù’:ÂÕ*R!å'e§°«”ùcÅpLÙ*m„üêʘXÇú 7cŠmÝ/)¶¢ä!3=ô„Ÿü–­S C+@Í'Øà äC¥ÁáçE_èÈÐrciPÚ *˜±æaÌÒ2DÙ XSC;gk‚7E>IèØVÞÕb‚•x}Üän•ƒ³±Gß¹²Ú+?lV%ñÒÒ»¥üV½à,‰Mç3Oâ¼Åš&~±®‹ lôã'LɵùåL0G[Ø0Åy|×Rw.4©ééM#„SNžƒFÇM|–îž ›™ 4Ú¥ïë]ÞÈâù|_®ðû* ²÷Æê. û¢[~<slÙÞ5p¯½S%G–²ž)ß~ÿëaÓ)Yï,¡‰ Ùf÷JGïÀŒÓº)ÝTV4D³2Oïž$˜ Ðm65ïþì¸õý­5•ƒð­Ôš�ÂfIչ‚€):•<¼”Ì¢bµ`ad2íÌÏ_:v102:’Q:í õ2­,S¦ÏMü 9Z|;êËmmÜy5MÒÅÕRÓ%Aj aèFav>:êˆ6Í?ŽÂþy¸ÔBÏY/d¢çÚªá0Z`ÚšØnân}ûæcÆmù ­Ò"`ŒÝ„Ð\y~iਬékX/‹o ì‘ ‹Æ¦^èÎlÞdš«RLAÈÊýß½´£Ì©Ñ.¡Ô`Öê'e©™Æ·G;¢ï„ì?WJô–I^9ðã!§¯ß{Ô,,:­! ¾+U˜!cjÿ§–#…hUJ¯È`<rig = ¼ÄwVæyÅ,[L¡h×-¨Ê«ùŽíšî–é÷cúÔ gö'âOYéƒu0¬ Ú(JõÒZñB¦œözu±€ø v¬º7ÁÞùÍÒ;)G*=ÒnO£cUx- 1€b¿÷ÃÜî¶FûÓ’ý²2I=ÿD&R¬<sÜz–DÔY ¼ç)&é”Æ.ßÙÆÈРĶÁúþ¡ö ®;p<Ó†gMûÂÔEó¼)‚pRŸS€áöÀ§•À]&¾ûí†>ÿì_>Ä 3Ûv®C0 : Q‚9©|H=2ËýEà•g›Š÷Ž!'8{¶o¬¼à'±¯u¡ó%„‰Q´ð'I 펖+ÈÒSGo4_£º¿GZ; y¶«2àFqTÈ0ï­Iõí«.èz¬Œñ¡vð|y—¶g±/f h'HŒ«w…3t­œ tGú)0!{çå&c–9dÂP¯ Ý¢Ú.üÈÅ=g%¶Bp›ÄuæY•$.VQjM‰¡ƒtÞvÙ—•Ö©ÈŽ,Úr¢Ÿù†ÕêÇÉËU%ûJFo”¬–I§Õü™áØ»:M;,<d„Š þµé‚VûÉîïX8V ( ê¾ Šö»0â]ˆ4‹Ž-N:­áĉÿ¹oNàµ$YGnš`è­ù(RF!/yaÊ–,·æ‡?«è“ äs®¹ el».q ÆT­Góø0ÌÜwá.ÀL'DÔ^<V?tˆ"ÚLÇ<N?ÚÕ0_¢çáú‚q¹RK@ÉEÕÖù¦+#&eÎÓ…e[µ'øBYf^ïÑô¡ã,HG<¥¬þ’GG¡G½®Îý][JÖ¢Ôë;â@‘Œ“&&+ð*¨lÄî2©Ô¯m(ŠÄÝ#fõ•ò••ÈÌ®ˆ:Röu—Î ^D.D‹ÊÞsO™Ëê8éè¨ä¦/y¦ÎZG·³A¤¼h‰ @¬ÐÑ´_OO‚Ö‘ÅÛf¡5ìeÏcÐåúêÎ3ð†ê~¯JcéGYbäÝ -Hí@âÄ>T³œ6š!Þ&Šx¾aêÉsÃL€qÆÎS[‘±åÕ¢ByÙ.Ë\ºÇòFçTèæ¯ßo‡L„ë ¾jÅž¿ º] 8xäêò` È#5µ5¿7G·óyþ?ô…N÷5Ê)úÖCÆ$êȦ…€ôTŽN0u­òŸ¾çMÛqƒèë…”CçAüuös05¦îàaj)b©0éó½ &L#“Õqkf.ð nÏšÕ±Um+†îûö<=Hˆž‚|e žÂ>5;ÙIP¤í ëWÛcQ;ÑïGÖ© ‹Cži­÷Yέgá<¶™up1#J4~[k]™¨9 ûÃùÞ°#IW¾{T»-íÓÞ–_,.PÉøU5¸c<°–T›>‡9Õo»dáÔóÝ å½ä+Ô Þ`Ôá\±x±¾ši!(;/V@†üO>œœ-š¶ø Ñ×Äyô /ÐéÿÞþÕ:52´ x1º#Y3™4ÛK`Ù²&!–Íop*N#345ØÃêƒ屷Һ“6ô ŒJO+ÊžYvé¹¥€ŒœGÊtœªaäM&´Úßp'´82>w‰2ÚÁÃÆÙj¡|OõÞ“ uw%Çž¬ÿeè½Ä¡GËa¹‘ Cð]ÑÈEZÈ ^;Ϋê¡ÙOäÉR«‹ !Á—f[zÔBÖØlß!­t¿PHéœÚöqÌCíHq}�S i&?ûLä¹=ëº{d¬k‹Ø”÷¶™†&AÕöoª#/”U $4íe|fQ^²Éº¢TâUЖAÎ^ÅÖLGk±ô)XÇú{Ãy´¢´[…ÃÎÇ%ÀÀzJ3%»M~±¯bäÌÝ©¡¥JÞ*Þcv[·œ·ÊAÊà(&ªº«›6`¼0a‡€”bäÖëšaB8©çüëׂeá &±Ì éóµcóJ®¨„žÝÌç’¼Ð}¤Ú›b² ï«ÕÏ™ÃÓ*f—X¹!ÇÝÐ2@E+ëäíß7-é£@þ“±9«†„a)ì^Ï+^Ë= Â\Ì›£bÖŒº†Øðn®D\ îù¨Ý.œãZ}¸K‰3·ˆï0öºy¹¡Ü�1Òx綸2Êq ›æLu»î ¸.æŸ×ÃÂéó‹'|Qºûþå†|Òxö:1¥Ó‚'îê¡cTâˆ(/˜2ÀÉzKÎ9[7…±u¨ÓBÙi>St£æÈÔR]U2†U)$•œ#“Ýîkù°òzWƒÐV˜¢ �z#ˆ$ø‡¾ÖÛbK-™ãΕSšõ’ ž.�rø^ùÓœ¾Qìuøºóo¸2RØ6q´üzˆ ßâ˜{/:&:Kdž.Ð*÷Tô*ÙžpÂ4ºtŠÜ4ak<쥸¨de>˜¼z d´;k+%QyheÔs>É(aÿå±Ãƒ&VqÐ5eu“gQi´°Í? F`¿Ùa>6-±Óª´[ÅjÞV®x÷ðê£ÏxXZ/mÛ¦¡»ç÷tQ|1<˜>m4ê±ßzp˜ïª¹ØóŸ€_'üAÉ×<=³Fí‚“0òºí–[ÐöB˜ƒ÷E)J4LhLD 4 2ë$˜Õ,‰ögwÿd~°£dÉ芟5½;¯ìjž½úö;xV茕-hºÐñžu^ïÏ'­kSd£ðvhÑQ?_ô_†&›<¼0Ä“ãˆÝzp)*á7L‹~cD} Ǩï™~×;=Õ&¦ˆ«ÒgD¶Ã-Tn4Vuu óm¦ã>pj"?›¯šO×!wGg‰¹¡?1(.¼ ˆ\Ï´l'ëÁš &=­Ò«~ª¶,Æ°‰o¼¾Ñ'Y­|Ín`ÔÚ4HÕ6ÿƒ¾:[¸Æ/?IâÁn¸ƒÆ–çåö¯Ç#Çê;¶ëÜæJÞ˜©.÷ÏóÔ¹o³±FO/œGGì68'+5L?८'¡cbÚ1µ•Ü_yUeUéöâÊ`#Kœ2 bmÇ„Å­<·Dú´zäGŒï}1ì;4Rë*°ÖE=Nu±ŸWµ.üi†gÆ5Æ!÷N–\Ì 1<ék³šêOEÙ¼PÂ�"Ý@DZ!bk…O-Oø88'MëâÇT}ýÿiû“õV•ek�m³ŸÂ½ÛÙûÿ¨‹&TØd@SÖúîû?Ç‘‘™¨°å¹Îmœ)ìµ,Afd£À”ºû§àÅ¥S5åd©EË0üRéA8WI6Æq’˜6gIíKÝò2XtbáV¸ kÇ%ÕKû6§ÊXk2c`ãéÄ*º~«…q•|³ž[ÂEÿ)×ÚèZ°¶ö»„2>ÕzêÒn1)ÓO5kå¥{@hpË#k5÷N!%2� ¯ýˆW¤eš"‡jYŽq_ú©w Ž³Kt瀄Á’P­½x€z-ŠÕ�ŽÖ唲á¨1ð±}&Ó[ÊTM`|«Œ#�¨pÓWÁO>ØZž³kNÎ�ÝOŠ¡b÷Ö89}KóÏÞ×ZHHkö)C”{íÇ#Û<¢o¾FY°³±æ\êÛsíHÝ"#~V}eRN²ÄÌË ®–íTP!ÉD‘`®FønßO6Û—¥ÕÊØ÷Ú„ŠdEÕ¹ufcëV4¡±3WÝ!Íï/n‹¤¬*}¤uø3Ä}çušÍÄVƒsp­™àa˜Þüz£zkÇ=<ºg«YÐÒ-ƒPŒôðýL|†¨n6í<TËòÂ矶œd§Yè‹…epÙAÖ:vÃlÔ?Â'þ$ÀæA±w@<8õôñO:—ÉèXO)C½ ù§`Õï¶<󧿀a£9ÕXÛíŒ-å[ Ĭ'ƒ6žî°4vãI»Ž–c4_ÌBØ[[rm"]0=¥[¿5|wuWüf¡Ò«Xv‚–b7@ B18‰8­Ô}S[˨ê¥()}ìJ”Ó†Kª ]–(ú"†qÎê«Aðy{ôf¿æ±¯Éƒ÷9¤r}ö dÇzCŸ¥vê~X ,ÖYðÝ/^s^¾È}‚ɶñ§Â'3ÀaëÖ\ôÚá43ÈJ_Sú Œéú.ÕÞ* àˆS‘ãF|ídºiˆ.æGú^ýäù˜™~XIqLo<YU68Ö_[8‚©ãEýÁGdmt?ú‰yf½ÇF&ƒJ�z½²þ“ª;mEiì$gL Ex›{Η«ô„õõ¾ X«¡bÄD˜öÓ£qÞ¼•à5æ€úê•DÑŠr¥&”2 j'^km- AÌQÿ÷¨¬XIY—ÁúnE‹X†Ò'½b­B_&å×K…«m ^7èÎØÜ^ƒó©¦ŽÝJÅ´ó—MVšîxn$¬/,¼×µ³rÇr;¹5ÓY¤FõuSðœ„,ò|¿,ãÊèÒÙDµïiYV–€ÉÙæŽÀôPÍF©•2Wˆ Ê°»k;Û<#Ë'CQîjþD,ól\‘S¶2˜ÀÉÖiÐ…€á•§îw9 ÆgÖûáYwÒfv™Q(nZ°]­±T$Öܬ%LIµü™Izà@S}@¦ieoûà«œ_/ŸÅó àÝ`†ˆ¥<Ñ«Ý*BÇ_ÞN/î, “0 ‹B&BÒxš/´ËÝdÊš ´MÎeŠ¦4nh˜=Õ×UïåYŠ—N¼‹¥°‚ CU´(Ksèùß·-U`ËßænI#d Ý Ã›TiüµˆÏ+8®4u¬\ ’èëÁïAE§;Uh~:w�íkZ:ç¬î>dÃÐMw6Ó¯84'Iä»ÈcŠL•}hÝ°ËÛN&G Åy,gõ§G˜ï~¶Š-n¸É|ÅÞlñÈÊ°óážžC­ž_:J~tµš*WÕª>,QòdìÕàˆöªþbÎÉ­;’ÜGkÞ2•AZ_|Óúú̼ŽÁÉÚ@}×=ò OâÐÏÍiÿN»4(šÚËué@tû¤‰íŸ‹´EYê減Hï)ðÿ3{¹íDñ¬;ÐêæÈ5Ôûù%ÛN|¶ðX“¯í]ú†¹b1L7wÊØDÍL/q¦×íu>"3Èà9¥ s„%)ù kÍXEÜ^Õæé^²aШäwuŸWÆuˆ»£ã)¾L€áç‰õOÙ}G¡ÛëBw„­Òn/i]®íjRê†ÛÃ"·íÞ©î·?B‡V×�d+Ù¥‚•R1ó”`¸tŸçC_‹…áßò2rž¸#Ž¤¿X‡ÄŸÀ‘;A˜äÌE”—“jù…¤@—D<Ïöì6)4|nèŃ¡VáQ°øë0%¾ì&=îÊq/Èi' ¡�5 »;áм(s]ÙHƒ!lCo¸<]- Oª¼‡>W$*gsóêäÐPIg=Ý ¶Õ¦·o¢æl+Ñv1"??äõ‹ %„q%åPPTéŸópXÞ øçPów‘vÞQ%e’±K+,svHɈ⻠Îÿ‘OJV9›§ ÚÍ–•wÞ½2ˆ2$ûgÙåVd`ž—›Uèk°„ª—°UüBÉCKÚœx×nú;É?mâ ÏfŸ"äz˜‘zSƒ…&"LÝ™ÅÎÝ\<@L&êø-#�ª÷yYØsıÁ˜*Œ÷ÿ/À¤r¨Ñ\­ia$V¢¯ ›ž)š"p‘]ˤe2Ó6äaÉêâírèÍA஀Åw•$£ÚæhŽìíVaž¼üãŽÄPèù„¨ˆ³5gaÙB.ÛÖ…Õy:ð”RÔË)rŠƒäeê(¥ÖúrІ+ÎyMµ7gæõ/œkî xDªà—ZI‘ÝЋ¦œå[/ÒÉ*‡$t®ÕCÐB‡»?i¯°SVÐZm')b'®´>œÿü‘7~gÑæ é{X[æóùÞäLBqn=zÙo®E ª"å/JÏ vŠ?p,±MW&öªI ÛZ¡à¢‘Êüâ£e¯j˜—Vô΀DèîT—Úœ®1æy</ÆŸšÎôÿx}’%qæÙáÒÒïgîpX‹>ˆKúñ1ãlh\œûÊ]òmAÊ,êÏE~ZD!šÁè8¯(Éì’‡ ÝœéqÛæÌêx»=ëRO›½`Ñ æwm;$DIv¶ \Epcí¼Þá÷D†è?¶C#ÆÙ7žËw=Q£( VÂ4HÉÑI™éaÖ‹–/·¢íüÍ>éùDëµî}y `Çv‚¤î³¡ë•Ü’µN‰³c:)“ìÔŸobÚª=4}–7‹²¥¨ÃAÍw{|`²®}Ë.ªpÃpJ(1÷§«a](ø׳ç…Á>¬5W çÙ^øŒÓ8sf{´Dç% b«ˆP´ËÜ ²¿ÿÑÌ—M7!h÷q¼·š…й½eVª%ùW~³ITئ±x”©ÁâñêG~$šúñ&°IìS•(]¨–‰û6™sÜPb3dùöÊîæÌãcù5Ü6û½çüÍÙS×E“6Z<Z2}ï{ZƒjA Y”º#U7gIiA’]#?C3†_›ëá×e C…kœìݺdc!Š˜7eëkÿÿŸL¦rSXÒ‘ð€ +Ç) †2Í¥ +@d™´`x¢ù;VpVÙEaº; B;ë®$iwoÿÝ„ÖQB#š:ðìì´C¥4B© ÓþÒö(16.Ñ(› ™ÊÿfIâ”ÙM`}üdðl;yüç'õéÓYSæF]~³Mà²ñnçØ|ªn8™*»Ûbˆy˜ë-é׺‘jÿø¶¹8ÒkªüŠM´3OâøZZUwñl¨$5-Õ_SLL7Æãû]�öV£à¼à'¿¸§JgÞð`ŸèiEq®±ª;4½ÒA!- ›ôp‚)µ&G0 Håâ©¿B>‡+ÓP€îëzlE¥Á;²LK²WQ!—÷]½òŠò~mQŠb)ñ£XK¤ê–æ°Å2®ÜyÂÈ›‘»iÿÒ0ÎΕDo!¤êÔ§̦Üø„î(ë¶îëy7³»xj¸jDFŠò¢y¡øåi¶ð©ZMqøÛ“Ò"\唧F‰{l5¤Íôäøcú›=㶩U(ÿIs¥ˆëðŸóIlúK Ùå™ÅœÆѧ3H¶ÓID<ñKEa?¼DÝçĤÙMvØÑ)µ³ÇÛÀw ðcES ÂÅ—Í4~¡cõ`Xo—ŒàÙÍqmõ‘CÄ-;fñ½ýòTŠE¬ýb1V¿çg¥ßµ‡/aS0·Ä‚Ëgè9®&E8ù¿WT{âJ+‘n¥Ô8Í)#[<)7§¯@Ƕ9½\ì2¼_›üF¨¼rOóÑ"®ä{±œ(‡†)œ"tð•–3%GB=í ˜ó;5×8‹3åo!ÉIÅÝ0Y<mnÞ(~õ—ΆèP†‡“`¦OÛ†¾EíË�Ÿ®&û» 7N#  «º§ƒäÚx6ÈK}ímÑKÅž'etŒ§ÂíÍ úo¾`?têjÁù ÍÅf²`qÍ0@Ž©«¹R%¥å‘:Jæp+&r îgõâ¡F§nçÅ‹ŸøúiX¬ô‚MCïrPv\Û½qccMµÇ±¡ FO»Cd¹ù<ËÛ4;Š×o*“û”~ž¯žÑí~ X!…œ²ï—kKoÑïè²>» \ Zûê¿«tÍ3Zß´ïß­á.½){ý°†ÊéD·—Š¢ï׳ –¼0àU ÝãØf�<1,„TóS×nêɼpBiGnéáù…Êš>U¿wžÇ‚ô²LEð O;ö *6›+¦|D|nÄX)Ü:˜¬ÑðY¿x U3&Ò8’ ·ŠÛHìŒÅIä?ÍãÒtbEJ.ÉÉ÷™Û_ÛnÕýIVÄ‘ Sãí1~Áæ­©}˜jp6¨¤'±È€Ø]ñãŽôIsßv�3jx> [áG,à&¥Œ:T>h ~Ó"ŒòÊgÐQDëéÏäV 1òHö¦Ï¶ã·»Ñ4«ãÈIôJË%ÓÿÑr<‘öš×ï}ÍÊ9+²{ŠyròíAØÝô‡6Ìx—«Hìaaæ}銛w?•›àœãÊœyS[§ÿZÄU7­ðË0ÐiÓ œ¤úÚŒäë”;¨Lá+Cr‡ìËlÏ;cƒW7wéÏCg¼]^f)•Ùj a¼¤ïꃅ¦nZ>u?h¹¢3Á ÁߎÆþvdßÇÃ)‰ƒ¢÷ˆËïd”௟»”ޙЙ¿öÂ"h‡2ÈΪ˜ƒMÙžtULxãÁP÷âX×Ý ?øê¤8Qc—"öE7øXåž…”æ¢0íd # a§¢,Ö¿W–Ž3g/Â7g)de‹†ëg–”É™û—òé‘dYé~^é»UÅA’ÃbN³Ü®ããŸ\¼RÚ1{ÿÔÓiQöÖ€Š&€ 8ŸÀrÝ«lY³1[ ìÚP…Û` +ž?(¸¿z­3دû[€åúîÇM`ì7Ù?–,(;u?Â"_Ø"X¤9`ÙçØ߽궚åο-gŠKª\EN„ákÅòšŠ}蹸r(B“1ÛO[ 7pin!¼Öa¬²Xû!÷Š† Å Ö¶îY�ÒÝ$’W«ìõ167rÞI•9@Jƒ£“?4¦›Ë!¥ç…?ïRKˆ^Ü"úÊ̇rË�ø‰|²…(èþj;pßníîràÖü}¦­œƒX$Ûúßâ´ÓÓ9+ÖõxúNSáá<B_Ä$,)Á¡g´L^èÝÑͫϽ¾¥f@O3¡²òý”UjÊѲ³æï¹iÄΗ€²ÐÃÐBüké:Ÿy¥ª}µV]ÿŒ‘:@£iº! Òi±\bÞ&>¹¿!üä¬Àk¼:@ß®º“݉Ã|`§�¯Â~<ƒxÉW¥©(áœÐÕ.l¤‚82-ÚÆ*úÃd¬�h ¿ua\©y]÷ŒROÿ=±§Ùûâ·Aöݲ‚á½*"œ–>ƒ��…ñb«çi ÃJµb2‡5ø¾Í„8¦IRçº,~ç¼YbÛæ²x³SH¹¯PûúÚŽNˆÌ¢½W»hJ'í’òî)‚°nT`.…#�*Uiõ§: ܈i6*¾Ž׋yŠõi:Xc1êB{ 5àþR $ YÁ#䤤ó¼¤ì­Žæ°£¬(jö.weºhG6W¶w[Üœû)¡Q¡-F«8º,¨vÊƧSšßà/øw´ª4/J€daèÓËPÂÖ”c”'%ÆÒ¾FÖ(& zã&gþ? ^ù™E”Æ+›ã9(²‹³ 6d‘bÚœ¡ŒHÇŽ9òWwçÁ¯Ø½ÖæJC¤8—çÆkÆÛ 9h±q&i/>€Ófè¬M+0Öó´;ãíÅÓÁ:£x¡ Þ×x,žsoögº!å0;¤nH79Ç­¦3#`{ñ79¥sé¨ d¾Â™X!‰edèW㙋§==^“³?󄮢ÌS£ï²�·jHœá<¡*Ôjã¸�-àù‚)‰Ú„‘©ó®Æbv웎B‹ÐM_¯òbÏüYh &+E…N7nž ÝærL¬ßºŽE©':ÈĤ}ÉõêI%õ‡äÎjPu†NaâOt ì…IØ ¤ãVažfjN½ù¿Ð„1Ã>Öì[u–Fºù¿ù|ê¦ÿk#ÇvóHpˆèv-’ŸV}LxuP3,:k4§”Ö§ Î%(HË’,rÆT<÷‡ÓIÜç£ÂüIDŸ¨ì€9˜¼ÚÀWðnè+c“é»b1¹áÒ8ºózÚ”¥ŽÕZ Ê5 ‹Ëlû‰©3-Xå%ʳCç\úÒâí,5§¨Q S$¸J|PÝOüF_°”f§Þ-ªÂIœ‡¢Fˆ9ïÞZÅ0|ÜX×qðy†T®ÈÔ&yïþqÁ‡5u°%•X'm¥Î‹jßÂy=¯˜“œ) òAïw8®çÓ•ù•Ü¨ ðRñ®žLeNÒ‡UÊ™Å% §‘WÚD¡$?’«0Îýt@JDªvðšýûÑ?R†„ÍÄRõÿë0»ÿÍ‚"YÉcõE_LíIC›ÙjTN©ù$6×/Ðf÷03¼ôùH‘cQ}66ÂË<cÔ]a¾½×öaÏÐõË-ÁÂÍÚº2¶[7–ŒÅ°}­8L?ÅCwõ¤ñge¾¢ÐD‡KÓV8yÍûK”Îs&ŠgÆöR¢ïn®ß$Ÿ÷ÿ%tr)rÑÞ^³ £³^H· I:1xðÒ¾§<4hÀ äÌÔ]Rø`°È;Ìö•K/Ðöª‡ÆŠQ¯³¹oÌâÈ#Úsï|×Ó½/­Ñ^&‘Ww)µ…>uÇœ\ëú½Ö%þ0Z RTògÝÙ‘[DÔÞ"ëk•#5´oåN*hÏ‚ìã¥�Å—®mDæÜ­²WÛˆ/úò#1W£kXšf2Xš©]RПè¯tʘà:£Ã‡Û‹àpÕó…,LŸ³ò•[²j1¥mS©"YèRÓó(ã Ÿ (‚yðÆ4 Ú…BˆÅ×L€º\èhË”Ç3Mf²½÷îÁL.É3ŸM敱快 �Èœ=³6NÐ×tŒöhoÝÒŒ"Ë4Ó1è8}zPF8tVìî¦ßþ¼ñnèGJ¬¤ :íbXø¦@GìIÐ3ÄâöÀSà‡®ØeáY’ÃѨ Èp2TŒ„…Ð=i¦W è3yø¨H@Δ?~®šDd4lms^fg¼¢úã%3< £"R£¡ö€Ü‡?õ�`þj¢äÅü´×HVÅJ .‰‚n¨ØÔ‰DŸΆ‘1ÞlÚT®›F8ÞOÝé„Çô›í©—x%NØÍ&DS熲ïi‰º÷“QEî³sÓpwFÓ°×d,OëàÎ53p-y†òê6€iàQ(¢nY¡SYdi÷ÃŽ*3—x¤@Åö¤Q(÷AØ æå©ßtmÆÑsF‹ªÕ!24ï§ú8·ö(/ÃÁs·ø£ÔC|ŠèÞÇRaÓ[gJ¼Õi•SÓ©‘÷[ËÞtj4`ÁÌ–(ÉÜsô$g:ÏﾸÀ, KÆÖ¼Nãf¿¶ŠL  ûÓG“t(f:]ÿŒÎ‚è2u_Ëo^ñnnôrCæH'*£¿]1äȇ¶‚EÀØezT°ü õžùzsvZïxõJ?]ež½ú‚æl Á.I ~´;Ôäa=+ù éÃ'³´ºT5§]ç¢Õ®›#›§Eµóµé¦Ý«"—©ž¹É- šî/ž‹òtö,>ÿ/3rd¦1›¡‰”/Þ.Ÿ¹`ÕZ<â£|¾7CðÕ\u3ò ³âS�¡¾××MWÛïò+ˆà=bÐ"Å“Ö,p–,³q쌈gv:ô¯Q&¸¬ÑÎ4-°ÌSCÅœ «Ct=ý¡/¯yžC½6ÊVu?Èî² Wz]ÅŠ½›è`ÊÂdú}]!Ý&·_|§3z÷xƳ6Qê“Ú±$�ëbà{æl �¹ÛWKdÊÐzZƒ~xdß)-ù2 ÒÆ ›e˜ìÅÉ÷<oÌaa1håm­4g#ýz2­úbÑPzÂ^ˆÛM|òp´n^žTRÁÐ6âð­¿¹MÿÞ(|%AO÷w¶VD,Ä´&-i^'èGÑŠ¾ÒáK5y6ho÷tø0ê!˜Œ£ …ßPrΥˆ>à°QY ±ûöA=“$±ßÁ£tI‚üdàˆðØð¦Gý|[ìÈvG‡O÷•e3xa÷ý|²ùf÷¥Ì¨î«™ñ{û®ÄC›§L'§ [Ö“­VúÀ @M.'Q[šºÝa^ÿðÔÉ0¶vU•ñq¦Ê+£»­DÄÓÈPòíaÃ(8é3eØZ®<Óäö«PÜ Z*}SXEžiߟoÂ&mJ¤xFŠy² 'cB(×›aÖŠ±öð—”d¹/ˆî>O‚¤›=" céõXYAéòx+o[¥l¦2AóY—MÌsBFW»rèú7q$R‹¦ïšã' …7E6à(âbzë¹Ùt£]öÝð.*c¡ÆË–ŽX�½“úâùк ÛOg™6l~öŽ|Ÿk±üéò zÿ2s¥œÏ $Äl,8î‡^n‡k…Bøz§­'S„ò’ÊÌŽÑØîÆ�å;W4öá{pßç9Ë€™í²ºÏp`˜Vÿa{Üg“ÕÒeû+†’¬¢�¤½™gžx ÞŠ*”òUMg‚f÷y>Ï>á"æù!5Xq3P¨ -À‚§R\ë4åÛÿ±*#Ÿ$CܪO%KÉצ}®§«Câ—J%šßØguê=–é—óœûú@ Ê)® Ï-f¬Q5}ytj߇|…¿ø dTÀÉÙD¯ˆGW:åÃüõ :òu�cOÖƒ… ò”Ù8Uœ'ÁÏ$ß½'ˆÚ…“Ƭm]­ÉÔ2[h¾”3Fyéè ±ØTÄC³¶OÂ+éºáM êkðy†RwÊ_T{u1Y÷Œ)=v1¥ò—Ä@5ä0cÊTšY!Ö ê’7¶WÒa8r»Éê÷Ä™Ÿ|p‡§ Rè+ÈáZ#™Àm…WhîD«ªMHhËÐ:Úz·‰oϷε,¦+dq+4“ËkîIi4(‡Y¶Îêa3ÛŽ ­›<v³wù\!Õ¥Öü›öAø©ŠÎÔÃw´‘¬>ŒÝ´úÛt?I2 GÇ(6WÒ(*£\o®—÷UT¾[dÐh$•Á1iáUÎö­ûZ:žLþŒrŠCÝ´‚ýˆ ¯šÔ—žzZŽ )”e0Y_ß,”ߤ‘e‘ùFöeÍÞVÌü”îLmeæÕôHƒ¦›Üþö ÷dC–{ìË ›,ˆ8 T‹ é˜بÍ]>WL+¿òˆ¡ñOiŒµÆA‘vÚ{sÛ19ÃAÏhe¬~x®øïyL è0 ”ŒTŸÚå/˜?2wÓŸñ`Š’GÚXß«d•¾½þÆ3°¶ñ0 Àw³eV+›©Ÿ}n“ÿÓ#g‘ØŸ²Ñ)wa8ÇpQϾ‚ãNÝ“sví`j4#øƒ\ 3¤a8ôbŽJ¸*F½¬ÖvÚLžb±[Ê´Ö—wó¼ÄK͹jfØî;ŸlÍdcK�Œ{– ª”‚ÿ&YpŠå¥=‰âλÝ©‹.V|õ׊;v)Dn˜¨h/NŠ<�Ñi:wÙ£à`l'Px¦ •JwÉc"DÏžÚ^^ßé>þ.õpì9¶1öžvÖ¸–î®ì8œÓ0 Ú[öC3~¡'𽄟£²fj%Ü¥}qéƶ>LôpŠú›Q‰ÕÿÄq”ó{×´'z‹®ìzG+ÔYâ~ý”:¶(lWÁ2P>Ò¨;:wÔ ‡ßè^ºYË‹r‚*øªÑ‘Ö@ø~öôYÕ—Ó¤¶²ž^må2EÎúð‹ ´—óÅcq—UFùæ xt|=bëø¶}†®CÏ*lü9Š{ÑðqŒŒ—†–LÙqêÜ€W!eV͵�‘‡®1þÇ'F'FÏí:–l²ë††è‰16dG›+}]÷ïàVúþyè.È—N_z¶B`üâšA£BKcZýkÖ@e¾|:ƒ#œV “­´­¿Ô+ïE™Mk–eýŒ‘�Ôª”³¿2°wŢߞ'†)û"€?d� VrQTyÌ#™›Îf3†Žx oŸÜü'$²ÌC1ËC>Aùl°F«ÐMÙ¶žêùrßzæÌo.G˜x`p»­;÷ 5#5pŸ-†œSÄ6Y‚Œu{\Ü0ªé$“bÌ.ŸÂY žÓ1|§ Š½µ©H¹ïЂÈl•cjäBÜçì[ì óò˜’8½]ìöSd‹âÔÆúƒ–ÄÂô ùiB¨ ßàrí~Ð4ŽÒÜoŠ Ž¶YÚä¨ÄØ Ýsçyñ|Èo�Ñû^`¬¹j ÄÖ�XaA<ÁûÔ¥—g(›&®þ4À‹³¨ôve:› •ÝÿX³ÕPži£ÊïF/Í×ú%BÇŠE¥F·îpJ‚rךUd¨…^í¸ìtžÚÃ,¬äs:Ôèª{_;2Ž>„uÍš™þ),‡\…mxÌÄ{ì KR3- aöl»ùÑO®+>'h£NÐÓ”4u/ò±=÷â£ù{R¡ ‰Ôœl§Žˆ¸>yd\Ü™÷–Ù�- Ø÷×axþƒÙdô ¤ÖQx£è´?Á´o¯Œm æ¸›kZ+-õ…Õß`é Ížwf‘‹,é‚éñ1ïÊh’,bøðHç&òˆ»½vHbnÖ«£Ëº~v€¬Ýt8ÎŒç—W/™y�V¿ÿ=ë‡&6—‹…úXù§í^ÌGgÿ:KÅ^ŒgðkìÇÄsEb‚Æ“ÀOP»#ÿ0JÜoО‹Õx8LDm:)lG/ŠJÑŽ¯íh鵯VŠjÊçæ%§LMu<v#Ü)Œ Ež¼ýï­ÐC=³n¶è:G£‰¶àñ`òPÚXù\®ØÉ ó~þ 4®;[£Å¬æ“iÈþÚd°ðxh @ŒiHϧs-øÓaóÁŽ¨æx—ÛcúÉš¶ròDðæ[ »º@cÁŸ€5ó{aÞåí ÄŸmßV,ù•ÒÂu\K[šÆØU¤[ü t³‘K½UA‹Êbe� î=ê,Ö33ù˜j¿ qÿ1k$X ˆ†ôyJ<ÔleóËßY®daV%¹IÚ*F^£ôŒ¶jÏ5Õ¿±+tÞ¸ÖG½Ýio]¤~„F3ãþe¦¿5L¯(²%#Ûä0¦Þ¾ÞTÖD/7yÃæBÚê%âÁÐß¿2PÜDßW žqê8l­J2Jì5�ç«“:R5H‰RÎÒ?£ºå¿ÚEæ—Kt·÷€¢w :C&Ó J`ÄDëEû‰(¬2Ÿd†žLTýÞs¤ù#Ì"kø*}˜×G÷¹çGpAI]Í,­b綩£pº<•9rBò&\ (º¿ÿ O~Wt§„a¨ü\­Ibjêàh"‡Æ?»¢Ù‹Çysæ} ÆÕw_´¼Ón²�UÈpûU~43K<<§òH\ãeå̹-˜|êG¦Æ ¡µÞ"mⶹüûª’\¬ÒHF6% :@ÿlÓ ©~ßÆþ±íO}£,ñUäàª:¡©§ÃˆcÁ£–0g̉ü©|W,‹J°�1¯U`mH  çcÔh»ñþ¹8šX"úÐ:¤¨7;Í´1ÝG=ÁOR±f½ºGGt‹s¦ Ãv¢,Þ’†­‰„RTÔ>¨!ª¥‘ÇjlîõC´OÊÐ÷KXFÒ1Öm]/mÕÉd»q€\ bÆžøEfž JgT&aPM:R‹¸O1‰¢¶‘좄µ?ÎøV9C´çn[˜ÖŸØÈ̦†E<_½EsêOâ/âNèÕ‰ âÁ©ßZe¯™Ð¾Ø)°9ŠÙ¾B®«ìøã/Ãÿä•K‹îÝf[‚Æ`fs¤—ÁrŸèËž¨>LûŽ>ü¾v#Ú©OL)jW,¾er»Lú¹[ÔFOÕúºíDh¡›Tù{Öe„®Áuñ¤-¾ùS‰…Y"Žb^dÔœ›L †ä)Âí1-Šr#À›Î¼Àþ!â‡õ>î­1Úw¸¿2ö•(QY>!ùb½‚ø$gúP #èp{œØ„^÷‚^[ìdwÃrìÛO5Žˆ¸ã~9xò¤(P ˜ä±*;ÝÕØã~eâÀ@ [{v¬bÚNÜù[ç…(2BrÆy& ŽÐŠÈ­@0c>Ž3åȪ¸th…(÷èÊôSÏíBdðz¸¢ç×Þ³”šF°C|š~«1~bº>ô»ëŽ–yzó©þÞ©zMÉ£´º§­ôÕ©\néùö€ "êD÷…Khóò]kLºVï)š<‡iʲúÝT[—åG¶¢¶ã”Ç™w•¼í»`ßmìlƒùó Nj7ÐÉf2cp…ÆúÃÌ�hñØ„Äè¦Áp¡Xwž`#·’—ñôƒP ثΊBhWÓž–yÞXõþ2Z!ºG1çÑ×µT„óST Ø̈́㶱œƒÐ8Ô:!ÃÓYl £ËÐÖJmûUèÏû: ŠZÇ<”“ÝÓæ€Ú 4„åg¼åD;ëâæâxøuõè÷c<ë¿ñ7L3$ƒ ‡Ý“ëY™8ÙØãéý¬ÔÞ�÷ ¬ )wÖƒ]*¤lÙ›™ä‡NCªåfß®f¿£:¨Q’ÙÛ˱Ô6n¯îò‰ìgûú^ }Ъ ›ÖÃì.ì` ÒÕÜ3­X}}"¿k‰"ŽL9ót,üæ&©?f…‘…bb^÷`Z>îe·nt—è ß+Ó$O˜µŒ]˹‰Y�óG·gìÛ¥±ó;¹% ¾uJŸPÞœÿŸ±Gä¡©æÃI8‡ˆjÆJ¥§̲}„ÈÂ-Eøªn/µë˜b¾Ö@Ò^Ð÷Ù 6ÒÃ÷9Ól.÷©pÍ3Þ)ø|þ¸2½ú—˜À—˜(x«V#Û«ïëûÈÂE¹xŽÙ½,d) S´±§æ¨ññÖ(E(LBÆ�D$ËÇ»ƒf<Àjä©Eu ä È´t·xÞ-GôùìDè÷€4‹ÒÔ+ZS•i•eí†s@ÊUw¾%K 5Å‹¯•ã? µe€§„56½½°Ï>¬2§Þa�JçVþÕ;ñtÎüÙÑQ®–Qç_óÃqKVÌJtªpweœnŽøq¯"G* }¥Rÿ0,²ÐÞVïu¥ŠÖœýj2§îo'ÝQ¥üŠÊ¨ßcÎ[N““ØPV®'Ç÷Þ(ª¬WÌU6j›ŠÈ±·È7õKM@ËÝ”fO™ÿû? ‘‘Wðû¼1©<޷ʈ)WÛÉÅ× 7s½î.@msü¢LËòЇœåÁñƒþ)-÷É:üæ)us¦^Üú9Õ;–Q¿ýù{AÈ4/2çDZ©}·Ùé§ñ´gày»"ÜnÌÔäéç9cQ@qhìú™N’¼ßzÔÝÚu}küæ:HÁ P²êèø]Œjï³åfKèØ3cdíO ÕŸt3]ãÅL-ÝC˜(ݪ{?ö—+6íË~Èè™ì==˜¹^ Ìa÷ìÕ~lߟ´d«<QO° Ôùq;ꩼš×‡’Ôi{õØG´Ú©kMÑýüÅž÷r6Yïmõ˜ˆé k€+΃™]› 8Њ”ë-ñªôtjò”3=[ÒEĪx¢lÁ þß8ófj&QãWŒ€>x–÷ZýëE·Ú‹'<˜*w7=ÄÛ~�Ô’Ö F¾]eïäÔæñèÿËŸŸan2Ÿ�õj‡›À:Eà­^¹ôŽÅKVå<½ÐþøòÉ`:àÛBÒã^&:=íÓÆ“I˜ÈCMÿù<Ù†Ö1SÚÜ -ƒÐiåÌ×MÍìE=©.W�Ç‘ôþáYûi¡v–¢ø˜í5B&àÔHÞ‹j‰|¡!ÖögzŸ/Å/S½a#e<6¨AîRÚ¬î̳{ï_0Pœ tŒ€´ëéÿ3n;o”€"6ëÆñî€) SÝåÏn•ãäî×i¢ÐšØ[ƒÙkíP'sAAÑ·¹ƵþÒQaò©åô´ÚÜ‘ I›Õ™ŸL®¾íQP¦Î5½¹º òVww‰¢§³<ë€òËKÍSŸÇõ¨[T…!+ƒ0Tv:¯¬Œ6,[3 ajO2V?|Ër �ÙTª¡:Ìò"Tó& /Ö¢åÏWY^8`fÊ4û8ÈfÕD(”Èóý÷­TD™ÂZþ2}Q£ÝHNø(h{J'-2 ¬‰q¥ÛÐ #—JÚë›±ÞZÿdÄm¿ŽVÜ1.‚òËÚÕAúRLÚJÆÔƒyD¯B/]2c—•ׄȬ= Ù× ½EèûoÐv§*‹–¢-þý?Ïõ°xj—mmz¶öâAAeA@Ò-Šæ6hë …Ai ¥Ÿ›X›úÒ›ahÝXŽžÏ;بªVš#ÎÇ©0 qi´"¢n_½¡CèÀXã˜C´²ß´TDäU@·pb2Ï©壳òí×?±x‘Km8N/uŒ–Žææ´Ò?FÄ“<ØÏêôæß粂ñÝüj‚eï A;áAêP‹’ 5˜"3uÞdœ’0w›u±T»¢\á¦iE/àÚ÷Ì+Ûj×]7L×Ç}÷Ü;©J#=º*�xE§Bð’j’•áÚ-•â»³i`Etí?š\žJjèþJ-¾JÝ#,PŒ°ÚV›( Ä•(Çsßý©§k‰û"Ì/cÐø¢MÍ¥žnQ·e@§s$}:ž•~&Á¬ez(î€"7Þ ßóV/æ!HˆƒÙÎÎ¥¤Ù`ÈvmþjŒÖÓÁ2¸l1¬×?åзcÃ+Q2{y©?ÄaãUÀ3^t÷ñ£ ü~ñ …Å<boâî=ñß,¦$Î-½RÚ sq£ñ�7j;~íÇ^™T¼ùÙñò¹(ŠC׆†š<œè Y#M[fô?mè£ÿãÒLS$ß½ú|¦ÅPÜüɃbkKÉ\ã¢N©®°œ(ÎÐ(°wÝÒy8üÃà$¢ÊÕÍæn¿†õ#¯¢)XàbÑÙÜz¸† ’íƒgWÂ-!½Àpú»>OœŒ ‹‡@­Ø7¶“‡Ó¸íœ3¢'iö/´Ðâ,ó„©iy¶Ð,©ìò/îñ:Z.´2öÚåkãºÔÓãT`ⴔ*›Èá1eJJDz'Ö¿®ÈŸçÎÿÓJ€D¡Öo!WÔÆŽMoœ¿¤…‹•É%ôUäÂî~žÑ’5HRÍÍ,r84KøØl  à·bM[3æžÒâ- ã×¼xrb‘RÅjzÃ~kU$.ð 0ÑÖ4}Ĺ8ι=½í¤ð}ØÈ*•c¦„Új4xø›.Šôžém¥_Í1 :Û;ëK†å£ZžNwóØëú³p öö ÜtQFöUåˆå/ù†eåÊÖ’‘2<è7V̼ª)x”«M^èllJËÿ«·ÿ+àþ ¢¢h·R!•Òýê¾<›õùtXêÞˆ¦˜#Ê¥'ö‡µZozCw8žà°²õ€÷ ¤wÓæP÷"{»=,{�ÆãŠyò=ÅYkJ› ¥(msA!©/WxÒYË&Ü/ªë2³È‡N°_ÈlG$S¨.¶ÕðKc8Ïn*MJåâ g0Id š©¦¨€g¬sÁËá«>Îw}X}E©¹ÂIâ¨�ùØ»-ÀQP·Œý-Ä0¢ôÖ™š@ Å-ÞÎS‘@Ʊ¢˜¼ÝW9^¹³²5K˜º8%AjY©3ÃÀKzóÌG~%3lS*5ã@ÞlËÄ©ÄY¶ë¯Î 8K@ƒcC>D!­�IqYRŽîšhÐKÑi6Wórn£s¡’{eË,ZˆQæ…EDIg²¢wÆŒÀ“Ê‘nhÅM¶Jù ì)´<懴\8k‹:ã´åžëBü½7Qg~MJeél;¯ì{Æ ½jÊ‘÷]‡72ð\i勪/$‚nÛuã´ëf/ð?¨°ãšå\fOÛ% ÊFù¹Ê h°·$AŒß]¿ë‰ÝAœ:kUf¾YE;'–)`¤Úuð<Ѽ„¹Á ±êøfp„«ÃJÖA“[¶ä<‚Xôî#– M³C†JŸT<8êoÎSkèbÞc}æðyzJ•ò÷ªö¢þ³¡€ak§©ò;þ^‘û"Zþrzw UÓõÇQök¬Ë³cf05f””,驶6ftú͸FÕÈÿ»ê©ü¿;xé£ß=œZíÐÌL\'ÈSöV”3öÜgcÍJ¼Â̸š2A}J\e†Zqh$J/09øºšº)eÃë®Uá ÛJàö6×Ãk¸þ,•—Nu0ÅÔBïï1ÕôÝcÔâ\2„ð3/ ¢„R¨:Ålè4|*ç4òeÆ2s¢$C+Î̫׎<rIÌRæä§Þ‰Æ4´1¬eÐï¨#.˜Ä¦æ¾´LÖgŒå®æf‰±®¸}½3P­.iÚÀ¦ÂAm 8½•VÒ]…:rçŸñ*G1[HiÁÒ¶+¢£3„ÂòŒƒe΃Ê:ÆJ¡ ñÒi{hnŒTî/¬R“ÜëK�ˆ‡4¾ òºóN ˆPYÙ½šaY\ØóÍü@ßØK©.å·&Ã/s»ÝÑ?H©€Ë‹ žzo2Í*ØÝ¢Y>o%&Œ×=O}U´„‡ k1Å{mÅ|¥\²NX„õ?˜d<[3T[Mð eÿíáä?‹Ð3£õâœ.·žDèvêŽôÍ;NçYH\/¶É¬Šƒ ©Ùd%N=B(÷¸v,ùdŽ‰Wת…V˜V|,—"HÙâ ûVd ƒªÈÕ_b>´æ5íœÃ b-Êeúßsÿ=”16ÓS”…ÉN¡HÈ+çÍ~„0ÖÍLG6qúnyÅ«ÁX¤jœû3ú{¢xO]|ÛËUÃ5‹÷Гø+÷ŸØ™™0fl'' sYÞ>ïù›àm8ä][èÅÿ<c }N(¬ù]‚ê½ví%é´ÈÀßè~™;¤ûCµ´î±oEæŽ Š™whÅðk!›™Ôî-¦}ñq¡ÓÃÅÕé™±’ìúy¥â¨Uuý²€‹<=´öð%–vÍT:\åéu1ûç4•A6t†ž©P†ËòqÓ„_ú@$½±<Í‚³èƒXwJþ@ÄwÝùËPùíÅ^Z:ÁÃi\9íŽ|mñD]›Ú³$žPé=£D“+äd*·æ¯DE0 ¯;Û|©æñ‹‘ÂxcyÅ®2_Æž¶+ƒC€ØwˆýhDk¬Þ¿…‡8m{æòã Ѫø<y†Uì—³¨¯~ C&í¹¯9 ®Íyú*eP5[…vŠÒË]|Óa']F€wo¨ýß}|g¹ÍÂòYOT~*²n(ªúTñJCÔ¯·.ºXšš[ÃMƒÆ¦J˜ÁkùˆFƒÑPᥢw¹¿-Ò±›q|é hp é°£€ðÏ`0[À^w³žYD;8¯L·–¢ˆ¨ê‘¼Ÿ%ö³4,ËØäÆ¥ ( ¿ëW„GÌ€ÃyÆ|[XD´› ÔŽuh£+ïµU�SW˜•ì5d_ê]”.Uª§=Ò^I'M•X„³§èÈ5ŠýÀËaQÎ8Zpô!¿“‰óøÆm®O�$LpÃç·šÓÉ ] ø·| ãEôׄ§4!Þ¢M¬bq_›’Ñ&è[æL}€ dœ9ƒÁ£<»ÑóÜ41ÔÓ­?Årv‘œÇ`kãUañûæ`»ÁóßÁû­Â@X™b·ï)§O®Šø±N|8Œ)Nioý§ »zÚ_{‘.1g ~Àˆ”¾¨Î.¼Xž.óâ˜Á™ÒèH1€‡gòL¡ ¦úÍ^U7H 7û‰•Z0ÐÔŠ¢�5êûË a)Î2æ8’#âU¯x¦Ü©Û[é ™�Ô»ÇWwíö"¹:vYPì{Od<(£²îZÇ zó)y½øÊ!;a_*ˆŒÀkŒÔˆNXþXd—¯ú�Œ”1ÿûØH" }o¦ÅÑsÎ •6‚ªˆHE›{¿±íb:£ŒqÚý„]ÿ`»On"›”ž{Ë_ŽùÛŒËCI‘ǼèÇ6ò±«d3З(µc@#¨¦ª¤3ç)r8#ýüÒ£V…«–1. ±§c(U”>×gó‹çÃŒÒ3‰{šR”{í«CÌPÈÍn ÄF{æß'ü‚(­|ïA ’X5ó¼óÒð1Àv1=Ñ¿ÍŒËU¸¥Û@N·x„ïz:JNmºêBG{Œï»p Ti׳ÊÒ?Ê Í9‘(Úúže“¼=ƒ²Ë•6ä�îEbÏîPô}æ½ï©õ�ÿBÅð!Ó`8ÍbSZ÷cj¯|ßÈ˸Å\g:‚Ü»xÈ?‘Küi)Ìð°Á^ÐÂó8$hö—÷Éw´âÐómš*ȇÉLpXlô©`x=¶,¡À=”¾C?¼Ÿ¡~Àˆº›¾Uä ´9WZÀ%G6îB\=(Ÿ{/ë—×Ú3‘ÚºŠŒLa5-›M> ¬ý¦Ä„È^+æ²8QLõŒD·…-JBÖµ\‹ ë'hŠa"Â̹ž”*ä7iÁüÓ9Œìtfê<VÚjÌDYìŸxrëe±/OTŸšoG<ÏÆøÆÁEwã,ÇíÍëÚ˜Çã1ˆÝ‘¬ÑN4ºš§épdY)“·¿Ò )”¯Â5MK:_j§–péØ”[óŒê‡þ«Óì'îš>Õ•BGßßÊx+2 ÄïØt´ù>ä=å+×+ê„%8€ñ»ƒTKížhÝÒb¥LÓðþ*MkPÌ\rãb\ë9œè<ž–2=Šþ¸Ž„_v3v2•9{g,þê¬zßõ×aå´JñK”¡C® 1ÏY PŸ÷cç*Í4ãza. ïßÜ^UR굞­;ìýŃS ¾ujߟéŒ:…Ÿ”¹é¨2ÁÇø¦˜—¿é‡e•Ob°"¥Kåé´REGL· 2vè÷½næîKqË8膌r …Aµ«<ÍcʃÏ3Å·ÚF+it<ëwdjàPšï0Ao:·ØGˆ×ÍPrÎiÓ`R8ÿòi¨JÖRb@ò,UìµiȨ_ZNâà. øhšùtwð¡MÑép‰Ì¡åêO¤%E¥&¾¢êµ?0ðâg¸\‘:å"Ñטèdzâäµ®On¬O2cÁÊŒ} >ûzShj5NKwÑ$Àؘ¿„ éÞäÔ/±æã0óA¡(¦=·Ö®&ZÄEcõ짯/¦œ½ØÞ¢MqÓ0ôõÌPâC‡84ñ¡z¢p X:Æß@wE‰blÇ ?d0uSg€×ƒnц=«T3&Šp~Ÿ¥t½"Tuø*”ë²à›¶X’¤"¯,ˆyhî¡Û°ã®X‘£ÖÒ¤ØÀüGMÑïÔF­�Ë;P²½|Rbg[Ù,mqì$ ÖF­§†òX¥\é ÒÎý@eXKI|mµØøM'ï•“!#„O7v__èà²iÓË1Ö¿pò¬E¸¶?o‡’í7œ¢�_ßÈF<¯éLZî‹BK'¦$ZÓžõ °´þ!ó_L³ò±ÔQåqQ¸þ¦ì.ˆ-Ž0‚̃4ª6Å×ÿ•êPôŸ*´L6ÑÊÛlÓ2ˆÞuŠÁÞfÄÂRÇõcG'òuz[®íöÐÿð£§Û± Ôèv XúÈiCñ‚Ü8—fÓáĪ•78¦>êZy;Ñý ¦m•-ÓÄ{vÚj’H³#£iS)¿�pù¬3f½ŠbÁsÌÊ*ÏZƒœfhšvĦ̬§GWêtÛ¸EÔPØ,?õS³ï½fëJ«èP¼teÁLÈñ‰•ÈÞþ¼5çePL Wj‹aÎO[w~‘ +ùb\i^‹ |`Ïq¥¦/„è´éϪLñ†2šÎŒi4¹¼w‰c(ɼ~6ä<kÚbåòî#¡|…œ~~;Ìõ–hTK ÔÙh·A A{’ëŸýÞTlÊ©y€!cë‹þ|t…©Î¹# ¦§ü7¯>¹ŸRÀ¦bpll1jFœ9O^údÐZ`I wùÔ€> ý1ZSA•ÐyÐXQÿ,p.¦Yz¥‰â‡§h[Üü¤ÄQ«H—ã0©ÑJ˜”‰~kî»]¸’‚Ëcžñ¼õF ü‰';|k,|2GŒ}ZxΆÈiÖ ¥ðê<Ìx©aUòn0 Žör5M©¢•"kA§æPõ—'üÉY¶ÚæÕÜ…X½üFR6**ŸŠ–A_ù®6':¦gè S¦?ªbÌEÖÃϦ?vOƦX÷ g-ªV€Ã‰r3–³Ë”›\®Ã›ýùn"ú‘œnŸKŽf’2~ ð÷‚xQXúø\º%—?*@1zÝS'áÎöA4Þ.cÿ‡•°œ†¦(ÃlÝÆ]ÊØÔB”J à4[1ê Íšn𮞣Ö]›bxwŽ!²ýîR¨™‚=íÓ•¸ŒŒÊ‘G·«2Ÿ€—mE5µ5G4¨-žÝi?UPý‘a¬�w[ÊЖï(N±9åyn÷•PÕcãÛÕ¶ùxC+N@Õz×ú•…§3yŒd9Ë ¬µ–Ê;€¸&Á7:vc=ü¡OÁ ›çö§-1ˆNÌ`¹ÐŸéj“™ÇÞA—¦hðé­„2–ñ‹Ñ«ç½¡(®V¶še¸W@Æ^žªçgj;Z˜X2/8ÓX÷rÓøŒàH ö¢~yºê1rïucp j2Ähä7ÔPÝ C­�”ðiª °ˆÈýx°æw]Ç#±óñ$lP®žyxE_ƒn&} ן ×ñž¢[WÙ<¬ÙHHÀn…Ê7Ã#0zQ9V8^èce–䌈F›¦·5¿êb9—‚ØÐç©ö‰ƒ¬?»“…½Ã ž¼~˜ÉðAaøbÔe˜~„ÝòÐØvååÀèàËNÿ[ïÒó"¤Rë?žNÒwÐC_XÄÄã*H‡ÁdQ3÷‹2 gˆý8¹ü&ÏÔYº13&i%}&Ém&[~o¨¦u„¢_›¦ÅYlapR_&Úâ–6Î]@ÓÌ#9Ÿ,³Zˆ“7(b~ÃÓ×ù"{äõí9v/3=žA…ðfÈÄ1‹¿"}„¢ÃàCÿŒ&ÔqÀåùÝO,¨ë¹b'apØ!¼(mÛ¸­ Õà•!ÍlíÈL•Ÿñ~ÅY¤5ȘÔÛÃä’Ó7ûŠ’媚fÇ´§¤:ÙNÅ“YA<ÑÂáLj7 Ñ\ªbŽ%7ê‘Gzfi1ÒÙ_<œþpô7^wÑÉlcTØ.ÃP1÷;"ƒ5îúÃ?uÓ-Væ_¼f,ßÿøÈ°pg”ppfAõܺ‘,e¬œêèb:löÐ~¹¿øžCeYö¹ÑÌk0ýÍ÷ZÌÒ"Ù|0›ÄÚÞÆb\fÝÞõpœÿ?1ÖËgÉÆnóHåjÔöŽ}e/’ß“hVNŽ%·Hq$Ë»go°ÐªÃ =üÕ'àÇè N&!xð»ð“¶YÓ'¸+×Zžl胾i³Ë4)p\›sHî;¼„ʲi²ŠX Oý[ý®ìÌBôÁÊèg«ð²$Më‹*ñÑÅ­l?âÏc`ÔímèÏ=GDáA#Š¶júˆ“ÉqF6Î7ØÀ›v)=^3'é,¾hI€mŸFÁøkñE•aÇ&dÂ=�gét²Å,Þxu¿«-`á1Òìô¯9DeÐîË hUo·òú¶à° Ȉì«Ðê®ê,iÙ©Ü—f,9�<»=ð@énˆŠÀŽômgh‹ªfþ3ͨ2Éné÷'ØÍ}ÕXZ4ƒÄí{ÅŒ¦ô¬©¦êko` ·¦F÷&GE¸Šê0'¤Ãnª½ÃáÏÕZ„ä¡…õ$~[zã쵞ó¢"‰¦ë6L4ˆ-©ÿ@oÇ09�)­3ŇÄZœ(¯þîî¼É}³xô×!üOjí·5»9PÐøkŠ/¥§'†Ñ"* zuïÆÖûî:¯ÚÞ’Vþì—U¾ “¾0Ö˜tš%ÜGïAK_* —i\ÖÊÔßrNÜ16>#óH·¬h:o ·COWÓÌú0¡ÌÑY,éÜÕÚþ*r¶Èlv’ =kæ“pâ#J§4l^€¢9þDf¬}zëÄ.æ"V ¤ƒšbÚZ³„òŸÎ‰[‹zËÃß0yÖŸ¤P ¿À ¥ê¯g Ôƒ•ø²Dëñø”–Æ«~"Eqª9à <éî/L°2g–¤_ä±I³˜×¥_i®«Î(©‘¨ó:R€w_ÖÏ]J.j”ŽøÕ\(.†…w£3Qõ.‚¤µZ™sq ÿY0!Pñ<G¦‰¯­ÏêÚiYž$T©`ïmˆ~¼âñ#ÀejÉ…Üe^ûV¹<|¹î†NUL¤´g™“ÁbÛ }‡|>yL|ú_Â÷Ïäu¨,iûñÜ¡ \'ÇmïRe*ß½ 3µžf£&¯ÜleÙ(ghcèˆSoΦT su¾~gq+7B¥®sβ¸ ˜áŸêŒ¤6•l|ÊqrøË!‰m}U+§ šÓæy×Ø �A{hšûû6M@×/«ž+§òú l%¥z[mšg< TÅ—_«÷V™Ñcô¢Ë µc„ˆQú?‡A't®Èy^î$žâ4ú}A;ÐÞÿqT%^¦¶’ÚÕt7\módyR¬æ âäݦÓù\ñ¦2Ž£ºYÖÝcÕPÅ1~x†¼pyRB`žaH³éÀžá¾6òe9ÇôâÞ]<W²ªi°;g”%_{Ïx éˬÌ@òä_àL×Èÿ,])r…ô_é:«\Hßù0œ+#\ôý¯VàÀÄ Ý6¤ ØÑy’ ³eçòWB;ÕWlEAç>vFBo/dÈ-sLÿ˜”ÚrÝ %N¢ƒ§ßø2æiæ9a%¬ø‡êúê‰Οgú+r‹BZ[Ÿ¨ ¥íëÖUÙZ­(äDÌ“çÌj¬¢åoÝÌ<3œÉ21‹ 4€gï6ÝæÃ<+üö‹ª'úOæ÷9¸3Ó}Ñ“ ß··§ G¼”lµn~©üZ™¦]Óœ)B=D³I¶öø.)W;KICAJkÐ >_㣩nQ,iLçDÄ:H‘]¥´Äñÿæ“üh‡)�æñeôŸ|-EG˜B~î<q-;J¸é+#Ïy¨r&+¡Ü(˜�ˆ+:+M‡³ ëkÉzd·©{ðuè½ZK£¦Dˬ”›}ý«²ƒS‘}œh[ÎÓÇavFE¯7,ƒÇ[ÄÁ¦)ƒp¶³‚�eЛߥ”r`n+U*ŠÂèGúN[Ú<fPò‹ ê¾L—,bT°Àgö¦³‡U&ØP ÂGŸY‚ãöK¤ô°6ì!&4)sœ";{:Mø¡É)Š cmpá<¿ýK=êxÐñ¶¥³9y·ýphÅoÏN‚õ×Çsꫪ SBwî<ã¨i„òì‹‘¨iÂ?F„n÷£6jÔéÆÙªIA+¿c$ÛûæqCEe§ŽLòsšÎí~”ú“çÜw=#°ºe,^~±`©ˆÕ½w¿/MÅ<]ùPÞu87»  múd&SzA 5)C/ÖÄ%"e™ƒ…ŠxÐjѶ¸È¶çL£ûêؾ^^d$£bž?^ Fhd‹{MY%ik;úFsNSW½¡S¿m±šžà`W8Ï› ÛÂf]K}æêܼ2õ¼óËýÊù‰cï@yëÉ$ðÿسMÇ*ëYèp¥Ê|>púL[åj<GŸcf@Ͼ>u=íö7ú Ûé�L½5àybÅ“¤™×Œ¦€uL`ÈôiA±9ãTg™±rÑ…ûN¹ðg²!;ÈÓ)Öž3[ «ý…ð¤ÁëO a£J‚7ƪé,¡ŠéM ð±½ FQaVs@7`î@S~3vtÜÿwÝó¢p¢A1ŽÂcEOH Ž¨Šç©Èˆ_(ܯ”2}ÕCP2Ù/6×I•D07* ´>Xý€:ÁÂ÷2iµ2£Bow΃¢÷ <<Ñ2H•ÍTÒÍAˆd×/‹’°I­¥»¡¢‡ÿå¹;š 9ŸÕ¿fðuÐNèó1l­ìæ4h ÑATXtÆÎÍÕaRٞȼÐÝ/趙KáYÙˆf-²EX5ÄL¨¢[¢l_<YôÎt._â~�Â,¥ó ¢› eµ·&÷ÜÞY¥‡Rü˜ wEE#!›®huáôÙŒÃA‘¯e÷E¸RŠHYÏ!}?{EÔ›*îðJí·ÒQæ°è¢]µ p¼[‡¡A×hkJò.2ÆÀ:á©Ù3±–$ } ´ç ÀáIsßÏ3Cì‰ù0@JÆ:ÅÞzþºGª%mqQÂAÊ°‹½5bZí$ŠûÝïGòqúÒ”àÅô”‡4½"`"K‡¡»pÅ‹þG¹Y½� ”øæ‰ôP-?då«IT%þ ­sµ�m~x ¡& Ì€¾ô\PÙ|õtyqKU¥&äbt#ÿÞC™Ò[p°.²Ž‰ÓŠœp{µÕ¥|A¤Økqš:t+>Oî¸E¹ebÌq>ÞÊZS,ýH bkms„‰ÜüB뤘4Í“ì &:rŠ*‰Œ»’…·¢ÏÞ‘iãÌÿ&ˆm»2¨Ÿ × ƒ@tãÝk¬{ð°–x¡XâåA3ƒ?S{0Žˆ;ÒJ‚T¥Ö&¿eÍ2Ÿ C ~ 0Jò9{v±:ñÈ)ó†2* ”'…—¯ÚX~Ŧ®¾ /Ý¢ŽŠk:…0z¹ÖËòÒ·õ|2V0 §xïÔXÿœiÊüÿÂ…öês—„ÙM Ž™5¡õïNdòM«1à`ÝßrkœzdeK3-ͨñ’wÞ$5Àz•e7UýÇB›uØ{íûÎòì^!£ý²‚¬Â­b¶QdNSIE~¯p%Ê`1<2NÛQšê”feLø=º?².™ø^„AÒk2Zôæ µp(£G÷Rl°ºð‰éì'ú'²bxèSÐ’8láU¥M•Íå¸ VP$«Qšë¦¯»¡>¿í.œ¬¬~ŠDÉÌÔËlfJyt¤ÝàÁ&î`¾@Þã@SÊϤYgÁ7Ǥò5¡cUñð]ANˆÒTm‰=Ê£Ô7*âI•y*âêÒzVçêq!oüB©iU¨EÒ/‘6Kçy/3¥ÃŠ”{š‹»z¢6ig·‘xŠË¢0ycQ|ìjª(þ^ˆ¥€‰¦‰Ð `½ t×ç/Offv®•VÏ{ƒh;ÖÚý}A™#ö¿R².=ŒÒ -‚Op‚ÞñÌ_éöcù<ª¦£"Î|Ó0Ø^©„´X@hÖŒÒÔ­‚Ø´ —ÿþÊ9Ù‰†ÌªË «=™L‡%NhPdþ§öœ=^€èÛ`›– Y”åϾ”ßÅá¼\ÃSÿ!ÎýOú7/\Qž†ÞœƒÒèsCû묔N D&ßRW ôþ\½”@õ¢«ûÇDÿž¢›{…Î_·3¢ L×¹ŽŽnÎîÀÚHÆ1nŸ‘%Ü#|L ¢�…Žž%QQfÞ×iZy‘Ü°ãXÒÖ–dýbtÞ• ±R×¾^arcÛ^éHþúò;zèh*iwÄG#……NÍpŸÈß©4¨€BîGÆ—‹v¬Bø\´gŠ«® ôÚIj ˜Æ”KÑc¿ó†¿»ºíæF¯¿°>â"„Hø'É‚òÔYõÔz9poÓÌõ|»6¬4"ý2´XlJ(‘4Y7ãp…‡|‘òîä}öTNeüì©J~Èéös¥¼~ÑÚrœ }O·ªô¾ÅEu¹¶Î‹ á»^®Ã÷ÊS…sw^O¢ò¯wÏs<í»þPû¢©¼’~F97k®ÏèÄmwQ…Y–ÂWd©<#!óÛî/u"ë ®¹ÎÀØb�¦lF!bò"ÔÛ*žÊ£Ì’Žå^Sú¤—ñ´X­<Q+ú¶£íˆ„(!"^Zx!Õ¶l4°9놊…5t9è7xEO<ñ`“â£$l÷fï…üº?íë¨î‘1ŒÐ&dÃ¥ BëiÇ…³VT7S»ÉêSßFmo¾N%Ù’S†¬;,cƒ£]G›˜ßsσvкÝÕĈg±Â|üÍÖ©ÑŒ6A”6H‘µúÕP!Ž× ÅÈ—Þ‘nÂivã/Ðþ¸ô3ʲ”pýÊž» WÓ;§zÖú43kàõÖéfw_XzÚòÍæº$œlYi°z‡ìÓ—J„Ö@Ä DÔÿ3¶¿ôò >Á.[ õ:Ði$Z;Gç ¹ SJØŸ¦ïº­§[’›wnfªCŠF]²™ãP;ݪߖó®$ÖyT?Ç ßüã9Ž3Å`KS®ÓÛ®nts}Öʢ̃0†8Œ,W´¸4|gÌNÜ×¼Ó)/êCA»ŒúgoŽös3S|½{dñ¾† '28Äa²¯É<ÖKÑ̇Éw5›aó.noÿÿÀ©&~ ¡/¶�w“·ž«ûtØ.³·¿¨Èv¥ÀÎðòÿ½tVìl#– €#ÄðRÝr'Š1ÌWeýµYþÖ'½íß5{JôßÕz8ŽkžØÔîE÷Pg¸ìäî ²úlÝËL»ôÊ褫4®®1xâ5°‚«†®Á.õÓH{ °j¥$;F;ؽÍ$Ò^ì!£¹Æ,e™Ó3«ä$ñ¥³lD™ ¨…‡q¯LäÂ4ódâ(Ó½@f rŽ±å¤E•Jݵƒ*Üy—O,Y¢¸ôs¬˜×'eoûÚ…£M¦“qó±JBÜ_üÂãgqŒX4Õ' ò‘JÎiLÒ;ÂUŽ)‡¿¬Ôw>2 òË\éÒ™D«dOøΠ•%ͨ^$©ûƒ¯½ë�;ÁúÊ4É—Ï"ˆÏ´‹ò÷ øÎc–'x&n¼­¾F¤¶iã¬L»©È¡-±ÝB„C¬ôï�/ûÞ¾&ÎSW•s pÙ–A¼=©44ø~RªŠòñ9 +~…iÁ”qoѦн;€|¯.ˆÙú*Ÿüžr•ûX\ �m]1B[([c‹fº\»ÐѳïüK: d}]šÇ†x\Yy¦<ó»AÓŸ»ÍXkáµB2Ñér$v‚yП v9Sà}´¢¾┬˜o1©ÀÿçtD,ÀGrÕ&¢{ÕÔ1e)3–'<±9Òj®»Þ²®¤Êôå9)"‹½j‰5­æŽRŠp°@OÍeÍõQûžßú½ÀŽØÉfÐtaW¨xÖ~Ñ4Ò¶ì•ÂÄÔž*òòä¶ÈóÄ‹X¶y„¸À—§¶EDgÍô÷ÇÞV)/uìm“G…™?ØänàNL7êŒ$Ÿ*¦“p0˜]ýþfÐ x£îøfšð¯ãâ¹{ cÌ'ÐðŠƒã¼p ’qP?,Pè2ÂåZõÁ¬ˆo'avXhHZ8»iŸž7bF÷‘+×Fý›_ï¡ïVHtê¨ð(·l¦Ç½öci®°ói©¤xˆÛÌÊÛJm›Ów†NQàNOœpºš‘•©@À®¯)ßA‰ûø·8ê\‘Ì*6§1 ¢Y…À D`L&ìhí'Dža"Á2›NñE|8L”µ(|-rù¤Ë”§$œÞ÷JÜÞ´`ͪM‚í4:Œ;NÍñ$oý(5þÞê=¯Ü²b ÀBwç«wã´²;[Uü’,’¡oCIà%¥šÈËÂäï‡/ög‚ÔãNm´öZeDÈ*}íÏÞëóÐh¡EK~ìWò »ŽÛH`R‘g±„ìjЊNÕÞJ@öè¨tŠ±˜5.–î?=Ä/Y-ØæXÄ \è6¾[ µÔ U¥`¹Ö-ê z==¿Þ1Ͻ»ÏôƒÍ%æÉŒ' š@\¾uÑn¦îÒýà™—{�d¼9kMfïƒ)ðȺœç3´å±à¤1Z§íåBÛ =ýãé­Y•Y&[1êýNðD5᡽À;v8QäI¶ÿXÄOigÀÜ:7¦}b‡ž5ÏÒ¦]JŸ®ÕÊÈ*ƒŠ·ÑÅáûà ¬lå…•˶ ’Y•fh¡Á‡ŽÎ"P*©@dh²LäÞ0‡ ïÇrdYèÄù|8%”t~*;NùHኈ› czÐw˜E€=Òþ‹<0·à22´–óÞkÚŒŒåú“ªM=‚µZЂª¥†1´ñÕLsMÿû–éð;ÄÍAiÁ»DÖk#¬©QË ^¤gpið ~…™&qj ‹b>>º„*Vïzÿa)÷ º-Ofùþë†iR“•ŽeË»žVVqµPà èÉYƒWˆŽ™ºIw]9¢ªða.*îåâéçôõé‚Ö¹ÁL#)Âßð$ܽËû¶cZT™CbœƒÞ•L-¤Î™ÿÏš>~_ g¹.Î|8¾ìv~2ªYË-`ÿZF‘xk¾gw h–/%B5tøLlGhó€” 5DÕ?#-’<Úy¦äŸy-$–ñº$ˆmb‡îC3 ®Ús¼ÿ«ù:šÌkmû“ç £–C7ŽdI˜ÜÏ0Jo5•GÒfü6áPL‹P€áŠŒ’f¯N`B0c}^'ÑdÅŠ_G'ÙªMPà@¡”ªÛ;ãy9@KÀ ÌâãÌEÀ8~ó£Z…áZîñ:¦1³‘’ÕLQ-n(ØŠÖ‚ÿf„•Ä®‚«@›þŠHFhWãêºwæÜÉ´%eè‹FSîÔc „û‹·˜õä·öZæãøG—©ûâ÷¿yõp!âT_›?ôA‹SïxÇù‚ž;c:§ó®¹šoIl¥-´FÔ÷E“"ëé J¯õaòA™Ô¥5·ÃÁ»RéH†þ€ z÷ ˜šøÕ„¢€ÿÈ;õ}A$™ sÌ,¥üuÙž²´ NZ1®‚û“‡ª•ó’ûù,Ò™gªí*èF‰ÑÊkè.fŸ;×;[j:< …}Üp[„~%X{q‡Ê,X®ho7Cå}ÅÖîW,d vJ5o1ǾƒjÎ]ç2('K»L…ÞzO=ø­|?øM³×ðºŸþ“w,Š]¥I›- L³6Z wÎðléUc¹¢Kw¢*g¨Ï`Eµ‡íöîÕk‚[I¼¦ âîÖ«½Óû"jºªDY[ü¨¨JðHm‰zTך€Ÿ(FÊ”æ)Æg„‹M±Š~¼êè»â?+#@Ÿ ¤¢ë³Ù¬S2’n*¤aÀ¢nìE�)ÌŽ§à³è6ô@¤}ë_"é”ÌPóC…_‹-G˜x6^)RÒ L]stö/P´‰/ÛÊEKD“MâŽt7Ø~%¢¬~èzÛJ·b™±×-Ϧ:‡AXk{4NÕ]ÒÞúyaªõ æe4´Ï~öÆrpðã�BR9ij„IÄ\Öãr0qþþص-GyX ½EÙ¬lÅ÷3û¹üfm—…+À9˜œzª÷L'£þhðÖxùþ–‰×ç²ú2hÔ‹LV¨ßÒÆ'+?…®wľŒ=S VÿŸ>g>Ns+»-ó¨u‡à©†¤U"²QÄÞ©ARo½à =ŒÁ›/¹¥ÅEä:lÇ6œ�ඨ_vÔÀ`Ó:Ÿ[¾|O ÈPäÃÕ5#Á,ît@i:ï/0R_ÍœÓEÊã‚èôiý:¦ÛÉG¤Œ¬^“˜+CJkö°ƒ©R«¾,©Ñ;�ô×y¬1V5Ö‹ÇL¬Ø+¿Å/g‚–¶3/+™HøݯŸ=‰\´ô}È|gäAè Ïm5çx ¯mõdBXÑF âãªf€1Ë«~Ge#RŠ~ÄÎÀÒä1”á†6g½?bUy À6õΤYôhPØxÛöÓÁî 4ÇRŒÜ( WÞÅ êߣ£È`-»ÅjPs‚HUCËe�r²¬Uy¯ó˜Âæ¡©mçŽNµxù^uí…iL^d+ÿM”®´ðÂZÉnsÏž="áî-SWȦðe=⾑۳ö^¬ˆ²L½_ÜìYx' ·=4‹½å‰z—ˆ²Î([h5æ“ò!�‹ŸÆ“i\”Cré•^cz%1›Û]ª ªÿ±“ÎZÓKÉX¡*ǾúïmîAñ®;§tøì´Ne!~Àø¼9\ž<÷  Àý/Œc_‰‚mˆzP J7†Îoæ/Ÿçq^¦¯Ê«ŸÞyó²?ï>%¦½×®«Ÿãtž¹v]*攂Å{í+aê5�ßx/óG·(Xº .žHô$‰ç(ùÆ�KÙwËî K«í±õ[¿ÉÜàeŒ‘X( fÓ?n"RO jzì?Œ¡ Õz'œÀꢧ¡‡ø¦³«ÙC­èsðìVŽag)Eô¹¿`/ÐÊÓMýfªR–סž–ìgg[q¬ñ¨w&™¾éíyˆõFU±ÁÐþþ7zJ|°p ”A~ýòšñp¸Ýé~ÞwË‹§@E™SdO8SÆ“Ëúú".1&€ÞȨY-µx…oŒƒe3;ʶ20ñÍ"1•ÚP!Û ‘þ •ƒúâÑÇ%Ù ÇÞì)ÿ ?µéŒ‰ƒ–?ÿ}SQ¼J¯ð <-iõß7ߎ•Û�¯ÿoèÔI\5ÌÇ&C…Šúy¢ŒXaNÿ'H!}ó>&i«‡5Šp™«ÍoWKô¥eh‰wù=ÔªÊ3+æÎdŠ‹ Úë^KÄr ]è„·íf4D4Î=øÕåÊìÞx$ËüĉvÐD'_ÙîÜÔ qS ˆáâÅ:0†sÅxÞÚÈ=ÛÚ-U Ž°ôbpE(ö%”£ÚoÝh3ú€‚ hÌè5C¤ªTþ¤Ü™᪟MEa :¤jâ�Èsö€ ärãɾ6¬WOêÁ¨3Ž<»;vµÞSe‘Úpå›Çˆ´9w£ï|Žrçý-0ï¶Ëò Új[9I„…=põ ìú‡¼|ÃÁcÑ£ÄÉ©…}G\ýS…=Íÿ—ÚÈŽaÃød $:ÚŠùÕr ‘ó{K)&–3§ú‹gtËÿ{ºq™¹s(GÔð\–zþ{)úƒËÙ×Ùëœâ¡?e³›[Í€Ÿ~V`Vgž%C‹X½8&pòøw¶mòïíQŠäs"Þ»Z©ç@Wöíã Aƒ’:Àg^möâƲP‘£Âà釉¶¢CTBlÞœ{ùzxצV|6Œ)JÈØïr¢Ç¼»jï úäìuiÕˆ©ˆ^ØÅÔ­*p¿5(ý˜áÂÔŠÙsãØŒ¬uê”~1Sí#×S¡q±¹»"üÞÍ\[ ³_Œ¿ÊÌN÷#D‡Õ)Û/ë¬Ù†SÌ-õﬔ©¿9‹xºlWÓ¨A”ï<”ÝGçë§ýd6‘©ˆr$r%Ë”û<É4¶ž†ò­–Àw‘G[dᶽÙ9†é@Ñx'Ó MÝi”ºá5§»+¬V5áÄc8QµÞµžýÚpê®6cO±ßÊçžmƒs¿j½Ã샥!ôŒ\¦ñbïÕlÛ·Ý.oZàñ§r³±²Åð(ØnW«üuÚEä·Xœ¾0)Þ[O›j J²&ó‰g WqA{Qx5ö¼�œB!+fx–ë•AùˆePÌؼ»|Óx§Î‚K0aÿç|7›úrÙ©.iqœ‡ƒ’˜^òŽ}áÖõ&XævÞ°^Æ"™'Cd•3‹R:é¢Þüè"£Çu3gð‚-¤=¨"·®ÙkmáÆâVhOúö盈®Ù2­¢ø8í m1[cvrp„~7|öjªH7\¢mWAÔïÕ~®Pä’h¯éûž$föոܙHÿê" ös>Jo+¶ä³Z‘béÄ#ï™U^âaç Åxæscšq8ШÂ8rŽ¥/ø{sT¾:°.­îÝÞ›EÒ 10-Ó,ïí¹çÞ3JaWo^W„ä4q(rn¶IÅ£~—-]‡«“K;ñš~U1ÕŠ+`N)ø½ÏÞŸ@¾Õda/|+þà/¶bR+Pêøn¢ƒ®Ó£´1Œ"¥O­I'¼«i<ö%<£r…ó b“ ÊÈ~~Œñ©X¢‡»wœ.Y*P_låÓ~«¬¤sظP4E˜ýÖÙÙlÆñCrBÌ醵ซ{“¡²ðô|Ç›…Öf4\ к;Oã©Vè8«ÑGâ êû–I¹ÁÌcÐò`“ÐèS1üø‰ùÒYñgCM7ÜÌ ™l)C žR˜­·æÈòMÀö˜-Î…º½Î<bÍÂ¥—B}=Ú÷ž³hý«ÅÝ¿’^¢È7xŠ`¿N•f÷ÇÀÁ&¸8Yôÿz8ž$‰0"é¾Rh;ÁŬs"ž'î×›¯Ø5 <6Ì ü£súO«N•›QÔeoòâQ3™lÞßÙa}{å2šµç.lRá7ªÍ¬¬`âçvµý|…þg¥ç½\ Öx< £LÝfÛD0¨þ×ÆQ®> BoÅœükçé5-#3;=ú™ðZ´óñM¤ˆýACddÎ++{!›ÆŒÇKƾ—8ªre•œÝÀn‚*uwØÚ¤ŽmÛÍBì¿L'öN]·ð9 Bág6M&Ðr#öB7û06¡§è]ùi–fÄtt™°B;ª°lÖžŸ8¹œO'n^fŠZ gs‡iþ…jáåÕÜ î ÆV‚-f5|‘&­‘ÛN ñê¹¾•®Oœ{‚0ÌV|i½Ç󦣴ߟUDa%4.ô<ŽÓçƒÄn±b¥R§ ¸œbÖÁº:”uã¹Åÿ»ØSä—ƒ#,C¹™¹]Z8X:^žÃî캀¯³v#g>(ÍΈêÓý§«£ì¸Gí‰</úÛWË9OÇ“ýäÚ+¬ZUq•!5K2¡âD« ¨Œ¸ëùL‘¥ô`R%δ¦‚Ö©Ð{ar<NÉP¬=ÖýÅíÛg‰óoEƒ] FÛÖ{ØýÈñÌœÁtðl¸³ô<zÆ™×de…ÝíƒA'8T†Xkɬ¤ÜÞNãŽ]PX‡›²wN.¡Ê ߘ½ðΟžë¥ÓüFjsµî¦@þÖ/JK`‰fVû%Ÿ_šî£¦ÎÉç¯:§ŽÕ™ñ•SAôHÃÊ.žõðzN´¡7{áWÐa»À.ÓvzÊùeè $Ó9~Ùb¬øyñ Ãyðë9c)¤ÿz‘#ü…Ô,§tŸ¹±¥¿áhd‚I±žÁI¬¤ÈÖð tÒ½=Y³lÝÎu~$Ý~šv;WfÞ#€°V7„ùÜÿ©e Ð;ÝE30/�ricÚÇ,µ°%/ì+ãB)'é<ôãFEe©m=ÑÝr$ªÜ ÷uT¶ã̦#£©¯¯YrÄ…7ã#»© áÑ{D#¬M ÏYšHÌb‡ñÒw/„Ž8Í|`%ÁÓ>¥4õälV1­§rô¿oI)çQ0 Ã|þ–ÖŽž‡wÚy3sÁ ZlZûÓ:A£iFýù‡%g¨ (Ÿ_pl@ö„»„OùÛ–Brå�¥™þȤr‘¼Ý‡þ¡Ÿpx?ãô\\ÏM¾PÎïŠ<Ñ¿2HJW0Û)¦ìõEù›‹ ÀMM!¬V²ÄúR+Ì=oÉB´÷nÿ•@x•ø51 z-X?Ÿ'Oח璉K¦7úz›Bú“¨+‘»T³v…"Ë(n<½·˜uÁŒ|=Ž¿é[ zCð‹± RÌ ¯àp!A1‚fÚ#(ªkÚ«†jJß45>S)Bz–Süe2+Š`ýæ÷‡¢ÐõšÅÅxF¯9wòš‰¾'§«¼ø¹àe圌ľö2ÑÆî/Ѐem¼.Î/Ë¿$^¹˜Ð‰ÑÀ2*þzwþpÓµ3îpR±½„ gDž2úàòEgty`z§Ûó9. ²š4›#àBºª¦S¢0¹R÷UY÷éó2àíRàl‰ËæÊ;P»Qòý¿Éáσà3Ó"ÊLñs¤¥Z±a4BMúôÓ›'JržŽÜõófúßÏûS§¾†ÕJå€p«ïÄr3rgÓ#Ç»ÔýÕÜ›53Â×cHnâè ~ûKDçÚÊåÖç-p.¿AÁDÄÑ)Â4tç¾ô {/ðNØžû‡k8s(Ñ Aû4îj'á}±›W‚¤l"Ý4�÷|×Bâµ’R ùµ$¨. KQÄ2NW¨ Ì÷„ò•Y²òzË.Ü'ç1ýñ£ zîË›‚áÛSj§Ìlò" º¥û•'nTv”±ÙÜe ÄëüÎßDÜñ¨Òiíd ôü–öÌÏr­‘ÃÙFp¿OÐÔŸ<¡E¾¥l#Æ«ãt<ÉŽ„ü³¼p‰ ü/5=ઞâ i÷QMéy¾ ~É3ß—²Ë�$ïUuâÌ‚÷㺾8ׇ€Qšù#Q £:°=›~I¼Ö?a—n�SP»±é‡JâŒ=Æ«>CäËâ Þ =2ì!Ö¶R~ˆl]ص|¿º³Ð¯Hh÷,¥ :«)óIfMHÙgÓ°ÛºÙ˜[®®_ض‚âá‹ÂÄöÚOžf›ôoù léÉšÙ4ŸûÂÆm³Î‰ ÙÛrêÖ)£T‡Lëi` h¦iÞþˆá7U-s² Zªäy¤«¥õV9êÙ­¶MgýbÖ‚ŒuÒã4ñáq%0ÎÞ{ŸXOŽÇìò€ÿ5$úO\­8$  Ÿ( ŠäºsÝB–ºƒÜîær¼Ž" ¾C P‹É*kjý�ø™ï®nøG S Ù¸ÿ_ÔȽ§4jT]@{1×ÆÚÿ-ÌCçAüº¦ðS,œ‘ãýÁç– £ò'A€ó.7ãI:R›3Æò\ ‘Ãœ‹?P? 1t<'Õ5rþÜh"¢œ( =G�Š:mO«~x÷Š)|c¨(íG“;全R7™K”&A2_ôÐAÞÀÁÈœó?bú³ìÆñ|ÚÑ?*g‰ObÒ´ë¼+m|Q»²?¹ÞeÜØQ“Õp‚’O)#&·ã¬_[ž”¡ãv†9ÌÙƒÝé1ÌhU*HÇ ÏüCb§$1ycüb̦R…@ðZ®$jŸflj”uCeTgURÇø`Sþpë‰ìkÖ0Êå²=tžHÁ¦§;kZº2vfü¦äl ,† ŒœÔ^y–>l‚e©T»7#¾êD^;‡úýö¥mš*ȧwÇ¡wãÈkw«h˜s8º~ÆqÖÖvsš¥•ÃÕ—xçëX¹u„ÈKi†«œ4ûtÍúòïCáÔ£——R¼PHÙ^¾Œñ†YG¿­éªUlÄRŸ3Š,W×õæ'çÂÀïEQ£2ʼè ÈšR_­×(]®ƒ³ø{£RoÑü×Âqv3Jä¯dDZ¼{ÿõ—Jœ1Já”Énem H3I e k5u~¤PDEé,…8ôô]^™mM²º>÷«Þ¬‚£ê6cmÜÍ-äaÑx‡Ã]›Â”~©‡ím*…/gÓ!?F‡^zr¿)�*Ô2EEg�ÚóÉ|öYÝ4”@ƒü‹–¼×¡À̃M“z¼‚XPØôÿ µ¾E?:eËW¶¯Ü^J¡KËÖq¦pקúj«—·÷s—¦oÜÞI€z´IÚÞ¶t,+†¨No»q^MO_XLÖ·±0Š…•}?'O ^4“×Zá™Jßq9ôøO1õÑî”ðL»”–Kwrý”?\MOvþ£’组wpù“˜Y�ÉÛÿÞ’š?ÞÉA²˜é :ÐOtVÓh¥6ÒKd_­©0°¨Ì\€ Ó2Ãèey`½1¬Öô÷àÛ  Ð*N„7×~Z‹º¡›ÝÜQáð¯´H郱RŒ7T¬J_qúÂtß/ŽôB7ý²“ê+»¾YͶ%TR :ÄT¡ßÉ¢ºbü*èܲQÐç ‡ųÀÚÄ)½ÍhT`V$XÓæ'ág · Ø§ÓÇ@²`8½;œ):\ëC[×ÈÚ‹¿ÀÈ¢• 8†š—4È[UC¹éë°¢»¥>A¯ù»$©‡5áĺiWû,0öjµ5¥ IcdUKÉq¯þ]kIºÍž2ÑÆæCà‘O®gv>i9üd4í…•ÑE»ŽtŽEÖÖ•-{®›N]Á°¯ÊÊ¥&ÜΡҙ¿ÏGRkVrC)^„we³SŠÖIù¼@ÐoëAáv`¨-ÃZ9êÑÕÿ ‰7ý¯¿˜Èåáóô°+ƒØjÁã$ÚP4©/6š{Y¥w©©Á÷¿ºqKc çøEGHfÉöpÇlÎ ®QõˆÃ‚cP_~ØLj+ ¦5Ž]Ä{K3çÀ3á.!Ù¬úü嫾x©°45箧:6é:XEÆ,ËXû0½*E?¼|àO NZ’ïЧf(RôuuÀ²÷ú4‡MmœT@"eqdaýRí_�©Ü“EñFÅÌÒœ¿4µÓš~®:]yÎtâ5½D¬&êZuF OÅ÷©Ä‰Âò  ÜC8Û‘FÕ*�f�…ÕÈ:"öâ@ÙË£1±-¢·ÝO°}]|«µº™Ë']½ÊWaä˜CW„pN ƒªÓÂ)Gõ}í¢Ù"táaw§¯šïr·GN*êÓbÏíéap§à™X¬Õ™û7Ûi¯cü¾-‡^´êô•Nª ã{@;®oÊ®µ5TØg­£‹4 ÂF-QŽQö ì•@þ\Å9JVººÀˆR‰n5ñÍ5Úœ6,*qP˜—dÓØ37*0è¼ ÀØ)uþ€!Ow­»ù‘^é´%óg¬íc4<H–†¾ 1”k‘ò´Ö ÏÿÎå ׶K –„‡îW}[žn`ÕSºF÷R}¿:vÅ޺̌Sÿ¦ñ±Võ‘q6žáÏ~éKK=çöYä^ &ùªµe8@“l>›i{Ð9´(½úY ˼2L¶égË˧Õog4jmZû]³0S°Gi$eAÒŠ‚¯ (õÛ¸~ɽíþ>ý…/Ù§ÕPC7>ýl]aaäNU{ä Œ,žjC·7·ægc®(ôË9JyW«¶¤z#2“ó4°@Aû ~%ê[…¾î5”ƶñ¾^dwôì5ûëЊ!´»z"SZå>j±Ã‰Â~a»Û1s6§½íÓ7ÍÙÌ“¨>oMùtçóýÄéÑ®Xa‡QAy™rÏôt>Û΀:> ~ÏÌÙ›ÔkHž\GÌ÷s{:ÆPÊöW¯Eî1*)ßîá—K®Z±Ýب; ƒÜ*é¤L˜m‘ºbBߨž÷¾¿Aá©1wØQÍ]57K½àqÖJ.€g‘²¹¨fDÇÊxk”¯Ã$fg/E‹äýl…‚7tf÷�5]M›Ë8iaù.Œ‹¢ýΖ3”XîWØÀÌÓ6/™MƒNc»xΚ .óèZ¹Ïž‰Ž–¢y†I?ýüùéÙã:…‡èÐf›)ç¹$ŒŸëp6%è”ŧԣÍvœ.P_1Œ 7·`ÈkÓ—TѴΣWmk,’â«H²üóXŒT{Îqh(Tì–AÔ]\YˆÄˆÒÏ6“æv€.†Cèo*Ý\gÖ®JEE=x`LJe ßÀ~¸78öï²­÷@ÄêÈð½˜ÑjÛYVT|C)ãÄýzsµ¨üL›>s?CÔC±}e.}dÇm~ÿ÷3§€.Ö\J´„åœ:[˜/oͳ^+by –ºGZÜ(Ö±ÑNi'¼I âÕ 2o“ÒãXÔê¥gƒ(ýùN† -V.ÁtÆ”°W8(’.[Êh};úc/à‹x6¢ÕP“å&¾N8¬jÔD7ÏØ’º«‰j‘e¾Ò{%‰U½÷ø-›eœµÖ(žâK‰ ºWŽ›[(8ý?«ƒ+Î Oðþ iæzHCw°_™]¶í¦é`µ€^QÞËV[eqŠ\íUÖr|}¶d¾eêEd#W“ó§n‹>T왶gº(ÙS9:ò·hmïNùéUÛóÄ ÆLfŽ\ºèEŒ‰÷Øf0h¤KÍ‹$aß_z®RÀ£k]a[û™£}°Q§ž¹?ßýä·D®>…ÌHtöÅøýî"u [.Xjئ¶Á¿~�åϳUI–ÓF‚P³õH0¡lG'0´èšº‘d0vßj·¤•[šsÒ‡U@éÒ\À¶>BkÀÚÇí¸-<â[ÔDôŸÈÇ›WHóÚN¹Ãâõ«}1 r'a<XïMÕûß[q7µ “êcJ–å„DeÅâ»mKU»Õ¤c r²‡q‹ò"Õäéè)³Óïÿoïã~P†ýÊ�£!SýbŒCÿ3+œðê ²ÌÛùËæˆ ý¾³b«P¿øÐï¦Ãq~c ‚ÆÌTvW¶]j“ŸÜˆ’4E´ü}R£Ð*øÙ1Ã/eÐlèc÷žÕTµt“kÏïðA;u/¦lôÌY–h(š×·¶Ã)áwC²Ì‡Ç¡ ˜ÂZ-aR9^ WÔn¿Ç.Eyz¦RHm<§¾‰rµælYJ”ÛpÕüHÿ¹^·C H~OIõ¤Âçݵ*ëŠ4\9Â*«Œ?ï~±½öí € ôܾdd·Z“²•À*Q´¤ç*† ¢böLÍ,R… á&Ǭˆ­Öè/χÑ@yNÝ ÊE@¼6&qyY" uJ‘óã °ª×B÷Øõ<Ì`ßa:ÏÂTU}†'BïXÙð‘ÎÌ´é¼± ÌrìúÚß´¸=®˜¨üm¯´¨§ÖžS‚¶±^æMOÕ'Kß_yJÆð¯0&1ý»W”õ‡§,óýtÔVanÆ(æE§ÆRvã#f\ç–K}m.ç—ñQ–8†Il}ýŶŠ‘&˜ ÷¯T]O,š >e·öâ)tñáiÐ0"„¾<cŠý6<ÈÆ@“A¹[X&B@VˆöÉv+* 1§ðÞ-Ö©‰ÌôÓ ¡7ËmɆ#­ m—0¢Tº1¶ë)ê&Å�ó&ÒÅΑ¶x˜jÌûPŠÓ7ÿ­‰´¯gá £N*h×Lµ�æá Y-t*‚ñpy õÈ<äYëLh¨Àipiéñn÷&‹Eàe^®É,™CHG8TéYõàÂù¾²É</¤’™]#T©÷ê±&6PãÌÒië[ìò„•§ÿG ?0éRMi•c˜œc#}ÆùC ZÃAi8NÓ©îנЇ¿Dï4ó$õÙ×j‘¸Q±ÖÀ0B¼Íi'ËŸÞƒNÀù'A.;r6ø48‚!][byî•S‚|G¾y‘Üð7Ž*aáÿ!® a<]<±FÜ/HUÑ9m�n;V±ü›FW+gv D­¡Úß›ËMs üÓTÖ¶ý§Ý@ªÁ¸çó ïÀè?‰M~Tf£­©<ˆŸÄìÆŒ žª”ð’h—E况 ¡ ´ñ4\!e€¯¥µLÐ3µ ¨4tsñ¿„ÿxMo7_Me†/;ñ¢â)ˆÂB4xßX5èúbµð·WE©êÈâ$‚èF¨õ ‰Ð§AÒêaàŒæï+à¥8[QŸ(Žµ”¸|*«*À^¿ÿ}Ë }òa¤\㾄SÜ_Ü÷ˆüÎjad½ Ñ…–±{ÚåÓaó*µ-²ÒA\þáA÷Q-ú%"mÇO''s/…壗›D·´šÔŸ­‡Úà®}Ô­Tð+êHżM隈€gø9y‰õ|£P@±BýA¹3Î}ÍØX1œöÞˆÚ¤‰zR‰Ãv JÔ‘rÄÑ9§rÅúØG:`¸›i]̘y}ÅuÕ² Cµ¼ØÀ¾*¯•¯ðÑ]LQ¹"Û=¨Ò£ì>;‹ ©2I"÷wØ–³¡‡Í;k{ZÀ–ÿ[zœ{^p‰{Èø•µlbq2ãuÿÁãôáÖÄ£ó¸b³P†0Yñ6ƒ˜ôèÃnÔðF-¯X;ì/è’ÐÒhê¤*îÏžý£Ô›½²)k붓—¤·¬~0;Ïu §/”Íy¡Ät²¦4È(Ƕ­”ó_êAU^Ÿ“÷Ó NDyé=¸ÜvW>–éïàquÁlüõDÆ”Kžv�0À–(B³ mÆÓÞ޲ǘ{8L±n•Àû€rï´¾šÜ oŽ>‚ïÓkÓ#ùéIzý'‡ ªi‡r‚,> û·k%WQÿ“ß÷Ý>ë®#Þ ô-.ÈŽ¬è§:h«ÇEݶк3'xy!Àzý :"ãÄ3Ó°9š)Xδcp ÍÑùã ɱyÝ0ãäQ3®:4á,ìÿúO…‚…€4NÀªÚn½z¿‹w$ D›õZ÷+…œÔicaEÁrI‚ä]S€G Èê]Þ_܃1³Ÿ’ïA†üž¢2<Ò+×n”ù m¿]OgÚ¹q3ñ™‡¥+Ãl^µ*6PQ¸¡m|Í!çMçñ¼\œ;$ +zîú, ʶ7pÖi¤‡Ë܃Uø \^š{gãò ;Yµ³g ’uë„Òç^¬ˆ/>¹Æ3'@SŠ¿ßÛD›#¼ Ú Ý|ìõËã‚EÑ]±(©Á²…dAcÑ]oÿ{KE¿ÙŽ´ç øjùxâªѺ ›jçh8î(µK¯±D;|±‡¿w›_®´¼TGT`v•çü‘³æ)ÆWç4ݵØ×SÕ ’Ñ=Ñ*Tµ}˜A×ôpãóÕ#»ÂYŽd“TìÀ]:z3ü•‡ÅÜ£3˜øÜÀLÑ4�Ü5‡•…à}}ífJL?;Ô³î ’ã…eðgŽÒÒÊH‹2ó»sšÇ£ÿ/‡ÕŽ{ÀNÂ?wÊQ‘¸—l99šU}aýV³ ­¨Â7â aåœpcëµ[X‡˜ÏÌ•¯³R‘à¶åÛë^®›½�˜ît-< e¢%Y¡æBv½‘a4êhÏÛ¡Z;u0h ÄÓla÷žL; `¹.p3ÍqÏÒhmŸÁj£ bÇ挛}›˜y©e´j^O´¬:Ú¥í¨£+p• KúãdãZ}¢]-ñ×)³+Lô~êc°¦O¥kwØ«ß—·¦¯ÿ}æe'JL˜ ?Qd[apŠ[t¶5ˆÏšC€E9§ÉST6¼ïv•øKc+¥Ëñ,d÷ž’U-Ùljn™44èóP‡å%¬ŸÁÏÖ‘•7‚,°+ØÄFvkR›úÉá ¦±=bËŠ]èCÓШ¸Á-l¯);Å…Ž_v¦Åòvê™÷õ}#?rŽrFиóW¨QŠÀèzyŸïѧŒẨ"'à½Ìc{ÃN…˜óÇJ)ÒÕ>O©‡üLñµv/_MÑK’Š˜¶tÄ) Ã§Ÿ»ÞOl%D#C´£¤­°H±Œtp†0ã�3ÝÊ–ÿRW¥ÈmóTè©»3«®Û Ä·¡<ÆÜ{p}™ÒF{`d/ 粩"D‹B]Ò¿{ÚßlŽáDÜP¨‹J/ä0þy:Âfzga1°³æ=O j´UZ ø(ã¯óC|z–ݸ£ÉíœÛ\ÉêÃf4!ž ÄWl<Ïtµ"˜9•s‹” ©\‚”…lØ˧ÝÈ؉æÆ©£[í¯ÂÝvÿ»ðÉ`âYZÐ?NW«w„ˆÔ×)À¡“zî…òþxÖ,§¥ÀltYTÛ €è£×ˆ�«àgÕ™ªÊüð€ñjdÝV‘6ØÈ´˜XåÖÒˆ¬õûí«ŽæŠÜ0"0ü ü¶…ÀÄòhd-‰Ê‰ JѲäS¶‰×#I©Ho$…iÐÃV¦³r[¨´/‡Á!< VãöUáXO\£B÷�"¡Ý—ãÜÒÇëœ<ÿë…U$Í”•Ü,“ßO>C™mËX—ÕúFüJ>-ÑF¿  cZÊ <M4γ€ÏYY-Â×£»¹šÔƒöªéÛñ#Í‚ÈU¡œkfíãØÞö†ÈýªèHå)ñb¡dH %×*V>.Y'ݹ’!ÑëoôÀÊ1SšûV–:‡FQ ­¬¼ÖeX¦{ŸÛjþö«îU’®r@:OÛ…bç¤òžÊ-©ð7e:°,ã,Ò)¬³©°ÃÆé|䓘ƒ²Ìì$'´©a•˜‚-2~îý~ÙªtÅw‹'è,̳7®®o¥VsÐÂá´†V×oZf>6?ã4gNRš0ª\v²ª2Z^¸¢a¥Kp[$>þíÚ´#ǾMƒl¹8Oð xË.¡ÞŸ[–dêÿð\œÃE×Ô¨-Õ'‹ÅHxì®*[#‰íë7~%Iâ›^2�= GÝËãu?»Iªñ&]ÙÅBÐ+ͧé cCÇ^Ô©‘(Ú"GaÚKšù¿%œóp¤o^4î£Èq1‘¶ ÀŒ?•ê™Ó±À„_ß—pæa¼†Á,ŠÐ'”QˆÎ]̵Ÿ•×éçÀo/Ë0B&a0_#– öTGØrY%úö“Ê»KþFtÇëžx�Ø\›~3E[;T­×ju:â?k$©¯0w„–R'¬SÜvá>:°Ú €ôÅ de7B·¤[’w>¶°­©Xš]‚Á5¢ÇÈÿª á“ ÞŽ'$‰¿¡¦‚Üj³DLål;ÙBÓJ°þŸh±FiuÃ.¢ª° ¢«fRhFu5-e>Äl×÷WÕ íšgÆ}nN)³ÿR˜!Îß‹7.ÄnYÑÛåqyßÀ›B­­\ªÌ·¡¢Œtw.ƒ|Û8kkýò&&w½8=îƶÏs'0úÐ4½j–- ŽPñK·J•œê‘N¶è(;ýIÌ%è[D:ŠþÖ I²Ü×–@Ý8G2<[´ Ž@1ñЋ^Åí…V±“Ǩ°”³¼Ný¸¼íöÃ+à9–±Þ1Üé;ÝÄ"Z«Ò9¯*Û/¯Ó8]±ÛPZî¬Îô«¦…Uè»ò@`lÎXsMæF×3Fvq|¥ß+ýضXnàBG0w[ÕPIC3˜2`[zC†ð*…ïzÔ®¡e€†Ò ¤±I̘»Ñ° ÿRo,Ž=$ø¤Wh ÈQQºŸÔb4µ3ÂçUîêá7)• Eô”íÄ“Âpz’˜¦íwL÷Ââ´ H ˜°&¦XUqÁA¢5N7ˆ‰¨xèïãa@–(f´NîRh«ì�Ñt‡Y‹ØûdÄ®_•fu’böI0HFXjN­LéÔåÀ¡P’†kCÜaGOŠ*ÐTO^CJ…$Y½ù0•¿Ò¤ðä’xò²iè»}ZsÙLÛ˜ø‹9y$3¾ZGó{/AŸFÀ ´iƒŠwí*f 25ÑÏšsÄ©k96~ïºe@½÷‹8(<P,ÆaõN»O¿p¾pô¶ÄH;ÏGxP5®ª].W—B”k6NpÏú!VH}3TÞ§ÁUõ­qåÄ ¿+c_¬g½>®¨hºÕ"Ž‘,{ìM ’g;;örfžõÜaÝdÕÜzHR~©c=É®Åiçõ©Ñ¼%¿Öï÷ÛHœg+®< ັ['|ÔhÙÆÑ„R£ír5çʱ>Ȭ»҃5Êü4˜»oÖ¡º ŽþcÝE}Y¢¿ØxišÝh]G’ïo,ÄЪÞ ÍågC…/´¿'ùÄŽõÛkNGÖÖ \lËhà<øh<…Ã1 ½ÞñŒuü¿¾ûŸ0.×醦DñÚw²½ô|ÃAw`åîµb–žñá¥SEoJÀ5¦Øm° cÃgbmÝç‘ÇC¾¹V  ¬g>8f¼v áŠ/B%ÚTñ»íZÁÎs‚\†õå qç]PWåSUç’Â3 ú …TZ^‹MJ¤pµÄœG¾0ß9Ĉ†ºÌ*CŽÛ—Šâž¶ßSÔß›=ef†û=Š&<m‡^}Ž¿dä¹ÕxæÜ »!eÙ8ç0ǃ?NgMš‰ž»i@bçÉ Œy/sLQ\®àg9h Y7½× ø ÜŒdf½ñÔ—o~¼S•*"w–rzéÀpÒÂ<¢½ÌÖX`äÐi‡¡…7`qW~q–%¾»y”Ñè“>i(:´c¢Hª!p­ý“ŒtäOºÅöê“bE`N1ןEÇ•8[ÖtVüzuTã¾Û6°çÜŠt07Ž\V»a™wØ‹›ÔvE>ýkóï8÷5'é/_*л·v%—’¼ŠësúŽ,­²úA.]TZ¨âP€ÎïKKi»E™BóÃ)9¸]ΨaVa»ùqÙC*Il´îƦe’§Ifê!{ÇÑN·Í0,±wŠ §ýÛiô( ? ÉUá*cÏÐëÌ?ʯˆ³ç£qfýÉ냋U÷eENºnJßÒÌD4äàÊ&NkßÞÇëf%„¶ëX,ûÑÖ³•'slþ¤^#+ [‹’}ÚwË‘hþ8¸²2G2"§øÔ}!hÌ's¥nŒCoÐ*}/2!Ü[¿jDÙ 7ˆ|Úbó½²´üÁù¿D1+=ávW¸limÌ_¦K—©Ö, ¥étFàÑÕR²bàúpR²µÀ€ÙËf†÷ƒì’šÉÄ¡*´v@7,“§lëp…å?Abãt¡ÈíûʈQ,}´°ù2uMÑ°0þLO}ô¤1¹“Få/dñg–*@y;XW«À05mESÊ?¿¼“ëXŸz«Úm0X? *Åaâ»0GÜy¡’óýìzq”Oã ÀÄ2xÚm‰,Ø-ÊÌüy„VDl}Ùîæ°ì-÷Øt>»+Ÿ¡Ó¸Ùsô{ÜJˆ<I”Ç#ºýâŽ%£tA™Í;dÍdx‹²ÈCR¼ï©Oƒâ}ö0ûô¡¾èIO†at<³Ä÷½ ”õ¶‰=UÐ},ÉÔ ‚ƒ/> »SHÉ›ë5BžšÃëFQì¾CŒz¾ïñ —Æã3¬¬ï¦ý8#ttÓf?wã¼Ú/N&o^\¢ÓÝ‹“¨ÌUÌ87Ü$PÖçcXzlÛ(…áM^¢}j Áâ¢Øëj«,cb´¯¼VY{I¨Ê±`JnÅfÁá”$At½xìì9.ÊÝÙ°ŽºûariH©JB½éŸü½¦H‚Ì Àæ©©ƒœT÷ûõ¯ì°=#¡ünj¤m”÷8Èÿ¹,Ž%O·ªJ²|ѧgÿ‹úqµ”)ͤd*é†ýÁ݇>&Á|haë}3Y„NV)‡{´‚-›;6çöÇ’²eŸ™š h…M­=<”zøæÇgŠ*óWzªéÆd_V­ðFŠ•ag×nüsè¿Ñ@L*ïæcª4ITjWùmÒPRáã(ÊÅ/pnc=r%£©i‘6µ'“6¥<¹ª—ý â:}°¹ëÅQľ™þ$¹#¾eÜûÈ‹ ˜:O—lFë^ArÇŽë­ÿŠ>.4·Ÿßù–:×[² ?ùX"Z3»îb l­€›9µhxÓ‘Fñ÷½µ¹ªV¢ÅfâÀ÷å»IBäÝPl¶¨÷'¥&.ʲ)^vn’ •¹ ò‡íöî•a[)?VÑ4d­hŠŸïæ©Â ·’väÆÑêÿ•ïðJ"˜]¸iÐÏ+‡Ì¾ê|ä=`¶À;ÁÂCu©;ÖÓ>XçvÀкU­ã9.¼+îIùZÙ9†@x$­"êY²WìtÚq'[�öJØx.¦+H—Ï.úwC; ÒU¯%ëJ·›Íͪ ÝL¬2æÇ›³bå´o7LCøæGd÷&'\‹„Th1c»¾–g¹ÿt²#*™",lø»ú‹Ï´ MVäYI÷ÝJYmöˆ%'­j)Wf²XÍžnŽõçLÑ=ïjQÉ…@ðÞrZ=»ö|ÕCFV± Ä]fÇäfUFpwÔ&‚�wÕºe³7#®GÂ;eîkxâ] »3Yu/ÎÂ]öy©QÔcŠÖ³ŠêdÛ²©Ãjf¬35S2²(þ(g¶9Ó4<oº5¡ó™)@á͵+ÞÛ =ÿaðZp[ä3^,¤Çû+KikØx?ù-°-¥O0féF¤ŸM$uS°jD':TƒŠ5ÑëÙ%àCÇ|àx¹29¥8G…׳ƒ“\ºÍ ¦=.ÜY;̯j Gy쓾éìÛŒi]:W{ïGhŠš|ì­ôüÃK=:,ÜDaÃ�÷u寘ÃØ7£vCÎ clWÆ?q§ƒ<ŒÍÖ‡Ð1ÑËæ‰YæiÖ£,d˜iïùkìÑAŸ¬òÐc±L'š)KÞhâvmµH¡ê~—ÅôÝz]?õ¼Žrw‡eý]Ç‚3=ê•Å;JÀÙ³kÐ÷:LóÚžôïÑ9TçµnIõB$³ïŒˆ¼VO}d°ÎÌiV–=œf>oT;}3Ö°ûôª„"YéX"­3î°É_Á§™•ñw@ZDèG×ÿéÄÝ®;Jó(Z27X¹Ö9TÚÞUÐÖ…‡Œ…ªSŸ[ŠrÎB·û¢Û-ßD®Ýú,ôà`î÷äùÌ¡¡/!ë[ïÊÍÝQ­4«öù6M‚t^\+â`ÿìÜm¶Ý$îJTÑm[¿m® eJý*rÒiR'…)”hµS¨ÀPlÖ‚Q@?3äÇúcö®ôÄ,"?ÞÒ‰É]e÷·ø¶íésòc{xhþ¤Hš™¯Œ�Çq¡«Aç^×¥›æž.ÕçaWˆ¸=àOÕ’o ¼lg'®,zEr œ(9­îzƒGr–uNôÌA&. [~‰ŽðøEé[ø9xðANÿ0d53`i,S:‹Ô’Ãaü¹wDá³Üªmjvo²Ù®§–ü¦ô€î§é$ø—¸=¡—qìǸå3ŸèïXJ"´—Úâ¬éè>˜žÁƒ+ÿ­­Ô@(†q ¬è [(¾g*, NE+Ú‹o�¯±bÈ„ÅG»áKÕ ±x”XÔSmXe¼È¤O÷"é“‚„Ó›ad eMÀ¶hëîϵ›ÇÁïù7íªú8ó¼Ð^¬õ¬Cˆq&Í©,Hè½{-À1Oø°¾€;J�įµŒŽYF÷l‹(^aQá"OÇ`¹Ušåz¾’=›þŒÏŒ¿Ä”`z¤ 0T¿6$÷›©ÌKo�´->Õ<ª‘5­Ûa9Ôfѽt?E­%­Ïn~D‹=Z¡ª+ÆÚfu½`¿%Úý£BíUÄmé‘>27PrUµ_–AëM)×7ªXiž’צûúÜz¸ WYå£Û’‰©&) ˆè‡°Œ;‡˜a åd°¹ã¥nÅé£ÂÕØIUQb¬±N=eK½Õ“)1һў®¿r/ãUC†”~n¯7ê 2Tñ&3ÂÔÝ.t¸0ô¦›ÑBg¾}íÌ} £æÙÓ²ãŠYnr,{X¾í¶= ¯z`R¯mŸ± tõS«ˆ4 ÕÀÅøÖqÃM>'£¥ìÕƒ„=Jß:’kd¿TêX º¼ä1¹°&pßæ½Y”…«¬op^Ô¯ tMt²À®þc–™¹ø昰±ÜøWT˜Aßð—0A;C*h7*úhšd‚ ÖÛ'ubßÎã8Ï(“°HôÿIA;©2Ï’uè¦_—¤µ=2H šÀD±¼¥˜‹òÅ#Ê÷XAœÝ9£÷~ߺJ÷ç°:3rÁ•hš¹íY(‡ròº!¯|Ú%e¾í¾ òë?Šgf ³K_-ú_0@[S¹»ðM°¨˜¸e9=#¼Ðÿå8“$²á-À‘£§c½²48‡åm‡§rêÍÔÝÝøG˜ã;§µ]¬?Ç`n¦ëÑ:z½Øv}0RÁHæ ¹…MàÙ)­ÞÒB©·•åw<ƒ©=|W³k--i½%¥ò@ÚTÆÑíù¸¥ÿG«åEÿÒfG Kh£\_Ìë=uÙØ ¹Ç¯4ˆkí%“¡,z±pɾØØåP8ƒ)ñú“á°÷bD”(;ÔÔë2`èe„ÿÇJ¤ññ­,ñŒÇ|fÀ—wïëëÅåú‚Oºyºêh/cAô )C ƒ7›jOt/b|j9·"�fã’Œüäæ'ºãÞÝ)ÐeÛü²°÷#%}5{ÃѯbBÇ+@ˆÊÇCæý£Òn2d¯ˆÛlÓ,¶5F«þ§SÃä—aÝQ‘:ÑgÚOŽë­óÄ`;¾Ýàçá$½\××ß‹YÃQÍ¢§ÐB¸°Õ †ùRfg%Ø*×äþB¹¯Ó&Npc)w³LUSàϾ‘–ûí« 3X…$7Å ´H²©÷É©õŸCoÉFH˜;Ažz—”žX]Vuμv;'ž,ü.77|¡ g2+àyƒ?Éœ­§xhQU”E£|#}C¥/%>[gœBþå7YKµÆvWÁr)(…\<nPœYïi?#Fæì‘ņI=ŠQ O_Š5ÈrC6sï #p%S¹Ëï2Œ(¿I~;h=~y™(Ö.}x+Aø«VDœyÊüÜñ ¦QmUx(ƒí”¿p"°VèY‹ãUF�Šr¯„r/íãa@(DRv+jÆ/œ8’r=¼Yú#ö¸Ð U$c7Kv/ŒŒúýxºcnê#<‘îžgµö7†@LÅó»&se²ætR-N?PEìÚò·£{a >” ´à½ñ0:›’°°ú;n ÄB‘6ïùI&)ñ¬œ*¼tDÒÉ’äq“1ú†0’í³½®ž‡^ @€¶òOMUl(yÛßâèíotX›n¢ŠYR½èî÷ߢ`’|Ë ƒs“á~ïŒdcÓ^òØ ögz ø{€M¨|¹PŠZ}ŸPQ`Ïш]Þßv˜ ê²ßŒÃåúà_OíS.Jm‡]F9ãɽràâ¾—ØOÃØ·/‚­nCaü&7Ódú┵`þd_t&í½1:xnxP$™§26äk}«]†îblÁÑ FHÿk®ÿ£@/Ui×nêIÆ…jF÷ø—èç}™LM†ˆŠôI:†w€;™ý@½{BÅ“Æ’– ´O(¥ª“×?lê^Ƀè Ô®t·þ„¡*tý53NBÏÃ.s(jœ&@Sh6¢1U;ÇÁnn2Ê›Ÿnó§Ü3OÑ”Þïàpbžß^TX ”Ù+”ùc¨)úëOßÁõ‹p…B‡µq²’®³ÿ£ÿ/c¸a=Z“sÜ_ÜÂ8BázP9USiÒ|9gJ£L)Bk½­^^¹V]Ôh@ˆ‹RQŸ¼ŽœUö—M¹)EYéëºÓ'…lV6Y’ ü3(Õ/ΔÈÈŠí|Ë*C²2/~êHBßåEP-_ŽKsš„bhºÊp{؃MØZ>(TOÉþæ 9“ÎFCæì»ÃºúÎ’•A&¡Û" ŠA¥ÝXª‚í‘Ù~çŠ7b©G—¬üB‘6vªD„J¨*w]zVK{ÛL‡ù©!öÖ¨€‡ÝJOH×ê˼Ö$"bû”IäNŠðF¶àÁæ´f†Œ03>à®7U®Ü 1„‡YHkQ¥Ü‚Á¬e訄\”éÃÐ*3r{M²- }¿-tN/Ñ%(ûÚòrîq7Xrd©°ßà(“›ü/æ‰Jëm­SÊ0z´]à“ì¾áÛY9î(1R¦<x·rMQeLs ü€zä“ßÝ÷>U¡¤-|EšOƒ«JƒÝ XoÁ•‰†úsPzdaq¨V’'ZŸeÝëÌv„hµØÂ| ·,ª€ÿx&‰x¼9|\ €ž®¯Þ(_‚þÜvVôð§·u|ˆØÈæÏwît„gòDÓHsÄbZItú0FƵ¯ÈÚ‘{±ÍCò2[£8›¼ ÒùjH¹ØbIo:qx:¥¯Oƒ‘oQ¢ŸÉ°›|Òªh„K'îÈfÀÍêÆQ!-0'ª®n©ÁÖ8‹)6È ô" CçC}[¸”Fwê2Ñó²>zH©ÛÃøgŠ£>±®ì’H<‡µ‰ûØDçw‡H;ír°µÜ/}lÊ0uS&6½¸$¼’Ó¢ªn™®ÕųTÙ‹£9œSµB·â4˜ÕvâvÙNÓÿȾi­“s§´ã%ÐÆž >nGÍ ï¹úâ)0PÀ'=é ]øœüß|¦äðÇzzô›Çe•ßPcfpR©¡VƼ|NÐoק+r¦¿S;2DWí÷Rr²?Ñ’OÅŸô¯¦§l„ag›Œ´ÞEDJΰËU>¾Þ Çyú“ù@Ž’éÚšit ¡l}û`OÄÖË“\6ê ت_å2}cSÆj™Ÿ8¦…ãØp£ºÝSh´lÅ7=v±BWž:1Ñ„*€MXs ×Êë?°Ã×bêÉ秧ooÜÞ­ª¯�Jï(ŽÉÍ{%(‹-lÔ:!bÄ÷Ï7xÝã1òìÄ…À2ÀêŒÆipRå㆖QD™ç6Ì�dðüöƒžéLï6ªeÐ`¶ÃXoÆÿ•ûMæÖ–Heè{KçáüèHw·î¬b¥ò/^ _ä+Ùò°‚¼f$ì‡ïT ÑW: "«lB䶞X:ü^ ÇzžD‰YÔÃzÞdËÏÝ5^ &ÑÕŽBŸ 2‹‘HM7}¹ÐÉÙªæ —ÐŒæÄâ¿o¹ã[,“ûƒw-“{'q²ê¸¬¼£ø–Zºr³ˆƒŠP&faêlwûêÛ¹¨ Û¹ø‹fØJ 9ë˜ÏÚØÆNÇ É[÷’šÛã“')½š%Å">ìrúkÚV©8ÞÌã‡k]¦®5Ë=/,w-pF~´}¾øóÝéxÑž˜­Ú2Û[6Wûú{«ÐÜÉ·I̘¨fO¿ô $Ì»¦ÕÔªgÖ;}ë.ha”!ó.æ8È­[0«›Ü]¹ÏÍ1ðÓÏÈ~<áœÝ¿ëlþñ¬Ðy†Á ¥4yvàv`òÓ%Í|8=ñw¥"ñóèE†Á¢º_&^6 Ÿ¨´óÖë,KOpà ¨%ü„>3¶¶õ´ã'»ò°»5´ó¹é :ÆûSN•ŽŽm0ë™wg[?µªPÛ –Ÿè€Ò¾;Å=ñ6i.–â×]Ò™Z‘®¦‚pöž½¹#QT7[V…½´e@Óäz¬ì¯µ³c?º‹)ª}Ì+šy¯†Bà.Ì1ܘ,m“&Ú-²w_ʃ¿kUùÔáÃŽnï§æc’ÊT0ÙíOQ!úOîزأTnç´G»Ö (‘¤ƒÁY«úe?]Å£ò5\Kœ†+.\,ò§²•rêÏGF*I¼.ÔÛRUé|] 5̼)�±ð²Ì÷;³ú)yÆ«8¼¿ÁŒ°¥Î4¯þûFK,‹€›úf/&Š\Hšÿ'#ÛüÖqÞ8Õÿ`ã\{H øÁ j¥„ð`L7×:ð¥œç¶V´­=½K¿þµiRoUø»DV¦=¾ý©n_߸»¨~ˆH2V‹rªŸü—uA/MÁÒɸ;[µ"g©JHfU›×U!f+n\hLÊ•Q§¯HT�ØÇÏËB™¥Çˆb*PÓ”AaùÜþã¬Úœ€è ühéTºÕ)WÞap’ íÏvžžSúodª‹Ì³bû åd‘u⢠,¤?£ÜŽ<)”V胂6YI¥¡Á äõIõ$XL§ö)‘Èi7¶ÌÙ=9#ôxØ­¥—Ôe,U­ö{~áhi`¤ d¨ç»­Ùàá׬ n}ú¿QŽ²"N3   2wjIÁÒ!Œozû<SPg¥k¡Á¬®q´B]ä»ß(PGð‘Ì,å™4¨¥¦ Š­VŸ§Îâï_žJ;!9‘éΤ–Ì‹ÉÌYÕ�‰»32ùø•NYµz8@p YP}ÎN¢HÈð¦Mûã^(+—@rMÕìÙH{Á€‰o馣c`ð¢ÈÌÌéwb+Óû}Šƒ@þ@ΦuZ|éi øÀö­UDÍG†KþõC^ßÆÆ �\IzÛÞ*»Åì1ôÇÉ:ù¼dôœ `Î'…xATïÚBƒõåxîgÛ|¢'&¨[{ñÀû&I< � ¡§3îLªW±¶þ1?  lcÙZÇoèM‹úâñ£¦ìÉ�ÎdëS Ÿ÷æ'#•BÜt#²ÆÞSëjtË$Z¢Þ0ßùº¶jedæ:¥ÊÅâpKg0d—Ûâå‡)b°ð«ï^MgˆnÁªÐÚ"’ļ?X×–ã™»íOMãµAe†HÓÔyPî•„–p^8¬îðŽ´kÑ`8B6êäO­ßmf¤7X“Ûç¢\r^寥s«2ùfß¡5³]ÜcÃû¬Þ}GC× „c­£'¢RëYßÝè/C«›b1³,= ¢ÇïèJô_TŒ÷¤¯W'z”e7á‚SÐâøÔ5¦ƒÛ¶}ý æ—–"/4;þ”¬[Í=‚ä9P,ô¨¤ŽùÑ—Ñ„T GÞh(Š‚ŽVh|V ×G=íà˜œ‡AMûjX¼ñ€‰ Cwyœ˜å¹«Â°áœ‚ÞÄà²Ú=-Qãa§ r$ºè_Ž*ÂsªµH½+V£Ð·£§Øyš„£ìx’3È©·©›ó¬óèŠÎÍ34XŠÍŸ2Hö;Yn¤ýÌ!}_la¢ÓäÍ›ÏiŒ¬¯Tßàʶ!ˆÆ[€¾÷?ŒwÛgÈ8/ñd"ß—XÆ"ìO²³N $»÷:†f¥Š“‚Ç¥µÅ·¤å¨”)€’»!²þO%bß“,d jëŽw%¯3çŠÓPñ 0O‚bâ+V<¢sÚão€ÐÍ7'É,SéS¤sïW-Ö:\5 *ä¡æ˜<‡[·‹,õ³½!·ôÔ•xÈX>lLe‚A˜QîêÖK5ñÀÜN¨×zmî&2 3(!C§qX £´j³Œƒc-«MÝM'<Ž«é!CMhçR±mGzÆ£ÉÓ¹A{—+Òÿ¡û?¶Ëûþwú›Û}’‡« sáwÖ ˆ| { Óº4ùõFu«€p‘tÚ€EN´¯eü'kQÒ Ó¡i\v¸Ža¸2MO™Fσ£í ×áßÙ:QçÒ@n.m$ŸêöÈæcïkè£×B‹­£wâgþÖÌüÕÛN—/‡.Zc›¥ G‹瀨ꀄýl$‘ 1{DT 7£YÑs ƒòª²Zl<mX•Z6³9V§ñÊ)êÍë=£Ï›3UŒ¾¢ÝyرÐþ+þ^äa»± !veÿè.‰ fR´ä¾¥t=¦v•‘”ÁM:AlÕX !“:뵤4ú{B}zâ^¬Œ¹§ã ²Êù‹âŒ1£ajÒÍË}#:õ\–Y»cóéÞ4;h™Zq§sÿa’H*À¥…¡íh©ˆô·7± J* ;ªIÁ,(!Ú'4D›oZ”…Æ]%þ°oý™[èªeÕ[tÈwƒÕ0«ì‡iÐ'TØ *pýI`?ÄmSbÃeÏh++šÿ1Œ†Z­¨hÖR2ŒŒÒÓ�öjct£CPôcw}H`}Š0ˆSG`Ìï ˜{»®ÆêóF ¦8dNgp?`Ç+¦-–mJŸµóºœ½/W³÷›|Q+³\ËöAO¹{yîÍMY­SEý? ùÝóÎÖYƒ4*†©ÂÚ•#€éJBnÑßÀ=\²‘6 Y6Dœ:Óû‚”÷¦£Õ°Qfœ°úÏߺ¾@C-óÜm�³’h2k£†ëPOóÇA›ÌXù+Æ…•ƒe$!ò‘]JɸFu0µ;ú�Wdï±ÛßÀ¹‹ÒÏÂ$è+Z„§(|4gƒYßëgVY«Nã?ׂ$7ë“5ø¸Z×·èGñ°Jröâ'g³}!ýsû;ad°ém²Á4Ã"A³´oúßd*£°½b o%Ë ×öû—Š÷qŒ<˜)þÇþGVÊÊå¸Ü¯ò•�<ì1`¤uJ&lh°n£Á1eTñÓ)ëu˜5øÏ&áQ”ºÙ? ±)b>_}¶£µß&€•ÄVÏ)ýýlXF®P1’¬§RnÐ'LûÞÑ®´ò$2—�ð~¢¯Û‹øVï³ ×fä!úðβ&eSõô³6À¿(dŽ¥üôùÎOýî2ûÎ+Ð*Јð='ÔÜѬƒ‘êÕÈÂÆiÍöNïf}2<-½³Ü“#uwkûqóÁƒ6ýke¡ž&î?YzÑí×ýM‹=‰<µœ”±Œ»„¶Õéì¨ t@:ÃN \­±7&ëÖ=+>/†·nÌíoà‡¥—ŒX–¬ä×*Vu­Êã4Î>Zã͚똛ö Æ‚¾;¡¡²zž<Ä•'hÉï0òˆ} üË)B‘i‰–JÞ-*-VPhgü÷­ÒMfÌM^ø’*”†Rò’êí˜+òrÃ.VÁô›Ó«gyw…¾±­ÊÔ³Éx JÕI7[Qp”^Ô°¸ÛH ÌõË‚ré<âÓ¥ƒ†–“ÒqjS_z«<!ÀoXaäôƶ9ŸV!KOgOyL–ióÈÒtötÍ&•ûXt>o¶ ¼Å4ÿ=cs9¾m;:„¥ˆ?r[…WíÐ>¸¸ñJç }¡ñ<{F‘à¥H§Ôöàp®ÍF6ú§K•‘×A=‚[i¥ÛS'ék£’¥wܱÄZømïU¼Ë»ýÅy;¼]»$¨öÎü=6Êù&=¿aç¦^ÇGè©Ç$ÊŠD°IkÔTVû^OûNX;ª’•¤f ¡· Z[)ã:ž†õo~ß“€[Ä]TýòP¦’|am÷ýì P§‘Hgª>-¢˜«óÌzçvç¼"SýÀ›Á²æßL13kNž­*ž¾¨Tju èoIñšÜˆ*×€øÒdjÃFäÅÔxó îeª¸Ü²Àlè¹ y´*‹Ab@îWöÚïNÙò½ßÑrä DwŒR$Š L"VÂ=Uæ?uº™-U…­òà%ߟ—6/ÜŠäâ´†4чWüº1™»z WSV.œ²m`5fáö…Øhªn³ñÖvõ§Ýë·/)2_@.ÏNïn¢ÜvoŸg¤‘ªÈ€Õ¼Ž'Éë~A’É«±2ç(WËuô€Ë­£TlVYaøÒ®w:Ýk ‹§à<W'ª#…ãVáapšÀ‚ï| ¦×…Ú“°òÍHøËPùfMŸEé6Ô:¦ôÝå0?Ö½ò„K…Éþ)û‹Umɵg’;…#¿ OIœ<»Læ¹tˆ›«gÇíÍø_0Q= +MÇ*HmŸ¢`ùa5"më$aö¢¡“^&ë/¿µáªd×Ó^¶âc˜û B½Ò„úA?è‘”Pºªs±1ª êõPù)[~[p”%/K%A>ƒËµŠ¢/±ä²< W1úøAߦh,à caŽ+ljZ½î—^ru¤Nßþ”oR¨ ÛŒk�'sÏu㯬Ì}Õm¶¥iš,È Á‰ŸR¦_ç“íöõÕ/Ž#íÍ Þl&ÍÚ®CËÓp¯¿‰½·NñØP¼¦ÅY{úÏñê ÆUrÇí·2 ïê®o ¬ 3£=õ s5D8Nl±(6 ?àL5ì)RbfÁ‹Š±Hߎcü�v`Þ·Þ¢>ÌŒ²•%=æMm»gƒ£Ø9|–þHo]Y“@#yˆR[%KN¯l÷â÷÷±=*7¥åkìÓ í?MÛ&¡BÓx¾jÆÉåêû­l®ÌÝB µƒED"+êænú3¦ß…Ú$_ :Ç)*÷ÅáFì¨ ?º®÷ ú‚Œx¬¿{Û¡-:WËzë)¶ñJEµJýhït%eRf|\Q«Es(ód’{ã²3BqÿÝ•ds0æPjæQ%n’2LÒÕ§BÙ²²ázë2Üɉ<±TrÃÐTAp¬†ÚÔA§Ï¼dèl‰*3Ò:t;³óXØùG1½RN­x¤b¬ úNÝ;ÇVG€-ÑRø õ«÷ßúG*v‹ˆ>Ûîé+¡6ΑiŠùf^²œîõíáOø ‰K½8·¾Leîµÿ씿dR�8‡Y¥­dŒH²ìÓcõ3pЛpQ½vnÄv_»>ƒòb��ƒPdq2-vÑÁ_ä† ˆ73Ý‹·yng©Wç”,ú<ˆv[ÓR¤c­>O‡±R�ŒOé­:1 hçq26ã?ýÚfJÊì³ ²ÅÒ`A¼éíßCZ~°š±+ëÁ<Ëü>+æQÚZVÇ v£.øƒ`r¤,$ñ;¥ÀsÀqR4ª. R(ž>›}Œ¯Óðo”Ç£05кÄ(Û.u$,ð™ÑE˜Ç·— P®(Ñ»d1-üïVF YaÌj˜ ƒ\$¿ÑöËð&:,h]j%°AaÀÏ÷XÆ0w¢m¬ ÓÀ²¬ZÔ'f ïÚiPí»AšC¯;ò&a¸b¯E’¼‡Ÿ­g“Üõ€ÓnTºÿæ°zVn;«¦È�¡æ‘îbÕ!PÂc²ÂLi¡2ÕD…( d8OYðÁ5fô™5Ø`*ý¨’, Ü,èN"ÛÁ×K& w”±öí0Ðy9Û7éÎB)R¤Á85×Õ¿ÀIL•¦Õ_L"c%lµ-Øì—²AÛëÄœžJÁS÷š›pœy0^†ß‹TûqãÁÒ¾~vÀImØgÆI˜Ó.Í‚¼þÇœ²Û¾;Oo-r‘…@{þèfÐd;Æߘ,Àæc�EÚŒ©î~Áò…ÎP«`¼ÊÚ„ÏJ'Úæíjº›à¥tŒ>÷#ª"ÁJ†*àµ9Ò†JÞOÉ•v×°«‡ƒVÛ”‘Œ§ÿïÿó£ÑðgxòºÎ¾ïrq+ûRÎæþ+ҽ¨‘ÕBð…ï!«A©Ôt8ÑùÕò.À>Ò\Àr#trö©kFUúšµ¬’ò‡þ’ÊÉ–™—ü.žÙßXÍU±çqÜË ã;Ðôç®a|=|Ð TÀÛkœ-7Æ•?*ú í™Zd4Nväãµëâ foh`û{ø± p¦°ÀX”Ã. Âwhˆ2bCH¼BÙPÏ äZÃ8g¹NÐ>]ü÷¦Ü¡sIH`öjJýð’Y'iæ¹C% A‹ë‹©SQÚAñ˜Þ•‘±´oPhúºÂŸåÅÊCƒÂÄÜWAx<µ¨íøÕâ‘"!,};R dfÛï¤hñ¿±zÒw4Î<óy˜maÛ¹v,CÆ/VÛóñVö,ÆÂȆ…y`øËkn0*Äg§ôÀÈH½N·OK_– ¾H{¸÷-vü+.óÇÑ>QCIÜRꬤ¯QÓòn»ŒŽƒÓ§rˆÀ½ê‘ÆŽZ^ ÿe03Ýý‰s œÂ“B W(Õ¤r œ=˜NEœ´¶ÆB©Ò:5bßôÕ¸°G 3îñúë°þÁL¸D‡êÖO Z¡Y¥¤³òä¹^ɲ³NHÁøaü$ì•QY”ö½áÈûæTÍlîƒ }~ªæ8k±þ^NnÅäN&St«áâéÉ|ÈÊôªn”çYé!­"€ýè8ÕÎ`T0|j]fDg3>x x.ŠU{1Ŧ¬Ç^Ü×ÿô]#¢á‚òšUT)­¨Ôžñ… ¬µÞw ·[i,fÁyþø-ÿ0+ÁX±ÙÕÁL)˜:“Làt¬7½m´§èG0Š~°•ñO†0Ì<g]¨½5ThÙÆ~ÐâFi‡Ó{×þ*<€Ö= Vaý#ªìÆ^x×SrøÏ»±±‡Ùb—!ºm,Üc”½–™5fn+ÄÜÌÌÓü†%ðønVŽ‡‘àûó ôó<žì+k㜺úã&.¤¡ï O«½¡}•œw)zé‰Êj'iuš´?#«wØxÎ-í³Xé:!?àŒ¹;y‚QTRº$e¬Í—Rf7*S€ ©f:3¾œß” ™LpÌÛ'—¸×y¶ö‰Ùlˈíbkz¾»–2ÍãØ)9¨n�”švô}}ÖâŒÔå",M ØlsÚþµNù{ÝQÁ¿»P 3Ò¹Âhÿýæ`âäËÅçO—Äâ"39ao@æ<Xí–£œŽöˆiÆ~f™±Õ2²R¥‚4Li)&Aaé.edÕ„æ`w>°³œ±­ýæPt×ÔðQÆ¥úžÖÈ¿í\)ZL&b¡9üî!‹NÜz£ììó á¬=°¥b/þHáõû2,ª—Ìò„†InÅ¥×VA±KÒ£þ@ÁûºfºY•ŽGp&Ç%D±Qs‘ÙNÉ1úÇÆFŠ@¦ã Í9ŒvÓzü„[:ÁRÀeÒàŒ1I³såÁ|ÝÔ¬Õ †oÆØ/î♾Mæi3™{s¤˜ô5X^‚º´ ù¤[J }Œ~ð´ï0ì•ÇhbÑEðüöGhâbGi…÷§â7çcnÏGQN@NƒüSD¹^ÆJÄx“ÿŒÁwIá8N³¨9æ0oáÑ+¿7MJkü$ÌS¶I*÷—=ÕT6Tó_Ú$UIèóôã8.EôV‡5’.œ[’IüÐÙËR7°ñvöŸŠ}Êbq)]Æ“ÇDHÒ+Ç003¶8AÞ Þ@’p>¼v<ಜê–çÏßsªý´<á}4¦´h]ŠâüâIQ”ÁŸÃf§Cm<yÖÍmè:识Œˆ E{«JÔz«‰V-Õ+…£¡qÒNÛéà‰ñ³†¾)Q]ò3x+4H–; L.3…ìϼ3n{†Kºù"㹿å1¯ ˆ“G‡³¯tÃý ,3ìûCâsix�Ö…ôÝç2ÎÖ¬#˜/Ž†ŠZIÈW8OG{u>XxˆÛCÂHÞï}F=Ó×ôa<¢$¨«Èsv´¹$AuREid%HQÈ«îvÛ j²»¼êž®J?uýÔ�ÌCHþÉ#ux⇳ošVcÍ€5J r.“͹Š)%[}c‘ ÌÌ †i›îÐû{ À<jÄ©y)ië«ø{ÏÒô­¿ljжçþ´¿G�x÷‹Gø²ÂîL,ÑSÒ{�Ë« èOü 7“É3™ýç Ì9‰ã¼.ÁO ¢¡ÿ4_f¡j2d5Æ-•ñŠdŸ'A6i‹ðÚBœúR³qÂzAi¯’<cž¡Qš¤­d˜îÂéæ4^ë~•¹©Jx¨úF=ŠèòòcµmÏ›ýLqRÌGEßM¼Ë…Uô„[DIá ÔP@… H÷ƒ',7Y£ß¤C,»M `šÐÃßÝy‹¥YæéíлÔYPî>MU1gt_/Kí€-‚Jëშª îkû2ciˆaz¡NPù·™”tI¦V‰p/¥¸qâ)"åÇÙ þÓú)¿ YCÍò›,�î]Nça øÒvîxÌœ†¨ÊŸ&úÀŸƒ)À(Ãó‹7„Á|×v´úú…Ñ/¡Q¥õ Š"0^æ“š¸Ñša‡næÓý F…ÞòŒ­õ]Q[ç÷°°X9þ~ã|fÞˆÑ(wóú™"[²/EÝH0$ÄÅ'‰þçàû}PF¦ñžpá‚þ/(ž_Š] Œr=º-­ŠŠnö£€îo^WÏ!Žb§ Áô½lµeëyXNŒr‡jU‡†vA2ÿÁÊ}næ« ¾»+¥ f™gª@ËrÌhÒ+ÕÉdoê^ùß7Ì")ü \ßœ´Æ �ÈJ¡–ßµ’ëVm–n”ðiá+iá÷×aÝN×Â^È}v5f¾O5[²|å‰Ö¡‡¢eë¬ág¿EÒú~ȼÉæÅ´:, w~XÄÄ;ÖFü–)ßZ±EŠ±6dsHq¦AÙéèÕ‘È;ͦg`ŽŽŸ ¢zÈJÃv€)@dU”þÙV"1M ˜ÓêéÉŽ„·¯kŵ$w¢– ŠÑ¦¢?6ú£M̺°2gå‚Ó½î,êk/ž8h~gÁ)NhHÊÑ.„açNhͨ0ÝßIaÇy´ÒûØp{V"ažŽÀülsÏʼnC,ílÊ3*vDr–Y0ÑæâΊ¡6ÄùÞwTÀŠþçs;±¤ði;a…ICP½OvBï#ó¨°W›©ã.l¬®°?þÒl”Ff.�ç¯="?zYfûñÊ81ÛáøÆÖÂ"¨Ì³¨8Âf–)Àò¢=y̾O'¬¢oƒk«æ†OEµæü#7AAÍ¢''öbj©E·^Uåeg¶iò(ƒjùÏ/¯Ó™¿‘øiˆ±žgDžãB&²9t}ZÎìfdþ#Ÿ¾¿Aeä þÐz™Á}ÝÛñ]†ÆÀX…}©O•ž;ûñ±ÄÏ»ë2¼GÁ‚R»Ý7B?qîM‹9a=ÝÁ‚…³D§=Ž TXÚ|T®ÿ“91í/£µ«¦"¡‚G`ôZ,ƒÇ·§ê`sµà5zýÖðÕYý°â�Ðû< 2KÉ¢£¸;¬Ç°×ôö½¾¬¹õÉJ³:B› ÇØé˲éS²S‹G€k®bmËQÆþÀ‚Ïž ž¨‹Ó"ÎÇÖd[±—]Et¼a£Ô׿Q}‰Ò4K”Ô’ §qìà[Ò[­Ž0‘¶ghÌnbÅuJúÎzDfž’ £Àyï}ÜEûÍ^j¤3g·ì QDBãù •`»­X²f}rŃÜù?© -{›á ¡þ4•”ù·¦‹-’Ž;·0v¤(‹=^pÃȈ-÷IEÁöâ‚mÛQñN+íxT|mãtœq p³ÛŸkUìVô¨O ª‚zs¶ôìÖÍ;úøGtÝ¿ˆ=cvâë¾ îßÖ®Ômi+¿ñJVõdT²ì…Z /Z5Š(1÷ø»¹hP¹½Ìxa˜hµïÚÁЯ9ŸV *bæÃ.§ÜæÓº`àíáé¬ 9¯«§ñ÷¿Â`ȉç�\HÇèþCïÁà—ýt>J ”*TK7Ù‹‡ÛÑfߪ!¿½f,’nÞ:e=C#µ‚dƒÑf°A—=z„~õ(È™W@‡0§I‚òÝÏóg¡êrßÇ$N{´4÷Š)äw¡æ?üÏ£fÁFú3p¨±D3Áb¬ÚtaÀúUwÌ7–˜Oý#¿¿³É’“—ž€SETrÑá¦ÀK…Ûaþ蘻W«s•Ué _ÊÒ  öuVX TYÐal¦qd»êß/V dÍ4~™€y ¤KªUßøÊ¢ùÝ#\^0ˆ˜LZ¶êžژÓðF–uÉã½ZTU0Õ0²rëý$n-¾qË|Ò¦ð3ºþz€W™'²á0ç¿€øÚÞ¥Žëæ.cqQ#j[ŠŽœÌ5ßÖ‚xº¦Ä¡Çý ÓÐÎ+ƒrÒPÅi €4˜,·~Ÿƒ¼ƒÝ ˆ V›Iß5U†VÈîl`°!8eþì—j«Ë–Š¡ÓÙ¼=OÄEuÞT hÂM¼nKÕò­šï„À„&‘èvž¾ZôãG·ø…À@œzÍ8çÈMòÖî FÖKa+~²A®4ú1½)î¥àó-¶Â´ôwÝeFö= rÙ‹Ç}âdÅwEË2}µõ˜ cÅè­.ô/²µ8Ž8"tת :_½”b:l[‡ÎÇ£Œ\¹x€¯7 ÃKqÞ`­šš>ê»EòbЉK3êþÔœª}p²}ëÕT -ÃÉz‚¼Ì`ˆ¢"«r'šÃ´xøA©› 쾘õÂïo&‚lǵ ?5†kR}zô OúÁ§�v‰b¼xgN3²à¬•~羆l¨ï©çj_±(ñDK´ú¼zæ–»sÄŽÎiû¼]ëIS7?:#»kd–1CO÷:Ò3g:ê7uÛ¯%…0ƒÞîÌïÏùÛX*h=§A^Ÿk bÍ[MQ”=( Hæp: {èQË9¢ôÞ<eM4h0¼kŸŠ{ɳäX…rˆ¢ÒÍŠØ‚‹¢“õE7äÏAu¿nÔ­º<T•_ü�ÝhXvRÛ4ˆ‰™ç`žˆ5éHxýS=‡[ØôÀ*”{‹<�èž¾±Ìñ!Cé(3‚úHÙn=?w–püÅ ÑÓüý4Š)ÐÚuý¬}ê"æÝló”6©Ò3 na€Úæv­šGÕoMj ¿ ÃÃUúzËÎÕ4]O·ËËE~I³v…±Ï¼ü$Û^z €|ìP˦‰x&·Rü˺gŸå»þm®<ˆ ¸Ö—A¼ÛyÁa¨˜Ÿ©¹>±¯(¥ô—YGÅ^>Á}ú.äpU‚b­ã½@¥¿Mûó¶1¥¦¸{™íëi¼\õ_4P=Wy¼ep€¤HÕªŸ„: ÎŽÛ" Ó:{ÆNC¯ýÂ$ æ%[Û(åóC†ýê8ó ¯(JS”&Ò†T|½ÛI/ªTª«dd·èÐ1ÿÞ ÌÇQâ7òA<£ŒÝ€L“.wë¾kÚ÷Ä­[®˜³í]ŽÒY×]ÅBCVÔ,þíÙž"kô'öÚcoz›ú"òÀ,ÿýX¼ðä˜Øpy_SµÐZ;AøÙÒóZ!ûϤT2ÕýA¥µˆäãŽtÆ ã_ܲ‘v5Îí6¨ë.JeŸO "_APöÄ¡?µÚ/P] µ½Èšþ〆—*êïéöìvcöš¡§ÂJѹíhÉ'¶bGÆñyfÔºjPÐe!83³Ÿ<ÌÙZû[›ùah¦— l4g+}–TVøОOV0ÇCQoëzT¼áº_6ˆ"•T}ãÌx¶ lL¿{µªÜql¼•æc”<Ÿ¬š1{ÇXï†ey(ì U%ìx©öë<”îÎåN°:hÏlæg^î� ^çKߥ¥nï*:;0.@T1h}%p5oÈì¦H[ö°Cf6ÝKd¨ômÈzú½Ú®R'ˆ0¥çœvè?$ÖÚ‹nê`q±^qì\HB6ê™?Ò ®mÙ„XÖdfã¤J^s_ÈlÇ?1ªD›#Ý›wíN°8Øp@$¢¬Î$eî瀾´á9˜¾©þ¬¥xºrª�#i€þÎvkg‰eò&|^¯Ù‹K'ªfíoºýZÒ8 ö_iPíß=É·ñm¤ÅX/ôøl,Þý•ûB†)Ê–jÆïX‘©GdÞr¡Ðγû[\ ΂÷v¯ýt.˜¬j7¨Ÿ–¹3EP¸²>Q¤¬5Á–5i…¦]8e;Æ�SEõµ¢NDÙº=1OôÆÆ0Lu¦úx 5?qŸÿΈ>M õU gy0ìèXªÞuhžð‘'NOfå7*ÙCÿ…­¼ð»êÐøQs+¾r;º9Nf3g:8ó™+µ÷\t/ÊÓ•Ó'%ÃPœè¬‘"`SØ’b‡7|ƒß;ÝÅY¶2dHÙô;95îˤé =ætüÆMÁ‘âPdER=GŒ_µAJô•MÔ§cã}äpÒ;¥!‰¼æ´C"À“$ #-$É^¬Q¬˜§Ðæ¥J[b¼*Âzªù¶ƒY°t×ÅÁK¨V¤ÙJ-z »– µÓê®QWïkF¯ŽÉìgÛ}â“d~›¹äwÕOîø)¥äubLÀ,¶ûg”wú.¬ô8–Ï"ˆO'—UÉ£à™‘ÚöõIÙ˜³f ÷Â.=”iEômÄâxv6×(ÊOæýi½^0„Ç àÔŽˆFY—%Î"'2çÙf¡[mZ‚ìë‹AúÍt>£¹[·*}^wijhíI J.NŒª/³O—éq¼l‡j™±aVíÏè«]í ;¢F¶í¯fžQζcô¦Ë–3o ¿Cç!¶S=|ôW›LŽÛûW:€·Fghé´.6ºdÃ. Š¶÷àîwŠIqÐY©žÄ™GÒ€kÚô©óÚ¼ 3-u¼Õ5,m¦¯²Ÿ ìFYtC빤°ÏnÍ mÅáD~še%¡ïr‰£! 8ËX|Ïe�¨Ît¿È9«Á°_(¯,«­âžWm ´(½cOÀ™ÕߥópÅÌ9ev’–îxRΫÔ Âö—ñ¬Ê3{¯¸iÝ^©ŽÛ«ÙFQ–!bÈ£8 Ü’¦[§ÄÈ`ü6Md[m{D@.+™gÊ<b¾L§Íbo(ÆýÁKƳ'÷áééÿ°VRßë†é.Ç.æsÛu)ŒG§á=Í<’Ìñ)D«‰îdþn…Z;ú±p³ó4Ãy\ÿlVžè¶Fk¥%h�åiPôVJ±[3øª `ЫáŒÍ°±»2+ }Ø7šèëT»½"KÑ‚ƒD4ûçŠÝ-ëÙ¡9ÕQá¦ß6ÿ­ŠqnÒ´í•Êü­Eýälo#`Š€ñ=œF>°T‹\ßFXdû˜šžÒ.hîPè|uTî{\®ì2èë /¼òkÙBxUK‘ ÅÚØ*ð^=Ÿy/fåjÓæO±§ã™ï¦zö<Dý†ÏöOÅv K‹¿í µRkS;¢©ÊæÒé5'QoC}ÚzàlëˆpY8Œ[ÎŒ@ˆGËäI}±2ºï/®kZº)?©òWôìã Ü«˜X²tb„÷[s 7€d}B@qÀò '˜š”Y!C—° êΞú›iDŒÔžÏp‹vŠªiø¸aûc¹0§´˜žÉÐ{Fj\D Z…ï#͸%Π×/ÎÌ;wŠz,`Hk¤KoþRf12Æʬ?‹1ºÖJjæ8ý™n´µÂÍ  –_øþeÛkj´ ´Ãnï€6\£¿Æ!+_„lþ¶újrÁJÚXe&Sg˜<j˜ §Bo�” mŠÎ 2´îܳã&°·üNSl熻³?ý'¯'¤5º9û39V^ tÖ9mð/ÿdâ¨"¢~™é)¼÷JüªI§¾þ§þï[Z*A/4ý¾Éóü|Œ‰ÊJ麣�LáC 0”>IcÛç˜ý�y¬¹ÄT·ç°[+A[­Žñ}}íf&›6ÉCPϱ&g°?)Z*8%›¡>ô ¬Õl]5íÅÝaè[ØsIÆPÿl°ùFÈTÜ ï!8¿Äù{f¿H"¢ C!´ã|Ô>¬ÛÄÕÔžNHwWß@¤JcÍŠ[^0`c ƒ¼Q§õŒM#¡ÂH/áEUáÚ²çÛ}£ºs쀸iR�¤ZŸ{`S)o§“’Öž©ŸG6!1ÄôA.f‰~tÝIôÑ�� ýSŸ¡¶a71 Çqà†£ÜŠõO%ô©—º±(=}Î:5äH|1rô•ª&ý÷W²™-•†­@›={å¤Ö(dMª&­.M®¨–è<ÐdÒ¸"}Îߌb¿}ŠE$Á»Õ`°Îçñx,ó&N’´Yéø~à"“9†Sʽ;�t&[´‰Ó¥–ý¨:ñœÀy„Òî3îdÛ˜Û˜tVû ”±˜?g6‡t%Ù£€ÒÏûžìˆQ5EúŽn×ÉÒ-Q^¶Îî¯>ü4ñ¨;Œ¿â@÷Ù{ |Ù¯žbÔOÁ.õ· » ¡ý`K,´¨Vb!÷ÁîyÔ+=G–ï;~¤IP1…32øÜ Ý- )…\Œ£°‹o^ NɹÎa“‹ È6tVrùßØBY…1ƒ.®‚SO·9|_¼|{f8…× ®ÏÛg‹)í³¸¤3¸ ¢FçÙ'ˆãTDbGkjq.ÅÀçè`òæÇǨ«Ô%cÈ7p"GežO¾ít-´nH'b3P”»z€kô&‡R™Ï] Á ep&,�3 KÁ,ôÅÇSû™Õ èøAŸ9ÙžL{ç/O¯L£@¤¢®äzÁ%.+W~‰%cwvW¦ø¿àŸqj‹¡uÑ©#ÿS±ížñì3ß·Wx¿´ÜW²K¬,Ãxc¼UõUi®9¿~‰a«ÎGñì5*iPd®¯ê¢©gèøvž:‰µ>›¸ºþ±’ivg*ÖKë9Tqµ5Zýðïmæ›kJûíib6.$)-‡Dì‹ç†Fg“º6/ûɤ¶ˆ=µ´Ûõfqëk®¾[—nIibAYarýØð¡oñ¯ìç@™óþ åмžÕ¯CîÐzî´ÈÌ´|©1%³êÐGxÃdf†Éý dA‘ò%Vºä‘€®ÏǬðÍÛŽÒªürò|ªeßÔØ—ì\Æ/�ùWSïG?!˜vD¤NÜM 㔋éó€¡Ò/hÅ_‘È {>‰¯é237Ù£í°¦‘ow»;fÅù× 5õyÚí¹9؈2j6!Ë*g ¼:µØDHû8ôÍUOªßkØÇš½åÆîpÎó ¶òè°óÿ·Ê²0¬Ø4²x þöꚢŠ‡*]u� ->]ú±;ô³¯¹ÆÌòVzñ\}T#ñy*ƒ#éÅÎÙåBWᦛ!¥SÎßÏȤ}qœociéij±U•Ñ~ëÕu[ˆ¹ˆ|‚Q>SZ™Ð`Ó¨ô¢ýÿù®¤t@xãaãáï5R[H5öo€ÖQžf~Ô¨(6†A2h/¢¹N–†“›ŸŒÅ»Ú×'>•Ÿ ±Ù©£C¿î=óx£ÊeÌM(›¥€º">󇾓]z ÃäªþÄè_Z*Ô’ºñêeªõçÃèk¥^jQ¶Ö×;9ë,öÁITêÌ#¦Ö³NõS¦z7:¡ª_õ,æØbé\(‚´³˜E,2ÊøiIÎjlÎÌÿ†ÿ¡ÅÄ'ƒ½xpDx{…!¦ï6Îe9êÜ[«ôß(T¥eæ{ÍQJ€†m±ÌŠ|¨qŸî8Ï0•\¼;ƒÿ*Ü\Ú�ôÛõ¿Z“Êb„ÜÕ…þ«õîÃ^ôé´1ø½}”{‚¥ú² ›jçî¾Å“;ÔNɬ¾˜91×èæ•-FÜQÌËÍ––dÀ=ëŠqgìS7ÓÏrÑEæ3—@A‚ýg­¬Pz×–Tíx} ‚°Ù‡FÄoÔÒp¥ ×*¶=y±r9(ÎÎæÚ†¿¿pÖö!T°É N@ï;fà ÅHWþú(qîwÊ® %$Z÷Ô}=ÔT¼z4µ) ÊMÓ¡øIfÿVÀD…Å%×ËüJ™ÅÏÙçMÅ]“-Ž ¹@›s¨ÝYÙv¦´ó.åK>r°J_+? ݳwæÓ!uè/†ƒÏê2´zÖ/²ÉÊÃ_"fzŽ¶¦ª¡p¶ÿdz¾ai“µ¼b²™—‘iQ®Ë�”Ê`J)O²€]œþÂÕr­¦n‚0%½üíèöœ¼Ä¼15‹H5s ÁùO{²ld3Ý´¶‹(aåý¿#¯Á»ßü¤H™%.â±s‘άì\; š ¨@ÝÅË×DQ ¯Â¼?Ä”‚¾Ï)'›t®ÆÀ+Öd”̶ƒ™OÔÇþ²ÙcèÎبý:¸jÝýÂó—]p­£ Ü5¦/˜šF]…Mâ±^žî¯0?+NÓ ì-Žµ²®A÷œÝ•¥ïy Ø/*ñ­v ¦B1v1¤ úïG§gº¦±[)ÚĈH\¶€T¾¢%tú8žâŠÁ$æ¨f‘ 60{@=(ø­Uu8’’;é;ÏzBòBƒú©ªöˆlÖ´àFçB"Q÷¸@ß”)#ò®bòV›$õS+îüWf‰ääÔ3 ‡Œ²¬Ïmi’™d™/öÈ„ºE³…íb¦?°úâŽÒüÑí(öÏî‚ჸ(Î2tI‡ØæOIÁE èø�âEJuᦸð©íÛÁvî͵¹½½Ò¹~š<y^äúø¼¶RgX#¾]!ýˆVÚ†° ´ãöfÇ Ÿ‘r¡ÃÆ,ŽÃifÈ•¾:C¬Ø€Hs]:%ò ÜYs´¼ÎGX íM2ÓÕØû†ðÍ![‡î¨kþ…ßãIÍ0裰>{x,ìç±?v‹=JÊH\Bã\½ëÒ÷Îà$î²I\ç’çBºt—éæ=`p§±Ë¯¤ªQ†9SM뢶‚•011˸nã¬óÏA1Óâ™$§ja“œ –¡Vñ {×Q�tüñ?m @­í€5Q”æ\Zùë(‚ÂQäíäAÔ»¶6l‰éÐ â{¡C+¼‘˜V¡X[hø pÚâšWëçwó_ú[±\Å’79åRì]Ȥ”Â3Ÿæð™k|~øWÏ°DÎÞHœ”âÛ켈ï³óoÒò¤LäÔàP Q̆¢dÊì_À»{ôŽÛ°úN!.Js¿ÓŽ¨›ÒíÕ“-Ô–U @qÇA¶?<áy(ê³£³=4&BÐN Qf±CEkmòÔâÄÁæ+£ <ï@¬ëþq];ô.%?&,-v$HâS*¯‡#†À;$ƒ¥å<ªaMl}fÿeásr¥i8íèÃ2*ò\|5ASÛ-ú1RÜ¿×åŽç€^;ÉãÌÆ•Á‘þ/¹¾µÇ Õ,‹°6È$U52쯦ˆPQS£wpút”èàtX âl:{H¿­`+5^˜Ú‚GžzdÕLÍ1Ïb¼—q·WXª1U…þÔ>¬àfI+þbÓ¤\b/øY²—Î'ZH(õE¤í5Ë$}8w˜Ë'F­ç0$9Üö<ýÓYÙôì¾Ø‡}œ sa^|7ÚÒزu`iGÃÀlÖÓ±nk…ÐQlçYžßGÍI-‘ü%’.í)Ðê¤Y{Ž8<×Ë©y%•|Ön–{6ª{€fp÷Cé{MNÑà³÷¨ç¢Äç4XLlÞ†gpÛ<ô¦Üqm¦”éÁ2°mÄb@d¼LÇJ„jù?|c={„LžëÍIäÍÉÓ(áÓû·§N\7ºWåâÜô½ ã?µÔ0I`­éÈ òkJdA%×ÐI §OG(ñJƒÞ•PP?YL ¼7ÏÞQú[僤Œ}34TK$‹JÛ`žÍÔžYõ’Î'f¬àŸ·©ÛæGeQd ï€1] ²«'RŽà`LBŽIˆß[†–ñ0gJCO¯<_½OŒ¬Š%_9=óÜ¢ç¶Lè ïâ¶õ¤ð"$çÓt\¯}å<h:v«ö‹s5J´§·ÐF),ü bœ,rtºàLé¤æ]'üEï¢8_i;‡AGwô¤JG âyܺ2›¾È”ýo2iê‘y Ž´øúÞotFv5%›&=3 ™M}i®Ì;Ø™À¸ª¶üjuHðÈqÚFÎÄ3Ú~7{²êŽ¼ÿ ¤tÛ ½ >8Ã~¯û)O�<Î}&ÎÍË2éh‰‡`/^öô±ybÉüœyïäÎ÷.'{qWf+œ¥#V÷6Ú]`Nv'[�À4rç¥nùž/ÝÜo眕;€n ¼´µìNbZniÖw›ô=÷·Ë¼!1†�UZ¬7úñ´/ö,¡&)à/uzó2ó­'bÁždŸWo õ.U˜ëzaìžT«´’NÖÝzóV¢2ýJÌLäÇ8ã°WBµUƒ%Æ;Ú`–N,eÑêLžÅ…e>È݈÷½ëŒ»Ò±˜HÆ‘{w1®ˆa—1{i̾ÖNœƒ#¼¬!z¬78Ùb@oluOýžh)[N£íýw¶‘Sª±¨ÍãSñX²kÎ_îËü`¡ëxY誔(°­c½·Y¾��ùgg¦ý³¡c‘ZYã@Óäå£Z>1¨Ÿïû°$µ½0aÌͤåÏ‹§ ½ÙóÄø´·É¯'µä]~ýI³Uk<F†H0»åN;T'W@ H¼^ =ññüH ¯XÅ@ÆG·#þšmWÙÂ(–öÁëýÈI®Ä\¸Ç¼›bÆŠEVu¦AyÎ?ï £·[(épsã)¢Ž½T×c¢Øñ�•¡sΕ­RÐÜê}EÛ Ích–Ú4^¹ãò’Ä· %|ÚÅ­ÌØ'±&H8A=ð  ‹†É½~¹/�Òl%Ÿ\ãøqÖ›*Ömae±"ŀŦãdŸrø.1b5Ë.gØDžéü©ýˆ¡µWعãÇjÃâá£ØxÚ_Ç< òYÕ¹Žç^üO [vȮ欥–¼l:l·Tös»UÓµãjç‘ŽÐJ (¡uØ瞊âîÀà3rÁ£´9‘oóøÁjÄ?ý…ž’Jh¨m„Ö¾,e½Ûƒ©nšqa0#O#n~üV]$*«[”åõÙ<izˬ²A}÷>ýÀJd/¾4kûM”‡¾*íT&À^¬jÏlÆa`±d“ïüR˜6ŠKŸ�Fk¡XDMzqUîÁØs´Œ1‚sãE§Ÿì®ÖÊžü)ë?SÂAèÐq ð,ùÁK? ¢–>ªÜ¶—|ä3¸Ä’/0(€o”RÓ³÷Ê®òæ¯ "—U‰r-ö•I…±ð{½ù<ýÞ!§93÷”–~ Ha«ºÑL€î[½š:F™aúÂ5ìÔ%Ð0ÒäðYç¾Y í,‹2GEpKƒý. ¢N[@Ÿn¦ó–•aªi ö¢3űÞ]=If¡xR$œFàt'nÆ•ŒâJǾžWÅϺƒ±*;È( XÄVV úОtù¯”íž ÝEÖ …þfø¹ód\î /;y‚ÞšgýŸšg{~6P6§}©ø‹%íÝÀ⯠ÿËÊÑYsîty-g�Ä8üÍlNOŸº\ÿ'ñ[çã€þg}kZ.·¿x©´ùê<¸ü©‚ÌŽ|éÙÙ¿Cj…©?úEÊräf»§Ñv­×´DF@) ,LêùÐsr«ùOå¨dÛ? ½Y¾ÿòÂêB^ýõµWp9Ï9ËåA²g¥žV~v  ‘j7‘£¼‘j÷Jý¿mO²ð¦€^jZ\I­ÊÈX‘0ÈFç%«}ÚÝv@"IV Œ½RJH²= 8•‚Ñ3Ç—9çý®&Ζš¹®Ú«AÑøh"EÑʈ1>t66Úfp£Ön÷‘¯ïƒßýý“­¦Pe"õè@2K§•Rø>3­xµˆêBz. Êϓ﯈Òñ¸²L°ù¿ôYo~|ŽŒpB]!k&6lª5ŸSÙ06]@8²£g$÷ü­~˜ù>´2· Âdî<j5§±6}~mP‘+?Ìsµ*H¬I¨>ƒ©×Gû, :´ZEü$^Q)†87žÈfs«Ö"OC»Úù“Ú$õwù¬U¶ B%ûL*   [eçw“ÄšfÉíP ¾?vÆÒžªØÎrW‚óp@hYŸNôÅ(¦}çdý'W•(3nÕÓŽŠèh[{øŠ½!D©ZÅ2ŽíAЧã7ðÖK©‡>åݶŸèn,ï^ûŒ*{ håH§^§`çõ…žv«ìÞP‰ÊÃeKµú´‚ èƒ_»CÚSà7Säï,´ g@ã”›;€«›«ev&úL•'…¿Ê ?£ð®œ … ù²AÇ0€Åt}·YPtÓK-WŸÄçòLµh¾m̼âPìe©ðõãlC¿?ì5þDe+{,€Ô^ÇvY ! ÕhU¨hüÏ`SS}*43Œ˜ô[ ŸØ5ºlZÖ±Xê+?+âi)ŠsŸåöâòŠ™=6§Y@6A äÇK•Œí;‰þ 4K†¤ ÒÙô ÿÖÙt_X&úå>¯”S#JW=±fü2¦87”_ay¿ƒâ¤q_E§™ÁëI¹Š}RÔ©/æEd)oœˆa¶Ø$¾6Szn­yêAè WR½·–Š\ŸèVrçßÊþXýTž•ïú¦ëÚGR4ÅHÊXôý ¸Ý<ªb8ÆÑËär…yÆvƒjVFwi„5LgÏœ¬ø #ÍôÁÞý‚W>ý±g?«Š¾÷h(e­‚xQ«Ü€²8®›²ˆ²Œ¯1éd¶Ü¤§;]úY —{*yçɉ~êÞá]¥©"§‰L>´&‹}æoÆDÎ% ²wͦÌ.îHNO\MÆ©7ª|¢nñ¢Ô`áQ;s~*8Ì­•ùö0ÁïÅK~"ÄJBÐñ/?5³ô©ˆÜN 3Úy”¬ñç_S“8k)*÷tô„µvLRÌëyïD¡Bv«Ñxñlj.ú"(--ì›ÎÑ£´ôI‚êžCcžÜP„J-\‡#¥o­3娉þ“&Yæ(PúŠeQd/Ølµ¼ý¦iiaaDÆcüJ)¨=‡¹OøŸ üÓƒ¨›†î9‚´˜ø:-°à™À—£œ+WfÚÓ Ÿ·ŸƒBµA[ßopªÔµ¶Y-ª¡· çÞk¡5$°,Îßò%ã2ôq»tDÒñÚ$ÒHÕ:`œZ÷Ùî¼pJ±ìi</ØhzXV‰E[›"ðß4fì˜R¸_”#JÍ_ëP䘢jþçEu³&-JëølhûqA xfPÿ1œ(G°XÚmò\úÃ"hÀ� ÐðÙºtârg�Kî0µÕ«½Þ|E‘žæS³Zû*)W-–—º·z Þõ÷ôÑÊM#–Ûaƒøð½÷ð/ÛÑŸÜ"]aì鷶ر¯ Ì®?Í>²ÓÞd{v”vsI¤žzvÍÀýÐ'ÞÁFíѾó$}Nªdâøgf­­_,!ã°ò•“ÂLØëé¥õ’RœÄTžr\¸a¯ {âÛ‚S  `± Ôyð"¯¶VÃYv08ߺ6ÜG×ÿ9XjßW .©¼FŒ€­y¤]d™§�ÊÜ‘a·µÆ²E”ÿ_þ–à¡jïb [ØKäúMAþ¡¿:í³ Õ•4iéX!wgw}ÛV²(ò]ÇœÎû1³ŒoD Ckg¿(üš+*Þ? ÆŠ•Å.{ Ñ,lû cDk[©›^é^¶²ŠŒuI†jt:y#Vt <ÿò#Û'½Ç ÚU| ñdþH8 Ư4 ŠiqrÊa‹wjKZ`Ôñä‹<Ÿ†Zübª•êtmhDÝÂy›n0èA¶ì©«?Öðž4Ï2ÇEç#¡øÕšB2ßâ6`Û—ýÁBþQÂ} ãE€Qk»PïyVœ¹¢š-Vµ =¸,ºÔí§g¢àJEdìÏE^-SDαí"$6ÓoW@ö¿Âr'žïŸì¨† &v¸E¾†+ËŠ*o—c<wbW#Q„0¦‘l¶'îÎÞðÌó€°h5J£•‡iÇÝ…¯‰(Ú°™à•’moº\üÕõØ®"oÚIg÷Jòã{èRd$¯eöÄÿܤ”q[ SVˆ¦£i²ŒV£õ£RT~k† Ñ‚¨QO˜’ÛˇW•ÁíÝPßIçæ™×deèÃŽ¹m” •±#ZŸb²ÉÆ­%Š"ôéÁí ÊV¿æ„æå8ø,²ÿ ½È& Ô¹LIP~Zlýe/ÒÙæø÷W¶kݶz8R—ïVcyˆãÜ’ÚÍõÕˆ½òœÀ(%ê¾Û}�P â¢0–Õls¼(ÄH ¢~TŽ°VaaT>Û°&¥7à\ Mqé»úŸŽò*ªOMFµŒý錦`>Šmœ?¬ˆ&kf$ŽjT¶ÉÁòiWJʾÏæ7Ž›:Î3nuU0Sšœ9¡¿PèN^3ü™ð€'@ÅNB‘‚ª4JÒO]¸°8 N³C�õ¬½£Ó¹·d­Ç¢ ‰ç&_±ž þÃ`(sõf3ÕÁ©!ꇖø°g»7úŸ§1¸g¸ß:&L $ä¢ÓÅsyæô¯žêæ0�cyA8ÎbÙR‚ÍI¢2ˆ÷'ÓðE$5ÑJ—µT½ö”½òvé3”mé™kó�b³Ï“àÿ×Ú›d7®$Û¢mä(Ô{sîB]4A,$„�0(ÆúóÇ·mææî`%*âÜõ^RfR$ànnÅ.’zrz9àK6µâ³–ô÷œèíx6Š “} ¥. öU1¾¥†ÄŠÒÁxk»KÐÊÐç"èIçA2~ºäFº×pÈ'é«êT¬¥¨¤´ Ú\xÓh3šMÞëä_‚-WK6WÙ§‰’vÐvª‚ÇEŸÎ@âsüÜ´W Ð‡AÐ kÚÄ–à0™8)DcJŒå=›Ú,.{qO¿¦ð5ÊÑ3Nè1Yo½‚Iˆ&–µMu~:¾’Ñh4îóÿs/‰a›á]]RÉøeø QÕ�Œ_`¦`ù?- UÇö¡sšž5æŽÀ cçÍd F}«9Eìç”@ hÜІò í#}’6LV[ÖgÆ9¯ôVʈ(øÑþ‘šE”dK^Øë¦+Ÿ3WûÚz ¼ê¯{�-i·–A8èûÊNr ŽÞriR…¦.è?åø¤Uæs|èaàUijjíœ{àXŸq¹·ÇXƒ^þèÃÎJ3¸¢$3ò®ñ™ù›qÏ!Ók/~õ-6>ñ†Û «t�pØÙí’{D3“/Ì^´°íçÈ µç E¤‹ßSà‡n2®m™py(˜ŸÄ×]Š¾Ma‹«¸fÏ““Í‘*+œWZLÆŠ[fqá“+©O|ÛT‡¥ômÅi¡ŠEÌ©×D]AϵMþ{çÑËCRÌéÌ,E‚•,«!Ä:+Ëf¤]±Àhû£ãÓ%*¡Õ�­Ÿ½û ØáØ!óýÿE÷¯Ü´—¹IYäf¨Fîê `mo-q»v׎ýb¾GOÓôÊVGt¦+þÕ™†na̸:tcn‡Û¡c“ 1„‡"•…-¡¡ûËf ·‹D©‡Þ`ñÚ«)‹B 8QEÖèÂ3=aC'¥&{þõÈܦ㸤+WN(,ÂSêNÐʲjž‘d ô­XAU†Ï*·õªÓæâB)÷J67Iœh£ˆõÈNNqY°<昘O½ùvb õÝϽ_ºJE¤·1¤Õ4H Ù†íaçÈtœNÇáE’Qì 3ˆëj̃Ò"lX í:|0ƒxEƒ<*­™/÷Ø)æA1¨>cŽÄxéßÚmw2­Ç2|qß=cX]ß¼2‚Ï¡NY€aܦ”}}zR¿WX%X'à¦T¤�^Âd•;¸:n©vuºb2é4{e‘¯kŠ‡¯^3RíÖ;DikEƒpRw«–E‹=Ñb2÷’ñ< ½ªÖTq³u`,ĆFxåÓ÷•”Dõ:O(Å;ʼnTáêíß·*\‹J%݈{~J´±Ñ¹¿“î– Ñ¸’Šª,(\{:aç²nOwvÅü�iQ_V^+JHô}RÕ´òò]ÊÆ€]²óÿŸøâæWn%b-Ý*x9ȶ>7Ë·Ucéï-¦sep…¦8t´¨‹ÝÊÛ:T K5c<Ú` 6cìê×òæ¥Ú C$<ºçTǸì’:*©_Å©¤^vN8ž‘§äá§ì0ƒí@Ãm#µBl„9ôîhþ–²³ÉªS©vÒõIyû{‹ÞJŒ5Ô´y½ix TÑÅ<‹zÚ ‹»r‡ýr骇½T ˆPP†n¯iÌò™¸÷œ†¶Í´23O~Šœ"\š~TÂ"ãxÇ…ÚN*äï=Ñ ‹-Ά+? ðØdÛÆp� ©ªG @B(á÷®Ì±T†~q³âµz3z=@ìIÕŽ-k|´¾>õÀ ­ù2k»t¬¡¾ÒòM¦•SI¦Êò­»ôºpÏûiÀЦíESìz8˜f‰o•¡ßKk¦ùÔ …NƒãÙç¸SÁQ_ÜÖøÆ÷ÛBœ?÷'œ­/_^g¨úo£3Î'2!h÷ÛÞ€lxÃ.ðoÍôÓ* d…ë—J]÷Quve0sÜÓcKKGvv†Ý¯bÃÜWO® ˜w²6½%&:¾ÄÈÜʺÅcÕ£*ô1ŽYÚßžÈéšEÀ_=_£r)…ºëÙªµz›«Kï?Uºc´ï¿éèžÚµ‡¶£ŽÒK÷<$uÕbbPRúñ³' ÀaF6qšÛ™k]}]çé ƒÉ;7±ÇÁg”5 ~…ý"©JRmX£–&°—˜„æÎ(×sá‹%Ÿ¢B.eÄfdúšÆÄöMÖÝ®ž×ð!å‡rBU.5wá‚’_å÷ªn.hIoà>#ü;rxVŽ”1ør¤ÒA+Ócý!ŽÌð °‹iqA%Ä î2HÊØ—"¦£²é¸ùgQSp'i¤Œï×Fƒ’»úQ®Ž—ÄFä1RÜâú¦sӧ󜎔… ~ = ÓéÙTôv¨éfÉ•á"ÚsùhÐ*¶3B b{#ÀgÚsߵ颲ðS9T­CÁN f¡û먆=èúlf#xw=Îpn^¥aþ4=UÛ­ íǬBYð<ó0ŽâôIŒƒ»º#D† >1=à ½yo7l´9½¡çNE‹ú4jÜ}àâyÝŽrb¶J, Õ9v˜ðHwVžûý÷žyå>!gv¡O[ø îÍ|ntlY:Ž�H¯p3 «Fp*û�NW†ò0’ Jï?êPútÖ¶Wôë×âfô¿Üæ=±)‚„1ßÕ^ät`qÖbüž3¯-+SX¢¦lß=‰h:‚Ö;uõ3HMyFK,)Ò³©‚zÑ¢±˜Oÿ¶g'‚èHîˆî¸Eÿ_‘’ DMënØ»¾Â“c0NÊkÌVdcÛ/0íñA´?–vx?Rð), † D“5¡è8[`ºÔr;Jý±!µ0ýófΰ¬·¨\‘klÞ° œiítO=Îœ·)F­ØÕûY-Û )Gcv50‚Ríñð©ˆåÂ(‰ÉüS—'½¡ë¶è(&¡Zý‰ÁÄóüC”co˜ ȧ½ôçÚîC:ù<)&Em3nö¼£õ}¤µEkˆ«WÓ‘ÊoæâIáËXÐú=~Ñž)êIó S½Ë¤®aô¹ç^ÃácXQéíõ”[¶5ݬ¬µ~%\7G;žþØs¦ ‚²WxßògO2Ó:#Š³Ú€Ð¡>ñ ÎX4=l®¥Y4¿Çf ãΔJè,ƒ’Àâ«x"†%ÝÐSþà2Ñ;0#pþƒÃ6ÂéÔцž#& güÏ"7MÏeê"2ÝI:¦{xë2¼* 暎Óí`ÎÏTnEwBšr -¨,功Ð{„‹ZŽÕµz: öR!TOóé`•E¿‘u`þÂ{“û¶ïp”Û7NÏ ß�IôŽ­�Y)œò7úÏ¡™uÿ·¦Ÿ§Õ0p3Á9ÂÆBõ#S ý~¤»Œ{�#gÞª›Swß^ÂëpÕÝôôæ‘í–¬«‹Ø²·NѱHÒ02‹«?WA¶Ó&=ØqoâC†E›ÚEÙåw|4N«‚ ”cLñoÖG”Gªäk×{"¤þåBKÀ³e/}Ö"§O³óP…è†d�š(2ÐA:6béyüx¡‰ÃÌ×Ià�ðêl½– x?õûÁ6 frýÑ:´ûñÞ^ÏÂp/‡ *À‰“×¥æîÈL õ<9OvÝQ¨à£Ÿ#Š‹%àïgAj[xÌ8ÙAãtº>G¡Ó"U+#³¹ÞáèV4G}B#t~$š†¼E¡(ÚÕtf÷7ÒQbZfFMßü'˜ÝXð‡2‘Ð׿1¸ØJû„?¤*ľ‰¥ n {ƒ ôƒ¹÷BÉ Õ;ý t}M0Ì_Ó¥‘§îc¤Ïg“, í¶¦¼U± eš,,÷Âÿõ ï¡ð—?Q€ K0ŒP`ª "»Ì8ÜÐ9!§ ^3û£)¬âÚ²°E|ÛW®ŒþW¤¾@åUý9¥¯2Û)@\µ$_‹(±ŽMÕmÚТêÓ@äÆUá4²dÜkÊ´¥ËFÅE¶+ƒd5©cÆÀtÿq=Vw FàJì±M•U©>XÐgƒq—U¯V7ˆ‚ ¤@dw�6 ÃkÝ\ÍÁ¬È :IŒ]í² Úi;2±Z›ŽÂ~­†¨KF6žÕN§ó‚qÙVs9cÉênrÀ¾×`Ù©\#ÆM¬(¶:]ŒþåbÍäi„‹g¦‰ÞåîÒ7l`±PUAÕðQŽp€ Fsñ¬_ؾ�Ò—êbË3éÑâEÑfYå`ˆ“¤ Y¶i=ˆGwä’Ã/¨¬[ódö1¶ÑïcrõÆ­|;u2&¿Çax¡o¿ø„oOyLRp×ÏêòÏõ”²…(†ä<­¹qëòçv+òÿ/èͧ¡ïdHw€1!N3Ÿ€)ü7xDÒ÷ôü>½6ªSZxظW®Ä 'ÌŠƒS\+ mnë·y¬iÇSÅ5nþy‹}5¯û]Ýháú •ÞÏTsCQwÇ ,Ï33y6‹T—ìk×ÒQ{5¼Œ<ß1)p<þœý•|…öÿf<,Z”ÇtSùn´Ž±¬f(E—à+=è˜|…±pŽiP}}¹ˆÓŒ¶Š0�¿f»¨ü'£â.=À¶È¨Q2ºJèÎtÖ â¼ïZ!¾þpˆâÕLp<|¤Aº±Š)”—h3Ðs3p f¡3©ì møÂ�O•/ù+¨»"H' U@^6¦iìTtŸ/êÙþ†ˆ¡¿ÚÕ³9½®úxE6†ß¬í·äiƒ¶ÞÕ¢ÛahÝlo%É;§"¢IõùhÆ]ØòÂëI}}ozq‘;ṫÀ*V´OÊOµk**ó÷½õ<· Ýwÿ°Ué‰Éwìlì?=ñ#¨÷8SYëÇúÑÎ3¼«;Æá|bÓ¹;>ýTX1rzã.Š"Ázâ…ÒjX]e­Ëà(Ç,̓uÝn€²½Àõ+wë}‚åo8”£ÖšA'2Ã&ÓlâÏæ:Q¹µE:§AöþéñØ~ÅcŸlŒ&ÿþÉéb‘5‚ü+`‘m¢"ÛcøG!NÊ¿Oœ¡­c¹ îTV”¤[8a‰ö�ϲ¡îXJ×íÅ­oìös¶ØûÍÉh¬°èÖóÁbŒÏ<”ÌÕIŽ)ˆØ «‰žxñ®Øâ3ÿ×9÷¢c./ò°Œ©œÖ²ß™Ö¥‰7@χ™Zøð©6g^Ô\J×S=ì^õþŒ²R=.xê}ê°ÊRÊY·…ð›q¹<YéNlŠ _ÕîÈö%±6­3u¦{ÓÏíf¬×óSFNú·eú/ú8(xKµdS¶öÿ~'«²¥†OÓ%,‰aú#UÀÔ[o5”Y›ÄýÛKzÿb)‰KEN Dk±c"¯L3 ]×g0”¥ã<}0†kÀÞo©¾žÎozÿ‚ΣO}{˜QnÚ±wd—ïµQÖw¶ší(˜­–"ý 'aýYYÑV󋹸Ð×âtÃ^¨ÛáZW?±Í…‹Ø'é˜ GS“瘎Y`V4öµÑpêì´ùŽ±£f«‹ ÓzÜB Dí‹þÄS3±îY‰Ùv+€†âéä¸8‡=ºæ9‚Zë/Æ6ë}wöç­«œÅÊÊk·+U ¦/ d`Oß‚û·¬AÅ$rªR ô=}§(æ·ÌbªÏ±tßO‚^�Ocðö~7ôÉnòí©õñá ±õ(¨šy¡²XSïû]ï ©û’êNpP,@ ,ƒ¤?Ù¬[ØOrÐ{!èÅh{Þ ŒÆ.EP½+ÝC|Lô| +½–ÍûF«R¹Ëcè4õw.Ú$¨¶ ID’Çt”/ÿÍ•¯*Ξ}PFhiWUÖ;Á¼žÕŒ<¤Ô÷e›UžJMÕÎ&ŒµªÀƒ¿…¾'ÄÊŠxêÁè»1&y¸°„#ã àHˆ8°¸æ4l¶aó¾Ç�5ïbT”»-¥7µvœbN ëNÊZ gc²>T^Ðó™p8@""{WMµ\0¾PV3·—‚=+`é뢛—†M èàÔWÖûÙhÁB�Î|ó®=ªtÿ7„qxe³è…ùŠÒ”°ÔÆF”vw7ìgîR@ü¿·¶9œpÐÁð¦~—žïe.¤ 2Zü9mi•lźBŸk‡‘¸PëL y§O˜VN”ˆñrÓw·WXö;ðòK€[Ô'€ÞŒìã+&¨Qj@ü�¡ ÑõyžíDðlZjÎÔYÇÉׯ7ȱ€µ_t‡{åƒ�•=0Ô•OúA€n@ûÅzSæEdªv);qEë”AÜê nÉëY=Ž¾Ý‚š»XSPè  PfÄ‘Û <\”9ØχP)½y_Z/_â_€×Ч>HA{§±eKGf°Eàt& á·ôc0üµo™kièr[Qx˜kÔ+JÀ=¦¸£ÃpJó5Í[wú€ÚЩ—Y€¤ànTsýŸÈÈV`Z‘Éû–’«rgë1@ÊŽƒŸŠj¬B›üôPè0*£}¤¢5­óÊʳa^ëôôTÚ°YŸ}Yµ_w *ú"8¢ o¡Gºx.ws\k<9£-IìįžëÏìðÐĵ#ŠÙ"÷öè5à°÷å Ñ:÷@-R³ˆð”p|h9ˆ.œ¸f¾DóÀ± ’G“(‰}gZ;;ÚŸÅî˵‚í”Ç:aì7õ—}]s#Ç9æÞïÓæ$_Ö9³eiWŒ-í E+ý¦·½aø9Âø ¼r|%¯™o$19¥{tž¢Ìòè øºØŠwOÛ___µKD[wº•.Œ²EcŸÇü‰-Û:z1’Õþ:¿œ×»+¼±¢mòGÙb³–€ dAa3â(7®xó¬ì«5¥¦œŸþ(¹©?ƒl€¸œÙæ ŒŸŒ§2R¥·»¸E77¬ð2þ;|BåïNz7 "g¯‡õpbÑ+‡R¹Ä´Qøì(FoWÎRðµÎ¯˜î7=‡ »—敇žË/(8-«xÖ^ž%䆋…‰pãUä )#èÛã<À¹‰ÐÌm²È;ÇÙ8#ÊøS§¶Àé@AÁkŠ»Ñäãùd”ä.ëgÒÖáƒÞ*o4·UÒs¶a]=pïZ8Ž×¯¶P ¸DÇ5²é·'P ´©p�Œ@Ò²ž'Íþ僊:÷:ä"ðþ1ÓH6*–Gý1A›ã‘ý8;i¥ˆ×å±k5º9Õ†,ô;¸a „I”¢Y;k"'Š¸ªIäÿÊ=w]É€þÉN'EÎÈÝìTÆxjSF›u5Ë¢P¯Å S CÏq.æ$ŠVg¿ó¬Õй`ÚÓiÄh¸ °†ŠÏñgL<nîè$Œ?wž3ìFzT¥D·œÁìòrO]1öe�˜-½^Áf«ö?!4|é±¹ &Š"Ì ¤^pB­¿T‰.¶Ô ªvcf y*3w6·÷pÛ/ÈDH32¯JŽvŸY­¸Õ83xd2R]wR®;*U”-Jãài:2v:eÓ‹ áñÄrÞq‰!¢F‡ý=h¥Nz??[}ð_…AÂü #m=RÒ„?üÊ¢-…hÅÁ£×þÁIžùÚdèöI÷–›ˆ¥­ãDýĉ$÷4×Xz:RR—Ÿô<*2y°<´¶££zÒÌ׃‚Ü+ãÊiµ³T è"ˆWåT¤Ždº;¢áË+áiË^r Ñsñ_J‹? ÆCA}ðKpø£$e¢’oH(÷Dlœ­0߶§Œ¶ÒEuøa¶³‚Ä*"G!mÀõh䦓¶Ý•À¿ÅCF $kØFñ]§–nmn4/OÂK0¼œ±—!Ä|Rƒ¼7c%xÍæ¨P©ÙT›r§Ë± ÊvòR‡cX Hcj»ÕÅü{§»9«Xp1ƒÕ2ë|Žs“]&äÃÞó6¼ò8LÃ…–ZeH±»ß®s>rÂnà²×õ×ZëöÏ0Û*¬‚i[¹;Dac|gw¾¦£Àê«Üç–ô®óWšÌr5ÑWÙ¬LHk‘6W ªQ¦3ý1èK¢©š×Q‰F%CÄÙ‘~A3-ÊMš#Àÿèj0ç¼{⣲—`D:ä<hŽm5Èõ‡yH|½;v3í@à^N?AÛ\sŽJÏ~¸D$ZH`M� )hÊÖOyã¼pÚÚ5å.íÁWÖ…K$kxxœ7 +GÒLÕ|#Ñûêì8óD®R'æ!åÄ*|™½Ê^³hÃ$ vïò–ì-@äa¬Ï˜Qþö ·$ËRÅ0*&̼à®ûÕ´TVM$V}œ™ûñƒ{¯N‚¹n´þ“‹›³(3�hœsÊÜW&£ÎÀŸqåÅ›§7üâm#?Ó¹ò®ç"’uÆáE®5Šµ2Q5-(yTd/ '(ˆûéZÕôiÍTx#½{9Ê[–g&Öª{†Ìï`EÕ Ïˆé™îÇåõÒ]ÔYHLƒ÷'efï[’·®·o£1 #ËMùxP® ÿÆ6-/2ý %ã»`½[Ú±Äp…3ßjO¥[ç…9á]úû¿»îäøy|›63Åý¤Ü[ÚbÂÕ>ð@{¿Ýîq¬Ì¿ ‘ì@Jœ.|¬’༡$þËWuÁæl$oE„1»¯ hòjÑzŽ‚CšÅö¢|¨lžÆœ@âÈVÆdµc4ž=)8‹Â§( k-fÖ#FÁ6ïè%¼?‘a‰ÊÄ}’;#m ;X“BëF“É›´.)}c W8[86€€=†6&ý÷‘|‰ˆñã& `™ƒã�.R}þ %Ï|*.¶ù˜óÐ8æ?Ȩg[ÈóZŽ÷/¯—o•8æ¸èbô›KÊ¡Ã3_+Ô®$|8òì«Â ‘ÇÅåÁ.%ñÚì1»ÅV®—íòéêGnä(#0@,ÐéK§)µ…¯¬ú–ók,ž³º)µ÷÷J?Ë÷rÆšQ¢`PZÐäÚ8³Nö@Áz¾bÏÌMQÐ^Ê °Ód^Ö'³ÔDµ¶F=JôüN3/.¼“\D.Æ*(,ólW³Šz |g("£æ9_Ú@6!2=´:îi$ 5#$ ªùÓYgÖy…üîë�Äq™-nÖ5º?g+»¡ìkçLbÖèýЧ·¯÷æ:žê5[H|šô½£–@¶h(È@\^³¾N´w vLûvèc”|3%s¿ Cu™x²ƒÙ÷O8ßIé™2 KŸ¬åm Qʵ{âè”{MŸ”IÁ˜ú( ZÚ"ý#M g{É’bt7†ð°ZY6Ãþ‹Åf IòÏ[RrŸf±ÈY€†Ö.E²ŽsÉ îœ³ñ^bä£Ü# ¡…Ií j‡·ÿ‚GÝ;Éؽ'Žm£¾ñ74·¥˜?Õ‚;ºÃ»Æ·4THóŽrwÓÉyµÔ\´Æ™—2�W×�F±•ÅÅ9€QŒ™wT@¶ó¢·ò˜D™„^¢Gÿë°–`PÛ«9€Ãß^^D/W ¿bTÉTvçõÎd‘ë±^ñTF½#¨òꃻ’g>P¥ÝLo½z÷Åôê~rôÏ¿3­Éª¨¤ 6—,H›OÍ‹�¶Ý‰:¡—Q`þù¯ˆ·¶Ìò½ùèãKΊcf²c+d?á ô®8~˜Î"ü°íòôˆ¾þ‰ËÐ4¶¤Ö©‚{«wó8ؘmüLÛØßpz“j!ø@arÜ1>Kç˜#ûâxÆJ5 >:AÎl%-9ÁApù»„he>ð’¼ûýÕÎôq¡(¾D°QŽ{P$wx½þk'+WG‰UMùn½2Äø­q1ï°¥¡žIV ]`¾è}+Ç\À¦bl¤<,¨ç§6P¬Ho)vtjœ7”„†í»'ûÖϬcå¡=ì_?« R'£%¨ù’?Õ¶v–õ©Úap_¥ÁèšbôÑ›ÈK7®Cß¾f1Q gC¹ñù@€Î€½»øžüo›»X²lžuˆ‹ ÛŽæ»°…z} ãeâÀ<±pùøTwU­£2£w÷Q…ç‘þ ‹Žq]A!&:ªµ Ø(ÓWÙ¶¾ÛÁe½«1ÝàÆö`ñMÐ /éóo¬SÄÚ?ÃåÍ(ÙÖ,ŽÀmw°:÷� ­ÙŠøòŸ«šöÜÜAZù晤ž–=&ýÁªuowöüØvl3:)œ@[. :ìZúŽÒù| —,Ó¥ cF/ß~­÷ãY3æñ´ŸºýðÔ¢ÃÖDÝŸâÞ*§2o­ûP®´ýÞÚQ¾Úò*#‡P`2ÑzÝ(ë®}¨÷µ9øã,6u·>jKøQNë‘ã¼~÷ÚW+JhÛ“ê£×œÕ# ”³%2bÈ£Wog4¥šVŽ~ëimTÆü`úHƒÄJ†Ñ±æ…?~¼idkyÕ¯Az]PnŸsM¹is=¤¿`9:úVÈ)­O[¸‹xécˆ¶ÚüYP5þ®t"#f2^©Î`dŽñ©„À~’þ) Ï…[˜¿ˆþ祃·×ŠæiÓÙ~¼1u8vó¤žyÿßÿÃÌÿ(-*CòxÞŠs#ê¯DäÅÛ°ÞšjÝÙUëXÿHê,]ÔÒÍÚÐÃUÌŠ­XXÃP‘F"º©ÏÌA6:âÜÓñø6*ó«½6en7æ³F+”vç‘9PJïêf˜èºƒ0ÆÊ).ž§|dÁ5`+Äß~y©W×÷¾Š­ þXLÅŸ­Š5•©ßÚ¡ÔžÊô‰Ê/'0ðÒ�9.c_î!.D8&;YGÚÚÛC7T—y¯– „c|Ÿ¶$šÎЯmÁV²?ñè xã”gaÓ «0ÅA>è:gƒ�ˆuLÿî­#nœzs¶ é&ÚùjçÍ£q„0’‰‡4:Ò ø5ÂG“À2\tŸ!JYãv×VT»·^+Ö‚ÃŽÕ.úkVk ã„ Phµo= *-ÞiápfJÐï+ѤÈl½óä•h×ù&ݾ9íÏe�ÒÐ` #ÃjnàòØ^Ô¤šýäúõÞê œù@ROáÅ‹é˜;É Ì¡ÀYNkíjÓÞzDP~ÜUR¾ò¹üÇ’±œ$Ù‚W_š,ž´fÎò5»_íô»ÀÑ*#çÌÒC©å¨^Þj AþHÈñºE®*¥ÀPå|q= ÄkJ°&+(n4 ì«¼<¿Š8qÀžÂl.§7ï—EÇ@sêápiDÝewÓ7loJó.t߯Ô|®r.H;ÊE;ˆBö˜îe/‚,ª‡…Ú uŠ±›Ûó‡éuÝa&®‡“ ]áøYÕJoŒ(%Ÿ ØRo›ñ"¼ §‚u.ô¸‰Y³ˆ"\:éÌ”Q:®ÔÁˆþ0ÊÝF½"ôû01zl�Fÿ6ëõˆåm„_¢Ðú׊²?Òß³hR4yy ¹…Ú¤Š'Ž—¦<ñßíißÉ,õÞ•&ñõžŒHjZ Ù¬„ƒ²Ô¦ÏNúéií”(XŸË¾«§c= ®5&MÊJiÖõwðøHj±4C=º¥(:†ŽàÀ~6Þ‡û-•ÔÓ¶Âþ5šÏì!ÌØßóêœ7ÀJ~^<4‹òï±W-|ëx¦=9œ ¼¢¯r2UA UÜ~ °kmË9çŒòDÜÉž:\.H÷Çݤ@Û/•Mí¶â>[ 5ûyÛ%øèëÑÞŸñ‚¬Pe&m¬÷“ ;ó„1òD©î?b™¸aû»Äà½]³óíÂð*ÇÙYr§É'A?˜Ê,S3ã×»\ZšøR#¼Ã 5’ôšŠyØ “pÀa@zè9“‰•‹i!?P YÈœ5p šÖ«´zôvéOxÒnèè$�†îžÒÓwÎÉeºpÑËèXLѺ9{0Î]{ìÞ>Ú=Â¥·-ÄäA� 7)nšúm}é1b¯©¾ó+¯Æ0Ç/,ÚÊ 6nÂè|ÄÂ䡼Á~-iŸÑC™¬¯ùÒÆÕµ¬’1ŸÌƒHºÛ^۽෮¤ß añ4¦«.Ñsó³8…ã·‹+°¾B!Üi*V©Uz(…Ñüº8ªR÷ÓZ5½è,°0˪k­ûé-ræ1„¦ }¢’¡È}kH™&ð†V0ô ™ÿÄC  Q6–ÍèI5ælçq¢Ò/™üûA}ãxÒ@Ðî¨H‰ùnP$º·µúšE†ÍŸ¤îèÉ™Ý÷g"±™”šiîÑ$ª;koˆˆh¾-$õr×+£ÉÁñÀæŠÐ§À°Ê›)Wk€Ä :OBcˆöYÓªZºœ½pãõƒaË@—=GfoYÛ€Ä$ ý@O$Ùn”. v{¡JAZ7‡z‹é*Td¡ÿE9ò~ËŸÔnPýhèsÚ,(\[ì®;уØO“SeëV}=´ ÿayÁC³E°;•”9[Pˆ)ËøZšú_;3Û$XtN#H‘'yÎz V2½dè§áD±ß×$ó¹?ôôB–È“]茷•»}Á]êX%à.ž“ª¯On�5LdOZ55Ô-î»ö¤~Jd·ãŒÊ0)§Ø(¾¯\I¥¼&= 5W=Š;ò~ðæ„Y.ø§®¢^CH¯Tºcšëyoçœ+6/çËš6î(ç*jFì°˜H»"ݼ3o+\zÙŽžmY'ÁþNÝi¿f­¼Y[)‹C¥¥t”[½0 =p4¸¤H(æÆwØÝ3‹ÈÒšŸSl]G¶0Äöõ*âO[˲ôèžÙÅ¢¥*£ä¶3@˜ï²‚$w _¶=;Ð ŠOzƒ èî-¸ì5 Y^.`Ø1¬Ÿ“ ]YWæ<°ÏæК€ÝK¾Ïn[åæÜ0tB‘!è›8;ï;ñêÐ×; º4»’Zªˆ>U@üº¯Û–› ãñEøþX»/Ž<à« š:šã@±¾Llä8ýóFÁ“ž”z»îuù%5Ëa  +šRmÛÒ Ífæï¨Ú–/©¯ßàù¯«U•Ow­(ÄT[gSãiîæYò ;ꡤoµ—±”Î)Æqæ9yA’¤¦Dâ]¿U{¬Õ 2žäÍ£Š—FŽNÇåЉImd ŠþÚ¢k ©ô½=Wô'œ ül:÷f– ãôUcÑœOÂÕZò4‘ÌL”¿TÍÎA£„4ìO†” Š¡ß÷¿ð–©a™d(ûª ÜiΚ— ¬Ñ“±Æ³Ç™×GבŠNZû ’ S+°À÷å0 $9GŠå$Šøÿ¢œ-ÜΠ§C•<Mª»Ìöº(æÄexå^=MUwÚGªÐÞÕ‚Q”®_íTPYù.®!Å\:¨“º÷f`ô,>^5°öœwÀ´¤€@!¢Q°K$0·dŒyh۴“Qé×û—^]’˜ò÷ü+Bë €%ááý©ÄßSÁ¿HÕ› k) ŽÝŠd3˜ÉWX,,2}nMìÚ £ àÈÀø»µtï,d®é§õßÃÐ`EéÏîôCmÉÄ3½b è¾<Kå:pòw¼÷çÓÊðgÒ€ˆÂÂ9Ÿ°Kû¹‡ÕoçϾÐ}ßw�¨s¦%·j‰Þs8A™-¹¯ˆé[dMTøGˆŽ d×#öè •iréml•KPi¦Á”�ߥ æáµíz0ÎcÜ¡_s».âÜs —c¿ Šó»âhÒ%ɱÁï_>ê”nÄÄ ,aHZQá4“Æ¢¼~B´Þ‰±œµP#E‹²Ñ*ƒ­ ) ²ú²i¸3ò1Ò2óÒ:i)PªÕl,@¸ ¾ó$Í3^œ#ååÜG´Kê‰Kæ*Õ!QÃŒé`>ÈBÃ8^.T ÿçL<u’[ß»žB±íœ*=úêîú`ï÷_7‰ÍaîªÎƒÊº4»x¢Ï=Ø@¹ Ó­øýÓ÷ÃFV L>m1¥ÜvÕŒ²D=ZÑÒ‰¥/ɘ"K?@E&K²jDw› £С熺<Òzâfýö´ŸÚ«e<ÛH‰é¢~÷—Wå+ aª“+«ŸI›¢ï÷‚ÕøßuJç Φ«´ ò•b*æQÕÍÑðhhû› ÝášGx/€-™¡Q²°àåA¶™ 6ˆ1M@Àö¦ü:<y{äÓs`FÒ€8éñ ãè7ùüÚ!–ª^€/o5Œ¬G|y3sßåOØí±/EKym•gQ&v6*mŠûÌ>pgöº-Îà¶aCOY€"î8æf¡_EA!¨zð†ð<<d€-O@ºãÑsວa¨¨­`ä (ÎD£PX!r¯?.lè§\¸Êïg&=FúÅaáK®ñV§øÙ©1Aˆ"÷8QÄeT0lŸÿ+îÄ pa.™eJUa;”adŒ¢WrW; ON4aÝåS€© \ b² ÍI§J¸Ó™+kTž+t+å}õðŽ¹’—¾ª'„•Øœé}ôX€ëoŽ‘ˆ0rT´\ËÍ‹’Gw‘]Â,‚Vå·b‚ÅÞ“‚}`áµÓÙha>Ó†³¼¡$O€Å¶Æ 2ÇÒ‹¾gùB–{ÒI$;= pßô <a~p¶j¿0ÖP2(Ì F©ÎÔ¢=›Í®ŠYàÿ1JÅÚIZ¬è°`6ǬH‘ú H¸vpßoœÑVœH šãŽsÞ½¸Ê²¥àÀz¤ÏÙ¨¹:F˜€Ë¶n€©H~“7­Çãå.ô4«ü±>%ã6fÖf©`#hºÁ"#µª)'Ê{ûö À+ò¼´…³Ê“í}6ã�eVÇׂÕHL¢÷ÈY7Ž|2¤ª»wø”l?<Bü8Oñ©ç´y]âBR×2aDw¿ÅF´-‰^gíSÛ_rÛê©L÷]|²k&H]zæTÕÖ< µõyÜĵ\à ½ié°Ç¨»íëÓÛê„W?A<1Ê<»¸d‘Ž¢Q}�Òèx:úªißt¤nÜÁ©`•a"´²Sí/Ë|-¤ÐPi‡½ ªy˜ÎÊá¯& Ö^È@÷(íJò <¿û> Ç®(Ö”Ç/ãˆâ’…g̶\˽ Äçš[¥'‡Üg€“éKƒõÿÑŽzžßÅöÚ~—Ò“Ú<ˆ;EqAÄ÷…¾xK±ÿš4OÕý]¾åŠš=hIÇ„xÎr„Nh([È(ã®ZÃáë-!À0ì¬ ¢Ýì™R—œ;³GÊÉ#CY˜f´Þ{¯8…–‹àïÚöCþyÕ{Ê qO‡BÔæò/W2~øÛÅa¸sqË_RCUo¼Œ�2Ûê9”Ÿé2øCaÿÜócvmGuV5tž›¼Äxg °å Ýó,.ª _¢nDWÇ!% ŸžÂÕTŸG‹*B(–Pÿîû78Ê'Õ©„Õ³´H|0ŸøB@—JC7 eÎ}r}D×Âÿ÷® ‡>@†D�W:Ð]ïÔ b<¢‹c½Ã¬u¨“ ÖÕ'»&ÎFõÕ©ÒúJn îèǘþ‚Ç4GßKôw^Uè6qlÁÚmOôOÖëcĈæØ_&—0cTobEDŽÌh^¼xöXÑuýw)Õ´¡[°ŸO FþY滋Òc}¸3Z‘fQæO¤&tH¢Uçò”ùÔy}Ãñ"2©¶³ûh”Yä™|¤„öœR «Á°iÏÒ00Ï8Mßþ}Ëÿ˜—û‰ŸÎRº„J±©»§ó\¤¶#rdthSÐiOÞ£¤ÅW4wÄ;²!ÂeÆywˆ^…'Bà 6Ž–¹%Ó^vWÚ¹×z¢/ÖCÝ¡iÈL[zµò“Ì:w `Œ'�¿$œ¤ ÄH‡\«‹xTy^‘ðG€ö™'^}iT«=9ü¢*ö5±á>ØR°HÝÕXµæ¶´Ûn/ )XzWDê›îNã½Ì|)Jô±OŸNZ{lö¿j;%xQÛIÒ^9¡lÉo2ki®{_ä÷û„ÉÂóÌÔ„Q¿%%‘­§å4ŒÛ¡6>¨ §(/AýÞÔžYšy@/ÊM/Çœâý ÍRLïq‡çãà‚$c̘–»÷·ðÅĽ=Ž“œBŽX:F"Ù…‰rpת¤ñøÊ/Ç®`nu?RmXœô Mrß?âpš<'Ç–ûtXÔûÉ•豫‚²W-ML»i£ÔŠñ¨cÃÄò‘}¹{f§yvUs®¦$ȆÖß'm£âp?³8’»Æ`’³³ÈÛzgµÿïöžuÅ*WdT¦–£änÖÁ×êØ«ˆž° ˆ:øôpEYÏ^Ü-ðâò껬&XÝŸzUÒ®,úPH*ÿN§¡ÿ=ÔFÓcù›ïŒs¬Ïm$ÌXÈÑ3*Oï|Ÿ¢@o!>ü”ô*J@ˆ–@§aÔôÜS+fV˜¾ØDÇVe‘íXQòðJÚ Àã{1= ÝbBª-o›¿kh,­#Ï©· žoÞÕˆÅø~#èì²sКÞvèk?ðöÂ}¯Ë(*=Œ1?¦–òáª÷´ˆ™F«B÷ª„'^Åb$@o¿í2õ­<% Ók7œÔ2öólûqm'ˆÏž¥£ä]ÞÑr £"óLSS‘BÍ[=\1Ó‚ø(›¡hîw’¨… W‘sx›LÚ˜©*5ùuäWƒW¡$yé·Þèi¯7Pÿí¨6]GÙ(匛S‡v¿Ý×'ËØ}À\x4ç )CÓS HæÚÓÜÿhëNÔ–$€· ËfÄÒúÔ‹^Õ—<™»ˆ‰Ê‡¢ R°ï÷(gžlÓÁþB"ý(ÞSR¿ÕT7ÏËÊ}Àk*†rÅÅà nëÎÕ“6øVN§ñ´]]Ì¿×í‹|1Jï” ŠÎò  îŒBõPgÕÜ8QìÞc ŸeÍé8€{Ê)»fÖý ïä…õŒJº±£ gj´o©ÜQv= _M[¢³¦ïˆ-@Vw`†Âºâ3NŽ¤ë=xÿ·¦ëæá4T"8·ÞxŸè,ºùœòQA¥¨¯ì̃2xÁº:­h•L«|«ÿë…TÁ¸ 2µÆ  v,Cíã\^‘ ˆí¼C•ÜÇ…åÏÚÝ zÍqz èî „£m8õ¾g¾²Pê Sež² [ý¶¢‘i({p1qc˜¤¹ðƒŸüÉDaåˆ(ž„Ýŵö1ë×ëcÝÕLŒ°w|%¨d0Ä´àÙ>3ßîLvÈhË#<Y)›úì'š¬ò„ÁXA´îâ ™´&¡$—âRÿ_yKT±#~Ž(ö˜2æÎàÜh75E»“gä±Âý™ÕÉÐpìë#‹(¯œñ´²DŒ³œ·vÃöܪؾR»Ú°2PÑs]RÐÓµ3ÉÕxÂÓT = K¾¶¾PjP-‹rzŸ4ˆm 1‰ES¨uêEmwÙýoVÖ>2ÊL?õ EO«/ŸÁ©·îiqOÖ‘\íqr¾^m³TCòµâ€ ¦ íÊl§Ì€õxj.cMÏ&V‚nÕ¤ ÍËKLšµèÍ×Íî„)ÒI'yÎŽoµçõªù=ùZxb šj^i{‘¬~éqo†¨¬óÆ›®Iµ²{~‹b×¼ù´® CW¥©JÉ)YuÇpD_9yNÁBC¶ÍmÛ¯bðÍÑÉNþïÊ6±¦J‚¡£s=úœÝÔ@rVãîÂJBÇ7¶¾âæjw<¶Æz§_GDNÛI}h{[áǤÐÞ؉!DüÎwéC–E”Þ)Î5`×–Af›&H°åxsÃÚÔ Ÿ?ÔÛ¾ölåØqA·ýå•,¿(u° X.‚tÔZSÿÓà*Ëe•ðo™x‚ó"?xüJƒä¤ÄõVÇÆN­å´*†þ‹œ£-^,';ZL$Áz’wÑZÎÿžÔãðn¼bºýzg›8W’šÕ•§Æ´Ð…PÚ_å fùÓ_i_ÚZÃó¨4&ÀV•›Á`«|,Y€Œ²ž#«Rãzerâ©õƒžšlzÕµDåäkb½¾(¬èrÑù½ëІ— ¨Ä1*Bö…°˜Á{K§5M´ÛäÈwœæzl}¡ÃØNY7T|íl_ϳ`ò.-@#v‰JÅ¡c÷qçCšúÜø~ãS[s$/-“ÙBÀb‰ŠÊ@³c\T«w HÕ;§²åñGºý´»¯™.Ì1�;h“ ¬•`‚yͱ»†½Ú~ 7ÐíóUW¯.·[<ËÃ+.ÁŽÖÉj2ã‰Â(ñ{qjK?WíˆcOv$Å_:CEϲ8qÓÏm—ËÕ²x AžäœÇÍL°U±X#ùŽþæ?oÈ=)rQBQÒŽ�a5î¹AhÏPžWºû™# Kþ�jÛ.,höãŽíBÿ€´RyÀ:yšÏU6¿ÍSië‘ò¥ŠªCÄø^ÓÞöl‘8¯Brt‰ÌjœVyN“°Á?J=“¦×Üá7ÂRžO\dž˜/tâà­Óª~VŠ¼L»~‚´MyÓÑ­�ÜÊ‚Ôj¹Ã‹å²Þ‰ÕyGÑ_Ž&ÔºAl¥^@]à]á+]J&óëCsåw¯dI£¥Ð4Ƈ9=ÇYŸ‚]Û×ãd;½¢ˆt¢_8©)ÏÑ­Åáµ.é킶7ýŸó O(G-² 5"­Fu(¥¿�Æw#†AÌÍÚznÏ5†(Ðn~á©éD’1äLkÉ?•Y‚$_`lN§ñï!‚IúRë´_Æo´š°’Ä=¤¢L)B笞%Œ2mnëæŽ÷—¢2UPJ¨· =å­m2lÒM·F­Ÿ5ƒë_âô‘BN´µÇ‹Åá�~ߣÖâ ‚ÌØ2ÆóÁñTmAV+Õ¨LVHãX9sµrXA¨7-‹„Ü/6ËÔÍ4¥Ö„iØиFÏ¿x|k0Î4±‡yeÝD3ß]<¦¢G<»,IíŒÖ¬ˆ±o„ C鉳€€³9òbÔ`B‹ý¹«»Ì$óÅ(">(É6[¾Æ4¼mŽ_²2„1ýˆ{¾Ý<€Ùª þT˜4 ŒaæiÜþwìñ̉ƒ ^°Ù•t4šä+nNp@f‹5Pêi/Îö;ƒž?{/3Ê|¯Zºg°åÊ&+Î!åùì:ߺÜ?ÃA„>†’ÞÕª ÊæËjnÜ©ß8‰÷#lÉ)âÑM½.p=˜ZóÀ‡Sîl‹Ä¬ ÑMÃÞjZ¥ @øËèp…�IZb¢éöä†�è+{½:ú迨/î⦳•å™ã@côYOo Øã½ ûvmd°é h` |ç⎠iêŠ:6ŸA¨,¢=b¿/* `-£­¼Œºøù/ºgj·–¾ð¸™è]!4ç]Ûvà¹Þ8ý—(·ƒ „4D÷]»;Ólí®_Šò+$�òfÊ‹Ï/·§¡Âë˜QõO^ÝG+#È«¹£“ðç¾°m—ÑÝØ(ºío}ÝÎlyìõ|Ve ì2˜GÀXº³'èošÆP¾Üµg ó-ÔX®kÕ=>ÉoZóí] L_Pý» ÒÔ·/Ãý¹¨3W¹|ë×g*ó -Gk»nÝ+%%¥[ã⿱Š*ìTǹ·gã›yð½ ôu²{¹±›§[Au†µ £ŒŠcðå$‘1ò±9vÃnßcŸþ~�eÁ@K{#Ê"ó˜U ‹n2æ‰8Dÿ ¶œf©'‰æåI5íð±±Êà¶1JÇÙ[ÍHYr§7gB÷í¸:Š<åXžX¬<Œ±ý‘Èçp(3½ãV($m},^œ/3½„rú ÞèÉÊSS¡,¼hBKf3}Ø—ÒüÒ軬(¸„'ëÖ‘±¨$mбOSgè…lj1ETÍÙo¦Ëºf>–¤;ª´µn/6@=Éçô.Ñ·Œ3ß«¢Ã®¢‚׊B•l<~ÕzÖµ¨`Q$<H+þq#*Ss,Q¬`®A½U´`>ÎÇ®Yƒ )±¢'—º®Ü•¬ÐùÓxLSY³u€,læg¥Lü@¥)òZ�<6£#(ô-ŠKic±f–1F§ÿ©@½»½x7êÅ}uM¨æ×(bgs+Ûé|ü¤]®-^Ú#`‚ŸN˜Yácx#+”Ìÿ‡$åtXù—ÜKí2´Æn.ÂÐþÂæV¦PyšÝM!ÓÃÅZÝG–mÌåL½Å¬ÄA›ÈÔŸ¾La‚U(r„l�g“l;7¯ÏtÚ“p!5…§ÈXž5±ÖíÕº2Ù²â%ã§[P°n×eIPÔ:Oº#‚£ºMGJT†s×Q4ßÛ3¥ÕMc_#O¨ 2½Ä=H²U«r{€ùÒbAr8‰y6íÇ#$<á3NãÉL¸Z3<{€i‹S'\%k‹^¾¿».ðKꧬb…Âf{5 (3_S‚öWK·e8[pØùK0Ÿ[œ¢Î¿¿?‘ï̲…´€§”´: H E‰Œå•UÄÚùúÇ;„à*\Ðv«`8FÉøZŒÙñáø™0¯ß$òæõ¾V¤ˆHU†ÀßÔNJìm©ÐyÎOÈûqè@‹¢o¹¹äA1oŒ–-óêGð“;³ì‡ã øß®ýWtlo~qÇ—%Z:ÎÐNÉGÜ©Lþ´7L÷Þ¨ns‡nÎíHf‘šjí{°HT,œ©r>CKâݲó¨X»¡çÑ¡(§m£Ã ž¬ÜIJ’<Ò#!æ~þ™ŽÆù·«Jõ¶¥sr3«G§ûWZBu/ìUbGa²ù¦‹ØÁ9Ÿ©ëüÛP×Ô£Ïo/Ö½5-qS@²î±‘ÊKìEóðâI„‘õjiuUy½R”Ýô0ÃY‡‘ Ðû3¸uµFežBU¯,'ÅG=˜¶9œ„i£—œËyPÛ2ôIÖ1+ØÖ¿{ø]zT[ãLÈ ›A}¹,öQëÅ’%+£”±Ê« Uú^~§¬»mmVå¼ÿµçq<÷òIQ}ŸW‘Žî¡cQ­,”‰µÚ:JÝêÎùhÀéŽ[æ'4wø”¿îòDEž³±w‚ ²­dˆøLЭÚLCÊ‘Wš_ílY©ÏýúRo¬À1Dôí%þ¤¥!…Û/ô‚¨]¶Pô¥zZ¥Auš¬ÞÄù£õKçœ2™Ñ›Ÿíê °ϼMlHå4š¹l´ò¿¾ìfCRq<#ªêÛ¾ÌgË|AïÌðÙhõ¬,”(eæ·%LIñ¦%KŒ+³h=ÂàŠîô»·mW '­¡Þo™"c/n,çÃÂö ²m×”A¹©M$«ŒprÝÍ|¨ãìe+à× °í±-M¥nˆEOç……¬Óx3fhUùŸ~Ú¥?Cóçê'ÒÌцN”nŠ`'Ò{õ,ì‡zÕ‡ðû­¶~f>† aoºó>+îÅñWÝ–4ôäËû¶ œ¨5-…Ìvš3šx£Ðt¨'ô×äÌûÝånÔÝfã‘–x](ï¤eaw)3â�òÍw;ï&8J;#=1³¿_æ…á©›¶á *ácí9u×ãçi§±°m¶+É:^RŠ²ëfgO+º~w­&ƒ æhÝÁ×ÒÛß 3¼@ƒ$ ÊA<l­Bü‡è§TÚ¥Àá"¹^Ö´ø8`º«[[€ÈתM˜«Ý˜·=týW{:%,ï¾aò7žžúÒ£yú()›²O‚ %mÛ‹ö]c°ÐB»;¾µžt"EÏbèèFåV"Ž°¥Žtú_¬m ÚÍäÿ^.Á´ÅTn>ìyJ ‚CÇç†mªpÊI°sW¯7dûئX:ipü¢»]Ö½7Ìæýã$w(°²†ZE}œ8W˜:²Ðõm"fÑ÷¯?½,�Së† “V›q´ &[¾¾]¸•«QÜýè™!ç©o†Œ¦_ÉÔ:°LsÂóÑÈ๠~g0˜Ç> ’D À£öâá¥F%’ ·î×PO(p¾EÛkÁÓ1³*€vgNèÔûÍ]ôS‡Ç,s£;¶Hš>€xÛ©ç<�A2×ç>¦—j3tÁÚ…a£Û‡¶þXÔ4YH{`ÎÓÇAÞ(§÷Ìúþ¥2["\Yز:#ôM@Šræ>®rè_f¼äO=â÷2ú¡ðÚ ¨êè0fRþ·I“úËâú¹òt’ÆÙ“î,¾×©š`ÃVA±ÈW*KJG{ØçJ–| ý ‚‡`ÍŽ©¶ñÆåÚ¤µðÁÎ3C}ël·à¹¬’3GèÍa†©ú7hÕ§iv˜<dÅBÄüF7J}4 YãŽNÔð½÷¨bï§~íô”Qmx0ñÐïÓ3ã¶1×Ô!@ÂDR1`6ƒJ#áúC-×(ÊÝè†óó®ƒ1Æ0ºrïÃÑTU>ÕÃN!r??øsÖØ°`.ÇŒö}�ÓÙÂx†¬¯Ã;dd£ Pf—>³Çˆ-».7ƒû™s;aQöÎÐÉ<sNÐ×Ìà&ô5sÞ£‘¡û¯&Z0ñ¨‡Çºm4Q&Z ÔüéÐ6,Åì–Šàö ºlz¯RqãÄ2Òº«55ÝâEáz©'X1Á.‡¢åYÕkJn¢‹d 9ªéñ"iÚš=ÒYȈ“J{uÛ Í½žâó ß|zLA6!¡OŒ|e žµþßziÔV; A«ÚÝ…«jýUÜ_ž,|ÌïNK»Qä¹Fcv6ú7ªRìÑ@ t4Iï£ß-ãÂÐè@¢uŠ>¥©÷ÉgŠ 訟µ—Òî̶\ðÞ OC Î<ì'³ðíNóµt$¥¡ÿÒÔBÜéæg4ŽhqõwÕußU¦ÎyrY¹ñ•U*ø‹49Ëâ®.!•wZDPíÊ# †˜¢¢Åd–Õ÷dùúÉáU¢h=!…–Je>é|±D1h= º~’`%±/ËDYøº¦‡TLÚîMÙ4»snLf²‚#Ç»\‡k•*rKJ¤#Ò„uv" f‚¡•M÷S6šcÔ‘ÙìWuiµ˜esöœÕ =4:âšý—5qèŽý6³w…úŠ)ѶéW¦qgV@i§4(m¼+™NÑ2ZÖš\ì;ÓHyf¸•å>w‡=T_ Ç• 1&ëœèó›…kõ•¦È¢ŸÜ¤ÓìØ‹q‚Yçl+}yC›þ9#:² !ã†XP˜+‚hŒ<}¹#”8NÀcr#WýBõõîhr‡à[rø€üÜ»§Èxëþh\úøi5|ÒÌíÀb÷šÃdô‚Ýù{˜f#“VèNMÿ¼EIiêôˆVoô=– r4åˆcÂj„àýN}XàÚv¼Ô¶u³öjÖ&Ü„‘îf •X ¿u€²€\ï³Ò´G/Û•‘›³º!k¾­úy û/,Qßk8�‚ï'zYNV(6…︥µ6£›sÜõ0\ -É=6"ŽsüxÁ`)‹ÊY!x’׃à›ÇEªD‹-­ÿZÆÇ/hŸäÞ â`5`2)t¯¸…¤mÐGp×RWcÖ¢¼§s$ÞÙ~sÆ­±ÚV‘oè!Ψ25ª±]›yL½¬D6m2N‹¬5 ‰çW8£<éf–<d�Mø®¡( ×,o -†çrd½â'HšEËepŽ_Ð|˜”óG[<'I:è„åƒñ4OG–G©bíe¢F{›N<ºŸö¼F§HR%î3Ò§Dþì.îuTÅ™E›`·¯(Á·º—¥™òr˜<bšÕÌç=²Œ ^¯•¤¹»ô ±.Uè[]FIÐMyïȵ>ͧCo¼M^h?gÅ¢û„ì¹TPJšŽVÆfð¿ZŸ‘ø7 Ù蹶²+ËØgV¶‰‚ÕeÛ ö÷Ö’Ô—$‡à\K•ÅÔûuS�Œªúë+;Éüb:ÌD-u6UÙ™Abº•Ôβ|¡S™±\ÚÔž®1ª>Š$Ñ~,÷'…‰qô¯¡:ZÕê4ÏÓ±k,R©uKÃ:×9➧bž³[™û¦qq$ŒŒÌ`' ¦(J2#îù Êͨ<3Ó‹Õ§Ço´¸[ëÓ¹iY"@ë_Ÿ˜n4¹žN îS�UjÀ"HÛÎíLžÙØüK8‡OªÀ<¼ÒºÆ8¨æ/Eý^÷´p̲ŒÜ±±$a}]¢,x/7*ãâdêÓÔ*ž˜’½Ó4ä1Z7J<&‡¤©Íƒd´Àþ‚̓ýãHn:R¦»šœw«ÍþâÛÔ¥AÒmL b¶xä©Ñ|ÿ¦ãxýjŒòÀ(cþÀƒ_#ÁO]‡ƒ5// oy÷œlÖÇ~ÏáÆ}§µ£ìú×÷Æ}ý¼™þ„S‹Š—µhˇI;LǃüËX~k7x®:éš.¯ë"¨úÁÄVÊÚñY⧻üÖµ`½Ób?­ p¨h #ð9@õÅœ'{âDÿ‹³lá¾ç1áÚÖaU¶§dßPQé÷®n±!©ÁÛÑIËQÊ’q°CZa~xóDp�Arï˜yúÓZô×!ÃPð8Ž1ë{MH-H¶ÀYÕ\í<kœï‡ÙåBe¨¸¦ðȽ’ôVÇè²:ªú \nUö¦ù>Ï—Éü‹o‘-¿DÓdjÅ#P)wû…­îÅi¸@5eò@†• ÄsMzþÁ(<d/ë�÷- ‰ÕÞÄX¤º�-B´\ÜÅ7]_­–Yøçº ’“u¬+—ˆ>`@wm×Wi{©WW"]^š¹gÈbãR5°øùmÃôã³^CŽ8À„’Dd»Ék[̧Fà?È!J¯ §d*Aò {ï\7ª§#Á©ö1ÉGN$­?h""‡Îóþ¾vrgžDeýô«•Íòs{˜,s�kôýxYûÓù`K¥�Γ;ûØ÷ÁpðŠ÷Ƴ$œÇ#ï…Å-.«Ó´{BwH”ï ¶w´b8Ëx`̉1ÿ0ýÕoòülá³L|,}§ìNÍ"Ìl¥­ù>ÓèôMþ’äÙbìžsO5wlµ÷hÇp‚Á]«N4ß ð'ÖIf % ÐÖ8_YóÒbCçfv[§<r3½ô`k"ø6aBón«]´ØOPábS;rýìDžÿh:¯›A‹0汆SCb‹DÇpíÇ$%öiý¡¤ÐFû«»TD™Ç͈*ʶéoOÓ ‘þ‹~›s{X‰áú}\e²”G�DãË@rvë&ˆ÷˜9¥“n¸_Ûµ”s%<‘Àü…˜ŠnÁ*¯c‘?kpÁÄ£…Á:ˆMx8VIu5y®´™…¨t„Ÿ6Ym-PB $-J·îÝÃ?ëYÄä«hûáq"ôTüX¥j)½Ú)‘Pö¶ßÞ7@ /ÙrGÑ T“�h¸©™¨²6ÒèeþðOH™nx‡-{#?Y(\07΀]—ä,¤d@A(t3O|w¤CwSï)Ì]ΗþbïÔ 2##ó ¾\L©Wt²OÎïh~;N4èö˜¯Ž:·Ð4ƒŠÖ[¥£Õ3]Š9’ñæäØÇ}ÓãX¿ÌŒ£ëi5ìúŠ¾q=®õqÍcwÞ„ƒ4ÿ~^·9E©Ìø\Í=܆VZ•ÐY^£ÚöÀÕˆ©°rñ›Ñ@ôÀÁsUâÄ}b˜l×r­S½EmЇÖÀ¢Ït’]Ì·[3-r/ Ù•‡jÅfãÉXÙñ“ê0šQ~/àþÌPR@è%êÑUΘ©ŒŽŠw-å¬ç;`ëPæ<ê£�ÿjØïvªÊGˆÿàÅ C(%o@,“gþ‡­›*r�¥Š%J7ôÀãq«þI€ožGúúoÛcKoË:bóy?C¦¤[ä¹Ð!@ëe‘ÏÈ›E³°Õª Û7*Œ ôÕ~Û×”ˆæû_p®½û™ð´†å8V[/)YµÐzýuj-uMTûª4\¸Ñ:1½´µ„>K=BBTOµ—xéIä¹q”,cÔy= }#6h(©ÍPl¬Ê𯟛g'©s f=u¤ßÕ`a|Ühƒœàì¬QŸæÝ6h‰“å•—cBåÓïÁ §ùT*%ˆd°g, C;Ü?ØÓ —œÎAÖÔ­mö.¡üÃÍ'ÑbÓ´ôË ²Ön0³q7¥[‹†¢¼7ó~ɼêRw>õ#öºôˆ =œ8ÈW“7 ˆæ´eÜQë ¤Æ>Î(r=TæJ<l‰¼pèò Uoønóµ^n5t…Ü^XgÑtáŽ|Iùªµú,.ë€#œBAŒ¦cÖÇc‹ –†8Žøå–½.‘žž.aÍT° 1ÔÿŒASæJ*NJvƒ+‹Û_›–Ç>Ji›„m?»óy†»§;yè®ý{ù—ò Ád¢¿½ðJûˆáF!¾ íÐî¼präª>pôhÃàwOçå À¦Mñì[Ä¡çøÅÊ9çÅËÆ %AÞ7½À¬4K³`ºG˜³J¿fùÓ¼£­óÆRw”A«\è¢.h›b7ºi7gâš.™8<Œ§fwl¯ÎMü¡”ÀAy-Œ,^Õè&èA'húš¿ƒ£Û0KüˇóÂÌ™&‰*ï4PùѯÝ‘­lßœvà¼oÌ Ò‹V@E nv­¢$¼2ë`œXÔµI€YE”­mÕË·í¡c¾˜#'d\‚$àÂŽ–©Zú #sc.™ÐènÓpe Õ4QVW+\£4¼–RCG¾îµvºùéŽvãÿ%¦u9(0|ªâ<8ÓqDIxô—ýÕËmHóh–bJÛìèø;­<,¥CY,ü  ‘ f4zVátÑ ¶ñú`6½ÆÛÎ?íÇe櫧Ó�ƒ«±c,ëö,yÌK¤ã+iÙ¨ S± òVà…¬¸ ‡•É ÆšywFÜDûóhnŽÃ›_Dn, Ð Ž*ÿfV«W™îqÃYÍþáz±ê 7µ˜q7J"ƤÍL°<¹•HýP{n ½ŒÎŠ3g\#Þž +ßµÀ/J‘ˆQ îa‹èïÇ]ÿ÷Úaø(Ýç*˜¶TÇôþGXսȑ¤Þ<îê:'™›¤ gWg¬S);ªí¬[”ŒLwÿ3ì!£¬/Œº½sžW .˜•”±Æƒb÷ËŠ5ÎF+¢tÊøŠ+»äÃäbÌ­ë±»U2¸Ÿ' n¦µàp¤òeç£> ×|ÈâDY{ÔYÕŠ¢ÆdžÞ£_ë¸åaç n.Œ®ÐžÓ‘þNzQ§Võ€Ý–³›)›"ßíáÿѾ7–« ¬ °=V¿™6ǹ!„Î6/�»‡Ò׳@Ë:‹5¢}]®˜H”%bSGi~Ú<>©ƒ+òU1ëÓ /5Á´2bŽÉzƒ»>j+;eo½B_þ‚ÞÉÅ»zµäôõDýÜ0i.rξ×<öö³ïîÄõúÍ¿¾´Ú. # œN²Þ³HK² MœÊ£‹øs,—1Ï•hfôp…õDÞ4€ñwþm|a¹L¥œÓé뢗ðÀÌH©îË"ñ3øůèìo}šªPJuxLËËxF»+Ynjjiî¡É qœ×ÑŠ- O¨;b½¦ø¾7ôLõß#:´Í]Fèu}°àã…™K² 0KÕõ.xáÔË⨞ï.†Åæ_Ï@£æ¾o¥he•3u2n`öÝY¾~„iñ‚…Faâ"xÂougl‹WCv}ʼV>Zç#½½èãsÖÝ/i!ý™óEšº ^†=NAµ²ÿ ]�b=縷ã¼oèÄøÐu VmM™­xx¡æ,}ÉlÖàb”bõ®)pOϪ»éÌviyJ%hþùÕ«0E+œ(xF0±Æ£† PókÙ!Gö‡¢;êÈõ3Ýò4\T B–®h7j‡aª7õ¸G7ÃBÖç#÷øYóô9"9 }È?ØÂmÄ_³¿ H^íg[ül²â¤cÕØ¢³ºšÝ$µƒìt#¾Ê&£‘?ufã­ZÙßØY¸œ:ÍgìïÙê=ñÐvØÛaüò >«Æ8dHëY_Æh†M{¹Ûx2Õ†“n)άM¬Du”Fç±ýØcx6WU]eû¯$(­1¬¡·cýሊÝ~SÙ×5Kµ:«‡+UªÌoY–,G ¶a”Öl:6òžý5£!÷43æÍ0ùøÚxd^·54RMD'O.®šãÞa} Õ7wž¬°åœ¬Úv≻€îž«¢›%(=.îÓ¬‚ÈNâÌûñ»Mœ!È¿ Õ­ÚÆ}ÐÅž¨)â¡ýß´2«›&cH¿ñ¦“r\ïø!B¤¯eÀú5ÔìZ8{µ¢;Ÿu­çS,r¬pÏÕöª?°É¹·µøá¾è‚z&ÁiQÙknÌ'Z_š9œ¾Ì!øLD£ò¬¥ÄŽë—Æ/ïÀhö+¢ßœP’èËM»:N”‚6—$(¦…*3²ìì9xÉ< wu‡7ìaçY½xhczÇ“Ö5çz;×ûNµVdj*‹d¿BƒmuäSõië0óºñðÍ Ï^ééÝP2RY{P 7à— rö7�kêtˆ›_ˆ Òò›îHåFÒp\efYÀÊdz{~°1SÏßB<ð¦#=¿d{ñͽ)ehd&)ÄùØ ØÁÃüKwˆFÿKòÉßP‡O蓇zˆ²úâ/~&ÉÌVóí[Æ”ZÀ2õ'8W 5nEkÕtG_¾ôI^�%ÀLoT  ¢²Kœnšüðü´¦cŠpbnJ}öìEh'RáòËî&GOy¨U©S¾dlÐúœEkCïU3Ž<_V'ñÜèTñÁ}õèvn@Ä쬦Oh]N7@CoöÔXòŸ{˜YãY>ø P …¦“?)ëÕŪ©¼¬Î”a |Î~1É;šb@óµ)æ#ÿ�—ω%ZÌŸp‚ž.N>…ývÙœ€««õ®Þʼˆ-Þf`Ü8ûÕ¸pÙœXŽRD£7´“DØ3 eòI [¾\ÝÛ…ª”óYPuº £„¥ëF!5ÚÔ³R>Âõ½âÄ�¾¶®óMñÄV!Êk¸À½ß=€DiéÀÛ,J¬UÑë–…˜3ø9ÜbgtEõYÂú`W^©ÆÌ zGTœ¿=ÑT-c,¶rwœEžOJ̇‚¬…šà$Æú´;e<ëu-”æ£ÕùiN132ÑúY†ã+%3/»í 6Ú2%?ö:–&Ùü§~¶‘Sä‡)ô| (㶱h§àêƶkª ïuú®Õ6p4ø@]Æ É[oö<Sy,0•W‹ñz|bI·^õ0×<ÃÅJá®iWÆ]ñÛ>¡ùj¡%†îÓoi7G›Éüb™Þ Ä‚‰�sm¨È<¢èq˜Ù€‹_8òƒ9Çí»;@Î2ϼö.œÉpV—Æ˄Η¾qR¹ëvÓ¿]ðŒ›€ê‘/ë{´¦*ÿ´äd¥‡L¢³žH¡ñ!õã«í=[#Ý;_l >48–=H»Î³§jÿ¶–ƒþTöÀfˆ¢ßŒ¨£ï}ãe)”þŽ»ý™ŽXEõÜšâ߸”hö߀.að`ð_AÑ)Î Æ»K##1XÙøª•«ÿ ÓÿK4!09ôtN «à½ã6§TæÓ9ÇŒغ©¼uØD¨&Bpâ&¹½¢*ÆÛä"j°šÊ >ép4''m/sum$½j'çg Ÿ²ñbŸ{äXtf&ŸQQ÷æß»¶<\Ð8ã ÙQMÚèçÄ` 2÷¥ :‡ }©5îLö®%_ârá4šRº@éË`[ ¸5bÑns&0þ…4êøo=‚Ûß|Ó=´Æ‘J•%V¶Zô¥9g|½M€×ÈàÚ]ÝÁ©DžŒ �Ãçà+3ù‰ü®že´o¶ˆ™…xý©Ûß<k^E>CÐÍhö}Öz€¤ÆWÍÄú^ØÊ`çYW9¥NPý¸£QD¡7Â@;¹Iƒr«~èÐå4fá6œ¹_›P Á¹c÷ŸË7¸†bÝŠÑiÊ‚pRQzä |—?X; kq-·wä­=wslMöÎÍW¶ç‚æð�6啯¶¹îõ™1Pæ>9ƒ‚ñŠ’ŠÌê¥AIÄgU)Œ}ÿ/W37?CýŒï² ú—›.\§Ó$΢×ç ý)닃~  Å[&ygÐæßÈ¿9‹ AskfH‹A ´^qÒ(K_&~WGJ|‡w‡9]W°¢ûfZRå­±wú¤}pÿÝ©$QrÒÕœL2ñÔPiPàýXЖÌÈ=â짧§içÉ€Û¸¤ã¤nÌÐÆÃ)e㙪ô‹wcmÒ'xB1Œ<…Œ­ÄÞécedûm䥘Š¶zÏÖQ–.¸ïŒv{cŽÐ›]“g>ÊŒñC”ï¿Í£ÛÚ4µ‘Bl–â-嬧5¢ÜÂHÍjµ‰ˆL`Hwk¦:ïÙ†;Æ¡éKâ£ëøHÆ_jL’|^°jfEêª:h«WõÊWn\ÁGz´ }Ë'z‘dd!ÚÒ„ŠÄѱFHáʧ˜¾¦ˆ¥±Óùeäú9póÛLÕP!pªú6ÜXmÞ©g;¡wODß×"â.Ý æ•Ê„+JÖ×ݯe|t„º±Ì¾»ôœÞ¥ç…!3ØÏá¬^Ügc x‚8CZŠªéê?Õ<\ô§žAJñä5+_JÁ¹’÷ÁçÈ{V¾¯·|‘{`§“ò3q—kü$ÀX`?pÂŽ3Ÿº@oˆ‰Cþ© <Pðö‡ã¼»H‡çñ˜!¢$©òÒ§¯€\]°Ó:×®=ïçù<_!Y‡aq­çù(”Ó»çÉ‚Ô—0R7µs�(^(’ãÌ7GûÜ>ª'8ÝÒ7Z÷DQg£lk^”y‚¿ýû†!DÁ¿ÅðK*ÖÛ}Ý/òm¹'Ãj¤a£:¡8IOëzRK³ ç—UHe`hÞ`¦ôS›TèWŽ:K¥´ñ´¶sµ¿F1EIî¦MŒ+_q5w²6˜ønµ"ßT~`¤w0ÿÞš/ä ÒxâÖÒè ;1M7›¨½îÕ9&¤ˆ± ÏhBoŠ?«ú®?Lä¾ß‘¼iGa˜Êç z.£'Ž‹ÔŠç¥KÑ…×lŽ‹ðZo~½KY2(±c%†¹qßÅ‚#ÿЮ³Ì2C¸ì(¹É7Òí¾¼›UZp£êùæÀï÷x†NÓ<žÆ#º1€/,f’…ÊwLK! R{¤jùrèÐƃLë]Éø„ùK,Mè+äbéQ-Ù~;º½TS6ºLLžóƒ:ØÕ$X/»²žÖs¥EXhZtË-Ú‡A²ö럛šnÊép[Ÿä…_Brk>½µÅÉ9 rÙ= RîÏ6Ys‚eF8*쌖Y¿Þë±›yŽÛš¬-a9¯qö°ù#W]ÅR§R]iÐZ‡ü˜-”sfÎHƒrÃc„Û•¥Å5‘O—$1<Œo _Mä{q²âÃ{Iþ ¥¯Zx¨PøZo ª†œ! åÒÌ6>ô/)<9tAšÐ¹5Ž:HY5t<ÚwúÖªð‚{*f’IO„¶”ÆøDI§"]~òíéo}ânjt¾oë/'†°®aCÈ`/ÏÝùðSË»lù</ˆÈ¨RP9±úRp/qùÀ•ø?o™JħžK{lÎEÒôHM°êž™4å"=M‹1hrnÌÀ‰Ûèz¿Æ?и˜Û—÷nXbÒ$uãÁƒ?×¾¦(v9›²ZbeÎ4÷Ÿ§LìÎMš ¨Ê5°•®>&Áïz—7º#ÎÉBX8hFRàM'8Ò×ËúÝî£ß‡ÌáJ×­Á†Ð·¤ÒL’³Éè@P ©}Y¼ƒ éë‘u.ïÈûæ.i_‹ÕR&³>G€Ï:�–UŸƒþÜ«¨c¶‹M ›™Œ Ì(©ù¼²ÂoµôNÍdÉh~ÈCúVÃ'«|›Jzzç© * XŒD”C d£¸øšN~UŽÁ™ã„èÀ›¦ß~Ë—…ðÂ1Ú½.D3dÀCËøßÖíhÙö`õf˜6PMÄ‚[Üàƒîš×�ŠÄŸs¬šÎ‹p™÷-(ŸŽŒIØë^=ôg§PRúî5<˜=ó¢mËP¦˜][P¦…¯{ d¥ß‚®Û@·Ë9Ì¢ E0ù*Ö±ñs‚$ ½¿.ÉŒùíÊ1ƒ…£È2Ú|ß,EæÞ•ígnùàÖ»0·¨š<(./û z¡§zÁôIÚ àõ8LyñÒ5Î+œ[¤á%UƼx½¡Ç^Y­ZPX(…ô=K=ׇglæ9€²™ %ÅÐÞµ S±éÙL±Ò³+z¸V‹žO·cMRCå¶4{”®`ãØ* †ÝÀá,nXNh—#·G?õÆ÷ÎæÝs3“8SúÏú(Õ¿âddBÄÛCIëmw–À ¢û.=UÔ¨´³Ù"È,[‘„¾U&‰;:™æöe Üÿ†ŸýHçxÚÍ΢SF¦yÞ26äÕ6 3LñgG¥GܺT›§qbT*Ý Ú7­2ÚØ´õ×x™VÖ~Zh6=TŸºVÄZTX6\LB4 ¯áB"LL&êÑÓÚá__�rЉ*- 'ïêvÀžùVŸãçñIW ‹#؃ %pµÚe£PåÑá¥} …“.3€‚éiYç[­pÿK²tÊ ¦•ìè—xjêµ"Ía6¤õQ57(Àtsòt´¡Fþ™`¸è~Å=80ú§ÆeDëãŽ{ã³¥cËU.Ó`pT›Ö%sú´N¯‚”‘JÓÒ{·JŠGïbÓºFÃaí|œüír[è²S4Å0V™mRè+ö8{·Z`x΋ø™™.ø˜pŦOl{ÄX´Æ˜•bSõÅÙŠÇÙÞÊåi¸ÔöïÇ…!«OÇ ¯¾t“¹Å§qæ XÏŠnJ¾Ó© " –4‘÷Çø ûƒÎ{:(ço,L\ó+7§à,–›I(µ7Ù§ÿ„Já­96½ÖõýËû*ΗÄ&ܬÛ]—A¼Û\9e'çy†ç†Ha®~¼kÿ“å¾H\ *&ùì¼…Ä2z:êïþ“gþ¼ˆÖÒÄìp8yƤГ¹2’ÑAXÓ¾ó/ëi¿ŤEx%=-¨Áê]ó@d‚˜­›$èVˆÖÀ­Ç8*ú{Е"ñù·±qå‰7:(cÁîR1¦§÷KF< %|x*SùÝv^ŽRà_{PQ@ñxg_)~^õUnä™�Kn4tTž´ª‘™¯o‚n¯cÒh³êñ/|Ö6;‚Ð]Ž)‡7³TóâÖIU{Eš)ó^Ó®6.MbRuWõé‚¢Âåzײ<Ç +s¼Ü¹XÐ0b°‹Da³õ˜Þq£}I(ÈüÉÜúØI §ÎBŽbzzeº“f ¤¦|2¾ª­ B/l'. o›Ì%}/™*¼3ÊJß×$dö#¾Ö?sN©– ½ø‹>ŸÇ|ª|“‹émZ¼;«\ Œýiž,>tû…Ô}ÛþóVz0¡ýÝv‡ýh@¼Ts –Ü¼Þ y‘™({¤²ÐàüÓ;‰Q,N.‰ú;ì§ë…$Fëð‘Bˆò·óUsˆ;“µ`Ïò37°È� ô•0É»¿´®Ã2u­L¥B)’íPÁj—WžBâÏó(’ÂÄy{®ö)Ø,AÖ[ýa&:÷’{üîÇLï,©ÔIÔŒ(Hwgç$Š•ÎþÒqØí…L.2ß#¶ÒE:ñ˜¬°F·Ð¥E³Ÿü~àÍlì†eªDÂAÇÑî+§0â\_X’Ï<+/ éíÕåM] Ÿ‘®ÂÜ%ï¥ägtÄ·žH=ëþ ¬il{4|Î^^vßÊ3M}ú1=ê¼^ÇÿÁÀ=“M½Þ9Ç6èؾ̣½®68F#Ê0—ÂéS;ÀTÜqUdǪŽ­ôlXŸä¡¯ÑE˜V|ÔZ6¿xÑ®tVèîÀÝ«›5’ÁçšÎî»a"<Fµçd%è®_׸g¹à‚·[$Av5Bº%ÑÛ¿o€¤ÓÃjÖ´ð‚bi)œ¢<—¤ã–¾ERÕØžVmï©~Q2ØH¹ô%5±ÀŸÊ¯º‰–Mu9´„í…™.f¼p¸~—zÇ4PÁÌ¿ÜéŸÚŠ=* w³£9tN⻦üÂõ¦ aa/!.Õ°3Tƒ,Xÿ¢s!<éü*y,ÛÑS7Cfvw”,Ë‚Ï@ øÙ·€´Ìwwd/]MÁ¨ûíšétÆÔV"–ßãi?uûá9.[„S(b#ÏkõiБ³ÿu‘A.­ÎÔy&Ž(Q7ܽù«Iz¢"ð™)½[TRT•Bèë¡;±|‡¢¯ˆ-Z$„‘ ä(JEï_Ψ¥Â-5˜Ãu`7 Š¢»ȸ›ñ™%„ÊÜf«tëj­ÁÛš>O{P¸¥ûôR)Z,Ø·žViä×Ŋš„ë²ØгhKíÌDÑ^|»Ê,‹Nþ0í›Ý s‡¶ñ´ ”úZ ¢Ö¸ Û‹?q‹KʢОÿsÔy«;IÅOÉA¯©�ëwgÑÿâj1­Á(¥ŽƒøÓ¢¯3Æ£‹*–ÄüÕr.b‡c“¾Ûjû6 #ÆFÔS˜h_§ùîàÆArSÛQ2HŸ{3yÐ*©,T¿i‡ºm › ^½:+;g‚ÉöéÐ7 Dz¥ÐHªŒíL7úF2šŒŽ-'ßZÈ·L} j"#¥N}k%Š+fÒ›|ågTÆÂ#¦¸ÛŽrÌrTgSô~þS ½ÔV¶†ñíù£áSïòVA¢òd YuŠåmßGçì1Í'^Z&“|Eà6\²ŒCzÓ,È{e P`v4sêùc¿òÖÖ¦-, ktú ]ŽÚÄ[ÑóC<`“ `_ÇîÕéK¸[šÄ½!Sš®}¬WhÜ àèS9æ‚ûöc_ƒÐlUˆþÜÐ2qþT¬¤²šHªÔÚ~„òÞ¢c©Üà9ø¸%Êcßå‚üST©õJYÆ°nö“Ê¡„Þˆ Æ3ÁÔj‘bÃ=gû e½ÙÕxéçv )X­‚„YsŸÔT¶M1‘ ü¡ ;9(ÁÅ2"Oˆ1°úopöª]²í$«² {wÎPì17u*Ï·<Ξѫ²,ò\…Ê�¤Žèô¥¼ß¨L„¨T‘J.cejwÎwÕЖ­›âÖÐ¥½k)¥¹Ñ[ÂG7[=2²íéó´l‹_äÝÉ“M…”¢Ì+Hä+TréÞ˜«‹Ôx8f^ }S“¤Zïºö‹ÉRŒ:dhéo$§Îå<ÝPðvtŠýo”7N’’/šæÁ²‡-ˆ:Ø’ÙgãMôx¶êþ+¿¢ðQpòƒÑtušœPÀ@…pÓö6|ÑhºŠ²‹´CûsÂ:¸©}ç}ÇünÿF¯ÉzP¡%>^8•2gÅÌŸuº8ìÏ#�ºLß©Ê€ë†6ao•“£a¯°\¹ý¬UAô¹õð›8#s|x�Îï!án4Q˜P>÷ôÉ“wÛDkÝØ+ÿZmˆ=èŒY„˜¹(aiû<ˆ- —¤Sß_XÆDÞs0%%ÚÜDšPß´“,D«4 ÛóÄL÷OÏûå°ïœ‘¶¥þܽºQž7eˆDö" ŠÍìP fiXÎзoØܮҩ”,.›Î<Õ(ܹK „úÎ߈K®_šûnÒ!N­‚n¼])÷Û°R4²R.¾å‚cñÙÖGÐÖÔ'Âæ¡ô`cƒh(¹S8%,‡Ù’ƒ¥H³6cŽ-ö “¹¿ë©Ý¤gñÂp „îYâs1òéN¦‰Þýñ—$ÏbïxF²tuI5ú§K*Ž<ø<c‰ì¹—ñÁŠ:¦…Ä9W.ÚJ#cª4m)S ûß®×i:;Êu^í·7:×Mû£>p\,Z �ßLèã§çü1Ô´g»Ž1ÍÄëfô•Ä™ÿ™±�QÏISŠDÇ]\K¬.`LíÊ'žXœž<ø óÆüØÂãxuï^èŠsãÓL7v?íÚþiÏÚ³%aøÑö„Hg…Xñ_…r¿ä„Ë:_æçFqµ0ˆ«ÐNI-e,Â%Ûó'ÜÏÄ0Uoñ98GÑòQ­*µ:Š9Ù]ƒã›ÞÐÜ FLS¨ûÑ#pÚIXq8‘Y1Ô󚋱?÷s¤IñåŽÅÍ!Úêð ‚M×"’N•ir7gûGVê»g%sÆâþ·+a¶#Ff÷ýq,Šbß°%B‡BŒ62DÅc·N­ÚíÌ# C¸ñÏÑè>ÒÃÁ›cX(8Þ¼¥COÉ<)�ü ØBld¿Sž?‹ k·.õFîЋ‡·€Õ»ãQH—»úWÝ/Å^ýËÓ—a¤›ýnU=ËU°”@¹v¼ïˆyD$è )mïÀ”‹E¨:·°îº€ Ÿ©g•‰ï|"Þ ­ÿ÷Æi„K“Î(°ó‘î/OíÅ’jô(6Š‘s!ùÉOltKåiëÊzûÍ~þ Ñê“iœó«éÈû «bÑöƒº"íæòsçjLìãvèëS¾cáǶ}iæ Q*1cÒc+öÜ\j;vÿ18õ¨}¬¿¨Êù|÷Ýê¡@‡/§²8:có¶g4íf+¥’dWZðP‡°+=ÿl†Öó– ½Çx:„•°ìWe¡Çk§ ¤¿ˆ7ýÏ•k€üÎ@˜Öa‹Fd«cX˜Í+í 7àä ¤Áv< ©ufvù¥¿KnºÇˆ ]ó ’0CE[>Ï g{q¶ÉÒž ÿ ­4ŽpçËúÚ4ZéÍû{B åÕ-;v`º¯Ô‚îØÊ —ºG80,qQxƒõvcd[ÝÔÛ㱺›¯Ø@[Ç]j¨KéçùÒ~׌²…­ ìÂzÉ>®`#¿ÿU¦;ÎrãÕ½¨¯yg²rÏK•¥[]AQ¯¢¼Ûie•Ë=oÜxöÊoî^)jaõRtD²Õ(¤¨Ð—@õieñ«&ùýÀì=k³mAÄw¯î?bÖ”±"Å1ËþÄAõÕ8æÏû©ßvÉÞjþü /ƒoFV¤ÝÅšVGV‹[ëã0pó”Ž#¬d}½:ß2—òq_íÊ ²£Œ¢vG´€ÍØæÇݪÜÑ»hBƒw¤âve{ûFR…êí²y k÷74Ÿ3×èÒ8 ‹­ MÇDE8Ýwx„£¨eÒÉ™?QåÚž<9öF_ÙÈ/ÞÓ[Û½*6àœµ…ï“‹ Ûùò’µ×ò6'‡›î û¡: êuMµˆ1b4­¥øF&ò±;j¤à2¬þ” ¶G>¼19kC€ Æ¹Û™Éôo,dÙ¾õõïöÞ¯n†¤™6dV!Ô!?­±4ª�:™›g«Hðàž‚pí)Ë?Î2*·üܬ®ƒ¤í=¢Š$2di¿æ–EÛ@ÌLœÏšè-ôPè-­%"&o³l[¨Â ÖwQ¢¶ýwu× ×Ÿ*Så1ƒ4X¬:ëÅ3çáXCÚß½ÞQ‹v)°Vmç:§DRÓ¼T}â r¦ëg3þ¯:®©Ú0wÿì= ÕF_ô?³¶‘œ~CbG³ ö „t¹1ЂÅ%*3CȈx6ÕÃ…Ðtq_üV…µ„í2¨¦“vp þ51¼­ÄÉT ­ˆ¬ ¡±ƒpÝvkNI4.ÞëÆ<Öc}æpo^¯:ÙÑbÈB;þ÷é<{áØr m—\WóƒãÔÁ…µB)º²•’ƒZg“‚Ÿ‹þD‹±e‰ãrôƒöX Qâ�öJ+ ú—Éü ^Ó´‰½@‹Ü4[p6<u:–I„DÜþ4 WÉ]êõ &krâÕœ2,c#·�DTBÑ»úÄ-{½°S@8æz—ç'‚Ž€°éb9šEão4„áÚÚ7VÔKÕ‹àxß :m÷”W{0™T“O«3 $^`ŠSÏú«í+H=k=†ð4îÑZ#jjlaö,ÎIçuCÙ/ÉîrÕöáTé=ÑHÎ-AêÆÙÐ5£q©°E†’¾ã<¤•ï¥F ²é(žílšõ<õ”`‹I¸L´uÖpKif_²×?âU_Œ± 2Óèéöáˆ+÷wíáÈ›Ö''9ÑÁê4¨«Ù´+'Êà÷~ûö»ÞÊ� €>¦}}n™¥ybq½œ=¯v¾ž<­ªÃib„ªÅï÷2 xivÅΚEjûmD[{˜$úéšÂ~MCTj^2ƒO®àæQX}A˜i/ žyy8¢GnŒök ¶&ò¦lF±T¥Äú™ÍCm-襫Qèw2jîø……¸Òy$Ch5LmÔÖL³o(Rè‹lÓg݆0ô]Ù¨üônÐÏ‘G(E´<Í–ºÎ?¶ª¬ÇR˜ãæPáþ¾ó(ëe‘š{SLã†Ò³”ú¯b½ò5Í£HÝy=ÒR Äÿ¿f»¢ÅÀù†C‡‹1|®Wqꛎšy Œn¦’:ˆ }3õýæoU¹—p0 `}@3X�ÚÇsoÅJÐʸ]\…<¢Ð]ç‡bÑÒÈ)Û£¥þnÓJðl.hjÚDÍ@wùŠÖ<²§…ò\! ä»­­û3{z$ëïåǵŽxPMGdÓRbã c–ìšoŠN }ƒ)HÑt¢zÖP Û±u?9©±Ìwb€ŸwBÛÊÆ îxVh ¯¸‘¤iæÀtÿ™¾“¶[ÏÕCzwÁç©E3› Õßðw<Ar‘éaTJÒ( Œ"î‡vÀŒJURíxQ¦[s©ó PÅ)ð§Féâ\°`¥ü¡ýáyѪwü88õ2\<Òe‹J'9€°GuoŒ6ƒÖŒhòqÏŠ¾”:ÄØÐt)-¤�Ý:Ĺ¹ïZñœÍwÜÕcsÔÒS>cŠ4uJ+‰GL›r+Qß´$¥UÝNߨèD…C®EŒÌÚ (ØvZ9dâmv@H²{Øõ îÃ^‰°ÔmË3²DÒÒGðš/§©|n÷£½5WOð/× z$;Aü^K¤DyT:ÕEnjƒþ­yÛµÛ-¬±7ÀŽífúðÓ[7³�å°ê‹l@‹¯<íÈ›H©^ûùW„ è!µªÙTêõËÓI-Ú®~ºÑZM®tÓÕÉ®SU"Bë·÷cÃæê²M‘êÀƒnîKmýá]-BRR,D½¡Ÿp Óß‚0Sñ¾èà“ «çN@yz…_y¾½Ô‰§§‡ózc1 ̸§ ØVÔ(ù²ÃS¦˜Ì¨j™Ógl [óÈoÂ$& í¼{Ðg6iR)ê0t¸­, 8cYçÐK¯jÃ,3º˜A5y?ºÎ-÷ðÀç/5Š”_î“Á{ÄRÎ>töŽ•EçØŽåô½˜á]Ú¾Xæs Q`@_·y7ót×2˜52?.¶-*æŽUÌ=÷‘Ð9ŒÇih׳+`³Å¨™¢ŸÁíLÅŸü»* Qšø@¡†­±Õo/3ñ[Î 1žŽkf¿üß[ßçoQ‡P°¼ö}”«µ“XÛ9œÍ~ótÆ][¢SÐvÕ®p>è1—•ÇS×þÈ\‰½A»ZMï궯OoÛ3]-~òÜ=ä¤Æ »¬©Ó&–S¿kHïŽ"sñâc£O¿¤çœ)S]"ÓšÞÔc뤦‹Û ÜЛyFqæk_¢¸,hO|j"–²ë3ÇÖù†ö:!Í'B$†Q!ÅÖçÙë¶÷@ƒ ¡îg…VRT>&”Þx>S@‰Úу²žñ?ðº!.¢×²îÈ×j`•¬~ Ï›ºq(ÀQž²Ó¦¸‰i!,^Ëø%Ž"õA@·„J|ª=Bõ(•sC$þÎZ®ð;âlšéh‘%0ùD¿k¿$­þ@rÂâº#3:8ÐrŽ¾Þ½–;�0‹®@™å¿ù’7¥éñU ÞÁ6¬ —z¬?<ÎÊb\½øA_oó¸ÊéaèZÍ%ªÞJþuBŠèL�ù¢"AdóîÛÎÅ‚¯xfŒØ»ßÒ‡o.J DƒýDÙÚmòï%Ê‹Ô©pý}ÎrÒ-W¡ ׉’1?q.3ÿËÇ éŽ=᪜%õ!$…$Þ¨¬Xå‚û ‹™'Kˆ®àSÖ³gܵí.}¯Ê;õZÞÞ¿ìZz×kÙ 0ô]S™Kõ”å4³æ$tÔ”Èäu€1†¬ ú/þn¿77©<jSÅÀ¸g'Vˆkcd²ãD1`zÁ<;W¹uMrÕ©ŽÇ¡žéH;O [1 SPùLU*ß‚+!‹ò¼“é–µÍáD QÚV.>I­ê¥ÈŠ;:vƒfÝ9l`öäý­¬8”èËýh;A+æ'Îò™÷F‘ÚÌ�£¼øè ÔëÌç‘ϵ<ûñ/èéè·~jŽ)�f½­�£ç<9¶5Bt4í_ßgŶќ™NÖj¢]\XºrŽ@@ÁbÉ&P£ï¹/>ÅS~;(<>‹r°wÙXÈPd$ŽšFÓHƒÉBÃ_ãë½ÊÍ¡#Æ0E,nig"Ý=w˜§>1™':À)N$ÖIóML�‘LB¸Ü¡ö\òèuIëv±)⺜zg0P)?¢­k“äÚ¿þîôô´>$=Å.œN`*®ƒòðwôº(u f½‰®Ò—ŠâT±W"K7í³—¥”2'ÉÂò,‘—ô:Õƒ²$NP“éÚYü™"zNî? ¦õXÏ?΋ªÌ׿ÄxŽm­u]!ƒ¿ÉáþŒØ8Oƒk]#øe4r‘-ê‚í(óY±a©s�µÙ›õ¢t¦”#<Â#¾ö©¼B‹KVB à¤OÏ�ÓW#ᮉéÛ™Þ  �0 2:‹®žX±�›Álpÿ¸«Ýw�a|?OoL1j°Œ}ê ¨L.êÉ™Ž7RsX!ô÷6Ó4‡0¬¸™S )³ àT¯gN{ã©€ê+ kIa`´yIGLWkƒ¤S­'×}ù’…’I•EæDR0­§T|§Ù‚¯Täc"¤ù`h_ľ<…\$jŶq­Ó·Ã±üüÔìØB‘… uÌYB+4ÑoŸFZF‰åæšGgt£:;¾VÅjQÆät¶-DRžŽn|m+2ÖNCÛ�oúNY¦J²%{ñ�¸ÐN‘¼˜^úú€ð;0¿)]ZžýšÄ×üª‘ºÞ€X¤bQ™‹CŽéŸÑOhº=¡¤Äá5ÌlÇ®àZ4 [@9¼?Æ¥³Gô“Ìëp!“if�>ðËP àI…H=xªw|äŸë, ÝØV÷ûó_aÑ»º*æ&ABg:Ù `˜y}íÃïÎ…'æS²/`QqmyP{N¯ZŒÖÜ^\3÷²¸È\±Ÿ,Lu¿<¢Ñ‚°shƒ$¯t×à–n®ð;•-–,1Ê&zDõw+é@7j|H~§bñ/‘!Ð\æ—§ë„?®cÖçAðaLôM7™ÚÞ¥AtÚ™Œ$@”Ø=¥Þ†°ýº¿‘—ÂU²ù4(ú•çK¯œñÜ8í'M¥ýkl€zäY×þÝÝ_zât"ÌHßcU•Ü®7;2Ÿ;´bG'¦Âµ,8zßf?¯wîâf¦’f%ýs|pt9­è@=Ïf¾1Õ‡ËÝ™GTA«ÁĪŽÖúý1\ä°Ä›-¡hžPÑ?º‘}WNyÒßݪ¼ô0àü¦šUWNŽÐ`˜‚0ð½FŸ;‘Þó&õMÚ¥\ßž*ªÖuH,K¯fwÐéýhþy‹"e þÚÓóKV| Œ ãü‘úx‡ít†PH«mï Óã¸oDJ}�Ü­6Ò~㑱áé¼®F$ôÏ>Ý螟Ѷv+ieÎp;-_¾õ+SbØmç1×ò?4}œy„ØŦ6«}ÝñW£äˆI§éoh ß•z‰¬L‘JoŸ!vQìjÓgætÌ3þ’Î?GÖ}õ/Ëo[Lfnð ë‘nMç‹Á ¼ë D:&KÊ å—æ¾U†#÷ m¿›JnG™† ‚º¸ãÖFøé>Ï|[Ǫ„%×NôG)‘ìë8}´à¿LÜr_üÀïíõÛ—­÷ÌÛú¡*%ÛÖðŽp/Zà­>®ô`{U¤eYZDBЂÙyœ%37¸]§m/õ×i×¢bÀ3FžÙîdØ -”7ž<Ë·‚ ÏÿìoIte½«žO@£ÿ•Þ¸;aãzðÉðۣǩ0àÙ󇞄…%-ðùK©9Õ9ÃÖ×>¬¤©âðµ¦Á-挳mtQJ†u\Ož=}”¦þµo´XoM¢¡¯OfþåÂ_„;T­¿«pt–6†¬Õ5¾¤ÄYj=‘¶‹î^rV¯7†e¿m[�- â%µ½4 —Èp¤í¶Ÿ?‘çÖÎJ'8f0ÁÏ¡ÔíåU9uHFFÚ«úwgó™“œ §Àäèä§k¡»Ù?jÉ'ñašó [i~ÍÖusA)g¹K1 N‡€=å-0±ùêÓ0­h³Ã…�Gìz'ƒ ºÍ"o?S6ÕÜ“Åò@Wì‹LÒ©Z&´\—î†?¿dI–y¾„ô.Gz×lz7}]ÖÈj×;±I½Häi °ÿHr.÷è’Ñ~ÌH￬Ãè—´Ãô¹Ÿ[Z†äuL5IG:ÅÁzM—˜¶’}ëºv¾üÿo|kS`Q/èƒú—Ãñ|™Ì¿¾ò†j‡õ}ÊÀLY™´Ln/ ;ç(#L»SPÜò° ÀÚK{¶FâçÀTíŸiµe¥o¯B¬xxؼ{]Ôæø«åÂU7È•u ýw^á&ùµÙÆJ˜úµ\ØSÙô ¦8Ò×ps°ÉfS­É…Ä7Ò-†®îÌÊ‘£­ˆo5ƒÕWNŠöþX9Ä™T”Æí´ëbzÛ颬‹Ÿê·õÖ²|Hq‘’q,Ú«¼çâ‡èY‘:÷qÎÇ-¥Å±ûË8Ù1N7*ïÃOØ×s}AÛUŒ³eEqÓ²éèV%v̇’ßwõ£œm²µ>$RßT™œ¾u"‰³ºO\Ò‰l9£%ùIÇ ô=Ùe‚²ñn~_@Ì“»óa@øj8djs<YA,«·àðs¤õåöíb†x€"½éº¶Œ´Ð0dâ" غc°ïÓú$[°­+ª¤»Ú³]ßÕ˜ ¸yéõy|©¢Þ:"ªFŸW줇ÉCMÒ¡ÁK Ç7bòdé»ÙÜÿ5“é<Šª$GÛuÛåf¼Ç .žjÉtjïqØO­:»ã {x”e‘ƒZóòÆ8¨lC'³(Hž·ŒþÛœ:W<•–(B‡f­óݱ ³ {sì†]=¯øÄqá €Ñ>7IPÍ+V…yÊæh«™(Â�p$fÄt¹ž ÆT‰¦Å ÏáÄJPð¤ï ý/°hk]~k9E•Ÿn£)ºËAS=¡dZÜ¢T­†¼ @(À˜]F«ÒÐý3¢ˆâÈg3ÄÏã÷Þ €°’<J¡!Æ$ªçu5~ž¬F©¶–Sㆽ>TA^+/â⦫¦Œå“–/ š;ì/W[—cNÞ•Å–+.åõîDAs"ú8+Ñ¢¹å6%iž9YCz׺ÊïS•`/¨´÷?³‹±³Ò§s`Ö´ØiLÅe6eÏ=Ôº3Æ §p¾ß§ºËf =1Ž\d `áÛ|:¨vÛºFÍqËGæ|ÞÏÀ94ã)¥¥‡že(Åx0öŽ«•U€h ¬_Ê>É0;gqù®^aHAé‚1ýQi{öt˜ûzØ»à¾ÌÄ ß^Ö?°0ûŒ3sK‰RI‡ž ¸#¯!cý½øBõ8³ÿ=?Œ0vt„ÝR#Fè˜?À$©¡Mè­çÞQéQ{´"7õê·ÿßÿ£pCGîâÃù¦O£­iol—f~.ýLªTÔ¤ýZSY¸G[ÑWM˜{ׯA°á½Oç.‹Ç=xuáÒ î³àØUAXkÞœè\C§»üL.ú_�¹Ù’¥Ýao~ÎntÚ®Æ+DÝ·Ív;5(õ*è’*Èê•WëЩqWŸXu-8Ž‡ ¹G>ÔQº7š|.‚È â°x‹¦m'fÁcš9ÙUê—±¯™6:îZy0o¨R_i<A=ÔH¡i¢a0·RwžÇ–V‘¾xrI5Bô¢ã<ȧÑCã±í»‹Ã@„Ñ6öâ¶íœDÞÍà®ÊtHƒôsãMvÐÀ¶‚*‡#ç,úÍI‘ùëQ‰ ;Wr|´^Éñƒž°ÿ”–GNÁ‘îf2Ÿ]ìDºØ´ÍùÒ4VSçI‘&ŸY@÷ow¢iá^²9~mh7û]àXl±µ·\ƒͲ•;Í(y sàŒ Ñæ¶×_$>V)œö«€EË´ºÀN<p‹(Â{XÂ(Ž ë¯Ñ*ëèƤ½41ÂÝÖ,rÁá‡6ô;ýþ ˆùÍ/¾ŸÙGI™y âfGQ¤Û,ºÑtÄ7Š7¦MD¸}}5èz±Â¬ó«Q ó†„òNáuiø¡‡CœfNÎ¥d 㶈½jÍXnÉs(ZSúbR7vB_þxËãŠ<š˜¨ ®èñä[ë Ç Ç.”Ì«ÀQõ­ŸÒJ-éMFªú}2+Œ’1äƸS››g¤’^þFž¯4Fv Åý®ñdÜ·Ç“ÒÕ¨ÖχVJ��6{DÇãGb0fW}D»O×ëSJX?ÂÊö<,ôÞ’ýÀç>†¥tãÕ8áí‚�E'e!šv(ÿü'<qGó#ój>¨¦·°èÜ*~EíÓ|v$ÌëÛögS¼…$PŒbm„cÞþV?F;mÆ㊉ۖ­GÙØZì0vh›'Z…Ã&Jc¹¥„·±•­¦èŽ>¯öZ£ý`âÉ;IN3ÃÀz÷Û ßÇÚã'°à€œ/O¸å¹·¡rVT©éÆÄï:­:\ºžK?¹ù¤ûÐV#dòÚ‘%›Ÿäz{(bìþ˜Õçl3eŽ ‡Ú&â³½Z[ ÄÄšDSzã$Îq ÷”ËiY¼ãʃ‡…9ôC#Ä8O ’RTzÛ©ö 5U ûU­–©Ou’Q…TÛiä_Š[ÏØZ©L¯‚<1Ï­ñ¡oí¡MŸ‰?bfÒÑC›Õ¸r™3•àɉ&Œ5 *‘Iƒý-o@€?ÔŒþU@L¢Àda@Íg’¤]É)õÉÒßÿ@öÙ6~Ô ™z‹F+†}ÐÒnÇq¿}Èò€Yeè[H@:8g ÍC‘=“µÙ/Û#¶åÛêÂHDÞ8ÂЋ«¡”§>Âpí¡ä\)²±õZ¥Bc:è%ÅóÏl2ÃÌ—RNB±ÉüTG‰<û÷-/UëÛZ½ì©%¤!a¯�8h+öüP_ In¥(#+§H·gèÚŸÀ4¢hQ$Ð;@ô]K“@Ù‡ViO«Bm-Z1ûF$îݕⶲÐcÃÀ›zoU« (f ‘³ÅXþXî-Š ×¢bAþÍ% ’ñäɬ#±DQbñÙj®ð¯@œh׊è€î*ü_{#_¯œ3c2Îú',ª‹N–çÎü€³í.iÓ¸¥ÃyÓ©U%jJ )'ý¸ôU �à9ƪPåæ(Úž2º —Éw’n‡¶gE$ë·Fï°é¤%rÕˆóEc. V`º§&SYÅ£§eØ·ÿ•a$ׯ‹"˜‚®/pºÊCK«!9ùii3â\³íÝE°ut¶³.”‘Nñô¢¹ÛÒ·n{è ·zxÆ9ã‚Ã~f õ¦i'F >R„]Úv²¹©¦œ,ƒ¦´fö: ÐúŸë²Âÿ™C¹ý·p:jcƒÉ<·DDZ¶ÁšŸ½%ë[ÜÙÉ¡•¤×oiã¥Vc•“4 ào´Ñ™¹ïãUY{ËŽ’.G^$sÊi ,ÿsò½ öÒî ©ëçÝ+7+¾ØÃéJÉs)ôÅu?W�[;ËÊ0�›ŽÂÜ°õÀå5м3ϵô½©êWVÄ‹;w#[´?’˜sXPèŽm6ò<oÅ€ªÊ©�b1Ko SäŸáHhü§´' kG¡à•ø_5 ,£”ínYn= ²ÝÆA;ãÓ¾û•Ô ªÀ ¼2( ßêâ'±_vƨ¡ ½W¢¯WX4bàgÔÜx¤D~ß..@€$ò@ÃŒh\í@Jz×n Ûˆ)šôË>•ìÊSNK¢81Õœ½'¡#p*Ù©ŠºweYùN›ñ:Ý'kq²ò›†ãaüÝs´  KFh‘S„LëÁÊ©ÌYFQÇÏÿ©ÎªáÑéé¾ ƒß®~RX»dÄ Î:0lÙkËõÙ òU„ú(‘'К#;kZˆ—L½Ó•êÕŠ[Üô®“³2qÎÞÃ{?1„3 #«Íïg¶1Ý)¿¥™Ü’@£ëŸ˜Æe¶°òÍ¥³’l''G·;Ío’~ð†êAøöÈÕÐöúiÅ -«*ÏpLèoa'ȨֺÛ1ZnüþñB™Ås‰=gÈ–vÆñ‹Ö`µ­¯™µG1îÆéÌÓâ"H È¿ƒÕ^Íåõ&§?`Åm+¶p¨©t¸Ø6 eGµŒ}Û7%ƒm)W8Žp¾ÿ[ƒ\sŒ–Ü $rT÷ÞÄù£‡9ï›?áxE~¶ò8U¢ÚšÓ“u„|úÔª¤q’# ã«*ÆÅ•&o³Ë™üÛh†6ÂDñL!°»zb•™Ø¶ŒiáóÏL¼> W‹»: R›ëSxì0É.éñ=5·C†§úò#’{VìŠ`êi_š#d¹qÈ2¦fgn&ÌwŒ<CMg$íˆèdžï º}¼Gd",ƒ;y¹wõlã„cãtf~̧6¤h±àÞHõ»–}¹”Œp9~×îÒúðø‚lTû&,Ç¡†Äë]}Z;][óŒí³–>ÃöM­([Þû5žtœ9ﱤ�aæ™ uÚbH¨Ýº?áAE½_š°CKÅõåì+?Ð'E+Vx'gp)ÏËF’-á¿ý%ã´ýEWFï(¨â]½ß¾&ºœGÞCÉ¥U@'}ܨM4T|Ð{„’€™šºŒ£ùÞ¯áq¯¥—rk¥AÏÐN@¹#ô¡ˆz¦ÒíûØ3ÈqÍ\€;ˆ‡8Ž\@P¾)EŠ]ç DÖGKøé[ĦÏÂ)Í'¢½à~gnž‰D™(:Z“ ȢОœ|÷ß:º1BjD‘0_JNŠIÀ�†2Ôõɨ¸ßΓ~bféÂH¤0aÖlg’rT¢–õùT–5ÌÝ}J€œêÚ*(»­eL2ÍG"k!¿:0ÿnß‹bۙʹÓþçîqx~ó¬ß°,`Ôš72XôV¢Õî±ß;œùÞ…m<Gn²¢†BÓÊfzÛ™íyb )o�gZ¾<n˜‡•"ìNyPt.U³]pË’q¶Ÿðw™tâõEÒMT÷–'ízÒG†¯&­%>àUT†õ©ÌËc¤kQ2c»„vÊfÈ¢ «'©6+Ô×ô›r²"‹I­S.i†|(ˆtR Úô‚tÞîm©üƒ™zæu„Y›´ïó |ׂ9¡Šv1 £xßqÞ~ Ô6òÊïà¶c_ýŽó¬$_¼·#bªÙCgR”Ž½’Ýo”åì°(`D&Ì‚¤Ùz½]Û XÎŽZëiÇÏ\_鹿nZ#cé$˜Ú û¾ }Ε—MȇL®< •ðvÕR g>ë±ÄˆÕþ­eŒ1£�ÙWFz6Þ•ÎQãäòhQº²=®²frË®íZ½åDÑÿÔ\[8T¸ÅS Ç­ÞkÙ°2dçRz\q?÷ÛK,Gæâxçu7ÁC·«µÓ8Ô“©MÄô9Ë-\ àès®7ð0h-�)&ëÞC‘Tsî*ÑâÔÇç=!nœ-ç@Ù„>Üå³Z,BnCKo”t“ëD¢8õMÌ”5ñG€³ÌÓŸªð÷v#=»ÏgH/˜9}„×cÇÛ ùs¶×â©éëøºýJƒÌ) 8�x~B‚æ7‡n¹Â‚¦#˜ Ù`Kk_©ÕoSÛmÞàóÞò¿»FÃk%É„^sÅÿ_ã=üèÚ»AÚÍê Œ®Š/Õ¡‡=]ŒË¡ä,ÆRhWÛ ×»¼9ñ+§â( ) &ÂVŸ |xcÛjYçׯ~_™5µÞQâZv`ƒšúŒmgòª¦vkÆ©÷¦ªF‹Çªp‡ô”VÀ<ÑXwVÌДF±z÷‘¦À¥šeÈ4!:U³ ³æçÈ7‘Ð3ÄÈpmþ‰Öȧük†·‡vIôMœÌŽTMyT+¿rO‚a÷<êì„þ¡õjw4¨„gvUÄãnxù2‡Ãf\߻ד¤Ó¤>¿©”饈¼ˆCÀ=üÍ¿TÉšßØ*ßÖG|n�^G§O5i§ôŒó¾cq“Ú/]rtö@äí×ÉÀYšë4£oë®Ä™`:ù›ŸPþ¢eÄܵõ/ªív¾Êr™= ûú7ÖG8GÀöP/®…™ãdaMÆZ‚T$¾¬Œ;úkNÇýŸ·ˆb\ÉÊs½×;û^\p}bRáñ ‚ßËœe)÷γ¦¯W" û‚¶Qf‹0\Þ1îÔŽt‰.+·×¨À‡Fïažª¦‚ øÝI³ß÷ú*ÇñÂóM5ù÷>@Þ¯Üس-(L­¬Ó)–xú…©tjÂâ·Ú±iÄó>qµÉö8îåá•?üü)“1Û¯Îmãà�pû<Q¬¦×•{ñ n£Èº¢>6gÓ$ÍÙ¿´Îå?¨Oã,w)& MötS=5¤ÄxCQB¹ñÛ:Úñ2Å6 "ïýîÚwÌå-…‘>kf #ÛÖ •F†zšœ½;x¤R¨è¿<5s:=v®šòxÜÅHgã5¶ÐVP†ÒÒFNew_<3ñl?°žÓ`EõŠÃþ˹ֹ¡õŽ¾Åqý1±¬y›å[ÚfàÙ«Õ F¤íöœï³iM`ˆÍhsQa]¯×Ú�Ü]z¸MôdXƵfÁüK>/žj‘°Iõ™W�ÿšv-•CìÆÌÕ�;ÒÂÄ\ý²•uþ>yÕ¨¥4Ü$¡Cþ‘•µ…H#uK¡/¶6cIæ¬ÍÉnÝI6L™Mßiù#ú÷ÅA…*_:rz… diÍÝR,Óÿ}½ÄÃÂ5R Üß”:¼?ÖðQÍžµe|{áúr¥¨rÿÐR~;¸I9-Ã}Ý×jB%2}½áZz% ™Ñæ°ùíõù  ¨Öšu'FÔîÊô÷8}]&–7yfVxÉ¡Ìe‹”ªBÍ ôð»ýzç£j~$|]„ UÌ„Å|»]Êô© ›—(‹‘ ©G<{€§ô'àL§w/ûÙ‰»•ät¦%nñ¥9Ù-ô0r³0´?ÐÚ¡`X¾+ä7ÉÚŽ]}BíÉ=Û{â2ÉÂ- v¦Ê‹ú·rŸèÍèb_ˆÉuë8¿[¯—)SÅÚ6¤X…h2 Ë漢OI‰ªÜ%=…°ñaù>{‰5­F4/|¬æ«sè,ôÑ‚®‚n®2"¬è°•/Äܳ¾âE¹þ•�²ùîm·ÿ]ÃB *j-禡¾þѴϯÛèEâd?¸ƒ1M´ö§w_ùG�†QôCTè-J4Šª´,ÉÐQVvîæ4þV„ò3T”K{Ô|v½¡B,®·¸— ªTcåØ_zËËtD , ÅãŽm—w“¥#²œÍh§ª[6û?@•¥«n£ÜÒ؛Ϋi¤Ò1ÍSž^ TçÙ/ãû¶Þ½¼N£ª(\º© py¶ṈÁ´ ™¥êpËÏ�Ìq¸h6„Q0 ´t ƒoX€)¶Ý¼_ë&à ö‹}~è¾ؘ? s©Sn àR}Y©Œ&ä`c«V¡]}áüì—fBwŒAâÌøãÿ±¤!pçŽeºi;úßÔ*‡Ò'Qîÿ^Õ0¯‰Gü¤9’á¢Aà­áI$ª"ûiÕBäμ>IJGYœùyádJkêYS80î˜fÒd¢»`ÚÔ°xÍS/Â*Ïœîn)º¬éæÝë>" •¨­Çò¤ôIÏã+:­ÎØBsîþLà˺¾ï9þ.MßSØæNûßj?ñ])™x5`×Q0¨»èBXV7³Õ;à9š–…ëŸH²9)ñÐxLJñ£K=¯LCä—ZþYáS†Wþ˜»mF±òÝõZÑ1ÇýÕwíäõîÆã–nÊAmTx–M,í½ž1h¶¨W” eß,w²hqäAx[õ.¦HÜ nÁ BH‹Q‚a°«Š>ôê·i³_û^ê“Á#áJÿÊ‘>T$]dø…€l©üÙõî|¤²þ¼™òT¯q¶>©Ù ·£@ɸՓ _Š†¨¸¨¾„ê·½ˆ›fþ,&âì#ñ°ilѵÕY)Ûz1q,€Ãœ¥ ³a£6GÆQg?" ¾(:WÆç43BúçÊ("ë¾4°`™&Ç3p5^j ÕNj–û& \³Méí*p[œ±´ 5yIb˜wºóݾwug±‡^$à?°¹$T„ï¬ïC‰„m×zçÞ]ˆ¿ö·Ö›F}; Îýd«” §mkñ‚FЉê{–\@k—[mÜÊ9<0s©k}@�§Å‚{oÝe„/ ‰L†ÿ¤ŸyTyÎg@uÕ=1Š1 gþ£ߘF•¯úL[ K1µ…€>¹é0K—œ•_XVK'¦t^)ÖŽí¾ß_ï¤UÝÕòÏöLqµiì+VwäŽ >äDø½U•šle–À÷°‚ˆ¾W…+pLÃêUðž‰55† §m<¬F.ç5‰?SÏç#ó+g*á —b4Ä“C¶kñ}ÙQ¢2«@,äéP“E£03"¢»Ó(^&à×e×ôEŸ¦0Ší,…UEŽ_túD£FÅ¥[Óñ "Dÿ¼q °ž‘ô\¸z¢ÍÃâßù&Ø6kÌ;,ƒÝ@çEj[Õ9[ |\Ò•ŒT‡Y@Ä™H^» ݺÙ¿d=w5`˳¾\‡¶ ù;ã ùÁ¾î$õ¹;„O’"ó3€Íb8³¶^¥ AJ†2]k¡üè‹Ã‰âl6Ã;ö’z:%>¿<+œÖŸ <FC&I¸ C"}›}Žž6øç ]ŸYa_çîòM’•Y/QvN�Ѓê¡âsãù3¾Ÿ‘¸„‚èã³=)³B9a›¡¤ï]Å$ýÙèðУÞîTL$G¤ú¦1è SLs›Í‚Ö‘ô›ÄÙŽ‹´Øìé"Jia%¢.ÕNµ¸½Æ¨¹¥)2Ëš_) ¼<j¯ªÊ–ƒÃÈ6 RkŸ0#C·Ä¯èÆWü‰Õø²ËazJ1,ªõ´,rU¯­nÇêØPö`Nó{+Äê9ÛÙÉ &8éN‰ý°§aÖ,;¢˜c½f! |FõÁ8P=žúE£=Òù–.AŒ;ì;§ ozëI#·ge,�—‚=Yå€�ø (gáIw €)ê‹7€Dt´ÂBmǢϤ±_׊¶xbÚÈ1ŸBHåiñX:‹Œ„ì/•Ý‘Ï“ëß,nÑN âWD­¢uRÑAVä+c€¸LøÛ¹ â0© iÓŒ–‹Gü5g=ó)½œ|U´‚<·4ö[œ–œ´8õh){>°6]9·)Ô„ªÄôwÆŠeäVj,ÆÅ1-ùÍo;ƒ 1I†‚jmÚ_7/Ž¨Ò2èBc®HÇ5´’Z…¤³“ UþBrnü¾Ì'«oèZͱNjä.Ýz΃©%€ Pq8ª„ú,åƒj‚cü7Œ>„µ‰Ì!±ªé>T Ðüíu«l8 祽ËË<ó3q¦?²£²UÕ/e &¸<ž±VnMÐÙŠGf¡S/‚º+¨ Ù¨°DÊÍúy§ù`ÛQ6iæ`oÀGê¯(¤Ëš¸n¬DÅ‘ŽÉÕû»—ÈAxáÌÆ¢ñ®_ÒÅaaùhã¥+dÓŽéÃD“©kkκe[>fµÚV̾Eunàd´q„,:*?&n;Q±¨ÇÕÂ2ƒ··&]Ž53ÌJ`]8º÷_A;â¸Í"8 ­Ä ÁûáÞä$J\)%6`kÌx>kïh^í›æýHÏâíÛ›o ÜDd"Hë¹å”·” ×NOSŠŠÎÚ™l¡ãLç g€IEŸá�VQkýy—?Ó1í©ñD…îåíÊ7#ê·è©j·¢˜}y›Qy^^¹[éb0ç> Ê¡÷vk«°±ãSïïQœúâ¾”õ¯ª"ÈÆw/»Ài4Y´Ã[~dœ.TP¢ÜÌ®ëÑ‘Nq\£í×Ô{°_]¥O ô £;|š½6ñy¯_“oÈ·ÄßØ áDÒ«€¢Â赊×-ýo|ØüxÜÚãÔ¸0]¿¢S/Jûª¨=Mãi«éà)eCª3’NÔJÆE·‚Ù ÙI'];F3Ró¬:ù-~�ð{<ÿ„j-B¥¯B»¥ •Þø\_Øní§ã]Ÿ;úñîÂNUž@|`L3E{6}²Üp=Ídýu/¶$õ˜;<%Z(È!½Þí©îë·“Ñ®¼04Z “9Š:32u ¥abµ›…y=ÊÙ•Ï1Þ0—r:B2R±8 ´l¥Šqƒw-Q}gåÜ4 ã¥͹:ÊÑêî~kœ­U<k!ÚüP»9u|fQk.eš_”•9n ¥k¬G/ݛӨö¾9@Z9ç¦ 9!²°/ˆè0>ÐàÕ…Àü’¼%G³^l$‘lä&½ë[ªâ­¥¾”r6ºÚ®]1øFŽ˜‡7?O½X(f8 ¤jã'ç÷xGMä±€V™„KO¶mÛòÚT3:Ü›z¶|KÕçÇ>ž&#©ÙK 6Ïrã¡T©@*¾é¹H¢PñM{¾îg3øÎ_Íî ÷ÐÚä<8Ù¨cýÑÔªks ú kžçwß(yFNsӲ»^èÍ»ŠéìÇšNeÕÂY1±Š¥ZY¡Áù/œÿ2näÎoÊmU™ï4AKi* ŸÝx°eÅùLƸ™L ÿ}†Î-ª"; %rV–ÄÏ®,K¶çÝ >E7¤6]·¿1¸qˆï’±µEð1S†Ñ*8=S¯661´ 5°WcX=¤ìeáBÈ$ÆQ8æA—†¢ejKÈœOqZ9µÄu$“€Ìk´¿ÚVý‰õ¦¾’{ÄéòÄM©ä¢{k½#2¶¯'ÓºÂ�áàÁV%ó¹Ç`fKŠõ†VU4í¼öŸs¾‘ͺkÝV”»  µ»Œ¸¨øí¾ùC0×'¨8ï£õ:íÝѪ`oBC+cÆÁi8BwTÿ£Ê;õ\5Å°M)ål´;¨ä-Ï°bI¨ ÜþÅ$Q j«-Dƒô±£ÅϓͶ/|´ó\Ïè:ðŠ¡øfÍ<ÔôP=À3wËLÛ©ié7 ðÌéÙYéS¦š¯ Q$qæ«H†hú‚s6hÝ€‰Õûq:ý¸Ž“¬Ex²÷µ¬2¥@ŠYÕjö€CMù®uqíQˆì'ƒoàÎpÜÃD©q~A•bOíZùÙiãXJõ¯ãºuÀb¸­[º½­LQÜ4% };{Ê ´ 1Öt|Ø3iîð˜Öô…ká]Jd[l­;¿Ò)ž42!·Ðb¹ÔÞ×™vÆcáÒ_š†nOM­í ½•¹×Þ%¬Iì<k ´÷+¢Þ í@¦`ží<óûau&~À¤U=}”Añùée•s{þ0½( k�é>íNÝÁþô&ºã$s5Ž”i‹Ùr{ñ\)i©ôô."׋n7½‘m»¹)‡›vWjS‘Ó¬aQg¡Œ£ox¹Ã¤muqÊßÔ®Y”y‹†IÛ—Aø¥úŒÔ[Šûõ É D/7ü¶¿+$p¢ÐÏ®S±k®áçhPÜóM1o¹8CòÒ×7‹!¯Iÿ”³JìGcudĨy¹î•±jeôKœ³“—ÕªÔúÂ(Œ¾^m$¹Û)œÓ†‡äÔØÃÈÁ¹1£ü…¼(K…tëÐæAÕ7nÇö—²ÀjÔã›y)ñÍ)šú§ •|ǯ®³HdÒ‡‘½u±7ý {ñÀo:*BWÁÄ¢«ƒÌâ½qõ#FtpêƒÛ'Ùsæu1tP&VX¸Û\çA>_ÜŒ[æsʃ˜¹kFÍV”3صƒ¥+¼|΢éCg7»‹EÕÏñù°ÎŒþ¿ÉTÞL!÷ÇcQ”;­±‚û>)ÚoƒdÁºÿ¢/åFÓåØÓI~xÙ:-Jb߉,¿h]Ž³÷ÝPpXTÜä±÷a›?ûé* —•ÓñäîÞ~HèØo­ .SëKï ‘áÓ»´ÍáÄ¥…½õ<{øÅ^yÆŽlèÃgA´ê¼o}xY™m²JVvêæO7]¢¯m¹¦¦­q~7muÔùšÊiK5­ô>ì…‰e*äLµ«FÏÒ˜ì0¦|í¤�!ybAwu~ìDKDhGïê0H'+•Á^Ô¢˜¬ÈÌR¤!¯+&Þ#ez î”dì·FIMö; ÐÉ?ÏÎnÀÈÙ‹–ÛHê g“&ÅHÿÞlcd­óL©¯µè±§”Ås‰u·3a‡+>Ë纲–FKPòô¡nØ&ì‹V™}½éø'•(ˆóB’áV³<pý70±”’¿þ^¥ÉvíÆÌáÜÕm¥WÙrµ4-„æë‹9O¸<”ÝLÿ¼%�†1Ʊ0îx曼$ò¥WIÞ¸¥È“vbeÙîßs€ó¾kw(9žð­¸Þ•M9[ä2Ö뛕>ß`ø`1`Öö¡lT:ƈ³‚º+bÔ¬�IAMk’?ªhéÅw“®X’Qbô¦áŸ›ÖªO¥G»Æ¾éè y«ÓGër¿uÐ…eÔ;À«ÍèylÜŒdÛñÓð’YJëÕ7Ö^=TN-Js s~6Y0•!ËŸ˜grÛ¯¡BÍ(oh1ðQÆ*=”buƒà—l.æÅ•|Í­3ôáÈŸ½"¡*’Ϥ;ú®Â×™gÜÅqwùIÿˆÂûf-Ü™hc$¯{¨]âyb€ÛÑ%é0ÚX²Rª „͹‡ä?@«ØdI’f áê‚«Zå,,þ·g;(ë×äÿ扱‘s"µ}¦êm§þÈä¹k,˜/ãÆþ â½ÈB‘š„’>w­—¦P”ðØÄç*ó´7ie¬&Nl!ÆÝ|>"?ðlû<y}låÙÕŸ·”‚„[í¤€¦‰V9òÍ7Ðb¹Ã^¡ëî]é¹xó Nk‘7¬dÔÖá!šn¸H—rò ý…ëÄú^‚½´{†‹ å×Å`iÄ!<øvûÁ†¸Íxl&¡Yþ ±-ubûj¦‡WlÛÃË »ÐnŸ?ž¸X� 0ñ«‹$ˆÚÖÃ3ŠþœÐoèïPb/Ñè o;‹(?†É²üÉ#6bé¦ æJÑ^Yú´w[¸+Ë~ã/D«¯»WyˆEæ'ñL„‚¦Õ,Ôwþ@}bžÐ=ïðkdiâú)vòÙ§"{˜vO+‰÷œ@ 걓±˜÷¢Y\’• ʼn"XC==±’E9{Q2gÂ�OD@ÜŒ|§zC« ù$5î=¡Öô Vx³i‰§%d§¸M½Á §ÿJ‹–/wë¤äZ³i³ Ù dˆíÏŽÎ×i@È7/Äbjbšvˆ˜Å¨¹"IÀ·´“½%,äã67”ô�FZ<uŸT…cÚêyÖž4||Q²Î¶Aùx#õ0KÈœ/âó­¯·ÐàÈã±N¿…мMxQ¨nêq9'�Ùþªëõª fQ8Ä ˆ©Œ‚âóÝÁóêî;º`B±Y Dnç®>ß;38$Æ›¿àÀÝY…€H²wÊŒ§-åÈò﵈cáø›BL_õ”&$õÉë¬I—†²zÃï;#¶ Ý÷‹þÅ¡/•¦Awʃx°¶ØàMý}~Cª‹L Óœ¿V]û‚ýWê!И {ƈ0Üž´ññRü”¹rA…Äj@"bæäÌ8ÂÈP™öÒy,ƒ°ÙzDoÚv‚¥ª{V0;£‡i2‡MI¦[¸Lše¾g}üí)•\ÿßSVüÇÖšŽ*¸¦G  :�w _Æ‹¾Sé1“Xk±ý‚aSmÙ {AÞ}Þ‹`Œ»@_2 M 3¿L&a¨‚Ȥ™Àèæi8IsO€Å*@çÿ`žò Š·[¶,¯œ‰vtb”¯0êF¸q‘]M»¶þ¢D z!Ýh¼©‡.f ÊÁ)�~[£©B§Ë›Sçz=&„aÍv·É :d—w]våq³šèØ›¬µÈÕì'ÖËoøÕ!Íüq2ì›�Ä ­Í-3RYçAlÌ/Lí4 ›Õý•Ÿˆç©‚Æ"m„& ¡ó<ç7'ÀãF£¡n�<ª¤þÔ’9Nsww˜ö2V–í*òb(öSÞ|Ø*[€%ÌÉŠ {׈ÛǾ“Àªn€ázƒøÕ;²4óä¢@¤ ÎIw;ê©VWæoß´\+ª0n^ý™ÊêâØ·+�%Œpg©M÷wŒÙg _*š<tŠ— GzE¿÷j±Të vm p%Œxð [–µ„/Ó êÏš…Áf?ÒRt]‡·zÚn³ïÝ°O¿dž3Kî]+Ï®KŒsO÷)•=››F’ä~tÞYÖ"×Bˆ©™¬DÂßQ¥33ZliséD+ƒ_k¡Ä®“€€u}êî@‚ Z…•åyÊž 4Jj;\7á;Nsß}îð°Iå´%‚®Çœ’¬“Û^ë±îžQßY°‘|º»Ë™ ÷ÄØÞ0˜²âº±ÜŸ« èlS™,}LHÆ­äVøó¬0öü§*ôù×ì<=u¨O¤Žs…‹è�f»_cG{—Kð$6‚W}fœÂ¶)ÌÑ:OÃÊL88"ö,»,£Ts\=F$D¾~–?»è%;½Wž/¹΋äRu׆z@-í‘õC.Ì´ª`UD Á²Å¡§j¬ÑIXSȹëL_ZbW*y‘ÒRC±¼Lƒ |;ckgJ6ÝŠ/¬ŒÚ¤°ø|íÛ¹ë?š+¥^ï•%<»Sä«Æ#élh­w”Ÿ*Hf>65:x=•ŒÊ³ja4;JÅV+׌¥·ê}™Z3 `Æi w~õD D$°]æ ™©. *Ëž‚·§ÿy«ÖWö¿Ø=ÎèNëãüC'€ÈyŽél{פA1¨7°¤¦ÐÅÒß9£°b4é ßf7¼â—šÊßn Ì3m,[!*?NÎ|ÏÊÇÓá&SÈ ßÝÞÒÄ“ìc&7´}Xï–]+í´k˲°]M¯]íÕ¸‹r7‹²+!å†yNžÎJ¬¼™Y7Kô'*é{ YSk6cËÉy§ Z^Ý…þ»`(³XPÓš™Ë]©BÅSÏžGºÙåÙÚqƒ¦½­S_Hló©ŠjQö�·Ë¢µ­š½ˆ1°F±Ôœ³1v«v½Àì>9¿#…äeŠ„åâÎÑ_a§v}Tÿ+j•QƒÎMþAiAÁzZV’‚n(ï*³þ2ˆªÒÍ済c'åÓÅcÉJ¿ÞŒ^é™E® •Ž28ßÊ N¾Ÿþc s$ËR0ªô¬à³mUhÐ ¥ˆHÇ»Áãß±u—œ?â³Z¬WeŠpjAí àuZŽëÓøÛ(ý¡=‹ƒÃfB7´ôàósï¾ÈG¿¬.¥;U_8`³t!›HìXpé¬7^T €ëM:U|8·ÊòëFèéù¨Ùz¨ÒU{�¥âN¦ÿlà“D•oyÏÒó(j7_fû¶VäÿÍ.*x8гæÁúwÄ{9‰ ¯[ÌÈž~›�uûÛ3ÜžÛà Š¨V_ nPìÙ•Á{nn>[…6“]<åßx…ÆKtvi€+ììpò@s]{f£ QŸ?|-¹˜6DòÕÌ(öS‰š jU¬7Íyójþ*„Û<…{¥jRü¶²aF[(σh˜ÌÓÚq}y;Р윛>Ò`ª»žµéôõàÖ¡'¸FaPx;&1GòL!J¹[Wˆ¸Çø8 ES±d$zÕh›B¢n1„²F\ Dÿ!"=Ê H@ØGP¾cžæÉÊœ—:Oùg¼^ÿ”«™»Z€[>ë9‚æ±b@ý^ѧ6ÝvÙy¢Çæÿ«°;–PmrzÃ2(&‹C`©çó^[„<Gi×Cm¨…¥8§÷ÓG¤ýű( Çý¤a“Å…TÐbK¿A™æ¡/m#wVß´k†þEö}×ùXl†éAví<= A¢H ÛTÀ*ÓNÆb#*ɶ>è£,/¡¯' ¤Ü©†â~gN[%_ò7Véc£¯ô ö™v¿%ÍT¦3ÎZq7-£ŽÙCôgëzA,Mò\°ÃyióÇÆAxŒ!ãtÒz-]©!€*<À!íml·ûéVAåñŦɒI§Íƒ< ”|m¸µçúnïúú.mz?ååÂf‰ªž‘J¼ß[NêãÀ($ { ›,?d%s*“«ò«„Çq¿BÅ·-‹«.ò\€k³B(€1”W{DÆšÆs©á†x}êY¬¸e~”Cº”¹õãˆb)ä(cÞ)7[9HxÅx%Ù÷EÛCW7'â'39LY(œtrŸ#nžz]n­DÔP¤tV88Íá•Á[K °0’èo¢Â*|xÿˆ_å®ÅK´ê¥i=døy/ftX*îä[9S uZz뢙>nÚÓšä' ‡6vÍÔª!õcDt”åÆ<¯4Ýßõ HùºuïN+­±~+Ë ð÷a§IÀÙàã«ù‚ÐNI¼vŠÌ¸é2[º\ÿ,û`ÚGÓ÷.ýÂ+1 3ƒˆ©öZG‡¬ZK\Vñ¡>>74D§Bø@7ùZåMšXd|ܦ´þ=]7õ~Z/ÅH;P¹çŽþÀ1Ý· ‹ÌŒS+’@“ˆG@›ì[ÓÄIzÊIØ÷|Kô °ÙÏX7¼.Uú€)9Mm Q{qÇÆÊuE"iF¬ÖL.cëðñ °—«J)ó›ÜÅ·¥Š+Ž½Y”§­ róq0~½rºŽÌY|î„”>K8J‚ÃGÕlÁÐ`C2 IHÒW{ôj—Jz†ä¬ÎJ!¹zß:,ÈL5-¦¥µ7-X÷ÉvšÍUm‹cX¹RØãºÃéløµ@Òß‚zî–Ä©!Z­æ%Ÿfa`¯õ–ö»RÓ-ƶ?È$õ¶,®½E?(¦­5¤úx�‰ÈÀÅ:vä_ŽQ"´ãŒÇ,À*7ŸO4YƳS푪ìm¨‰XøNä¯<a–Äd·¾�^ê19EquW¼ù2fJ,mÉËñmß÷8NÇ_J*Ñ+¸’"wúäÆäež�ËØP”Gèîü„¬ ¬>´¦8-/2ˆåºáéî/1ÐL|=ôXt#Óqð%5n’‰~¯EbŽYVÆN.d`<…¦óøˆ�å­ºÐòlƒöœdw0œE¶dãÍŸyö£ëiY™6lxÛtíA:©ãüP^(J —Ýq,mû”®‹“¬YºH˜01ä—_žÄIääËØ~Õ%Alæõ•fHI(™³ðú×±MË›û°û*è”?{ĉñ8Yuâ]»BjªÍÓ'H�ëo–™jWWL÷°8ÔLoTúá‚ÞC_ÈË…3—Aþð ‹ä‡#ãs¬1Ë+П8qÌ/–ü‚àZ„óÅEM)¹%>…#zgÝÝôÞ—Jä!jÏ.õìIžSpmec³ÊßrÕšåp›E¾Ö”‹¦µÕ“¥cºë‹øO‡vÞqßÁ»º?—‚²Dè+ÃÙ ÊÞ…ë\Â,®cf¢A1T[ÛqÂ,p6S÷t™¸þSÁ½4�7,ç~ªH, r¢¡b<®ÅÒ^8µsåX ¬Áh<¶^§x%Á|èÚPôâåÂ+;B®÷:6­zÿOÖ="mÝÍ`lê+H–òôåµý`Ïùô0ÒºýÒ†*oáÜR÷ÆVyÍg5þçZ/ãU滕òˆm•äoz¯ç‰üP$÷þÌé"Ê=IŠ”SiÈã4–¾[˜Y”4?TþæK„–<ò+=*WØx|gÇ UªÝSÍÕ9zÍ2ýÿ±ë¸„‡àÔÑ7µ¿J[ÉÅdM¼Pyÿò5—7†aR”€0Û­iÒ©Ç}7ãˆQ„¦]küLâ &2A†ÄÝÅ“DÆ×öÛV‡>Ï<ò¬²:¶<"¦|/£¬WMÔSVEÃò¬òs·°•CÍÿá¡ÝSZé=’¢5¢:ÅÚS…Ps\MÊ*Oe®Ø$ýÞ•£:î\c#Ú–RÀÜŠ çj5ÊJÇKl­rš Äþ&§¾à�Ÿ™lAYí>ÍIT€¥±?ôô?Òlíg”¹çzV>Ú Õ¸Xì×[Öž4UÇ|y[×= lçÒOX¨mêÖ½šYÇ <ëEã°\ý¶RÈè±´è™>ÜæŸ7z@ܧҤg½£k,ÖwÝÄÊØ1këAªs¸ØÄ ±ßOöÈÚí{™«}G\/®{ bUe¹&lu=^ýpÜ£Õ™1a,‚ÏJÃòâ®|û ;qR'bØŮջßx¼ƒMŒ?ÿdö@t‘-Fø´“ Ï«'*NnHÇe»Û:Fp¹n÷S¬Ò …y–p¼,7µ68 ˆÑÒ™uPqÞ³Ú¿ç{ùŒøåÚnbí–0 Ö¿h}”MkÏGAQ4{Ϥê_y†ý©gqs×ß^{~G‚Ëã¤díaseŠLõo—Ê›ôÕ¯Žlíý›RÔ•cÓÖ "1m†xƒf¯?Hâ“Ðg©c2r„¥·s´V¿Ô–Ši˜M§FDÀoÊÓ*õË^FvÑí*Ì6Ýx\í{iÛäu.‚Þå3ÄN–ùù2­£sMŸ=7Ç¿D ÊÜI2ýÌQâ´y.ôvSúÞXTÝÙò<®½Çšõ­:¡Ñõ3©Dë¶É«>}™FpKü™W(úðpêþcõ3yzG½ô’IîÚ÷€yöc¬c»B:9h0?ˆ×—/™©‡ }AìœõÈÃ@‹WWÆ©zÒ̾J!¶$=ì ùå&Y¿ÉÚ³"ó" ™Ê m¿¬Ï X§Áÿ]ëÎWxîŽ<›mpZeAÚœ<‰�ÊgþÞZ\po‘6×c稚êïÜNR‹Drl¾Á£4vx£ÇYs8Š áÓ—Ž&ê}ì3R[\hªr‡á†,[w¤¨“Œ;=Á)Àòæ³LÞþØ5XË—ûa'ó$>ÔJ«UÁÄLYÌÃa!eo•›N`·ÇYpl-iyYÛD¦1ha:p­~« }.\XƒÀ:dØCõnÏðõï G£24'Zfü;*ªº6S2@I)Eã¨iVTï£?ž¼7¾ÀSÎ’ª»,­£;r¶cOÿí°6b¶µä{üï˜Z´°"¥vuTÝÅCŒtGža¸®È7–¹gLŸc¹¯j¨«v {ÄïÞвëÑ»|¬Ÿ§¹]ò"•4¹ï;O¹x½»ô<™Å0|d)ѱmFÞE÷fµV~)1äéy‚eƒµc– ]O>‘GíÚ¸hy4ðã_°—^¶ôlZ*Šï‹*ÜdTw5©Í‹¥J¦áÒq8TÏ«>c¶í0ÒiãŒìÄ \üG—?Ýãø¦ âõ+¡Û÷N`’r”õh¡K/Y.Æ>ÿ›­äÏ”SÕÁN¢ÇèŸHô×YBpòñ™fÒ–hæ³CŠÅ|ˬ9¬'(u6Š¢?¤W‹8°´ xúvø@yñÛåŒWKV,:ÌAÚÒ-& O‚±Nb•~bT{gl¸ðýdѦÐá¢"AË$ÁEÀ—^ÀîÓß<H‰lºe1/CºN¾,Xßï…wÖkŠ}ÓGË~Ú÷à­:ê.VtžbW{<Vvå™À¯üù؃)™¥6‹ãj¼/�ä®7BíÀTçšÅtq'vÇ¡½‹çÊ]¡' f:V¢Içåe�¬=¹ç<˜Öt�wFÅu~{?îz–²?kus´)y¿ï=B­³òOíûųú>huK{îôÅé¾¼p!2´õǕ̓§-8Ó© ÂvÖ”9aëN Æ¤F}±—ÛØÃlÿ`ÞÐAû9z ª¬öph›Öˆ]ÁxÙh­èLQšN‘¾`÷¤>Mš €Ò}N¶ìá , ‹B{Ù*/±I¶(¡æ€e–A䌗<OÇ×1˜K•*Ú†Üy)­~3´UiÛþ:*e�3ûËÈrQ[/.SânBcC« îUR¦FMuzUf(Ê}'S¨â›ô.Œ…Z×î ÁÏ)&~/ýï%©øå$tÎ_^0Or0|æó‘fbîpž"Ïñ“µh�M ¿L4¦V´,,õ¦î&"ûz³N²|'ÆCE,æùAÇóûÆiÄ!¥ OFæ«öâ®|®u–$ªCH:ª <éà&ä£B#JqÿEÒ‘¦Nò bæˆDå¨y c�H]Û˜oàóʵ/ª¬:&ô ãqvÙÂÚx{Ím@•À#ï])T2 }Ê=DTôP–<ÿö¬§V,zÓî7‚ÃJ «È.¥8½+³Í»¶1Jt®†îØZqü§’€vw„öT‚$`µ²J‘U þN!.&yò®0[6ØÏÎR»óBƒao¿”õº˜¨6ú4ºÞrñIÛ‚·2ãL§Ž” zyžÝò œt®EO±a$rPuPc¥‚9¸ñ-†+o¸M²á®‡.i´P¹ #°ë²$(f¥ä³vèDa!d­(Ç?nƒáÜu”ÂìïÙjehù4 rFeòø€Gâ³$2ÏS¼Ê–®—¯‹UíbÄ ™cªu`Üï^qEÖ®=5çÊn*éiçÉ•2ÅäÂʼnI3ê}Ï‚ú˜c›•Ãî'<qwƒq›J·é ísƒc›TJ†¼DñL:t6j?éµÛs^{ŸML·y<œ ’”yb¯AÖœ³¥-æ Í~³¹y¼]”ÿúÝ–b}vêÁ""#g—ýæš¡gz$”é„}Ùd}$ ÈpkI3Ço"‡'è*v[̶ ¼Ž ¯7x.NÈâ­;i…¿ì|åbG¾4Nž¤5”�¤W0ù’¿[û¥Þ®áÙ¶¨ºoÔ¸JP4aè¼> š/¼&é¾P·fDÛp,ƒr|ÃzÑ$4-½®i’;˜FÈa·…ïõf6”êÙïË“›PP‹k¼QÍ Qê­–(í¦Â³H‘VÚºwGêó¨’' %:¢g¨YǃLôZèvïëÎÃù1ö?ú"¥ �q@)ÀD™Üš·2ËËÉØ#B}Qú;[ª Ò~ëÙÓ:¹�ažð¬åÑ]wúí‘‘¡!¥ú®’.(üó¸=çÛZ ]E?F’'•7b`êÁ¸ÃmÙŽÞ�F«¬b8–<‚?ŽôuÙDŒËЩÇÌüͦ/SÞT!kZ%ßí•ŽÓ$f¦ç_`z|u&¬³y÷0{ãꩼ}Arš×碼¾‰(’°<Øž2:÷œLBqU˜l:>þê+™¸|¯èEg<<\7®ù9Ö{¨ØÓaMçÅzB¯»º=êËØÙðÐ&ו•†�ß9ΛõÜãÚ§«%ÑÕǦc™v¼v^0é="ÎYgS€ŒxïžÇN5šõMi@µÀßqR SáÍ@€´…d|ûKïo£iR š–ò¼N÷i–Ãõ8ØBÓR1$2ÜóÖÉ,�=cþ/ô.«Õd•›͹`]ñéZ¾Ï÷/}w¼ÐèÌ ³x¥™!¦¢Üi9ö®Ãó:Ø+‘¹¯¶ZQŽè"¥EÇãï³$Ó'á¥Á—½z;ï‘J×�’?ømø?•Û‘tƒîG?Æ%~bw)Eçl@d4­[¨(~ÉO÷ÆÆ©uä˜Ì”9óý#É’†ã0\¬OÊkÂièË€²È(°ÁN¹9~Ás§{ê/Û²…—žò9 ªñÓ¤Yq¥ôíizO=×ÞöâfFét¸«)ᯄ¾ÁÊgýâÍ5únÆV‹0x™I¾[0©Iy¨è”Ó]RO)\Öý‡òQÂkp„Ò Ê¢UdƒÕm„Æ"tÈZ6D2«æ5Äž;Qs68~Ñ;ZSK€5Î-ûj»ãÈoUƒüÞ >ÒÜM†C{‚ßHµ½xeµáè7íÛvO¨»Cûlª'‰ßIŽ¡Þæç×Ö°nf øöD5¬5ì¾CØ%üè,j ‰GLœ>·ljþ+µæ¨ÒíË¥¡6dÍÎä¬ý‰þ‹¨0:¾R¦JLË™á.††ý ñ!.õwmPΨRˆwþiŽÆbÍÆÞŽûôºØWï›Ü¡žÝþÞï ¶% V=ºÒê)�(pÙŠÜÕqgF´þ;·þÀÞ½«Aœ,]ß>»{ÔÐVvi8Öܸ¹¯–ñ5†çæÇWa•È åR(žrŸj½«ÏL‹Ÿ8X²’¯¨£¬Dß蹡\êI¬²âÔÒÛžÔOŽ;õþwsÝ»~R &.ÍÅY¢#XzÒB©íÚªÝeÞu¶wñ}7Ðb*Ua8ÒòJvç1Ô-¡$Ñ”Bnı]‚«Ÿ¼ŠEæÀaA»¸bð¯Á±ÀDo tÿÆô`ÓιÔæ4”ÕEEXËtÝöW³páo1Ò„„°V$nn ·™±H׉“¬ùµßAm¶ÆÜ#ìCîHUUÞdµDšÔq‹Çq?njœ×ÇzÖ|ƒGðÿîû7')ªoãÒÊÌu|Q'UO;ºÚJæÕÓ®ÅÉù^i7¶ýÝñZ.}Èi” º™N/`Úsÿ§Œy{nh>#Ä'¡‡óeÒF7A¼ŽÕsM Ó®Ž c5¾�oÏu£.ðmgÓ"‘q(¨ÊÀß{x88Ó+0Þ.Æìe¹žpƒ’8rõ"æ@Á9 âyvÐ*Î6ýõXò8¹/‹9ßÒle0¾$ªL'`EJ7~¥R‚ܘÄïÐ?o¥úKªÈ$w­[ô¬Çö!y„ò$Ÿ=é¨: ÊÁŽRÑŒ gæÃP_t< ³…›gBÙdÄVê<BubÇ‘ÍÛvúÃl2¶v½bôû!¶qFMÍh9¥k( ÿÎÄ¿ûæiyžy½¥(”YJL7VRTè»´¿N­>ƒÄ*!ÚÿÄ3×þ&FTu&¡‡¯/Àµ‰8ø„MlzÒ ¶ô<`ø¶>€g…>ÒÛJ˳ b}Dý§édpÓíW#$@¹èdÄtûÆÂÄbƒ~õÊÒŠ®ÝÌ+v‚ü¡:aâ…/Û¨€`ºy kªB8Nxîi]%§ÁaBþNÛlp›ØL»1o<Ö“we‘eÈj£œ¤˜>ºfÝ nýYZÀ*\ö¯s¤<ϼZ†¼HG¯#p–Á·+t_Ô‰‹ÜÇQ*qøÈ‚b»óâdãÏ w-kHŒýŸ Vb»Ø� JX²vãÆ‚”oD;âÇ\´Ø󖬹§u —k×­èyz7Ë#ˆ?ºVbl¹S”}É×¼×ßu¸âwÜ{€„÷úŸ—BÉÚŒ`Ñt Œ¤axž“°µ Ê—$8ÐQd10èn÷ÎÕìϨE´~Ôæ41ó5˦cÞzSáèf*)œûàҢۮʚgû^3¹Çsád×fA6¯œóü žvÃÕþíÞeÔ¹¯ùçâO%V`¥Îõ¯=/x¨ÃPœÇ>šER–6 YæþÕ¿¼ÃE¯9õÿ¸Á––¾~ å2ŒÖªæÚÄ&¬+ü-uáß�¶J¥vq E&y¥eBé©Òëho¡îñ�ÓœGNWÕpîXSø]—kÂJª=¾¹Cy.ßû©¡ç“rë-Iƒ¢¾XØOÂÔŸöâL^e#F¹OšçImêÝ¡×SËÔòÿâ;Eåt¯tç[ÛC¨Dµò§²âN´‚gØ™Ñæ†gá].È«Úœ`KOh˜g£N´Ø”JK9á l*•ô¬9§ ûªAbÙ×ë ›•üSÕ²ã çñØž' %s½´ù™Y&˜%ú>¡ñ'•CiTˆ°t5wžš ~·àËòщG†àÎ@?2µmëÈæk ¶÷ƒj:Ê”_ó‰³ûOô쇖Þï²òtÚôNû~Rå$ÊÀùXûãçäL ¡dÛ²>™Ä­9™Þ.GC×rõÚïQ­‘·¦E&7…`?k³üµP¼ÅØ»å àp<Ó»]îÿxËcŒ¢Äù¥± Ô�‹÷ßn³nGp_}Ã4*|·Î}égTŠƒs'ºT]OÅÁøîûˆ†KIÓ½:>“Fë#Úƒ¢ÖSå°1|Õï­êœ�…:LÐWJ:(ÉdLátª‘Iä¤6ݪõšy«‰1FÕÂlò´ðqw†zóc2‹jÍsÙ Ó’mÙ`àbUùnŒ0o1‹Ê¹Ð±e媧藬ÔÔ*áfG÷«¥¢u†Ùz¨¯]KÇÇõTÈ7L(Ôe‹ÚçKž÷‡áhÕw$Rü˜2i³ÔP§-…ŽÑÆï<•cÁIÖ ´Ò«[wÉÂÐÕ€VMP Zü"ëD ±å/Î@”ÆÁ±£µjP±1÷•Á‰qž½/Їœ®@ª Q€£T’A¹lÕº~⽶ÜwBc>Š1 f¤³%³°"òiÕµ e±Òfßµó ïs4bÌs¿»¢÷²9x솎ªþ+¾‘Þ ´˜ˆÉÀanp‹‘Sù8ätL ôöÈp†ÅY¿ªÛÏ|Ɖk–vžßU{‡XeÏa“{%n˜ñ¿i}DaþöÍàäG°åÒS¸eÉâõÙ™?sEÁ1th¯`½à½Kgqz ]”Ñ»æãq(¢ßÆ-pÕ†y ŽÎ宩·Õ² sc> ß\LSL>ƒ”ôÅ~æšž¹ äÀ)¸e»“›—¬Úí±ß×Z­óÃ*úBsý¡:óŒ^Û÷྾{dsä÷¶:5„‚ÕžåÁ@î7…›Í–µôU¶Üóñˆð|?æ<H[½c&]bûÇé¥@üXtÖŠ·*!ý¼¡ &íµµÕxêy#ظÔПäê÷îÆÇ·K_ò—P¸C˜4Ÿë<ç�Ám#ÇYüxçfýÿ£Ðñ•ù]’����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/data/prices-10k-random-1.tsv.gz�������������������������������������0000664�0000000�0000000�00001124440�15100345067�0024021�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������‹3‚jbprices-10k-random-1.tsv�´ýÉrãÊ’- qžB³;9ûúf`#�€IqÛüïÿ¿/÷ðˆ�ERTV}VeI(ólŠ"<¼YMeaDU•ÿ…ÿDiЕAÔœ‚( ¿ ⤠‚ÝTïëãÛ4ÖmÐC;ú²¯7Cw¥ÿEW/Ýôfþ:üO†ò®Å?aöOsùgkÞ6Oè]û®éôMÏ»ý8ó¥æ®þöþ' ù ã0Êþ é“–Á²’ º áwœêv§·ýxž» öã±›‚ãy³»tC?n>‚y?§y˜:ÿ2üO™˜wNþ‰¢Â(zûª¹˜Ïe|†÷àR÷A°§æjþ¤ßŠ9-ã ï˜òŽaüO˜þCÿýÐ%I.ÿ)½cäa4‡i³? ;úÏÞê?Ýp¦O5ž—ý½I×·óÝŸ–ëÐ͇¶ pñV-}¹z¢ß˜&™ùô *þSTqÿenÏoó¶—¥ÞÑý¡»ÝÚgJw¨íé³m7uô·A3u›žÞßn;ÒW¦'Pš'ZÒÛãKÍKTét¢/Ä·‰é|¢uÐŽõÇüÖN‡?ô•ú=ãÔ>¹Ð›‡ež•¸k9ÿ‚$ØlszÛóÞ|…ÍeZÞ†îrm[zÀÍø§›¬DúœËå°¼ëwZB˾{ûS÷ÝÛ¸}ÛõõqœvõðàoÃÿU•ñm ±ªâ,8u¸kó â* ›ƒßо»ËàSåãóùè楣§ÐíÛŒý°^St³*¬�z—m${ý*1Ý«e˜—¾»Œc+OÞ?—ú£ãÇå_Ñïy»ŽÓ‡þ‚(/䓇´jc<Žf*‚¬Ì'§¿ØöõòåÁåÐ÷ãåm7Ñ hÍÍ}·?Oó²ºn¦ñØßÛÈQ‘ºÅL·¨¤µCA¢h{o1·]=ìé×Ð;OËMŒ˜›ý‘.ßÎ'ZëØ+Ýüý÷”i&¿[ðºAsG¿«üì°´èÿ,¯åm×Ñ£ëæ·M?Ò>_ÿ¢¦ûºûJ ü£(û8(¦+ïoºU1­¦é<Ì—Ãæãm^¦®[(BÔúßµØ æEß÷X›=ž;6^¤OVmœ§>¡|ÚkôHéÝ»iºnÆñØÈ*¤ÅÛƒ¾p¡[7 ]úÀ^ ÄrWâ·u4=Ñ´YÌB¢›ÒõG~„æ–ÔÃŽ"6sXh}™ÐÔô eÍçyî¾èÝóDo -Ñ¡ò Z4¤bÓÐf¡p†Þh~ãl¦ñÒŒ‚6½eÝ·´ºzõÖ¡ ´hâà°£›²ØS1uOq¹»ÊÚ?ô¼©ÌËÔµÍth)P}_ŽQiîwɱ•îH“eûnfÁAˆ¾þýgS½¡5Bwd?MOGUsž°›¦çÕBÿ¼©í¶Õá†ÐÃ&Zw%Ey³o£Àß5òÙ7õÔ#ŠÓþÿC{�«÷yÜ.´)6Ð/™Ï[¢©Y/qdΆùHŸŸv„‰¢iŒíD[d0gc€µ ½Ï‚—ïwEßU¢AãÝšø}§¬øqÒ·¥_Õ˜5¡¯¼,Æ/ýk:\ªXBMhBM΂Ô�:h­;s6¶´“–šî° ‘M׺7[ý€˜_dzöÒ¥]ê(WH&=¶h™Ð·›ëðè™"Û…V"ß‹º5ÿïÿÌoýuXÿ`ŽGúfz†¹³,JS{æcãtæ§A¹¿Ú#Ÿ²ži¤;FO™““> ï°tm#t¥gKiçñ#¥ouýÄ=£ÿÓÀðv­iÍo(ÃXoîQ°é†eªûõ ¼û—tŽ•&z†|Ó`ÚGaµ[óŒ8z"Yë;,Uù2ô+/ØúºŽxè^ÆEïÙTôñé?Løãïñ`¶õt4A?>ºáÐ_øéð/øÆ /ƒþ°?S<³ü‹Ž‡çêŒO¯«Wt\G:ŠÓ÷wåèÑo%‡á·(wãßþƒD ØütÌ»Óòá?Ð̼H_2¤xÑ—ü2 ¡éjÊ ÿº ¥õ4pòE~ØâkšÞÓ1ÍÉÒæ|¤¸…t5Õ@’sd¥ÓyNÒ ›·�éФkk0ûT/›ý¥¾ÒYD‰ÁØ›7ßQn¼áÓƤ®wÿ–"nî2Î7(Z¥t”ź“ðË:óÛ‚é¼£°&^ê gŸ¾U†TÏlŽìÚÞÇZLU;˜[r¤ÿ=Ÿ&¯tÂÌx ÇGùêÓŸèö#ÿ’*‘Û° ²zѨ•H“нÂf;ÕÓ‡¦¬Ý)ôìÇ;»3N4PRð—ìèK&ÛÙäH è·Ñ ~£ì˜v¦ü–t„tÈŸieÓ‚_°ÓÃÄ-"ü?E1J¾‹Zs�毧îíÔãP¢øM_ÇäÁ”ÔŽËìÏ~C«rSå´Ï¥JíÙA¹LœÓŽnQÑè>ÁÙq¢MÎa> 4»º©gzWz4Íáy[àÖب•˜¨s°§%Di>½÷»]Gôô·Ó¸ãí/çßžr~ìs¼í?ãðePt_VùýÛq'Ùî·yQ¸ò õv”ȳ-@“ÁÊ.–N’„ËÔQ¸×Ê•ÂÌÅt¤ÝÈ )Šìw^gÒt�ÍùIé̵½{¬f±K62ÜŒí5ª©¶‡u„ãyârÉœNœgœFڿϯèÝãо;•mt@PêHoÖSˆ0­äŽŠ)Š¼ÌWwWSGÙðÙ+,–Ë„‚¹Ûi.ƒtÞSlBÝþouO¥ÕöT ºµþ ÷FƒvŠ DŸ‘³lvÞ:™û«f1ÍÈ;Ÿò.Ž^ • Ùô*‹ì¡P™…H‹Þ«õ�îMƒÿÎF4Z†È{o_±ÙsiPÐ.”*ÖúY ,éë,ÛfGIy= ”uA;Nšêó™E?ÏQÍ Þ˜>¥éЬ‚]O‘=;}š�¶Ùק®7M äz´’w´Æäž,Ý…êGÊI¯.¿Gù(É#ZÔòTé¼*‚™2v �)?Q¤x²Yæÿ¾Q°jŠ˜Ë‘¶ã}i:q[¿àœ÷9:ï^ñA³:,5[é¡©³?ÑöÌÞÿÕK;ŒìdÚê.Fä϶¦z>b1-«Å”±Fì†4è¾â [ô>©Þ˜ê«É4øL ÝP6<›­Ü}uxJæ¥íþHåç%Ê~¦?òéb|ŒSøŠÏ*›—ž2r>:û®£Uú½ì.ܹŽÎUt~ÍZJ&H³'ÊÞ© ´”¬7sGüËýuh¹Y­úJj̸¤LˆÊÓ´{×–œ“Ð!ÙùÁL÷];ÿZÄê+D^Åšã)ž¦2Höµ²DmV/{/ßâÅp¢÷ò¯º-Ÿ÷´:»+'F´D´ŒG­]HâC;¢xׄ*§/pÚ”)~½!ÙÁ;Qê"LÞ#yù—ÛéwT!e9¦„Ê8nŽY g³X¦šŠÖA6íM!øø6’®iù› »ˆÏ0ñ“I«'vŽoT¦Ûó©]¼$Û˜"a®MÛŸ¹#õíOJSM4yãb…ôf“6D+T–=­A]ϦÐ×ï ÖÔÔa®ÉÀ> ’¶1¡€ºu \ ˆ\¨‘hC¹ x>O½ÐâK܉‘ ÞlѶô3ÒÖ vT<ÓâãgçZR²2´w.èt®l{K#£“”ÃÜèº.¨Úœ‡ž’y=1^>Hs¯j°Ë/yPuƒyë´DR4mé;ên¹ía±¶Žú2HŠ¶çÞo÷xE¶iÆ`ççˆö—?Øœ³võÐê‘ÄŽÏkân@ž´º¬û¹¾Sùç5rá<.iž¶æy¾×ó ð¿o‘¦Æò©å 5ÝMCŒYúºß¾I’FE%qœs IiIϽF�ÚRe†Ö¦xÍa:Ò²áÖðÝËÛoS…®£¯Š8™R….¿¡¢•„ï3˜Lét»\¸!úsÌÕ±òiÖh}Öæ1Ð×ÜQJ‡öËah§3=Ÿàã0}`5â©H$¦2µHâ]ÑVrKUšV·í‡<(®ÚÃéFûÅë=îÞšóæc= 3îjô»ƒ(ôêô”{ÜK»Ú$5tßG ¹»zj»Áœv”Cðûзè)rbà]j ’¥îŽsѶ½&Aµ×î|JõøŒ–›)Ù^ÚX¶ùH_¿£{Ï´‚¤:Ãa\§ÒCw¹³w¢ÿ¤%eJöÜÄÙÝSÚE‹;–P`~CÑŸÒh¹»’/Þ¼ÜïÀf®÷…ÞGEËžŽƒÏOóÍ9Ì7õðÈ#31€VȼAG–‹E*Mi½Nwθ 4â&QIoŒŠZçB9Îúz[SF7™mB‡¦ûƒƒ‰ÄHiŽê[?ýGnq¢*Öf•òÓ‘ÂANÛ…vú_S-£™û^Jª7*!Û©ÃiQ_gÊ)²còe/芴£™C­£’ÃŽ è¶RîO7Ää¬cJÊI1;Ñ\Ã<Õ…OzÜ}·ÜièÇÚ©E.CÙb|,.ãÏÙü®4´G3}¾ÍÞ¾?zÚ\IÊ° ëM%ìΪÌ°Äx6ÜîHÞÏþr¤ÿµÍÏUæF Ï:Ú@¨äͨ’–\ÈL§úhü UPXAXú¨cè>ÉœãŠZ‚n‰$7ßv‘û•öÖöJò¤¹E„ a×a•›0p¯÷eÓÓ3B .ש[‡Æ"ö’»ï;~¡êk´¡J÷v8/o8þûV”5ºBCwmÐL=J4n§+i\`Ö´$ž]öª_ö¨€nÚÄ‘üny&œ—Í;Ú%õÅ4 1òÅ"y£OÛ\9ƒdz†‘¤ì…uað­L¨\ógd,ŸI7's×ÐÜÐ3’¶'…‰‘~šº]Sd‡î ­Ü©¡ßn^ðÉ+³ãRþäT+¸ig¾i2!ÂùV/”ì]ô� “¤VÞOEÙ'aìÛ2(kMO’@:©óõséî„”ln[ ’úáì¢rä^5iï¤2ïÝ#©üÜ{ „éÜâ8‘G«ýÛW»B¿üÑùKé´þl4µ>̦°07yõW²Ï´}}ûê5<ðqK^ =7³¤ÇƒÈ+ßæýæ^ŠšÕKDoV¸°ÏÛ]Oa?k2V`aæHoNÒ#¤ÏÙ޼ܩ±½a '×ÁŒ¸ÿ©5XlÓ<»´á~Á&<·ŠMG¸Ø7Úƒ(éam¥?jÎgùé/ûÁqÛgIJ諤­ŽSN‹?lÿö€ÿš˜Q2M=Ó‘ÔÓFî~bÈïý§ªüö-•ýÓ¸ö[¤d {ZjvàG¹Kƒm¯ëþA²¡ŒPšCÝáæáTë’¾¤S% ’åSÛ¶ià¥}“i3ò|òCŸÃSèÒ†0”)%¥<”Eu¶zÍ i c”ÀßãÔ×x:—ç ëDPz†ÿ/ƒaGçUøYë¢ÂÆÑÎmÓZùþèDI 7æ§Ew‡¢ÄăØÛ§‚úÛÁnè€O¨D©‚̖ƨ¾»£Ü[·z/#~š¿>ýé&ÍO4�¡[ŒT?Ø)Xæ½íÞòŽ>,K§¹ ÿ�O„žèH¥ÉùÐKx°'»Ý)ˆÞs©)ûé®ÞöCšrÍäì8qïÆì˜vwÁ掶?šÏ.³£lTÇÚ¶ë縠ȶ@"žÎ`5ʇ>ŽÏŠ¹)ô 5dpŽóôs”‹>_¼%­„ñO­Íç×znyê£n(]Ûì)ʽ_Í'Ř²––žÙÇô¹¹zÚN BÛ³S~;ï©‚«¢bTÍë‹¥QXDRv°¹ÅÊàŽŸâ»ŸˆÇØš›KÃÖ¼a†í�`Åê¹Q"¶÷®8ϘÆkÝã)ßÌédcÆ(œvç4(É%>JmsCó23‹ôÖØÕ–e™Ý0öå©£õ·:îÀøa[&W5IXÏw7´ùy~SÚ?a„S\Ú<H†“Ž9cžvŸMÖõ|›¨øaPïx,ð™Öñ÷Ü(­€‡ Œb §½®*võaXŸÖ>í!œ-*µï«g×îLéû~Ò1]Ä«=GÌ91¸wÓïÞ~mxæfÈ<\ò 3­* ÓM`ÒÌu¡ÙðŒé[˜ÍBS¦æ8œ(¯«-ˆ¨àaO‚¥ãûÑÍT,ÑÅá4óú3P útÒ"tÐ( ýšƒ’+Ù1Û­¦t‡©|G\]$½}°Wì3SP£ca&mïæo@N!wã¯/÷5£Ê¯nÇ‹¼ÿ½®wD7Õõ1€ì¡ˆEGäéK£õ¦Þjídè!‹_„ÏŽŠÔý-ZÜ¿=Š}Œ'…/ P1C2M7c EŒv¡t4fZµÈÆÐäPgŽ•Žë¦}ïÕ(2+]Š²YhI[E•¢w“ Rñ°¼ˆ@@ž\'£¤Ö¸g¦_‘{óTÕU|ZNTsúÀ-“²˜<L_7‡åŠŠèÑϼWÅX‚º’VMÔ¾¯[“6Cm…CU‰-çÛCðgå;— u¸9Ò¯ùÔ3©ÐmÛ`{Ž”¯˜—30b3/ÎÎ�?b›«pmJÏu³-â Ü¶§ZÓ9v¥w¤’ŠŠ6ztËLçtOu$ýeGÇeYËuÓŸ‡`¢ ³mi±]d^5í—;HcéÂcŠiiçT$aʳk‡pKçÞ•¿œJô?ð xä'¾9×£©ôµ±r8,æ±ånÛjFQc»Õ2iJ£"×þ¾´ãç® ’mmÒá=F2ç ÏÏöp-BswîÑúŸf¡Ò.nw9Ì÷[ÑQéµ<M(ƒªm5"§¨ì@èM¹øáÃôŒl¯îɌ،¯üe0 ·'J‘ÛöRÖ<h{Ê…kí(¢\©'4‰;—J¶õ¤Xµ/)}ÌÂ�n…rëŠjcÍÃŽ5Uä›Ë!ÊîÑþNÒš×­[hnçqº°ùCÇmÙ_l‹;pç³âÊΗuß/¤&éLN~Ó<Š"=ùYP%Ôä›&MÑ’”R:3I£Àù( ÝY¶¤wI¿â¶ ]’küfŠ¸ iG·Cûÿ ã½}ý>°"èÓÓ=&AÚ™åšP)îfÇôrÆøÎhh^úsÿò~ŸV·wÌ£AK=¥Zy»õ²îù< È¡°¨´K \Âuà@¸‡‹þ‰y•ÍÝLʳ£ƒ@ÙÑ-Ñ#¥<šn6\w,R¥Qy±¦ŠŠ*òOD‹© â¦ÑÀQHÉI"ïqç_šes»| m=qË…Öåf¤í\6­y´–ænøô¶§eóF¡„"›~%i•¾qEÛ½ õ¿Ý½¿¢ê«åù»†ø4u!>b´õ2P¼MzeÍ× @òT"LPÎ8“‚óæCaé÷À¿©Õ ÚõT´´¢ÍM“#1jûx;ÎíÄ]Ø =ã°×Eæ1׃œ¿È‘0µ&¼6«ŠSÉ’!½å¡ÌòiÒŒ=¥×Í8Àç1Ehß´°ÐÙê<O©§;6Ê)g€3tµ¼¡„é@ÿãG¯tžån Œ Úç³éÕý’¯ß"Úž,›“,$aB¾è*Fqö”},ºKJ´Ô›=£tzÕG™Oõýåý§H¼8„S ˜?":–gmSí€-»ê!à>©¶‘¾øAË ïŒSW€ÈÒ\mñ¨­B)êýÍ‘öXº×n{¼ÆÛŸs÷ß·Äð&ê`ÂÔ܌ȥÜàøà®t3% £—¹pXóï®s"”uØ Xí´§°_ôE¢ÑI³ÎöhC‘ûÑö\Ì€º?]k‘+/6£utŠæV‚,¥Ï‚|RTj„ÌnƲÁR–;¬¨dNPx.è®VÐ'â.”Ü›¯é»×µ©Ðct̉- r©ÏÒ_¿P¢wš§±Wü£óú3÷Þj´Ù‘›d(™Qø º‹-Ïa€ÈŸV¨Áøéh2ª‚}›e§ƒ$Æ;JYÄoÕrx}µC_`q˜•Wâ~·-îÎæi%–tߣȣ¸2£tYä=]Ö]ÝdU^™ð(Àï´¹z‰%9ô*LN²=Á¸x×ÿ¥€äÖÌâp&âw/ýoV ¦ÙË…±u@~J8v:ÓÕ;ª;6Œ÷xð«#?ÜÇŸÿ JŽ‰e:È“–Ÿ � @Ó.tŠüd�/Œ)>-W¾´›ŸÍSË"Ê >£Z³<+žòÏb3¯?hÿ\ÿ¡„Ž>¨Ÿ²hâ’fT5Áá0Lô ÊeR¨¡kh]HI:â5UÜ£h°oèy±Â_ÔA§Ø2ÑÛ¤öÔÅ19éB…¿éåíëkß™?OÝp9В𠤹—yrYÙ´töS`àÞ;ê}íPQê‹r¿ä.~£å6‘D=†K$´A4'Ìy>¦9úOÈê 3;?~$A1L¶nt_·ˆœ ¶ï;ZοÁ­»ui(eÔÕòeÛ†ÈqÎóž©ÌÞ^o¬Gÿ‰ªÔG]›Ñ É‚p×xgJ;½-ã„–ª ±º í-Š´¯v©HÈø΀Iì¨QTµÌ½õ{g"[Üq|kÎÒ/ÓAN"oɉó ÀþÃ=´Zn„ðŠ>nž{ãºR<}üZ~›DšyÿðA©ÌÀÙ¯ ó±é&]þþ8ß2ÿ÷ÐS¨é„Ëεé'¢ã‚ãAŠ|­0(££å™žBÝÓoœ¿UÃ¥;ÞðÞy°ÿ¢Ç0ýëËéÓÐa«w…Vía[Ù× W 9ú>È-×FHØ—Ùbó¯î)1<½Ã¾ëÑSsWk(fzsgtVO´yߕĦ–  i‡úhk¤¾îîip‡yZe[ú[ûŠî™.O†¨fÊÚ²÷ÞÄÞˆ™²CÇ`gs›é±ö]ƒŽ–d‚õ-�·2D·Í>¥"ø}k7†Ìêëap÷Š’JËåü?P~}“¹ä^4– �¶ï¼.ݾFËœg&¡xá©–qæ3ËQ Òº ?}ã¸ÆÞá5vZ··ðê#/Ì£„fPêLk/<YðvRwDã„‹ufõÔìXPœ S0èÌÒ•W"̨™ÇÃ1. u,$ùQ`βT™>Ò;ïA"þÔà $bª8OÈÄM¨¿—p*‚íf¥+®ÀL!éèû,‚ØâV9JtÄãeàŒ€×'GFÇ­ä±ÂŒøßаPòÔ›@1ø>¿¨:_ô¾ƒ*N)\¿¥mcn‰Ì-Ö/â=õ2C<Ç$²¯w/oC@œ_]ƒîy”yÍrоéÀˆO /H1|Û¸cvôÖG¤jÏ)¸\7ÒÕüÖ†J¼\€›73Þ¾ÑIEÊT•zrá‰Ó*ŽÊÞåmç:«\î]¢ ì² :Û¡)ò Jš6˜˜(BPªoó:Zò`ÿص^—?Ê\!ŸZŒRJÀ-î8ä>ÛQ2½ùîB›]tîD/j¯îþ^„£f¨ÓxÂÇ«‘)ÿž¬BTêƒË ·eÌ%\1mI92fo,çEÚÑçIÃ#Ïä³"XÝÒ­¢ÒãA,ÂÐRmk$²žÛ3+öë‰ct…Ê£-—´’§$ß(‰Ý ›×•o8;õì¯xÚþ1F§Øª‘aêëã8s9€OÎEP ÚšÞ%‘R£Ä“éúÉÿÌ…O 8É8ÿûomUžR–½Î{Â3Õà6n&í^{üX ³ç¥‘ápÂã;š#Œ\ÒãÔP égÓBÚœ—¾žg'P`v-Û*eÍ&¤Û³ý·(îÈmOYôí@5]o;ÛLE)è1EÅàþZéý”^!-ÿSŸ¹mž€aç6Sžú«Ô¯:r{üè;'&x¬IÊëwÇî§ ¥:mºÝ®–nðïÈ“qä£Ì7š¯%w‚Ô©”è¹AÆI;p%BiiÏý@¹« 5D ™Ò>*ÍAœj×vpD‡fœ>í¿Ü`þ|hʼ*¸”A^+äO è#͇q0u�=—Ÿð75�ÅËYUm45º�¸;…ÚJ7ÃãlÍݧ…Ø@^zbÔd£ÐxðJJžy(Š£=äfåDEVŠAZãÒÛ—{Œ&×ÌŽ 9ýc¡[¶®r¡/=tº¶((i3õ PQ…‡¬ó.Ý&Š7`cæ+#©¤7në;ûšÆVqw Œ÷0Œ‘ßÃÔ¨*‚´?968Ö`7)ÂiêÚö@üÎÅ·\ ôHóhŤﭕži„˜ZKüíâÈ<ÐSÉ“¢™>ü»¦ZEÅâQJ/oþøü…T7)=F/ó'»<ˆw;÷0M³…·ç˲$eâOàƒë);¸Ø <—×]͸;-˜Æaqu=.óeìï>Ôh„åÁì¼ã@fJºUEÌ_‚ª–I˜ù¿Ö…¥_îRÐÜL`Ì*ä'‰M;À½NTBB¼RªR«m,ã™ à”õÐíïµ ¥©2ä~Í—ºåȵÜ\óïóúý«Ö©ùϹ@áhé­ºÖÁ.çÃiqóS7ÐJ¥3Çhc@Þé{çªÌø…ÁnÿÚ>‰*í¸7ú;Õ´8ôKQzº Ü$ÃìÚ�íÚæzvÁNm˜˜’!g[œH§É Û¡CAo„ÙåÆŠý•¦Œ¦ˆ¥"wM4ˆ/,eÆ2Ü Ó\€Â(rsU¢7ã¬f`n¯ðÑM¢Ø¹Yn�yÍ\R-ç gxCâ¿�åD¾N�k¿´{º³µ~ð§(( Õ0]Çö<qÍ1žz»»?ùsD.6(žã£''…·Ocôžr N)…óPNç—i°‘ˆgØhÓ™Y··C­ šõñ†5íõ•íÿÄ¿z„°ìGN|Y­ Nƒ¸þ2­µŒî[Mß°í,Ö—PÓ×ÿÒ»Q˜0C¡`Ñ­d rs—`@sëæ—ƒ¸äÛÿ�®%ž†çÓ§¾ ¦õ¯Ì¬ê hõ}w•œ ›[Þëž D¤˜Œ/6 %,G1q hye0EÀÆ°¢Å´K!#§ï–fô J63¥XâtþÎ ’™ßjŒJËè&\lèŠ *6·ž0¡ `Ú®¯)‰ùM{ÖÍý£r";Z.¦¬Y†>výÑ9Á@%Ý»ºmÊÆaaûð" CÅ,’³m±ñÁKAìGôrúÐÿXLú#úlÑ|:lœÞÄæÜ÷£,4”À²t!DU‘­ÉƒÝ@\õ~²° $IcËMvyÇýضÝÌ„½z†ÏZ!xhul¶)gmÐ~ÃnÞPÖXc+e”‚ Žˆ`˜‰”¿úáUÌ^Rde©`àzèÀ ƒ|Ù{‰OÝŸöµ•œú!/°ú3u¶™èKÞ5ªA6Óö{ .='9@êñð�a™/}ÿƒ´ŸÞ‚¢þÕ}‹L¦ôó›! ’ZwA"êw”^[ä ¨×n²VÀ¶öã2ÝüƤ`•9 0œÃD(ÙÛs(sͬ ÍÓOêœqa:"•éì¿RÊstÉmŲû+÷[ØóJ;ÛBÆb!uÓù¶¯‚äý_˸â&.S Q\ÉÿoæÍ%­¯3pþ¥ÈZì®ÞaE46:>æcf¦…s@÷ÌÑžO*Jø˸xº3?¤`Q¶‰>ÎA³÷ÆÍJ˜TÉ8e¹‘wbsQ<@‘>º}4ëI-X"#eë½U ‰¥É©Y.•ÿšêß¿tPàÜéO&,7sƒ|;(Â;’-’ð9÷SwñšGr»©WܱRífOa+k-43¢6×/¢õ„†šîâÎ'*üÆæßsíÞkkÖÓîª9ºc»£‹37Ò¤¥*oSOR 2Óíî_úС &à8´X>­B”Ýf v':áý?ùM;¦»Ö@¾ÈPÖv8Ñ›ïŠúDGü:kF”�_YLàÈ[ƒ:¤ oŠVRÊfp¬†|½ÚcÚ6ií/(¢º `@g»GÊMiµÒ"ÌèÃBSWIºE.)ЛùXˆ=›i}¦¼èú‹R“ãF•ÊQÍÒ*ƒõHz n‡¿ÆªŠÂUœ>cFQ|Õúè.Z¬gS±ð¹Fïj ìp’^¹!]r{aRþ]’³ #¥;§#µùóL/¯·’(\Õ.I€¤"z×Ó±—RÖ4„«R5Bœ¼­CÎÿ¥°X±ØdŸË³  „{•/ìðŠž]åSp>9Eçj:OcpW¤,ñ¤y™2ŽÙGh‰÷^jô¸_™ð0 ¢]Gq:ÒÆŸÏ^t/]9»^¨Ú᛾. ‡ì·w‰hVŒ5/´(cÆF!’CøU4Úže‡Ié5y2Üìi{w*aôHKiÌA•Â„Ya Äûêê hé#a0ÿ‡Äi»ø¨Ä³;~#mZ:Ñx8û¼š†z¹ö©³Õ­k{àß™Ž2-KïÖ€÷uò†ÚÇzw:tvxiŽÂïG!~ È¡m^Ò¦´c 4š!aÎ[ú×ùWԾȟ2 âÜ Ž­õvç,ª…¥g 8.Ï_f£Û 4wÍ＃ -BòKKñBxc§¥I=t77öáŒÙÂ÷÷ =ÍxŽ¶:z‹ãb£´†•‚ø8ô¬|mÆã”SnŒÐñw¹è) Jï©ëµëŠx"Í{Ÿµ­¸¾ïßCæn ÎÃÔ ÝóE…SŒâ}K¬Ù0N(zÕ£ÓÆþ‡Çðj•zë6^ÁÍ( =±� bG²Hª<àà<% Š`,¡vûêõxåÄ£¨ÛÏè«}~ê¾D÷€.X²­Œž5½#–·È<aŽhz·^°`õ×!àúlžß¨Ü#Áq*pþ‘Ñ3°â˜¯‡­NqXlr'ÝIZ=ü”%?ù>jO×eUfܲüÔ2# be ü¹c™yÒ}"ùÌRÓVÎ'ÂGI_gZ îýôØŽ!¾‘ÿ¥Å¶F–çÇ/€ìÌ êÞNz¶§23pàÁ‘økÐþNVÿ¦ ‚ó Ša¼XÂKìMŽ’�ĦýÛó¿ñûÑ•Ñ°¾ŽÛ¢úêI X� Û•Æ'õþ %¨s#][A¦ ÂæË2Ö„g-­:*ówÀ_ Ô÷l{°Ê\~ÅL§^ø¾³]ún8êk{aéâ3=Ù§ÃE;Þµ°üy ëë_YÛ_ÌA¥ çifc Ÿíºp ÃÀÕô81V„I&å0yùëÓƒH2£ÏâßP—+ãÅfArM»ÕœÜPó€]ä‡Ò©æ’+r \ ‘ñ»¾³­–V]h€Æ™R0Z3FyÅd¾•ñÔ&qfäy†ûÛ½дÖßÏíì5,0B®¢*xËÈsã•g«)oˆ‚+¤©™(eÉSÍ·‡‰iHðÎ¥/hd??‡Â© ¢k—ÒBIirºúYÜô‹,Üùf† T™–ÿûÖµÇ3¶Èýj..=ëËl.´N¡áhE˜:Z ̵áJϦ©ñ©õbƒâ›Q ž�CéÑ¥y°>ì ‘µµ°túBÇð+Èí]ߤ™x‹n îüCÙ—¡§Ê{€bL|Rd<St uŸ<‘ät'sœfÄš»${wôKˆØ{™':ZûM“ ZcmÇÉ{Ü”ã ÔšÊQê8¡N]&AGêÃѬ£%ß3É�%´(ßëþu3>@f›Á,—ñ ½;ZT6AðÍ CÍ?¬§£_³?h±ä§‹¹!Q«fׇ‡Ÿ:Ö› Hã¿ôèoõX4BdL;6GÚ´i­ó¸Þ˜fÇ_¬ž³z±])ÛõMxîèÙų gtºÓìénÒá'œê*¼I×=½UoGò±þèLHþC¸~°ÃmMƒŒ!ãÜô~yh ¼cŸÛuˆ=WFë¦-m×{H²¿ Þ&¡+²EÔh‚J˜‚b�²<1“Rl3ŒßèOÓQ¤Ú\d¶U/³å¶þMì`}‡~æ¤Èèp1ÁɯC›dßûÉ⊠˜êf½Ã™`¶@7ú*ÞLëüý0+°÷Ž¬»:sH°/‚}‚­¾1”I7ËlúEÄ"ƒ¤Ë)6,ÜXÒܸ ´lEÖ]Êc|n –æd³çjôPÛÞ´ãÈ œO#¾v^U€<eõ!¡A»îrmñ'ÎþJºèl/m;ñªT³Ï¸¶ÐÌ'¬�ÃÛ‰g»ÃÏ–CŽ˜Ú97|†ÚÜúªà&ÊÉ ¾¬ŸêCœCšÔ´~z~ãY»4HTY´pw®Ágf2¦À[¸øý¿ËžÄy‘fN9ø+¬vTaU3[/Tdg¤ŠŽq{ 4ÈÔ´í¹µ¶+÷”€Ñt™+sŠ} +êódg#®<¹9P#îÉç]ÿþ§2ts&OàLN)*§/×q£µr‚¤™•@c»nºCw”NPÉ]w8!Žñ,¶!t�v(\Õ;)Ï@¤üz£3 ÁœnŒ/*#?K uØÍwï|^øjhääSïYìÏ»•hÏ0“Ê5[4ˆàI*U|ºW(…:<©¤¸Ó¯)•:Kš5½WÛªNÄ\v ³%ƒ­NŽu¿0Ê}Ћ¶F}§zø’Dç)P]ÃLÕFYSWPâ°³ êL¥óu}Ï™æ>0öÛsÈ<¹™JÈJU,“É@sv~-:Øÿ¿Ž°ôà.å±õ¤ÄP¢ €[6z²@*QŸ‰§ß; ¡Î+ÂSw!n6ç7Ãœ‹Usc7âÞåó˜Î›ÇŽ&$ÝîË0; _‹ýôÇØh@"ú¦Ø°ônQ,Ž)™¦çcñ¬³PÖ•Kœ½K=+Ÿÿ•aX¬zâ´i êkO$£³– ²ÊÆa‘ ×=MÛŸ"¬¤œŽ8£$�n{ï~l\XÌ€›J+Iò¼—'­6µj¶:²íÖ:=´LÔ¹˜Âª"}·¾7ݽåd1�¦]jÐ}I{½À‡O̪°éN”­š1Lxv›)yO¨q•²úÁ¢ØüKl?ꂉ÷™a§Æo@!ZÈ„¡²*@|:|Ii,¯·Ê¸Yì]­Ð^« ¼^uƒ)[憟(‘™tòã)•ñ¨3Æ!Âèf ,FþÖjöÄ™ý?ç%c1ˆ‰býÙ¶±¶tÄ}@_›ÛÑ7˜•‡Ø•2Î#-§Øª¯©œ*ÞO7Ëq¼)ô?H‰ÿcœïóÐd,*¼Ã\ä;TU;À2èNLƒc-Êx ¡aì)¼•V2ˤ‡=•Ymm"Ùù³wlƒW5Ûµ²•i ŒqÐHK-ú€…m'vkŠ%ô:h¯\ûíºÊèà¦"È÷ƒ3@’²›%èDAd³¥O}]‹k¯½¡bO1Þ“ÊÚg˜÷ΊܾD³‰œ¡Ñb*ƒìȬ󤶮Êmseú@eÀûõöÕŒ M¯ŒÇ~›-Ëzž=žåz˜ë­Y°JûŸž¡b¼¸¹äÛäF>­žq MM§Hä<’sÌVψî^©Â;ôÏÔ¹RÇý�/¶À<‚¢Ê²sRlsW󌸽¥Ù†I-/xhû[5¿DrsÊåw£•º3%W) xÖšã7pá4ux-Nk§=}ÂFÛÆwZÂ+mwŠkkž©kyHóæÚ•2,Ç4 ’ÝÉé7L(£0ùc%1Àô=Ý"Vr£¤¸>›ÐÁã«•Iï¾n/&â=í¾DâªÈ9Vì){ï¤gßu¥h3·Oezž5¥"ÏQWmVPGäÝÖSÒ3±÷ü\l {~å)nF¥é±Ã+¦ßÙ–ðð,ŇÈcº¿uŠ±$A¬JM7ºSˆ!Ø ÙóZøöv°ÍŠ^P²üQ/'ÎUS¬0R‡ãWdíÎÀÍЀ،ã dƒ@±B‡ƒÌÀoþÁ!Ö©›§Ç}¾ëµbÅ3£;þµ�F¼Ò›¯Œ7˜ÁJdôáò<ˆ?µ@Dã3N éWšÞ –É,9×È^*Ò’”¡˜á ™rçÑ¿¨h’UŠƒyf{ëût%oÃN!/8bqƒþé»öt§¿ÿÅ=sŽ(Õq*WV¨p'ª¬j«úQ5Ú=zÔ\Á@qåGÙG!Ò¹a3c`»?»(Ó@œjvJí¿gX@³ÍŽ„ óŸÓ¯<yp~}7Ü‹1»Xüv…Ó­WO<È“ÏKô'Höê7@êÔßQðí:çûæO/ùÓȉ+ ð‚~g½5ù†Ù!•› 4ÑîZ1=’ú*Ạ̃؆má诿œJsîÁtRI¦|¿½×¿YèoyÒø}ÿä•t¡EZ¥µ†ŽŒÖ¬ô>pl$a—×JË‘•a> )LÚËÆvŸäƒÈyõ_< ÿ5c˹…šCþŒhZ£›Jϱ%æIl^ÿpÕ>"Kk˜^?ŸiëÇñx PxÍ7tñ`=ž¶Š9ç‚ …ÝË>)(¢®Ã¯‡ë‘ÈŽ¨<HÈ>?4£iïæ½ÚDP¨±X¦{Î8²?æØsL@£ØUµ[OC¹§cÆëilÆÉ<¸×¢Ö¥#äÒ ~÷å‚Ñ#FÝJ¥9hüÓÐÉ÷„¬ÌiAN±~à<S�æ_Fà`öKÃܼ~sŒñ]J™Ü¼ÙRªï4ÞŠ¡=R„BåÅÕ¥çËå�Û—÷qâ-¢8.5¾ÿ·*…¯GUflá”Z*$¤lP0k˦ÇÆMeè,jx]Ò)ñ¾ós i=©ã†¸¨HƒO4½ nzý²ÖRIV^HÞ ǵ ¥2?ûñüB÷ÂÝ¥‘ßÿFý„G¤•'§Õx0qV› ÆMã—È™¬ý�þùG70ÒO³ØRsöÔŒK˜].Z®@@уã±�Ø/K-2Ft+é /8HË“µ×ÍUœœexvg듳ºþ ÚÜ´¹q;ìÐ`pªc&;à»4«'™8>Þ¼Š‚A½œÝwTGRd¾Ö@ŒkÖ9$%›ë]ßÁGÂ(ñ”8™¨�!Îü:X9–ÀGæÀùë£ÎØšZTfßÀ¡ê&‡õ¤ÿé…Ó©͈õÞ°*Ío<+ûš–άH<ž6,Šå¼âß»²AÉu Øg“ (ë)q‹©†¼ƒ¦gñ<0›�OrUH¤w½à4Àqÿ¶hÀø?HŸa¾+ã‚u’»«þà–ó}ÀS”d’Ö ×o·=<‹Prß®Ï)—T¶2ðÖo>`,!áGõ‚0÷Õ €]¦“±ÜùâH›©¾l=] ßC~RÏ‘‰5ÂÑ9­: ¨i®ÝR–Ԧ΃^©I"bW6[îgþ]Êd ²ÞÌq»¾Ïs¢¸È|NtJ_6óæ^iÂÝ ³i xQ;÷÷®þáEõ jßô¬¯¬ôÙáˆ2¥Aú¯LEbôf¦ŽÂí|-Ñu�c§¦N‚%zN‡†rÈõêO²•v"íÑÉÎåòÔºñ¦´|ÄñDڈЀœUH›žxçãz¢ÜáÑ#ÜJ¢ó kT¨,´ti•yïU´^Ä%UÎ< á3k¦,ªþTîs0FÜ àZjƒíU0J9ßnzîÝ©ØXÛBÔ¹U©Óvòt†zÐ5Í…s£Ýw~Û]±¯ò›š3˜¶Î(Kƒíû}'Ù‡ä6˺’€›Ðn¦ÙÚr’Õ¤Àl™ÝãvûýKgòª©«Q§2ŽÞóôÉ2U!Å1\¬2ÂsÁâÈ׆¥¥¦?JgöÅt‘éx�tÙنžt\wõ¸Ó'U‘e· €?ü›Ô%ÍÌ;§ÄƒZÄ 32 ŽšmVEæ³>¯‰˜(™³‘å® b²ñÄ6”Æ;ÿ¥{£Å»—ýP:D0[6ô)=©1‚Hˆ-Ú›ò˜· …P‘Ú9Oó†sžq:ÎÜÅÆyâ‡õ)™�EmD¾q¡}\¬}heð°¢quWfãµv]š­4%¡¡L9C­¤*�±DóÁˆV²¨˜Ãà52N’:ä!gÕ›?´³ýâ:ü]=õJtúEZºðÇO†îÑ»bjœU4³C¬BßS#÷ x¤ç9ÊûÉ OðdÔÊ ŸˆòN'I)Y GoÇÒ•ãpQ3eÉ•%5‚X;‹‰”ŠlNtZñν‰Ïéû£ÅìêåUYjE`Ü€fËZ·³~çª.oeæ ¬êß4´Bg3c{{ΰ=å}>¸•b^×ë<W-ÕJA •ÏCcÑŒ÷Á{60Zƒ7z>Ïó¿¼È<ð.ÝŸ–“½vK8I…mÒ¦ÿÕ¼wm—ä[ÜÃ!œé~Ù³}¬?pOæÿ¾™®“<”¥æ8#NM £n &²Û¯Îùʯë`²3ÓÚ) È,çO=AÜV@îb¤SØ÷;*œâ€IxúÔgDZª÷ã¨OÔJ€üJ‰.±yœ@„3 @ÕîVÇ|P4†Œyj ¼~ÒZÌ<ÿGF–°üqÿé r×»¶žfO÷ød'ÙÆô ;gì$,Òw‡ðú�Üx&éësq»¤Jó²*”[d΄œ¥7~ã­Y#ÈÀÑü€(,Ò ž ùy8,³¡¾¨úøü¸7yf>¯ßµYÎÂÆ‘/¹Ò1Ýȹ"Rd=£ïòù®´œAá{PµtÕ+:ûemÊøx~¸ïÚÁXuQ28 -d^wÀ7©Ï0v ŸFpÉÞ=ÓÑIŒØ=XÙO…Û×U%Ï|˜~XHëòÜ[í¡n£Mx ’RC‘˜¡ô¿ocš±…gõsiøÞylVŠV6S‚ô:\~yìšhM‰¢Èè—œú¸rGpâI#!Úa_ššû¡9ÊŠ•¬a†IkïU…�^AÍu²B û®?šGz÷Ò]U 4ÊMc袼;yŒ2Zé”v­f—c+ŠÔÌ[Aãô ‡‰V¨;D\‚7&·›jéÈpêZOón~t%m‘úWºMMK{½hO®·bL]y¶”±vý‘ï›d7k…>yD­?±äo3{ê•ÍyØ¡÷+/ß L×í òã:B­ò½vwcê6ËhõÚŠÆNy:FÑÚA7‡î¸ûÌÿAÂÉ«¾è_n±!lã¼ëõÕ�àUð&Єøÿï(‹þžÙ_”$¡ð"¦‰çuïQs…*íj«Ï+§Ò/HãQQø$P€N´ÚýY̲œ¸ÎKØ@WT ðZÊj«Nm$E q§zflðÑ)¿õfÅ‘g4Íb‹Cä!ªèíŸ7J3€f¼RäB•­ :ÖIkçÚèëôg7æýÕiM%‡‡ElKÇŒ­ŒóšÈ4¨MržÌ—djþÏaøÇöBž4E;TûRË@Q ¦¶Û:ÑN¢coóöq˜)S…A¼+€¾šô1ó¹¿&§:/kk¯«Îâ!vÀT›äôzY6¯C?’{v©‚jZ\µ„ü¼µD ­)Qzßg¤kºrLGa¤§éS�üâ,Âó9íVÀQä8aµ¥cͳIœ/LïµÓ•xócD‰’6èD €?W”;µšŒ*!*ÁTÈÜnžMó 8ÞXâÝýþÍ­3]ê÷‹b†=äA:÷^W ø†,ŽÜ‹œÈí…†š2\‘X"�ŠËVN:÷Äì ­ût "rzŒ V«2 ^p8ÓçZZ«±›”|Ó8‹ØòíŸ^4kðb̽&ë βÍhÅýg<™':GUžyzrtû.uT[m”D¡©o½íw9 ÃCkË´<õ³Å™§ J‘“i£ñ¶õT†à<,­Ö|5OCµ¬Ñ‡ÔÈ,¬ÔŸAæ=ý9cI“_$Ay4M²³èšÁS`†—,ýBtzÖOOÓÐg¨Âðm ~j<§ðD‰ ©Oiô7ÍH©ý©»Ì¬Ðú­¿ÄáÊ08 š¾ ˜}2·ÊC{Êf‹ ™A•z¡þ \ÃÄív>.a³¬dk¢ß´j}ƒ…ïWw£ifUéÈÙë)äÁ¶–$Ã0(¶mûŽÕ{—äID•›-š!ÆK_ÞÌòM3Q‡ð©zqß=õÎ.æ¦ôN®'/oF[AFE÷t×+°ùîJ"tŽœ$´€ƒëž‚?ò™âý"‰c_ì*œ‹Ñ~ñ*¼íÔaêæºÉwÆß•…'Ba¢�f>ù¢g‚ü–“í/-V3„çFr¨Jj¶žý‡;¬ ‹müÍ­[=t¨q-TÝ•6³N¥ÿò§sÀÌîCþXÕ¦o0À••ñmüä�p)+Å¡Ó7æ4eáŒîÒYS-:úöwrÛÈ™q‰hò hfS½\' s»–×-CsÀS™ò…ŽÆSïí©o �Ú q¡a/¤gŠ~N!J»‚ã=¾ÐÒé"Œkp�YØ#oßzàÖ»bRXXð‰·%u˜ø]c(|³)æN1øóEN¯%˜cõx|Þ§¶˜…aéíeHª Ù+IÓá HêÂú6¿§é¾!'4üÍ ¼¡)×yELû<­Ç ‡Æv[Æ1£$™Øeû7`»õfÞÈ󕻊ýN~Ç€�×OU­W…_ÄàÚRöÄÄ€Ùƒ<«y¢|ZºvrÊ hw¥Í—ãS{ÚÍ­ðxϘ èî8ôFã4 mÁÌÔ %#¢•²ÏNçŅ˾^n0ºÓyÞ›ü=À%…OÙƒŸCXªx˜M·:JOƒè¤Þ‚¶ ËàÂìÔè›Ë{®òœ°Å¶DC!¨°l¹ðK 2최dnö#Þ¿iU;9Õ_çÝMÿ¹.èÄT†¾%ží1Çø~È’›Õð= ÚÑT>Ónª¼ïÌC°¹Œx[o2Ùãê@gÜ.xñ„,œêž¾¾|{d‘§¾Çâ½LY‹¡X~v_ž6Æ©ë•ê=Á!òWºhUè éyÆ8(O‹íÓS{ï¦?‡Ù§ìTŒžãlšìw/=dÆO2¿‡nòûä<.xËå¨0H2¦€0*A¡ –¼îOeò"»A*Á˜2Þ÷>‡¶¡3£ê0ÿlMI_Õ¡òŒÊÙñ$æ) N¶÷zvc•*à ›»+MpÌëž?>Ñ)ŠÊ•E¸ï"$´¯=ò÷Žk–ÝÞ.¿ÓrçFÅÞK}³$”Iàëáº;„ªgëù"éٙęÆà…r¾¶µ¯¾$§XhÀΕGÚ6®%o!‹$˜YñY¨}Ì7¼÷7?Õ¸*G Å;Ý©À ² ã·“AËÍ'ª£ßRWeͬ¤Ï\N0ÚZ}·Ìߧ •'ìÄ¢6û3eà¶=•�KG·ùL™ IŠŽŸFçÞ!ì?̈Lȸ?ý <–™SÝù˜ißX™Õ}â4ÊÑÖ68T¤ú|¤q%•E¤°ÑwT-“kKšYŸeù óôGŠN\®äðÎidF¤?f¶ëO{ˆÿ®@IÒ¢O`¸cÚ¸¸!¹›SfŸOò½_R-IJŸÍÇ|ºë{•ñŠ˜ Œà¯ú tò5­¨Ï3m¢¶“‘Ñ–²s€{—¨@CŸŠ‡a.+]|]=“).Õ­‚ƒZÿ]\»’‚…`Ù¬8«öc»“²9Ðj>ÌßœïØ«N`á#Ôe.ƒ|ÿ¯#Jh]f:Œv‡š1í`Ï1ûz+©®üUc6\¦ou\6›á1sq ß8~˜bè)¯ÆÊcÅ&x]¶ÉSE™"¬ŠLó4ÅZLàºÐ\‹,U:R±?Ðe³ÞºØ”È¥%¿7Áñ÷lÙÐ3äb辦ÛR>º f¢—z_ÌëÚÝ,2}}د ç!R1¶fýâ½êÍP~ ÓvSãaT³£ßë–ÒâæÏï†Ö<ƘɅÁ´+ƒb¯e/l®Q–©ûƒŠÌƒe'CImÈþ8œôŒvYmcìéîU“Ž ÒŒ'ž­€ý-Ùi³g™ýï÷EœâÐPD²‹PNÙ6x<�tT© §ûGôŸ,Í ­æái Ž½Osõˆ–ìüz´–¦(e ׿|¨ìäè*Ól‡/Vì°²§™eÿ{?¬8É}õQqö££ç´õ�Eõ‡-Vååç1Œd0L%~dïûU?XA·jNÚw›½@·ükœJ=ä¾{ïk}Ž’âkäçÎgNj€5_ä•x9¶zTšDŸoÜYxA$@o(6pÚÚa¿òhU¨O´¹`ļ-©ZíTh­÷å:¼]‘CmØh¡Òà2±hÎ KôúàÒëF²y×ÓfN–Åûè=É'41ƒáJÏNѵTÊJ¨z 1oÃ]Ó�l¢ˆ^ö™êúFÛ+õfc4RüËýu�¶å¦vˆ3o$Ä„¨KKÕ`Þ(Þª¨aEåÂY½áä1ù$’ÛÍ~iöa¢ßz¬7pÜú[NM¼L}]Ç„Åöb´´­!üÁ1’"ˆt´"®3ž6…9ûýq#Í|¡Ù^ˆ-²Åþ°6ûqì=åžÍ.a¼KFÐÍÃf0Cæ¹ Q¨3ÊQöi¶7ÕÝ2Nºfúôª|T”¦4Ä;mì©‚X•Q„0w74W„wÏPHÆò¡°†¦„y¹ßÒ­ÏÍ­˜Þ)¤«öZ7Ëtf¾.OgpÊY–ý,¦()²õĤº1ÛÎåEHƒ9<pi")½±½›³2½óW¾Ö¿ªíl.e 6+à†j,†ÍAoÆÉ×_²·‹•hoÔiäuë5Å=ü˜9Ÿ)V¼c@*¢A òr@öDÉN§ˆ/u€ó5%˜_hm9yÇŒœÃ´òÚ_ÛND� ÿoèÉ«‰í”ͬ*ÖV6²ç°â;úOTⵇíöá«/ýSjò´£:ƪîŠk3w7Ý–äÅB[Ò³ïZ9p‘Ú2B™%}?ûQ`èjðmCñTŸ¥J}Ö}ëSG;ú´ú®<.ÀÓ³)øT1LüMKËÊó‰>}øñ+ ÒÅöÍ­œãË$‚Ðx„"l-[”Y,é™M|™†Þ<„–êÇB$,U©v¾Ôƒhè™Kw^w¯Y©Y«t›Ã$ØŸ¸ ¶ª ;¿t0,dta��­Œí•á|S8K ŸþJY!Ë¿¶^an€W`ÿÄ ¹—ýe©[Ÿ¬"³9R wZL  ´gHZ<ù=A“Èw•\v”½ä­ ¤žÆy±N¼£ª=Ÿ¦s»å4à¼ý›Z”y²\·õ5P‹íà(72Ø_jôpÍ ¥£½Ë‡"Pqª~~²á燱ñ§Œ^„ K sz¸óO¯ŒbKO;VŠòáBYÞ¢c^uO'zˆßäRhë�£ô=^•pÍì¾=Ì>¬’[.'½/@±“»ï®žù”y<¼Aâ\‹/öHK®k³_/ų4Î|7vU™Tr kŽBíÞÜâßÀãÄ&L6$ ¹áxLÿ팹oÄ{ŠÔºÍÿ§cé%Ù<Í ÌÖ?ÖWHñÿ÷­(QæðÊsŸ¿Í,«äÆN¥¹E¥£ê§pÀÍšÿ¾¥j< |ƒ^ŒÒ˜cUj‹*C·‰Äë!n¾¼Ž+Xi‡y[û ¿syÈ<[ ØÍ”öÍïšöLÒãQ¬µ§LH7öê>ƒ=q¼VƒªQ…'^<~0$I«Xn¨ßîâÒõ—+Ü<ônêŠ4‹W<ŸHÀdE£Ñ’f‹È*ÚÜá9šì3£ÀiÁ­TçqK¬RQSÓÁ59¾,níÇ@úÓÜÂtuûJõ*tZø|Åb~k1*•a:ƒ•ëìæ~v™÷õbF)îéÎEÓVù4ç «ÔG6õеv9™ëä.DUräf–yñ¬X±^4² ÚkRXß+S”»¦“ Ãv,½Wà¨Üœh`%œ'щaSp| KÆ«¶šQœF#õ¼Êî-AVˆ'E¯8(­)$¥%íäå^”ß-}•R•²¿VÞð›êþØ_@K…‰^¹c¹å5ãýkc0Eõ²y£gQmþУ.†«ÞyÌ8ú–qÚɯ/‚å<ï¨2’?oÖ|ûrrt:zte†Îs¬=‚Ênc¥§ñ@O`,<n—ã$!l "!å³”»¶ÎZ´Ã4nìØfeæÉE¡)Ü–l+yUùˆÔZ#�)Õ¤‡GI͉ÞôÜ¢é)‘çq ̆ÑÒXopÊ'[6Q¨ûsØpmî&ÿ;(Ën nöST­¢w!u¶ãz%.=å3EÎø¸2¬²yGw?{$©MnúŠÝ±µIçåÀÃÄf﹞¢Âì¹#Žÿ…IbDˬp]JÖ:~ÀkxXÔV„[­ fÕ”ÊbD7ãðy†$ácïe‡ø+8g+‚~ ”ðsëXœGªŸ|Un_¿w2Î92‰…µ…11¸× <¼Ç3Äý»˜•žýwÊ]щ~t& ^2^ƒ!Y¯š"§ s©øe[ñ»ÆëÈiÿ+\‘?XD¬ç¼¥CgyJx(œ†}Æô±wª|…FÉ©kÕáÑÓ¼ÅûúŠ‹Ù?,KþŠÅ4r@fÎ,Ùlq|ûÑ0z0¡S~ü¢ÝmÿÕ_€|ŸùhÒj¥(j4_ŸŠF²YU ª/AXé¼.…%UµW°”Üœ[ðûJ!QÔF&z·üÜzI0N÷7P0B§Ù}Pèg1ž¦DlüÏr'¿3f¬‚ј=)t"«¤•aà’cà=m/nG¥ÚDÜ ¤Úzté.ªù[±{iqø ç«üq7›õ­Ê,­¦ad?yúyJä7oi]_°?Ή©ŽÌ .¬sK´6]U�Ý/IÔ "ö€wQé—Ÿž»è†"ÉA Œ)–BXÙÄ(NðPw çt°òЩQpë’2J…ç½öèo;kd–'¤ˆãwGµÊüôEêë*þHÕ„-uö„ÞÏ-&4þÜ+ŒâUO ñ±p¥´bÒ0ðéºÜù4 ©Wã›\m}ñÜLÝùn²Æ3­÷Óz\¿·µìD[¿î¨ŠTÆ¡ÃivLg"Ã(+ˆ†©+›¾QX¤Ôv²}ë’]ˆ1ß2ÙÉ;çà;<<ð”Ãæ‘b7F‡^Ø)Ö³([.vÏ QÖ’W3òPù[3g¡² i3£Âäê}V”öÎá'ê£].Æ%´‚ "ý.#ýsZ'.B:e¥i…@VrßÙfêú絧òá0øXr^Œ®;¿¯¯"e'åW&™‹uÊbzžwüŒ=Ï縟͖îÍÞæ²°ÙÀü…Ó=ü.Í{²îc‹ÌÈ0èi„ÐÜ»¾Õ³—óì·ÃÌ]¼o?þœäj íg|©!ÅÓê£ EåøjÔ ½ÓixE‚ÏÕ6‚& (Ò8iUÞ#a»œcç-Hróêí©L›o0رŸG‹ÉîˆQügíÀ˧ýÆÿ°í’4[³„ú¹òøÎ  ©ýa+†=P”ôQ´zw7©$¶)0¥_½ÓZ|–‡Êò)Môw~fö‡Õ-IVúM0a0¯ÞŸ<óyÖ]N:}jÕmÓ+jôYÃÕ0w¬mk¡„ .ÒR…i„$ÍAT+^ú½S‹Ö>±tG";ßI„á=ˆ ‹Qø±5qQ:o&Ô'¾}ôvs^aCÎgÌݸs%у¾¨¿ßwŽ}®ÌUSàm¨XXvš¢ÐRDSû ]…‘Ô‹@=QâØXsïÎôöy§¹ 6ôaY {cÌg® ýçËò£:SVúŒb |¯hµ)¤˜5 vH®d¿1³‹k·ËõĨ]iúS<î# Ju,$Š>f®¸œÛÃÈUOWªD2ñµtËÞZè>×ËòBu¬~ÑGZéÕ°Ó~gŠ:}Ú[§ÿV¾,«aŠiݨ™ð2€e¨*I§£9‘”ÌЖöþþîù^ŸºaI‚.C·ùW°÷Ò«>¹iף˓¶_qsØ–@¹þ4_û~yhî­fèìüK»‹Â¶C GoóK‘š5 $‹]ëT‰niH8 c#äS ¯×\‰H<½ótreÛ¼PJº©·’ŽOY(q™™ûj6Úb¶zÉ™ç´óÆYÉãñ•Ï²±Ç¨ŒMXÞYåÚLÎz94¥ ûÐ ,Nbw1(|OÒ§ŸVÑz1ÑF*ÿ+äÑMunÿ…e™{¢‘a?•AfņúC_oœVV"`bÞóvšÆ?#e?;q¤58„äo ê°H‹Ò®u:Cú™v“­Î�×ßÂÌÙNæX^¤Ù b…áû§›Ž_žÏÊ_�›«È÷â¥<­½i=F¦¨jº/.AW/wøè.ÿ̘›»YPì•Mq <UY¤ç¶Qú‰½||öUÞX(çÓ<ˆ¬®1Œ âØRi܉_”=òUÂXùÂ�³=ÒÈp–cÏ4»÷Zæã‡tCWî5oÙ,ôþb±zäÆj¯~µº”9Á¢]c±|z]ìçŒTç¼ mjs>$`E7Ùœ ÂuÓŒuXKç«fÂá83Ì‹åÔ¸~øk)Öd¥·AY´¢¹õ`”àÏ-Ú–ªOIGÑH)uÓ_Y(p˜1‰úŽMH¬fjbT¸4¾-Ù05ŒÀ«G’ämŠî¹eÒé'±©G{æx̨å¸Ó®—106Ú—©å£Ô*L²*i7Ho•OÀ@$í—7ª¡STÇm×ÄÏøm8�jPÏëÞƒ{Ã¥wê¶y’­ƒjœú&Í»£½Üi5QDzü§ÄÓ»_ k™s Mxi#�ØuR-xnRû:}9Ç) øÈù Jj· ðFòj¤SmØ;v=V2CîÈ·hx‰gÓ+¶Úó¥ðÈqñöNÃgñlðÉ&(y‹â5|)¥\š—½a-T¿Öóÿû?VXÕºvÚÔÕue57>J¡¿±½öíM¾mû¬2«‚î+IyërZÍhÏ ,öÂï|èÑuáñí]šÈ¸rL3LÌ^Çv ;™ºOG4`‘’Z¼¶«Ê·p=;úȶƒ<-{¤Ñ6¸P\oÆz¢Í‚Ôú%‡ï̹> òq^háçèÅæs"M4‡¶=ƒÃ%€€qøîô~U+ÀÂz½§Ba~{ò7õ`Ú׎7Æn §¦¹»;ÇAõi-“Ð`ÈžÚ`Ðâ.zçÊáìb®•ighðéà*�¦ÁT_zÑ µp”:´M~vNø€#)iMþLùà‰eTÃÏo—ìب––¹×ÕeóGº)T ïß­Qöèw–BïÉ+]^VVÁ÷ó\.ö´Î(-CΞ!8’,\Sõè‹Á'prþ÷’Ð}ý–Õ÷ö\¯¨ßQб kAËœ­ÚÁ öÝQÌÌv5=,-?¥Å÷ án×–ÈïGœˆ§ÓäAydâÏûúÇ„ÛÖáQb8Õ}G‰Nõ9y†îÃèî ºàî²Uøó.¿Ù>&yxcúyù“er}2T lJ¤7ý6lâÔþæ§[Ê}µj¨‡1d/SÎíŬ:œBéHL´…fJ¦G�i 6L»ª©þX]=ªbþJh�D²<OD^ú,f páÐ=Rˆ³è†b6ÏQÂ'­LÀ—š‘DRÎ"%±’Ü!!Ù3vŽd 馕´Pjuå»?Òb²§*úáŽÂõáDÏ nNN¹­ÇoT÷$øË"ò/¡F«“71HýžuÅgÁ1 ²¡õtÃP-l<ÌÝ3äm²’UnO ÞþfÔŸœH¯YÝ0ÖК§Üžæ¥fAðܬ=kl#æÈ ÷ ~î—«œá«ôõ;:V> ÞÚŒTäŸg³ÔÑc­›†²l)w˜bAOÜÂ7ï^Ú†JîYèòáÞ }t7V õí Çn¢ ¥¹ÚW‰1:0¼åp|ÿû£wÖxFøIÚ«g®#ô1[9¼f&PŽ7Å$¤ñô}¦³jéÕô¿ÆÅúš¡^„¸]J9Ìõ¥T>ò8Á¢ø„[¯Y¢6›ÅPèÚì뮟ö´€ÀŒ7ÉÄÏíG}ÍÈ<³ÎskÄU¡1©8X“Š×»ùq¹rÀ�[ééÕ“[®áë^L%Ý0ýÎ9r¥nÂu:ºà©•sÁÒ‚wAÍA`¿6ž¹»ü«èä“8Ÿ°Gu²À‹8§î XíY¤{ž z¬Ä6ñ´eP¬Ťâ›rôœ$/[ûß¿\å*¹³E•X~¤ƒ&ª;ÓzÄûƒf4Š©±Ôt¤³ØPí½ûCS+ç™òWàac9]ÛQú-º% {ý-•¨¨Ü‰òúĘ·2b´RSžH£ç¦Ž;˜äœôåaO,RÒÌÔ´<ÅJ{ÜL˜Ø¿ ÿèj Tœ½´ìS'Ä1F§Õäòiê~”ôHkJà¬Þß,mÈû—ßTù2çýi4Ïwðm˜<qxÚ‹ ZÜ&7¨ØõëÞ•Ö•ÖWè!MÅWTëá^¤ \PI$Ãá’è/œ9Ëd¥ÎOu2%Ÿùþìmj§Ÿopç„ãÛÅw ‡ìÆn0‚Räÿ®Üño]DTô´Ï»Áh‹¤«Ø ÷é,H¬—�|tZÕ±jgs@w‰ø®e±Óq+9 H³»˜1šø·y½–$C¢âÒªêCÍ ¥f¬ûxàªv•RIPtžÃ¨¦FïZa® Ÿ qî^mYeè}ú*X¶´äϪ¾›âx< º¿;|û+EOùÈ—©£w×zËòÆ’rØÑq¯Ì¼,#_•ß£�ezuÇj+LW`Ì” Z½º¯˜6óëj"²P|C*Í0h£½³×F` ÿû–qx_ §ýµg^.ý­rc½<éàË>PHüÜb¦gÕ×ΤþR+SÂb¾d»Cð¨Þoµ¡ç©À2VÁöJGÝJà ;¥=Ì{Â@]âáìó+“NYÍrÚ‹§>fÝÏØé\P[Ÿ¿ÌùÕ Ð 6%F§§™‘“ª¶Wž¨+²Ýíÿ3óßÜBà—è„Ÿ–²¿ýóåZ ¸tœvó] ñÌÍÎ;©C_"ºBçV†U'žò×Ýü7ÙB{B—‰Ê>­]ZeÀÞÕ“‚ _Ññ’Z>J–™’?‚ðšmºõ‘íNóšAFëÈΞÅÎèšë›á8¯ÜÃM‹e =w@ßN–ÎP¢E3,ÎÝÜ_Îܘãñ„½%:©ª‰Ï­Òxþù<XT‘ÃùáEÍ?§]˜)´΋ û±h£\´¼täOÙЄ˵h|ÂðZÁZ@„΋=R(&}thu8)À_´À“ÐCçÌà­éÓ~yî‹ZO¨~ü Zú‘¶º£Ìà›=½Ùçât€fCÓ©ñ—¢Ýñ1\ÿt.¾Æ,2¯EšóPóXx:%’9÷HAZ9ÜLðºW€l¥éÙ¡yúàð¨¤� )®Æää�z�Nà12HÐMm;£÷/=]¦Ðô•†ÜŠ+YÅÄ{ŒeüY w˜~ðçž)ÍàßxÎd«r†‡AÏáÓ”é€ØzVðزÝ?ýª=5¹_Ï&P­6¢ó*`’ÎÞ›Dø"ÿ3‹Žó·¿yÈKÎÒ4s³Rñ+¦ÃóÝúhWk ¦ FzBfgœÄÓ…+&µž?ŠpmôuKJü`]k•{(ö:!�þ¢Ìg?{õ™—9Š¥Tæžôd¥‹_ükÓÅÐ5™[@ý8>+2'ÁÄ™îßK(Q ×öÝ ¢ýù8ÛщDζà?‚ƒ¯6tRŸV…Öª13ñ®¾ŸBê i1à }ý‡áÏa­Ô%Ú…„ªà\$Ù•wø‹ìÚ؆óü7\eM/«¼s“«yBæó?ÊÐòÀaÛŒ <�H”h×›Ãëö0Ùï‚©Sxö$®Ž\ÊþÐ÷Zg¥?½`€ºx S#Ôäë4}ZSµÞÌÏ^Dqä LÓžXæ<(y¯:šÎ\µšõ57¿‡Û9)Ui½PŽÐ‡AÕh¿º/§YhEý=ï?6µA 7ßé«®Üb>Â?2*d-&å-gmM^e]GQâ³_XíRzòÆ¥˜Jœ(Ïù£uúѼ´ì±æ®×Û’0L{®û¢.ûš=¨ð<öãÑaÿ©¾ˆ^|ŸÔYMËÌp(¹•+¢æ¾Þ.F·Ã$ÓÓN\»BæY!æOA4ïM—Ö@1¢ÞßÈ~x*A*w5xÌÁ *è¸6Ü@4öPôßuÂú™+”ܘ}Î…&ÅðØ ²/Ï{çß®³»íµÕ”Xs\¡¾å”@ÕjK'�Å£óÕÖ½m Ž­¡Ïz˜Ç]Ç 8wÖSååNlÄv¤%U¬gDÆÆ`ã䚎Àjßs-!ö>.7õxœÎ8ì2K¯BÂÍe;·¾=rΩ<¡W–Gizº)ï[“¡@½ bIoÍRÍ^péˆÄE(NÍá)Ͼ~œ Ju²¯-†{l„|¥•= °0šGÞSÓzÌ7R¢. †ÊÕ–µ%œYs>Ù•2¦Ìé¤TÚÆìg©{ rxx¬ýxûé\ƒ&tXÒ=£º4Z±ÀÀÜéÆ\-—¸ù ¥ÉÂgÍLï½+¤ÏŒáXõÂËð¦q²ùCO³²µI™pØíÝ1Ï;¨pšìÚ¨“þLáŽãÄgÿÙžfxnÝDVfç|ž²4cßJôÖ/è'5;O3âÔœ&zŸåuÆMšjÁŸxû<f ƒÎËä‘RO¦e¡Ë’/|ÜŒÌë>¦ V¨q(XÝü,tSA4Lá”ï{˨ qCþ(N¿o_= XYÙVq¶?œ0,V.;p6¢ÿ·«'FÉXæ…7¶Rɲ)´LI-Zé—žê”9 gÎi8µ¸y»“|l ‹¡;ÊܬHfè…󼸒â-d~x- ÇÖÚXô…±“ ûW§e@S¶ÓÁ]K¦ ƒ¹Žo[Š™´—~Àž'‰£„æXÓ²Aqía^®°žÐ_xQhÐæ2zª ÿ<{ß`èºÖ �CϦ (g›–ÌåoúF÷ïžÅ,=ÓTAø®ã,œ\-Ë÷`-RqBµWý¬'2ìm:0ï«=cCº;¨”€1bï½5”uuÀûX$ìôbu$¸ögfÄg‡ŠZõ�{¿Öšo¹jÆ[OÚæyþWžŽX$eaÐîó îóôQµÛM„l…DíGÑûÐÖÞÝFÞm[/)<Œ(ß½vI‚ܦÁ2¯‡ƒ¹Òq#m½àˆ‰÷¦# ı« ¸äi0±ŠÖ™é]鳧Éœ ¯õøŠüfÚû±TAdÑͬîŠVÆäØԴլȠ»~[åÙ*GÊ‚®E:„°*Ú2‹ŠÌôÌŠ€O<Î3‘ñ^“‚~+˜õ{§Xøc=:IŽ)ýÜ^¬ Œ9ÇÍ"É+<A¨l4¶^Rt0FQ1XË š¿¼)â"E»zÑŠ{¶ÐKÖ?=AÿÅ‘óvg¡Hª¼qWÿ5•7û3ðªHK÷Õ Œéã1‡Õ€îÜЧ~ k5÷L„$éŒKf_9Y•u$và ãŒî¯Ãðøs,I€¼QÃ2ô´Ñ)V ;î.ª’é©­~OÐÙáhn.ž÷1 ùUmqéNîDÍÞ;oO‹Ó1æªå/íê^J†_(@ºž†´‘M~™€ýnÈ ìS€ç€ Âyš[FÿÉ=HhÉ©8ìÛbÛ,ÉD±‡–ØUÍóÿܾ-u}ýˆ›%}ŸbRÜ8‰ „Ý·ýu;]©Â™Ø_[JÁ«»ÝÒƒ9 ‡qwÇüd­\ 'ð! ÂZw|§~ÜØÝ%Hw0Väb$t²:g³ÌX˶ŸN ½éú?0»óEð’ÖªÜOà†¼>ì[Ï×5¼ë#‚×ÓùÄ3d*±nš" Šyr,P:Dì¤XX‚ãQKÚ^Ü\ÿfÿ­ô�!6à8k,C¡R„E{UtEð@tâ® Eú4}¿€óNŽ3ÌûߌY‚ãDžOfúpê4‡Ï­Z:Ͻ×Õý}ÙöÄ!NÙœdùDÏ—›ãfª9t=@è‚e¡gÏßÂÌëªB”Æ®}(«±`¬Øâ`{Ø&Ûlz8ì@ñ´±Ì½§Cìè?E²²¤zl¢evú×d%fÙÅûZQPD7¼¤¦Èƒè«öÔˆµ³¥R¢!•Ä äS­‹g6h}:9è*87TXÝËŒ='HŽ«IΤJÇ?³…¬v™¬v¨Îƒ¼]¼?RŠvíjâ¿é>÷@[qî0Ú8ŒŠ`ßÒ“)Ì NÒÁ™C·ÊkJo±và†Øf¬¨¸þ×kt r~;³qê~Ûƒ¡Â7x_÷2âk&ƒlñT|gIJ¯§)†‚¼H³²úv0ã¥Æ“6†éñÊØêžœt¬9ªÑ È L—RMtu¤Ñ%QðÇ$Ñý×µ±„6 #*ÖÌZ÷ä ;vôV–è~·á'¾ã�HÛT!dí§Sßhê v拳¥ÐC!':/sÓ˜J38ÑΞ÷ƒ®:ë]l)ðϯìyªöQ"(ì*®ɶ–ÂË~huƒ~Æ Ëœ‰â&­°& ’nöö„ØitNHéwÝ¢ÆKs@Í%‡8kSvê6tĹ©ò®^D´œ–nßýlãf+…qè~ï½ô“¥&ð¤5÷‚úI\f>«#LPgA5,î“#–Ú¦ t„ÔTÞÔ¾¶º£Ã2˜ö,9­wðݹ›†ÙJ©lÀnÂ=¸y½yã4ôZW±ñ¬/N½—_x‚Fâpú ãä@Ïó{þöÔ¾>t8“ˆU[æ¹  ·Ø9±4‰YfnÔM7ˆÛ²‰K¢Ê©n³¶"µ"˜óŒàmþŽw»Ô'pOé¥Sƒç8gSÖ7°Wß«©ïèÆD׶§s«¿X‡IJCõDI¯‘Å1´<åT962%¾…¡ÒÈ'.2žpæ»UjËUŠÃ¿5•Y\ÐhI´#Gd¡J¶¸K]}h!kþÃþðS‘B À†Ý7ÏM•Þc´Ü cÜx¥W²…ȧ8H­Ù!eä¡qú™÷wp”¯Œ Yy–¢ô0xžUÇn¡Seì šî ?+xʪÙMÍ£ÂìÛÏhݨt°I9*®#U¸eóéˆXœýˆì¦I.é¨ËžéêéÒ¯CAæ=‹éÏ¥¦ôò4›÷­ÌÈt¯Þ™Æ p:x ß êýn ƒ?ÚM©Ç£zÙoÆ¡¶¸³qdîj•Zñ¬DåêvXò­)œ—]ïmSôVÄ[ÍP {cõ‰‡3Ôÿv”­JkÝ©y”¹o3Lok}è3T¢²k¬Bë KõÙf¯Z©L·Ùœ|±ÖË­ÇÎ#Ùÿ~™Äv´×ïË–ïÐÉ}•ýxâÎ6P~¹kTàž¤kE”y@Z~Ë@»©ªOVmÆ–ð‰:ü>Ä\”[ó^€5æU¥­ì�?5 æñƒþ(?5c1<ñh“Rä2‚lú&¸#1“|ûè0@{úkR­\>!u…^ð—=¢iYÛG€¯Äíåc×°^Æ}¸_ê�©˜t\Mt:Ïã86D—€ô 屎à¹þé{kÈ@òäAp"z©‚¨ë­{~(.Í÷Gú£>uc#6ô†ŒJØwçUq¡²UQ­Ÿ î:È[ÂFjZÙû…Šìd;³¥ZÈ[—DÞ¶òg[oX\äVÓ LWGÖE‚7ôçÞ< ,šÓáÄj¿Fð³ƒÃ<³éCÛi¶woTzŃM®#* ‹©s‹Óá- £0é9hÔß°ŸÊÌæÌ–¥f6õõM0ýÚÝ‚Œ$ŸêÞÓç¿Ï¶{"&Y_†Ìvµèü¬ZuP÷|¸\…s÷ß7íYÛ¿çßf~�¸õæO êôBƇҕ­ÍS~ #¬æé�³ ×úêyWNpï §Ú|cdås¢cŤ…{j Z[ø¨¬~3(!¥¦÷¸ /Á2£¨ôiC6”™†Q1Rîtêtjéw Jï:©ÍˆžFzßjof0äëZÑùÀ’/Cp B‘w7ÚR7?ùQbÆTM ãþâMÔ+­«c5Jø—"7q/ ùªªG÷’²‰éÝ;ý¡§Ñ$âùµüù¤{Y–~'BÅø•¦A1Ížþ2‹™Ö_vàÙK9d¼”~tî̼¡<J]Æ[F»/OЇÒuÃÌÿ „eZº»oÐFºùìõÛsÿQߟú<¬hiadoleŠõ™‚èxY èÑAP_¢fž¸Qués/¯†N¡áâ6ãU†æšÙA‰8¡ó.U£\ð´?ýµ—@æ0R.m,È-‡e²¯ åòÐWrq ”¾°~z˹…Z¶|3o€´¿8%ñ;ñE¥—ð¢(Z¡ cüî<HfMzsÓ㎆#Ì›ó`a¯ýž¬}Í—œÅ!ãzïhí´Q>®¶Ñ߉›i?j@Ú±º©rJaé9T'ý ™AV¹$¤3ª}ÃpEìr‰}ºñ[Kõà/´gà ÇNM2¥ìc¬àÃ+EÅ)²Pm·mèÅÓÖÛuC÷§6á¹u}×/!p°B”¤”'%…i½ÁÐü<wVõ<þ¿V£›½é»úîßíkLˆv·Úº®$•s…{:nNžbkøœ'�8×4ˆ »y…ÍFÖáÏ&c2µ‚-&ÕmÒ®g?IãobÓ&4çe“ TÚÊYËADŽx]¨挞Χe>&8Ôj:Ëø³¿ÐÉJ¢,ó˜ûÀK 4Ù°ÍÒµ#D¸mN?¨³®¯ƒ7­¡Mn@Ë-ÎÍxÒnò„G¤¿a7Ñ6bÆæíÖ¿©{¢ÌÙæŠÐæ[aÛZ­û‘BlÐq“H?úUšõâZ'ÿb �¶û«îJJߟ’Æmç#X»¥ 2çêiò“”&JgÑš ØOñþìÐP�RG• ~µ¡ O7‘]´ƒ D÷~Ñéäé¯X–-ɸœõØRßç_•³Ò`ýAîlï4|¡ù¾ÔÇšª §ŸêšÁÆ“bÝþ®þšë/‰M{EÜR¶µ©7ãJç²¹4tºñ�£ª­)C šö-x"ƒÊÝ…fŒNÛ¡C²¨ÁQ"&Êz+èÓûA$®ð~Ô߯ž~Ô üÈÓv2KwŠVï¤àÜ] ºÉî¤`÷¡î­¦£mšˆÓA<ñ J|'(Ê}šüžV ,ËL¿P(QðdØw^oŸ¼)üæG3·sŸ úèò™œj}´hž[‹/ÊéWoö¶³Ü{òˆ+Õ9neluL#NVájx<ÆúØý˜ÖÚá±@5íÓ ±>´%ü§×Æåš…ý:I‹|rGÄδ¡JW^ÄŽK©¥NvͶWTX€œSŽ÷àoQʬ¢éWM;zâƒâhu;Ú¸Š‘q± c×ÂïHK+°Î´·¯‘§|œ'™ !¶Añwé þmo›¤¢=qo’š¬Ufè¬Z 2Ö“7‘ÚuØ\l¬®=ØÄÃm:ÇÎ)$Á;‡$>ï<Kkóc5ŽëiqQò×èéIU® •„×ÚÏÑæ=]g; „Q2F—‚¦„ÅÃd£:M hçÔ8œ=ÀflÉh‰ÁØO;HRí5^DŃÑ~p z‚é4>Üüè3n¤;=ÚÐ6§Sd¬´ÚXŸP…^Ò+2ü9Íèöœº8È®ª˹È�î9 =„£ˆ™A9H‡º«¾Ÿ'‘î*ã\±£ýœ~úæ[üá§É'–2{ÕK7Z{¦†L‰¦ü¡þò´ð$´ùÂäw0ﳡýi#|›(–ÎS7ãïZ|êJ­k/nkEœÝ¤U-0 ØãXàë¦â΢x¸kŠ#‚²²õÙ€±+ð’o’«Ò?ïð„¤¥f¦ï¸„¤Œ} Czt�ÒAGvˆÅ¢JìH@—ÚDú›¢ÒP˶˜žß½±lÃY‡¨ÿPQü†UŠnÔ0%IP.V) "wERO·HðžÐNÛ.w¬f’ĦÜRç4{Øœ9‚reÒ7ãò·F´Îm†÷ -�çθS¡à”õiq¼U‡—\:‹ÜŠE`�Dù½ƒ ?Wº£ðJ×Jª 3l%pæå¹ ‰³mÀÖRñ<(Ä¥2燜€6˜]nIìOšn±ïÍL¡¦ÉAtºxÀé#´™©Z3P| f#>¸»jÏ­í{íÍ´ðE`”1EɧÎÃÐ ´Mð7ƺð%tѪµÃ6yM ð´÷Ü`ž<kiCü~ñ½ê,Ý>Îyu6ôî dEΠ‹Ò3À@Í7@ÃlÄ›×õ�;Ï|F(DŸk”÷“‚*ãL»²YJ—ÎnìÅ–E¦³ Rá| çEˆ#tzÚÃH¡åÂØÞu…fN«ìÒYI›é°Ù)Úü„…VX¤’žs$½â› 0‹Ç¾¿²Göï�dQžû¸4(Òö-¢¡ö\ûcíù÷ô‹˜E{—wοÄë’çè5³q4]ð†š¼?zŽõ2ûþÑ„8÷PÝ 3ú)EHj«úÇ7c°ªÂh'»Æ²1N¡ôígy’­.Åj·½¦A±÷`<Ðict*z²jpÎ#9óò)ë±€Dÿ‰*WÚ<ï'×;¤85žx<‚ Ò”«]•¬7õ« c±•Ê ƒ|·U¡~8Š1/Ã_£úº‘L¦™dU¯#2¾ªQqô'US60F†¼‘µ,eàèý�ç@w”sŒ©:ÛÉI<ËÒŒ™‚ô›ÒÖÎj(:‹œ …³d˜<’d%6½aÖz®•­ä£Á£¬'n.N眶9,}f_§,E²Vc½ð)nÈ–¶÷È¢LCûègßëP”!²`™³ í¶–â‘ÓFC#Aky€g?¡‚q¼héüÎ#Ý¿’B„ÁcGŒãeçt£„&ðñ“Ç }z”6É|kL¨ÐRrn×°zÆé¿o©™o2׃}0àW_îso\¸ãMý¯“—å"Ma.ÕØa·;š¡¸<w³W>ó�+sã7IK‰Ô´•Œÿ/º¥gl©d)8/Y; ÙP¾q—°eåèó´Bà_g¤êœþNî±iE–à ړׇŸ7ûqì­R ÍõÍ‚/ÑÅâLòž*`¬wøêà²-)“Óý³}Ùx»;xÍ 7ñ9˜è�eù|«®’5˜xsú¤~¯!õ I¹=÷ÕæWÛ+E§¡ír TXm·ãl¥‡ù˜ÕK)] K%‰Ìé0ï¨tœ;Ù.ø óÎ̸¶¯²8ÖðŠo.ÔG†—‰vï°[Y6^x¢,È y1twW—+í æÜîD€33 ú3m¨É'ïŸFzçɢ̘´EŒE\𰧺_Cwÿò›‡(òÆ™=þuì ªÐFÏXžÿS5¯#µR Á•£;Rj6( /–‘£¡€ó™d~v4Ô;òUìN<!hÓ‰WPúÒx'ž˜ì=+?ó¬iSwa¾žQîJ»Øu:¤4ƒmOyV%‹9ÇŒIK¸Ü:ö<jÚAeeð' •3 Ù9D(¾(§1¶O :n +ôRïµaíé?ò(ÖV±Â-œ¯°ÛmgS›‰*¶MGÅ0r*ûùáCvâb³{w¹é¦®=ì�[¹K¿©U˜ Õ@-¾°‰Q)Üyn�Ñn?°7æëÑÐëÛ0/|æᚺEÕøä௛QSx™‹ÕwÿìÇe‰{ ݸ·ö]œÄ™ˆ!"-Ú¹Us|ƒs47ž÷ t\¾{ÀÎÒÝîjõuK£\¡·ÞÊ@4¿±(ZyÇ"Óÿðd?Êà’éûÙ6ýîª[P?*A™Uûâ‰KpÄñxY<�0ýwÓÕN*ñxÇGÿuöy Áͬ'={ •Ûƒ2êÖ¤0wÚFeWl[ÖHÒè>ý«¨/ž~Õ‚n+çY%,wŒèôyf×óã·*%òû ´*'J#óÓ§U¸llXU–0W(Ï&UQ¶Ò9¢ZyØUA>mÍGØ6¹c^MÑC÷) õ%ÚÑw ]‰YíQnbÒRçA¶=ñoZ?‹9“XÎU˜ÕL &liãÅš0ñõ Ñ9�VÇb€ØÿüÚúÈ¿BqO|¡Fžíë"HšÙó~çÈiE°ê¶KO”«Ì± •7ÒOŠÿYýê<;û®{áuC»Ê¾HÉŠ¤Æ«1cÆj©5VžËɾʹº¦—Ù|–¯ZcI:ýNg/dVÅ\[%Ú¿ÑaH2ß½±*@SmhºVbX…SÝø)>ëÿä‰6JºCLÄï©öL»›z' #‡ÀðÑ3«yüÛ<3¯á¶ÂžxßøZòrÏ Ê“²cFàš×ã;QŸ±½ÒneL”6c”Íì †kÙÅ~2b‹^ýP¿ªVþëæÈ!-{„²Îð±¾àiKÌPtŒÚÃ<?œHe).…‘HŽdDÍC”fµÆpêBYëDüôOžö"g¸ìØÐ'T¾h$ •Ùj:¾èÕ3í«"ª¼¯ºÄBgÆ»I)ã’÷°6‘‹¢Õ£‘®Á¦†þŸ ˆî^jv˜{.è|@²Ë_tÞÛZ»ÛìYüFGæz†ET£]1 T‰f#è¶>ÊD6¾OI°¢‚»a%‘V›$r¶lRµÑ0ç~ ëHnP*P*é¤êÓôÄŒ¿œù*&Áx ŠöòT' ý¾3œe*Xj4²:3hÁ!%Öï8tœÎö•ÅY¶WèïÒ£·òI·™¨Æ}¿Ã”Yû+þô%ì-2X¤õOm­X(Â5)à¯t¿NµÖÑýaÓY險–;XS”9ïúzþ+]dçò.óÞX\qÊÓ*<³…×ø{? ±¶Õ×æ@¾ûÁNä Xtk×Ú#è<p£É^ˆŒ1eP\ÍÞð†ó¸J+§¡_0ª³:éᕳº§$íêîÚOhÎ"tk–ÞÔô\ZMÑú‘Ö­êË­T…`ýeU²�9÷.¬p”„™G/€Ñ×6§¨pu¨1Êm£zÆ->ÖƒaŽ˜«'Á;ÊóÌ#CR]u©)1¬¬C„¾˜_ú ]Q+ŽÍe’éò#ÁØ!H3Œö/ðc´”}¶w;+“Àêuf2ü«0ñ’!™8ÐÖ ¼³Ö¨óáðý'b*)ù™æוç"ÂJ‚t€æô˜73¡”°ãÙ†.Í=åÞõ\ݳyŒWà ÝúpB'w±J9!#Ü177Àê¿�«Œ2,–nn÷( OÞ´dÃdA |4®ÖƒôÓñ(ç¹Ì0~ªpU†¾¶P<{Ra§[‰ Ø0¨µÄˆyoeÀí哼4¯üü¹®”-YÁqó4ÍàôÁüÔr\xrÍŠcšòZ·AjŸGf“žKÎ*ÃRÂÁ6¥Åh! C�ö?oð %0ÌAß_®ífìZHÛ§=-¶~Û\a¾ ǽ¿B¨ÎnÚ¬ˆiEÝ{ÐœfºÖÜRÕÿ<¨EŠf”¨ÆÊ–hÆn뢈ÊU‹„݆6•×<4ÚÃO&XIY…V‰‘HSA?äÝ< )ç Ù+MYêTÀiͲ²ò¤=õ³BtXødUVˆ¦Goµ›¨òèÀ$´_ZM¥g½Æ†¬ÁÿùîÑ1éû)Ö_‰ð§éJ¥$a€`t>yÝ\Ž»Ãy‘îá|à/‘‚Eâ/dŠ­×øÍúì1Gÿëžr4}œòÒÒ¶8¬G×wøÔIæ+"‡0ÌÌ‚Ðz‹E0ó/Uù=š¦ëÚÝFVÞNrQêS(¡*ŒSi@ë~œÒGÇ£TV¯ÿ~u'd¡ïÌ^Et®gÍÚ6{(Vo‹`ƒé–`NÄxÌ,ùQ¼$öûlï„(Ö;Ç‘šÎ�ѽ(Žîhe>Ä2Ã}oeí)Pþ9l(%>Ô6£ù•XfdíŽ5p-ÀËÅV{�²{ †Ÿ”§r3p–”÷ÌÞ•©£R/qÍ‘-÷k.:|ÌsDLu_Nñâ<»¡¡/ÛØèpûu.CpÞH©ë.îCP³ÐG;Ñ{N{*ÉË¡¶F<’ïzUækúYúV¹t_/mTïŠm=QÌîÞ.ûɯ˜r;Å Ò‚z6üÏ–ÝóïùÃÕ Ñ/{4 ÂaÐð—q@�½õ”ÏãéU¬4Í< !~‘4J¥ï�cNg¾¡Ê?+`8ÜSb0„¨;9dèÊ!y˜¨§«QâOúב…±”¦W¿ÙÒ™u:©X-ayúHGÇë“ 0lœ¦·{ø�çµõ/&Ùø‡òç„ ÔÃá²YåÐÑ3t¼ºˆ“С·> ,ßý?µ•ÅÑÐ «iÑo¤-XÆðHçîY‘ôHq[®ž6{“£§AÇØ«7äJB�3úê·¯÷KüV<»?Óá5=v•Ÿ›ùzz¹º2´a³O›yŠç4›B›õìz¶÷®Vñ:ñ­1ûõô˜]½ún;Ñ¡Lç—¸Èß}QT„'öàmfÊØ@6­#ºEƒëÈ-.ØbùÔAÑ–W€+gÚóÿk_ÿÍ„4[YNQ9pɹ‰d—ñdŒÍÙ×¼½Ú¿r<X÷ã{ê–f~×À€?·n¦q^ÝôE̓iFS'Ù>•^äLKÿù›wZd«°�Ê5ªùâtcÄÐÀÔdì¸à.¶õFfcFeãåÝòC½löÍÙà©Ù]¨”G®þb4KP»'ÝÖSÆ·Š­ í^+ߣ°òQTvÓ*H­œ5¬.ÝÕ`êKõdó²:L£L‘8¹IÛ¹ÊÖz¦@ÖBH-å’e¾ó-Ý‘ÍèÚä©‹Íì{Dõ:@¡@°1˜Á {Ùd"󛕱vÁ\N (ßuXö‡ú˺Œ2ÐK½ÊI3ý ¨® `8EUVH=|_›yU‘SÎK aV´Ê¸`¿útb™Ó¯ÿmök½eÂÐ@6/Œ²,½4Énö+íüEôÞ‚ÎÐ=£[xsZø<=…vˆâ\<×N9ëa…ËÞëC}@c‡¼þFQÄo‘³>Ø›Q¯k ξø¯=ùéßÑ7øFaf½—-z“]oFù”´^ÛYð¾Ø½XÍÝ$M´0³š9ö¬—÷¨ï¹’A4¹(¨và X`FŽôl ýK§V7gW’0û "Ç[·ãdb9žX¤™Ïùñý.êÎK-ç3ë%1DÍ•Oò^qA¶ª¼BCÊ‚íµôô(ÈõÝ(òš‰ÄßR ã¤ÿ ªoà¥×t“¾ýÅöÚ··©g’ùÉŠ%8i>•\%g¥Ð†2èÇq‡®æÔíóú‡;‰gQ­4 ’`:R<,­ôN$ÒbÜñ“É•4T@ÃaÙóÊŽwq«ÈØñ©X8Ú_=Yì-<ÉYú(†{Çñ£»?~?•cßš3fÁ1‚e×Éõa7#ÕƒrOÐÎö¨±)ùæW’F¾š/4ƨl‰­ÏZÊ{œÍŽ–Ñr?Ò> ºq¥lØÂôJ¥°S›dÁÊœ  à¶-2?—þ>[‡ Ùç­™+ îx‹Ü"#\ß„ Lvyþ7žÙ@(pË j)”Ô}jy—…âåj„öcß0ùá5¥”²È<ávJög½Õµ§"#ƉÒƒƒn<¿Œ_ô"w„m“£,©'L{ì– UnØD¥ÊlûA™£$¥ÂÁ ²¸o6€îY¼~ÿ}<RN´98×ÒëpÛöleÂ7u7XÜ¿dD¶Ÿ c’ÿ' RçÈQ¬cÆñ 8¨Ì~á óÇ"s†™aI_! ²zv{ìXCÐÇþv,Öµìgî€�|å.Ê2Nۺ쫙óYzÐ [ʨŠÆ‡Ç|¿;ã #“ÿ¬νP±H4¬«BÁfaÜ:Ö#âia•­"'’ö-šW–tDþ÷-Ï°DGª–ð¹UŒ€n,ËW*+àÛ_üL#(¼”O‡a(ƒ¤·‰ÈŒ�­LÖ—ÌóïänÉZˆ’ yÓ©ñì˽á±éÑñ¨ãÍ+2•ùN§<u\\øPãDÊ‚Üfè˜Ç÷5šÒç£áã*a#CÜî ,ãÐUG!›]$íÖv f2øpsÚö˜P–ŠkžÛ¯Œ.,éµ0½ù-˜¨×Ê®ŠYuù(ÂG·§Ðwû,O©[¤€ øâïÞًܧôú®&sW&ØÖÇÙæ-ŽVN*Æý7í cT{r%ýƦ“ÖÖ‹¨¿<\½?•.CEIùà§BÕðèçâ×wô7 RÕ5¬/Z‡CâuË�HCj*Õ·qxÂÌôS!ÑNß&%§ñv$=Õ-²)ÃøÓag"ÝÙöõ±\»î6ó³NàçäW‹øM!r]o¥MW«ã.×Éœè”*npi-OnL‚Ne×vGœUèv/PYÜÕíˆÕ JJ© êžÞ´tŽÎÝþvªwÎÊQ¼ùÜÅèC¸øFxˆnäÐ'X³×Î5XQì9³ð ÜKŒ°ÄOúFT‹Z`¸’‰öš¿S¶©xå(ÎjŠ‡©ï¬‹Âï„>³N‚$9ë¾@¤±|Sîá¸bsáŒÝêÄ•©ÛSÜG­>iÓ„B¢ó§îÜy2¨í4^û“o/ ”¢Ór¿/šæ7ôö¹Îax¾õ2u@@‘•LKÒ~<Jîº#Å€èZÿdF V�€ž¯P­ y©’4œÿ†ø˜yVšÚ; RÅ÷ÚÓ2F;Ç<ךysü�¼Ë;RjQ–ùò—PŒ§Gœ´Zd½͙P©¶¶Ñ£aYÃu¯«Ìã̶Aè“ í¦O¡²n$«jû¾1ßm.ïüÝ÷=œ­…þZH¤D'!§Æ‰%wlÞFÅѬ©Àê^ °Gÿñ«eQnúù§‰Ž¹ú]×P&°”/”{^$Å°öf‡0¥§rݽw C-ÌÒ ½ÌèCÆ_B)AÎœõå'ž{¼0¢ät·(ÑÖ{’1óü+R‰ª…… C—RDÕǑǾՠI;^}ö¯¬‡ÈSƒ±™òÆ´œÞݸ#@|Uw:3z]þ5´¨1®óuIÖ°Ôüs\R• #–¤6˜QX­£ŠV08eEÝŸAé„LèTDo¼05FмuûNe,~fòy JóHYÝÒõÜâuº+~;`ç\ °™ÑüÝw=ŽæÅIåF…i3Ñê›}AÚ¶ëNÎ5€( ÀÏЛëÞ ªÁ’eˆUu:j ¯lf²ÌE¶À8rô½o8óH'É÷ùáÚð4AÖÚÞ1QVæUÉÊÇ–rôk k+9¯OÅ{@Å(ÓGß­pvEÀ?uÄ–M|c¯§_˜B¥™©ÔßòøjÖâ±D8iîz‹0ëƒa™_)œ—ÞŠÎq°ôgªv,e€ð¬-×Ý©aUYa)™n óYí”1 \ }¾næ å"ñÏ>¯v¬qÅ2¸ÐðOõ…ÊÙPO>Ÿ.þWhÞѲÜy¥Èx FYõVõ RóFoÝ/‘9eE¡3Ì™Ïý õ¶(HÒ)žÜ0~„{¿pÉËB?§Gg­©ìhmÏVôõYsˆá6ÿ˺N*7±/%¨k]§Åsî¥@¾§Käïó¹’Ô•HÇUc‰éC;h·®O±‡h?ª)�S2ÿg¤MõÃíÞ(ÎM$ÿ~žyØÔ—Æùzž¿LUi/žZjžm(KÔäAܾ{ž®=6:÷A:;åÛÉ·vWOyëQ¾Ò Ê(7ÈiY][ÃØO¾ŽÓ}Ñù#ºm߯ïTõñÊ7“ŠYŠgÅyïáÃXžÐzLÃn%ÓZ^Q*×…>WDT˯Oß –ªÉÉUEûÃÐq^ÏBˆùèük~îm'cA¹ÓµI¦qYXˆw¡K­ïà¿Ò®ë¡‡[;7ºHe öhtBøÛñçâ¾êÓ�ív¹2y$Ð×ïû9²=ÂÊæ1ä}ë)õîêÉê3±"á/Qï©Òl¬‰žMGç}ØÔÖD­d Ûªx™Kc´!»þÆìN÷¸µÒ‚Ì «z-#Œ ðÿµ2Àßþâ¡Gó X€&)ÕYA�‰“Ƹ BÉùJÓUÉÈo#ßý¿…r°³Cg#eó®dPX@‘Ö0vÒ-��Į̂տëåà|5 E9ÓÑû[òAÛA\²ÅhQ<zwZâ쥉•¶CêøGÂ9Ý®4 ²ýÙ0vn!ç|xõ§—•A_W@<rNqP~êRCYÉÖ;gOa/n®�9ä‰ßW¬<6eÎú9TnÇ{=û€ý6ú¢º¤ÑÐûËÀÜt§reX‹b”ž¡Kfnöiä_ïMžn7C‰ ¹ïkñÑ‹;x$[ÑïiíRpŠìy”²Bô‡/%üC`ÊÕùi„A:HÓg_œë䌹„gÒñ3’FYDYlÝ*�ªœ‹ a@Yd’�úœbÛ°ðýí)3‚‰7mð²ò§ätGY“<™¬Œ œ‡Ù3ðùIÜéi*€äØ%A1kk€TeÁ|AÅ̉ä@~"še9ü©oötf' 5e*ˆC·¤›i$n½Ë» øVjsAD¹®�;T^g7Y©e€%ŽseUh¾®!šnê£AŠšZ<’†0·xßšù) )-ãÉ 7‹v/ý�ÅMrÇ@¨D¾G{<1½íÔ 68QLëZQà|{÷Ãÿ<á[i²(繡øêµýÙŸƒ£ž•2æåT_2÷8Ûs¸•Ð6¤sHÃÖ®¯ÛŒ£!‡§QÚn°¢ß £Qšß¤«X"™«Kúáú?öÇ»’ÇmpùÓ&2"5ÕAQ­ÕzAÀïÍÓHN<ÖyÁK½ã8ÉRὤFÑu¢mZÍ;OhiXSŸ– ûú„΋ÚtdǾ¨¢zÊ¢'¶u÷0³²ËQÒÆMe´ö·Ï ¦ÄÊ¡ÏlÌ!ÜÕwá×8ô=­) {ŒÀv†W ¸í¾¼ƒzÍxNH´#ÛBϘxT'í;$ÆòБ5ÖErˆÇ0™ þ×Ðql¿<9J:*¯#¥’¶…qê€rík‡¼ÏØ,ŠÌ% EïYîwæãr»gê.ŠÇ…¸¶ÒÇólý^TÝuN„¥)†D‡ 3‰8N5ó8«àýÜèˆs ç'b‘çžXA龦³÷ìƒ.8}„ÓdM ¹³Bï'>sÊf¶³½o5âÐCÓ-1¹Í?}-/Ckî»Ëð@éÀé£6yçæÌRPòسÞÄÉ,Í[šñ!=dÖœD°5%Bë·“aÎúC§^BT ·×´1СïžaðÄ^¡Ö™ZÞúppÖ²x(”Ga–;±(ºÏm_Ršªd5iBZ±4’íùd’0ûª’£>ôtmjëLŸ™ª4/Iµšjãü{ï¦??Ïþ¥câ6ñ[‚ýD5Qß8+lÚMËÅÙéPr#Â/$t[v0?#;£.—óκuŒˆ¬R%ýà þöÛD¥z¾Ä†ÕCB¸o]E­ËKfOY·‚èÈ€B÷hĉ¯õÃ~Ål*?{jÙhæ1Ô«>·,Ž¾aç÷9ÕÓ³ ÒcñŽ9÷bý)#?ÊẙiöFú»ÄJý´Ù„ée·Ã§®„jZƒdô®üÒÃm«›MƒiWÑç»Co©÷œ+ª: ùAŠìî·¿øÑë,õZ6‹±7Y}Yt$¨nÆŠcÓs…PÜÞÔ› Hï¯C+ûtµ JW0y‹ÃgïÂÕç3¥ÜýúPFåÿ‚/™*:N­ñúb¬â¹‘É­ÏŸ;ƒÎ8Tnó)©^?ìpêM­G{†&Òì9QËÑsó*],ª½‡»Þ äæô3f¬mí9Ê mÛ^¡`ŽŸ§Åë9Hëžß8ïôSxå†c5Ë Œ«]*N»þˆÄƒßyîz ý_ý‚*ó‡ïkë26g0ï_B΂îêdKSÅ¿Þ½òÞQPËt“ǯ¸dÖš#&þòÓÒ3–ëpyÁ-x¼ÚÕñ5’V íߌ™eŽJyÁ`˜év™¼–±øÄŠ‚]B.TlÍgÇ}4vŽ-ôÿƒû` nïúˆ,ì‰xJa@ž�­fÖd2Ê ®tq§çK¶®í–rKµ”ñgÞÝè.Ú6€gøô?AËr52„v]dÍì ìkú ó½Ïû$Ù­Ô§QzE ÏIÒ«õ~°¨N“«ˆopçG(èŒçöÛŒ$rämæF`­l ï—^ßQ#>d| </ÓƒÔ+k*.–dìiwN<`.ã0XMú¢ïos8ÆÅž§­¸H5�çÙ䈈 ¬æ7T#Ë…“ T#:[mšÝŒ\…]äÿi˜Fþì‘‹œ¦zè½yÕzŠÙ«„>¤9ø‚ò~–{×ìOÕ  ¿líÇ:]5••. ³Ù‡µÖˆø žÂ¦°ê‘`LZÒ¸Ñ>†È£€�7ãi-GÉúÄ.}çÄqw¦Å•Mg¯{Á¼p.ÿu6‰&b‚Þ¥5ƺǓWÎ|× ÏkZ KkÕ)Ã7;O<õ|˜ûÃéy[Är^Ų(÷«º÷Xn›Ã,ƒM؆s±ÞÍ4_ã¤ëaÁÙeSé^Û‘b)dfk”B§Y=§ãÏÏS#Ãÿ³Pæña¾Ûù¨ôfŠ3ûp�j–(mÍ/¢Ìr·¢ó„ù*w«@% ¾Ø©>¸r~Ò:>蜙›zÇæuK‰/”ï®qÐ3²Lý²Êl€t6Æ,�0Õ^/@øáöÕˆ)}#žEEêfÜA™ç”…8ÌÁ…Fd(Y{ØtlQI cJ/,õ$ñhʱ r|Ö^+Hdšgëv§DÃùg¥Ï2r $FE²ÿbf ¢"A¢SŠõÉ^r_L<« öö_IP\´{…fíi¢óÁ$_üÇËÄ¢þ°­¿žOvÃ<óÙPIÐi/ P,Ìpi­?{¯Kõ¼_åñØÏêCçýÕ’~ÞþyË"58v½Sµ0°æãÁt_·çþ¾ÁUæ§ Ì®(éµ ,>Æ,—î”tÏ!À "0dô\"ÆÍcS#ZØT@ÿÔÎuâXÏÀËS¸y6ȶ Bþ í,{ñméW…gDÅÅù’ñçb1ÂMÀ-Õ£Ñ_Y©Î½|·¶–1HJCíóCè˜-®V_EGymñ¸Ô`ž\MeÃÍu:XÒÉÊìçî%¸c™/³NõHû7j”´‰6æ2ªm7ƒ 9?óšœ'ï4?#×ü4ú´%Á”²F½ÖU wG__µùSó½¡J°ßNì´ýdª©ži.¼ú„ÂÏÖ52èVÌίì[E»‹[Lƒ?{c-T &çZàó&òÌDã4Ñ;5Ú™-£@©,væF'®ñ£€Kqj%:\­~ƒÌfú©E£dðdçæ„œRJÑ€öß5˜öWˆA—«ùóÆ” C4t>.“uŸÏ€"ìkzŽñwÏ2ôÏgŒã:‹Þuiàt–YŠo¦à;ï\¹ŽrœùPÈ’’E Ñß/6íÊíy$yÕ{#ËùÿÓ\™¹T·çé›2çsÉÌüf ¨û¯Å(#]–´ÖC?þ. þÈÚðeÁu¤ì9nt¢lPi‰Ç7éi¤sÔlpE.ÌÓ[Iù‘Ö~y®]±ÕÑ.è)ÜÚ3l—[hÄOŒIñ*3Ëò•fŠÁÃä“Â6gUÛ²ƒnD?I;<cHY<òÓÞMó€m«Ì®>Þ’„@S5Ãä{2>žd*>~@\÷ÓêÜNuçÃH óÃSæºg-l:w¯ÿåcmG&³< ÛKi¨ÁÁ@ÿËÝØ×ê%ý³¿Tš:Xú÷±ØgR7K;ñ±àR˃øûFZyÇÓ¢7K”­× ¥s‘oª•ì Ú0ö]‹| ª²ÞB1C»’ {ÿ4å §3fc`ç#»^„y•þÔŠ›è›†òõìýjÎNvŠõ¤E` 6™ 'ð¿ÔŽLãÐëYRÏjð ‡ä)öH™7çAĉüK)MîzÜ’š]$B’̹ ÊéâÕ®}ý¯”óªæÝÊ7ºÔ=æ€îõV¸>öz‰ 3]Çå�‚w?O%-;³f×úq©›°ÜMŸà¼U+Bž Rcs˜>š«ÇùÆ Cü×ÐŽ<ô £¤ûìk¿`ZÉÕwíŽjS÷¯IøW¾« à ‚°bi—ñý=pWkæ’,o¬÷pÂWÅÍöW—ºrë,- mX,ÂQµrm|Ó§ó€Z80„qóâ³T #è¼ùªN¯¸”™ôx&ÈNçÝlÿÏac'¸’pá›Qö_RvkÝÌùå¤û}Ïù'ÿFÚó ?~Ðñ}ZóšÝ°{v`a°£ø çè¿Áᯰl=×Öe iz¢iX›¦s{ídÏ>‚ôF*�j$-“`{M‚j>{µe;<Øä1y?¿r-¼PècE°ŸhCÚVsÌÁ×Ö£?žmZÓ¨næ3‡¬æl½5ËQ?.ÝF¿öØ™NýÂ#€ÆÈ™@2_<>ÅFY&þŸß§i”­é }OÕ\±WÙ·i?δÛx}ü÷­ÈM­p.­ÈQ ßÑäsji^ƒQ4œýÚQùã°Ô»s§õ'™ï8q™ÃÐzô•‡‘bñžvAgÕsW©Ãa¥bƒ•ºü¡C mþÿ)hŒÄjZt³ð,G2­OùóJÛpÞO£ù5Þ%b§sŠ¾�¢}úù©¶;ˆçˆ’‡žG í76¿ð¾ÏO^<qeŒBaŒ~Nc…D1æèhyUšÔ6o"Á„!,CàëônÞS¸²œ8}=òÎJ¥zðõ¶ƒWLѹCHÇ.OGsþ.²è©²¡ŒIvæ`“M×ï`ÚpÛcÚ| w™^¹Õ|‘¶ÀeKt±ÅÄÙÉêÆ4z‰¦ ¯˜Ø8ZƒçÈÊ-ý•Ãslß97ÜÝfNè{\}5o AX(ÈD0ž™1Ç_áÕÓp%™C„½Æ¡Ä ‹¶:©¤—õC8ÌZ~©y|<¬?70ö}1ÚâoÃù‡äùFrÏ\=$XĹOl¢àÉjÓ ­lÖa™‘y÷2~ЮˆÂÈyAA3…î>c;í!$ìØ>Ì€¤v¢6Á.kŠ5\ý ó±ŸÿÃHwWè›a»Åö°Äïm©~UÀ_ì¶Òƒ’e8† ¬n¦É¤YY^9ò¢þ¤Ç9g¨GA£½ÏÂ@ßE ñÎX–îO˜M1ÿxœŒ„‡Åsû!ªA74€ˆõywž—³ruËä•E”¢mþöwƒu5ÖIæ™ už‡ÔC󉤆Eó™­=r_UÚÄ‹ºK™ßtŸ–CíÊQòèé%‹ÊàAWÍóáv=ûY~SÅi0Òë*’x—‰Ž¡¦*¢»v ö4gK%„¹Žë “¤‹«üùD)$ŽÊ•½hH{;R«ß ÅõsC%©³ÙâÆ %þ6tZ„+#R‘¾+ÊñXozŠ>ÿ/ XÇÃã3ÿjœz>x¸A9åut—¢¶óÈ'eçóAÊîyÝüAï”g>8rÕ;JN²y¯Lj‹çFíh‚Ð:äØÞ8ÚrívçÊiÄ,4ÊÐ7;׃W\ìçÄ€.æ.`¬Èñó)¨' KcÑ=oú<Èv{ÏwÛáßq@©+6ñÌ^@f? ð³]T”…Ù¤Þ‚N/{7ëùÞ¨Fzñü@_Ò&Œ ãØe]1”A@ÿP }CZâ´1Š­È/œ»N=p_µ}³•avi¼¥§OëEU/ô}ï«"|·i/½ö‹g *%Ó q5Úoz5j ‹¥\;1¹—TåŠÊ—#¡8ă渽º™ØB)7sÑ géåIs\¹ÙjÅ7ÓFšÎv6Ô ÛeE*Ä‹c‚Çd/]S<us¤{$¡è6iË”~Ñ7¸TÀYéþœ(õåw²‡ñÿ`;ßXžRŽË™ý§'ŇTɺÙüúx°rñXT¥£]2ò+{JżV”.…èu¬íÆÐÝù›çš7QåóÁ0~ÅܯV<UÆàãΕUÏì˜ÊÊ!EµŸ‡ ÛÙ„“-Ñimë9Ð_EKõQ’în…Iý¶÷ÚCù/„Û`6%ªkè ^¦î‹ãíÍ+¢nâÛ€‚ YWA5y1˲8 ­½CáÖ eùt#Í(£Ø¬UV^¯¯•0³ùg_æïa·¢´ð‰ؽˆE{OÝz#·9˜bSC”‡°Îü.×鶫….š¢)‘†AÒî­égX“7A™®üíkä*Gœ^ Ý¢·‹)w»h (JVä,²ˆÙ=y;kš•˜1õ0D,ð˜šôUqÀ²2~/¸ÝÕjö-‹¸S³LôœjU̓5äµ»x ýÎÓhþÜ Œ†âŸsÅ+=¡9®w—mEoèE]̽€µâÅJ5{ÔȈÓŸ6H»Ê I쮞œ¥¨{ >Š,£ ÔY„¡û‰ªõ¬?8zWʈÊóÅ$¥‡T4î×ʯÑ"H̲)éN(¼ ¿ïúzTeÅß*¦T¡ßÑã¡/Ò]=ç6Ì2äß°ÔgÞÔ7¯æím 'J M³i P­îyʇ=à Բ¡anTƒiì™Ë+aµ+Vdõ@ŠûJ‚¼ÓÍx"›_¢µÉùŸ‚‰^å™/ŒƒTŸ%AÆkfºA{hóvÞºm} ÝåÚ¶ÁéÒ÷û®?íåJ›4�B²kANÌ¢Ì7tOP<ÓB_I½úîÌ{º¯0x÷ò‘gfæõJ™ÆÓwH¾¬¤@ˆ"íOÊe:çwèEFý®ýŒßã‘U ´ÐþêŠ,·Ë¥àõ/F‰U<Ž•ó#’¾ DÛ«ëðáѦÿ^Ð7NKÔD}G™þlJôªí™óá)C,D0agÉBýŽõ•}íþû–D^ãRõ›#´¼ä¾Á Þ=Ó3¾Žæ;}©“(|ÑДÅßõ'.¸<³u×6|^fk6<ŒÜ¢“Ë+òµµë¯,Ü"-’e–OÕÕ¹7³³¶Ü%«ïXñïäd|s“‚½—€ètP ‡§&`ûpÒ^|t”<ü*Và¥1ÒS»BQþ]“Ü´XŸ6š÷Ü‹>—ëlþô¸ë1Sé£SZ´ –””‘ê[Añ‘X/!³Ê`åÀ~ê« èôí!îÝÐÝ«yÌn,šÌ¿pZ°ž¾FÂ}?Ø”G§/¯ßÍ6…NEÉ?ȇ¹í€ƒçæ'zV@=[ùe(ƒì(6Ń’-cg˜#M““Á¼@®ñGåÇ4No(ö0Ê wÖV€™øÈ=w îˆHý,'•gQá)Vebª’ö³?é¤|‹ßìhÏSåe{•$®À€SgW1� òíÖ´w¡ÛÂ�OoŽ¢­Œ–Ÿ"AóÔ‡žCMa¤czúò8 èÀ-Km»÷`ÒÙùâÞ¥S&ÓµÓä0Ñ›…ƒíw³ú>ÚvÀËCH®(z}ˆM |”õÝNÝnôLµC;:‘z]‘`êÐm=o41ÚIÐàà}÷Ò Yló$5M ”I~j¡§M€ep§Ýç‰Ëcö"²öªê@ÊØæAâtÙ0 =Ñ~äfD±aÏÉ„ŠGØ ÎŽK,ìzÑ6ÎoÄÜã<vâOø̘c¢»xR:ÐS:+IŒòè1ï3&Êð!ÖCDà³wж[_Àƒ êµQ}óêèÙʽ6Ï Ì0”QCÇ®P+™å·7àF+ÌgšÆÏ}kãâV鯙ééuZñÀdg©{(ŒÔöž¼L ²^S d·x÷€ØÆÉ@Y¼¨û3b7JªÕì3 6—,ÈûÖkÎP1¡0ýä•ìk}$Q7?yä¡pÅY�ÚÙ¬÷ä*Êä·¦3¹éTt½8´Œ,±+2ô Ã© Ú/óKWa*‡x‡Lb'Ü…1ÜÅ$©Üí¼üv=b­cäFGÅD°çÖu$ Õb#6&Ü�^¤µ¶C5a·íWãbŸÓØ|8í¨ßjÐ9É%ñUÉ�ò¢Öêf¨û¦­uŒ ×Üü ô¸[À×ìW”妩%9F´Wz.ÓÉó­í¯ô z!éæ'³¥X-§‘)|cžü‡t\\Rö»™–ëÞ¹[ª†1ò~ÿŒý'öéæ<Ÿ»$(-º'¢$/`N0KÑüŽ;i Ž¿‘f¦"þÔ{ht Z¯y5^dÉ ãû²…‰ÅZÇQfÒ‘ÙÌLjfv|-‹v<�â¬`OìÅu¥¨Ý{zÙzƒÔS…õ–;i%wõG WW*ã4‚ˆ·¥IS £:5_01èÏž‡ÑT"‡–Yß|A]>a ƒ“eÙ{µóšŸÂ<3ªSòF¿Èø¢Ä‹| K× :·k¡ž÷Îk{fS¬gü¼kúP2ò÷ÚïÄPTšœrѯVMæ¹SR"¹ƒáoU+ó›¾#sÓí˜U&]P@ÚéÊw!qWfN˜ˆ~AÍW| ÐGa_ôyu<,Êö…öXôŸ<O|Îh˜Rz’Åt›lR‰óª=†v°ÁÇ;n{ÄtŠÞ7rÅáJ«ê:­–÷«çgj’·â„}ûz1W9|7‹¦,Ÿtö¤ïê[– êùÓ9¢WÁ •ˆ,i�5UYéé«q©»o‹ ¯/N¸®…šÕeÅhý–±óOÓ—ÄC«TÜ™§'øåÿ›Cë$ìT˜ÿG<–Ý?‘ÌX3äl´å]lÊ‹^‰[àAdÇHÓü¬Qãá鑲ŒP,éã X|†–œoWÐOÕ*\‚bå3¸bäÅ™Â0G7û˜¥«þÜè+ˆ¢êüþ$ƒòø_"ª– ×:H„éåA\ëä Ḵ̡Ỡ=ÖG‰r—'bòO{Hƒx™\®ÅΠ(+½ôÜäú¯¡I ……f »¨ âÓÙ p .ÓK?û‹nÏ™W$ÜW¹&AìÌžq*žZª—@3‰ˆ5؉T¨ðÍ`éï>=h.ß^À[ƒ¿„™å‰Ck±k™²Ø‚Á�Îm(£?Œf¦Ô�ßÄÍ/1¤}Õ™6Î4fŽ3ˆû´’Zy €Ï;ïµÿ‚+k¾2{¥ÕÎnÇyu£ø#¤UÙ,ÜÌB^·;¶,{áMÓ#`Ì{2[ÂR…mn“õg¨÷¸X#Gàç“é¹ê^jW º•.Ÿ…œÈзëëã8tÿo‘@%®ï”²Ð­˜êSóc$sßÕ.Ñÿµ'k”ç…+sQÝ}QŒ‹ÚÖŸÿAáQ2ÕµÖá9´7N2QåጸmºÃç†ÁdHV WÞ ?Ï×OlÏŒµþ¸à¢liy÷ª檿ÓwŒóþS{õVÓ×àÜ®î|=ë Ð5IËXÇÚž—3=E¿˜æ ¦KÜylú+Ή¿3¿WSÉa5i]ç¤Ã·-@ûëÐ2$Ô»z@ÊÓt/”€› ó³luþ€ý¯‰¨ùèÿ›~qXf,P–*3¦”‘o;ÓOÄs9ÕýÁC¬ó$ÐSéùwX„«,‰™RµÙÎöKG\ùÑÙîgç»Èãœ0XøÄwt®=½$:ý¶‹¹«.+bzõô ¾ã�j~ ³ò|¶¢’¬²Ñ»å^©ø�'š«RÎp΃ÊÜa%¶õÖáûçAZQ…k@EC‡ì»µÍ¢À ²M¶SõZĉ2?¡ŒUã=g*Øh9l‘:ýz›d7‚o”ÊÓÂßÀa¶G¤1$u”À{êÈ,±ÌÇ·¶¸ØPÆøÐ0ð&}Ç)êýKzFéʸFð�l¼@¸§óMÁòKb6|¬hdÌ¡ç.l·nH�¹™?Rv|@Ê)Ã5X¾G¿ø¨€qÑ4‘öUV^\ø]Vîá¦Aºë=««Ýˆ’dˆ ÃjfF·jnø —…‘oØL{€µAd½‹oG&b˜bò‘Müîd‡±Ó —êwìË ÙëÒ(Ñ9�y÷„fãÊOàèžoüKÓYcU2^°ÒþWXâYR¥ƒRNŠºKÙ~ïq8±o OÃM6~Ç|õž·Å Ì5ÌEØ‚0b*�eÛ"Pt‡~ô®(—?"ê,Raý3SGB_»+ »<HÞ§äí‹Œ½l(ÇîŽx3Snïµw ø1=\6/rv½ 9¬úc~gn,`NfÑÛîTB7Qþ.…£`Á¡ÁXI­.ïøKAµòµBÂ2X m·'‡¸kúŸêÊ»ŽîmgꣳžÒ÷ÁQŠóÌÌdx¿5y¤óÉóÍ$ªâF¾õØq?ïƒG¯,#ÿ½jÒ¹£éQv_Idï[Ïð™SN)pE9´¡ïÊ“røus£(m“MñÎþ÷æøG |BÝ ñ<²sÃÊ€|;ø„~ZÜGÄ ¤-»2~ìïø¦®,€AÏŠ²çA¡úêÊ#­ë#†z‚g"÷(ôðM¸}5I;B䪅¾x‹I綱˜8©¯Cÿ!ýE{Á˜èy¿ %e¸ÅøÌMª €ÙàÍyØÕhr¡ â3š²Ž„Ñt<VÃ*{ðùcíì /¸íî8ÝÅ)³®ÛJí“Ž1Ó]<8&x‚Á�‚YÝ�Å©h`;Ùõ‘ú䩺FoÂÃ3Ìö³³ªbÎJU8Æf¨ÕR¨|AÊÆ奺4Ë|9ØÈãã&Û“¡ð�F9ŸãEea%Eìpj/V’)Ö6UTãÐ�Y±øD”ÞäpHÛŒ”¿4K,B‹�ŽbñB¡O|ê\¿±žvg…k[ä7òˆ¡ïpD¿àc¡e)Ö Z0 …è,Í‹mYß¿¾£MîåŌςBö€‡Ù.^Ç®è÷ˆšýŽbF÷Wgµih÷”"´ƒ9€újÔÆM¬dõ\¹l–>Hg¥¶Œ¥í}.L˜ù꟨ݧ$H-|8HŸ×t0Äæ\ß]=Ê(³²ÊV8òa‚o×)_ `°fª)&€¡eöínœÄCÓŒY®tê3˜èæG‡äH$ƒ`Ù. ³½ë9Wehê ,à©�š²˜ãÿGçHõ‰$5QìBÊÃvß)¡‡¶…¾ÀEYóRrIÈRgcO_ ŸU„jœ›óô¯M/ËIˆsg–Ö/‹±Rm›mgUXI3é\ŒÐýµÅPýçA&Ä62m€b5Ía ŸïÑ«'X!T~ŠAŒäŒO*7ÄZ6h³ñÍP¨Ø_C9£ÿd¥ÏS¤X:~ÑI÷þ.X.]çÑOÛWrýû9Eè«0‡ÐÊÁ­ïO¶Œ§[Ï´‘GÅ©E5¢ã²Gks™ïI¸ZhFÈ€W` q-:ï®ûæ Ì~¸à™Ÿe‰ààV/߯œ¢Cd[o´wç $Ë«(S²ù÷vœþxÀD ¿óÔ²òû€\Yèâ|ö X˜ K ص.„Ñ1:¿ý,Éö-Ü·¥!�»2ˆ;£ª€›/¶ ÷ô¥¼K=tžÿ•¯Â )!£Œ˜Ž¢®÷* ùÔ ^¦¥•qv}èðšÅ>pÖuA'þ»¶LÙØÀêUg:@âpŽ‹ß>÷ÕŽÃÔõ$°ƒC{2ôô±ÿ=ÛÒªïFãZ|l&%è*Ξ›˜BÓšvF¸_¼AøÒQ¿ËsîeáÍ]pjRúAq-lÕ)®?·ë(qâ‰€Ä Ÿv¢©u\bg¥TöM·¬Ì]G€õ¦Lû½×¡r>œQæ`()†N(®’î•Ñ_²YFœg¾¢L%Ð…DV­Ûú´¯•ð•¨—K4ã$¼õÌ80«œ>%'=¦TEÿ镸›qü,žïØóûŸ¤ªjiœЕ;ÛAƒ€QÝc¢l&_‡Ýù6ÑoôǼ.za§žÒuX¤&¶T¤»O ³æ�¿Àœõ¾-‘=zs.PL»<ˆ¬Â:,´»‰gMTmHêêIžê³L+÷rS¶€Ä#Ÿ´eØ ãò{Á*ô*gºå< t8ÙP$Õд昿›Z·j”„…¤¿ávï¹°Ãè‡ù¨Æ8%äü÷!R(587!nA´)‚t7)$jÁ}¯ÙzÐÑÌ{óÇþS¹^n"WÄWm ÃT‘e>:ÑÁýï[ªÒ»€åђ䶋W7顆êæÞQVE&Õâ;mÇ'e=x~z£JÉmlµ·þ…öVÌÚˆ¼¶Öz9ûw‡‡ùàÖ¬¯R’2§àÔÕÞÕª(óæ°h“T¨ F¸5)zR•ÜËáLU¦÷+~ú3šºÍä„ôÀºcV0Tš¦¢ OxGY3ëw|ÓÂQÃø8?õiÚ?Ó¸ÁtEÖ$™ÿû*#UÝ«75ÁwöÂKôe.Ä‹G*ÃÏÓ§RÃke0ØËãÙÔ’½EGaù¤Jyõ`Z3ÇåTvL¦³Ë8AÅʼ€+‘ùê­9DÀ¦›=»ùÏÔì8N?zý$VF$3ÒiðÌOÊ5¤ ¼=`áQ !Áþ’VVêê8¨¦Æô°z¦÷Æc�×-º¶móay­ J­„hWd“µƒœ>#Œ˜ÿ÷HT8q4@QMZÐå­Ø¹6’^ :ƽáX3}¹ÓaÞŒ§Ç(ñ¿yÈ}®bs rª�Íâž6p5X¨"/½aÜvÚ±Ò q^\ô C¼ŒÙ‰%Ì�s ÜÕŽ§ /šÎMű§ëoqèg™ô®#äèÏWO-C �–´öhonR(Æùåo-iéKH˾ȂèÓwZÐËfuú—œ}|5 R¸“Ð^ûRÄL–0·ó•qÒúœd:€Æ‹¾(¦ZKÓ‰vJ¾íÎ; Ø–û~ê.ƽù‘Z[”Y­40K~ª=]/:~‡ñËsÃ}úÍãÕ’äº#ÙKkÞ‘‚Ì{}‡Ã¦6#ÄóémÏ7¶5Ýwý"]%ïòNåPY4ª0³º/Z=ñ§~p<³úbä]ѾXðg1°nJꩶЊq½b¯¹Í ·í’Å»BåŒ]ê|ƒ%ç™™'žséÌA¡Æ°­91µåiêm7ÚÂcÏR{U¦ðà|<ÏwúÊ£Jëø@ÎÝÁâ*ÏsÑÄõB6Ùb“I3žYÍ“ñú|4I<yØR°ÀNlk×5$ *?qŽS¯tFëÿDÏÂUóHŽiYM¬ãÛ1~³b–GRÆŽáá_ÕÌn0›™¶DÚŸ=”’[qáÖå?óùÔMÿ`¢vïo@,g�)Ú¸v¹™õ‰!1=öúìÀ8¡À>ŽÎ‘ö¥óÿ”Sò–€Ã(ôûúôUŽ âlÌK ò•ÀÜ)£û7*J*ûl0/¥ ‚iDÙ7nB³¯ÿ¥[à ×¾Íø…êk¶žÊ$¢¢}1¢”–Äšf¯I°ERGÇmÓ°ñµ2 î¦"µ[ãߊ6ªBÐænÜ‚hfkñÍ(óSvè”A8ÍfS_@÷BÝÅÝ-yÓÌô²` %Õ(£8%µ«ôBDàúQVyÃw‚Љ–a7y½fÀúNj�³q÷òyÂ;%¶�à–£%mEÖ[6tZJKÚjt®‘RÆX@ôó|ò·²ëÐ!XþòüîÂñ›L¹¾l)�bIêm[R‰5—­O|Ù“Ø:F6\`·[\¶ž…o®‚Ål×t~B¯D^á®<ßö“"`Ú3¯™Kˆ14섶ÿ‰–‰Äü•—¡ÝL±áå´¤)ÛöVŠüùÃ`†�sÝ$…¸‹KýС!N{£ÎÖ�0†åÀÁ#[J?Šafïë듹—K™Cô‡o£½mhñÔMcw£ö~v q2»‘A3·!ú´*ô­?§t¥ÍäòmŠ-ýo§ÅŸL…üb€b¦GÕÙ‡&(f¯ÂÝÔmk2ÑúYô Ì]‚Zñ#«vètôêþL»Ù„mþÂ2ú›/õÀPÇ›WÜGÒ•§é¡…¯ þ‚¦þ0ÔR2VÝê;ÿ\ø'I¡¦XR>ÌKDÃÉ˨)Óm,ögAOðÖöÖ‚Pí”ëø½ KÙ¦jÝ®ŒÒŽ‚‰Ì±Ý@w5úŒ+Ð\4ï$ÏÖÒ²œéùâI=Y‘FÓE¢»aI´ÔUòå©Hæ¡5*ö|-@ã²R¥‘·/]Îñ†),ŸúëŸâm|ú"ëM^hÄïï:s„"‹aCÉ_`Òµ/M˜ øyy§€<Pÿè¶^>°6fzЇ¡›ÿ�ٺ垨"à®çBUä>§…ÖÚØWTÁ,ža8O •«nMzû@Ïš-ç‚Â[FçÎ3K'ÎÊ0žmEÅ”??ݸ–%žÙ{i³HÏcÒùEï=¼»¿¤¯/°þ…�Q–¯ ÌâªR̪)A·³`6š ²j(Ïàøö²»Šº€É¤@R£v kë­—r±Âg,ΪõLgR/huBrÝýC'1Ö%R•/†U _ÊÛOá�Å7Þt­,ré Ū{¤Úä˜èí+Ó•›M–gsiî þÙAÒž<Ž†¾¢GÚýA«!rƒKIÜécîÛ˜•‹£9 +†Pчò¬=^eé9õm> h«î  ·œ<M^ét韽|Ð{Wn];â=[›mB'ÀdÈcó̌Ұ\©jW—Óžîj[¿m®8÷ïý/'òˆÁ“ÔN»A]ØeÄ]#‰ÿ¯WMiâkÅFÌÕ ÂYr}^roƒ*0íîÈ eQE¾X´œà6˜%x.Ý°ê0d0*>ˆ�ËzÒ÷„šå®™ÉH`¦§­×hëEVÈcÖýÿˆi¸ôÍH«õê3ÀOÜ$#ï½Y¯j©!ÿøƒ,Lâ!–*ÔUsÄM«ÏG>€äl…l¡€w\¢ŸøEGyîK nÙüQÅ PT–´9œ¼ß°ƒÃ·ý¹?ÚŸœ¶è#Iž•*SF…šN`³¬TÆFQëfqÉg¾µA¸ð²‡ŒËØ\Aqˆlƒ·âìþÀ3iûj4¾Wø6ǺœBqî‰Eð<:Ù$¨ô5Üupÿ”ÇbmÅUìyÎazö²8ºeJ¾ Lrª/¬Síq°ÜÕ–-î…„U@<Š¶ï¶PAM,ò3r£O<¹ôÿĬ'uY3[^Ž_ vnm€„´Åî Ò6b%ðT¹¾‰À-`rä'ŸÝÙÍŽn Dt±‚úlˆÝ¼ ÜVÞi…’eþz€Ä„¾ñ—'WòÑ]ÕeÂÓLº}5X»2_ÑY0Zåaóµ7=û­Íå°y;TGþ÷-6Ú$0¨tçÌsDP –Á(«Ì7´JP‡ArÖ2…QSë,¢ÛaÇMY0‚Aw:¡@6<3M’ØoÓD)D¾Ò ùüôîÐÜ[« ®RiÙ¿j=–:ªžŒ9ögàRú‹WñÖ㌑ÂD€ÍË_bG~L¤û Ó½21~è{ʹ–ô;ZAòjîUÒz\?–™_“¢ÿNû YTâ ^`§ºUù0I+O¾ŸÞiÚÑgNæÅ,) á¤(“.BF™Ü¥³T{óoa-§;/”Þ¤²À¤r™©y_<rÝÑæjýñh1‰D,ÕL°®5ðÂgÚ‡q戰‘Ø‘Žt¯ úâ¹!?|Qú Lü§ÿ÷æ7ãÐñœÝgž <ÚT]QF<×¾« å>ý hw)8ÝÕ~<3†Lw»¡?�,¡°ysòÈ\÷ÕÖÄø~¿Õgã ýL+úOlI ™=ûÀ@>©rNŒ jz’´Ñ?l·�³ ì1iqÕ0éSÄÀ=SjœW…JéðØ`˜â,(úÞ+ã¬N„1ýãÃE–‚¬»ÖDÕ=eså"?ØV¢ÚƒQôÞ g;S~ï ¼J~¡÷UfkÑÃe S¢jÔ‹=¼Y–~«q7DÔe§ñ8Ð!'§'å@'$\ʳHTw*7CªÚä¨?†¾q=Y®¨ˆ8zR,ÛŽÝGìëãu¥K‡'›m N@ëÉYÒR^v}=33 •R,½î¦ªëƒK_‡A +ÇU_ó \@××Ã1E°×{I’"*·ŠyÞÙ`‚ g$0å¹áù¶]¬²Èƒ´_<ôేý¾­‚´ýòÀzà5UÈÑÞûþ¸=`·?)Ȩ̈üR<9˜¦j·uGŸ‚¢Fn,Ö#Ý%íÎGs÷’…ÖoÜ~Oˆ.ÉE£ ÇkÚÛ G­¯Éu˜?:ô[îø¢ÄAcE7áHåTÕ6+%Mº9ÌÐP¶Á])Ç[{UZä7™úf¡eÚúªo Åˆ 23¡MZ§ÓrÛ–•¹9ï ÔuèÄ’ h‘µ.‰ùuýb‰0±éÿìë$(?;¯�;L š©Ö€”š èÀ{¹£¨§BUƒÛš‚vþÞZšp‘S«œL%F‰Ê éÿtmÇ}nwõ@..Ü 'Ämg%OP„ ¨qdÇýkª_ш)æ=Œ¿W±'¹±·LÙà6›ÿÕß‹°4Ê@Ö®NgqûÌìÖîR>»«à2SiÙé˜1«ÖM§M__÷œO?z´º‰cl†ðóð”À­gõÑÓ£sÐü%·^­Ôž)Z(_sù†U}´´»'‚àx§UCñ­Uvøñ•ßxÑ"3ß‹ŒužI¢šˆöÀºï=„Š,ºß³I³Lw¢Gòú…‡>O–„ÒZŸ“ewƒ˜¦%ø¾3ó*öbüǵ§»Þ’¤]w:\)¹ÐN§gm‚vĵ8JÌû󲨌âïvz–û¢c¬B‰xûåA,OÓôÔÿ" ‰ð¦*ÒUA²«Í釬z¬?ØÉÁ‚¥å\ú¹ø‹ã•yHÙ³íNcAÌ æ¦”ɆèS¤‰ ÁËÉ{”…~B à=MÒÝ¿NÛ‡ÿ+ƒöŒ¡=Àràítž(_5±ý-Κ=Eʤ·Èüa°¯´_¹G 3yâã×¥,œw–ø~Qù—žf§ÅuìvµÅâ¿; LÁzTïEYz£§t¤Œ£ZO’ÈÔ¿æ]Ï“Ø´{ã¹>uìùÙ¢Øg{ºó_š<W<‰µ¿@é,ˆ/ôû«"»ÝwÛj×hL WŠ_磄G*.¢¿ìTáýrPQ˜Pêá90V>ÌÝoõ pÇWëÄ,µ¬í$Þ1”ãqÀDu?»~;UÍÖ\…2hŠ$ÈYî‚A|nÕ „FZE€oÈ[L¬ºý‹gxç°¸14C?]ÎÇþï<¬•Ö_´ðýŽGat’?([+œðL¢ºçc/ƒuø…tRúƒžÑCÝÇb” QµÛm=Ñž¾^èë§ýµ½nºÃty²ï’([É>¢5’†Aj•G*W‰j­WY þ$"í?zá…±'R ÇÖÜz”¥‚Uœßº¯e:Ï ÒZ:ir9_Wyâˆíç…8à*5ÄQa­Ø1H<˹µyÉo+y¸’p'c‚ ‹/l�ÛöŠâÐ œæ8*}Qi*2NÅ’l:¹0u¼}N•+÷kãÀ’«fðW`4 ®Úö$MjM_ºu0€ß&>ÖJ"ŠŒNy‚ÒªæÄ€¯ø*Ì HZÎô]°^¨ÝT‰ƒ%Z1Å+«+‹šzÇcJzZèwžê3}û3;YþE³3WBhIÐ.PÓÕ4A2 ½¦EÉž`Ýü¦žø‹bj£ÔjXww|…׶Âaýü$ˆ÷ƒB±“ô<¬åxL,hä_>Èäã•ÉW‰0íÊ ´·f¼ íà&7Hv’•8ómôæÇÐ1ž+“ó¶Ûg*j䜄 tRŒ×Däò©ñ L›{¿£0¸û4û”óBgDå¦ô¾íÕ÷ŒÉsÒŠ’Ö¼)ù–Ù –_G°R8ªœ.°B&€Ùo·¯çÍ~{¯þ5ˆÈyØL¤K(A§ˆ[km^%øÜŠVÚŒ§ö†™3Û×µø³ßyÌùy^1à²dNeR�öõZuë.­èÉ+ì4ú&y"iÜ):Úqù¢»-ñp26S}Tá*~¦g 2´Gëÿh¨U›«æœ1ÔÍfà”ëÓª\”ÈþÆ w ÑC»f¢ˆ1HáòÓ?™ÌÓ™›—pë*èÞÙƒ²§n Û)ú4´ç<s.gÒåêFˆÒBÚ ™Ö.Þ°‡ÒØÑzÝÜŸvß|[gPR:1ÏÐêøWÇÅ8ÐhespµªçßœÕïж.V`7{Ï‘‹Xï¦3þ½åŸÐ1U<<Â’/)=ò‡œÓî08V~°Žÿ$W›Ê¯U®¬ÝHdà+Š4‰µkJ*àƒŒgðýdaþ,–f®M›n~¤õ»gdr¬¯.ÞÜ*Öè«‚üó•ÃWB»r΃ÐÊZDl^EÙ‚X[þª„¥ÏK…¯ìLÃÖ¹û—~Í¿ |{ bÖc—GÌc¿™¹ˆí`‰éd™11_8ÇSü+Ô mæESÌ�7ˆ(û°ÑÀÆ“{WŽÛé~Üed!Ϊݚ¤BŒ“i¾É„ñ©úfänD(€:@[:;Êvë óÉ�"_ëˆù²�}åÃnÏX~¾'žù¢ûºò<«‘ˆmÑÔåÿ DL‘–³™-p2ª/Òìéë[é§üVùu:‚Vø¥°!¸1Ug®YGn/^ƒŒ—R8 TÄ“jÓ@¤]?šÊ–§¯øã>ì¥*²Õ8¼a.½÷@ ÿäòQÄ%î6ï+M&qæKÆÒ~e;­dP_;Ö"®Å Ö¸#_ZöÂyÑGËÇͲªÞ°£¥Ò èéü×gx‚ÙÜ’'~—zšÇÓ‹rä…³§mµÓÑ XAZ�ð2q«§Ž'n7¯kMìÒÃmª‚b¯©y^ZyOÇè…k:lB0’IÊœæÆÚ,#—<ÖVt‹Ixæœ�Ë~o⇭¹ÄïGpæǶ嬌–X ŠB­øÝŸë2² mî »Éújg)…Á“p—OT‡H1lZå‡V†Z\Ÿ¬„¥ŸÂ³PËa‡<Ï"±8›{ÔOCÒ WÀUü<ƒí5 {«‘¶/‡?®i]àcÙ¼<Ö_´ãÒƒÉl÷µg©BãLtœLP±àšP6QU$ΉòÆðÆÂ/R溼qShqfÐ×?q[šñEÇ…«¨ThdqñçälpgßhËìÇYºqÞAôªmŸäsa雡'¼ÀŸ|Pâ<t»þðo eˆ7:‡ç˜ÑvÈå•tSèÝkN£È=fŸµA¼DņËùÝ›Ì6$ b•™:ïñ¥Ç¡)½H„'Ê­Šdhï!VC§±óì‹(Ž|Wà¹{{Þ{ƒ|îKlTÿm7ÖòÀxÈfbú“[X1 TÆÔg0+FeBb˜ìwŒî˳—¨!Ù¤D›ýÁ Öïˆs%±G´ŠXWþ˜i³un®’k!3R‡Ó×q6J˜p@ù©DWä=ã”m+Xbòýâ@G@oÞ6g¸öÙ8C¡ks>=ž¼±ÑòáÞ$¦áb¿h0àî1ÒUëŸz°F›æÇ'­MuóSӸℋÞŒ×krÛ³¿ªÁùPÜ2‹åozF¥33’ DÙOó2šžK®”l–=²þÛuî[ÑÐoäQEK©lJ'WëÑyο¡/iJ:Q$Bæ¦Ûì¹; lX3}£ov~¤‘*b#x&5q/{´5@ãWÓ4ˆñ³U½zƒ½%ƒÓ¥{ô·è`$.%,æF_#éÕžSKU¬¶¯é„›ßL×Á”5/"ü|.ã©Ð⪛_¥oÿ¼UwdFl„2SÛ¿@:[nK$HçPÀI¥5œAš ›Gø?R°†ùÏà$+‚~SÅ-^ ‡’ÏÁÓD7 'á3³ãÐ^°½¦ó®ã&ÐacM·3œ<ôu}àºKÄÆ8¶“aGŒRmtwñî)[AR©ºÛÆ ¤´‰¡–á&ó/o§Þóf=Ò�“½Bƒ’"pÚ%Ìnƒ<O˜õ¹7õ l(Bžvÿþì9çð×gËzîö nU >ôîp´âÄÞÛ•  èÕX“ry ¬È•(1Ú1¤±§÷ÜŠûö7áª$ó„æâ‚’kº¿ç^Gcâ%ÔÏ«bOz c/Þvæ5à®j̼I¿+u|é°Òž-'Å+„žæuóë)oá‰Îqâ3íèŸï¦<C×i¤’wÀ½š™!wOèè•>Øo ¡\µÍÃ`Ð塀÷ýÜjs¾ú]+©ëÖÕý¿õü…¤¡€_DµTÒmÜÁÔmp¬äæ^d®;Ï™ø>‰ƒ 2†é ›#å9׫ŽªYTõ Å—cݳ­¡¼Ø–a²R÷bt 2”®,,Øè+-tQßW-J 7GPAœ;,�¯Þ o>·"Hc^¿Û«æ¥£²ôëü‘P1¶xÓ؆ÙÁŠîá•~@.ΙN¦õw)-º´m£ɿᛊËOr.q­ôý Ѳ è?EU²ý])'$å‰ @“2ߌõ‡å9~t¨ž¹¯D9KªÈ\¸“³ÖÖosáôV¼ÞØq·÷zØýái¦«ßàüdêq¶˜§ gõþå¶ R.¿Óü¢½CX%Æ>}C7ªw^ûFªÊ™Y<½²i^dN¤–îíÇi–«& b¢A Jo5c0à°×ÿò;?w"4¬1°|Òxÿ²~<QJMWÅ<M$Álj’ò«ÿºR†‹,ýJøú)TÜèçvç!’ òIÆF×n¤ï­/EÊ’"¼q<!H”ÝbN0@—Y=^©ÈAw4 Ó¹yÇ´ˆLœ@‡8m-dq‡nÌÕµž ¡¤z0å¦}À´¦²UeŒùË*й*ή»ö3˜­¨|w(]Žtì:/5ç^¬œÕ:;{:J£[lì@8­wίÀ¸9Z{4ۄꆩ#¥7>R1^.žÓ(ࢾnã/¤‚œï·J �7”½_QÍH,âuÀ¦W¬»ÖÌ^ø>!B»sTÎúZ>â‹@ܬj#Õ‰þ²`ôPzŠP§Ñg~šçE}¾»4ƒ+T•„¢@/ÉõËç“Z¡dF­½íY:9±O=s úê•äαC£~“$ˆ-{µù‘R)HJ÷ò§kÛýè¡á f‰xqDûYçþtp|P§Š`½-ŸyaW…í[GÜZj¦,ˆ&í¿ExÓMOe‘¸ñ¦é¤Jo¡<EèeY T|åAâÄÍ)†œ‡ƒK4–éÀ}Ý.ì–bŒÇB qèfˆ)[Ó“ =S`1e¤ÎÖIÍÏrýXsGÞÀ¯ a¡Û3ìm®±Öõ´Kç§$F€5fÊ6bö0Y…=l‘4kñ—0$[@ÉnNk@ÍW·ž¿(Ÿ9^`š–æîëŸêé<ܺšøM~ÆÂå1ŸZUGobC¡Õæ|Ðås¹íjFÖ¼Æ4®"§*ÁB½ÓÅåä³ÍÄXsÆ®¥“‰Â›ñd¤M6S}1ÈeýOÏ>v~†“µ¦ª”‹'É™,ª™ªb¶pøeù)òN^sŒFQ'}<°­õ×ñ,cPA[‚©™Ú“–ß%úV~ƒç±Ø§.¦MÑ+ÆLÍŒ›ŠiR{ 1Gq~lFÿå¦S‘”N.Ÿâ‡6v5/ž&ù|ÝÔø8ÿøèà>'êïW÷ªÁ ÀlŠÓ#ìÅN:¦‰`¥hó‹â%XºWàõo¾Á³š¢TCû®:]-�8­Qâ�÷.³ cÇ –#Å…»]j ±Ðï¥õº¹]™”¥Y§¨›Ì{bØØð l&i/u?4žyËÃ×É Ð©Úr½±çX‡˜-¥…P‚:#kcˆ<Ù+gœš†ßiJ)ÍVj‹«‰ù£SŸbá,»<I‘"šÕšµFi¥‰ƒ1"u×S5~ò„ ÿt{�>ÑTò5Œ‹ÂC3…´ oÄ š›š”‰„~îˆãØ íá´Â±§Þ›0aeó'Fåº÷Ô‡zîÔ+ì™[²M8Bf‡ÐŽ¦"—ËŠ…Ö¹1ÿ­ê�7Ýnè¼jø'NÛŽ8¹ÙŸÃŸâƒN(8‚úÌx„OÕ¡î\ñK#K³uu.DeÖ>/P|IwF$|¿x°”m ‚Â_÷…ñG»õ±n”#é@nÎtfÈç]~7cNc7ÚàÞ|Ÿ€ì|ñ@Õt*Sºt°³ ¬]Š°öõ>²"=«EƸ/uÉ:ÉN…¢þåjÇ•Hi讪ÁîÍsG¹êˆÕúS´‰Q|0¼šöÞÔÿ‘©B=jèÃ]]”7Íž]`碸ѥtˆµ©áè.[{:£kM¦½øÙ )ròrØ@U/·dfö3Á)o'0?K9|Bf4玘 eÓày™óÈc‡–~ïÊ2¼c@¥Y %Šî_e\uv¾¢í«šõ‰'ùÆ»1VÙû»kòó™Ð$˜¶Ö‡U=ÒÀb%Ï*3æˆÌào0)ùÒPa8‹ zôþG~òé ZCÕBéý÷5 ¬]OˆPG˜•×â<€Øb¹†ƒâÐí)Qʬ‘’‚Ë6 Ò­¥¶p÷£û‚Lm=}>LêîGù.M8ãÐ0%/[”ÓV;G"F§o‡AȇÁ1Ú×þŽ;Z§¥O 1& E£3`tDºÞd|´h‡šE…~eŸç©¶]T‘%>©ÃóSD×ù¿oêÞ`Â’ýµw?ÊûÂó1k(°è{3{ÌdêÛiDly¡^x€úLØeU¼OÀeK1—]A•Ï²Û+aô^,4] ›–Ñ$Û¶5÷&r%3¸/·®ªã Kõïr§³X$¾h3…–KMo½ÿò$w)ɦÚÖ³kè™—ÏÛüKcUy÷+ÈñºDGd:Rîת?DÉ¢¾ÞdGgM-qªÚù×À®ŠïïÈÄÂ>DQ:æôÞ¶¥–IÃîèƒú·×ûk¤0Æ–ë>~AÙÁPq‰¾<"Ú•Žz|é‡Lx¤ù”¯ê]Â]ª ÜŸT@éd“zÈib¦™m%³Wd·ÇmV°GÑa\†4¨:ëR0uÖ–±ñ²> tO¨°PCèlóðI'm:� ý–?õù‹ 7JÐ/¿kì¤<½ Ì¥q²°µ*(±éë\ïÓ¸Fh²žåæÞ˜‚“ËMCï=+J 6ŒGª£Ù®Õ`˜Æso KÆfÍd àÕûƒ­h݇@6Ð䙵¼èÏLmÏF/ý¯„ ªÂ¡ ƒoPjà˜§û(@¯0Š™vŠ ÏݶB5³½"|èDÁàÈàÎLF”pÀ¼wåV)Rˆ”Á»[LU­\ÆØÝ–¥å¬¶scDýÈn;Õ›åÙÁkXŠÍì¾’˜¶ƒõ²*VVÕî‘QÀÎœ(SIì>ͶŽ½¢$Î#Zrý<štåïN±$vG¡¶îè½ØÔ‰Ñçù�ÄD*˜ÜÂpÆò¿\òÒ­�0Ý CR®¼èè+uqÚi‚ 7%�,<ª¸²Ó¸°TÝ-Î…fÀÛï@k¿4„vÄ™âÑypd+^ó‘þÇ#Týªœx6>Ü1úü‰5qgü¨ð8Q6#4Ý8˜;'ª{.蹇e`cO†#¦½`l‚~m=/·£¨£ Ÿï:óÉs ns†Æ|ùuñJ-y žãßÅø\°%ð  ö§ip¤š!´Êú)K,ñM{Š•Þ4¼÷¬ÝS¦.UAyH %æLQî@Ýbñ` ¢yLœÍÑ)Ã}rä@zªjÛÆ2´Œ»šÌ¤Ì±æjVÏ5ÑF¤üb`‹çíϧ”9Á3¥Ú^=Q‹ãˆe¹cÉ#Ï‚ùѵP,X4À´&k£[xyÎE·úœ!<b:ž¦±×Š\C·ª—Yö(tšÞ¤6 }‹ü}qdÔZ`P[SU*÷¸»y]µ¯*—4 óy.ƒb±S5ø,¿c†ý¶Ã²Xq!Kðý[Š^™G ¢È¶�d5·®ï'_EÀt(�øsé“i4ñp¥ŠmcâwÆå:'“&hwýÇ,`sÁÍbtê©Od¬RÜЪʬa(nÜ¿(L,ÛpqX ‡M0±?˜&iæÓ§Bö`J‚b¸ºç´9ÌNÙúEߥ(tžÃÒ¾ÔtL—_g3à3Hí¤çE4JÝÕ±Þl \Ê[Ýjð–—°Hö}ÖºwͶ-OFÌ{ëaõýâþafY ¸Þ+ÅØËEËÌ8ð ‘ )=·j ñ#œºî:ßû+ÐeoÛ¼ÅÊË£`eñì¤îqúÎé!6èVB|n á@ÜÈ?”·]³(5à{4/¢Nͪ nÑêÔÈèzϨ1‘5ŒŒøÄŽuÚöƒg:F ~Xè­­܆YmüD~옥V�?7Ý€[â½RZ•æ‡-°¼ÝÑSgù ×âëÿ¥, 4¡qÔiG (¬ÚŽ¢1”ƒ*Ò]îQuíÄ]‹{^±¹C‹°ûoÓÒgÏš³WêìkôY¡›¯ì>Óèz¡ãå¨lWMñn³¥Ó t þìoúítEx¦ )Ú雞r¨W¥Ó“4öMÎh¡Ê8¥ëЀ§',$ú‹AJ¤8LáÁ'h¡õ~ÓÔ–¡hÉÊ]÷!¬à̬N&º[˜sRfk¯#tè£Æ’˜K=’þ¦GŸV¡Ï¶ ‹àc‰¡´u¼³šª’3¢jîLõŒ×»ž®I¬X¸ùJ)EbËdÌo8Ú”T6èîŒ3ÖÉ3?¿r-7VÐwJ°,kG¡ûüïÁR©öe!0 WâU÷…g]낧/`ù€#u–ChÜÇíÕçõäâÛ ‚01FÀ)::{O£W.-7.Š:½¾¬yzJ/èÅŸ•ÖgTnnñã[ƒ‹~èåž5\, ÈE~êCĺëÀ6»‹¼ü ®“3É+a¿™2¾Èت*¢|‚x>fö3 ÔÈØiÁ¹^2ÂŒ’ÉÞó2öô9”æ~ëZñ8¹¼GaÐîó µÌÍQÚ/fà ’_û"Y¬_L«ÞaŒþ€©Üì-|Oƒç—Ä9çÁ^}‰æ¶;¡k²íصÒBŸ _…æ†,ÑvY¤€n³PJ”Âxi°à"Ÿû˜8™£Ò43´öÞuKfL§îN{«üzJ|‹0¤dÃÄwS e]4"o©;r9O—óÕ?u2¬oJbðtýuºæ/¸›˜t‰î–×±RöŒæLÓÿÆH>rÓ5#¯–íÝAá8i43sîùö‚3[£³¶}x ¾T¸(„#e[˜†QÒo°ç!Ïh�4“ÁºŒ¹Tuã Ÿÿ£§|ŠACŒŽöëΣ»œ¦q>u‹‘V¡G¯>ñP¼°ÀlK’ Z´…³±Ê.:]EÙìxê¾D긘Ûæ³Ü^¦¼eIec ê`Ò‡Ú~zd|º ºBº»©{�}^ÒiÌ”•‘v¦ì…¯b¾5îÂPTÕ8 çåTí…H”ub õ á ŠXV_Õ4{Ÿ½“mi]èŸWK¼ùŠÄ´µÓ@ <FºTÁ©ö_\²’†Y‘9#r„€2(/;8¥ ¦òš p9´û2ò‹éÚ™ô.iÃ÷f«M එÆ%sïÛùÞ»Z›>ºïŸcUÒá@Ф³bîÖJRif‰ŽÑ�V­ù>þò¸ˆÒØHÜÆÙŸ*¶hR¡ÒþLëHLº«-—Y¥ëͨ«LoóL‹åŽŸ„ÐŽÐ2Qȯg—yz‰Ú…ª†ÊQ q9w š2óNîOpfƒéÐv 9ëç<ÀšLÿÕQ„ D¬ lOý‘XPT'¤‹%L»ß°ÎmÆX™º÷4Ñ'}¿zê·ž`”Ê(ZK_Wå{œUqæ4Y5‡R¢ídö½ 4³ª­ôŠ_:Pé^T¶1'J—™Vãø¹ïM—fwÞJ>?ŒË›Nw[3 à_[p1 ¨¿ê8ƒ[�ÒDÜAÏff{s¾Â‰­)@ßLJ.íë0Ÿ(µù™?:(Î ý gèrãSÄã½b‹¸”¨¶dänÌm—øa·8 C_ö?âN˜å³”+ ܳoY€qÏé$m¯{¼ÈAã¼y0ô*O~Gφ›m|^jWײ½ý±ðzDœ†~@a( 6£%—‘m k]kàöõqF^ÆeaÐ4 wT\ßM›Sœ#T– 1ºô¶*q[ÿWÅR•‡‡•Â;Ë]äýà5bxv½ìÇáꪻ—’õheºB§Éø• ×¥ª‚5êúrX†Î8Ã>~‘‚ÿŒ:f?ä˜æ<øÙûJ¤8L%¤Ø΂Z¿S”L™o°?§An™àP.aÒ㡶Š‰ÿ“fºe?Æ §§0;ŸÍžž®-¬{r-?Jû² “'roèNÇ$Ⱦ”®È”¯³ƒMSRö²4®¡ÎI©ºÑGi{—:é(#?³¦ƒþ°«‚¼Uj¨q6Ö¼‰ÏRqÅáÃæÆN¹æÃQV hzi±™)KMÂ4ëž·«ñ8ž>îOö27ö?&ãi­Ü'TÛ¢ cG¶ªLú£á¸Õ 6î3Y0ƒ[~]´[•ó~ÝNŠ~ ð¼¡~p}S€âèG[ø]&Á kØ6B…ì)žâS7æ0×î·‹ß 2w»ã,S0,“ã jòõÕóké[BR ”¾Ô¢”GäðÌ+0Tæ†óyËÜ!œ‹¹U9í YëÿcàÖ©‚/üŠí4»;xéXUL"1Ǭ- ÒOeÌSè0È°‚÷(@0„éaÿruBzœ_V÷‡‰&-ÝCóí®¯|ÿ³CefÉt†áVU{Øn¿½Bl¸Zw'(8AòuRÍ’‹^ú˜JØ×ÒŠw÷䱧^-%T7ÐW°vñyó¹z±s‰Îöh%YŒ³¢• iž”x4‡þ§VŸ™šNàek?ç7&ÇjGá‘oKA Àì:צwz÷ƒÍé¿Z,èyý£P‡no“í‘Éô¼€‡n}zóÚMÍCs›pTBŸfö®¾áNS7"‹ÝS‘ –r¾Û�1Y“Ãî;zÈT9¼…‹ýùøíËbEpÊ¡žQÙd%ÈÅŠ2ÝhøÛyc<E_Y”hO¡k×ÓBAÒÌÿWŠ b½¨áÖ{íqC`<VÄk@K áŸ$(Ú³22:M×9ųþ¡Æ�C„BÏŽ9rŸšÇš’í.H§Ï²KLô¼~©Þ]e+ë©u¯Ãæä¹Q,‘H`â�ÞÄÖûG•k«ˆeż›ßmï!֜̎í©ÜÿËÞV‘õ¶bç�è¡d­6Bࡵ/˜ jÍùpØøˆî‡ÂvYœy^…kÐÉuþòBÒ>XÔq£ë±#½Vû¡ïýôKæ ÊPªÀvÇi·ó”æy ï„‚þÆé8‹WÏÃ�‚ÃEÁÒ[Zï£÷x0 <ÅXén°VóE½mŠýZOç\l‡V1¾â<WA¼ŸUNµpë³Üu^w–딈θG?ƒ¶r£<Ó£§úòR`‹Ø1¢?w’Ñ»Á‰Û¡˜Õ† ÀOÞµO™„ óà·Â‘.c4ê|ác<aµÖ(bNƒØ*=‚5vóø_­ë+Œâ ý¼*¨lÚ…&ái¤âCd`è?•Y­½x,¡ áó�±þ)ÂqJÎy¨„OÎï}ª;†8Û‹‡BÒ9¡0~i#ço³»VHD 5|Peü³<+\£>%ZüE¯‘Y î{k›còY|¿‘M¶2äQnDŠèkPEÙµŽ›EY6ëøp™Æ/<Cú^ e?|Ÿt%‰ÍBpØœ¶I7…;A¢œ¥øI9ÈR¶ Ãõæ(Ѳ5@TxNrÊmÆKsX¨©ÙEƼ÷~ìùvÜÐiª¶ó¨ÚΨ”×®¸´ƒ  ÌZósq÷]f3HS®ÜÖ5³ÙÎë#È|’e^ãŒÂéf¤Àgë1`w`~3Ь<ÕËÒêQ™Ü4wNc$Ó²#Õ°Þ! ÑaÓÌX·¦„µñ ,«ÒËc£u‰ÎAÚ¨ªÌoX»6Lhò†°Ø³7 ­‡vù‘-â§;^gb´ã)îúŒN:ª=ýT·-\É�sz¦:_ÞX§ÃoYÐØß…þ/5NrG9ãÓq8Auúôò”cÝÍ{ªK¯ô“ằ›vˆEµqà'o¹þÉ”¤ŸÁ¨ñÍ‘~Á¶U}™ÜÈ·5rGÍ·š Ót ï^Yìlá5KÖÚ§´ÞÏg¯uE¥/Ë= Åt–`—׋¢‘QѼ·B3¸ï‡©~] #^YXÃnJRÏ>Kä±ÜÃŽqx,o20@e«òv0%#eº£Ð<ŠkÕ_žl>O5,¤ù¯õ"c¿`«IÐí6¥X½³¹é»®W~‡O¹ƒ@èqŠãöÒxf_¨oŒÜÿÄkÛL±ñbî¡ã˜ž¶n¾!äyVÿ3“\0kÐ)ÿÿ³ö&Û­ëJ¶h›ùîÝÎÙ9XMR¤ ›¢d’Z²öxÿÿ/f�U{¼#¯E{-Ë$ˆbó‹¿Ã>ÙÔ`…Æ-”ð-ÌPdœïý”ŽM±¡eÁM®‡BQYù:žì®IUר㓂ÙYýéËI†¾Ô[D¸°AÑCËØ9Á}@Œïdúî¼›îª4%eìÓÕn×ú²à\ƒÆ8æ.F=è®7ÃeIî=Ù¸ùM_Q£Tä2n~œÍ fŸ;>äñ¯GÇÄ掹‘ÛÖ%Õþg¯LßÃàTE»v#=;óúЪÕöh_Cqm{±Ú-F$n­D»{â‘XV^Äþ�jY�šUëožÈX|ó©¡}í6î~_£Þs¬`¶3å/T nµß2ïŽG.oè`§bÅù ±ÁT¶ªœûÀÂ#+³ó‰I'ó ´Âˆ¬_«%Tù‚ÈýöŠ+ÚPçß3ìœk_ô´Â3gSò‚ÖöÒ=køûX½,v§"ËAP\ª‚ÂÚŸªWïF'çVËÖ{ŽœÄ„]TÄAÕ(5B,ÅÐñ;` â"vÍÈ»M$ÓèIÇnì6,ú®gK”ªc0“èÁöƒU›ºaȦ!ð1k*_ÍçïüÄ»¼‘g±ÎKÖ¬du†{¬õj«X[ˆþk^Hñ�C:C0žáÕw· L¬ýG«´ÑŽøþø•ŽëàÏŬcP®=|Z[,]N<Mj_ï'G[K\[P—í�.+TGÆåæ AqçÎz&û‰>…ðàøt\Ô ~îÝ.£+ž£¶¢£f«ST°v ÞÝŸ““Á£•øJx,ñ ºLLØéQ—]ãE¤á€™öêSÎC®Z–“•7REV½RÁØç–Þúòí ‹9Uß…»Ø¤}¡ó']ʧ:q”dž…$L4ù*û¬ÑqÌÙ‘Îî¥~°gÝVÛÐÐÂNŸFÀÔGcÜø|FÞÁ"=ìcmmµ(èÈ%~gcç¢Ò½IšäsòÖГ2šñZx*\{UÕjʪòœd"iœÇÖI|Ýs={çü¿®sþ¿¯›èqZ¹Ó¹b²ñ¡BK6†Y÷÷ 9†ŽáYA s~T^¡IuRË,v[qæžY=§½Ã™2™­Žw¬yºÛ¾–8ruLÓñ†¡Æm¶”T¾˜æû¢Š"éþ·c}Á5Xz«Ãa6 ‚‡…=[3´®Œ$í0ÐYUŽÚ€Øɺ¿¬ `9´”r£Ê_ïù„¥×v§t=ãÖ*ÓiˆFÍn¸*ž] áسΨøDçFç[™ôà¿üÓïÉ÷¤…o.J»fÅöcç­m£xcæh¬Ìeêùõ’HCO¶RÈÚ¬òk•1m¸÷~¨‡ç =¨_[^X³$1© ßÕ^àNШår,8T/¸ÛÓûíöp»Øµp°2톇¼„*ó•'Qh@ ¶¢îñÇ?ì¿,Þ†P¼¯“–>%JÇ3ä!-÷CÆƘmð@ô©Ù­™¥Ó…R]‡T S ø¾x`�Ž&C“2÷£ÝñlzùÝ=‹ødñ `jφa›):f‡¹{Ï8!Ë|n)Ú»>öäí¤3ö¦¸mžÓð^ºÍ=ûΣë3(x„|Zò »¿QB~¶f®D¥í.¬«Ya̤^¡ u®Á…Œ0<X1gˆ*Èá"`ÒÛŒ§µü Ð4ñ `9*¸UÃ4­ÙMoÛÃfÓǽ`}’BúלË8×,ª0Bë=ßÍ¿†™¡ß0n¨pèý¤“Ñqß\^L/âÜv>ÅÝp¢ý¹Ve¾2CÝQ¥üîòx¦©¾Ë‘”AR7šÝˆ§Žã Ëé 0²c<\ê~Áç´‰Ö 1ëi5cý­Î#\³Î» ^1«š§ ‘ IfåØÜÌ–évãy ! ›¶‡ƒÅà©UÆkËŒ(.2_j ì&”“ËóÀèá–÷gg{"WëÏ¿uX89€N"%ž­ŽZÂj¾£×¸ÀJ‚ÎLVᯬØú!±áÎO<y[î, WÒ–AÕ;½‘<ð‡Í6ƒyŸÜ§Y’ƶÍ*Û9âµZ_p™Ö±Ò)äF8‰¹ê]SĪ‡ØOchÞoÿ,ç÷”å¯æÌx|©š ©87µ ö‡2Ch [Eiécl(Hn[ú{ŒÂ•xÑ©}á ÅÛö„ÏÀ´ß<ÑèòDêeÀ½G‰Õ¨r„ßc¬4$áþ̆.ý¦³Fyx�Ä»àð“bBÖy\H«Þ$¿F²=¸æagÈÌå58µ¼>·GÊü*+ Ò¨Þ;Õ±iÉÝw~”õ焽Mõ[°{ZÄÙ¢‘ØlcŠ#k[ŸæžnŽgW1áÃ^<`y$^…s†e`'9ó}b/JàNÆAÑ;l\AY‰ŸäßÚYXoq`EU7ı4IÎ °åÔOÆ‚žîàðì'¦Ww˜©aæSÙª‚ìÇâaÕ×Ð#ë&y`²î¯%ñ*-®Bƒ ;Óé^ö?¦‘û]=ïæ)½# … $ Š ‡ÔXÞšŽmŒ2;ý§œ‹{.ÛôÏ?�.ÜsÙ®b¿œ¦ ƒ–t­I?ÚjPH®ÕckÞóÕ„5[Ø¡²½ã§7†æ‘‰©†ÌþÝ/Õ³¢4Ë<þ+( ™kex!™;Ö³çoþÞ ŸÅ¾N ôµ›H² ?ˆá´Œk†=a¢-€°§Z QšÛ>ÎÊ­À ˜¬N'bNb6§]/Ƚ+›§Vº2£kÚ7n"N7Ö‘ŒÞÂÖùª”Wkèÿ'5A‰îŽ¬ißø­ý‘/ºBv’ÄPg•…shá,ú½À=lóáøßôÏ,Á«2Èê#ÜsK볘ǵA÷J׶ûž·ì‰œÏþñh@IåÓ!1Ìêè ZwžÎŽÁLóÜÌvCï^¡vªœBU"hUé\Q ›]·êÓe¢¨‚¾ÏkÈpjJX˜@¸§›qü׳ÞªÓâ_H�&>•„càt�^p=›IèYÙ$†ÑªÓ'Õ0èÿzÑÃ$ŽÑ8wO¡È=UqÐ¥ßsìéï°c¾,W¾á…lø+MÇ^I F©gÂúhUÜ‘€PbŒ]Oñ’¾ý¬žx ©Ä{Ÿ´žàó¾Þ Îf”'"bk‘:§ik&*wÂzT8!¨”¨ØÏÝÎÈqÆÃjÛÖÖbb«Jy—óeè ±´{§ÎwŽ>)°uÅç¨ê?•š*e¾œô†Ë+*Œtc<Á4Ðà$+ˆé£ÌnìÑ4më3eÖ;it]½¢€K|õù0fÕò¬S h,ýé™}ÆÕ¶WŽaå¿É™1îšf B§•¦Î|ƒÅÃz¸Ì8çt<SœýNKªç%×;_äÀ=®¼–¡,×16ʾ’¸¿xCzZo:¾S@èÕ­Åc¡T9›z£æ%?µ¶Ì§ƒ…%ýÕeoU"1ÈEß<ä¹ßuå‘8ØáümíѸly`ˆ°:n€«µ[~wuĤ!U‹ÍÅrÛSTß¾OYRÎÛÿ;­2uÙ0SÅÊ:ÊVT Âäa©\”Ä˿™žî\®Õþ‰¸ã£.¬éüéYNlG9;Jü30vZ-$žÒ`>ƒ£2;_ÛYÜÖƒD´uÇj” ž(Á¼7J·z#L’í\ÑAïcêÌ)fÓ2DI]¦×¸êÒÓ ä0¹9ÁPúç_oÙ„Ã~×w$Y/x1<¯R×ÉaÊfKŸ­8©šö*Å «‡®Ó½¯˜¬¤>Þ8m]crQ@CO%ªß¸ïé^öûõw÷qQ'Iæ»ÈF°}¡oI¸­hôˆ¯œ«¢$r ^RÛwåUñ “cÓA7ô6ÿ<B7q/œXÓãü;DPêóiµ]$MãÉ*SF R…Ú¤Ú¹G%/Å>boψ˜}ß%Aüi­KáÿN²¡í¬h4—5}†ãÍ»ôJ1žºì…è,¼å¤`[Odþ}µí<õ%{)S†p`eõ/bð÷íÿ*ˆEEa¯ˆÔ +2TÐ5õ»ñÜ$ iFÑÀ©.¾½3·J}§u.ÝÆ Å͵Êλ– Ç‘Ç ! Xñ•2ÿjÕ5xQÌ왺oUäÀSë;òè‘Œ‰}÷gáû<Q÷Sö2wù ›1maìÛk~‚÷ÞãLf3båÈð áÞ•2ËÎ… KØÍ~¶ÿzŸÓöÐpg_†êHw:½oæn·1G¿4Äêy*Î3�— lŽÍ|­ÝO°ûsY4ûøˆÔo1¾ãÔTAne!ñ¹µ…ØñaaBžñtB¢(t~ñp¦=$YÀéÇüʧ|¥gíÅ~4ÃÈNÅVƒ®M×›a(*$íÍ?4P‰)Ï¥#ÌSõïát£Vl@ÉÛŽ”¹}1ßÔ\ˆ®ÉÁ o#JâÕ3nè"éV½òHD¥œ?÷où"Q©½zñÊè ò"¨¦O§Mx–.ºyÊ€õ˜®í{D^:ï\îp°”Hecm$¥6´ø½pˆç9‰½ÌJñ9˜SJô vÜ8u¶<¬>_X)rù¾ÞvQ³ì ÷=Q ö6‹§r:rf&¿Š‚ŽmÖÝL4ޓ注™Ü¸Ñ÷PÌ­€>Ò»Õ®ÿÀaÜ´[7HÇ-W¯êDfJô†_s$bE´[!éj)=sá¦z—ï¯Z^š;eÉP«©DŽÕµúW)šxƒ>Ö“;Ž½—ERÅ„ykƒŠÁ3-“¤Ê|ePzÌÇžbnR{P>¨‡“®.Z ó©½Í¡Ýï†û]¢øZÂp8Ó»µ¬hì†EWí•i§ZÓO£ðù¯wòŒN¸ìø7‚±ouË–¬”·G+º”ÒwZ[”çs‰¤ÌCm°Zg€46íÀ üP²ýÙï<Ö½.Ÿ¢Á-ÝËÓ§gËzë ÿ¶Ò¨,ï¬/¯•¨ã$ôÝøà˾‡ãéâ)]N B±Ì‹šn�š7ö‚-3|½Lzú¼qGOjÌ,taü½~vî¬ñX:#ØaV6Þ<x ÚºfÙ¢ŸÛî¦é±÷º¶0¢MDô®ª/n'ª‰¯s÷|BgEïE©$fåOŠò–*ÉnD}brw�!EAÿ!¶ÆzʉXd\´¬sKu‡ÑzG覾Ї>Ó¶hÇšî0ò2ï‹s‹ˆRÓ‚ Õ”Ÿ:3)È%á8y4“âÑÇáñ¨|‡î7K®Ûltl›†pdf‡”ÑP-0è4­×vPOqò{ÎjóãÍóÕ÷ÐaCï˜~ŸD‘#:»d@•¶ÜÕncêí?n‡à�È:í'ð´¹EkôÐþ·ñ?ò½KÆ|Q†9¬=ã6„¤nü/|ï£(öY” °­é‹+Ð+l꾦jïOí@;ðeá«™„EÐ$€_N¦êéë“ÐãŒzb\Û*%c†•šuþ¦Oe™»îoÄå}K@Û{N¾Ù,®­çλCz —°%2ÊÌšÞƒ� „è~7[‚!&<ñÄøŒ;ˆfˆöÕ2¥¼µöT6KepÅMCá«Þ(©:b(û8èÅÓ8wõ¹ÎG[çîÑO}ŵpé8*D·Áb4* Pì@]–À‹ÖSô?K]› ò”þ’Ñ!gh~Ÿ\п7æ~6ðÎ Êã8~%-5ú}ý5Ð6?"ß×ÐùëqwêeÈÜ>Žôô¿'ß©P6üÂ?CíërSGnFˆ;_«&bÚ|d¥V†MjàÏž^9wáx, ‰ÚQͺÉÍ£[–k?ú½…ŸêQ%éBö:¡•[Rxöú ʺá²ök×\ÕPÏ)Uæ«xÖRQ¿ñZ�˸̗žÑ?<lŠ°^Žilk•Uþ@n0 vHö«yZeËLgµ§ÃkøVgdòjúpòkîç¥RTGʃ„šÍï/€ýGO>#Y»©ïÈn®n1„‹¼c5c†Ó æ x¬/ŽßH‡ /ô¥?V‘ùnRa*ÒËÉV#~žn4ÕÅ´ª­Kßoõ—uj, L†bÆyÅN!ÔSv´m÷ŽÞ É݉™€¢%–ô HŸ®‰‚ÊA}°&5>ÌDÿóÙÔÑ>º ƒ¡œsn|n(:JÔÄ:æãq‚gñ™…Ñš¾"Hé�‹]‰ÙýFj‰óhSÁ/<7pdEäËÄ)××ù·S½ŽMˆs{¼zeõ#C£,\h7äÁ„pò£–!NN˜yIoBWãÂ7¨D^‘FÌõ’wN²‹'¨iPvïÃê"XÏ8[/Ú7óH5XômÁVôé÷ëS_›b =€É]øÅ¢‚öÔ/#Ãc¥•Rû ò¾>?à®êk--Ê ܈xÒpŒ`(hw‹twŽô§ÍàÓOö6Ó³ãdñú•50ÒpÁ£›¿« ø\{:à3M˜Â(ý õúæÃŒ£ä^;Õ˜°ž¢[jí¥á%OOŒn$Û ¨ÅÛif4PÈ|[ŸÇ»´ÊÂ…­%’‘°·ÁıL*ýÛl$*<3™Øž`[ÅkPn¼úñÁùÙ V„ g´D6zןO¿žSb G*?÷øEbqÁDs÷310Î )¨ÑŸR÷21.®€å}GÏ÷¸u£RÌÑqÄ›{D\2¯_¸Ô¿ÝLMÜy™3¤Å¬蔄Ãe5n™6 Çú¼†T2Zl«¯­èj?IßC'gþi æAÙ©W~­Ô†Á4¤öõÁ°Xr_Ñ҃ŠT±A0À¬žÜJƲ¼ßØ. K ©€9Шu-´§ Œìlýxš¹Þ Œr%l…¦ô†©A¹<Ž,mhô¿dm÷ÅPìÇî¶ÁHK¯GÆžÉëòûNp¦k?º?u°:ï(À4f]wîÕ[.‗Be&gËçȲW¦#§,¼é_*ÈD¡ª2:šAËt@tƒ5ŒÌ®÷'u˜Z*⽫—ª Efœ>WbHïiÛ C#ólÕÇÓ¦¹,¾^éÄÃAÚeغj„°g±é͇OÉOtl-ÔMV_pÞ¼w¥´›øËœ³jtÚ 7(Ø×—¥Â3Îx•®§”"SfÁ Ø†üº?n©¸ Þ”ò;•ÒÂ÷`ÚÌž424-}HsȽ6ŽC¼Lo=Úg7Kj;:Ž!ñb€“ý ÓÃ@Ñ 5è*1!Ó;éµG¢ÿû’Îù“ƒÉž·;—øü¥u’øÀ¨§1t¸WïQŠ¨ÿî€JãsÚÓ2ƒœ’ðžöãؾx–±Oøb5ðÕÊÚ¢‡D|Ýï“gSߎwqCŽ³EÁ,/ ²Vôöš¶õz6D%p¿=ÓŽ¬1«=О�kÿõ2‚éÒzXÛQE÷ƒ’þŽÈÀRr÷! ò*”©0J=wÎ7îBáIÕ2aïH²ÜLŠ†‚vÚçé¸óZçt¦T±`|y %·-X_þ$žÜGH#ÎÿSϘPbÎRì©Vë؀ק¬˜+²¹ø{=ì²¥j?ýGÔ©Ñ9œÀàF§*A…Ùµz³Ò‚$‘Ú±l#'µÛÚÑL¹!c ŽðÇ<@ys ;¸[©™Eý=ÅÿEaf½E•¡í©DßêzMÑF)«ç] ÐØ̼'æ¸ÝüH½f|ø"æn.!΋àêÇ­¶bA·™.ÿâß±õ­mh©ì7Jp0î6vó,ÌÐÁ,×Á¯Ò›¿ÈwbëA›ªF�¡õpˆ,e±:ï˜ÅW>’SD›³vÙqý--icÑ›¢Ìì-¸é×Êžx4iÐ÷iTMí$@ŒH Áããáîé¤Øø—íÒxÁæ|º¶]¨Æ�>’ÉÑÊŠrgv7b0lµ2^yE:ÏÙÐ0U»Ÿ’ŽcW^ EV÷3ÇêÐû³wpÞ¥íuîHRÆóL‘/"1vŒ–„7µ¦ôþ4ñ/A!óOsù‡…p8~#Ó˜zy…¨>tŠ«YI·¨ÂVŒ¥¥]£]ñöúuW7hðÌË‚8"š<¨Z;wMY%€r•Zo“¬¤‘W÷w³ &èYsùˆR/µÊ`xѹªW ˆ\õt-Ó¬WwPh”»9%o¬: NUwöÀå”n këÈÎ~éêÎÃ*˜ˆ ”På{Ãg|³®NLÍðÍ®%–²+ƒ„aoUÏ#(/g:‡]Ú‘f´>»îë}…»dé ËŠüeZ`2D§©X\c{¯à~öÞQ•ù–A¢:_&' MyrG•µH¹yw!ôH7èÑÝHf¦Kô4h&Úqu£ý;ã?Ô@÷†X~-¶¦‹‚8M0~)ØpÖ$í©•(ðwC«ßíyÄÙ‚OÌh¥Â¹%t™Ñ·d•Z¨Ý‘kyƒ³­«1Ce‰”Ëoˆ .ó¯Œ'¼¨ªVÅ*€:9�:dEäªÈóᬠ_V"×çàQÃ7Ëšø?‰[eê÷Ž(Ü{Êvlç|VzK|É&ý« Ed«FqïŲKË ½(¼hpF<KÛØॠèÝz³¶Ìt_sµ«oý¶Knr¬}L‹âÔšÁf9­h5ÈM<v(Úù‰{5ÌsV.$œiÕÑö‡»ÑÚë]ŒÜäµhù7tar7Í€[jzHF5žî>ª#‡pkêÕéh¾>rmpé4#ibÀÚ„¿BÅÌk5g«›‚ÜwQ¨Š+l1ª£ØÊ&·ÿëwåŠ&Iò«ª(+<t)£äýŸÎû¸,¬eQô�¿Ufy¥f8_±ƒØ9 ŠYÇiH©ò±î†û*åÁ‡åÛ÷8°ï‰Õ¤•vãã“MršÓBkO¹âÿ&Š<™Ø¨oCáÄŽ^Ðç¥U�®¥(ÜE‰YÓR¡?·yw G’ÔµöˆyÚˆbÑÝA8¸»cÊâùè)ô‡6`vj½¥&zÌNï óc€?‘ J"ë\Âþ-È6[|²Z v= »Fiä7Â7:qèi´¦hZ\Ðhµèš˜#‡K‡h‹ì„­¶rÃeÿú¶fÊ¢ÌÙ6Mîj°`¿0\2( jàæø§Û¿ér§aéwÏ�Œ{ë—V1Í’Ö†TÿµCIzfŠa´zfÍ·ÃÓ¡ÜBmO \¾Ü‚¶QŒ|%§l"£sV9–˜×}"ú™é?=‚³z/“(5MUâô»“º³–` ÖÕÊÄ÷ò¼/>w%6­¯y¢/¡e‹²fŠÚº½ bÓw,ºsÿòÊ*Ÿ”GU“6]·õEtF8­¬)›€ýyjÅwÕî‰Â?ûÚÖöOÎÔ"2 ¹Ð Ç-ýÆYÓêúx¤­¼Úêo6m”F~°´ïÙµLŸxÞ#)<Üq)ÀT&¤³Ö® ãè £L¦ûÓ½Ÿ¤éB›ºóÛl;»é»™:š_ðâykÕé ¤ÀL46c]¼ª»ÿïÿTÎÒ™õÆg9c¨ŒUl7q/þ¥ç·,/Xv}¤­„Ê8È`…1v:¦–ó;Rf‰oŠ¨)[ìW²e'ôïr6;Ÿ(^ú°Qi 119Ã:É4é=á$ôÐ3´)úýq^~­Á,ëi}è….úÚ™×ò+0`ÙA|´ó•L:–¶g„ZnM•™ñsô.=÷Ì84lǾÆQÔn<mÚc“¦VbtöÏnøg}ÄÉíOœ²Yd[\ʆa¢«3ˆ¥Swð*à@¼ÚÖ]ïdÚÒ]‹Òw)¬çO”V +ò•L˜2qôF´›Û[«3%†óÛ±{ ÿ­bbV´ì›±;w/„m“rQ{Ñöl/(‰;å¤~˜öµ ™i½(×ëþÁùÍ(vþœÏh‘j,CÅÖÓú¦–ó{{q;$Š  [—4È¥³|ÖÓž%ru@„mtà™Ö´¥{"U®¢¥¹=aÊ •¯$¨F[²jZVN[ïÒ7ñ¿Ñÿ”˜.»†bÀ<=ÐV½$•)‘iŒ,oº¢+pƒŸƒç-õ•Ý°Dw¿ŠÖÃWè…,¦”„»øÊmœ{¸1RZ²Ý줷&Mk^:¨Ãø2¿ºÿS”yáBž;R‹`¹™Ò–©KwîU9ÎÌ¢ät®„õB„“êÂJ>/ µ(ªÑÇaœ&œªn‘ªònDƒs¼§;Yx#»^àŽV9%fT6ŸŠ¦t§×¥ˆ§xÍKE(‰¶-Ô—:$j ëh†Ï¸X>Öó/–@b£ae†äíœsc»«[:¥×à *ñçlã†ó™–÷Í5Yßç«òŸ1€²AQ,µ qèÁûN¦¯*å(Ë]1ÈPÿýWTÉ Ëÿ!|»)µ צµüaü™-Û5È^·ÎÊ¥UäeèŽU§ÌÛÒœéç3ò²ÿ¢ •ùöxœ^nzD Ëk‹Ó ™‹ÉÕŽÙy˸Ë;î2aZd®S Ò3š\½ÉÆÊPP8Z}8ÙJ{(ñ7^{ =xð/jžk¥ü�¢ßóù¯¶¼½ñ—5UA†Á™3áò&OÆboŒÍŠÐ&ÀçiŒ36§0Ý(Ù^½™_ÄÔɼ>Ò}Aåìé¶zh†}6f¶R8O$Õ;wSÝÊÓkÏ™ •y3yÚ(Œ=Ù^$ƒ2Rß“Àµ,d-t–º¾x‡“cg„Ú6œ"CÅô-ÄY¾P²¸ò¤ï[õFþµgãßzþ¯Ê™ØW6É‘{pÍ1xüº.TÌ Nãçí²C‹¥84æ{MBIé·zadÜ%éõô;ºNäùGâŒ)Ð RÛa¬D«Â1šçñƒë§#Ëí£0H;E ÈÝï;Z4§ý‡ÑR¯¶ÛXêwCy £ûO­¹×'¸*êØ8JMÆŽPêŒ.¬š)&t÷€#©×qæ.}fú¬[%â ó±Ð“ÿE¯Ë‰”&#huÒÜnìZ×®0Ÿžò3éݘ|X½¦?ùÊÔMP…$Œ)¥@?úÝvv‡ÙpyGqÛ!a”yOëÆ¥V1Àzû£«ïXl ‹Ü\pÌÞ¤Oqõd‹©k²(D\¶.W@ë{¨R÷†HDF¾‘B˜± ]ûãæXE×ïhýN‰.õ¼R8OØ¡?Ü͈YqJtÇ8T¾-ž;~»ðQ7Q×µG¨?׬t¾ììN ôî]ÝzZdáR¤a…=}*°®¨ØZÚ4P~*ªQ·Rª¾‚A와 ­òf,m Þ¡ ›ÿ; dYús¡Ƙh¿ý¸°/læ�öaü>‰¦¾.}13Ï]¢OA÷CaåÓWÜhN}“ƒ¨ûéØœpñb×Z± ô³Ö ¸p"\T†‹Äòä©,ílcPdf®_=Ãñã>ªª …£Ó9asB7ÚÏ@‡¢¹ö·XásølaXÆF»É™‘h¥Ûxº!�¦tóÿ½dS¹ 6³Šþ¡7ãi˜Ø¸Í>«èï;'ž½,òvSoò•;̈́ʇ…Up<ÐþKNZÑy; mÅöÒEw¹ãî:WNžÅkMŸóZËæ™éÀ6ÈSŠ~òD2çKÛíË‚:h'À˜w[Šq9 B†žÌC\ûð2ÉÃU„—mkX m&wq%’{Ã_µz(ÝàP|Cw¶aœ">’KbOטñaì¶ÞôÖŒ"à\s{8Z=·w¼bÔ€ƒ’ÍãHo;o=ÄùÔ:ÿâëâùn­„g¶…G?eµgÿ?í:Esm „€~}ç»ã®g½Y:²fÖ¢Ûνw¥ÜÃ<uUE†[3ƒŸöª%‡8Ñ$úSo­¶ì¿ô‰»ÅÅ5ÝÉáw23_5tCòéÛklÓÇöÁ‹k´˜ÿ‰ÁŠqGáh…JT[žËFA]S¡:̦–$fœ®(~dÛªOz>zîá²V #|Çsdûzö'e¶êO°Î° ½@3† %®!}–Nc”ƒW¯ž‹HTb³¥ô•n¾TsÈÊ„(hÎÒƒ—jýÑ50ü.å6‹Ç~_<Ì ‹ô6]­ÄÕágËn0gmïÊÜÜ,÷gúTÅniÏÄÓųBè»ÖYÒžëËÿðB`|6¹ô Τ7X‚±Ê’«5§ápn^Ræ‡bøþV§9ö9|Ë:0n· ȧ5FÇýh~Só€*ªBql/Íš²É À(†m„–’¬ÑBùúD‘<®"§­ÁP¥Ãô@¦ÖÈËß/œ§}GVK»êCŽ©À©Ëqåý/!>h÷þ‘Í@ä\m¿u‰--ã¬QIp9 C«Ì6v_.çåÒŽtW»$æµÓ2ý·šN,¶õù¥S¢sÐÍ ßmè¨`·+ÐÔþ°©="æ úòÞÏ®ª ƒ2–à€ÛaÔ¬=uºéˆ½a}«)ëg¹É¼}ÏõÓZ ñÙ€¾å¶¥?ª;ûâ!»ñË£ÛJýÅç ئ‘Bw 2²Ð§°R8<Ó1w²á "½†µ¬µ=Ó§ãQèc©D‰ãY·§›Þ×í…sŒƒq ÆÓ,H>óŠÚ±È<Ð1­•î'LÞW[Vz‚¦»ö!|:Ž½Ù O“ÏðO{ECÐÑlþ>+Yº=ôü1­'f|ƒ¾²fât§ªŽ²…NUì¿2ÆЙ¢·° æfM˜¼ú™Xĵt„­øÂØ öø6{nß4svÿÖpGöÄzò¸ÛozâµzX•~ªé]|46&»mï<:(Ý™‡¡Oo.‚! âAû0Q•ëxºÛ¾xso S×–;硶Yº”ת‚¦J‚rpÒu…t«Œ’.ŽìãÉççtèw<±'¶,7‹Å½é‘âè”&UÒsP¦ŠùÌÝùË�q½ËÛ~»o+ íÑÞ( ’¦w‰ qͶ?’’Öpì}l²p©<¥Ö ¼¨ƒ²¸€‡ý ì ú‘.y¯½úv¿ÌjY¤Æø…i«Q§à9*ë�ä0¬ ¡5AáñÒ¶OÈ«ÖÚDZ“1‹ƒÐ­ùÑ4z:…ϼUNj%í•ÄÕDö´A|¦ß_‹€[ÏRqVèØ Å:‰ gµU¦l²ë´j§ŽVö2|cŽž-äliÃíSTŒŸf{Xq,Y:XLîAž3ú|!‰ÑÝ/¸ŒùbÞFo}<�Uú­K9ϸÍc‡ßê"}ýêFì eÔiA5Sso‹¨ÝÈî>XTq£ßÿ­m8#`Ìt1€›>Kƒl«k ôÕW=cd+ÊÞ°ëé>4ÂŽþ‰Ùçt›hˆËn®YK÷xĶÍ6G-¾+|]%¢œÿêÇ>›%âñ€º¤J®ÇEµ}eb™U®¸ ?×ëµ€‡ºÕ×µ(mº0:sÚ2´â†Ú“›0Àÿ|�ê˨MãéJAóÌBc²›Ô¢$þ–ñq[Œªkë‚rÙ71ãѯæ& P‰Ã·×w}豓ÙÅ·3ÓçÖ+ ŸŽ]_Ýhôç(uA€òWÜ}ë" ^1}vºÓ£¶2ÜsÎ.8r°e,WEöÂ\®#Ë2£ôô&¨–ãѳ-¥3ÒÑw}<Ö£kŠÛ 4 Dº¿ÅVA¨ Á,ËjI°ÍÛ€*q‡uʺ£œb{¶ ,ŠvðÐêæ_a-ËK‡Ó} Ã%µD‰aïkí͘ó$Z1‡q?a4(±Ó{XËç–dW(‘îùéä©FHOÔ9Ö³Rzv e/îŒÁ8X¦8ƒ ǵ® {~y}Ë4bÓ1t•mˆ~$òçÄþ(Éð‡W”©v”3ev*“ºn¦9{ÅÕ|ÈÙ,B?˜ÑiÖŸè±~Z}ª ê£[U=1À‰Û+ÞWg_æf&xèé©*§A¼`×ØÀ²^Ú¢ÿnåÊß=b¹ï`ÍƆv&l—›Öï°ë¾ÞPŽóÒûâlCk˜Lõ ÕÉÁshõÌÆ›c¿çd´‡£I}–íÊåw°y‰3oTÂÌ Š[½mÐqÌ=Z…°ÕaØ©ì›ü1ßðcXOQ2öÞ½¢Û#T«lÍQÝÕRë']dŒôº(H×?fùïV ò†, †žVàS^›Q¾h¶”NOÔ–æï$Hzk[— ßÕb T˜°¯©½¸eÙ»^ug:Kí@gêVØÁ8ŠÅ�ÍU#�:ðhol>."áðÜ<ŠKWÁ²ñÞyÀš]«%«§³ ½v¯Ë¼YŸ ëî©êæ6pà]àÅÊcG‰ôáËtp—ßùïbN‘C„ÝFÅebø5ÆeoàÙüÅ &,„ÚÄ©'aÍY&”7Q¢žøͯÛÑqè»r/äÆh§– ªçÉžñ®ÿ"SsíšÒ8@ž5ÛZâXÁžÎhö·Š™NMVF©é… ›”6è1©š6BžuDòüJ‡s@K+FOó¯ªA�[;6n¼Ó.{Âð\Ф0¯éýÜ¢%à£ÂÊÚ<j<B×åï„÷Ë,ôt¶h¡MÝz‹ÓŠb´¶–j—¬¾œåWTy|èŒ%Î Õg™‹(’Ö;¶!òf¥:a:wŸ§|c0õã¬ÜAm‰70úªÏOÛõ§»T7Mç[g½JºÊrQ‹•°s¥4¢U6tl5 ÷q‚S‹Î:ÃùˆÁå7öÓǾM›o7èñŒnnH÷SBüQkdâ„““¯f€©·JtÝU`²’óÜCF$šš,ØB©@#bNF2W—)”Ñ™0x£6D¤úN€©;Ã+ˆ±¬ùxƒ¹-ô}Õ1‰<—Ž«ˆ²Ó<¨z]œiÈjÐkJí!ù®å†œÀjÊqmµ0Å®Á ´A|d:ôWbÊêž*Cº?mzz{rÄè׬:h˜Þ4q¹brWLp4 øi4ž1&`N<, ÆmF¥£vó7p³_ùÈÿíaÓ*¬~éþÀÊQœ–Ñejèþ@{Æx<9TvæŽ%öfYmi/—V 7Mš6ÊVxÞ¿…iD Pï4¡­il;TU]9-ØxŽÎ^™õ®‡wTÅ þx0¨Œ:¬ÚEÍ’06m¾´Ø2„ç^9‡ éW¨X¦T—ÖnMÀéÆ;?NÓ" (ÈöSV¿ÚRaµ¸Àèìyñq0=<ïƱîõe™¾z*ŒìŒµª¡ Ò)‡|I“fp÷¾  ¶¼ˆp‰$cÇ8Ê+ÇðŠÑ€l¶Èæ;태pì1ª¢:Ÿ¸Á%d¢bË ºŠ±1-ŸÒ3aõ~׆*iÔÑøpqŸÑ •3ãdËÈúZu°‡´!ÿóÑÁ³o“‡ð,îyãêš$=zc ¯½‚ÊcÖPñ5À aä,¬7å͡3ïJå<Ý^J'¦Œ72n­íDbè»ÑÿÎà⚘Vˆ[V~Ñ_V˜a·²`ªü–ƧX/­²òE³ –‚2êoëö[rÙmMHY wzSsqGÉs=çR<hèéŽNg¿ýÙ:ן:€—õ×»F�ÑÇDI0ß¿Ïnc5%@rW8°3™TÛ´ò™¯Ûª÷êŒxi sŠÿ³,O,þZb~ª½;§A᾽眒ꣅ:Œ¸ô<ŠÝ±P¦3¡`µœè·zsâÔíÉá²+oe >ÔÓ©7ƒUÀ¢EصKk^„`!ùÝzÿV™/ÅŒGÞ9´ö´˜Ðéàø°­Ï_lj+POîpßÅ$®É-3šÃOÖŒNÎ58FŸ`ñ— œ`ùb“§=Àep°mé\8Û žãHËÀ<QÑŸcý˜wÜ$(ð¤Ze—J¯AZ[Ü¡?mYJOÌNlÕŠÓ°SÝ•G0㡸9¥ŸŠ²£Ã‘ÑÜÓs€8åÐ>3tʪ%0=‚HØÿ8•J•Q�É[cÏ$ôÌx6¡…Ò8-”‚ÙæÜ‚åÛ>’÷ÇÁ‘¢ ieÑBSƒI.5cxßѧ¦°×tFÓ¶Óº'ÁV<°%$:¦E²üìgD*Q‰x,ñUFUœã·£'ñ K2_íò¿Á"• ;‡(8¯)·ï[_ÝtXÖ't$·â{W·V®™o _–: Rëʆšhº&Íq7 b1Þ£Ûæaf[«›¨öTáß^ a½¯×"—Íÿ¤ÌêÇü¶á¶wbî”·rËV¾/ßrñî®ßÏ耎”k%Vú‹œ^NÀÒ3â@§-+}5Å •JMç}è(U ?• 5-œu–\Àiâ‡3r.…š‰ì•ŠÛ¨[Qe ÌiÌ^¦a×xZKŒõcœ‰)ž7‡ÑG’›ï¶ âî°à¦Ú«Ö’×Xt¢?,ÃœªPZúoZÅ$>¤ ƒ}(›z’æÎé!çžàŸø*Í|+ƒ*h†Ä#§ìൻr›zÀD¹ËMÉ9kúd”ÏôÊŒ“3£3*¦Â<t¦/Âd¦g] k[™¤»ŽÞIO¥V ýeÞN'㽜,Ë|e a\#l•cêÔƒL1 Í]ü§(„Þ©¢¸p!Í�ËÊ·‹séFiiüµÃImOÔ Õ¾†âqƒ²5)"2ëùSˆ,‚Ü–F‘*)yÓá0 R£fg¼ÇTÁ,r˜d†qO´ÄÃSí ã¿1lGÃ]‘üͦÙã)ˆ³B[à+[¯ýFò­­ßé°?ò ÕýD1Ü är¿ÁwU ôú¹dÓdAöSRÎ|J„£Lõþú"æ <éš(N­ï³½ -ûY-©§¡‡6æp×P6’-Ü+ÉüóÝþO‹ÔëÄ�Ò“à€ã¥UçU»yU÷kúCè¯`÷ €`kÏX5y¹›¶&YæSø3:^iE%çÆ[LàŒÛã–-¾ÍW”ÜûÎkr…ÆSõØÁŒdë©å‚¢S[>�Œ|àÛ{‚aÀFözù`dQ9h\Ä­ñUC÷§°e­�p�£ÕÓ†«¬ñoÐúQ˜g-¢•K‹*:)~•R@:]­ÐQéS�j[6ÿN8=ÝÀƒç* "«W“Èã Ël˜–ÐøÖÓÊCXî׬r¢¸#éÃAÄïteþÏY'Prƒ�a¹Þð¿b7®/}{7ˆ=iú=ý9•eÛ"­-œ<ÝLõžÌµ)Œë@ƆhyS{°yÚê{Æ•3[fþ§Ÿ—¶h¢ %'4 ŒME‘bPÐÔhé¡JJjFb;Ìøú®þ·³sñíeªªw‰Îÿ.BIØ: ’¹óÞžßÚÌF ‡OhˆîuÛ}œÇŽ’³¥DKV9ÝBð¿T9:wP€í×AZ=eòeþD¼Ä}€ãmÙ¨>ù È-BÀùð#ž }„o­œžØŠEú8c  «§–ãÚ˜ BÕ­ÝÍ«­wÝ—N¥ )öAç±¼U1øñ1'ÜÆïñà­’ªr«Œí•¦½aÙ¶ŽÆ­µ§*æ1\Îp‡ï^ú-´Ènqþ»i5L ðÀ9Ò”çä{ìO{J3]û·•ŠÓ8ó…㔟)<£å™ö;½ÃÆ3ÉËÍI€cAÚ¼G÷Vاtöa&©— 1ÝîkŒËe1K-ߧÃ^¾ò1ØqƒÐµ2­Ñpf"Õ<°BUë`½¨E¬hÏ6¼ªQ\}+‰Êµˆi¶<;r·“Gg⻾ûïœV› $)æžó ÞüX1ZZõÇñ@÷×Ì@ –•÷/Uè›”b §Ÿm{O_mÚb"dlˆ µŽõ«®~áõ%q>‰2f癶jÎ\Vž¿f³ÙwÚ‰í—&ª ÊæÚ­3ö sór‚Ëᓨ§ ùJS‹ÜñÓ-cÓ¿âÌ¿¦£e–®[£ÊIÇ„k ;^¸ ôp’Ÿi£Mº5YЗA>N¾p¯Yű¼e•¿d7£Õ6ƒìs6)nÂÉto€æ3>™ðäY–—fág£²¨³F¶ÄÅEŒ>ŸuA¥d¹ÃùÊòÈ'õSßêÄ¡ç²¢$ù }öˆ²ýOéýáb ¼/‚¬·üÕÔÍk;!*ó:Ú`³ÏnqºMæ|C£³…ÇG�;.dX3>¡."z–úû�«ˆþÒ©|–8ºóûÂ0¹ž~AÏN ží0Ü‘´�㣀ÞQ ÕQðp܃7Z±ª#Fbl• þ6Þþë¤'`ï(o6ùí6¢}ôÆ%=Gí´HÔZCôŠÅ~SÚ�vä m/ôiZ'w±Év¤­j¿6<6®å!–}ÐCD/‹±½¸²…)EH‡ô%£]¢ñgµíPð&gB‰§«÷HQ/‹Ã…‡FœéÿW£¶%((^@®‡iG‘éM„V.¿?56ïøËywéõCRÔnì­cÄ E|®‘MŒ¥“ë~ÓSEiî¼Ø+Ïþݺ­(KêÎ#¤7Ì9µ#7ô¢‡N!Qš–ŽþÉO¸ÄbRG˜}}0«7ÕY¹ò‹³Äô_Ž8è®NÒGÐĤŠ¼Â™ÎÉã!S×ú*A:ˆ‡?'sx®hNæësÿ¾8Y¦LaÐßÖvÀfÔþ[»†) d3‚JÜØÏöâªkED† \IHÙõÆiYKûH”*$ï–]øœ™óc‚XK(*H\JÏ7pÇW'†³Ùb¸^À,(6¶±ÕA·a èD‘a“×kû¿¸ôD7YIûÉF ÷Žžf‰óÆBª> ÜšÀ¬þUé{7°á¥B´ØçÁ)ªRÉ9ïèÎê-Ǫ7±ÇNp‰‡ÇHyÖQFX~þx¾ƒ Ï\úXÀQÜýé ?ÙbâTˆXŸêŠLkÕ— Eè‘rÚÓ]°­ ô:øÐÿø4îó¢ÔqIØ�=•NËë4¯¹wüåÊŽþðoÒè›Né‘‚ÅCî2°>=ñvv"èÂ9ͧy+L/%- †$õh³Õ’¨Dc— §]íyz¬¾¤6ºfÆ%–î_ ÒÕ´têYsLž8¿®dÚõØ…O£4rà2 v?ô9"ã}½aò,E´{¨˜f&sA÷ïšú›…ÅqæºÚÒG\·êÏgg¶ÞË×h®gÚ…¶…ÎÔô�ÖtÌ:‘–ŒV7åÞõTSçJÌxI›ã±1¡PuïGè°_õy*JÕå¨EP}6žM.PMº ÷¦Wô”Y_8T³´ f; Ì`|åU¸Òˆþóß²ì=ë5F‚æAQÁ)èPHfª©×;ÁÛšü¹é�qº8<®’ÂÉ ÅöQh³Ò è^}‰t©Vãíé]ªp×í€/JKŸÁ@gÕñ@'aë$J3¤Tˆ5bd8$sù…RZ,KÐ’ç0†ø“²#AlˆÚR•öÄLOrCKŠÊ§çæú±°FIúåtô ’\ì.´|hý·x °=_¤µéÂW& ÚÉøÑÿ¢ ö¼x¶õOç"®Åí þjoñ ¢Œ ·¡! ªYó´’݉ LDÄ`>ÄÖÇ™Ãóõ÷jpŸšÒ-Š mµ.b:JþUs[nû—¶ýØpD7s[ƒ¼ >ó…’\Š~[:[*g.¶­É{? é{ÝÑÍææêØxä¾þ¤‡¶[ñ|õݾjé1Yº‚Êt•»Šü ˆ¹Ãu:ùÄã'ŽÒ…ÌhlaÉ/áÌñÔrÓÄX)£Ò@'ë|éת/cùSÝÒ^x!jx°W“Nþ©OtžL'¡âÇb‹î›°;3ö8ɲ¥HÄê�œÚÉïОð¼=*½=Ü¥;&½î>> L>N'FÊøîLaÙPÈ9Šß{¿‡–áó¹‹Ã8ÙŒÁS sl‘‘`§jfO‘ÉÎ'oîš8“Q�îO´Z.Gëúµëik t h6x=—¡/²È–”ýÁîGwÝÈ;ª7MóÖï›Ñ3ŸšÍiÚñ£`ŒêZ,Óÿz9毩svíxÏì7誡“%].Ϭû‰owYúFÊpzf\ B+̘ò¬NÊ¿:‘ôL×í¶`‘q+[Û÷ºM”Þž/ýº(¾•/¼’4óž6U›žõ¬�›I²õ­÷Èó÷/íÁ[¹¨˜@€IûÓùüDº»½€õ^6“ÊÕÒÛ5y$ ºy{+4A@IOI׹ŠBO°h¥óª±“q^ISW/´ž´7¿øæµÊtåÐ"Àï%PII>¸1¤óÎÚ¿R>ÏS§é±f2ã™­±¦´Z\Ä1Bƒ:&ÄCá®9gЭ‘ŒçSa­Ø1Z"ëÑK;u6e.P€ÞÚZ³(Ü=`"ËæD›.ÜZø\¤ÖX,ybý»Ze߸ÜÈÏ’ìÄEµWÛ–#?ňþáØ×Ús§?]E¡ÙAëúû7RË(M8þ,˜Ïô{ çx—9òª²ëŽÛ Oœ1œ&Œ¦ä«uêµYÅÔ£éÚØrÿ·…Q.d{èÔ“ µ::ÀÔvÌ1Î5zp5ë®ÆÃþ®tCûoMOõ<QŽðÙúŠäJyådt¹±1S¾~½FGéؘ»O¨õfJúZ푤€´ì Õ!¨4§ëøàRS¿,¹2;n&Jrª~ö”ùèc ãaJÓ[?ª¿p¨ò`dÒL§Ùö¢Oʱ`£( ÿÎgÖq‹C#]5O´¡gÅËÆ<øÿ¨PÖ¶F .ÖFÌLðÊXö¶Ižyv ´Cš!øtp(Qœì†µ¿¯>Ør½ú¾¦(•%IèEÁ„ï^„vÖ¢ QgÖŠåÖðý–ÏÃF“gæ8À!ˆyâP‡Ážóï[ç†O*£¢ÕÃB5Z+Â%e†ñÄÐSˆH3–êE}_V>-ˆvʹ¥[4Óu¦íµ“ù¬é;G¹Ñ*°‰¨Ì …e®9ôõFõ O–>°‘ÔàÔ®»ïºðàsF8/mú’ÄAsËU)¡28èåpûë9à#|y¶ ±$†Ð¿o{«üAi‰ñØòàEuÚqÓŽG1Æt:cଡ%ò@… N¨q‹ÑÉÉs5—’õbkŽF²MS¾Þ¯ò0MrüÓ´U3ã ‡EšHwíNŸÛz7]Œ"4Ô "B.n–OêµjXý•ŒôÓR«fë/—N¼Ì-¢T›Ÿ ‡PFaÉçų!^&iAX¦Î¯Æaq´ìˆ†tZ�ç@F9÷8&zw˜{2R'ý.õk³ÔaOEY‰#Ýÿi°*7Ʊqôrfy;#ÞºkõÑ]ua¡š£²M ­·g¢}½c|§ú9äçKh”G.ÕåÕ'RÄö6c™ôl^,Ýv+KüTˆ¸tžÈÂÊY()ßZk3ÐQN{‡} ”èt¤>/©#{ÆKTB-•Þ½Ófò žŠÏõ®Ñ:Ö^¬¶bW…˜Ï ÷ÁÅëíL‘êdS,ÀRò㺶çÝ Ý.{q?Áõ¶y¼““S̯% Ö}w‚uâÅbÏ3ñ¶u‘Ç 8T,ò–Éd5°üàBýå«ß•´, _6ˆR¶í ontéÂEÆÙÿ°Ùê®ù;¯1ÇñH B¤™hå[Û—•*’™ä/Ôã<l]ÄC:ªÊ£ ³vô,ÄCÇJ=ŽõlHS^5þninÛ‘ªÓ9%€i‰„|ãK4g¼€p=Þ3—HJ?Ç¥|å ú,ø}A>œLmÔ—gd£0[,׊Y-³ª0ÔïÄIj'xû¬º(+NJÌ ÙSA²óôñ çÞqÉQÞœþýóË›Èý0^ò‹ßxY™4 i•´Ÿ5§W•ÓV,[ŠÿR¤%ѹ·m ÍmÃÌBûxó±oêEÃ(á-ÝhÕV_ú ÛaB™=ØàíÃÆ–Ç¡˜yÉÀ÷ÆòüêÒ{ãÒ™7É =ô”?]PºâÃPw§ýý"zĹçø“!^¯þ€Õ®œÒÌŒµ›æâTx*ç`m4ª³:  ÜüžíO”µ¾Â†ë?fUÛ-%¹ëúǾ>ONgÎíÿa¤,<m{86xÊ6C£þ ÙÇÈÉ=+à_©2FQî>y„S§¡gàì"2…4=JîÑh%Q §ü[{õ°æŽýÎpÈÃœ†Žö“ª;ÁqP@¸6-E[òaáÎÕÍA'ڵʄvž9™˜i©tœº}45[„اxÇ8*©Pö#T•A6–`|&T)Wá3¥0tœSÆÙôÚØŽ?©Ÿª8ó`wÈö[( ŸmI#~jdû:£vÞ êâÕ@??^«âQ ~Q@õ®cf³u¡l°í~ËÓ±Ì{) ’‚»>{¾øý¾Ì$È–wy›éûòDìÙÁºÉå÷¿]mŒŽï“1¬/ïË%[L©c¦€DŸ3Ô*#î*í;uÿÑ#I2rIw:ÂHLcJ^ Þ¹‰iíüè(Œ£W(˜” Â!?*ŽÑ0‡’Ô³x­ô3Rx´<æm'(ð®]Õ¢J&–ô¾÷C_ãEü /2ÀS‡Q(ÚÖ­#öXp”žÕS7,¿¡ ¢Fp5ÕQ  Ù@}l¨ðÜž¼†ëÂ{M,àüDšµ &ƒÛÉ$?'‘Pû¥à®ÏAæ±—ŒófLêJ÷£ã³Ñu8 ¨{3Õ«4+¤<÷ÊMŸåA8¯M‰Ræj µS=ò¹À DŒLK7}B]Ù:èyÞÚrzDhd€Õá1¾Äªí•a/ü³bßÚŽ8ÎëlªÊiÓÕ+# #X_ ÿ.˜ÆIn˜¬,õ8•Žá]ÝtÍËÄuZXèkþ’¹Ñ˜Š–Å¡–v ‘¥Üšût0¼¸×GHKÏ@˜5Û·u¤ë­)Át~lî*Î&æ@šEPÊ]<âÐ'©k†äH èø«ÃÎÔWŒS,ÌÕ;^2±VçÆhn6LWp7ÇQ˜—äl76p@'Ê؆`MÅ¿^ VÌ´¯gKé<óU©¸]­iɸÊ 2ëðׇ.Ú¼´p™+>",oY]‹1 ›¾¦ûéÊû?å8mk÷Í<Wç4(×µÙièÕt’A¦ufüÎ{æ›Ýniâd˜xÜ®˜›V$oùa4¯TùgÌSúçæPÐäi·ÿªÐ2ÕžÇn^¬qú ­ç&ðh¸Ûd/3Ž5ÛMTÍ·K‡é9Ï1ÛØújJŒ5zÆ<WÓEÑæ…%=Q`¨LœŒÜ(¾›t‡žÒ„½wõ�dÝäË'ª5ó~òòßÕ”XÍáEû«“‡]±JÇ¿[8Þ\G2¼Ë¶r|iœÊ ¨DuÝ\9ûÑ…ÒSÉÒÅ?t"gñr/ù‹V¾á£Ã*¦uT˜ò`ú‚¢þöbê”�@ï›ë@58Mb/~æ øÒ/^íj+ê¾½@_f0/‘O=0®\¨|Á„–Roqº‘÷{RFÖÈ\|~:eþ'RåñXé}`ÆÃã¿^#²ž¾O Ó7‹öæîGIákâ©x¢BgsÑYr¡ctzÚÓ@¡–ÉXL”U. ý»?¤õ¿@Ý¡ËP¸°]ØWŠžÃÔ 2{|u­E)wUø–îBnm9  MÁ²»¬{å•üa²Ãó(Á”ØÒkB¶ePL Ke³JzHSký Àñ7b–/ç ÉRsEÓ‚ª¾8 =&{ø~êôW|Ñs.„uË —ü¼N‚„õ! ðWf ¼ye4'\·éÁy—ÅV“VlIš- ikôß+ ‡‡yú[/ªÂFÌðõ)%+‚¯××ÎçT2Aò+-4¾Oà`½ÀüDUºPSÎy€žm¿M,€H³72úÏGVÕ:\£\µ£_¨ýWÃõ,ôUpéà£0™Ù89Ú«Óz›÷ãd¤|a&ˆ N!Œšõ7›ý¬W�7¹(ò™7ˆ£çäFiuÜÀò´V†žk ƒÈ2-$y=_„3õtm–׳Ö›.zmà§|¼î&!#0a˜ÈoA‰çâÈÌ;¨•¦ßŸnÐx¬[HÃ[�1ÝÓÜ}ªNš.´Œ)2úrš½y‹«ðãŸpÓ¦^ŽšÝ·t\¶l‘£WÏúY±'$“±OG—IÿéeÛR” »#>"Ô†Gý¼,¿àB£×®gs¼¡Š£íÖC€›Û,ÖAô&®Kq8ŠÐ‘ݜ슪±É:ìÆÝCïèòР–JSŸî6 A4“Ù›`Š®èùcU[]$y\W¯"'IÙépŸ’–§.ÕcÙŽý·‡Á4‰ƒËÃSÓŽ)ÃÌøgÌ5Ÿ?R Öd’5‹bé�µFN‰è.ã|OÙxÉOØÐ<´]ãáØMžÐ¥x“¨p¿i\®�1JÌwÌ ÷‡ÞØ’Ñ©¤ã¹¶Ìt:A²•.VÛ6Sf À ‘“û¶kÂTŠ´Lyëëã>œ³VcålÊ•(PÑ!Ôºü¼ÆŒƒ™<;³g; øaÿ,^¿öÐï‡l NÈ9>0Ñã7‚A¾bÁ£U~ªÌ„”OžÝ{㥬ð=º!QSiÕ ®§nÛ‰FÒ•žýn¢žpž® ™”À(9vÌ‚’Uë¬l›Q+ºOñ”žÕBŸ³ …œåYO†”ÍΣä¡ðg”ØÓyt™/¼ÔÒ`* ©#>nv£÷lÙÜ/•]#g^šÛ~<$”Zã<^$þi)†3²šḦ¿<'mÚ6§aï†`AIVÓEn‰F0­V7¯lN }@WvtÉ‚]ÿõ|¹fžfP™ÙdÏN––<`û.åî»ónºk]Â[©‰ "Â4YìZ#$pXMW¾ƒÎ¨¬…wª-¸ÜyçˆÄõ¡‡P§´‰%ÅêýªE÷‘Ùï3ôÀ±L­®ø4áÏ,”¾ZË!A¨±2Ͻޔ³ËÎаM3ö˜s4žf7ySW@8jžðÙ‹{=}í%[QããBN»öz^GZ£EXÓ-‘Ƀò;õIFµ«šZñºC6RpÈféhBY°í (r¥2Qúòþ�¹ ” Z%qø7œÅKÞƒ0º™;$‡_ª ôÒ“%FEQ™Ü–ÉáÍQ¾Öº( H+�`'¿=r3¤ysZ“çÖÛ!âqaßôgͳGÅhê‹oØKGJß­¶�-þsùgƒ.šPfïðœo~�jnûuÜ“ÝÃ%¤lÔ,wÈ=9ï¹PßøQ;ý¬T¥_!d:×¾tËÜ 3çú4PIĆ–Ì“OgÈÛ±§M [kæxX:uæfµ^ �÷h¾@�Áj††ìÅ=[Èdu#›ho—›ÉRSX(±¨m(\¬tiu´còY;íQ±÷¸­ß €yeÒÚÌlôáLq<gkòÈxñ¸¸Ñ»½¯¶` ¹¯ÃHâÛEB ¸‡(dï+ÝÓ4 é±Ú‡úÛ©P™$ª¯t÷»už&ÏÂtû—æ­Ô…]ãÉMª 7“o‚i\€1| œQ¦Kªdœ£/Ví0s ÜnŽÓ’ûHõ®œ«N„_£º—·òD‰ arÄT±•>4Œ¢ÚŸª%ÓÛ‰=·k*"Çza?mZêAzÜxh-¥øK—¯co iôxü«xau"ZŽ%%ïú\rñ1Þ!JTJ/Ï—áCÙ%ô¦ú#ŠßÊa[Žà¬ƒ·À¦}˜(Âä6˜±1`2lÃb`3Wn¡¿“™O.x1‹0ÅAuú±Ð¯Ú(ãªNqœ†s å…òšÜ…&Äþ`šòšMŸÑÃ?[½ŸHÆÅ?fåQ5¿eã<Qõ³.¥Þåñ·.6ã‘Áa¦ ʵÕWŒ ­Ç\d1EþzImõbÑÿ)¨.ÄXË680Õb8€p‹/àD¯ Ùq²®fó½é}:`n‚j¬hP¼Æ¨;§x’„jN¢ÿ [æQÕýO9Óˆp¥FÿG8‘%!öÐ Òü• t%¾ðÓpÈ­ÊDç™hð_öŒ©‘“šÑ-5¨C8uêÒSÓÀ,ô™Q¥ £NNG&GªU³ ‡•ç/Š >’þ™É¥B®C¦|ÓßÄXàl°=?̦ƎÞ�Ö>6¡‡Ü_†§x`sà«ÐC‚Š ýQæ4”,FGµ§Ç8BƒÝñOŸ±c¿;BQÓPþ'“?"™8¢åç+¯sØ›×E»?_(ÌÑÉÔvY$míå¸tê¬=È‘Â(A}¹5Oó!d?9AÓ[l\iæ÷hÓV_…6YùŽ"ùÀã•oKöÐ0Þšnq“öFØåš`ÎÝèÀ^IÁL{Zêã§çÍ)÷áL‡á$¨y¹%‚E¾\>לô%q#¨¶Î?ôõÀ<óµÙ°d�~Û:¢Øm6|E¨¬Ê…¯|lò j·^¾Ú�ÛïY†°G؇ÅÈ=î敆ÚO„Ö6�h]¿û·†Ï›]÷ é1/ÏÞ=ÉQfZ^DDÛœîHç<'Gu±Íˆ¹{Ï› ¡ˆm¯nÏí(ôE©´ÚÁÕwVÐ"¬ˆ;*°?jb†t^ æù!l§Ð¯ÄÉðéïê¶ì¾ùÀkÐy¨0ÚÝqÑØ =Ù VX>Žq|6ÖÛhƒ‘¨�žÖ§žÿj5ðÓ×+í_ϱù}Ìjî] Û.‡ßzÞEÅR:¤‚H´=lÕ‘Ç"`çÜ8¯Ì˜Ö W/È÷TL€ç£ÎlOÛÄYnó ‹_¹ü‘M¦rc)¼Úã“Ž'§ü°¯ÿ5c:èà'ÌÿïÿÁù`NÂ{?{y:z¨(2úN”a…AúÝjó‘‰â…ÀàT âíÜÊag9DÓãí§@Sp¯†Œ²„EsÌ|}DÁ«®óÐƆŸ–nɆA@vC_CAŽ{šÏ]73×ê”òz…ÆRÚXåg˜2Ö€{ š{WhcM%aMað`oÑ]”ysƒÞÙz€Æ(+<Rržè‡ t]ƒÃÊgÞ', Æú¸¦ù^,%s6ƒÕý[É¡ØÒÌT‘wõ6™ˆ †Æ×@ŸVÍæËŸfƒ¤Û‹›ºs¹ã ½äAÙ+z4 EF^|=åýYî¼Ä—Äÿæ*'VU« w<�6gU€DªS†*ÚK¼ Îÿ0–E7ßÞôèçË‚@B—IÏŸí¥gO÷»±)Ü_±e" »â=Ø, jÍ%Ñ¿º‹I¶ºiR¦(šã>E$azâ@ðëkŠ r±Ñ™Gš·oeÖ¹êw(Ê”›îšÆÍl¯t¸2ßQ°Ï{YsôH—P¥9œ / |êñêvG¡ß=€‚�ø\ ~Ç–}è7˜’ð­˜)©lv_¯.ÎQ+ƒVk >»Ùé5P8é™I¨SÄWnõVz,4Ä‚Ý1NÙRÞ¼g"§¡aße¢ýØ­¾®y¡wÿØnwéù4­Ñ…I˜“åÕ {Öf€ ‡q*„æˇ±]~9S/‹üº@xZÓ @Ú‹;äíŽ"PûtÍ ÇìÈFhœr_dÜqçü®ÊÌóvÀBÈ«p:ÜÌû:´nTèþN¢¹v5^©8ª³’Ë6§”îWûít_œ·ôaQåjDZ‰B¦|–žô!Ì€õæþ˜¢0Ø» ¨ñõV! ˜y$hs¤H¿[~ÔžV» (š^ƒÀW7 Ñ^€âC=µøÏA]=dA¾½ør÷»¾Ý×óø;Å5ú뙉s–™]ö„›6ãMïò5Úä+ÈÓbPq[ =.Š²ÈsžàŽ3t>ªVU!ª’õ¡`dGqeÙÉ}Ôiµ¾ñ¡”ÊIpìiÿ'k]§”ËÔ£t¹ñ’ñó¼X¶úD1Õßû~7Ûác¸ß*Ôœ|šÝ’N&wÝ/ûNçïp¢½3WÌYÝxúó& ÛL w•=Ó«j9óH畘BQö±¶™7;–wê9J3nŸw&-W,8ÏŠÍ4©î \,s6ÊÐ7êßûÒA›OÅHu[úû3^àƒBL…¨jôÐô”HO\<¥�ÎG*÷Tž€?¦­CØEO¹z< ×dñ"[ôÕR­ýu±£é<í蜡Ån”ÚßXæ‰'<ƒ·-¨ôˆƒ²™½tÒDq ž•Ñ<^~÷P 9I=X”_èÖ÷ÞVÛ#ŸÆÃÍaF¬Þ»Š¬ø ÑWˆƒŽj÷ò[Û!û(ûÅ:Ïaê‘’ ¿Ï-p¹#KCL%}û©•{.õ‘‡‘ì:0Žf˜Ayò]îØÙYÆ M‚¤Þz¬ä¦ÂÁMøajá+Lh‘Ç™ãG&Ft7¬õö"…SÃFf¶t$ÿ²»eêP/ÜÖgÙ¥F‡QœÕÀç~×oÚhÊÜÂT»3ÄRn¢Xý©’®!Ò£qÜYEWñkìê¯î¼Â,sþ9³/¶”Á%ÍÖsq;Žò8\›Êüľޛž/˜6–N÷€‡u‚ wޱЎ•üëÓ`›¹W·Q¨7„Ѿ<e mi ¤‘*Nƒ§©wõÚJ€­¬eÌÀØý­+úxõ§®ucC„0îË~6¾8“Æöœ…ÁM=Uë–©À\ Q¢ðaªö‰ŸÞÕKäú¨±X@UTiUAøS+b²àòhÍ›æäLwA÷óýÊ* û¤™1FVô µ!J*ž×ìXå=+ƒô)݉L›V˜ûô?œ×„ûT2㦃  |5ÌPœJ½?xpíºR¾Æg,~¶[1z¤Âñ²^_†AûRõ~_K뮨~€붳ÞhËï=¸p‘ó„F®rÁ 3ÏâÄAÊ5gÉK’ÌbÕã4t÷„JJ‰ÚúÓ‹°ìÏÄ3û ¿ìÍ½Æ ÐäÄ ðJ¸`BF˜îÉñÛ™dÛÃÙ¸{6˜û8Qœ†žé ºó�u‡£N±wøñtä(ê1ëèfE|ª<¡¤‚]òK}eº`ðK[¯PC°ÕNf³u"9⨉x!óû¶k¥X{ªøâ“­3¦Ëž©êˆ·«Ìf1º0f-¨³ët„¬×Ä^íwÇX‘ÂzEeæè‘o‘;ðTÇxkù¾3wáPÅB?”N#H eõöGª<4ˆ¯æð}I¡"ñ¨ì 7n* ?ƒÇ¤4‹Ú m9Ê BƒÝüà•cl™Ã¿³©s¾7¦>(%OÒP·¦o–;øjÑ;EÊQP¡L ªžé¿¹XWÿ|fÞ7ýìð[¤x•^”˜Í«ì"?û©ì€`Ûµz “V¾¼#Ôº;fp%ì�%‰‡©¾1x±-n{ãEÄ?ÐmÁ¸ôãéO=˜iÁea(r8§É ã×�gn¿‘ÂI‹Ð³ sxsŠÑtsÙ&†}÷·ÄÚ¶¾†úÈ5§ð/ôÅ™- Žj»4ˆ­,['¡\è}~9ð6 ™O{Êé'}번5Õ~‹¶Çïà/–›šçˆî|eÕ>XåàÅÀI›Ã$¥«ÿrÝß.Â…J]€]Nªñ"+Fçât|Ýr[æòÐON|x%Bï.²ymšft„¢¦[7îÕû 6Ç­{Rô?Iu…/<v0Oמ½¥×6yÃÐÅ hþß¡;ÌÓkTg@Ë™I0:rŸê“ 2S»EúÇ|þÕöÔïåç÷²á4Ï034ô™Jlô7$ýQÉ÷ æ~ÙÒm®„”ãɶ¨ˆl—žLã€}$§ÑiJŠ¬]wvQýjýôm!ÏG+åÛvR�>XŠ…-wOÃjµ·0Á4ó—5LêÓ ûžž“™êb«Í‘’îƒHY¼cQŸ/ Í¥ºUô‡ê>E!g3IÛ²âŸ<2‘8ù•Ýî–‚ÏrÞ"÷'pôþAÓƒJúÐ"ÕVu#ˆaM{O[·Û N»š®ß¡…/I1B—ÙƯ&H,!+ ¬Î ü‚wçQoͨâëqžè¤ÎŸn*²­Ï}'ÿµTjå¥nܸ£Üžîace’sî Xø„ZêcÚq¡ œËñ×4²?溕ÇëŸxÚHûðS#ÒµgñRÎuénÅçwìr›h·´½7ƒéJÃ?°?ˆ^žSd¥5uwa„ë´üææ[ÂxlT˶#}й6~®HeÅ3¶¦T3„ó®HÆ¾à•«Aaã­øÓ6}ÄßµG†¨éázøwÞîËÝ ß.ƒç‰UBتò˜î”w¦ ÷½_Û#°¥âé ™ÔZCì!DGM¦ü²³Sï_úú|7§Û tsï|+–“°0&msqC+©&äW¾E’µ2Ç™ÉßØ8<êôhÏñž5Õ€Ú|yÇ„ºˆã@½àü'ŠáÛëìè÷k°> ˜t9¸4¶çââjBé aoòxP÷6µ[Âø/¾ !¯—ßØ”GIfÍDqbTÁL‰gi»†âO p‡ŠJþFº¨ŠÌ³¬¨{ú�¸¯z®<Fmõ—AMûü”ó:óÌ2¿ @JôEæä|0X7äº�2aŒ×ù½«û¬+š²ÒF쎘þ *ÎÒ׈ C '½€q ÂV>´J3>­¹g¾:ÐP÷ú½ç‘ üFà_/ôt­‡‰)´â~hl{ÚwW(ÊLk6*ŒX?A¨¢Qq"ØSÁWÌÈ›RjÄ”ÑçrÒÖ�F¼�ª`{DT·ðÀ’ù¿ý´ûWÛ5ÛnßÆ¿?Šs[¯ãi‹4K˜0p::Òsë3€– HÜÖs×ð£3É¡ˆU-'U· Òj¡g,0tÓª0…qÐò½^Ã?roØÆMÉsM÷¹·šì<v6ÜeE´ŒµÈhr#­ÍÔ½K ?Ò… 2›ºAuälნKv3Œ„‰e½ÜnMÝ¢Ô:pÎÙhõ¶–V[²„ùáhÕ³7ãn?)~\twLšnŽ¹*šqh-ƒ‰ŽÚW†¤Ëž'§ûW¨9§Òš‘æ {ï ^k”½—§`ÛŸöüÚQæ»:üç#1¯2x†+’꣚^e¯ÞìñfEæ±BFIÒŸÖ¨Ü å¿ê*ÛíM dæ 7ñ oµÍiOwCëÑSÌ0‘£99%{þ­¸}ËÜÑ—Z 3Ï¢ƒýWýìkÇÝWmŠ‡s݃ÜÍ–Å¿á3©c3±ŠQ;€¹€ÚL‘£Ç<£ÆŸYj§G‹ssWwÄs«ÐƒÑ=;ePn7šÖcnrb:/¼¯®Ç‚dÐÇâY€ ´@eyÊøƒ(1Un è»#Ñ `t³£vý—ÜuzP¦½ŒG¼£Ÿ ì6Ýôªg†<×½Ò°`kôCî/-UÍð¬ ÎmÍ>Oìc}ÿí™a¡÷?oéñ~0äŽÆ^åiæì‹p®¸[&Ûîme¶¼!”*7icÂ=GÍ|ѵà½æop´.¡Ùeé*ËPÓ•_jveiè ‘ÛAªçèDØ3îò#µQ‚Òá<=ÜSYg6Tš–ÇÁÒfŽ'+ýÎA}âêE.òýˆ(‹ü‰9Îr矛\2 PÕg ¯ˆåÁ‚àÂHvó¨YëàUÈ¢J ãx{øÛz/c+ð*ÖCaÞ˜Ú(Ë9UÑ/U”ΣU{-°fWm©í|VT+ Öš´—¢xQž†-#­1-âóET,ôÂWÓøØó–b¨7EY:\&§¢tfËs<t{Ý·‰oEÕ$ò*®�ÃüimæKå`}ÿ•éû™_°ÄtŒ"<)�Çï泧è}îX“@­W6Áµ/,P¨BôÕÈ‘ åk]²Qu²Ç~×ðµADH¢QÉ ÉQÓ»Ⱦ¾»š×-UáóÄ.qoé#—®‰*’V£)ë[«CI(ŨðÔ m„~¯cOü:A&ìéÓW2óbÉÎ:¨tªV ÒNÚRØœ†Àܯû°N‡Oµ Ê£æ4¨>µ9„ Þê¶`ÚŒ7ü0âÜ:¾^šôà€³´rÐ WÂeZ"ÿðŸ%,ÅEÎSþñ/§8ŒªóÛ ÓDe•%XPÚ(¹mvuxð0|iµvk½V*IW˜™Ñtf±¥­wÿdzcçÑ{2 n”ºÂzzø» hlvÜö’ùM[zƒî_z²Ê¢¢‘K=úSQ*'ì‚}­ð˜&7†(¨XÎV!8÷âºs¦Qzýêb¶÷†¬KÓ²‹pge#ÑvÅ¿1\K¼² TäAZkŽ³Lên`´µVZ+»ŸýË¿±ªÈÓÐÆ„ØÞ ÄÁSim; O–¾·ãœÕ¼J÷™ t±¤m##qç*÷8Ïë*HNëF"Ç*«ÉÁÿµ¿(±Øz¬WoZ<$ƧZË}ã¹øб¸óˆroô’ckWUâ¸Åìt69ªaô{*¨Déæ`èþµhmu¢Yê» /§Œ†HôKÚÆ£?P™ûÇ#Ús³� Ž• #ûâªðŠ†2 è÷Ÿ)δí@úvâ‰óX Ýñ!Ù”B#Mɨð|´¬ý*ð•}ø0ø \xd%03#•=O”R„ã·K¥#q®w½¥ƒ 1Îý¡——ª°©íj –Û1·U“Œ[° D¬¡ï*‘à]>_ÜÒ²l/ôÖýÅ뇛9’™µ�Åáñ©¥uV.dš¡™PÑ)¦í˜Šµ‡û®qè¨ÛѽX®m™PèYÍEP v4ƒ.PÍ­ºs~åK¸G\xI s>¶è'[«ŠR É\ÿún2›TvW þrÀìùò¯×È]Õ­ÕçC“²÷4äôúo"¤ ¹Ÿ)¢¬¯ƒ×´­õkYÖ4ö´ˆØË}['´"5ŒU9ϘŽ¯]£åýHÒ;Ê*‰ÆT*†AØÖ¢rÅìØî²`ÂP‰cnÔK¼sYZ°/>9T¾(5<Y-¯s:é «`t#_ÙÂÃl/´®¬Ò;æ–Sxn<–¿%*®ã¸;�çöŠ—U®gÌXÅvHƒìØhDyHrv\Ú7;0öèŒEÈ$ ¾fZˆñÖðÂ’ïB[Ó]V_›#E;ùʧBÇE»wjf¾^ä}­‹Þ857l”ñz–FÙ’ž,Dÿé-’‘ÖS ñ.ÂâBdþfP¾¥£¡VaaVŠì„/dŽÌ_ëÞÚQf¨Š._³(ÒxðúùcÓÆŲ~Éù;,ÒÛ»?|Ì46 ™v´‰&ûl1‚ür ½s×Ú[÷¨“¤á¢T+ÀÔÂOM¤‘ôö»ãqG§±¡Æ¡CÍ£R ªM•ãu¦íÙùô;ZV¡a°;Ò.ø´CÈŽ)ÖwÛƒFçÝqblþõ«õ8Hšr0Õ¯œf+(ØÞ0fžóüâ$õa˜”aÀ)#:Ù&~Xˆ5€0LÉù¿Î-ã_gX·«˜1cÌ CÓj­8Ap VõØÍQ³Jêû®ÿš;„e±Iw+ †MD›O/æRq @îAA샗ěìóù¥©øö1\PÖf¢­œýa2¼ó}Uoô7‰bÜý©`_‰Ç,Ȭó3(Ü›÷T1yÀª ȳšé•ô@Qø–l°é¡À–ýûíiùÕÇ#Ó¶ìóè©kpqN0è]‹Ö×Â… ÞëÏíÆ¿ô3ò̓׮1Qé¦v2ìbŸÈš«ãø«bwQ÷–…+/BÜ&™ÅN–¥ì$]À*¿eI”……jTGi\2~ºôyµÇ“Žlê“PÊèý'Ô_ÏÇiæ§Bà®PüªÆ­ëdq®Í>¾BÑZÕN„âI„}#gtl¸}»#}»±¦›¬ƒSûд¯nÚ@èá:,Ý™H÷(Û§ ‰r¸¢vuV…²n׋ ±´Á5âþWa7ÉÚçt<hÙ·³a#ÃàòÚâx7¾‚Çã=µw`RἆP¾ñÓ°Vζ9çN¶¿¾žÇŽÎC}ÁsÈÝT)2„ü*(浧aÒ6ƒb¨°{ôîå²¼.Ã…$¯Vwõ›9Ý,ÏßwQœ-ÀHe@‰^Ú+@5NkXÕ£AIþÌãû'ˆööñ@_âÍ¿^ezè;Zñb¢nÑGÏõk+²i,GhÓ[›Gu$¥ÓYŸ;@õâ‹-àÆa>»¶ËÚ'”.mÊhü'®=åØP ¦¨ sb\¿ÞgfD•ãés„8Ór?~C£îç²­¿˜újÞØ™3Þ¹Z’uÕmBQ[úËÉŠÆåØXó¿Çz7x6½Çšµé )ç9Ó>¹Vx³v˜ì‰a‡é Õ60ÄŒï5̶½~}�¾°3-Î=HAßÎ)›Í®<¶7n·ïnËð÷ÕšVPµíÕˆ%‹RàkÍVÝp¡HòD!ö§:,gpìª úV ¨ZX½ÒÒê½|fiçuÂZ»Á‘çÈE¾²t½æÆsáÆÀº>–4ávR&|{1mǃSŸðÆ!’ˆÁÞLÚÁ« èÑOh¥k̮»ÁhR]•8y±ØûQFqi®uLdmž÷šlq<aHp ¶â³q·„v)yÆ…S c„Ãì55¨Àg†&ÏxŸqƉÏ:‹+Pƒ‚Ê.ZàA|ÈqnÓ·‡¶wÓ<ã+ͱ€RØïå¿ø'Išr:¹è†Ÿ=u}ËïÀgœàÈô”{"M7€C©€‘!-“õ ]™ñÓ½}>ÎŒf|XóŽ~–—fVáB< †M’Åim:Hó�"“MßÕ²ªõB¢ñ£åE>pŠ’hAZ?Ï\*xŒß†é0w yÂk¹§Ãx8ùd¯þ²—DüÝ®_™û9.4º$(¿õ¼îÃñÂ䘆2MÎD� ¶ Š÷ùC#jº–¬ßvèsZ’£ìÃ0fÇùDÆúŸt‰ÿé)¿ýÉs?©\ïQaìì7'zÈQv£ï®ßf‹†ckgc¢ ËJË’Ž2>'fÎV²²§T(ðä° ø¿”§Ž¸Í~?£ ÀÛÜ¢p|‰˜k£2H6sºS]»s âûI&0z±ìÆf±Kƒøí¦ nÎÚ+I›Àï®xîx¿AÞŽ$óÒÑ X°¯‚üódxÁ•qnr¶PÞƒ»yÿܳE*»þ5çAÚª:N§öзVЙže³EGsñ^(+Êù¥(S‡íÑj08t¬a{d´Ïi,ÖòG`Ç@ª4´§ D.M¤WéócZN*ì•­ ù�pA–$!mbÑ5â]÷5C¿ Ó»Cold*l&êÓÛõÖDÈ.ýÈseÊpèÍèwôy&²ÄÇ#nÞüàÞ/ò;?«t t§3«‚6í±YQJ§Õ×À˜$HAÀ`:Ö‚5ï™»Æq”yÀä8ƒ!e䈋B´îkM V}½ò,(¯¾½u¤,j~ȹᢗ¯Ô],aû�9pFeÖ_‚wç>Ö¯,S"§™aý_ôëÒÖšÑåµ´?ט¿Ú×Z£¹ø5Ð=(ÇmÓ¾vÝÓñ;h·hçÓÇ]6o.aþíq÷-õ)4Vÿ¦§ÀÐkz†³q½'z÷‡Öˆ„ ¬å«=<5UŽÏ1…›ÒS¬‰zY“Iμ¼íŠ†ö@Q5+CŸÚkÊ[=áã²Ä}àt«Óúž»'Δà7ˆÞɬ»!íSÌÓ.žpë/DN¬sY¼vȃò8{ŠDì™bŽªÑúÃù]pª¥bóL�´  vëQÕä pTéró±º'a¿‰ôÿ¦ß­ YÄèzJŸ?ÊtŽÜ c^ûÀÙ¶hÁAá+B‡ˆ°HÞ8bÿ˜Fj9÷Õanhá®îÉTäžÓlV5Ó§ª&hôa”0…F·M› L—½{ô㎽ÕNÀõbzS™daÜäžh-:øÆ›Ó ñfJ,W2&BüÈ‚d¼xâ¬xJGV1‰ ªâõ 0ÈæG|Ýù^ý¿s§@dUÌÞƒM~@ˆï¶²&))0Û¸•ƒÉÉn0÷VÛ?4ûa¨‚lž=c^¿—dôŽÞKÄã$¼È£~Ë«ôæ¹ß[áoaRçÜÒ˜q/ŽÀ¿Ì’£ÿɪ…Bx§†rÚo…îòF@“¤s¸TZt¤•%š¸²$N?æ4Ví&eæë"u^nÕ„H‹«�¤uÅÑà™Ìyœ8±ÂûEt]æÖ䀶ÇåC„—aD?¢þ==K"v݃v[mù탘óÑ7.|²hÝMŒ+»k gáR„ª°2¨fåñ%<jX€öð0Ä„vö|¼Cq˜žõ`‚“,®«|Ð)N©«2¥%9óšmÓ•gÊ¢©fº–”“l¶tÎuÈ|Ír´Qü¶ªïÏg-‰¯€ö/ª#J•úßõ¸â0qÈ_n>›Z” Z÷ã¥sç¬Ã̾žM3_ýî1ò}0뙶l:j°×Ûw¥¶ÓÜðUï &Øzv° m÷ÚɶyŽ÷®l·ÏÚË`Ü3Èfò qrÒ‘z½êë–ò„ñ®(ˆ¥ìåÆ‘eèò$¨ê+½”zê²ê6eî­»BG³ h'.ªqä0WÒÒbi¹@O!)”Ža ÚF´s:2*ãvúCÓ4Éý¢”"÷¸…âÆÆÁ ’ÅžSªýÌý�óòéXxØþkhuÈ‚ÐÊÈ2<–ª^JÒJó›wG¦=qZ¯,éÁÆPï¦DÜ ÚD‘ØØ|�t8O(.Öæ4{Âwt`­Ò(ŒÚQæÆÚi¬¥„ÕC+wá™{­Õ–7ÜÞ˜VgÁ‚ÑNMê¼Ñwm’¤_üxaÆ>D›U FPO’[О.§¬Å'4`q¸sÑ ² "ÏÔzNÝõM]† `BºNqÌÛmc)zøÖ,A{°{Uâ æ±ËöH™è¬³ >Uéø‡æE§ð à׫t[†;ȸ,qœ6!^0çÑ OÕÙ÷–zÓvìΤrï’8Èãh/ø]õÔÃ÷‰Nűü³Ó²nìa¸p…9±Ã"W‚Kð*džî¨šfÎVpå=…Ûd«µ¸ÜñyŸ:P¢®|ó|ë“RüÉ(˜­Ö²¾ð*4=<,:̳›:j¥Æ97ÜoÏ =8ÄŽn|MelòíùÚn/ž53Ñý«ÃUÇëd[cÆBG‰é¯ EóÓi‰ÁV{–¢^‚úŸ|jßš9ƒÈeÇ£7q�íÈwV?ï•­!'Êž¾¡Ìüi]däÊÏ=…Ž¾g(ÜÅÖL¯E2ÐÉÆ<ÝPŦ6ql”e²æÿ|Ä¥róò…¤€Út‹^êò;¨Ó­ó[ Ñ"y!_ÕçèÒsN©ê¦§4‰þq× 6Ñ]Ùã#V›ËX:" n¥ =’#­žëó Ë7Ú(zœçM¤ôÏ_À5G%óä¡X§Õ–ö”ÙlÝE<ÌëcBiÀ¦F*f¢xÔMÁE™ç[¨ú8ˆ1††ù’&ny2Ø¢÷ë[$'Ú¨ø¢LÝ€o™à åû£€ÅÚ‘¤ÎT[ÊW¯¼ÔÙë,ˆÖªq²Nôv¢;%S«7$å}¾?ã'æ2Öd8Z 'v{8gû® ƒ0 òŸ¾ªådìÙž„ "ô ú¾xàû}×Åòûç…®ð¡Æ›3=½ZQ®X™E¯û«5)¬[¹ˆYí»”Ê&OöMôQ ’¤ž…(¯û®æ<¿�êAL¡œGzËè»ó‚X7,=gᆴôè&OwцV+¬0wÈaÅ£Ê�Ž)ÚD›î‰"ÖÍ€-J³ÅT>£ÐM5i7+øâ06FæÄù5&#”fí•cã“x^†.óä&ÁÐѺH·ßñ"ïÞ@²eå°S†va…÷¾{Ø6T™ÂHª±˜ja䎽©âÑWÅ^á.ŒmM¬Vº·—¡å^Û²Š·ÉPµBaù¢‚ËqññEpÕ=¬ý-oþ¤ëiÛ[MÖtaæòØ- Šµ"ÃK‚u[ÛÁÆžwu刹r.ÝNV‚™=ž§Ÿ©ôdd!ÿL'z6ÿìñáoòŠ.à C&=.Å +¡sµóæ`"[c© Ì* Ä+¥ýõœŸG>‚žb|Ño­C¼f,´öÞÔ ú^ºvå¼y‚¸9KÐh‹ o:Ÿ@8· 9}Ga[iâ⤠…Ë„öòhí+P%‹9íò}•#õ=SÖ¸PãšR='ŠEýèT˜(ƒß³5õfïÀùqšëhå>¾–Ÿ-vX»ú4ÏƃƒÄbaFQîCL(~ÐûùÑ› Ëf”Ádªõ`çò ¦£Ù¯ÄVËpáSÈ=±ýX »Dξ²±ß0¡G¶ÛÐRîUj¡Z—cå&ø”;%º£0¹ÐßAæðùprfArS–Ž Ô×.ðÙR‡êRœEõÑë^º3k‡ÈÚ½ˆŠå›ë«ð$ÁÅ›äÉïÉ ™¬®¿ P\;åò"£—Sø,ÆÝÒô’6Òé½{PÇȳB•ÑÁýÇŠTÄë݉›&àF¬ú2UÆ™+$(MSèéïŬ›ÐÍÝat ?–ÈסíÍ^CRßIJ%Ó4š­êÝÇ«`QStôä9¨²·‰ÅZ.hIwèËŠV:”«éHJ­Z4ó©€e ²5«Üµ«Ó‘òσgæËÐÁ<©Y[­œVôº¶Ö@v6†L¦]"KTÜ H®Z¨/Óc{�Œn ³ÒÙ8d :Ͷ2·EzPxT_H0£5n¬¢XZ.íÁí<ô±¯Ž5KÌ—Ç*k-™ En¼ð!¡yÓ¯­ÇÜ(Ö´Ÿ¾r ’£VG&]â˜Íâã»*n¶ñÈ+peÏ4²¨æØYsBÊ/ Ó]m)|Lý=a^%ÇýÑ»O“g¾Iñ†¡<oq±­CÅ% ÂY7ÿzÞß}WC®Ì83¿‰ÎÎU Á˜Ž%Øÿ÷¢›” €ƒ€0Ó9V�¯w­ø»ÿò^º2·¬,¸k¡ÄÁž¶dÚŒNDÊS9‘1äYöÓ»,œÜý—8²g˜ŠWÕSɘž4NÓ¼ëlO`Ów“qáe£ˆ›Êé/€NâbÞ™Òù#Ñ{ &£î!rݸ)æUøí”’ w32ÏgSéó@_r+ø: e–L§v½7 uàƒ´EC|ix”&EætI ÌÐÓ£ÞX®qÙ–Ï–‘m*®9tžæË»-ŽDßø‘`*â ìk¨È:€½:‚jXXŒô.Æ~̸²·ÐGR`ôiX«?1$Ø-ųrú|ÔYóÔ-O:ÞåëC± ‘û/JBŠz4E§ÔNÑb0•ØÜø,—çÖËbZöPl«(#—õñ,GÚiÏ<©Aé�ÿ¢Ì;Kw�ötìs<§&zŒ¾˜¶Q°¯·râî5OÌÎT¬ŽÿzR냦}O@¿ŒýN8Ó-$ŸgOM%>äme•| "…’W?kœ±òw{—~¦0“8 cAlù1ó·fQ½uj×wš%^ÎÂnTŒ¬†}QH$¾¬t€�tƒçP@zö™¾eÂ�½ˆ¤oSù—‰ˆ´Øú«úO‰/FÉ6‚ðIÅ~™‰¥ÐbX§ÙöÎìe9 5û+¹“2ó{èX÷´­#GVFÞËxB)cOG«ûðpJål•Ec-‡â_ÄŽ,ÌìäšÏõb]Ñ‘IÉÎqq)«ñŽ å5–1 }½hJÕt8·½«?×ýnAý¡î•Fª{ÕǾo~#&eaKXŒkϺóÔ~pö‰V‚X¦K®²eä·õ‘¿÷î.½ˆP„&#à´ÎZ+®1×ð¹Ë{#Ýž-eæŸ-!ÏÙ£YS[¨À�Ãa‡É:Æ–èå´=ñÄI (j2Þ‰ÎâHÝ�ßìsEžŽElôÃé¥Oß+^¢îïa&S¥ißeVzmWVç¿@/:–y ¢–׎¤×æºñ­¹î;vºš‰à…ªïŠ£v²Lº¦â–óf]WEeèaT°-™rEÁ ´U#’LйŽ=wvŸÑ­"n•$úñ@ë­°vRQr 8¢S—ÞãiŸÕB 9O®ú·™­÷g÷gW[Zyt+l|Ì®¹v4WašiFê¡h,æDúÎ÷Œb|›Óšzþ­nmEr ß±óÒŽºíúg·Ð  ýâ/*"ß³RG0-š>¶˜ÑñœLë]>M_°Šäž¹üõËï¢ÿ)³E>> ˆ5Î<èãÁ¢Á¡Ð¾ñš ¨îŽ“Ožx %>¹˜’¶7¬øðb ]a<Qè(û-·Öö�/Ï}ãvoðÅ]”éÍ™Ižù˜Z¶ÃH1¬G×°‚@ÛóÈÜ„gÆT„·É‚oôð×èþPÉ ·õKqf9MC(5>Êb6Ǹb…9xÊfQxöÆD©Ñ¨;ìÿõÜÕP{w#«IªýÒ{~Q/Úôi0 ´áú£GE42ÄÌd1(­7ÌáîÊ,WŠÑ$`¦ýÅkåSîý%†Ffœ¶ÌáØ ÷]2žÏSTA³1Œ­¹]½už,”­>.ã%%³ÙLCûìÌp^È•Ìá‡Bó·†þÑïx H:š" ¦Æ ›ãF益yäáàÙ"kú9ÄL;c>a Å©T»›–Ý K*D¾võ+%ÈÌ¡äJ£ "X—R!§ê6¡0J³à-áÁti”Òv¢ç»=›YF’¬Ô¨UPUòáOÇ#-^ì`Ú}ãæån_.¼&èƒBƒ¡¿ŸZª²™TÖM¢uaåÞÓaPµ`1ñ‚¶kå¼u­¶í \¯õ.Éü«[A½Ð@Ï·'™ì™ ™Š˜¦X’·´Sï¼¹–´ªWÿÄDõÐsÅt¿Co@™,5,‚,.púÏGjjÙ,ÔQñÛ�Ê8\HDÒŸ¬BnÄ•˜u˜$¥õˆLï`JÏý)ASÑsø´µLÉB~,äÜVéêw|ìŲUóË5%qEõÖà, dqI#]NU7'5 >’;qt}™»–ÐPñëMÀÇæYÆz­z¤î -•Èz*Ú i“Ѩë4짣ðææ¸oÑ%]Ú‘¬çv0u6îÔ´h0gõÜò(V\ŽóG7QÌŒxÖ«lÏsêÙaJú烞þÛaö”Z¼e¢íáG ê¡9 ½é¬CÏØ¡ ¶<:<‚ «>rá‹‚þÍ2N2‚É>{1A¶>ú¤FˆÞjªóë™sDÏÓ�–"Û@è혒ã¦H(Z!˜.bVy¿3xúDgÐõîë*å¹iÔ‡¦b:Ú·ÉÏZ½’�/:ÓíàgnL"ú šqøªôïDrš„>p2§ÙÓIó`ËÛ\eMgõÀL 7bAf PÌߥXjjG8‹H³æ6s¬èdä +ÈÅÌHOƒ+Aõ˜øû F*Î= W¸œã<°æŒÂÜwg‹�Gå&¼Î>€MW!51Iܵt/5ð¦`£/ÊÏèöB÷ÁÁ##Æ›më/Úto , m¸,¿Û×€’ ôhº‰sÿXç Å‚ÎÚþA…à4Ÿj ·¿Gd{Fi‹ å!¤F¼­½$A2w.Q£ÿÖɃ¿�Gq{í4ˆ*ÏÀžlHƒ”‘¾ç'ÝÞx¦¹o aÇ6NŒZPʃĪfP+¤âý5E7Ó­„Ñ»’³[^Í0m+:LÍ(œŠ²³Ví†2üeMß"TDi¸€ÙGÌJEQèã Às£Â‹ µŽŽú15ŽSWÃ�9Ì–ÞÙælHßý˜©ŽËF‚¢ÂD¼§¨ã!Î9vµ™¿aüns„é4 ‡í@Іï.ããÌ�ÌÉ`îv›A]Àz—¤siR¥Œ,0t$oxÞø¾tìñ5l¸M3A;±H-‘äT? õG¬<mÿeWOÜÕð°n¡ÿéÂ<-f¶ e>Ø=žÇk{¶~>õe¢`%Õ—»ˆœu®fè_ò…A»„´ò?[ =¦#}E…… ã¹ øôD�M2–vŒ,Â9eaá–ŒÄý¿Wt,ÊE%SPÎ £­Ù‚Dy[Ï;D²L­.¯òÎLÛª%ÓÓ2t´Ã kï/óƾ¿tS@it;wòï¢)³; Gg¾³tò@¢\�ÇßsÀ—ôWPý°ˆ‘QeŽGý¼.Ò6§´j˜ÖJ‡UwÍdŠ0˜AóL‰£‹“íÍc.óH� \!´ÐoÜ0x>ÐyÀÜ!{&¿­ráÖ”Psá1K…dºnm ÌÙ±ë¥óa~E³kŹqÖç­Dl½@^BYO³¥=Uuž8z·&ßtîÇ…~ÿ«âµDÅ‚IU›>‹=M$y†NLêç„„süxJæ2×ãg@Ñ™þò¸?Û¤×^»æi¤æïú×µ…5RF=æI·!(‰| púÅóñèÔHYÏÄF5º>[EïúÜÕ=Ÿå; }q*»šœBµS´åY—Gïw/½âØ)˜!S¬Þ×zÔä€Vîö‡yK[¶³†9oâÛm+ŽÕ‰Ñïìü¦æ‚JðþRA#‰·¾ÕÀ3ŸŽnyÒ³ô%<ìãož±c“ !+%ý½zaÓ·Cyö?“¸ÇêWšcgiæу O7@ãåSCmƒÎõÍ®Ÿì*ºÔ\`›Å˯×RrÙ"0˜vkÖ«ãŸôuxKH¾×ÞÀû׬X$ršˆ%ÝšÁkëÒ_í ºÓJ™%ø»+þì~ãð HZ¸†7/Õ~¢ûuúÇd D’e¶Â;`ÚìZšx�Áºd¤Žžùo6[l1-†—ub"=gÐË–-e‘_?Á¢sN‚lúñdóÏ]ÃÅ»ù¼¿šÔÜ nRšòŸÂm«Yå¬(Õ·¶Ôbä$Æu�¡´zV–´‹c[ o÷µ¼Ã™Yê#æ••ã\@ÕŸ.vÚUvý ®¨…‰gÌ4™4(­¼ (¨ß'(Þ®ÔËóQ;Å5õ„Þ^ÉL5öfÊ@Jnʯf§iÚ‡ôó¶'”[AF£ t>*€þ²ù¯¸qUfAßKÞ'±…MÆÆ.U@/ªÈI/b^ç¥ ó(˜“‚Y¾$hTÁy¹OããJyª/›Yo“L3 Së1”8öEÆhÊŽB^d"1eî)à›Ø4UF3…i“÷r…t¨W´–Xû«m¤Öø‚Çðõ0ÔŠƒë¯ }ùÂÅT\$h!åHaá²ö|ÄheQMç€AA×nÎh=*ÊõEl(·dxÜãaÒèß­ëûºB†0:CÆÅí =ßDnwöI”kÍQÉÄÂ�«âEÞ| ‡³hûÕÖšwßkØêô)cÆ5递÷®”ãáLß.ÂDЦ®Ð_:íñi …<—\Š„œ­ûuTyR$êSžwû#†Gôß­¶”š0‚hF×÷Ó/HU¹#«J7àª=û_0ù5-»²~߸ð)¤ôÇ ìh¾Ü‚< ÆYM:›1`L¢bÁ%(qŠÓo°J60xÚÕŒ;‘^³àcÚ]KùÉSÀÄ©ŒÙšf¬‚êSSB|x±v}¬$ ®DBä®îñºãÌcÕEHzè7X!:P6¹i¦ §õšáðïf;‘YÅc—†"ˆl¶±2´~~‘-pßÐÇ B¢†Å#ëÉq…©²¤sÓ .\s"OBŠp�OÔ¢L‡v¨r7t2X0òµAÙ_–9ÞVj„fiAeAö­øÛÏå³Koca¿K7k u#æöŠb”å±ôþå¯KÁ[HƒdsòÜ`è¾µO9>í_±–$ì ŠÌ¦Ös8 ä8Af%úÞO!~·22•6½K«#*îömÅõÓî‹Âû±tFo o-¿ípMn}ÖM êm£oK²ÐÉÃì¢:¾53¨íÍ$‹ z-cäõì ±v¬ÙKO4⸧e~ôT¦¸p÷Eà;`9Ô&ƒß'T«´ƒ˜$ZÌ—ð2moOyj¹QfÖ´¤ ³ïæ;RžUœ/fy`8GgJ:µÒØ2rÇüfXXYtŠWTM\ï÷¾Å5|¹-‰ô=\¯/[ÓÚ�Ôãw0˜ÇT†=þ~¬)YÚµ 7ÓroO#åö§é/<”Ò©e= )G+ñæ~=Tš~ͱ£$âÓ¢«A,êÁCÑS"Sm×!?^J�?×÷NU™tBWÛè­­k Õ?ôÙ÷Ö’y7RؾzY„þ\],n‘"É:…-TËïì$Tf:tUþé-�Å7—Åè.¸€eŸ7ÞoÿmRÍ7—¬‰qõeIžá}:Ð[—71ÖÓ“tàÿîÕbªg>_DèAŠµÊ ¦'‡“Áº>«”+O†œð푧²þ´“•‚sž¶c�Ѻô¦_wç S×{ýR; 6ÚÓY0Ÿ« ¶µ>æÓbnˆ†°q{ñBµ7_Pöèm§"ˆû“Üåס‘Ö¤bl»µÕpW7C@÷df†vì! ¢™~ŠìôäUâiU¬TöÃ` ©X^e>ÿ|¦#$ÛÎNÁšõ²”èvâƒÔSØŽT mŽm…Fr5YÉMA4ç6Ÿ*4áPC/u::/´¿Ró¯Å6â,áOëD·Ä™„qÂ\ Cö¶‹ç<%³pÌ{óO-ã²’1£ozüÖ 7¢|vIž« [ÅuEµfÐ#@À¤£ÂL8’Úêk¸å¨EÎC3L wlÚ@Üs½5÷¿tr„–m7€™g^è_žŽ]¿)X°Cç–ö–½áLÍOˆš9Þ÷ZûÏÇj ùU“;È()Ç;ÿµ4õxá!ì–ãÏÙÛ +�~8Lp Ò'ox+çÚÔN €¹Ýž­ú]ÆmÝTÛYìy7³FK͆WpõâUbŠ‡`¢­š•P׳§‘¤jôoö'õñH·“rà0sx?Æ*`I\A)ëÙS"›kÌð0ƒ³1Hmð[< ûp‡à~‹'É®Ìå únqtš“ÉÒ_Š{/F—ɧŹFÙ:Œ@ÉF°ÆvËu"drýOßýcüˆêm»c™¥*DžøNP „« ­Óì@?ŒçßjÖÈm¸KHÞïð~M_7—[]WKÖ1så4X_ÀŒRäOå,ê´a~O‘Ö]k°¸õ´æÏS$íÆ¡èÖ§ñßNjx q —ëëÕðÆrÖJ#µ‡|™Çqè¡ _ž ÕTO¸`Öðâã¼÷'­H'mαsºYÃpø±ó²ešûîÔ¬,|ãg‘~–dÍTm\´ÝfµÑjL±>Œm²–¥w]šÜÿ©7EP®KàÑV» O"–aú¡³i§Eæê„ ö<ˆkµŒéíE´GͪîþV%>fD-–í& Âõ§idå~ÝÁX:¾7FÞæk@Ÿ@qv€5 ™×dV×1«Ìð²ïè�þþ×ñTx*d¤¿vä,MW£±?z[ië¤Ånö“†d¦Ád¸SÀ<^PqòzÂÓxÄÖ( ¿—Š±h_YÓ˜P±)íÎƺ®‹\‰ýrßÚ°ðý“YÌ!#Ù©8ƒúG­+ŸíÄ;QÈ,£j¯î€Ã²«ØĶi÷'ÛÚäµ¼L÷ûk3%Pè2´vA=¡Üá³öê7ÓL¾îuöÝy7Ý%fÇñRvØô±mB’ö’ÝÁæ ·dšjž/Ý 3ìÈ3<5^3=úSk릞Sߺ¯OÃÊÈAÜUírE„P›šç,?í7ÖSñßë×Û²¡²?ü_´]$³Û‰vç°‹оž{à_ôÕ1~à˜ž®œã…TÊB×kÒFܘû%S¢4àÍ«ð¶oúq”%(*6ÇMaIæe}=Í#³þvVkVu¯Ý꣤r ÞŒÔ0)Ï5ËTÙ…ÉQbuÖ°äµúy9ú #>Ь(.ÚaD¡âw$ îèÒýVE¥7±çÊnÚä< 3)ZlhÁˆÈ€­Sö+ÓçwK^Ö*7ÿÈiñDýS*,,ˆQ|uÔ¹¶^‹k¹©ÇëQœûÝZÚâ &<CkŽ›‰Ç&ÚôòŸ´0ƒ¹¹í†–wmßR0Ê<"17‰!|[}Nã†RulïZc<ý¦úIR.8ÐP­>S\«ü'b‹SŒzÇš'r"ƒröGŒÛʱ÷¦ƒ0ûá†úŽ;%ß\ðFÚþtw~â•3¡ÉÐIj¬u2æ?gº»N"ñþøçÎÏ®g©Ãjá¯*E,TÛcsÂG±Æv|–¥T$}Yææ›Ê`‘j£EìJ ý] ÌÜŸb±8ðˆêQJ™_5_¢RPÌI^*§IiSšÒ¶¼1löŽïRvè½s¥L+–꧒R÷±ö¬+ÙRÆþ5ŽOŽñšj±sdÝ3„ƒ£õê@©¤…¼ê0×{àÇnÉïU”¶Tˆ€‡wh§C`¢)Gg]ómÇ4TCjúàîY÷1Ôÿv÷~tkn´ô£0R„tëgŠ¸§?}DïÆÊB(`Ïeçò»ÇéEá”.b/xÂø@Ñù% ­.¨ºf=‚¥¤µŠW/t¬£°\èT`YQ3y¤pˆ”³z‡Et«"È#•×óH †c5C O—Ë#úE7'ƒPït!Ä£7¡a �)‚p£í;ú/6c­€Ç*/ Ðc úÌêÿÎ1Kq㌺ÚÓBªÖ'óË”‰1¢‘ Z k}7îVx”Aô|ŸÌ’©JŸƒ·q:eæÎÜîêws­:7¿áéÆž"9Ú]à@&æ1(´iº‹¤#›W’T™9VŸ˜=c Éÿâ×3C翬N¦T•óñèòçó(ìoµègù"qè¶oš ¨zœqÓ>Gž”ÞB ÕdA çݦ_€€”K¥˜Œi,‚â<{í_üáÖ/ŒB—;òÒÕª©l;gŽfe'¶‹NÚ£ç‰\Ó‡e¾èßF;ñ½Ø8 )ÕmJ¸O 4 Ú݆*³­ÍX1uÑ›!u&äþ“ñdE#XåC÷+¹ÿÔ³,`¼Åj¤tÔ… ${ª™u¿ß‰æþ#‘“¨H}¹›4¦ï‡yá1AÿÕDZ?íÙZ‚jvî/^l4VuN´<j”£ .™uPäÉìÁ‡èrÊ  M’õ”»žRÚŒ {òÿj,q=éλˆn-ÅÙZ-*£¦'h9“žÑ§ï'>DíÅ£ÎOî…ñ’MôöG+¼šFYM‹JÀ“k*qÀ@; ùêd„¡Ý¥'·i4¼s(œ„A1(ܧ@)|±æ@TuCƒ‘6ÏXiúz…N2ŸÕŒÍ ®ú≆®ŸÎŽÌLw½¾Î³UQ uæ8Ãï,™t¶Ðw¨7Ág½3ºIÍn³Ùð3¿™»=¨¼ :ÍÔÕbƒZá}V ±ˆf~'3‹„´*¥ž‡ÊcwÆкH–æZ™¤PÙ ÒØ™…‡­Çñ(D…ßµ%}§¶˜„¢u, ”û1PLçmïåÂiš.àeÐTô­­!¡ýˆ³Ù¨1ã?“üñ'®B_>Bu }¬³çè„Žã>ŠÐZîâv̆³«ËH,^\–»ÕÊâ}=ÐŒ_dzæn`¾¾á|¡ïü¨k[ûŠó'ÎbÓÕKXJ¤6â ÅàÖ¢Çóqò(O…Ròı¿¸Iö<›Îp§' 6z´«!©ç=T뺭 ì}´ã1ª µÉl—‹N˜v³ýé»^ëqœ-†‚YÐΈ“Óóbfó^[N-°ä™‘rGÖòGÝ”Cêí,ضqª–iŽ©º*&›°¸=Âkèr’¶twÆc©e63£<aƒåØ3JsCj`EÀ‰'+SôN–GŽ#è—=øE»±8öJª0nÔ¥òwæÄI–ÛúWbããÒip}²KÍnåÒù8´»Õaî^Â᪥7$L³ ²˜�À€ØR¡¿5>vx¥ˆ…þ+ òí7sgšTó\B_«ªe ¡ öÈM©„=µn,1ÕýN`$‚§}ôT†ò7‚ÊqX^1¡¦}õÉ“kó;,ÓX„½œNóݬ,Ž<1[6&ùšé@™Tš£‡©ÒU¡Üȸ„Û1þZ†Ë.(º«oýö*»Ò2é°Ž>­*uˆóxõÕïü9ì5§|f–ldr´;…nÈ@¥M:O¾iZ=û@—gzË¡³ZÀÿUÁ¸¡p‘üXˆ¼JqZm#Ô£æ9•g[zs¥¬›àóNIt~†<H·GÇêR2âxã‘°+8å +pV¨*ßþëpm[§üФßëo¥RP?gàTÖµ5}¬®±°iæÔ®ùÿ´(¿•Ò•Û³<Snké1» %¢©ŒañòóŸ4H­’|¦ ÿϨ,hÝ}õÝu³FŒâwtô ©ú4Ä-5ì�KHÿÕNWü›ˆM‹$dÒ Û ~ÚÍ÷Í|êð§îßâ„åÕ•¦T3%i­Ó´^×ýÊÂòŽð)âÓ_ ¥©àμ1¼‘Ú8¡òupNìÓnú².õAs¢¤ïÂ#ƒ ò#·Ãƒp1üBsuSY½ñttÙxBZ6TìpãS_ßQ¤QætÑÏ¢”H3�Y f¡µþª„M"¯ ŠÆpp¦·l>={^ÔÓ½aúc•òªrC%ÛMl;«Ž-9ðjäd{n÷/u÷䱈t°#="üHhxütÈŽ*ñšUÍ:)þôö>Óº%ÇZËÖ ­5g¶¶¯/LQ4oߥ1[É|ùP²seèì&ÅjG9 ÇYn;¸=Xð­t 5OèàL¤_ïå|InÀo ÁñÙZôöa茖0oý´B”µušâÍÂÎS<¦út¿gU±î!6/ôÀfù�ž)q÷Ù'®<b{®þ$,.[žýAÈs”bfŹÝÅM•TwÀ¡KC »­6m]µ®7ÿÄp\I<–N5ô>íIɬLÄeô3CoßR"­‰‰"Æ6'Ï5Ÿ_AëvÉ d¦s0R´bÍ…©§ È}Ù¦¬æ¶ÄîyÒ’‡^ø½9–ð…,1móeƒ5ÓŠÁå5¬ÚàW¨ÂGĽÈgQ°Jl_ÓñxÚ¸Á�ROéûØxWÂúà<×çä¹G€«˜°†&~ÙXËÛ¨æÐtôÌ™Þ)e²r! ×$:HŽvl˜3üágÞº‚÷×$ç<ϲôôy;|Ü^§T¢l´œÒºÞÐ'ÝîþÊËÅR±IRÖ"Š :né­éðc5˜CX;ƒ¾§›_9DDÎRå´±Kk’Ä"G:ép{>IFõZ´<ËN_E°Zƒ’ô©b¤ìBO…¨*»Ñv0^++D‘Ç©DŒ>©Uâƒû,wöô>ÛB6â`e¾=æ®Rhßp§ˆ‹‚­1cpDžnõuEäÉ Ï¢YJ+eÛy7b®ûæ0¿Û!­¼q>€¸¢ô–úù5­!Ñj,¥·+q·[÷i;j/ ?Yhr“Õî*x+ÿ—4¹4¾2ó:Ž”™œç”°¯)½gùúÔóës¬(ô'^QÈÖ#áç¿*YG·,€sýɪåÿÖzÄBEãÐ ²n[|œÝžì/´ãeŽÃ¥LÛù2vºåoDÚ’Ê ·’¸=Ut*vŠÜ* <xh0nRþW £±*ŒŠîÅøy¤c.;)í¡0(·Ýð5!ÿ—i/VØP@a9¨@œ-U9S MaXl#S TÌ“>›˜znm,e@[  ¡ñ¦ìM7|Ö{%àMH8íÅ :pZ.D9Ñ’ž·žc4<.⯼=tHˆéͦ—VY·ÖY‘Õ›´8ØþСbݬòôãŸS`*X_°k�¦2)îò»§ù$òÂÁ~€kN1×2SÚ[Ûæ^·çòz2•ïßVx^·œÇµ‡žS(»a(=¥?ã⼌ÿž?÷ܱC<¨¾Ï(5=*ä¢Ñ!?�Ú ‚×ã¡ãÜ÷tNìîtË“0÷wwó¥²¼ÝÈh@ì¯dδÍZ/Üê£Ì«hR¦Ð&èx(xZ CGɨ¡´+„à<Y䙘É\¾+N'FÈU9ý¥ ~¨·ÓÇ÷©~í¹’VH•y%ë ­œO]9�Üÿ٭攈ÍÔRxu 3¬/´(9ê]EëX%Ñ rïÊ ÞhyÇô­qRˆÚ¼ä*òÇz‚g´-—©× …eLeG¾µ²Ã™ãýVtJ,ê.ÿì†Á(y làúä¾ÉB³Y*Дщ¦Í“,,¯“¬’bû]t—µJcüUX«1¤Ç0:^ãÔõÞ>Ò1îc ÿB02æ ; ŠãÆs8„›Ó (Òƒ:0«fࡽ�Î_B«´³Ôô*ƒþ˜6ZtjY¡?Å^G 8Å¡Ž0X�ÆRq˜ç ™$É}£Ú©ãΠÖoyÜá0mëËdÎeÊᬄäxaÑ ›Jᯡ1”Yè—GO%bs\”QúéñÙ§“¢6?ºv¢½*ßÚAZ{âE\nú"Èl^ «®®ÄÐÀОáÖÜ3ï™">…/úžnðÒЃ®sßÞÕpH3o ±Çí¼d;{^€±wV(CSÎ×àçÊ+çJ3=¦w¤Ä_vK{=ùÍÚœŒãÕ[ãåŸÝ¿~Ý•9¶ÃÁ|¡À§b(q†²¡$)kÑÚæ4@T  ø“}î~Q|eÞÇÅÄ`9D¥@Ð…=Ξ–‹ÊÂ:U™F$ŒðèÛÍÅE{4Í/hwfuüb˜æxåÜžÁ`0‘Aì¦U°ãø#Ì;WN(‹ãÌ#lD OŽº­É¥8MòaQ¾¿Å'»€–…†>)‚¼½xµ×¢ ¥ÍµcÍVž÷TPŠxÁË!Lãó¡€s‚[``Ê Ó׿Q¨Šâ…å ¦³SNÁGW´•gëË€ºTpt<Ý%;ƒl®›¸„-aY”¯ŠÖÏà9›¾n—hÛ]¿ç6ðCÖ"]¨n0r˜Ã­…YØ3âl‹ó÷åVb¿Ib&~Pü-:‚Ên<hŸ¤*4p{ÁƒÁ9§µ§žk‹ù=7 ‡ ô2lÉ�’zD[Àx‘Жކï¶F@·ÎDÞƒ#„ °¦‰ÿÅ÷EÆæ m©ý$s45UÜP‡p +7šº?÷‹§ ÂêDÁkT¢¼ß~Ø$.½Q~,Ü$(¬×Œ“8æJÚgyü=9$Ñ)rf=öÌføö%Ý|:Š;Õz?4抽û/lÊééw°§K‹ÌZÄ'ÑQI(˜’"d°‰;þÞÉ#ϦEPHç)Z€·CFÌK¦Ä¹k#ìðˆªê¨GÜ–¦÷˜Z6}{”lÈSZ©ª©é+³ïÌv¢%£ÃÏ‹¿ó8þCeêA}¸nÇÞ4f#å¼1ŸµéáA[}[‡%fú°¶ê“ FÊò/œú|cNl,nk±y´DŒ0>×YMÏZ3p†* õßñ?¼AªØ|LèV(°1…ŸVš)6úKÅïT½ò—uÿm ˆ=jvàšè„.ZbñzÖ^á}/åW4<c`Z­RU¦…è|XëœÚ-Fœœ+!ŠghÕf›¼ç¸k€Ê_.™<´6)BÕe×Qu*ã£Ú@˜]Œ_Ðt¯ô\PæS%€ŠœƒÆ%»UmTÃ_6¨ãpA¹¤ÛÜSêÿu}Ç5;eX’èó ‰¾›‡fv4œ­ë˜§h�"uMQe.Ÿ–7=²ê i8 OÖÅWß“Ué׉òÄúÔßh„ñ‚Í ä$Z+¦,ãéûž ýcòÚ$Ì e<1¾Ž‡ŠT³6Š8Ðá(7ï"$oˆ{©bðÑ¿;¢ßÛ9.Ú• &}0Ãm“Wùxâ¸îŸÊUQež I4C ‡³ãþïG½k©Vµ¼@•"®ì<9£‘gy|é€ÊIìèXKj¨,H­qL�ðX˜‹_Ö B›×Ápe#ݯ¥"ë¥(æî­zV/µÔn¤meÅÍ´|¹]´‹®/¦)øüÙdÝt÷¦Žò ŸœÎ*iõ¼ÛÃÓ¤›ÅsÜ»º3iw´1Û-D4BC Á¨a­ö§ë¥j}{|è”`cóô÷”bT£ï_¼Úžœ`ýÆföw”%!¸`C¬OEF\ŠˆµMµï„¯GLu:¤"¦Š{·Ž…®ÆêT(40ü® Ã&Q©I}‹3Ï3O”ˆ`çTkKã¼½Ì7)K&‡Ž~º‚ìåbP™ù.÷aôUµ–J²öª“£è÷$¯œ´FÊ&[X&׉3íiì¹ÅÇÝ�†h)|On“V¤åôõx¡dãùĤ~'>Bäå!ýСóæï’Ê1cD‘"2EIÍPa ežF'M _©IçÙ•«Ó‹öhÈ,ôÆæ6Þƒqý fz-ÌbpèPù·öÚº}}¢p51Úø÷Š(Œë{¿‚Ê:MîœÑÓ>Wl‡nº‹eÔðéí½ã/ô­B]fb$Ì€âú_un å¹"'c‡BñÊ ;vù•PœÄqè÷Hw°áЊ¦C†Vï M÷¢áŒÂß–Ã|vѱ@çIÝûgYì*§F´5 ²~v¤«£cQábnÅûÞw×pT¤Ù¶Ï¸Øhî »£=PĬÕoÍiÁ„=„ÇÆÁ&2ðXÚ×Û¯š5yOiÜ;µ·›¼RH}ÿp†=2wßvqeŒ/ ÌˆÛ—žÎÕ I-;ˆÕ·tr½²‘À;ËAÞ:³¬³Lìë²Ñ}ÏîIyÐ1h´hË~örvµË{ šÂÌD©GŒ‰¨,o�ݦ/º=ÙVÄrîL¦épTFc=ªâŸþ‹ÔÇ®þZŠ€Äª”.êh@ýÎUÏ^ª¦zoo}¿<_u®¾¯Y•çàÈ: ÍѨ3f¿l-Jð+÷#ÃѸ/PpO²€ûkæøä±w?Ñ *ë£M�`„2Ûp‰†í‰ææå4×9K±û(›"Rº™}êp6qlãÞœ†M. Õ×Np\(X®Ö}*©5à’„T€C&h\+j»¢x*G¿Ha×è#Ð;”Þå qNzº™/~‡â‹Ò‹öì4øðy¥ÈÈ?\ýŠABÚWуÖEéòZ,MôaÙÆJÑ®VŸX gc|‰GÍ]T©£0Г­¦70„Ìsïc[ßv›[/+, ½ß» /QJø? ŠœâÐ^R„‹b´—*(>gÇ)«Ã梉ÒC3}`¤çûš³î!äŠA)ÂÚb÷&3”Á× žÞ“Zˆ­Åud´ÎmTG«¿”ðDÒÆ©UFe>¡ojÊ™‡ŠðN\TûìÈŠN)a�#Ê\•ŸïDŸõÚ¢èí>´h•È!sh&µF©ñ×â³¥²öÙŽ44ŸšÆŒzÔBV_ýõžûXÌuU~+fæ¤ÀUTÙP*72~Ýo€u]U$Lʈ W5èöbŸÚ{»<ßy×4Æl<0•h K¯­L¸o|$ã…ø'ôÇÐt<*dUÿÌKRFˆD‹…³þ·Æny¹X¢lFëÀim°ØÆÍ=%Æ~Ñb«^9âxü1Q>À¼´!Cd¿ŸŠ.Ây°¯ÏrKONMKçP»6 /ž&™çðݪŠ~Ÿ99—ßÍ[„zžßZ5¦qJÿç¦á!ý%EPUõì¡ÝMêÑŽÌ¢ûÃ5Œ1 ¯‡¥{n^9‰¸’ᨠTeŸÊLcà æÝð²Zw< øó2ÏçÖ¨ÉV ƨ;2YöÙÓ”A„?̶ëþ+§Í"½Ö‡Y}øiA1±ôßKƒsë=$S¸’ïš™6ÛJûK¦Œ«uN7Üê !ÚñIbtUkyz݇Glúz¥:<ø)ÝøÄ;0ÕìðCõ ¹(ˆñÓãë¹q¡“R¨Œ­’ô‰%Ë Eyéb…~ÇaK†S‹CÏÖ¼üݼ4v]týi %Aú=˜½@aoqB‡¦±=aÞiè/8*êAªuî©_½Ø’©¬"V¿ÚÐr g åFÉ)¦ˆÉ'¶¹5´Ô«;CAß›0_pv¢£J‡Å‘âÀ¥Ï#ªÆö.ƒ'ªŠE{9ƒ0Bo´Ý�ªÄ Ðêi”¬ ýAµPþ…ˆHÚd¯vYB[^1 öäö `j;Stö;ÿ«h |`xCæêÚÏ£¯« ëþõHiÈ90ýS/ ET·šÙØ}ýÅ(PTy½ìa¼§5ê_eÜ4Ð|6rŒï‚{]zÁ”ö0¦D„2˜úl§€i`°H,ÌŸ²­wÞ:^á­Õ]µèˆ@™q3·Œ^ -ûšýËf×MâJ¿}ë}Îñ …PC8ê9em<hÙC~Û<Bª‚yJ¹a-ê©ë•Å´ôÛÊ<gÈe�̪Šéìäpé@?a´Ð£ˆaÊ9ÝlÖ{^4ZÊYDeBLj1¹Ÿ¥èµDÆ#Î ÓwG‹:Ÿ@ù]§1I²\TÌYP~¶Vf¯N>7aùܲóÂ{WƤ¿ìoí™Wi2if•ìÆöl53!uŠŒ"û,HÐCàõ0ÑË<BG8ìF›%Œß@ñÿPI8O|Ê)(›I†§©Æ$�m§Þoê¸æNš/t@;BÌÿ[{© Œ6ìðx?1T>Øò;ÎëéÿYƒÛ° zú˜ål=2;ðDÐüMã=‰$ã0ô•Ò1ÜèçE.Ç™ëÊáÝ¿Øí ;ÂPô¯_Ý1Ž”Þ²³þW‹l‰’B“LØUÂŒS@v«y¬á8<ý1ñTÑ…ýE¼6‡›j(ï9«yŸ=9’(³NàRLÈÝ Î½9ƒ-ï|‚ËK!_¨#z6ãÀ=Íi׃cgBy_Ôö[¿Èl±‚)ÀÑ '{7 œ#Ý,zä|3áǾý;ÕÔʪa³ErÞ« ýWô §Qô…™Ã› Js+"f®ê'çIêÁHŸJ©Hj;êùaÞfR«Qô“$ô[ºô¤O U'k1hµµº¿æ†©ÕÑâ›­ŒÊî‚‘ ÕÆŠ cµNKú ..™ëå1+à”z–| :õö2~Ì—v½ë_| ¤B¾PϦó�˜çøólôã�€•·ÿh«ËÇæ°éA�ƒ�ÁÔ]¬êql¾³gÏò{êY™y°¥v^pö˜ôb_V[.RZWAÞ¨¡ ~ [ôŸ(D ¾¿PHx0ñ>‹kOø5*˜,ãߢïÁÁÏٻ؄¥Ç ·¢ðÂ'KLN(ʲVÈ\~Ÿ:ìË%úX§ÛrA¤; çX~º„SÃn²«ž3Hú…êrRÄVø¾@hjúU™õ1ˆªkO1Z;” KçÛsF’mñ@ZÄv ;ËS¤Ãìáb¿jD2ª -‹£þRx¤ Mç5¥ÑóèÚ±} ɯõåûœ>v<MB/Š3¤(›d­RŠ@´,Ü¢ÀK\Ze>D* Ö—"È?µïD›vÀýà$ž ôÀµãÄ@pŽž×<”èrÅõÇ×)eâvòVΪßžÂÔiÔ�S-&’)–’âhï´ 9?ô­¿0;Ïç£ØúaZÅËï¼CnZbôÿË®u2VíáO· †>‡Q)AI¡ÜbâS™ieeY>Gžš€àj%tìnú ^í™ å ã¤«PÎh¹y›žVqæ‰@A!ö+ù¶öl0·‡ã—+‹€Pÿ*îâz�.èãùOÔÚÖjPÞ§ñµ)IÏoT„Âÿ|TVßhAüý•Kžr5­“ÊtJ~{v´œ²Òå=Lx³'r¿±W뉨ûÔO˜¥%v°º¥€ÕMôÇt”¨Ð•*õa¯8JÌžÝ_æx¥”(¶µÛutz'%¼í~,|é cÙd‡Æ¯¢×Q¶H)´A¯$}瘳hCem ͇’ï¹wò[  vÕoka€ßÈ)rý‘9z¢)q“nTñˆ,°©ŸsìÍ´âWn깰׳ÙIQ#5¥½3L<Ö†§|JCh·¹ÜºóE>‘Ï…Ý‘–EÕ¯=èÃB¹§¥eÝõ»”fÏ i²`}`$r΃¢¯]ž÷§pÕ${ÚXxm9™ùN´ ŠïOsK6ÝÈPëΖÖêIÜ�µ.þofV|_ä ¨ôÜ¡ÔÒ ž3¼êH …oËŒ¶Ö×N·ÎNW¤–Óà<äA8¯ ^¥÷ «Ôªºÿo¨"ÇÞcÛö„ò¼³Ì‡"` È@Z9R…wù7­âbéE뎒\*‹MQÒ’TãžôÇ$[º\;:Á(˜„Fð°vÊ|‡:êVÀD]ûPB‡Kræçþ¥a‚^3Bã´ôNé8ZÍȃì{ãÐï#ƒéž+uó™èRœW¾å;ŠÇœlj=áhQD‹Œî­/¿{pKR'¢Â:§0-¢OücÁ…P¸‚œ¼rÏ#†&ü¦Þ¥©žïö1U¢5JÌtfÓӻϵǺ°‚r_ÞõªN׊ã(Þ4HZÛöC¢~bìv„P?õ+¶ú/6{6¨â^öÂxˆƒÕyp¶×é =ïÖˆ‡Üdˆež-åH¾fŒØ¾;Ë@/K>Ù}l¾1ÂéY*ñŒÛñ\!åD÷b«w¥…õ8ÐmZèæ;ª ©À]ƒéX?Zín˜”ºueÏè[e˜èôÔ‰·’]V§¾?HóÇ»„™£Èf[ñì(ó @²T¬Gµ"åpkÄÊÞ¸ÝzýÅxúÙ?C÷3Ó­é˜pñH[ÞlJS  ú~Ÿ Z. „Š!5îj» åõ L–ık:°jHG9ÖÆŽ~ÙÕuWgãbö+Ûæ<µ"Uœ#|y:å®à¡î)Â*óP8·]Í-½ç¸Q«W.Ú4«?ygör<í<«ó,ÆE„Tµ¿†Ó ØHCuí"^ÞÔFòt1PݦqPáá0ík§(ÞìFŠ‡Ìçò.ï™#§É"C/‚¦*ƒò³W` ªÜËÆÆ16Fý‰®m¡Úç.n2ÜÌO ™–\÷ôa-“�Ùë?;nß;;Z·1‘ó®n„ ¯¤ãÖ§AuMaa$š¼‘èëÆu”]3>8�à&QëöÆZÀž´I àêp¢ô)5Lä…áXb…‰€\SDô诽Æ"m2Šýq±³Ó¿®9ñY¯ÍdäDqB?×ßw†H2ëNéÈK©høöFž”JP:_wJ|ÆWO{—iîµxùlØÓ!\lή²Ÿä´ñ+p6¼³mM¸[ôY|žHñ…)Ô¼ZÉ:w¨øÀ4šÝ¦€¦}.pœ^pO5½í°,7 ®@ÙfõÚÁÏ€2¤ 4­ hSÿ ÂÖ?C¸LßéÚ2ƒOƒÌÎMtd¬¥û²äÐĹ'£Yàš!û¹ÑÂЗì£;1NâêÕèxé|”G‹* âÅàͶ) t‘îty0åŽQp逨Qµ¾£÷Ö™oÔÂBX[ÒNZу;KOmg+Ù$œ,÷`œ¢>g MŒ,½‹2õI˜°!ÚgèP¿œ}F <y¬†BË m‰oÏ”Õe˦¶;1¶ææ«¿ÒE)gñøh™iÚGAþ0»îÁïèyäÀ¨aã=\̹¼:ŒS½ÕEˆî!f5°¨iñJ3Ї­C™18ôUPZ}^€È§Ëªæû®v[f¶âFúok^îÇ„ØPŒ¢ÒÑ-TR£æ¨že©á‘! ~H)/—¢È‘“!;‹*!iPŽÖ6 C¸šBë8XòEççj{Ü;NÈš!–H“éñ¦“©š>G¬AM·Z™bãÎfÓìÖahì×ôeo J —4È6 ÊÁÁÉÜsCš ßþ-o¬2ôñ!€ŸîË 9õæó¦@Š6Ýê00 [E=ê´*핧ȱä¦èoõ€3'x"%Ø6¸Ÿ“WÂо|ñÀ[ž¼òbÁBËÂl½ópIƒy‹»î;èO€8^ÑèÞ5<Ž<î±_!IJ[……D’¹ÿ¯Kþ÷u¦äüã8S‚%yI»õ¨:_ô¼uœtWn陣·răȂvÈéÔÕÑ+Z¡®~曀þx3ÇpWwd¼‰¤(fîŽ�‘©ÏRÅýº­Ípwœ¸áxýêŽqC° æ#ÎÉkºö,N=ØÀ¹=ô—ÊsÐ\m:ÎÌÿ[þŸùL)ß½ÝÑŒ\ÓÕ7'®¹5{ š øÓ®÷ü/PZ:¹\û®d'Ëò�@PÓý …÷0îöà”~˜*¤Æçd€ûÎL’jíµDä<Ró¨ÙŽÆ±Y#oŒe¦aɽ·ŠìcŽÍPo5Ó*ª{3r>Ðþqê`Xèôñšúâ]ݶƒ|ˆyŠ¤võ‡bõZuòQ¤}¶Xû'«í÷R¢9¢@á6K‚6-,1Oj€…´¤¹Œ�Ë‚þ�oÜlåÞQ—÷ªk–ˆj&Tð–Ü“8T¯ëžÊe÷p¶:ü3Ž”zìk«"a¨«oY“Ü•‡°hŸé WÀ”7°Võ¹†¿³ÙŠ= 8«èìÄ3íµòˆ‰r—³A<ÄLM¼ãì;pÄÊX²LhÂçÖ|:6zrìÉbþôŸþ°»Ý|1__¹ñfpfGøSKz¤ÇCgÇÊôž\²¤Kþ^6Ìn3ÝFãæ8¸ª‰Æ1 ݃— Ö'aN9ͽ7E,âlaiK»h['Añ=Z‚à­ÂP¤uÄ‘ PÕ¢˜#ÙùÓ\:ržVïuè趇I‹‡Èä¨>Òëh©Ø…é‚Ê`뾚i%y«Ó¤¡œNôægÏú…&nÎ>ÏÜ_lrÆrWbÉ(úÑáiòÀï½ \WEGW¯µiÂ¥•í¡BL¨ŠÌØO½k1f�±€î¢vø^Š¥-tÓ´),¥4{c0@§õÄ´.V÷Y_¸ ¹êz¢z*7³8+ .ÖâK®gýd$DÀ±ul>UN~-ºîs ÷à9OQ �pçÄp ú|_K‹WøÂ%·|*O‡�gF^¥Vï1æÆž4°y#™oÀ¨E§BÏó;L+©_Ýù‚»å)Æ<ÜZÇÙÁ‰'’ñÒãÄ2¦ 3 ￵C¸ ö‚JؘïƒÃ,Qê‰Lúš ˜¥ÂG4ùwã7X0”Bâ"ì€Ç’5Ön04Ç&zA¡ë7¦ŒÍ‚¦¢Õ¿ÑŠ•™ñâ ‹`Õ¤T·Žžºb_ŸYªÑh2XGÕ;W6êé‰fä%ºõ™ B¼1“˜)dÔ'ê<‹¯¢[ßåEoí¸)›„!¶§ ór­µi+¹F5-O„[³Ä"»2¸ûš)̳U9JH &@o͇FÁ9ÛþÐwz´Ù<1WFInŠ¥Õšitš�F2·“õ"y-9ŸeŽæ‰¶†û¾h<Î 0srðô¥Ð÷/d¿#ËhËŒ÷KßC´°ÖÌ(¿ï,cÜ^zùLŠ]ò^‹oÐñLg/¨¾ž:JƒáL*.ndQ`zmÜKä„œC¡ÓÁ+¥÷�ˆÊ* `xׯÌ©'Æüµ¦ú­ù׳¾2¨:wÕÓ±žA¡±ùžô,-mkµ*ÄK–»®¾µÎ妚2Ôéãló¤>ZƒŠ·`|uXm)¯jG·þh¿‹ó'¶û”5>l èŒ~Ý«¾y%Èuelpߎp/—&Uùf/i âVÊê%ƒ4*§Z b§Îz­ô!gÎŒ[ÄÐÃ…;Ë©½r!£H©óv¤2hì­é*)èï¨Ø¢åÀ¤ÛÃäâÀA7…ƒn¡Üù=ÜãF°°ÄƒV)ÚYe¨ÔΛà™ïD[2V‘0?È>·f¤iƾ«Î)5¼t.¢‰±ù[­³ Ÿu½Pi9Ñ[^H½ ²“pËÇú0ñ²Xš§õ ]J4HÿàxV<æk¶qáKÏBÎPêÈÖ)´(o\ˆèjyh%´o~ð1¤~†A í<VA>jÊ"ôJvÎÝaþ_ >((ø—¬f7R(õ ¢¬\ì±8˜¾0xŸ¬Ž… º‹Ç9xSæÖ/¹ >F†$HÚÆ›¢RXB*¢qoDßk!ùÎ{â µE¥m~c+˜vèõèÁ=Ñä‚ZÊbʺZ+Y±®íäP¼Ü¢åoÇÊpþwä |ÈC…ÚiP/ž~ñŒ¿ÕÞù{÷äÙÝñiY™à6PF;øúw”#o‡w¦DÏÊ<¿-[y¹º0Ò[*KÇÁ™RUúAeàˆ ·t¯çËd¾zQX¡e³¤¾âÆÿÑÈç¼#Ìæ+-Ç8 ·§’íT–D/–(ø_{ŠTž‰±ô.fxIw³b$lÊßâìý€ÿéØ4áµL¤B·fpV‡žÊ埳–u`Ò ‡7v)¼·ÆÃåÍÑŠãx3î-DíŸûec0¼Ÿ‡ë5CÝcã²+ ZôÛ[k^Ms…‚Œnƒäf3£Á.uó9¾[ý×qg9¨&ªý§ã¦GOÌJ##·feÑ*èÛ¦A5]¿ÞŠ‚#ýÇ+3½wuýâÔ:rß÷¼.‚b«œˆ²X õJF´ò‡¹[Tº?;)£Hq´©6öô”'Ux.YZxv_Ür@U²íz#½|ÿRÛI‘]›ªauV­'ç$DL'ÞôTˆ²$Š]º@ ”dÙ§92îàô?^³ø�§Ó>Š…A[†ó¿èÀûÍs™º©{É4U”Ö^Ò}SÏŸVZ=ôë88‹üåKãóÈóT@3¥éãä‰; ìÐ0?¾‘˜~‰gvó»Ìø¾N¨ºÂA‰Ïm{lâê…¤yMeµÃ»/C«›°«„l3ø¶V(6´¬AòÓD’ÓŒ¬û¿@GY¾Ð=â>Ád¹º%ù€1ÞŒçQ ðׯžKTi%ô6߶Í`uŸÍß²w{Ä}õ>äæÛŸ;æ½1ãÔ² ·6¹X\«z µöýÞ*b_W½µrªÓFE+€MÜï,fF¯,Õs÷¼\X¦´æbQ˜¶Í.Qd¶ƒ—Ž¶5œDÝÅêp¼#ˆ£Ä±Qkd^±þÖR ùÑôuéݘá³ß˜Ç†·ei=(Ÿ¨ýæìO—«MJL]Få N'0Œ(  �@4*Tçš–Á¦Ã†ÍõM&žC9¥ Î_ôë>ÕÕ!1Ö³ßvÞŠ‡w32[îÐzW¬ËUþÄê°³P 4ÇÇaÛíMô°Ùv¼ŒÛÖ)(* ]اÔQûr ‰g€Üѹ£Gv„B…”§¿‡?-fâ%V¥�ŠNªõŒÝdHàÖfñ(ÑKDQ”ä>PÝUsJ\TÀ!Ã2|n�ü®pú;bêqe¾ ¥2`žÎÞ¨“J[óG1v¢ä3˜Å �ŽrJ}ñ&ä·ÙáƒÉrÚZìUÈb^—ê Ö(,œX7´æ!¢­¢9Q&§Dn6ÓùV€»Z"x×<Yê†+Lš*&D"^™û­(ÝÖðFÞÆcq3Zæ™*÷<¯f†ÏˆzßYò‰ý–€íÈÚ£k1IÃÓÖ¡£¢­7Cí)¿möeÑb¬‚F.¨“Ÿg‡¿§·lÆîHËT¾òŠéX‘Èvq Ì< &«&b|öÎl–G¶òf¿âaäiè!_ÑBûB?èS“—„’gËÞ^(©ç/3¶3RügE‚zh)¹ú’‰#¨Ñ!‹%+ÿ¡?*¯›6H·" ªÍXyÂmê°e]I–’ôÇ5…&>¹n2-*)ü݆Úd§W¡O{1Т×#熫NXEßNG¢€­çñqDcøej ¾Òu¾æ<H-,ðMˆ­™üŠu…,r”Ÿ6ž¤×ìD Ë/^Mì¾-Ÿ=E£ ÑŒ“¾ì;O•D7‰[ŠgÍï�Ý”sRÔó¼Qy}JÀ‹‚Ý‘R¹bÈf }ÊŒþ@;Ë؉=v£µg^àÁ~jª ˜?M…ɧ OÑng!Ì“§•ÞØî¸íȶh¼ÿË"J²|©óÄ$Èwb,3ªÝ¸Ú²ò€É³$ßÛ4sê8Ï%³£Tol´c¦îߤÙ|¯E¼ÑTM/Õh’p!–‰ûIñ½µí:v¦uöez’zˆy6ž¾Ê ê¬é[¤Zz¾€Ê 4”›ž7ã4N‹Ôâl  ’ —¹vù®@ž© iì.˜SŽ«ƒ5'ÊûÉÊ´Té]xaóMÈ:ù¶Úa¹NlÔ‡çm uâ6–ÜTni%ÍÉ“£Û×6Sç¡Þ쵑ŸàÇ 5,œŸ"¨&ŵ3û?Z»‹¶>÷àHêëL9²nh%Äqå è¡¿8Ò2Œ¦^y¾‰QùP£ŽKÍuÝÑNêË[ïè¼ð3 ¥ZœñÓ çÝèð çËW÷ÎM°ÇŠ­1`+–õZoeïØF°Á˨­ØK1á{ëا!pÃÇ­½ŽÔüß57#g UFmÊæ[±mpŸÑGd:GôZQØ&HUfé#U‘³’·»º âË·×¢W]b“�ž÷}Ö©»ú =ËøÝŸË¡ ªF{YE*'.F…h{$ÓæS±6š@0ŽO½³ç"åô)& {K±D ¨…Uõg€ £V w@i ¤÷†½3@Iÿ4Ë°»÷3Êè–T¸‡3ÖüÝâÇ‹n8=ð:N†Ú#m»£WÁlë~·®ìë33ä´(2ÏgdtcNˆˆf;Êá”´dÆz°tÝÔ£´ÒÔÍI ‘Í‹ lÊS9˜˜Ê)ZèÄ_(ªÌ·:YkŽ’ ï“‹ñFêÅSØèheVØýK-Tô¾P9:îó ?*º.R!6•uÕ<i ª…ê{èöØÏn¹k<t¯ìHj¥´‡Ho¥ ( ÐñÇSu™™Îp<!'-“ø•š‹;xkCÍͧ§Ï†RÆf_eê“5Vý·ÂÅέ0æ¿:As„Jã‹&’ ²•]Ï®Nfû̽ð¤8*ÂÓ+ì<4Wa.¨ÔˆîŸG¯ë×B*Ϥ†¹ä\³6p.0‚Ð<•ÙG}sªC�³¡ÊãÙ Wd¾2å‹#îDf5Øe¬:öÒY/iÅâò¡goQú‚ŒÀºVA¹Ý˜s9)ÄŒh©Ðû\Çžo™Aªô•ÙÕQsˆ2ZŽœ]ràúæ9…²Œ3O½!d±ÂøgRH”Xˆµl{ Ð÷õ 5w:hO]„ºZûÅ0˜§BéçFîÉð?IC_Ž &Yò²¡óBÞq7¯êÅ&OûnÞrq};®ü¯ÏùÊ• Ç~È‚ô¬j:1 Ã´ ì¼Ðé T~o©Úuÿ§èŠf¾›v  pÛ“ëlN=<6[ ôÿPëkÆ ¢ÙÒªÕÇè¾A„ä?iQ«î»§ËýÝš<[PÙ �$ƒ¨ñDUVý¥µ^ÚäF!Ã`#ŸF‚H¥l¢ÂèžMSl(Ub\PȤ®ÞŒ“({y²¿rCŒÃ¥·¬Ë tLÈ"Çr LpXö­šîç.«8}ÿÛ˜ë"ÈG@»æ³£¾ØÔp¹ÛûœÜÄ.õe۰͉>s5¨æÌÜÕÿ¢2§<;Ÿ¢Q#m«Ç¦–k™&«Ê&Cï5Ù0œ¾|•6Õíµ”¬û7+ Vh¢0'‰icýxÝhÓÆ’­÷vËÊp+JèxH�m´¹³Îhur$«¤H+èësmý<ó=Ÿ),oNIBGúÚ¡ïð¬øcR!7É‘r¶uÑ|‹¼“•s„Ó€ÍÆS•ÔYs¡]ÏÍCŒPýñÃZH·x‘8^Ì2¢`_™Í>9ͪ{Ÿ*ûGðÈcøÉÝhgJ ;Šs:>×ÒPëèÎÐ[ô‚Ó4øà¶v:Qèᦙ^¹!b]{"®i¨QÛ÷î‘Åê¤| R~´¦e˜Ž«mÈÝðt¨iRµ¡—@^÷8#Pp¦D)¬ w/ wzÌó¨®c±LÌc-h÷ù•Gˆv4Ô˜WÆnñ·o1ÏB£ÜTµ?ªÖz >zN‰Jw³¤Ý¿ú`SíšH±äëJP%ŽÛ‹§Ú*aÆ¿v¨¸é/Z{Cª{8œ'ãùúd`‘zm$I1÷_ô%Ý*ø p;¯¸VÖ¬Ï( ¼fE�+uîK2 òž-Oï@‰}·ÚSÎR7ÞŒoÞîÐdC£ñ:BØß1©×»²9xéRÆ$N´Ò~ëñð D>’?téÕDáeÁQ°ˆ}©;6u‰é1kÇ&MØÿnƒ@}kæ™/PF§ ˜^7šl¾‰ në9Ì·Tö _ë ók»@enÓ FÒŸª¦ÉN® YÞÎȹzhöú×Ïòæ+m AJMÚ“ÇgCœ²·áú§v{è^o05Â6ÂgÀ̃Ð7ÁDB¨›XáQ’û*;fÄ1ÿé»Ö—¾ín¤G!y¼�&$AÛCwTÆ,Îi±ŒÂèF:¨¹Xê[»QTríUŸL……ž›NÔ·5¨¸5?RUo¥¼ÐÜ‚ Üº ¯õÕªExµ[äñQdr<¤aPý4Þ<DìéÍ-_Ó9°eƒ™'¹%øÁIZÐ?è_ßz8–¡ucZ”*O˜TVH&2»~ÊiÓkø*Ù¦wJ‘¿¥‡GiîÎpVÛrâ–J”q.ó]Sgo|›_ïé-:|"äq)8,·„sÄÀ�*X@£E{Vµ<÷•Œ%#¨2É~tŠ†Ö„¢W€‹ãÇ°Ìù–©¢ºè|ppÎXI¤W¨æÛ ŽÙM=v³•Ò›Qé°ˆî 1#+‰pŠh²§x]~ëï 5ÿCËt¬yvþŸ<Uâ§ûVïÀû Õ«Ü*u8ZÑ ë;ôo¶*³.g:ë[ç7ºï„,)Þ[ÈÀ–›d£×½ØS²6ô: ;¦ˆÇ@¶-@H´ÍpªøJг¡|!ÿVd@Dõ[¢Õ›�µ=vt½:ÀBBt)ßmØ{%[üô¦h'ÏT YœkˆªûäƒW×öp°Ý·´Ò¬Î7XéÛúÌ4<íÙ=*h;™®éí ÜÊ»Äm/¼Ìps4Y£=x­wó¿ãárM§y¸b}š¸èËü$Ð4ûö\hôÌßîë³i`Îp9ñ/¥b\ÊáYnZhtÇdõ§³Âã.¬ñÞÔÆ[™Az‡*—²ãÆê¬Å-Œ[à,m p ›ÆíÄîC+ž‡¯wt`⥙w 'w*·l[ ! GßZS`PN¨tn'á·ZóÎl52ÈÏ34·z—*N¹!O¾k‡{ SL <@ÓõÞÃùb§Þð¢UÄHR3œ:lØA®Ûì¦å7wüÑ¢¤X˜­ÄÁ@‰ZÑZw`º1m÷}Oõr_1õù½NH’¥¾L­CJqó"b‰ÏðRL}ÒîZì¦Wà¶*­ªÈL·y/ gz·b£(hfvu³’Ö*õ¦� ŽgƒKƒoÉù•Ç¾æ}ƒô©ê¶žÂ.ܘ¬À.­Ž¯Ž³m½$垀h¼€ G°±Nƒ¤Ñ¤»¼µS(„Îqïi%< òÈŒ¹¡GƺçØÇ`Ù © Ô:°¾Üèi÷ç¢ržbÚKU U´pmODÅ;Ywºasíÿ)ÀÕHw¿–ðÎCßì“èm$ŒYì ‹ª›ºzŒdJ~Ð@ydÃ)ÿ«úòJ_¨bÁG¬‘jÓ(&»´FìNÍ” 4Üåê�écrw+m.O01FÔçÚÉL;HX¹NåCPH…Íb”ø²vôÐ’A8Ëì^:é> „4í|gÞ`´Äžþ –t «·ŒKŽÄf¿‡úëƒem8œà×lÐ axdSMðX’$}&W4”DÎt£¸”7v.ã÷Ïù'G¾5R5îlІHƒìÛÚC²Þ9í{…­ÍãQÜÂ.îÊð,Xéqë4�v Œr¡m²/‹ } .U¼XeBH>GÔs?ª 9t¨{ϲ•“À9¼ËÇE¶ÈâAì|–¤UÒÜrñö=€\¤Î»±2òÌ"³Üýë…”"÷0»™z�e.Õl,1°‹EüJ¦£ôÆ?,©1Œó$,ôõi„†&dQÇ=‚-¥$²;×—‘KmBu•lÖJãyªXM6­›w0±ÅÜq¶±¯™™¥x»$[ä6ôÖÓTy²“t×ó\«zL‘›,~(³gKpà×ûs W&Fmº�o\:ÅN{]ÒrŸ$šy磲._‡Ú+´Çãz½ŸP!7š:Z½moueCDyÄLÛ>ùV¿.¤{Jⶓü�‡QÍà„ÄxC„3 }1u°hèPÎÇ£÷RIiúìrt{ß»ò(Š3Áà,·]Z\Î<¹ö‘aÙËɹ%F3—8†ôg[=,ÐPå <lŒ«Û»»øæVDA2Âû¥÷ePò£¿ (C±ØÈ+äOYø¤M ¡i%sc¢FlìÇa½V ¢æ�õ–»³ò4M$Ôè|P%{útñšÁ$Ž®±ð¼wù<7ŠS§k,NX@<–Vs Ò¤ð7¦ÕõûÿK/ÄÊ—–¦ŽRPJqíž‹üÕƒ?ŒÑ0Æ:è°æ%~'û,ß±óÖÿJM`Áp:†k•Ñ[æüÉ9yìædL˜ÝQ]›6'išÿWEµ74zø«Ø(|€GÏaù}êØ?ëÄÆ‘î­79&¾¦±0nì™z�F½!ÉÐ_üK¤/‘¢¿¿¯Kzk•X×=gÚ ÃûFÑ+GY—%2Ê%Œƒ-Ó~Ž“y4xH…¦h†¸~¾t/„(¢ÂÑcÅ’½ÉiÌjk—ÎèÝ!µ(<œiÉ<àÌG…J܉Î~J*ÐÉêã"Xfã‰[H¿/Fä÷ª*_â+6Ê-*Ÿ^e·AµXÿÃø÷õÜV_¯PÃIéË¢Ÿ ÔÍÉZa<`Øh{S¤™¶^óÕCUyï¼ü%©Gb|+ß*ˆ¿?}ëZW»£;Çq°u‡yzƒš¤ ¯R�9�*Úz¾ß\øÑc›C0|>c¶ßç΋%ÔB0òþz‚ñFÁæ‘Úq_¦Í¡eoBzäøÒ×Óo| #Ûí²i꙲Õ4È.IÖùÏGjò <¦^÷À^x81³ÄôàÅCfP€S.fHÚö…*ÿ+ÿ›¯äUζ…‘Ê*¬tn:åT^ÎŒ�TãÕ·ë+ëh.�â*h€•³­ˆ8T%Ë¿-®ÂÔëd±Àö¶ÎƒxÖêÇ̸tVÊ;…ÙðrÉÑõ©t™o:ÈSƉ ¶äÇò˜ £ %"Ât£iîÞ¿7+I½‰k\€˜[[–ö u*ÿw¼Ä¨ÒÈ&c+ZË›Œq–Þµ{[AÚZÏÃt(ôëù°Á*‡ÇŠÐ0`‡ÜêØy¾ ΣÁö Þ´ÇÕœ/£ Öe¥$Ø1† 'Ssmÿ„U/þ«ïð¢Âm–KÙŽg«m§Sa€«¡çÝíŃó0*]i 8´“ k~<[4Vfª[x8²Â©ÀêÆ,^Õ8’öèV7æQéëôžýD!û<»æ~‰ íÒ[¼ás‘ê@Øꀟ¶Šé‹­…ì/“™u¸ñ¢5j)•=ž§b¥î0‘½  ?~(§ün=Ÿ X‘¥#üòåViŠi/sß—,bçÐFí¨*MöHü¥Z¹‡«Ã©[`½SøØÖž…w7(B᥾\ö¥—¦a0lÛŒ¶Ól[½y`z8ôèy“ÿa}lÆSyò{¨׬IkÞÖiÔ>S«Ml.’Œì<$UŒ£'è*ÃI‹qrqZ»òþW„âÌË)…®2ÇAe?nŒaÇãÂçùW&ÙÑÿ$‰›³RcpFŠ0«‚ºAK.1l¶ºÕ¹­—p¾+_,å�c Ó:?×^ùL™Þš…üEˆ.½GÎbSvOVTD„ÇL!‡þDõJ¾Gx¯ ð=Z€ü‚sET£®Tú¼­öAü*$ãQóôŒÖtÊd¾DY”û"NO* “£’J@ã¤n÷qÓ_€v_µî¿U.}•{ºÉ«? œÕO$Î6N´Å­ˆ±÷<ž¬¯(4C©†³`/@ûŽÝ¸ó ¢¿Åb$±Fì`þ°¡Û_: å;y DYgB;–3=×íò™ÞÂ,ùÊ9ÙïzñtažèKÚŸ]](ŽcÕ¯çÓô_Ó¢ oÐ#ãÀrÍÂ*Á27Ës?Sj«x-ÎýœPÁâÛ{f×¥³éÆ‚€Aô©f•LjÔqWÿûo-0+__zir¶T{‰ƒù\Pò¢ØÔ(0œgO„,§'#Yõ+µ¦¿M›Sòzq§ýñÀÌN¯÷³L„ždDje-Pºó7}ðxVÐܘêÃÌ©ïšØ!^‰u#FÂÞ7wY¥‰7dÆ~ö]„Ö™{¬/lÜ<öG›rÐÍàÄDQY1Ob_ïŒè¹öµÒwR-É GÏKg©*€MDyì‰\n•YgØ î« ¯5òArÓJU]elýòÅÚ熡Z£ò£0C>j£ë1e7†X0Ç:=ù1òý˧µÐÓÍà„kš)YO,´Çéq÷Õ9éG#ÚzsqcI/,Âæ·å·5êÀv”ÞÙ=ó›Ôü8ætGÖÚŸ Y(Ù97¢¢ÿcì#ÕjBCÒ×EÛ!I ±b7;J žùxñ,Z%¡Gîf¤"Ãå=Ä—,=’4¼ˆ$fd‡íÀœuRU#iz›”í F?Ž ÃJQ—_d”Ç­R-ò„Ãœ¬J “gOÇe{]^þÐÁ©¥Ѫ¾²^Ç´è11Ä~™SÿÊdÂêd¦Xm/tª,htZ~1ÐÄ@ô¸W¸|¹é#$¥oú™–º­E zø 'ýîW†àø�®\)ö帅iʱµ½ÙM´Õ—ö&šËš²ðÙ´ÇÎPmbõã}m^¯ú+ŠPâ–žuZkv´J­Ñ8”÷Þõ_2ž±Tža:³ìVw'1¡´ŸzÕbâP«Ÿ Ó‘†ÿÛêª ß MŠ0\š£ÍiPXE«•Ùç}k‡Ë2ø(¢“¤‹”þšùØ=;R™÷íÌG†Ë¾k=»ØXû%QjÀÕ{ºéYói@*Qxײt SÔ{ØÑÎFde#í&¼;½1ƒñä<J}kæ/Ó¢95´w׵ʃҟ~@Y.°òFib<îbE¦±iÇyˆ =˜cÝè÷]‡Ã­q&ží«t˜ï¦ßqè)ÌSÍÕ4t2l„*w´¨Lƒ# dzw¯±7Ž\/V |´(›o·ž årÖÙ£‰œ9–›×+ÐXTøy6\PŒç6<A¥98ºÆ•}Æ+72É|$.½5 Ü·üsÈwjlÄß9¹[ú›ØS:n`­iuÜ3Ö™º«P Q.nWr®·úBg\;.7? uG#.8!£\÷èd«zokiÁÑYûo÷4TTn ̇D»Í‚jR— 6Ñë).BZÙà˜Ñøä@›•ŸÁÄ0Á9\µ73Ór CCÚÓŸM8¾s:_gV]»øç§*ý©ÇIÐHŸGzÓŸ³c©T®Ç¹SÔ#¼C»¶Ä}ŽÅóxæë H¿ÌåâÐ6gÅÁaºÐ}² S–ÃcMÀÑ‚Ò›úÂ-uIv~æ’ïæ¾õ~ –°Ž­ÒB‰"Ñ”ËZH´õøO7ýC·¤¦ÿ–aº=Ô·L¸<OÍË@›­*#eŠ…E9,ý5.U¢ ,¼Gxt†t¤¯·ŸN3Jf7”QÑÂê=¥è~å|ùïõ׶6 Þñ(ðYNeóšØ¨ó÷uF'GëÊ3üå¬Ê`ÀOlà ”3 z²ƒé¤*yÿšK¼Èkè$ï~€û›Ôý#OËé ƨÊÈÎÜÝ]+)’.<ÂsO=¨bï©ž‰V°Î"¬Ö§PÞa;EV¾Ç÷Ȳ+“ðbßëÖ㆚n~‰uqUæÝsdùï"M“/:½jå)æ\A)‹öz´r¦íÓÑüõ > ËÐÃKÀþgLƒjÖ*¼bñ)úüâmËÊ_ñËÌ—E¢»„‰}ÕakK‹5 2êãr_ŽíËÌw²¦r ª­¥`JJÑG=ƨRèSš—GJ©IYøú'à^ôTtß®‰Mç;÷&ºP(^3+9³hùËG±((XÁ@ùÜa"¦qzê˜KnÒ ·8çáÊ‹š`:°s4“ü>ç’i~üÂÂ=r•ŠÈÔ=X~?Z•ƒO²¢ºÎ¸Q>§:Üý2ËúýuÑœ‡WÞ­p:Š¦OOSÞdB3á©×ÑQ».&8ãêO8½s£nºs{Å:ÅBoNÿþ[ó&»ú¬§gm½8É}¦0CÙÒK¦{c®úÁz¦$  è<-© èïu]nú/Qê–~<@(ú%]ëR"�ßàlŠéE˜åÿÒÄ™ 0¢ ²ÎŸZs¶$¹êͨÚí©[¾^ÿ„kƒ¾©£Ê&û4_c¶á¾cœã»¢Â– '\UP`g¾U6—°uë[ V'€£cÕCê*µ*Sôh ”« U8ø`DXD¡öàe´¯‚òûèÐ3 ¡;œh Ì�HÊr¿ æL—,Åá`ÿçÅÝMC°ÛÇ$(6/y!ƒk22÷‡k[KÕû8{*?Tyw|{øÑ@¡ÈD!s-š–KÕuGbcºK0’¶'*ÿó‘&jè}¥~òŽøÉRÅrj#†F†ŒyòŒ˜j´Äacção±1 ÏÛM\ªæ$ˆ¾5âXXfþ_‹›‚¬C:Fyå|[o-\æŠ)E´W#$”’¹T”!6¶*_€8ó]a³Èï03#Ö8¥±¹hê2»Œõ¶ÒÀ·ÇeÞÊGÊ$ów÷¿Y4R2o-±"jäx´hHñAùÜR×^º­?Î( )îþO™nà¾R´96tXGµÒšÑZ3UR€m}þ2ê�lÙó½ÔY¿Ã|ZÆ€ÄRÚ1P"Ï»Ús\ß 0ßzº_©?v(bS1ð†Ç º+‚¢Óý±x8}¿ÑjJ³Ð'"Ò­Úîw6/.jƒ8\…¹»¡ù>=>È2'ñb†n5E–½‡”~O¹[¯ÚÜæ›'|U+-›‡;ŸÕFÃTý¢ì»ñ›CoäK` Þ¥…e<E—^ç„[gý”Óy`]ÂÄBóåf­¯'‡Bâ8í¢‡ŽéTôY{¥-;®[ëÑ×C©Ø*V¦±00dè6Î6¼¹ŒF5—ÂŒMûÚ%~F•ð°ÍHàs ßU|ÿx@ ¨}ucgù<oië#„O(’©Ì›ÁX±ü^ý;Šäi¸�è°z�}ðü4ëûªaC[ðÂÞDZÆ9ä[A[xìaWB*ËÜÒä¾½´ñzŠƒ*„ÁDOôó}dŸÙÉ‘1ºQÙüõ…*™fmâŠ@ïû™ó@Cm·KBÃ)GK–€{~åè"¢OF¡ùÐÓVcfiSÃQç¨ £·,“\-Ç›Ž#õfQƒ.mµ{zJmƒuv¦'Þæ¾¥œøú²t§ºcGuõ‹Ygàp^Õ PÈqŒó$ëÏ»t"¼‰Ø]h |v7{êëÝh©&5X¾,…,Ï<Á+±§%Ø­ër¿¢®ì–*m™]°z7ÛêÍGÜ{=â3üs:‚z N¶TSZÀC×·¨òc/P=Ì°X«4%L¿*Qö„α}ï ˜|4¥¸ ²é_#Jž$×J?S}Æ­pØìW0íhá.rä}]1üÏt:ž0kåUÓ¡L}M0èj e~+b±CúnZcHµ;<µ÷lêÒ8ôÕf M·Åȸž¬¤µvƒ$ÍêdŽåq� 9"«I_ìjL—f¾ ½¹Ìfõ Xu”X*b»ÒN]¯žÍªÐG¤²÷n+eg~öôG)…@È؈­4z)öBͺ=±~ \Å*GD¢Ð7uÖ±œâˆ9Å$SQå™å<LGž¬3V‡Äƒ#dØŸVBÉ4¢!tb h“ÐûXŸVwi«¶XËT²oÊó ¹´Þâ㧅B]}k>lÞÃÚÊJŒâCh°%Lb´Ú•ÇÃêˉ)°ð2'‰×4bþÑpLÓ è­·s.†¾¿˜¾Ñ꼇f ¬×uç^Ñ­ö«@èÅQH,¾;o¸Å0;ërÓ±´øÛs Û0Rú£"Âz0c9kFZèâ{Š„HC‡±`Uív‹¬ S0…ògmÙ{«”fûJ5F|8¦Ø Œ`šðN•ö¤\àœG“ˆI:–s´ö{WÕ=ñÞš;Œ¿Ÿ=‹\ØÊÇþÆã/]vaÂÀçd<Ù‘Ÿh1ÃçMÊôÄ+$Î]µÎ„´ž6G<=ژדÊ=ß*ݪòÜò Ž£ØÑ“E:éL7!µ€XÕžirDOÚ(•ô AôBËÒtZg|l<EmTÁ·ònþ‰ã0”ð2¥H˜¶˜KûæRKæòß»²å^ªÁÎfÇÝ?Ì$öþqL´Y4¦4L×0¯ÏÕ¸’¥Ysç´,È,ì¢0N»³àÓ~ùDºg™–øF| Ñ`ÿ·ÊèŒu'É‘åÃÝï6Þë?úâÞâµÔ^Øéìú?r/ ±mŠ–ß8µ{á,d‡™f¤ìÿG‰SFX×ÐÇSËßÖÊFÚ@ëÝÕ£b£ô€F¼¢Îkp* AlÐå0CV =fúëž-…7*™ÿ(ª#gpÀDº�¾¥óËiq””à‘ š–N²nÕ“–ÊÈŠpB%¢ÊLŒAÏüÁJÏ>ÛW ÏQ˜§Qñ’6î|b"¸U°½¦WEXä­<BD+îÌö“70ñªÅÛ€Ì;õê;_ØÎrz‘<�I¥÷÷8½{1»£Š–ùή%Ú´Z…G@gkSŸf‹K¡eAK®[^Þ+cèù%aj{îè0L1jô“×;ŽXwõZÝLÑŒòúadrèFQÒ~ù0çáò;ºíeétQåÞŸ² ïtì‚Ài¸ö¦Ës°Þ~ì?_CÅúõ|‡2—,\t ™¨’: aÓàKû[ZVV:+b‘X¿�sÕo6÷KTzíE"Š¥qWÛ åRצ~ ½(¯†„Ó!AK ñœô¦JÁ–¡Ð±§kÝ4ª%j>bÇì8².0”ùBËŠÖàá' *;GEªŠ±£å·R«³‹òÞ‘›<ªê|ÛÀ*UVð㈳´8mÒ�”ëºrcù^/Ž}½ghEP¶Öb2¾£Â¯NA¦H¸úöaG6IBOZIŒ¬éÈú<yðUÊFŒNíÃPèý’/ïJ¶Xfm·­À ‡Ñ ŸÅ£™Ù ý¨H*ŠÚÈ/a[ù’ ô0vØè¹bú~P̆ݹ!¡º-fTã—8¶¸X@ÖSÚÂqP6zòæ1+,Áú˜{Õ&ÌD·òú«¯c]p•‹WeÇ£PA˜;ÓÞµ%éî"ä€4õÆ\iê‘ï"ƒ‰Ï‚r<{BèPíg‘B¯ÛËøL}:Qsq_¤kµÕA½ÿéxäƒh7AmîÕsÉJ>Cl+ëeO+Ïò21‚ÕÅš‰¶‡1PNüŽ¹‰§"ù~3Ç«üŬ‹Nª;ê=¿'àq=awÐû&…w‡le滢haßÚ‘á|ÙC³ÜÉt'q²�ÞÕÀ{k˜& zRlÛ*ˆ¶Âw‘“¡©ÎØïz'´½zÂ/ C_ñ=¤dt!x;ÄxÃ>Sy˜¾€üh³[oc�sã“DÙ‚å£/¤§§È 8Š§a±íöÌ{è4˜‘´5%X§ý Ò#+�ozÊû/:ŽÃOí”ÀµjD)Ìæ¢ârI‰ÅÂÙd\½BŠÛÔÙK‚áH9QÞÿë‰÷mÆz·ù·—=ÄGæë°ºí¾¶£<þ¡`ëz¸F1>[zwÛ!‰3ñ~ñŠÕ;`K“BÂÙ„uW͇MºDâu<�2ÞønrÓih:ºáèl“8ö]½.ôw"bŒ³¦Dnpp……ÃárÍì©-Ã!,´Ã‹b¢ã¿>ßsH2_>�¶oû”-õv&ퟬ©¦˜áy˜{&ž�=ófš†nòñèô<8QV’u=1n:Jú¤Üÿò/—8A?3ÉPùP‘Ðv´¼åBx#@‘kÚ'ÿ?mo²Ý¸’l Žq¾B³šä¹ }3°‘@@QŒUÿÿeÛÌÍÝA±SdÖ»ë‰NEîæÖìæb¾òA5ÒÚö †ba¼Döq3©Ö9sEd—ùÒQõë­^7ÊY«#¥#»×öOì4Ii-vº€m_°¢Ì¦ÝmvËKTgqææ¨[ú Gk¾ À3ÇC¿›lôe2[)¹6×ý”An¥"aY~hˆ> ð¬6oæ§)”äa&¬w ~ø»Já&Ìˤõ±>PP2ƒ¸×M»¼C…RÕA¢AùçðG÷¶›¬›À©ßÔîÄ ÿNÕè¶yî0î€/ÅJõºÿž÷lÂÂqì·ÝèŠÜ0nwçù28f2§—ü•Ý4ÞæºàõOÔ„…{ìm ê´eb¸'ž6t|ªV‰…¾¨Êœ¡,at »™¡…®”Î}}1Žk'�!ÔÚ& <7Þšú~¥ Böy°§J±l­^•˜vêÎ1ù8Dñ¯{ 6[UùÙ h/”gQLeÁãmm ÿŠ|½]˜»$_ÌkhjtzÅàsu«—¡;Ϭ›dk£LÍõꙶT_q‰ Óx ¥¶rPZG»éÃI䙘بPÎ/¶{S»ŸS¼Ò«‘bîA6ýô334ËéuQØÌu"ñ¼€þ|n¼ÃOŠ�n™×NgI·(HïÙ^[`ia ôº§Å9 &>±iÛÙÚ Á™¶OÖ¦©W?¸žIœygÄ?%µ7?µòd/{ùÞOœmL3*CãqÁëK½¨`äjÜÕ¿Ììø·§÷Gm˜„EæÍÄà†yŒà‹ã‡§+v¨9Z.™_{ÖF† ±=Afº³«É@O©’Cm6PV1esñ7úLQšúF–´Lg¸ ÛÉsºe•!íÅ¿½Ÿèî+ŒìfwÐ’­UÀê+¡]<¯tï²[užwú€>COùš›MÇúž›|œ¸õ‰óNÂÐ3M¦Jî5<Bö\[…ϦûYé†û<úl/ ­M£äA*ý‰Â…~ÅõTÚæ#…á´\àsÃmHzÀ½"o(¥’¦‰Çe§ òµ£C·Þx sS#Þ¡ }˜ã8‘Qxo&¬ßµVÕðÑÞRˆ¶øãI^¯G-®HFô(¬)# û‹Œ*TÛ&¥ª×Ì×òXe¶0šá�hß{`pGÎõE¥™»ØOŠœ÷««È‡•X«@º%ƒ†i0j*”7¶ñù_ÀÛœ•PdÚ”h÷•ãÆôþ‹xE±é´öÚf¯vûrON¥Df±ÛäAÔôÀ„�שÜÉôÀ¼<˜&qéÜf˜•ÁÞ†6-Š]ØoP‚êcý¥¿aæ©ì³-ë�Ô¥%`Wf´ m›õ'KVxè@Fæ®ÖÐáïüh²B ãæl÷{MU!�RiÂQ&øûwm¡D¡ É€išßÖ=Äýy“×´¥íŒêZ)òÎs’) HþÇù¦1|UŒ¥ÒO`k»FômôõŽÇ¶Ÿ,ì`ä©óË„`Ñ5ƒaá·¢!o,k,* w5Çô–Nq¨2žCö€(!lvxa(‘MŠ’Ô1#MU¬Í¤N奬¦­S©’ºÊ~¹M¿Ô5*,a™•A´QØ125hgزô#³ˆ¢ñJ˜£Ì—€é/݉ð¤âŸt5Æ× 5%Þ7ÔÌJÏ|)XzܲÜÛÙÔ𠤺ìâ´Y®…�n Ð}4 q<¦9 G݀˔N®çeèêöõš–^æ™?¿¯¨�+ƒð{T«(9О­È‹…WèM9Ãj¡ü]~+ø#ÂÙ®t&«×uQ JG>OfÓQ²ˆ$̽‰ƒªûÖa`!çy}~}ÕIkáÊÎ:;+(¥@(!²ŒÖ¦«„‘3Äê[1üÍ}UæC¬(þ˜çõqÐT ¥Îkó‘1”©3¼;±¢"Ž§}ýn{õW/®o{îT9E…eÜP ·j{„˜aœÆ³·=(+2†î’¢¸ìÎÎgÆ~WT麆aŒôÖÙÛ¿oð°XÀÅ}+ZÐ/éÒE†ç™/fÁp¦%ù©0o9Ö–½ Ü/9gÉ5jÓiwöXìeÚµ/óµò¸Ê<}â08€HÙwŠÉâ ¸P‰ûÁYÆs˜q:?b©W†$½Ícpì€îd>p e= n¹‘ÇS±ë.$ÁÇLAµÛšàšZº™½˜…xKžüõþœ@ÄÏÒvÇQMÇÝ÷ªë§ yTBaŒS4>F6*æGÇîlz÷ÌוÊ Í!þ<zð ñW¼fè]‚CôO©òÜH¤CU5EùOýÜ hW nµî?ñ¼Eònœ ßxŽ³K£JzÚ]ÄkŸa¿æ-$éÝDÁp•´sH¡W>1ÔÁ]ý‡UQmù# óµNƒxúã%3Çñ�ad k½Àaïy‹XCæ\)ÕA{ž˜A 1Å~Žín_^î¸T¤ÌŒ"˜De›ZUc±wçÌHКÌÖåëMé·bÆ€qg¤G˽!Zþ72ª<ô»èL ›œmdÄœëî¾Ò“×£6weZʼ.XÁ1L%4n•,ϱ-¯’-ADÚÚZ¥>´p‹þIòГuÆÒÛ”AÚhô-xhQº£W{@Ï.íß’znñlCñ1Ç´äÚÙ â#–4õ*swPã`£1£ªŽ†î99çHÈÓ1¼çŠh³ ‘˜,ꆩ~(>'Ž[ÆsåÂ)œ•Ó0Hß­~/¤˜àŠz<©¦é¾ÅEö•`œ yÄ\*‚‹qã7c¡ëeÄ`¿Ã›ð¶©E´„¸ØŽeä¦"Êy°kºo>‹vyš>Êœÿ£w%D¤¦ä|Þx¢ó /J δ[¿ŽÅ÷}= Ÿ9Æ ¡fZ ½‹\:B»‰Î;açÊäßétìÆéÞ+ÔÁ:©\}»œŽ ;œjÆhÜzÓ1 H¼áñ‹io.“ N¨Ë^…&øX飫žèkïZd×9QGK»íiŒÃÌ“”5þ¿¬Ø­™–êfÁÆÛÑ÷Æ›]÷­g·þ‹‘ü¼ê~wõ‡¦Y¶à§à§A9*%$‹ �ª,Ê|ƒSO KÞã?çi 3õ¦Ý¹§ÂMOnÙ¼,Ì€Ù@k�"öØÛ¥-Á˜Kÿ§Ÿº~‡^ìëÖ“ë=-¦Ã‘Qn~¿SCí׸6Î418ä (áx>¹)ƒuάQÈ£<L¸¡T ü¼X¨ 8 ázŒcövšÛúþ&èb2<_¦é¼ ž‚" Ü4?×ðÂíT2úûCÓp_^ÙMÃižLÎõ¨jÄ<„ä|ä`É<ò>ÌJ›2̘€ë/­7–Ùî³ÿ¤^€¶I@E`JµÔ·vÀŽøt´š±Ì‰þ°Ë"X<²`‹ÝÄ[áT,ѧz€òRÀv”–T¶Ñ’–t¡U§2}{ÍRVä »ÛÂx‚:=ÌÕwØìoô¹W[‹ïù…hžšŽGh¨Ç=ÞºÉæ;ø<ëÅ[±+¸˜ãÊ•l”ˆ¡ðɶ&R¾ýÌ|²oû+1q„ìÊ»oØ€¬ÿéÙ´¯;™l˜é’ôi½¬‰kPÊZn¤O‘Õ*ݪ=TJJêÎÔoÓ®†Úd‚I�MДö…îôS½¾j锘P²¾P&8è„Lb #Ù)¤^ìö m8ÑG¨4?å1å�!&±…_:Âgîdaè攂¿¬&lR¨>ˆ¤YDJEõè+–«ñ¤§·Ma[Åûd²Ë‚y"Öµq½ñ­–­x—WÝYWe^@þ-ÔÐj’!icÑI‘”bµ ʶ¾ºé5ݲr›?Áó9šõ„Ù}]\9 †‰‹Qü žçÐ^í ]4Eâm¯’e£¯ÖGùö,t¾•VÎÝ´%²Þáqh`t|®E¢…XøÌ`éSèZ‚½r°EW½ˆ5â‹ l­Ùleë~ß 7Í‚ÝÈíÆäh)Çœ zxÚjÎ% 3)PLlû%~¸pj£BH?bðßžlšŽÛC'àÞú¿Ô<iþÔPwú¤äμ Ãojaœ²e†Ìéç@IæûGÄ\Ñ’±y:[û5–¸Äó½¦Oh®îTD•—`1T_ìx¢äѼPyÝñ%õš¤¬)ßÐ}/Íì?f^ÊÂêøƒ’`†Ð¼ iP•W™ò´Ï(•Ûø‚0(È­è ¿j~?ïRvÙ-�bžF®j2b:QÆ£Š¤)íYiäÙãëì7üX'Ùš™Á×4ÄA|ì”w—2lÍ}$\?3¶ò<Âó ÙÛ6l_=æS f‚"E¤s¿ñù:va…“Ð}÷RÎl0øþž’"^Y6EReÎQ˜–Íå¬&ñ¬�G©r5sÌà÷=ñî]·vÚÓeê=÷vgÞU Ó±§/E¯r8vÙŽ•Ñ̓5¤<†ìLz î[¹,£Ÿ tòpËÔóž…ò�ÍæS^œŒ9ŸX\Þñ/b'‡(]:ÙƒbºX½?ƨÓb<µ»ÃB@Šï<ò/&X•Ñz£6PH; š¦ôÐIô£ê�}}`©Ÿö�×Ü¥ j:De7Z‡e×›÷÷®>8 Ã…#×t¦:©×ÆIíieY>WV—÷™¸¡¥Lи£ûÛ{UÙ ë5BwxW¯F?Á¼Ã?òÁÔ ü 7̓iä‘[2hQýZÀ ³>ËÄ@˜†vð`åpCþx&fZ2^#÷Þµ=Q<‘\:Ý¿ÝZÞpj´‚ÕPaâÄÒ» ÏÊﻬ{]š™ ÐP\Lœè'+C³AX‰ÌßJ Æa•y¨b38?=Ï)°¥VŠ8Õ1ž¾>›qf%™á$ ,ÎNcb!ÇmÀ•ñÐú/qV–BGgý@µðÜ[=@ÕYÔÏüb£vqçÕƒO˜x]™ tO»¢jzO" ›><MŠ}½áòüqêCO!¥]lÆ& ~lðm­z.¬ņæÂúúE1òÜ#ø$£mЃ­é<E€¥@ç¶u:ù·`¿ÞGŽÌšU™J]nÑ>P¨lO$áÃþXÉý%¥ºÂU°pÌÔQºo©ÐQPÓq5ïÑà Ç›°m}MK¾ëÅcï•É|ìy¦âÖCñbÔ.GóáÈHŸ`C‹VÈŠF¯ƒï×)öNx/5¢”SŸÑ1£n)ì«·…R•Ñ N#ó7牳_f}Ôh][Ñ!£ç¤Ää›?–!C/ɸ+ìÍ2ˆÚž×´û×�ÎQ…g¤mé´\ñ¯v¥ßˆX˜9¡Ûû©@2 =ÿŸ7Àµ$Å,Ä1…ײ&€ø‹çÑÔ¹w˜ó‰›¥2Q|µE`«-Ú83Nœ®·÷@Ê"/y¬Äžé”xT¶êDZC©…IûBf{®Ã@=í¥ âqpñ¹Ýl«–…3 Pu8ºmL’Vt“T1AÉ:Múݾ{ûØõj²¤&¢TAŒõ`–’x­•ŒuN;Ô[ëÈÉ0‡Ý ÍúÚâ²`ñ·J?¸³b.Äæì`†A? j–3\5ϾI­1¼Š]éj³¼š¶–¦þw7ü»†`Þ4Ýø‰§§‘\ÙÐœ¿àÑg[wèæ³2µ“ÜõÓóÁe>~ƒÂn² ,ìW™�åY‡}g¾î¡Þz ¼ÙRÑÓµäCtµ¦ƒ'­5ÇË =Ééºo8³…òÔ¡Ò$ôƒ):‰"gÓ»ð÷õùâä= þ$IK-OQ ñiÑ­Ax˜:S&à·…²¼Õº¾LŒÈèΦÔÂ[—¯Ú…¸õª¥Zí†L ÖÊÖ‚¢K£ÞÆ«ü)wM¢n»­E×½O'] Ôµ"gçn„?‚¬ª€‹Ú—ôw kcÛq[úôþ|Ä›;þL‚Á>ÕùN³+PÏ{~{æ” nÙ»4XЛ³þÔ³Íe&$tNyægJ» W?ÁTr¿›¸A·ZÓÂQKŠgCÊÔÁzÍydÉhŠ­Ž‹+¢K`?áT¿ýî¨í{KÑ•©Pµžö±Ÿ.äaN«_ UE0˜³zdÌ5ihCl](Ï+aS/̲]ÀYÃrO$Ù8c‹Z_XÊ)OKÞˆzɳ|Mͧ%0•tèhÕµ³,á‚ØÛVÅ_oã0qý.ž yÚ¢jù¨7ðtT»Ð_v ù‚ƒ +YM08Ï&ÉËy$7Ìl›ËkÃÚ8KB¯ Ç¾:P8ÊÖ–—1‚/SMY¡T'õq[ôÃWwc¬ µ¸UvLŠy¿ÑP›ŒúC'/„µ¨}9`VU§ã<´.OØl/ íÊF‚QÔ£ 3€Ã´yy`̨uÌZ 7'J—ªõä$-ö;Š0ŠhvÜ·Ó61ú¶‡â[ˆ°e’õ"ˆ»O}Ó åF·ýVOâQ–î Î h´Á*‰ke䬶”ì™E¢ì–_°`,îŸAyëUáÍ¡í6ãŠÝPån”‚œ/t¸Ï}¿íú]°9Óî¡è«ï˨çù¸ƒb[;¡Îà‰«dZ"5¯’:Õƒh¸Ûžz" Ò3pÉÓfëu¡ÑŒ—é ߘ¿ä“[3³˜a§ù&´òîÜßK®äî8ñ¸÷A£²ý$Å5žkÑ= Ë^š'‚c=»0s¶Ä: ”s7UÉŽ6ÎTS‡PRXôœv3}\{ñ“¾.Ì (?íÓŠ±ËÆДÊôu·:OŠz]iÜ#¥’– ÆÇÛ=•wÿòçb‰¢*ô>=Êwƃ0BòwêçÎ .õ86¬ÿ"…\Uؾ&„$ lÊ–Ö—‚Û?±5,¦ qA´ÀxßÎ]S写:ç% !Ô£óì/FFùº˜Ü9‡ðu×;å^= ~~…ÃM£ÅÌîf[Z7ÑçàIƒ¯à¡ˆ4PÕÎl1cTÙw­æW9AQ9F<» ›,(6äËÀÀÎ/öà ; ͯû¹‘ù㉻‰ðÁe˜i‘]±J ÔíWcL ,ì 6½åç»G„_ŽjDï¤sG ŒlSºÇÌÍþQÕDªËÊ(ˆL”¦¦Û‹§N}©|åÐnHäõnX(®ü^v¼ÊM«–ý�Ž½S>·"²néÞÙ©ñü¶Ãäûi8)cœK‡x9½µ¶±Áf䘓MãÕ±[ÏÜï ÍÏMVØAO~Ëö^÷Ö·ôa”�{Ö[ ¼„ÎË¥÷ZG¿­G2gÈT×Ŭ½•AÝš©¿ %yyÛwg'þΊð.£Bä~ÞõŸY† É;åK©å1WàýR l¥›c4†Úuoü¬ÐY`ü<P,B‚_R€‹"˼ÑOMCë¨#Àáô‡Ípãé¼5œ„C„ÂŽJöûv>ï˜ ^¯VêM³½ íO«H'$½!$„ô›Ófô4¨ÑJ¢“Æ“¶ym)9”›éŒ/ê ·uÔ9sÅgŒMNì5_×Tf³ÜçYFRøh;ŠÇ.)‚²ûã Ÿ±ÞïÍvº¸s½^ îç'!Š(5JýÎcDõÖÑbZ´SÍ™ø’c™íkJ Uœé*ú˜Úîçqá¶ëú)$œãüø€¿0•F/¦û ã¼\nL¥‚Ķžr)¾qxpÑ1´è®®©jq™ùòÕT™uß -ŽZÓ¿êŽB© ¦±X¦9ìààðÑ-ú?Wí²"[HþÆtÀÅ!Ë÷ƒÄ×wú}ž&)å=cœé LJ¾žøW÷-Û7X4rJZÓôäˆ?SU– G3DÀŒWLÕÞvýAÞx¸àlí1q(~oŠÀÕåv¬‚¢×ÂqÉÈŸ³‰6ç‘Øûç †w´üâ!™Gà¦xèK: UZ(.Yj^èɲé §GD§<öMÖÀp±ÛU ƒé9�ÔÓ0ÖLÒa[]¼oüý³ˆÄÀ+Ž´Á?/ÎO :Î æ,í±W„�sPÆTUªËh•J»ûª‡¹Vd6:æ¡é˜ËhÂsFÐZmQ²yZ†øì&ß®‚¼k¼ƒÃ‰´ž õãTÛS`Ì‘O2›9nßÝíÆ ËFðŒ7Õ¢p÷:sâ‚í…é%¶ÎðýèÖ†Œ/¬kí †¶ö¤P“Pz³UC";ê¼€-É¥mÉ\çÆ'O÷*”ÿˆìöIGL˜…UD Y›^Üj|¿Mi˜Á à’†u¶¡Fö›ÞSa¿B2lN†iÅ5ÌÃðí«3Ü¿U›¨ÔâÝÎDQ(§埂-éü>öÙd¯aSóLÁfÜHi|Ô~"zôè¬ÖÂdð/¥OýŒßš–Ž=ØŒN¿FOÖÜøÍQ„k©T®ÌÊŒ .˜ôÛ(…nŽžóOÛÕ–ø[ _VXjdz8ïZÀ™®5>èåENhæš«’¬¾*_’¥4+®â¼¡¸¯.Ø»|aÑ„‹6.¼ °÷õìáÉ ®jz;Ó¯\ÿçr)7âª_&Ê# ¢7ñæ<ü &÷!,T=œ©4¨u$šPBë©<àέé]!fÕ“gx„ù#§Î“l©A¼š¡¬fS­ª0¬xZÿ|cùá±ÁÞ´¸¦Ó ¦±ìÓÈ2ÁCÅAuñ)†œ `cöÅ-ìÓ ”ͶD šÆ=ÔȔŠ6o<ÉïèÇYè‹ÙAϵK‚|;9öq ¶æä¼7xg{ŠM}úC °’ù5bA5N³ õS$x2-ˆÕžDp°læÀê°Ò¨6ËýÍ.ØÉ3H€®²Ë ~©,³“‘".ú ÚQ›;h¨C“¡pçY2u~-¦ŒsÝjàë­]‚jäáB:æ’,ok+½aˆaè›LWq=-¾O¨'þ·ìßñÍ1‹igô—oè©O¸‰Ãs ‹RG£Ò ΃iƒêž¤ÙI0¼®Wá¹r8ë š?ÄγГ|fXò@EÒúl Å€ë‹õÁ�j¢aŸ¾kÀáI.XÓ\P¬} –€&“ÆÙrsÝt×D‘—ÄТ8õqÜÒÆ âIA¡eÆVN“‹x*îÝЪ:ö³ïéª<Œ/ÒÌÀÓ 8½;+W^ÖüŽÒSpÍ(Iä8¼3ÏL½Yà}à¤nt(n…ùx0.b®iàÃjÆ&inÜ_b‰²Ô¬|†Kcë‹ÜÐýŸ g¬Ëmu‚¹Ñ¼}ÅK7²¢kŠ@šz×£vªÁ1ᮊ}(÷ÐÐ-Ý<èDkñ ÒÞ")*æ¿zÏy×®NGÚß7‹Ò0ó¦t°{™è¾CD(²˜Ö±[áŸí,@ñ…6}î ExµÛ°†“ kVQ°pªdž;—4æ•Ç"-EÃMA Çøc÷ºJÅclG†M×ïVõB'ºcì>aFé‚âA7›OúÏ‹ÁZpìFpvNê—òF‹F0>?~dèãWVdTì/ºëŽÏVâldÜXGý6-dèLNùyÂ|šþŠÿ÷ÿ¡šý2 ÷¿1ƒ_ô"~ÔÀYäKÓ)¾Ï‚l£AuB&ýÛ¦ñ?Cì/ΗNÐ÷ׯ·a]>CŠ 4MEëâÝê]W¸½T6¨eýÏìÿnU¥ûSXôk�Å=?ª¨X`ïù«£ÐŸ^‹}Ý‹êKrÚž¿ÏætMÙŒƒ¼‰H¯'ïiî0ÌÌ–S9u®mKÇ ¤¼É¯Uœl“L¦þ¦EfòÌ8Ì-ÚS´Nš‰²™ªÖ&h‡úC†9VÜZ¡aÑùô—’ljްPÉï,ìV½{ž XcÛ³—ñ<%"™oÎHËèc.)lÜ{ÒÑ}8B,Þ©ˆdûMo«}›;Ç™©N c@&±²Z©t àGmʇÄ«™°£HK–ÍÄ4Í|$5å~-ËɨüÏJI0dì˜Åk… Äö^4G"[Z¶$NhøìY–K‡Ð`¢cáR5í;ÜôÕÇýQQœÆeYÚŒ•>ðÇ …¡^¡`Ð�^ºól¤º#U,ò•ãç™þˆ»È<mµ§|ägK‘´J§Bò™�Ûk!­©ÏB¥Ié•Šaµ0‹L¥6Œ¾$ýü¶é㦳Úá¯k"î(‰5»2P|¡ßtÒ”+¯jn¸ÿÙõ·õoV–(„³YñØQZRÙîæ|gpÌeZ~�[¨`Ó±fm³ù0e èT{>‰HyR1‚æïÀ¯˜&+îˆ1ŽòErC÷¶†ˆ2Ô3öµ]X×»^ÚÃ+KÉÈ|ËE|TT±E\bøvìö¾ž,íÝâ«÷6*ÿ¸:ÝùùÍaÏ:èf;ð!­tvsõ%hzJ.6ƒy.õJ”ÚÈÐ%ePZíxé—u>Á€Á„ÅwWÂ(Rj;Ð*Ûžþúr£ÚK(ÝX´˜å½XT¬(BÊü¥L&i/!Š u^ ³Ï5ßior' Ä×»¾Oƒ6Së.Z[ÝäÙ)Ñ Š× �¼êM‡|±Døw)•í“¶í»ß›Ò5=“ÏMø½·\ÐÓ²€àкˆUlÒÉÀø›þ*è>ß’U§¹ÜŒ]ß0¯ª8‡C˸ ÓãÈ:„~ªö7Ñݵîlì5í xø¦lõ[c>9z ¸{(b:€»`„¸ÄOOšb›v*\x§W…*+Oq¥W0Œ”ÜÌvøñ°rì,vä†ÌÄ•DŠsG:œã:éžû»a¿J©Åa’î5GÏ¿J—(˜0$S ´¢o^ÂM@Sæ×ÖýNìo]ùq\†.¯¸Ê™‚žÁî¢ãþ)>#-““mlÒé¸ßMŒ§[î]™ºm©…xSâËOž¥±²C6¿›& þ.. a£ºP×R¯h;,ÀP ³•iw$³n2î�ö‡õüŸ7ª\¿8Ëy͡Ꙃ׊8Ï|„ )0+ç£Cÿ1sfÛç¡lKðÇëBK+vn´Ó %AÞ+• çà¶þ¢{P«ÄÉy×v‡c7Üìr…ˆK¦«ü82oÈm�#ôT•þË)f£ô T<ÔÒÏ1þ¥¥“VáÔiOÁ5=jùn^3±LNqi€zGX¶J}yŒ£EÚöéÜzp©©^Súa6ìy·‘ŒÏ¼ÒÏ¡èO~œ=¥×öfÃœ¶£¥ŽkÇ!ç­­€Ï½‘Þ¦´ûH«F†8f´ »féb”X.(<}Û, vý§B´¯ ‚lº08²q:z) wÿÚ·÷züÚM ¹s”½ó øž³CEƒiCq¶îÝâït+¬…�é8nÜ•A€/´Ú¯•Û=ìÅó‘>{÷à¾\L:”)’Üð—ƒÕŒP5'12R¼)¶Ežh§ÈÓŒ&¤k€¶ÄÖfžf{€$ù»cOr¾Ý-ã”û>à%Œ×fNÓˆÂ5ôy~Øgß´ÑŽÏg(gäÚPaý‡ï ©phݱ /ÃmOGÍ᧪K(æ“‚Ç–*ã—µªéãÎꕳ8ÞŒÈ=L†II…t¸waÙTÎ$7Ò†—ÿ­CÕ_‡Ä´Q0­\6xïúç "I4ß•Ì( -‚ì¤Èúä:ñŠËiÛ i¿v¬ûeãÿæ!íá·%Á½úÊ‚b­x;&ìúÕa0ݺÏ*b¯3+m•sM'AØö^Ó¿¡|c;½y`ðþ²ß?è g¾Îm(±ái?ÍéB)¨Ìn¤!—rƒ@ŠÃßòäeäN2îþ±µjµm<C‡kŽ)«eœ àcæn‘9B½éIˆšÊéVɱE°H]x& iEæ/ëQü[FnäÕ¹òǬö´šFµöL„¤Ó9d‡»‡–w¥€Ö’§Çæꊠ¬7^ÍL¹È‡Cƒ/ó,:æo¶°Ë…Xœ1–)ùôíÜN}?‰%´Üó-–¨Ÿ_�4¹;À½•éH7»ŸŒ·£訫¬à’éëRÈÝýé<¢î,Õ]EΩ%7–ÃH'nõ©ù*2ÁwÚ¸G*à5tØ﵃3Šº*])DKx¸ñ'å‹–€yªå¹s¨ÉFýºŒéeè>Ù¸ðð±<¹î¾1q´î¦©š[‹•3øó<ÏÒ‹Ÿ­½¨H® eö ;@ÈÒkØO¶yÃŒÆËiÓjx=2EA7½ÖCGØ€šfZCß¼îN©]m‹xž¸ÌîuÙ×ò9ÁÌ ˜Ÿ}~{6‘”mÖhÚÔ80»wIë;wyš'l6>Íà‘áV 7Mð«¹ö€ ý­³Ãáßz‚?ŸeR†‹y^Ìç*ˆ[5ú8XŠÀÈâ„ <S­­Ä/æçÅc…ò,öKz¼mq:b‘¬´ÿ7µ¤û�0/sï¯_­3ªúZP´iZZ—™õEO#Î.ûݺþV)K�mŸpÃ’Äb˜¤Ëç¨ÓŽ3»¹Ž»o[«>í6G¹×›# à”ËIÓJ¼£tn%¥áA*3LÌ uÙn³ìEÂ]Ä~p¡cus¢e×­GUg>¼ºÝp×H¾ò»é¦r”Šý±‹ƒ²W·–¨ŠZïGJÄV‡VœXa±,VKaGUÒi@c„è)П‹Ì~K•ãÔ¦¢YŒwÐ�tö}Z†j;‹óG5ÝÀôwa Óã6™ÝaYì³P(¼O9m°OGjn´kì»ÂÈ;°¶asWwu;žù’ƒŒáæ Te· ëѤ;ŒXÉPéÌÄ*óh1a-æ©žý¶ðxôë´ƒèÛž†nâôi{vv-#}•eþò€ $’iÖØCCÛ¹lïwþ˱¯ÏÄÔ™òù¨UÀˆs­ä‰f£Un^߀Lì¡G-ä:M2ÇA DBØÕh¿H<ŠÔ½yÊÖQš‚±ilMW][;Þ5Æô—/ÅMoêLÅ¥C–³ÆÉ¡§¸o­¯&ìx—vr¾”«­¡A^_Ü\ª¹(ýFM‚@Ûx Z4Ò–}¥.ˆŠÌ‡5³<C„ømfBaÔ­6^JÙ£Ê<ô"zêŠe¡ÍD.Šk-¸GG1,ä£Cséßa[&>“µ·Ê í,·-R>—Vô|p8£oo©LTZ+«â=D×:\û~û|+Þ�qg< iGÆXr:èYõ˜_K¨Ï힃'[k•˜âM3žj 9ðhBQmäãÑ°{ÉXÃzçñùøßj›ÓyvÚ˜ˆ°žÎù¶?œµ†ù²èbò ÆÃmëNlsñÌñ†TQd†T"]B™¹so{'%¨gZh&†¼âÍíÜ&"#Í ít²ƒqHóö—AD]ti?qÐŽÃÔbÃQ-&G ÒZçE˜Øn,–[Fþz/žª÷¿çjc¹K«h!![¼a@À,RsóÝ÷̯¶ß>¤°Fié[ †´„ΙN =Á~o©2ñÔ–Ÿ!MdŽ-#–ZžZèåeò Ç#ì;9Ó•I¯n1€ÔXS‹OúEk‡@ZTÎZ‹VHb€x;aVÜyá…§^†7�ÿUå­!ùo‹ ¨?=… ßhi1è=iŠz‘wýŸ7߇µŒz_ùß (}#mð·´Žßž˜”µFϵ<í™ÎrŽÅ¶/P9·?žŽméxN;[,±A Gµ§†rÑÕË-eakæ$enÛ´ZÏ£¦¥?`9b\zH{^ãÃ+ª -QÖlD‹è]Gh;>|l_x½Ëô¶›„×x§·Ç…Ïå\cxÝÔ^zëô~Õ¢—!rÿöÝ¿ÚWýùdò]’p)ée‡µ¡Ñ؜҂]ú,’d¦?„î@p8÷T«êBëã[è}( ÃpAéKdð@Mmè£uõ$%6t–¨â݇c8£kT†uNS)õ¹¦ÛµVå¶41Rá’S4t×YÃïy¢ç²’Œð@a®?õ1ŸÙ!xŠ*'°]Bö y °•€'D7Ä¢4æ ãƽ£JkË‹~Ü�]•Ë•Y¤ûÖézB_êƒî¡¶®ÌÌ«òì_m“ø.’6ö&wR¸7|A‡ÑóÁ•e?-ö›jÁŽû&·Ãjθ!£}M½Q/ :ÒGxs5ü±ãV¤w%=}$$·áö™Ñ6ëcHGwžWÖ´7ö¸%üxSÒX8 Z ävž:,DB¹µ>k/RÐ O?&”óLVbÌ£`^„7ÅdîO­=²~)†Êel-9wU¯ÓB¾Ö’Ñ×Z{yfyGXZÌ[˵¶%w·º¶8�…ø8ëÖüS)Ýëmĉ/2@‡ãýqÛªÆS¥“⨧`ð‚Öƒùz»ŒÑÁ B°T`êþîç|+Êø6v˜(e‚^PFÑIœ·¡,‹ËD Rf%C¯ 앺·º$³¶Â¸0@Ï¡9Ìõ°[½M`Fw¯­«w*¹lN°ï¶r¯ñâ–±Ê+^ŒUêp|ltkŽ ¶¦´õçzwh¨ià×’ŒÕï¡®Q¾^Ž…ÙÞÄ©à«8•Ç¶+¹=˜`´a­™é°0ú<2á»Mž»Ž‹Ìs¨¢íÚÎtcÆï¥$EÀ~Õ‹æ’¨é…ɹF–àwH÷,öÚí9²¯Ý¦ ²Æ9«„Á¹€±0Òòp¯¾í(å¥ìÄÒš•Y“(ã+Qã>òiò”¢ë––6E>ØAx“I'øtä à%2Bê‰Xq!ŽÑneUT¢˜åÃÆq·YNs1ÚŒ§¡Ø­„•@Cóu¿A¥ã»ï€Âóêpnvó‹ÀÐÌ ž1:¹3”“áÓ¤œ@pÔôôµYšOTSŒ‡¼}5Ó;*ÙjÓg¶xdó±by–< sùŠ?H!o›¾¦#ïöOÑ9O²e?n*è„ìOX†ñ·àÊ$Ÿi­@uЋܨ\üÔà‰ËðºýÙÑ ó®‚QŽÇ\OÝ×ná/Í*Ï\@Üg©ÇpI« µjšiÊ}‹}çIÌÜ™ÜX6‚¸…P*3n@)´„_–0ÇZørxÑI¼§€èwײØ9—ôë}YWA¿8Ñet:£T~0ÞLÓ/z«¦f#ÓG[±ßJà®Û\çAz>ù IÃh «Höðh”ž­Ié]ê›Ç–R-ð䦡›uµ±gNc ×vC¢ÊKàêu±ÓxÊ‹ƒ¾-ƒ¸Ý8HQÚl¤ gz·Û Ýâòp¦Â]¾z½X!Ý$‘XT—­Ö£I‰äyÚu¿TÖ³ ’Üè„CãÙéY4£Oä.,âëÒwO=à3à@uì<@A¸´â$4DœöÄ­îØý>™•Æ::.Ž × %½Þá4ðNjq¤àÎÜÓ HéEšû?,}NQÖô›„p*F÷]¿ûSÃZÁÜ¿áÊ DÖ#Z[Á”‘U)JÙ›½_Ì@±-ܽ¹yõ#4Ù0¡žÌš'«¨€‘*SŠ½Y ^x:ã]šX’&™?‚L`Nw¢¢Pgª:((`a�w~wìa`ÔŠè6ÛUß³ \’슯Õ÷P²Ú=8Üêa¬ûÞÁõxOÕ´f¼+:Ë›Ýf«i¶÷ ¥c¹kí²ìjM™Sd3§Ü€¯-™`˜/T‡P0·´^Úúmu0 ®×ë[?âCÚx¬^×l)ô@Ý©DP"ãº{ÛSÖ!ßÃ`Ú ¯I‚Uzý!˲ í,Í Rd‡ÕÇÎ7%µˆÈ'W~‡4TšÄ!ŠM«-'*}�aG%¹?”>h½á]ÚÖX¾PŸ�þƒîp¯ÀÑ—Yµ3zþ…ÞOG½Â5Õ¥Îl¶´•;ëj‹qgëšnßi1Þ½^²I2F~6 P!Pie´Õ{ÿïÍbáE¡éÓ‰¯P§ <Hö`wüç~nÀ;´dˆc;/ 9À¿Ì¿‹ Ý*à?*äT¿m(Xìý%0÷ôí™°ZSúží%w¦®£¿årÄ/ö®^Ý—vlXZ¿tJh³÷‹7Õƒ¯É@ߥ1k^äã?@d‡~Z„*¯¥¨2kÒ¹¿Œ¤[]°�ù·¸À¥cGûýc06/žøàB‡0-üAÝ©y¢t?î;Oó\ïdtoe1ñ{¹Ñsû’1Þ™3Åbþ;$í·ÎV¶¥P"úçô/¦ûd÷%jÑ3éEfP—“[yŸwàh7®¾¢‰8d³6à_°u¬6[Ä,¯ÈXù§Ô°lEé‚~ƒŽ)Wë»ý’ýMV^q ›Mƒ75“\9Åÿ {¨˜*P(þ¢péNÐCÄMÅäîªÁ“¹’ç‚V ßÜ´\´sëÿÇò^@ÓÑÞ˜–¢‰·u´Ó"óµY�êéÑ7Š}uSd­Íã‡ý"ð4;<L¬³N þìqòK øÆb]1§m�'ÑóŒ[u«]ïÄZ;UFõ‰©ZlëBådö©ê)€7ô»xþQ½P\_)'#ëÈÅ,‚˜©#A|T¸Ó(˜ÙOQ‘‡7Æ'ú/eÞc { Çe°ÿHƒh«µfzãZ›ã®OãÁ9þ.࡬Å8”6J”V)§œLË¥“ÓÖ¯¡ÕJUüÞñÒqsäÆ>ñ¤ÖÌ\»KèýOµ³¯lzWŒòv¦µCeÀ_ѽr¯òƒ# &UPYk6ävÄŽ'yìçûèXmŠÄ, U³JLtØçæ¬-…ºˆ©Ä0;ßµ•ßpϦ+ÒJéš#< š!9ÒŠü¦=t0ê…¼D*ÔNþ{ÀxáL±.öubU‡< Òéݯtå\…y@žã®îØáØhez)ÛueCïñb°<L7û5«®Ø©Åa¡Áym©øVa~;OÑSJÊzï_œLd±oÚ;iŠ#±•å†Ú£6=Õ(ö:|<Š#Elñ~BøÄ/ÿ(9gõŸÙ ßnÏöZ†ûÒ?|óé|¥Ä÷Û:®V<ÑwV§òwÍ%›E'¥"6yPžµþc:4€6¾Û°{Mz0N^aDÕXJ©ñNðÃz]‹AÖ™{Áø”"Í.c¥~„-suÍrë?6ûùУñô©'´áPe®62ý£–9YqΤ¼’ú[¦…13?Ž–Ã&qœã¿ÄÌÑïLԋЯÇ)ËYà_Ó=½IJ`'í­¨xÁ¬ÞˆE]}û8‘”Þ!’2 “ëÆçÎúÚz¨üš­“;û0€É’4k¡…³ÞÉOf�@±Ê€úFÿ¶ôå§<è)ï̶ßë‚݇ó‡H ú—?+#ËJˆ 3v¤’/ˆ…EIÕˆ‘ý^çÈÖ“áÊ›a1ÚÍ Õ¿©cq¨0Çq·‚_¬Èq[¡Sî^ºÃ×® T\¾g·è0Ÿ;5YI˜½®o:–ÞÔ•Ž¶Èx0Z£àá­F \ÃN{f|ÈÙvº[1Ù4្W¾ˆ0-µéÑâÛ\¼–+–+7ƒ4Òm±¥ÒÞ†a“ ß u$$‚;ÊÝã­>F4Ad¢Ž–%CÎ6‡ÖÛê¿òGÍ"ŸVf”Ÿ¤AÑ*#R~ÊF°‘^nWßÞÍZ*¯ß(Þ$mjfQ†¬'_`|®o[:>0:gjÆÂÖŒ[ZoÍiÚšì„Ò<>a£¶·l‰žÕ‹…6dÛTèÒiÓM¶£Â-:O*ÃÉø w؆!Aâ.7¢Ì³¥m÷]ápe Øwµ¹Im}îwÀ;›Wž¨C ÎÓl4†1Iƒê2x¤i3Oçii·Z! Ô×3zRX¼64TËÁ %@Û‹¦õÔrùNÃj.Ov!ë×›ey#"ÆîüC»…Þ‘¾íµYÅK{8Ywj÷Ó0;wûFò?y½'ÂZ„ øNBudJ¿§6¨êã©Ÿ¸¹h$Ì D×X Ò–¦›Ì²ìÏPTÑ?©×‹Xpt¤ÔçÝâW’:—5#K4)W}"}½2’ö3ÖË¢£7EšÇúcÑ߶FnIðm ]ßweÚ•œ‹*Œ¥vìš+‹Æ‡ê-΄H0Gi°§³ºè´E”Ó2Þ°£¥~T³Ô¼ öo]¤Nf ™øÊX¥L$dL⯠âilj){àÑYu³4¿v÷¤µkoø鯈vÝJÝ,ôÝ£È(õõ=N;«g“_KÛ?`å»ó!3lí>É™ç¼*ÇÓÑ ¼Ïö1Î|]•3žn(mªúµEdK% QTÍ bο¢Ì綼X¸øqÌŸ´&ªùäi2ñ¿z[ŸFLÕ5£™–t!Ýô[.õï‰èMU ¶Î)…Í?vŠý °ÐGŸ`€O.ït€ÍË´Ø6ÒÓ–ãý­Ùu#´eA¨f?#ïê†Yb´¬¤ (™¬lUÂ#ý™õÂYšÖTÍ•¯¾•ßõÃÆ2÷­aaÐ|ò‡E#ÕxÃÊCñ®°cO pW­ØÑ~tÿÒþÕ<p¦p©;º I°§"?][ NµçÝà›Щ/Y‡$÷½iò¸ú&Â_·é3z:ÖŽ/f?êÑ͹€|žÕ>óÖåÏÛ5©KcÝÛ£ˆÊꋇ©Ç ͤE` (%@ïÖ^ðêëkŒ\Tù8ÄDœ9ËîÝ3´» ¶¡ú£Þp€zèeÁ}¢æ•6á»í²²Õ´NzÑnØfè{Çϵ—FBî†þiåË ÍÛÒnßêøÝørÆ1ýçÍ*b+üì/glYúã:Ît8vµgðÖàž;«Q.65÷ëj&­þDTK©ž0(+ ·[¯ÅÀÁØ%_ï®hûΙpe؃Vhãa®ìqÓw¡§Î‰[WZ繓do =L‡òIKo( ‰>ÎòÐiŸ[WÊë¾:ÈQQÒYc)'êMªféõ¼¼àüWVÎË€GàÛ#&ùïkŸ¤™H³w­sä­+†y1êïŠQ’ZÒ5eŒŒG[ÁEbnàÆùâ—ÂðÃ+S.›”î±Á>‚ªÝ8!1öy¶°¡Ó¸çÏ aýÌ=·Ñ¦Ý”AÒhU‹©ç4{8»Û]®›—öþ„Þ &Gvsªè8»òƒS>}æ·Me ÏLƒ'QÛ#º~Öù¹‡_)ÅÌì0ûòožmìû,ÅÌ+9:µ– @:¦f!|xÏŠÎ ¾‹FüX€®î¬dD‚ìÔ&ÞÎoåF–Vša‚6PnZ/‹Ý×›áÐïji¥ž�Zã$ËM·/ßkɱ"ä4€€ò^{™-·÷L/ÂÖŸŠŠÛzDP PdØ&ŒSvç-2 ŽŽHYfO …x¯öŒò(–NÊZôyôЈðÛb0¯<Å—ä± O‘ˆ *ÆÀ¯0å%´<Çùb”âüí_úZ:Äלæƒ&º×¯7„Y=lÖ“eMj¡ºßRYÙÛþ²gMVøjbaô´L£w[‰L¼´¢­ŠÇaBþozÏÈÝ–jY!¨)N„æÐt)Ý‹û¿ÑÛŽ<>Ñ©‹Z%_@í]Vè[Ù¢öA‡n±"S,ŸÍ …Æ°uðE.ûŒ·(ÏZÃú×ãiÚ20ôÔÌsêÌcY‘È3¼¶U;=ç3ko#Yµ¯êŒub™AË£ rÆô“ñ¼Úx~ÅŽðÊš0¬BÏ„"tJ…“w 8ÌK½—a‹rö¼Ó|ñÍbX˜xƒ1FnSv\Ò=Ò®.Åì¹ÞõÖèúéCÕ‚€ ¤8¹a—‹Ãþ•$Ê¢ÌcZSŒÙéGï­ EÐ9LP”Æ/8œáqG+G,^%áp‰Gg k„ˆÞ° âYî#¤\,y zB@DcAÖû,y°æ8Mm2}çjìÅ€ó c¢ä¦Œv–à”jݱ 'dIæ¹÷Ré»ý¦êtœÝ’g{?l{ƒ˜3Ôv£c_W`¦ŽS°¨OKOû-Vš‰¶k4ªtÁÚ/g?Œ±þ$mѪ ¿Ãn±âÃÿ¨Ê‰2í66fIäßiÛ*háY?¬:8 hyq‰h‘©YPÌ…2ሮXCò; boa¤®ŒàÏ‹ãÊ(5n%ä+³©öÀ�›ÃèÆ3Ϲ�…í3ŠÛ^œ[¨«Ø‘ûqŸÆ?'G‘t. 0ŠdŠå¡dêo v:™‡$õDì! È$ªÚ³UžTNî⪑Çi戎0â¥Skî­¥z.ôISxz1ƒwÍGß]-avœ¬“ŠSYÍ{R)²„ÍŸÁ‘ýÛÅŽûuoåoY|i�‹"é/š8C%‰ŽÀãΤ- o¶_sâ§J\Ô”2Fƒ›lºo4¤Ê:y> YÅü|],‰…'¥¥LóÆN) 6’ÇÊ*\hxåÁü™p.ê†MÀNŒŽ¬m‹×Ú<Œ Jy¹¢¡rOtê‹ ^O¤Meà¿L`€ ñáœ/ÒοQPdž}ÁA £ôÖm¬²D›v‡¶"½™ÊÕ/'J6n{!µBf> i¿‡´ÚîØFÈNÝDvÚçYܹ¶`Y·.¥K¯[ò9K�)Œ ƒ(.¹« í4½rø<ŽqØ^ @5>o}bEÛÇã ',À„_¸h´\t`¥ ¸#vÕ[Öñ4É$E/=—ô×|X²ty¤…Á=ÿ¨][[/J#z ¦$Êï¹³¦N:8üè¿>œ!&kãšÝ3Í%wñUR„APqi¼œK+}×7êæ K<oOf\6¬–pôXrÍŽŠS×Íøµ7¢õî²´\=ÆÕà µHô ìùJak dÁ:¥}:;¹Vú�êÌöõ‰ [¤P¼™; ÇŽv«¾x6`RHDHÛÊ ´ µ„l€1ä%cx%ÑB¾~ ù[]ÌÒ3åª8P�Ô7",¦0HéŸ×#ùM÷Fj zóF*ƒŸES³ eŸáF¬ŽPYî;zŽëZÿ”¿ÎSFx¨‘%Ksî„`ZúE}öíryhí{Ögí¹<xMËÿ±2r±@dD8µè—¢î°Í+£ø'¦ÀÛÚtžíŹëϸÀë¸P…Q¶0ÏËiÙE_A:j1™D5ªUä!w€xfòƒM` ¸n̲òljvÄj‚Q3Xå úï:€bP p¢0Ó–Œ'{9­(=”gb­óBÛUŒ0²×ŠB…žæEvrýD™Êñ@™ôI?ZuÛeÆÃûåa¬Î}^æ[¨BÌý»²cíj\Á€QõýeÆÙÙ5zš àïÖÓå~!RªJ!ã0ü<E¾E"“U¿Ü„öÄaóÇW¬&->ñeÙUJ}ßé& aL FG½ouWâPqcÜU$y’™’•º¦#[V};!Yð<5P‰OžMA̾§l$ýÑ #¼'˜F¾ºšJ-” ›ð#CÛN@þMù”k�÷Æ0¨,M,Ž%ëšKì¼Ñ*1ƒ ž¡÷zCì4óhÍØecvhe%IúØïÇŠUùœR•™ïó•dª³?[g ¹ê–vt´öf”ö5‹X¼ Óàæð© 7-Upk¬bfÁF4æ´yů;  Pªa=µ}÷ Ïù�ˆ¾5áz‰éi½|CÇ,ÿP´G+úçs; z Y-sÁýùŠ ÕͤsT—¾«‚b=ôdYš®¹¢>(§j‡y�>´„¢Ì·¢©jÓôÄå¶F^;3N'ÇhÄìAiÚ*˜Æã4æt{ófö‚RlhWv3–¥,ÎeU0]Ò »lU’'‘’‚u~d/|Vw–úÇ€‡î°³ªäJ­hØ@[NS–4ÀïÕ…ò¦7zZ=þ#« !¡(’–:(•¾™ÙÕXÄŒ*^b” ÿG¤FçŒbÇÖÃü I‘s#Ê[´ž¡ý7LlÃûãâ†j;&†˜¾=!Ý]÷*Jó�Œ¹ÊF{T�ü@bGg htÜƸû<@Þˆ2_–”í<½iáã]°uzçy~Û¨¶HhE9üXò fg¡QL³ÀE‡¶MaliW<´Õ`þP>ývíDÀ×7˜Æ<(N;ßiï}Q,ÈWÏLÌ¿|L^̼&»°´vÅh»8Ó4c7vÞÀ3Xf¸=ŒGÊV½6ß‚=uïçÑ?I”¸7Ï;$)®Žw¨%>—/'Ä… cUÛMBÁ£³9V‰®ÖùƒÕV¬»–¹ ¹cXŸüj ]XgæZtÀÖ³’|o|å„; `Ò›lÝfôÕRöµÝÐ -j_kU¢”ÁÔwµö—}rßÔ„6샨m¼‰Ü†ÞÇîàíd*üãb`ó2s@LÊCÇ }RÚÎb4°¯Ûî}úØ¡²hw§=§ïõŸ?o«z >,-|Ö§¹~è#Wî`fÊÒjOïrôà®Çn>ᬷ•Ã~ö“8ƒ¸KË<¨ðÿ\†K§Á†²þíÚ|\ŒÊ¹ Êøžp甿T© dÙÍtÚ ¿0¡¿EÉ£Q¡újðÆ)ßµ±(˜¦+"JVTax*§Ïœqbµ t­Ë± òïVy@`<\z5˜k©ýj™ÆåÂP&b¯ØÜ[4[_à8šðŽ3Yúœÿþ5<*ãÌt¤uÚAQ©³ã¿ÌuélHÞb¿yXÂd ³ß~ØÙ¾]¤þÜL]Ø=É8ôVW˜¢¹öœ·‡ ßÑDÜA«Qáy"Àþ¥¸‰—¼AÓÒËR°Æø~ Š¸ßÞŸö íÔWxþaa  ,Yø"”àoúÌS{maƒ ÛÊ•`s8µúrƒÐ’-` ÒÓ‘×£×~b@½,xɒ؆>(vÃô�ä%ÞãÝ[øq³ª.²]òj>ŒÓc;é»ÙÈ{Ñ[Ì}}¾Ñ¡O«Ü×7ÆAÿ $S×ZÚL‡E²uã}t}ƒ”áC*”Wö qì;¸Ññw®ßµ5ì-n÷·eYÚónìL@K{DåN«î1ƨ ýhÅÜךOÕÏ]CÀ@u&NüwMÓw:–‘ƒægQ¾=Ò²þ6ÐôZ;x†ùŸ�–ݧ| _h›3± ™ÑîNXfɶ±(¤±eå‹$!x ½í©¼q;çAúþé(ï20à]Ë­s{!ôJš%‰­æ§±�©‚¨?››W ×Jvø[qŸ8ŠlœÂÑH;e‚gÅrÑÍ8ÒޙػPdéŸ!Åý)ÛÆLE ­_ñ‚ι½ .ð±¡f›/;:„ž'/6^,êZóåî0¸\9_º>´^,Â…tSœ)Aέºb”ÕÒë`é\ÓÁ=ïf&—h\´M&‰1?‰¯á,‚tŒ~›µ©M«…쎩î^óø£Â·úCœÈ%o.VMSœC½^ †gñaç;ô+äKTzÊälQÖ^yÚüÆ„yu‚ó΄¦jÏôûñ„“ŽÛœ/t$vÕOQ`ßç½4ݳyp›¬AÏI‚ümðòá£ôiϳ~P£MÚ¹ýävA¿£êÔ¶ÎÛ·ýnŠ#Ü׋¬j§¥S×qkå^˜36Í¥JB ³ÁôËßâ#hI8„IŽÔá<Ò¼wžãêÀ.K ›ûêÄd÷Bçc ®ŸGîEëB\nh WãÅëPà8©{ºw†/L¹–žAÜ\}ûªdg¶±ƒfäWæu,_Ù”Äèa]ÛiÜõÕˆ|êZ,Þ(qÊ"‘MˆàÜCËÁÈÍ� �÷-öY䇯w^þ�ü%ÊóŸIný+3Æ™ÎTò[wîX|ÕýaøK›—ÂGvbæ‘ádV247lëÓØÑb—ÔŸO§#2¶Øú…Æç°¡Ù‚v6¨_S»°-7†Îú§(–»}fÃ/$_’Ŭ7¶-}ôSm¿$»¢Þáþ ZåÔR`œäÐûØ”1u7ÔnÓ¬°ºl|pRl9zÓtÕÏÝ É×ýüÂÚE‹ý¥uSëV ôètHºä]{b;‚ŸRû–ï­'€Oï<a_iOPXÈÀÀûÙט*r“å¡v|…•çÁ•ðˆ‘~U÷Çœ¯t ò?Y¢-`gß õÌr+¬§&eÁ‹ Á í§�µpT NÓÑêà”4`᤯z°pÀ×jQìA^» VÄ•õèñ¼EÏ[ZP\ Jƒûaÿu3Œ“álÊÿ¦« ümI’Y 'Zî¿Ój¬çÆÀ„!5)Ì•«o5 FN~Œï$>ó”ŠÙ“ã´Ñâü"A´Kºo=ƽËGŒ û`2ã·Ðl« ¶â‰À}íPÿPièÑQ~Í̉Â|Ñb+‚õ%£»wt6 òáè—Ôh7âŒÇ²ZõtJQÚ2Ýú÷”9YuWW$Y<-øtÚYd‚ü°Gè øÁyƒLþÂVÛ@VtÌGëbÜRB™54&Üçé×mÍ¥c/€£m}9ó#„p§reºl“ÅÞ½“0lý¢wm¥€KkŸ’A^W¿Wìý,®!6SŽ ;¢cﺪêé¯ûIÑ`¯ë ;FGdÓfó8ôtÃ!¸±¡#¾®uÃ?X d¥š÷ÚPÕÎ<(Ø'ßô§XmäÂiiŠ»à/‚Lì5¾Ñ×¢\®†aˆµýÜ×ôOvcÀº€|Çq¤Ö<h¢0×î6;ÌIݥǕÅ 1æ3ÚI­fŽ1NÊ.&v_6›uÇݪ“¸p%ˆLÊ]¤ÓÛ†çÎ@õ;>¶Nt@™*d®EËäqwÛåTªpÝô´0·s.fxoÂÉèøËdT_n·)XV‹ÈÖ/º3ÑÖwÐåvk79Š>4QYÿ¬û©¾)ZïÁ›x”Þ§A<& ÉRnw8ÂàsÊDgžåÅèÍöhcû¶{Oß2JTBÜüJvQKþØùZsU ‰„Sõ¿±RSAOžUñø‹r²ò¨‡DÁÏd§Ûô‡äÛIv%Ìu„tìðiç ùDÈÜIΔۗ wTŠ°†c­©s@Ñ~ó$Zþ{¥Õ"òm¶Že¶Ú÷Ä€xu˜UúÅ´å¯ÚC–ß“P:[ èßMI‡Þg[S!d¹h6`ÕÒ"cÜœ}])YaVT)uˆòØø½ñ˜,¿¼›ôÌ:´È|ñÖÊ‚l;9tÀ+èQö&ÅX|ö®îsC…á y CÖ¦.’Ör „Æ ŒŽ“Ï¿*”¦™'‡· œ!mìÖ0žf§_Œ?þ ›ÍöÆ’öºlkh™úf�¥•A4ªU,óÏ–”ë„h(@IZrƒ^íô"ñò ¬?­'iàB¸?Ö¬tzò)w~a ™&Aµ®ó³OØþ¢c>Á"›yÕõ«}ß$ é}<+ÒMŸ%Ì}q¾#ƒ‘PYã^¡ãǾŠ.ÓRÆ=F&­í€/H5¶äæÆÒÑ:r¼bÓ©¥2íýÃÁ� 7c ³~G}ZÃNQàbÏ(ài²(Š€VL‚¬Û˜#:E¢ð$ŸZJ°ŒïUzF§A»VËO¹Ò¤Ïì%ù'7r„¤È–Ki®éS̵kŽ—Ž`<ü£„1#¢tðv¯x‰¥žB8øÀ”ÞP%¾ÕÁ7œ[pÇ<õÝD–×þýì&Q£ gèô�¾Ëøa"â:ü4 yÖ•U Ò W*ò‡ÆcµŠtöaTÐåÁÊó¥¯LbÅÈD´Ø·šRÐÜ" p:YJÓ¨‚†ä!@˜ö;YñËï<¥û ·²‘VTÆØâE§|®çÙäHX¹6•”øþ=¸IStõFñú͉šÞBäoÙ&ï_V«£³X2 1úØžäîg S‡·ÁŠ-<EFyj?>©L…‹­ŽUQç:µ½åøå©pdí2#Ü…ÑYÕ« +LÍûº½°Œ± Ê/Ñ"òП¹Pðiª2·Ÿï$:>ª Ùµ- 7.~öÜ«Ð CàƒbÌRJHÃôÿƒ…ö¿D3µ#rÁÎþ |P§EåqÜí±‡½ÇÝ 1!žÇ|8|x9ä#1S«R™CÓÒa‹ÛdY¡À@ 5'ͪ& h~ƒÉ´,åÕžžoÒª InnК½Q.›{±ëÄ‹:‡ÊŒp»¥„£=›ÁP‘@ nmoZÚ¨%ÀáÌÉ©HØÀ°d˜/o7¿¹Ei²©>Ø)¢[Q[oör˜iåQq­Óíå <¾'Ê8†çÓÉÓs€6¯‡§…‰œYd“Ö_ ð±5\MÌ(šÒß$(k m`æ45­Í ×’–wº:œmC¿X*dy½JSÏ1>SŠõî\Êtö/ëÑ´ú, ‹mM9‡oÐœ3"..?U‡¥*¹òŠ7hµŽ6·_|Á:‰Þºz`7š†>huì¬Ó¾;òj?úm¯zNGEì3a5u(‚ªöÜ›{¤:|T. ÛC÷Äç#]„l­P‰sëÏÁš|¼4–â™Ün/TŒY-³ Âñ{Œ«v(CP5‹×"†•**v[Iºt# ñ ØS…~þÑy}Êýk“Ù]˼™+—†,—=_ŠcUuÔêM§ô7l8Ù¢‚iE M#¼;¡ÓÐdN™Ñž]�T'sÈFÈ™kŽ´²£†Ó oúãB�Ú1C»ò °‚D• Éàz&ƒ*êå¬Æeˆc®»|Ÿãij‚:Ì*^¿›Ð‰'00yºUcÚ·¾; 貺ÔM—œÌI‡IÓ¸Š î,Ö7BHK— Ôg”Ý´øzErŽ#óQÓ{';Y&èë³@ÐD̲Dªj[7´xœ½ÈÑ.¼b0d;Ú6B-ÿǃgbÚÅ !nwÇÇ}á2±JIâuyiuÔ‚ÑÈÂÙ½7Ç©|ó DãQ§JzìhY`Hí»²;5Û˜ß(œLÏUl+¯ ‹Rªñè°øT}Pê?hnÚ{`þè€�™&š›lZaBw™ùfh´UºotjS—2÷äsë´Ùj?mÞz½@w‰çÊ_î»_-æÏoÅc'cV®dj¹‰n±ÊÒ‰©+¹þé¬AïC_´Û9~õ½fºkªGqá× ’±¶žN!@bµ°õÚõÏ”°du¥@4`âÙ×FK‘ "úØíÁµ½¦Þî4ûdOg؇©OißQÀ;¸áõj»§Oh/|lú‚#àìp1O­‹Þ*MWLÁího¸%MUŽL Ÿÿ€uË¢›Æö’ñií‘‚<VÍæ0uÏ–›z–Ý9ÒüÊHŽšàîþ§KzšûŽòP™mh¾î»¡Ý ‡Ø ËŠhø<až|…™}Z'TöÔbé Q œ_UYú[q…<æª!høçÔÕ¡åqÐ1àO(’æ}²¤Ìny}›Iµÿ#ý¤N1ÀÈ+®{è IÓù°=¡-ø©M†ÕXRþƘUå5èÙ¢•ó7£¶´¨,_<bäËDO#´UY*ˈÛ8Üõå¡kÝ\þnѦ á1¸± 5tT‡ê$pncrî%^(–¡¿ìMÂwDb©îY@Ø: ²fmR™T9ÓÙ:\­ê#›Í/ymïÓ…ÆôèØÑûw® ‘g¥RÆN+:†´Ë‰ Ì¬ç?x>Ê|l xm,§¸+:uvÃÐçˇæ Íaƒn 즧å7õx®kŸÒ¤¡Ia¦ìñhÌ°Ú,ƒº7 G{ñÔ#ªôÒû‚«ÏŠ¹ŸN ‘«déúðé¯|û¢’Ü-/À ‚yäÁµv~ ø§ýÑhÉvôͼµ¯T8Ž;®M¬NCy†%·þ†*ˆæð~X„–R 浘&Šî¸K'© ŠÆòê‹2ÂMí¡ÎxòÌžð*ö ÌW±¯F ™Â© TÞÚa ;$RÊ·}럋ç•/ÝL÷dÿAq"í¬àLˆ töê‘;ëÉ€s< MS±­éù *yV•KÏK•Ì¿§œû÷b¢l¸0Ë8ˆd˜û±ãƒÞ¢=ñ&/õÚÜÒò•XÜL |öÞðŒÂY?Ù0*ºŸÿNÐäþw_·~bÖ•¤Wßâ¤.rF£ßÏOB›{P´õYlý,_äb-‹2ôåmy¸#©ÉšMÔ8ƒè&õ¦x×·(¦¬):7”ÒÙÉ.[à»QuÔÕ/éeTL꡸yrøFã{ë©ZžŽTšóYYœ%â÷²|±PÇÊ7|¤{Á²ZÝT>VtÖŸ;UÒº‚½Ž(ËÂØËÿQ°ô¹'åtúàËÅÊŒ¾ïfÔâ»GZ"Öÿ*” –•‡µu7¥2œv« Þ{ªš/6ìá}ç¾Q8òíÑEú#bž¦íåôpÿm(¾¥™%©´„ÚâGÊ<V18‚;]–½úª•›œ¨ÑÏôQÙøíaÚ›ÃƯŽ)vÍÛöeoóÝSCT jj�!-|ºÓƪ5P·xÙHÀ`IEóU#ò­ï|ðPfÒôû²Ï‹EÇ�}Û^Î/ý1³nuÔ7G«—œKáa­•{J? ]Ç@t›EB(Y,MåR?öërÇAe=D¬Zí&Çb„ýѶ{S§M_ï#:i·êiˆê+ýšCO‹¨lE ¶º$è”i$Ò[,¾{ì®Uf®cÂýjn¸WŸÚ2a8 {ƒçõ çžg\¦µ?ѹ[aûip,V)pšôi5kÏÂÞ¿±\T¡Cî• H dµÖÊÎG@N<^0Yºtþ¦Ãê Ž`Cw˜_iÑh±1ÞõÀ‘VÐÆ*I…ìjä‹%qa:(¥Ö;ÑT¸Í®O O1‰™Iã†w4~š»óæÃ@,ð°ùR÷³ÇÙ¢äB¹¹JªE eùIª¿-û+4„O«­Ù ÀyžÃyº²"·“ {Ÿ<ÏôæPÏJvbÝ®ws›Ö"SûX9o½Žó"ód?"E*(o</©€G¹ïÂIy…’™OÖ»ì=ƒÎkTCÄmØS‹ÏÇÝ^àÓÍ_$„×ÙaéÁ8n²¡t1)M+e5'åa˜Cò¿p•ŽâÄ¢ìð;ˠǼì¸V c„Zê,‚¿ërR8]iT¸{Vçï{f©ŸVÉ›¸yl"à#ûꋈ*¢`5C™â¨4< ºéƒ»ÚñëýÄìŠ÷�¤˜gšû–fÈÁ™ÙÕl< ¹½• ½Åèú5ËËÚZ M˜ž,»¥­€õÛ¸½ìÇW»ëd{š96|h?Æ—?.i×d  ‰ |=þ¬qê‹úSMÑA~PùÄ”ýœ�<ýg9õôõ†"xeDk*sÇ{4aœhz‘1ŸÔKà»D5Æ¥Ö† æ9Õ4: :•´®àKNojx2Jw#§­±¸pPq¡Œ¬Fà'O#ŠVë§QPˆ÷ ¨¶5­¾ êò©ý6`Ÿ¹%e‰EvÚô *rӑ؈Ll1‡©m%¥¢4ù&\,rã쇄ƈŸI·c"€4³©¦‘…Ó<hÛG7ϬBè]ý�àF¾m°pÇúŽ¢õ»ÓÁ§¥§ð '£ôø*ü§Š\ˆåaq“Y§3­ÐŸ»Y?¾×4# ‹l8,Èy£Ü.ô$Øòš%´eSÒÃëÿ¦,®rºáã­¡L©¬íòÁh½í�’µyäKC—®™À�–Õ–žè¬í>`o7ã(K½9׸)Ç |þ_¨ ÷¼~™¯Öô -ÔÚM(lBÑ©º=Ð{ò H�Â`ŸPJ: G…ì½*[@$^¶%q²­ÒçÍèM*† Iøa�ˆAGX¸ÏžUsk ÖÝLÎNÊkùy*’oÀÛÉã¹V—´b#–GßÁnd<z * þt"k)ÏkYqVÀ2Ì?KÜÔë¼Ä8ºÏY~kÜÇ=¥[õÍëž©PL‘µvF:PSžjåþcs2”†àE§Òêλ’©ïl¾å®‘al‘)®fmë©~,`T˜°êFj ƒÿ­C5»CøØ¡üïxˆ¡ÖþD³j:,èý0I­l^”Ð0ô™@ô¡Ç=˜[£vÑ}ÙõT2Ê ©èxI4·nyG.V𖦣<îUð°šë¯]=(!fÚÎHË®;O/ [;—84=Þ¶+¨¨µ"§E`á uí?dTÔ�.~•yÒT9‡7ZÙS”–èÏŠ¦Tø~\à‹dáéüÌ´ññã ”¿÷½iU{îÄ r”*È?³½®Ç71<–{e¿7®mgÝ?HZ\ÑS˜ĸI¡ ­}©‚åÂÇš‚©Jh{š–¯ Q®Vó… „ãÒÆî…hi;Ëg>¼Ï¼«;ºáU�i¨ãËßP±6k×íëé`ÏŸ'òm…'{ÁÉ\8f«6¨”S:Üò¿ô/íiðÚ¹VøsGz¨MKù~b}tÕø`C»| &éÙH >çc¦„¢ÑÏŽ´Þ‰#š›M•j³L—¹xMlȉ0 ð™N=…åOº±RÍnhMaoKe`û‡æua”ù”°’ŽzËþâü΋JeŒ~1¹ÂŠô;X*âr�i´2øð¾¤ÜÜ$Üåë/Wf7 %Avü4·»íf(Y,<¶Šà$ÛØÿB-sžîØóZP<äõg*ZêÉkbn¬%àë¾ô”§‰^ëòX¦í¿ äû·¿ìjF'‰³žÃƒÈ <—Õ{ç= £¥ä W=Öœ«2ßþ&ÎkZÿiÓ¹ÑjïÉ°OPl6G`«ªžD2<ÀÒÐiŸ.¶«ÚJÖÈ'5(/èÛ‹W¥¡ËÒ´6Cƒ³X­².°¼“)b:¥³54Õ¹`"Ö‰ò…ÂÚ/£%æÛª¤ÀtÒR™3/å¢J¨/0j׈5ߨO—óÄ^¸*d ø0þJvíwFsàæÕõºÉ¼ù\GO«3iô€o„™xÛõ²Šœ!wÏû8Ù‚o¦Áp®‚b8zíR`€\KvÞQh[R˜€\ÔõøpÚ×g£|#R²$×j¤ßcwSŠ-&ªok*‹(¹B…Y$¿ð–ðqU‚ð8eÖ.Œ¡¥;î'ìY(§£ŠŒLÂÃäŠk/]be|ev![)ÝŸµgy"Jjµú¥ c^‰Ðx3Î'©cŠrDkò‚¤ªÀða¥)¦ûµ§ˆŠæ‚E [Üÿ8ho”˜á|šaç:«øV„§ÚsÐó=ñŸ9)ŽœQÚO¿WóêÂDZõv¤Ýûç¨hMèrµ�uˆ¨ŸØ÷˜mawÊ2Ò »i»E?ÖÂ-ÔªpÜV”Š*�\VžãðØïùÏÚŒ«¨½¸Ñªv´ÆDõ–Y×Ý q¸ÝH4¦íÿöЭʅ9,�¢1§ÒÉÉŸLÌU»z ÿ.aË]XOÔȇ˜Ó1´e¥'íLg™0Ú$^j Ø¢ûvÖ—òƉKˆcDàÝ1 ÊîõEŠ�‡°¾Pj6ve¬ÊLÎYƒêñXæc눜¬n&êô6ü}n]Æ–»ýÆö=Ϻ‚%Ó„{k¶£M †¿.Kݳ'—ò/;Ê.ÑS¢$,åŽJ¾‰2™13'{‘c?_8ÏóÔêO •ƒÛÚñÛÑ–à0n´h.�"ËW§Ë{£]znlÀËС_Õæ:ƒÌocL®M–áµSn_Þî»D‰/ €ý2æž5Ë\ôoe0³ YÝ{¾¯5y&“FûŒçÝÊ ³w&.¨ùùM!r¿ïf¾­p(Óý|Û©E4V!'^jGé€_Sùgóý2ó'›7îéö¿Nðžsâ<è6<ä—/UÁòå†SnõÍ© *‹ c:0zMžµTö h›_9é`2›ÕUéBŠ¥Vgªý>ƒÀÓ°©Á— èŠ+NÌ70X…VZîí&‹Ê!AY¯ã<PE<œTÚ>´º oÒ­uÃ_yÀb±v–¬AN™$8ý)–§©»Är ]'>O[î©òåo´d¢Ä'±‡ »¼¦VúENTÑ2ü_nÝ«^®Yå¼£QïC0‹%bB3¹lÒ2Z1eCž„\PÒ9P¡Ózg^û$p€ºÐ¹Ìûoü~¬¥¹bæÊ}=ÅGŠ®¿¿Ïä²ü%ÑF®@¹ ¢VyÈyÎÖÙêIÝDºñ³ë_T”.ÁOyèRËéâõ(#D‰Ï:í]»‘ÒÁ¼Þm¯eÙUŸwÕäA|VædrðŽ¶¿Lg»Þü¬—+4ÂpÕ·Ea¸Eb\1l ÆúéÝÎ$ 2¡“®Ý«üƒrq„•AÓR.Øù%É|a—°M–{‚aéó•(tž¿h-iÓ¡ äd°Ãß[)žië@6[à‘·ê“&Œ¯üÿ¼id-‚u7hó+ß™¾e8‡½¸IÆŠ£Ì°§*ã†;@`;gõ¾ÈÈà]{ævƒÈÝPyv $àoD¼¬¥b¨ºÕ«mZÒQ¡üð³€f6by˜€¾�†©J—cÝ_½,jÆÂïkG¬Hv.ƒªÕ..{Dá14µ£Bw°PÙVû¥êÌѧþÆ·ªÊ|Ñr&\æyñxÞlëHwŒÚ¿Ýûeå J¨ÖŸõ`ç½Ïýý‹^Òݲ˜ÛÌØhæýøSïð™œ�iÝ°á|f­_‚ï„€l¡€ÃB.†„ª2ø7ÝÈr™= $U¢áÒÍÌGRŸ'à{—¶eÆ¢š‘ Õñì47(~éÔh'd'Æ“#Æ܇„xm$tð%”N½Ïžî=E¯õ’èoýÚ RA³+åw8¬¨ŸÎfWrà $æãÎòèxºÌF`êĬ-cà‹¤Ù·=âå™™ç†Ãoþ\K3\#æ$Iæ#ÏrøA”AQ[ =°é&Ã×ùí¼í:1ô¹Gá×y£ÑÿgH'Åó~t¤)Þ¤n¬ŠÛÂmôW0ª¶Š{EE>ªæ­)ºô;Ô¬J;•TkéÒ¾w}† .Uô},ÎÙ¾gÉÛ¿o(hÏc÷AžLx¶‡i¾àoÒŸÿx¼°WšŠ¶væèYþ}ðM±Ì¦›þB·‡¼¢Dø|«}”vµ§"ý"À ËGÞGŸ ‰Õ%'ª™÷õÒ 3CÙ(5ù7Bdöýíá[h…¸tø¯ƒ¤J£Øpê‹ZÁ`kÖ$Hø‘Ì«X*ý’ÇÓšBŠTû¡ÔC¦ÈkÙÝ"Y´áyÚõ÷Á£iåy¬qc®½D0#^T,Öí`w{awg)#A¯ìRØÞÀNTCdí.Æ‚Üì©‘æÐÒ“œiêúærÓ[3öC%,sÝÑó¿¤ÈG™Ó¾žT#Ž¡øW/?Œr¼yEÁX¤½Ûµÿ¾}Ý*ø”žn‡ˆÍF‚Vr8*L·‰V%`FšNc]¯îä1ÈÍ@,(‡Vå°[^ˆÂÆmR9¾Ó¸W6튢£i½-OSöLñ׊±@øOªf�üx½këÁ‚õÃÔü}gýÚrãœG¶ Ë.X0—n¹ùô±|ûòN©PùZ`À¥6ÅÉN•§bŽÎ¬£p²ÓÈP`}]râs§c%ÚbÌÀM»ÙsµB±ý}Ömå2tö$mzúË[m:á/§¢Ÿˆ[îËíîRûg&óénæ߶Üå¼Ë,‡ßÜF몱w–²‹Î/ÓTšQЪ±ËRÕ�˜›ç}å —Åò¦™(¤†Û­-«#&5ñ�â ”?µNáÆñ_bˆójáBÙ£s„Ãɶ*5k\TüqÙ²|U¸-*}YÁ€%¥ª'׋ê “¨Z¬­Î·±ž:(‘@ß|#£—Û"álze 1ƒ¬ºdAù©v*°À£àîã4N³Éz Þs?´(AÅ76-½ÖŽ«= 2:‚VË(öÉ œ½ kœ[YaÁÙ¢EGïŸ[]ãÌzÍØÙ1w·X+H4†ƒf»5eäº~lz~`õšoGÌÇ6ëܾ‰� U÷ú˜>‡ B-Ú3è#ÛÖ­�¢ýh0Ýý{Õ6ÀÕ»©NÐÖ¦8ÿþÇcbø *Ö&Ê6ç_ÊØšrÇjû*È›V=Þ,g‘Y˜\ì<ÆÜDèA4ã`þ,‚t«'ÊtÂMàÛÌJ»½©ˆ¿�3'³YÕ§Óƒz?YQŽÒ3àŠ�è™?i%NªÄ܃j¶b¥&£råˆÿ£h—Éï0R‘uñ_¯”lJëÖ!öh°h³ZYf1ÃIñ~ÊÄ6(n;½­iÉ"[{}T'±(ÿ€–שöÂ9ý ,‡*PˆD ]|”A:×^¬5ËœSÚ!Io{¯<w˜ç÷f¾ùò™§@ZçAÕX4n(žó ûÇÉÛß‚Y?�\û^c©©o¥U’3NC*†â4VÖ‰åäT#ä·Ui¡z¥ÚNéKÞZ¥*ÌlÇË´;l¬]nÓœ™èæ]Ñþé†úô¶9c:¹ü!+óåB R¨«ÏWÜSÊõÖmú3$õyg í£‹PõP%Óeí͹®‚Ä8xùö—•Õ¬ ç©{f¶¼©o¥¸F ,cÈ|RenQIÙ² VøSÈFUdK*ˆ?†ßjŒ|Mibòöºä£oxÇy7@ùSabäü»(qXCÍ’ÙÐö|¥à€n¥áYµðN˜:§¿³o¤2ôÓñ¨x´$uÆ=é—b™$åÁ¼Nƒääù"uý×ÎeætK·bhúP¡OÁT_PW¹]Ïì ÛÀª/©O¦}†ýRËÏŒ2~-FEñÂ唲å-E™rÛyYïmz«Ÿ1½HYå¡_‘|ÇW"€ýD°< Lš“�ßÆñ¡¶ U¡‘¸j/g€6ë £tÞYݘzÃ3@O}(ˆ¿¥Ö™¦™•G&Ê@.[³˜9Š†™%ád â{.Ýÿæ‘Sžû¹&HSŠŠ:G5ÈhZW²M{i$ãa–ܯÇqìu¿Xƒcµ§`P}ÛõÆ"Øœ”«2Š€™/°|ļӰSá›ÂÀcÎ5·›Ùäm2e£êÙèŸÏ"k¢Ê¾ÆiäB #ŽLí´3å³í'ǯ?RÖ#qð·ØÑÌ'|#ó¯©h¬jíR%O ñ·¾�Þ•DѾþè¸ð_¸Õ ñ0e‹J©ÓC<I¸œµBrÿ]ÿ(ÊÒØzUŒ:¬‘3ÌGÓ}FjÛú·%ÆåmµƒÑÝzqé­Ç=œ5:›€.¿þùÁ!Ýôô4jm¤¦Œn[_”ßÖt·/mÀqq£((©z »ÉwJrF<,y"'5."“ÓL´ùã­VþìïÐÇQùwÈ·b®<8üù@e§'GúêˆÀºzņM> yP¼kô+ÐÅïÐÑ e’!}c"ÎÕ+pÀÙ“”vWñ6-æ±&±“ÄÔSfr €nB ŒG&öꆅ¦®F;0 † ã‰í›&Ó‰h†áRÃ5ŠÑ¥Â¼V^8†Òù>^Ù8#Ýr‹d|[ÄÝè!AâÇuøã_<ÚOºt%¶œdë“^Ë™€ÀÑ8⬆{X»ÓîélqE5£½œE«²8‡úƒù~†2ÂÛú‚q÷*Xuë¡Û®Ín9ð&yº¹ÑåYCôU…-8ðdaâ8â9Ü€W²Hè„„_†#æO‡~·=ÝÀrªRš¹À<%T.{Ôíf¬=!ei¶Lñâzð]D'z䣡Aª=DtÇf¿Ïv<\E'EàÇŽ2C“®étz„‚JSÇ" Ye’SëN»,õå s’ú*/aCbJ¼ ù/jÆ3+þŒ5œN •z™©i3¥T¼ ƒ©e ,#ä¿1‘quoâlS¿g<O+Í%$gx¡è È�Ú³�c®'�{“Žoåå-ÅLgPPša Sn& Z¥H‡èüŽCš{Âl["ŽÍ'Õ^Ø×dO2½øÏ[\…A}DK8È[QÜ¿pr¶L>Êa»0$T÷4¶½šcJÖuM­ØÀùÿ¬Z®å†ÝøÙ–1œ›kÉ[¦+ÓƒE«uï Tm»ón¶z^õ$Tô[ݵ˜q°„ßøÉr]öšITÙc+kËþ~k:ºô¿ØõÒ¼uåÇ*Ë@|7Úå…%Eb‚v¶BÈ:öý˜äV:Ýx1¹<¢>Ì…âÒÊ” ÁEÄ‘[dúè(š¦‡ŽžQš.䑬}«eÆâ «ÕI"*ŽÉpZþJ×Ñ%”(¾£›Ö̉й§,úK[z¯ÙŒú6hÌþä(ë(F±±Ø¨UáÄ/Úåw¾†Ù1ÞÀ¶Ÿ|¤ íú3­³n—â}ΣepMëáJ)Æó}÷Tk;zˆ˜X@ñpöÎ ‘½wuxbøWþè;‚{€/8‹‚µk=Ùô÷(ÝP�cØžU3—Ö+Àõî„ÔRŠ DÙžÝ8¡¡ÓÆ &ŒÉ„XûN‹ø:c |1dÉ”Ì<™ªRLPÀåjÎî uçµM~‘ øb£¬'ß×”-¿-�ÇÃúœ†s~Å›¾u¥à£Ø—M…Ü &~ɶQø…áÑÊ‹§T=M5‘3ÿ›3RÇáúÛT¦ÄÕZ.TÕ¢·”ÓžRiËe§Yà‘<-)wPß.WEæqÙéH:|ÓsˆlInñ¯P~šéöÛ ÕÙbÝ,qw¸ÑKK‡ífErÁ Ù&G¦{ì;Fjš£à%”¥ÔÈxº@ªD,„;=ñŒçÞ¢<OÁ#‚¢Z¶AÔ³ <^L º¥$„{V”;ìæmu|qbŠ"õ »h¡KÀftÃÈŠ`ï<Bö¼µšðAèô÷3µãžrcžù“èÝÑ4ódS1ˆUX…]ÈyûõŽ®®M‰ÂØôgHxdŸ”PGÇSo\gL³ê2\ØàÔùÚ½¤œ-À¥Ä ~‡ý´ï\]òÔ pá è«!2€~GÚZ °>w{ýC~÷ÞI”Ùü7TuLy-�ã Sò l꽧;ÚS‰=´îâ º!ŠÔ¶¡4>°«Ú·‘ŠJ ´vç‰^=ŒVn]ØŽOæõS©>*E°*””„N”�zZt ‰²•ÝÀ¼IÝLYTd®{RjCsÖî,¢‹û€v(†k/£´ãÜ+ù8G8vIʶÄ6|-œy׋ˆý3UÅ«îïZ •Ç%7ñ ZÃŽ6]™Lî´Až®êa8€‘M)ôO¾s”ånª17ª‚ÄÒçñôðp%WŒ0iv= _´ÐË|/ ƒm[¥u,^ö>ñ„Þ€êqÎ48Ÿ½‹pWŸ—ÏkÎì™ `å†æ×ã^V­ÓK™Î%Ô׈ðí{½÷Dû8™ahlzúóÊ“’s±òÅô�zªt¾͹;Ÿß¿üÙôK<Ñv¦í·�Kæï­×œ£3"ÃèÀ?"¾\ŸVL °›5Cr X¶€|Ò;³(XvÔ“Æ,€©._¿¹)E¼0åĈ!k>D•+Ér˜5¡£©/\ 'Ð<)û=cO"Td/›hf«kiÞnÑG?”$î£8,ÂPÀÒQÅpòâøÇkŽ}–Ë&O`½®‡*/ Í`ªÁnkÏV€{Z[Éo ú‘¬èŃ¾ÜsBñ†©¹¹]#eÁ½¬­TßBîf.S÷•]""1}ê­ÄD…L¡ŽÎêtõÕXV¡Æ´¡;?ö¬‰JccÅ"˜óÆAñá©ÆD PK_ÀL“0öq·‘¤º‹àó´\íñJªW«#A?b:Gp·ÿcÒöãx˜Ž”v©®¦2§ «Z<ŠyÃ{4ò¨\xÃQÐY¿WZ8?´®±—œ‡4·‘×iÞFʳ…!hœ1RßÇ(ëtò¹kÒé ½N 4£�ÀC*–`è‘f,‰(±ïÒ a¶¦ Â÷I©©Ä„ ×d˪¾&Nù…>x{mdátÉ#ƒÍØmhõ½Ÿ=ÂÇWµS˜çÞ0Iœ…Ë[2õàœkûx+tå8=—îÆeïÈÚ£WßÙQŠÅ´x?®hZ–➘ì¢É‚â4x ™÷zuh.¦Ûµ›¦@ðKýÀT¾Â GÌ€|cM¡>:ÁÑI ÁoÁú„ÿÅ°<\È8Q`è©BJÞ'ÓbO$qÓb¹Ø™ ¼KàVý1Î"åì/!×ßHŒÈþ ˜ZÜ)a N‚Ó°2Ê€}\Ö(%‡…Ë<÷‰þI‹l©K:ŒUu'ÇÖG:‚›%w§«'¿d²$ö%Sæ˜xhöQJá%TE²L¦‡NF×)�L3¸å´¿n*•Ç‰k‡E¬:îË ŽžíØ ÖRjû+bJ?+<,ù êé}[Õ·ë”JùŸ7›„ÊØ äÖ‹oT‰ 2;e§§ œMh§Ž"¡n_}DÌj»;åCýЛê̱WO pês*3z…†ðoø Ôl'fÃÒKáùÃó£éî‰e©Êtø~{ zcZV3ç›·Ô$?OèŠNž`©TûÂ3q!NVyë-ZÀ$‡G' …ké+ñX5„c Ò ß¨ý]%¹:BŒ¸vÇéäX……~/=&ïÒ¶›’Ì÷¨¤Ê »ð}kŤ†½ÕÆjbÈJIp’sºþ/ºü¦ÙÌ`(n$Ö³ŽîÔ…žƒ‘c£;‚zýªm06I¹u ÎûÎ]Õt^6 N"_U j[D¸V¸2ñ €3Kpi…YGÌǺΣ·H“|á3M‰ù�éRµnA÷æ&šu®~bà^Æ™FL®äwÇ”ýÄy íR4@ùN\ ˆü‰’B¬ ¬ÎÉúByÙ¨ ‡*´¢§'p<œP¤þÛwÿ®/”y3Çç*cðçm<(‚}}uVÌU àS·y©Ô}YCòmK1k²w@n:áÛ÷c<’„ž< ¨ðwøÔÓ½aë‡ÿ+‡$_0€< Qd'Üš2b¬üIä§ÊÈjvæf*ÉPœªi<Ϻ/UÑû/q8¶“XšYáN<sïÉYpäc‘¸ ø"Øw˜—»Š69èf™![™&óhâ¢ïÖÈZ©ªÕk¦áÂãV sFÁêÛ“>ë»Ú˜‡¹¹å½&@Ç‹… s%x̪3Ú·X´!’da¥|¬E{J¹‹/Ò }Î.ÌL+Ûo3Wƒ…øû ‰ÝàŒ¿ž3ÓìhVüc£¸V®ux^äÆCú;ª:þ‚ØZž¸ê‡ÁµL¬íŽMHÆãëú6Iæ 6Á8å?õ£×ݦÁìÃÙc»=v<L²Ó~¨v‡Ç³ûÈM}1ÒÔL¥›øÜ^a€Y·§ñ*Œ»,[%â‘œe§O…dBIh'4†ÞKÊ«nþp¦êº>ºêÃÈÕðàa×úú·O ™ ¥?‡º]>Ä©!¶�*dÓ¾3}ƒ²Œ§6ü=3º)ÝüÖÈwMtZkG÷BßÁrG¨héï.«í"+qÅ5+‰Püë{ú’^´¸. |}CÙæeÏóÂq[Sà†ÝÌÐàMÍ«ækÞ7èÝ'™§ü€ÁÀ˜qc_Òÿ6iëyÜÊ·<ÛªÜoP#Sï «iTŒ±²8ºÚŦMÝy7ÝÌÿ³"ól ÌiûöÇwEqõ‰ï­|jÛ™éÁßÐÓå²îyJ[œ-S„è¾éÄ´ž<JEù5œ<[¦;tu÷-S“&ûv·Q\]Ióì;ªåggfìR`LƒLÚ‘MM;N„ :£•§Jl±‡D`°ðÔ!‘œÿ¸Á5#÷pÐ_ËÂ<Ïow¦>=óð ½×¸uS–ÚÐÖ¿í’òöó’½9D¸2v(=!ZŽ…7Òˆ…—cæ_bDu8S[mUëI^—ª‰Q„Èš-îÍv£o \SÍ2,š³Ž—iŠ/¾±Ò,QQ„KÑ·Õžö‰Ý10õ¾«^Ý’ãFõaÇÒ±¼+ܦ#6ƒ—ú'íiØ1mb=OÿySä\à<ÜüÕ<ù‰uá†,ÌzX(MÞX©øJš‹õÊ™0>šGiêR.úxÏ <ÿðLµqù`‡,ia.ò#ñ»ªIoÆz¿'Ö~†Uòø÷gâV†ó'ßáÚº9¦fǸeq§î¸N2*ïãÇÈ1¨8¥áhGd8fúº½0È^›¯´ÏÒþ30àå··­43g!‚©´ë³ ;Ztd±â2|Íz7÷NB¯§ËݧfJèÄìT`"9ÇÝ„£t·8eèF‘&ÿ+¢j­“›mj ð‰ØÓ¶‡¥ûÿÂõHCˆnR–ÑöIPl¢ˆÅs<ìƒk‰Š+T†Ýum=jGþö%º@J)<>ÓA3‹šÏ®Ø1¢V@'3Ý3ô†Ï与S¤•ªÌ”ÊšþüÑJF-Æ ¿o.醕¹ %§&ÊAûű ÈFÏÝ3 }wŒ!œØmb˜ Ù¢AñQX+‰|C5»!y=åÄñ²K0øæÛÄØÃØÐz>C2šYhø~FZãu]M(I[0=«R2赜ŽÊù­¸ìë;%@Ñ'%¯B[#!$)ûBÌY }Y± ªÉàÕLâQÜè¹vW[XÃÂӟͬÑWò‡óáKª™ÿ%•ïÃY7:Ô&‹Q\ÙiŒBSO¼Y~ãð—/œh׿`¤é,¾`µPf„jj?~úƒ„ä;þ¨Pq€ØHæ­qP¬UŽ]ƒñ€éôÚQš$:Éb?À‹l³¶DV+ûæòfL½å;Z8fKÝÇʦ‘G1—Iáa[û,JxÌœ Ð6Ïi¥3 úê•'ö™OIf#:"ÆwGŸlê’0'54–š}½;øά¹TatÔ¤EºUS/ôj†3tgÚòÀî4J}wn»ë2H§AuKâÀùÈ:U=,"óbŒÌ‹GÆäÙCŸ6´óúèŽÉ©ÞO9žZ5á}ÙeÆæW¡±=s³YÛ`¸Ói cXÊkçgöÜLí�<#†aˆD³'Òé|sêϲåeðÁ]ïë-]ô4öµ…L›8ȧw¯à6(9{†³ øë·®ÞXÛ˜Ósw吏(Vf†T´Ð.¼èŠ„jžå�Êz<LXxT¦ü¼Xlõ8ôN¸Ï3ãô¨¶ƒFÜ,pÆÒË›;û´_™ù…âxæ<·èiŒ:Ç‹Q $l¬¼Ñ ÃÑY&\rŒbò,»‰ÚØ-¿þ‰=È!O…JŠí·ªåäÏTôX Ö=ÀzÁt 2JÒº-ÍH‚ŸDÚj 3ÂFr²zÿÔüFœX³:V?~:Qé A#ÈÓr+‚xÛéÎNaÿ¸ëÏÌõÑ®m9ôw5îZ OZNIµp=¯Äs²ì´&.ÃÀXKjwÇøMÞ1žd•r“®1™ëVSxÈDÒÓl.Öâ¥"$ª2a”J 5bqÅ*H.“¤(ynéöiëÜéã9o<Úc´µŠ\¤•kÊ—H2);¯<×�¸a$ï}¬O½Ïrjj#ÍâM-Ééá4•·Ó gUZö 6 å; :Ö´ù`‡™¯@÷jwD*5÷î;‹Cœ™gÑò/Ŧ]Gn€ë!&¢Žœ!à3ë~F桵¬Zqp»sý$]¨ÓÒ ž¬ˆ[Xq HÛ~ ý¯LÍ£¼È<cØ)醗­æ—YภºöEy?kæœ/¢è¦¯?q&±ç—FTê íÙµJ‡ú¸SIÑ×  (ñ0ª¬]3Púè¼AÔy7ø@Æp¢=Á»ÍAǘlOóúyÂ8j­’á@„ÓâÛÔVØuɹ»vUKµê»/Þüaèq½rW¬œƒ²y·¶æÚÿêÔèNiì\>æ—%µâÊ©0\f€ükcq© äe†›‚÷=_3¼3ƒd_Ù结¢ç~ÅŽÖˆäUãA¬‚­ÓêjðÐv½YýíqX¬¨v§²\âæ*DDFäi߃5”a¼5‹i&”8z9ÒðEÓᲦ)ÞÕµpJš;t8§vôÁ‡wÏRq…€Ðî”ÌùªÒæ+ê›yêžsÊxÉM¤ß'ã ßS‹vƒ˜<wT9Š ¾ ߀´º÷c‰Ýý²2\ð‰Ñ¿BNk½>ʘk% nø/k‰“PÓßÀ-xÔ.ÇöTÓÑf5lÑÕ_0æ è�¼ô¬¥æû|"/C4»í%[’˜ÀœXk´VºY ˜fç‰)Ü•¿JJëú±}ª†z‚Ž#¹Ä–)Z]ýæ„Håè WÀIÛrxŠüH z4FðÜò¼ýMÐíæ;1c4z“Oís/<ˆ^Ó†ŽËj::_ŠÔ²$d»y†ÅλŸyW?ËžT'>†è�Ë#Ø"¯-îîê=“’xv¦R¼“Ÿc\Â…0ÃÛoŒ©|¥LU«3D ºÕ¨Yé7œÞ fó¼ÚM r#ÜÐLtÛÒZ[YG:-¦Ó¤üçÌŒ8“ <ÖRû÷¦ÀQê]™;ÇÒ±q¯H,èŠÐ³ï1RamÁ ¥ÍÛgâ>e‘yjÉ”ÉÏEP}*2h­!óEyfÝ!.íY¯¶&·_fÅ‚j-PÛ-æ齧—JgæV¦S³¢º³›gz= óåÍp –ßÑ‚*ÂC¨hC³Æpœ@:Í1)÷¹¸ÜÍÚ7*2_Ÿ&„æ %”Íôfjzä׺øb“Â-‚ìÎÎuœêT;73£óˆ_ÔzÀkž6˃Ø3{Ó›WiËÜp|O iúü¬ˆNžá;ÝT¯E¥îäw…°5›qOSásD–e…I…̯ƒ*<üJØ?W †TÁpF*|òAŽ—Îj¾ff[d^É_õ «Ý»$xv%Î2RTBÖšª¾=Á]è|Tùðnxì¶:f)à••q5ñ4î삶EwÞXsÝúÙ V„¾6œIÌ@Ž¬Åd…@¸Ï HŽq·‚Z=íúáiu…Vç y8{Ïsxî&ñÈXæ“Ÿ&ÇiîÀعh.f %–kWHБģ<39¦hC¿lIJ÷HÀ·•3W¦‹KÛ¢¬ßòÀ(ÙÎŽëü;s”8K¯4¢¹Ø ×­Nn�"ª1VsDZ^Ü“¦Ü‹u—Â`¸¹ŒãhµÎÓ q¢M)–Ûº³žmTÔÕÂð‘W„.¥?oúzA¶¸ýS*)ç%K¶Ú,ز¹bŒRþþeÕ’¢Z¨¦A;WA>m0æÌëRë Óx«Z·À £ë1˜SûÚ€%Ê<ÿ¦ˆ§Ä ¤™'Ï–¨;…ý› ŒwØqîK¤Ç0ȆØÍqír(6F¾ˆ=÷NN£†¹d‘¾È†v JK=^W†L¸½ÐFìtAZÌø.†ðþç-noµ˜ÙŽ>™yËâ›;À2«>5ŽÍËÊú±bš3í¾{�, fÁŸ˜ ÉÞîáYóÒïÀ¡¾G°´6ÖI.:DÈ„¬Üä,bi�äR€¼ñƒ™ráb”ö !ýTwµ.!‹ØyöýŠbß`Ý8èÙ:÷ºªi%àŒ½ø—å $W˜c8ÕV2SÉ®ˆ àGyâøDè4ñÐ9Š4=8d³©~a!^ÌÛò‰ \6×R/ôtc«ÂÏZ>Ø5°™vR�MÐY¿ JÌv©“‘gØ *ÞC'"$&ƒ1ž<»wœ£üOËà4+<6+ò™RÂÓZÅþCæd@#Ìú…pþ*JZ·|Õ^N)Ú¦uÆT•ó:~¡ó�13LÚuÙÌÒxâ—ûßx9ò¥”þr UXÕµëB°•“/˜…í²¥Ì}蟖GVk# ¢ãÅ/‡N3aÙK6âI”yèbµeeïKÁ>8ØŽõ¬Xé')R/azÆ1yÓ{¼XZØ|³Åó>NødŠ %|6iσ•|H¹°—{ÆÇ9í+*ttôõùÖ ¯ã0iW¾¤UOJ£ ˸ó5T0 „ðhe\;ôY' Qp9×Tö•BËÚC‹Rn ìL­ÊçÍKÁôš6Y°OP‘k&TÄÌ-Ù;">Ád\ïµXkv%1†WyŠ|:[ƘLþÄ�·_§´Çç‡Êrh=’}ݯ)¶¾êN™2ˆˆ™Ä‰Ñ²:õ®Ü2 •ÈªÌ^±b¯©Z•N[ZÄöš6îäu5õ·&tÐÒ“yº…¥ˆv E»Š&›Î„»\Zrþõ§oQ½Û/㟪T„~@7©û¦’Öšg éË þY-mœ#ºðBºvgªƒk$må|fø4 †±ôhf¨&7e¡Ú"hÇúâ“#YYvtTSŽÆ»ÿIKNýßÿôPnó`hj0Ýûæhå5+‚(«b¯uGz[§LLPÒײ8»Ú {KwVQ{<í¦~w´¯Ìy-H15˜ÇËiIÇúÛ6A4ó¾~]h[ÅÎ^D¤E>ôSgŽ ÃÊ‘NÄ_ª‡Z)„XÝ'† ýèEj†ü§/[tøkp#d¦I¸ìį¶ -·S#¤úèo³Ô®±jÈwý«¡4»/É‚ì]uôvò||R ˜Qüyq¥19 :Œh JL³ ÿVßà¾(!´  îú]åæ¬ibÓP¦¿€–ɱqqq^Ë^á¾üWDÞÌUôôÿËéìuãÎ[êêL]o]ý” Š36AO€’0JVß­?qˆŽ—£|˜Ç¥ ¥ªFNà:Ž&–¨®\›ß7GoIÿùþîèØߘCÍBö.¯»zÑ?ié=¢e\Ï?{[bH"6²¬ûÊ»@ÊÐ^>º –`™©qšGù1S‰QLÚ•¡OóyÂJTãúfd_bÑ–gÀ˜•N€–smD#Åk81¼È$*î´ôÑÐ,Ó7Rú~R5C ™ÖØFE]Õ=”¼ Î••N­Ÿ{ÊF¢ÏΩÜçÁ`ðï9î{©Æߧ06ã�þ4¥¥3žå”š¶µq§¼oã~ßÓÝ‚\M nì¿g÷éóM}׌ãdÙ*ÆÝ°ãõå{æ 2¥>„ÛFš±åЀ3(³"3ºé²êh)6TA¦eÀkMµ§}….PäZÑ<Ðç÷hmŸªZúdݦ{5—Ó<Շ̚c¥§«Ã:"_”ì eÑ&€N#Ž:fí~§Ù[ºIéQ¾¾7A|½ž<¨Ì‚tR÷o¢²ÐŽ‡áuV|î©2±vV WÅF‡}ÀW£¸ €!ïÅÒ%`=m•òóp<å8o¬»BS¶åðÒ¨…ØÓ(Eüʺp=<)]V3àD[C³OC«e€Œt‹¤1¶¯ÇÈ''b–ss­ ¿®‰¤†üpë´Â¬0ýHéëÄɧ,d\ï0óFÃn°ö8Ìð«EÃPWà#ƨuPã„+úð©µÂÚèHgÏ]~ÅÈaÂ;ª¤yl¾4ä•LdšÇÙ2õH©Bn/ž_"ÞÚ©¡?·ZŽR§‰(=^`8"+ÌÄõÀ«lYßody´PŠ¥·<ûÆÉLZ8ôÖüÓE"ÙÙ)å 9µHä=Ôeb^ë•ä¬Ì4l`[ˆ6z~«+X}QÞUÎצŠ¶žÞh_õÝ‚„9ièØ µÖoׯýVø‹T^z�´ÛA‡…ãIÛ“ÍhLƒgu:š¯Ðàéx¯\‘²,ØYä´Ë¾èƒ·šnA;˜}KÖPá¹²” ÂYÀ‰ÊôÐúE®è3+L`ö[4fÓ*y Œ²•W–Ðe¤ÙkYrÃê¯5Ãaߎ´IŒ —þ=/üQ˜/•ŒyÒá¤HûŠ•‰>žyîêóV¡ßx 9î¡MÄŒ§È¤u´­à O p¿à®v³…-ì[é#¶½Ã·+¸ÅP]%qŠT³“¶êã-s†d!¤æ!�÷Go®<×,A:±Œá‘eíänÓå7=� îiSÝÐÛM½–7Xò”‘P!ºý¾œütÚ;\„QÂé{åÚ§ â¾KˆÖ±u™ðÐs7½±]¹ÂjÊRÛÓj¾ë¿”/ÀÓ�ãÓúûœÔǃ1D~¥Qv.°NÉœ¡xÉ\­ñp2»ñ™qÊ ¾;\•< ÿkÅ-‡”’ÕçÁÀutÉ3-ÝP‘¿,L©‘ƒÁ&$â[6ŽÞXëØ_ö*ÓÄ6‡Ó©ÿ3³ÒáÓTSŠ™]”p ¯‹· ™%;_ÚGÁ>¿L§þÏ‹h©¡ Õö³BLY²Ã°ðyÆÌ‹ThÍŒI0nhÏZve86wÇV‘öׯÑ?¥—g‹ŒAWRqÒx.€ A¬ÃïJÛDiä‘•ûY'¨ìà3J•e'À+X¶˜F´ ¶«úÜß6µ‹¼t˜'<óg䵂!ƒ%6•ñ«wöļ†·©LS¬@¹‰{L“cïëóºöŠoú[×F_Ã]ýô©ñh ,¢Ï¡Ò WTCPuŸ¦†ûõk–CyîtéDsˆèóŸ: âOLÛ¬6LK‘äO7ÙWÊCNÏœâ—Í¢Ðt« Ë”¼+™ä° ÂâÅ» OqkI²«0<¤gd¥ÖJùaItæ2DgÁ¯Œï (µa êå°„ƒe”šØ}GovÈýÜ ‹ÝÕfFK±¦'®„Iû>ga.]ø?»<°>ͧý [óºŽá‹ÃHXÛ¹Ÿ¡,bUk£Ðt=µ]Ê€X*Ê]¼Fá‰ÃÔ5èr6+¤5š­ŠF|1Bl­×h¬LI#å™bP³ñÆ]¬»zø*ì7| ßÿ€…!Å‹õøÝ·ÄÒÁ‹½G(P/ÿ¶Ý¿}ýï:Û¶7~bP¥l±¼$“üà–”NÓHžÒ°¡]“^´Ïn½ NWòg¾&µÑ=, )†(e­£é°5½a~jv£m˜<Z–’CE¶Nl]<W‡Æ÷\{ÑŸÕ’8%8û¦=½ï¬Õ²òÔz V†³÷f´:Ò Õ«c}É‚tÛøŒ cJ¡Ã«EpXg¿?~ôSôÌòley¦ÍMÖý+涻+Û üìÃË.Ž¦w,j<ˆ5èyí+VÑò .ܽkª› á4Ñ hE@¸”k\“Mç¦õ zò=Œhý-Œ¼àÊÂ7ýXøFUé[ÅQðž×ŸUÄZÇ}ZrrÔ\»Hg&B¨÷Òì²r‘Šå®Á¢Ÿj²¸ïZœ•¿²ŠÊãZTK=DÑeÁ¯kqgü‚®Øj]¾Þ”O ßö�¶É@¬‡Ã§‡Xï[+ˆ` ·|T¾YªØi.$|†)Ù³¾ylïm!¸}ÔÝêc{`ã$ÿúx€÷°|õIvÚÐcI¹Þ˜Z´Xdxb<ÿ"Œ$I-ñDpïç)5þÞ‘ñX‡D Ÿî†]÷ú¥?^¯[ ±/?µé‘nE¯+ kÓi.oM‚"àâŽ>¤»èêIss« ÁÒ ű ÓwÛµ.“âÌÖiÆÌŸÏÄ}þPnDçó ë—±edçrôj~& ߇`ùÜSf¡à‰ªKr€-[tº ZâV ü v•äOQAzú´náY&5;Àwøì¢bÕ—Ÿ%ižU•Žî9u<±bW(ü_IO‘M¿u@,8²å워7U¥*nÃv´+³í$‘•±óÛ×¢·5èÍͧn†â>d]„ ßävŠqyÓuâÊ7*\ÜÖ)50m<³Â?ZÑFe**]»Þ^_ïxÍð\Lþm¬óAêÏõíÇòw¿D\R؆”A5+'!Ó¢s2ý­\½Šë«V!Eê7ND) [¦åŽóʸ¯ÿ˜Ý>(3†ŠA] ;8«q‚† å°Ò¾bÞ ô</}?? /,D2.Œ}Ÿ9i:üÿá3gΛ&Ã~i!îZCR6¼ýaŽaß}Qh6™K äxÉm=ö×#K¿½ÆYúo)Kqú}“EZä­jBg{7 ƒMÌ"éÉŠ$œNm@ ð?’Mà®l÷þ‘:ÏÞÚl¾4iDÊØÚt;ž˜ü¥û’m­–ž ¨ 9‡\©§cç”Z}—ö¥c{§~ÙA?Piqn=’.zƒB• d¿ëGõ¤»<³(\Agvw¤<d­1lͲ­rþ}tÏ⮥“éÑf¥ã1áUàÎhg”Ó¤AÞ}ú€µ‹f?Ö Ñ˜Çôã.ÃÂÂXdM)êtz-4ÑXÆWˆÅàŽ2í-­ÚÈD³`øt¡;Ù¡×Ì,Óc¨œt.rjy•íUÞÂçÊ£ï(@§ïï®b$.oñeß10c8‹D<û³¦vCæÀü¦£¯ ªcÁÙ´w€åÛ&™bÖ¢N3 Ǽ.ýbÞÿ៳\æ,#Õ„STb¹V†3W Tøñ’Ì÷õâþa;6G>I燅D$€Á×µ¡Ê¥õ%­”¿§½Ø¡û>M&ÊTAݶœ™è ïlÞ–ô‘èŸÒóIªpBN:}×YJš/´Ë•~‘Ñÿ@~Gœ¾Åë…iëV¯ ì�ç‚ø²õ¦ÔÓeU³s¯ÁBv“ª}¼ZSfIæ'¡#N£8é^„ŒµÞˆp’qô¬W+L˜,†)r,g·üÎ=kD:tiTõuƒýt‚½VÄ+ÐaìØÑwOm³tÁä£]0aÄ'EYB¼… ÍñÒšYß1£àlî>çdÜ…¼?á6IÐSœŽ¾·^B0ßžðóŽiœdˆÜý•#r�fHÉnôÉù€”±‚~çäu̸Kz®[Š)tÿ©nfÎ+„^/2ê8hë$(?-ì£b.D¤ëÚáhmøh@5u ˆ<I&‹Õ¨2ZV�‡AÙh›xÈI$N—|˜uýMƒhá¶rªÚ‹[B¢áýœåéÛëfâmˆJ�}äf,ųªZÁr =—Zéë’Ò=Fç m¼ƒo9n°»º’%+R£Á…¶ž¨%Á±=Q¤`™4 Dóé%1Bõ�·š0 öT%ß³3Qõ¬ßX¬ ˜Œœœ¾Þ†ÉÅNÁýÎ`ŸPÅÕLÞ,†Š¨%›²œþrŽÎ¯ª-è”Xz¶a4 U¢vÒQU¨±º¦ó =·[MºNq¸ð®¢“ìïÊt½u*LXÕÖŒE NLDÍÌÕ]ÞPU™ï‡Á\+ƒl²þaÉÇC§Þ8à=iè{šcÆ=LëR°½¨¶¾t ¶º5Z†ø1ß³æ>Њ¶õ¹uF.¨1ÿõè^\6Ý]৉Ê,Á|ÕÆuûî»vÆÉïkœ:þ]Ü ßü»dØ-TB5Œ¤¬¼?rÎb_¯Àâ0¿êD#$ñ.šxd¬‰7¶‹79_0âf¯î0•ùbÈZÓHÕÕûçnŽ>¸ƒXL¬4ÎgÙíËðç8óóHCQ@ õ8F<¡?=zwç)RÞzddœï-S(±*8U <d. D˜ÛÂz*gž¯k(w´6úw«Åküß|Ll%®¢:7Xþ5ì׸å&Ó-ðæ3�a8J ©jµ»(ðgúíðfâüßd!ɻѭ¨[Ì´^m!I—p Bm‡ú×Vcðá²ò&Eì Iõ¤=yôÕöôÑyèôBêV.HÃàšA4¡‘«Ã ·µiÚü¼°:™/s ,1¯ìKqÝ38ÛÝl²9[cìÉÉr ¯É‚v¦#¯U8 Kk¾gÏÓÄíÒbÿrOcÓ­><v¸M*“ß5„:oÕG½ŠZÖµz8½B±ÍãÌçæÀ.†âN³õÄDÙÎ à�vC›t5UlJó@«5“ˆù´–v"莜µ`ð¯oçišfž½Sþž?ÎHmâªæ²hî*˜¬g@Ðe¯*©·ÁìÖÇQ€Ftšt I´^›oǹûÆ6–Ƕ—ç*‡igž´@$’€Y­Û}6Žu‰.˜ª{µ mà}ôlõl§ùÿÞ/=R¨¢½D§(§írxf\¦pÒ}Á•q‘þ,fØàØœ| f]°†’ç{{nÀW©x•œeKžÊ‰GèNÆõZmSÆÐÐ Rº2Ï¡;P\~’DEÿä.퀜¿Ó÷Úã’p‚l'™¯8—©+ ™¥5ÍÐén.:®‡h¨hF˜™/ëd©Ö ·$/ÇaZJ`¿÷§~Þq++²%_ïÖô`×=Ù¶ž}ÄÚM‹œHeÕPŠÎŽ¶oc‡wˆ!7mEBžd²,¼¢mp¯×Â>à ¯“ì¿îì¦^¥P ¶$£³Èêà0’r]ئ´{ôñ•g­éÈêØÓaZlÌþp<Ö-‡à#o»¯ ‡5ñm;ËÜ}^A®¾èKÁ¹j¤Ú°3]Ðñ´i.‹¯WÓÛ„cwIŒþ½“[6Ö/1pÍŠÕ®ï¤:¿3´–eöˆƒ©¤Ê®ß¸öØ - Õз‡–ª­ú5Âz•-èõ¥Xb½ö$𶶸˜Þ56 žS?û}1+ÏðK$;ϱ±ÅdÐ1¦Æ}'UÁ –í]±ÿJ•Ù£+Ѷï'5Ë$ÛҀѵú +¿¢0LcLõ‘e‡`ßtµDmͱ~™»‹(>Îh°’2ëí–çKŸ­–þj”zsA.N[*¢òoß3q@ë›nÊ#ÎeLž¤_±À%ºÐ›Ï# "ß:7…“ðš’ͧR¯½¹{2ì¦` F Š²[»´ðfcl§ „«ŽßªÖ€:Šr½=ÑšÀÊÐ�uGÔ?¶.^<_¡ÄtÚSékÅ>+±‘ô<-–«{P«¼ð‘"ÒZ6y£9–OŽ¶ˆÈãô.ëž¹?‹o,Žê´ *Kû¡ƒ¼^ÝÜ Ôfþx’²H–Öî¹\5/wDâÌwÏ+ Zgß„žn R)ƒ—&½FÎu˳¦ù)™-Mܬ=aá[Ê‹ní…J7D·¶M¯‘.3Å0ß/Œ1R(ƒ´Q⨰FÅ×4‚˜ ý„¿xñ8™$ü¢‘Ñ;KŒ}¹À"P°o¶ô «Á*“°¶«p;Å+ñî¬/Õþ~$ ÇØè$Û ³lNÈ‚õá›O yËדã¤,Aejp†6Á> Ò‹ºqWAMyʼ±+…kÆÁÇ,¾Ð$ŒþÉrÇ)áðNŸ? ÊwEëƒCÖþºþv*Zaø×àGî%QòurßG pÛI§ýXãÚé郾�ܶƒhÁÕ /<ÒFµ:¬.1²M¤hGMõxÚãVìÄôìöa—¥JÒoÁŠÝ½ªĶ6ÖW³†ûBÝ…ÓK1Fmìÿö}´Ø#΋f ú(êP–Þ:MïúÁÙ>)¶ —¦Ó> Ò£ÕoÌ”4Ÿ``Ô_ÜîÖ—{"ˆ*Û±-Ý•Ý‘îq8´–¼YKôr»‘#%þ¹AìÁ0uaÜkÁ÷)Ïõ0Ȧ¢°Ú꽊Œ¸î·võV’ì~âÍÍ¿”~…@µ¦;Õ]YfËAú-ùöÛÛóMÝóçl¬3Â*Ú.fãÕ«m ·¨“JzÑ‚œŒZ~X˦[ÌÐ"óÜš�4Z§tŸ­»L 0èðwÕq%#k Ù=ôôgÊñü¶—ñm¾´ë]ÿä[€½J·dxXr„9ÎñäŒ {Ô½hü ¢"±‰ciÚæ5¦H–D  õ�6Þ­YýáXkìé.T¼‘è –ÝÚ3[•XâÑV(ÅãV¯¼Ü‚/VÞøw|C…kÑ;«U,²É ÎrÓˆG°!ÝÙ¡¥k[PEÿ¥/Öõlú¨•í|c6GÙ÷ÄJD’HìOâæ#ôqÚ–Ø¢PNÊÓ�šçÖƒ |VTþ¨à9è[î-:`ÐÜqxó‡[¹{|L5Ð$²›Q-=/ÛúÔ$MCß€Þ J>¥ut£ˆ.ÓvèÝÑ„}U2?¶J)F$–BKÊu†ëÙq¾cŒÑ-ÙúŽù™e†‚`)F·'VdëÌÜçKZˆn Ã¯Ú 99?áÀG’ÎVgŽÐBUwøÂ$ )©i¯36‡C—OÜÊ,r?rðÔÐ:Ê?'m–oÿ¾A”œ]wwƒ…  ’!»æu+—ñ *šË‰¬Ñ{Ñxˆ#åS‚+!�+]}ø„9èÕPûè äe­Ž¬pÛa/ Àw‡Á Aè矊Þ/ŒuÍŠŒeØ4æA5^<Bö²–ýëáOf>Z‘’.ö™]OÞ¨M+/SÁ<±™þ‰²Ø‡€@WŽ¥¦‡ÖñÎöü²Ö´ýUšÁAÆ/v6a¶%•Å_·àóµß˜‘ÞC_(¶�ðôµŽïhµ5XÒ[:î>˜n.S{0¿æ§NR¥‚ÓW|&3–n³œ~7‰P› •¯± ¢ÒÙ•ãìLÍí¶Ü»A+œÉ6a2ãâý·×5¿5 “®Ðñ>|S9½kµ©[N‰ }ÿx¸UݼL?.=›F!O ™ vªŒ¥Ó¢š¦Uªú6ߺºÓ˜ñ{šEÐ 1•§A»‹¢@m6°ê^ÜÑ¿ˆþ‰ã"ó˜ˌ»Œ$VÖšIäS»P”:ŒGµ¯²W÷•-Æ<4L’yUåh%L2fÉŽŒõüÇ_u|,m@œeèQï)a(Œèú¥oR¯õ$N¼ÚRØmÛz§,üѦ(ƒèh‰ã’! H*xP[ïe—=·¡Èò+-ù™‡¶[•MíÌ» ¡­qØ{±‘þ ܾı˜:ñûwçx`ã£ñ1íší„¬Û›�a/VÛ½O &AÊö :BgD }Nk,þ¯*o>: ÷ìÅHû¹.–+]¹ ¡%ƒ>M܃ҔiT^N�f)Ï_å»Ìz´SÑ[&A¹ë1’ƒªúô­ö¹?u B…zû¹ÒäY•¢ðæ˜aèæ’<(ZÐÁz‡>ÏM¤ª¥ÔŠ~Ÿ˜Õ¨¡7ƒ¿9¡}yõÓtÝ.9™8—TsªWL¦Þ Br™'ùm3bÕ«ûÈò(ý£>¤ÌacR ÜÇnØ Ó©7\¹ÄVÆÔi–e#5TÝ·,éö#x§¹/öMµçþ#Ř{öµªëqÓÍêCúщ_}`ÒòëןI"g£ô0.‡œöÀû§W×îø©¬äAg ã*;l5oɇ®k $ÊÎ�)±åѾ†Ä¶¨ÀW´Ô@ÛÖ"驯3UK dµ¦ªy”y¶Ü”`5ˆw]ʉîn´שE’#ì«ÔEOËÍ Ï±í,Š2ôOD’t²qƒY [¦gÛ‹+Þ‘•1Œ+™JC[`«÷Ÿ›Ò>ìIí8‘•Nß(Õ¹I©¹¡S¸Ì û‚îV›•­g0Å=vãjG‡½u;ø!õÌ íˆ?èâ&÷]/:-VÜö5OŸ,qÝ@ñ__cÖœ}ýùùmÞöµj2ð¼¯oèaxÂqîZÜÅ짊™)þ\,ÐT Ìð¡¤÷ìtŠÐ×…¡¸ }³u’»=Ýïå3‡`€‰ÁJ8»Í`µb_ãH›Œœûg€ rÖ9R¦²‡eïœwÜÇ5²WT&Yá{ Óê†$(¬D9š(C½™Ð¯ÓyòÓô+ŠrŸ= ÀcK«žÍúvë‘RÝ´ªoªñ>.bGLÅW<Ž­nßXua›vŠ×Oaö±²ïccÞ&6uÖ³nÝ8\«Ñ•Í V8”Öûþ+±ßù÷‰ÞºþtÂ+ìGwñÍ&ùi*MýÇžóÚØ07³3Zqq§Š!)Àfõ—éóá>r¡Ø\XØ͸¾ò½º³M,M—û] éÖÁ{]Ñ<"þB>©¤y`'õå®÷€G»ÁP+FñFËjÐIiF:}¦ygùø”¼4È/i·Øß7~æNRO¯žež‡‘nRÚ_¼§Þ×è{œÔ€ƒÔ‘8T«‹¥.甽¼¿{Ðq“lGZñ._)ªÂ‡Ó™6éψ[í+lΗa]ëiÄ¢N"¶ ×ëWoÖg}›Æ=•Ï½B¼A«¬/ý^«–�ÆØ *»Ø*q×þð' ²‚®âªÌNâÙåì9nPs03Ãk÷ðkq°ó+{DÂl¯üÖ&ÀŽ°eeíþ­”º «¢ÅÀªlSM…rÓ/€ TI{"ÛSî{æq±y¦»m‹ ý´LYP‡(1Ä[ôÍ=í‡`{j1R”[u_g ŠGK›Q¶˜6ú ŠX9ì*΀†] !F™'>…Ž,ì¹Dé’þ~²Á.õ¹¾¯@œ#IJÌÖ–"ÒÑÑ ŽgSä<¥g/c½Ù¨Å¤†¼ðX ÇDS_ž’’\±f ´Ów5ŽÙ.«ÿ6 ƒì·”Õ(×Ë3M\‰óÄ¡dÙ\V7÷½aJÙtÏuã'‡C+ÐSU•.ËØJÚfˆ;€\ÅSë�°æ 146ôD(a¹mŠäøÕ©«·sd£FbÄF)ß´«…-"Cœ[ÞMKœ::ò”„ä'ÅBàÂnè ÒÊð¿Þlká"MHDc¶°©qýùÒÈéÆŸì©ÎläM*î–dtd—AÕ4^…Õv½Ê_ëþE ŒêY>ÍÄâæxØÁJ5âSO'’5`ÆM$µe£™g€dæ@㇞Š•‹:(ÆÁ]aK;ZÞº šæ–Î\EM,“È)6.Kã»õjq•,ƈ™SXÓ'ÔoŒØPµïûÌi•U1ãwæèöF6ÛžjÊ) ‚ãpþ«¾^™caóGui¥Œ‚Ǧ aýí ãÀ¿ñô_aØü :Ay9öduŒÅ¡…=îôcßÖ]¶#YÑåƒ?ß@yW{+ÀåÚ‚Rê‚Äþñ'ðÌLôžÜÕø÷$Ëxt® 6“Ž}?*èi³ƒ…Ú‘r\O†5±2/(ó¼TŠÓÁq KifsQY ’'ÀØ݈ÎÒ&v´j}ÜÖüHorËnß=ÂŨ8vœ."pl ÝêpÍíNÒÌw‚€XÒÑøsôØúçýùÎpGXöB3×u^,„sÈîUÖ˜pƒyÀôÆ’Ù}·ŸÌŒ®åvbSS¤Úø ‰4Ë®ü.·”k¤§Ù£è‹€áÊ )ù7Ù añK¸`>Ólš‘†j†nó¤ �ÈôÈ¡ï]¾¦¼§,JÉ”èÓ»4Èm&Ì[LÍzmyòzbñ!Ëo0ZÏÈ·óy3õ]äCïõëEËƶŒ¨òO‚ÄD~ãC¦,òõ¼Au¨¤š·n¿=�Ô£HV+ôpõúC#E$¡¥›ykÂ)í�÷ÔM!$½";^j×AˆôUÐЉë³ç·}ú뫘UKÒ‘Ñ·ÆæÁIP† ·÷¬ÞŠÍ­¨Ýß ¥§NîòƒL–ºÊ’%xÍtµ7EîÞMžÛλp � #7eîJþ©ë&*p 9oõߢáKOÈ6GVÌö$i¯C¶\ºÁ½9—ðš= äaRßF‚nÙ¸¡§�Í,ÑЃçf’VÍt<¬zÆÞvg}&á±}ÈìÇK1÷H=ÓÌœ*¤D–Ž?‹™‡t÷Zìöâ¬Ü¾êÝ¿÷½7eÁèO¢š6ÆG¬¿ ¿`¢“t|œ¯„ô²,’%_É\ó€‰Ò§¾ñæ€/ìæíÎ2K 1‹—0EAé¿"žD:Ì’þÈ8&ëQïÙ…>üÙM•^m¤[äû耻A•shyÀ‘Ù-á6ûxÌÛMs?=zW¥uŽ9)ø÷»µˆ_+]½(y{.à OMÄŸ±€þŽè¹ïmffå7zhE–ʱ辣£½øôùaÇí¡vê>;íúL36eÔø@!Vл7…Ÿ<Áƒ»†Ògã9CðâW_h‰µî_Ù›úy+½ßŠå±w`@T‰}}»~BÄ`ÿ|]wƒ)>®©îIè›ÚPfv¦-[ÖªHJ6—žlûl²ÜëgÊ‚¦—àé3×=•�žXÖ!‡dßmΛÿï‹Ðiy©W?ÄÃÔ¦Åê÷uB æÛ‰·Ý…c,«/Öü ×7¤»wÇ‹Âq€JY3EGÏÔv,‡þ´ojQ{¿L MŸG FÕ•D¡.†–2%Û•y@i:wûc_[Ÿ'¿q©±ññP¬êÙUšÑ{OÅjÒ4ž¯á03BÊœ]Oç YâEâX°Ë µ0ñ„‹àzà/Ý…~} ÷ø¶¡m5¡UDÖ8Üp¼v"‰"fMi<„*ë ÃÑæØ ãö0¹�†•wj‡ÃÛ;!6Bßæ|1_#guœ=áí r2ÖV#ödwävoOÐÏǽ³K"÷³ÿ„?¥ðíP¾®øôÆP…7ì<"‹SÍßî½zÒØÆ@.KqÆôfoÒ{‘Ù:mž-»þ6q. ÝøAÔ)Ž,³ÜjPI=Ú¾Å_<>þúx^ŸÆž‡¢�½ûÔûõØíJ4UuCG‚NJn÷]eÄÔÚKd£5y«å`õŒ€!:šôXuôvÛÛ2ôb¶@I[O¨?ï•ãÎÊO @}vlGpmzŠ±íÑ ºôXÆS.…¸<ð;‹,MKÀfE°ÝУšTxO[ÙLÚ½‚B¦Ëÿx&Ã송1ªñœi¬ mùrRŒM¡=–9ÞJ£øE]—ÜiØÑ•n.[õJADÁaf}ïLQ¸Ý͆8$‚‰üÕ´Ol%&Ú+°-J‚¬þö< eæ¤qäwvJ*’Âó C/éLAü¨t¹(Õ›>xÒl¿Ä æqµ¤·7[й¶ŸÞ�ƒA—_ §¤ ùz[&¤Zuª\˜Ý{gô¯H©¤šÓçx Ì(´By¢ ±¶Š ÿÅGcÝf•#çÆTƒª2kÀ”&VUÜD‚ ¬7Ò{ˆ(ã± †‘jÌO«îÇæôI¹`R�ün¼*¿¥¬,$ÑÀˆ!Ž´­]^î€bÛ1Œf2 üîz ½aD2]ñð*ŽÆiŸ€¯{ù3ßÓ ,#ØhjcJ—¦ëí¸ËbÃãIJ Eè,¨VSöíîg!³Ù…rm®{‡UFÆL—Ñ{eß°ç=ó̦†êvo€YvkÚÂúºbÂëŸÿiEKÕ‰TPíávöf¸2pžE×xö›¸öÜ›�ð$nžò <^<ô…Økò&j‡ScØq] UÞô\ͱ^ã­jWÙ³§o16«lC ^'lÄÓI‘7b0%HV§A´4LT_4—nüÈåÊ&™©Î¨­‘lÁo¸…s4tgkܺú—qïÿÒçë~–ÁÞ_Æ‚aÒÝn´a^¶œ¹"¸ndßúÙævV.æ`R¨äþÜz@ÎCÁ±Y¥‰Ò/ ø¨Ê¾pX¨”j/ôW|Ï®ûŸ¹I‡³óŽq¡æýÞï?4ÚKçÍ,ä=ʾjÔ¤41^äªûz׊öÅ­+.äÕÂ_´2†¯§ÁSj§ÐYoêŒ÷ ÇW2ILó¤…{BrútP{ZåûzÞ ¬Ø[©±hÓ"ó_YƒÀibơߺövWãáÈÐxAÙ½ ˜ŠÒ…›ýY[ÀáÚÖÉÏñ°ÂסœEÐ2zaµ°»¥ö­¸9µ:˜R?#Ž'9Ì'Ö-3d<uvºkñd»í1Wlqp^'A2ž=¤«Ê˜ÓÒHhz¾÷ q±C{‰F|ÓSý:yˆ8^vm×5>Ñï1à.Yºoîk '‘q¯@¡ÕµÛb¸hc¢8zŒýuɼ„øIŠ²Æ"(ºÑ«™™1ÁÒSó¸­‡Z•Oê¢,^¤D!¤¹Š kìáÊy¬Öâ"hºþ‹î¨ìÝ÷M*B¸çÔR k;?Ž.øàè‡J‰¾ëS®væ qÅ<CCìS‹Wôî) )éÀ¬š¹>Éâ[¾šn±'1c±I²ò`·áŒvë5äè=ëÙá” tèúõ ”(òzL„j(6ÇÛÞ›j €˜kÑXú½,¥†axÒQÖv§´µîùUéG·‘õ/"î/{.Ø:À 3¥ÎCäõlÀ�éhïN¢20}t€cM.Aò2™¥Ý LXšøLûxüc«Êz–MkwSOÏÝ]ø�Zf ¾¿%f´Ì4rJ´ÙOìÝ3Æ3˜:M‹w“´§ÅhžÊÚ¹nTOø–vcá¡U•§P$04ühwM7ZˆåHÑžË`{±ÊWùÂþ¡Vg ìõ-¡6`Ý&• ¼øÜ=”UŽ`ËšyPëu,ƒx8{ƒɃeÌêw5”b²ë‰‡ôi(õ¨L>1xV0]jOýô�¼ÁÔu_Mú@ßWÇwõàüýĉ“%ÞX®[WËôÁÓˆ’ÞÙWk+ˆY¨¶ÞËκQäÁŒr3Þ¦�p´²x—þñašäèë«–r‹“œ*H4©œï+7©ÏÁïM½Ò§úѶÃ$»hg¼ˆ¸‡´é¦Ér<ÆþmÚî–šó¯Ò&ÓÜ]‡úcp¦#x¼Š€þçG˜~ÚôŒ6¸·”ÂoØÐÇ®l#OÜ/=J3ž{ši¿;Šè˜bP<ZæKºwá!x» ìjlµ§êm¯¶™hË,ÆíK‹ãòÜ.YºÃéâÏä47訹°j˜è2Åœ~1o^N¤¯'6q膬⨹Q6:}zJÙe“Õ´¤ß# +Ï3Êž§”[Y‘õãq�O¹/Ë’öõï<¥èÄ�r[Fæ µgÏB§\¡gËò9ÊÚyÅ…rÒ4sÈ:TVç*(ÏJóÅìf‚­œ”#„Cç—àO/uoC4‡O‡Y[Ò¡ìţ"·ù¬ÊZÝØ»ÅÓŠõ\æÝhVFê•®YAbã¹ Ñ ×v¡É:YZM wE©&ȸõxîîýÔ§@©$c²Ê¶vÕ [:Wºäq­ç58cQYբı§3böÁ’´Ï¼j ‡®°@Ÿ¶Á}‹$~ ã~–(†“jÂäçü‰aRo èÊË`•Úª±[p*J`V¦ÑÇâ}ÎÛ—·Õd=ÍL‰4@ãZµÝÒÔ¨½š¸¤óPwñŠã’m„DFBj€k¢Rg:L~Ð5øÕ®¾ îTÛ˜)Ç .e’yb߈²Š'këã‰ßÈ%„nA*èmß×]Úèš{†4ÌUbhóiûŽåÇ'À+ÅÍ%xþYd¾iÂ7•öå ãäŒeüêã^oÃúÔócPöu‘V'¡çŠ’ e\ÃA;p•ðG³|�ô1Íâ’þëxó0M¢Ð§e�?&´™·'«T‹Ým§È‰Ê™ºZeÐ gkÐÿ~ í)ú8˜œYÀaù ÿ¢Ðø¬šÁó^Z×]'ßt@#O0TôaÚm„ýd` ý…‡ì[5±0 é¦|ε˜N©Z¢¹ñkþ˜i„V©˜ÑR+Ûh³µ»˜tÍ]Ýè¢W®žÈÏyÑÙ†w)Döø8&סˆEkÍqÍÕ?¥"3žØŒ#£Ì�ÉÇðÇÜ#hŒ@ÞÜêšr×ó�Â4ónli/&hDw0½èÿØ:R¶Ãäœ~÷þ‰Gå$sèèãÁbû2Óx±ð'{ã Ú* [ºY)37‰�ŸYí‹ ëÏ®CB[öx°Ì“f¬wŠuïÊ2”ã%îà ª$«µ"¢bž+XmÅñ4}˜@9õ]mšø¸X™_ÝÌgœÄ>æ3E¤ªQ54Z…?¢ô†Nöö|Su•n;š�¬Ò{B‘ëf³$\—Ü&¸£n¼ –‹îÝ|âL@0æ¯#ø²hÁ~‹ŒOê»U¦„É •"xÑ(5J¼Âœí5×(Þh§};ôu]GI²#ƽݺ¢›-¤-¡ýCŸñ»U¹¡ÕöðÖ`ÒÃD{úPNÀŸŽn#&ý£²=âµ@FG|¬½–| :—0V»ù¿¶: ðXá_m„“Òù89CÒŠE«‡4™œÏ´ÙyKÞnçx¡e‘ÿ±q hçÌÛ‚E0äƃҎŒÿ‡C†àÞØŸZ0}âkÆ°ê¸ étvƒe*Ž¾¢Å]z‚%¾…B? a$ãEåÙ6}Ýz5ç„-[F«÷zÀ_ýoßý‹yíÏ`8 ¥w~[è ARDbæ­Þ|ðPŽ'ÎŽ¸'ù²_SîYY‰a0Ýšh£¡£‡ Jâ­VÊÐ/o»½ÇÝ»TFqœ9·mDghvÛ&�8ÐXîfÜ)\IZÌÿ’ïîÆfG¬c¨ôz&àn>=Æа:ì¤_‡ª«ÌÁ›™¥Ò«Œ^Á¼ØgKÏÅ[ŠÒ´¥h j“4ØGGm°¥:¡m¨,!�‰ñSý…HÈ3~Õyè ª ׳Â�[9-Œóuæ:ÜúÉc§,˼"„þž7–³‚BJÖ;ûF§×ØÓQž-Íæ³F ¥Ž#Ó^hêÒS|çÿ1E™ÀjGP(ÙñËæÚrº¨tŠà{‘&Þ‰Œöš$Èk=ܨ“3yŽ'kƒÍ³¨S9í3öRJÞ‹®ñ(”î­»ÝìqÇ@üDO%OïMzËØiV1^nµF«zûn]Æ>‡ØWçÍéž «lamHI{MUåÉ ÃŸV€KZmO*ü'ºô+úÝ$÷ýé4ç'·iª¡ôwì¼ÒuÕ­‡· ¬¿ƒÕy¿95ÚÔ|Sø+ßð·¹î!”ñó'ú[t˜"dÎç*ˆfK OYw¶·L_m×þ¼xÒÀU4·tÌéৢ­`–¾æº_Ÿå'{¹©)ÛŒ„J&€š.Óͨ¿”é;<ã¼1²Jñói8ûÇÖkÞâ¾·�ý¾§¨YL*¡IQqs¾ôëZ)ˆ,j®5EeX¾5»ÍVe¾½o`*äÖQŒ›?îÁ†P€Èï§fGÉ™;r{)ºï–®±5Ä,Í»B€$ׄ§DÂc`çú¶×$w„H¨"JêZ¯;çAÚé¬uÕ×òÆžÃlìOƒ§TþË :NÂ¥uÆjKk?›•ä—Q8>…E¹¥FN.¿½¸A×rŽ’9Ó9ðMû÷}ë‘Ä™Ï"Y61ëرšßòÅa¸ý î"ùië¹ð?V(äºÚ,óWðQV Zì3 ÿŒªœþøE4Ûiú‰þ+ú;¶ý]šE÷T<#sÊàhXAC·ÿöù0.ewò…Åígt{¢Ëè6¦ú˃áxzØê©J_4 A´¢ ¼q¾dÓzß+$AÈù†âÔ¯‚|Ü~P 9Lz›µ#˜“`Ë•Á‹±:2 Qˆº¶§ÇïÈy‰ÞHÙ\,˜†¡x=hªlÆ„´<w7ÚJŽU«IÕ+¾œö?¾—ÏòC9ÀSRÙZàf‹` ‹ÀxˆŒ_ÊAüÚ`?)ýžl iÄ"ˆR%ewƒzb}_QÝ0ß9D{qKød˜ÜÖEÂØ땆-›zÂ0H©½~BT®¾Ã¤ƒ›*=TUfzÑ^Ö]k5™¤†mmr¼bÝ3¯ëè𧵥v·dÂØ-^ƒgÚNµ–Êe o¦¥QÙS>}T¤©ÝíEdo2ËÿÙrîlp¾¸7pšSgØgžd&k+ù™ÑnC±úÝA®)þYd€Üi}y ¹˜&žÀ+L›2Ȭ/FŒôD­JÈAl)ƃˆ^š)²…IL=Ö¦§›zFÌM³™Fz8C™óºŸì›8]H´p²ˆ±,ÊGê/ƒ2ÔtPð¹Í]¾›f‰'ÇZ1ÈæÚGÛ{‹ßí§öòa6‘qÑ~b¦…‘sƒdõÌ™Î÷Z—3ݯA÷Ä_c×u›Ýë挖T)¦³QÐewf¨Úô4„uðç¬[T\ŽrëafÞ™XªtÔ‘\(ÎÐe0 }:P—‹* '­´ ¸ÒVŽ~ïú†´£Ï`L…ÌñûÅ {ó¯ÿó–[äO¢&Žÿ¥*{xÝ ™,Û{Ç1%_r_÷£BtW¶Y ½‰)N>1œ‡j¯Õ²:ÀŽÎèÕ¬Áæ¦gÕ㤠üÚ§{ô† ß6õ Ércч¢ÒzÊû8Oêñ¢ÀS«Â|†Ô€ìœÛ—JÏÒÁþpWºOãRG;S¤k.h€Ü0,ÔxÔ{1i{ÃîyÉ`5²-OéØE¥˜Y¥­f…ytdþoE•»¹ï2ªW¾="ÿæ@7ÌÚ1;¾î;&¸™ _‘ˆ[™0ƳêH9×t®wŠ½ èG‰ø…{–b3õ£{™z£R–€[Õ =YWø¤$�¢§FôGMš±ø‘`Eåt¦Ev-j[3•J%É»lm]PV¿=ôûNè,ÐBö"£^¸oÚóâ~{- •Îfª: ³¡5Ëôì?oYüöï[fš ðRîX‡\ùb¿UÏwœn.¸\gõ? -AªÞqËÔK,'Ý]-K¢Â‰ã @fÑ ƒt´mÃŒºnø躣ìƒÚ”‰¨Ó9õ»­§ËŸÜÁšEƒ®¦ÂÔõÁ–>kõ ¨¦°ñÖtõ ÑãøBߤ0GfÌ“ ¥g£Í_«d)᲌®÷\"Ó£“ŒÁc‘'uÙZç¥H?XM€Õh™(úâŒ.2¶‹Fç–vj6u®y¨?ü^ê‰qsF×éÚ–·tØ\ì±*hÚÐâÑ£å®0jµž"tËy ¤T;+'p"~Ó²Z‘ÏšzX–˜u!¦¢}ßIÐbͲۚéÙbñQjúV3znÈtŽ¿½¯W+¨÷ZÓ³{PЫó0]eXsÁÒ!éÎœú~b²êŽï6üì(ãÀ0¨në÷ûŠ…|†ÓÌâ#Y"® ’AÓ4Z¨Èy{÷&qîâ!¶˜Êv³Îs3:nÚ<HØZˆÿ¯dcçîËs‹z&Ll .8'£Ý¿=åAÕû CT¢[£ZòOå4·òkô(ö(D¦ÖåÚmGéÑÁýÂÝÆ*»U3ƈööŠ*<ƒmž_n[:ã­Ý0¸p ÅÜàtÕKâŽU¼àæÆtlV¦jòÕ¶{»*¿Õ³4Ldu.Zb÷ÍÇJç="MšaC¿Ì¶ÝF¼üé êàÈVAÕˆ+'*ãÙ¾}ïÖ§–’“Õö ‰¸ÉO÷Ý·æÀÞåÃéNQež~>ÏÕž~WÞ:b¥FŠ„æ8Äòd¤;YƒŽ_4¸Z4AåAñ ìõ™ÎèÊRŸÙŠ{¯º#!þW>ƒYèRÓ¢ð¡w`÷Âß99ž=Kéæ„ã Ù!U}·éÜxÑ;gî x§Q¼°î ’+¡©í<j¢@°¼ˆ4aþübÆ'Á‰ïOM°h<ÝŸ}ÝMo—ñí2m(Q€L?Ì‚ë‘roÈ{—ZN/¿§€â† ÒóŸGôCO­‘?›Ï‡7J‚(“ÇΠ ˆ‹î#@êÃ¥$ÅÝCלaQè5 á<OY)ÕÑrÿ›“êìýi›ÃÈÚáØi0@¾Ùô‘ÚsõZÊLð ¼jìwOkbu˜æÚïFQæËZ0t¢GMŠ(ðÐѦS�•‘Y¢…¹vù¢9Êßf[y£x¦"-%w,–Þºùïÿy[üoeʇÌä•ÿ6÷U†R¦¡2ŒŽû‡ò„Ѷ®«y Ïý5P×££ULëË ®ÿ8b#Pä'+!‚¸îG6©×äaþ<€âvÒÆ#ÚËìòép¹ÿ%ÿ¶JöÔ){ؔͷihC ÄúýZ2Ù¥oÅö5›(̦ãïÏðîëzUÕ‚HÅ_mäq ý“y† ªk ÿni¥?šú[Ð}Ü—+‰Í([8áÐ ¢Í·ƒ¯`Þó|Ø}HQö?ìÅDïÞøX‹!Û¸›0¡¶'ü´Û[—yiÝÄr@©¨œÿYþlÁô½wmýõtìéK9=é.€bh¥\t9uCÝKsàÿ¬F OUÆ}·©±ˆÌʈ¾ÍŸmœ}Ä7z˜oLÈ„øʬ-ÉÃ<t ?ÁÿÄ™.„®ÿ1aø ø»0‚ ¬1I×áÏâ@¼Çj)=3v?v(g,í�¢X>;øïÑ[Pr­'ØI‚tûîñT·õ™Ž%îŽóãĪ¿[ÿâíŽÖNé©<3< íÕ¢4£þ¶¥šZý±-9ª ú´­[Z€´)¡LCz•e6Ƕþª™¦e^\Ó/©Ê(sâ÷”LtKš³ƒ+ÑŸÏX—°qK”K´×€zYî¶YC7ÜÒl±Æ?�4¹áZÄ, t• á.g¨ £—aS`¶ßq_Ìã ”?쎴¢NçhÚY…Ax|Î>¸&»éž nìœvp’Ǭ–5G—Ø |È´Ì^Ъn¨K¤!‚XøÏâ×ÿy£ô܃LR¶…ÚÜ=<€?DYf L,'¦“¥Aò>›­—@}raöf¸…6ö"{ÌwoföD?Eè’[ŽWÛßvöÉ=SuÂ05�Ó¡bëO r!ßr­¨?ø¾Ä† =A›‚a`.EŸ¹¶ÞÕAåƒ ×\ÜåæbÛ±shãæÈ‚¾âÏMq“—íåcUn‹cÿ%è¶àÛž=pàD|±iîͨ•žc€Ñã>‹3$GÑØlÔÙÍrGÁýyÒßbë1}P¨4lù˜gqm!u’‹Ó“^SE>‡èž‚´ŒˆÑ'cín0„ãþÄ#Ð_ñQÓ… B*Z˜å§RsòTüµzÎÅ„wÍ8 èÓ¡_—Å,Ü8AT+‡. Òù²Õ3)mYų̈Z-9?�Y¼õ³ë.·c Gj“H¿.;ª÷¶1Âê6<Ôäô¬(.3¥Z@¨—þÕABLßöÝ›ÑbºFtçè.µúrCŸ7J}²0¸Š Ý–ª³.ß¹, †ŒÂAum9 ‹ÏFÆ‘Ú=‰úž=;1¾«%Œ[Nj ³“éƒÙ^Á\·Ú(éz«\°h5eW}óãbͧvÊòR!ž†EÈÇ+âž89ò{J3Ïç ÙN;vgçq¶û殂y½–C±V6‘]zšTÃYßHö°0&¬ºZ^Ö\Nâ¬È¬â=P´ô†½UÌ2®Ž”ôìV«º¥lûò‹¥ýÙBº'2£ké93P ¸ÉñàÞœãÊ?ÐjEFClš‹ uEÝÖ¡ãÆiæ´“ü–†æ «=¼&�-4i à Æ£5±-¥ç¬[$ý»þ]£`§Äæ•ŸxÓ¶Ì;hò\ePÙÕ™TŒ«²f¶®ˆ–å~oѫ̪ \Bª&ê*H¶ê®£Ýt#ÆÀ²˜§Ùw¢ok®Ó­*»ú MA gÒŸ*Z‘yÊ6]œ½SñÖÈLe;ÀÌ&Y7ŠôȾ/PÝÉÝÀ'+\²œ"$R‘•ÀL.ÐÆv3E'Ýj±1ï-ú™­pùÜ¢ê~r “gÏ%ûx™W[ÇéÆÞ÷<jM¹ÚÖF âƇ#Ï6;dÄÑ1 ŠoK3ì‹cÅÜSt¿Wª åêv={ò�h%Ý7øÊßÖ0˜¥@Û ÷þè<íÅVƒ„Ä@±•àVËØ$¤ñŠb>zÓÝÑPPl1,ã†%¦5X^ Bh.Ø#Xûƒ‘XHL7K$ši&ˆ<âÊ©¢ê/V¢]¢Ýü‡Í²”où¢ësšEËÜHœ'Êh˜Ö`´CÆ®}s†®?%§ïIOç0ù¶ÝI¸IS~¾LÛP¬Õ0ÃÒÒR+ËÌ•s7VåCÔÀ3É‚)–¡CMádc‡7 :á—éÒ¶o0%ì©„û]{: „ijW¨å°bÆç»sû ›À Pþ‚®=CK—>ù¯E2¢ÅRàÈÓ{g•KÒ}5Ì< ÑŒÃ¹‡&ÞLf‚iìx ¢ˆÉq¢<}`>Y®åøî™±qæ9�¢Ž[”|j›‘½7$¾›á\ î]ßs;°"ÒÀˆàøNwæè(è('°òyA÷Õ‰FÂ]kàÄwÖb’;÷\Þ{eÙúWŽ!ð»ÎK¤•Œç(èc¤ÖáÆ l¸©À§áW'\gkØ­>®l ËÐQ%#v1€›ÿ©ÞR¥6Rl×Ñ6Nqs}Kk1ë¹u$Î/5ž>Œð6;b>`¾v´êWîßÅc^z2æ—׫9µçX–4L,[+F<œ>€âpOàÂ_RšÇ¹J¡RÇ?®‘)­dI=ÄMGæqVìfm¤Ÿî ^ÅÕµ†·­®pÊ­²Ê*/ôx—ý^'îX¹ÅóWL5¹UN´ê—¼ÍØqŸa†7êÛ<üî*ªû¨ ‚úT´xcGê)VS1ŠäA}ÅL’ñóB÷ò;6.˼€ {mµƒ^æê¼[ï/<²Móß{yòV¢1Ì<†¬=hŸò@m§“ªßµµ±¸N³·‰b®A"2†W;ß÷ÈÑ?Iû|YxI½+=HÔ-‚4�LÇ�¤ÆÃþ¦è`¤V<ñþ3À;Ç£7Dêú½T!¶sÒh-?`òyÖÁ<„e" ½.{lÆË`qµûŽûH§qþ—,õ *Ã~ ÞiUÅb``-¾Æ #µÝÕÔÑ 6ÒãJ{H<G+”·m¸²]×¹ ×ÝÆ=Û’‚3¼b§?îuZ% ‚sGGfåJÀ€{“`ª™Ã…Ã6kÕ§Þ\Üè¨æ¥Ã×�˜€Ng„ïŸjÀz!h2*èq›3‰r_x+¦©ÏéÀŸ¬sÈý}Anà;ë€zœÐ)vÞó[9�…3ÑRZ5XJÝÖ“ÓÃ:7-OªLGØ@BOz¸þö†ïº[ÿ…Q/n¶TƒDïg…UbPoô ÜÔ­7å†z£æå7Î7.C_çÒÅ}DÇ?ÇcX:Þ7JùöoZ[ ¤§¿E´ÃÛµç¦J1†3ûŠpøÕ ?õ:_[O'c¬[QÛUQ#­ýíÆpT9N¡€*œ¨ïulV ÿk¨oùº’¿²¢Š<ä&  *Ž>•WžÅíAä&Û/ãœ2Uj6÷1§¼6 ƒ¤½xPžéó´Ùú‡¹òðHXVa·ÜA}ŸÐ$ô´^3§Œ8¶Î[¨é6P€2“ ¿ÓEŒÊØ÷ÔF¿‡Š³ª¾ø ÿ®…ʱAš=ôN‹|•̉¥¢-‰08A+Û*+½âªèhÔ}¢J7<Õ¦Ÿ•'EK‡›_Hó†iuè¼¢÷Qpµþ_±Q:r~¨=az¬m«ëž-¢µèŒ˜úÀž7?`3– )ÀQqXïú$\tnîæ…~Ï¿ç á/ÆÒ¹§ìË­Õ(Ⱦ'ÏuÓQÔ°zõCÇ´ó'+Õ5°¹?ƒgs¦Š@elÀþ\n–ð{áFþ±ù¹àF~Û8šð4™iªíX6þ‡Â/ sé4C3Ëâ©é•Ô:&=¹W�Πg¶éUÕª†v<)7(€ææélLŸJ›U™¯¾€–\—Y­XeVn2nl¶×ýws˜çUæ3;¸Jëò È̺÷ Œy¤;4XG‡u¾ó±é}0¡¸p‡@¦·Y‡9øXPù•¡µ5ˆRcìÝÓÉ”Ýý©AgóÎ'žy™ï¬ÆS#Ýaã‹[ L½-Çu—Õnµ.B9¬*¾xm-j ʼ/ÎDµ™‡íîY”ú6 í Ý‚¼Ñîê¾îGo£¿u·†â‡¼,-t#¥âˆ©œÑa¿qkCëõ0xÈ‹¿’ÐIýH-¬±Ž²ºâÓ§S"±^ïLÚFÔ¢ÉÀå5w5n¨ê-%2StÈikÖ³çÿˆ XØ]Ûšæ×G7Ï"wà®nôš«Ôºl+ºZ'%=Æwo£¬ÎT+€¢q0ªiëÝæa¾ÐùÓ¶0ãègo«Ë€ÝH)ë­ÁÉÎew+{oh ÅŸv—¥I³ë}wñ“*¿¹—ø³[˜† ±fô\¨¹[3YŒÍD»ªHmmÛM"~ø6‚´×˜Ö$LE î¥TNÍÞÛÊ=UWtÓM3`§å·2¹±Ÿ,¬37¿e3û¦öI(ÈÚÝ´µÊ› 0HtW«ž+œS¨¢«nª˜ùct—="áÉUƒ´õ!âe²Ø^¿ÂÝ·NÝVn…ÒD�]™Ð¡cMB •:œ ‹Ø"ø„ß0pÊ™:×ûÎâ÷Ъ^8ÝU“ùÿô‰œÊ‚8L%hïÚó*b…½¶ƒù¨ˆL\( ôÇ8ÿ¡§qï{ß~RóÌ;7sªIÌ¿fàªf†9CšÖ]­¤ Î{ ¹EP}ªb‚UšÁ9Ç¡3.&{QÑ/Íý9?D9‘-¬pZ¶yYf— PâÜ)[‰šÖ_<o½þÞÀäüyëèŽ/Ê”ÌxdÝè©z¡~cJXq0…Þ"ç Gý4ÃkE‹Ò2[}%HGj¯šÎ½ÜÏ�ÁB9ýôÑYþ›Ÿ5êh1‰à“‚~$=õ+[Ùè:8õ=Z¢G݆3¤ù½ÃMÛë"G ‚ ­{º¸ôåqœ—jåª)¡žBÚö0w3²ºÓýç-cy_<0"6Àþݑþœª¶7z^¼šUúôƒ»!ÀÀ5G;¡ž¨•-y’2çz¾Žv|<X3@Ax�6Ú ¼ì�Z‘z;G¸ZGè6}»ò’´½ÁÏHÇ'îÇÎ[’‰—¾—xó#¤ÂÞ³<¦›>w"fårŽ`®¿v¼>%ZNV£°ôñ&Tà#;/?UFo8ík+-ð~èÝN5!%5/`)ÑÕJŸÛµŸÔÐUF‹Ð~ä9E=w¤3-ŠS» `õœ Yõew€Ý8Ë OâŽù‘Jˆ²ÓÒ܇ñpžÒíh»Ž©NˆíÜ X‰™exOé-Ô�{›Ãˉ²XAò)6¡´ ö›ÁB^]ÿ]ã6† ¢v×”:Ì:,’oà[A©rŸ]"Óñ¤êw”Э¹¨IVáhA)A4Õ†_„4ãý=´ÇÓ†¶|½ jYú¦ñ ^m–¢sÃÓöÔO; ¤ïý†6½h•žn"'×ó„ªÈBHr½tZí¿Äž¥+nžü¿¢`§n…ñé¤L¸"9!@çæ7=³Ñ´†fÕ£¾û‹|Ø>t£ý”!? 5ü®é¸SorgŠӱwÈØîÐÖ'î2 {eÒ|#\6TøÙøµvW¢ §aÙ½ý5:ÌÝlXÐà”·-`<@ÄüH‡Åž½eÞ{ý!°+ä!zžÚmAÄ•ÀGNÔÝ!n]ý¬%âª0µxfÌ/PU­á—ظY. %,óáh´Ìg79×OŒnœùÐô¦ó�¿»ºwØY>Å-;6nºo„ZÍ-¯¾•fßÉÇJ!,HL‹0ªáäN»ÍXO“„ Ždr3ÌDzÆ2¿j¤—N]I"ËS¿û턽G½$ÊSd–ÉÏG(`EÙÙërRÖÊ30s®ýþVDIé~î’ï?R*OZÅLÂfkË××ÇDz Ö¸"æô‘Uôöê¶ë1 R̦3Ð/­Ó2Ë ´|9¤‰iF†ÛÏ©°YƒFÒç܉…’,8¾ô±œ(r[ôîð…üs£›¶¡Š1í7¾Õ§Å0Ë-û<éèp¨·/í»;˜! GÊ—æÁ}Ñ:œÔå‹Ö¯Ñè ê”'ÜW«iè#·ôFÌ꧈økFâÑ›hÒÀ€is„\ × Ý$GìÃë<¨@8¼‡…„a’„>u3ÐCBÂ8;ò€ûÔ q|„édïx¨šÜVJ¬HKdt/º„÷Š™ôÁA¬¾ho8Vq¤ ·lƒ¬VoØkh²¬Lüú>‚®U ?¿Öe[¾øˆVœqàF1²Å/²v´?œ9 ¾¯ì@»§³ÞÕ€Ân1ikÌ®në;Ýõõµ´84ƒüpNÊõÆì¡5ŽR°ü¸Ì"<ô>":“á2‘šÿ8ž†á²ïZ/0: ¹ÒО;ºO“Z‚¬Xmlj€ÉÛC”“îœ0·nÑûž:!dž ›•TTƒ lMüÝï-b±E_ˆ(h©Ä0ÌÝ°€|»õûæ¦@¿|КˆO /–lþ YãTê÷k(æ®k?GYå·ÙAOè·%ÛÉmX˳­w½XÿèŹ“qù5ë5ò5Ã$èÛ$(mƒM2›la:qÞ×lRo¶ g¬"³è3G g¨²‹•Lš6BuWzs#ìõÂ0 ŒÍ…I­+J+误gç[+'“Â*ЫFÑóؾ&ŽKßÒÞ·ƒF¸åСŽ?¶ë½ß¶q¸³Û"+; ÐW™¨ž/Zí³Áýƒ¯å½åsCCž©Æ¢ù ÃmI)¯Û?õ‰´¡ Á‡¾¤¼5DZöº[ †½Òá´ý0e›4 ò^Ëb‰N[â7jO®‹—·gˆÖÞ½4£ÊI² µÍê8lÐè`k«ýHKþ(Öñ&£rÁž¸¢R¤ ˆMF§,äû*ëN›ÍÄ#¹·Òýàîr}áùÞŽSÄŸßþäºF™ß™ŒQÄF€tžN]²ÿÄÀ'³Öû¼I‘IÈ@D¢¼X—…ké‰n £³È|«ZZðZâò´ë?¤ü Æ(MÜCfT_?¡Ÿ5¶ž.F…žxÈÞ 6ò)KCdœ}’Pž¿V.(“1Œå’xŒÍÅé} ‡³(,8ÞL]åš¼¤-l56r´øêúÓÈü‘–97Rôõ¾Õwš›9Ø==Éäô‡?v̇©3š¦Ï=›£ÞÛ;”´ß—²99•Ù”›òËV—~&^T­iòŸÑ'Äû¿fƒPÅ‹9zÆMH‘óÛt 5–JÛ“‘kýU¯&±‚o‘ÑøkÆ’‚œÿéûË€³„ß{:׬Mý³“ŸøÍ1`•7ô%ê”\4)SxÝ©£@™ |H -{q@_x¼Ï5ßxŒÛŽÍ©ë§0Y-?–LÃP5xúþé¡ÚXŒKä¿*Á­Ú©èPÅÁ> ²^Ok°>¸±«¤#³à.¼$u1—ïøj¤ß0逽d»–ntö³Fqè®òPâ;ÆlNè:íd¬ уC™�Œ?߶»N³Ü ¡wáꢚyÑÜÉx-L'$Q@ùu‹ñø}Bò.òªüà x¹ñ4Ñë¯Ã –‹’^è´Ç°ÞÂ>Zqi±»'TªŠÍ·9ˆóëIF,V‘ìe•²Â !!Ó6 ©­OVB@Òÿ‹HwõÅç—Õôã…}3é0ÆÓßõµ[͇‘Þ߈'¥AÇ {ž-ú©”XÚ×Û½Tg3Îa¨@÷IPM¾çº¯\1˜Óó¹µAæ J¬Ði™•BèëÓH»ŸQ×Te—èr^K­™‘õòåÇ/ÊUè06òÊê¹5‚»3<b¤ª6ìEc›Ì›1ñ¼ÙBUÃÙJ�xH žîØ)4Ê,ú_c87¸êר@z_Ñ"òК9–m?вíß=y—ºõ�V¯6+ã*óšÊtWÆ=°!ÖBmªÀèhIОJóL‡y×óym_oQ:bÿÓïXÕ›µšÀ,g_ïìjìèÙApÒ]ÜP„Eú’->9E ª—ºÎóά›FGñ‰ ^˜@„Pí@‘§þÄ£ƒ¶ ôWñYU,ª©õ¬^E/K2:K«Ø°úš˜ñÏÁ² åÎ5SƒPlÁîÑ׺=Wù§¥¢´‰€“b¬j1>ð[?ô£y%C7ß&j.¬þÔ“—ˆþ)½ñÚµŒý(ÚÖŸ¾mådSýkØ•DҦ̃y hjgQ%árX«Áyì¨VÑ&4.pæð¯JpphtJ!xBˆÕÃxQn‚OŸ¶01ûŽCèC„Ìûth!=#ÌoTñW Å£D±O¹±UFÊC·ŸžÔ¬‰&¿â†½ý•Í}T…¾Ð Cä '®º ÆU¥ÆN:¶Aj>=ýÞ<å´t-4Ë^­–&1 Îk:8B4ÁiúýþܶÈ z”?s‚cxKni¬,`ÞL_�äGaâÅBui¤"+±Ã¡FýpÌŒ<Âg3#¯u­³NzÀâc(:»¦é»;®·ÂéÚ…><å¿¡ÎMÈÕ ñÿûÿèØÓ˜Þ›—eY)H±,„ÐOWÅvòŒ¦ »ËÄ›v œ¤j¯~¨dÇ¡/Q¡™CL‘‚+pŒÊ„T·ÙÃvź‡f)ŠŸ)‘lôà̳ڴÏý£íµÀך ±êvGà­3ê['àbTÁ–9Å-¨Èú¯æF¼ŒƒwY[¹¯Bùo†½¥=í{¡;ú'O³…ÈFl˜[ ½õÿF‡¾ZÇÅêKoõö l·Ÿ¼•ˆ–Yæc?BÖ²`…z6§<�8´æ/‡Î ¢ÒÖ¹!üPiîÞ7f3¶}Äu§ì<kNºÂª¦"’k<;Zè}ÙèŸ8W4ÕM:|ƒ°ÖžMÌÚò¾”6Ð仞F¬·Shø™óHë$éÖžµÉ±Wo}G;¤.ˆŽÝð‡ž&¨�d(}¾È–÷¥î™ÖGÞLÚé‹ ÀB’Šo7½f÷v’Ÿø¨Ï{ùj±%¡ß¦Ã¦€Ðê•jVdB ÛÙ¢³©íú¿[690'ÚCîšTzÚ)Ìh;**¶芊éM8• 8göõ Ë®€¥”|¹ªŠÂÈ jÄÜÍJrÚ>ï^äVÍ1GiÒqJòM‘öd‘y·q¬jÌ2LìyÓêôJä7² ÎTFÄT§ôtŒå[=ý8ÌhyŒÛË�ãnàD  ÌÏÚîÔŽ5Ûùœ)ÂÒÐWO:2(þ)Ò%�c ˜éÍ›“¼z(nM¡"ãìsD[­Þy{Ö–½‘è$¨†ù;œÖ=ÀV¤­i™j"Ï Æ-¤L[7ƒsùeðŽŸƒAÅÞíGÖv%1øÜrïVq»/¥ëÀ¯ÙFÕÄtÙõëm`m¦‹hq´4ck®’‰È7‡õC¯Gsc Ð9Ò;vœ@“«+WxSkfÍJËïO'ã3øNeT,NTfqP­%e¡ÔFP)Ѳ¢ml¢žxt1íSÕ;@Š{]°,öZé nbHåurøÖ+¤˜9-ºÐ ã>÷KJÖyæyŠˆ6$’Zi»æleÞžU1ë½Ã+Ò<�TYÓêa§Æ�Ît†Fb{SÌŸš�õ9 t&ñFÆO½oâJ·³ä!ô§LUvšpCÎƱÖ0ê™~Kœû­B £Â零¾lyÍÓ²9)ú^böe…ãg³œæÇ\Uk‘¢xº"ON÷×ÎHð×cþ|#¡.½‚sž` –%ˆ­&‘LÜÐ>w]«rÌ/h¡FÊ­A…úybHx£š1 7‡±ýÁÍ¥µø ä.r¾y•1›…ÉOyÖ£œ½% Üw<#‰Q„‘ìÏüzò®’£jtŠE=Ùýj›:rD’»S²vÁ¡ýaÆŒ+Ù1õø£ƒÇÍÃïÀær"f"-Û^ò <2+˺9(~äg1 Y~s³ñ¼z##­? a)ëK—2µÃa¥}ͬ»ÊY¶Ò5[ŽGS{´ä’Æ‹ð„ì'íÜ{õlÒ)§7\ÕT̽›éCv|b´‚"Ç~7õwáºSžÕ¯¤sMïÛù@²BƒU D ñw³6xdn„£ ô©À�ô†ò'#Â1SQÆÖÓ¡ß±K‡½øñ´¼d>’qUé6Þ©®A ÓrµdÏì¿ iç…? §¤èTÊÖµ£;>äC-°Ç€²›ÞxÌ©Ï1ÿm.Œ¬»ÑSñdæÆl·Œ–¯öÄDÏU[ÄA>©‹bÜ´\¶ÉNltÛ»o0#žLŒ¡Fc%Ü}w\/^RŸ¥þLÜÝå"šæ³,"‹÷)Åèײ4qºÀõÂœq½ÖŽíºÀµoäs赆xùý €Îuo©bQ ñèEŒ\¸§¤âŒó®é@V±0KëØœ/ôaï¡Éäa¤Êr²ŸRðB¢Ó¯Ÿsb™Fiëܼ¼î—¤¡Spãúõ<8&A‡¿.¸ªùðcëOóõ†¿ÏC‹™„Ó?:ZO/ºçFÄMG$f¬~÷ÔO¢E°¦]7� ¢ôŸž§ÌÕ˜j೚->þö±Óq/«â‘VAþÙzÚßàãÌ\ :è¬?Ç›Õ µÛ÷͈$C ÌfÇðÕÁ¤öâ'¸¼êþuÖá:܇šËè½õ_ÓQ£0÷±Ú`sOJv“¦ ¯™DPœ5n_w*}-(3º“«=ˆ4Ÿžç*çŽ]ÿuØŒàEú(h0uĪÇÒ5J¿G‹ð‚•˜t'SRŠ\’7>ªè9KcV÷þO z.¬(ÑK£/ioû»a® 4îðÔ½zû}@Ì<•#–¡½@9±2ô¸'"Å‘nw3H'òòØ74ý–2þ¢ŒN"]ìZ7;üêoø-«!ŽãÌÕ3÷ ‹§ÑÄäFÛú¬¦ÅÌLÅ2-õ®ÝŸ°Òïèà‘«Ê¸BÞÖô¦Ÿº¯ÄÆóƒrSíä«'í=kÚBíxc°;B]ÕŽ5¸*¢qó¦ëÈtÜcã·cSÇ‹1oŸêoü ŒX–Nÿ¨¸ÓûCR'ŸeŠ§-­®æì ýz­à¡ÕaêíÿÇÚŸl7®$Û¢hùêÝN樋&@€…‚�Åïÿ¿ãÙ4ssw°ÖZgÜsƒÖNŠÜÍ­˜ÅÄžF lñ‰´†@»ÜtïrI(ci@Ìh%YBYh›Ãs=ïlC…¢‘p)ð‹Ás¡Ú@Îl•x.ªpL€@=eNukà>C¿,ÖKüÏ‚Öú>¦aV\‹ ‡UæCgŠ`·¡úªÛºìúK¬œä³¿íö'±Ã%qÿæpÅY›­Ei€Oˆg¿¶…+2_ãRÒ°ñÊ­ðµ¥0ÚÉ6X8ºòÑ⇧ü¤$Í}† •…»M„­]µD%Á$Ê7&U~û>%©ç Qá`„tfg7,®{0í8Ð@ßs¶Ö|¡ÂOg:Ó£ú$GQí¯Ð×àE­S¨ïŠïè¨óx6w ?øj.'u$Ž”÷U¥|WéÛ7(,«aòpc¬õÇG—t£q0Ö#µþõ° ¯˜O«™Î¼Y{ º¶ Û •æ_ŠËG,]³JŠÐ™ýpâ×ý$tn·?¾FrýG©‡tR‹ ª½3dI·«Ü±§KùæôF‘•¸‚5}SC†Íৠs[¢‹µhÄUoju05@7Í:Ý)zïT¿ÖÏ65‘j®)8v®Ó¹Ç ÂÀÍW¢*€¨?}u¯ a­°»1ˆ*)ÁKAñ®Í1WZC=‡áþØÍLhðÎÿ×´ø8L}m àÑ�k,ÿ£ ²¨ûÖ³ƒ :;ý œ{syfw¶[úFN^ƒe'¢T@[ª¾§%ÜešT_qùâ¼XÄd‡N >ÊÁºÐñ‚é÷l§'*ŽêhöÊ[8‚Œ–tçÏ<Ñ'/êÑQíÇ]÷§>õ?6Ýœv“&I� Ö"I¸ê1 @ýt÷—´N#÷‡˜y^§A¼¶�´âº=ÚÉ«)ñ‚>4÷é6}ÖŸwuƒËɼÃ[tÒf`¡¶Vn,å={ì¬Ð¾ü@› #+Ê(½0©òbt—¢d ­´ËŽ‡VŸ×[ñ¦ÜzdŒºËüö'º 3]ý„üÕÓ™e¬~’RßùõöqÄ_+F£!áÝ\ð­ßúÿ7î7UÇæ‚¡,΢J~áù>~ÞK3î¿an O$GS1«Þû?f7ß–f¾ì'%ç?ÜÂìú½@SàÆ×Ä1ÏÖ§C»;.H åÂÝ.ÂÑYá¬z¥˜Î×^JtM“z"nV.R ´ GÊ[­Æ€QØvƒúÓéÃy¨¾Þw‚3Â϶í:ÍiÎÓX  Û -–æ¿úÑ™Æìšo½º¤¬ÚÊ £ ýš:ÇN§$÷0éoßí¶Å™îc‡€Ó¤Ñ?5ËŽ¿÷ µ'ZÐÕUÉ´ûÌ—Lïl b”îèýkUÏ‹òÒçÌ —€¿{Oy×¾Z( QÍÖAç=ÿô+Dl'$OÏ]Š}+ õD#JëBqÏ #±0~tƒêñƒÓE–wLÌ¢Ì÷´bE þÍ·g¦z¬1nÀ”„ý7Ñ]ý§Š‰Ž'«ÆÏ¢¾z©=o›é¸[9'Žk¬×;à/•€6íiJ·ö‹f´¼§�„Éy·²¢QtÇz}Y¶-3–•Ç `»î¯Zm†¬¼VƒEi¡`±÷×òýÊÝ•2ø4 _ÅŸ‘ÙÌ{–:¢ì¤æV<¦¼—“,BÍáÑÅ°9Q^û‚úÓi€ÕÄ™»¢}‡A�ÝQy“ú*ó H ˆA3ú>9ÿ@ê1›ô¼¬8šÙæ3ir”Ò-�ŸÇ¿ŠÿzÓ0[¡;÷DT♊Uââÿ+v“ØðäN+3Ê�h¡¸ñ¥Î«xèÝöÇ•o\;MÅdáüU‰6_:ØÌ&A½ÍÓçeQöD’/KœJ«žœ¡^u:Ê-EOÅtýåLk­ÍÎÿ½pÜq”ìSyz¤;¬9³ÌìÀ*ÿqþÁ…žô*÷;:ø¶R¡ÿ}þáŽjQZ.ôsÙó‘U‰à=oZ)æIü£]Å•Å™éL�²é[×z+‡óÑ ì~g©”&~Ë€Lz̳%}±7÷ÏÂÒö8¦í$쪡“·üñ}ÿжmA/9Ñ;_>„„;«C—õF“vâ+s´Ì«SRˆÂ¬š‚N’¿ŽsO'!3VäqàÂßéúË›îki•ùbxcK§Ï·j´$ûˆ’gžNaáÿú ô¶ãFk¢œþHíT?&s`µ¾n»ß&ÌYæ+†R¾<£ñk† )øéò¿ðÏ|ÉßSSZQg“Mèf8×í äŒÜ¿Š]á8ÅpAS}åLÒ•˜»Ê,'Y±™0]³;~!)ì.¡ÚpL°ÓìwÚ€ÀZ€ˆ·+טZÕ”_”ëkÄvÙ0ÕM&Šdáù”«?ymŽ6°–2D|]uŒâÞõj”T^hÊ°Š ^KÖ[ïØÒÌž›¥S·<sŒë6Á{Ô/Ûh‰Œíy_Ó—ìÿº2g%¾œ�`ùC´lÐæ›Uc xWôš4-âÌAc¡´ˆ¸rlq°æ©™ ‡uÿGò»w”îl­‹ÈCŸÕ±6n”ò)ª` ÄÍ;öص>yÃK™†46@±*Ù�§ØÎ&¢'³Sû?ˆça<¢F2Ompâr1”†¬Ê>õa§˜QAÜ.Ûý…ýãý‡&ï( ðªÀáQAÄšTTw '·ýÞ<þÙdÞ?¼Åa€©©r¦0ù(’'£ß†¾Äž©™ÙuŸ0ü'rN>T÷yò@fÇÓ¦é1ýÚšöüiSÍ8°Nj<hX!´> †KkuÏEò)ÆyLd–è-ÓñÛ³i9Ô_Rçi‘´9L²þ©k–™ƒ À´þI¿g¯ÿŠ¶Dºw£”ÜäºÝFü;èoðMoPó¯ßÑÆ냈œ+ÁC&L¹¡ [œ/Ã`гÂI¤ÿ³þP|Ýß­ió¥~\A÷›–ópòìîé ŒV={DþêbU M·hBô-§µgàTÓ[{ˆ7Ú1Þ�@ä}§‘ªd‹É}ðÕMGzzñxà*•*dwqÝ€JO‰œsËÃå{Åhù~ +-œú]wúØwgZø;hžë‹lcŸº°¤18ª sÑÀc`¿ZËWbCÒNˆœFXºierG÷þ%›õY ¢˜>O”º¤ëƒ4]·¥Íe´þêó+6lÂr«íÒ &JBObxU“²ÑŠëÚ3¦uÎ¥í…ÒñZ M¯ù¬yv…8h¥O6 Šcµ•9”M#ù&[¡d\<²Ø}ù1X÷˜¤ýx¢+›º—Ef•Q” m_O�£T§ø±Q2Úô´úZ œY*“:UÐÞÖ4Ë=›L|Ï h;¾Ðܸ£÷<>úÒiì6äã&:n�*ùê‡$ù.­õ==á°ë¼Æ¹;Ÿ.c=З—²P¸#öðfˆÒiŽÄe]É-éc3x0‰„‰öÑd?û‡ßáh_9ñšûú|ò{M¼`1ý­ýp¶‡soÖ»ðÌ[ÎÇ@áŸHÙEYì‹S ;ö ~ÖÞ¹“Óýô!­�T‡Eņo`~^é'Ìß‰Î2ôXÓ±Á9½¸1Ž2_úY_IÛi ËfZ¯zåî*¸äÉ#µF QeDx}¤–ˉÊÛBüe¹û‹lFÛ*|ø _q:2ýDõdmÍ 1ã¤\)Œþ…7ºŸ¾·4gRC—C áÇZ3ïƒ ]ŒH垸+´¾Aü­ºà·‘i¸ÌL²¡Øžüüx,‹éx=%¬™Õž@zÐ þàô¦æƒ_ýè·XrS¡cÊæ:›¢Uèý†÷IÆQ¸æ$búåÚBz º«–¹àcƒ¯ûn_VœJ±Ê›S”óQUHb¥þ½ÌÁ¡Ê]Ýv.ãÜI*Ë0fB>µ½ £B&T¡N³¥êù³û‹^Ó]Kc7RÈ°¡r¡l×–àÉàêM»Ð)Dkxpâ‹¥ £¢}1hبЃë>IPâôÆšQ mVâíH:Ê|M:.Ž]œÅÆC;r=ÜYØy€¦ úÙ†KŠÚ¤å)¦d¾Ó|Ç‘3Õ¦Œ±+MÅh>é¡-Jx#òŠOG ‚ áH­öžû¼•H ™#MEÄ ððlÔÕöÐn D!ßÃB#Ø Ó ]‰/سƒ ô)< „ ÇB€K‚öBÉäål¹Ýµ‘OrÊДÒ ÖÓ¨‰ü}~wGþ‡ÜNévòJE6eg¶dã ž 2vPá3ûéX»‹¡ü•DìÕk»ly>yÀ>žf_‹åÒ*­ÿf™Ó°§°ÖÉ$}¾ÉªÖ¾ðJâ#"ýì%Ά~0— Æ }‡Ñ~ÿ´Ù$™×Ñ Ðgûè¨8FŒÂ65e°î€üUÓ=÷ä_D‹ks¢@÷¹ñ$b¡&nÙáNÉôŽ¦©{¬ ÏYÍK)þŸÖÎ|‡zM‘Œ¾+z«ç¡;ae°&�‘ǦÏ~·ãî `¢ßƒÆãÄàq¢Ê ‡b¹õ§7\X´R¡þåtõnÞòÎßȽY)›”÷ ZìqÅ4Mtˆ4Y¸“¹ ˜AyâqbI1SÚQ³UöÓ nEDx÷þ•`²ÓôÎY¿% ÎëÒƒS›¤Pö=~€YïÖtÿ—O�4¶Ÿ+ôSܹ. ²îäå¨[àTåt^”ú,©E9 ñˆçN»½òA9‚.;p^p²`èá¯lx´â•)y¢Ç4‹8Ff›ÛeÒ {<¿{NëW1m«‚§ð±õùŒ,XÎ6S«?ÂÇ.{y˜±B'$r %a)€ÜóÕÉ�w‚·2waNâÕOÎÎP–tº¿±>Ã9·$[ìv’¡½èŽlqaD‚m+  ¯r- ­vçc€q»R^î®,\€“ÀÎ0Ä&Óq •¸ªc„‡Î j[*ÑC [?¶¥RÀ<Ê š(ejµtx´•8’mÄ&Èçrãö¬5[Q.U«ò¬¼½L;À•¾T´I˜BOøBQZ.È6CAôSû8ÏíÏé=á‹Áå¼€÷ Ìë´Ïr<@ã`AüÈŒUýûégž]QU¦ ÐÅOO&Ë–XG-d÷7½'«3+šÍ U9Žâzv½=�Ìëžj5'âí†8ì®P6 \5Xºt™ùI UØ>0,5Æ¢ƒøñC¡"÷†?žqâÙÞM–š…™×–†#ù–JÀ£blÒ\lB=ͽw|K–&é’/EixÎñúÛ3¬PW-“~EiŽ–u ¿»"ÈZ–Fsm?vGtcw¦%¿|¿²pœºYFÛÁûâÇ;Dçú<Ȥ»ß í$Íür²0šM‚qO«ù¢‹#¯P&éº:3ÜZmé5Tò Ö¡Ìié îŽì|€Œ@ Ž 7eÛµWfÂF!z¿×5“]í«ßr³,AÜ�·Ž7Ìš6\0ÁôÃJŸÑInìÁº:ÀQÉ⌮Qëõ ™—Ówy”›Þcn¯!!‚*Rdè6ËxñP÷œ™ÅÁ‡Ö•†Ä¤DQY®=ANg)=äâxòÚ4†Ì¦ø^ÑÝ—.׼ߗŒS<wpJy“££¤"Cßõ{Çùw`ÈXK‰¸ 9C…wÜxžÞ®ö0”æGJ¼¥Îßs1 ¨ö.[•jŽ™”Ó{‚B°Mã”zº›*ŠòÏaÓx¤7z7~|tœSäb`xG+éæGÊ'Îó¯×6€8ÏEáìRxµ)ÆŒ}Ó³Õ“áÊý9û‰¢ˆU”A.(­åê¨7{×,\5Í0õ–EòËþrVú‰rŒ¿‘SºÖS™•‘˜H(·®ìï½»ð¢å92(ù8Òçþn<\G”½6 nûæu1ŠŽŠj¡£¢{шµšiv«/”¦QónŸ$.³¥Oü¹.¨¦³I}Äê}SmŠeêi¸ã ¸ �zqBï çREFŒÆvô§˜¶ûä&ÑÀïCMʘÝõ'þÚÞ¿(»l˘èvÀBjmA»ñ°¯MZbª¹¦ùÔ4“Kt‰yØ Þ†íØÁ’(Ê¢¶åS§s!nøRÁ<Ò'Þº¶ã^³ÿú9Ø&ö¥ƒc3£Ù®=´Hx Û"~ÃÇ’`~¯.¾\TEyYF­áiDöךv)mâÃGƒ> ÔYí¬’zÃêL€}”0·ÙÆ-’r·ê+Pà‘Æ[UëúÌ<ózÅÒòü†ÖAí¢Y7S‹¹¥™ œZÕÆPí´{vK‘0œõ‰øÇF–¨ÊwfHØÝ*‚⤠¬ï€nswOÖW¥ˆÀ‰n}I|Ï*%óéÁ06­é‘ÛÆW„ñÞÊû·µà!î\øÚí® uXU¦ÇóçxÃ5…coR;Î+¸•áB/©B+JÄŽ­²×à)â®,ûÎ]IL·þš¶-UúQÚagÊ÷af»fÅAl®¨I*·øÌË5JÊlÉ”9B½rkÍG!KE„ýô÷gÀ&Ãå’t’Aƒ6¦¥®YFY²jžu@Ïq·ŸTìæW*´±£BVÆîܦìó•¥ÒúïŽ6W fJlˆ¹ÝZ;J=Œá?éGˆ+‡ÌA)Ž™ØœlÕm78Þ†Ç!&ª¢8ç¶È{ôær¡©ÅAL½-)á>ÑwÁ©dNÖÜè¡ZàÒƒK”áâKP¥vJÒ m:£ ƒï±Ã Ô<ýÅÄT9¹ø)¸±};QÄ*W œm«ÚºÃÆ–à<[§(iµ0T@)7‹èW„WÞ‚õ‘õæãLŸþÃiv´õž‚@U8üDΓ¤ŽU8è_(k4¤DnTYCøŸ²0æ]/^\òu}<dE±¡³姧»D™°ìxcÚ´U …g=îÌV›jQ”±5c|P¤£¼ZÏ~ÁlÍSg!Ä©x3Q0¨_%�C•s� É×Å<•Ãü>×¹È2)0K;¢¸³ÂTÜØvÝqu ÕvzF°2Ùh*T6 =_ØÚ÷ÞÞ:ŸX‹œÕ™þL;[lÿF8ŠÓ/Q á) qq%”0‹~Ñ\L“XY bgº§Õ–€©ˆvb�h4Ã@UïÁOµÑæá¹ÛdÁ¹;b-Ö8È'Oèáû^ˆ¯‚L‰óÆ1B0Á4Íá,¿âò쎴Çã¶õíí: 39ï@*ª±iÝõ»h’ÙÌìFZ#ö>jÁ‰ì˜SWHl,ŒéË’ úf VF~[žÅJ!$ÓûœM Ló Z\Ümºõ°³=K>&ÝüBù�’¹ˆ2Ĥ’Î:v¥²VJ­¶ôµ÷"^” 0TÌ�‰Û¦9 ýeØ yA‚vgSí_!è“pa ’È»óÁ‚1q|‹³Ò}\ä–¥¿ï:ÙºRä)2tÀ⠙מìì0Á6oOë’““Ým†Å:gŽ2CX«{ø u­‡µÀŒäX·-´ya¦œþ|>ìÏׇ~’y‹’ÏËË!§ti̧–ôP&§{,rê³WÆ`ÞQÄIRÛÙdK(åA:LN¥Id‘1nW€ö¸kmå]ÿ3èUá`™lð9tô÷«—%L¹ßääîþ)Î׺å©`Á¶¥E¼ÑÁRÄ–ü|8ØaRì<z·§¦<š¯qtod ¡Z Ì´ã& <%cËHg8ïaYœY|·î^s6h¤(}cA8®é„À„'ýùt5ü±£“óðÕYSö±>rûâ«C§†›Žµ�B^Îeß18G8ïzÈ[{V,*Ìf_Ò»ò•”0©æÉ Ý[‘Æü U‹—;«³ôÏŽ;¶O@Õ±ZiÈ–¢ù÷ c´{X„ªô â R=Ñ;füŠ”dìÓ*l‰ÑðÿÐoГ”T7=ÈjÍ×7†³Š9¬rŽ&êÐ7˜}eD•^+©GQ좔Ïa™À¦c‘…N²µ”ÙÈôþôžö´âÊŸ|P©6ÍY67²êw½U:²ÛðÞ•rìokÂB§ ¯*t+¡¤»U×-4W7‡¶­í„ƒc¸šŸ1{Þ¬È=µ5¶PŸò$(fE~ã½Ï`¸;“=þ‘#IÛÁ{Çè<ƒêDqœ.ü%aˀɵ|‰}w€cô¢'³çénxϨ!vmá—5[T7moŒhÐO[J¾ëcTºtAÖ%#£ÏÙÅŒ–ÂäÓÕRò—ØÀ4Ž¢4r”*‰éÓ}~š ê;:ON}ýa]Ó?L’’G` Õ]{ßÇ÷-ÚÔ³úåó3D‘’Z Ç%g†6AÀXÅ„ÿÇSúÇ“8UK®ø´¡±Ðò,yöóz„w;?ëÕ×Ä€kl<ÚÜ»^èÞ¥IÍ®Õo¬ì¦Œª`ð0ã¡7ŠD g[)OS‡wu¿ÔâHâ̳¦=€s6kµ_Ó[Áev.?ÿèœuî$©éÀpÐÿ:Qc:îà³öÇ/c…ËÔ«{‚ëO9k;ÿ·<øïG©ä;ôp·Ë¸ì½æp'y‘y¨hZ—ÝÜŒûÆt÷'4[謓‡@PѬõ¸:õýÁôR‘«Š".¼BŠý#ìƼQÁà™np§v×ÑC6Ò6óxwÉúQ¡n•qF:ÊuÊúäÉx¤;çØÑ÷ ƒ¿j$•GwD;tð”ECÍ©q#hfZ“+»ô|Y÷VõÍþÀºžúCêcôÞhN…©P®‡þz!í¬¢6ËzX-uô„Ž´tð[¦ÈiÚ¢K¬¯o'HYžùžTX31mV=( æ#ß#zeðx3ë$LK`Æ óõ83#ÉÒ ªè̪Áí²©~«ß2³$ó}«)Œn”£gMã±1Ô¤^Fi AF@ìß5È1ä|§¬ˆép_åçÑë± V-ÇX ˆÍ"Rl@Ä-äÈò¼Ã’§¥ãÜän`Ç]4:Œ÷ƒÅ­½IL’åÞСջ]$À…‹…f:}Á }µAç ðçß]¹©/|79^M�Îr/Ý%oLC2 ßŽ7ÌÖÀ¤ª‘ö}³Ÿ¿n@`±F¨݈|Ü]Ýqû+âÜvÁXÒbžÒ n-"c‡Õ™mÇ<�ýoÊðÚál4)훺ñt_ºãtØk)ú[ÙGZÍÍàj$ƒLÑfŠÜ7Üø‚4ô°á›ñƒ”K`Œ#ؘ žžGíwZ¸û9<¯ØºÙãíæœK8¨Ì3ÌÙ¤½®^u“TÉŒ¤¢åÿŒ){"uâ&¨W1Í®Q7mëapáä ÔËù|W°9Eà®Ï^¥uD²Á)�å`ƒ•¤»çy›i£27^Âl8}ª˜½ÔzhoRÇû‡œ¿öœö±³)úëeˆ5â<1eÿ«iw&}�XìÓB7d¦Úäb+oùËŸ( d‘³¶È9ºR½–ÛñûÜõˆdˆ¿3€Š’ˆ³É´©éÔ@§s«fù“—Ç¡Árg0ÞZ9MØŠ}Š¸ Lø‹†`’/` 0æ„iW㕶{î�; Â*…[ç€ÝÑÈd?¯R¿¥†bª¦ŒõäO¬<¬+6pwž D b€¹#lHp΃ꢳƒu}ê¿ÀÑ5¼ ƒyÖ®q ø­6„ãV¦ã0´ ºÆ‰Cà8™åÐòÌ€>@å}–çY«ˆÐ¤aóD{*ëŽv ž¾a×mYÖvü•îcjùŒ"üX²=p1¨`A.Vì†Ø¤©…°m¼qÇôd›ë‰û›lÆÌœÿ€|?m=ïQº¥*³‹ÄµHæ‰-Oâ+1ò9Ûαgªr¨¿ÌÓE?Ÿs?ee-êWü®×Ý6Ë”n0Š¼-ê1btýÇŠ7ÔÎn§¦Ff|š- ÅNˆÛ.ÖUIJ·TÀÒº ¾éåØùæô ®7ôw:ñ6˜œ¡£þaM׺Hp÷—Hk™§L@!Ÿ’Õp«¾Ï�ª5'Ó•´ºðõ]™Åùjî¡wbl­c_’–Õq( xÚÙÐá%žzšÒÝA ;iÎÐSi m—éÊ?uì°©C™NëjFüp4wk{Ò¼ëîžå€sdƒfö¨â~%ûÃÔøýß›[ ¶"Ém=í‘<sjîÙÒ•ô/¦Ì×*ÂÉ@èF³‹ØÎ)¶œäíÐc™y 7rO$¶òš±•»"ˆlôˆE5VLŽŒ«Å–;̶úƒën0ZC×rUy¼0‘, ÀE©×çÚzÉ3 v5ZWVuë-M,õ̉Ä_&¨OšÙœX¼f,kõÖ(/ÇÔ€»¸=+p™—ûéGæƒí ¦Ã_oì½`x²×Û�þȪtèÇ>9@?f¨Y<„™ÏÈæØv*ëú’ÕPV™Gìfý$¨†o›¤¬`ù‡û½•zxÏ/>ñ5f0Øìé}í|šE_ìƒ5Ûå ¯g¬ˆyy@ ¯g4î¢ÏÎë4ŒÝ¦Vº2ßè× “Ä(duŸlÛyônáã|çä÷ŸÊ�—(ÓõóšK«ª2H(“à® XÄÑ63¢+oRÉÒÂû¢Z}¢û>÷ž})ëÿ`à·QEŠZ÷T‘ª§’›Û ž[,{Õo÷7{þ‹íúG#%ñ¶õ‹¼¨ÆÙlOUÖ¨°_.\4Y<§åÈg~ÌO´ž¶lhDn?ÛC÷H |ŸŒ„Ó]ÉZ¥¨‹†7¢šk�7³ÐñpKy"}÷V»O7!Ë„XwœÎÅqOÁ1m‹(¹öèFkí2±+ Œ6ÝEÿO+øcÄhÊ  .;“`ácÿK[ÔÌWV¥µµÂ9^þl½sâÐï}”äK …J£‡Šf;ûÝb.°¿÷l°7X@„á<>½ºc]ŒûÇYÊgâ¾÷Ý­Çn¼ ö)~4}ýççàw„££$Y Åb.š>M†™ €²i>ÉðQ„YûÊZ.÷ô$Õ÷b×n¸ð‘¨ÐoÀ†2ÅŽ’jXÅýŽÃwôŸª\4ƒA'}òšB5#ŒN$¯âñ´i.æß›qGéw®"þŠ lOÞ3¿cߘÑ|ýá Œ—åOôáëa^²u¼<^*šv�q£$Å”µÉ[GåþÇèÐä TDª®‚ª×NÊtz¸¿Ú?ÕQ³ƒ›Å5 8+B£a&“p3™d{ÚtãADÿûA[ØûagKd7ëx=üˆÂb¡–kE»‡BpäøGTeJW¯¯ z<Váõ‘ Pì÷'xýô}žQv¸öŒ_)íÜé2p¸°èÚ;¨¨Ä¦>|° 2…Ù£"gâZØ£ŒÈ3+~s \bÏ [UåÔ1²$“Ýô´Š’ã¹ýô½×³9œ¸D•öÄß?6¥ó´±ôÐy“ø‘¤YJ÷@xe9ËþLtJ&[­fá%|˜g[à7õJÀÈÎÍòêG V×Hà yìiY®ÿ*óEP$my»þN(ö€¿« õZZýó¸RîÐêt´¼ë' ׸L+†[ ‚µéO‘vh íw†• ’ cw~eãr:¶ƒmÚÌÛÃtâ:yžÍó½5È{ÜèÊcÅ%©”ÙöHŸ­¸$Ìa(´ó”ã::5>èߣÀ·"Æ+'J²Œ/„Òv²ú¨Æ¢EÔ‹ì=çÐréÈú¦�‰bºÞ.Ú ç®ë)dJ\Ðøù/⨠ÙÂØDìƒ.‰e«s<Ò¾ªúî¼›î÷æÒ,ó$ûÀa¥8²ƒLˆ^5ïìfûú˜Ä‡úÝZìÕ¬6ÑtÒŒk·FѸl-`ÿWb-i¶0”ª‚q'"}¾9¤ÆÕ–µZL rD®7J›ü… ƒ!µª)N÷sÄNÿŒÃØ‹V0&ù3}Äê~¦|Æü‘2íR÷ˆ¬3Ç›C3y(ƒÜ†iøqÕs!¨' ººîe(ƒ_=ðVª*?› ±ÚCeEÏ° ÚžT LZ¯w½±æ¾©™eVù"HV·iN…L㉟rnjŽ•gþÊŠ5G`"T³ªµØ§´Å#ÏÌå9Û K[!ò¹1øF#ßG?/›¶•—«´´XüЌ݊áÿ¾VT’ù;Âp„2‚ð[“ë†nš€ÛŒ]`D‡«–éÇÝ(%­ÿï°J_Ü™sQ¼T‹˜ÎÄ^”ï(Ö#—}¨ ¨÷„°íážCÞy¤@Ÿ5ŸŽÖqb‹Êv ‹KËïPò'œx.…>¤ ²sÔ‹Ç>´¹åÞ Ãåû ŸlúæÐÒ׉‚÷šþqäè-ìPÒ�çÝkEž'ÀÖÐÿùÖÒÔ&LËy€üæ„4Ì\G¾yJ0ãëÎî…Ôð_1³Ì÷z¨QæKcDÚQêT»™K)™˜{OïI4×ÂÙWc ½á¬ýLtÀ»¢ÍtBÿ­ÿ }]7Û§:˜RË~×Ö¶‹úæý*=2ç„0½íh�S.`+Ü÷<*lí­Ët,ƒt«¡xUuëÔB±£<„ÒñiËœúÞ|üù¯^ÀçS—ÑÜt–Ói*9A}¬ú®§sMbçîüez5w¤4< g sN ØŽÈSÖÇï;Kdþ5ç?öœY¿{ )E:›½v3ÔU7¶WCg|Ç;æÝ©jäs +QåE9¡’fYQã¯\„ggo’†V»¯~ö½Ðè§& R»!_ÐÖ P{‘ð¡‡.b§b_ö„ Jø�.°õ~ïwûŽ“ƒÄ`ÿ/ÎHö‚÷TÉÿ;…u鉚± Í”çAôùíZoëÚR/eR‚â_àâï¢l£2\’ÀW?íÄ'¬f0|4 mLõz /賤W?žxаTHŽ´‰¢lYO‡|%�–TvšþkȘ‰ t‘ê8zŽä,¾ÿÑtÊ¡v ‘w©#2OðùÇp>ÊúÚ붶PIÞ0>²Í`ƒ…¤u’àÍZ„Uc¡ÇûzÃ}¨ç€|¦ƒÚ²’¹¦,"ŸÔÛ‘}Òp÷ÜpK ¿;î0AëY¯°Í=œ"c‰VkŠÆr“U¥®ïiq³ã7fã¹> LÙÛšnà»áŽ2š±æTçô -r-3¹Âl¦OÒNÓÂg ßëa2 ¨cOœ­u3æIq“¦üüÕT–%= EøØanÕß-*ŠHšP�>…ÏEª»Ë%J$ur2ˆ:×t뛋² 1¾Y`¿eý.fqèè ŽVž÷Þ%Ê[wç±S©¼Ý@¸ù[‘™h£NnbÖµg`ÆÁ´Ê/€³\Bhqð»U¦v ﱑKkØgWG]Pü„@¥<„ÿ~$©—at€ôcl±êx3+ó¤FYÕ;h¨âNª_nˆò]ÄÓ'ß{÷,v#t‘ÜëÒ0H~jOã˜öh F·áÂ]\þ÷±/’ÐÕ¥zL„o—åAhbLL‡zê´b§Šáéyy,~ ÖÒ~€ðqvζò3Ü“¾wuû¤«ÌçGÈñVZk锑ÇñæÏþ‡…Ôí豫ìEç 2'j#üOÊ|C§7•°ZçsºaÅà·QSôög¸–3Œ ¼¦ëˆÚÔͪªô`J#3»R ÏR8ã^vÑøÌŽNCnUõ½;Sèè/ÌF~\í¿8O{ƒU±Ð¯æ¦höù¸ñÈ_»^Øy6ï¥ÔÑðõÞœ:…žÖ£ÁVë„ÖÒQµòSÙ¢“üJ³úÑu˜©èC×£Eȶ ·Ï áÓ*ïž#S”§O¯BÜpË•wè?7¤*³…›.ÝÃta¢Z%%> <óÌT=ÞŸê-XÒ`}Õôȃ=íβûTO¡øj@(÷³[Q1½ÒŒb×ÛàBŒ!Ë`Dfð¡±èx‹»¡1`ìêI5)t›'×#R–²){]g‚¶Z}¹‘Ø3­:ÓŠÌy1Ìòr6ùtiÒ–?÷-lÃolvÌÇ`Ø`È5b”w§Ð­*´Âzü‹O x*Þ¦ÊAÎ1‰ˆôü^9šd©oWÊB¬twòqò˜V@»‹[ðz1]¦Gq6|Áfú ¬!OòoÂÑ,¤õ¿|îsžÜ/v9¸…TsN[§´LENo}Ê)W;3@¤q®~|è%ùÊXÀã¨Ø@T%ûΟê¦àÿ­ÿ_'vd 'ÔfýÆÀ¡aT;¢M%ý=©ÞÞ@ 9Z+tÒ½š'ZÂáºS‘»ðÎŒæ ›(Î3ÖOÇßöH¹S£fèžp ÷€†©žÜÊXѽ>¤w8iíX D e…½:ì×P?’ðànÿoDîéj<”ÈéoÌߺš75C )0lôÙ¤pIœ2ö}ã¡n¶{†ÿOžOϱ¦cç«Öá=Kïòþ“Vø_¤3- ï[Éb´Èžè…�ò§c’˜\á+¨4‡ßiçªâDq7{päýa˜´æäˆÞ‘%Š¢…O�­É¦È‚b®¼ëMf CÿF�?NCƒzîL›k´¨Ø»Ø™Ä?¼C#±Ì ý·6ä‰Ö«1‹ù†9žYPì4JÆ€3çÚŽ^³®w&ÒûÏü)ÌÐW«f¿Âv[å¬üLx26cæ¡ÙBdÕ*z‚”ѽp2®<" ›·¤‰õÖ̦Þ9ŠÝ†Òþ$'8_0YÍê+ìMä©)G†«qìhÑÒY®ý‰ÉÓøò}0Þ6ň•>h)Cã*nÛÞ—$Ùà“•ÇmázÒxÿú;J$^tîÑFµ\@¯dr«ÒtÝQ«Gßó_áHŒÝ½c(sO¦ìGOæõÐ[S±×¢ßÖºÚ 9!ÙI9ÔìÓYYDeAøU¼²P.õOg ÙZµ?åÒ£FŒúôh²…·7 U&‹µÝÚC|<©î¨XÏ#h'å¯nLæó͸nï~À4´UŒaY_†a¡Ž"óµc ³(”è~‡JlAh‰ÈCXÞ·Ý!‹b“ç©É*'KÞ¿w¦QQº3Ë‘NÒ*¨ìŒèÑ£ ôRÁV"gè]ÑGîÚý‰î¼°-€£Œ2y_ÞoÈ*°]©åø·‘ʯ±¬}·QÖ,1‰¤OyÜ8³ˆ¹¾ô‡q Åz±!°;XVp4·¼’Š?Xƒo?]Ê=ÄËÇ|9_¦Ã†¯í¥ MA1@…¸½€£L\Ã-2pèÀ_4A‰ê@l%õ¡ t‚ê?N»'C]VþðŽbUGû ð0hL¡OÑïVõ•è*ýµBÙ±-ù%ÓŽ Ûw­iUg«í™…Uƒºk¿ÞÏxW ]¿rTu"\Äà¾ÆÖ=â$>gmñ{€Ô|³ í­ AŽa7ñ¹/ ÷;µ—(©l+AʲþD¡i]ŠÒÐq´û«Ž%aÒVòIüU@Î}ÎuÎdý/>=Mð+¨mgá²î:ü`ü°Õ1ìa½6b:»µj´ µ^†&˜KÓ¯erÿÊ"ÓŸafÈ ˜²–v½‡¬ÃÂü¶Záš™ø~t’Ñ¡9È„1^N\±¬˜î¶>¿S-}UBèŠÂãÃú·p×q¬Ñpg…±Þ Iëqí#6>ÝÀÂàsð<V¦¹†‡“̨œd€Ü…¨d.fB7âbeœyb°åë³$(·ƒ•.½ ëõ…Y¿N°jÜ&—Ï}OQzÀÁ¶k[û ´‚g¬È§ßîH_)úþv˜Š?»/»¬žg™ÔÙ×}¾QÎè"Î`=Ú ^(ôø.[–غ“‚7ܼ=ü»%DXð¼¦èûì[´¥Ž3Í#NÜ»ºõˆ©Ò¤Èm*�¢Ú™nô…íp”ÿWs·§¿ƒID7Øø<ÒŠâ³Ö­¡ÂΊD{b5WA4Ÿ<¬qs›î5 ôõJm1Çó37…m[ÊDãy4ljâR,W–QJ°myàâßûÞÕ­ä—ÓÒÍ!²§ÚÉ5kŽ»u:ÐjÆàê;\2?XªN$h79ý­áÓ“˜è¬‹”€&•¼»wyÃÈ—:¡`П#zäõÙëèàò ¥ˆqǽ¬4ªœ*˜zAßQn3hŽ„TE)!Gg&ݹÊŒ‚˜Ñ9Ý"¶á’û`òàë$†C´F· ü¶Ìhã®)Ôíº#0¿6]ü ¯wD8ÊÊ­£ÎI‚¶/Ø]5Ž9ôïÝ )*ŒþLFÚ²Õžýý„¹›ÈÍPˆÚY3{‰Ý,Œ)9Ìå€'8n89¡tr§ÃÂ;ÉÚþ¾X™QîèŒwsÐî‹ èÔy÷Ï>ò¥ãéžBcúpªåoïc–°ª2)Fòô5¬„M‡štâ`5£$k›Ü›E¾/» 8ßòO¿¡¥(ycxjÎU;y#çê½ùlî|Fèð‡AŸÙ})Ã’‘Ú[Ñ‹Ûs!6çm]ÙVÏ&qÑ–2“̺ÇÒ0¾½¾ƒ=Œ "alE ùVí´ãs«÷iµæ¯–mDɇ †A¨ÖŸ¬5¿ zÒ Ãׯ_™OE…ÓjØæ¤Uÿ£o\r cF`ÇN#lz.“›1¾j¯¦\A¹­Úo»oÙi°8Û_òm‹ØRc±"éЇn[×{€F+5r+jì÷á/™‰×È”BVkyT°0Õ†rhÚü $0Åçà„?çÝ2@®¯ty’ët~8¦ilÅ;ÊÙÎÚð¶Ñ`u¦w©Ùnz]wîÛiéò l9¥�isñœR�b&c{u¿ÓõŽæß”ä¡>`òI[»sŸ´ÅÓ]·t©ª5“¦›QrºÔ †ÛÔN½Rѧ¿æƒÎ ›Ã†í+»ÍnbykdK¦eX¸¶ Šø/ Ö{C§³rá¿Â¡0qê÷þ°×Äw–hä•‚¡q;×hÕ}w.i¤Up,h` R,}:8Ńz4òB/}¿ùô¢D;¬›Ýðs¬w=&3rg:…]ƒ0½ûýíé¥/ŸCôŸ"wëœm×Æ…$¶ù—ºY=øòQY-$])¾ÍyPôÞ°§¡Ú] 7_‹%:¾Ð>rW·Fªq´¸9 "ö´0ÓF¡Mß5†û`Î�ÌsŒ¥!ca  û®N_û²¤ð&ÞÒq8fXŽ¦2e…»Iq’‡ƒ8eŠÃ" "üj3¥}ùÈCg²© %\ñÑçBP¢´°wÒ›ï÷\ŠÊáÔ¸>ÞþÐÝ©oot? XÁD8ã@ŽÃ¾5þÍ7IRØôM÷äÒãQïÎàƒNè,V½¹©¾ *Ïb“…ô†Žòždû׶øSH;âèS¬”ÚüZ Uá•íøjpô2x„ÑÉÚåÎèëãŽý‡çíeü˜/ãúë=(„‘‘,‚¹…@åçÙc¦MÙª{f$*'€£9ïÿ‰þo>w]{ýñï#¹:9`8³u H%À™‰W‘iK(›Ä¿¾MÕ«b1<dåL©D4ý59îæpFÃÀŒÞ|ˆ}v¬ÀŽ_jîMÙfÿíÿʃ °OÁHÅn:ê|!Kë+m ¤¸~õvEr¸ý& ÒïÁÅUæ5ê$¡éÖÉ‘©Rœw\Qn’|éKg$ü Æ‹†OÐͱÅaÀOú0UEÚ^©Âí+^7UMÉ0ÀúÜï&“æ¾6¸sZ­…‘8ŽQ”[ÅÃd¹4b/v0ü¨gìzÇeìz@‘Ø£ }ékjÑÏ™ëð‰÷®®1‹‹©{΂TàsLžxíåÏa,iêYÁRöàúô¬À<Ã08é.¶®`œÐàY£šs¾Ó 2Ú&¶&¶æ³—…“Zoé‚ÓÚZ½#dbqKùÈšÞö8x¼yf²ú;wIÞk¥•Õ÷«˜é £ Þ+&„©ê9CšÄéÞÕý|?\ƒ�ÀKÁ·øQ¶$¤ë·õß®R›×+zËÉ8¸ü’Ä®ÅèšaÉWÃ_­Ÿ kÀnÛdwäM^ ,¬UrfTo("“/Ô^¾¨ždÖÊbÀó»¸çÊ4j"…´M3æÑz6# ø&ôÀc™Ût+iy›‘{JÀ]A÷›akErŒ€R={¾6ôÃB¯æE t¿ÓJ]†"î›[íxbÒ¡_x~Rh›SF´¾(¨+äÞQ}Z[‚¦A×®0Ôe»X9tcQñxïÌS*I.“VÇ<›Ãab„’…LÆi.o°3[5ä–ŸT°ovbaŸM k¢Ýp°UÓ òQ·x(YAÏ*\˜°7U™– ìnе­¡ø˜žSW³=És3îÈ*ÆF·g] n=*Ýæ|iG·mNGSh€‘ ÕÕ+›Í]‡¦vãúÛó{§ój=;ÛÖ_KÃ¥¾Æ¤»‚ýÆ‘5o†HÃn߉*éšjŽ2Ýé_(ö1[ØŸ¡…Ð|N ª¡.Þ°{g<þtŠöÏY÷ö›ÿ(8£ã˜Z ^²èØæ¦ ._oèIvš¾m\ žþ:ÿ±ƒIžÕZ>¡9(t·'@L;#‚ÖKh§™¡Ö baV™Íµ¯)¸¬Ç BÕG{ØÐ/úI 9œâÏ9:QZ¹»”ÉЂNÅQá/™ØƒÕ£˜Î©†ñ×ï]]߬Â5ÛX „B ¥Q]çÙ2â®Ýçßôb_ ¿"¬T¢”·¶Ó s?6ùµê›wU8#/‡†éÙ•œà˜C0'–]úsnëÕ×p7? ›ŸŠlÖ¹N‚üSáåÈ™è\^™„iÜý<&-yDQè£t L¹§„ŒôròL¬Y(íûéøX‚‡‰mˆ ÏÙ×é#’²2´†÷”- gœÏŠ‰Ìy.@Š¬è+Ÿ‹6¥ªƒÁŠ6<&žó o>½rÚÝVæßYhsËÀwO¡ þLï»sQÛðsÁþùœ5Šôãgf *Þ†ß~‚„.Óû7Ö†Ö=CL]c8\¡´_[§TqéFHšJ§…=³®þq®¡d¨€\G8¯GÓCDÃoßõž§è¶»pJ¥¯ÏòŠ([TôëÖƒ3v P"[=ö”µ‰žÖ¯g|q¸Û‡5ãž"×V„¯ô›4^AŽö j'V.¿£‹‘ç™] ƒÝ<¤ŸÉëJžÀ GÏ>PV•5 Ì«tˆ)wIö>…DÂÝt¸­Æ¶åát|=ú7:éqå¹Ïeh!B:QåX=§4* ëËòK#iGgu';=ÿ‘�kkê&øôBaš׿?»VÙhô"ÛI9ê”(œ†nÛ¥Zæ3Ñ̸\\PJl8½+‘GÀ mbù’@‘Ò™² vj8W”e[] Ørá|×Ö¦3Ô{Á†‰Öf­°qt“Ó2Ò9’ø+ÜXëåðÖ˜ßJ‰Ð?mžž¡@ƒ%óXtˆk& ˜L /MŸT Ñ“päK Ó¡ÎÛ'Ü(ô<ôÒnpö¿Ø;‘“ÚyéÓÛZw:,ïö4cgÃÃápdû]á ]¿^)«ؚ4NB$Ú1†˜gÍ™–u&O€ùã|&‘™õæìör‹.rÛIÎóX±±¯%°Ê3ˆ6—oÇ'Û[ïê|Ym!{û`¿AÀt¹a¤÷ÍêÙ,˜æÀ”WZw]Ôôð^ç´gæEzžµQ$¤ÕôGw ŠyÛõwœUQä—Q)N(é#Ö%ªày€2|8oŒvþÐ>»P~‹¶e(Øv½i߸ ¶±WÅ°ë×; §zI'& VçŒ%Ÿbûa=ç žf�/YWᙫmç®þ-q–Jˆ:kû Óp8Ó¢8ÚîÚk“5.gTiœP8É‚Ò’lcÑe§4qç”XF¨™\Ì$qñ¸Ü¡¼Uêt7]À«UH+E#7><¨Œ·~ÌïÊ€V™ï9XC ø¬=š |:Ï6hÚíeŸJòË•„y]ºf¹ŸGG ,Í‚t´Ö}±à¢Yç»Þ „껶q{ÅFL–TVªê¾tF·Ô½S䎇 {¹®àóUãZ¿ÊnÐþvÔÍ0ç2Ýòíü‡b>¶CÑ‹ó˜y¨Hˆ‡qsë‰Ò–•?,cåŒÒÔÎãañšàŽÌ/XuÜVšÕ?#Ê‹º£•ê`TÃ( ÕkŽôç¾* —’½Ð>i’ƒØxiëþW€çÌwòÒ÷0T˜;«u_¢hC=ïܲç£zõûÀ¾Þ#{è*¶Ö tvdŸê†b³Ê`½›ÿÖ½õNà™±®“åOw0¶©±Û‘ÖNÚj—iìZQ‚;ºtº"n èw"Æ©r–?!zêP17˜§ùLwë[Û䛺ojßæ σú´9MóÉŠ6qõ']:*':ï<éÈuæ˜ØŸ² OÍ… }e­8H©Ž½%Œ² ,óàŸ@­´îð-ýɤ¿xàá3…üùUVð”ã(ÿ£+xIÔ~õŸ`­dZèqhÜйH.*ê %¡sÿFr»ÍAô¶m‹'3¥8ôÑõš�¿==xD/ “™‚'z¶ŠD˜‡Ò­ÞÃâq⊩?ϼ_¼¬yF¨mËf‚ÎÏ8yàö5°ú‰Ðx3ÒÿM§c7þo_ÛZç±”­³gI™øí–nnñ˜¤Të“»h‰kìD¶l‡º\Kw4©kO _ %.ìÃÒwâ7‰Èç]?ñŽ.–>¢¨>“<(·.à-…ñ`QèH" m«¯Ï[ì¹—£óP°ï0½¯•†óRö:»ë±ÕtV¿øÀÉ»·øá"ò}îè.!FR:d Aô¿ÞÕ—G(Íèÿ>À÷B~Ö«%Ïp¡MlÀœÙ·oy$Ö¢ZóÿV<. }j, ó: Â^§¿Ç/T·‚è„I—t¹ÇŽ~­/žÜqXš~Ѧ§»nÔ—>a)n->i­M2z•WzćS{GDÏi4æÆ{)+žJ±Â¤dæLjõQ0¯ô+âx8Ãù{Lƒb>¹×f‡f¾7cŸ©îwreÝE½+_ÐE‹Ïi¤ÛÚÕ ™©Ó0\à'vqåþÌýËëN_æ\DÉ¥¡ÕœÝî0S¤îê0»úù=ù¥"qJj cØá\4(TH?SšÅbÄh;Äb;³¥LáxÛn6zзšªQžûÍJq{píT+„Èz\Õ-ÕR|J+K˜NŽp#7¿Yô¤}rYfá¦̻ϵ/äÖõ7 Ý'RñyåÃt²SyÓ¨ [‘ôôÀN?¿¦åfуì[“ztLºý+kyMŸÜh8Ø+^'{¡ª)ºÏr CFàE’~j@‡†Æ†>³ƒªÍŠ¤º‡n¨O ²¯~òÉÐìdAøkŽƒl­A63ò©tç™&i>ö]ñ—÷aò…ª*Ýú¶FþiùötûGFý[­?ˆ<Ýâê>2=‰r?˜³p‡O3òÕ*@¸”%[¦<É® æÎ…Ýv°zâ�0£}ëŒ~ãȵóËÌ#Ž|¢)ô}@À¶3èVv¬~&Ž4¡3½WZq¶€›Q»m¤c>ÊG—¤/fìVaÎ槼5Õ£dr2#DdßÿýPÙ‰\ ¨BÚTõ°Å£¥k6ŤP‘y»½ZýÖìÐÐÛ@ƒábw¯çÅ¿¼¿nš3<4ɼCŽ¥Õ8§íÚjæÑ1ÚZ® HÍïÊ· âôõÆå%µ‡¶ºb Ú»–'uø팗mãصÎ#FgõÐ\L¿×½‡g !œ‰6ô¸Íèg8C#Àüx›¹qš« òA•€2L¶ög÷PC~^’Р“ ‹­nŸ"RiÎÚäu”˜vô{"öž^©´üeQ½æ"ľëÍÉVMÿï©_øòxvsbk M(ÔžŒj48þëqÇ ÇUm°FKƤmVX&N½Ñ7+W0ŒZkÚ‹gÑ‚?û'8~$…Ï „0.Ú¿Uc}.1 òleíŸýÀÐh$-ÿÐçуqmì2h†¢"G3á¦ç7]öÍÎÉ÷ã»L=þЯlÉ n�›ç [±"võó×sU˜EÆ2± ƒ_tÏÌR‚ôÏ”GÖÚ§ÛïÄóL±j©HOªwPàSö*õ¬ø$Y 9>n=¤#¯%ßêêtÆ ÀÕͱÙB ËjKÆ›ƒq¦™Žšî±Ô¿ôpÞ¹6÷Ê|‹ ©ÈÐåt|ÕÐ8 t_˜ç€^®´ž#Á£ÿ$qæ{óÅ ß©‚´þ´Ì²ESÍ™PÚ§' žÐWS wßÑ-™ÔdD˜)þövx×ï,ß^qU/éÀá•RÁîÅÔ;Øg½Ž-øÌb¡qÆXÁ*¾Ì ጊBn/hf¾(õ% âÁ:¨–°Ûš¼ÃŽ©^裈FBÇÞn7¿‚ÔÒo0÷ÜÐr§:B~s2YlÃŒ‹½.Vª6›C{¹ÆòðQÂXÓÛVøö…a„»™‹NÑ<“ri÷›¥óæ-2JAXYk}PÅ*s]3Œ_qÔ“Ru,*£(Ø `ò·Ú‡È…g:{Ú"/µcENpÛžn÷¼¦ f[“LÝGÇ=m:ØWÊFLç‹O÷•câóö‡>â4™ME6ˆQÚ3"š´^³rrƒó¨Í’j°e£Û˜AQqk§‡^E8ïâyîüîºÔwXTÑâÈ©(©‚¸S&1¦õ^ä.cÒÕÐ.3âoWÃ;’éÒ,/awÜòSQCÄ£WÿÕÎk%þÂ×Îx V’T•ƒ¢Ã*4›èÇ«ð_¦P´aåþæ²€’1‘j2e€ËÆG€©»{žbo»#u* QÄW‘㫸ÿëÙP8ö:xøå�+s2�.:š¶^FÆ.˜tCÄ?õp˜——{"óY‘-éÿ €¦ÑÏ_¯w‹^ØNÓ |ïýk Xô½ÄX‡²›ðçèJ™…Ôº&þáŒ0É€\¶AC+ÀÚóV,j…$½¦ZxŽfO—ä-Q M‡Z#.Ð%”Õ²ý¼Üˆ%‹ú™ÚŽVdìHéKC%ü zN C ‡¶æ ÞÜšzµÒÁ†w¹½ -ÚXËóȳfcNdÂFí] ˜5]V0ͶˆËeÜ€áM·úºe¶•PPäw¸i­bõÈ÷¦k`âÁ³^‚œ¤M“QaA±ªüÙ&‹…b8¡ø†uô)´Ý6·Ã§ÿÚ«fÌÎ<Òa{´Ð…PD…I¦¿«ñÓ]<™ »¦"·¼"Œw(®|n­þ_V:¯1ªã]«3`ÕÛÒÚ£Ÿ#ÊÊÍq&j ðW‡2É°�*;S,]g›Ã$¥ÙÕëRv1¼ö=œ~¦„GúH×døt[¨Jœ¹Îýîw™:ÇQá·óŒø¨€hà�WJöýïGZ˜Ì*¾Rk='Î*—ÕšmŽC¿ž\7°ÆÚ·òøi±|±§|ê‹ ˆÂ½å9¯œËÚã2Ž‡cJvÿòºýçiÄ:—QØ^\“ñÜqW9îà<¼)уy‘cp‡.S£3ÖÂй¿ê·žp8èamj:<Šcu{ºñ·(¼ ˆOBZ!ÆkM# ,—c`}¸ëæ‰Ï;¢´jõ'¡ÑמTæ¶8é»ÚÈE¢^¼þñWyb6T:ñ¼Šº ßþ¨Øhºâ²gØQ©Îì•÷ÊçH…ÅLrÛÒ2Hj}_zÆÆCL¹†;%1èí sYÉ›Å^±ìpRf&F*ÂÀ".Œõå‰öKä©ñ™ÓlãÕvä\(Eª îè?ÖžñÀÇÓÈç5ÿ‰K^ÁÛóŒ“&?Y[ ™º¦¡s’u{ôh¯‡‹Þ¼šŽò ±.[X•Rt¤´! ªÉšþ ¥øã6«XƒIëìê§û@Oa˜cŒ ÍDw¼øôóvKÌVFàrñjˆ_VÙ2à�*‘ukϵg{8[™½Õ Ê4rÃ_ñ<’xáý$,½nWÖ›×)¦*NãÝÞ›.…è±v?0¸ÿ™]@0ꃂö>w`Rì²:£ÙÿÌ°òºÝÜœ>‚ÐV8KKQ5êä ¯žè?Eé«×Ã`†Å“Žµür-¨¬Þ—Û'¯Ü`„uû*ˆÚÞ“Ü:2fyr‘ö¹ÄDdü$ZXœ@Yá,Ä̤cöÿ${Ê=_«6E¬È¶ YÒ+š”V̬ˆIÛì‘â«žõmÄÌ=ö=ï¨âÌ{‹ÛÓ;öK¨­=:.x´èóŸËuÌÝ´¢æ–‡>"b¥Œ [Kæ£iþÉÒÂa™~Ìâ=ô-âmí9ÂC𮬅ú“</M2¯~Õ‹ _&m;áƒò°ÄêÎR¦ÚÖ'ßå1÷]á#DZ#æh⨕s¤Öt0‹Ú(|ÀŒÏz‚ PèÍå¼Nツ¸£¿½>¯#Jž>€Œ™²÷¿vóóÀ°?¬>óµgŸÕ½ŽD^%7 %ÖbœVÝJà¢V ÈŸ‰¿©UÇ u ŠYÓü�µá�Þʼn… 'göÕË3CO€«6Êu©¦×¡~îØúD›¸çÝ<heüD«V©¢Æ c 3òO2€ÈDõïaäÇøþ@4²”@±ŽŒdÚºÕæ FY]¿;hþþ;Çñ²€É `ÒÚkMÇ–2öøñ,6²`Zm)Ìš}ϧþ KhÕ•0;$v0·ÝÎVÝ |¿{Ñ2ï.§Vbù_Dã,õÆð©Ó@;¸U•ÓãÁ93@Øô}~0S‚ÀðE¡l÷ë5·²dtBËuŠ) }»*  úó{‡OçИ9†=”… …Ë}Xžþ{©H/t±P‚Šg±ø‘.èwÝIRûv×R&«/¯Ôœc«±­^Ä«‘vÈñè"»~j=ˆþ‡Kë$�ÍOúzËwÍ—òyEpÁX8êœÉ¶}ŒC8÷šU¤A„/ä'WwpuI庤ȭJúÊID¦¶ˆL⥮¿)Î9dÉÑ.צ–~uRßnˆ–üh±ŽxÀœS ·Çgn8'ß$‡G¤nÕ#5Mur³¡8ŸÁwï/¢ÀNSs8ä 6†Ò<óÑ´ÅОèGIQf€˜ðmLÊQ™�ÉÌv�BÂRÔX°î½ï ¦ÿ\è óyÂ…DÏ*Hm½}æÑø®Ö'ÿ_*]… BIFc¾ úFu È0ºT`[/åÑ‹¥¼SSù˜Ö‚î¡–…8›r[3Õb™é]Þsš¯¬¢cnPŒ3ijskV ˆ8?5cUi¦ Ý^¼€¥¥±ú G<BßwO³š=ð9ŸÆ½šL;†7Ä3Ù{ äK<&5L¡@Ô.¬j(³;J¸nÐ;ò.õäe!f)èÿ{»E’‹U_П°ù ,U•ï]‚?OA¡vOO|ŸÒDåvÄ÷)‘ñʺuîÃŒ•&€ÉiÞš«d )›Ì{zË­5 Y»iÃþ&Š 6:*9¸ë½³?•½+=\ ocðbÛ–IØ2gdýzUÒ:žÞô••/¯$ Õ•gKçgÑÖú<kÿÛ&}œ™çʘ@ê¿‚ùS¿£êÝÆ<bYž÷Enš4Yá÷¬îicd£¥;[¨òǪÆ"œØUóp¾z±Èƒ¨L]J”áñ4(†­×óúâ:\øº<Nb_¾“fª ·ëÇÁ‡úK Ǧ/@cÍh¾Åá÷fâuÏ}ƺҋ5cô=’ûþìåXˆZzp%ø@ÃS´‹áÍž‡á¬ÿ² ï¤+Q6 ²Y% ØÛµ¯ Çh½'Èu±Èðݨ%©õ™F~é²"ˆÕäžO”x›ø–¢Ÿ4é¡ÞC’ñ}ý²¸X�K¬éó^ãm茂Ã:¾ˆ.<.?ÕsFÏ d¯±»ˆn¯ß$Ï M·ÁÚ¨‡k¤é#ßy›ŠŒÀí[(ëic(n6XfKÏ…š~ÿ5½­ÉνK„Öعá3â»öP7K…ÁxÚæß’T¹k8±*Ýê@«0ÿ<™»cœ¦ðÿûQTrw¨�2}a¶)E cËësùã ¨Õ²éc#U×OeuŸž¡Öì(h‰`\ô]G;Íÿ÷–^yÂt\7í;ô³×Jà,Øaîü¥U›ñeea/™<;†+×gqž¶§ °µÖ8›‹èR™È,”3ûŠJǸÊ*ë*‰}q`“×ôOxÔ±ïníýe±8‘ÒRdÛŸoh/Xî”5}äSkz•¸/}W{ŽÉo‹eT…UŒ�»ˆ(™­¿•øǵrs šø¸Ueh@!ŠÞ½Ò»øæ0 ºŸ„ŽY±f)«�­ÚÃnºì¶3s@¸êèEIœyð�ZíMÁè©ÆÑr,6™Š«Ap©”ÒK¿Ê^\y¹—^3�•Ö^Zñºõ`=æçQsŒ=\ǵ›y1®½NØ#¥ç“•%ÊD9C÷ê,þÒ@;YX•G%7x“£Va²3xöô|ÞÔMÒå×΃ŽŽÌÄFì„5ƒFg¬®oÈ­Ò«Ÿº#\õoi («…¤¤fÏôå7Dˆu$u~o„g723ܘ'dÍš*3_Ü‘Ç’…“¿ä†È¡Ôsc›—;þ9 ?ш¦‘þæ–v:r -7lnå2CßgÆ7ïDV›R¯&S¹•y“NDlOPšlµ»‹vh=Ðåc±úšjQ¦�‹ÁÂŽ´è|qaùáðج¦ƒS_3&=÷՞ ˜÷yah:­ú¬þ¿|¿:ÖRpFª™·\XfjÓ£H›j“þd‚ä?"g£çg->º~ÃýËÛfŠæYVùw}I™V"»= ÃÁõQü>$Ûòôçùúá‘ãå1’å9ÃKãµSQkð¾6UßSèL£Ìo4‚×€c>ªn@’ƒ8ݱø4Ξ@ St,×ô\æ+‡f5ßS´JÒBL%–¯àþÑž"ÚT; ©Ê½ «e•ylß6bê 5ç�Ø.زkú#š¤ûר‰YÍ¿9yé÷ðoÄê¤7ýömŒ# g " »:4B®æ—®·nË–á[(qõ{µ‹Ë¹‰[$>`ú"waMl«-%=Ö–ìZÈrÞ²©6f”Ó-—ÍŽ÷yIR´;¹a!' Ï€{q€—¦ÍÎ$ó±_fš,Us³�¼¤rÐf†}kÕÑ 9,‰E»¯ô8DûŠDßÍwʽ¸Xx.‡ #T µç×à ;j¤…ãב²Ùnð®èA4b¸½]ÊÚ…:> ÆqêÕ*Êúk¨ÿ°»ïWû%Þ‘*K='+fÝ|ÍTêk¯ã¡KÄÀ^Á˜íÿò=f’„~Ë*œ3}—­¸�QlèýP—jþ^éäLÑR#>îó m&Oó‘n,ŸñNwhÏ‹U_ß×K£Ð_a,•B‡ôz£-;(›Œå–PÐ÷{ï$©ºF3³Sv'·Ç©aš‚²cMAÔûÌã j®Oƒÿ_|oéu‚$äW~´nSe&¾ {¿M•3Ú¼\ÕèÕ΄C¬‰‚OL´l‹ï¿ÞÖCÆ3ÞêÅý`ñâÈQe^S]Uó×ct¿ê%„€eoÜ'ÚÇY™-}VðŽÉǿαrc­ì¼ñ€:ð(܈`{5Æÿ{~C¹§ ’àù­Æ0H¿¿—\OyÆŽ|Œq †Æ¸ÎéLA¿´uvn«S}¹OoÝ‹éÓíR«®šC‡9…3äK1§ÝlFÛõïñÛ¤±0s)Çò­îP€–DÔÜgC§ôY=™³þ£ø; Mñg ËÕÐ7ÆgZKÒIu×nè&÷J‰œl$/TçãóPÁ7§¸88M×#êÝîÿ‰/nXeMäî?Yv[ÏÜL¤Ì Y`of´¿wÚŠó+¿Ê¡ƒÄÞè!æëqâÒM¦šN&Óo™Cä¡3s‚6Ú¬åçhÖiaM>;”cݶ»Éï«ëÂ¥rÞ°aÄÈ–2jlÞÛ…\¦™tˆ1Ÿ¢ä=ûé|àȾ&‹Ã­™;×­Œ^:Ïg^·…%øÛmµÙBQÍ|úvı܈ï~ŸÈ¿“h , J”G–t^n)2q ¡*}ï¡‘š¹(–lkŠ"Ö¶¯`gñÚø) áEê{}¹=½ŽCÊ”£–Ê™AÁûðÓh!©ïœ¸èÃCèÖpŽËþd… IYBàœñ¤z[[Äh°á±%=»›DÒ#úo}÷~7»ý#ÊþVk'§½Ç©¸ßPßwOåØG¦°Ó÷¾Wn<yC:…×=§ê +~m»Ã´–öîÄ’üth¨ÖFfÄ)e\û/ŠdE}ñS¡ðôÁdDï¾6Áˆl',3uÈžnXwž¾?‹:ˆ0æG4P>ãe‹œj?Pðy±áÑ»&­•ñÆjâÙ—Ùy”.Ìb¾¦2pìô¡_ýèÓ]#cŽÙýÀ)¹ÖjJÂmkƒa0;¢½m_¹Ÿ 'ˆ=GòÂ×,áÑO¹ [`V¢éãgtÇ“èÓÞï$'YæuËà©�m°Nq˜¬fFËÀ‰u\IÍ‚UÞ¥I†,=†¿)|ú¾|–<iê³ì…¯Žbœ½xlmjÍ ÓÏg†n2ù¨T,Y}ï_Ós“ØJˆ0c­‚lúôf¾XZ—cÎ﬉âÌãðÅìR»—¬Ý8šÒ5+×2²2V/²~¾:q¸¶ÚæÌIS1 š¾½í)-ù_89ªrn¬#VkúœG_¨^ ƒÖî­G{ŠHÓSÃ?¯Ê«î‰ÒÚ¤ÙzRr€úR­}%q•Rq<mÒýØ/2³«ˆ¼¡ô>™4\áÝ'6N2”‚4ä­¾¶'ÌN¸7î2¢`î0\‘Hs“'9å-AB£6;í_ùô‡ˆUžîG´w4$ËØç{`N\ÓÉ•lU¤Å3ŒùŠ*vÃwú<lg>£]<îAêüKµo]þì  kܺ¤âYMÊQ A¸éOÀeŽã³ãì=ýÊCß¡‘–®È°C¹dðfø‰Y‡qG'ñÓ ÈÉœø1»UØ[ïäõÏêþÏΚ>ë “l^Íö"+°)RQÐÐ3øVìxýŽÎuÚ¿˜•™\2ϲiôßÂF–ói(J%½eš±B努‚á�oLá$Èš[K£¥ü&Ý°g?ùãi†VGpÁɂºˆ°¥ÓXc£9¯AI}H�Íé_ýE;±*Íxp>3Ùe´3Š(¸‚¦xíÎŽ§+öõ±Ri;r+zÿxFpÁù=+\:ñFÀŒ%)>¡{`̼뭳>¼`$îQÉ‚›ë4Hú­× ³–.»i{8ÒYr‹8€uÒ1¯&Ã÷{Ÿ6®UÆÚ…{²±_m‹Ý0ÔûƒÓ¼xQºWž Ù´Å¡Îf+lñqx5Ó‘ÝŠ齟›yD™ƒZD&c£uç§`DÔõ�`ÑèY5ZÍjáYAC‹&îÕ÷±„ ñvxCb;Î|‚»VAõ¹væÐSûÑœvÜ®ôVŠ\1 ~eã¥ÎWB„Î1m´ÞfIœe¬º¶VràÒ.á¾5KR*ðLà }C`Fëž7ÅÈ/D¤V:ETí´îW{wÖù䢰´Vá•qÀn Š ³…~Īª¢W×ÞÎÏìö"¿Ë¡¤œ±š{ßÕðµQEnþ‘Ù^’™ç?�Ôù”•ePgææ0ObÄÛí0:±”7.ÔbON[D©9¦d£ŠZᨇ vvpÒ“w^ƒ_»=§ïF–ĹÂǧc²ä™Ÿ)‡+Õhsõ×ÌlæA~k7J ×m¼3jõhA­.Št>:Ãþúj:®»zI*Þ-Äé>y…/–Îæ¿�]:2ýŸ\DIù¢á·""5²ŸéÏdŸ?~àEùèªÉç°J%!sž6§¢¤r0UÒîJºÚ?«¶§¡çeîñ_’M°ø:÷Þ÷ƒužØKz=Ì4ÔßÆÝÆèÎ@tWêÆigl¸ 539c‰¾�ÖiÞë<+‚¼?án¨/:1ã#ãÛü·ÔXfìýüMñ¼Ú¨Ë$ZµÍáÌ4/Óà¢bþò1ƒˆtAèá¶i3¥\»Š€Ú2øŠyS€RäŸÊW€¶/{SŸõ[зú=µ‹»¸Ùy.G=Z©Åvã™Oé·é>|ÏZq.OYÏ“nB3{¢,Ç‹IÙ³ýé&äOr…'gz/iZzn{cáÍÀ*èÎuÕЋVәLJ‘y½ƒ”9;L65€Yß?¶}×p¶×öN—u„6"?“û”•‰RCôkûŒ1¬ž·,ªc«gùÅ�¶ŸŸš¹³Ü•QÀj_ÉÚÆ@ ÷t;Õ…»á-BÞ»Òà],<Ñ0±_§ @7^ªËó~PX? QZË”qˆ÷~…˜TÚâCNA5žÔºè´Z7.Q{ÏX.ú&¨tÙDÇa›% |‹ ks@z—KiN@߀G$AÚY5`²àœ³îQ<3dâÌícœÊ^ brÌÍY*¦ö´¨wDZ¸ô3N!ˆÐ9°îœ2sZúNqÿžùJqŒ’]mSˆ5 Ðd_c`¡­jðµk4Ñî†ãØ¡Ìð`^áq¶ n¶2­‰ßN¤Ÿ>dà9RŠñÔ(<öd/@, ZA¡Õ6.f»Ñãy¥ŠZUNÖ±Äm_5%K‰I©}ÞîfªÝØÞÀÓ]dG=»U—lIRF†S¡ º2­¥Á æ÷†–›‹¢šLWVb€}Ý×ò¨ý@cÆØÂ^ƒËÌcS™rì)r…Ÿ£Ó>âœ7¨$ÆÇ£S<£< ¸Ç2ÕnåÇ‚e]&ú§¼ŒJn_íœ8Ê¿™¥UžÆ9·ˆ?�$ ¶§f =›úˆ~:·žë†¶3¡ê`Ê“‚¸Ã )K} /öoJå´…èeea0z>»ò¨oë¨gËö<é²FS ”HpͶì/~¸ÍgÈüî ØâùVµùÀ™¨viÜœ†~´¹³}«ü¥y˜yêQ°‡¿Ñ÷Öƒ«ŒÚ§güþû‘$Þ¼(U!u°|™ Þ§¿ù@²r8)´v‚&O‚¸Ý:ü/mŸžº¥ç?Ñ!1<ÊèË^/Œ}Æ r6Q½qhåcw8öŒlÿðÒtjùPh€ÄÞø[Z =ZôÑÃÞsV=^ &NpÇHKüâ68Ç6)BÂà‹ÝP·æ@ºË ໬"¨e(ñšAµÎN¼9ÞÁù,RÕHPé%Ýü¦óÒím8ãö€Vv7Q^^_âdˆfIŠ{Ú‡y?[Åìš=¸Ó­r!¸ÿÀwQH˺ÿ¡±nÅÖáÝ@g!À”­i*”'MäÖ#Æwf‹ë1]”aT"7JBtšÛZåMàÕ“~ÆÁ¶Fqì2„½ rŒk¤æ†¯’™r|˜.²eßyWwì Jì #ÀªF³ XÛXÐ褌A‹?ò.vÚŠjAå,ƒ=íþøl‰–a¬Ò²Þh¶ì©á/ø磦ʻ׹tòË µ¤Ð‡:n}*E›¦Î,}àc(Ê:{”M·¿ñ@m¦L1{›‰5�@-Â2˜µçí¨º_oé§>,™Y}ì”ÜjæHu‡KçÄt ËpÆÀÒCïdÛ g<L’öOrÍsA¹Æ±Mz}tP)Õ?S P_G#¶Æ¯�|z¾½´b ¥ê$ÿ< õD‘qü¨œþ`} [zYŽè_ èÛÊ(7ãˆcס£ç<#v »˜ßvÝQ¸ÝŒ9N{‚>4–áBS« èd¤uQJÑMhPʼÉ+°®h,ÿa€$ePMƒk@³í«ÒQCiÛ/Ú~qä€])ó°Nô–ß“54M[ÿXˆ7ÿzg6ƒ®€ èåvfúŒ¥"¬@cÆ`(®´Þ!'™×ݯD³¶ òºÓ NÏñóôw‡Ç(}V^cÛmÞ³þ3£Sñ* -'GW¹Ì€Ñ”SÍŠÇ*[åæÄ» 5X«n=tÈ›†*"b¾1.´¢ë6i} “ GÛ÷@ZsÒ#c¹BÞƹhiq’ËÜ¡”* íØ€:D+V©CJÜ×KÊÉ3÷«ØÇ£0m¦) ?êì¸(üÉÝ‚Ž~Ø‹?í⧇ÅvúC�üœbÙç·çÛÑp^YUï ßE6J !¡`‹ùÔlRžìF#oeúY¿u•¯<^´².c5¨Ð8ÍÙ¥ŒO´_á˜3A–¿©¦O_â Èø^Ö#nÂs±›2/2G aóDŸ¢³±µ2À”Ån(QüÒ°¿F)JZðÉ}H~Ö˜E ‡"´2 ûk}w†Žµ§yU^öNNûÞô%ñŒå3�Œ÷_”‹|*ÃÃÖ0EHç(Øa%€ô/ÔþßLd•±m Rw,(ÂYñAVÍùøâtøTž1ã£z(,v½8OlÇþå/‘06y0õ@GY:ÛÉX¦Ü}E¾©?þŽ&yá2Ó³)ƒxÐ?\f¹@nïÎ Öüˆ Ï-ߪÏÞs½çÄ (ü® V_¬%lIÞÄN†¾H4-úí&ŠïÖƒë® 8ßË0~% oé¡Q=šàÉ”t½ §L—U»Ž5*Ö'N•–ÐÏêvœ�œ¨ô¨Nš!ŽJz‚ÞKûÑò¢Â˜Ø¶á¿gåÒ°È�cÄ¡éúð£¨ùè°†4wiU‰BD±–J?¶PÎ>/º ý'0wDïhÚ5.0l£Àç[õÜQ¹ðâ”å #pÙz–i MF³Tµå('‡¶=ûº´²e¤¸…C¥\_ÌÇXKŽ™}22wï¤7QY6žHí ÍôRŽBv^ô/: ©E…q>œ¿Ó §ê5´7þX˸¥›Ž´3­M• »@/#$'ÌKôŸ‹Óïô0"/ûÉ%§5}=îÃJ÷CŒš„oÿtJäX¹6yǸµ5;ôPª¯P¹fGÞ>À¥ÿ(ô%zÈ‘uG§Û÷§ÍÙs«-òÓ¸ÛЮšÏÓÿ.ÿ[ºöZtC÷ŒTI´G[hÏ”“U<ID4n×ÛÄŸœ6ÐßûÉšljCíפŠ­…h¡ÛGÉDò4ZÕ¤;a÷±kúRï*ÆÀ‡öüåâ™Ó™|iÆ˼B|¢Œ(hõðhz’ãÖ“èTc§U-ú·œ€.Oà×õLå9A±ñt¤z[{ªZ×94À¶^Ϧb’µcÔŒ­¨q• Óµ~ jîôéèÛÓ�¼{åºðúuéb.A T:<)?<j?�SËmŒÁ° Ç{2Àž8Û™Gîsj MÙJçÍï(ÃÜ…Îm‰ò¾RE±§±O'ÚnÇö§Ý°Úmú]§9žŽGé2ÈôW}ú0©ò…¸Ò‘B·ðñÿÁos¤»B1È!Réôï VÉÝ ŒJ˜wP›¾öÿq<Vilô§<ˆ¬ÂC¥Ñ.E“Ì4f</î߸“Źi禕 5ýx,M<Úç2’þþÁy‡je”Ȩ޶’øb›Ôý Y;kù»T†o…ò¹††ÚQ×Nξ؜9»Ã+ú(]öÊca=‡,Žjb9ŒŸZ içï† ÝÌz8¼Í®Ê+µ¨íÉ?”PÖ �nP{l–a€n16¢¼KI™7GÑÀ}7=X~UPÞú8‡qèWá¾çíÙað,Ô4µŸÞ#ŠÒ¹ƒ ™š5aüŽÙ…Î3pʺµúO ëœÍ.'´Nç5­Ól<:Æ&S~� æ“ WöšQ…Ê·Ñ`ñ­ b6žó¥‰û® ŠÏÑ7�:ô§}s2ìªkz 3—F–HJ²:QãhÆÉàsV”îÈD>Y”ÃèÁÿÅËsë> üñFí&Ï™—é\Ç‘nƬ±(¯TÌÒõæ5rk¤»~]; ãè ¼˜ú2ÈUäüli(hé³[j¨ùM\?_S‰¶(V¼ZŸ¡E™E¥òé·‡~ßÙæäÚ RΕµSâz#žº4# ý* €⑸Ù ÿýH –¼òű‚ö²€äõŽ§ƒ›žsmßwìâíFŸh*pÞÌq{b¿J+®�ËCƒÚؤ źZ6·Ý´,¼ U»cŒbK•~*ÀŒ¨¸²Ú6µ(`¢¨kAžIŸHÆ’n<éÄÄu¤ šŠ ÝNM«)ŽuÎ5â¿eúñ¿2·¢ î¿[Vö-4øaB™)�$Òjæk†Î…µš75žHa¡ÿ„IûÀÕ¦€»jmÙ“µQ‡us´°rq%ÃÞg%™ªSȤ k*ySN˜·eŠÐ'†Bº'¥TAâ¨^Õm½×gô;ÚS’æ¾s˜s"’X"`Ž»#+|ËðŸe!Q©ƒ×”ë©DúÂk_‹ÛÓÂÛ¾á¤zhÃw“G!Ý×#•Öó]ÚYÙÓUf Éc%†mí‚|&vWw~N°!GÃfµGËꬣ)Ô"Q`Í€*•q²Ä RôéèŸütòÕ®‡Á¸|›[°= ³IŒÝ¥Œ|ŒÏ°Aðg %673ò~7ÎÐòõ"8í©Íö =ÉÙ|Å´?Ež/z&˜º¦I7(G ÈþT+w«íxi…¼AÓUGµþn³;,.é—¡/–eØ E~=O˜æÄíÁù;óÅÞO \NüBhûÌu¤ÛÖ«ÌÀÊœø›InVM">~ýñ€ïÿšf»#¥½µÝ'  ìÄøQÞqwœ8W¿~u±8Š“¤ }äÉÈ“d=«Û¨xbKÇËAjèÞ[¿­Ôpæzÿ˜®†§1S±´stÔþ ˆÅÕi÷á×êÍIé›ksWõÚžÚƒ½]óÞýZìçÅ€§5L^UB¸?”KF¤ø| #}¹ø4;¦ ªG³•�mà݉5Ë_AcK‡áÒ’ ±#¥‰ñ÷Ú« ¾O@Ø:ùØÉ‹¹o\e>ÀŽ óHrþ«èn£»®x#Ç*+h¬ðJa¿-¿²Yi¹í‰òÝ©ñHZî¡\t­ðÉüïêšÒ%EÒJèkˆ*×¾Ûµñ÷™5%»­ƒèµâü³ðcp+ªoÅÆ%¢ûIbÊžõÀÆ—¡=á\ʸq ÓMM¯–ð,óš…LÖ8CCßÎÝy*I;Š³‰6WMòÌ3‚ÔáO¤º2Ä5ÜCZש64v}ÑOj•T£9OåŸ[WÕÓˆ Z§&lè–sÇÒ'¯~ôLYzª;”ð×=ÝÙþÓÅñý®ÿsšìQ«ÇRV‘“çbx5zkgö ²P´2D6Õs=zÃ3¼ðÐ1,ÌÑBnh½6½LxÎ}=š5Ö ¬ ‡úËK. sKH÷œ51Ѧ`xëéñ¶ Ïä´¸âSyó l“6gÇ*n$Ké)¶Y'a¶ŽÝÒñ“,zw”®8OÌ(Ýv{˜ÊtÆ‾;åÖ§ýÍósXÂÊ´a›)e �×íÚÁ»¢ÛbµÐßö«‹ãÔwâåVxDÖ'Ju–‘ÛL¹‡9åçÒ´ä�Åe¼àÛSn²rЉ¢VÜÉË“˜‚ot:ò(]{åšžx¡DÕË)ÊÅóÙc‘6õÔ v×ðTÿÿʹçz²x7û)tfGò‡Z¨²B·ÂÉœwš›<}|œÓ¹nùš;«aoÖ’;•–™ÇËJ"¶*Œ*¿bÚ:ºz³c³¼ÿÄ«Å1M CÛAôs m7a6þaÝ×ï íIRdž¸ ›Œò'_¥ï~Lq§=aÏ÷àÕåÍüÀ°¨Ê ½Ð¿ÿ:ä´OMÓöœýÚAGí^—?Áy^Q ·-õÐQð™sÐL”æ«×²TÜžÒõÖÔ37xþ7¨&üTe^öC]ÝÀÀÕvö`Û4ß궉‘î¡ç4[œ¶í¹ÇÂî/ðøÁT°¢t='ÍP k;A;: ÊOmóžÑà.±ò‘!S5L·¦…½èyWêÌíûŠÊòú‡¶Eƒðg·¢]¸«­âËl1öô@4ÎüR (ª\ ËVçf¤çǨp¿ ø±qüaä(ñ¥Aàôudî@¥ï,wW£Í¤ìa°fxÌþHòÞËÕåþCä% œá–9Æúï¼ãÒÍx¢ŠŒˆ6Ȩ¡»YP<mhðˆñœä \l1ÿ…‘i™ éüשÌMÇ‚½VÝÑWßGND“P¥þ@„ÅÚw w«fdø8÷šÍ•îÛ›_x´]Áx„ Óô­»¿Î,¢>]Wu›Sëü7lN[4WdÐð™GßhpÈÙkËÿ/´6‹$J3óž\TM%Ü6.1DwçØëÙ¯|M‡#N= (T‘Þ œ‘¿aBÙ2)kûíQ¬½”‘ݳ¶1ÌÛ•°u*|-æ£b[¥y�µ¬­j4ò-ª3¿&–øPäÚq<œ'³’&_Q’ùÍ>6“tþçÇÓˆïúÝßdîC·O ßjƒýRGŸ¾RÅ¡ï»*L]+üFBÀdU§o@¸-7µóÜÚ“òϵ;À¼K¼ïnkáN²Œ;hçØSÃÜñОw^‡ŽRµ?&»|ËXP¥°Cyì@q¬8þõ|aYw¶8îCÛš¿Àd1)$�_7Öª,Ê\ÿœ”™Ø·mOxó^HŠv=‚™¤¾×`RŒ~¶6þÒÓ=ý˜ ü‘ÁwKÒ¨JVËðÁž[×Î^v'ïŽϯürÕÞV=#6n˃´U‰A"”NûÃúrf¿#Ç[þøÐÊÍ‚VˆB6"Ìk•H¦{/3 ¥üµ aôŸÂL Bõ×\UÛ[Ön ¸'­Û‘ºïª‚îV»ªüÈ™²‘ÒK'qØ™ê]},ó^µåIÍ 3³¼í<¢,åÂóNëíβsþYrV¾Æ [¸¬±m€JN�ª´wÝ ©mX”(5­NÀ[n®eá· Án¢ä ʼn]AêD«²B8Ð5€"´OÍßÇ7£TíNXêÜÊCD8y«ŸŽTúM7p¿íE$°X µ@` ÃVAç8[LŒtùå/8 QújÈ@ô”Ÿ…ƒFŒQŸFùØ¥’?Ó¯^ÑÊTmñÜhYOÜTwN‚i Ä¶y^YwY”`íCãvYÀþl𫨇¯·æ·K\ ½»$fu5´PTÙ|›GûG =ŽÄ*bwƒ¾§ÕY…lÔŒT,Ôc½ñHâX§v8\#ü½Ù:Xý¡û’ŽÚÿ‹�-¸[5´Ûä½ýRŽŸ Üé@ïZ}­pÚaC9×a§p9ó YzNªèkDƒÂ?ªèþ` E[à‹Ñr¼wHQq_bÝSåf5NÌŠí¼>μÕú(ƒ!š¥ÂÁÖ/oè(ÁÉ­x¼tQ`³Fùm·-E±/þN¦jÕ©ç) ŠzöÎCŽû»ÁiÇbO’çþâ'Ô/eèà z,aPlGÏ ^}¯çØS”ÎsEà‘3­±ØB1T¥L¹wC„Ç1ã6xz¶dŠïAØ(·ò½ˆ&O¹4òΙ=@Ú÷%Ö÷<ûŠÜNÿ˜T%Cç²Ý¨·“ûûÚW@Ÿ ¨ÀMŸ'¬€ú#èdðE1¬Ž}Â.°NÅ‚„3nf£ÐW™Ç*‰¸ƒF¶|ñ ¹[¦æQÿ:–V¾å`R5Ú'ObS(ºåÜißÔÜzm³[šBjÌC·cEÛP§�éP3ê<¤•ó )ú¸Ô3?|Òó…{¥Ý¢sÚùë¬ðX8\< ›„ª§Á:¿T¶Á3”½ÁŒÀHƒ^M?YY1 _fG£~4Þ³å~)x¢§¯è˜µ0ø·—Þ‚»‡²hæUÛ²ÞøÚéç\#„.6PÍÖÓs§ªn%¤š÷§)Yì&™U1ºd½gkž±.×ñ´i.æß«SÉÚê àRJ2¶ª@@OMêP{$%ú;“sÔ½ óú@ƒÚ3OÌpX³Bo§ÚÜ)#~!­ã —ŸŠóEæ! 1ßRÈNzkâ™cˆÆ”Óc=ž¬w:Ðɶ¢¶%Klß=3J‚Ãù·*ôˆX¦  ³"1¿è­)^¶0¢pKr7‡Â•úЩl!ö{W·íš4ñ8¥©ïª šu¿ífš¢Àø®=·k‰5´à’ þÔⱌX.‹î°çŒ°e‹ '‚ïêÂ¥©o–¢ÓL¥Ý§Þ&¨¿²ƒ„ 5„²‘ Š“wyíÀgšo–vE§×XRìßzÒã 8,4∸vëY¬;ºðl/QÑîzYo<3OV+óà%Éøý½¢qšS02dq1_F @ ‡*î6œtŒ9Ó‹l®ÊÃpé@Æ–L£²+%«5¾IéaWòˆÅšÃþŠÂØiz×™)* –ת%€f)‚ô‘9wyÐ.ëRÿ ,¸’/±TYî¦o‰…šoYŸµXûœ”^[•¿™!DyäúÙ1ËŽ´:­^H5Þ¢×i¢ª»?–y·êijG¥M$õ§k“ãý¼ÖŒaEô°ôbk9wµÄé[çñ‰„~ßYõÝ‘vý×Áé‹jÄòåŽ5n™y“ç(giBèîDV£o„m˜¹íW÷BÑe†·�„m–!XŠ@²Pº'éý…®‘ŸúuÜ ±4\}–÷ ä.X$vÝîvDµ;·Ìë’v{�œë G:¡#q³1ú/�¬ê¾ÝQÎä.(iâÜQÞuù*0]Óò#d4bÛ]öµÌîò·ƒ$w~s˜Ä«Ù¼ú4N;úÑAÜyéº5'V{(»PL…ÃëçúËøàzW7kÜÂIcíÄ`ˆµµõãdº³u)gQoÎYÏ…J¨ÊØå bH›šs[£ñ`}Ÿþ&oš8¥R« ñþYar1­ucLÞ0Ýo�ƒÍu¤®ÚêVª{Ü1Zû½êÊruµ•"íƒBb;v¬ y™Ý;B€Ð^ ® Y㓆.ƒÜv®1<RvwìV³cÇS»=tWBä×?ªt'5(j#ª éþTßÖµ-ü~·öŒ:ØFªã@õòRçÃŽýG9Ì攲÷¡[øìk`¨Åög ½èUKÈe•_©)tv!Ç4«€;C´¾ÆŽ?éÄé�ZUkÀ¸A½Z)Ao{ZÆá.C´l+3‡‹ÞºS‡Œ,™¥iÇIÏ,H\ŠÌ4¬ìðEo–þ•:þ0ìhÌ2aÞÏ®ö5K¤jéýàcbï¤À¬Ö¬sÛ«¢l'‰ÑRÇ+)ÿÙº/=8«çÒ²ƒâb÷UšÑ}øé•cíù~iÞç9s}¼:#AûkÂ~Y™’¿·6Ñ=åynÄWÄæR÷‹Vî›e£†Dkªª¦z¡ý«Å1-êQ^h•áÓ놫O¶“‚­îé}_<™²-Ý&N´¹ia;=¯A€IâôðEn[gAtª|‘c"gxSpÜï®/¼§<{rÛþȶ?¾˜N¨“CÜüZ%\�Ð…g“²˜·É™€Íï|NiŸ¡š‹{Hâ,vO³ŽjÄó'XÁ¹cVã,;ei­/}{ÝtòîFŽ£uØðàÍN5(›éšnèþ:E@ü± QÎúø&ÖbÐÊMWT¹Ç:�kqó£8¡ O °cµÌ§m·6Ógwu3ãpF/"B;þQº÷9ÙV)J“E›"Ž1%úú>'ÂòîêFóÅ¥Q1œ1Ê ¬µÓ(UÇ÷‰Nºÿ~d^U’¥æ¿‰ì&–‡>asõÄ&CÓX6?àeJ¹v3­Æœ³Ø‹‘$ûqz÷ž¹´PÎÆ2XÍК¯-yNÂŽ+÷EIF_gºì%«½ôL†ùƒî9%žkOk¶:Ýl=Jg3š¦ïjZžhpdq¼XxÜýVPú­‘Œ?äá8q ‘ÊÜðÓ0^§Õ—¦}÷ÿIe„:FAï*ÑfÐÏÏeÒ¦þÖV™Øp,ª™ªKÕF¿AÅ¡S€Å®ÍhW”4Õ¶ÑÄÛö0 9:$¬p‘fC7vº¹jEdÑÂ&“#7'GΡЛ»!Ã컧«H[.ò´+X—;*Aá`ø WÖMÓ]|(Ð{kÏ3ºÆ-)–%AòãÉa5§Y>¤ŒR]×Ä»|–ž‡Ž^sZr¡Skz)†ŸT›°‚¦Sg�oE”¹í%ŸâÆ|nÁÎ<SùŒ‰��Ç“Ï3ÞL•É~'�^ä>"ëà/E ²#ñÇSõæz¯tÝc­Õ›k¸è–AI¶+‚èbÕ4¹¹\ïzPóô®<i]ùÉ“ÃÏkzªÅh¡Œ*¬Ž£V; ýÕ—ÇåÝ?b_µL:)âáld¬Ñ™aÓr‹"7iæ”Ñ(/2¯âÃêÀ®/¬¾N„scúºôŽÔ»ïú/iÐÞE%E¹g,Í©PGõ^¯úf9œª4æúœË¤ôÕH-ö0cÜ|ÛÙƒ×úBÅÒ8† '•T)B£Äþê~!î¸"9›‡oA¾±Mlt ™/Ï>)Ý@eKé½üÁ)™„ùœ„ù,-‘b«qªäF5k4rapÞµÝá(~á·Êa/ ,qSÌâ1½(ìˆð£Ü1´w'ø£øöÂô"°\\~TV«Œµ ÿÌö`±¹xokÚ.ŸŸ–•TßÊN·µüÛ =%ÓÒ?ÓñRù‹·0°¦à id?ènN=ÌÏT<áM]…(Ig@bTÁéî²{Oä„èûÖ_ÝCAðçâàIî”HE}ØÐÚNzÅ›àPl/_­®õg>ú×'‰}wâ¦:çÖ,cé‘Ž¾Ò]»&_¹` ÆË––ªo¨÷Ä[϶bñÅIàmB5•pÀö¢Çú;tÒLÝ+c“h±~@QéJFuÊúÁÉ K‡Çeÿýˆ3îã¬ÔÉ™t> J¾MìqyÇdØQ#¶´¥ÃŽ"!7²/Ì&‘ºz½Vß4Rg‚‹XÀ’ŽNí‹7´w&µV7®±y¤ »5f×båxïb90ÊS;ÁÀ>Ž9€üƈD(w¼²_C<+fß ÞÑÏß½C‹Ñ'úC«u‚6·èùÓ¦ÐÔYM}7[›ÔPþö§3 ®¨TÕ6ÅàbsÊ‚ð[í'™YŠî‡7Ǿ”öL‰*eÛ~Ê�Š\#*õ ýì·:$TÚx ¢'F;Ê"=ï^Zòzîm†àØãö8Á}Ì4Š ¥Þ¶ÑÄ pþãŒsðl$ʇªA‚yÌè ö½RãÌF*Wí_«9yª_¬?ÐÝìs[Û™´hÀ‘üôà‹¼$‚•W!ˆØgôé-Á‰ÞÄW²`­ÓvÐ’·!#Aº¢2%ýßÓ½„äó­¥¼=9*³¯W3LF[A§fšì!Æz?Ý©†%3¯Õ:)ƒèøm²ª‚~{Y¯Aë8âvÒ»Çð߈6Õ|9Ò£hßö÷Éœ·4ïy~÷¾…RPÈüö\ÈLSýå�ËJÈÜHŒEW‹÷Ǿiúf~i°maò3zTbÓ|³ßž „^Â#{*$ÃÉû¬”oÌù`SQZæÂý wkÝ SMZ4»#°cïs 9fRtã€Ùî¦é±öeì5¥¼e·Øí§&3)Ãì|“í÷ ˆ:h³NPgHoGŸ–ÓU£3GŒråŒöób$lFF»‹+É òfšt,¸½‚QAY+ÅlZ;+eÖáÀ$4{q‚¡É´p6ŒÓÔÉ€r²5nbQˆé{ýAøIùÈJÓ:?P04.(½2åž22ïZúÓl¸àw¼â8µh!qi‡·O\=~næ²þ³>boÐ{ŽPÅ¡Õ„ôLÄV"5ÍüfÈ+õ÷Ô'zBÊv·ÍÔj:&¨P š3Ao(î ®p¢0Êœ7 .š¾Êñp¾LªÍä _atCÆ2Î Ö Ì¶ÜíÎÆèiùr›¤WÊttr”tdwÎtü¸ûê$P)ê-ïf+GF/q»¡çdGz<št9âôiáû¦Þp/° ´Ìû¸ËÞó…¦#'ËÚ@x!P™Ç>ÿ#¬–bkyRrÜê(‚Εòw²G…®=«Z2 %c+¥bAZdjý€÷(Ó°sèÜ×£…h=à#¹¨"À qƒ)ûZõ5Kz†á°›É»»Z„‹ŸŠ¦/ˆnÜz^ò š•OMwɈµ‰#˜,ÈÕa쉤E6ûzX‚Ê”ÙÚãEãQ×cû·ÚÐ5Ó¾ý¬÷?RzoN!7'::3;ä. ›äÉ¡Ö£Þ½ïR2Rës¦sÒÌsDgô÷t íUŽ­G/ié÷Û-ÐEù8Ô_/»þîÀWÌND¿õzŒpˆn! ê¬gÞ ¯o(ùïîJx -2®$UŸ f:NÆèg¤ 2¿G¨J3ŸÍIëæ\ùiãeD,"Æd´ClâÔ¼¥KÅb "WýÄ­%5#v†C矺îqƒ>ëÕ¡ù6‚ù+oépE”½Hą̂Õu³Oì¦j`¯¶7buìñŠôJdíˆþEU¯yóŽQ<xÆh~~ì&Ž¼7?þ¡¸´œy–ÕÛ‚f}w~ö…1§T7Š>èÔëëÓBÁúVÛÛ“£¡Ñ·˜½Nছv“¼0JÍ\åÁʱ«mIhÑú¿[yœw–ü8Q†$4(žµÜKibw¼¢³[» -›Y‘jÐÝÔtZõÞˆ[ƒ¾P}ljµ{â.™?)Ð…QšÞ{†9ŸþþE{tÜ1±›rc§(ÓkmÃ(+Ò…`uH{ªŒÄ øÞK—ÏÄhX�zaeì™mKJ—Rêž«§vA,×ï]¯Ut²²½Ã‰ëq…`ÓSlÐqxÍ%L Wb°­É<P®;o=ŒŠéÆ[XÖx»²`>™Öê–ÞülªÉ2óµ8éX=OÕ‚WÚRúpµé»M'•‹dv×À�Àú‘€©‰¼ßIwo}© :°j¶š7{hB„‚뤦*¼d"f5=æIk0Éiº¦“äLZ›Ú0q=ï*«¯ñô?b„é;áÿad”¿âz0eo‘~à袇!°¹¨´á†òÿÐÖú‹r?ÿþ暇™» ‹Ýï¾Ø{´Ö¶dª 0Þ©ÏÞpœ çîb¶ö.¬Õ/eK6{é V¤}»ÊŸ½Ó>ê¡•zùó¬Ë¹Ìý9%‚Øñ´vËBÆ¿.¥ü_ÔÜÍ«xuZ¯~„�¯]l#LÐÇ=Í÷:]V5ÛÕêAæ¸Ì {è5’¾|?½-TkÊN ËŒ½7@añ#§å°hu›®e‡ÛîGû™ÒPhžfõÙÓüf¢æÞ&‰Ðx1¥ ûk#óÕ6‘óÌ@ÊÞTiÓx4ºÕˆbÕý3µÔ÷JùÉÉ4yÃÓºß×N’›*$3¿Ú¢zWÐ"JC_pŠŽ‚ìíóF™™hp-´Ð ìƒöðb=1¡±Sh¯Tµ BŽVÎ9ÌkÌëÝÈt:îfŒëha³É†œÏt’¿BVËl¤‰¯íÚ{r›ºíL�,ê•fÈ»"e’yä[DŸš‚Ïh'îIàk$Ÿwœ0�/Ä"¥ ©šÐGà…Ŭ‚¸×)'…qA_h÷P4dk^¶²äTó¶å‡~Iûµ™N®Ë·gÛ G¨‹·ÿ¥€z¤ó ºyâl«Ê;CÒ÷‚N¶Ç¥Õ#~W˜8ϯ°«‘âÊ0¨$.ìõŒiîȽcuN}Y™Ý-n.sù8Šô‚ölJéxë” @Cªûú²Ü²Ü¡ºË‹ãl)�;né€~|w$z;DZÄ–õ§{ÇßÔçéq1Èh‰¸ÕÀÇgÚƒ-�oâ'ÊŸ]p ˆ UGÀ¦-òíÁ¹ê=‰Gÿ)CǽÊÄ7ˆ µ‹§•²†*{Y‰íÈ÷ã©°Lœe~|¡ûÚÎôfÖ’ ót«t´‚m¬r†Ð*ìÆ™$ôà;¬»~< ¿¿]›n$=®Æð1Êdiã¦;a¢¸ôqí+•RbÒ*ñê'eû«d#’«` hoí¦­=/ÕítsýÈ´AŽ}¤ƒf‚ÀÚ)ÖÌÎé'N´żâbÕ’ ¡õžÿz#àÍi04>mX¼ãùºô­<^ ƒ.ÆXµÏÜ©ž¶œG8ÏÄ¥ÊÛ?Ð}K’…*X:DgmT7f¬øF|0v›Öê3þÂÞ!OÝŸã±ÕúByæqöŠìŽÂPVqfeÐ¥æõ½+“CyÔP”z”XöZ›E¨kÖãÒ¹"@k¢Ù£Ž¯ˆÅ¡ÉYEÚæçbn ØõvãfS§¿­fc}‹5ÉY­sð†”cG•?ú²ê¶#ãŽ?ÔÇ Üÿ-à%¡׾ν•+þtŽ;‘¡—Ê×®¿£¬öBåB>h¿[ƒ0fGïý…ÚaV˜$;3*ë<þÒ~c0ŒV w®íy‹ž²4}e© g^„‹Ô1èÍ$pŸY¯òSQžŠÁ‹¯¹$•"ªTFwQÔEk ­µ½tG¼ËîŽX‘1ä†?l÷7ÃÄDåub 6N„ó`}m^ƒ!Êp±CäÖl1.Û¾·Ûè×pK°bÿ)c¶á°uòÚ\û8?ówG¨qäñpαäªùëW‹ó¾\²mÆ(kJÑR³b¬˜;"#‘4™¯VPX²†½Òü‘Nj.̧Aé´oU^6—?tRùºûÞ{¯løC)2NqÛ€ì€>5ÖjÀUB´�ûîù9:0xnà @—fƒBËcAžwôY™„Îbh(ßÜS¥eÛ¿ ‡â/Ñ°ÐuÔ‘â|\ÅÄ@´[J‹~zÏÚ`¤Ùð^{™àsïcÚÐÏ>)okúˆ•¶é/«-§î,FlÇ´e0~´¥Çç‰a­,_î2_Ù õ/Ý­ã+ªŽ—ÃÎpÐd|Ïã¬hæ°Ùg)YX`1eöœfZu«]¯7Â}F#‚>¢ÑìpWwH©9»âÐ@EöRZw&¶y½ú4Õ'ýt0ò ¿ÙTežÈ®±¦©Ú×ÐéÚb:“¤¶‹“1‰bM‰UÕ´žz×îðõÆvŠØèUFtp±X¯o^=S÷ܶmîá!÷`ˆ6œqzÄi•»}×ÔÕwè®ÕBo#Ü,(-ê¼yb&Çy>½­¶Hn&ÂíT”¡op1-ùjpêW]sy[Šs1xfÛÞCŸù§•±L…´ØÁ Ý7•¢\¹,Ïÿ׳ß0N)LUªZXATÁy¤5i…–™¹ã¬œŽÊ¶ñê £S}î\9önê:3G¡ %›Ñ·Õ=Äⵌ°Ü™%Hôõi Ù6 NFfNOgJW¢Í`åÝ&«ÂŒ#» SœFÙ0•ƒ!Ñá¾¥44oOžé`CyÜÎð:,Ó…*;X§‡ÕëË7b&C–¼§´pê’ :5K9|^*…¶ìööÝy7ÝwYȼVP.€nJŸ›‹5Nç2@7_¸Ÿ³ÝKßçQ$ºî‡VËKJ£qr> ™F`xšÄ–ŠÍ£z´ñjºÅß6ûoõoô1ß;GÊ«Ô©¦Ê7¬@É'ÑD~v¾¨Þùê[ýÕ¶ž oýZT8qI8Ô`ÅEäûÇÉZ{^1Œ�œ<‘;&!FYÁ蛄>Ÿ ¦±M*”ò{Ð)ÞõŒ’2DŽ»D¶D}ñª`œq§†G 5¸¬qhbÙí0û…»Tv-õÐý$€Qû¬wVãØ U𹉛êUFd`ØäF“52¹o{hD.Ì*Ù†¿6)žÿ • cç6…\,ŠÆ¶}¶Ý ] 3²4°:Y¶0‚òSïsm5EIx¤©W…sÞ:nè&e½Þ¤Œ'JÐx2ï””gA5/&1^“t]ÓcF7˜f^œ"±Ðî>°¾‰y¹ŸxKr ø9ÖLi·iÕê& #áѬNƸTPéq�6ų±gx¯<N}@z ªAƒyî4¾ì*yŽß Xˆ_±ÜâdQ""Û„KvúñWl0Ï(š÷ÅÊ0ÓTG<—ÐÂ/±Cº4Ä4Gžwpü^Ž&˜Â*PqѪÖÊ­ºÏ%Ð Ùý5å=-34E%aSPÌÜ*á-cba=÷ƒ–’…F§!óЦ¾¹¸Ö5ô9…)žl³…H¦:£¦‰–XÍÍÅjÙ$´ó{™ÕäíÀ¸(¿˜]»8_µ3¨-‡ }¹¿ø«ÌS\n¶ ¿ŸŽ^ k3 ³úGã˜Ò$4‹¦‹Ÿ²"tÇC”[}˜UáI%x¸{�—˜é$ßÛ»ô:–‘&ÌÒˆ?µ“ƒ„RÈú)}‚†€£,#ãî/Q{,ÎR\ à|ñJpºwß'£mÒõJ�1Ë}Þ>´"p?T|vÎùòÕÙ Äý[ðèÆÄIåO’(ô¶ \‡V_±­Ç?»Õ2«7¾ñ¿UÍà™ŒVÄV“M ¡ìMË´¿X*Óì}–):¼©é“©J¼"P ´±ìlLïþ·¦U·³æÂ&01Œ‡§+wFV‘s—gÁ6òîzs¦@tÇ#öƒUvšîJîÕ3c 8)2?3Ë‚i‚æ@ãDâ-—‡¥ÕVõð‡–¾A¥î¤pd\Bš,<#A»¡ŠÕÚÕ# Ò Z`s8¹4ýwCŽ$Ž}A†¸b ·ÜšîéÌþ°UÇôß„}öÏb›ŸäîOÝ_W /dÜŠ"½BU59}©šIÂt¦•ÌÉ¢¥MuÈ$r}Þå­Žž'Ö¸AG¹ý6!]_|fK+º’æº/Ñ•þ°§É@+®,&‹c†g~5KLøV†/]·ðÀvõh¼Ràüô(ê3}–Ö5r˜VÁ½Üîc¨ÿÞýÕŒÆR][Iè”^y¹B}.9vžŽHCÛT;ù·ºsèÊÌ/ÇKüSÕZy‡À²öõB¸¢åŒ}þ€|\Dv˜‚C‚̼ ’YËñ’9'½:¶5T„ˆp˵µL.1ÕõTtÚ?€ž áe2”ÒŠJÐãSÈ“wýHtÔJFrÓ…¯¶Ë�"±Ømô)zZˆNsŠ§/pñš¨Î[L{¬Ú’e‹yÝ¿èÓ¦Æ)nûŸŽ<DÜñ•à_¦’\™ZÜÖôN?ZÂf\_ugx]6xW£‹}eÝ”;3¶8q  ù(­£2þ2y2÷ýat€­õ©=¢g6æYVX’(wèç5­†öÇ7O»ýAµ¥tÄ­úGÕÜGôsœÚ¥i÷Ú×æíëD‹·‡¡c@†9 n^!¯Zƒwãg$cbÓ|_<yùS©­”®_]umD°’`ÓC‚þìQ€ØÁÙ™\º^ÕËËÛÒB(õð¿ƒËcÿãR�–Íåõ Ö!zåŠsÜ­êËýá™Z¸TÆ®„¥âyr'(4ìÜh´Z¿ð…æ¿t"üà蹊ó�w,=Äø÷ê{íE&–TæÎŽ›èÿºg D_ÏF©¡t7;«Rõ\ÚäFwÖŒ3‘¶;*çÜÅÍ‘§R„]�ØMr»±£Lô:÷Žý vRƾ€½×¦ÏhÖ?Þ<÷‹6Gg+R8B+¡ëÜ9Û˹;u”;|ÕbÁC§;>m¨^™tÿ Œ|žŽ;ÜF>è…ò_oî_]·¬â0qs æ‚H•tJjj|ØÃèîõ{ԩأУ[QD¦ÍYžw4¬ îZYZå>‹ñA…Œ·Ò<¦þ©Båì Ú ´–íP‹•jHîñ¨}Û(ž oO”‚º\Æò3çhñï=€³…'V¥¿Š²¡³º+>$Zºó÷½ÎDô‰.ljH±-´HÂã_¯KMOÓ³f]‡ä“ÄjQ®_ï¢,œ*ÌV5Ä°:­œA1±ÉÈVp>Ê,Jºó°A“<ú(2VïËHº©,?RåÚzª†,Ž~ÆÉPÍ8ÉE/OŽÏÇj$Ej%„òx„±E<ë{g×3tß.Ó¯å-'I&Ip« œ6^?|õõiDÏ-hÇÃNÄÝÕù²Ú ìüfÚ‘Vi‘™£DLÃéÀÊ6éB,Nk“zIZtòž5ô¬uI$˜mX °Ç_ë’<Úm}æž eXýÂHjïŒ5"ÏŽ11j2ó@·¼´0=�¶;¸¬t†n þq`‹ýÀÓܶ:[RðÁÄߪÎÿá ¿ûïØ\…å,ÕVŸlšûzc•±Û²¥ø‚Ñט-´„qà®ÿ#S,ÃÑÆ0CÝ®~ºC¨²\§°2Óõ#­œêd7!’ÑËì.Ÿ £GJo¶3ŒÆC¶3q¸18Fý¼´f÷Úù´ ÔT¥Ü‹×É°MÛDó}Ws“Ú!ïDy‚³/ñ€i;j×÷R<·STò!c#2KcGB0žæ=lDe…wJ£çü5Axé}I³A½öø3ªG”eà=ïP7XBÑŽ:X°§AòmL¹²B ¬P‚Ìrv5+B7^ E†²}6Ns£óMU¾7ª}ØK ÅÔÆ8}åÜ“J )Ê-Sà+†úŽ,:{õ`”…¾‹1nô ¦Æcö”ÂG‘]oœ\ûþ )�Wžô0¹·Ø„ý›Ù>! YE½›“Š¼.¤ìmGçå/i©Dn,iÈõŸ=ÇúŸÌ—éÃs^XmwC'¹¿é:—ÕÐð¦–M8Ìê•Jž)¬[Gq‘%Øá¿WÙ½ûÂm™“™Ouö³×V™xQ_w¦/ý;’Ô[§L@ngÆ}{PWƒØ𣠂V!x”_ou&hÁ„Á^u䓺‰2E§ëûÅþÕ€8[ø¬²~äag'qÏ]çɾé]ñ¶;¿»¿I=îOl0“È>u&V¹ˆÙá+—ÚoÌ$ž)2ö€‡ªº‹±ö*õÚ³Ræ½Ô…‡ñ”᦭ü KÇ¿fr()€Jå-ûml:uy–‡é é.®Î¾‘' ô¶Gº=§o[ǃ÷·dÞ%îd O(=G\mטš;ÃM=ÏŠ•ñ?AÇyâgSè¢×”å[)V<Œƒ?N”AÀcwk%£ 3VªLï{ÕÒæì7æî3OR‡­Ú‡Žöjvl=•$¾óì9¬$%þ¿Úh»aiY5·˜ÝÙ1ÐíhñÄ&%1‰›|G>áõm·r™±¡•ÝßUõ÷¾ ˜wv²Nù×h'À3Mçõ´ø}k§ˆÀO›1Šï“Ã(b}¬w«iëMzùðc§±³cgf÷jMiNÚ]í >+'=²¹æñе—q»;s¶³½ŒvÚõ®ñ#z ©•ƒNPÄx÷t²Vé C•¶p¬Ï=”^AÞcº‹b#t·­éÀœ49?Î5ƒ–ÁÏøƒuÂáTbÊõñ„<ü¨¾¬wyZ¥gŽÌPýf `åQÛ�ðl˜.H×d¹ ‘éÿz$ÞÜ„ý)¡½4YäwÂmW¨íº#Æ¢o*vûº…9Ê@*5i¥7ÇgpQ‘WIïosh½ýø›²3*<¤i,þVUnlÜ̦ÔãäÔ¤š®3öÝïô„^xÉ�ËBïA…‛YpGºA ÀÁ»@Ù<¼z «%…*¤…§·ã+Î)“ï!£/ñLôx°ÒÓ­(¬ÞC?ö]al÷–¯OQ,TR£�Ýôøí‰i‚_ÙyªËoÃy#Ai-ånCï_N?f(O>MšOEùÇÿ>R#y§ÌIÝ/ðHÆ©áMÇ«Kjœº TfÓÅ"Hmõ>&¶·,4ãüÝ1‰ƒ¢<$èŒAzïZSPgþèÚýi`-1½P%GäÅ¢JÂ|²¾i­<è’Þz2£¬·4}-éˆe'Cö ¨‚º glVÏÃÑØ°ºzB€áÎ×›ª{¹³êx…EO C’Áù þnøªtÐG „ÀÂå=X¯–¹ÂM¤¯xÄgßÜnˆ÷O¸øQ˜ZãSÑ º2H¨ø—L!gÃ2n¶ÈdñwZYŽÊ`þ±§¿‘~þuzû=xXÍxì0©\ÓôÕ©“cŽ;®“'IæÞtc¡ ’ÕʚǬr+R•F!Ëoê>,Õãh1;/ÄÓ,EØ& Ù¤·í®AÏö£%RG&=L.}<M-ŒgÞk–»¶‹šÑ-X\¿òáÛÂiè–Ú0ùIP.*•5ë»!¤“¨ÅAéDŒcºïÐÉ@ÎÁK1ÜtZîi`aè{“âž!üž,s ^õyòæ‚¿qHŠd¼y`3Þkæ…ì…ÓlwÜ Šô»át/LÖqû+{qgC (­Ì==âÂêýÁ—º­-rBð\ ÒÕü­†¼AºÞ8à3¼ Û\²Ut x‚÷+Û?§s!mt‘#‘Uô§>–œ¦Ó ó¯Cý5yW¦ƒ\TWýÜn(ƒÒZ\ZÊÌn ©¢õÂ…[þÔ0É)×UgjÉb2ÉKéÖ‚o7iâDãÛÿípß¹¯ ˜U7vín³C”q—ÑDhAÚŒ ±a Ã¹´Æ;Œ»•]hª( RÍeñï=í¤TQ_¡©¼‡å¬XfÖ”*Ñ¡lÄ=!Íq˜hÇp”;Á#Ãb fÞÑ¡ÚY[f#QÓrA5 fĦèõ/˜jwx‘ÖÙanlƒL£’“Rç ÞMÝÞçFžÕškqññ@ù0qša +iOt3òþè¡Ù¯.®ìëæò†‡ÇST[u±eGU”j[ô|l[uø„bŽõ{ÝS©9o½«ÇºYºˆ¥aet”Zm¦á{u¬DãKÐþ½$**ƒ³`ØQ¾µ›�Ý"V9w s× ‡ ¤´¸’vœò ™­¡$Ú!ÜM„9—øÞ©ßžTrù"P�’‹–H:^u³ƒ$Tù {–cå ›JOMÆ’*öÑîôÙuœD¾æ1 »~ãòÁe*¡l<q¥‘ßæaîOŠcT\¡§ž£ßU×ê:xYhÅZ—,úX6:ýÈÂz™hrß 1Ê(ÕÝþâ �©N‹Cåøm@Ö´:)á'O•»€SäXà ¯*L-~x,;ÅR“v´C €j— üÞz‚{Bé•ï¦º<ׯ®dIÊ…ŽUL&˜Öpw‹µ„¹ˆÇ®§½ŽMÄ÷oöp˜Býæ¯AÕFVk¨aµÅЇÿâÙnxîÚe‰à›Ñêbñ@'t¹Þº¨>í8‘4 ž÷T¬ã´ò›‘Ïú¢õÓ¦zò ´N=üñlÒßT%:y•t¢SyV™ÒˆƒÜàÚu“á¯Ý—k^ PélÐ-{Õ¥£$”åêm„£|‘gÓ¬yö>ßd#èI¢;MG½1‘8äA»Í‚òÓ:°öW7¡ßãÔ‰G½‰¬ïaåQWöŽN^ç4€zmÞÞt®_5°£Â4á‡z ü½øQ›[Œg±?0£z.¼>Ú*ÖŒ*/®ñæÉH·˜:¦ÍÙ-ñóŽÆ>íÀþ¿Î œ@óšÓË÷ÍCœÅ­4 p5³ë.x+ u—_XÁx…¢(H¹4…vðp£þXõõ‘;v÷“nêúx*h£$ÛO·9é>L옣“n:Úñ¾y.^E^&Á$Ðy¤¢OåóPøÔô_zž’¸,$=|AÃÍ¡»?Gl¦­@Q{ºŸû¹qQffîT§ž3WÊZ @Ú/ ã÷=Š(ó»ÓàÜfA8÷žæ;Ä™ƒ…M•XwÖ‘×?Î[zp*·}Ã!õiž §ž€`OÕV೑2dt33)<Ó°÷«%KsÒ½cA_kíTJ¶‡£?ÅCFy™-Ø0Ròm!UQ+.wõõZp5tóo)ï§d¥^ßnuÀí•öFÖÜlY³Ù„<q÷¹ïý‘xšûž¾´é¦™ži¸Ö²x0«)o]¥$~|qÓ«0–Áüe‚¤ÓX‡ךŽLÖ¶À¬Œ¢ýHKÍoGÊä=ºUûÔØûDLm]˜è˜z6w¿h&¡ú2¨·#E%zÃÉ)·}u,ƒ,w z›<†qÇIî ว#òóì Cûúâ%k“¸~½ûymÆ b*†èÚ5:僼cm@]1oƒã â. ‹vê@«­àXœ¯¬lÖ/õXãÔ®X’‡-é7¹éÊi”nwÀºëË«¹}—¡7¨¤}:ƒ‚“~ON`ÀÈ&~ ¤8è%áNë+7N"Oü&2£‰a„+ç§5ÂÎ;üå…0‚FþºÞÍÛçª~å¢ÓÃn­™)ŽÙó…n!övýÅ ×–c²›©Yì»êDXàç–îJ¼µš_“l(©¹L¦Ïל¨Z¼è â8Û¨ÜÚ:ç®ïƒýÉÎw`Ñ}ÚÉSAv?Ðgä¯éþܹïM·žÇÿð ­Ø¹cS8yÇßÎÿc¯+ÎSN©Ç÷ïà+¶Ž5Tŧ-½-E3– rW·µtê™J‰Û@ËrÔGÛußž†þ2 O®túæ»É€¸¦sÝò6°ÀsnjPáè'ÈW?zÜÒ˜6P¢ ·“§QªÖ-£ Œwh[§Ï|*J­6}–Ð7Úz6*pcÒœ)¥ À»¼Íó+m¥<0KÙâ+”d˜ËmÚ-Ü‘ ¶1?å×>_&º6I°¥l ízÐÀüOÓäRó1ôÈ;·ú—?ùÙMb‰( …Oûà`뙿ÎëW”$N/²Î$ôt=FßÔ-l�04=<oUÈ8©ºÞ¬œ_%ÇàÔñômœÏ8²ðE4! ÎƶtdÜíóDj&/“-TŠÁÀ*;î»UrÓ,üÑ+¢íŠšÏ¡OƒÌèǼ ÷Ü‹×G¸„“=C•¹Û=‘'¨bW[}vt¦î/#e—vÌ;sy‘XÃ=¥ˆŠý+q$”ã“>JÄÊÕX7Ø ÿ†p\¹ƒV 1SÙX=|ˆŠÑ‘dðoû¨ä‹ÌyëœÒJ<y%9‰"zª%â¿’[N\CJâΪ¦˜–Ûºã»ußí—ç^.ö⣨œV/ÖUM/­ÛªìàºÎ'öJû'bª¡“Š…²g4 ¾sçMøn_lxkk*Î}aâæ„ óì·Èǯ›!ªßAOŒv}\Áê°ß³&û4Q 3=*]6!cª(8SÒùY[¼úÇÿ>Ð)Ü T¢ìŠÜßtn)~$4zÍ@ùa2†´šã4kÂöÛºš7bß!¨.™Ó‘4awï>f)˜tò¾òÄa(|šù=pO~BåžAÒwÖ•#òÁâEúž{Fšú:Ć'ZFÕZé¶8Ú-nH†a`Ýða&F& àmY]Â÷«®Ö/áýlžl¦0fËÂ|áýw4øcÕ7ŽCS¬öv•ˆ�Yn¬QÉ(ç^PÎx±Ñȃú B1§lUæAp[Óf ô6éhë¦o³û¬ì$òà6"¿¥uZW‘,P'™Ã>Ñ=sTRb¦p(ÁdȦP',Çóp£3t‡yz ‹óí~Ø„ (û­…^¼ Þ6£é‘²Äàæ}Ѿ2L³Ì1Li¯S dGc Oį]‘5mbö@S^ pÿÌÔ»¯Ý /(†ª…¶Z„]ׄ[3Öbã¨ó9«`/n_–;·Åœ+¸ ÎŽó_U‘ çGŸ3ÑŸÛžV_:ntçÔ ŠÜ]Ï81ËSîe:`@‡BçxPì?ímoÍÏ–?á<æŽìõ)ª…ºOŒ ‹þÂqò@x«ÓÌæ dñ„vûõ¾“ZW¤©ýü‚=šÐ4 ‹l0\sž+˜(»e¥J¼Ÿßm{àºf"㧮è*ö‡õ2ASL XÜô§î{wÑñ8áÁ‡ÐGFm#ÈjmÆšˆ‡,oÚÑÎùïGTÁ3ÛºìÉá :ƒ¿uN¯÷Ý"Î/TTDƒNA¢ÐÃDczjb¡wi2…âUìb>Ïâ g”­k~ÿ˜{%ã¥c!Z¹s¿œøF±{:âÉF!‰êÅaÔ¼$bâV¨P—öò÷Ðè Zf05×á¨pÇ;~œ[ê'7U‘öø±n[Û0=Ëpýæõj’`Hn’Ðj³ÙÖ‰ˆ�4wêûZd"4žšÞÄ®m£ÊýH5ù8²É^�”^qš1 ²NÑy° àÄ(åU²´ ~ðV¦¾SyíÇ(þT!u¡u!>ði!áa¾¢ a ¼ßZè”…ÏÆ<­¢8v]ט+q‘·¥sãt!’Pú•A¼¶¸=&k Dëpb{ÚlèèåöÆêP÷BýE£Ã—°c®“ã~DÛX(E{Á–ÿE‰èŽ}̽ÙÊBW•ÎÎa`ˆä×6á’O!/c}äfÃWÑ?ÎA®yƒºt¶¹HÍ3�îh)÷ŠiŠ¸Ù1@²ÞÕOu±R2îú¹ìm¤æÈÚGyÕv,'áÂ.Ã&=õØÈMK åãbœ#Må£ÿ‚i¿Gƒæ‘Ëijwöz¦›C{è[;&ïNè÷èŸö¾}‹P:{ú3É‚û…Q‹°ªõ-ÆýÚ=q¤öˆ‘~ÍHÁªî+åë2Ô“§*`vôã­r6Qb¤^ÑdINVX+ÕÊμÐf.½š5Až$Í“²"–ñ¿›ù¸™ÆØÄb@Jç ¿uBgŸžÄ<å8FL6ßv=¦tG †;'Ú÷Z½Ïç;²ÞÈá‡þrÔ5‘õyÿÆ°aH•ï ™û“¡�E¿*ÌK ÌÂÆ;GG®ÿBaãQ ±Ôz¿]°FÿÉÊÐwb”NJ«z6q1,ý2úßÆ<% p–î¬o+$M‘dÂCüÅ/Š¼•ÀÓÿî‡@ÕêpbÚíûÚ ÄõÇd0ÀÉ@{‡…ì;ôq'>˜bHèv tÊ'GS/K Ö¦ÏZäÖâZø*´–ÏE|«<o&®¼ï¿å…Ié A3ŠöÜBO{l€üÙØ®i,^bØËŸ='v¤>`›>fâ“ÔBàÛPôçAùü"’‚uû}BÍãM^V™§O”Ð!¥@ò­3‘ÜxöÉ7ê/ÆýÊ»z 5Sx}ñÌ׋ÏI§‰•±1Žf:îªyý<E±§QœyòÈaдePkÛ»Ká1š¤Ò†Ô×Óˆ$u „„EIkÚáV½¢ñÆ‚ý±n”󼜜îò Öj²I{œüž©MëY¯ºžRaÓ·‡i¾P.õí³Ç¯^UÂOÍî!& o‰fmHØh¨Ì�X¦h9ß…Û SÆYÁöÐ(± #ˆ½žô¦ÕgBAÌè;ÿ|lê3ÛÄÚ¥ìVVzˆhA^£c·û‰q>*T }Ènl­Ø¯ ü‡éÜu_h¨2“àr‹p­xyn¨Xs]Э];–6ÌaÚÕVNÑæïáÂÈ+²fæ©¥ aåÚÕ#´h›Ë½y67Ðpºs¶[¯QU£“°ƒå‘Yª… ì,íu›Ð-ßþ…f^fžŒ~7‹v¸Ê7æÿÕ1õ°X‘øvRËŽµõ£/ôëEgŽ³û—¶€YâV';²AÁ¦h=÷ºÚî-Ä_«Ô¤züe<›OÑîBV¥òè¨÷lN Æ* Žª”ïNÖ£ { QŽ—-ô50ÛÚ}la}Îí¬) lÈ™äC\  M†9õ0¤­Í¬Sú Œ¢÷ùïG‚ŽE–ŸJ2�²Š*,Ÿ‹¯põ•“:Jì[+Vt÷×¾�AlºcÓž>Aß{¦0ì¿1;WU#ñþHé=«ë *bm¾€V1Z,uäæÌÀÈÿÊ$¹ ½=G"1à(¸Y;¡†Õ¡i¬ý.XÙ¦šð.'b‘ùp©2˜rÊ{Žßfî€Ñk”Z•Uøgì«ð> òEÑ8@ Ó3·JåÔö‡³O~‰x«B_LºVHªÚÁCo¯XO‚súö¢²h/ ?øBVy" mäÄJ£Í³;BÛj£¾ÈGôÒfÓ;JCÀ*RjëÿYn«ýšŽ§³e3ËÞK±f¢t}øÖPiÓnßõÐ3PÉ kh‚þègßtC6uIE“•÷ƒãür8¡|‘oÁhIóïK¹=¾BÝMÍ–*³FFéä;iÅiT¹ª—ùÏïÅßÓhQ¯%LxÃàC{TcëÌ"S®¥¡þ 莾Á…[°ãY7yÜâÌÓï‰>Õ¦f¨µ©ii-ð¸Å½>µ½b_ùóqºMéecâcÅ»™"N§À¹_T÷¦_/9t,ª´Ò {lPM@‘up¿§›0r–NôŽøÿ’9Í™Çi¦·–Úºõ&úgT{*Òø‚fsŠÌØïô}J›¯_;ÔD3^ªÕvýî° 'Õtíè.6çËе­}õÐ\… �-ƒÐ¢‡AŠ¤ѸÙ†©Ä0°\!A“Rݹ˜Ê�ŠÚ6Ò­ú²nÕi.²>eóû:Y3‘Ü’Îõ¤h¤…u¸²•‘g\A}×Í^ÛCÛ¾×ÎvŪL` r^f³ñ„ El½‰Tv]–çy75ºþæõqË|l$m†…Ãì9œoë D 7ûwЊȗ¶æ‘ä¿ ^§?EÆ$M¦ÞßBž¸š—Ç$¢xÁ9g)ðÃm^œ£46Žøó–ÆÔkÝ)Ï©É2:†MÄF\†zA•H«^Íi׳F²Ãægaw=¢9ûLv¢$ófƒÐÚ@—çä!]©väÕh™+oéÎF‹¾LÎm5ÝÙV¥>loÃ,{9J»a0ŸÑ–‘7œáÌC�Gh�¶Û*(ÆÆ3™ç#Ø®ÂzÅ<ymA,fºÖSѹ4 H<5B1—ÚôK�ä­˜Êãü ‰˜È³3a>cÖÖ ÷¾»écÂjú M™Uï,#ú$°¢¨ð·`"û' ‡®¥åäJù÷j~.([X¥AaÛ'LÝvøcª$[#ùØ.0úOäKBrߪCÕž <F‚2^›†ñaà‡q?hkª'×ëYB-õ7Þ~EÐwðøÀ6ttŒ:nr#ž»W^iš1ØԔ嗽„Põ±†…ºehÛhI:†¥Ë ‡ ãÜ)Ž“°ÊŠÔÜ'ÎèÏ0³º8CB=RÏÿuÿÆÿfÿý`F©ln)je€tÕU~dfyHR±%®‚= ˆ݇‹×úòO´R¸=5“„¾£Ã9>õ^2\ïæ/#á#¥ÍÖ*HRxø¶ÝLæ"eRK•„Ö"=§Ø:TDòÁ¡qGŸn€³^¬Ç›š9 ¯ læ‰âi4(+5‰Ü37í‰_“Ñï°Ó3¯¯ÆT¸†²Ñ0{´¨ÏzõåÕ)ÁØ0”Á¿ÚÞ¦âï÷ ’ÛQ…„£æðl/¦AIæ ›ÐF¦sŽj¦Zýþ†å¾£NCê\aq’·¢=Ïä{œ» £›Ñ苇É9ƒ~²t¬‰àõ¸fI–¾ë( É¿7½\–Q«¬È6-<± ²oZC[ëO'È6süsÐ/çå_+AsËyïú¡¯IÍQâ:g’çvCDŸ'›çVâ4ÇMsEøfùr `Úñ"£Íñm„pg/vH¡·¢Ê<ZÈÊu‚Žb¸ë?›ÝFyiC¬ˆ ¬/hæÚÀÁ¥ê/>·l‹þ“Å•õÔiÿ’¾ ‘˜ÁE{‘éBñk:´3}Âî3î®c%$fí|Íc­†1ªtw{´W…;]Ga¿ëÍàguh8ƒ“—;RÇQ|¢à΃–Íu­’:½åîO=lמŽãaxÝ› Ñ‹ +áÜ•Z…Èg2Eñ|ië`ÕKŒî ÿËOüc¦s˜ïü|.§‡#à:JÆ«Ééó¥ _è)‰ê‹=Q,ÔƧjØÙ#èì­×W§uã@¹ ðPãŒî¸OU¢“~JÁÍ™=àRsŠc ’—Ñ‹쌹ã¯-Üc_˜-²2 »¥³Ê1Ó¬•VW¯:&¼Ü…{ºÐbYÆhj39/Õ¶âS׌Ñ+樚ÌÎîÕbŸ0­£\hÔVa©ÀššvïÆdÖ2$¢R]$³Î¸„Râ L±’îû8w½I®Y@á s&.çg«IöOí¼Hð ;ÐwÖIÄwNxå¢U 2ڞ͘ÉV˜joëX´óòŽLi¤¢d)º<£ ¦³dŒë6»fr<�lvó×Ò°·J±aæÏØK裠¬·®Û³¶UÃËK6õ¶.È ˆýÛJÜt“TŘ˱§Ô©õt¥oÛ R‡:dQŒák /]o�|d\Ö.¡S9ì©Ô·†?8«håù6 \`Îój1·¿ñžpžZMYïã6ÊÉ*’$@Õ‹`ËpE}yÞkL­ü#Bðt§stÊùìÉ?Š Ã?"0øóAFÀbLdƒ¢úPHzÜÓ ýE+¼9í(žÀ¶NIþÕ¨Äö$¢Ðœ5Tƒç^Ç­ÊK=ÏæQÁ¡ 7óµ·§"$0›ÕBöÅ'ÙmÐqqÙET›Ü½tPŽ:ed|‡„Vq£0qÜÎ æc@ú2x kE»333ƒ™ëP•ªJûES²?!™[}sq ¾œacÏ€9)¸qAºûKMG5àÂçàuú±öĈWLm˜gƒÍŠ+CŸœÉE !OT"­´žœËà s‡ ÑÔ^¸ŠK7(Å3n» rJºdá£]w,Ô ·tîÁéÇÄgâÆiäõ"ävô°q°šÀñ²ï˜—¾ÅQˆ9UDv}´õy:Ètg=ÿ÷#AÞÓµ=«,�p®Û—ĈÇ'fQùú%!æ<´NªáÇK9e=«7"ý+6/ÞåR yAÏÏ 7'.%7ÄCZztˆY2šLžaeå„ì™2 s4ÏæYÒîkašó€(1ðø¤äZœ‰aG+¯û”9=lN”Á¿ŽÖuwôòvP3væ!¾¸òÅzSÃý<@ƒèlÕ¼ëçía_Û鶾p¿Áx©ÞüxãOSø6jÜn˜ÐìÏ»­S�3ðZøQ3yPîÓ ÐÛß t˨Æp)çnSÐU¢Š¹0wXÎÞà­z˜™ørn©F¯ŽŠXG{¯é¾:•L|sï+S2äzµ†åBÓ{ztXPªæP×Ø<-š_ã–>_[¬.ÎÒz½¾÷+ä¥Âƒg—ïòûâÍY´ˆBÌðÅÛàµÏwåQ¹¸ëÙv± .Éø1Ã$Æ{Æ£x[·mÇ$y.ì¹ï'¿K�XÚ–ªæêÜz„Š-}¨N ƒnåÚ5&¸ÔŠ›-tVÏkŠ.½6�Ù½øZŒ"°þeU”¡çèGÉÈæ„RùÇ1EVÛ03€¢ZÔ&îàö®l2•-Ä:áÇV'ôàþúefSÿEÓÎã¨8ëik¸‰èg–Êõ,Ä@›£ •ØPo×>©²¡ÿcç®k×0Ø+ùz]WžÛfÉö®@e?'[E« Ó»Ñ4-·Ý~bb%:½*Š*¯óÎFUÝ=Ⱦuä醽‡ôÀ»o•WYdkáŠÐýuÜO±–J¥î¥ö¥®p¢}YPÛá4 D¼s('ÙB‡9‡FK”ÝäTºZé%g ¢Ø“úªC„2Ê $;ñŒ2,˜¾£|k:L ‹-U>B=úÚ52-¤#Ú°[íp`ëäÆnÚÑ=§²ÇCN÷Êê°±1F©Èáú;ouÍÃÐ$0Ì0 =* œ»¦ÑHË^ c8'Ýtïj„G kûÚ±§ÆO>¶tš¼)ƒ$׳ò”üÊ¿t8ðCrÚWtk>;'GVFQ}7¯Œ5¬ÔøýZjç»ÎL—Æ …¡£ÏOëF ` q5VÒiüV:)|'MFPR9^Š&¹oè®ñìæWO©ò|‹+!±¦AUÞZcÔ«´;ߧ±Æ¶ínqŸS©imÌÒ+èùÕ§ÉS¾°6î¿r|/2·¢¹£:•QP J™Åìš»¡_ü¬*1{ö[”iîN^óia=\ûì*îž™àÝZ<ÔƒK¢,Îm†‹ 'ËþŠ¡¯<H|2„ç[³Ì[ÛÌ$/\}ÌR±Ó†bRSë|$<Šù­EóÔú<¡«ã мÒcrt—ÐÜ”ù; JŠÄ Q`¶(p5ÔëœQ‹j*aU5õE_|•ÂÊ$ÊS£òw < ×+Îb¤Š¨âaÀjÂܨ}ƒK]¹¤CªO‚â¤É…$æ+ú_a~0ðÞËG½xêôæŽøÅ¢®ûŠ2ŒÆLe#ÁÏ/†âZÏŠ;£Ñ—Ž¥{HeœÅñèEÊÖUS³kßkýÇig^EÃ�lzßqãPS·: ¾ òG=‹õ¶¡ºMuì—˜ògvHÔ„/*ߌૂdP5’Lµ¤Ù×Ò´9“ÚŒ;ÓC{¨ ’øÅcS¦ LÖºvÙÃH÷áÄ!-¾G=QZ b¾™7º0º)SRxx½L‡3³<‚ š—ÿLç"JâÌãBÓŸ:·ÜÿÑ]C‘p!åÉÚÔ*ª®²f/j(›d ÏL›’uÈ#©Œ)vvÎEøX·;.¶Ÿ‘lJOf‰ÇlýDµ<]<»$ì}·?Ðê9éØý|6[x@  „#dÌòïÎSÿX Þ•G:kAUÉý†s'ªí«„8‹|sΰ¢G7%ê­®y›fXç’K2ô®–J¥§ôÂR©€¡'¶Ã–Åñ¿qVÿº³jMFØ|†nùª¡4­ø±°6ZØY£.Xr>n†7O ´¦5W9]z&Ý_«,üCgïeN»‘U—m“¤¡êD™xÅÿ§OD,­ð„HûE¢Ã—õJhLÒ$0šZÿL‡¯ŠìˆX š-}—Z•C»~2Sd&:ª~ãúôjT‘º‚ç€Ù�§³GOÀy>9AX£S芻Å÷лIæ{4°³tŽ-n“µŒY[�YŒ¨/sO=&Yª&ÓAQP±mµë0GuÅŠ|¼sn/îHåÿ¶d·æŸßª˜^²äâ9(Ja>gî4Ò²4Íã̵0â`}¥Wd]V—ãxšœ¯Ø>sC –(ëKß^ƒË’¥3%TWZ©¥¿Í¥)N¡D¬Ð«Œeå�¦ÏÍÌ[°¡óÌÏ:Xy LÛþÇ»1]¿û[ƒÿÄY1­ðÍa60švå]=l#툮õèMx¾ Ì™Å.¬â;—T ºZ˜ãF¬úœ`IÝÂë…SÎ-Œ¡/Œ‡Ùè›_¼Ôb<xF0N0)ŸæÀ[ŽG3¤ŸÔ莓NHGaç³fµÑk¼”½7úî ¹'ØáëXµr.´ÓóO•l­\ØŠW‚.½/¸`9½Ä %uýpc çŠÑIUç Ä9! 2îŽùÃÊß9±êºóŽ]/îò®‰fÅk™ŽÇd(VŸÿz�±ÎKž V§¹ï‚#i»~«¿¥¾&ç)ÂÒÿ¿ÿÇíÁ4ÑîýîÆZ\,½¥¨ éE\&µþ¿«ƒ´ÌשAÔû5‘-òŒ‡ÐV‹©ð¦¥\öÖ£-©9mh»Ý#{ïNví…L‰»VâÙÂØ…êÏT@`{ÊØzÇ‚th1µÞÔJ)üÖØ_"»0rýÕBôtè©œIhÍ”œÉ8†Jî\<xRr•G C‚DrÙ²Ô5„#ƒýª‹D†Š®³Y‘ÿR')õÔ] vßF ™U³3‘Æ3_mEÐV0uŸwy�’+7MµcWŠ0ÖkYW´ù´WT"sZLÃØŸ3Ï ,æbÊâ ²ž°œC<ØySiô{q{² oI8dKN ×qŽ}Z« ú²î/8¢ú//Y@[Î9á/êúòGOŒÖÀ53J)^+öƒaü‡¡Þ¨ ñ´ãÞ1øºú vóÚ”÷ML‘R&•úV‹™úXü·môl™L§…OxZŠÆöå~b£$SÄíŽ熧'S×+¹êʬÖ3»DÉ ìT¤£Ú2ÇF²k_÷3ëêYMéÃ@ ‚v7MÙñ‰¶å±Ý4ï>ÿÖ(Ê°k<{Ý¿zµÒÒö2´X¨Ë3»ò̆˜ÜÚ”³?}=oþ`Ö!çª,‡Â¹U¤Í³Ì÷ͬ „Jásk¸e#ÄÝÕèÍ­Æy'Ž“šà¼AMâ̇jQ…=bèʬ¸à µ å·“OY™ª÷»–4GÆ#`JªÐ¡|az¼§ wH©cŠÖÒLoùÃh$D¼ ~Ä�W{˜ÈdÿìVt<îj[T>Æð©,†ÑÊÃŽ­VU…QÝãöKNÔ¹ñΕ9EQ]•ýTÖ zbôwªæÛSI¢„ýcs E£TÚÆåźÍn êñ4\뾆Fu#cùT:Ãï¿fû|vµŠÚ˜Qâ|8`#™ÙÊ;í)g,˜X1dA¾¾h›©•,vs#hs~ø£Å(òl©˜ÜÑsfzúö6ÖP™Šñƒß+yÐ1‰²ÂM2#eY°d¨|þÕxZíÀáWKãØ“$íðdîŸ[w§âC—¹0*’áçšÎ–þ¯w¶óln¡é “>œ]oûþ¥7™ê=䲶Iÿ3Ý O´ãƒmfƒu‡ÿ<¨±µ$¶à#«2²­ó é?=úÀÍ-D~gÈK¹!§VÍ@UyjK³Ä¬Àyˆ‚lR&EÉÎĽ©}”õÏlb“| B²ñí뎊ú¥àn» ƒJÀ$@ÛCk:&Hù'E¾`ƒPŸ×UXý¦$tý^OŠ´Lׯ/†ÿêÿø\—2*¯å¬O -¨°×é]œ¤œËTÄ ö,¬Ì|?4*Z€@ÂOÕ*Ì+§'(ßFðëÓ¤cƒ÷Ôš—º9€ü« ·»E̽7ÞߥNÊ"óòiºß«}QÅÒYÛ]Ldz&™èp˜E@îÉ\*¾òäjª ëuˆrD¤…¦úcÛ¡Ë£ºÏ6 ø—7CÆØÑN°é8VPŠØ×Z-f¢"F®ÇôH´Ê|£ ¹Ã�öQ˜ùFòa!ÍÞ¤ÿ1§^Æ8C‘6žßhô:&#¿%ÏÝRJ ¯Í¢&ðÜÊå!î3v­Y‰7Ô»Ø*öÅf]4eƒ2 é½02Ñ™…Š‚ôËÀ\ÄVºTüA(|~Ø'‰ £˜#“ƒ4ÞY+¸P¹Ý9+”)hþØÌ6S;xåƒÍ-$/¯e9½--:+Eo”(P†w`!o Ñúî4\`ç6 Šöl18‘C”šw馲®§Oƒ{éR(µÆI?iËœQ*,Xä0Ÿ%™™iÏN0à–¥ K… ?Ø’µ9âcã±5V+p ¨·T8"/!„ó*¦ÿR÷šf˜©‰‰2&Ú÷ŸkN”hïÅþ Øî«€H+}{„²¶m€±ÐÃ׎¥iU7¨Ñ¥…)løèí‡;ˆÞÌKc9ãì{zëd˜<GbÖk¼(˜¼kDçÇl‰¥\”†46ÀKµX×ÈpCqnÃSm°:ïWpAQÐõ#=,ôJ…Ê T)|4­³ð6Dy³’ŸµÐ#í;E¬ æɞΨNϨԪM{Ê}ð?§ˆÇCTóbÑóv˜‚Ó¦§Ð0XÍd¼Õ|Z¯ñÁ`~x_¡°t¹M‰7F¨ƒM òÚCåiVvâz_a$-¼f/ü™× CM%a>[µ•ÚÀ£gtý—ܾ 3|‘ê5jëÑS6ž!HÜ“çEY8åÍ#UÏh§‘ÎΤ)ä@9ïíW„W³Ó�*ñ¬ùð€Meq@K îD{Ž»˜O™;:²MiE,å|ñžW?yŠ™â”«õMDv¤Â‘g8!ˆCF¤LÀIxü‘ ëh™ù�&rññ¯b�9›g;"x>{=žËBÇ%bõå¡£í_3™˜ûÛÃ<O£âûžµóí…¤Æ`¢rrCI-¼£,e“àŽÎš¸=™ÀÜ`°µ@õäeÝ{ñ­òóÌ'>zŽ0˜w{©8O¬v›�#¤pÝÖÉN诚´øýÉä×óÊC€Vb{‘¢züöÆ]»ÓŒ{Sïê.îŒ0e´2 c¥`Ž‚öî 󠹆‹Å9½¦¿ÄUèO])¶m,`½5XÂT}Íæ¨/t@r'õÎË|Ü“¶É<»’ª?ÁzQc*E¥ÚØ¡æåªpŸ˜eº©á¤%†Š_œKA¡ÂgîeòuÙ ¶Ì»ó`ºP¼hmûgt‡®FPqN€ P­G¹½°rT€i¸©ÊéàM¼=[v<̵ï¾ÍñªÜˆ^įö½[­w€ÈùÿTAÒôÆÀ ºØ›\_<ruhñö©tÀiݪ×uÁuý¯T4"o*IJ/{ʳ#熕;%Óäñ,Gdïø^ß7ãôl÷P–ÅH´h§oTè*fgR¼y/ˆÌ_¬å¥3c)SI7ö¼®2×lwÚ¥›37s‘¼£SOÛeÅgýö”12ty”Ãò¨†qá›ÖÊk{M4³¾nY³…×"@FŸìžkŲJà?qìó=yWÎ5 =õ2vïk‡$ ²q¸’X–â}·Ÿ÷êá‚îøèÜþÞ­õ(Õã|ÀåÛ[œ[«eÛŒ°I©M?Mo< s(g%ßn=¡qwDŠç*×7Íã-{A\Š亡¸•š6ï¹ÏýÅYÍÅ@QDü¤`¿’ßI3ß›$Ĩ 2K D–²ÆÁvÍ(ý½ÖĆ·ZðÛøë—F¨’qx:Žö”å·Îþ.«þ4¼MjºòÑ—¬·B`”ꯅ¶ö+å ÞGãµBûzw¤º2úœ­ª Ê}xÌH/ÅÈpZNÓØ2€#TåÒð*64ÒæÇdd”0L èŒì I¢¡OuPü+žD%uý%ZV™×­ˆ‘1îõÇtÊXSí„TÃlS~×”·è¿Tɶ»£/óG™ï&ÕµFSí"•wÐ^1¨–CÒÒà,DšÄ›•6”±º…óð?øjº‘qþä¾>kJÆüaˆ£ðBý7½}-³¸ä°ò5µ ‹õƒJÁÕ\ïÚ– 8M=_Z§UŒ!²$‚¯ Ú$Î<aÖ8ªFaˤ4p&ó¢ö±¿šËˆ·¬ŒgL x_sX³PÉöT餤?ëÓ“0»¾Aï„; ÿlᕵ|N‚|R8þ±ã1°•P5Epe2 ¾ƒÁ¦úhR®‡èìô0À¸3ðZ¸5"M£øP|; ‘TÍx »£²$žù¥'Ùr´Õ�xÜz“-ô5R`šñÖï¥%žõ!ÌŒo=ã³V09F>ì.®ÓWÐÆÜS¨`îój ƒâ§½ç6‚Én7eÈ@]¸ee^oo­åÍ wðØÁ$cð°`«ÞÂ÷ÅdÐTL¥²‚gÊ“yùKOšœU £ä¼Ñfæ‘Jrú„\æ}ì¦zƒs] Ýú2ÇsßÓJÙÝqMÒÄ}Æ[J·G[Yö€Díö2?b|c*©e°˜.T 1lÃ> ?ݳ¢!W‡Ú)ÝlÔÐk¶IPÕ:£âŒÖSø7?s85×´ýçzf¿ç¾|ñ)_„j›_Kú˜5Õ„S ™»ïppA^åb_›ÑêÔ.ž|.tmbЕ©Ä<^,cŽžý±ÖD­#J¾¼MX®¼e?écϽK$Œ2¡iHQ®£{Mž8^j{Ò6V”dõž }µÔl˜yá˜8_ºÅõ —êpQ!“ƒeôé µ]Û ÿˆ÷ëç3:å®*ë ‘;Ó¬âx€ZÿÔ{!i<q«BÓ¹á0Á.¢È0V瑾Oñ©²&8µ?jO@zƒÏÓ4ã‰ÿ¥Ã’=ü+|k0wª'†Iµ‚á’Br­`|äx þ;W7 ’GnºÂÄmÖÙ@”A̱œ®Æ›Î~ex%8Р㇙Rj‡t7™¬:• Ú{€å»‡î‹òÒYX*¤í+*"U}¿0°N-8(åu´ªÙ;þðÆ€îmáN 6JädùÙ:Byk-NíÊY6S®%X¹w”ã´t{G”Ó!¡:õÛW¯A1æ©›OT¤b4¿˜û<˜ÑÅq¾°Ë VGÑnÒåÄÚ/8çÚf—Sw¤Wþå[ß±K¨Ó¨óå_ß P§vo8òO­OlÀÍÅà.;ÊIèfƵ¬™Ð;ÒC,.–²ÂX?½/Æ_d¾Û‹0K éÔÿ‰)œ»~òÌ[ï~J)‰þS&™‡9§ºšó ÿT¥nP%(ã°¦t~T Nº«U=HÀ»8¯ÔèJÍmþ¦›\]ΣiuéþO…: 5=ë’|3Õ5 ⲜþØ#5ðÚ¼V;¹ºåÊ8úUPL=[CÁ#ÎXI÷cyÃìØIGÃÓ^¸Qað•?CUyÊ’�‘WU³Zý )é~,±â‰†C*êÿümþb+±±+gà„d•ÛÝ< áDA}¯æ1ÇZ+¥ëŠÉ÷Ó‚žylýZgrµ|ápø2*"=É¥ê-è!¬øÐÝU ö]Â�¢"ˆjÏçælÛ ,�îM,ÒÌ›w¥üÑEÀ­1ªœ¬¡¬úöõP÷œWã׫Ëtéû¹cg€Íá®/Udµ£"‘2¥G[øZv­jzo^8!k…”ØÑ'?R 6¾Ìy¶ü íþ*ó œоÿ:ő锦}ãpeš®¼ÈbÜ7R¾ý™*‘QÍkSƒAötcÅ2 îs'ÿ ¥ïzHÆ×ÊG„QY²­³ j·&ÙNU%)áõâ–æq‡ùŽ¾°ŽûùžHRêÎþRˆ Õºß^ƲéÆy<µÝÛÊ©Ï ¥)D•: ƒ-få¡T£¦Gb´IATIGÌ",…´Õ÷Œ€œd¹fÅÒg>Œjª÷ZÉ’…í¬|ý¯qðpäSýç`¦tŒP¶¿ÒáÁL‡ã׃hhg§~RNo‹›ãÇGT'Õ·~|[Ï;¡9 €FKŽ'JéÕú²Ò–­€G·—C´U'ó^Ok×ȶÅ<›*•mFåàÿŒ¦ÄÖ—ûýZ+œ#7„ƒ‰}Ý^XfŠÎ ´:kÊ;VRþÀ”löäßчŽþûÊ­<½ijÀë‡ÖþD¦dOw¸îzK–¹t‡?»^_䌰M=Ÿe+Ù#6­6~ÎÚßÎsf\çWvÏ–ªÂÇÐeA2_LR‚Ú«Ö8 Œåÿ¥mEá\W±hK6ª¬V䆢7N P*øWköýV*‘eÅfô?aÖ;Žb-@zè'ø/ñòö·KY]ZVl€Õp!.. éïÎýPW¤íÃfó›±î13ø—†Ä‘ê-ØŠÖ_BÀò²3>Ö€Uúo]TòÐoËðê«Êãçwʈj©š %|ÐI©ƒ1^ÇZÂËfêñ„˜ zAõ/»_!,pGOË[¤HtH›—iåD’î8Šxº‰èùM µz£<|–*öé–1éšól–ªÝ:“4¶ø;ÔçHn)Œ–ý‚HuÀä@Ãg'·xÛýo:ô¸Ï·¿Ù&î[/*,—ÄÝɦÂ@™fy&î¢XmžV¥ˆª`ÐY‚ªc_öŽeãöôÿ—ÛÁ³�Ýû`®_L«Ð 98ÿ¡7d÷Hž¡C‘®SL3ŸRÈ4Lízèe¨&õæò§k@RùØPŠÁû4 ŠYp�±©ˆèئ4h2SK xoL¾áÝ÷v[a?yú£ ùÛ €°´¯wc’"rZ¤<GnY%¢^+¬ºàaOëX[®kšiM f¶ML’kxíêøf ›:ªê¾ÏÆ:âÒæ²·îæðæ`Åqé?œä¥o?CË}{¤(°0Ájºù³Ó.Þ¶Ûwýý{q•ëŸ1ókuác—ÅÆ:‹‹À8ç¿ÚJØœ™ÌþóþvîtÄåq5Gh6¯˜Î÷#¾žÁmqÙÄð)H 3Æ äDZ]GžòR‚êúmÏä³÷tÓæÐ6&ô#Úóè¦óãÅžF©èöQzjšæ êÔ‡•ô>rú¨’Ô¾×€K³Ü'H–”Æ&š4OJ*¤¦é@Ÿ‡- Àg¶›£gFaοT)åÏ>Ù(3CÇa„í·N;«xÙ¦AQ,¾>Áù‚V›«ÉoùŒÒسä]â<È~,W¢õôÅCS³=`î¶ãý{/åÁƒÒà l.}@º6pm•( P´ãiCçšÿïUÑY_ëÒÜ1¿6ÿº– g6õ!À)±ö]‚mG~»0‡š6 Úu"þ¼ J4æ‘lX+åòÏ7Ÿ57á*¡Â™å£/V8Ϫ–h+ÝèÊ@q&ŸdØÑB‰˜Ø!fD“{{ÊÌ.N» XòïÝ“! }9Z`‚sHh ~gRN~ã0×#]yÓE5Ê|Ñt¥¾"X°Ïìos¸˜r ÝMi`.Ï1±qìFÂ\>5”u…V¶ J/ÄI‹ï¢óžQn2âbÍ4Æó"æµk"ŠŠÅò=þ)ˆ mS¿DóZ¿$91é°ìa¢Yô“w1ª]ürŸ'pyØódNo…NÛÍ ­™±$XUÙ, ŠÓu¿ç¶rm@®[]y"ôLTc„lbŠ×»ùï¾>»Uç“I#Ô^îS“‚w`²Qlï°ÄG‚ÇëúÖVÜ#:€äsøÐs=üDýÛêIÛ¦ —©Aä¬isÛf—ãdìËû8«8L=qCÑw¢w¶*æh‡/hŽé«¾>òJ»¯âäÄg“…)ž$:0²0œ‚%PøtÜ}ÙÉx˜ö@ÂT’|w?ÐyX&Oã­îqA7ÐàÆÐö00ÏÛ8´ø‰–ü‚žIo›ª‚ +m!=‰²OI“<"ž—^X.…%æ¦ÓÞÔt3B Ô¡Ü_¼Úì€ûÀK˜ŽQì°sÖ ðÈ ‚µÎl&z^õÚÜ^z‹v·w á¨o¸þ¡q*d¿°2^˜ ÃΕnÊçà±oN‡åÿ¥Mh¹p(B+ô§ ê°÷lÐ6Üár‚jÛ®ÁÌÞŽ>ÙºAu¤åžÙzô´à×½µ)ZÈÕëý³'u&ñè_Òf¥GlSJêw`â{ô$2õÐ ¬ 2lh-EÛ­gƒTciv~®gtÑ}LmºhœÝS¯-Uî—kÂô öàƒ´»ú”×ù˜ØÖ“¨WØ‹+ŒAêiÄ—ÈŒú Xs­(¬ŒÒ?Ü89Øõ>sÎhdå²8[mW`Îrd<ÁÇqûß4‰ëe@ûw«5Ë3okÀ71F;˶2"î÷°})72ÄêR8ÐöÑ>­ü„#ž¢ÓNß°ÙxDŽ¿ÙÙi¥$ÄÌ9î ÂEœçuAÇöæÊ8ÕêÕ—°ÆÞ¤#åK(•è3Ô‰­àrÅÆÝ}ÖûÜMà› Nܱ+ÞayûebAxî)Tg«µ½ñ(G)­@öÛ½BêII•Å™'C½år4T ¹ƒÛÖ]É#Êíｫ{öÒWB’æ€|²¿8ù­y<M>¶Y´¨¡Spßî3¦À~fF¥qæR º3l¦·)ÀZòÔPæ ÐÚß{)ÄÕ•Sû„ùoÕuZƒ¢oBk“I McœÄO^ÕT­ŸMd¯|-5[aÃœrºø´tª–:OÐþŸ™æD”[xrL´˜×1ý-§ðÅÚ¢X Q9ʃýéÛì‘Bäq¨°^³`}¡Ò¤n¼< Ý�¹[Ç7Ñ7…ìA'nÙ2ÌJJ’ò· ©æ®§,Ë.àK–vœÜ¡û~I^)ÂOuäE|@—suÆ@gÖíCÎi†ÑZ½~ 0öÌ93§wŽ{ÒÃl«Á¬„ž»›A×ãQ_^õĦš*äfv�‚¶ë·;w—'×Z§ÅÒ‡ôU9£Vh€Ê9‡uh}F?²oij¦*ˆ6úžàL ,NºAÇÓÈÆûZ„N6ˆbâ/áu"V .ØË]-O…ÙÓ 7sÀ¤ñ!j¼4Q‚EJöÚós^"òl7ð³›ÐúÇ#+‹Ý0!&C)$[maǪ» œêx#3ru$>©àªÌSå›$’Aá<ÛîÒ"ñGª Ð_ $f×7x4\Aó@ê‹Ü%í¿€¦¯å æ ð­v§Ií¤wÊFýÕ†Mâ… ¥ìS$$Пù¢{D‹I…�¸ä@jƒå¾øAaCûègî Ê cîíu™Ð×Râ8ýŸÐ*h¹vßm>.ë®=ó)3SÒ~ðÔ€8Î]‹õÔ¦™Ž˜¢V¾Õ|êwGáauÝ—ü³`uXHÝ­6Yâ9¦dÜk^Ó¹’u'g™rìh¿Í³ŠXÍÉ@¬Ê|Þ^FZºíz×_ÿ¨~8Vfö´t»,¸Ñ°þô¥¢Í÷]iŸÔZ@ab@$óuÚ·ç9Pg÷Ì¿­ÏÏœ|*z¤¿{³ ïF< ÷²¥7ÉšQË1•ˆ•1îšæzìUÄ 8¤ SÚΕ»dX3¥ÄR)£3JId[w®TJõæ¾ÁcnúÌÇއ †YÙglasÉO'Áq¯|ÉD�¶ W­àÁa½bíÐÜíZ¨”ô0E¯¬ùTd$÷ÙÓY'¸ ø¨‡ ×"l,ʽuypp8¸rJªÌW|L‚¦­‚|«ª_i %?DôÙ¡ííÅí×¢èØ8�æ\åéOãì¿÷õª>õ*ã ¶ó Т¨[<¶éIãÌohP!ÝÖT|ê^”Ö;ä7ì�Ïâ{9Ìî�¥³³½ø¢¿ÕY¾ï<A\ë\˜SUÚÝðMeºrÇGþ}ÖàN]ºÇ@Ð r§o™œEV¸æ•�‘‡ÏZ1e¦l{ö ŽåýÍâ$þ…éoPÌ,BŠ®EP]¶Z³‰¬x¿ƒ ¼Ä×çAõUÈ£ÊǤR<ïO´ûêÉæÜ©›ÐÛ%tCžâÔ¥<‘˜ÜmI ] Mp©áýÌ"Òï˜3D‚pà,”KóÉ!8§ºßM^2ižXW3 ýÞU¦¹ï¼,±ÑôˆIy4{ò¿ôߥ5Íáp­A9ÙÝÐá[s£XÕÎE4Ú†Âú6J¾Âqï1Ðä°¸ú.$ø"J'Ș“áLË®›­ÇX-;Ñ“­¸‚¼=àåø¸G&ä³SÖi#e“ùVí|¯¸ٽθS :¶$þëõäl¬×©ÓÎørÞ»RtîZÿ9[ОÌú^Söãk'…lkKµ6ÞQkH ßÃýy¤¡ÊØ ˜Ãƒ|#y˜„ž–K!ƒóÈx¯£’,T_€‹F\Fw7ìÖì(>BÀè–zE5U€¢…¡´Ê•±‘gA)ruY0O 9ü¬=ÅÔõç‹fºª<É}¼Úè¿ÿf£±E1aX\Ö*NŠÚu ƒ²Ít'¦/}Ùò ëôýÜ#D°SÂSSý§fRRc§ÛʧâNÿbòzó cßí·;®7Yå€â3&AbE  µ¬™…:›Ö׆­i¨Ø ôƒ¹§0uT]– ÚÍ©ë[“5ÐvûaiëÓ°?œƒò”i9e 5à3ô‰§[%lVkC©´c¥Qðë†Å•ÜeaYd¦»iÌéÏÿ\kÀԺذâÌŸ_áæ˜qQ:縥=’ü¨``àÞÖ(à…·Ã÷h<µæ"lM3M_¯ˆ6±Ó¦3(‹M”­ÕéåŽKÍ UìÕ®‡Ã’WýØ—.ƒo–õXIàHß =ÚÞKȘ}²y›bëîaì";NLƒëkNƒÂºã¢æ[ÑÒÞ‹àèFrGE*ý!“ÉÁí8# ÑÍ1¹>[öN"\*ø[K…¡‚ïÂkJ}'7}½?ŒHÚîÿçDœy¤) l i¥ar–ù’‡¹:ð£{Ã2V8­åV6œE(¾†Ç‘nk·ÒÇîã'ß ,ÐWtê|ÞÔë9Á¦\$ÄFLÉ’öL ;6;16K>¼1§¸Õ6 ³%'x>G´ájédÑI•qµ\³¸6þƒq™í¸ ¯÷L/N·¡aVévðtPΣW´Àéîûäïœñ]œ…žVäOAÕڶ슦`=ú-·÷R‹¸Š\Ññú+ˆwfÖû;âÄRÍX_ik†2•9¶ðãç@\åVFHŽ�Óu,Å°•¶¾é ªÂÔ žA. p%%¢E€­9çSH ðJ¹~AÞ¸ŸrF¢ÃgEèx?›ñ9ýÃÅä»�x&’žWp¡(óÌ"¸OÜwT‘|ëY$f;v4É® #½gÅ‹"–£!Jq«œR%,A¤`ð—šèI•yjt[ç5ä.žUOÓ Ÿì «ËgD7n†qêì,·¡Ô:Ö¢@¢² ÄY-áÕ5ïöÂj?Fæ]#á.Âü:˃p°§LhÜV­„‡t:ôé†J÷È€i—ª¾EzÕ|>OTÜX1¼ñtB#Û,+ÊÁfv¯7ipšy3z><+kf‡£®d-¶í\ì÷²¢´�l£Ú¥”'®gLJ󜭞¥ú=Ò©ŽQ¾¢ßǽ™Ê{ä °ƒÞC댾Æà‹6SnÞ»V†…GgKäÃ>˜‚Ê,ÆZ{ Pð¼*Q—EÙÃú1͇JL)-×R„µ? ‚Óa<š1¶»z˜a:ãkFТqik9Y9)L/(¿­-m‰Û‘욣NZß­Ó7Î_šj¸7Ji÷&œÑìJ ÍΆ£_~²¼/dZ£îj@|Ìxë,O½"»b‡Ÿ źãä}hzbþÅb´&§ÅµÁs>ëËÊÌóŽ£#pºÐù]4ªì]°Æ†è°RuTS˜2ŽbTämáGï]çËdþ…Uäfþ1ûÒÁöõ¨¼Ú,õ³¨©´ö½/³‘rùX4鎊eŽ�R2 ÞtÉ*_K$Èsˆ¤Ë2×Úì%uu“yÒ—´(å«òc¤´þÏjiÝüÂél‰ˆ¢Eºy`Å%jb¨BçYÑl´¦Útú¬úå¶[©ÿÑ›|¡<YxFR©ºþGlLϽ:øÿIZÀXÖÔÜÚië‚’Œoµ�Ž¬ÉÚ»Š¢&×÷t\œF?"i3zZ²ÓɃøRÖõkÒýƒÂþKoºÌQýdÒ{žͪÖÖžMokŶE™¼9§ìOLu¢Ä‘{bŽHúéxtº0T\4Kü}Ÿ+‹YŽ]¢G!îÑŸ ™#̾ڀŸPUg´=–§Á{JßôþŠ?yÌš²æÌm/QÌUІËÿ¼7Åþ˜J=·Øúü&‘�ÒSršX;³#¯¾è?Ö«B…ñ¸ß³'‰HÑáÏî 3¸y<¨6šwÉÁû>&-Ã…OtlzܳúìZÇêõ Ú§Ãð–öŒwyGZ;^!Ó6X_² ²¨¤Y-4ÎPˆ•¨5„ØQÄf:Žãîj!Ô) ‚î=ÙfðXµ,[<ÏÝE°`F‡‘s»ö ¶[Enù³ýÌ —ií{lÞX|‡¹î_NVúÒ‡ÙfîEF#9}ÈÆz›w›šrs_^9£Bd×iéøRà, =÷‡˜m ¹Èû-ahØ­UÁù¿E¦‡šKï®VxÛn´V«¯»Öá‹Ö)¢Aƒgf|aØtB¾\{¢- ¼™wõF”¶~y¹ÑJê² š´±i»@sh'Þ#³oy‚{·¸ æ´ÇÑú°´û’•'±·6ci¨#üo7üo}bó[¿qãNß]AÉSM!©Ö…›¦\-Ÿ5çû‚òå ¤ÈeØ:Xj€6±êvEÎzÁ^H2?Éù¢Tû}±ñr9Ž…·¦|Ì(=¥Šµ»×µÆø€G"¸‹ FSû%ÄÊwZ§ÖC‡{N¾Žõüè™Òb_;•C -EËDVÛµúž¶Ü?ò’~³•)Ü¢­ð¨SaTv‚™¢R=ÃoÜ.OàêëIl­»|ëOù»ó-ôLg<üЬoRZ7¶ÙÂ)L*±|¹¥ ÇæÄé~Àý›FO§ , åA°«üÄP6hžëÿ?mÿ¶<²´‰ÂÇú®ÂG«ÿŒY=´ßJH l!°$^L¾ÿëXñDdd¦0`üÎ^k}]È®Y¤ÌÈØ<›“V”7Q5÷ô"JîŽNaö“2R×v:Žó7™ÄÇr‰¾ûlÐǶNö¨ä Žê. ú&ÆÁuÎh½¾¸üC/ŸcœËå×NË{$§-£„µÇøÓIßüJ§üq½9£µwu›ú žFõB1ù‰ÄM´ÔÄÞÊÂMƳ~Ê쮉¿»;ÓÃ…uba Æ>dGã‹îŒ ùbÒUÓVíŠQ¸–]eëäpRÚDLè0[,¶Õ/ãg“äD%* ³ä7[Pl€H…É*¼J"¤ÇH+”ךûÛí·W£ÃoÖġ3tPzx'Q%67ÿXû 2‘<qhH¢—,H:-6Ñ'¦ h¢Áš®ýhDïQ¨¥6ÞŸâ T÷µ>Q$;ª[JÒDãKîºÅn_]É©gb¨ùs®(\^}Iq$˜àÆšwý¿áì”ò¸ú€[qöÕ{­ ƒ1Eæýã´¸qЃ”OÚwæá5m#T…”E6Ã)ñ¸êùÀÙ.•”%1XçC” Ra)‹ ÇÎ7C¿/Ãð£žîê™r ¨‰ŽÏã‹éò6×ÃYŠ{ŠÍcˆyÕî”÷ƒºhܦ·½ÌyP;˜æ| ÿÛ©iï¬JÌog‘ø¾¹aœ›‚Ê AAnÉ[)ºÓya5Â!ÃPcøÌ Ï¡Ï+“Ä̘(~~:ýPf?솚’HÌ|Q¹2»Een€ÀÎ&ë† Õ´« !I;þÃñrób›ßqሠ#"’VŸ ôg—ƒ¾†û»sáâx]7׿ƒ"8³;qP)ƒn­XH/I[ù¸§bÖA9�:=í6PÎï L·(ÊWF:%èóôN:ÍT. —èC’†5ôŒvø»z>áÓ—ÉÊ£­ Û˜y²ÆŒ¡;Ï6² ¯jו_üÄ!Ó8!tÑ•÷ѳj |‡˜O0¿ˆÆ™@Cq v÷jé,Ì<h=›öJïî\½©º°Gï®rÛó.æŒ}P9ƾõƒ(ÒΊÅÆ’÷q@r‘Ýy?ÈiwïÊ‹¦h‹ BƒÖ0ÈÞ½þ9ì=„ɳ«Wê '«UÍg7O`ÅØWG° ËÜ0 uì,} ãe.e½Ë;óÝ<ÌVÄ`úôSdÛņ¦îI~Øxtï,“WÏykÓƒÂÏ,ŸÇƪÈü�ôQŒŽÕâ•¡–ãkz%2(žp;äÇKßÿT¨Ô”%è uÃÍ]su*õv6%/ÕŒÁ¡U~Êi¥.õu8Úúª¿ÊÇËÜÇjAƒ Éƒø«óÔRåØ`¬ý¢lêÁØ$ܨ9Ž³UnC$#¡÷îÏŽS7uâú)ÒCõ¢I|ÿó¿æ·á:®0ûy¹£ZR¤«­r#%Þ*³. ì2`›7ºñW¯‡ò³mN”ù‚õì}ˆ&Ak†P‚¥%¶bŽ­õõû›G‰çÉL©Z‰œ*‚wj˜'¯Ö�÷Û‘w,ÅÆÿlþ¨‚ÄvhÐÞ€ÚÍ¡SI|ô¼·œ _öÃaƹú|°R8œˆÐ¹»/ $Þ¹J9âjÀþ“¥Ç"h˜nb÷Õq²ö­©až»� nï]Õç»ë’ÑA>árÛ+¶Î_¿bìøtn#<I­Ôl[Î(â4åjàoÌ #Ë¡TàEí7§ÿì©Àªw3nž©þ€Â>ùx®S×Òÿ¼ˆüªÁÝÿ¥ézX%í8¥„$¥³|4 i\š±žåÖ{úGjÛ¿ÉÔô í­òÜy’ž§n·³‡È¤ÀXw)åù÷­©G±Tk=èò vÖã¶A#Zèü/‘byš9¯»s Š¶›öThÁ~¡Éá5” ™ŽÍN‹ù¨á¸Á¶†¤½H‰Æ¦¦Õô98­Å`–nRß4JeqäÝ»p¤k†•¡£þ„¾ëNYx†6næߪ¹$¡PÓžBÍDd†A™ËiD;iä©šÚP=O,ÛÛú/1cq- ®/sLE`«p)˜TãEOÜWŸˆ%æ0©DT2‘möç¥aæÌ\ÊH¯´ïÚÑà]7õ8¢§b^ß8ü|+ÎÜ9^˜SV†éÝ£¿â @×U§£¿#QU±Ÿ) ZÑÖÈZ­ø“P\zeyšKüŒ|À…i0`dtýtˆZMHÊJ:ŠúÞºÅý…¿RUøfrtrŽÀ”Ÿôf‘w°«l-å‹N#Ô^®\Yå›àѪ^¦’bÊ—ÃÝácK4@kD—e¿y£@™àîÂHD}åQçDÊw‘È3¶C{æz¤„gƒ¨¼Ýož_üöšßâ®B<YämŒøAß”Ž{Ô´ÚúS]Ì·jvÛm'diÍÉ ÛhYΚj²ê3}×íÂOcçã¢Ò“ŒbW”¶Ë©XÜÞ¹öÍ,|êøœddÏOfò±× gUôã•'-F9Ù¢½cáß'?âÁÐíà!ÎÈô1,Ž@Lú3¯ÇЫ¤TºYð|9{tºYãž:‡ëÍz~ÛL:G¦W±´ø<;¤¿é× S~;t—±€Ë WÓ"Êi²ue½7u¸Ûœ<Vb‹ºHÔÅBÖÌ®qß rn¹óõ]ËŠø‰DG” ä¬Á®´Û㇎ݤ¯À@âpå÷ˆ‘Ö@'ÿ»îRébŽÚÞÒÒ¨7Ê©b9>ðGZ_êšFlûù׈䱋ä¬g iñ„ê“Äv¸)Å]ÐÉüIXÜ4” žšC iú¥d–óŸ·Â!w"Ä%Ä’š¿ „§šj&õ?‹ Ôh‰þÖ ºÝæ¹p4ŽGý½ëMž9´µˆ¡QBó(ÐòA=7#§5ãæòmú¿$.¦+º(-ų*;•è‡€>‡I—eÓÿ(\äÀ"1 ;Ñîëª,¬T/jÝ'(&±o~@áî ÎE6NÎ~�ÂjKŸÒê4>P4}®n§…§ÒBœ+ Ê^K"ôÊ8Zt°¬±#Ò¾¦åS=Uæ²j Z$>`d=k¶ àr¤âR-1+>ðû4BaTÌØ‚²Yl·žÃq¸NûZ¶Ô‰M±þݧ%®Ì€] 2 '˜¾Î&†6¦(دP"Pv¦rÎuB—úÌ6&æ•»‰EÉ “‘æË¥Ìt¹¬Hnì®l¦:<ñS™óŸ…3=‹LžiöçœÍ¡Lë§à™ÁÅ(±œ‡›âüM†ù(&am =o=SÑFp›XýZRèŽ8á wìø6få“ïG&tiC>7Ú¸]Í@5¯!©ÇŒýØ3”Ú’€_±;HWV]!„éÍ›N‹Z‰›²ÚÍ£ÿždÅQâ;ÝP€ÿX"xö«æ3%Ñ”: ñ ª%=Ù‹é<Ž×C×zÐXmиڧÜv´«<Ť2Ölzø#ÆJ’éîÞOþl½2ùá0Òšß}ºô¡·.+Öî ¥¬é·©Ùìsxiäó¤+ÓÑ£ùÙ{ãص{·ÈÊ%õÿ«–^ä«?ñ_¼‚ÖSíf+•ÎžN¾F#F_=‰ i8 fxO¶Ú­¢ýÀ`At¥ä‰´íÞH‰ÿŒ§P; £]™ÒI‚t»Ó¢àUÌÈ­ÂòAí/Ã7Ü1}(|oȉåÙJ·)ARBßàdIÕ)K¯Qtãëð¢Ù+ÏL1¸ùÑKU|•t:üX(íY>=Å;äL°H⪒ö&›¾F.«<‘àDÚ`TáÇMï¦}÷§>_–âên‘wùÒp®ðú%Ìü«)�eí¿߬š½¥Ì-ÿû~®Çy}©W·ëê’àáÐßAgq¨}6ýñ8ÈÓ0ðØ·f?³¾ë ÿÜŠv1[ØGy°;CÁaê=q^)½NP^è+„^‡’s¼qGK«²[$öeí _U^Š’ĵ,˜M×Â2+ÞégO@Øî`£äÙ›,‹é¼Ì+e/ûŽëú­Ö“§‹, 0œl•Ê˪—Zfÿ˜�¤pl±âŸtWš†¾DùÞùR“õ´w3ÑSÝîyÁžÙñľ®õãBʘN°ž•Ê\2z‚Î×àE¢ˆw¯ÃÔ%XïaP5;—§³áCPì oOu°?ÀÕ·?ß.øÄ:RW†>4wô1óFã3ÅfD…ù[*ÛŽÃö;nï‰Æp‘†ž@#¬VF*0[«N­•¡žU¡‘÷y§£ê|ðíÛ·Žü=IÈÂõ³ù!/ vUo™s8{VNˆÒââÞË”l¦åß°ÔØzÏ"üŽQã}ÇÆ¢Ìü F ª—AÖ(£ïyÚŸ:ÓÚçw7Ãr¬wïò¾3m^­îbª¢ CÛ{Äæ¹P¤yP¦f?±¶ÇÎ|ˆÕÇ°0òû¤�¦Ê vN7‘¥\YýùE:Ì·IffÞscý*¨lË +¥=¶-×Ôæ;ËJÙ ;²u]i([›†¶|ÿ¯Yè§óÄ4…Õ;´¿–Tñ™7ì÷j”V A ®§Ð0ŸI±§lë:Ÿ¡Ê(cYÞHÁ™ñ’@ll½¯trwÉ‚¨^<öµ¢É}þ`WZ?n~Æ A\kO¨žÌ´×*›˜ÛV³¡1¥†¦€CŸQ²°vóO“Š¸ˆ"Šµ†úõÉ‘2œ ºH¬"´ c…<Þ9qsëªV™‘ü-´ô¤Ûl¾n 2 CZ4›l¿}{ ϪÃEÑjžÞ=‰í™²ŸÙH¸é”CVÿÃMÇ—¡Dôj©"(ÚΣÕÐÛŽ­E*Цбž»úŽÒâA–õXÅ –bAö9xÅ鼜é8Òê¨^ä¾Ê+ä•E‚Ÿ EHÔõ¦€OÔ 3¦íÈP¦Ú œy9¹›}ñYÓüg‰²ÓÊÖWlŽYPŽšš%¦Õ&Hžá´¯ ]ñ돦-Ûj·§b__ª6·&Óî|H~ó¼ÀÅ›HàˆÍl3Uº,naîÄ ñ)(1Ï<à{a„j3:M•õ;ï‡ùèZÁ—ù?td—ÎG€MrÌÿ#k:ðº¨o(D;ÒîßD!Ú*T"é?í=‚V¡º­ÌÒ£¹2ƒâL„aƒÝ{+‰ˆ“Úïºô×¥£棣œž(Eî°ÆxCh°Ñ»–çG<ä†<ÇËwÑæó©›þ9Ô6 µ)ãÍf©;>(¦v'zÀEwr™=2urÚ´³[,'Xý xÓCÕèr‡Áüù©ö†ý”PÒ’£SßÓ`ÿ­~¹²¦w=tß/'ŸÆ=;[é®c‚ 扒wøØ͔լ4À@yIˆÓ—Q™ø)ݹ}—¦:ß“4ˆ-Ø7F4¼ÀÆ@V`ÍÍ'ù'§F®î·Å3>¯­ `È@hPßœ$*#rä¨ÞÀhÙ]<BǪž&‡O —á,Èmî˜"«9s5yÙS 7¿B£øìý©Ëúøùhu»’@é=8qeBÛs31pš°¼¨·¼'±V·4kôL£å§md•û¢Ò¤Hó$ßÞ'CRew,¬É6}!œã~«ã×Áà :œîÔ$R¢ÞŒó·hɳÝÎÒœŸŽ Oš…àœ£¾ÿ-^NØí"«o�AÁˆîÊ‹†‘§c«ý[õ‰(nŒÁ®Nð5¹ÿÂË°+V߆k9Ö6³k'ãwÙó4èE0_á?†Àr\¸+›ÅD>«¢>ý…¦öRù-˜&ƒtÇk¦“ªøœÕ‹{ Jêr½@ÑfÚ,«d{6\–ý³óÂS›óáÐ"im5öÄ,,J¢ØN9ÄçB1Q£,¥¾¾B FA}3þ§²Ýð/‚'´›µEÄ–uNïÙ·FàçýíÿyÛ½ýÿG€þÿoÃÒªn²‚Áõa"Ë6=³öö•23UƘèY šþÅQƒ×qq*³ƒo_¿k™«×²{RÆCEl$ÿŽ(ƒ§ˆ(aÖÍ$ZÉúzSW7-ñ BZiq1èðö”oz‡æ ÆóÈÈP{Á;€²¡*Ýàâ‹Ò-OÎýš‰ÂI5b¶ei+R+iñÉ¥§Wù]+Àe&{W(âÌ-êVÄ+u¡mx*f1\V‘t¢#o§£6�ŠaÐîëQôýŸP›DEÛJt\l¯ôÓ»×züØOxVÚ”¿Ç?÷™èTìúhaª®Xÿ-«»´˜€;› <€Q×ý�\ž9õ•”Ÿ[E¹QVHæÚ´7|n#àùXÉÓ ô&Cú'|ÿ×£× ÝñttéÖÏÚ?Uæ<hcô;*ÊÂkÌ£#Pf²iÀ»´ÃÙlóÞÕ÷qHY9…ÓHŒŒA¾={â$0zãtT‡Öç<e‹òÂ,€A wmbO=Ezx›u‡;\Eöf�u±CÿûÕP›y…EÆ(ç¥ÊO+ìɈ¸öíàÆÄðö „û‡{«ÿ@4÷ï*s˜à8𜾷NçÃ?g©\ú åœ*—'Í`™jëÒ*Þ§©q“^ñ©‘`£™Æý}§ym¶Wl³õNÍRk+€Šêskéž*Pövªw B|>ÂÏ=‚[Þà¸QagÝ…„æue§®…/ž¿`$7ß$Û\Ó&~ E (õÌZ¿p#gð­–^Ûä?2–×›ž’“jÕqa/<}ÓQ&fæ…nI73LžïãVåß( ~¥Ú¡3MCŸw¶Rs¬)ÓŸ£Å“p<õ5½zC‡ç­­áŽüà·Ê{‘p\qÔéŠ ;O‡®ï Ä†±ºxê™G‡FÉŠÚ¼íF–¿mF¦¡SŸÄ;ü)(ßÏ×£"̽’Öž²›BO†˜ÅߧŸ”‚Q›F©gøˆZAáöÕk�Š³}™Aœu®¬§º¡cÑÒ ±;ÖlýÍ .õÖ>;„C�>é”êGÇ¿ÑÁAd°U¯hÀGn梄šT,$YÉúdÃÞ œ8?yYÿ.ô´TXXxÞålì) ©€!äÀúÏ Sp)½Mó?Ð2gA…3Eð(oÀ'˜Sf=1º©¬f˜«&À6ÂŒqð–®ñÙ’tò:J`BÊÝÐ\ïÛGEgNÏ£  äbZ¯v8ÔÓiÐ.6»ÈÃ{Ñb™$æ?4Ìü]žbú•y«Ë·ŒÈ•ëýÌNð9—,,¨L~ÒЗTžÅ–g«È÷,�:÷$ž3¢ù“P¦ee¥Å“bbVïrã Ý¥q™®îâ6ý© _®:éP°,Ú‹I#�qj8O›{Þ¡t=Ž³AFý"0ÊóÌóLˆ@<‚@í©ö<oçA¸Ú>ŒÆ0¥mñý8.*ëÌÀñD"ýTÈgÓÕgP¤,·›ddÐûá8Jþ¦òi×?A[·Èœ§sJ+:­pYÅf:Î0µðhM0ÙäsBî ƾ\þßΫ‰&á”óçÛÚÔ†Q^KoÔÊ_a™‘e¤åT3nkz0úýORz² êkE)VkË´‚El¬üëzVtÁJ‘Zêû„×É'‹ª9‘¥ã @eôVé?o‘ ¯3ÃSwÑ’ög|Ž6‘»E<„'“ª? ×ÑŒÄL0†2àHk%U.luÿøfmŸY]¤He)¡‹Î–ôÃb ]ý1ŸèyÍ÷nØã�á¿7ÑQjTýYÕ·c.[jüXsÄUe¥›ëWbñNªõƒ­Œa2¿¹¡ùÿ­Å_”„YšØþ1D\ŽYÔg'nc?±=ñ~ñ]ì,¥2>_<È/­Êt•{žŒëã|8ÃOlWåR©žë¾ª ï:+˜ÖÞÌKÕûælÚa2$çðüýW÷W5qÔ* =”Øèc’y€)ìø¦äp|©)÷ŽCT£6dq62,’‡:!M´õÐøS·43‡ÑZF€2§ÑK!gÝY@"$±ҤϮ¢áf#•+}1X5%¸Ýì<”æóhD³è+BÁ`¿“–ý`0ήRåÎtªb—T…Æ·íáßf@²wä7~rð\—!÷ÆRÜ@„‰:Ýül¤²’„‚ÍõŸ¶ûg¨ÿù—N9Å-ÊXs]}+•¼®/·%™-4É”wÃNS/e!Øš¥ïLϬ?³<€VÔï¥-âŒ>›Î¸¾Û‹¿A$'¡@§à¶tc<žµò£ðç 9wÓg¤3EµR½Ë{¿ 3Ï 7Œà™Ä’r/€=ƒÍÝþÔ×<T¦7™™¯òTºYåÐá8ÖéØ€Á«šŒƒ ÃsgÕƒ`¤ðyU/Sž¸ƒ†Ý—Ì #£c~ÁÍIëÝ<ED ® %^ppqIã.Ÿ§¶qµvØŒ1ìÈ‚r«$å¯á™Þ3ð¦…ûô¹ü·@â}Z!ý }È]šÍí±æ^öâ!YÈ÷ŒdâBÓ� õyö„• èœ}Ü4Lsèö›>i•ùœ|¸Tön¿¼ÎX__¶¥¢nW:ãhgsÙÒÔ‚íDüà 讎h]sW¨’H#ÊœO^JNO «Þó°dŠòø‡{.só‚ÊÀ †=kœnbÏRo×éí¸£ öùú™;Xeâ·&MÁÉßžÁÔ!4\óÏèŠ|åƱ4[b¿R”0S”Þà~ÏU'⯵٢4ó¦‚FTŽJçÖ)’«ÂŽ"´æÆ7ì~¼‚#¡Ý¬è›C„–¹$ÉfÚŸf÷¨‚#¥“SÐ ÕÐtê¬JQ˜¸&?HnÁþDåË×ÖX§Ü­‘X÷ÑÍ;H€ß6æ)[­¹óyy©‡ôw=È놟ï®I‰ ´k[°T<ºÜ/‹°'U’gî”WˆEBþ®(Hò•®\4yå«ß2>\„ŒÄÖiÿgÏŸvµHpÓ›³Àâ·bÕ“#d„ »¿Æµ.F¦!‡Að[ÐÈLÿ˜D´bó�zTAõ©jÓU®’YÎPS="½2 Ö:7 Y… IòwMšE’‚˜ÿ¼•:[6(U�­¡= Z;kwühM’¯ÕýŠ RܵÞÀ‡Í´u¯¨»;ÿô¥ =W"Z“€ ÇýàÅ:nœÿÙk«^WÊ“®YZ8Š4þmjèî¾Û‰:NKJÅÒµ*Ûï]¾†1´¾•¦W�‘FMoáÖ1×în“TÐ{ÐȼA•}»Û®;ó ŠMöÓ_<_Ôöìü*JyªÒ ϲ<ïåOöÑÖóP©¤1Ò¨ÜXo"±{{ |e9ô¡±nÇHøÆ[t>BÖ^Ñ\¬pf{v¼ôï�ø¿ÿÞªF‰q)ßl :&?í(òs—ŽÊ6¡Æ±¾qšÞ¿šÆ…Ç›el{ÛÓž5‘;Ôª†Íb¨ÜT©ˤÚ3ó±7 ^ßîþøMz9)ý%®åßOœ+Ä ª_¯~ó*ó&ØP”Ê7¥ªXgf¡è\kÉŒ½ÿª!g=)C‘,/�•¦ï3œ¼*™[âûƒâµZÞù')ç€ñ¸ §ÛYmôŠCÇð"{òìÞ̈ߓ¥˜º ¥|ëS­XÀ6ePÖ Çn’èhØÞ>…g±9M ËY\¦¼‡ H8jÄ2ˆTÊ%¶¬uH5߸\OЭL@¨”èV=öní¤í¹Š»é6òÑÂ÷á²\S¥ ¡HUââ‚Ô&/42_—-(zïÿzùÐEWGÒ;/u  g}{ç<qK“zcEÝ(Á™žÇi¯I—I9 ½Ôåø¯ô×’ØwNòh¡„ÿÝsm^Î3•ŸjÒ ÿêGυǨjBêºà¿ü¹f3åQûÌëš#l <c-$­¥¬]qN)çëèçš¾²Ñ%$T€Qew±Z"ð¬¯xSËÛ·›óéqÙUz–L¹hz–0.îRÇ-ln­Ç6(2]³¼ÍNt’M+leLëÞXK0D¯<†ÄÖ„zúyiÞr Ï<œ÷™y¢(†cÜkÓ7§,qI>bKmpú+[s¢GfºTÎêÐH…ÿ¤"…+kûÆaAÔ¿› H”ahÔ€5Øåž'|äºc‘éòoè¦:Õ÷X _°B`Š>ŠƒNn½KìŒom¬©Ã>òh!NTÅí¾RZñÀˆ0¥ž!ËîuÏ}uFUÕ£ÈN9äuåÉÜ‹àÕŠöfr³zr(L‰Fµ(|ÈTõ ÏšÎÂáz0· `³§Wúñ 6 ð%ݤÂæŠh–ÉÒñ܆~Æ^楥Š…å¤NöŽZt ” }ÕG3lo–]f>XS¨./Ø79±ÅŽµ²DJ¾¢ÿœcc¬qçZð+#–‰Â\…µQæSDnkëŽ}MØ7 “ª,Í^b¬ûîLeíû»ÙJÙZ<ì9d òÌsúó!§ÜBáCyÆxIî§éçDçN›ƒîRæÊw&¯ž‚6+µQ±“òLZ²š÷¾m°=®uü2M|Ö1…®¶ªÍL;½ž,ìßL¡ãÄè^Ʀò9t쾡âòEgÇïL9\ùÁ�ù[0Hx ÖûzeéÌœæ˵OE%A£¦¡õïE‹ì+Ý£æ*-Ró›oí뤈3OY� ß8ÈZ=o‘ØPoò»Ç²xÅŠ£›pÔýë„ëq¿›ÚJhx£à§Saëol|aíNoùn×ñQ¯é|ÛëxŽÖ*€P†�â¡ò³’€2LñDµ9£Ö4û)­6Çžÿ*‚²¦•AËt„Ù]¿óO|Êú%„5qžd6è Á]/ÚJˆóºÖÿéN%©—thÁ‰–¦3´± 7e(¼È"Ls«Š"p†q„dÖl—QQÖœô;( –?û Éxå Ç¢?ÑöŠj Ž( 7”½‰™Ã$ýŒNrˆßÜh+Ì3Å…ÄÊÆ t;íÒ =DµJ0£¼L"bØj«¬àNÙÞÎ3Lø“åÀ…èÞ6=jI#b&´‚Wÿ7,ržùR}¥P/¢÷Ú�–T±ÊÑî·&h¼ •fá w“ŠŸduRB_S»<ÜØ,S²Ñ-WßUÒÌíî·úãìf¨»?ц+úÉCLûë¦[Dæ<è®"íëúºk‘¯6Nùœ¤ôfʽ*CÀ�¶Ò“´bMú‹âžâEúö¿ÀÕOaì]¯h{m·“µ ½Åb<:vmÐæž=ÆfÇ"ÈϽÖþØ#gZk}²›Ÿööhô3¾¸,3iF©Ø<Aü®ƒ{˜+Ï›éܘ²±yºå.Lq%ªýŽýé`Ó +ËœðÉ㫪ȋβŽãø4_gÁ‚gb²ø½õÀ£¦Ëü—‚iåO)œ:ÈBtzÜ"Ûë¹)2Ùñ´ª¶É˪n,0 � ¾hÓ&W­ƒ{©[fe©ÁË~&¢¾<¯ òòFˆûø…©e6ŠnË-{£÷T7ÆÓB{}Œp ­<Í·ïž`FlªL2núôÅ<jR°ù‡G8úõ8*ò53À~å[§®‚®ÕUlߌ²-g5f®(ØÖa(‰O–YäAb ƒ9f¸ýtZô8îiÔ£¡3“ËÛWÉN!#‘# ÇX^°ôÛ—A¯6ÀÔŸû5É©$̳•Jý!e–¬ÄýºQ'y±'ŒžUÁ~®ë Gпô„‰ L @;TôˆF¯QÂCKHªÑ¦1ºl]½TÃom¯`ªqe“÷(áÁ$ˆgõ€É&ÀŠÇ ‘Vw0v$\Q¿oÆ*¨f«Ðp}qFä<æ÷CGÿú&{‹ã•ü&ìL` öÚ?¦¯~n¹SaÚR6G\˜AN¬º)KÖ]YÍ>¿¼3Þþäš~‚4»@fÈÑ*Ÿ¼]–¬„ÐÂ8øXò ›ôÝÊR _X<O`kÜn÷‹”„S³¿mE[¬zîú!Òd‚R>9aÇfO™‹Œ9„—ô7줤ÌVZEhtÒ½®mý‰5A…ÚvéVý3 ÉÌò¹ë—ïøÇD½9@*'×pu$¶ò;þÒ¡µªŠ¢Xzþ™µ´F¿Œi·jÿõ‚ ¿íøçùWææO'+ɳïÓièÚ£ëÊÿŒ[¶#ÚØôã ZùÃØè…¼ù°ØwØŸlíãÌ/#èÎ,Ÿðn¿~ú¤°ó—=Î;žW›º¢nšãB·}¿Í­²Š4iVe9°dÕÆòËž+ÏìÙtþ y§ÅŠ¨^£w© Næ%{Ü ék:ß­èÍD•Éˆ92N Èú¶ÿ‚’W¸ºNÝCßÇ*¾eÊ€À}Z\Þç«Æß‹'yhž¬Aºçì?“7¶wQš®-”õxyÉjÆ!’7]ú*˜°SÝZf×Þo½rbÐ_éÆi«òÐW',)A£ $ž”Zº?+¢)tæ±Ã+„@ÇÅä9îòÁnJcÇgg²\ÛCsúËéóŒI ÚŸ’ Ó-2~e¸Yx|?ÆuÓú‡ ŒÒ <;³ˆ†¶§FU È~Œ¢‹ùÂŽðôÓjq ;W~Ú>xåaµ´ô‹|Àiù‹µqŽ8=‹þäi›½3“F!ŠrOM_×å4Î]ó%AUÂyrZ_l@ÛXåoUýEšl£2ºé<Ø1|ÓJsÄÐîaØwgÛ cØ‹X1³ãÃ8)\•TIêû½Ð¦YÄÏ–)óÃp S Y¼ÔûçŽHUå|C݈if&õnà—ÀÓi[Õ¯lûYû»ß;F^‡Û° ó øì *,­q«Å×’D{£Ýý#­&ò°V¬èA†6† Ø»ÇÛâSuòä˜Q…4?©•FÖ§;1MØfNK–а+ ›ÊíAÉEþ>Õ0/±EþB~}ÀCâÓ‘×¼§Iµp×î7¦EÙ]‡­¯+!”Ü/ÏhiôE¯Nñ Óq¾ŽÒ:ó w‚×úa–&±-ÍXƒ ^‡•Eă/¨æç¶ûï{¾ntXx›ÍÄ®Gn\¶~Ÿ·3m‰ƒÀAfçÓ•Ý®ï=ÌÔUM,Û=ãæÔ ‚áZ/~„FœðÆ¡ó.è7kÜFÙ*ô`¨L -XXæyÂú›+*z;رn˜Hi QØÍ} -^Y2wè`˜²u'5xÒ–¨ª÷®0o*W³>¸=Ò èNÞN8TeùNšr'cI,!YÐeTœznû”*C]¹tWs–ÜÉümí‡FN>Ñ FÖÙˆ³éj~æ¥8Hì�¥—ÑI©5ôÑq¸ŸÇv¥5ÿÈf$abœüú@˜vÁ&™àIvb‚sfÛŠ¨ÞozÊYâ®áS‘$A>iÎÓAàöx68ù6hlIÌ )9æ%¥>uõÇvã¾Ga°ÿÒÛ©OÎ7wcXß&×ÎÎ/Z<©–ËÆʼ jŽN„lPtgX(ç<uÇ:,UúP•Ÿ™’ØÎÂTh¶k¥&I¶ª2ëäçmù²‰Á·Ãõ¬,i{ÙÁ†7”§piÍ÷|’ôø‘Y\hÛ:²a'lÌë³·’€y¤ýHÏè½ÿ÷fOÓå)QÐ*¦ó¹×[ ,œñÐSæÇ‘)ñ’½èµ—{Ö?,@|©é‘›3xS3E[Ð(äÅJ©?¸ôlQ³¡�tb ‘öŒ˜¤ño7HQd5;ª£0«ßÿ¹®Êb|p7Ì}ßjD¸Í[è)µ:Žõ²wGàKGHœ¥Nn4FSu™h”êÀüðǬaisŒVŠù7>¯‰‹ÑrûÁv(?=©á壼ÊmpÉ®Øöñ@'iW«Š‰ÓŒ)¨i xÊ¢=\69üXãЗ·£g¹Œ•És#é•lŽ—–Ί9 £XÓïWÆSFÆí:^V“¹P=·¡)æeÜ{>‚€FVO/7*Ðó’ù§/«¹éëS7¬µJ$Q)”WEQÒÐS §ã÷tä©ö8‹TµjäË`wœE]мº\2úŸ¢¸ñž[æ¸ òwÁ€ŠÊtÕ=íxræîÙØ tÊÒ30ëƧ¹Ëòø<›P‰²“€¾9ZÊœxÅ45ƒ®ù©Ú_ÞQsHÝDŸçZíºÿ:y±¶þ³·mÙ`ÙËÀæo!ó¬$4_Á[87ÎUue×uœñt¸¿˜ûéè0Qyê:½ åž)ÅÍéiX—ºµ hfLÂÛXíJ/²?bŒ¤•QDËM®²a݇Fs ‡z“ÙA}y¿öp ÎäÄ ¹8Ï>|Ђžó^ëÑUÈ™>xuûÔ©SŠœ!¥@ÕÙJ  gù¨Qê¹ß«zfÍ«=1¹£'°¯íd%f±GŠà¼EéœÃéît÷¿ûh¤kõ/0tF¿"K˜3üèZ5I«‡ÖŒúõ4X…ÝÇìµÌ˜ÍhW…»OÓ'DÇú´f3ŒU½þDò=I2ÿ@¢9�;’^U�;EÉÑÕ0‘št8c�#K²wõwµq«xªNTG‡hÿÅŸ7ùvÎ4“~÷‹_qô?ga´»æÃÕ4ˆòÌ „p£…áW ??Ñ xß'æ^»‹Gzº­¥’èO("Þ¶Ðï‡ó¨nør¡sF5]ÿ­žaÐwåˆ7’Ž¤ô˨ôób0\öõ òc2Ÿþ± ,½¾ƒ÷óÕÁ¬ÙŽ}žF“Õjðªc7?ß‹óÕjùC,¡‹#ð ³Ï˵‘²Û€ÕÅ}h–¶Ïì¹ä¬Q¤9´.›x2šì~Pÿ9^u:U¡oÜLÿá Á wûŸ…¿¯Öwú©ƒdbvTRyku˜ –`¼ÕšEržHådžn h5pá¬OX£¿›=Ûr|V‹ˆg–\¤GÖ%̓¬ž¬]#w­F–¹<ϯ‘]zÏÜ)g!ÔŸtÈ2·î‘s´|¹'ÁQˆo–…ô÷l¤ÜBÄÕ¡Ÿð{ObÝô6}'{miýÐé*Ò7åyÔ§âxÔ5mŒÅao ›BÜ`j Úî´3œznP+}K±tÐÍœ³üO=;rПa':ÿDØp°åÖa7ŠÑ'4õ-ë® BÕWÈÃó™v·ŸÄXNÎxö†ãÅûèÇúCL›ÔÌR|9Çoqm¥ç÷ÅýZú´iŸÕŽ,abäDUíWmØ.Çöpd wõÌJ/ñI>:_TQ'ݻ˫†ý`13Ëãà¦`q#Ê­._cášaÈzd¾jÄ!e«¾>WkŽ<?aÝÀ)''Ïp«éèZ,}Ž7Ž9s"/d:õÒ6a êÊul(®ÿFz#ÎWš¸"›6ƒ|>{2\Û{böKÇ 9‰Pm-é߃̴?Ê¥wZŸNô®º9åEmoõÃ=˜A¸&µõD »ë½£ÖèΛYèÏ)ì­#JìÌ%F7ì¯çS§ëå󌔧žýwÿÒFÂ"¼ËÏ�®[o<1çî~þôŒÿÅvÈ$ kãŽRÀ„ŠoÙ=¸2¡Â©™ûnØšÊ0Ãöã?`é3áû¯ìÅwÒDgsFDÀ˜$ÄçÞS÷¥`óÆD)Ú0þå‰`ûžúŠéõäd:Ù‡‘çøw!@Îä*7ôXž'}ã¤G£_Í®£Gu=ùÍÔˆÌùßïS¶Ðyˆ%„…Q³5á ßÛ¥œ$<@]yìÑ3ÑþD)í×NÅŇî j_µ¤ƒoVe1ôþ•9ÿÎî>J ol˜Ÿœ-g*;æ³iø`Žl’N©::cÜØœÿý—}’9ÑX=ßÛ‡:ujÎ}…\:Õmú`(üü]vèvWbjÌÄ=ÙC‡Þ´BfÊ»3Ø·ŸZÈï¦ëv ßdGË.L1†ñˆðkB’ý&>ÙŒ=6Â`¬ܨ|K–P®Ø}A«d×yïû:ÁÅ ¾ÎY)}™ôÝ@†‡Ù§à=¡³ù˪`ïQºÉe§øâ2BMíŒG_´Ç¦}jÒ‰˜V óµÆÀ<s< õl9&svW?¯¤ð”¸;°éiktª$0<æßÁ€ˆõ;űU?7ÿÞ(¯ŒWîãÙ+mªýh*|ï Bâwè¡�•Ç|V>ZÊY/Îø[ÔOXm~Â3ˆtÀÈð:$¦ÓŽª´lÐrY}?X‚ûBü&,éðÑù×Ò”ëÄ΃,$¾ +S[x&Z­Z@®_è,Ô|w¦­iñ³ëÌÒ_§·åÚn÷Ã?zžî² @XE£®­-Ž¯q®ƒßEµGø^�Vës"Cs( r«Þ† ‡V2¡TÉj¶ ”MI€5ªÊ¯*#Ä£‚"±%yÙ“ÀÝp}…çýOì«yå@au_ôpËúj'ÇÁë6BtjÎçV+0´¥÷öºn%òЛk¤ø¤Ö´gkçm7쿾WG¯”Kyì \³Õ9©Vâ5¯´ƒ£^ ë¤U‡bZÜ?úÙSXñª0 ¹Î§á§ZªÒ%ô‰¾›öEÿc[\*_@ÏÁƒJ0”jq0ö-l2LBÔqÓI^x;é@÷N¬Ž³Â/üh9nUPŽ …àØ ð@ZÆX@ÍyÜÕ¶Èb4Ï[¬9ïØv9ŠAPÍq¼Øp¯„ñYcJ–›5ƒbLš)²^‡N¦Ò×npÆ K}²�5ÇÏ ¢5 °jœ{WÈÎ-7Ïúص§cƒˆ©ûâGróªHJ¥Qc /¿ÚuÅN•]J<ZÇo­üò•ŸnŒ{BK6ŸÎöð?Š®±D ¶Œ-Lhûã) µÐîï3­JS( µ @&³E«ÅL»€˜–5Ûjp¿ùˆÞr²uû³¹ý7dÿ¤ònW.Bþ¬;hýë8 ãQ½í$êû…Kº¼ÏÏÞ¶O‚´ž<Zèp5¹7*koÎiíáoþºìÉ®&ë5Ázkh¼)­Q ‹Õ†å#³a¬&8v’#“Ã=�ëÚÜý54kÒÐ3@@½”qgÛœ0Vö‡ùxÛf~›‹Ë#âêq¨‚p˜Ôê60æ»Ã‘¿Ë–÷L§ŒóaD»5 J‹ƒ¬œØ@Ùj¨ƒ ð+°h‘à]8C­5«ͨ¹¼±zŸó0ÈfÛÅHÑ»ø¸©“¯Š³²8êÕo! ™âá%˜“#t1äTV<yݳ|¦þà)ØÏM áï3ªÐa426Þ=Ðj: ÜÞ$ðFÞü¼x¤÷G$¼¸J|Œ${0°ø:4—5·5§×üEüfjiÚt'[KG¼ë¼MEGᧉ4Õù ".=KSƾZ¬U–ŒJÞŠ¡ö Ì} f••Ô¾G߯ŠÌÓª Á“£¼Å²Ix€8ª™ý÷²…eêtt2Û[Õk¨€$¦¨j§«•Y»§Å)ËØÞ¹€©´a ¨cÓõ‡x§ý9,´^CÞG©1*ÍrO”"6SD³öv!ç¨m?1(¡ú|˜ŸÊp'(ò,çQþÈ>àšð7,cº,¾«nîûÉ~,B)ï£Ì¨rS®RXxÒçNœôœº÷뜱<Î|V:÷`èmmX±  ¿Ò?ö“7bz0iJW¼Jž;V£''5tu¶¢~jÊDõ+{—‚]';¥§Ç¢¤ÿX°î¬Æ"¢”ñ pa%ï$ñ<ˆ‚õ ­š: aÑø‡®¨°p Gó¿ 2DÑJÎ…þÎîŒN~§G‰n— bqÛ)âÄW·"º <Zñ‡c§ÉÇ l*Њ ³¡xAZçžàz¹>¼Õ2`‘\ä¼_f¶þí\ÒR)C8S"k?«i2«1\Ù®ÍbW¥]³êÚøƒ‚ÈÙ÷'dÇ‹vÚ3I8éè‚P°pÞÃâä ®ÿßo]{8£¹ñ€{¾f'è¿Ñì­6ΊáˆV§‘Åãuñ¶‘qÞKç´•.ãóós¨ïV«9’Gg–ÎÉݧl|;îˆÔ~y iñ[8]*~NDÿ–ÏþØc`mGKfÁH2×€n€˜Ž.o0þÔ{$WM7¾™Ãå>73*D#®•%D¡ÍÔ¦M7ìXïSÇó ~§‡…™„™M ˆU[j¯€yµqVÒÏÏxXï©w¡mCA±Ödûuœá-ê0‹Co–�YÂÑøSKùAmYº™÷°©‹Ö ¤ô^œAe꼘O0ˆ©e­Šß¡1uý‘êlS·o÷Fåuf e$�-`ÒÙ·þ™N•ˆ‘M“e¯úLñCÐrë]·þèyJMû¼}½R¹Žòò&XˆåqÓzhh4]Gwmwü{ä8- ¸§4Äç¦Ðw;ªDÄ^=ØɨNäæײ0®9›-=Øž“À| Ó19Ø¿"éºæ{ÃÐæž/`µYó'Ù¥>; <…ßu³ïÅ ˜xCŠž¯Y·§XÌj@´fòó [ȹ‡3Šˆ!;Àß û—E®˜ˆpê ëmNÕ}™ÑbŽß: ™£Á" 4ÝPGìRa@J©wûÑKÌÍ÷‡@¥Áþaƒú´ú÷œÒ;22¤J—-ä Û‹óv¦ÏÙ $Ã�¯Q 2lÈ¿|Œs(Kߺ—¢ì€¬UÄ‚#ãì�?[öÆÙÊÛ9†± òéËY/ýñPÏo»}3Û¹>sÉ 6÷m'ÖÐ!{ú¸û¦æâé-ÃÓdó™[–jy•*믋Á(TzM‘­½TøSp:eñÃf•_õ{b¥Ý ÀÙis¾¥F!UžâjKõ¹ÞݳåY”­­´ië–A:ê9PÁ™cꂳ_~eVm—À¾È×’ÖÎîÙ¯x ¾£çÿüd‰ØyÀ‹Šf§x9nUÑG…K˜Éî@ÅÕIE_çS7¯Á›éyÄEtÁä„eŧ½Ï°*éÔyÉ#S>:Ö»`4»^Ýat¦•ÕR¥lvöÍ»­'Ê Mß:ûÞwøµ’ßF;B¼ÂIe­QÙ‚ÓÒUPáT`¹#fâDMÊÊ÷m‘Z>T*¿€†½ÃSTwÍü̹(AïèÆ™Oé†élAeçdËN�Í;hÙ%·ÔYiöâ[G3ÍmDÊ A~é ZG$¾j&9x (ìÇJ«Oµ°"ÛcÊ o�  é pßFÁªÏ/Ÿ†-NŒGŸª.(¹nà.2¦n)#¦dÉçÕÁÙ·µµm£ÊŸKŸ¾¦àà¼:Ø‹;«ÏÂuâÈÜ£MOI}ÜNkBàŸŽs'­ù/û‰*}Y5.í±2ð¢±Ë1¦\Ôœ|Àã°±À©·À’T^î“þø]ˆSýqíA)âLKç�cÍt=ŽE÷¢(“âÝ¢ÂèJ5Þ+yIÄr•ò$4Ù_”â…\v÷0@ܬé4•ÈX+`£–ÎAʽ:Ã/÷Û־ℵ>¾Æb£¡U‘6ƒ§)ÍÂ-L’SQ»H[âÌž+vh™g¾aE¡ô¦ âærYÑ™‘›|VÍð2bg¡¶€¡Ó‘¶ý½-[£U²“@–¾û»‚èDÖÛ$8Ó2‚8´QÞh]ƒ_Œ³$ôûs!¦çX7Í¿ž:²ùMX.WãFjì•ê}ê®|x¿µLš*9ìCeuÎú£“¦¼Ã›!ie¹8Ø¢ ò§ãÊß&E®äzJú¾9Eð= “U³, ]cöÓciŽ0»‰àˈ p ~êóôÜ Y˜¦ÎʱoŽõÇüiË“tù±†6RéÔJKŽºÜíøU%œÇE¶*èY ©lTo…6Ï{=CoÐœø÷¤¾‰"Yål£áÄ)1UEƒ={¸t¤c%Ú¥¿×jÑð8.VSR<½& ŠóÎk�Ù^­]îHu„†6¤ÒØßÛ]ަީɇzNMç5kÿÀ;±sUâ¾e™t:oæŠyèù¤‰W(Älë“—º/ c-n°ø¢÷ˆ©žSÖV»bçYÎ*ƒ<:Çä¡£:‡¾ýt¬jå€F1tì¨&8/ÊPÍ™´~•Fs°ýOï]Ý&×IX¸º€]’ÚåYsòfÜ›žª \i¿1|rÁ©æfðõ¡ÀmíÝ3O¹šnÉ\ÀbÔ»³ï•…¦´§„ñ\#NÓ*[iu~`H[Ãôˆ4¦iÑæãÁÿ'ß‹ŽY—ŽXÔ„öÂÙ±ózÒä/—*µ“ëRïÎîsÿLªÖðL(ÐâËOŸ^7“m–雞™ñ 4P‘`Á€Sèif:³óìuk¨`4 + ò¿sò(=„+àΕG¬<åq Š�62XóioÜÿ ”Á]Ü™Žf+{Zº»! "'B„=÷G:­ºã¹Õ—;nÀqlkFqmÙò n´˜Æ ¦þ{VÃâ etvüZ:p‡ÆÝô;IDV:c3f`:è±ëªÎQ�ïœ3ÞNTFxM¸ËCײ2¡¼xüVx‰K5Ž­¯T…õ´U—ÿvØÇ+rd\ZŠ«ƒ•<KÅkB‡L³Ð Ç1ÿ={&‹|ïÞ{‰r ÜWÛÑóHfBÐPÞÀ¥¥V=̵ŸûÞO€«ÎwHyÑ<xÕ[Œ v6Ûíë£ .*qÈÔÛƒ-#>»UW3zpºˆ‚Ó~XØÀâ¼ùP€Îwh>~ìÎÔ(¼Rt?Õë˜ÎÞÝñ:þõ”³ôœþœ<\4ZÿUCëÚ¯WŒežÐX‰´ëm¬8 ÃŽ·ªJZ† ¾gÇ4%êþ ÃGcš�ž3Ð{uÊ×…êªa})ÊÒïFÅà§K´OÝ4_Ú3§#e®ù»áEÆ lèjñ<xãÑ¢/ä!‰yz˜šßüÄãŒUw0�á›YŒðÀèƒÅƒ|Ðòãù*Ã%ñ<!D­©« ²b‹(i•ÏK· 嬙@ÖMÞÉ}#Âd-"„¹i”µò�¡½¥Â¦f–q8¨o©¾®-4=i)ÓÚ†"HOj!›2ù¸6xWú—’Õ¸Ðõð˜IþìšnDÓGpαG!߉®û` (Élï5j¢ 4-L^|R3€TɤÛáê Û§¤X±ò‘Òb–1›`á)1±XÆ€Vp:^,ßúnü°ÒIj-|šè�zßš–€CuÜ1e–¿ñæx:Ù „ÕÍìëê1%Ñê4Ƭõ£’±5ïj¤a©•jœƒXE"]æ¬Û]Ý]¸™WŠHZ;3ZY­VàH[Œ«†?míqpLЉLuºÜ ~¥RB¾·KQøóDZn—º ²E[Q¬ÒÙ/¢†š9cMqîÛ¥^­û?ùÊÖæP®´wvÈI"êêVðbö­›Ô¯Î4¢¬\iÏBÇŽA:lêè4À^–²ð?o•ŽœÜ¿1…¨©šVÏI;)ÓžØu+Y,J’’Ë=+©õrmt~ç°eQᑦڛ-8å:÷e9>;}Aï!­L›BäéÁCW+¯Vlp|UQ‹>,r*ŒŒÑÇÖÖ ‹˜·4úŸœ+ÒÄ—›E¹XSÝYvzíè öôíƒÍ…6¢éÓ·ÆÄvH‹öp”5cT4h=hÈÞõïyâä{¦—‚eÕ,§1‹f¤¤_Åë¨L¢Saëó“GçÖBb²-v°qùP¨'³oëÍfõêÓ.1ª¸ßŽú–¨(ØÝ])¥— ©£G·ÛÏ®÷nP$~‰{[ïúöUàæ—?¹w~ÂÙºæþ´*¨¬™¸Ï~ºé)VPô g0äAn‡Ï(¬a!ÁÙáé¿;\cLà&¥ÔU5ž™6“Öί>(ôÚ\<mIÛɤ¨ð|�áç´õŒNqÈP�³ýãŽEùáÔÓy¼ e™áº*bèЕT²* +b{¨a�ÌFÞñ~yæ]ªR¹ß«ŒDÙ("KÙK¸BÏ{#›md&_hr 7عï£w¯ Ph–ðã}È3o ŽµˆÙجY(ÞO"Ú¡D�«ž6ÁJ2Ò)©­ÇGç`ùÆd!hÅI÷jú7_hIÀ‘iòᛑJMõõÕd'\{sÝ䱌—îòaT Ÿ9Œ&Ôïiü˜R¡ <#HØúGeÖû×Çe¦­v¯“æÖhL4ˆ ¤§£M‹ü¹Œ Á¾ÆÕÄî›Z–ÕÕtzJ-ýé«ë$«˜Š =‹Øž¾.=Ó¶pæ^enÜAøR'A¾\=Ô5¶×Ì<xÙVóð™; £WÜHÓRÊØ4Æö:í~ú轩æwÏc8O^d7ê\ìéZEç<7ç‚9~íâìì ,� átP´ø®m! ¤”Cð*¦3»?±XÞúª@Ï„VNôÚ‘þ µí¾˜f|m½£jÖÂ`õ߸è¬òEâ©®º4H·šaöÞ àì–ø ùÁÓénä5ñ]I)Ê|û°‹žS:ê.Ì“q¤$õo~ʼ1ØQoóçÕuâô�Äf i² Ÿ-…ÍKq¶››Vo6º\½Ëþ:¶Œ‰[U@iêª)cìæ4 ²ñ_ŸP†4Óηc¨×–£È7 /DÑ%¦ºÄj—@}IOwÅÚ•û‹øî/¿‹CùBüç¨2¦¡?6¡(,¢0·e{äy˜¤…ÃíÑ…2Žz™ØP«åóÔtÛÌ<%‚h\æíа”�–Z’kVX+zÒòþß‚ØmÜÊýÎpÊyì ¦Y×yT-èB 3ŒRíü‘Ö 8¨ÅT[ÓF?½ÞÏa?hˆÖ‘|6{¡Ó´Âô“6RÇãE ;á±=¡?Vé�¥ž`Û<ãÿŽ_O})úºIP̳ãš”mæS·¡êŽv™'ð@V�7›ˆý2±OòÐÓrÇØ>Iƒì¬:V0#êÆz/¤ktyhCÛ×ñx‘ö•ŸädvÞAQA”˜¿:³7ÀÃYnWüöÏò½•è]æÈs¨-Ì4œ�‘ºtN)XPõfêT{ŽHØIÉ2¢©æYç‚”W!”síÉZ<p<°Ãi<'.÷1CÿíR|í£Ÿ}ŽeÁ3£4 ˆweÄ�¨çÙ…êÞ‚L¥4߆QHïCÕŠTÚ]¹a¿`;¸SQÓˆu~†sDzòœAÑ‚ž‡»úÉ~Àh¥¬U‹Žk¼hKX*úìW/ÿ°T‰¾ž»UKû³[‘Ü°€g†(F‚Í Œ‡ë—òV¼y;)-sß÷îÌõÿÃFÀOõ¼œ'oÎ ›½î'a[�ej®z¦§ýéÓíXþNlB$ËxhUÅvž+ýíùƒþ‘îf‡oç8ž{ï Ô%N}û@t+­Â•ÜQŒ'ª/³FuÎ0373NæLOóG¯~[86L©NLMõÀÜo@½\í@y=I'S«Ë|aE zÊC·ÜÃM+'‹›ulw7Ð[9 [´´D' éFP�ŒìþwëŸÐ7 îIdžÕ,ž!N¸&4Î QHí<K» ¾=Mí-y«Ññ$­Â¥C¤Ú(®}¹ï®ùðš}`lÔ )Çj%ÙDx#–35øO!Îߊ¹ðÜ”Äy€<Y9µèJ冀3.éBG9•Ë*žðâ©Ùi}¦%Ú–že¶X{“XÝÓß»I x2Ýr—Ohõ•‡ç�pÙ–AbÚ†{aÊYc>ý"cŸÙ/+ëé)ÜarrbFÃF*™q½ç~ýø§×Þ,qXe^2滢kízQ-Åvu¬¿Àôb³w)8-Za5*·UfkMŒþ+ªSgEXýÇF˜Û r,t Ö_öõ™v^éuðÁ0C,‰¾¨œ·XÊõ»fÐñ æêz/ ¥ã$AöÙxJ‹¤ÛÖVtÆÇ}îÊD¥›‘ælB 7†ÓèùЈÚÿÒö8Ë ¯c@xsÐä´óÅÅä ý6:\7FáùÅÍK<.•jn°[ú¹-4È:£«ÞjËd�^×y[ëÚ92ü|¸\é¯ñË[ƒlá8^ôŸ^'‘‡•bƒN¸×‰U„†åJµšòùÉ¿ç§TTf~'÷¥`ó¢VËÌŒ¯&c¤hþKc+õ…ó4wðB9fÇKVÓ÷TÿÙ¬½o­ˆÿ󖘾AAõõíýØSŠë9KüFÖiª² ¯,øÓ+E41šÂQD•Á0Ì Fæ‚Ë~ñÈÌÓ•ö]hƒ”¸¹Ô·ÝC¦³`[½€´ÐH›?yìzÛ ÍÃÜ;8}ÓЖݗ™zwAS%tÐ>ôÄ»îO' A˜ì]ÞŸ·Æ…“)–QPˆ 7‰pÆ7ÓµÝ×ã*1yS/×ø2ÀÄçÅÔÓ}euñùTé²86¤QD6¬Ýû=ëûª*ÎÀ,Ö‘úiѵñ¬ØL*g8F¡o�Wd.3=B–½ù‰GfØL‡kZz´Q¯‹²ÆÿØø»Émr,=‘Á²²O†7ð„èç© �‚ ‹ùtõHMâb r7ZNþ–¦9;šÔ˜ÜÎÀ䦓²…–îp:ÓšAî?o±™¼Vô•&6~¥/Œ\QüÿÖ-Â'ÚÞéÚ̘kªc÷ý0̼!±›ÿø‘Ñ¢³šÏ ùÜ$AºÕÀ…$¢fq¦ýÀhpét¢ùb Ø*kÊ,„žùgeÞá]ŠÄ:-ˆQÿJð©¾ú{†¶ëÆ2!”Ýþ3¬²0cߘUã’Š¸aPÕÿšç÷†ž¨SþÅ -®\æ—0Fv X;^=»újš Æ]{¥Óò‚gœï‚•š-g–ïW+œÅ¸DqTâ ¥Ù#°oóÞri>Òø. ?¬`À:ÒÓt– ¿·5s˜ß|xп¬&§«ëKÇ~_/IoúxÎt]Ž}Œø‹%z »Þ`ÞœIàƒ)±7-ŽVaŒ–(ëY§#Ì2[›š†n¦äõÅ•ÇgTR­D”èýóŒºöÌ‹ÔTu¾½U@™Oþx ÷н#}F#ÄA.ë•:±ÐÞ±¡3ˆºIÏÙÍ+×!+‡h.xˆƒWïž®”ò†[b²Ž¼jŽÍßçþÆa' Cä #,:µ¦£‡©âš¯¡Ô¯©Û£æ® ”DªI;y‰ÉáÇíµ ¢scÒÃ4p뮜%³ˆÄ¬ôö:´·ärÅ.¡×vEó护²²Éš,|~Z=‡ƒ½Q½+R—mD ×mjªdn&³´×™ÞÈÌVÐJ°ÿø[¬ØZÊ$Ù9(QȬFtÚâ8Šõ&KÔ2UXX( 8é¿™p¸fvªÙôiJ9´âRJy§ú¬®³TD§-Ü3–·¾Ã—Ë=M¼Œ”š7;+f¶U³K§C(>Y:3€–> ÎLnñC΃úƒ&þ Oõ¿&ë_àîá"k²V™vÅÐQDI.'Ï8¦¦h>ø]Ç;N# ¹5×'Î#Ò¤cE“,(ßÕ#;¨07ü Ï}9éÇC;ݓ㉊ tqÏE–+ hƒJ8¨¥»zÁ±'QË´Hã @o0lÔ ¯Êj£Z«ô_= ”üÔ‹NK+ÑÞ^#/Ó)$ Ý{ôtÖ´àæÙó+¦—†¾‚WNU{ aÓ‹‡ÚØÂ&e2(ôV:óϸÀƸ~_¦®`Oš¥¦;þÙšåáf*!.W:µÍ@ýÌœ`­¹o~d©¦Çû\å4cá]�»DÄJT1‰r/žÀætÛˆdÑ/ÐJYn÷øjÑ!A+ætòôAÙˆPŽ®ÍqÙaøº~³Ïä³b¤”£²: éÊÿ•Š¢/ï“›lì¯7Ë2ŸçѲ¡}_+™•…EEž»^™¡|ࣂéñÆÄΚÖÙ†z£"—ëts’Ø%š˜ §mç5sz±'çsä*ñ űõ¥Ì¨’¨^·ó 3í5£\õDñ:q;6°ÅÚò¤ÕÞr-¶!Xf×íéV?”K­F`hDVˆéîÓCˆ~žÑy€· §ñÒà &‘!T>¥Yúú®Ü„Øô¢ndÕ÷hMš´ê‘pïUó"'‰+-‚ÓDo5^¹Pdþñ2ý¯Î»’ÉÓRWd»àe)›5RiË55hïiWQRúîâ˜ÜFä2Sþö ùK‡kq\¸¿y‰DÖÚeüvý>Eiâr‚|÷xŒ×FÆ̇žR]u_2V°¯õ7Á9׆`5H|ò1ɨ­A—…79¿–Ú§§·ÁÝ{¤„UdIäð`€BpEÙª‚´ÿ†Öl;nµÚ×Çev#Þ;NYž†;ƒ5yk,ÿ4a¶L9ŸhSŠJÉÑé_+¾‡ãïËS#¤ª [Ô¼6ÒÀà×Ézžù¹:8èô¡c[òÑ¡ö¡Ã÷ 4à°ÖÍGÅü̶öĽ£Ì ú96“J.Å,«ËíF&;¸.Ïïcè<ñDM}cÈÅêyEÿÌ3ÁË’Èx«|¢añ›Ø/°üýì‘Îf\jÃìKJ+ óÆ;Ò5OˆµÉjgα£7Oª¦…y1,¨ït\Ôóñú£À©ý"cLw\dÏó²j]…ÿìyâ­y3[«iKe—Ö´Ur”¼ÍÞÃ>¼-ûÃIèŸô ¹ˆ]õ|LbE •,®ÇXüBSkÅÛÐ Ý\Q7~HNÒü4W/h5ÖÑŒŽ¾º»£6ªî†®±€ UÛ¿}½œˆlg<AÚ±¹TA1+«ŽEZ©büÏK¯ 1SÅÌá(¬r‘àÏ̱ÁöRùÈêèúþo"g-(ãs¢ý`MylT;­<6ªîö¡5®V¬ø85^ìªþOâ|:qu°ô‰çÁ2ôåW™ñ—mAÀ&F¢Âìä“Æhä óPVT³†zAx+HUۈتӽunÓÔPL*Ñ\€¡ž;GéöãyVmâWD"OŽÃ°<`^Ùn=’d߇7V—Ó�Nt5åv”'póèúá#_9)SõÛŸ Çeœ,YVMTs<+yu!™öAúÐ); ËÿÝKKgŸ0G²·–3§�/yîáßüø®œ‡¾y0½õ8¦A^[!´ZŠ«Î¡…DòsU4<¸¶uCú(™œE+2kUa¡µJw¬Ž±Ð+Šaᚇ)Nô‘þî—Ïž -i¬ƒž·ì‹ÄG—਺@?áËS3¤å†¬¯°jßuÂóøö¦Ud!›2Y8³ i;T§(‚:2É*hUXd¡ |dƒJñtŸÐPÆ+ý~õEPX[kv©¤H>®[ç�3ÎØ]}/Ælbcdsˆ<ÒJT “•#/‡7Öu”ûü7yn˜$•á3EÆ¢?©ï7üiÇ_gÚ4VñofLÚU e ›Àó>¡ç<zNc¼Øe­¼jto‰82 L‘Ø&«‘QpD8êŒÓõñ:¿D3œM“IvÒ`¦³#¯·n S-c<ö’}9¨7'–û}üê\{ÃJÅké1NÇ·Ý_•0γÃÉì…a±¿·Þb«¢{D¼\1ò-ˆóÙ^H}£ƒÏ�ííl Y¯öb­T§ûÝÙoî—ZÞ1Ó¦5\±œq‚Þ¢çn¦:l#žgú’l*•ç–>X²yèCêhs�…ò®YÛ«â‚ú²¡<ÑÁ¨3Ý螺âp%^AÆ> Ò{sÐõõp|3(‹ •EWYhü›œ}UVzž«õ¦e% =mÕ61C˜ý‰æõÉpZ�˜(¦òIP ³gḼÎE3%9 [îqo>K3_b(3¨þôxmx’´umy;ìî#¿êœ—‘4BÖj¤$zÐÜ6cCÔóè‰b²1Å={ gî›Sf:ЩÏöþÌ�óiõü|+’4ôYAa!ú^•µr‹EO€“mK<a‡€Ú^“ø*W*a/[Øk´C§=ð™G¯wÄúÝ»ún˜›yYbɸ Nj\1NÔëÒmu±cw£ÂÀ­%Àº#¾2 ׶ªJmc¹’ùÝø¡¬ÁzrN»‡ÿ¯"’p$+>í›pJ:&K›°"e¹Xj*²íÕÈïrçÎGç=ÀèUÉÔ|[Ó[;#´Ýw”ÉÚ‚ŽY!qÛ¹š¹ò8QìØ*V0«)œ¶Þc>Ô_Ε-V¶%AÃe¹ýñ�ÆiÕ?+U:/4nºt´WA¹ë̼ ¥&ž‡jÙƒÀ¨ì'(÷ŽwÛ#)ÇÌå³õ%à$¥žþà†š”ÙÁèï_®Ä ý—¹&c´]–™•û…«!0˜ŒåVÚ°R¦¾:€˜ñ¿Y÷§ò|¥ÞÊZŒ˜R÷Ú‡Qµ l²é€g˜‚àõNXvljóŸ^Ⱦ)1únyìVº;ƒÚ²U·B¬ú‘¡(ØlK«ò .›sÀTêmñoP•®f¦iЀˆí:=Zäjƒ•Û‚lÚ«ßÏÇ EM4èœ:é]’j—î†o>[¤ë2p†;¯õàwÄ£¤òa“ðg˜ lôã.†)§ULé… 8ÎrwoXN3òtPÖÅãî„Ñš9¸í/Íçý¿74C_INëËíÝ3V¦œHSÔï CQø!ˆ’ª¡Ž�z¶ j.GÊm(|Ê?XÄ‘Ù]Iz±L¡‚‘XÕ|`æ+® °ì'Z œó6÷¤‹÷ÚA'NIç„6é}'…B€¨ûþW=m®&Ýê„<Ô I­s$÷¡ÐkÐN­ub¼ïÙÖYš¿M9c¿ ŸŠÇ`Æ¢+ŽKtäþ½Å£Gº2ÿ¼/yT¨´©ˆÞÄœKÐSÝŽ:ÏÇ«=ìábÂzmµñ~7¹Ã÷eïÒE'ñ ¼ê•ºzS .J‹ãL•ZTzW ¤W£ó§ÙN)WÚ€ .Ú«–_UÎÖ@o+ëαæ‰çß#2kóGÎBéÎuˆ¢2†©Ì„ðôªPÊ4]’t#N�»×w•\rXW™™íÿ(Ð]ÉÚÁ‰èüŒ|7rɵ2Âò²a £ålݼòZó$©âЗ¬¨èéf”¯YXéEª†msrN¿”ý±äê84†Ž9Û«v:*#ˆ3šåi´K0ËÞËC£8έ Ü~>Wþmµ( îB>§ô—~s²ÜØxÃmŸ½US._x-ŒóC)ÿ†¾†ùÍ%8„ݼ?÷ظÖ%Çž©£‡ËnVxéç$3RA s»¡ž©Õ“OýVª9jãX÷³ˆ5·9''E Ž'Tn¢vñü;DQ^BM7ˆÞšÛ§óÂ'ˆ¾zX Ò°×7˜þ§.z8ÓJ‡$†9Æ÷ hôõ¡+ ¸MÌ,¨¯‹ ],çü9À¬åÖ8Q­z„Ÿ»`ƒ;óÕ4·}N©¶Ž_”©¥×Ϊ€œò[.6gåD º‰{?ë1yÂ’¿&³ü{—Énrù õbúïØïáW< +ù³KCÌU|v¼h¾nÐTìÌà‡êÆ–‡µòò­Ñ‘yšVI÷YòÔòú㇥–w_, e^ìˆÝ“î‰"ƒ/‚äkv”µî ÙÄPÛz²¯w±�ùŠ ©æzl¼AÉG}=Ôg}Hü„(&òôt:Q 5=Ðv4Q9´r‰îP±cÿÂxnmŽøê Š+x€ Ub,šk*±yË/H¸s1îÇhgçøBœ¢h·�ü¡g> :ö•ËîäÚtjByçè+˘h®”)ÀËn89Ý„v©²ÿø°|êÊÜb¹¢UAeÁ¢«=6ÙüQ89»ñÖºÔeÚÀÖ±“¶Jö-š˜æ¥—dÖ¼x!GÌÆ"rglhÍ vtªñÆ2±nÍrë(*Žãõ@‡€÷ oЗ`«R©CaÑRÞc›‚‰¢HiQ¤Õµ)´]Pk¡z:Y)ŠðáÑz;£Çg…t¯9ê:ÄÙ߯ï‘þ\“‡uÌú1羑‘»÷ —Æ_Mßã4ôG¿´à—ôÚK+¹¾!l-²¾‹¼î_bhÑPÛHß'·\…-ÅÆw­G7ÂM½#£;FôŒ+´ËÌéÂËÇ¥onš³RlšûÁs8¨‡CýßÚ3GÎâ]àTsMƨ†°+1Ï[º]°•¼| ÆÍ #,Á›WÏÕÎL#Ó¬ìayJ ð’‚°[×ê9G{ÎÖëº10AaùÖ‚f`µ¹¸·#Ϥ5ý§¾¤wt~MÇ'5îoÖ1ÑÿTêDUpuiˆCͽÓá>²™×²¨ñ'‹2 ºnyÈ»hñölí»Ku�F-ÿ×µ_{e,(Wªl?I´ÅÞØ™eMñ»ÆUWø_/1ó…߬¡Ÿ½zJù6Ï¥{ô[cÁ¬OšˆÁ~W¹uŒŽÅñTQñûÇøbÁYæ§ðïër²¤H>#ßd®µ¯WlXµz‹äï©f -iö«3¯7bCÞÍèÅ'&©iFO“›uw éMà oýá�+“›Ì§kó¨ýz¤…˜X+èˆ BH…ÁIÇ€5VŽãþPÏç†-ŒÖuEâ=h[YFñ{½õ&égÂ%ÍOu vhw<‹-=O6G,g_\ø ›Ó(ƒÚ…q†ÏÔ@ ïûÖ0ŒRF*ÏV~Ý‚|Ú‰ô‰Ø„À"ÈƇû=Ôtx^iÕ‡Út<Ò?é{@7èx¹ê?¡V²:à)¥ÉƒØ)?Æ|fÖ|E•Ÿ-åcW¨ˆ½ÇþD5PmÉÅìÌÒ ( ©ÈÖ­ÕÝwË»D)÷¡ßÝ ðø<©".=ŽËˆ¼;¶ë‡Ppõ¿(#®-,oŒg:KØ×ã±Á$7N^“N€ûF©Ÿvµ‹5xvööÑÍ<ÝCøý×LŒ-ɺ4¶)õ@çÌ|1<­ ZK!OPÏcS·bæ~êF1÷¸oÉy*i<Ù£ ”dVüHjÇå3U{7'ª„ðîßÓ2ô¥œ@d9fT\ì«„ÈÜYoÜ·†¾ÎyK˜s«ãÙ�Å•õ #M¬JÌ ‚èFÏŽ ¶½ŽÚ¨Ao‘bT0NÜ×RK :™Û\«�‡›Jëv¾#$1UµLÔà•ûÓÿº„—>PËrÕߦ(ÏÙÝÍë=l#„ÓsI(Só¦~ÃÓ¾·‡3gÀO2Ž2s0úŒé…S’Uo{¦UÀò‹Pï¡på7À( oF ÞZAE^!5ß<”AVÛ�}ÿíyb¶¢±£`“Üå [æhh&Qê(ÀÛþ˜&,à$ Úq˜ßarß=Ã)&eæ‹“Å´¼2¿Ž§ý¼FñØ(zhÝÑý¡ ÌÌ;¿úŽ†ÊÖIÜ" ùVø5«ÁÓQXÛüݵ4퉅ª ÂnÙ°óß¿žâÌå–¬~†¬>þ7†eíœ|¸|ÿÓ{øŠA>`½étÔ'V 7?>je¥Eì²Fæö¢9œø²,üÔk? ýú¥yº hÜTB· í€(cXÂ~÷vÞº£É˜;®`›+˜–eó;¤šUïËÌ¿BB(±æ1(uŒ§…i¸Ã/›-%Å:ßK‚á\᧊[«÷ž²‰è«nYœ ¡˜]ÙÏÿBúç™vjm£BõÁHÀf•ÀÃÑ¿‡Z—Q* ŒÒlVèÓ`}m=ч;yIæ“…§ÞBäm´q2…6F;Ô ÚyLPrÏ­D¢z:&AÖ]ÝY.å/Üå¡W`²$ª|960F(œû”!£â× @È”§í®¾‰Z*e!VÔê©£‚$»zc梑qÆ‘ÜGt•ƒù£Ûq{ä™±]H‘x#‹Ïé X­÷ ÍdþtÖ³àeÄêÖáýÇ•èÎxðs± o?ÊÊPššù@vŒÀJz€V)›òÉhƦ9žìkSSÅ´ õåGÒU4…oôuåÁd³Xhyž”è¥Ãñ|}4ŸÒðf}æJ€ßu6Bdž•y ]“Ä*gܳ�[‡+ ôûï‡^”+·¹4–ÅÜ¥LÏJ ıQC2Ô)ý`@›ep‘™Ž!®ùÿ¹â `ÅQGû€”QÍHªìë­x~~£ùÌÂÞIß:»óá:J½eú7ÚÞæUE*o¢’Â1˜þê²·*¢j” b@ »ôçù”í`ZÛÉy¦%“Ÿ¯/}/Ë×áÙ·)Z^T™C–SwüJƒ¤žMñ.½Z–¢ªÑ5<±¼V]dwƒkæÊÌåî‹SŠÖ~MÄùW,(ç|çõk.}GÙÈ$B’¯cœ•älEˆ¢"1äuTf«.Ûh<FóÂ\ˆ2…ñ…ùæì¦ ^T†_¦ÓÎsܸlÄɶ³ÔïšáV&šC‡)§gHL7¾Ñdx:@¨©QFŽ@1÷[u|‡W´¢<ò»gq$&Ɖ±´Ý¡›GOÄo™öË Ó`ù—þÆßüóÐsgmgö%kv¶‰Ãæ|³ïMÖSÌÖ¥öœw”dñŠŸ_Q~WÑîÓ,ì-è3(yML ,9g7‘Y5BÁ>à?#R÷jFf‰K-…¨Ñ­NÛs'}¨í€ÐŠ¿pa}µÑʽOoÖMzª:×j- !#þdÚ*áH=kûš´?Å`W©yDzn=sd^¤¶šk»?û;î<<Ñì¬[¼xT13.ƒqG5byéàˆÖ¼†lÌ\UPîkF[tzb’gÖ:$bkJÚ‘t'¾jÏûsº:´”Ý}7¯ŽâÇ…Ç¢ç6ÌqP|6¨`s¤OàèÔÏ‚5êù 3¦ƒGíÎËÉõtpR9¿f€GÅ_^b‰I ¨˜&tW˜úž:{¨Ó®ý¾4/Ý1Á5͉sñw«uÎ0‘C×)¼ËŠn)½å‚|?SÕÖ3÷ýÿü¯ùm@“EȲ�ÁgDÛÓYÌÂ`wµÀžžÆ¹ÄH:I¯[›ñ€8;–_å%Z²¸q&§Ð%w8X˜èÉÁ™¸KÓë9 GDUìR{¥‰;ñÇ(Ru u¾/Ò­kH܉¡3­J¼ üžWn*0 º_ "+ å>]É>Y"6Ý�¬4»×Á°g+¯{ÖaEúÚôôñóA•ò¶°ÌµÞÕÿyK ööݪMfÞð!×Ùo³ï4`€rŸ_¶y\­|AvCgŽ‰ùÜòÂo0-ßùMÞ8öLõ¸;rº÷Ê6Bù·Ð~9ÚD\OL©ë9²röüQQYÞxª! Æš”´/¶’ìé`ëüPsÃLî„8°º ]ì˜ÕØN7Z&21mþ³”á¬lúF%D=Òaˆù#üy¶#˜gÆ‹¶Cõj‡¬iÀ4gºÞ÷µû©ÖöÎ3&@{6g#†Á ·Ç$~÷›Fdóžþ ˜ýF¿è›úLºšv‰f;½ñ§ÊÏDv•_mû¨ò¼3²Â2×ñz¤”ãÓ2‰"Àºã÷§!q?ÍχG¥gÔ+ýª‰¾G>+òò˜PM;DõÙˆ€ Ê V“1³Üó*[³KqÐM-úk.ÿy‹WÝŠ_úèæ‘«q±ß"¤ÅŸ Ë”>\Oˆj˜ÛÑUu®q%zî£9C]éÄÒr«…ReëN<Õ‹œ…? vEeî÷èa.Ÿ±ç cÄxÜx“¾ØJôíŸ=m‰‰A‚Þkã^üþwe ÍLYM̾‹È˜ªÚÜ)ŠhT`¨^ý¥©Þ]—p¥{ƒ•¯¨ˆTøãTÓëÞ²ò¼ÂÞ»¼[öçÙªÜášSpŠÑÈÜ‚,m´Òöƒét¾f›:yáN^þ@ho«ûìÙ;}°Äª›þFâÓ†»Xý1e×Y_µ2: "^b`h}A+èUßÄ*ó CQ .” öï"¼ž65D„éXŒíÙŽÃ@R‰çø°ÌwçÑ,Õ‹TÏÏ­·›‡ú<ñ³3y™£œ‡½Yp>)¿‹êµiB›Ã^ ž®˜²ræbž¡}G ÆèÁúJsý½«öeññÄ©,‹óèŒ!ÀVñàÒò¦ŒÌ’Y1Æ…Š_ýˆ h÷…ða÷½[ò·«zÑ­Ts^Yöî<¶?¬`#…'Î!j·WÚÅg%t/Ý¿§ó8ßk~þZy~êƒ !ßœ4­G•CÖêÔ«zóò L»p9Dg¾EDa¿(î”–½”ÉAoüxç}û\™fQæX ´M÷hî”­%ü ío>�“¢€ûúËÐUÜ´õ>OÛ™y2û—¶¨@§—-ô@@ß+EÖ»�êï>IüâfìyÆC\LäÓ¡„)Ëúœ¤Lg <{õ}Ûç”—óìa®(G³âÁ�”ºQˆÊÓö_VX?B‘ýi»‚ò2+=Sˆ›´‡éÅ]f=N6´]~ï'ð6Ól•g´ŠÉ¶ö¬h(knDðÓl?³p|rW|™-qæã›\„†ÜÄ*Ñi²¢ù2[øÏ[Yž¸ W Øk µÄC¶fFó5 Šeð:g ‚÷^¹¼yAK+-=è˲tÃÛÞʽŠ>Ρ†æp·P€>ûïªûOˆI nGt´��9Ð3Nzég:í`«ÙÏýñ„¢Ð™çUqÙ¸UYñ “¤*º¼² nVÂO§{ÁS3Õè ™|s¤„ô •˜dPÆzO}ÛbYX¦¹I69ð^5^´A¯ËÀ%»—{´<‡-3•msëT÷ÂüZQËsJ8Ÿ_ÿÃîZ€›2tgŠÅ½_¢‘éÊP)£a˜ÍC”Ô¦£ËJ˜<"î¸/NTâlÕV¥ÌfÑl€áz„uŽaS¿ª¤gkP9Õ0HjMÜš®ë÷¼p¿¡trUÃXDWÚ¬YúoJߎëÎ3€à&AþÙ¸#¢¹NN讎TÈ`Öþ² H™û.ºu€*à¬(üú A;ýJ“8¨T{À±f¥~Þþª>…5ߊŒ¬P?Qp{œÛz|»¾5Óø¯Zp´7Å|hsÆi âcíÔFŒ÷^êq‡çë_ȧ:ž Ò±×^a±X[ÄURÄ£ªWÿFÀÉj%Æúí4Qºh­gÙ–öƒtÜÍW…4Æèþ¼õ“ÒƒJâÞQÈŒF;KxÒ¾§u|ÙõÝ6' Ï4 † i#%b¼F³ûqKÿ÷ c¼í…—²îÆàß~3ÓÈ6qrô°çcš1Å nÓ^:OãùàÂk®N=èèšácÞèöän7P‚~ ã09Ÿ”<ˆüqWÌnzbFæ¶Õ\ôû<ÆHˆFyp ÕZŒªg$â3Í–F!T `¯ý�2ßê~›Ø2TŽÅ:σr‡ÀÓ1ðRögbßåJ�O›MÞ~éM*nŒ‰`wŽèf¨sÇ8—5¹²¨Üþå• ÒÙ§Úi0NšÞÄbÑÐtÛÞ©‚”µzêëWÛ¹i¸ÚÊòÎM”ngÙÓL{K¸Ÿcò…áþ|0öèè,÷PšÙ|>M=@ˆHl½'ã21„ëœó³ba=†wSЛÈæà+üDeô‹”–ÊFV•|f©q§8²jr©Ë—ßm˜h;˜ì‡ët*~È—ÝѬÞsã˜ù¨ àÿ, üû¡¥ÿ‚Fݽ@í)ü‰à¸xh¨<a…|¶«‹~x Kb­ÏÕ‰ŽGHzVÛÚùÓ½G>f„Ê‘,“Úçy>ÖYLóD@õíó<HÏÖ‡•Žö-›a›B‡—Û›i›[Và'B‰ ´�AQ\èchX^- ¦„Š¥XO;ÉRôÊfT/#ÐKi{c›ÅÅÚ¤‘¹‘©ãb– ìÏC®<©åŸ‘¹:/ÒQTB›„g¯Lul2 ™õàár(;ÆJ72¥…IÒÔŸ‚@Á¿šjÏtá�G‡ @=$Õ׶²…¹FyಥG_½.«§¯Ìm,ÞÔ¸UÏüW2ŸnLusi]ߣD:' ú ·;]²Ît÷f¤Z|·µæGC7‚oNO–ÿcnÒ aˆ§Ïw4®â|]��w‚ù«U¾�caÓû|ñZN¢£Ÿ—=Ué÷¼3xeÓ'¢ g°bÇCÇ#3ŒWmîÝq–q’5¶3žáÐ/¾÷»[%cçîžÛÂJÅI]ì²5îOlIlvi2=9rÛvªŒfÎÖˆig¡ÞÆ«O¾d˜ûLlÕŸö0^f�ŽÎV2Ðq2æc’ƒˆš¢¾<e©TDþûÆÆÍEq?9'˜‡¹³hÓNĸÓ,¸:æÙEôq—úÂí…(m˜2šJ`èϾv]Ë'÷ÑWì!u¹2ÈÚû‹N-¬V&¥¹ÂÇåMÍ+/óoGѳɉêð8ÙG:h‹Fg…¬þjéwœç”s ~AÊb«;ç†y½¼�ð±ìxJZZÿ«ëoÝæ$óV!;{Aú1m'ÏÞŒËã'¥G[âF•iô·ÌâiôÙ–,°öÆÒw032ð…ge6—‰´}G+š½Æ*íZ`]è¾Ó¶{ÀÜ‹³æUƒ:×õJ}Òy*Šç%”³WµSlÁdð8(Û³*|Ø/.!½8üÏýKÌP<UõtIjOÖv" ÄRæY&ÜÚý“àQz½e¥7 ½¡ý´Ì,(4¨ábð”gù#û2b™é0¥$3 ’½eÌpø¹¹·3¸eÀôŵ"ßPçÌëÞ¤íËp)df•Ú–¢*äpLÀÌrƒ4 ý«'á*Ìn”7‡"H–«g~ŽñÒàþf2¤–»WVo<Z±¸)ñY.TX®”a¦ú*È$Õ»Us†Ç. –ËÎm|Q ¤3Þ2|à™ˆíêÙ òÖé÷(¨½Ë[t|œä® —âóv_”¨%½ðX1nW3o 0‘ ÷16(fÙjȹöÁˆ3_ÈÖ’t„Ÿ6ePxs„Žw££a›yÇç­ÞTa«…9¾Æ ÝsíeRܯ7à-ð5$ÁŽOïnóqƒpÜ~–~È~¡wZ<bÓJÔÙ“ð/õÖ–©ËÛc&Þ_`a5vVÿ¿áIº.·êUU±’5Ç9;(·ù ­!Aõ‡˜J94:×€ZŒÝ¡l›Y±§È}è*&‰( FqãÛz:àæv&û¥t‹ ×yÏçµÑé\ãnò°ò¸hÈÒúÍ·[O¡Dô)ÌZx1‹ÉØ'ÝZîr9 ŠíbÚt¡ƒk™o™’l+ðBG¹Ê|d=…Š®¬Ù<xÚü»ó8"õ`Äáå:JÜpÖµ¼u�‚òàÛ/p(晢´·-)óþRt)«^^˜@'í HR"íÏhašòéq’ß°¡àÂd!‰Èã…Ƨ(©èÄt}®JÜuîàç’l ÀóŽ’Ú°šÐ ùªí¼<§2Ÿñ¢7ÀËHW¯€GˆYûp˜k&Áe†¥ó—GØ°A2¿ó7Å2E¥;×àîõôŒŒnáp<š:Ó/>—ÒŠÊ]Ž”Þ•ZüÑC>ºa=e.âdkTâðí¾Ä¾¹`´Po­BK%MÖgêuU«,õýʨöäAiõ rhÖtƒhájÂož×²Ê %é.‚yʃêódÝ=áâ|.žÞ£þøË{—·Õž»Ë…ï™#}òÍ ¬pÛ3ð /²52ÏQŠÉŠ#þH´Óóƒ�:='Úöçd£1'„ó+®6¡*pBxºú—”Î%nç2ïvžá «’îihÐ5(øôÐ勤sx•ßþŒÓ¡t5F69…íÓ§kÔ ]QéÓñ0?wù}œ&>?>4³ºÈQÒà–“cçqß.„ër4‡çwÈ›ïU2Sz¡÷/ÞON‹Ôy¦›%†^ž‘"{¯WšI “vðž,fÒØÜ©góK‚³VySàÓ IÐÆ(fÜ0“>øÄIŒ„ £âïØÜÉ¿Ý!™ÓâE ’°ygÞ|yšñÏytÝ26PÉ=<óÒJÌDœªŒ;:J¢EsŠ´RÉ;j8â4W¹G|ò(ô§ÞLKÁ…ÎåEÉ»eÈßóh»bÇ5®Î«×yG73ZñÔSØwåAünT©ë7˜_Š²–xy9'hÑ–ê<zë€Ý鯃ãX8¸ç½+¿«¯óŽ>[­]ý8—uÙ8*=î7ËÖØ«Û,<ªVÞÛP¥x=Î^§6ëÊeÐ×DÂÃëòŸ¹ï¿y> ·ö]¸ß,¿yi“ ü]–~êTî‚Õ–:ÉR>èmL`xêÕcÙsà �¾:å· çOùã{}°aS÷Å킯ôž·‚Hì}™Žî”úuì”4ùÄýÒ×N•ÄdÓƒ²7\¼8ð׃'ø÷ÜǸŠ2OC&’wµ~åþÃñ2û“Úñp9A{¢3àœájxZ?ÙkxZBèJªè;Ëm‚'U'@ ί¶ËU `€Ý]È÷¸D‡¾ì²èñ±éÝúÅq`²È–€Üa¬‡4¨¾¬\CnPÝü¥x:èôd)Ë N }<"ê”cÅn§i=W@çš.mëý‘'O÷åŒ/H ç<ÊË ·Jw9Láüî9ËúXûI°Ó¯Ḧˆ2'º–ùaŽ¼ƒ®ü}ú”$ájЕ—$¨jõû(yFVⳄ¨¢c_ºã¸¬ËÃéo¸Òæg1š,H¦«ç‹À¬IÜ(cÛ…TùëÍF»výulùˆ] �ŠUG—v&”Q"ëÀ…~¾·k㽦òÐ:[Kg6=ý…âݪ°b:k ø/»Õ? Sßïíýñäxžrr0±ý„¿»$¾y\Áã÷ù8{¨VÏØ^Ë DÁ4a±oMY–Â#å ˆÍì¹ $Í]ÝA6XF~Ä[4¤ÿºÑ½%çÑ&:÷S}ÏÖ[lLI¹ÃG^·ØàO èÖh;U©ºÄ3”OpøÇÁΆï^Ú†cg‰šU;Ì)>µ~<Õm Æ,Ÿ‚róÈ•g ô†Úœ ‡‡dN^ø‰ãÇõÈ÷A 磾Èê¡Kƒ¬¹Øjg'ŽDgçr‡®ýg~1#S1±].dq|]½^­ óыŠi£;é]Þ;Ö|·RLŒÀ”ÊY *5¼_¸`Ey©LiŒFÍH—ü`bÝ5rô3¦Æ!GnÊÃÜUé: ¬›ÏŒ6‡ /ê8\=7º›õÅÓÚÃ=uy²¶Ô•Òßngátt^qjå…¡HÜ]aòX§¸ô7€dTdD_“£Ž`ãÀ»z?:ÓÅî±JJ¹¢ ”znFçrŒl;jú<¯õ3ÜÔcë0oz,ƒ°¶Fæ—vvm«Ã‚’�úõ]UÖ*­¼Æ;$]Zø£oUZ7©9t6üÀéÌ�½xæ¦åß :Z—‘|Ø*ú" 3fR[bi�‡4Õ¤±ÅúßYOé›±~ÞpÖX¨"«U€¨¡Ì‹µ÷ÌÁàÕëƒ)•ÎýªxEéf!¡øgÐ×k:ßÙèL_®¶Ö´ÌAÎ¥åod•ìlG6¶Căæ²ÒC˜Wréö¦ äû!3™EzÙœ/ôYx”†ÅYë!Å“Ýxöµ^ÿ–Äé#2³òÒÒý­pf$hþ}íH¹’iëë·R̳%`íД¹*‹I¶äX'@úýmð*=4.¼íÔ;^è·.JZx,eF÷0"©šO^;‚mÎ5ïxŽBÊ*'A¢é{tJ®ÈïÐQbmêeââã'›Þd%´žMRðøÞ:ô{6aRì|Í66ßqB3=åþ|¯?\ø+8lõePÎ*öËÂ}½]Œa6p?[¦ê®ñ0=ÉD~˜íH·9ßÕZ‘Ñç!?¶‡öv·ReùÙ×?¢LrïW2^[Eå;¿Â^ËW€ÆB:sñ§!>C1~¿;šçLß³á6Á/Ûr¥çGZâµ5hû½‰±E&|¯Óþät:ZeÅËĆ ±DÚ\Š µü$4&XÔ¦u7òdYAöâ¾ ¾£Ókÿá€Û’½ëmÉ)……Ö~ l”åE¯‡cGeIå3«Â(hû*(]û05Z¦@¹tÜ�K)¡;ËõÍГÖ?ÁÒ+ó¤üCæ*¶¥˜«cÓ ûùÃŽË ¦šX­þ[—Uÿ@YZÓ—¢¤tÂ)Œ¥\.¨Ò[[z%üÕt“›)9¾Ú^äô§HnyÒ'¢³téÏ]ß½bŒã!…ö´0~$šÁ þ/ㆢØ[y!“!,þi3Úâ2ÍÐ)Ïó>ðä %EøõÛ©£gT.^ÿK (f€Í×Vü¹º•NÉË¢%±årÃÊÔpQ{o=_zûæo^ÕÜ/"§Ã|%ÑÑŠŸ½"HÀ£¬€â><ã᳊_~þ«6+˜M&6§«i0`T#U–c� î_ød¸Ü*3 Ñùwj|×Ñ’ú<»öfýµý©áI 9ó'xg”1ù¢àf&0rÏ]]ˆ½9-`Ãè:FØœ¨Ät0‰$ï¤ÑÿR__ÇITX˜vƉCžq­c ðrZÔ&<Ð<r{ "0•ÚÊä^RË0òyLØ^.²Ÿ|² Ed‹¹y<³ˆ«²ôÍTSÔúT‹[ÌoÔïÃŒ×N¬ÃÏ¥2eQ¶h|àKá0d"‡lDúÒvk{Œ<&Ä\B$´›á#"yÎK*}^ƒ\JÃApØ’oX‰b×Q­úFmB¦?a^M·”.®E¨±¡Í¦®Þ~I|'„w,o)\µJùï¤ÔIÜìqŒÓ)Œp=¬…âîþÒûˆ�àï×ët%1 -ë_5[I±ðXÿôÀØÃQ‡…®Í–žuQªI…Á“aŵ“꬗ª<ËJåÑ)¶»ŠÓÓפDæ8ú8ÒJÚ4 [ç6 j+)kÄBoýãÔ)ÅüõÖ›w2÷Ž1\=ÛÐQq¿ÓHè(¼à:ZEå4¸™ÔŸ‹ Ù ž"dMAÏÔFýé´Æèõ”í§Æm\$f‚À•Ó~GUå4{•‘>ÂSMjóã“»ÇPS—dÜ€xµü8= œÌ�¡Œ*ÍW[¾æ+)”!ºM_Ÿ6=à.㸜€³-‚>AÈ»üN*œ÷ÀÚ™ž·÷¼\ï<ŒÏˆaMå»´˜¤rj^b.ߌ±ô<aE¨Âçá|sé5(ëÂbf�ÂFg]MïðdוÒ'lÊQÕå Ÿ—+ ³„hœ%iìðÝÜ ùLU¨ rŽ#:Xõm«èDX”'¾ß5EÝ~ʃr<ûØãúppÍŽ¡;*áTɲëØ­B`¶’qŽÃ·eT jZõÒ¥Ÿ\£ï8¡™–Jiœeíi”°Tl³…àÞÃl»&�ÇJÕzó£[ôIÞDÖOÓ»§0êØ$æùYúð·‹û÷(-]•éöT°v´Ñ¥®áfÃÆdŠýîj1Mç1=af±K˲dD« x·ÂK7ºKS‡·…nðÌ5ˆ»úÆ>±é˜+1ÊYf¸X|z K5 ¦£)©ÍëtÜô«†‡o’È>mMB Ü©Ñ¡0"}ÝRà6‡ÈoëßxO¼À â”Z!žŠ;èní Tµ”Ã�è;¡g¢"”™®P;ÕÚßµ }œëØáãÏÞ©–,Ýáj‘þµü +ºä©/¥žpËò’$H¬ù7#ÍšóŸÌV{iÆHIÊö1§·¬ÂÒ hzçÐj™œTvé`„køš;Zæå®Rjå18©ÛüAÂüétÖ‚´/ë€gj”¬6ì™Ë«çm¦z¼nîš2?¶g¶NÙBN£Ú…>z|²ˆ¾(k°ÔMþÁ™ÒÒQå_[7¡k¤ãaÒÒ¯±ù­{O%´ +Žn¾Ï¦fර~¼\¬zn¦ãŽ"BÕkq±8=ÕŒ³›³ãß—ª*c)ÄnÔ´d å8"àFýG¿Ò²ÀWöã;0×oñ­Àyè“ü ãÚói{ò„¯P©b `—*ÝÉë…ÕS wex‘®åEîÓç!/ŸÑq耠Ÿ#€¯Š/ªŽ)ÕZœ  ñ=D þ­ÎgOÏ¢Ñz¾nìúå¾ä[îr>¶úX(-hÕDÕ7YÉÛç©ÙË0Á\¼†‹Cr³N!ݤü]Pâ° ŒÄþòw&ËÎ+1ûâò‡ró^ 5øg[1:'ñ³¸•ãtWÏ͈0ËœýlÆ\ք΃ÏÚ½;Î>ÚºÛ‰ |Œ�Aa%/P…7âLtÙioU1×€rqßî5š‹³øÈ Ù´Š š`Õí¤óÃuŽùá%ó°âVSt„ûfþi R°3bäC—ÇüUÞ¡šUzK#°+Œû¾F7Ú`¯2ªM.ì±°í6=¤<üëU–¨²8A�AïL"sÖ ûÄm¥ þ„²ãsÇà:#_P[*ôe˜ ÛÕ¦;tõÈ]”§q‹=?-JC¦Ô»Ûœ¯v;ø†ÛæÃ}ø3¼x˜»‡ñZ›mRQ¯çVÁü¥ñ‚Ž’¦´BàmIq¹ž`hEñ”¶"U›+ìfÑ¥¹÷+§·Œv ‚·È%‹×|ctúÕC¾7,`Ç­‡ûÔAc 3¨`Ý­´S‡LAššj=*žï)ný¥ W™9åø‚õ5ú êƳ뮦×Æ‹s±8ó•âÀýoév¥õΛ‹Ù^¤$Î;>ÅѬ¥¬ðCÜ@^"dÈ]K‚ËXùYÓ¡¬ò<4à ”%ŸúëÔÒMÁakœXUd±/a0œ³ ;Ï:ðQàx<LÄêÉÚŸÃMáØB4èg¿…ÈCŽ ¨îðIlyÞ¸cldäÎ`6ßv£ð­nAœV‰N#ÿ|¤H >StÉ”å¯ÛÑ^çEz~Ç/ú¤£ZYÁš4`™¼àÐùþš r�XÚîL®2溑³ÿhº‘uîÔrúö$¢‚ÎKûs#Ò±à‘Ãä^`!>*ÀkÚvop­GKj`ÆûãñÒ›3vødAu²¤zh) ˆZÔ½ð&�¦æ÷N«g™OùÝ.hc ×E÷;²»/¢û“ž®óBL­èËZí|ÖæBçãhá{kÔc °íI zcJÏvøôõ‰JÃY)fLp`iS½ààîÊío(^—þtì§!3Ý—‡™DË©½‘®ÃF:·ãÑ»Âùq5ÿD²ùbP1ĹXÇ_ó©Z0L"€«¢¸']Çë¬ýù§M{— Š2EEå#ºÛVéxݶ{+'Öì9å™Î»æjþy#àû æ w|ó'Á®RB ,hY:¿Åí«;²,÷îb´ù“ëÉÂ{°’X¶öÐ]f¯ñêü©ì¿…ů.»{öľ„[) µ4(Åz07° z Fµ8…4ËI»ØwW't6ïuÙŠt…ا“˜ Ôx˜½ ‘ÒZº÷³ÈÔó©^Àr½ì¹¾g†ê´;™AËe¾@Ú´±#Í,°òÝo e(GÔ˜Û6¿è†+=uÖµ¢ûuk°R™xÏ° â íåáøvBÇ@ùÁ?:ÅZ³ÒLPÑ“‰kS—ØœK |æþÜ’Ic/¡^[tovƒ'u"U¬÷¬ØÔ+£6 íñ:^át£ (UìÊ˘n³¯ÌOžÛõ},y¾*!áÌTµÑ"Ä‚Ù™êW,µ2÷‰îÀ¶j(Ÿ �XN{µ ¥$q?ì·lG‡É�‡DÆàùҬÊïáÆ*b\¦dí¨è!„°ëL!Ê©M®(ŒnJ“ØŸ5”¨)Ê$¬o”èDó?4*øÓ2ëúÒÍÎâÒ¡wÄj=H;\9Óöz…â"ôŨ#nµÅÖß&.Å¿|קUü¹Ïå•ÛH ÷¨k:ü¬/•kØuÜŒò¤ôÍj“$ó…7èý¦Cä¶çX(½|Âéx´ž¢ö*ó¹i³Ž÷‘Åéz0K,Ûçð<ŽWx|k¦‡NÄÕ¾Þå:["@˜äò8ÂRE9G¸Ü°qíÞxˆPi¸üRa.)|YqàË/tè¾¼¸Kå_Rqê.ü“oÐX ñ<¨G¤Ô¡:ŒmŠ½q]¯ E“Z´"½çýSe|AN!ûï¨Âèì…JéP_e0¢s²ù»wõ½Í'‘ïx m<4³.»yÓƒ¨1œe´»' Æ’q+tLΫ¹ -÷lvÇ(bÊm;\>lR¥’••ycnGö6”Fîl¿±Í“=Ó*úŸQü�¥`OU52®ó‡•Ý|*¿•¹“îfëþÄ®>W‡òåÎJ0´F6¡˜^¸ Vù¾²»½Q&KŒ‚ ¾d®µ6>6ÇúãÖeæ¦LTnñ©ÃlÁúðFÞˆµf~;Þ8T½ŒüÊÊ0ÎÌ(Vlj TNìÊþH5¯§ˆ21MØ»p’cž *Þ1Þ¢KƒP6jÎë2=¦-J.P¸„UêŽy4WGævŒO‘ ’ŽÃòµ&uéÇ@:±)þõ£‡ä3â‡òÞPg’µÁȉ Î 0½ÑF «p C›™^ª<7LžOtA�ÙDÕ{=ñ'Ýñ(ñÒM¶ò:vÚêG™VûŽoh1(Ú5°vân±ßköF‰dŠ”­‡é_¬¶•zTi¢÷㥣º:€%§çŽ¶g²ÔÎÇ´í†?µµÀ{†Åy¬µÖ‚Ë3,\“qò*tzPT^^ñ,(2ßè ƒ-hñ¿«¸n%¦kÆ¿]y7??½ÈȾ[Wž<hÇ<() sÒ‹õe´ '°Wé »Ü»ºcƒ…>k‹ÁÔçAÑ鸇)HêrM锯`Ô§n/ž!€s«¥œµ¢s²ë‰ñ¡祩W¨E»åܧ·È/L"‹ÌVì%û%wvªJí\§<~09,­qÎy[¸’×[¬tTö#Ãý%UYšy›bf%›ï;Ïc¶97æÍáŽ@g ?]bˆ®üÎÙ¨龪 oU¬œ_ä:¢› êÔǬf6-3ßèL[Ìpâû¯î˜/œ›~æØe$kÃC¿PíƤ@9¯_åv¾¤³™×RSúB²‘R°í fNg«è§tz4­óºû¿Å’€\¯Yà,%Òôè£÷§·Ÿëzc18÷±ŒBP€c‚àRÓé]t£Lã8VŠB´;Ù¡±“ò5ê+ôAúˆ £(îòÖRø£@”˜xШþØ8»®Ûñ&Ç–ÿѽ—¾lG Ê/B+¦(žœûÏs¹`„"’Ð~Œ€ó›z›ßòB¾ÿŠÞ7`žÂ´Ã7°0€ù;ž¯HÃ|4ê)üá=O÷£–ŽÞ„«i‘æ¼»èB»ô²¦_~¿øn5Æ7í àáûYüàFùñÿ%€0Š\ëV؃¦§÷n Ijüµ3Å(ÛÚ»iç=mëY´ÏÁÑǪ©ܶžàPßQr¡%ø õá8MFÅõatÿÄHRM�ø¦Cï0„Ì(¸D€ø+dèÉsuŒ@> èÞ_¶eZ·ßˆe )MfvÃônKuÏò d'¥ïa»™*‰ÑJ Ój±ÛT´º)»þBHÑÊK˜2Ø‘¥ŽÍ 4›@á¤iSÙ¿k™—žZ[Å+è 8gkúKEîPWlî|f#¨oÿ8wÝZ†°´àù[4+´‹1ng‰?ý $Ü¿¼Ò„ñ‚êÖ(çs1Ïh l–±êpA·"k±&ôŸŸÝ \‡’[ÿaŽV†‹çB7_é˜Á {¥4Y¿8ÃÅ9îøïó”mõÃ&r‘º ŧÄñ &ïg¯])S(œÚ/#×1ò­ÐÇÈqx£ÊдtvÆCçYVŸ¨Ä8uH½ŸžÖïO?`шOù³ã…r@ÛԱπÓ@{y¥6ªØ7a¤4¨ú«§”/Z­!µœG oœ�þø³i›¤Uæ;8Ðã„ófÅÒÌHýP¾hÂÿã —o¦JïçM}u-/:RÄYé¾f„Öiòíºw@›Û@ ÜŒ­æŸ­ýËö:´·sáÄ:ôŒÛŽÛ¤SF¬`} *âÙðŠ«ƒƒ©hW“-ñª­š:µWtlÐÌ;b6Ü\;³Ù)וfÊ—¼Ì‚ŠyÂÇŠ‡²…âç™JøŽò|i¥ÿÒÇèÄIMXKœ‚²=ìRV=:tr÷»ù pç¦däîé˜vT†(ªˆ‚"”)@±Sé ­ß<ÌÓÔàùB¦£Öt¢F‹êþÀ×ûˆñ9ˆˆGvÝ9°.õæxº=Uûuñ‚ àB+°ž}5‰nòz(¿ôŽ\™Ps}(Yï¾\úeÈMê£q®²2tÑ=þ…)C݉&¶fUm‰f@knëf_[ ¯ÿ;¦f7Žcô·×<?'OÝ÷øõ¦¢¥ûUÁƒÐ†îÙ°0‡ºYšiêƒÏaú<Ñ®´[CÚ¤Ïö™<æˆØ±*w¬YF²Kh±4­öR©AqÞÓ‘,L—3V?=†ŸWhÅ™øÉŸw{¥Ç:Î^F{tÕ�¸'A´#JoÌœYP4ÊP@§ý,¦4œØAÈ H <k~£]�¢ï³Ÿ(Ò8½TÑÅ;|PÊ•ŽžÂ6žF%ÊÎë×ï:ü‰©É¡Ú”}¶nÀÔÐÎ`¾5gü¯‰6}_'ÖL¦Rà^5s ä€Ër<½Arµ­¥Ä‡Î6Ÿézñ½a”øóMÖ?À"º·ï Ê"b6ç¿&gß9Yâo¢<aå[´¡ó»Mhe [K%Š×JÕÔ†"‡õØÞ¹ˆŒõ‰`ždÞÓeL2v†ÆŒ³‰°E[aUümÿÝÀ’(S &C3‚e9eo¦¯_>ïÌë½)ˆ»ç¬e¨·ó ³mº( <›O¥‡ÖÙ# eËý¯Z]ßÓʉ“ó'¬‚~ª‚lùòÌQÑcuèÒaºdŽmôŸÖ/×î'~‘zˆ}!•Oì±×ê.(æ…ÀÜîˆàKt’­ ÂÎd¶2Ó]ñ5«ÐS™Á•´µ´(aÑ÷)kw¤ÔI_có…nÊ7)§\º ’³?ÛôPÓ€ÀlóŽÏrðÔº6 >¾Ç|(™TlFð“ÓÇYPz|Révž(ž¿ª‘zÎÐœy\�h,N[JÔ¨¡—t#n„`žjYÆIæOë VþçðåÓº1ǦÈš ¿^¦Ùº¨£[TÓ£z·»Vb‰†"ed¥T¥_ÎqŠý± Wy„±Ž¦BéEŸˆ%ˆœº î»á þñÚ)ËSÇüaD¨�dŸ K@°\(Q·ÜŸ™ÿñªÆY;;D«ß$ôK\xEM;qvFy­ŸœïÊ ŽÈ£½H»3cs¼¢;{*J[ÁT·‹çÔ±ëV÷’O^æÏé1,#íü°×c MA׿dÅ›ØIio=]gŠHHNhAY§¿1’Ì¡/ mŠŸ¡”‹Pº/ åÓ Á®û¶n"ÏȽTÔž¶Oä$ûÎAD¬;aiêhÊ(gÇV¿m ks8ZÃèýû6 ’Q3yhâ˜g'RÕ¡ Ÿ$¾ý¢íB7´‰&U<qCˆG$#Ò:œÛôÿú6WK½8á—2k/Qж+‚ìdÙs¥Q4ôMË÷FÏÖ]Ð1t¡·¼ñ—/ãÌdÂL@…éYb¬’—úð¶ˆì¨Ñï¹-üîIoHÝýWäÃV5×8÷åÍ·×ÄÚ#[ZGúú ÷GùÊã öKh~*^.“DÇ—žÜ« $n_W–Q‘‡Åc>ÿ|ȃ²·™;ýËàó -IÿÖ_œ[wùHü,NÔLQÔE°|&Tœ½Ô†2=øOõ~ÇQ}¡œ€6¸ya@qœ”ÖB‹¶ÊrI‚´WE¾2[÷oÆñ‚Žßüa9͹Ωڲ‚¸·,X`&™Áû±g9vhµ æáB¡Ž:±åÞ®b´Õ@šh)Ö¸jGouë¾ûLŒ¡Ð]“¼¬ä¢Î,ÈFY¯§¢‘g#†-nü—¬ü¸£Êí˜)Ï÷ìÕ‰é5G¦4K|ô¸2¨†­‡¤d^®�"j¶¡OàõßåÈò­¥/PP´ŒÐ¶JC¡ºØð¨R6½äÔ°—2±¿èL<þ(ŸE§Î ëOÝíñ<ÌžD†mhüª÷…©Û¿ÚiÿF[Å7³&4¦ÒÕã@›àŒ¯½†KùðPfW!ó*Ï™²ä\^}£é×#s$I3_P'¦YÑN'd9«ùdjIø±¥Ò­}]§©Ëxîã8ãgm%aÅkʪvJª°ÐÂA¹y“žq¶¶áOiJGÛÕµ©¦~y;t�•žY¸es9€Gè+ŪmݹW´IÓS’´9¨p§Îƒ)=$ígëõÇؤ{¥È‡¯²ZN·‰AÞigd;'çÜ=ÚÊpQ¨A'›n4ãçÏ3 6Òìg äß#xìµxî¸?%0ÂÓŒ;ˆRÏ© —N\”vÍẢ]{8Ü ÓK™É8[–ø¾H´ ›z#ƒ)H"lXä›w.Ö~Ta¶2aÍ‚ÝÙÈÅé;ÓùqEH÷¸›z7÷ÇžJx±2¢k”•.JãØ/˜®äç‹åŒœF©÷(|»qßÍfÜÿƒgR¬˜!§Î07µŸ½úÖìxd‘¨T„QâMYÆ.”ćfŒŒñ5¤O5?³¿U°‹“5º5 – ¸ý×C )«¢¿zArOõìŒsoBŒÓWø íW7È9IJ-sö8ÌÁ¥/bÊÑËT¬žó¾zÿ¸_‚zÌ+¶’ó )îì±ÿá*" ]Ö²ìM‹·—wÆ‹qXúý5Z #´b*+YÎÓ 0L8 È¸HÄ]ݵÍ `?y>0‘ù<` /ïn^ £X±¦_uMÝ<15SžVæƒÚ~µõYƒŒïWd¥u.é§sEüÊ 3ò¡T,8IÏ» ’¶Qÿ,(Vx¥)xÄ}}ùéy'žø,îZlº2Ÿ‹§ˆÿoI¥ј)­¬ºäÀcGgà§ÖÖ¬ÂIåX ̾'üò¸¥ž(x„lp)©Ì,�@Ó<a)ç¦ûÂÓQ(ÂÍw5CŠÂí8f1£L«ìQ†æÏ~ðÎÞK´8^éV#"EìÊiùúPù…ð_zÄgZ‡EvÛ+-œ´×Œi>ÆÀÔR8!†ú¶œŒ/½ÿÅǸ6*Q×ê†ÿ†/ŒsÇ­JüÐU´éº#hÉŽõ”-JVþbkR5OMù5ÜXmÓEŸ›µÑó"(·zka™yäöOMÝH»3JHÁ|DÙÿ!]Qþù|µäf^òú/û :b4‚S˜�Pjïr+XóÒWµÈJ̶%qEö³ôôûåÚn÷ÃíÑÿ( &ªÌâÙlvÕ3‹‡ñ€K¿96ª¯± …ÐxÞP©¼ßn¿½FÀìÑÿg û'êh }©pÏ©][VJ‚çC/Aæ™7O œ²Ã²>Û¤òPw` ÃÁª€´ºVžŒÍÆ EæY:�þ–ñ©sýƒ†ê@�v¾Y¿€Àå^ÁXðw˜+Šm–½ZÁ ø2À®×�@|ŒÔoSŠ¦ŒBÅýÌT2Zsx€Qb¶ß)ªÿУìV¨ç<ß9÷ãr#í-fh!"畸ìä¹€(¦jwÇ=çä÷¦FÃtYøIÈ®¨Å¨=Ð 0ú_¾a °’Þ_,O Q‹pUÐ[@…°…4JÎýòït4m(BÒ¿wùÝu6ËWV˜Tu”2F½õš�½ ÝÏSM‡¤Í³†+¤Ü?ßÄRþFQjå>+âyÐÌ”Ø~6žú†-L¬P‡NÕñÑÏ*⦰—wpÉš>½bB0V,—êÚ/¾×T­ŒÝq™ƒþ<â®·z†|S/ÈBuÅJ}3ðCÙà¤úB!ž(käUz¤}Q93Â*jnaÀg™ UÑó…ûvu sceo5”ãLÖ“8ubãZI8féðSÔBCt.)ºíø™3R¯à=Bæ-Ý?3ÅR tŽ3›ì¬ z…7Ȍا„Ê·xgí_3ãÀÃÆÞê$¦m/L¶`žqò("´%®q`ËzFsøƒ­§±,K­† {Á&ºû[©† ßLù;'t½9yÔ”¤k¨M )}ø󗇛#ç싳°œÓaÆôà¹ÆˆÓ?O8…-éQQÆ?êfâ ËKÍ¿ôÝ":á.m¡…Ò\ï¸hZ°Gjô(VukÞ= Vº¡rÉûïj´^9ëy&îS­úcI0—ôãlµèî˜É_ðŸOöU$³ª$îØnÄ™Ñ$b %X›-zó§‹)ƒÒ€ç©û“·ÄeúŠ 1ôM|Ã4è¾² aø›ªÒ`–®puúçf¸RÚÙy”í[ õð†-<f¤5Jr|ÓŽ³¿ZÄn¨ìÛT«A‘º—›'~=”0­rßJŠnθ£³ngûþqfÂ/W‰ª­Ä.ð¼.= ;úŸ}Iyï¤+ "Ý=%é§mô–¾Ýƒ-9¶Ø’•zö„È*+`(‡%«o»º…ü¿ëx.בÎ{üsGÿèÚÖ¾"ý÷lÑrŽÌ0D½x®´Be²­nÀ¼xÔ¹»Pyѹ¦C?ž'Û¶g9ˆšö:-ùñBæf?ìPkŽ²ôvtñ|ˆáúP’ç[Åwg§f§Ò3¯"Q¢]fþJ/ű«z×ùg^ʬÛsWÿÁ¤+¿u™ë,¨¬0 hæhÌ`xêšc÷”_z Ë^8ß½#¼àБguã_gRG™˜+ ¡sJôØ:ós¯ô¼)äÑîEO{€Í³R`¡8NŽ¢“/”ƒ|øÕ Rµ"NÊÃ�aº‚9Aêß²éiûî­qÀ~èñ_$ƒÆ©Ë×2ÔrGÐ[²±×a*É]½±peˆÖòÔôûÅëƒ0ôY @•B,¿Qœ�ÊT°rÓçy¯³.ùw²i ñô¦iŽ‹Ýï ²ÜÄÛÈÙ òV$ÆE‘R1©ànÏG×±.—Iàþ+)óÈâg¢ÂR2ÏéÕÚ;ñL¹4ã;ü‚‰þœôŸÎƒ{L„œ#‰ÈŸ$�NÓþ¯½zo»Ÿ Ymî6G=FÞP&£¹=vžµç`ê¨tÂÂzºLô—Í‚Y—â8\ÇÙIŽiûåÞ•6Ëx5èŒïRuj^–4TzŸ÷ìR+Äc‹qyíÅ~Q¢Ý˯ÏÅ3Ó\!%Žõ‹‰ÊËt^|l^ÙkÜtß C•ž‹8(Ç­Ù}É‚4{E½ùÛ/t ¬9¹ßÑΞ&ÇÐbÛªslz}O kqå3+d»ñ¨·x3ÔNF845 z6dRÉqbÑ÷ï€Ä ^bá¾Aºk=AªdŒ>׋t÷$®üvIÁ† ‰s²-mƒ6¯ÇÔi‘þÎ'ÔúHWnŽ­B+aû§e:N~¼ÎÀ�SƒŽ”é=ÞA`äz•‹ -E½hÐìõ–Dƒ–En—¦ÝP/ áÒØ$°NÀîœÑ7à.„Q[í†S_ïLê©ü“ÉU‰—$ëN®2(Ú/m÷×F¤ýÙJ^{¾.cæ>�5ðŒ”rga¶3}‡z?:fÌ¢8!Ëþ½—“¥Ì1šb>ÉÔy½+np [¿æ;ƒˆùáÐÁ9­Lžo¶eäõE}¡ÕQ—­, Õ˜ô»…¶^7îŽÚd´’¢¯þ%˜Âg+QJ?`=j•jàaa‘»"È À,Ÿãšy} êµÆ)‘¨oGšYEV¤E¬`s®“¡¢ò%¤¡³WSA²Ýzù ï„ñìFoPF0‹h¨?ÖÜ™è oè+%ZK;í_Áäw öÿ½xåÊ®¡ß¼œ¢\·ó¸{»³?1ü«&}šøó5Ìik`+>½ …'îJp8åµÇ:gþåŒ|>¤ºH2¯ §ÏÛÑñb¥2ÊPΙ¨²§ËorQ–8„„?9Û‡\µ¸ÊJCC”p;¿™ÇQé/@8BS:hÿõºV˜ÖXÿR~\¨X�ÒÀxÜ¥§íQøD3¤AaÔcæÿ¯åS¶œ"O¬Wû£`´Mc$ª`U'T˜»1¸ñÚbÉZéÕ¿ *¿í°¡:t6»GÃØå±™øÎ;Ú‹–Å•–¾%‹Ó__:º]Ñ]}•{Âñ"µ¹’ Ý~zYïç‘ËwYx÷º S}YºË‡1º#�Û(zÝã "ÏzȢ빡p>Ê¡§X°Å)æ^Ç+Õð¢Ã vÒw”ç!.n!mG[óÓJëA s¨Û«“8€SÔ ÀÖã\®¡«‘?™†Èl’ñà«y *’¾ç+³³ÒC/Í7*ŒˆÔLs¸k<Ӻ˕~œ2±±×l<>jó;m*9®‚vÌ‚r¶c¬ˆM_:GÕ½'1óLlƶÄGÅ£LôÆÞ!îʾ?Ï S×ÜtôŒ“A®Ÿ¹ÑÚF™iºƒü‘ky„ûÎ9‹Ü šŠ\‘› g¥ž…Þ¤*Î᤟štÉLD„GU$›·–JBÊù€21½×ÜðÂ)3BP˧�8Mû#4Ôös,ñÓÕ$�Ëq®Ã¼ÈÝG‹Í}ñ +(„Ñw¡ÛqšÌ—1uŠI‰ó Ñë5]–®mÍË»|Ñâ/UIŠÊ HtNGgeÓ%ÜÝöž)îvØóͳ½ßøé„<XÈÞ§U+ÚÒÁUÏò¶ÄzRkÙ`'ÓR(Ѫ¨ÏžhÃrÍáò‚P¾~îT°igÔŠ¯ΨP‹7†iÐãFSY.yÂú'ÊÎêqy6Ä´£äµÜŽ›s2}… 7·†áôýJ«•o¿0FæºÚx¢|èèTÏ'kĪ]»gà9[Ë …é¨<qqeàšï~Ý/To¥§GwnêÎÃZO¸Ie¾t@AÇ”x'ηcŽJØÒBl†³ÁámM‘Vî(m¯²ÖÞt¨) ‚µóš1Ýw¾ŸÖ§ÑÝúþ‹'ÖLÑ7eQ:!s+‘:AëªÅÔýBÀÇaæ³Ídæ/êo×BéZ…¾ßDË·QÈ‘ƒ¾îáôPÁ|ÿú±Ef”øú´°ÛA3¦:)âNp×â¯)¢…c‡Œig{Õ´±fïàoÓG-×ñµ: KœT„6Þ “š-v‰uiEXÝ=À½êqì¾Ð½Òz¦Íže§šö9#WÖ„gzw¡§ÇÁZ;3lkëËØ@©¯•ܬÁßê Z³>ãik6=›V Á“Éæx:ѱí¼Ô¿_|WËÍ|-ŒÐ¨‹çõ—§ç¾=~Lî«ìŸ8óñÊxØWº5eÛzW#wà<’Ê@J¸)÷ž©$Ùô×>Rýêz-X\„~Sœâîñ Ú…Ÿ×:}ÑD¶F#ßæ®~Ò‡©Öã©ÇlT­v�³ØÖ(f sŸ‘Ž‡ •6þ@+ÅÍ\ØÐÅïg-ǯ_Ýå¯îÊK`#'úi–!Åž+•z¾F'3Îf3>o È3*`»ÇC çö’·®œZùTÚÍŠŒ¸Ë6³T’µ9¶àþIªü³lGù~t°éó ÚÚ±n¡X 6ëõ¼—ßúë“· ŸÛ”õ�U¢¨úFó³•>|)7i;›$So†])‘ãÙmÒ²ö‚I2·C/—ðÝ—|À·÷}­z”ÄËñ2þ$ P…>ˆå2äò¬¯;O¿ó¢’½›Ñy0[°©bf‚÷U€iÁ…•|ñ³}á‡+IJ’ç$È­³Fš::¤åK=Q#yö’¤Ø¦xhÂtŸlBÆ'ƒ-ÒÈ LDúr’œ^ꖗ΢ßÍ;™×‡t ,•uƒlRÑ×Ńþâöž÷½­|¯ÿ„ˆÊ"ãƒîÕ»öÛ¡ùv\ŽÃ©ŸýAA¾úŠÜx ’.aæ>õ8&Aùe­-ƒà8ƒbîÚ_B“rÕ×O0ͤº4:ͤ{6Ó¾–ÿëQfî GqÛG<s X²>k^ÁÝrïçúwÿGõ<d…‰QÐcuÉÔtü¯ý# ¿{¿ÎWH.üóŸ6œ£%UΞ¬8<²ÀΉ#´#ýILá¾½®•‘…[éSZO»÷âëa}ÙIÓý‰SݦP@p„ípW ©öy™yˆ,ä8ïŶ2ÐÃ,±*¬‚eDJ÷®ßÕȱþ0tïúòa²Þ©eñ@Ò,‹WH ÚUìÙžw™sÓ—–´Dt<Á]›:_[±l§"z4ÍÞeä¤F­6â´ïª#f0ÀQryr H ¥*želý! 3|;ºõÐ'ª²U²ÃÞwÅÉJd°qÜŽ¾¤ƒ—ÅeŸ›à91qy®àjZ€®ÊJ‚&4#,ücË4X†˜yô´:’Vå×€CiÎûA)<ºðvŒ>A£ôt¦t$ZµnŠÕÈÓ¨°Z×ÆSÅ“boYTÑtÜ‘¿+@WÎV/eÃæ\;­\2¿Ý™ªˆIÒ%D“u ¬X^BhY{m©lz*ð¬üg¢<\SRÇžHöt›™Šqo5Þèd\©ÒáQ¼ŸUÛ*æue$¢Õkyq\zCñ’¡²3mõâSI�À&öÿþÛiMÿ½à¾™%ËÎŽBn~d:ÞM¤/Å_V‚ o»šÞ°îzX=÷W¥Fnƒwzuvš�~/Æ ã¯«Ý$}7Z?- Šã^ë*ŒA¬J7Åèý^#8KÃÕ% – ,D3e)߬÷s«í³n¡2ê”ñ[·tûŒ´ÞðºÔÈ#$€¨–ŒŽÓÆêDÔFB^*Ó»²¡òº½ÇœMOË%GÿÜPñ6Yn`'kÃïüe†º½´î¾oäkêf\œ�––~j‡,“ƒÃž—8y¸°_º±åùhguGm™#Ik÷ë—Õ±GÖÊ"–X'íy¤ªƒéÓà÷>ÒÏ‹U9IÛ’2ájT>lÂ’stÜÔ“*ôÇáFm?²@¾³B-֢،Ò;³6Z"qOßeïºÑ¯é6eÊ8Q•á™ÒÅôkp“‡Ë~tçÂL?1ëçæÕV©ŽKñG¶’·zŸë¦NßBæ{\±YlN‹u¼8r$HåÌÖqÓ£}"·À¿æ‘Ï›o4´°þ ‰g¶î쎧nR —¥SÖ“–˜GŠé ]YêF—æÖ¾2M m†’­Û³Šlþ4¹'Þ{žùܪµ>6.‹œÃ8êQ:µ\è†E€šÃQŒR3QÑ—¼í›óD€ÄšsGÆá}J胚k³‚²=sQ6}ÖIUÁ;=ÏË/¨öž'¦¬œ†žìtV*Bä<CtóX4ìÀÎç·?�¡?­dÔ²ì,L…]FÑúäá8N` ƒíuP…Ø„4 ¯u{¾…º=$ñª-‚ä49:ùö<ýÛ™÷\8cv"öÆÜwÙɲÒ> În—Ï8(»Áa¿·ûÉÛ ?Ö a²¢`àMƒ¨ÖÆ) /×›ýv¿‘ƒøñÝ*Yq–©l�î-þµò˜©)Í0Ù©ì{g7WÈûñ~dÁ\…uA:êç_àÀ/3O;.€‚î¤:À‚²(ÑÃ’å$ÂbœiéîG<!LôÝ…ŸŒó2£¨>9(4-¿!�¬5ýA’$2"?[|†+K2zØ쨔wµµÄ+ã%"€¿uL~�ýô»oÈwʨéÌï¶ÎU‰GU¬*lM*l"­Ïúù¯ÀZ,’0wgll:AÒÁ:»Ôk@(§{:"³,6ó4nXmßHnQª›ÌÐäc“ ʲ€úÒŸ=ˆKçƒÙz?àl¢(÷[´Š©æ§Ü`V\“µ@èS:AÌ,éwÅ0ñclhpZé§Ï»ìñwèð{–5DDǨ0¨&ÛS„Ê t^¶õ—5/Å—üæõ<'öðëØt:LeouXÅKS–ÎñéZüÏ%;ãb- š§²Q{—G$¾“-Ïv ’úÁtòžNG$¹™•C‚;*=æ±ñF ìúµš¿¨´ùÀ Ã’ÀñŒÞµº„ÃN3PaÍÇèoD¼K‡Ú’ÑÎ2¡ÖíLA»Š2;ZhpŸ©Prfê'zhX®ôú/eÝû¹Ê‰•.q4L'* ð‰M¼é Æ« 6vÇÉooý˜µ¥ÏJÅ]ÿ P”Z×çì¬5²*Ý5öŽ6-oúʱãÔÕ7­à,µ•RÈXŸ„µ¢OŘü±÷ã|†ñ†µ?åtMç»:>=sø íiýMVuŒîº$èÝ'!BÛ”›…¢ÀÌdïB57§²u>ñ=£,1Ó¼øTF:pƒ)Öl’à zË©OǾoÂIûÑt¶Lo .Ê 2û<»€´5ÝâÍž>oË@¼û¿<í¿kV ÕµUìùÁ“5 Wf¾¬O]!7Ë\b¹ÙQÈÏ‚½õó{ÙÜ/­Vñ˜y08¯Vñ>LDŠ·.9¢i9p¡¯‰­q¬nk*ן<nU6fãZ¸+—1*&‡î¯$ÜàI;mC—C>nòJvC”úÏÖ%×Úþç_Zýßüj¿4|”³ÖvyhÈq¾Ïh¶ËéõÛ³ÝúÓ*Iƒ‘uÓ——¡J^kòüœuùnÒœú6=œ‘3…D¸ä9” eFcŽn¶3ÀÒq3O)Pûè§p‘­›ÓÐ.L­Õ.=³‘ÊÓUÖ„¾ìé‘«­ý+Š…¶j* Das ¤+ŸtSULWœ£%9,@£ùMYèñ„ÍD'¥”¬÷tø²,›ÌÌX{7uT»‰+ÝE¾Ù„ÖÝÀdQ>å¿—aYá$óX5‰õíãap  #ìçÑ�³ôý ÿÍ´6ÊÂÜž|ïOhE½·ÞX{ÁSrÚ¤BrWú×^”YÔ0IðÅàBÛXß¾½"”Zvd³ zÏnQgË…–ƒ¾¯wÝžyþð ’)£‘G¨�ûåbü"Ç�°…üßÀÌV»þÝ—BGŸáU£¸ðéÖ«ÅO™VùÞòHú¾-ûWVýz”a¤u“�qéÔO™çY1–æ8û–¨ýóÀ/­ Æ7Q4Ÿ]ÌÖ¶(9T…¹¦ãÈ}Và.¶Éš¹Þüø­ ¹²ÁÊ8ÜžÁòX¶hFc<br¸‡ÆTvêgJÇ2hhC•§ÁîJfmI‡ìÑWðYêâ;5µ#=ÔOËO©¤ ™Xq¾„qvvf±Q^‹öÓ?3³÷åÒžx¡€M—-jêÖ¢*‘*ézºªð”Ø‹Ç"ÓQ¹ÖQ ƒZ„»OåkEøÁôàé¾~Æó•è.TžoÜ%àÙ¼[2L˜¹³âéê‘›prÏÁfœˆNjÄ'ÇSd‹zK檻n1‚LýÇ—¯«ëÃqä )ï¼þɳ]V½!VjKmo«#?–ÊOŒ›gÁW?‹µQÍ›y®‡ ëÓ2-ê³ë“Õ‹QûáôEôo4}þ ÒÁ={¥a€:„f*Т‚“žD}pä6v4^èžèë`ŸÝ¼ÂªªVœ0ÇJ'+8»CG»<jâw Lë­—1çš)EêˆÚ‰ÁcSå±L¾<å¸Û²5®Ò´7<|ÇL¥\qeÙÚº†%梯wÏnÀok†ÜZKîÊréZÁo†òßi6°h héj×Rr‘7£Ø­³Ê†*21©w#8›I<ý—+ŒÑ´œ`%Þì¬ÇK¬‰£ÿ¥é–âùP&æ®.ØDߪv¢BðÊо¡Sm÷îò9ìªä3¹Wœ©Öí_ôuòðFhh<ÑZögœtAl½U`¾ïí+zŽ.§‰’2&…—?Æ칎iÛìf¦èçå”ôgloèÎïzz( %XG‚t_¾Ã%¢F-ºÚˆÓñnü ׸ëuß„ÊŠÞ÷ŒûB_õ)¬Ð÷§Äuø2Áë퀎Æ{)†¸Ú$G­Äó³CoÝqKt°„ŸKtIoõ+‰f½:°î ´¿µ÷µ®f~ðé3ø[$åŒK¾»)n“»ñ8ìk_Kü/`cqæûŠÁ'cÂøj§¥.:­ ÐÖ²aûÉ^lÀQÙ|ø}8 {š]<CA'§…WÇõÛ?oqÜþÎñâÅ/%iâxå&KËî€Ö\Z+H¢tõ°Y“7J×E .9í2䧔Ž(Ïo\i6K„èóé)®.XO‹¦dPâh±ò·°Šq…qkjÀZµUÉe ôèí8ŽA<Д¥»�ÛÀ‚³èný75RÔŒhJ‡™ø›f—­GC뮄V l÷M{Ã0~ A\&Þˆ¢â€zA?|RÓ¿‚*ØŒ­êç©G»>rœ°Î-µ”ïõHøêlS‚œ‡çh.œêy^Òºý¿ÂSh©F“ÕÅË}ƒœÍqöUÇ©ey¶V†íÛœ…a”›ÏÙ±h`ªîÖ~'D wõŒ§lÏÈÂÛ›rxCãäü$n­6A6¿¼íÊÊÊW°¤%³Sã)þl n·ÕÉÔO¯ñ#óĶâ$>톌¢’•¯†OØfÊEï»a£wù½q§ët„ÖJPœkOô çüÀ•ä̘ Ýp03-wiÁ-žõMŠÂÉ]ÙI.Æü,‰ cÝÔÊŸ4š½«Ÿ~ÒJý .biï,ÈÏg¬eÉR*1ÏÂjt~³QÇ«ZyúŒÅ!•¹“' ÏY{.`0ã’·ôô}Jý¾{£Ô-ØæËsBó'ŒtÂèmÄ·© ‹A[Ót>|ƒiP–Ç©îB/DìÄ, ¤Õ³ù–Te1'LXÍ YÞ•ç ­*؃Ülq1ï\èѶúQÕ€ÊuiYçÔsCç[£4‹Üð=%‹ßB¼$ǃZø|G3<ϼL€ÇÓŽnyù©fƒpTšxDêô£%O«Ü‚téNj~¶RO¼Ú—sD*á(Ï]ÏOq@¤ÞnU6çJMÁÙ»zæ.•¥  S*09š¿‹$ê?‚+7‰”Èžl‡ãB»ÍZœÊÍû>‹(=ƒá¸@Fìýâ¬Éù1€EÛ\í™ÏÜCõ4nîüæ8Ï‘õwut•„kŒ_†€Høà]­ÍôLˆ½£$É3e‘WÒ£ ²þäûKQ´µ½Ž×°­Ö\[܈ »KïÚ)G+Y«ÂIQ}úö{‘ûx5Œ<J»ãõg¨Ú²°äÙž«s8¶ð¿‘AË"_O^[ÞXf®A·9BNt³W’ï«Íî(uL–Ùô•*ŸPå(:pø§}Ð]†#vô³a˜ÓÌé�_˜û]„­U6�ΘnNݲ£I”_Qߊ<rbd~a~Z²œ(™\/–J-p_ƒ±——úC@´wV­óñ@Ü8ÐfË›~eÉÓšúÎðw¥/IÏ ¨Æš=o¿ã€²øFZœ{)ñU!“襴▦¹ äÝJ‰£èF!ˆ»ö³Ês³¾­oùq=óëßÌ©¬ìµ„ ÔÈ=ïWgJöëTï[‡à}ðvÿyÛôØo†Û…4Y°ý¯üo²ä@·J»jQà3O¦õ‡Š Š…ǪÅéIð«žU¼’Ä'TCûÇÚ �ºEŠT¸¹æ«Õ€ÎÍöQ nó4HšÎ£Ô€òB%Õ<݇þ¾ÒK6¢È²£Sô8Aõþo•Ö †™^fX¨¾ÇaY§VépÀÚÓa&»ëÞÕ·&¾ªÆFUdw¦#'—U/ uµ%`µ¢#åŠ ú³Ÿv” 'u _„+ Ü"¸€ûºè¬ŠývkÙÀ uDǨpóÓ-SÕðeÂMÀÎÀ.kXÑ|n')´9¶3¿GDXa_µjÜ4eP4z,¤QÔç©;Nz_ŒÉ¼+�QøŠmQÆ7ç¶óL[87Fâ`…CÐü~¦“¡Z4ù=+>håýâHŠõÇÞ“urù£ÉHC®áÙ¦õ{’Y®w/Éy¨èï( ¢hœã³2Z‡ êHh%ËwxžÃjt‘ñ3-ÔSGc~U2oR°ÆÐA›fð35ý¯€(Q¨JO¹*~w9=%5Pœ\ N²š›‘M™Ž—åùÓпu aÔ0Ašk§ß+¶.Hü„oÓAø8¹ÓZJmü8óŒ§`7  çă¬X"÷LGn}ñ& º;¿Aê·"¡G2&Av½¨à9€K ]÷!ÿXí§75qš‡(×3Ÿ0hœU‘&êF(_øïÜ`Mì¥!vd…«\Cºs©U挕<Ð.®ÍÃüï;qùJŒFx¼´p{ý³ŒæD”×Ð_±yOH<Á aWÑ!¬TU´—[8™XŽmˆ>o–ù —ŠL¿‚«¡N·–=Ë F>Ë¥Y‹üÜÛž–Î$MEØ D” yTEH|nY…;eS€É[NZZÐÑñ125VxÉHà ¸÷ “7[¹;ÓŠj* †×‹.3ïë8vB¼0Ö­)JyÜÅ·4¤¬ Oö6dõJ‹ý°iÌ~’{ôz͇dheÃÜ3§}­Öa'U"- löFÁTIiá6}7¸äî'Êz\yîÙ©1¡Êã]'™jˆMW£®Ì¯XYð^¨HQ ÀÂ\Þz€Íw=è|(ŽÍË‹ëL³ï5ìþ¬6‹}Ÿ2X~quîùlš�Ê®›5SZ0êeâ–^€Ä±¦žY"9gÖ°ïÃ$`Vv2ëÛõ]Çr)NbÕœç¯á?ܸ!1¶ZÍœ {õÎú*“nÁ4oŠì?gu¶¶¾Q€Na|úŠÇò¬-Yɉ·¯ßý ñcæ5l&{ÁðÃH« ÎU 3‰Ði °?" L–GvïÕ•¡[•éùÑN ÕAŸ¢wÚ/Pøáœfš‡®½™Êv\™ÒYÍ4Rg°,Í¥íµ <F‡MLÖ­7ÎÅÏhøá�únHYô,>+{ÝŽ°à°ž>Ö©7®ŽøQ4ŠË'*;H;{””º‹×\sàËÅXðÿ£а'ãÈ R¶×2H¾jí’ÇÒzï니ë@6±ŸÜ$‚fàö:´7÷0-¼£¡Ii“(ñ©LÙí÷3uìxÌ•Ë Öàd6Wéðî ã™_ìÉË?µ·ŠŠÊ"�Yz‚½‰“éÝÓšÎÕ |)G‡‹k7¶OLŠ#-j¤¶ý‡ÞÎJþÜÎäpD˜eìá�ìîz%fYæµt0ù©չüÃШƒØ¦iß‘a¹«­äå \‹á“Ï×<(ÚO›+@³ÔÙÞo¬É=Ý‹Å+ÈèEI¼òa€çZdç«­Å ®ÔÌLñ%ÌÌËÅ nËÐîu ñï~ö/¹Á( ¤ûJ0k´jDwí!E¢Ÿ”!Ù-•‰t†´$œÖBÝUrwXǽbûäY»ø¼âË믑]×2 º]pÎjB<äé{¤ïµGØrB»Ç-æJÏÁ”Giõ@Y°£²@Æ°E]`*@TÌhu©W·#!E‘…b}›Pp¼ª±Ab9ÛÝþŒ†ÓlÔQüããb¥4ÿÀ…RÉYË,îöPô àtüãyѳlÏé¿o|µ(ŠmÒ›¢¨?ÑÒÙƒŒ}IÁm¿ J<Ø#wÊëJÃW©l@:‹éä2¾¶CŽ_A:cÕ‘ñè>rÜkpvÃB¤´µê?šÒRÖMÅ:æ4ªÎê]]èÙï–ÆeöˆFsøˆrái?Z8dbLJ=Ȣ঩ˆç(HšƒõÍ™3?eFFiØ#÷+è{5uT䦨�ô|AÅ;¨3RbjÓ†êÚrãñ7˜Š|•ú‡8é1Xp%O—Àã¡,ÑF4…Úþ³ÁêŒù[–=|ÛÁ,ƒý ý‹¯ÎIù\hK)(U-éÑüÖðûãÜÊD%š¢sGß`¶÷HnhõûÝ›Ì3”ت!óR+ñXì¶éSŠ­–nÈÆÝf?X›è¡žA°wN²Êü;•‰òHõù¯ç16íOlÉ+O@„FÊTž5"pú3䆯ÿñ4>¦>ÒÿÎ( } …=h&ŸžjÓ¦Fy¢•FhðÁ«jÕjÖAº=£P}µ&o v¥ûê†ìõ$^âŒT|’y¹IamÙ‹A““8«=úC›©[c+^ñ‚5{²v¢ÎMve`9áZÓþ:»ªÊ4S!kÑd¤Ô5t¾µàOcÊ�®‰'Çã®þ95ùÏp=|omÇaé \®l&ª©vÚö¤Otk„“x ËÞÓê?ìES|Ÿ"žŽQ~ÈLŸäóäzÒî�DçSd_$ûäÖÞHVÒ|¤³ œwn&ør’¿†òž UÌšvKÄaG‡\YèöªÚ6ØÏ@ÆèqYY.g»UfESQS+;&F—ûŒÒÁú€Xåߟtk“Ê!˜*¾-”®ä¢dŒ>“,š #B‘ýo³O<J"õ0dðÖ¼"á º…b(F¸ÛÄŒ°ä¼k~è°³h•g,{sî]K aeìíÜý$z“†¾à9tÄrÚZEtÜ™µe†#Dz ©Ûíçõw°Å‰~Ô 8ç‹~`º•ì&oŠö·Îüéw@sk‚Z˜îË8Ñ]Žßµ\oê;¶ iJžÿ¬œÆŸÀç-‘´0춧›ô©Ec™¾ Z`Jd`pÔõíîOžÆ…´Àè¸Bq‘Ÿ”ÞK“í—_“F³UaÈî?Tµ¼»Gk¸„úÍ­Î#ßÄ „ ”ÊZÅÒ”a„Bì¤Ì=–g>,iâY+s7¾EÙY-¸•‰Úõ?oUaRÙ˜î ïºÓº]ûÀS5úŸÒïK%†TÍ—AIV•<Ë·m=©ê«çöÚ =ѵi#`ó§ ’ºs*82×â)iSï’ééß×{²E>]iÍP®Äöôˆà¤Iù·¯nÐÌ‘Ö=ã¹Õ—;Äû"ôí‹*ÀGÆ49adøœvÜ#ãÞû·_×uêmÕº‚2$nD g­Yt’YµlÓŽì¨õþí<U:«¨w¦¿¶U`#T#艀Ug´‹Ûó¨ý¯_ø`X‡qJ ëWá8{feR[ªŸ„]ý½¾ßlA)*‚Ê4;±<«Œ05qÛ•…=æS½þAÿ@‹”þæ%¹é[U¾e¦\²S£„í%.rX3Øê7ÂÌq¶Ò£u. `ÛT¬J‘ ó䇎µ‹Æ:Œ?i­\j•iqÛQÚí‹#Ü:>®?Ë•ÿ”mNà߆½©ÇºÝ×€u¯ä¿_üÃT6SÜ)›ñQL¨¾ô‘/ǦÞlŽoª¶ÿyËè¤8¹°Kuù Ä÷sž;U42ÌrƒØdS<Gìþ€Ìa‚?… öä\½Ü7v¯¾iÙ]Ê ^F׈i h•ã<“ÙRD¦ÎpÎ,èT¨l æå‘uÀõ•®Š‰æºj…/^;ùÄq uxÐѯ¯ž®…D!!è*<!6TåJŒ’ņ)­°Ý\(‘ãà»hÞË·“2Mó?Ždd:ÿe3IW1†vÌIÞô]Û p«L->kÕƦ¸6 ¸ýæÇÇ®XåmÍ}=æ!ó¹åM]Ëó'x!™?E»š/n/F¹|ÃïXGÇ·ºª:ªùËMƒÙ‚×óݽÅóÞš¸c+Ñék¦Ûópó’…™Ÿ�>kžÂªaBçÊ&ëÜï±?‹µæˆÉRÎ×]œšÞ­{+˜Î­·ßôè<—9. ¿}ªÂÀáõc¶èA‚2›Y£‡†]ð+þÜYW‰îÕ¦I)Øè3Ú˜Fˆœd…ýYÌ$^Ã:Þ cY¸¥ë<±l)6OðÙº×Kû)OÂâ¦*¹ÔePLd—µBõ/û}ZóÒ³i¬¾xHšÌ¤M£Õ«|ôpêÖR>0ãÅ‚±Ê¿ºƒC­“˜ãŒTd槓ƒMõÙÊ6Î@¸pŠ*Š¿ör-+×ðÍÅêâ`–šŽWïç t&…ø+±E«Ëf»FSŸÓá«&$ÈT(ü/Ýàªçž½Q)¸ì™ÿŠ-€q‹ðr¬ÞVâgôч‚ÙVmñD2Œ˜ÿ~üg‹À:Ï/ýÆÜìwÊ.}— ýÅ^7ùû¹Ù%!§iL+“GÄ/‰/æié[£Æ›€¿ùt»Ü„!ÛöÒ°ô0<Ñw͵œ5<kØ'~ZHæ³nß•¹“b¹bD£!™zjV¹lñ[‡‚b0°í„؃àß»ºÝEé²CIƒ¢œKNLí¬;qÿ~q'Znf^±ÉðB (¬Ï 0¢,;º£åæ¾Ú"{é_BH!O'òÚU<:ÙzŠ8amE’™¸u<ÌR|v`hAÊ˼‚Ê×-OZFbP)C dšÜôò»S=σX¥“‚󯜸Zeδ–Šw¹s²‰™gS·Vз¿.}gþyscâÄÉ<HyÔÐÛ7Ë£à›~Ð/­q"G‚•¢/íœQ™S—² ZýrŽeíËp†B�;„'VU Zcâïà8…O<ÂÓÊŽÑÑõf‹&Œelm‚¼Xdæ`µVÏ#;àÚ ‘ÈÅp£nšYîz©q:Jƒ¤wÛýv^¯„Ò‹H¸U…}SnÇaâ›S\§ @åö©÷˜R Œ½2ߤ©>Np+Ï,‹}ïØ€"vÞa‰¼©'p¥Þ=("ÏßN†$}M{ÞR\‘�Š[¼SžŸÄúdºNÔ•;Tá ™²úr©½bÞ¹²ßq¤I€¯y<8OŸk¨/÷Œ'ʲ(,Ê‚ör…õÃæܽ«Ÿvß0EK}Ó¶ä ndhÜs[€ª”jÑË`_îÙ)@^0Í …ÃôS{’xG´}Á®Wz‘EæÃ×èÉ­·Ja2õ„¬öJ¹›AJ;dÆcŒFæ“E:ó §ùݨ¢Ê¸þX°D,{’þI+Ín^wýO•úžnÜø¡¨³¨ÒAŽ´p\¦ýáW³I—ðW®£Nkjt6 Ž´lŠfçÑµ<xÄZ¶rö©£ç‹Qµv`ƒM•€š«¹É§þúwpúÈËQ±#¥¥ rpzú&Öpœ´åû¸ìJBçÑ"9±‰Ä»+xQPx¨g4Fù­wÇ™Åln_ýÀœ%§—á9u1…Ÿ%V Wuei £Â´@@5Îîòxe•+¯»]å”GU² 9(r»50ÑyÚϳµ?pãçãBGåð½µÉ Îí&´Àxüß(t!Î MW!Eœ¹Óæ©ÅÊ¡…Ö'§•q£ª<62f>I)˵>-Ë"¤D£óh’ hï-šé7ŽÅFñ×Ê$2=ÈšL(\øÎé ü¤? -ÝÅ+edt®–g+ÓW5ì·ò! q º—e<K8ŠØÉ–ÇüäŽ)Ý“þËRÎY­ïÌž„SýÔB$LÁž‚tû°ÑXÕ¤ÕwV)–"Î÷z.ûY=œ¿·Y<︊-G ãHÅ›ðÖ´ñÈyŸïxAÏÑO Xi°™(ÞéD1ËUÃZF ûÄ»zXÔeÞØÁÇTès…àË”cKn˜KwÀp1˜7ô-(‰Ù ôzÉÐg6iìsù0RžpƒÆQÓ¥ŠyñGk-Á¦c ;ÚÚO*Y‘[Tk;(](>ÿ5…7 þ°:gùlC]££o˜AyYÍ°È\ß‹Ù"<iÎfë“é]FÙñ¬À*üzºlÑ ¡«µlÔ;í{2Å@Ì¿Y.±Q…܆ŠL¶û±Ïr­3¨¸9§”’SÎ5Lf<5Ÿi¥þ©Ç+Gý­‘ŒùÑIÕÙÀª_àÐÑíºÖ‰‚œÿˆÙzVÿçù•j#(Ö‹–֥̓¸ï=-):«”9Û t·¹›ë_#}šéÎ~&ž¢G,Íá|ÒÃW4kY›&јývûÖ‹dßíaç¬Ãê'1Ô«1‚ê·ž¶<#B4[¨?¨¶p›S_[õ縆'ºÑ­A ÀÈò&âÞãñé«"�£•5TqÇ(ñª)63¦ó™rOÝV?»y®-à*1 ‹†Ñë*BcŠÁÓÿµ ™/Þ³xg]°®h„núúÔ æ©¨¦ì̽8ÆÚ?ªÊøvèÜÙ§¯ šÅƒÎõáÜYd ~™¿ÿRÎy;1ºgÝýÑðÓúPæ.‡ŒË^ÛÒœ9,õÉ®Ä/°Ä¤Ìu ¡BQÑVUU)’¶ûúp´v«gŽY'àd·”L,Ïú\Qž¸s a1ª3}úÈrÐ.¢ÿF¨/ÇSo ”}MÙŽìL{èŒçQÀTÖÌórf0`½ÖžwŽLÂwÙ3ò’¶SÛˆ±´þ滺{šønîÐ)i˜'OŠñ¼èƒ¾àXdÁô=¼>_UŽe„+Ìå³ ²¡ö¬O0#£Ú‡oò,ÇÝ{óro†y4nã sŒî÷§g= N Ûzh)|fôrc s%tí‡ç}ýâVl>¤T¡|y%ü®¶Â›!gê˃¼;-WÒÜep@ßë­t~!(k!@í@gy‘5~ÏèÄ€DšÀ± dZuÆઇsñ¢kÎ<ë{`´á;ChÑSuy–@£â&ÓÑÕÚØØ XÎWä‚o{¦#ÿ‘ŽÙ›Z-uö,ìA ¦[le!†ñ#2šÉÛ?oSpðø/ßÒÒ­Á=ßö׊ßrªyò;n{™e÷sD(ᦃGÈÿ³§´t^Ñ»1L÷brÿWšiž®Ð\úVA|öÁ%œjï}GëÊ%…¿©}Ý>d%r¨¦Ï14óz„žp½WEè…²˜½ Üº½“\'xRæó­#¸Æ–øÁb¾ø;þò‹ G+A[âÓ‘6E´Uh厒&c댽Œã]ûÑÁ›ÖÛÅêÙ4 Ÿ_ ò‹WâOªÁBëg3…¿y6f‘ÞåŠÙX&.‹aùÉ˶ðôÅbd1´Íڌق\ÌJmc÷êÁ¯\Ué M;Cö:¥o,j*0‘zE<¢xºr¦à7ïhÅ|Öæí)é!èÁ 0?yf‹?âá¼f‰ídÓ‘ W…Å¢è3DÒ<ÏbNÞì NüƒîÙ&2]bî“âc Hâ?*%̾ŠÚŒ­s(³TÃD!Ñüåó×\ý—ñIéwÁB°U¡Š®0ÊŠNɽ'1/ôe¯>Kõ;a5K|ÉW¦ ”\;«å|èœì±é@ÈÒÉä+þïåJí8¹ 3AïI΢^ÓA„˜»Ô# ±ÝÅ£~?OW®ØíPRP»zkó]‘):æ%؇=ˆX|ïÍž‰COÊVÞáƒ'ÿuUaÃ*§Æ3S tÒËÎ4Œkðõ»ùéO<«â6xÌSÊöÎôxW£ÿí\›!'ØKUïò–Ú;×Q; Ï?Uƒ ŽÐÃ~¨7n° AÃãI"É=ÏægXîˆEö3+KKÏã�¡!Û«˜îf?GI²Üö¹ywŸå™ëÆ ïr™úZ''³ïM/Otk¤Ü@÷¬º e:OÇûsëñ.í´ à aÿ¯j„àýÖ<t1²6×ÃAþñH® Š3ÿÃÕ�æâÙd…nqºR\@³Äºíá@}p¬F¥ ƒ ´‘X=Õ‚­„é&0ÁÎLžÜé«Ú§QâqM™R9`Nw‹éÂôõ¶ßvGN¡9_7 oŒ÷;·#nõx¹šš|Ô±\¨švi¤pGYÍÞ,õÇš‡pÈB®É‘R<÷iï\aZdÎc’âÚ2Ór,?=𿼣Řã<ï_b|âŽÒ#!£Í #FC X±Ô½uä|ÔÄȽØX±¦ðW‚¡åcf"×x¡3I­B†46µø4m ŒfÚÚ´/V`r¨î&ˆ©5€é%‘0zR¢9dg‚?Ã_¡ß!$�VØ£°öËÿU5wÅ3“è2»±A”$ÆUÍN¦Fë4õ‹`™«$‚¨Q ÖY-ÚnFKãpüòGœãx„æ°Žšû]ÎœáȃŒ÷3ͪþY.SàÒ…–rGcГõ87Ð}5™iºßèÁz/ôÞûÝ7Õ‚$JãT# O»MLësÛªZ±2ŸaÌIj³?-c¡Ÿ†ÖN6‹3œˆñ:t—Ú«C ÌEk.z¡G½Ÿ ÉYŒÄàRú²ñQa¬œ TÎPy¶\¶Õ “Ä)D"'ýQæ( WBO±ˆ*–'[ôÔ¨ÿ±+>_QNŒcM<Bƒ,’Ùm={ ãT“bö~5§­ŠÐë³PÐmêÃÚflº®§»Bu´Uz¡]"ΒȵÍ?¿Û¸9Á x„©ˆ#|n½&g¡ªºŽxñš"‚ò"å9êb ¹\<t›B¬ZÞT_p…W ¢Í?ÍõúŠRzt-UÙ¼Ævöî/#z,Þ1Ëð¶Ç¾ÓÖ#¬@ùâhPVkæ¶,}8XäÔs¾Zâ‘t ûö ‚þ»¦¢ÈÂü:cp»©;T£Æ ‹²8`@iåVáCa‹ù®Œi#ÇÔbª=ºÄ‰{uŠ»@»c–Žño‚já9²ýó-u«9óºN]£ú \£í;ŽØ5¯oÌÐþ¶ ‹È—š‚ a²o¯¬ghW58SÁHOàZkæé¤Å†¥OY®5@Wrª1²ë®vðX¥Åb$Ç€÷;¢¨˜N&ÿ+CUÎÊo…ÓaýؤE‹Tœ2dQ†-sN?š3þNÆp“9”Î]DäN÷§”ŽAm&¦kÊý:›ÜOç¹Ç’{³�~úÏf™]>fSÇЮbÀ…‚s4Ú"œ¾.êë³r±š\Ù}èþ+öÉl÷H[‚=íDTðŒÛã½Ça¿¥Rò£¤`C™²Døø‡Œíg;vJD‘ŠVk ÎÁÊÝqèwT„•dïlÑ8¦Ô¼üž]y~§‰Ñé8Á¥*ívŽ¿F 7nºV„ÛšG…öu/=9,@JšÊ üÒˆ³òûˆ7cßcV‹93TX0ý2ç¦0ýeJüÛ¤ó\>l´lÁPkèÅcá¹·ƒøü¬ç­^‚úŒ;d‚#+Ñ ¤Ä–çKK÷»ÛÄ Ö´ ¥Üÿ2yÞ�¨v8€˜~f_KW†ÅŽQ‹*_)”¶i\Pf»9nà2#í�&´˜Âòú7®ÂqTX¶›œ`uEŸƒAp 8Z&‚wôÙ\?0»b-tBé~GÜÚ ßup]@+}º‚Ûä„ÇlgïÞÕ·™u컩Pí² ´0 ¦«ÏÐó{·ðÄ8X£¸>yéÚ)kßRA{Š”‰%hBÞŒcnÊjgõŽ‹Oú ëë‡.$ž¤³Ë–RîÆyÌækU`fH˜ÌÒ/x‹¯ P’æ,˜GpÕ½ôn8ìU:�£U‘ì¼yõ¼|Ccˆ; 5Tuƒ§ÊÀã ^¢YýæÙù<söÉ2ŸA ¡[(sFÛïm<SØÞ›ÌE«ÙªÚ"w:Éb0½(÷{OrËŒYûGô†t©¿ðpyÁÒ]>DÖúžcF™fV*†E±NðËlB[|SÅ‚°«Ü.ÿûmìŽT˜þ8{©ò°*,ë<8*„ê‹)Ø Sm ú€iiÅÉù¡0¢Ofè/XuDm†õ±Àš¢EYÍïžð ks3^Gk8‰{˜‚Ŭ0®PVHKÞ?y«i{ûD3ý¿’ò{z ™é.ÏsÄí§S—§‡s°ÀdÖúÔ©Æê¾[”Y<úÙsd’ÝGgÜ ’\RÏVþ‹ê‹úÐÁ·Ï‰iü¤™YÄdßH £E­ø à. =¯KÏ 9I~LϲŠERljþ;K8®#÷øõÅ�n6Úß~º£’®Æ×¢ï‚øú).E·E¢)v0™(†Æøô•ä-Ê jˆ©Ì;:d«ÑúFe n°‚‘èsÖ‚q£•»ÛQ‘u êoô bá&’5͘¢ZìÐ2³0Uµ”â  3×T2ÞŽq¢[ïüA+h°¢­UÀcëW„;Ç™Lècl´»º_iä^ù”ª™nXôuQ�‡Þ“9{tohr¼I´‡ XûÖ[lBhä1vç*rV92E‘WܳGQÍÊøóm&§;…׸è íÕÈØö8nŸoöJEç®ÒàÎÄüAÛ©èÔM01Fòl«¤’!PL Óíò ‡zC!È4C8WVû_wèqœO@Y,[O¾Ù4nÅ•³.*gv8nðˆ0þ‘h”­¤ BïJÙ4îŽÓ"H† ÓÁ¬±üYÊ;¥Ã#nù§  êqáHá}ö•(8·N6 -ô/=èr³‹=²ãÓáb¤v;QhÈ(ýTñöâægТluDÁ¸åÿ^-UíD¸[¥yš­5k¦z"ïÿê=ýÜÞ  ‰XÄOÆeÖTLIB§=¥Ôv|•³ïðÅTCÆê å{‚mºæBÛn4*·R8…'£Ê¶´>‚¤ý²0upSÐfsB¡‘ASç®ä…¿B ÈÖÓË'\€›ŽÉ3£¦°ˆ_’ºtv[‰?ÌÇ4¤ŠÎöòÐѧãôheÀ:ó¯ø†¦¹“6W’ŽÂÔh‰�EØÀ§€“ãI燩~xÛþ[€äë­W„¢wlAHþÊZÊÈ¿å‡ÇÖlwG„QYèØY�#Ø`a­XëcýSá¦z1DVÍ ^f‰¬ geâY1µmW»‘#æ +MgöÒÓtú%mļôYa)Õé¤XøOe¤Çü£;µKk*…Û}D0D~¾nàÔy'ÑÝØÊçÑÍOëž"—Þ㔤TÂœ¼¾ß¡«iû°¢9P;~ûú]â,ªÖÒ¢tíèmß{GI¾t-lé…Bêp?ÚW9AŸ =ÙÓ.fçX@ï0ü×3‹™ÔìfˆV¨YÅ9Ÿÿ `¼Ì7Ð ³�#âô½óýr¦}çA¯^”r°üaÓÍL( S¶ýô¸ Í™‘.|Êq¡(TY;÷§¶V].3˜îË6gyZçH°éˆ¶W?ð$ñ)ªˆ}O樈¹ 68˜)e ^&Žòöù-/}WLkRzß±õæ)Û=S_;ü5÷¨ý7ÅâýÉoÇ ÛËVèÖÏöuoú»ˆ’ÙJdŒîéi s´¨ÿ5Ÿ×JÌþç ªÈ2¢³o˜ëòi•¹“ÄãSpö¼�˜/ÿ:xÆi8³FŒ!†´çQl»áŠ2£eDtö®4©(×^b˜ÕÒ’.šw…,QŠ³,óN´ÿ¼ÅùÛ?o*—œæ+d X‡æ•ó¢–’¾ñ¾=STúJ€ã(3°&—€ùÒé? àqh*“a/ž‹hx‚vâtßÂ6á:XãF†p£ö“%D±á<iÏ»ªÇw’K”ùz)Ðìs:Dzg$àiÙ–‹ÃŸ<@¡Ät[2ƒRÆAXIuîÞM6Æèç“œÿuA–®œ‡h¹O=­Û¢9*f2w×Ñêíìa‹4òh_³¯7SâЙÕ’¦IqˆÀO‡–î€ocÈKœ­¯<ߣ¨ò5ŒéülZHugÏ|‰’ôÖ+™…ÃÒ@L¼u 5æçïX‹DO¾H©m_Q5 M0®Þ>®GÍqp)PüÖÏ9}½nÎî|‹mí|½úú2ÛÜÝë¡=o§UØŸ…ÿ/ ×Ê«TdH8¶ÖcéÞ•ë8äIÄR0Mci«]°†�Õt&¾´j ðód±ˆWe`¾ÏÓ’£¹¢tô�¡7Æ. ð÷<­~ç-ôN[+˜–À�¦ÖU½­~¤½hº¯ìÜ×÷¥c§cÑÓej%l‚x8ÔóA0T“ªÕè\çɈ§ð¨#|€m=Ù‚<0+à>ü°/¶SÒÂHOøåøîrÆÝTóØœo7jrä)1¸Ã|½×—¥—¬Ú²èóRØýXÊ jjMdþIæ]¦Êãp”pýÃp°ÕÊýQ\$Ó¨0™kPLÛÖh_!,ÐAgÒx æ€_ëð¾³ãõÏ,Ûè¨Ï'Á°>0˜´óað‚¡Þ3*lXáù{Þöv$G{Â|F‘—VµéùeáŒÊÉVÁ±/’†#5x¬q¢ô!µØnŠÈ½v/é™YoÛ e�—ã®c‡¥? Å·¨é¬mj—Ÿ€)®îš/ˆ‘¥¹šÅÕôP3ÿôt[ßë ±ÃÞ‚£^·UzÑz©,VŒÈœŽíœVMÁ0;GCú P­7×Úþç_ŠÕýof¬vå±Ê(Xcïj.w¾ÐgÄ0fŸíqØAò|GÖ;²Gš"¹!i_õŸŠgˆk‰.£Ãdi"þVà>ö¦ 2«(]9kaÊÐY ¹Í ð!‘¢ò&¥<B²Òîï_zù…iX…0šò׎QÔ`!³â²Y×îH·|¾åӃߒ›nÙf äßyp×MM§‰µ¼;Ž×H^ÞÕÔÓÞnë·Íu¤nÔ½_A ÍÀ•l»Ò ?·®;ÈŸÓ…õglw/í¹â4€$™;ªÞ7£°2Q3åõÓŽÌâÂ&{è9¥,Fí|"Œä&´öƒL ½Ë’ÔQå g0¬n¦»l.^”z ¼ý&øéÂyÎ]7½HEkrêét±†Yp@C²µ 昅®Ý쬭ö |ï…–by‰ÄËÞuÜ(Ë­‡ŒV¢B Ì4Z|%9/lO¦¯§cnžˆù¤…Z•Å¼BJºµTz¥§“{wàÑ;+âÞÕFC—ïßT†‰ÊxߘJk '«ÎŸ{d½ª N];ÖË¥u¶ê"ÑòkÀ{Ë—Ñë õEÜùîϺ>ã?óùDæP›Nòú7Híf½ùÑhN¬Ø®GºGýÖœ¤¥'NœŽ¡ÒÛΊÔeÖ¾ûòàÂ×mDÑ 4}ºÒ‘Y=ÒëHA°È®Œp_茬»Ñ¾bæIæe}9¤h£Ôd`gïnSj”€|HÊŠXI„þ$Èg„›2õñlFª/;阯‚‰ÕwÑ3ùV®ï¡(˜u—bJ‡3|£ëÆÓbi/óàeÅ"! 6çÝÄy‹ Æn<;¬y³á_'Aÿ•i§6Ae¢Aut¸`žöfñ7«ŸCËÔuô ƒGãáå|;øÿκ#ò†rÒ*‚>='+ÏHI†�08Cb4 ¢Ïæ½h4KCÈŽX¬ra1sG©-ücD‘Y¸\WÈäqw¨ðç+ vÀþD!(·åe„½¬®S¦#!ŽSÖpÊ4ÖZ]áXÌÊS‡éØ—ƒ¨E…uG;îfc²·i«öç_b(ç-Ý`~V}Ì¡ 0Ï®g[ƒÔ¾'øèó²„-tNY_Hu *üðÚ?gÖøöOñvtÄèr¯€žî^ô´¢íü/¥^£,ÉÖü É­›w'0´¡Šî8YÕZIˆý¢8NVcñDnA¯ÇSÊFâGTÖœ„w¿z–{ÙËW±J~Ôéijö8­Ì‘h÷χ3_Ó¼ÒòzjÔ¦J ’£ÒYhžµÚ£M5ã²m¤®Á°÷Ä.Òãy¢§„5˜¹¼Z±#n…w>îdEٶ苽Ò,)2çö@gö‚®¼hÛˆ Œö¸(ÉùG™Tßé'ûcžµºKç)ÂÓ±2öÝþ  MôŸãí”´ô#{É‚£Ô`úè§å–9À¡™^#iÍ4â'Ž%,ñM Ìã|]ƒ·™°Ó‘L•zó®zúh£¤^²ŽçZˆFúzŸ ®¿TLEPZÿèØ ›}‹‚'¤pºùñ¡›sœxMRî»_ª é'ëºÔˆÂóÄPa“6®; á`Lwžîü|•B3g- Š¥q  3‹óÇ l]ŒU¡JàYä½Ô@sÎ<€ßà+¯GÆ8ëë1¦„®µ3sŠ³ËñâÁWnò8“ÌÅÊÙ#›0õôõßO®]–£”[¦>…(� /u­ÔÏE»‹ÌÇ:D0`ƒrÉ»ê=¤LåBlÿ^ñû/£�|sl>ôiŒ=¯@QTêw”À[ÝLú"#%)o~M[ `p¨) ’à泇9ŽŒQÿ¾‰3oüÀ eU³²¦†ãηÿ¼QÈàØœÇz¤ˆÐVèü¿š4ìN/ö½Ù8Á�>¤ì¶ŒžÊš­>[íÒ‡æü×y@ꄃQé§"1l]ÃjK÷lRù˿Јˆ=3 ™a²8«^PaÖˆ_V@èiGÌyo ,ƒs5ÂÝÙ¢G õ¨•X 4£½66:ïÈñFQèœX™o:_錙-ÿÄY�E¤eíù~RŸÚ»—¼Qj±-\ó°¢pݶƒñB7ç|Ò‘²`S4X¯uU¯ü‹(hݧ*D ,”Y²H k+‚"¬=ws¥O·tŠ¬ü t.”˧§5L›üu šQÞ“¶¥xx b/T½žUKsËqRœTñ?ÔèÍüd„h)ó2³GîK7=­½~Â|mGç[ÇA°æŠ,#¼ÂºY'ŠÜ˜OrJÍpåi¡“LÙ�ßsJ›Y敯ÁÏ6&ôi³eëTöìhdt Sb²–óØ9zþ ÈØ]DÀöŽo}á«ÒЧ_.1·b¸í_tè©H¾¦©i“õèÝ9‰++°j(†øtäGVÉ ˜ª1Ô„ç[¢õâŸÉÓ}DÖ[T±š6q·ßn;å'ÿ¨&Vz”_®—À)çži¨¤?žNŒà9sœÇýòV« ×~Úœ‡zº1š¹Kþ'2?í*PÂa\éËF¼Ïtkz »Û¯´ G 3ª·£3g ‡¾î[ úH%º§šõkW÷ØWl&†‚fÞ*Ì ã<bÀQÙµßÂV,ê@d(îœ ´ä‡Ô¹»r}ÌTd¸ŠÊ—= ÿßÖ¾d»Q¥YwÌÿžÉþï¢o† Pc#•JµÎû?Ç/"#3‘%Y®}&ví-ËÍ×<üÁMƒ}¯`üMÇr5øô+ó(Œg Ïr–AÑ�>ÇdÍ7q€m®>©Ðe¼)Ú÷‘³®³ÃZEš¾Š8ÍâD‹k{…ù’U¬>Ë°C†ö e÷Ý躻 Vëã�¢¶ž-ðéÖù29/=ñ}©eÞ(÷[tCºu`Ê•Lð<ü¤Šž¹T™o( =ôó›^ÂÔ4rŠø „¾­d—öâ ]4NV®ÁU�ÒR¼SªÄË¡oJ Pø3åz 9|ªO.ŠIÓ Nên˜=‡âPàú2H>[DˆzI“®E6ŘÈĈç\` à•+›ö¬pƒ0ç�¢:É|*7%‰Sš,¤IA{bQ'¿Äœ?쌩—«÷C¶‡ÝÎbõ›Réhk‘ÊECÇ%—ivŒ"åœ_)z÷¥uºÉéì™x|À¼wgB);ëËôÄê- ãl¥à³`äVíµákôÔ¼8E?óCmß9!ÿr©©ÖvØí¾¦‚ÍVJcH´Ì€·r¾G9íjì%Ö[ëþÎÑÉ3¹/¡S}ä«+‡2¤O¾ë¥Wñ/’·Jû> 2+es]z†ÓÏÐW瀑Õ#KŒx$¨}¡¥Ú±“&=¤a7FÛD0zX/ÿŠ8öÝ!è©;Z¡MüòLä‘]t¢=(ÁÈÜìÅ@ÙþÇwÎ×8Ë|J4‹?Çàpÿ¶b˜mÖýqœTkî" _^¿`qÖ¾ÀßÒ¡dÛ%ëJ_ýöÀ†‚ôéèWÞfd„OOi^ô[»Äð†P°¹J&QšÊ²Q¶HøÆ ×q«2AÉ ¡b:6¿¨pÞMžS˼hÛÙ Ìêv+Í›Þ «Ð ¼ p{:–Aôn[a…Àéo±]Ìö8ºb\7G„ T\a[&.<다væP[û‚-pT(Å®2\šéÈJ6Z€¦BLáƒfb[Cåè`ùŠÀ/a|ýSò•Û(rð }‰ú“vÁ€»“˜'ÍMÕ¥t'Oø7&KØN‰ªF¼Ïâ`8Ñ—ÔòepÈu¸¶àÅ˵¹Ð¹F'RÛQ¦·î†úüòró¬Ï\Èùll‚âäyŸ)¦›y²â—üÂ6ˆâj%ê[Ñ„4ÑÞJ¡"1h™Øe ¨'ûZç¨i¼ŸN¿œYª µ’à4þv0oš•fv·ï®~ñúø9Ï¢"¯è}:› ¢'Èž1]¦‘§š¬½ )¬Fqk½Õ÷.ÂR'c7ƒ,Xvó(Ó=ı<¼ÝÑ¢pe ªQØÉ+DVFaÂÿø™[Xë$-4À\®×âNa¢)[åõô‹¶È“Íÿ¶JÓž¾ˆ еÀ<µœ·ªë‚*­—)íΉ¹µ¾>vÇó)X¢ltb<|Ú} Ø™q˜•¿Ù€WßÜéeºEž•JX`vö¤ç>œ´%’Oèr4§ñw”qiN5ËnàÅÏVÕÚX  ê2[* l yÞ¶ëïÉôfy¬ Ä0–U±Àƒ›!<Q© ³ŸhMÆ™WÆDP…®]£õ_éùC½à(Ľ·°.¬›ÛïG2=ïÀ®­z¬’èûž–Ou=›µ„ÙEÊ+…ö�aòmýÖ\‘ó8öþX·ãî¶.ó}dxÍÞe§Å«‘Ûzòîný|¿•Ö¨Ì(¸Ý'”¼ë!áÆ÷GÉyƒƒ‹mÅi±b!V„жÚÍú;øþsUlV*=kq~ºy½Ô}3> ÚÎåë“WxoFÖGd ¸]‹PMú6ÐùЋJ»r»ÌòF”Ì–Ñpò@ì²ÈÀÁó[ ¢ðVUw. Rª·¾HŒß“¹Ë—ñØë•Lš|GhoöhÛü1»t#®Ö¶qø¥ÅÔé,“JÝ?þë—Q«ê4SÊÞ­ŽJ3_{8¸ˆBÎs› h…§Œ«¥·Î&‘/TÆ,|ð©î\MO ê ûÃé¹w€ýð: ‚U¶{÷ºòÛú2Ø’y¯2 xèúäëE§¸ão(ÉMJ‚µMT¦^a…Kßr>–P¥ ï– =æΚ_ {K‡{à˜9ì¬å<Í_š\éÊÛ‘]á’ Ôh' kî¢ ðî„Iò‚uS­HŽa,½³¼«]ƒÉÓ!rŒÒ×ÈÚQè7#�ÉŠ·÷Xw€+ž›«ÍÓ~Ø\ŒWÓâžùP025²'äö°üÙuT¿µÖHŸÔ|]ë`>ü)äøç³Á¨¥‹€xÈ)ŒWWAÐÅ“äYÑ0UAú©L ôÙÓ±¶c¾a€ïÅ3Âaå;s<yXù4[iæ•Ì0&ÈÜ%ìù°÷ £÷%UaFv*åq¨euUŒ7:j^OêVÈèì)õc'IïR¯Ve¦Âð;ÀT fÏ‚Vëe�‰ßÊÃö5^wEáÖ3”ét~ªýM5¥ƒéŒßÕÌ^^Àž˜ƒ5ífN<…àG~ÓQ»µ”õ†aømõeRµ1ÀèÅ&©ß¡–™ç³É·åøÐÒ»¶2Y³Ww†@|8N0°éš`ÛKÓò½ùÞ#F•òÙÌV~t.14ßô½^µs©°€«¡³VÕIÓ��ØV’¢Æ¢‰qPº¦s®ëí×;à4Jv“ÐQ”ˆ3P}Á NÃ$÷Ý#¾µ’°2Ú±Ás-Àú³µÉËÉ7:lË & ž®IeÜ÷ömE1J{Løô‹¢rïèÈ̶†¶?–sõh—¬B8OYZô'«]ƒÑqôÑâ¯IÓG¹+UEDfcì½·SÓžF"Y $‘˜=˜ÒTŏ¶¨)4ðí—Ò»pJب:2#a>wVkBE¼8Iu¢åäË#e‰Ð}î±Ç ¢ÕÁ%8gf�h¿ñ1F.ªÈÐá°«‚|ï™) RÙNdhJRÊͲæ¶õ%n˜+Šµ8ˆãÎÎúBÖÅ¥ÿW§Ú‚r¯ô©’ÊGÑ…Ü~ [ÜÚ™%²¨}Ã_ðb…Ý #5æÖLÈMs[g'x"¸³xîܯÙt;®tj<YÚksã †Šáì‡iåÒõúåk b-ÿÅk 0ö*ÊN8Ãxi-ëì%8Ë=ä< ´(˜·êV�JË8Ú)ñ½”ânrÔHì۪·²c¤ï»o¡Š±8Óë´Ñ ¶ñ°WŠFÎ]Ÿ–»T‡pZûÖ«Øe¿›`¾5úa"1¶¶™ñH³6‰Â•§gœnèeÖfÚƒžþaæÞ* £ûÕNõ•åL&¿®†=j kѺJAçkö›d*„B -Û8(-°0Œ{c\l$'ÍŠ´/-Ø8ÌnAv'º‡q£û®ÿ�ç­¨q\{Ãоs…®Ä½ƒ=Rá%ÓD¨ä€Œ›³·+8à¨kÎONG•S—6Z˜R2UŤ;,ˆSÝzª„2J”µþf/¨»8V…gF™™¶÷}A¿Çeô€#L”²»ótØ w×m‡Ìu¸Šª‘)¡§öå¦#m æ°Á!ý¾Ó­HÄYd@¬Ýõ»aqœgÞ¤'§‚û{UŒ«ªZ·z°Nßì…¬Ñ@Í¿9«påCá®F嬈pPoꦛaYC@Ìð#2ºÕ³¨Œ»=Ë¹Í >ûþøźuÁ»è˜áûy´kêVƹuéK¶»êO.ÛF5^²÷ %‰È;ĺ4g.öGbT­†)9:EºÛôo™×‹¤0IÂ> ê¶d°Í×L¾¦ÑãX t´,{¿`»�ˆ<™5Ù–ÂΪG§½¬ |ÀÙ¢s¥þÜ~ÆRˆÝÀMd9Ô†ö „1ì¹¥¯`ÈŸˆÂêÆ»lÎsª>-D…Ý>Ɖ+‹q?O"+# 3{ìÕ×nWšùÒ.Ј؈FnU £…úük<L’Ëýófà´¸€ùðEw¾µÏHWT4 Vñ`ÒÝ`:-pd\³<ü" VæS·±ýu“9`Ö‘¿/º- 6ðKn¹<С?žºá>¹–÷.Eå&™·¬Q@Bä› ú…¯I�Zsè¤Rì¡¸Ç ½äVTi>fA|ÚZÌmֹ̱‹(Št›½m•;[Ïé5—qtB ÈôÇn¿Ø³Äñ:úóÛBI½th_#°&Q¸ÒjÉÄG²°¢§úÌ€ánØžö5/(ŽUæßþoÌ$ßÖŠîçÐ%YPõY�ÊP®±ƒ–¸='£°„ïpLÝ|/›éᲈlbÛQ:ÅYG&ë<ÚøÊY美ÌSI™4T!ëÔ`ò‡<È{ݾò ¹㓲¢Õ¿Ü‚´ë#¸Î_—dú€9£žgÒôÿñÉýa‘ãæ; îÕà“‹½Ó˜€¬ÖE.õu÷KQÈ›}Eùª È@·›ïü7W:ði‚yíàÓ;ŠÉ(ÝÐ_3gŠ5éu{íۯʨòüHY¾f^ò ûݺyÑ8ìd8k‰L·ôÓgß2[Q§„�%´H`ö¹SIá }Ò3âW¯¸NÖöáU8qÂÅŒvÇ—U¹ö%B`Å'Ä÷õEt°$>86¶Ý|B\\À@=—ël¾zf:F+¸DîMISÝ{G9»ü}ê퇂ÙW…óiò„Ðî¢wñüMvõ`¾Þï4„©¯ôˆš¡¥Ä S–ZÒ–çþ±�4×WÍ€";Þ(ÍsìÛ2ˆk½Ï Ç4Ól4^ÝaÇäÿ^;zÇ Je²Sça26l»Š‚’¡²7‰·NŒãò<ëᦘŽRWæ pÄè‹N²ßÊ@C…Ð÷T¯]®ý¶»òv˜é4÷-�vò÷{—þ)˜»ÝÖP;ÝzRŒóž»° P5æ ÓáI†m³_‘±‰YŽœ²ßYUHÚ lRè%ÙYƬlFßj”óâÄòÎép%ìдô«bëÍ¿Þ.f!k>lÆjß׊ÜË9ëÇ×9ëb™ÛÆCïÈܸàCú—3’ äƒ+h¦mÖEF¬r˜è´wâq‘ § ŒW 7³Âm¬¢´]îi…æ¥%'ËÄa³�ÿÑhgíxÅjt£Rq°PyËjoi1Þ*ÉùZarxž#Ï7•µ0YÈŽï¢ï ¥-5+V ðzÛ³ö¡ Õฬ›å ÉšÕîüÕže¾`Dñªâ^ 4“(ñ!ª6x úú$l•áÊÈ< –‰–¼ecjm 4žkZ,›=ºZ@½£a© V;Þ�Ø×*ßøÓÓÅÌXã±Îé>Ï;Ï-ÕôtžÈ°:Ü]9:¨»|˜Öåú;ö,w…›GÎ; ãÎðnª·ÛƒàÕ(B,àãs‡~èš—Ñ‚iè‘.xšÛÑŠ<YƒD°†M_¦ŸÉ¾–^£ÀÂÙ4´7ÏV½ÇiÔ|Î6sŸ_¹þq¶Â“P® �ê秵ON£`Î HÌ2Kç¥j2®œ&¹Ô‚JÔšÂd‡ Ä“SùH"ÿ‹ü»H,HÄw`T‘]µž‘*C6ÌÈ£bÙUž±ÍÈa`QÆîøÄ™ÁìêêlÇ9@Ú!}¥4ÉʹՙwÄeLRm“ üœ= ¼¹LéX˜«®+(öÇÒÙ¢¹ùuÄU™×D§¨8œ(±H­]':ÒWUZ p¥T7]Ó\LŠõWꬬRãMÛÌ€ÕÛ®FYiÏ©ÎVgæU¡¾7Í%‡¹¥_qB㪤U*+ô'P‰°§Ÿ…ñ`ES>ÎdŠü_sX‘)ïÌUWv3RF·½—<Š´™§Ýu< þgǘ~÷=@«¾ubÜEfˆ5Fzü0ïòm¬uE§Æ1Ý´9(Ü4ÃfßÓ´ÏóÌýD°ÇÉ÷Cø‚xÞ4µžÛT£/lºÉ DA¹¬_ŒµZI¤`ždŒ· _æÑ-ÙŸ·´ÄƒéŒéz�aYÚvjŒá}ã‰1”ÆÏ÷ò+ ÊîÓ}`$½E7�–%3ËØÿâ•ëE¾­éO·d¨(ŽBo‚ ¸Àœá»3)ê­•¿]§qùŠÜM‡³­@ØÝñÊc î_€.3ïß ‡óÁúÙw ÞeŒ\æipÒ¹ÛÌIÄŸVM<âô¯=2yE a:g‹®ÐOljú›&ÁýŸÂ¤wE&£p8P1aõÚ`ÚŽÝKùë‰O§aX»«¯=żÈ<† åvµÇ/žVýw“›³^€èå©`^c6¹›“±µÅAùFgÙn§f;fEíÅ ëiã&‰pûDâ{£ ŠIû6%¨8THMÎ1š‹¶šÞÈ»z¶S|­ÚˆÝ%–˜‚ìÖCcsýbÄ=ÐCøÒR¨R'€”=Ð8ÓG2!ëíl[¯ HGžš¤p7û,Hç³Ç:éPØ­à)›q꽕ӭ‘Çð°zLBßä ‘öBÉKéRG,¨vRy‡{ Þ§ ãÔóKä÷%¦¤ú·›lcÙ <ëŽ?5pMŒÈd×ÃX,»H�öU» ñºa&Î9Ï–!«uOoú©ü §n0ÑÃGÆUf4 «Æê:nŽÑ\?*ÇåJýŽ±‹->âÔÆ<—y0›>=SP¤wH'íÛ¿ Ðîh‰¹©—ög LX€_D**Å÷²YûoÌ)K7Þ4ÕL‰vø9™ccé\Þ–ýxÄÑ]SEÌ/®ß¤%{>I:Z¸œÍÞ¼FpÍóDQh7Ï=µ{}âp[DFw1´±kPÏT†›¯ŒqƒÈ²;_~�üÃJu>®‚þ ýiC&¬ÛÏ‹‚p2 à×ô?Ó·OR—™£6I‘Ji¥u-®Ü(˜÷®ÅÉåp: ×ãî¦QQ9…U^NGâ'+Å’ Xœƒ­eŽG�=fŽe>÷·§Ž|/³�îš�>Ö)ù¢XqóÐ6Vâ̸ʩÎZèÐ0fñÄ,A¤Ì¢.ý‚³\¬³8cqš2}¬¬O^Ôë¯& Êçｚgð˜>¶2YLYñwÝü©†=E†Dë8¦gŽj,+OÅR¤•Í|ÙRœ´ê*±ˆÂ4"6hPkUÞÆ^<nÓ:he®þÙGÀ|Þ}˜ŸwJR¤›Ç»kl½+[T‰íupÀGæžQoUù1à¥Õ…·5Ùºd(…b_9gÏû)§Ú@“Æʨ*ûŠÄ}7êùôÜe,ÏC_·"Ž„1côiÖ°`Žg§õíì×2ÅRcw%žQ'ä?q¢jŽ×{‡Çs§¨<6"͉ñmÆŠê1·P°Nº Ž W Üî„ÈkÜJ@åzÏj—y®`¤É´åû®gXø™}÷³‡‰/¬H%ý<Au²1*EêÝÌž²ÒñÌó*: ¾‡niDV·1ÌÍjLQ±mÍÁÈ“#'a r¿A=ÒúÓµñ÷jEY±b^B!Aslq, ÖÅ ‘­bfÇÇY¨JÓ!ûZÁÅníŒ_yªÜ”ZìÄxœ&¼ë·ã•Š##ÏÕwy¤Íâª_Eü\¹Øâ)­wõ¥øJcyaä˨À+‚¢U;•÷õ•sY˜WÈ¥ý]Ug=O+Ö—O¶ZГƒ~­ÖÖ:À™Žýøxê ·+àñ“ð@øRÍuÌSÉÝ3át¹i"P9vý[&àËŒ;¥ÊPÏÓ¼®ºÄŸ‘³¼åþ”ÕpÕ9œÌ€@ξ;v=սǓٺ7ß?²§.ü€É  ®èy§âyš·Wbï¥ßð¶§ÅJçæÅ×™á5°ƒr¨¤«›Á0gßí»[M`¸²KŠ„‰uþB®­gÝ^-”"‹`. s ˆo¼(q£ò¥¢=Žò•hÅXú¼ßy¶¦8å úb%þF~¤/éC£P…§]ÎĈȾ;sM˜KonS'GísÓ4ícx9~dÖð5*˜öÂ{É,!¤õüEK7®\ðäòóÝ?ѯ,ýN2TßÀ3Ç&s‚FvÉÇV"䃘S¾è&~d4›Z2IboP¼ï;_0šÙ+ÆÊs“årå âùMK ש“‰fžÚ-,Í3&Ì1Ä@öÃT3¦AµRýïfªU8œ°•¹/ é@8Ïì¦c�VM (™ ·ŽÎw]LÒ•(a Ì,nN­ ãª_‡Í2N‡Ú.WŽ=ÿ6Aí`¶0~/B ¤ßѹ«áÓ“ò5„=+Ü÷�${aÁ·Ãq¶|.Wr~î H†Òኹ ŸŸ<³NʹfaªøúšYº’ …õAé�Ä)åŒÐ&­wBä¡égÂñc½/ŒÀÝë?|‚.⃋Â\á®ÎÍãXS>Yãɇ֭ Ó ¥1Ïø¿0(/{ç–FuªGîw`™{W_Ð~‰ç Ë�šSø\«’ëcÑC;º¯áÍæ.ŒÜÞ©çÒÙ?ÉŒìˆZ­ü½|­n¿­FYÁgñ‹Ðþý¬§ò™pŽ*uÐ4Ø{ž¤ þVˆ‚îÝãý¬âI,y/7rzè{Ä‹·Äθ¤kZg7ŠÓaÞ³ð‘mºä@ª`*Š ®·^šuÛµ‡LKàºúú´Ý”0Š„Õ¶ñTŠa6xðtŠ_ª¶J¦œGôjo„AANõ8uÔ|ˆ×ôp?±ô£iÁ…‹ÖN§n˜h-Üã»2‚_Z 3¡Â³íX%áæÛ5§+‰KùXؘâLS9-€PV|kôM‚Ñ_ ôÕÛ™ÃäæÄìgˆºž ð—Ï ÆaI˜{’c¤ó¬ÏWzø¦±…U‰c ©`牂[º¼î>‡ž(= ŽAú%êÔFõ°YgÕI B‹ÌYß’'}“,ô×Ü·GJÜÏ;o²;æ-Îäa õ‹Y²uïÒœñʯç %;Í쉾Pñ5õ�MŠÌµi=?õûÈ‹p=Ýi»"ÈÚE{ÍÈJέ(úAUÚ‹Ž" 7,WíI9HØÑQ|Š·J6[Ò*¿xÉÕvE×JšU(WV Ö“±Î‹›0»oÚ¤vޯё¢ÒÎv1æ<÷5ä_•»³›Û¿{¼Š~°ÎÌ ŒÜËpÌI½\Yà ÐׯpÈâ—U7[ÊÝ’ýÕ[(6ñ‘~7ÀhÀ¾¢•ª²»Ô(”ïÿÔ¯í5 mŠ*(Γ‡ÄrÓt¾hY>µ,b¿Â§ q„Éäûìü¯NgH•ª3±œoë—GÏÌc†ÄQéûSã‰+"^YùX¡øWÏÅQó,ó=ecÔÁe ‹G§2­~gÂ><]X}ƒ©þo\¬haÀ‹/î‡T£ª‹>ã¶Çé »T™ñ!»Oà{ämh¼¡òL ‡ý™T›í3¡Dwm4}³¯4³~TÐ;¤À6Ñ[6'Ï•Þp´Z4Ocb¡€l@ònd½= žyÁ€/œµK‰+øHF¯æ<Ñ;BÆqœŽ3ö®<^ï×7?t>Œ²ê7ûœÞ´Öm–acù¬p|Áå0ÑY¬/+Bi—«ô+ º˜‹ óy##oP8h˜ÔWëë"¶ßYî$Ò‚W^‰˜É§öõ/¢Ï®\†2â‡kOÜä{™+‘ÁàRl3 ÚE²¿–is#¡¦_XÛŽ“×ýºÓ<å+§Ú¢‰àt„ªìƶ…™yk=¬.Wä"oLcg¥(ùÁË<Š"qÊ\)óÝê"òÎ*sqv¡ËC‹Ûm.…9Ò)ÉÛøÞw÷‘i²’ðÏY¾4lw¦]& ÿ%‹‹û“ t×ú¥OÕê˜+3Ô÷eà¨ò Ø ; Ñà^ä$.ügÂ1Ñ$H_ØÌ‘Çå“ç¿ÙBçóÓVn¡ßRJ}´û"J‡íöË«§°«ã\‚ãvkTÌYšªüød5•Ö‡MS€¯¶Áüq#Oì'2Ö"ó’ol·›@{µ‡ÿ:|ÞD¿IßØèr™+³€¤ƒJîß°‹¹Õ‹0*Ü]¢Íz}<¶‹³Ý8®²kdO9Xѽ{óóË ‹P®®;þž¬^zÛ±v`…Ê0è6,UÓï,T2滄ó^ï8Šàõ;¬ç_•Fåª$J±ó ù½õH ÷$æZ°ÊöÁ¨Ÿ^øs=?UâàܬϪ1q£eˆÈu9¹ãˆ<³÷oEdòxå­RóÅ íJ³l�¢Ô¢Aë͆¦œl*�&Úëïüµ£0úfséVË#VmQÿÈQû–+6.–jUØÂ_f¨¥@¦DJÁ­ b»X°ÿBWg'ot…šÀuÛMn0ð1„êâþ­—;?Q>¬…ËÑMšJVcr’TP3ܺr?rxá€F¹ô7c,ðäe’’³JvøëÖÌQ˜ zkcð¯<~O€R7pe¬–«‡³S&ZÜÚ2>Š>3ò…~”J#ëU<׿uaÅ“¾UQJ«ØªL%¨"yÚk)aÇö‘^F°õûhäãù8ÓBµý´ ‘ºu.ü�Ë“ ŽÂ¬µ™\Â}“eÏIŠ@ÿÚ7ö°RÒ„ð<\¼¶ºÚšuêįï]}¿ÎJs¶WFÊŠç‹ÑÎ΢S{ÊpÌc;8¦×ýÕˆ1ó]– 18,‚j»ø1Á¦4ÔÚÃ"§8Ïð‘6ç?j(-~+re©9fP«v‘’ç„)Âi»™¸üL°ÈÁ¶d¾wKGÆâ[Þ°Ã#”ö·öFYzÄJ-— pËíZpRÖÚÕx0£-Rc2Õ´@ÉE¬ø4ñP˜7fÉÝlª½>Ãǡס´MßDBájež'w™{êÒ2Ÿg<‡¶÷fjË„SiÏÖ}Ú_½i´FÎ¥;d¸÷U}ªqžs%k[O߈vä+=E j*Þß=º#[tYî­¬i�Nç·ñ‹§Vìñ‡ØïûÂÒ†¶³bÀíÍ›2auøoßý׸ÛÞùÉ!=ÊiK{ܧ¬ät|Ùôž(ól|F®£¦Þ=ôqL"Sa„Fpu΃¢Õe–³CBOe‹4†  î_)³ä‹ ÙD{'Ý*È?–óËDmXTÁ¯=¿†&´œD0ñ¾6bæϤa²§³ø}o-’êÛT°þÒž|åÚ7¸á©€ÞUPÔ[ªG•ó´uiNZ|q.2oiÛ܃vE³µ ú¾n[)ÀY.Q ;ç–ÿÔz¨†å€BFæõ,mñbs1Uy ‘3Œ‘B|mÑZ8“ì°Â¼9r¯_@ËOüµÒ•WnHÛ, ’Kçœð*‰Výš†åï/ ÏÇЛU²Ã{úþtñ’‰ºßQ=à¡ÔBÜ�ø¿äˆÔ4U´¤ÜWó¶õðõR[™Ý†½º7ï_‹»øãŒ,NåeÆÁ¦Ÿ³ ™z“®#yã*Ì®ŽËÔÀÊ–m"ýD&¦B.b²»I $eÏE…÷=Õ“3_úþã kW‡ÿð°vÖ8;gùE1¸ÞS÷Øs–¯æ¢‘Ð÷³e}„V,rrk»é§²8¶å+e†ª±œ>…ò1S‚,{Ôb“éfÉîZ0ƒÆ¹¿BÓ Äç2¹ žÏåf?f Õ¿ÖÌQ_õe ã.¸ƒ}¾C÷Ììx¦ÄFn÷eÖÊ–BmY&º"cŒA(‹_¾Ïú•ò\øØY™8K7 ÝÒÞïOûû׬k“µ3t."“ÉÉ;j˜¡¡�¨n˜ötÖabÿHf2ñi‚s&Ò ÞÕf—±Ó·-Š­(ïNrU¯ë[Y¢õ<\ú=ÓΓ&¥½%›Îb¶þ ǧäKW®‰+645’c9Hœõ4Y Ú×Ô¢T3(ÍÉÖ¤”´|.Þô™’®qð”Àuÿê¾Kì‰/GCG‡ñþÓõÛù´^oè»'™£C1Úeèbèî-9Üë!`³­«$$w*>óƒ#4pSòŸiáÿ9œyÍ:û:ŠWåÞYš–#ü ÔéìS¾·+³ãâM Rè ±ƒ ýà M3 S@¢<jŸÅþâ¬8Ô]ê¬Ëú•´RêÝCÅÆÇúqß\2jq›;S¥bZÓÿÑjÔ› ÏœÇJÏÂ*EàÄd¸\)@åçðð›ì¡žÿt$œG™—¬Ñý<~¤IP¼/¾j@‡a§7õ$¢QÆ9@R…gV}®IÎm¨ˆ_�´úA'~=P}­%lËؘS~x `•í‡1|oßm=Œ>¥PGÓ%y´ý'Ê‹SD¯#ìcz½ç9Òíûľm§±5»œŽGùEuŠâ(óR]ÐWQ–…æºè.²;„Ç9ð_©bopŸ·ú¹?ŒM’2¨~«Hšä_t4Oc¶Ö^Ôü³ý©“¼5T²åtC™ofy¸s}1ª:ªf"ük?€o8»¡=œèX5sdó½/ÊR®f—´4ú:¦4Û®k>çY Çþ6äwŠS1«…ËŽß8{)‹¤§³V…]+>}ÎÅë–ƒSmq ¥ÐÿCùC‡|^Ä%¸,h„õ0ÅçΨgË@Qô]U.ó¬å2™ó¢ù¾ÑïaV”ò=Ax‡eÎÈø›[3Úì+ß%’ÊP‹‚¢U‰®ÎŒêâÁâ->óå}èÁw¿;™ß½r×Ép^”¹~èÍÝíûQhp½a/d™ïÞ‚FÙ–r­UHUy�„é|ÄÙød.%ñ*(§6õOnca3ëUIùªlU”†kå^СòË¢£Vìe*)f3е Æ £ÿb‡÷<†¾³RÄA艷 ­=—Ó\þÈÉG›làÅ‚÷óêúç°Û¤ôóÊp ³_ZàŽè¯l·fPׄç²úÂm¬Ó#P©r”Æ@k–5eá#îkT¹Žø« ìÛöò3ìrª°­ñˆt¯Æž–ÉÝfý#SØ2µ +hàâU”/|:¬ã¬c®„¢‘Mã”mKÕ<”¤ UûN{£Ì• #Ä“RKdæÛJ¦J¾¦›”'™ûH,§ù®ÞŽ2“n8ºLïÍŸóàŽ›¦å»Ö 9û-¾‰$ *\¿ y+Sg:.u¤§Þãr3]ðä­ã É´—oœBÒr--’‰ZÍ´xóc1?^¸ˆ2„ŸHÕľlu(z§,ÝlÀéÓ ‡Ížâlx¥AÝ0þ ¾=Ѻp+ƒå3ÊN× L1öõéTÓGWB›EŒßEŽG‘RS“n6 %ÛÞ4¿˜m&¸T£úÕ=å‡>*ÎJ³0¼¤ Äà[+`Ÿñmú8ôíÝäóá°pÝrƉ&ºÓeLø¬FõAü;mFõ–@‰ÎäÙ–§ûÃìÊ~:*éÿB³„—м9Ö§e©¿†æÛ¨yÍžñ[‘mßÝP“p…Áå¶x°¾Œ§È¬2kŸ!þw«ÕGÇ~†ŸÇ¶Y˜ Ã+Ķ§HŸÄ1O1“mQ{»Ût(•€ö<%5˜ç±¸RÏ»,ez˜”–æ–°1Ô‡¤EøÌ{üПõÎä >áaÿïÿÌoýuL{;ö«ãv耊bfBUZ÷gSGf?––ŸÀ »£¸2 @± {ûèÐÏ}úÇ®À ¼³vïº÷ër_´(j¬$ežhËX~€ °rZ ÍÕãÁX5tÈ" Mí%½í(.oùæ¿*O‘* ®ÐbF)mcY Šâãðù*³Ûï-“j%´NgÉæåS¶8‹Àzt è¡ð½±ÞÃöbÝŠþãY+¢#*ú(­:§Âͯ[YقĹÜ_¿Üìx+n!¥Pl3k†mLO(VI÷5ÛCs×BÐ)_~[³_á8Ùi}:kͺþŽ¥" åáïԵ㶷(ç&õ\0ÀcqÉ›_¸¯¯´ÚÍ×g5Eö„F jò °Š¹”ÞTÿ|ÌÒÆG_Ób¨¨ó¦×\뙿ó˖ʺ^}~ŠÌ×,¹Hºä’»ƒŽÔË Ä·àci¬â²söœŒâ»½§Bo|”ŒÅ¾2ãÌæšÖ÷öjºÅõy§Üž…uŒ&ý T®”×öHpEÅÍ4ÈCßAn%p$…•Äè5±Óö7í-'º™™7…òk~5œòŒÃ0ÚRöµW;Éä¨,('‚iŸjt§Ln`›D÷ÎÁÆ,0|HÏP±tØ»‚6/I/b_™‰2.ëÏæ‹¡RÄr£»×±bÏS`ŸÛk$û‹5³¨:̵ÁäÔ¢ úë"hDù§»úݶ€æÍ‚þF9Q28Ÿ•ÍÔËLÌÌRÁãåæÅ Cø¸ç÷âÔÓR®ìIt<ü9Õû�æڤϻó0f´fîCâì2²i0îÖíÜL§žÚrΩ”ãÃLJ¶·åÅãTâAÑ=DþªùD[‚¢FÒ(åB$ ùwàÁn)Ö“’€Ç‹¸üëûjÒq¢üYUäøXÆ'oº¶¬ªÅ!doÜÉ%”ðÌDø¢w,œÝŽ/TeiDûšV£i?ÑZG?dö«ÑoœOn\P<ËÊXÂþ™ujÊ0;;έ“Û4£‘y~TåF5«0ž„ Õxe[;mp.礭öTÂ)ë@¿²wO+QC€½ˆþûªÜ×fɃxVæÁÃT;8»ˆ<–: =dॅZàâ% ?ÃÖQÖÀH§ŒC -�còÑWÓEL•Ï7­ú_U}ößôÿˆS‚â,køÅ¿sãN+_@2æ)2ÁçZÿ”ÊÎZ›Ò<žì+EN]ýqÖ-\Xå›8–}ª1¨|÷¨ -ð…è•$>c?„l?!{Ûk5f opKÐÇùר¸¸p\dŒ‡J\(³è|/Q*› ÞCifôÀ·_7×¼^Ÿyè*cÆSióî»i!Eß×Y+ψcïê~%ÎÓ*w¦YÐP¤Iú“žª0<äÓS£Ÿ°ÕPT•õ• Ûpšª ÜKKš#Âa‚·Œc{ʇvWÝ–Æ+ÈY¼2o¥Ï¼ëéûÔª½UÀ]þ« �ô ÀMLx\~åºÄ…ÛÉ`%P"Võ»I•Nû±¿ßö ù€ýçÍ÷L¢ƒ:Aór¬?ºéGô$Ç«ªLçIvÝiïIOœ`dzÿÍV³Ú¢ZžÓ uûwæãíÌÌDžþ0›/"'n‘1+ÆrTø‚U,G ZSo%™h Ò»(ÙN“¾­€b^ØÏíëWT"îK7#ïv7ZîÆ•––Sí‰.«ÝÛ7£ ëP%žÃ%;–Duíé”ØÜÿ ´!w'~ÈΠÞXV¶¿âéô² | ­á·Ã�Uç[0upçg_¡ù±± Ý×±' JëK�ÐY‘ºsÏÊé7/_[Üw—ÍF†)‰ƒÔz9±‘ú^Ãé»#¤šoF¥D!ÝÌÏ“ŒGz_Ÿ.¢•ôò¨$úOVÆþ4Ð¥beÞrÁâà`Ù?Cø8ŘˆktŒ‡Ú‹Ø—Ž{*Žfo/¾^|ÕÒ•“SªvÀÜiÙ{�Yºg§©³cÅ@ùúWS’ÜÁá8¸½âOútšeÒañ�¹ÜÆe¯ÐçW>ÎQá]C—b ³3’¯œ}MÀ)ík°^M…·0Å få „%J½r)ÿ/×µyZçcäŒã¼©é™8ðç %Ùpâ“í^’ƒèaEÁ1¯\0 þTã¼4úJ8¾ Ùe-à¸ÙC±Žþ+Ú&5pÖÑ£*2'ç�Ú—Azºz~òËØ/´,mýO«îùJ3e5b…ÿÜ<¤['‰J-êžÆ#„þþEf[æĄ̂°­~u_QQYùÓaEƒÎÊ“ÞæR]?ÍÓ›ÎhŸž6mR_×WÆ´£íšXg ÆÝþpªƒ ¥ÚóÛ#‚)áÎoyÌ*5Ò#šDƒS"«pÉ@é =†9pZûîÕv¹ Kü9î&O‚x?y&¼˜wPÔ“}dô£€îï Á1<² NŠ5hª¼KÄSgµŠF`l}�@V ­óüw8(O^ZʹF˼Öá`™ˆ-ê¾;÷ãŽáŠà븋 ÝD+tê¹þÞÓV3šyèÃb°ý¹8åó\8ëÁQÞͪo¬õl €·þÅ­¶U··¬ÜyÃx®ÈðÄj¬a‡} ˆ¯ºè3ý6Nî¡èžH ¥E¶2Ó[ }[¿{^ìMhõRŸ¹T½y5k×ï^¥åŠ9ÂÒ‚ðž>{¶\[ܔٚ#χã(f%Vap:4ÐÆ5Ó…µf@˜ù…GX}—q£=f†0¼dÁAú¿Õ”Ëñfï]…"ïÜgÁŠ'#ÀP|TÅhÑzœF3Å>œä¹¯„ZŸö¢Âá“°z„À¼ã nF,µßRžœC™5uóÝe› ÔEi*üÜ8 ‚—^Ì'S—¡@çM¢`—îÚ­Ыo¾¢ŸU…% Dîþ\U¯Øô°!˜3uûW\˜*wF>ëÛÜTº¨Ø¾ümlË"ÓC´x²;QªL £õG•~Bac•ä0T#íΰŠOU³Œø:p”-vÞœy•ÈHݼ8l}œûÎatCÌê¹®hÚQdÐÌNÙ/·¯¥¥XÛ–@}¤ç³ÉQ2Ú—"ü5 4eõrq®Å‡@¡¢ˆ”ÛÙ„õôýUCÄ–"`ÄäTJdgðŒÿÁŽŠ5¤ÖË[}¦÷÷“/PÙ1°‚€míâOoí“<¤œB;;Š^/V³¾ÿ¡‡Êð»MѶV»œ*ZÓ‰6uÇÀ d,ûëD±¶Ýúo¾çIJVe¾±|æt€üö¸~èÈòtPi@ë ‘Ê]Ýiê—eæë˜gAÒû ¢fG^WÒ¶IHüÔ%eZT@VBkµ_œÙŸ¸5A±{¼°¬Ð-_AqæáTèBÍ<Ÿ§ˆö=”âÔýqî5«×·’ÛÊo‰Ô6wÚCõ³Q5H:ЃzÚ•wðÜ8ÃácJ3îgÚe¶ï¸ï€]ÏtœbÿñqöÜðÀ©PÝc×S,ß+ßÿ­Àþy+ #Ss_kô‹,c<·úòµ{…Š‘‰øsŠról)d„B:Åv1kþåh”åþf¢3áp¢Ól¶5fbƶMyy8ͬzûê•àf+L0ÞUç}@+üÏ®-Ý÷\…Ä[Û%ƒŽjŒ¼k݈8¸(2¶_]«ì|Í»|˜9zµ:ª\áY•¼äœwcKG£Iq©Ðs‚0ÞõåÄA9Wa߈Â:瀔Ìsu±ðM#Ð}œ©ìÃ6ƒNü>ˆÎ/×ôhN «O§ ÉRq°àTK @½ ÷³/=VC«BdFKæcI‚¬Þ{ü�PÑéü6ê€VeZå]¾&Rš&^¡Ãöa‡ô´¶2Ì•£©hÛúÐåÈÖL°¾PR+O À¦v--üË´¡Klœ%ÂÃa áW£—M#ݲv÷ß=d%B #Ã[1äøx^¸ç ¯(Š¢—°r)Ï)‚¨þc>1xÜZ—KÉ¡÷5…A«+dÆ ó|TŒØ™t1|„ZÏ…¡C;ï¬z'7,5ÈRß«¶"ÎÂfèÂÅÛÉt»}Õˆ«¨¢ÅÐ…1Ë Ìyîî “Öæ¹ ŠÉr`j&Aö¶~ ïE_Ì…(—*L¨ð:°M}*ã06Ç0(Yß!Rñì -wg¾ƒŒ•jEº7P>ÁR÷ÔUãÈ3üäªÙÙµ³2hOÜÉm½ç;_”MVÔ[7…–·¦3FKì6cpHoLÒضX» o.z>®BËÕ¶.!%.N°â̼­­ÛÃ<T,» öÍyüÀÔJ¦<p«˜’ ~×}^ÑŽ|?›å  ÷­dµ÷jŽ¢Ü£„'" KŸ¶ÓÓܨîWGyŽ½Ôö¤xyq‡}aDUΩêÆ™92dà£ï³2ôÝ[ÀŒ»TAÕ(ú_2†Þp6}}r­¿ïÚ,™'»›1¯ 2ë–’Õ2Ž‹z#*Uçöõ>c×Þ‰Ø@ZÊa7X ¨?'PÂiä“($ËTJÈH›§‚S+LcvNcÕ¬K¹éÈÛX³º;Lµ<‚-íš½€w¼ËçFöž¼À‡ŽJò¢±”„L¶þɪúݥʿHœ/Õ{DN9)öÒ²x¥ÈØšv›PÓ y©' ’àáÏU6g¯cDÚàÊA¦¿äj@á—C„Â}M-&´;ñp̹ÌçßµoDGSš|ykó‹^ùøq\øBPlð@+ëla|aà­1#H㫽à±V$µèoÒ3sw–Ñ‹Ô4ñÂÌÉŸºº[ãÛX}:­›ObN·rñä6=Ô)¦Ñ¿zÖU«!ߺBùË"ú°Hµyâ«?œ†çYé±^¡õ‚š´î îfÈýÙ Ã7|yBI<A܉Hdܲó»)^°çó®ždÃ9õhÙÝ—r«2ŸJ ¯—ŠNÿwevÇŒ‡àï"5:… Š­w.¾€I³Ô÷øIúD7"ùl]w¡çoÖÇyh¯,g}@îNwž�ò^ëï¼Z4MÉq¢B)zW¢Z‰/7Žµ¡ˆ‘öÑ3«z8B‰s£Ú¦ñrìY¡O%Eª’ç¨ÓÕpLŒR·»¸òˆ¼=_ˆ9ÄáûÞ“q?vVpÞ,»Ÿ³¨Jñç)\v}I_­ÈÕ4b«Mïn1²£òJOa¾Œý½’:­V}T“53å¨å þL›Ý×SÏe˜(aï$1Rgêµ”¼ùyûJbnT¾$ÍEÇ{´€Ð¦R̈zÃxí=ÿ‘î-Lógw¦¿áýä=–Sݵt}®)¯\>èùž&4T5ËžÑNN©M3ÓÛ×›)@šùŠú©Èg~nM¬e  Í‡ Jx7aÈÙ¿¬Ÿ®`ñLü†ý›S\,Ý8ß± ù7–!Î)O%M‹}64å‡V£³k¤¤û£cŒ•›Ë?3ð±zµ Ü6±Ó‚Ú¸J!/¶tA{XSØU}tŠ[ý˜ÔĉcÑÐrÑ;LÖ|ÑÙú_¼ Êg+àĈ2ÍIP6JV>‚>=hfÓô Fµÿ¼ÅZÖ0ð@£H²iKÜ÷¯¾rIÊtR;dAõÞ»¿hæúö6®Þãù<cü”…Ï‚ƒ?›ÔØÊ9a8ý™‡Naÿ–Z扺òÈ´½R}´í×›Kµ xçýi:ä}0ëM•ù(+�†Hñv®BïÈý¿Q«NÒÄE'è‘MšÑtuÖ_‡M=Õ;ó 9G)rOå{êMîw±Q%”Kmr˜ 6˜çíÙ Ãà‚üÈNÃZ˜äFtaù„جÜJÌm¬kÒ¼VÄ{«põ¾¹çò–„~åA‡R?ÓïˆmΞ‰åØJV|ëéøm.f©qåêñ#B‡äÓ:*¢gÇ}þ`»~ß]·G´nsà“éŒë=Ç_¹¡ÒäÎÜvP§Ì ´È‰YM4$è-®iºŒ“60é†È°å®£a䕪L5<œ€súÔ¥Y¾cÛ5²¬!j#Ò»>·ëwgIè)ôÐ3k:ŠV;ÞVÅÀƒK@‡žÿZÓ‰Á’a á–ôn¿7Ô'H»î›R,5ª—I“$ª†}w8Ê]GhÞKîí¬NúÉÜŠù‚gweŒÓUך·u)ÝE,=Ô®ûú-LKõ©FHσÖd^/ŽÁjF±©Ùµä‹™iÜo¨ïºöSK]\ÆÍ>˜(úÒüÀðèóݱ¡‘ µOoÉ+§¦b¶ÂX™mL±ø¬½œñ¯ì_Ÿ™~ñA¨æu3á^Ý„™oËŒsGÙÞ:±"ÅèÝTÃÊ Wó ô™êNV¥UlOcZªì™¸Ý{GÎŒú<Qˆ4ª«ÛiÜG‘_ý¶ Ž„Ô«94è�NOŠJ‚û͉%Z.ºqµÙé]­ÊRëre jò`˜Š ü³sí‘÷ñºØ–”o¶ãðÜÎÎܱÃ#‹ ô‚EÛôâf×ßÉ°ô„+¡±EQŽŸ$ å-TšóÕÁ~T+CÜT q›“ãÈOã¥þ—†¸eè[ª�µßòJ¥R-})$6çV’ÁW8¾•j- :€åÛÚmú¬O*[®ÜÕízKã5!¬@d§H²Û»-`%J_èsÊÇâ’ðv8ËüŽ?$±we¶³¥îìf&dfÿE¹æ XK?XÛV?*=çhÜ”½K‚IJ€—šJÚo8Ô€?^i“/6r¢ªpÉIeBS\ßÍ"LDhLQù_ÞãÇèX‚r@3ðŸnùoÛ­é†\'«±Á©Õw_¡ñàŸ1”’æÞ¬F›¾xC%nf$>ôÐM‘Ú_pÕ’Þêëc5×(ÉWî,”)ð�Û+‘§°¶nLÍdBHy!±ßdB‘Ÿ¢s§uè’<ûÖ¤ÛÁˆ¨ 2yò®åw>QpõúÞ,]¼Y0¶{Ÿ<X @–Ê$À¾1ž_Þ%Õf'ÄbÅ gj º™ A †äká?"®ÔGWµ4ìBkºF‡¢VÈ#6re‡–ûÙð]olª7ÆVľ¶ÐÔÏv~ÖkÉÎó7ÎXK'˜å9þá+TD¬Ç’Œ¹í² Ylï¶\¯CÏžépº›PÓ^3àÂ5™vU¾åéÓšÂ$Ê•D.if#g(�[¿ú§deŒºß´aò“ì­¢5¸r#¦®=Ü—èò$FC0kªÒ¤§ªø*‘(w~! ñéx8®‹Áï;‰Y¸âNRBB±ð·2ÔËÌOX±´;)Ƀä$ ãÙ'§Œ*¡Ü²®s #`ÝV � #KX½2žp¿2eÛ®‡Vd­ª‰ª_Àõºœ÷/=\¢Ã˜IJ|:m‘lνš¢Æ6“öô¶æ·}ý *ðÛýb.>Cð.ß[–PIYÕ¦«óÌ;ßNlÊ[Ià”~ÍùÄzI3š~ þ ‡Î£{ƒÿÁ–ÿøƒGáúØ ±ñ)©·d,K‰ÉkÖ*·ó‰°[¶Rѵé”B¦EOš}}1æÛÜüôþÖíú =ÐÍ4v3¥¶‡þ0î‚ÍåØL𠤶îÜ+ZŽúŠu’s uo‹àÆ(¨ó˜l˜s|€à×Ôô÷Ð-ºÜiÝ­úÀ1{íµ°‰ïíýÀ°»¯ÊŒ–²? ÙP›»7Ñ�µ4ASø.BºÄI_×ð¡(húsqÁ¨‹Üf´+éQ}íÑS ªs¸À©³[Yâ=7°ó Ìþ¾ŽTò¤Ýâùã5TU–z:RÆz¸/ǨRO.q‘î‰æW­8L–ïcÕFõçy]îË"׌t5Å<ÈêNËѾ_t³¦ú°³ �f;mêKoh Cë.<)ij§€ïÒã˜÷Þ7ÛãjàKŸÈ^L{z¸mý¶¹²b=¥w÷~Dgë_àw‰®[f¹RfŽ²Îçù©’[D…Âͺgt¦þx¢ÛÎ*I ¯¾çãæCT‹6ÂÆ·¸ ¸ô[hŒo(Í°; ç¦^àCk4è#Ä(­Ò~Å¾æ ·6öS©jf0í˜dv^<Þv½œ—Î Oý,f¤=ÝÞtÒ‘#dwêËÇŒf‚"êVÆ÷üÓ¸ò=®á*�U¢d89ÝÌœÛÂáRß·rüFŸÈÆhQƒ£ ´ÐãÌìoˆ–kÚì üb%röúw8z]‹@v+dÉ’òQÉ [s^ q…'Ä9L°qš]‡E­PÐÚýú!Ú©LŠ4shÒˆý‘ÃN‡Ø>ï÷v¯ù#Gÿ‰UÀQô™i¡Ó h”O+ùhÙ:Vè´ŒEqö¼©€ŒÃÜ™¤…¬)Bõ6˜Ë{Ý+¶vÄñJ©­ØÒ@ Ë GÆÐ, ò€�ýëÐÎŽýû]F™éDQ<PQ½Ã)yPìQQ0XøÐ_¤'l˜}ãïÞBw~ ™øXÄÏ0Üks ˆ³FÖî¼6‚KˆÂ rV;° ðÍØP>/€ËÞ#b_Ð D·t,5•‡¯ªÄþ#‘;Ó¢šj¯šjÎôy¯FKZ‹Ì‹Pû¾¼~mOè›>d³/ƒrQ^6¸ãОµ|ûï[¤°V*-Ç“µÍŒ'‰â0½ú$7µý2圕']wÃIØ!o‘IÊWUe>€£àG$ùK ÝC‹q�ýãBÏaûÏ[¬Óã 3‘]7X •—žPâ©|‡ †:â×f­¦(Œ³‚ìˆiý9ÃÓ/Ö§©'É"�Ô6‚jdí~5š?‘ŽZõ(oaSuÎ$§”¶ÜQæÕœÃumÿ#­ÈÜs]ˆÕ˜9ücEqYöÚ´*‹Ëf¥"ž{3gI™9Ïg*=)íà“kèÞm\ÖiŒ;OÇùF®}™ŒxÆýPšW+°"&YZ•ˆá>³’–œ¶»áY¥k•ļ‰E Ë ¶ôl>À¸w³£ôo1Cº ëq8×— `¼/Îû4hèA—[5ÔÈbOr¥D›ØhÉž;¯¹väáºîK�­ƒbYØP'N(~~å}0F¼¦ed¦fttF½Nû˜ê*÷ÝÒ]ÿyK¿5¢Ñrh<oÅ¿P /ÒÐ3w« ?Sj·×2 Ù€9Ú ÛŸ ôå+²‹Ì@°J#m}ä›´L6ÀŽ xþší)„ʹÃi^«Ö*Ùbcâ– ¿†Î·~€©øɃèXÖ«ýÔ¯‘îâp5BB ½‰FK™ŠòïÚNæýÙh ü×Px~%Rk6$I-$+)¹<xþw8Î<Ú݃¶£(OŸÖB¢2i/œÊEÐüxµã¶£ÿÕiŸ:EH¡ , ©:ÝÇ7¸ÍPo¡H}¸Fwf¾'4kïØ>:é[e]ƒoÀ*.Öÿž—WŽáÉ *ž#&¿kÏüÂåUÄà÷�¾|Ë_Œní¥ù½S™Þ„ç¡p.·Ðš—:ß^\mõ†Îrç8Ùq¿À~V‰ÇkÆFUqãªÓÀ:ÚÕ¦m_Hï‘~‹šºiˆÜRëîpTÅÅuÃÂÕµߨúe�lâžéN”jÁ[ÖÑe=‡Û®ò”YX¼vž)ÐZ­ùÈ42~[’ ¼^ÔUø°Î2õö{³Ým¶Œ? a#óÉ3I5ÐW…FÖíï´‘IÐ×uÛ(/|ê sw‹ ÜÌ"‰+öÓ°KÄ܈7Dªé_ð¨Ó2ó•f«`f]§º¥Ø\0BsÙýêiy³Ý»úŠg°@^ ë,(»Î«¼ð<ÞjŠ#×á­=èMãüDÖ>m‘Då¥ Um ?b‹z¡`l9ÜåÍøväÖ@Ÿ¤Ø+B¥Òžšœ¸,“»@œS=Þå·4ºÑ¹m:½{ôr:Uô[Z×ÏÌüšVQŽGœ¦1„¡!©Êü·#åž5… ôík­úòÐtu°£ÞŸ=Y3mªß{û‡TL•PQŒ=>6$EÏZ“ÀzÆ�hVÂ`Y¨*-ý5 :‚Ç{¿ò›ªÄ8G"#@gÕ@ç`²Ø1mÂÉë2{Þtçi#PXž½+ñÈ3¯48~ŸÙg£óq( Âã°³ÊÍxa• ã¸~ñ½~„ôIõÞ”Éé];ä8ŸM<6 ŸÔ›ýÁHÒÒ¿õ³Üÿ÷¯ !çµÃ«<) l…Ø0íu€@õz#å‡WjnÇYéH8¦˜YñØ}ÉJ”¦ðœ‹4¨Z+Dð¤s©¿òQ÷ ²$*’$ËìÁBIý©Ï)Ù~7É6¤ ߸3}ôÎ-Xú¯RnÛ0ùðÑŽXІ±§ã¥Ö–T`JM dΊ?x¢æå>¼",|Y¯F`õVu©>¢çËŽ .³‡ä-R4yTçÇš»±E課_[A6Ywv<F­.*´Ðtè8IU®ï4%¿X¤"hó‹2 ¨Ÿ=Úþ¼\}#á®>yÓùT[¦›tØ".Ù9’Í }äÔJ,F©aÂoœPQ¹Þò—¯fÛV„ £Žw˜;/¹6øC–Ž‘«R<¬\£JéX"i­ë“ùšÃ•×Ñ`»Z¤IÎØÕV4o­hœÖQ˜WQCãåà¤ô…©jZ&t•›“…ªb€NB·u/KÚ^lÐb¥›íû©gÞL4(è>[+&€FWl+W¶ïýâJAÉJ|óݬ’±hXôÒ’2¨dúè.|Á°ÝµÙª™ã'ó|°Ï–’D ¨œXÛÆs¤V£É^̘S‡ê]ŸþœÙlýY.fĬÞ,÷=ò0ž[t»ÃLaŸ–T V·üyÏœ¥ši†FØ2Ñ2ÈN³Oé!Ù1Œ×ÓÀÎÔxÀèÆÜRÇ£jåKÉ2越}Cë‹>4m‰k¦šq#ºþjTµÖÝ–;î»áMónüQqhm aÂ*”J•¶N%ß^>Ò]U½7ç¬X&ëwžòHW=ë[y+HsûÊ#‡ûgHë\Ó­NÓŠeJ¹ßæmwÁö‚‚òGÞÂj¹òŸ•£”ç/×e™B`®!¦U63Z³ÆÒ“ÿÓȾ‹ÿí»ÿŠŒõ—ÜizݶÉ-}«ßcPûND©—³Ý» óÏÃWÓ_5þaã<U|Ì;ðÔarhëçŒÔ¤(2ÏÊ/Ã"§wÙ_•’ÊV'3Í@ý¦Êº[mYÏI™EÊ%N&] x¾;C-‚aúóz1…Üs½H%ÔtRÜB˜å9PÚl#³ÛðͪÙ;lã3Áí,t=!á»]Ë µq-ËX¡fkÕžð~çIù&È@©·ô &LEE•OUv1íUÞ ”óÿ–ØXµ´n qf¾|n4s§ï\FÈ©©ñrûÁúF4Wf«Ö²"¦nó¡ÖU¨þ•|‚q†üSÑÙDU«cÅÅpC#?÷Þf½+üxïg_�š‘'Õ(Q¿¥]Qõ½5dÑ­‹£x g'<ªï犕@ÍËjÃ} }xS"UiPRYf¯l+–e|xeßÛƒ…1˜¨­!Þzz;è5ôØ7†aÏÔ^9oMPíD.Ô‰ÒeK5ãé‘„§ ê£FíG«r«àf¥¯¢w×/æ¿xM ÃÙG±ŒF¸f¡Ó%�î:¹ïkž¬HTé½ï<Ždf,ÄÙÏ-nvHÅj%ý%¥š]‹3__¥`Ñø}Õm8´îðý‚¨ŽGcc¡Òý.éÏž€Åþ *3&Óï~KÖɉà ]+IWUo ?µ8ÈO‹‰¦²•›2åÀ£€U÷ž8=k.#¿ BcŸÌ—�;H{éÚß±õðð~l8çó5"-áè–8¥¦[}¡5ŸöàÈ8V;Ë/âÞ¤¦Ïòå¬Ê<ÑÊ3Y¶ðGR‚ú|YôåÙú®Ö vìêÙìÎ¥›=\2èPd—(ïôþ¶¸´ÄU#t@ TšéÜ«þƒèJ01Ûìº/|ÓùO79øØÏR»­ Ï™ë[°‹ð¼¤Aún»÷ûvØTÙƒ?×Ó8ó&a%ÆYõb¾© Tc°èÊ?ëU;­2óûwaJÑ» òw;.E:„.{ÊL.WUCdyò£}½hÿóÆ7Ô‚v#k‚„LËzƒ€ iŽ'MSæz»Ø`’û§gtèç5¨- }³Š8$(tFј.¶9Š©€§ ”ÂA=,^ðºkµò:€CÆÇáõªb]B¼ZŒ!& ®…~2;¶¢©¡‹?À"5̲¿‘q²¡1:øGN‹VÁ^Tuès_À Óä%ÍTö‚9ìb!)<½i¶Wì|úzºT‹ ´öÖ¸m¬¯¡6ÓÁ“àx;]¹¹GeÌ<«XÑFØÓ—Âò© üb­¸_ì¡11r 3½�˜,8bæÔÎ8µ¦àça¤ò•§ò¢C}Û¨‹‡PH¤Îk5ÌLãRHë’<¢’—çk "õ×yýzｚ¤‰ƒþ|+ub4š‚ÃW´@Rq£RN¸Y饑+¶Ný³¶Óát3áU,T–ç-#˜¡]TÃ3ÛSLçýÝwàik몥zÐÀYŒ^ãjVýÈ»HCO¥ Ÿ*¦rÍJ)A¡`}ªÌ<öÖ ¶·•Žð éBâ oší¢áÑ_ÿ<…|îá7¸«ò…(£§¿¤î}aå�|& €ÕèY9 ‰Ü‹Lª«?YøÑÎ Sëþ‰øÖ@ß¾u\<´ód,Þh]vµ0Ù­Ôƒâ£ü¤˜dŒ`µìm 3z«šÒ—‡N5f_èv—¥¯f m2 ²“ºÂ,™:8é¨îEÉ;Çã(Lw˜²GÊ7ÚÚV¢{¯­áÝùJö` x·Ý`D!oÂR˜œ1R¶iÃÃIY¸Œb[þŸT/:³û‘„ëÂeF1½¡ >ŸE–VÛ ‚ša¿`nž€bqaTuo~Qè-öJRÊ=‚Úkpþ×:ñŽ2k]( Ñï]ª~<÷–Oü ´ò…è®LÇœ¨²í™–K'ƒRS®ÚrËFôi<>WƒE8ˆ3OÖÁK„Ö!%¾S=9úA¢*¼ò\É#ßh5F˜nöçóaiQï¥äX-I€ð�ë�Ýïà¥\̲4–cï÷΃Qn)¬ò˜ÂÔY‡_×ÇÞ¢Ö­0²Þ¢yD‹rµàTLŸp6j²FîôUÓe¯¥,ýØÝ™‚7C†aîű¶"Ä@'±…gLϺPÜÛ:ÊI))›Ühü©¯”s3ð¥.~’ûîÀgŽB`Ÿi¦ÑÒÜõ9IÁ¹—ÊVÁctqßN_Ÿ«MÚÃ?Ê ¦’By¼ëõ@ý¸öh<ZXâlAñôë[Ç•‡Úq‘ùœç„“½ŠÒ׋ _ûúOßñygìÏ „B$yöôT&˜¨2QÉ}a’€qB,G?5^NcœÐýÖ®Ô3§©{Ev'K\ÿ4f‹a|êò¤$±^CÛóô§ûQQZx’5%¼{Zî“žÒ@ÙË8züßÿy[öôE$¨^k°(I¡‡ºD൞(¯9 S(¨MX솳O­}¸Œ®¸ë_¼«•¢=@¡P«fÝ `;|À‘Šíî1«—óz]ѯñÔòØç¡iù:›ÅpñéÚ £7ĤeóÌã›GIΗ, ¤sªxŠs¯CÀbâ# ‹v¦î²úʇé@3º}™–ÔÇ×P¼(wOj;~¾±‰046ð|÷Å2^7¦¹=GÐ|Nƒe W&-@D“("k¶îÒIr™ºÃ /‘òt¥,g1˜ñ7rïiëä  Ì:$,#Œq)¾YÁ¼»£²È?IRŒiv}ìIÃâiÒzG£WŸæç#ó¿È2ÎS'zÏ“ÍH§is˜!Æ]­_î ç…þá/¸+éÄ�îž&¡ÚÛÞŒÆ_Ý^¬ã|Y‚·:£Ì%IÙÄÒ¼5>ßöà·ëä;›¶Èª¸ýÃïÿÔ3ª.UÝ@ë~R1êsO•“"œÒÒùn{ˆ‘†¶~yÒÑ»?íó j5&ÇÆÚÕôƒD×¼<‡ µ/+;6OJ‘à·—MÂþZf͘žY÷2w©-"‹6€J„É’ar½cT©3Õ¨8Õ.TA”ø'òd¹g?…=™ÐÁ…„áÓrXYæç!4èeÝò{r:l½œäÇì\¯aŒ;@ʾµŒ`h±¨¦ôkìÇËðÆÇüHË9yo¼ªgKpŒ‡F<ÚÙ·ô˜0`úúÀä7½qþ›¼ ­Ùg ­‘àk3d¾\éÙñ½4!üY#[»ÅìÒap¤ØÔÞ”ˆ6Ö¯Ú©_9&]ŽÒ‚ô.­{™94§£MKÇeØkqµ¯/PÖ0ÉùŽOýùÐsXý�¤E4`ÍÐâ´ò§,°Ú=Ñqf-"AÅÇ.þC‘Ž}  d«îÆ'úΕMÿL"§¦<±û­¥9ÜÚ¤ð¶pxM›žŽ›3ܽô´”9I ™^•Òx÷†€ÓU ¶Üê/î †£¥›–bJ¨çP+´@!R£‚ 3KäpEî]~1Ç‹= ýJœšbÚâVš%Ž=äÔØêŠ^÷"fÓ™grÓq ý+ŽÁ²£ÖWÆQ‹ßš—ø ¹íåJùÞjJ>ðTƸúÖ¢…Ò¬¿Nð^ÓÈO ×&c8+<äªfð¼?†ñÒw·àhNcî;Èý�Lű/ÅEÏö41‰ªEJW´M·&¯ÓÝ¢nüknÈY:Á`K—ÓÉÑkÀžp“£ýØRäæ:È^Ñ ûm<÷¾Ì=¬E¤ª´@ìZÛª“4@èü¸­f .ìž»¦¡‹8<S‡¸n¤öàaA(€Øá…Lˆä…¸ÒŸî tdþÙb¬›²½îÕ43ù-„V^uoZ)—jÖ˜ô³*…V[ôˆëW¶lDIFhÿ¢Zs–­¨d°§³#ìX ·f®Ïþ“ô¹[_ú,`zÇÍ/:�󽦊˜nhïðÌI%ì×]­G]. ¬¤ãP*›å»×–CqeÛÏ{`ÁÞO6´¢i“°HŒIh+_úò81çí[AE­ëNÜ"bœ}ÝoyfõóºðÀ¬,µ;\(z…íÕÁQxîŽõä†Ð+ž{~íX²‚X‰:>©Gw “È5ÃlHoÄDüS§t-fí•ÞôS‰^%7´é³À…T¦ƒk]㈦¸ZQŽpàì ä,q@·…œ¦lv5+÷AOûúf°øëï¢ÿ^NÉÐæý9÷léX$lde^ýü 'MT+ªçŸp• .J+¶³2%!e:b’£¿®ûÝq¢-/ÚðKÃÊbnàu‚”\6XW#õ÷¢ ^F¦RÈ¿f˜g™?•è6m–*H¦ãÙõééX«ÂäÞŽÞxY'ÅŠò}‚FGcÍйV¨7Ýä È›q\PÈË=”!f)yfm°à6å©Q}ºR\¢ýkØ&†3Cõ;•¯—«gàÞLWP"õ}¿)̷ܳ ¢w¼l ~|±µÒý¨aX›æÂ-pQ¸EïÂd —×àN .¦=B5KYBéÙ–iïö;Ã5C|÷< ª`(ƒòd‹I¤ì4[BUÝú]Íû‡l]›Äj_U\÷težlÝ À–zkINñˆºê ÖBî„Vs†œ« úT/G0ñvô§w¿:Árh/à'ðD"Ëb$Í\ÑIá½±r7‘ä¶5p¨Ž¼ùó_g´‰!%]fJŒçÅ4ÝÀF{½ŸqŒy½]ÛyºrÇÙ ¬ÞÝ™èm˜ø€•+SÚæû}~+ûK×ȦL|Ž @ÛWúG:ï4"Õ×UJ'!~{g£"‘ºå ÓQ6Ã}EµÏƒñ(iª Tlš9çVAvÊ\¿wu—ÍžDŽÏ#Ío†$H®:TIÚ#tXµoÛÄh¬%ÀUWiHGp _#ü¢?YëJ" ç B&Õú¶žý±H*PÞ7`yµšȶ¹êËsÓÌ2ÏVdJè:£l¹¾€,®êpŒJûÀšÕéHïTÝÖ(ñºTlÕaŒòµ›e,s,äI=à’¶9ƒ!öwtCM†>°ö@¡Åíý›eòåJ"0æõQß8S ¥ë¤m •—öÖüDFÓ@Lö* [X£úÍPÉ*é‘qsŸÞiþ º½ëîE«ž <ù.´ÄìðEýT<‡·¢tØRúb$ƒžU|Þ[h|aÎ åïïž<ƒ°`™$cz߇NíŠB£%ŒþdbÕåÐc˜»†²ÎƒÌþ¦KE é`HZ-no8õžD˜ r!N]¶}bãé­¦˜$à‚'É%nIâ¬r¸7½½Ú¤s^´ ­5ŠI[·=}åbË]}å|ÄiæU¤”o¶ITVãsîÓt82˜Ùö`XÎïeɽ¼* dúø2ÐùÖª—»ç¡Ø6à õ´?Ól]FÑÂ<Ñ_StJ¶…Îü¡›À·5ÅÈrF ë{ßAࢣ\FbtûÕ#*]uŽiål¦0È—ßvi&xíAIEÎ(Õ o<öHWÖ pê(xŸ<¥Œ³kQõRÞíÌpê±mU2.Ä4à­Ü)´þŽ5PÜ™ÄYRC!´gRQÝèòßOpŸ±ß£üf†à{Åà<oÇA¤bR—ìÍ$YÇÉQ‘­éàí‚¡rQãÔ¸}(/þÒrî— >ÄTÖ£¡”áJn! Ž%«Ú%6âÐ"¡pI+H•î'x¤cùüΙxŒŒÁ›aÑ÷é›—wÀq‹mÆqWv°»è6Ä£ ¥cºaé$j©2£´’³kA£<Qy¬µ8|É~1 }sw@À *º7}æ’Õ†C»†{=ç8»æªYó'úôE­è˜þ'-™# #jL-Bhf©/õê›ÇfÕq艎”ìR¤H‘·@Z¶šœê_KPñ ]h@Û ¯¼P>;÷f/0ã4 4÷°´-OÈÖ_|n=ß �V¾}e"ÃD14k¬»vÌà,R,ž­û… ßçkUžú"Ç ÞýRÇA1|Ú C;…Ϊ·¹ë·®‹3Í«žÙó!Âjž¦®êƒ�NH-ý*ëýÙƒ¿5Òš5ת¦î]¿Ø¸ìR±Œh_utÎ''M‚Ó¥¤—¿Õh,Ocÿª<Rš;Zqc8¨ «ñÑÚ©cžáeê~sp¼yõq•jgAUnÄiä£h{Øt.ÔÇ«ã0@îÒÉzqÐ3”â ¼bÍCÕpUšU<iŽkÃS¬‡ÖÇ8ÜÄñ•‘rœ¸+ëËñ€aÐ&ŒõçùÐל©Ñ‡¢5°]Ö…ol+Ó¨°Õªä¸IóoÓæª9AÍAËù»}Ñ'ÒU®ÌÍÜ¡«‚Üʽ²ª5Ü™±gÁ,Îû±9v”–Î’U ‡ê"¨¬ŒKìÖýbM¦ÀMšYŸä‰Ú‘LU½dHè|P@h•–„“—^½{¿5ñ£•± m¢è›wÏ>e3rïocÊ©…«cžA{—VàRÈ‹{L‘ï4‘_e†U3HWíÞäPÑhÇÓ¬¾Òw#ï_zù‘ú×õ ‹§­Ç2 OÙZ“ë”Þ6>¶#­'“Šô‹<Dšå¬&A©cñj‘€ÉTRk¨§ß× •ö!UsG›+fíK„vÕÖ»œFî=}ÄŠlÅƦ…2íRúM­6@n¸Û,£jU›±Š£º­¯Œ£º B¨$è(Ø©Æ*p¾80T†Ð¨»®œZ¿…+ZI¬˜+¦‰°óì‡9u;`!ýŽClP£¥<OW:QùËs¦#îÉ©QNx´öI»'x_Z‘•í™§¿ñ<]÷<CZ<)®n.Íý~Îf%žmûo,U|`G®‰VïJâî)1Œœ†LÄóÌãûýoçÃ#5ç+/7š?:°c¥Ó¤Ww�n‰=ÐmMô 6®rñúsô1!?²V€Ác=dfD 5Ä¢ÍxB¶£ßRYs5Ú5”b(GLlå‹5N 9ˆª¡¯ºs·½ºÿ’VÞï\š���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/decompress_index.sql������������������������������������������������0000664�0000000�0000000�00000007377�15100345067�0022525�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; CREATE TABLE ht_metrics_compressed(time timestamptz, device int, value float, tag text); ALTER TABLE ht_metrics_compressed SET (autovacuum_enabled = false); SELECT create_hypertable('ht_metrics_compressed','time',create_default_indexes:=false, chunk_time_interval => interval '100 day'); ALTER TABLE ht_metrics_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); -- helper function: float -> pseudorandom float [0..1]. CREATE OR REPLACE FUNCTION mix(x float4) RETURNS float4 AS $$ SELECT ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ LANGUAGE SQL; INSERT INTO ht_metrics_compressed SELECT '2020-05-18'::timestamptz + interval '1 second' * (x + 0.1 * mix(device + x * 10)), device, 100 * mix(device) * sin(x / 3600) + 100 * mix(device + 1) * sin(x / (3600 * 24)) + 100 * mix(device + 2) * sin(x / (3600 * 24 * 7)) + mix(device + x * 10 + 1), format('this-is-a-long-tag-#%s', x % 29) FROM generate_series(1, 3600 * 24 * 90, 100) x, generate_series(1,2) device; analyze ht_metrics_compressed; select show_chunks('ht_metrics_compressed') as "CHUNK" limit 1 \gset select count(*) from :CHUNK; select count(distinct tag) from :CHUNK; select device, min(time), max(time) from :CHUNK group by 1 order by 1, 2, 3; -- decompress with no indexes select where compress_chunk(:'CHUNK') is null; select where decompress_chunk(:'CHUNK') is null; -- decompress with one index select where compress_chunk(:'CHUNK') is null; create index on :CHUNK(device, time); select where decompress_chunk(:'CHUNK') is null; -- decompress with two indexes select where compress_chunk(:'CHUNK') is null; create index on :CHUNK(tag); select where decompress_chunk(:'CHUNK') is null; -- check the data after decompression set enable_seqscan to off; select count(*) from :CHUNK; select count(distinct tag) from :CHUNK; select distinct on (device) device, time from :CHUNK order by 1, 2; -- To avoid differences in PG15 output which doesn't support this feature SET timescaledb.enable_skipscan_for_distinct_aggregates TO false; -- check that the indexes are used explain (buffers off, costs off) select count(distinct tag) from :CHUNK; explain (buffers off, costs off) select distinct on (device) device, time from :CHUNK order by 1, 2; RESET timescaledb.enable_skipscan_for_distinct_aggregates; drop table ht_metrics_compressed; -- Fix for issue #8681: IndexScan is not chosen for columnstore segmented on varchar column -- We should chose IndexScan now, and use SkipScan as well CREATE TABLE record (time timestamptz not null, data varchar); SELECT table_name FROM create_hypertable('record','time'); ALTER TABLE record SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='data'); INSERT INTO record SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); analyze record; SELECT compress_chunk(ch) FROM show_chunks('record') ch; -- enable_seqscan is OFF, should see IndexScan explain (buffers off, costs off) SELECT * FROM record ORDER BY data; -- SkipScan is chosen because IndexScan is chosen explain (buffers off, costs off) SELECT DISTINCT ON(data) * FROM record; -- (seg_col = const) condition is checked even when seg_col is coerced explain (buffers off, costs off) SELECT * FROM record WHERE data='Yes' ORDER BY data; explain (buffers off, costs off) SELECT * FROM record WHERE 'Yes' <= data ORDER BY data; drop table record cascade; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/decompress_memory.sql�����������������������������������������������0000664�0000000�0000000�00000007210�15100345067�0022710�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; CREATE TABLE ht_metrics_compressed(time timestamptz, device int, value float, tag text); ALTER TABLE ht_metrics_compressed SET (autovacuum_enabled = false); SELECT create_hypertable('ht_metrics_compressed','time',create_default_indexes:=false); ALTER TABLE ht_metrics_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); -- helper function: float -> pseudorandom float [0..1]. CREATE OR REPLACE FUNCTION mix(x float4) RETURNS float4 AS $$ SELECT ((hashfloat4(x) / (pow(2., 31) - 1) + 1) / 2)::float4 $$ LANGUAGE SQL; INSERT INTO ht_metrics_compressed SELECT '2020-01-08'::timestamptz + interval '1 second' * (x + 0.1 * mix(device + x * 10)), device, 100 * mix(device) * sin(x / 3600) + 100 * mix(device + 1) * sin(x / (3600 * 24)) + 100 * mix(device + 2) * sin(x / (3600 * 24 * 7)) + mix(device + x * 10 + 1), format('this-is-a-long-tag-#%s', x % 29) FROM generate_series(1, 3600 * 24 * 356, 100) x, generate_series(1,2) device; -- compress it all SELECT count(compress_chunk(c, true)) FROM show_chunks('ht_metrics_compressed') c; select count(*) from ht_metrics_compressed; -- Helper function that returns the amount of memory currently allocated in a -- given memory context. create or replace function ts_debug_allocated_bytes(text = 'PortalContext') returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; -- Check that decompression doesn't leak memory. Record memory usage after each -- compressed chunk, and use linear regression to tell if memory usage grows. with log as materialized ( select rank() over (order by c) n, ts_debug_allocated_bytes() b, decompress_chunk(c, true) from show_chunks('ht_metrics_compressed') c order by c) , regression as (select regr_slope(b, n) slope, regr_intercept(b, n) intercept from log) select * from log where (select slope / intercept::float > 0.01 from regression) ; -- Same as above but for compression. with log as materialized ( select rank() over (order by c) n, ts_debug_allocated_bytes() b, compress_chunk(c, true) from show_chunks('ht_metrics_compressed') c order by c) , regression as (select regr_slope(b, n) slope, regr_intercept(b, n) intercept from log) select * from log where (select slope / intercept::float > 0.01 from regression) ; -- Test recompression with small batches. select count(decompress_chunk(c, true)) from show_chunks('ht_metrics_compressed') c; alter table ht_metrics_compressed set (timescaledb.compress, timescaledb.compress_segmentby='time', timescaledb.compress_orderby='value'); select count(compress_chunk(c, true)) from show_chunks('ht_metrics_compressed') c; update ht_metrics_compressed set value = 0 where value < 1 and value > -1; with to_recompress as ( select tableoid::oid::regclass c, count(*) r from ht_metrics_compressed where value = 0 group by 1 ), log as materialized ( select rank() over (order by r) n, ts_debug_allocated_bytes(case when _timescaledb_functions.recompress_chunk_segmentwise(c)::text != '' then 'PortalContext' else '' end) b from show_chunks('ht_metrics_compressed') c join to_recompress using (c) order by r), regression as (select regr_slope(b, n) slope, regr_intercept(b, n) intercept from log) select * from log where (select slope / intercept::float > 0.01 from regression) ; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/decompress_vector_qual.sql������������������������������������������0000664�0000000�0000000�00000133663�15100345067�0023740�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER create function stable_abs(x int4) returns int4 as 'int4abs' language internal stable; create table vectorqual(metric1 int8, ts timestamp, metric2 int8, device int8); select create_hypertable('vectorqual', 'ts'); alter table vectorqual set (timescaledb.compress, timescaledb.compress_segmentby = 'device'); insert into vectorqual(ts, device, metric1, metric2) values ('2020-01-01 00:00:00', 1, 11, 12); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; alter table vectorqual drop column metric1; insert into vectorqual(ts, device, metric2) values ('2021-01-01 00:00:00', 2, 22); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; alter table vectorqual add column metric3 int4 default 777; insert into vectorqual(ts, device, metric2, metric3) values ('2022-01-01 00:00:00', 3, 32, 33); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; alter table vectorqual add column metric4 int8; insert into vectorqual(ts, device, metric2, metric3, metric4) values ('2023-01-01 00:00:00', 4, 42, 43, 44); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; select * from vectorqual order by vectorqual; -- single chunk select * from vectorqual where ts between '2019-02-02' and '2020-02-02' order by vectorqual; select * from vectorqual where ts between '2020-02-02' and '2021-02-02' order by vectorqual; select * from vectorqual where ts between '2021-02-02' and '2022-02-02' order by vectorqual; select * from vectorqual where ts between '2022-02-02' and '2023-02-02' order by vectorqual; set timescaledb.debug_require_vector_qual to 'require' /* all following quals must be vectorized */; select count(*) from vectorqual where ts > '1999-01-01 00:00:00'; select count(*) from vectorqual where metric2 = 22; select count(*) from vectorqual where 22 = metric2 /* commutators */; select count(*) from vectorqual where metric3 = 33; select count(*) from vectorqual where metric3 = 777 /* default value */; select count(*) from vectorqual where metric4 = 44 /* column with default null */; select count(*) from vectorqual where metric4 >= 0 /* nulls shouldn't pass the qual */; set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where device = 1 /* can't apply vector ops to the segmentby column */; -- Test various combinations of arithmetic types. create table arithmetic(ts int, a int2, b int4, c int8, d float4, e float8, ax int2, bx int4, cx int8, dx float4, ex float8); select create_hypertable('arithmetic', 'ts'); alter table arithmetic set (timescaledb.compress); insert into arithmetic values (100, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), (101, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11); select count(compress_chunk(x, true)) from show_chunks('arithmetic') x; set timescaledb.debug_require_vector_qual to 'require'; select * from arithmetic where a > 1::int2 and a > 1::int4 and a > 1::int8 and b > 1::int2 and b > 1::int4 and b > 1::int8 and c > 1::int2 and c > 1::int4 and c > 1::int8 and d > 1::int2 and d > 1::int4 and d > 1::int8 and d > 1::float4 and d > 1::float8 and e > 1::int2 and e > 1::int4 and e > 1::int8 and e > 1::float4 and e > 1::float8 ; -- Test columns that don't support bulk decompression. alter table vectorqual add column tag name; insert into vectorqual(ts, device, metric2, metric3, metric4, tag) values ('2025-01-01 00:00:00', 5, 52, 53, 54, 'tag5'); select count(compress_chunk(x, true)) from show_chunks('vectorqual') x; set timescaledb.debug_require_vector_qual to 'require'; select tag from vectorqual where metric2 > 0; -- Can't vectorize parameterized join clauses for now. set timescaledb.debug_require_vector_qual to 'forbid'; set enable_hashjoin to off; set enable_mergejoin to off; with values(x) as materialized(select distinct metric2 from vectorqual) select x, (select metric2 from vectorqual where metric2 = x) from values order by 1; reset enable_hashjoin; reset enable_mergejoin; -- Can't vectorize initplan parameters either. select count(*) from vectorqual where metric2 = (select metric2 from vectorqual order by 1 limit 1); -- Can vectorize clauses with query parameters. set timescaledb.debug_require_vector_qual to 'require'; set plan_cache_mode to 'force_generic_plan'; prepare p as select count(*) from vectorqual where metric3 = $1; execute p(33); deallocate p; -- Also try query parameter in combination with a stable function. prepare p(int4) as select count(*) from vectorqual where metric3 = stable_abs($1); execute p(33); deallocate p; reset plan_cache_mode; -- Queries without aggregation. set timescaledb.debug_require_vector_qual to 'require'; select * from vectorqual where ts > '2021-01-01 00:00:00' order by vectorqual; select * from vectorqual where metric4 >= 0 order by vectorqual; -- Constraints on columns not selected. select metric4 from vectorqual where ts > '2021-01-01 00:00:00' order by 1; -- ANDed constraints on multiple columns. select * from vectorqual where ts > '2021-01-01 00:00:00' and metric3 > 40 order by vectorqual; -- ORed constrainst on multiple columns. set timescaledb.debug_require_vector_qual to 'require'; -- set timescaledb.debug_require_vector_qual to 'forbid'; -- set timescaledb.enable_bulk_decompression to off; select * from vectorqual where ts > '2021-01-01 00:00:00' or metric3 > 40 order by vectorqual; -- Some more tests for boolean operations. select count(*) from vectorqual where ts > '2021-01-01 00:00:00'; select count(*) from vectorqual where 40 < metric3; select count(*) from vectorqual where metric2 < 0; select count(*) from vectorqual where ts > '2021-01-01 00:00:00' or 40 < metric3; select count(*) from vectorqual where not (ts <= '2021-01-01 00:00:00' and 40 >= metric3); -- early exit inside AND BoolExpr select count(*) from vectorqual where metric2 < 0 or (metric4 < -1 and 40 >= metric3); -- early exit after OR BoolExpr select count(*) from vectorqual where metric2 < 0 or metric3 < -1; -- expression evaluated to null at run time select count(*) from vectorqual where metric3 = 777 or metric3 > case when now() > now() - interval '1s' then null else 1 end; reset timescaledb.enable_bulk_decompression; -- Test with unary operator. set timescaledb.debug_require_vector_qual to 'forbid'; create operator !! (function = 'bool', rightarg = int4); select count(*) from vectorqual where !!metric3; select count(*) from vectorqual where not !!metric3; -- Custom operator on column that supports bulk decompression is not vectorized. set timescaledb.debug_require_vector_qual to 'forbid'; create function int4eqq(int4, int4) returns bool as 'int4eq' language internal; create operator === (function = 'int4eqq', rightarg = int4, leftarg = int4); select count(*) from vectorqual where metric3 === 777; select count(*) from vectorqual where metric3 === any(array[777, 888]); select count(*) from vectorqual where not metric3 === 777; select count(*) from vectorqual where metric3 = 777 or metric3 === 777; -- Custom operator that can be vectorized but doesn't have a negator. create operator !!! (function = 'int4ne', rightarg = int4, leftarg = int4); set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric3 !!! 777; select count(*) from vectorqual where metric3 !!! any(array[777, 888]); select count(*) from vectorqual where metric3 !!! 777 or metric3 !!! 888; select count(*) from vectorqual where metric3 !!! 666 and (metric3 !!! 777 or metric3 !!! 888); select count(*) from vectorqual where metric3 !!! 666 and (metric3 !!! 777 or metric3 !!! stable_abs(888)); set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where not metric3 !!! 777; select count(*) from vectorqual where metric3 !!! 666 or (metric3 !!! 777 and not metric3 !!! 888); select count(*) from vectorqual where metric3 !!! 666 or not (metric3 !!! 777 and not metric3 !!! 888); set timescaledb.debug_require_vector_qual to 'allow'; select count(*) from vectorqual where metric3 !!! 777 or not metric3 !!! 888; select count(*) from vectorqual where metric3 !!! 777 and not metric3 !!! 888; select count(*) from vectorqual where not(metric3 !!! 666 or not (metric3 !!! 777 and not metric3 !!! 888)); -- These operators don't have a commutator. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where 777 === metric3; select count(*) from vectorqual where 777 !!! metric3; -- NullTest is vectorized. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric4 is null; select count(*) from vectorqual where metric4 is not null; select count(*) from vectorqual where metric3 = 777 or metric4 is not null; select count(*) from vectorqual where metric3 = stable_abs(777) or metric4 is null; -- Can't vectorize conditions on system columns. Have to check this on a single -- chunk, otherwise the whole-row var will be masked by ConvertRowType. select show_chunks('vectorqual') chunk1 limit 1 \gset set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from :chunk1 t where t is null; select count(*) from :chunk1 t where t.* is null; select count(*) from :chunk1 t where tableoid is null; -- Scalar array operators are vectorized if the operator is vectorizable. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric3 = any(array[777, 888]); /* default value */ select count(*) from vectorqual where metric4 = any(array[44, 55]) /* default null */; select count(*) from vectorqual where metric2 > any(array[-1, -2, -3]) /* any */; select count(*) from vectorqual where metric2 > all(array[-1, -2, -3]) /* all */; -- Also have to support null array elements, because they are impossible to -- prevent in stable expressions. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric2 = any(array[null::int]) /* any with null element */; select count(*) from vectorqual where metric2 = any(array[22, null]) /* any with null element */; select count(*) from vectorqual where metric2 = any(array[null, 32]) /* any with null element */; select count(*) from vectorqual where metric2 = any(array[22, null, 32]) /* any with null element */; select count(*) from vectorqual where metric2 = all(array[null::int]) /* all with null element */; select count(*) from vectorqual where metric2 = all(array[22, null]) /* all with null element */; select count(*) from vectorqual where metric2 = all(array[null, 32]) /* all with null element */; select count(*) from vectorqual where metric2 = all(array[22, null, 32]) /* all with null element */; select count(*) from vectorqual where metric2 = all(array[]::int[]); select count(*) from vectorqual where metric2 = any(array[]::int[]); select count(*) from vectorqual where metric2 = all(null::int[]); select count(*) from vectorqual where metric2 = any(null::int[]); -- Check early exit. reset timescaledb.debug_require_vector_qual; create table singlebatch(like vectorqual); select create_hypertable('singlebatch', 'ts'); alter table singlebatch set (timescaledb.compress); insert into singlebatch select '2022-02-02 02:02:02', metric2, device, metric3, metric4, tag from vectorqual; select count(compress_chunk(x, true)) from show_chunks('singlebatch') x; set timescaledb.debug_require_vector_qual to 'require'; -- Uncomment to generate the test reference w/o the vector optimizations. -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 22]); select count(*) from singlebatch where metric2 = any(array[0, 22, 0, 0, 0]); select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 0]); select count(*) from singlebatch where metric2 != any(array[0, 0, 0, 0, 0]); select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 0]); select count(*) from singlebatch where metric2 <= all(array[12, 0, 12, 12, 12]); select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 12]); select count(*) from singlebatch where metric3 = 777 and metric2 = any(array[0, 0, 0, 0, 22]); select count(*) from singlebatch where metric3 = 777 and metric2 = any(array[0, 22, 0, 0, 0]); select count(*) from singlebatch where metric3 = 777 and metric2 = any(array[0, 0, 0, 0, 0]); select count(*) from singlebatch where metric3 = 777 and metric2 != any(array[0, 0, 0, 0, 0]); select count(*) from singlebatch where metric3 = 777 and metric2 <= all(array[12, 12, 12, 12, 0]); select count(*) from singlebatch where metric3 = 777 and metric2 <= all(array[12, 0, 12, 12, 12]); select count(*) from singlebatch where metric3 = 777 and metric2 <= all(array[12, 12, 12, 12, 12]); select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 22]) and metric3 = 777; select count(*) from singlebatch where metric2 = any(array[0, 22, 0, 0, 0]) and metric3 = 777; select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 0]) and metric3 = 777; select count(*) from singlebatch where metric2 != any(array[0, 0, 0, 0, 0]) and metric3 = 777; select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 0]) and metric3 = 777; select count(*) from singlebatch where metric2 <= all(array[12, 0, 12, 12, 12]) and metric3 = 777; select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 12]) and metric3 = 777; select count(*) from singlebatch where metric3 != 777 and metric2 = any(array[0, 0, 0, 0, 22]); select count(*) from singlebatch where metric3 != 777 and metric2 = any(array[0, 22, 0, 0, 0]); select count(*) from singlebatch where metric3 != 777 and metric2 = any(array[0, 0, 0, 0, 0]); select count(*) from singlebatch where metric3 != 777 and metric2 != any(array[0, 0, 0, 0, 0]); select count(*) from singlebatch where metric3 != 777 and metric2 <= all(array[12, 12, 12, 12, 0]); select count(*) from singlebatch where metric3 != 777 and metric2 <= all(array[12, 0, 12, 12, 12]); select count(*) from singlebatch where metric3 != 777 and metric2 <= all(array[12, 12, 12, 12, 12]); select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 22]) and metric3 != 777; select count(*) from singlebatch where metric2 = any(array[0, 22, 0, 0, 0]) and metric3 != 777; select count(*) from singlebatch where metric2 = any(array[0, 0, 0, 0, 0]) and metric3 != 777; select count(*) from singlebatch where metric2 != any(array[0, 0, 0, 0, 0]) and metric3 != 777; select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 0]) and metric3 != 777; select count(*) from singlebatch where metric2 <= all(array[12, 0, 12, 12, 12]) and metric3 != 777; select count(*) from singlebatch where metric2 <= all(array[12, 12, 12, 12, 12]) and metric3 != 777; -- Also check early exit for AND/OR. Top-level clause must be OR, because top-level -- AND is flattened into a list. select count(*) from singlebatch where (metric2 < 20 and metric2 < 30) or metric3 = 777; select count(*) from singlebatch where (metric2 < 30 and metric2 < 20) or metric3 = 777; select count(*) from singlebatch where metric3 = 777 or (metric2 < 20 and metric2 < 30); select count(*) from singlebatch where metric3 = 777 or (metric2 < 30 and metric2 < 20); select count(*) from vectorqual where (metric2 < 20 and metric2 < 30) or metric3 = 777; select count(*) from vectorqual where (metric2 < 30 and metric2 < 20) or metric3 = 777; select count(*) from vectorqual where metric3 = 777 or (metric2 < 20 and metric2 < 30); select count(*) from vectorqual where metric3 = 777 or (metric2 < 30 and metric2 < 20); select count(*) from singlebatch where metric2 < 20 or metric3 < 50 or metric3 > 50; select count(*) from singlebatch where metric2 < 20 or metric3 > 50 or metric3 < 50; select count(*) from singlebatch where metric3 < 50 or metric2 < 20 or metric3 > 50; select count(*) from singlebatch where metric3 > 50 or metric3 < 50 or metric2 < 20; select count(*) from vectorqual where metric2 < 20 or metric3 < 50 or metric3 > 50; select count(*) from vectorqual where metric2 < 20 or metric3 > 50 or metric3 < 50; select count(*) from vectorqual where metric3 < 50 or metric2 < 20 or metric3 > 50; select count(*) from vectorqual where metric3 > 50 or metric3 < 50 or metric2 < 20; select count(*) from singlebatch where metric2 = 12 or metric3 = 888; select count(*) from singlebatch where metric2 = 22 or metric3 = 888; select count(*) from singlebatch where metric2 = 32 or metric3 = 888; select count(*) from singlebatch where metric2 = 42 or metric3 = 888; select count(*) from singlebatch where metric2 = 52 or metric3 = 888; select count(*) from vectorqual where metric2 = 12 or metric3 = 888; select count(*) from vectorqual where metric2 = 22 or metric3 = 888; select count(*) from vectorqual where metric2 = 32 or metric3 = 888; select count(*) from vectorqual where metric2 = 42 or metric3 = 888; select count(*) from vectorqual where metric2 = 52 or metric3 = 888; select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 777 and metric2 = 12); select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 777 and metric2 = 666); select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 888 and metric2 = 12); select count(*) from singlebatch where ts > '2024-01-01' or (metric3 = 888 and metric2 = 666); select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 777 and metric2 = 12); select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 777 and metric2 = 666); select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 888 and metric2 = 12); select count(*) from vectorqual where ts > '2024-01-01' or (metric3 = 888 and metric2 = 666); -- On versions >= 14, the Postgres planner chooses to build a hash table for -- large arrays. We currently don't vectorize in this case. select 1 from set_config('timescaledb.debug_require_vector_qual', case when current_setting('server_version_num')::int >= 140000 then 'forbid' else 'require' end, false); select count(*) from singlebatch where metric2 = any(array[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 ]::int8[]); reset timescaledb.enable_bulk_decompression; reset timescaledb.debug_require_vector_qual; -- Comparison with other column not vectorized. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric3 = metric4; select count(*) from vectorqual where metric3 = any(array[metric4]); -- Vectorized filters also work if we have only stable functions on the right -- side that can be evaluated to a constant at run time. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where ts > '2021-01-01 00:00:00'::timestamptz::timestamp; select count(*) from vectorqual where ts > '2021-01-01 00:00:00'::timestamp - interval '1 day'; -- Expression that evaluates to Null. select count(*) from vectorqual where ts > case when '2021-01-01'::timestamp < '2022-01-01'::timestamptz then null else '2021-01-01 00:00:00'::timestamp end; select count(*) from vectorqual where ts < LOCALTIMESTAMP + '3 years'::interval; -- These filters are not vectorizable as written, because the 'timestamp > timestamptz' -- operator is stable, not immutable. We will try to cast the constant to the -- same type in this case. set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where ts > '2021-01-01 00:00:00'::timestamptz; select count(*) from vectorqual where ts < LOCALTIMESTAMP at time zone 'UTC' + '3 years'::interval; -- Can't vectorize comparison with a volatile function. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric3 > random()::int - 100; select count(*) from vectorqual where ts > case when random() < 10 then null else '2021-01-01 00:00:00'::timestamp end; -- Test that the vectorized quals are disabled by disabling the bulk decompression. set timescaledb.enable_bulk_decompression to off; set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric4 > null; set timescaledb.enable_bulk_decompression to on; -- Test that the debug GUC works \set ON_ERROR_STOP 0 set timescaledb.debug_require_vector_qual to 'forbid'; select count(*) from vectorqual where metric4 > 4; set timescaledb.debug_require_vector_qual to 'require'; select count(*) from vectorqual where metric3 === 4; \set ON_ERROR_STOP 1 -- Date columns create table date_table(ts date); select create_hypertable('date_table', 'ts'); alter table date_table set (timescaledb.compress); insert into date_table values ('2021-01-01'), ('2021-01-02'), ('2021-01-03'); select count(compress_chunk(x, true)) from show_chunks('date_table') x; set timescaledb.debug_require_vector_qual to 'require'; select * from date_table where ts > '2021-01-02'; select * from date_table where ts >= '2021-01-02'; select * from date_table where ts = '2021-01-02'; select * from date_table where ts <= '2021-01-02'; select * from date_table where ts < '2021-01-02'; select * from date_table where ts < CURRENT_DATE; -- Text columns. create table text_table(ts int, d int); select create_hypertable('text_table', 'ts'); alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = 'd'); insert into text_table select x, 0 /*, default */ from generate_series(1, 1000) x; select count(compress_chunk(x, true)) from show_chunks('text_table') x; alter table text_table add column a text default 'default'; insert into text_table select x, 1, '' from generate_series(1, 1000) x; insert into text_table select x, 2, 'same' from generate_series(1, 1000) x; insert into text_table select x, 3, 'different' || x from generate_series(1, 1000) x; insert into text_table select x, 4, case when x % 2 = 0 then null else 'same-with-nulls' end from generate_series(1, 1000) x; insert into text_table select x, 5, case when x % 2 = 0 then null else 'different-with-nulls' || x end from generate_series(1, 1000) x; insert into text_table select x, 6, 'одинаковый' from generate_series(1, 1000) x; insert into text_table select x, 7, 'ç•°ãªã‚‹' || x from generate_series(1, 1000) x; -- Some text values with varying lengths in a single batch. They are all different -- to prevent dictionary compression, because we want to test particular orders -- here as well. insert into text_table select x, 8, repeat( x::text || 'a', x) from generate_series(1, 100) x; insert into text_table select x + 100, 8, repeat((101 - x)::text || 'b', (101 - x)) from generate_series(1, 100) x; insert into text_table select x + 200, 8, repeat((101 - x)::text || 'c', (101 - x)) from generate_series(1, 100) x; insert into text_table select x + 300, 8, repeat( x::text || 'd', x) from generate_series(1, 100) x; -- Use uncompressed table as reference. set timescaledb.debug_require_vector_qual to 'forbid'; select sum(length(a)) from text_table; select count(distinct a) from text_table; select count(compress_chunk(x, true)) from show_chunks('text_table') x; select compress_chunk(x) from show_chunks('text_table') x; -- Check result with decompression. set timescaledb.enable_bulk_decompression to on; set timescaledb.debug_require_vector_qual to 'forbid'; select sum(length(a)) from text_table; select count(distinct a) from text_table; -- Test vectorized predicates. set timescaledb.debug_require_vector_qual to 'require'; -- -- Uncomment to generate the test reference w/o the vector optimizations. -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'default'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = ''; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'same'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a != 'same'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'одинаковый'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'same-with-nulls'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'ç•°ãªã‚‹1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different-with-nulls1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different1000'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different-with-nulls999'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a in ('same', 'different500'); select count(*), min(ts), max(ts), min(d), max(d) from text_table where a in ('same-with-nulls', 'different-with-nulls499'); select count(*), min(ts), max(ts), min(d), max(d) from text_table where a in ('different500', 'default'); select count(*), min(ts), max(ts), min(d), max(d) from text_table where a = 'different500' or a = 'default'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a is null; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a is not null; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%same%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%одинаковый%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%одилаковый%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%одимаковый%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%ç•°ãªã‚‹%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%異オる%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%ç•°ã«ã‚‹%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'ç•°_ã‚‹_'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%different1%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like '%different1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%%1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%\1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%_'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%__'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%___'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%_1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%nulls_'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different1%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different\%'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different\1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different_%1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different_'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different_1'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'same_'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a not like '%different1%'; \set ON_ERROR_STOP 0 select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different\'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a like 'different%\'; \set ON_ERROR_STOP 1 -- We don't vectorize comparison operators with text because they are probably -- not very useful. set timescaledb.debug_require_vector_qual to 'forbid'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a < 'same'; select count(*), min(ts), max(ts), min(d), max(d) from text_table where a > 'same'; reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bulk_decompression; -- Test the nonstandard Postgres NaN comparison that doesn't match the IEEE floats. create table nans(t int, cfloat4 float4, cfloat8 float8); select create_hypertable('nans', 't', chunk_time_interval => 1024 * 1024 * 1024); alter table nans set (timescaledb.compress); insert into nans select pow(2, n), x, x from unnest(array[null, 0, 1, 'nan', '-inf', '+inf']::float8[]) with ordinality as x(x, n) ; select count(compress_chunk(x)) from show_chunks('nans') x; set timescaledb.enable_bulk_decompression to on; set timescaledb.debug_require_vector_qual to 'require'; select format('select sum(t) from nans where %s %s %s::%s;', variable, op, value, type) from unnest(array['cfloat4', 'cfloat8']) variable, unnest(array['=', '!=', '<', '<=', '>', '>=']) op, unnest(array['null', '0', '1', '''nan''', '''-inf''', '''+inf''']) value, unnest(array['float4', 'float8', 'numeric']) type \gexec reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bulk_decompression; -- Test predicates on UUID columns can be vectorized -- if UUID compression is _disabled_. With the new changes -- vectorized decompression should be supported, regardless of -- whether the UUID compression is enabled or not. set timescaledb.enable_uuid_compression = off; -- Generate reference results with uncommenting the next two lines -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; create table uuid_table(ts int, u uuid); select count(*) from create_hypertable('uuid_table', 'ts'); alter table uuid_table set (timescaledb.compress); insert into uuid_table values (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '01941f29-7c00-706a-bea9-105dad841304'), (18, '01941f2a-665f-7722-b4b5-cf4e70e666d0'), (19, NULL::uuid), (20, NULL::uuid), (21, NULL::uuid); select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; -- With the new changes bulk decompression and vectorized filtering -- will be supported regardless of whether the UUID compression is -- enabled or not. set timescaledb.debug_require_vector_qual to 'require'; select * from uuid_table where u = '01941f29-7c00-706a-bea9-105dad841304'::uuid; select * from uuid_table where u in ( '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid) order by 1, 2; select * from uuid_table where u = any(array[ '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid ]) order by 1, 2; select * from uuid_table where u not in ( '0197a7a9-b48b-7c70-be05-e376afc66ee1'::uuid, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'::uuid) order by 1, 2; select * from uuid_table where u is not null order by 1, 2; -- Modify the data to make sure dictionary compression is used as well. update uuid_table set u = '0197a7a9-b48b-7c70-be05-e376afc66ee1' where ts in (1, 2, 3, 4); update uuid_table set u = '0197a7a9-b48b-7c71-92cb-eb724822bb0f' where ts in (5, 6, 7, 8); update uuid_table set u = '0197a7a9-b48b-7c72-bd57-49f981f064fd' where ts in (9, 10, 11, 12); update uuid_table set u = '0197a7a9-b48b-7c73-b521-91172c2e770a' where ts in (13, 14, 15, 16); select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; -- Generate reference results with uncommenting the next two lines -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; select * from uuid_table where u = '01941f29-7c00-706a-bea9-105dad841304'::uuid; select * from uuid_table where u in ( '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid) order by 1, 2; select * from uuid_table where u = any(array[ '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid ]) order by 1, 2; select * from uuid_table where u not in ( '0197a7a9-b48b-7c70-be05-e376afc66ee1'::uuid, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'::uuid) order by 1, 2; select * from uuid_table where u is not null order by 1, 2; reset timescaledb.enable_bulk_decompression; reset timescaledb.debug_require_vector_qual; -- Test predicates on UUID columns can be vectorized -- if UUID compression is _enabled_ set timescaledb.enable_uuid_compression = on; -- Generate reference results with uncommenting the next two lines -- set timescaledb.enable_bulk_decompression to off; -- set timescaledb.debug_require_vector_qual to 'forbid'; delete from uuid_table; insert into uuid_table values (1, '0197a7a9-b48b-7c70-be05-e376afc66ee1'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c72-bd57-49f981f064fd'), (4, '0197a7a9-b48b-7c73-b521-91172c2e770a'), (5, '0197a7a9-b48b-7c74-a2a4-dcdbce635d11'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c79-92c7-7dde3bea6252'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7c-aa7a-60d47bf04ff8'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '01941f29-7c00-706a-bea9-105dad841304'), (18, '01941f2a-665f-7722-b4b5-cf4e70e666d0'), (19, NULL::uuid), (20, NULL::uuid), (21, NULL::uuid); select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; set timescaledb.debug_require_vector_qual to 'require'; select * from uuid_table where u = '01941f29-7c00-706a-bea9-105dad841304'::uuid; select * from uuid_table where u in ( '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid) order by 1, 2; select * from uuid_table where u = any(array[ '01941f29-7c00-706a-bea9-105dad841304'::uuid, '0197a7a9-b48b-7c75-a810-8acf630e634f'::uuid ]) order by 1, 2; select * from uuid_table where u not in ( '0197a7a9-b48b-7c70-be05-e376afc66ee1'::uuid, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'::uuid) order by 1, 2; select * from uuid_table where u is not null order by 1, 2; reset timescaledb.enable_bulk_decompression; reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_uuid_compression; -- Test predicates on boolean columns can be vectorized -- with the bool compression enabled. set timescaledb.enable_bulk_decompression to on; set timescaledb.enable_bool_compression = on; create table bool_table(ts int, b bool); select count(*) from create_hypertable('bool_table', 'ts'); alter table bool_table set (timescaledb.compress); insert into bool_table values (100, true), (101, false), (102, null); select count(compress_chunk(x, true)) from show_chunks('bool_table') x; set timescaledb.debug_require_vector_qual to 'require'; -- BooleanTest expressions select * from bool_table where b is true order by 1; select * from bool_table where b is false order by 1; select * from bool_table where b is not true order by 1; select * from bool_table where b is not false order by 1; select * from bool_table where b is unknown order by 1; select * from bool_table where b is not unknown order by 1; -- Combinations of nulls and bool exprs select * from bool_table where b = true order by 1; select * from bool_table where b = true or b = false order by 1; select * from bool_table where b = true and b = false order by 1; select * from bool_table where b = true or b is null order by 1; select * from bool_table where b = true or b is not null order by 1; select * from bool_table where b = true and b is null order by 1; select * from bool_table where b = true and b is not null order by 1; select * from bool_table where b = false order by 1; select * from bool_table where b = false or b is null order by 1; select * from bool_table where b = false or b is not null order by 1; select * from bool_table where b = false and b is null order by 1; select * from bool_table where b = false and b is not null order by 1; select * from bool_table where b is null order by 1; select * from bool_table where b is null or b is not null order by 1; select * from bool_table where b is null and b is not null order by 1; select * from bool_table where b is not null order by 1; delete from bool_table where b is null; select count(compress_chunk(x, true)) from show_chunks('bool_table') x; select * from bool_table where b is true order by 1; select * from bool_table where b is false order by 1; select * from bool_table where b is not true order by 1; select * from bool_table where b is not false order by 1; select * from bool_table where b is unknown order by 1; select * from bool_table where b is not unknown order by 1; select * from bool_table where b = true order by 1; select * from bool_table where b = true or b = false order by 1; select * from bool_table where b = true and b = false order by 1; select * from bool_table where b = true or b is null order by 1; select * from bool_table where b = true or b is not null order by 1; select * from bool_table where b = true and b is null order by 1; select * from bool_table where b = true and b is not null order by 1; select * from bool_table where b = false order by 1; select * from bool_table where b = false or b is null order by 1; select * from bool_table where b = false or b is not null order by 1; select * from bool_table where b = false and b is null order by 1; select * from bool_table where b = false and b is not null order by 1; select * from bool_table where b is null order by 1; select * from bool_table where b is null or b is not null order by 1; select * from bool_table where b is null and b is not null order by 1; select * from bool_table where b is not null order by 1; reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bulk_decompression; reset timescaledb.enable_bool_compression; -- Check that the bool compression changes didn't mess up the -- array compression support for the bools. delete from bool_table; set timescaledb.enable_bool_compression = off; insert into bool_table values (100, true), (101, false), (102, null); select count(compress_chunk(x, true)) from show_chunks('bool_table') x; select * from bool_table where b is true order by 1; select * from bool_table where b is false order by 1; select * from bool_table where b is not true order by 1; select * from bool_table where b is not false order by 1; select * from bool_table where b is unknown order by 1; select * from bool_table where b is not unknown order by 1; select * from bool_table where b = true order by 1; select * from bool_table where b = true or b = false order by 1; select * from bool_table where b = true and b = false order by 1; select * from bool_table where b = true or b is null order by 1; select * from bool_table where b = true or b is not null order by 1; select * from bool_table where b = true and b is null order by 1; select * from bool_table where b = true and b is not null order by 1; select * from bool_table where b = false order by 1; select * from bool_table where b = false or b is null order by 1; select * from bool_table where b = false or b is not null order by 1; select * from bool_table where b = false and b is null order by 1; select * from bool_table where b = false and b is not null order by 1; select * from bool_table where b is null order by 1; select * from bool_table where b is null or b is not null order by 1; select * from bool_table where b is null and b is not null order by 1; select * from bool_table where b is not null order by 1; delete from bool_table where b is null; select count(compress_chunk(x, true)) from show_chunks('bool_table') x; select * from bool_table where b is true order by 1; select * from bool_table where b is false order by 1; select * from bool_table where b is not true order by 1; select * from bool_table where b is not false order by 1; select * from bool_table where b is unknown order by 1; select * from bool_table where b is not unknown order by 1; select * from bool_table where b = true order by 1; select * from bool_table where b = true or b = false order by 1; select * from bool_table where b = true and b = false order by 1; select * from bool_table where b = true or b is null order by 1; select * from bool_table where b = true or b is not null order by 1; select * from bool_table where b = true and b is null order by 1; select * from bool_table where b = true and b is not null order by 1; select * from bool_table where b = false order by 1; select * from bool_table where b = false or b is null order by 1; select * from bool_table where b = false or b is not null order by 1; select * from bool_table where b = false and b is null order by 1; select * from bool_table where b = false and b is not null order by 1; select * from bool_table where b is null order by 1; select * from bool_table where b is null or b is not null order by 1; select * from bool_table where b is null and b is not null order by 1; select * from bool_table where b is not null order by 1; -- At this point the bool data is generated as 'bool compression disabed' -- meaning, it is compressed with array compression. I try to confuse the -- executor by creating a vectorized plan and still hoping to get the right -- results. set timescaledb.debug_require_vector_qual to 'require'; set timescaledb.enable_bool_compression = on; select * from bool_table where b is true order by 1; select * from bool_table where b is false order by 1; select * from bool_table where b is not true order by 1; select * from bool_table where b is not false order by 1; select * from bool_table where b is unknown order by 1; select * from bool_table where b is not unknown order by 1; select * from bool_table where b = true order by 1; select * from bool_table where b = true or b = false order by 1; select * from bool_table where b = true and b = false order by 1; select * from bool_table where b = true or b is null order by 1; select * from bool_table where b = true or b is not null order by 1; select * from bool_table where b = true and b is null order by 1; select * from bool_table where b = true and b is not null order by 1; select * from bool_table where b = false order by 1; select * from bool_table where b = false or b is null order by 1; select * from bool_table where b = false or b is not null order by 1; select * from bool_table where b = false and b is null order by 1; select * from bool_table where b = false and b is not null order by 1; select * from bool_table where b is null order by 1; select * from bool_table where b is null or b is not null order by 1; select * from bool_table where b is null and b is not null order by 1; select * from bool_table where b is not null order by 1; -- Verify that NULL compression with bools is vectorized set timescaledb.debug_require_vector_qual to 'require'; update bool_table set b = NULL; select count(compress_chunk(x, true)) from show_chunks('bool_table') x; select * from bool_table where b is null order by 1; select * from bool_table where b is not null order by 1; select * from bool_table where b is null or b is not null order by 1; select * from bool_table where b is null and b is not null order by 1; select * from bool_table where b is not true order by 1; select * from bool_table where b is not false order by 1; select * from bool_table where b is unknown order by 1; select * from bool_table where b is not unknown order by 1; -- Verify that NULL compression with ints is vectorized create table int_table(ts int, b int); select count(*) from create_hypertable('int_table', 'ts'); alter table int_table set (timescaledb.compress); insert into int_table values (100, NULL), (101, NULL), (102, NULL); select count(compress_chunk(x, true)) from show_chunks('int_table') x; select * from int_table where b is null order by 1; select * from int_table where b is not null order by 1; select * from int_table where b is null or b is not null order by 1; select * from int_table where b is null and b is not null order by 1; -- check the compression algorithm for the compressed chunks set timescaledb.enable_transparent_decompression='off'; DO $$ DECLARE comp_regclass REGCLASS; rec RECORD; BEGIN FOR comp_regclass IN SELECT format('%I.%I', comp.schema_name, comp.table_name)::regclass as comp_regclass FROM _timescaledb_catalog.chunk uncomp, _timescaledb_catalog.chunk comp, (SELECT show_chunks('bool_table') as c UNION SELECT show_chunks('int_table') as c) as x WHERE uncomp.dropped IS FALSE AND uncomp.compressed_chunk_id IS NOT NULL AND comp.id = uncomp.compressed_chunk_id AND x.c = format('%I.%I', uncomp.schema_name, uncomp.table_name)::regclass LOOP FOR rec IN EXECUTE format('SELECT b, _timescaledb_functions.compressed_data_info(b) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Compressed info results: %', rec; END LOOP; FOR rec IN EXECUTE format('SELECT b, _timescaledb_functions.compressed_data_has_nulls(b) FROM %s', comp_regclass) LOOP RAISE NOTICE 'Has nulls results: %', rec; END LOOP; END LOOP; END; $$; reset timescaledb.enable_transparent_decompression; reset timescaledb.debug_require_vector_qual; reset timescaledb.enable_bool_compression; �����������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/detach_chunk.sql����������������������������������������������������0000664�0000000�0000000�00000010215�15100345067�0021573�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER GRANT CREATE ON DATABASE :"TEST_DBNAME" TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- Create test tables and hypertables CREATE TABLE devices(id int PRIMARY KEY); INSERT INTO devices VALUES (1), (2), (3); CREATE TABLE detach_test(id int, time timestamptz not null, device int, temp float); CREATE INDEX detach_test_device_idx ON detach_test (device); ALTER TABLE detach_test ADD CONSTRAINT detach_test_temp_check CHECK (temp > 0), ADD CONSTRAINT detach_test_device_fkey FOREIGN KEY (device) REFERENCES devices(id), ADD CONSTRAINT detach_test_id_time_unique UNIQUE (id, time); SELECT * FROM create_hypertable('detach_test', 'time', 'id', 2); CREATE TABLE detach_test_ref ( id int PRIMARY KEY, ref_id int, ref_time timestamptz, FOREIGN KEY (ref_id, ref_time) REFERENCES detach_test(id, time) ); INSERT INTO detach_test VALUES (1, '2025-06-01 05:00:00-8', 1, 23.4), (2, '2025-06-15 05:00:00-8', 2, 24.5), (3, '2025-06-30 05:00:00-8', 3, 25.6); -- Get chunk information for testing SELECT chunk_id AS "CHUNK_ID", hypertable_id AS "HYPERTABLE_ID", schema_name AS "CHUNK_SCHEMA", table_name AS "CHUNK_TABLE", schema_name || '.' || table_name AS "CHUNK_NAME" FROM _timescaledb_functions.show_chunk((SELECT show_chunks('detach_test') LIMIT 1)); \gset -- Detach by non-owner is not allowed \set ON_ERROR_STOP 0 set role :ROLE_1; CALL detach_chunk(:'CHUNK_NAME'); set role :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 SELECT count(*) AS "PREV_CHUNK_ROWS" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; \gset -- Test successful detach CALL detach_chunk(:'CHUNK_NAME'); -- Verify chunk is detached: SELECT count(*) = :PREV_CHUNK_ROWS-1 FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; SELECT count(*) = 0 FROM pg_inherits WHERE inhrelid = :'CHUNK_NAME'::regclass; -- Data should still be in the detached table SELECT count(*) > 0 FROM :CHUNK_NAME; -- Verify catalog cleanup SELECT count(*) = 0 FROM _timescaledb_catalog.chunk_constraint WHERE chunk_id = :'CHUNK_ID'; SELECT count(*) = 0 FROM _timescaledb_catalog.dimension_slice ds JOIN _timescaledb_catalog.chunk_constraint cc ON cc.dimension_slice_id = ds.id WHERE cc.chunk_id = :'CHUNK_ID'; SELECT count(*) = 0 FROM pg_constraint WHERE contype = 'f' AND confrelid = :'CHUNK_NAME'::regclass::oid; DROP TABLE detach_test_ref; -- Verify new rows do not go to the detached chunk SELECT count(*) AS "DETACHED_CHUNK_ROWS" FROM :CHUNK_NAME; \gset INSERT INTO detach_test VALUES (4, '2025-06-01 09:00:00-8', 1, 50.0); SELECT count(*) = :'DETACHED_CHUNK_ROWS' FROM :CHUNK_NAME; -- Verify detach can rollback SELECT count(*) AS "PREV_CHUNK_ROWS" FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; \gset BEGIN; SELECT schema_name || '.' || table_name AS "ROLLBACK_CHUNK" FROM _timescaledb_functions.show_chunk((SELECT * FROM show_chunks('detach_test') LIMIT 1)); \gset CALL detach_chunk(:'ROLLBACK_CHUNK'); ROLLBACK; SELECT count(*) = :PREV_CHUNK_ROWS FROM _timescaledb_catalog.chunk WHERE hypertable_id = :'HYPERTABLE_ID'; -- Error cases \set ON_ERROR_STOP 0 CALL detach_chunk(98765); CALL detach_chunk(0); CALL detach_chunk('detach_test'); CALL detach_chunk(NULL); -- Detach a regular table CREATE TABLE regular_table(time timestamptz, temp float); CALL detach_chunk('regular_table'); -- Try to detach already detached chunk CALL detach_chunk(:'CHUNK_NAME'); \set ON_ERROR_STOP 1 -- Compressed chunks ALTER TABLE detach_test SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device' ); SELECT schema_name || '.' || table_name AS "COMPRESSED_CHUNK" FROM _timescaledb_functions.show_chunk((SELECT * FROM show_chunks('detach_test') LIMIT 1)); \gset SELECT compress_chunk(:'COMPRESSED_CHUNK'); -- Try to detach compressed chunk (should fail) \set ON_ERROR_STOP 0 CALL detach_chunk(:'COMPRESSED_CHUNK'); \set ON_ERROR_STOP 1 DROP TABLE :CHUNK_NAME; DROP TABLE detach_test; DROP TABLE devices CASCADE; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/direct_compress_copy.sql��������������������������������������������0000664�0000000�0000000�00000024320�15100345067�0023374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser for copy from program \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE metrics (time TIMESTAMPTZ NOT NULL, device TEXT, value float) WITH (tsdb.hypertable, tsdb.partition_column = 'time', tsdb.orderby='time'); -- first try without the GUCs BEGIN; COPY metrics FROM PROGRAM 'seq 100 | xargs -II date -d "2025-01-01 + I hour" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; ROLLBACK; SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_sort_batches = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; -- simple test with compressed copy enabled BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; ROLLBACK; -- simple test with compressed copy enabled and reversed order BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; ROLLBACK; SET timescaledb.enable_direct_compress_copy_sort_batches = false; -- simple test with compressed copy enabled and without batch sorting BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; ROLLBACK; -- simple test with compressed copy enabled and reversed order and no batch sorting BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; ROLLBACK; -- test compressing into uncompressed chunk RESET timescaledb.enable_direct_compress_copy; RESET timescaledb.enable_direct_compress_copy_sort_batches; RESET timescaledb.enable_direct_compress_copy_client_sorted; BEGIN; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 + I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- simple test with compressed copy enabled and reversed order BEGIN; SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- status should be 9 SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- simple test with compressed copy enabled and no presorted BEGIN; SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics FROM PROGRAM 'seq 3000 | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,d1,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- status should be 11 SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test with segmentby BEGIN; ALTER TABLE metrics SET (tsdb.segmentby = 'device'); SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics FROM PROGRAM 'seq 0 0.2 9.8 | sed -e ''s!.[0-9]$!!'' | xargs -II date -d "2025-01-01 - I minute" +"%Y-%m-%d %H:%M:%S,dI,0.I"' WITH (FORMAT CSV); EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT format('%I.%I',schema_name,table_name) AS "COMPRESSED_CHUNK" FROM _timescaledb_catalog.chunk where compressed_chunk_id IS NULL \gset -- should have 10 batches SELECT count(*) FROM :COMPRESSED_CHUNK; ROLLBACK; -- test unique constraints prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_copy = true; ALTER TABLE metrics ADD CONSTRAINT unique_time_device UNIQUE (time, device); COPY metrics FROM STDIN WITH (FORMAT CSV); 2025-01-01,d1,0.3 \. EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test triggers prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_copy = true; CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER metrics_trigger BEFORE INSERT OR UPDATE ON metrics FOR EACH ROW EXECUTE FUNCTION test_trigger(); COPY metrics FROM STDIN WITH (FORMAT CSV); 2025-01-01,d1,0.3 \. EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test caggs prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_copy = true; CREATE MATERIALIZED VIEW metrics_cagg WITH (tsdb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, device, avg(value) AS avg_value FROM metrics GROUP BY bucket, device WITH NO DATA; COPY metrics FROM STDIN WITH (FORMAT CSV); 2025-01-01,d1,0.3 \. EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test chunk status handling CREATE TABLE metrics_status(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time'); -- normal insert should result in chunk status 0 INSERT INTO metrics_status SELECT '2025-01-01'; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; BEGIN; -- compressed copy into uncompressed chunk should result in chunk status 11 (compressed,partial,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics_status FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; -- compressed sorted copy into uncompressed chunk should result in chunk status 9 (compressed,partial) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics_status FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; TRUNCATE metrics_status; BEGIN; -- compressed copy into new chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics_status FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; -- compressed sorted copy into new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics_status FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; SET timescaledb.enable_direct_compress_copy = false; SET timescaledb.enable_direct_compress_copy_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'; SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; SELECT compress_chunk(show_chunks('metrics_status')); SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; BEGIN; -- compressed copy into fully compressed chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY metrics_status FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; -- compressed copy new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY metrics_status FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; SELECT tableoid::regclass AS "CHUNK" FROM metrics_status WHERE time = '2025-01-01' LIMIT 1 \gset -- repeat tests with direct reference to chunk BEGIN; -- compressed copy into fully compressed chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = false; COPY :CHUNK FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(:'CHUNK'::regclass); ROLLBACK; BEGIN; -- compressed copy new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_copy = true; SET timescaledb.enable_direct_compress_copy_client_sorted = true; COPY :CHUNK FROM STDIN; 2025-01-01 \. SELECT _timescaledb_functions.chunk_status_text(:'CHUNK'::regclass); ROLLBACK; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/direct_compress_insert.sql������������������������������������������0000664�0000000�0000000�00000034003�15100345067�0023725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics (time TIMESTAMPTZ NOT NULL, device TEXT, value float) WITH (tsdb.hypertable, tsdb.orderby='time'); -- first try without the GUCs BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' hour')::interval, 'd1', i::float FROM generate_series(0,100) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- should have no status aka normal uncompressed chunk SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_sort_batches = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; -- EXPLAIN with too small batch EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) INSERT INTO metrics SELECT '2025-01-01'::timestamptz, 'd1', i::float FROM generate_series(0,5) i; -- EXPLAIN with large enough batch EXPLAIN (BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) INSERT INTO metrics SELECT '2025-01-01'::timestamptz, 'd1', i::float FROM generate_series(0,500) i; -- simple test with compressed insert enabled BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- simple test with compressed insert enabled and reversed order BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; SET timescaledb.enable_direct_compress_insert_sort_batches = false; -- simple test with compressed insert enabled and without batch sorting BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- simple test with compressed insert enabled and reversed order and no batch sorting BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT first(time,rn), last(time,rn) FROM (SELECT ROW_NUMBER() OVER () as rn, time FROM metrics) sub; -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- test compressing into uncompressed chunk RESET timescaledb.enable_direct_compress_insert; RESET timescaledb.enable_direct_compress_insert_sort_batches; RESET timescaledb.enable_direct_compress_insert_client_sorted; BEGIN; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- since the chunks are new status should be COMPRESSED, PARTIAL SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- simple test with compressed insert enabled and reversed order BEGIN; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- since the chunks are new status should be COMPRESSED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- simple test with compressed insert enabled and no presorted BEGIN; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- since the chunks are new status should be COMPRESSED, UNORDERED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- simple test with compressed insert enabled and no presorted and with uncompressed data BEGIN; SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics SELECT '2025-01-01'::timestamptz, 'd1', 0; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,3000) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; -- since the chunks are new status should be COMPRESSED, UNORDERED, PARTIAL SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- test with segmentby BEGIN; ALTER TABLE metrics SET (tsdb.segmentby = 'device'); SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics SELECT '2025-01-01'::timestamptz - (i || ' minute')::interval, floor(i), i::float FROM generate_series(0.0,9.8,0.2) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT format('%I.%I',schema_name,table_name) AS "COMPRESSED_CHUNK" FROM _timescaledb_catalog.chunk where compressed_chunk_id IS NULL \gset -- should have 10 batches SELECT count(*) FROM :COMPRESSED_CHUNK; -- since the chunks are new status should be COMPRESSED SELECT DISTINCT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics') chunk; ROLLBACK; -- test unique constraints prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_insert = true; ALTER TABLE metrics ADD CONSTRAINT unique_time_device UNIQUE (time, device); INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,100) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test triggers prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_insert = true; CREATE OR REPLACE FUNCTION test_trigger() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql; CREATE TRIGGER metrics_trigger BEFORE INSERT OR UPDATE ON metrics FOR EACH ROW EXECUTE FUNCTION test_trigger(); INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,100) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test caggs prevent direct compress BEGIN; SET timescaledb.enable_direct_compress_insert = true; CREATE MATERIALIZED VIEW metrics_cagg WITH (tsdb.continuous) AS SELECT time_bucket('1 hour', time) AS bucket, device, avg(value) AS avg_value FROM metrics GROUP BY bucket, device WITH NO DATA; INSERT INTO metrics SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval, 'd1', i::float FROM generate_series(0,100) i; EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, SUMMARY OFF, TIMING OFF) SELECT * FROM metrics; SELECT DISTINCT status FROM _timescaledb_catalog.chunk WHERE compressed_chunk_id IS NOT NULL; ROLLBACK; -- test chunk status handling CREATE TABLE metrics_status(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time'); INSERT INTO metrics_status SELECT '2025-01-01'; -- normal insert should result in chunk status 0 SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; SET timescaledb.enable_direct_compress_insert = true; BEGIN; INSERT INTO metrics_status SELECT '2025-01-01' FROM generate_series(1,9); -- small insert batches should not result in compressed chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; INSERT INTO metrics_status SELECT '2025-01-01' FROM generate_series(1,10); -- status should be COMPRESSED, UNORDERED, PARTIAL since we have more than 10 rows in the chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; -- compressed sorted copy into uncompressed chunk should result in chunk status 9 (compressed,partial) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, PARTIAL SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; TRUNCATE metrics_status; BEGIN; -- compressed insert into new chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, UNORDERED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; -- compressed sorted copy into new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; SET timescaledb.enable_direct_compress_insert = false; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'; -- no status aka normal uncompressed chunk SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; SELECT compress_chunk(show_chunks('metrics_status')); -- status should be COMPRESSED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; BEGIN; -- compressed insert into fully compressed chunk should result in chunk status 3 (compressed,unordered) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = false; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, UNORDERED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; BEGIN; -- compressed insert new chunk should result in chunk status 1 (compressed) SET timescaledb.enable_direct_compress_insert = true; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO metrics_status SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_status') chunk; ROLLBACK; -- test direct compress into chunk directly CREATE TABLE metrics_chunk(time timestamptz) WITH (tsdb.hypertable,tsdb.partition_column='time'); SET timescaledb.enable_direct_compress_insert = true; -- create uncompressed chunk INSERT INTO metrics_chunk SELECT '2025-01-01'; -- status should be normal uncompressed chunk since it was single tuple insert SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_chunk') chunk; SELECT show_chunks('metrics_chunk') AS "CHUNK" \gset EXPLAIN (costs off,summary off,timing off) INSERT INTO :CHUNK SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; BEGIN; INSERT INTO :CHUNK SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, UNORDERED, PARTIAL SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_chunk') chunk; -- delete should propagate to compressed chunk SELECT count(*) FROM :CHUNK; EXPLAIN (analyze,buffers off,costs off,summary off,timing off) DELETE FROM :CHUNK WHERE time > '2025-01-01'::timestamptz; SELECT count(*) FROM :CHUNK; ROLLBACK; BEGIN; SET timescaledb.enable_direct_compress_insert_client_sorted = true; INSERT INTO :CHUNK SELECT '2025-01-01'::timestamptz + (i || ' minute')::interval FROM generate_series(0,100) i; -- status should be COMPRESSED, PARTIAL SELECT _timescaledb_functions.chunk_status_text(chunk) FROM show_chunks('metrics_chunk') chunk; ROLLBACK; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/exp_cagg_monthly.sql������������������������������������������������0000664�0000000�0000000�00000046656�15100345067�0022524�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); -- Check that buckets like '1 month 15 days' (fixed-sized + variable-sized) are not allowed \set ON_ERROR_STOP 0 -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; \set ON_ERROR_STOP 1 -- Make sure it's possible to create an empty cagg (WITH NO DATA) and -- that all the information about the bucketing function will be saved -- to the TS catalog. CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT mat_hypertable_id AS cagg_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary' \gset SELECT raw_hypertable_id AS ht_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary' \gset \pset null <NULL> SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id; \pset null "" -- Check that the saved invalidation threshold is -infinity SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure truncating of the refresh window works \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('conditions_summary', '2021-07-02', '2021-07-12'); \set ON_ERROR_STOP 1 -- Make sure refreshing works CALL refresh_continuous_aggregate('conditions_summary', '2021-06-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Make sure larger refresh window is fine too CALL refresh_continuous_aggregate('conditions_summary', '2021-03-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Special check for "invalid or missing information about the bucketing -- function" code path \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER CREATE TEMPORARY TABLE restore_table ( LIKE _timescaledb_catalog.continuous_aggs_bucket_function ); INSERT INTO restore_table SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function; DELETE FROM _timescaledb_catalog.continuous_aggs_bucket_function; \set ON_ERROR_STOP 0 -- should fail with "invalid or missing information..." CALL refresh_continuous_aggregate('conditions_summary', '2021-06-01', '2021-07-01'); \set ON_ERROR_STOP 1 INSERT INTO _timescaledb_catalog.continuous_aggs_bucket_function SELECT * FROM restore_table; DROP TABLE restore_table; -- should execute successfully CALL refresh_continuous_aggregate('conditions_summary', '2021-06-01', '2021-07-01'); SET ROLE :ROLE_DEFAULT_PERM_USER; -- Check the invalidation threshold SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Add some dummy data for two more months and call refresh (no invalidations test case) INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-07-01' :: date, '2021-08-31', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; -- Double check generated data SELECT to_char(day, 'YYYY-MM-DD'), city, temperature FROM conditions WHERE day >= '2021-07-01' ORDER BY city DESC, day; -- Make sure the invalidation threshold was unaffected SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure the invalidation log is empty SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Call refresh CALL refresh_continuous_aggregate('conditions_summary', '2021-06-15', '2021-09-15'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Make sure the invalidation threshold has changed SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure the catalog is cleaned up when the cagg is dropped DROP MATERIALIZED VIEW conditions_summary; SELECT count(*) FROM _timescaledb_catalog.continuous_agg WHERE mat_hypertable_id = :cagg_id; SELECT count(*) FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id; -- Re-create cagg, this time WITH DATA SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; -- Make sure cagg was filled SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Check the invalidation. -- Step 1/2. Insert some more data , do a refresh and make sure that the -- invalidation log is empty. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-09-01' :: date, '2021-09-15', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; CALL refresh_continuous_aggregate('conditions_summary', '2021-09-01', '2021-10-01'); SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Step 2/2. Add more data below the invalidation threshold, make sure that the -- invalidation log is not empty, that do a refresh. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, (CASE WHEN city = 'Moscow' THEN -40 ELSE 40 END) FROM generate_series('2021-09-16' :: date, '2021-09-30', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'UTC' AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'UTC' AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; CALL refresh_continuous_aggregate('conditions_summary', '2021-09-01', '2021-10-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Create a real-time aggregate DROP MATERIALIZED VIEW conditions_summary; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Add some data to the hypertable and make sure they are visible in the cagg INSERT INTO conditions (day, city, temperature) VALUES ('2021-10-01', 'Moscow', 1), ('2021-10-02', 'Moscow', 2), ('2021-10-03', 'Moscow', 3), ('2021-10-04', 'Moscow', 4), ('2021-10-01', 'Berlin', 5), ('2021-10-02', 'Berlin', 6), ('2021-10-03', 'Berlin', 7), ('2021-10-04', 'Berlin', 8); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary', '2021-10-01', '2021-11-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions (day, city, temperature) VALUES ('2021-11-01', 'Moscow', 11), ('2021-11-02', 'Moscow', 12), ('2021-11-03', 'Moscow', 13), ('2021-11-04', 'Moscow', 14), ('2021-11-01', 'Berlin', 15), ('2021-11-02', 'Berlin', 16), ('2021-11-03', 'Berlin', 17), ('2021-11-04', 'Berlin', 18); ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions') AS ch; -- Data for 2021-11 is seen because the cagg is real-time SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; CALL refresh_continuous_aggregate('conditions_summary', '2021-11-01', '2021-12-01'); -- Data for 2021-11 is seen because the cagg was refreshed SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary ORDER by month, city; -- Test N-months buckets where N in 2,3,4,5,6,12,13 on a relatively large table -- This also tests the case when a single hypertable has multiple caggs. CREATE TABLE conditions_large( day DATE NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_large', 'day', chunk_time_interval => INTERVAL '1 month' ); INSERT INTO conditions_large(day, temperature) SELECT ts, date_part('month', ts)*100 + date_part('day', ts) FROM generate_series('2010-01-01' :: date, '2020-01-01' :: date - interval '1 day', '1 day') as ts; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_2m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('2 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_2m ORDER BY bucket; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_3m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('3 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_3m ORDER BY bucket; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_4m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('4 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_4m ORDER BY bucket; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_5m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('5 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_5m ORDER BY bucket; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_6m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('6 months', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_6m ORDER BY bucket; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_1y WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('1 year', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_1y ORDER BY bucket; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_1y1m WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT timescaledb_experimental.time_bucket_ng('1 year 1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_1y1m ORDER BY bucket; -- Trigger merged refresh to check corresponding code path as well DROP MATERIALIZED VIEW conditions_large_1y; SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_large_1y WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT timescaledb_experimental.time_bucket_ng('1 year', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_large GROUP BY bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_large_1y ORDER BY bucket; INSERT INTO conditions_large(day, temperature) SELECT ts, date_part('month', ts)*100 + date_part('day', ts) FROM generate_series('2020-01-01' :: date, '2021-01-01' :: date - interval '1 day', '1 day') as ts; CALL refresh_continuous_aggregate('conditions_large_1y', '2020-01-01', '2021-01-01'); SELECT * FROM conditions_large_1y ORDER BY bucket; -- Test the specific code path of creating a CAGG on top of empty hypertable. CREATE TABLE conditions_empty( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_empty', 'day', chunk_time_interval => INTERVAL '1 day' ); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_empty WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_empty GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER by month, city; -- The test above changes the record that gets added to the invalidation log -- for an empty table. Make sure it doesn't have any unintended side-effects -- and the refreshing works as expected. INSERT INTO conditions_empty (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); CALL refresh_continuous_aggregate('conditions_summary_empty', '2021-06-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER by month, city; -- Make sure add_continuous_aggregate_policy() works CREATE TABLE conditions_policy( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_policy', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions_policy (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_policy WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_policy GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_summary_policy; \set ON_ERROR_STOP 0 -- Check for "policy refresh window too small" error SELECT add_continuous_aggregate_policy('conditions_summary_policy', -- Historically, 1 month is just a synonym to 30 days here. -- See interval_to_int64() and interval_to_int128(). start_offset => INTERVAL '2 months', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '65 days', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour') AS job_id \gset SELECT delete_job(:job_id); SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '2 months', end_offset => INTERVAL '0 months', schedule_interval => INTERVAL '1 hour') AS job_id \gset SELECT delete_job(:job_id); \set ON_ERROR_STOP 0 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '2 months', end_offset => INTERVAL '1 months', schedule_interval => INTERVAL '1 hour'); \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '3 months', end_offset => INTERVAL '1 months', schedule_interval => INTERVAL '1 hour'); ����������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/exp_cagg_next_gen.sql�����������������������������������������������0000664�0000000�0000000�00000013404�15100345067�0022622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Make sure experimental immutable function with 2 arguments can be used in caggs. -- Functions with 3 arguments and/or stable functions are currently not supported in caggs. CREATE TABLE conditions( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT to_char(bucket, 'YYYY-MM-DD'), city, min, max FROM conditions_summary_weekly ORDER BY bucket; DROP TABLE conditions CASCADE; -- Make sure seconds, minutes, and hours can be used with caggs ('origin' is not -- currently supported in caggs). CREATE TABLE conditions( tstamp TIMESTAMP NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions (tstamp, city, temperature) VALUES ('2021-06-14 12:30:00', 'Moscow', 26), ('2021-06-14 12:30:10', 'Moscow', 22), ('2021-06-14 12:30:20', 'Moscow', 24), ('2021-06-14 12:30:30', 'Moscow', 24), ('2021-06-14 12:30:40', 'Moscow', 27), ('2021-06-14 12:30:50', 'Moscow', 28), ('2021-06-14 12:31:10', 'Moscow', 30), ('2021-06-14 12:31:20', 'Moscow', 31), ('2021-06-14 12:31:30', 'Moscow', 34), ('2021-06-14 12:31:40', 'Moscow', 34), ('2021-06-14 12:31:50', 'Moscow', 34), ('2021-06-14 12:32:00', 'Moscow', 32), ('2021-06-14 12:32:10', 'Moscow', 32), ('2021-06-14 12:32:20', 'Moscow', 31); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_30sec WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('30 seconds', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; CREATE MATERIALIZED VIEW conditions_summary_1min WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 minute', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; CREATE MATERIALIZED VIEW conditions_summary_1hour WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 hour', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD HH:mi:ss'), min, max FROM conditions_summary_30sec ORDER BY bucket; SELECT city, to_char(bucket, 'YYYY-MM-DD HH:mi:ss'), min, max FROM conditions_summary_1min ORDER BY bucket; SELECT city, to_char(bucket, 'YYYY-MM-DD HH:mi:ss'), min, max FROM conditions_summary_1hour ORDER BY bucket; DROP TABLE conditions CASCADE; -- Experimental functions using different schema for installation than PUBLIC \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER CREATE SCHEMA test1; SET client_min_messages TO ERROR; CREATE EXTENSION timescaledb SCHEMA test1; CREATE TABLE conditions( tstamp TIMESTAMP NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT test1.create_hypertable( 'conditions', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_monthly WITH (timescaledb.continuous) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; CREATE MATERIALIZED VIEW conditions_summary_yearly WITH (timescaledb.continuous) AS SELECT city, test1.time_bucket('1 year', tstamp) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function ORDER BY 1; -- Try to toggle realtime feature on existing CAgg using timescaledb_experimental.time_bucket_ng ALTER MATERIALIZED VIEW conditions_summary_monthly SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW conditions_summary_monthly SET (timescaledb.materialized_only=true); \c :TEST_DBNAME :ROLE_SUPERUSER DROP DATABASE :TEST_DBNAME_2 WITH (FORCE); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/exp_cagg_origin.sql�������������������������������������������������0000664�0000000�0000000�00000052006�15100345067�0022303�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); \set ON_ERROR_STOP 0 -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; -- Make sure 'infinity' can't be specified as an origin CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, 'infinity' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- Make sure buckets like '1 months 15 days" (fixed+variable-sized) are not allowed CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', day, '2021-06-01') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; \set ON_ERROR_STOP 1 CREATE MATERIALIZED VIEW conditions_summary_weekly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, '2000-01-03' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT to_char(bucket, 'YYYY-MM-DD'), city, min, max FROM conditions_summary_weekly ORDER BY bucket; SELECT mat_hypertable_id AS cagg_id, raw_hypertable_id AS ht_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_weekly' \gset -- Make sure truncating of the refresh window works \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('conditions_summary_weekly', '2021-06-14', '2021-06-20'); \set ON_ERROR_STOP 1 -- Make sure refreshing works CALL refresh_continuous_aggregate('conditions_summary_weekly', '2021-06-14', '2021-06-21'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS week, min, max FROM conditions_summary_weekly ORDER BY week, city; -- Check the invalidation threshold SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Add some dummy data for two more weeks and call refresh (no invalidations test case) INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-06-28' :: date, '2021-07-11', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; -- Double check generated data SELECT to_char(day, 'YYYY-MM-DD'), city, temperature FROM conditions WHERE day >= '2021-06-28' ORDER BY city DESC, day; -- Make sure the invalidation threshold was unaffected SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure the invalidation log is empty SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Call refresh CALL refresh_continuous_aggregate('conditions_summary_weekly', '2021-06-28', '2021-07-12'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS week, min, max FROM conditions_summary_weekly ORDER BY week, city; -- Make sure the invalidation threshold has changed SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'UTC' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Check if CREATE MATERIALIZED VIEW ... WITH DATA works. -- Use monthly buckets this time and specify June 2000 as an origin. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_monthly WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2000-06-01' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_monthly ORDER BY month, city; -- Check the invalidation. -- Step 1/2. Insert some more data , do a refresh and make sure that the -- invalidation log is empty. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, row_number() OVER () FROM generate_series('2021-09-01' :: date, '2021-09-15', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; CALL refresh_continuous_aggregate('conditions_summary_monthly', '2021-09-01', '2021-10-01'); SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_monthly ORDER BY month, city; -- Step 2/2. Add more data below the invalidation threshold, make sure that the -- invalidation log is not empty, then do a refresh. INSERT INTO conditions (day, city, temperature) SELECT ts :: date, city, (CASE WHEN city = 'Moscow' THEN -40 ELSE 40 END) FROM generate_series('2021-09-16' :: date, '2021-09-30', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'UTC' AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'UTC' AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; CALL refresh_continuous_aggregate('conditions_summary_monthly', '2021-09-01', '2021-10-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_monthly ORDER BY month, city; SELECT _timescaledb_functions.to_timestamp(lowest_modified_value) AS lowest, _timescaledb_functions.to_timestamp(greatest_modified_value) AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Create a real-time aggregate with custom origin - June 2000 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_rt WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2000-06-01' :: date) AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; -- Add some data to the hypertable and make sure it is visible in the cagg INSERT INTO conditions (day, city, temperature) VALUES ('2021-10-01', 'Moscow', 1), ('2021-10-02', 'Moscow', 2), ('2021-10-03', 'Moscow', 3), ('2021-10-04', 'Moscow', 4), ('2021-10-01', 'Berlin', 5), ('2021-10-02', 'Berlin', 6), ('2021-10-03', 'Berlin', 7), ('2021-10-04', 'Berlin', 8); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_rt', '2021-10-01', '2021-11-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions (day, city, temperature) VALUES ('2021-11-01', 'Moscow', 11), ('2021-11-02', 'Moscow', 12), ('2021-11-03', 'Moscow', 13), ('2021-11-04', 'Moscow', 14), ('2021-11-01', 'Berlin', 15), ('2021-11-02', 'Berlin', 16), ('2021-11-03', 'Berlin', 17), ('2021-11-04', 'Berlin', 18); ALTER TABLE conditions SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions') AS ch; -- Data for 2021-11 is seen because the cagg is real-time SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; CALL refresh_continuous_aggregate('conditions_summary_rt', '2021-11-01', '2021-12-01'); -- Data for 2021-11 is seen because the cagg was refreshed SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_rt ORDER BY month, city; -- Clean up DROP TABLE conditions CASCADE; -- Test the specific code path of creating a CAGG on top of empty hypertable. CREATE TABLE conditions_empty( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_empty', 'day', chunk_time_interval => INTERVAL '1 day' ); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_empty WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2005-02-01') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_empty GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER BY month, city; -- The test above changes the record that gets added to the invalidation log -- for an empty table. Make sure it doesn't have any unintended side-effects -- and the refreshing works as expected. INSERT INTO conditions_empty (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); CALL refresh_continuous_aggregate('conditions_summary_empty', '2021-06-01', '2021-07-01'); SELECT city, to_char(bucket, 'YYYY-MM-DD') AS month, min, max FROM conditions_summary_empty ORDER BY month, city; -- Clean up DROP TABLE conditions_empty CASCADE; -- Make sure add_continuous_aggregate_policy() works CREATE TABLE conditions_policy( day DATE NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_policy', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions_policy (day, city, temperature) VALUES ('2021-06-14', 'Moscow', 26), ('2021-06-15', 'Moscow', 22), ('2021-06-16', 'Moscow', 24), ('2021-06-17', 'Moscow', 24), ('2021-06-18', 'Moscow', 27), ('2021-06-19', 'Moscow', 28), ('2021-06-20', 'Moscow', 30), ('2021-06-21', 'Moscow', 31), ('2021-06-22', 'Moscow', 34), ('2021-06-23', 'Moscow', 34), ('2021-06-24', 'Moscow', 34), ('2021-06-25', 'Moscow', 32), ('2021-06-26', 'Moscow', 32), ('2021-06-27', 'Moscow', 31); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_policy WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, '2005-03-01') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_policy GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT * FROM conditions_summary_policy; \set ON_ERROR_STOP 0 -- Check for "policy refresh window too small" error SELECT add_continuous_aggregate_policy('conditions_summary_policy', -- Historically, 1 month is just a synonym to 30 days here. -- See interval_to_int64() and interval_to_int128(). start_offset => INTERVAL '2 months', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '65 days', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); -- Clean up DROP TABLE conditions_policy CASCADE; -- Make sure CAGGs with custom origin work for timestamp type CREATE TABLE conditions_timestamp( tstamp TIMESTAMP NOT NULL, city TEXT NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_timestamp', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_timestamp WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('12 hours', tstamp, '2000-06-01 12:00:00') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamp GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; -- Add some data to the hypertable and make sure it is visible in the cagg INSERT INTO conditions_timestamp(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts)*100 + date_part('hour', ts) FROM generate_series('2010-01-01 00:00:00' :: timestamp, '2010-01-02 00:00:00' :: timestamp - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_timestamp', '2010-01-01 00:00:00', '2010-01-02 00:00:00'); SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions_timestamp(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts)*100 + date_part('hour', ts) FROM generate_series('2010-01-02 00:00:00' :: timestamp, '2010-01-03 00:00:00' :: timestamp - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; ALTER TABLE conditions_timestamp SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions_timestamp') AS ch; -- New data is seen because the cagg is real-time SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; CALL refresh_continuous_aggregate('conditions_summary_timestamp', '2010-01-02 00:00:00', '2010-01-03 00:00:00'); -- New data is seen because the cagg was refreshed SELECT city, to_char(bucket, 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamp ORDER BY b, city; -- Add a refresh policy SELECT add_continuous_aggregate_policy('conditions_summary_timestamp', start_offset => INTERVAL '25 hours', end_offset => INTERVAL '1 hour', schedule_interval => INTERVAL '30 minutes'); -- Clean up DROP TABLE conditions_timestamp CASCADE; -- Make sure CAGGs with custom origin work for timestamptz type CREATE TABLE conditions_timestamptz( tstamp TIMESTAMPTZ NOT NULL, city TEXT NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_timestamptz', 'tstamp', chunk_time_interval => INTERVAL '1 day' ); -- Add some data to the hypertable and make sure it is visible in the cagg INSERT INTO conditions_timestamptz(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts at time zone 'MSK')*100 + date_part('hour', ts at time zone 'MSK') FROM generate_series('2022-01-01 00:00:00 MSK' :: timestamptz, '2022-01-02 00:00:00 MSK' :: timestamptz - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; \set ON_ERROR_STOP 0 SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; -- For monthly buckets origin should be the first day of the month in given timezone -- 2020-06-02 00:00:00 MSK == 2020-06-01 21:00:00 UTC CREATE MATERIALIZED VIEW conditions_summary_timestamptz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', tstamp, '2020-06-02 00:00:00 MSK', 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamptz GROUP BY city, bucket; -- Make sure buckets like '1 months 15 days" (fixed+variable-sized) are not allowed CREATE MATERIALIZED VIEW conditions_summary_timestamptz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', tstamp, '2020-06-01 00:00:00 MSK', 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamptz GROUP BY city, bucket; \set ON_ERROR_STOP 1 CREATE MATERIALIZED VIEW conditions_summary_timestamptz WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('12 hours', tstamp, '2020-06-01 12:00:00 MSK', 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_timestamptz GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_func; -- Make sure the origin is saved in the catalog table SELECT mat_hypertable_id AS cagg_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_timestamptz' \gset SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; -- Check the data SELECT to_char(tstamp at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS ts, city, temperature FROM conditions_timestamptz ORDER BY ts, city; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_timestamptz', '2022-01-01 00:00:00 MSK', '2022-01-02 00:00:00 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions_timestamptz(tstamp, city, temperature) SELECT ts, city, (CASE WHEN city = 'Moscow' THEN 20000 ELSE 10000 END) + date_part('day', ts at time zone 'MSK')*100 + date_part('hour', ts at time zone 'MSK') FROM generate_series('2022-01-02 00:00:00 MSK' :: timestamptz, '2022-01-03 00:00:00 MSK' :: timestamptz - interval '1 hour', '1 hour') as ts, unnest(array['Moscow', 'Berlin']) as city; ALTER TABLE conditions_timestamptz SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions_timestamptz') AS ch; -- New data is seen because the cagg is real-time SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; CALL refresh_continuous_aggregate('conditions_summary_timestamptz', '2022-01-02 00:00:00 MSK', '2022-01-03 00:00:00 MSK'); -- New data is seen because the cagg was refreshed SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS b, min, max FROM conditions_summary_timestamptz ORDER BY b, city; -- Add a refresh policy SELECT add_continuous_aggregate_policy('conditions_summary_timestamptz', start_offset => INTERVAL '25 hours', end_offset => INTERVAL '1 hour', schedule_interval => INTERVAL '30 minutes'); -- Clean up DROP TABLE conditions_timestamptz CASCADE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/exp_cagg_timezone.sql�����������������������������������������������0000664�0000000�0000000�00000044724�15100345067�0022656�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Make sure that timezone can't be used for types other that timestamptz CREATE TABLE conditions( day timestamp NOT NULL, -- not timestamptz! city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions', 'day', chunk_time_interval => INTERVAL '1 day' ); \set ON_ERROR_STOP 0 -- timebucket_ng is deprecated and can not be used in new CAggs anymore. -- However, using this GUC the restriction can be lifted in debug builds -- to ensure the functionality can be tested. SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions GROUP BY city, bucket WITH NO DATA; -- Reset GUC to check if the CAgg would also work in release builds RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; \set ON_ERROR_STOP 1 DROP TABLE conditions CASCADE; CREATE TABLE conditions_tz( day timestamptz NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_tz', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions_tz (day, city, temperature) VALUES ('2021-06-14 00:00:00 MSK', 'Moscow', 26), ('2021-06-15 00:00:00 MSK', 'Moscow', 22), ('2021-06-16 00:00:00 MSK', 'Moscow', 24), ('2021-06-17 00:00:00 MSK', 'Moscow', 24), ('2021-06-18 00:00:00 MSK', 'Moscow', 27), ('2021-06-19 00:00:00 MSK', 'Moscow', 28), ('2021-06-20 00:00:00 MSK', 'Moscow', 30), ('2021-06-21 00:00:00 MSK', 'Moscow', 31), ('2021-06-22 00:00:00 MSK', 'Moscow', 34), ('2021-06-23 00:00:00 MSK', 'Moscow', 34), ('2021-06-24 00:00:00 MSK', 'Moscow', 34), ('2021-06-25 00:00:00 MSK', 'Moscow', 32), ('2021-06-26 00:00:00 MSK', 'Moscow', 32), ('2021-06-27 00:00:00 MSK', 'Moscow', 31); \set ON_ERROR_STOP 0 -- Check that the name of the timezone is validated SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'Europe/Ololondon') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; -- Check that buckets like '1 month 15 days' (fixed-sized + variable-sized) are not allowed CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month 15 days', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; -- Check that only immutable expressions can be used as a timezone CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 day', day, city) AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; \set ON_ERROR_STOP 1 -- Make sure it's possible to create an empty cagg (WITH NO DATA) and -- that all the information about the bucketing function will be saved -- to the TS catalog. CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT mat_hypertable_id AS cagg_id_tz, raw_hypertable_id AS ht_id FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_tz' \gset -- Make sure the timezone is saved in the catalog table SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id_tz; -- Make sure that buckets with specified timezone are always treated as -- variable-sized, even if the interval is fixed (i.e. days and/or hours) SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_1w WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket WITH NO DATA; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT mat_hypertable_id AS cagg_id_1w FROM _timescaledb_catalog.continuous_agg WHERE user_view_name = 'conditions_summary_1w' \gset -- Make sure the timezone is saved in the catalog table SELECT bucket_func, bucket_width, bucket_origin, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :cagg_id_1w; -- Check the invalidation threshold is -infinity SELECT _timescaledb_functions.to_timestamp(watermark) at time zone 'MSK' FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure the invalidation log is empty SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Make sure truncating of the refresh window works \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-07-02 MSK', '2021-07-12 MSK'); CALL refresh_continuous_aggregate('conditions_summary_1w', '2021-07-02 MSK', '2021-07-05 MSK'); \set ON_ERROR_STOP 1 -- Make sure refreshing works CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-06-01 MSK', '2021-07-01 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; -- Check the invalidation threshold SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- The default origin is Saturday. Here we do refresh only for two full weeks -- in June in order to keep the invalidation threshold as it is. CALL refresh_continuous_aggregate('conditions_summary_1w', '2021-06-12 MSK', '2021-06-26 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as week, min, max FROM conditions_summary_1w ORDER by week, city; -- Check the invalidation threshold SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure creating CAGGs without NO DATA works the same way SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz2 ORDER by month, city; -- Add some dummy data for two more months (no invalidations test case) INSERT INTO conditions_tz (day, city, temperature) SELECT ts, city, row_number() OVER () FROM generate_series('2021-07-01 MSK' :: timestamptz, '2021-08-31 MSK', '3 day') as ts, unnest(array['Moscow', 'Berlin']) as city; -- Double check the generated data SELECT to_char(day at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS'), city, temperature FROM conditions_tz WHERE day >= '2021-07-01 MSK' ORDER BY city DESC, day; -- Make sure the invalidation threshold was unaffected SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure the invalidation log is still empty SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Call refresh for two full buckets: 2021-07-01 and 2021-08-01 CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-06-15 MSK', '2021-09-15 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; -- Make sure the invalidation threshold has changed SELECT to_char(_timescaledb_functions.to_timestamp(watermark) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :ht_id; -- Make sure the invalidation log is still empty SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Add more data below the invalidation threshold, make sure that the -- invalidation log is not empty, then do a refresh. INSERT INTO conditions_tz (day, city, temperature) SELECT ts :: timestamptz, city, (CASE WHEN city = 'Moscow' THEN -100 ELSE 100 END) FROM generate_series('2021-08-16 MSK' :: timestamptz, '2021-08-30 MSK', '1 day') as ts, unnest(array['Moscow', 'Berlin']) as city; SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-08-01 MSK', '2021-09-01 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; SELECT to_char(_timescaledb_functions.to_timestamp(lowest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS lowest, to_char(_timescaledb_functions.to_timestamp(greatest_modified_value) at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') AS greatest FROM _timescaledb_catalog.continuous_aggs_hypertable_invalidation_log WHERE hypertable_id = :ht_id; -- Clean up DROP MATERIALIZED VIEW conditions_summary_tz; DROP MATERIALIZED VIEW conditions_summary_1w; -- Create a real-time aggregate SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_tz WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 month', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_tz GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; -- Add some data to the hypertable and make sure they are visible in the cagg INSERT INTO conditions_tz (day, city, temperature) VALUES ('2021-10-01 00:00:00 MSK', 'Moscow', 1), ('2021-10-02 00:00:00 MSK', 'Moscow', 2), ('2021-10-03 00:00:00 MSK', 'Moscow', 3), ('2021-10-04 00:00:00 MSK', 'Moscow', 4), ('2021-10-01 00:00:00 MSK', 'Berlin', 5), ('2021-10-02 00:00:00 MSK', 'Berlin', 6), ('2021-10-03 00:00:00 MSK', 'Berlin', 7), ('2021-10-04 00:00:00 MSK', 'Berlin', 8); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; -- Refresh the cagg and make sure that the result of SELECT query didn't change CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-10-01 00:00:00 MSK', '2021-11-01 00:00:00 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; -- Add some more data, enable compression, compress the chunks and repeat the test INSERT INTO conditions_tz (day, city, temperature) VALUES ('2021-11-01 00:00:00 MSK', 'Moscow', 11), ('2021-11-02 00:00:00 MSK', 'Moscow', 12), ('2021-11-03 00:00:00 MSK', 'Moscow', 13), ('2021-11-04 00:00:00 MSK', 'Moscow', 14), ('2021-11-01 00:00:00 MSK', 'Berlin', 15), ('2021-11-02 00:00:00 MSK', 'Berlin', 16), ('2021-11-03 00:00:00 MSK', 'Berlin', 17), ('2021-11-04 00:00:00 MSK', 'Berlin', 18); ALTER TABLE conditions_tz SET ( timescaledb.compress, timescaledb.compress_segmentby = 'city' ); SELECT compress_chunk(ch) FROM show_chunks('conditions_tz') AS ch; -- Data for 2021-11 is seen because the cagg is real-time SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; CALL refresh_continuous_aggregate('conditions_summary_tz', '2021-11-01 00:00:00 MSK', '2021-12-01 00:00:00 MSK'); -- Data for 2021-11 is seen because the cagg was refreshed SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_tz ORDER by month, city; -- Test for some more cases: single CAGG per HT, creating CAGG on top of an -- empty HT, buckets other than 1 month. CREATE TABLE conditions2( day timestamptz NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions2', 'day', chunk_time_interval => INTERVAL '1 day' ); -- Create a real-time aggregate on top of empty HT SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions2_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT city, timescaledb_experimental.time_bucket_ng('7 days', day, 'MSK') AS bucket, MIN(temperature), MAX(temperature) FROM conditions2 GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; INSERT INTO conditions2 (day, city, temperature) VALUES ('2021-06-14 00:00:00 MSK', 'Moscow', 26), ('2021-06-15 00:00:00 MSK', 'Moscow', 22), ('2021-06-16 00:00:00 MSK', 'Moscow', 24), ('2021-06-17 00:00:00 MSK', 'Moscow', 24), ('2021-06-18 00:00:00 MSK', 'Moscow', 27), ('2021-06-19 00:00:00 MSK', 'Moscow', 28), ('2021-06-20 00:00:00 MSK', 'Moscow', 30), ('2021-06-21 00:00:00 MSK', 'Moscow', 31), ('2021-06-22 00:00:00 MSK', 'Moscow', 34), ('2021-06-23 00:00:00 MSK', 'Moscow', 34), ('2021-06-24 00:00:00 MSK', 'Moscow', 34), ('2021-06-25 00:00:00 MSK', 'Moscow', 32), ('2021-06-26 00:00:00 MSK', 'Moscow', 32), ('2021-06-27 00:00:00 MSK', 'Moscow', 31); -- All data should be seen for a real-time aggregate SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions2_summary ORDER by month, city; -- Refresh should work CALL refresh_continuous_aggregate('conditions2_summary', '2021-06-12 MSK', '2021-07-03 MSK'); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions2_summary ORDER by month, city; -- New data should be seen INSERT INTO conditions2 (day, city, temperature) VALUES ('2021-09-30 00:00:00 MSK', 'Moscow', 0), ('2021-10-01 00:00:00 MSK', 'Moscow', 1), ('2021-10-02 00:00:00 MSK', 'Moscow', 2), ('2021-10-03 00:00:00 MSK', 'Moscow', 3), ('2021-10-04 00:00:00 MSK', 'Moscow', 4), ('2021-09-30 00:00:00 MSK', 'Berlin', 5), ('2021-10-01 00:00:00 MSK', 'Berlin', 6), ('2021-10-02 00:00:00 MSK', 'Berlin', 7), ('2021-10-03 00:00:00 MSK', 'Berlin', 8), ('2021-10-04 00:00:00 MSK', 'Berlin', 9); SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions2_summary ORDER by month, city; -- Make sure add_continuous_aggregate_policy() works CREATE TABLE conditions_policy( day TIMESTAMPTZ NOT NULL, city text NOT NULL, temperature INT NOT NULL); SELECT create_hypertable( 'conditions_policy', 'day', chunk_time_interval => INTERVAL '1 day' ); INSERT INTO conditions_policy (day, city, temperature) VALUES ('2021-06-14 00:00:00 MSK', 'Moscow', 26), ('2021-06-14 10:00:00 MSK', 'Moscow', 22), ('2021-06-14 20:00:00 MSK', 'Moscow', 24), ('2021-06-15 00:00:00 MSK', 'Moscow', 24), ('2021-06-15 10:00:00 MSK', 'Moscow', 27), ('2021-06-15 20:00:00 MSK', 'Moscow', 28), ('2021-06-16 00:00:00 MSK', 'Moscow', 30), ('2021-06-16 10:00:00 MSK', 'Moscow', 31), ('2021-06-16 20:00:00 MSK', 'Moscow', 34), ('2021-06-17 00:00:00 MSK', 'Moscow', 34), ('2021-06-17 10:00:00 MSK', 'Moscow', 34), ('2021-06-17 20:00:00 MSK', 'Moscow', 32), ('2021-06-18 00:00:00 MSK', 'Moscow', 32), ('2021-06-18 10:00:00 MSK', 'Moscow', 31), ('2021-06-18 20:00:00 MSK', 'Moscow', 26); SET timescaledb.debug_allow_cagg_with_deprecated_funcs = true; CREATE MATERIALIZED VIEW conditions_summary_policy WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT city, timescaledb_experimental.time_bucket_ng('1 day', day, 'Europe/Moscow') AS bucket, MIN(temperature), MAX(temperature) FROM conditions_policy GROUP BY city, bucket; RESET timescaledb.debug_allow_cagg_with_deprecated_funcs; SELECT city, to_char(bucket at time zone 'MSK', 'YYYY-MM-DD HH24:MI:SS') as month, min, max FROM conditions_summary_policy ORDER by month, city; \set ON_ERROR_STOP 0 -- Check for "policy refresh window too small" error SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '2 days 23 hours', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); \set ON_ERROR_STOP 1 SELECT add_continuous_aggregate_policy('conditions_summary_policy', start_offset => INTERVAL '3 days', end_offset => INTERVAL '1 day', schedule_interval => INTERVAL '1 hour'); ��������������������������������������������timescaledb-2.23.0/tsl/test/sql/feature_flags.sql���������������������������������������������������0000664�0000000�0000000�00000007347�15100345067�0021776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timezone TO 'America/Los_Angeles'; -- hypertable creation SHOW timescaledb.enable_hypertable_create; SET timescaledb.enable_hypertable_create TO off; CREATE TABLE test(time timestamptz, device int); \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('test', 'time'); \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_create TO on; SELECT * FROM create_hypertable('test', 'time'); -- hypertable compression SHOW timescaledb.enable_hypertable_compression; SET timescaledb.enable_hypertable_compression TO off; INSERT INTO test SELECT t, 0 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-04 1:00', '1 hour') t; SELECT * FROM show_chunks('test'); -- compress_chunk \set ON_ERROR_STOP 0 SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_compression TO on; -- ensure compression cannot be enabled \set ON_ERROR_STOP 0 ALTER TABLE test SET (timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device'); \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_compression TO on; ALTER TABLE test SET (timescaledb.compress, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device'); SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); SET timescaledb.enable_hypertable_compression TO off; -- cannot alter compressed table \set ON_ERROR_STOP 0 ALTER TABLE test ADD COLUMN col1 boolean DEFAULT false NOT NULL; \set ON_ERROR_STOP 1 SET timescaledb.enable_hypertable_compression TO on; ALTER TABLE test ADD COLUMN col1 boolean DEFAULT false NOT NULL; SET timescaledb.enable_hypertable_compression TO off; \set ON_ERROR_STOP 0 ALTER TABLE test DROP COLUMN col1; \set ON_ERROR_STOP 1 -- cagg creation SHOW timescaledb.enable_cagg_create; SET timescaledb.enable_cagg_create TO off; \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW contagg WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS hour, device FROM test GROUP BY hour, device; \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_create TO on; CREATE MATERIALIZED VIEW contagg WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time) AS hour, device FROM test GROUP BY hour, device; SET timescaledb.enable_cagg_create TO off; \set ON_ERROR_STOP 0 CALL refresh_continuous_aggregate('contagg', NULL, NULL); \set ON_ERROR_STOP 1 SET timescaledb.enable_cagg_create TO on; -- policy creation SHOW timescaledb.enable_policy_create; SET timescaledb.enable_policy_create TO off; \set ON_ERROR_STOP 0 select add_retention_policy('test', INTERVAL '4 months', true); select remove_retention_policy('test'); select add_compression_policy('test', compress_after => NULL); SELECT remove_compression_policy('test'); SELECT add_continuous_aggregate_policy('contagg', '1 day'::interval, 10 , '1 h'::interval); SELECT remove_continuous_aggregate_policy('contagg'); CREATE INDEX idx ON test(device); SELECT add_reorder_policy('test', 'idx'); select remove_reorder_policy('test'); SELECT timescaledb_experimental.add_policies('test', refresh_start_offset => 1, refresh_end_offset => 10, compress_after => 11, drop_after => 20); SELECT timescaledb_experimental.show_policies('test'); SELECT timescaledb_experimental.alter_policies('test', refresh_start_offset => 11, compress_after=>13, drop_after => 25); SELECT timescaledb_experimental.remove_all_policies('test'); SELECT timescaledb_experimental.remove_policies('test', false, 'policy_refresh_continuous_aggregate', 'policy_compression'); \set ON_ERROR_STOP 1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/fixed_schedules.sql�������������������������������������������������0000664�0000000�0000000�00000007074�15100345067�0022322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; select '2023-01-02 11:53:19.059771+02'::timestamptz as finish_time \gset select :'finish_time'::timestamptz - interval '5 sec' as start_time \gset -- years select ts_test_next_scheduled_execution_slot('1 year', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "1 yr", ts_test_next_scheduled_execution_slot('1 year', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "1 yr timezone", ts_test_next_scheduled_execution_slot('10 year', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "10 yr", ts_test_next_scheduled_execution_slot('10 year', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "10 yr timezone"; -- weeks select ts_test_next_scheduled_execution_slot('1 week', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "1 week", ts_test_next_scheduled_execution_slot('1 week', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "1 week timezone", ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "2 week", ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "2 week timezone"; -- months select ts_test_next_scheduled_execution_slot('1 month', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "1 month", ts_test_next_scheduled_execution_slot('1 month', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "1 month timezone", ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'start_time'::timestamptz) as "2 month", ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'start_time'::timestamptz, 'Europe/Athens') as "2 month timezone"; -- timezone in Berlin changes between 1 and 2 am \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 hour\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 hour\'' \set START_TIME_BEFORE_SUMMER_SWITCH 'TIMESTAMPTZ \'2022-03-27 01:00:00\'' \set FINISH_TIME_AFTER_SUMMER_SWITCH 'TIMESTAMPTZ \'2022-03-27 01:19:20\'' \set START_TIME_BEFORE_WINTER_SWITCH 'TIMESTAMPTZ \'2022-10-30 01:01:00\'' \set FINISH_TIME_AFTER_WINTER_SWITCH 'TIMESTAMPTZ \'2022-10-30 01:10:19\'' \ir include/scheduler_fixed_common.sql \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 day\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 day\'' \ir include/scheduler_fixed_common.sql \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 week\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 week\'' \ir include/scheduler_fixed_common.sql \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 month\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 month\'' \ir include/scheduler_fixed_common.sql \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'1 year\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'1 year\'' \ir include/scheduler_fixed_common.sql \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'2 month\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'2 month\'' \ir include/scheduler_fixed_common.sql \set BUCKET_WIDTH_WINTER_SUMMER 'INTERVAL \'2 year\'' \set BUCKET_WIDTH_SUMMER_WINTER 'INTERVAL \'2 year\'' \ir include/scheduler_fixed_common.sql ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/foreign_keys_test.sql.in��������������������������������������������0000664�0000000�0000000�00000002451�15100345067�0023306�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER \set TEST_BASE_NAME foreign_keys SELECT format('include/%s.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_generic.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_GENERIC", format('%s/results/%s_results_custom.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_CUSTOM" \gset SELECT format('\! diff -u --label "Generic plan results" --label "Custom plan results" %s %s', :'TEST_RESULTS_GENERIC', :'TEST_RESULTS_CUSTOM') AS "DIFF_CMD" \gset set plan_cache_mode to force_generic_plan; \o :TEST_RESULTS_GENERIC \ir :TEST_QUERY_NAME \o reset plan_cache_mode; \set TEST_DBNAME_2 :TEST_DBNAME _2 CREATE DATABASE :TEST_DBNAME_2; \c :TEST_DBNAME_2 :ROLE_SUPERUSER SET client_min_messages = ERROR; CREATE EXTENSION timescaledb CASCADE; RESET client_min_messages; set plan_cache_mode to force_custom_plan; \o :TEST_RESULTS_CUSTOM \ir :TEST_QUERY_NAME \o \c :TEST_DBNAME :ROLE_SUPERUSER reset plan_cache_mode; DROP DATABASE :TEST_DBNAME_2 WITH (force); -- compare outputs for generic vs. custom plans for FK check prepared statements :DIFF_CMD �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/hypertable_generalization.sql���������������������������������������0000664�0000000�0000000�00000027040�15100345067�0024411�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE FUNCTION part_func(id TEXT) RETURNS INTEGER LANGUAGE PLPGSQL IMMUTABLE AS $BODY$ DECLARE retval INTEGER; BEGIN retval := CAST(id AS INTEGER); RETURN retval; END $BODY$; -- test null handling \set ON_ERROR_STOP 0 CREATE TABLE n(); SELECT create_hypertable('n',NULL::_timescaledb_internal.dimension_info); SELECT add_dimension('n',NULL::_timescaledb_internal.dimension_info); \set ON_ERROR_STOP 1 SELECT by_range('id'); SELECT by_range('id', partition_func => 'part_func'); SELECT by_range('id', '1 week'::interval); SELECT by_range('id', '1 week'::interval, 'part_func'::regproc); SELECT by_hash('id', 3); SELECT by_hash('id', 3, partition_func => 'part_func'); -- Check if we handle the varlength of the datatype properly SELECT * FROM by_range('id') WHERE by_range IS NOT NULL; SELECT * FROM by_range('id', partition_func => 'part_func') WHERE by_range IS NOT NULL; SELECT * FROM by_hash('id', 3) WHERE by_hash IS NOT NULL; SELECT * FROM by_hash('id', 3, partition_func => 'part_func') WHERE by_hash IS NOT NULL; \set ON_ERROR_STOP 0 SELECT 'hash//id//3//-'::_timescaledb_internal.dimension_info; SELECT by_range(NULL::name); SELECT by_hash(NULL::name, 3); \set ON_ERROR_STOP 1 -- Validate generalized hypertable for smallint CREATE TABLE test_table_smallint(id SMALLINT, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_smallint', by_range('id')); -- default interval SELECT integer_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_smallint'; -- Add data with default partition (10000) INSERT INTO test_table_smallint VALUES (1, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_smallint VALUES (9999, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_smallint VALUES (10000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_smallint VALUES (20000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); -- Number of chunks SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_smallint'; -- Validate generalized hypertable for int CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id')); -- Default interval SELECT integer_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_int'; -- Add data INSERT INTO test_table_int VALUES (1, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES (99999, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES (100000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES (200000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); -- Number of chunks SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_int'; -- Validate generalized hypertable for bigint CREATE TABLE test_table_bigint(id BIGINT, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_bigint', by_range('id')); -- Default interval SELECT integer_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_bigint'; -- Add data INSERT INTO test_table_bigint VALUES (1, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_bigint VALUES (999999, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_bigint VALUES (1000000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_bigint VALUES (2000000, 10, '01-01-2023 11:00'::TIMESTAMPTZ); -- Number of chunks SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_bigint'; DROP TABLE test_table_smallint; DROP TABLE test_table_int; DROP TABLE test_table_bigint; -- Create hypertable with SERIAL column CREATE TABLE jobs_serial (job_id SERIAL, device_id INTEGER, start_time TIMESTAMPTZ, end_time TIMESTAMPTZ, PRIMARY KEY (job_id)); SELECT create_hypertable('jobs_serial', by_range('job_id', partition_interval => 30)); -- Insert data INSERT INTO jobs_serial (device_id, start_time, end_time) SELECT abs(timestamp_hash(t::timestamp)) % 10, t, t + INTERVAL '1 day' FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-08 1:00':: TIMESTAMPTZ,'1 hour')t; -- Verify chunk pruning EXPLAIN VERBOSE SELECT * FROM jobs_serial WHERE job_id < 30; EXPLAIN VERBOSE SELECT * FROM jobs_serial WHERE job_id >= 30 AND job_id < 90; EXPLAIN VERBOSE SELECT * FROM jobs_serial WHERE job_id > 90; -- Update rows UPDATE jobs_serial SET end_time = end_time + INTERVAL '1 hour' where job_id = 1; UPDATE jobs_serial SET end_time = end_time + INTERVAL '1 hour' where job_id = 30; UPDATE jobs_serial SET end_time = end_time + INTERVAL '1 hour' where job_id = 90; SELECT start_time, end_time FROM jobs_serial WHERE job_id = 1; SELECT start_time, end_time FROM jobs_serial WHERE job_id = 30; SELECT start_time, end_time FROM jobs_serial WHERE job_id = 90; -- Test delete rows -- Existing tuple counts. We saves these and compare with the values -- after running the delete. CREATE TABLE counts AS SELECT (SELECT count(*) FROM jobs_serial) AS total_count, (SELECT count(*) FROM jobs_serial WHERE job_id < 10) AS remove_count; -- Perform the delete DELETE FROM jobs_serial WHERE job_id < 10; -- Ensure only the intended tuples are deleted. The two counts should be equal. SELECT (SELECT total_count FROM counts) - (SELECT count(*) FROM jobs_serial) AS total_removed, (SELECT remove_count FROM counts) - (SELECT count(*) FROM jobs_serial WHERE job_id < 10) AS matching_removed; DROP TABLE jobs_serial; DROP TABLE counts; -- Create and validate hypertable with BIGSERIAL column CREATE TABLE jobs_big_serial (job_id BIGSERIAL, device_id INTEGER, start_time TIMESTAMPTZ, end_time TIMESTAMPTZ, PRIMARY KEY (job_id)); SELECT create_hypertable('jobs_big_serial', by_range('job_id', 100)); -- Insert data INSERT INTO jobs_big_serial (device_id, start_time, end_time) SELECT abs(timestamp_hash(t::timestamp)) % 10, t, t + INTERVAL '1 day' FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-08 1:00'::TIMESTAMPTZ,'30 mins')t; -- Verify #chunks SELECT count(*) FROM timescaledb_information.chunks; -- Get current sequence and verify updating sequence SELECT currval(pg_get_serial_sequence('jobs_big_serial', 'job_id')); -- Update sequence value to 500 SELECT setval(pg_get_serial_sequence('jobs_big_serial', 'job_id'), 500, false); -- Insert few rows and verify that the next sequence starts from 500 INSERT INTO jobs_big_serial (device_id, start_time, end_time) SELECT abs(timestamp_hash(t::timestamp)) % 10, t, t + INTERVAL '1 day' FROM generate_series('2018-03-09 1:00'::TIMESTAMPTZ, '2018-03-10 1:00'::TIMESTAMPTZ,'30 mins')t; -- No data should exist for job_id >= 290 to job_id < 500 SELECT count(*) FROM jobs_big_serial WHERE job_id >= 290 AND job_id < 500; -- The new rows should be added with job_id > 500 SELECT count(*) from jobs_big_serial WHERE job_id > 500; -- Verify show_chunks API SELECT show_chunks('jobs_big_serial', older_than => 100); SELECT show_chunks('jobs_big_serial', newer_than => 200, older_than => 300); SELECT show_chunks('jobs_big_serial', newer_than => 500); -- Verify drop_chunks API SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'jobs_big_serial'; SELECT drop_chunks('jobs_big_serial', newer_than => 500); SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'jobs_big_serial'; SELECT drop_chunks('jobs_big_serial', newer_than => 200, older_than => 300); SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'jobs_big_serial'; DROP TABLE jobs_big_serial; -- Verify partition function CREATE TABLE test_table_int(id TEXT, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10, partition_func => 'part_func')); INSERT INTO test_table_int VALUES('1', 1, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES('10', 10, '01-01-2023 11:00'::TIMESTAMPTZ); INSERT INTO test_table_int VALUES('29', 100, '01-01-2023 11:00'::TIMESTAMPTZ); SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int'; DROP TABLE test_table_int; DROP FUNCTION part_func; -- Migrate data CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); INSERT INTO test_table_int SELECT t, t%10, '01-01-2023 11:00'::TIMESTAMPTZ FROM generate_series(1, 50, 1) t; SELECT create_hypertable('test_table_int', by_range('id', 10), migrate_data => true); -- Show default indexes created for hypertables. SELECT indexname FROM pg_indexes WHERE tablename = 'test_table_int'; SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int'; DROP TABLE test_table_int; -- create_hypertable without default indexes CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10), create_default_indexes => false); SELECT indexname FROM pg_indexes WHERE tablename = 'test_table_int'; DROP TABLE test_table_int; -- if_not_exists CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10)); -- No error when if_not_exists => true SELECT create_hypertable('test_table_int', by_range('id', 10), if_not_exists => true); SELECT * FROM _timescaledb_functions.get_create_command('test_table_int'); \set ON_ERROR_STOP 0 -- Should throw an error when if_not_exists is not set SELECT create_hypertable('test_table_int', by_range('id', 10)); -- Should error out when hash partitioning is used as the main partitioning scheme SELECT create_hypertable('test_table_int', by_hash('device', number_partitions => 2)); \set ON_ERROR_STOP 1 DROP TABLE test_table_int; -- Add dimension CREATE TABLE test_table_int(id INTEGER, device INTEGER, time TIMESTAMPTZ); SELECT create_hypertable('test_table_int', by_range('id', 10), migrate_data => true); INSERT INTO test_table_int SELECT t, t%10, '01-01-2023 11:00'::TIMESTAMPTZ FROM generate_series(1, 50, 1) t; -- adding a space dimension via "by_hash" should work SELECT add_dimension('test_table_int', by_hash('device', number_partitions => 2)); SELECT hypertable_name, dimension_number, column_name FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_table_int'; SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_table_int'; SELECT set_partitioning_interval('test_table_int', 5, 'id'); SELECT set_number_partitions('test_table_int', 3, 'device'); SELECT integer_interval, num_partitions FROM timescaledb_information.dimensions WHERE column_name in ('id', 'device'); DROP TABLE test_table_int; -- Hypertable with time dimension using new API CREATE TABLE test_time(time TIMESTAMP NOT NULL, device INT, temp FLOAT); SELECT create_hypertable('test_time', by_range('time')); -- Default interval SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_time'; INSERT INTO test_time SELECT t, (abs(timestamp_hash(t::timestamp)) % 10) + 1, 0.10 FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-08 1:00', '1 hour') t; SELECT count(*) FROM timescaledb_information.chunks WHERE hypertable_name='test_time'; SELECT add_dimension('test_time', by_range('device', partition_interval => 2)); SELECT hypertable_name, dimension_number, column_name FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_time'; SELECT set_partitioning_interval('test_time', INTERVAL '1 day', 'time'); SELECT time_interval FROM timescaledb_information.dimensions WHERE hypertable_name = 'test_time' AND column_name = 'time'; DROP TABLE test_time; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0020056�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/aggregate_queries.sql���������������������������������������0000664�0000000�0000000�00000006572�15100345067�0024274�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This files assumes the existence of some table with definition as seen in the aggregate_table.sql file. -- All of these should be able to be pushed down if enabled :PREFIX SELECT :GROUPING, min(allnull) as min_allnull, max(temperature) as max_temp, sum(temperature)+sum(humidity) as agg_sum_expr, avg(humidity), ROUND(stddev(CAST(humidity AS INT)), 5), bit_and(bit_int), bit_or(bit_int), bool_and(good_life), every(temperature > 0), bool_or(good_life), count(*) as count_rows, count(temperature) as count_temp, count(allnull) as count_zero, ROUND(CAST(corr(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(covar_pop(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(covar_samp(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_avgx(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_avgy(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_count(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_intercept(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_r2(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_slope(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_sxx(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_sxy(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(CAST(regr_syy(CAST(temperature AS INT), CAST(humidity AS INT)) AS NUMERIC), 5), ROUND(stddev(CAST(temperature AS INT)), 5) as stddev_temp, ROUND(stddev_pop(CAST(temperature AS INT)), 5), ROUND(stddev_samp(CAST(temperature AS INT)), 5), ROUND(variance(CAST(temperature AS INT)), 5), ROUND(var_pop(CAST(temperature AS INT)), 5), ROUND(var_samp(CAST(temperature AS INT)), 5), last(temperature, timec) as last_temp, histogram(temperature, 0, 100, 1) FROM :TEST_TABLE GROUP BY :GROUPING, timec ORDER BY :GROUPING, timec; -- Aggregates on custom types are not yet pushed down :PREFIX SELECT :GROUPING, last(highlow, timec) as last_hl, first(highlow, timec) as first_hl FROM :TEST_TABLE GROUP BY :GROUPING, timec ORDER BY :GROUPING, timec; -- Mix of aggregates that push down and those that don't :PREFIX SELECT :GROUPING, min(allnull) as min_allnull, max(temperature) as max_temp, sum(temperature)+sum(humidity) as agg_sum_expr, avg(humidity), ROUND(stddev(CAST(humidity AS INT)), 5), bit_and(bit_int), bit_or(bit_int), bool_and(good_life), every(temperature > 0), bool_or(good_life), first(highlow, timec) as first_hl FROM :TEST_TABLE GROUP BY :GROUPING, timec ORDER BY :GROUPING, timec; -- Aggregates nested in expressions and no top-level aggregate #3672 :PREFIX SELECT :GROUPING, sum(temperature)+sum(humidity) as agg_sum_expr FROM :TEST_TABLE GROUP BY :GROUPING, timec ORDER BY :GROUPING, timec; -- Aggregates with no aggregate reference in targetlist #3664 :PREFIX SELECT :GROUPING FROM :TEST_TABLE GROUP BY :GROUPING, timec HAVING avg(temperature) > 20 ORDER BY :GROUPING, timec; ��������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/aggregate_table_create.sql����������������������������������0000664�0000000�0000000�00000001622�15100345067�0025220�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This file creates a table with a lot of different types to allow a range of aggregate functions. -- This does not include the creation of a corresponding hypertable, as we may want to vary how that is done. CREATE TYPE custom_type AS (high int, low int); CREATE TABLE :TEST_TABLE ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, region TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL, lowp double precision NULL, highp double precision null, allnull double precision null, highlow custom_type null, bit_int smallint, good_life boolean ); ��������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/aggregate_table_populate.sql��������������������������������0000664�0000000�0000000�00000006665�15100345067�0025622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- This files assumes the existence of some table with definition as seen in the aggregate_table.sql file. INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'POR', 'west', generate_series(25, 85, 0.0625), 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'SFO', 'west', generate_series(25, 85, 0.0625), 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'SAC', 'west', generate_series(25, 85, 0.0625), 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'SEA', 'west', generate_series(25, 85, 0.0625), 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'TAC', 'west', generate_series(25, 85, 0.0625), 75, 40, 70, NULL, (1,2)::custom_type, 2, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'NYC', 'north-east', generate_series(29, 41, 0.0125), 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'BOS', 'north-east', generate_series(29, 41, 0.0125), 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'CHI', 'midwest', generate_series(29, 41, 0.0125), 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'MIN', 'midwest', generate_series(29, 41, 0.0125), 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'DET', 'midwest', generate_series(29, 41, 0.0125), 45, 50, 40, NULL, (3,4)::custom_type, 4, false; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'LA', 'west', generate_series(61, 85, 0.025), 55, NULL, 28, NULL, NULL, 8, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'SDG', 'west', generate_series(61, 85, 0.025), 55, NULL, 28, NULL, NULL, 8, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'PHX', 'west', generate_series(61, 85, 0.025), 55, NULL, 28, NULL, NULL, 8, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'DAL', 'south', generate_series(61, 85, 0.025), 55, NULL, 28, NULL, NULL, 8, true; INSERT INTO :TEST_TABLE SELECT generate_series('2018-12-01 00:00'::timestamp, '2018-12-04 08:00'::timestamp, '5 minute'), 'AUS', 'south', generate_series(61, 85, 0.025), 55, NULL, 28, NULL, NULL, 8, true; ���������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_migrate_common.sql�������������������������������������0000664�0000000�0000000�00000031517�15100345067�0024567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Setup some variables SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset -- restore dump SELECT timescaledb_pre_restore(); \ir :TEST_SCHEMA_FILE SELECT timescaledb_post_restore(); -- Make sure no scheduled job will be executed during the regression tests SELECT _timescaledb_functions.stop_background_workers(); \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature) SELECT generate_series('2022-01-01 00:00:00-00'::timestamptz, '2022-12-31 23:59:59-00'::timestamptz, '1 hour'), 0.25; \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM public.conditions $$; INSERT INTO conditions ("time", temperature) SELECT generate_series(1, 1000, 1), 0.25; \endif CALL refresh_continuous_aggregate('conditions_summary_daily', NULL, NULL); CALL refresh_continuous_aggregate('conditions_summary_weekly', NULL, NULL); \set ON_ERROR_STOP 0 -- should fail because we don't need to migrate finalized caggs CALL cagg_migrate('conditions_summary_daily_new'); -- should fail relation does not exist CALL cagg_migrate('conditions_summary_not_cagg'); CREATE TABLE conditions_summary_not_cagg(); -- should fail continuous agg does not exist CALL cagg_migrate('conditions_summary_not_cagg'); \set ON_ERROR_STOP 1 DROP TABLE conditions_summary_not_cagg; SELECT ca.raw_hypertable_id AS "RAW_HYPERTABLE_ID", h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name AS "PART_VIEW_NAME", partial_view_schema AS "PART_VIEW_SCHEMA", direct_view_name AS "DIR_VIEW_NAME", direct_view_schema AS "DIR_VIEW_SCHEMA", user_view_name AS "USER_VIEW_NAME", user_view_schema AS "USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily' \gset \set ON_ERROR_STOP 0 -- should fail because the new cagg with suffix '_new' already exists CALL cagg_migrate('conditions_summary_daily'); \set ON_ERROR_STOP 1 -- remove the new cagg to execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; -- get and set all the cagg data SELECT _timescaledb_functions.cagg_migrate_pre_validation( 'public', 'conditions_summary_daily', 'conditions_summary_daily_new' ) AS "CAGG_DATA" \gset CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); \x on SELECT mat_hypertable_id, user_view_definition FROM _timescaledb_catalog.continuous_agg_migrate_plan; \x off SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; -- should resume the execution CALL cagg_migrate('conditions_summary_daily'); SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; \set ON_ERROR_STOP 0 -- should error because plan already exists CALL _timescaledb_functions.cagg_migrate_create_plan(:'CAGG_DATA', 'conditions_summary_daily_new'); CALL cagg_migrate('conditions_summary_daily'); \set ON_ERROR_STOP 1 -- policies for test ALTER MATERIALIZED VIEW conditions_summary_daily SET (timescaledb.compress=true); \if :IS_TIME_DIMENSION SELECT add_retention_policy('conditions_summary_daily', '30 days'::interval); SELECT add_continuous_aggregate_policy('conditions_summary_daily', '30 days'::interval, '1 day'::interval, '1 hour'::interval); SELECT add_compression_policy('conditions_summary_daily', '45 days'::interval); \else SELECT add_retention_policy('conditions_summary_daily', '400'::integer); SELECT add_continuous_aggregate_policy('conditions_summary_daily', '50'::integer, '1'::integer, '1 hour'::interval); SELECT add_compression_policy('conditions_summary_daily', '100'::integer); \endif SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'USER_VIEW_SCHEMA' AND hypertable_name = :'USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; -- execute the migration DROP MATERIALIZED VIEW conditions_summary_daily_new; TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; CALL cagg_migrate('conditions_summary_daily'); SELECT ca.raw_hypertable_id AS "NEW_RAW_HYPERTABLE_ID", h.schema_name AS "NEW_MAT_SCHEMA_NAME", h.table_name AS "NEW_MAT_TABLE_NAME", partial_view_name AS "NEW_PART_VIEW_NAME", partial_view_schema AS "NEW_PART_VIEW_SCHEMA", direct_view_name AS "NEW_DIR_VIEW_NAME", direct_view_schema AS "NEW_DIR_VIEW_SCHEMA", user_view_name AS "NEW_USER_VIEW_NAME", user_view_schema AS "NEW_USER_VIEW_SCHEMA" FROM _timescaledb_catalog.continuous_agg ca JOIN _timescaledb_catalog.hypertable h ON (h.id = ca.mat_hypertable_id) WHERE user_view_name = 'conditions_summary_daily_new' \gset \d+ conditions_summary_daily_new SELECT * FROM timescaledb_information.jobs WHERE hypertable_schema = :'NEW_USER_VIEW_SCHEMA' AND hypertable_name = :'NEW_USER_VIEW_NAME' AND job_id >= 1000 ORDER BY job_id; SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; -- compress both caggs SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily') c ORDER BY c::regclass::text; SELECT compress_chunk(c) FROM show_chunks('conditions_summary_daily_new') c ORDER BY c::regclass::text; -- check migrated data after compression. should return 0 (zero) rows SELECT * FROM conditions_summary_daily EXCEPT SELECT * FROM conditions_summary_daily_new; CREATE OR REPLACE VIEW cagg_jobs AS SELECT user_view_schema AS schema, user_view_name AS name, bgw_job.* FROM _timescaledb_config.bgw_job JOIN _timescaledb_catalog.continuous_agg ON mat_hypertable_id = hypertable_id ORDER BY bgw_job.id; -- test migration overriding the new cagg and keeping the old DROP MATERIALIZED VIEW conditions_summary_daily_new; TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; CALL cagg_migrate('conditions_summary_daily', override => TRUE); -- cagg with the new format because it was overriden \d+ conditions_summary_daily -- cagg with the old format because it was overriden \d+ conditions_summary_daily_old \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; -- should return the old cagg jobs SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; -- test migration overriding the new cagg and removing the old TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; DROP MATERIALIZED VIEW conditions_summary_daily; ALTER MATERIALIZED VIEW conditions_summary_daily_old RENAME TO conditions_summary_daily; -- check policies before the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; CALL cagg_migrate('conditions_summary_daily', override => TRUE, drop_old => TRUE); -- cagg with the new format because it was overriden \d+ conditions_summary_daily \set ON_ERROR_STOP 0 -- should fail because the cagg was overriden SELECT * FROM conditions_summary_daily_new; -- should fail because the old cagg was removed SELECT * FROM conditions_summary_daily_old; \set ON_ERROR_STOP 1 -- check policies after the migration SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily'; -- should return no rows because the old cagg was removed SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_old'; -- should return no rows because the cagg was overwritten SELECT * FROM cagg_jobs WHERE schema = 'public' AND name = 'conditions_summary_daily_new'; -- permission tests TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; GRANT ALL ON TABLE conditions TO :ROLE_DEFAULT_PERM_USER; ALTER MATERIALIZED VIEW conditions_summary_weekly OWNER TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan' catalog table CALL cagg_migrate('conditions_summary_weekly'); \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step' catalog table CALL cagg_migrate('conditions_summary_weekly'); \set ON_ERROR_STOP 1 RESET ROLE; GRANT SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan_step TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 0 -- should fail because the lack of permissions on 'continuous_agg_migrate_plan_step_step_id_seq' catalog sequence CALL cagg_migrate('conditions_summary_weekly'); \set ON_ERROR_STOP 1 RESET ROLE; GRANT USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq TO :ROLE_DEFAULT_PERM_USER; SET ROLE :ROLE_DEFAULT_PERM_USER; -- all necessary permissions granted CALL cagg_migrate('conditions_summary_weekly'); -- check migrated data. should return 0 (zero) rows SELECT * FROM conditions_summary_weekly EXCEPT SELECT * FROM conditions_summary_weekly_new; SELECT mat_hypertable_id, step_id, status, type, config FROM _timescaledb_catalog.continuous_agg_migrate_plan_step ORDER BY step_id; RESET ROLE; -- according to the official documentation trying to execute a procedure with -- transaction control statements inside an explicit transaction should fail: -- https://www.postgresql.org/docs/current/sql-call.html -- `If CALL is executed in a transaction block, then the called procedure cannot -- execute transaction control statements. Transaction control statements are only -- allowed if CALL is executed in its own transaction.` TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; DROP MATERIALIZED VIEW conditions_summary_weekly_new; \set ON_ERROR_STOP 0 BEGIN; -- should fail with `invalid transaction termination` CALL cagg_migrate('conditions_summary_weekly'); ROLLBACK; \set ON_ERROR_STOP 1 CREATE FUNCTION execute_migration() RETURNS void AS $$ BEGIN CALL cagg_migrate('conditions_summary_weekly'); RETURN; END; $$ LANGUAGE plpgsql; \set ON_ERROR_STOP 0 -- execute migration inside a plpgsql function BEGIN; -- should fail with `invalid transaction termination` SELECT execute_migration(); ROLLBACK; \set ON_ERROR_STOP 1 -- -- test dropping chunks -- -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; -- drop 1 chunk \if :IS_TIME_DIMENSION SELECT drop_chunks('conditions', older_than => CAST('2022-01-08 00:00:00-00' AS :TIME_DIMENSION_DATATYPE)); \else SELECT drop_chunks('conditions', older_than => 10); \endif -- now he have one chunk marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; -- this migration should remove the chunk metadata marked as dropped CALL cagg_migrate('conditions_summary_weekly', override => TRUE, drop_old => TRUE); -- no chunks marked as dropped SELECT c.table_name as chunk_name, c.dropped FROM _timescaledb_catalog.hypertable h, _timescaledb_catalog.chunk c WHERE h.id = c.hypertable_id AND h.table_name = 'conditions' AND c.dropped ORDER BY 1; -- cleanup DROP FUNCTION execute_migration(); REVOKE SELECT, INSERT, UPDATE ON TABLE _timescaledb_catalog.continuous_agg_migrate_plan FROM :ROLE_DEFAULT_PERM_USER; REVOKE USAGE ON SEQUENCE _timescaledb_catalog.continuous_agg_migrate_plan_step_step_id_seq FROM :ROLE_DEFAULT_PERM_USER; TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; DROP MATERIALIZED VIEW conditions_summary_daily; DROP MATERIALIZED VIEW conditions_summary_weekly; DROP TABLE conditions; SELECT _timescaledb_functions.start_background_workers(); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_migrate_custom_timezone.sql����������������������������0000664�0000000�0000000�00000001626�15100345067�0026521�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('../data/cagg_migrate_%1$s.sql', lower(:'TIME_DIMENSION_DATATYPE')) AS "TEST_SCHEMA_FILE" \gset SELECT timescaledb_pre_restore(); \ir :TEST_SCHEMA_FILE SELECT timescaledb_post_restore(); -- Check restored watermark values SELECT mat_hypertable_id, _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(mat_hypertable_id)) FROM _timescaledb_catalog.continuous_agg; DROP MATERIALIZED VIEW conditions_summary_daily_new; CALL cagg_migrate('conditions_summary_daily'); -- Cleanup TRUNCATE _timescaledb_catalog.continuous_agg_migrate_plan RESTART IDENTITY CASCADE; DROP MATERIALIZED VIEW conditions_summary_daily; DROP MATERIALIZED VIEW conditions_summary_weekly; DROP TABLE conditions CASCADE; ����������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_on_cagg_common.sql�������������������������������������0000664�0000000�0000000�00000017137�15100345067�0024536�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGG on hypertable (1st level) CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, SUM(temperature) AS temperature, device_id FROM conditions GROUP BY 1, 3 ORDER BY 1, 2, 3 WITH NO DATA; -- CAGG on CAGG (2th level) CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , devices.device_id , devices.name FROM :CAGG_NAME_1ST_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_1ST_LEVEL.device_id GROUP BY 1, 3, 4 ORDER BY 1, 2, 3, 4 \else FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- CAGG on CAGG (3th level) CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket, SUM(temperature) AS temperature \if :IS_JOIN , :CAGG_NAME_2TH_LEVEL.device_id , :CAGG_NAME_2TH_LEVEL.name , devices.location FROM :CAGG_NAME_2TH_LEVEL JOIN devices ON devices.device_id = :CAGG_NAME_2TH_LEVEL.device_id GROUP BY 1, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5 \else FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 ORDER BY 1, 2 \endif WITH NO DATA; -- Check chunk_interval \if :IS_TIME_DIMENSION SELECT h.table_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, _timescaledb_functions.to_interval(d.interval_length) AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \else SELECT h.table_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.hypertable h LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = h.id WHERE h.table_name = 'conditions' UNION ALL SELECT c.user_view_name AS name, d.interval_length AS chunk_interval FROM _timescaledb_catalog.continuous_agg c LEFT JOIN _timescaledb_catalog.dimension d on d.hypertable_id = c.mat_hypertable_id WHERE c.user_view_name IN (:'CAGG_NAME_1ST_LEVEL', :'CAGG_NAME_2TH_LEVEL', :'CAGG_NAME_3TH_LEVEL') ORDER BY 1, 2; \endif -- No data because the CAGGs are just for materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime data SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Materialized data SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; \if :IS_TIME_DIMENSION -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-01 01:00:00-00'::timestamptz, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES ('2022-01-03 01:00:00-00'::timestamptz, 2); \else -- Invalidate an old region INSERT INTO conditions ("time", temperature) VALUES (2, 2); -- New region INSERT INTO conditions ("time", temperature) VALUES (10, 2); \endif -- No changes SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- Turn CAGGs into Realtime ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=false); -- Realtime changes, just new region SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- Turn CAGGs into materialized only again ALTER MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL SET (timescaledb.materialized_only=true); -- Refresh all data CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- All changes are materialized SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- TRUNCATE tests TRUNCATE :CAGG_NAME_2TH_LEVEL; -- This full refresh will remove all the data from the 3TH level cagg CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Should return no rows SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- If we have all the data in the bottom levels caggs we can rebuild CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_3TH_LEVEL', NULL, NULL); -- Now we have all the data SELECT * FROM :CAGG_NAME_2TH_LEVEL; SELECT * FROM :CAGG_NAME_3TH_LEVEL; -- DROP tests \set ON_ERROR_STOP 0 -- should error because it depends of other CAGGs DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); \set ON_ERROR_STOP 1 -- DROP the 3TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_3TH_LEVEL; \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs TRUNCATE :CAGG_NAME_2TH_LEVEL,:CAGG_NAME_1ST_LEVEL; CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); SELECT * FROM :CAGG_NAME_1ST_LEVEL; SELECT * FROM :CAGG_NAME_2TH_LEVEL; -- DROP the 2TH level CAGG don't affect others DROP MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_2TH_LEVEL; \set ON_ERROR_STOP 1 -- should work because dropping the top level CAGG -- don't affect the down level CAGGs SELECT * FROM :CAGG_NAME_1ST_LEVEL; -- DROP the first CAGG should work DROP MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL; \set ON_ERROR_STOP 0 -- should error because it was dropped SELECT * FROM :CAGG_NAME_1ST_LEVEL; \set ON_ERROR_STOP 1 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_on_cagg_setup.sql��������������������������������������0000664�0000000�0000000�00000003472�15100345067�0024403�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- CAGGs on CAGGs tests SET ROLE :ROLE_DEFAULT_PERM_USER; DROP TABLE IF EXISTS conditions CASCADE; \if :IS_DEFAULT_COLUMN_ORDER CREATE TABLE conditions ( time :TIME_DIMENSION_DATATYPE NOT NULL, temperature NUMERIC, device_id INT ); \else CREATE TABLE conditions ( temperature NUMERIC, time :TIME_DIMENSION_DATATYPE NOT NULL, device_id INT ); \endif \if :IS_JOIN DROP TABLE IF EXISTS devices CASCADE; CREATE TABLE devices ( device_id int not null, name text, location text); INSERT INTO devices values (1, 'thermo_1', 'Moscow'), (2, 'thermo_2', 'Berlin'),(3, 'thermo_3', 'London'),(4, 'thermo_4', 'Stockholm'); \endif \if :IS_TIME_DIMENSION SELECT table_name FROM create_hypertable('conditions', 'time'); \else SELECT table_name FROM create_hypertable('conditions', 'time', chunk_time_interval => 10); \endif \if :IS_TIME_DIMENSION INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 01:00:00-00', 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-02 01:00:00-00', 20, 3); \else CREATE OR REPLACE FUNCTION integer_now() RETURNS :TIME_DIMENSION_DATATYPE LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions $$; SELECT set_integer_now_func('conditions', 'integer_now'); INSERT INTO conditions ("time", temperature, device_id) VALUES (1, 10, 1); INSERT INTO conditions ("time", temperature, device_id) VALUES (2, 5, 2); INSERT INTO conditions ("time", temperature, device_id) VALUES (5, 20, 3); \endif ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_on_cagg_validations.sql��������������������������������0000664�0000000�0000000�00000005067�15100345067�0025562�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CAGG_NAME_1ST_LEVEL conditions_summary_1 \set CAGG_NAME_2TH_LEVEL conditions_summary_2 \set CAGG_NAME_3TH_LEVEL conditions_summary_3 -- -- CAGG on hypertable (1st level) -- CREATE MATERIALIZED VIEW :CAGG_NAME_1ST_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_1ST time_bucket(:BUCKET_WIDTH_1ST, "time", :'BUCKET_TZNAME_1ST') AS bucket, \else time_bucket(:BUCKET_WIDTH_1ST, "time") AS bucket, \endif SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_1ST_LEVEL -- -- CAGG on CAGG (2th level) -- \set VERBOSITY default \set ON_ERROR_STOP 0 \echo :WARNING_MESSAGE CREATE MATERIALIZED VIEW :CAGG_NAME_2TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_2TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket, \else time_bucket(:BUCKET_WIDTH_2TH, "bucket") AS bucket, \endif SUM(temperature) AS temperature FROM :CAGG_NAME_1ST_LEVEL GROUP BY 1 WITH NO DATA; \d+ :CAGG_NAME_2TH_LEVEL \set ON_ERROR_STOP 1 \set VERBOSITY terse -- Check for incorrect CAGGs \if :INTERVAL_TEST INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-01 00:00:00-00', 10, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-15 01:00:00-00', 20, 4); INSERT INTO conditions ("time", temperature, device_id) VALUES ('2022-01-31 01:00:00-00', 30, 4); CALL refresh_continuous_aggregate(:'CAGG_NAME_1ST_LEVEL', NULL, NULL); CALL refresh_continuous_aggregate(:'CAGG_NAME_2TH_LEVEL', NULL, NULL); CREATE MATERIALIZED VIEW :CAGG_NAME_3TH_LEVEL WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT \if :IS_TIME_DIMENSION_WITH_TIMEZONE_2TH time_bucket(:BUCKET_WIDTH_3TH, "bucket", :'BUCKET_TZNAME_2TH') AS bucket \else time_bucket(:BUCKET_WIDTH_3TH, "bucket") AS bucket \endif FROM :CAGG_NAME_2TH_LEVEL GROUP BY 1 WITH DATA; \d+ :CAGG_NAME_3TH_LEVEL --There should never be dulpicates in the output of the following query SELECT * from :CAGG_NAME_3TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_3TH_LEVEL; DELETE FROM conditions WHERE device_id = 4; \endif -- -- Cleanup -- DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_2TH_LEVEL; DROP MATERIALIZED VIEW IF EXISTS :CAGG_NAME_1ST_LEVEL; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_planning_query.sql�������������������������������������0000664�0000000�0000000�00000002263�15100345067�0024616�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SHOW timescaledb.enable_cagg_sort_pushdown; :PREFIX SELECT 'query 01' AS label, * FROM cagg1 ORDER BY time_bucket; :PREFIX SELECT 'query 02' AS label, * FROM cagg1 ORDER BY time_bucket DESC; :PREFIX SELECT 'query 03' AS label, * FROM cagg1_ordered_asc ORDER BY time_bucket; :PREFIX SELECT 'query 04' AS label, * FROM cagg1_ordered_asc ORDER BY time_bucket DESC; :PREFIX SELECT 'query 05' AS label, * FROM cagg1_ordered_desc ORDER BY time_bucket; :PREFIX SELECT 'query 06' AS label, * FROM cagg1_ordered_desc ORDER BY time_bucket DESC; :PREFIX SELECT 'query 07' AS label, * FROM cagg2 ORDER BY time_bucket; :PREFIX SELECT 'query 08' AS label, * FROM cagg2 ORDER BY time_bucket DESC; :PREFIX SELECT 'query 07' AS label, * FROM cagg3 ORDER BY time_bucket; :PREFIX SELECT 'query 08' AS label, * FROM cagg3 ORDER BY time_bucket DESC; -- not optimized atm :PREFIX SELECT 'query 101' AS label, * FROM cagg2 ORDER BY time_bucket::date; :PREFIX SELECT 'query 102' AS label, * FROM cagg2 ORDER BY time_bucket::date DESC; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_query_common.sql���������������������������������������0000664�0000000�0000000�00000117354�15100345067�0024310�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT format('%s/results/%s_results_view.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW", format('%s/results/%s_results_view_hashagg.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_VIEW_HASHAGG", format('%s/results/%s_results_table.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_TABLE" \gset SELECT format('\! diff %s %s', :'TEST_RESULTS_VIEW', :'TEST_RESULTS_TABLE') as "DIFF_CMD", format('\! diff %s %s', :'TEST_RESULTS_VIEW_HASHAGG', :'TEST_RESULTS_TABLE') as "DIFF_CMD2" \gset \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' SET client_min_messages TO NOTICE; CREATE TABLE conditions ( timec TIMESTAMPTZ NOT NULL, location TEXT NOT NULL, temperature DOUBLE PRECISION NULL, humidity DOUBLE PRECISION NULL ); select table_name from create_hypertable( 'conditions', 'timec'); insert into conditions values ( '2018-01-01 09:20:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-01-02 09:30:00-08', 'por', 100, 100); insert into conditions values ( '2018-01-02 09:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-01-02 09:10:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-11-01 09:20:00-08', 'NYC', 45, 30); insert into conditions values ( '2018-11-01 10:40:00-08', 'NYC', 55, 35); insert into conditions values ( '2018-11-01 11:50:00-08', 'NYC', 65, 40); insert into conditions values ( '2018-11-01 12:10:00-08', 'NYC', 75, 45); insert into conditions values ( '2018-11-01 13:10:00-08', 'NYC', 85, 50); insert into conditions values ( '2018-11-02 09:20:00-08', 'NYC', 10, 10); insert into conditions values ( '2018-11-02 10:30:00-08', 'NYC', 20, 15); insert into conditions values ( '2018-11-02 11:40:00-08', 'NYC', null, null); insert into conditions values ( '2018-11-03 09:50:00-08', 'NYC', null, null); create table location_tab( locid integer, locname text ); insert into location_tab values( 1, 'SFO'); insert into location_tab values( 2, 'NYC'); insert into location_tab values( 3, 'por'); create materialized view mat_m1( location, timec, minl, sumt , sumh) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --compute time_bucketted max+bucket_width for the materialized view SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; CALL refresh_continuous_aggregate('mat_m1', NULL, NULL); --test first/last create materialized view mat_m2(location, timec, firsth, lasth, maxtemp, mintemp) WITH (timescaledb.continuous, timescaledb.materialized_only=false) as select location, time_bucket('1day', timec), first(humidity, timec), last(humidity, timec), max(temperature), min(temperature) from conditions group by time_bucket('1day', timec), location WITH NO DATA; --time that refresh assumes as now() for repeatability SELECT time_bucket('1day' , q.timeval+ '1day'::interval) FROM ( select max(timec)as timeval from conditions ) as q; CALL refresh_continuous_aggregate('mat_m2', NULL, NULL); --normal view -- create or replace view regview( location, timec, minl, sumt , sumh) as select location, time_bucket('1day', timec), min(location), sum(temperature),sum(humidity) from conditions group by location, time_bucket('1day', timec); set enable_hashagg = false; -- NO pushdown cases --- --when we have addl. attrs in order by that are not in the -- group by, we will still need a sort :EXPLAIN select * from mat_m1 order by sumh, sumt, minl, timec ; :EXPLAIN select * from regview order by timec desc; -- PUSHDOWN cases -- -- all group by elts in order by , reorder group by elts to match -- group by order -- This should prevent an additional sort after GroupAggregate :EXPLAIN select * from mat_m1 order by timec desc, location; :EXPLAIN select * from mat_m1 order by location, timec desc; :EXPLAIN select * from mat_m1 order by location, timec asc; :EXPLAIN select * from mat_m1 where timec > '2018-10-01' order by timec desc; -- outer sort is used by mat_m1 for grouping. But doesn't avoid a sort after the join --- :EXPLAIN select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; :EXPLAIN select * from mat_m2 where timec > '2018-10-01' order by timec desc; :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc ) as q limit 1; :EXPLAIN select * from (select * from mat_m2 where timec > '2018-10-01' order by timec desc , location asc nulls first) as q limit 1; --plans with CTE :EXPLAIN with m1 as ( Select * from mat_m2 where timec > '2018-10-01' order by timec desc ) select * from m1; -- should reorder mat_m1 group by only based on mat_m1 order-by :EXPLAIN select * from mat_m1, mat_m2 where mat_m1.timec > '2018-10-01' and mat_m1.timec = mat_m2.timec order by mat_m1.timec desc; --should reorder only for mat_m1. :EXPLAIN select * from mat_m1, regview where mat_m1.timec > '2018-10-01' and mat_m1.timec = regview.timec order by mat_m1.timec desc; select l.locid, mat_m1.* from mat_m1 , location_tab l where timec > '2018-10-01' and l.locname = mat_m1.location order by timec desc; \set ECHO none SET client_min_messages TO error; \o :TEST_RESULTS_VIEW select * from mat_m1 order by timec desc, location; select * from mat_m1 order by location, timec desc; select * from mat_m1 order by location, timec asc; select * from mat_m1 where timec > '2018-10-01' order by timec desc; select * from mat_m2 where timec > '2018-10-01' order by timec desc; \o RESET client_min_messages; \set ECHO all ---- Run the same queries with hash agg enabled now set enable_hashagg = true; \set ECHO none SET client_min_messages TO error; \o :TEST_RESULTS_VIEW_HASHAGG select * from mat_m1 order by timec desc, location; select * from mat_m1 order by location, timec desc; select * from mat_m1 order by location, timec asc; select * from mat_m1 where timec > '2018-10-01' order by timec desc; select * from mat_m2 where timec > '2018-10-01' order by timec desc; \o RESET client_min_messages; \set ECHO all --- Run the queries directly on the table now set enable_hashagg = true; \set ECHO none SET client_min_messages TO error; \o :TEST_RESULTS_TABLE SELECT location, time_bucket('1day', timec) as timec, min(location) as minl, sum(temperature) as sumt, sum(humidity) as sumh from conditions group by time_bucket('1day', timec) , location order by timec desc, location; SELECT location, time_bucket('1day', timec) as timec, min(location) as minl, sum(temperature) as sumt, sum(humidity) as sumh from conditions group by time_bucket('1day', timec) , location order by location, timec desc; SELECT location, time_bucket('1day', timec) as timec, min(location) as minl, sum(temperature) as sumt, sum(humidity) as sumh from conditions group by time_bucket('1day', timec) , location order by location, timec asc; select * from (SELECT location, time_bucket('1day', timec) as timec, min(location) as minl, sum(temperature) as sumt, sum(humidity) as sumh from conditions group by time_bucket('1day', timec) , location ) as q where timec > '2018-10-01' order by timec desc; --comparison for mat_m2 queries select * from ( select location, time_bucket('1day', timec) as timec, first(humidity, timec) firsth, last(humidity, timec) lasth, max(temperature) maxtemp, min(temperature) mintemp from conditions group by time_bucket('1day', timec), location) as q where timec > '2018-10-01' order by timec desc limit 10; \o RESET client_min_messages; \set ECHO all -- diff results view select and table select :DIFF_CMD :DIFF_CMD2 --check if the guc works , reordering will not work set timescaledb.enable_cagg_reorder_groupby = false; set enable_hashagg = false; :EXPLAIN select * from mat_m1 order by timec desc, location; ----------------------------------------------------------------------- -- Test the cagg_watermark function. The watermark gives the point -- where to UNION raw and materialized data in real-time -- aggregation. Specifically, test that the watermark caching works as -- expected. ----------------------------------------------------------------------- -- Insert some more data so that there is something to UNION in -- real-time aggregation. insert into conditions values ( '2018-12-02 20:10:00-08', 'SFO', 55, 45); insert into conditions values ( '2018-12-02 21:20:00-08', 'SFO', 65, 45); insert into conditions values ( '2018-12-02 20:30:00-08', 'NYC', 65, 45); insert into conditions values ( '2018-12-02 21:50:00-08', 'NYC', 45, 30); -- Test join of two caggs. Joining two caggs will force the cache to -- reset every time the watermark function is invoked on a different -- cagg in the same query. SELECT mat_hypertable_id AS mat_id, raw_hypertable_id AS raw_id, schema_name AS mat_schema, table_name AS mat_name, format('%I.%I', schema_name, table_name) AS mat_table FROM _timescaledb_catalog.continuous_agg ca, _timescaledb_catalog.hypertable h WHERE user_view_name='mat_m1' AND h.id = ca.mat_hypertable_id \gset BEGIN; -- Query without join SELECT m1.location, m1.timec, sumt, sumh FROM mat_m1 m1 ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; -- Query that joins two caggs. This should force the watermark cache -- to reset when the materialized hypertable ID changes. A hash join -- could potentially read all values from mat_m1 then all values from -- mat_m2. This would be the optimal situation for cagg_watermark -- caching. We want to avoid it in tests to see that caching doesn't -- do anything wrong in worse situations (e.g., a nested loop join). SET enable_hashjoin=false; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; -- Show the current watermark SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); -- The watermark should, in this case, be the same as the invalidation -- threshold SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; -- The watermark is the end of materialization (end of last bucket) -- while the MAX is the start of the last bucket SELECT max(timec) FROM :mat_table; -- Drop the most recent chunk SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; SELECT drop_chunks('mat_m1', newer_than=>'2018-01-01'::timestamptz); SELECT chunk_name, range_start, range_end FROM timescaledb_information.chunks WHERE hypertable_name = :'mat_name'; -- The watermark should be updated to reflect the dropped data (i.e., -- the cache should be reset) SELECT _timescaledb_functions.to_timestamp(_timescaledb_functions.cagg_watermark(:mat_id)); -- Since we removed the last chunk, the invalidation threshold doesn't -- move back, while the watermark does. SELECT _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_invalidation_threshold WHERE hypertable_id = :raw_id; -- Compare the new watermark to the MAX time in the table SELECT max(timec) FROM :mat_table; -- Try a subtransaction SAVEPOINT clear_cagg; SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C", m1.timec DESC LIMIT 10; ALTER MATERIALIZED VIEW mat_m1 SET (timescaledb.materialized_only=true); SELECT m1.location, m1.timec, sumt, sumh, firsth, lasth, maxtemp, mintemp FROM mat_m1 m1 RIGHT JOIN mat_m2 m2 ON (m1.location = m2.location AND m1.timec = m2.timec) ORDER BY m1.location COLLATE "C" NULLS LAST, m1.timec DESC NULLS LAST, firsth NULLS LAST, lasth NULLS LAST, mintemp NULLS LAST, maxtemp NULLS LAST LIMIT 10; ROLLBACK; ----- -- Tests with time_bucket and offset/origin ----- CREATE TABLE temperature ( time timestamptz NOT NULL, value float ); SELECT create_hypertable('temperature', 'time'); INSERT INTO temperature VALUES ('2000-01-01 01:00:00'::timestamptz, 5); CREATE TABLE temperature_wo_tz ( time timestamp NOT NULL, value float ); SELECT create_hypertable('temperature_wo_tz', 'time'); INSERT INTO temperature_wo_tz VALUES ('2000-01-01 01:00:00'::timestamp, 5); CREATE TABLE temperature_date ( time date NOT NULL, value float ); SELECT create_hypertable('temperature_date', 'time'); INSERT INTO temperature_date VALUES ('2000-01-01 01:00:00'::timestamp, 5); -- Integer based tables CREATE TABLE table_smallint ( time smallint, data smallint ); CREATE TABLE table_int ( time int, data int ); CREATE TABLE table_bigint ( time bigint, data bigint ); SELECT create_hypertable('table_smallint', 'time', chunk_time_interval => 10); SELECT create_hypertable('table_int', 'time', chunk_time_interval => 10); SELECT create_hypertable('table_bigint', 'time', chunk_time_interval => 10); CREATE OR REPLACE FUNCTION integer_now_smallint() returns smallint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_smallint $$; CREATE OR REPLACE FUNCTION integer_now_int() returns int LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_int $$; CREATE OR REPLACE FUNCTION integer_now_bigint() returns bigint LANGUAGE SQL STABLE as $$ SELECT coalesce(max(time), 0) FROM table_bigint $$; SELECT set_integer_now_func('table_smallint', 'integer_now_smallint'); SELECT set_integer_now_func('table_int', 'integer_now_int'); SELECT set_integer_now_func('table_bigint', 'integer_now_bigint'); INSERT INTO table_smallint VALUES(1,2); INSERT INTO table_int VALUES(1,2); INSERT INTO table_bigint VALUES(1,2); CREATE VIEW caggs_info AS SELECT user_view_schema, user_view_name, bucket_func, bucket_width, bucket_origin, bucket_offset, bucket_timezone, bucket_fixed_width FROM _timescaledb_catalog.continuous_aggs_bucket_function NATURAL JOIN _timescaledb_catalog.continuous_agg; --- -- Tests with CAgg creation --- CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours'; DROP MATERIALIZED VIEW cagg_4_hours; CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset'; DROP MATERIALIZED VIEW cagg_4_hours_offset; CREATE MATERIALIZED VIEW cagg_4_hours_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset2'; DROP MATERIALIZED VIEW cagg_4_hours_offset2; -- Variable buckets (timezone is provided) with offset CREATE MATERIALIZED VIEW cagg_4_hours_offset_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_ts'; DROP MATERIALIZED VIEW cagg_4_hours_offset_ts; CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin'; DROP MATERIALIZED VIEW cagg_4_hours_origin; -- Using named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin2'; DROP MATERIALIZED VIEW cagg_4_hours_origin2; -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts'; DROP MATERIALIZED VIEW cagg_4_hours_origin_ts; -- Without named parameter CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, 'UTC', '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts2'; DROP MATERIALIZED VIEW cagg_4_hours_origin_ts2; -- Timestamp based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_wo_tz'; CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz'; DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz; -- Variable buckets (timezone is provided) with origin CREATE MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, origin=>'2000-01-01 01:00:00'::timestamp), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_origin_ts_wo_tz2'; DROP MATERIALIZED VIEW cagg_4_hours_origin_ts_wo_tz2; CREATE MATERIALIZED VIEW cagg_4_hours_offset_wo_tz WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval), max(value) FROM temperature_wo_tz GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_offset_wo_tz'; DROP MATERIALIZED VIEW cagg_4_hours_offset_wo_tz; DROP MATERIALIZED VIEW cagg_4_hours_wo_tz; -- Date based CAggs CREATE MATERIALIZED VIEW cagg_4_hours_date WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date'; DROP MATERIALIZED VIEW cagg_4_hours_date; CREATE MATERIALIZED VIEW cagg_4_hours_date_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, '2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin'; DROP MATERIALIZED VIEW cagg_4_hours_date_origin; CREATE MATERIALIZED VIEW cagg_4_hours_date_origin2 WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, origin=>'2000-01-01'::date), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_origin2'; DROP MATERIALIZED VIEW cagg_4_hours_date_origin2; CREATE MATERIALIZED VIEW cagg_4_hours_date_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 days', time, "offset"=>'30m'::interval), max(value) FROM temperature_date GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_4_hours_date_offset'; DROP MATERIALIZED VIEW cagg_4_hours_date_offset; -- Integer based CAggs CREATE MATERIALIZED VIEW cagg_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_smallint GROUP BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint'; DROP MATERIALIZED VIEW cagg_smallint; CREATE MATERIALIZED VIEW cagg_smallint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::smallint), SUM(data) as value FROM table_smallint GROUP BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_smallint_offset'; DROP MATERIALIZED VIEW cagg_smallint_offset; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_int GROUP BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int'; DROP MATERIALIZED VIEW cagg_int; CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::int), SUM(data) as value FROM table_int GROUP BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_int_offset'; DROP MATERIALIZED VIEW cagg_int_offset; CREATE MATERIALIZED VIEW cagg_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint'; DROP MATERIALIZED VIEW cagg_bigint; CREATE MATERIALIZED VIEW cagg_bigint_offset WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, "offset"=>1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset'; DROP MATERIALIZED VIEW cagg_bigint_offset; -- Without named parameter CREATE MATERIALIZED VIEW cagg_bigint_offset2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('2', time, 1::bigint), SUM(data) as value FROM table_bigint GROUP BY 1 WITH NO DATA; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_bigint_offset2'; -- mess with the bucket_func signature to make sure it will raise an exception SET ROLE :ROLE_CLUSTER_SUPERUSER; \set ON_ERROR_STOP 0 BEGIN; UPDATE _timescaledb_catalog.continuous_aggs_bucket_function SET bucket_func = 'func_does_not_exist()'; -- should error because function does not exist CALL refresh_continuous_aggregate('cagg_bigint_offset2', NULL, NULL); ROLLBACK; \set ON_ERROR_STOP 1 SET ROLE :ROLE_DEFAULT_PERM_USER; DROP MATERIALIZED VIEW cagg_bigint_offset2; -- Test invalid bucket definitions \set ON_ERROR_STOP 0 -- Offset and origin at the same time is not allowed (function does not exists) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; -- Offset and origin at the same time is not allowed (function does exists but invalid parameter combination) CREATE MATERIALIZED VIEW cagg_4_hours_offset_and_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, "offset"=>'30m'::interval, origin=>'2000-01-01 01:00:00 PST'::timestamptz, timezone=>'UTC'), max(value) FROM temperature GROUP BY 1 ORDER BY 1; \set ON_ERROR_STOP 1 --- -- Tests with CAgg processing --- -- Check used timezone SHOW timezone; -- Populate it INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; -- Create CAggs CREATE MATERIALIZED VIEW cagg_4_hours WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg_4_hours_offset WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; -- Align origin with first value CREATE MATERIALIZED VIEW cagg_4_hours_origin WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; -- Query the CAggs and check that all buckets are materialized SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_4_hours; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_4_hours_offset; ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_4_hours_origin; ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; -- Update the last bucket and re-materialize INSERT INTO temperature values('2020-01-01 23:55:00 PST', 10); CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); SELECT * FROM cagg_4_hours; SELECT * FROM cagg_4_hours_offset; SELECT * FROM cagg_4_hours_origin; -- Check the real-time functionality ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); -- Check watermarks SELECT continuous_agg.user_view_name, continuous_aggs_watermark.watermark, _timescaledb_functions.to_timestamp(watermark) FROM _timescaledb_catalog.continuous_aggs_watermark JOIN _timescaledb_catalog.continuous_agg USING (mat_hypertable_id) WHERE user_view_name LIKE 'cagg_4_hours%' ORDER BY mat_hypertable_id, watermark; -- Insert new data INSERT INTO temperature values('2020-01-02 00:10:00 PST', 2222); INSERT INTO temperature values('2020-01-02 05:35:00 PST', 5555); INSERT INTO temperature values('2020-01-02 09:05:00 PST', 8888); -- Watermark is at Thu Jan 02 00:00:00 2020 PST - all inserted tuples should be seen SELECT * FROM cagg_4_hours; -- Watermark is at Thu Jan 02 00:30:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_offset; -- Watermark is at Thu Jan 02 01:00:00 2020 PST - only two inserted tuples should be seen SELECT * FROM cagg_4_hours_origin; -- Update materialized data SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); RESET client_min_messages; -- Query the CAggs and check that all buckets are materialized SELECT * FROM cagg_4_hours; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_4_hours_offset; ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_4_hours_origin; ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; -- Test invalidations TRUNCATE temperature; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-01-01 01:00:00 PST'::timestamptz, '2000-01-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-01-01 00:00:00 PST'::timestamptz, '2020-01-01 23:59:59 PST','1m') time; INSERT INTO temperature values('2020-01-02 01:05:00+01', 2222); INSERT INTO temperature values('2020-01-02 01:35:00+01', 5555); INSERT INTO temperature values('2020-01-02 05:05:00+01', 8888); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_4_hours', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_4_hours_origin', NULL, NULL); RESET client_min_messages; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours; ALTER MATERIALIZED VIEW cagg_4_hours SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours; SELECT time_bucket('4 hour', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_offset; ALTER MATERIALIZED VIEW cagg_4_hours_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_offset; SELECT time_bucket('4 hour', time, '30m'::interval), max(value) FROM temperature GROUP BY 1 ORDER BY 1; ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=true); SELECT * FROM cagg_4_hours_origin; ALTER MATERIALIZED VIEW cagg_4_hours_origin SET (timescaledb.materialized_only=false); SELECT * FROM cagg_4_hours_origin; SELECT time_bucket('4 hour', time, '2000-01-01 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; --- Test with variable width buckets (use February, since hourly origins are not supported with variable sized buckets) TRUNCATE temperature; INSERT INTO temperature SELECT time, 5 FROM generate_series('2000-02-01 01:00:00 PST'::timestamptz, '2000-02-01 23:59:59 PST','1m') time; INSERT INTO temperature SELECT time, 6 FROM generate_series('2020-02-01 01:00:00 PST'::timestamptz, '2020-02-01 23:59:59 PST','1m') time; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; CREATE MATERIALIZED VIEW cagg_1_year WITH (timescaledb.continuous, timescaledb.materialized_only = false) AS SELECT time_bucket('1 year', time), max(value) FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM _timescaledb_catalog.continuous_aggs_materialization_invalidation_log ORDER BY 1, 2, 3; --- -- Tests with integer based hypertables --- TRUNCATE table_int; INSERT INTO table_int SELECT time, 5 FROM generate_series(-50, 50) time; CREATE MATERIALIZED VIEW cagg_int WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg_int_offset WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5), SUM(data) as value FROM table_int GROUP BY 1 ORDER BY 1; -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_int; SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_int_offset; -- Update table INSERT INTO table_int VALUES(51, 100); INSERT INTO table_int VALUES(100, 555); -- Compare bucketing results SELECT time_bucket('10', time), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_int; CALL refresh_continuous_aggregate('cagg_int', NULL, NULL); SELECT * FROM cagg_int; SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; SELECT * FROM cagg_int_offset; -- the value 100 is part of the already serialized bucket, so it should not be visible CALL refresh_continuous_aggregate('cagg_int_offset', NULL, NULL); SELECT * FROM cagg_int_offset; -- Ensure everything was materialized ALTER MATERIALIZED VIEW cagg_int SET (timescaledb.materialized_only=true); ALTER MATERIALIZED VIEW cagg_int_offset SET (timescaledb.materialized_only=true); SELECT * FROM cagg_int; SELECT * FROM cagg_int_offset; -- Check that the refresh is properly aligned INSERT INTO table_int VALUES(114, 0); SET client_min_messages TO DEBUG1; CALL refresh_continuous_aggregate('cagg_int_offset', 110, 130); RESET client_min_messages; SELECT * FROM cagg_int_offset; SELECT time_bucket('10', time, "offset"=>5), SUM(data) FROM table_int GROUP BY 1 ORDER BY 1; -- Variable sized buckets with origin CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin'; DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin; -- Variable due to the used timezone CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2 WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-01 01:05:00 UTC'::timestamptz, timezone=>'UTC') AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin2'; DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin2; -- Variable with offset CREATE MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3 WITH (timescaledb.continuous) AS SELECT time_bucket('1 year', time, "offset"=>'5 minutes'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_variable_bucket_fixed_origin3'; DROP MATERIALIZED VIEW cagg_1_hour_variable_bucket_fixed_origin3; --- -- Test with blocking a few broken configurations --- \set ON_ERROR_STOP 0 -- Unfortunately '\set VERBOSITY verbose' cannot be used here to check the error details -- since it also prints the line number of the location, which is depended on the build -- Different time origin CREATE MATERIALIZED VIEW cagg_1_hour_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg_1_week_origin WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2022-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_origin GROUP BY 1 ORDER BY 1; -- Different time offset CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>'30m'::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; -- Cagg with NULL offset on top of cagg with non-NULL offset \set VERBOSITY default CREATE MATERIALIZED VIEW cagg_1_week_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>NULL::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; -- Cagg with non-NULL offset on top of cagg with NULL offset CREATE MATERIALIZED VIEW cagg_1_hour_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, "offset"=>NULL::interval) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg_1_week_non_null_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, "offset"=>'35m'::interval) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_null_offset GROUP BY 1 ORDER BY 1; \set VERBOSITY terse -- Different integer offset CREATE MATERIALIZED VIEW cagg_int_offset_5 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>5) AS time, SUM(data) AS value FROM table_int GROUP BY 1 ORDER BY 1; CREATE MATERIALIZED VIEW cagg_int_offset_10 WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('10', time, "offset"=>10) AS time, SUM(value) AS value FROM cagg_int_offset_5 GROUP BY 1 ORDER BY 1; \set ON_ERROR_STOP 1 DROP MATERIALIZED VIEW cagg_1_hour_origin; DROP MATERIALIZED VIEW cagg_1_hour_offset; DROP MATERIALIZED VIEW cagg_int_offset_5; --- -- CAGGs on CAGGs tests --- CREATE MATERIALIZED VIEW cagg_1_hour_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS hour_bucket, max(value) AS max_value FROM temperature GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_hour_offset'; CREATE MATERIALIZED VIEW cagg_1_week_offset WITH (timescaledb.continuous) AS SELECT time_bucket('1 week', hour_bucket, origin=>'2000-01-02 01:00:00 PST'::timestamptz) AS week_bucket, max(max_value) AS max_value FROM cagg_1_hour_offset GROUP BY 1 ORDER BY 1; SELECT * FROM caggs_info WHERE user_view_name = 'cagg_1_week_offset'; -- Compare output SELECT * FROM cagg_1_week_offset; SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; INSERT INTO temperature values('2030-01-01 05:05:00 PST', 22222); INSERT INTO temperature values('2030-01-03 05:05:00 PST', 55555); -- Compare real-time functionality ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; -- Test refresh CALL refresh_continuous_aggregate('cagg_1_hour_offset', NULL, NULL); CALL refresh_continuous_aggregate('cagg_1_week_offset', NULL, NULL); -- Everything should be now materailized ALTER MATERIALIZED VIEW cagg_1_hour_offset SET (timescaledb.materialized_only=false); ALTER MATERIALIZED VIEW cagg_1_week_offset SET (timescaledb.materialized_only=false); SELECT * FROM cagg_1_week_offset; SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; TRUNCATE temperature; SELECT * FROM cagg_1_week_offset; SELECT time_bucket('1 week', time, origin=>'2000-01-02 01:00:00 PST'::timestamptz), max(value) FROM temperature GROUP BY 1 ORDER BY 1; DROP VIEW caggs_info; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_refresh_common.sql�������������������������������������0000664�0000000�0000000�00000041501�15100345067�0024567�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE conditions (time timestamptz NOT NULL, device int, temp float); SELECT create_hypertable('conditions', 'time'); -- Test refresh on a cagg built on an empty table CREATE MATERIALIZED VIEW daily_temp WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); CALL refresh_continuous_aggregate('daily_temp', NULL, NULL, force => true); SELECT setseed(.12); INSERT INTO conditions SELECT t, ceil(abs(timestamp_hash(t::timestamp))%4)::int, abs(timestamp_hash(t::timestamp))%40 FROM generate_series('2020-05-01', '2020-05-05', '10 minutes'::interval) t; -- Show the most recent data SELECT * FROM conditions ORDER BY time DESC, device LIMIT 10; -- The continuous aggregate should be empty SELECT * FROM daily_temp ORDER BY day DESC, device; -- Refresh one bucket (1 day): SHOW timezone; -- The refresh of a single bucket must align with the start of the day -- in the bucket's time zone (which is UTC, since time_bucket doesn't -- support time zone arg) CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 17:00 PDT', '2020-05-04 17:00 PDT'); \set ON_ERROR_STOP 0 \set VERBOSITY default -- These refreshes will fail since they don't align with the bucket's -- time zone CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-04'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 PDT', '2020-05-04 00:00 PDT'); -- Refresh window less than one bucket CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-03 23:59 UTC'); -- Refresh window bigger than one bucket, but failing since it is not -- aligned with bucket boundaries so that it covers a full bucket: -- -- Refresh window: [----------) -- Buckets: [------|------] CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 01:00 UTC', '2020-05-04 08:00 UTC'); \set VERBOSITY terse \set ON_ERROR_STOP 1 -- Refresh the most recent few days: CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); SELECT * FROM daily_temp ORDER BY day DESC, device; -- Refresh the rest CALL refresh_continuous_aggregate('daily_temp', '2020-04-30', '2020-05-04'); -- Compare the aggregate to the equivalent query on the source table SELECT * FROM daily_temp ORDER BY day DESC, device; SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 ORDER BY 1 DESC,2; -- Test unusual, but valid input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::timestamptz, '2020-05-03'::date); CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::date, '2020-05-03'::date); -- Unbounded window forward in time CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', NULL); CALL refresh_continuous_aggregate('daily_temp', NULL, NULL); -- Unbounded window back in time CALL refresh_continuous_aggregate('daily_temp', NULL, '2020-05-01'); -- Test bad input \set ON_ERROR_STOP 0 -- Bad continuous aggregate name CALL refresh_continuous_aggregate(NULL, '2020-05-03', '2020-05-05'); CALL refresh_continuous_aggregate('xyz', '2020-05-03', '2020-05-05'); -- Valid object, but not a continuous aggregate CALL refresh_continuous_aggregate('conditions', '2020-05-03', '2020-05-05'); -- Object ID with no object CALL refresh_continuous_aggregate(1, '2020-05-03', '2020-05-05'); -- Lacking arguments CALL refresh_continuous_aggregate('daily_temp'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03'); -- Bad time ranges CALL refresh_continuous_aggregate('daily_temp', 'xyz', '2020-05-05'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', 'xyz'); CALL refresh_continuous_aggregate('daily_temp', '2020-05-03', '2020-05-01'); -- Bad time input CALL refresh_continuous_aggregate('daily_temp', '2020-05-01'::text, '2020-05-03'::text); CALL refresh_continuous_aggregate('daily_temp', 0, '2020-05-01'); \set ON_ERROR_STOP 1 -- Test forceful refreshment. Here we simulate the situation that we've seen -- with tiered data when `timescaledb.enable_tiered_reads` were disabled on the -- server level. In that case we would not see materialized tiered data and -- we wouldn't be able to re-materialize the data using a normal refresh call -- because it would skip previously materialized ranges, but it should be -- possible with `force=>true` parameter. To simulate this use-case we clear -- the materialization hypertable and forefully re-materialize it. SELECT format('%I.%I', ht.schema_name, ht.table_name) AS mat_ht, mat_hypertable_id FROM _timescaledb_catalog.continuous_agg cagg JOIN _timescaledb_catalog.hypertable ht ON cagg.mat_hypertable_id = ht.id WHERE user_view_name = 'daily_temp' \gset -- Delete the data from the materialization hypertable DELETE FROM :mat_ht; -- Run regular refresh, it should not touch previously materialized range CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00'); SELECT * FROM daily_temp ORDER BY day DESC, device; -- Run it again with force=>true, the data should be rematerialized CALL refresh_continuous_aggregate('daily_temp', '2020-05-02', '2020-05-05 17:00', force=>true); SELECT * FROM daily_temp ORDER BY day DESC, device; -- Test different time types CREATE TABLE conditions_date (time date NOT NULL, device int, temp float); SELECT create_hypertable('conditions_date', 'time'); CREATE MATERIALIZED VIEW daily_temp_date WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_date GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('daily_temp_date', '2020-05-01', '2020-05-03'); -- Try max refresh window size CALL refresh_continuous_aggregate('daily_temp_date', NULL, NULL); -- Test smallint-based continuous aggregate CREATE TABLE conditions_smallint (time smallint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_smallint', 'time', chunk_time_interval => 20); INSERT INTO conditions_smallint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::smallint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION smallint_now() RETURNS smallint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::smallint FROM conditions_smallint $$; \set ON_ERROR_STOP 0 -- First try to create an integer-based continuous aggregate without -- an now function. This should not be allowed. CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; \set ON_ERROR_STOP 1 SELECT set_integer_now_func('conditions_smallint', 'smallint_now'); CREATE MATERIALIZED VIEW cond_20_smallint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(SMALLINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_smallint c GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_smallint', 0::smallint, 70::smallint); SELECT * FROM cond_20_smallint ORDER BY 1,2; -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_smallint', NULL, NULL); -- Test int-based continuous aggregate CREATE TABLE conditions_int (time int NOT NULL, device int, temp float); SELECT create_hypertable('conditions_int', 'time', chunk_time_interval => 20); INSERT INTO conditions_int SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::int, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION int_now() RETURNS int LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0) FROM conditions_int $$; SELECT set_integer_now_func('conditions_int', 'int_now'); CREATE MATERIALIZED VIEW cond_20_int WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(INT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_int GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_int', 0, 65); SELECT * FROM cond_20_int ORDER BY 1,2; -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_int', NULL, NULL); -- Test bigint-based continuous aggregate CREATE TABLE conditions_bigint (time bigint NOT NULL, device int, temp float); SELECT create_hypertable('conditions_bigint', 'time', chunk_time_interval => 20); INSERT INTO conditions_bigint SELECT t, ceil(abs(timestamp_hash(to_timestamp(t)::timestamp))%4)::bigint, abs(timestamp_hash(to_timestamp(t)::timestamp))%40 FROM generate_series(1, 100, 1) t; CREATE OR REPLACE FUNCTION bigint_now() RETURNS bigint LANGUAGE SQL STABLE AS $$ SELECT coalesce(max(time), 0)::bigint FROM conditions_bigint $$; SELECT set_integer_now_func('conditions_bigint', 'bigint_now'); CREATE MATERIALIZED VIEW cond_20_bigint WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket(BIGINT '20', time) AS bucket, device, avg(temp) AS avg_temp FROM conditions_bigint GROUP BY 1,2 WITH NO DATA; CALL refresh_continuous_aggregate('cond_20_bigint', 0, 75); SELECT * FROM cond_20_bigint ORDER BY 1,2; -- Try max refresh window size CALL refresh_continuous_aggregate('cond_20_bigint', NULL, NULL); -- Test that WITH NO DATA and WITH DATA works (we use whatever is the -- default for Postgres, so we do not need to have test for the -- default). CREATE MATERIALIZED VIEW weekly_temp_without_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; CREATE MATERIALIZED VIEW weekly_temp_with_data WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; SELECT * FROM weekly_temp_without_data; SELECT * FROM weekly_temp_with_data ORDER BY 1,2; \set ON_ERROR_STOP 0 -- REFRESH MATERIALIZED VIEW is blocked on continuous aggregates REFRESH MATERIALIZED VIEW weekly_temp_without_data; -- These should fail since we do not allow refreshing inside a -- transaction, not even as part of CREATE MATERIALIZED VIEW. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; END $$; BEGIN; CREATE MATERIALIZED VIEW weekly_conditions WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH DATA; COMMIT; \set ON_ERROR_STOP 1 -- This should not fail since we do not refresh the continuous -- aggregate. DO LANGUAGE PLPGSQL $$ BEGIN CREATE MATERIALIZED VIEW weekly_conditions_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; END $$; BEGIN; CREATE MATERIALIZED VIEW weekly_conditions_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('7 days', time) AS day, device, avg(temp) AS avg_temp FROM conditions GROUP BY 1,2 WITH NO DATA; COMMIT; -- refresh_continuous_aggregate can run two transactions, thus it cannot be -- called in a transaction block (from a function, from dynamic SQL) or in a -- subtransaction (from a procedure block with an EXCEPTION clause). Though it -- does NOT require a top level context and can be called from a procedure -- block without an EXCEPTION clause. -- DO block DO $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; -- Procedure without subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_normal() LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CALL refresh_cagg_proc_normal(); \set ON_ERROR_STOP 0 -- Procedure with subtransaction CREATE OR REPLACE PROCEDURE refresh_cagg_proc_subtransaction() LANGUAGE PLPGSQL AS $$ DECLARE errmsg TEXT; BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS errmsg = MESSAGE_TEXT; RAISE EXCEPTION '%', errmsg; END; $$; CALL refresh_cagg_proc_subtransaction(); -- Function CREATE OR REPLACE FUNCTION refresh_cagg_fun() RETURNS INT LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); RETURN 1; END; $$; SELECT * from refresh_cagg_fun(); -- Dynamic SQL DO $$ BEGIN EXECUTE $inner$ CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); $inner$; END; $$; -- Trigger CREATE TABLE refresh_cagg_trigger_table(a int); CREATE FUNCTION refresh_cagg_trigger_fun() RETURNS TRIGGER LANGUAGE PLPGSQL AS $$ BEGIN CALL refresh_continuous_aggregate('daily_temp', '2020-05-03 00:00 UTC', '2020-05-04 00:00 UTC'); END; $$; CREATE TRIGGER refresh_cagg_trigger AFTER INSERT ON refresh_cagg_trigger_table EXECUTE FUNCTION refresh_cagg_trigger_fun(); INSERT INTO refresh_cagg_trigger_table VALUES(1); \set ON_ERROR_STOP 1 -- check that cagg refresh is not blocked by decompression limit CREATE TABLE conditions_decompress_limit (time timestamptz NOT NULL, device text, temp float) WITH (tsdb.hypertable, tsdb.partition_column='time'); INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 1.0 FROM generate_series(1,100) g(i); CREATE MATERIALIZED VIEW daily_temp_decompress_limit WITH (tsdb.continuous) AS SELECT time_bucket('1 day', time) AS day, device, avg(temp) AS avg_temp FROM conditions_decompress_limit GROUP BY 1,2 WITH NO DATA; ALTER MATERIALIZED VIEW daily_temp_decompress_limit SET (tsdb.columnstore,tsdb.segmentby = 'device'); CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SELECT compress_chunk(show_chunks('daily_temp_decompress_limit')); INSERT INTO conditions_decompress_limit SELECT '2020-01-01','d' || i::text, 2.0 FROM generate_series(1,100) g(i); SET timescaledb.max_tuples_decompressed_per_dml_transaction TO 1; CALL refresh_continuous_aggregate('daily_temp_decompress_limit', NULL, NULL); SHOW timescaledb.max_tuples_decompressed_per_dml_transaction; -- More tests for forceful refreshment TRUNCATE conditions; INSERT INTO conditions VALUES -- daily bucket 2025-07-04 10:00:00+00 ('2025-07-04 10:00:00+00', 1, 1), ('2025-07-04 10:05:00+00', 1, 1), -- daily bucket 2025-07-04 11:00:00+00 ('2025-07-04 11:00:00+00', 1, 1), ('2025-07-04 11:05:00+00', 1, 1), -- daily bucket 2025-07-04 12:00:00+00 ('2025-07-04 12:00:00+00', 1, 1), ('2025-07-04 12:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_hour WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 hour', time) AS bucket, -- Fixed bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_hour ORDER BY bucket; CALL refresh_continuous_aggregate('conditions_by_hour', '2025-07-04 10:00:00+00'::timestamptz, '2025-07-04 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_hour ORDER BY bucket; -- Monthly buckets INSERT INTO conditions VALUES -- monthly bucket 2025-05-01 00:00:00+00 ('2025-05-04 10:00:00+00', 1, 1), ('2025-05-04 10:05:00+00', 1, 1), -- monthly bucket 2025-06-01 00:00:00+00 ('2025-06-04 11:00:00+00', 1, 1), ('2025-06-04 11:05:00+00', 1, 1); CREATE MATERIALIZED VIEW conditions_by_month WITH (timescaledb.continuous) AS SELECT time_bucket(INTERVAL '1 month', time) AS bucket, -- Variable bucket size device, MAX(temp), MIN(temp), COUNT(*) FROM conditions GROUP BY 1, 2 WITH NO DATA; CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz); -- It should return 2 buckets SELECT * FROM conditions_by_month ORDER BY bucket; CALL refresh_continuous_aggregate('conditions_by_month', '2025-05-01 00:00:00+00'::timestamptz, '2025-07-01 12:00:00+00'::timestamptz, force=>true); -- It should return the same 2 buckets of previous query SELECT * FROM conditions_by_month ORDER BY bucket; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cagg_run_timebucket_migration.sql���������������������������0000664�0000000�0000000�00000002145�15100345067�0026653�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SELECT mat_hypertable_id, format('%I.%I', partial_view_schema, partial_view_name)::regclass AS partial_view, format('%I.%I', direct_view_schema, direct_view_name)::regclass AS direct_view FROM _timescaledb_catalog.continuous_agg where user_view_name = :'CAGG_NAME' \gset SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; SELECT pg_get_viewdef(:'partial_view', true); SELECT pg_get_viewdef(:'direct_view', true); SELECT pg_get_viewdef(:'CAGG_NAME', true); CALL _timescaledb_functions.cagg_migrate_to_time_bucket(:'CAGG_NAME'); SELECT * FROM _timescaledb_catalog.continuous_aggs_bucket_function WHERE mat_hypertable_id = :mat_hypertable_id; SELECT pg_get_viewdef(:'partial_view', true); SELECT pg_get_viewdef(:'direct_view', true); SELECT pg_get_viewdef(:'CAGG_NAME', true); -- Test CAGG refresh CALL refresh_continuous_aggregate(:'CAGG_NAME', NULL, NULL); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/chunk_utils_internal_orderedappend.sql����������������������0000664�0000000�0000000�00000024724�15100345067�0027730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TESTS for hypertable_osm_range_update_function -- orderedappend (needs hypertable_osm_range_update to update catalog range) -- (so that ordered append will work with OSM chunks) -- TEST for hypertable_osm_range_update function -- test range of dimension slice for osm chunk for different datatypes CREATE TABLE osm_int2(time int2 NOT NULL); CREATE TABLE osm_int4(time int4 NOT NULL); CREATE TABLE osm_int8(time int8 NOT NULL); CREATE TABLE osm_date(time date NOT NULL); CREATE TABLE osm_ts(time timestamp NOT NULL); CREATE TABLE osm_tstz(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('osm_int2','time',chunk_time_interval:=1000); SELECT table_name FROM create_hypertable('osm_int4','time',chunk_time_interval:=1000); SELECT table_name FROM create_hypertable('osm_int8','time',chunk_time_interval:=1000); SELECT table_name FROM create_hypertable('osm_date','time'); SELECT table_name FROM create_hypertable('osm_ts','time'); SELECT table_name FROM create_hypertable('osm_tstz','time'); CREATE FOREIGN TABLE osm_int2_fdw_child(time int2 NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_int4_fdw_child(time int4 NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_int8_fdw_child(time int8 NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_date_fdw_child(time date NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_ts_fdw_child(time timestamp NOT NULL) SERVER s3_server; CREATE FOREIGN TABLE osm_tstz_fdw_child(time timestamptz NOT NULL) SERVER s3_server; SELECT dt, _timescaledb_functions.attach_osm_table_chunk('osm_' || dt, 'osm_' || dt || '_fdw_child') FROM unnest('{int2,int4,int8,date,ts,tstz}'::text[]) u(dt); SELECT ht.table_name, ds.* FROM _timescaledb_catalog.dimension_slice ds INNER JOIN _timescaledb_catalog.dimension d ON d.id=ds.dimension_id INNER JOIN _timescaledb_catalog.hypertable ht on ht.id=d.hypertable_id WHERE ht.table_name LIKE 'osm%' ORDER BY 2,3; -- test that correct slice is found and updated for table with multiple chunk constraints CREATE TABLE test_multicon(time timestamptz not null unique, a int); SELECT hypertable_id as htid FROM create_hypertable('test_multicon', 'time', chunk_time_interval => interval '1 day') \gset insert into test_multicon values ('2020-01-02 01:00'::timestamptz, 1); SELECT c.id, c.hypertable_id, c.schema_name, c.table_name, c.compressed_chunk_id, c.dropped, c.status, c.osm_chunk, cc.chunk_id, cc.dimension_slice_id, cc.constraint_name, cc.hypertable_constraint_name FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc WHERE c.hypertable_id = :htid AND c.id = cc.chunk_id; \c :TEST_DBNAME :ROLE_SUPERUSER ; UPDATE _timescaledb_catalog.chunk SET osm_chunk = true WHERE hypertable_id = :htid; \c :TEST_DBNAME :ROLE_4; SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', '2020-01-02 01:00'::timestamptz, '2020-01-04 01:00'); -- view udpated range SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id; -- check that range was reset to default - infinity \set ON_ERROR_STOP 0 -- both range_start and range_end must be NULL, or non-NULL SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', NULL, '2020-01-04 01:00'::timestamptz); SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', NULL, NULL); SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon'); \set ON_ERROR_STOP 1 SELECT _timescaledb_functions.hypertable_osm_range_update('test_multicon', NULL::timestamptz, NULL); SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; -- TEST for orderedappend that depends on hypertable_osm_range_update functionality -- test further with ordered append \c postgres_fdw_db :ROLE_4; CREATE TABLE test_chunkapp_fdw (time timestamptz NOT NULL, a int); INSERT INTO test_chunkapp_fdw (time, a) VALUES ('2020-01-03 02:00'::timestamptz, 3); \c :TEST_DBNAME :ROLE_4 CREATE TABLE test_chunkapp(time timestamptz NOT NULL, a int); SELECT hypertable_id as htid FROM create_hypertable('test_chunkapp', 'time', chunk_time_interval => interval '1day') \gset INSERT INTO test_chunkapp (time, a) VALUES ('2020-01-01 01:00'::timestamptz, 1), ('2020-01-02 01:00'::timestamptz, 2); CREATE FOREIGN TABLE test_chunkapp_fdw_child(time timestamptz NOT NULL, a int) SERVER s3_server OPTIONS (schema_name 'public', table_name 'test_chunkapp_fdw');; SELECT _timescaledb_functions.attach_osm_table_chunk('test_chunkapp','test_chunkapp_fdw_child'); -- view range before update SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; -- attempt to update overlapping range, should fail \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp', '2020-01-02 01:00'::timestamptz, '2020-01-04 01:00'); \set ON_ERROR_STOP 1 -- update actual range of OSM chunk, should work SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp', '2020-01-03 00:00'::timestamptz, '2020-01-04 00:00'); -- view udpated range SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; -- ordered append should be possible as ranges do not overlap :EXPLAIN SELECT * FROM test_chunkapp ORDER BY 1; SELECT * FROM test_chunkapp ORDER BY 1; -- but, insert should not be possible SELECT ts_setup_osm_hook(); \set ON_ERROR_STOP 0 INSERT INTO test_chunkapp VALUES ('2020-01-03 02:00'::timestamptz, 3); \set ON_ERROR_STOP 1 SELECT ts_undo_osm_hook(); -- reset range to infinity SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp',empty:=false); -- ordered append not possible because range is invalid and empty was not specified :EXPLAIN SELECT * FROM test_chunkapp ORDER BY 1; SELECT * FROM test_chunkapp ORDER BY 1; SELECT cc.chunk_id, c.table_name, c.status, c.osm_chunk, cc.dimension_slice_id, ds.range_start, ds.range_end FROM _timescaledb_catalog.chunk c, _timescaledb_catalog.chunk_constraint cc, _timescaledb_catalog.dimension_slice ds WHERE c.hypertable_id = :htid AND cc.chunk_id = c.id AND ds.id = cc.dimension_slice_id ORDER BY cc.chunk_id; -- but also, OSM chunk should be included in the scan, since range is invalid and chunk is not empty :EXPLAIN SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; -- now set empty to true, should ordered append \c postgres_fdw_db :ROLE_4; DELETE FROM test_chunkapp_fdw; \c :TEST_DBNAME :ROLE_4; SELECT _timescaledb_functions.hypertable_osm_range_update('test_chunkapp', NULL::timestamptz, NULL, empty => true); :EXPLAIN SELECT * FROM test_chunkapp ORDER BY 1; SELECT * FROM test_chunkapp ORDER BY 1; -- should exclude the OSM chunk this time since it is empty :EXPLAIN SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; SELECT * FROM test_chunkapp WHERE time < '2023-01-01' ORDER BY 1; \set ON_ERROR_STOP 0 -- test adding constraint directly on OSM chunk is blocked ALTER TABLE test_chunkapp_fdw_child ADD CHECK (a > 0); -- non-dimensional ALTER TABLE test_chunkapp_fdw_child ADD CHECK (time > '1600-01-01'::timestamptz); -- dimensional -- but on hypertable, it is allowed ALTER TABLE test_chunkapp ADD CHECK (a > 0); SELECT * FROM test.show_constraints('test_chunkapp_fdw_child'); \set ON_ERROR_STOP 1 -- test error is triggered when time dimension not found CREATE TABLE test2(time timestamptz not null, a int); SELECT create_hypertable('test2', 'time'); INSERT INTO test2 VALUES ('2020-01-01'::timestamptz, 1); ALTER TABLE test2 SET (timescaledb.compress); SELECT compress_chunk(show_chunks('test2')); -- find internal compression table, call API function on it SELECT format('%I.%I', cht.schema_name, cht.table_name) AS "COMPRESSION_TBLNM" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.hypertable cht WHERE ht.table_name = 'test2' and cht.id = ht.compressed_hypertable_id \gset \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update(:'COMPRESSION_TBLNM'::regclass, '2020-01-01'::timestamptz); \set ON_ERROR_STOP 1 -- test wrong/incompatible data types with hypertable time dimension -- update range of int2 with int4 \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.hypertable_osm_range_update('osm_int2', range_start => 65540::int4, range_end => 100000::int4); -- update range of int8 with int4 SELECT _timescaledb_functions.hypertable_osm_range_update('osm_int8', 120, 150); -- update range of timestamptz with date SELECT _timescaledb_functions.hypertable_osm_range_update('osm_tstz', '2020-01-01'::date, '2020-01-03'::date); -- udpate range of timestamp with bigint SELECT _timescaledb_functions.hypertable_osm_range_update('osm_tstz', 9223372036854771806, 9223372036854775406); \set ON_ERROR_STOP 1 -- test dimension slice tuple visibility \c :TEST_DBNAME :ROLE_SUPERUSER CREATE TABLE osm_slice_update(time int not null); SELECT hypertable_id AS ht_id FROM create_hypertable('osm_slice_update', 'time', chunk_time_interval => 10) \gset INSERT INTO osm_slice_update VALUES (1); UPDATE _timescaledb_catalog.hypertable SET status = 3 WHERE id = :ht_id; UPDATE _timescaledb_catalog.chunk SET osm_chunk = true WHERE hypertable_id = :ht_id; \c BEGIN; SELECT _timescaledb_functions.hypertable_osm_range_update('osm_slice_update',40,50); ROLLBACK; \c -- new session should not be affected by previous rolled back transaction -- should show 0 10 as range \set ON_ERROR_STOP 0 INSERT INTO osm_slice_update VALUES (1); INSERT INTO osm_slice_update VALUES (1); \set ON_ERROR_STOP 1 ��������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cluster_test_setup.sql��������������������������������������0000664�0000000�0000000�00000006216�15100345067�0024544�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE cluster_test(time INTEGER, temp float, location int, value TEXT); SELECT create_hypertable('cluster_test', 'time', chunk_time_interval => 5); CREATE INDEX on cluster_test (location); CREATE OR REPLACE FUNCTION ensure_scans_work(table_name TEXT, should_output REGCLASS=NULL, seqscan BOOLEAN=FALSE, indexscan BOOLEAN=FALSE, bitmapscan BOOLEAN=FALSE) RETURNS TABLE (a TEXT, b TEXT) LANGUAGE SQL STABLE AS $BODY$ SELECT format($INNER$ SET LOCAL enable_seqscan=%1$s; SET LOCAL enable_indexscan=%2$s; SET LOCAL enable_bitmapscan=%3$s; EXPLAIN (buffers off, costs off) SELECT * FROM %4$I WHERE time=7 $INNER$, seqscan, indexscan, bitmapscan, table_name) as a, format($INNER$ WITH T1 as (SELECT * FROM %1$I WHERE time=7), T2 as (SELECT * FROM %2$I WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location, substring(T1.value for 30), substring(T2.value for 30), length(T1.value), length(T2.value) FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL $INNER$, table_name, should_output) as b; $BODY$; CREATE OR REPLACE FUNCTION ensure_scans_work_no_val(table_name TEXT, should_output REGCLASS=NULL, seqscan BOOLEAN=FALSE, indexscan BOOLEAN=FALSE, bitmapscan BOOLEAN=FALSE) RETURNS TABLE (a TEXT, b TEXT) LANGUAGE SQL STABLE AS $BODY$ SELECT format($INNER$ SET LOCAL enable_seqscan=%1$s; SET LOCAL enable_indexscan=%2$s; SET LOCAL enable_bitmapscan=%3$s; EXPLAIN (buffers off, costs off) SELECT * FROM %4$I WHERE time=6 $INNER$, seqscan, indexscan, bitmapscan, table_name) as a, format($INNER$ WITH T1 as (SELECT * FROM %1$I WHERE time=7), T2 as (SELECT * FROM %2$I WHERE time=7) SELECT T1.time, T2.time, T1.temp, T2.temp, T1.location, T2.location FROM T1 FULL OUTER JOIN T2 ON T1 = T2 WHERE T1 IS NULL OR T2 IS NULL $INNER$, table_name, should_output) as b; $BODY$; -- Show default indexes SELECT * FROM test.show_indexes('cluster_test'); -- Show clustered indexes SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; -- Create two chunks INSERT INTO cluster_test VALUES ( 0, 18.9, 3, 'a'), ( 8, 13.3, 7, 'b'), ( 3, 19.4, 3, 'c'), ( 6, 27.3, 9, 'd'), ( 5, 25.4, 1, 'e'), ( 4, 18.3, 2, 'f'), ( 2, 12.4, 8, 'g'), ( 7, 20.3, 4, repeat('xyzzy', 100000)), -- toasted value ( 9, 11.4, 1, 'h'), ( 1, 23.4, 5, 'i'); CREATE TABLE expected AS SELECT * FROM cluster_test; -- original results to be compared against SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_alter.sql���������������������������������������0000664�0000000�0000000�00000020616�15100345067�0024334�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir compression_utils.sql \ir ../../../../test/sql/include/test_utils.sql CREATE TABLE test1 ("Time" timestamptz, intcol integer, bntcol bigint, txtcol text); SELECT table_name from create_hypertable('test1', 'Time', chunk_time_interval=> INTERVAL '1 day'); INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-05 1:00', '1 hour') t; INSERT INTO test1 SELECT '2018-03-04 2:00', 100, 200, 'hello' ; ALTER TABLE test1 set (timescaledb.compress, timescaledb.compress_segmentby = 'bntcol', timescaledb.compress_orderby = '"Time" DESC'); SELECT count(compress_chunk(ch)) FROM show_chunks('test1') ch; -- TEST: ALTER TABLE add column tests -- ALTER TABLE test1 ADD COLUMN new_coli integer; ALTER TABLE test1 ADD COLUMN new_colv varchar(30); SELECT count(*) from test1 where new_coli is not null; SELECT count(*) from test1 where new_colv is null; --decompress 1 chunk and query again SELECT count(decompress_chunk(ch)) FROM show_chunks('test1') ch LIMIT 1; SELECT count(*) from test1 where new_coli is not null; SELECT count(*) from test1 where new_colv is null; --compress all chunks and query --- --create new chunk and fill in data -- INSERT INTO test1 SELECT t, gen_rand_minstd(), gen_rand_minstd(), gen_rand_minstd()::text , 100, '101t' FROM generate_series('2018-03-08 1:00'::TIMESTAMPTZ, '2018-03-09 1:00', '1 hour') t; SELECT count(*) from test1 where new_coli = 100; SELECT count(*) from test1 where new_colv = '101t'; SELECT count(compress_chunk(ch, true)) FROM show_chunks('test1') ch; SELECT count(*) from test1 where new_coli = 100; SELECT count(*) from test1 where new_colv = '101t'; CREATE INDEX new_index ON test1(new_colv); -- TEST 2: ALTER TABLE rename column SELECT * from _timescaledb_catalog.hypertable WHERE table_name = 'test1'; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='test1'::regclass; ALTER TABLE test1 RENAME new_coli TO coli; SELECT * from _timescaledb_catalog.hypertable WHERE table_name = 'test1'; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='test1'::regclass; SELECT count(*) from test1 where coli = 100; --rename segment by column name ALTER TABLE test1 RENAME bntcol TO bigintcol ; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid='test1'::regclass; --query by segment by column name SELECT * from test1 WHERE bigintcol = 100; SELECT * from test1 WHERE bigintcol = 200; -- add a new chunk and compress INSERT INTO test1 SELECT '2019-03-04 2:00', 99, 800, 'newchunk' ; SELECT count(compress_chunk(ch, true)) FROM show_chunks('test1') ch; --check if all chunks have new column names --both counts should be equal SELECT count(*) FROM _timescaledb_catalog.chunk WHERE hypertable_id = ( SELECT id FROM _timescaledb_catalog.hypertable WHERE table_name = 'test1' ); SELECT count(*) FROM pg_attribute att INNER JOIN _timescaledb_catalog.chunk ch ON att.attrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable ht ON ht.id = ch.hypertable_id AND ht.table_name = 'test1' WHERE attname = 'bigintcol'; --check count on internal compression table too i.e. all the chunks have --the correct column name SELECT format('%I.%I', cht.schema_name, cht.table_name) AS "COMPRESSION_TBLNM" FROM _timescaledb_catalog.hypertable ht, _timescaledb_catalog.hypertable cht WHERE ht.table_name = 'test1' and cht.id = ht.compressed_hypertable_id \gset SELECT count(*) FROM pg_attribute att INNER JOIN _timescaledb_catalog.chunk ch ON att.attrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable ht ON ht.compressed_hypertable_id = ch.hypertable_id AND ht.table_name = 'test1' WHERE attname = 'bigintcol'; -- check column name truncation with renames -- check if the name change is reflected for settings ALTER TABLE test1 RENAME bigintcol TO ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccabdeeeeeeccccccccccccc; SELECT * from _timescaledb_catalog.compression_settings WHERE relid = 'test1'::regclass; SELECT * from timescaledb_information.compression_settings WHERE hypertable_name = 'test1' and attname like 'ccc%'; SELECT count(*) FROM pg_attribute att INNER JOIN _timescaledb_catalog.chunk ch ON att.attrelid = format('%I.%I', ch.schema_name, ch.table_name)::regclass INNER JOIN _timescaledb_catalog.hypertable ht ON ht.compressed_hypertable_id = ch.hypertable_id AND ht.table_name = 'test1' WHERE attname like 'ccc%a'; ALTER TABLE test1 RENAME ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccabdeeeeeeccccccccccccc TO bigintcol; SELECT * from timescaledb_information.compression_settings WHERE hypertable_name = 'test1' and attname = 'bigintcol' ; -- test compression default handling CREATE TABLE test_defaults(time timestamptz NOT NULL, device_id int); SELECT create_hypertable('test_defaults','time'); ALTER TABLE test_defaults SET (timescaledb.compress,timescaledb.compress_segmentby='device_id'); -- create 2 chunks INSERT INTO test_defaults SELECT '2000-01-01', 1; INSERT INTO test_defaults SELECT '2001-01-01', 1; -- compress first chunk SELECT compress_chunk(show_chunks) AS compressed_chunk FROM show_chunks('test_defaults') ORDER BY show_chunks::text LIMIT 1; SELECT * FROM test_defaults ORDER BY 1; ALTER TABLE test_defaults ADD COLUMN c1 int; ALTER TABLE test_defaults ADD COLUMN c2 int NOT NULL DEFAULT 42; SELECT * FROM test_defaults ORDER BY 1,2; -- try insert into compressed and recompress INSERT INTO test_defaults SELECT '2000-01-01', 2; SELECT * FROM test_defaults ORDER BY 1,2; SELECT compress_chunk(ch) FROM show_chunks('test_defaults') ch LIMIT 1; SELECT * FROM test_defaults ORDER BY 1,2; -- timescale/timescaledb#5412 ALTER TABLE test_defaults ADD COLUMN c3 int NOT NULL DEFAULT 43; SELECT *,assert_equal(c3,43) FROM test_defaults ORDER BY 1,2; select decompress_chunk(show_chunks('test_defaults'),true); SELECT *,assert_equal(c3,43) FROM test_defaults ORDER BY 1,2; select compress_chunk(show_chunks('test_defaults')); SELECT *,assert_equal(c3,43) FROM test_defaults ORDER BY 1,2; -- test dropping columns from compressed CREATE TABLE test_drop(f1 text, f2 text, f3 text, time timestamptz, device int, o1 text, o2 text); SELECT create_hypertable('test_drop','time'); ALTER TABLE test_drop SET (timescaledb.compress,timescaledb.compress_segmentby='device',timescaledb.compress_orderby='o1,o2'); -- dropping segmentby or orderby columns will fail \set ON_ERROR_STOP 0 ALTER TABLE test_drop DROP COLUMN time; ALTER TABLE test_drop DROP COLUMN o1; ALTER TABLE test_drop DROP COLUMN o2; ALTER TABLE test_drop DROP COLUMN device; \set ON_ERROR_STOP 1 -- switch to WARNING only to suppress compress_chunk NOTICEs SET client_min_messages TO WARNING; -- create some chunks each with different physical layout ALTER TABLE test_drop DROP COLUMN f1; INSERT INTO test_drop SELECT NULL,NULL,'2000-01-01',1,'o1','o2'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; ALTER TABLE test_drop DROP COLUMN f2; -- test non-existant column \set ON_ERROR_STOP 0 ALTER TABLE test_drop DROP COLUMN f10; \set ON_ERROR_STOP 1 ALTER TABLE test_drop DROP COLUMN IF EXISTS f10; INSERT INTO test_drop SELECT NULL,'2001-01-01',2,'o1','o2'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; ALTER TABLE test_drop DROP COLUMN f3; INSERT INTO test_drop SELECT '2003-01-01',3,'o1','o2'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; ALTER TABLE test_drop ADD COLUMN c1 TEXT; ALTER TABLE test_drop ADD COLUMN c2 TEXT; INSERT INTO test_drop SELECT '2004-01-01',4,'o1','o2','c1','c2-4'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; ALTER TABLE test_drop DROP COLUMN c1; INSERT INTO test_drop SELECT '2005-01-01',5,'o1','o2','c2-5'; SELECT count(compress_chunk(chunk,true)) FROM show_chunks('test_drop') chunk; RESET client_min_messages; SELECT * FROM test_drop ORDER BY 1; -- check dropped columns got removed from catalog -- only segmentby and orderby are in catalog which we dont support removing -- atm, so nothing to see here SELECT * FROM _timescaledb_catalog.hypertable WHERE table_name = 'test_drop'; SELECT * FROM _timescaledb_catalog.compression_settings WHERE relid = 'test_drop'::regclass; ������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_test.sql����������������������������������������0000664�0000000�0000000�00000005636�15100345067�0024211�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors DROP TABLE IF EXISTS compressed; CREATE TABLE compressed AS SELECT :COMPRESSION_CMD AS c FROM (:QUERY) AS sub; SELECT (_timescaledb_functions.compressed_data_info(c)).*, pg_column_size(c) as "compressed size" FROM compressed; --rewrite table (needed to make sure the compressed data does not reference toast table of original) CREATE TABLE temp AS SELECT * FROM :TABLE_NAME; DROP TABLE :TABLE_NAME; ALTER TABLE temp RENAME TO :TABLE_NAME; --test that decompression gives same result in forward direction with original AS ( SELECT row_number() OVER() row_number, * FROM (:QUERY) as q ), decompressed AS ( SELECT row_number() OVER () row_number, * FROM (SELECT :DECOMPRESS_FORWARD_CMD FROM compressed) as q ) SELECT 'Number of rows different between original and decompressed forward (expect 0)', count(*) FROM original FULL OUTER JOIN decompressed ON (original.row_number = decompressed.row_number) WHERE (original.*) IS DISTINCT FROM (decompressed.*); --test the decompress reverse direction too with count_orig AS ( SELECT count(*) as cnt FROM (:QUERY) as q ), original AS ( SELECT count_orig.cnt + 1 - row_number() OVER() row_number, q.* FROM (:QUERY) as q, count_orig ), decompressed AS ( SELECT row_number() OVER () row_number, * FROM (SELECT :DECOMPRESS_REVERSE_CMD FROM compressed) as q ) SELECT 'Number of rows different between original and decompressed reversed (expect 0)', count(*) FROM original FULL OUTER JOIN decompressed ON (original.row_number = decompressed.row_number) WHERE (original.*) IS DISTINCT FROM (decompressed.*); --Test IO SELECT c "COMPRESSED_AS_TEXT" FROM compressed \gset WITH original AS ( SELECT row_number() OVER() row_number, * FROM (:QUERY) as q ), decompressed AS ( SELECT row_number() OVER () row_number, * FROM (SELECT :DECOMPRESS_FORWARD_CMD FROM compressed) as q ), decompressed_from_text AS ( SELECT row_number() OVER () row_number, * FROM (SELECT :DECOMPRESS_FORWARD_CMD FROM (SELECT :'COMPRESSED_AS_TEXT'::text as c) as txt) as q ) SELECT 'Number of rows different between original, decompressed, and decompressed deserializeed (expect 0)', count(*) FROM original FULL OUTER JOIN decompressed ON (original.row_number = decompressed.row_number) FULL OUTER JOIN decompressed_from_text ON (original.row_number = decompressed_from_text.row_number) WHERE (original.*) IS DISTINCT FROM (decompressed_from_text.*) OR (decompressed.*) IS DISTINCT FROM (decompressed_from_text.*) ; SELECT 'Test that deserialization, decompression, recompression, and serialization results in the same text', :COMPRESSION_CMD::text IS NOT DISTINCT FROM :'COMPRESSED_AS_TEXT' FROM (SELECT :DECOMPRESS_FORWARD_CMD as item FROM (SELECT :'COMPRESSED_AS_TEXT'::text as c) as txt) as decompressed_serialized; \set ECHO all ��������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_test_hypertable.sql�����������������������������0000664�0000000�0000000�00000003570�15100345067�0026423�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors DROP TABLE IF EXISTS original_result; CREATE TABLE original_result AS :QUERY; SELECT count(compress_chunk(c, true)) AS "count compress" FROM show_chunks(:'HYPERTABLE_NAME') c; --dump & restore while data is in compressed state. \c postgres :ROLE_SUPERUSER SET client_min_messages = ERROR; \! utils/pg_dump_aux_dump.sh dump/pg_dump.sql \c :TEST_DBNAME SET client_min_messages = ERROR; CREATE EXTENSION IF NOT EXISTS timescaledb; RESET client_min_messages; --\! cp dump/pg_dump.sql /tmp/dump.sql SELECT timescaledb_pre_restore(); \! utils/pg_dump_aux_restore.sh dump/pg_dump.sql SELECT timescaledb_post_restore(); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER with original AS ( SELECT row_number() OVER() row_number, * FROM (SELECT * FROM original_result :QUERY_ORDER) qo ), decompressed AS ( SELECT row_number() OVER() row_number, * FROM (:QUERY :QUERY_ORDER) as q ) select original, decompressed FROM original FULL OUTER JOIN decompressed ON (original.row_number = decompressed.row_number) WHERE (original.*) IS DISTINCT FROM (decompressed.*); SELECT count(decompress_chunk(c)) AS "count decompress" FROM show_chunks(:'HYPERTABLE_NAME') c; --run data on data that's been compressed and decompressed, make sure it's the same. with original AS ( SELECT row_number() OVER() row_number, * FROM (SELECT * FROM original_result :QUERY_ORDER) qo ), uncompressed AS ( SELECT row_number() OVER() row_number, * FROM (:QUERY :QUERY_ORDER) as q ) SELECT :'HYPERTABLE_NAME' AS table, count(*) AS "diff between original and compressed/decompressed" FROM original FULL OUTER JOIN uncompressed ON (original.row_number = uncompressed.row_number) WHERE (original.*) IS DISTINCT FROM (uncompressed.*); \set ECHO all ����������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_test_hypertable_segment_meta.sql����������������0000664�0000000�0000000�00000002032�15100345067�0031143�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors SELECT 'NULL::'||:'TYPE' as "NULLTYPE" \gset --compress the data SELECT count(compress_chunk(ch, true)) FROM show_chunks(:'HYPERTABLE_NAME') ch; SELECT ch.schema_name AS "COMP_SCHEMA_NAME", ch.table_name AS "COMP_TABLE_NAME" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.chunk ch ON (ch.hypertable_id = ht.compressed_hypertable_id) WHERE ht.table_name like :'HYPERTABLE_NAME' ORDER BY ch.id LIMIT 1\gset SELECT bool_and(:SEGMENT_META_COL_MIN = true_min) as min_correct, bool_and(:SEGMENT_META_COL_MAX = true_max) as max_correct FROM :"COMP_SCHEMA_NAME".:"COMP_TABLE_NAME", LATERAL ( SELECT min(decomp) true_min, max(decomp) true_max, ((count(*)-count(decomp)) > 0) true_has_null FROM _timescaledb_internal.decompress_forward(:"ORDER_BY_COL_NAME", :NULLTYPE) decomp ) as m; \set ECHO all ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_test_merge.sql����������������������������������0000664�0000000�0000000�00000002601�15100345067�0025355�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors DROP TABLE IF EXISTS merge_result; CREATE TABLE merge_result AS :QUERY; SELECT count(compress_chunk(chunk, true)) as count_compressed FROM show_chunks(:'HYPERTABLE_NAME') chunk; with original AS ( SELECT row_number() OVER() row_number, * FROM merge_result ), compressed AS ( SELECT row_number() OVER() row_number, * FROM (:QUERY) as q ) SELECT 'Number of rows different between original and query on compressed data (expect 0)', count(*) FROM original FULL OUTER JOIN compressed ON (original.row_number = compressed.row_number) WHERE (original.*) IS DISTINCT FROM (compressed.*); SELECT count(decompress_chunk(ch)) FROM show_chunks(:'HYPERTABLE_NAME') ch; --run data on data that's been compressed and decompressed, make sure it's the same. with original AS ( SELECT row_number() OVER() row_number, * FROM merge_result ), uncompressed AS ( SELECT row_number() OVER() row_number, * FROM (:QUERY) as q ) SELECT 'Number of rows different between original and data that has been compressed and then decompressed (expect 0)', count(*) FROM original FULL OUTER JOIN uncompressed ON (original.row_number = uncompressed.row_number) WHERE (original.*) IS DISTINCT FROM (uncompressed.*); \set ECHO all �������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_test_segment_meta.sql���������������������������0000664�0000000�0000000�00000000571�15100345067�0026732�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors SELECT _timescaledb_internal.segment_meta_min_max_agg_max(i) = max(i), _timescaledb_internal.segment_meta_min_max_agg_min(i) = min(i) FROM :"TABLE"; \set ECHO all ���������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/compression_utils.sql���������������������������������������0000664�0000000�0000000�00000012743�15100345067�0024367�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ECHO errors -- -- decompression functions for testing; not exposed in normal installation -- CREATE OR REPLACE FUNCTION _timescaledb_internal.decompress_forward(_timescaledb_internal.compressed_data, ANYELEMENT) RETURNS TABLE (value ANYELEMENT) AS :MODULE_PATHNAME, 'ts_compressed_data_decompress_forward' ROWS 1000 LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.decompress_reverse(_timescaledb_internal.compressed_data, ANYELEMENT) RETURNS TABLE (value ANYELEMENT) AS :MODULE_PATHNAME, 'ts_compressed_data_decompress_reverse' ROWS 1000 LANGUAGE C IMMUTABLE PARALLEL SAFE; -- -- compression-specific aggregates for testing; not exposed in normal installation -- CREATE OR REPLACE FUNCTION _timescaledb_internal.deltadelta_compressor_append(internal, BIGINT) RETURNS internal AS :MODULE_PATHNAME, 'ts_deltadelta_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.deltadelta_compressor_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_deltadelta_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_internal.gorilla_compressor_append(internal, ANYELEMENT) RETURNS internal AS :MODULE_PATHNAME, 'ts_gorilla_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.gorilla_compressor_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_gorilla_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_internal.compressor_append_timestamptz(internal, timestamptz) RETURNS internal AS :MODULE_PATHNAME, 'ts_deltadelta_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.timestamptz_compress_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_deltadelta_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_internal.dictionary_compressor_append(internal, ANYELEMENT) RETURNS internal AS :MODULE_PATHNAME, 'ts_dictionary_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.dictionary_compressor_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_dictionary_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_internal.array_compressor_append(internal, ANYELEMENT) RETURNS internal AS :MODULE_PATHNAME, 'ts_array_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.array_compressor_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_array_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_internal.bool_compressor_append(internal, ANYELEMENT) RETURNS internal AS :MODULE_PATHNAME, 'ts_bool_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.bool_compressor_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_bool_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE OR REPLACE FUNCTION _timescaledb_internal.uuid_compressor_append(internal, uuid) RETURNS internal AS :MODULE_PATHNAME, 'ts_uuid_compressor_append' LANGUAGE C IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION _timescaledb_internal.uuid_compressor_finish(internal) RETURNS _timescaledb_internal.compressed_data AS :MODULE_PATHNAME, 'ts_uuid_compressor_finish' LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; CREATE AGGREGATE _timescaledb_internal.compress_deltadelta(BIGINT) ( STYPE = internal, SFUNC = _timescaledb_internal.deltadelta_compressor_append, FINALFUNC = _timescaledb_internal.deltadelta_compressor_finish ); CREATE AGGREGATE _timescaledb_internal.compress_deltadelta(timestamptz) ( STYPE = internal, SFUNC = _timescaledb_internal.compressor_append_timestamptz, FINALFUNC = _timescaledb_internal.timestamptz_compress_finish ); CREATE AGGREGATE _timescaledb_internal.compress_gorilla(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.gorilla_compressor_append, FINALFUNC = _timescaledb_internal.gorilla_compressor_finish ); CREATE AGGREGATE _timescaledb_internal.compress_dictionary(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.dictionary_compressor_append, FINALFUNC = _timescaledb_internal.dictionary_compressor_finish ); CREATE AGGREGATE _timescaledb_internal.compress_array(ANYELEMENT) ( STYPE = internal, SFUNC = _timescaledb_internal.array_compressor_append, FINALFUNC = _timescaledb_internal.array_compressor_finish ); CREATE AGGREGATE _timescaledb_internal.compress_bool(boolean) ( STYPE = internal, SFUNC = _timescaledb_internal.bool_compressor_append, FINALFUNC = _timescaledb_internal.bool_compressor_finish ); CREATE AGGREGATE _timescaledb_internal.compress_uuid(uuid) ( STYPE = internal, SFUNC = _timescaledb_internal.uuid_compressor_append, FINALFUNC = _timescaledb_internal.uuid_compressor_finish ); \set ECHO all �����������������������������timescaledb-2.23.0/tsl/test/sql/include/cont_agg_equal.sql������������������������������������������0000664�0000000�0000000�00000002362�15100345067�0023552�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --expects QUERY to be set \o /dev/null DROP MATERIALIZED VIEW IF EXISTS mat_test; CREATE MATERIALIZED VIEW mat_test WITH (timescaledb.continuous) as :QUERY WITH NO DATA; select h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" from _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) where user_view_name = 'mat_test' \gset \c :TEST_DBNAME :ROLE_SUPERUSER INSERT INTO :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" SELECT * FROM :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \o with original AS ( SELECT row_number() OVER(ORDER BY q.*) row_number, * FROM (:QUERY) as q ), view AS ( SELECT row_number() OVER (ORDER BY q.*) row_number, * FROM mat_test as q ) SELECT 'Number of rows different between view and original (expect 0)', count(*) FROM original FULL OUTER JOIN view ON (original.row_number = view.row_number) WHERE (original.*) IS DISTINCT FROM (view.*); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cont_agg_equal_deprecated.sql�������������������������������0000664�0000000�0000000�00000002417�15100345067�0025733�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --expects QUERY to be set \o /dev/null DROP MATERIALIZED VIEW IF EXISTS mat_test; CREATE MATERIALIZED VIEW mat_test WITH (timescaledb.continuous, timescaledb.finalized=false) as :QUERY WITH NO DATA; select h.schema_name AS "MAT_SCHEMA_NAME", h.table_name AS "MAT_TABLE_NAME", partial_view_name as "PART_VIEW_NAME", partial_view_schema as "PART_VIEW_SCHEMA" from _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) where user_view_name = 'mat_test' \gset \c :TEST_DBNAME :ROLE_SUPERUSER INSERT INTO :"MAT_SCHEMA_NAME".:"MAT_TABLE_NAME" SELECT * FROM :"PART_VIEW_SCHEMA".:"PART_VIEW_NAME"; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \o with original AS ( SELECT row_number() OVER(ORDER BY q.*) row_number, * FROM (:QUERY) as q ), view AS ( SELECT row_number() OVER (ORDER BY q.*) row_number, * FROM mat_test as q ) SELECT 'Number of rows different between view and original (expect 0)', count(*) FROM original FULL OUTER JOIN view ON (original.row_number = view.row_number) WHERE (original.*) IS DISTINCT FROM (view.*); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/cont_agg_test_equal.sql�������������������������������������0000664�0000000�0000000�00000001222�15100345067�0024603�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --expects QUERY and VIEW_NAME to be set with original AS ( SELECT row_number() OVER(ORDER BY q.*) row_number, * FROM (:QUERY) as q ), view AS ( SELECT row_number() OVER (ORDER BY q.*) row_number, * FROM :VIEW_NAME as q ) SELECT 'Number of rows different between view and original (expect 0)' as description, :'VIEW_NAME' as view_name, count(*) FROM original FULL OUTER JOIN view ON (original.row_number = view.row_number) WHERE (original.*) IS DISTINCT FROM (view.*); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/debugsupport.sql��������������������������������������������0000664�0000000�0000000�00000000563�15100345067�0023326�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE FUNCTION test.tsl_override_current_timestamptz(new_value TIMESTAMPTZ) RETURNS VOID AS :TSL_MODULE_PATHNAME, 'ts_test_override_current_timestamptz' LANGUAGE C VOLATILE; ���������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/filter_exec.sql���������������������������������������������0000664�0000000�0000000�00000001417�15100345067�0023073�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE SCHEMA IF NOT EXISTS test; GRANT USAGE ON SCHEMA test TO PUBLIC; CREATE OR REPLACE FUNCTION test.execute_sql_and_filter_data_node_name_on_error(cmd TEXT, data_node_prefix TEXT DEFAULT :'TEST_DBNAME') RETURNS VOID LANGUAGE PLPGSQL AS $BODY$ DECLARE original_error_text TEXT; error_text TEXT; BEGIN EXECUTE cmd; EXCEPTION WHEN others THEN GET STACKED DIAGNOSTICS original_error_text = MESSAGE_TEXT; SELECT regexp_replace(original_error_text, '\[' || data_node_prefix ||'_.+\]', '[' || data_node_prefix || '_x]', 'g') INTO error_text; RAISE '%', error_text; END $BODY$; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/foreign_keys.sql��������������������������������������������0000664�0000000�0000000�00000070305�15100345067�0023270�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test single column fk constraint from plain table to hypertable during hypertable creation CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time), info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- chunks referenced in fk constraints must not be dropped or truncated \set ON_ERROR_STOP 0 TRUNCATE metrics; TRUNCATE _timescaledb_internal._hyper_1_1_chunk; TRUNCATE _timescaledb_internal._hyper_1_2_chunk; DROP TABLE _timescaledb_internal._hyper_1_1_chunk; DROP TABLE _timescaledb_internal._hyper_1_2_chunk; SELECT drop_chunks('metrics', '1 month'::interval); \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with RESTRICT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE RESTRICT ON UPDATE RESTRICT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; \set ON_ERROR_STOP 0 -- should fail DELETE FROM metrics WHERE time = '2020-01-01'; -- should fail UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; -- create new chunk and repeat the test INSERT INTO metrics(time, device, value) VALUES ('2021-01-01', 'd1', 1.0); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2021-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2021-01-01', 'info2'); SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with CASCADE CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET NULL CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz references metrics(time) ON DELETE SET NULL ON UPDATE SET NULL, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable during hypertable creation with SET DEFAULT CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); CREATE TABLE event(time timestamptz default null references metrics(time) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test multi column fk constraint from plain table to hypertable CREATE TABLE metrics(time timestamptz , device text, value float, primary key (time, device)); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, device text, info text); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time,device) REFERENCES metrics(time,device) ON DELETE RESTRICT; -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, device, info) VALUES ('2020-01-02', 'd1', 'info1'); INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd2', 'info2'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, device, info) VALUES ('2020-01-01', 'd1', 'info2'); -- should fail \set ON_ERROR_STOP 0 DELETE FROM metrics WHERE time = '2020-01-01'; DELETE FROM metrics WHERE device = 'd1'; \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to hypertable with constraint being added separately while data is present CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01', 'd1', 1.0); CREATE TABLE event(time timestamptz, info text); INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); INSERT INTO event(time, info) VALUES ('2020-02-01', 'info1'); -- should fail \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE SET NULL; \set ON_ERROR_STOP 1 INSERT INTO metrics(time, device, value) VALUES ('2020-02-01', 'd1', 1.0); ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time) ON DELETE CASCADE; -- delete should cascade DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from plain table to compressed hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 0:00:00', 'd1', 1.0); INSERT INTO metrics(time, device, value) VALUES ('2020-01-01 1:00:00', 'd1', 1.0); ALTER TABLE metrics SET(timescaledb.compress, timescaledb.compress_segmentby='device'); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics') ch; CREATE TABLE event(time timestamptz references metrics(time) ON DELETE CASCADE ON UPDATE CASCADE, info text); -- should fail \set ON_ERROR_STOP 0 INSERT INTO event(time, info) VALUES ('2020-01-02', 'info1'); \set ON_ERROR_STOP 1 -- should succeed INSERT INTO event(time, info) VALUES ('2020-01-01', 'info2'); \set ON_ERROR_STOP 0 -- should fail UPDATE event SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; \set ON_ERROR_STOP 1 -- should succeed BEGIN; UPDATE event SET time = '2020-01-01 01:00:00' WHERE time = '2020-01-01'; ROLLBACK; -- should cascade BEGIN; DELETE FROM metrics WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; -- should cascade BEGIN; UPDATE metrics SET time = '2020-01-01 00:30:00' WHERE time = '2020-01-01'; SELECT * FROM event ORDER BY event; ROLLBACK; SELECT conname, conrelid::regclass, confrelid::regclass, conparentid <> 0 AS parent FROM pg_constraint WHERE conrelid='event'::regclass ORDER BY oid; SELECT tgfoid::regproc, tgparentid <> 0 AS parent, tgisinternal, tgconstrrelid::regclass FROM pg_trigger WHERE tgconstrrelid='event'::regclass ORDER BY oid; DROP TABLE event; DROP TABLE metrics; -- test single column fk constraint from hypertable to hypertable CREATE TABLE metrics(time timestamptz primary key, device text, value float); SELECT table_name FROM create_hypertable('metrics', 'time'); CREATE TABLE event(time timestamptz, info text); SELECT table_name FROM create_hypertable('event', 'time'); \set ON_ERROR_STOP 0 ALTER TABLE event ADD CONSTRAINT event_time_fkey FOREIGN KEY (time) REFERENCES metrics(time); \set ON_ERROR_STOP 1 CREATE TABLE event2(time timestamptz REFERENCES metrics(time), info text); \set ON_ERROR_STOP 0 SELECT table_name FROM create_hypertable('event2', 'time'); \set ON_ERROR_STOP 1 DROP TABLE event; DROP TABLE event2; DROP TABLE metrics; -- test FK behavior with different cascading configurations CREATE TABLE fk_no_action(fk_no_action text primary key); CREATE TABLE fk_restrict(fk_restrict text primary key); CREATE TABLE fk_cascade(fk_cascade text primary key); CREATE TABLE fk_set_null(fk_set_null text primary key); CREATE TABLE fk_set_default(fk_set_default text primary key); CREATE TABLE ht( time timestamptz not null, fk_no_action text references fk_no_action(fk_no_action) ON DELETE NO ACTION ON UPDATE NO ACTION, fk_restrict text references fk_restrict(fk_restrict) ON DELETE RESTRICT ON UPDATE RESTRICT, fk_cascade text references fk_cascade(fk_cascade) ON DELETE CASCADE ON UPDATE CASCADE, fk_set_null text references fk_set_null(fk_set_null) ON DELETE SET NULL ON UPDATE SET NULL, fk_set_default text default 'default' references fk_set_default(fk_set_default) ON DELETE SET DEFAULT ON UPDATE SET DEFAULT ); SELECT table_name FROM create_hypertable('ht', 'time'); ALTER TABLE ht SET(timescaledb.compress, timescaledb.compress_segmentby='fk_no_action,fk_restrict,fk_cascade,fk_set_null,fk_set_default'); \set ON_ERROR_STOP 0 INSERT INTO fk_set_default(fk_set_default) VALUES ('default'); INSERT INTO ht(time) VALUES ('2020-01-01'); -- NO ACTION -- should fail with foreign key violation INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- ON UPDATE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; ROLLBACK; -- ON UPDATE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_no_action SET fk_no_action = 'fk_no_action_updated'; ROLLBACK; -- ON DELETE NO ACTION BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); -- should error DELETE FROM fk_no_action; ROLLBACK; -- ON DELETE NO ACTION with compression BEGIN; INSERT INTO fk_no_action(fk_no_action) VALUES ('fk_no_action'); INSERT INTO ht(time, fk_no_action) VALUES ('2020-01-01', 'fk_no_action'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_no_action; ROLLBACK; -- RESTRICT -- should fail with foreign key violation INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- ON UPDATE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; ROLLBACK; -- ON UPDATE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error UPDATE fk_restrict SET fk_restrict = 'fk_restrict_updated'; ROLLBACK; -- ON DELETE RESTRICT BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); -- should error DELETE FROM fk_restrict; ROLLBACK; -- ON DELETE RESTRICT with compression BEGIN; INSERT INTO fk_restrict(fk_restrict) VALUES ('fk_restrict'); INSERT INTO ht(time, fk_restrict) VALUES ('2020-01-01', 'fk_restrict'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should error DELETE FROM fk_restrict; ROLLBACK; -- CASCADE -- should fail with foreign key violation INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- ON UPDATE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; ROLLBACK; -- Run EXPLAIN setups for both generic and custom plans so that DIFF_CMD won't differ -- as custom plans for FK UPD/DEL cascades with constified params -- are legitimately different from generic plans with run-time params, -- with the resulting "ht" partial chunk composition being different. -- ON UPDATE CASCADE with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade UPDATE fk_cascade SET fk_cascade = 'fk_cascade_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE BEGIN; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; ROLLBACK; -- ON DELETE CASCADE with compression without direct batch delete SET timescaledb.enable_compressed_direct_batch_delete TO false; BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; RESET timescaledb.enable_compressed_direct_batch_delete; -- ON DELETE CASCADE with compression and direct batch delete BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_cascade(fk_cascade) VALUES ('fk_cascade'); INSERT INTO ht(time, fk_cascade) VALUES ('2020-01-01', 'fk_cascade'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should cascade DELETE FROM fk_cascade; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET NULL -- should fail with foreign key violation INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- ON UPDATE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null UPDATE fk_set_null SET fk_set_null = 'fk_set_null_updated'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL BEGIN; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; ROLLBACK; -- ON DELETE SET NULL with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_null(fk_set_null) VALUES ('fk_set_null'); INSERT INTO ht(time, fk_set_null) VALUES ('2020-01-01', 'fk_set_null'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; -- should set column to null DELETE FROM fk_set_null; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- SET DEFAULT -- should fail with foreign key violation INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); -- ON UPDATE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; ROLLBACK; -- ON UPDATE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; UPDATE fk_set_default SET fk_set_default = 'fk_set_default_updated' WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- ON DELETE SET DEFAULT BEGIN; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; ROLLBACK; -- ON DELETE SET DEFAULT with compression BEGIN; SET plan_cache_mode TO force_custom_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; BEGIN; SET plan_cache_mode TO force_generic_plan; INSERT INTO fk_set_default(fk_set_default) VALUES ('fk_set_default'); INSERT INTO ht(time, fk_set_default) VALUES ('2020-01-01', 'fk_set_default'); SELECT count(compress_chunk(ch)) FROM show_chunks('ht') ch; SELECT * FROM ht; DELETE FROM fk_set_default WHERE fk_set_default = 'fk_set_default'; SELECT * FROM ht; EXPLAIN (analyze, buffers off, costs off, timing off, summary off) SELECT * FROM ht; ROLLBACK; -- #7226 -- test multi-column fk constraint where constraint column order is different from index column order CREATE TABLE i7226(time timestamptz, device_id int, PRIMARY KEY (device_id, time)); SELECT create_hypertable('i7226', 'time'); CREATE TABLE i7226_valid(time timestamptz NOT NULL,device_id int NOT NULL, FOREIGN KEY(time, device_id) REFERENCES i7226(time, device_id)); INSERT INTO i7226 VALUES ('2024-08-29 12:00:00+00', 1); -- test foreign key constraints that have been created before hypertable conversion create table converted_pk(time timestamptz, id int, unique(time, id)); create table converted_fk(time timestamptz, id int, foreign key (time, id) references converted_pk(time, id)); select table_name FROM create_hypertable ('converted_pk', 'time'); \set ON_ERROR_STOP 0 -- should fail INSERT INTO converted_fk SELECT '2020-01-01', 1; \set ON_ERROR_STOP 1 INSERT INTO converted_pk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should still fail INSERT INTO converted_fk SELECT '2020-01-01', 1; \set ON_ERROR_STOP 1 INSERT INTO converted_fk SELECT '2020-01-01 0:01', 1; \set ON_ERROR_STOP 0 -- should fail DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; TRUNCATE converted_pk; \set ON_ERROR_STOP 1 DELETE FROM converted_fk; DELETE FROM converted_pk WHERE time = '2020-01-01 0:01'; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/jit_cleanup.sql���������������������������������������������0000664�0000000�0000000�00000000477�15100345067�0023104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. DROP TABLE IF EXISTS jit_test CASCADE; DROP TABLE IF EXISTS jit_test_interval CASCADE; DROP TABLE IF EXISTS jit_test_contagg CASCADE; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/jit_load.sql������������������������������������������������0000664�0000000�0000000�00000003007�15100345067�0022364�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE jit_test(time timestamp NOT NULL, device int, temp float); SELECT create_hypertable('jit_test', 'time'); ALTER TABLE jit_test DROP COLUMN device; CREATE TABLE jit_test_interval(id int NOT NULL, temp float); SELECT create_hypertable('jit_test_interval', 'id', chunk_time_interval => 10); CREATE TABLE jit_test_contagg ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT table_name FROM create_hypertable('jit_test_contagg', 'observation_time'); CREATE MATERIALIZED VIEW jit_device_summary WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 hour', observation_time) as bucket, device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM jit_test_contagg GROUP BY bucket, device_id WITH NO DATA; INSERT INTO jit_test_contagg SELECT ts, 'device_1', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; INSERT INTO jit_test_contagg SELECT ts, 'device_2', (EXTRACT(EPOCH FROM ts)) from generate_series('2018-12-01 00:00'::timestamp, '2018-12-31 00:00'::timestamp, '30 minutes') ts; CALL refresh_continuous_aggregate('jit_device_summary', NULL, NULL); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/jit_query.sql�����������������������������������������������0000664�0000000�0000000�00000002261�15100345067�0022613�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- github issue #1262 -- :PREFIX INSERT INTO jit_test VALUES('2017-01-20T09:00:01', 22.5) RETURNING *; :PREFIX INSERT INTO jit_test VALUES ('2017-01-20T09:00:02', 2), ('2017-01-20T09:00:03', 5), ('2017-01-20T09:00:04', 10); :PREFIX SELECT * FROM jit_test WHERE temp > 5 and temp <= 10 ORDER BY time; -- update with iteration over chunks -- :PREFIX INSERT INTO jit_test_interval (SELECT x, x / 2.3 FROM generate_series(0, 100) x) RETURNING *; :PREFIX SELECT * FROM jit_test_interval WHERE id >= 23 and id < 73 ORDER BY id; :PREFIX UPDATE jit_test_interval SET temp = temp * 2.3 WHERE id >= 23 and id < 73; :PREFIX SELECT * FROM jit_test_interval ORDER BY id; :PREFIX SELECT time_bucket(10, id), avg(temp) FROM jit_test_interval GROUP BY 1 ORDER BY 1; -- test continuous aggregates usage with forced jit (based on continuous_aggs_usage.sql) -- :PREFIX SELECT * FROM jit_device_summary WHERE metric_spread = 1800 ORDER BY bucket DESC, device_id LIMIT 10; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/modify_exclusion_load.sql�����������������������������������0000664�0000000�0000000�00000010030�15100345067�0025150�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE metrics_int2(c1 int,c2 int, c3 int, c4 int, c5 int, time int2 NOT NULL, value float, data text); CREATE TABLE metrics_int4(c1 int,c2 int, c3 int, c4 int, c5 int, time int4 NOT NULL, value float, data text); CREATE TABLE metrics_int8(c1 int,c2 int, c3 int, c4 int, c5 int, time int8 NOT NULL, value float, data text); CREATE TABLE metrics_date(c1 int,c2 int, c3 int, c4 int, c5 int, time date NOT NULL, value float, data text); CREATE TABLE metrics_timestamp(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, value float, data text); CREATE TABLE metrics_timestamptz(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamptz NOT NULL, value float, data text); CREATE TABLE metrics_space(c1 int,c2 int, c3 int, c4 int, c5 int, time timestamp NOT NULL, device text, value float, data text); SELECT table_name FROM create_hypertable('metrics_int2','time',chunk_time_interval:=10); SELECT table_name FROM create_hypertable('metrics_int4','time',chunk_time_interval:=10); SELECT table_name FROM create_hypertable('metrics_int8','time',chunk_time_interval:=10); SELECT table_name FROM create_hypertable('metrics_date','time'); SELECT table_name FROM create_hypertable('metrics_timestamp','time'); SELECT table_name FROM create_hypertable('metrics_timestamptz','time'); SELECT table_name FROM create_hypertable('metrics_space','time','device',4); CREATE FUNCTION drop_column(text) RETURNS VOID LANGUAGE PLPGSQL AS $$ DECLARE tbl name; BEGIN FOR tbl IN SELECT 'metrics_' || unnest(ARRAY['int2','int4','int8','date','timestamp','timestamptz','space']) LOOP EXECUTE format('ALTER TABLE %I DROP COLUMN %I;', tbl, $1); END LOOP; END; $$; -- create 4 chunks each with different physical layout SELECT drop_column('c1'); INSERT INTO metrics_int2(time) VALUES (0); INSERT INTO metrics_int4(time) VALUES (0); INSERT INTO metrics_int8(time) VALUES (0); INSERT INTO metrics_date(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2000-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2000-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2000-01-01','1'),('2000-01-01','2'); SELECT drop_column('c2'); INSERT INTO metrics_int2(time) VALUES (10); INSERT INTO metrics_int4(time) VALUES (10); INSERT INTO metrics_int8(time) VALUES (10); INSERT INTO metrics_date(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2001-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2001-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2001-01-01','1'),('2001-01-01','2'); SELECT drop_column('c3'); INSERT INTO metrics_int2(time) VALUES (20); INSERT INTO metrics_int4(time) VALUES (20); INSERT INTO metrics_int8(time) VALUES (20); INSERT INTO metrics_date(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2002-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2002-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2002-01-01','1'),('2002-01-01','2'); SELECT drop_column('c4'); INSERT INTO metrics_int2(time) VALUES (30); INSERT INTO metrics_int4(time) VALUES (30); INSERT INTO metrics_int8(time) VALUES (30); INSERT INTO metrics_date(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamp(time) VALUES ('2003-01-01'); INSERT INTO metrics_timestamptz(time) VALUES ('2003-01-01'); INSERT INTO metrics_space(time,device) VALUES ('2003-01-01','1'),('2003-01-01','2'); SELECT drop_column('c5'); CREATE TABLE metrics_compressed(time timestamptz NOT NULL, device int, value float); SELECT table_name FROM create_hypertable('metrics_compressed','time'); ALTER TABLE metrics_compressed SET (timescaledb.compress); -- create first chunk and compress INSERT INTO metrics_compressed VALUES ('2000-01-01',1,0.5); SELECT count(compress_chunk(chunk)) FROM show_chunks('metrics_compressed') chunk; -- create more chunks INSERT INTO metrics_compressed VALUES ('2010-01-01',1,0.5),('2011-01-01',1,0.5),('2012-01-01',1,0.5); ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/ordered_append.sql������������������������������������������0000664�0000000�0000000�00000013506�15100345067�0023557�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- In the following test cases, we test that certain indexes are used. By using the -- timescaledb.enable_decompression_sorted_merge optimization, we are pushing a sort node -- below the DecompressChunk node, which operates on the batches. This could lead to flaky -- tests because the input data is small and PostgreSQL switches from IndexScans to -- SequentialScans. Disable the optimization for the following tests to ensure we have -- stable query plans in all CI environments. SET timescaledb.enable_decompression_sorted_merge = 0; vacuum analyze :TEST_TABLE; -- test ASC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; -- test DESC for ordered chunks :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; -- test query with ORDER BY column not in targetlist :PREFIX SELECT pg_typeof(device_id), pg_typeof(v2) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; -- ORDER BY may include other columns after time column :PREFIX SELECT time, device_id, v0 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; -- test RECORD in targetlist :PREFIX SELECT (time, device_id, v0) FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time DESC, device_id LIMIT 1; -- test sort column not in targetlist :PREFIX SELECT time_bucket('1h', time) FROM :TEST_TABLE ORDER BY time DESC LIMIT 1; -- queries with ORDER BY non-time column shouldn't use ordered append :PREFIX SELECT device_id FROM :TEST_TABLE ORDER BY device_id LIMIT 1; -- time column must be primary sort order SET enable_seqscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY device_id, time LIMIT 1; RESET enable_seqscan; -- test equality constraint on ORDER BY prefix -- currently not optimized SET enable_seqscan TO false; SET enable_indexonlyscan TO false; :PREFIX SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time LIMIT 10; RESET enable_seqscan; RESET enable_indexonlyscan; -- queries without LIMIT should use ordered append :PREFIX SELECT time FROM :TEST_TABLE WHERE device_id IN (1, 2) OR time > '2000-01-06' ORDER BY time ASC; -- queries without ORDER BY shouldnt use ordered append SET enable_seqscan TO false; :PREFIX SELECT pg_typeof(time) FROM :TEST_TABLE LIMIT 1; RESET enable_seqscan; -- test interaction with constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time ASC LIMIT 1; :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-07' ORDER BY time DESC LIMIT 1; -- test interaction with runtime exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz ORDER BY time ASC LIMIT 1; -- test constraint exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz AND time < '2000-01-10' ORDER BY time ASC LIMIT 1; :PREFIX SELECT time FROM :TEST_TABLE WHERE time < '2000-01-08'::text::timestamptz AND time > '2000-01-07' ORDER BY time ASC LIMIT 1; -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; -- min/max queries :PREFIX SELECT max(time) FROM :TEST_TABLE; :PREFIX SELECT min(time) FROM :TEST_TABLE; -- test first/last (doesn't use ordered append yet) :PREFIX SELECT first(time, time) FROM :TEST_TABLE; :PREFIX SELECT last(time, time) FROM :TEST_TABLE; -- test query with time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY time ASC LIMIT 1; -- test query with ORDER BY time_bucket :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; -- test query with ORDER BY time_bucket, device_id -- must not use ordered append :PREFIX SELECT time_bucket('1d', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time_bucket('1d', time), device_id LIMIT 1; -- test query with ORDER BY date_trunc :PREFIX SELECT time_bucket('1d', time) FROM :TEST_TABLE ORDER BY date_trunc('day', time) LIMIT 1; -- test query with ORDER BY date_trunc :PREFIX SELECT date_trunc('day', time) FROM :TEST_TABLE ORDER BY 1 LIMIT 1; -- test query with ORDER BY date_trunc, device_id -- must not use ordered append :PREFIX SELECT date_trunc('day', time), device_id, v0 FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY 1, 2 LIMIT 1; -- test query with now() should result in ordered ChunkAppend :PREFIX SELECT time FROM :TEST_TABLE WHERE time < now() + '1 month' ORDER BY time DESC LIMIT 1; -- test CTE :PREFIX WITH i AS ( SELECT time FROM :TEST_TABLE WHERE time < now() ORDER BY time DESC LIMIT 100 ) SELECT * FROM i; -- test CTE -- no chunk exclusion for CTE because cte query is not pulled up SET enable_seqscan TO false; :PREFIX WITH cte AS ( SELECT time FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ) SELECT * FROM cte WHERE time < '2000-02-01'::timestamptz; RESET enable_seqscan; -- test subquery -- not ChunkAppend so no chunk exclusion :PREFIX SELECT time FROM :TEST_TABLE WHERE time = ( SELECT max(time) FROM :TEST_TABLE) ORDER BY time; -- test ordered append with limit expression :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT ( SELECT length('four')); -- test with ordered guc disabled SET timescaledb.enable_ordered_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; RESET timescaledb.enable_ordered_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; -- test with chunk append disabled SET timescaledb.enable_chunk_append TO OFF; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; RESET timescaledb.enable_chunk_append; :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time LIMIT 3; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/ordered_append_load.sql�������������������������������������0000664�0000000�0000000�00000015062�15100345067�0024555�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- create normal hypertable with dropped columns, each chunk will have different attribute numbers CREATE TABLE metrics(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics','time',create_default_indexes:=false); ALTER TABLE metrics DROP COLUMN filler_1; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics(time DESC); CREATE INDEX ON metrics(device_id,time DESC); ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space','time','device_id',3,create_default_indexes:=false); ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space(time); CREATE INDEX ON metrics_space(device_id,time); ANALYZE metrics_space; -- create hypertable with compression CREATE TABLE metrics_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_compressed','time',create_default_indexes:=false); ALTER TABLE metrics_compressed DROP COLUMN filler_1; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_2; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id-1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_compressed DROP COLUMN filler_3; INSERT INTO metrics_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_compressed(time); CREATE INDEX ON metrics_compressed(device_id,time); ANALYZE metrics_compressed; -- compress chunks ALTER TABLE metrics_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_compressed')); -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_4; -- create hypertable with space partitioning and compression CREATE TABLE metrics_space_compressed(filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_space_compressed','time','device_id',3,create_default_indexes:=false); ALTER TABLE metrics_space_compressed DROP COLUMN filler_1; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz,'2000-01-05 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_2; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz,'2000-01-12 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); ALTER TABLE metrics_space_compressed DROP COLUMN filler_3; INSERT INTO metrics_space_compressed(time,device_id,v0,v1,v2,v3) SELECT time, device_id, device_id+1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz,'2000-01-19 23:55:00+0','2m') gtime(time), generate_series(1,5,1) gdevice(device_id); CREATE INDEX ON metrics_space_compressed(time); CREATE INDEX ON metrics_space_compressed(device_id,time); ANALYZE metrics_space_compressed; -- compress chunks ALTER TABLE metrics_space_compressed SET (timescaledb.compress, timescaledb.compress_orderby='time DESC', timescaledb.compress_segmentby='device_id'); SELECT compress_chunk(show_chunks('metrics_space_compressed')); -- Reindexing compressed hypertable to update statistics -- this is for planner tests which depend on them -- necessary because this operation was previously done by compress_chunk REINDEX TABLE _timescaledb_internal._compressed_hypertable_6; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/rand_generator.sql������������������������������������������0000664�0000000�0000000�00000001240�15100345067�0023566�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -------------------------- -- cheap rand generator -- -------------------------- create table rand_minstd_state(i bigint); create function rand_minstd_advance(bigint) returns bigint language sql immutable as $$ select (16807 * $1) % 2147483647 $$; create function gen_rand_minstd() returns bigint language sql security definer as $$ update rand_minstd_state set i = rand_minstd_advance(i) returning i $$; -- seed the random num generator insert into rand_minstd_state values (321); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/recompress_basic.sql����������������������������������������0000664�0000000�0000000�00000016612�15100345067�0024130�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE TABLE test2 (timec timestamptz NOT NULL, i integer , b bigint, t text); SELECT table_name from create_hypertable('test2', 'timec', chunk_time_interval=> INTERVAL '7 days'); INSERT INTO test2 SELECT q, 10, 11, 'hello' FROM generate_series( '2020-01-03 10:00:00+00', '2020-01-03 12:00:00+00' , '5 min'::interval) q; ALTER TABLE test2 set (timescaledb.compress, timescaledb.compress_segmentby = 'b', timescaledb.compress_orderby = 'timec DESC'); SELECT compress_chunk(c) FROM show_chunks('test2') c; ---insert into the middle of the range --- INSERT INTO test2 values ( '2020-01-03 10:01:00+00', 20, 11, '2row'); INSERT INTO test2 values ( '2020-01-03 11:01:00+00', 20, 11, '3row'); INSERT INTO test2 values ( '2020-01-03 12:01:00+00', 20, 11, '4row'); --- insert a new segment by --- INSERT INTO test2 values ( '2020-01-03 11:01:00+00', 20, 12, '12row'); SELECT time_bucket(INTERVAL '2 hour', timec), b, count(*) FROM test2 GROUP BY time_bucket(INTERVAL '2 hour', timec), b ORDER BY 1, 2; --check status for chunk -- SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; SELECT compressed_chunk_schema || '.' || compressed_chunk_name as "COMP_CHUNK_NAME", chunk_schema || '.' || chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' \gset SELECT count(*) from test2; SELECT compress_chunk(:'CHUNK_NAME'::regclass); -- Demonstrate that no locks are held on the hypertable, chunk, or the -- compressed chunk after recompress_chunk has executed. SELECT pid, locktype, relation, relation::regclass, mode, granted FROM pg_locks WHERE relation::regclass::text IN (:'CHUNK_NAME', :'COMP_CHUNK_NAME', 'test2') ORDER BY pid; SELECT chunk_status, chunk_name as "CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; --- insert into a compressed chunk again + a new chunk-- INSERT INTO test2 values ( '2020-01-03 11:01:03+00', 20, 11, '33row'), ( '2020-01-03 11:01:06+00', 20, 11, '36row'), ( '2020-01-03 11:02:00+00', 20, 12, '12row'), ( '2020-04-03 00:02:00+00', 30, 13, '3013row'); SELECT time_bucket(INTERVAL '2 hour', timec), b, count(*) FROM test2 GROUP BY time_bucket(INTERVAL '2 hour', timec), b ORDER BY 1, 2; --chunk status should be partially compressed for the previously compressed chunk SELECT chunk_status, chunk_name as "CHUNK_NAME", compressed_chunk_name as "COMPRESSED_CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; SELECT add_compression_policy AS job_id FROM add_compression_policy('test2', '30d'::interval) \gset CALL run_job(:job_id); CALL run_job(:job_id); -- status should be compressed --- -- compressed chunk name should not change for -- the partially compressed chunk indicating -- it was done segmentwise SELECT chunk_status, chunk_name as "CHUNK_NAME", compressed_chunk_name as "COMPRESSED_CHUNK_NAME" FROM compressed_chunk_info_view WHERE hypertable_name = 'test2' ORDER BY chunk_name; \set ON_ERROR_STOP 0 -- call compress_chunk when status is not unordered SELECT compress_chunk(:'CHUNK_NAME'::regclass); -- This will succeed and compress the chunk for the test below. SELECT compress_chunk(:'CHUNK_NAME'::regclass); --now decompress it , then try and recompress SELECT decompress_chunk(:'CHUNK_NAME'::regclass); SELECT compress_chunk(:'CHUNK_NAME'::regclass); \set ON_ERROR_STOP 1 -- test recompress policy CREATE TABLE metrics(time timestamptz NOT NULL); SELECT hypertable_id AS "HYPERTABLE_ID", schema_name, table_name, created FROM create_hypertable('metrics','time') \gset ALTER TABLE metrics SET (timescaledb.compress); -- create chunk with some data and compress INSERT INTO metrics SELECT '2000-01-01' FROM generate_series(1,10); -- create custom compression job without recompress boolean SELECT add_job('_timescaledb_functions.policy_compression','1w',('{"hypertable_id": '||:'HYPERTABLE_ID'||', "compress_after": "@ 7 days"}')::jsonb, initial_start => '2000-01-01 00:00:00+00'::timestamptz) AS "JOB_COMPRESS" \gset -- first call should compress CALL run_job(:JOB_COMPRESS); -- 2nd call should do nothing CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- do an INSERT so recompress has something to do INSERT INTO metrics SELECT '2000-01-01'; ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- should recompress CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- disable recompress in compress job SELECT alter_job(id,config:=jsonb_set(config,'{recompress}','false'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; -- nothing to do CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- do an INSERT so recompress has something to do INSERT INTO metrics SELECT '2000-01-01'; ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- still nothing to do since we disabled recompress CALL run_job(:JOB_COMPRESS); ---- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- reenable recompress in compress job SELECT alter_job(id,config:=jsonb_set(config,'{recompress}','true'), next_start => '2000-01-01 00:00:00+00'::timestamptz) FROM _timescaledb_config.bgw_job WHERE id = :JOB_COMPRESS; -- should recompress now CALL run_job(:JOB_COMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; SELECT delete_job(:JOB_COMPRESS); SELECT add_job('_timescaledb_functions.policy_recompression','1w',('{"hypertable_id": '||:'HYPERTABLE_ID'||', "recompress_after": "@ 7 days", "maxchunks_to_compress": 1}')::jsonb) AS "JOB_RECOMPRESS" \gset ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; ---- nothing to do yet CALL run_job(:JOB_RECOMPRESS); ---- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; -- create some work for recompress INSERT INTO metrics SELECT '2000-01-01'; -- status should be 3 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; CALL run_job(:JOB_RECOMPRESS); -- status should be 1 SELECT chunk_status FROM compressed_chunk_info_view WHERE hypertable_name = 'metrics'; SELECT delete_job(:JOB_RECOMPRESS); ����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/scheduler_fixed_common.sql����������������������������������0000664�0000000�0000000�00000011161�15100345067�0025304�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; \set client_min_messages = DEBUG; -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022, in particular, between 1am and 2 am (old time) select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :FINISH_TIME_AFTER_SUMMER_SWITCH, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_SUMMER_SWITCH as initial_start_summer_switch, :FINISH_TIME_AFTER_SUMMER_SWITCH as first_finish_time_summer_switch; select :'t1' as without_timezone, :'t1_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; --------- and then +2 to +1 select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH) as t1 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :FINISH_TIME_AFTER_WINTER_SWITCH, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t1_tz \gset select :START_TIME_BEFORE_WINTER_SWITCH as initial_start_winter_switch, :FINISH_TIME_AFTER_WINTER_SWITCH as first_finish_time_winter_switch; select :'t1' as without_timezone, :'t1_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t2 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t1_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t3 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t2_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH) as t4 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_SUMMER_WINTER, :'t3_tz'::timestamptz, :START_TIME_BEFORE_WINTER_SWITCH, 'Europe/Berlin') as t4_tz \gset select :'t4' as without_timezone, :'t4_tz' as with_timezone; select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH) as t5 \gset select ts_test_next_scheduled_execution_slot(:BUCKET_WIDTH_WINTER_SUMMER, :'t4_tz'::timestamptz, :START_TIME_BEFORE_SUMMER_SWITCH, 'Europe/Berlin') as t5_tz \gset select :'t5' as without_timezone, :'t5_tz' as with_timezone; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_comp_query.sql������������������������������������0000664�0000000�0000000�00000035527�15100345067�0025030�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; -- multicolumn sort not matching compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; -- same result when we use compressed IndexPath with pathkeys not matching DecompressChunk path required path keys SET enable_seqscan TO false; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time DESC; RESET enable_seqscan; -- Distinct column not a segmentby column: should be no SkipScan :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev = 1 ORDER BY time DESC; -- multicolumn sort with dev as non-leading column and with leading column pinned -- we are able to apply SkipScan here after resolving #7998 :PREFIX SELECT DISTINCT time, dev FROM :TABLE WHERE time = 100 ORDER BY time, dev; -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- dev is leading column :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev DESC, dev_name DESC; -- query sort doesn't match "segmentby" sort :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE ORDER BY dev, dev_name DESC; -- dev_name is not a leading column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 ORDER BY dev_name; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev = 1 AND dev_name IS NOT NULL ORDER BY dev_name; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev = 1; -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; -- use SkipScan as only one non-const distinct column :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT dev + 1, 'q1_13' FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist counts as extra distinct column, no SkipScan :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time DESC; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests -- no SkipScan as distinct is over subquery :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT val, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; -- no SkipScan: 2 distinct columns :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev, val) dev, val FROM :TABLE WHERE dev IS NOT NULL UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (val) dev, val FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE where val IS NULL; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE val IS NULL AND dev > 100; SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_dagg_comp_query.sql�������������������������������0000664�0000000�0000000�00000034131�15100345067�0026000�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- test different compression configurations -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev; -- NULLS FIRST doesn't match segmentby NULL direction :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- multicolumn "segmentby = 'dev, dev_name'" SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- multicolumn compressed index with dev as leading column :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; -- multicolumn compressed index with dev as leading column and with extra distinct column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev_name = 'device_1'; -- multicolumn compressed index with dev as non-leading column :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev_name), dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev_name; -- multicolumn compressed index with dev as non-leading column and with leading column pinned -- TODO: should be able to apply SkipScan here, issue created: #7998 :PREFIX SELECT count(DISTINCT dev), count(DISTINCT dev_name) FROM :TABLE WHERE dev = 1; -- Basic tests for "segmentby = 'dev'" ----------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT dev + 1), 'q1_13' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; -- Basic tests for text index "segmentby = 'dev_name'" ------------------------------------------------------ SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; -- Various tests for "segmentby = 'dev'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries -- "segmentby = 'dev, val'" --------------------------------------- SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time', timescaledb.compress_segmentby='dev, val'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT val) FROM :TABLE WHERE dev = 1; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT val) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query RESET max_parallel_workers_per_gather; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where val IS NULL; -- no tuples in resultset :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE val IS NULL AND dev > 100; SELECT decompress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_dagg_load_comp_query.sql��������������������������0000664�0000000�0000000�00000016010�15100345067�0026773�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC NULLS FIRST; \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; -- expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE set enable_seqscan to off; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; RESET max_parallel_workers_per_gather; RESET enable_seqscan; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_dagg_query.sql������������������������������������0000664�0000000�0000000�00000030776�15100345067�0024775�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan_for_distinct_aggregates') AS enable_dagg_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev IS NOT NULL GROUP BY dev ORDER BY dev DESC; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 GROUP BY dev; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL GROUP BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IN ('device_1','device_2'); DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT count(DISTINCT dev%3) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev%3), dev%3 FROM :TABLE GROUP BY dev%3 ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE -- Various distint aggs over same column is OK :PREFIX SELECT count(DISTINCT dev), sum(DISTINCT dev), 'q1_1' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), max(DISTINCT dev_name), 'q1_2' FROM :TABLE; -- Distinct agg over Const is OK :PREFIX SELECT count(DISTINCT dev), count(DISTINCT 2), 'q1_3', NULL FROM :TABLE; -- DISTINCT over distinct agg is OK :PREFIX SELECT DISTINCT count(DISTINCT dev), dev, 'q1_4' FROM :TABLE GROUP BY dev ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q1_5', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_6', length(md5(now()::text)) FROM :TABLE; -- volatile expression in targetlist :PREFIX SELECT count(DISTINCT dev), 'q1_7', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT count(DISTINCT dev_name), 'q1_8', length(md5(random()::text)) FROM :TABLE; -- Mix of aggregates on different columns and distinct/not distinct -- currently not supported by skipscan :PREFIX SELECT count(DISTINCT dev), max(DISTINCT dev_name), 'q1_9' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), sum(dev), 'q1_10' FROM :TABLE; :PREFIX SELECT count(DISTINCT dev), dev_name, 'q1_11' FROM :TABLE GROUP BY dev_name ORDER BY dev_name; -- distinct on expressions not supported :PREFIX SELECT count(DISTINCT time_bucket(10,time)), 'q1_12' FROM :TABLE; :PREFIX SELECT count(DISTINCT length(dev_name)), 'q1_13' FROM :TABLE; :PREFIX SELECT count(DISTINCT 3*time), 'q1_14' FROM :TABLE; -- But expressions over distinct aggregates are supported :PREFIX SELECT count(DISTINCT dev) + 1, sum(DISTINCT dev)/count(DISTINCT dev), 'q1_15' FROM :TABLE; -- DISTINCT aggs grouped on their args :PREFIX SELECT count(DISTINCT dev), dev, 'q2_1' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_2', NULL FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, 'q2_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_immutable(), 'q2_5' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_stable(), 'q2_6' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev, int_func_volatile(), 'q2_7' FROM :TABLE GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev+1, 'q2_8' FROM :TABLE GROUP BY dev ORDER BY 2; :PREFIX SELECT count(DISTINCT dev), dev+1, dev+2, 'q2_9' FROM :TABLE GROUP BY dev, dev; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT time, count(DISTINCT dev), 'q2_10' FROM :TABLE GROUP BY time; -- Cannot do SkipScan if we group on 2+ columns :PREFIX SELECT count(DISTINCT dev), dev, tableoid::regclass, 'q2_11' FROM :TABLE GROUP BY dev, tableoid ORDER BY dev, tableoid; -- DISTINCT aggs grouped on their TEXT args :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_1' FROM :TABLE GROUP BY dev_name; -- Test not-NULL mode :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_11' FROM :TABLE WHERE dev_name IS NOT NULL GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_2', NULL FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_3', length(md5(now()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, 'q3_4', length(md5(random()::text)) FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name::varchar), dev_name::varchar, 'q3_5' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_immutable(), 'q3_6' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_stable(), 'q3_7' FROM :TABLE GROUP BY dev_name; :PREFIX SELECT count(DISTINCT dev_name), dev_name, int_func_volatile(), 'q3_8' FROM :TABLE GROUP BY dev_name; -- Cannot do SkipScan as we group on a column which is not the distinct agg argument :PREFIX SELECT count(DISTINCT dev_name), dev_name, tableoid::regclass, 'q3_9' FROM :TABLE GROUP BY dev_name, tableoid ORDER BY dev_name, tableoid; -- Can do SkipScan if extra group column is eliminated by pinning to a Const -- and when it changes group by ordering :PREFIX SELECT count(DISTINCT dev_name), dev, dev_name FROM :TABLE WHERE dev = 1 GROUP BY dev, dev_name ORDER BY dev, dev_name; \qecho LIMIT queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev LIMIT 3; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE GROUP BY dev ORDER BY dev DESC LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time BETWEEN 100 AND 300 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time < 200 GROUP BY dev; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 800 GROUP BY dev; \qecho ordered append on :TABLE :PREFIX SELECT count(DISTINCT time), time FROM :TABLE WHERE time BETWEEN 0 AND 5000 GROUP BY time; \qecho SUBSELECTS on :TABLE :PREFIX SELECT c1, c2, 'q4_1' FROM (SELECT count(DISTINCT dev) as c1, sum(DISTINCT dev) as c2 FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_2' FROM (SELECT count(DISTINCT dev) as dev FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, c1, 2, c3, 'q4_3' FROM (SELECT count(DISTINCT dev) as c1, dev, 1 as c3 FROM :TABLE GROUP BY dev) a; \qecho ORDER BY :PREFIX SELECT c, dev, 'q5_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev) a; :PREFIX SELECT c, dev, 'q5_2' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev ORDER BY dev DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT c, dev, 'q6_1' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE WHERE dev > 5 GROUP BY dev) a; :PREFIX SELECT c, dev, 'q6_2' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev HAVING sum(DISTINCT dev)>2) a; :PREFIX SELECT c, dev, 'q6_3' FROM (SELECT count(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE dev > 5; :PREFIX SELECT c, dev, 'q6_4' FROM (SELECT sum(DISTINCT dev) as c, dev FROM :TABLE GROUP BY dev) a WHERE c > 2; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT count(DISTINCT dev), 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE:PREFIX SELECT count(DISTINCT dev), 'q6_7' FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT count(DISTINCT dev), 'q6_8' FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT count(DISTINCT dev), 'q6_9' FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT count(DISTINCT dev), 'q6_10' FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- always false expr similar to our initial skip qual :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 GROUP BY dev ORDER BY dev; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT count(DISTINCT dev_name) FROM :TABLE WHERE dev_name IS NULL; -- Distinct aggregate path with no pathkeys because of Const predicate. -- PG is smart to add LIMIT 1 to SELECT DISTINCT in this case, -- but not smart enough to add LIMIT 1 to distinct aggregate input. -- TODO: create an issue for this task, i.e. add LIMIT 1 to distinct aggregate input when input equals to a Const :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE dev = 1; :PREFIX SELECT count(DISTINCT dev), dev FROM :TABLE WHERE dev = 1 GROUP BY dev ORDER BY dev DESC; -- CTE :PREFIX WITH devices AS ( SELECT count(DISTINCT dev) FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT dev, count(DISTINCT dev) FROM :TABLE GROUP BY dev ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT count(DISTINCT dev_name) FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT c, 'q7_1' FROM (SELECT count(DISTINCT dev) c FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT c, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT c, 'q8_1' FROM (SELECT * FROM (VALUES (1), (2)) a(v), LATERAL (SELECT count(DISTINCT dev) c FROM :TABLE WHERE dev >= a.v) b) c; -- DISTINCT aggs on different columns in different subqueries :PREFIX SELECT count(DISTINCT dev) FROM :TABLE UNION ALL SELECT count(DISTINCT time) FROM :TABLE; :PREFIX SELECT *, 'q9_2' FROM (SELECT count(DISTINCT dev) cd, dev FROM :TABLE GROUP BY dev) a, LATERAL (SELECT count(DISTINCT time) ct FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(dev, val, query) SELECT dev, sd, 'q10_1' FROM (SELECT sum(DISTINCT dev) sd, dev FROM :TABLE GROUP BY dev) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT count(DISTINCT time) FROM skip_scan_nulls WHERE time IS NOT NULL; ��timescaledb-2.23.0/tsl/test/sql/include/skip_scan_dagg_query_ht.sql���������������������������������0000664�0000000�0000000�00000003455�15100345067�0025462�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT count(DISTINCT 1) FROM pg_rewrite; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE where dev=1; -- SkipScan with ordered append :PREFIX SELECT count(DISTINCT time), time FROM :TABLE GROUP BY time ORDER BY time; --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- compression on one chunk doesnt prevent skipscan on other chunks SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- compression on one chunk will prevent skipscan if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); -- skipscan will be applied on decompressed chunk if it's the only chunk remaining :PREFIX SELECT count(DISTINCT dev) FROM :TABLE WHERE time = 100; --baseline query with skipscan :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx1; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_time_idx; :PREFIX SELECT count(DISTINCT dev) FROM :TABLE; RESET timescaledb.enable_compressed_skipscan; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_load.sql������������������������������������������0000664�0000000�0000000�00000016345�15100345067�0023561�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE skip_scan(time int, dev int, dev_name text, val int); INSERT INTO skip_scan SELECT t, d, 'device_' || d::text, t*d FROM generate_series(1, 1000) t, generate_series(1, 10) d; INSERT INTO skip_scan VALUES (NULL, 0, -1, NULL), (0, NULL, -1, NULL); INSERT INTO skip_scan(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan; CREATE TABLE skip_scan_nulls(time int); CREATE INDEX ON skip_scan_nulls(time); INSERT INTO skip_scan_nulls SELECT NULL FROM generate_series(1,100); ANALYZE skip_scan_nulls; -- create hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_ht(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_ht', 'time', chunk_time_interval => 250, create_default_indexes => false); INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f1; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f2; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_ht DROP COLUMN f3; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_ht(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_ht; ALTER TABLE skip_scan_ht SET (timescaledb.compress,timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); -- create compressed hypertable with different physical layouts in the chunks CREATE TABLE skip_scan_htc(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htc', 'time', chunk_time_interval => 250, create_default_indexes => false); ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f1; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f2; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htc DROP COLUMN f3; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htc(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; ANALYZE skip_scan_htc; CREATE TABLE skip_scan_insert(time int, dev int, dev_name text, val int, query text); CREATE OR REPLACE FUNCTION int_func_immutable() RETURNS int LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$SELECT 1; $$; CREATE OR REPLACE FUNCTION int_func_stable() RETURNS int LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT 2; $$; CREATE OR REPLACE FUNCTION int_func_volatile() RETURNS int LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT 3; $$; CREATE OR REPLACE FUNCTION inta_func_immutable() RETURNS int[] LANGUAGE SQL IMMUTABLE SECURITY DEFINER AS $$ SELECT ARRAY[1,2,3]; $$; CREATE OR REPLACE FUNCTION inta_func_stable() RETURNS int[] LANGUAGE SQL STABLE SECURITY DEFINER AS $$ SELECT ARRAY[2,3,4]; $$; CREATE OR REPLACE FUNCTION inta_func_volatile() RETURNS int[] LANGUAGE SQL VOLATILE SECURITY DEFINER AS $$ SELECT ARRAY[3,4,5]; $$; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_nulls'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_ht'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_ht'::regclass); UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htc'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htc'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan set (autovacuum_enabled = off); alter table skip_scan_nulls set (autovacuum_enabled = off); alter table skip_scan_ht set (autovacuum_enabled = off); alter table skip_scan_htc set (autovacuum_enabled = off); -- create compressed hypertable with different physical layouts in the compressed chunks CREATE TABLE skip_scan_htcl(f1 int, f2 int, f3 int, time int NOT NULL, dev int, dev_name text, val int); SELECT create_hypertable('skip_scan_htcl', 'time', chunk_time_interval => 250, create_default_indexes => false); ALTER TABLE skip_scan_htcl SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(0, 249) t, generate_series(1, 10) d; -- Make sure 1st compressed chunk has columns which will be dropped later, it also doesn't have NULLs SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch; ALTER TABLE skip_scan_htcl DROP COLUMN f1; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(250, 499) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f2; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(500, 749) t, generate_series(1, 10) d; ALTER TABLE skip_scan_htcl DROP COLUMN f3; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, d, 'device_' || d::text, random() FROM generate_series(750, 999) t, generate_series(1, 10) d; INSERT INTO skip_scan_htcl(time,dev,dev_name,val) SELECT t, NULL, NULL, NULL FROM generate_series(0, 999, 50) t; -- The rest of the compressed chunks do not have dropped columns -- compressed chunks #2 and #3 have attnos out of sync with uncompressed chunks SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htcl') ch order by 1 desc limit 3; ANALYZE skip_scan_htcl; -- adjust statistics so we get skipscan plans UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid='skip_scan_htcl'::regclass; UPDATE pg_statistic SET stadistinct=1, stanullfrac=0.5 WHERE starelid IN (select inhrelid from pg_inherits where inhparent='skip_scan_htcl'::regclass); -- Turn off autovacuum to not trigger new vacuums that restores the -- adjusted statistics alter table skip_scan_htcl set (autovacuum_enabled = off); �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_load_comp_query.sql�������������������������������0000664�0000000�0000000�00000015410�15100345067�0026014�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_compressed_skipscan') AS enable_compressed_skipscan; -- To avoid ambiguity in test EXPLAIN outputs due to mixing of chunk plans with no SkipScan SET max_parallel_workers_per_gather = 0; -- Run SkipScan queries on the provided compression layout -- compressed index on "segmentby='dev'" has default "dev ASC, NULLS LAST" sort order -- SkipScan used when sort order on distinct column "dev" matches "segmentby" sort order :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- multicolumn sort with dev as leading column matching (segmentby dev, order by time DESC) compression index :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, time FROM :TABLE ORDER BY dev DESC, time; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time DESC; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time DESC LIMIT 3; \qecho range queries on :TABLE set enable_seqscan to off; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; reset enable_seqscan; -- Various tests for "segmentby = 'dev'" --------------------------------------- \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time DESC) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; -- Force not choosing SeqScan under DecompressChunks before SkipScan can evaluate it, -- as cost of scanning and sorting a small dataset can be less than scanning an index, including startup cost. -- After the fix in #8056 we take startup costs into account, -- but even startup costs for scanning and sorting can be smaller for seqscan if we also have a filter on the index columns. -- So for below queries with filters on "dev" we still need to disable SeqScan to choose IndexScan+SkipScan. SET enable_seqscan = false; :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests -- have SkipScan as Distinct is over index :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; RESET max_parallel_workers_per_gather; RESET enable_seqscan; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_multi_load.sql������������������������������������0000664�0000000�0000000�00000010427�15100345067�0024766�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Create tables with 4 not-null index columns (ASC, DESC, ASC, ASC) to test various multikey SkipScan scenarios -- Not-null scenarios are tested separately in skip_scan_notnull.sql, here we are testing multi-keys specifically CREATE TABLE mskip_scan(time int not null, status int not null, region text not null, dev int not null, dev_name text not null, val int); -- Status: (1,2), region: (reg1..reg4), dev: (1..5), dev_name same as dev, 4000 timestamps divided into 4 chunks tied to status, 80K rows total -- We want to test both (1 distinct, N distinct) and (N distinct, 1 distinct) scenarios, -- (status,*) where time<100 will do for the former, (dev, dev_name) will do for the latter INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(0, 999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(1000, 1999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(2000, 2999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(3000, 3999) t, generate_series(1, 4) r, generate_series(1, 5) d; CREATE INDEX on mskip_scan(status, region, dev, dev_name); -- To test reverse column orders CREATE INDEX on mskip_scan(status, region DESC, dev); ANALYZE mskip_scan; -- Same with a hypertable CREATE TABLE mskip_scan_ht(time int not null, status int not null, region text not null, dev int not null, dev_name text not null, val int); SELECT create_hypertable('mskip_scan_ht', 'time', chunk_time_interval => 1000, create_default_indexes => false); INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(0, 999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(1000, 1999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(2000, 2999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_ht SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(3000, 3999) t, generate_series(1, 4) r, generate_series(1, 5) d; CREATE INDEX on mskip_scan_ht(status, region, dev, dev_name); -- To test reverse column orders CREATE INDEX on mskip_scan_ht(status, region DESC, dev); ANALYZE mskip_scan_ht; -- Same with columnar CREATE TABLE mskip_scan_htc(time int not null, status int not null, region text not null, dev int not null, dev_name text not null, val int); SELECT create_hypertable('mskip_scan_htc', 'time', chunk_time_interval => 1000, create_default_indexes => false); -- Cannot have reverse orders on segmented columns in columnar index, so it won't be tested for columnar table ALTER TABLE mskip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='status,region,dev,dev_name'); INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(0, 999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(1000, 1999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(2000, 2999) t, generate_series(1, 4) r, generate_series(1, 5) d; INSERT INTO mskip_scan_htc SELECT t, 1, 'reg_' || r::text, d, 'device_' || d::text, t*d FROM generate_series(3000, 3999) t, generate_series(1, 4) r, generate_series(1, 5) d; SELECT compress_chunk(ch) FROM show_chunks('mskip_scan_htc') ch; ANALYZE mskip_scan_htc; alter table mskip_scan set (autovacuum_enabled = off); alter table mskip_scan_ht set (autovacuum_enabled = off); alter table mskip_scan_htc set (autovacuum_enabled = off); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_multi_query.sql�����������������������������������0000664�0000000�0000000�00000011601�15100345067�0025207�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_multikey_skipscan') AS enable_multikey_skipscan; -- multicolumn index with uniform order :PREFIX SELECT DISTINCT ON(status, region, dev, dev_name) * FROM :TABLE ORDER BY status, region, dev, dev_name; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region DESC, dev DESC; -- index with reverse column orders (applied to non-columnstore ony) :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE ORDER BY status, region DESC, dev; :PREFIX SELECT DISTINCT ON(region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev DESC; set enable_seqscan=0; -- (1,N) distinct scenario :PREFIX SELECT DISTINCT status, dev FROM :TABLE WHERE time < 100 AND region = 'reg_1' ORDER BY 1,2; -- (N,1) distinct scenario :PREFIX SELECT DISTINCT dev, dev_name FROM :TABLE WHERE status = 1 AND region = 'reg_1' ORDER BY 1,2; -- SELECT list order of distinct columns shouldn't matter if OBY matches index order :PREFIX SELECT DISTINCT dev, status, dev_name FROM :TABLE WHERE region = 'reg_2' ORDER BY status, dev, dev_name; reset enable_seqscan; -- Basic queries :PREFIX SELECT DISTINCT region, dev, 'q1_3', NULL FROM :TABLE WHERE status = 1 ORDER BY region, dev; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, tableoid::regclass, 'q2_11' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_immutable(), 'q2_12' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_stable(), 'q2_13' FROM :TABLE WHERE status = 1; :PREFIX SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name, int_func_volatile(), 'q2_14' FROM :TABLE WHERE status = 1; \qecho ordered append on :TABLE :PREFIX SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 AND time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, region, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1) a; :PREFIX SELECT NULL, region, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (region, dev) * FROM :TABLE WHERE status = 1 ORDER BY region, dev) a; -- RowCompareExpr :PREFIX SELECT DISTINCT ON (status, dev) * FROM :TABLE WHERE region = 'reg_1' and (status, dev) > (1,2); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > NULL and status > NULL and region > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev > 20; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE status = 1 ORDER BY status, region; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT status, region, dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) AND (sq.status = ref.status) AND (sq.region = ref.region) WHERE 1 > 2; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT ON (region, dev) region, dev FROM :TABLE WHERE status = 1 ) SELECT * FROM devices ORDER BY region, dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (region, dev, dev_name) region, dev, dev_name FROM :TABLE WHERE status = 1; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, status, region, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (status, region, dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; set enable_seqscan=0; :PREFIX SELECT time, status, region, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, status, region, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (status, region, dev) * FROM :TABLE WHERE dev >= a.v) b) c; reset enable_seqscan; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT status, region, dev FROM :TABLE ORDER BY status, region, dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); �������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_notnull.sql���������������������������������������0000664�0000000�0000000�00000006304�15100345067�0024327�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Base queries with regular NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE; :PREFIX SELECT DISTINCT dev FROM :TABLE order by dev DESC; -- Index quals except IS NULL discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev > 2; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev BETWEEN 1 AND 5; -- next two filters produce small output for which we may select seqscan, don't want it set enable_seqscan=0; :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev in (1,2,3); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NULL; -- PG is smart enough to convert negation of IS NOT NULL to IS NULL index condition :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE (dev IS NOT NULL) = false; -- Complex expressions over IS NOT NULL are non-strict filters :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE ((dev is null) = false)::int + 1 > 1; reset enable_seqscan; -- Strict Index filters discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev * 2 < 8; -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev < 2 OR dev > 0; -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,-1) < 1; -- Strict non-index filters on relation discard NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100; -- OR is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev + time < 100 OR dev > 0; -- Coalesce is non-strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100; -- If at least one filter is strict then it filters out NULLs :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE coalesce(dev,20) + time < 100 and dev + time < 100; -- Index qual on a non-skip key: skip key can be NULL :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1'; -- Index quals on several keys including skip key :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev_name > 'device_1' and dev > 2; -- Index qual row comparison will filter out NULLs in skip key when skip key is a leading column -- But for compressed chunks ROW is not pushed into index quals, it is treated as a filter and is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev,dev_name) > row(1,'device_1'); -- Satisfying (dev_name>'device_1') may allow NULLs into dev :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev_name,dev) > row('device_1',1); -- Non-index qual row comparison: row comparison in general is not strict :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE row(dev+1,dev_name) > row(1,'device_1'); -- Different SkipScan column :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev=1 and dev_name IS NOT NULL; -- Boolean and NOT NULL constraint tests -- Boolean column index qual is strict :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b; :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b != true; -- Boolean column predicates could be non-strict filters, below filter can accept NULLs :PREFIX SELECT DISTINCT b FROM skip_scan_b WHERE b IS NOT true; -- dev is declared NOT NULL :PREFIX SELECT DISTINCT dev FROM skip_scan_nn; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_notnull_setup.sql���������������������������������0000664�0000000�0000000�00000002224�15100345067�0025544�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test 2-key index "(dev,dev_name)" where index qual may not be on a skip col -- Make sure it's the only index to be used for "dev" skipscan key -- skip_scan table CREATE INDEX skip_scan_dev_devname_idx ON skip_scan(dev,dev_name); -- skip_scan_ht table CREATE INDEX skip_scan_ht_dev_devname_idx ON skip_scan_ht(dev,dev_name); -- skip_scan_htc table ALTER TABLE skip_scan_htc SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev,dev_name'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_htc') ch; -- table with a bool column CREATE TABLE skip_scan_b as select dev, coalesce(time,100) time, nullif(dev%3,2)::boolean as b from skip_scan; CREATE INDEX skip_scan_b_idx ON skip_scan_b(b); --table with not null constraint CREATE TABLE skip_scan_nn as select coalesce(dev,0) dev, coalesce(time,100) time from skip_scan; ALTER TABLE skip_scan_nn ALTER COLUMN dev SET NOT NULL; CREATE INDEX skip_scan_nn_idx ON skip_scan_nn(dev); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_query.sql�����������������������������������������0000664�0000000�0000000�00000036240�15100345067�0024003�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- canary for result diff SELECT current_setting('timescaledb.enable_skipscan') AS enable_skipscan; -- test different index configurations -- no index so we cant do SkipScan :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; -- NULLS LAST index on dev CREATE INDEX skip_scan_idx_dev_nulls_last ON :TABLE(dev); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev DESC; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_nulls_last; -- NULLS FIRST index on dev CREATE INDEX skip_scan_idx_dev_nulls_first ON :TABLE(dev NULLS FIRST); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev NULLS FIRST; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev NULLS FIRST; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev NULLS FIRST; DROP INDEX skip_scan_idx_dev_nulls_first; -- multicolumn index with dev as leading column CREATE INDEX skip_scan_idx_dev_time_idx ON :TABLE(dev, time); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_dev_time_idx; -- multicolumn index with dev as non-leading column CREATE INDEX skip_scan_idx_time_dev_idx ON :TABLE(time, dev); :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time = 100; -- Test not-NULL mode :PREFIX SELECT DISTINCT dev FROM :TABLE WHERE time = 100 AND dev IS NOT NULL ORDER BY dev; DROP INDEX skip_scan_idx_time_dev_idx; -- hash index is not ordered so can't use skipscan CREATE INDEX skip_scan_idx_hash ON :TABLE USING hash(dev_name); :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IN ('device_1','device_2') ORDER BY dev_name; DROP INDEX skip_scan_idx_hash; -- expression indexes -- currently not supported by skipscan CREATE INDEX skip_scan_expr_idx ON :TABLE((dev % 3)); :PREFIX SELECT DISTINCT dev%3 FROM :TABLE ORDER BY dev%3; :PREFIX SELECT DISTINCT ON (dev%3) dev FROM :TABLE ORDER BY dev%3; DROP INDEX skip_scan_expr_idx; CREATE INDEX ON :TABLE(dev_name); -- Tests for #8107: accounting for scanning most of the input due to non-index quals -- Non-index qual, no tuples match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE val < 0 ORDER BY 1; -- Highly selective non-index qual, have to scan many tuples to match: SeqScan preferred :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 ORDER BY 1; -- Same but a combo of non-index quals :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE time = 100 and dev = 1 ORDER BY 1; -- Highly selective index qual: less tuples to scan for low-selective non-index qual, can choose SkipScan :PREFIX SELECT DISTINCT dev_name FROM :TABLE WHERE dev_name IS NULL and dev = 1 ORDER BY 1; CREATE INDEX ON :TABLE(dev); -- RowCompareExpr where some args are not in the index: -- we extract lossy "dev >=5" index condition which is strict and doesn't allow NULLs SET timescaledb.debug_skip_scan_info TO true; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); RESET timescaledb.debug_skip_scan_info; CREATE INDEX ON :TABLE(dev, time); CREATE INDEX ON :TABLE(time,dev); CREATE INDEX ON :TABLE(time,dev,val); \qecho basic DISTINCT queries on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_1' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_2' FROM :TABLE ORDER BY dev_name; :PREFIX SELECT DISTINCT dev, 'q1_3', NULL FROM :TABLE ORDER BY dev; \qecho stable expression in targetlist on :TABLE :PREFIX SELECT DISTINCT dev, 'q1_4', length(md5(now()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_5', length(md5(now()::text)) FROM :TABLE ORDER BY dev_name; -- volatile expression in targetlist :PREFIX SELECT DISTINCT dev, 'q1_6', length(md5(random()::text)) FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev_name, 'q1_7', length(md5(random()::text)) FROM :TABLE ORDER BY dev_name; -- queries without skipscan because distinct is not limited to specific column :PREFIX SELECT DISTINCT * FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT *, 'q1_9' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, time, 'q1_10' FROM :TABLE ORDER BY dev; :PREFIX SELECT DISTINCT dev, NULL, 'q1_11' FROM :TABLE ORDER BY dev; -- distinct on expressions not supported :PREFIX SELECT DISTINCT time_bucket(10,time), 'q1_12' FROM :TABLE; :PREFIX SELECT DISTINCT length(dev_name), 'q1_13' FROM :TABLE; :PREFIX SELECT DISTINCT 3*time, 'q1_14' FROM :TABLE; :PREFIX SELECT DISTINCT 'Device ' || dev_name FROM :TABLE; -- DISTINCT ON queries :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, 'q2_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) *, 'q2_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, time, 'q2_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, NULL, 'q2_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) time, 'q2_10' FROM :TABLE ORDER by dev, time; :PREFIX SELECT DISTINCT ON (dev) dev, tableoid::regclass, 'q2_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_immutable(), 'q2_12' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_stable(), 'q2_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev) dev, int_func_volatile(), 'q2_14' FROM :TABLE; -- DISTINCT ON queries on TEXT column :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; -- Test not-NULL mode :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NOT NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_2' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_3', NULL FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_4', length(md5(now()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, 'q3_5', length(md5(random()::text)) FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) * FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) *, 'q3_7' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, time, 'q3_8' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, NULL, 'q3_9' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) time, 'q3_10' FROM :TABLE ORDER by dev_name, time; :PREFIX SELECT DISTINCT ON (dev_name) dev_name, tableoid::regclass, 'q3_11' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name::varchar) dev_name::varchar FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_immutable(), 'q3_13' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_stable(), 'q3_14' FROM :TABLE; :PREFIX SELECT DISTINCT ON (dev_name) dev, int_func_volatile(), 'q3_15' FROM :TABLE; \qecho DISTINCT with wholerow var :PREFIX SELECT DISTINCT ON (dev) :TABLE FROM :TABLE; -- should not use SkipScan since we only support SkipScan on single-column distinct :PREFIX SELECT DISTINCT :TABLE FROM :TABLE; \qecho LIMIT queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev DESC, time DESC LIMIT 3; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE ORDER BY dev, time LIMIT 3; \qecho range queries on :TABLE :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time BETWEEN 100 AND 300; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time < 200; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE time > 800; \qecho ordered append on :TABLE :PREFIX SELECT * FROM :TABLE ORDER BY time; :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE WHERE time BETWEEN 0 AND 5000; \qecho SUBSELECTS on :TABLE :PREFIX SELECT time, dev, val, 'q4_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; :PREFIX SELECT NULL, dev, NULL, 'q4_3' FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a; :PREFIX SELECT time, dev, NULL, 'q4_4' FROM (SELECT DISTINCT ON (dev) dev, time FROM :TABLE) a; \qecho ORDER BY :PREFIX SELECT time, dev, val, 'q5_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev, time) a; :PREFIX SELECT time, dev, val, 'q5_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE ORDER BY dev DESC, time DESC) a; \qecho WHERE CLAUSES :PREFIX SELECT time, dev, val, 'q6_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 5) a; :PREFIX SELECT time, dev, val, 'q6_2' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE time > 5) a; :PREFIX SELECT time, dev, val, 'q6_3' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE dev > 5; :PREFIX SELECT time, dev, val, 'q6_4' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a WHERE time > 5; --\qecho immutable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_5' FROM :TABLE WHERE dev > int_func_immutable(); --\qecho stable func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) *, 'q6_6' FROM :TABLE WHERE dev > int_func_stable(); --\qecho volatile func in WHERE clause on :TABLE :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > int_func_volatile(); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_immutable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_stable()); :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = ANY(inta_func_volatile()); -- RowCompareExpr :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE (dev, time) > (5,100); -- always false expr similar to our initial skip qual :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > NULL; -- no tuples matching :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev > 20; -- multiple constraints in WHERE clause :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time = 100; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev > 5 AND time > 200; :PREFIX SELECT DISTINCT ON (dev) dev,time FROM :TABLE WHERE dev >= 5 AND dev < 7 AND dev >= 2; :PREFIX SELECT DISTINCT ON (dev) dev,time,val FROM :TABLE WHERE time > 100 AND time < 200 AND val > 10 AND val < 10000 AND dev > 2 AND dev < 7 ORDER BY dev,time; :PREFIX SELECT DISTINCT ON (dev) dev FROM :TABLE WHERE dev IS NULL; :PREFIX SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE WHERE dev_name IS NULL; -- test constants in ORDER BY :PREFIX SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev = 1 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE dev = 1 and time = 100 ORDER BY dev, time DESC; :PREFIX SELECT DISTINCT dev_name::varchar FROM :TABLE WHERE dev_name::varchar = 'device_1' ORDER BY 1; -- test distinct PathKey with sortref = 0 in PG15 due to FALSE filter not pushed into relation (should not crash in PG15) :PREFIX SELECT DISTINCT sq.dev FROM (SELECT dev FROM :TABLE) sq JOIN :TABLE ref ON (sq.dev = ref.dev) WHERE 1 > 2; -- test distinct PathKey with sortref not aligning with targets sortrefs in PG15 due to Window function :PREFIX SELECT DISTINCT case when false then c10 else c10 end as c0, max(c8) over (partition by c10 order by c6) as c1 FROM (SELECT time as c6, val as c8, dev as c10 FROM :TABLE WHERE false) subq WHERE false; -- test multiple distincts with all but one pinned: #7998 :PREFIX SELECT DISTINCT dev, dev FROM :TABLE ORDER BY 1; :PREFIX SELECT DISTINCT dev, time FROM :TABLE WHERE time = 100 ORDER BY 1; :PREFIX SELECT DISTINCT dev, time, val FROM :TABLE WHERE time = 100 and val = 100 ORDER BY 1; :PREFIX SELECT DISTINCT ON (dev, time) * FROM :TABLE WHERE time = 100 ORDER BY dev; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE dev = 1 AND time < 20 ORDER BY dev, time; -- CTE :PREFIX WITH devices AS ( SELECT DISTINCT ON (dev) dev FROM :TABLE ) SELECT * FROM devices; :PREFIX WITH devices AS ( SELECT DISTINCT dev FROM :TABLE ) SELECT * FROM devices ORDER BY dev; -- prepared statements PREPARE prep AS SELECT DISTINCT ON (dev_name) dev_name FROM :TABLE; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; :PREFIX EXECUTE prep; DEALLOCATE prep; -- ReScan tests :PREFIX SELECT time, dev, val, 'q7_1' FROM (SELECT DISTINCT ON (dev) * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT * FROM :TABLE WHERE time != a.v) b) a; :PREFIX SELECT time, dev, val, 'q7_2' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev != a.v) b) a; -- RuntimeKeys :PREFIX SELECT time, dev, val, 'q8_1' FROM (SELECT * FROM ( VALUES (1), (2)) a(v), LATERAL (SELECT DISTINCT ON (dev) * FROM :TABLE WHERE dev >= a.v) b) c; -- Emulate multi-column DISTINCT using multiple SkipSkans :PREFIX SELECT time, dev, val, 'q9_1' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) * FROM :TABLE WHERE dev = a.dev) b) c; :PREFIX SELECT time, dev, NULL, 'q9_2' FROM (SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b) c; -- Test that the multi-column DISTINCT emulation is equivalent to a real multi-column DISTINCT :PREFIX SELECT * FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0; :PREFIX SELECT DISTINCT ON (dev, time) dev, time FROM :TABLE WHERE coalesce(dev, -1) >= 0 UNION SELECT b.* FROM (SELECT DISTINCT ON (dev) dev FROM :TABLE) a, LATERAL (SELECT DISTINCT ON (time) dev, time FROM :TABLE WHERE dev = a.dev) b; -- SkipScan into INSERT :PREFIX INSERT INTO skip_scan_insert(time, dev, val, query) SELECT time, dev, val, 'q10_1' FROM (SELECT DISTINCT ON (dev) * FROM :TABLE) a; -- parallel query SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); :PREFIX SELECT DISTINCT dev FROM :TABLE ORDER BY dev; SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'off', false); TRUNCATE skip_scan_insert; -- table with only nulls :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls; -- no tuples in resultset :PREFIX SELECT DISTINCT ON (time) time FROM skip_scan_nulls WHERE time IS NOT NULL; -- Test for SDC issue #2976 -- We should use index "btree ("time", dev, dev_name)" where "dev_name" index key is #3 but we have 2 index quals including SkipScan qual -- We should not drop qual on "dev_name" CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev,dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; -- "dev_name" is not a key column: it's not in the index quals and should be a filter CREATE INDEX skip_scan_idx_time_dev_dname ON :TABLE(time,dev) INCLUDE(dev_name); :PREFIX SELECT DISTINCT time FROM :TABLE WHERE dev_name IS NULL ORDER BY 1; DROP INDEX skip_scan_idx_time_dev_dname; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/skip_scan_query_ht.sql��������������������������������������0000664�0000000�0000000�00000002373�15100345067�0024476�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE INDEX ON :TABLE(dev); CREATE INDEX ON :TABLE(time); -- To test scenarios with SkipScan/no SkipScan over a mix of uncompressed and compressed chunks SET timescaledb.enable_compressed_skipscan TO false; -- SkipScan with ordered append :PREFIX SELECT DISTINCT ON (time) time FROM :TABLE ORDER BY time; --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; -- compression doesnt prevent skipscan SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); --baseline query with skipscan :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; -- partial indexes don't prevent skipscan DROP INDEX _timescaledb_internal._hyper_1_1_chunk_skip_scan_ht_dev_idx; :PREFIX SELECT DISTINCT ON (dev) dev, dev_name FROM :TABLE; -- IndexPath without pathkeys doesnt use SkipScan EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT 1 FROM pg_rewrite; RESET timescaledb.enable_compressed_skipscan; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_constraintaware.sql���������������0000664�0000000�0000000�00000004574�15100345067�0031370�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --- TEST for constraint aware append ------------ --should select only newly added chunk -- SET timescaledb.enable_chunk_append TO FALSE; :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; -- DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 4 AND device_id_peer = 5 AND time > '2002-01-01' AND time < now() ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 5 AND m.time = d.time AND m.time > '2002-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz AND m.device_id_peer = d.device_id_peer GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --query with no results -- :PREFIX SELECT m.device_id, d.v0, count(*) FROM metrics_ordered_idx d, metrics_ordered_idx m WHERE m.time = d.time AND m.time > '2000-01-01 0:00:00+0'::text::timestamptz GROUP BY m.device_id, d.v0 ORDER BY 1, 2, 3; --query with all chunks but 1 excluded at plan time -- :PREFIX SELECT d.*, m.* FROM device_tbl d, metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz ORDER BY m.v0; -- no matches in metrics_ordered_idx but one row in device_tbl :PREFIX SELECT d.*, m.* FROM device_tbl d LEFT OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE d.device_id = 8 ORDER BY m.v0; -- no matches in device_tbl but 1 row in metrics_ordered_idx :PREFIX SELECT d.*, m.* FROM device_tbl d FULL OUTER JOIN metrics_ordered_idx m ON m.device_id = d.device_id AND m.time > '2019-01-01' AND m.time < '2000-01-01 0:00:00+0'::text::timestamptz WHERE m.device_id = 7 ORDER BY m.v0; SET timescaledb.enable_chunk_append TO TRUE; ������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_ordered.sql�����������������������0000664�0000000�0000000�00000003066�15100345067�0027603�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column CREATE TABLE metrics_ordered(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float); SELECT create_hypertable('metrics_ordered','time'); ALTER TABLE metrics_ordered SET (timescaledb.compress, timescaledb.compress_orderby='time DESC',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered SELECT * FROM metrics; CREATE INDEX ON metrics_ordered(device_id,device_id_peer,time); CREATE INDEX ON metrics_ordered(device_id,time); CREATE INDEX ON metrics_ordered(device_id_peer,time); -- compress all chunks SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered') ch; VACUUM ANALYZE metrics_ordered; -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM metrics_ordered ORDER BY time DESC LIMIT 10; -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered WHERE device_id = 1 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered d INNER JOIN LATERAL (SELECT * FROM metrics_ordered m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON true; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_ordered_index.sql�����������������0000664�0000000�0000000�00000012565�15100345067�0030776�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET work_mem TO '50MB'; ---Lets test for index backward scans instead of seq scans ------------ -- for ordered append tests on compressed chunks we need a hypertable with time as compress_orderby column -- should not have ordered DecompressChunk path because segmentby columns are not part of pathkeys :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM ( SELECT * FROM metrics_ordered_idx WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10) AS q ORDER BY 1, 2, 3, 4; :PREFIX SELECT DISTINCT ON (d.device_id) * FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx d INNER JOIN LATERAL ( SELECT * FROM metrics_ordered_idx m WHERE m.device_id = d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1) m ON m.device_id_peer = d.device_id_peer WHERE extract(minute FROM d.time) = 0; --github issue 1558 SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT device_id, count(*) FROM ( SELECT * FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time) AS subq GROUP BY device_id; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_mergejoin = TRUE; SET enable_hashjoin = FALSE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; SET enable_mergejoin = FALSE; SET enable_hashjoin = TRUE; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY time; --enable all joins after the tests SET enable_mergejoin = TRUE; SET enable_hashjoin = TRUE; --end github issue 1558 -- github issue 2673 -- nested loop join with parameterized path -- join condition has a segment by column and another column. SET enable_hashjoin = false; SET enable_mergejoin=false; SET enable_material = false; SET enable_seqscan = false; -- restrict so that we select only 1 chunk. :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.*, 'query no. 9' FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' ORDER BY v0; --add filter to segment by (device_id) and compressed attr column (v0) :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.v0 = 5; :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version WHERE met.time = '2000-01-19 19:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; -- lateral subquery :PREFIX WITH f1 as ( SELECT * from (values( 7, 5, 4) , (4, 5, 5) ) as lu( device_id, device_id_peer, v0) ) SELECT * FROM metrics_ordered_idx met JOIN LATERAL ( SELECT node, f1.* from nodetime , f1 WHERE node = f1.device_id) q ON met.device_id = q.node and met.device_id_peer = q.device_id_peer and met.v0 = q.v0 and met.v0 > 2 and time = '2018-01-19 20:00:00-05'; -- filter on compressed attr (v0) with seqscan enabled and indexscan -- disabled. filters on compressed attr should be above the seq scan. SET enable_seqscan = true; SET enable_indexscan = false; :PREFIX WITH lookup as ( SELECT * from (values( 3, 5) , (3, 4) ) as lu( did, version) ) SELECT met.*, lookup.* FROM metrics_ordered_idx met join lookup ON met.device_id = lookup.did and met.v0 = lookup.version and met.device_id = 3 WHERE met.time > '2000-01-19 19:00:00-05' and met.time < '2000-01-20 20:00:00-05' and met.device_id = 3 and met.device_id_peer = 3 and met.v0 = 5; RESET enable_hashjoin ; RESET enable_mergejoin; RESET enable_material ; RESET enable_indexscan ; --end github issue 2673 �������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_ordered_indexplan.sql�������������0000664�0000000�0000000�00000003377�15100345067�0031652�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- tests for explain plan only -- ---check index backward scans instead of seq scans ------------ CREATE TABLE metrics_ordered_idx2(time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int); SELECT create_hypertable('metrics_ordered_idx2','time', chunk_time_interval=>'2days'::interval); ALTER TABLE metrics_ordered_idx2 SET (timescaledb.compress, timescaledb.compress_orderby='time ASC, v0 desc',timescaledb.compress_segmentby='device_id,device_id_peer'); INSERT INTO metrics_ordered_idx2(time,device_id,device_id_peer,v0, v1) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz,'2000-01-20 11:55:00+0','10s') , 3, 3, generate_series(1,5,1) , generate_series(555,559,1); SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx2') ch; VACUUM ANALYZE metrics_ordered_idx2; --all queries have only prefix of compress_orderby in ORDER BY clause -- should have ordered DecompressChunk path because segmentby columns have equality constraints :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC LIMIT 10; :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 asc LIMIT 10; :PREFIX SELECT * FROM metrics_ordered_idx2 WHERE device_id = 3 AND device_id_peer = 3 ORDER BY time DESC , v0 desc LIMIT 10; :PREFIX SELECT d.device_id, m.time, m.time FROM metrics_ordered_idx2 d INNER JOIN LATERAL (SELECT * FROM metrics_ordered_idx2 m WHERE m.device_id=d.device_id AND m.device_id_peer = 3 ORDER BY time DESC LIMIT 1 ) m ON m.device_id_peer = d.device_id_peer; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_query.sql�������������������������0000664�0000000�0000000�00000035676�15100345067�0027340�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this should use DecompressChunk node :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5; -- test RECORD by itself :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time; -- test empty targetlist :PREFIX SELECT FROM :TEST_TABLE; -- test empty resultset :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < 0; -- test targetlist not referencing columns :PREFIX SELECT 1 FROM :TEST_TABLE; -- The following plans are flaky between MergeAppend or Sort + Append. SET enable_sort = off; -- test expressions :PREFIX SELECT time_bucket ('1d', time), v1 + v2 AS "sum", COALESCE(NULL, v1, v2) AS "coalesce", NULL AS "NULL", 'text' AS "text", :TEST_TABLE AS "RECORD" FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id ; -- test constraints not present in targetlist :PREFIX SELECT v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; -- test order not present in targetlist :PREFIX SELECT v2 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY v1; -- test column with all NULL :PREFIX SELECT v3 FROM :TEST_TABLE WHERE device_id = 1; -- -- test qual pushdown -- -- v3 is not segment by or order by column so should not be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE v3 > 10.0 ORDER BY time, device_id; -- device_id constraint should be pushed down :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time, device_id LIMIT 10; RESET enable_sort; -- test IS NULL / IS NOT NULL :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NOT NULL ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IS NULL ORDER BY time, device_id LIMIT 10; -- test IN (Const,Const) :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id IN (1, 2) ORDER BY time, device_id LIMIT 10; -- test cast pushdown :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = '1'::text::int ORDER BY time, device_id LIMIT 10; --test var op var with two segment by :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = device_id_peer ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id_peer < device_id ORDER BY time, device_id LIMIT 10; -- test expressions :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = 1 + 4 / 2 ORDER BY time, device_id LIMIT 10; -- test function calls :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id = length(substring(version(), 1, 3)) ORDER BY time, device_id LIMIT 10; -- -- test segment meta pushdown -- -- order by column and const :PREFIX SELECT * FROM :TEST_TABLE WHERE time = '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE time < '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE time <= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE time >= '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE '2000-01-01 1:00:00+0' < time ORDER BY time, device_id LIMIT 10; --pushdowns between order by and segment by columns :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < 1 ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 < device_id ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE device_id < v0 ORDER BY time, device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE WHERE v1 = device_id ORDER BY time, device_id LIMIT 10; --pushdown between two order by column (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE v0 = v1 ORDER BY time, device_id LIMIT 10; --pushdown of quals on order by and segment by cols anded together :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' AND device_id = 1 ORDER BY time, device_id LIMIT 10; --pushdown of quals on order by and segment by cols or together (not pushed down) :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-01 1:00:00+0' OR device_id = 1 ORDER BY time, device_id LIMIT 10; --functions are pushed down as well :PREFIX SELECT * FROM :TEST_TABLE WHERE time < now() ORDER BY time, device_id LIMIT 10; -- test sort optimization interaction :PREFIX SELECT time FROM :TEST_TABLE ORDER BY time DESC LIMIT 10; :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY time DESC, device_id LIMIT 10; :PREFIX SELECT time, device_id FROM :TEST_TABLE ORDER BY device_id, time DESC LIMIT 10; -- -- test ordered path -- -- should not produce ordered path -- This plan is flaky between MergeAppend over Sorts and Sort over Append SET enable_sort TO off; :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; RESET enable_sort; -- should produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time; -- test order by columns not in targetlist :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time LIMIT 100; -- test ordering only by segmentby columns -- should produce ordered path and not have sequence number in targetlist of compressed scan :PREFIX_VERBOSE SELECT device_id, device_id_peer FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer LIMIT 100; -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0; -- should produce ordered path -- only referencing PREFIX_VERBOSE should work :PREFIX_VERBOSE SELECT device_id, device_id_peer, v0, v1 FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; -- should not produce ordered path. :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id, device_id_peer, v0, v1 DESC, time, v3; -- should produce ordered path -- ASC/DESC for segmentby columns can be pushed down :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1 DESC, time; -- should not produce ordered path :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY device_id DESC, device_id_peer DESC, v0, v1, time; -- -- test constraint exclusion -- -- test plan time exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08' ORDER BY time, device_id; RESET enable_sort; -- test runtime exclusion -- first chunk should be excluded :PREFIX SELECT * FROM :TEST_TABLE WHERE time > '2000-01-08'::text::timestamptz ORDER BY time, device_id; -- test aggregate :PREFIX SELECT count(*) FROM :TEST_TABLE; -- test aggregate with GROUP BY -- Disable hash aggregation to get a deterministic test output SET enable_hashagg = OFF; :PREFIX SELECT count(*) FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; -- test window functions with GROUP BY :PREFIX SELECT sum(count(*)) OVER () FROM :TEST_TABLE GROUP BY device_id ORDER BY device_id; SET enable_hashagg = ON; -- test CTE :PREFIX WITH q AS ( SELECT v1 FROM :TEST_TABLE ORDER BY time ) SELECT * FROM q ORDER BY v1; -- test CTE join :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time ) SELECT * FROM q1 INNER JOIN q2 ON q1.time = q2.time ORDER BY q1.time; :PREFIX WITH q1 AS ( SELECT time, v1 FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 5 ), q2 AS ( SELECT time, v2 FROM :TEST_TABLE WHERE device_id = 2 ORDER BY time LIMIT 5 ) SELECT * FROM q1, q2; -- test prepared statement PREPARE prep AS SELECT count(time) FROM :TEST_TABLE WHERE device_id = 1; :PREFIX EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; EXECUTE prep; DEALLOCATE prep; -- -- test indexes -- SET enable_seqscan TO FALSE; -- IndexScans should work :PREFIX_VERBOSE SELECT time, device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; -- globs should not plan IndexOnlyScans :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id, time; -- whole row reference should work :PREFIX_VERBOSE SELECT test_table FROM :TEST_TABLE AS test_table WHERE device_id = 1 ORDER BY device_id, time; -- even when we select only a segmentby column, we still need count :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE WHERE device_id = 1 ORDER BY device_id; :PREFIX_VERBOSE SELECT count(*) FROM :TEST_TABLE WHERE device_id = 1; -- should be able to order using an index CREATE INDEX tmp_idx ON :TEST_TABLE (device_id); :PREFIX_VERBOSE SELECT device_id FROM :TEST_TABLE ORDER BY device_id; DROP INDEX tmp_idx CASCADE; -- These plans are flaky between MergeAppend and Sort over Append. SET enable_sort TO OFF; --use the peer index :PREFIX_VERBOSE SELECT * FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer, time; RESET enable_sort; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer = 1 ORDER BY device_id_peer; --ensure that we can get a nested loop SET enable_seqscan TO TRUE; SET enable_hashjoin TO FALSE; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1)); --with multiple values can get a nested loop. :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id_peer IN ( VALUES (1), (2)); RESET enable_hashjoin; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); --with multiple values can get a semi-join or nested loop depending on seq_page_cost. SET enable_hashjoin TO OFF; SET enable_mergejoin TO OFF; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); RESET enable_hashjoin; RESET enable_mergejoin; SET seq_page_cost = 100; -- loop/row counts of this query is different on windows so we run it without analyze :PREFIX_NO_ANALYZE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); RESET seq_page_cost; :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1)); :PREFIX_VERBOSE SELECT device_id_peer FROM :TEST_TABLE WHERE device_id IN ( VALUES (1), (2)); -- test view CREATE OR REPLACE VIEW compressed_view AS SELECT time, device_id, v1, v2 FROM :TEST_TABLE; :PREFIX SELECT * FROM compressed_view WHERE device_id = 1 ORDER BY time DESC LIMIT 10; DROP VIEW compressed_view; -- test INNER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time INNER JOIN :TEST_TABLE m3 ON m2.time = m3.time AND m1.device_id = m2.device_id AND m3.device_id = 3 ORDER BY m1.time, m1.device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE m1 INNER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; :PREFIX SELECT * FROM metrics m1 INNER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; -- test OUTER JOIN :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = m2.device_id ORDER BY m1.time, m1.device_id LIMIT 10; :PREFIX SELECT * FROM :TEST_TABLE m1 LEFT OUTER JOIN :TEST_TABLE m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; :PREFIX SELECT * FROM metrics m1 LEFT OUTER JOIN metrics_space m2 ON m1.time = m2.time AND m1.device_id = 1 AND m2.device_id = 2 ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 100; -- test implicit self-join :PREFIX SELECT * FROM :TEST_TABLE m1, :TEST_TABLE m2 WHERE m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.time, m2.device_id LIMIT 20; -- test self-join with sub-query :PREFIX SELECT * FROM ( SELECT * FROM :TEST_TABLE m1) m1 INNER JOIN ( SELECT * FROM :TEST_TABLE m2) m2 ON m1.time = m2.time ORDER BY m1.time, m1.device_id, m2.device_id LIMIT 10; :PREFIX SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time LIMIT 1) m1 ON TRUE; -- test prepared statement with params pushdown PREPARE param_prep (int) AS SELECT * FROM generate_series('2000-01-01'::timestamptz, '2000-02-01'::timestamptz, '1d'::interval) g (time) INNER JOIN LATERAL ( SELECT time FROM :TEST_TABLE m1 WHERE m1.time = g.time AND device_id = $1 LIMIT 1) m1 ON TRUE; :PREFIX EXECUTE param_prep (1); :PREFIX EXECUTE param_prep (2); EXECUTE param_prep (1); EXECUTE param_prep (2); EXECUTE param_prep (1); EXECUTE param_prep (2); EXECUTE param_prep (1); DEALLOCATE param_prep; -- test continuous aggs SET client_min_messages TO error; CREATE MATERIALIZED VIEW cagg_test WITH (timescaledb.continuous, timescaledb.materialized_only = TRUE) AS SELECT time_bucket ('1d', time) AS time, device_id, avg(v1) FROM :TEST_TABLE WHERE device_id = 1 GROUP BY 1, 2 WITH DATA; SELECT time FROM cagg_test ORDER BY time LIMIT 1; DROP MATERIALIZED VIEW cagg_test; RESET client_min_messages; --github issue 1558. nested loop with index scan needed --disables parallel scan SET enable_seqscan = FALSE; SET enable_bitmapscan = FALSE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = FALSE; SET enable_mergejoin = FALSE; :PREFIX SELECT * FROM metrics, metrics_space WHERE metrics.time > metrics_space.time AND metrics.device_id = metrics_space.device_id AND metrics.time < metrics_space.time; SET enable_seqscan = TRUE; SET enable_bitmapscan = TRUE; SET max_parallel_workers_per_gather = 0; SET enable_hashjoin = TRUE; SET enable_mergejoin = TRUE; ---end github issue 1558 ������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_systemcolumns.sql�����������������0000664�0000000�0000000�00000002643�15100345067�0031104�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_TABLE 'metrics' -- test system columns -- all system columns except for tableoid should error \set ON_ERROR_STOP 0 SELECT xmin FROM :TEST_TABLE ORDER BY time; SELECT cmin FROM :TEST_TABLE ORDER BY time; SELECT xmax FROM :TEST_TABLE ORDER BY time; SELECT cmax FROM :TEST_TABLE ORDER BY time; SELECT ctid FROM :TEST_TABLE ORDER BY time; -- test system columns in WHERE and ORDER BY clause SELECT tableoid, xmin FROM :TEST_TABLE ORDER BY time; SELECT FROM :TEST_TABLE ORDER BY cmin::text; SELECT FROM :TEST_TABLE WHERE cmin IS NOT NULL; \set ON_ERROR_STOP 1 -- test tableoid in different parts of query SELECT pg_typeof(tableoid) FROM :TEST_TABLE ORDER BY time LIMIT 1; SELECT FROM :TEST_TABLE ORDER BY tableoid LIMIT 1; SELECT FROM :TEST_TABLE WHERE tableoid::int > 0 LIMIT 1; SELECT tableoid::regclass FROM :TEST_TABLE GROUP BY tableoid ORDER BY 1; SELECT count(distinct tableoid) FROM :TEST_TABLE WHERE device_id=1 AND time < now(); -- test prepared statement PREPARE tableoid_prep AS SELECT tableoid::regclass FROM :TEST_TABLE WHERE device_id = 1 ORDER BY time LIMIT 1; :PREFIX EXECUTE tableoid_prep; EXECUTE tableoid_prep; EXECUTE tableoid_prep; EXECUTE tableoid_prep; EXECUTE tableoid_prep; EXECUTE tableoid_prep; DEALLOCATE tableoid_prep; ���������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/include/transparent_decompression_undiffed.sql����������������������0000664�0000000�0000000�00000004510�15100345067�0027736�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- test planning regression with many chunks CREATE TABLE tags(id SERIAL PRIMARY KEY, name TEXT, fleet TEXT); INSERT INTO tags (name, fleet) VALUES('n1', 'f1'); CREATE TABLE readings (time timestamptz, tags_id integer, fuel_consumption DOUBLE PRECISION); CREATE INDEX ON readings(tags_id, "time" DESC); CREATE INDEX ON readings("time" DESC); SELECT create_hypertable('readings', 'time', partitioning_column => 'tags_id', number_partitions => 1, chunk_time_interval => 43200000000, create_default_indexes=>false); ALTER TABLE readings SET (timescaledb.compress, timescaledb.compress_segmentby = 'tags_id', timescaledb.compress_orderby = 'time desc'); INSERT into readings select g, 1, 1.3 from generate_series('2001-03-01 01:01:01', '2003-02-01 01:01:01', '1 day'::interval) g; SELECT count(compress_chunk(ch)) FROM show_chunks('readings') ch; VACUUM ANALYZE readings; EXPLAIN (buffers off, costs off) SELECT t.fleet as fleet, min(r.fuel_consumption) AS avg_fuel_consumption FROM tags t INNER JOIN LATERAL(SELECT tags_id, fuel_consumption FROM readings r WHERE r.tags_id = t.id ) r ON true GROUP BY fleet; -- run query with parallel enabled to ensure nothing is preventing parallel execution -- this is just a sanity check, the result queries dont run with parallel disabled SET max_parallel_workers_per_gather TO 4; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SET min_parallel_table_scan_size TO '0'; EXPLAIN (buffers off, costs off) SELECT * FROM metrics ORDER BY time, device_id; EXPLAIN (buffers off, costs off) SELECT time_bucket('10 minutes', time) bucket, avg(v0) avg_v0 FROM metrics GROUP BY bucket; EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space ORDER BY time, device_id; RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; SET enable_seqscan TO false; -- should order compressed chunks using index -- (we only EXPLAIN here b/c the resulting order is too inconsistent) EXPLAIN (buffers off, costs off) SELECT * FROM metrics WHERE time > '2000-01-08' ORDER BY device_id; EXPLAIN (buffers off, costs off) SELECT * FROM metrics_space WHERE time > '2000-01-08' ORDER BY device_id; SET enable_seqscan TO true; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/information_view_chunk_count.sql������������������������������������0000664�0000000�0000000�00000003300�15100345067�0025127�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; CREATE TABLE sensor_data( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); SELECT from create_hypertable('sensor_data','time'); INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random() * 100 AS temperature FROM generate_series('2018-03-02 1:00'::TIMESTAMPTZ, '2018-03-28 1:00', '1 hour') AS g1(time), generate_series(1, 100, 1 ) AS g2(sensor_id) ORDER BY time; CREATE materialized VIEW sensor_data_v WITH(timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT sensor_id, time_bucket(INTERVAL '1 day', time) AS bucket, AVG(temperature) FROM sensor_data GROUP BY sensor_id, bucket; INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2018-03-03 1:00'::TIMESTAMPTZ, '2018-03-31 1:00', '1 hour') AS g1(time), generate_series(1, 100, 1 ) AS g2(sensor_id) ORDER BY time; SELECT count(*) AS num_chunks FROM show_chunks('sensor_data'); SELECT drop_chunks('sensor_data','2018-03-28'::timestamp); SELECT count(*) AS num_chunks from timescaledb_information.chunks where hypertable_name = 'sensor_data'; SELECT num_chunks from timescaledb_information.hypertables where hypertable_name = 'sensor_data'; SELECT count(*) AS num_chunks FROM show_chunks('sensor_data'); DROP TABLE sensor_data CASCADE; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/insert_memory_usage.sql���������������������������������������������0000664�0000000�0000000�00000012317�15100345067�0023240�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test that transaction memory usage with COPY doesn't grow. -- We need memory usage in PortalContext after the completion of the query, so -- we'll have to log it from a trigger that runs after the query is completed. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; create table uk_price_paid(price integer, "date" date, postcode1 text, postcode2 text, type smallint, is_new bool, duration smallint, addr1 text, addr2 text, street text, locality text, town text, district text, country text, category smallint); alter table uk_price_paid set unlogged; -- Aim to about 100 partitions, the data is from 1995 to 2022. select create_hypertable('uk_price_paid', 'date', chunk_time_interval => interval '90 day'); -- This is where we log the memory usage. create table portal_memory_log(id serial, bytes bigint); -- Returns the amount of memory currently allocated in a given -- memory context. Only works for PortalContext, and doesn't work for PG 12. create or replace function ts_debug_allocated_bytes(text) returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; -- Log current memory usage into the log table. create function log_memory() returns trigger as $$ begin insert into portal_memory_log values (default, ts_debug_allocated_bytes('PortalContext')); return new; end; $$ language plpgsql; -- Add a trigger that runs after completion of each INSERT/COPY and logs the -- current memory usage. create trigger check_update after insert on uk_price_paid for each statement execute function log_memory(); -- Memory leaks often happen on cache invalidation, so make sure they are -- invalidated often and independently (at co-prime periods). set timescaledb.max_open_chunks_per_insert = 2; set timescaledb.max_cached_chunks_per_hypertable = 3; -- Try increasingly larger data sets by concatenating the same file multiple -- times. First, INSERT into an uncompressed table. create table uk_price_paid_one(like uk_price_paid); \copy uk_price_paid_one from program 'bash -c "cat <(zcat < data/prices-10k-random-1.tsv.gz)"'; truncate uk_price_paid; insert into uk_price_paid select * from uk_price_paid_one; truncate portal_memory_log; alter sequence portal_memory_log_id_seq restart with 1; -- Don't use joins here because they might materialize a subquery which will -- lead to weird memory usage changes. insert into uk_price_paid select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; -- Use linear regression to check that the memory usage doesn't significanlty -- increase with increasing the insert size. -- Note that there's going to be some linear planning and parsing overhead for -- bigger queries, unlike the COPY. It can constitute a sizable percentage of -- the total memory usage, so we'll check the absolute value as well. \set parsing_overhead_bytes 50000 select * from portal_memory_log where ( select regr_slope(bytes, id - 1) / regr_intercept(bytes, id - 1)::float > 0.05 and regr_slope(bytes, id - 1) > :parsing_overhead_bytes from portal_memory_log ); -- INSERT into a compressed table. truncate uk_price_paid; insert into uk_price_paid select * from uk_price_paid_one; alter table uk_price_paid set (timescaledb.compress, timescaledb.compress_orderby = 'date'); select count(compress_chunk(chunk)) from show_chunks('uk_price_paid') chunk; truncate portal_memory_log; alter sequence portal_memory_log_id_seq restart with 1; -- Don't use joins here because they might materialize a subquery which will -- lead to weird memory usage changes. insert into uk_price_paid select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; insert into uk_price_paid select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one union all select * from uk_price_paid_one; select * from portal_memory_log where ( select regr_slope(bytes, id - 1) / regr_intercept(bytes, id - 1)::float > 0.05 and regr_slope(bytes, id - 1) > :parsing_overhead_bytes from portal_memory_log ); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/jit.sql�������������������������������������������������������������0000664�0000000�0000000�00000003200�15100345067�0017735�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; \set TEST_BASE_NAME jit SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') as "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('include/%s_cleanup.sql', :'TEST_BASE_NAME') as "TEST_CLEANUP_NAME", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_OPTIMIZED", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNOPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') as "DIFF_CMD" \gset -- enable all jit optimizations SET jit=on; SET jit_above_cost=0; SET jit_inline_above_cost=0; SET jit_optimize_above_cost=0; SET jit_tuple_deforming=on; SET enable_hashagg=off; \ir :TEST_LOAD_NAME \set PREFIX 'EXPLAIN (VERBOSE, TIMING OFF, BUFFERS OFF, COSTS OFF, SUMMARY OFF)' \ir :TEST_QUERY_NAME -- generate the results into two different files \set ECHO errors SET client_min_messages TO error; \set PREFIX '' -- get query results with jit enabled \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o -- disable jit optimizations and repeat SET jit=off; \o /dev/null \ir :TEST_CLEANUP_NAME \ir :TEST_LOAD_NAME \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o -- compare jit vs non-jit output :DIFF_CMD \set ECHO queries \qecho '--TEST END--' ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/license_tsl.sql�����������������������������������������������������0000664�0000000�0000000�00000000451�15100345067�0021460�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; SHOW timescaledb.license; SELECT _timescaledb_functions.tsl_loaded(); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/merge_append_partially_compressed.sql�������������������������������0000664�0000000�0000000�00000034753�15100345067�0026123�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- this test checks the validity of the produced plans for partially compressed chunks -- when injecting query_pathkeys on top of the append -- path that combines the uncompressed and compressed parts of a chunk. -- We're testing the MergeAppend here which is not compatible with parallel plans. set max_parallel_workers_per_gather = 0; set timescaledb.enable_decompression_sorted_merge = off; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' CREATE TABLE ht_metrics_compressed(time timestamptz, device int, value float); SELECT create_hypertable('ht_metrics_compressed','time'); ALTER TABLE ht_metrics_compressed SET (timescaledb.compress, timescaledb.compress_segmentby='device', timescaledb.compress_orderby='time'); INSERT INTO ht_metrics_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02 00:00:00+00'::timestamptz,'2020-01-18 00:00:00+00'::timestamptz,'6 hour') time, generate_series(1,3) device; SELECT compress_chunk(c) FROM show_chunks('ht_metrics_compressed') c; -- make them partially compressed INSERT INTO ht_metrics_compressed SELECT time, device, device * 0.1 FROM generate_series('2020-01-02 00:00:00+00'::timestamptz,'2020-01-18 00:00:00+00'::timestamptz,'9 hour') time, generate_series(1,3) device; VACUUM ANALYZE ht_metrics_compressed; SELECT tableoid::regclass, min(time), max(time) from ht_metrics_compressed group by 1 order by 2; SELECT show_chunks('ht_metrics_compressed') AS "CHUNK" LIMIT 1 \gset -- test UNION with partially compressed chunks :PREFIX SELECT * FROM :CHUNK UNION ALL SELECT * FROM :CHUNK; :PREFIX SELECT * FROM :CHUNK UNION ALL SELECT * FROM :CHUNK ORDER BY time DESC; :PREFIX SELECT device FROM :CHUNK UNION ALL SELECT device FROM :CHUNK ORDER BY device DESC; :PREFIX SELECT value FROM :CHUNK UNION ALL SELECT value FROM :CHUNK ORDER BY value DESC; -- chunkAppend eligible queries (from tsbench) -- sort is not pushed down :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time DESC, device LIMIT 1; :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time_bucket('1d', time) DESC, device LIMIT 1; :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time desc limit 10; :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY time_bucket('2d',time) DESC LIMIT 1; :PREFIX SELECT * FROM ht_metrics_compressed WHERE device IN (1,2,3) ORDER BY time DESC LIMIT 1; :PREFIX SELECT * FROM ht_metrics_compressed WHERE device IN (1,2,3) ORDER BY time, device DESC LIMIT 1; -- index scan, no sort on top :PREFIX SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time DESC LIMIT 1; -- index scan, no resorting required SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time DESC LIMIT 1; :PREFIX SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY device, time DESC LIMIT 1; -- this uses the index and does not do sort on top SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY device, time DESC LIMIT 1; :PREFIX SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time, device DESC LIMIT 1; -- this also uses the index and does not do sort on top SELECT * FROM ht_metrics_compressed WHERE device = 3 ORDER BY time, device DESC LIMIT 1; -- not eligible for chunkAppend, but eligible for sort pushdown :PREFIX SELECT * FROM ht_metrics_compressed ORDER BY device, time DESC LIMIT 1; -- with pushdown :PREFIX SELECT * FROM ht_metrics_compressed WHERE device IN (1,2,3) ORDER BY device, time DESC LIMIT 1; -- with pushdown -- Test direct ordered select from a single partially compressed chunk select * from show_chunks('ht_metrics_compressed') chunk order by chunk limit 1 \gset :PREFIX SELECT * FROM :chunk ORDER BY device, time LIMIT 5; SELECT * FROM :chunk ORDER BY device, time LIMIT 5; :PREFIX SELECT * FROM :chunk ORDER BY device DESC, time DESC LIMIT 5; SELECT * FROM :chunk ORDER BY device DESC, time DESC LIMIT 5; CREATE TABLE test1 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test1', 'time'); ALTER TABLE test1 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'time DESC, x3 ASC, x4 ASC'); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); -- Insert some dummy rows to inflate the cost estimates to get it to actually -- use the MergeAppend. We will filter them out using the "x4 % 11 != 0" which -- thwarts the normal selectivity estimation. INSERT INTO test1 select '2000-01-01 04:00:00-00', /* x1 = */ 0, /* x2 = */ 0, /* x3 = */ 0, /* x4 = */ 11 * (11 + x), 0 from generate_series(1, 10000) x; SELECT compress_chunk(i) FROM show_chunks('test1') i; -- make all the chunks partially compressed INSERT INTO test1 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:01:00-00', 10, 20, 30, 40 ,50); ANALYZE test1; -- tests that require resorting (pushdown below decompressChunk node cannot happen) -- requires resorting, no pushdown can happen :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC LIMIT 10; -- requires resorting :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST LIMIT 10; -- all these require resorting, no pushdown can happen :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 ASC NULLS LAST LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time DESC NULLS FIRST, x3 ASC NULLS LAST, x4 DESC NULLS FIRST LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS LAST LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS LAST, x3 DESC NULLS FIRST, x4 DESC NULLS FIRST LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time ASC NULLS FIRST, x3 DESC NULLS LAST, x4 ASC LIMIT 10; set enable_hashagg to off; -- different on PG13 :PREFIX SELECT x1, x2, max(time) FROM (SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY time, x1, x2 LIMIT 10) t GROUP BY x1, x2, time ORDER BY time limit 10; reset enable_hashagg; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4, time LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x4 LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x3 LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x3, x4 LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x4 DESC LIMIT 10; -- no pushdown because orderby does not match -- queries with pushdown :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time DESC, x3 ASC, x4 ASC LIMIT 10; -- pushdown :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time ASC, x3 DESC, x4 DESC LIMIT 10; -- pushdown :PREFIX SELECT * FROM test1 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time, x3 DESC LIMIT 10; -- test append with join column in orderby -- #6975 CREATE TABLE join_table ( x1 integer, y1 float); INSERT INTO join_table VALUES (1, 1.0), (2,2.0); :PREFIX SELECT * FROM test1 t1 JOIN join_table jt ON t1.x1 = jt.x1 ORDER BY t1.x1, jt.y1; --------------------------------------------------------------------------- -- test queries without ordered append, but still eligible for sort pushdown --------------------------------------------------------------------------- CREATE TABLE test2 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test2', 'time'); ALTER TABLE test2 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'x3 ASC, x4 ASC'); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); -- chunk 2 INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:00:00-00', 1, 2, 5, 5, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 01:00:00-00', 1, 3, 6, 6, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 02:00:00-00', 2, 1, 7, 7, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 03:00:00-00', 1, 2, 8, 8, 0); -- Insert some dummy rows to inflate the cost estimates to get it to actually -- use the MergeAppend. We will filter them out using the "x4 % 11 != 0" which -- thwarts the normal selectivity estimation. INSERT INTO test2 select unnest(array['2000-01-01 04:00:00-00', '2000-01-10 04:00:00-00']::timestamptz[]), /* x1 = */ 0, /* x2 = */ 0, /* x3 = */ 0, /* x4 = */ 11 * (11 + x), 0 from generate_series(1, 10000) x; SELECT compress_chunk(i) FROM show_chunks('test2') i; -- make them partially compressed INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:02:01-00', 1, 2, 9, 9, 0); INSERT INTO test2 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:02:01-00', 1, 2, 10, 10, 0); ANALYZE test2; set enable_indexscan = off; -- queries where sort is pushed down :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; -- queries where sort is not pushed down :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; :PREFIX SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; SELECT * FROM test2 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; ----------------------------- -- tests with space partitioning ----------------------------- CREATE TABLE test3 ( time timestamptz NOT NULL, x1 integer, x2 integer, x3 integer, x4 integer, x5 integer); SELECT FROM create_hypertable('test3', 'time'); SELECT add_dimension('test3', 'x1', number_partitions => 2); ALTER TABLE test3 SET (timescaledb.compress, timescaledb.compress_segmentby='x1, x2, x5', timescaledb.compress_orderby = 'x3 ASC, x4 ASC'); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:00:00-00', 1, 2, 1, 1, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 01:00:00-00', 1, 3, 2, 2, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 02:00:00-00', 2, 1, 3, 3, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 03:00:00-00', 1, 2, 4, 4, 0); -- chunk 2 INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:00:00-00', 1, 2, 5, 5, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 01:00:00-00', 1, 3, 6, 6, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 02:00:00-00', 2, 1, 7, 7, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 03:00:00-00', 1, 2, 8, 8, 0); -- Insert some dummy rows to inflate the cost estimates to get it to actually -- use the MergeAppend. We will filter them out using the "x4 % 11 != 0" which -- thwarts the normal selectivity estimation. INSERT INTO test3 select time, x1, /* x2 = */ 0, /* x3 = */ 0, /* x4 = */ 11 * (11 + x), 0 from generate_series(1, 10000) x, unnest(array['2000-01-01 04:00:00-00', '2000-01-10 04:00:00-00']::timestamptz[]) time, unnest(array[1, 2]::int[]) x1 ; SELECT compress_chunk(i) FROM show_chunks('test3') i; -- make them partially compressed INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:02:01-00', 1, 2, 9, 9, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:02:01-00', 1, 2, 10, 10, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-01 00:02:01-00', 2, 2, 9, 9, 0); INSERT INTO test3 (time, x1, x2, x3, x4, x5) values('2000-01-10 00:02:01-00', 2, 2, 10, 10, 0); ANALYZE test3; set enable_indexscan = off; -- queries where sort is pushed down :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3 LIMIT 10; :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x3, x4 LIMIT 10; -- queries where sort is not pushed down :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x3 LIMIT 10; :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, x4 LIMIT 10; :PREFIX SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; SELECT * FROM test3 WHERE x4 % 11 != 0 ORDER BY x1, x2, x5, time LIMIT 10; reset enable_indexscan; -- test ordering on single chunk queries CREATE TABLE test4(time timestamptz not null, device text, value float); SELECT table_name FROM create_hypertable('test4','time',chunk_time_interval:='1 year'::interval); ALTER TABLE test4 SET (tsdb.compress, tsdb.compress_segmentby='device', tsdb.compress_orderby='time'); INSERT INTO test4 SELECT '2025-01-01', NULL, 0.1; INSERT INTO test4 SELECT '2025-01-02', NULL, 0.1; INSERT INTO test4 SELECT '2025-01-02', 'd', 0.1; SELECT count(compress_chunk(ch)) FROM show_chunks('test4') ch; INSERT INTO test4 SELECT '2025-01-02', 'd', 0.1; VACUUM ANALYZE test4; set enable_hashagg TO false; SELECT time, device FROM _timescaledb_internal._hyper_9_21_chunk GROUP BY time, device; EXPLAIN (buffers off, costs off, analyze, timing off, summary off) SELECT time, device FROM _timescaledb_internal._hyper_9_21_chunk GROUP BY time, device; reset timescaledb.enable_decompression_sorted_merge; reset max_parallel_workers_per_gather; ���������������������timescaledb-2.23.0/tsl/test/sql/merge_chunks.sql����������������������������������������������������0000664�0000000�0000000�00000036357�15100345067�0021644�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; set role :ROLE_DEFAULT_PERM_USER; -- A limitation in the tuple routing cache can lead to routing errors -- when multi-dimensional time partitions are not aligned. Therefore, -- multi-dimensional merges are disabled by default until the routing -- is fixed. However, allow it in this test. set timescaledb.enable_merge_multidim_chunks = true; ------------------ -- Helper views -- ------------------- create view partitions as select c.table_name, d.column_name, ds.range_start, ds.range_end from _timescaledb_catalog.hypertable h join _timescaledb_catalog.chunk c on (c.hypertable_id = h.id) join _timescaledb_catalog.dimension d on (d.hypertable_id = h.id) join _timescaledb_catalog.dimension_slice ds on (d.id = ds.dimension_id) join _timescaledb_catalog.chunk_constraint cc on (cc.chunk_id = c.id and cc.dimension_slice_id = ds.id) where h.table_name = 'mergeme' order by d.id, ds.range_start, ds.range_end; create view orphaned_slices as select ds.id, cc.constraint_name from _timescaledb_catalog.dimension_slice ds left join _timescaledb_catalog.chunk_constraint cc on (ds.id = cc.dimension_slice_id) where cc.constraint_name is null; ----------------- -- Setup table -- ----------------- create table mergeme (time timestamptz not null, device int, temp float); select create_hypertable('mergeme', 'time', 'device', 3, chunk_time_interval => interval '1 day'); -- Create helper view for chunk information create view chunk_info as select relname as chunk, amname as tam, pg_get_expr(conbin, ch) checkconstraint from pg_class cl join pg_am am on (cl.relam = am.oid) join show_chunks('mergeme') ch on (cl.oid = ch) join pg_constraint con on (con.conrelid = ch) where con.contype = 'c' order by 1,2,3 desc; -- -- Insert data to create two chunks with same time ranges like this: -- _______ -- | | -- | 1 | -- |_____| -- | | -- | 2 | -- |_____| --- insert into mergeme values ('2024-01-01', 1, 1.0), ('2024-01-01', 2, 2.0); -- Show chunks and check constraints select * from chunk_info; -- Show partition layout select * from partitions; -- Now merge chunk 1 and 2: begin; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); select * from _timescaledb_internal._hyper_1_1_chunk; select reltuples from pg_class where oid='_timescaledb_internal._hyper_1_1_chunk'::regclass; select * from partitions; select count(*) as num_orphaned_slices from orphaned_slices; select * from chunk_info; select * from mergeme; rollback; -- create a new chunk as a third space partition -- _______ -- | | -- | 1 | -- |_____| -- | | -- | 2 | -- |_____| -- | | -- | 3 | -- |_____| --- insert into mergeme values ('2024-01-01', 3, 3.0); -- Test some basic error cases \set ON_ERROR_STOP 0 -- Can't merge chunk 1 and 3 call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_3_chunk'); call merge_chunks(NULL); call merge_chunks(NULL, NULL); call merge_chunks(999999,999991); call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk']); call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', NULL); call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', NULL]); call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_1_chunk'); -- Check permissions reset role; set role :ROLE_1; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); reset role; set role :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 -- Show new partition select * from partitions; begin; -- Should be able to merge all three chunks call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk']); select * from partitions; -- Note that no space partition CHECK constraint is added because it -- now covers the entire range from -inf to +inf. select count(*) as num_orphaned_slices from orphaned_slices; select * from chunk_info; select * from mergeme; rollback; -- create two new chunks, 4 and 5, as follows: -- _____________ _______ -- | | | | | -- | 1 | 4 | | 5 | -- |_____|_____| |_____| -- | | -- | 2 | -- |_____| -- | | -- | 3 | -- |_____| --- insert into mergeme values ('2024-01-02', 1, 4.0), ('2024-01-04', 1, 5.0); -- Show new partitions select * from partitions; \set ON_ERROR_STOP 0 -- can't merge 3 and 4 call merge_chunks('_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_4_chunk'); -- can't merge 1 and 5 call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_5_chunk'); -- can't merge 2 and 4 call merge_chunks('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_4_chunk'); -- can't merge 4 and 5 call merge_chunks('_timescaledb_internal._hyper_1_5_chunk', '_timescaledb_internal._hyper_1_4_chunk'); -- currently can't merge 1,2,3,4 due to limitation in how we validate the merge call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_4_chunk', '_timescaledb_internal._hyper_1_1_chunk']); begin; -- Should be able to merge all three chunks 1,2,3 call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_3_chunk']); -- But merging the merged 1,2,3 chunk with 4 is currently not -- possible, although we chould do it in theory call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_4_chunk'); rollback; \set ON_ERROR_STOP 1 alter table mergeme set (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='device'); select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); select compress_chunk('_timescaledb_internal._hyper_1_3_chunk'); -- Test merging compressed chunks begin; select * from chunk_info; select * from _timescaledb_catalog.compression_chunk_size order by chunk_id; call merge_chunks('{_timescaledb_internal._hyper_1_1_chunk, _timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from _timescaledb_catalog.compression_chunk_size order by chunk_id; select * from chunk_info; select count(*) as num_orphaned_slices from orphaned_slices; select * from mergeme; rollback; -- Test mixing hypercore TAM with compression without TAM select * from chunk_info; begin; select sum(temp) from mergeme; call merge_chunks('{_timescaledb_internal._hyper_1_1_chunk, _timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from chunk_info; select count(*) as num_orphaned_slices from orphaned_slices; select sum(temp) from mergeme; rollback; select * from chunk_info; -- Only Hypercore TAM and non-compressed chunks begin; select sum(temp) from mergeme; call merge_chunks('{_timescaledb_internal._hyper_1_1_chunk, _timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from chunk_info; select count(*) as num_orphaned_slices from orphaned_slices; select sum(temp) from mergeme; -- Test that indexes work after merge set timescaledb.enable_columnarscan = false; set enable_seqscan = false; analyze mergeme; explain (buffers off, costs off) select * from mergeme where device = 1; select * from mergeme where device = 1; select * from _timescaledb_internal._hyper_1_1_chunk where device = 1; reset timescaledb.enable_columnarscan; reset enable_seqscan; rollback; --- --- Merge hypercore TAM into compressed chunk without TAM --- begin; select * from chunk_info; select compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); select sum(temp) from mergeme; call merge_chunks('{_timescaledb_internal._hyper_1_2_chunk, _timescaledb_internal._hyper_1_3_chunk}'); select * from chunk_info; select count(*) as num_orphaned_slices from orphaned_slices; select sum(temp) from mergeme; rollback; --- -- Test some error cases when merging chunks with non-chunks or chunks -- from other hypertables --- -- Decompress all chunks to ensure we only have non-compressed chunks select decompress_chunk(ch) from show_chunks('mergeme') ch; -- Create a non-chunk table create table mergeme_too(time timestamptz not null, device int, temp float); select create_hypertable('mergeme_too', 'time', 'device', 3, chunk_time_interval => interval '1 day'); create table mergeme_regular(time timestamptz not null, device int, temp float); insert into mergeme_too values ('2024-01-01', 1, 1.0); insert into mergeme_regular select * from mergeme_too; create materialized view mergeme_mat as select * from mergeme_too where device=1; select * from show_chunks('mergeme_too'); \set ON_ERROR_STOP 0 -- Merge chunk and regular table call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', 'mergeme_regular'); call merge_chunks('mergeme_regular', '_timescaledb_internal._hyper_1_1_chunk'); call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', 'mergeme_mat'); -- Merge chunks from different hypertables call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_3_9_chunk'); -- Merge with unsupported access method alter table _timescaledb_internal._hyper_1_1_chunk set access method testam; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); alter table _timescaledb_internal._hyper_1_1_chunk set access method heap; -- Merge OSM chunks reset role; update _timescaledb_catalog.chunk ch set osm_chunk = true where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); reset role; update _timescaledb_catalog.chunk ch set osm_chunk = false where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; -- Merge frozen chunks select _timescaledb_functions.freeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); call merge_chunks('_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_2_chunk'); call merge_chunks('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_1_chunk'); select _timescaledb_functions.unfreeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); \set ON_ERROR_STOP 1 -- Set seed to consistently generate same data and same set of chunks select setseed(0.2); -- Test merge with bigger data set and chunks with more blocks insert into mergeme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-01'::timestamptz, '2024-01-04', '0.5s') t; -- Compress two chunks, one using access method select compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); -- Show partitions before merge select * from partitions; -- Show which chunks are compressed. Their compression_chunk_size -- metadata should be merged. select chunk_name from timescaledb_information.chunks where is_compressed=true order by chunk_name; -- -- Check that compression_chunk_size stats are also merged when we -- merge compressed chunks. -- -- Use a view to compare merged stats against the total sum of that -- stats for all chunks. There are only two compressed chunks, 1 and -- 2. Show each chunks stats as the fraction of the total size. This -- is to make the test work across different architectures that show -- slightly different absolute disk sizes. --- select sum(ccs.uncompressed_heap_size) as total_uncompressed_heap_size, sum(ccs.uncompressed_toast_size) as total_uncompressed_toast_size, sum(ccs.uncompressed_index_size) as total_uncompressed_index_size, sum(ccs.compressed_heap_size) as total_compressed_heap_size, sum(ccs.compressed_toast_size) as total_compressed_toast_size, sum(ccs.compressed_index_size) as total_compressed_index_size, sum(ccs.numrows_pre_compression) as total_numrows_pre_compression, sum(ccs.numrows_post_compression) as total_numrows_post_compression, sum(ccs.numrows_frozen_immediately) as total_numrows_frozen_immediately from _timescaledb_catalog.compression_chunk_size ccs \gset -- View to show current chunk compression size stats as a fraction of -- the totals. create view compression_size_fraction as select ccs.chunk_id, ccs.compressed_chunk_id, round(ccs.uncompressed_heap_size::numeric / :total_uncompressed_heap_size, 1) as uncompressed_heap_size_fraction, ccs.uncompressed_toast_size::numeric as uncompressed_toast_size_fraction, round(ccs.uncompressed_index_size::numeric / :total_uncompressed_index_size, 1) as uncompressed_index_size_fraction, round(ccs.compressed_heap_size::numeric / :total_compressed_heap_size, 1) as compressed_heap_size_fraction, round(ccs.compressed_toast_size::numeric / :total_compressed_toast_size, 1) as compressed_toast_size_fraction, round(ccs.compressed_index_size::numeric / :total_compressed_index_size, 1) as compressed_index_size_fraction, round(ccs.numrows_pre_compression ::numeric/ :total_numrows_pre_compression, 1) as numrows_pre_compression_fraction, round(ccs.numrows_post_compression::numeric / :total_numrows_post_compression, 1) as numrows_post_compression_fraction, round(ccs.numrows_frozen_immediately::numeric / :total_numrows_frozen_immediately, 1) as numrows_frozen_immediately_fraction from _timescaledb_catalog.compression_chunk_size ccs order by chunk_id; \set ON_ERROR_STOP 0 -- Test blocked multi-dimensional merges set timescaledb.enable_merge_multidim_chunks = false; call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_4_chunk','_timescaledb_internal._hyper_1_5_chunk', '_timescaledb_internal._hyper_1_12_chunk']); set timescaledb.enable_merge_multidim_chunks = true; \set ON_ERROR_STOP 1 -- -- Merge all chunks until only 1 remains. Also check that metadata is -- merged. --- select * from compression_size_fraction; select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_1_chunk', '_timescaledb_internal._hyper_1_4_chunk','_timescaledb_internal._hyper_1_5_chunk', '_timescaledb_internal._hyper_1_12_chunk']); select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; select * from partitions; call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_10_chunk','_timescaledb_internal._hyper_1_13_chunk', '_timescaledb_internal._hyper_1_15_chunk']); select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; select * from partitions; call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_11_chunk','_timescaledb_internal._hyper_1_14_chunk', '_timescaledb_internal._hyper_1_16_chunk']); -- Final merge, involving the two compressed chunks 1 and 2. The stats -- should also be merged. select * from compression_size_fraction; select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; select * from partitions; call merge_chunks(ARRAY['_timescaledb_internal._hyper_1_3_chunk', '_timescaledb_internal._hyper_1_1_chunk','_timescaledb_internal._hyper_1_2_chunk']); select * from compression_size_fraction; select count(*), sum(device), round(sum(temp)::numeric, 4) from mergeme; select * from partitions; select * from chunk_info; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/merge_compress.sql��������������������������������������������������0000664�0000000�0000000�00000007604�15100345067�0022175�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE TABLE target ( time TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL, partition_column TIMESTAMPTZ NOT NULL ); SELECT table_name FROM create_hypertable( 'target'::regclass, 'partition_column'::name, chunk_time_interval=>interval '8 hours', create_default_indexes=> false); -- enable compression ALTER TABLE target SET ( timescaledb.compress, timescaledb.compress_segmentby = 'series_id', timescaledb.compress_orderby = 'partition_column, value' ); SELECT '2022-10-10 14:33:44.1234+05:30' as start_date \gset INSERT INTO target (series_id, value, partition_column) SELECT s,1,t from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '5m') t cross join generate_series(1,3, 1) s; -- compress chunks SELECT count(compress_chunk(ch)) FROM show_chunks('target') ch; CREATE TABLE source ( time TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP NOT NULL, value DOUBLE PRECISION NOT NULL, series_id BIGINT NOT NULL ); SELECT table_name FROM create_hypertable( 'source'::regclass, 'time'::name, chunk_time_interval=>interval '6 hours', create_default_indexes=> false); SELECT '2022-10-10 10:00:00.0123+05:30' as start_date \gset INSERT INTO source (time, series_id, value) SELECT t, s,1 from generate_series(:'start_date'::timestamptz, :'start_date'::timestamptz + interval '1 day', '5m') t cross join generate_series(1,2, 1) s; \set ON_ERROR_STOP 0 -- Merge UPDATE on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN UPDATE SET series_id = (t.series_id * 0.123); -- Merge DELETE on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN DELETE; -- Merge UPDATE/INSERT on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN UPDATE SET series_id = (t.series_id * 0.123) WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, '2021-11-01 00:00:05'::timestamp with time zone); -- Merge DELETE/INSERT on compressed hypertables should report error MERGE INTO target t USING source s ON t.value = s.value AND t.series_id = s.series_id WHEN MATCHED THEN DELETE WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, '2021-11-01 00:00:05'::timestamp with time zone); \set ON_ERROR_STOP 1 -- total compressed chunks SELECT count(*) AS "total compressed_chunks", is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'target' GROUP BY is_compressed; -- Merge INSERT on compressed hypertables should work MERGE INTO target t USING source s ON t.partition_column = s.time AND t.value = s.value WHEN NOT MATCHED THEN INSERT VALUES ('2021-11-01 00:00:05'::timestamp with time zone, 5, 210, '2021-11-01 00:00:05'::timestamp with time zone); -- you should notice 1 uncompressed chunk SELECT count(*) AS "total compressed_chunks", is_compressed FROM timescaledb_information.chunks WHERE hypertable_name = 'target' GROUP BY is_compressed; DROP TABLE target; DROP TABLE source; ����������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/modify_exclusion.sql.in���������������������������������������������0000664�0000000�0000000�00000021523�15100345067�0023144�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set PREFIX 'EXPLAIN (ANALYZE,VERBOSE,SUMMARY OFF,TIMING OFF,BUFFERS OFF, COSTS OFF)' \i include/modify_exclusion_load.sql -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = 15; :PREFIX DELETE FROM metrics_int4 WHERE time = 15; :PREFIX DELETE FROM metrics_int8 WHERE time = 15; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.5 WHERE time = 15; :PREFIX UPDATE metrics_int4 SET value = 0.5 WHERE time = 15; :PREFIX UPDATE metrics_int8 SET value = 0.5 WHERE time = 15; ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,23)); :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,23)); :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,23)); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.3 WHERE time = length(substring(version(),1,23)); :PREFIX UPDATE metrics_int4 SET value = 0.3 WHERE time = length(substring(version(),1,23)); :PREFIX UPDATE metrics_int8 SET value = 0.3 WHERE time = length(substring(version(),1,23)); ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_int2 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; :PREFIX DELETE FROM metrics_int4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; :PREFIX DELETE FROM metrics_int8 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; :PREFIX UPDATE metrics_int4 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; :PREFIX UPDATE metrics_int8 SET value = 0.4 WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int2 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; :PREFIX UPDATE metrics_int4 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; :PREFIX UPDATE metrics_int8 SET value = 0.1 * value, data = 'update' WHERE time = length(substring(version(),1,20)) RETURNING 'returning', time; ROLLBACK; -- immutable constraints -- should not have ChunkAppend since constraint is immutable and postgres already does the exclusion -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'; :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'; :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01' AND device = '1'; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.6 WHERE time = '2000-01-01'; :PREFIX UPDATE metrics_timestamp SET value = 0.6 WHERE time = '2000-01-01'; :PREFIX UPDATE metrics_timestamptz SET value = 0.6 WHERE time = '2000-01-01'; :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01' AND device = '1'; :PREFIX UPDATE metrics_space SET value = 0.6 WHERE time = '2000-01-01'; ROLLBACK; -- stable constraints -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date; :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp; :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.9 WHERE time = '2000-01-01'::text::date; :PREFIX UPDATE metrics_timestamp SET value = 0.9 WHERE time = '2000-01-01'::text::timestamp; :PREFIX UPDATE metrics_timestamptz SET value = 0.9 WHERE time = '2000-01-01'::text::timestamptz; ROLLBACK; -- space partitioning -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table BEGIN; :PREFIX DELETE FROM metrics_space WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_space WHERE device = format('1'); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE time = '2000-01-01'::text::timestamptz AND device = format('1'); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_space SET value = 0.1 WHERE device = format('1'); ROLLBACK; -- should have ChunkAppend since constraint is stable -- should only hit 1 chunk and base table, toplevel rows should be 1 BEGIN; :PREFIX DELETE FROM metrics_date WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; :PREFIX DELETE FROM metrics_timestamp WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; :PREFIX DELETE FROM metrics_timestamptz WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_date SET value = 0.2 WHERE time = '2000-01-01'::text::date RETURNING 'returning', time; :PREFIX UPDATE metrics_timestamp SET value = 0.2 WHERE time = '2000-01-01'::text::timestamp RETURNING 'returning', time; :PREFIX UPDATE metrics_timestamptz SET value = 0.2 WHERE time = '2000-01-01'::text::timestamptz RETURNING 'returning', time; ROLLBACK; -- subselects -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2) AND time < length(version()); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 SET value = 0.1 WHERE time IN (SELECT time FROM metrics_int2 WHERE time < length(version())) AND time < length(version()); ROLLBACK; -- join -- no chunk exclusion for subqueries joins atm BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2; ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time; ROLLBACK; BEGIN; :PREFIX DELETE FROM metrics_int4 m4 USING metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time; ROLLBACK; BEGIN; :PREFIX UPDATE metrics_int4 m4 SET value = 0.15 FROM metrics_int2 m2 WHERE m4.time = m2.time AND m4.time < length(version()); ROLLBACK; -- cte -- should all have chunkappend nodes BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) SELECT * FROM d; ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version())) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) SELECT * FROM u; ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update 1' WHERE m4.time < length(version())) UPDATE metrics_int2 m2 SET data = 'cte update 2' WHERE m2.time < length(version()); ROLLBACK; BEGIN; :PREFIX WITH d AS (DELETE FROM metrics_int4 m4 WHERE m4.time < length(version()) RETURNING time) UPDATE metrics_int2 m2 SET data = 'cte update' WHERE m2.time < length(version()); ROLLBACK; BEGIN; :PREFIX WITH u AS (UPDATE metrics_int4 m4 SET data = 'cte update' WHERE m4.time < length(version()) RETURNING time) DELETE FROM metrics_int2 m2 WHERE m2.time < length(version()); ROLLBACK; -- test interaction with compression -- with chunk exclusion for compressed chunks operations that would -- error because they hit compressed chunks before can succeed now -- if those chunks get excluded -- delete from uncompressed chunks with non-immutable constraints BEGIN; :PREFIX DELETE FROM metrics_compressed WHERE time > '2005-01-01'::text::timestamptz; ROLLBACK; -- update uncompressed chunks with non-immutable constraints BEGIN; :PREFIX UPDATE metrics_compressed SET value = 2 * value WHERE time > '2005-01-01'::text::timestamptz; ROLLBACK; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/move.sql������������������������������������������������������������0000664�0000000�0000000�00000016607�15100345067�0020134�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set ON_ERROR_STOP 0 \c :TEST_DBNAME :ROLE_SUPERUSER SET client_min_messages = ERROR; DROP TABLESPACE IF EXISTS tablespace1; DROP TABLESPACE IF EXISTS tablespace2; DROP TABLESPACE IF EXISTS tablespace3; SET client_min_messages = NOTICE; CREATE TABLESPACE tablespace1 OWNER :ROLE_DEFAULT_PERM_USER LOCATION :TEST_TABLESPACE1_PATH; CREATE TABLESPACE tablespace2 OWNER :ROLE_DEFAULT_PERM_USER_2 LOCATION :TEST_TABLESPACE2_PATH; --Running some of the same tests as we do for reorder/cluster because that's how move is implemented \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER \set ON_ERROR_STOP 1 \ir include/cluster_test_setup.sql BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- Show chunk indexes SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_2_chunk'); \set ON_ERROR_STOP 0 -- cannot move a chunk with no reorder index on first call SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1'); -- cannot move a chunk without a destination tablespace set SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>NULL, index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- cannot move a chunk without an index_destination_tablespace set SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- cannot move a chunk or an index to a tablespace we do not have create permissions on SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace2', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- cannot move to a nonexistent tablespace SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace3', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace3', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- cannot move a hypertable (must specify a chunk) SELECT move_chunk(chunk=>'cluster_test', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- cannot move a NULL chunk SELECT move_chunk(chunk=>NULL, destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); -- cannot move within a transaction BEGIN; SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); END; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 -- must be hypertable owner to move a chunk SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace2', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); \set ON_ERROR_STOP 1 -- grant create permissions on tablespace2 so we can use it later. SET client_min_messages TO error; GRANT CREATE ON TABLESPACE tablespace2 TO :ROLE_DEFAULT_PERM_USER; RESET client_min_messages; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- move with chunk index for reorder SELECT FROM move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace1', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx'); SELECT * FROM test.show_subtables('cluster_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; SET enable_seqscan=Default; SET enable_indexscan=Default; SET enable_bitmapscan=Default; -- check that move puts things in the correct order, as it also reorders SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; -- move back to pg_default SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'pg_default', index_destination_tablespace=>'pg_default', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); SELECT * FROM test.show_subtables('cluster_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- move chunk and indexes to different tablespaces SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace1', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); SELECT * FROM test.show_subtables('cluster_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); -- keep chunk in same space and move index tablespace SELECT move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'pg_default', index_destination_tablespace=>'tablespace2', reorder_index=>'_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose=>TRUE); SELECT * FROM test.show_subtables('cluster_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); --TEST with compression bug 4000 --compress chunk and then move chunk and index to different tablespaces ALTER TABLE cluster_test SET (timescaledb.compress, timescaledb.compress_segmentby = 'location'); SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk') as ch; SELECT true INTO move_chunk_compressed FROM move_chunk(chunk=>'_timescaledb_internal._hyper_1_2_chunk', destination_tablespace=>'tablespace2', index_destination_tablespace=>'tablespace1', verbose=>TRUE); SELECT * FROM test.show_subtables('cluster_test'); SELECT * FROM test.show_indexesp('_timescaledb_internal._hyper%_chunk'); SELECT * FROM test.show_indexesp('_timescaledb_internal.compress_hyper%_chunk'); �������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/ordered_append.sql.in�����������������������������������������������0000664�0000000�0000000�00000004166�15100345067�0022543�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME ordered_append SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s.sql', :'TEST_BASE_NAME') as "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') as "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u --label "Uncompressed results" --label "Compressed results" %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') as "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- get EXPLAIN output for all variations \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' set work_mem to '64MB'; set max_parallel_workers_per_gather to 0; set enable_nestloop to off; \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \ir :TEST_QUERY_NAME -- get results for all the queries -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none SET client_min_messages TO error; -- run queries on compressed hypertable and store result \set TEST_TABLE 'metrics' \o :TEST_RESULTS_UNCOMPRESSED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_compressed' \o :TEST_RESULTS_COMPRESSED \ir :TEST_QUERY_NAME \o -- diff compressed and uncompressed results :DIFF_CMD -- do the same for space partitioned hypertable \set TEST_TABLE 'metrics_space' \o :TEST_RESULTS_UNCOMPRESSED \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space_compressed' \o :TEST_RESULTS_COMPRESSED \ir :TEST_QUERY_NAME \o -- diff compressed and uncompressed results :DIFF_CMD reset enable_nestloop; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/partialize_finalize.sql���������������������������������������������0000664�0000000�0000000�00000044650�15100345067�0023212�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- TEST1 count with integers SHOW enable_partitionwise_aggregate; SET enable_partitionwise_aggregate = on; create table foo (a integer, b integer, c integer); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 11 , 20); insert into foo values( 1 , 12 , 20); insert into foo values( 1 , 13 , 20); insert into foo values( 1 , 14 , 20); insert into foo values( 2 , 14 , 20); insert into foo values( 2 , 15 , 20); insert into foo values( 2 , 16 , 20); insert into foo values( 3 , 16 , 20); create or replace view v1(a , partial) as SELECT a, _timescaledb_functions.partialize_agg( count(b)) from foo group by a; create table t1 as select * from v1; select a, _timescaledb_functions.finalize_agg( 'count("any")', null, null, null, partial, cast('1' as int8) ) from t1 group by a order by a ; insert into t1 select * from t1; select a, _timescaledb_functions.finalize_agg( 'count("any")', null, null, null, partial, cast('1' as int8) ) from t1 group by a order by a ; --TEST2 sum numeric and min on float-- drop table t1; drop view v1; drop table foo; create table foo (a integer, b numeric , c float); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 20 , 19); insert into foo values( 1 , 30 , 11.0); insert into foo values( 1 , 40 , 200); insert into foo values( 1 , 50 , -10); insert into foo values( 2 , 10 , 20); insert into foo values( 2 , 20 , 20); insert into foo values( 2 , 30 , 20); insert into foo values( 3 , 40 , 0); create or replace view v1(a , partialb, partialminc) as SELECT a, _timescaledb_functions.partialize_agg( sum(b)) , _timescaledb_functions.partialize_agg( min(c)) from foo group by a; create table t1 as select * from v1; select a, _timescaledb_functions.finalize_agg( 'sum(numeric)', null, null, null, partialb, cast('1' as numeric) ) sumb, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; insert into foo values( 3, 0, -1); insert into foo values( 5, 40, 10); insert into foo values( 5, 40, 0); --note that rows for 3 get added all over again + new row --sum aggfnoid 2114, min aggfnoid is 2136 oid numeric is 1700 insert into t1 select * from v1 where ( a = 3 ) or a = 5; select a, _timescaledb_functions.finalize_agg( 'sum(numeric)', null, null, null, partialb, cast('1' as numeric) ) sumb, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; SET enable_partitionwise_aggregate = off; --TEST3 sum with expressions drop table t1; drop view v1; drop table foo; create table foo (a integer, b numeric , c float); insert into foo values( 1 , 10 , 20); insert into foo values( 1 , 20 , 19); insert into foo values( 1 , 30 , 11.0); insert into foo values( 1 , 40 , 200); insert into foo values( 1 , 50 , -10); insert into foo values( 2 , 10 , 20); insert into foo values( 2 , 20 , 20); insert into foo values( 2 , 30 , 20); insert into foo values( 3 , 40 , 0); insert into foo values(10, NULL, NULL); insert into foo values(11, NULL, NULL); insert into foo values(11, NULL, NULL); insert into foo values(12, NULL, NULL); create or replace view v1(a , b, partialb, partialminc) as SELECT a, b, _timescaledb_functions.partialize_agg( sum(b+c)) , _timescaledb_functions.partialize_agg( min(c)) from foo group by a, b ; create table t1 as select * from v1; insert into foo values( 3, 0, -1); insert into foo values( 5, 40, 10); insert into foo values( 5, 40, 0); insert into foo values(12, 10, 20); insert into t1 select * from v1 where ( a = 3 and b = 0 ) or a = 5 or (a = 12 and b = 10) ; --results should match query: select a, sum(b+c), min(c) from foo group by a order by a; --sum aggfnoid 2111 for float8, min aggfnoid is 2136 oid numeric is 1700 select a, _timescaledb_functions.finalize_agg( 'sum(double precision)', null, null, null, partialb, null::float8 ) sumcd, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; insert into t1 select * from v1; select a, _timescaledb_functions.finalize_agg( 'sum(double precision)', null, null, null, partialb, null::float8 ) sumcd, _timescaledb_functions.finalize_agg( 'min(double precision)', null, null, null, partialminc, cast('1' as float8) ) minc from t1 group by a order by a ; -- TEST4 with collation (text), NULLS and timestamp -- drop table t1; drop view v1; drop table foo; create table foo (a integer, b numeric , c text, d timestamptz, e bigint); insert into foo values( 1 , 10 , 'hello', '2010-01-01 09:00:00-08', 10); insert into foo values( 1 , 20 , 'abc', '2010-01-02 09:00:00-08', 20); insert into foo values( 1 , 30 , 'abcd', '2010-01-03 09:00:00-08', 30); insert into foo values( 1 , 40 , 'abcde', NULL, 40); insert into foo values( 1 , 50 , NULL, '2010-01-01 09:00:00-08', 50); --group with all values for c and d same insert into foo values( 2 , 10 , 'hello', '2010-01-01 09:00:00-08', 10); insert into foo values( 2 , 20 , 'hello', '2010-01-01 09:00:00-08', 20); insert into foo values( 2 , 30 , 'hello', '2010-01-01 09:00:00-08', 30); --group with all values for c and d NULL insert into foo values( 3 , 40 , NULL, NULL, 40); insert into foo values( 3 , 50 , NULL, NULL, 50); insert into foo values(11, NULL, NULL, NULL, NULL); insert into foo values(11, NULL, 'hello', '2010-01-02 09:00:00-05', NULL); --group with all values for c and d NULL and later add non-null. insert into foo values(12, NULL, NULL, NULL, NULL); create or replace view v1(a , b, partialb, partialc, partiald, partiale, partialf) as SELECT a, b, _timescaledb_functions.partialize_agg(sum(b)) , _timescaledb_functions.partialize_agg(min(c)) , _timescaledb_functions.partialize_agg(max(d)) , _timescaledb_functions.partialize_agg(stddev(b)) , _timescaledb_functions.partialize_agg(stddev(e)) from foo group by a, b ; create table saved_partials as select * from v1; create table t1 as select * from v1; --sum 2114, collid 0, min(text) 2145, collid 100, max(ts) 2127 insert into foo values(12, 10, 'hello', '2010-01-02 09:00:00-05', 10); insert into t1 select * from v1 where (a = 12 and b = 10) ; --select a, sum(b), min(c) , max(d), stddev(b), stddev(e) from foo group by a order by a; --results should match above query CREATE OR REPLACE VIEW vfinal(a , sumb, minc, maxd, stddevb, stddeve) AS select a, _timescaledb_functions.finalize_agg( 'sum(numeric)', null, null, null, partialb, null::numeric ) sumb , _timescaledb_functions.finalize_agg( 'min(text)', 'pg_catalog', 'default', null, partialc, null::text ) minc , _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partiald, null::timestamptz ) maxd , _timescaledb_functions.finalize_agg( 'stddev(numeric)', null, null, null, partiale, null::numeric ) stddevb , _timescaledb_functions.finalize_agg( 'stddev(int8)', null, null, null, partialf, null::numeric ) stddeve from t1 group by a order by a ; SELECT * FROM vfinal; CREATE TABLE vfinal_res AS SELECT * FROM vfinal; --with having clause -- select a, b , _timescaledb_functions.finalize_agg( 'min(text)', 'pg_catalog', 'default', null, partialc, null::text ) minc, _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partiald, null::timestamptz ) maxd from t1 where b is not null group by a, b having _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partiald, null::timestamptz ) is not null order by a, b; --TEST5 test with TOAST data drop view vfinal; drop table t1; drop view v1; drop table foo; create table foo( a integer, b timestamptz, toastval TEXT); -- Set storage type to EXTERNAL to prevent PostgreSQL from compressing my -- easily compressable string and instead store it with TOAST ALTER TABLE foo ALTER COLUMN toastval SET STORAGE EXTERNAL; SELECT count(*) FROM create_hypertable('foo', 'b'); INSERT INTO foo VALUES( 1, '2004-10-19 10:23:54', repeat('this must be over 2k. ', 1100)); INSERT INTO foo VALUES(1, '2005-10-19 10:23:54', repeat('I am a tall big giraffe in the zoo. ', 1100)); INSERT INTO foo values( 1, '2005-01-01 00:00:00+00', NULL); INSERT INTO foo values( 2, '2005-01-01 00:00:00+00', NULL); create or replace view v1(a, partialb, partialtv) as select a, _timescaledb_functions.partialize_agg( max(b) ), _timescaledb_functions.partialize_agg( min(toastval)) from foo group by a; EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF) create table t1 as select * from v1; create table t1 as select * from v1; insert into t1 select * from v1; select a, _timescaledb_functions.finalize_agg( 'max(timestamp with time zone)', null, null, null, partialb, null::timestamptz ) maxb, _timescaledb_functions.finalize_agg( 'min(text)', 'pg_catalog', 'default', null, partialtv, null::text ) = repeat('I am a tall big giraffe in the zoo. ', 1100) mintv_equal from t1 group by a order by a; --non top-level partials with cte as ( select a, _timescaledb_functions.partialize_agg(min(toastval)) tp from foo group by a ) select length(tp) from cte; select length(_timescaledb_functions.partialize_agg( min(toastval))) from foo group by a; select length(_timescaledb_functions.partialize_agg(min(a+1))) from foo; \set ON_ERROR_STOP 0 select length(_timescaledb_functions.partialize_agg(1+min(a))) from foo; select length(_timescaledb_functions.partialize_agg(min(a)+min(a))) from foo; --non-trivial HAVING clause not allowed with partialize_agg select time_bucket('1 hour', b) as b, _timescaledb_functions.partialize_agg(avg(a)) from foo group by 1 having avg(a) > 3; --mixing partialized and non-partialized aggs is not allowed select time_bucket('1 hour', b) as b, _timescaledb_functions.partialize_agg(avg(a)), sum(a) from foo group by 1; \set ON_ERROR_STOP 1 --partializing works with HAVING when the planner can effectively --reduce it. In this case to a simple filter. select time_bucket('1 hour', b) as b, toastval, _timescaledb_functions.partialize_agg(avg(a)) from foo group by b, toastval having toastval LIKE 'does not exist'; -- -- TEST FINALIZEFUNC_EXTRA -- -- create special aggregate to test ffunc_extra -- Raise warning with the actual type being passed in CREATE OR REPLACE FUNCTION fake_ffunc(a int8, b int, x anyelement) RETURNS anyelement AS $$ BEGIN RAISE WARNING 'type %', pg_typeof(x); RETURN x; END; $$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION fake_sfunc(a int8, b int, x anyelement) RETURNS int8 AS $$ BEGIN RETURN b; END; $$ LANGUAGE plpgsql; CREATE AGGREGATE aggregate_to_test_ffunc_extra(int, anyelement) ( SFUNC = fake_sfunc, STYPE = int8, COMBINEFUNC = int8pl, FINALFUNC = fake_ffunc, PARALLEL = SAFE, FINALFUNC_EXTRA ); select aggregate_to_test_ffunc_extra(8, 'name'::text); \set ON_ERROR_STOP 0 --errors on wrong input type array with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, null, part, null::text) from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['a'::name, 'b'::name, 'c'::name]], part, null::text) from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array[]::name[]]::name[], part, null::text) from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[]::name[], part, null::text) from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['public'::name, 'int'::name], array['public', 'text']], part, null::text) from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['public'::name, 'int4'::name], array['public', 'text']], part, null::text) from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['pg_catalog'::name, 'int4'::name], array['pg_catalog', 'text'], array['pg_catalog', 'text']], part, null::text) from cte; select _timescaledb_functions.finalize_agg(NULL::text,NULL::name,NULL::name,NULL::_name,NULL::bytea,a) over () from foo; \set ON_ERROR_STOP 1 --make sure right type in warning and is null returns true with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 'name'::text)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['pg_catalog'::name, 'int4'::name], array['pg_catalog', 'text']], part, null::text) is null from cte; with cte as (SELECT _timescaledb_functions.partialize_agg(aggregate_to_test_ffunc_extra(8, 1::bigint)) as part) select _timescaledb_functions.finalize_agg( 'aggregate_to_test_ffunc_extra(int, anyelement)', null, null, array[array['pg_catalog'::name, 'int4'::name], array['pg_catalog', 'int8']], part, null::text) is null from cte; -- Issue 4922 CREATE TABLE issue4922 ( time TIMESTAMPTZ NOT NULL, value INTEGER ); SELECT create_hypertable('issue4922', 'time'); -- helper function: integer -> pseudorandom integer [0..100]. CREATE OR REPLACE FUNCTION mix(x INTEGER) RETURNS INTEGER AS $$ SELECT (((hashint4(x) / (pow(2, 31) - 1) + 1) / 2) * 100)::INTEGER $$ LANGUAGE SQL; INSERT INTO issue4922 (time, value) SELECT '2022-01-01 00:00:00-03'::timestamptz + interval '1 year' * mix(x), mix(x) FROM generate_series(1, 100000) x(x); SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); SET parallel_setup_cost = 0; -- Materialize partials from execution of parallel query plan EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF) SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; CREATE MATERIALIZED VIEW issue4922_partials_parallel AS SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; -- Materialize partials from execution of non-parallel query plan SET max_parallel_workers_per_gather = 0; EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF) SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; CREATE MATERIALIZED VIEW issue4922_partials_non_parallel AS SELECT _timescaledb_functions.partialize_agg(sum(value)) AS partial_sum, _timescaledb_functions.partialize_agg(avg(value)) AS partial_avg, _timescaledb_functions.partialize_agg(min(value)) AS partial_min, _timescaledb_functions.partialize_agg(max(value)) AS partial_max, _timescaledb_functions.partialize_agg(count(*)) AS partial_count FROM public.issue4922; RESET max_parallel_workers_per_gather; -- partials should be the same in both parallel and non-parallel execution SELECT * FROM issue4922_partials_parallel; SELECT * FROM issue4922_partials_non_parallel; -- Compare results from partial and non-partial query execution SELECT sum(value), avg(value), min(value), max(value), count(*) FROM issue4922; -- The results should be the EQUAL TO the previous query SELECT _timescaledb_functions.finalize_agg('pg_catalog.sum(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_sum, NULL::bigint) AS sum, _timescaledb_functions.finalize_agg('pg_catalog.avg(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_avg, NULL::numeric) AS avg, _timescaledb_functions.finalize_agg('pg_catalog.min(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_min, NULL::integer) AS min, _timescaledb_functions.finalize_agg('pg_catalog.max(integer)'::text, NULL::name, NULL::name, '{{pg_catalog,int4}}'::name[], partial_max, NULL::integer) AS max, _timescaledb_functions.finalize_agg('pg_catalog.count()'::text, NULL::name, NULL::name, '{}'::name[], partial_count, NULL::bigint) AS count FROM issue4922_partials_parallel; -- Test that a "soft" error causes an attempt to repair the row -- We don't care about the result here (but it is the sum of the b -- column where a = 1 in table "foo" above), just that it should -- attempt a repair, do the repair, and then not fail. -- -- Do this by reading the partial numeric format and drop bytes from -- the end of it (16 bytes, meaning 32 characters). This is what we -- know how to repair. Next, attempt to decode the partial and check -- that it attempt a repair and actually does the repair (zero-filling -- the end). SET client_min_messages TO debug2; \set VERBOSITY default WITH sample AS (SELECT encode(partialb, 'hex') part FROM saved_partials WHERE a = 1), broken AS (SELECT decode(left(part, -32), 'hex') partialb FROM sample) SELECT _timescaledb_functions.finalize_agg('sum(numeric)', null, null, null, broken.partialb, null::numeric) sumb FROM broken; RESET client_min_messages; \set VERBOSITY terse DROP TABLE saved_partials; ����������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/plan_skip_scan.sql.in�����������������������������������������������0000664�0000000�0000000�00000004045�15100345067�0022550�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_query.sql \set TABLE skip_scan_ht \ir include/skip_scan_query.sql \ir include/skip_scan_query_ht.sql -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_comp_query.sql -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_load_comp_query.sql -- try one query with EXPLAIN only for coverage EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan; EXPLAIN (buffers off, costs off, timing off, summary off) SELECT DISTINCT ON (dev_name) dev_name FROM skip_scan_ht; -- #3629 skipscan with constant skipscan column in where clause CREATE TABLE i3629(a int, time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('i3629', 'time'); INSERT INTO i3629 SELECT i, '2020-04-01'::date-10-i from generate_series(1,20) i; EXPLAIN (SUMMARY OFF, BUFFERS OFF, COSTS OFF) SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; SELECT DISTINCT ON (a) * FROM i3629 WHERE a in (2) ORDER BY a ASC, time DESC; -- #3720 skipscan not being used on varchar column CREATE TABLE i3720(time timestamptz not null,data varchar); SELECT table_name FROM create_hypertable('i3720','time'); INSERT INTO i3720 SELECT time, (array['Yes', 'No', 'Maybe'])[floor(random() * 3 + 1)] FROM generate_series('2000-01-01'::timestamptz,'2000-01-03'::timestamptz, '10 minute'::interval) AS g1(time); CREATE INDEX ON i3720(data, time); ANALYZE i3720; :PREFIX SELECT DISTINCT ON(data) * FROM i3720; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/plan_skip_scan_dagg.sql.in������������������������������������������0000664�0000000�0000000�00000001611�15100345067�0023526�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set TABLE skip_scan \ir include/skip_scan_dagg_query.sql \set TABLE skip_scan_ht \ir include/skip_scan_dagg_query.sql \ir include/skip_scan_dagg_query_ht.sql -- run tests on compressed hypertable with different compression settings \set TABLE skip_scan_htc \ir include/skip_scan_dagg_comp_query.sql -- run tests on compressed hypertable with different layouts of compressed chunks \set TABLE skip_scan_htcl \ir include/skip_scan_dagg_load_comp_query.sql �����������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/plan_skip_scan_notnull.sql������������������������������������������0000664�0000000�0000000�00000003162�15100345067�0023715�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to modify statistics \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \ir include/skip_scan_load.sql -- we want to run with analyze here so we can see counts in the nodes \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' -- test SkipScan NOT NULL mode -- also sets up "skip_scan_b" table with a bool column and a not null column \ir include/skip_scan_notnull_setup.sql SET timescaledb.debug_skip_scan_info TO true; \set TABLE skip_scan \ir include/skip_scan_notnull.sql -- Set up hypertable with bool column SELECT create_hypertable('skip_scan_b', 'time', chunk_time_interval => 500, create_default_indexes => false, migrate_data => true); -- Set up hypertable with not null column SELECT create_hypertable('skip_scan_nn', 'time', chunk_time_interval => 500, create_default_indexes => false, migrate_data => true); \set TABLE skip_scan_ht \ir include/skip_scan_notnull.sql -- Compress on bool column ALTER TABLE skip_scan_b SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='b'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_b') ch; -- Compress on not null column ALTER TABLE skip_scan_nn SET (timescaledb.compress, timescaledb.compress_orderby='time desc', timescaledb.compress_segmentby='dev'); SELECT compress_chunk(ch) FROM show_chunks('skip_scan_nn') ch; \set TABLE skip_scan_htc \ir include/skip_scan_notnull.sql RESET timescaledb.debug_skip_scan_info; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/policy_generalization.sql�������������������������������������������0000664�0000000�0000000�00000010062�15100345067�0023545�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Validate utility functions and policies for INTEGER columns -- using chunk creation time metadata. This allows to specify -- INTERVAL boundary for INTEGER type columns. DROP TABLE IF EXISTS test; CREATE TABLE test(time INTEGER, device INTEGER, temp FLOAT); SELECT create_hypertable('test', 'time', chunk_time_interval => 10); INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; select count(*) from timescaledb_information.chunks where hypertable_name='test'; -- Validate that show_chunks/drop chunks doesn't work with existing arguments \set ON_ERROR_STOP 0 SELECT count(*) from show_chunks('test', newer_than => INTERVAL '1 hour'); SELECT count(*) from show_chunks('test', older_than => now()); SELECT count(*) from drop_chunks('test', older_than => now()); \set ON_ERROR_STOP 1 SELECT count(*) from show_chunks('test', created_after => INTERVAL '1 hour'); SELECT count(*) from show_chunks('test', created_before => now()); SELECT count(*) from drop_chunks('test', created_before => now()); select count(*) from timescaledb_information.chunks where hypertable_name='test'; INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; select count(*) from timescaledb_information.chunks where hypertable_name='test'; SELECT count(*) from drop_chunks('test', created_after => INTERVAL '1 hour'); select count(*) from timescaledb_information.chunks where hypertable_name='test'; -- retention policy INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; \set ON_ERROR_STOP 0 -- interval input for "drop_after" for INTEGER partitioning errors out SELECT add_retention_policy('test', INTERVAL '5 seconds', true); -- integer input for "drop_after" for INTEGER partitioning without valid -- integer_now function errors out SELECT add_retention_policy('test', 2000, true); -- both drop_created_before and drop_after should error out SELECT add_retention_policy('test', drop_after => INTERVAL '5 seconds', drop_created_before => INTERVAL '2 seconds'); \set ON_ERROR_STOP 1 SELECT add_retention_policy('test', drop_created_before => INTERVAL '2 seconds', if_not_exists => true) as drop_chunks_job_id \gset CALL run_job(:drop_chunks_job_id); select count(*) from timescaledb_information.chunks where hypertable_name='test'; SELECT pg_sleep(3); CALL run_job(:drop_chunks_job_id); select count(*) from timescaledb_information.chunks where hypertable_name='test'; -- check for WARNING/NOTICE if policy already exists SELECT add_retention_policy('test', drop_created_before => INTERVAL '2 seconds', if_not_exists => true); SELECT add_retention_policy('test', drop_created_before => INTERVAL '20 seconds', if_not_exists => true); SELECT remove_retention_policy('test'); -- compression policy ALTER TABLE test SET (timescaledb.compress); INSERT INTO test SELECT i, i %10, 0.10 FROM generate_series(1, 100, 1) i; -- Chunk compression status SELECT DISTINCT compression_status FROM _timescaledb_internal.compressed_chunk_stats; -- Compression policy SELECT add_compression_policy('test', compress_created_before => INTERVAL '1 hour') AS compress_chunks_job_id \gset SELECT pg_sleep(3); CALL run_job(:compress_chunks_job_id); -- Chunk compression status SELECT DISTINCT compression_status FROM _timescaledb_internal.compressed_chunk_stats; SELECT remove_compression_policy('test'); SELECT add_compression_policy('test', compress_created_before => INTERVAL '2 seconds') AS compress_chunks_job_id \gset CALL run_job(:compress_chunks_job_id); -- Chunk compression status SELECT DISTINCT compression_status FROM _timescaledb_internal.compressed_chunk_stats; -- check for WARNING/NOTICE if policy already exists SELECT add_compression_policy('test', compress_created_before => INTERVAL '2 seconds', if_not_exists => true); SELECT add_compression_policy('test', compress_created_before => INTERVAL '20 seconds', if_not_exists => true); SELECT remove_compression_policy('test'); DROP TABLE test; ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/privilege_maintain.sql����������������������������������������������0000664�0000000�0000000�00000002420�15100345067�0023020�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ROLE r_maintain; CREATE TABLE metrics(time timestamptz, device text, value float); SELECT create_hypertable('metrics', 'time'); INSERT INTO metrics SELECT generate_series('2020-01-01'::timestamptz, '2020-01-09'::timestamptz, '3 day'::interval); \dp metrics \dp _timescaledb_internal._hyper_* GRANT MAINTAIN ON TABLE metrics TO r_maintain; -- check privilege is present on all the chunks \dp metrics \dp _timescaledb_internal._hyper_* REVOKE MAINTAIN ON TABLE metrics FROM r_maintain; -- check privilege got removed from all the chunks \dp metrics \dp _timescaledb_internal._hyper_* ALTER TABLE metrics SET (timescaledb.compress); SELECT compress_chunk(chunk) FROM show_chunks('metrics') chunk; GRANT MAINTAIN ON TABLE metrics TO r_maintain; -- check privilege is present on all the chunks \dp metrics \dp _timescaledb_internal._hyper_* \dp _timescaledb_internal.*compress* REVOKE MAINTAIN ON TABLE metrics FROM r_maintain; -- check privilege got removed from all the chunks \dp metrics \dp _timescaledb_internal._hyper_* \dp _timescaledb_internal.*compress* ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/read_only.sql�������������������������������������������������������0000664�0000000�0000000�00000016751�15100345067�0021142�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; -- Following tests checks that API functions which modify data (including catalog) -- properly recognize read-only transaction state -- -- create_hypertable() -- CREATE TABLE test_table(time bigint NOT NULL, device int); -- EXPLAIN should work in read-only mode, when enabling in transaction. START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM test_table; ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) SELECT * FROM test_table; ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO test_table VALUES (1, 1); ROLLBACK; -- This should give an error since we are using ANALYZE and a DML. The -- read-only is checked when executing the actual INSERT statement, -- not inside our code. \set ON_ERROR_STOP 0 START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) INSERT INTO test_table VALUES (1, 1); ROLLBACK; \set ON_ERROR_STOP 1 SET default_transaction_read_only TO on; -- EXPLAIN should work in read-only mode, even when using the default. START TRANSACTION; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT * FROM test_table; ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) SELECT * FROM test_table; ROLLBACK; START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (BUFFERS OFF, COSTS OFF) INSERT INTO test_table VALUES (1, 1); ROLLBACK; -- This should give an error since we are using ANALYZE and a DML. The -- read-only is checked when executing the actual INSERT statement, -- not inside our code. \set ON_ERROR_STOP 0 START TRANSACTION; SET transaction_read_only TO on; EXPLAIN (ANALYZE ON, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF) INSERT INTO test_table VALUES (1, 1); ROLLBACK; \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 SELECT * FROM create_hypertable('test_table', 'time'); \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; SELECT * FROM create_hypertable('test_table', 'time', chunk_time_interval => 1000000::bigint); SET default_transaction_read_only TO on; \set ON_ERROR_STOP 0 -- set_chunk_time_interval() -- SELECT * FROM set_chunk_time_interval('test_table', 2000000000::bigint); -- set_number_partitions() -- SELECT * FROM set_number_partitions('test_table', 2); -- set_adaptive_chunking() -- SELECT * FROM set_adaptive_chunking('test_table', '2MB'); -- drop_chunks() -- SELECT * FROM drop_chunks('test_table', older_than => 10); -- add_dimension() -- SELECT * FROM add_dimension('test_table', 'device', chunk_time_interval => 100); \set ON_ERROR_STOP 1 -- tablespaces -- SET default_transaction_read_only TO off; SET client_min_messages TO error; DROP TABLESPACE IF EXISTS tablespace1; RESET client_min_messages; CREATE TABLESPACE tablespace1 OWNER :ROLE_CLUSTER_SUPERUSER LOCATION :TEST_TABLESPACE1_PATH; SET default_transaction_read_only TO on; -- attach_tablespace() -- \set ON_ERROR_STOP 0 SELECT * FROM attach_tablespace('tablespace1', 'test_table'); \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; SELECT * FROM attach_tablespace('tablespace1', 'test_table'); -- detach_tablespace() -- SET default_transaction_read_only TO on; \set ON_ERROR_STOP 0 SELECT * FROM detach_tablespace('tablespace1', 'test_table'); \set ON_ERROR_STOP 1 -- detach_tablespaces() -- \set ON_ERROR_STOP 0 SELECT * FROM detach_tablespaces('test_table'); \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; SELECT * FROM detach_tablespaces('test_table'); DROP TABLESPACE tablespace1; -- drop hypertable -- SET default_transaction_read_only TO on; \set ON_ERROR_STOP 0 DROP TABLE test_table; \set ON_ERROR_STOP 1 SET default_transaction_read_only TO off; DROP TABLE test_table; -- Test some read-only cases of DDL operations -- CREATE TABLE test_table(time bigint NOT NULL, device int); SELECT * FROM create_hypertable('test_table', 'time', chunk_time_interval => 1000000::bigint); INSERT INTO test_table VALUES (0, 1), (1, 1), (2, 2); SET default_transaction_read_only TO on; -- CREATE INDEX -- \set ON_ERROR_STOP 0 CREATE INDEX test_table_device_idx ON test_table(device); \set ON_ERROR_STOP 1 -- TRUNCATE -- \set ON_ERROR_STOP 0 TRUNCATE test_table; \set ON_ERROR_STOP 1 -- ALTER TABLE -- \set ON_ERROR_STOP 0 ALTER TABLE test_table DROP COLUMN device; ALTER TABLE test_table ADD CONSTRAINT device_check CHECK (device > 0); \set ON_ERROR_STOP 1 -- VACUUM -- \set ON_ERROR_STOP 0 VACUUM test_table; \set ON_ERROR_STOP 1 -- CLUSTER -- \set ON_ERROR_STOP 0 CLUSTER test_table USING test_table_time_idx; \set ON_ERROR_STOP 1 -- COPY FROM -- \set ON_ERROR_STOP 0 COPY test_table (time, device) FROM STDIN DELIMITER ','; \set ON_ERROR_STOP 1 -- COPY TO (expect to be working in read-only mode) -- COPY (SELECT * FROM test_Table ORDER BY time) TO STDOUT; -- Test Continuous Aggregates -- SET default_transaction_read_only TO off; CREATE TABLE test_contagg ( observation_time TIMESTAMPTZ NOT NULL, device_id TEXT NOT NULL, metric DOUBLE PRECISION NOT NULL, PRIMARY KEY(observation_time, device_id) ); SELECT create_hypertable('test_contagg', 'observation_time'); SET default_transaction_read_only TO on; -- CREATE VIEW -- \set ON_ERROR_STOP 0 CREATE MATERIALIZED VIEW test_contagg_view WITH (timescaledb.continuous) AS SELECT time_bucket('1 hour', observation_time) as bucket, device_id, avg(metric) as metric_avg, max(metric)-min(metric) as metric_spread FROM test_contagg GROUP BY bucket, device_id WITH NO DATA; -- policy API -- compression policy will not throw an error, as it is expected to continue -- with next chunks SET default_transaction_read_only TO off; CREATE TABLE test_table_int(time bigint NOT NULL, device int); SELECt create_hypertable('test_table_int', 'time', chunk_time_interval=>'1'::bigint); create or replace function dummy_now() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 5::BIGINT'; select set_integer_now_func('test_table_int', 'dummy_now'); ALTER TABLE test_table_int SET (timescaledb.compress); INSERT INTO test_table_int VALUES (0, 1), (10,10); SELECT add_compression_policy('test_table_int', '1'::integer) as comp_job_id \gset SELECT config as comp_job_config FROM _timescaledb_config.bgw_job WHERE id = :comp_job_id \gset SET default_transaction_read_only TO on; CALL _timescaledb_functions.policy_compression(:comp_job_id, :'comp_job_config'); SET default_transaction_read_only TO off; --verify chunks are not compressed SELECT count(*) , count(*) FILTER ( WHERE is_compressed is true) FROM timescaledb_information.chunks WHERE hypertable_name = 'test_table_int'; --cleanup DROP TABLE test_table_int; SET default_transaction_read_only TO on; CALL _timescaledb_functions.policy_refresh_continuous_aggregate(1,'{}'); CALL _timescaledb_functions.policy_reorder(1,'{}'); CALL _timescaledb_functions.policy_retention(1,'{}'); SELECT add_compression_policy('test_table', '1w'); SELECT remove_compression_policy('test_table'); SELECT add_reorder_policy('test_table', 'test_table_time_idx'); SELECT remove_reorder_policy('test_table'); SELECT add_retention_policy('test_table', '1w'); SELECT remove_retention_policy('test_table'); SELECT add_job('now','12h'); SELECT alter_job(1,scheduled:=false); SELECT delete_job(1); �����������������������timescaledb-2.23.0/tsl/test/sql/recompress_chunk_segmentwise.sql������������������������������������0000664�0000000�0000000�00000043645�15100345067�0025154�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE VIEW compressed_chunk_info_view AS SELECT h.schema_name AS hypertable_schema, h.table_name AS hypertable_name, c.schema_name as chunk_schema, c.table_name as chunk_name, c.status as chunk_status, comp.schema_name as compressed_chunk_schema, comp.table_name as compressed_chunk_name, c.id as chunk_id FROM _timescaledb_catalog.hypertable h JOIN _timescaledb_catalog.chunk c ON h.id = c.hypertable_id LEFT JOIN _timescaledb_catalog.chunk comp ON comp.id = c.compressed_chunk_id ; CREATE OR REPLACE VIEW compression_rowcnt_view AS select ccs.numrows_pre_compression, ccs.numrows_post_compression, (v.chunk_schema || '.' || v.chunk_name) as chunk_name, v.chunk_id as chunk_id from _timescaledb_catalog.compression_chunk_size ccs join compressed_chunk_info_view v on ccs.chunk_id = v.chunk_id; -- enable GUC to ensure correct index is being used during recompression SET timescaledb.debug_compression_path_info TO ON; ------------- only one segment exists and only one segment affected --------- create table mytab_oneseg (time timestamptz not null, a int, b int, c int); SELECT create_hypertable('mytab_oneseg', 'time', chunk_time_interval => interval '1 day'); insert into mytab_oneseg values ('2023-01-01 21:56:20.048355+02'::timestamptz, 2, NULL, 2), ('2023-01-01 21:56:10.048355+02'::timestamptz, 2, NULL, 2); --same chunk same segment alter table mytab_oneseg set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select show_chunks as chunk_to_compress_1 from show_chunks('mytab_oneseg') limit 1 \gset select compress_chunk(:'chunk_to_compress_1'); SELECT compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name_1 from compressed_chunk_info_view where hypertable_name = 'mytab_oneseg' \gset SELECT ctid, * FROM :compressed_chunk_name_1; -- after compressing the chunk select numrows_pre_compression, numrows_post_compression from _timescaledb_catalog.compression_chunk_size; insert into mytab_oneseg values ('2023-01-01 19:56:20.048355+02'::timestamptz, 2, NULL, 2); -- after inserting new row in compressed chunk select numrows_pre_compression, numrows_post_compression from _timescaledb_catalog.compression_chunk_size; select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_1'); -- check the ctid of the rows in the recompressed chunk to verify that we've written new data SELECT ctid, * FROM :compressed_chunk_name_1; -- after recompressing chunk select numrows_pre_compression, numrows_post_compression from _timescaledb_catalog.compression_chunk_size; insert into mytab_oneseg values ('2023-01-01 19:56:20.048355+02'::timestamptz, 2, NULL, 2); select chunk_id from compressed_chunk_info_view where hypertable_name = 'mytab_oneseg' \gset -- check we are handling unexpected chunk status (partially compressed but not compressed) update _timescaledb_catalog.chunk set status = 8 where id = :chunk_id; \set ON_ERROR_STOP 0 select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_1'); \set ON_ERROR_STOP 1 ---------------- test1: one affected segment, one unaffected -------------- -- unaffected segment will still be recompressed in a future PR we want to avoid doing this create table mytab_twoseg (time timestamptz not null, a int, b int, c int); SELECT create_hypertable('mytab_twoseg', 'time', chunk_time_interval => interval '1 day'); insert into mytab_twoseg values ('2023-01-01 21:56:20.048355+02'::timestamptz, 2, NULL, 2), ('2023-01-01 21:56:20.048355+02'::timestamptz, 3, NULL, 3), --same chunk diff segment ('2023-01-01 21:57:20.048355+02'::timestamptz, 3, NULL, 3); alter table mytab_twoseg set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select show_chunks as chunk_to_compress_2 from show_chunks('mytab_twoseg') limit 1 \gset select compress_chunk(:'chunk_to_compress_2'); -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; insert into mytab_twoseg values ('2023-01-01 19:56:20.048355+02'::timestamptz, 2, NULL, 2); select * from :chunk_to_compress_2 ORDER BY a, c, time DESC; SELECT compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name_2 from compressed_chunk_info_view where hypertable_name = 'mytab_twoseg' \gset select ctid, * from :compressed_chunk_name_2; select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_2'); -- verify that metadata count looks good select ctid, * from :compressed_chunk_name_2; -- verify that initial data is returned as expected select * from :chunk_to_compress_2 ORDER BY a, c, time DESC; -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; ----------------- more than one batch per segment ---------------------- -- test that metadata sequence number is correct create table mytab2(time timestamptz not null, a int, b int, c int); select create_hypertable('mytab2', 'time', chunk_time_interval => interval '1 week'); insert into mytab2 (time, a, c) select t,s,s from generate_series('2023-01-01 00:00:00+00'::timestamptz, '2023-01-01 00:00:00+00'::timestamptz + interval '1 day', interval '30 sec') t cross join generate_series(0,2, 1) s; alter table mytab2 set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select compress_chunk(c) from show_chunks('mytab2') c; SELECT compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name_2 from compressed_chunk_info_view where hypertable_name = 'mytab2' and compressed_chunk_name is not null limit 1 \gset insert into mytab2 values ('2023-01-01 00:00:02+00'::timestamptz, 0, NULL, 0); -- goes into the uncompressed chunk select show_chunks('mytab2') as chunk_to_compress_2 \gset select ctid, * from :compressed_chunk_name_2; -- after compression -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; select _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress_2'); select ctid, * from :compressed_chunk_name_2; -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'chunk_to_compress_2'; -- failing test from compression_ddl CREATE TABLE test_defaults(time timestamptz NOT NULL, device_id int); SELECT create_hypertable('test_defaults','time'); ALTER TABLE test_defaults SET (timescaledb.compress,timescaledb.compress_segmentby='device_id'); -- create 2 chunks INSERT INTO test_defaults SELECT '2000-01-01', 1; INSERT INTO test_defaults SELECT '2001-01-01', 1; SELECT compress_chunk(show_chunks) AS "compressed_chunk" FROM show_chunks('test_defaults') ORDER BY show_chunks::text LIMIT 1 \gset -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'compressed_chunk'; SELECT * FROM test_defaults ORDER BY 1; ALTER TABLE test_defaults ADD COLUMN c1 int; ALTER TABLE test_defaults ADD COLUMN c2 int NOT NULL DEFAULT 42; SELECT * FROM test_defaults ORDER BY 1,2; INSERT INTO test_defaults SELECT '2000-01-01', 2; SELECT * FROM test_defaults ORDER BY 1,2; SELECT compress_chunk(:'compressed_chunk'); SELECT * FROM test_defaults ORDER BY 1,2; -- stats are no longer updated during segmentwise recompression select * from compression_rowcnt_view where chunk_name = :'compressed_chunk'; -- test prepared statements -- PREPRE A SELECT before recompress and perform it after recompress CREATE TABLE mytab_prep (time timestamptz, a int, b int, c int); SELECT create_hypertable('mytab_prep', 'time'); INSERT INTO mytab_prep VALUES ('2023-01-01'::timestamptz, 2, NULL, 2), ('2023-01-01'::timestamptz, 2, NULL, 2); alter table mytab_prep set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); PREPARE p1 AS SELECT * FROM mytab_prep ORDER BY a, c, time DESC; select show_chunks as chunk_to_compress_prep from show_chunks('mytab_prep') limit 1 \gset SELECT compress_chunk(:'chunk_to_compress_prep'); -- the output of the prepared plan would change before and after compress INSERT INTO mytab_prep VALUES ('2023-01-01'::timestamptz, 2, 3, 2); VACUUM ANALYZE mytab_prep; -- plan should be invalidated to return results from the uncompressed chunk also set enable_sort to off; /* penalize MergeAppend for predictable plans on PG < 17. */ EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; EXECUTE p1; reset enable_sort; -- check plan again after recompression SELECT compress_chunk(:'chunk_to_compress_prep'); VACUUM ANALYZE mytab_prep; EXPLAIN (BUFFERS OFF, COSTS OFF) EXECUTE p1; EXECUTE p1; -- verify segmentwise recompression when index exists, decompress + compress otherwise -- we verify by checking the compressed chunk after recompression in both cases. -- in the first case, it is the same before and after -- in the second case, a new compressed chunk is created CREATE TABLE mytab (time timestamptz, a int, b int, c int); SELECT create_hypertable('mytab', 'time'); INSERT INTO mytab VALUES ('2023-01-01'::timestamptz, 2, NULL, 2), ('2023-01-01'::timestamptz, 2, NULL, 2); select show_chunks as chunk_to_compress_mytab from show_chunks('mytab') limit 1 \gset -- index exists, recompression should happen segment by segment so expect a debug message alter table mytab set (timescaledb.compress, timescaledb.compress_segmentby = 'a, c'); select compress_chunk(show_chunks('mytab')); select compressed_chunk_name as compressed_chunk_name_before_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset INSERT INTO mytab VALUES ('2023-01-01'::timestamptz, 2, 3, 2); -- segmentwise recompression should not create a new compressed chunk, so verify compressed chunk is the same after recompression SELECT compress_chunk(:'chunk_to_compress_mytab'); select compressed_chunk_name as compressed_chunk_name_after_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset select :'compressed_chunk_name_before_recompression' as before_segmentwise_recompression, :'compressed_chunk_name_after_recompression' as after_segmentwise_recompression; INSERT INTO mytab SELECT t, a, 3, 2 FROM generate_series('2023-01-01'::timestamptz, '2023-01-02'::timestamptz, '1 hour'::interval) t CROSS JOIN generate_series(1, 10, 1) a; -- recompress will insert newly inserted tuples into compressed chunk along with inserting into the compressed chunk index SELECT compress_chunk(:'chunk_to_compress_mytab'); VACUUM ANALYZE mytab; -- make sure we are hitting the index and that the index contains the tuples SET enable_seqscan TO off; EXPLAIN (BUFFERS OFF, COSTS OFF) SELECT count(*) FROM mytab where a = 2; SELECT count(*) FROM mytab where a = 2; RESET enable_seqscan; SELECT decompress_chunk(show_chunks('mytab')); alter table mytab set (timescaledb.compress = false); alter table mytab set (timescaledb.compress); select compress_chunk(show_chunks('mytab')); select compressed_chunk_name as compressed_chunk_name_before_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset INSERT INTO mytab VALUES ('2023-01-01'::timestamptz, 2, 3, 2); -- expect to see same chunk after recompression SELECT compress_chunk(:'chunk_to_compress_mytab'); select compressed_chunk_name as compressed_chunk_name_after_recompression from compressed_chunk_info_view where hypertable_name = 'mytab' \gset select :'compressed_chunk_name_before_recompression' as before_recompression, :'compressed_chunk_name_after_recompression' as after_recompression; -- check behavior with NULL values in segmentby columns select '2022-01-01 09:00:00+00' as start_time \gset create table nullseg_one (time timestamptz, a int, b int); select create_hypertable('nullseg_one', 'time'); insert into nullseg_one values (:'start_time', 1, 1), (:'start_time', 1, 2), (:'start_time', 2,2), (:'start_time', 2,3); alter table nullseg_one set (timescaledb.compress, timescaledb.compress_segmentby= 'a'); select compress_chunk(show_chunks('nullseg_one')); insert into nullseg_one values (:'start_time', NULL, 4); select show_chunks as chunk_to_compress from show_chunks('nullseg_one') limit 1 \gset select compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name from compressed_chunk_info_view where hypertable_name = 'nullseg_one' \gset SELECT compress_chunk(:'chunk_to_compress'); select * from :compressed_chunk_name; -- insert again, check both index insertion works and NULL values properly handled insert into nullseg_one values (:'start_time', NULL, 4); SELECT compress_chunk(:'chunk_to_compress'); select * from :compressed_chunk_name; -- test multiple NULL segmentby columns create table nullseg_many (time timestamptz, a int, b int, c int); select create_hypertable('nullseg_many', 'time'); insert into nullseg_many values (:'start_time', 1, 1, 1), (:'start_time', 1, 2, 2), (:'start_time', 2,2, 2), (:'start_time', 2,3, 3), (:'start_time', 2, NULL, 3); alter table nullseg_many set (timescaledb.compress, timescaledb.compress_segmentby= 'a, c'); select compress_chunk(show_chunks('nullseg_many')); -- new segment (1, NULL) insert into nullseg_many values (:'start_time', 1, 4, NULL); select show_chunks as chunk_to_compress from show_chunks('nullseg_many') limit 1 \gset select compressed_chunk_schema || '.' || compressed_chunk_name as compressed_chunk_name from compressed_chunk_info_view where hypertable_name = 'nullseg_many' \gset SELECT compress_chunk(:'chunk_to_compress'); select * from :compressed_chunk_name; -- insert again, check both index insertion works and NULL values properly handled -- should match existing segment (1, NULL) insert into nullseg_many values (:'start_time', 1, NULL, NULL); SELECT compress_chunk(:'chunk_to_compress'); select * from :compressed_chunk_name; -- Test behaviour when no segmentby columns are present CREATE TABLE noseg(time timestamptz, a int, b int, c int); SELECT create_hypertable('noseg', by_range('time', INTERVAL '1 day')); ALTER TABLE noseg set (timescaledb.compress, timescaledb.compress_segmentby = ''); INSERT INTO noseg VALUES ('2025-01-24 09:54:27.323421-07'::timestamptz, 1, 1, 1); SELECT show_chunks as chunk_to_compress FROM show_chunks('noseg') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); INSERT INTO noseg VALUES ('2025-01-24 10:54:27.323421-07'::timestamptz, 1, 1, 2); -- should recompress chunk using the default index SELECT compress_chunk(:'chunk_to_compress'); -- Test behaviour when default order by is empty: should not segmentwise-recompress in this case CREATE TABLE no_oby(ts int, c1 int); SELECT create_hypertable('no_oby','ts'); \set VERBOSITY default ALTER TABLE no_oby SET (timescaledb.compress, timescaledb.compress_segmentby = 'ts'); \set VERBOSITY terse INSERT INTO no_oby (ts,c1) VALUES (6,6); SELECT show_chunks as chunk_to_compress FROM show_chunks('no_oby') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); INSERT INTO no_oby (ts,c1) VALUES (7,7); -- Direct segmentwise-recompress request: throw an error \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); \set ON_ERROR_STOP 1 -- Compress wrapper: do full recompress instead of by segment SELECT compress_chunk(:'chunk_to_compress'); RESET timescaledb.debug_compression_path_info; --- Test behaviour when enable_segmentwise_recompression GUC if OFF CREATE TABLE guc_test(time timestamptz not null, a int, b int, c int); SELECT create_hypertable('guc_test', by_range('time', INTERVAL '1 day')); ALTER TABLE guc_test set (timescaledb.compress, timescaledb.compress_segmentby = 'a, b'); INSERT INTO guc_test VALUES ('2024-10-30 14:04:00.501519-06'::timestamptz, 1, 1, 1); SELECT show_chunks as chunk_to_compress FROM show_chunks('guc_test') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); INSERT INTO guc_test VALUES ('2024-10-30 14:14:00.501519-06'::timestamptz, 1, 1, 2); -- When GUC is OFF, recompress function should throw an error SET timescaledb.enable_segmentwise_recompression TO OFF; \set ON_ERROR_STOP 0 SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); \set ON_ERROR_STOP 1 -- When GUC is OFF, entire chunk should be fully uncompressed and compressed instead SELECT compress_chunk(:'chunk_to_compress'); RESET timescaledb.enable_segmentwise_recompression; --- Test behaviour of enable_exclusive_locking_recompression GUC CREATE TABLE exclusive_test(time timestamptz not null, a int, b int, c int); SELECT create_hypertable('exclusive_test', by_range('time', INTERVAL '1 day')); ALTER TABLE guc_test set (timescaledb.compress, timescaledb.compress_segmentby = 'a, b'); INSERT INTO guc_test VALUES ('2024-10-30 14:04:00.501519-06'::timestamptz, 1, 1, 1); SELECT show_chunks as chunk_to_compress FROM show_chunks('guc_test') LIMIT 1 \gset SELECT compress_chunk(:'chunk_to_compress'); INSERT INTO guc_test VALUES ('2024-10-30 14:14:00.501519-06'::timestamptz, 1, 1, 2); -- Default behavior will try to get exclusive lock at the end of operation -- in order to change the chunk status. Here it will succeed since there -- isn't any concurrent operations. RESET timescaledb.enable_exclusive_locking_recompression; BEGIN; SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); SELECT c.relname FROM pg_locks l INNER JOIN pg_class c ON c.oid = l.relation WHERE locktype = 'relation' AND mode = 'ExclusiveLock' ORDER BY 1; ROLLBACK; -- If we enable this GUC, it should get exclusive locks on 3 relations: -- uncompressed chunk table, compressed chunk table, and compressed chunk index. -- This is done so that we keep locking consistency to legacy way of locking. SET timescaledb.enable_exclusive_locking_recompression TO ON; BEGIN; SELECT _timescaledb_functions.recompress_chunk_segmentwise(:'chunk_to_compress'); SELECT c.relname FROM pg_locks l INNER JOIN pg_class c ON c.oid = l.relation WHERE locktype = 'relation' AND mode = 'ExclusiveLock' ORDER BY 1; ROLLBACK; RESET timescaledb.enable_exclusive_locking_recompression; �������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/reorder.sql���������������������������������������������������������0000664�0000000�0000000�00000026235�15100345067�0020626�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \ir include/cluster_test_setup.sql BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- Show chunk indexes SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_1_chunk'); SELECT * FROM test.show_indexes('_timescaledb_internal._hyper_1_2_chunk'); \set ON_ERROR_STOP 0 -- cannot reorder a if with no index of the first call SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', verbose => TRUE); \set ON_ERROR_STOP 1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- reorder a chunk directly with an chunk index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', TRUE); BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- reorder a chunk without an index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', verbose => TRUE); BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- reorder a chunk directly with a hypertable index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', 'cluster_test_time_idx', TRUE); BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; \set ON_ERROR_STOP 0 -- other chunks in the hypertable are still not clustered SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); -- cannot cluster using another chunk's index SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', '_timescaledb_internal._hyper_1_1_chunk_cluster_test_time_idx', TRUE); -- cannot reorder a hypertable SELECT reorder_chunk('cluster_test', 'cluster_test_time_idx', TRUE); -- cannot reorder NULL SELECT reorder_chunk(NULL, verbose => TRUE); -- cannot reorder within a transaction BEGIN; SELECT reorder_chunk('_timescaledb_internal._hyper_1_2_chunk', verbose => TRUE); END; \set ON_ERROR_STOP 1 BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- reorder puts things in the correct order SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; -- can perform first reorder using a hypertable index (also test non-toast) SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', 'cluster_test_time_idx', verbose => TRUE); BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- and this sets the clustered index correctly SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); BEGIN; SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- reorder puts things in the correct order SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; SELECT ctid, time, temp, location, substring(value for 30), length(value) FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; -- can still use other index BEGIN; SET LOCAL enable_seqscan=false; SET LOCAL enable_indexscan=true; SET LOCAL enable_bitmapscan=false; EXPLAIN (buffers off, costs off) SELECT * FROM cluster_test WHERE location < 6; SELECT time, temp, location, substring(value for 30), length(value) FROM cluster_test where location < 6 ORDER BY time; COMMIT; -- drop toast column ALTER TABLE cluster_test DROP COLUMN value; ALTER TABLE expected DROP COLUMN value; BEGIN; SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); BEGIN; SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; -- reorder puts things in the correct order SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY ctid; SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY ctid; -- force an indexscan SET enable_seqscan=false; SET enable_indexscan=true; SET enable_bitmapscan=false; SELECT reorder_chunk('_timescaledb_internal._hyper_1_1_chunk', verbose => TRUE); BEGIN; SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', seqscan => true) \gexec SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', indexscan => true) \gexec SELECT * FROM ensure_scans_work_no_val('cluster_test', should_output => 'expected', bitmapscan => true) \gexec COMMIT; SET enable_seqscan=Default; SET enable_indexscan=Default; SET enable_bitmapscan=Default; -- reorder puts things in the correct order SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_1_chunk ORDER BY time; SELECT ctid, time, temp, location FROM _timescaledb_internal._hyper_1_2_chunk ORDER BY time; CREATE TABLE ct2(time INTEGER, val BIGINT); SELECT create_hypertable('ct2', 'time', chunk_time_interval => 5); INSERT INTO ct2 VALUES (10, 0), ( 2, 12), ( 0, 10), (14, 4), (11, 1), (12, 2), ( 3, 13), ( 1, 11), ( 4, 14), (13, 13); select show_chunks('ct2'); -- if we use someone elses index error \set ON_ERROR_STOP 0 SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', 'cluster_test_time_idx', verbose => TRUE); SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', '_timescaledb_internal._hyper_1_2_chunk_cluster_test_time_idx', verbose => TRUE); \set ON_ERROR_STOP 1 -- if the hypertable has a CLUSTERed index we can use it CLUSTER ct2 USING ct2_time_idx; SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); -- if we drop a CLUSTERed index we still fail correctly DROP INDEX ct2_time_idx; \set ON_ERROR_STOP 0 SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); \set ON_ERROR_STOP 1 -- but re-create for future tests CREATE INDEX ct2_time_idx ON ct2(time DESC); CLUSTER ct2 USING ct2_time_idx; -- deleted chunks are removed correctly DELETE FROM ct2 where time < 2 OR val < 2; VACUUM ct2; SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_3_chunk ORDER BY time; SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_4_chunk ORDER BY time; -- There's a special case when a tuple is deleted, but that deletion isn't committed -- But we disallow reorder within transactions for now, if we enable it, we should -- enable the test -- BEGIN; -- DELETE FROM ct2 where time = 2 OR val = 2; -- SELECT reorder_chunk('_timescaledb_internal._hyper_2_4_chunk', verbose => TRUE); -- COMMIT; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_3_chunk ORDER BY time; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_4_chunk ORDER BY time; -- There's a special case when a tuple is inserted earlier in the same txn -- NOTE: this reorder vaccums the one deleted in the previous test -- But we disallow reorder within transactions for now, if we enable it, we should -- enable the test -- BEGIN; -- INSERT INTO ct2 VALUES (12, 2), ( 2, 12); -- SELECT reorder_chunk('_timescaledb_internal._hyper_2_4_chunk', verbose => TRUE); -- COMMIT; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_3_chunk ORDER BY time; -- SELECT ctid, time, val FROM _timescaledb_internal._hyper_2_4_chunk ORDER BY time; SELECT indexrelid::regclass, indisclustered FROM pg_index WHERE indisclustered = true ORDER BY 1; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 SELECT reorder_chunk('_timescaledb_internal._hyper_2_3_chunk', verbose => TRUE); \set ON_ERROR_STOP 1 -- #3651 incorrect index attribute mapping in reorder_chunk CREATE TABLE i3651(c1 timestamptz NOT NULL,c2 text, c3 text, c4 text); SELECT table_name FROM create_hypertable('i3651','c1'); ALTER TABLE i3651 drop column c2; CREATE UNIQUE INDEX i3651_attmap ON i3651(c1,c4); INSERT INTO i3651 VALUES('2000-01-01','foo','foo'),('2000-01-01','foo','bar'); SELECT reorder_chunk(chunk,'i3651_attmap') from show_chunks('i3651') chunk; -- test error handling when trying to create on internal hypertable CREATE TABLE comp_ht_test(time timestamptz NOT NULL); SELECT table_name FROM create_hypertable('comp_ht_test','time'); ALTER TABLE comp_ht_test SET (timescaledb.compress); SELECT format('%I.%I', ht.schema_name, ht.table_name) AS "INTERNALTABLE" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable uncompress ON (ht.id = uncompress.compressed_hypertable_id AND uncompress.table_name = 'comp_ht_test') \gset \c :TEST_DBNAME :ROLE_SUPERUSER \set ON_ERROR_STOP 0 SELECT add_reorder_policy(:'INTERNALTABLE','internal_idx'); \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/scheduler_fixed.sql�������������������������������������������������0000664�0000000�0000000�00000016444�15100345067�0022322�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- -- Setup for testing bgw jobs --- -- \c :TEST_DBNAME :ROLE_SUPERUSER CREATE OR REPLACE FUNCTION ts_test_next_scheduled_execution_slot(schedule_interval INTERVAL, finish_time TIMESTAMPTZ, initial_start TIMESTAMPTZ, timezone TEXT = NULL) RETURNS TIMESTAMPTZ AS :MODULE_PATHNAME LANGUAGE C VOLATILE; -- follow exactly cagg_bgw_drop_chunks -- Remove any default jobs, e.g., telemetry DELETE FROM _timescaledb_config.bgw_job; TRUNCATE _timescaledb_internal.bgw_job_stat; create or replace procedure job_20(jobid int, config jsonb) language plpgsql as $$ begin perform pg_sleep(5); end $$; create or replace procedure job_5(jobid int, config jsonb) language plpgsql as $$ begin perform pg_sleep(1); end $$; select * from _timescaledb_internal.bgw_job_stat; -- add job that has a runtime well under the schedule interval select now() as initial_start \gset select add_job('job_5', schedule_interval => INTERVAL '15 seconds', initial_start => :'initial_start'::timestamptz) as short_job_fixed \gset select add_job('job_5', schedule_interval => INTERVAL '15 seconds', initial_start => :'initial_start'::timestamptz, fixed_schedule => false) as short_job_drifting \gset SELECT _timescaledb_functions.start_background_workers(); select initial_start as initial_start_given from timescaledb_information.jobs where job_id = :short_job_fixed \gset -- wait for the job to run SELECT test.wait_for_job_to_run(:short_job_fixed, 1); SELECT test.wait_for_job_to_run(:short_job_drifting, 1); -- select ts_bgw_db_scheduler_test_run_and_wait_for_scheduler_finish(15000); select next_start as next_start_short from timescaledb_information.job_stats where job_id = :short_job_fixed \gset -- verify the next_start is 15 seconds after the initial_start for the fixed schedule job select :'next_start_short'::timestamptz - :'initial_start_given'::timestamptz as schedule_diff; -- test job that runs for longer than the schedule interval select add_job('job_20', schedule_interval => INTERVAL '15 seconds', initial_start => now()) as long_job_fixed \gset select test.wait_for_job_to_run(:long_job_fixed, 1); select initial_start as initial_start_long from timescaledb_information.jobs where job_id = :long_job_fixed \gset select next_start as next_start_long from timescaledb_information.job_stats where job_id = :long_job_fixed \gset select :'next_start_long'::timestamptz - :'initial_start_long'::timestamptz as schedule_diff; -- test some possible schedule_interval, finish_time, initial_start combinations SET timezone = 'UTC'; -- want to execute on the 15th of the month select ts_test_next_scheduled_execution_slot('1 month', '2022-09-16 13:21:34+00'::timestamptz, '2022-09-15 19:00:00+00'::timestamptz); -- ..or the first of the month select ts_test_next_scheduled_execution_slot('1 month', '2022-09-01 19:21:34+00'::timestamptz, '2022-09-01 19:00:00+00'::timestamptz); -- want to execute on Sundays (2022-09-04 is a Sunday) select extract(dow from date '2022-09-04') = 0; select ts_test_next_scheduled_execution_slot('1 week', '2022-09-22 13:21:34+00'::timestamptz, '2022-09-04 19:00:00+00'::timestamptz); -- want to execute at 6am every day select ts_test_next_scheduled_execution_slot('1d', '2022-09-21 13:21:34+00'::timestamptz, '2022-09-21 06:00:00+00'::timestamptz); -- test what happens across DST -- go from +1 to +2 set timezone to 'Europe/Berlin'; -- DST switch on March 27th 2022 select ts_test_next_scheduled_execution_slot('1 week', '2022-03-23 09:21:34 CET'::timestamptz, '2022-03-23 09:00:00 CET'::timestamptz) as t1 \gset select ts_test_next_scheduled_execution_slot('1 week', '2022-03-23 09:21:34 CET'::timestamptz, '2022-03-23 09:00:00 CET'::timestamptz, timezone => 'Europe/Berlin') as t1_tz \gset select :'t1' as without_timezone, :'t1_tz' as with_timezone; select ts_test_next_scheduled_execution_slot('1 week', :'t1'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz) as t2 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t1_tz'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz, timezone => 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; select ts_test_next_scheduled_execution_slot('1 week', :'t2'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz) as t3 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t2_tz'::timestamptz, '2022-03-23 09:00:00+01'::timestamptz, timezone => 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; -- go from +2 to +1 -- DST switch on October 30th 2022 select ts_test_next_scheduled_execution_slot('1 week', '2022-10-29 09:21:34+02'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz) as t1 \gset select ts_test_next_scheduled_execution_slot('1 week', '2022-10-29 09:21:34+02'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz, 'Europe/Berlin') as t1_tz \gset select :'t1' as without_timezone, :'t1_tz' as with_timezone; select ts_test_next_scheduled_execution_slot('1 week', :'t1'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz) as t2 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t1_tz'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz, 'Europe/Berlin') as t2_tz \gset select :'t2' as without_timezone, :'t2_tz' as with_timezone; select ts_test_next_scheduled_execution_slot('1 week', :'t2'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz) as t3 \gset select ts_test_next_scheduled_execution_slot('1 week', :'t2_tz'::timestamptz, '2022-10-29 09:00:00+02'::timestamptz, 'Europe/Berlin') as t3_tz \gset select :'t3' as without_timezone, :'t3_tz' as with_timezone; \set ON_ERROR_STOP 0 -- test some unacceptable values for schedule interval select add_job('job_5', schedule_interval => interval '1 month 1week', initial_start => :'initial_start'::timestamptz); \set client_min_messages = DEBUG; select '2023-01-02 11:53:19.059771+02'::timestamptz as finish_time \gset -- years select ts_test_next_scheduled_execution_slot('1 year', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); select ts_test_next_scheduled_execution_slot('2 year', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); select ts_test_next_scheduled_execution_slot('10 year', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); -- weeks select ts_test_next_scheduled_execution_slot('1 week', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); select ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); select ts_test_next_scheduled_execution_slot('2 week', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); -- months select ts_test_next_scheduled_execution_slot('10 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); select ts_test_next_scheduled_execution_slot('10 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec', 'Europe/Athens'); select ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec'); select ts_test_next_scheduled_execution_slot('2 month', :'finish_time'::timestamptz, :'finish_time'::timestamptz - interval '3 sec', 'Europe/Athens'); ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/size_utils_tsl.sql��������������������������������������������������0000664�0000000�0000000�00000003746�15100345067�0022242�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. SET timezone TO 'America/Los_Angeles'; -- Prepare test data for continuous aggregate size function tests CREATE TABLE hypersize(time timestamptz, device int); SELECT * FROM create_hypertable('hypersize', 'time'); INSERT INTO hypersize VALUES('2021-02-25', 1); -- Test size functions on empty continuous aggregate CREATE MATERIALIZED VIEW hypersize_cagg WITH (timescaledb.continuous) AS SELECT time_bucket('1 day', "time") AS bucket, AVG(device) AS value FROM hypersize GROUP BY 1 WITH NO DATA; SELECT format('%I.%I', h.schema_name, h.table_name) AS "MAT_HYPERTABLE_NAME" FROM _timescaledb_catalog.continuous_agg ca INNER JOIN _timescaledb_catalog.hypertable h ON(h.id = ca.mat_hypertable_id) WHERE user_view_name = 'hypersize_cagg' \gset SELECT * FROM hypertable_size(:'MAT_HYPERTABLE_NAME'); SELECT * FROM hypertable_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; SELECT * FROM chunks_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; SELECT * FROM hypertable_size('hypersize_cagg'); SELECT * FROM hypertable_detailed_size('hypersize_cagg') ORDER BY node_name; SELECT * FROM chunks_detailed_size('hypersize_cagg') ORDER BY node_name; SELECT * FROM approximate_row_count('hypersize_cagg'); -- Test size functions on non-empty countinuous aggregate CALL refresh_continuous_aggregate('hypersize_cagg', NULL, NULL); SELECT * FROM hypertable_size('hypersize_cagg'); SELECT * FROM hypertable_detailed_size('hypersize_cagg') ORDER BY node_name; SELECT * FROM chunks_detailed_size('hypersize_cagg') ORDER BY node_name; SELECT * FROM hypertable_size(:'MAT_HYPERTABLE_NAME'); SELECT * FROM hypertable_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; SELECT * FROM chunks_detailed_size(:'MAT_HYPERTABLE_NAME') ORDER BY node_name; ANALYZE :MAT_HYPERTABLE_NAME; SELECT * FROM approximate_row_count('hypersize_cagg'); ��������������������������timescaledb-2.23.0/tsl/test/sql/skip_scan.sql�������������������������������������������������������0000664�0000000�0000000�00000010014�15100345067�0021122�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to adjust statistics in load script \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME skip_scan SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_multi_load.sql', :'TEST_BASE_NAME') AS "TEST_MULTI_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNOPTIMIZED", format('%s/results/%s_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- run tests on normal table and diff results \set TABLE skip_scan \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_skipscan; -- compare SkipScan results on normal table :DIFF_CMD -- run tests on hypertable and diff results \set TABLE skip_scan_ht \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD -- run tests on compressed hypertable with different compression settings and diff results SELECT format('include/%s_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htc \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on compressed hypertable :DIFF_CMD -- run tests on compressed hypertable with different layouts of compressed chunks SELECT format('include/%s_load_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htcl \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on compressed hypertable :DIFF_CMD -- run tests on compressed hypertable with different layouts of compressed chunks SELECT format('include/%s_multi_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset -- run multikey SkipScan tests \ir :TEST_MULTI_LOAD_NAME \set PREFIX '' -- make sure multikey SkipScan results are correct \set TABLE mskip_scan \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_multikey_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_multikey_skipscan; -- compare SkipScan results on table :DIFF_CMD \set TABLE mskip_scan_ht \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_multikey_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_multikey_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD \set TABLE mskip_scan_htc \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_multikey_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_multikey_skipscan; -- compare SkipScan results on compressed hypertable :DIFF_CMD -- make sure multikey SkipScan is applied correctly SET timescaledb.debug_skip_scan_info TO true; \set TABLE mskip_scan \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o \set TABLE mskip_scan_ht \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o \set TABLE mskip_scan_htc \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.debug_skip_scan_info; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/skip_scan_dagg.sql��������������������������������������������������0000664�0000000�0000000�00000005021�15100345067�0022106�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- need superuser to adjust statistics in load script \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER \set TEST_BASE_NAME skip_scan SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_dagg_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_dagg_results_unoptimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNOPTIMIZED", format('%s/results/%s_dagg_results_optimized.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_OPTIMIZED" \gset SELECT format('\! diff -u --label "Unoptimized results" --label "Optimized results" %s %s', :'TEST_RESULTS_UNOPTIMIZED', :'TEST_RESULTS_OPTIMIZED') AS "DIFF_CMD" \gset \ir :TEST_LOAD_NAME -- run tests on normal table and diff results \set TABLE skip_scan \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_skipscan_for_distinct_aggregates TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_skipscan_for_distinct_aggregates; -- compare SkipScan results on normal table :DIFF_CMD -- run tests on hypertable and diff results \set TABLE skip_scan_ht \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_skipscan_for_distinct_aggregates TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_skipscan_for_distinct_aggregates; -- compare SkipScan results on hypertable :DIFF_CMD -- run tests on compressed hypertable and diff results SELECT format('include/%s_dagg_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htc \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD -- run tests on compressed hypertable with different layouts of compressed chunks SELECT format('include/%s_dagg_load_comp_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME" \gset \set TABLE skip_scan_htcl \set PREFIX '' \o :TEST_RESULTS_OPTIMIZED \ir :TEST_QUERY_NAME \o SET timescaledb.enable_compressed_skipscan TO false; \o :TEST_RESULTS_UNOPTIMIZED \ir :TEST_QUERY_NAME \o RESET timescaledb.enable_compressed_skipscan; -- compare SkipScan results on hypertable :DIFF_CMD ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/split_chunk.sql�����������������������������������������������������0000664�0000000�0000000�00000070400�15100345067�0021500�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER CREATE ACCESS METHOD testam TYPE TABLE HANDLER heap_tableam_handler; set role :ROLE_DEFAULT_PERM_USER; -- Test utility wrapper around split_chunk() to validate the split. It -- automatically performs some basic checks to validate that the split -- is OK. create or replace procedure split_chunk_validate(chunk regclass, split_at timestamptz = null) as $$ declare chunk_stats_before _timescaledb_catalog.compression_chunk_size; uncompressed_heap_size_sum bigint; compressed_heap_size_sum bigint; hypertable regclass; new_chunk regclass; children regclass[]; stats_are_equal boolean; count_before bigint; count_after1 bigint; count_after2 bigint; chunk_reltuples float8; new_chunk_reltuples float8; begin -- Get the chunk size stats if compressed or it will be null select * into chunk_stats_before from _timescaledb_catalog.compression_chunk_size ccs join _timescaledb_catalog.chunk c on (c.id = ccs.chunk_id) join pg_class cl on (cl.relname = c.table_name) join pg_namespace ns on (ns.oid = cl.relnamespace and c.schema_name = ns.nspname) where cl.oid = chunk; -- Compare chunk children before and after split to get new chunk select inhparent into hypertable from pg_inherits where inhrelid = chunk; select array_agg(inhrelid) into children from pg_inherits where inhparent = hypertable; execute format('select count(*) from %s ch', chunk) into count_before; call split_chunk(chunk, split_at); with arr_diff as ( select inhrelid as rel from pg_inherits where inhparent = hypertable except select unnest(children) ) select rel into new_chunk from arr_diff; -- Add up the counts for the two result chunks. Would normally do -- a UNION ALL query across the two chunks but it doesn't work for -- compressed chunks. execute format('select count(*) from %s ch', chunk) into count_after1; execute format('select count(*) from %s ch', new_chunk) into count_after2; if count_before != (count_after1 + count_after2) then raise exception 'count before split is different from count after: % vs % (% + %)', count_before, count_after1 + count_after2, count_after1, count_after2; end if; execute format('select reltuples from pg_class where oid=%s', chunk::oid) into chunk_reltuples; execute format('select reltuples from pg_class where oid=%s', new_chunk::oid) into new_chunk_reltuples; raise notice 'chunks after split are % (reltuples %) and % (reltuples %)', chunk, chunk_reltuples, new_chunk, new_chunk_reltuples; if chunk_stats_before is not null then select sum(uncompressed_heap_size), sum(compressed_heap_size) into uncompressed_heap_size_sum, compressed_heap_size_sum from _timescaledb_catalog.compression_chunk_size ccs join _timescaledb_catalog.chunk c on (c.id = ccs.chunk_id) join pg_class cl on (cl.relname = c.table_name) where cl.oid in (chunk, new_chunk); if chunk_stats_before.uncompressed_heap_size = uncompressed_heap_size_sum and chunk_stats_before.compressed_heap_size = compressed_heap_size_sum then raise notice 'compression size stats are OK'; else raise exception 'compression size stats are different after split: ' 'uncompressed size % vs % and compressed size % vs %', chunk_stats_before.uncompressed_heap_size, uncompressed_heap_size_sum, chunk_stats_before.compressed_heap_size, compressed_heap_size_sum; end if; end if; end; $$ language plpgsql; create view chunk_slices as select h.table_name as hypertable_name, c.table_name as chunk_name, _timescaledb_functions.to_timestamp(ds.range_start) as range_start, _timescaledb_functions.to_timestamp(ds.range_end) as range_end from _timescaledb_catalog.chunk c join _timescaledb_catalog.chunk_constraint cc on (cc.chunk_id = c.id) join _timescaledb_catalog.dimension_slice ds on (ds.id = cc.dimension_slice_id) join _timescaledb_catalog.hypertable h on (h.id = c.hypertable_id) order by range_start, range_end; create table splitme (time timestamptz not null, device int, location int, temp float, comment text); select create_hypertable('splitme', 'time', chunk_time_interval => interval '1 week', create_default_indexes => false); alter table splitme set (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='device'); -- Create information view for test create view chunk_info as select relname as chunk, amname as tam, reltuples, con.conname, pg_get_expr(conbin, ch) checkconstraint from pg_class cl join pg_am am on (cl.relam = am.oid) join show_chunks('splitme') ch on (cl.oid = ch) join pg_constraint con on (con.conrelid = ch) where con.contype = 'c' order by 1,2,3 desc; -- -- Insert data to create two chunks with time ranges like this: -- _____________ -- | | | -- | 1 | 2 | -- |_____|_____| --- --- Make sure we have a long text value to create toast table insert into splitme values ('2024-01-03 22:00', 1, 1, 1.0, 'foo'), ('2024-01-09 15:00', 1, 2, 2.0, 'barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar'); -- Remove a column to ensure that split can handle it alter table splitme drop column location; -- All data in single chunk select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; select time, device, temp from _timescaledb_internal._hyper_1_1_chunk order by time; select * from chunk_slices where hypertable_name = 'splitme'; \set ON_ERROR_STOP 0 call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 1); call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 1::int); call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => '2024-01-04 00:00'::timestamp); -- Split at start of chunk range call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 'Wed Jan 03 16:00:00 2024 PST'); -- Split at end of chunk range call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => 'Wed Jan 10 16:00:00 2024 PST'); -- Split at multiple points. Not supported yet. call split_chunk('_timescaledb_internal._hyper_1_1_chunk', split_at => '{ 2024-01-04 10:00, 2024-01-07 12:00 }'::timestamptz[]); -- Try to split something which is not a chunk call split_chunk('splitme'); -- Split a chunk with unsupported access method alter table _timescaledb_internal._hyper_1_1_chunk set access method testam; call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); alter table _timescaledb_internal._hyper_1_1_chunk set access method heap; -- Split an OSM chunk is not supported reset role; update _timescaledb_catalog.chunk ch set osm_chunk = true where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); reset role; update _timescaledb_catalog.chunk ch set osm_chunk = false where table_name = '_hyper_1_1_chunk'; set role :ROLE_DEFAULT_PERM_USER; -- Split a frozen chunk is not supported select _timescaledb_functions.freeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); select _timescaledb_functions.unfreeze_chunk('_timescaledb_internal._hyper_1_1_chunk'); -- Split by non-owner is not allowed set role :ROLE_1; call split_chunk('_timescaledb_internal._hyper_1_1_chunk'); set role :ROLE_DEFAULT_PERM_USER; \set ON_ERROR_STOP 1 select * from chunk_info; call split_chunk_validate('_timescaledb_internal._hyper_1_1_chunk', split_at => '2024-01-04 00:00'); select * from chunk_info; select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; select * from chunk_slices where hypertable_name = 'splitme'; -- Show that the two tuples ended up in different chunks select time, device, temp from _timescaledb_internal._hyper_1_1_chunk order by time; select time, device, temp from _timescaledb_internal._hyper_1_2_chunk order by time; select setseed(0.2); -- Test split with bigger data set and chunks with more blocks insert into splitme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-03 23:00'::timestamptz, '2024-01-09 01:00:00 PST', '10s') t; select count(*) from splitme; -- Add back location just to make things more difficult alter table splitme add column location int default 1; -- Update stats vacuum analyze splitme; -- There are two space partitions (device), so several chunks will -- have the same time ranges select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; -- Split chunk 2. Save count to compare after split. select count(*) from _timescaledb_internal._hyper_1_2_chunk; select count(*) orig_count from _timescaledb_internal._hyper_1_2_chunk \gset -- Generate some garbage so that we can see that it gets cleaned up -- during split update _timescaledb_internal._hyper_1_2_chunk set temp = temp+1 where temp > 10; -- Add an index create index on splitme (time); -- Generate a garbage tuple insert into _timescaledb_internal._hyper_1_2_chunk (time, device, location, temp) values ('2024-01-04 23:00', 1, 1, 1.12); delete from _timescaledb_internal._hyper_1_2_chunk where time = '2024-01-04 23:00' and device = 1 and location = 1; -- This will split in two equal size chunks select * from chunk_info; call split_chunk_validate('_timescaledb_internal._hyper_1_2_chunk'); select * from chunk_info; select chunk_name, range_start, range_end from timescaledb_information.chunks order by chunk_name, range_start, range_end; -- Check that the counts in the two result partitions is the same as -- in the original partition and that the tuple counts are roughly the -- same across the partitions. with counts as ( select (select count(*) from _timescaledb_internal._hyper_1_2_chunk) count1, (select count(*) from _timescaledb_internal._hyper_1_3_chunk) count2 ) select c.count1, c.count2, c.count1 + c.count2 as total_count, (c.count1 + c.count2) = :orig_count as is_same_count from counts c; -- Check that both rels return proper data and no columns are messed -- up select time, device, location, temp from _timescaledb_internal._hyper_1_2_chunk order by time, device limit 3; select time, device, location, temp from _timescaledb_internal._hyper_1_3_chunk order by time, device limit 3; -- -- Test split with integer time -- create table splitme_int (time int not null, device int, temp float); select create_hypertable('splitme_int', 'time', chunk_time_interval => 10::int); insert into splitme_int values (1, 1, 1.0), (8, 8, 8.0); select ch as int_chunk from show_chunks('splitme_int') ch order by ch limit 1 \gset select * from chunk_slices where hypertable_name = 'splitme_int'; \set ON_ERROR_STOP 0 call split_chunk(:'int_chunk', split_at => 0); call split_chunk(:'int_chunk', split_at => 10); \set ON_ERROR_STOP 1 call split_chunk(:'int_chunk', split_at => '5'); select * from chunk_slices where hypertable_name = 'splitme_int'; select * from :int_chunk order by time; select * from splitme_int order by time; -- Split with one empty chunk call split_chunk(:'int_chunk', split_at => 3); select * from chunk_slices where hypertable_name = 'splitme_int'; select * from :int_chunk order by time; select ch as int_chunk from show_chunks('splitme_int') ch order by ch limit 1 offset 2 \gset \echo :int_chunk select * from :int_chunk order by time; -- Insert data into the empty chunk insert into splitme_int values (4, 4, 4.0); select * from :int_chunk order by time; -- -- Try with more data after split -- -- Remove comment column to generate dropped column alter table splitme drop column comment; select * from chunk_info; \c :TEST_DBNAME :ROLE_SUPERUSER set role :ROLE_DEFAULT_PERM_USER; select setseed(0.2); select * from chunk_slices where hypertable_name = 'splitme'; insert into splitme (time, device, location, temp) select t, ceil(random()*10), ceil(random()*20), random()*40 from generate_series('2024-01-03'::timestamptz, '2024-01-09 01:00:00 PST', '10s') t; -- Make sure stats are up-to-date before split vacuum analyze splitme; select * from chunk_info; call split_chunk_validate('_timescaledb_internal._hyper_1_2_chunk'); select * from chunk_info; -- -- Test multi-dimensional hypertable -- -- Currently not supported because the subspace cache cannot handle -- tuple routing when there are two overlapping primary dimension -- ranges. This can happen when the "time" range is split in one space -- partition but not the other. -- create table splitme_md (time timestamptz not null, device int, location int, temp float); select create_hypertable('splitme_md', 'time', 'device', 2, chunk_time_interval => interval '1 week'); insert into splitme_md values ('2024-01-03 22:00', 1, 1, 1.0), ('2024-01-09 14:00', 1, 2, 2.0); select ch as chunk_md from show_chunks('splitme_md') ch limit 1 \gset select * from chunk_slices where hypertable_name = 'splitme_md'; \set ON_ERROR_STOP 0 -- Currently can't split multi-dimensional chunks due to bug/limitation in subspace store. call split_chunk_validate(:'chunk_md'); \set ON_ERROR_STOP 1 -- Split when insert in progress begin; insert into splitme values ('2024-01-04 22:00', 20, 20, 20.0); call split_chunk_validate('_timescaledb_internal._hyper_1_1_chunk'); rollback; -- Split when delete in progress begin; delete from splitme where device = 1; call split_chunk_validate('_timescaledb_internal._hyper_1_1_chunk'); rollback; ------------------------------------------- ------------------------------------------- --- Split a compressed/columnstore chunk ------------------------------------------- ------------------------------------------- -- Convert one chunk to columnstore call convert_to_columnstore('_timescaledb_internal._hyper_1_2_chunk'); -- Compute aggregations to compare with after split create table chunk_summary_before_split as select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_2_chunk; -- Split the columnstore chunk, fully compressed select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_2_chunk'::regclass \gset -- All data should be in the (internal) compressed chunk select count(*) from only _timescaledb_internal._hyper_1_2_chunk; select count(*) from :compress_relid; -- Use split point Thu Jan 04 13:40:30 2024 PST which should be within -- some segments select 'Thu Jan 04 13:40:30 2024 PST'::timestamptz as split_point \gset select _ts_meta_count, device, _ts_meta_min_1, _ts_meta_max_1 from :compress_relid where _ts_meta_min_1 <= :'split_point' and _ts_meta_max_1 >= :'split_point'; call split_chunk_validate('_timescaledb_internal._hyper_1_2_chunk', split_at => :'split_point'); select * from chunk_info; select * from chunk_slices where hypertable_name = 'splitme'; select show_chunks('splitme'); -- Still no data in non-compressed relations after split. select * from only _timescaledb_internal._hyper_1_2_chunk; select * from only _timescaledb_internal._hyper_1_13_chunk; -- Show how compressed segments are split across the resulting -- compressed chunks select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_2_chunk'::regclass \gset select _ts_meta_count, device, _ts_meta_min_1, _ts_meta_max_1 from :compress_relid; select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_13_chunk'::regclass \gset select _ts_meta_count, device, _ts_meta_min_1, _ts_meta_max_1 from :compress_relid; -- Would normally do a UNION ALL between the chunks, but it is broken -- on compressed chunks create table chunk_data_after_split as select * from _timescaledb_internal._hyper_1_2_chunk; insert into chunk_data_after_split select * from _timescaledb_internal._hyper_1_13_chunk; -- All data should be compressed so these queries should not return -- anything select * from only _timescaledb_internal._hyper_1_2_chunk; select * from only _timescaledb_internal._hyper_1_13_chunk; create table chunk_summary_after_split as select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from chunk_data_after_split; select * from chunk_summary_before_split; select * from chunk_summary_after_split; -- Split a columnstore chunk CALL convert_to_columnstore('_timescaledb_internal._hyper_1_3_chunk'); -- Add some non-compressed data. One tuple in each partition after -- split. insert into _timescaledb_internal._hyper_1_3_chunk values ('2024-01-07 09:03:11', 1, 21, 21.0), ('2024-01-10 02:04:12', 1, 17, 32.0); select * from ONLY _timescaledb_internal._hyper_1_3_chunk order by time; select table_name, dropped, status, compressed_chunk_id from _timescaledb_catalog.chunk where table_name = '_hyper_1_3_chunk'; truncate chunk_summary_before_split; insert into chunk_summary_before_split select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_3_chunk; select * from chunk_summary_before_split; select * from chunk_info; call split_chunk('_timescaledb_internal._hyper_1_3_chunk'); -- Check that the resulting chunks look OK and have the right access method select * from chunk_info; select table_name, dropped, status, compressed_chunk_id from _timescaledb_catalog.chunk where table_name in ('_hyper_1_3_chunk', '_hyper_1_16_chunk'); -- Check that the non-compressed data rows ended up in separate partitions select * from ONLY _timescaledb_internal._hyper_1_3_chunk order by time; select * from ONLY _timescaledb_internal._hyper_1_16_chunk order by time; -- Show aggregate summary. Should be equal to summary before split truncate chunk_data_after_split; insert into chunk_data_after_split select * from _timescaledb_internal._hyper_1_3_chunk; insert into chunk_data_after_split select * from _timescaledb_internal._hyper_1_16_chunk; truncate chunk_summary_after_split; insert into chunk_summary_after_split select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from chunk_data_after_split; -- Compare summaries before and after split select * from chunk_summary_before_split; select * from chunk_summary_after_split; -- Show the summary for each new chunk select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_3_chunk; select count(*), sum(device) as device_sum, sum(location) as location_sum, round(sum(temp)::numeric, 5) as temp_sum from _timescaledb_internal._hyper_1_16_chunk; select chunk_name, range_start, range_end, is_compressed from timescaledb_information.chunks where hypertable_name = 'splitme' order by chunk_name, range_start, range_end; select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_16_chunk'::regclass \gset select count(*) from :compress_relid; -------------------------------------------------------------------- -------------------------------------------------------------------- -- Split compressed chunk in a way that leaves no compressed data in -- one of the chunks -------------------------------------------------------------------- -------------------------------------------------------------------- call convert_to_columnstore('_timescaledb_internal._hyper_1_8_chunk'); select max(time) as split_point from _timescaledb_internal._hyper_1_8_chunk \gset select :'split_point'; call split_chunk_validate('_timescaledb_internal._hyper_1_8_chunk', split_at => :'split_point'::timestamptz + interval '1 second'); -- -- Show new chunk ranges. Note that, because the original chunk was -- compressed, both result chunks are also "compressed" even though -- one of them has no compressed data. -- -- The chunk without compressed data could have been marked -- "uncompressed" and the compressed relation removed. But this is not -- how things work currently. -- select chunk_name, range_start, range_end, is_compressed from timescaledb_information.chunks where hypertable_name = 'splitme' order by chunk_name, range_start, range_end; select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_8_chunk'::regclass \gset select count(*) from :compress_relid; select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_19_chunk'::regclass \gset select count(*) from :compress_relid; select count(*) from _timescaledb_internal._hyper_1_8_chunk; select count(*) from _timescaledb_internal._hyper_1_19_chunk; -------------------------------------------------------------------- -------------------------------------------------------------------- --- Test split points at time min and max values of compressed --- segment. We'd like to check that these values end up in the --- "right" result chunk after split. The split point should end up in --- the "right" result chunk, i.e., it should be a min value in a new --- segment. -------------------------------------------------------------------- -------------------------------------------------------------------- select compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_13_chunk'::regclass \gset select sum(_ts_meta_count) as original_count_sum from :compress_relid \gset select _ts_meta_count as meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max, _ts_meta_min_1 as split_point_min, _ts_meta_max_1 as split_point_max from :compress_relid order by meta_min limit 1 offset 2 \gset -- Show metadata from the segment to be split. There might be other -- segments split too, but we are only intrested in this one segment -- for the test. select :'meta_count' as meta_count, :'split_point_min' as split_point_min, :'split_point_max' as split_point_max; -- Split with a split point at min value call split_chunk_validate('_timescaledb_internal._hyper_1_13_chunk', split_at => :'split_point_min'); select compress_relid as compress_relid2 from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_21_chunk'::regclass \gset -- The segment should remain intact, and be completely in the "new" -- chunk (to the "right side" of the split) select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid where _ts_meta_min_1 = :'split_point_min' and _ts_meta_count = :'meta_count' order by meta_min; select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid2 where _ts_meta_min_1 = :'split_point_min' and _ts_meta_count = :'meta_count' order by meta_min; -- The sum of the counts should match up with the original sum before -- split select :'original_count_sum' = ((select sum(_ts_meta_count) from :compress_relid) + (select sum(_ts_meta_count) from :compress_relid2)); -- Use a split point at end of a segment (its max value). The segment -- should be split with the max value ending up as the only value in a -- new segment to the "right side" of the split (i.e., in the new -- chunk) select sum(_ts_meta_count) as original_count_sum from :compress_relid2 \gset call split_chunk_validate('_timescaledb_internal._hyper_1_21_chunk', split_at => :'split_point_max'); select compress_relid as compress_relid3 from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_23_chunk'::regclass \gset select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid2 where _ts_meta_min_1 = :'split_point_min' and _ts_meta_count = (:'meta_count' - 1) order by meta_min; select _ts_meta_count, _ts_meta_min_1 as meta_min, _ts_meta_max_1 as meta_max from :compress_relid3 where _ts_meta_min_1 = :'split_point_max' and _ts_meta_count = 1 order by meta_min; -- The sums of the counts should match up select :'original_count_sum' = ((select sum(_ts_meta_count) from :compress_relid2) + (select sum(_ts_meta_count) from :compress_relid3)); select * from chunk_info; select count(*), min(time), max(time) from _timescaledb_internal._hyper_1_23_chunk; select max(time) as max_time from _timescaledb_internal._hyper_1_23_chunk \gset -------------------------------------------------------- -------------------------------------------------------- -- Split a partial chunk so that the compressed data ends up in one -- chunk and the non-compressed data in the other. -------------------------------------------------------- -------------------------------------------------------- -- Create a new chunk insert into splitme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-10 23:00'::timestamptz, '2024-01-12 22:00:00 PST', '10s') t; call convert_to_columnstore('_timescaledb_internal._hyper_1_25_chunk'); select * from chunk_info where chunk = '_hyper_1_25_chunk'; -- Check that all data is compressed select compress_relid as compress_relid from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_25_chunk'::regclass \gset select count(*) from only _timescaledb_internal._hyper_1_25_chunk; select count(*) from :compress_relid; -- Insert non-compressed data insert into splitme (time, device, temp) select t, ceil(random()*10), random()*40 from generate_series('2024-01-12 23:00'::timestamptz, '2024-01-16 22:00:00 PST', '10s') t; select count(*) from only _timescaledb_internal._hyper_1_25_chunk; select count(*) from :compress_relid; -- Split at a point between the compressed and non-compressed data call split_chunk_validate('_timescaledb_internal._hyper_1_25_chunk', split_at => '2024-01-12 22:30'::timestamptz); select * from chunk_info where chunk in ('_hyper_1_25_chunk', '_hyper_1_27_chunk'); -- Check that the distribution of data is such that one chunk has only -- compressed data and the other only non-compressed data. select compress_relid as compress_relid2 from _timescaledb_catalog.compression_settings where relid = '_timescaledb_internal._hyper_1_27_chunk'::regclass \gset select count(*) from only _timescaledb_internal._hyper_1_25_chunk; select count(*) from :compress_relid; select count(*) from only _timescaledb_internal._hyper_1_27_chunk; select count(*) from :compress_relid2; --- --- Test splitting chunks that are using a time partitioning function --- -- There are multiple versions of to_timestamp() so need to find the -- Oid of the one we want. select p.oid as time_funcid from pg_proc p join pg_namespace n on (p.pronamespace = n.oid) where proname = 'to_timestamp' and provolatile = 'i' and n.nspname = 'pg_catalog' \gset create table time_part_func (time float8, temp float); select create_hypertable('time_part_func', 'time', time_partitioning_func => :'time_funcid', create_default_indexes => false, chunk_time_interval => interval '1 month'); alter table time_part_func set (tsdb.orderby = 'time'); insert into time_part_func values (1734714800, 10.0), (1736220400, 11.0), (1736420400, 12.0); select ch as chunk_to_split from show_chunks('time_part_func') ch \gset call split_chunk(:'chunk_to_split'); select ch as chunk1 from show_chunks('time_part_func') ch limit 1 \gset select ch as chunk2 from show_chunks('time_part_func') ch limit 1 offset 1 \gset select to_timestamp(time), * from :chunk1; select to_timestamp(time), * from :chunk2; -- Split a compressed chunk using time partitioning func call convert_to_columnstore(:'chunk2'); select * from show_chunks('time_part_func'); select to_timestamp(1736320400::float8); call split_chunk(:'chunk2', split_at => 1736320400::float8); select ch as chunk1 from show_chunks('time_part_func') ch limit 1 \gset select ch as chunk2 from show_chunks('time_part_func') ch limit 1 offset 1 \gset select ch as chunk3 from show_chunks('time_part_func') ch limit 1 offset 2 \gset select to_timestamp(time), * from :chunk1; select to_timestamp(time), * from :chunk2; select to_timestamp(time), * from :chunk3; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/telemetry_stats.sql�������������������������������������������������0000664�0000000�0000000�00000027250�15100345067�0022412�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --telemetry tests that require a community license \c :TEST_DBNAME :ROLE_CLUSTER_SUPERUSER; SET timezone TO 'America/Los_Angeles'; -- function call info size is too variable for this test, so disable it SET timescaledb.telemetry_level='no_functions'; SELECT setseed(1); -- Create a materialized view from the telemetry report so that we -- don't regenerate telemetry for every query. Filter heap_size for -- materialized views since PG14 reports a different heap size for -- them compared to earlier PG versions. CREATE MATERIALIZED VIEW telemetry_report AS SELECT (r #- '{relations,materialized_views,heap_size}') AS r FROM get_telemetry_report() r; CREATE VIEW relations AS SELECT r -> 'relations' AS rels FROM telemetry_report; SELECT rels -> 'continuous_aggregates' -> 'num_relations' AS num_continuous_aggs, rels -> 'hypertables' -> 'num_relations' AS num_hypertables FROM relations; -- check telemetry picks up flagged content from metadata SELECT r -> 'db_metadata' AS db_metadata FROM telemetry_report; -- check timescaledb_telemetry.cloud SELECT r -> 'instance_metadata' AS instance_metadata FROM telemetry_report r; CREATE TABLE normal (time timestamptz NOT NULL, device int, temp float); CREATE TABLE part (time timestamptz NOT NULL, device int, temp float) PARTITION BY RANGE (time); CREATE TABLE part_t1 PARTITION OF part FOR VALUES FROM ('2018-01-01') TO ('2018-02-01') PARTITION BY HASH (device); CREATE TABLE part_t2 PARTITION OF part FOR VALUES FROM ('2018-02-01') TO ('2018-03-01') PARTITION BY HASH (device); CREATE TABLE part_t1_d1 PARTITION OF part_t1 FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE part_t1_d2 PARTITION OF part_t1 FOR VALUES WITH (MODULUS 2, REMAINDER 1); CREATE TABLE part_t2_d1 PARTITION OF part_t2 FOR VALUES WITH (MODULUS 2, REMAINDER 0); CREATE TABLE part_t2_d2 PARTITION OF part_t2 FOR VALUES WITH (MODULUS 2, REMAINDER 1); CREATE TABLE hyper (LIKE normal); SELECT table_name FROM create_hypertable('hyper', 'time'); CREATE MATERIALIZED VIEW contagg WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('1 hour', time) AS hour, device, min(time) FROM hyper GROUP BY hour, device; -- Create another view (already have the "relations" view) CREATE VIEW devices AS SELECT DISTINCT ON (device) device FROM hyper; -- Show relations with no data REFRESH MATERIALIZED VIEW telemetry_report; SELECT jsonb_pretty(rels) AS relations FROM relations; -- Insert data INSERT INTO normal SELECT t, ceil(random() * 10)::int, random() * 30 FROM generate_series('2018-01-01'::timestamptz, '2018-02-28', '2h') t; INSERT INTO hyper SELECT * FROM normal; INSERT INTO part SELECT * FROM normal; CALL refresh_continuous_aggregate('contagg', NULL, NULL); -- Reindex to avoid the dependency on the way the index is built (e.g. the caggs -- might get their rows inserted in different order during the refresh based on -- the underlying aggregation plan, and the index will be built differently, -- which can influence its size). REINDEX DATABASE :TEST_DBNAME; -- ANALYZE to get updated reltuples stats VACUUM ANALYZE; SELECT count(c) FROM show_chunks('hyper') c; SELECT count(c) FROM show_chunks('contagg') c; -- Update and show the telemetry report REFRESH MATERIALIZED VIEW telemetry_report; SELECT jsonb_pretty(rels) AS relations FROM relations; -- Actual row count should be the same as reltuples stats for all tables SELECT (SELECT count(*) FROM normal) num_inserted_rows, (SELECT rels -> 'tables' -> 'num_reltuples' FROM relations) normal_reltuples, (SELECT rels -> 'hypertables' -> 'num_reltuples' FROM relations) hyper_reltuples, (SELECT rels -> 'partitioned_tables' -> 'num_reltuples' FROM relations) part_reltuples; -- Add compression ALTER TABLE hyper SET (timescaledb.compress); SELECT compress_chunk(c) FROM show_chunks('hyper') c ORDER BY c LIMIT 4; ALTER MATERIALIZED VIEW contagg SET (timescaledb.compress); SELECT compress_chunk(c) FROM show_chunks('contagg') c ORDER BY c LIMIT 1; -- Turn of real-time aggregation ALTER MATERIALIZED VIEW contagg SET (timescaledb.materialized_only = true); -- Reindex to avoid the dependency on the way the index is built (e.g. the caggs -- might get their rows inserted in different order during the refresh based on -- the underlying aggregation plan, and the index will be built differently, -- which can influence its size). REINDEX DATABASE :TEST_DBNAME; -- ANALYZE to get updated reltuples stats VACUUM ANALYZE; REFRESH MATERIALIZED VIEW telemetry_report; SELECT jsonb_pretty(rels) AS relations FROM relations; -- check telemetry for fixed schedule jobs works create or replace procedure job_test_fixed(jobid int, config jsonb) language plpgsql as $$ begin raise log 'this is job_test_fixed'; end $$; create or replace procedure job_test_drifting(jobid int, config jsonb) language plpgsql as $$ begin raise log 'this is job_test_drifting'; end $$; -- before adding the jobs select get_telemetry_report()->'num_user_defined_actions_fixed'; select get_telemetry_report()->'num_user_defined_actions'; select add_job('job_test_fixed', '1 week'); select add_job('job_test_drifting', '1 week', fixed_schedule => false); -- add continuous aggregate refresh policy for contagg select add_continuous_aggregate_policy('contagg', interval '3 weeks', NULL, interval '3 weeks'); -- drifting -- add retention policy, fixed select add_retention_policy('hyper', interval '1 year', initial_start => now()); -- add compression policy select add_compression_policy('hyper', interval '3 weeks', initial_start => now()); select r->'num_user_defined_actions_fixed' as UDA_fixed, r->'num_user_defined_actions' AS UDA_drifting FROM get_telemetry_report() r; select r->'num_continuous_aggs_policies_fixed' as contagg_fixed, r->'num_continuous_aggs_policies' as contagg_drifting FROM get_telemetry_report() r; select r->'num_compression_policies_fixed' as compress_fixed, r->'num_retention_policies_fixed' as retention_fixed FROM get_telemetry_report() r; DELETE FROM _timescaledb_config.bgw_job WHERE id = 2; TRUNCATE _timescaledb_internal.bgw_job_stat_history; -- create some "errors" for testing INSERT INTO _timescaledb_config.bgw_job(id, application_name, schedule_interval, max_runtime, max_retries, retry_period, proc_schema, proc_name) VALUES (2000, 'User-Defined Action [2000]', interval '3 days', interval '1 hour', 5, interval '5 min', 'public', 'custom_action_1'), (2001, 'User-Defined Action [2001]', interval '3 days', interval '1 hour', 5, interval '5 min', 'public', 'custom_action_2'), (2002, 'Compression Policy [2002]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_compression'), (2003, 'Retention Policy [2003]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_retention'), (2004, 'Refresh Continuous Aggregate Policy [2004]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_refresh_continuous_aggregate'), -- user decided to define a custom action in the _timescaledb_functions schema, we group it with the User-defined actions (2005, 'User-Defined Action [2005]', interval '3 days', interval '1 hour', 5, interval '5 min', '_timescaledb_functions', 'policy_refresh_continuous_aggregate'); -- create some errors for them INSERT INTO _timescaledb_internal.bgw_job_stat_history(job_id, pid, succeeded, execution_start, execution_finish, data) values (2000, 12345, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema":"public", "proc_name": "custom_action_1"}}'), (2000, 23456, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"ABCDE"}, "job": {"proc_schema": "public", "proc_name": "custom_action_1"}}'), (2001, 54321, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "public", "proc_name": "custom_action_2"}}'), (2002, 23443, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"JF009"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_compression"}}'), (2003, 14567, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_retention"}}'), (2004, 78907, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_refresh_continuous_aggregate"}}'), (2005, 45757, false, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '{"error_data": {"sqlerrcode":"P0001"}, "job": {"proc_schema": "_timescaledb_functions", "proc_name": "policy_refresh_continuous_aggregate"}}'); -- we have 3 error records for user-defined actions, and three for policies, so we expect 4 types of jobs SELECT jsonb_pretty(get_telemetry_report() -> 'errors_by_sqlerrcode'); -- for job statistics, insert some records into bgw_job_stats INSERT INTO _timescaledb_internal.bgw_job_stat values (2000, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2001, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2002, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2003, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2004, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0), (2005, '2040-01-01 00:00:00+00'::timestamptz, '2040-01-01 00:00:01+00'::timestamptz, '-infinity'::timestamptz, '-infinity'::timestamptz, false, 1, interval '00:00:00', interval '00:00:02', 0, 1, 0, 1, 0); SELECT jsonb_pretty(get_telemetry_report() -> 'stats_by_job_type'); -- create nested continuous aggregates - copied from cagg_on_cagg_common CREATE TABLE conditions ( time timestamptz NOT NULL, temperature int ); SELECT create_hypertable('conditions', 'time'); CREATE MATERIALIZED VIEW conditions_summary_hourly_1 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 hour', "time") AS bucket, SUM(temperature) AS temperature FROM conditions GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW conditions_summary_daily_2 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 day', "bucket") AS bucket, SUM(temperature) AS temperature FROM conditions_summary_hourly_1 GROUP BY 1 WITH NO DATA; CREATE MATERIALIZED VIEW conditions_summary_weekly_3 WITH (timescaledb.continuous, timescaledb.materialized_only=true) AS SELECT time_bucket('1 week', "bucket") AS bucket, SUM(temperature) AS temperature FROM conditions_summary_daily_2 GROUP BY 1 WITH NO DATA; SELECT jsonb_pretty(get_telemetry_report() -> 'relations' -> 'continuous_aggregates' -> 'num_caggs_nested'); DROP VIEW relations; DROP MATERIALIZED VIEW telemetry_report; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/transparent_decompression.sql.in������������������������������������0000664�0000000�0000000�00000025072�15100345067�0025062�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression SELECT format('include/%s_load.sql', :'TEST_BASE_NAME') AS "TEST_LOAD_NAME", format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset SET work_mem TO '50MB'; SET enable_incremental_sort TO off; SET timezone TO 'America/Los_Angeles'; -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; CREATE TABLE metrics ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 int, v2 float, v3 float ); SELECT create_hypertable ('metrics', 'time'); ALTER TABLE metrics DROP COLUMN filler_1; \set INTERVAL 30m INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_2; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id - 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics DROP COLUMN filler_3; INSERT INTO metrics (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics; -- create identical hypertable with space partitioning CREATE TABLE metrics_space ( filler_1 int, filler_2 int, filler_3 int, time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int, v1 float, v2 float, v3 float ); SELECT create_hypertable ('metrics_space', 'time', 'device_id', 3); ALTER TABLE metrics_space DROP COLUMN filler_1; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-01 0:00:00+0'::timestamptz, '2000-01-05 23:55:00+0', (interval :'INTERVAL') / 3) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_2; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-06 0:00:00+0'::timestamptz, '2000-01-12 23:55:00+0', (interval :'INTERVAL') / 2) gtime (time), generate_series(1, 5, 1) gdevice (device_id); ALTER TABLE metrics_space DROP COLUMN filler_3; INSERT INTO metrics_space (time, device_id, device_id_peer, v0, v1, v2, v3) SELECT time, device_id, 0, device_id + 1, device_id + 2, device_id + 0.5, NULL FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-19 23:55:00+0', :'INTERVAL') gtime (time), generate_series(1, 5, 1) gdevice (device_id); VACUUM ANALYZE metrics_space; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none SET client_min_messages TO error; \o :TEST_RESULTS_UNCOMPRESSED \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \o RESET client_min_messages; \set ECHO all -- compress first and last chunk on the hypertable ALTER TABLE metrics SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics') x) t where n in (1, 3) ; VACUUM ANALYZE metrics; -- compress some chunks on space partitioned hypertable -- we compress all chunks of first time slice, none of second, and 2 of the last time slice ALTER TABLE metrics_space SET (timescaledb.compress, timescaledb.compress_orderby = 'v0, v1 desc, time', timescaledb.compress_segmentby = 'device_id,device_id_peer'); select compress_chunk(x) from (select row_number() over (order by x) n, x from show_chunks('metrics_space') x) t where n in (1, 2, 3, 7, 8) ; SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics' \gset SELECT ht.schema_name || '.' || ht.table_name AS "METRICS_SPACE_COMPRESSED" FROM _timescaledb_catalog.hypertable ht INNER JOIN _timescaledb_catalog.hypertable ht2 ON ht.id = ht2.compressed_hypertable_id AND ht2.table_name = 'metrics_space' \gset \c :TEST_DBNAME :ROLE_SUPERUSER -- Index created using query saved in variable used because there was -- no standard way to create an index on a compressed table. -- Once a standard way exists, modify this test to use that method. \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SET timezone TO 'America/Los_Angeles'; CREATE INDEX ON metrics_space (device_id, device_id_peer, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id, device_id_peer DESC, v0, v1 DESC, time); CREATE INDEX ON metrics_space (device_id DESC, device_id_peer DESC, v0, v1 DESC, time); VACUUM ANALYZE metrics_space; SET enable_incremental_sort TO off; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set PREFIX_NO_ANALYZE '' \set ECHO none SET client_min_messages TO error; \o :TEST_RESULTS_COMPRESSED \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \o RESET client_min_messages; \set ECHO all \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' \set PREFIX_NO_ANALYZE 'EXPLAIN (verbose, buffers off, costs off)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; -- get explain for queries on hypertable with compression \set TEST_TABLE 'metrics' \ir :TEST_QUERY_NAME \set TEST_TABLE 'metrics_space' \ir :TEST_QUERY_NAME \ir include/transparent_decompression_ordered.sql \ir include/transparent_decompression_systemcolumns.sql \ir include/transparent_decompression_undiffed.sql -- diff compressed and uncompressed results :DIFF_CMD -- check hypertable detection in views CREATE VIEW ht_view AS SELECT *, 0 AS res FROM metrics UNION ALL SELECT *, 1 AS res FROM metrics; CREATE FUNCTION ht_func() RETURNS SETOF metrics LANGUAGE SQL STABLE AS $sql$ SELECT time, device_id, device_id_peer, v0, v1, v2, v3 FROM ht_view WHERE res = 0; $sql$; -- should have decompresschunk node :PREFIX SELECT * FROM ht_func(); \c SET enable_incremental_sort TO off; -- plan should be identical to previous plan in fresh session :PREFIX SELECT * FROM ht_func(); -- repro for core dump related to total_table_pages setting that get -- adjusted during decompress path. CREATE SEQUENCE vessel_id_seq INCREMENT 1 START 1 MINVALUE 1 MAXVALUE 9223372036854775807 CACHE 1; CREATE TABLE motion_table( id bigint NOT NULL DEFAULT nextval('vessel_id_seq'::regclass) , datalogger_id bigint , vessel_id bigint , bus_id smallint , src_id smallint , dataloggertime timestamp with time zone , interval_s real ); CREATE INDEX motion_table_t2_datalogger_id_idx on motion_table (datalogger_id); CREATE INDEX motion_table_t2_dataloggertime_idx on motion_table(dataloggertime DESC); CREATE INDEX motion_table_t2_vessel_id_idx on motion_table(vessel_id); SELECT create_hypertable( 'motion_table', 'dataloggertime', chunk_time_interval=> '7 days'::interval); --- do not modify the data. We need atleast this volume to reproduce issues with pages/tuple counts etc. --- INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), random() , random() , generate_series( '2020-01-02 10:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; INSERT into motion_table(datalogger_id, vessel_id, bus_id, src_id, dataloggertime, interval_s) SELECT 1, random(), 2, 3, generate_series( '2020-01-10 8:00'::timestamp, '2020-01-10 10::00'::timestamp, '1 min'::interval), 1.1; ALTER TABLE motion_table SET ( timescaledb.compress, timescaledb.compress_segmentby = 'vessel_id, datalogger_id, bus_id, src_id' , timescaledb.compress_orderby = 'dataloggertime' ); --have 2 chunks -- SELECT COUNT(*) FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table'; -- compress only the first one --- SELECT compress_chunk( chunk_table) FROM ( SELECT chunk_schema || '.' || chunk_name as chunk_table FROM timescaledb_information.chunks WHERE hypertable_name = 'motion_table' ORDER BY range_start limit 1 ) q; --call to decompress chunk on 1 of the chunks SELECT count(*) from motion_table; --END of test for page settings CREATE TABLE repro(time timestamptz NOT NULL, device_id text, room_id text NOT NULL, score_type int NOT NULL, algorithm_version text NOT NULL, adjusted_score float NOT NULL); SELECT create_hypertable('repro','time'); ALTER TABLE repro SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device_id, room_id, score_type, algorithm_version', timescaledb.compress_orderby='"time" DESC' ); SELECT _timescaledb_functions.create_chunk('repro','{"time": [1717632000000000,1718236800000000]}'); select compress_chunk(show_chunks('repro')); select from repro where room_id = 'foo' order by device_id, algorithm_version, score_type, time desc; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/transparent_decompression_join_index.sql����������������������������0000664�0000000�0000000�00000004507�15100345067�0026663�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- github issue 5585 create table test ( time timestamptz not null, a varchar(255) not null, b int, c int ); SELECT create_hypertable('test', 'time'); insert into test values ('2020-01-01 00:00'::timestamptz, 'lat', 1, 2), ('2020-01-01 00:01'::timestamptz, 'lat', 1, 2), ('2020-01-01 00:01'::timestamptz, 'lat', 2, 2), ('2020-01-01 00:03'::timestamptz, 'lat', 1, 2), ('2020-01-01 00:01'::timestamptz, 'lon', 1, 2); create table test_copy as select * from test; -- compress the chunk alter table test set (timescaledb.compress, timescaledb.compress_segmentby='a, b'); select compress_chunk(show_chunks('test')); -- force an index scan set enable_seqscan = 'off'; -- make some tweaks to avoid flakiness analyze test; analyze test_copy; set enable_hashagg = off; set enable_sort to off; set jit = off; set max_parallel_workers_per_gather = 0; explain (buffers off, costs off) with query_params as ( select distinct a, b from test_copy where test_copy.a IN ('lat', 'lon') and test_copy.b IN (1) ) select test.time, test.a = q.a as "this should never be false", test.a, test.b, test.c, q.* from test inner join query_params q on q.a = test.a and q.b = test.b where test.time between '2020-01-01 00:00' and '2020-01-01 00:02' order by test.time; with query_params as ( select distinct a, b from test_copy where test_copy.a IN ('lat', 'lon') and test_copy.b IN (1) ) select test.time, test.a = q.a as "this should never be false", test.a, test.b, test.c, q.* from test inner join query_params q on q.a = test.a and q.b = test.b where test.time between '2020-01-01 00:00' and '2020-01-01 00:02' order by test.time; -- Also test outer join for better coverage of nullability handling. -- This test case generates a nullable equivalence member for test.b. explain (buffers off, costs off) with query_params as ( select distinct a, b + 1 as b from test_copy where test_copy.a IN ('lat', 'lon') ) select test.a, test.b from test full join query_params q on q.a = test.a full join query_params q2 on q2.b = test.b ; reset enable_seqscan; reset jit; drop table test; drop table test_copy; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/transparent_decompression_ordered_index.sql.in����������������������0000664�0000000�0000000�00000023435�15100345067�0027756�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set TEST_BASE_NAME transparent_decompression_ordered_index SELECT format('include/%s_query.sql', :'TEST_BASE_NAME') AS "TEST_QUERY_NAME", format('%s/results/%s_results_uncompressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_UNCOMPRESSED", format('%s/results/%s_results_compressed.out', :'TEST_OUTPUT_DIR', :'TEST_BASE_NAME') AS "TEST_RESULTS_COMPRESSED" \gset SELECT format('\! diff -u -- %s %s', :'TEST_RESULTS_UNCOMPRESSED', :'TEST_RESULTS_COMPRESSED') AS "DIFF_CMD" \gset -- disable memoize node to avoid flaky results SET enable_memoize TO 'off'; -- Testing Index Scan backwards ---- -- We want more than 1 segment in atleast 1 of the chunks CREATE TABLE metrics_ordered_idx ( time timestamptz NOT NULL, device_id int, device_id_peer int, v0 int ); SELECT create_hypertable ('metrics_ordered_idx', 'time', chunk_time_interval => '2days'::interval); ALTER TABLE metrics_ordered_idx SET (timescaledb.compress, timescaledb.compress_orderby = 'time ASC', timescaledb.compress_segmentby = 'device_id,device_id_peer'); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT time, device_id, 0, device_id FROM generate_series('2000-01-13 0:00:00+0'::timestamptz, '2000-01-15 23:55:00+0', '15m') gtime (time), generate_series(1, 5, 1) gdevice (device_id); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2000-01-20 0:00:00+0'::timestamptz, '2000-01-20 11:55:00+0', '15m'), 3, 3, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT generate_series('2018-01-20 0:00:00+0'::timestamptz, '2018-01-20 11:55:00+0', '15m'), 4, 5, generate_series(1, 5, 1); INSERT INTO metrics_ordered_idx (time, device_id, device_id_peer, v0) SELECT '2020-01-01 0:00:00+0', generate_series(4, 7, 1), 5, generate_series(1, 5, 1); -- misisng values device_id = 7 CREATE TABLE device_tbl ( device_id int, descr text ); INSERT INTO device_tbl SELECT generate_series(1, 6, 1), 'devicex'; INSERT INTO device_tbl SELECT 8, 'device8'; ANALYZE device_tbl; -- table for joins --- CREATE TABLE nodetime ( node int, start_time timestamp, stop_time timestamp ); INSERT INTO nodetime VALUES (4, '2018-01-06 00:00'::timestamp, '2018-12-02 12:00'::timestamp); VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on uncompressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' -- Unfortunately the ECHO cannot be redirected to the output file. \set ECHO none SET client_min_messages TO error; \o :TEST_RESULTS_UNCOMPRESSED \ir include/transparent_decompression_ordered_index.sql \ir include/transparent_decompression_constraintaware.sql \o RESET client_min_messages; \set ECHO all --compress all chunks for metrics_ordered_idx table -- SELECT count(compress_chunk(ch)) FROM show_chunks('metrics_ordered_idx') ch; -- reindexing compressed hypertable to update statistics DO $$ DECLARE hyper_id int; BEGIN SELECT h.compressed_hypertable_id INTO hyper_id FROM _timescaledb_catalog.hypertable h WHERE h.table_name = 'metrics_ordered_idx'; EXECUTE format('REINDEX TABLE _timescaledb_internal._compressed_hypertable_%s', hyper_id); END; $$; VACUUM FULL ANALYZE metrics_ordered_idx; -- run queries on compressed hypertable and store result \set PREFIX '' \set PREFIX_VERBOSE '' \set ECHO none SET client_min_messages TO error; SET enable_seqscan = FALSE; \o :TEST_RESULTS_COMPRESSED \ir include/transparent_decompression_ordered_index.sql \ir include/transparent_decompression_constraintaware.sql SET enable_seqscan = TRUE; \o RESET client_min_messages; \set ECHO all -- diff compressed and uncompressed results :DIFF_CMD -- This is to illustrate that we have some null device_id values. This fact -- might influence the runtime chunk exclusion when doing joins on device_id. select count(*) from metrics_ordered_idx where extract(minute from time) = 0 and device_id is null ; \set PREFIX 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off)' \set PREFIX_VERBOSE 'EXPLAIN (analyze, buffers off, costs off, timing off, summary off, verbose)' -- we disable parallelism here otherwise EXPLAIN ANALYZE output -- will be not stable and differ depending on worker assignment SET max_parallel_workers_per_gather TO 0; SET enable_seqscan = FALSE; -- get explain for queries on hypertable with compression \ir include/transparent_decompression_ordered_indexplan.sql SET enable_seqscan = FALSE; \ir include/transparent_decompression_ordered_index.sql SET enable_seqscan = TRUE; \ir include/transparent_decompression_constraintaware.sql -- github bug 2917 with UNION ALL that references compressed ht CREATE TABLE entity ( oid bigint PRIMARY KEY, type text, name text ); INSERT INTO entity values(10, 'VMEM', 'cpu'); CREATE TABLE entity_m2 ( timec timestamp with time zone NOT NULL, entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision, peak double precision ); SELECT create_hypertable('entity_m2', 'timec', chunk_time_interval=>'30 days'::interval); INSERT INTO entity_m2 values ( '2020-12-21 15:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); INSERT INTO entity_m2 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 2097152 , 0 , 100); ALTER TABLE entity_m2 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m2') c; VACUUM FULL ANALYZE entity_m2; CREATE TABLE entity_m1 ( timec timestamp with time zone , entity_oid bigint , entity_hash bigint , type text , current double precision, capacity double precision, utilization double precision ); SELECT create_hypertable('entity_m1', 'timec', chunk_time_interval=>'30 days'::interval); INSERT INTO entity_m1 values ( '2020-12-21 16:47:58.778-05' , 10 , -7792214420424674003 , 'VMEM' , 0, 100 , 0 ); create view metric_view as SELECT m2.timec, m2.entity_oid, m2.entity_hash, m2.type, m2.current, m2.capacity, m2.utilization, m2.peak FROM entity_m2 m2 UNION ALL SELECT m1.timec, m1.entity_oid, m1.entity_hash, m1.type, m1.current, m1.capacity, m1.utilization, NULL::double precision AS peak FROM entity_m1 m1; VACUUM FULL ANALYZE entity_m1; SET enable_bitmapscan = false; SET enable_hashjoin = false; SET enable_mergejoin = false; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; --now compress the other table too and rerun the query -- ALTER TABLE entity_m1 SET (timescaledb.compress, timescaledb.compress_segmentby = 'entity_oid', timescaledb.compress_orderby = 'type, timec'); SELECT compress_chunk(c) FROM show_chunks('entity_m1') c; VACUUM FULL ANALYZE entity_m1; SELECT m.timec, avg(m.utilization) AS avg_util FROM metric_view m, entity e WHERE m.type = 'VMEM' AND m.timec BETWEEN '2020-12-21T00:00:00'::timestamptz - interval '7 day' AND date_trunc('day', '2020-12-22T00:00:00'::timestamptz) AND m.entity_oid = e.oid GROUP BY 1 ORDER BY 1; RESET enable_bitmapscan ; RESET enable_hashjoin ; RESET enable_mergejoin; -- end github bug 2917 -- When we cannot use compression sort as query keys do not match, -- and have useful and cheap IndexScans due to selective index conditions, -- we should be able to use ChunkAppend after sorting IndexScans to desired query keys. -- Before, we would only try to sort SeqScans in such scenarios. SET enable_seqscan = false; -- IndexScan keys (device_id, device_id_peer, time) do not match query keys, can't push sort into compressed index. -- Cannot use batch sort either as have to order on (time, device_id_peer). -- IndexScan can be cheap because of (device_id>2), -- should allow ChunkAppend with LIMIT after sorting decompressed IndexScans on query keys. :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; -- Make sure we can use ChunkAppend over sorted decompressed parametrized IndexScans and SeqScans -- Parametrized IndexScans :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; -- Parametrized SeqScans RESET enable_seqscan; SET enable_indexscan = false; :PREFIX SELECT nd.node, mt.* FROM metrics_ordered_idx mt, nodetime nd WHERE mt.time > nd.start_time AND mt.device_id = nd.node AND mt.time < nd.stop_time ORDER BY "time", mt.device_id limit 5; SET enable_seqscan = false; RESET enable_indexscan; -- When we decompress top chunk, uncompressed IndexScan is sorted on (time DESC), -- should allow ChunkAppend with LIMIT -- over (Sort(time, device_id_peer) <- IndexScan + Sort(time, device_id_peer) <- DecompressChunk ...) select show_chunks as chunk_to_decompress_1 from show_chunks('metrics_ordered_idx') order by 1 desc limit 1 \gset select decompress_chunk(:'chunk_to_decompress_1'); :PREFIX select * from metrics_ordered_idx where device_id > 2 order by "time" desc, device_id_peer limit 10; select compress_chunk(:'chunk_to_decompress_1'); RESET enable_seqscan; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/transparent_decompression_queries.sql.in����������������������������0000664�0000000�0000000�00000012445�15100345067�0026617�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. --TEST github issue 1650 character segment by column CREATE TABLE test_chartab ( job_run_id INTEGER NOT NULL, mac_id CHAR(16) NOT NULL, rtt INTEGER NOT NULL, ts TIMESTAMP(3) NOT NULL ); SELECT create_hypertable('test_chartab', 'ts', chunk_time_interval => interval '1 day', migrate_data => true); insert into test_chartab values(8864, '0014070000006190' , 392 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '0014070000011039' , 150 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8864 , '001407000001DD2E' , 228 , '2019-12-14 02:52:05.863'); insert into test_chartab values( 8890 , '001407000001DD2E' , 228 , '2019-12-20 02:52:05.863'); ALTER TABLE test_chartab SET (timescaledb.compress, timescaledb.compress_segmentby = 'mac_id', timescaledb.compress_orderby = 'ts DESC'); select * from test_chartab order by mac_id , ts limit 2; --compress the data and check -- SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); select * from test_chartab order by mac_id , ts limit 2; SELECT compress_chunk('_timescaledb_internal._hyper_1_2_chunk'); select * from test_chartab order by mac_id , ts limit 2; VACUUM ANALYZE test_chartab; -- test constraintawareappend sort node handling SET work_mem to '16MB'; SET enable_hashagg TO false; SET timescaledb.enable_chunkwise_aggregation TO false; SET max_parallel_workers_per_gather = 0; CREATE TABLE public.merge_sort (time timestamp NOT NULL, measure_id integer NOT NULL, device_id integer NOT NULL, value float); SELECT create_hypertable('merge_sort', 'time'); ALTER TABLE merge_sort SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id, measure_id'); INSERT INTO merge_sort SELECT time, 1, 1, extract(epoch from time) * 0.001 FROM generate_series('2000-01-01'::timestamp,'2000-02-01'::timestamp,'5 sec'::interval) g1(time); --compress first chunk SELECT compress_chunk(ch) FROM show_chunks('merge_sort') ch LIMIT 1; VACUUM ANALYZE merge_sort; -- this should have a MergeAppend with children wrapped in Sort nodes EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time < now() GROUP BY 2, 3; -- this should exclude the decompressed chunk EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT last(time, time) as time, device_id, measure_id, last(value, time) AS value FROM merge_sort WHERE time > '2000-01-10'::text::timestamp GROUP BY 2, 3; RESET enable_hashagg; RESET timescaledb.enable_chunkwise_aggregation; RESET max_parallel_workers_per_gather; RESET work_mem; -- test if volatile function quals are applied to compressed chunks CREATE FUNCTION check_equal_228( intval INTEGER) RETURNS BOOL LANGUAGE PLPGSQL AS $BODY$ DECLARE retval BOOL; BEGIN IF intval = 228 THEN RETURN TRUE; ELSE RETURN FALSE; END IF; END; $BODY$; -- the function cannot be pushed down to compressed chunk -- but should be applied as a filter on decompresschunk SELECT * from test_chartab WHERE check_equal_228(rtt) ORDER BY ts; EXPLAIN (analyze,buffers off, costs off,timing off,summary off) SELECT * from test_chartab WHERE check_equal_228(rtt) and ts < '2019-12-15 00:00:00' order by ts; -- test pseudoconstant qual #3241 CREATE TABLE pseudo(time timestamptz NOT NULL); SELECT create_hypertable('pseudo','time'); ALTER TABLE pseudo SET (timescaledb.compress); INSERT INTO pseudo SELECT '2000-01-01'; SELECT compress_chunk(show_chunks('pseudo')); SELECT * FROM pseudo WHERE now() IS NOT NULL; -- ensure needed decompression paths underneath a sort node -- are not recycled by PostgreSQL SET random_page_cost = 4.0; DROP TABLE IF EXISTS options_data; CREATE TABLE IF NOT EXISTS options_data ( date date NOT NULL, contract_code text NOT NULL, expiry_code text NOT NULL, option_type character(1) NOT NULL, strike real NOT NULL, price double precision, source text NOT NULL, meta text ); SELECT create_hypertable('options_data', 'date', chunk_time_interval => interval '1 day'); INSERT INTO options_data (date, contract_code, expiry_code, option_type, strike, price, source, meta) SELECT date_series, 'CONTRACT' || date_series::text, 'EXPIRY' || date_series::text, CASE WHEN random() < 0.5 THEN 'C' ELSE 'P' END, -- Randomly choose 'C' or 'P' for option_type random() * 100, -- Random strike value between 0 and 100 random() * 100, -- Random price value between 0 and 100 'SOURCE' || date_series::text, 'META' || date_series::text FROM generate_series( '2023-12-01 00:00:00', '2023-12-05 00:00:00', INTERVAL '10 minute' ) AS date_series; ALTER TABLE options_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'contract_code, expiry_code, option_type, strike, source', timescaledb.compress_orderby = 'date DESC'); SELECT compress_chunk(ch) FROM show_chunks('options_data', older_than=> '2023-12-05') ch; VACUUM ANALYZE options_data; SELECT max(date) AS date FROM options_data WHERE contract_code='CONTRACT2023-12-03 04:00:00+01'; RESET random_page_cost; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/tsl_tables.sql������������������������������������������������������0000664�0000000�0000000�00000035411�15100345067�0021314�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER SET timescaledb.license_key='CommunityLicense'; CREATE OR REPLACE FUNCTION ts_test_chunk_stats_insert(job_id INTEGER, chunk_id INTEGER, num_times_run INTEGER, last_time_run TIMESTAMPTZ = NULL) RETURNS VOID AS :TSL_MODULE_PATHNAME LANGUAGE C VOLATILE; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; CREATE TABLE test_table(time timestamptz, junk int); CREATE TABLE test_table_int(time bigint, junk int); SELECT create_hypertable('test_table', 'time'); SELECT create_hypertable('test_table_int', 'time', chunk_time_interval => 1); CREATE INDEX second_index on test_table (time); CREATE INDEX third_index on test_table (time); select add_reorder_policy('test_table', 'test_table_time_idx') as job_id \gset -- Noop for duplicate policy select add_reorder_policy('test_table', 'test_table_time_idx', true); select add_reorder_policy('test_table', 'second_index', true); select add_reorder_policy('test_table', 'third_index', true); \set ON_ERROR_STOP 0 -- Error whenever incorrect arguments are applied (must have table and index) select add_reorder_policy('test_table', 'bad_index'); select add_reorder_policy('test_table', ''); select add_reorder_policy('test_table'); select add_reorder_policy('test_table', 'second_index'); select add_reorder_policy('test_table', 'third_index'); select add_reorder_policy(NULL, 'third_index'); select add_reorder_policy(2, 'third_index'); \set ON_ERROR_STOP 1 select * from _timescaledb_config.bgw_job where id=:job_id; -- Now check that default scheduling interval for reorder policy is calculated correctly -- Should be 1/2 default chunk interval length CREATE TABLE test_table2(time timestamptz, junk int); SELECT create_hypertable('test_table2', 'time', chunk_time_interval=>INTERVAL '1 day'); select add_reorder_policy('test_table2', 'test_table2_time_idx'); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; DROP TABLE test_table2; -- Make sure that test_table2 reorder policy gets dropped SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Error whenever incorrect arguments are applied (must have table and interval) \set ON_ERROR_STOP 0 select add_retention_policy(); select add_retention_policy('test_table'); select add_retention_policy(INTERVAL '3 hours'); select add_retention_policy('test_table', INTERVAL 'haha'); select add_retention_policy('test_table', 'haha'); select add_retention_policy('test_table', 42); select add_retention_policy('fake_table', INTERVAL '3 month'); \set ON_ERROR_STOP 1 select add_retention_policy('test_table', INTERVAL '3 month', true); -- Should not add new policy with different parameters select add_retention_policy('test_table', INTERVAL '3 month', true); select add_retention_policy('test_table', INTERVAL '1 year', if_not_exists => true); select add_retention_policy('test_table', INTERVAL '3 days', if_not_exists => true); select add_retention_policy('test_table', INTERVAL '3 days', if_not_exists => true); SELECT * FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_retention' ORDER BY id; \set ON_ERROR_STOP 0 select add_retention_policy('test_table', INTERVAL '1 year'); select add_retention_policy('test_table', INTERVAL '3 days'); \set ON_ERROR_STOP 1 SELECT * FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_retention' ORDER BY id; select remove_retention_policy('test_table'); -- Test set_integer_now_func and add_retention_policy with -- hypertables that have integer time dimension select * from _timescaledb_catalog.dimension; \c :TEST_DBNAME :ROLE_SUPERUSER CREATE SCHEMA IF NOT EXISTS my_new_schema; create or replace function my_new_schema.dummy_now2() returns BIGINT LANGUAGE SQL IMMUTABLE as 'SELECT 1::BIGINT'; grant usage on SCHEMA my_new_schema to public; grant execute on ALL FUNCTIONS IN SCHEMA my_new_schema to public; select set_integer_now_func('test_table_int', 'my_new_schema.dummy_now2'); \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER select * from _timescaledb_catalog.dimension; SELECT * FROM _timescaledb_config.bgw_job WHERE proc_name = 'policy_retention' ORDER BY id; select remove_reorder_policy('test_table'); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; select add_retention_policy('test_table', INTERVAL '3 month'); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; select remove_retention_policy('test_table'); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; select add_retention_policy('test_table_int', 1); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Should not add new policy with different parameters select add_retention_policy('test_table_int', 2, true); select remove_retention_policy('test_table_int'); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Make sure remove works when there's nothing to remove select remove_retention_policy('test_table', true); select remove_reorder_policy('test_table', true); \set ON_ERROR_STOP 0 select remove_retention_policy(); select remove_retention_policy('fake_table'); select remove_reorder_policy(); select remove_reorder_policy('fake_table'); \set ON_ERROR_STOP 1 \set ON_ERROR_STOP 0 -- This should be noop select remove_reorder_policy(2, true); -- Fail with error message select remove_reorder_policy(2); \set ON_ERROR_STOP 1 -- Now make sure policy args have correct job deletion dependency SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; select add_retention_policy('test_table', INTERVAL '2 month') as job_id \gset select add_reorder_policy('test_table', 'third_index') as reorder_job_id \gset select count(*) from _timescaledb_config.bgw_job where id=:job_id; select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; select delete_job(:job_id); select count(*) from _timescaledb_config.bgw_job where id=:job_id; -- Job config should still be there select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; select delete_job(:reorder_job_id); select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; -- Now make sure policy args have correct job deletion dependency select add_retention_policy('test_table', INTERVAL '2 month') as job_id \gset select add_reorder_policy('test_table', 'third_index') as reorder_job_id \gset select count(*) from _timescaledb_config.bgw_job where id=:job_id; select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; DROP TABLE test_table; select count(*) from _timescaledb_config.bgw_job where id=:job_id; select count(*) from _timescaledb_config.bgw_job where id=:reorder_job_id; -- Check that we can't add policies on non-hypertables CREATE TABLE non_hypertable(junk int, more_junk int); CREATE INDEX non_ht_index on non_hypertable(junk); \set ON_ERROR_STOP 0 select add_retention_policy('non_hypertable', INTERVAL '2 month'); select add_reorder_policy('non_hypertable', 'non_ht_index'); \set ON_ERROR_STOP 1 -- Now make sure things work with multiple policies on multiple hypertables CREATE TABLE test_table(time timestamptz, junk int); SELECT create_hypertable('test_table', 'time'); CREATE INDEX second_index on test_table (time); CREATE TABLE test_table2(time timestamptz, junk int); SELECT create_hypertable('test_table2', 'time'); CREATE INDEX junk_index on test_table2 (junk); select add_retention_policy('test_table', INTERVAL '2 days'); select add_retention_policy('test_table2', INTERVAL '1 days'); SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; DROP TABLE test_table; DROP TABLE test_table_int; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; DROP TABLE test_table2; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Now test chunk_stat insertion select ts_test_chunk_stats_insert(123, 123, 45); select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; \c :TEST_DBNAME :ROLE_SUPERUSER TRUNCATE _timescaledb_internal.bgw_policy_chunk_stats; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER -- Now test chunk_stat deletion is correct select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; CREATE TABLE test_table(time timestamptz, junk int); SELECT create_hypertable('test_table', 'time'); CREATE INDEX second_index on test_table (time); insert into test_table values (now(), 1); insert into test_table values (now() - INTERVAL '5 weeks', 123); select c.id from _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as h where c.hypertable_id=h.id and h.table_name='test_table' ORDER BY c.id; select c.id as chunk_id from _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as h where c.hypertable_id=h.id and h.table_name='test_table' ORDER BY c.id LIMIT 1 \gset select add_reorder_policy('test_table', 'second_index') as job_id \gset -- Simulate reorder job running and setting this stat row select ts_test_chunk_stats_insert(:job_id, :chunk_id, 1); select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Deleting a chunk that has nothing to do with the job should do nothing select c.table_name as other_chunk_name,c.schema_name as other_chunk_schema from _timescaledb_catalog.chunk as c, _timescaledb_catalog.hypertable as h where c.id != :chunk_id \gset select concat(:'other_chunk_schema','.',:'other_chunk_name') as other_chunk \gset DROP TABLE :other_chunk; select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Dropping the hypertable should drop the chunk, which should drop the reorder policy DROP TABLE test_table; select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Now check dropping a job will drop the chunk_stat row CREATE TABLE test_table(time timestamptz, junk int); SELECT create_hypertable('test_table', 'time'); select add_reorder_policy('test_table', 'test_table_time_idx') as job_id \gset select add_retention_policy('test_table', INTERVAL '2 days', true); select ts_test_chunk_stats_insert(:job_id, 123, 1); select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Dropping the drop_chunks job should not affect the chunk_stats row select remove_retention_policy('test_table'); select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; select remove_reorder_policy('test_table'); -- Row should be gone select job_id,chunk_id,num_times_job_run from _timescaledb_internal.bgw_policy_chunk_stats; SELECT * FROM _timescaledb_config.bgw_job WHERE id >= 1000 ORDER BY id; -- Now test if alter_job works select add_reorder_policy('test_table', 'test_table_time_idx') as job_id \gset select * from _timescaledb_config.bgw_job where id=:job_id; -- No change select * from alter_job(:job_id); -- Changes expected select * from alter_job(:job_id, INTERVAL '3 years', INTERVAL '5 min', 5, INTERVAL '123 sec'); select * from alter_job(:job_id, INTERVAL '123 years'); select * from alter_job(:job_id, retry_period => INTERVAL '33 hours'); select * from alter_job(:job_id, max_runtime => INTERVAL '456 sec'); select * from alter_job(:job_id, max_retries => 0); select * from alter_job(:job_id, max_retries => -1); select * from alter_job(:job_id, max_retries => 20); -- No change select * from alter_job(:job_id, max_runtime => NULL); select * from alter_job(:job_id, max_retries => NULL); --change schedule_interval when bgw_job_stat does not exist select * from alter_job(:job_id, schedule_interval=>'1 min'); select count(*) = 0 from _timescaledb_internal.bgw_job_stat where job_id = :job_id; --set next_start when bgw_job_stat does not exist select * from alter_job(:job_id, next_start=>'2001-01-01 01:01:01'); --change schedule_interval when no last_finish set select * from alter_job(:job_id, schedule_interval=>'10 min'); --next_start overrides any schedule_interval changes select * from alter_job(:job_id, schedule_interval=>'20 min', next_start=>'2002-01-01 01:01:01'); --set the last_finish manually \c :TEST_DBNAME :ROLE_SUPERUSER UPDATE _timescaledb_internal.bgw_job_stat SET last_finish = '2003-01-01:01:01:01' WHERE job_id = :job_id; \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER --not changing the interval doesn't change the next_start select * from alter_job(:job_id, schedule_interval=>'20 min'); --changing the interval changes next_start select * from alter_job(:job_id, schedule_interval=>'30 min'); --explicit next start overrides. select * from alter_job(:job_id, schedule_interval=>'40 min', next_start=>'2004-01-01 01:01:01'); --test pausing select * from alter_job(:job_id, next_start=>'infinity'); --test that you can use now() to unpause select next_start = now() from alter_job(:job_id, next_start=>now()); --test pausing/resuming via scheduled parameter select job_id from alter_job(:job_id, scheduled=>false); select job_status, next_start from timescaledb_information.job_stats where job_id = :job_id; select job_id from alter_job(:job_id, scheduled=>true); select job_status from timescaledb_information.job_stats where job_id = :job_id; \set ON_ERROR_STOP 0 -- negative infinity disallowed (used as special value) select * from alter_job(:job_id, next_start=>'-infinity'); -- index should exist select * from alter_job(:job_id, config => '{"index_name": "non-existent", "hypertable_id": 7}'); -- index should be an index on the hypertable select * from alter_job(:job_id, config => '{"index_name": "non_ht_index", "hypertable_id": 7}'); -- hypertable should exist select * from alter_job(:job_id, config => '{"index_name": "test_table_time_idx", "hypertable_id": 47}'); \set ON_ERROR_STOP 1 -- Check if_exists boolean works correctly select * from alter_job(1234, if_exists => TRUE); \set ON_ERROR_STOP 0 select * from alter_job(1234); \set ON_ERROR_STOP 1 select remove_reorder_policy('test_table'); \c :TEST_DBNAME :ROLE_SUPERUSER set session timescaledb.license_key='Community'; -- Test for failure cases \set ON_ERROR_STOP 0 select alter_job(12345); \set ON_ERROR_STOP 1 select add_reorder_policy('test_table', 'test_table_time_idx') as reorder_job_id \gset select add_retention_policy('test_table', INTERVAL '4 months', true) as drop_chunks_job_id \gset \c :TEST_DBNAME :ROLE_DEFAULT_PERM_USER_2 \set ON_ERROR_STOP 0 select from alter_job(:reorder_job_id, max_runtime => NULL); select from alter_job(:drop_chunks_job_id, max_runtime => NULL); \set ON_ERROR_STOP 1 �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/unlogged.sql��������������������������������������������������������0000664�0000000�0000000�00000003720�15100345067�0020762�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. CREATE UNLOGGED TABLE t1(time timestamptz) WITH (tsdb.hypertable); SELECT oid::regclass,relpersistence from pg_class where oid = 't1'::regclass; INSERT INTO t1 SELECT '2025-01-01'; SELECT count(compress_chunk(chunk)) FROM show_chunks('t1') chunk; -- check that all objects related to hypertable are unlogged SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; ALTER TABLE t1 SET LOGGED; SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; SELECT show_chunks('t1') AS "CHUNK" \gset ALTER TABLE :CHUNK SET UNLOGGED; -- only chunk and compressed chunk should be unlogged now but not hypertable SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; ALTER TABLE t1 SET LOGGED; -- all objects should be logged now SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; DROP TABLE t1; CREATE TABLE t2(time timestamptz) WITH (tsdb.hypertable); ALTER TABLE t2 SET UNLOGGED; SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; INSERT INTO t2 SELECT '2025-01-01'; -- new chunk should be unlogged SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; ALTER TABLE t2 SET LOGGED; -- everything should be logged now SELECT oid::regclass,relpersistence from pg_class where relpersistence = 'u' AND relnamespace <> 'pg_toast'::regnamespace ORDER BY oid::regclass; ������������������������������������������������timescaledb-2.23.0/tsl/test/sql/utils���������������������������������������������������������������0000777�0000000�0000000�00000000000�15100345067�0023213�2../../../test/sql/utils�����������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_byte.sql�������������������������������������������������0000664�0000000�0000000�00000003435�15100345067�0022324�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Tests for grouping by single-byte data types. Only bool for now, because char -- lacks a vectorized representation. create table groupbyte(ts int, b bool, x text, i int) with (tsdb.hypertable, tsdb.partition_column = 'ts', tsdb.chunk_interval = '10', tsdb.compress, tsdb.compress_segmentby = 'b', tsdb.compress_orderby = ts); insert into groupbyte select 1, case when x % 11 = 0 then null else x % 3 = 0 end, case when x % 13 = 0 then null else 'tag' || (x % 7) end, x from generate_series(1, 1000) x; select count(compress_chunk(x)) from show_chunks('groupbyte') x; alter table groupbyte set (tsdb.compress_segmentby = ''); insert into groupbyte select 11, case when x % 11 = 0 then null else x % 3 = 0 end, case when x % 13 = 0 then null else 'tag' || (x % 7) end, x from generate_series(1, 1000) x; select count(compress_chunk(x)) from show_chunks('groupbyte') x; set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select format('select %s%s from groupbyte%s%s;', grouping || ', ', function, ' group by ' || grouping, ' order by ' || function || ', ' || grouping || ' limit 10') from unnest(array[ 'count(*)' , 'count(b)' , 'sum(i)' ]) function, unnest(array[ null , 'b' , 'b, x' , 'x, b' ]) with ordinality as grouping(grouping, n) order by function, grouping.n \gexec reset timescaledb.debug_require_vector_agg; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_default.sql����������������������������������������������0000664�0000000�0000000�00000005167�15100345067�0023011�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- Uncomment these two settings to run this test with hypercore TAM --set timescaledb.default_hypercore_use_access_method=true; --set enable_indexscan=off; create function stable_abs(x int4) returns int4 as 'int4abs' language internal stable; create table dvagg(a int, b int); select create_hypertable('dvagg', 'a', chunk_time_interval => 1000); insert into dvagg select x, x % 5 from generate_series(1, 999) x; alter table dvagg set (timescaledb.compress); select compress_chunk(show_chunks('dvagg')); alter table dvagg add column c int default 7; insert into dvagg select x, x % 5, 11 from generate_series(1001, 1999) x; select compress_chunk(show_chunks('dvagg')); vacuum analyze dvagg; -- Just the most basic vectorized aggregation query on a table with default -- compressed column. explain (buffers off, costs off) select sum(c) from dvagg; select sum(c) from dvagg; set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference --set timescaledb.debug_require_vector_agg = 'forbid'; --set timescaledb.enable_vectorized_aggregation to off; -- Vectorized aggregation should work with vectorized filters. select sum(c) from dvagg where b >= 0; select sum(c) from dvagg where b = 0; select sum(c) from dvagg where b in (0, 1); select sum(c) from dvagg where b in (0, 1, 3); select sum(c) from dvagg where b > 10; select count(*) from dvagg where b >= 0; select count(*) from dvagg where b = 0; select count(*) from dvagg where b in (0, 1); select count(*) from dvagg where b in (0, 1, 3); select count(*) from dvagg where b > 10; explain (buffers off, costs off) select sum(c) from dvagg where b in (0, 1, 3); select sum(a), sum(b), sum(c) from dvagg where b in (0, 1, 3); explain (buffers off, costs off) select sum(a), sum(b), sum(c) from dvagg where b in (0, 1, 3); reset timescaledb.enable_vectorized_aggregation; -- The runtime chunk exclusion should work. explain (buffers off, costs off) select sum(c) from dvagg where a < stable_abs(1000); -- The case with HAVING can still be vectorized because it is applied after -- final aggregation. select sum(c) from dvagg having sum(c) > 0; -- Some negative cases. set timescaledb.debug_require_vector_agg to 'forbid'; explain (buffers off, costs off) select sum(c) from dvagg group by grouping sets ((), (a)); -- As a reference, the result on decompressed table. select decompress_chunk(show_chunks('dvagg')); select sum(c) from dvagg; drop table dvagg; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_filter.sql�����������������������������������������������0000664�0000000�0000000�00000013411�15100345067�0022641�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; -- non-vectorizable equality operator create operator === (function = 'int4eq', rightarg = int4, leftarg = int4); -- an abs() function that is stable not immutable create function stable_abs(x int4) returns int4 as 'int4abs' language internal stable; \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table aggfilter(t int, s int, cint2 int2, dropped int4, cint4 int4); select create_hypertable('aggfilter', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, 1 as dropped, (mix(s + t * 1021) * 32767)::int4 as cint4 from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into aggfilter select * from source where s = 1; alter table aggfilter set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('aggfilter') x; alter table aggfilter add column ss int default 11; alter table aggfilter drop column dropped; insert into aggfilter select t, s, cint2, cint4, case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1053 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss from source where s != 1 ; -- print a few reference values before compression select count(ss) from aggfilter; select count(ss) filter (where cint2 < 0) from aggfilter; select count(ss) filter (where cint4 > 0) from aggfilter; select count(ss) filter (where s != 5) from aggfilter; select s, count(ss) from aggfilter group by s having s=2 order by count(ss), s limit 10; select s, count(ss) filter (where cint2 < 0) from aggfilter group by s having s=2 order by count(ss), s limit 10; select s, count(ss) filter (where ss > 1000) from aggfilter group by s having s=2 order by count(ss), s limit 10; select s, count(ss) filter (where cint4 > 0) from aggfilter group by s having s=2 order by count(ss), s limit 10; select count(compress_chunk(x)) from show_chunks('aggfilter') x; vacuum freeze analyze aggfilter; set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; set max_parallel_workers_per_gather = 0; select format('%sselect %s%s(%s)%s from aggfilter%s%s%s;', explain, grouping || ', ', function, variable, ' filter (where ' || agg_filter || ')', ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 's', 'ss', 'cint2', 'cint4', '*']) variable, unnest(array[ 'min', 'count']) function, unnest(array[ null, 'cint2 > 0', 'cint2 is null']) with ordinality as condition(condition, n), unnest(array[ null, 's']) with ordinality as grouping(grouping, n), unnest(array[ null, 'cint2 < 0', 'ss > 1000', 'cint4 > 0', 's != 5']) with ordinality as agg_filter(agg_filter, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') order by explain, condition.n, variable, function, grouping.n, agg_filter.n \gexec reset timescaledb.debug_require_vector_agg; -- FILTER that is not vectorizable set timescaledb.debug_require_vector_agg = 'forbid'; select count(*) filter (where cint2 === 0) from aggfilter; -- FILTER with stable function set timescaledb.debug_require_vector_agg = 'require'; select count(*) filter (where cint2 = stable_abs(0)) from aggfilter; -- With hash grouping select ss, count(*) filter (where s != 5), count(*) filter (where cint2 < 0) from aggfilter group by ss order by 2, 3; reset timescaledb.debug_require_vector_agg; -- Grouping with a scalar UUID column (segmentby or default). create table uuid_default(ts int, value int4) with (tsdb.hypertable, tsdb.partition_column = 'ts', tsdb.compress, tsdb.chunk_interval = 1000); insert into uuid_default select generate_series(0, 999), 1; select count(compress_chunk(x)) from show_chunks('uuid_default') x; alter table uuid_default add column id uuid default '842ab294-923a-4f50-be7d-af6c51903a5f'; alter table uuid_default set (tsdb.compress_segmentby = 'id'); insert into uuid_default select generate_series(1000, 1999), 2, '5dd0565f-1ddf-4a6c-9e96-9b2b8c8c3993'; select count(compress_chunk(x)) from show_chunks('uuid_default') x; set timescaledb.debug_require_vector_agg = 'require'; select id, sum(value) from uuid_default group by id; select sum(value) filter (where id = '5dd0565f-1ddf-4a6c-9e96-9b2b8c8c3993') from uuid_default; select sum(value) filter (where id = '842ab294-923a-4f50-be7d-af6c51903a5f') from uuid_default; reset timescaledb.debug_require_vector_agg; reset max_parallel_workers_per_gather; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_functions.sql��������������������������������������������0000664�0000000�0000000�00000016740�15100345067�0023374�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table aggfns(t int, s int, cint2 int2, cint4 int4, cint8 int8, cfloat4 float4, cts timestamp, ctstz timestamptz, cdate date); select create_hypertable('aggfns', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, (mix(s + t * 1021) * 32767)::int4 as cint4, (mix(s + t * 1031) * 32767)::int8 as cint8, case when s = 1 and t = 1061 then 'nan'::float4 when s = 2 and t = 1061 then '+inf'::float4 when s = 3 and t = 1061 then '-inf'::float4 else (mix(s + t * 1033) * 100::int)::float4 end as cfloat4, '2021-01-01 01:01:01'::timestamp + interval '1 second' * (s * 10000) as cts, '2021-01-01 01:01:01'::timestamptz + interval '1 second' * (s * 10000) as ctstz, '2021-01-01'::date + interval '1 day' * (s * 10000) as cdate from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into aggfns select * from source where s = 1; alter table aggfns set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('aggfns') x; alter table aggfns add column ss int default 11; alter table aggfns add column cfloat8 float8 default '13'; alter table aggfns add column x text default '11'; insert into aggfns select *, ss::text as x from ( select * , case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1053 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss , (mix(s + t * 1039) * 100)::float8 as cfloat8 from source where s != 1 ) t ; -- print some reference results before compression select ss, count(*) from aggfns group by ss having (ss=11 or ss is null) order by count(*), ss limit 10; select ss, min(cdate) from aggfns group by ss having (ss is null) order by min(cdate), ss limit 10; select ss, avg(cfloat4) from aggfns group by ss having (ss is null) order by avg(cfloat4), ss limit 10; select ss, max(cfloat4) from aggfns group by ss having (ss=11 or ss is null) order by max(cfloat4), ss limit 10; select ss, min(cfloat4) from aggfns group by ss having (ss=11 or ss is null) order by min(cfloat4), ss limit 10; select ss, stddev(cfloat4) from aggfns group by ss having (ss is null) order by stddev(cfloat4), ss limit 10; select ss, avg(cfloat8) from aggfns group by ss having (ss is null or ss=11) order by avg(cfloat8), ss limit 10; select ss, max(cfloat8) from aggfns group by ss having (ss is null or ss=11) order by max(cfloat8), ss limit 10; select count(compress_chunk(x)) from show_chunks('aggfns') x; vacuum freeze analyze aggfns; create table edges(t int, s int, ss int, f1 int); select create_hypertable('edges', 't', chunk_time_interval => 100000); alter table edges set (timescaledb.compress, timescaledb.compress_segmentby='s'); insert into edges select s * 1000 + f1 as t, s, s, f1 from generate_series(0, 12) s, lateral generate_series(0, 60 + s + (s / 5::int) * 64 + (s / 10::int) * 2048) f1 ; insert into edges select 200000 t, 111 s, 111 ss, 1 f1; select count(compress_chunk(x)) from show_chunks('edges') x; vacuum freeze analyze edges; -- We can't vectorize some aggregate functions on platforms withouth int128 -- support. Just relax the test requirements for them. I don't want to disable -- this test in release builds, and don't want to have the guc in release builds, -- so we'll assume we have int128 in all release builds. select case when setting::bool then 'require' else 'allow' end guc_value from pg_settings where name = 'timescaledb.debug_have_int128' union all select 'require' guc_value limit 1 \gset set timescaledb.debug_require_vector_agg = :'guc_value'; ---- Uncomment to generate reference. Note that there are minor discrepancies ---- on float4 due to different numeric stability in our and PG implementations. --set timescaledb.enable_chunkwise_aggregation to off; set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'forbid'; set max_parallel_workers_per_gather = 0; -- Disable sorting to force vectorized agg plans for min and max, -- which otherwise can produce a non-vectorized init-plan that does a -- sort with limit 1. set enable_sort = false; select format('%sselect %s%s(%s) from aggfns%s%s%s;', explain, grouping || ', ', function, variable, ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 't', 's', 'ss', 'cint2', 'cint4', 'cint8', 'cfloat4', 'cfloat8', 'cts', 'ctstz', 'cdate', '*']) variable, unnest(array[ 'min', 'max', 'sum', 'avg', 'stddev', 'count']) function, unnest(array[ null, 'cfloat8 > 0', 'cfloat8 <= 0', 'cfloat8 < 1000' /* vectorized qual is true for all rows */, 'cfloat8 > 1000' /* vectorized qual is false for all rows */, 'cint2 is null']) with ordinality as condition(condition, n), unnest(array[ null, 's', 'ss']) with ordinality as grouping(grouping, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') and (variable not in ('t', 'cts', 'ctstz', 'cdate') or function in ('min', 'max')) -- This is not vectorized yet and (variable != 'cint8' or function != 'stddev') and (function != 'count' or variable in ('cint2', 's', '*')) and (condition is distinct from 'cint2 is null' or variable = 'cint2') order by explain, condition.n, variable, function, grouping.n \gexec -- Test multiple aggregate functions as well. select count(*), count(cint2), min(cfloat4), cint2 from aggfns group by cint2 order by count(*) desc, cint2 limit 10 ; -- Test edge cases for various batch sizes and the filter matching around batch -- end. select count(*) from edges; select s, count(*) from edges group by 1 order by 1; select s, count(*), min(f1) from edges where f1 = 63 group by 1 order by 1; select s, count(*), min(f1) from edges where f1 = 64 group by 1 order by 1; select s, count(*), min(f1) from edges where f1 = 65 group by 1 order by 1; select ss, count(*), min(f1) from edges where f1 = 63 group by 1 order by 1; select ss, count(*), min(f1) from edges where f1 = 64 group by 1 order by 1; select ss, count(*), min(f1) from edges where f1 = 65 group by 1 order by 1; reset max_parallel_workers_per_gather; ��������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_groupagg.sql���������������������������������������������0000664�0000000�0000000�00000010461�15100345067�0023171�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Check that the vectorized aggregation works properly in the GroupAggregate -- mode. \pset null $ set max_parallel_workers_per_gather = 0; set enable_hashagg to off; --set timescaledb.enable_vectorized_aggregation to off; --set timescaledb.debug_require_vector_agg to 'forbid'; create table groupagg(t int, s int, value int); select create_hypertable('groupagg', 't', chunk_time_interval => 10000); insert into groupagg select xslow * 10, case when xfast = 13 then null else xfast end, xfast * 7 + xslow * 3 from generate_series(10, 99) xfast, generate_series(1, 1487) xslow ; alter table groupagg set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 's'); select count(compress_chunk(x)) from show_chunks('groupagg') x; vacuum analyze groupagg; set timescaledb.debug_require_vector_agg to 'require'; select s, sum(value) from groupagg group by s order by s limit 10; -- The hash grouping policies do not support the GroupAggregate mode in the -- reverse order. set timescaledb.debug_require_vector_agg to 'forbid'; select s, sum(value) from groupagg group by s order by s desc limit 10; reset timescaledb.debug_require_vector_agg; -- Also test the NULLS FIRST order. select count(decompress_chunk(x)) from show_chunks('groupagg') x; alter table groupagg set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 's nulls first'); select count(compress_chunk(x)) from show_chunks('groupagg') x; vacuum analyze groupagg; set timescaledb.debug_require_vector_agg to 'require'; select s, sum(value) from groupagg group by s order by s nulls first limit 10; reset timescaledb.debug_require_vector_agg; -- More tests for dictionary encoding. create table text_table(ts int, a text); select create_hypertable('text_table', 'ts', chunk_time_interval => 3); alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = 'a'); insert into text_table select -1, 'scalar' from generate_series(1, 1000) x; select count(compress_chunk(x)) from show_chunks('text_table') x; insert into text_table select 1, '' from generate_series(1, 1000) x; insert into text_table select 2, 'same' from generate_series(1, 1000) x; insert into text_table select 3, 'different' || x from generate_series(1, 1000) x; insert into text_table select 4, case when x % 2 = 0 then null else 'samewithnulls' end from generate_series(1, 1000) x; insert into text_table select 5, case when x % 2 = 0 then null else 'differentwithnulls' || x end from generate_series(1, 1000) x; alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'a'); select count(compress_chunk(x)) from show_chunks('text_table') x; vacuum analyze text_table; set timescaledb.debug_require_vector_agg to 'require'; select a, count(*) from text_table group by a order by count(*) desc, a limit 10; -- The hash grouping policies do not support the GroupAggregate mode in the -- reverse order. We have to filter out the chunk where 'a' is segmentby. set timescaledb.debug_require_vector_agg to 'forbid'; select a, count(*) from text_table where ts >= 0 group by a order by a desc limit 10; reset timescaledb.debug_require_vector_agg; reset enable_sort; -- with NULLS FIRST select count(decompress_chunk(x)) from show_chunks('text_table') x; alter table text_table set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 'a nulls first'); select count(compress_chunk(x)) from show_chunks('text_table') x; set timescaledb.debug_require_vector_agg to 'require'; select a, count(*) from text_table group by a order by a nulls first limit 10; reset timescaledb.debug_require_vector_agg; -- TODO verify that this works with the serialized hash grouping strategy set timescaledb.debug_require_vector_agg to 'forbid'; select ts, a, count(*) from text_table group by ts, a order by ts, a limit 10; select a, ts, count(*) from text_table group by a, ts order by a desc, ts desc limit 10; reset timescaledb.debug_require_vector_agg; reset max_parallel_workers_per_gather; reset timescaledb.debug_require_vector_agg; reset enable_hashagg; ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_grouping.sql���������������������������������������������0000664�0000000�0000000�00000015135�15100345067�0023213�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; -- To not confuse null with empty strings in the test reference \pset null $ \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table agggroup(t int, s int, cint2 int2, cint4 int4, cint8 int8); select create_hypertable('agggroup', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, (mix(s + t * 1021) * 32767)::int4 as cint4, (mix(s + t * 1031) * 32767)::int8 as cint8 from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into agggroup select * from source where s = 1; alter table agggroup set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('agggroup') x; alter table agggroup add column ss int default 11; alter table agggroup add column x text default '11'; insert into agggroup select *, ss::text as x from ( select *, case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1051 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss from source where s != 1 ) t ; select count(compress_chunk(x)) from show_chunks('agggroup') x; vacuum freeze analyze agggroup; set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. Note that there are minor discrepancies -- on float4 due to different numeric stability in our and PG implementations. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select format('%sselect %s%s(%s) from agggroup%s%s%s;', explain, grouping || ', ', function, variable, ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 'cint2', '*']) variable, unnest(array[ 'min', 'count']) function, unnest(array[ null, 'cint2 > 0', 'cint2 is null', 'cint2 is null and x is null']) with ordinality as condition(condition, n), unnest(array[ 'cint4, cint2', 'cint4, cint8', 'cint2, cint4, cint8', 's, cint2', 's, ss', 's, x', 'ss, cint2, x', 'ss, s', 'ss, x, cint2', 't, s, ss, x, cint4, cint8, cint2', 'x']) with ordinality as grouping(grouping, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') order by explain, condition.n, variable, function, grouping.n \gexec reset timescaledb.debug_require_vector_agg; -- Test long text columns. Also make one of them a segmentby, so that we can -- test the long scalar values. create table long(t int, a text, b text, c text, d text); select create_hypertable('long', 't'); insert into long select n, a, x, x, x from ( select n, 'short' || m a, repeat('1', 100 * 4 + n) x from generate_series(1, 4) n, generate_series(1, 4) m) t ; insert into long values (-1, 'a', 'b', 'c', 'd'); insert into long values (-2, repeat('long', 1000), 'b', 'c', 'd'); alter table long set (timescaledb.compress, timescaledb.compress_segmentby = 'a', timescaledb.compress_orderby = 't desc'); select count(compress_chunk(x)) from show_chunks('long') x; set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; -- Various placements of long scalar column select sum(t) from long group by a, b, c, d order by 1 limit 10; select sum(t) from long group by d, b, c, a order by 1 limit 10; select sum(t) from long group by d, b, a, c order by 1 limit 10; -- Just the scalar column select sum(t) from long group by a order by 1; -- No scalar columns select sum(t) from long group by b, c, d order by 1 limit 10; reset timescaledb.debug_require_vector_agg; -- Test various serialized key lengths. We want to touch the transition from short -- to long varlena header for the serialized key. create table keylength(t int, a text, b text); select create_hypertable('keylength', 't'); insert into keylength select t, 'a', repeat('b', t) from generate_series(1, 1000) t; insert into keylength values (-1, '', ''); -- second chunk alter table keylength set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 't desc'); select count(compress_chunk(x)) from show_chunks('keylength') x; set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select sum(t) from keylength group by a, b order by 1 desc limit 10; select sum(t) from keylength group by b, a order by 1 desc limit 10; reset timescaledb.debug_require_vector_agg; -- Add a very simple test for NULLs. We also have some null values in the general -- grouping test above. create table groupnull(t int, a text, b text); select create_hypertable('groupnull', 't'); insert into groupnull values (1, '1', null), (2, null, '2'), (3000000, '3', '3'); alter table groupnull set (timescaledb.compress, timescaledb.compress_segmentby = '', timescaledb.compress_orderby = 't desc'); select count(compress_chunk(x)) from show_chunks('groupnull') x; set timescaledb.debug_require_vector_agg = 'require'; -- Uncomment to generate reference. --set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'allow'; select sum(t), a, b from groupnull group by a, b order by 1; select sum(t), a, b from groupnull group by b, a order by 1; reset timescaledb.debug_require_vector_agg; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_memory.sql�����������������������������������������������0000664�0000000�0000000�00000007220�15100345067�0022665�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER --set enable_indexscan=false; -- Helper function that returns the amount of memory currently allocated in a -- given memory context. create or replace function ts_debug_allocated_bytes(text = 'PortalContext') returns bigint as :MODULE_PATHNAME, 'ts_debug_allocated_bytes' language c strict volatile; create table mvagg (t int, s0 int, s1 int); select create_hypertable('mvagg', 't', chunk_time_interval => pow(10, 9)::int); insert into mvagg select generate_series(1, 2 * pow(10, 6)::int) t, 1 s0, 1 s1; -- Need two segmentbys to prevent compressed index scans to force hash aggregation. -- Otherwise we might get GroupAggregate with Sort which uses linear memory in -- the number of compressed batches. alter table mvagg set (timescaledb.compress, timescaledb.compress_segmentby='s0, s1'); -- Need to inflate the estimated cardinalities of segmentby columns, again to -- force the hash aggregation. insert into mvagg select -1 - x t, -x s0, -x s1 from generate_series(1, 1000) x; -- Need two chunks for chunkwise aggregation. insert into mvagg select -1 t, 1 s0, 1 s1; select count(compress_chunk(x)) from show_chunks('mvagg') x; vacuum analyze mvagg; -- We are going to log memory usage as a function of number of aggregated elements -- here. create table log(n int, bytes int, a bigint, b bigint, c bigint, d bigint, e bigint, f bigint); -- First, ensure that the underlying decompression has constant memory usage. explain (buffers off, costs off) select distinct on (s0, s1) ts_debug_allocated_bytes() bytes, s0, s1, t from mvagg where t >= -1 and t < 1000000 order by s0, s1, t desc; truncate log; \set ECHO none select format('insert into log select distinct on (s0, s1) %1$s, ts_debug_allocated_bytes() bytes, 0 a, 0 b, 0 c, 0 d, 0 e, 0 f from mvagg where t >= -1 and t < %1$s order by s0, s1, t desc', pow(10, generate_series(1, 7))) \gexec \set ECHO all select * from log where ( -- Ideally the memory usage should be constant, but we have to allow for -- small spurious changes to make this test more robust. select regr_slope(bytes, n) > 1/65536 from log ); -- Test the vectorized aggregation with grouping by segmentby with various number -- of input row. We expect approximately constant memory usage. truncate log; set max_parallel_workers_per_gather = 0; set timescaledb.debug_require_vector_agg = 'require'; set enable_sort to off; set enable_indexscan to off; set enable_bitmapscan to off; -- We should reliably see HashAggregate here because of the tweaks we made above. explain (buffers off, costs off) select ts_debug_allocated_bytes() bytes, count(*) a, count(t) b, sum(t) c, avg(t) d, min(t) e, max(t) f from mvagg where t >= -1 and t < 1000000 group by s1; \set ECHO none select format('insert into log select %1$s, ts_debug_allocated_bytes() bytes, count(*) a, count(t) b, sum(t) c, avg(t) d, min(t) e, max(t) f from mvagg where t >= -1 and t < %1$s group by s1', pow(10, generate_series(1, 7))) \gexec \set ECHO all reset timescaledb.debug_require_vector_agg; reset max_parallel_workers_per_gather; reset work_mem; reset enable_sort; select * from log where ( -- For aggregation by segmentby, memory usage should be constant regardless -- of the number of tuples. Still, we have to allow for small variations -- that can be caused by other reasons. select regr_slope(bytes, n) > 0.01 from log ); reset timescaledb.debug_require_vector_agg; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_param.sql������������������������������������������������0000664�0000000�0000000�00000003106�15100345067�0022454�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test parameterized vector aggregation plans. create table pvagg(s int, a int); select create_hypertable('pvagg', 'a', chunk_time_interval => 1000); insert into pvagg select 1, generate_series(1, 999); insert into pvagg select 2, generate_series(1001, 1999); alter table pvagg set (timescaledb.compress, timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('pvagg') x; analyze pvagg; -- The reference for this test is generated using the standard Postgres -- aggregation. When you change this test, recheck the results against the -- Postgres aggregation by uncommenting the below GUC. -- set timescaledb.enable_vectorized_aggregation to off; explain (verbose, buffers off, costs off) select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a) from pvagg where s = x) xx; select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a) from pvagg where s = x) xx; explain (verbose, buffers off, costs off) select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a + x) from pvagg) xx; select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a + x) from pvagg) xx; -- The plan for this query differs after PG16, x is not used as grouping key but -- just added into the output targetlist of partial aggregation nodes. select * from unnest(array[0, 1, 2]::int[]) x, lateral (select sum(a) from pvagg group by x) xx; drop table pvagg; ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_segmentby.sql��������������������������������������������0000664�0000000�0000000�00000007177�15100345067�0023365�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table svagg(t int, f int, s int); select create_hypertable('svagg', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); insert into svagg select s * 10000::int + t, (s + t) % 7::int, s from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, -- (values (1), (10)) s(s) generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; alter table svagg set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('svagg') x; analyze svagg; set max_parallel_workers_per_gather = 0; -- Check that the debug GUC actually works. \set ON_ERROR_STOP 0 set timescaledb.debug_require_vector_agg = 'require'; set timescaledb.enable_vectorized_aggregation to off; select sum(t) from svagg; set timescaledb.debug_require_vector_agg = 'forbid'; set timescaledb.enable_vectorized_aggregation to off; select sum(t) from svagg; set timescaledb.debug_require_vector_agg = 'forbid'; set timescaledb.enable_vectorized_aggregation to on; select sum(t) from svagg; set timescaledb.debug_require_vector_agg = 'require'; set timescaledb.enable_vectorized_aggregation to on; select sum(t) from svagg; set timescaledb.debug_require_vector_agg = 'allow'; set timescaledb.enable_vectorized_aggregation to on; select sum(t) from svagg; \set ON_ERROR_STOP 1 set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference --set timescaledb.debug_require_vector_agg = 'forbid'; --set timescaledb.enable_vectorized_aggregation to off; select s, sum(t), count(*) from svagg where f >= 0 group by s order by s; select s, sum(t), count(*) from svagg where f = 0 group by s order by s; select s, sum(t), count(*) from svagg where f in (0, 1) group by s order by s; select s, sum(t), count(*) from svagg where f in (0, 1, 3) group by s order by s; select s, sum(t), count(*) from svagg where f > 10 group by s order by s; select s, sum(t), count(*) from svagg group by s order by s; -- another example that we used not to vectorize because of the projection. explain (buffers off, costs off) select sum(t), s, count(*) from svagg group by s order by s; select sum(t) from svagg group by s order by 1; reset timescaledb.debug_require_vector_agg; -- text segmentby column select count(decompress_chunk(x)) from show_chunks('svagg') x; alter table svagg set (timescaledb.compress = false); alter table svagg add column x text; update svagg set x = repeat(s::text, 100); alter table svagg set (timescaledb.compress, timescaledb.compress_segmentby = 'x'); select count(compress_chunk(x)) from show_chunks('svagg') x; set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference --set timescaledb.debug_require_vector_agg = 'forbid'; --set timescaledb.enable_vectorized_aggregation to off; select substr(x, 1, 2), sum(t), count(*) from svagg where f >= 0 group by x order by x; select substr(x, 1, 2), sum(t), count(*) from svagg where f = 0 group by x order by x; select substr(x, 1, 2), sum(t), count(*) from svagg where f in (0, 1) group by x order by x; select substr(x, 1, 2), sum(t), count(*) from svagg where f in (0, 1, 3) group by x order by x; select substr(x, 1, 2), sum(t), count(*) from svagg where f > 10 group by x order by x; reset timescaledb.debug_require_vector_agg; drop table svagg; �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_text.sql�������������������������������������������������0000664�0000000�0000000�00000012017�15100345067�0022341�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \c :TEST_DBNAME :ROLE_SUPERUSER -- helper function: float -> pseudorandom float [-0.5..0.5] CREATE OR REPLACE FUNCTION mix(x anyelement) RETURNS float8 AS $$ SELECT hashfloat8(x::float8) / pow(2, 32) $$ LANGUAGE SQL; \set CHUNKS 2::int \set CHUNK_ROWS 100000::int \set GROUPING_CARDINALITY 10::int create table agggroup(t int, s int, cint2 int2, cint4 int4, cint8 int8); select create_hypertable('agggroup', 's', chunk_time_interval => :GROUPING_CARDINALITY / :CHUNKS); create view source as select s * 10000 + t as t, s, case when t % 1051 = 0 then null else (mix(s + t * 1019) * 32767)::int2 end as cint2, (mix(s + t * 1021) * 32767)::int4 as cint4, (mix(s + t * 1031) * 32767)::int8 as cint8 from generate_series(1::int, :CHUNK_ROWS * :CHUNKS / :GROUPING_CARDINALITY) t, generate_series(0::int, :GROUPING_CARDINALITY - 1::int) s(s) ; insert into agggroup select * from source where s = 1; alter table agggroup set (timescaledb.compress, timescaledb.compress_orderby = 't', timescaledb.compress_segmentby = 's'); select count(compress_chunk(x)) from show_chunks('agggroup') x; alter table agggroup add column ss int default 11; alter table agggroup add column x text default '11'; insert into agggroup select *, ss::text as x from ( select *, case -- null in entire batch when s = 2 then null -- null for some rows when s = 3 and t % 1051 = 0 then null -- for some rows same as default when s = 4 and t % 1057 = 0 then 11 -- not null for entire batch else s end as ss from source where s != 1 ) t ; -- print a few reference values before compression select x, count(*) from agggroup group by x having (x='11' or x is null) order by count(*), x limit 10; select x, count(cint2) from agggroup group by x having (x='11' or x is null) order by count(cint2), x limit 10; select x, min(cint2) from agggroup group by x having (x='11' or x is null) order by min(cint2), x limit 10; select x, count(*) from agggroup where cint2 > 0 group by x having (x='11' or x is null) order by count(*), x limit 10; select x, count(cint2) from agggroup where cint2 > 0 group by x having (x='11' or x is null) order by count(cint2), x limit 10; select x, min(cint2) from agggroup where cint2 > 0 group by x order by min(cint2), x limit 10; select x, count(*) from agggroup where cint2 is null group by x having (x='11') order by count(*), x limit 10; select x, count(cint2) from agggroup where cint2 is null group by x having (x is null) order by count(cint2), x limit 10; select x, count(*) from agggroup where cint2 is null and x is null group by x order by count(*), x limit 10; select x, count(cint2) from agggroup where cint2 is null and x is null group by x order by count(cint2), x limit 10; select x, min(cint2) from agggroup where cint2 is null and x is null group by x order by min(cint2), x limit 10; select count(compress_chunk(x)) from show_chunks('agggroup') x; vacuum freeze analyze agggroup; -- Long strings create table long(t int, a text, b text, c text, d text); select create_hypertable('long', 't'); insert into long select n, x, x, x, x from ( select n, repeat('1', 100 * 4 + n) x from generate_series(1, 4) n) t ; insert into long values (-1, 'a', 'b', 'c', 'd'); alter table long set (timescaledb.compress); select count(compress_chunk(x)) from show_chunks('long') x; set timescaledb.debug_require_vector_agg = 'require'; ---- Uncomment to generate reference. Note that there are minor discrepancies ---- on float4 due to different numeric stability in our and PG implementations. --set timescaledb.enable_chunkwise_aggregation to off; set timescaledb.enable_vectorized_aggregation to off; set timescaledb.debug_require_vector_agg = 'forbid'; select format('%sselect %s%s(%s) from agggroup%s%s%s;', explain, grouping || ', ', function, variable, ' where ' || condition, ' group by ' || grouping, format(' order by %s(%s), ', function, variable) || grouping || ' limit 10', function, variable) from unnest(array[ 'explain (buffers off, costs off) ', null]) explain, unnest(array[ 'cint2', '*']) variable, unnest(array[ 'min', 'count']) function, unnest(array[ null, 'cint2 > 0', 'cint2 is null', 'cint2 is null and x is null']) with ordinality as condition(condition, n), unnest(array['x']) with ordinality as grouping(grouping, n) where true and (explain is null /* or condition is null and grouping = 's' */) and (variable != '*' or function = 'count') order by explain, condition.n, variable, function, grouping.n \gexec -- Test grouping by long strings select count(*) from long group by a order by 1 limit 10; reset timescaledb.debug_require_vector_agg; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vector_agg_uuid.sql�������������������������������������������������0000664�0000000�0000000�00000010322�15100345067�0022320�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. -- Test grouping by uuid segmentby column (scalar by-reference fixed-width column). CREATE TABLE public.plan_plus( "time" timestamp with time zone NOT NULL, device uuid NOT NULL, field text NOT NULL, value_numeric double precision, value_bool boolean, value_string text, value_geo point, created timestamp with time zone DEFAULT now() ); CREATE INDEX plan_plus_device_time_idx ON public.plan_plus USING btree (device, "time" DESC); CREATE INDEX plan_plus_time_idx ON public.plan_plus USING btree ("time" DESC); SELECT public.create_hypertable( relation => 'public.plan_plus', time_column_name => 'time', create_default_indexes => false ); ALTER TABLE public.plan_plus SET ( timescaledb.compress, timescaledb.compress_segmentby = 'device', timescaledb.compress_orderby='"time" DESC' ); INSERT INTO plan_plus WITH devices AS ( select gen_random_uuid() AS device from generate_series(1, 10) ), fields AS ( select 'field '||f AS field from generate_series(1,100) AS f ) SELECT t, device, field, 10, true, 'value', null, '2025-04-15 00:00:00'::timestamptz FROM generate_series('2025-04-15 00:00:00'::timestamptz - interval '1 month', '2025-04-15 00:00:00'::timestamptz, interval '12 hour') AS t, devices, fields; -- Compress data SELECT count(compress_chunk(c)) FROM show_chunks('plan_plus') AS c; -- Get one of the UUIDs SELECT device FROM plan_plus LIMIT 1 \gset SET timescaledb.debug_require_vector_agg = 'require'; -- Used to segfault SELECT device = :'device'::uuid, field, SUM(value_numeric) AS value FROM plan_plus WHERE device=:'device'::uuid AND field='field 1' AND time > '2024-03-31T00:00:00+00:00'::timestamptz AND time < '2025-04-01T00:01:00+00:00'::timestamptz GROUP BY device, field LIMIT 1; SELECT device = :'device'::uuid, SUM(value_numeric) AS value FROM plan_plus WHERE device=:'device'::uuid AND field='field 1' AND time > '2024-03-31T00:00:00+00:00'::timestamptz AND time < '2025-04-01T00:01:00+00:00'::timestamptz GROUP BY device LIMIT 1; RESET timescaledb.debug_require_vector_agg; SELECT count(*) FROM (SELECT device FROM plan_plus GROUP BY device) t; SELECT count(*) FROM (SELECT device, field FROM plan_plus GROUP BY device, field) t; -- UUID groupping create table uuid_table(ts int, u uuid); select count(*) from create_hypertable('uuid_table', 'ts', chunk_time_interval => 6); alter table uuid_table set (timescaledb.compress); insert into uuid_table values (1, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (2, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (3, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (4, '0197a7a9-b48b-7c71-92cb-eb724822bb0f'), (5, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (6, '0197a7a9-b48b-7c75-a810-8acf630e634f'), (7, '0197a7a9-b48b-7c76-b616-69e64a802b5c'), (8, '0197a7a9-b48b-7c77-b54f-c5f3d64d68d0'), (9, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (10, '0197a7a9-b48b-7c78-ab14-78b3dd81dbbc'), (11, '0197a7a9-b48b-7c7a-8d9e-5afc3bf15234'), (12, '0197a7a9-b48b-7c7b-bc49-7150f16d8d63'), (13, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (14, '0197a7a9-b48b-7c7d-8cfe-9503ed9bb1c9'), (15, '0197a7a9-b48b-7c7e-9ebb-acf63f5b625e'), (16, '0197a7a9-b48b-7c7f-a0c1-ba4adf950a2a'), (17, '01941f29-7c00-706a-bea9-105dad841304'), (18, '01941f2a-665f-7722-b4b5-cf4e70e666d0'), (19, NULL::uuid), (20, NULL::uuid), (21, NULL::uuid); -- add a few derived columns alter table uuid_table add column ver int; alter table uuid_table add column uuid_ts timestamptz; update uuid_table set ver = uuid_version(u) , uuid_ts = uuid_timestamp_micros(u) where u is not null; select count(compress_chunk(x, true)) from show_chunks('uuid_table') x; SET timescaledb.debug_require_vector_agg = 'require'; SELECT ver, u, ts, uuid_ts from uuid_table where uuid_ts < '2025-06-25 16:16:46.347779+01' and ver = 7 order by 1,2; SELECT ver, u, count(*), sum(ts) from uuid_table where uuid_ts < '2025-06-25 16:16:46.347779+01' and ver = 7 group by 1,2 order by 1,2; RESET timescaledb.debug_require_vector_agg; ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/sql/vectorized_aggregation.sql������������������������������������������0000664�0000000�0000000�00000032724�15100345067�0023711�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������-- This file and its contents are licensed under the Timescale License. -- Please see the included NOTICE for copyright information and -- LICENSE-TIMESCALE for a copy of the license. \set EXPLAIN 'EXPLAIN (VERBOSE, BUFFERS OFF, COSTS OFF)' CREATE TABLE testtable ( time timestamptz NOT NULL, segment_by_value integer, int_value integer, float_value double precision); SELECT FROM create_hypertable(relation=>'testtable', time_column_name=> 'time'); ALTER TABLE testtable SET (timescaledb.compress, timescaledb.compress_segmentby='segment_by_value'); INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(-10, 100, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; -- -- Enable this GUC to run this test with Hypercore TAM. The EXPLAINs -- will differ, but the results should not. -- --SET timescaledb.default_hypercore_use_access_method = true; --- -- Tests with some chunks compressed --- SELECT compress_chunk(ch) FROM show_chunks('testtable') ch LIMIT 3; VACUUM ANALYZE testtable; -- Vectorized aggregation possible SELECT sum(segment_by_value) FROM testtable; :EXPLAIN SELECT sum(segment_by_value) FROM testtable; -- Vectorization possible - filter on segment_by :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE segment_by_value > 0; -- Vectorization with filter on compressed columns :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE segment_by_value > 0 AND int_value > 0; :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE int_value > 0; :EXPLAIN SELECT sum(segment_by_value) FROM testtable WHERE float_value > 0; -- Vectorization possible with grouping by one fixed-size column :EXPLAIN SELECT sum(segment_by_value) FROM testtable GROUP BY float_value; :EXPLAIN SELECT sum(segment_by_value) FROM testtable GROUP BY int_value; -- Vectorization possible with grouping by multiple columns :EXPLAIN SELECT sum(segment_by_value) FROM testtable GROUP BY int_value, float_value; -- Vectorization possible with grouping by a segmentby column. :EXPLAIN SELECT sum(int_value) FROM testtable GROUP BY segment_by_value; :EXPLAIN SELECT sum(segment_by_value), segment_by_value FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; SELECT sum(segment_by_value), segment_by_value FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; :EXPLAIN SELECT segment_by_value, sum(segment_by_value) FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; SELECT segment_by_value, sum(segment_by_value) FROM testtable GROUP BY segment_by_value ORDER BY 1, 2; -- Vectorized aggregation possible SELECT sum(int_value) FROM testtable; :EXPLAIN SELECT sum(int_value) FROM testtable; -- Vectorized aggregation possible SELECT sum(float_value) FROM testtable; :EXPLAIN SELECT sum(float_value) FROM testtable; --- -- Tests with all chunks compressed --- SELECT compress_chunk(ch, if_not_compressed => true) FROM show_chunks('testtable') ch; VACUUM ANALYZE testtable; -- Vectorized aggregation possible SELECT sum(segment_by_value) FROM testtable; :EXPLAIN SELECT sum(segment_by_value) FROM testtable; -- Vectorized aggregation possible SELECT sum(int_value) FROM testtable; :EXPLAIN SELECT sum(int_value) FROM testtable; --- -- Tests with some chunks are partially compressed --- INSERT INTO testtable (time, segment_by_value, int_value, float_value) VALUES ('1980-01-02 01:00:00-00', 0, 0, 0); -- Vectorized aggregation possible SELECT sum(segment_by_value) FROM testtable; :EXPLAIN SELECT sum(segment_by_value) FROM testtable; -- Vectorized aggregation possible SELECT sum(int_value) FROM testtable; :EXPLAIN SELECT sum(int_value) FROM testtable; --Vectorized aggregation not possible for expression SELECT sum(abs(int_value)) FROM testtable; :EXPLAIN SELECT sum(abs(int_value)) FROM testtable; -- Vectorized aggregation NOT possible SET timescaledb.enable_vectorized_aggregation = OFF; :EXPLAIN SELECT sum(int_value) FROM testtable; RESET timescaledb.enable_vectorized_aggregation; -- Vectorized aggregation without bulk decompression only possible for -- segmentby columns. SET timescaledb.enable_bulk_decompression = OFF; :EXPLAIN SELECT sum(int_value) FROM testtable; :EXPLAIN SELECT sum(segment_by_value) FROM testtable; SELECT sum(segment_by_value) FROM testtable; RESET timescaledb.enable_bulk_decompression; -- Using the same sum function multiple times is supported by vectorization :EXPLAIN SELECT sum(int_value), sum(int_value) FROM testtable; -- Using the same sum function multiple times is supported by vectorization :EXPLAIN SELECT sum(segment_by_value), sum(segment_by_value) FROM testtable; -- Performing a sum on multiple columns is supported. :EXPLAIN SELECT sum(int_value), sum(segment_by_value) FROM testtable; SELECT sum(int_value), sum(segment_by_value) FROM testtable; -- Using the sum function together with another non-vector capable aggregate is not supported :EXPLAIN SELECT sum(int_value), bit_or(int_value) FROM testtable; -- Using the sum function together with another non-vector capable aggregate is not supported :EXPLAIN SELECT sum(segment_by_value), bit_or(segment_by_value) FROM testtable; --- -- Tests with only negative values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(-10, 0, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; -- Aggregation with vectorization SELECT sum(segment_by_value) FROM testtable; SELECT sum(int_value) FROM testtable; --- -- Tests with only positive values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 10, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; -- Aggregation with vectorization SELECT sum(segment_by_value) FROM testtable; SELECT sum(int_value) FROM testtable; -- Vectorization possible - filter on segment_by :EXPLAIN SELECT sum(int_value) FROM testtable WHERE segment_by_value > 5; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 5; SET timescaledb.enable_vectorized_aggregation = OFF; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 5; RESET timescaledb.enable_vectorized_aggregation; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 10; SET timescaledb.enable_vectorized_aggregation = OFF; SELECT sum(int_value) FROM testtable WHERE segment_by_value > 10; RESET timescaledb.enable_vectorized_aggregation; --- -- Tests with parallel plans --- SET parallel_leader_participation = off; SET min_parallel_table_scan_size = 0; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; :EXPLAIN SELECT sum(segment_by_value) FROM testtable; SELECT sum(segment_by_value) FROM testtable; RESET parallel_leader_participation; RESET min_parallel_table_scan_size; RESET parallel_setup_cost; RESET parallel_tuple_cost; --- -- Tests with only zero values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, 0 AS segment_by_value, 0 AS int_value, 0 AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; -- Aggregation with vectorization SELECT sum(segment_by_value) FROM testtable; SELECT sum(int_value) FROM testtable; --- -- Tests with null values --- TRUNCATE testtable; INSERT INTO testtable SELECT time AS time, value AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 10, 1) AS g2(value) ORDER BY time; -- NULL values for compressed data INSERT INTO testtable SELECT time AS time, value AS segment_by_value, NULL AS int_value, NULL AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 5, 1) AS g2(value) ORDER BY time; -- NULL values for segment_by INSERT INTO testtable SELECT time AS time, NULL AS segment_by_value, value AS int_value, value AS float_value FROM generate_series('1980-01-01 00:00:00-00', '1980-03-01 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(0, 2, 1) AS g2(value) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value), sum(int_value), sum(float_value) FROM testtable; SELECT compress_chunk(ch) FROM show_chunks('testtable') ch; -- Aggregation with vectorization :EXPLAIN SELECT sum(segment_by_value) FROM testtable; :EXPLAIN SELECT sum(int_value) FROM testtable; SELECT sum(segment_by_value) FROM testtable; SELECT sum(int_value) FROM testtable; -- Vectorizable aggregation filters are supported :EXPLAIN SELECT sum(segment_by_value) FILTER (WHERE segment_by_value > 99999) FROM testtable; SET timescaledb.enable_vectorized_aggregation = OFF; SELECT sum(segment_by_value) FILTER (WHERE segment_by_value > 99999) FROM testtable; RESET timescaledb.enable_vectorized_aggregation; SELECT sum(segment_by_value) FILTER (WHERE segment_by_value > 99999) FROM testtable; --- -- Tests with multiple segment by values --- CREATE TABLE testtable2 ( time timestamptz NOT NULL, segment_by_value1 integer NOT NULL, segment_by_value2 integer NOT NULL, int_value integer NOT NULL, float_value double precision NOT NULL); SELECT FROM create_hypertable(relation=>'testtable2', time_column_name=> 'time'); ALTER TABLE testtable2 SET (timescaledb.compress, timescaledb.compress_segmentby='segment_by_value1, segment_by_value2'); INSERT INTO testtable2 SELECT time AS time, value1 AS segment_by_value1, value2 AS segment_by_value2, value1 AS int_value, value1 AS float_value FROM generate_series('1980-01-03 00:00:00-00', '1980-03-04 00:00:00-00', INTERVAL '1 day') AS g1(time), generate_series(-10, 25, 1) AS g2(value1), generate_series(-30, 20, 1) AS g3(value2) ORDER BY time; -- Aggregation result without any vectorization SELECT sum(segment_by_value1), sum(segment_by_value2) FROM testtable2; SELECT compress_chunk(ch) FROM show_chunks('testtable2') ch; ANALYZE testtable2; :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2; SELECT sum(segment_by_value1) FROM testtable2; :EXPLAIN SELECT sum(segment_by_value2) FROM testtable2; SELECT sum(segment_by_value2) FROM testtable2; -- Vectorization possible - filter on segment_by :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 0; :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 0 AND segment_by_value2 > 0; :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 0 AND segment_by_value2 > 0 AND 2>1; -- Vectorization not possible filter on segment_by and compressed value -- Disable parallel worker to get deterministic query plans on i386 SET max_parallel_workers_per_gather = 0; :EXPLAIN SELECT sum(segment_by_value1) FROM testtable2 WHERE segment_by_value1 > 1000 AND int_value > 1000; RESET max_parallel_workers_per_gather; -- Can't group by a system column SELECT sum(float_value) FROM testtable2 GROUP BY tableoid ORDER BY 1 LIMIT 1; -- Postgres versions starting with 16 remove the grouping columns that are -- equated to a constant. Check that our planning code handles this well. SELECT sum(float_value), int_value FROM testtable2 WHERE int_value = 1 GROUP BY int_value; -- -- Test handling of Agg on top of ChunkAppend. This reproduces a crash -- in the vector agg planning code introduced in commit 947f7f400. -- CREATE TABLE testtable3 (time timestamptz, location_id int, device_id int, sensor_id int); SELECT create_hypertable('testtable3', 'time'); ALTER TABLE testtable3 SET (timescaledb.compress_orderby='time', timescaledb.compress_segmentby='location_id'); INSERT INTO testtable3 SELECT t, ceil(random() * 20)::int, ceil(random() * 30)::int, ceil(random() * 20)::int FROM generate_series('2024-01-01'::timestamptz, '2024-01-10'::timestamptz, '1h') AS t; SELECT count(compress_chunk(ch)) FROM show_chunks('testtable3') ch; VACUUM FULL ANALYZE testtable3; EXPLAIN (buffers off, costs off) SELECT (date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour')::timestamp as time, TT.location_id as location_id, TT.device_id as device_id, 0 as sensor_id, date_trunc('day', current_timestamp) as discovered_date FROM testtable3 TT WHERE time >= date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour' GROUP BY TT.location_id, TT.device_id; SELECT (date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour')::timestamp as time, TT.location_id as location_id, TT.device_id as device_id, 0 as sensor_id, date_trunc('day', current_timestamp) as discovered_date FROM testtable3 TT WHERE time >= date_trunc('hour', '2024-01-09'::timestamptz) - interval '1 hour' GROUP BY TT.location_id, TT.device_id \g :TEST_OUTPUT_DIR/vectorized_aggregation_query_result.out ��������������������������������������������timescaledb-2.23.0/tsl/test/src/��������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016423�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/CMakeLists.txt������������������������������������������������������0000664�0000000�0000000�00000001510�15100345067�0021160�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(SOURCES test_chunk_stats.c test_merge_chunk.c compression_unit_test.c compression_sql_test.c decompress_text_test_impl.c test_continuous_agg.c) include(${PROJECT_SOURCE_DIR}/tsl/src/build-defs.cmake) add_library(${TSL_TESTS_LIB_NAME} OBJECT ${SOURCES}) # Since the test library will be linked into the loadable extension module, it # needs to be compiled as position-independent code (e.g., the -fPIC compiler # flag for GCC) set_target_properties(${TSL_TESTS_LIB_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON) target_include_directories(${TSL_TESTS_LIB_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/test/src) target_include_directories(${TSL_TESTS_LIB_NAME} PRIVATE ${PG_INCLUDEDIR}) target_compile_definitions(${TSL_TESTS_LIB_NAME} PUBLIC TS_SUBMODULE) ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/compression_sql_test.c����������������������������������������������0000664�0000000�0000000�00000033702�15100345067�0023053�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <math.h> #include <postgres.h> #include "compression/arrow_c_data_interface.h" #include "compression_sql_test.h" #include <funcapi.h> #include <libpq/pqformat.h> #include <utils/builtins.h> #include <utils/uuid.h> #if !defined(NDEBUG) || defined(TS_COMPRESSION_FUZZING) static int get_compression_algorithm(char *name) { if (pg_strcasecmp(name, "deltadelta") == 0) { return COMPRESSION_ALGORITHM_DELTADELTA; } else if (pg_strcasecmp(name, "gorilla") == 0) { return COMPRESSION_ALGORITHM_GORILLA; } else if (pg_strcasecmp(name, "array") == 0) { return COMPRESSION_ALGORITHM_ARRAY; } else if (pg_strcasecmp(name, "dictionary") == 0) { return COMPRESSION_ALGORITHM_DICTIONARY; } else if (pg_strcasecmp(name, "bool") == 0) { return COMPRESSION_ALGORITHM_BOOL; } else if (pg_strcasecmp(name, "uuid") == 0) { return COMPRESSION_ALGORITHM_UUID; } ereport(ERROR, (errmsg("unknown compression algorithm %s", name))); return _INVALID_COMPRESSION_ALGORITHM; } /* * Specializations of test functions for arithmetic types. */ #define ALGO GORILLA #define CTYPE float8 #define PG_TYPE_PREFIX FLOAT8 #define DATUM_TO_CTYPE DatumGetFloat8 #define IS_FINITE(X) isfinite((double) X) #include "decompress_arithmetic_test_impl.c" #define ALGO DELTADELTA #define CTYPE int64 #define PG_TYPE_PREFIX INT8 #define DATUM_TO_CTYPE DatumGetInt64 #include "decompress_arithmetic_test_impl.c" #define ALGO BOOL #define CTYPE bool #define PG_TYPE_PREFIX BOOL #define DATUM_TO_CTYPE DatumGetBool #define ARROW_GET_VALUE(A, I) (arrow_row_is_valid(((const uint64 *) ((A)->buffers[1])), I)) #include "decompress_arithmetic_test_impl.c" #define ALGO DICTIONARY #define CTYPE pg_uuid_t #define PG_TYPE_PREFIX UUID #define DATUM_TO_CTYPE *DatumGetUUIDP #define IS_NOT_EQUAL(X, Y) (memcmp(&X, &Y, sizeof(pg_uuid_t)) != 0) #include "decompress_arithmetic_test_impl.c" #define ALGO UUID #define CTYPE pg_uuid_t #define PG_TYPE_PREFIX UUID #define DATUM_TO_CTYPE *DatumGetUUIDP #define IS_NOT_EQUAL(X, Y) (memcmp(&X, &Y, sizeof(pg_uuid_t)) != 0) #include "decompress_arithmetic_test_impl.c" /* * The table of the supported testing configurations. We use it to generate * dispatch tables and specializations of test functions. */ #define APPLY_FOR_TYPES(X) \ X(GORILLA, FLOAT8, true) \ X(GORILLA, FLOAT8, false) \ X(DELTADELTA, INT8, true) \ X(DELTADELTA, INT8, false) \ X(ARRAY, TEXT, false) \ X(ARRAY, TEXT, true) \ X(DICTIONARY, TEXT, false) \ X(DICTIONARY, TEXT, true) \ X(DICTIONARY, UUID, false) \ X(DICTIONARY, UUID, true) \ X(BOOL, BOOL, false) \ X(BOOL, BOOL, true) \ X(UUID, UUID, false) \ X(UUID, UUID, true) static int (*get_decompress_fn(int algo, Oid type))(const uint8 *Data, size_t Size, bool bulk) { #define DISPATCH(ALGO, PGTYPE, BULK) \ if (algo == COMPRESSION_ALGORITHM_##ALGO && type == PGTYPE##OID) \ { \ return decompress_##ALGO##_##PGTYPE; \ } APPLY_FOR_TYPES(DISPATCH) elog(ERROR, "no decompression function for compression algorithm %d with element type %d", algo, type); pg_unreachable(); #undef DISPATCH } /* * Read and decompress compressed data from file. Useful for debugging the * results of fuzzing. * The out parameter bytes is volatile because we want to fill it even * if we error out later. */ static void read_compressed_data_file_impl(int algo, Oid type, const char *path, bool bulk, volatile int *bytes, int *rows) { FILE *f = fopen(path, "r"); if (!f) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FILE), errmsg("could not open the file '%s'", path))); } fseek(f, 0, SEEK_END); const size_t fsize = ftell(f); fseek(f, 0, SEEK_SET); /* same as rewind(f); */ *rows = 0; *bytes = fsize; if (fsize == 0) { /* * Skip empty data, because we'll just get "no data left in message" * right away. */ fclose(f); return; } char *string = palloc(fsize + 1); size_t elements_read = fread(string, fsize, 1, f); if (elements_read != 1) { fclose(f); ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FILE), errmsg("failed to read file '%s'", path))); } fclose(f); string[fsize] = 0; *rows = get_decompress_fn(algo, type)((const uint8 *) string, fsize, bulk); } TS_FUNCTION_INFO_V1(ts_read_compressed_data_file); /* Read and decompress compressed data from file -- SQL-callable wrapper. */ Datum ts_read_compressed_data_file(PG_FUNCTION_ARGS) { int rows; int bytes; read_compressed_data_file_impl(get_compression_algorithm(PG_GETARG_CSTRING(0)), PG_GETARG_OID(1), PG_GETARG_CSTRING(2), PG_GETARG_BOOL(3), &bytes, &rows); PG_RETURN_INT32(rows); } TS_FUNCTION_INFO_V1(ts_read_compressed_data_directory); /* * Read and decomrpess all compressed data files from directory. Useful for * checking the fuzzing corpuses in the regression tests. */ Datum ts_read_compressed_data_directory(PG_FUNCTION_ARGS) { /* Output columns of this function. */ enum { out_path = 0, out_bytes, out_rows, out_sqlstate, out_location, _out_columns }; /* Cross-call context for this set-returning function. */ struct user_context { DIR *dp; struct dirent *ep; }; char *name = PG_GETARG_CSTRING(2); const int algo = get_compression_algorithm(PG_GETARG_CSTRING(0)); FuncCallContext *funcctx; struct user_context *c; MemoryContext call_memory_context = CurrentMemoryContext; /* stuff done only on the first call of the function */ if (SRF_IS_FIRSTCALL()) { /* create a function context for cross-call persistence */ funcctx = SRF_FIRSTCALL_INIT(); /* switch to memory context appropriate for multiple function calls */ MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); /* Build a tuple descriptor for our result type */ if (get_call_result_type(fcinfo, NULL, &funcctx->tuple_desc) != TYPEFUNC_COMPOSITE) ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context " "that cannot accept type record"))); /* * generate attribute metadata needed later to produce tuples from raw * C strings */ funcctx->attinmeta = TupleDescGetAttInMetadata(funcctx->tuple_desc); funcctx->user_fctx = palloc(sizeof(struct user_context)); c = funcctx->user_fctx; c->dp = opendir(name); if (!c->dp) { elog(ERROR, "could not open directory '%s'", name); } MemoryContextSwitchTo(call_memory_context); } funcctx = SRF_PERCALL_SETUP(); c = (struct user_context *) funcctx->user_fctx; Datum values[_out_columns] = { 0 }; bool nulls[_out_columns] = { 0 }; for (int i = 0; i < _out_columns; i++) { nulls[i] = true; } while ((c->ep = readdir(c->dp))) { if (c->ep->d_name[0] == '.') { continue; } char *path = psprintf("%s/%s", name, c->ep->d_name); /* The return values are: path, ret, sqlstate, status, location. */ values[out_path] = PointerGetDatum(cstring_to_text(path)); nulls[out_path] = false; int rows; volatile int bytes = 0; PG_TRY(); { read_compressed_data_file_impl(algo, PG_GETARG_OID(1), path, PG_GETARG_BOOL(3), &bytes, &rows); values[out_rows] = Int32GetDatum(rows); nulls[out_rows] = false; } PG_CATCH(); { MemoryContextSwitchTo(call_memory_context); ErrorData *error = CopyErrorData(); FlushErrorState(); values[out_sqlstate] = PointerGetDatum(cstring_to_text(unpack_sql_state(error->sqlerrcode))); nulls[out_sqlstate] = false; if (error->filename) { values[out_location] = PointerGetDatum( cstring_to_text(psprintf("%s:%d", error->filename, error->lineno))); nulls[out_location] = false; } FreeErrorData(error); } PG_END_TRY(); values[out_bytes] = Int32GetDatum(bytes); nulls[out_bytes] = false; SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(heap_form_tuple(funcctx->tuple_desc, values, nulls))); } (void) closedir(c->dp); SRF_RETURN_DONE(funcctx); } #endif #ifdef TS_COMPRESSION_FUZZING /* * Fuzzing target for all supported types. */ static int target_generic(const uint8 *Data, size_t Size, CompressionAlgorithm requested_algo, Oid pg_type, bool bulk) { StringInfoData si = { .data = (char *) Data, .len = Size }; const CompressionAlgorithm data_algo = pq_getmsgbyte(&si); CheckCompressedData(data_algo > 0 && data_algo < _END_COMPRESSION_ALGORITHMS); if (data_algo != requested_algo) { /* * It's convenient to fuzz only one algorithm at a time. We specialize * the fuzz target for one algorithm, so that the fuzzer doesn't waste * time discovering others from scratch. */ return -1; } const CompressionAlgorithmDefinition *def = algorithm_definition(data_algo); Datum compressed_data = def->compressed_data_recv(&si); if (bulk) { DecompressAllFunction decompress_all = tsl_get_decompress_all_function(data_algo, pg_type); decompress_all(compressed_data, pg_type, CurrentMemoryContext); return 0; } DecompressionIterator *iter = def->iterator_init_forward(compressed_data, pg_type); for (DecompressResult r = iter->try_next(iter); !r.is_done; r = iter->try_next(iter)) ; return 0; } /* * This is a wrapper for fuzzing target. It will called by the libfuzzer driver. * It has to catch the postgres exceptions normally produced for corrupt data. */ static int target_wrapper(const uint8_t *Data, size_t Size, CompressionAlgorithm requested_algo, Oid pg_type, bool bulk) { MemoryContextReset(CurrentMemoryContext); int res = 0; PG_TRY(); { CHECK_FOR_INTERRUPTS(); res = target_generic(Data, Size, requested_algo, pg_type, bulk); } PG_CATCH(); { /* EmitErrorReport(); */ FlushErrorState(); } PG_END_TRY(); /* * -1 means "don't include it into corpus", return it if the test function * says so, otherwise return 0. Some test functions also returns the number * of rows for the correct data, the fuzzer doesn't understand these values. */ return res == -1 ? -1 : 0; } /* * Specializations of fuzzing targets for supported types that will be directly * called by the fuzzing driver. */ #define DECLARE_TARGET(ALGO, PGTYPE, BULK) \ static int target_##ALGO##_##PGTYPE##_##BULK(const uint8_t *D, size_t S) \ { \ return target_wrapper(D, S, COMPRESSION_ALGORITHM_##ALGO, PGTYPE##OID, BULK); \ } APPLY_FOR_TYPES(DECLARE_TARGET) #undef DECLARE_TARGET /* * libfuzzer fuzzing driver that we import from LLVM libraries. It will run our * test functions with random inputs. */ extern int LLVMFuzzerRunDriver(int *argc, char ***argv, int (*UserCb)(const uint8_t *Data, size_t Size)); /* * The SQL function to perform fuzzing. */ TS_FUNCTION_INFO_V1(ts_fuzz_compression); Datum ts_fuzz_compression(PG_FUNCTION_ARGS) { /* * We use the memory context size larger than default here, so that all data * allocated by fuzzing fit into the first chunk. The first chunk is not * deallocated when the memory context is reset, so this reduces overhead * caused by repeated reallocations. * The particular value of 8MB is somewhat arbitrary and large. In practice, * we have inputs of 1k rows max here, which decompress to 8 kB max. */ MemoryContext fuzzing_context = AllocSetContextCreate(CurrentMemoryContext, "fuzzing", 0, 8 * 1024 * 1024, 8 * 1024 * 1024); MemoryContext old_context = MemoryContextSwitchTo(fuzzing_context); char *argvdata[] = { "PostgresFuzzer", "-timeout=1", "-report_slow_units=1", // "-use_value_profile=1", "-reload=1", //"-print_coverage=1", //"-print_full_coverage=1", //"-print_final_stats=1", //"-help=1", psprintf("-runs=%d", PG_GETARG_INT32(3)), "corpus" /* in the database directory */, NULL }; char **argv = argvdata; int argc = sizeof(argvdata) / sizeof(*argvdata) - 1; int algo = get_compression_algorithm(PG_GETARG_CSTRING(0)); Oid type = PG_GETARG_OID(1); bool bulk = PG_GETARG_BOOL(2); int (*target)(const uint8_t *, size_t) = NULL; #define DISPATCH(ALGO, PGTYPE, BULK) \ if (algo == COMPRESSION_ALGORITHM_##ALGO && type == PGTYPE##OID && bulk == BULK) \ { \ target = target_##ALGO##_##PGTYPE##_##BULK; \ } APPLY_FOR_TYPES(DISPATCH) #undef DISPATCH if (target == NULL) { elog(ERROR, "no llvm fuzz target for compression algorithm %d and type %d", algo, type); } int res = LLVMFuzzerRunDriver(&argc, &argv, target); MemoryContextSwitchTo(old_context); PG_RETURN_INT32(res); } #endif ��������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/compression_sql_test.h����������������������������������������������0000664�0000000�0000000�00000000735�15100345067�0023060�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #pragma once #include "compression/compression.h" int decompress_ARRAY_TEXT(const uint8 *Data, size_t Size, bool bulk); int decompress_DICTIONARY_TEXT(const uint8 *Data, size_t Size, bool bulk); const CompressionAlgorithmDefinition *algorithm_definition(CompressionAlgorithm algo); �����������������������������������timescaledb-2.23.0/tsl/test/src/compression_unit_test.c���������������������������������������������0000664�0000000�0000000�00000156535�15100345067�0023245�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/heapam.h> #include <access/htup_details.h> #include <catalog/pg_type.h> #include <fmgr.h> #include <guc.h> #include <lib/stringinfo.h> #include <libpq/pqformat.h> #include <utils/array.h> #include <utils/builtins.h> #include <utils/lsyscache.h> #include <utils/rel.h> #include <utils/syscache.h> #include <utils/typcache.h> #include "test_utils.h" #include "ts_catalog/catalog.h" #include <export.h> #include "compression/algorithms/array.h" #include "compression/algorithms/bool_compress.h" #include "compression/algorithms/deltadelta.h" #include "compression/algorithms/dictionary.h" #include "compression/algorithms/float_utils.h" #include "compression/algorithms/gorilla.h" #include "compression/algorithms/null.h" #include "compression/algorithms/simple8b_rle.h" #include "compression/algorithms/uuid_compress.h" #include "compression/arrow_c_data_interface.h" #include "compression/batch_metadata_builder_minmax.h" #include "uuid.h" #define TEST_ELEMENTS 1015 TS_FUNCTION_INFO_V1(ts_test_compression); static void test_int_array() { ArrayCompressor *compressor = array_compressor_alloc(INT4OID); ArrayCompressed *compressed; DecompressionIterator *iter; int i; for (i = 0; i < TEST_ELEMENTS; i++) array_compressor_append(compressor, Int32GetDatum(i)); compressed = array_compressor_finish(compressor); TestAssertTrue(compressed != NULL); i = 0; iter = tsl_array_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), INT4OID); for (DecompressResult r = array_decompression_iterator_try_next_forward(iter); !r.is_done; r = array_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt32(r.val), i); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); iter = tsl_array_decompression_iterator_from_datum_reverse(PointerGetDatum(compressed), INT4OID); for (DecompressResult r = array_decompression_iterator_try_next_reverse(iter); !r.is_done; r = array_decompression_iterator_try_next_reverse(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt32(r.val), i - 1); i -= 1; } TestAssertInt64Eq(i, 0); } static void test_string_array() { ArrayCompressor *compressor = array_compressor_alloc(TEXTOID); ArrayCompressed *compressed; DecompressionIterator *iter; char *strings[5] = { "a", "foo", "bar", "gobble gobble gobble", "baz" }; text *texts[5]; int i; for (i = 0; i < 5; i++) texts[i] = cstring_to_text(strings[i]); for (i = 0; i < TEST_ELEMENTS; i++) array_compressor_append(compressor, PointerGetDatum(texts[i % 5])); compressed = array_compressor_finish(compressor); TestAssertTrue(compressed != NULL); i = 0; iter = tsl_array_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), TEXTOID); for (DecompressResult r = array_decompression_iterator_try_next_forward(iter); !r.is_done; r = array_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); if (strcmp(TextDatumGetCString(r.val), strings[i % 5]) != 0) elog(ERROR, "%4d \"%s\" != \"%s\" @ %d", i, TextDatumGetCString(r.val), strings[i % 5], __LINE__); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); iter = tsl_array_decompression_iterator_from_datum_reverse(PointerGetDatum(compressed), TEXTOID); for (DecompressResult r = array_decompression_iterator_try_next_reverse(iter); !r.is_done; r = array_decompression_iterator_try_next_reverse(iter)) { TestAssertTrue(!r.is_null); if (strcmp(TextDatumGetCString(r.val), strings[(i - 1) % 5]) != 0) elog(ERROR, "%4d \"%s\" != \"%s\" @ %d", i, TextDatumGetCString(r.val), strings[i % 5], __LINE__); i -= 1; } TestAssertInt64Eq(i, 0); } static void test_int_dictionary() { DictionaryCompressor *compressor = dictionary_compressor_alloc(INT4OID); DictionaryCompressed *compressed; DecompressionIterator *iter; int i; for (i = 0; i < TEST_ELEMENTS; i++) dictionary_compressor_append(compressor, Int32GetDatum(i % 15)); compressed = dictionary_compressor_finish(compressor); TestAssertTrue(compressed != NULL); i = 0; iter = tsl_dictionary_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), INT4OID); for (DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); !r.is_done; r = dictionary_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt32(r.val), i % 15); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); } static void test_string_dictionary() { DictionaryCompressor *compressor = dictionary_compressor_alloc(TEXTOID); DictionaryCompressed *compressed; DecompressionIterator *iter; char *strings[5] = { "a", "foo", "bar", "gobble gobble gobble", "baz" }; text *texts[5]; int i; for (i = 0; i < 5; i++) texts[i] = cstring_to_text(strings[i]); for (i = 0; i < 1014; i++) dictionary_compressor_append(compressor, PointerGetDatum(texts[i % 5])); compressed = dictionary_compressor_finish(compressor); TestAssertTrue(compressed != NULL); i = 0; iter = tsl_dictionary_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), TEXTOID); for (DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); !r.is_done; r = dictionary_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); if (strcmp(TextDatumGetCString(r.val), strings[i % 5]) != 0) elog(ERROR, "%4d \"%s\" != \"%s\" @ %d", i, TextDatumGetCString(r.val), strings[i % 5], __LINE__); i += 1; } TestAssertInt64Eq(i, 1014); iter = tsl_dictionary_decompression_iterator_from_datum_reverse(PointerGetDatum(compressed), TEXTOID); for (DecompressResult r = dictionary_decompression_iterator_try_next_reverse(iter); !r.is_done; r = dictionary_decompression_iterator_try_next_reverse(iter)) { TestAssertTrue(!r.is_null); if (strcmp(TextDatumGetCString(r.val), strings[(i - 1) % 5]) != 0) elog(ERROR, "%4d \"%s\" != \"%s\" @ %d", i, TextDatumGetCString(r.val), strings[i % 5], __LINE__); i -= 1; } TestAssertInt64Eq(i, 0); TestEnsureError(dictionary_compressor_alloc(CSTRINGOID)); } static void test_gorilla_int() { GorillaCompressor *compressor = gorilla_compressor_alloc(); GorillaCompressed *compressed; DecompressionIterator *iter; uint32 i; for (i = 0; i < TEST_ELEMENTS; i++) gorilla_compressor_append_value(compressor, i); compressed = gorilla_compressor_finish(compressor); TestAssertTrue(compressed != NULL); TestAssertInt64Eq(VARSIZE(compressed), 1312); i = 0; iter = gorilla_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), INT8OID); for (DecompressResult r = gorilla_decompression_iterator_try_next_forward(iter); !r.is_done; r = gorilla_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt64(r.val), i); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); iter = gorilla_decompression_iterator_from_datum_reverse(PointerGetDatum(compressed), INT8OID); for (DecompressResult r = gorilla_decompression_iterator_try_next_reverse(iter); !r.is_done; r = gorilla_decompression_iterator_try_next_reverse(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt64(r.val), i - 1); i -= 1; } TestAssertInt64Eq(i, 0); { StringInfoData buf; bytea *sent; StringInfoData transmission; GorillaCompressed *compressed_recv; pq_begintypsend(&buf); gorilla_compressed_send((CompressedDataHeader *) compressed, &buf); sent = pq_endtypsend(&buf); transmission = (StringInfoData){ .data = VARDATA(sent), .len = VARSIZE(sent), .maxlen = VARSIZE(sent), }; compressed_recv = (GorillaCompressed *) DatumGetPointer(gorilla_compressed_recv(&transmission)); iter = gorilla_decompression_iterator_from_datum_forward(PointerGetDatum(compressed_recv), INT8OID); for (DecompressResult r = gorilla_decompression_iterator_try_next_forward(iter); !r.is_done; r = gorilla_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt64(r.val), i); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); } } static void test_gorilla_float() { GorillaCompressor *compressor = gorilla_compressor_alloc(); GorillaCompressed *compressed; DecompressionIterator *iter; for (int x = 0; x < TEST_ELEMENTS; x++) gorilla_compressor_append_value(compressor, float_get_bits((float) x)); compressed = gorilla_compressor_finish(compressor); TestAssertTrue(compressed != NULL); TestAssertInt64Eq(VARSIZE(compressed), 1168); float i = 0; iter = gorilla_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), FLOAT4OID); for (DecompressResult r = gorilla_decompression_iterator_try_next_forward(iter); !r.is_done; r = gorilla_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertDoubleEq(DatumGetFloat4(r.val), i); i += 1.0; } TestAssertInt64Eq(i, TEST_ELEMENTS); iter = gorilla_decompression_iterator_from_datum_reverse(PointerGetDatum(compressed), FLOAT4OID); for (DecompressResult r = gorilla_decompression_iterator_try_next_reverse(iter); !r.is_done; r = gorilla_decompression_iterator_try_next_reverse(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetFloat4(r.val), i - 1); i -= 1; } TestAssertInt64Eq(i, 0); } static uint64 test_hash64(uint64 x) { x ^= x >> 30; x *= 0xbf58476d1ce4e5b9U; x ^= x >> 27; x *= 0x94d049bb133111ebU; x ^= x >> 31; return x; } static void test_gorilla_double(bool have_nulls, bool have_random) { GorillaCompressor *compressor = gorilla_compressor_alloc(); GorillaCompressed *compressed; double values[TEST_ELEMENTS]; bool nulls[TEST_ELEMENTS]; for (int i = 0; i < TEST_ELEMENTS; i++) { if (have_random) { /* Also add some stretches of equal numbers. */ int base = i; if (i % 37 < 3) { base = 1; } else if (i % 53 < 2) { base = 2; } values[i] = (test_hash64(base) / (double) PG_UINT64_MAX) * 100.; } else { values[i] = i; } if (have_nulls && i % 29 == 0) { nulls[i] = true; } else { nulls[i] = false; } if (nulls[i]) { gorilla_compressor_append_null(compressor); } else { gorilla_compressor_append_value(compressor, double_get_bits(values[i])); } } compressed = gorilla_compressor_finish(compressor); TestAssertTrue(compressed != NULL); if (!have_nulls && !have_random) { TestAssertInt64Eq(VARSIZE(compressed), 1176); } /* Forward decompression. */ DecompressionIterator *iter = gorilla_decompression_iterator_from_datum_forward(PointerGetDatum(compressed), FLOAT8OID); ArrowArray *bulk_result = gorilla_decompress_all(PointerGetDatum(compressed), FLOAT8OID, CurrentMemoryContext); for (int i = 0; i < TEST_ELEMENTS; i++) { DecompressResult r = gorilla_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); if (r.is_null) { TestAssertTrue(nulls[i]); TestAssertTrue(!arrow_row_is_valid(bulk_result->buffers[0], i)); } else { TestAssertTrue(!nulls[i]); TestAssertTrue(arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(values[i] == DatumGetFloat8(r.val)); TestAssertTrue(values[i] == ((double *) bulk_result->buffers[1])[i]); } } DecompressResult r = gorilla_decompression_iterator_try_next_forward(iter); TestAssertTrue(r.is_done); /* Reverse decompression. */ iter = gorilla_decompression_iterator_from_datum_reverse(PointerGetDatum(compressed), FLOAT8OID); for (int i = TEST_ELEMENTS - 1; i >= 0; i--) { DecompressResult r = gorilla_decompression_iterator_try_next_reverse(iter); TestAssertTrue(!r.is_done); if (r.is_null) { TestAssertTrue(nulls[i]); } else { TestAssertTrue(!nulls[i]); TestAssertTrue(values[i] == DatumGetFloat8(r.val)); } } r = gorilla_decompression_iterator_try_next_reverse(iter); TestAssertTrue(r.is_done); } static void test_delta() { DeltaDeltaCompressor *compressor = delta_delta_compressor_alloc(); Datum compressed; DecompressionIterator *iter; int i; for (i = 0; i < TEST_ELEMENTS; i++) delta_delta_compressor_append_value(compressor, i); TestAssertInt64Eq(delta_delta_compressor_compressed_size(compressor, NULL), 56); compressed = DirectFunctionCall1(tsl_deltadelta_compressor_finish, PointerGetDatum(compressor)); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertInt64Eq(VARSIZE(DatumGetPointer(compressed)), 56); i = 0; iter = delta_delta_decompression_iterator_from_datum_forward(compressed, INT8OID); for (DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); !r.is_done; r = delta_delta_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt64(r.val), i); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); } static void test_delta2() { DeltaDeltaCompressor *compressor = delta_delta_compressor_alloc(); Datum compressed; DecompressionIterator *iter; int i; for (i = 0; i < TEST_ELEMENTS; i++) { /* prevent everything from being rle'd away */ if (i % 2 != 0) delta_delta_compressor_append_value(compressor, 2 * i); else delta_delta_compressor_append_value(compressor, i); } size_t calc_size = delta_delta_compressor_compressed_size(compressor, NULL); compressed = DirectFunctionCall1(tsl_deltadelta_compressor_finish, PointerGetDatum(compressor)); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertInt64Eq(VARSIZE(DatumGetPointer(compressed)), 1664); TestAssertInt64Eq(calc_size, 1664); i = 0; iter = delta_delta_decompression_iterator_from_datum_forward(compressed, INT8OID); for (DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); !r.is_done; r = delta_delta_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); if (i % 2 != 0) TestAssertInt64Eq(DatumGetInt64(r.val), 2 * i); else TestAssertInt64Eq(DatumGetInt64(r.val), i); i += 1; } TestAssertInt64Eq(i, TEST_ELEMENTS); } static void test_delta3(bool have_nulls, bool have_random) { DeltaDeltaCompressor *compressor = delta_delta_compressor_alloc(); Datum compressed; size_t compressed_size; int64 values[TEST_ELEMENTS]; bool nulls[TEST_ELEMENTS]; for (int i = 0; i < TEST_ELEMENTS; i++) { if (have_random) { /* Also add some stretches of equal numbers. */ int base = i; if (i % 37 < 4) { base = 1; } else if (i % 53 < 2) { base = 2; } values[i] = test_hash64(base); } else { values[i] = i; } if (have_nulls && i % 29 == 0) { nulls[i] = true; } else { nulls[i] = false; } if (nulls[i]) { delta_delta_compressor_append_null(compressor); } else { delta_delta_compressor_append_value(compressor, values[i]); } } size_t nulls_size; compressed_size = delta_delta_compressor_compressed_size(compressor, &nulls_size); TestAssertInt64Eq(compressed_size, delta_delta_compressor_compressed_size(compressor, NULL)); compressed = PointerGetDatum(delta_delta_compressor_finish(compressor)); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertInt64Eq(VARSIZE(DatumGetPointer(compressed)), compressed_size); /* Forward decompression. */ DecompressionIterator *iter = delta_delta_decompression_iterator_from_datum_forward(compressed, INT8OID); ArrowArray *bulk_result = delta_delta_decompress_all(compressed, INT8OID, CurrentMemoryContext); for (int i = 0; i < TEST_ELEMENTS; i++) { DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); if (r.is_null) { TestAssertTrue(nulls[i]); TestAssertTrue(!arrow_row_is_valid(bulk_result->buffers[0], i)); } else { TestAssertTrue(!nulls[i]); TestAssertTrue(arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(values[i] == DatumGetInt64(r.val)); TestAssertTrue(values[i] == ((int64 *) bulk_result->buffers[1])[i]); } } DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); TestAssertTrue(r.is_done); /* Reverse decompression. */ iter = delta_delta_decompression_iterator_from_datum_reverse(compressed, INT8OID); for (int i = TEST_ELEMENTS - 1; i >= 0; i--) { DecompressResult r = delta_delta_decompression_iterator_try_next_reverse(iter); TestAssertTrue(!r.is_done); if (r.is_null) { TestAssertTrue(nulls[i]); } else { TestAssertTrue(!nulls[i]); TestAssertTrue(values[i] == DatumGetInt64(r.val)); } } r = delta_delta_decompression_iterator_try_next_reverse(iter); TestAssertTrue(r.is_done); } static int32 test_delta4_case1[] = { -603979776, 1462059044 }; static int32 test_delta4_case2[] = { 0x7979fd07, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x79797979, 0x50505050, 0xc4c4c4c4, 0xc4c4c4c4, 0x50505050, 0x50505050, 0xc4c4c4c4, }; static void test_delta4(const int32 *values, int n) { Compressor *compressor = delta_delta_compressor_for_type(INT4OID); for (int i = 0; i < n; i++) { compressor->append_val(compressor, Int32GetDatum(values[i])); } Datum compressed = (Datum) compressor->finish(compressor); ArrowArray *arrow = delta_delta_decompress_all(compressed, INT4OID, CurrentMemoryContext); DecompressionIterator *iter = delta_delta_decompression_iterator_from_datum_forward(compressed, INT4OID); int i = 0; for (DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); !r.is_done; r = delta_delta_decompression_iterator_try_next_forward(iter)) { TestAssertTrue(!r.is_null); TestAssertTrue(i < arrow->length); TestAssertTrue(((int32 *) arrow->buffers[1])[i] == DatumGetInt32(r.val)); TestAssertTrue(arrow_row_is_valid(arrow->buffers[0], i)); TestAssertTrue(values[i] == DatumGetInt32(r.val)); i++; } TestAssertTrue(i == arrow->length); TestAssertTrue(i == n); } static void test_bool_rle(bool nulls, int run_length, int expected_size) { Compressor *compressor = bool_compressor_for_type(BOOLOID); int rlen = run_length; bool val = true; int64 compressed_null_count = 0; for (int i = 0; i < TEST_ELEMENTS; ++i) { if (rlen == 0) { if (nulls) { compressor->append_null(compressor); ++compressed_null_count; } else compressor->append_val(compressor, BoolGetDatum(val)); rlen = run_length; val = !val; } else { compressor->append_val(compressor, BoolGetDatum(val)); --rlen; } } Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertInt64Eq(VARSIZE(DatumGetPointer(compressed)), expected_size); rlen = run_length; val = true; DecompressionIterator *iter = bool_decompression_iterator_from_datum_forward(compressed, BOOLOID); ArrowArray *bulk_result = bool_decompress_all(compressed, BOOLOID, CurrentMemoryContext); const uint64 *bulk_data = bulk_result->buffers[1]; int64 decompressed_null_count = 0; for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = bool_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); if (rlen == 0) { if (nulls) { TestAssertTrue(!arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(r.is_null); ++decompressed_null_count; } else { TestAssertTrue(arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(DatumGetBool(r.val) == val); const int16 block = i / 64; const int16 offset = i % 64; TestAssertTrue(((bulk_data[block] >> offset) & 1UL) == (int) val); } rlen = run_length; val = !val; } else { TestAssertTrue(arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(r.is_null == false); TestAssertTrue(DatumGetBool(r.val) == val); const int16 block = i / 64; const int16 offset = i % 64; TestAssertTrue(((bulk_data[block] >> offset) & 1UL) == (int) val); --rlen; } } TestAssertInt64Eq(decompressed_null_count, compressed_null_count); TestAssertInt64Eq(bulk_result->null_count, compressed_null_count); DecompressResult r = bool_decompression_iterator_try_next_forward(iter); TestAssertTrue(r.is_done); } static void test_bool_array(bool nulls, int run_length, int expected_size) { Compressor *compressor = array_compressor_for_type(BOOLOID); int rlen = run_length; bool val = true; for (int i = 0; i < TEST_ELEMENTS; ++i) { if (rlen == 0) { if (nulls) compressor->append_null(compressor); else compressor->append_val(compressor, BoolGetDatum(val)); rlen = run_length; val = !val; } else { compressor->append_val(compressor, BoolGetDatum(val)); --rlen; } } Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertInt64Eq(VARSIZE(DatumGetPointer(compressed)), expected_size); rlen = run_length; val = true; DecompressionIterator *iter = tsl_array_decompression_iterator_from_datum_forward(compressed, BOOLOID); ArrowArray *bulk_result = tsl_array_decompress_all(compressed, BOOLOID, CurrentMemoryContext); const uint64 *bulk_data = bulk_result->buffers[1]; for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = array_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); if (rlen == 0) { if (nulls) { TestAssertTrue(!arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(r.is_null); } else { TestAssertTrue(DatumGetBool(r.val) == val); const int16 block = i / 64; const int16 offset = i % 64; TestAssertTrue(((bulk_data[block] >> offset) & 1UL) == (int) val); } rlen = run_length; val = !val; } else { TestAssertTrue(r.is_null == false); TestAssertTrue(DatumGetBool(r.val) == val); const int16 block = i / 64; const int16 offset = i % 64; TestAssertTrue(((bulk_data[block] >> offset) & 1UL) == (int) val); --rlen; } } DecompressResult r = array_decompression_iterator_try_next_forward(iter); TestAssertTrue(r.is_done); } static void test_bool_dictionary(bool nulls, int run_length, int expected_size) { Compressor *compressor = dictionary_compressor_for_type(BOOLOID); int rlen = run_length; bool val = true; for (int i = 0; i < TEST_ELEMENTS; ++i) { if (rlen == 0) { if (nulls) compressor->append_null(compressor); else compressor->append_val(compressor, BoolGetDatum(val)); rlen = run_length; val = !val; } else { compressor->append_val(compressor, BoolGetDatum(val)); --rlen; } } Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertInt64Eq(VARSIZE(DatumGetPointer(compressed)), expected_size); rlen = run_length; val = true; DecompressionIterator *iter = tsl_dictionary_decompression_iterator_from_datum_forward(compressed, BOOLOID); ArrowArray *bulk_result = tsl_dictionary_decompress_all(compressed, BOOLOID, CurrentMemoryContext); const uint64 *bulk_data = bulk_result->buffers[1]; for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); if (rlen == 0) { if (nulls) { TestAssertTrue(!arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(r.is_null); } else { TestAssertTrue(DatumGetBool(r.val) == val); const int16 block = i / 64; const int16 offset = i % 64; TestAssertTrue(((bulk_data[block] >> offset) & 1UL) == (int) val); } rlen = run_length; val = !val; } else { TestAssertTrue(r.is_null == false); TestAssertTrue(DatumGetBool(r.val) == val); const int16 block = i / 64; const int16 offset = i % 64; TestAssertTrue(((bulk_data[block] >> offset) & 1UL) == (int) val); --rlen; } } DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); TestAssertTrue(r.is_done); } static void test_empty_bool_compressor() { /* This returns an ExtendedCompressor from bool_compress.c */ Compressor *compressor = bool_compressor_for_type(BOOLOID); Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) == NULL); /* further abusing finish: */ compressed = (Datum) compressor->finish(NULL); TestAssertTrue(DatumGetPointer(compressed) == NULL); /* make codecov happy */ TestAssertTrue(bool_compressor_finish(NULL) == NULL); /* Passing a NULL pointer returns NULL. */ TestEnsureError(DirectFunctionCall1(tsl_bool_compressor_finish, PointerGetDatum(NULL))); TestEnsureError(bool_compressor_for_type(FLOAT4OID)); bool old_val = ts_guc_enable_bool_compression; ts_guc_enable_bool_compression = true; TestAssertTrue(compression_get_default_algorithm(BOOLOID) == COMPRESSION_ALGORITHM_BOOL); ts_guc_enable_bool_compression = false; TestAssertTrue(compression_get_default_algorithm(BOOLOID) == COMPRESSION_ALGORITHM_ARRAY); ts_guc_enable_bool_compression = old_val; } static void test_bool_compressor_extended() { Compressor *compressor = bool_compressor_for_type(BOOLOID); void *finished = compressor->finish(compressor); TestAssertTrue(finished == NULL); /* adding a null value should reinitialize the compressor */ compressor->append_null(compressor); finished = compressor->finish(compressor); TestAssertTrue(finished == NULL); /* finishing a finished compressor should return NULL */ finished = compressor->finish(compressor); TestAssertTrue(finished == NULL && "finishing a finished compressor should return NULL"); /* adding a non-null value should reinitialize the compressor */ compressor->append_val(compressor, BoolGetDatum(true)); finished = compressor->finish(compressor); TestAssertTrue(finished != NULL); } static uint32 bool_compressed_size(int num_values, int flip_nth) { Compressor *compressor = bool_compressor_for_type(BOOLOID); for (int i = 1; i < (num_values + 1); ++i) { if (i % flip_nth == 0) compressor->append_val(compressor, BoolGetDatum(false)); else compressor->append_val(compressor, BoolGetDatum(true)); } Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); return VARSIZE(DatumGetPointer(compressed)); } static void test_bool() { /* code covareage and simple tests */ test_empty_bool_compressor(); test_bool_compressor_extended(); /* testing a few RLE configurations with or without nulls: */ test_bool_rle(/* nulls = */ false, /* run_length = */ 1, /* expected_size = */ 152); test_bool_rle(/* nulls = */ false, /* run_length = */ 5, /* expected_size = */ 152); test_bool_rle(/* nulls = */ true, /* run_length = */ 19, /* expected_size = */ 296); test_bool_rle(/* nulls = */ false, /* run_length = */ 27, /* expected_size = */ 152); test_bool_rle(/* nulls = */ true, /* run_length = */ 43, /* expected_size = */ 296); test_bool_rle(/* nulls = */ false, /* run_length = */ 61, /* expected_size = */ 152); test_bool_rle(/* nulls = */ false, /* run_length = */ 65, /* expected_size = */ 152); test_bool_rle(/* nulls = */ false, /* run_length = */ 100, /* expected_size = */ 112); test_bool_rle(/* nulls = */ true, /* run_length = */ 97, /* expected_size = */ 256); test_bool_rle(/* nulls = */ false, /* run_length = */ 191, /* expected_size = */ 72); test_bool_rle(/* nulls = */ true, /* run_length = */ 237, /* expected_size = */ 144); test_bool_rle(/* nulls = */ false, /* run_length = */ 600, /* expected_size = */ 40); test_bool_rle(/* nulls = */ true, /* run_length = */ 720, /* expected_size = */ 80); test_bool_rle(/* nulls = */ false, /* run_length = */ TEST_ELEMENTS + 1, /* expected_size = */ 32); /* few select cases for comparison against bool compression: */ test_bool_array(/* nulls = */ false, /* run_length = */ 1, /* expected_size = */ 1055); test_bool_array(/* nulls = */ true, /* run_length = */ 19, /* expected_size = */ 1149); test_bool_array(/* nulls = */ false, /* run_length = */ 600, /* expected_size = */ 1055); test_bool_array(/* nulls = */ true, /* run_length = */ 720, /* expected_size = */ 1094); test_bool_array(/* nulls = */ false, /* run_length = */ TEST_ELEMENTS + 1, /* expected_size = */ 1055); /* few select cases for comparison against bool compression: */ test_bool_dictionary(/* nulls = */ false, /* run_length = */ 1, /* expected_size = */ 186); test_bool_dictionary(/* nulls = */ true, /* run_length = */ 19, /* expected_size = */ 330); test_bool_dictionary(/* nulls = */ false, /* run_length = */ 600, /* expected_size = */ 74); test_bool_dictionary(/* nulls = */ true, /* run_length = */ 720, /* expected_size = */ 114); test_bool_dictionary(/* nulls = */ false, /* run_length = */ TEST_ELEMENTS + 1, /* expected_size = */ 65); int baseline = bool_compressed_size(1, 1); int no_rle = bool_compressed_size(64, 2); /* verify that we can pack 64 bits into the same size */ TestAssertTrue(no_rle == baseline); int rle_size = bool_compressed_size(65, 66); /* verify that we can RLE 65 bits into the same size */ TestAssertTrue(rle_size == baseline); } static void test_null() { /* pointless tests to make codecov happy */ StringInfoData buffer = (StringInfoData){ .data = NULL, .len = 0, .maxlen = 0, }; TestEnsureError(null_decompression_iterator_from_datum_forward((Datum) 0, INT2OID)); TestEnsureError(null_decompression_iterator_from_datum_reverse((Datum) 0, BOOLOID)); TestEnsureError(null_compressed_send(NULL, &buffer)); TestEnsureError(null_compressed_recv(&buffer)); TestEnsureError(null_compressor_for_type(BOOLOID)); { StringInfoData buffer; void *compressed = null_compressor_get_dummy_block(); Datum sent_datum = DirectFunctionCall2(tsl_compressed_data_send, PointerGetDatum(compressed), PointerGetDatum(&buffer)); bytea *sent = (bytea *) DatumGetPointer(sent_datum); StringInfoData transmission = (StringInfoData){ .data = VARDATA(sent), .len = VARSIZE(sent), .maxlen = VARSIZE(sent), }; TestAssertTrue(transmission.len > 0); TestAssertTrue(transmission.data != NULL); Datum res = DirectFunctionCall1(tsl_compressed_data_recv, PointerGetDatum(&transmission)); TestAssertTrue(DatumGetPointer(res) != NULL); } { void *compressed = null_compressor_get_dummy_block(); Datum has_nulls = DirectFunctionCall1(tsl_compressed_data_has_nulls, PointerGetDatum(compressed)); TestAssertTrue(DatumGetBool(has_nulls)); } } static void test_simple8b_rle_compressed_size(uint64 *elements, int num_elements) { Simple8bRleCompressor compressor, compressor2; void *dest = NULL; simple8brle_compressor_init(&compressor); simple8brle_compressor_init(&compressor2); for (int i = 0; i < num_elements; i++) { simple8brle_compressor_append(&compressor, elements[i]); simple8brle_compressor_append(&compressor2, elements[i]); } size_t compressed_size = simple8brle_compressor_compressed_const_size(&compressor); dest = compressed_size > 0 ? palloc(compressed_size) : NULL; /* finish_into must not fail even if the compressor is empty */ void *dest_past_end = simple8brle_compressor_finish_into(&compressor2, dest, compressed_size); if (num_elements == 0) { TestAssertTrue(dest_past_end == NULL); TestAssertInt64Eq(compressed_size, 0); return; } TestAssertTrue(dest_past_end != NULL); Simple8bRleSerialized *serialized = simple8brle_compressor_finish(&compressor); size_t serialized_size = simple8brle_serialized_total_size(serialized); TestAssertInt64Eq(compressed_size, serialized_size); /* Check the const size function after the compressor is finished, * this may happen accidentally, not on purpose. */ compressed_size = simple8brle_compressor_compressed_const_size(&compressor); TestAssertInt64Eq(compressed_size, serialized_size); pfree(serialized); pfree(dest); } static void test_simple8b_rle_expected_size(uint64 *elements, int num_elements, int expected_size) { Simple8bRleCompressor compressor; simple8brle_compressor_init(&compressor); for (int i = 0; i < num_elements; i++) { simple8brle_compressor_append(&compressor, elements[i]); } size_t compressed_size = simple8brle_compressor_compressed_const_size(&compressor); TestAssertInt64Eq(compressed_size, expected_size); } static void test_simple8b_rle() { /* clang-format off */ /* clang would place all the elements on a single line otherwise */ uint64 elements[] = { 1, 2, 4, 8, 16, 7, 3, 32, 64, 63, 31, 15, 7, 3, 1, 0, 128, 127, 63, 31, 15, 7, 3, 1, 0, 256, 255, 127, 63, 31, 15, 7, 3, 1, 0, 512, 511, 126, 63, 31, 15, 7, 3, 1, 0, 1024, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 2048, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 4096, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 8192, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 16384, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 32768, 32767, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 65536, 65535, 32767, 16383, 8191, 4095, 2047, 1023, 511, 255, 127, 63, 31, 15, 131072, 131071, 65535, 16777216, 16777211, 16777215, 4294967296ULL, 12884901888ULL }; uint64 elements_corner_case[] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0xFFFFFFFFULL, }; /* clang-format on */ int n = sizeof(elements) / sizeof(*elements); for (int i = 0; i < n; i++) { test_simple8b_rle_compressed_size(elements, i); } /* test corner cases */ test_simple8b_rle_expected_size(elements_corner_case, 63, 24); test_simple8b_rle_expected_size(elements_corner_case, 64, 48); /* set the last value to a two bit one, so the 1 bit values are only extended to 2 bits */ elements_corner_case[63] = 3; test_simple8b_rle_expected_size(elements_corner_case, 64, 32); /* make this less favourable for the 1 bit values */ elements_corner_case[60] = 0xFFFFFFFFFFFFFFFFULL; test_simple8b_rle_expected_size(elements_corner_case, 61, 56); } static void compare_datum_ptr(Datum datum1, Datum datum2, const char *msg) { char *ptr1 = DatumGetPointer(datum1); char *ptr2 = DatumGetPointer(datum2); TestAssertTrue(ptr1 != NULL); TestAssertTrue(ptr2 != NULL); size_t size1 = VARSIZE_ANY(datum1); size_t size2 = VARSIZE_ANY(datum2); TestAssertInt64Eq(size1, size2); int memcmp_result = memcmp(ptr1, ptr2, size1); if (memcmp_result != 0) { elog(WARNING, "memcmp failed: %s, size: %zu, memcmp result: %d", msg, size1, memcmp_result); TestAssertInt64Eq(memcmp_result, 0); } } static void test_delta_size_and_placement(const int32 *values, int n, int expected_size) { size_t var_size; size_t calc_size; Datum pass1 = (Datum) 0; Datum pass2 = (Datum) 0; Datum pass3 = (Datum) 0; /* First pass, obtain a reference and verify expected size is legit */ { DeltaDeltaCompressor *compressor = delta_delta_compressor_alloc(); for (int i = 0; i < n; i++) { /* Zero values are treated as nulls */ if (values[i] == 0) delta_delta_compressor_append_null(compressor); else delta_delta_compressor_append_value(compressor, values[i]); } pass1 = (Datum) delta_delta_compressor_finish(compressor); var_size = DatumGetPointer(pass1) == NULL ? 0 : VARSIZE(DatumGetPointer(pass1)); TestAssertInt64Eq((int64) var_size, (int64) expected_size); if (expected_size > 0) { StringInfoData buf; bytea *sent; StringInfoData transmission; DeltaDeltaCompressed *compressed_recv; pq_begintypsend(&buf); deltadelta_compressed_send((CompressedDataHeader *) pass1, &buf); sent = pq_endtypsend(&buf); transmission = (StringInfoData){ .data = VARDATA(sent), .len = VARSIZE(sent), .maxlen = VARSIZE(sent), }; compressed_recv = (DeltaDeltaCompressed *) DatumGetPointer(deltadelta_compressed_recv(&transmission)); DecompressionIterator *iter = delta_delta_decompression_iterator_from_datum_forward(PointerGetDatum( compressed_recv), INT8OID); int i = 0; for (DecompressResult r = delta_delta_decompression_iterator_try_next_forward(iter); !r.is_done; r = delta_delta_decompression_iterator_try_next_forward(iter)) { if (values[i] == 0) TestAssertTrue(r.is_null); else { TestAssertTrue(!r.is_null); TestAssertInt64Eq(DatumGetInt64(r.val), values[i]); } i += 1; } TestAssertInt64Eq(i, n); } } /* Second pass, verify that the compressed data size calculation is idempotent and * produces a valid result */ { DeltaDeltaCompressor *compressor = delta_delta_compressor_alloc(); bool has_nulls = false; for (int i = 0; i < n; i++) { /* Zero values are treated as nulls */ if (values[i] == 0) { delta_delta_compressor_append_null(compressor); has_nulls = true; } else delta_delta_compressor_append_value(compressor, values[i]); } size_t nulls_size = 0; calc_size = delta_delta_compressor_compressed_size(compressor, &nulls_size); TestAssertTrue((has_nulls && calc_size > 0) == (nulls_size > 0)); TestAssertInt64Eq(calc_size, expected_size); pass2 = (Datum) delta_delta_compressor_finish(compressor); /* Make sure the compressed data size is the same as the var size */ TestAssertInt64Eq((int64) calc_size, (int64) var_size); /* And the var size is the same as in the previous calculation */ var_size = DatumGetPointer(pass2) == NULL ? 0 : VARSIZE(DatumGetPointer(pass2)); TestAssertInt64Eq((int64) var_size, (int64) expected_size); } /* Third pass, verify that we can use the calculated size and serialize the * compressed data into a buffer which results the same data as in the previous * passes */ { DeltaDeltaCompressor *compressor = delta_delta_compressor_alloc(); for (int i = 0; i < n; i++) { /* Zero values are treated as nulls */ if (values[i] == 0) { delta_delta_compressor_append_null(compressor); } else delta_delta_compressor_append_value(compressor, values[i]); } size_t est_size = delta_delta_compressor_compressed_size(compressor, NULL); TestAssertInt64Eq(est_size, expected_size); pass3 = (Datum) palloc0(est_size + 4); char *pass3_ptr = DatumGetPointer(pass3); pass3_ptr[est_size] = 0xDE; pass3_ptr[est_size + 1] = 0xAD; pass3_ptr[est_size + 2] = 0xBE; pass3_ptr[est_size + 3] = 0xEF; char *result = (char *) delta_delta_compressor_finish_into(compressor, DatumGetPointer(pass3)); if (expected_size == 0) { TestAssertTrue(result == DatumGetPointer(pass3)); return; } TestAssertTrue(DatumGetPointer(pass3) != NULL); TestAssertTrue(result != NULL); TestAssertTrue(result != DatumGetPointer(pass3)); TestAssertTrue(result == pass3_ptr + est_size); size_t pass3_size = VARSIZE(DatumGetPointer(pass3)); TestAssertInt64Eq(pass3_size, est_size); TestAssertInt64Eq(pass3_size, VARSIZE(DatumGetPointer(pass1))); TestAssertInt64Eq(pass3_size, VARSIZE(DatumGetPointer(pass2))); TestAssertInt64Eq((unsigned char) result[0], 0xDE); TestAssertInt64Eq((unsigned char) result[1], 0xAD); TestAssertInt64Eq((unsigned char) result[2], 0xBE); TestAssertInt64Eq((unsigned char) result[3], 0xEF); compare_datum_ptr(pass1, pass3, "pass1 and pass3"); compare_datum_ptr(pass2, pass3, "pass2 and pass3"); } } static void test_delta_size_and_placements() { int32 single_value[] = { 1 }; int32 triple[] = { 1, 2, 3 }; int32 nulls[] = { 0, 0 }; int32 mixed[] = { 1, 0, 100 }; int32 large[] = { 0, 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 0, 2, 20, 200, 2000, 20000, 200000, 2000000, 20000000, 200000000, 0, 3, 30, 300, 3000, 30000, 300000, 3000000, 30000000, 300000000, 0, 4, 40, 400, 4000, 40000, 400000, 4000000, 40000000, 400000000, 0, 5, 50, 500, 5000, 50000, 500000, 5000000, 50000000, 500000000, 0, 6, 60, 600, 6000, 60000, 600000, 6000000, 60000000, 600000000, 0, 7, 70, 700, 7000, 70000, 700000, 7000000, 70000000, 700000000, 0, 8, 80, 800, 8000, 80000, 800000, 8000000, 80000000, 800000000, 0, 9, 90, 900, 9000, 90000, 900000, 9000000, 90000000, 900000000, 0, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 0, 11, 110, 1100, 11000, 110000, 1100000, 11000000, 110000000, 1100000000, 0, 12, 120, 1200, 12000, 120000, 1200000, 12000000, 120000000, 1200000000, 0, 13, 130, 1300, 13000, 130000, 1300000, 13000000, 130000000, 1300000000, 0, 14, 140, 1400, 14000, 140000, 1400000, 14000000, 140000000, 1400000000, 0, 15, 150, 1500, 15000, 150000, 1500000, 15000000, 150000000, 1500000000, 0, 16, 160, 1600, 16000, 160000, 1600000, 16000000, 160000000, 1600000000, 0, 17, 170, 1700, 17000, 170000, 1700000, 17000000, 170000000, 1700000000, 0, 18, 180, 1800, 18000, 180000, 1800000, 18000000, 180000000, 1800000000, 0, 19, 190, 1900, 19000, 190000, 1900000, 19000000, 190000000, 1900000000 }; test_delta_size_and_placement(single_value, sizeof(single_value) / sizeof(*single_value), 48); test_delta_size_and_placement(triple, sizeof(triple) / sizeof(*triple), 48); test_delta_size_and_placement(nulls, sizeof(nulls) / sizeof(*nulls), 0); test_delta_size_and_placement(mixed, sizeof(mixed) / sizeof(*mixed), 72); test_delta_size_and_placement(large, 2, 72); test_delta_size_and_placement(large, 3, 72); test_delta_size_and_placement(large, 4, 72); test_delta_size_and_placement(large, 5, 72); test_delta_size_and_placement(large, 6, 80); test_delta_size_and_placement(large, 7, 80); test_delta_size_and_placement(large, 8, 80); test_delta_size_and_placement(large, 9, 88); test_delta_size_and_placement(large, 10, 88); test_delta_size_and_placement(large, 13, 96); test_delta_size_and_placement(large, 20, 120); test_delta_size_and_placement(large, 24, 136); test_delta_size_and_placement(large, 30, 152); test_delta_size_and_placement(large, 35, 168); test_delta_size_and_placement(large, 40, 184); test_delta_size_and_placement(large, 46, 208); test_delta_size_and_placement(large, 50, 224); test_delta_size_and_placement(large, 57, 248); test_delta_size_and_placement(large, 60, 256); test_delta_size_and_placement(large, 68, 288); test_delta_size_and_placement(large, 70, 296); test_delta_size_and_placement(large, 79, 328); test_delta_size_and_placement(large, 80, 328); test_delta_size_and_placement(large, 90, 368); test_delta_size_and_placement(large, 100, 400); test_delta_size_and_placement(large, 102, 408); test_delta_size_and_placement(large, 110, 432); test_delta_size_and_placement(large, 113, 440); test_delta_size_and_placement(large, 120, 464); test_delta_size_and_placement(large, 124, 488); test_delta_size_and_placement(large, 130, 520); test_delta_size_and_placement(large, 135, 544); test_delta_size_and_placement(large, 140, 560); test_delta_size_and_placement(large, 146, 584); test_delta_size_and_placement(large, 150, 600); test_delta_size_and_placement(large, 157, 640); test_delta_size_and_placement(large, 160, 648); test_delta_size_and_placement(large, 168, 680); test_delta_size_and_placement(large, 170, 688); test_delta_size_and_placement(large, 180, 728); } static Datum * generate_uuidv7(int n) { Assert(n > 0); Datum *uuids = palloc(n * sizeof(Datum)); /* seed the random number generator */ srand(1); for (int i = 0; i < n; ++i) { uuids[i] = UUIDPGetDatum(ts_create_uuid_v7_from_timestamptz(GetCurrentTimestamp(), false)); } return uuids; } static void test_uuid_dictionary_simple() { /* Make sure dictionary makes sense by only compressing 1/4 of the elements */ Datum *uuids = generate_uuidv7((TEST_ELEMENTS + 3) / 4); Compressor *compressor = dictionary_compressor_for_type(UUIDOID); for (int i = 0; i < TEST_ELEMENTS; ++i) { compressor->append_val(compressor, uuids[i / 4]); } Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); ArrowArray *bulk_result = tsl_dictionary_decompress_all(compressed, UUIDOID, CurrentMemoryContext); const pg_uuid_t *bulk_data = (pg_uuid_t *) bulk_result->buffers[1]; const CompressedDataHeader *header = (CompressedDataHeader *) PG_DETOAST_DATUM(compressed); /* The dictionary compression may recompress the data id Array compression would save space. * Make sure it is not the case here. */ TestAssertTrue(header->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY); DecompressionIterator *iter = tsl_dictionary_decompression_iterator_from_datum_forward(compressed, UUIDOID); for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); TestAssertTrue(DatumGetPointer(r.val) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall2(uuid_eq, r.val, uuids[i / 4]))); TestAssertTrue(DatumGetBool( DirectFunctionCall2(uuid_eq, PointerGetDatum(&bulk_data[i]), uuids[i / 4]))); } } static void test_uuid_array_simple() { Datum *uuids = generate_uuidv7(TEST_ELEMENTS); Compressor *compressor = array_compressor_for_type(UUIDOID); for (int i = 0; i < TEST_ELEMENTS; ++i) { compressor->append_val(compressor, uuids[i]); } Datum compressed = (Datum) compressor->finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); ArrowArray *bulk_result = tsl_array_decompress_all(compressed, UUIDOID, CurrentMemoryContext); const pg_uuid_t *bulk_data = (pg_uuid_t *) bulk_result->buffers[1]; const CompressedDataHeader *header = (CompressedDataHeader *) PG_DETOAST_DATUM(compressed); TestAssertTrue(header->compression_algorithm == COMPRESSION_ALGORITHM_ARRAY); DecompressionIterator *iter = tsl_array_decompression_iterator_from_datum_forward(compressed, UUIDOID); for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = array_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); TestAssertTrue(DatumGetPointer(r.val) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall2(uuid_eq, r.val, uuids[i]))); TestAssertTrue( DatumGetBool(DirectFunctionCall2(uuid_eq, PointerGetDatum(&bulk_data[i]), uuids[i]))); } } static void test_uuid_compressor_simple(int null_modulo, int value_modulo) { Datum *uuids = generate_uuidv7(TEST_ELEMENTS); UuidCompressor *compressor = uuid_compressor_alloc(); bool has_nulls = false; for (int i = 0; i < TEST_ELEMENTS; ++i) { if ((null_modulo > 0 && i % null_modulo == 0) || (value_modulo > 0 && i % value_modulo != 0)) { uuid_compressor_append_null(compressor); has_nulls = true; continue; } pg_uuid_t *uuid = DatumGetUUIDP(uuids[i]); uuid_compressor_append_value(compressor, *uuid); } Datum compressed = (Datum) uuid_compressor_finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall1(tsl_compressed_data_has_nulls, compressed)) == has_nulls); const CompressedDataHeader *header = (CompressedDataHeader *) PG_DETOAST_DATUM(compressed); TestAssertTrue(header->compression_algorithm == COMPRESSION_ALGORITHM_UUID); ArrowArray *bulk_result = uuid_decompress_all(compressed, UUIDOID, CurrentMemoryContext); pg_uuid_t *bulk_values = (pg_uuid_t *) bulk_result->buffers[1]; /* * Forward iterator based test */ DecompressionIterator *iter = uuid_decompression_iterator_from_datum_forward(compressed, UUIDOID); for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = uuid_decompression_iterator_try_next_forward(iter); if ((null_modulo > 0 && i % null_modulo == 0) || (value_modulo > 0 && i % value_modulo != 0)) { TestAssertTrue(r.is_null); TestAssertTrue(!arrow_row_is_valid(bulk_result->buffers[0], i)); continue; } TestAssertTrue(!r.is_done); TestAssertTrue(!r.is_null); TestAssertTrue(arrow_row_is_valid(bulk_result->buffers[0], i)); TestAssertTrue(DatumGetPointer(r.val) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall2(uuid_eq, r.val, uuids[i]))); TestAssertTrue( DatumGetBool(DirectFunctionCall2(uuid_eq, PointerGetDatum(&bulk_values[i]), uuids[i]))); } TestAssertTrue(uuid_decompression_iterator_try_next_forward(iter).is_done); /* * Reverse iterator based test */ iter = uuid_decompression_iterator_from_datum_reverse(compressed, UUIDOID); for (int i = TEST_ELEMENTS - 1; i >= 0; --i) { DecompressResult r = uuid_decompression_iterator_try_next_reverse(iter); if ((null_modulo > 0 && i % null_modulo == 0) || (value_modulo > 0 && i % value_modulo != 0)) { TestAssertTrue(r.is_null); continue; } TestAssertTrue(!r.is_done); TestAssertTrue(DatumGetPointer(r.val) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall2(uuid_eq, r.val, uuids[i]))); } TestAssertTrue(uuid_decompression_iterator_try_next_reverse(iter).is_done); /* * Test that we can send and receive the compressed data */ { StringInfoData buf; bytea *sent; StringInfoData transmission; UuidCompressed *compressed_recv; pq_begintypsend(&buf); uuid_compressed_send((CompressedDataHeader *) compressed, &buf); sent = pq_endtypsend(&buf); transmission = (StringInfoData){ .data = VARDATA(sent), .len = VARSIZE(sent), .maxlen = VARSIZE(sent), }; compressed_recv = (UuidCompressed *) DatumGetPointer(uuid_compressed_recv(&transmission)); DecompressionIterator *iter = uuid_decompression_iterator_from_datum_forward(PointerGetDatum(compressed_recv), UUIDOID); int i = 0; for (DecompressResult r = uuid_decompression_iterator_try_next_forward(iter); !r.is_done; r = uuid_decompression_iterator_try_next_forward(iter)) { if ((null_modulo > 0 && i % null_modulo == 0) || (value_modulo > 0 && i % value_modulo != 0)) { TestAssertTrue(r.is_null); i++; continue; } TestAssertTrue(!r.is_done); TestAssertTrue(DatumGetPointer(r.val) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall2(uuid_eq, r.val, uuids[i]))); i++; } TestAssertTrue(uuid_decompression_iterator_try_next_forward(iter).is_done); TestAssertInt64Eq(i, TEST_ELEMENTS); } } static void test_uuid_compressor_switch_to_dictionary(int modulo) { /* Make sure the compressor switches to dictionary compression when the cardinality is * not high enough to justify the overhead of the uuid compressor. */ Datum *uuids = generate_uuidv7(TEST_ELEMENTS); UuidCompressor *compressor = uuid_compressor_alloc(); for (int i = 0; i < TEST_ELEMENTS; ++i) { pg_uuid_t *uuid = DatumGetUUIDP(uuids[i % modulo]); uuid_compressor_append_value(compressor, *uuid); } Datum compressed = (Datum) uuid_compressor_finish(compressor); TestAssertTrue(DatumGetPointer(compressed) != NULL); const CompressedDataHeader *header = (CompressedDataHeader *) PG_DETOAST_DATUM(compressed); TestAssertTrue(header->compression_algorithm == COMPRESSION_ALGORITHM_DICTIONARY); DecompressionIterator *iter = tsl_dictionary_decompression_iterator_from_datum_forward(compressed, UUIDOID); for (int i = 0; i < TEST_ELEMENTS; ++i) { DecompressResult r = dictionary_decompression_iterator_try_next_forward(iter); TestAssertTrue(!r.is_done); TestAssertTrue(DatumGetPointer(r.val) != NULL); TestAssertTrue(DatumGetBool(DirectFunctionCall2(uuid_eq, r.val, uuids[i % modulo]))); } } static void test_uuid() { bool old_value = ts_guc_enable_uuid_compression; ts_guc_enable_uuid_compression = true; test_uuid_dictionary_simple(); test_uuid_array_simple(); test_uuid_compressor_simple(0, 0); test_uuid_compressor_simple(0, 5); test_uuid_compressor_simple(0, 10); test_uuid_compressor_simple(0, 100); test_uuid_compressor_simple(2, 0); test_uuid_compressor_simple(5, 0); test_uuid_compressor_simple(10, 0); test_uuid_compressor_simple(100, 0); test_uuid_compressor_switch_to_dictionary(2); test_uuid_compressor_switch_to_dictionary(20); test_uuid_compressor_switch_to_dictionary(200); ts_guc_enable_uuid_compression = old_value; } static void pointless_tests_to_satisfy_codecov() { TestEnsureError(tsl_array_decompress_all((Datum) 0, InvalidOid, CurrentMemoryContext)); TestEnsureError(tsl_dictionary_decompress_all((Datum) 0, InvalidOid, CurrentMemoryContext)); } Datum ts_test_compression(PG_FUNCTION_ARGS) { /* Some tests to verify the size of the compressed data with the delta delta compressor */ test_delta_size_and_placements(); test_int_array(); test_string_array(); test_int_dictionary(); test_string_dictionary(); test_gorilla_int(); test_gorilla_float(); test_gorilla_double(/* have_nulls = */ false, /* have_random = */ false); test_gorilla_double(/* have_nulls = */ false, /* have_random = */ true); test_gorilla_double(/* have_nulls = */ true, /* have_random = */ false); test_gorilla_double(/* have_nulls = */ true, /* have_random = */ true); test_delta(); test_delta2(); test_delta3(/* have_nulls = */ false, /* have_random = */ false); test_delta3(/* have_nulls = */ false, /* have_random = */ true); test_delta3(/* have_nulls = */ true, /* have_random = */ false); test_delta3(/* have_nulls = */ true, /* have_random = */ true); test_bool(); test_null(); test_simple8b_rle(); test_uuid(); /* Some tests for zig-zag encoding overflowing the original element width. */ test_delta4(test_delta4_case1, sizeof(test_delta4_case1) / sizeof(*test_delta4_case1)); test_delta4(test_delta4_case2, sizeof(test_delta4_case2) / sizeof(*test_delta4_case2)); pointless_tests_to_satisfy_codecov(); PG_RETURN_VOID(); } TS_FUNCTION_INFO_V1(ts_segment_meta_min_max_append); Datum ts_segment_meta_min_max_append(PG_FUNCTION_ARGS) { BatchMetadataBuilder *builder = (BatchMetadataBuilder *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); MemoryContext agg_context; MemoryContext old_context; if (!AggCheckCallContext(fcinfo, &agg_context)) { /* cannot be called directly because of internal-type argument */ elog(ERROR, "ts_segment_meta_min_max_append called in non-aggregate context"); } old_context = MemoryContextSwitchTo(agg_context); if (builder == NULL) { Oid type_to_compress = get_fn_expr_argtype(fcinfo->flinfo, 1); builder = batch_metadata_builder_minmax_create(type_to_compress, fcinfo->fncollation, -1, -1); } if (PG_ARGISNULL(1)) builder->update_null(builder); else builder->update_val(builder, PG_GETARG_DATUM(1)); MemoryContextSwitchTo(old_context); PG_RETURN_POINTER(builder); } TS_FUNCTION_INFO_V1(ts_segment_meta_min_max_finish_max); Datum ts_segment_meta_min_max_finish_max(PG_FUNCTION_ARGS) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (builder == NULL || batch_metadata_builder_minmax_empty(builder)) PG_RETURN_NULL(); PG_RETURN_DATUM(batch_metadata_builder_minmax_max(builder)); } TS_FUNCTION_INFO_V1(ts_segment_meta_min_max_finish_min); Datum ts_segment_meta_min_max_finish_min(PG_FUNCTION_ARGS) { BatchMetadataBuilderMinMax *builder = (BatchMetadataBuilderMinMax *) (PG_ARGISNULL(0) ? NULL : PG_GETARG_POINTER(0)); if (builder == NULL || batch_metadata_builder_minmax_empty(builder)) PG_RETURN_NULL(); PG_RETURN_DATUM(batch_metadata_builder_minmax_min(builder)); } TS_FUNCTION_INFO_V1(ts_compression_custom_type_in); TS_FUNCTION_INFO_V1(ts_compression_custom_type_out); TS_FUNCTION_INFO_V1(ts_compression_custom_type_eq); /* basically int2in but returns by reference */ Datum ts_compression_custom_type_in(PG_FUNCTION_ARGS) { char *num = PG_GETARG_CSTRING(0); int16 *val = palloc(sizeof(*val)); *val = pg_strtoint16(num); PG_RETURN_POINTER(val); } /* like int2out but takes values by ref */ Datum ts_compression_custom_type_out(PG_FUNCTION_ARGS) { int16 *arg = (int16 *) PG_GETARG_POINTER(0); char *result = (char *) palloc(7); /* sign, 5 digits, '\0' */ pg_itoa(*arg, result); PG_RETURN_CSTRING(result); } /* like int2eq but takes values by ref */ Datum ts_compression_custom_type_eq(PG_FUNCTION_ARGS) { int16 *arg1 = (int16 *) PG_GETARG_POINTER(0); int16 *arg2 = (int16 *) PG_GETARG_POINTER(1); PG_RETURN_BOOL(*arg1 == *arg2); } �������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/decompress_arithmetic_test_impl.c�����������������������������������0000664�0000000�0000000�00000014524�15100345067�0025232�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #define FUNCTION_NAME_HELPER3(X, Y, Z) X##_##Y##_##Z #define FUNCTION_NAME3(X, Y, Z) FUNCTION_NAME_HELPER3(X, Y, Z) #define FUNCTION_NAME_HELPER2(X, Y) X##_##Y #define FUNCTION_NAME2(X, Y) FUNCTION_NAME_HELPER2(X, Y) #define PG_TYPE_OID_HELPER(X) X##OID #define PG_TYPE_OID_HELPER2(X) PG_TYPE_OID_HELPER(X) #define PG_TYPE_OID PG_TYPE_OID_HELPER2(PG_TYPE_PREFIX) #ifndef IS_NOT_EQUAL #define IS_NOT_EQUAL(X, Y) ((X) != (Y)) #endif #ifndef IS_FINITE #define IS_FINITE(X) true #endif #ifndef ARROW_GET_VALUE #define ARROW_GET_VALUE(A, I) ((CTYPE *) (A)->buffers[1])[I] #endif static void FUNCTION_NAME3(check_arrow, CTYPE, ALGO)(ArrowArray *arrow, int error_type, DecompressResult *results, int n) { if (n != arrow->length) { ereport(error_type, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("Expected %d elements, got %d.", n, (int) arrow->length))); } for (int i = 0; i < n; i++) { const bool arrow_isnull = !arrow_row_is_valid(arrow->buffers[0], i); if (arrow_isnull != results[i].is_null) { ereport(error_type, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("Expected null %d, got %d at row %d.", results[i].is_null, arrow_isnull, i))); } if (!results[i].is_null) { const CTYPE arrow_value = ARROW_GET_VALUE(arrow, i); const CTYPE rowbyrow_value = DATUM_TO_CTYPE(results[i].val); /* * Floats can also be NaN/infinite and the comparison doesn't * work in that case. */ if (IS_FINITE(arrow_value) != IS_FINITE(rowbyrow_value)) { ereport(error_type, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("At row %d\n", i))); } if (IS_FINITE(arrow_value) && IS_NOT_EQUAL(arrow_value, rowbyrow_value)) { ereport(error_type, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("At row %d\n", i))); } } } } /* * Try to decompress the given compressed data. Used for fuzzing and for checking * the examples found by fuzzing. For fuzzing we do less checks to keep it * faster and the coverage space smaller. This is a generic implementation * for arithmetic types. */ static int FUNCTION_NAME3(decompress, ALGO, PG_TYPE_PREFIX)(const uint8 *Data, size_t Size, bool bulk) { StringInfoData si = { .data = (char *) Data, .len = Size }; const int data_algo = pq_getmsgbyte(&si); CheckCompressedData(data_algo > 0 && data_algo < _END_COMPRESSION_ALGORITHMS); if (data_algo != FUNCTION_NAME2(COMPRESSION_ALGORITHM, ALGO)) { /* * It's convenient to fuzz only one algorithm at a time. We specialize * the fuzz target for one algorithm, so that the fuzzer doesn't waste * time discovering others from scratch. */ return -1; } const CompressionAlgorithmDefinition *def = algorithm_definition(data_algo); Datum compressed_data = def->compressed_data_recv(&si); DecompressAllFunction decompress_all = tsl_get_decompress_all_function(data_algo, PG_TYPE_OID); ArrowArray *arrow = NULL; if (bulk) { /* * Test bulk decompression. Have to do this before row-by-row decompression * so that the latter doesn't hide the errors. */ arrow = decompress_all(compressed_data, PG_TYPE_OID, CurrentMemoryContext); } /* * Test row-by-row decompression. */ DecompressionIterator *iter = def->iterator_init_forward(compressed_data, PG_TYPE_OID); DecompressResult results[GLOBAL_MAX_ROWS_PER_COMPRESSION]; int n = 0; for (DecompressResult r = iter->try_next(iter); !r.is_done; r = iter->try_next(iter)) { if (n >= GLOBAL_MAX_ROWS_PER_COMPRESSION) { elog(ERROR, "too many compressed rows"); } results[n++] = r; } /* Check that both ways of decompression match. */ if (bulk) { FUNCTION_NAME3(check_arrow, CTYPE, ALGO)(arrow, ERROR, results, n); return n; } /* * For row-by-row decompression, check that the result is still the same * after we compress and decompress back. * * 1) Compress. */ Compressor *compressor = def->compressor_for_type(PG_TYPE_OID); for (int i = 0; i < n; i++) { if (results[i].is_null) { compressor->append_null(compressor); } else { compressor->append_val(compressor, results[i].val); } } compressed_data = (Datum) compressor->finish(compressor); if (compressed_data == 0) { /* The gorilla compressor returns NULL for all-null input sets. */ return n; }; /* * 2) Decompress and check that it's the same. */ iter = def->iterator_init_forward(compressed_data, PG_TYPE_OID); int nn = 0; for (DecompressResult r = iter->try_next(iter); !r.is_done; r = iter->try_next(iter)) { if (nn >= n) { elog(ERROR, "the repeated recompression result doesn't match"); } if (r.is_null != results[nn].is_null) { elog(ERROR, "the repeated decompression result doesn't match"); } if (!r.is_null) { CTYPE old_value = DATUM_TO_CTYPE(results[nn].val); CTYPE new_value = DATUM_TO_CTYPE(r.val); /* * Floats can also be NaN/infinite and the comparison doesn't * work in that case. */ if (IS_FINITE(old_value) != IS_FINITE(new_value)) { elog(ERROR, "the repeated decompression result doesn't match"); } if (IS_FINITE(old_value) && IS_NOT_EQUAL(old_value, new_value)) { elog(ERROR, "the repeated decompression result doesn't match"); } } nn++; } /* * 3) The bulk decompression must absolutely work on the correct compressed * data we've just generated. */ PG_TRY(); { arrow = decompress_all(compressed_data, PG_TYPE_OID, CurrentMemoryContext); } PG_CATCH(); { EmitErrorReport(); elog(PANIC, "bulk decompression failed for data that we've just compressed"); } PG_END_TRY(); FUNCTION_NAME3(check_arrow, CTYPE, ALGO)(arrow, PANIC, results, n); return n; } #undef FUNCTION_NAME3 #undef FUNCTION_NAME_HELPER3 #undef FUNCTION_NAME2 #undef FUNCTION_NAME_HELPER2 #undef PG_TYPE_OID #undef PG_TYPE_OID_HELPER #undef PG_TYPE_OID_HELPER2 /* These are defined by the caller */ #undef ALGO #undef CTYPE #undef PG_TYPE_PREFIX #undef DATUM_TO_CTYPE #undef IS_FINITE #undef IS_NOT_EQUAL #undef ARROW_GET_VALUE ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/decompress_text_test_impl.c�����������������������������������������0000664�0000000�0000000�00000014456�15100345067�0024071�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <libpq/pqformat.h> #include "compression_sql_test.h" #include "compression/arrow_c_data_interface.h" static uint32 arrow_get_str(ArrowArray *arrow, int arrow_row, const char **str) { if (!arrow->dictionary) { const uint32 *offsets = (uint32 *) arrow->buffers[1]; const char *values = (char *) arrow->buffers[2]; const uint32 start = offsets[arrow_row]; const uint32 end = offsets[arrow_row + 1]; const uint32 arrow_len = end - start; *str = &values[start]; return arrow_len; } const int16 dict_row = ((int16 *) arrow->buffers[1])[arrow_row]; return arrow_get_str(arrow->dictionary, dict_row, str); } static void decompress_generic_text_check_arrow(ArrowArray *arrow, int errorlevel, DecompressResult *results, int n) { /* Check that both ways of decompression match. */ if (n != arrow->length) { ereport(errorlevel, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("Expected %d elements, got %d.", n, (int) arrow->length))); } for (int i = 0; i < n; i++) { const bool arrow_isnull = !arrow_row_is_valid(arrow->buffers[0], i); if (arrow_isnull != results[i].is_null) { ereport(errorlevel, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("Expected null %d, got %d at row %d.", results[i].is_null, arrow_isnull, i))); } if (!results[i].is_null) { const char *arrow_cstring; size_t arrow_len = arrow_get_str(arrow, i, &arrow_cstring); const Datum rowbyrow_varlena = results[i].val; const size_t rowbyrow_len = VARSIZE_ANY_EXHDR(rowbyrow_varlena); const char *rowbyrow_cstring = VARDATA_ANY(rowbyrow_varlena); if (rowbyrow_len != arrow_len) { ereport(errorlevel, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("At row %d\n", i))); } if (strncmp(arrow_cstring, rowbyrow_cstring, rowbyrow_len) != 0) { ereport(errorlevel, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("the bulk decompression result does not match"), errdetail("At row %d\n", i))); } } } } /* * Try to decompress the given compressed data. */ static int decompress_generic_text(const uint8 *Data, size_t Size, bool bulk, int requested_algo) { StringInfoData si = { .data = (char *) Data, .len = Size }; const int data_algo = pq_getmsgbyte(&si); CheckCompressedData(data_algo > 0 && data_algo < _END_COMPRESSION_ALGORITHMS); if (data_algo != requested_algo) { /* * It's convenient to fuzz only one algorithm at a time. We specialize * the fuzz target for one algorithm, so that the fuzzer doesn't waste * time discovering others from scratch. */ return -1; } const CompressionAlgorithmDefinition *def = algorithm_definition(data_algo); Datum compressed_data = def->compressed_data_recv(&si); DecompressAllFunction decompress_all = tsl_get_decompress_all_function(data_algo, TEXTOID); ArrowArray *arrow = NULL; if (bulk) { /* * Check that the arrow decompression works. Have to do this before the * row-by-row decompression so that it doesn't hide the possible errors. */ arrow = decompress_all(compressed_data, TEXTOID, CurrentMemoryContext); } /* * Test row-by-row decompression. */ DecompressionIterator *iter = def->iterator_init_forward(compressed_data, TEXTOID); DecompressResult results[GLOBAL_MAX_ROWS_PER_COMPRESSION]; int n = 0; for (DecompressResult r = iter->try_next(iter); !r.is_done; r = iter->try_next(iter)) { if (n >= GLOBAL_MAX_ROWS_PER_COMPRESSION) { elog(ERROR, "too many compressed rows"); } results[n++] = r; } if (bulk) { /* * Check that the arrow decompression result matches. */ decompress_generic_text_check_arrow(arrow, ERROR, results, n); return n; } /* * For row-by-row decompression, check that the result is still the same * after we compress and decompress back. * Don't perform this check for other types of tests. * * 1) Compress. */ Compressor *compressor = def->compressor_for_type(TEXTOID); for (int i = 0; i < n; i++) { if (results[i].is_null) { compressor->append_null(compressor); } else { compressor->append_val(compressor, results[i].val); } } compressed_data = (Datum) compressor->finish(compressor); if (compressed_data == 0) { /* Some compressors return NULL when all rows are null. */ return n; } /* * 2) Decompress and check that it's the same. */ iter = def->iterator_init_forward(compressed_data, TEXTOID); int nn = 0; for (DecompressResult r = iter->try_next(iter); !r.is_done; r = iter->try_next(iter)) { if (nn >= n) { elog(ERROR, "the repeated recompression result doesn't match"); } if (r.is_null != results[nn].is_null) { elog(ERROR, "the repeated decompression result doesn't match"); } if (!r.is_null) { const Datum old_value = results[nn].val; const Datum new_value = r.val; /* * Floats can also be NaN/infinite and the comparison doesn't * work in that case. */ if (VARSIZE_ANY_EXHDR(old_value) != VARSIZE_ANY_EXHDR(new_value)) { elog(ERROR, "the repeated decompression result doesn't match"); } if (strncmp(VARDATA_ANY(old_value), VARDATA_ANY(new_value), VARSIZE_ANY_EXHDR(new_value)) != 0) { elog(ERROR, "the repeated decompression result doesn't match"); } } nn++; } /* * 3) The bulk decompression must absolutely work on the correct compressed * data we've just generated. */ PG_TRY(); { arrow = decompress_all(compressed_data, TEXTOID, CurrentMemoryContext); } PG_CATCH(); { EmitErrorReport(); elog(PANIC, "bulk decompression failed for data that we've just compressed"); } PG_END_TRY(); decompress_generic_text_check_arrow(arrow, PANIC, results, n); return n; } int decompress_ARRAY_TEXT(const uint8 *Data, size_t Size, bool bulk) { return decompress_generic_text(Data, Size, bulk, COMPRESSION_ALGORITHM_ARRAY); } int decompress_DICTIONARY_TEXT(const uint8 *Data, size_t Size, bool bulk) { return decompress_generic_text(Data, Size, bulk, COMPRESSION_ALGORITHM_DICTIONARY); } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/test_chunk_stats.c��������������������������������������������������0000664�0000000�0000000�00000005202�15100345067�0022153�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include <access/htup_details.h> #include <fmgr.h> #include <utils/timestamp.h> #include "bgw/job.h" #include "bgw_policy/chunk_stats.h" #include "export.h" #include "osm_callbacks.h" TS_FUNCTION_INFO_V1(ts_test_chunk_stats_insert); Datum ts_test_chunk_stats_insert(PG_FUNCTION_ARGS) { int32 job_id = PG_GETARG_INT32(0); int32 chunk_id = PG_GETARG_INT32(1); int32 num_times_run = PG_GETARG_INT32(2); TimestampTz last_time_run = PG_ARGISNULL(3) ? 0 : PG_GETARG_TIMESTAMPTZ(3); BgwPolicyChunkStats stat = { .fd = { .job_id = job_id, .chunk_id = chunk_id, .num_times_job_run = num_times_run, .last_time_job_run = last_time_run, } }; ts_bgw_policy_chunk_stats_insert(&stat); PG_RETURN_NULL(); } typedef int (*chunk_insert_check_hook_type)(Oid, int64, int64); typedef void (*hypertable_drop_hook_type)(const char *, const char *); typedef List *(*hypertable_drop_chunks_hook_type)(Oid, const char *, const char *, int64, int64); static int osm_insert_hook_mock(Oid ht_oid, int64 range_start, int64 range_end) { /* always return true */ elog(NOTICE, "chunk_insert_check_hook"); return 1; } static void osm_ht_drop_hook_mock(const char *schema_name, const char *table_name) { elog(NOTICE, "hypertable_drop_hook"); } static List * osm_ht_drop_chunks_hook_mock(Oid osm_chunk_oid, const char *schema_name, const char *table_name, int64 range_start, int64 range_end) { List *ret = NIL; elog(NOTICE, "hypertable_drop_chunks_hook "); for (int i = 0; i < 2; i++) { char *chunk_name; chunk_name = psprintf("%s%d", "_timescaledb_internal.dummy", i); ret = lappend(ret, chunk_name); } return ret; } OsmCallbacks_Versioned fake_osm_callbacks = { .version_num = 1, .chunk_insert_check_hook = osm_insert_hook_mock, .hypertable_drop_hook = osm_ht_drop_hook_mock, .hypertable_drop_chunks_hook = osm_ht_drop_chunks_hook_mock, }; /* * Dummy function to mock OSM_INSERT hook called at chunk creation for tiered data */ TS_FUNCTION_INFO_V1(ts_setup_osm_hook); Datum ts_setup_osm_hook(PG_FUNCTION_ARGS) { OsmCallbacks_Versioned **ptr = (OsmCallbacks_Versioned **) find_rendezvous_variable("osm_callbacks_versioned"); *ptr = &fake_osm_callbacks; PG_RETURN_NULL(); } TS_FUNCTION_INFO_V1(ts_undo_osm_hook); Datum ts_undo_osm_hook(PG_FUNCTION_ARGS) { OsmCallbacks_Versioned **ptr = (OsmCallbacks_Versioned **) find_rendezvous_variable("osm_callbacks_versioned"); *ptr = NULL; PG_RETURN_NULL(); } ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/test_continuous_agg.c�����������������������������������������������0000664�0000000�0000000�00000004121�15100345067�0022650�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <postgres.h> #include "ts_catalog/continuous_agg.h" #include <test_utils.h> TS_TEST_FN(ts_test_continuous_agg_find_by_view_name) { Oid cagg_relid = PG_GETARG_OID(0); ContinuousAgg *cagg; ContinuousAgg *cagg2; cagg = ts_continuous_agg_find_by_relid(cagg_relid); TestAssertTrue(cagg != NULL); /* Get a cagg by direct view */ cagg2 = ts_continuous_agg_find_by_view_name(NameStr(cagg->data.direct_view_schema), NameStr(cagg->data.direct_view_name), ContinuousAggDirectView); TestAssertTrue(cagg2->data.mat_hypertable_id == cagg->data.mat_hypertable_id); cagg2 = ts_continuous_agg_find_by_view_name(NameStr(cagg->data.direct_view_schema), NameStr(cagg->data.direct_view_name), ContinuousAggAnyView); TestAssertTrue(cagg2->data.mat_hypertable_id == cagg->data.mat_hypertable_id); /* Get a cagg by user view */ cagg2 = ts_continuous_agg_find_by_view_name(NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name), ContinuousAggUserView); TestAssertTrue(cagg2->data.mat_hypertable_id == cagg->data.mat_hypertable_id); cagg2 = ts_continuous_agg_find_by_view_name(NameStr(cagg->data.user_view_schema), NameStr(cagg->data.user_view_name), ContinuousAggAnyView); TestAssertTrue(cagg2->data.mat_hypertable_id == cagg->data.mat_hypertable_id); /* Get a cagg by partial view */ cagg2 = ts_continuous_agg_find_by_view_name(NameStr(cagg->data.partial_view_schema), NameStr(cagg->data.partial_view_name), ContinuousAggPartialView); TestAssertTrue(cagg2->data.mat_hypertable_id == cagg->data.mat_hypertable_id); cagg2 = ts_continuous_agg_find_by_view_name(NameStr(cagg->data.partial_view_schema), NameStr(cagg->data.partial_view_name), ContinuousAggAnyView); TestAssertTrue(cagg2->data.mat_hypertable_id == cagg->data.mat_hypertable_id); PG_RETURN_VOID(); } �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/src/test_merge_chunk.c��������������������������������������������������0000664�0000000�0000000�00000001655�15100345067�0022124�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* * This file and its contents are licensed under the Timescale License. * Please see the included NOTICE for copyright information and * LICENSE-TIMESCALE for a copy of the license. */ #include <string.h> #include <unistd.h> #include <postgres.h> #include <fmgr.h> #include <utils/builtins.h> #include "chunk.h" #include "export.h" TS_FUNCTION_INFO_V1(ts_test_merge_chunks_on_dimension); Datum ts_test_merge_chunks_on_dimension(PG_FUNCTION_ARGS) { Oid chunk_id = PG_ARGISNULL(0) ? InvalidOid : PG_GETARG_OID(0); Oid merge_chunk_id = PG_ARGISNULL(1) ? InvalidOid : PG_GETARG_OID(1); int32 dimension_id = PG_ARGISNULL(2) ? 0 : PG_GETARG_INT32(2); Chunk *chunk = ts_chunk_get_by_relid(chunk_id, true); Chunk *merge_chunk = ts_chunk_get_by_relid(merge_chunk_id, true); Hypertable *ht = ts_hypertable_get_by_id(chunk->fd.hypertable_id); ts_chunk_merge_on_dimension(ht, chunk, merge_chunk, dimension_id); PG_RETURN_VOID(); } �����������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/����������������������������������������������������������������������0000775�0000000�0000000�00000000000�15100345067�0016077�5����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/001_job_crash_log.pl��������������������������������������������������0000664�0000000�0000000�00000004467�15100345067�0021622�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. use strict; use warnings; use TimescaleNode; use Test::More tests => 5; # This test checks that a job crash is reported in the job errors table # (that is, a record gets inserted into the table _timescaledb_internal.job_errors). # We cannot do that with a regression test because the server will not recover after # a crash in that case my $node = TimescaleNode->create('job_crash_log'); # by default PostgresNode doesn't doesn't restart after a crash # taken from 013_crash_restart.pl $node->safe_psql( 'postgres', q[ALTER SYSTEM SET restart_after_crash = 1; ALTER SYSTEM SET log_connections = 1; SELECT pg_reload_conf();]); # create proc to run as job my $query = <<'END_OF_SQL'; CREATE OR REPLACE PROCEDURE custom_proc_sleep60(jobid int, config jsonb) LANGUAGE PLPGSQL AS $$ BEGIN RAISE NOTICE 'im about to sleep for 60 seconds, plenty of time for you to kill me'; perform pg_sleep(60); END $$; END_OF_SQL my $ret = $node->safe_psql('postgres', "$query"); my $query_add = q[select add_job('custom_proc_sleep60', '5 minutes', initial_start => now())]; my $jobid = $node->safe_psql('postgres', "$query_add"); is($jobid, 1000, 'job was added'); my $query_pid_exists = <<"END_OF_QUERY"; select count(*) from pg_stat_activity where application_name like 'User-Defined Action%' and query like '%custom_proc_sleep60%' END_OF_QUERY # select the pid of this job in order to kill it my $query_pid = <<"END_OF_QUERY"; select pid from pg_stat_activity where application_name like 'User-Defined Action%' and query like '%custom_proc_sleep60%' END_OF_QUERY ok($node->poll_query_until('postgres', "$query_pid_exists", '1')); my $pid = $node->safe_psql('postgres', "$query_pid"); isnt($pid, "", "check the pid is not null"); # now kill the one backend my $int_pid = int($pid); kill 9, $int_pid; # Wait till server restarts is($node->poll_query_until('postgres', 'SELECT 1', '1'), 1, "reconnected after SIGQUIT"); my $errlog = $node->safe_psql('postgres', 'select count(*) from _timescaledb_internal.bgw_job_stat_history where job_id = 1000 and succeeded is false' ); is($errlog, "1", "there is a row for the crash in the error log"); done_testing(); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/002_logrepl_decomp_marker.pl������������������������������������������0000664�0000000�0000000�00000040533�15100345067�0023356�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. use strict; use warnings; use TimescaleNode; use Test::More; # This test checks the creation of logical replication messages # used to mark the start and end of activity happening as a result # compression/decompression. # Publishing node my $db = TimescaleNode->create('publisher', allows_streaming => 'logical'); sub run_queries { foreach my $query (@_) { $db->safe_psql('postgres', $query); } } sub query_generates_wal { my $description = shift @_; my $query = shift @_; my $expected_wal = shift @_; $db->safe_psql('postgres', $query); my $result = $db->safe_psql('postgres', qq/SELECT data FROM pg_logical_slot_get_changes('slot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');/ ); # Remove BEGIN/COMMIT from output since there are only single # transactions in the output and the only interesting part from a # testing perspective are the other messages. $result =~ s/^(BEGIN|COMMIT).*\n?//gm; # creation_time is non-deterministic, so strip it from wal (it's # always the final column) $result =~ s/\s+creation_time.*//g; # Strip leading and trailing whitespace $result =~ s/^\s+|\s+$//g; is($result, $expected_wal, $description); } sub discard_wal { $db->safe_psql('postgres', qq/SELECT data FROM pg_logical_slot_get_changes('slot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');/ ); } my $server_version = 0 + $db->safe_psql('postgres', "select current_setting('server_version_num')::int"); # stop background jobs because they can scribble in our WAL run_queries( qq/ SELECT _timescaledb_functions.stop_background_workers(); / ); run_queries( qq/ CREATE TABLE metrics(time timestamptz, device_id bigint, value float8); SELECT create_hypertable('metrics', 'time'); ALTER TABLE metrics REPLICA IDENTITY FULL; ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); SELECT 'init' FROM pg_create_logical_replication_slot('slot', 'test_decoding'); / ); query_generates_wal( "insert into plain chunk", qq/INSERT INTO metrics VALUES ('2023-07-01T00:00:00Z', 1, 1.0);/, qq(table _timescaledb_catalog.dimension_slice: INSERT: id[integer]:1 dimension_id[integer]:1 range_start[bigint]:1687996800000000 range_end[bigint]:1688601600000000 table _timescaledb_catalog.chunk: INSERT: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:null dropped[boolean]:false status[integer]:0 osm_chunk[boolean]:false table _timescaledb_catalog.chunk_constraint: INSERT: chunk_id[integer]:1 dimension_slice_id[integer]:1 constraint_name[name]:'constraint_1' hypertable_constraint_name[name]:null table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:1) ); query_generates_wal( "compress chunk", qq(SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(message: transactional: 1 prefix: ::timescaledb-compression-start, sz: 0 content: table _timescaledb_catalog.chunk: INSERT: id[integer]:2 hypertable_id[integer]:2 schema_name[name]:'_timescaledb_internal' table_name[name]:'compress_hyper_2_2_chunk' compressed_chunk_id[integer]:null dropped[boolean]:false status[integer]:0 osm_chunk[boolean]:false table _timescaledb_catalog.compression_settings: INSERT: relid[regclass]:'_timescaledb_internal._hyper_1_1_chunk' compress_relid[regclass]:'_timescaledb_internal.compress_hyper_2_2_chunk' segmentby[text[]]:'{device_id}' orderby[text[]]:'{time}' orderby_desc[boolean[]]:'{f}' orderby_nullsfirst[boolean[]]:'{f}' index[jsonb]:'[{"type": "minmax", "column": "time", "source": "orderby"}]' table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:2 dropped[boolean]:false status[integer]:1 osm_chunk[boolean]:false table _timescaledb_internal.compress_hyper_2_2_chunk: INSERT: _ts_meta_count[integer]:1 device_id[bigint]:1 _ts_meta_min_1[timestamp with time zone]:'2023-06-30 17:00:00-07' _ts_meta_max_1[timestamp with time zone]:'2023-06-30 17:00:00-07' "time"[_timescaledb_internal.compressed_data]:'BAAAAqJgYhxAAAAComBiHEAAAAAAAQAAAAEAAAAAAAAADgAFRMDEOIAA' value[_timescaledb_internal.compressed_data]:'AwA/8AAAAAAAAAAAAAEAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAEAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAEGAAAAAAAAAAIAAAABAAAAAQAAAAAAAAAEAAAAAAAAAAoAAAABCgAAAAAAAAP/' table _timescaledb_catalog.compression_chunk_size: INSERT: chunk_id[integer]:1 compressed_chunk_id[integer]:2 uncompressed_heap_size[bigint]:8192 uncompressed_toast_size[bigint]:0 uncompressed_index_size[bigint]:16384 compressed_heap_size[bigint]:16384 compressed_toast_size[bigint]:8192 compressed_index_size[bigint]:16384 numrows_pre_compression[bigint]:1 numrows_post_compression[bigint]:1 numrows_frozen_immediately[bigint]:1 message: transactional: 1 prefix: ::timescaledb-compression-end, sz: 0 content:) ); query_generates_wal( "decompress chunk", qq(SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(message: transactional: 1 prefix: ::timescaledb-decompression-start, sz: 0 content: table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_catalog.compression_chunk_size: DELETE: chunk_id[integer]:1 table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:null dropped[boolean]:false status[integer]:0 osm_chunk[boolean]:false table _timescaledb_catalog.compression_settings: DELETE: relid[regclass]:'_timescaledb_internal._hyper_1_1_chunk' table _timescaledb_catalog.chunk: DELETE: id[integer]:2 message: transactional: 1 prefix: ::timescaledb-decompression-end, sz: 0 content:) ); run_queries( qq(SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);) ); discard_wal(); query_generates_wal( "recompress chunk (NOOP)", qq(SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(message: transactional: 1 prefix: ::timescaledb-compression-start, sz: 0 content: message: transactional: 1 prefix: ::timescaledb-compression-end, sz: 0 content:), ); query_generates_wal( "insert into uncompressed chunk", qq(INSERT INTO metrics VALUES ('2023-07-01T01:00:00Z', 1, 1.0);), qq(table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 18:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:3 dropped[boolean]:false status[integer]:9 osm_chunk[boolean]:false), ); query_generates_wal( "recompress chunk", qq(SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(message: transactional: 1 prefix: ::timescaledb-compression-start, sz: 0 content: table _timescaledb_internal._hyper_1_1_chunk: DELETE: "time"[timestamp with time zone]:'2023-06-30 18:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_internal.compress_hyper_2_3_chunk: INSERT: _ts_meta_count[integer]:1 device_id[bigint]:1 _ts_meta_min_1[timestamp with time zone]:'2023-06-30 18:00:00-07' _ts_meta_max_1[timestamp with time zone]:'2023-06-30 18:00:00-07' "time"[_timescaledb_internal.compressed_data]:'BAAAAqJhOK/kAAAComE4r+QAAAAAAQAAAAEAAAAAAAAADgAFRMJxX8gA' value[_timescaledb_internal.compressed_data]:'AwA/8AAAAAAAAAAAAAEAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAEAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAEGAAAAAAAAAAIAAAABAAAAAQAAAAAAAAAEAAAAAAAAAAoAAAABCgAAAAAAAAP/' table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:3 dropped[boolean]:false status[integer]:1 osm_chunk[boolean]:false message: transactional: 1 prefix: ::timescaledb-compression-end, sz: 0 content:) ); query_generates_wal( "insert into uncompressed chunk 2", qq(INSERT INTO metrics VALUES ('2023-07-01T02:00:00Z', 1, 1.0);), qq(table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 19:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:3 dropped[boolean]:false status[integer]:9 osm_chunk[boolean]:false), ); query_generates_wal( "update rows in uncompressed and compressed chunk", qq(UPDATE metrics SET value = 22 WHERE time IN ('2023-07-01T00:00:00Z', '2023-07-01T02:00:00Z');), qq(message: transactional: 1 prefix: ::timescaledb-decompression-start, sz: 0 content: table _timescaledb_internal.compress_hyper_2_3_chunk: DELETE: (no-tuple-data) table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:1 message: transactional: 1 prefix: ::timescaledb-decompression-end, sz: 0 content: message: transactional: 1 prefix: ::timescaledb-decompression-start, sz: 0 content: table _timescaledb_internal.compress_hyper_2_3_chunk: DELETE: (no-tuple-data) table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 18:00:00-07' device_id[bigint]:1 value[double precision]:1 message: transactional: 1 prefix: ::timescaledb-decompression-end, sz: 0 content: table _timescaledb_internal._hyper_1_1_chunk: UPDATE: old-key: "time"[timestamp with time zone]:'2023-06-30 19:00:00-07' device_id[bigint]:1 value[double precision]:1 new-tuple: "time"[timestamp with time zone]:'2023-06-30 19:00:00-07' device_id[bigint]:1 value[double precision]:22 table _timescaledb_internal._hyper_1_1_chunk: UPDATE: old-key: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:1 new-tuple: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:22), ); query_generates_wal( "compress chunk after update", qq(SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(message: transactional: 1 prefix: ::timescaledb-compression-start, sz: 0 content: table _timescaledb_internal._hyper_1_1_chunk: DELETE: "time"[timestamp with time zone]:'2023-06-30 18:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_internal._hyper_1_1_chunk: DELETE: "time"[timestamp with time zone]:'2023-06-30 19:00:00-07' device_id[bigint]:1 value[double precision]:22 table _timescaledb_internal._hyper_1_1_chunk: DELETE: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:22 table _timescaledb_internal.compress_hyper_2_3_chunk: INSERT: _ts_meta_count[integer]:3 device_id[bigint]:1 _ts_meta_min_1[timestamp with time zone]:'2023-06-30 17:00:00-07' _ts_meta_max_1[timestamp with time zone]:'2023-06-30 19:00:00-07' "time"[_timescaledb_internal.compressed_data]:'BAAAAqJiD0OIAAAAAADWk6QAAAAAAwAAAAMAAAAAAAAB7gAFRMDEOIAAAAVEvxcRN/8AAAAAAAAAAA==' value[_timescaledb_internal.compressed_data]:'AwBANgAAAAAAAAAAAAMAAAABAAAAAAAAAAEAAAAAAAAABwAAAAMAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAEGAAAAAAAAAAEAAAABAAAAAQAAAAAAAAAEAAAAAAAAAA4AAAABKgAAA/4/+OAb' table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:3 dropped[boolean]:false status[integer]:1 osm_chunk[boolean]:false message: transactional: 1 prefix: ::timescaledb-compression-end, sz: 0 content:) ); query_generates_wal( "insert into uncompressed chunk 3", qq(INSERT INTO metrics VALUES ('2023-07-01T03:00:00Z', 1, 1.0);), qq(table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 20:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:3 dropped[boolean]:false status[integer]:9 osm_chunk[boolean]:false), ); query_generates_wal( "delete row in compressed chunk", qq(DELETE FROM metrics WHERE time IN ('2023-07-01T00:00:00Z', '2023-07-01T03:00:00Z');), qq(message: transactional: 1 prefix: ::timescaledb-decompression-start, sz: 0 content: table _timescaledb_internal.compress_hyper_2_3_chunk: DELETE: (no-tuple-data) table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:22 table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 18:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 19:00:00-07' device_id[bigint]:1 value[double precision]:22 message: transactional: 1 prefix: ::timescaledb-decompression-end, sz: 0 content: table _timescaledb_internal._hyper_1_1_chunk: DELETE: "time"[timestamp with time zone]:'2023-06-30 20:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_internal._hyper_1_1_chunk: DELETE: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:22) ); # switch to PK on time for insert with PK decompression test run_queries( qq/ SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'); DELETE FROM metrics; ALTER TABLE metrics SET (timescaledb.compress = false); ALTER TABLE metrics REPLICA IDENTITY DEFAULT; ALTER TABLE metrics ADD PRIMARY KEY (time); ALTER TABLE metrics SET (timescaledb.compress = true, timescaledb.compress_orderby = 'time', timescaledb.compress_segmentby = 'device_id'); INSERT INTO metrics VALUES('2023-07-01T00:00:00Z', 1, 1.0), ('2023-07-01T12:00:00Z', 1, 2.0); SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'); / ); discard_wal(); query_generates_wal( "insert into compressed chunk with pk forces decompression", qq/INSERT INTO metrics VALUES ('2023-07-01 00:00:00Z', 1, 5555) ON CONFLICT DO NOTHING;/, qq/table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:4 dropped[boolean]:false status[integer]:9 osm_chunk[boolean]:false/ ); # Disable marker generation through GUC $db->append_conf('postgresql.conf', 'timescaledb.enable_compression_wal_markers=false'); $db->reload(); query_generates_wal( "compress chunk after disabling markers", qq(SELECT compress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:4 dropped[boolean]:false status[integer]:1 osm_chunk[boolean]:false) ); query_generates_wal( "decompress chunk after disabling markers", qq(SELECT decompress_chunk('_timescaledb_internal._hyper_1_1_chunk'::regclass, TRUE);), qq(table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-06-30 17:00:00-07' device_id[bigint]:1 value[double precision]:1 table _timescaledb_internal._hyper_1_1_chunk: INSERT: "time"[timestamp with time zone]:'2023-07-01 05:00:00-07' device_id[bigint]:1 value[double precision]:2 table _timescaledb_catalog.compression_chunk_size: DELETE: chunk_id[integer]:1 table _timescaledb_catalog.chunk: UPDATE: id[integer]:1 hypertable_id[integer]:1 schema_name[name]:'_timescaledb_internal' table_name[name]:'_hyper_1_1_chunk' compressed_chunk_id[integer]:null dropped[boolean]:false status[integer]:0 osm_chunk[boolean]:false table _timescaledb_catalog.compression_settings: DELETE: relid[regclass]:'_timescaledb_internal._hyper_1_1_chunk' table _timescaledb_catalog.chunk: DELETE: id[integer]:4) ); # re-enable background jobs run_queries( qq/ SELECT public.alter_job(id::integer, scheduled=>true) FROM _timescaledb_config.bgw_job; / ); pass(); done_testing(); ���������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/003_mvcc_cagg.pl������������������������������������������������������0000664�0000000�0000000�00000011303�15100345067�0020725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # This TAP test tests the MVCC behavior of the watermark function of the CAGGs # It creates a hypertable, a CAGG, and a refresh policy. Afterward, it inserts # into the hypertable and checks that all workers of a parallel query see the same # watermark. use strict; use warnings; use TimescaleNode; use Data::Dumper; use Test::More tests => 5; # See debug output in 'tsl/test/tmp_check/log/regress_log_008_mvcc_cagg' my $debug = 0; # Should be enabled as soon as _timescaledb_functions.cagg_watermark is declared as parallel safe my $check_for_parallel_plan = 0; my $timescale_node = TimescaleNode->create('insert'); # Test 1 - Create table my $result = $timescale_node->safe_psql( 'postgres', q{ CREATE TABLE adapter_metrics ( time timestamptz NOT NULL, adapter_token text NOT NULL, dyno text NOT NULL, queue text NOT NULL, value double precision NOT NULL); } ); is($result, '', 'create table'); # Test 2 - Convert to hypertable $result = $timescale_node->safe_psql( 'postgres', q{ SELECT FROM create_hypertable('adapter_metrics','time', chunk_time_interval => INTERVAL '5 seconds'); } ); is($result, '', 'create hypertable'); # Test 3 - Create CAGG $result = $timescale_node->safe_psql( 'postgres', q{ CREATE MATERIALIZED VIEW adapter_metrics_rollup WITH (timescaledb.continuous, timescaledb.materialized_only=false) AS SELECT time_bucket('00:00:05'::interval, adapter_metrics.time) AS bucket, avg(adapter_metrics.value) AS avg_value, max(adapter_metrics.value) AS max_value, count(*) AS count FROM adapter_metrics GROUP BY time_bucket('00:00:05'::interval, adapter_metrics.time) WITH DATA; } ); is($result, '', 'crete cagg'); # Test 4 - Create CAGG policy $result = $timescale_node->safe_psql( 'postgres', q{ SELECT add_continuous_aggregate_policy('adapter_metrics_rollup', start_offset => INTERVAL '20 seconds', end_offset => NULL, schedule_interval => INTERVAL '1 seconds'); } ); is($result, '1000', 'job id of the cagg'); # Test 5 - Test consistent CAGG watermarks for (my $iteration = 0; $iteration < 10; $iteration++) { # Insert data $timescale_node->safe_psql( 'postgres', q{ INSERT INTO adapter_metrics SELECT now(), random()::text AS dyno, random()::text AS queue, random()::text AS adapter_token, value FROM generate_series(1, 100, 1) AS g2(value); } ); # Perform selects while the CAGG update is running for (my $query = 0; $query < 10; $query++) { # Encourage the use of parallel workers my $sql = q{ SELECT set_config(CASE WHEN current_setting('server_version_num')::int < 160000 THEN 'force_parallel_mode' ELSE 'debug_parallel_query' END,'on', false); SET enable_bitmapscan = 0; SET parallel_setup_cost = 0; SET parallel_tuple_cost = 0; SET parallel_tuple_cost = 0; SET client_min_messages TO DEBUG5; SELECT * FROM adapter_metrics_rollup WHERE adapter_metrics_rollup.bucket > now() - INTERVAL '30 seconds'; }; my ($stdout, $stderr); if ($debug == 1) { print "===== New query\n"; } # To be able to access stderr, use psql instead of safe_psql $timescale_node->psql( 'postgres', $sql, stdout => \$stdout, stderr => \$stderr, on_error_die => 1, on_error_stop => 1); # Ensure all parallel workers have seen the same watermark my @log_lines = split "\n", $stderr; my $seen_watermarks = 0; my $cagg_id = -1; my $watermark = -1; # Check that all workers have seen the same watermark foreach (@log_lines) { if (/watermark for continuous aggregate .+'(\d+)' is: (\d+)/) { my $current_cagg = $1; my $current_watermark = $2; if ($debug == 1) { print $_ . "\n"; } if ($watermark == -1) { $watermark = $current_watermark; $cagg_id = $current_cagg; } elsif ($watermark != $current_watermark) { diag( "Some workers have read the watermark $watermark, one worker read the watermark $current_watermark\n" ); fail(); BAIL_OUT(); } elsif ($cagg_id != $current_cagg) { diag( "Got watermarks for different CAGGs, this test can not handle this ($cagg_id / $current_cagg)\n" ); fail(); BAIL_OUT(); } $seen_watermarks++; } } if ($check_for_parallel_plan == 1 && $seen_watermarks < 2) { diag( "Got watermark only from one worker, was a parallel plan used?" ); fail(); BAIL_OUT(); } } } # No errors before? Let test 5 pass pass(); done_testing(); 1; �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/004_truncate_or_delete_spin_lock.pl�����������������������������������0000664�0000000�0000000�00000013016�15100345067�0024730�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # This TAP test verifies the spin lock behaviour when the `timescaledb.compress_truncate_behaviour` GUC is set to `truncate_or_delete` # The order of operations tested are the same as the `compression_freeze` isolation test for this GUC behaviour, except session 2 starts a transaction rather than using debug_waitpoints # This ensures that we can actually test the spin lock use strict; use warnings; use TimescaleNode; use Data::Dumper; use Test::More; # Test setup # Create node with timescaledb my $node = TimescaleNode->create('node'); # Create table my $result = $node->safe_psql( 'postgres', q{ CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null); } ); # Create hypertable $result = $node->safe_psql( 'postgres', q{ SELECT table_name FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '1 month'); } ); is($result, 'sensor_data', 'create hypertable'); # Insert data $result = $node->safe_psql( 'postgres', q{ INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-14', INTERVAL '1 hour') AS g1(time), generate_series(1, 50, 1) AS g2(sensor_id) ORDER BY time; } ); # Define count query my $count_query = "SELECT count(*) FROM sensor_data;"; # Define compression query my $compress_query = "SELECT count(*) FROM (SELECT compress_chunk(show_chunks('sensor_data')));"; # Count inserted rows my $num_rows = $node->safe_psql('postgres', $count_query); is($num_rows, 15650, 'validate inserted rows'); # Enable compression $result = $node->safe_psql( 'postgres', q{ ALTER TABLE sensor_data SET (timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id'); } ); # Get number of chunks my $n_chunks = $node->safe_psql( 'postgres', q{ SELECT count(*) FROM show_chunks('sensor_data'); }); # Create psql sessions my $s1 = $node->background_psql('postgres'); my $s2 = $node->background_psql('postgres'); # SET session 1 behaviour to `truncate_or_delete` $result = $s1->query_safe( "SET timescaledb.compress_truncate_behaviour TO truncate_or_delete;"); # Run tests # TEST 1: # Session 1 tries to truncate at the end of compression, but is blocked by session 2 # After the spin lock timeout is exceeded it falls back to delete instead # Begin txns in both sessions $result = $s1->query_safe("BEGIN"); $result = $s2->query_safe("BEGIN"); # The aggregation query takes an AccessShareLock on the chunk, preventing truncate $result = $s2->query_safe($count_query); is($result, $num_rows, "session 2: validate row count"); # Compress the chunk # This tries and fails to acquire an AccessExclusiveLock on the table # so after the spin-lock timeout it falls back to doing a delete $result = $s1->query_safe($compress_query); is($result, 1, "session 1: compress chunk"); $result = $s1->query_safe( "SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2;" ); my $expected = "Compressed|1"; is($result, $expected, "verify chunks are compressed"); $result = $node->safe_psql('postgres', $count_query); is($result, $num_rows, "session 2: validate row count again"); $result = $s2->query_safe("COMMIT"); # No AccessExclusiveLock on the uncompressed chunk $result = $s1->query_safe( "SELECT relation::regclass::text FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' AND locktype = 'relation' AND mode = 'AccessExclusiveLock' ORDER BY relation, locktype;" ); $expected = "_timescaledb_internal.compress_hyper_2_2_chunk"; is($result, $expected, "verify AccessExclusiveLock was not taken"); $result = $s1->query_safe("ROLLBACK"); ########################################################################## # TEST 2: # Session 1 is blocked by session 2 but session 2 commits before the spin-lock timeout is exceeded so session 1 truncates # Begin txns in both sessions $result = $s1->query_safe("BEGIN"); $result = $s2->query_safe("BEGIN"); $result = $s2->query_safe($count_query); is($result, $num_rows, "session 2: validate row count"); # We have to use 'query_until('', ...)' so that the test immediately fires the next query # Otherwise s1 times out and performs a delete $s1->query_until('', $compress_query); # Session 2 immediately commits, releasing the AccessShareLock on the table $result = $s2->query_safe("COMMIT"); # The result from the previous query_until() is returned with the next query # so perform a dummy query on s1 to discard the result # There might be a better way of doing this... $s1->query_safe("SELECT 1"); $result = $s1->query_safe( "SELECT compression_status, count(*) FROM chunk_compression_stats('sensor_data') GROUP BY 1 ORDER BY 1, 2;" ); is($result, 'Compressed|1', "verify chunks are compressed"); # AccessExclusiveLock taken on the uncompressed chunk $result = $s1->query_safe( "SELECT relation::regclass::text FROM pg_locks WHERE granted AND relation::regclass::text LIKE '%hyper%chunk' AND locktype = 'relation' AND mode = 'AccessExclusiveLock' ORDER BY relation, locktype;" ); $expected = "_timescaledb_internal._hyper_1_1_chunk _timescaledb_internal.compress_hyper_2_3_chunk"; is($result, $expected, "verify AccessExclusiveLock was taken"); $result = $s1->query_safe("ROLLBACK"); $s1->quit(); $s2->quit(); done_testing(); ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/005_recompression_spin_lock_test.pl�����������������������������������0000664�0000000�0000000�00000012261�15100345067�0025012�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# This file and its contents are licensed under the Timescale License. # Please see the included NOTICE for copyright information and # LICENSE-TIMESCALE for a copy of the license. # This TAP test verifies the behavior when recompression is attempted on a chunk # with unique constraints while concurrent DML is happening use strict; use warnings; use TimescaleNode; use Data::Dumper; use Test::More; # Test setup my $node = TimescaleNode->create('node'); # Create table with a unique constraint my $result = $node->safe_psql( 'postgres', q{ CREATE TABLE sensor_data ( time timestamptz not null, sensor_id integer not null, cpu double precision null, temperature double precision null, UNIQUE(time, sensor_id) ); } ); is($result, '', 'create table with unique constraint'); # Create hypertable $result = $node->safe_psql( 'postgres', q{ SELECT table_name FROM create_hypertable('sensor_data','time', chunk_time_interval => INTERVAL '1 month'); } ); is($result, 'sensor_data', 'create hypertable'); # Insert data $result = $node->safe_psql( 'postgres', q{ INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01-07', INTERVAL '1 hour') AS g1(time), generate_series(1, 50, 1) AS g2(sensor_id) ORDER BY time; } ); is($result, '', 'insert data'); # Define count query my $count_query = "SELECT count(*) FROM sensor_data;"; # Count inserted rows my $num_rows = $node->safe_psql('postgres', $count_query); is($num_rows, 7250, 'validate inserted rows'); # Enable compression $result = $node->safe_psql( 'postgres', q{ ALTER TABLE sensor_data SET ( timescaledb.compress, timescaledb.compress_segmentby = 'sensor_id', timescaledb.compress_orderby = 'time' ); } ); is($result, '', 'enable compression'); # Compress the chunk my $compress_query = "SELECT count(*) FROM (SELECT compress_chunk(show_chunks('sensor_data')));"; $result = $node->safe_psql('postgres', $compress_query); is($result, '1', 'compress chunk'); # Insert more data to make the chunk partial $result = $node->safe_psql( 'postgres', q{ INSERT INTO sensor_data SELECT time + (INTERVAL '1 minute' * random()) AS time, sensor_id, random() AS cpu, random()* 100 AS temperature FROM generate_series('2022-01-01', '2022-01--7', INTERVAL '1 hour') AS g1(time), generate_series(51, 55, 1) AS g2(sensor_id) ORDER BY time; } ); is($result, '', 'insert more data to make the chunk partial'); # Create psql sessions my $s1 = $node->background_psql('postgres'); my $s2 = $node->background_psql('postgres'); my $s3 = $node->background_psql('postgres'); # Enable segmentwise recompression $s1->query_safe("SET timescaledb.enable_segmentwise_recompression TO on;"); # Enable waiting to acquire an exclusive lock $s1->query_safe("SET timescaledb.enable_recompress_waiting TO on;"); # TEST 1: # Session 1 tries to acquire an exclusive lock at the end of recompression but is blocked due to the inserts by Session 2 # We use session 3 to set up debug waitpoints # Begin txns in all sessions $s1->query_safe("BEGIN;"); $s2->query_safe("BEGIN;"); $s3->query_safe("BEGIN;"); # We enable the debug_waitpoint after the latch and release it after s2 aborts # This allows s1 to successfully acquire the lock the second time around $s3->query_safe( "SELECT debug_waitpoint_enable('chunk_recompress_after_latch');"); # Get lock data $result = $node->safe_psql('postgres', "SELECT relation::regclass::text, mode FROM pg_locks WHERE relation::regclass::text LIKE '%hyper_1_%chunk' and granted;" ); is($result, '', "verify no locks exist on the chunk"); # Session 2: Insert rows into the chunk # This blocks until session 2 releases its locks $s2->query_until( '', q{ INSERT INTO sensor_data VALUES ('2022-01-05 12:00:00', 100, 0.5, 25.5), ('2022-01-05 13:00:00', 101, 0.6, 26.5); }); # We have to use 'query_until('', ...)' so that the test immediately fires the next query $s1->query_until( '', q{ SELECT compress_chunk(show_chunks('sensor_data')); }); # Session 2 immediately aborts, releasing the RowExclusiveLock on the table $s2->query_safe("ABORT"); # Release the debug waitpoint so that recompression succeeds $s3->query_safe( "SELECT debug_waitpoint_release('chunk_recompress_after_latch');"); # Verify ExclusiveLock on uncompressed chunk $result = $node->safe_psql('postgres', "SELECT relation::regclass::text FROM pg_locks WHERE relation::regclass::text LIKE '%hyper_1_%chunk' AND granted AND mode = 'ExclusiveLock';" ); is( $result, '_timescaledb_internal._hyper_1_1_chunk', "verify ExclusiveLock on uncompressed chunk"); # Verify AccessShareLock on compressed chunk $result = $node->safe_psql('postgres', "SELECT relation::regclass::text FROM pg_locks WHERE relation::regclass::text LIKE '%hyper_1_%chunk' AND granted AND mode = 'AccessShareLock'" ); is( $result, "_timescaledb_internal._hyper_1_1_chunk", "verify AccessShareLock on internal compressed chunk"); # Clean up $s1->query_safe("ROLLBACK;"); $s3->query_safe("ROLLBACK;"); $s3->quit(); $s2->quit(); $s1->quit(); done_testing(); �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/tsl/test/t/CMakeLists.txt��������������������������������������������������������0000664�0000000�0000000�00000001352�15100345067�0020640�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������set(PROVE_TEST_FILES 001_job_crash_log.pl 002_logrepl_decomp_marker.pl) set(PROVE_DEBUG_TEST_FILES 003_mvcc_cagg.pl) # The API for PostgreSQL::Cluster::BackgroundPsql was changed in PG16. We only # use the new version of the API, so run TAP tests that use it only on later # versions. if((${PG_VERSION_MAJOR} GREATER_EQUAL "16")) list(APPEND PROVE_TEST_FILES 004_truncate_or_delete_spin_lock.pl) list(APPEND PROVE_DEBUG_TEST_FILES 005_recompression_spin_lock_test.pl) endif() if(CMAKE_BUILD_TYPE MATCHES Debug) list(APPEND PROVE_TEST_FILES ${PROVE_DEBUG_TEST_FILES}) endif(CMAKE_BUILD_TYPE MATCHES Debug) foreach(P_FILE ${PROVE_TEST_FILES}) configure_file(${P_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${P_FILE} COPYONLY) endforeach(P_FILE) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������timescaledb-2.23.0/version.config�������������������������������������������������������������������0000664�0000000�0000000�00000000053�15100345067�0016725�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������version = 2.23.0 previous_version = 2.22.1 �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������